Генератор фото: Сайт дня: генератор фотографий несуществующих людей

В январе 2019 года мы добавили поддержку нового формата изображений WEBP от Google.

SSL — большое дело для любого веб-мастера в 2018 году. Ваши изображения-заполнители будут работать с HTTPS или без него…

http: // via.placeholder.com/300
https: / / via.placeholder.com/300


… вызывается из доменов HTTP или HTTPS.

Есть вопросы?

У нас есть ответы.Пожалуйста, посетите нашу страницу с часто задаваемыми вопросами.

StyleGAN: использование машинного обучения для создания и настройки реалистичных изображений | автор: Джамшед Хан

Прежде чем углубляться в изменения, внесенные исследователями в архитектуру сети GAN для создания StyleGAN, важно отметить, что эти изменения относятся только к сети генератора , таким образом влияя только на процесс генерации. Не было изменений ни в дискриминаторе, ни в функции потерь, которые остались такими же, как в традиционной GAN.

Цель NVIDIA StyleGAN — преодолеть ограничения традиционной GAN, в которой управление отдельными характеристиками данных, такими как черты лица на фотографиях, может оказаться невозможным. Предлагаемая модель позволяет пользователю настраивать гиперпараметры для достижения такого контроля. Кроме того, он учитывает фактор изменчивости в сгенерированных изображениях из-за добавления «стилей» к изображениям на каждом уровне свертки.

Модель начинается с генерации новых изображений, начиная с очень низкого разрешения (что-то вроде 4×4) и, в конечном итоге, постепенно увеличивается до конечного разрешения 1024×1024, которое на самом деле обеспечивает достаточно деталей для визуально привлекательного изображения.

Основным принципом обучения StyleGAN является этот «прогрессивный» метод, который впервые был использован NVIDIA в их ProGAN.Он работает путем постепенного увеличения разрешения, тем самым обеспечивая медленное развитие сети, сначала изучая простую задачу, а затем прогрессирует к изучению более сложных проблем (или, в данном случае, изображений с более высоким разрешением). Такой принцип обучения обеспечивает стабильность и, как было доказано, сводит к минимуму общие проблемы, связанные с сетями GAN, такие как сбой режима. Он также гарантирует, что сначала обрабатываются высокоуровневые функции, прежде чем переходить к более мелким деталям, уменьшая вероятность того, что такие функции будут сгенерированы неправильно (что окажет более сильное влияние на окончательное изображение, чем наоборот).StyleGANs используют аналогичный принцип, но вместо создания одного изображения они генерируют несколько изображений, и этот метод позволяет отделить стили или функции друг от друга.

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

На каждом слое свертки можно использовать разные стили для создания изображения: грубые стили с разрешением от 4×4 до 8×8, средние стили с разрешение от 16×16 до 32×32, или прекрасные стили с разрешением от 64×64 до 1024×1024.

Грубые стили управляют высокоуровневыми функциями, такими как поза объекта на изображении или волосы объекта, форма лица и т. Д. Средние стили управляют такими аспектами, как черты лица. Наконец, тонкие стили покрывают детали изображения, такие как цвет глаз или другие микроструктуры.

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

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

Традиционный GAN не позволяет контролировать более тонкую стилизацию изображения, потому что он следует своему собственному распределению, которое регулируется его обучением с высокоуровневыми атрибутами, а также потому, что на него влияет общая «тенденция» своего набора данных (скажем, например, доминирующий цвет волос во всем наборе данных). Максимум, что можно было сделать, — это изменить входное изображение (вектор) и таким образом получить другой результат.

Архитектура NVIDIA включает промежуточное «скрытое пространство», которое можно рассматривать как «съемное». Затем в это пространство можно встроить входной скрытый код. Стили или функции, присутствующие в изображениях, на самом деле являются разными формами одного и того же встраивания скрытых векторов, которое используется для нормализации входных данных каждого сверточного слоя.

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

Извлечь текст из изображения | Средство извлечения текста онлайн

Нужно ли мне платить за использование Workbench?

Нет! Workbench на 100% бесплатен. Не требуется лицензии, подписки или даже адреса электронной почты.

Будете ли вы добавлять новые инструменты в Workbench в будущем?

Да!

Наша команда будет продолжать наращивать полезные ресурсы и со временем выпускать их.

Как работает автоматическая пометка AI?

AI — это функция, используемая платформами управления цифровыми активами (DAM), чтобы помочь пользователям сэкономить время за счет исключения ручной работы, поощрения организации и упрощения поиска файлов.

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

Как работает генератор цветовой палитры?

Генератор цветовой палитры Workbench извлекает серию цветов HEX из изображения при загрузке. Он считает каждый пиксель и его цвет и генерирует палитру, содержащую до 6 HEX-кодов наиболее повторяющихся цветов.

Что такое метаданные?

Метаданные предоставляют информацию о содержимом актива.

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

Что такое управление цифровыми активами?

Управление цифровыми активами (DAM) в последние годы стало критически важной системой для компаний всех отраслей и размеров.DAM — это программная платформа, которую бренды используют для хранения, редактирования, распространения и отслеживания активов своего бренда. DAM предназначены для поощрения организации цифровой архитектуры компании, исключая использование скрытых файлов и папок, которые обычно хранятся на Google Диске или Dropbox.

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

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

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

Как разработать Pix2Pix GAN для преобразования изображения в изображение

Последнее обновление 18 января 2021 г.

Генеративная состязательная сеть Pix2Pix, или GAN, представляет собой подход к обучению глубокой сверточной нейронной сети для задач преобразования изображения в изображение.

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

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

После прохождения этого руководства вы будете знать:

• Как загрузить и подготовить спутниковое изображение в набор данных преобразования изображения в изображение карт Google.
• Как разработать модель Pix2Pix для перевода спутниковых фотографий в изображения карты Google.
• Как использовать окончательную модель генератора Pix2Pix для перевода специальных спутниковых изображений.

Начните свой проект с моей новой книги «Генеративные состязательные сети с Python», включающей пошаговые руководства и файлы исходного кода Python для всех примеров.

Приступим.

• Обновлено в январе / 2021 г. : Обновлено, поэтому замораживание слоев работает с нормой партии.

