Сверточные сети во встраиваемых системах: Что такое свёрточная нейронная сеть / Хабр

Как устроена сверточная нейронная сеть: архитектуры и параметры

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

Двумерная сверточная нейронная сеть

Двумерная свертка

Двумерная свертка (2D convolution) — это довольно простая операция: начинаем с ядра, представляющего из себя матрицу весов (weight matrix). Ядро “скользит” над двумерным изображением, поэлементно выполняя операцию умножения с той частью входных данных, над которой оно сейчас находится, и затем суммирует все полученные значения в один выходной пиксель.

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

Операция свертки

Независимо от того, попадает ли входной признак в “примерно то же место”, он определяется в зависимости от того, находится он в зоне ядра, создающего выходные данные, или нет. Это значит, что размер ядра сверточной нейронной сети определяет количество признаков, которые будут объединены для получения нового признака на выходе.

В примере, приведенном выше, мы имеем 5*5=25 признаков на входе и 3*3=9 признаков на выходе. Для стандартного слоя (standard fully connected layer) мы бы имели весовую матрицу 25*9 = 225 параметров, а каждый выходной признак являлся бы взвешенной суммой всех признаков на входе. Свертка позволяет произвести такую операцию с всего 9-ю параметрами, ведь каждый признак на выходе получается анализом не каждого признака на входе, а только одного входного, находящегося в “примерно том же месте”. Обратите на это внимание, так как это будет иметь важное значение для дальнейшего обсуждения.

Часто используемые техники

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

Padding

Padding. Если вы наблюдаете анимацию, обратите внимание на то, что в процессе скольжения края по существу обрезаются, преобразуя матрицу признаков размером 5*5 в матрицу 3*3. Крайние пиксели никогда не оказываются в центре ядра, потому что тогда ядру не над чем будет скользить за краем. Это совсем не идеальный вариант, так как мы хотим, чтобы размер на выходе равнялся входному.

Padding добавляет к краям поддельные (fake) пиксели (обычно нулевого значения, вследствие этого к ним применяется термин “нулевое дополнение” — “zero padding”). Таким образом, ядро при проскальзывании позволяет неподдельным пикселям оказываться в своем центре, а затем распространяется на поддельные пиксели за пределами края, создавая выходную матрицу того же размера, что и входная.

Свертка с шагом 2

Striding. Часто бывает, что при работе со сверточным слоем, нужно получить выходные данные меньшего размера, чем входные. Это обычно необходимо в сверточных нейронных сетях, где размер пространственных размеров уменьшается при увеличении количества каналов. Один из способов достижения этого — использование субдискритизирующих слоев (pooling layer), например, принимать среднее/максимальное значение каждой ветки размером 2*2, чтобы уменьшить все пространственные размеры в два раза. Еще один способ добиться этого — использовать stride (шаг).

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

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

Многоканальная версия сверточной нейронной сети

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

В большинстве случаев мы имеем дело с изображениями RGB с тремя каналами

Вот где ключевые различия между терминами становятся нужными: тогда как в случае с 1 каналом термины «фильтр» и «ядро» взаимозаменяемы, в общем случае они разные.

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

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

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

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

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

Параметры в сверточной нейронной сети

Свертка — это по-прежнему линейное преобразование

Даже с уже описанной механикой работы сверточного слоя, все еще сложно связать это с нейронной сетью прямого распространения (feed-forward network), и это все еще не объясняет, почему свертки масштабируются и работают намного лучше с изображениями.

Предположим, что у нас есть вход 4*4, и мы хотим преобразовать его в сетку 2*2. Если бы мы использовали feed-forward network, мы бы переделали вход 4*4 в вектор длиной 16 и передали его через полносвязный слой с 16 входами и 4 выходами. Можно было бы визуализировать весовую матрицу W для слоя по типу:

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

Если мы использовали ядро K размера 3 на видоизмененным входом размера 4*4, чтобы получить выход 2*2, эквивалентная матрица перехода будет выглядеть так:

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

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

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

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

Вам не нужно оптимизировать все 64 параметра, потому большинство из них установлено на ноль (и они останутся такими), а остальные мы преобразуем в общие параметры и в результате получим только 9 параметров для оптимизации. Эта эффективность имеет значение, потому что, когда вы переходите от 784 входов MNIST к реальным изображениям 224*224*3, это более 150 000 входов. Слой, пытающийся вдвое уменьшить вход до 75 000 входных значений, по-прежнему потребует более 10 миллиардов параметров. Для сравнения, ResNet-50 имеет около 25 миллионов параметров.

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

Ответ заключается в комбинациях образов, изучаемых параметрами за счет prior.

Локальные особенности

Итак:

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

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

Если это были какие-то другие данные, например, данные об установках приложений по категориям, то это стало бы катастрофой, потому что количество столбцов установки приложений и типов приложений рядом друг с другом не означает, что у них есть «локальные общие признаки», общие с датами установки приложений и временем использования. Конечно, у нескольких могут быть основные признаки более высокого уровня, которые могут быть найдены, но это не дает нам никаких оснований полагать, что параметры для первых двух точно такие же, как параметры для последних двух. Эти несколько могли быть в любом (последовательном) порядке и по-прежнему оставаться подходящими!

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

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

Применение ядра, детектирующего грани

Для сетки, не содержащей граней (например, неба на заднем фоне), большинство пикселей имеют одинаковое значение, поэтому общий вывод ядра в этой точке равен 0. Для сетки с вертикальными гранями существует разница между пикселями слева и справа от грани, и ядро вычисляет эту ненулевую разницу, находя ребра. Ядро за раз работает только с сетками 3*3, обнаруживая аномалии в определенных местах, но применения ко всему изображению достаточно для обнаружения определенного признака в любом месте изображения!

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

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

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

После 2-й и 3-й свертки

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

Тем не менее, как бы глубоки ни заходили наши детекторы признаков, без каких-либо дальнейших изменений они все равно будут работать на очень маленьких участках изображения. Независимо от того, насколько глубоки ваши детекторы, вы не сможете обнаружить лица в сетке 3*3. И вот здесь возникает идея рецептивного поля (receptive field).

Рецептивные поля

Существенной особенностью архитектур сверточной нейронной сети является то, что размеры ввода становятся все меньше и меньше от начала до конца сети, а количество каналов становится больше. Это, как упоминалось ранее, часто делается с помощью strides или pooling layers. Местность определяет, какие входные данные из предыдущего уровня будут на выходе следующего. Receptive field определяет, какую область исходного входа получает выход.

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

Свертка 3*3, шаг 2

Затем мы применяем нелинейность к выходном данным, затем накладываем еще один новый слой свертки сверху. Здесь все становится интересным. Даже если бы мы применили ядро того же размера (3*3), имеющее одну и ту же локальную область, к выходу strided convolution, ядро имело бы более эффективное receptive field.

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

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

Визуалицая усложнения после добавления слоев

Такое расширение восприимчивого поля позволяет слоям свертки сочетать признаки низкого уровня (линии, ребра) с признаками более высокого уровня (кривые, текстуры), как мы видим в слое mixed3a.

Вслед за слоем pooling/striding сеть продолжает создавать детекторы для еще более высокоуровневых признаков (частей, шаблонов), как мы видим на mixed4a.

Повторное уменьшение размера изображения к 5-му блоку сверток дает размеры ввода всего 7*7, по сравнению с входами 224*224. В этот момент каждый отдельный пиксель представляет собой огромную сетку размером 32*32 пикселя.

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

Сеть в целом развивается из небольшого количества фильтров (64 в случае GoogLeNet), обнаруживая функции низкого уровня, до очень большого количества фильтров (1024 в окончательной свертке), каждый из которых ищет чрезвычайно специфические признаки высокого уровня. И далее применя

Сверточная нейронная сеть на PyTorch: пошаговое руководство

В предыдущем вводном туториале по нейронным сетям была создана трехслойная архитектура для классификации рукописных символов датасета MNIST. В конце туториала была показана точность приблизительно 86%. Для простого датасета, как MNIST, это плохое качество. Дальнейшая оптимизация смогла улучшить результат плотно соединенной сети до 97-98% точности. Это уже намного лучше, но всё еще не достаточно для MNIST. Требуется более современный метод, который может действительно называться глубоким обучением. В данном туториале представлен такой метод — сверточная нейронная сеть (Convolutional Neural Network, CNN), который достигает высоких результатов в задачах классификации картинок. В частности, будет рассмотрена и теория, и практика реализации CNN при помощи PyTorch.

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

Особенности CNN

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

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

Принцип работы CNN

Свертка — фактически главное, что необходимо понять о сверточных нейронных сетях. Этот замысловатый математический термин нужен для движущегося окна или фильтра по исследуемому изображению. Перемещающееся окно применяется к определенному участку узлов, как показано ниже. Где примененный фильтр — ( 0.5 * значение в узле):

На диаграмме показаны только два выходных значения, каждое из которых отображает входной квадрат размера 2×2. Вес отображения для каждого входного квадрата, как ранее упоминалось, равен 0.5 для всех четырех входов (inputs). Поэтому выход может быть посчитан так:

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

Первое положение связей движущегося фильтра показано синей линией, второе — зеленой. Веса для каждых таких соединений равны 0. 5.

Вот несколько вещей в сверточном шаге, которые ускоряют процесс тренировки, сокращая количество параметров, весов:

• Редкие связи — не каждый узел в первом (входном) слое соединен с каждым узлом во втором слое. Этим отличается архитектура CNN от полностью связанной нейронной сети, где каждый узел соединен со всем другими в следующем слое.
• Постоянные параметры фильтра. Другими словами, при движении фильтра по изображению одинаковые веса применяются для каждого 2 х 2 набора узлов. Каждый фильтр может быть обучен для выполнения специфичных трансформаций входного пространства. Следовательно, каждый фильтр имеет определенный набор весов, которые применяются для каждой операции свертки. Этот процесс уменьшает количество параметров. Нельзя говорить, что любой вес постоянен внутри отдельного фильтра. В примере выше веса были [0.5, 0.5, 0.5, 0.5], но ничего не мешало им быть и [0.25, 0.1, 0.8, 0.001]. Выбор конкретных значений зависит от обучения каждого фильтра.

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

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

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

