从零手写AI：拆解线性回归、神经网络与自注意力机制

在AI技术浪潮席卷全球的今天，你是否曾感到困惑：那些看似高深莫测的数学模型、复杂精妙的算法逻辑以及支撑起整个AI系统的庞大架构，究竟是如何被创造出来的？对于许多开发者而言，理解AI的原理往往停留在调用API和调整参数层面，知其然而不知其所以然。Prof. Tom Yeh的“亲手打造的AI”专栏，为我们提供了一条独特的路径——通过回归最原始的手写推导和构建，来拆解AI背后的数学、算法与架构。本文将带你深入解读这一理念，并尝试用同样的“手写”精神，从零开始构建几个核心的AI概念，让你不仅会用AI，更能亲手“打造”AI。

1. 专栏理念与核心价值：为什么需要“手写”AI？

在快餐式的技术学习环境中，“手写”构建AI听起来似乎效率低下。然而，这正是Prof. Tom Yeh专栏的精髓所在。其核心价值在于建立深刻的理解与直觉。

1.1 从“黑盒”到“白盒”：打破认知壁垒

现代AI框架（如TensorFlow, PyTorch）封装了极其复杂的运算，使得开发者可以快速搭建模型。但这带来了一个副作用：模型成了一个“黑盒”。我们输入数据，得到结果，但对中间发生的矩阵变换、梯度流动、损失计算等关键过程一无所知。这种认知状态是脆弱的，一旦模型表现不佳或出现诡异错误，排查将异常困难。

“手写”意味着我们暂时抛开这些高级框架，使用最基础的编程语言（如Python的NumPy）甚至纸笔，去一步步实现某个算法或模型的前向传播、反向传播。这个过程强迫我们直面每一个数学公式和逻辑判断，将“黑盒”彻底打开，变成完全透明的“白盒”。

1.2 构建坚实的数学与算法基础

AI的三大支柱是数学、算法和架构。

• 数学：线性代数、微积分、概率论是AI的通用语言。例如，神经网络的本质是矩阵乘法（线性代数）和链式法则求导（微积分）。
• 算法：从最简单的线性回归、K-Means聚类，到复杂的反向传播、注意力机制，都是一套明确的、可执行的步骤序列。
• 架构：如何将数学和算法组织起来，形成如LeNet、Transformer等高效、可扩展的系统，这是工程能力的体现。

通过手写实现，你将不得不厘清：

• 这个损失函数是如何从数学公式翻译成代码的？
• 梯度下降的每一步更新，权重矩阵究竟发生了什么变化？
• Self-Attention机制中的Q, K, V矩阵是如何计算并产生权重的？

这种深度的理解，是单纯调用model.fit()无法获得的。

1.3 培养解决未知问题的能力

当你能从零构建一个经典模型时，你就获得了拆解任何新论文、新模型的能力。你可以快速识别出新架构中的核心创新点究竟是新的数学变换、新的算法流程，还是新的模块组合方式。这种能力让你不仅能复现，更能创新。

2. 环境准备：你的“手写”工作台

我们不需要复杂的GPU集群或特定的AI框架。一个纯净的Python环境加上基础的科学计算库就足够了。这模拟了最原始的“从第一性原理出发”的构建环境。

核心环境要求：

• Python 3.8+: 现代Python环境。
• NumPy: 用于高效的矩阵和数值计算。这是我们实现所有数学运算的基石。
• Matplotlib: 用于可视化结果，如损失曲线、数据分布、模型决策边界。

安装命令：

# 使用pip安装 pip install numpy matplotlib # 如果你使用Anaconda conda install numpy matplotlib

验证安装：

import numpy as np import matplotlib.pyplot as plt print(f"NumPy version: {np.__version__}") # 创建一个简单的数组并运算 a = np.array([1, 2, 3]) b = np.array([4, 5, 6]) print(f"a + b = {a + b}") print("环境准备就绪！")

我们将在一个Jupyter Notebook或一个简单的Python脚本中完成所有“手写”代码，确保每一步都可交互、可验证。

3. 核心拆解一：从线性回归理解机器学习本质

线性回归是机器学习世界的“Hello World”。让我们用手写的方式，完整实现它，理解模型、损失函数、优化算法这个机器学习铁三角。

3.1 数学原理与模型定义

线性回归假设目标y和特征x之间存在线性关系：y = w * x + b。 其中：