Как разработать генерирующую состязательную сеть Pix2Pix для преобразования изображения в изображение
Фотография сделана Европейской южной обсерваторией, некоторые права защищены.

Обзор учебного пособия

Это руководство разделено на пять частей; их:

1. Что такое Pix2Pix GAN?
2. Набор данных преобразования изображений со спутника на карту
3. Как разработать и обучить модель Pix2Pix
4. Как переводить изображения с помощью модели Pix2Pix
5. Как перевести карты Google на спутниковые изображения

Что такое Pix2Pix GAN?

Pix2Pix — это модель генерирующей состязательной сети или GAN, разработанная для универсального преобразования изображения в изображение.

Подход был представлен Филипом Изола и др. в своей статье 2016 года под названием «Преобразование изображения в изображение с помощью условно-состязательных сетей», представленной на CVPR в 2017 году.

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

Модель Pix2Pix — это тип условного GAN, или cGAN, где создание выходного изображения зависит от входа, в данном случае исходного изображения. Дискриминатору предоставляется как исходное изображение, так и целевое изображение, и он должен определять, является ли цель правдоподобным преобразованием исходного изображения.

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

Pix2Pix GAN был продемонстрирован на ряде задач преобразования изображения в изображение, таких как преобразование карт в спутниковые фотографии, черно-белые фотографии в цветные и эскизы продуктов в фотографии продуктов.

Теперь, когда мы знакомы с Pix2Pix GAN, давайте подготовим набор данных, который мы можем использовать для преобразования изображения в изображение.

Хотите разрабатывать сети GAN с нуля?

Пройдите бесплатный 7-дневный ускоренный курс электронной почты (с образцом кода).

Нажмите, чтобы зарегистрироваться, а также получите бесплатную электронную версию курса в формате PDF.

Загрузите БЕСПЛАТНЫЙ мини-курс

Набор данных преобразования изображений со спутника на карту

В этом руководстве мы будем использовать так называемый набор данных « maps », используемый в статье Pix2Pix.

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

Набор данных представлен на веб-сайте pix2pix и может быть загружен в виде zip-файла размером 255 мегабайт.

Загрузите набор данных и распакуйте его в текущий рабочий каталог. Будет создан каталог под названием « карты » со следующей структурой:

карты ├── поезд └── val

Папка поезда содержит 1097 изображений, тогда как набор данных проверки содержит 1099 изображений.

Изображения имеют цифровое имя файла и находятся в формате JPEG. Каждое изображение имеет ширину 1200 пикселей и высоту 600 пикселей и содержит как спутниковое изображение слева, так и изображение Google Maps справа.

Образец изображения из набора данных Maps, включая изображение со спутника и Google Maps.

Мы можем подготовить этот набор данных для обучения модели Pix2Pix GAN в Keras. Мы просто будем работать с изображениями в наборе обучающих данных. Каждое изображение будет загружено, масштабировано и разделено на элементы спутниковой карты и карты Google.В результате получится 1097 пар цветных изображений с шириной и высотой 256 × 256 пикселей.

Функция load_images () ниже реализует это. Он перечисляет список изображений в заданном каталоге, загружает каждое с целевым размером 256 × 512 пикселей, разбивает каждое изображение на элементы спутника и карты и возвращает массив каждого из них.

# загружаем все изображения из каталога в память def load_images (путь, размер = (256,512)): src_list, tar_list = список (), список () # перечисляем имена файлов в каталоге, предполагаем, что все изображения для имени файла в listdir (путь): # загрузить и изменить размер изображения пикселей = load_img (путь + имя файла, target_size = размер) # преобразовать в массив numpy пикселей = img_to_array (пиксели) # разделить на спутник и карту sat_img, map_img = пикселей [:,: 256], пикселей [:, 256:] src_list.добавить (sat_img) tar_list.append (map_img) возврат [asarray (src_list), asarray (tar_list)]

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

Полный пример приведен ниже.

# загружать, разделять и масштабировать набор данных карт, готовый к обучению из os import listdir из numpy import asarray из numpy import vstack из кераса.preprocessing.image import img_to_array из keras.preprocessing.image import load_img из numpy import savez_compressed # загружаем все изображения из каталога в память def load_images (путь, размер = (256,512)): src_list, tar_list = список (), список () # перечисляем имена файлов в каталоге, предполагаем, что все изображения для имени файла в listdir (путь): # загрузить и изменить размер изображения пикселей = load_img (путь + имя файла, target_size = размер) # преобразовать в массив numpy пикселей = img_to_array (пиксели) # разделить на спутник и карту sat_img, map_img = пикселей [:,: 256], пикселей [:, 256:] src_list.добавить (sat_img) tar_list.append (map_img) возврат [asarray (src_list), asarray (tar_list)] # путь к набору данных путь = ‘карты / поезд /’ # загрузить набор данных [src_images, tar_images] = load_images (путь) print (‘Загружено:’, src_images.shape, tar_images.shape) # сохранить как сжатый массив numpy filename = ‘maps_256.npz’ savez_compressed (имя файла, src_images, tar_images) print (‘Сохраненный набор данных:’, имя файла)

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

Загружено: (1096, 256, 256, 3) (1096, 256, 256, 3) Сохраненный набор данных: maps_256.npz

Этот файл можно загрузить позже с помощью функции load () NumPy и получения каждого массива по очереди.

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

# загружаем подготовленный набор данных из numpy import load из matplotlib import pyplot # загрузить набор данных data = load (‘maps_256.npz’) src_images, tar_images = данные [‘arr_0’], данные [‘arr_1’] print (‘Загружено:’, src_images.shape, tar_images.shape) # сюжет исходных изображений n_samples = 3 для i в диапазоне (n_samples): pyplot.subplot (2, n_samples, 1 + i) pyplot.axis (‘выключено’) pyplot.imshow (src_images [i] .astype (‘uint8’)) # построить целевое изображение для i в диапазоне (n_samples): пиплот.подзаговор (2, n_samples, 1 + n_samples + i) pyplot.axis (‘выключено’) pyplot.imshow (tar_images [i] .astype (‘uint8’)) pyplot.show ()

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

