Разработан новый алгоритм классификации без отрицательных данных в датасете

29 ноября 2018
алгоритм классификации без отрицательных данных в датасете

Разработан новый алгоритм классификации без отрицательных данных в датасете

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

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

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

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

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

Исследователи протестировали работу метода на датасетах MNIST и The CIFAR-10. Результаты Pconf сопоставимы с другими современными методами классификации, использующими отрицательные данные для обучения. Подход поможет улучшить работу моделей классификации и минимизировать ошибки в случаях, когда невозможно получить отрицательные данные для подготовки.

Обучение нейронных сетей: проклятие размерности

3 октября 2018
обучение нейронной сети - проклятие размерности

Обучение нейронных сетей: проклятие размерности

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

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

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

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

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

Обучение глубокой нейронной сети

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

обучение нейронных сетей глубокая сеть DNN
Глубокая нейронная сеть (DNN)

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

Давайте начнем с самого наивного метода: случайный перебор. Установим веса случайным образом и подсчитаем результаты. Повторить много раз, сохранить все результаты, выбрать наиболее точные. На первый взгляд это кажется не таким уж плохим подходом. И действительно, компьютеры уже очень мощные, может быть мы можем получить решение брутфорсом? Для небольших нейронок (~30 нейронов) это и вправду работает. Но для задач из реального мира, где нейронов под 12,000 , случайный перебор теряет свою актуальность. Попробуйте найти иголку в 12000-мерном стоге сена методом простого перебора.

N-мерное пространство — одинокое место

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

Чтобы проиллюстрировать это, давайте рассмотрим несколько простых однослойных нейросетей: с тремя и с двумя нейронами.

Пространства 10х10(слева) и 10х10х10(справа) точек
Пространства 10х10(слева) и 10х10х10(справа) точек

В первом случае нужно найти всего два веса. Как много попыток нужно сделать, чтобы угадать идеальный набор? Один из подходов — представить двумерное пространство возможных весов и до изнеможения искать нужную комбинацию при некотором разбиении. Возможно, мы можем разбить каждую ось на 10 частей. Тогда попыток всего будет 10^2 = 100. Не так уж и плохо, но давайте сделаем разбиение более мелким, чтобы подобрать веса корректнее, например на 100 частей. Тогда уже комбинаций может быть 10,000. Достаточно маленькое число, компьютер сможет обработать его меньше, чем за секунду.

Так, а что же со второй сетью? Теперь нам нужно подобрать уже 3 веса и, следовательно, работать в трехмерном пространстве. Проделаем такие же операции 10*10*10 = 1000 вариантов и 100*100*100 = 1,000,000 вариантов соответственно при разных вариантах разбиения. Миллион вариантов — не так уж и страшно, но рост пугающий. И что же произойдет, когда мы перейдем к реальным сеткам?

Проклятие размерности

Что же будет, когад мы попробуем классифицировать цифры из датасета MNIST? Cеть будет содержать 784 входных нейронов, 15 нейронов в 1 скрытом слое и 10 выходных нейронов. Итого 784*15 + 15*10 = 11910 весов. Получается, чтобы угадать, нужно сделать 10^11910 попыток… Это 1 почти с 12,000 нулями. Для сравнения атомов в видимой Вселенной всего 10^80. Никакой суперкомпьютер не справится с таким перебором. И эта простая сетка даже близко не сравнится с самыми современными, где десятки и тысячи миллионов весов!

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

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

Деформирующие автоэнкодеры

2 октября 2018
DAE-deforming-autoencoders-e1537543914660

Деформирующие автоэнкодеры

В настоящее время генеративные модели привлекают к себе огромное внимание в мировой среде машинного обучения. Этот тип моделей имеет практическое применение в различных сферах. Одни из самых эффективных и широко…

В настоящее время генеративные модели привлекают к себе огромное внимание в мировой среде машинного обучения. Этот тип моделей имеет практическое применение в различных сферах. Одни из самых эффективных и широко используемых типов данной модели – это Вариационные Автоэнкодеры (Variational Autoencoders – VAE) и Генеративные состязательные нейросети (Generative Adversarial Networks – GAN).

Деформирующие автоэнкодеры

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

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

Ранние работы

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

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

Деформирующий автоэнкодер

Не так давно, Zhixin Shu и коллеги представили новые Деформирующие Автоэнкодеры, или коротко – DAEs (Deforming autoencoders). DAE представляет собой генеративную модель анализа изображений, которая выделяет признаки без дополнительных подсказок. В своей работе, исследователи предлагают способ выделения признаков, предполагая создавать экземпляры объектов посредством деформации «шаблонного» объекта. Это означает, что вариативность объекта может быть разделена на уровни, связанные с пространственными трансформациями формы объекта. Несмотря на простоту идеи, это решение, основанное на глубоких автоэнкодерах и самостоятельном обучении нейросети, доказало свою эффективность в ряде задач.

