GENets: Neural Architecture Design For GPU-Efficienet Networks

Введение

Авторы статьи [1] решают проблему backbones для эффективного инференса на GPU в задачах Computer Vision. Поскольку, по их мнению, существующие решения не используют всю мощь GPU.

В работе они показывают, как проектировать такие backbones и как результат получают семейство backbones GENet. Из результатов экспериментов мы видим, что проблема актуальна и авторам удалось спроектировать очень быстрое решение для GPU!

Эффективный backbone авторы получают при помощи двух составляющих:

1. Набор блоков (пространство поиска), оптимизированных под быстрый инференс на GPU.
2. Легковесный Local Linear Regression (LLR) NAS, при помощи которого будет найдена целевая архитектура из блоков предыдущего пункта.

Цель исследователей — показать, что быструю архитектуру можно сделать с помощью грамотного проектирования пространства поиска вместо того, чтобы «закидать всё железом»:

Сначала разберём, из каких блоков состоит пространство поиска, а затем, как алгоритм ищет по нему нужную архитектуру.

Проектирование пространства поиска

Базовые блоки — это наименьшая единица, которой оперируют авторы статьи. Как правило, это несколько последовательных свёрток (Conv + BN + ReLU) определённого типа.

Варианты базовых блоков

Базовые блоки для проектирования пространства поиска изображены на рисунке ниже:

Предлагается 3 типа блоков:

1. XX-Block — две классические свёртки размера k x k.
2. BL-Block — классическая свёртка со структурой bottleneck, коэффицент r задаёт, насколько будет уменьшено исходное количество каналов (r < 1):
   1. Дешёвыми свёртками 1х1 уменьшается количество каналов.
   2. Применяются тяжелые свёртки k x k.
   3. Далее дешёвыми свёртками 1х1 восстанавливается необходимое количество каналов.
3. DW-Block — depth-wise свёртка в структуре inverted bottleneck, коэффицент r задаёт, насколько будет увеличено исходное количество каналов (r > 1):
   1. Дешёвыми свёртками 1х1 увеличивается количество каналов.
   2. Применяются depth-wise свёртки k x k.
   3. Дешёвыми свёртками 1х1 восстанавливается необходимое количество каналов.

Базовый блок всегда обёрнут в residual structure, и если выходной shape не совпадает со входным — используется projection layer c down-sampling (Рис. 2).

FLOPS/model size vs latency

Авторы провели эксперименты, чтобы установить, зависит ли latency от FLOPs и model size. Для этого они сделали замеры latency vs FLOPs и latency vs model size, представленные на рисунке 3 (left) и (right) соответственно для популярных backbones: ResNet-50, ResNet-152, MobilNetV2, Efficientnet-B0. Здесь и далее по тексту все замеры производились на batch size 64.

Из графиков можно заметить, что latency не зависит от FLOPS и model size. Это совпадает с тем, что наблюдали авторы статьи [2].

Basic block latency

Чтобы понять, какие блоки и где их использовать в сети, авторы замерили latency для трёх сетей, составленных из базовых блоков одного типа.

Для всех свёрток в базовых блоках stride = 1, kernel_size = 3. Для сети на базе XX-Blocks использовались 5 блоков, а для сетей на базе BL-Blocks и DW-Blocks — 10 блоков для покрытия того же визуального региона. Замеры проведены на batch_size = 64, image_size = 224×224. На Рис. 4 приведены результаты замеров latency.

Пояснение:

1. На Рис. 4 (a) приведено сравнение XX-Block против DW-Block с разнымими r и шириной блока. При уменьшении 1/r для DW-Block уменьшается и время инференса в сравнении с XX-Block.
2. На Рис. 4 (b) приведено сравнение XX-Block против BL-Block с разными r и шириной блока. Здесь стоит отметить, что при r = 1 BL-Block медленнее XX-Block.

На основе графиков (а) и (b) можно сказать — лучше использовать BL-Block и DW-Block, что используется в Resnet/EfficientNet.

Авторы статьи рассматривают ещё дополнительную ось — ёмкость сети, которая позволяет выучивать сложные функции. Результаты этих замеров приведены на графиках (c) и (d). Из них следует, что на фиксированой ёмкости сети XX-Block использовать выгоднее всего.

Авторы предлагают воспринимать BL/DW-Blocks как низкоранговую аппроксимацию XX-Block (с меньшим количеством параметров). При r = 1 BL/DW-Blocks медленнее, чем XX-Blocks следовательно, лучше использовать его. А значит, BL/DW-Blocks более эффективны на GPU, чем XX-Blocks, в зависимости от того, насколько конкретный слой представим низкоранговой аппроксимацией.

