1. 从零理解 TensorFlow 到底在算什么

很多人第一次接触 TensorFlow，脑子里冒出来的第一个问题不是“怎么用”，而是“它到底在算什么”。我刚开始也是这个状态，看了一堆文档，满屏的placeholder、session、graph，感觉像在看天书。后来真正跑通几个项目之后才明白，TensorFlow 的核心就一件事：把数学运算表达成一张计算图，然后让这张图在 CPU、GPU 或者分布式集群上高效执行。

你可以把它想象成一个极其聪明的“流水线调度员”。你告诉它每一步要做什么运算，它帮你安排这些运算在哪台设备上跑、什么时候跑、怎么并行跑。你不需要手动管理内存分配、设备切换、梯度回传这些琐事，它全包了。

那为什么是“图”而不是直接写循环？因为图结构天然适合做优化。比如你有两个运算互相不依赖，TensorFlow 可以自动把它们分配到不同设备上并行执行；再比如你定义了一个很复杂的损失函数，它可以自动做算子融合，把多个小操作合并成一个大操作，减少内存读写开销。这些优化在动态执行模式下很难做到，但在静态图模式下就是家常便饭。

TensorFlow 的版本演进也值得说一嘴。1.x 时代是纯静态图，写起来像在搭积木，调试起来很痛苦，因为图定义和实际执行是分开的。2.x 引入了 Eager Execution，默认就是动态执行，写起来像普通 Python 代码，调试也方便了。但底层依然保留了图执行的能力，你可以用tf.function把 Python 函数编译成图，兼顾开发效率和运行效率。这个设计思路其实很聪明：开发阶段用动态模式快速迭代，部署阶段用图模式榨取性能。

对于刚入门的人来说，我的建议是直接从 2.x 开始学，不要碰 1.x 的Session那一套。网上很多老教程还在讲tf.placeholder，那个东西在 2.x 里已经被废弃了，学了也是白学。你只需要记住三个核心概念：张量（Tensor）、变量（Variable）、计算图（Graph）。张量就是多维数组，变量就是可训练的参数，计算图就是运算的依赖关系。把这三个东西搞清楚，后面的事情就顺了。

2. 环境搭建中最容易翻车的几个环节

2.1 版本匹配比你想的重要得多

TensorFlow 的版本兼容性是个大坑。我见过太多人装完 TensorFlow 之后跑代码报一堆ImportError，最后发现是 CUDA 版本和 TensorFlow 版本对不上。这里有一个基本原则：TensorFlow 版本决定了 CUDA 和 cuDNN 的版本，而不是反过来。

举个例子，TensorFlow 2.10 是最后一个支持原生 Windows GPU 的版本，之后的版本在 Windows 上只能用 WSL2 或者 Docker。如果你在 Windows 上装了 2.11 以上的版本，又没配 WSL2，那 GPU 就是用不了。这个信息在官方文档里写得很清楚，但很多人不看，装完发现tf.config.list_physical_devices('GPU')返回空列表，然后开始怀疑人生。

我的做法是：先确定要用的 TensorFlow 版本，然后去官方文档查对应的 CUDA 和 cuDNN 版本，再按这个版本去装驱动。顺序不能乱。如果你用的是 conda，可以用conda install tensorflow-gpu=X.X让它自动解决依赖，但 conda 的源有时候更新不及时，可能装不到最新版本。pip 装的话就要自己手动对齐版本。

提示：装完 GPU 版本后，一定要用tf.config.list_physical_devices('GPU')验证一下，返回空列表就说明没配对。

2.2 虚拟环境不是可选项，是必选项

我刚开始学的时候图省事，直接装在系统 Python 里，结果后来做另一个项目需要不同版本的 TensorFlow，两个项目互相打架，最后只能重装系统。从那以后我就学乖了，每个项目一个虚拟环境，用venv或者conda都行。

python -m venv tf_env source tf_env/bin/activate # Linux/Mac tf_env\Scripts\activate # Windows pip install tensorflow

如果你需要 GPU 支持，就装tensorflow-gpu，不过 2.11 之后官方把 GPU 支持合并到主包了，直接装tensorflow就行，但需要额外装 CUDA 运行时。具体怎么装看官方文档，这里不展开。

2.3 国内下载慢的问题

pip 默认从国外源下载，国内下载 TensorFlow 经常断线或者慢得离谱。换国内镜像源能快很多：

