机器学习进阶笔记之二 | 深入理解Neural Style

1. g = tf.Graph()
2. with g.as_default(), g.device(‘/cpu:0’), tf.Session() as sess:
3.     image = tf.placeholder('float', shape=shape)
4.     net, mean_pixel = vgg.net(network, image)
5.     content_pre = np.array([vgg.preprocess(content, mean_pixel)])
6.     content_features[CONTENT_LAYER] = net[CONTENT_LAYER].eval(
7.         feed_dict={image: content_pre})

　　这里会调用imagenet-vgg-verydeep-19.mat这个model，在这个基础上通过vgg里面的net构建前文当中提到的abcde那五个卷积层conv1_1, conv2_1, conv3_1, conv4_1, conv5_1，net每个不同的key表示对应的层，然后ceontent_pre得到经过model输出后再经过abcde后的content的的feature

•  for i in range(len(styles)):
•      g = tf.Graph()
•      with g.as_default(), g.device('/cpu:0'), tf.Session() as sess:
•          image = tf.placeholder('float', shape=style_shapes[i])
•          net, _ = vgg.net(network, image)
•          style_pre = np.array([vgg.preprocess(styles[i], mean_pixel)])
•          for layer in STYLE_LAYERS:
•              features = net[layer].eval(feed_dict={image: style_pre})
•              features = np.reshape(features, (-1, features.shape[3]))
•              gram = np.dot(features.T, features) / features.size
•              style_features[i][layer] = gram

　　这里和content的feature的计算一样，只不过，由于计算loss的方法不同（style loss 为total loss包括每一层输出的loss），因此CONTENT_LAYER = 'relu4_2'``STYLE_LAYERS = ('relu1_1', 'relu2_1', 'relu3_1', 'relu4_1', 'relu5_1').

　　然后就是最小化loss的过程：

1.  with tf.Graph().as_default():
2.      if initial is None:
3.          noise = np.random.normal(size=shape, scale=np.std(content) * 0.1)
4.          initial = tf.random_normal(shape) * 0.256
5.      else:
6.          initial = np.array([vgg.preprocess(initial, mean_pixel)])
7.          initial = initial.astype('float32')
8.      image = tf.Variable(initial)
9.      net, _ = vgg.net(network, image)
10. 
    
11.      # content loss
12.      content_loss = content_weight * (2 * tf.nn.l2_loss(
13.              net[CONTENT_LAYER] - content_features[CONTENT_LAYER]) /
14.              content_features[CONTENT_LAYER].size)
15.      # style loss
16.      style_loss = 0
17.      for i in range(len(styles)):
18.          style_losses = []
19.          for style_layer in STYLE_LAYERS:
20.              layer = net[style_layer]
21.              _, height, width, number = map(lambda i: i.value, layer.get_shape())
22.              size = height * width * number
23.              feats = tf.reshape(layer, (-1, number))
24.              gram = tf.matmul(tf.transpose(feats), feats) / size
25.              style_gram = style_features[i][style_layer]
26.              style_losses.append(2 * tf.nn.l2_loss(gram - style_gram) / style_gram.size)
27.          style_loss += style_weight * style_blend_weights[i] * reduce(tf.add, style_losses)
28.      # total variation denoising
29.      tv_y_size = _tensor_size(image[:,1:,:,:])
30.      tv_x_size = _tensor_size(image[:,:,1:,:])
31.      tv_loss = tv_weight * 2 * (
32.              (tf.nn.l2_loss(image[:,1:,:,:] - image[:,:shape[1]-1,:,:]) /
33.                  tv_y_size) +
34.              (tf.nn.l2_loss(image[:,:,1:,:] - image[:,:,:shape[2]-1,:]) /
35.                  tv_x_size))
36.      # overall loss
37.      loss = content_loss + style_loss + tv_loss
38. 
    
39.      # optimizer setup
40.      train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)

　　和上文中提到的公式一一对应，除了多了一个total variation denoising，定义好 total loss后调用AdamOptimizer来进行迭代计算，最小化loss注意这里的代码还是按像素点计算，并未向量化，所以看起来会有点头疼，后面如果更加熟悉tensorflow后，我再来这儿试图改改，看看能不能把这里计算的部分做稍微高效点。

　　如果想要详细了解这部分代码的童靴，可以clone这个项目下来，仔细研究研究，当做学习tensorflow。