Классические CNN архитектуры 🏛️

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

Пройдём четыре точки на этой линии. LeNet-5 (1998, Ян Лекун) — крошечная по нынешним меркам сеть, которая тем не менее первой доказала на практике, что свёрточная архитектура работает не только в лаборатории, а в реальном коммерческом продукте — распознавании рукописных цифр на банковских чеках. AlexNet (2012, Алекс Крижевский, Илья Суцкевер, Джеффри Хинтон) — сеть, победа которой на соревновании ImageNet с разгромным отрывом от всех предыдущих подходов принято считать точкой отсчёта современной эры глубокого обучения. VGGNet (2014, Оксфорд) — архитектура, которая свела дизайн CNN к одному простому принципу: бери маленькие фильтры 3×3, но складывай их много слоёв подряд, и глубина сама сделает всю работу. И GoogLeNet, он же Inception v1 (2014, Google) — сеть, показавшая, что можно быть одновременно глубже конкурентов и экономнее по параметрам, если применять несколько размеров фильтров параллельно внутри одного модуля.

Это не музейная экскурсия. Каждая идея из этих четырёх архитектур — ReLU и dropout из AlexNet, маленькие фильтры 3×3 и глубокие однородные блоки из VGGNet, параллельные ветви и bottleneck-свёртки 1×1 из GoogLeNet — в том или ином виде живёт в архитектурах, которые ты будешь использовать на практике: в ResNet (следующий урок 337, где разберём skip-connections — приём, который наконец сделал возможным обучение сетей глубиной в сотни слоёв), в EfficientNet, в современных детекторах объектов. Сегодня в каждом блоке будет: интуиция идеи, точная архитектура списком слоёв, несколько разобранных числовых примеров — сколько параметров в конкретном слое, какой получится размер карты признаков, — и объяснение, почему именно этот шаг оказался важен для всего, что пришло дальше.

История

Свёрточные сети — не изобретение 2012 года. Ещё в 1980 году японский исследователь Кунихико Фукусима предложил неокогнитрон — архитектуру, вдохновлённую строением зрительной коры кошек, где одни нейроны реагируют на вертикальные линии, другие — на горизонтальные, третьи — на углы, и эта иерархия признаков собирается снизу вверх. Идея была правильной, но неокогнитрон обучался без backpropagation (обратного распространения ошибки, урок 330) и по современным меркам работал крайне ограниченно. Настоящий практический прорыв случился на десятилетие позже, когда Ян Лекун, работая в AT&T Bell Labs, применил к похожей архитектуре именно алгоритм backpropagation — и получил сеть, которую действительно можно было обучить на реальных данных. Итогом этой работы стала LeNet-5, опубликованная в 1998 году в статье «Gradient-Based Learning Applied to Document Recognition» и внедрённая в коммерческую систему распознавания рукописных цифр на банковских чеках — CNN здесь не осталась лабораторной демонстрацией, а реально обрабатывала миллионы чеков в банковской системе США.

После этого успеха наступила вторая «зима» интереса к нейросетям, продлившаяся почти полтора десятилетия. Причина была не в ошибочности идеи, а в двух вполне материальных ограничениях: не хватало ни размеченных данных достаточного объёма, ни вычислительных мощностей, чтобы масштабировать архитектуру LeNet-подобного типа на действительно сложные и разнообразные изображения. На практике доминировали методы, опирающиеся на вручную сконструированные признаки (SIFT, HOG) в связке с классическими алгоритмами вроде SVM (урок 319) — они требовали куда меньше данных и вычислений, а качество на доступных на тот момент датасетах было сопоставимым или лучшим.

Перелом подготовили две вещи, случившиеся почти одновременно. Первая — в 2009 году группа под руководством Фей-Фей Ли в Стэнфорде опубликовала датасет ImageNet: свыше 14 миллионов размеченных изображений, распределённых по более чем 20 тысячам категорий, — на тот момент беспрецедентный по масштабу набор данных. С 2010 года на его основе проводится ежегодное соревнование ILSVRC (ImageNet Large Scale Visual Recognition Challenge) на подмножестве из 1000 классов и 1,2 миллиона тренировочных изображений. Вторая — стремительное удешевление и рост производительности GPU, изначально созданных для видеоигр, но идеально подходящих для параллельных матричных вычислений, лежащих в основе нейросетей. В 2012 году эти два фактора сошлись в одной работе: Алекс Крижевский, Илья Суцкевер и Джеффри Хинтон из Университета Торонто представили на ILSVRC сеть AlexNet, обученную на двух GPU NVIDIA GTX 580, и выиграли соревнование с результатом, который не укладывался в ожидания даже оптимистов — подробности этого момента разберём отдельно чуть ниже, он того стоит.

Победа AlexNet немедленно запустила гонку архитектур. Уже в 2014 году на ILSVRC одновременно и независимо появились сразу две значимые работы: команда Оксфорда (Карен Симонян и Эндрю Зиссерман) представила VGGNet, доказавшую, что если наращивать глубину сети, используя только маленькие фильтры 3×3, качество растёт предсказуемо и устойчиво; а команда Google (Кристиан Сегеди и соавторы) представила GoogLeNet — архитектуру на основе inception-модулей, которая заняла первое место в классификации ILSVRC 2014 (VGGNet стала второй, хотя выиграла в отдельной номинации локализации объектов), сумев при этом быть глубже AlexNet почти втрое, а параметров использовать почти в 12 раз меньше. Общий тренд этих лет очевиден: архитектуры становятся всё глубже, потому что глубина напрямую связана с качеством, но одновременно исследователи ищут способы делать обучение таких глубоких сетей практически возможным и вычислительно доступным. Уже в следующем, 2015 году, эта гонка за глубину упрётся в новую фундаментальную проблему — деградацию качества при слишком большом числе слоёв, — и её решением станут skip-connections в архитектуре ResNet, которую мы подробно разберём в уроке 337.