Intrinsic Rank of Convolutional Layers

Вдохновлённые экспериментами с замерами времени работы базовых блоков, авторы изучили, какие слои стоит представлять низкоранговой аппроксимацией, а какие — нет. Для этого они проанализировали ранги ядер свёртки с разных частей backbone. Ранг свёртки (читай матрицы) напрямую связан с собственными значениями, которые больше нуля: их количество равно рангу матрицы. Если какие-то собственные значения близки к 0, значит, ранг на количество этих собственных значений может быть уменьшен → матрица может быть аппроксимированна.

В эксперименте рассматривались 3 нейросети, которые построены только на XX-Blocks: resnet-18, resnet-34 и profilenet-132 (спроектирован авторами, архитектура представлена в [1], Appendix A, Table 5). Обучали всё на Imagenet 360 эпох. На Рис. 5 представлены распределения собственных значений ядер свёрток с разных этапов. Для каждого этапа брались свёрточные ядра с последнего слоя, исключая первый, всего получилось 4 этапа. Затем свёртку разворачивали в матрицу (\(C_{out}\), \(C_{in} \times k^2\)), где \(С_{in}\) и \(C_{out}\) — количество входных и выходных каналов соответственно. Далее считаются собственные значения и нормализуются: для \(i\)-го собственного значения \(\lambda_{i}\) его \(x\) координата нормализована по \(i/c_{out}\)

Согласно графикам на рисунке выше, собственные значения слоёв ближе к концу сети убывают быстрее, чем те, что ближе к началу. Это значит, что слои, расположенные ближе к концу сети стоит аппроксимировать, и для них предпочтительно использовать BL/DW-Blocks, а на начальных слоях лучше использовать XX-Blocks.

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

Алгоритм NAS

Общая идея алгоритма поиска, предложенного авторами, следующая:

1. Используя полученное знание о том, где какие слои размещать вручную строится backbone с эффективным инференсом на GPU. Его называют MasterNet.
2. MasterNet используется как начальное состояние для LLR NAS алгоритма, чтобы далее оптимизировать его.

Построение MasterNet

На рисунке представлена верхнеуровневая архитектура MasterNet: stem layer, супер-блоки, Average Pooling и FC layer.

Stem layer — свёртка со stride 2, а каждый супер-блок — несколько базовых блоков одного типа и ширины. Параметры супер-блока — глубина, ширина и stride, первый блок в супер-блоке может быть down-sampling (avg pool) со stride 2, но это необязательно.

Авторы вручную спроектировали 20 разных MasterNet-сетей. У всех latency примерно 0.34ms на изображение при bs=64 (это latency resnet50/effnetb0). Backbones обучали на Imagenet 120 epochs, BL-Block r = 1/4, DW-Block r = 6.

В таблице 1 представлены 20 MasterNet, спроектированных вручную и отсортированных по accuracy. Можно заметить, что сети с top accuracy соответствуют принципу XX-Blocks на ранних слоях и BL/DW-Blocks — на поздних слоях. Net1 выбран в качестве MasterNet, но конкретная конфигурация MasterNet не так важна после введения NAS, Net2 и Net3 также могут быть выбраны в качестве MasterNet.

Local Linear Regression NAS

Пусть MasterNet состоит из \(M\) супер-блоков \(S_1, …, S_M\). Параметры супер-блока \(S_i(d_i, c_i, T_i)\) — глубина \(d_i\), ширина \(c_i\) и тип \(T_i\) .

В этих обозначениях LLR NAS состоит из 3 этапов:

1. Дистилляция. Для каждого супер-блока \(S_i\) алгоритм заменяет его на случайный блок \({\widehat{S}_i}^j({d_i}^j, {c_i}^j, {T_i}^j)\) c изменёнными параметрами глубины, ширины и типа блока. Далее полученная сеть с изменённой структурой дообучается до сходимости, и для неё рассчитывается accuracy — \({A_i}^j\). Это выполняется до тех пор, пока каждый супер-блок \(S_i\) типа \(T\) не соберёт достаточно настроенных значений точности \(\{{A_i}^1, {A_i}^2, … , {A_i}^N\}\)
2. Регрессия. Для каждого \(i\) и типа блока \(T_i\) вычисляются псевдо-градиенты \(g = [g1, g2]\) при помощи метода наименьших квадратов \(g_1({d_i}^j — d_i) + g_2 ({c_i}^j — c_i) \approx {A_i}^j — A^{}\), где \(A^{}\) — точность MasterNet. Они показывают, как изменение параметров слоя виляет на весь пайплайн сети. То есть посчитав псевдо-градиенты для всех блоков, можно посчитать точность для сети определённой структуры.
3. Отбор. Случайным образом генерируются структуры сетей, и для них предсказывается accuracy при помощи псевдо-гранидента \(g\), а далее выбирается подходящая конфигурация в зависимости от требуемой latency.

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

