机器学习

运行一个完整示例 · 01

构建多数标签基线

用训练标签选规则，再用独立测试标签评分。

from collections import Counter
train_y = [0, 0, 0, 1]
test_y = [0, 1, 1, 0]
counts = Counter(train_y)
baseline = min(counts, key=lambda label: (-counts[label], label))
predictions = [baseline] * len(test_y)
correct = sum(pred == true for pred, true in zip(predictions, test_y))
print('baseline class:', baseline)
print('predictions:', predictions)
print(f'test accuracy: {correct / len(test_y):.2f}')

python features-labels-baselines-ml-majority-baseline.py

baseline class: 0
predictions: [0, 0, 0, 0]
test accuracy: 0.50

逐步读懂代码

Counter 统计训练标签。min 按负计数排序，因此最大计数排前；类别编号用于处理平局。列表重复为每个测试行生成预测。zip 配对预测和标签，sum 把为真的比较按一计数。输出只是基线，不能证明词数或链接有用。

运行一个完整示例 · 01

把完整设备放在一起

不用随机库调用，构建这个 120 行的划分。

groups = [device for device in range(12) for _ in range(10)]
train = [i for i, device in enumerate(groups) if device < 8]
valid = [i for i, device in enumerate(groups) if 8 <= device < 10]
test = [i for i, device in enumerate(groups) if device >= 10]
train_devices = {groups[i] for i in train}
test_devices = {groups[i] for i in test}
print('rows:', len(train), len(valid), len(test))
print('shared devices:', sorted(train_devices & test_devices))
print('test error:', 2 / len(test))

python framing-splits-leakage-ml-group-split.py

rows: 80 20 20
shared devices: []
test error: 0.1

逐步读懂代码

第一行把每个设备编号重复十次。enumerate 提供行号。三个条件分配完整分组。集合去掉重复编号，& 查找共有编号。空列表表示训练和测试没有共享设备。最后一行假定出现两次错误；它没有训练或评估真实传感器模型。

运行一个完整示例 · 02

用刻意简单的记忆器暴露泄漏

米娜为四台设备各记录两次读数。她每台拿一条训练、另一条测试，只记住设备编号的模型就得到满分。改用完全没见过的设备测试，分数降到一半。模型并不是突然变差了：第一次划分检验的是熟悉设备，第二次问的才是新设备。

rows = [(device, label) for device, label in
        [("A", 0), ("B", 1), ("C", 0), ("D", 1)] for _ in range(2)]

def evaluate(train, test):
    memory = {device: label for device, label in train}
    fallback = int(sum(label for _, label in train) > len(train) / 2)
    predictions = [memory.get(device, fallback) for device, _ in test]
    accuracy = sum(p == label for p, (_, label) in zip(predictions, test)) / len(test)
    overlap = {d for d, _ in train} & {d for d, _ in test}
    return accuracy, sorted(overlap)

row_train, row_test = rows[::2], rows[1::2]
group_train = [row for row in rows if row[0] in {"A", "B"}]
group_test = [row for row in rows if row[0] in {"C", "D"}]
row_score, overlap = evaluate(row_train, row_test)
group_score, clean_overlap = evaluate(group_train, group_test)
assert row_score == 1.0 and group_score == 0.5 and not clean_overlap
print(f"row split: accuracy={row_score:.2f}; shared devices={overlap}")
print(f"group split: accuracy={group_score:.2f}; shared devices={clean_overlap}")

python framing-splits-leakage-memorizer-leakage-audit.py

row split: accuracy=1.00; shared devices=['A', 'B', 'C', 'D']
group split: accuracy=0.50; shared devices=[]

按执行顺序理解

1. 构造同设备标签固定的重复测量，用人工数据把捷径暴露出来。

2. 只在训练行拟合记忆表和多数类后备规则；平票时选零。

3. 比较按行划分与设备互斥划分，同时报告共享编号和准确率。

逐步读懂代码

准确率=测试预测正确数/测试行数。按行测试时四条全对；按设备测试时四条中两条正确，因为未见设备都得到只由训练集确定的后备标签零，而只有 C 的标签是零。

分离单位取决于部署目标。要面对新患者、新设备或新视频，就应把整个组留出；若预测已知设备的未来事件，则应采用合适的时间划分。只做组间隔离还不能阻止预处理中的未来信息泄漏。每一折的缺失值填补、缩放和特征选择都只能用训练部分拟合。