pip install tensorflow -i https://pypi.tuna.tsinghua.edu.cn/simple

这个清华源是我用得最多的，速度稳定，包也全。如果遇到某个版本镜像源没有，再换回官方源试试。

3. 张量操作：TensorFlow 的“基本功”

3.1 张量到底是什么

张量说白了就是多维数组。标量是 0 维张量，向量是 1 维张量，矩阵是 2 维张量，再往上就是 3 维、4 维甚至更高维。TensorFlow 里的一切数据都是张量，图片是 4 维张量（batch、height、width、channels），文本是 2 维张量（batch、sequence_length），音频是 3 维张量（batch、time_steps、features）。

创建张量的方式有很多种，最常用的是tf.constant和tf.Variable。前者创建不可变张量，后者创建可变张量，通常用来存模型参数。

import tensorflow as tf # 创建常量张量 a = tf.constant([[1, 2], [3, 4]]) print(a) # 创建变量张量 b = tf.Variable([[1.0, 2.0], [3.0, 4.0]]) print(b)

tf.constant创建的张量一旦定义就不能改，tf.Variable可以通过assign方法修改。这个区别很重要，因为模型训练的本质就是不断更新变量。

3.2 形状操作是绕不过去的坎

张量形状操作是 TensorFlow 里最容易出错的地方。reshape、transpose、expand_dims、squeeze这几个函数我建议你反复练，练到闭着眼睛都能写对。

reshape改变张量的形状但不改变数据顺序。比如一个[2, 3]的张量可以 reshape 成[3, 2]或者[6]，但元素的总数必须一致。transpose是转置，交换维度顺序。expand_dims在指定位置插入一个维度，squeeze去掉长度为 1 的维度。

x = tf.constant([[1, 2, 3], [4, 5, 6]]) print(x.shape) # (2, 3) y = tf.reshape(x, [3, 2]) print(y.shape) # (3, 2) z = tf.transpose(x) print(z.shape) # (3, 2) w = tf.expand_dims(x, axis=0) print(w.shape) # (1, 2, 3) v = tf.squeeze(w) print(v.shape) # (2, 3)

我踩过的一个坑是：在模型里做 reshape 的时候，batch 维度经常写成固定值，结果换了个 batch size 就报错。正确的做法是用-1让 TensorFlow 自动推断：

x = tf.reshape(x, [-1, 28, 28, 1])

这样不管 batch size 是多少都能跑。

3.3 广播机制：省内存的好帮手

广播（Broadcasting）是 TensorFlow 里一个很实用的特性。当你对两个形状不同的张量做运算时，TensorFlow 会自动把维度扩展成兼容的形状。比如一个[3, 4]的张量和一个[4]的张量相加，后者会被自动扩展成[3, 4]。

a = tf.constant([[1, 2, 3], [4, 5, 6]]) # shape (2, 3) b = tf.constant([10, 20, 30]) # shape (3,) c = a + b print(c) # [[11, 22, 33], [14, 25, 36]]

广播的好处是不需要显式复制数据，省内存。但要注意，广播只在维度兼容的时候才生效，如果形状完全不匹配就会报错。我一般会在做运算之前用tf.debugging.assert_shapes检查一下形状，避免运行时才发现问题。

4. 模型构建：从 Sequential 到自定义层

4.1 Sequential API：快速搭建原型

如果你只是想快速搭一个模型跑通流程，Sequential是最省事的选择。它就像搭积木一样，一层一层往上叠：

model = tf.keras.Sequential([ tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(10, activation='softmax') ])

这个模型有两层全连接层，中间加了个 Dropout 防止过拟合。input_shape只在第一层指定，后面的层会自动推断输入形状。Sequential适合简单的线性堆叠结构，但如果你的模型有分支、跳跃连接或者多输入多输出，就得用 Functional API 或者自定义层了。

4.2 Functional API：处理复杂拓扑

Functional API 的写法更像在描述数据流：你定义输入，然后一层一层调用，最后定义输出。这种方式可以处理任意复杂的网络结构。

inputs = tf.keras.Input(shape=(784,)) x = tf.keras.layers.Dense(128, activation='relu')(inputs) x = tf.keras.layers.Dropout(0.2)(x) outputs = tf.keras.layers.Dense(10, activation='softmax')(x) model = tf.keras.Model(inputs=inputs, outputs=outputs)

这种写法看起来和 Sequential 差不多，但灵活性高很多。比如你要做一个残差连接：

