深度学习

运行一个完整示例 · 01

给全连接层标明各轴

行表示记录，列表示特征。

import numpy as np
x = np.array([[2.,1.,0.], [0.,3.,1.]])
w = np.array([[1.,-1.], [2.,0.], [0.,3.]])
b = np.array([0.5,-0.5])
out = x @ w + b
print('shape:', out.shape)
print('output:', out.tolist())
print('mean per feature:', out.mean(axis=0).tolist())
print('mean per recording:', out.mean(axis=1).tolist())

python dl-tensors-dl-dense-axis-check.py

shape: (2, 2)
output: [[4.5, -2.5], [6.5, 2.5]]
mean per feature: [5.5, 0.0]
mean per recording: [1.0, 4.5]

逐步读懂代码

@ 将每个输入行与每个权重列组合。加 b 时，两项偏置在各记录间重复。shape 报告轴长度。mean(axis=0) 消去记录轴，mean(axis=1) 消去特征轴。不同均值说明轴命名的重要性。权重为手工选择，代码只是层运算，不是训练好的记录分类器。

运行一个完整示例 · 01

打印函数值与斜率

小型预设输入让计算容易检查。

from math import exp
for z in [-2.,0.,2.]:
    relu = max(0.,z)
    sigmoid = 1/(1+exp(-z))
    slope = sigmoid*(1-sigmoid)
    print(f'z={z:.0f}: ReLU={relu:.1f}, sigmoid={sigmoid:.6f}, slope={slope:.6f}')

python dl-activations-dl-activation-values.py

z=-2: ReLU=0.0, sigmoid=0.119203, slope=0.104994
z=0: ReLU=0.0, sigmoid=0.500000, slope=0.250000
z=2: ReLU=2.0, sigmoid=0.880797, slope=0.104994

逐步读懂代码

循环分别计算三个输入。max 实现 ReLU，exp 提供 sigmoid 指数，sigmoid*(1−sigmoid) 计算解析导数。格式化输出显示 −2 与 2 的斜率对称。这个直接 sigmoid 表达式适合当前小数值；大幅值输入需要数值稳健实现。

运行一个完整示例 · 01

追踪两个隐藏单元

用 NumPy 向量实现列向量公式。

import numpy as np
w1 = np.array([[1.,-1.], [-1.,1.]])
b1 = np.array([-1.,-1.])
w2 = np.array([1.,1.]); b2 = 0.
for values in [[3.,1.], [1.,3.], [2.,2.]]:
    x = np.array(values)
    hidden = np.maximum(0, w1 @ x + b1)
    output = w2 @ hidden + b2
    print('input:', values, 'hidden:', hidden.tolist(), 'output:', float(output))
print('parameters:', w1.size + b1.size + w2.size + 1)

python dl-representations-dl-mlp-gauges.py

input: [3.0, 1.0] hidden: [1.0, 0.0] output: 1.0
input: [1.0, 3.0] hidden: [0.0, 1.0] output: 1.0
input: [2.0, 2.0] hidden: [0.0, 0.0] output: 0.0
parameters: 9

逐步读懂代码

w1 @ x 计算两个加权和。加 b1 等于减去容差。maximum 对各单元应用 ReLU。第二次点积加总剩余信号。size 统计存储的标量，最后加一统计输出偏置。权重为手工设计，用于展示表示能力，脚本没有拟合参数。

运行一个完整示例 · 01

计算稳定概率与交叉熵

Python 示例中的类别编号从零开始。

import numpy as np
logits = np.array([2.,1.,0.]); target = 0
def softmax(values):
    shifted = values-values.max()
    weights = np.exp(shifted)
    return weights/weights.sum()
probabilities = softmax(logits)
loss = -np.log(probabilities[target])
print('probabilities:', np.round(probabilities,6).tolist())
print(f'sum: {probabilities.sum():.6f}; loss: {loss:.6f}')
print('shift unchanged:', bool(np.allclose(probabilities,softmax(logits+1000))))

python dl-softmax-loss-dl-stable-softmax-loss.py

probabilities: [0.665241, 0.244728, 0.090031]
sum: 1.000000; loss: 0.407606
shift unchanged: True

逐步读懂代码

