Как обойти капчу питон

Как байпасить reCaptcha V3 с помощью Selenium Python?

Мы будем использовать библиотеку python Selenium для байпаса google reCaptcha v3. Следуйте пошаговой инструкции, чтобы получить результат.

Для примера мы будем использовать демо-версию Google reCaptcha api.

Сначала необходимо отключить настройку защиты контента в браузере Chrome.

Для этого зайдите в Настройки в Chrome. И напишите «настройки сайта» в строке поиска.

Перейдите в настройки сайта и найдите «Защищенный контент».

Перейдите к защищенному контенту и отключите его.

Теперь перейдем к части кодирования.

Установите библиотеку Beautiful Soup для скрипта.

Откройте файл-скрипт и импортируйте в него упомянутые библиотеки.

Установите «delayTime» и «audioToTextDelay» в соответствии с вашей скоростью интернета. Установленные значения работают для всех.

Остальная часть кода приведена ниже. Теперь я объясню, как это работает.

Когда скрипт запускается, проверяется поле I’m not a robot.

И дальше все появляется (как обычно).

После по скрипту выбирается кнопка аудио внизу слева.

И появляется вот это. После этого загружается аудио с именем «1.mp3».

Это займет несколько секунд, не волнуйтесь. После этого в браузере откроется новая вкладка, которая перейдет от речи watson к конвертеру в текст и загрузит файл.

Как видите, аудиофайл преобразуется в текст. Он копирует текст и вставляет его в текстовое поле.

И далее нажимается кнопка «Проверить».

Вот, смотрите. Проблема решена. Если у вас есть какие-либо проблемы и вопросы, пишите. Я отвечу на них как только смогу.

Всех читателей нашего блога приглашаем ознакомиться с курсами по тестированию от OTUS.

Источник

Как обойти капчу: нейросеть на Tensorflow,Keras,python v числовая зашумленная капча

Тема капч не нова, в том числе для Хабра. Тем не менее, алгоритмы капч меняются, как и алгоритмы их решения. Поэтому, предлагается помянуть старое и прооперировать следующий вариант капчи:

попутно понять работу простой нейросети на практике, а также улучшить ее результаты.

Сразу оговоримся, что не будем погружаться в размышления о том, как работает нейрон и что с этим всем делать, статья не претендует на научность, а только предоставляет небольшой туториал.

Плясать от печки. Вместо вступления

Возможно повторятся чьи-то слова, но большинство книг по Deep Learning действительно начинаются с того, что читателю предлагаются заранее заготовленные данные, с которыми он начинает работать. Как-то MNIST — 60 000 рукописных цифр, CIFAR-10 и т.п. После прочтения человек выходит подготовленным… к этим наборам данных. Совершенно не ясно, как использовать свои данные и главное, как что-то улучшить при построении своей собственной нейросети.

Поэтому очень кстати вышла статья на pyimagesearch.com о том как работать со своими собственными данными, а также ее перевод.

Но, как говорится, хрен редьки не слаще: даже с переводом разжеваной статьи по keras осталось много слепых мест. Опять же предлагается заранее подготовленный датасет, только уже с котами, собаками и пандами. Придется заполнить пустоты самостоятельно.
Однако за базу будет взята эта статья и код.

Собираем данные по капчам

Поэтому вот код ножа на python — скачать. (для Windows. Предварительно создать папки C:\1\test и C:\1\test-out).
На выходе получится свалка из цифр от 1 до 9 (нулей в капче нет).
Далее надо разобрать этот завал из цифр по папкам от 1 до 9 и разложить в каждую папку по соответствующей цифре. Так себе занятие. Но за день можно разобрать до 1000 цифр.

Если при выборе цифры возникает сомнение какая из цифр, лучше удалить этот образец. И ничего страшного если цифры будут зашумлены или неполностью входить в «кадр»:

Набрать в каждую папку надо штук по 200 образцов каждой цифры. Можно эту работу поручить сторонним сервисам, но лучше сделать все самим, чтобы потом не искать неправильно соотнесенные цифры.

