1 в класс фото: Картинки 1 класс (21 фото) • Прикольные картинки и позитив

В учебных пособиях.

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

Мы рассмотрим следующие варианты:

• обучение небольшой сети с нуля (в качестве основы)
• с использованием узких мест предварительно обученной сети
• тонкая настройка верхних уровней предварительно обученной сети

Это приведет нас к рассмотрению следующих функций Keras:

• fit_generator для обучения модели Кераса с использованием генераторов данных Python
• ImageDataGenerator для увеличения данных в реальном времени
• Замораживание слоев и точная настройка модели
• …и более.

Примечание: все примеры кода были обновлены до API Keras 2.0 14 марта 2017 г. Для их запуска вам потребуется Keras версии 2.0.0 или выше.

Наша установка: всего 2000 обучающих примеров (по 1000 в классе)

Начнем со следующей настройки:

• машина с установленными Keras, SciPy, PIL. Если у вас есть графический процессор NVIDIA, который вы можете использовать (и установлен cuDNN), это прекрасно, но поскольку мы работаем с несколькими изображениями, это не является строго необходимым.
• каталог обучающих данных и каталог данных проверки, содержащий по одному подкаталогу для каждого класса изображений, заполненному изображениями .png или .jpg:

 данные /
    поезд/
        собаки /
            dog001.jpg
            dog002.jpg
            ...
        кошки /
            cat001.jpg
            cat002.jpg
            ...
    Проверка/
        собаки /
            dog001.jpg
            dog002.jpg
            ...
        кошки /
            cat001.jpg
            cat002.jpg
            ...
 

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

В наших примерах мы будем использовать два набора изображений, которые мы получили от Kaggle: 1000 кошек и 1000 собак (хотя в исходном наборе данных было 12500 кошек и 12500 собак, мы только что взяли первые 1000 изображений для каждого класса). Мы также используем 400 дополнительных образцов из каждого класса в качестве данных проверки для оценки наших моделей.

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

Насколько сложна эта проблема? Когда Kaggle начал игру cats vs.соревнование собак (всего 25000 тренировочных изображений), чуть более двух лет назад, оно появилось со следующим заявлением:

«В неофициальном опросе, проведенном много лет назад, эксперты по компьютерному зрению заявили, что классификатор с точностью выше 60% будет затруднен без значительного прогресса в данной области техники. Для справки: 60% классификатор повышает вероятность предположения HIP с 12 изображениями с 1/4096 до 1/459.
Текущая литература предполагает, что машинные классификаторы могут получить более 80% точности при выполнении этой задачи [ref].»

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

О важности глубокого обучения для проблем с небольшими данными

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

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

Предварительная обработка и расширение данных

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

В Keras это можно сделать с помощью класса keras.preprocessing.image.ImageDataGenerator . Этот класс позволяет:

• настроить случайные преобразования и операции нормализации, которые будут выполняться с данными изображения во время обучения
• создают экземпляры генераторов пакетов расширенных изображений (и их меток) через .flow (данные, метки) или .flow_from_directory (каталог) . Затем эти генераторы можно использовать с методами модели Keras, которые принимают генераторы данных в качестве входных данных, fit_generator , Assessment_generator и pred_generator .

Сразу посмотрим на пример:

 из keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator (
        диапазон_ вращения = 40,
        width_shift_range = 0,2,
        height_shift_range = 0,2,
        rescale = 1. / 255,
        shear_range = 0,2,
        zoom_range = 0,2,
        horizontal_flip = Верно,
        fill_mode = 'ближайший')
 

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

