Pix2Pix Unleashed – превращение изображений с творческой силой

Pix2Pix Превращение изображений с творческой магией

Введение

Представьте себе особую компьютерную программу, которая может оживлять рисунки, созданные детьми. Знаете те многоцветные и фантазийные рисунки, которые рисуют дети? Эта программа может превратить их в реалистичные изображения, почти как магия! И она называется Pix2Pix. Мы знаем, как фокусник может делать удивительные трюки с помощью колоды карт. Аналогично, Pix2Pix способен делать удивительные вещи с рисунками. Pix2Pix вызвал значительные изменения в том, как компьютеры понимают и работают с изображениями. Он позволяет нам иметь очень точный контроль над создаваемыми изображениями. Это похоже на наличие сверхспособности создавать и изменять изображения!

Цели обучения

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

Эта статья была опубликована в рамках блогатона по науке о данных.

Общая адверсарная сеть (GAN)

Одним из самых захватывающих новых изобретений в области искусственного интеллекта является генеративно-состязательная сеть или GAN. Эти мощные нейронные сети могут создавать новый контент, включая изображения, музыку и текст. GAN состоит из двух нейронных сетей. Одна из них – генератор, который создаёт контент, а другая – дискриминатор, который оценивает созданный контент.

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

Источник: Neptune.ai

Весь процесс обучения GAN известен как адверсарное обучение. Оно очень просто понять. Генератор создает контент, который изначально далек от идеального. Дискриминатор оценивает контент, то есть старается различить реальность и подделку. Генератор получает обратную связь от дискриминатора и корректирует свой контент, чтобы он стал более убедительным, и здесь, генератор предоставляет более качественный контент, чем ранее. В ответ на улучшения генератора дискриминатор улучшает свою способность обнаруживать поддельный контент. Таким образом, адверсарное обучение продолжает делать GAN более мощным.

Pix2Pix

Концепция преобразования и манипулирования изображениями началась с традиционных методов обработки изображений. К ним относятся изменение размера изображений, коррекция цвета и фильтрация. Однако эти традиционные методы имели ограничения в отношении более сложных задач, таких как трансляция изображения в изображение. Машинное обучение, в частности глубокое обучение, революционизировало область преобразования изображений. CNNs в наше время стали важными для автоматизации задач обработки изображений. Однако разработка генеративно-состязательных сетей (GANs) стала достижением в области трансляции изображения в изображение.

Pix2Pix – это модель глубокого обучения, используемая для задач трансляции изображений. Основная идея Pix2Pix заключается в том, чтобы взять входное изображение из одной области и сгенерировать соответствующее выходное изображение в другой области. Он переводит изображения из одного стиля в другой. Этот подход называется условными GANs, потому что Pix2Pix использует условную установку, где входное изображение условно определяет генератор. Pix2Pix использует архитектуру GAN в условной форме, называемой условной GAN (cGAN). На основе условия будет сгенерирован выходной результат.

Условная генеративно-состязательная сеть, или CGAN, является продвинутой версией основной GAN-структуры, которая обеспечивает точный контроль над создаваемыми изображениями. Она может создавать изображения в определенной категории. Pix2Pix GAN является примером CGAN, где процесс создания изображения зависит от наличия другого заданного изображения. На изображении видно чудеса, которые созданы с помощью pix2pix. Я могу создавать уличные сцены по метке, фасады по метке, черно-белое в цветное, воздушные виды на реальный маршрут, снимки дня в ночной режим и фотографии на основе краев.

Проблемы перевода изображения в изображение

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

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

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

Архитектура Pix2Pix

Архитектура Pix2Pix состоит из двух основных компонентов: Генератора и Дискриминатора. Обычно для построения моделей генератора и дискриминатора используются стандартные строительные блоки, состоящие из слоев, таких как Свертка-Нормализация пакета-ReLU. Комбинируйте эти строительные блоки, чтобы сформировать глубинные сверточные нейронные сети.

Модель генератора U-NET

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

Верхняя часть формы U состоит из серии сверточных и объединяющих слоев, которые постепенно уменьшают пространственные размеры входного изображения и увеличивают количество каналов признаков. Именно эта часть сети отвечает за захват контекстуальной информации из входного изображения. U-Net стала основой архитектуры в глубинном обучении для задач сегментации изображений. Наконец, этот генератор будет создавать изображения, неотличимые от реальных изображений.