Загружено: (1096, 256, 256, 3) (1096, 256, 256, 3)

Также создается график из трех пар изображений, показывающий спутниковые изображения вверху и изображения карты Google внизу.

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

График из трех пар изображений, показывающий спутниковые изображения (вверху) и изображения Google Map (внизу).

Теперь, когда мы подготовили набор данных для перевода изображений, мы можем разработать нашу модель Pix2Pix GAN.

Как разработать и обучить модель Pix2Pix

В этом разделе мы разработаем модель Pix2Pix для перевода спутниковых фотографий в изображения Google Maps.

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

Реализация в этом разделе будет использовать структуру глубокого обучения Keras, основанную непосредственно на модели, описанной в документе и реализованной в базе кода автора, предназначенной для получения и генерации цветных изображений размером 256 × 256 пикселей.

Архитектура состоит из двух моделей: дискриминатора и генератора.

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

Дизайн дискриминатора основан на эффективном воспринимающем поле модели, которое определяет отношение между одним выходом модели и количеством пикселей во входном изображении.Это называется моделью PatchGAN и тщательно спроектировано таким образом, чтобы каждый выходной прогноз модели соответствовал квадрату или фрагменту входного изображения размером 70 × 70. Преимущество этого подхода заключается в том, что одна и та же модель может применяться к входным изображениям разных размеров, например. больше или меньше 256 × 256 пикселей.

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

Функция define_discriminator () ниже реализует модель дискриминатора 70 × 70 PatchGAN в соответствии с дизайном модели, описанной в статье. Модель берет два входных изображения, которые объединены вместе, и предсказывает исправление вывода предсказаний. Модель оптимизирована с использованием бинарной кросс-энтропии, и используется взвешивание, так что обновления модели дают половину (0,5) обычного эффекта.Авторы Pix2Pix рекомендуют это взвешивание обновлений модели, чтобы замедлить изменения дискриминатора по сравнению с моделью генератора во время обучения.

# определяем модель дискриминатора def define_discriminator (image_shape): # инициализация веса init = RandomNormal (стандартное отклонение = 0,02) # вход исходного изображения in_src_image = Вход (shape = image_shape) # ввод целевого изображения in_target_image = Вход (shape = image_shape) # объединить изображения по каналам merged = Concatenate () ([in_src_image, in_target_image]) # C64 d = Conv2D (64, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (объединено) d = LeakyReLU (альфа = 0.2) (г) # C128 d = Conv2D (128, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (d) d = BatchNormalization () (d) d = LeakyReLU (альфа = 0,2) (d) # C256 d = Conv2D (256, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (d) d = BatchNormalization () (d) d = LeakyReLU (альфа = 0,2) (d) # C512 d = Conv2D (512, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (d) d = BatchNormalization () (d) d = LeakyReLU (альфа = 0.2) (г) # второй последний выходной слой d = Conv2D (512, (4,4), padding = ‘same’, kernel_initializer = init) (d) d = BatchNormalization () (d) d = LeakyReLU (альфа = 0,2) (d) # вывод патча d = Conv2D (1, (4,4), padding = ‘same’, kernel_initializer = init) (d) patch_out = Активация (‘сигмоид’) (d) # определить модель model = Модель ([in_src_image, in_target_image], patch_out) # скомпилировать модель opt = Адам (lr = 0,0002, beta_1 = 0,5) model.compile (loss = ‘binary_crossentropy’, optimizer = opt, loss_weights = [0.5]) вернуть модель

Модель генератора сложнее модели дискриминатора.

Генератор представляет собой модель кодера-декодера, использующую архитектуру U-Net. Модель берет исходное изображение (например, спутниковое фото) и генерирует целевое изображение (например, изображение Google Maps). Для этого сначала используется понижающая дискретизация или кодирование входного изображения до уровня узкого места, а затем повышающая дискретизация или декодирование представления узкого места до размера выходного изображения. Архитектура U-Net означает, что между уровнями кодирования и соответствующими уровнями декодирования добавляются пропускные соединения, образуя U-образную форму.

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

Архитектура генератора U-Net модели
, взятая из преобразования изображения в изображение с помощью условно состязательных сетей

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

Функция define_generator () ниже реализует модель генератора кодера-декодера U-Net. Он использует вспомогательную функцию define_encoder_block () для создания блоков слоев для кодера и функцию decoder_block () для создания блоков слоев для декодера. В выходном слое используется функция активации tanh, что означает, что значения пикселей в сгенерированном изображении будут в диапазоне [-1,1].

# определить блок кодировщика def define_encoder_block (layer_in, n_filters, batchnorm = True): # инициализация веса init = RandomNormal (stddev = 0.02) # добавить слой понижающей дискретизации g = Conv2D (n_filters, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (layer_in) # условно добавить пакетную нормализацию если батчнорм: g = BatchNormalization () (g, обучение = True) # дырявая активация relu г = LeakyReLU (альфа = 0,2) (г) вернуть г # определяем блок декодера def decoder_block (layer_in, skip_in, n_filters, dropout = True): # инициализация веса init = RandomNormal (стандартное отклонение = 0,02) # добавить слой с повышенной дискретизацией g = Conv2DTranspose (n_filters, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (layer_in) # добавить пакетную нормализацию g = BatchNormalization () (g, обучение = True) # условно добавить отсев если бросил: g = выпадение (0.5) (g, обучение = True) # объединить с пропустить соединение g = Concatenate () ([g, skip_in]) # активация relu g = Активация (‘relu’) (g) вернуть г # определить модель автономного генератора def define_generator (image_shape = (256,256,3)): # инициализация веса init = RandomNormal (стандартное отклонение = 0,02) # ввод изображения in_image = Вход (shape = image_shape) # модель кодировщика e1 = define_encoder_block (in_image, 64, batchnorm = False) e2 = define_encoder_block (e1, 128) e3 = define_encoder_block (e2, 256) e4 = define_encoder_block (e3, 512) e5 = define_encoder_block (e4, 512) e6 = define_encoder_block (e5, 512) e7 = define_encoder_block (e6, 512) # бутылочное горлышко, нет норм партии и relu b = Conv2D (512, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (e7) b = Активация (‘relu’) (b) # модель декодера d1 = decoder_block (b, e7, 512) d2 = decoder_block (d1, e6, 512) d3 = decoder_block (d2, e5, 512) d4 = decoder_block (d3, e4, 512, dropout = False) d5 = decoder_block (d4, e3, 256, dropout = False) d6 = decoder_block (d5, e2, 128, dropout = False) d7 = decoder_block (d6, e1, 64, dropout = False) # выход g = Conv2DTranspose (3, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (d7) out_image = Активация (‘tanh’) (г) # определить модель model = Модель (in_image, out_image) вернуть модель

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

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

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

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

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