Отображение признаков и мультиканальность

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

Теперь в правой части рисунка можно видеть несколько сложенных (stacked) выходов операции свертки. Их несколько, потому что существует несколько обучаемых фильтров, каждый из которых производит собственный 2D выход (в случае 2D изображения). Такое множество фильтров часто в глубоком обучении часто называют каналами. Каждый канал должен обучаться для выделения на изображении определенного ключевого признака. Выход сверточного слоя для черно-белого изображения, как в датасете MNIST, имеет 3 измерения — 2D для каждого из каналов и еще одно для их числа.

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

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

Объединение (Pooling)

Основными преимуществами для пулинга в сверточной нейронной сети являются:

• Уменьшение количества параметров в вашей модели благодаря процессу даунсемплинга (down-sampling).
• Детектирование признаков становится более правильным при изменении ориентации или размера объекта.

Пулинг — другой тип техники скользящего окна, где вместо применения обучаемых весов используется статистическая функция некоторого типа по содержимому этого окна. Наиболее частый тип пулинга — max pooling, который применяет функцию max(). Есть и другие варианты — mean pooling (который применяет функцию усреднения по содержимому окна), которые применяются в особых случаях. В этом туториале мы будем концентрироваться на max pooling. На рисунке ниже показано, как работает операция max pooling:

Давайте пройдемся по некоторым пунктам, связанным с диаграммой:

Основы

На диаграмме можно наблюдать действие max pooling. Для первого окна голубого цвета max pooling выдает значение 3.0, которое является максимальным значением узла в 2х2 окне. Таким же образом зеленое окно выводит максимальное значение, равно 5.0, а для красного окна максимальное значение — 7.0. Здесь всё просто и понятно.

Шаги и даунсемплинг

На диаграмме сверху можно заметить, что пулинговое окно каждый раз перемещается на 2 места. Можем говорить, что шаг равен 2. На диаграмме показаны шаги только вдоль оси x,  но для задачи предотвращения перекрытия окна, шаг должен быть также равен 2 и в направлении y. Другими словами, шаг обозначается как [2,2]. Следует упомянуть, если во время пулинга шаг больше 1, тогда размер выхода будет уменьшен. Как можно видеть на диаграмме, входной объект размера 5×5 уменьшается до 3х3 на выходе. И это хорошо — такое явление называется даунсемплингом и уменьшает количество обучаемых параметров в модели.

Padding

Важно отметить также, что в пулинговой диаграмме есть дополнительный столбец и строка, добавленные к входу размера 5х5, делающие эффективный размер пулингового пространства равным 6х6. Это делается для того, чтобы пулинговое окно размером 2х2 корректно работало с шагом [2,2]. Такой прием называется padding. Padding-узлы зачастую фиктивные, так как значения на них равны 0, и операция max pooling их не видит. Этот факт нужно будет учитывать при создании нашей сверточной сети на PyTorch.

Теперь мы разобрались в механизме работы пулинга в CNN,  выяснили его полезность в осуществлении даунсемплинга. Рассмотрим еще его некоторые функции и ответим на вопрос, почему max pooling используется так часто.

Использование пулинга в сверточных нейронных сетях

В дополнении к функции даунсемплинга пулинг используется в CNN, чтобы детектировать определенные признаки, инвариантные к изменениям размера или ориентации. Другой способ представить действие пулинга  — он обобщает низкоуровневую, сложно структурированную информацию. Представим случай, когда у нас есть сверточный фильтр, который во время тренировки обучается распознавать знак «9» в различных положениях на входном изображении. Чтобы сверточная сеть научилась корректно классифицировать появление «9» на картинке, требуется каким-то образом активировать сеть каждый раз, когда эта цифра появляется на изображении независимо от размера и ориентации (кроме случая, когда «9» напоминает «9»). Пулинг может помочь в такой задаче выбора высокоуровневых, обобщенных признаков. Этот процесс иллюстрирован ниже:

Диаграмма — стилизованное представление операции пулинга. Если мы считаем, что маленький участок входного изображения содержит цифру 9 (зеленый квадрат), и предполагаем, что пытаемся детектировать эту цифру на изображении. В таком случае несколько сверточных фильтров обучаются активироваться с помощью ReLU функции каждый раз, когда они видят «9» на картинке. Однако, они будут активироваться более или менее сильно в зависимости от того, как она расположена. Мы хотим научить сеть обнаруживать цифру на изображении независимо от ее ориентации. Здесь наступает черед пулинга. Он«смотрит» на выходы трех фильтров и берет настолько высокое значение, насколько высокий порог функций активации этих фильтров.

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

Общий взгляд

Ниже представлено изображение из Википедии, которое показывает структуру полностью разработанной сверточной нейронной сети:

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

Полносвязный слой

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

Рассматривая предыдущую диаграмму, на выходе имеем несколько каналов x x y тензоров/матриц. Эти каналы необходимо привести к одному (N x 1) тензору. Возьмем пример: имеем 100 каналов с 2х2 матрицами, отображающими выход последней пулинг операции в сети. В PyTorch можно легко осуществить преобразование в 2х2х100 = 400 строк, как будет показано ниже.

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

Реализация CNN на PyTorch

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

Мы собираемся реализовать следующую архитектуру сверточной сети:

В самом начале на вход подаются черно-белые представления символов размером 28х28 пикселей каждое. Первый слой состоит из 32 каналов сверточных фильтров размера 5х5 + активационная функция ReLU, затем идет 2х2 max pooling с даунсемплингом с шагом 2 (этот слой выводит данные размером 14х14). На следующий слой подается выход с первого слоя размера 14х14, который сканируется снова 5х5 сверточными фильтрами с 64 каналов, затем следует 2х2 max pooling с даунсемплингом для генерирования выхода размером 7х7.

После сверточной части сети следует:

• операция выравнивания, которая создает 7х7х64=3164 узлов
• средний слой из 1000 полносвязных улов
• операция softmax над крайними 10 узлами для генерирования вероятностей классов.

Эти слои представлены в выходном классификаторе.

Загрузка датасета

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

num_epochs = 5 
num_classes = 10 
batch_size = 100 
learning_rate = 0.001
DATA_PATH = 'C:\UsersAndyPycharmProjectsMNISTData'
MODEL_STORE_PATH = 'C:\UsersAndyPycharmProjectspytorch_models\'

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

Далее задаем преобразование для применения к MNIST и переменные для данных:

trans = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))]) 

train_dataset = torchvision.datasets.MNIST(root=DATA_PATH, train=True, transform=trans, download=True) 
test_dataset = torchvision.datasets.MNIST(root=DATA_PATH, train=False, transform=trans)

Первое, на что необходимо обратить внимание в коде сверху, это функция transform.Compose(). Функция находится в  пакете torchvision. Она позволяет разработчику делать различные манипуляции с указанным датасетом. Численные трансформации могут быть соединены вместе в список при использовании функции Compose(). В этом случае сначала устанавливается преобразование, которое конвертирует входной датасет в PyTorch тензор. PyTorch тензор — особый тип данных, используемый в библиотеке для всех различных операций с данными и весами внутри нейросети. По сути, такой тензор — простая многомерная матрица. Но в любом случае, PyTorch требует преобразования датасета в тензор таким образом, что его можно использовать для тренировки и тестирования сети.

Следующий аргумент в списке Compose() — нормализация. Нейронная сеть обучается лучше, когда входные данные нормализованы так, что их значения находятся в диапазоне от -1 до 1 или от 0 до 1. Чтобы это сделать с помощью нормализации PyTorch, необходимо указать среднее и стандартное отклонение MNIST датасета, которые в этом случае равны 0.1307 и 0.3081 соответственно. Отметим, среднее значение и стандартное отклонение должны быть установлены для каждого входного канала. У MNIST есть только один канал, но уже для датасета CIFAR c 3 каналами (по одному на каждый цвет из RGB спектра) надо указывать среднее и стандартное отклонение для каждого.

Далее необходимо создать объекты  train_dataset и test_dataset, которые будут последовательно проходить через загрузчик данных. Чтобы создать такие датасеты из данных MNIST, требуется задать несколько аргументов. Первый — путь до папки, где хранится файл с данными для тренировки и тестирования. Логический аргумент train показывает, какой файл из train.pt или  test.pt стоит брать в качестве тренировочного сета. Следующий аргумент — transform, в котором мы указываем ранее созданный объект trans, который осуществляет преобразования. Наконец, аргумент загрузки просит функцию датасета MNIST загрузить при необходимости данные из онлайн источника.

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

train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size,shuffle=True) 
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)

Объект загрузчик данных в PyTorch обеспечивает несколько полезных функций при использовании тренировочных данных:

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

Как можно видеть, требуется задать три простых аргумента. Первый — данные, которые вы хотите загрузить; второй — желаемый размер партии; третий — перемешивать ли случайным образом датасет. Загрузчик может использоваться в качестве итератора. Поэтому для извлечения данных мы можем просто воспользоваться стандартным итератором Python, например, перечислением. Такая возможность будет позже продемонстрирована на практике в туториале.

Создание модели

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

class ConvNet(nn.Module): 
     def __init__(self): 
         super(ConvNet, self).__init__() 
         self.layer1 = nn.Sequential( nn.Conv2d(1, 32, kernel_size=5, stride=1, padding=2), 
            nn.ReLU(), nn.MaxPool2d(kernel_size=2, stride=2)) 
         self.layer2 = nn.Sequential( nn.Conv2d(32, 64, kernel_size=5, stride=1, padding=2), 
            nn.ReLU(), nn.MaxPool2d(kernel_size=2, stride=2)) 
         self.drop_out = nn.Dropout() 
         self.fc1 = nn.Linear(7 * 7 * 64, 1000) 
         self.fc2 = nn.Linear(1000, 10)