• диапазон_ вращения — значение в градусах (0–180), диапазон, в пределах которого можно произвольно вращать изображения
• width_shift и height_shift — это диапазоны (как доля от общей ширины или высоты), в пределах которых можно произвольно перемещать изображения по вертикали или горизонтали
• rescale — это значение, на которое мы умножим данные перед любой другой обработкой.Наши исходные изображения состоят из коэффициентов RGB в диапазоне 0–255, но такие значения были бы слишком высокими для обработки нашими моделями (с учетом типичной скорости обучения), поэтому мы нацелены на значения от 0 до 1, вместо этого масштабируя их с 1/255. фактор.
• shear_range для произвольного применения трансформаций сдвига
• диапазон масштабирования — для произвольного масштабирования внутри изображений
• horizontal_flip предназначен для случайного переворачивания половины изображений по горизонтали — актуально, когда нет предположений о горизонтальной асимметрии (например,г. картинки из реального мира).
• fill_mode — это стратегия, используемая для заполнения вновь созданных пикселей, которые могут появиться после поворота или сдвига ширины / высоты.

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

 из keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img

datagen = ImageDataGenerator (
        диапазон_ вращения = 40,
        width_shift_range = 0.2,
        height_shift_range = 0,2,
        shear_range = 0,2,
        zoom_range = 0,2,
        horizontal_flip = Верно,
        fill_mode = 'ближайший')

img = load_img ('data / train / cats / cat.0.jpg') # это изображение PIL
x = img_to_array (img) # это массив Numpy с формой (3, 150, 150)
x = x.reshape ((1,) + x.shape) # это массив Numpy с shape (1, 3, 150, 150)

# команда .flow () ниже генерирует пакеты случайно преобразованных изображений
# и сохраняет результаты в каталог `preview /`
я = 0
для партии в датагене.поток (x, batch_size = 1,
                          save_to_dir = 'предварительный просмотр', save_prefix = 'cat', save_format = 'jpeg'):
    я + = 1
    если i> 20:
        break # иначе генератор будет зацикливаться бесконечно
 

Вот что мы получаем — вот как выглядит наша стратегия увеличения объема данных.

Обучение небольшой свёрточной сети с нуля: точность 80% в 40 строках кода

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

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

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

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

Приведенный ниже фрагмент кода — это наша первая модель, простой стек из 3 слоев свертки с активацией ReLU и последующими слоями максимального объединения.Это очень похоже на архитектуры, которые Ян Лекун защищал в 1990-х годах для классификации изображений (за исключением ReLU).

Полный код этого эксперимента можно найти здесь.

 из keras.models import Sequential
из keras.layers импортировать Conv2D, MaxPooling2D
from keras.layers import Activation, Dropout, Flatten, Dense

model = Последовательный ()
model.add (Conv2D (32, (3, 3), input_shape = (3, 150, 150)))
model.add (Активация ('relu'))
model.add (MaxPooling2D (размер_пул = (2, 2)))

модель.добавить (Conv2D (32, (3, 3)))
model.add (Активация ('relu'))
model.add (MaxPooling2D (размер_пул = (2, 2)))

model.add (Conv2D (64, (3, 3)))
model.add (Активация ('relu'))
model.add (MaxPooling2D (размер_пул = (2, 2)))

# пока что модель выводит трехмерные карты объектов (высота, ширина, особенности)
 

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

 model.add (Flatten ()) # преобразует наши 3D-карты объектов в 1D-векторы.
model.add (Плотный (64))
model.add (Активация ('relu'))
model.add (Выпадение (0,5))
model.add (Плотный (1))
model.add (Активация ('сигмоид'))

model.compile (loss = 'binary_crossentropy',
              optimizer = 'rmsprop',
              метрики = ['точность'])
 

Подготовим наши данные. Мы будем использовать .flow_from_directory () для создания пакетов данных изображений (и их меток) непосредственно из наших файлов jpg в соответствующих папках.

 batch_size = 16

# это конфигурация дополнения, которую мы будем использовать для обучения
train_datagen = ImageDataGenerator (
        rescale = 1. / 255,
        shear_range = 0,2,
        zoom_range = 0,2,
        horizontal_flip = True)