Функция define_gan () ниже реализует это, принимая уже определенные модели генератора и дискриминатора в качестве аргументов и используя функциональный API Keras для их соединения в составную модель. Обе функции потерь указаны для двух выходных данных модели, а веса, используемые для каждого, указаны в аргументе loss_weights функции compile () .

# определить комбинированную модель генератора и дискриминатора для обновления генератора def define_gan (g_model, d_model, image_shape): # сделать веса в дискриминаторе необучаемыми для слоя в d_model.слои: если не isinstance (слой, BatchNormalization): layer.trainable = Ложь # определяем исходное изображение in_src = Вход (shape = image_shape) # подключаем исходное изображение ко входу генератора gen_out = g_model (in_src) # подключить вход источника и выход генератора к входу дискриминатора dis_out = d_model ([in_src, gen_out]) # src image как вход, сгенерированное изображение и вывод классификации model = Модель (in_src, [dis_out, gen_out]) # скомпилировать модель opt = Адам (lr = 0.0002, beta_1 = 0,5) model.compile (loss = [‘binary_crossentropy’, ‘mae’], optimizer = opt, loss_weights = [1,100]) вернуть модель

Затем мы можем загрузить наш набор данных парных изображений в сжатом формате массива NumPy.

Это вернет список из двух массивов NumPy: первый для исходных изображений и второй для соответствующих целевых изображений.

# загрузить и подготовить обучающие изображения def load_real_samples (имя файла): # загружаем сжатые массивы данные = загрузка (имя файла) # распаковать массивы X1, X2 = данные [‘arr_0’], данные [‘arr_1’] # масштаб от [0,255] до [-1,1] Х1 = (Х1 — 127.5) / 127,5 Х2 = (Х2 — 127,5) / 127,5 возврат [X1, X2]

Для обучения дискриминатора потребуются пакеты реальных и поддельных изображений.

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

# выбираем партию случайных выборок, возвращаем изображения и выбираем def generate_real_samples (набор данных, n_samples, patch_shape): # распаковать набор данных trainA, trainB = набор данных # выбираем случайные экземпляры ix = randint (0, trainA.форма [0], n_samples) # получить выбранные изображения X1, X2 = поезд A [ix], поезд B [ix] # генерировать «настоящие» метки классов (1) y = единицы ((n_samples, patch_shape, patch_shape, 1)) return [X1, X2], y

Функция generate_fake_samples () ниже использует модель генератора и пакет реальных исходных изображений для создания эквивалентного пакета целевых изображений для дискриминатора.

Они возвращаются с меткой class-0, чтобы указать дискриминатору, что они поддельные.

# генерировать пакет изображений, возвращает изображения и цели def generate_fake_samples (g_model, samples, patch_shape): # создать поддельный экземпляр X = g_model.predict (образцы) # создать фальшивые метки классов (0) y = нули ((len (X), patch_shape, patch_shape, 1)) возврат X, y

Обычно модели GAN не сходятся; вместо этого находится равновесие между моделями генератора и дискриминатора. Таким образом, мы не можем легко судить, когда обучение должно быть остановлено. Следовательно, мы можем сохранить модель и использовать ее для периодического генерирования примеров преобразования изображения в изображение во время обучения, например, каждые 10 эпох обучения.

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

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

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

# сгенерировать образцы и сохранить как график и сохранить модель def summarize_performance (шаг, g_model, набор данных, n_samples = 3): # выбираем образец входных изображений [X_realA, X_realB], _ = generate_real_samples (набор данных, n_samples, 1) # создать партию поддельных образцов X_fakeB, _ = generate_fake_samples (g_model, X_realA, 1) # масштабировать все пиксели от [-1,1] до [0,1] X_realA = (X_realA + 1) / 2.0 X_realB = (X_realB + 1) / 2.0 X_fakeB = (X_fakeB + 1) / 2.0 # построить реальные исходные изображения для i в диапазоне (n_samples): pyplot.subplot (3, n_samples, 1 + i) pyplot.axis (‘выключено’) pyplot.imshow (X_realA [i]) # сюжет сгенерировал целевое изображение для i в диапазоне (n_samples): pyplot.subplot (3, n_samples, 1 + n_samples + i) pyplot.axis (‘выключено’) pyplot.imshow (X_fakeB [i]) # построить реальное целевое изображение для i в диапазоне (n_samples): пиплот.подзаговор (3, n_samples, 1 + n_samples * 2 + i) pyplot.axis (‘выключено’) pyplot.imshow (X_realB [i]) # сохранить график в файл filename1 = ‘plot_% 06d.png’% (шаг + 1) pyplot.savefig (имя_файла1) pyplot.close () # сохраняем модель генератора filename2 = ‘model_% 06d.h5’% (шаг + 1) g_model.save (имя_файла2) print (‘> Сохранено:% s и% s’% (имя_файла1, имя_файла2))

Наконец, мы можем обучить модели генератора и дискриминатора.

Функция train () ниже реализует это, принимая заданный генератор, дискриминатор, составную модель и загруженный набор данных в качестве входных данных. Количество эпох установлено на 100, чтобы сократить время обучения, хотя в статье использовалось 200. Размер партии 1 используется, как рекомендовано в статье.

Обучение включает фиксированное количество итераций обучения. В наборе обучающих данных 1097 изображений. Одна эпоха — это одна итерация по этому количеству примеров, при этом размер пакета, равный единице, означает 1097 шагов обучения. Генератор сохраняется и оценивается каждые 10 эпох или каждые 10970 обучающих шагов, а модель будет работать в течение 100 эпох, или всего 109 700 обучающих шагов.

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

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

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