Это то место, где определяется модель. Наиболее простой способ создания структуры нейронной сети в PyTorch — создание наследственного класса от материнского nn.Module. Класс nn.Module очень полезен в PyTorch, он содержит всё необходимое для конструирования типичной глубокой нейронной сети. Кроме этого, класс имеет удобные функции: способы перемещения переменных и операций на GPU или обратно на CPU, применение рекурсивных функций через все свойства в классе (например, перенастройка всех весовых переменных), создание оптимизированных интерфейсов для тренировки и тому подобное. Все доступные методы можно посмотреть здесь.

Первый шаг — создание нескольких объектов последовательного слоя с помощью функции class _init_. Сначала создаем слой 1 (self.layer1) через создание объекта nn.Sequential. Этот метод позволяет создавать упорядоченные слои в сети и является удобным способом создания последовательности свертка + ReLu + пулинг. Как можно видеть, первый элемент в определении этой последовательности — метод Conv2d, который создает набор сверточных фильтров. В этом методе первый аргумент — количество входных каналов; в нашем случае изображения MNIST черно-белые и количество каналов равно 1. Второй аргумент в Conv2d — количество выходных каналов; как показано на диаграмме архитектуры модели, первый слой сверточных фильтров состоит из 32 каналов, поэтому значение второго аргумента равно 32.

Аргумент kernel_size отвечает за размер сверточного фильтра, в нашем случае мы хотим фильтр размеров 5х5, поэтому аргумент равен 5. Если бы мы хотели фильтры с разными размерными формами по оси х и y, необходимо было указать параметры в виде python tuple (размер по х, размер по y). Наконец, мы хотим установить padding, что делается несколько сложнее. Размер измерения на выходе от операции  сверточной фильтрации или пулинга может быть посчитан с помощью уравнения:

Где W(in) — ширина выхода, F — размер фильтра, P — паддинг, S — шаг. Такая же формула применима для расчета высоты.  В нашем случае изображение и фильтрация симметричны, поэтому формула применима и к ширине и к высоте. Если хотим оставить входные и выходные измерения без изменений с размером фильтра 5 и шагом 1, то исходя из верхней формулы паддинг нужно задать равным 2. Таким образом, аргумент для паддинга в Conv2d равен 2.

Следующий аргумент в последовательности — простая ReLU функция активации. Последний элемент в последовательном определении для self.layer1 — операция max pooling. Первый аргумент — размер объединения, который равен 2х2; следовательно, аргумент равен 2. Во втором аргументе мы хотим взять подвыборку из данных через уменьшение эффективного размера изображения с факторов 2. Чтобы это сделать используя формулу выше, устанавливаем шаг равным 2 и паддинг равным 0. Следовательно, шаговый аргумент равен 2. Паддинг аргумент по умолчанию равен 0, если не указано другое значение, что сделано в коде сверху. Из этих вычислений теперь понятно, что выход слоя self.layer1 имеет 32 канала и “изображения” размером 14х14.

Второй слой, self.layer2, определяется таким же образом, как и первый. Единственное отличие здесь — вход в функцию Conv2d теперь 32 канальный, а выход — 64 канальный. Следуя такой же логике и учитывая пулинг и даунсемплинг, выход из self.layer2 представляет из себя 64 канала изображения размера 7х7.

Далее определяем отсеивающий слой для предотвращения переобучения модели. В конце создаем два полносвязных слоя. Первый слой имеет размер 7х7х64 узла и соединяется со вторым слоем с 1000 узлами. Чтобы создать полносвязный слой в PyTorch, используем метод nn.Linear. Первый аргумент метода — число узлов в данном слое, второй аргумент — число узлов в следующем слое.

Определение слоев создано при помощи  _init_. Следующий шаг — определить потоки данных через слои при прямом прохождении через сеть:

def forward(self, x): 
     out = self.layer1(x) 
     out = self.layer2(out) 
     out = out.reshape(out.size(0), -1) 
     out = self.drop_out(out) 
     out = self.fc1(out) 
     out = self.fc2(out) 
     return out

Здесь важно назвать функцию “forward”, так как она будет использовать базовую функцию прямого распространения в nn.Module и позволит всему функционалу nn.Module работать корректно. Как можно видеть, функция принимает на вход аргумент х, представляющий собой данные, которые должны проходить через модель (например, партия данных). Направляем эти данные в первый слой (self.layer1) и возвращаем выходные данные как out. Эти выходные данные поступают на следующий слой и так далее. Отметим, после self.layer2 применяем функцию преобразования формы к out, которая разглаживает размеры данных с 7х7х64 до 3164х1. После двух полносвязных слоев применяется dropout-слой и из функции возвращается финальное предсказание.

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

Обучение модели

Перед тренировкой модели мы должны сначала создать экземпляр (instance) нашего класса ConvNet(), определить функцию потерь и оптимизатор:

model = ConvNet()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

Экземпляр класса ConvNet() создается под названием  model. Далее определяем операцию над потерями, которая будет использоваться для подсчета потерь. В нашем случае используем доступную в PyTorch функцию CrossEntropyLoss(). Вы уже могли заметить, что мы еще не задали активационную функцию SoftMax для последнего слоя, выполняющего классификацию. Это сделано потому, что функция  CrossEntropyLoss() объединяет и SoftMax и кросс-энтропийную функцию потерь в единую функцию. Далее определяем оптимизатор Adam. Первым аргументом функции являются параметры, которые мы хотим обучить оптимизатором. Это легко сделать с помощью класса nn.Module, из которого вы получается ConvNet. Всё что нужно сделать — снабдить функцию аргументом model.parameters() и PyTorch будет отслеживать все параметры нашей модели, которые необходимо обучить. Последним определяется скорость обучения.

Тренировочный цикл выглядит следующим образом:

total_step = len(train_loader)
loss_list = []
acc_list = []
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        # Прямой запуск
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss_list.append(loss.item())

        # Обратное распространение и оптимизатор
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        # Отслеживание точности
        total = labels.size(0)
        _, predicted = torch.max(outputs.data, 1)
        correct = (predicted == labels).sum().item()
        acc_list.append(correct / total)

        if (i + 1) % 100 == 0:
            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}, Accuracy: {:.2f}%'
                  .format(epoch + 1, num_epochs, i + 1, total_step, loss.item(),
                          (correct / total) * 100))

Самыми важными частями для начала являются два цикла. Первый цикл проходит по количеству эпох, в нём итерации проходят по train_loader используя перечисление. Во внутреннем цикле сначала считаются выходы прямого прохождения изображений (которые представляют собой партии нормализованных MNIST изображений из train_loader). Отметим, нам не требуется вызывать model.forward(images), так как nn.Module знает, что нужно вызывать forward при выполнении model(images).

Следующий шаг — отправление выходов модели и настоящих меток в функцию CrossEntropyLoss, определенную как criterion. Потери добавляются в список, который будет использован позже для отслеживания прогресса обучения. Затем — выполнение обратного распространения ошибки и оптимизированного шага тренировки. Сначала градиенты должны быть обнулены, что легко делается вызовом zero_grad() на оптимизаторе. Далее вызываем функцию .backward() на переменной loss для выполнения обратного распространения. Теперь, когда градиенты посчитаны при обратном распространении, просто вызываем optimizer.step() для выполнения шага обучения оптимизатора Adam. PyTorch делает процесс обучения модели очень легким и интуитивным.

Следующий набор строк отвечает за отслеживание точности на тренировочном сете. Предсказания модели могут быть определены с помощью функции torch.max(), которая возвращает индекс максимального значения в тензоре. Первый аргумент этой функции — тензор, который мы хотим исследовать; второй — ось, по которой определяется максимум. Выходящий из модели тензор должен иметь размер (batch_size,10). Чтобы определить предсказание модели, необходимо для каждого примера в партии найти максимальные значения из 10 выходных узлов. Каждый из этих узлов будет соответствовать одному рукописному символу (например, выход 2 равен символу «2» и так далее). Выходной узел с наибольшим значением и будет предсказанием модели. Следовательно, надо задать второй аргумент в функции torch.max() равным 1, что указывает функции максимума проверить ось выходного узла (axis = 0 соответствует размерности batch_size).

На этом шаге возвращается список целочисленных предсказаний модели, а следующая строка сравнивает эти предсказания с настоящими метками (predicted == labels) и суммирует правильные предсказания. Отметим, что на этом шаге выход функции sum() всё еще тензор, поэтому для оценки его значений требуется вызвать .item(). Делим количество правильных предсказаний на размер партии batch_size (эквивалентно labels.size(0)) для подсчета точности. Наконец, во время тренировки после каждых 100 итераций внутреннего цикла выводим прогресс.

Результаты тренировки будут выглядеть следующим образом:

Epoch [1/6], Step [100/600], Loss: 0.2183, Accuracy: 95.00%
Epoch [1/6], Step [200/600], Loss: 0.1637, Accuracy: 95.00%
Epoch [1/6], Step [300/600], Loss: 0.0848, Accuracy: 98.00%
Epoch [1/6], Step [400/600], Loss: 0.1241, Accuracy: 97.00%
Epoch [1/6], Step [500/600], Loss: 0.2433, Accuracy: 95.00%
Epoch [1/6], Step [600/600], Loss: 0.0473, Accuracy: 98.00%
Epoch [2/6], Step [100/600], Loss: 0.1195, Accuracy: 97.00%

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

Тестирование

Для тестирования модели используем следующий код:

model.eval()
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print('Test Accuracy of the model on the 10000 test images: {} %'.format((correct / total) * 100))

# Сохраняем модель и строим график
torch.save(model.state_dict(), MODEL_STORE_PATH + 'conv_net_model.ckpt')

В первой строке устанавливаем режим оценки используя model.eval(). Это удобная функция запрещает любые исключения или слои нормализации партии в модели, которые будут мешать объективной оценке. Конструкция torch.no_grad() выключает функцию автоградиента в модели, так как она не нужна при тестировании/оценке модели и замедляет вычисления. Остальная часть кода совпадает с вычислением точности во время тренировки, за исключением того, что в этом случае итерации проходят по test_loader.