Описание метода

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

Архитектура предлагаемого деформирующего автоэнкодера
Рис 1. Архитектура предлагаемого деформирующего автоэнкодера

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

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

Архитектура предлагаемого Деформирующего Автоэнкодера с заданной классификацией
Рис.2. Архитектура предлагаемого Деформирующего Автоэнкодера с заданной классификацией

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

Структура Встроенного Деформирующего Автоэнкодера
Рис.3. Структура встроенного Деформирующего Автоэнкодера

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

Результаты

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

Результаты восстановления MNIST изображений Деформирующим Автоэнкодером
Рис.4. Результаты восстановления MNIST изображений Деформирующим Автоэнкодером

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

  1. Наложении изображений без учителя.
  2. Изучении семантически важных множеств для формы и внешнего вида объектов.
  3. Внутренняя декомпозиция без учителя.
  4. Детектирование локализации без учителя.
Результаты восстановления MNIST изображений Деформирующим Автоэнкодером с заданной классификацией.
Рис.5. Результаты восстановления MNIST изображений Деформирующим Автоэнкодером с заданной классификацией.
Наложение изображений ладоней без учителя
Рис.6. Наложение изображений ладоней без учителя. (а) – Входные изображения. (b) – восстановленные изображения. (c) – изображения текстур, деформированные с использованием среднего декодированной деформации. (d) – среднее входное изображение. (e) – средняя текстура.

defermation interpolation

Smooth interpolation of the latent space representation
Рис.7. Гладкая интерполяция представлений скрытого пространства

Видео, показывающее возможности Деформирующих Автоэнкодеров:

Сравнение с другими современными методами

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

Сравнение результатов работы Деформирующего Автоэнкодера и метода Thewlis и коллег
Рис.8. Сравнение результатов работы Деформирующего Автоэнкодера и метода Thewlis и коллег

Заключение

Lighting interpolation with Intrinsic-DAE
Рис.9. Интерполяция освещения с помощью встроенного DAE

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

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

Автоэнкодеры: типы архитектур и применение

11 сентября 2018
автоэнкодер

Автоэнкодеры: типы архитектур и применение

Autoencoder (автокодер, автоэнкодер, AE) — нейронная сеть, которая копирует входные данные на выход. По архитектуре похож на персептрон. Автоэнкодеры сжимают входные данные для представления их в latent-space (скрытое пространство), а затем…

Autoencoder (автокодер, автоэнкодер, AE) — нейронная сеть, которая копирует входные данные на выход. По архитектуре похож на персептрон. Автоэнкодеры сжимают входные данные для представления их в latent-space (скрытое пространство), а затем восстанавливают из этого представления output (выходные данные). Цель — получить на выходном слое отклик, наиболее близкий к входному.

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

Автокодер состоит из двух частей:

  1. Энкодер: отвечает за сжатие входа в latent-space. Представлен функцией кодирования h = f (x);
  2. Декодер: предназначеа для восстановления ввода из latent-space. Представлен функцией декодирования h = f (x).
Архитектура автокодеров
Архитектура автоэнкодера

Таким образом, автокодер описывают функцией g (f (x)) = r, где r совпадает с изначальным x на входе.

Зачем копировать вход на выход

Если бы единственной задачей автоэнкодеров было копирование входных данных на выход, они были бы бесполезны. Исследователи рассчитывают на то, что скрытое представление h будет обладать полезными свойствами.

Этого добиваются созданием ограничений для задачи копирования. Один из способов получить полезные результаты от автоэнкодера — ограничить h размерами меньшими , чем x. D этом случае автокодирование называется неполным.

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

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

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

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


Где применяются автоэнкодеры

Два основных практических применения автоэнкодеров для визуализации данных:

  • сглаживание шума;
  • снижение размерности.

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

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

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

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


Типы автоэнкодеров

В этой статье будут описаны четыре следующих типа автокодеров:

  1. Автокодер Vanilla;
  2. Многослойный автокодер;
  3. Сверточный автокодер;
  4. Регуляризованный.

Чтобы проиллюстрировать типы автокодеров, с помощью структуры Keras и датасета MNIST создан пример каждого из них. Код для каждого типа автокодера доступен на GitHub.

Автоэнкодер vanilla

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

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

Многослойный автоэнкодер

Если одного скрытого слоя недостаточно, автокодер расширяют до большего их количества.

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

Сверточные автоэнкодеры

Можно ли использовать автокодеры со свертками вместо использования с полносвязными слоями?

Ответ — да. И принцип тот же, но только с использованием 3D-векторов вместо 1D-векторов.

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

Регуляризованный автоэнкодер

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

Sparse

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

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

