AI 的数学地基：三个最少必要知识块

import numpy as np

# 向量：一摞有序的数，模型里几乎所有东西的形态
v = np.array([1.0, 2.0, 3.0])
print(v.shape)                 # (3,)

# 矩阵乘法：把同一个「变换」批量作用到一摞列向量上
A = np.array([[1.0, 0.0],
              [0.0, 2.0]])     # 对角阵：x 不动，y 翻倍
V = np.array([[1.0, 2.0],
              [3.0, 4.0]])     # 两列 = 两个被变换的向量
print(A @ V)
# [[1. 2.]
#  [6. 8.]]

# 第一个 softmax：任意一组数 → 和为 1 的概率分布
def softmax(x, t=1.0):
    e = np.exp((x - x.max()) / t)   # 减 max 防溢出；除以 t 是温度
    return e / e.sum()

print(softmax(np.array([2.0, 1.0, 0.1])).round(3))
# [0.659 0.242 0.099]

$ python warmup.py
(3,)
[[1. 2.]
 [6. 8.]]
[0.659 0.242 0.099]

import torch

logits = torch.tensor([2.0, 1.0, 0.1])
print(torch.softmax(logits, dim=-1))
# tensor([0.6590, 0.2418, 0.0992])：与 numpy 版完全一致
print(torch.softmax(logits / 0.7, dim=-1))
# tensor([0.7658, 0.1835, 0.0507])：温度 0.7，第一类更敢押注

A = np.diag([2.0, 3.0])            # 变换机器：x 放大 2 倍，y 放大 3 倍
v = np.array([1.0, 1.0])
print(A @ v)                       # [2. 3.]：一次乘法，批量变换

u = np.array([1.0, 0.0, 1.0]); w = np.array([1.0, 1.0, 0.0])
cos = u @ w / (np.linalg.norm(u) * np.linalg.norm(w))
print(cos.round(3))                # 0.5：夹角 60°，方向只算半像

vals, vecs = np.linalg.eig(A)      # 特征向量：变换后方向不变的方向
print(vals)                        # [2. 3.]：坐标轴本身就是它的特征向量

x = np.array([[1.0, 2.0, 3.0, 4.0]])               # 一个样本，4 维
W = np.arange(8, dtype=float).reshape(4, 2) / 10   # 4 个输入 × 2 个神经元
b = np.array([0.1, -0.1])
print(x @ W + b)
# [[4.1 4.9]]：这就是 nn.Linear 的全部数学

p_dis = 0.01                 # 患病率 P(D)：基础率
p_pos_dis = 0.99             # 敏感度 P(+|D)：有病的人 99% 验出阳性
p_pos_ok = 0.05              # 假阳性 P(+|健康)：健康人也有 5% 阳性
p_pos = p_dis * p_pos_dis + (1 - p_dis) * p_pos_ok
print(p_dis * p_pos_dis / p_pos)     # 贝叶斯公式逐项代入
# 0.1666…：阳性结果里只有约 1/6 真有病

p = np.array([0.7, 0.2, 0.1])          # 模型给出的预测分布
y1 = np.array([1, 0, 0]); y3 = np.array([0, 0, 1])
print((-np.sum(y1 * np.log(p))).round(3))   # 0.357：押对了，代价小
print((-np.sum(y3 * np.log(p))).round(3))   # 2.303：押错到只剩 10%，代价大

x = np.array([3.0, 2.0, 0.5])
for t in (0.5, 1.0, 2.0):
    e = np.exp((x - x.max()) / t)
    print(t, (e / e.sum()).round(2))
# 0.5 [0.88 0.12 0.01]   温度越低分布越尖：0.88 → 0.69 → 0.53
# 1.0 [0.69 0.25 0.06]
# 2.0 [0.53 0.32 0.15]

p = np.array([0.5, 0.5])
print(-(p * np.log(p)).sum())     # 0.6931：五五开，最拿不准
q = np.array([0.99, 0.01])
print(-(q * np.log(q)).sum())     # 0.0560：快确定了，熵很小

import torch

x = torch.tensor(2.0, requires_grad=True)
y = (x - 3) ** 2            # 同一只碗
y.backward()                # 自动求导：链式法则全自动
print(x.grad)               # tensor(-2.)：和手推的 2*(2-3) 一致

f  = lambda x: (x - 3) ** 2          # 一只碗
df = lambda x: 2 * (x - 3)          # 导数 = 斜率

