企业官网建设流程全解析

1. 从零搭建AI工程能力：为什么我劝你别再“调包”了

“ai-engineering-from-scratch”这个标题，第一次看到的时候我愣了一下。不是因为陌生，恰恰相反，是因为太熟悉了。过去两年，我面过不下五十个号称“做过AI项目”的候选人，简历上清一色写着“基于Transformer的文本分类”“调用大模型API实现智能问答”，但当我问一句“注意力机制里的缩放因子为什么要除以根号dk”或者“位置编码为什么用正弦函数而不是直接拼接位置索引”时，能答上来的人不到三成。

这就是问题所在。我们正处在一个“AI能力极度易得”的时代——HuggingFace上几行代码就能加载预训练模型，各大云平台把推理服务封装成HTTP接口，连微调都有LoRA这种几乎零门槛的方案。但易得的另一面是脆弱：你不知道模型为什么work，就不知道它什么时候会fail；你没亲手实现过反向传播，就永远只能停留在“调参侠”的层面。

“ai-engineering-from-scratch”这个项目标题，核心价值不在于教你“用AI”，而在于教你“造AI”。它瞄准的是那些不满足于pip install transformers、想要真正理解每一层张量流动、每一个梯度更新的人。适合谁？我认为有三类人最应该关注：第一类是计算机相关专业的在校生，学校课程还在教几十年前的MLP，但工业界已经在用MoE架构了；第二类是转行做AI的工程师，有编程基础但缺乏系统性的深度学习底层认知；第三类是在职的算法工程师，日常被业务需求推着走，想找个机会把知识体系重新夯实一遍。

这篇文章，我会从项目整体设计思路、核心技术点拆解、实操落地路径、常见坑与排查四个维度，把“从零构建AI工程能力”这件事讲透。不是泛泛而谈“你要学数学”，而是具体到“先写哪个文件、用什么数据结构、怎么验证梯度正确性”。读完你至少能清楚：一个合格的AI工程师，从零到一到底需要跨过哪些坎。

2. 项目整体设计与思路拆解

2.1 为什么“从零实现”比“调包”更有价值

先讲一个我自己的经历。2021年的时候，我接手了一个文本相似度计算的项目，当时图省事，直接用了某个开源库里的Sentence-BERT封装。离线评测指标很好，余弦相似度在测试集上达到了0.87的准确率。但上线之后，线上badcase率飙升，用户反馈“明明意思一样的两个句子，系统说不相似”。排查了两周才发现，问题出在tokenizer的padding策略上——离线评测时用的是动态padding，线上为了批处理效率改成了固定长度padding，导致短句被大量padding token稀释了语义向量。

如果我当时自己从零实现过一遍BERT的推理流程，就会知道attention mask的处理方式会直接影响输出向量的质量。这就是“调包”的代价：你跳过了所有细节，也就跳过了所有理解。

“ai-engineering-from-scratch”这个项目的设计哲学，我理解下来核心就一条：用最小依赖实现最大理解。它不追求性能最优，不追求工程完备，而是追求每一行代码你都能解释清楚为什么这么写。比如实现一个全连接层，不是直接nn.Linear，而是手动定义weight和bias两个Parameter，手动写forward里的矩阵乘法，手动推导反向传播时梯度的形状变换。这个过程很“笨”，但正是这种“笨”让你真正理解自动微分到底在做什么。

从项目结构上看，一个合理的从零实现路线应该包含四个层次：数学基础层（矩阵运算、微积分、概率论）、核心组件层（张量、自动微分、优化器）、模型架构层（MLP、CNN、RNN、Transformer）、工程实践层（训练循环、数据加载、模型保存与加载）。每一层都依赖下一层，不能跳级。我见过太多人直接跳到Transformer，结果连softmax的数值稳定性问题都处理不好。

2.2 技术选型：为什么用NumPy而不是PyTorch