# поезд pix2pix модель def train (d_model, g_model, gan_model, набор данных, n_epochs = 100, n_batch = 1): # определяем выходную квадратную форму дискриминатора n_patch = d_model.output_shape [1] # распаковать набор данных trainA, trainB = набор данных # подсчитываем количество пакетов за период обучения bat_per_epo = интервал (len (trainA) / n_batch) # рассчитываем количество итераций обучения n_steps = bat_per_epo * n_epochs # вручную перечислить эпохи для i в диапазоне (n_steps): # выбрать партию реальных образцов [X_realA, X_realB], y_real = generate_real_samples (набор данных, n_batch, n_patch) # создать партию поддельных образцов X_fakeB, y_fake = generate_fake_samples (g_model, X_realA, n_patch) # обновить дискриминатор для реальных образцов d_loss1 = d_model.train_on_batch ([X_realA, X_realB], y_real) # обновить дискриминатор для сгенерированных образцов d_loss2 = d_model.train_on_batch ([X_realA, X_fakeB], y_fake) # обновить генератор g_loss, _, _ = gan_model.train_on_batch (X_realA, [y_real, X_realB]) # подвести итоги print (‘>% d, d1 [%. 3f] d2 [%. 3f] g [%. 3f]’% (i + 1, d_loss1, d_loss2, g_loss)) # подвести итоги работы модели если (i + 1)% (bat_per_epo * 10) == 0: summarize_performance (я, g_model, набор данных)

Объединив все это вместе, ниже приведен полный пример кода для обучения Pix2Pix GAN преобразованию спутниковых фотографий в изображения Google Maps.