Модель дискриминатора PatchGAN

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

Модель дискриминатора использует традиционный GAN с глубокой сверточной нейронной сетью для классификации изображений. Вместо использования традиционного GAN, дискриминатор Pix2Pix использует PatchGAN. Вместо классификации полного входного изображения как реального или поддельного, конструируется глубокая сверточная нейронная сеть, которая определяет заплатки изображения. Она разделяет реальные и сгенерированные изображения на не перекрывающиеся патчи и оценивает каждый из них индивидуально. PatchGAN предоставляет детальную обратную связь генератору и позволяет ему сосредоточиться на улучшении локальных деталей изображения. Это помогает генератору обучаться лучше. Оно действительно полезно в некоторых задачах, где сохранение мелких деталей критично. Такие задачи включают увеличение разрешения изображения. Оно помогает создавать изображения высокого разрешения и реалистичные результаты.

Применение Pix2Pix

Теперь давайте рассмотрим некоторые применения Pix2Pix.

Архитектурное проектирование: Pix2Pix может преобразовывать грубые наброски зданий в детальные архитектурные чертежи. Это помогает архитекторам создавать лучшие здания.
Перенос стиля: Он может переносить стиль одного изображения на другое. Он может взять стиль известной картины и применить его к фотографии.
Навигационные системы: Pix2Pix имеет применение в навигационных системах. Мы можем захватывать изображения улицы и с помощью Pix2Pix преобразовывать их в точные карты. Это может быть ценно для автономных систем навигации.
Медицинское изображение: Pix2Pix может улучшать и преобразовывать медицинские изображения в медицинской диагностики. Изображения с высоким разрешением всегда полезны в медицинской отрасли для оказания лучшего лечения. Этот Pix2Pix помогает превратить сканы МРТ низкого разрешения в сканы высокого разрешения или создавать изображения КТ на основе рентгеновских снимков.
Искусство и творчество: Используйте Pix2Pix для творческих целей. Он генерирует уникальные и художественные изображения или анимации на основе ввода пользователя.

Компании, использующие Pix2Pix

Теперь давайте рассмотрим некоторые компании, использующие Pix2Pix.

Adobe использовала Pix2Pix для разработки функций для своих продуктов Creative Cloud. Это включает преобразование набросков в реалистичные изображения и перевод изображений из одного стиля в другой. Pix2Pix также используется Adobe для создания синтетических данных для обучения своих моделей машинного обучения.
Google использовал Pix2Pix для разработки функций карт и фотографий. Он создает реалистичные виды улиц на основе спутниковых изображений и раскрашивает черно-белые фотографии.
Nvidia использует Pix2Pix для своей платформы искусственного интеллекта. Он способен создавать синтетические наборы данных для обучения моделей машинного обучения. Он также создает новые стили для изображений.
Google Magenta Studio – исследовательский проект, который исследует машинное обучение и искусство. Google Magenta Studio использовал Pix2Pix для создания множества инструментов для создания искусства. Magenta Studio выпустил множество Colab Notebooks, которые используют Pix2Pix для создания разных видов искусства, таких как перевод изображения, завершение изображения и восполнение изображения. Восполнение изображения включает удаление объектов с изображений или заполнение отсутствующих частей изображения. Кроме того, Magenta Studio выпустил множество моделей Magenta, которые используют Pix2Pix для создания разнообразных форм искусства. Эти модели включают Pix2PixHD, который генерирует изображения высокого разрешения на основе изображений низкого разрешения; Disco Diffusion, который создает изображения, вдохновленные различными художественными стилями, и GANPaint, который создает изображения, сочетающие реализм с воображением.

Реализация

Давайте начнем с импорта всех необходимых библиотек и модулей. Если вы обнаружите отсутствующие модули, импортируйте их с помощью команды pip.

import numpy as npfrom matplotlib import pylab as pltimport cv2import tensorflow as tfimport tensorflow.keras.layers as layersfrom tensorflow.keras.models import Modelfrom glob import globimport timeimport os

Набор данных

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

Ссылка: https://www.kaggle.com/datasets/balraj98/facades-dataset

