Код простой нейронной сети питон. Нейронная сеть против DDoS'а
И тут как раз на наш сайтик приехал DDoS. Отбиваться от которого можно было админско-программерскими (grep / awk / etc) способами или же прибегнуть к использованию технологий машинного обучения.
Пример построения словаря и feature-vector"а
Предположим, мы обучаем нашу нейронную сеть всего на двух примерах: одном хорошем и одном плохом. Потом попробуем её активировать на тестовой записи.Запись из "плохого" лога:
0.0.0.0 - - "POST /forum/index.php HTTP/1.1" 503 107 "http://www.mozilla-europe.org/" "-"
Запись из "хорошего" лога:
0.0.0.0 - - "GET /forum/rss.php?topic=347425 HTTP/1.0" 200 1685 "-" "Mozilla/5.0 (Windows; U; Windows NT 5.1; pl; rv:1.9) Gecko/2008052906 Firefox/3.0"
Получившийся словарь:
["__UA___OS_U", "__UA_EMPTY", "__REQ___METHOD_POST", "__REQ___HTTP_VER_HTTP/1.0", "__REQ___URL___NETLOC_", "__REQ___URL___PATH_/forum/rss.php", "__REQ___URL___PATH_/forum/index.php", "__REQ___URL___SCHEME_", "__REQ___HTTP_VER_HTTP/1.1", "__UA___VER_Firefox/3.0", "__REFER___NETLOC_www.mozilla-europe.org", "__UA___OS_Windows", "__UA___BASE_Mozilla/5.0", "__CODE_503", "__UA___OS_pl", "__REFER___PATH_/", "__REFER___SCHEME_http", "__NO_REFER__", "__REQ___METHOD_GET", "__UA___OS_Windows NT 5.1", "__UA___OS_rv:1.9", "__REQ___URL___QS_topic", "__UA___VER_Gecko/2008052906"]
Тестовая запись:
0.0.0.0 - - "GET /forum/viewtopic.php?t=425550 HTTP/1.1" 502 107 "-" "BTWebClient/3000(25824)"
Её feature-vector:
Заметьте, насколько "разрежен" (sparse) feature-vector - такое поведение будет наблюдаться для всех запросов.
Разделение Dataset"а
Хорошей практикой является разделение dataset "а на несколько частей. Я бил на две части в пропорции 70/30:- Training set . На нём мы обучаем нашу нейронную сеть.
- Test set . Им мы проверяем, насколько хорошо обучена наша нейронная сеть.
В дальнейшем, если придётся озадачиться выбором оптимальных констант, dataset надо будет разбить на 3 части в соотношении 60/20/20: Training set , Test set и Cross validation . Последний как раз и будет служить для выбора оптимальных параметров нейронной сети (например weightdecay).
Нейронная сеть в частности
Теперь, когда у нас на руках больше нет никаких текстовых логов, а есть только матрицы из feature-vector "ов, можно приступать к построению самой нейронной сети.Начнём с выбора структуры. Я выбрал сеть из одного скрытого слоя размером с удвоенный входной слой. Почему? Всё просто: так завещал Andrew Ng в случае, если не знаете с чего начать. Думаю, в дальнейшем с этим можно поиграться, порисовав графики обучения.
Функцией активации для скрытого слоя выбрана многострадальная сигмойда, а для выходного слоя - Softmax . Последний выбран на случай, если придётся делать
многоклассовую класиффикацию c mutually exclusive классами. Например, "хорошие" запросы отправлять на бэкенд, "плохие" - в бан на фаерволе, а "серые" - разгадывать капчу.
Нейронная сеть склонна к уходу в локальный минимум, поэтому у себя в коде я строю несколько сетей и выбираю ту, у которой наименьший Test error (Заметьте, именно ошибка на test set , а не trainig set).
Disclaimer
Я не настоящий сварщик. О Machine Learning я знаю только то, что подчерпнул из ml-class и ai-class. На питоне программировать начал относительно недавно, а код ниже был написан минут за 30 (время, как вы понимаете, поджимало) и в дальнейшем был лишь слегка подпилен напильником.Также этот код не самодостаточен. Ему всё равно нужна скриптовая обвязка. Например, если IP сделал N плохих запросов в течение X минут, то банить его на firewall"е.
Производительность
- lfu_cache. Портировал с ActiveState, дабы сильно ускорить обработку запросов-"высокочастотников". Down-side - повышенное потребление памяти.
- PyBrain, внезапно, написан на python и поэтому не очень быстр, однако, он может использовать ATLAS-based -модуль arac , если при создании сети указать Fast=True . Подробнее про это можно почитать в документации к PyBrain .
- Распараллеливание. Свою нейронную сеть я обучил на довольно "толстом" серверном Nehalem"е, однако, даже там чувствовалась ущербность однопоточного обучения. Можно поразмыслить на тему распараллеливания обучения нейронной сети. Простое решение - тренировать сразу несколько нейронных сетей параллельно и из них выбирать лучшую, но это создаст дополнительную нагрузку на память, что тоже не очень хорошо. Хотелось бы более универсальное решение. Возможно имеет смысл просто переписать всё на C, благо вся теоретическая база в ml-class"е была расжевана.
- Потребление памяти и кол-во features. Хорошей оптимизацией по памяти являлся переход со стндартных питоновских массивов на numpy"ные. Так же уменьшение размера dictionary и/или использование PCA может очень хорошо помочь, об этом чуть ниже.
На будущее
- Дополнительные поля в лог. В combined лог можно добавить ещё много всего, стоит подумать на тему, какие поля помогут в идентификации ботов. Возможно, имеет смысл учитывать первый октет IP адреса, ибо в не интернациональном web-проекте китайские пользователи вероятнее всего боты.
Искусственные нейронные сети (ИНС) - математические модели, а также их программные или аппаратные реализации, построенные по принципу организации и функционирования биологических нейронных сетей - сетей нервных клеток живого организма.ИНС представляют собой систему соединённых и взаимодействующих между собой простых процессоров (искусственных нейронов).
Нейронные сети не программируются в привычном смысле этого слова, они обучаются. Возможность обучения - одно из главных преимуществ нейронных сетей перед традиционными алгоритмами. wikipedia
Нейронные сети были вдохновлены нашим собственным мозгом. Модель стандартного нейрона изобретена более пятидесяти лет назад и состоит из трех основных частей:
- Дентрит(ы) (Dendrite) - ответственны за сбор поступающих сигналов;
- Сома (Soma) - ответствена за основную обработку и суммирование сигналов;
- Аксон (Axon) - отвечает за передачу сигналов другим дендритам.
Работу нейрона можно описать примерно так: дендриды собирают сигналы, полученные от других нейронов, затем сомы выполняют суммирование и вычисление сигналов и данных, и наконец на основе результата обработки могут "сказать" аксонам передать сигнал дальше. Передача далее зависит от ряда факторов, но мы можем смоделировать это поведение как передаточную функцию, которая принимает входные данные, обрабатывает их и готовит выходные данные, если выполняются свойства передаточной функции.
Биологический нейрон - сложная система, математическая модель которого до сих пор полностью не построена. Введено множество моделей, различающихся вычислительной сложностью и сходством с реальным нейроном. Одна из важнейших - формальный нейрон (ФН). Несмотря на простоту ФН, сети, построенные из таких нейронов, могут сформировать произвольную много мерную функцию на выходе (источник: Заенцев И. В. Нейронные сети: основные модели).
Нейрон состоит из взвешенного сумматора и нелинейного элемента. Функционирование нейрона определяется формулами:
Нейрон имеет несколько входных сигналов x и один выходной сигнал OUT . Параметрами нейрона, определяющими его работу, являются: вектор весов w , пороговый уровень θ и вид функции активации F .
Нейронные сети привлекают к себе внимание за счет следующих возможностей:
- способны решать трудно формализуемые задачи;
- присущ параллельный принцип работы, что очень важно при обработке больших объемов данных;
- способность к обучению и способность к обобщению;
- толерантность к ошибкам;
К основным свойствам нейронных сетей можно отнести:
Способность обучаться . Нейронные сети не программируются, а обучаются на примерах. После предъявления входных сигналов (возможно, вместе с требуемыми выходами) сеть настраивают свои параметры таким образом, чтобы обеспечивать требуемую реакцию.
Обобщение . Отклик сети после обучения может быть до некоторой степени нечувствителен к небольшим изменениям входных сигналов. Эта внутренне присущая способность "видеть"" образ сквозь шум и искажения очень важна для распознавания образов. Важно отметить, что искусственная нейронная сеть делает обобщения автоматически благодаря своей структуре, а не с помощью использования "человеческого интеллекта"" в форме специально написанных компьютерных программ.
Параллелизм . Информация в сети обрабатывается параллельно, что позволяет достаточно выполнять сложную обработку данных с помощью большого числа простых устройств.
Высокая надежность . Сеть может правильно функционировать даже при выходе из строя части нейронов, за счет того, что вычисления производятся локально и параллельно.
Алгоритм решения задач с помощью многослойного персептрона (источник: Заенцев И. В. Нейронные сети: основные модели)
Чтобы построить многослойный персептрон, необходимо выбрать его параметры. Чаще всего выбор значений весов и порогов требует обучения, т.е. пошаговых изменений весовых коэффициентов и пороговых уровней.
Общий алгоритм решения:
- Определить, какой смысл вкладывается в компоненты входного вектора x . Входной вектор должен содержать формализованное условие задачи, т.е. всю информацию, необходимую для получения ответа.
- Выбрать выходной вектор y таким образом, чтобы его компоненты содержали полный ответ поставленной задачи.
- Выбрать вид нелинейности в нейронах (функцию активации). При этом желательно учесть специфику задачи, т.к. удачный выбор сократит время обучения.
- Выбрать число слоев и нейронов в слое.
- Задать диапазон изменения входов, выходов, весов и пороговых уровней, учитывая множество значений выбранной функции активации.
- Присвоить начальные значения весовым коэффициентам и пороговым уровням и дополнительным параметрам (например, крутизне функции активации, если она будет настраиваться при обучении). Начальные значения не должны быть большими, чтобы нейроны не оказались в насыщении (на горизонтальном участке функции активации), иначе обучение будет очень медленным. Начальные значения не должны быть и слишком малыми, чтобы выходы большей части нейронов не были равны нулю, иначе обучение также замедлится.
- Провести обучение, т.е. подобрать параметры сети так, чтобы задача решалась наилучшим образом. По окончании обучения сеть готова решить задачи того типа, которым она обучена.
- Подать на вход сети условия задачи в виде вектора x . Рассчитать выходной вектор y , который и даст формализованное решение задачи.
Решаемые проблемы
Проблемы решаемые с помощью нейронных сетей ().
Классификация образов . Задача состоит в указании принадлежности входного образа (например, речевого сигнала или рукописного символа), представленного вектором признаков, одному или нескольким предварительно определенным классам. К известным приложениям относятся распознавание букв, распознавание речи, классификация сигнала электрокардиограммы, классификация клеток крови.
Кластеризация/категоризация . При решении задачи кластеризации, которая известна также как классификация образов "без учителя", отсутствует обучающая выборка с метками классов. Алгоритм кластеризации основан на подобии образов и размещает близкие образы в один кластер. Известны случаи применения кластеризации для извлечения знаний, сжатия данных и исследования свойств данных.
Аппроксимация функций . Предположим, что имеется обучающая выборка ((x1,y1), (x2,y2)..., (xn,yn)) (пары данных вход-выход), которая генерируется неизвестной функцией (x), искаженной шумом. Задача аппроксимации состоит в нахождении оценки неизвестной функции (x). Аппроксимация функций необходима при решении многочисленных инженерных и научных задач моделирования.
Предсказание/прогноз . Пусть заданы n дискретных отсчетов {y(t1), y(t2)..., y(tn)} в последовательные моменты времени t1, t2,..., tn . Задача состоит в предсказании значения y(tn+1) в некоторый будущий момент времени tn+1. Предсказание/прогноз имеют значительное влияние на принятие решений в бизнесе, науке и технике. Предсказание цен на фондовой бирже и прогноз погоды являются типичными приложениями техники предсказания/прогноза.
Оптимизация . Многочисленные проблемы в математике, статистике, технике, науке, медицине и экономике могут рассматриваться как проблемы оптимизации. Задачей алгоритма оптимизации является нахождение такого решения, которое удовлетворяет системе ограничений и максимизирует или минимизирует целевую функцию. Задача коммивояжера, относящаяся к классу NP-полных, является классическим примером задачи оптимизации.
Память, адресуемая по содержанию . В модели вычислений фон Неймана обращение к памяти доступно только посредством адреса, который не зависит от содержания памяти. Более того, если допущена ошибка в вычислении адреса, то может быть найдена совершенно иная информация. Ассоциативная память, или память, адресуемая по содержанию, доступна по указанию заданного содержания. Содержимое памяти может быть вызвано даже по частичному входу или искаженному содержанию. Ассоциативная память чрезвычайно желательна при создании мультимедийных информационных баз данных.
Управление . Рассмотрим динамическую систему, заданную совокупностью {u(t), y(t)}, где u(t) является входным управляющим воздействием, а y(t) - выходом системы в момент времени t. В системах управления с эталонной моделью целью управления является расчет такого входного воздействия u(t), при котором система следует по желаемой траектории, диктуемой эталонной моделью. Примером является оптимальное управление двигателем.
Виды архитектур
Архитектура нейронной сети - способ организации и связи отдельных элементов нейросети(нейронов). Архитектурные отличия самих нейронов заключаются главным образом в использовании различных активационных (возбуждающих) функций. По архитектуре связей нейронные сети можно разделить на два класса: сети прямого распространения и рекуррентные сети.
Классификация искусственных нейронных сетей по их архитектуре приведена на рисунке ниже.
Похожая классификация, но немного расширенная
Сеть прямого распространения сигнала (сеть прямой передачи) - нейронная сеть без обратных связей (петель). В такой сети обработка информации носит однонаправленный характер: сигнал передается от слоя к слою в направлении от входного слоя нейросети к выходному. Выходной сигнал (ответ сети) гарантирован через заранее известное число шагов (равное числу слоев). Сети прямого распространения просты в реализации, хорошо изучены. Для решения сложных задач требуют большого числа нейронов.
Сравнительная таблица многослойного персепторна и RBF-сети
| Многослойный персептрон | RBF-сети |
|---|---|
| Граница решения представляет собой пересечение гиперплоскостей | Граница решения - это пересечение гиперсфер, что задает границу более сложной формы |
| Сложная топология связей нейронов и слоев | Простая 2-слойная нейронная сеть |
| Сложный и медленно сходящийся алгоритм обучения | Быстрая процедура обучения: решение системы уравнений + кластеризация |
| Работа на небольшой обучающей выборке | Требуется значительное число обучающих данных для приемлемого результат |
| Универсальность применения: кластеризация, аппроксимация, управление и проч | Как правило, только аппроксимация функций и кластеризация |
Значение производной легко выражается через саму функцию. Быстрый расчет производной ускоряет обучение.
Гауссова кривая
Применяется в случаях, когда реакция нейрона должна быть максимальной для некоторого определенного значения NET.
Модули python для нейронных сетей
Простой пример
В качестве примера приведу простую нейроную сеть (простой персептрон ), которая после обучения сможет распознавать летающие объекты, не все, а только чайку :), все остальные входные образы будут распознаваться как НЛО .
# encoding=utf8 import random class NN: def __init__(self, threshold, size): """ Установим начальные параметры. """ self.threshold = threshold self.size = size self.init_weight() def init_weight(self): """ Инициализируем матрицу весов случайными данными. """ self.weights = [ for j in xrange(self.size)] def check(self, sample): """ Считаем выходной сигнал для образа sample. Если vsum > self.threshold то можно предположить, что в sample есть образ чайки. """ vsum = 0 for i in xrange(self.size): for j in xrange(self.size): vsum += self.weights[i][j] * sample[i][j] if vsum > self.threshold: return True else: return False def teach(self, sample): """ Обучение нейронной сети. """ for i in xrange(self.size): for j in xrange(self.size): self.weights[i][j] += sample[i][j] nn = NN(20, 6) # Обучаем нейронную сеть. tsample1 = [ , , , , , , ] nn.teach(tsample1) tsample2 = [ , , , , , , ] nn.teach(tsample2) tsample3 = [ , , , , , , ] nn.teach(tsample3) tsample4 = [ , , , , , , ] nn.teach(tsample4) # Проверим что может нейронная сеть. # Передадим образ чайки, который примерно похож на тот, про который знает персептрон. wsample1 = [ , , , , , , ] print u"чайка" if nn.check(wsample1) else u"НЛО" # Передадим неизвестный образ. wsample2 = [ , , , , , , ] print u"чайка" if nn.check(wsample2) else u"НЛО" # Передадим образ чайки, который примерно похож на тот, про который знает персептрон. wsample3 = [ , , , , , , ] print u"чайка" if nn.check(wsample3) else u"НЛО"
Оригинал: Creating a Neural Network in Python
Автор: John Serrano
Дата публикации: 26 мая 2016 г.
Перевод: А.Панин
Дата перевода: 6 декабря 2016 г.
Нейронные сети являются крайне сложными программами, доступными для понимания лишь академикам и гениям, с которыми по определению не могут работать обычные разработчики, не говоря уже обо мне. Вы ведь так думаете?
Ну, на самом деле все совсем не так. После отличного выступления Луиса Моньера и Грега Ренарда в Колледже Холбертон я понял, что нейронные сети являются достаточно простыми для понимания и реализации любым разработчиком программами. Разумеется, самые сложные сети представляют собой масштабные проекты с элегантной и замысловатой архитектурой, но положенные в их основу концепции также являются более или менее очевидными. Разработка любой нейронной сети с нуля может оказаться достаточно сложной задачей, но, к счастью, существует несколько отличных библиотек, которые могут выполнять всю низкоуровневую работу за вас.
В данном контексте нейрон является довольно простой сущностью. Он принимает несколько входных значений и в том случае, если сумма этих значений превышает заданный предел, активируется. При этом каждое входное значение умножается на его вес. Процесс обучения по сути является процессом установки весов значений для генерации необходимых выходных значений. Сети, которые будут рассматриваться в данной статье, называются сетями "прямого распространения", и это означает, что нейроны в них расположены по уровням, причем их входные данные приходят с предыдущего уровня а выходные - отправляются на следующий уровень.
Существуют нейронные сети и других типов, такие, как рекуррентные нейронные сети, которые организованы отличным образом, но это тема для другой статьи.
Нейрон, работающий по описанному выше принципу, называется перцептроном и основан на оригинальной модели искусственных нейронов, которая на сегодняшний день используется крайне редко. Проблема перцептронов заключается в том, что небольшое изменение входных значений может привести к значительному изменению выходного значения из-за ступенчатой функции активации. При этом незначительное уменьшение входного значения может привести к тому, что внутреннее значение не будет превышать установленный предел и нейрон не будет активироваться, что приведет к еще более значительным изменениям состояния следующих за ним нейронов. К счастью, эта проблема легко решается с помощью более плавной функции активации, которая используется в большинстве современных сетей.
Однако, наша нейронная сеть будет настолько простой, что для ее создания вполне подойдут перцептроны. Мы будем создавать сеть, выполняющую логическую операцию "И". Это означает, что нам понадобятся два входных нейрона и один выходной нейрон, а также несколько нейронов на промежуточном "скрытом" уровне. На иллюстрации ниже показана архитектура данной сети, которая должна быть вполне очевидной.
Моньер и Ренард использовали сценарий convnet.js для создания демонстрационных сетей для своего выступления. Convnet.js может использоваться для создания нейронных сетей непосредственно в вашем веб-браузере, что позволяет вам исследовать и модифицировать их практически на любой платформе. Конечно же, у данной реализации на языке JavaScript присутствуют и значительные недостатки, одним из которых является низкая скорость работы. Ну а в рамках данной статьи мы будем использовать библиотеку FANN (Fast Artifical Neural Networks). При этом на уровне языка программирования Python будет использоваться модуль pyfann, который содержит биндинги для библиотеки FANN. Вам следует установить пакет программного обеспечения с данным модулем прямо сейчас.
Импорт модуля для работы с библиотекой FANN осуществляется следующим образом:
>>> from pyfann import libfann
Теперь мы можем начать работу! Первой операцией, которую нам придется выполнить, является создание пустой нейронной сети.
>>> neural_net = libfann.neural_network()
Созданный объект neural_net на данный момент не содержит нейронов, поэтому давайте попробуем создать их. Для этой цели мы будем использовать функцию libfann.create_standard_array() . Функция create_standard_array() создает нейронную сеть, в которой все нейроны соединены с нейронами из соседних уровней, поэтому ее можно назвать "полностью соединенной" сетью. В качестве параметра функция create_standard_array() принимает массив с числовыми значениями, соответствующими количеству нейронов на каждом из уровней. В нашем случае это массив .
>>> neural_net.create_standard((2, 4, 1))
После этого нам придется установить значение скорости обучения. Данное значение соответствует количеству изменений весов в рамках одной итерации. Мы установим достаточно высокую скорость обучения, равную 0.7 , так как мы будем решать с помощью нашей сети достаточно простую задачу.
>>> neural_net.set_learning_rate(0.7)
Теперь пришло время установить функцию активации, назначение которой обсуждалось выше. Мы будем использовать режим активации SIGMOID_SYMMETRIC_STEPWISE , который соответствует функции ступенчатой аппроксимации гиперболического тангенса. Она является менее точной и более быстрой, чем обычная функция гиперболического тангенса и отлично подходит для нашей задачи.
>>> neural_net.set_activation_function_output(libfann.SIGMOID_SYMMETRIC_STEPWISE)
Наконец, нам нужно запустить алгоритм обучения сети и сохранить данные сети в файле. Функция обучения сети принимает четыре аргумента: имя файла с данными, на основе которых будет осуществляться обучение, максимальное количество попыток запуска алгоритма обучения, количество операций обучения перед выводом данных о состоянии сети, а также частота ошибок.
>>> neural_network.train_on_file("and.data", 10000, 1000, .00001) >>> neural_network.save("and.net")
Файл "and.data" должен содержать следующие данные:
4 2 1 -1 -1 -1 -1 1 -1 1 -1 -1 1 1 1
Первая строка содержит три значения: количество примеров в файле, количество входных значений и количество выходных значений. Ниже расположены строки примеров, причем в строках с двумя значениями приведены входные значения, а в строках с одним значением - выходные.
Вы успешно закончили обучение сети и теперь хотите испытать ее в работе, не так ли? Но сначала нам придется загрузить данные сети из файла, в котором они были сохранены ранее.
>>> neural_net = libfann.neural_net() >>> neural_net.create_from_file("and.net")
После этого мы можем просто активировать ее аналогичным образом:
>>> print neural_net.run()
В результате должно быть выведено значение [-1.0] или аналогичное значение, зависящее от данных сети, сгенерированных в процессе ее обучения.
Поздравляю! Вы только что научили компьютер выполнять простейшие логические операции!
В этой части предсавлены ссылки на статьи из рунета о том, что такое нейросети. Многие из статей написаны оригинальным живым языком и очень доходчивы. Однако здесь по большей части рассматриваются только самые азы, самые простые конструкции. Здесь же можно найти сылки на литературу по нейросетям. Учебники и книги, как им и положено, написаны академическим или приближающимся к нему языком и содержат малопонятные абстрактные примеры построения нейросетей, их обучения и пр. Следует иметь ввиду, что терминология в разных статьях "плавает", что видно по комментариям к статьям. Из-за этого на первых порах может возникнуть "каша в голове".
- Как японский фермер при помощи глубокого обучения и TensorFlow огурцы сортировал
- Нейронные сети в картинках: от одного нейрона до глубоких архитектур
- Пример программы нейронной сети с исходным кодом на с++.
- Реализация однослойной нейронной сети - перцептрона для задачи классификации автотранспорта
- Скачать книги по нейронным сетям . Полезно!
- Технологии фондового рынка: 10 заблуждений о нейронных сетях
- Алгоритм обучения многослойной нейронной сети методом обратного распространения ошибки (Backpropagation)
Нейросети на Python
О том, какие библиотеки существуют для Питона можно кратенько прочитать . Отсюда же я буду брать тестовые примеры для того, чтобв убедиться, что требуемый пакет установлен корректно.
tensorflow
Центральным объектом TensorFlow является граф потока данных, представляющий вычисления. Вершины графа представляют операции (operation), а ребра – тензоры (tensor) (многомерные массивы, являющиеся основой TensorFlow). Граф потока данных в целом является полным описанием вычислений, которые реализуются в рамках сессии (session) и выполняются на устройствах (device) (CPU или GPU). Как и многие другие современные системы для научных вычислений и машинного обучения, TensorFlow имеет хорошо документированный API для Python, где тензоры представлены в виде знакомых массивов ndarray библиотеки NumPy. TensorFlow выполняет вычисления с помощью высоко оптимизированного C++, а также поддерживает нативный API для C и C++.
- Введение в машинное обучение с tensorflow . Пока опубликована только первая статья из четырех анонсированных.
- TensorFlow разочаровывает. Глубокому обучению от Google не хватает «глубины»
- Общий взгляд на машинное обучение: классификация текста с помощью нейронных сетей и TensorFlow
- Библиотека машинного обучения Google TensorFlow – первые впечатления и сравнение с собственной реализацией
Установка tensorflow хорошо описана в статье по первой ссылке. Однако, сейчас уже вышла версия Python 3.6.1. Её использовать не получиться. По крайней сере на данный момент (03.06.2017). Требуется версия 3.5.3, которую можно скачать . Ниже приведу последовательность, которая сработала у меня (немного не как к статье с Хабра). Непонятно почему, но Python 64-бит сделан под процессор AMD соответственно и всё остальное под него. После установки Phyton не забываем установить полный доспуп для пользователей если Python устанавливался для всех.
pip install --upgrade pip
pip install -U pip setuptools
pip3 install --upgrade tensorflow
pip3 install --upgrade tensorflow-gpu
pip install matplotlib /*Загружает 8,9 Мб и ещё пару небольших файлов */
pip install jupyter
"Голый Python" может показаться малоинтересным. Поэтому далее инструкция по установке в среду Anaconda . Это альтернативная сборка. Python уже интегрирован в неё.
На сайте опять фигурирует новая версия под Python 3.6, которую пока новый Google-продукт не поддерживает. Поэтому я сразу взял из архива более раннюю версию, а именно Anaconda3-4.2.0 - она подходит. Не забываем установить флажек регистрации Python 3.5. Конкретно Перед установкой Anaconda термилал лучше закрыть иначе он так и будет работать с устаревшим PATH. Также не забываем изменять права доступа пользователей иначе ничего не получиться.
conda create -n tensorflow
activate tensorflow
pip install --ignore-installed --upgrade https://storage.googleapis.com/tensorflow/windows/cpu/tensorflow-1.1.0-cp35-cp35m-win_amd64.whl /*Загружается из Сети 19.4 Мб, потом 7,7 Мб и ещё 0,317 Мб*/
pip install --ignore-installed --upgrade https://storage.googleapis.com/tensorflow/windows/gpu/tensorflow_gpu-1.1.0-cp35-cp35m-win_amd64.whl /*Загружается 48,6 Мб */
Скрин экрана установки: в Anaconda всё проходит удачно.
Аналогично для второго файла.
Ну и в заключение: для того, чтобы всё это заработало, нужно установить пакет CUDA Toolkits от NVIDEA (в случае использования GPU). Текущая поддерживаемая версия 8.0. Ещё нужно будет скачать и распаковать в папку с CUDA библиотеку cuDNN v5.1, но не более новой версии! После всех этих манипуляций TensorFlow заработает.
Theano
- Рекурентная нейронная сеть в 10 строчек кода оценила отзывы зрителей нового эпизода “Звездных войн”
Пакет Theano входит PyPI самого Python. Сам по себе он маленький - 3,1 Мб, но тянет за собой зависимости ещё на 15 Мб - scipy. Для установки последнего нужен ещё модуль lapack... В общем, установка пакета theano под Windows будет означать "танцы с бубном". Ниже я постараюсь показать последовательность действий для того, чтобы пакет все-таки заработал.
При использовании Anaconda "танцы с бубном" при установке не актуальны. Достаточно команды:
conda install theano
и процесс проходит автоматически. Кстати, загружаються и пакеты GCC.
Scikit-Learn
Под Python 3.5.3 устанавливается и запускается только более ранняя версия 0.17.1 взять которую можно . Есть нормальный инсталятор. Тем не менее прямо так под Windows он работать не будет - нужна библиотека scipy.
Установка вспомогательных пакетов
Для того, чтобы обозначенные выше два пакета заработали (речь о "голом" Phyton), нужно сделать некоторые предварительные действия.
SciPy
Для запуска Scikit-Learn и Theano, как уже стало понятно из вышеизложнного, потребуется "потанцевать с бубном". Первое, что нам выдает Yandex - это кладезь мудрости, правда англоязычный, ресурс stackoverflow.com , где мы находим ссылочку на отличный архив почти всех существующих для Python, пакетов, скомпиллированных под Windows - lfd.uci.edu
Здесь есть готовые к установке сборки интересующих в данный момент пакетов, скомпиллированные для разных версий Python. В нашем случае требуются версии файлов, сореджание в своем имени строку "-cp35-win_amd64" потому что именно такой пакет Python был использован для установки. На stakowerflow, если поискать, то можно найти и "инструкции " по установке конкретно наших пакетов.
pip install --upgrade --ignore-installed http://www.lfd.uci.edu/~gohlke/pythonlibs/vu0h7y4r/numpy-1.12.1+mkl-cp35-cp35m-win_amd64.whl
pip install --upgrade --ignore-insalled http://www.lfd.uci.edu/~gohlke/pythonlibs/vu0h7y4r/scipy-0.19.0-cp35-cp35m-win_amd64.whl
pip --upgrade --ignore-installed pandas
pip install --upgrade --ignore-installed matplotlib
Два последних пакета возникли в моей цепочке из-за чужих "танцев с бубном". В зависимостях устанавливаемых пакетов их я не заметил, но видимо какие-то их комноненты нужны для нормального прохождения процесса установки.
Lapack/Blas
Эти две связанные низкоуровневые библиотеки, написанные на Фортране, нужны для установки пакета Theano. Scikit-Learn может работать и на тех, которые "в скрытом виде" уже установились в других пакетах (см. выше). Собственно если Theano установлено версии 0.17 из exe-файла, то тоже заработает. В Anaconda по крайней мере. Тем не менее эти библиотеки тоже можно найти в Сети. Например . Более свежие сборки . Для работы готового пакета предыдущей версии это подходит. Для сборки нового пакета потребуются новые версии.
Также следует отметить, что в совершенно свежей сборке Anaconda пакет Theano устанавливается намного проще - одной командой, но мне, честно говоря, на данном этапе (нулевом) освоения нейросетей больше приглянулся TensorFlow, а он пока с новыми версиями Python не дружит.
Мы сейчас переживаем настоящий бум нейронных сетей. Их применяют для распознания, локализации и обработки изображений. Нейронные сети уже сейчас умеют многое что не доступно человеку. Нужно же и самим вклиниваться в это дело! Рассмотрим нейтронную сеть которая будет распознавать числа на входном изображении. Все очень просто: всего один слой и функция активации. Это не позволит нам распознать абсолютно все тестовые изображения, но мы справимся с подавляющим большинством. В качестве данных будем использовать известную в мире распознания чисел подборку данных MNIST.
Для работы с ней в Python есть библиотека python-mnist. Что-бы установить:
Pip install python-mnist
Теперь можем загрузить данные
From mnist import MNIST mndata = MNIST("/path_to_mnist_data_folder/") tr_images, tr_labels = mndata.load_training() test_images, test_labels = mndata.load_testing()
Архивы с данными нужно загрузить самостоятельно, а программе указать путь к каталогу с ними. Теперь переменные tr_images и test_images содержат изображения для тренировки сети и тестирования соотвественно. А переменные tr_labels и test_labels - метки с правильной классификацией (т.е. цифры с изображений). Все изображения имеют размер 28х28. Зададим переменную с размером.
Img_shape = (28, 28)
Преобразуем все данные в массивы numpy и нормализуем их (приведем к размеру от -1 до 1). Это увеличит точность вычислений.
Import numpy as np for i in range(0, len(test_images)): test_images[i] = np.array(test_images[i]) / 255 for i in range(0, len(tr_images)): tr_images[i] = np.array(tr_images[i]) / 255
Отмечу, что хоть и изображения принято представлять в виде двумерного массива мы будем использовать одномерный, это проще для вычислений. Теперь нужно понять "что же такое нейронная сеть"! А это просто уравнение с большим количеством коэффициентов. Мы имеем на входе массив из 28*28=784 элементов и еще по 784 веса для определения каждой цифры. В процессе работы нейронной сети нужно перемножить значения входов на веса. Сложить полученные данные и добавить смещение. Полученный результат подать на функцию активации. В нашем случае это будет Relu. Эта функция равна нулю для всех отрицательных аргументов и аргументу для всех положительных.
Есть еще много функций активации! Но это же самая простая нейронная сеть! Определим эту функцию при помощи numpy
Def relu(x): return np.maximum(x, 0)
Теперь чтобы вычислить изображение на картинке нужно просчитать результат для 10 наборов коэффициентов.
Def nn_calculate(img): resp = list(range(0, 10)) for i in range(0,10): r = w[:, i] * img r = relu(np.sum(r) + b[i]) resp[i] = r return np.argmax(resp)
Для каждого набора мы получим выходной результат. Выход с наибольшим результатом вероятнее всего и есть наше число.
В данном случае 7. Вот и все! Но нет... Ведь нужно эти самые коэффициенты где-то взять. Нужно обучить нашу нейронную сеть. Для этого применяют метод обратного распространения ошибки. Его суть в том чтобы рассчитать выходы сети, сравнить их с правильными, а затем отнять от коэффициентов числа необходимые чтобы результат был правильным. Нужно помнить, что для того чтобы вычислить эти значения нужна производная функции активации. В нашем случае она равна нулю для всех отрицательных чисел и 1 для всех положительных. Определим коэффициенты случайным образом.
W = (2*np.random.rand(10, 784) - 1) / 10 b = (2*np.random.rand(10) - 1) / 10 for n in range(len(tr_images)): img = tr_images[n] cls = tr_labels[n] #forward propagation resp = np.zeros(10, dtype=np.float32) for i in range(0,10): r = w[i] * img r = relu(np.sum(r) + b[i]) resp[i] = r resp_cls = np.argmax(resp) resp = np.zeros(10, dtype=np.float32) resp = 1.0 #back propagation true_resp = np.zeros(10, dtype=np.float32) true_resp = 1.0 error = resp - true_resp delta = error * ((resp >= 0) * np.ones(10)) for i in range(0,10): w[i] -= np.dot(img, delta[i]) b[i] -= delta[i]
В процессе обучения коэффициенты станут слегка похожи на числа:
Проверим точность работы:
Def nn_calculate(img): resp = list(range(0, 10)) for i in range(0,10): r = w[i] * img r = np.maximum(np.sum(r) + b[i], 0) #relu resp[i] = r return np.argmax(resp) total = len(test_images) valid = 0 invalid = for i in range(0, total): img = test_images[i] predicted = nn_calculate(img) true = test_labels[i] if predicted == true: valid = valid + 1 else: invalid.append({"image":img, "predicted":predicted, "true":true}) print("accuracy {}".format(valid/total))
У меня получилось 88%. Не так уж круто, но очень интересно!