这是被问得最多的问题：“既然要学深度学习，为什么不直接用PyTorch从零写模型？”我的回答很直接：因为PyTorch帮你做了太多事，多到你会忽略掉真正重要的东西。

用NumPy从零实现，你被迫面对所有底层细节。比如实现一个简单的线性回归，用PyTorch你写三行：

model = nn.Linear(1, 1) criterion = nn.MSELoss() optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

但用NumPy，你需要自己定义权重初始化（为什么用Xavier初始化而不是全零？），自己写前向传播（矩阵乘法的维度怎么对齐？），自己推导损失函数对权重的偏导数（链式法则具体怎么展开？），自己实现梯度下降更新（学习率设大了会怎样？）。这一套下来，你对线性回归的理解会深刻十倍。

当然，NumPy方案也有明显的代价。没有GPU加速，训练大一点的模型会慢到怀疑人生；没有自动微分，每加一层都要手动推导梯度，容易出错。所以我的建议是：用NumPy实现核心组件，用PyTorch验证正确性。比如你手写了一个卷积层，可以用PyTorch的nn.Conv2d做对照，确保输出数值一致。这样既保证了理解深度，又保证了工程效率。

还有一个关键选型是测试驱动开发。从零实现AI组件，最怕的就是“看起来能跑，但结果是错的”。梯度算错了，损失函数照样下降，只是收敛到错误的地方。所以每个组件都要有单元测试：梯度检验（数值梯度vs解析梯度）、形状检验（输入输出维度是否匹配）、数值稳定性检验（极端输入下是否溢出）。这些测试代码可能比实现代码还长，但绝对值得。

2.3 学习路径设计：从感知机到Transformer的渐进路线

“ai-engineering-from-scratch”不是一蹴而就的，需要一条清晰的渐进路线。我总结了一个“四阶段”路径，每个阶段都有明确的里程碑。

第一阶段：基础组件（1-2周）。目标是实现一个可用的张量库和自动微分引擎。核心任务包括：实现Tensor类，支持加减乘除、矩阵乘法、reshape、transpose等基本操作；实现计算图，支持反向传播；实现基础优化器（SGD、Momentum）。这个阶段的验收标准是：用自己写的自动微分引擎，能正确计算一个三层MLP的梯度，并且和PyTorch的autograd结果误差小于1e-6。

第二阶段：经典模型（2-3周）。用自己写的组件实现线性回归、逻辑回归、多层感知机、卷积神经网络、循环神经网络。重点不是模型本身，而是理解每种架构的设计动机：为什么CNN需要权值共享？为什么RNN会有梯度消失？LSTM的门控机制到底解决了什么问题？这个阶段的验收标准是：在MNIST上达到98%以上的准确率，在CIFAR-10上达到70%以上。

第三阶段：Transformer与注意力（2-3周）。这是重头戏。从最基础的Scaled Dot-Product Attention开始，逐步实现Multi-Head Attention、Positional Encoding、Layer Normalization、残差连接，最后组装成完整的Transformer Encoder和Decoder。这个阶段最容易踩的坑是维度变换，建议每写一行都打印shape。验收标准是：实现一个迷你GPT，能在小规模文本数据上完成语言建模任务。

第四阶段：工程化与优化（1-2周）。包括混合精度训练、梯度累积、学习率调度、模型量化、推理优化等。这个阶段的目标是让你的从零实现具备一定的实用价值，而不是玩具代码。

整个路径走下来，大概需要6-10周，取决于每天投入的时间。我建议至少保证每天2小时的有效编码时间，周末可以适当加长。切忌贪快，第一阶段如果没吃透，后面会越来越吃力。

3. 核心细节解析与实操要点

3.1 自动微分引擎：计算图与反向传播的手动实现

自动微分是从零实现AI工程能力的第一道坎，也是最能体现“理解深度”的地方。很多人觉得自动微分很神秘，其实核心思想非常简单：把前向传播过程中的所有操作记录下来，形成一个计算图，然后沿着计算图反向应用链式法则。

