TensorFlow 1.2 入门教程

TensorFlow 1.x 的核心思想是“先定义，后运行” (Define-and-Run)，你需要先构建一个完整的计算图，然后再创建一个会话来执行这个图中的计算。

核心概念

1. 图：计算图是 TensorFlow 的核心，它是一个包含所有计算（操作，Operation）和它们之间数据流（张量，Tensor）的抽象表示，你可以把它想象成一个电路图，操作是电路元件，张量是连接元件的电线。
2. 会话：图本身只是定义，不会进行任何计算，会话 是用来执行图中的操作并获取结果的运行环境，它拥有并管理 TensorFlow 程序的所有资源（如变量、张量等）。
3. 张量：TensorFlow 中的基本数据单位，可以理解为多维数组，它有一个类型（如 tf.float32）和一个形状（如 [10, 20]），在构建图时，我们操作的是这些“符号”张量，而不是具体的数值。
4. 变量：一种特殊的张量，其值可以在计算过程中被改变，通常用于存储模型的参数，如权重和偏置。
5. 占位符：也是特殊的张量，它们在图构建时是“空”的，只在运行图时通过 feed_dict 参数传入具体的值，这为模型提供了输入数据。

安装 TensorFlow 1.2

你需要确保你的环境中安装了 TensorFlow 1.2，由于版本较旧，建议使用虚拟环境。

# 创建一个虚拟环境 (推荐)
python -m venv tf1-env
source tf1-env/bin/activate  # Linux/Mac
# tf1-env\Scripts\activate   # Windows
# 安装 TensorFlow 1.2
pip install tensorflow==1.2.1

第一个程序：Hello, TensorFlow!

让我们从最简单的例子开始,感受一下 TensorFlow 1.x 的流程。

# 1. 导入 TensorFlow 库
import tensorflow as tf
# 2. 创建一个计算图
# 在 TensorFlow 1.x 中，所有操作都会被添加到默认的图 中
# 创建两个常量节点
a = tf.constant(5, name="a")
b = tf.constant(3, name="b")
# 创建一个加法操作节点
c = tf.add(a, b, name="c")
# 3. 创建一个会话来运行图
with tf.Session() as sess:
    # 4. 执行计算并获取结果
    result = sess.run(c)
    # 打印结果
    print("a + b =", result)
# 5. 关闭会话
# 'with' 语句会自动处理会话的关闭

代码解析：

1. import tensorflow as tf: 导入库。
2. a = tf.constant(...): 创建一个值为 5 的常量张量。a 还不是一个数字，而是一个指向图中的“常量操作”的句柄。
3. c = tf.add(a, b): 创建一个加法操作，它的输入是 a 和 b。c 也是一个句柄。
4. with tf.Session() as sess:: 创建一个会话对象 sess。with 语句确保会话在使用完毕后被正确关闭。
5. result = sess.run(c): 这是执行的关键。sess.run(c) 会运行图中的所有必要操作来计算 c 的值，并将结果返回给 Python 变量 result。
6. print(...): 打印最终结果。

线性回归模型

这是机器学习入门的经典例子,我们将用 TensorFlow 1.2 来实现一个简单的线性回归 y = Wx + b。

目标

根据一些数据点 (x, y)，找到最佳的权重 W 和偏置 b，使得模型预测值尽可能接近真实值。

完整代码

import tensorflow as tf
import numpy as np
# 1. 准备数据
# 使用 NumPy 生成一些模拟数据
X_train = np.linspace(-1, 1, 100)
y_train = 2 * X_train + np.random.randn(*X_train.shape) * 0.3 # y = 2x + noise
# 2. 定义模型参数 (变量)
# 这些值会在训练过程中被不断更新
# 使用 tf.get_variable 可以更好地管理变量，并支持变量初始化
W = tf.get_variable("W", shape=[1], initializer=tf.random_normal_initializer())
b = tf.get_variable("b", shape=[1], initializer=tf.random_normal_initializer())
# 3. 定义模型输入和预测 (占位符和操作)
# 占位符用于在运行时输入数据
X_ph = tf.placeholder(tf.float32, name="X_placeholder")
y_ph = tf.placeholder(tf.float32, name="y_placeholder")
# 模型的预测值
y_pred = W * X_ph + b
# 4. 定义损失函数
# 使用均方误差
loss = tf.reduce_mean(tf.square(y_pred - y_ph))
# 5. 定义优化器
# 使用梯度下降法来最小化损失
# 学习率设为 0.1
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(loss)
# 6. 初始化变量
# 在运行任何操作之前，必须初始化所有变量
init = tf.global_variables_initializer()
# 7. 创建会话并运行训练
with tf.Session() as sess:
    # 执行初始化操作
    sess.run(init)
    # 设置训练参数
    training_epochs = 200
    display_step = 20
    print("开始训练...")
    for epoch in range(training_epochs):
        # 在每个 epoch 中，我们用所有的训练数据来更新一次参数
        sess.run(optimizer, feed_dict={X_ph: X_train, y_ph: y_train})
        # 每 20 个 epoch 打印一次损失和当前的 W, b 值
        if (epoch + 1) % display_step == 0:
            current_loss, current_W, current_b = sess.run([loss, W, b], feed_dict={X_ph: X_train, y_ph: y_train})
            print(f"Epoch {epoch+1}/{training_epochs}, Loss={current_loss:.4f}, W={current_W[0]:.4f}, b={current_b[0]:.4f}")
    # 8. 训练完成后，获取最终的模型参数
    final_W, final_b = sess.run([W, b])
    print("\n训练完成!")
    print(f"最终的 W = {final_W[0]:.4f}, b = {final_b[0]:.4f}")
    # (可选) 使用训练好的模型进行预测
    test_X = 0.5
    predicted_y = final_W[0] * test_X + final_b[0]
    print(f"当 x = {test_X} 时，预测的 y = {predicted_y:.4f}")