# пример pix2pix gan для спутника для преобразования изображения в изображение из numpy import load из numpy импортных нулей из множества импортных из numpy.random import randint от keras.optimizers импорт Адам из keras.initializers import RandomNormal из keras.models импорт модели from keras.models import Input из keras.layers импортировать Conv2D из keras.layers import Conv2DTranspose from keras.layers import LeakyReLU из кераса.активация импорта слоев из keras.layers import Concatenate из keras.layers import Dropout из keras.layers import BatchNormalization from keras.layers import LeakyReLU из matplotlib import pyplot # определяем модель дискриминатора def define_discriminator (image_shape): # инициализация веса init = RandomNormal (стандартное отклонение = 0,02) # вход исходного изображения in_src_image = Вход (shape = image_shape) # ввод целевого изображения in_target_image = Вход (shape = image_shape) # объединить изображения по каналам merged = Concatenate () ([in_src_image, in_target_image]) # C64 d = Conv2D (64, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (объединено) d = LeakyReLU (альфа = 0.2) (г) # C128 d = Conv2D (128, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (d) d = BatchNormalization () (d) d = LeakyReLU (альфа = 0,2) (d) # C256 d = Conv2D (256, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (d) d = BatchNormalization () (d) d = LeakyReLU (альфа = 0,2) (d) # C512 d = Conv2D (512, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (d) d = BatchNormalization () (d) d = LeakyReLU (альфа = 0.2) (г) # второй последний выходной слой d = Conv2D (512, (4,4), padding = ‘same’, kernel_initializer = init) (d) d = BatchNormalization () (d) d = LeakyReLU (альфа = 0,2) (d) # вывод патча d = Conv2D (1, (4,4), padding = ‘same’, kernel_initializer = init) (d) patch_out = Активация (‘сигмоид’) (d) # определить модель model = Модель ([in_src_image, in_target_image], patch_out) # скомпилировать модель opt = Адам (lr = 0,0002, beta_1 = 0,5) model.compile (loss = ‘binary_crossentropy’, optimizer = opt, loss_weights = [0.5]) модель возврата # определить блок кодировщика def define_encoder_block (layer_in, n_filters, batchnorm = True): # инициализация веса init = RandomNormal (стандартное отклонение = 0,02) # добавить слой понижающей дискретизации g = Conv2D (n_filters, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (layer_in) # условно добавить пакетную нормализацию если батчнорм: g = BatchNormalization () (g, обучение = True) # дырявая активация relu g = LeakyReLU (альфа = 0.2) (г) вернуть г # определяем блок декодера def decoder_block (layer_in, skip_in, n_filters, dropout = True): # инициализация веса init = RandomNormal (стандартное отклонение = 0,02) # добавить слой с повышенной дискретизацией g = Conv2DTranspose (n_filters, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (layer_in) # добавить пакетную нормализацию g = BatchNormalization () (g, обучение = True) # условно добавить отсев если бросил: g = выпадение (0,5) (g, обучение = верно) # объединить с пропустить соединение g = Concatenate () ([g, skip_in]) # активация relu g = Активация (‘relu’) (g) вернуть г # определить модель автономного генератора def define_generator (image_shape = (256,256,3)): # инициализация веса init = RandomNormal (stddev = 0.02) # ввод изображения in_image = Вход (shape = image_shape) # модель кодировщика e1 = define_encoder_block (in_image, 64, batchnorm = False) e2 = define_encoder_block (e1, 128) e3 = define_encoder_block (e2, 256) e4 = define_encoder_block (e3, 512) e5 = define_encoder_block (e4, 512) e6 = define_encoder_block (e5, 512) e7 = define_encoder_block (e6, 512) # бутылочное горлышко, нет норм партии и relu b = Conv2D (512, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (e7) b = Активация (‘relu’) (b) # модель декодера d1 = decoder_block (b, e7, 512) d2 = decoder_block (d1, e6, 512) d3 = decoder_block (d2, e5, 512) d4 = decoder_block (d3, e4, 512, dropout = False) d5 = decoder_block (d4, e3, 256, dropout = False) d6 = decoder_block (d5, e2, 128, dropout = False) d7 = decoder_block (d6, e1, 64, dropout = False) # выход g = Conv2DTranspose (3, (4,4), strides = (2,2), padding = ‘same’, kernel_initializer = init) (d7) out_image = Активация (‘tanh’) (г) # определить модель model = Модель (in_image, out_image) модель возврата # определить комбинированную модель генератора и дискриминатора для обновления генератора def define_gan (g_model, d_model, image_shape): # сделать веса в дискриминаторе необучаемыми для слоя в d_model.слои: если не isinstance (слой, BatchNormalization): layer.trainable = Ложь # определяем исходное изображение in_src = Вход (shape = image_shape) # подключаем исходное изображение ко входу генератора gen_out = g_model (in_src) # подключить вход источника и выход генератора к входу дискриминатора dis_out = d_model ([in_src, gen_out]) # src image как вход, сгенерированное изображение и вывод классификации model = Модель (in_src, [dis_out, gen_out]) # скомпилировать модель opt = Адам (lr = 0.0002, beta_1 = 0,5) model.compile (loss = [‘binary_crossentropy’, ‘mae’], optimizer = opt, loss_weights = [1,100]) модель возврата # загрузить и подготовить обучающие изображения def load_real_samples (имя файла): # загружаем сжатые массивы данные = загрузка (имя файла) # распаковать массивы X1, X2 = данные [‘arr_0’], данные [‘arr_1’] # масштаб от [0,255] до [-1,1] X1 = (X1 — 127,5) / 127,5 Х2 = (Х2 — 127,5) / 127,5 return [X1, X2] # выбираем партию случайных выборок, возвращаем изображения и выбираем def generate_real_samples (набор данных, n_samples, patch_shape): # распаковать набор данных trainA, trainB = набор данных # выбираем случайные экземпляры ix = randint (0, trainA.форма [0], n_samples) # получить выбранные изображения X1, X2 = поезд A [ix], поезд B [ix] # генерировать «настоящие» метки классов (1) y = единицы ((n_samples, patch_shape, patch_shape, 1)) return [X1, X2], y # генерировать пакет изображений, возвращает изображения и цели def generate_fake_samples (g_model, samples, patch_shape): # создать поддельный экземпляр X = g_model.predict (образцы) # создать фальшивые метки классов (0) y = нули ((len (X), patch_shape, patch_shape, 1)) вернуть X, y # сгенерировать образцы и сохранить как график и сохранить модель def summarize_performance (шаг, g_model, набор данных, n_samples = 3): # выбираем образец входных изображений [X_realA, X_realB], _ = generate_real_samples (набор данных, n_samples, 1) # создать партию поддельных образцов X_fakeB, _ = generate_fake_samples (g_model, X_realA, 1) # масштабировать все пиксели от [-1,1] до [0,1] X_realA = (X_realA + 1) / 2.0 X_realB = (X_realB + 1) / 2.0 X_fakeB = (X_fakeB + 1) / 2.0 # построить реальные исходные изображения для i в диапазоне (n_samples): pyplot.subplot (3, n_samples, 1 + i) pyplot.axis (‘выключено’) pyplot.imshow (X_realA [i]) # сюжет сгенерировал целевое изображение для i в диапазоне (n_samples): pyplot.subplot (3, n_samples, 1 + n_samples + i) pyplot.axis (‘выключено’) pyplot.imshow (X_fakeB [i]) # построить реальное целевое изображение для i в диапазоне (n_samples): пиплот.подзаговор (3, n_samples, 1 + n_samples * 2 + i) pyplot.axis (‘выключено’) pyplot.imshow (X_realB [i]) # сохранить график в файл filename1 = ‘plot_% 06d.png’% (шаг + 1) pyplot.savefig (имя_файла1) pyplot.close () # сохраняем модель генератора filename2 = ‘model_% 06d.h5’% (шаг + 1) g_model.save (имя_файла2) print (‘> Сохранено:% s и% s’% (имя_файла1, имя_файла2)) # поезд модели pix2pix def train (d_model, g_model, gan_model, набор данных, n_epochs = 100, n_batch = 1): # определяем выходную квадратную форму дискриминатора n_patch = d_model.output_shape [1] # распаковать набор данных trainA, trainB = набор данных # подсчитываем количество пакетов за период обучения bat_per_epo = интервал (len (trainA) / n_batch) # рассчитываем количество итераций обучения n_steps = bat_per_epo * n_epochs # вручную перечислить эпохи для i в диапазоне (n_steps): # выбрать партию реальных образцов [X_realA, X_realB], y_real = generate_real_samples (набор данных, n_batch, n_patch) # создать партию поддельных образцов X_fakeB, y_fake = generate_fake_samples (g_model, X_realA, n_patch) # обновить дискриминатор для реальных образцов d_loss1 = d_model.train_on_batch ([X_realA, X_realB], y_real) # обновить дискриминатор для сгенерированных образцов d_loss2 = d_model.train_on_batch ([X_realA, X_fakeB], y_fake) # обновить генератор g_loss, _, _ = gan_model.train_on_batch (X_realA, [y_real, X_realB]) # подвести итоги print (‘>% d, d1 [%. 3f] d2 [%. 3f] g [%. 3f]’% (i + 1, d_loss1, d_loss2, g_loss)) # подвести итоги работы модели если (i + 1)% (bat_per_epo * 10) == 0: summarize_performance (я, g_model, набор данных) # загрузить данные изображения набор данных = load_real_samples (‘maps_256.нпз ‘) print (‘Загружено’, набор данных [0] .shape, набор данных [1] .shape) # определить форму ввода на основе загруженного набора данных image_shape = набор данных [0] .shape [1:] # определить модели d_model = define_discriminator (image_shape) g_model = define_generator (image_shape) # определить составную модель gan_model = define_gan (g_model, d_model, image_shape) # модель поезда поезд (d_model, g_model, gan_model, набор данных)

Пример можно запустить на аппаратном обеспечении ЦП, хотя рекомендуется аппаратное обеспечение ГП.

Пример может занять около двух часов на современном оборудовании с графическим процессором.

Примечание : Ваши результаты могут отличаться из-за стохастической природы алгоритма или процедуры оценки или различий в числовой точности. Попробуйте запустить пример несколько раз и сравните средний результат.

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

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

