训练环境：Googlecolab训练时长：<15min论文地址：https://arxiv.org/abs/1508.06576

importosimg_dir='/tmp/nst'ifnotos.path.exists(img_dir):
os.makedirs(img_dir)
!wget--quiet-P/tmp/nst/https://upload.wikimedia.org/wikipedia/commons/d/d7/Green_Sea_Turtle_grazing_seagrass.jpg!wget--quiet-P/tmp/nst/https://upload.wikimedia.org/wikipedia/commons/0/0a/The_Great_Wave_off_Kanagawa.jpg!wget--quiet-P/tmp/nst/https://upload.wikimedia.org/wikipedia/commons/b/b4/Vassily_Kandinsky%2C_1913_-_Composition_7.jpg!wget--quiet-P/tmp/nst/https://upload.wikimedia.org/wikipedia/commons/0/00/Tuebingen_Neckarfront.jpg!wget--quiet-P/tmp/nst/https://upload.wikimedia.org/wikipedia/commons/6/68/Pillars_of_creation_2014_HST_WFC3-UVIS_full-res_denoised.jpg!wget--quiet-P/tmp/nst/https://upload.wikimedia.org/wikipedia/commons/thumb/e/ea/Van_Gogh_-_Starry_Night_-_Google_Art_Project.jpg/1024px-Van_Gogh_-_Starry_Night_-_Google_Art_Project.jpg!wget--quiet-P/tmp/nst/https://ucc.alicdn.com/images/user-upload-01/20210403204754742.jpg

importmatplotlib.pyplotaspltimportmatplotlibasmplmpl.rcParams['figure.figsize'] = (10,10)
mpl.rcParams['axes.grid'] =FalseimportnumpyasnpfromPILimportImageimporttimeimportfunctools

%tensorflow_version1.ximporttensorflowastffromtensorflow.python.keras.preprocessingimportimageaskp_imagefromtensorflow.python.kerasimportmodelsfromtensorflow.python.kerasimportlossesfromtensorflow.python.kerasimportlayersfromtensorflow.python.kerasimportbackendasK

tf.enable_eager_execution()
print("Eager execution: {}".format(tf.executing_eagerly()))

# Set up some global values herecontent_path='/tmp/nst/chongzi.jpg'style_path='/tmp/nst/The_Great_Wave_off_Kanagawa.jpg'

defload_img(path_to_img):
max_dim=512img=Image.open(path_to_img)
long=max(img.size)
scale=max_dim/longimg=img.resize((round(img.size[0]*scale), round(img.size[1]*scale)), Image.ANTIALIAS)
img=kp_image.img_to_array(img)
# We need to broadcast the image array such that it has a batch dimension img=np.expand_dims(img, axis=0)
returnimg

defimshow(img, title=None):
# Remove the batch dimensionout=np.squeeze(img, axis=0)
# Normalize for display out=out.astype('uint8')
plt.imshow(out)
iftitleisnotNone:
plt.title(title)
plt.imshow(out)

plt.figure(figsize=(10,10))
content=load_img(content_path).astype('uint8')
style=load_img(style_path).astype('uint8')
plt.subplot(1, 2, 1)
imshow(content, 'Content Image')
plt.subplot(1, 2, 2)
imshow(style, 'Style Image')
plt.show()

defload_and_process_img(path_to_img):
img=load_img(path_to_img)
img=tf.keras.applications.vgg19.preprocess_input(img)
returnimg

defdeprocess_img(processed_img):
x=processed_img.copy()
iflen(x.shape) ==4:
x=np.squeeze(x, 0)
assertlen(x.shape) ==3, ("Input to deprocess image must be an image of ""dimension [1, height, width, channel] or [height, width, channel]")
iflen(x.shape) !=3:
raiseValueError("Invalid input to deprocessing image")
# perform the inverse of the preprocessing stepx[:, :, 0] +=103.939x[:, :, 1] +=116.779x[:, :, 2] +=123.68x=x[:, :, ::-1]
x=np.clip(x, 0, 255).astype('uint8')
returnx