Результаты эксприментов

Авторы запустили LLR NAS с бюджетом по latency 0.34/0.2/0.1 ms, на bs = 64, GPU V100, вычисления проводились в fp16. Для LLR NAS случайным образом выбраны 50000 изображений из обучающего набора для валидации NAS, которые не используются в обучении. Авторы использовали SGD with Nesterov momentum 0.9, стартовый lr 0.1 на bs=256, cosine learning rate decay + warm-up 5 эпох, weight-decay \(4 × 10^{-5}\).

В LLR NAS каждый изменённый супер-блок дообучался 30 эпох на lr 0.01 и batch size 256.

Пространство перебора:

1. kernel_size \(\{3, 5\}\);
2. [2.0\(c\), 0.5\(c\)], где \(c\) — ширина супер-блока;
3. [\(d\) + 2, \(d\) − 2], где \(d\) — глубина супер-блока;
4. Для BL-block \(r \in {0.5, 0.25}\);
5. Для DW-block \(r \in \{3, 6, 9\}\).

Для каждого супер-блока случайным образом выбирались 9 конфигураций из упомянутого выше пространства перебора. Далее лучшее разрешение выбиралось из простраства {196, 224, 256}, для каждого разрешения выбиралась сеть в пределах вычислительного бюджета и дообучалась 120 эпох.

В итоге NAS занял 60 часов на 24 V100, а затем лучшие найденные архитектуры обучались 480 эпох с label-smoothing, mix-up, random-erase и auto-augmentations, также применялась дистилляция знаний из ResNet-152 в пропорции с true labels 1:1.

Найденные NAS-структуры назвали GENet-large/normal/light. В таблице 2 представлены структуры GENet light/normal/large.

Замеры скорости инференса моделей авторы проводили в трёх конфигурациях:

1. NVIDIA V100 в FP16 и PyTorch в качестве движка для инференса;
2. NVIDIA T4 в FP16 и TensorRT в качестве движка для инференса;
3. NVIDIA T4 в INT8 и TensorRT в качестве движка для инференса.

Результаты сравнения ImageNet Top-1 accuracy vs latency для GENets и популярных backbones приведены на Рис. 7.

Согласно результатам, представленным на Рис. 7, GENets превосходят все backbones, с которыми сравниваются: они либо быстрее при той же точности, либо точнее при той же скорости. Авторы отмечают — GENet-large на 5% точнее EfficienetNet-B0 при той же latency на V100, а также небольшое количество сетей, которые пробивают accuracy 81.3% на ImageNet, но при этом намного быстрее EfficienetNet-B3. Стоит отметить эффективность GENet на T4, хоть и оптимизация проводилась на V100.

Также было проведено сравнение latency для сетей с близким top-1 accuracy на ImageNet, результаты представлены в Таблице 3.

Превосходство GENet проявляется, когда нужен высокий accuracy. Большинство сетей не могут достичь точности в ≥ 81% на ImageNet, за исключением EfficienetNet-B3 и GENet-large, но при этом GENet-large быстрее в 6.4 раза в конфигурации T4 INT8, а GENet-normal в 6.8 раз быстрее EfficienetNet-B2 в конфигуации T4 INT8.

Заключение

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

1. Для ранних свёрточных слоёв предпочтительно использовать классические свёртки.
2. Для поздних свёрточных слоёв лучше применять depth-wise свёртки или bottleneck-структуру.

Также был предложен легковесный Local Linear Regression NAS, использующий упомянутый принцип для поиска эффективных на GPU свёрточных сетей. Найденные при помощи этого NAS сети GENet-light/normal/large достигают высокой accuracy на ImageNet, будучи при этом в несколько раз быстрее EfficienetNet.

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

Есть и «шероховатости»: для предложенного метода нужно вручную подобрать MasterNet, а при сравнении метрик для полученных моделей авторы применили дистиляцию + label-smoothing, mix-up, random-erase и auto-augmentations, что довольно таки много и сравнение получается не совсем честное. Это, в свою очередь, не умаляет их вклада и рекомендации ознакомиться с работой подробнее 😊

Разработанное семейство backbones доступно в библиотеке timm.

Полезные ссылки

1. Neural Architecture Design for GPU-Efficient Networks
2. Designing Network Design Spaces