Нейросеть. Тестовая

Тятя, тятя, наши сети притащили мертвеца

Перед тем как начать работать с собственными данными лучше пройтись по вышеуказанной статье и запустить код, чтобы понять, что все компоненты (keras, tensorflow и т.п.) установлены и работают корректно.

Будем использовать простую сеть, синтаксис запуска которой из командной (!) строки:

*Tensorflow может писать при работе об ошибках в собственных файлах и устаревших методах, можно это исправить руками, а можно просто игнорировать.

Главное, чтобы на выходе после отработки программы в папке проекта output появились два файла: simple_nn_lb.pickle и simple_nn.model, а на экран будет выведено изображение животного с надписью и процентом распознавания, например:

Нейросеть — собственные данные

Теперь, когда тест работоспособности сети проверен, можно подключить собственные данные и начать обучать сеть.

Поместим в папку dat папки с цифрами, содержащими отобранные образцы по каждой цифре.
Папку dat для удобства разместим в папке с проектом (например рядом c папкой animals).
Теперь синтаксис запуска обучения сети будет таким:

Однако пока рано запускать обучение.

Необходимо поправить файл train_simple_nn.py.

1. В самый конец файла:

Это добавит информативности.

Здесь мы изменяем размер входной картинки. Почему именно такой размер? Потому как большинство из нарезанных цифр имеют такой размер либо приводятся к нему. Если масштабировать до 32×32 пикселя, картинка будет искажена. Да и зачем это делать?

Кроме того, загоняем это изменение в try:

Т.к. некоторые картинки программа не может переварить и выдает None, поэтому они пропускаются.

3.Теперь самое важное. Там где комментарий в коде

определим архитектуру 3072-1024-512-3 с помощью Keras

Архитектура сети в статье определена как 3072-1024-512-3. Это означает, что сеть получает на вход 3072 (32 пикселя * 32 пикселя * 3), далее слой 1024, слой 512 и на выходе 3 варианта — кот, собака или панда.

В нашем случае вход 1776 (16 пикселей*37 пикселей*3), далее слой 1024, слой 512, на выходе 9 вариантов цифр.

*9 выходов дополнительно указывать не нужно, т.к. программа сама определяет количество выходов по количеству папок в датасете.

Запускаем

Так как картинки с цифрами маленькие, сеть обучается очень быстро (5-10 мин) даже на слабом железе, используя только CPU.

После прогона программы в командой строке посмотрим результаты:

Это означает, что на обучающем наборе достигнута верность — 82,19%, на контрольном — 75,6 % и на тестовом — 75,59 %.

Нам надо ориентироваться на последний показатель большей частью. Почему остальные также важны будет пояснено далее.

Посмотрим также графическую часть работы нейросети. Она в папке output проекта simple_nn_plot.png:

Быстрее, выше, сильнее. Улучшаем результаты

Совсем коротко о настройке нейросети можно посмотреть здесь.

Вариант подлиннее следующий.

Добавим эпох.
В коде меняем

Увеличим «количество раз», которое сеть пройдет обучение.

Таким образом, 93,5%, 92,6%, 92,6%.

Здесь заметно, что синяя и красные линии после 130 эпохи начинают разъезжаться друг от друга и это говорит, что дальнейшее увеличение числа эпох ничего не даст. Проверим это.

Что ж, увеличение числа эпох, явно пошло сети на пользу. Однако этот результат обманчив.

Проверим работу сети на реальном примере.

Для этих целей в папке проекта есть скрипт predict.py. Перед запуском подготовимся.

В папку images проекта положим файлы с изображениями цифр с капчи, ранее не попадавшиеся сети в процессе обучения. Т.е. надо взять цифры не из набора датасета dat.

В самом файле поправим две строки для размера изображений по умолчанию:

Запускаем из коммандной строки:

Однако не со всеми зашумленными цифрами работает:

Что здесь можно сделать?

Попробуем другие методы