max 找到平移值。exp 将相对分数转为正权重，除以总和完成归一化。用 target 索引取正确类别概率，再以 log 计算损失。allclose 在浮点容差内检查平移不变性。这行简单损失适合当前 logits；极端情况应使用稳定的 log-sum-exp 损失实现。

运行一个完整示例 · 02

概率下溢时仍能计算有限损失

米娜发现网络给错误类别极大的分数，目标类别的概率被舍入为零，直接算 -log(概率) 就出问题。她回到 logits，用 log-sum-exp 计算交叉熵，损失仍然有限。随后逐一微调 logit，用数值斜率核对解析梯度。

from math import exp, log, isclose

def probabilities(logits):
    peak = max(logits)
    weights = [exp(z - peak) for z in logits]
    return [w / sum(weights) for w in weights]

def cross_entropy(logits, target):
    peak = max(logits)
    return (peak - logits[target]) + log(sum(exp(z - peak) for z in logits))

logits = [1000.0, 0.0, -1000.0]
target = 2
p = probabilities(logits)
loss = cross_entropy(logits, target)
gradient = [value - int(j == target) for j, value in enumerate(p)]
epsilon = 1e-4
numeric = []
for j in range(len(logits)):
    plus, minus = logits.copy(), logits.copy()
    plus[j] += epsilon
    minus[j] -= epsilon
    numeric.append((cross_entropy(plus, target) - cross_entropy(minus, target)) / (2 * epsilon))
assert p[target] == 0.0 and loss == 2000.0
assert all(isclose(a, b, abs_tol=1e-6) for a, b in zip(gradient, numeric))
print("target probability:", p[target])
print(f"finite loss: {loss:.1f}")
print("analytic gradient:", gradient)
print("numeric gradient:", [round(value, 6) for value in numeric])

python dl-softmax-loss-stable-loss-gradient-check.py

target probability: 0.0
finite loss: 2000.0
analytic gradient: [1.0, 0.0, -1.0]
numeric gradient: [1.0, 0.0, -1.0]

按执行顺序理解

1. 取指数前减去最大 logit，不需要计算正指数。

2. 直接计算 log-sum-exp 减去目标 logit，不对已经被舍入的概率取 log。

3. 把 p_j-1[j=target] 与中心差分比较，每次只改变一个坐标。

逐步读懂代码

对有限 logits z 与目标 t，L=(m-z_t)+log(Σ_j exp(z_j-m))，其中 m=max_j z_j。代数上它等于 -log softmax(z)_t，但避免先生成极小的目标概率。本例 m-z_t=2000，剩余对数项约为零。

梯度为 dL/dz_j=p_j-1[j=t]，指标函数只在目标类别处为一。得到 [1,0,-1]：降低最大的错误 logit，或提高目标 logit，都能降低损失。中心差分为 (L(z+epsilon×e_j)-L(z-epsilon×e_j))/(2×epsilon)，e_j 只改变第 j 个坐标。

有限差分是诊断工具，不是反向传播的替代。epsilon 太大会引入近似误差，太小会在相减时损失精度。稳定公式也不能修复 NaN 输入或任意浮点范围限制。框架交叉熵接口通常接受 logits，不要重复应用 softmax。

运行一个完整示例 · 01

打印每层形状

固定层只检查数据排列，不衡量识别质量。

import numpy as np
images = np.arange(8,dtype=float).reshape(2,2,2)
flat = images.reshape(images.shape[0],-1)
w1 = np.ones((4,3)); b1 = np.zeros(3)
w2 = np.ones((3,2)); b2 = np.zeros(2)
hidden = np.maximum(0,flat @ w1+b1)
logits = hidden @ w2+b2
assert flat.shape == (2,4)
for name, array in [('images',images),('flat',flat),('hidden',hidden),('logits',logits)]:
    print(name, array.shape)
print('first flattened image:', flat[0].tolist())
print('parameters:', w1.size+b1.size+w2.size+b2.size)

python dl-shape-tracing-dl-shape-path.py

images (2, 2, 2)
flat (2, 4)
hidden (2, 3)
logits (2, 2)
first flattened image: [0.0, 1.0, 2.0, 3.0]
parameters: 23

逐步读懂代码

arange 提供八个已知值。第一次 reshape 创建两图，第二次保留批维。ones 与 zeros 明确建立权重和偏置形状。矩阵乘法保留批轴。断言检查计划的展平方式，最后统计标量参数。全一权重导致输出列相同是预期行为；这不是训练好的分类器。