> 1, d1 [0,566] d2 [0,520] г [82,266] > 2, d1 [0,469] d2 [0,484] г [66,813] > 3, d1 [0,428] d2 [0,477] г [79,520] > 4, d1 [0,362] d2 [0,405] г [78,143] > 5, d1 [0,416] d2 [0,406] г [72,452] … > 109596, d1 [0,303] d2 [0,006] г [5,792] > 109597, d1 [0,001] d2 [1,127] g [14.343] > 109598, d1 [0,000] d2 [0,381] г [11,851] > 109599, d1 [1,289] d2 [0,547] г [6,901] > 109600, d1 [0,437] d2 [0,005] г [10,460] > Сохранены: plot_109600.png и model_109600.h5

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

В конце прогона у вас будет 10 сохраненных файлов модели и 10 графиков сгенерированных изображений.

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

График спутника на карту Google, переведенные изображения с помощью Pix2Pix после 10 эпох обучения

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

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

График спутника на карту Google, переведенные изображения с помощью Pix2Pix после 100 эпох обучения

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

Как переводить изображения с помощью модели Pix2Pix

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

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

В этом случае мы будем использовать модель, сохраненную в конце прогона, например после 100 эпох или 109 600 итераций обучения.

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

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

# загрузить и подготовить обучающие изображения def load_real_samples (имя файла): # загрузить сжатые файлы данные = загрузка (имя файла) # распаковать массивы X1, X2 = данные [‘arr_0’], данные [‘arr_1’] # масштаб от [0,255] до [-1,1] Х1 = (Х1 — 127.5) / 127,5 Х2 = (Х2 — 127,5) / 127,5 возврат [X1, X2]

Эту функцию можно вызвать следующим образом:

… # загрузить набор данных [X1, X2] = load_real_samples (‘maps_256.npz’) print (‘Загружено’, X1.shape, X2.shape)

Затем мы можем загрузить сохраненную модель Keras.

… # модель нагрузки model = load_model (‘model_109600.h5’)

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

… # выбрать случайный пример ix = randint (0, len (X1), 1) src_image, tar_image = X1 [ix], X2 [ix]

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

… # генерировать изображение из источника gen_image = model.predict (src_image)

Наконец, мы можем построить исходное, сгенерированное изображение и ожидаемое целевое изображение.

Функция plot_images () ниже реализует это, обеспечивая красивый заголовок над каждым изображением.

# сюжетное исходное, сгенерированное и целевое изображения def plot_images (src_img, gen_img, tar_img): images = vstack ((src_img, gen_img, tar_img)) # масштаб от [-1,1] до [0,1] изображения = (изображения + 1) / 2.0 title = [‘Источник’, ‘Создано’, ‘Ожидается’] # построчно строить изображения для i в диапазоне (len (изображения)): # определить подзаговор pyplot.subplot (1, 3, 1 + я) # выключить ось pyplot.axis (‘выключено’) # построить необработанные данные пикселей pyplot.imshow (изображения [i]) # показать заголовок pyplot.title (заголовки [i]) pyplot.show ()

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

… # построить все три изображения plot_images (src_image, gen_image, tar_image)

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

# пример загрузки модели pix2pix и ее использования для преобразования изображения в изображение из кераса.модели импортировать load_model из numpy import load из numpy import vstack из matplotlib import pyplot из numpy.random import randint # загрузить и подготовить обучающие изображения def load_real_samples (имя файла): # загружаем сжатые массивы данные = загрузка (имя файла) # распаковать массивы X1, X2 = данные [‘arr_0’], данные [‘arr_1’] # масштаб от [0,255] до [-1,1] X1 = (X1 — 127,5) / 127,5 Х2 = (Х2 — 127,5) / 127,5 return [X1, X2] # сюжетное исходное, сгенерированное и целевое изображения def plot_images (src_img, gen_img, tar_img): images = vstack ((src_img, gen_img, tar_img)) # масштаб от [-1,1] до [0,1] изображения = (изображения + 1) / 2.0 title = [‘Источник’, ‘Создано’, ‘Ожидается’] # построчно строить изображения для i в диапазоне (len (изображения)): # определить подзаговор pyplot.subplot (1, 3, 1 + я) # выключить ось pyplot.axis (‘выключено’) # построить необработанные данные пикселей pyplot.imshow (изображения [i]) # показать заголовок pyplot.title (заголовки [i]) pyplot.show () # загрузить набор данных [X1, X2] = load_real_samples (‘maps_256.npz’) print (‘Загружено’, X1.shape, X2.shape) # модель нагрузки model = load_model (‘модель_109600.h5 ‘) # выбрать случайный пример ix = randint (0, len (X1), 1) src_image, tar_image = X1 [ix], X2 [ix] # генерировать изображение из источника gen_image = model.predict (src_image) # построить все три изображения plot_images (src_image, gen_image, tar_image)

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

Примечание : Ваши результаты могут отличаться из-за стохастической природы алгоритма или процедуры оценки или различий в числовой точности. Попробуйте запустить пример несколько раз и сравните средний результат.

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

График спутника для преобразования изображения карты Google с помощью окончательной модели Pix2Pix GAN

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

Мы можем выбрать изображение из набора данных проверки в разделе maps / val и обрезать спутниковый элемент изображения.Затем его можно сохранить и использовать в качестве входных данных для модели.

В этом случае мы будем использовать « maps / val / 1.jpg ».

Пример изображения из части проверки набора данных карт

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

Пример обрезанного спутникового изображения для использования в качестве входных данных для модели Pix2Pix.

Мы должны загрузить изображение как массив пикселей NumPy размером 256 × 256, изменить масштаб значений пикселей до диапазона [-1,1], а затем расширить размеры одного изображения, чтобы представить один входной образец.

Функция load_image () ниже реализует это, возвращая пиксели изображения, которые могут быть предоставлены непосредственно загруженной модели Pix2Pix.

# загрузить изображение def load_image (имя файла, размер = (256,256)): # загрузить изображение желаемого размера пикселей = load_img (имя файла, target_size = размер) # преобразовать в массив numpy пикселей = img_to_array (пиксели) # масштаб от [0,255] до [-1,1] пикселей = (пикселей — 127,5) / 127,5 # изменить форму до 1 образца пикселей = expand_dims (пикселей, 0) возврат пикселей