Этот набор данных содержит изображения фасадов зданий и соответствующую сегментацию. Он был разделен на обучающую и тестовую выборки. Всего в нем содержится 506 изображений фасадов зданий.

Предварительная обработка

На следующем этапе мы загрузим данные и предварительно обработаем их в соответствии с нашей постановкой задачи. Мы определим функцию, которая выполнит все необходимые действия. Она загружает партии изображений и соответствующих меток, предварительно обрабатывает их и возвращает их в виде массивов NumPy, готовых для подачи на вход вашей модели. Сначала определяем пути, где находятся тестовые изображения и метки. Применяется функция glob для поиска всех файлов в двух каталогах. Создаем два пустых списка – img_A и img_B. В этих пустых списках будут храниться предварительно обработанные изображения из партий 1 и 2. После создания цикла он перебирает пары путей к файлам из партий 1 и 2. Для каждой пары используется функция openCV для чтения изображений, которые сохраняются в переменные.

Цветовые каналы

Мы меняем порядок цветовых каналов изображений – такой шаг часто необходим для выравнивания спецификаций входных моделей глубокого обучения. Затем мы изменяем размер изображений до 256 × 256 пикселей и, наконец, добавляем предобработанные изображения в соответствующие списки. После обработки всех изображений в пакете код преобразует списки img_A и img_B в массивы NumPy и масштабирует значения пикселей в диапазон [-1, 1]. Наконец, он возвращает обработанные изображения как img_A и img_B.

def load_data(batch_size):    path1=sorted(glob('../test_picture/*'))    path2=sorted(glob('../test_label/*'))    i=np.random.randint(0,27)    batch1=path1[i*batch_size:(i+1)*batch_size]    batch2=path2[i*batch_size:(i+1)*batch_size]        img_A=[]    img_B=[]    for filename1,filename2 in zip(batch1,batch2):        img1=cv2.imread(filename1)        img2=cv2.imread(filename2)        img1=img1[...,::-1]        img2=img2[...,::-1]        img1=cv2.resize(img1,(256,256),interpolation=cv2.INTER_AREA)        img2=cv2.resize(img2,(256,256),interpolation=cv2.INTER_AREA)        img_A.append(img1)        img_B.append(img2)          img_A=np.array(img_A)/127.5-1    img_B=np.array(img_B)/127.5-1        return img_A,img_B

Аналогично, нам нужно создать еще одну функцию для обработки обучающих данных. Ранее мы выполнили все шаги предобработки для тестовых данных и, наконец, сохранили все изображения в списке, и они существуют до конца. Но здесь, для предобработки обучающих данных, нам не нужно хранить все изображения до конца. Поэтому мы используем функцию-генератор. Инструкция yield используется для создания функции-генератора. Он выдает обработанные изображения как img_A и img_B для текущего пакета, позволяя вам итерироваться по обучающим данным пакет за пакетом без загрузки их полностью в память. В этом заключается преимущество генераторов.

# Функция-генераторdef load_batch(batch_size):    path1=sorted(glob('../train_picture/*'))    path2=sorted(glob('../train_label/*'))    n_batches=int(len(path1)/batch_size)      for i in range(n_batches):        batch1=path1[i*batch_size:(i+1)*batch_size]        batch2=path2[i*batch_size:(i+1)*batch_size]        img_A,img_B=[],[]        for filename1,filename2 in zip(batch1,batch2):            img1=cv2.imread(filename1)            img2=cv2.imread(filename2)            img1=img1[...,::-1]            img2=img2[...,::-1]            img1=cv2.resize(img1,(256,256),interpolation=cv2.INTER_AREA)                img2=cv2.resize(img2,(256,256),interpolation=cv2.INTER_AREA)            img_A.append(img1)            img_B.append(img2)              img_A=np.array(img_A)/127.5-1        img_B=np.array(img_B)/127.5-1            yield img_A,img_B

Затем мы определим класс с именем pix2pix, где мы определим все необходимые внутри него функции. Мы определим конструктор, генератор, дискриминатор, метод train и sample_images для визуализации вывода. Мы рассмотрим каждый из этих методов подробно.

class pix2pix():    def __init__(self):      pass    def build_generator(self):      pass    def build_discriminator(self):      pass    def train(self,epochs,batch_size=1):      pass    def sample_images(self, epoch):      pass