Как видно из последнего графика, синяя и красная линии расходятся примерно на 130 эпохе. Это означает, что, обучение после 130 эпохи неэффективно. Зафиксируем результат на 130 эпохе: 89,3%,88%,88% и посмотрим, работают ли другие методы улучшения работы сети.

Снизим скорость обучения.

Дабавим дополнительный скрытый слой.

Однако, если увеличить количество эпох до 250:
84%,83%,83%

При этом красная и синяя линия не отрываются друг от друга после 130 эпохи:

Сохраним 250 эпох и применим прореживание:

Между слоями вставим прореживание:

Первое значение ниже остальных, это говорит о том, что сеть не обучается. Для этого рекомендуют увеличить количество эпох.

С 1 дополнительным слоем, прореживанием и 500 эпохами:

Несмотря на более низкий процент по сравнению с простым увеличением эпох до 500, график выглядит более ровным:

И сеть обрабатывает изображения, которые ранее выпадали:

Соберем теперь все в один файл, который нарежет изображение с капчей на входе на 5 цифр, прогонит каждую цифру через нейросеть и выдаст результат в интерпретатор python.

Здесь попроще. В файл, который нарезал нам цифры из капчи добавим файл, который занимается предсказаниями.

Теперь программа не только нарежет капчу на 5 частей, но и выведет все распознанные цифры в интерпретатор:

Опять же надо иметь в виду, что программа не дает 100% результата и зачастую одна из 5 цифр неверна. Но и это неплохой результат, если учесть, что в обучающем наборе всего по 170-200 экземпляров для каждого числа.

Распознавание капчи длится 3-5 сек на компьютере средней мощности.

Как еще можно попытаться улучшить работу сети можно почитать в книге «Библиотека Keras — инструмент глубокого обучения» А. Джулли, С.Пала.

Итоговый скрипт, который режет капчу и распознает — здесь.
Запускается без параметров.
Переработанные скрипты для тренировки и теста сети.
Капчи для теста, в том числе с ложным срабатыванием — здесь.
Модель для работы — здесь.
Цифры, разложенные по папкам — здесь.

Источник

Распознавание капчи Python: готовые проекты и примеры реализации

Автоматическое распознавание капчи может потребоваться в разных ситуациях. В основном такие манипуляции с капчей организовывают, используя искусственный интеллект и нейронные сети. Как многие знают, при работе с нейронными сетями и искусственным интеллектом используются разные языки программирования, но чаще все го применяется Python, поэтому сегодня мы рассмотрим, как происходит распознавание капчи при помощи данного языка.

Наиболее популярными инструментами от Python являются библиотека TensorFlow и Keras.

Распознавание капчи при помощи Python

TensorFlow — это одна из самых популярных библиотек для Python, которая применяется для распознавания изображений. А большинство капч — это и есть изображения, поэтому данная библиотека подходит как нельзя лучше. Внутри нее заложены различные алгоритмы и модели обработки изображений, что позволяет организовывать довольно гибкие нейросети для распознавания различных изображений и даже текста.

Keras — это API высокого уровня, которые помогают по максимуму использовать возможности TensorFlow, создавая мощные и сложные функции распознавания. Причем создание сложных функций происходит довольно прост о при помощи Keras.

Как происходит распознавание капчи при помощи Python

Распознавание капчи при помощи Python происходит по следующему алгоритму:

Капча в виде изображения попадает в нейронную сеть для дальнейшей ее обработки.

Потом извлеченные признаки переходят на следующий этап работы нейросети, где они анализируютс я д ля получения нужного результата.

Последний этап — получение результата.

Самым важным процессом в решении капчи является извлечение признаков, по которым будет распознаваться изображение. На этом этапе не й росеть разбивает представленное изображение на пиксели и проводит его через различные фильтры, которые формируют у нейросети «понимание» обрабатываемого изображения.

Распознавание капчи при помощи Python: рабочий процесс

Из чего состоит рабочий процесс программирования нейронной сети:

Обучить вашу модель нейронной сети. Как только данные для обучения собраны и у вас выстроена модель обучения, можно приступать к самому обучению. Продолжительность обучения вы задаете самостоятельно. Считается, что чем дольше нейронная сеть обучается, тем точнее будет результат ее работы, однако тут тоже важно не «переобучить» ее.

Распознавание капч при помощи Python на практике

В качестве эксперимента можно реализовать распознавание капчи при помощи Python, но на практике это мероприятие показывает довольно плохие результаты. Почему? Потому что такой метод распознавания капч подойдет для тех видов капч, которыми, мягко говоря, не занимаются разработчики. Потому что если попытаться распозна ть капчу, например, от Google, то вы столкнетесь с массой трудностей, которые не стоят сил, затраченных на их решение. Капчи такого уровня постоянно модернизируются и обновляются, для вас это будет означать следующее:

необходимо будет постоянно находить и обрабатывать новые данные для вашей нейронной сети, потому что имеющиеся будут быстро устаревать;

нужно будет постоянно лично контролировать процесс решения капч и вносить необходимые правки в нейросеть;

для обучения нейронной сети под такие виды капч требует ся мощно е оборудовани е ;

Альтернативный метод распознавания капчи

А сам ресурс уже находит исполнителей и гарантирует, что в 99% случаев капча решена будет правильно. Стоимость таких услуг разная : начинается от 20 рублей за решени е 1000 простых капч и за канчивается несколькими сотнями рублей за решение 1000 сложных капч. Объемы решаемых капч у разных сервисов разные, но можно встретить и такие, которые помогут вам решить до 15 000 капч в минуту.

Заключение

Мы будем очень благодарны

если под понравившемся материалом Вы нажмёте одну из кнопок социальных сетей и поделитесь с друзьями.

Источник

Как обойти капчу на Python?

Я мог что-то не так понять, если это так, то прошу прощения.

Я создал сессию.
session = requests.Session()
Дальше я делаю запрос к сайту

Дальше сбрасываю куки (может я их не так очищаю?):
session.cookies.clear()
При этом, все так-же происходит смена IP и UserAgent.
Но даже так, сайт все равно выдает капчу. Что я делаю не так, и какие еще есть варианты?

Если у вас возникла такая-же проблема как у меня, а именно капча при парсинге сайта, то прочитайте как я её решил.

Ну и вот собственно само решение 🙂
Я решил заменить библиотеку requests на selenium. Я через него подключался к сайту (у меня даже открывалось окно браузера) и с помощью метода page_source я получал html-код странички. Кстати, будьте внимательными, я так понял что с помощью этого метода можно получить только html, без js и css. Поэтому если сайт использует js для генерации контента, то у вас вряд-ли это получится. А потом, я просто с помощью bs4 парсил полученную html страничку, и извлекал из нее нужные мне данные. Да, капча все равно появлялась, но она появилась лишь однажды, я её вручную решил прямо через окно selenium, и можно сказать что я обошел капчу, так как она больше в процессе парсинга у меня не выскакивала.

Можете попробовать все описанные выше способы, может что и поможет. С каждым сайтом нужно извращаться по своему)

Источник

Декодирование капчи на Python

Это перевод и форма повествования от первого лица сохранена. Автор — Бен Бойтер, бакалавр информационных технологий в Университете Чарльза Стерта (CSU).

Большинство людей не в курсе, но моей диссертацией была программа для чтения текста с изображения. Я думал, что, если смогу получить высокий уровень распознавания, то это можно будет использовать для улучшения результатов поиска. Мой отличный советник доктор Гао Джунбин предложил мне написать диссертацию на эту тему. Наконец-то я нашел время написать эту статью и здесь я постараюсь рассказать о всем том, что узнал. Если бы только было что-то подобное, когда я только начинал…

