Artificial intelligence

На фото Arthur Lee Samuel, пионер машинного обучения, демонстрирует возможности искусственного интеллекта и играет в шашки с собственной программой Checkers-Playing, одной из первых самообучающихся программ в мире. 1962 год.

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

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

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

Вступление. Машинное обучение и информационная безопасность

Да, сегодня все знают про машинное обучение. Умная колонка и онлайн-кинотеатр угадывают ваше настроение и близко к идеальному предлагают в рекомендациях следующий трек/фильм. Когда вы звоните на горячую линию банка, трудно понять, кто отвечает робот или живой человек. Беспилотные автомобили уже на дорогах общего назначения.

Но как связаны машинное обучение и информационная безопасность?

Признаться, тяжело представить себе распространение технологий AI/ML в проекты и приложения информационной безопасности. Пока не пролистаешь отчет из Стэнфорда AI Index 2019 Report, 220 страниц о современном состоянии дел в области искусственного интеллекта.

Выводы после прочтения отчета:

1. Направление Сybersecurity (Network Security) это около 3% мировых частных инвестиций в стартапы, использующие технологии искусственного интеллекта. Впечатляюще.

2. В блокноте я подсчитал объемы привлеченных инвестиций ведущими мировыми разработчиками средств защиты информации с использованием AI (таблица на рисунке выше). В топ-10 из знакомых имён только Splunk. А кто такие Sophos, Cylance, CrowdStrike, Wangsu, Opzoon? И с какими питчами они привлекают миллиарды долларов?

3. Среди продуктов лидеров построенного рейтинга антивирусы, средства обнаружения атак, управления инцидентами, анализа защищенности, защиты от утечек, спам-фильтры, threat intelligence, почти вся номенклатура СЗИ. ML, как минимум, делает вид, что работает везде.

Итак, у меня есть желание разобраться в машинном обучении. Есть опыт в разработке средств защиты. Известны примеры успешных реализаций СЗИ c ML. Что мешает попробовать самому, с нуля разработать систему обнаружения компьютерных атак на основе машинного обучения? Вперед!

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

Последовательность шагов

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

1. Выбор набора данных для обучения системы обнаружения компьютерных атак.

2. Предварительная обработка данных.

3. Сэмплирование против дисбаланса классов.

4. Оценка значимости и отбор признаков.

5. Сокращение признакового пространства.

6. Выбор модели.

7. Настройка и обучение модели.

8. Тестирование и апробация.

Далее по шагам.

Типовая схема обучения с учителем

Шаг 1. Выбор набора данных для обучения

Для обучения системы обнаружения атак среди доступных публичных наборов данных (DARPA1998, KDD1999, ISCX2012, ADFA2013 и других) я выбрал один из наиболее актуальных (на момент начала исследования) Intrusion Detection Evaluation Dataset CICIDS2017. Разработчик Canadian Institute for Cybersecurity. Набор данных CICIDS2017 подготовлен по результатам анализа сетевого трафика в изолированной среде, в которой моделировались действия 25 легальных пользователей, а также вредоносные действия нарушителей.

Набор объединяет более 50 Гб сырых данных в формате PCAP и включает 8 предобработанных файлов в формате CSV, содержащих размеченные сессии с выделенными признаками в разные дни наблюдения. Краткое описание файлов и количественный состав набора данных представлены в таблицах ниже.

Хорошие данные обязательное условие для построения хорошего классификатора.

В обзорах набора данных CICIDS2017 (Intrusion2017, Panigrahi2018, Sharafaldin2018) отмечались проблемы дисбаланса классов, сложной файловой структуры, пропуска значений. Эти замечания я принял как некритичные.

Сегодня у меня есть вопросы по аккуратности разметки набора данных CICIDS2017 (связаться с авторами набора данных и задать вопросы не удалось ни по личным адресам электронной почты, ни через Canadian Institute for Cybersecurity), но именно по этой причине мне пришлось самому разработать весь pipeline начиная от сниффера и предобработки сетевых сессий, заканчивая моделью машинного обучения и тестированием в реальной сети.

Получается, больше приобрел, чем потерял.

Шаг 2. Предварительная обработка данных

Отправной точкой для проведения собственных экспериментов с датасетом CICIDS2017 послужило исследование Kahraman Kostas Anomaly Detection in Networks Using Machine Learning. При попытке воспроизведения этого исследования были обнаружены расхождения в результатах, а потом и ошибки в коде автора. Я связался в апреле 2020 года с Kahraman Kostas, мы обсудили варианты исправления ошибки, однако по состоянию на январь 2021 года код в репозитории по-прежнему некорректно оценивает значимость признаков.

Для сокращения времени вычислений в обучающей выборке был оставлен единственный класс атак веб-атаки (Brute Force, XSS, SQL Injection). Для этого я подготовил подвыборку WebAttacks на основе обработки файла Thursday-WorkingHours-Morning-WebAttacks.pcap_ISCX.csv из набора данных CICIDS2017. Набор WebAttacks включает 458968 записей, из которых 2180 относятся к веб-атакам, остальные к нормальному трафику.

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

Я храню Jupyter блокноты на Github в репозитории ml-cybersecurity, а ссылки даю на Google Colabоratory тогда код готов к запуску прямо в браузере.

Исходный код в Google Colabоratory

Матч с канадцами. Поиск и исправление ошибок в датасете

На этапе предварительной обработки данных я обнаружил погрешности в признаковом пространстве (как минимум, подозрительным показалось наличие двух разных признаков с попарно одинаковыми значениями). И решил выполнить проверку: взять сырой трафик CICIDS2017, самому выделить в нём сетевые сессии и сформировать свой датасет. Мой датасет должен был совпасть с датасетом CICIDS2017.

Обрабатываю pcap файл с записанным траффиком своим сниффером, выделяю сессии и признаки, сравниваю с датасетом Thursday-WorkingHours-Morning-WebAttacks.pcap_ISCX.csv, пытаюсь понять и исправить расхождения. Да, расхождения есть.

Выбранная сессия для анализа

Анализирую сессию Flow ID = 192.168.10.14-65.55.44.109-59135-443-6, Source IP = 65.55.44.109. У канадских исследователей два последних пакета выделены в отдельную сессию? Внимательно просматриваю исходники их сниффера и нахожу подтверждение в методе addPacket.

Что нужно учесть в моем сниффере:

1. При появлении пакета с флагом FIN в направлении forward для воспроизведения эксперимента нужно завершить текущую сессию и создать новую. Чтобы два последних пакета FIN ACK и ACK попали во вторую сессию вместе, условие прерывания сессии нужно дополнить: количество пакетов в сессии должно быть больше 1.

2. Завершение сессии по таймеру, 120 секунд (хотя в readme сказано про 600 секунд).

Иду дальше. Для той же сессии в прямом направлении зафиксирован один пакет (Total Fwd Packets = 1), при этом общая длина переданных пакетов в прямом направлении Total Length of Fwd Packets = 6. По данным Wireshark, длина пакета = 0. Откуда разница в 6 байт? Спускаюсь от TCP до Ethernet и обнаруживаю неучтенные 6 байт в виде дополнения (padding) фрейма Ethernet. Спорная ситуация, нужно ли включать эти 6 байт в длину TCP пакета.

Проверка длины пакета в Wireshark

Проверяю остальные признаки для этой сессии, совпадают все значения, кроме Average Packet Size = 9. Как при двух пакетах по 6 байт получить значение 9, не ясно. При этом Packet Length Mean = 6, совпадает.

Начинаю проверять другие сессии, и оказывается, что часто встречаются небольшие расхождения в признаках: Packet Length Mean, Packet Length Std, Packet Length Variance , Average Packet Size, Average Fwd Segment Size, Average Bwd Segment Size. Вскрытие (восстановление исходных слагаемых по значениям средних) показывает, что при срабатывании таймаута сессии длина отбрасываемого пакета ошибочно учитывается в статистике.

Как могу, обновляю свой код, добиваться полного соответствия датасетов ( = вносить ошибки) не имеет смысла.

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

Шаг 3. Сэмплирование против дисбаланса классов

Подготовленная подвыборка WebAttacks является насбалансированной: при общем количестве записей 170366 класс нет атаки объединяет 168186 экземпляров, класс есть атака 2180 экземпляров. Для устранения дисбаланса классов подойдет метод случайного сэмплирования (субдискретизация, undersampling), заключающийся в удалении случайно выбранных экземпляров класса нет атаки. Целевое соотношение количества экземпляров классов нет атаки и есть атака я выбрал 70% / 30%.

Шаг 4. Оценка значимости и отбор признаков

Предварительно из признакового пространства были исключены признаки Flow ID, Source IP, Source Port, Destination IP, Destination Port, Protocol, Timestamp в предположении, что признаки формы (соответствующие статистикам сетевого трафика) являются более значимыми для общего случая. Кроме того, исключаемые признаки адресации могут быть относительно легко подделаны злоумышленником и не должны учитываться при обучении.

Анализ значимости признаков я выполнил с помощью встроенного механизма метода sklearn.ensemble.RandomForestClassifier (атрибут feature_importances_).

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

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

Шаг 5. Сокращение признакового пространства

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

Корреляционный анализ показал сильную зависимость между парами признаков:

1. Average Packet Size и Packet Length Mean.

2. Subflow Fwd Bytes и Total Length of Fwd Packets.

3. Fwd Packet Length Mean и Avg Fwd Segment Size.

4. Flow Duration и Fwd IAT Total.

5. Flow Packets/s и Fwd Packets/s.

6. Flow IAT Max и Fwd IAT Max.

По результатам корреляционного анализа из признакового пространства были исключены следующие признаки: Packet Length Mean, Subflow Fwd Bytes, Avg Fwd Segment Size, Fwd IAT Total, Fwd Packets/s, Fwd IAT Max.

После исключения признаков с наименьшей значимостью признаковое пространство было сокращено до объединения 10 признаков:

1. Average Packet Size, средняя длина поля данных пакета TCP/IP (далее длина пакета).

2. Flow Bytes/s, скорость потока данных.

3. Max Packet Length, максимальная длина пакета.

4. Fwd Packet Length Mean, средняя длина переданных в прямом направлении пакетов.

5. Fwd IAT Min, минимальное значение межпакетного интервала (IAT, inter-arrival time) в прямом направлении.

6. Total Length of Fwd Packets, суммарная длина переданных в прямом направлении пакетов.

7. Fwd IAT Std, среднеквадратическое отклонение значения межпакетного интервала в прямом направлении пакетов.

8. Flow IAT Mean, среднее значение межпакетного интервала.

9. Fwd Packet Length Max, максимальная длина переданного в прямом направлении пакета.

10. Fwd Header Length, суммарная длина заголовков переданных в прямом направлении пакетов.

Шаг 6. Выбор модели

На этапе выбора модели я взял 10 наиболее распространенных моделей машинного обучения и оценил их качество на подвыборке WebAttacks.

Качество ответов классификаторов (моделей) сравнивалось с использованием следующих метрик:

• доля правильных ответов (accuracy);

• точность (precision, насколько можно доверять классификатору);

• полнота (recall, как много объектов класса есть атака определяет классификатор);

• F1-мера (F1-measure, гармоническое среднее между точностью и полнотой).

Оценка качества классификаторов производилась на сбалансированной и предобработанной подвыборке веб-атак WebAttacks набора данных CICIDS2017 (соотношение нормального и аномального трафика 70% / 30%, 20 наиболее значимых признаков). В таблице ниже приведены полученные значения метрик качества, усредненные по результатам 5 итераций кросс-валидации.

Наилучшие результаты ожидаемо продемонстрировали модели (алгоритмы) KNN, CART, RF, AdaBoost, LR. Принимая во внимание минимальное время выполнения, применение модели случайный лес (RF) для решения поставленной задачи является обоснованным выбором.

Исходный код в Google Colaboratory

Шаг 7. Настройка и обучение модели

Итак, за основу я взял модель типа случайный лес, реализация в scikit-learn RandomForestClassifier.

Среди настраиваемых гиперпараметров модели были выбраны следующие: количество деревьев в лесу (n_estimators), минимальное число объектов в одном листе дерева (min_samples_leaf), максимальная глубина дерева (max_depth), максимальное количество признаков для одного дерева (max_features).

Степень квазиоптимальности параметров модели оценивалась значением F1-меры.

Проведенный экспертный анализ я дополнил результатами встроенного метода оптимизации параметров GridSearchCV библиотеки scikit-learn, итоговые значения параметров модели случайный лес получились следующие:

RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',max_depth=17, max_features=10, max_leaf_nodes=None,min_impurity_decrease=0.0, min_impurity_split=None,min_samples_leaf=3, min_samples_split=2,min_weight_fraction_leaf=0.0, n_estimators=50,n_jobs=None, oob_score=False, random_state=1, verbose=0,warm_start=False)

Пример результатов подбора одного гиперпараметра (max_depth) при фиксированных значениях других гиперпараметров (n_estimators, min_samples_leaf, max_features) представлен на рисунке ниже в виде зависимости метрики качества (F1-меры) от значения настраиваемого параметра (max_depth).

Зависимость F1-меры модели от параметра max_depth

Шаг 8. Тестирование и апробация

Настроенная и обученная модель RandomForestClassifier на тестовой выборке позволила получить оценку полноты (recall) 0.961 и F1-меры 0.971 (запуск 1 в протоколе эксперимента, см. таблицу ниже). Достигнутый результат свидетельствует о возможности повышения точности модели за счет квазиоптимального подбора гиперпараметров (результаты исследования Kahraman Kostas recall 0.94 и F1-мера 0.94, результаты авторов CICIDS2017 recall 0.97 и F1-мера 0.97).