代码解析：

1. 数据准备：使用 numpy 创建模拟数据，y 是 2*x 加上一些随机噪声。
2. 定义变量：W 和 b 是我们想学习的参数，我们使用 tf.get_variable 来创建它们，并指定初始值为随机分布。tf.Variable 也可以达到同样效果。
3. 定义占位符：X_ph 和 y_ph 是模型的输入接口，它们在图构建时是空的，在 sess.run 时通过 feed_dict 传入实际的训练数据 X_train 和 y_train。
4. 定义模型和损失：y_pred 是模型的预测输出。loss 是衡量预测与真实值差距的均方误差。
5. 定义优化器：tf.train.GradientDescentOptimizer 是梯度下降优化器。.minimize(loss) 会自动计算 loss 相对于所有变量（W, b）的梯度，并更新它们的值，以使 loss 变小。
6. 初始化：tf.global_variables_initializer() 创建了一个操作，这个操作会初始化图中所有的变量（W, b），必须在 sess.run 中执行它。
7. 训练循环：
   • for epoch in range(training_epochs): 循环训练指定的次数。
   • sess.run(optimizer, feed_dict={...}): 这是训练的核心，它执行一步优化操作，并从 feed_dict 中获取输入数据。
   • sess.run([loss, W, b], ...): 在训练过程中，我们定期运行 loss, W, b 来监控训练进度。
8. 获取结果：训练结束后，再次运行 sess.run([W, b]) 来获取最终学到的参数。

TensorBoard 可视化 (TensorFlow 1.2)

TensorFlow 1.x 集成了 TensorBoard，这是一个强大的可视化工具，可以帮助你理解图的结构和训练过程。

修改代码以支持 TensorBoard

我们只需要在代码中添加一些“操作即可。

# ... (前面的代码保持不变，直到定义损失函数之后)
# 4. 定义损失函数
loss = tf.reduce_mean(tf.square(y_pred - y_ph))
# 5. 为 TensorBoard 添加摘要tf.summary.scalar("loss", loss)
# 参数 W 和 b 的直方图摘要
tf.summary.histogram("W", W)
tf.summary.histogram("b", b)
# 6. 合并所有摘要
merged_summary_op = tf.summary.merge_all()
# 7. 定义优化器
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(loss)
# 8. 初始化变量
init = tf.global_variables_initializer()
# 9. 创建会话并运行训练
with tf.Session() as sess:
    # 创建一个写入器，用于将日志写入指定目录
    summary_writer = tf.summary.FileWriter("./logs", graph=sess.graph)
    # 执行初始化操作
    sess.run(init)
    # ... (训练循环)
    training_epochs = 200
    display_step = 20
    print("开始训练...")
    for epoch in range(training_epochs):
        # 运行优化器和摘要操作
        _, summary, current_loss = sess.run([optimizer, merged_summary_op, loss], feed_dict={X_ph: X_train, y_ph: y_train})
        # 将摘要写入 TensorBoard
        summary_writer.add_summary(summary, epoch)
        if (epoch + 1) % display_step == 0:
            print(f"Epoch {epoch+1}/{training_epochs}, Loss={current_loss:.4f}")
    # ... (后续代码保持不变)
# 关闭写入器
summary_writer.close()

如何运行 TensorBoard

1. 在终端中,确保你的虚拟环境已激活。
2. 运行以下命令,告诉 TensorBoard 去哪个目录读取日志：

   tensorboard --logdir=./logs

3. 打开浏览器,访问 http://localhost:6006，你就可以看到 TensorBoard 界面，包括图结构和标量数据（如 loss）的变化曲线。

总结与 TensorFlow 2.x 的对比

给新手的建议：

• 如果你是初学者：强烈建议直接学习 TensorFlow 2.x，它的 API 更简洁，学习曲线更平缓，更符合现代编程习惯。
• 为什么学习 1.x：如果你需要维护旧的 1.x 项目，或者想深入了解 TensorFlow 的底层工作原理（如计算图），那么学习 1.x 是有价值的。

希望这份教程能帮助你顺利上手 TensorFlow 1.2！