• w(weight): 权重，表示特征的重要性。
• b(bias): 偏置，表示基准值。

给定一组数据(x_i, y_i)，我们的目标是找到一组参数(w, b)，使得模型预测值y_pred_i = w * x_i + b与真实值y_i尽可能接近。

损失函数（Loss Function）：我们使用均方误差（MSE）来衡量“接近”的程度。Loss = (1/N) * Σ(y_i - y_pred_i)^2目标是最小化这个损失函数。

优化算法（Optimization）：我们使用梯度下降（Gradient Descent）。通过计算损失函数对参数w和b的梯度（导数），并沿着梯度反方向（即下降最快的方向）更新参数。w = w - learning_rate * ∂Loss/∂wb = b - learning_rate * ∂Loss/∂b

3.2 手写实现代码

我们不使用sklearn的LinearRegression，而是用NumPy从头实现。

import numpy as np import matplotlib.pyplot as plt # 1. 生成模拟数据 np.random.seed(42) # 确保结果可复现 X = 2 * np.random.rand(100, 1) # 100个样本，1个特征，范围[0,2) true_w = 4 true_b = 3 y = true_w * X + true_b + np.random.randn(100, 1) * 0.5 # 加入噪声 # 2. 初始化模型参数 w = np.random.randn(1) # 随机初始化权重 b = np.zeros(1) # 偏置初始化为0 learning_rate = 0.01 # 学习率 n_iterations = 1000 # 迭代次数 # 3. 梯度下降核心循环 loss_history = [] # 记录损失变化 for iteration in range(n_iterations): # 前向传播：计算预测值 y_pred = w * X + b # 计算损失 (MSE) loss = np.mean((y_pred - y) ** 2) loss_history.append(loss) # 反向传播：计算梯度（手动求导） # ∂Loss/∂w = (2/N) * Σ(y_pred - y) * X # ∂Loss/∂b = (2/N) * Σ(y_pred - y) dw = (2 / len(X)) * np.dot((y_pred - y).T, X).flatten() db = (2 / len(X)) * np.sum(y_pred - y) # 更新参数 w = w - learning_rate * dw b = b - learning_rate * db # 每100次迭代打印一次 if iteration % 100 == 0: print(f"Iteration {iteration}: loss = {loss:.4f}, w = {w[0]:.4f}, b = {b[0]:.4f}") print(f"\n训练完成！最终参数: w = {w[0]:.4f}, b = {b[0]:.4f}") print(f"真实参数: w = {true_w}, b = {true_b}") # 4. 可视化结果 plt.figure(figsize=(12, 4)) # 子图1：数据与拟合线 plt.subplot(1, 2, 1) plt.scatter(X, y, alpha=0.7, label='Training data') X_line = np.array([[0], [2]]) # 生成两个点画线 y_line = w * X_line + b plt.plot(X_line, y_line, 'r-', linewidth=3, label=f'Our model: y={w[0]:.2f}x+{b[0]:.2f}') plt.xlabel('X') plt.ylabel('y') plt.title('Linear Regression Fit') plt.legend() plt.grid(True) # 子图2：损失下降曲线 plt.subplot(1, 2, 2) plt.plot(loss_history) plt.xlabel('Iteration') plt.ylabel('Loss (MSE)') plt.title('Gradient Descent: Loss Convergence') plt.grid(True) plt.tight_layout() plt.show()

3.3 代码拆解与思考

• 前向传播：y_pred = w * X + b，这就是我们的模型，简单的一次线性变换。
• 损失计算：np.mean((y_pred - y) ** 2)，对应MSE公式。
• 梯度计算：我们手动推导了MSE对w和b的偏导数，并用NumPy实现了向量化计算。这是理解优化如何发生的核心。
• 参数更新：w = w - learning_rate * dw，这是梯度下降的实质。

通过这个简单的例子，你已经亲手实现了机器学习最核心的闭环：预测 -> 计算误差 -> 根据误差调整模型。所有复杂的神经网络，都是在这个基本环上叠加了更复杂的变换（激活函数）和更深的层次。

4. 核心拆解二：构建一个微型神经网络（MLP）

理解了线性回归，我们就可以组合多个这样的“线性变换+非线性激活”，构建一个真正的多层感知机（MLP），这是深度学习的基础单元。

