SRGAN: Генеративно-состязательные сети сверхразрешения
Изображения высокого разрешения и видео высокой четкости в наши дни являются одними из самых популярных предметов первой необходимости для людей, желающих насладиться отдыхом и отдыхом. Чем выше качество конкретного изображения или видео, тем более приятным и примечательным становится общее впечатление от просмотра для аудитории. Каждая модернизированная визуальная технология, разрабатываемая в современном мире, направлена на удовлетворение требований высококачественного видео и аудио. Поскольку качество этих изображений и видео быстро растет, спрос и предложение на эту продукцию также быстро растут. Однако не всегда возможно достичь или создать изображения или видео высочайшего качества из-за технологических ограничений, с которыми приходится сталкиваться в ходе надлежащего процесса.
Генеративно-состязательные сети сверхвысокого разрешения (SRGAN) предлагают решение этих проблем, возникающих из-за технологических ограничений или любых других причин, вызывающих эти ограничения. С помощью этих потрясающих архитектур GAN вы можете масштабировать большую часть изображений или видеоконтента с низким разрешением, которые вы можете найти, в объекты с высоким разрешением.
В этой статье наша основная цель — работать с этими архитектурами моделей SRGAN для достижения нашей цели — получения изображений сверхвысокого разрешения из изображений более низкого качества. Мы изучим архитектуру и построим простой проект с сетью SRGAN.
В этой статье мы рассмотрим большую часть необходимого содержания, связанного с пониманием того, как работает преобразование изображений с низким разрешением в изображения со сверхвысоким разрешением с помощью SRGAN. После краткого ознакомления с многочисленными спектрами разрешения и понимания базовой концепции SRGAN мы приступим к реализации архитектуры SRGAN. Мы построим модели генератора и дискриминатора, которые мы сможем использовать для создания многочисленных проектов, связанных с SRGAN. Мы, наконец, разработаем проект с этими архитектурами и получим дальнейшее понимание того, как работает их реализация.
Введение
Прежде чем мы продолжим изучение темы изображений сверхвысокого разрешения, давайте разберемся в многочисленных спектрах качества видео, которые обычно существуют в современном мире. Типичное низкое качество при просмотре видео онлайн — 144p, 240p или 360p. Эти разрешения отражают более низкие качества, с которыми вы можете транслировать или смотреть определенное видео или просматривать изображения. Некоторые из более мелких деталей и более подходящих особенностей конкретного визуального представления могут быть неуловимы для человеческого глаза при таком низком разрешении. Следовательно, общее впечатление для зрителя может оказаться не таким эстетически приятным, как ожидалось.
Разрешение 480p считается минимальным стандартным разрешением для большинства форматов просмотра. Это разрешение поддерживает качество пикселей размером 640 X 480 и было типичной нормой на ранних этапах вычислений. Это стандартное разрешение (SD) просмотра визуального представления имеет соотношение сторон 4:3 и считается нормой для большинства представлений. Дальше по шкале масштабирования идут форматы высокой четкости (HD), начиная с 720p, размер пикселей которого обычно составляет около 1280 x 720.
Затем у нас есть Full High Definition (FHD) с короткой формой 1080p, представляющей размер пикселей 1920x1080, а также Quad High Definition (QHD) с короткой формой 1440p, представляющей размер пикселей 2560x1440. Все эти три шкалы имеют соотношение сторон 16:9 и являются одними из наиболее широко используемых шкал для большинства обычных вычислительных механизмов. Последние диапазоны масштабирования включают более современные спектры визуализации с разрешением 2K, 4K и 8K. С развитием технологических достижений цель состоит в том, чтобы еще больше улучшить качество изображения и видео, чтобы зрители или аудитория могли получить наилучшие впечатления.
Однако мы можем заметить, что иногда мы не получаем желаемого качества изображения или видео, которое нам нужно. Это могут быть причины, варьирующиеся от типа объектива в камере, функций масштабирования, отсутствия эффективной технологии, неэффективного редактирования, размытия фона или любых других подобных факторов. Хотя некоторые программы могут помочь решить эту проблему, одним из лучших передовых решений для борьбы с этими проблемами является использование нейронных сетей глубокого обучения, а именно архитектуры генеративно-состязательных сетей сверхвысокого разрешения (SRGAN), для преобразования этих изображений с низким разрешением (или видео) в контент более высокого качества.
В приведенном выше представлении GIF мы можем заметить, что более низкое разрешение изображения видео находится в масштабе просмотра 135p, и в нем отсутствуют некоторые важные детали изображения. Общее качество контента, такое как полет более мелких частиц камня и общий вид космического корабля, выглядит довольно размытым. Однако с использованием SRGAN видео было преобразовано в формат 540p, что позволило зрителю лучше визуализировать сложные детали фильма. Я бы порекомендовал посмотреть следующий клип в качестве источника изображения, поскольку он демонстрирует отличную работу по преобразованию части сцены из фильма «Интерстеллар» из низкого разрешения в высокое. Давайте теперь перейдем к концептуальному пониманию SRGAN, а затем соответствующим образом реализуем их на основе полученных знаний.
Предварительные условия
Основы генеративно-состязательных сетей (GAN): понимание архитектуры и функционирования GAN, включая роли генератора и дискриминатора.
Базовые знания в области глубокого обучения: Знакомство с нейронными сетями, особенно со сверточными нейронными сетями (CNN), поскольку они играют ключевую роль в задачах обработки изображений.
Опыт обработки изображений: понимание концепций разрешения изображений, методов масштабирования изображений и показателей оценки качества (например, PSNR и SSIM).
Навыки программирования на Python: Знание Python, особенно с такими библиотеками, как TensorFlow или PyTorch, для реализации и обучения моделей SRGAN.
Знакомство с методами оптимизации: базовые знания методов обучения моделей глубокого обучения, включая функции потерь, обратное распространение ошибки и регуляризацию.
Понимание SRGAN
Концепция SRGAN — один из первых методов, который позволяет модели достичь коэффициента масштабирования почти в 4 раза для большинства визуальных изображений. Идея оценки и создания изображения с высоким разрешением из изображения с низким разрешением является очень сложной задачей. Ранее CNN использовались для создания изображений с высоким разрешением, которые позволяют быстрее обучаться и достигать высокого уровня точности. Однако в некоторых случаях они не способны восстановить более мелкие детали и часто создают размытые изображения. Предлагаемая архитектура SRGAN решает большинство этих проблем, обеспечивая создание высококачественных современных изображений.
Большинство контролируемых алгоритмов, работающих со сверхвысоким разрешением, используют среднеквадратическую ошибку между полученным изображением с высоким разрешением и истинной информацией конкретного изображения. Этот метод оказывается удобным, поскольку минимизация среднеквадратической ошибки автоматически максимизирует пиковое отношение сигнал/шум (PSNR). PSNR — один из наиболее распространенных терминов, который используется для оценки изображений сверхвысокого разрешения. Однако эти термины больше ориентированы на определение особенностей каждого отдельного пикселя, а не на более визуально воспринимаемые атрибуты, такие как высокая детализация текстуры конкретного изображения.
Следовательно, в следующей исследовательской работе по созданию фотореалистичного суперразрешения одиночного изображения с использованием генеративно-состязательной сети предлагается потеря, которая предназначена для борьбы с более ориентированными на восприятие функциями с помощью недавно введенной потери, называемой перцептивной. потеря. Потеря VGG — это тип потери контента, представленный в рамках Perceptual Loss for Real-Time Style Transfer и Super-Resolution Super-Resolution и структуры передачи стилей. Потеря восприятия представляет собой комбинацию как состязательной потери, так и потери контента. Формулировку этой потери можно интерпретировать следующим образом.
Эта потеря предпочтительнее потери среднеквадратической ошибки, поскольку нас не заботит попиксельное сравнение изображений. Больше всего нас беспокоит улучшение качества изображений. Следовательно, используя эту функцию потерь в модели SRGAN, мы можем достичь более желаемых результатов.
Разрушение архитектуры SRGAN
В этом разделе статьи мы более подробно разберемся в построении архитектуры SRGAN. Мы рассмотрим архитектуру генератора и дискриминатора отдельно и поймем, как именно они работают. Архитектура генератора по сути представляет собой полностью сверточную модель SRRESNET, которая используется для генерации высококачественных изображений сверхвысокого разрешения. Добавление модели дискриминатора, которая действует как классификатор изображений, создано для того, чтобы общая архитектура адаптировалась соответственно к качеству изображений, и полученные изображения были намного более оптимальными. Архитектура SRGAN генерирует правдоподобные естественные изображения с высоким качеством восприятия.
Генератор
Источник изображения
Архитектура генератора сети генераторов SRRESNET состоит из входных данных с низким разрешением, которые проходят через начальный сверточный слой из ядер 9×9 и 64 карты признаков, за которым следует параметрический слой ReLU. Примечательно, что вся архитектура генератора использует параметрический ReLU в качестве основной функции активации. Причина выбора параметрического ReLU заключается в том, что это одна из лучших нелинейных функций для этой конкретной задачи преобразования изображений с низким разрешением в изображения с высоким разрешением.
Функция активации, такая как ReLU, также может выполнять следующую задачу, но могут возникнуть проблемы, связанные с концепцией мертвых нейронов, когда значения меньше нуля напрямую отображаются на ноль. Альтернативным вариантом является Leaky ReLU, где значения меньше нуля сопоставляются с числом, установленным пользователем. Однако в случае параметрического ReLU мы можем позволить нейронной сети самой выбирать лучшее значение, и, следовательно, она является предпочтительной в этом сценарии.
Следующий уровень полностью сверточной модели SRRESNET с прямой связью использует группу остаточных блоков. Каждый из остаточных блоков содержит сверточный слой из ядер 3×3 и 64 карты признаков, за которым следует слой пакетной нормализации, функция активации параметрического ReLU, еще один сверточный слой с пакетной нормализацией и метод окончательного поэлементного суммирования. Метод поэлементного суммирования использует выход прямой связи вместе с выходом пропуска соединения для получения окончательного результирующего результата.
Ключевым аспектом следующей архитектуры нейронной сети, на который следует обратить внимание, является то, что каждый из сверточных слоев использует одинаковое заполнение, так что размер следующих входных и выходных данных не меняется. В отличие от других полностью сверточных сетей, таких как архитектура U-Net, часто используются уровни пула для уменьшения размера изображения. Однако для нашей модели SRGAN нам не требуется следующее, поскольку размер изображения не нужно уменьшать. Напротив, мы стремимся достичь в некоторой степени противоположного.
После того, как остаточные блоки построены, строится остальная часть модели генератора, как показано на изображении выше. Мы используем перетасовку пикселей в этой архитектуре модели генератора после 4-кратного повышения дискретизации сверточного слоя для создания изображений со сверхвысоким разрешением. Перемешиватели пикселей берут значения из измерения канала и вставляют их в измерения высоты и ширины. В этом случае высота и ширина умножаются на два, а канал делится на два. В следующем разделе статьи будет подробно рассмотрен код архитектурной сборки генератора.
Дискриминатор
Источник изображения
Архитектура дискриминатора построена таким образом, чтобы наилучшим образом поддерживать типичную процедуру GAN. И генератор, и дискриминатор конкурируют друг с другом, и оба они совершенствуются одновременно. Пока сеть дискриминатора пытается найти поддельные изображения, генератор пытается создать реалистичные изображения, чтобы избежать обнаружения дискриминатором. Работа в случае SRGAN аналогична: генеративная модель G призвана обмануть дифференцируемый дискриминатор D, который обучен отличать изображения со сверхразрешением от реальные изображения.
Следовательно, архитектура дискриминатора, показанная на изображении выше, позволяет различать изображения сверхвысокого разрешения и реальные изображения. Построенная модель дискриминатора направлена на решение состязательной проблемы мин-макса. Общую идею формулировки этого уравнения можно интерпретировать следующим образом:
Построенная архитектура дискриминатора довольно интуитивно понятна и проста для понимания. Мы используем начальный сверточный слой, за которым следует функция активации Leaky ReLU. Для этой структуры значение альфа для Leaky ReLU установлено на 0,2. Затем у нас есть куча повторяющихся блоков сверточных слоев, за которыми следует слой пакетной нормализации и функция активации Leaky ReLU. Если у вас есть пять таких повторяющихся блоков, у нас есть плотные слои, за которыми следует функция активации сигмовидной кишки для выполнения действия классификации. Обратите внимание, что начальный начальный размер свертки составляет 64 x 64, который умножается на 2 после двух полных блоков каждый, пока мы не достигнем 8-кратного коэффициента масштабирования 512 x 512. Эта модель дискриминатора помогает генератору обучаться более эффективно и давать лучшие результаты.
Разработка проекта с SRGAN
В этом разделе статьи мы будем развивать проект с SRGAN. Для выполнения этой задачи доступно множество наборов данных. В исследовательской работе используется случайная выборка из 350 тысяч изображений из набора данных ImageNet. Однако размер набора данных ImageNet составляет около 150 ГБ, и обучение такой модели займет много времени. Следовательно, для этого проекта мы будем использовать более удобный и меньший по размеру набор данных Diverse 2k (div2k), который составляет около 5 ГБ.
В этом проекте мы будем использовать платформы глубокого обучения TensorFlow и Keras для построения модели SRGAN и ее обучения по мере необходимости. Большая часть кода, используемого для создания этого проекта, взята из следующего репозитория GitHub, который я настоятельно рекомендую проверить. Фактически, я бы предложил загрузить папку datasets и utils в ваш рабочий каталог, поскольку это упростит извлечение данных, и мы сможем сосредоточиться на построении и обучении модели архитектуры SRGAN.
Импорт основных библиотек
Первым шагом к началу работы над проектом SRGAN является реализация всех основных библиотек, необходимых для выполнения следующей задачи. Убедитесь, что на вашем устройстве включена версия TensorFlow для графического процессора, и импортируйте все необходимые библиотеки, как указано в блоке кода ниже. Потери, оптимизаторы, слои, архитектура VGG19 для потерь VGG16 и другие необходимые библиотеки. Другим важным импортом является прямой импорт из загруженных папок по ранее упомянутой ссылке GitHub. Убедитесь, что папки datasets и utils находятся в вашем рабочем каталоге. Они будут использоваться для упрощения подготовки набора данных и сокращения усилий по обучению модели.
import tensorflow as tf
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.optimizers.schedules import PiecewiseConstantDecay
from tensorflow.keras.losses import MeanSquaredError, BinaryCrossentropy, MeanAbsoluteError
from tensorflow.keras.layers import Input, Conv2D, BatchNormalization, Add, Lambda, LeakyReLU, Flatten, Dense
from tensorflow.python.keras.layers import PReLU
from tensorflow.keras.applications.vgg19 import VGG19, preprocess_input
from tensorflow.keras.models import Model
from tensorflow.keras.metrics import Mean
from PIL import Image
import time
import os
from datasets.div2k.parameters import Div2kParameters
from datasets.div2k.loader import create_training_and_validation_datasets
from utils.normalization import normalize_m11, normalize_01, denormalize_m11
from utils.dataset_mappings import random_crop, random_flip, random_rotate, random_lr_jpeg_noise
from utils.metrics import psnr_metric
from utils.config import config
from utils.callbacks import SaveCustomCheckpoint
Подготовка набора данных
Набор данных DIVerse 2K содержит высококачественные изображения различных разрешений, которые идеально подходят для модели SRGAN, которую мы хотим построить. Вы можете скачать набор данных со следующего веб-сайта. Чтобы продолжить чтение этой статьи, я бы посоветовал вам загрузить каждый из четырех отдельных zip-файлов, упомянутых в приведенном ниже фрагменте кода. Эти четыре файла содержат файлы обучения и проверки для изображений как с низким, так и с высоким разрешением. После завершения загрузки вы можете извлечь их соответствующим образом.
Убедитесь, что вы создали новый каталог с именем div2k и поместили все извлеченные файлы в только что созданный каталог. У нас есть изображения с низким разрешением и соответствующие им изображения с высоким разрешением, которые наша модель будет использовать в учебных целях. В исследовательской работе они используют случайный кадр размером 96 x 96, и, следовательно, мы будем использовать то же самое в нашем методе обучения. Каждый образец изображения с низким разрешением будет обрезан в соответствии с соответствующим фрагментом с высоким разрешением.
# Dataset Link - https://data.vision.ee.ethz.ch/cvl/DIV2K/http://data.vision.ee.ethz.ch/cvl/DIV2K/DIV2K_train_LR_bicubic_X4.ziphttps://data.vision.ee.ethz.ch/cvl/DIV2K/DIV2K_valid_LR_bicubic_X4.ziphttp://data.vision.ee.ethz.ch/cvl/DIV2K/DIV2K_train_HR.ziphttp://data.vision.ee.ethz.ch/cvl/DIV2K/DIV2K_valid_HR.zip
dataset_key = "bicubic_x4"
data_path = config.get("data_path", "")
div2k_folder = os.path.abspath(os.path.join(data_path, "div2k"))
dataset_parameters = Div2kParameters(dataset_key, save_data_directory=div2k_folder)
hr_crop_size = 96
train_mappings = [
lambda lr, hr: random_crop(lr, hr, hr_crop_size=hr_crop_size, scale=dataset_parameters.scale),
random_flip,
random_rotate,
random_lr_jpeg_noise]
train_dataset, valid_dataset = create_training_and_validation_datasets(dataset_parameters, train_mappings)
valid_dataset_subset = valid_dataset.take(10)
Построение архитектуры генератора SRRESNET
Архитектура генератора SRRESNET построена точно так, как подробно описано в предыдущем разделе. Архитектура модели разделена на несколько функций, что упрощает построение общего размера структуры. Мы определим блок перемешивания пикселей и соответствующую функцию, которая будет повышать дискретизацию наших данных вместе со слоем перемешивания пикселей. Мы определим еще одну функцию для остаточных блоков, содержащую непрерывную комбинацию сверточного слоя из ядер 3 × 3 и 64 карт признаков, за которыми следует слой пакетной нормализации, функция активации параметрического ReLU, еще один сверточный слой с пакетной нормализацией и последний элемент поэлементно. метод sum, который использует прямую связь и пропуск соединения соответственно.
upsamples_per_scale = {
2: 1,
4: 2,
8: 3
}
pretrained_srresnet_models = {
"srresnet_bicubic_x4": {
"url": "https://image-super-resolution-weights.s3.af-south-1.amazonaws.com/srresnet_bicubic_x4/generator.h5",
"scale": 4
}
}
def pixel_shuffle(scale):
return lambda x: tf.nn.depth_to_space(x, scale)
def upsample(x_in, num_filters):
x = Conv2D(num_filters, kernel_size=3, padding='same')(x_in)
x = Lambda(pixel_shuffle(scale=2))(x)
return PReLU(shared_axes=[1, 2])(x)
def residual_block(block_input, num_filters, momentum=0.8):
x = Conv2D(num_filters, kernel_size=3, padding='same')(block_input)
x = BatchNormalization(momentum=momentum)(x)
x = PReLU(shared_axes=[1, 2])(x)
x = Conv2D(num_filters, kernel_size=3, padding='same')(x)
x = BatchNormalization(momentum=momentum)(x)
x = Add()([block_input, x])
return x
def build_srresnet(scale=4, num_filters=64, num_res_blocks=16):
if scale not in upsamples_per_scale:
raise ValueError(f"available scales are: {upsamples_per_scale.keys()}")
num_upsamples = upsamples_per_scale[scale]
lr = Input(shape=(None, None, 3))
x = Lambda(normalize_01)(lr)
x = Conv2D(num_filters, kernel_size=9, padding='same')(x)
x = x_1 = PReLU(shared_axes=[1, 2])(x)
for _ in range(num_res_blocks):
x = residual_block(x, num_filters)
x = Conv2D(num_filters, kernel_size=3, padding='same')(x)
x = BatchNormalization()(x)
x = Add()([x_1, x])
for _ in range(num_upsamples):
x = upsample(x, num_filters * 4)
x = Conv2D(3, kernel_size=9, padding='same', activation='tanh')(x)
sr = Lambda(denormalize_m11)(x)
return Model(lr, sr)
Постройте модель дискриминатора и архитектуру SRGAN
Архитектура дискриминатора построена точно так, как подробно обсуждалось в предыдущем разделе. Мы используем сверточные слои, за которыми следует функция активации Leaky ReLU, которая использует значение альфа 0,2. Мы добавляем сверточный слой и функцию активации Leaky ReLU для первого блока. Остальные пять блоков архитектуры дискриминатора используют сверточный уровень, за которым следует уровень пакетной нормализации и, наконец, добавленный уровень функции активации Leaky ReLU. Последними уровнями архитектуры являются полносвязные узлы с 1024 параметрами, слой Leaky ReLU и последний полносвязный плотный узел с сигмовидной функцией активации для целей классификации. Полный фрагмент кода, посвященный построению архитектуры дискриминатора, приведен в приведенном ниже блоке кода.
def discriminator_block(x_in, num_filters, strides=1, batchnorm=True, momentum=0.8):
x = Conv2D(num_filters, kernel_size=3, strides=strides, padding='same')(x_in)
if batchnorm:
x = BatchNormalization(momentum=momentum)(x)
return LeakyReLU(alpha=0.2)(x)
def build_discriminator(hr_crop_size):
x_in = Input(shape=(hr_crop_size, hr_crop_size, 3))
x = Lambda(normalize_m11)(x_in)
x = discriminator_block(x, 64, batchnorm=False)
x = discriminator_block(x, 64, strides=2)
x = discriminator_block(x, 128)
x = discriminator_block(x, 128, strides=2)
x = discriminator_block(x, 256)
x = discriminator_block(x, 256, strides=2)
x = discriminator_block(x, 512)
x = discriminator_block(x, 512, strides=2)
x = Flatten()(x)
x = Dense(1024)(x)
x = LeakyReLU(alpha=0.2)(x)
x = Dense(1, activation='sigmoid')(x)
return Model(x_in, x)
Обучение модели SRGAN
Теперь, когда мы успешно завершили построение архитектуры SRGAN, можно приступить к обучению модели. Сохраните модель генератора и модель дискриминатора в соответствующих моделях. Определите модель VGG для интерпретации постоянных потерь, которую мы будем использовать для этой модели. Создайте свои контрольные точки и определите оптимизаторы для сетей генератора и дискриминатора. После того, как вы выполните следующие шаги, мы сможем приступить к обучению модели SRGAN.
generator = build_srresnet(scale=dataset_parameters.scale)
generator.load_weights(weights_file)
discriminator = build_discriminator(hr_crop_size=hr_crop_size)
layer_5_4 = 20
vgg = VGG19(input_shape=(None, None, 3), include_top=False)
perceptual_model = Model(vgg.input, vgg.layers[layer_5_4].output)
binary_cross_entropy = BinaryCrossentropy()
mean_squared_error = MeanSquaredError()
learning_rate=PiecewiseConstantDecay(boundaries=[100000], values=[1e-4, 1e-5])
generator_optimizer = Adam(learning_rate=learning_rate)
discriminator_optimizer = Adam(learning_rate=learning_rate)
srgan_checkpoint_dir=f'./ckpt/srgan_{dataset_key}'
srgan_checkpoint = tf.train.Checkpoint(step=tf.Variable(0),
psnr=tf.Variable(0.0),
generator_optimizer=Adam(learning_rate),
discriminator_optimizer=Adam(learning_rate),
generator=generator,
discriminator=discriminator)
srgan_checkpoint_manager = tf.train.CheckpointManager(checkpoint=srgan_checkpoint,
directory=srgan_checkpoint_dir,
max_to_keep=3)
if srgan_checkpoint_manager.latest_checkpoint:
srgan_checkpoint.restore(srgan_checkpoint_manager.latest_checkpoint)
print(f'Model restored from checkpoint at step {srgan_checkpoint.step.numpy()} with validation PSNR {srgan_checkpoint.psnr.numpy()}.')
С помощью @tf.function, который действует как декоратор, наши команды Python преобразуются в форму графиков TensorFlow. Мы будем использовать функцию градиентной ленты для компиляции и обучения модели по мере необходимости. Мы будем обучать сеть генератора и дискриминатора одновременно, потому что мы хотим, чтобы обе эти архитектуры моделей улучшались синхронно друг с другом. Мы будем использовать функцию вечных потерь, как обсуждалось в предыдущих разделах. Код процесса обучения должен показаться довольно интуитивным, если зрители следили за некоторыми из моих предыдущих статей о GAN, где мы более подробно освещаем процесс обучения. Ниже приведен фрагмент кода, позволяющий начать процесс обучения модели SRGAN.
@tf.function
def train_step(lr, hr):
with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
lr = tf.cast(lr, tf.float32)
hr = tf.cast(hr, tf.float32)
sr = srgan_checkpoint.generator(lr, training=True)
hr_output = srgan_checkpoint.discriminator(hr, training=True)
sr_output = srgan_checkpoint.discriminator(sr, training=True)
con_loss = calculate_content_loss(hr, sr)
gen_loss = calculate_generator_loss(sr_output)
perc_loss = con_loss + 0.001 * gen_loss
disc_loss = calculate_discriminator_loss(hr_output, sr_output)
gradients_of_generator = gen_tape.gradient(perc_loss, srgan_checkpoint.generator.trainable_variables)
gradients_of_discriminator = disc_tape.gradient(disc_loss, srgan_checkpoint.discriminator.trainable_variables)
generator_optimizer.apply_gradients(zip(gradients_of_generator, srgan_checkpoint.generator.trainable_variables))
discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, srgan_checkpoint.discriminator.trainable_variables))
return perc_loss, disc_loss
@tf.function
def calculate_content_loss(hr, sr):
sr = preprocess_input(sr)
hr = preprocess_input(hr)
sr_features = perceptual_model(sr) / 12.75
hr_features = perceptual_model(hr) / 12.75
return mean_squared_error(hr_features, sr_features)
def calculate_generator_loss(sr_out):
return binary_cross_entropy(tf.ones_like(sr_out), sr_out)
def calculate_discriminator_loss(hr_out, sr_out):
hr_loss = binary_cross_entropy(tf.ones_like(hr_out), hr_out)
sr_loss = binary_cross_entropy(tf.zeros_like(sr_out), sr_out)
return hr_loss + sr_loss
После успешного завершения выполнения вышеуказанного блока кода вы можете перейти к следующему фрагменту кода, как показано ниже. Обратите внимание, что процедура обучения может занять довольно много времени, и рекомендуется дать модели возможность обучаться от нескольких часов до нескольких дней в зависимости от типа вашей системы, чтобы получить наилучшие результаты и изображения с высоким разрешением, генерируемые SRGAN, которые мы разработали. Изображения, созданные в конце каждой эпохи, будут сохранены в папке обучения монитора, и вы сможете соответственно просмотреть сгенерированные результаты в конце каждой эпохи. Лучшие веса также сохраняются благодаря обратным вызовам контрольных точек, которые мы создали ранее.
perceptual_loss_metric = Mean()
discriminator_loss_metric = Mean()
step = srgan_checkpoint.step.numpy()
steps = 200000
monitor_folder = f"monitor_training/srgan_{dataset_key}"
os.makedirs(monitor_folder, exist_ok=True)
now = time.perf_counter()
for lr, hr in train_dataset.take(steps - step):
srgan_checkpoint.step.assign_add(1)
step = srgan_checkpoint.step.numpy()
perceptual_loss, discriminator_loss = train_step(lr, hr)
perceptual_loss_metric(perceptual_loss)
discriminator_loss_metric(discriminator_loss)
if step % 100 == 0:
psnr_values = []
for lr, hr in valid_dataset_subset:
sr = srgan_checkpoint.generator.predict(lr)[0]
sr = tf.clip_by_value(sr, 0, 255)
sr = tf.round(sr)
sr = tf.cast(sr, tf.uint8)
psnr_value = psnr_metric(hr, sr)[0]
psnr_values.append(psnr_value)
psnr = tf.reduce_mean(psnr_values)
image = Image.fromarray(sr.numpy())
image.save(f"{monitor_folder}/{step}.png" )
duration = time.perf_counter() - now
now = time.perf_counter()
print(f'{step}/{steps}, psnr = {psnr}, perceptual loss = {perceptual_loss_metric.result():.4f}, discriminator loss = {discriminator_loss_metric.result():.4f} ({duration:.2f}s)')
perceptual_loss_metric.reset_states()
discriminator_loss_metric.reset_states()
srgan_checkpoint.psnr.assign(psnr)
srgan_checkpoint_manager.save()
Обратите внимание, что процедура обучения может быть довольно длительной в зависимости от типа системы, которую вы используете для этого процесса. Будут предоставлены основные требования для решения следующей задачи. Не стесняйтесь исследовать и глубже погружаться в мир генеративных нейронных сетей, создавая многочисленные результаты изображений на основе обученной модели SRGAN.
Заключение
Общая взвешенная комбинация всех основных функций и атрибутов в конкретной визуализации способствует классификации качества изображения представления. Более низкие разрешения не позволяют выделить некоторые более мелкие и важные детали конкретного изображения или видеоконтента, что решается увеличением разрешения и общего качества указанного объекта. Мы предпочитаем использовать большинство визуализаций в современном мире в высочайшем качестве, чтобы мы, зрители и зрители, могли получить наилучшие впечатления от конкретного контента. Следовательно, суперразрешение — это основная концепция, имеющая большое значение в современном мире, и то, чего мы стремились достичь в этой статье с помощью генеративных нейронных сетей.
В этой статье мы рассмотрели большинство важных аспектов, необходимых для начала работы с разрешением изображений. Мы поняли разные масштабы разрешения и важность получения спектров с высоким разрешением вместо использования более низкого разрешения. Получив краткое представление о концепциях разрешения изображения и видео, мы поняли концепцию SRGAN более подробно. Затем мы подробно изучили архитектуру этой сети, соответственно рассмотрев блоки генератора и дискриминатора. Наконец, мы разработали проект, чтобы понять значение этих генеративных нейронных сетей и то, как они будут работать в мире природы.
В будущих статьях мы постараемся изучить больше архитектур GAN и узнать больше о различных типах генеративных сетей, которые в последнее время постоянно набирают огромную популярность. Мы также рассмотрим концепции передачи нейронного стиля и более подробно рассмотрим такие темы, как обучение с подкреплением. А до тех пор продолжайте изучать и наслаждаться нейронными сетями и всем, что может предложить ИИ!