具体实现上，有两种主流方案：基于 tape 的和基于算子重载的。PyTorch用的是动态图+算子重载，TensorFlow 1.x用的是静态图。从零实现的话，我推荐用算子重载，因为代码更直观。

核心数据结构是一个Tensor类，每个Tensor有两个关键属性：data（存储数值）和grad（存储梯度）。还有一个_backward函数，用来定义这个Tensor的梯度如何传播到它的父节点。每次做运算时，不仅计算结果，还要构建计算图。

举个例子，实现加法：

class Tensor: def __init__(self, data, children=(), op=''): self.data = np.array(data) self.grad = np.zeros_like(self.data) self._backward = lambda: None self._children = set(children) self._op = op def __add__(self, other): other = other if isinstance(other, Tensor) else Tensor(other) out = Tensor(self.data + other.data, (self, other), '+') def _backward(): self.grad += out.grad other.grad += out.grad out._backward = _backward return out

这段代码的关键在于_backward函数。加法的梯度传播规则是：输出梯度原封不动地传给两个输入。所以self.grad += out.grad和other.grad += out.grad。注意这里用的是+=而不是=，因为一个Tensor可能被多次使用，梯度需要累加。

乘法稍微复杂一点：

def __mul__(self, other): other = other if isinstance(other, Tensor) else Tensor(other) out = Tensor(self.data * other.data, (self, other), '*') def _backward(): self.grad += other.data * out.grad other.grad += self.data * out.grad out._backward = _backward return out

乘法的梯度是“交叉相乘”：self的梯度等于other的值乘以输出梯度，反之亦然。这就是链式法则的具体体现。

有了这些基础算子，就可以实现反向传播了。核心逻辑是：对计算图做拓扑排序，然后逆序调用每个节点的_backward函数。

def backward(self): topo = [] visited = set() def build_topo(v): if v not in visited: visited.add(v) for child in v._children: build_topo(child) topo.append(v) build_topo(self) self.grad = np.ones_like(self.data) for v in reversed(topo): v._backward()

这里有个细节：self.grad = np.ones_like(self.data)，为什么初始梯度是1？因为对标量损失函数求自身的导数就是1。如果是向量，需要传入外部梯度，但大多数情况下损失是标量。

注意：实现自动微分时，最容易出错的地方是梯度累加。如果你发现梯度值比预期大很多倍，大概率是某个节点的梯度被重复计算了。检查一下是否在每次前向传播前清空了梯度。

3.2 张量运算与广播机制：维度对齐的底层逻辑

张量运算是深度学习的基石，而广播机制是张量运算中最容易让人困惑的部分。很多人写代码时遇到shape不匹配就瞎试，试到不报错为止，但根本不知道为什么能跑通。

广播机制的核心规则只有一条：从最后一个维度开始，逐个维度比较，要么相等，要么其中一个为1，要么其中一个不存在。满足这三个条件之一，就可以广播。

举个例子：形状为(3, 1, 5)的张量和形状为(4, 5)的张量相加。从最后一维开始：5和5相等，通过；倒数第二维：1和4，其中一个为1，通过；倒数第三维：3和不存在，通过。所以结果形状是(3, 4, 5)。

实现广播的关键是stride的计算。在NumPy中，广播后的张量并不实际复制数据，而是通过设置stride为0来实现“虚拟扩展”。比如一个形状为(1, 5)的张量广播到(3, 5)，它的stride从(5, 1)变成(0, 1)，意味着沿着第一个维度移动时，内存地址不变，始终指向同一行数据。

从零实现张量库时，我建议先实现一个broadcast_shapes函数，用来计算两个形状广播后的结果形状：