Наконец, результат выводится в консоль, а модель сохраняется при помощи функции torch.save().

В последней части кода в этом репозитории на GitHub дополнительно построен график отслеживания точности и потерь, используя библиотеку для рисования Bokeh. Финальный результат выглядит так:

Точность на тестовой выборке на 10000 картинках составляет 99.03%

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

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

Интересные статьи:

Аппаратная реализация сверточной нейросети на ПЛИС c использованием модельно-ориентированного проектирования

Статья впервые была представлена на DSPA-2019 21-й Международной Конференции «Цифровая обработка сигналов и её применение». 

Авторы:  инж. Воробьев А.Н, инж., к.т.н. Шидловский Д.Ю., инж., к.т.н. Багров А. А., Центр инженерных технологий и моделирования «Экспонента»

Инженер ЦИТМ «Экспонента» Воробьев Александр представил на конференции доклад на тему «Аппаратная реализация сверточной нейросети на ПЛИС c использованием модельно-ориентированного проектирования», раскрывающий возможности среды MATLAB по проектированию сверточных нейронных сетей и по их последующей аппаратной реализации на ПЛИС. В этом проекте наши инженеры ставили перед собой задачу пройти процесс от разработки архитектуры сети до ее аппаратной реализации наиболее оптимально, с минимальными временными затратами. Как правило, нейронные сети запускают на GPU и этот процесс уже отлажен. Запуск сверточных нейронных сетей на ПЛИС имеет ряд трудностей – это отсутствие готовых библиотек, ограниченные аппаратные ресурсы, высокая сложность разработки и отладки алгоритма непосредственно на ПЛИС. В этом докладе наши инженеры показывают, как можно обойти описанные выше проблемы, используя модельно-ориентированное проектирование и среду разработки MATLAB/Simulink.

В последнее время во многих областях нашли применение сверточные нейронные сети – от задач удаления шума и повышения разрешения изображений до задач построения современных систем содействия водителю (Advanced Driver-Assistance Systems – ADAS) способных распознавать окружающие его объекты: автомобили, дорожные знаки, пешеходов, линии разметки. Однако к этим системам предъявляется ряд дополнительных требований – обработка видео в режиме реального времени и возможность запуска алгоритма на встраиваемых платформах.

Однако запуск сверточных нейронных сетей на ПЛИС и на других встраиваемых системах имеет ряд трудностей – это отсутствие готовых библиотек, ограниченные вычислительные ресурсы аппаратной платформы, высокая сложность разработки и отладки алгоритма на встраиваемой платформе. В этой работе предлагается обойти описанные выше проблемы используя модельно-ориентированное проектирование и среду разработки MATLAB/Simulink.

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

На первом шаге создается структура нейронной сети в MATLAB, сеть обучается на тестовых данных и при необходимости ее структура уточняется. На следующем шаге реализуется потоковая модель алгоритма нейронной сети в среде Simulink для работы с потоковым видео, пригодная для аппаратной реализации на ПЛИС. И на третьем шаге, используя автоматическую генерацию кода из Simulink-моделей, получаем HDL-код с описанием алгоритма нейронной сети, пригодного для синтеза и запуска его на ПЛИС.

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

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

Связанное видео «Реализация нейронной сети на ПЛИС».

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

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

Повестка дня в этой области состоит в том, чтобы дать возможность машинам видеть мир так, как это делают люди, воспринимать его схожим образом и даже использовать знания для множества задач, таких как Распознавание Изображений и Видео, Анализ и Классификация Изображений, Восстановление Медиа, Системы Рекомендаций, Обработка Естественного языка и т.д. Достижения в области Computer Vision и Deep Learning были разрабатывались и совершенствовались с течением времени, главным образом благодаря совершенно конкретному алгоритму — Сверточной нейронной сети (Convolutional Neural Network).

Введение

CNN-последовательность для классификации рукописных цифр

Сверточная нейронная сеть (Convolutional Neural Network — ConvNet/CNN) — это Deep Learning-алгоритм, который может принимать входное изображение, присваивать важность (усваиваемые веса и смещения) различным областям/объектам в изображении и может отличать одно от другого. Предварительной обработки в ConvNet требуется значительно меньше по сравнению с другими алгоритмами классификации. В то время как в примитивных методах фильтры сконструированы вручную, ConvNets при достаточном обучении способны изучать эти фильтры/характеристики.

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

ConvNets или Feed-Forward Neural Nets (FF, FFNN — Нейронные сети прямого распространения)?

Сглаживание матрицы изображения 3х3 по вектору 9х1

На изображении не что иное, как матрица пиксельных значений, верно? Так почему бы просто не сгладить изображение (например, матрицу изображения 3×3 по вектору 9×1) и передать его в многослойный персептрон для классификации? Ну… Все не так просто.

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

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

Входное изображение

RGB-картинка 4x4x3

На рисунке у нас есть RGB-изображение, разделенное по трем цветовым плоскостям — красной, зеленой и синей. Существует несколько таких цветовых пространств, в которых существуют изображения: Grayscale (оттенки серого), RGB, HSV, CMYK и т.д.

Можете представить, что станет с вычислительными ресурсами, когда изображения достигнут размеров, скажем, 8K (7680 × 4320). ConvNet нужен, чтобы преобразовать изображения в ту форму, которую легче обрабатывать без потери характеристик, которые имеют решающую роль для получения хорошего прогноза. Это важно, когда мы хотим разработать архитектуру, которая будет не просто хороша в обучении, но еще и масштабируема для массивных наборов данных.

Сверточный слой — Кернел (the kernel)

Свертывание изображения 5x5x1 с кернелом размерностью 3x3x1 для получения свернутой функции 3x3x1

Размеры изображения = 5 (высота) x 5 (ширина) x 1 (количество каналов, например, RGB)
На гифке выше видно, что зеленая часть напоминает наше входное изображение 5x5x1, I. Элемент, участвующий в выполнении операции свертки в первой части сверточного слоя, называется кернелом/фильтром, K, показан желтым цветом. Мы выбрали K в качестве матрицы 3x3x1.

Кернел/Фильтр, К =
1 0 1
0 1 0
1 0 1

Кернел смещается 9 раз, так как длина страйда (Stride) = 1, каждый раз выполняя операцию умножения матриц между K и частью P изображения, над которым кернел ​​зависает.

Передвижение кернела

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

Операция свертки на матрице изображения MxNx3 с кернелом размерностью 3x3x3

В случае, когда у изображения несколько каналов (например, RGB), кернел ​​имеет ту же глубину, что и входное изображение. Матричное умножение выполняется между стэками Kn и In ([K1, I1]; [K2, I2]; [K3, I3]), и все результаты суммируются со смещением, чтобы выдать нам сжатый выходной сигнал одной глубины.

Операция свертки с длиной страйда = 2

Цель операции свертки — извлечь из входного изображения высокоуровневые признаки, например, линии, края. ConvNets вовсе не обязательно должны быть ограничены только одним сверточным слоем. Традиционно, первый ConvLayer отвечает за захват низкоуровневых признаков, таких как края, цвет, градиентная ориентация и т.д. Благодаря добавленным слоям архитектура адаптируется также к высокоуровневым признакам, выдавая нам сеть, которая имеет столь же здравое понимание изображений в наборе данных, что и мы.

Эта операция может давать два типа результатов: один, в котором свернутый признак имеет меньшую размерность по сравнению с входным, в другом же размерность либо увеличивается, либо остается неизменной. Это делается путем применения паддинга без дополнения (Valid Padding) в случае первого или паддинга с дополнением нулями (Same Padding) в случае последнего.

Same-паддинг: изображение 5x5x1 дополняется (is padded) нулями, чтобы создать изображение 6x6x1

Когда мы преобразуем изображение 5x5x1 в изображение 6x6x1, а затем применяем к нему кернел размерностью ​​3x3x1, мы обнаруживаем, что размер свернутой матрицы — 5x5x1. Отсюда и название — Same-паддинг.

В то же время если мы выполним ту же операцию без паддинга, мы получим матрицу, которая имеет размеры самого кернела (3x3x1) — Valid-паддинг.

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

Пулинговый слой (Pooling Layer)

3×3 преобразуется с помощью пулинга в сложную функцию 5×5

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

Существует два типа пулинга: максимальный (Max Pooling) и средний (Average Pooling). Максимальный пулинг возвращает максимальное значение из части изображения, покрываемой кернелом. А Средний пулинг возвращает среднее всех значений из части изображения, покрываемой кернелом.

Максимальный пулинг также выступает в роли шумоподавителя (Noise Suppressant). Он полностью исключает шумовые сигналы, а также совмещает подавление шума с уменьшением размерности. Средний же пулинг просто использует уменьшение размерности как способ подавления шума. То есть можно сказать, что Max Pooling работает намного лучше, чем Average Pooling.

Типы пулинга

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

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

Классификация — Полностью Связанный Слой (Fully Connected Layer, FC Layer)

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

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

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

1. LeNet
2. AlexNet
3. VGGNet
4. GoogLeNet
5. RESNET
6. ZFNet

GitHub Notebook — Распознавание рукописных цифр с использованием набора данных MNIST с TensorFlow

Источник

Стэнфордский курс: лекция 5. Свёрточные нейронные сети

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

Предыдущие лекции:

Лекция 1. Введение
Лекция 2. Классификация изображений
Лекция 3. Функция потерь и оптимизация
Лекция 4. Введение в нейронные сети

Немного истории

В 1957 году Фрэнк Розенблатт изобрёл вычислительную систему «Марк-1», которая стала первой реализацией перцептрона. Этот алгоритм тоже использует интерпретацию линейного классификатора и функцию потерь, но на выходе выдаёт либо 0, либо 1, без промежуточных значений.

Индикаторы и переключатели «Марк I»