4.1 从单层到多层：引入非线性

单个线性回归器能力有限，无法拟合复杂模式（如异或问题）。解决方案是：

1. 堆叠多个线性层。
2. 在每个线性层后加入非线性激活函数（如ReLU, Sigmoid），这样网络就能拟合任意复杂的连续函数。

一个最简单的两层MLP前向传播公式为：h = ReLU(X * W1 + b1)y_pred = h * W2 + b2其中ReLU(x) = max(0, x)。

4.2 手写实现一个二分类MLP

我们将实现一个具有一个隐藏层的MLP，用于解决简单的二分类问题。

import numpy as np import matplotlib.pyplot as plt from sklearn.datasets import make_moons from sklearn.model_selection import train_test_split # 1. 生成非线性可分数据（月牙形） X, y = make_moons(n_samples=300, noise=0.2, random_state=42) y = y.reshape(-1, 1) # 将标签变为列向量 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # 2. 定义网络结构参数 input_size = 2 # 输入特征数 (x1, x2) hidden_size = 8 # 隐藏层神经元数量 output_size = 1 # 输出层神经元数量 (二分类，可以用一个神经元+sigmoid) learning_rate = 0.1 epochs = 2000 # 3. 初始化参数（使用He初始化，适合ReLU） def initialize_parameters(input_size, hidden_size, output_size): np.random.seed(1) W1 = np.random.randn(input_size, hidden_size) * np.sqrt(2. / input_size) b1 = np.zeros((1, hidden_size)) W2 = np.random.randn(hidden_size, output_size) * np.sqrt(2. / hidden_size) b2 = np.zeros((1, output_size)) return {'W1': W1, 'b1': b1, 'W2': W2, 'b2': b2} params = initialize_parameters(input_size, hidden_size, output_size) # 4. 定义激活函数及其导数 def relu(x): return np.maximum(0, x) def relu_derivative(x): return (x > 0).astype(float) def sigmoid(x): return 1 / (1 + np.exp(-x)) # 5. 前向传播 def forward_propagation(X, params): W1, b1, W2, b2 = params['W1'], params['b1'], params['W2'], params['b2'] # 第一层: 线性变换 + ReLU Z1 = np.dot(X, W1) + b1 A1 = relu(Z1) # 第二层: 线性变换 + Sigmoid (输出概率) Z2 = np.dot(A1, W2) + b2 A2 = sigmoid(Z2) # A2就是预测概率 y_pred cache = {'Z1': Z1, 'A1': A1, 'Z2': Z2, 'A2': A2} return A2, cache # 6. 计算损失（二元交叉熵） def compute_loss(y_pred, y_true): m = y_true.shape[0] # 避免log(0)的情况，进行数值稳定处理 loss = -np.mean(y_true * np.log(y_pred + 1e-8) + (1 - y_true) * np.log(1 - y_pred + 1e-8)) return loss # 7. 反向传播（手动推导梯度！） def backward_propagation(X, y_true, params, cache): m = X.shape[0] W1, W2 = params['W1'], params['W2'] A1, A2, Z1 = cache['A1'], cache['A2'], cache['Z1'] # 输出层梯度 dZ2 = A2 - y_true # 这是Sigmoid+BCE损失求导后的简洁形式 dW2 = (1 / m) * np.dot(A1.T, dZ2) db2 = (1 / m) * np.sum(dZ2, axis=0, keepdims=True) # 隐藏层梯度 dA1 = np.dot(dZ2, W2.T) dZ1 = dA1 * relu_derivative(Z1) # 链式法则，乘以激活函数的导数 dW1 = (1 / m) * np.dot(X.T, dZ1) db1 = (1 / m) * np.sum(dZ1, axis=0, keepdims=True) gradients = {'dW1': dW1, 'db1': db1, 'dW2': dW2, 'db2': db2} return gradients # 8. 更新参数 def update_parameters(params, gradients, learning_rate): params['W1'] -= learning_rate * gradients['dW1'] params['b1'] -= learning_rate * gradients['db1'] params['W2'] -= learning_rate * gradients['dW2'] params['b2'] -= learning_rate * gradients['db2'] return params # 9. 训练循环 train_losses = [] test_losses = [] for epoch in range(epochs): # 训练集前向传播和反向传播 y_pred_train, cache_train = forward_propagation(X_train, params) loss_train = compute_loss(y_pred_train, y_train) train_losses.append(loss_train) gradients = backward_propagation(X_train, y_train, params, cache_train) params = update_parameters(params, gradients, learning_rate) # 每隔一定轮次在测试集上评估 if epoch % 100 == 0: y_pred_test, _ = forward_propagation(X_test, params) loss_test = compute_loss(y_pred_test, y_test) test_losses.append(loss_test) if epoch % 500 == 0: print(f"Epoch {epoch}: Train Loss = {loss_train:.4f}, Test Loss = {loss_test:.4f}") # 10. 评估与可视化 def predict(X, params): y_pred, _ = forward_propagation(X, params) return (y_pred > 0.5).astype(int) # 将概率转换为0/1类别 y_pred_train_final = predict(X_train, params) y_pred_test_final = predict(X_test, params) train_accuracy = np.mean(y_pred_train_final == y_train) test_accuracy = np.mean(y_pred_test_final == y_test) print(f"\n训练准确率: {train_accuracy:.2%}") print(f"测试准确率: {test_accuracy:.2%}") # 绘制决策边界 plt.figure(figsize=(15, 5)) plt.subplot(1, 3, 1) plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train.flatten(), cmap='coolwarm', edgecolors='k') plt.title('Training Data') plt.xlabel('Feature 1') plt.ylabel('Feature 2') plt.subplot(1, 3, 2) # 生成网格点来绘制决策边界 h = 0.02 x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5 y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5 xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) Z = predict(np.c_[xx.ravel(), yy.ravel()], params) Z = Z.reshape(xx.shape) plt.contourf(xx, yy, Z, cmap='coolwarm', alpha=0.8) plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test.flatten(), cmap='coolwarm', edgecolors='k', marker='^') plt.title(f'Decision Boundary (Test Acc: {test_accuracy:.2%})') plt.xlabel('Feature 1') plt.ylabel('Feature 2') plt.subplot(1, 3, 3) plt.plot(train_losses, label='Train Loss') # 由于测试损失不是每轮都计算，需要插值绘制 test_epochs = np.arange(0, epochs, 100) plt.plot(test_epochs, test_losses, label='Test Loss', marker='o') plt.xlabel('Epoch') plt.ylabel('Loss (Binary Cross-Entropy)') plt.title('Training History') plt.legend() plt.grid(True) plt.tight_layout() plt.show()