这只是诊断玩具，不是某个真实模型准确率为 50% 的证据。刻意简单的基线有时比复杂模型更容易暴露捷径。scikit-learn 官方交叉验证指南提供按组划分工具，但分组变量要从真正想回答的问题出发选择。

运行一个完整示例 · 01

拟合中位数，再重复使用

本例用 NaN 表示未知数值。

import numpy as np
train = np.array([2., np.nan, 6., 4.])
test = np.array([np.nan, 10.])
missing = np.isnan(train)
median = np.median(train[~missing])
filled_train = np.where(missing, median, train)
filled_test = np.where(np.isnan(test), median, test)
print(f'training missing fraction: {missing.mean():.2f}')
print('training flag:', missing.astype(int).tolist())
print('filled training:', filled_train.tolist())
print('filled test:', filled_test.tolist())

python missing-data-eda-ml-median-imputation.py

training missing fraction: 0.25
training flag: [0, 1, 0, 0]
filled training: [2.0, 4.0, 6.0, 4.0]
filled test: [4.0, 10.0]

逐步读懂代码

isnan 标出缺失项。~ 反转布尔掩码，使索引选出已观测训练值。median 取中位数。where 只在缺失位置选择替代值。astype(int) 把标记显示成零和一。测试使用相同的中位数。代码准备数值数据，并不能说明填补改善了预测。

运行一个完整示例 · 01

编码已知与未见类别

明确使用最后一列记录未知类别。

vocabulary = ['paper', 'wood']
def encode(value):
    return [int(value == name) for name in vocabulary] + [int(value not in vocabulary)]
print('columns:', vocabulary + ['unknown'])
for value in ['wood', 'paper', 'metal']:
    row = encode(value)
    print(value, row, 'sum:', sum(row))

python categorical-preprocessing-ml-category-columns.py

columns: ['paper', 'wood', 'unknown']
wood [0, 1, 0] sum: 1
paper [1, 0, 0] sum: 1
metal [0, 0, 1] sum: 1

逐步读懂代码

列表推导把取值与每个已保存名称比较。int 将比较结果转为零或一。最后一项检查它是否不在整个词表中。打印行和可确认恰有一个指示被激活。编码器只准备特征，既未训练分类器，也未学会怎样正确处理金属。

运行一个完整示例 · 01

比较直线与常数

用相同三行演示计算。

import numpy as np
x = np.array([1., 2., 3.])
y = np.array([3., 5., 8.])
prediction = 1 + 2 * x
residual = prediction - y
mse = np.mean(residual ** 2)
baseline_mse = np.mean((y.mean() - y) ** 2)
print('prediction:', prediction.tolist())
print(f'MSE: {mse:.6f}; RMSE: {np.sqrt(mse):.6f}')
print(f'constant MSE: {baseline_mse:.6f}')

python linear-regression-mse-ml-line-loss.py

prediction: [3.0, 5.0, 7.0]
MSE: 0.333333; RMSE: 0.577350
constant MSE: 4.222222

逐步读懂代码

np.array 保存有序数值。乘法和减法按对应位置计算。**2 平方每个残差，mean 求和再除以三，sqrt 恢复原单位。y.mean 给出常数基线。这些行仅用于比较计算。所选直线既不是声称求出的最小二乘最优解，也不是独立测试结果。

运行一个完整示例 · 01

标准化后更新一步

下面所有梯度都使用更新前的参数。

import numpy as np
x = np.array([2., 6.]); y = np.array([1., 3.])
z = (x - x.mean()) / x.std()
w, b, rate = 0., 0., 0.1
error = w * z + b - y
gw = 2 * np.mean(error * z)
gb = 2 * np.mean(error)
w, b = w - rate * gw, b - rate * gb
print('scaled inputs:', z.tolist())
print(f'gradients: {gw:.1f}, {gb:.1f}')
print(f'weights: {w:.1f}, {b:.1f}')
print(f'loss: {np.mean((w * z + b - y) ** 2):.3f}')

python gradient-descent-scaling-ml-gradient-step.py

scaled inputs: [-1.0, 1.0]
gradients: -2.0, -4.0
weights: 0.2, 0.4
loss: 3.200

逐步读懂代码

mean 和 std 计算训练统计量；这里 NumPy 的 std 使用总体约定。error 保存旧残差。乘以 z 得到权重导数中的输入贡献。均值乘二来自平方的求导。元组赋值让两个参数都使用旧梯度更新。最后重新计算损失。这只是微型线性模型的一次精确更新，并非完整训练流程。

运行一个完整示例 · 01

同一个概率，两种决策

