keras教程-n-图片风格转换理论和实践

import numpy as np
import tensorflow.contrib.keras.api.keras.backend as K
from scipy.misc import imsave, imresize
from scipy.optimize import fmin_l_bfgs_b
from tensorflow.contrib.keras.api.keras.applications import vgg19
from tensorflow.contrib.keras.api.keras.preprocessing.image import load_img, img_to_array
from IPython.display import Image

# 图片的高和宽
img_h = 80
img_w = 100

# 两张图片
CONTENT_IMG_PATH = './images/content.jpg'
STYLE_IMG_PATH = './images/style.jpg'

Image(filename=CONTENT_IMG_PATH, width='200', height='180')

Image(filename=STYLE_IMG_PATH, width='200', height='180')

def preprocess(img_path):
    img = load_img(img_path)
    img = img_to_array(img)
    # 图片缩放到设置的大小
    img = imresize(img, (img_h, img_w, 3))
    img = img.astype('float64')
    # 增加一个维度, 为了将三张图片在这个维度上合并
    img = np.expand_dims(img, axis=0)
    # 图片处理成vgg模型需要的
    img = vgg19.preprocess_input(img)
    return img


# 只是为了测试
print(preprocess(CONTENT_IMG_PATH).shape)

content_img = K.variable(preprocess(CONTENT_IMG_PATH))
style_img = K.variable(preprocess(STYLE_IMG_PATH))
gen_img = K.placeholder(shape=(1, img_h, img_w, 3))
# 注意: 三个图片构成一个输入张量, 而每个图像所在位置要记住
input_tensor = K.concatenate([content_img, style_img, gen_img], axis=0)

model = vgg19.VGG19(include_top=False, weights='imagenet', input_tensor=input_tensor)
print('Model loaded')

outputs_dict = dict([(layer.name, layer.output) for layer in model.layers])

outputs_dict

# 内容图片和生成图片的像素点数值的差的平方和
def content_loss(content, gen):
    return K.sum(K.square(gen-content))

# 内容损失权重
CONTENT_WEIGHT  = 0.025
# 初始损失值为0
loss = 0.
# 我们并不是选择最后一层作为输出层
# 因为我们希望提取的是一些基本特征, 比如直线/斜线等
# 而越靠后的层的特征越倾向于识别更宏观的特征, 比如眼睛
layer_features = outputs_dict['block5_conv2']
# 内容图片位于第一
content_img_features = layer_features[0, :, :, :]
# 生成的图片位于最后
gen_img_features = layer_features[2, :, :, :]
# 损失值是需要加权的
loss += CONTENT_WEIGHT * content_loss(content_img_features, gen_img_features)

def gram_matrix(x):
    assert K.ndim(x) == 3
    # 将一个3阶张量转变为2阶张量，其第一维度保留不变
    features = K.batch_flatten(K.permute_dimensions(x, (2, 0, 1)))
    gram = K.dot(features, K.transpose(features))
    return gram


def style_loss(style, gen):
    assert K.ndim(style) == 3
    assert K.ndim(gen) == 3
    S = gram_matrix(style)
    G = gram_matrix(gen)
    channels = 3
    size = img_h * img_w
    return K.sum(K.square(S - G)) / (4. * (channels ** 2) * (size ** 2))

# 注意加权
STYLE_WEIGHT = 1
feature_layer_names = ['block1_conv1', 'block2_conv1', 'block3_conv1', 'block4_conv1', 'block5_conv1']
for name in feature_layer_names:
    layer_features = outputs_dict[name]
    style_features = layer_features[1, :, :, :]
    gen_img_features = layer_features[2, :, :, :]
    s1 = style_loss(style_features, gen_img_features)
    loss += (STYLE_WEIGHT / len(feature_layer_names)) * s1

def total_variation_loss(x):
    assert K.ndim(x) == 4
    # 纵向 相邻像素点差值的平方
    a = K.square(x[:, :img_h - 1, :img_w - 1, :] - x[:, 1:, :img_w - 1, :])
    # 横向 相邻像素点差值的平方
    b = K.square(x[:, :img_h - 1, :img_w - 1, :] - x[:, :img_h - 1, 1:, :])
    return K.sum(K.pow(a + b, 1.25))

TV_WEIGHT = 1
loss += TV_WEIGHT * total_variation_loss(gen_img)

grads = K.gradients(loss, gen_img)

outputs = [loss]
if isinstance(grads, (list, tuple)):
    outputs += grads
else:
    outputs.append(grads)

f_output = K.function([gen_img], outputs)


def eval_loss_and_grads(x):
    x = x.reshape((1, img_h, img_w, 3))
    outs = f_output([x])
    loss_value = outs[0]
    if len(outs[1:]) == 1:
        grad_values = outs[1].flatten().astype('float64')
    else:
        grad_values = np.array(outs[1:]).flatten().astype('float64')
    return loss_value, grad_values


class Evaluator(object):
    def __init__(self):
        self.loss_value = None
        self.grads_value = None

    def loss(self, x):
        assert self.loss_value is None
        loss_value, grad_value = eval_loss_and_grads(x)
        self.loss_value = loss_value
        self.grads_value = grad_value
        return self.loss_value

    def grads(self, x):
        assert self.loss_value is not None
        grads_values = np.copy(self.grads_value)
        self.loss_value = None
        self.grads_value = None
        return grads_values

evaluator = Evaluator()

# Run L-BFGS optimizer
x = preprocess(CONTENT_IMG_PATH)

x, min_val, info = fmin_l_bfgs_b(evaluator.loss, x.flatten(), fprime=evaluator.grads, maxiter=100)
print('    loss: {}'.format(min_val))
# Save img
# print(x.reshape(img_h, img_w, 3))
img = x.reshape(img_h, img_w, 3)
imsave('./output/img0.jpg', img)

Image(filename = './output/img0.jpg')