LeNet-5: рукописные цифры и первая практическая CNN

Интуиция

LeNet-5 спроектирована под очень конкретную прикладную задачу: распознать, какая цифра от 0 до 9 написана от руки на маленьком чёрно-белом изображении. Ключевая идея Лекуна против классического подхода «разверни изображение в один длинный вектор пикселей и подай на полносвязную сеть» — использовать локальные обучаемые фильтры, которые ищут паттерны (штрихи, изгибы, пересечения линий) независимо от того, в каком именно месте изображения эти паттерны встретились. После каждого свёрточного слоя пространственный размер карты признаков сжимается слоем subsampling (это ранний вариант pooling, урок 335), а число каналов, наоборот, растёт — сеть постепенно выменивает точное пространственное разрешение на богатство извлечённых признаков, пока в конце не остаётся компактное представление, достаточное для десятиклассовой классификации.

Архитектура

LeNet-5 (Лекун и др., 1998).

• Input: изображение $32\times32\times1$ (исходные цифры MNIST-подобного датасета — $28\times28$, дополненные паддингом до $32\times32$)
• C1: свёртка $5\times5$, $6$ фильтров, stride $1$, без паддинга → $28\times28\times6$, активация $\tanh$
• S2: average pooling $2\times2$, stride $2$ → $14\times14\times6$
• C3: свёртка $5\times5$, $16$ фильтров (в оригинале — частичное соединение карт признаков, см. пример 3) → $10\times10\times16$
• S4: average pooling $2\times2$, stride $2$ → $5\times5\times16$
• C5: свёртка $5\times5$, $120$ фильтров (фактически полносвязный слой, поскольку вход в точности $5\times5$) → $1\times1\times120$
• F6: полносвязный слой, $84$ нейрона
• Output: $10$ нейронов (в оригинале — слой радиальных базисных функций, RBF; на практике сегодня заменяется обычным softmax)

Разбор примеров

Пример 1 (размер карты признаков после C1). Формула размера выхода свёртки без паддинга: $\text{output} = \dfrac{\text{input} - \text{kernel}}{\text{stride}} + 1$. Для C1: input $=32$, kernel $=5$, stride $=1$: $\dfrac{32-5}{1}+1 = 27+1 = 28$. Значит после C1 карта признаков имеет размер $28\times28$, и таких карт шесть — по одной на каждый из шести фильтров слоя.

Пример 2 (число параметров слоя C1). Каждый из шести фильтров C1 имеет размер $5\times5\times1$ (один входной канал — изображение чёрно-белое) плюс один параметр смещения (bias): $5\times5\times1+1=26$ параметров на фильтр. Для шести фильтров: $26\times6=156$ параметров. Обрати внимание — это число не зависит от размера входного изображения: один и тот же фильтр $5\times5$ «проезжает» по всей карте $32\times32$, используя одни и те же 26 чисел в каждой позиции, — в этом и состоит экономия параметров свёртки по сравнению с полносвязным слоем, где для входа в $1024$ пикселя потребовались бы тысячи независимых весов на каждый выходной нейрон.

Пример 3 (общее число параметров сети и историческая деталь про C3). Если посчитать все слои при упрощающем предположении полной связности C3 (каждый из $16$ фильтров C3 подключён ко всем $6$ картам S2): C1 $=156$, S2 (по историческим правилам LeNet имеет обучаемый коэффициент и смещение на каждую карту: $2\times6=12$), C3 при полной связности $=(5\times5\times6+1)\times16=151\times16=2416$, S4 $=2\times16=32$, C5 $=(5\times5\times16+1)\times120=401\times120=48\,120$, F6 $=(120+1)\times84=121\times84=10\,164$, выходной слой $=(84+1)\times10=850$. Сумма: $156+12+2416+32+48\,120+10\,164+850=61\,750$ — отсюда и общепринятая формулировка «LeNet-5 содержит около 60 тысяч параметров». Историческая деталь: в оригинальной статье 1998 года C3 на самом деле не был полносвязным по картам — каждый из 16 фильтров подключался лишь к некоторому подмножеству из 6 карт S2 (обычно к 3–4 из них), что снижало реальное число параметров C3 до 1516 вместо 2416. Причин было две: экономия вычислений, критичная при отсутствии GPU в 1998 году, и намеренное нарушение симметрии между фильтрами — разные фильтры, видящие разные подмножества входных карт, с большей вероятностью выучивают разнообразные, а не дублирующие друг друга признаки.

Почему это важно

LeNet-5 — не просто первая по хронологии архитектура в этом уроке, а буквально шаблон, по которому собраны все последующие CNN: чередование свёртки и pooling, постепенный рост числа каналов при одновременном сжатии пространственного размера, и полносвязный классификатор в самом конце. Масштаб LeNet-5 — около 60 тысяч параметров, семь слоёв с весами — сегодня выглядит игрушечным, но это не недостаток архитектуры, а прямое следствие вычислительных ограничений 1998 года: не было GPU, обучение шло на CPU, а размеченные датасеты исчислялись тысячами, а не миллионами примеров. Как ты увидишь в следующем разделе, стоило появиться доступным GPU и датасету масштаба ImageNet — и тот же самый принцип «свёртка + pooling + полносвязный классификатор» масштабировался на порядки, дав качественный скачок результата.