def broadcast_shapes(shape1, shape2): result = [] for dim1, dim2 in zip_longest(reversed(shape1), reversed(shape2), fillvalue=1): if dim1 == 1: result.append(dim2) elif dim2 == 1: result.append(dim1) elif dim1 == dim2: result.append(dim1) else: raise ValueError(f"Cannot broadcast {shape1} and {shape2}") return tuple(reversed(result))

然后实现broadcast_to函数，把张量扩展到目标形状。这里的关键是计算新的stride：如果某个维度被扩展了（从1变成N），对应的stride设为0。

实操心得：调试张量运算时，养成随时打印shape的习惯。我通常在每个函数入口和出口都加一行print(f"{op}: {x.shape} -> {out.shape}")，虽然看起来笨，但能省下大量排查时间。

3.3 优化器实现：从SGD到Adam的演进逻辑

优化器是训练神经网络的核心组件。很多人直接用torch.optim.Adam，但不知道Adam里的betas参数到底在做什么。从零实现一遍，这些问题都会迎刃而解。

朴素SGD最简单：param = param - lr * grad。但它的缺点很明显：对所有参数用同一个学习率，遇到不同尺度的梯度时容易震荡。

Momentum引入了“速度”的概念：v = beta * v + grad; param = param - lr * v。这就像给梯度下降加了一个惯性，能加速收敛并减少震荡。beta通常取0.9，意味着历史梯度的权重衰减很慢。

RMSProp则是对学习率进行自适应调整：cache = beta * cache + (1-beta) * grad^2; param = param - lr * grad / (sqrt(cache) + eps)。梯度大的参数学习率自动变小，梯度小的参数学习率自动变大。

Adam结合了Momentum和RMSProp：同时维护一阶矩（梯度的指数移动平均）和二阶矩（梯度平方的指数移动平均），并做偏差校正。偏差校正这一步很多人不理解，其实原因很简单：初始时刻一阶矩和二阶矩都初始化为0，导致估计值偏向0，需要除以(1 - beta^t)来校正。

class Adam: def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8): self.params = list(params) self.lr = lr self.beta1, self.beta2 = betas self.eps = eps self.m = [np.zeros_like(p.data) for p in self.params] self.v = [np.zeros_like(p.data) for p in self.params] self.t = 0 def step(self): self.t += 1 for i, p in enumerate(self.params): self.m[i] = self.beta1 * self.m[i] + (1 - self.beta1) * p.grad self.v[i] = self.beta2 * self.v[i] + (1 - self.beta2) * (p.grad ** 2) m_hat = self.m[i] / (1 - self.beta1 ** self.t) v_hat = self.v[i] / (1 - self.beta2 ** self.t) p.data -= self.lr * m_hat / (np.sqrt(v_hat) + self.eps)

注意：Adam的默认学习率1e-3在大多数情况下都能work，但如果你发现训练初期loss震荡严重，可以尝试调小到1e-4。另外，Adam对batch size比较敏感，batch size很小时（比如小于16），二阶矩的估计会很不稳定，这时候可以考虑用SGD+Momentum。

3.4 注意力机制：从数学公式到代码实现

注意力机制是Transformer的核心，也是从零实现中最有挑战性的部分。它的数学公式看起来很简单：

Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V

但实现起来有几个关键细节。

首先是缩放因子。为什么要除以sqrt(d_k)？假设Q和K的每个元素都是独立同分布的，均值为0，方差为1，那么QK^T的每个元素是d_k个乘积之和，方差会变成d_k。当d_k很大时（比如512），点积的结果会非常大，导致softmax的输入进入饱和区，梯度接近0。除以sqrt(d_k)就是把方差拉回1，保证softmax的输入在合理范围内。

其次是mask的处理。在解码器中，需要防止模型看到未来的token，所以要加一个上三角为负无穷的mask。实现时，在softmax之前把mask位置的logits设为一个很大的负数（比如-1e9），这样softmax之后这些位置的概率就接近0。