为什么需要中间层?为了让一个网络执行图像分类(我们的网络已经接受了这样的训练)，它必须理解图像。这涉及到将原始图像作为输入像素，并通过将原始图像像素转换为复杂的图像特性理解来构建内部表示。这也是卷积神经网络能够很好地泛化的部分原因:它们能够捕获类(例如，猫vs狗)中的不变性和定义特征，而这些不变性和定义特征对背景噪声和其他滋扰是不可知的。因此，在输入原始图像和输出分类标签之间的某个地方，模型充当一个复杂的特征提取器;因此，通过访问中间层，我们能够描述输入图像的内容和样式。具体来说，我们将从我们的网络中拉出这些中间层:

# Content layer where will pull our feature mapscontent_layers= ['block5_conv2'] 
# Style layer we are interested instyle_layers= ['block1_conv1',
'block2_conv1',
'block3_conv1', 
'block4_conv1', 
'block5_conv1'               ]
num_content_layers=len(content_layers)
num_style_layers=len(style_layers)

defget_model():
""" Creates our model with access to intermediate layers.   This function will load the VGG19 model and access the intermediate layers.   These layers will then be used to create a new model that will take input image  and return the outputs from these intermediate layers from the VGG model.   Returns:    returns a keras model that takes image inputs and outputs the style and       content intermediate layers.   """# Load our model. We load pretrained VGG, trained on imagenet datavgg=tf.keras.applications.vgg19.VGG19(include_top=False, weights='imagenet')
vgg.trainable=False# Get output layers corresponding to style and content layers style_outputs= [vgg.get_layer(name).outputfornameinstyle_layers]
content_outputs= [vgg.get_layer(name).outputfornameincontent_layers]
model_outputs=style_outputs+content_outputs# Build model returnmodels.Model(vgg.input, model_outputs)

defgram_matrix(input_tensor):
# We make the image channels first channels=int(input_tensor.shape[-1])
a=tf.reshape(input_tensor, [-1, channels])
n=tf.shape(a)[0]
gram=tf.matmul(a, a, transpose_a=True)
returngram/tf.cast(n, tf.float32)
defget_style_loss(base_style, gram_target):
"""Expects two images of dimension h, w, c"""# height, width, num filters of each layer# We scale the loss at a given layer by the size of the feature map and the number of filtersheight, width, channels=base_style.get_shape().as_list()
gram_style=gram_matrix(base_style)
returntf.reduce_mean(tf.square(gram_style-gram_target))# / (4. * (channels ** 2) * (width * height) ** 2)

defget_feature_representations(model, content_path, style_path):
"""Helper function to compute our content and style feature representations.  This function will simply load and preprocess both the content and style   images from their path. Then it will feed them through the network to obtain  the outputs of the intermediate layers.   Arguments:    model: The model that we are using.    content_path: The path to the content image.    style_path: The path to the style image  Returns:    returns the style features and the content features.   """# Load our images in content_image=load_and_process_img(content_path)
style_image=load_and_process_img(style_path)
# batch compute content and style featuresstyle_outputs=model(style_image)
content_outputs=model(content_image)
# Get the style and content feature representations from our model  style_features= [style_layer[0] forstyle_layerinstyle_outputs[:num_style_layers]]
content_features= [content_layer[0] forcontent_layerincontent_outputs[num_style_layers:]]
returnstyle_features, content_features

defcompute_loss(model, loss_weights, init_image, gram_style_features, content_features):
"""This function will compute the loss total loss.  Arguments:    model: The model that will give us access to the intermediate layers    loss_weights: The weights of each contribution of each loss function.       (style weight, content weight, and total variation weight)    init_image: Our initial base image. This image is what we are updating with       our optimization process. We apply the gradients wrt the loss we are       calculating to this image.    gram_style_features: Precomputed gram matrices corresponding to the       defined style layers of interest.    content_features: Precomputed outputs from defined content layers of       interest.  Returns:    returns the total loss, style loss, content loss, and total variational loss  """style_weight, content_weight=loss_weights# Feed our init image through our model. This will give us the content and # style representations at our desired layers. Since we're using eager# our model is callable just like any other function!model_outputs=model(init_image)
style_output_features=model_outputs[:num_style_layers]
content_output_features=model_outputs[num_style_layers:]
style_score=0content_score=0# Accumulate style losses from all layers# Here, we equally weight each contribution of each loss layerweight_per_style_layer=1.0/float(num_style_layers)
fortarget_style, comb_styleinzip(gram_style_features, style_output_features):
style_score+=weight_per_style_layer*get_style_loss(comb_style[0], target_style)
# Accumulate content losses from all layers weight_per_content_layer=1.0/float(num_content_layers)
fortarget_content, comb_contentinzip(content_features, content_output_features):
content_score+=weight_per_content_layer*get_content_loss(comb_content[0], target_content)
style_score*=style_weightcontent_score*=content_weight# Get total lossloss=style_score+content_scorereturnloss, style_score, content_score