# это конфигурация дополнения, которую мы будем использовать для тестирования:
# только масштабирование
test_datagen = ImageDataGenerator (масштабирование = 1. / 255)

# это генератор, который будет читать картинки, найденные в
# подфолеров 'data / train' и неограниченно генерировать
# пакет расширенных данных изображения
train_generator = train_datagen.flow_from_directory (
        'data / train', # это целевой каталог
        target_size = (150, 150), # все изображения будут изменены до 150x150
        batch_size = размер_пакета,
        class_mode = 'binary') # поскольку мы используем потери binary_crossentropy, нам нужны двоичные метки

# это аналогичный генератор, для проверки данных
validation_generator = test_datagen.flow_from_directory (
        'проверка достоверности данных',
        target_size = (150, 150),
        batch_size = размер_пакета,
        class_mode = 'двоичный')
 

Теперь мы можем использовать эти генераторы для обучения нашей модели.Каждая эпоха занимает 20-30 секунд на GPU и 300-400 секунд на CPU. Так что запускать эту модель на CPU определенно целесообразно, если вы не торопитесь.

 model.fit_generator (
        train_generator,
        steps_per_epoch = 2000 // размер партии,
        эпох = 50,
        validation_data = validation_generator,
        validation_steps = 800 // размер партии)
model.save_weights ('first_try.h5') # всегда сохранять вес после тренировки или во время тренировки
 

Этот подход дает нам точность проверки, равную 0.79-0,81 после 50 эпох (число было выбрано произвольно — поскольку модель мала и использует агрессивный отсев, к этому моменту она, похоже, не слишком подходит). Таким образом, к моменту запуска конкурса Kaggle мы уже были «в состоянии искусства» — с 8% данных и без усилий по оптимизации нашей архитектуры или гиперпараметров. Фактически, в конкурсе Kaggle эта модель попала бы в сотню лучших (из 215 участников). Я предполагаю, что по крайней мере 115 участников не использовали глубокое обучение;)

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

Использование узких мест предварительно обученной сети: точность 90% за минуту

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

Мы будем использовать архитектуру VGG16, предварительно обученную на наборе данных ImageNet — модель, ранее представленная в этом блоге. Поскольку набор данных ImageNet содержит несколько классов «кошек» (персидский кот, сиамский кот …) и множество классов «собак» среди 1000 классов, в этой модели уже будут изучены функции, относящиеся к нашей задаче классификации. Фактически, вполне возможно, что простой записи прогнозов softmax модели на основе наших данных, а не характеристик узких мест будет достаточно, чтобы решить наши проблемы с собаками против.проблема классификации кошек очень хорошо. Однако метод, который мы представляем здесь, с большей вероятностью будет хорошо обобщен на более широкий круг проблем, включая проблемы с классами, отсутствующими в ImageNet.

Вот как выглядит архитектура VGG16:

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

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

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

 batch_size = 16

генератор = datagen.flow_from_directory (
        'данные / поезд',
        target_size = (150, 150),
        batch_size = размер_пакета,
        class_mode = None, # это означает, что наш генератор будет выдавать только пакеты данных, без меток
        shuffle = False) # наши данные будут в порядке, поэтому все первые 1000 изображений будут кошками, затем 1000 собаками
# метод pred_generator возвращает результат модели, учитывая
# генератор, который выдает пакеты большого количества данных
bottleneck_features_train = модель.pred_generator (генератор, 2000)
# сохраняем вывод как массив Numpy
np.save (open ('bottleneck_features_train.npy', 'w'), bottleneck_features_train)

генератор = datagen.flow_from_directory (
        'проверка достоверности данных',
        target_size = (150, 150),
        batch_size = размер_пакета,
        class_mode = Нет,
        shuffle = False)
bottleneck_features_validation = model.predict_generator (генератор, 800)
np.save (open ('bottleneck_features_validation.npy', 'w'), bottleneck_features_validation)
 