AlexNet и революция ImageNet 2012

Интуиция

AlexNet по своей структуре — прямой потомок LeNet: то же чередование свёрток и pooling, тот же полносвязный классификатор в конце. Но масштаб и несколько точечных инженерных решений превратили эту знакомую схему в архитектуру, изменившую всю область ИИ. Три ключевых нововведения: активация ReLU $\max(0,z)$ вместо сигмоиды или гиперболического тангенса (урок 328 уже показал тебе, почему сигмоида страдает от затухающего градиента на краях — ReLU сохраняет полноценный градиент для положительных входов, что критично при обучении по-настоящему глубокой сети); dropout — техника случайного «выключения» части нейронов на каждом шаге обучения, которая борется с переобучением огромной сети (60 миллионов параметров) на датасете, который, несмотря на масштаб в 1,2 миллиона изображений, всё равно относительно мал по сравнению с числом весов сети; и обучение на GPU, которое впервые сделало возможным пройти через такой объём вычислений за приемлемое время — около пяти-шести дней на паре GPU вместо месяцев на CPU.

Архитектура

AlexNet (Крижевский, Суцкевер, Хинтон, 2012).

• Input: $227\times227\times3$
• Conv1: $11\times11$, $96$ фильтров, stride $4$, без паддинга → $55\times55\times96$, ReLU
• MaxPool1: $3\times3$, stride $2$ → $27\times27\times96$
• Conv2: $5\times5$, $256$ фильтров, паддинг $2$ → $27\times27\times256$, ReLU
• MaxPool2: $3\times3$, stride $2$ → $13\times13\times256$
• Conv3: $3\times3$, $384$ фильтра, паддинг $1$ → $13\times13\times384$, ReLU
• Conv4: $3\times3$, $384$ фильтра, паддинг $1$ → $13\times13\times384$, ReLU
• Conv5: $3\times3$, $256$ фильтров, паддинг $1$ → $13\times13\times256$, ReLU
• MaxPool3: $3\times3$, stride $2$ → $6\times6\times256$
• FC6: $4096$ нейронов, ReLU, dropout $0{,}5$
• FC7: $4096$ нейронов, ReLU, dropout $0{,}5$
• FC8: $1000$ нейронов, softmax

Разбор примеров

Пример 1 (размер и параметры Conv1 — и почему в статье указан «неправильный» размер входа). По формуле $\dfrac{\text{input}-\text{kernel}}{\text{stride}}+1$ для входа $227$, фильтра $11$, stride $4$: $\dfrac{227-11}{4}+1=\dfrac{216}{4}+1=54+1=55$ — отсюда карта признаков $55\times55\times96$. Любопытная деталь: в самой статье 2012 года заявлен размер входа $224\times224\times3$, но при таком входе формула даёт нецелое число $\dfrac{224-11}{4}+1=54{,}25$, что физически невозможно — общепризнанная опечатка оригинальной статьи, и настоящий вход, дающий целые $55\times55$, равен $227\times227\times3$. Параметров в Conv1: каждый из $96$ фильтров имеет размер $11\times11\times3$ (три канала RGB) плюс bias: $11\times11\times3+1=364$; всего $364\times96=34\,944$ параметра.

Пример 2 (параметры FC6 — где живёт большая часть весов AlexNet). После MaxPool3 карта признаков имеет размер $6\times6\times256$, то есть при разворачивании в вектор — $9216$ чисел. FC6 содержит $4096$ нейронов, каждый полносвязный со всеми $9216$ входами: $(9216+1)\times4096=9217\times4096=37\,752\,832$ параметра — только в этом одном слое почти 38 миллионов весов. Для сравнения, FC7 даёт $(4096+1)\times4096=16\,781\,312$, а FC8 — $(4096+1)\times1000=4\,097\,000$. Три полносвязных слоя в сумме дают около $58{,}6$ миллионов параметров из общих примерно $62$ миллионов во всей сети — то есть свёрточные слои, при всей их вычислительной «тяжести» (умножения выполняются в каждой пространственной позиции карты), содержат лишь малую долю весов AlexNet.

Пример 3 (момент ImageNet 2012 в цифрах). До AlexNet лучшие результаты ILSVRC достигались методами, не основанными на глубоком обучении, — вручную сконструированными признаками в связке с классификаторами вроде SVM. В 2011 году победитель показал top-5 error (ошибку, при которой правильный класс не попал даже в топ-5 предсказаний модели) на уровне $25{,}8\%$. В 2012 году AlexNet выдала top-5 error $15{,}3\%$, тогда как второе место (уже не на основе глубокого обучения) показало $26{,}2\%$ — почти в 1,7 раза хуже победителя. Относительное снижение ошибки AlexNet против второго места: $\dfrac{26{,}2-15{,}3}{26{,}2}\times100\%\approx41{,}6\%$ — почти на сорок два процента меньше ошибок, чем у лучшего из подходов «старой школы» в том же самом соревновании, в том же самом году.

Почему это важно

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

VGGNet и идея глубины через маленькие фильтры

Интуиция