使用示意性的固定权重，不是真实训练的夜空分类器。

from math import exp
x, w, b = 2., 0.8, -1.2
score = b + w * x
probability = 1 / (1 + exp(-score))
print(f'score: {score:.4f}; probability: {probability:.4f}')
for threshold in [0.50, 0.65]:
    label = int(probability >= threshold)
    print(f'threshold {threshold:.2f}: class {label}')

python logistic-thresholds-ml-sigmoid-cutoffs.py

score: 0.4000; probability: 0.5987
threshold 0.50: class 1
threshold 0.65: class 0

逐步读懂代码

第一项计算生成线性分数。exp 实现 sigmoid 中的指数。循环重复使用同一个概率。>= 与各阈值比较，int 将真假变成一或零。输出类别改变，但分数不变。没有使用数据拟合这些权重，也没有数据证明哪种阈值更合适。

运行一个完整示例 · 02

用明确错误代价选择决策阈值

学校机器把损坏的练习零件送去检查。漏掉坏件的代价记为四个工作单位，误查好件记为一个。米娜先用常见的 0.5 阈值，再在小验证集上列出两种错误。降低阈值能补获一个坏件，只多一次误查。她在查看最终测试集之前固定阈值。

scores = [0.10, 0.35, 0.45, 0.60, 0.80]
truth = [0, 1, 0, 1, 1]

def cost_at(threshold):
    predicted = [int(score >= threshold) for score in scores]
    fp = sum(p == 1 and y == 0 for p, y in zip(predicted, truth))
    fn = sum(p == 0 and y == 1 for p, y in zip(predicted, truth))
    return fp + 4 * fn, fp, fn

candidates = [0.30, 0.50, 0.70, 1.10]
for threshold in candidates:
    cost, fp, fn = cost_at(threshold)
    print(f"threshold={threshold:.2f} FP={fp} FN={fn} cost={cost}")
best = min(candidates, key=lambda t: (cost_at(t)[0], t))
assert best == 0.30 and cost_at(best) == (1, 1, 0)
print(f"selected on validation: {best:.2f}")

python logistic-thresholds-validation-cost-threshold.py

threshold=0.30 FP=1 FN=0 cost=1
threshold=0.50 FP=0 FN=1 cost=4
threshold=0.70 FP=0 FN=2 cost=8
threshold=1.10 FP=0 FN=3 cost=12
selected on validation: 0.30

按执行顺序理解

1. 比较阈值前先规定代价；本例优化 FP+4×FN，而不是准确率。

2. 每个候选阈值都用 score>=threshold 产生预测，再统计两种错误。

3. 最小化验证代价并说明平局规则；最终测试集不参与选择。

逐步读懂代码

阈值 0.30 时预测为 [0,1,1,1,1]，一个假正例、零个假负例，总代价为 1。阈值 0.50 时没有假正例，却有一个假负例，代价为 4。全预测负类的候选 1.10 代价为 12。若比较不同规模验证集，可除以五，报告每个样本的平均代价。

若 p 是校准后的概率，假正例代价为 C_FP、假负例代价为 C_FN，正确决策代价为零，则 C_FP×(1-p)≤C_FN×p 时预测正类。整理得 p≥C_FP/(C_FP+C_FN)，本例为 0.2。这是总体期望代价规则，与用五个已观测标签从有限网格选阈值不是同一件事。模型分数也未必是校准概率。

部署后，代价、类别比例和校准情况都可能变化。调阈值不能修复很差的排序或无效的数据划分。这只是小例子，实际结论需要足够有代表性的验证数据及不确定性检查。

运行一个完整示例 · 01

从计数计算四个指标

这些计数描述自拟评估集上一个阈值的结果。

tp, tn, fp, fn = 8, 78, 12, 2
total = tp + tn + fp + fn
accuracy = (tp + tn) / total
precision = tp / (tp + fp)
recall = tp / (tp + fn)
f1 = 2 * tp / (2 * tp + fp + fn)
for name, value in [('accuracy', accuracy), ('precision', precision),
                    ('recall', recall), ('F1', f1)]:
    print(f'{name}: {value:.3f}')
print('clips to review:', tp + fp)

python metrics-imbalance-ml-confusion-counts.py

accuracy: 0.860
precision: 0.400
recall: 0.800
F1: 0.533
clips to review: 20

逐步读懂代码

四个计数恰好覆盖一百段片段。每个除法对应不同问题。F1 直接用计数计算；在精确率和召回率有定义时，它等于两者的调和平均。循环把比例保留三位小数。本例假设分母非零。代码只计算指标，并未训练音频检测器。

