Варианты EfficientNet от B0 до B7

(В этом разделе приведены некоторые сведения о «составном масштабировании», и его можно пропустить если вас интересуют только модели)

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

• Разрешение: Разрешения, не кратные 8, 16 и т. д., вызывают заполнение нулями вблизи границ некоторых слоев, что тратит впустую вычислительные ресурсы. Особенно это относится к более мелким вариантов модели, поэтому входное разрешение для B0 и B1 выбрано равным 224 и 240.

• Глубина и ширина: строительные блоки EfficientNet требуют, чтобы размер канала кратно 8.

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

В результате глубина, ширина и разрешение каждого варианта моделей EfficientNet подобраны вручную и доказали, что дают хорошие результаты, хотя они могут быть значительно от формулы составного масштабирования. Поэтому реализация keras (подробно описанная ниже) предоставляет только эти 8 моделей, от B0 до B7, вместо разрешения произвольного выбора параметров ширины/глубины/разрешения.

Реализация EfficientNet в Keras

Реализация EfficientNet от B0 до B7 поставляется с tf.keras начиная с TF2.3. К используйте EfficientNetB0 для классификации 1000 классов изображений из imagenet, запустите:

 из tensorflow.keras.applications import EfficientNetB0
модель = EfficientNetB0 (веса = 'imagenet')
 

Эта модель принимает входные изображения формы (224, 224, 3), и входные данные должны находиться в диапазоне [0, 255]. Нормализация включена как часть модели.

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

Для базовых моделей от B0 до B7 форма ввода отличается. Вот список формы ввода ожидается для каждой модели:

Когда модель предназначена для трансферного обучения, реализация Keras предоставляет возможность удалить верхние слои:

 model = EfficientNetB0(include_top=False, weights='imagenet')
 

Этот параметр исключает последний слой Dense , который превращает 1280 объектов в предпоследний слоя в предсказание 1000 классов ImageNet. Замена верхнего слоя на пользовательский Layers позволяет использовать EfficientNet в качестве экстрактора признаков в рабочем процессе трансферного обучения.

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

 model = EfficientNetB0(weights='imagenet', drop_connect_rate=0,4)
 

Значение по умолчанию — 0,2.

Пример: EfficientNetB0 для стэнфордских собак.

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

 # IMG_SIZE определяется выбором модели EfficientNet
IMG_SIZE = 224
 

Настройка и загрузка данных

Для этого примера требуется TensorFlow 2.3 или выше.

Чтобы использовать TPU, среда выполнения TPU должна соответствовать текущему запущенному TensorFlow. версия. Если есть несоответствие, попробуйте:

 from cloud_tpu_client import Client
с = клиент ()
c.configure_tpu_version(tf.__version__, restart_type="всегда")
 

 импортировать тензорный поток как tf
пытаться:
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    печать ("Устройство:", tpu.master())
    стратегия = tf.distribute.TPUStrategy(tpu)
кроме ValueError:
    print("Не подключен к среде выполнения TPU. Используется стратегия CPU/GPU")
    стратегия = tf.distribute.MirroredStrategy()
 

 Не подключен к среде выполнения TPU. Использование стратегии CPU/GPU
INFO:tensorflow:Использование MirroredStrategy с устройствами ('/job:localhost/replica:0/task:0/device:GPU:0',)
 

Загрузка данных

Здесь мы загружаем данные из tensorflow_datasets (далее ТФДС). Набор данных Stanford Dogs представлен в TFDS как stanford_dogs. Он содержит 20 580 изображений, принадлежащих 120 классам пород собак. (12 000 на обучение и 8 580 на тестирование).

Просто изменив dataset_name ниже, вы также можете попробовать этот блокнот для другие наборы данных в TFDS, такие как сифар10, сифар100, еда101, и т. д. Когда изображения намного меньше, чем размер ввода EfficientNet, мы можем просто повышать разрешение входных изображений. Это было показано в Тан и Ле, 2019 г.которые передают обучение результат лучше для увеличенного разрешения, даже если входные изображения остаются маленькими.

Для TPU: при использовании наборов данных TFDS, ведро GCS местоположение требуется для сохранения наборов данных. Например:

 tfds.load(dataset_name, data_dir="gs://example-bucket/datapath")
 

Кроме того, и текущая среда, и учетная запись службы TPU имеют надлежащий доступ к ведру. Кроме того, для небольших наборов данных вы можете попробовать загрузить данные в память и использовать tf. data.Dataset.from_tensor_slices() .

 импортировать наборы данных tensorflow_data как tfds