К 2014 году AlexNet доказала, что глубокие CNN работают, но её архитектура — с фильтрами разных, довольно крупных размеров ($11\times11$, $5\times5$) на разных слоях — выглядела скорее как набор удачных инженерных решений, чем как системно обоснованный принцип. Команда Оксфорда задала простой вопрос: что если максимально упростить архитектуру, используя всюду только фильтры минимального осмысленного размера $3\times3$ (наименьший размер, способный уловить понятие «центр и его непосредственные соседи по вертикали, горизонтали и диагонали»), но зато сложить таких слоёв очень много подряд? Результат оказался неожиданно сильным: предельно однообразная, «скучная» с точки зрения дизайна архитектура стабильно обгоняла AlexNet и другие более замысловатые конфигурации — при условии, что сеть достаточно глубокая.

Архитектура

VGG-16 (Симонян, Зиссерман, 2014) — 16 слоёв с обучаемыми весами (13 свёрточных + 3 полносвязных).

• Блок 1: conv3-64, conv3-64, maxpool $2\times2$ → карта $112\times112$
• Блок 2: conv3-128, conv3-128, maxpool $2\times2$ → карта $56\times56$
• Блок 3: conv3-256, conv3-256, conv3-256, maxpool $2\times2$ → карта $28\times28$
• Блок 4: conv3-512, conv3-512, conv3-512, maxpool $2\times2$ → карта $14\times14$
• Блок 5: conv3-512, conv3-512, conv3-512, maxpool $2\times2$ → карта $7\times7$
• FC1: $4096$ нейронов, FC2: $4096$ нейронов, FC3: $1000$ нейронов, softmax

Каждая свёртка conv3-N — фильтр $3\times3$, $N$ выходных каналов, паддинг $1$ (сохраняет пространственный размер входа неизменным). Формула роста receptive field при последовательных слоях без пулинга: $\text{RF}_{new}=\text{RF}_{old}+(k-1)\cdot\text{jump}_{old}$, где $\text{jump}$ — эффективный шаг между соседними «пикселями» карты признаков относительно исходного изображения; при добавлении пулинга или свёртки со stride$=s$ обновляется $\text{jump}_{new}=\text{jump}_{old}\cdot s$.

Разбор примеров

Пример 1 (почему три слоя $3\times3$ заменяют один слой $7\times7$ — и выгоднее по параметрам). Три последовательных слоя $3\times3$ со stride $1$ дают receptive field $3+(3-1)+(3-1)=7$ — ровно такой же, как у одного слоя $7\times7$ напрямую. Но число параметров различается: для $C$ входных и $C$ выходных каналов один слой $7\times7$ даёт $7\times7\times C\times C=49C^2$ параметров, а три слоя $3\times3$ подряд — $3\times(3\times3\times C\times C)=27C^2$. Отношение $27/49\approx0{,}551$ означает экономию почти в $45\%$ параметров при одинаковом receptive field. Дополнительный, не менее важный бонус: вместо одной нелинейности ReLU после единственного слоя $7\times7$ ты получаешь три последовательные нелинейности — сеть в целом становится выразительнее, способна выучивать более сложные, не сводящиеся к одному линейному фильтру закономерности.

Пример 2 (числовой пример на реальном блоке VGG-16 — блок 5). Блок 5 состоит из трёх слоёв conv3-512 подряд (вход и выход каждого — $512$ каналов). Параметры одного такого слоя: $(3\times3\times512+1)\times512=4609\times512=2\,359\,808$; три слоя дают $3\times2\,359\,808=7\,079\,424$ параметров, при receptive field, равном $7\times7$ (по формуле из примера 1). Гипотетический альтернативный слой $7\times7$ с теми же $512\to512$ каналами дал бы $(7\times7\times512+1)\times512=25\,089\times512=12\,845\,568$ параметров — почти на $45\%$ больше, чем реальный блок VGG из трёх слоёв $3\times3$, при абсолютно одинаковом receptive field. Это не случайное совпадение с примером 1, а прямое числовое подтверждение общего принципа архитектуры VGGNet.

Пример 3 (где на самом деле живут параметры VGG-16 — и это не там, где вычисления). Просуммируем параметры всех 13 свёрточных слоёв VGG-16 по формуле $(3\times3\times C_{in}+1)\times C_{out}$ для каждого слоя — суммарно получается около $14{,}7$ миллионов. А параметры трёх полносвязных слоёв: FC1 после блока 5 принимает на вход развёрнутую карту $7\times7\times512=25\,088$ значений, значит $(25\,088+1)\times4096=25\,089\times4096=102\,764\,544$; FC2 даёт $(4096+1)\times4096=16\,781\,312$; FC3 даёт $(4096+1)\times1000=4\,097\,000$. Сумма полносвязных слоёв — около $123{,}6$ миллионов, что при общей сумме сети около $138$ миллионов параметров составляет $\dfrac{123{,}6}{138}\times100\%\approx89{,}4\%$. Иначе говоря, почти $90\%$ всех весов VGG-16 сосредоточено всего в трёх последних слоях, тогда как 13 свёрточных слоёв, выполняющих основную массу вычислений (умножения повторяются в каждой пространственной позиции карты признаков), содержат лишь чуть больше десятой доли всех параметров сети.

Почему это важно

