很多新手在搜索栏里输入“python安装教程”“keras安装教程”“深度学习环境配置”的时候，其实心里想的是同一件事：我想跑通一个深度学习模型，但第一步就被环境卡住了。TensorFlow 2.0加上Keras，恰恰是绕过这一堆琐碎细节、最快把手放到真实模型上的组合。我当年从1.x时代折腾静态图的痛苦经历，到现在2.0下的流畅体验，感触非常深。这篇文章不谈虚的，就围绕“用TensorFlow 2.0/Keras跑一个深度学习项目”这件事，把环境、建模、训练、部署、避坑这几环一次讲透，适合刚读完Python基础、想进入深度学习但又被各种教程碎片搞懵的人。

1. 为什么偏偏是TensorFlow 2.0加Keras

1.1 Keras被官方收编之后，建模变成搭积木

Keras最初是一个独立的高级神经网络API，后来被Google收编成为TensorFlow的官方高级接口，也就是tf.keras。这个收编动作的意义远不止换个名字：它意味着你写模型时不需要再去手动管理计算图、不需要自己写backpropagation、不需要关心张量在设备间的分配。你只需要把层像积木一样搭起来，然后调用fit()。

对比一下1.x时代，那是真的折磨——你得先定义一个静态计算图，再开一个session去run()，中间要手动global_variables_initializer()，每一步都像在写底层的C++一样繁琐。2.0之后，Keras帮你把这些全包了。对新手来说，这可能是这个框架做的最正确的一个决策：把“深度学习”从“系统工程”里剥离出来，让初学者先专注于“模型长什么样”“数据怎么喂进去”这些更本质的问题。

1.2 Eager Execution动态图，让调试像普通Python一样自然

TensorFlow 2.0默认开启动态图模式（Eager Execution），这可能是对新手最友好的一次改变。什么意思？就是代码执行到哪一行，结果立刻就能算出来。你可以直接print中间张量的shape和值，可以用Python的断点调试器逐行debug，可以写if语句来控制张量的流向。这种体验和写普通Python脚本几乎没有区别。

我见过很多朋友从PyTorch切到TensorFlow，最不适应的点就是静态图时代的“不可调试”。但2.0之后这个差距基本不存在了。你完全可以像玩NumPy一样先去验证一段逻辑，再把逻辑包进Keras的自定义层里，这种平滑的过渡体验对新手极其宝贵。

1.3 生态成熟度，决定了你学完之后能走多远

入门框架的选择不能只看好不好写，还要看学完之后，你的模型能不能真的用起来。TensorFlow生态里有TensorFlow Lite（移动端和嵌入式）、TensorFlow Serving（服务端高性能推理）、TensorFlow.js（浏览器端）、TFLite Micro（微控制器），还有内存分析工具、模型优化工具、部署工具链。这意味着你从“训练出一个模型”到“把一个模型部署上线”之间有非常顺滑的路径，不需要自己拼凑一堆零散的工具。

相比之下，PyTorch在科研论文复现和动态图灵活性上确实很强，但它的部署链路相对分散，通常需要转成ONNX再做推理优化。我不是说PyTorch不好，而是在“入门+落地”这个综合维度上，TensorFlow 2.0+Keras的性价比更高。等你有经验后再学PyTorch，会发现两者很多概念相通，切换成本并不高。

2. 环境搭建，或者说“先让电脑变成能算的机器”

2.1 Python版本与虚拟环境，别把小问题留给未来的自己

环境搭建时最常见的翻车点不是TensorFlow本身，而是Python版本、pip版本、系统库之间互相打架。我的建议是：装Python 3.8到3.11之间的版本，不要一上来就追最新版。TensorFlow对新版本Python的支持往往滞后一到两个月，如果你装了Python 3.13，去装TensorFlow的时候很可能没有对应的预编译wheel包，或者即便装上了也容易在运行时踩到奇怪的ABI错误。

然后是虚拟环境。我知道新手嫌麻烦，觉得“直接装到系统里不就行了吗”。等几个月后你同时维护两三个项目，A项目要TensorFlow 2.10，B项目要TensorFlow 2.15，你就会明白虚拟环境的必要性。一个项目一个虚拟环境，这是正经做开发的基本素养。推荐用Anaconda或者Python自带的venv模块，前者对Windows用户更友好，后者更轻量。我第一次用Anaconda建环境的时候也觉得多此一举，后来两个项目依赖冲突了一下午之后，再也没偷懒过。