def scaled_dot_product_attention(Q, K, V, mask=None): d_k = Q.shape[-1] scores = Q @ K.transpose(-2, -1) / np.sqrt(d_k) if mask is not None: scores = np.where(mask, scores, -1e9) attn_weights = softmax(scores, axis=-1) return attn_weights @ V

Multi-Head Attention则是在这个基础上，把Q、K、V分别投影到多个子空间，并行计算注意力，最后拼接起来。这里的关键是投影矩阵的维度设计：如果模型维度是d_model，头数是h，那么每个头的维度是d_model // h。这样总计算量和单头注意力差不多，但模型能同时关注不同位置的不同特征。

实操心得：实现注意力时，最容易出错的是维度变换。建议在纸上画出每个张量的形状，标注清楚batch_size、seq_len、num_heads、head_dim这些维度。我通常会在代码里用注释标注形状，比如# (batch, heads, seq_len, head_dim)，这样调试时一目了然。

4. 实操过程与核心环节实现

4.1 环境准备与项目骨架搭建

动手之前，先把环境搭好。我的建议是：Python 3.10+、NumPy、Matplotlib、PyTorch（仅用于验证）。不需要CUDA，因为从零实现阶段主要在CPU上跑小模型。项目结构可以这样组织：

ai-from-scratch/ ├── core/ │ ├── tensor.py # Tensor类与基础运算 │ ├── autograd.py # 自动微分引擎 │ ├── nn.py # 层与模块 │ └── optim.py # 优化器 ├── models/ │ ├── mlp.py │ ├── cnn.py │ ├── rnn.py │ └── transformer.py ├── utils/ │ ├── data.py # 数据加载 │ └── metrics.py # 评估指标 ├── tests/ │ ├── test_tensor.py │ ├── test_autograd.py │ └── test_models.py └── train.py # 训练入口

这个结构的好处是职责清晰：core放底层组件，models放模型定义，utils放辅助工具，tests放单元测试。每个模块都可以独立测试，不会互相干扰。

环境配置上，我强烈建议用虚拟环境：

python -m venv venv source venv/bin/activate # Linux/Mac pip install numpy matplotlib torch pytest

注意：PyTorch只用来做数值验证，不要用它来构建模型。如果你发现自己不自觉地想用nn.Module，说明你在偷懒，赶紧回到NumPy实现。

4.2 手写全连接层与反向传播验证

全连接层是最基础的组件，也是验证自动微分引擎是否正确的试金石。一个全连接层的数学表达是：y = xW + b，其中x是输入，W是权重，b是偏置。

实现时，权重初始化很关键。全零初始化会导致所有神经元对称，梯度完全相同，网络永远学不到东西。我通常用Xavier初始化：W = np.random.randn(fan_in, fan_out) * np.sqrt(2.0 / (fan_in + fan_out))。这个公式的推导基于保持前向传播和反向传播的方差一致。

class Linear: def __init__(self, in_features, out_features): self.W = Tensor(np.random.randn(in_features, out_features) * np.sqrt(2.0 / (in_features + out_features))) self.b = Tensor(np.zeros(out_features)) def __call__(self, x): return x @ self.W + self.b def parameters(self): return [self.W, self.b]

验证反向传播是否正确，最可靠的方法是梯度检验。核心思想是：用数值微分近似计算梯度，和解析梯度对比。数值微分的公式是：f'(x) ≈ (f(x+h) - f(x-h)) / (2h)，其中h取一个很小的值（比如1e-5）。

def gradient_check(f, x, h=1e-5): analytical_grad = x.grad numerical_grad = np.zeros_like(x.data) for i in range(x.data.size): original = x.data.flat[i] x.data.flat[i] = original + h f_plus = f().data x.data.flat[i] = original - h f_minus = f().data x.data.flat[i] = original numerical_grad.flat[i] = (f_plus - f_minus) / (2 * h) diff = np.abs(analytical_grad - numerical_grad).max() return diff