Как я уже говорил, я пытался взять обычные изображения из интернета и извлекать из них текст для улучшения результатов поиска. Большинство моих идей было основано на методах взлома капчи. Как всем известно, капча — это те самые всех раздражающее штуки, вроде «Введите буквы, которые вы видите на изображении» на страницах регистрации или обратной связи.

Капча устроена так, что человек может прочитать текст без труда, в то время, как машина — нет (привет, reCaptcha!). На практике это никогда не работало, т. к. почти каждую капчу, которую размещали на сайте взламывали в течение нескольких месяцев.

У меня неплохо получалось — более 60% изображений было успешно разгадано из моей небольшой коллекции. Довольно неплохо, учитывая количество разнообразных изображений в интернете.

При своем исследовании я не нашел никаких материалов, которые помогли бы мне. Да, статьи есть, но в них опубликованы очень простые алгоритмы. На самом деле я нашел несколько нерабочих примеров на PHP и Perl, взял из них несколько фрагментов и получил неплохие результаты для очень простой капчи. Но ни один из них мне особо не помог, т. к. это было слишком просто. Я из тех людей, которые могут читать теорию, но ничего не понять без реальных примеров. А в большинстве статей писалось, что они не будут публиковать код, т. к. боятся, что его будут использовать в плохих целях. Лично я думаю, что капча – это пустая трата времени, т. к. ее довольно легко обойти, если знать как.

Собственно по причине отсутствия каких-то материалов, показывающих взлом капчи для начинающих я и написал эту статью.

Давайте начнем. Вот список того, что я собираюсь осветить в этой статье:

Используемые технологии

Все примеры написаны на Python 2.5 с использованием библиотеки PIL. Должно работать и в Python 2.6 (под Python 2.7.3 отлично запускается, прим. перев.).

Установите их в указанном выше порядке и вы готовы к запуску примеров.

Отступление

В примерах я буду жестко задавать множество значений прямо в коде. У меня нет цели создать универсальный распознаватель капч, а только показать как это делается.

Капча, что это такое в конце концов?

В основном капча является примером одностороннего преобразования. Вы можете легко взять набор символов и получить из него капчу, но не наоборот. Другая тонкость – она должна быть простая для чтения человеком, но не поддаваться машинному распознаванию. Капча может рассматриваться как простой тест типа «Вы человек?». В основном они реализуются как изображение с какими-то символами или словами.

Они используются для предотвращения спама на многих интернет-сайтах. Например, капчу можно найти на странице регистрации в Windows Live ID.

Это изображение является примером капчи, которую мы будем расшифровывать. Это реальная капча, которая размещена на реальном сайте.

Это довольно простая капча, которая состоит из символов одинакового цвета и размера на белом фоне с некоторым шумом (пиксели, цвета, линии). Вы думаете, что этот шум на заднем плане затруднит распознавание, но я покажу, как его легко удалить. Хоть это и не очень сильная капча, но она является хорошим примером для нашей программы.

Как найти и извлечь текст из изображений

Существует много методов для определения положения текста на изображении и его извлечения. С помощью Google вы можете найти тысячи статей, которые объясняют новые методы и алгоритмы для поиска текста.

Для этого примера я буду использовать извлечение цвета. Это довольно простая техника, с помощью которой я получил довольно неплохие результаты. Именно эту технику я использовал для своей диссертации.

Для наших примеров я буду использовать алгоритм многозначного разложения изображения. По сути, это означает, что мы сначала построим гистограмму цветов изображения. Это делается путем получения всех пикселей в изображении с группировкой по цвету, после чего производится подсчет по каждой группе. Если посмотреть на нашу тестовую капчу, то можно увидеть три основных цвета:

На Python это будет выглядеть очень просто.

Следующий код открывает изображение, преобразует его в GIF (облегчает нам работу, т. к. в нем всего 255 цветов) с печатает гистограмму цветов.

В итоге мы получим следующее:

Здесь мы видем количество пикселей каждого из 255 цветов в изображении. Вы можете увидеть, что белый (255, самый последний) встречается чаще всего. За ним идет красный (текст). Чтобы убедиться в этом, напишем небольшой скрипт:

И получаем такие данные:

Цвет	Количество пикселей
255	625
212	365
220	186
219	135
169	132
227	116
213	115
234	21
205	18
184	15

Это список из 10 наиболее распространенных цветов в изображении. Как ожидалось, белый повторяется чаще всего. Затем идут серый и красный.

Как только мы получили эту информацию, мы создаем новые изображения, основанные на этих цветовых группах. Для каждого из наиболее распространенных цветов мы создаем новое бинарное изображение (из 2 цветов), где пиксели этого цвета заполняется черным, а все остальное белым.

Красный у нас стал третьем среди наиболее распространенных цветов и это означает, что мы хотим сохранить группу пикселей с цветом 220. Когда я экспериментировал я обнаружил, что цвет 227 довольно близок к 220, так что мы сохраним и эту группу пикселей. Приведенный ниже код открывает капчу, преобразует ее в GIF, создает новое изображение такого же размера с белым фоном, а затем обходит оригинальное изображение в поисках нужного нам цвета. Если он находит пиксель с нужным нам цветом, то он отмечает этот же пиксель на втором изображении черным цветом. Перед завершением работы второе изображение сохраняется.

Запуск этого фрагмента кода дает нам следующий результат.

Оригинал	Результат

На картинке вы можете увидеть, что у нас успешно получилось извлечь текст из фона. Чтобы автоматизировать этот процесс вы можете совместить первый и второй скрипт.

Слышу, как спрашиваете: «А что, если на капче текст написан разными цветами?». Да, наша техника все еще сможет работать. Предположите, что наиболее распространенный цвет – это цвет фона и тогда вы сможете найти цвета символов.

Таким образом, на данный момент мы успешно извлекли текст из изображения. Следующим шагом будет определение того, содержит ли изображение текст. Я пока не буду писать здесь код, т. к. это сделает понимание сложным, в то время как сам алгоритм довольно прост.

На выходе у вас будет набор границ символов. Тогда все, что вам нужно будет сделать – это сравнить их между собой и посмотреть, идут ли они последовательно. Если да, то вам выпал джек-пот и вы правильно определили символы, идущие рядом. Вы так же можете проверять размеры полученных областей или просто создавать новое изображение и показывать его (метод show() у изображения), чтобы убедиться в точности алгоритма.

В результате у нас получалось следующее:

Это позиции по горизонтали начала и конца каждого символа.

ИИ и векторное пространство при распознавании образов

Распознавание изображений можно считать самым большим успехом современного ИИ, что позволило ему внедриться во все виды коммерческих приложений. Прекрасным примером этого являются почтовые индексы. На самом деле во многих странах они читаются автоматически, т. к. научить компьютер распознавать номера довольно простая задача. Это может быть не очевидно, но распознавание образов считается проблемой ИИ, хоть и очень узкоспециализированной.

Чуть ли ни первой вещью, с которой сталкиваются при знакомстве с ИИ в распознавании образов являются нейронные сети. Лично я никогда не имел успеха с нейронными сетями при распознавании символов. Я обычно обучаю его 3-4 символам, после чего точность падает так низко, что она была бы на порядок выше, отгадывай я символы случайным образом. Сначала это вызвало у меня легкую панику, т. к. это было тем самым недостающем звеном в моей диссертации. К счастью, недавно я прочитал статью о vector-space поисковых системах и посчитал их альтернативным методом классификации данных. В конце концов они оказались лучшем выбором, т. к.

Конечно, бесплатного сыра не бывает. Главный недостаток в скорости. Они могут быть намного медленнее нейронных сетей. Но я думаю, что их плюсы все же перевешивают этот недостаток.

Если хотите понять, как работает векторное пространство, то советую почитать Vector Space Search Engine Theory. Это лучшее, что я нашел для начинающих.

Я построил свое распознавание изображений на основе вышеупомянутого документа и это было первой вещью, которую я попробовал написать на любимом ЯП, который я в это время изучал. Прочитайте этот документ и как вы поймете его суть – возвращайтесь сюда.