Затем мы можем загрузить наши сохраненные данные и обучить небольшую полностью подключенную модель:

 train_data = np.load (open ('bottleneck_features_train.npy'))
# функции были сохранены по порядку, поэтому легко воссоздать метки
train_labels = np.array ([0] * 1000 + [1] * 1000)

validation_data = np.load (open ('bottleneck_features_validation.npy'))
validation_labels = np.array ([0] * 400 + [1] * 400)

model = Последовательный ()
model.add (Flatten (input_shape = train_data.shape [1:]))
model.add (Плотный (256, активация = 'relu'))
model.add (Выпадение (0,5))
model.add (Плотный (1, активация = 'сигмоид'))

model.compile (optimizer = 'rmsprop',
              loss = 'binary_crossentropy',
              метрики = ['точность'])

модель.подходят (train_data, train_labels,
          эпох = 50,
          batch_size = размер_пакета,
          validation_data = (данные_проверки, метки_проверки))
model.save_weights ('bottleneck_fc_model.h5')
 

Благодаря небольшому размеру эта модель очень быстро обучается даже на CPU (1 с в эпоху):

 Обучить на 2000 образцах, проверить на 800 образцах
Эпоха 1/50
2000/2000 [==============================] - 1 с - потеря: 0,8932 - в соответствии с: 0,7345 - val_loss: 0,2664 - val_acc: 0,8862
Эпоха 2/50
2000/2000 [==============================] - 1 с - потеря: 0.3556 - согласно: 0.8460 - val_loss: 0.4704 - val_acc: 0.7725
...
Эпоха 47/50
2000/2000 [==============================] - 1 с - потеря: 0,0063 - в соответствии с: 0,9990 - val_loss: 0,8230 - val_acc: 0,9125
Эпоха 48/50
2000/2000 [==============================] - 1 с - убыток: 0,0144 - расчет: 0,9960 - val_loss: 0,8204 - val_acc: 0.9075
Эпоха 49/50
2000/2000 [==============================] - 1 с - убыток: 0,0102 - в соответствии с: 0,9960 - val_loss: 0,8334 - val_acc: 0.9038
Эпоха 50/50
2000/2000 [==============================] - 1 с - потеря: 0.0040 - согласно: 0.9985 - val_loss: 0.8556 - val_acc: 0.9075
 

Мы достигли точности проверки 0,90–0,91: совсем неплохо. Это определенно частично связано с тем, что базовая модель была обучена на наборе данных, который уже включал собак и кошек (среди сотен других классов).

Тонкая настройка верхних уровней предварительно обученной сети

Чтобы еще больше улучшить наш предыдущий результат, мы можем попытаться «настроить» последний сверточный блок модели VGG16 вместе с классификатором верхнего уровня.Тонкая настройка состоит в том, чтобы начать с обученной сети, а затем повторно обучить ее на новом наборе данных с использованием очень небольших обновлений веса. В нашем случае это можно сделать за 3 шага:

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

Обратите внимание:

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

Точная настройка

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

Вы можете найти полный код этого эксперимента здесь.

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

 # построить модель классификатора, чтобы поставить поверх сверточной модели
top_model = Последовательный ()
top_model.add (Flatten (input_shape = model.output_shape [1:]))
top_model.add (Плотный (256, активация = 'relu'))
top_model.add (Выпадение (0,5))
top_model.add (Плотный (1, активация = 'сигмоид'))

# обратите внимание, что необходимо начинать с полностью обученного
# классификатор, включая верхний классификатор,
# для успешной тонкой настройки
Топ модель.load_weights (top_model_weights_path)

# добавляем модель поверх сверточной базы
model.add (верхняя_модель)
 

Затем мы приступаем к замораживанию всех сверточных слоев до последнего сверточного блока:

 # установить первые 25 слоев (до последнего блока conv)
# на необучаемый (веса не будут обновляться)
для слоя в model.layers [: 25]:
    layer.trainable = Ложь