Метод конструктора

Сначала мы определим метод конструктора. Этот метод инициализирует атрибуты и компоненты вашей модели pix2pix. Это уникальный метод, который автоматически вызывается при создании объекта класса. Мы определили размеры изображения и количество каналов. Ожидается, что изображения будут иметь размер 256 × 256 пикселей с 3 цветовыми каналами (RGB). Атрибуты self.gf и self.df определяют количество фильтров (каналов) для генератора и дискриминатора соответственно.

Затем мы определим оптимизатор, где мы будем использовать оптимизатор Adam с определенной скоростью обучения и параметром beta для обучения модели. Далее создается модель дискриминатора. Она настроена с бинарной перекрестной энтропией и ранее определенным оптимизатором Adam. Мы также замораживаем веса дискриминатора во время обучения объединенной модели. Атрибут self.combined представляет собой объединенную модель, которая состоит из генератора, за которым следует дискриминатор. Генератор создает фальшивые изображения, а дискриминатор определяет их достоверность. Эта объединенная модель обучает генератор производить более реалистичные изображения.

def __init__(self):
    self.img_rows=256
    self.img_cols=256
    self.channels=3
    self.img_shape=(self.img_rows,self.img_cols,self.channels)
    patch=int(self.img_rows/(2**4)) # 2**4 = 16
    self.disc_patch=(patch,patch,1)
    self.gf=64
    self.df=64
    optimizer=tf.keras.optimizers.legacy.Adam(learning_rate=0.0002, beta_1=0.5)
    self.discriminator=self.build_discriminator()
    #self.discriminator.summary()
    self.discriminator.compile(loss='binary_crossentropy', optimizer=optimizer)
    self.generator=self.build_generator()
    #self.generator.summary()
    img_A=layers.Input(shape=self.img_shape)#picture--label
    img_B=layers.Input(shape=self.img_shape)#label--real
    img=self.generator(img_A)
    self.discriminator.trainable=False
    valid=self.discriminator([img,img_A])
    self.combined=Model(img_A,valid)
    self.combined.compile(loss='binary_crossentropy', optimizer=optimizer)

Создание генератора

Следующим шагом является создание генератора. В этом методе определяется архитектура модели генератора в стиле pix2pix GAN. Здесь нам понадобятся две различные функции. Они называются conv2d и deconv2d. Функция conv2d – это вспомогательная функция, которая создает сверточный слой с возможной нормализацией по батчам. Она принимает входной тензор, количество каналов, размер ядра и bn, булеву переменную, указывающую, следует ли использовать нормализацию по батчам. Она применяет 2D-свертку, активацию LeakyReLU и, при необходимости, нормализацию по батчам, а затем возвращает полученный тензор.

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

Модель генератора состоит из нескольких слоев, начиная с входного слоя. Затем она проходит через серию сверточных (conv2d) и деконволюционных (deconv2d) слоев. Здесь d1 до d7 – это сверточные слои, которые постепенно уменьшают размерности, увеличивая количество каналов. Аналогично, u1 до u7 – это деконволюционные слои, которые постепенно увеличивают размерности, уменьшая количество каналов. С помощью соединений skip (skip connections) сохраняются мелкие детали изображения в выводе, что делает его подходящим для задач, таких как перевод изображения в изображение в рамках pix2pix. Последний слой – это сверточный слой с активацией tanh. Он производит выходное изображение. Оно имеет то же количество каналов, что и входное изображение (self.channels), и стремится сгенерировать изображение, похожее на целевой домен.

