保存和恢复模型

一旦你训练了你的模型，你应该把它的参数保存到磁盘，所以你可以随时随地回到它，在另一个程序中使用它，与其他模型比较，等等。 此外，您可能希望在训练期间定期保存检查点，以便如果您的计算机在训练过程中崩溃，您可以从上次检查点继续进行，而不是从头开始。

TensorFlow 可以轻松保存和恢复模型。 只需在构造阶段结束（创建所有变量节点之后）创建一个保存节点; 那么在执行阶段，只要你想保存模型，只要调用它的save()方法:

  1. [...]
  2. theta = tf.Variable(tf.random_uniform([n + 1, 1], -1.0, 1.0), name="theta")
  3. [...]
  4. init = tf.global_variables_initializer()
  5. saver = tf.train.Saver()
  6. with tf.Session() as sess:
  7.     sess.run(init)
  9.     for epoch in range(n_epochs):
  10.         if epoch % 100 == 0: #  checkpoint every 100 epochs
  11.             save_path = saver.save(sess, "/tmp/my_model.ckpt")
  13.         sess.run(training_op)
  14.     best_theta = theta.eval()
  15.     save_path = saver.save(sess, "/tmp/my_model_final.ckpt")

恢复模型同样容易：在构建阶段结束时创建一个保存器，就像之前一样，但是在执行阶段的开始，而不是使用init节点初始化变量，你可以调用restore()方法 的保存器对象：

  1. with tf.Session() as sess:
  2.     saver.restore(sess, "/tmp/my_model_final.ckpt")
  3.     [...]

默认情况下，保存器将以自己的名称保存并还原所有变量，但如果需要更多控制，则可以指定要保存或还原的变量以及要使用的名称。 例如，以下保存器将仅保存或恢复theta变量，它的键名称是weights：

  1. saver = tf.train.Saver({"weights": theta})

完整代码

  1.  numpy as np
  2. from sklearn.datasets import fetch_california_housing
  3. import tensorflow as tf
  4. from sklearn.preprocessing import StandardScaler
  6. housing = fetch_california_housing()
  7. m, n = housing.data.shape
  8. print("数据集:{}行,{}列".format(m,n))
  9. housing_data_plus_bias = np.c_[np.ones((m, 1)), housing.data]
  10. scaler = StandardScaler()
  11. scaled_housing_data = scaler.fit_transform(housing.data)
  12. scaled_housing_data_plus_bias = np.c_[np.ones((m, 1)), scaled_housing_data]
  14. n_epochs = 1000  #  not shown in the book
  15. learning_rate = 0.01  #  not shown
  17. X = tf.constant(scaled_housing_data_plus_bias, dtype=tf.float32, name="X")  #  not shown
  18. y = tf.constant(housing.target.reshape(-1, 1), dtype=tf.float32, name="y")  #  not shown
  19. theta = tf.Variable(tf.random_uniform([n + 1, 1], -1.0, 1.0, seed=42), name="theta")
  20. y_pred = tf.matmul(X, theta, name="predictions")  #  not shown
  21. error = y_pred - y  #  not shown
  22. mse = tf.reduce_mean(tf.square(error), name="mse")  #  not shown
  23. optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)  #  not shown
  24. training_op = optimizer.minimize(mse)  #  not shown
  26. init = tf.global_variables_initializer()
  27. saver = tf.train.Saver()
  29. with tf.Session() as sess:
  30.     sess.run(init)
  32.     for epoch in range(n_epochs):
  33.         if epoch % 100 == 0:
  34.             print("Epoch", epoch, "MSE =", mse.eval())  #  not shown
  35.             save_path = saver.save(sess, "/tmp/my_model.ckpt")
  36.         sess.run(training_op)
  38.     best_theta = theta.eval()
  39.     save_path = saver.save(sess, "/tmp/my_model_final.ckpt") # 找到tmp文件夹就找到文件了

使用 TensorBoard 展现图形和训练曲线

所以现在我们有一个使用小批量梯度下降训练线性回归模型的计算图谱，我们正在定期保存检查点。 听起来很复杂，不是吗？ 然而，我们仍然依靠print()函数可视化训练过程中的进度。 有一个更好的方法：进入 TensorBoard。如果您提供一些训练统计信息，它将在您的网络浏览器中显示这些统计信息的良好交互式可视化（例如学习曲线）。 您还可以提供图形的定义，它将为您提供一个很好的界面来浏览它。 这对于识别图中的错误，找到瓶颈等是非常有用的。

第一步是调整程序，以便将图形定义和一些训练统计信息（例如，training_error（MSE））写入 TensorBoard 将读取的日志目录。 您每次运行程序时都需要使用不同的日志目录，否则 TensorBoard 将会合并来自不同运行的统计信息，这将会混乱可视化。 最简单的解决方案是在日志目录名称中包含时间戳。 在程序开头添加以下代码：

  1. from datetime import datetime
  2. now = datetime.utcnow().strftime("%Y%m%d%H%M%S")
  3. root_logdir = "tf_logs"
  4. logdir = "{}/run-{}/".format(root_logdir, now)