4.3 关键点解析

1. 参数初始化：使用了He初始化 (np.sqrt(2. / input_size))，这对ReLU激活函数更有效，能缓解梯度消失/爆炸。
2. 激活函数：隐藏层使用ReLU提供非线性；输出层使用Sigmoid将输出压缩到(0,1)区间，表示概率。
3. 损失函数：使用二元交叉熵（BCE），这是二分类问题的标准损失。
4. 反向传播：这是核心中的核心。代码中的dZ2 = A2 - y_true是Sigmoid+BCE组合求导后的优雅结果。我们手动实现了链式法则，将误差从输出层逐层反向传播到每一层的权重和偏置。
5. 决策边界：通过可视化，我们可以看到这个手写的MLP成功学习到了一个非线性的决策边界，将两类数据分开。

至此，你已经不借助任何深度学习框架，亲手实现并训练了一个能解决非线性分类问题的神经网络。你清晰地看到了数据如何流动（前向），误差如何反向传播并指导参数更新。

5. 核心拆解三：窥探Transformer架构的基石——Self-Attention

Transformer架构是当今大语言模型（如GPT、BERT）的基石，而Self-Attention（自注意力）机制是其最核心的创新。让我们尝试拆解这个看似复杂的概念。

5.1 Self-Attention的直觉理解

想象你在阅读一句话：“The animal didn't cross the street because it was too tired.” 这里的it指的是什么？是animal还是street？人类会自然地将it与animal关联起来。Self-Attention机制让模型具备这种能力，它允许序列中的每个位置（单词）去“注意”序列中所有其他位置的信息，并根据相关性动态地聚合信息。

5.2 手写实现一个简易的Self-Attention

我们忽略批量处理和多头机制，实现一个最基础的、针对单个序列的Self-Attention。