运行一个完整示例 · 01

检查梯度并更新网络

使用手工导数与数值检查，不依赖自动微分库。

x, target = 2., 1.
w, b, v = 0.5, 0., 2.
def loss(weight, bias, output_weight):
    prediction = output_weight * max(0., weight*x+bias)
    return 0.5 * (prediction-target)**2
z = w*x+b; a = max(0., z); error = v*a-target
gv = error*a; gw = error*v*int(z>0)*x; gb = error*v*int(z>0)
epsilon = 1e-6
numeric = (loss(w+epsilon,b,v)-loss(w-epsilon,b,v))/(2*epsilon)
print(f'gradient w: {gw:.6f}; finite difference: {numeric:.6f}')
w, b, v = w-0.05*gw, b-0.05*gb, v-0.05*gv
print(f'new loss: {loss(w,b,v):.7f}')

python dl-autograd-dl-chain-rule-check.py

gradient w: 4.000000; finite difference: 4.000000
new loss: 0.0003125

逐步读懂代码

loss 定义精确前向目标。z、a、error 保留链式法则需要的中间值。int(z>0) 给出远离零点时 ReLU 的斜率。中心差分比较 w 两侧的邻近损失。所有更新使用保存的旧梯度。两者一致只检查了这个局部光滑例子，并不验证整个训练流程。

运行一个完整示例 · 01

比较 SGD 与 Adam 的第一步

两种方法都从相同标量参数重新开始。

import numpy as np
targets = np.array([2.,4.]); theta = 0.; rate = 0.1
gradient = np.mean(theta-targets)
sgd = theta-rate*gradient
beta1, beta2 = 0.9, 0.999
m = (1-beta1)*gradient; v = (1-beta2)*gradient**2
m_hat = m/(1-beta1); v_hat = v/(1-beta2)
adam = theta-rate*m_hat/(np.sqrt(v_hat)+1e-8)
for name, value in [('SGD',sgd), ('Adam',adam)]:
    loss = np.mean(0.5*(value-targets)**2)
    print(f'{name}: parameter {value:.6f}; loss {loss:.6f}')

python dl-optimization-dl-sgd-adam-first-step.py

SGD: parameter 0.300000; loss 4.145000
Adam: parameter 0.100000; loss 4.705000

逐步读懂代码

mean 形成一个批梯度。SGD 直接使用它。Adam 从零统计量开始，进行首次更新，再除以首步偏差修正项。sqrt 与小量 epsilon 构成分母。两个损失都采用二分之一平方的约定。这只解释一批数据的更新机制，不能判断哪个优化器普遍更好。

运行一个完整示例 · 01

运行五步透明训练

用实际学习的单参数回归模型讲解循环结构。

import numpy as np
x = np.array([-1.,0.,1.]); y = 2*x
valid_x = np.array([-1.5,1.5]); valid_y = 2*valid_x
weight = 0.; best_loss = float('inf'); best_weight = weight
for epoch in range(1,6):
    error = weight*x-y
    gradient = 2*np.mean(error*x)
    weight -= 0.3*gradient
    train_loss = np.mean((weight*x-y)**2)
    valid_loss = np.mean((weight*valid_x-valid_y)**2)
    if valid_loss < best_loss:
        best_loss, best_weight = valid_loss, weight
    print(f'epoch {epoch}: w={weight:.4f}, train={train_loss:.4f}, valid={valid_loss:.4f}')
print(f'best weight: {best_weight:.5f}')

python dl-training-loop-dl-one-weight-training-loop.py

epoch 1: w=0.8000, train=0.9600, valid=3.2400
epoch 2: w=1.2800, train=0.3456, valid=1.1664
epoch 3: w=1.5680, train=0.1244, valid=0.4199
epoch 4: w=1.7408, train=0.0448, valid=0.1512
epoch 5: w=1.8445, train=0.0161, valid=0.0544
best weight: 1.84448

逐步读懂代码

前两行建立不同的训练与验证输入。error 和 gradient 只用训练数组，减法更新标量权重。两种损失都在更新后重算，确保比较一致。if 保存最佳验证状态，标量赋值会复制数值。这里五轮就是五次整批更新。代码确实学习合成直线，但未评估真实神经网络应用。

运行一个完整示例 · 02

微批次大小不同时正确累积梯度

