3. Построение генератора.

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

5. Построение и компиляция GAN.

6. Обучение GAN.

7. Генерация изображений.

Пример кода:

```python

import tensorflow as tf

from tensorflow.keras import layers, models

import numpy as np

import os

import matplotlib.pyplot as plt

from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Шаг 1: Импорт библиотек

import tensorflow as tf

from tensorflow.keras import layers, models

import numpy as np

import matplotlib.pyplot as plt

import os

# Шаг 2: Подготовка данных

# Загрузка набора данных CelebA

# Этот пример предполагает, что данные находятся в папке 'img_align_celeba/img_align_celeba'

# Скачивание и подготовка данных не входит в код

DATA_DIR = 'img_align_celeba/img_align_celeba'

IMG_HEIGHT = 64

IMG_WIDTH = 64

BATCH_SIZE = 128

BUFFER_SIZE = 60000

def load_image(image_path):

image = tf.io.read_file(image_path)

image = tf.image.decode_jpeg(image, channels=3)

image = tf.image.resize(image, [IMG_HEIGHT, IMG_WIDTH])

image = (image – 127.5) / 127.5 # Нормализация изображений в диапазоне [-1, 1]

return image

def load_dataset(data_dir):

image_paths = [os.path.join(data_dir, img) for img in os.listdir(data_dir)]

image_dataset = tf.data.Dataset.from_tensor_slices(image_paths)

image_dataset = image_dataset.map(load_image, num_parallel_calls=tf.data.experimental.AUTOTUNE)

image_dataset = image_dataset.shuffle(BUFFER_SIZE).batch(BATCH_SIZE).prefetch(tf.data.experimental.AUTOTUNE)

return image_dataset

train_dataset = load_dataset(DATA_DIR)

# Шаг 3: Построение генератора

def build_generator():

model = models.Sequential()

model.add(layers.Dense(8 * 8 * 256, use_bias=False, input_shape=(100,)))

model.add(layers.BatchNormalization())

model.add(layers.LeakyReLU())

model.add(layers.Reshape((8, 8, 256)))

assert model.output_shape == (None, 8, 8, 256) # Убедитесь, что выходная форма такая

model.add(layers.Conv2DTranspose(128, (5, 5), strides=(2, 2), padding='same', use_bias=False))

model.add(layers.BatchNormalization())

model.add(layers.LeakyReLU())

assert model.output_shape == (None, 16, 16, 128)

model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))

model.add(layers.BatchNormalization())

model.add(layers.LeakyReLU())

assert model.output_shape == (None, 32, 32, 64)

model.add(layers.Conv2DTranspose(3, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))

assert model.output_shape == (None, 64, 64, 3)

return model

# Шаг 4: Построение дискриминатора

def build_discriminator():

model = models.Sequential()

model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same', input_shape=[64, 64, 3]))

model.add(layers.LeakyReLU())

model.add(layers.Dropout(0.3))

model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'))

model.add(layers.LeakyReLU())

model.add(layers.Dropout(0.3))

model.add(layers.Conv2D(256, (5, 5), strides=(2, 2), padding='same'))

model.add(layers.LeakyReLU())

model.add(layers.Dropout(0.3))

model.add(layers.Flatten())

model.add(layers.Dense(1, activation='sigmoid'))

return model

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

generator = build_generator()

discriminator = build_discriminator()

# Определение функции потерь и оптимизаторов

cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)

def discriminator_loss(real_output, fake_output):

real_loss = cross_entropy(tf.ones_like(real_output), real_output)

fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)

total_loss = real_loss + fake_loss

return total_loss

def generator_loss(fake_output):

return cross_entropy(tf.ones_like(fake_output), fake_output)

generator_optimizer = tf.keras.optimizers.Adam(1e-4)

discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)

# Шаг 5: Построение и компиляция GAN

@tf.function

def train_step(images):

noise = tf.random.normal([BATCH_SIZE, 100])

with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:

generated_images = generator(noise, training=True)

real_output = discriminator(images, training=True)

fake_output = discriminator(generated_images, training=True)

gen_loss = generator_loss(fake_output)

disc_loss = discriminator_loss(real_output, fake_output)

gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)

gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)

generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))

discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))

def train(dataset, epochs):

for epoch in range(epochs):

for image_batch in dataset:

train_step(image_batch)

print(f'Эпоха {epoch + 1} завершена')

# Генерация изображений в конце каждой эпохи

if (epoch + 1) % 10 == 0:

noise = tf.random.normal([16, 100])

generate_and_save_images(generator, epoch + 1, noise)

# Шаг 6: Обучение GAN

EPOCHS = 100

train(train_dataset, EPOCHS)

# Шаг 7: Генерация изображений

def generate_and_save_images(model, epoch, test_input):

predictions = model(test_input, training=False)

fig = plt.figure(figsize=(4, 4))

for i in range(predictions.shape[0]):

plt.subplot(4, 4, i+1)

plt.imshow((predictions[i] * 127.5 + 127.5).numpy().astype(np.uint8))

plt.axis('off')

plt.savefig(f'image_at_epoch_{epoch:04d}.png')

plt.show()

# Генерация изображений после обучения

noise = tf.random.normal([16, 100])

generate_and_save_images(generator, EPOCHS, noise)

```

Пояснение:

1. Импорт библиотек: Импортируются необходимые библиотеки TensorFlow, Keras, numpy и matplotlib.

2. Подготовка данных: Загружаются и подготавливаются данные CelebA. Изображения нормализуются в диапазоне [-1, 1].

3. Построение генератора:

– Генератор создает изображения из случайного шума. Он включает плотные слои, batch normalization и Conv2DTranspose слои для генерации изображений размером 64x64 пикселей.

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

– Дискриминатор оценивает, являются ли изображения реальными или сгенерированными. Он состоит из свёрточных слоев, слоев LeakyReLU и dropout для классификации изображений.

5. Построение и компиляция GAN:

– Генератор и дискриминатор объединяются в модель GAN. Определяются функции потерь и оптимизаторы для обеих моделей. Процедура `train_step` выполняет одну итерацию обучения GAN.

6. Обучение GAN:

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

7. Генерация изображений:

– После обучения GAN, создаются и сохраняются изображения, сгенерированные генератором.

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

– Задача: Создание REST API для модели.

Развертывание модели машинного обучения в продакшн включает создание REST API, который позволяет клиентам взаимодействовать с моделью через HTTP запросы. В этом примере мы будем использовать Flask, популярный веб-фреймворк на Python, для создания REST API, который может обрабатывать запросы на предсказание с использованием обученной модели.