2.2 CUDA和cuDNN版本匹配，深度学习环境配置的最大坑

如果你有NVIDIA独立显卡，想用GPU加速训练，那么CUDA和cuDNN的版本匹配是打开深度学习大门的第一道坎，也是搜索关键词里“深度学习环境配置”常年霸榜的原因。

这里先说一个底层逻辑：TensorFlow不是一个纯Python库，它底层有大量的CUDA算子，这些算子是在特定CUDA版本上编译出来的。所以TensorFlow、CUDA、cuDNN三者必须形成一个稳定的三角组合。装错了版本，轻则运行时报错，重则导入时直接崩溃。

以TensorFlow 2.10到2.15为例，常见匹配关系如下表：

注意，TensorFlow 2.11之后在Windows上不再提供官方GPU wheel包，Windows用户要么退回2.10版本，要么使用WSL2或Docker。这是很多人在Windows上折腾半天装不上GPU版TensorFlow的根本原因。如果你不想折腾这些，最简单粗暴的方案就是直接用CPU跑入门项目——图像分类这种小模型，CPU训练也就几分钟到十几分钟的事情，完全不影响学习进度。

2.3 安装TensorFlow之后，先做这两个小验证

不管你是用pip install tensorflow还是pip install tensorflow-gpu（后者在2.1之后已经合并到主包了），安装完成后一定要先跑一段代码确认环境没问题，不要急着敲模型。

第一个验证是TensorFlow能否正常导入并执行基础运算：

python复制import tensorflow as tf

# 创建一个随机张量并做一次矩阵乘法
a = tf.random.normal([4, 4])
b = tf.random.normal([4, 4])
c = tf.matmul(a, b)

print("TensorFlow版本:", tf.__version__)
print("矩阵乘法结果shape:", c.shape)

如果你能看到版本号和(4, 4)的shape，说明基础安装没问题。如果这里报错，比如DLL加载失败或者缺失某个动态库，那基本就是CUDA/cuDNN版本问题，回头检查上一节的版本匹配表。

第二个验证是看看GPU是否真的被识别出来了：

python复制gpus = tf.config.list_physical_devices('GPU')
if gpus:
    print("检测到GPU数量:", len(gpus))
    for gpu in gpus:
        print("GPU型号:", gpu.name)
else:
    print("未检测到GPU，将使用CPU训练")

这一步能帮你确认TensorFlow是否真正用上了显卡。如果你的CUDA装得乱七八糟，TensorFlow不会直接崩溃，但会安静地退回CPU模式——如果你没做这个测试，可能训练了半天还以为自己在用GPU加速。我遇到过不止一个人，在CPU上跑了一个通宵，后来才发现GPU压根没被调用。

3. Keras建模的三层境界：选对API能少写一半代码

3.1 Sequential顺序模型，最快出活的原型工具

Keras最直观的建模方式是Sequential，它适合层与层之间按顺序堆叠的网络，比如典型的卷积神经网络。你只需要把层往列表里排，Keras会自动把它们串起来。看一个最简单的MLP分类器：

python复制import tensorflow as tf
from tensorflow.keras import layers

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

这种写法的好处是阅读起来极其符合直觉：第一层收输入，第二层做个随机失活，第三层输出10类概率分布。对新手来说，不需要理解背后自动求导和反向传播的数学细节，先能看到“我的网络长什么样”比什么都重要。

但Sequential的局限性也很明显：它不允许有分支、不允许层之间有跳跃连接、不允许有多输入或多输出。当你后面想实现ResNet的残差连接，或者想做个同时输出分类和回归的多任务模型时，Sequential就完全不够用了。

3.2 Functional API，面向真实问题的工业标准

当网络结构不再是一条直线堆叠到底时，就该切换到Functional API了。它的核心思想是“层就像函数，张量在层之间流动”，你可以把上一层的输出传给多个下游层，也可以把多个分支的输出拼接起来。这个命名本身就是做函数式编程的意思——每个层都是一个无状态函数，输入Tensor，输出Tensor。

看一个带残差连接的小例子：

python复制from tensorflow.keras import layers, Model

inputs = layers.Input(shape=(64, 64, 3))
x = layers.Conv2D(32, 3, padding='same', activation='relu')(inputs)
x = layers.BatchNormalization()(x)
x = layers.Dropout(0.2)(x)
outputs = layers.Add()([x, inputs])  # 残差连接：把输入加到卷积输出上