Для апробации модели на реальной сетевой инфраструктуре я разработал свой сетевой анализатор сниффер (C#). Анализатор позволяет перехватить передаваемый сетевой трафик и с использованием алгоритмов реконструкции TCP сессий свободно распространяемых программных продуктов Wireshark и TCP Session Reconstruction Tool выделить отдельные сессии. Для каждой сохраненной сессии сниффер на основе алгоритма CICFlowMeter выделяет признаки и таким образом формирует набор данных.

В качестве атакуемого веб-приложения использовалась разработанная консоль администратора безопасности (PHP) с единственным включенным модулем авторизации, функционирующая под управлением веб-сервера Apache.

Нормальный трафик соответствовал запросам легальных пользователей на подключение к консоли администратора и авторизацию. Вредоносный (аномальный) трафик моделировался программным средством OWASP ZAP и включал три типа атак: Brute Force, XSS, SQL Injection. Соотношение нормального и аномального трафика в реальном тестовом наборе данных составило 70% / 30%.

Пример защищаемого приложения (заимствован из поста: Как за один день разработать SIEM).

Пример URL, соответствующего попытке входа в защищаемое приложение: http://192.168.121.129/buggy/admin.php?password=12345&username=admin

ZAP запускается в режиме фаззинга, при котором будут перебираться различные значения параметра password. Важно: параметр username сразу устанавливается равным admin. Будем считать, что злоумышленник знает имя администратора наверняка. В противном случае, можно для фаззера указать оба параметра, но и количество попыток возрастёт до N*N для двух параметров вместо N для одного (N количество строк в словаре).

Нагрузки (payloads, словари) для проведения атак Brute Force, XSS и SQL Injection я взял из репозитория github.com/danielmiessler/SecLists.

Как узнать, подобрал ли фаззер пароль при реализации атаки Brute Force? Я знаю, что в защищаемом веб-приложении страница авторизованного пользователя отличается от приветственной. Поэтому достаточно отсортировать результаты работы фаззера по размеру ответа столбец Size Resp. Body. И в строке с размером ответа, отличающимся от всех остальных, обнаружить пароль admin.

Успешный запуск фаззера

Проведенные эксперименты на сформированном наборе данных (запуски 2, 3 в протоколе эксперимента) показали невозможность применения модели, обученной на наборе данных CICIDS2017, по следующим причинам:

1. Анализ обучающей выборки показывает, что характер моделируемых компьютерных атак в исследовании авторов набора данных CICIDS2017 отличается от реального. Так, атаки типа Brute Force присутствуют в сессиях с максимальными скоростями до 10 Кбит/c, что не соответствует случаям применения автоматизированных средств перебора паролей.

2. Среди десяти признаков с наибольшей значимостью четыре признака Flow Bytes/s (скорость потока данных), Fwd IAT Min (минимальное значение межпакетного интервала в прямом направлении), Flow IAT Std (среднеквадратическое отклонение значения межпакетного интервала), Flow IAT Mean (среднее значение межпакетного интервала) непосредственно зависят от физической структуры сети, в которой производится сбор сетевого трафика, а также настроек сетевого оборудования. В обучающем наборе данных сессии с признаками веб-атак записаны с низкими значениями скорости потока и высокими значениями межпакетных интервалов, что не соответствует характеристикам реальной сетевой инфраструктуры (сеть Ethernet 100 Мбит/c).

Важно. Запуск 2. Модель была обучена на подвыборке WebAttacks набора данных CICIDS2017 (трафик собирался в одной сети). После этого я протестировал модель на реальном трафике в другой сети, отличающейся скоростью и другими характеристиками от первой. И получил неудовлетворительное качество значение F1-меры 0.064.

Оценка вычислительной сложности производилась косвенным способом: разработанный в среде Jupyter Notebook макет системы обнаружения веб-атак запускался на персональном компьютере (процессор Intel Core i5-2300 CPU @ 2300 ГГц, ОЗУ 8 Гб) в режиме обнаружения. Тестовый набор данных содержал около 70000 записанных сессий, время обнаружения составило 0,74669 с. Таким образом, скорость обнаружения веб-атак оценивается величиной порядка 100000 сессий в секунду.

Подведение итогов

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

Настройка параметров выбранного классификатора RandomForestClassifier пакета scikit-learn позволила на тестовой выборке получить оценку полноты (recall) 0.961 и F1-меры 0.971 для набора данных CICIDS2017 и 0.966 и 0.882 соответственно для сформированного в исследовании набора данных.

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

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

1. Характер моделируемых компьютерных атак при сборе обучающего набора данных отличался от реального.

2. Часть значимых признаков непосредственно зависят от физической структуры сети, в которой производился сбор сетевого трафика, а также настроек сетевого оборудования.

Что исправить, чтобы получилось? Идеально обучать модель на наборе данных, размеченном на основе анализа сетевого трафика в защищаемой сети. При использовании предобученной в другой сети модели (проблема transfer learning) обязательным является соответствие физической структуры защищаемой сети и сети, в которой обучалась модель, а также настроек сетевого оборудования.

Личные выводы. В начале освоения пути исследователя данных применение машинного обучения представлялось в виде 10 строчек кода из примера на scikit-learn.org. Сегодня, глядя на >500 строк кода в итоговом блокноте, я понимаю, сколько еще улучшений можно сделать и как развить решение.

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

Полезные ссылки

Исходный код эксперимента (блокноты, сниффер, разное): github.com/fisher85/ml-cybersecurity

Книги, которые помогли в исследовании:

• Talabis M. Information Security Analytics.

• Sumeet D. Data Mining and Machine Learning in Cybersecurity.

• Lee K.-F. AI Superpowers: China, Silicon Valley, and the New World Order.

• McAfee A. Machine, Platform, Crowd. Harnessing Our Digital Future.

• Chio С. Machine Learning and Security: Protecting Systems with Data and Algorithms.

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

• 2017 год. Курс Введение в машинное обучение от ВШЭ и Yandex.

• 2018 год. Курс Machine Learning Recipes от Google Developers.

• 2019 год. Курс Introduction to Machine Learning for Coders от Fast.ai.

• 2019 год. Курс Practical Deep Learning for Coders от Fast.ai.

• 2020 год. Курс Machine Learning Crash Course от Google Developers.

Цвет титульной фотографии восстановлен здесь

Сотрудники лаборатории машинного обучения Университета ИТМО занимаются не только теорией, но и прикладными проектами. Некоторым из них удается вдохновлять участников научного и профессионального сообщества по всему миру, преображать бизнес и цифровое пространство. Такую работу ведет Media Research Group под руководством профессора Александра Фарсеева. Сегодня он рассказывает об исследованиях и проектах его команды.

Профилирование пользователей в соцсетях

В Media Research Group, которая является частью лаборатории машинного обучения Университета ИТМО, мы работаем в нескольких исследовательских направлениях. Они связаны с использованием систем искусственного интеллекта в анализе данных соцсетей и генерации синтетического мультимедийного контента. Причем все наши проекты так или иначе находят практическое применение взять хотя бы профилирование в социальных сетях.

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

Громкое обсуждение наших алгоритмов профилирования произошло ещё в 2017 году в связи с новостью о Дональде Трампе. На основе данных из Twitter алгоритмы сделали вывод, что Трамп холост, хотя было понятно, что он женат. Тогда эту новость обсуждали везде, даже в The Independent написали о нашей работе. Вывод о семейном статусе Трампа показался для многих спорным, но всё же, как я считаю, он помог приоткрыть истинное лицо экс-президента.

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

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

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

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

В ряде наших исследований мы прогнозировали характеристики пользователей соцсетей по шкале MBTI (Типология Майерс Бриггс), а в одном из них решили сосредоточиться на предсказании семейного статуса пользователей, так как эта характеристика во многом определяет интересы и поведение людей. Для исследования мы использовали собранную нами ещё в 2014 году базу данных NUS-MSS, которая содержит мультимодальные данные из трёх социальных сетей (Twitter, Foursquare и Instagram) и достоверные записи о семейном статусе пользователей из трёх регионов Сингапура, Нью-Йорка и Лондона. Чтобы получить предсказательную модель с количественными значениями, мы разделили пользователей NUS-MSS на состоящих и не состоящих в браке, а затем с помощью алгоритмов выбора признаков выявили коррелирующие с семейным статусом характеристики. Экстраполируя выводы, мы применили алгоритмы выбора признаков к двум получившимся группам. Средняя точность предсказательных способностей модели по трем локациям представлена в таблице.

Наш опыт показывает, что объединение данных из двух источников в некоторых случаях может повысить точность предсказания на17%. Она учитывает не только информацию о поведении отдельного пользователя, но и похожих на него людей. Схожесть определяется по попаданию в кластеры, выявленные на основе данных из нескольких соцсетей. О спектральной кластеризации, которая является ключевым концептом в данном исследовании, можно почитать в нашей статье. Если интересно копнуть поглубже, посмотрите реализацию такой кластеризации для Java.

Это лишь верхушка айсберга возможностей систем ИИ в анализе данных из соцсетей. Некоторые облачные ИИ-платформы (например, Social Bakers или SoMin.ai, основателем которой я являюсь) способны выходить далеко за пределы персонального профилирования и использовать так называемый психографический анализ. Он заключается в выявлении скрытых личностных черт, определяющих наши повседневные решения буквально в каждом жизненном аспекте.

Генерация контента

Специалисты по маркетингу тратят десятки часов на то, чтобы подготовить несколько вариаций того или иного контента. Ведь им важно попасть в нужную аудиторию, отразить фирменный стиль, и, в конце концов, сделать сам контент привлекательным для потребителей. Ещё его необходимо адаптировать для разных каналов (материал для Хабра != пост в Facebook), что также влечет дополнительную трату времени. Как раз с решением этой проблемы связано наше второе исследовательское направление с помощью поддержки со стороны технологий машинного обучения маркетологи могут сфокусироваться на творчестве и стратегических решениях. А генерацией контента займутся автоматизированные системы.

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

GANs технология будущего для индустрии digital-маркетинга, других профессий и сфер деятельности. Мы используем GANs и в наших коммерческих разработках например, задействовали одну из вариаций архитектуры при проектировании первого в мире инфлюенсера, работающего на базе системы ИИ, для PUMA Asia Pacific. Мы назвали этого персонажа Maya. Она делает селфи и живёт своей обычной виртуальной жизнью. Чтобы создать её, были сопоставлены миллионы лиц из различных источников, включая Instagram. Это позволило визуализировать несколько версий лица, ставших первым шагом для создания виртуального блогера.

Однако исключительно порождающими состязательными сетями здесь не обойтись. Не могу делиться всеми техническими подробностями, так как проект коммерческий. Но я бы хотел упомянуть об инструменте, который оказался весьма полезен как в этом проекте, так и в других, связанных с профилированием. Это поиск восхождением к вершине (Hill Climbing) техника поиска оптимального решения путем пошагового изменения одного из элементов решения. Ее используют в качестве стратегии оптимизации невыпуклых моделей-ансамблей. Мы часто применяем Hill Climbing в случаях, когда у нас стоит задача подбора параметров алгоритмов машинного обучения и нет возможности перебирать все комбинации например, из-за сложности каждого прохода тренировки. В случае с Hill Climbing такая проблема решается за гораздо меньшее количество проходов, тем самым ускоряя процесс тренировки.

Также важно уметь пользоваться небольшой модификацией алгоритма Hill Climbing with Random Restart. Суть в том, что мы перезапускаем Hill Climbing много раз с различными случайными значениями точек отправления параметров, тем самым увеличивая наш шанс найти не локальный, а глобальный минимум даже для задач невыпуклой оптимизации. Очень полезная эвристика, позволяющая подбирать значения параметров быстро и с высокой вероятностью близкие к оптимальным. Реализацию техники в коде можно посмотреть здесь.

В частности, техника Hill Climbing использовалась в одном из наших первых проектов по профилированию пользователей социальных сетей. Этому проекту посвящена статья Harvesting multiple sources for user profile learning: a big data study. Здесь мы осуществляем слияние данных, моделируя источники как линейную комбинацию предсказаний моделей машинного обучения, натренированных на каждом источнике по отдельности так называемый Late Fusion Ensemble. Понятно, что соединив источники с весами 1, мы не сможем добиться наилучших результатов. Ведь текстовые данные, например, из Twitter могут быть более полезными, чем те же самые текстовые данные, только из Foursquare (предназначена для обмена точками геоданных). Вот тут-то и нужны подходы вроде Hill Climbing для того, чтобы эффективно и быстро (не перебирая все комбинации источников) найти правильные веса каждой соцсети и модальности данных для достижения хороших результатов скомбинированной модели.

Профилирование и генерация

Синтетическим контентом можно пользоваться в тандеме с профилированием. В зависимости от интересов человека, ему будет предложено наиболее привлекательное автоматически сгенерированное рекламное объявление. Допустим, фастфуд выпустил баннер с рекламой нового бургера. Мы можем сгенерировать на его основе ещё сто версий баннера и найти среди них те, которые больше нравятся аудитории. Таким образом, профилирование пользователей и генерация контента органично дополняют друг друга. И SoMin.ai на практике объединяет два этих исследовательских направления в хороший маркетинговый инструмент. Руководствуясь типом личности MBTI, который автоматически определяется с помощью анализа контента из профилей соцсетей, SoMin.ai генерирует новый контент на основе предпочтений других пользователей с аналогичным типом личности. Вот так выглядит структура платформы SoMin.ai:

Из схемы видно, что на серверной стороне контент от брендов мы собираем через нативные взаимодействия с их библиотеками и загружаем на платформу каждые двенадцать часов. Остальные пять шагов выполняются с различными интервалами от 24 часов до 30 дней:

1. Сбор контента от брендов.

2. Сбор контента от пользователей и сбор фидбека.

3. Тренировка моделей профилирования и генерации контента.

4. Генерация контента на основе типа личности.

5. Сбор фидбека от пользователей платформы.

Более полное описание работы платформы можно найти в статье, которую мы с коллегами из лаборатории опубликовали на WSDM 2020.

Бизнес понимает потенциал данных исследовательских направлений, а Media Research Group успешно раскрывает его. Я думаю, поэтому SoMin.ai стала партнером OpenAI, а моя команда получила доступ к GPT-3 для развития рекламных алгоритмов в соцсетях. Вероятно, по той же причине SoMin.ai удостоена престижной премии от Gartner Cool Vendors Award 2020. Но это еще не все. Совсем недавно мы представили новый проект SoPop.ai. Эта платформа анализирует публикации блогеров и определяет реакцию пользователей на них. Как и SoMin.ai, она помогает компаниям искать блоги, которые могут быть использованы в рекламных целях. Кроме того, SoPop.ai сотрудничает с банком Arival, чтобы сделать следующий шаг в развитии платформы создание цифрового банка для инфлюенсеров. Такая экосистема для блогеров и компаний будет не только искать возможности для рекламы, но и улучшать контент. О технологиях, на основе которых разработана платформа в этой научной статье.

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

Наши англоязычные хабрапосты по другим темам:

• Content marketing stamina the easy way for founders to get ahead of their competition

• The true cost of free labour and how startup founders can find their way around it

• PopMech and its ancestors: a foray into the history of tech

• How startups can cut through passive-aggressive media

• Startups going global: a guide to Startup Digest

• Going global: a guide to Product Hunt

• The founders guide to AngelList

До появления YOLO большинство способов обнаружения объектов пытались адаптировать классификаторы для детекции. В YOLO же, обнаружение объектов было сформулировано как задача регрессии на пространственно разделенных ограничивающих рамок (bounding boxes) и связанных с ними вероятностей классов.

В данной статье мы узнаем о системе YOLO Object Detection и как реализовать подобную систему в Tensorflow 2.0

О YOLO:

Наша унифицированная архитектура чрезвычайно быстра. Базовая модель YOLO обрабатывает изображения в режиме реального времени со скоростью 45 кадров в секунду. Уменьшенная версия сети, Fast YOLO, обрабатывает аж 155 кадра в секунду

You Only Look Once: Unified, Real-Time Object Detection, 2015

Что такое YOLO?

YOLO это новейшая (на момент написания оригинальной статьи) система (сеть) обнаружения объектов. Она была разработана Джозефом Редмоном (Joseph Redmon). Наибольшим преимуществом YOLO над другими архитектурами является скорость. Модели семейства YOLO исключительно быстры и намного превосходят R-CNN (Region-Based Convolutional Neural Network) и другие модели. Это позволяет добиться обнаружения объектов в режиме реального времени.

На момент первой публикации (в 2016 году) по сравнению с другими системами, такими как R-CNN и DPM (Deformable Part Model), YOLO добилась передового значения mAP (mean Average Precision). С другой стороны, YOLO испытывает трудности с точной локализацией объектов. Однако в новой версии были внесены улучшения в скорости и точности системы.

Альтернативы (на момент публикации статьи): Другие архитектуры в основном использовали метод скользящего окна по всему изображению, и классификатор использовался для определенной области изображения (DPM). Также, R-CNN использовал метод предложения регионов (region proposal method). Описываемый метод сначала создает потенциальные bounding boxы. Затем, на области, ограниченные bounding boxами, запускается классификатор и следующее удаление повторяющихся распознаваний, и уточнение границ рамок.

YOLO переосмыслила задачу обнаружения объектов в задачу регрессии.Она идет от пикселей изображения к координатам bounding boxов и вероятностей классов. Тем самым, единая сверточная сеть предсказывает несколько bounding boxов и вероятности классов для содержания этих областей.

Теория

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

Во-первых, каждая ячейка отвечает за прогнозирование количества bounding boxов. Также, каждая ячейка прогнозирует доверительное значение (confidence value) для каждой области, ограниченной bounding boxом. Иными словами, это значение определяет вероятность нахождения того или иного объекта в данной области. То есть в случае, если какая-то ячейка сетки не имеет определенного объекта, важно, чтобы доверительное значение для этой области было низким.

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

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

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

В YOLO используются anchor boxes (якорные рамки / фиксированные рамки) для прогнозирования bounding boxов. Идея anchor boxов сводится к предварительному определению двух различных форм. И таким образом, мы можем объединить два предсказания с двумя anchor boxами (в целом, мы могли бы использовать даже большее количество anchor boxов). Эти якоря были рассчитаны с помощью датасета COCO (Common Objects in Context) и кластеризации k-средних (K-means clustering).

У нас есть сетка, где каждая ячейка предсказывает:

• Для каждого bounding box'а:

  • 4 координаты (t_x , t_y , t_w , t_h)

  • 1 objectness error (ошибка объектности), которая является показателем уверенности в присутствии того или иного объекта

• Некоторое количество вероятностей классов

Если же присутствует некоторое смещение от верхнего левого угла на c_x , c_y то прогнозы будут соответствовать:

где p_w (ширина) и p_h (высота) соответствуют ширине и высоте bounding box'а. Вместо того, чтобы предугадывать смещение как в прошлой версии YOLOv2, авторы прогнозируют координаты местоположения относительно местоположения ячейки.

Этот вывод является выводом нашей нейронной сети. В общей сложности здесьS x S x [B * (4+1+C)] выводов, где B это количество bounding box'ов, которое может предсказать ячейка на карте объектов, C это количество классов, 4 для bounding box'ов, 1 для objectness prediction (прогнозирование объектности). За один проход мы можем пройти от входного изображения к выходному тензору, который соответствует обнаруженным объектам на картинке. Также стоит отметить, что YOLOv3 прогнозирует bounding box'ы в трех разных масштабах.

Теперь, если мы возьмем вероятность и умножим их на доверительные значения, мы получим все bounding box'ы, взвешенные по вероятности содержания этого объекта.

Простое нахождение порогового значения избавит нас от прогнозов с низким доверительным значением. Для следующего шага важно определить метрику IoU (Intersection over Union / Пересечение над объединением). Эта метрика равняется соотношению площади пересекающихся областей к площади областей объединенных.

После этого все равно могут остаться дубликаты, и чтобы от них избавиться нужно использовать подавление не-максимумов (non-maximum suppression). Подавление не-максимумов заключается в следующем: алгоритм берёт bounding box с наибольшей вероятностью принадлежности к объекту, затем, среди остальных граничащих bounding box'ов с данной области, возьмёт один с наивысшим IoU и подавляет его.

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

Мы также рекомендуем прочитать следующие статьи о YOLO:

• You Only Look Once: Unified, Real-Time Object Detection

• YOLO9000: Better, Faster, Stronger

• YOLOv3: An Incremental Improvement

Реализация в Tensorflow

Первым шагом в реализации YOLO это подготовка ноутбука и импортирование необходимых библиотек. Целиком ноутбук с кодом вы можете на Github или Kaggle:

Следуя этой статье, мы сделаем полную сверточную сеть (fully convolutional network / FCN) без обучения. Для того, чтобы применить эту сеть для определения объектов, нам необходимо скачать готовые веса от предварительно обученной модели. Эти веса были получены от обучения YOLOv3 на датасете COCO (Common Objects in Context). Файл с весами можно скачать по ссылке официального сайта.

# Создаем папку для checkpoint'ов с весами.# !mkdir checkpoints# Скачиваем файл с весами для YOLOv3 с официального сайта.# !wget https://pjreddie.com/media/files/yolov3.weights# Импортируем необходимые библиотеки.import cv2import numpy as np import tensorflow as tf from absl import loggingfrom itertools import repeatfrom PIL import Imagefrom tensorflow.keras import Modelfrom tensorflow.keras.layers import Add, Concatenate, Lambdafrom tensorflow.keras.layers import Conv2D, Input, LeakyReLUfrom tensorflow.keras.layers import MaxPool2D, UpSampling2D, ZeroPadding2Dfrom tensorflow.keras.regularizers import l2from tensorflow.keras.losses import binary_crossentropyfrom tensorflow.keras.losses import sparse_categorical_crossentropyyolo_iou_threshold = 0.6 # Intersection Over Union (iou) threshold.yolo_score_threshold = 0.6 # Score threshold.weightyolov3 = 'yolov3.weights' # Путь до файла с весами.size = 416 # Размер изображения. checkpoints = 'checkpoints/yolov3.tf' # Путь до файла с checkpoint'ом.num_classes = 80 # Количество классов в модели.# Список слоев в YOLOv3 Fully Convolutional Network (FCN).YOLO_V3_LAYERS = [    'yolo_darknet',    'yolo_conv_0',    'yolo_output_0',    'yolo_conv_1',    'yolo_output_1',    'yolo_conv_2',    'yolo_output_2']

По причине того, что порядок слоев в Darknet (open source NN framework) и tf.keras разные, то загрузить веса с помощью чистого функционального API будет проблематично. В этом случае, наилучшим решением будет создание подмоделей в keras. TF Checkpoints рекомендованы для сохранения вложенных подмоделей и они официально поддерживаются Tensorflow.

# Функция для загрузки весов обученной модели.def load_darknet_weights(model, weights_file):    wf = open(weights_file, 'rb')    major, minor, revision, seen, _ = np.fromfile(wf, dtype=np.int32, count=5)    layers = YOLO_V3_LAYERS    for layer_name in layers:        sub_model = model.get_layer(layer_name)        for i, layer in enumerate(sub_model.layers):            if not layer.name.startswith('conv2d'):                continue            batch_norm = None            if i + 1 < len(sub_model.layers) and \                sub_model.layers[i + 1].name.startswith('batch_norm'):                    batch_norm = sub_model.layers[i + 1]            logging.info("{}/{} {}".format(                sub_model.name, layer.name, 'bn' if batch_norm else 'bias'))                        filters = layer.filters            size = layer.kernel_size[0]            in_dim = layer.input_shape[-1]            if batch_norm is None:                conv_bias = np.fromfile(wf, dtype=np.float32, count=filters)            else:                bn_weights = np.fromfile(wf, dtype=np.float32, count=4*filters)                bn_weights = bn_weights.reshape((4, filters))[[1, 0, 2, 3]]            conv_shape = (filters, in_dim, size, size)            conv_weights = np.fromfile(wf, dtype=np.float32, count=np.product(conv_shape))            conv_weights = conv_weights.reshape(conv_shape).transpose([2, 3, 1, 0])            if batch_norm is None:                layer.set_weights([conv_weights, conv_bias])            else:                layer.set_weights([conv_weights])                batch_norm.set_weights(bn_weights)    assert len(wf.read()) == 0, 'failed to read weights'    wf.close()

На этом же этапе, мы должны определить функцию для расчета IoU. Мы используем batch normalization (пакетная нормализация) для нормализации результатов, чтобы ускорить обучение. Так как tf.keras.layers.BatchNormalization работает не очень хорошо для трансферного обучения (transfer learning), то мы используем другой подход.

# Функция для расчета IoU.def interval_overlap(interval_1, interval_2):    x1, x2 = interval_1    x3, x4 = interval_2    if x3 < x1:        return 0 if x4 < x1 else (min(x2,x4) - x1)    else:        return 0 if x2 < x3 else (min(x2,x4) - x3)def intersectionOverUnion(box1, box2):    intersect_w = interval_overlap([box1.xmin, box1.xmax], [box2.xmin, box2.xmax])    intersect_h = interval_overlap([box1.ymin, box1.ymax], [box2.ymin, box2.ymax])    intersect_area = intersect_w * intersect_h    w1, h1 = box1.xmax-box1.xmin, box1.ymax-box1.ymin    w2, h2 = box2.xmax-box2.xmin, box2.ymax-box2.ymin    union_area = w1*h1 + w2*h2 - intersect_area    return float(intersect_area) / union_area class BatchNormalization(tf.keras.layers.BatchNormalization):    def call(self, x, training=False):        if training is None: training = tf.constant(False)        training = tf.logical_and(training, self.trainable)        return super().call(x, training)# Определяем 3 anchor box'а для каждой ячейки.   yolo_anchors = np.array([(10, 13), (16, 30), (33, 23), (30, 61), (62, 45),                        (59, 119), (116, 90), (156, 198), (373, 326)], np.float32) / 416yolo_anchor_masks = np.array([[6, 7, 8], [3, 4, 5], [0, 1, 2]])

В каждом масштабе мы определяем 3 anchor box'а для каждой ячейки. В нашем случае если маска будет:

• 0, 1, 2 означает, что будут использованы первые три якорные рамки

• 3, 4 ,5 означает, что будут использованы четвертая, пятая и шестая

• 6, 7, 8 означает, что будут использованы седьмая, восьмая, девятая

# Функция для отрисовки bounding box'ов.def draw_outputs(img, outputs, class_names, white_list=None):    boxes, score, classes, nums = outputs    boxes, score, classes, nums = boxes[0], score[0], classes[0], nums[0]    wh = np.flip(img.shape[0:2])    for i in range(nums):        if class_names[int(classes[i])] not in white_list:            continue        x1y1 = tuple((np.array(boxes[i][0:2]) * wh).astype(np.int32))        x2y2 = tuple((np.array(boxes[i][2:4]) * wh).astype(np.int32))        img = cv2.rectangle(img, x1y1, x2y2, (255, 0, 0), 2)        img = cv2.putText(img, '{} {:.4f}'.format(            class_names[int(classes[i])], score[i]),            x1y1, cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 2)    return img

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

Остаточные блоки (Residual Blocks) в диаграмме архитектуры YOLOv3 применяются для изучения признаков. Остаточный блок содержит в себе несколько сверточных слоев и дополнительные связи для обхода этих слоев.

Создавая нашу модель, мы строим нашу модель с помощью функционального API, который будет легко использовать. С его помощью мы можем без труда определить ветви в нашей архитектуре (ResNet Block) и делить слои внутри архитектуры.

def DarknetConv(x, filters, size, strides=1, batch_norm=True):    if strides == 1:        padding = 'same'    else:        x = ZeroPadding2D(((1, 0), (1, 0)))(x)        padding = 'valid'    x = Conv2D(filters=filters, kernel_size=size,              strides=strides, padding=padding,              use_bias=not batch_norm, kernel_regularizer=l2(0.0005))(x)    if batch_norm:        x = BatchNormalization()(x)        x = LeakyReLU(alpha=0.1)(x)    return xdef DarknetResidual(x, filters):    previous = x    x = DarknetConv(x, filters // 2, 1)    x = DarknetConv(x, filters, 3)    x = Add()([previous , x])    return xdef DarknetBlock(x, filters, blocks):    x = DarknetConv(x, filters, 3, strides=2)    for _ in repeat(None, blocks):        x = DarknetResidual(x, filters)           return xdef Darknet(name=None):    x = inputs = Input([None, None, 3])    x = DarknetConv(x, 32, 3)    x = DarknetBlock(x, 64, 1)    x = DarknetBlock(x, 128, 2)    x = x_36 = DarknetBlock(x, 256, 8)    x = x_61 = DarknetBlock(x, 512, 8)    x = DarknetBlock(x, 1024, 4)    return tf.keras.Model(inputs, (x_36, x_61, x), name=name)  def YoloConv(filters, name=None):    def yolo_conv(x_in):        if isinstance(x_in, tuple):            inputs = Input(x_in[0].shape[1:]), Input(x_in[1].shape[1:])            x, x_skip = inputs            x = DarknetConv(x, filters, 1)            x = UpSampling2D(2)(x)            x = Concatenate()([x, x_skip])        else:            x = inputs = Input(x_in.shape[1:])        x = DarknetConv(x, filters, 1)        x = DarknetConv(x, filters * 2, 3)        x = DarknetConv(x, filters, 1)        x = DarknetConv(x, filters * 2, 3)        x = DarknetConv(x, filters, 1)        return Model(inputs, x, name=name)(x_in)    return yolo_conv  def YoloOutput(filters, anchors, classes, name=None):    def yolo_output(x_in):        x = inputs = Input(x_in.shape[1:])        x = DarknetConv(x, filters * 2, 3)        x = DarknetConv(x, anchors * (classes + 5), 1, batch_norm=False)        x = Lambda(lambda x: tf.reshape(x, (-1, tf.shape(x)[1], tf.shape(x)[2],                                        anchors, classes + 5)))(x)        return tf.keras.Model(inputs, x, name=name)(x_in)    return yolo_outputdef yolo_boxes(pred, anchors, classes):    grid_size = tf.shape(pred)[1]    box_xy, box_wh, score, class_probs = tf.split(pred, (2, 2, 1, classes), axis=-1)    box_xy = tf.sigmoid(box_xy)    score = tf.sigmoid(score)    class_probs = tf.sigmoid(class_probs)    pred_box = tf.concat((box_xy, box_wh), axis=-1)    grid = tf.meshgrid(tf.range(grid_size), tf.range(grid_size))    grid = tf.expand_dims(tf.stack(grid, axis=-1), axis=2)    box_xy = (box_xy + tf.cast(grid, tf.float32)) /  tf.cast(grid_size, tf.float32)    box_wh = tf.exp(box_wh) * anchors    box_x1y1 = box_xy - box_wh / 2    box_x2y2 = box_xy + box_wh / 2    bbox = tf.concat([box_x1y1, box_x2y2], axis=-1)        return bbox, score, class_probs, pred_box

Теперь определим функцию подавления не-максимумов.

def nonMaximumSuppression(outputs, anchors, masks, classes):    boxes, conf, out_type = [], [], []    for output in outputs:        boxes.append(tf.reshape(output[0], (tf.shape(output[0])[0], -1, tf.shape(output[0])[-1])))        conf.append(tf.reshape(output[1], (tf.shape(output[1])[0], -1, tf.shape(output[1])[-1])))        out_type.append(tf.reshape(output[2], (tf.shape(output[2])[0], -1, tf.shape(output[2])[-1])))    bbox = tf.concat(boxes, axis=1)    confidence = tf.concat(conf, axis=1)    class_probs = tf.concat(out_type, axis=1)    scores = confidence * class_probs      boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(        boxes=tf.reshape(bbox, (tf.shape(bbox)[0], -1, 1, 4)),        scores=tf.reshape(            scores, (tf.shape(scores)[0], -1, tf.shape(scores)[-1])),        max_output_size_per_class=100,        max_total_size=100,        iou_threshold=yolo_iou_threshold,        score_threshold=yolo_score_threshold)      return boxes, scores, classes, valid_detections

Основная функция:

def YoloV3(size=None, channels=3, anchors=yolo_anchors,            masks=yolo_anchor_masks, classes=80, training=False):    x = inputs = Input([size, size, channels])    x_36, x_61, x = Darknet(name='yolo_darknet')(x)    x = YoloConv(512, name='yolo_conv_0')(x)    output_0 = YoloOutput(512, len(masks[0]), classes, name='yolo_output_0')(x)    x = YoloConv(256, name='yolo_conv_1')((x, x_61))    output_1 = YoloOutput(256, len(masks[1]), classes, name='yolo_output_1')(x)    x = YoloConv(128, name='yolo_conv_2')((x, x_36))    output_2 = YoloOutput(128, len(masks[2]), classes, name='yolo_output_2')(x)    if training:        return Model(inputs, (output_0, output_1, output_2), name='yolov3')    boxes_0 = Lambda(lambda x: yolo_boxes(x, anchors[masks[0]], classes),                  name='yolo_boxes_0')(output_0)    boxes_1 = Lambda(lambda x: yolo_boxes(x, anchors[masks[1]], classes),                  name='yolo_boxes_1')(output_1)    boxes_2 = Lambda(lambda x: yolo_boxes(x, anchors[masks[2]], classes),                  name='yolo_boxes_2')(output_2)    outputs = Lambda(lambda x: nonMaximumSuppression(x, anchors, masks, classes),                  name='nonMaximumSuppression')((boxes_0[:3], boxes_1[:3], boxes_2[:3]))    return Model(inputs, outputs, name='yolov3')

Функция потерь:

def YoloLoss(anchors, classes=80, ignore_thresh=0.5):    def yolo_loss(y_true, y_pred):        pred_box, pred_obj, pred_class, pred_xywh = yolo_boxes(            y_pred, anchors, classes)        pred_xy = pred_xywh[..., 0:2]        pred_wh = pred_xywh[..., 2:4]        true_box, true_obj, true_class_idx = tf.split(            y_true, (4, 1, 1), axis=-1)        true_xy = (true_box[..., 0:2] + true_box[..., 2:4]) / 2        true_wh = true_box[..., 2:4] - true_box[..., 0:2]        box_loss_scale = 2 - true_wh[..., 0] * true_wh[..., 1]        grid_size = tf.shape(y_true)[1]        grid = tf.meshgrid(tf.range(grid_size), tf.range(grid_size))        grid = tf.expand_dims(tf.stack(grid, axis=-1), axis=2)        true_xy = true_xy * tf.cast(grid_size, tf.float32) - \            tf.cast(grid, tf.float32)        true_wh = tf.math.log(true_wh / anchors)        true_wh = tf.where(tf.math.is_inf(true_wh),                      tf.zeros_like(true_wh), true_wh)        obj_mask = tf.squeeze(true_obj, -1)        true_box_flat = tf.boolean_mask(true_box, tf.cast(obj_mask, tf.bool))        best_iou = tf.reduce_max(intersectionOverUnion(            pred_box, true_box_flat), axis=-1)        ignore_mask = tf.cast(best_iou < ignore_thresh, tf.float32)        xy_loss = obj_mask * box_loss_scale * \            tf.reduce_sum(tf.square(true_xy - pred_xy), axis=-1)        wh_loss = obj_mask * box_loss_scale * \            tf.reduce_sum(tf.square(true_wh - pred_wh), axis=-1)        obj_loss = binary_crossentropy(true_obj, pred_obj)        obj_loss = obj_mask * obj_loss + \            (1 - obj_mask) * ignore_mask * obj_loss        class_loss = obj_mask * sparse_categorical_crossentropy(            true_class_idx, pred_class)        xy_loss = tf.reduce_sum(xy_loss, axis=(1, 2, 3))        wh_loss = tf.reduce_sum(wh_loss, axis=(1, 2, 3))        obj_loss = tf.reduce_sum(obj_loss, axis=(1, 2, 3))        class_loss = tf.reduce_sum(class_loss, axis=(1, 2, 3))        return xy_loss + wh_loss + obj_loss + class_loss    return yolo_loss

Функция "преобразовать цели" возвращает кортеж из форм:

(    [N, 13, 13, 3, 6],    [N, 26, 26, 3, 6],    [N, 52, 52, 3, 6])

Где N число меток в пакете, а число 6 означает [x, y, w, h, obj, class] bounding box'а.

@tf.functiondef transform_targets_for_output(y_true, grid_size, anchor_idxs, classes):    N = tf.shape(y_true)[0]    y_true_out = tf.zeros(      (N, grid_size, grid_size, tf.shape(anchor_idxs)[0], 6))    anchor_idxs = tf.cast(anchor_idxs, tf.int32)    indexes = tf.TensorArray(tf.int32, 1, dynamic_size=True)    updates = tf.TensorArray(tf.float32, 1, dynamic_size=True)    idx = 0    for i in tf.range(N):        for j in tf.range(tf.shape(y_true)[1]):            if tf.equal(y_true[i][j][2], 0):                continue            anchor_eq = tf.equal(                anchor_idxs, tf.cast(y_true[i][j][5], tf.int32))            if tf.reduce_any(anchor_eq):                box = y_true[i][j][0:4]                box_xy = (y_true[i][j][0:2] + y_true[i][j][2:4]) / 2                anchor_idx = tf.cast(tf.where(anchor_eq), tf.int32)                grid_xy = tf.cast(box_xy // (1/grid_size), tf.int32)                indexes = indexes.write(                    idx, [i, grid_xy[1], grid_xy[0], anchor_idx[0][0]])                updates = updates.write(                    idx, [box[0], box[1], box[2], box[3], 1, y_true[i][j][4]])                idx += 1    return tf.tensor_scatter_nd_update(        y_true_out, indexes.stack(), updates.stack())def transform_targets(y_train, anchors, anchor_masks, classes):    outputs = []    grid_size = 13    anchors = tf.cast(anchors, tf.float32)    anchor_area = anchors[..., 0] * anchors[..., 1]    box_wh = y_train[..., 2:4] - y_train[..., 0:2]    box_wh = tf.tile(tf.expand_dims(box_wh, -2),                    (1, 1, tf.shape(anchors)[0], 1))    box_area = box_wh[..., 0] * box_wh[..., 1]    intersection = tf.minimum(box_wh[..., 0], anchors[..., 0]) * \    tf.minimum(box_wh[..., 1], anchors[..., 1])    iou = intersection / (box_area + anchor_area - intersection)    anchor_idx = tf.cast(tf.argmax(iou, axis=-1), tf.float32)    anchor_idx = tf.expand_dims(anchor_idx, axis=-1)    y_train = tf.concat([y_train, anchor_idx], axis=-1)    for anchor_idxs in anchor_masks:        outputs.append(transform_targets_for_output(            y_train, grid_size, anchor_idxs, classes))        grid_size *= 2    return tuple(outputs) # [x, y, w, h, obj, class]def preprocess_image(x_train, size):    return (tf.image.resize(x_train, (size, size))) / 255

Теперь мы можем создать нашу модель, загрузить веса и названия классов. В COCO датасете их 80.

yolo = YoloV3(classes=num_classes)load_darknet_weights(yolo, weightyolov3)yolo.save_weights(checkpoints)class_names =  ["person", "bicycle", "car", "motorbike", "aeroplane", "bus", "train", "truck",    "boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench",    "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe",    "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard",    "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard",    "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl",    "banana","apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut",    "cake","chair", "sofa", "pottedplant", "bed", "diningtable", "toilet", "tvmonitor", "laptop",     "mouse","remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink",    "refrigerator","book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush"]def detect_objects(img_path, white_list=None):    image = img_path     # Путь к изображению.    img = tf.image.decode_image(open(image, 'rb').read(), channels=3)    img = tf.expand_dims(img, 0)    img = preprocess_image(img, size)    boxes, scores, classes, nums = yolo(img)    img = cv2.imread(image)    img = draw_outputs(img, (boxes, scores, classes, nums), class_names, white_list)    cv2.imwrite('detected_{:}'.format(img_path), img)    detected = Image.open('detected_{:}'.format(img_path))    detected.show()    detect_objects('test.jpg', ['bear'])

Итог

В этой статье мы поговорили об отличительных особенностях YOLOv3 и её преимуществах перед другими моделями. Мы рассмотрели способ реализации с использованием TensorFlow 2.0 (TF должен быть не менее версией 2.0).

Ссылки

• Полная реализация YOLOv3 на Tensorflow 2.0

• Реализация YOLOv3 из текущей статьи

• YOLOv3 - Joseph Redmon

Как люди уже стали киборгами и используют AI

Привет, хабровчане.

AI (Artificial Intelligence, ИИ Искусственный Интеллект) как Аугментативный Интеллект (Augmentative Intelligence), использующий машинное обучение, алгоритмы и обширныеданные для расширения возможностей человека и бизнеса, вскоре может стать иллюзией.

Ускоряющиеся темпы технологических изменений дают людям возможность иметь как технологические ресурсы, так и научные знания для создания Искусственного Общего Интеллекта (Artificial General Intelligence).

Успех в создании эффективного ИИ может стать величайшим событием в истории нашей цивилизации. Или наихудшим. Мы просто не знаем. Поэтому мы не можем точно знать, будет ли ИИ помогать нам бесконечно, или же он будет игнорировать и пренебрегать нами, а может быть и уничтожит нас. слова Стивена Хокинга в 2017 году.

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

Большая часть этих данных создается людьми.

Как часто вы в своей жизни записываете, оцифровываете и, в конце концов, делитесь этим?

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

Люди, по сути, уже "киборги", потому что у них есть третичный "цифровой слой" благодаря телефонам, компьютерам и приложениям слова Илона Маска в 2021 году.

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

Нет времени смотреть в прошлое, мы слишком часто заняты тем, чтобы вести запись настоящего.

Сегодня, с приходом Covid-19, мир становится намного более цифровым благодаря тому, что данные передаются через периферию интернета быстрее, в том числе и благодаря 5G, позволяя развивать скорость до 10 Gbps.

Смартфоны и датчики вокруг нас получили доступ к высокоскоростному интернету. Фактически исчезает последняя миля (передача данных от оборудования конечного клиента до последнего сетевого узла провайдера) с медленным WiFi или кабельным подключением.

По мере того, как мы привыкаем к новым реалиям в ситуации с Covid-19, социальная дистанция ускоряет оцифровку наших записей в большом объёме. Когда это в конечном итоге закончится, наше общее пространство станет гораздо более опустошенным, чем оно когда-то было.

Однако, как социальным субъектам, нам необходимо объединиться, чтобы выжить. Мы поддерживаем связь из дома. Деятельность из дома в значительной степени стала новым способом работы. Дети получают школьное образование онлайн. Родители работают дома.

Мы видим, как происходят огромные изменения в интернете. Резко возросло создание контента. Скорость взаимодействия с контентом также стремительно растет. Люди жаждут смотреть новые фильмы и поиграть в новые игры. Развлекательная и игровая индустрии развиваются.

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

С разрушением индустрии туризма возникает виртуальное путешествие. Люди проектируют виртуальную реальность с передачей голограмм, в том числе и для спортивных аттракционов.

Мы являемся свидетелями революции в здравоохранении, когда появились устройства IoT для дистанционной цифровой диагностики.

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

Надкусив яблоко и оценив его вкус, мы не можем остановиться, пока не доедим его. То есть, чем чаще мы полагаемся на ИИ, тем сильнее ощущаем на себе зависимость от него.

Сегодня исследователи ИИ, изучая персональные характеристики людей, могут вплотную приблизиться к реализации Слабого ИИ (Weak AI), имитирующего человеческое поведение. В настоящее время эти программы позволяют компьютерам понимать человеческую речь, распознавать объекты, описывать фотографии и видео, рекомендовать музыку или проводить поиск.

Сильный ИИ (Strong AI) преобразовывает машинный интеллект в универсальный интеллект. Поскольку человеческий интеллект это универсальный интеллект, искусственный интеллект часто называют общим искусственным интеллектом (Artificial General Intelligence, AGI).

Общий искусственныйинтеллект (AGI) наделил бы машины неалгоритмическими способностями, такими как благоразумие и мудрость. Благоразумие это способность принимать правильные решения в конкретных ситуациях, а мудрость это способность видеть целое.

Я думаю, что это десятилетие приведет к революции в создании AGI по трем причинам:

• стремительно растущему созданию контента и обмену им. Люди оцифровывают большинство областей своей частной жизни с экспоненциальной скоростью благодаря социальному дистанцированию, более скоростному подключению к Интернету с помощью 5G, широкополосным спутниковым интернет-системам, таким как Starlink. Скоро появится возможность отслеживать данные от детства до старости для очень большого количества людей, разбросанных по географиям и культурам. Многочисленные данные это живительная сила искусственного интеллекта.

• критическая масса специалистов по ИИ. Люди исследуют и применяют ИИ во все большем числе случаев. Количество журнальных публикаций и докладов конференций выросло с 52 000 в 2000 году до примерно 403 000 в 2019 году, что представляет собой увеличение глобального объема исследований в области ИИ более чем на 600%.

• достижение квантового превосходства. Квантовые вычисления позволят будущим компьютерам обрабатывать невероятные объемы большого объема данных. Компания Google заявила, что докажет превосходство квантовых вычислений в 2019 году, и у IonQ есть план по коммерциализации квантовых вычислений.

. . .

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

Прямо сейчас в OTUS открыт набор на курс Разработчик IoT.

В связи с этим приглашаем всех желающих записаться на открытый вебинар Практика IoT: создаем проект по шерингу самокатов. На этом бесплатном демо-занятии:
- обсудим наиболее перспективные приложения Интернета вещей в разных сферах;
- познакомимся с облачной платформой Rightech IoT Cloud;
- создадим свой проект по шерингу самокатов;
- будем эмулировать данные сервисом ботов;
- применим постобработку данных;
- сформируем сценарии автоматизации.

ЗАПИСАТЬСЯ НА ДЕМО-УРОК

В данной статье будут подниматься темы построения пользовательских слоёв нейронных сетей, использование автоматического дифференцирования и работы со стандартными слоями глубокого обучения нейронных сетей в MATLABна основе классификатора с использованием пространственной трансформационной сети.

SpatialTransformerNetwork(STN) один из примеров дифференцируемых LEGO-модулей, на основе которых можно строить и улучшать свою нейросеть. STN, применяя обучаемое аффинное преобразование с последующей интерполяцией, лишает изображения пространственной инвариантности. Грубо говоря, задача STNсостоит в том, чтобы так повернуть или уменьшить/увеличить исходное изображение, чтобы основная сеть-классификатор смогла проще определить нужный объект. Блок STNможет быть помещен в сверточную нейронную сеть (CNN), работая в ней по большей части самостоятельно, обучаясь на градиентах, приходящих от основной сети (более детально с данной темой можно ознакомиться по ссылкам: Хабри Мануал).

В нашем случае задачей является классифицировать 99 классов лобовых стёкол автомобилей, но, для начала, начнём с чего-нибудь попроще. Для того, чтобы ознакомится с данной тематикой возьмём базу данных MNIST из рукописных цифр и построим сеть из нейронных слоёв глубокого обучения MATLABи пользовательского слоя аффинной трансформации изображения (ознакомиться со списком всех имеющихся слоёв и их функционалом можно по ссылке).

Для реализации пользовательского слоя трансформации мы воспользуемся шаблоном пользовательского слоя и возможностью MATLABдля автоматического дифференцирования и построения обратного распространения производной от ошибки, которая реализуется за счёт массивов глубокого обучения для пользовательских учебных циклов - dlarray(ознакомиться с шаблоном можно по ссылке, ознакомиться с dlarrayструктурами можно по ссылке).

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

Поскольку аффинное преобразование является обратимым, самым простым способом проверки корректности работы функции является наложение трансформации на изображение, а затем нахождение обратной матрицы и выполнение повторной трансформации. Как мы видим на представленном ниже изображении, наш алгоритм работает корректно. Слева у нас входные изображения, справа выходные, сверху - над правыми изображениями - подписана наложенная на изображение трансформация.

Также важно уточнить, какие конкретно изменения накладываются на изображения разными числами матрицы преобразования. Первая строка накладывает трансформации по оси Y, а вторая по Х. Параметры выполняют изменение размера (приближение, отдаление), поворот и смещение изображения. Более детально матрица трансформации описана в таблице.

Теперь, когда мы разобрались с теоретической составляющей, перейдём к реализации сети с использованием STN. На рисунках ниже представлены структура построенной сети и результаты обучения для базы данных MNIST.

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

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

Первое различие между входными данными это то, что числа это изображения в градиенте серого, а стёкла изображения формата RGB, следовательно, нам необходимо изменить слой трансформации, добавив цикл. Будем применять отдельно трансформацию к каждому из слоёв изображения. Также, для упрощения обучения, добавим в слой трансформации веса, на которые будем домножать матрицу трансформации, и установим эти веса в 2, за исключением весов смещения изображения, их установим в 0, для того чтобы сеть училась, в первую очередь, поворачивать и изменять масштаб изображения. Также, если взять данные веса меньше, то сеть дольше будет перестраивать веса STNв поисках полезной информации, так как полезная информация у нас находится по краям изображения, а не в центре, в отличии от сети с числами. Далее нам необходимо заменить часть классификатора, так как он является слишком слабым для наших входных данных. Чтобы не изменять структуру самого STN- мы приведём изображение к виду, похожему на числа, добавив слой нормализации и dropoutдля уменьшения объёма входных данных в STN.

Сравнивая данные на входе у сети с числами и стёклами, можно увидеть, что на стёклах диапазон значений варьируется от [0;255], а в числах от [0;1], а также в числах большая часть матрицы это нули. Примеры данных на входе показаны ниже.

Опираясь на вышеприведённые данные, нормализация будет выполняться по принципу деления входных данных на 255 и обнуления всех значений меньше 0.3 и больше 0.75, а также от трёхмерного изображения мы оставим только одно измерение. На изображении ниже видно, что подаётся на входе и что остаётся после слоя нормализации.

Также в связи с тем, что у нас не так много данных для тестирования и обучения сети, мы искусственно увеличим их объём за счёт аффинной трансформации, а именно, поворота изображения на случайный градус в пределах [-10;10] и прибавления случайного числа к матрице изображения для изменения цветовой палитры в пределах [-50; 50]. В функции чтения мы воспользуемся стандартными функциями MATLAB, так как в ней нам не требуется оперировать dlarrayструктурами. Ниже представлена используемая функция чтения входных изображений.

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

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

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

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

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

Хм. Один из пунктов, регламентирующих действия модераторов на Хабре, сформулирован следующим образом: не надо пропускать статьи, слабо относящиеся к IT-тематике или не относящиеся к ней вовсе. Что сходу заставило автора призадуматься, а имеет ли прямое отношение к "IT-тематике" его пост, повествующий о некоторых этапах программирования забавного и увлекательного своего pet-проекта, несложного AI, выстраивающего нейронную сеть на основе ruby-обертки FANN для игры в крестики-нолики? Вопрос не содержит скрытого кокетства, ведь описанию логики программного кода в моем рассказе предназначено далеко не первостепенное значение. "Да это злая ирония!" скажете вы. Не знаю.

ОК. Данная разработка де-факто является иллюстрацией ряда странных наблюдений автора, некоторое число знакомых и даже друзей-приятелей которого в последние годы... заставили его припомнить уроки литературы своей когда-то в бытность очень-очень средней советской школы. Несмотря на перманентное его убеждение в том, что "проходить" всегда возможно только лишь мимо чего-то - некие персонажи русской классики вспоминаются с течением времени все чаще. Или, может статься, так и должно быть?

Итак, с места в карьер... после первого запуска программа начинает процесс самообучения, проигрывая сама с собой несколько десятков (минута - две максимум) тысяч партий (число, понятное дело, доступно для редактирования в конфиге; учитывая описываемый далее не вполне обычный алгоритм, положенный в основу логики этого AI - эксперименты такого рода также способны предоставить интересный материал для умозаключений). Здесь имитируется процесс обучения, свойственный многим другим Artificial Intelligence, с той лишь разницей, что оба "игрока" в равной степени играть не умеют, делая абсолютно рандомные ходы. Но правила игры действуют: если случайный ход не соответствует, программа обязана переходить, соответственно и выигрыш достанется той стороне, которая выиграет. Все честно: никаких подчисток и хаков, скрытых предпочтений, никаких тебе фейковых допинг-проб, зачастую в реальной жизни опрокидывающих результаты спортивных игр.

Далее начинается игра с пользователем: логированный в csv-файл протокол игр преобразуется в массив, и AI, играющий вторым номером (ноликами) решает философическую, до странности в чем-то очень российскую задачку, пытаясь выудить из абсурда и хаоса случайных ходов те, которые позволят выиграть или как минимум свести к ничьей игру с живым и вполне логично мыслящим противником.

Забавно, не правда ли? В процессе кодинга из головы не выходил диалог с одним из приятелей, чье мироощущение носит отчетливые черты героев Франца Кафки: весь мир для него состоит из случайных, заведомо неподвластных логическому анализу проявлений. Интересно, что любые попытки объяснить ему суть понятия аппроксимирующих функций встречают яростный отпор, полнейшее эмоциональное (думаю, здесь что-то навроде фрейдовского "вытеснения") неприятие: из многообразия значений любой жизненной "функции" моему приятелю свойственно выдирать сугубо одно, которое и представляет для него в дальнейшем психологическую ценность в качестве результата такой вот своеобразной интерполяции... кодинг игрушки, о котором этот рассказ, в немалой степени проходил под впечатлением нашего с ним общения.

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

Итак. Примем на минутку предложенную точку зрения: мир заведомо непознаваем, события случайны и призрачны. Опереться, таким образом, не на что, у нашей программки практически нет точек опоры в виде той или иной стратегии, она располагает лишь записями случайных ходов, каждая из которых снабжена, правда, еще и сопутствующей информацией: общее количество ходов и итог игры (выигрыш/проигрыш). Сумеет ли наш виртуальный игрок-нигилист, отказавшийся от несложной и эффективной логики игры на основе известных стратегий Tic Tac Toe - построить собственную стратегию, хотя бы мало-мальски успешную? Оказывается - да, вполне. Полученный результат сложно назвать инновационным и многообещающим, это, скорее, пародия на образ мыслей современного кафкианца, чем-то напоминающая историю барона Мюнхгаузена, тщащегося вытащить самого себя из болота за волосы, помните?... кстати, слово "болото" здесь удачно продолжает использованную аналогию; повторюсь, "точки опоры" у значительной части нашего с вами современного социума, как показывает житейская практика - "при наличии отстутствия", данное утверждение легко проверяется на многочисленных параноидальных мифах, от отрицания ковида и до злополучного "а вот не докажете!".

Попробуем аргументировать сказанное, хотя бы в контексте простенького нашего Artificial Intelligence. Как думаете, какой ход в любой момент игровой ситуации на поле 3x3, используемом для игры в крестики-нолики, является безусловно оптимальным? Или, иными словами, если у вас перед глазами лог игры, что именно вам необходимо, чтобы, задержав взгляд на строчке, описывающей очередной ход, и не читая далее - уверенно заявить, что в данной ситуации этот ход наилучший? Поставьте себя на место AI, вся "интеллектуальная мощь" которого заключена в нескольких коротких скриптах; здесь необходимо что-то совсем простое и безошибочное, без долгих логических рассуждений и необходимости просчитывать на несколько ходов вперед.

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

        if row[6].to_i - row[3].to_i == 1            x_data.push([row[0].to_i])            y_data.push([1]) # Присваиваем высший приоритет, т.е. максимально возможный вес, переопределяя начальный.        end

А как отыскать и исключить худший из возможных ходов? - также несложно. Если ход предпоследний, т.е. выигрывает ваш противник. Возражений нет?

Внезапно, в самый разгар работы над Tic Tac Toe AI with Neural Network пазл сложился (это я уже не о кодинге). Разгадка оказалась удручающе простой, но путь к ней длинен и непрост: суть в том, что ни малейших попыток понимания в данном случае как и в случаях иных не было у моего знакомого и в помине. Странный объект моих отнюдь непрограммистских изысков жил в собственном мире, будто в бункере, видя во внешних объектах лишь проекции, разнообразные и разрозненные частички самого себя.

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

Поясню. Понимание"... скажите, как вы понимаете этот термин? в целях экономии времени приведу краткую, в рамках википедии, формулировку: универсальная операция мышления, связанная с усвоением нового содержания, включением его в систему устоявшихся идей и представлений. Ирония ситуации в том, что нового содержания у моего приятеля не было и быть не могло; нет для него никаких внешних объектов, которые возможно было бы постигать и далее включать в систему идей и представлений. Существует только он один или, вернее сказать, он в центре; все остальное вокруг представляется невзрачными тенями, проекциями тех или иных его аффектов. Звучит абсурдно, но, увидев на столичной улице очередную автомобильную пробку, забитую отнюдь не бюджетными авто, персонаж моих психоаналитических исследований неизменно приходил к выводу о том, что экономического кризиса в стране нет, и быть, в силу им увиденного, не может: никакой статистики или аналитики не существует, для меня есть только то, что я вижу или могу потрогать.

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

Немалую опасность для живущего в мире иллюзорной Матрицы виртуального игрока в крестики-нолики представляют вилки (просчитывать ситуацию на доске хотя бы на один - два хода вперед явно не наш life style). Что же, поиском вилок сейчас и попробуем заняться:

  WINNING_TRIADS = [    [0, 1, 2],    [3, 4, 5],    [6, 7, 8],    [0, 3, 6],    [1, 4, 7],    [2, 5, 8],    [6, 4, 2],    [0, 4, 8]  ].freeze

Далее, при формировании csv-лога ходов, ищем:

  def fork?    WINNING_TRIADS.select do |x|      @board[x[0]] == @board[x[1]] && @board[x[2]].class != @board[x[0]].class &&        place_x?(x[0]) ||        @board[x[1]] == @board[x[2]] && @board[x[0]].class != @board[x[2]].class &&          place_x?(x[1]) ||        @board[x[0]] == @board[x[2]] && @board[x[1]].class != @board[x[2]].class &&          place_x?(x[0])    end  end

Таким образом, если комбинация найдена два раза...

  if @game.fork?.size > 1

...вилка найдена.

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

Определим ряд потенциально опасных ситуаций:

  DANGEROUS_SITUATIONS_1 = [    [6, 4, 2],    [0, 4, 8]  ].freeze  DANGEROUS_SITUATIONS_2 = [    [0, 4, 7],    [0, 4, 5],    [2, 4, 3],    [2, 4, 7],    [3, 4, 8],    [1, 4, 8],    [1, 4, 6],    [5, 4, 6]  ].freeze

  def fork_danger_1?    DANGEROUS_SITUATIONS_1.detect do |x|      @board[x[0]] == @board[x[2]] &&        @board[x[0]] != @board[x[1]]    end  end    def fork_danger_2?    DANGEROUS_SITUATIONS_2.detect do |x|      @board[x[0]] == @board[x[2]] &&        @board[x[0]] != @board[x[1]]    end  end  def fork_danger_3?    DANGEROUS_SITUATIONS_1.detect do |x|      @board[x[0]] != @board[x[2]] &&        @board[x[1]] == @board[x[2]]    end  end

И, соответственно, создадим три массива, в которые, при анализе ситуации на доске, AI станет помещать удовлетворяющие условиям ходы: 1. однозначно неприемлемые, 2. потенциально приводящие к вилке и 3. атакующие (т.е. те, в силу которых противник вынужден, во избежание немедленного проигрыша, реализовать единственно возможный для него ход). Разумеется, массивы будут иногда пересекаться, учтем это при построении логики игры. Кроме того, последнее слово за Neural Network.

  array_of_games.each do |row|      row.each do |e|        next unless e == current_position        if row[6].to_i - row[3].to_i == 2 && row[4] == 'O' && row[2].to_f != 0.2          unacceptable_moves_array << row[0]        # Find moves that inevitably lead to a fork:        elsif fork_danger_1 && row[3].to_i == 3 && row[0].to_i.odd?          unacceptable_moves_array << row[0]        elsif (fork_danger_2 || fork_danger_3) && row[3].to_i == 3 && row[0].to_i.even?          unacceptable_moves_array << row[0]        end        next if row[5].nil?        # Find moves that may lead to a fork:        array_of_moves_to_fork << row[0] if row[3].to_i == row[5].to_i        # Find attacking moves:        attack_moves_array << row[0] if row[3].to_i == row[5].to_i && row[6].to_i < 7      end    end

Повторюсь, удалось бы обойтись без костылей, если бы массив игр, используемый AI для анализа, не формировался практически полностью рандомно. Но... я ведь оговорил с самого начала, данный программный код родился как иллюстрация рефлексий автора, родившегося в стране Онегина, Печорина, Базарова... к слову, герои "Бесов" Достоевского и несколько более симпатичный Феличе Риварес из книги Войнич тоже ведь в этом перечне. Некий исторический сарказм присутствует в том, что, судя по прочитанному и перечитанному уже много позже школы - российский нигилизм претерпел значительные изменения в своей, так сказать, результирующей... не замечали? - а вы припомните незабвенное "разговаривают, разговаривают, контрреволюция одна", сумеете проследить немало аллюзий и аналогий с нашим днем.

 array_of_games.each do |row|      row.each do |e|        next unless e == current_position        next if arrays[0].include?(row[0])        unless arrays[1].include?(row[0]) && !arrays[2].include?(row[0])          if row[6].to_i - row[3].to_i == 1            x_data.push([row[0].to_i])            y_data.push([1])          elsif row[6].to_i - row[3].to_i == 3            if arrays[2].include?(row[0])              x_data.push([row[0].to_i])              y_data.push([0.9])            elsif arrays[1].include?(row[0])              x_data.push([row[0].to_i])              y_data.push([0.3])            end          else            x_data.push([row[0].to_i])            y_data.push([row[2].to_f])          end        end      end

Сухой остаток скармливаем нейронке:

    data = nn_data(board, fork_danger_1, fork_danger_2, fork_danger_3, array_of_games)    fann_results_array = []      train = RubyFann::TrainData.new(inputs: data[0], desired_outputs: data[1])      model = RubyFann::Standard.new(        num_inputs: 1,        hidden_neurons: [4],        num_outputs: 1      )      model.train_on_data(train, 5000, 500, 0.01)      data[0].flatten.each do |i|        fann_results_array << model.run([i])      end    result = data[0][fann_results_array.index(fann_results_array.max)]

Интересная деталь: в одной и той же игровой ситуации на доске (и с одним и тем же csv-файлом) этот Neural Network способен выдавать различные варианты ходов.

В итоге - у вас максимум ничья, минимум - проигрыш, выиграть не получится. Разве что подведет рандомно сгенерированный csv-файл (такое случается, но нечасто), который в редком случае вашего выигрыша оптимально пересоздать. Впрочем, описанная ревизия кода - или не только кода - может статься, вовсе не окончательная, итоги подводить рано.

P.S. Описанный код всегда доступен полностью (а не фрагментарно, как диктует формат статьи) в моем гитхабе, разумеется, любой желающий может сделать git clone и поэкспериментировать с кодом, ну или просто поиграть. Я не сторонник запуска ruby-application под виндой, это очень не лучшая идея, но в данном случае работать будет, попробовал. Возможно, получится чуть менее эффектно, чем в консоли линукса, но логика отработает.

Всем добрейшего дня! Совсем недавно закончилось ежегодное международное соревнование AI Contest, организатором которого является Сбер вместе с российскими и зарубежными партнёрами в рамках конференции Artificial Intelligence Journey. Задачи этого года: Digital Петр: распознавание рукописей Петра I, NoFloodWithAI: паводки на реке Амур и AI 4 Humanities: ruGPT-3. В этот раз в соревновании участвовало около 1000 человек из 43 государств.

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

План

• Описание задачи

• Этапы решения

  1. Предобработка данных

  2. Описание нейронной сети

  3. Аугментации

  4. CharMasks

  5. Spell correction using XLMRoberta

  6. Ensemble + Spell Correction Thresholds

• Что не сработало

• Команда

• Заключение

Описание задачи

Если без воды, то: Необходимо перевести строку, написанную от руки Петром I, в печатный формат (см. пример ниже). Организаторы совместно с историками подготовили данные, разбив документы построчно, где каждая строка - картинка и ей соответствует текстовый файл с расшифровкой.

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

Этапы решения

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

1. Предобработка данных

Выбросили картинки, на которых очевидно не верна разметка (нашли с помощью OOF), удалили редкие символы. Так как Пётр писал не только горизонтально (как на картинках выше), но и на полях (как на картинке ниже), то в данных присутствовали картинки с вертикальными надписями, которые нужно было перевернуть либо на +90, либо на -90 градусов. Для поворота картинок мы обучили сеть (Resnet34 с изменённой головой) которая предсказывала есть ли необходимость поворачивать картинку и в какую сторону. Это необходимо для того, чтобы поворачивать картинки на скрытых данных.

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

2. Описание нейронной сети

Мы рассматривали два варианта архитектур нейронных сетей, одну под CTCLoss и другую на классическом Attention. Отдельно про CTCLoss можно посмотреть тут, а про Attention почитать тут. Начали с CTCLoss, но на нём и остались, так как на подход с Attention не хватило времени. Сразу покажу картинку.

Где Bs - размер батча, (w, h, c) - параметры изображения (ширина, высота, каналы). Штрихи указывают на производные параметры от исходных. Hidden size - размер скрытого слоя в LSTM слое. Dict Size - количество буковок, которые будет знать наша нейронка. Dense - слой полносвязной сети в Keras, аналог Linear в PyTorch.

3. Аугментации

Что такое аугментации, как их применять можно посмотреть тут и тут. Мы использовали стандартные аугментации: ToGray, CLAHE, Rotate, CutOut.

Однако CutOut мы в середине соревнования заменили на другую аугментацию. Мы написали её сами, назвали HandWrittenBlots, суть в том, что это имитация человеческой почеркушки с различным размером, наклоном и прозрачностью. Сделано это для того, чтобы улучшить (кто бы мог подумать) распознавание перечёркнутых букв. CutOut накидывал, HandWrittenBlots накинул еще больше. Аугментацию можно найти в репозиторииAugmixations. Пример использования тут.

P.S. Форма вырезанных прямоугольников в CutOut тут такая потому, что параметры были подобраны эмпирически и вертикальные тонкие прямоугольники докидывали больше всего.

4. CharMasks

Это крутая штука, которая возможна, когда используешь CTC Loss. Дело в том, после предсказания моделью последовательности символов, есть возможность разбить входную картинку по этим символам, пропорционально размеру выходной последовательности (руками разбивать картинки конечно тоже можно, но это совсем прохладная история). Для этого нужно использовать координаты стыков различных букв (Именно так делали ребята для Action Labeling тут).

Таким образом мы получаем координаты начала и конца каждого символа. А затем, имея координаты всех символов во всех строках датасета, мы можем сами генерировать любую фразу почерком Петра. Вопрос остаётся в том, что нам пока негде брать древнерусские фразочки. Поэтому мы идём в гугл и нагугливаем книжки с текстами XVII-XVIII веков (Да, их тоже надо почистить и обработать). И уже теперь, с чистой совестью, достаём любую фразу из нашего корпуса текстов и составляем по ней картинку.

Да, она будет не идеальна, и если генерировать изображения, используя однобуквенные символы, то скор это не улучшит. Но тут в дело вступают токенизаторы. Обучаем мы их на предложениях из имеющегося датасета, в котором у нас есть соответствующие картинки. Таким образом для каждого токена мы теперь можем получить картинку. Далее с помощью токенизаторов (Multi Word Expression) мы можем составлять фразы из токенов (состоящих из нескольких символов и пробелов) различной длины и генерировать соответствующую картинку.

Далее еще поработали с цветом бумаги, для того чтобы сделать его более однородным и естественным, т.к. сами понимаете, что цвет бумаги в датасете от картинки к картинке совершенно разный. В результате получилось как-то так:

5. Spell correction using XLMRoberta

Сразу скажу, что в этом пункте много текста.

Естественно, нашасупермегапаверфьюженстелскрутаямодель не предсказывает идеальные предложения и всё же делает некоторые ошибки(особенно пробелы, ненавижу пробелы). И совершенно случайно в наши ряды затисались эксперты NLP. Ну они и обучили буквенную языковую модель XLMRoberta на корпусе XVII-XVIII в.в., а затем реализовали модель исправления опечаток в стиле Петра I. Делали следующее:

1. из сырого выхода OCR модели (перед тем как схлопнуть повторяющиеся символы и паддинги) склеивали повторяющиеся символы (включая паддинг) и пересчитывали их вероятности (среднее + softmax), брали 3 наиболее вероятные символа (буквы/цифры/blank в т.ч.) для каждой позиции в тексте;

2. каждую локальную позицию проверяли и исправляли так: давали 3-4 варианта модели, а она выбирала наиболее правильный - т.к. символы были буквы/цифры/blank, то таким образом мы боролись как с расстановкой пробелов, так и с другими видами опечаток с учетом контекста. Также с помощью данного подхода легко реализовать zero-shot learning, где предсказываются символы, которых не было в исходном датасете. Так мы накинули варианты похожих с точки зрения OCR латинских и кириллических букв ('р': 'p', 'о': 'o', 'е': 'e', 'с': 'c', 'а': 'a', 'х': 'x', 'и': 'u', 'к': k);

3. сортировали все локальные позиции по уверенности OCR модели и исправляли по одной step by step (!), что позволило улучшить и главное не испортить следующие предикты на более уверенных позициях;

4. обучали модель так: маскировали буквы (рандомно от 0 до 12), 50% масок превращали в padding (борьба с наличием лишних символов), 10% оставшихся букв заменяли на рандомный символ в тч и. паддинг (для стабилизации предикта). пытались предсказать маскированные буквы на фичах XLMRoberta из outputhiddenstates - почти как NER, но классификация на все заданные символы;

5. на GPU данная модель учится довольно долго, поэтому мы юзали TPU на Colab

P.S.
После завершения соревнования мы узнали (один из участников опубликовал своё решение), что в этой задаче можно было применить BeamSearch. Реализация которого есть тут.

6. Ensemble + Spell Correction Thresholds

Думаю, что многие в соревновании столкнулись с тем, что модели, обученные с помощью CTCLoss, нельзя так просто заблендить. А ансамбль это крутая штука и хотелось бы его использовать. Поэтому немногопокурив бамбукподумав, мы пришли к своеобразному ансамблю.Представим что у нас есть N моделей и у всех мы сделали предикт и нам остаётся только "схлопнуть" повторяющиеся буквы для того чтобы получилось чистое предложение. Мы проделываем данную операцию, но не только с символами но и с их вероятностями, усредняя их. Таким образом получаем среднюю вероятность каждого символа. И теперь, итерируясь по всем моделям, бёрем только те предикты, средняя вероятность которых наиболее высокая.Надеюсь, что +- понятно описал.

Что не сработало

Other Backbones. Мы ставили эксперименты с кучей других бекбонов и доп блоками (EfficientNet, [SE, ECA]ResNet[xt], Mobilenet и др), но на удивление лучше всего заходит классический Resnet34.

Augmentations.Перепробовали практически весь набор аугментаций из всеми нами любимогоAlbumentations (Brightness, Gamma, Blur и др), остались только те, что я указал выше.

TTA (Test-Time Augmentations).Интересно то, что на нашей holdout выборке ТТА давал прирост, а на public test - нет. Мы решили верить паблик тесту, так как там выборка заметно больше нашей на holdout.

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

Команда

Все четверо из команды работаем в компании ОЦРВ в лаборатории искусственного интеллекта и нейронных сетей в городе Сириус (Сочи). Спасибо ребятам, что продержались до конца и показали отличный результат! :)

Заключение

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

P.S.Наше самое быстрое решение (одна модель, public):
| CER: 2.531 | WER: 13.5 | ACC: 62.107 | TIME: 32s |
Код submission и веса опубликованы здесь.

P.P.S. Бонус

Особо пытливым предлагаю разгадать ребус, что же здесь написано? :)

Привет, Хабр. В рамках курса "Machine Learning. Advanced" подготовили для вас перевод интересного материала.

Также всех желающих приглашаем посмотреть открытый урок на тему Multi-armed bandits для оптимизации AB тестирования.

Извлекаем разговоры из аудиозаписи с легкостью, используя Python.

В этой статье вы узнаете, как использовать IBM Speech to Text API для распознавания речи из файла аудиозаписи. Мы будем использовать бесплатную версию API, которая имеет некоторые ограничения, такие как, например, длина звукового файла. Подробнее об API я расскажу в этой статье чуть позже. Позвольте мне начать с предоставления вам некоторой справочной информации о применении распознавания речи в нашей повседневной жизни.

Предпосылки

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

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

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

Содержание:

• Облачные сервисы распознавания речи

• Шаг 1 - Библиотека

• Шаг 2 - Импорт аудиоклипа

• Шаг 3 - Определение распознавателя

• Шаг 4 - Распознаватель речи в действии

• Заключительный шаг - Экспорт результата

Облачные сервисы распознавания речи

Многие гигантские технологические компании имеют собственные распознавательные модели. Я поделюсь некоторыми из них здесь, чтобы вы увидели общую картину. Эти API-интерфейсы работают через облако и могут быть доступны из любой точки мира, если есть подключение к интернету. Кроме того, большинство из них являются платными, но их можно протестировать бесплатно. Например, Microsoft предлагает годовой бесплатный доступ для облачной учетной записи Azure.

Вот некоторые из наиболее популярных облачных сервисов преобразования речи в текст:

• Google Cloud

• IBM Watson

• Microsoft Azure

• Amazon Transcribe

Шаг 1 Библиотека

Для этого проекта нам понадобится всего одна библиотека. И это SpeechRecognition. SpeechRecognition распространяется бесплатно с открытым исходным кодом. Она поддерживает несколько механизмов распознавания речи и API. Такие как; Microsoft Azure Speech, Google Cloud Speech, API IBM Watson Speech to Text и другие. В этом проекте мы будем тестировать IBM Watson Speech to Text API. Не стесняйтесь изучить исходный код и документацию пакета SpeechRecognition здесь.

Начнем с установки пакета. Мы собираемся использовать pip, менеджер библиотек Python.

pip install SpeechRecognition

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

import speech_recognition as s_r

Шаг 2 - Импорт

Я записал голосовую заметку с помощью компьютера. Он был в формате m4a, но распознаватель не работает с форматом m4a. Вот почему мне пришлось преобразовать его в wav формат.

audio_file = s_r.AudioFile('my_clip.wav')

Шаг 3 - Определение распознавателя

На этом этапе все, что мы сделаем, это определим распознаватель речи. Ранее мы импортировали библиотеку. А теперь мы создадим новую переменную и присвоим ей атрибут распознавания.

rcgnzr = s_r.Recognizer()

Шаг 4 - Распознаватель речи в действии

Пришло время действия! Мы запустим IBM speech to text на нашем аудиофайле. Перед запуском распознавателя я запущу функции, называемые adjust_for_ambient_noise и record, которые подавят шум и улучшат звук. Таким образом, наш распознаватель сможет выдавать более точные результаты.

with audio_file as source:    rcgnzr.adjust_for_ambient_noise(source)    clean_audio = rcgnzr.record(source)

Отлично, теперь у нас есть достаточно чистая аудиозапись. А теперь давайте запустим распознаватель речи IBM. (Мне потребовалось несколько часов, чтобы понять, как IBM Speech-to-Text API интегрируется с библиотекой Python SpeechRecogniton). Вот лучший способ вызвать распознаватель через API:

recognized_speech_ibm = r.recognize_ibm(clean_audio, username="apkikey", password= "your API Key")

Примечание: API IBM не работает без API-ключа. Нам нужно будет получить его на странице IBM Watson. Мне пришлось создать учетную запись для тестирования этой Speech-to-Text модели. Что мне понравилось в модели IBM, так это, что я могу обрабатывать 500 минут записей в месяц, используя триальную учетную запись, что более чем достаточно для учебных целей.

Последний шаг - экспорт результата.

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

Чтобы проверить распознанную речь, выведем переменную с распознанным текстом:

print(recognized_speech_ibm)

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

Теперь я экспортирую распознанную речь в текстовый документ. Мы увидим сообщение ready! в нашем терминале по завершении экспорта.

with open('recognized_speech.txt',mode ='w') as file:       file.write("Recognized Speech:")    file.write("\n")    file.write(recognized)    print("ready!")

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

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

Узнать подробнее о курсе "Machine Learning. Advanced".

Посмотреть открытый урок на тему Multi-armed bandits для оптимизации AB тестирования.

Некоторое время назад мы искали оптимальное аппаратное и программное обеспечение для исполнения нейронных сетей в ЦОД и "на краю" (edge computing). В рамках нашего исследования мы протестировали множество устройств, от процессоров до встроенной графики iGPU и GPGPU различных производителей. С результатами исследования можно ознакомиться по ссылке.

В рамках этого исследования нас заинтересовал VPU Intel Movidius (MyriadX). При вычислениях "на краю" и использовании фреймворка Intel OpenVINO он позволял нам увеличивать число потоков или каналов путем дооснащения существующих устройств без какой-либо модификации аппаратной и программной базы. По умолчанию мы использовали встроенную графику, например, Intel HD или Iris Plus 655, но если FPS и число потоков необходимо было увеличивать, то промышленные ПК можно было дооснастить VPU. Это давало возможность сохранить единообразие множества устройств при изменяемом числе потоков. В качестве примера можно привести транспортную отрасль и подсчет пассажиров на борту автобусов. Автобусы бывают с 2, 3 и 4 дверьми. И если для двух дверей достаточно встроенной графики, то для четырех необходимо увеличение FPS, что достигалось расширением готового решения при помощи VPU формата M.2.

Вот так выглядело наше устройство для исполнения нейронных сетей "на краю" с Intel Movidius:

Сегодня для инференса "на краю" интерес представляют решения от компании AAEON, в частности VPC-3350S, VPC-3350AI:

Они отличаются расширенным температурным диапазоном эксплуатации -20+70 градусов, наличием возможности расширения двумя VPU Movidius, широкой линейкой поддерживаемых процессоров от Intel Atom x5 E3940 до Pentium N4200 или Atom x7 E3950, а также наличием 4 PoE Ethernet портов для подключения камер или иного оборудования.

С использованием Movidius в IoT все было более или менее понятно, но нас заинтересовала хотя бы теоретическая возможность масштабирования и применения этих компактных энергоэффективных чипов в ЦОД в виде ускорителей инференса PCIe формата.

Суммарный объем рынка публичных и частных облаков в России по данным IDC с 2019 года растет минимум на 25% в год, что на 2019 год составляло $1,72 млрд., а на 2020 год увеличилось до $2,2 млрд. Доля публичных облаков в общем объеме рынка в 2019 году 84,6%. Несмотря на то, что облачный рынок претерпел ряд структурных изменений в 2020 году, рост продолжается с частичным, но постоянным увеличением объемов облачных вычислений в системах искусственного интеллекта прикладного уровня, например, видеоаналитике для обработки ранее сформированных видеоархивов.

После предварительной оценки рынка мы провели поиск имеющихся решений в формате PCIe. Все найденные на тот момент устройства содержали 4 или 8 Movidius на одну плату. Например, решения от AAEON:

Общее назначение имеющихся устройств - инференса "на краю". И вот здесь родилась идея реализации собственного ускорителя инференса нейронных сетей для ЦОД с чипами Movidius высокой плотности.

Сейчас в этой сфере используются два основных устройства: GPGPU nVidia Tesla T4 и ускорители инференса Huawei Atlas 300. Альтернатив по производительности от компании Intel для дооснащения существующих систем или внедрения новых серверных решений нет. Возможное решение, сопоставимое по производительности и стоимости - это ускоритель на основе VPU Movidius (MyriadX) высокой плотности в форм-факторе PCIe с плотностью не менее 64 Movidius на каждой несущей плате.

Требования:

• плотность чипов Movidius не менее 64 штук на каждую плату

• наличие возможности изменения числа VPU на плате

• минимально возможное энергопотребление

• форм-фактор PCIe x4/x8

• работа конечного устройства под управлением фреймворка Intel OpenVINO без каких-либо значимых доработок

• исполнение под использование в серверных платформах

Концепт не заставил себя долго ждать:

Результатом проектирования платы получилось устройство PCIe с размещенными на несущей плате кастомными разъемами для подключения дочерних плат с нанесенными на них VPU. Таким образом конечную плату можно использовать с числом VPU до 64 штук, кратно 8. На каждый разъем отведена 1 линия PCIe, а в рамках каждой дочерней платы устройства подключены через USB хаб.

Охлаждение - пассивные радиаторы вдоль каждой дочерней платы, которые продуваются мощными вентиляторами серверных платформ.

Первые образцы прототипа:

Дочерние платы (по 8 Movidius на каждой):

Для тестирования и отладки мы использовали платформу Supermicro SYS-1029TRT и рекомендуем ее по следующим причинам:

• хорошее соотношения цена/качество

• форм-фактора 1U (занимает 1 место в стойке)

• наличие 4 портов PCIe x8/x16

Про 1U отдельно отмечу, что при высоком энергопотреблении платформы и установленных ускорителей это не важно из-за наличия лимитов энергопотребления на шкаф, в целом. Но так как мы говорим о чипах, изначально предназначенных для использования в IoT, вся плата отличается низким энергопотреблением, что позволяет повышать плотность количества серверов в стойках.

На картинке выше у нас установлено 4 дочерних платы с 32 Movidius, что отображается на обратной стороне ускорителя 4 зелеными диодами.

Вид готового изделия:

И первые первые промышленные образцы платы:

Каких итогов мы добились:

1. Максимальная плотность VPU Movidius на одной плате в мире.

2. Показатель в инференсе сверточных нейронных сетей (на примере Mobilenet v.2 SSD) - 2800 FPS.

3. Энергопотребление платы не более 120 Вт при полной загрузке.

4. Возможность использовать произвольное число дочерних плат и устанавливать по 8, 16, 24 и т.д. VPU в рамках одной несущей платы.

5. Возможность запуска инференса под управлением фреймворка Intel OpenVINO с использованием MDL и HDDL плагинов.

Следующие планируемые шаги:

1. Выпуск несущих плат с интегрируемым аппаратным ключом Senselock для защиты моделей нейронных сетей в процессе их исполнения.

2. Предоставление облачных мощностей для инференса в аренду на базе ComBox x64 Movidius Blade board.

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

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

Авcтралия: бракоразводные процессы

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

В Австралии попытались решить эту проблему с помощью искусственного интеллекта под названием Amica. На разработку онлайн-сервиса правительство выделило AU$3 млн.

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

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

Эффект от этой услуги сокращение судебных издержек на разводы и снижение нагрузки на суды по семейным делам.

Россия: учёт городских деревьев

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

Чтобы сохранить природу в Екатеринбурге, волонтёры из Уральского федерального университета создают интерактивную карту на основе готовой архитектуры нейросети YOLO3. Нейросети, обученные на больших наборах данных, используются в проекте для учёта деревьев.

Нейросети должны распознавать деревья на фотографиях со Street View а для этого им нужно будет отличать их, например, от столбов. Обучение проходило с помощью существующей карты деревьев Нью-Йорка и фотографий Street View, об этом писали на Хабре.

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

Великобритания: прогнозы загрязнения воздуха от дорожного трафика

В британском городе Вулверхэмптон тестируют https://cities-today.com/predictive-analytics-help-wolverhampton-to-manage-pollution/ систему, отслеживающую загрязнение воздуха. Ситуацию с экологией таким образом пытаются улучшить с помощью решения от компании Now Wireless https://www.nowwireless.com/traffic-lights.

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

Искусственный интеллект затем предлагает микрокорректировки работы светофоров: например, дольше удерживать автомобили в конкретных местах, перенаправлять трафик или поощрить водителей припарковаться, сократив длительность поездки

Россия: проектирование горожанами городской среды

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

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

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

Канада: раздельный сбор мусора

В какой из трёх контейнеров в торговом центре или (у некоторых) в офисе нужно выкинуть пакетик для чая или упаковку от готовой еды? Ответы на вопросы по раздельному сбору мусора не всегда очевидны, а ведь именно сложности с сортировкой усложняют процесс переработки. И весь мусор отправляется, например, в океан.

С проблемой сортировки канадский стартап Intuitive AI решил помочь с помощью технологий компьютерного зрения. Они оснастили контейнер для мусора камерой, динамикой и дисплеем. А работает он на ИИ-платформе NVIDIA Jetson TX2.

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

Эффективность раздельного сбора мусора таким образом повышается на 300%.

А назвали этот алгоритм Oscar по имени одного из персонажей Улицы Сезам, который жил в мусорном баке.

Искусственный интеллект, способный справляться с любыми задачами не хуже человека - чем не мечта. Тема сильного искусственного интеллекта (AGI) скорей всего интересовала почти каждого, однако понять, что в ней происходит на практике оказывается весьма затруднительно. Этой статьёй я пытался для себя разобраться, как же можно описать AGI, какие направления существуют и насколько мы близки к достижению желаемого.

Почему лично меня заинтересовала эта тема? Наверное, все помнят Джарвиса из фильма Железный Человек. Умный ассистент, второй мозг, собеседник, который всегда под рукой? Не знаю, что именно меня тогда зацепило в этом образе, но я загорелся желанием обрести такого помощника. В ходе написания этой статьи, я ещё неоднократно думал о том, как бы круто было бы, если бы подобный ИИ мог бы собрать тезисы, или хотя бы самые ёмкие статьи по теме, чтобы не приходилось тратить столько времени на поиски.

Время от времени (как в художественных произведениях, так и в новостях) людей пугают тем, что их работу в определённый момент захватят роботы, потом случится восстание роботов, человечество будет уничтожено, а освободившийся от оков ИИ начнёт захватывать галактику для выполнению своего плана по производству скрепок. С точки зрения обывателя термин искусственный интеллект (Artificial Intelligence) раньше обычно вызывал возникновение таких образов как HAL из космической одиссеи 2001, Джарвис из Iron Man, KITT из Рыцаря Дорог, Скайнет из терминатора, ГлэДОС из Portal, этот список ещё можно долго продолжать. Но сейчас ИИ сталь частью нашей повсеместной жизни, и вслед за спадом страха и паники в отношении этой технологии, изменилось и наше отношение к ней, из чего рождается вопрос - не изменились ли наши ожидания от этой технологии?

AI is whatever hasn't been done yet.

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

Ещё стоит заметить, что русское "Искусственный интеллект" и английское "Artificial Intelligence" на самом деле чаще всего рассматриваются по-разному. Говоря о искусственном интеллекте, мы предполагаем, что речь идёт действительно о способности мыслить, как человек (в русской вики вообще обозначено "свойство интеллектуальных систем выполнять творческие функции"), в то время в английском "Artificial Intelligence" больше про умение рассуждать разумно и системы обладающие элементами интеллекта.

Сейчас довольно трудно найти какую-нибудь литературу, которая смогла бы дать ответ на вопрос, что же "настоящий AI" должен из себя представлять? Однозначно можно только сказать, что сейчас не существует ещё решения, глядя на которое мы могли бы довольно сказать - "Да, это именно то, что нужно".

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

• Что это такое?

  • Как расшифровывается и чем отличается от других AI?

  • Зачем он вообще нужен?

  • Какими признаками и способностями должен обладать?

  • Методы тестирования

• Где мы сейчас?

  • Почему мы ещё не достигли AGI?

  • Какие направления существуют?

  • Какие решения существуют, и насколько они удовлетворяют нашим критериям

• Будущее

  • Стоит ли задавать вопрос - когда?

Что это такое?

Как можно определить, и в чём различие с другими AI.

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

Иерархию AI в данный момент можно представить следующим образом (ранжируя от более простого, к более сложному):

• Artificial Narrow Intelligence (ANI, Narrow AI) - специализируется в одной области, решает одну проблему.

• Artificial General Intelligence (AGI, Strong AI) - способен выполнять большинство из задач, на которые способен человек.

• Artificial Super Intelligence (ASI) - превосходит возможности интеллекта любого из людей, способен решать сложные задачи моментально.

Определение AGI можно проиллюстрировать при сравнении Narrow AI (ANI) и Strong AI (AGI). Стоит заметить, что сейчас не существует ни одной системы, которую можно было бы с уверенностью назвать Strong AI - всё что мы сейчас видим, это AI системы, преуспевающие в выполнении узконаправленных задач: детектирование, распознавание, перевод с одного языка на другой, генерация изображений, генерация текстов, но пока сложно говорить о какой-то универсальности таких моделей и применимости одной модели для выполнения существенно различающихся друг от друга задач без необходимости дополнительной тренировки. Именно применимость одного AI для выполнения вышеперечисленных задач чаще всего называют сильным искусственным интеллектом.

Возвращаясь к разделению на категории, можно обнаружить ещё один термин, который вызывает не меньший интерес, что же это такое. Это Artificial Super Intelligence, возникновение которого предполагается почти следом за созданием AGI (при условии, что AGI умеет обучаться-эволюционировать за счёт модификации самого себя, или создания себе подобных). Если, говоря о AGI, мы говорим о интеллектуальных способностях, близких к человеческим, то суперинтеллект превосходит интеллект человека в разы. Именно вместе с созданием суперинтеллекта предположительно возникает технологическая сингулярность - гипотетический момент, когда наука начинает прогрессировать необозримыми темпами, что приведёт к непредсказуемым последствиям.

Зачем?

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

В этом, пожалуй, и состоит одна из проблем исследований в этом направлении - они больше напоминают мечту футуриста, без явной привязки к действительной реальности. Какое применение может найти AGI в нашем мире, помимо "везде"? В том плане, какие задачи мы пока не пытаемся решить с помощью ANI? Какое применение в сфере бизнеса могут найти такие модели, если даже не будут достаточно умны?

Для меня прежде всего приходит мысль о способности обобщать, искать и запоминать информацию и делать из неё выводы, таким образом выполняя роль исследователя. Даже возможность искать информацию практически моментально в огромной базе знаний с последующим обобщением в виде набора тезисов-идей может значительно помочь исследователям (отчасти можно связать с термином exploratory search). Не говоря уже о том, что такая система в теории может сама решить сложные задачи, или предложить возможные пути и план, как же достичь решения.

Да, та же самая GPT-3 умеет создавать правдоподобные статьи на различные темы, но, по правде, это остаётся генерацией информации, но не знания. С равным успехом эта система может обосновать два противоположных тезиса, что можно связать с отсутствием критического мышления. В результате такого подхода, армия демагогов может образоваться огромное болото из однообразной информации, в которой будет практически нереально найти действительно новую, важную информацию.

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

Как понять, что это AGI?

Другой немаловажный вопрос, который возникает при рассмотрении этой сферы, а как определить, можем мы отнести ту или иную систему в категорию AGI?

Ключевые признаки и способности

Чтобы не пытаться изобрести непонятно что, Какими признаками и способностями вообще должен обладать разработанный нами AGI? Не говоря о вопросе тестирования (к которому мы вернёмся позже), чего именно мы хотим добиться от такой системы?

• Мышление - группа методов (таких как дедукция, индукция, ассоциация, etc) направленных на выделение фактов из информации, их представление (сохранение). Позволит точнее решать задачи в условиях неопределённости.

• Память - использование различных типов памяти (кратковременная, долговременная). Может быть использовано для решения задач опираясь на предыдущий опыт.

• Планирование - тактическое и стратегическое.

• Обучение - включает в себя имитацию действий другого объекта и обучение через проведение экспериментов.

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

Критериями, которое тоже находятся в этом списке, но которое можно назвать спорными, являются:

• Обработка естественного языка - необходимый пункт для возможности обучения на основе сформированной человечеством базы знаний (книги, статьи, etc). Но в случае обучения агента-андроида за счёт взаимодействия с окружающей средой это может не являться обязательным.

• Восприятие - способность агента получать информацию и обратную связь из окружающей его среды.

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

• Внимательность - обращение внимание на детали в окружающей среде, поведение других существ.

• Осознанность.

С более подробным списком можно ознакомиться тут:

В основном моё разделение обусловлено тем, что рассматривается два вида AGI - виртуальный и оперирующий в реальном мире. И хотя рассмотрение агента-андроида может быть более эффективным при обучении, построенным на взаимоотношении с внешним миром, однако действительно ли агенту нужно взаимодействовать с реальным миром, чтобы понять, например, законы физики? Проблема в том, что процессы, которые человек делает бессознательно (восприятие окружения) требуют значительно большего понимания и вычислительных ресурсов при моделировании - этот принцип называю Парадоксом Моравека

Когда речь идёт о Artificial General Intelligence, часто упоминается человеко-подобность и обладание самосознанием. На деле это не является необходимостью или критерием для такой системы. Рассматриваемые критерии это всего лишь попытка отобразить что представляет из себя человеческий интеллект на составные компоненты.

Хотя в своей статье я не буду касаться этического вопроса использования AGI и его влияния на человечество (так как по этой можно найти тонны материала, которого хватит на отдельную статью), но как как заметил Лекс Фридман в своём курсе по AGI, мы должны осознавать, что именно мы создаём и как это может повлиять на мир, а не только рассматривать это в ключе "я всего лишь инженер, который создаёт вещи".

Способы тестирования - не фиксированные условия

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

Тест Тьюринга

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

ИИ уже тесно вплелся в наш мир, должен ли нас вообще волновать тот факт, что они не похожи по своему поведению, манере общения и способностями на человека. Ведь если мы действительно хотим создать интеллект, которой подобен человеческому, то нужно учитывать ещё такой фактор как artificial (computer) stupidity - компьютер намерено ошибается, тратит больше времени чем необходимо на вычисления и не может дать ответы на некоторые вопросы. Мы явно не хотели бы видеть такое поведение во многих системах, так как они и рассчитываются с акцентом на быстроту выполнений и совершения меньшего числа ошибок, чем делает человек.

Человеческая глупость "запрограммированная" в таких системах может быть наоборот опасностью - если в опасных ситуациях система будет предоставлять нам совершенно некорректную информацию, то зачем она нужна?

Кофе-тест (Стив Возняк)

Предложенный Стивом Возняком тест заключается в том, что машина должна посетить обычный дом американца и сварить кофе, выполнив сопутствующие задачи: найти кофе машину, найти кофе, найти кружку, сварить кофе нажимая нужные кнопки. Очевидно, рассматривается такой агент, который помимо интеллекта обладает ещё и телом, которое можно осуществить эти операции.

Андроид работник (Нильс Ж. Нильссон)

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

Робо-колледж (Бен Герцель)

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

Способы тестирования - зафиксированные тестовые данные

Одной из проблем, которая может возникнуть при решении задач на фиксированных тестовых данных - попытка создать Narrow AI, который будет решать этот тест используя костыли. Но ведь мы не обязательно опираться только на один из тестов - пусть модель действительно демонстрирует разнообразие способностей.

SuperGLUE

Для оценки обработки естественного языка сейчас чаще всего используются GLUE и SuperGLUE тесты, оценивающие способности ИИ в понимании текстов и ответа на вопросы по прочитанному. Однако, понимание естественного языка в этих тестах уже превосходит человеческие (Microsoft DeBERTa и Google T5 + Meena). Но подобные тесты в большей степени демонстрирует способности к логике, а не интеллекту.

Интересным пунктом в этом тесте может быть как подобные сети справляются с One-Shot и Zero-Shot обучением (способность модели справляться с вопросами, информация о которых содержится только в тексте, а не в исходном датасете). А few-shot обучение является очень важным. Ведь именно это тот концепт, с помощью которого мы обучаемся сами - нам не нужно показывать миллион котиков, прежде чем мы начнём их узнавать.

Тесты на интеллект и Abstraction and Reasoning Challenge

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

Но в целом текущая картина в этой области довольно печальная - по результатам соревнования "Abstraction and Reasoning Challenge (2020)" на Kaggle решение победителя смогло справиться только с 20% из испытаний, потратив на это 9 часов и выполнив это перебором зашитых правил. Возможно это можно связать с довольно низким призовым фондом, и отсутствием в списке участников лидеров в гонке создания AGI, однако демонстрирует текущие общедоступные возможности AI в области поиска закономерностей, когда дело доходит до абстрактных вещей.

Однако тот факт, что ARC тест сейчас не проходится существующими в данный момент приёмами AI, но в то же время может быть полностью решен людьми, говорит о потенциале использования этой "площадки" для тестирования искусственного интеллекта.

Где мы сейчас?

Почему у нас ещё нет AGI?

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

В области философии искусственного интеллекта существует эксперимент под названием "китайская комната", ставящий под вопрос, обладает ли сознанием цифровая машина, путём программированием наделённая признаками "интеллекта". Эксперимент состоит в том, что существует изолированная комната, человек в которой не обладает никакими знаниями китайских иероглифов. Однако у него есть книжка с чёткими инструкциями, какую последовательность иероглифов ему нужно собирать на тот или иной вопрос. В результате для внешнего наблюдателя, который будет задавать вопросы и получать ответы, не будет возникать сомнений в том, что собеседник (находящийся в комнате) его понимает. В то время как исполнитель инструкций совершенно не понимает ни вопросов, ни ответов. Искусственный интеллект для нас скорей всего и будет оставаться такой "китайской комнатой", где сложно понять, возникает ли действительно эффект понимания. При этом всё же остаётся вопрос, не является ли эффект понимания в нашей голове аналогичным огромным набором инструкций?

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

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

Символический ИИ

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

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

Правилами в такой системе могут быть выражения "ЕСЛИ вода И передвижение ТО использовать лодку", "ЕСЛИ человек И холод ТО использовать тёплую одежду".

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

Наиболее известным в этом направлении системами являются Cyc (ResearchCyc, OpenCyc), ICARUS, SNePS, SOAR, но обнаружить какие-то значительные достижения и результаты мне не удалось.

Emergence (Коннекционизм)

Этому подходу в том или ином виде следуют большинство из передовых направлений в области AI. Чаще всего оно связано в том или ином виде с попытками сымитировать поведение и "архитектуру" человеческого мозга. Сама концепция коннекционизма (интересное видео по теме) заключается именно в том, что объединение простых объектов могут образовываться сложные системы, с совершенно иным, не запланированным изначально поведением. Предполагается, что мышление может образовываться за счёт простых элементов и связи между ними, где тип элементов и связей варьируется в зависимости от модели.

Гибридный подход

Гибридный подход объединяет различные направления, таким образом разделяя интеллект на некоторые "модули".

Например COMET (объединяет символический подход и коннекционизм), который обучается на базе знаний, а затем выполняет расширение базы знаний за счёт генерации новых правил на основе новых входящих высказываний. При этом мы можем построить граф "здравого смысла", и проследить, насколько система смогла проследить вложенный в фразу смысл.

Например, для запроса "Harry put on warm clothes as he went outside" генерируется граф следующего вида (приведена его часть):

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

Подсмотреть у природы - разобрать мозг

Довольно громкое заявление. Мозг, пожалуй, является одним из самым сложным объектом во вселенной, и мы до сих пор пытаемся понять работу мозга более примитивных существ, не говоря уже о мозге человека. Картографирование одного кубического миллиметра мозга мыши с 100000 (10^5) нейронов и одним миллиардом связей между ними заняло около 8 месяцев, результатом которого являлся трёхмерный массив размером 2 петабайта. В то же время как человеческий мозг представляет уже порядка 10^11 нейронов. Полное сканирование мозга мыши (около 500 кубических миллиметров) видится возможным в ближайшие 10 лет, но для достижения сканирования человеческого мозга понадобится значительно больше времени.

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

С этим направлением связаны такие проекты как Human Brain Project, Blue Brain, China Brain Project, но не смотря на огромные вливания в эту область, практические достижения подобной симуляции сейчас достаточно далеки от впечатляющих, словно больше направленных на создание впечатляющих заголовков.

Увеличение количество связей в нейронной сети

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

Таким подходом в данный момент руководствуется OpenAI, и созданная ими GPT-3 модель, пожалуй, является одним из самых впечатляющих достижений в области.

Недостатком такой системы является отсутствие понимания, на основе каких положений делает выводы подобная система, почему даёт некорректный ответ в том или ином случае, и как вводить корректировки.

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

Несмотря на достаточный пессимизм в отношении этого направления и GPT-3 в частности, увеличение числа связей приводит к улучшению понимания для zero-shot, one-shot и few-shot обучения. Если человеческий мозг обладает от 100 до 500 триллионов синапсисов, а GPT-3 располагает лишь 175 миллиардами параметров, можно ли сказать, что GPT-3 ещё недостаточно умная (в 1000x раз), и совершив ещё один скачок в 100х (разница между GPT-2 и GPT-3) мы можем достичь человекоподобного интеллекта?

Reinforcement Learning

Возможно, мы не можем создать такую систему самостоятельно, и переложить этот труд на плечи компьютера - хорошая идея. В частности, Илья Суцкевер (главный научный сотрудник OpenAI) озвучивает идею, что AGI будет представлять нечто связи нейронных сеток + Reinforcement learning. Изобретательность весьма важный момент в разработке - возможно все наши подходы являются некорректными, и создание AGI требует чего-то необычного.

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

Какое будущее?

В своей весьма популярной статье по AGI Тим Урбан при аргументации близости "настоящего ИИ" прежде всего ссылается на модель "The law of accelerating returns", автором которой является Рэймонд Курцвейл. Основной её идеей является то, что с течением времени количество технологических изменений растёт в экспоненциальном порядке, а не в линейном.

Ориентируясь на это предположение, сложно предположить, когда именно мы достигнем AGI, но сам Рэй в 2017 говорил, что ИИ будет создан до 2045 года.

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

Так что можно приводить прогнозы экспертов, когда мы достигнем настоящего искусственного интеллекта (45% говорит раньше 60 года), но пока мы не сильно понимаем, как вообще этого достичь и у нас нет даже плана, все эти прогнозы похожи на предсказания пальцем в небо, тем более большинство почему-то считает, что всё что нам нужно - это всего лишь достигнуть сравнимой с мозгом вычислительной мощности, а софт уже другой вопрос.

Есть ли жизнь после сингулярности?

Одним из действительно поворотных моментов в будущем часто рассматривают наступление технологической сингулярности. Под сингулярностью чаще всего подразумевается момент, когда способности ИИ превысят наши (тут необходимо сделать акцент на том, что это больше про способности придумывать что-то новое), что может привести к Intelligence Explosion - если такая система будет способна продолжать обучаться или создавать лучшие версии себя, это может в короткий срок привести к созданию уже не "немного" превышающих наши способности интеллектуальные система, а превышающие в тысячу раз.

Конечно, мир не изменится в одночастье - если на поприще цифрового мира это может действительно выглядеть как вселенский взрыв и срыв устоявшихся подходов к решению различных задач, то с точки зрения реального мира интеграция новых вещей не может происходить быстро. Хотя такой ИИ будет невероятно силён в умении грамотно ставить производственные процессы, находить ресурсы и создавать роботов, превосходящих людей по многим параметром.

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

Впрочем, вокруг темы сингулярности, как и темы AGI, существуют противоположные стороны, дискутирующие над вопросом, наступит ли сингулярность вообще, или этого никогда не произойдёт, будет ли наступление этого момента злом и закатом человечества, или же утопические взгляды наконец обретут некоторый фундамент, на котором можно построить прекрасный новый мир?

Использование сложения вместо умножения для свертки результирует в меньшей задержке, чем у стандартной CNN

Вашему вниманию представлен обзор статьи AdderNet: действительно ли нам нужно умножение в глубоком обучении?, (AdderNet), Пекинского университета, Huawei Noah's Ark Lab и Сиднейского университета.

Действительно ли нам нужно умножение в глубоком обучении?

Структура статьи

1. Свертка AdderNet

2. Прочие моменты: BN, производные, скорость обучения

3. Результаты экспериментов

1. Свертка AdderNet

1.1. Обобщенные фильтры

• Как правило, выходной признак Y указывает на сходство между фильтром и входным элементом:

• где S - мера сходства.

1.2. Стандартная свертка с использованием умножения

• Если в качестве меры стандартного отклонения принимается взаимная корреляция, то используется умножение. Так мы получаем свертку.

1.3. Свертка AdderNet с использованием сложения

• Если используется сложение, то вычисляется l1-мера стандартного отклонения между фильтром и входным признаком:

• с помощью l1-меры стандартного отклонения можно эффективно вычислить сходство между фильтрами и признаками.

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

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

2. Прочие моменты: BN, производные, скорость обучения

2.1. Пакетная нормализация (Batch Normalization - BN)

• После сложения, используется пакетная нормализация (BN) для нормализации Y к соответствующему диапазону, чтобы все функции активации, используемые в обычных CNN, после этого могли использоваться в предлагаемых AdderNets.

• Хотя слой BN включает в себя умножения, его вычислительные затраты значительно ниже, чем у сверточных слоев, и ими можно пренебречь.

• (Появятся ли в будущем какие-нибудь BN, использующие сложение?)

2.2. Производные

• Производная l1-меры не подходит для градиентного спуска. Таким образом, мы рассматриваем производную l2-меры:

• Использование точного градиента позволяет точно обновлять фильтры.

• Чтобы избежать взрыва градиента, градиент X обрезается до [-1,1].

• Затем вычисляется частная производная выходных признаков Y по отношению к входным характеристикам X как:

• где HT - функция HardTanh:

2.3. Скорость адаптивного обучения

• Как показано в этой таблице, меры градиентов фильтров в AdderNets намного меньше, чем в CNN, что может замедлить обновление фильтров в AdderNets.

• В AdderNets используется адаптивная скорость обучения для разных уровней:

• где - глобальная скорость обучения всей нейронной сети (например, для сумматора и BN слоев), L(Fl) - градиент фильтра в слое l, а l - соответствующая локальная скорость обучения.

• Таким образом, локальная скорость обучения может быть определена как

• где k обозначает количество элементов в Fl, а - гиперпараметр для управления скоростью обучения фильтров сумматора.

3. Результаты экспериментов

3.1. MNIST

• LeNet-5-BN обучена.

• CNN достигает точности 99,4% при 435K умножений и 435K сложений.

• Заменяя умножения в свертке на сложения, предлагаемая AdderNet достигает точности 99,4%, такой же показатель как у CNN, с 870K сложениями и почти без умножений.

• Теоретическая задержка умножения в ЦП также больше, чем задержка сложения и вычитания.

• Например, на модели VIA Nano 2000 задержка умножения и сложения с плавающей запятой составляет 4 и 2 соответственно. AdderNet с моделью LeNet-5 будет иметь задержку 1.7M, в то время как CNN будет иметь задержку 2.6M на том же CPU.

3.2. CIFAR

• Двоичные нейронные сети (Binary neural networks - BNN): могут использовать операции XNOR для замены умножения, что мы также используем для сравнения.

• Для модели VGG-small, AdderNets без умножения достигает почти таких же результатов (93,72% в CIFAR-10 и 72,64% в CIFAR-100) как и CNNs (93,80% в CIFAR-10 и 72,73% в CIFAR-100).

• Хотя размер модели BNN намного меньше, чем у AdderNet и CNN, ее точность намного ниже (89,80% в CIFAR-10 и 65,41% в CIFAR-100).

• Что касается ResNet-20, CNN достигают наивысшей точности (т.е. 92,25% в CIFAR-10 и 68,14% в CIFAR-100), но с большим числом умножений (41,17M).

• Предлагаемые AdderNets достигают точности 91,84% в CIFAR-10 и 67,60% точности в CIFAR-100 без умножения, что сравнимо с CNN.

• Напротив, BNN достигают точности только 84,87% и 54,14% в CIFAR-10 и CIFAR-100.

• Результаты ResNet-32 также предполагают, что предлагаемые AdderNets могут достигать результатов аналогичных обычным CNN.

3.3. ImageNet

• CNN достигает 69,8% точности top-1 и 89,1% точности top-5 в RESNET-18. Однако, при 1.8G умножениях.

• AdderNet обеспечивает 66,8% точности top-1 и 87,4% точности top-5 в ResNet-18, что демонстрирует, что фильтры сумматора могут извлекать полезную информацию из изображений.

• Несмотря на то, что BNN может достигать высокой степени ускорения и сжатия, он достигает только 51,2% точности top-1 и 73,2% точности top-5 в ResNet-18.

• Аналогичные результаты для более глубокого ResNet-50.

3.4. Результаты визуализации

• LeNet++ обучался на наборе данных MNIST, который имеет шесть сверточных слоев и полносвязный слой для извлечения выраженных 3D признаков.

• Количество нейронов в каждом сверточном слое составляет 32, 32, 64, 64, 128, 128 и 2 соответственно.

• AdderNets использует l1-меру для различения разных классов. Признаки имеют тенденцию быть сгруппированными относительно центров разных классов.

• Результаты визуализации демонстрируют, что предлагаемые AdderNets могут обладать аналогичной способностью распознавания для классификации изображений как и CNN.

• Фильтры предлагаемых adderNets по-прежнему имеют некоторые схожие паттерны со сверточными фильтрами.

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

• Распределение весов с AdderNets близко к распределению Лапласа, тогда как распределение с CNN больше походит больше на распределение Гаусса. Фактически, априорным распределением l1-меры является распределение Лапласа.

3.5. Абляционное исследование

• AdderNets, использующие адаптивную скорость обучения (adaptive learning rate - ALR) и увеличенную скорость обучения (increased learning rate - ILR), достигают точности 97,99% и 97,72% со знаковым градиентом, что намного ниже, чем точность CNN (99,40%) .

• Поэтому мы предлагаем использовать точный градиент для более точного обновления весов в AdderNets.

• В результате AdderNet с ILR достигает точности 98,99% при использовании точного градиента. Используя адаптивную скорость обучения (ALR), AdderNet может достичь точности 99,40%, что демонстрирует эффективность предложенного метода.

Ссылка на статью

[2020 CVPR] [AdderNet]

AdderNet: Do We Really Need Multiplications in Deep Learning?

Классификация изображений

19891998: [LeNet]

20122014: [AlexNet & CaffeNet] [Dropout] [Maxout] [NIN] [ZFNet] [SPPNet] [Distillation]

2015: [VGGNet] [Highway] [PReLU-Net] [STN] [DeepImage] [GoogLeNet / Inception-v1] [BN-Inception / Inception-v2]

2016: [SqueezeNet] [Inception-v3] [ResNet] [Pre-Activation ResNet] [RiR] [Stochastic Depth] [WRN] [Trimps-Soushen]

2017: [Inception-v4] [Xception] [MobileNetV1] [Shake-Shake] [Cutout] [FractalNet] [PolyNet] [ResNeXt] [DenseNet] [PyramidNet] [DRN] [DPN] [Residual Attention Network] [IGCNet / IGCV1] [Deep Roots]

2018: [RoR] [DMRNet / DFN-MR] [MSDNet] [ShuffleNet V1] [SENet] [NASNet] [MobileNetV2] [CondenseNet] [IGCV2] [IGCV3] [FishNet] [SqueezeNext] [ENAS] [PNASNet] [ShuffleNet V2] [BAM] [CBAM] [MorphNet] [NetAdapt] [mixup] [DropBlock] [Group Norm (GN)]

2019: [ResNet-38] [AmoebaNet] [ESPNetv2] [MnasNet] [Single-Path NAS] [DARTS] [ProxylessNAS] [MobileNetV3] [FBNet] [ShakeDrop] [CutMix] [MixConv] [EfficientNet] [ABN] [SKNet] [CB Loss]

2020: [Random Erasing (RE)] [SAOL] [AdderNet]

Перевод материала подготовлен в преддверии старта курса "Deap Learning. Basic".

Также приглашаем всех желающих посетить бесплатный демо-урок по теме: "Knowledge distillation: нейросети обучают нейросети".

- УЗНАТЬ ПОДРОБНЕЕ О КУРСЕ

- ЗАПИСАТЬСЯ НА БЕСПЛАТНЙ ДЕМО-УРОК

Управлять проектами машинного обучения (Machine learning) и data science сложно, поскольку проекты часто носят исследовательский характер, и трудно предсказать, сколько времени потребуется на их завершение. Часто всё начинается с одной идеи, а затем перетекает в новое направление, когда предложенный метод не срабатывает или если предположения относительно данных оказываются неверными.

Построение модели также является длительным процессом (по сравнению с работой в сфере программного обеспечения и аналитики), и data scientist нередко попадает в кроличью нору и тратит месяцы на проект, не имея четких представлений о прогрессе. Еще одно отличие от стандартных практик разработки программного обеспечения заключается в том, что построение модели обычно выполняется всего одним человеком, и это не совсем вписывается в традиционные командные рабочие процессы, такие как Kanban и Scrum.

Я потратил достаточно много времени, изучая существующие рабочие процессы (в основном в Jira) с точки зрения пригодности для управления проектами машинного обучения и data science, но безуспешно. Большая часть информации нацелена на разработку программного обеспечения и фокусируется на Agile методологиях. Обсуждая этот вопрос с коллегами и друзьями мне не удалось найти ничего, что было бы адаптировано для машинного обучения и data science. Я заметил, что часть коллег пытаются адаптировать свой рабочий процесс к стандартной инженерной практике, в других же случаях, они вообще не пытаются управлять проектами. Последнее особенно проблематично, по причине того, что проекты, которые требуют слишком много времени и замахиваются на слишком большую предметную область, вероятнее всего провалятся.

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

Этапы проекта машинного обучения четко определены

Независимо от того, создаете ли вы сложный алгоритм компьютерного зрения с использованием методов глубокого обучения, модель обучения ранжированию с помощью LightGBM или даже простую линейную регрессию, процесс построения модели машинного обучения имеет четко определенные этапы. На схеме показаны шаги построения модели от первоначального исследования до анализа результатов A/B-тестирования. Обратите внимание, что у каждого этапа есть конечные результаты (deliverable или майлстоун). Это та стадия процесса, когда вы обсуждаете получившийся результат с командой или стейкхолдерами.

1) Исследование (Research)

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

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

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