inputs = tf.keras.Input(shape=(784,)) x = tf.keras.layers.Dense(128, activation='relu')(inputs) residual = tf.keras.layers.Dense(128)(x) x = tf.keras.layers.Add()([x, residual]) outputs = tf.keras.layers.Dense(10, activation='softmax')(x)

这种结构在 Sequential 里就很难表达。所以我的建议是：原型阶段用 Sequential，正式项目用 Functional API。

4.3 自定义层：当内置层不够用的时候

有时候内置层满足不了需求，比如你想实现一个特殊的注意力机制或者自定义的归一化方式，就需要自己写层。自定义层继承tf.keras.layers.Layer，实现__init__和call方法：

class MyDense(tf.keras.layers.Layer): def __init__(self, units): super(MyDense, self).__init__() self.units = units def build(self, input_shape): self.w = self.add_weight( shape=(input_shape[-1], self.units), initializer='glorot_uniform', trainable=True ) self.b = self.add_weight( shape=(self.units,), initializer='zeros', trainable=True ) def call(self, inputs): return tf.matmul(inputs, self.w) + self.b

build方法在第一次调用时执行，用来创建权重。call方法定义前向传播逻辑。这种写法比直接用Dense麻烦，但胜在灵活。我一般只在需要特殊初始化或者特殊运算的时候才自定义层，能用内置层就用内置层。

5. 训练循环：fit 与自定义训练的选择

5.1 model.fit：最省心的训练方式

model.fit是 Keras 提供的高级训练接口，一行代码就能完成训练：

model.compile( optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'] ) model.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.2)

compile指定优化器、损失函数和评估指标，fit执行训练。validation_split会自动从训练数据里切一部分做验证。这种方式适合标准的有监督学习任务，省去了手写训练循环的麻烦。

但fit也不是万能的。如果你的损失函数需要多个输入、或者训练过程中需要动态调整学习率、或者需要自定义梯度计算，fit就力不从心了。这时候就得自己写训练循环。

5.2 自定义训练循环：掌控每一个细节

自定义训练循环的核心是tf.GradientTape，它负责记录前向传播过程中的运算，然后自动计算梯度：

optimizer = tf.keras.optimizers.Adam() for epoch in range(epochs): for x_batch, y_batch in train_dataset: with tf.GradientTape() as tape: logits = model(x_batch, training=True) loss = loss_fn(y_batch, logits) grads = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(grads, model.trainable_variables))

这段代码看起来比fit复杂，但每一步都清清楚楚。GradientTape默认只记录一次前向传播，如果你需要计算高阶梯度，要加persistent=True。apply_gradients把梯度应用到变量上，完成参数更新。

我一般会在以下场景用自定义训练循环：需要多任务学习、需要对抗训练、需要自定义学习率调度、或者需要梯度裁剪。其他情况用fit就够了。

5.3 学习率调度：训练稳定性的关键

学习率设大了训练不收敛，设小了训练太慢。固定学习率很难兼顾两头，所以通常会用学习率调度策略。TensorFlow 内置了几种常用的调度器：

lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay( initial_learning_rate=0.01, decay_steps=10000, decay_rate=0.9 ) optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)

ExponentialDecay每过decay_steps步就把学习率乘以decay_rate。还有PiecewiseConstantDecay可以分段设置学习率，CosineDecay做余弦退火。我个人的经验是：先用固定学习率跑通，再根据损失曲线决定要不要加调度。如果损失下降很平滑，不加也行；如果损失震荡得厉害，加个衰减策略通常能改善。

6. 数据管道：tf.data 的正确打开方式

6.1 为什么不用 numpy 直接喂数据

小数据集用 numpy 直接喂没问题，但数据量一大就出问题了。numpy 数组全部加载到内存里，内存不够就崩了。而且 numpy 是单线程的，数据预处理会成为训练瓶颈。tf.data就是为解决这些问题设计的：它支持流式读取、并行预处理、预取，能把数据管道的效率拉满。

dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)) dataset = dataset.shuffle(10000).batch(32).prefetch(tf.data.AUTOTUNE)

shuffle打乱数据，batch分批，prefetch在训练当前批次的时候提前准备下一批数据。AUTOTUNE让 TensorFlow 自动决定预取多少批，通常比手动设值效果好。

6.2 map 操作的并行化

数据预处理通常用map来做，比如图片解码、归一化、数据增强。默认情况下map是串行的，速度很慢。加上num_parallel_calls就能并行处理：