Уже вернулись? Хорошо. Теперь мы должны запрограммировать наше векторное пространство. К счастью, это совсем не сложно. Приступим.

Это реализация векторного пространства на Python в 15 строк. По существу оно просто принимает 2 словаря и выдает число от 0 до 1, указывающее как они связаны. 0 означает, что они не связаны, а 1, что они идентичны.

Обучение

Следующее, что нам нужно – это набор изображений, с которыми мы будем сравнивать наши символы. Нам нужно обучающее множество. Это множество может быть использовано для обучения любого рода ИИ, который мы будем использовать (нейронные сети и т. д.).

Используемые данные могут быть судьбоносными для успешности распознавания. Чем лучше данные, тем больше шансов на успех. Так как мы планируем распознавать конкретную капчу и уже можем извлечь из нее символы, то почему бы не использовать их в качестве обучающего множества?

Это я и сделал. Я скачал много сгенерированных капч и моя программа разбила их на буквы. Тогда я собрал полученные изображения в коллекции (группы). После нескольких попыток у меня было по крайней мере один пример каждого символа, которые генерировала капча. Добавление большего количества примеров повысит точность распознавания, но мне хватило и этого для подтверждения моей теории.

На выходе мы получаем набор изображений в этой же директории. Каждому из них присваивается уникальных хеш на случай, если вы будете обрабатывать несколько капч.
Вот результат этого кода для нашей тестовой капчи:

Вы сами решаете, как хранить эти изображения, но я просто поместил их в директории с тем же именем, что находится на изображении (символ или цифра).

Собираем все вместе

Последний шаг. У нас есть извлекание текста, извлекание символов, техника распознавания и обучающее множество.

Мы получаем изображение капчи, выделяем текст, получаем символы, а затем сравниванием их с нашим обучающим множеством. Вы можете скачать окончательную программу с обучающим множеством и небольшим количеством капч по этой ссылке.

Здесь мы просто загружаем обучающее множество, чтобы иметь возможность сравнивать с ним:

А тут уже происходит все волшебство. Мы определяем, где находится каждый символ и проверяем его с помощью нашего векторного пространства. Затем сортируем результаты и печатаем их.

Выводы

Теперь у нас есть все, что нужно и мы можем попробовать запустить нашу чудо-машину.

Здесь мы видем предполагаемый символ и степень уверенности в том, что это действительно он (от 0 до 1).

Похоже, что у нас действительно все получилось!

На самом деле на тестовых капчах данный скрипт будет выдавать успешный результат примерно в 22% случаев (у меня получилось 28.5, прим. перев.).

Большинство неверных результатов приходится на неправильное распознаваине цифры «0» и буквы «О». Нет ничего неожиданного, т. к. даже люди их часто путают. У нас еще есть проблема с разбиванием на символы, но это можно решить просто проверив результат разбиения и найдя золотую середину.

Однако, даже с таким не очень совершенным алгоритмом мы можем разгадывать каждую пятую капчу за такое время, где человек не успел бы разгадать и одну.

Выполнение этого кода на Core 2 Duo E6550 дает следующие результаты:

От переводчика. У меня на Dual Core T4400 получились следующие результаты:

В нашем каталоге находится 48 капч, из чего следует, что на разгадывание одной уходит примерно 0.12 секунд. С нашими 22% процентами успешного разгадывания мы можем разгадывать около 432 000 капч в день и получать 95 040 правильных результатов. А если использовать многопоточность?

Вот и все. Надеюсь, что мой опыт будет использован вами в хороших целях. Я знаю, что вы можете использовать этот код во вред, но чтобы сделать действительно нечто опасное вы должны довольно сильно его изменить.

Для тех, кто пытается защитить себя капчей я могу сказать, что это вам не сильно поможет, т. к. их можно обойти программно или просто платить другим людям, которые будут разгадывать их вручную. Подумайте над другими способами защиты.

Источник