VGGNet доказала, что глубина — это самостоятельный, управляемый «рычаг» повышения качества сети, а не побочный эффект удачного подбора гиперпараметров: если удерживать фильтры маленькими (и тем самым — контролировать рост параметров на каждый слой), можно систематически наращивать число слоёв и получать предсказуемый прирост точности. Стандарт «блок из нескольких conv3×3 подряд плюс pooling» стал настолько влиятельным, что в том или ином виде используется в подавляющем большинстве архитектур, появившихся после 2014 года, включая ResNet из следующего урока. Расплата за эту простоту — тот самый перекос параметров в полносвязные слои из примера 3: VGG-16 тяжела и медленна именно из-за FC-слоёв, и одним из направлений, по которым архитектуры развивались дальше (в частности, в GoogLeNet ниже), стал поиск способов избавиться от этого перекоса.

GoogLeNet / Inception v1: параллельные фильтры

Интуиция

VGGNet решала вопрос «какого размера фильтр использовать на каждом слое» однозначно — всегда $3\times3$. Команда Google в том же 2014 году предложила принципиально иной ответ: а зачем вообще выбирать один размер? Что если применить сразу несколько размеров фильтров ($1\times1$, $3\times3$, $5\times5$) параллельно внутри одного модуля, обработав одну и ту же входную карту признаков всеми ими одновременно, а затем склеить (конкатенировать по каналам) все получившиеся результаты в единый выходной тензор? Сеть в этом случае не обязана заранее «угадывать» оптимальный масштаб для конкретного паттерна — она сама во время обучения научится придавать больший вес той ветви, которая оказалась полезнее для конкретных данных. Подробный разбор inception-модуля, включая эволюцию до Inception v2/v3 и EfficientNet, — тема урока 338; здесь мы остановимся на самой идее и на одном критичном инженерном приёме, без которого параллельные свёртки были бы попросту неподъёмны по вычислениям.

Архитектура

Базовый inception-модуль (GoogLeNet, Сегеди и др., 2014).

• Ветвь 1: свёртка $1\times1$
• Ветвь 2: свёртка $1\times1$ (bottleneck, снижает число каналов) → свёртка $3\times3$
• Ветвь 3: свёртка $1\times1$ (bottleneck) → свёртка $5\times5$
• Ветвь 4: max pooling $3\times3$ → свёртка $1\times1$
• Все четыре ветви применяются параллельно к одному и тому же входу и конкатенируются по каналам в единый выход

Вся сеть GoogLeNet — $22$ слоя с весами, $9$ inception-модулей подряд, около $5$ миллионов параметров; вместо огромных полносвязных слоёв перед классификатором используется global average pooling (усреднение каждой карты признаков в одно число), что и объясняет, почему параметров у существенно более глубокой сети оказывается на порядок меньше, чем у AlexNet.

Разбор примера

Пример (зачем нужен bottleneck $1\times1$ — конкретный расчёт для ветви $5\times5$). Возьмём типичные для GoogLeNet числа: вход модуля — карта признаков с $192$ каналами, ветвь $5\times5$ должна выдать $32$ выходных канала. Без bottleneck, свёртка $5\times5$ напрямую с $192$ входных на $32$ выходных канала: $(5\times5\times192+1)\times32=4801\times32=153\,632$ параметра. С bottleneck — сначала свёртка $1\times1$, снижающая число каналов с $192$ до $16$: $(1\times1\times192+1)\times16=193\times16=3088$ параметров, а затем уже свёртка $5\times5$ от $16$ каналов к $32$: $(5\times5\times16+1)\times32=401\times32=12\,832$ параметра. Итого с bottleneck: $3088+12\,832=15\,920$ параметров против $153\,632$ без него — сокращение почти в $9{,}6$ раза при том же итоговом числе входных и выходных каналов ветви.

Почему это важно

Bottleneck-свёртка $1\times1$ — на первый взгляд странный приём (зачем нужна свёртка, которая ничего не «видит» пространственно, только пересчитывает число каналов в одной точке?), но именно она делает параллельное применение нескольких размеров фильтров вычислительно реалистичным: без неё дорогая свёртка $5\times5$ на входе с сотнями каналов взорвала бы и число параметров, и объём вычислений. В сочетании с global average pooling вместо тяжёлых полносвязных слоёв (вспомни, что почти 90% параметров VGG-16 сидело именно в FC-слоях) GoogLeNet показала: глубину и качество можно наращивать, одновременно радикально снижая число параметров, если правильно организовать архитектуру, а не просто добавлять слои один за другим.

Сравнение архитектур

Таблица делает общий тренд наглядным сразу по трём осям. По глубине — рост почти монотонный: от 7 слоёв LeNet-5 до 152 слоёв ResNet за 17 лет. По параметрам — тренд куда менее очевидный: VGG-16 при 16 слоях тяжелее, чем GoogLeNet при 22 слоях, в 27 раз, потому что архитектурные решения (маленькие фильтры конкатенации, bottleneck, global average pooling) определяют число весов сильнее, чем формальная глубина. А по точности — устойчивое, но всё более затратное по инженерным усилиям снижение ошибки: чтобы упасть с 15,3% (AlexNet) до 3,57% (ResNet-152), потребовалось не просто больше слоёв, а несколько принципиально новых архитектурных идей одна за другой. Ту идею, которая наконец позволила стабильно обучать сети глубиной в сотни слоёв, не столкнувшись с деградацией качества, — skip-connections — мы разберём в следующем уроке.

Практика: 30 заданий

Базовые задания (1–10)

Задание 1: Изображение $32\times32\times1$ проходит через свёртку C1 LeNet-5: фильтр $5\times5$, stride $1$, без паддинга. Найди размер выходной карты признаков.