米娜的设备一次装不下四个样本，于是拆成三条和一条两个微批次。直接平均两批梯度，会让最后那一个样本占一半权重。她改为按样本数加权各批平均梯度，在累积期间固定参数，最后只做一次优化器更新。

from math import isclose
x = [1.0, 2.0, 3.0, 4.0]
y = [2.0 * value for value in x]
weight = 0.0

def mean_gradient(indices, weight):
    return sum(2 * (weight * x[i] - y[i]) * x[i] for i in indices) / len(indices)

batches = [[0, 1, 2], [3]]
batch_gradients = [mean_gradient(batch, weight) for batch in batches]
wrong = sum(batch_gradients) / len(batches)
accumulated = sum(len(batch) * gradient for batch, gradient in zip(batches, batch_gradients)) / len(x)
full = mean_gradient(list(range(len(x))), weight)
updated = weight - 0.01 * accumulated
assert isclose(full, -30.0) and isclose(accumulated, full)
assert not isclose(wrong, full) and isclose(updated, 0.3)
print("batch gradients:", [round(g, 6) for g in batch_gradients])
print(f"unweighted mean: {wrong:.6f}")
print(f"sample-weighted gradient: {accumulated:.6f}")
print(f"one optimizer step: {updated:.6f}")

python dl-training-loop-unequal-batch-accumulation.py

batch gradients: [-18.666667, -64.0]
unweighted mean: -41.333333
sample-weighted gradient: -30.000000
one optimizer step: 0.300000

按执行顺序理解

1. 两个微批次使用相同 weight；若第一批后就更新，第二批梯度会在另一个参数点计算。

2. 第一批三条、第二批一条，两个平均值不能同权。

3. 每批平均梯度乘以该批样本数，累加后除以总数，最后更新一次。

逐步读懂代码

N 个样本的损失 L=(1/N)Σ_i l_i。若微批次 b 有 n_b 条样本，平均梯度为 g_b，则整体平均梯度为 g=Σ_b(n_b/N)g_b。这里平方误差 l_i=(w×x_i-y_i)^2 的导数是 2(w×x_i-y_i)x_i。

w=0 时，逐样本梯度是 -4、-16、-36、-64。第一批均值为 -56/3，第二批为 -64。把两批同权平均会得到 -124/3，约 -41.3333；正确均值是 (-4-16-36-64)/4=-30。学习率 0.01 时，w 更新为 0.3。

自动微分循环中，在累积前清空一次梯度，每批平均损失乘 n_b/N，逐批反向传播，最后更新一次。严格等价要求损失能逐样本相加，且参数固定。BatchNorm 等依赖批次的操作、随机层、每微批次单独裁剪以及浮点求和，都可能改变结果。因此梯度累积并不自动等同于所有大批次训练配置。

运行一个完整示例 · 01

精确计算 dropout 结果

枚举标量结果，并用固定向量掩码保证输出可重复。

import numpy as np
probability = 0.25; h = 4.
outcomes = np.array([0., h/(1-probability)])
weights = np.array([probability, 1-probability])
expected = weights @ outcomes
variance = weights @ (outcomes-expected)**2
vector = np.array([2.,4.]); mask = np.array([1.,0.])
print(f'expectation: {expected:.6f}; variance: {variance:.6f}')
print('training:', np.round(mask*vector/(1-probability),6).tolist())
print('evaluation:', vector.tolist())

python dl-regularization-dl-dropout-expectation.py

expectation: 4.000000; variance: 5.333333
training: [2.666667, 0.0]
evaluation: [2.0, 4.0]

逐步读懂代码

outcomes 列出被丢弃和保留的标量值，weights 保存其概率。两次点积精确计算期望与方差，无需抽样。固定掩码展示一种可能的向量传播，评估则返回原向量。代码演示 dropout 机制，没有训练或验证声音模型。

运行一个完整示例 · 01

逐行归一化特征

使用总体方差约定与明确的 epsilon。

import numpy as np
x = np.array([[1.,3.], [10.,14.]])
mean = x.mean(axis=1,keepdims=True)
variance = ((x-mean)**2).mean(axis=1,keepdims=True)
normalized = (x-mean)/np.sqrt(variance+1e-5)
print('means:', mean.ravel().tolist())
print('variances:', variance.ravel().tolist())
print('normalized:', np.round(normalized,6).tolist())
print('row means:', np.round(normalized.mean(axis=1),6).tolist())

