1. 从零搭建深度学习环境：TensorFlow 与 Keras 的安装与验证
搞深度学习，环境配置是绕不过去的第一道坎。很多人兴致勃勃打开教程，结果卡在pip install tensorflow这一步就是一整天。我前后在 Windows、Linux、macOS 三套系统上装过不下二十次 TensorFlow，踩过的坑足够写一本小册子。这一节就把环境搭建这件事彻底讲透，让你少走弯路。
1.1 版本选择：TensorFlow 2.x 是唯一正确答案
现在网上还能搜到大量 TensorFlow 1.x 的教程，代码里全是tf.Session()、tf.placeholder()这种写法。如果你照着那些教程敲代码，在 TensorFlow 2.x 环境下会直接报错。所以第一件事：确认你用的是 TensorFlow 2.x。
截至我写这篇内容时，TensorFlow 2.15 是相对稳定的版本，2.16 之后对 Keras 3.0 的支持有较大变动。如果你是新手，我建议直接用 2.15 或 2.13，这两个版本资料最全、坑最少。
# 创建独立虚拟环境（强烈建议，不要装在系统 Python 里） python -m venv tf_env # 激活虚拟环境 # Windows: tf_env\Scripts\activate # Linux/macOS: source tf_env/bin/activate # 安装 TensorFlow pip install tensorflow==2.15.0为什么一定要用虚拟环境？因为 TensorFlow 对 numpy、protobuf 等依赖包的版本要求很严格。你系统里可能已经装了某个版本的 numpy 给其他项目用，直接装 TensorFlow 会把依赖搞乱，最后两个项目都跑不起来。虚拟环境就是给每个项目一个独立的“房间”，互不干扰。
1.2 GPU 支持：CUDA、cuDNN 与驱动的版本匹配
如果你有 NVIDIA 显卡，想用 GPU 加速训练，那版本匹配就是最头疼的事。TensorFlow、CUDA、cuDNN、显卡驱动四者之间有严格的对应关系，错一个就报错。
以 TensorFlow 2.15 为例，它要求：
| 组件 | 版本要求 |
|---|---|
| Python | 3.9 - 3.11 |
| CUDA | 12.2 |
| cuDNN | 8.9 |
| 显卡驱动 | >= 525.60.13 (Linux) / >= 527.41 (Windows) |
安装完 CUDA 和 cuDNN 后，用下面这段代码验证 GPU 是否可用：
import tensorflow as tf print("TensorFlow 版本:", tf.__version__) print("GPU 是否可用:", tf.config.list_physical_devices('GPU')) print("CUDA 版本:", tf.sysconfig.get_build_info()["cuda_version"]) print("cuDNN 版本:", tf.sysconfig.get_build_info()["cudnn_version"])如果GPU 是否可用输出的是空列表[]，说明 GPU 没被识别。常见原因有三个：一是 CUDA/cuDNN 版本不对，二是显卡驱动太旧，三是环境变量没配好。这时候不要急着重装，先逐个排查。
注意：不要同时安装
tensorflow和tensorflow-gpu。TensorFlow 2.15 之后已经合并为一个包，装tensorflow就自带 GPU 支持（前提是 CUDA 环境配好）。装两个反而会冲突。
1.3 验证安装：跑通第一个神经网络
环境装好后，跑一个最简单的全连接网络确认一切正常：
import tensorflow as tf from tensorflow import keras import numpy as np # 造一批简单数据 x_train = np.random.rand(1000, 20) y_train = np.random.randint(0, 2, size=(1000, 1)) # 搭一个三层全连接网络 model = keras.Sequential([ keras.layers.Dense(64, activation='relu', input_shape=(20,)), keras.layers.Dense(32, activation='relu'), keras.layers.Dense(1, activation='sigmoid') ]) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) model.fit(x_train, y_train, epochs=5, batch_size=32, verbose=1)这段代码能跑通，说明你的 TensorFlow + Keras 环境完全没问题。接下来就可以进入 CNN、Transformer 这些真正的模型了。
2. CNN 卷积神经网络：从卷积核到特征图的全流程拆解
CNN 是深度学习的“老大哥”，图像分类、目标检测、语义分割，几乎所有视觉任务都离不开它。但很多人学 CNN 的时候，只是照着教程搭几层Conv2D和MaxPooling2D，对里面的卷积核到底在干什么、特征图为什么能提取特征，其实一知半解。这一节我把 CNN 的核心机制掰开揉碎讲清楚。
2.1 卷积的本质：一个滑动窗口在做什么
卷积操作说白了，就是拿一个小矩阵（卷积核）在输入图像上从左到右、从上到下滑动，每滑到一个位置，就把卷积核和对应区域的像素做逐元素相乘再求和，得到一个数值。滑完整个图像，这些数值拼起来就是一张新的“特征图”。
举个例子，假设输入是一个 5x5 的灰度图，卷积核是 3x3：
输入图像 (5x5): 卷积核 (3x3): 1 2 3 0 1 1 0 -1 0 1 2 3 1 1 0 -1 1 0 1 2 0 1 0 -1 2 1 0 1 2 1 2 1 0 1卷积核在左上角 3x3 区域计算：1*1 + 2*0 + 3*(-1) + 0*1 + 1*0 + 2*(-1) + 1*1 + 0*0 + 1*(-1) = 1 - 3 + 0 - 2 + 1 - 1 = -4。这个 -4 就是输出特征图左上角的值。
这个特定的卷积核（左边一列全 1，右边一列全 -1）其实是一个垂直边缘检测器。当它滑到图像中垂直边缘的位置时，输出值会很大；滑到平坦区域时，输出值接近 0。这就是 CNN 能自动提取特征的底层逻辑——不同的卷积核负责检测不同的模式（边缘、纹理、角点等）。
2.2 用 Keras 搭一个完整的 CNN 图像分类器
理论讲完，直接上代码。下面是一个在 CIFAR-10 数据集上做 10 分类的 CNN：
import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers # 加载 CIFAR-10 数据 (x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data() # 归一化：把像素值从 0-255 缩到 0-1 x_train = x_train.astype('float32') / 255.0 x_test = x_test.astype('float32') / 255.0 # 构建 CNN 模型 model = keras.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.BatchNormalization(), 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.BatchNormalization(), layers.MaxPooling2D((2, 2)), layers.Dropout(0.25), # 第三组卷积块 layers.Conv2D(128, (3, 3), activation='relu', padding='same'), layers.BatchNormalization(), layers.MaxPooling2D((2, 2)), layers.Dropout(0.25), # 分类头 layers.Flatten(), layers.Dense(256, activation='relu'), layers.BatchNormalization(), layers.Dropout(0.5), layers.Dense(10, activation='softmax') ]) model.compile( optimizer=keras.optimizers.Adam(learning_rate=0.001), loss='sparse_categorical_crossentropy', metrics=['accuracy'] ) model.summary() # 训练 history = model.fit( x_train, y_train, batch_size=64, epochs=30, validation_split=0.1, verbose=1 )这个模型在 CIFAR-10 上大概能跑到 85% 左右的准确率。下面我逐个解释关键设计决策。
2.3 每个设计决策背后的理由
为什么用padding='same'？如果不加 padding，每次卷积图像尺寸都会缩小 2（3x3 卷积核）。几层下来图像就没了。same模式会在边缘补零，保证输出尺寸和输入一致，这样我们可以堆更多层。
为什么加 BatchNormalization？它把每层的输出归一化到均值 0、方差 1 附近，让训练更稳定、收敛更快。我实测过，同样的网络加不加 BN，收敛速度能差一倍以上。
为什么用 Dropout？防止过拟合。训练时随机“关掉”一部分神经元，强迫网络不依赖某几个特定神经元。注意 Dropout 只在训练时生效，推理时会自动关闭。
为什么卷积核数量逐层翻倍（32→64→128）？浅层提取的是低级特征（边缘、颜色），需要的通道少；深层提取的是高级语义特征（物体部件），需要更多通道来表达。这是 CNN 设计的通用经验法则。
实操心得：如果你的 GPU 显存不够，优先减小 batch_size，而不是减小模型。batch_size 从 64 降到 32 或 16，显存占用会明显下降，但模型表达能力不变。
3. Transformer：注意力机制如何颠覆序列建模
Transformer 是 2017 年那篇《Attention Is All You Need》提出的架构，现在已经成了 NLP 领域的绝对主流，而且正在向视觉（ViT）、语音、时间序列预测等领域全面渗透。它的核心思想是自注意力机制——让序列中每个位置都能直接“看到”其他所有位置，而不是像 RNN 那样一步步传递信息。
3.1 自注意力机制：Q、K、V 到底是什么
自注意力的计算过程可以用一个生活化的类比来理解。想象你在一个嘈杂的聚会上，你想听清某个人说的话。你的大脑会自动给周围的声音分配不同的注意力权重——说话人的声音权重高，背景噪音权重低。自注意力做的就是类似的事。
具体来说，每个输入向量会被映射成三个向量：
- Query（查询）：我想找什么信息
- Key（键）：我能提供什么信息
- Value（值）：我实际包含的信息
计算过程：
import tensorflow as tf from tensorflow.keras import layers class SelfAttention(layers.Layer): def __init__(self, d_model): super().__init__() self.d_model = d_model self.wq = layers.Dense(d_model) self.wk = layers.Dense(d_model) self.wv = layers.Dense(d_model) def call(self, x): q = self.wq(x) # (batch, seq_len, d_model) k = self.wk(x) v = self.wv(x) # 计算注意力分数 scores = tf.matmul(q, k, transpose_b=True) # (batch, seq_len, seq_len) scores = scores / tf.math.sqrt(tf.cast(self.d_model, tf.float32)) # softmax 归一化 weights = tf.nn.softmax(scores, axis=-1) # 加权求和 output = tf.matmul(weights, v) return output, weights为什么要除以sqrt(d_model)？因为当 d_model 很大时，Q 和 K 的点积会变得很大，softmax 之后会变成接近 one-hot 的分布，梯度几乎为零，训练不动。除以sqrt(d_model)把方差拉回到 1 附近，保证梯度健康。
3.2 用 Keras 实现一个完整的 Transformer 编码器
下面是一个可以直接用的 Transformer Encoder Block：
class TransformerEncoderBlock(layers.Layer): def __init__(self, d_model, num_heads, d_ff, dropout_rate=0.1): super().__init__() self.attention = layers.MultiHeadAttention( num_heads=num_heads, key_dim=d_model // num_heads ) self.ffn = keras.Sequential([ layers.Dense(d_ff, activation='relu'), layers.Dense(d_model) ]) self.norm1 = layers.LayerNormalization(epsilon=1e-6) self.norm2 = layers.LayerNormalization(epsilon=1e-6) self.dropout1 = layers.Dropout(dropout_rate) self.dropout2 = layers.Dropout(dropout_rate) def call(self, x, training=False): # 多头注意力 + 残差连接 attn_output = self.attention(x, x) attn_output = self.dropout1(attn_output, training=training) out1 = self.norm1(x + attn_output) # 前馈网络 + 残差连接 ffn_output = self.ffn(out1) ffn_output = self.dropout2(ffn_output, training=training) out2 = self.norm2(out1 + ffn_output) return out2残差连接为什么重要？Transformer 可以堆很深（BERT-base 有 12 层，GPT-3 有 96 层）。如果没有残差连接，梯度在反向传播时会逐层衰减，深层参数根本更新不了。残差连接提供了一条“高速公路”，让梯度直接流到浅层。
LayerNorm 和 BatchNorm 有什么区别？BatchNorm 在 batch 维度上归一化，对 batch_size 敏感；LayerNorm 在特征维度上归一化，跟 batch_size 无关。Transformer 处理的是变长序列，用 LayerNorm 更合适。
3.3 Transformer 做时间序列预测的实战
Transformer 不只用于 NLP，做时间序列预测也很强。下面是一个用 Transformer 预测正弦波的例子：
import numpy as np # 生成正弦波数据 def generate_sine_data(n_samples, seq_len): x = np.linspace(0, 100, n_samples + seq_len) y = np.sin(x) X, Y = [], [] for i in range(n_samples): X.append(y[i:i+seq_len]) Y.append(y[i+seq_len]) return np.array(X), np.array(Y) X, Y = generate_sine_data(5000, 50) X = X[..., np.newaxis] # (5000, 50, 1) # 构建 Transformer 预测模型 inputs = keras.Input(shape=(50, 1)) x = layers.Dense(64)(inputs) x = TransformerEncoderBlock(d_model=64, num_heads=4, d_ff=128)(x) x = layers.GlobalAveragePooling1D()(x) x = layers.Dense(64, activation='relu')(x) outputs = layers.Dense(1)(x) model = keras.Model(inputs, outputs) model.compile(optimizer='adam', loss='mse') model.fit(X, Y, batch_size=32, epochs=20, validation_split=0.1)这个模型能相当准确地预测正弦波的下一个值。你可以把正弦波换成股票价格、气温、销量等真实数据，框架完全一样。
注意：Transformer 对位置信息不敏感（自注意力本身是置换不变的），所以处理序列时一定要加位置编码。上面的例子因为正弦波本身有周期性，简化处理没加，但实际项目中必须加。
4. GAN 生成对抗网络：让两个网络互相博弈
GAN 的思路非常巧妙：用一个生成器（Generator）造假数据，用一个判别器（Discriminator）判断真假，两者互相博弈，最终生成器能造出以假乱真的数据。我第一次跑通 GAN 看到生成的数字图像时，那种感觉还是很震撼的。
4.1 GAN 的核心原理：极小极大博弈
GAN 的目标函数是一个极小极大问题：
min_G max_D V(D, G) = E[log D(x)] + E[log(1 - D(G(z)))]翻译成人话：判别器 D 想最大化这个值（把真数据判为真、假数据判为假），生成器 G 想最小化这个值（让假数据被判别器判为真）。两者交替训练，最终达到纳什均衡。
4.2 用 Keras 实现一个生成手写数字的 GAN
# 生成器：从随机噪声生成 28x28 图像 def build_generator(): model = keras.Sequential([ layers.Dense(128, activation='relu', input_shape=(100,)), layers.BatchNormalization(), layers.Dense(256, activation='relu'), layers.BatchNormalization(), layers.Dense(512, activation='relu'), layers.BatchNormalization(), layers.Dense(28 * 28, activation='tanh'), layers.Reshape((28, 28, 1)) ]) return model # 判别器：判断图像真假 def build_discriminator(): model = keras.Sequential([ layers.Flatten(input_shape=(28, 28, 1)), layers.Dense(512, activation='relu'), layers.Dropout(0.3), layers.Dense(256, activation='relu'), layers.Dropout(0.3), layers.Dense(1, activation='sigmoid') ]) return model generator = build_generator() discriminator = build_discriminator() discriminator.compile(optimizer=keras.optimizers.Adam(0.0002, 0.5), loss='binary_crossentropy', metrics=['accuracy']) # 组合模型：固定判别器，只训练生成器 discriminator.trainable = False gan_input = keras.Input(shape=(100,)) gan_output = discriminator(generator(gan_input)) gan = keras.Model(gan_input, gan_output) gan.compile(optimizer=keras.optimizers.Adam(0.0002, 0.5), loss='binary_crossentropy')训练循环：
# 加载 MNIST (x_train, _), (_, _) = keras.datasets.mnist.load_data() x_train = (x_train.astype('float32') - 127.5) / 127.5 # 归一化到 [-1, 1] x_train = x_train.reshape(-1, 28, 28, 1) batch_size = 128 epochs = 50 for epoch in range(epochs): # 训练判别器 idx = np.random.randint(0, x_train.shape[0], batch_size) real_imgs = x_train[idx] noise = np.random.normal(0, 1, (batch_size, 100)) fake_imgs = generator.predict(noise, verbose=0) d_loss_real = discriminator.train_on_batch(real_imgs, np.ones((batch_size, 1))) d_loss_fake = discriminator.train_on_batch(fake_imgs, np.zeros((batch_size, 1))) d_loss = 0.5 * np.add(d_loss_real, d_loss_fake) # 训练生成器 noise = np.random.normal(0, 1, (batch_size, 100)) g_loss = gan.train_on_batch(noise, np.ones((batch_size, 1))) if epoch % 5 == 0: print(f"Epoch {epoch} | D Loss: {d_loss[0]:.4f} | G Loss: {g_loss:.4f}")4.3 GAN 训练的坑与调参经验
GAN 是出了名的难训练。我踩过的坑包括：判别器太强导致生成器梯度消失、模式崩溃（生成器只会生成同一种图像）、训练震荡不收敛。下面是我总结的几条经验：
判别器不要训练得太强。如果判别器准确率一直接近 100%，生成器就学不到东西。可以降低判别器的学习率，或者减少判别器的训练次数（比如判别器训 1 次，生成器训 2 次）。
用标签平滑。把真实标签从 1.0 改成 0.9，假标签从 0.0 改成 0.1，能缓解判别器过度自信的问题。
模式崩溃的应对。如果生成器只输出相似的图像，可以试试加 minibatch discrimination，或者改用 WGAN（Wasserstein GAN），它的损失函数更平滑，训练更稳定。
实操心得：GAN 训练时一定要定期保存生成的图像样本。我习惯每 5 个 epoch 保存一次，训练完把图像拼成网格看变化过程。这样能直观判断生成器是在进步还是崩了。
5. 胶囊网络：CNN 的挑战者还是补充者
胶囊网络（Capsule Network）是 Geoffrey Hinton 在 2017 年提出的，目的是解决 CNN 的一个根本缺陷：CNN 的池化操作丢失了空间信息。比如一张人脸，眼睛在鼻子上方还是下方，CNN 经过多次池化后可能就分不清了。胶囊网络用“向量”代替“标量”作为神经元输出，向量的方向编码了物体的姿态信息。
5.1 胶囊网络的核心：向量神经元与动态路由
传统神经元的输出是一个标量（一个数），胶囊的输出是一个向量。向量的长度表示某个特征存在的概率，方向表示特征的属性（位置、旋转、大小等）。
胶囊之间通过动态路由机制传递信息。简单说，低层胶囊会“投票”决定把信息传给哪个高层胶囊，路由权重通过迭代更新。这个过程让网络能动态地建立部分与整体之间的关系。
5.2 用 Keras 实现一个简单的胶囊网络
import tensorflow as tf from tensorflow.keras import layers class PrimaryCapsule(layers.Layer): def __init__(self, num_capsules, dim_capsule, kernel_size, strides): super().__init__() self.num_capsules = num_capsules self.dim_capsule = dim_capsule self.conv = layers.Conv2D( num_capsules * dim_capsule, kernel_size, strides=strides, padding='valid', activation='relu' ) def call(self, x): output = self.conv(x) # 重塑为 (batch, num_capsules, dim_capsule) batch = tf.shape(output)[0] output = tf.reshape(output, [batch, -1, self.dim_capsule]) # squash 激活 return self.squash(output) def squash(self, x): norm = tf.norm(x, axis=-1, keepdims=True) return (norm ** 2 / (1 + norm ** 2)) * (x / (norm + 1e-8)) class DigitCapsule(layers.Layer): def __init__(self, num_capsules, dim_capsule, routing_iters=3): super().__init__() self.num_capsules = num_capsules self.dim_capsule = dim_capsule self.routing_iters = routing_iters def build(self, input_shape): self.num_input_capsules = input_shape[1] self.input_dim = input_shape[2] self.W = self.add_weight( shape=(1, self.num_input_capsules, self.num_capsules, self.dim_capsule, self.input_dim), initializer='glorot_uniform', trainable=True ) def call(self, x): # x: (batch, num_input_capsules, input_dim) batch = tf.shape(x)[0] x = tf.expand_dims(x, 2) # (batch, num_in, 1, input_dim) x = tf.expand_dims(x, -1) # (batch, num_in, 1, input_dim, 1) # 变换矩阵乘法 u_hat = tf.matmul(self.W, x) # (batch, num_in, num_out, dim_out, 1) u_hat = tf.squeeze(u_hat, axis=-1) # (batch, num_in, num_out, dim_out) # 动态路由 b = tf.zeros((batch, self.num_input_capsules, self.num_capsules)) for i in range(self.routing_iters): c = tf.nn.softmax(b, axis=-1) s = tf.reduce_sum(c[..., tf.newaxis] * u_hat, axis=1) v = self.squash(s) if i < self.routing_iters - 1: b += tf.reduce_sum(u_hat * v[:, tf.newaxis, :, :], axis=-1) return v def squash(self, x): norm = tf.norm(x, axis=-1, keepdims=True) return (norm ** 2 / (1 + norm ** 2)) * (x / (norm + 1e-8))这个实现比标准 CNN 复杂不少，但核心逻辑就是：低层胶囊的输出通过变换矩阵变成对高层胶囊的“预测”，然后通过动态路由迭代确定传递权重。
5.3 胶囊网络的适用场景与局限
胶囊网络在小数据集（如 MNIST）上表现不错，能很好地捕捉空间关系。但它的计算量比 CNN 大很多，在大规模图像数据集（如 ImageNet）上还没有证明能超过 CNN。我的建议是：如果你的任务对空间关系特别敏感（比如医学图像中的器官位置、工业质检中的缺陷定位），可以试试胶囊网络；如果是通用图像分类，CNN 仍然是更务实的选择。
6. 常见问题与排查技巧实录
这一节整理我在使用 TensorFlow 和 Keras 过程中遇到的高频问题，以及排查思路。
6.1 环境与安装类问题
| 问题现象 | 可能原因 | 解决方法 |
|---|---|---|
ImportError: DLL load failed | Windows 缺少 VC++ 运行库 | 安装 Visual C++ Redistributable |
| GPU 不可用 | CUDA/cuDNN 版本不匹配 | 对照官方版本表重新安装 |
pip install超时 | 网络问题 | 换国内镜像源，如清华源 |
| 内存溢出 OOM | batch_size 太大 | 减小 batch_size 或模型规模 |
| Keras 版本冲突 | 混用了 tf.keras 和独立 keras | 统一用tf.keras |
6.2 训练过程中的典型问题
损失不下降。先检查学习率，太大震荡、太小不收敛。我一般从 0.001 开始试，不行就 0.0001 或 0.01。再检查数据有没有归一化，输入范围差异太大会导致训练困难。
过拟合。训练集准确率很高但验证集很低。加 Dropout、加 L2 正则、做数据增强、减小模型规模，这几个手段按顺序试。
梯度爆炸。损失变成 NaN。加梯度裁剪tf.clip_by_norm，或者降低学习率。
训练速度慢。确认在用 GPU，用tf.config.list_physical_devices('GPU')检查。另外，tf.data.Dataset的prefetch和cache能显著加速数据加载。
6.3 模型保存与部署的注意事项
# 保存整个模型（推荐） model.save('my_model.keras') # 只保存权重 model.save_weights('my_weights.weights.h5') # 加载 loaded_model = keras.models.load_model('my_model.keras')注意：TensorFlow 2.15 之后推荐用
.keras格式保存，旧的.h5格式对自定义层支持不好。如果你有自定义层，加载时需要传custom_objects参数。
7. 模型选型与实战建议
最后聊聊实际项目中怎么选模型。CNN 适合图像和局部模式提取，Transformer 适合长距离依赖和序列建模，GAN 适合生成任务，胶囊网络适合对空间关系敏感的小规模任务。但实际项目往往不是单选，而是组合使用。
比如图像分类可以用 CNN 做特征提取，再接 Transformer 做全局关系建模（这就是 ViT 的思路）。时间序列预测可以用 CNN 提取局部模式，再用 Transformer 捕捉长期依赖。GAN 的生成器也可以用 Transformer 架构（如 StyleGAN 的部分变体）。
我的经验是：先从简单模型开始，跑通 baseline，再逐步加复杂度。很多人一上来就搭最复杂的架构，结果调不通，连问题出在哪都不知道。先用一个三层 CNN 跑通，再换成 ResNet，再试 Transformer，每一步都有对比，才知道什么在起作用。
另外，数据量决定模型上限。几千条数据用 CNN 就够了，几十万条以上才考虑 Transformer 这种大模型。模型再大，数据不够也是过拟合。这个道理我踩过很多次坑才真正理解。