Затем мы можем загрузить наш обрезанный спутниковый снимок.

… # загрузить исходное изображение src_image = load_image (‘satellite.jpg’) print (‘Загружено’, src_image.shape)

Как и раньше, мы можем загрузить нашу сохраненную модель генератора Pix2Pix и сгенерировать перевод загруженного изображения.

… # модель нагрузки модель = load_model (‘модель_109600.h5’) # генерировать изображение из источника gen_image = model.predict (src_image)

Наконец, мы можем снова масштабировать значения пикселей до диапазона [0,1] и построить график результата.

… # масштаб от [-1,1] до [0,1] gen_image = (gen_image + 1) / 2.0 # построить изображение pyplot.imshow (gen_image [0]) pyplot.axis (‘выключено’) pyplot.show ()

Если объединить все это вместе, ниже приведен полный пример выполнения специального перевода изображения с одним файлом изображения.

# пример загрузки модели pix2pix и использования ее для одноразового перевода изображений из кераса.модели импортировать load_model из keras.preprocessing.image import img_to_array из keras.preprocessing.image import load_img из numpy import load из numpy import expand_dims из matplotlib import pyplot # загрузить изображение def load_image (имя файла, размер = (256,256)): # загрузить изображение желаемого размера пикселей = load_img (имя файла, target_size = размер) # преобразовать в массив numpy пикселей = img_to_array (пиксели) # масштаб от [0,255] до [-1,1] пикселей = (пикселей — 127.5) / 127,5 # изменить форму до 1 образца пикселей = expand_dims (пикселей, 0) вернуть пиксели # загрузить исходное изображение src_image = load_image (‘satellite.jpg’) print (‘Загружен’, src_image.shape) # модель нагрузки модель = load_model (‘модель_109600.h5’) # генерировать изображение из источника gen_image = model.predict (src_image) # масштаб от [-1,1] до [0,1] gen_image = (gen_image + 1) / 2.0 # построить изображение pyplot.imshow (gen_image [0]) pyplot.axis (‘выключено’) пиплот.показать ()

При выполнении примера загружается изображение из файла, создается его перевод и отображается результат.

Созданное изображение является разумным переводом исходного изображения.

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

Участок спутникового изображения, переведенный на карты Google с помощью окончательной модели Pix2Pix GAN

Как перевести карты Google на спутниковые изображения

Теперь, когда мы знакомы с тем, как разработать и использовать модель Pix2Pix для перевода спутниковых изображений на карты Google, мы можем также изучить обратное.

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

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

# загрузить и подготовить обучающие изображения def load_real_samples (имя файла): # загружаем сжатые массивы данные = загрузка (имя файла) # распаковать массивы X1, X2 = данные [‘arr_0’], данные [‘arr_1’] # масштаб от [0,255] до [-1,1] X1 = (X1 — 127,5) / 127,5 Х2 = (Х2 — 127.5) / 127,5 # возврат в обратном порядке возврат [X2, X1]

Примечание : порядок X1 и X2 обратный.

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

Выполните пример, как прежде.

Примечание : Ваши результаты могут отличаться из-за стохастической природы алгоритма или процедуры оценки или различий в числовой точности. Попробуйте запустить пример несколько раз и сравните средний результат.

Как и раньше, о потере модели сообщается на каждой итерации обучения. Если потери дискриминатора стремятся к нулю и остаются там в течение длительного времени, рассмотрите возможность перезапуска обучающего прогона, поскольку это пример неудачного обучения.

> 1, d1 [0,442] d2 [0,650] г [49,790] > 2, d1 [0,317] d2 [0,478] г [56,476] > 3, d1 [0,376] d2 [0,450] г [48,114] > 4, d1 [0,396] d2 [0,406] г [62,903] > 5, d1 [0,496] d2 [0,460] г [40,650] … > 109596, d1 [0.311] d2 [0,057] г [25,376] > 109597, d1 [0,028] d2 [0,070] г [16,618] > 109598, d1 [0,007] d2 [0,208] г [18,139] > 109599, d1 [0,358] d2 [0,076] г [22,494] > 109600, d1 [0,279] d2 [0,049] г [9,941] > Сохранены: plot_109600.png и model_109600.h5

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

График карты Google Map со спутниковым переводом изображений с помощью Pix2Pix после 10 эпох обучения

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

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

График карты Google на спутниковые изображения, переведенные с помощью Pix2Pix после 90 эпох обучения

Расширения

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

• Автономный спутник . Разработайте пример перевода автономных изображений карт Google в спутниковые изображения, как мы сделали для спутниковых изображений в карты Google.
• Новый образ . Найдите спутниковый снимок совершенно нового места, переведите его на карту Google и сравните результат с фактическим изображением на картах Google.
• Дополнительная подготовка . Продолжите обучение модели еще на 100 эпох и оцените, приведет ли дополнительное обучение к дальнейшему улучшению качества изображения.
• Увеличение изображения . Используйте небольшое увеличение изображения во время обучения, как описано в статье Pix2Pix, и оцените, приводит ли это к лучшему качеству сгенерированных изображений.

Если вы изучите какое-либо из этих расширений, я хотел бы знать.
Разместите свои выводы в комментариях ниже.

Дополнительная литература

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

Официальный

API

Сводка

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

В частности, вы выучили:

• Как загрузить и подготовить спутниковое изображение в набор данных преобразования изображения в изображение карт Google.
• Как разработать модель Pix2Pix для перевода спутниковых фотографий в изображения карты Google.
• Как использовать окончательную модель генератора Pix2Pix для перевода специальных спутниковых изображений.

Есть вопросы?
Задайте свои вопросы в комментариях ниже, и я постараюсь ответить.

Развивайте генеративные состязательные сети сегодня!

Разработайте модели GAN за считанные минуты

Узнайте, как это сделать, в моей новой электронной книге:
Генеративные состязательные сети с Python

Он предоставляет руководств для самообучения и сквозных проектов на:
DCGAN , условных GAN , перевод изображений , Pix2Pix , CycleGAN
и многое другое …

Наконец-то привнесите модели GAN в свои проекты Vision