复用 TensorFlow 模型

如果原始模型使用 TensorFlow 进行训练，则可以简单地将其恢复并在新任务上进行训练：

  1. [...] #  construct the original model
  1. with tf.Session() as sess:
  2.     saver.restore(sess, "./my_model_final.ckpt")
  3.     #  continue training the model...

完整代码:

  1. n_inputs = 28 * 28  #  MNIST
  2. n_hidden1 = 300
  3. n_hidden2 = 50
  4. n_hidden3 = 50
  5. n_hidden4 = 50
  6. n_outputs = 10
  8. X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
  9. y = tf.placeholder(tf.int64, shape=(None), name="y")
  11. with tf.name_scope("dnn"):
  12.     hidden1 = tf.layers.dense(X, n_hidden1, activation=tf.nn.relu, name="hidden1")
  13.     hidden2 = tf.layers.dense(hidden1, n_hidden2, activation=tf.nn.relu, name="hidden2")
  14.     hidden3 = tf.layers.dense(hidden2, n_hidden3, activation=tf.nn.relu, name="hidden3")
  15.     hidden4 = tf.layers.dense(hidden3, n_hidden4, activation=tf.nn.relu, name="hidden4")
  16.     hidden5 = tf.layers.dense(hidden4, n_hidden5, activation=tf.nn.relu, name="hidden5")
  17.     logits = tf.layers.dense(hidden5, n_outputs, name="outputs")
  19. with tf.name_scope("loss"):
  20.     xentropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=logits)
  21.     loss = tf.reduce_mean(xentropy, name="loss")
  23. with tf.name_scope("eval"):
  24.     correct = tf.nn.in_top_k(logits, y, 1)
  25.     accuracy = tf.reduce_mean(tf.cast(correct, tf.float32), name="accuracy")
  27. learning_rate = 0.01
  28. threshold = 1.0
  30. optimizer = tf.train.GradientDescentOptimizer(learning_rate)
  31. grads_and_vars = optimizer.compute_gradients(loss)
  32. capped_gvs = [(tf.clip_by_value(grad, -threshold, threshold), var)
  33.               for grad, var in grads_and_vars]
  34. training_op = optimizer.apply_gradients(capped_gvs)
  36. init = tf.global_variables_initializer()
  37. saver = tf.train.Saver()
  1. with tf.Session() as sess:
  2.     saver.restore(sess, "./my_model_final.ckpt")
  4.     for epoch in range(n_epochs):
  5.         for iteration in range(mnist.train.num_examples // batch_size):
  6.             X_batch, y_batch = mnist.train.next_batch(batch_size)
  7.             sess.run(training_op, feed_dict={X: X_batch, y: y_batch})
  8.         accuracy_val = accuracy.eval(feed_dict={X: mnist.test.images,
  9.                                                 y: mnist.test.labels})
  10.         print(epoch, "Test accuracy:", accuracy_val)
  12.     save_path = saver.save(sess, "./my_new_model_final.ckpt")

但是，一般情况下，您只需要重新使用原始模型的一部分（就像我们将要讨论的那样）。 一个简单的解决方案是将Saver配置为仅恢复原始模型中的一部分变量。 例如，下面的代码只恢复隐藏的层1,2和3：

  1. n_inputs = 28 * 28  #  MNIST
  2. n_hidden1 = 300 #  reused
  3. n_hidden2 = 50  #  reused
  4. n_hidden3 = 50  #  reused
  5. n_hidden4 = 20  #  new!
  6. n_outputs = 10  #  new!
  8. X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
  9. y = tf.placeholder(tf.int64, shape=(None), name="y")
  11. with tf.name_scope("dnn"):
  12.     hidden1 = tf.layers.dense(X, n_hidden1, activation=tf.nn.relu, name="hidden1")       #  reused
  13.     hidden2 = tf.layers.dense(hidden1, n_hidden2, activation=tf.nn.relu, name="hidden2") #  reused
  14.     hidden3 = tf.layers.dense(hidden2, n_hidden3, activation=tf.nn.relu, name="hidden3") #  reused
  15.     hidden4 = tf.layers.dense(hidden3, n_hidden4, activation=tf.nn.relu, name="hidden4") #  new!
  16.     logits = tf.layers.dense(hidden4, n_outputs, name="outputs")                         #  new!
  18. with tf.name_scope("loss"):
  19.     xentropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=logits)
  20.     loss = tf.reduce_mean(xentropy, name="loss")
  22. with tf.name_scope("eval"):
  23.     correct = tf.nn.in_top_k(logits, y, 1)
  24.     accuracy = tf.reduce_mean(tf.cast(correct, tf.float32), name="accuracy")
  26. with tf.name_scope("train"):
  27.     optimizer = tf.train.GradientDescentOptimizer(learning_rate)
  28.     training_op = optimizer.minimize(loss)
  1. [...] #  build new model with the same definition as before for hidden layers 1-3
  1. reuse_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
  2.                                scope="hidden[123]") #  regular expression
  3. reuse_vars_dict = dict([(var.op.name, var) for var in reuse_vars])
  4. restore_saver = tf.train.Saver(reuse_vars_dict) #  to restore layers 1-3
  6. init = tf.global_variables_initializer()
  7. saver = tf.train.Saver()
  9. with tf.Session() as sess:
  10.     init.run()
  11.     restore_saver.restore(sess, "./my_model_final.ckpt")
  13.     for epoch in range(n_epochs):                                      #  not shown in the book
  14.         for iteration in range(mnist.train.num_examples // batch_size): #  not shown
  15.             X_batch, y_batch = mnist.train.next_batch(batch_size)      #  not shown
  16.             sess.run(training_op, feed_dict={X: X_batch, y: y_batch})  #  not shown
  17.         accuracy_val = accuracy.eval(feed_dict={X: mnist.test.images,  #  not shown
  18.                                                 y: mnist.test.labels}) #  not shown
  19.         print(epoch, "Test accuracy:", accuracy_val)                   #  not shown
  21.     save_path = saver.save(sess, "./my_new_model_final.ckpt")

首先我们建立新的模型，确保复制原始模型的隐藏层 1 到 3。我们还创建一个节点来初始化所有变量。 然后我们得到刚刚用trainable = True（这是默认值）创建的所有变量的列表，我们只保留那些范围与正则表达式hidden [123]相匹配的变量（即，我们得到所有可训练的隐藏层 1 到 3 中的变量）。 接下来，我们创建一个字典，将原始模型中每个变量的名称映射到新模型中的名称（通常需要保持完全相同的名称）。 然后，我们创建一个Saver，它将只恢复这些变量，并且创建另一个Saver来保存整个新模型，而不仅仅是第 1 层到第 3 层。然后，我们开始一个会话并初始化模型中的所有变量，然后从原始模型的层 1 到 3中恢复变量值。最后，我们在新任务上训练模型并保存。

任务越相似，您可以重复使用的层越多（从较低层开始）。 对于非常相似的任务，您可以尝试保留所有隐藏的层，只替换输出层。