model = Model(inputs, outputs)

这种写法明确、灵活、可读性好，是实际项目中最常用的建模方式。我的建议是：新手不要停留在Sequential，尽快转到Functional API，因为绝大部分真实模型（多分支网络、双塔模型、注意力机制）都是用这种方式构建的。

3.3 Model子类化，属于研究人员的自留地

第三种方式是通过继承tf.keras.Model来定义模型，这种方式给了你最大的自由度，你可以完全自定义call()方法里的前向传播逻辑，甚至在里面写for循环、if分支、动态shape变换。PyTorch用户会觉得很亲切，因为这就是PyTorch的nn.Module写法。

python复制import tensorflow as tf
from tensorflow.keras import layers

class MyModel(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.dense1 = layers.Dense(128, activation='relu')
        self.dense2 = layers.Dense(10, activation='softmax')

    def call(self, inputs):
        x = self.dense1(inputs)
        x = self.dense2(x)
        return x

model = MyModel()

Model子类化适合需要高度定制训练逻辑的场景（比如动态控制推理路径、实现复杂的图网络算法）。但代价是：模型的结构不再自动可见，Keras的一些旁路功能（比如model.summary()的自动推断）会受限。对一个新手来说，除非你确信Sequential和Functional不够用，否则不必过早跨入这一层。

3.4 compile时那三个参数，背后的选择逻辑

Keras的compile()函数一共有三个核心参数：损失函数、优化器、评估指标。新手常常随便填，但这三个参数直接决定模型能不能收敛、收敛成什么样子。

损失函数的选择标准是“你的任务是什么”——分类任务用交叉熵，回归任务用均方误差（MSE）。这里有个易错点：多分类时到底用categorical_crossentropy还是sparse_categorical_crossentropy，取决于你的标签是one-hot编码还是整数编码。前者需要把标签做one-hot（例如[0, 1, 0, 0]），后者直接用整数标签（例如1），但它们的损失函数公式一模一样。很多人模型训练了很久loss始终不降，回头一查，就是没搞清楚这两种编码对应的损失函数。

优化器的首选是Adam。它可以自动调整每个参数的学习率，对新手极其友好。你不需要像SGD那样手动设计学习率衰减策略，设置一个learning_rate=0.001就能在大多数任务上取得一个还不错的起点。

评估指标也要和任务匹配：分类任务用accuracy、top_k_categorical_accuracy，回归任务用mae、mse，多标签任务用AUC。评估指标的作用并不是梯度下降的参与变量，而是人眼观察模型训练效果的窗口。

4. 用CIFAR-10走一遍完整的训练流程

4.1 数据准备：加载、归一化、划分验证集

理论说了一堆，我们还是用CIFAR-10这个经典数据集跑一个完整的CNN项目。CIFAR-10是60,000张32x32的彩色图像，共10个类别（飞机、汽车、鸟、猫、鹿、狗、青蛙、马、船、卡车）。这个数据集足够小，CPU也能跑得动，又足够复杂，不至于像MNIST那样随便写个神经网络就99%正确率，能让你真正感受到调参对模型效果的影响。

python复制import tensorflow as tf
from tensorflow.keras import datasets, layers, models

(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()

# 归一化：把0-255的像素值压到0-1之间
train_images, test_images = train_images / 255.0, test_images / 255.0

print("训练集shape:", train_images.shape)  # (50000, 32, 32, 3)
print("测试集shape:", test_images.shape)   # (10000, 32, 32, 3)

归一化这一步看起来简单，但很多人随手跳过，导致训练收敛极慢甚至不收敛。为什么？因为像素值0-255的范围太大，激活函数（比如sigmoid、tanh）在输入绝对值很大时已经进入了饱和区，梯度几乎为0。把数据压到0-1之间，等于让网络在激活函数的敏感区域工作。

这里还建议从训练集中再切出一部分作为验证集，别用测试集来调参。验证集是训练过程中的“模拟考”，测试集是最后的“期末考试”，如果你拿测试集反复调参，相当于“考前就把答案背熟了”，得到的准确率是有水分、不可信的。

python复制# 从训练集中切出5000张作为验证集
val_images = train_images[:5000]
val_labels = train_labels[:5000]
train_images_small = train_images[5000:]
train_labels_small = train_labels[5000:]

4.2 网络搭建：为什么是卷积、池化、再加全连接这样的组合

下面搭一个经典的卷积神经网络结构：卷积层提取局部特征，池化层压缩特征图尺寸并保留主要信息，全连接层做最终的分类决策。我自己在实践中的体会是：对于CIFAR-10这种32x32的小图，不需要一上来就堆很深很宽的网络，而是先用简单结构跑通流程，再逐步加深。

python复制model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)),
    layers.BatchNormalization(),
    layers.Conv2D(32, (3, 3), activation='relu', padding='same'),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.25),

    layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.25),

    layers.Flatten(),
    layers.Dense(256, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')
])