运行一个完整示例 · 01

检查每一张近邻投票

表格为合成数据，两个特征已经采用可比尺度。

import numpy as np
x = np.array([[0.,0.], [1.,0.], [2.,0.], [4.,0.]])
y = np.array([0,0,1,1])
query = np.array([1.6,0.])
squared = np.sum((x - query) ** 2, axis=1)
order = np.argsort(squared, kind='stable')
print('squared distances:', np.round(squared, 2).tolist())
for k in [1,3]:
    labels = y[order[:k]]
    print('k:', k, 'labels:', labels.tolist(), 'prediction:', int(labels.mean() > 0.5))

python nearest-neighbours-ml-knn-vote.py

squared distances: [2.56, 0.36, 0.16, 5.76]
k: 1 labels: [1] prediction: 1
k: 3 labels: [1, 0, 0] prediction: 0

逐步读懂代码

减去 query 时，每行都使用同一查询。sum(axis=1) 在每行内加总特征贡献。argsort 按距离从小到大返回行索引，稳定排序让等距离按原行顺序处理。[:k] 选取邻居，标签均值就是一的比例。这是实际可运行的微型近邻分类器，但没有真实音频准确率的证据。

运行一个完整示例 · 01

计算双词分类器

用预设训练词频总计展示各个概率。

import numpy as np
counts = np.array([[3.,1.], [1.,3.]])
word_prob = (counts + 1) / (counts.sum(axis=1, keepdims=True) + 2)
query = np.array([1.,0.])
log_scores = np.log([0.5,0.5]) + np.log(word_prob) @ query
weights = np.exp(log_scores - log_scores.max())
probabilities = weights / weights.sum()
print('word probabilities:', np.round(word_prob, 3).tolist())
print('class probabilities:', np.round(probabilities, 3).tolist())
print('class:', ['spam','ordinary'][int(np.argmax(probabilities))])

python text-naive-bayes-ml-naive-bayes-counts.py

word probabilities: [[0.667, 0.333], [0.333, 0.667]]
class probabilities: [0.667, 0.333]
class: spam

逐步读懂代码

行代表类别、列代表词。sum 配合 keepdims 为每行保留列形状的分母。加一实现平滑。@ 把按查询计数加权的对数概率相加。减去最大对数分数能保持指数计算稳定，而不改变归一化结果。argmax 选择较高分数。分类器只依赖这些计数，不是训练好的语言模型。

运行一个完整示例 · 01

计算分裂分数与树的平均

计算局部分裂准则，不构建整棵树。

def gini(positive, total):
    p = positive / total
    return 2 * p * (1 - p)
parent = gini(6, 10)
children = 0.5 * gini(4, 5) + 0.5 * gini(2, 5)
probabilities = [0.2, 0.7, 0.9]
print(f'parent: {parent:.2f}; children: {children:.2f}')
print(f'gain: {parent - children:.2f}')
print(f'forest probability: {sum(probabilities) / len(probabilities):.2f}')

python trees-ensembles-ml-gini-forest.py

parent: 0.48; children: 0.40
gain: 0.08
forest probability: 0.60

逐步读懂代码

函数先把计数转成正类比例，再计算二分类基尼不纯度。子节点一样大，因此权重均为 0.5。相减衡量局部增益。sum 除以 len 得到树概率的平均。数值只展示一个候选分裂与一种集成规则，没有进行树搜索或森林训练。

运行一个完整示例 · 01

拟合一个残差树桩

固定以 x<2 分裂，便于检查两个叶子均值。

import numpy as np
x = np.array([0.,1.,2.,3.]); y = np.array([1.,1.,3.,3.])
prediction = np.full_like(y, y.mean())
residual = y - prediction
left = x < 2
correction = np.where(left, residual[left].mean(), residual[~left].mean())
updated = prediction + 0.5 * correction
print('residual:', residual.tolist())
print('updated:', updated.tolist())
print(f'MSE before: {np.mean((prediction-y)**2):.2f}')
print(f'MSE after: {np.mean((updated-y)**2):.2f}')

python boosting-residuals-ml-residual-stump.py

residual: [-1.0, -1.0, 1.0, 1.0]
updated: [1.5, 1.5, 2.5, 2.5]
MSE before: 1.00
MSE after: 0.25

逐步读懂代码