def build_generator(self):
    def conv2d(layer_input,filters,f_size=(4,4),bn=True):
        d=layers.Conv2D(filters,kernel_size=f_size,strides=(2,2),
            padding='same')(layer_input)
        d=layers.LeakyReLU(0.2)(d)
        if bn:
            d=layers.BatchNormalization()(d)
        return d

    def deconv2d(layer_input,skip_input,filters,f_size=(4,4),dropout_rate=0):
        u=layers.UpSampling2D((2,2))(layer_input)
        u=layers.Conv2D(filters,kernel_size=f_size,strides=(1,1),
            padding='same',activation='relu')(u)
        if dropout_rate:
            u=layers.Dropout(dropout_rate)(u)
        u=layers.BatchNormalization()(u)
        u=layers.Concatenate()([u,skip_input])
        return u

    d0=layers.Input(shape=self.img_shape)
    d1=conv2d(d0,self.gf,bn=False)
    d2=conv2d(d1,self.gf*2)
    d3=conv2d(d2,self.gf*4)
    d4=conv2d(d3,self.gf*8)
    d5=conv2d(d4,self.gf*8)
    d6=conv2d(d5,self.gf*8)
    d7=conv2d(d6,self.gf*8)
    
    u1=deconv2d(d7,d6,self.gf*8,dropout_rate=0.5)
    u2=deconv2d(u1,d5,self.gf*8,dropout_rate=0.5)
    u3=deconv2d(u2,d4,self.gf*8,dropout_rate=0.5)
    u4=deconv2d(u3,d3,self.gf*4)
    u5=deconv2d(u4,d2,self.gf*2)
    u6=deconv2d(u5,d1,self.gf)
    u7=layers.UpSampling2D((2,2))(u6)
    
    output_img=layers.Conv2D(self.channels,kernel_size=(4,4),strides=(1,1),
        padding='same',activation='tanh')(u7)
    
    return Model(d0,output_img)

Построение дискриминатора

Следующим шагом является построение модели дискриминатора. Этот метод определяет архитектуру модели дискриминатора в стиле pix2pix GAN. Подобно функции conv2d в генераторе, здесь мы определяем функцию d_layer. Эта вспомогательная функция создает сверточный слой с возможной нормализацией по батчам. Она принимает входной тензор, количество каналов, размер ядра и bn, булевое значение, указывающее, нужно ли использовать нормализацию по батчам. Она применяет двумерную свертку, активацию LeakyReLU и опциональную нормализацию по батчам и возвращает полученный тензор. Модель дискриминатора имеет два входных слоя: img_A и img_B, каждый с формой, определенной self.img_shape.

Эти входы представляют пары изображений: одно из исходной области (img_A) и одно из целевой области (img_B). Входные изображения img_A и img_B конкатенируются вдоль оси каналов (axis=-1) для создания объединенных изображений. Архитектура дискриминатора состоит из сверточных слоев, от d1 до d4, с возрастающими фильтрами. Эти слои уменьшают пространственные размеры входного изображения при извлечении признаков. Финальным слоем является сверточный слой с функцией активации сигмоиды. Он выдает одноканальный выход, представляющий вероятность того, является ли входная пара изображений реальной или поддельной. Используйте этот выход для классификации входной пары изображений как реальной или поддельной.

def build_discriminator(self):
    def d_layer(layer_input, filters, f_size=(4, 4), bn=True):
        d = layers.Conv2D(filters, kernel_size=f_size, strides=(2, 2),
                          padding='same')(layer_input)
        d = layers.LeakyReLU(0.2)(d)
        if bn:
            d = layers.BatchNormalization()(d)
        return d
    
    img_A = layers.Input(shape=self.img_shape)
    img_B = layers.Input(shape=self.img_shape)
    
    combined_imgs = layers.Concatenate(axis=-1)([img_A, img_B])
    d1 = d_layer(combined_imgs, self.df, bn=False)
    d2 = d_layer(d1, self.df * 2)
    d3 = d_layer(d2, self.df * 4)
    d4 = d_layer(d3, self.df * 8)
    
    validity = layers.Conv2D(1, kernel_size=(4, 4), strides=(1, 1), padding='same',
                             activation='sigmoid')(d4)
    
    return Model([img_A, img_B], validity)

Обучение

Необходимо создать метод обучения, который будет обучать модель при вызове. Массив “valid” состоит из единиц в форме массива numpy, представляющих реальные метки изображений. Аналогично, массив “fake” содержит нули в виде массива numpy, представляющих поддельные (сгенерированные) метки изображений. Затем мы запускаем цикл для итерации по указанному количеству эпох. В каждой эпохе мы запускаем таймер, чтобы засечь время, затраченное на эту конкретную эпоху. Генератор используется для загрузки тренировочных данных пакетами внутри каждой эпохи, что позволяет получать пары изображений: img_A (вход) и img_B (цель).