размер партии = 64
dataset_name = "stanford_dogs"
(ds_train, ds_test), ds_info = tfds.load(
    dataset_name, split=["train", "test"], with_info=True, as_supervised=True
)
NUM_CLASSES = ds_info.features["метка"].num_classes
 

Когда набор данных включает изображения разного размера, нам нужно изменить их размер в общий размер. Набор данных Stanford Dogs включает только изображения размером не менее 200 x 200. пикселей по размеру. Здесь мы изменяем размер изображений до входного размера, необходимого для EfficientNet.

 размер = (IMG_SIZE, IMG_SIZE)
ds_train = ds_train.map (лямбда-изображение, метка: (tf.image.resize (изображение, размер), метка))
ds_test = ds_test.map (лямбда-изображение, метка: (tf.image.resize (изображение, размер), метка))
 

Визуализация данных

Следующий код показывает первые 9 изображений с их метками.

 импортировать matplotlib. pyplot как plt
def format_label (метка):
    string_label = label_info.int2str(метка)
    вернуть string_label.split("-")[1]
label_info = ds_info.features["метка"]
для i (изображение, метка) в enumerate(ds_train.take(9)):
    топор = plt.subplot (3, 3, я + 1)
    plt.imshow(image.numpy().astype("uint8"))
    plt.title("{}".format(format_label(метка)))
    плт.ось("выкл")
 

Увеличение данных

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

 из импорта tensorflow.keras.models Последовательный
из слоев импорта tensorflow.keras
img_augmentation = последовательный(
    [
        слои.RandomRotation (коэффициент = 0,15),
        слои.RandomTranslation(height_factor=0,1, width_factor=0,1),
        слои.RandomFlip(),
        слои.RandomContrast (коэффициент = 0,1),
    ],
    имя="img_аугментация",
)
 

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

 для изображения, метка в ds_train.take(1):
    для я в диапазоне (9):
        топор = plt.subplot (3, 3, я + 1)
        aug_img = img_augmentation (tf.expand_dims (изображение, ось = 0))
        plt.imshow(aug_img[0].numpy().astype("uint8"))
        plt.title("{}".format(format_label(метка)))
        плт.ось("выкл")
 

Подготовка входных данных

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

Примечание: предварительная выборка и АВТОНАСТРОЙКА могут в некоторых случаях улучшиться производительность, но зависит от среды и конкретного используемого набора данных. См. это руководство для получения дополнительной информации о производительности конвейера данных.

 # Горячее/категориальное кодирование
def input_preprocess (изображение, метка):
    метка = tf.one_hot (метка, NUM_CLASSES)
    вернуть изображение, метка
ds_train = ds_train.map(
    input_preprocess, num_parallel_calls=tf.data.AUTOTUNE
)
ds_train = ds_train.batch(batch_size=batch_size, drop_remainder=True)
ds_train = ds_train.prefetch(tf.data.AUTOTUNE)
ds_test = ds_test.map(input_preprocess)
ds_test = ds_test.batch(batch_size=batch_size, drop_remainder=True)
 

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

Мы строим EfficientNetB0 со 120 выходными классами, которые инициализируются с нуля:

Примечание: точность будет увеличиваться очень медленно и может привести к чрезмерному соответствию.

 из tensorflow.keras.applications import EfficientNetB0
со стратегией.scope():
    входы = слои. Ввод (форма = (IMG_SIZE, IMG_SIZE, 3))
    x = img_augmentation (входы)
    выходы = EfficientNetB0 (include_top = True, веса = нет, классы = NUM_CLASSES) (x)
    модель = tf. keras.Model (входы, выходы)
    модель.компилировать(
        оптимизатор = "адам", потеря = "categorical_crossentropy", metrics = ["точность"]
    )
модель.резюме()
эпохи = 40 # @param {тип: "слайдер", мин:10, макс:100}
hist = model.fit(ds_train, epochs=epochs, validation_data=ds_test, verbose=2)
 

 Модель: "functional_1"