На вход перцептрона подаются веса w и исходные данные x, а их произведение корректируется смещением b.

В 1960 году Бернард Уидроу и Тед Хофф разработали однослойную нейросеть ADALINE и её улучшенную версию — трёхслойную MADALINE. Это были первые глубокие (для того времени) архитектуры, но в них ещё не использовался метод обратного распространения ошибки. 

ADALINE

Алгоритм backpropagation появился в 1986 году в работе Дэвида Румельхарта, которая называлась «Многослойный перцептрон». В нём используются уже знакомые нам уравнения, правило дифференцирования и выходные значения в диапазоне от 0 до 1.

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

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

Нейросети повсюду

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

Примеры задач классификации и поиска изображений

Примеры детектирования объектов и сегментации

Нейросети активно развиваются и уже используются в автономных автомобилях, в задачах распознавания лиц, классификации видео, определения позы или жестов человека. Кстати, именно свёрточные архитектуры научились обыгрывать людей в шахматы и го. Среди других специфичных применений — анализ медицинских изображений, сегментация географических карт, составление текстового описания по фото (Image captioning) и перенос стиля художников на фотографии.

Примеры переноса стиля

Эта лишь малая часть примеров использования свёрточных сетей. Давайте разберёмся, как они работают и что делает их такими разносторонними.

Как устроены свёрточные сети

На прошлой лекции мы обсудили идею создания полносвязных линейных слоёв. Предположим, что у нас есть исходное 3D-изображение 32x32x3. Растянем его в один длинный вектор 3072×1 и перемножим с матрицей весов размером, для примера, 10×3072. В итоге нам нужно получить активацию (вывод с оценками классов) — для этого берём каждую из 10 строк матрицы и выполняем скалярное произведение с исходным вектором.

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

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

В результате прохода по изображению мы получаем карту активации, также известную как карта признаков. Этот процесс называется пространственной свёрткой — более подробно о нём можно почитать в статье Свёртка в Deep Learning простыми словами. Из неё вы также можете узнать, почему размер карты активации получается меньше, чем у исходной фотографии.

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

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

Примеры фильтров для свёрточных слоёв нейросети VGG-16

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

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

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

Схема работы свёрточной нейросети

По такому принципу работают современные свёрточные нейросети.

Подводя итоги

Итак, посмотрим на полный набор функций свёрточного слоя:

1. Принимает исходное изображение определённой размерности W₁ x H₁ x D₁.
2. Использует четыре гиперпараметра для фильтров:

— число фильтров K;

— их размер F;

— шаг S;

— число дополнительных нулей P (используются для заполнения «потерянных» участков изображения после применения свёртки).

3. Выводит карту активации размером W₂ x H₂ x D₂, где:

W₂ = (W₁ − F + 2P) / S + 1

H₂ = (H₁ − F + 2P) / S + 1

D₂ = K

4. Использует F * F * D₁ весов на каждый фильтр, в общей сложности (F * F * D₁) * K весов и K смещений.

Если мы посмотрим на код фреймворка Caffe, который мы упоминали на прошлой лекции, то увидим примерно те же параметры:

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

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

Для выполнения задания вам понадобится Python > 3.6 и среда Jupyter Notebook или Jupyter Lab. 

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

Следующие лекции (список будет дополняться по мере появления материалов):

Лекция 6. Обучение нейросетей, часть 1
Лекция 7. Обучение нейросетей, часть 2
Лекция 8. ПО для глубокого обучения
Лекция 9. Архитектуры CNN
Лекция 10. Рекуррентные нейронные сети

С оригинальной лекцией можно ознакомиться на YouTube.

Сверточная нейронная сеть — Convolutional neural network

Искусственная нейронная сеть

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

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

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

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

Определение

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

Архитектура

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

Сверточный

При программировании CNN входными данными является тензор с формой (количество изображений) x (высота изображения) x (ширина изображения) x ( глубина изображения ). Затем после прохождения через сверточный слой изображение преобразуется в карту объектов с формой (количество изображений) x (высота карты объектов) x (ширина карты объектов) x (каналы карты объектов). Сверточный слой в нейронной сети должен иметь следующие атрибуты:

• Сверточные ядра, определяемые шириной и высотой (гиперпараметры).
• Количество входных и выходных каналов (гиперпараметр).
• Глубина фильтра свертки (входные каналы) должна быть равна количеству каналов (глубине) входной карты функций.

Сверточные слои сворачивают входные данные и передают результат следующему слою. Это похоже на реакцию нейрона зрительной коры на определенный стимул. Каждый сверточный нейрон обрабатывает данные только для своего рецептивного поля . Хотя полностью связанные нейронные сети с прямой связью можно использовать для изучения функций, а также для классификации данных, применять эту архитектуру к изображениям нецелесообразно. Было бы необходимо очень большое количество нейронов, даже в мелкой (противоположной глубокой) архитектуре, из-за очень больших входных размеров, связанных с изображениями, где каждый пиксель является релевантной переменной. Например, полностью связанный слой для (маленького) изображения размером 100 x 100 имеет 10 000 весов для каждого нейрона во втором слое. Операция свертки решает эту проблему, так как уменьшает количество свободных параметров, позволяя сети быть более глубокой с меньшим количеством параметров. Например, независимо от размера изображения, мозаичные области размером 5 x 5, каждая с одинаковым общим весом, требует всего 25 обучаемых параметров. Использование регуляризованных весов по меньшему количеству параметров позволяет избежать проблем с исчезающим градиентом и взрывным градиентом, наблюдаемыми при обратном распространении в традиционных нейронных сетях.

Объединение

Сверточные сети могут включать в себя локальные или глобальные уровни объединения для упрощения базовых вычислений. Слои объединения уменьшают размер данных, объединяя выходные данные кластеров нейронов на одном уровне в один нейрон на следующем уровне. Локальный пул объединяет небольшие кластеры, обычно 2 x 2. Глобальный пул действует на все нейроны сверточного слоя. Кроме того, объединение может вычислять максимальное или среднее значение. Максимальный пул использует максимальное значение от каждого кластера нейронов на предыдущем уровне. Средний пул использует среднее значение от каждого кластера нейронов на предыдущем уровне.

Полностью подключен

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

Рецептивное поле

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

Вес

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

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

История

Дизайн CNN следует за обработкой изображений в живых организмах .

Рецептивные поля в зрительной коре

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

Их статья 1968 года определила два основных типа зрительных клеток мозга:

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

Хьюбел и Визель также предложили каскадную модель этих двух типов ячеек для использования в задачах распознавания образов.

Неокогнитрон, происхождение архитектуры CNN

« Неокогнитрон » был представлен Кунихико Фукусимой в 1980 году. Он был вдохновлен вышеупомянутой работой Хьюбеля и Визеля. Неокогнитрон представил два основных типа слоев в CNN: сверточные слои и слои с понижающей дискретизацией. Сверточный слой содержит блоки, рецептивные поля которых покрывают участок предыдущего слоя. Весовой вектор (набор адаптивных параметров) такого блока часто называют фильтром. Юниты могут использовать общие фильтры. Слои с понижающей дискретизацией содержат блоки, рецептивные поля которых покрывают участки предыдущих сверточных слоев. Такой юнит обычно вычисляет среднее значение активаций юнитов в своем патче. Эта понижающая дискретизация помогает правильно классифицировать объекты в визуальных сценах, даже когда объекты сдвинуты.

В варианте неокогнитрона, называемом крецептроном, вместо использования пространственного усреднения Фукусимы J. Weng et al. представил метод, называемый max-pooling, где блок понижающей дискретизации вычисляет максимум активаций блоков в своем патче. Max-pooling часто используется в современных CNN.

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

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

Нейронные сети с временной задержкой

Время задержки нейронной сети (TDNN) была введена в 1987 году Алекс Уэйбел и соавт. и была первой сверточной сетью, поскольку она достигла инвариантности сдвига. Это было сделано за счет использования распределения веса в сочетании с тренировкой обратного распространения . Таким образом, используя также пирамидальную структуру, как в неокогнитроне, он выполнил глобальную оптимизацию весов вместо локальной.

TDNN — это сверточные сети, которые разделяют веса во временном измерении. Они позволяют обрабатывать речевые сигналы независимо от времени. В 1990 году Хэмпшир и Вайбел представили вариант, который выполняет двумерную свертку. Поскольку эти TDNN оперировали спектрограммами, полученная система распознавания фонем была инвариантной как к сдвигам во времени, так и по частоте. Это вдохновило на неизменность перевода при обработке изображений с помощью CNN. Распределение выходов нейронов может охватывать временные этапы.

TDNN теперь демонстрируют наилучшую производительность при распознавании речи на большом расстоянии.

Макс пул

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

Распознавание изображений с помощью CNN, обученных методом градиентного спуска

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

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

Этот подход стал основой современного компьютерного зрения .

LeNet-5

Основная статья: LeNet

LeNet-5, новаторская 7-уровневая сверточная сеть, разработанная LeCun et al. В 1998 году эта классификация цифр применялась несколькими банками для распознавания рукописных цифр на чеках ( британский английский : чеки ), оцифрованных в изображениях 32×32 пикселей. Способность обрабатывать изображения с более высоким разрешением требует все большего и большего количества слоев сверточных нейронных сетей, поэтому этот метод ограничен доступностью вычислительных ресурсов.

Сдвиг-инвариантная нейронная сеть

Точно так же нейронная сеть, инвариантная к сдвигу, была предложена W. Zhang et al. для распознавания символов на изображениях в 1988 г. Архитектура и алгоритм обучения были изменены в 1991 г. и применялись для обработки медицинских изображений и автоматического обнаружения рака груди на маммограммах .

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

Пирамида нейронной абстракции

Пирамида нейронной абстракции

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

Реализации GPU

Хотя CNN были изобретены в 1980-х, их прорыв в 2000-х потребовал быстрой реализации на графических процессорах (GPU).