В наш скрытый слой мы добавили регулятор активности l1, который будет применять штраф к функции потерь во время фазы оптимизации. Как результат, представление теперь более уникальное по сравнению с автокодером vanilla.

Denoising

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


Интересные статьи по теме:

Генеративно-состязательная нейросеть (GAN). Руководство для новичков

29 августа 2018
генеративно-состязательная нейросеть GAN

Генеративно-состязательная нейросеть (GAN). Руководство для новичков

Генеративно-состязательная нейросеть (Generative adversarial network, GAN) — архитектура, состоящая из генератора и дискриминатора, настроенных на работу друг против друга. Отсюда GAN и получила название генеративно-созтязательная. В случае работы с изображениями, во…

Генеративно-состязательная нейросеть (Generative adversarial network, GAN) — архитектура, состоящая из генератора и дискриминатора, настроенных на работу друг против друга. Отсюда GAN и получила название генеративно-созтязательная. В случае работы с изображениями, во всем остальном — это сверточная нейронная сеть.

GAN были впервые представлены в работе 2014-го года Ian’a Goodfellow’a и других исследователей университета Монреаля, включая Yoshua Bengio. Директор Facebook по исследованиям искусственного интеллекта Yann LeCun назвал состязательную тренировку сетей “самой интересной идеей в машинном обучении за последние 10 лет”.

Вряд ли вы подумаете, что программиста можно назвать артистом, но, на самом деле, программирование это очень творческая профессия. Творчество, основанное на логике — John Romero

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

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

Рассмотрим, как работают алгоритмы дикриминатора и генератора.

Дискриминатор

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

К примеру, пробегая все слова в письме дискриминационный алгоритм может предсказать, является сообщение спамом или не спамом. Спам — это категория, а пакет слов, собранный из электронной почты — образы, которые составляют входные данные. Математически категории обозначают y, а образы обозначают x. Запись p(y|x) используется для обозначения «вероятности y при заданном x», которая обозначает «вероятность того, что электронное письмо является спамом при имеющемся наборе слов».

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

Генератор

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

В то время как дискриминационные алгоритмы волнует взаимосвязь между y и x, генеративные алгоритмы волнует “откуда берутся x”. Они позволяют находить p(x|y), вероятность x при данном y или вероятность образов при данном классе (генеративные алгоритмы также могут использоваться в качестве классификаторов. Они могут делать больше, чем классифицировать входные данные.)

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

  • Дискриминационные модели изучают границу между классами;
  • Генеративные модели моделируют распределение отдельных классов.

Как работают GAN

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

Предположим, мы пытаемся сделать что-то более банальное, чем повторить портрет Моны Лизы. Мы сгенерируем рукописные цифры, подобные тем, что имеются в наборе данных MNIST. Цель дискриминатора — распознать подлинные экземпляры из набора.

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

Шаги, которые проходит GAN:

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

Таким образом, у есть двойной цикл обратной связи:

  • Дискриминатор находится в цикле с достоверными изображениями.
  • Генератор находится в цикле вместе с дискриминатором

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

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

Обе сети пытаются оптимизировать целевую функцию или функцию потерь в игре zero-zum. Это, по сути, модель актера-критика (actor-critic). Когда дискриминатор меняет свое поведение, то и генератор меняет, и наоборот.

Автокодеры и VAE

Полезно сравнить генеративные состязательные сети с другими нейронными сетями, такими как автокодеры (автоэнкодеры) и вариационные автокодеры.

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

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

Вы можете разделить генеративные алгоритмы на три типа, которые имея:

  • категорию, предсказывают связанные функции (Naive Bayes);
  • скрытое представление, предсказывают связанные функции (VAE, GAN);
  • некоторые образы, предсказывают остальное (inpainting, imputation);

Советы по обучению GAN

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

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

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

GAN требуют много времени на тренировку. На одном GPU тренировка может занимать часы, а на одном CPU — более одного дня. Несмотря на сложность настройки и, следовательно, использования, GAN стимулировали создание многих интересных исследований и статей, например:

Просто покажите код

Вот пример GAN, запрограммированной в библиотеке Keras, из которой модели могут в дальнейшем быть импортированы в Deeplearning4j.