如果diff小于1e-6，说明反向传播实现正确。如果diff很大，检查链式法则的每一步，特别是涉及广播的操作。

4.3 训练循环与损失函数实现

训练循环是连接数据、模型、损失函数、优化器的枢纽。一个标准的训练循环包含以下步骤：

1. 前向传播：output = model(input)
2. 计算损失：loss = criterion(output, target)
3. 清空梯度：optimizer.zero_grad()
4. 反向传播：loss.backward()
5. 更新参数：optimizer.step()

损失函数方面，分类任务用交叉熵，回归任务用均方误差。交叉熵的实现要注意数值稳定性：直接计算-log(softmax(x))可能会溢出，正确的做法是用log-sum-exp技巧。

def cross_entropy(logits, targets): # logits: (batch, num_classes) # targets: (batch,) 整数标签 max_logits = np.max(logits, axis=-1, keepdims=True) shifted = logits - max_logits log_probs = shifted - np.log(np.sum(np.exp(shifted), axis=-1, keepdims=True)) batch_size = logits.shape[0] loss = -np.mean(log_probs[np.arange(batch_size), targets]) return loss

训练过程中，我习惯每100个step打印一次loss和准确率，每1000个step保存一次模型。这样既能监控训练进度，又不会因为意外中断丢失太多进度。

实操心得：训练初期loss不下降，先检查学习率是不是太大了。我遇到过好几次loss直接变成nan，最后发现是学习率设成了0.1，对于Adam来说太大了。另外，如果loss下降但准确率不涨，可能是数据标签有问题，建议随机抽样几个样本人工检查。

4.4 从MLP到Transformer的完整实现路线

有了前面的基础，就可以逐步搭建更复杂的模型了。我建议按照以下顺序推进：

第一步：MLP on MNIST。用两层全连接层，隐藏层维度256，激活函数ReLU，输出层10维。训练10个epoch，准确率应该能达到97%以上。这个阶段的目标是跑通完整流程。

第二步：CNN on CIFAR-10。实现卷积层、池化层、BatchNorm。卷积层的实现可以用im2col技巧：把输入特征图展开成矩阵，然后用矩阵乘法计算卷积。这样能利用NumPy的BLAS加速。训练50个epoch，准确率应该能达到70%以上。

第三步：RNN/LSTM on 文本分类。实现基础的RNN单元，然后加上门控机制变成LSTM。这个阶段重点是理解序列建模的思路，以及梯度消失问题的解决方案。

第四步：Transformer on 语言建模。实现完整的Encoder-Decoder架构，在小型语料上训练一个字符级语言模型。这个阶段最复杂，建议先实现Encoder，验证无误后再加Decoder。

每个阶段都要写单元测试，确保每个组件的输出和PyTorch一致。比如卷积层，可以用torch.nn.Conv2d做对照，确保输出数值误差小于1e-5。

5. 常见问题与排查技巧实录

5.1 梯度消失与梯度爆炸的排查与解决

梯度消失和梯度爆炸是从零实现深度学习时最常见的两个问题。梯度消失表现为：靠近输入的层梯度接近0，参数几乎不更新；梯度爆炸表现为：梯度值变得极大，参数更新后loss直接变成nan。

排查方法很简单：在反向传播后，打印每一层参数的梯度范数。如果发现某些层的梯度范数比其他层小几个数量级，就是梯度消失；如果梯度范数超过1e3，就是梯度爆炸。

解决方案方面，梯度消失可以用ReLU激活函数（代替Sigmoid）、BatchNorm、残差连接来缓解。梯度爆炸则用梯度裁剪：grad = np.clip(grad, -max_norm, max_norm)，通常max_norm取1.0或5.0。

注意：梯度裁剪要在参数更新之前做，而且是对所有参数的梯度整体裁剪，不是逐个元素裁剪。整体裁剪能保持梯度的方向不变，只限制大小。

