用户输入

"什么是机器学习"

        │
        ▼
① Tokenizer
─────────────────────
["什么","是","机器","学习"]

        │
        ▼
② Token ID
─────────────────────
[3,5,7,9]

        │
        ▼
③ Embedding
─────────────────────
[[0.2,0.5,...],
 [0.8,0.1,...],
 ...]

        │
        ▼
④ Transformer
─────────────────────
Attention
MLP
LayerNorm
...
得到新的隐藏状态

        │
        ▼
⑤ Linear
─────────────────────
变成 vocab_size 个分数(Logits)

        │
        ▼
⑥ Softmax
─────────────────────
每个Token一个概率

"一种" 0.42
"人工智能"0.31
"模型"0.15
...

        │
        ▼
⑦ 选择概率最大的Token

输出：
"一种"

        │
        ▼
加入输入

"什么 是 机器 学习 一种"

继续预测...

import numpy as np

# ==========================================================
# 1. Sigmoid 激活函数
# ==========================================================
# 神经元输出不能直接使用加权和
# 而是需要经过激活函数
#
# Sigmoid 可以把任意数字压缩到 0~1
#
#    输入：-10   -1    0    1    10
#    输出：0.00 0.27 0.50 0.73 1.00
#
def sigmoid(x):
    return 1 / (1 + np.exp(-x))


# ==========================================================
# Sigmoid 导数
# ==========================================================
# BP反向传播需要计算梯度
#
# Sigmoid'(x)=Sigmoid(x)*(1-Sigmoid(x))
#
def sigmoid_derivative(y):
    return y * (1 - y)


# ==========================================================
# 2. 训练数据
# ==========================================================
#
# 输入：
# 天气（晴=1 雨=0）
# 是否周末（周末=1 工作日=0）
# 身体状态（好=1 差=0）
#
# 输出：
# 是否去骑车
#
X = np.array([
    [1, 1, 1],   # 晴天 周末 身体好
    [1, 0, 1],   # 晴天 工作日 身体好
    [0, 1, 1],   # 雨天 周末 身体好
    [1, 1, 0],   # 晴天 周末 身体差
    [0, 0, 1],   # 雨天 工作日 身体好
    [0, 1, 0],   # 雨天 周末 身体差
    [1, 0, 0],   # 晴天 工作日 身体差
    [0, 0, 0]    # 雨天 工作日 身体差
])

# 标签（真实答案）
Y = np.array([
    [1],
    [1],
    [0],
    [0],
    [0],
    [0],
    [0],
    [0]
])


# ==========================================================
# 3. 初始化网络参数
# ==========================================================

np.random.seed(0)

# 输入层(3) ------> 隐藏层(4)
#
# W1 大小：
#
#      隐藏1 隐藏2 隐藏3 隐藏4
# 天气
# 周末
# 身体
#
W1 = np.random.randn(3, 4)

# 隐藏层偏置
b1 = np.zeros((1, 4))

# 隐藏层(4) ------> 输出层(1)
W2 = np.random.randn(4, 1)

# 输出层偏置
b2 = np.zeros((1, 1))

# 学习率
learning_rate = 0.5


# ==========================================================
# 4. 开始训练
# ==========================================================
#
# BP神经网络训练流程：
#
# 前向传播
#      ↓
# 得到预测值
#      ↓
# 计算误差
#      ↓
# 反向传播
#      ↓
# 更新权重
#
for epoch in range(10000):

    # ======================================================
    # 第一步：前向传播（Forward）
    # ======================================================

    # 输入层 -> 隐藏层
    #
    # hidden_input =
    # X × W1 + b1
    #
    hidden_input = np.dot(X, W1) + b1

    # 隐藏层经过激活函数
    hidden_output = sigmoid(hidden_input)

    # 隐藏层 -> 输出层
    final_input = np.dot(hidden_output, W2) + b2

    # 输出层激活
    prediction = sigmoid(final_input)

    # ======================================================
    # 第二步：计算误差
    # ======================================================
    #
    # prediction：AI预测
    # Y：真实答案
    #
    error = Y - prediction

    # 均方误差(MSE)
    loss = np.mean(error ** 2)

    # ======================================================
    # 第三步：反向传播（Back Propagation）
    # ======================================================

    # -----------------------------
    # 输出层梯度
    # -----------------------------
    #
    # 告诉输出层：
    # "你应该修改多少"
    #
    d_output = error * sigmoid_derivative(prediction)

    # -----------------------------
    # 隐藏层误差
    # -----------------------------
    #
    # 输出层误差
    #        ↓
    #   传播回隐藏层
    #
    hidden_error = np.dot(d_output, W2.T)

    # 隐藏层梯度
    d_hidden = hidden_error * sigmoid_derivative(hidden_output)

    # ======================================================
    # 第四步：更新权重
    # ======================================================

    # 更新隐藏层 -> 输出层权重
    W2 += learning_rate * np.dot(hidden_output.T, d_output)

    # 更新输出层偏置
    b2 += learning_rate * np.sum(d_output, axis=0, keepdims=True)

    # 更新输入层 -> 隐藏层权重
    W1 += learning_rate * np.dot(X.T, d_hidden)

    # 更新隐藏层偏置
    b1 += learning_rate * np.sum(d_hidden, axis=0, keepdims=True)

    # 每1000轮打印一次Loss
    if epoch % 1000 == 0:
        print(f"Epoch {epoch:5d}  Loss={loss:.6f}")


# ==========================================================
# 5. 测试
# ==========================================================

print("\n============== 测试结果 ==============\n")

tests = {
    "晴天 周末 身体好": [1, 1, 1],
    "晴天 周末 身体差": [1, 1, 0],
    "雨天 周末 身体好": [0, 1, 1],
    "晴天 工作日 身体好": [1, 0, 1],
}

for name, sample in tests.items():

    x = np.array([sample])

    # 前向传播
    hidden = sigmoid(np.dot(x, W1) + b1)
    output = sigmoid(np.dot(hidden, W2) + b2)

    print(f"{name:<15} -> 去骑车概率：{output[0,0]:.3f}")

       训练开始
           │
           ▼
    输入训练数据(X)
           │
           ▼
   初始化权重(W1、W2)
           │
           ▼
    ┌─────────────┐
    │ 前向传播     │
    │ Input → Hidden → Output │
    └─────────────┘
           │
           ▼
    得到预测值 Prediction
           │
           ▼
   与真实值 Y 比较计算 Loss
           │
           ▼
    ┌─────────────┐
    │ 反向传播 BP   │
    │ Output → Hidden │
    └─────────────┘
           │
           ▼
更新权重 W1、W2 和偏置 b1、b2
           │
           ▼
   Loss 是否足够小？
     │           │
    否           是
     │           │
     └────继续训练┘
           ▼
       输出训练好的模型