В 2004 году К.С. О и К. Юнг показали, что стандартные нейронные сети могут быть значительно ускорены на графических процессорах. Их реализация была в 20 раз быстрее, чем аналогичная реализация на CPU . В 2005 году в другом документе также подчеркивалась ценность GPGPU для машинного обучения .

Первая реализация CNN на GPU была описана в 2006 году K. Chellapilla et al. Их реализация была в 4 раза быстрее, чем аналогичная реализация на CPU. В последующих работах также использовались графические процессоры, первоначально для других типов нейронных сетей (отличных от CNN), особенно нейронных сетей без учителя.

В 2010 году Дэн Чиресан и др. в IDSIA показали, что даже глубокие стандартные нейронные сети со многими уровнями можно быстро обучить на графическом процессоре путем обучения с учителем с помощью старого метода, известного как обратное распространение . Их сеть превзошла предыдущие методы машинного обучения в тесте рукописных цифр MNIST . В 2011 году они распространили этот подход с использованием графических процессоров на CNN, добившись коэффициента ускорения 60 с впечатляющими результатами. В 2011 году они использовали такие CNN на GPU, чтобы выиграть конкурс распознавания изображений, в котором они впервые достигли сверхчеловеческой производительности. В период с 15 мая 2011 г. по 30 сентября 2012 г. их CNN выиграли не менее четырех имиджевых конкурсов. В 2012 году они также значительно улучшили лучшую производительность в литературе для нескольких баз данных изображений , включая базу данных MNIST , базу данных NORB, набор данных HWDB1.0 (китайские иероглифы) и набор данных CIFAR10 (набор данных из 60000 изображений 32×32 с маркировкой RGB ). .

Впоследствии аналогичный CNN на базе GPU Алекса Крижевского и др. победила в конкурсе ImageNet Large Scale Visual Recognition Challenge 2012. Очень глубокая CNN с более чем 100 слоями от Microsoft выиграла конкурс ImageNet 2015.

Реализации Intel Xeon Phi

По сравнению с обучением CNN с использованием графических процессоров сопроцессору Intel Xeon Phi уделялось не так много внимания . Примечательной разработкой является метод распараллеливания для обучения сверточных нейронных сетей на Intel Xeon Phi, названный Controlled Hogwild с произвольным порядком синхронизации (CHAOS). CHAOS использует параллелизм на уровне потоков и SIMD, который доступен на Intel Xeon Phi.

Отличительные черты

В прошлом для распознавания изображений использовались традиционные модели многослойного персептрона (MLP). Однако из-за полной связи между узлами они страдали от проклятия размерности и плохо масштабировались с изображениями с более высоким разрешением. Изображение размером 1000 × 1000 пикселей с цветовыми каналами RGB имеет 3 миллиона весов, что слишком много для эффективной обработки в масштабе с полной связью.

Слои CNN расположены в 3-х измерениях

Например, в CIFAR-10 изображения имеют размер только 32 × 32 × 3 (32 в ширину, 32 в высоту, 3 цветовых канала), поэтому один полностью связанный нейрон в первом скрытом слое обычной нейронной сети будет иметь 32 * 32 * 3 = 3072 веса. Однако изображение размером 200 × 200 приведет к появлению нейронов с весами 200 * 200 * 3 = 120 000.

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

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

• 3D-объемы нейронов. Слои CNN имеют нейроны, расположенные в трех измерениях : ширине, высоте и глубине. где каждый нейрон внутри сверточного слоя связан только с небольшой областью слоя перед ним, называемой рецептивным полем. Различные типы слоев, как локально, так и полностью связанные, складываются в стек, чтобы сформировать архитектуру CNN.
• Локальная связность: следуя концепции рецептивных полей, CNN используют пространственную локальность, навязывая шаблон локальной связи между нейронами соседних слоев. Таким образом, архитектура гарантирует, что изученные « фильтры » дают наиболее сильный отклик на пространственно локальный входной шаблон. Наложение множества таких слоев приводит к нелинейным фильтрам, которые становятся все более глобальными (т. Е. Реагирующими на большую область пиксельного пространства), так что сеть сначала создает представления небольших частей ввода, а затем из них собирает представления более крупных областей.
• Общие веса: в CNN каждый фильтр реплицируется по всему визуальному полю. Эти реплицированные единицы имеют одинаковую параметризацию (вектор веса и смещение) и образуют карту характеристик. Это означает, что все нейроны в данном сверточном слое реагируют на одну и ту же функцию в пределах своего конкретного поля ответа. Репликация единиц таким образом позволяет результирующей карте признаков быть эквивариантной при изменениях местоположения входных признаков в поле зрения, то есть они обеспечивают трансляционную эквивалентность.
• Объединение: в слоях объединения CNN карты характеристик делятся на прямоугольные подобласти, и функции в каждом прямоугольнике независимо подвергаются понижающей дискретизации до одного значения, обычно с использованием их среднего или максимального значения. В дополнение к уменьшению размеров карт признаков, операция объединения обеспечивает некоторую степень трансляционной инвариантности для содержащихся в них признаков, позволяя CNN быть более устойчивой к изменениям их положения.

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

Строительные блоки

Архитектура CNN образована стеком отдельных слоев, которые преобразуют входной объем в выходной объем (например, удерживая оценки классов) посредством дифференцируемой функции. Обычно используются несколько различных типов слоев. Это более подробно обсуждается ниже.

Нейроны сверточного слоя (синий), связанные со своим рецептивным полем (красный)

Сверточный слой

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

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

Локальная связь

Типичная архитектура CNN

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

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

Пространственное расположение

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

• Глубина объема выходного контролирует количество нейронов в слое , которые подключаются к одной и той же области объема ввода. Эти нейроны учатся активироваться для различных функций на входе. Например, если первый сверточный слой принимает необработанное изображение в качестве входных данных, то различные нейроны по измерению глубины могут активироваться в присутствии различных ориентированных краев или пятен цвета.
• Шаг управляет распределением столбцов глубины вокруг пространственных размеров (ширины и высоты). Когда шаг равен 1, мы перемещаем фильтры по одному пикселю за раз. Это приводит к сильному перекрытию принимающих полей между столбцами, а также к большим объемам вывода. Когда шаг равен 2, фильтры перемещаются по 2 пикселя за раз. Аналогично, для любого целого числашаг S вызывает преобразование фильтра на S единиц за раз для каждого вывода. На практике длина шагаредка. При увеличении длины шага рецептивные поля меньше перекрываются, и результирующий выходной объем имеет меньшие пространственные размеры.S>0,{\ textstyle S> 0,}S≥3{\ textstyle S \ geq 3}
• Иногда удобно заполнить ввод нулями на границе объема ввода. Размер этого отступа — третий гиперпараметр. Padding обеспечивает управление пространственным размером выходного тома. В частности, иногда желательно точно сохранить пространственный размер входного объема.

Пространственный размер выходного объема можно вычислить как функцию размера входного объема, размера поля ядра нейронов сверточного слоя , шага, с которым они применяются , и количества нулевого заполнения, используемого на границе. Формула для расчета количества нейронов «умещается» в заданном объеме:
W{\ displaystyle W}K{\ displaystyle K}S{\ displaystyle S}п{\ displaystyle P}

W-K+2пS+1.{\ displaystyle {\ frac {WK + 2P} {S}} + 1.}

Если это число не является целым числом , то шаги неверны, и нейроны не могут быть выложены плиткой, чтобы соответствовать входному объему симметричным образом. В общем, установка нулевого отступа для шага гарантирует, что входной и выходной объем будут иметь одинаковый пространственный размер. Однако не всегда полностью необходимо использовать все нейроны предыдущего слоя. Например, разработчик нейронной сети может решить использовать только часть заполнения.
пзнак равно(K-1)/2{\ textstyle P = (K-1) / 2}Sзнак равно1{\ Displaystyle S = 1}

Совместное использование параметров

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

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

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

Слой объединения

Максимальное объединение с фильтром 2×2 и шагом = 2

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

Интуитивно понятно, что точное расположение объекта менее важно, чем его приблизительное расположение относительно других объектов. Это идея использования пула в сверточных нейронных сетях. {1} S_ {2X + a, 2Y + b}.}

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

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

Из-за агрессивного уменьшения размера представления в последнее время наблюдается тенденция к использованию меньших фильтров или полного отказа от слоев пула.

RoI пул до размера 2×2. В этом примере предложение региона (входной параметр) имеет размер 7×5.

« Область интересов » объединения (также известный как Roi объединения) представляет собой вариант макс объединения, в котором выходной размер фиксируется и входной прямоугольник является параметром.

Пул — важный компонент сверточных нейронных сетей для обнаружения объектов на основе архитектуры Fast R-CNN. {- 1}}

Полностью связанный слой

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

Слой потерь

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

Softmax loss используется для прогнозирования одного класса из K взаимоисключающих классов. Сигмоидная кросс-энтропийная потеря используется для предсказания K независимых значений вероятности в . Евклидовы потери используются для регрессии к меткам с действительной стоимостью .
[0,1]{\ displaystyle [0,1]}(-∞,∞){\ Displaystyle (- \ infty, \ infty)}

Выбор гиперпараметров

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

Количество фильтров

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

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

Форма фильтра

Общие формы фильтров, встречающиеся в литературе, сильно различаются и обычно выбираются на основе набора данных.

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

Максимальная форма объединения

Типичные значения — 2 × 2. Очень большие входные объемы могут потребовать объединения 4 × 4 в нижних слоях. Однако выбор более крупных форм резко уменьшит размер сигнала и может привести к избыточной потере информации . Часто лучше всего работают неперекрывающиеся окна объединения.

Методы регуляризации

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

Эмпирический

Выбывать

Поскольку полностью связанный слой занимает большинство параметров, он подвержен переобучению. Один из способов уменьшить переобучение — это отсев . На каждом этапе обучения отдельные узлы либо «выпадают» из сети с вероятностью, либо сохраняются с вероятностью , так что остается сокращенная сеть; входящие и исходящие ребра выпавшего узла также удаляются. На этом этапе на данных обучается только сокращенная сеть. Затем удаленные узлы повторно вставляются в сеть с их исходными весами.
1-п{\ displaystyle 1-p}п{\ displaystyle p}

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

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

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