import numpy as np def softmax(x): """稳定的Softmax函数""" exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True)) # 减去最大值防止溢出 return exp_x / np.sum(exp_x, axis=-1, keepdims=True) def scaled_dot_product_attention(Q, K, V, mask=None): """ 实现缩放点积注意力。 参数: Q: 查询矩阵 (seq_len, d_k) K: 键矩阵 (seq_len, d_k) V: 值矩阵 (seq_len, d_v) mask: 可选的掩码矩阵 (seq_len, seq_len) 返回: output: 注意力加权后的输出 (seq_len, d_v) attention_weights: 注意力权重 (seq_len, seq_len) """ d_k = Q.shape[-1] # 1. 计算Q和K的点积 scores = np.dot(Q, K.T) # (seq_len, seq_len) # 2. 缩放 scores = scores / np.sqrt(d_k) # 3. 可选：应用掩码（如解码器的掩码，防止看到未来信息） if mask is not None: scores = scores + mask * -1e9 # 将掩码位置设为负无穷，softmax后接近0 # 4. 应用Softmax得到注意力权重 attention_weights = softmax(scores) # (seq_len, seq_len) # 5. 权重乘以V，得到最终输出 output = np.dot(attention_weights, V) # (seq_len, d_v) return output, attention_weights # 让我们用一个极简的例子来演示 # 假设我们有一个包含3个单词的序列，每个单词用4维向量表示（嵌入维度d_model=4） np.random.seed(0) seq_len = 3 d_model = 4 # 随机生成输入序列 X (3个单词，每个单词4维向量) X = np.random.randn(seq_len, d_model) print("输入序列 X (shape: {}):\n{}".format(X.shape, X)) # 在标准Transformer中，Q, K, V是通过线性变换从X得到的。 # 为了简化，我们假设权重矩阵W_Q, W_K, W_V是单位矩阵，即 Q=K=V=X。 # 在实际中，它们是不同的可学习参数。 W_Q = np.eye(d_model) # 简化为单位矩阵 W_K = np.eye(d_model) W_V = np.eye(d_model) Q = np.dot(X, W_Q) K = np.dot(X, W_K) V = np.dot(X, W_V) print("\n查询矩阵 Q (shape: {}):\n{}".format(Q.shape, Q)) print("\n键矩阵 K (shape: {}):\n{}".format(K.shape, K)) print("\n值矩阵 V (shape: {}):\n{}".format(V.shape, V)) # 计算自注意力 output, attn_weights = scaled_dot_product_attention(Q, K, V) print("\n注意力权重矩阵 (shape: {}):".format(attn_weights.shape)) print(attn_weights) print("\n每个单词的注意力输出 (shape: {}):".format(output.shape)) print(output) # 解释：注意力权重矩阵的第i行，表示第i个单词对所有单词（包括自己）的注意力分数。 # 输出矩阵的第i行，是第i个单词根据注意力权重对V（值）的加权和，即它“注意”到的信息。 print("\n--- 解读 ---") print(f"对于单词0（X[0]），它对单词0、1、2的注意力分数分别为：{attn_weights[0]}") print(f"因此，单词0的新表示（output[0]）是：") print(f" {attn_weights[0][0]:.2f} * V[0] + {attn_weights[0][1]:.2f} * V[1] + {attn_weights[0][2]:.2f} * V[2]") print(f" 最终结果：{output[0]}")

5.3 从Self-Attention到Transformer

上面的代码展示了最核心的注意力计算。在一个完整的Transformer中：

1. 多头注意力（Multi-Head Attention）：将d_model维的Q、K、V投影到多个（如8个）低维子空间（d_k,d_v），在每个头上并行计算注意力，最后将结果拼接并投影。这允许模型同时关注来自不同表示子空间的信息。
2. 位置编码（Positional Encoding）：Self-Attention本身没有顺序信息，需要向输入嵌入中加入位置编码。
3. 前馈网络（Feed-Forward Network）：对注意力输出进行非线性变换。
4. 残差连接与层归一化（Add & Norm）：为了训练更深的网络，每个子层（注意力、前馈）都包裹着残差连接和层归一化。

通过手写Self-Attention，你理解了Transformer如何让模型动态地、有选择地聚焦于输入序列的不同部分，这是其强大上下文理解能力的根源。

6. 常见问题与手写实践中的坑点

在亲手实现这些算法的过程中，你一定会遇到各种问题。以下是典型问题及解决思路：

梯度检验示例：这是验证你手写的反向传播是否正确的最可靠方法。

