Python Deep Learning - Краткое руководство
Глубокое структурированное обучение, или иерархическое обучение, или, вкратце, глубокое обучение - это часть семейства методов машинного обучения, которые сами по себе являются подмножеством более широкой области искусственного интеллекта.
Глубокое обучение - это класс алгоритмов машинного обучения, которые используют несколько уровней нелинейных модулей обработки для извлечения и преобразования признаков. Каждый последующий уровень использует выходные данные предыдущего слоя в качестве входных.
Глубокие нейронные сети, сети глубоких убеждений и повторяющиеся нейронные сети применялись в таких областях, как компьютерное зрение, распознавание речи, обработка естественного языка, распознавание звука, фильтрация социальных сетей, машинный перевод и биоинформатика, где они давали результаты, сравнимые с, а в некоторых случаях лучше, чем у экспертов-людей.
Алгоритмы глубокого обучения и сети -
основаны на неконтролируемом обучении нескольких уровней функций или представлений данных. Функции более высокого уровня являются производными от функций более низкого уровня для формирования иерархического представления.
используйте какую-либо форму градиентного спуска для обучения.
В этой главе мы узнаем о среде, настроенной для Python Deep Learning. Нам необходимо установить следующее программное обеспечение для создания алгоритмов глубокого обучения.
- Python 2.7+
- Scipy с Numpy
- Matplotlib
- Theano
- Keras
- TensorFlow
Настоятельно рекомендуется устанавливать Python, NumPy, SciPy и Matplotlib через дистрибутив Anaconda. Он поставляется со всеми этими пакетами.
Нам необходимо обеспечить правильную установку различных типов программного обеспечения.
Давайте перейдем к нашей программе командной строки и введем следующую команду -
$ python
Python 3.6.3 |Anaconda custom (32-bit)| (default, Oct 13 2017, 14:21:34)
[GCC 7.2.0] on linux
Затем мы можем импортировать необходимые библиотеки и распечатать их версии -
import numpy
print numpy.__version__
Вывод
1.14.2
Установка Theano, TensorFlow и Keras
Прежде чем мы начнем установку пакетов - Theano, TensorFlow и Keras, нам нужно подтвердить, что pipустановлено. Система управления пакетами в Anaconda называется pip.
Чтобы подтвердить установку pip, введите в командной строке следующее:
$ pip
После подтверждения установки pip мы можем установить TensorFlow и Keras, выполнив следующую команду -
$pip install theano $pip install tensorflow
$pip install keras
Подтвердите установку Theano, выполнив следующую строку кода -
$python –c “import theano: print (theano.__version__)”
Вывод
1.0.1
Подтвердите установку Tensorflow, выполнив следующую строку кода -
$python –c “import tensorflow: print tensorflow.__version__”
Вывод
1.7.0
Подтвердите установку Keras, выполнив следующую строку кода -
$python –c “import keras: print keras.__version__”
Using TensorFlow backend
Вывод
2.1.5
Искусственный интеллект (ИИ) - это любой код, алгоритм или метод, который позволяет компьютеру имитировать когнитивное поведение или интеллект человека. Машинное обучение (ML) - это подмножество ИИ, которое использует статистические методы, чтобы машины могли учиться и совершенствоваться с опытом. Глубокое обучение - это подмножество машинного обучения, которое делает возможным вычисление многослойных нейронных сетей. Машинное обучение рассматривается как поверхностное обучение, а глубокое обучение - как иерархическое обучение с абстракцией.
Машинное обучение имеет дело с широким спектром концепций. Концепции перечислены ниже -
- supervised
- unsupervised
- обучение с подкреплением
- линейная регрессия
- функции затрат
- overfitting
- under-fitting
- гиперпараметр и др.
В контролируемом обучении мы учимся предсказывать значения на основе помеченных данных. Один из методов машинного обучения, который здесь помогает, - это классификация, в которой целевыми значениями являются дискретные значения; например, кошки и собаки. Еще один метод машинного обучения, который может помочь, - это регресс. Регрессия работает с целевыми значениями. Целевые значения - это непрерывные значения; например, данные фондового рынка можно анализировать с помощью регрессии.
При обучении без учителя мы делаем выводы из входных данных, которые не помечены или не структурированы. Если у нас есть миллион медицинских записей, и мы должны разобраться в этом, найти основную структуру, выбросы или выявить аномалии, мы используем метод кластеризации, чтобы разделить данные на широкие кластеры.
Наборы данных делятся на обучающие наборы, наборы для тестирования, наборы для проверки и так далее.
Прорыв в 2012 году сделал концепцию глубокого обучения популярной. Алгоритм успешно классифицировал 1 миллион изображений по 1000 категорий, используя 2 графических процессора и новейшие технологии, такие как Big Data.
Связь глубокого обучения и традиционного машинного обучения
Одна из основных проблем, с которыми сталкиваются традиционные модели машинного обучения, - это процесс, называемый извлечением признаков. Программист должен быть конкретным и указывать компьютеру функции, на которые следует обратить внимание. Эти особенности помогут в принятии решений.
Ввод необработанных данных в алгоритм редко работает, поэтому извлечение функций является важной частью традиционного рабочего процесса машинного обучения.
Это возлагает огромную ответственность на программиста, а эффективность алгоритма во многом зависит от того, насколько изобретателен программист. Для сложных задач, таких как распознавание объектов или распознавание почерка, это огромная проблема.
Глубокое обучение с возможностью изучения нескольких уровней представления - один из немногих методов, который помог нам с автоматическим извлечением признаков. Можно предположить, что нижние уровни выполняют автоматическое извлечение признаков, практически не требуя указаний от программиста.
Искусственная нейронная сеть, или просто нейронная сеть для краткости, - не новая идея. Он существует уже около 80 лет.
Так продолжалось до 2011 года, когда глубокие нейронные сети стали популярными благодаря использованию новых технологий, доступности огромных наборов данных и мощных компьютеров.
Нейронная сеть имитирует нейрон, который имеет дендриты, ядро, аксон и терминальный аксон.
Для сети нам понадобится два нейрона. Эти нейроны передают информацию через синапс между дендритами одного и терминальным аксоном другого.
Вероятная модель искусственного нейрона выглядит так -
Нейронная сеть будет выглядеть так, как показано ниже -
Круги - это нейроны или узлы, с их функциями в отношении данных, а линии / ребра, соединяющие их, являются весами / передаваемой информацией.
Каждый столбец - это слой. Первый уровень ваших данных - это входной слой. Тогда все слои между входным и выходным слоями являются скрытыми.
Если у вас есть один или несколько скрытых слоев, значит, у вас неглубокая нейронная сеть. Если у вас много скрытых слоев, значит, у вас глубокая нейронная сеть.
В этой модели у вас есть входные данные, вы их взвешиваете и передаете через функцию в нейроне, которая называется пороговой функцией или функцией активации.
По сути, это сумма всех значений после сравнения с определенным значением. Если вы запускаете сигнал, то результатом будет (1) out, или ничего не выйдет, затем (0). Затем это взвешивается и передается следующему нейрону, и выполняется такая же функция.
Мы можем иметь сигмовидную (s-образную) функцию в качестве функции активации.
Что касается весов, они начинаются случайным образом и уникальны для каждого входа в узел / нейрон.
В типичной «прямой связи», самом основном типе нейронной сети, ваша информация проходит прямо через сеть, которую вы создали, и вы сравниваете результат с тем, что, как вы надеялись, на выходе использовались бы ваши образцы данных.
Отсюда вам необходимо настроить веса, чтобы результат соответствовал желаемому результату.
Акт отправки данных прямо через нейронную сеть называется feed forward neural network.
Наши данные идут от входа к слоям по порядку, а затем к выходу.
Когда мы идем назад и начинаем корректировать веса, чтобы минимизировать потери / затраты, это называется back propagation.
Это optimization problem. На практике с нейронной сетью приходится иметь дело с сотнями тысяч переменных, миллионами или даже больше.
Первое решение заключалось в использовании стохастического градиентного спуска в качестве метода оптимизации. Теперь есть такие варианты, как AdaGrad, Adam Optimizer и так далее. В любом случае это масштабная вычислительная операция. Вот почему нейронные сети в основном лежали на полке более полувека. Совсем недавно у нас даже были возможности и архитектура на наших машинах, чтобы даже подумать о выполнении этих операций, и соответствующие наборы данных с соответствующими размерами.
Для простых задач классификации нейронная сеть относительно близка по производительности к другим простым алгоритмам, таким как K Nearest Neighbours. Реальная полезность нейронных сетей реализуется, когда у нас есть гораздо большие данные и гораздо более сложные вопросы, которые превосходят другие модели машинного обучения.
Глубокая нейронная сеть (DNN) - это ИНС с несколькими скрытыми слоями между входным и выходным слоями. Подобно мелким ИНС, DNN могут моделировать сложные нелинейные отношения.
Основная цель нейронной сети - получать набор входных данных, выполнять с ними все более сложные вычисления и выдавать выходные данные для решения реальных проблем, таких как классификация. Мы ограничиваемся нейронными сетями прямого распространения.
У нас есть вход, выход и поток последовательных данных в глубокой сети.
Нейронные сети широко используются в задачах контролируемого обучения и обучения с подкреплением. Эти сети основаны на наборе слоев, связанных друг с другом.
В глубоком обучении количество скрытых слоев, в основном нелинейных, может быть большим; говорят около 1000 слоев.
Модели DL дают гораздо лучшие результаты, чем обычные сети ML.
В основном мы используем метод градиентного спуска для оптимизации сети и минимизации функции потерь.
Мы можем использовать Imagenet, хранилище миллионов цифровых изображений для классификации набора данных по таким категориям, как кошки и собаки. Сети DL все чаще используются для динамических изображений, помимо статических, а также для анализа временных рядов и текста.
Обучение наборов данных составляет важную часть моделей глубокого обучения. Кроме того, Backpropagation является основным алгоритмом обучения моделей DL.
DL занимается обучением больших нейронных сетей со сложными преобразованиями ввода-вывода.
Одним из примеров DL является сопоставление фотографии с именем человека (лиц) на фотографии, как это делается в социальных сетях, и описание изображения с помощью фразы - еще одно недавнее применение DL.
Нейронные сети - это функции, которые имеют входные данные, такие как x1, x2, x3…, которые преобразуются в выходы, такие как z1, z2, z3 и так далее, двумя (мелкие сети) или несколькими промежуточными операциями, также называемыми слоями (глубокие сети).
Веса и смещения меняются от слоя к слою. «w» и «v» - веса или синапсы слоев нейронных сетей.
Наилучший вариант использования глубокого обучения - это задача контролируемого обучения. Здесь мы имеем большой набор входных данных с желаемым набором выходных данных.
Здесь мы применяем алгоритм обратного распространения, чтобы получить правильный выходной прогноз.
Самый базовый набор данных глубокого обучения - это MNIST, набор рукописных цифр.
Мы можем глубоко обучить сверточную нейронную сеть с помощью Keras, чтобы классифицировать изображения рукописных цифр из этого набора данных.
Срабатывание или активация классификатора нейронной сети дает оценку. Например, чтобы классифицировать пациентов как больных и здоровых, мы учитываем такие параметры, как рост, вес и температура тела, артериальное давление и т. Д.
Высокая оценка означает, что пациент болен, а низкая оценка означает, что он здоров.
У каждого узла в выходном и скрытом слоях есть свои классификаторы. Входной слой принимает входные данные и передает свои оценки следующему скрытому слою для дальнейшей активации, и это продолжается до тех пор, пока не будет достигнут выход.
Этот прогресс от входа к выходу слева направо в прямом направлении называется forward propagation.
Путь присвоения кредита (CAP) в нейронной сети представляет собой серию преобразований, начиная от входа к выходу. CAP детализируют вероятные причинно-следственные связи между входом и выходом.
Глубина CAP для данной нейронной сети с прямой связью или глубина CAP - это количество скрытых слоев плюс один, поскольку включен выходной слой. Для рекуррентных нейронных сетей, где сигнал может распространяться через слой несколько раз, глубина CAP может быть потенциально безграничной.
Глубокие сети и мелкие сети
Нет четкого порога глубины, который отделяет поверхностное обучение от глубокого; но большинство согласны с тем, что для глубокого обучения, имеющего несколько нелинейных уровней, CAP должен быть больше двух.
Базовый узел нейронной сети - это восприятие, имитирующее нейрон в биологической нейронной сети. Затем у нас есть многослойное восприятие или MLP. Каждый набор входных данных изменяется набором весов и смещений; каждое ребро имеет уникальный вес, и каждый узел имеет уникальное смещение.
Предсказание accuracy нейронной сети зависит от ее weights and biases.
Процесс повышения точности нейронной сети называется training. Выход из сети опоры вперед по сравнению с этим значением, которое, как известно, является правильным.
В cost function or the loss function это разница между сгенерированным выходом и фактическим выходом.
Смысл обучения состоит в том, чтобы сделать стоимость обучения как можно меньшей для миллионов обучающих примеров. Для этого сеть настраивает веса и смещения, пока прогноз не будет соответствовать правильному результату.
После правильного обучения нейронная сеть может каждый раз делать точные прогнозы.
Когда шаблон становится сложным, и вы хотите, чтобы ваш компьютер распознал их, вам нужно обратиться к нейронным сетям. В таких сложных сценариях шаблонов нейронная сеть превосходит все другие конкурирующие алгоритмы.
Теперь есть графические процессоры, которые могут обучать их быстрее, чем когда-либо прежде. Глубокие нейронные сети уже революционизируют область ИИ
Компьютеры показали себя хорошими в выполнении повторяющихся вычислений и следовании подробным инструкциям, но не так хороши в распознавании сложных закономерностей.
Если есть проблема распознавания простых шаблонов, машина опорных векторов (SVM) или классификатор логистической регрессии могут хорошо справиться с этой задачей, но по мере увеличения сложности шаблона нет другого выхода, кроме как использовать глубокие нейронные сети.
Следовательно, для сложных шаблонов, таких как человеческое лицо, мелкие нейронные сети терпят неудачу и не имеют альтернативы, кроме как использовать глубокие нейронные сети с большим количеством слоев. Глубокие сети могут выполнять свою работу, разбивая сложные шаблоны на более простые. Например, человеческое лицо; Глубокая сеть будет использовать края для обнаружения таких частей, как губы, нос, глаза, уши и т. д., а затем повторно объединить их вместе, чтобы сформировать человеческое лицо
Точность правильного предсказания стала настолько точной, что недавно на конкурсе Google Pattern Recognition Challenge глубокая сеть обыграла человека.
Идея сети слоистых перцептронов существует уже некоторое время; в этой области глубокие сети имитируют человеческий мозг. Но есть один недостаток в том, что на их обучение уходит много времени из-за аппаратных ограничений.
Однако недавние высокопроизводительные графические процессоры смогли обучить такие глубокие сети менее чем за неделю; в то время как быстрому процессору могли потребоваться недели или, возможно, месяцы, чтобы сделать то же самое.
Выбор глубокой сети
Как выбрать глубокую сеть? Мы должны решить, создаем ли мы классификатор или пытаемся найти закономерности в данных, и собираемся ли мы использовать обучение без учителя. Для извлечения паттернов из набора немаркированных данных мы используем машину Больцмана с ограничениями или автоматический кодировщик.
При выборе глубокой сети учтите следующие моменты:
Для обработки текста, анализа тональности, синтаксического анализа и распознавания сущностей имен мы используем рекуррентную сеть или рекурсивную нейронную тензорную сеть или RNTN;
Для любой языковой модели, которая работает на уровне символов, мы используем повторяющуюся сеть.
Для распознавания изображений мы используем сеть глубокого убеждения DBN или сверточную сеть.
Для распознавания объектов мы используем RNTN или сверточную сеть.
Для распознавания речи мы используем рекуррентную сеть.
В общем, сети глубоких убеждений и многослойные персептроны с выпрямленными линейными единицами или RELU являются хорошим выбором для классификации.
Для анализа временных рядов всегда рекомендуется использовать повторяющуюся сеть.
Нейронные сети существуют уже более 50 лет; но только теперь они стали известными. Причина в том, что их тяжело тренировать; когда мы пытаемся обучить их методом обратного распространения, мы сталкиваемся с проблемой, называемой исчезающими или взрывающимися градиентами. Когда это происходит, обучение занимает больше времени, а точность отходит на второй план. При обучении набора данных мы постоянно вычисляем функцию стоимости, которая представляет собой разницу между прогнозируемым выходом и фактическим выходом из набора помеченных обучающих данных. Затем функция стоимости минимизируется путем корректировки значений весов и смещений до самого низкого значения. получается. В процессе обучения используется градиент, который представляет собой скорость изменения стоимости в зависимости от изменения значений веса или смещения.
Ограниченные сети Больцмана или автоэнкодеры - RBN
В 2006 году был сделан прорыв в решении проблемы исчезающих градиентов. Джефф Хинтон разработал новую стратегию, которая привела к развитиюRestricted Boltzman Machine - RBM, неглубокая двухслойная сетка.
Первый слой - это visible слой, а второй слой - hiddenслой. Каждый узел видимого слоя связан с каждым узлом скрытого слоя. Сеть известна как ограниченная, поскольку никаким двум уровням на одном уровне не разрешено совместно использовать соединение.
Автоэнкодеры - это сети, которые кодируют входные данные как векторы. Они создают скрытое или сжатое представление необработанных данных. Векторы полезны для уменьшения размерности; вектор сжимает необработанные данные в меньшее количество основных измерений. Автоэнкодеры работают в паре с декодерами, что позволяет реконструировать входные данные на основе их скрытого представления.
RBM - это математический эквивалент двустороннего переводчика. Прямой проход принимает входные данные и переводит их в набор чисел, который кодирует входные данные. Тем временем обратный проход берет этот набор чисел и переводит их обратно в восстановленные входные данные. Хорошо натренированная сеть выполняет подпорку спиной с высокой степенью точности.
На любом этапе решающую роль играют веса и смещения; они помогают RBM в расшифровке взаимосвязей между входами и в принятии решения, какие входы важны для выявления закономерностей. Посредством прямого и обратного проходов RBM обучается воссоздавать входные данные с разными весами и смещениями до тех пор, пока вход и повторное построение не станут как можно более близкими. Интересным аспектом RBM является то, что данные не нужно маркировать. Это оказывается очень важным для наборов данных реального мира, таких как фотографии, видео, голоса и данные датчиков, которые, как правило, не имеют маркировки. Вместо того, чтобы вручную маркировать данные людьми, RBM автоматически сортирует данные; правильно регулируя веса и смещения, RBM может извлекать важные особенности и восстанавливать входные данные. RBM является частью семейства нейронных сетей для извлечения признаков, которые предназначены для распознавания внутренних закономерностей в данных. Их также называют автокодировщиками, потому что они должны кодировать свою собственную структуру.
Сети глубокого убеждения - DBN
Сети глубоких убеждений (DBN) формируются путем комбинирования RBM и внедрения умного метода обучения. У нас есть новая модель, которая наконец решает проблему исчезающего градиента. Джефф Хинтон изобрел RBM, а также Deep Belief Nets в качестве альтернативы обратному распространению.
DBN похожа по структуре на MLP (многослойный перцептрон), но сильно отличается, когда дело доходит до обучения. это обучение, которое позволяет DBN превзойти их мелкие аналоги
DBN можно визуализировать как стек RBM, где скрытый уровень одного RBM является видимым слоем RBM над ним. Первый RBM обучается как можно точнее восстанавливать входные данные.
Скрытый слой первого RBM принимается как видимый слой второго RBM, а второй RBM обучается с использованием выходных данных первого RBM. Этот процесс повторяется до тех пор, пока не будет обучен каждый слой сети.
В DBN каждый RBM изучает весь ввод. DBN работает глобально, последовательно настраивая весь ввод, поскольку модель медленно улучшается, как объектив камеры, медленно фокусирующий изображение. Стек RBM превосходит одиночный RBM, поскольку многослойный перцептрон MLP превосходит одиночный перцептрон.
На этом этапе RBM обнаруживают в данных собственные закономерности, но без каких-либо имен или меток. Чтобы завершить обучение DBN, мы должны ввести метки в шаблоны и настроить сеть с помощью контролируемого обучения.
Нам нужен очень небольшой набор помеченных образцов, чтобы функции и шаблоны можно было связать с именем. Этот небольшой набор данных используется для обучения. Этот набор помеченных данных может быть очень маленьким по сравнению с исходным набором данных.
Веса и смещения немного изменяются, что приводит к небольшому изменению восприятия сетью шаблонов и часто небольшому увеличению общей точности.
Обучение также может быть завершено в разумные сроки с использованием графических процессоров, дающих очень точные результаты по сравнению с мелкими сетями, и мы также видим решение проблемы исчезающего градиента.
Генеративные состязательные сети - GAN
Генеративные состязательные сети - это глубокие нейронные сети, состоящие из двух сетей, противопоставленных друг другу, отсюда и название «состязательная».
GAN были представлены в статье, опубликованной исследователями из Монреальского университета в 2014 году. Эксперт Facebook по искусственному интеллекту Янн ЛеКун, имея в виду GAN, назвал состязательное обучение «самой интересной идеей в области машинного обучения за последние 10 лет».
Потенциал GAN огромен, поскольку сканирование сети учится имитировать любое распределение данных. GAN можно научить создавать параллельные миры, поразительно похожие на наш, в любой области: изображения, музыка, речь, проза. В каком-то смысле они художники-роботы, и их работа впечатляет.
В GAN одна нейронная сеть, известная как генератор, генерирует новые экземпляры данных, а другая, дискриминатор, оценивает их на подлинность.
Допустим, мы пытаемся создать рукописные числа, подобные тем, которые содержатся в наборе данных MNIST, взятом из реального мира. Работа дискриминатора, когда ему показан экземпляр из настоящего набора данных MNIST, заключается в том, чтобы распознать их как подлинные.
Теперь рассмотрим следующие шаги GAN -
Сеть генератора принимает входные данные в виде случайных чисел и возвращает изображение.
Это сгенерированное изображение подается в качестве входных данных в сеть дискриминатора вместе с потоком изображений, взятых из фактического набора данных.
Дискриминатор принимает как настоящие, так и поддельные изображения и возвращает вероятности, число от 0 до 1, где 1 означает предсказание подлинности, а 0 - подделку.
Итак, у вас есть двойная петля обратной связи -
Дискриминатор находится в петле обратной связи с достоверной информацией об изображениях, которую мы знаем.
Генератор находится в цепи обратной связи с дискриминатором.
Рекуррентные нейронные сети - RNN
RNNSare нейронные сети, в которых данные могут передаваться в любом направлении. Эти сети используются для таких приложений, как языковое моделирование или обработка естественного языка (NLP).
Основная концепция, лежащая в основе RNN, заключается в использовании последовательной информации. В обычной нейронной сети предполагается, что все входы и выходы независимы друг от друга. Если мы хотим предсказать следующее слово в предложении, мы должны знать, какие слова были перед ним.
RNN называются повторяющимися, поскольку они повторяют одну и ту же задачу для каждого элемента последовательности, а результат основан на предыдущих вычислениях. Таким образом, можно сказать, что RNN имеют «память», которая фиксирует информацию о том, что было ранее вычислено. Теоретически RNN могут использовать информацию в очень длинных последовательностях, но в действительности они могут оглядываться назад только на несколько шагов.
Сети с долговременной краткосрочной памятью (LSTM) являются наиболее часто используемыми RNN.
Вместе со сверточными нейронными сетями, RNN использовались как часть модели для генерации описаний немаркированных изображений. Удивительно, насколько хорошо это работает.
Сверточные глубокие нейронные сети - CNN
Если мы увеличим количество слоев в нейронной сети, чтобы сделать ее глубже, это повысит сложность сети и позволит нам моделировать более сложные функции. Однако количество весов и смещений будет экспоненциально расти. Фактически, изучение таких сложных задач может стать невозможным для обычных нейронных сетей. Это приводит к решению - сверточным нейронным сетям.
CNN широко используются в компьютерном зрении; были применены также в акустическом моделировании для автоматического распознавания речи.
Идея сверточных нейронных сетей заключается в идее «движущегося фильтра», который проходит через изображение. Этот движущийся фильтр или свертка применяется к определенной окрестности узлов, которые, например, могут быть пикселями, где применяемый фильтр составляет 0,5 x значение узла -
Известный исследователь Янн ЛеКун был пионером сверточных нейронных сетей. Facebook как программное обеспечение для распознавания лиц использует эти сети. CNN была идеальным решением для проектов машинного зрения. В сверточной сети много уровней. В испытании Imagenet в 2015 году машина смогла победить человека в распознавании объектов.
Вкратце, сверточные нейронные сети (CNN) - это многослойные нейронные сети. Слои иногда могут быть до 17 и более, и предполагается, что входными данными являются изображения.
CNN резко сокращают количество параметров, которые необходимо настроить. Таким образом, CNN эффективно обрабатывают необработанные изображения высокой размерности.
В этой главе мы рассмотрим основы глубокого обучения Python.
Модели / алгоритмы глубокого обучения
Давайте теперь узнаем о различных моделях / алгоритмах глубокого обучения.
Вот некоторые из популярных моделей глубокого обучения:
- Сверточные нейронные сети
- Рекуррентные нейронные сети
- Сети глубоких убеждений
- Генеративные состязательные сети
- Автокодеры и т. Д.
Входы и выходы представлены в виде векторов или тензоров. Например, нейронная сеть может иметь входы, где отдельные пиксельные значения RGB в изображении представлены как векторы.
Слои нейронов, лежащие между входным и выходным слоями, называются скрытыми слоями. Именно здесь происходит большая часть работы, когда нейронная сеть пытается решить проблемы. Более пристальный взгляд на скрытые слои может многое рассказать об особенностях, которые сеть научилась извлекать из данных.
Различные архитектуры нейронных сетей формируются путем выбора нейронов для подключения к другим нейронам следующего слоя.
Псевдокод для вычисления вывода
Ниже приведен псевдокод для расчета вывода Forward-propagating Neural Network -
- # node []: = массив топологически отсортированных узлов
- # Ребро от a до b означает, что a находится слева от b
- # Если нейронная сеть имеет R входов и S выходов,
- # тогда первые R узлов являются входными узлами, а последние S узлов являются выходными узлами.
- # incoming [x]: = узлы, подключенные к узлу x
- # weight [x]: = веса входящих ребер в x
Для каждого нейрона x слева направо -
- if x <= R: ничего не делать # это входной узел
- входы [x] = [выход [i] для i во входящем [x]]
- weighted_sum = dot_product (веса [x], входы [x])
- output [x] = Функция_активации (взвешенная_сумма)
Теперь мы узнаем, как обучать нейронную сеть. Мы также изучим алгоритм обратного распространения и обратный проход в Python Deep Learning.
Нам нужно найти оптимальные значения весов нейронной сети, чтобы получить желаемый результат. Для обучения нейронной сети мы используем метод итеративного градиентного спуска. Сначала мы начнем со случайной инициализации весов. После случайной инициализации мы делаем прогнозы для некоторого подмножества данных с процессом прямого распространения, вычисляем соответствующую функцию стоимости C и обновляем каждый вес w на величину, пропорциональную dC / dw, т. Е. Производную функций затрат относительно вес. Константа пропорциональности известна как скорость обучения.
Градиенты можно эффективно вычислить с помощью алгоритма обратного распространения. Ключевое наблюдение обратного распространения или обратной опоры заключается в том, что из-за цепного правила дифференциации градиент на каждом нейроне в нейронной сети может быть вычислен с использованием градиента на нейронах, к которым у него есть выходящие края. Следовательно, мы вычисляем градиенты в обратном направлении, то есть сначала вычисляем градиенты выходного слоя, затем самого верхнего скрытого слоя, за которым следует предыдущий скрытый слой, и так далее, заканчивая входным слоем.
Алгоритм обратного распространения реализован в основном с использованием идеи вычислительного графа, где каждый нейрон расширяется до множества узлов в вычислительном графе и выполняет простую математическую операцию, такую как сложение, умножение. Вычислительный граф не имеет весов на ребрах; все веса назначаются узлам, поэтому веса становятся их собственными узлами. Затем на вычислительном графе запускается алгоритм обратного распространения. После завершения расчета для обновления требуются только градиенты узлов веса. От остальных градиентов можно отказаться.
Техника оптимизации градиентного спуска
Одна из часто используемых функций оптимизации, которая корректирует веса в соответствии с вызванной ими ошибкой, называется «градиентный спуск».
Градиент - это другое название уклона, а уклон на графике xy представляет, как две переменные связаны друг с другом: подъем на пробеге, изменение расстояния с течением времени и т. Д. В этом случае наклон равен отношение ошибки сети к единичному весу; т.е. как изменяется ошибка при изменении веса.
Точнее говоря, мы хотим найти, какой вес дает наименьшую ошибку. Мы хотим найти вес, который правильно представляет сигналы, содержащиеся во входных данных, и преобразовать их в правильную классификацию.
По мере обучения нейронная сеть медленно регулирует множество весов, чтобы они могли правильно сопоставить сигнал со значением. Отношение между ошибкой сети и каждым из этих весов является производной, dE / dw, которая вычисляет степень, в которой небольшое изменение веса вызывает небольшое изменение ошибки.
Каждый вес - это всего лишь один фактор в глубокой сети, которая включает в себя множество преобразований; сигнал веса проходит через активации и суммируется на нескольких уровнях, поэтому мы используем цепное правило исчисления, чтобы проработать сетевые активации и выходы. Это приводит нас к рассматриваемому весу и его связи с общей ошибкой.
Учитывая, что две переменные, ошибка и вес, опосредуются третьей переменной, activation, через которую проходит груз. Мы можем рассчитать, как изменение веса влияет на изменение ошибки, сначала рассчитав, как изменение в активации влияет на изменение ошибки и как изменение веса влияет на изменение активации.
Основная идея глубокого обучения - это не что иное, как корректировка весов модели в ответ на ошибку, которую она производит, до тех пор, пока вы не сможете больше уменьшить ошибку.
Глубокая сеть тренируется медленно, если значение градиента небольшое, и быстро, если значение высокое. Любые неточности в обучении приводят к неточным результатам. Процесс обучения сетей от выхода обратно к входу называется обратным распространением или обратной опорой. Мы знаем, что прямое распространение начинается с ввода и идет вперед. Back prop выполняет обратное / противоположное вычисление градиента справа налево.
Каждый раз, когда мы вычисляем градиент, мы используем все предыдущие градиенты до этой точки.
Начнем с узла выходного слоя. Край использует градиент в этом узле. Когда мы возвращаемся к скрытым слоям, все становится сложнее. Произведение двух чисел от 0 до 1 дает меньшее число. Значение градиента становится все меньше, и в результате на тренировку обратной опоры уходит много времени, и страдает точность.
Проблемы в алгоритмах глубокого обучения
Как для неглубоких нейронных сетей, так и для глубоких нейронных сетей существуют определенные проблемы, такие как переоснащение и время вычислений. На DNN влияет переобучение из-за использования дополнительных уровней абстракции, которые позволяют им моделировать редкие зависимости в обучающих данных.
Regularizationтакие методы, как выпадение, ранняя остановка, увеличение данных, переносное обучение, применяются во время обучения для борьбы с переобучением. Выпадение регуляризации случайным образом исключает единицы из скрытых слоев во время обучения, что помогает избежать редких зависимостей. DNN учитывают несколько параметров обучения, таких как размер, т. Е. Количество уровней и количество единиц на уровне, скорость обучения и начальные веса. Поиск оптимальных параметров не всегда практичен из-за больших затрат времени и вычислительных ресурсов. Некоторые приемы, такие как пакетная обработка, могут ускорить вычисления. Большая вычислительная мощность графических процессоров значительно помогла процессу обучения, поскольку требуемые матричные и векторные вычисления хорошо выполняются на графических процессорах.
Выбывать
Dropout - популярный метод регуляризации нейронных сетей. Глубокие нейронные сети особенно подвержены переобучению.
Давайте теперь посмотрим, что такое отсев и как это работает.
По словам Джеффри Хинтона, одного из пионеров глубокого обучения, «если у вас есть глубокая нейронная сеть, и она не переоснащается, вам, вероятно, следует использовать более крупную и использовать отсев».
Выпадение - это метод, при котором во время каждой итерации градиентного спуска мы отбрасываем набор случайно выбранных узлов. Это означает, что мы случайным образом игнорируем некоторые узлы, как будто их не существует.
Каждый нейрон сохраняется с вероятностью q и случайно отбрасывается с вероятностью 1-q. Значение q может быть разным для каждого слоя нейронной сети. Значение 0,5 для скрытых слоев и 0 для входного слоя хорошо работает для широкого круга задач.
Во время оценки и прогнозирования отсев не используется. Выходные данные каждого нейрона умножаются на q, чтобы входные данные следующего слоя имели то же ожидаемое значение.
Идея Dropout заключается в следующем: в нейронной сети без регуляризации отсева нейроны развивают взаимозависимость друг от друга, что приводит к переобучению.
Уловка реализации
Отключение реализовано в таких библиотеках, как TensorFlow и Pytorch, путем сохранения значения 0 для случайно выбранных нейронов. То есть, хотя нейрон существует, его выходные данные перезаписываются как 0.
Ранняя остановка
Мы обучаем нейронные сети, используя итерационный алгоритм, называемый градиентным спуском.
Идея ранней остановки интуитивно понятна; мы прекращаем обучение, когда ошибка начинает расти. Здесь под ошибкой мы подразумеваем ошибку, измеренную на данных проверки, которые являются частью обучающих данных, используемых для настройки гиперпараметров. В этом случае гиперпараметр является критерием остановки.
Увеличение данных
Процесс, при котором мы увеличиваем объем имеющихся данных или дополняем его, используя существующие данные и применяя к ним некоторые преобразования. Используемые точные преобразования зависят от задачи, которую мы собираемся решить. Более того, преобразования, которые помогают нейронной сети, зависят от ее архитектуры.
Например, во многих задачах компьютерного зрения, таких как классификация объектов, эффективный метод увеличения данных заключается в добавлении новых точек данных, которые являются обрезанными или переведенными версиями исходных данных.
Когда компьютер принимает изображение в качестве входных данных, он принимает массив значений пикселей. Допустим, все изображение сдвинуто влево на 15 пикселей. Мы применяем множество различных сдвигов в разных направлениях, в результате чего увеличенный набор данных во много раз превышает размер исходного набора данных.
Трансферное обучение
Процесс взятия предварительно обученной модели и «точной настройки» модели с использованием нашего собственного набора данных называется трансферным обучением. Для этого есть несколько способов, которые описаны ниже:
Мы обучаем предварительно обученную модель на большом наборе данных. Затем мы удаляем последний слой сети и заменяем его новым слоем со случайными весами.
Затем мы фиксируем веса всех других слоев и обучаем сеть обычным образом. Здесь замораживание слоев не меняет веса во время градиентного спуска или оптимизации.
Концепция, лежащая в основе этого, заключается в том, что предварительно обученная модель будет действовать как экстрактор признаков, и только последний слой будет обучен текущей задаче.
Обратное распространение реализуется в таких средах глубокого обучения, как Tensorflow, Torch, Theano и т. Д., С использованием вычислительных графов. Что еще более важно, понимание обратного распространения на вычислительных графах объединяет несколько различных алгоритмов и их вариации, такие как обратное распространение во времени и обратное распространение с общими весами. После того, как все преобразовано в вычислительный граф, они по-прежнему остаются тем же алгоритмом - только обратное распространение на вычислительных графах.
Что такое вычислительный граф
Вычислительный граф определяется как ориентированный граф, узлы которого соответствуют математическим операциям. Вычислительные графики - это способ выражения и оценки математического выражения.
Например, вот простое математическое уравнение -
$$p = x+y$$
Мы можем построить вычислительный график вышеуказанного уравнения следующим образом.
Вышеупомянутый вычислительный граф имеет узел сложения (узел со знаком «+») с двумя входными переменными x и y и одним выходом q.
Возьмем другой пример, немного более сложный. У нас есть следующее уравнение.
$$g = \left (x+y \right ) \ast z $$
Вышеупомянутое уравнение представлено следующим вычислительным графиком.
Вычислительные графики и обратное распространение
Вычислительные графы и обратное распространение - важные базовые концепции глубокого обучения для обучения нейронных сетей.
Вперед пас
Прямой проход - это процедура для оценки значения математического выражения, представленного вычислительными графиками. Выполнение прямого прохода означает, что мы передаем значение из переменных в прямом направлении слева (вход) вправо, где находится выход.
Давайте рассмотрим пример, присвоив некоторую ценность всем входам. Предположим, всем входам заданы следующие значения.
$$x=1, y=3, z=−3$$
Дав эти значения входам, мы можем выполнить прямой проход и получить следующие значения для выходов на каждом узле.
Сначала мы используем значение x = 1 и y = 3, чтобы получить p = 4.
Затем мы используем p = 4 и z = -3, чтобы получить g = -12. Идем слева направо, вперед.
Задачи обратного прохода
В обратном проходе мы намерены вычислить градиенты для каждого ввода относительно окончательного вывода. Эти градиенты необходимы для обучения нейронной сети с использованием градиентного спуска.
Например, нам нужны следующие градиенты.
Желаемые градиенты
$$\frac{\partial x}{\partial f}, \frac{\partial y}{\partial f}, \frac{\partial z}{\partial f}$$
Обратный проход (обратное распространение)
Мы начинаем обратный проход с нахождения производной конечного результата по отношению к конечному результату (самому себе!). Таким образом, это приведет к получению тождества, и значение будет равно единице.
$$\frac{\partial g}{\partial g} = 1$$
Наш расчетный график теперь выглядит так, как показано ниже -
Затем мы выполним обратный проход через операцию «*». Мы рассчитаем градиенты в точках p и z. Поскольку g = p * z, мы знаем, что -
$$\frac{\partial g}{\partial z} = p$$
$$\frac{\partial g}{\partial p} = z$$
Мы уже знаем значения z и p из прямого прохода. Отсюда получаем -
$$\frac{\partial g}{\partial z} = p = 4$$
и
$$\frac{\partial g}{\partial p} = z = -3$$
Мы хотим вычислить градиенты по x и y -
$$\frac{\partial g}{\partial x}, \frac{\partial g}{\partial y}$$
Однако мы хотим сделать это эффективно (хотя x и g находятся всего в двух шагах на этом графике, представьте, что они действительно далеко друг от друга). Чтобы вычислить эти значения эффективно, мы будем использовать цепное правило дифференцирования. Из цепного правила у нас есть -
$$\frac{\partial g}{\partial x}=\frac{\partial g}{\partial p}\ast \frac{\partial p}{\partial x}$$
$$\frac{\partial g}{\partial y}=\frac{\partial g}{\partial p}\ast \frac{\partial p}{\partial y}$$
Но мы уже знаем, что dg / dp = -3, dp / dx и dp / dy просты, поскольку p напрямую зависит от x и y. У нас есть -
$$p=x+y\Rightarrow \frac{\partial x}{\partial p} = 1, \frac{\partial y}{\partial p} = 1$$
Отсюда получаем -
$$\frac{\partial g} {\partial f} = \frac{\partial g} {\partial p}\ast \frac{\partial p} {\partial x} = \left ( -3 \right ).1 = -3$$
Кроме того, для входа y -
$$\frac{\partial g} {\partial y} = \frac{\partial g} {\partial p}\ast \frac{\partial p} {\partial y} = \left ( -3 \right ).1 = -3$$
Основная причина сделать это в обратном порядке заключается в том, что, когда нам нужно было вычислить градиент в x, мы использовали только уже вычисленные значения и dq / dx (производная выхода узла по отношению к входу того же узла). Мы использовали локальную информацию для вычисления глобального значения.
Шаги по обучению нейронной сети
Выполните следующие шаги, чтобы обучить нейронную сеть -
Для точки данных x в наборе данных мы выполняем прямой проход с x в качестве входных данных и вычисляем стоимость c в качестве выходных данных.
Мы выполняем обратный проход, начиная с c, и вычисляем градиенты для всех узлов в графе. Сюда входят узлы, которые представляют веса нейронной сети.
Затем мы обновляем веса, выполняя градиенты W = W - скорость обучения *.
Мы повторяем этот процесс до тех пор, пока не будут выполнены критерии остановки.
Глубокое обучение дало хорошие результаты для нескольких приложений, таких как компьютерное зрение, языковой перевод, субтитры изображений, транскрипция аудио, молекулярная биология, распознавание речи, обработка естественного языка, самоуправляемые автомобили, обнаружение опухолей мозга, перевод речи в реальном времени, музыка. композиция, автоматическая игра и так далее.
Глубокое обучение - это следующий большой скачок после машинного обучения с более продвинутой реализацией. В настоящее время он становится отраслевым стандартом, обещая изменить правила игры при работе с необработанными неструктурированными данными.
Глубокое обучение в настоящее время является одним из лучших поставщиков решений для широкого круга реальных проблем. Разработчики создают программы искусственного интеллекта, которые вместо использования ранее заданных правил учатся на примерах для решения сложных задач. Поскольку глубокое обучение используется многими специалистами по обработке данных, более глубокие нейронные сети дают более точные результаты.
Идея состоит в том, чтобы разработать глубокие нейронные сети, увеличивая количество обучающих слоев для каждой сети; машина узнает больше о данных, пока они не станут максимально точными. Разработчики могут использовать методы глубокого обучения для реализации сложных задач машинного обучения и обучать сети искусственного интеллекта высокому уровню восприятия.
Глубокое обучение находит свою популярность в компьютерном зрении. Здесь одной из решаемых задач является классификация изображений, при которой заданные входные изображения классифицируются как кошка, собака и т. Д. Или как класс или метка, которые лучше всего описывают изображение. Мы, люди, учимся выполнять эту задачу очень рано в своей жизни и обладаем навыками быстрого распознавания закономерностей, обобщения предшествующих знаний и адаптации к различным условиям изображения.
В этой главе мы свяжем глубокое обучение с различными библиотеками и фреймворками.
Глубокое обучение и Теано
Если мы хотим начать кодирование глубокой нейронной сети, лучше иметь представление о том, как работают разные фреймворки, такие как Theano, TensorFlow, Keras, PyTorch и т. Д.
Theano - это библиотека Python, которая предоставляет набор функций для построения глубоких сетей, которые быстро обучаются на нашей машине.
Theano был разработан в Монреальском университете, Канада, под руководством Йошуа Бенжио, пионера глубокой сети.
Theano позволяет нам определять и оценивать математические выражения с векторами и матрицами, которые представляют собой прямоугольные массивы чисел.
Технически говоря, нейронные сети и входные данные могут быть представлены в виде матриц, а все стандартные сетевые операции могут быть переопределены как матричные операции. Это важно, поскольку компьютеры могут выполнять матричные операции очень быстро.
Мы можем обрабатывать несколько значений матрицы параллельно, и если мы построим нейронную сеть с этой базовой структурой, мы сможем использовать одну машину с графическим процессором для обучения огромных сетей в разумное время.
Однако, если мы используем Theano, мы должны строить глубокую сеть с нуля. Библиотека не предоставляет полной функциональности для создания определенного типа глубокой сети.
Вместо этого мы должны закодировать каждый аспект глубокой сети, такой как модель, слои, активация, метод обучения и любые специальные методы, чтобы остановить переобучение.
Однако хорошей новостью является то, что Theano позволяет строить нашу реализацию поверх векторизованных функций, обеспечивая нам высокооптимизированное решение.
Есть много других библиотек, расширяющих функциональность Theano. TensorFlow и Keras можно использовать с Theano в качестве серверной части.
Глубокое обучение с TensorFlow
Googles TensorFlow - это библиотека Python. Эта библиотека - отличный выбор для создания приложений глубокого обучения коммерческого уровня.
TensorFlow вырос из другой библиотеки DistBelief V2, которая была частью Google Brain Project. Эта библиотека направлена на расширение переносимости машинного обучения, чтобы исследовательские модели могли применяться к приложениям коммерческого уровня.
Как и библиотека Theano, TensorFlow основан на вычислительных графах, где узел представляет постоянные данные или математическую операцию, а ребра представляют собой поток данных между узлами, который представляет собой многомерный массив или тензор; отсюда и название TensorFlow
Выходные данные операции или набора операций используются как входные для следующей.
Несмотря на то, что TensorFlow был разработан для нейронных сетей, он хорошо работает для других сетей, где вычисления могут быть смоделированы как граф потока данных.
TensorFlow также использует несколько функций Theano, таких как исключение общих и подвыражений, автоматическое дифференцирование, общие и символьные переменные.
Используя TensorFlow, можно создавать различные типы глубоких сетей, такие как сверточные сети, автоэнкодеры, RNTN, RNN, RBM, DBM / MLP и так далее.
Однако в TensorFlow нет поддержки настройки гиперпараметров, для этого мы можем использовать Keras.
Глубокое обучение и Керас
Keras - это мощная простая в использовании библиотека Python для разработки и оценки моделей глубокого обучения.
Он имеет минималистичный дизайн, который позволяет нам создавать сетку слой за слоем; тренируй и запускай.
Он включает в себя библиотеки эффективных численных вычислений Theano и TensorFlow и позволяет нам определять и обучать модели нейронных сетей с помощью нескольких коротких строк кода.
Это высокоуровневый API нейронной сети, помогающий широко использовать глубокое обучение и искусственный интеллект. Он работает поверх ряда библиотек нижнего уровня, включая TensorFlow, Theano и так далее. Код Keras переносим; мы можем реализовать нейронную сеть в Keras, используя Theano или TensorFlow в качестве обратной стороны без каких-либо изменений в коде.
В этой реализации глубокого обучения наша цель состоит в том, чтобы спрогнозировать убыль клиентов или отток данных для определенного банка - какие клиенты могут покинуть эту банковскую службу. Используемый набор данных относительно невелик и содержит 10000 строк с 14 столбцами. Мы используем дистрибутив Anaconda и такие фреймворки, как Theano, TensorFlow и Keras. Keras построен на основе Tensorflow и Theano, которые работают как его серверные части.
# Artificial Neural Network
# Installing Theano
pip install --upgrade theano
# Installing Tensorflow
pip install –upgrade tensorflow
# Installing Keras
pip install --upgrade keras
Шаг 1. Предварительная обработка данных
In[]:
# Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# Importing the database
dataset = pd.read_csv('Churn_Modelling.csv')
Шаг 2
Мы создаем матрицы характеристик набора данных и целевой переменной, которая представляет собой столбец 14, помеченный как «Exited».
Первоначальный вид данных показан ниже -
In[]:
X = dataset.iloc[:, 3:13].values
Y = dataset.iloc[:, 13].values
X
Вывод
Шаг 3
Y
Вывод
array([1, 0, 1, ..., 1, 1, 0], dtype = int64)
Шаг 4
Мы упрощаем анализ, кодируя строковые переменные. Мы используем функцию ScikitLearn LabelEncoder для автоматического кодирования различных меток в столбцах со значениями от 0 до n_classes-1.
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelencoder_X_1 = LabelEncoder()
X[:,1] = labelencoder_X_1.fit_transform(X[:,1])
labelencoder_X_2 = LabelEncoder()
X[:, 2] = labelencoder_X_2.fit_transform(X[:, 2])
X
Вывод
В приведенных выше выходных данных названия стран заменены на 0, 1 и 2; в то время как мужчина и женщина заменяются на 0 и 1.
Шаг 5
Labelling Encoded Data
Мы используем то же самое ScikitLearn библиотека и другая функция, называемая OneHotEncoder просто передать номер столбца, создав фиктивную переменную.
onehotencoder = OneHotEncoder(categorical features = [1])
X = onehotencoder.fit_transform(X).toarray()
X = X[:, 1:]
X
Теперь первые 2 столбца представляют страну, а 4-й столбец - пол.
Вывод
Мы всегда разделяем наши данные на обучающую и тестовую части; мы обучаем нашу модель на данных обучения, а затем мы проверяем точность модели на данных тестирования, что помогает в оценке эффективности модели.
Шаг 6
Мы используем ScikitLearn's train_test_splitфункция для разделения наших данных на обучающий набор и тестовый набор. Мы сохраняем соотношение между поездами и тестами как 80:20.
#Splitting the dataset into the Training set and the Test Set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)
Некоторые переменные имеют значения в тысячах, а некоторые - в десятках или единицах. Мы масштабируем данные, чтобы они были более репрезентативными.
Шаг 7
В этом коде мы настраиваем и преобразуем обучающие данные с помощью StandardScalerфункция. Мы стандартизируем масштабирование, чтобы использовать один и тот же подходящий метод для преобразования / масштабирования тестовых данных.
# Feature Scaling
fromsklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
Вывод
Теперь данные масштабируются правильно. Наконец, мы закончили предварительную обработку данных. Теперь мы начнем с нашей модели.
Шаг 8
Мы импортируем сюда необходимые модули. Нам нужен модуль Sequential для инициализации нейронной сети и плотный модуль для добавления скрытых слоев.
# Importing the Keras libraries and packages
import keras
from keras.models import Sequential
from keras.layers import Dense
Шаг 9
Мы назовем эту модель классификатором, поскольку наша цель - классифицировать отток клиентов. Затем мы используем модуль Sequential для инициализации.
#Initializing Neural Network
classifier = Sequential()
Шаг 10
Мы добавляем скрытые слои один за другим, используя функцию плотности. В приведенном ниже коде мы увидим множество аргументов.
Наш первый параметр output_dim. Это количество узлов, которые мы добавляем к этому слою.init- это инициализация Stochastic Gradient Decent. В нейронной сети мы назначаем веса каждому узлу. При инициализации веса должны быть близки к нулю, и мы случайным образом инициализируем веса, используя равномерную функцию. Вinput_dimПараметр нужен только для первого слоя, так как модели не известно количество наших входных переменных. Здесь общее количество входных переменных равно 11. На втором уровне модели автоматически известно количество входных переменных из первого скрытого слоя.
Выполните следующую строку кода, чтобы добавить входной слой и первый скрытый слой -
classifier.add(Dense(units = 6, kernel_initializer = 'uniform',
activation = 'relu', input_dim = 11))
Выполните следующую строку кода, чтобы добавить второй скрытый слой -
classifier.add(Dense(units = 6, kernel_initializer = 'uniform',
activation = 'relu'))
Выполните следующую строку кода, чтобы добавить выходной слой -
classifier.add(Dense(units = 1, kernel_initializer = 'uniform',
activation = 'sigmoid'))
Шаг 11
Compiling the ANN
До сих пор мы добавляли в наш классификатор несколько слоев. Теперь мы скомпилируем их, используяcompileметод. Аргументы, добавленные в финальном контроле компиляции, завершают нейронную сеть, поэтому на этом этапе нам нужно быть осторожными.
Вот краткое объяснение аргументов.
Первый аргумент OptimizerЭто алгоритм, используемый для поиска оптимального набора весов. Этот алгоритм называетсяStochastic Gradient Descent (SGD). Здесь мы используем один из нескольких типов, называемый «оптимизатором Адама». SGD зависит от потерь, поэтому наш второй параметр - это убытки. Если наша зависимая переменная является двоичной, мы используем функцию логарифмических потерь, называемую‘binary_crossentropy’, и если наша зависимая переменная имеет более двух категорий на выходе, мы используем ‘categorical_crossentropy’. Мы хотим улучшить производительность нашей нейронной сети на основеaccuracy, поэтому мы добавляем metrics как точность.
# Compiling Neural Network
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
Шаг 12
На этом шаге необходимо выполнить ряд кодов.
Подгонка ИНС к обучающей выборке
Теперь мы обучаем нашу модель на обучающих данных. Мы используемfitметод, чтобы соответствовать нашей модели. Мы также оптимизируем веса, чтобы повысить эффективность модели. Для этого нам нужно обновить веса.Batch size - количество наблюдений, после которых мы обновляем веса. Epoch- общее количество итераций. Значения размера пакета и эпохи выбираются методом проб и ошибок.
classifier.fit(X_train, y_train, batch_size = 10, epochs = 50)
Прогнозы и оценка модели
# Predicting the Test set results
y_pred = classifier.predict(X_test)
y_pred = (y_pred > 0.5)
Прогнозирование одного нового наблюдения
# Predicting a single new observation
"""Our goal is to predict if the customer with the following data will leave the bank:
Geography: Spain
Credit Score: 500
Gender: Female
Age: 40
Tenure: 3
Balance: 50000
Number of Products: 2
Has Credit Card: Yes
Is Active Member: Yes
Шаг 13
Predicting the test set result
Результат прогноза даст вам вероятность ухода клиента из компании. Мы преобразуем эту вероятность в двоичные 0 и 1.
# Predicting the Test set results
y_pred = classifier.predict(X_test)
y_pred = (y_pred > 0.5)
new_prediction = classifier.predict(sc.transform
(np.array([[0.0, 0, 500, 1, 40, 3, 50000, 2, 1, 1, 40000]])))
new_prediction = (new_prediction > 0.5)
Шаг 14.
Это последний шаг, на котором мы оцениваем производительность нашей модели. У нас уже есть оригинальные результаты, поэтому мы можем построить матрицу неточностей, чтобы проверить точность нашей модели.
Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
print (cm)
Вывод
loss: 0.3384 acc: 0.8605
[ [1541 54]
[230 175] ]
Из матрицы путаницы точность нашей модели может быть рассчитана как -
Accuracy = 1541+175/2000=0.858
We achieved 85.8% accuracy, и это хорошо.
Алгоритм прямого распространения
В этом разделе мы узнаем, как написать код для прямого распространения (прогнозирования) для простой нейронной сети.
Каждая точка данных - это клиент. Первый вход - это количество учетных записей, которые у них есть, а второй вход - сколько у них детей. Модель предсказывает, сколько транзакций совершит пользователь в следующем году.
Входные данные предварительно загружаются как входные данные, а веса находятся в словаре, называемом весами. Массив весов для первого узла в скрытом слое представлен в весах ['node_0'], а для второго узла в скрытом слое - в весах ['node_1'] соответственно.
Веса, подаваемые в выходной узел, доступны в весах.
Выпрямленная функция линейной активации
«Функция активации» - это функция, которая работает на каждом узле. Он преобразует ввод узла в некоторый вывод.
Функция выпрямленной линейной активации (называемая ReLU ) широко используется в высокопроизводительных сетях. Эта функция принимает на входе одно число, возвращая 0, если ввод отрицательный, и ввод как вывод, если ввод положительный.
Вот несколько примеров -
- relu (4) = 4
- relu (-2) = 0
Заполняем определение функции relu () -
- Мы используем функцию max (), чтобы вычислить значение для вывода relu ().
- Мы применяем функцию relu () к node_0_input, чтобы вычислить node_0_output.
- Мы применяем функцию relu () к node_1_input для вычисления node_1_output.
import numpy as np
input_data = np.array([-1, 2])
weights = {
'node_0': np.array([3, 3]),
'node_1': np.array([1, 5]),
'output': np.array([2, -1])
}
node_0_input = (input_data * weights['node_0']).sum()
node_0_output = np.tanh(node_0_input)
node_1_input = (input_data * weights['node_1']).sum()
node_1_output = np.tanh(node_1_input)
hidden_layer_output = np.array(node_0_output, node_1_output)
output =(hidden_layer_output * weights['output']).sum()
print(output)
def relu(input):
'''Define your relu activation function here'''
# Calculate the value for the output of the relu function: output
output = max(input,0)
# Return the value just calculated
return(output)
# Calculate node 0 value: node_0_output
node_0_input = (input_data * weights['node_0']).sum()
node_0_output = relu(node_0_input)
# Calculate node 1 value: node_1_output
node_1_input = (input_data * weights['node_1']).sum()
node_1_output = relu(node_1_input)
# Put node values into array: hidden_layer_outputs
hidden_layer_outputs = np.array([node_0_output, node_1_output])
# Calculate model output (do not apply relu)
odel_output = (hidden_layer_outputs * weights['output']).sum()
print(model_output)# Print model output
Вывод
0.9950547536867305
-3
Применение сети ко многим наблюдениям / строкам данных
В этом разделе мы узнаем, как определить функцию под названием pred_with_network (). Эта функция будет генерировать прогнозы для нескольких наблюдений данных, взятых из сети выше, взятой как input_data. Используются веса, указанные в приведенной выше сети. Также используется определение функции relu ().
Давайте определим функцию под названием pred_with_network (), которая принимает два аргумента - input_data_row и weights - и возвращает прогноз из сети в качестве вывода.
Мы вычисляем входные и выходные значения для каждого узла, сохраняя их как: node_0_input, node_0_output, node_1_input и node_1_output.
Чтобы вычислить входное значение узла, мы умножаем соответствующие массивы вместе и вычисляем их сумму.
Чтобы вычислить выходное значение узла, мы применяем функцию relu () к входному значению узла. Мы используем цикл for для перебора input_data -
Мы также используем нашу pred_with_network () для генерации прогнозов для каждой строки input_data - input_data_row. Мы также добавляем каждый прогноз к результатам.
# Define predict_with_network()
def predict_with_network(input_data_row, weights):
# Calculate node 0 value
node_0_input = (input_data_row * weights['node_0']).sum()
node_0_output = relu(node_0_input)
# Calculate node 1 value
node_1_input = (input_data_row * weights['node_1']).sum()
node_1_output = relu(node_1_input)
# Put node values into array: hidden_layer_outputs
hidden_layer_outputs = np.array([node_0_output, node_1_output])
# Calculate model output
input_to_final_layer = (hidden_layer_outputs*weights['output']).sum()
model_output = relu(input_to_final_layer)
# Return model output
return(model_output)
# Create empty list to store prediction results
results = []
for input_data_row in input_data:
# Append prediction to results
results.append(predict_with_network(input_data_row, weights))
print(results)# Print results
Вывод
[0, 12]
Здесь мы использовали функцию relu, где relu (26) = 26, relu (-13) = 0 и так далее.
Глубокие многослойные нейронные сети
Здесь мы пишем код для прямого распространения для нейронной сети с двумя скрытыми слоями. Каждый скрытый слой имеет два узла. Входные данные были предварительно загружены какinput_data. Узлы в первом скрытом слое называются node_0_0 и node_0_1.
Их веса предварительно загружаются как веса ['node_0_0'] и веса ['node_0_1'] соответственно.
Узлы во втором скрытом слое называются node_1_0 and node_1_1. Их веса предварительно загружены какweights['node_1_0'] и weights['node_1_1'] соответственно.
Затем мы создаем вывод модели из скрытых узлов, используя веса, предварительно загруженные как weights['output'].
Мы вычисляем node_0_0_input, используя его веса weights ['node_0_0'] и заданные input_data. Затем примените функцию relu (), чтобы получить node_0_0_output.
Мы делаем то же, что и выше, для node_0_1_input, чтобы получить node_0_1_output.
Мы вычисляем node_1_0_input, используя его веса weights ['node_1_0'] и выходы из первого скрытого слоя - hidden_0_outputs. Затем мы применяем функцию relu (), чтобы получить node_1_0_output.
Мы делаем то же, что и выше, для node_1_1_input, чтобы получить node_1_1_output.
Мы вычисляем model_output, используя веса ['output'] и выходы из массива hidden_1_outputs второго скрытого слоя. Мы не применяем функцию relu () к этому выводу.
import numpy as np
input_data = np.array([3, 5])
weights = {
'node_0_0': np.array([2, 4]),
'node_0_1': np.array([4, -5]),
'node_1_0': np.array([-1, 1]),
'node_1_1': np.array([2, 2]),
'output': np.array([2, 7])
}
def predict_with_network(input_data):
# Calculate node 0 in the first hidden layer
node_0_0_input = (input_data * weights['node_0_0']).sum()
node_0_0_output = relu(node_0_0_input)
# Calculate node 1 in the first hidden layer
node_0_1_input = (input_data*weights['node_0_1']).sum()
node_0_1_output = relu(node_0_1_input)
# Put node values into array: hidden_0_outputs
hidden_0_outputs = np.array([node_0_0_output, node_0_1_output])
# Calculate node 0 in the second hidden layer
node_1_0_input = (hidden_0_outputs*weights['node_1_0']).sum()
node_1_0_output = relu(node_1_0_input)
# Calculate node 1 in the second hidden layer
node_1_1_input = (hidden_0_outputs*weights['node_1_1']).sum()
node_1_1_output = relu(node_1_1_input)
# Put node values into array: hidden_1_outputs
hidden_1_outputs = np.array([node_1_0_output, node_1_1_output])
# Calculate model output: model_output
model_output = (hidden_1_outputs*weights['output']).sum()
# Return model_output
return(model_output)
output = predict_with_network(input_data)
print(output)
Вывод
364