model.summary()

几个关键设计的理由：第一，padding='same'能让卷积层输出尺寸不变，这样特征图信息不会过早缩小，网络前面的层能够学到更多细节；第二，BatchNormalization放在卷积层和激活函数之间，作用是缓解梯度消失、加速收敛，这是从实践中总结出的高效做法——BN之所以有效，是因为它把每一层的输入分布拉回零均值单位方差，让激活函数永远工作在线性区附近，梯度不容易饱和；第三，Dropout放在池化之后和全连接层之前，它的作用是在训练时随机丢弃一部分神经元，迫使网络学到更鲁棒的特征而不是死记硬背。

4.3 训练配置：epochs、batch size、learning rate的经验区间

训练配置上，新手常问的问题集中在三个：训练多少轮？每批多少张？学习率设多大？

epochs（训练轮数）不要拍脑袋决定。我一般会先在训练集上跑20~30个epoch，同时用验证集监控loss和准确率曲线的变化。如果验证准确率升高后开始下降，而训练准确率还在上升，那就是典型的过拟合信号，此时应该做的是加Dropout或数据增强，而不是继续加轮数。

batch size（批大小）直接影响收敛速度和稳定性。batch太小（比如1），梯度方向波动大，训练曲线非常震荡；batch太大，每个epoch的更新次数少，收敛慢且可能陷入尖锐极小值。经验上，图像分类任务里32或64是个不错的起点，显存不够就降到16或8。

learning rate是最敏感的超参数。用Adam时，1e-3是一个值得从它开始尝试的默认值。如果loss在训练初期从大值往下降，但很快变得平缓且不平滑，可以试试降到3e-4。注意学习率太大，loss会爆炸成NaN；太小，loss几乎纹丝不动。这两种极端情况我在实战里都踩过。

python复制model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

history = model.fit(
    train_images_small, train_labels_small,
    epochs=20,
    batch_size=64,
    validation_data=(val_images, val_labels),
    callbacks=[tf.keras.callbacks.EarlyStopping(patience=3, restore_best_weights=True)]
)

这里用到了EarlyStopping回调，它的逻辑是：如果验证集loss连续patience个epoch没有任何改善，就终止训练，并自动恢复训练过程中验证集表现最好的那一次权重。这是一个非常实用的防过拟合手段，新手一定要养成使用回调的习惯。

4.4 评估和预测：从准确率数字到单张图片的预测结果

训练完成后，第一步用model.evaluate()看模型在真正的测试集上的表现，这是衡量模型泛化能力的核心指标：

python复制test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f"测试集准确率: {test_acc:.4f}")

如果我的网络结构设计正确、训练配置合理，CIFAR-10的测试准确率应该能到70%~75%。能不能到80%以上？能，但需要更深的网络结构、数据增强、学习率调度，这些是下一步的进阶内容。

然后，我们用模型对单张图片做预测：

python复制import numpy as np

class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']

# 取测试集第一张图片
img = test_images[0]
img_batch = np.expand_dims(img, axis=0)  # 从(32,32,3)变成(1,32,32,3)

predictions = model.predict(img_batch)
predicted_class = np.argmax(predictions[0])

print("预测类别:", class_names[predicted_class])
print("真实类别:", class_names[test_labels[0][0]])
print("各类别概率:", predictions[0])

这里有一个基础但重要的细节：model.predict()期望的输入是四维张量(batch_size, height, width, channels)，即使你只有一张图，也要用np.expand_dims补上一个batch维度。很多新手第一次做单张预测时都会在这报错，原因就是维度不匹配。

5. 部署不是把模型文件拷走就完事，浮点数精度的选择题

5.1 部署精度为什么成了热搜词