def preprocess(image, label): image = tf.image.resize(image, [224, 224]) image = image / 255.0 return image, label dataset = dataset.map(preprocess, num_parallel_calls=tf.data.AUTOTUNE)

AUTOTUNE会根据 CPU 核心数自动决定并行度。我实测下来，加了并行之后数据预处理速度能快好几倍，尤其是图片解码这种 CPU 密集的操作。

6.3 数据增强：在管道里做还是在外边做

数据增强可以在tf.data管道里做，也可以在模型里做。管道里做的好处是增强后的数据不占额外内存，而且可以和训练并行。模型里做的好处是增强逻辑和模型绑定，部署的时候不用额外处理。

我一般把随机增强放在管道里，把确定性的预处理（比如归一化）放在模型里。这样训练的时候增强是随机的，推理的时候归一化是固定的，逻辑清晰。

def augment(image, label): image = tf.image.random_flip_left_right(image) image = tf.image.random_brightness(image, 0.2) return image, label train_dataset = train_dataset.map(augment, num_parallel_calls=tf.data.AUTOTUNE)

7. 模型保存与部署：别等到最后才想这件事

7.1 SavedModel 格式：部署的标准

TensorFlow 推荐的保存格式是 SavedModel，它包含了模型结构和权重，还包含了计算图，可以直接被 TensorFlow Serving、TensorFlow Lite、TensorFlow.js 等工具加载。

model.save('my_model')

保存之后目录结构是这样的：

my_model/ ├── assets/ ├── variables/ │ ├── variables.data-00000-of-00001 │ └── variables.index └── saved_model.pb

saved_model.pb存的是模型结构，variables目录存的是权重。加载的时候直接用tf.keras.models.load_model('my_model')就行。

7.2 只保存权重：灵活但麻烦

如果你只需要权重，可以用model.save_weights：

model.save_weights('my_weights')

加载的时候需要先重建模型结构，再加载权重：

model = create_model() model.load_weights('my_weights')

这种方式适合在代码里定义模型结构的场景，比如你有一个create_model函数，每次都用同样的方式建模型。但如果模型结构变了，权重就对不上了。

7.3 导出为 TFLite：移动端部署

如果要在手机或者嵌入式设备上跑模型，需要转成 TFLite 格式：

converter = tf.lite.TFLiteConverter.from_saved_model('my_model') tflite_model = converter.convert() with open('model.tflite', 'wb') as f: f.write(tflite_model)

TFLite 会对模型做量化压缩，体积能缩小到原来的四分之一，推理速度也能提升。但量化会损失一点精度，具体损失多少取决于量化方式。我一般会先转 FP32 版本，如果体积还是太大再考虑 FP16 或者 INT8 量化。

8. 踩坑实录：那些文档里不会写的问题

8.1 内存泄漏：循环里创建模型

我遇到过一个很隐蔽的内存泄漏问题：在循环里反复创建模型，结果内存越用越多，最后 OOM。原因是 TensorFlow 的变量在 Python 垃圾回收的时候不一定能及时释放，尤其是 GPU 内存。

解决办法是用del model显式删除模型，然后调用tf.keras.backend.clear_session()清理会话。如果还是不行，就得用gc.collect()强制垃圾回收。这个坑我在做超参数搜索的时候踩过，跑了几十个实验之后 GPU 内存就满了，后来加了清理逻辑才解决。

8.2 随机种子：结果不可复现

深度学习的结果本来就有随机性，但有时候你需要复现实验结果。这时候就要固定随机种子：

tf.random.set_seed(42) np.random.seed(42) random.seed(42)

但即使固定了种子，GPU 上的某些操作仍然是非确定性的。要完全确定性的结果，需要设置环境变量：

export TF_DETERMINISTIC_OPS=1

不过这样会牺牲一些性能。我的建议是：开发阶段不用太在意复现性，实验阶段固定种子，最终报告结果的时候跑多次取平均。

8.3 GPU 内存按需分配

TensorFlow 默认会占满所有 GPU 内存，即使模型很小。这在单卡环境下没问题，但在多卡或者共享 GPU 的环境下就很讨厌。解决办法是开启按需分配：

gpus = tf.config.list_physical_devices('GPU') for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True)

这样 TensorFlow 会根据实际需要申请内存，而不是一次性占满。还有一个办法是限制 GPU 内存上限：