Задание 2: Посчитай число обучаемых параметров слоя C1 LeNet-5 (шесть фильтров $5\times5$ на одном входном канале).

Задание 3: Карта признаков $28\times28\times6$ проходит через average pooling $2\times2$, stride $2$ (слой S2 LeNet-5). Найди размер выхода.

Задание 4: Два свёрточных слоя $3\times3$ подряд, stride $1$, без пулинга между ними. Найди итоговый receptive field.

Задание 5 (машинное обучение): Почему AlexNet использовала ReLU вместо сигмоиды или гиперболического тангенса в скрытых слоях?

Задание 6: Вход AlexNet $227\times227\times3$, свёртка Conv1: фильтр $11\times11$, stride $4$, без паддинга. Найди размер выхода.

Задание 7: Посчитай число параметров Conv1 AlexNet (96 фильтров $11\times11\times3$).

Задание 8: Найди receptive field одного свёрточного слоя с фильтром $3\times3$, stride $1$.

Задание 9: Три свёрточных слоя $3\times3$ подряд, stride $1$, без пулинга. Найди итоговый receptive field и сравни с одним слоем $7\times7$.

Задание 10 (машинное обучение): Что такое top-5 error и почему именно эта метрика стала стандартом для соревнования ImageNet?

Средние задания (11–20)

Задание 11: Слой VGG conv3-128 принимает вход с $64$ каналами. Посчитай число параметров.

Задание 12: Сравни число параметров одного слоя $5\times5$ и двух слоёв $3\times3$ подряд при одинаковом числе входных и выходных каналов $C$ (в единицах $C^2$).

Задание 13: VGG-16 применяет к входу $224\times224$ пять последовательных пулингов $2\times2$, stride $2$ (по одному в конце каждого блока). Найди пространственный размер финальной карты признаков.

Задание 14: Посчитай число параметров FC6 в AlexNet: вход — развёрнутая карта $6\times6\times256$, выход — $4096$ нейронов.

Задание 15 (машинное обучение): Зачем в GoogLeNet перед дорогими свёртками $3\times3$ и $5\times5$ ставят свёртку $1\times1$?

Задание 16: Сколько слоёв с обучаемыми весами в архитектуре VGG-16 и откуда взялось число в названии?

Задание 17 (машинное обучение): В VGG-16 полносвязные слои содержат около $123{,}6$ млн параметров из общих примерно $138$ млн. Какую долю это составляет и что это говорит о распределении параметров в сети?

Задание 18 (машинное обучение): GoogLeNet (22 слоя, ≈5 млн параметров) почти втрое глубже AlexNet (8 слоёв, ≈62 млн параметров), но при этом легче её более чем в 12 раз. Как это возможно?

Задание 19: Карта признаков $55\times55\times96$ (выход Conv1 AlexNet) проходит через MaxPool1: фильтр $3\times3$, stride $2$. Найди размер выхода.

Задание 20 (машинное обучение): В чём принципиальная разница между LeNet-5 (1998) и AlexNet (2012) с точки зрения масштаба и доступных вычислительных ресурсов?

Продвинутые задания (21–30)

Задание 21: Посчитай общее число параметров LeNet-5, если C1$=156$, S2$=12$, C3 (полная связность)$=2416$, S4$=32$, C5$=48\,120$, F6$=10\,164$, выходной слой$=850$.

Задание 22: Первый полносвязный слой VGG-16 принимает на вход развёрнутую карту $7\times7\times512$ и выдаёт $4096$ значений. Посчитай число параметров.

Задание 23 (машинное обучение): Прирост точности VGGNet при увеличении глубины с 11 до 19 слоёв убывающий, а не линейный (каждые дополнительные слои дают всё меньший прирост). Почему?

Задание 24: AlexNet показала top-5 error $15{,}3\%$ на ILSVRC 2012, второе место — $26{,}2\%$. Посчитай относительное снижение ошибки AlexNet по сравнению со вторым местом.

Задание 25 (машинное обучение): Ветвь $5\times5$ inception-модуля должна преобразовать $192$ входных канала в $32$ выходных. Сравни число параметров без bottleneck и с bottleneck через промежуточные $16$ каналов.

Задание 26: Цепочка слоёв: conv3 (stride 1) → conv3 (stride 1) → maxpool2 (stride 2) → conv3 (stride 1). Найди итоговый receptive field, используя формулу $\text{RF}_{new}=\text{RF}_{old}+(k-1)\cdot\text{jump}_{old}$, $\text{jump}_{new}=\text{jump}_{old}\cdot s$ (начальные значения $\text{RF}=1$, $\text{jump}=1$).

Задание 27 (машинное обучение): Почему GoogLeNet использует global average pooling вместо полносвязного слоя непосредственно перед финальным классификатором?

Задание 28: Сравни число операций умножения-накопления (FLOPs, пропорционально $H\times W\times C^2\times k^2$) для трёх слоёв $3\times3$ и одного слоя $7\times7$ при одинаковом числе каналов $C$ и одинаковом пространственном размере выхода $H\times W$ на каждом слое.

Задание 29 (машинное обучение): AlexNet исторически была разделена на две параллельные «колонны», обучавшиеся на двух отдельных GPU (из-за нехватки видеопамяти на одной карте). Почему этот вынужденный инженерный компромисс позже стал осознанным архитектурным приёмом в более поздних сетях?