Генератор использует входные изображения для создания изображений. Дискриминатор обучается классифицировать реальные пары изображений как реальные, вычисляя потери для реальных изображений. Аналогично дискриминатор обучается классифицировать сгенерированные пары изображений как поддельные, в результате чего вычисляются потери для поддельных изображений. Общая потеря дискриминатора определяется усреднением потерь для реальных и поддельных изображений. Цель обучения генератора состоит в том, чтобы генерировать изображения, обманывающие дискриминатор и заставляющие его классифицировать их как реальные.

def train(self, epochs, batch_size=1):
    valid = np.ones((batch_size,) + self.disc_patch)
    fake = np.zeros((batch_size,) + self.disc_patch)
    
    for epoch in range(epochs):
        start = time.time()
        for batch_i, (img_A, img_B) in enumerate(load_batch(1)):
            gen_imgs = self.generator.predict(img_A)
            
            d_loss_real = self.discriminator.train_on_batch([img_B, img_A], valid)
            d_loss_fake = self.discriminator.train_on_batch([gen_imgs, img_A], fake)
            d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
            
            g_loss = self.combined.train_on_batch(img_A, valid)
            
            if batch_i % 500 == 0:
                print("[Epoch %d] [Batch %d] [D loss: %f] [G loss: %f]" % (epoch, batch_i, d_loss, g_loss))
            
            self.sample_images(epoch)
            
        print('Time for epoch {} is {} sec'.format(epoch, time.time() - start))

Визуализации

Метод sample_images генерирует и отображает примеры изображений для визуализации прогресса генератора во время обучения. Здесь переменные r и c установлены равными 3, что означает, что на сетке отображаемых изображений будет 3 строки и 3 столбца. Здесь загружаются 3 пары входных и целевых изображений. Генератор используется для создания поддельных изображений на основе входных изображений. Затем изображения конкатенируются в один массив для целей отображения. Значения пикселей масштабируются от диапазона [-1, 1] до [0, 1] для правильной визуализации. Изображения отображаются на подграфиках. Фигура сохраняется как файл изображения с номером эпохи в качестве имени файла.

def sample_images(self, epoch):        r, c = 3, 3        img_A, img_B =load_data(3)        fake_A = self.generator.predict(img_A)        gen_imgs = np.concatenate([img_A, fake_A, img_B])        # Rescale images 0 - 1        gen_imgs = 0.5 * gen_imgs + 0.5        titles = ['Исходное изображение', 'Предсказанное изображение', 'Истинное изображение']        fig, axs = plt.subplots(r, c)        cnt = 0        for i in range(r):            for j in range(c):                axs[i,j].imshow(gen_imgs[cnt])                axs[i,j].set_title(titles[i])                axs[i,j].axis('off')                cnt += 1        fig.savefig("./%d.png" % (epoch))        plt.show()

Результаты

После определения всех необходимых методов, необходимо вызвать главный метод. Создайте объект с именем gan класса pix2pix. Затем обучите модель, указав количество эпох и размер пакета.

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

if __name__ == '__main__':    gan = pix2pix()    gan.train(epochs=50, batch_size=1)

Результат первой эпохи:

После 10 эпох результат следующий:

Результат после 50 эпох:

Вывод

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

Основные выводы

Pix2Pix – умный компьютерный друг, который помогает нам создавать удивительные картинки на основе наших идей. Это как магия для цифрового мира!
Pix2Pix стал революционным технологическим решением в области компьютерного зрения и обработки изображений.
Он предлагает интересные возможности, но также сталкивается с вызовами, такими как стабильность обучения и необходимость значительных наборов данных.
Проект Magenta Studio от Google, исследующий машинное обучение и искусство, использовал Pix2Pix для создания различных инструментов для создания искусства.
В этой статье мы увидели, как работает pix2pix, и поняли его волшебную силу.
Мы узнали, как использовать Pix2Pix с данными о фасаде здания, чтобы превратить чертежи в реалистичные фотографии здания, что дает нам практическое понимание.

Часто задаваемые вопросы

Файлы, показанные в этой статье, не принадлежат Analytics Vidhya и используются по усмотрению автора.

blogathon,convolutional layer,GANs,generator model,Pix2Pix,UNet