DropConnect

DropConnect — это обобщение отказа от подключения, при котором с вероятностью может быть сброшено каждое соединение, а не каждое устройство вывода . Таким образом, каждая единица получает входные данные от случайного подмножества единиц на предыдущем уровне.
1-п{\ displaystyle 1-p}

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

Стохастический пул

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

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

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

Искусственные данные

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

Явный

Ранняя остановка

Один из простейших методов предотвращения переобучения сети — просто остановить обучение до того, как произойдет переобучение. Его недостатком является то, что процесс обучения останавливается.

Количество параметров

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

Снижение веса

Простая форма добавленного регуляризатора — это уменьшение веса, которое просто добавляет дополнительную ошибку, пропорциональную сумме весов ( норма L1 ) или квадрату величины ( норма L2 ) вектора весов, к ошибке в каждом узле. Уровень приемлемой сложности модели можно снизить, увеличив константу пропорциональности, тем самым увеличив штраф за большие весовые векторы.

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

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

Ограничения максимальной нормы

Другой формой регуляризации является обеспечение абсолютной верхней границы величины вектора весов для каждого нейрона и использование прогнозируемого градиентного спуска для обеспечения ограничения. На практике это соответствует выполнению обновления параметра как обычно, а затем принудительному применению ограничения путем ограничения вектора весов каждого нейрона, чтобы удовлетворить его . Типичные значения порядка 3–4. В некоторых статьях сообщается об улучшениях при использовании этой формы регуляризации.
ш→{\ displaystyle {\ vec {w}}}

Глубокое обучение и сверточные сети

1 Глубокое обучение и сверточные сети Ян Лекун Facebook AI Research & Center for Data Science, NYU

2 Машинное обучение (контролируемый Лернинг) обучает машину отличать автомобили от самолетов.Мы показываем ему множество примеров автомобилей и самолетов. Каждый раз мы настраиваем ручки так, чтобы получился хороший ответ. PLANE CAR

3 Машинное обучение — обучение машины отличать автомобили от самолетов. Мы показываем ему множество примеров автомобилей и самолетов Каждый раз мы настраиваем ручки так, чтобы они давали хороший ответ PLANE CAR

4 Масштабное машинное обучение: реальность Сотни миллионов ручек Тысячи категорий Миллионы обучающих образцов Распознавание каждого выборка может потребовать миллиардов операций Но эти операции представляют собой простое умножение и сложение

5 55 лет ручной работы Традиционная модель распознавания образов (с конца 50-х) Фиксированные / спроектированные функции (или фиксированное ядро) + обучаемый классификатор Персептрон рука -созданный простой обучаемый классификатор экстрактора признаков

6 Глубокое обучение = изучение иерархических представлений Традиционное распознавание образов: фиксированный / созданный вручную компонент экстрактора признаков Обучаемый классификатор экстрактора Основное современное распознавание образов: неконтролируемые функции среднего уровня F Функции обучаемого экстрактора среднего уровня Классификатор Глубокое обучение: представления являются иерархическими и обучаемыми. Обучаемые функции низкого уровня среднего уровня высокого уровня Функции Функции Классификатор

7 Глубокое обучение = изучение иерархических представлений. -линейное преобразование функций Низкий уровень Средний уровень Высокий уровень обучаемых функций Классификатор функций Визуализация функций сверточной сети, обученной в ImageNet из [Zeiler & Fergus 2013]

8 Иерархия обучаемых функций Иерархия представлений с возрастающим уровнем абстракции Каждый этап своего рода обучаемая функция преобразования Распознавание изображений Pixel edge texton motif part object Text Символьное слово группа слов предложение история предложения Речь Пример спектрального диапазона звука телефонного слова фонемы

9 Shallow vs Deep == таблица поиска vs многошаговый алгоритм неглубокий и широкий против глубокого и узкого == больше памяти против большего времени Таблица поиска по сравнению с алгоритмом Немногие функции могут быть вычислены за два шага без экспоненциально большой таблицы поиска Использование более 2 шагов может уменьшить память в экспоненциальной фактор.Шаг 4 Шаг 3 Шаг 2 Шаг 2 Шаг 1 (поисковая таблица / шаблоны) Шаг 1

10 Текущие исследования: глубокое обучение + структурированное прогнозирование Глубокая архитектура, обученная на глобальном уровне Распознавание рукописного ввода: с середины 1990-х годов Распознавание речи: с 2011 года Все модули обучаются с помощью комбинации неконтролируемого и контролируемого обучения Сквозное обучение == глубоко структурированное прогнозирование Unsup + Unsup + контролируемые фиксированные фильтры + Unsup + фиксированные контролируемые фильтры Объединение ReLU + контролируемые контролируемые фильтры Объединение ReLU Низкоуровневые функции среднего уровня Функции Unsup + + ReLU Графическая модель, детали, телефоны, персонажи Объект, высказывание, слово

11 Как мозг интерпретирует изображения? Вентральный (узнающий) путь в зрительной коре имеет несколько этапов: сетчатка — LGN — V1 — V2 — V4 — PIT — AIT… [изображение Саймона Торпа] [Галлант и Ван Эссен]

12 Давайте вдохновимся природой, но не слишком. Это приятно подражать природе, но нам также нужно понимать, как мы узнаем, какие детали важны? Какие детали являются просто результатом эволюции и ограничений биохимии? Для самолетов мы разработали аэродинамику и динамику сжимаемой жидкости. Мы пришли к выводу, что перья и взмахи крыльев не имеют решающего значения. ВОПРОС: Что такое аэродинамика для понимания интеллекта? L’Avion III de Clément Ader, 1897 (Musée du CNAM, Париж) Его Eole взлетел с земли в 1890 году, за 13 лет до братьев Райт, но вы, вероятно, никогда о нем не слышали (если только вы не француз).

13 Сверточная сеть (винтаж 1990 г.) Filters-tanh pooling filters-tanh pooling filters-tanh

14 Банк сверточных сетевых фильтров + банк фильтров нелинейности + банк фильтров объединения + нелинейность Банк фильтров объединения + нелинейность [LeCun et al. NIPS 1989]

15 Пул с разреженным нелинейным расширением Во-первых, разбейте все на части, второй объедините вместе похожие вещи Фильтрация + объединение нелинейностей.Агрегация

16 Общая архитектура: несколько этапов нормализации Банк фильтров Нелинейность Объединение норм Банк фильтров Нелинейная функция Объединение норм Банк фильтров Нелинейная функция Объединение Нормализация: изменение отбеливания (необязательно) Вычитающее: среднее удаление, фильтрация верхних частот Divisive: локальная нормализация контраста , нормализация дисперсии Банк фильтров: расширение размеров, проекция на сверхполной основе. Нелинейность: разрежение, насыщение, латеральное подавление… Исправление (ReLU), Компонентная усадка, tanh, .. ReLU (x) = max (x, 0) Объединение: агрегация по пространству или типу объекта Max, Lp norm, log prob. p p MAX: Макс i (X i); L p: X i; PROB: 1 log b (ei bx i) Классификатор

17 Контролируемое обучение: стохастическая (под) градиентная оптимизация

18 LeNet1 Demo с 1993 г. Работает на ПК 486 с дополнительной платой AT&T DSP32C (20 Mflops!)

19 ANNA: чип аналогово-цифрового ускорителя ConvNet (Bell Labs) [Boser, Säckinger, Bromley, LeCun, Jackel, IEEE J.SSC 26 (12), 1991] 4096 Операторы умножения-накопления, 6-битные веса, 4-битные состояния, тактовая частота 20 МГц Регистры сдвига для эффективного ввода-вывода со свертками 4 GOPS (пиковая) 1000 символов в секунду для OCR с ConvNet.

20 Распознавание нескольких символов [Матан и др., 1992] Каждый слой представляет собой свертку

21 ConvNet со скользящим окном + взвешенный конечный автомат

22 Автомат со скользящим окном ConvNet + Weighted FSM