# компилируем модель с помощью оптимизатора SGD / импульса
# и очень медленная скорость обучения.
model.compile (loss = 'binary_crossentropy',
              optimizer = оптимизаторы.SGD (lr = 1e-4, импульс = 0,9),
              метрики = ['точность'])
 

Наконец, мы начинаем тренировать все это с очень медленной скоростью обучения:

 batch_size = 16

# подготовить конфигурацию дополнения данных
train_datagen = ImageDataGenerator (
        rescale = 1. / 255,
        shear_range = 0,2,
        zoom_range = 0,2,
        horizontal_flip = True)

test_datagen = ImageDataGenerator (масштабирование = 1. / 255)

train_generator = train_datagen.flow_from_directory (
        train_data_dir,
        target_size = (img_height, img_width),
        batch_size = размер_пакета,
        class_mode = 'двоичный')

validation_generator = test_datagen.flow_from_directory (
        validation_data_dir,
        target_size = (img_height, img_width),
        batch_size = размер_пакета,
        class_mode = 'двоичный')

# настроить модель
model.fit_generator (
        train_generator,
        steps_per_epoch = nb_train_samples // размер партии,
        эпохи = эпохи,
        validation_data = validation_generator,
        validation_steps = nb_validation_samples // размер партии)
 

Этот подход приводит нас к точности проверки 0,94 после 50 эпох. Огромный успех!

Вот еще несколько подходов, которые вы можете попытаться достичь выше 0.95:

• более агрессивное увеличение данных
• более агрессивный отсев
• Использование регуляризации L1 и L2 (также известное как «снижение веса»)
• точная настройка еще одного сверточного блока (наряду с большей регуляризацией)

На этом пост заканчивается! Напомним, вот где вы можете найти код для наших трех экспериментов:

Если у вас есть какие-либо комментарии к этому сообщению или предложения о будущих темах, которые нужно осветить, вы можете связаться с ними в Twitter.

.Блог фотографов

Breyer | DeviantArt

Осенняя и осенняя выставка фотографий лошадей!

Всем привет! Я провожу свою ОЧЕНЬ ПЕРВУЮ модельную выставку лошадей!

Он будет состоять из 2 ТИПОВ классов, один из которых является одомашненным, а другой — диким / диким.

Важна креативность! Каждое изображение будет рассматриваться в поисках «идеи / концепции» изображения, в большей степени, чем качества. Это одна из причин того, что это шоу отличается от большинства.

Второе, что отличается от большинства шоу….. Нет никакого приза (если только кто-то не хочет пожертвовать баллы на приз)! Это шоу предназначено исключительно для развлечения и практики!

Домашний

(1–3 лошади на фото)

Класс 1 — Соревновательная фотография (в этом классе у вас есть возможность использовать наездников и гвоздь. Вы можете использовать наездников и галс ТОЛЬКО в этом классе)

Класс 2 — На свободе (на этой фотографии лошадь / лошади могут быть свободными … делать что угодно. Это НЕ квалифицируется на Feral!)

Класс 3 — Джек — О — Фонарь (В этом классе вы должны включить Хэллоуин тему в вашу фотографию для приближающегося праздника!)

Wild / Feral

(ограничение от 1 до 6 лошадей на фотографию)

Класс 1 — со стадом (должно быть стадо! Ограничение от 3 до 6 Лошади)

Класс 2 — Кошмары (Это класс «Дикий Хэллоуин»! Вы ДОЛЖНЫ сделать это фото так или иначе, чтобы было темно.Будь то ночь, закат или простой световой эффект)

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

Большое спасибо всем, кто входит! Я попрошу hoofbeats111 судить этот конкурс вместе со мной. (У меня есть запасной судья, не волнуйтесь) Конкурс заканчивается 4 октября!

Спасибо, ребята! Любой желающий может войти бесплатно, и нет ограничений на количество фотографий!

• Jr

.