defcompute_grads(cfg):
withtf.GradientTape() astape: 
all_loss=compute_loss(**cfg)
# Compute gradients wrt input imagetotal_loss=all_loss[0]
returntape.gradient(total_loss, cfg['init_image']), all_loss

importIPython.displaydefrun_style_transfer(content_path, 
style_path,
num_iterations=1000,
content_weight=1e3, 
style_weight=1e-2): 
# We don't need to (or want to) train any layers of our model, so we set their# trainable to false. model=get_model() 
forlayerinmodel.layers:
layer.trainable=False# Get the style and content feature representations (from our specified intermediate layers) style_features, content_features=get_feature_representations(model, content_path, style_path)
gram_style_features= [gram_matrix(style_feature) forstyle_featureinstyle_features]
# Set initial imageinit_image=load_and_process_img(content_path)
init_image=tf.Variable(init_image, dtype=tf.float32)
# Create our optimizeropt=tf.train.AdamOptimizer(learning_rate=5, beta1=0.99, epsilon=1e-1)
# For displaying intermediate images iter_count=1# Store our best resultbest_loss, best_img=float('inf'), None# Create a nice config loss_weights= (style_weight, content_weight)
cfg= {
'model': model,
'loss_weights': loss_weights,
'init_image': init_image,
'gram_style_features': gram_style_features,
'content_features': content_features  }
# For displayingnum_rows=2num_cols=5display_interval=num_iterations/(num_rows*num_cols)
start_time=time.time()
global_start=time.time()
norm_means=np.array([103.939, 116.779, 123.68])
min_vals=-norm_meansmax_vals=255-norm_meansimgs= []
foriinrange(num_iterations):
grads, all_loss=compute_grads(cfg)
loss, style_score, content_score=all_lossopt.apply_gradients([(grads, init_image)])
clipped=tf.clip_by_value(init_image, min_vals, max_vals)
init_image.assign(clipped)
end_time=time.time() 
ifloss<best_loss:
# Update best loss and best image from total loss. best_loss=lossbest_img=deprocess_img(init_image.numpy())
ifi%display_interval==0:
start_time=time.time()
# Use the .numpy() method to get the concrete numpy arrayplot_img=init_image.numpy()
plot_img=deprocess_img(plot_img)
imgs.append(plot_img)
IPython.display.clear_output(wait=True)
IPython.display.display_png(Image.fromarray(plot_img))
print('Iteration: {}'.format(i))        
print('Total loss: {:.4e}, ''style loss: {:.4e}, ''content loss: {:.4e}, ''time: {:.4f}s'.format(loss, style_score, content_score, time.time() -start_time))
print('Total time: {:.4f}s'.format(time.time() -global_start))
IPython.display.clear_output(wait=True)
plt.figure(figsize=(14,4))
fori,imginenumerate(imgs):
plt.subplot(num_rows,num_cols,i+1)
plt.imshow(img)
plt.xticks([])
plt.yticks([])
returnbest_img, best_loss

best, best_loss=run_style_transfer(content_path, style_path, num_iterations=1000)

defshow_results(best_img, content_path, style_path, show_large_final=True):
plt.figure(figsize=(10, 5))
content=load_img(content_path) 
style=load_img(style_path)
plt.subplot(1, 2, 1)
imshow(content, 'Content Image')
plt.subplot(1, 2, 2)
imshow(style, 'Style Image')
ifshow_large_final: 
plt.figure(figsize=(10, 10))
plt.imshow(best_img)
plt.title('Output Image')
plt.show()

show_results(best, content_path, style_path)