TensorFlow 教程：基础介绍
前言
欢迎来到 TensorFlow 的世界！如果你对机器学习、深度学习或者人工智能充满好奇，那么 TensorFlow 是一个你绝对绕不过去的强大工具。它是一个由 Google 开发的开源软件库，旨在帮助开发者轻松构建和部署各种机器学习模型。
本教程旨在为你提供 TensorFlow 的基础入门知识，从它是什么，到它的核心概念（张量、操作、变量），再到如何在实际中构建一个简单的模型。我们将重点关注 TensorFlow 2.x 版本，因为它带来了更简洁、更直观的编程体验，特别是其默认开启的即时执行模式（Eager Execution）和对 Keras API 的深度整合。
阅读本教程后，你将对 TensorFlow 的基本工作原理有一个清晰的认识，并具备编写简单机器学习程序的能力，为进一步深入学习打下坚实的基础。
第一章：初识 TensorFlow
1.1 什么是 TensorFlow？
TensorFlow 是一个用于数值计算的开源软件库。虽然它在机器学习领域声名鹊起，被广泛应用于构建和训练神经网络，但其核心能力远不止于此。从数学运算、统计分析到复杂的物理模拟，只要涉及大量数值计算，TensorFlow 都能发挥作用。
它最初由 Google Brain 团队开发，用于 Google 内部的各种研究和生产任务。现在，作为一个开源项目，它拥有庞大的社区和丰富的生态系统，支持多种平台（桌面、服务器、移动设备、Web）和多种编程语言（Python、C++、Java、Go、JavaScript等），其中 Python 是最常用和最方便的接口。
1.2 TensorFlow 的核心思想：计算图 (Graph) 与 即时执行 (Eager Execution)
理解 TensorFlow 的工作方式，有两个关键概念：
- 计算图 (Computation Graph): TensorFlow 1.x 版本的主要工作模式是构建计算图。你首先定义一系列操作（Ops）和它们之间的依赖关系，形成一个有向图。这个图代表了你的计算流程。然后，你需要在一个“会话”（Session）中显式地运行这个图，才能得到结果。这种模式的好处是便于优化（可以在执行前对整个图进行静态优化）和跨平台部署，但缺点是编写和调试不够直观。
- 即时执行 (Eager Execution): TensorFlow 2.x 将即时执行作为默认模式。在这种模式下，操作会立即执行，并返回具体的结果，就像标准的 Python 代码一样。这使得 TensorFlow 的使用体验更接近 NumPy 等库，极大地提高了开发效率和调试便利性。虽然即时执行是默认的，但 TensorFlow 2.x 仍然可以通过
tf.function等机制，将部分 Python 函数转换为高性能的计算图进行优化和部署。
本教程将主要基于 TensorFlow 2.x 的即时执行模式进行讲解。
1.3 为什么选择 TensorFlow？
- 强大与灵活: 支持多种类型的计算任务，从简单的数学运算到复杂的深度学习模型，并提供细粒度的控制。
- 生态系统完善: 拥有丰富的工具和库，如 Keras（高级 API，简化模型构建）、TensorBoard（可视化）、TensorFlow Serving（模型服务）、TensorFlow Lite（移动和嵌入式设备）、TensorFlow.js（Web 端）等。
- 社区活跃: 庞大的用户和开发者社区提供了丰富的资源、教程和支持。
- 生产可用性: 被广泛应用于工业界，其模型可以方便地部署到各种环境中。
- 自动微分: 内置强大的自动微分能力 (
tf.GradientTape)，这对于训练神经网络至关重要。
第二章：环境搭建
开始使用 TensorFlow 的第一步是安装它。
2.1 安装 TensorFlow
最常见的安装方式是使用 Python 的包管理器 pip。
如果你没有 NVIDIA GPU 或者不需要 GPU 加速，安装 CPU 版本即可：
bash
pip install tensorflow
如果你有 NVIDIA GPU，并且已经正确安装了 CUDA 和 cuDNN（具体版本要求请查阅 TensorFlow 官方文档），你可以安装 GPU 版本以获得显著的训练速度提升：
“`bash
bash
pip install tensorflow[and-cuda] # TensorFlow 2.10+ 版本推荐此方法安装带 GPU 支持的版本
或者对于旧版本或特定情况： pip install tensorflow-gpu
“`
请注意，TensorFlow 的 GPU 版本对 CUDA 和 cuDNN 的版本有严格要求，务必查阅官方安装指南。
2.2 验证安装
安装完成后，可以在 Python 环境中验证是否成功：
“`python
import tensorflow as tf
print(“TensorFlow 版本:”, tf.version)
应该输出安装的 TensorFlow 版本号，例如 2.9.1 或 2.10.0
验证 GPU 是否可用 (如果安装了 GPU 版本)
print(“GPU 是否可用:”, tf.config.list_physical_devices(‘GPU’))
如果输出类似 [PhysicalDevice(name=’/physical_device:GPU:0′, device_type=’GPU’)]
则表示检测到了 GPU
“`
如果上面的代码运行正常，恭喜你，TensorFlow 环境已经搭建好了！
第三章：TensorFlow 的核心概念：张量 (Tensor)
张量是 TensorFlow 中最基本的数据单位。你可以把它想象成一个多维数组，类似于 NumPy 中的 ndarray。从标量（0维张量）到向量（1维张量），再到矩阵（2维张量），以及更高维的数据，它们在 TensorFlow 中都以张量的形式表示。
3.1 创建张量
有多种方法可以创建张量：
“`python
导入 TensorFlow
import tensorflow as tf
1. tf.constant: 创建一个常量张量 (值不可改变)
scalar = tf.constant(123, dtype=tf.int32) # 0维张量 (标量)
vector = tf.constant([1, 2, 3, 4], dtype=tf.float32) # 1维张量 (向量)
matrix = tf.constant([[1, 2], [3, 4]], dtype=tf.float32) # 2维张量 (矩阵)
tensor3d = tf.constant([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], dtype=tf.float32) # 3维张量
print(“标量:”, scalar)
print(“向量:”, vector)
print(“矩阵:”, matrix)
print(“三维张量:”, tensor3d)
可以从 NumPy 数组创建张量
import numpy as np
numpy_array = np.array([[5, 6], [7, 8]], dtype=np.float32)
tensor_from_numpy = tf.constant(numpy_array)
print(“从 NumPy 创建的张量:”, tensor_from_numpy)
2. tf.zeros, tf.ones, tf.fill: 创建特定值的张量
zeros_tensor = tf.zeros(shape=(2, 3), dtype=tf.float32) # 2×3 的全零张量
ones_tensor = tf.ones(shape=(4,), dtype=tf.float32) # 1×4 的全一张量 (向量)
filled_tensor = tf.fill([2, 2], 9.0) # 2×2 的全 9 张量
print(“全零张量:”, zeros_tensor)
print(“全一张量:”, ones_tensor)
print(“填充张量:”, filled_tensor)
3. tf.random: 创建随机张量
random_normal = tf.random.normal(shape=(3, 3), mean=0.0, stddev=1.0) # 均值为0，标准差为1的正态分布随机张量
random_uniform = tf.random.uniform(shape=(2, 4), minval=0, maxval=10, dtype=tf.int32) # 0到10之间的均匀分布随机整数张量
print(“正态分布随机张量:”, random_normal)
print(“均匀分布随机张量:”, random_uniform)
“`
3.2 张量的属性
张量有两个重要的属性：
- 形状 (Shape): 张量的维度。用一个元组表示，元组中的每个元素代表该维度的大小。
- 数据类型 (Data Type): 张量中元素的数据类型，例如
tf.float32,tf.int32,tf.string等。TensorFlow 对数据类型有严格要求，不同类型的张量进行操作时可能需要进行类型转换。
“`python
tensor = tf.constant([[1.0, 2.0], [3.0, 4.0]])
print(“张量:”, tensor)
print(“形状:”, tensor.shape) # 输出: (2, 2)
print(“数据类型:”, tensor.dtype) # 输出:
print(“张量内的 NumPy 表示:”, tensor.numpy()) # 可以将张量转换为 NumPy 数组
“`
3.3 张量的索引与切片
张量的索引和切片与 Python 列表或 NumPy 数组类似：
“`python
tensor = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=tf.int32)
print(“原始张量:\n”, tensor.numpy())
索引单个元素 (需要使用 .numpy() 来获取具体数值)
print(“索引元素 (0, 0):”, tensor[0, 0].numpy()) # 输出: 1
print(“索引元素 (1, 2):”, tensor[1, 2].numpy()) # 输出: 6
切片 (返回新的张量)
print(“切片 (第一行):\n”, tensor[0, :].numpy()) # 输出: [1 2 3]
print(“切片 (所有行的第二列):\n”, tensor[:, 1].numpy()) # 输出: [2 5 8]
print(“切片 (前两行, 前两列):\n”, tensor[0:2, 0:2].numpy()) # 输出: [[1 2] [4 5]]
print(“切片 (步长):\n”, tensor[::2, ::2].numpy()) # 输出: [[1 3] [7 9]]
“`
第四章：TensorFlow 的核心概念：计算操作 (Operation)
操作（Op）是 TensorFlow 中对张量进行计算的基本单元。它接受零个或多个张量作为输入，执行某种计算，并产生零个或多个张量作为输出。
TensorFlow 提供了非常丰富的操作，涵盖数学运算、数组处理、矩阵运算、控制流、神经网络层等等。
4.1 基本数学运算
张量支持像 NumPy 一样的元素级数学运算：
“`python
a = tf.constant([[1.0, 2.0], [3.0, 4.0]])
b = tf.constant([[5.0, 6.0], [7.0, 8.0]])
print(“a + b:\n”, (a + b).numpy()) # 元素相加
print(“a – b:\n”, (a – b).numpy()) # 元素相减
print(“a * b:\n”, (a * b).numpy()) # 元素相乘 (不是矩阵乘法)
print(“a / b:\n”, (a / b).numpy()) # 元素相除
print(“a 的平方根:\n”, tf.sqrt(a).numpy()) # 元素开平方
“`
4.2 矩阵运算
对于矩阵乘法，需要使用特定的操作：
“`python
matrix1 = tf.constant([[1.0, 2.0], [3.0, 4.0]])
matrix2 = tf.constant([[5.0, 6.0], [7.0, 8.0]])
矩阵乘法
matmul_result = tf.matmul(matrix1, matrix2)
print(“矩阵乘法 (matmul):\n”, matmul_result.numpy())
@ 运算符在 Python 3.5+ 中也表示矩阵乘法
matmul_result_at = matrix1 @ matrix2
print(“矩阵乘法 (@ 运算符):\n”, matmul_result_at.numpy())
矩阵转置
transpose_matrix1 = tf.transpose(matrix1)
print(“矩阵转置:\n”, transpose_matrix1.numpy())
“`
4.3 归约操作 (Reduction)
归约操作可以沿着张量的某个或某些维度计算总和、平均值、最大值、最小值等。
“`python
tensor = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)
print(“原始张量:\n”, tensor.numpy())
计算所有元素的总和
sum_all = tf.reduce_sum(tensor)
print(“所有元素总和:”, sum_all.numpy()) # 输出: 10.0
沿着第0维 (行) 计算总和
sum_axis0 = tf.reduce_sum(tensor, axis=0)
print(“沿 axis=0 总和:”, sum_axis0.numpy()) # 输出: [4.0 6.0] (1+3, 2+4)
沿着第1维 (列) 计算总和
sum_axis1 = tf.reduce_sum(tensor, axis=1)
print(“沿 axis=1 总和:”, sum_axis1.numpy()) # 输出: [3.0 7.0] (1+2, 3+4)
计算平均值
mean_all = tf.reduce_mean(tensor)
print(“所有元素平均值:”, mean_all.numpy()) # 输出: 2.5
计算最大值
max_all = tf.reduce_max(tensor)
print(“所有元素最大值:”, max_all.numpy()) # 输出: 4.0
“`
第五章：TensorFlow 的核心概念：变量 (Variable)
到目前为止，我们创建的张量都是常量 (tf.constant) 或由常量计算得来的结果。这些张量的值在创建后是不可变的。然而，在机器学习中，模型的参数（如神经网络的权重和偏置）是需要在训练过程中不断更新和优化的，它们的值是可变的。
为了处理这种情况，TensorFlow 引入了 tf.Variable。变量是一种特殊的张量，它维护着一个可以在计算过程中修改的状态。
5.1 创建和使用变量
创建变量需要指定初始值和数据类型：
“`python
创建一个标量变量，初始值为 0.0
w = tf.Variable(0.0, dtype=tf.float32)
print(“变量 w:”, w)
创建一个形状为 (2, 2) 的矩阵变量
b = tf.Variable(tf.zeros(shape=(2, 2)), dtype=tf.float32)
print(“变量 b:\n”, b)
变量的值可以通过 .read_value() 或直接使用变量对象来获取 (在即时执行模式下)
print(“w 的当前值:”, w.numpy())
print(“b 的当前值:\n”, b.numpy())
变量的值可以通过 .assign() 方法改变
w.assign(1.0)
print(“更新后的 w:”, w.numpy())
也可以使用 assign_add() 等复合操作
w.assign_add(2.0) # w = w + 2.0
print(“再次更新后的 w:”, w.numpy())
变量可以像普通张量一样参与计算
c = w * 5.0 + 3.0
print(“c 的值:”, c.numpy())
“`
5.2 为什么需要变量？
变量的主要作用是存储模型中需要学习和更新的参数。在神经网络训练过程中，权重和偏置会通过优化算法（如梯度下降）不断调整，以最小化损失函数。tf.Variable 就是用来追踪这些可变参数的状态。
第六章：即时执行与自动微分 (Eager Execution and Automatic Differentiation)
如前所述，TensorFlow 2.x 默认开启即时执行，这让编程体验更加直观。即时执行模式下的张量和变量操作会立即返回结果，就像 NumPy 一样。
机器学习的核心在于训练模型，而训练模型的核心在于计算损失函数相对于模型参数的梯度，然后根据梯度更新参数（梯度下降）。TensorFlow 强大的自动微分能力通过 tf.GradientTape 来实现。
6.1 使用 tf.GradientTape
tf.GradientTape 是一个上下文管理器，它会在其作用域内记录所有张量（特别是通过 tf.Variable 创建的变量）上的操作。一旦记录完成，你就可以调用 tape.gradient() 方法，根据记录的操作计算某个输出张量相对于某个输入张量（通常是变量）的梯度。
“`python
x = tf.constant(3.0)
w = tf.Variable(4.0)
b = tf.Variable(5.0)
使用 tf.GradientTape 记录操作
with tf.GradientTape() as tape:
# 记录 w 和 b 的操作
y = w * x + b
计算 y 相对于 w 和 b 的梯度
dw, db = tape.gradient(y, [w, b])
print(“y =”, y.numpy()) # 输出: 17.0 (4.0 * 3.0 + 5.0)
print(“y 对 w 的梯度 (dy/dw):”, dw.numpy()) # 输出: 3.0 (根据 y = wx + b, dy/dw = x = 3.0)
print(“y 对 b 的梯度 (dy/db):”, db.numpy()) # 输出: 1.0 (根据 y = wx + b, dy/db = 1.0)
如果需要计算相对于常量张量的梯度，需要 watch 它
with tf.GradientTape() as tape:
tape.watch(x) # 明确告诉 tape 也要记录 x 的操作
y = w * x + b
计算 y 相对于 x 的梯度
dx = tape.gradient(y, x)
print(“y 对 x 的梯度 (dy/dx):”, dx.numpy()) # 输出: 4.0 (根据 y = wx + b, dy/dx = w = 4.0)
“`
tf.GradientTape 是训练神经网络的核心，因为它能自动计算出损失函数相对于模型参数的梯度，省去了手动推导和实现反向传播算法的复杂性。
第七章：构建简单的模型：线性回归示例
为了将上述基础概念串联起来，我们来实现一个最简单的机器学习模型：线性回归。目标是找到一条直线 y = wx + b 来拟合一组数据点 (x, y)。我们需要学习的参数是权重 w 和偏置 b。
7.1 准备数据
我们先生成一些带有噪声的模拟数据：
“`python
生成模拟数据
TRUE_W = 3.0
TRUE_B = 2.0
NUM_EXAMPLES = 1000
生成 x
x_data = tf.random.normal(shape=[NUM_EXAMPLES], dtype=tf.float32)
生成 y = TRUE_W * x + TRUE_B + noise
noise = tf.random.normal(shape=[NUM_EXAMPLES], dtype=tf.float32)
y_data = x_data * TRUE_W + TRUE_B + noise
print(“x_data 的前5个:”, x_data[:5].numpy())
print(“y_data 的前5个:”, y_data[:5].numpy())
“`
7.2 定义模型参数
模型参数就是我们需要学习的 w 和 b。我们将它们定义为 tf.Variable：
“`python
定义模型参数 (初始化为随机值)
w = tf.Variable(tf.random.normal([])) # 标量变量
b = tf.Variable(tf.random.normal([])) # 标量变量
print(“初始 w:”, w.numpy())
print(“初始 b:”, b.numpy())
“`
7.3 定义模型 (前向传播)
模型就是一个函数，接收输入 x，计算预测值 y_pred：
“`python
定义模型函数
def linear_model(x):
return w * x + b
“`
7.4 定义损失函数
损失函数衡量模型的预测值 y_pred 与真实值 y_true 之间的差距。对于线性回归，常用的损失函数是均方误差 (Mean Squared Error – MSE)。
“`python
定义损失函数 (均方误差)
def mean_squared_error(y_true, y_pred):
return tf.reduce_mean(tf.square(y_true – y_pred))
“`
7.5 定义优化器
优化器负责根据梯度更新模型参数。最简单的优化器是随机梯度下降 (Stochastic Gradient Descent – SGD)。我们需要指定学习率 (learning rate)，它控制每次参数更新的步长。
“`python
定义优化器
optimizer = tf.optimizers.SGD(learning_rate=0.01)
“`
7.6 训练循环
训练过程是一个迭代过程。在每次迭代（称为一个训练步）中，我们执行以下步骤：
- 使用
tf.GradientTape记录操作。 - 进行前向传播：用当前参数计算预测值
y_pred。 - 计算损失：根据
y_pred和真实值y_true计算损失。 - 计算梯度：使用
tape.gradient计算损失函数相对于参数 (w和b) 的梯度。 - 更新参数：使用优化器根据计算出的梯度更新参数。
这个过程会重复多次（称为训练轮次或 Epoch）。
“`python
训练循环
NUM_EPOCHS = 500 # 训练轮次
print(“\n开始训练…”)
for epoch in range(NUM_EPOCHS):
# 使用 GradientTape 记录计算过程
with tf.GradientTape() as tape:
# 前向传播: 计算预测值
y_pred = linear_model(x_data)
# 计算损失
loss = mean_squared_error(y_data, y_pred)
# 计算损失相对于模型参数 (w 和 b) 的梯度
gradients = tape.gradient(loss, [w, b])
# 使用优化器更新参数 (w 和 b)
optimizer.apply_gradients(zip(gradients, [w, b]))
# 每隔一定轮次打印损失和参数
if (epoch + 1) % 50 == 0:
print(f"Epoch {epoch + 1}/{NUM_EPOCHS}, Loss: {loss.numpy():.4f}, w: {w.numpy():.4f}, b: {b.numpy():.4f}")
print(“\n训练结束！”)
print(f”最终 w: {w.numpy():.4f}, 最终 b: {b.numpy():.4f}”)
print(f”真实 w: {TRUE_W}, 真实 b: {TRUE_B}”)
“`
运行上述代码，你会看到损失函数的值逐渐下降，并且 w 和 b 的值逐渐接近真实的 TRUE_W 和 TRUE_B。这就是一个完整的 TensorFlow 训练流程。
第八章：Keras API 简介
虽然我们可以像上面那样手动构建训练循环，但这对于更复杂的模型会变得非常繁琐。TensorFlow 2.x 深度整合了 Keras API，这是一个高级、用户友好的 API，大大简化了模型的构建、训练和评估过程。对于大多数常见的用例，强烈推荐使用 Keras。
8.1 Keras 的优势
- 用户友好: 提供简洁的接口来定义层、模型和训练过程。
- 模块化: 模型由可堆叠的层组成，易于组合和扩展。
- 易于调试: 即时执行模式下更容易调试。
- 功能完整: 提供了构建、训练、评估和部署模型所需的所有工具。
8.2 使用 Keras 实现线性回归
让我们看看如何用 Keras 实现同样的线性回归模型：
“`python
导入 Keras
from tensorflow import keras
from tensorflow.keras import layers
1. 定义模型
Keras Sequential 模型适用于按顺序堆叠层的情况
model = keras.Sequential([
# Dense 层是全连接层 (w * x + b)。
# units=1 表示输出一个标量 (y)
# input_shape=[1] 表示输入的形状是一个包含一个元素的向量 (x)
layers.Dense(units=1, input_shape=[1])
])
2. 编译模型
编译模型时，需要指定优化器、损失函数和评估指标
model.compile(
optimizer=tf.optimizers.SGD(learning_rate=0.01), # 使用 SGD 优化器
loss=’mean_squared_error’ # 使用均方误差作为损失函数
)
Keras 模型的前向传播非常简单
print(“模型在 x_data 前5个上的初始预测:”, model(x_data[:5]).numpy())
3. 准备数据 (Keras 通常期望输入是二维的 [样本数, 特征数])
x_data_keras = x_data[:, tf.newaxis] # 将形状 (1000,) 转换为 (1000, 1)
y_data_keras = y_data[:, tf.newaxis] # 将形状 (1000,) 转换为 (1000, 1)
4. 训练模型
print(“\n开始 Keras 训练…”)
history = model.fit(
x_data_keras,
y_data_keras,
epochs=NUM_EPOCHS, # 训练轮次
verbose=0 # 不打印每个 Epoch 的详细信息，只在最后打印
)
print(“Keras 训练结束！”)
获取训练后的模型参数
Keras Dense 层的权重 (w) 和偏置 (b) 存储在 get_weights() 方法中
get_weights()[0] 是权重矩阵 (本例中形状是 (1, 1))
get_weights()[1] 是偏置向量 (本例中形状是 (1,))
keras_w, keras_b = model.get_weights()
print(f”Keras 学习到的 w: {keras_w[0][0]:.4f}, b: {keras_b[0]:.4f}”)
print(f”真实 w: {TRUE_W}, 真实 b: {TRUE_B}”)
Keras 的 fit 方法返回一个 History 对象，可以用来查看训练过程中的损失变化
print(“损失随训练过程的变化:”, history.history[‘loss’])
“`
可以看到，使用 Keras 构建和训练模型更加简洁直观。model.fit() 方法封装了内部的训练循环、梯度计算和参数更新等复杂细节。对于初学者和大多数应用而言，Keras 是一个非常好的起点。
第九章：模型保存与加载
训练好的模型需要保存，以便将来进行预测或部署。TensorFlow 提供了多种保存和加载模型的方法。对于 Keras 模型，最常用的是 SavedModel 格式。
“`python
保存模型
model_save_path = “./linear_model_saved”
print(f”\n保存模型到: {model_save_path}”)
model.save(model_save_path) # Keras 模型的 save 方法默认保存为 SavedModel 格式
加载模型
print(f”从 {model_save_path} 加载模型…”)
loaded_model = tf.keras.models.load_model(model_save_path)
使用加载的模型进行预测
加载的模型可以直接像原始模型一样使用
x_test = tf.constant([[10.0]], dtype=tf.float32) # 注意输入形状需要是 (1, 1)
predicted_y = loaded_model.predict(x_test)
print(f”加载模型对 x=10.0 的预测值: {predicted_y[0][0]:.4f}”)
print(f”真实值 (approx): {TRUE_W * 10.0 + TRUE_B:.4f}”)
你也可以检查加载模型的参数
loaded_w, loaded_b = loaded_model.get_weights()
print(f”加载模型的 w: {loaded_w[0][0]:.4f}, b: {loaded_b[0]:.4f}”)
“`
SavedModel 格式非常强大，它可以包含模型的结构、权重以及计算图，并且支持跨平台部署。
结论
恭喜你完成了 TensorFlow 基础介绍的学习！本教程带你了解了：
- TensorFlow 是什么以及它的核心思想。
- 如何安装 TensorFlow。
- TensorFlow 的基本数据结构：张量 (
tf.constant)。 - 如何在张量上执行各种操作。
- 如何使用变量 (
tf.Variable) 存储可学习参数。 - TensorFlow 2.x 的即时执行模式和强大的自动微分 (
tf.GradientTape)。 - 如何手动构建一个简单的线性回归模型并进行训练。
- 如何使用高级 Keras API 更便捷地构建和训练模型。
- 如何保存和加载训练好的模型。
这只是 TensorFlow 冰山一角。在此基础上，你可以进一步探索：
- 更复杂的 Keras 层和模型（卷积层、循环层等）。
- 处理更真实、更大规模的数据集（tf.data API）。
- 构建和训练更复杂的神经网络模型（如图像分类、文本生成）。
- 模型评估和调优。
- 使用 TensorBoard 进行训练可视化。
- 分布式训练。
- 模型部署到不同平台（TensorFlow Serving, TFLite, TF.js）。
希望这篇基础教程能为你打开通往 TensorFlow 及其广阔应用领域的大门。祝你在机器学习的学习旅程中一切顺利！