class GAN():
    def __init__(self):
        self.img_rows = 28 
        self.img_cols = 28
        self.channels = 1
        self.img_shape = (self.img_rows, self.img_cols, self.channels)

        optimizer = Adam(0.0002, 0.5)

        # Build and compile the discriminator
        self.discriminator = self.build_discriminator()
        self.discriminator.compile(loss='binary_crossentropy', 
            optimizer=optimizer,
            metrics=['accuracy'])

        # Build and compile the generator
        self.generator = self.build_generator()
        self.generator.compile(loss='binary_crossentropy', optimizer=optimizer)

        # The generator takes noise as input and generated imgs
        z = Input(shape=(100,))
        img = self.generator(z)

        # For the combined model we will only train the generator
        self.discriminator.trainable = False

        # The valid takes generated images as input and determines validity
        valid = self.discriminator(img)

        # The combined model  (stacked generator and discriminator) takes
        # noise as input => generates images => determines validity 
        self.combined = Model(z, valid)
        self.combined.compile(loss='binary_crossentropy', optimizer=optimizer)

    def build_generator(self):

        noise_shape = (100,)
        
        model = Sequential()

        model.add(Dense(256, input_shape=noise_shape))
        model.add(LeakyReLU(alpha=0.2))
        model.add(BatchNormalization(momentum=0.8))
        model.add(Dense(512))
        model.add(LeakyReLU(alpha=0.2))
        model.add(BatchNormalization(momentum=0.8))
        model.add(Dense(1024))
        model.add(LeakyReLU(alpha=0.2))
        model.add(BatchNormalization(momentum=0.8))
        model.add(Dense(np.prod(self.img_shape), activation='tanh'))
        model.add(Reshape(self.img_shape))

        model.summary()

        noise = Input(shape=noise_shape)
        img = model(noise)

        return Model(noise, img)

    def build_discriminator(self):

        img_shape = (self.img_rows, self.img_cols, self.channels)
        
        model = Sequential()

        model.add(Flatten(input_shape=img_shape))
        model.add(Dense(512))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dense(256))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dense(1, activation='sigmoid'))
        model.summary()

        img = Input(shape=img_shape)
        validity = model(img)

        return Model(img, validity)

    def train(self, epochs, batch_size=128, save_interval=50):

        # Load the dataset
        (X_train, _), (_, _) = mnist.load_data()

        # Rescale -1 to 1
        X_train = (X_train.astype(np.float32) - 127.5) / 127.5
        X_train = np.expand_dims(X_train, axis=3)

        half_batch = int(batch_size / 2)

        for epoch in range(epochs):

            # ---------------------
            #  Train Discriminator
            # ---------------------

            # Select a random half batch of images
            idx = np.random.randint(0, X_train.shape[0], half_batch)
            imgs = X_train[idx]

            noise = np.random.normal(0, 1, (half_batch, 100))

            # Generate a half batch of new images
            gen_imgs = self.generator.predict(noise)

            # Train the discriminator
            d_loss_real = self.discriminator.train_on_batch(imgs, np.ones((half_batch, 1)))
            d_loss_fake = self.discriminator.train_on_batch(gen_imgs, np.zeros((half_batch, 1)))
            d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)


            # ---------------------
            #  Train Generator
            # ---------------------

            noise = np.random.normal(0, 1, (batch_size, 100))

            # The generator wants the discriminator to label the generated samples
            # as valid (ones)
            valid_y = np.array([1] * batch_size)

            # Train the generator
            g_loss = self.combined.train_on_batch(noise, valid_y)

            # Plot the progress
            print ("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss))

            # If at save interval => save generated image samples
            if epoch % save_interval == 0:
                self.save_imgs(epoch)

    def save_imgs(self, epoch):
        r, c = 5, 5
        noise = np.random.normal(0, 1, (r * c, 100))
        gen_imgs = self.generator.predict(noise)

        # Rescale images 0 - 1
        gen_imgs = 0.5 * gen_imgs + 0.5

        fig, axs = plt.subplots(r, c)
        cnt = 0
        for i in range(r):
            for j in range(c):
                axs[i,j].imshow(gen_imgs[cnt, :,:,0], cmap='gray')
                axs[i,j].axis('off')
                cnt += 1
        fig.savefig("gan/images/mnist_%d.png" % epoch)
        plt.close()


if __name__ == '__main__':
    gan = GAN()
    gan.train(epochs=30000, batch_size=32, save_interval=200)

Источник: https://skymind.ai/wiki/generative-adversarial-network-gan

Может быть интересно:

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

17 июля 2018
сверточная нейронная сеть пример

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

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

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

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

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

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

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

сверточная нейронная сеть
Операция свертки

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

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

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

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

padding нейронной сети
Padding

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

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

striding сверточная нейронная сеть
Свертка с шагом 2

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

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

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

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

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

rgb каналы
В большинстве случаев мы имеем дело с изображениями 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-й свертки
После 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 в окончательной свертке), каждый из которых ищет чрезвычайно специфические признаки высокого уровня. И далее применяется окончательный слой — pooling layer, который сворачивает каждую сетку 7*7 в один пиксель, каждый канал является детектором признаков с receptive field, эквивалентным всему изображению.

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

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

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

Проблема adversarial attacks

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

Для человека очевидно, что на обоих картинках изображена панда. Для компьютера - не совсем.
Для человека очевидно, что на обоих картинках изображена панда. Для компьютера — не совсем

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

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

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