Задание 30 (машинное обучение): Блок VGG-16 (блок 5) состоит из трёх слоёв conv3-512 подряд ($512\to512$ каналов на каждом). Посчитай суммарные параметры блока и сравни с гипотетическим одним слоем $7\times7$ с теми же $512\to512$ каналами и тем же receptive field.

Частые ошибки

• Считают LeNet-5 устаревшей и бесполезной для понимания современных сетей. На самом деле LeNet задала саму схему «свёртка + pooling + полносвязный классификатор», по которой построены все последующие CNN, включая AlexNet, VGGNet и даже современные детекторы объектов — меняется масштаб и отдельные детали, но не базовый принцип.

• Путают год выхода датасета ImageNet (2009) с годом прорывной победы AlexNet на его основе (2012). Это разные события: датасет существовал и соревнование ILSVRC проводилось с 2010 года без участия глубокого обучения на первых порах — прорыв случился именно в 2012 году, когда AlexNet впервые показала на этом уже существующем датасете разгромный результат.

• Считают, что чем больше параметров у архитектуры, тем она «лучше» или «современнее». Задание 18 и сравнение AlexNet/VGG-16/GoogLeNet в таблице прямо опровергают это: GoogLeNet при вдвое-втрое большей глубине использует на порядок меньше параметров, чем AlexNet и особенно VGG-16, и при этом показывает более высокую точность — число параметров и качество архитектуры далеко не тождественны.

• Игнорируют расхождение между заявленным в статье AlexNet входом $224\times224$ и фактически необходимым $227\times227$. Это известная опечатка оригинальной публикации (задание 6); при попытке воспроизвести архитектуру буквально по описанию 224×224 расчёт размера Conv1 даёт нецелое число, что должно сразу насторожить и привести к использованию реального входа $227\times227$.

• Считают, что три слоя $3\times3$ подряд полностью эквивалентны одному слою $7\times7$. Эквивалентен только receptive field (задание 9) — а вот число параметров, число нелинейностей и, как следствие, выразительная способность различаются существенно (задания 12, 28): три маленьких слоя дешевле и мощнее одного большого именно за счёт дополнительных нелинейностей между ними.

• Не различают роль свёрточных и полносвязных слоёв в общем числе параметров сети. Задания 17 и 22 показывают, что в VGG-16 почти 90% всех весов сосредоточено в трёх последних полносвязных слоях — при анализе размера модели или попытке её «облегчить» в первую очередь стоит смотреть именно на них, а не на свёрточную часть.

Главное запомнить

• LeNet-5 (Ян Лекун, 1998) — первая практически успешная CNN, внедрённая в реальный коммерческий продукт (распознавание рукописных цифр на банковских чеках), около 60 тысяч параметров, семь слоёв; заложила базовую схему «свёртка + pooling + полносвязный классификатор».

• После LeNet-5 CNN пережили почти пятнадцатилетнее затишье — не из-за ошибочности идеи, а из-за нехватки размеченных данных и вычислительных мощностей для масштабирования архитектуры.

• AlexNet (Крижевский, Суцкевер, Хинтон, 2012) выиграла ILSVRC с top-5 error $15{,}3\%$ против $26{,}2\%$ у второго места (относительное снижение ошибки ≈ $41{,}6\%$) — этот разрыв принято считать общепризнанной точкой отсчёта современной эры глубокого обучения.

• Три ключевых инженерных решения AlexNet: активация ReLU вместо сигмоиды (не насыщается на положительных значениях), dropout против переобучения гигантской сети, и обучение на GPU, впервые сделавшее возможным пройти такой объём вычислений за приемлемое время.

• VGGNet (Симонян, Зиссерман, 2014) показала, что глубина — самостоятельный рычаг повышения качества: используя всюду фильтры $3\times3$, можно наращивать число слоёв предсказуемо, при этом три слоя $3\times3$ дают тот же receptive field, что один слой $7\times7$, но требуют примерно на $45\%$ меньше параметров и вычислений (задания 9, 12, 28).

• В VGG-16 почти $90\%$ всех параметров сосредоточено в трёх полносвязных слоях, а не в 13 свёрточных, хотя именно свёрточные слои выполняют основную массу вычислений.

• GoogLeNet/Inception v1 (2014) параллельно применяет несколько размеров фильтров ($1\times1$, $3\times3$, $5\times5$) в одном модуле и конкатенирует результаты; bottleneck-свёртки $1\times1$ перед дорогими слоями и global average pooling вместо FC-слоёв позволили сделать сеть глубже AlexNet (22 слоя против 8) при почти в 12 раз меньшем числе параметров.

• Общий тренд эволюции 1998–2014: архитектуры становятся глубже, а качество на ImageNet растёт, но одновременно появляются техники (маленькие фильтры, bottleneck, global average pooling), которые не дают числу параметров расти пропорционально глубине.

• Формула receptive field для последовательных слоёв: $\text{RF}_{new}=\text{RF}_{old}+(k-1)\cdot\text{jump}_{old}$, $\text{jump}_{new}=\text{jump}_{old}\cdot s$ — позволяет точно рассчитать, какую область исходного изображения «видит» один нейрон на любой глубине сети.

• Дальнейший рост глубины (VGG-19 и глубже) упирается в проблему деградации качества, которую решают skip-connections в архитектуре ResNet — тема следующего урока 337.

Связь с темами курса