h = 1e-6                            # 数值导数验算：中心差分
print((f(2.0 + h) - f(2.0 - h)) / (2 * h))
# -2.0000000001…，真实导数正是 -2

x = 0.0                             # 梯度下降：沿负梯度滚到碗底
for _ in range(60):
    x -= 0.1 * df(x)                # lr = 0.1
print(x)                            # 2.9999954…：基本到底了

import numpy as np

rng = np.random.default_rng(0)          # 固定种子，结果可复现
X = rng.uniform(-1, 1, (64, 1))         # 64 个标量样本，形状 (64, 1)
Y = 3 * X + 1                           # 要学的目标：一条直线

W1 = rng.normal(0, 1, (1, 16)); b1 = np.zeros(16)   # 隐藏层参数
W2 = rng.normal(0, 1, (16, 1)); b2 = np.zeros(1)    # 输出层参数
lr = 0.05                               # 学习率：每步走多远

h = np.tanh(X @ W1 + b1)        # (64,1)@(1,16) → (64,16)，非线性压到 -1~1
y = h @ W2 + b2                 # (64,16)@(16,1) → (64,1)，网络输出
loss = np.mean((y - Y) ** 2)    # MSE：平均平方误差，越小学得越像

dy = 2 * (y - Y) / y.size       # dL/dy：MSE 对输出的导数
dW2, db2 = h.T @ dy, dy.sum(0)  # 输出层梯度：上游差 × 本层输入
dh = dy @ W2.T * (1 - h ** 2)   # 穿过 tanh：它的导数是 1 − tanh²
dW1, db1 = X.T @ dh, dh.sum(0)  # 隐藏层梯度：同一套乘法再来一遍

import numpy as np

rng = np.random.default_rng(0)
X = rng.uniform(-1, 1, (64, 1))     # 64 个标量样本
Y = 3 * X + 1                       # 目标：学一条直线

W1 = rng.normal(0, 1, (1, 16)); b1 = np.zeros(16)
W2 = rng.normal(0, 1, (16, 1)); b2 = np.zeros(1)
lr = 0.05

for step in range(2001):
    # ---- 前向：线性代数 ----
    h = np.tanh(X @ W1 + b1)
    y = h @ W2 + b2
    loss = np.mean((y - Y) ** 2)

    # ---- 反向：链式法则 ----
    dy = 2 * (y - Y) / y.size
    dW2, db2 = h.T @ dy, dy.sum(0)
    dh = dy @ W2.T * (1 - h ** 2)
    dW1, db1 = X.T @ dh, dh.sum(0)

    # ---- 更新：梯度下降 ----
    W1 -= lr * dW1; b1 -= lr * db1
    W2 -= lr * dW2; b2 -= lr * db2
    if step % 500 == 0:
        print(f"step {step:4d}   loss {loss:.4f}")

x0 = np.array([[0.5]])
pred = np.tanh(x0 @ W1 + b1) @ W2 + b2
print("predict x=0.5 ->", pred.round(2), "(target 2.50)")

step    0   loss 20.8016
step  500   loss 0.0008
step 1000   loss 0.0004
step 1500   loss 0.0004
step 2000   loss 0.0003
predict x=0.5 -> [[2.52]] (target 2.50)

lr = 0.9               # 改大：loss 可能不降反升，甚至 NaN
# lr = 0.005           # 改小：收敛明显变慢
# Y = np.sin(3 * X)    # 换个更难的目标：直线 → 曲线

x = np.array([1000.0, 999.0])
# np.exp(x)              # overflow → inf/inf = nan
e = np.exp(x - x.max())    # 减 max：等价且稳定
print((e / e.sum()).round(3))   # [0.731 0.269]

a = np.array([1.0, 2.0]); b = np.array([3.0, 4.0])
print(a * b)     # [3. 8.]：逐元素相乘，shape 不变
print(a @ b)     # 11.0：点积，出来的是标量

a = np.array([1.0, 2.0, 3.0])        # shape (3,)
b = np.array([[1.0], [2.0], [3.0]])  # shape (3,1)
print((a * b).shape)                 # (3, 3)：广播悄悄扩张了

col = a[:, None]                     # 想要列向量，显式造：(3,1)
print(col.shape)                     # (3, 1)

# 1) 学习率太大：步子迈飞了 → lr 除以 10 再试
# 2) log(0)：概率下溢为 0 → 写成 np.log(p + 1e-9)
# 3) 除零：分母用 y.size 这类真实计数，别写死常数
# 4) 梯度爆炸：连乘后巨大 → clip_grad_norm_ 裁剪一下