最近一段时间，“深度学习模型部署必知：fp32、fp16、bf16、tf32浮点数格式详解与实战选型”成了热门搜索，说明越来越多的人开始意识到：训练出一个高准确率的模型只是第一步，模型到了部署阶段，精度选择直接关系到推理速度、显存占用、功耗和模型文件大小。尤其现在大家喜欢把模型塞进手机、边缘设备，这些资源受限场景对数值格式的要求比PC上更高。

模型训练时默认使用fp32（单精度浮点数，占4字节），这保证了大动态范围和精度。但到了推理时，同样的计算用更高精度的格式未必划算。这里有一个反直觉的事实：在很多深度学习任务中，模型对数值精度的容忍度远高于我们的直觉。用更低的精度做推理，准确率下降可能只有0.1%~0.5%，但推理速度却能翻倍。

5.2 fp32、fp16、bf16、tf32四种格式的差异对比

四者的核心区别在于数字在内存中的编码方式：指数位和服务数字精度的尾数位如何分配。

一句话总结：fp16和bf16都是2字节，但fp16保留了更多尾数位而牺牲了指数范围，bf16反其道而行之，保留和fp32相同的指数范围但尾数位更少。tf32则是NVIDIA专为Tensor Core设计的取巧方案——它占用4字节，但计算时只使用19位，相当于把fp32的计算量大幅压缩。

对于新手，最容易踩的坑是：把模型转为fp16后，loss或输出突然变成NaN。原因通常是fp16的指数范围太窄（最大值约65504），一旦中间张量计算中出现大数就溢出了。bf16就是为了解决这个问题诞生的，它的指数范围和fp32完全一样，所以不会因为数量级溢出而崩溃。但bf16的尾数位只有7位，精度损失比fp16更明显，适合对精度容忍度更高的场景。

5.3 TensorFlow里的混合精度和量化，实操怎么做

TensorFlow 2.x提供了非常简洁的混合精度API。所谓混合精度，不是让整个模型全部使用低精度，而是让一部分算子（比如矩阵乘法）用更高吞吐的fp16来计算，其他一些对精度敏感的算子（比如BatchNormalization、Loss计算）继续保持fp32。这样就兼顾了速度和数值稳定性。

python复制from tensorflow.keras import mixed_precision

# 开启混合精度训练
policy = mixed_precision.Policy('mixed_float16')
mixed_precision.set_global_policy(policy)

开启之后，你的模型训练速度在支持Tensor Core的NVIDIA GPU上可能提升2~3倍。注意，这里的mixed_float16策略会在模型内部自动把可用算子转成fp16，同时把某些算子保留在fp32。这正是入门者最容易忽略的地方：只看到精度格式的名字，不知道真正发挥作用的是“混合”这两个字。

到了部署端，TensorFlow Lite的量化工具是你最常用的武器。最简单的量化方式是动态范围量化，它把权重转成int8、在推理时再把int8权重计算出的结果还原为浮点。整个过程只需要一行API调用，无需重新训练：

python复制import tensorflow as tf

# 先转换为TFLite格式
converter = tf.lite.TFLiteConverter.from_saved_model('saved_model')
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# 保存为.tflite文件
with open('model_quantized.tflite', 'wb') as f:
    f.write(tflite_model)

这行代码生成的模型大小通常能减少到原来的四分之一，而准确率下降通常不到1%。如果你的应用场景是移动端或者边缘设备，这就是你必须掌握的部署手段。

5.4 部署精度的选型建议，别把路走窄了

我个人的选型经验，可以总结成一张决策表：

新手最容易犯的错误是听到“量化提速”就无脑给所有模型上int8，结果在关键应用里精度崩了。所以最稳妥的流程是：先跑通fp32的推理基准，记录准确率作为基线；再做量化，对比量化后的准确率差了多少；如果差异可接受，再谈部署。这个流程虽然废话，但能帮你从源头上避免莫名其妙的事故。

6. 新手最容易踩的坑，和排查思路

6.1 训练loss不降，我的排查链路

模型开始训练后，loss纹丝不动或者居高不下，这是新手最容易崩溃的时刻。我先说一个结论：绝大部分loss不降的问题，根源不是模型结构太差，而是数据处理或者训练配置的问题。我自己有一套排查顺序，从成本最低的开始试：