_________________________________________________________________
Слой (тип) Выходная форма Параметр #
================================================== ===============
input_1 (InputLayer) [(Нет, 224, 224, 3)] 0
_________________________________________________________________
img_augmentation (Последовательно (Нет, 224, 224, 3) 0
_________________________________________________________________
Effectivenetb0 (Функциональный) (Нет, 120) 4203291
================================================== ===============
Всего параметров: 4 203 291
Обучаемые параметры: 4 161 268
Необучаемые параметры: 42 023
_________________________________________________________________
Эпоха 1/40
187/187 — 66 с — потеря: 4,9221 — точность: 0,0119 — val_loss: 4,9835 — val_accuracy: 0,0104
Эпоха 2/40
187/187 — 63 с — потеря: 4,5652 — точность: 0,0243 — val_loss: 5,1626 — val_accuracy: 0,0145
Эпоха 3/40
187/187 — 63 с — потеря: 4,4179 — точность: 0,0337 — val_loss: 4,7597 — val_accuracy: 0,0237
Эпоха 4/40
187/187 — 63 с — поражение: 4,2964 - точность: 0,0421 - значение_потери: 4,4028 - значение_точности: 0,0378
Эпоха 5/40
187/187 — 63 с — потеря: 4,1951 — точность: 0,0540 — val_loss: 4,3048 — val_accuracy: 0,0443
Эпоха 6/40
187/187 — 63 с — потеря: 4,1025 — точность: 0,0596 — val_loss: 4,1918 — val_accuracy: 0,0526
Эпоха 7/40
187/187 — 63 с — потеря: 4,0157 — точность: 0,0728 — val_loss: 4,1482 — val_accuracy: 0,0591
Эпоха 8/40
187/187 — 62 с — потеря: 3,9344 — точность: 0,0844 — val_loss: 4,1088 — val_accuracy: 0,0638
Эпоха 9/40
187/187 - 63 с - поражение: 3,8529- точность: 0,0951 - знач_потери: 4,0692 - знач_точность: 0,0770
Эпоха 10/40
187/187 — 63 с — потеря: 3,7650 — точность: 0,1040 — val_loss: 4,1468 — val_accuracy: 0,0719
Эпоха 11/40
187/187 — 63 с — потеря: 3,6858 — точность: 0,1185 — val_loss: 4,0484 — val_accuracy: 0,0913
Эпоха 12/40
187/187 — 63 с — потеря: 3,5942 — точность: 0,1326 — val_loss: 3,8047 — val_accuracy: 0,1072
Эпоха 13/40
187/187 — 63 с — потеря: 3,5028 — точность: 0,1447 — val_loss: 3,9513 — val_accuracy: 0,0933
Эпоха 14/40
187/187 — 63 с — поражение: 3,4295 - точность: 0,1604 - значение_потери: 3,7738 - значение_точности: 0,1220
Эпоха 15/40
187/187 — 63 с — потеря: 3,3410 — точность: 0,1735 — val_loss: 3,9104 — val_accuracy: 0,1104
Эпоха 16/40
187/187 — 63 с — потеря: 3,2511 — точность: 0,1890 — val_loss: 3,6904 — val_accuracy: 0,1264
Эпоха 17/40
187/187 — 63 с — потеря: 3,1624 — точность: 0,2076 — val_loss: 3,4026 — val_accuracy: 0,1769
Эпоха 18/40
187/187 — 63 с — потеря: 3,0825 — точность: 0,2229 — val_loss: 3,4627 — val_accuracy: 0,1744
Эпоха 19/40
187/187 — 63 с — потеря: 3,0041 — точность: 0,2355 — val_loss: 3,6061 — val_accuracy: 0,1542
Эпоха 20/40
187/187 - 64с - поражение: 2,8945 - точность: 0,2552 - значение_потери: 3,2769 - значение_точности: 0,2036
Эпоха 21/40
187/187 — 63 с — потеря: 2,8054 — точность: 0,2710 — val_loss: 3,5355 — val_accuracy: 0,1834
Эпоха 22/40
187/187 — 63 с — потеря: 2,7342 — точность: 0,2904 — val_loss: 3,3540 — val_accuracy: 0,1973
Эпоха 23/40
187/187 — 62 с — потеря: 2,6258 — точность: 0,3042 — val_loss: 3,2608 — val_accuracy: 0,2217
Эпоха 24/40
187/187 — 62 с — потеря: 2,5453 — точность: 0,3218 — val_loss: 3,4611 — val_accuracy: 0,1941
Эпоха 25/40
187/187 — 63 с — потеря: 2,4585 — точность: 0,3356 — val_loss: 3,4163 — val_accuracy: 0,2070
Эпоха 26/40
187/187 — 62 с — потеря: 2,3606 — точность: 0,3647 — val_loss: 3,2558 — val_accuracy: 0,2392
Эпоха 27/40
187/187 — 63 с — потеря: 2,2819 — точность: 0,3801 — val_loss: 3,3676 — val_accuracy: 0,2222
Эпоха 28/40
187/187 — 62 с — потеря: 2,2114 — точность: 0,3933 — val_loss: 3,6578 — val_accuracy: 0,2022
Эпоха 29/40
187/187 — 62 с — потеря: 2,0964 — точность: 0,4215 — val_loss: 3,5366 — val_accuracy: 0,2186
Эпоха 30/40
187/187 — 63 с — потеря: 1,9931 — точность: 0,4459 — val_loss: 3,5612 — val_accuracy: 0,2310
Эпоха 31/40
187/187 — 63 с — потеря: 1,8924 — точность: 0,4657 — val_loss: 3,4780 — val_accuracy: 0,2359Эпоха 32/40
187/187 — 63 с — потеря: 1,8095 — точность: 0,4874 — val_loss: 3,5776 — val_accuracy: 0,2403
Эпоха 33/40
187/187 — 63 с — потеря: 1,7126 — точность: 0,5086 — val_loss: 3,6865 — val_accuracy: 0,2316
Эпоха 34/40
187/187 — 63 с — потеря: 1,6117 — точность: 0,5373 — val_loss: 3,6419 — val_accuracy: 0,2513
Эпоха 35/40
187/187 — 63 с — потеря: 1,5532 — точность: 0,5514 — val_loss: 3,8050 — val_accuracy: 0,2415
Эпоха 36/40
187/187 — 63 с — потеря: 1,4479 — точность: 0,5809 — val_loss: 4,0113 — val_accuracy: 0,2299
Эпоха 37/40
187/187 — 62 с — потеря: 1,3885 — точность: 0,5939 — val_loss: 4,1262 — val_accuracy: 0,2158
Эпоха 38/40
187/187 — 63 с — потеря: 1,2979 — точность: 0,6217 — val_loss: 4,2519 — val_accuracy: 0,2344
Эпоха 39/40
187/187 — 62 с — потеря: 1,2066 — точность: 0,6413 — val_loss: 4,3924 — val_accuracy: 0,2169
Эпоха 40/40
187/187 — 62 с — потеря: 1,1348 — точность: 0,6618 — val_loss: 4,2216 — val_accuracy: 0,2374
 

Обучение модели происходит относительно быстро (занимает всего 20 секунд на эпоху на TPUv2, т. е. доступны на Colab). Может показаться, что просто обучить EfficientNet на любом набор данных нужен с нуля. Однако обучение EfficientNet на меньших наборах данных, особенно с более низким разрешением, таким как CIFAR-100, сталкивается со значительной проблемой переоснащение.

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

 импортировать matplotlib.pyplot как plt
определение plot_hist (хист):
    plt.plot(hist.history["точность"])
    plt.plot(hist.history["val_accuracy"])
    plt.title("точность модели")
    plt.ylabel("точность")
    plt.xlabel("эпоха")
    plt.legend(["поезд", "проверка"], loc="верхний левый")
    plt.show()
plot_hist(хист)
 

Перенос обучения из предварительно обученных весов

Здесь мы инициализируем модель с предварительно обученными весами ImageNet, и мы настраиваем его на нашем собственном наборе данных.

 по определению build_model (num_classes):
    входы = слои. Ввод (форма = (IMG_SIZE, IMG_SIZE, 3))
    x = img_augmentation (входы)
    модель = EfficientNetB0 (include_top = False, input_tensor = x, weights = "imagenet")
    # Заморозить предварительно обученные веса
    модель.trainable = Ложь
    # Восстановить вершину
    x = слои.GlobalAveragePooling2D(name="avg_pool")(model.output)
    x = слои.BatchNormalization()(x)
    top_dropout_rate = 0,2
    x = слои.Dropout(top_dropout_rate, name="top_dropout")(x)
    выходы = слои. Плотность (ЧИСЛО_КЛАССОВ, активация = "softmax", имя = "пред") (x)
    # Скомпилировать
    модель = tf.keras.Model (входы, выходы, имя = "EfficientNet")
    оптимизатор = tf.keras.optimizers.Adam (learning_rate = 1e-2)
    модель.компилировать(
        оптимизатор = оптимизатор, потеря = "categorical_crossentropy", metrics = ["точность"]
    )
    модель возврата
 

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

Обратите внимание, что конвергенция может занять до 50 эпох в зависимости от выбора скорости обучения. Если бы слои увеличения изображения не были применяется, точность проверки может достигать только ~ 60%.

 со стратегией.scope():
    модель = build_model (num_classes = NUM_CLASSES)
эпохи = 25 # @param {тип: "слайдер", мин.:8, макс.:80}
hist = model.fit(ds_train, epochs=epochs, validation_data=ds_test, verbose=2)
plot_hist(хист)
 

 Эпоха 1/25
187/187 — 33 с — потеря: 3,5673 — точность: 0,3624 — val_loss: 1,0288 — val_accuracy: 0,6957
Эпоха 2/25
187/187 — 31 с — потеря: 1,8503 — точность: 0,5232 — val_loss: 0,8439 — val_accuracy: 0,7484
Эпоха 3/25
187/187 — 31 с — потеря: 1,5511 — точность: 0,5772 — val_loss: 0,7953 - val_accuracy: 0,7563
Эпоха 4/25
187/187 — 31 с — потеря: 1,4660 — точность: 0,5878 — val_loss: 0,8061 — val_accuracy: 0,7535
Эпоха 5/25
187/187 — 31 с — потеря: 1,4143 — точность: 0,6034 — val_loss: 0,7850 — val_accuracy: 0,7569
Эпоха 6/25
187/187 — 31 с — потеря: 1,4000 — точность: 0,6054 — val_loss: 0,7846 — val_accuracy: 0,7646
Эпоха 7/25
187/187 — 31 с — потеря: 1,3678 — точность: 0,6173 — val_loss: 0,7850 — val_accuracy: 0,7682
Эпоха 8/25
187/187 — 31 с — потеря: 1,3286 — точность: 0,6222 — val_loss: 0,8142 — val_accuracy: 0,7608
Эпоха 9/25
187/187 — 31 с — потеря: 1,3210 — точность: 0,6245 — val_loss: 0,7890 — val_accuracy: 0,7669
Эпоха 25/10
187/187 — 31 с — потеря: 1,3086 — точность: 0,6278 — val_loss: 0,8368 — val_accuracy: 0,7575
Эпоха 25/11
187/187 — 31 с — потеря: 1,2877 — точность: 0,6315 — val_loss: 0,8309 — val_accuracy: 0,7599
Эпоха 12/25
187/187 — 31 с — потеря: 1,2918 — точность: 0,6308 — val_loss: 0,8319 — val_accuracy: 0,7535
Эпоха 13/25
187/187 — 31 с — потеря: 1,2738 — точность: 0,6373 — val_loss: 0,8567 — val_accuracy: 0,7576
Эпоха 14/25
187/187 — 31 с — потеря: 1,2837 — точность: 0,6410 — val_loss: 0,8004 — val_accuracy: 0,7697
Эпоха 15/25
187/187 — 31 с — потеря: 1,2828 — точность: 0,6403 — val_loss: 0,8364 — val_accuracy: 0,7625
Эпоха 16/25
187/187 — 31 с — потеря: 1,2749 — точность: 0,6405 — val_loss: 0,8558 — val_accuracy: 0,7565
Эпоха 17/25
187/187 — 31 с — потеря: 1,3022 — точность: 0,6352 — val_loss: 0,8361 — val_accuracy: 0,7551
Эпоха 18/25
187/187 — 31 с — потеря: 1,2848 — точность: 0,6394 — val_loss: 0,8958 — val_accuracy: 0,7479
Эпоха 19/25
187/187 — 31 с — потеря: 1,2791 — точность: 0,6420 — val_loss: 0,8875 — val_accuracy: 0,7509Эпоха 20/25
187/187 — 30 с — потеря: 1,2834 — точность: 0,6416 — val_loss: 0,8653 — val_accuracy: 0,7607
Эпоха 21/25
187/187 - 30 с - потеря: 1,2608 - точность: 0,6435 - val_loss: 0,8451 - val_accuracy: 0,7612
Эпоха 22/25
187/187 - 30 с - потеря: 1,2780 - точность: 0,6390 - val_loss: 0,9035 - val_accuracy: 0,7486
Эпоха 23/25
187/187 - 30 с - потеря: 1,2742 - точность: 0,6473 - val_loss: 0,8837 - val_accuracy: 0,7556
Эпоха 24/25
187/187 — 30 с — потеря: 1,2609 — точность: 0,6434 — val_loss: 0,9233 — val_accuracy: 0,7524
Эпоха 25/25
187/187 - 31с - потери: 1,2630 - точность: 0,6496 - значение_потери: 0,9116 - значение_точность: 0,7584
 

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

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

С другой стороны, когда мы используем предварительно обученные веса в наборе данных, который более отличается от ImageNet, этот шаг тонкой настройки может иметь решающее значение, поскольку экстрактор признаков также нуждается в существенной корректировке. Такую ситуацию можно продемонстрировать при выборе вместо этого набора данных CIFAR-100, где точная настройка повышает точность проверки примерно на 10%, чтобы пройти 80% на EfficientNetB0 . В таком случае сходимость может занять более 50 эпох.

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

 по умолчанию unfreeze_model(модель):
    # Мы разморозим верхние 20 слоев, оставив слои BatchNorm замороженными.
    для слоя в model.layers[-20:]:
        если не экземпляр (слой, слои.BatchNormalization):
            слой.trainable = Истина
    оптимизатор = tf.keras.optimizers.Adam (learning_rate = 1e-4)
    модель.компилировать(
        оптимизатор = оптимизатор, потеря = "categorical_crossentropy", metrics = ["точность"]
    )
unfreeze_model(модель)
эпохи = 10 # @param {тип: "слайдер", мин.:8, макс.:50}
hist = model.fit(ds_train, epochs=epochs, validation_data=ds_test, verbose=2)
plot_hist(хист)
 

 Эпоха 1/10
187/187 — 33 с — потеря: 0,9956 — точность: 0,7080 — val_loss: 0,7644 — val_accuracy: 0,7856
Эпоха 2/10
187/187 — 31 с — потеря: 0,8885 — точность: 0,7352 — val_loss: 0,7696 — val_accuracy: 0,7866
Эпоха 3/10
187/187 — 31 с — потеря: 0,8059 — точность: 0,7533 — val_loss: 0,7659 — val_accuracy: 0,7885
Эпоха 4/10
187/187 — 32 с — потеря: 0,7648 — точность: 0,7675 — val_loss: 0,7730 — val_accuracy: 0,7866
Эпоха 5/10
187/187 — 32 с — потеря: 0,6982 — точность: 0,7833 — val_loss: 0,7691 — val_accuracy: 0,7858
Эпоха 6/10
187/187 — 31 с — потеря: 0,6823 — точность: 0,7880 — val_loss: 0,7814 — val_accuracy: 0,7872
Эпоха 7/10
187/187 - 31с - потери: 0,6536 - точность: 0,7953 - val_loss: 0,7850 - val_accuracy: 0,7873
Эпоха 8/10
187/187 — 31 с — потеря: 0,6104 — точность: 0,8111 — val_loss: 0,7774 — val_accuracy: 0,7879
Эпоха 9/10
187/187 — 32 с — потеря: 0,5990 — точность: 0,8067 — val_loss: 0,7925 — val_accuracy: 0,7870
Эпоха 10/10
187/187 — 31 с — потеря: 0,5531 — точность: 0,8239 — val_loss: 0,7870 — val_accuracy: 0,7836
 

Советы по тонкой настройке EfficientNet

О размораживании слоев:

• Слои BatchNormalization должны оставаться замороженными (подробнее). Если их также превратить в обучаемых, первая эпоха после разморозки значительно снизит точность.
• В некоторых случаях может быть полезно открывать только часть слоев вместо разморозить все. Это значительно ускорит точную настройку при переходе к более крупным моделям, таким как Б7.
• Каждый блок должен быть полностью включен или выключен. Это связано с тем, что архитектура включает в себя ярлык от первого слоя к последнему слою для каждого блока. Не уважая блоки также значительно ухудшает итоговую производительность.

Другие советы по использованию EfficientNet:

• Большие варианты EfficientNet не гарантируют улучшенную производительность, особенно для задачи с меньшим количеством данных или меньшим количеством классов. В таком случае более крупный вариант EfficientNet выбран, тем сложнее настроить гиперпараметры.
• EMA (экспоненциальная скользящая средняя) очень полезна при обучении EfficientNet с нуля, но не столько для трансферного обучения.
• Не используйте настройку RMSprop, как в исходной статье, для трансферного обучения. импульс и скорость обучения слишком высоки для трансферного обучения. Это легко испортит предварительно тренированный вес и взорвать потерю. Быстрая проверка заключается в том, чтобы убедиться, что потеря (как категорическая перекрестная энтропия) становится значительно больше, чем log(NUM_CLASSES) после того же эпоха. Если это так, начальная скорость/импульс обучения слишком высока.
• Меньший размер партии повышает точность проверки, возможно, благодаря эффективному предоставлению регуляризация.

Использование новейших весов EfficientNet

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