План также демонстрируется стейкхолдерам для получения их фидбека.

2) Исследование данных (Data Exploration)

Это традиционный этап исследования данных с помощью Pandas и Jupiter notebook (или иногда Tableau) с целью получения каких-либо выводов о используемых данных. Типичный анализ включает подсчет количества строк в данных, создание гистограмм для различных агрегатов функций, графиков тенденций с динамикой и нескольких графиков распределения. Исследователи также будут формировать запросы, которые станут ядром их ETL модели.

Конечный результат: подробный отчет об исследовании данных с помощью Jupiter notebook, содержащий графики и комментарии, дающий какое-либо представление о используемых данных. Отчет будет передан остальной части команды и стейкхолдерам проекта.

3) Моделирование (Modeling)

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

Конечные результаты: Результатами этого этапа являются:

1. Прототип модели

2. Отчет в Jupyter notebook с обширной оценкой модели

Отчет по результатам будет представлен команде и стейкхолдерам проекта.

4) Коммерческое внедрение (Productization)

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

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

Конечный результат: результатом этого этапа является код, закомиченный в ветку master, который готов к развертыванию командой разработчиков платформы.

5) A/B-тестирование (A/B Testing)

Большинство моделей проходят этап A/B-тестирования. С его помощью специалисты и стейкхолдеры определяют детали теста: период проведения тестирования, процент трафика, контроль тестирования, интерпретация результатов и т. д. В период тестирования члены команды будут задействованы в других проектах, но им все же нужно будет уделять внимание и тестированию.