• 第一步，检查数据归一化。像素值是不是还在0-255？标签有没有和特征对齐？我见过最离谱的一次是数据集的图片和标签错位了，模型学了个寂寞。
• 第二步，检查损失函数。多分类用的是categorical_crossentropy但标签是整数编码？这种错误会有报错提示，但如果是sparse_categorical_crossentropy配上了one-hot标签，模型也能跑，只是准确率永远上不去。
• 第三步，降低学习率。把Adam的learning_rate从1e-3降到1e-4，等待50步观察loss是否有微弱的下降趋势。如果有，说明之前学习率太大导致梯度震荡，无法收敛。
• 第四步，减少网络复杂度。如果网络有大量参数而训练数据很少，模型会直接过拟合，训练集loss可能下降但验证集loss一直在涨。这时候应该先减少层数或通道数。

6.2 过拟合：从训练准确率100%到测试准确率60%的落差

过拟合的典型信号是：训练集准确率不断上升，甚至接近100%，但验证集准确率在某个epoch之后开始下降。这说明模型在“背诵”训练数据，而不是在“理解”规律。处理过拟合的方法优先级从高到低排列：

第一是数据增强。图像任务里，随机翻转、随机裁剪、随机改变对比度和亮度，这些操作成本极低，却能让模型的泛化能力大幅提升。TensorFlow Keras里实现数据增强也非常简单，可以通过tf.keras.layers.RandomFlip、RandomRotation、RandomZoom等内置层直接嵌入网络：

python复制data_augmentation = tf.keras.Sequential([
    layers.RandomFlip("horizontal"),
    layers.RandomRotation(0.1),
    layers.RandomZoom(0.1),
])

第二是加Dropout，它的作用是随机丢弃部分神经元，防止某些神经元单独决定输出。第三是早停，在验证集指标不再改善时停止训练，这个之前已经提过。第四是降低模型容量，不要一上来就用ResNet50这种大网络处理一个小数据集。

6.3 显存不足、版本兼容、模型保存加载——三个高频小毛病

显存不足（OOM）在Windows上最常见的报错是CUDA_OUT_OF_MEMORY。原因要么是batch size太大，要么是同时加载了多个模型没有释放gpu内存。新手优先调小batch size；如果模型输入尺寸可变，可以用tf.config.set_memory_growth让GPU显存按需分配，而不是一次性占用全部剩余显存：

python复制gpus = tf.config.list_physical_devices('GPU')
if gpus:
    try:
        for gpu in gpus:
            tf.config.experimental.set_memory_growth(gpu, True)
    except RuntimeError as e:
        print(e)

版本兼容问题在搜索词里也一直很热门。很多旧教程里的代码是TensorFlow 1.x的，里面有tf.Session()、tf.placeholder()、tf.get_variable()这类API，在2.0里基本都删了。遇到老代码，最简单的处理方式是直接搜索“这个API在TF2里的替代方案”，不要试图在新版本里兼容旧API。

模型保存与加载有两个常用方式。model.save('my_model.keras')会保存完整的模型结构、权重、优化器状态，tf.keras.models.load_model()可以一键加载，但注意如果你自定义了层或模型类，加载时必须确保自定义类在作用域内，否则会报找不到类的错误。model.save_weights('my_weights.h5')只保存权重，加载时需要先手动搭好同样的网络结构，然后再load_weights，这种方式更轻量，适合迁移学习和推理部署。

7. 一点个人体会

最后说点真心话。这一路走来，我最大的感受是：深度学习入门真正难的从来不是数学公式，而是环境配置那一地鸡毛、调试信息那一堆报错、和网上教程版本不一致时的那种无助。TensorFlow 2.0和Keras的组合，把其中很大一部分复杂度消除了——你不需要理解计算图是怎么构建的，不需要手动写反向传播，只需要按直觉搭好网络、喂数据，剩下的交给框架。

如果你正在入门，我的建议是：不要试图一次性啃完所有理论，先跑通一个CIFAR-10级别的完整项目，然后再回头去看那些理论问题，你会发现以前看不懂的东西突然变得具体了。模型训练这个环节本身是很有节奏感的——loss和accuracy的变化曲线像心电图一样反馈你的每一次调整，这种即时反馈带来的学习效率，远高于单纯看书。

另外说一个我踩过很多次后才养成的小习惯：每次训练前，先把固定随机种子、数据划分和模型结构记录清楚，哪怕只是写在一个文本文件里。深度学习的实验变量太多，没有记录的话，你根本不知道三天前那个70%准确率的模型用的什么参数，到时候只能从头再跑一遍。这个小习惯，可能比任何调参技巧都更早让你变成一个正经的深度学习工程师。