Этот урок напрямую опирается на урок 335, где были введены свёртка, pooling и полносвязный слой как отдельные строительные блоки — сегодня ты увидел, как из этих же самых блоков за 16 лет были собраны четыре архитектуры, определившие всю траекторию развития компьютерного зрения. Расчёты размеров карт признаков и числа параметров используют ровно те же формулы, что были даны в уроке 335, только применённые последовательно, слой за слоем, к реальным опубликованным архитектурам, а не к отдельным примерам. Обсуждение ReLU против сигмоиды напрямую продолжает урок 328, где разбирался затухающий градиент сигмоиды, — именно эта проблема, актуальная уже для многослойных персептронов, стала критичной при переходе к по-настоящему глубоким CNN вроде AlexNet.

Общий тренд эволюции архитектур, отмеченный в этом уроке — рост глубины при параллельном поиске техник, делающих такой рост практически возможным, — получит прямое продолжение в уроке 337, где будет показано, почему после определённой глубины простое добавление слоёв начинает не улучшать, а ухудшать качество сети (проблема деградации), и как skip-connections в архитектуре ResNet решают эту проблему, позволяя обучать сети глубиной в сотни слоёв. Идея параллельных ветвей внутри inception-модуля, затронутая сегодня лишь кратко, будет разобрана куда подробнее в уроке 338 вместе с её дальнейшей эволюцией в Inception v2/v3 и принципиально иным подходом к масштабированию сетей — EfficientNet.

Интересные факты

• Момент объявления результатов ILSVRC 2012 историки области ИИ нередко описывают как один из немногих по-настоящему «переломных» моментов во всей истории машинного обучения: разрыв в top-5 error между AlexNet ($15{,}3\%$) и вторым местом ($26{,}2\%$) был настолько велик, что организаторы и участники соревнования не сразу поверили результату — подобного скачка не случалось ни до, ни в течение нескольких последующих лет; уже на следующий год, в 2013-м, подавляющее большинство участников соревнования использовали архитектуры на основе глубокого обучения.

• LeNet-5 использовалась не в лабораторных демонстрациях, а в реальной коммерческой системе: по оценкам, на пике внедрения система на её основе обрабатывала значительную долю всех чеков, проходивших через банковскую систему США в конце 1990-х — редкий на тот момент случай, когда нейросетевая технология вышла далеко за пределы академических публикаций.

• В оригинальной статье AlexNet 2012 года заявлен размер входного изображения $224\times224\times3$, хотя при таком входе формула размера выхода Conv1 даёт нецелое число ($54{,}25$) — общепризнанная опечатка, которую заметили и обсуждали в сообществе годами; фактический вход, дающий целые $55\times55$, равен $227\times227\times3$ (задание 6).

• VGGNet при всей своей концептуальной простоте («всюду фильтры $3\times3$») остаётся одной из самых требовательных к памяти классических архитектур именно из-за трёх финальных полносвязных слоёв: почти $90\%$ её $138$ миллионов параметров сосредоточено именно там (задания 17, 22) — это один из ключевых факторов, подтолкнувших последующие архитектуры, включая GoogLeNet, к отказу от больших полносвязных слоёв в пользу global average pooling.

Лайфхаки

• Прежде чем воспроизводить архитектуру по описанию из старой статьи, всегда проверяй согласованность заявленных размеров входа и выхода формулой $\dfrac{\text{input}-\text{kernel}}{\text{stride}}+1$ — как показывает пример с AlexNet, даже в основополагающих публикациях встречаются опечатки, и нецелый результат сразу укажет на несостыковку.

• При сравнении двух архитектур по «сложности» не ограничивайся числом слоёв — сравнивай отдельно число параметров и число операций (FLOPs), поскольку глубина и число параметров, как показывает пример GoogLeNet против VGG-16, могут вести себя почти противоположным образом.

• Если нужно быстро прикинуть, где именно «тяжёлая» модель хранит основную массу параметров, в первую очередь смотри на последние полносвязные слои перед классификатором — в архитектурах, построенных по образцу AlexNet и VGGNet, они почти всегда доминируют по числу весов над всей свёрточной частью.

• Формулу receptive field $\text{RF}_{new}=\text{RF}_{old}+(k-1)\cdot\text{jump}_{old}$ полезно держать под рукой при проектировании собственной архитектуры: она быстро отвечает на вопрос «какую область исходного изображения реально “видит” нейрон на этой глубине», что критично для задач, где важен размер объекта относительно кадра (например, детекция мелких объектов).

• При выборе между одним крупным фильтром и несколькими маленькими подряд с тем же receptive field почти всегда выгоднее второй вариант — экономия параметров и вычислений около $45\%$ (задания 12, 28) сопровождается ещё и дополнительными нелинейностями, которые повышают выразительность сети без роста числа весов.

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

Сегодня ты прошёл путь длиной почти в двадцать лет — от крошечной LeNet-5, распознававшей цифры на банковских чеках в 1998 году, до параллельных inception-модулей GoogLeNet 2014 года — и на каждом шаге не поверил цифрам на слово, а честно их пересчитал: сколько параметров в конкретном слое, какой размер получится у карты признаков, во сколько раз дешевле три маленьких фильтра одного большого. Эта привычка — не принимать архитектурные решения как данность, а прогонять их через конкретные числа — останется с тобой и дальше в курсе. Следующий шаг — понять, почему даже такой богатый арсенал приёмов упёрся в стену глубины около 20–30 слоёв, и как одна на удивление простая идея, skip-connections, эту стену пробила.