23 Check Reader (Bell Labs, 1995) График сеть трансформаторов обучена считывать суммы чеков.Обучено глобально с потерей NegativeLog-Likelihood. 50% правильных, 49% отклоненных, 1% ошибок (обнаруживается позже в процессе. Выведен в 1996 г., используется во многих банках США и Европы. Обработано от 10% до 20% всех чеков, выписанных в США в начало

Важность сети во встроенных системах для начинающих

Вы, должно быть, слышали эти слова: LAN, WAN и MAN; чаще всего все они относятся к сетям. Итак, что такое сеть? «Сеть» — это общий термин, который относится к группе объектов, таких как объекты, люди и т. д., которые связаны.
Таким образом, сеть позволяет распределять материальные или нематериальные элементы между всеми этими объектами на основе четко определенных правил. Существуют различные типы сетей, которые обычно используются для связи. Поэтому давайте посмотрим, какова важность сети во встроенной системе.

Sensor Network

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

Что такое сеть и сеть?

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

Различные типы сетей связи

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

Телефонная сеть

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

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

Телефонная сеть

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

Компьютерная сеть

Компьютерная сеть — это группа компьютеров связаны вместе с физическими линиями обмена информацией в виде цифровых данных (двоичные значения, т.е.е., значения, закодированные как сигнал, который может представлять 0 или 1). Связи (соединения) между узлами устанавливаются с использованием кабельной или беспроводной среды. Лучшим примером компьютерной сети является Интернет.

Компьютерная сеть

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

Почему сети важны?

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

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

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

Важность сети

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

Такие системы обладают следующими преимуществами:

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

Какова важность сети в Встроенная система?

Встроенная система изначально была разработана для работы с одним устройством. Однако в текущем сценарии реализация различных сетевых опций повысила общую производительность встроенной системы с точки зрения экономии, а также технических соображений.
Наиболее эффективными типами сети, используемой во встроенной системе, являются сеть BUS и сеть Ethernet.
ШИНА используется для подключения различных сетевых устройств и передачи огромного количества данных, например, последовательной шины, шины I2C, шины CAN и т.д.
Сеть типа Ethernet работает с протоколом TCP / IP.
Примеры встроенных сетей включают CAN, I2C, компонентную сеть, датчик и последовательную шину.

Встроенная сеть

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

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

Различные типы сетей обычно имеют следующие общие черты:

• Серверы: Это компьютеры, которые предоставляют основную информацию.
• Клиенты: Это компьютеры или другие устройства, которые получают доступ к общим ресурсам.
• Среда подключения: Среда подключения определяет взаимосвязь различных устройств.
• Общие данные: Это информация, которая передается в сети и принимается клиентами.
• Принтеры и другие совместно используемые периферийные устройства: Периферийные устройства (устройства), которые подключены к клиентским машинам для обработки и получения информации.

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

Фото:

CNTK 103: Часть D — Сверточная нейронная сеть с MNIST — Python API для CNTK 2.6 документация

Мы предполагаем, что вы успешно завершили CNTK 103 Часть A (MNIST
Загрузчик данных).

В этом руководстве мы обучим сверточную нейронную сеть (CNN) на
Данные MNIST. Эта записная книжка предоставляет рецепт с использованием Python API. Если
вы ищете этот пример в BrainScript, пожалуйста, посмотрите
здесь

Введение

Сверточный нейронный
сеть
(CNN, или ConvNet) — это тип
прямая связь
искусственная нейронная сеть, состоящая из нейронов, имеющих обучаемый вес
и смещения, очень похожие на обычный многослойный персептрон (MLP)
сети, представленные в 103C.CNN используют преимущества пространственного
характер данных. В природе мы воспринимаем разные предметы по их
формы, размеры и цвета. Например, объекты в естественной сцене
обычно ребра, углы / вершины (определяемые двумя или более ребрами), цвет
патчи и т. д. Эти примитивы часто идентифицируются разными
детекторы (например, детектор края, детектор цвета) или комбинация
детекторы взаимодействуют, чтобы облегчить интерпретацию изображения (объект
классификация, обнаружение интересующей области, описание сцены и т. д.) в
задачи, связанные с видением реального мира. Эти детекторы также известны как
фильтры. Свертка — математический оператор, который берет изображение и
фильтр на входе и производит отфильтрованный вывод (представляющий, скажем,
края, углы, цвета и т. д. на входном изображении). Исторически эти
фильтры — это набор весов, которые часто создавались вручную или моделировались
с математическими функциями (например,
Гауссовский /
Лапласиан /
Canny filter).
Выходы фильтров отображаются через нелинейные функции активации.
имитирующие клетки человеческого мозга, называемые
нейроны.

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

Было показано, что многие примитивы CNN концептуально
параллельные компоненты в визуальном
кора. Группа
Клетки нейронов зрительной коры при стимуляции излучают ответы. Этот
область известна как рецептивное поле (RF). Эквивалентно в
свертка входная область, соответствующая размерам фильтра, может
считаться восприимчивым полем.Популярные глубокие CNN или ConvNets
(например, AlexNet,
VGG,
Начало,
ResNet), которые используются для
различный компьютер
задачи видения имеют
многие из этих архитектурных примитивов (вдохновленных биологией).

В этом руководстве мы познакомимся с операцией свертки и
знакомство с различными параметрами в CNN.

Задача : Как и в CNTK 103C, мы продолжим работать над тем же
проблема распознавания цифр в данных MNIST. Данные MNIST состоят из
рукописные цифры с небольшим фоновым шумом.

# Фигура 1
Изображение (url = "http://3.bp.blogspot.com/_UpN7DfJA0j4/TJtUBWPk0SI/AAAAAAAAABY/oWPMtmqJn3k/s1600/mnist_originals.png", ширина = 200, высота = 200)
 

Цель : Наша цель — подготовить классификатор, который будет определять
цифры в наборе данных MNIST.

Подход :

Применяются те же 5 этапов, которые мы использовали в предыдущем уроке:
Чтение данных, Предварительная обработка данных, Создание модели, Изучение модели
параметры и оценка (a.k.a. тестирование / прогноз) модель. — Данные
чтение: Мы будем использовать программу чтения текста CNTK — Предварительная обработка данных: Покрыто
в части A (предлагаемый раздел о расширении).

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

from __future__ import print_function # Использовать определение функции из будущей версии (скажем, 3.x из интерпретатора 2.7)
импортировать matplotlib.image как mpimg
импортировать matplotlib.pyplot как plt
импортировать numpy как np
импорт ОС
import sys
время импорта

импортировать cntk как C
импорт cntk.tests.test_utils
cntk.tests.test_utils.set_device_from_pytest_env () # (требуется только для нашей системы сборки)
C.cntk_py.set_fixed_random_seed (1) # исправить случайное начальное число для компонентов CNTK

% matplotlib встроенный
 

Чтение данных

В этом разделе мы прочитаем данные, сгенерированные в CNTK 103 Part A
(Загрузчик данных MNIST).

Мы используем данные MNIST, которые вы загрузили с помощью
CNTK_103A_MNIST_DataLoader записная книжка. В наборе данных 60 000 тренировок.
изображений и 10 000 тестовых изображений, каждое из которых имеет размер 28 x 28 пикселей.Таким образом
количество функций равно 784 (= 28 x 28 пикселей), 1 на пиксель.
Переменная num_output_classes установлена ​​в 10, что соответствует
количество цифр (0-9) в наборе данных.

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

Входные размеры :

В сверточных сетях для изображений входные данные часто имеют вид
3D-матрица (количество каналов, ширина, высота изображения), сохраняющая
пространственные отношения между пикселями.На рисунке выше
Изображение MNIST представляет собой одноканальные (в градациях серого) данные, поэтому входной размер
задается как кортеж (1, ширина изображения, высота изображения).

Цветные изображения естественной сцены часто представлены как красно-зелено-синий (RGB)
цветовые каналы. Входной размер таких изображений определяется как
(3, ширина изображения, высота изображения) кортеж. Если у вас есть входные данные RGB как
объемное сканирование с шириной объема, высотой объема и глубиной объема
представляя 3 оси, формат входных данных будет определяться
набор из 4 значений (3, ширина тома, высота тома, глубина тома).В
таким образом CNTK позволяет указывать входные изображения в произвольных
многомерное пространство.

# Определить размеры данных
input_dim_model = (1, 28, 28) # изображения размером 28 x 28 с 1 каналом цвета (серый)
input_dim = 28 * 28 # используется читателями для обработки входных данных как вектора
num_output_classes = 10
 

Формат данных Данные хранятся на нашем локальном компьютере в CNTK CTF
формат. Формат CTF — это простой текстовый формат, содержащий набор
образцы, каждый из которых содержит набор именованных полей и их
данные.Для наших данных MNIST каждый образец содержит 2 поля: метки и
объект, отформатированный как:

 | метки 0 0 0 1 0 0 0 0 0 0 | характеристики 0 255 0 123 ...
                                              (784 целых числа, каждое из которых представляет уровень серого пикселя)
 

В этом уроке мы собираемся использовать пиксели изображения, соответствующие
целочисленный поток с именем «функции». Мы определяем create_reader
функция для чтения данных обучения и тестирования с помощью CTF
десериализатор.
.

Этикетки имеют горячее кодирование
(метка, представляющая выходной класс 3, становится 0001000000
поскольку у нас есть 10 классов для 10 возможных цифр), где первая
индекс соответствует цифре 0 , а последний соответствует цифре
9 .

# Прочитать текст в формате CTF (как упоминалось выше) с помощью десериализатора CTF из файла
def create_reader (путь, is_training, input_dim, num_label_classes):

    ctf = C.io.CTFDeserializer (путь, C.io.StreamDefs (
          label = C.io.StreamDef (field = 'labels', shape = num_label_classes, is_sparse = False),
          features = C.io.StreamDef (field = 'features', shape = input_dim, is_sparse = False)))

    вернуть C.io.MinibatchSource (ctf,
        randomize = is_training, max_sweeps = C.io.INFINITELY_REPEAT, если is_training иначе 1)
 

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

data_found = False # Флаг, указывающий, найдены ли данные обучения / тестирования в локальном кеше
для data_dir в [os.path.join ("..", "Примеры", "Изображение", "Наборы данных", "MNIST"),
                 os.path.join ("данные", "MNIST")]:

    train_file = os.path.join (data_dir, "Поезд-28x28_cntk_text.txt")
    test_file = os.path.join (каталог_данных, "Test-28x28_cntk_text.txt")

    если os.path.isfile (train_file) и os.path.isfile (test_file):
        data_found = Верно
        перемена

если не data_found:
    Raise ValueError («Пожалуйста, сгенерируйте данные, заполнив CNTK 103 Часть A»)

print ("Каталог данных: {0}".формат (каталог_данных))
 

Каталог данных: .. \ Примеры \ Image \ DataSets \ MNIST
 

Создание модели CNN

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

В этом разделе мы познакомим вас с основами операций свертки. Мы
показать иллюстрации в контексте изображений RGB (3 канала),
хотя данные MNIST, которые мы используем в этом руководстве, имеют оттенки серого
изображение (одноканальный).

Слой свертки

Сверточный слой — это набор фильтров.Каждый фильтр определяется
матрица веса ( Вт, ) и смещения (\ (b \)).

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

Изображение (url = "https://www.cntk.ai/jup/cntk103d_conv2d_final.gif", ширина = 300)
 

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

% PDF-1.5
%
1 0 obj
> поток
application / pdf

Транзакции IEEE по компьютерному проектированию интегральных схем Системы199ПП10.1109 / TCAD.2017.27852571

конечный поток
endobj
2 0 obj
> / Метаданные 1 0 R / Страницы 6 0 R >>
endobj
3 0 obj
>
endobj
4 0 obj
> поток
xS (Т

.