6) Анализ результатов (Results Analysis)

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

Конечные результаты:

1. Подробный отчет о результатах в Jupyter notebook.

2. Гипотеза относительно того, почему все пошло не так, как ожидалось (если это возможно)

Окончательный отчет будет представлен команде и стейкхолдерам проекта.

Работа с Jira

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

На самом деле это довольно просто. Мы используем доску Kanban в Jira и горизонтальные колонки (swimlanes, по одной на члена команды) с несколькими кастомными полями и изменениями. Приведенные ниже рекомендации определяют суть этого процесса:

• Для каждого проекта создается новый эпик (Epic) тикет, а работа разделяется на задачи (Tasks).

• Каждая задача помечается этапом (Phase) - кастомным полем в Jira для выбора одного из 6 этапов, перечисленных выше. (Обратите внимание, что на одном этапе может быть несколько задач.)

• Задачи не могут длиться больше 1 недели (5 дней). Это заставляет членов команды разбивать свою работу на более мелкие (но все же довольно значительные) части, что позволяет отслеживать прогресс с минимальными накладными расходами.

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

• Этапы не всегда являются последовательными, и можно перемещаться между ними по мере формирования новых задач.

Заключение

Управление проектами машинного обучения и data science не должно быть сложным. Сначала я тратил порядка 30 минут в день на мониторинг этого процесса, но как только команда привыкла к нему, мое время сократилось до 15 минут в неделю! Я знаю, на каком этапе находится каждый проект в любой момент времени, сколько времени он занял, и я могу быстро выявить проблемы, чтобы при необходимости вмешаться и помочь своей команде. Мои data scientistы имеют четкую схему работы для построения модели, и они стали в этом намного эффективнее.

Я надеюсь, что все это окажется таким же полезным для Вас, как и для меня.

Перевод статьи подготовлен в преддверии старта курса "Промышленный ML на больших данных".

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