python dl-normalization-dl-row-layernorm.py

means: [2.0, 12.0]
variances: [1.0, 4.0]
normalized: [[-0.999995, 0.999995], [-0.999999, 0.999999]]
row means: [0.0, 0.0]

逐步读懂代码

axis=1 选择行内特征，keepdims 保持统计量对齐以便广播。中心化差值平方后沿相同轴平均得到总体方差。分母先将方差加 epsilon，再开平方。ravel 仅为把统计量显示为一维。运算省略可训练尺度与偏移，等价于分别取一和零。

运行一个完整示例 · 01

滑动滤波器并添加捷径

两个独立计算演示两种不同机制。

import numpy as np
x = np.array([[1.,0.,2.], [2.,1.,0.], [0.,3.,1.]])
kernel = np.array([[1.,0.], [0.,-1.]])
out = np.zeros((2,2))
for row in range(2):
    for col in range(2):
        out[row,col] = np.sum(x[row:row+2,col:col+2] * kernel)
residual_sum = np.array([2.,-1.]) + np.array([0.5,0.25])
print('filter output:', out.tolist())
print('residual sum:', residual_sum.tolist())
print('after ReLU:', np.maximum(0,residual_sum).tolist())

python dl-convolution-dl-filter-residual.py

filter output: [[0.0, 0.0], [-1.0, 0.0]]
residual sum: [2.5, -0.75]
after ReLU: [2.5, 0.0]

逐步读懂代码

嵌套循环选择各个有效窗口。切片取出 2×2 条目，逐元素相乘再求和，实现不翻核的互相关。残差计算按对应坐标相加，maximum 随后应用 ReLU。这个手选滤波器不是训练好的划痕检测器，残差向量也是独立示例。

运行一个完整示例 · 01

查找词元并忽略填充

表的最后一行表示填充；向量为示意值，未经学习。

import numpy as np
table = np.array([[1.,0.], [0.,2.], [0.,0.]])
ids = np.array([0,1,2]); padding_id = 2
vectors = table[ids]
mask = ids != padding_id
pooled = (vectors*mask[:,None]).sum(axis=0)/mask.sum()
reversed_ids = np.array([1,0,2])
reversed_mean = table[reversed_ids][reversed_ids != padding_id].mean(axis=0)
print('vectors:', vectors.tolist())
print('real-token count:', int(mask.sum()))
print('masked mean:', pooled.tolist())
print('reversed mean:', reversed_mean.tolist())

python dl-token-embeddings-dl-embedding-mask-mean.py

vectors: [[1.0, 0.0], [0.0, 2.0], [0.0, 0.0]]
real-token count: 2
masked mean: [0.5, 1.0]
reversed mean: [0.5, 1.0]

逐步读懂代码

table[ids] 为每个位置选一行。比较生成布尔掩码。[:,None] 添加特征广播轴，让每个位置的掩码作用于整个向量。沿轴零求和组合位置，mask.sum 统计真实词元。逆序得到相同均值，展示顺序丢失。代码只执行查表与池化。

运行一个完整示例 · 01

比较允许与遮蔽的上下文

这是学习输出投影之前的单头数值示例。

import numpy as np
q = np.array([[np.sqrt(2.),0.]])
k = np.array([[1.,0.], [0.,1.]])
v = np.array([[2.,0.], [0.,4.]])
scores = q @ k.T / np.sqrt(k.shape[1])
def softmax(row):
    values = np.exp(row-row.max(axis=-1,keepdims=True))
    return values/values.sum(axis=-1,keepdims=True)
weights = softmax(scores)
masked = softmax(scores + np.array([[0.,-np.inf]]))
print('weights:', np.round(weights,6).tolist())
print('output:', np.round(weights @ v,6).tolist())
print('masked output:', (masked @ v).tolist())

python dl-attention-dl-attention-mask.py

weights: [[0.731059, 0.268941]]
output: [[1.462117, 1.075766]]
masked output: [[2.0, 0.0]]

逐步读懂代码

@ 生成配对分数，.T 将键向量排成列。缩放使用键维度而非序列长度。softmax 减去行最大值以保持稳定。负无穷让被禁止键的指数为零，最后矩阵乘法混合值。向量是手选的，示例未实现分词、语言训练或完整 Transformer。