def gradient_checking(X, y, params, forward_prop, compute_loss, epsilon=1e-7): """ 数值梯度检验。 通过微扰参数，计算损失的近似梯度，与反向传播计算的梯度进行比较。 """ # 将参数字典展平为一个向量 param_vector, shapes, keys = _flatten_params(params) grad_vector = _flatten_grads(backward_propagation(X, y, params, forward_prop(X, params)[1]))[0] num_grads = np.zeros_like(param_vector) for i in range(len(param_vector)): # 创建参数向量的副本，并对第i个元素施加微小扰动 theta_plus = np.copy(param_vector) theta_minus = np.copy(param_vector) theta_plus[i] += epsilon theta_minus[i] -= epsilon # 将扰动后的向量恢复为参数字典 params_plus = _restore_params(theta_plus, shapes, keys) params_minus = _restore_params(theta_minus, shapes, keys) # 计算扰动后的损失 loss_plus = compute_loss(forward_prop(X, params_plus)[0], y) loss_minus = compute_loss(forward_prop(X, params_minus)[0], y) # 数值梯度近似 num_grads[i] = (loss_plus - loss_minus) / (2 * epsilon) # 计算反向传播梯度和数值梯度的差异 diff = np.linalg.norm(grad_vector - num_grads) / (np.linalg.norm(grad_vector) + np.linalg.norm(num_grads)) print(f"梯度检验差异度: {diff}") if diff < 1e-7: print("✅ 反向传播实现正确！") else: print("❌ 反向传播可能有误，请检查代码。") return diff # 注意：_flatten_params, _restore_params 等辅助函数需要根据你的参数结构实现。

7. 最佳实践与工程化思考

将“手写”的洞见迁移到工程实践中，能极大提升你的AI开发能力。

1. 从理解到调试：当你用PyTorch训练一个复杂模型出现问题时，如果你亲手实现过反向传播，你会本能地去检查梯度流（model.parameters()的grad属性），怀疑是某一层的激活函数饱和了，而不是盲目地调整学习率。
2. 自定义层和损失函数：框架提供的层和损失函数并非万能。当你有特殊需求时（如一个新的注意力变体、一个领域特定的损失函数），手写的经验让你能自信地继承nn.Module或Function类，实现自定义模块。
3. 模型轻量化与部署：理解每个操作的数学本质，有助于你在模型部署时进行有效的融合、量化和剪枝。你知道哪些操作是计算密集型的（如大矩阵乘法），哪些是内存访问密集型的。
4. 阅读论文与复现：当一篇AI论文提出一个新架构时，你能快速抓住其核心创新点：是提出了新的注意力计算方式？是改进了优化算法？还是设计了新的模块连接方式？你能将其核心公式翻译成可运行的代码。
5. 构建个人知识体系：将手写实现的代码、公式推导、问题笔记整理成你自己的“AI构建手册”。这比收藏无数篇博客文章更有价值。

8. 总结与学习路线建议

Prof. Tom Yeh的“亲手打造的AI”专栏精神，其价值远超过学会几个模型。它培养的是一种第一性原理的思考方式和拆解复杂系统的能力。

建议的学习路线：

1. 夯实基础：从线性回归、逻辑回归开始，彻底弄懂损失函数、梯度下降。
2. 深入神经网络：实现一个全连接MLP，理解前向/反向传播、激活函数、初始化。
3. 征服CNN：手写卷积、池化操作，理解局部连接、权值共享、特征图。
4. 理解RNN/LSTM：实现时间步循环，理解隐藏状态和梯度在时间上的传播。
5. 拆解Transformer：实现Self-Attention、多头注意力、位置编码，并尝试组合成一个Decoder-Only或Encoder-Decoder小模型。
6. 探索优化算法：实现SGD、Momentum、Adam，比较其收敛特性。
7. 转向现代框架：在有了深厚的手写基础后，再用PyTorch/TensorFlow去实现相同的模型。此时，框架的API对你而言将是透明的，你关注的是如何更高效、更优雅地组织代码。

记住，目标不是永远手写，而是通过手写获得深刻理解，从而更自信、更高效地使用高级工具，并具备创造新工具的能力。下次当你面对一个复杂的AI系统时，试着问自己：“如果让我从零开始，我能否勾勒出它的核心骨架？” 这就是“亲手打造的AI”带给你的终极礼物。