신경 스타일 전송

import os

os.environ["KERAS_BACKEND"] = "tensorflow"

import keras
import numpy as np
import tensorflow as tf
from keras.applications import vgg19

base_image_path = keras.utils.get_file("paris.jpg", "https://i.imgur.com/F28w3Ac.jpg")
style_reference_image_path = keras.utils.get_file(
    "starry_night.jpg", "https://i.imgur.com/9ooB60I.jpg"
)
result_prefix = "paris_generated"

# 각 손실 요소들의 가중치
total_variation_weight = 1e-6
style_weight = 1e-6
content_weight = 2.5e-8

# 생성된 이미지의 크기.
width, height = keras.utils.load_img(base_image_path).size
img_nrows = 400
img_ncols = int(width * img_nrows / height)

from IPython.display import Image, display

display(Image(base_image_path))
display(Image(style_reference_image_path))

def preprocess_image(image_path):
    # 이미지를 열고, 크기를 조정하고, 적절한 텐서로 포맷(형식 변환)하는 유틸리티 함수
    img = keras.utils.load_img(image_path, target_size=(img_nrows, img_ncols))
    img = keras.utils.img_to_array(img)
    img = np.expand_dims(img, axis=0)
    img = vgg19.preprocess_input(img)
    return tf.convert_to_tensor(img)


def deprocess_image(x):
    # 텐서를 유효한 이미지로 변환하는 유틸리티 함수
    x = x.reshape((img_nrows, img_ncols, 3))
    # 평균 픽셀값으로부터 영점 중심(zero-center) 제거
    x[:, :, 0] += 103.939
    x[:, :, 1] += 116.779
    x[:, :, 2] += 123.68
    # 'BGR'->'RGB'
    x = x[:, :, ::-1]
    x = np.clip(x, 0, 255).astype("uint8")
    return x

# 이미지 텐서의 gram matrix (특성 간 외적(outer product))


def gram_matrix(x):
    x = tf.transpose(x, (2, 0, 1))
    features = tf.reshape(x, (tf.shape(x)[0], -1))
    gram = tf.matmul(features, tf.transpose(features))
    return gram


# "style loss"는 참조 이미지의 스타일을 생성된 이미지에서 유지하기 위해 설계되었습니다.
# 이는 스타일 참조 이미지와 생성된 이미지의
# 특성 맵에서 gram matrices(스타일을 포착하는)을 기반으로 합니다.


def style_loss(style, combination):
    S = gram_matrix(style)
    C = gram_matrix(combination)
    channels = 3
    size = img_nrows * img_ncols
    return tf.reduce_sum(tf.square(S - C)) / (4.0 * (channels**2) * (size**2))


# 생성된 이미지에 베이스 이미지의 "콘텐츠"를 유지하도록 설계된 보조 손실 함수


def content_loss(base, combination):
    return tf.reduce_sum(tf.square(combination - base))


# 세 번째 손실 함수, 총 변동 손실(total variation loss),
# 생성된 이미지가 로컬에서 일관성을 유지하도록 설계되었습니다.


def total_variation_loss(x):
    a = tf.square(
        x[:, : img_nrows - 1, : img_ncols - 1, :] - x[:, 1:, : img_ncols - 1, :]
    )
    b = tf.square(
        x[:, : img_nrows - 1, : img_ncols - 1, :] - x[:, : img_nrows - 1, 1:, :]
    )
    return tf.reduce_sum(tf.pow(a + b, 1.25))

# 사전 트레이닝된 ImageNet 가중치로 로드된 VGG19 모델을 빌드합니다.
model = vgg19.VGG19(weights="imagenet", include_top=False)

# 각 "key" 레이어의 상징적인 출력값을 가져옵니다. (고유한 이름을 부여했습니다)
outputs_dict = dict([(layer.name, layer.output) for layer in model.layers])

# VGG19의 모든 레이어에 대해 활성화 값을 반환하는 모델을 설정합니다. (dict로)
feature_extractor = keras.Model(inputs=model.inputs, outputs=outputs_dict)

# 스타일 손실에 사용할 레이어 목록
style_layer_names = [
    "block1_conv1",
    "block2_conv1",
    "block3_conv1",
    "block4_conv1",
    "block5_conv1",
]
# 콘텐츠 손실에 사용할 레이어
content_layer_name = "block5_conv2"


def compute_loss(combination_image, base_image, style_reference_image):
    input_tensor = tf.concat(
        [base_image, style_reference_image, combination_image], axis=0
    )
    features = feature_extractor(input_tensor)

    # 손실 초기화
    loss = tf.zeros(shape=())

    # 콘텐츠 손실 추가
    layer_features = features[content_layer_name]
    base_image_features = layer_features[0, :, :, :]
    combination_features = layer_features[2, :, :, :]
    loss = loss + content_weight * content_loss(
        base_image_features, combination_features
    )

    # 스타일 손실 추가
    for layer_name in style_layer_names:
        layer_features = features[layer_name]
        style_reference_features = layer_features[1, :, :, :]
        combination_features = layer_features[2, :, :, :]
        sl = style_loss(style_reference_features, combination_features)
        loss += (style_weight / len(style_layer_names)) * sl

    # 전체 변화 손실 추가
    loss += total_variation_weight * total_variation_loss(combination_image)
    return loss

@tf.function
def compute_loss_and_grads(combination_image, base_image, style_reference_image):
    with tf.GradientTape() as tape:
        loss = compute_loss(combination_image, base_image, style_reference_image)
    grads = tape.gradient(loss, combination_image)
    return loss, grads

optimizer = keras.optimizers.SGD(
    keras.optimizers.schedules.ExponentialDecay(
        initial_learning_rate=100.0, decay_steps=100, decay_rate=0.96
    )
)

base_image = preprocess_image(base_image_path)
style_reference_image = preprocess_image(style_reference_image_path)
combination_image = tf.Variable(preprocess_image(base_image_path))

iterations = 4000
for i in range(1, iterations + 1):
    loss, grads = compute_loss_and_grads(
        combination_image, base_image, style_reference_image
    )
    optimizer.apply_gradients([(grads, combination_image)])
    if i % 100 == 0:
        print("Iteration %d: loss=%.2f" % (i, loss))
        img = deprocess_image(combination_image.numpy())
        fname = result_prefix + "_at_iteration_%d.png" % i
        keras.utils.save_img(fname, img)

display(Image(result_prefix + "_at_iteration_4000.png"))