full_like 为每个目标生成常数初始预测。布尔 left 掩码定义两个叶子。各叶子取残差均值，它能最小化叶内残差平方误差。where 为每行分配对应修正。加上一半修正即完成一次提升。代码不含分裂搜索、多轮训练或独立验证。

运行一个完整示例 · 01

计算分组与 PCA 方差

矩形数据让两种计算都容易看清。

import numpy as np
x = np.array([[0., 0.], [0., 2.], [4., 0.], [4., 2.]])
centers = np.array([[0., 1.], [4., 1.]])
assignment = np.array([0, 0, 1, 1])
loss = np.sum((x - centers[assignment]) ** 2)
centered = x - x.mean(axis=0)
covariance = centered.T @ centered / len(x)
values = np.linalg.eigvalsh(covariance)
print(f'cluster loss: {loss:.1f}')
print('covariance:', covariance.tolist())
print(f'first variance share: {values[-1] / values.sum():.2f}')

python clustering-pca-ml-cluster-pca-geometry.py

cluster loss: 4.0
covariance: [[4.0, 0.0], [0.0, 1.0]]
first variance share: 0.80

逐步读懂代码

centers[assignment] 为每行选一个中心。平方再求和得到分组损失。mean(axis=0) 计算每列均值。.T 交换轴，@ 矩阵乘法构建总体协方差。eigvalsh 按升序返回特征值，因此最后一个最大。代码衡量已选分组和方差，没有发现岩石类别，也没有运行迭代 K-means 拟合。

运行一个完整示例 · 01

给三个标签视频排序

标签为手工设定；示例不学习嵌入。

import numpy as np
names = ['astronomy', 'robotics', 'mixed']
items = np.array([[1.,0.], [0.,1.], [1.,1.]])
profile = np.array([1.,1.])
scores = (items @ profile) / (np.linalg.norm(items, axis=1) * np.linalg.norm(profile))
order = np.argsort(-scores, kind='stable')
for index in order:
    print(f'{names[index]}: {scores[index]:.3f}')

python content-recommendations-ml-cosine-recommendations.py

mixed: 1.000
astronomy: 0.707
robotics: 0.707

逐步读懂代码

@ 为每个物品计算点积。norm 计算向量长度，axis=1 分别保留物品长度。除法去掉长度影响。对负分排序使高分在前，平局按输入顺序处理。在这些标签下混合视频排第一。这是可检查的评分规则，不是经验证的观众偏好模型。

运行一个完整示例 · 01

区分拟合目标与验证

用候选摘要演示两种不同的比较。

candidates = {'A': (1.0, 9), 'B': (1.4, 1)}
strength = 0.1
for name, (mse, squared_weights) in candidates.items():
    print(f'{name} objective: {mse + strength * squared_weights:.1f}')
folds = {0.0: [1.0, 1.4, 1.2], 0.1: [0.9, 1.0, 1.1]}
means = {value: sum(errors) / len(errors) for value, errors in folds.items()}
for value, score in means.items():
    print(f'lambda {value:.1f}: validation MSE {score:.1f}')
print('chosen lambda:', min(means, key=means.get))

python validation-regularization-shift-ml-regularization-validation.py

A objective: 1.9
B objective: 1.5
lambda 0.0: validation MSE 1.2
lambda 0.1: validation MSE 1.0
chosen lambda: 0.1

逐步读懂代码

每个候选保存训练 MSE 与权重平方和。第一个循环加上惩罚。folds 字典存放另一组示意性的验证摘要。接着对等大小折取平均。min 的 key=means.get 选择验证误差最小的强度，不按惩罚后的训练损失选择。这些是预设摘要，不是实际拟合模型的结果。

运行一个完整示例 · 01

检查一个概率分箱

四个例子都属于概率约为 0.8 的同一分箱。

import numpy as np
probability = np.array([0.8,0.8,0.8,0.8])
label = np.array([1.,1.,0.,0.])
brier = np.mean((probability - label) ** 2)
print('bin count:', len(label))
print(f'mean probability: {probability.mean():.2f}')
print(f'observed positive fraction: {label.mean():.2f}')
print(f'Brier score: {brier:.2f}')

python calibration-monitoring-ml-calibration-bin.py

bin count: 4
mean probability: 0.80
observed positive fraction: 0.50
Brier score: 0.34

逐步读懂代码

数组把每个概率与真实标签配对。相减、平方、取平均实现布里尔分数。标签为零或一，因此均值就是正类比例。打印数量提醒我们四个案例的证据有限。脚本诊断预设预测，没有拟合校准器，也没有监控真实系统。