接下来，在构建阶段结束时添加以下代码：

  1. mse_summary = tf.summary.scalar('MSE', mse)
  2. file_writer = tf.summary.FileWriter(logdir, tf.get_default_graph())

第一行创建一个节点，这个节点将求出 MSE 值并将其写入 TensorBoard 兼容的二进制日志字符串（称为摘要）中。 第二行创建一个FileWriter，您将用它来将摘要写入日志目录中的日志文件中。 第一个参数指示日志目录的路径（在本例中为tf_logs/run-20160906091959/，相对于当前目录）。 第二个（可选）参数是您想要可视化的图形。 创建时，文件写入器创建日志目录（如果需要），并将其定义在二进制日志文件（称为事件文件）中。

接下来，您需要更新执行阶段，以便在训练期间定期求出mse_summary节点（例如，每 10 个小批量）。 这将输出一个摘要，然后可以使用file_writer写入事件文件。 以下是更新的代码：

  1. [...]
  2. for batch_index in range(n_batches):
  3.     X_batch, y_batch = fetch_batch(epoch, batch_index, batch_size)
  4.     if batch_index % 10 == 0:
  5.         summary_str = mse_summary.eval(feed_dict={X: X_batch, y: y_batch})
  6.         step = epoch * n_batches + batch_index
  7.         file_writer.add_summary(summary_str, step)
  8.     sess.run(training_op, feed_dict={X: X_batch, y: y_batch})
  9. [...]

避免在每一个训练阶段记录训练数据，因为这会大大减慢训练速度（以上代码每 10 个小批量记录一次）.

最后，要在程序结束时关闭FileWriter：

  1. file_writer.close()

完整代码

  1. import numpy as np
  2. from sklearn.datasets import fetch_california_housing
  3. import tensorflow as tf
  4. from sklearn.preprocessing import StandardScaler
  6. housing = fetch_california_housing()
  7. m, n = housing.data.shape
  8. print("数据集:{}行,{}列".format(m,n))
  9. housing_data_plus_bias = np.c_[np.ones((m, 1)), housing.data]
  10. scaler = StandardScaler()
  11. scaled_housing_data = scaler.fit_transform(housing.data)
  12. scaled_housing_data_plus_bias = np.c_[np.ones((m, 1)), scaled_housing_data]
  14. from datetime import datetime
  16. now = datetime.utcnow().strftime("%Y%m%d%H%M%S")
  17. root_logdir = r"D://tf_logs"
  18. logdir = "{}/run-{}/".format(root_logdir, now)
  19. n_epochs = 1000
  20. learning_rate = 0.01
  22. X = tf.placeholder(tf.float32, shape=(None, n + 1), name="X")
  23. y = tf.placeholder(tf.float32, shape=(None, 1), name="y")
  24. theta = tf.Variable(tf.random_uniform([n + 1, 1], -1.0, 1.0, seed=42), name="theta")
  25. y_pred = tf.matmul(X, theta, name="predictions")
  26. error = y_pred - y
  27. mse = tf.reduce_mean(tf.square(error), name="mse")
  28. optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
  29. training_op = optimizer.minimize(mse)
  31. init = tf.global_variables_initializer()
  32. mse_summary = tf.summary.scalar('MSE', mse)
  33. file_writer = tf.summary.FileWriter(logdir, tf.get_default_graph())
  35. n_epochs = 10
  36. batch_size = 100
  37. n_batches = int(np.ceil(m / batch_size))
  39. def fetch_batch(epoch, batch_index, batch_size):
  40.     np.random.seed(epoch * n_batches + batch_index)  #  not shown in the book
  41.     indices = np.random.randint(m, size=batch_size)  #  not shown
  42.     X_batch = scaled_housing_data_plus_bias[indices] #  not shown
  43.     y_batch = housing.target.reshape(-1, 1)[indices] #  not shown
  44.     return X_batch, y_batch
  46. with tf.Session() as sess:                                                        #  not shown in the book
  47.     sess.run(init)                                                                #  not shown
  49.     for epoch in range(n_epochs):                                                 #  not shown
  50.         for batch_index in range(n_batches):
  51.             X_batch, y_batch = fetch_batch(epoch, batch_index, batch_size)
  52.             if batch_index % 10 == 0:
  53.                 summary_str = mse_summary.eval(feed_dict={X: X_batch, y: y_batch})
  54.                 step = epoch * n_batches + batch_index
  55.                 file_writer.add_summary(summary_str, step)
  56.             sess.run(training_op, feed_dict={X: X_batch, y: y_batch})
  58.     best_theta = theta.eval()
  59. file_writer.close()
  60. print(best_theta)

保存和恢复模型 - 图1