5.2 数值稳定性问题：softmax溢出与log-sum-exp技巧

数值稳定性问题在实现softmax、交叉熵、注意力机制时经常遇到。核心原因是exp(x)在x很大时会溢出，在x很小时会下溢到0。

解决方案是log-sum-exp技巧：计算softmax(x)时，先减去最大值max(x)，这样exp的输入最大为0，不会溢出。数学上可以证明，减去常数不改变softmax的结果。

def softmax(x, axis=-1): x_max = np.max(x, axis=axis, keepdims=True) exp_x = np.exp(x - x_max) return exp_x / np.sum(exp_x, axis=axis, keepdims=True)

交叉熵的实现也要用类似技巧，先对logits做log_softmax，再取负对数。这样避免了先softmax再log的两步计算，减少了数值误差。

5.3 训练不收敛的常见原因速查表

训练不收敛的原因很多，我整理了一个速查表，按排查优先级排序：

这个表是我踩了无数坑之后总结出来的，基本上覆盖了80%的训练问题。遇到问题先查表，能省很多时间。

5.4 从零实现与框架实现的性能差距分析

很多人关心：从零实现的代码，性能比PyTorch差多少？我实测下来，在CPU上，纯NumPy实现的MLP训练速度大约是PyTorch的1/5到1/10。差距主要来自三个方面：没有GPU加速、没有算子融合、没有内存优化。

但这个差距是可以缩小的。比如用np.dot代替手写循环，能利用BLAS加速；用im2col实现卷积，能把卷积变成矩阵乘法；用float32代替float64，能减少一半内存带宽。我优化过的NumPy实现，在MNIST上训练一个三层MLP，一个epoch大约需要3秒，和PyTorch CPU版本差距不到3倍。

当然，从零实现的目的不是替代框架，而是理解框架。当你自己实现过一遍之后，再看PyTorch的源码，会有一种“原来如此”的顿悟感。这种理解带来的价值，远超过性能上的差距。

6. 从零实现之后：如何继续深入AI工程

走完从零实现的路线，你对深度学习的理解已经超过了大多数“调包侠”。但这只是起点，不是终点。接下来有几个方向可以继续深入。

方向一：阅读经典论文并复现。从AlexNet、VGG、ResNet到Transformer、BERT、GPT，每篇论文都代表了一个技术突破。复现论文不仅能加深理解，还能锻炼工程能力。我建议从ResNet开始，因为它的残差连接思想影响了后续几乎所有架构。

方向二：深入特定领域。计算机视觉、自然语言处理、强化学习、生成模型，每个领域都有独特的技术栈。选一个你感兴趣的方向，深入下去。比如做CV，可以研究目标检测、语义分割、图像生成；做NLP，可以研究预训练、微调、提示工程。

方向三：工程化与部署。从零实现的模型如何部署到生产环境？需要考虑模型压缩、推理优化、服务化等问题。这个方向更偏工程，但同样重要。我见过太多算法工程师只会训练模型，不会部署，导致模型永远停留在实验室。

方向四：参与开源项目。GitHub上有很多从零实现深度学习的项目，参与这些项目能让你接触到更规范的代码、更严格的测试、更高效的协作。我自己的很多编程习惯，都是在参与开源项目的过程中养成的。

最后分享一个我个人的小技巧：建立自己的代码片段库。把常用的组件（各种层、损失函数、优化器、数据增强）整理成可复用的模块，加上详细的注释和测试。这样下次做新项目时，可以直接拿来用，不用从头写。我的片段库已经积累了上百个模块，覆盖了从数据处理到模型部署的全流程，效率提升非常明显。

这个方向后续还可以这样扩展：把你从零实现的组件和PyTorch的对应组件做性能对比，写一个benchmark报告；或者用你的从零实现去参加Kaggle比赛，看看能拿到什么名次。这些实践都会让你对AI工程的理解更加立体。