tf.config.set_logical_device_configuration( gpus[0], [tf.config.LogicalDeviceConfiguration(memory_limit=4096)] )

限制成 4GB，够用就行。

8.4 自定义损失函数里的形状问题

写自定义损失函数的时候，经常遇到形状不匹配的报错。比如y_true的形状是[batch, 1]，y_pred的形状是[batch, 10]，直接相减就会广播成[batch, 10]，结果完全不对。

解决办法是在损失函数里先做tf.squeeze或者tf.reshape，确保两个张量形状一致。我一般会在损失函数开头加一行y_true = tf.cast(y_true, y_pred.dtype)，既统一了数据类型，也顺便检查了形状。

9. 性能调优：让训练快起来的几个实用技巧

9.1 混合精度训练

混合精度训练是这两年最实用的加速技巧之一。它的原理是用 FP16 做前向和反向传播，用 FP32 存权重。FP16 的计算速度比 FP32 快很多，尤其是在支持 Tensor Core 的 GPU 上。

policy = tf.keras.mixed_precision.Policy('mixed_float16') tf.keras.mixed_precision.set_global_policy(policy)

开启之后，Dense 层和 Conv 层会自动用 FP16 计算。但要注意，损失缩放（Loss Scaling）是必须的，因为 FP16 的表示范围比 FP32 小，梯度容易下溢。Keras 会自动帮你加损失缩放，不用手动处理。

我实测下来，混合精度训练能快 1.5 到 2 倍，精度损失几乎可以忽略。但也不是所有模型都适合，有些对数值精度敏感的模型开了混合精度反而会崩。建议先在小规模数据上试一下，确认没问题再上全量数据。

9.2 XLA 编译

XLA（Accelerated Linear Algebra）是 TensorFlow 的编译器，能把多个小算子融合成一个大算子，减少内存读写和 kernel 启动开销。

tf.config.optimizer.set_jit(True)

或者在tf.function上单独开启：

@tf.function(jit_compile=True) def train_step(x, y): ...

XLA 对 Transformer 类模型的加速效果特别明显，因为这类模型有很多小算子。但 XLA 编译本身需要时间，如果模型经常变结构，编译开销可能抵消掉运行时的收益。我的经验是：模型结构固定、训练步数多的时候开 XLA，原型阶段不开。

9.3 数据管道与计算重叠

训练速度慢很多时候不是模型计算慢，而是数据供给跟不上。prefetch能让数据准备和模型计算重叠：

dataset = dataset.prefetch(tf.data.AUTOTUNE)

AUTOTUNE会自动调整预取数量。如果 CPU 核心多，还可以加num_parallel_calls并行处理数据。我一般会监控 GPU 利用率，如果利用率忽高忽低，多半是数据管道拖了后腿。

10. 从 TensorFlow 出发的下一步

TensorFlow 的生态很庞大，学完基础之后可以往几个方向深入。如果你做计算机视觉，可以研究tf.keras.applications里的预训练模型，或者用tf.image做数据增强。如果做自然语言处理，可以看tf.keras.layers.TextVectorization和tf.keras.layers.Embedding，或者直接用 Hugging Face 的 Transformers 库，它底层支持 TensorFlow。

如果你对部署感兴趣，可以研究 TensorFlow Serving、TensorFlow Lite、TensorFlow.js 这三个方向。Serving 适合服务端部署，Lite 适合移动端和嵌入式，JS 适合浏览器端。每个方向的侧重点不同，但核心都是把训练好的模型高效地跑起来。

还有一个方向是分布式训练。TensorFlow 支持MirroredStrategy、TPUStrategy等多种分布式策略，可以在多卡、多机甚至 TPU 上训练。不过分布式训练涉及的东西比较多，建议先把单卡训练跑熟再考虑。

我个人的体会是：TensorFlow 的学习曲线前期比较陡，但一旦跨过那个坎，后面就是一马平川。关键是要动手写，不要只看文档。看十遍文档不如自己跑通一个例子。遇到报错不要怕，报错信息里通常包含了解决问题的线索。实在搞不定就去搜，你遇到的问题大概率别人也遇到过。

最后分享一个小技巧：TensorFlow 的官方教程质量很高，尤其是 “TensorFlow Core” 那一部分，从张量操作到自定义训练循环都有详细的代码示例。我建议把官方教程里的例子都跑一遍，跑的过程中改改参数、换换数据，看看会发生什么。这种“折腾式学习”比被动看文档效率高得多。