运行一个完整示例 · 01

运行完整玩具前置归一化模块

恒等注意力投影与重复行让结果容易检查。

import numpy as np
def layer_norm(values):
    centered = values-values.mean(axis=-1,keepdims=True)
    return centered/np.sqrt((centered**2).mean(axis=-1,keepdims=True)+1e-8)
x = np.array([[1.,-1.], [1.,-1.]])
u = layer_norm(x)
scores = u @ u.T / np.sqrt(u.shape[1])
allowed = np.tril(np.ones((len(x),len(x)),dtype=bool))
scores = np.where(allowed,scores,-np.inf)
weights = np.exp(scores-scores.max(axis=1,keepdims=True))
weights /= weights.sum(axis=1,keepdims=True)
y = x + weights @ u
w1 = np.eye(2); w2 = 0.5*np.eye(2)
z = y + np.maximum(0,layer_norm(y) @ w1) @ w2
print('attention:', np.round(weights,6).tolist())
print('first residual:', np.round(y,6).tolist())
print('block output:', np.round(z,6).tolist())

python dl-transformer-block-dl-tiny-transformer-block.py

attention: [[1.0, 0.0], [0.5, 0.5]]
first residual: [[2.0, -2.0], [2.0, -2.0]]
block output: [[2.5, -2.0], [2.5, -2.0]]

逐步读懂代码

layer_norm 中心化每个词元的特征行。tril 建立下三角因果许可掩码，where 把禁止分数设为负无穷。稳定逐行 softmax 给出混合权重。y 将注意力加回原残差流。最后表达式归一化后，应用零偏置的双层 ReLU 网络，再加回修正。所有权重固定用于教学，没有语言训练或预训练权重。 np.eye(2) 创建这个 2 × 2 单位矩阵。把它乘以 0.5 后，对角线元素变为 0.5，其余元素仍为零。

运行一个完整示例 · 01

在固定特征上训练预测头

用预设向量代替编码器输出，不加载预训练模型。

import numpy as np
z = np.array([2.,-1.]); w = np.array([0.1,0.2]); b = 0.; y = 1.
def probability(weights, bias):
    return 1/(1+np.exp(-(weights @ z+bias)))
p = probability(w,b)
gw = (p-y)*z; gb = p-y
w, b = w-0.1*gw, b-0.1*gb
new_p = probability(w,b)
print('new weights:', np.round(w,3).tolist())
print(f'new bias: {b:.3f}; new probability: {new_p:.6f}')
print(f'loss before: {-np.log(p):.6f}; after: {-np.log(new_p):.6f}')
print('fixed features:', z.tolist())

python dl-transfer-dl-frozen-feature-head.py

new weights: [0.2, 0.15]
new bias: 0.050; new probability: 0.574443
loss before: 0.693147; after: 0.554355
fixed features: [2.0, -1.0]

逐步读懂代码

probability 计算预测头点积与 sigmoid。二元交叉熵对原始分数的导数为 p−y，乘 z 得到权重梯度。更新只改变 w 与 b。由于 y=1，损失为 −log(p)。示例训练微型预测头一步，不能证明真实预训练特征迁移有效。

运行一个完整示例 · 01

比较独立与合并适配器路径

所有矩阵都为算例预设，既未预训练，也未拟合。

import numpy as np
base = np.eye(3,4)
a = np.array([[1.,0.,-1.,0.]])
b = np.array([[0.1],[0.2],[0.3]])
x = np.array([1.,2.,3.,4.]); scale = 1.
separate = base @ x + scale*b @ (a @ x)
merged = (base+scale*b @ a) @ x
print('full entries:', base.size, 'adapter entries:', a.size+b.size)
print('output:', np.round(separate,6).tolist())
print('merged agrees:', bool(np.allclose(separate,merged)))

python dl-efficient-adaptation-dl-low-rank-merge.py

full entries: 12 adapter entries: 7
output: [0.8, 1.6, 2.4]
merged agrees: True

逐步读懂代码

eye(3,4) 创建矩形恒等式基础映射。a 把四个输入压成一个修正坐标，b 再扩为三个输出。独立表达式保留两条路径，合并表达式先加矩阵修正。size 统计项数，allclose 检查数值一致。这个微型计算不支持速度结论，也没有训练模型适应。