神经网络
基础

def neuron(features, weights, bias):
    if len(features) != len(weights):
        raise ValueError("特征与权重长度不一致")
    linear = sum(value * weight for value, weight in zip(features, weights)) + bias
    return linear

features = [42.0, 0.75, 3.0]
weights = [0.08, 1.2, -0.15]
bias = 0.5
score = neuron(features, weights, bias)
print("pre-activation:", round(score, 3))
assert isinstance(score, float)

import math

def relu(value):
    return max(0.0, value)

def sigmoid(value):
    if value >= 0:
        return 1.0 / (1.0 + math.exp(-value))
    exp_value = math.exp(value)
    return exp_value / (1.0 + exp_value)

def tanh(value):
    return math.tanh(value)

for value in (-8.0, -1.0, 0.0, 1.0, 8.0):
    print(value, relu(value), round(sigmoid(value), 4), round(tanh(value), 4))

import torch
from torch import nn

class MLP(nn.Module):
    def __init__(self, in_features=4, hidden=16, classes=3):
        super().__init__()
        self.network = nn.Sequential(
            nn.Linear(in_features, hidden),
            nn.ReLU(),
            nn.Linear(hidden, hidden),
            nn.ReLU(),
            nn.Linear(hidden, classes),
        )

    def forward(self, features):
        if features.ndim != 2 or features.shape[1] != 4:
            raise ValueError("期望形状为 (batch, 4)")
        return self.network(features)

model = MLP()
batch = torch.randn(5, 4)
logits = model(batch)
print(logits.shape)
assert logits.shape == (5, 3)

def count_parameters(model):
    return sum(parameter.numel() for parameter in model.parameters() if parameter.requires_grad)

def summarize(model):
    rows = []
    for name, parameter in model.named_parameters():
        rows.append({"name": name, "shape": tuple(parameter.shape), "trainable": parameter.requires_grad})
    return rows

# 假设 model 是上一段创建的 MLP
print("trainable parameters:", count_parameters(model))
for row in summarize(model):
    print(row)

def score(features, weights, bias):
    if len(features) != len(weights):
        raise ValueError("长度必须一致")
    return sum(x * w for x, w in zip(features, weights)) + bias

def local_sensitivity(features, weights, bias, index, delta=1e-3):
    changed = list(features)
    changed[index] += delta
    before = score(features, weights, bias)
    after = score(changed, weights, bias)
    return (after - before) / delta

x = [2.0, 0.5, 4.0]
w = [0.2, -1.5, 0.1]
b = 0.3
for index in range(len(x)):
    estimate = local_sensitivity(x, w, b, index)
    print(index, round(estimate, 4), "expected", w[index])
    assert abs(estimate - w[index]) < 1e-9

import torch

features = torch.tensor([[42.0, 0.75, 3.0, 1.0], [18.0, 0.40, 1.0, 0.0]], dtype=torch.float32)
labels = torch.tensor([2, 0], dtype=torch.long)

print("features:", features.shape, features.dtype, features.device)
print("labels:", labels.shape, labels.dtype)
assert features.ndim == 2 and features.shape == (2, 4)
assert labels.dtype == torch.long and labels.shape == (2,)

# reshape 保持元素数量，permute 只交换轴的解释
sequence = torch.arange(24, dtype=torch.float32).reshape(2, 3, 4)
swapped = sequence.permute(0, 2, 1)
assert sequence.numel() == swapped.numel()
print(sequence.shape, swapped.shape)

import torch

x = torch.tensor([[1.0, 2.0, 3.0], [10.0, 20.0, 30.0]])
feature_bias = torch.tensor([0.1, 0.2, 0.3])
sample_bias = torch.tensor([[1.0], [2.0]])

by_feature = x + feature_bias
by_sample = x + sample_bias
print(by_feature, by_sample)
assert by_feature.shape == x.shape
assert by_sample.shape == x.shape

weight = torch.ones(3, 2)
output = x @ weight
assert output.shape == (2, 2)
print("matrix output:", output)

import torch
from torch import nn

class TraceMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.layers = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 3))

    def forward(self, x):
        if x.ndim != 2 or x.shape[-1] != 4:
            raise ValueError(f"期望 (B,4)，实际 {tuple(x.shape)}")
        if not torch.isfinite(x).all():
            raise ValueError("输入含 NaN 或 Inf")
        logits = self.layers(x)
        if logits.shape != (x.shape[0], 3):
            raise RuntimeError("输出类别轴错误")
        return logits

model = TraceMLP()
batch = torch.randn(2, 4)
logits = model(batch)
print("logits:", logits.shape, logits.mean().item(), logits.std().item())

def shape_hook(name):
    def hook(module, inputs, output):
        input_shapes = [tuple(item.shape) for item in inputs if hasattr(item, "shape")]
        output_shape = tuple(output.shape) if hasattr(output, "shape") else type(output).__name__
        print(name, "in=", input_shapes, "out=", output_shape)
    return hook

handles = []
for name, module in model.named_modules():
    if name and isinstance(module, (nn.Linear, nn.ReLU)):
        handles.append(module.register_forward_hook(shape_hook(name)))

_ = model(torch.randn(2, 4))
for handle in handles:
    handle.remove()

import torch

def require_shape(tensor, expected, name):
    if tuple(tensor.shape) != tuple(expected):
        raise ValueError(f"{name}: 实际 {tuple(tensor.shape)}，期望 {tuple(expected)}")

def require_batch_features(tensor, features, name):
    if tensor.ndim != 2 or tensor.shape[-1] != features:
        raise ValueError(f"{name}: 期望 (B, {features})，实际 {tuple(tensor.shape)}")

batch = torch.randn(6, 4)
require_batch_features(batch, 4, "features")
expanded = batch.unsqueeze(1)
require_shape(expanded, (6, 1, 4), "expanded")
restored = expanded.squeeze(1)
require_shape(restored, (6, 4), "restored")
print("shape contract passed")

def mse(actual, predicted):
    if len(actual) != len(predicted) or not actual:
        raise ValueError("需要等长且非空的序列")
    return sum((a - p) ** 2 for a, p in zip(actual, predicted)) / len(actual)

def mae(actual, predicted):
    return sum(abs(a - p) for a, p in zip(actual, predicted)) / len(actual)

def huber(actual, predicted, delta=1.0):
    total = 0.0
    for a, p in zip(actual, predicted):
        error = abs(a - p)
        total += 0.5 * error * error if error <= delta else delta * (error - 0.5 * delta)
    return total / len(actual)

y = [10.0, 12.0, 30.0]
pred = [11.0, 11.0, 18.0]
print(mse(y, pred), mae(y, pred), huber(y, pred))

import torch
from torch import nn

logits = torch.tensor([[2.0, 0.5, -1.0], [0.2, 1.4, 0.1]])
targets = torch.tensor([0, 1], dtype=torch.long)
loss_fn = nn.CrossEntropyLoss()
loss = loss_fn(logits, targets)
predicted = logits.argmax(dim=1)
print("loss:", loss.item(), "predicted:", predicted.tolist())
assert logits.shape[0] == targets.shape[0]
assert targets.min().item() >= 0 and targets.max().item() < logits.shape[1]

binary_logits = torch.tensor([1.2, -0.7])
binary_targets = torch.tensor([1.0, 0.0])
binary_loss = nn.BCEWithLogitsLoss()(binary_logits, binary_targets)
print("binary loss:", binary_loss.item())

import torch
from torch import nn

batch, steps, classes = 2, 4, 5
logits = torch.randn(batch, classes, steps)
targets = torch.tensor([[1, 2, 3, -100], [0, 4, -100, -100]], dtype=torch.long)
loss_fn = nn.CrossEntropyLoss(ignore_index=-100, reduction="none")
per_position = loss_fn(logits, targets)
valid = targets.ne(-100)
valid_count = valid.sum()
loss = per_position.masked_select(valid).sum() / valid_count.clamp_min(1)
print("loss:", loss.item(), "valid tokens:", valid_count.item())
assert per_position.shape == targets.shape

import torch
from torch import nn

logits = torch.tensor([[2.0, 0.0, -1.0], [0.2, 1.4, 0.1]])
targets = torch.tensor([0, 2])
criterion = nn.CrossEntropyLoss(reduction="none")
per_sample = criterion(logits, targets)
print("per sample:", per_sample.tolist())
print("mean:", per_sample.mean().item())

token_logits = torch.randn(2, 4, 5)
token_targets = torch.tensor([[1, 2, 0, 3], [4, 0, 0, 1]])
valid = token_targets.ne(0)
flat_loss = nn.CrossEntropyLoss(reduction="none")(
    token_logits.reshape(-1, token_logits.shape[-1]),
    token_targets.reshape(-1),
)
masked_mean = flat_loss[valid.reshape(-1)].mean()
print("valid tokens:", int(valid.sum()), "masked mean:", masked_mean.item())

import torch

weight = torch.tensor(2.0, requires_grad=True)
bias = torch.tensor(1.0, requires_grad=True)
feature = torch.tensor(3.0)
target = torch.tensor(10.0)

prediction = weight * feature + bias
loss = (prediction - target) ** 2
print("prediction:", prediction.item(), "grad_fn:", prediction.grad_fn)
loss.backward()
print("dw:", weight.grad.item(), "db:", bias.grad.item())
assert weight.grad is not None and bias.grad is not None

import torch

parameter = torch.tensor(1.0, requires_grad=True)
first = (parameter - 3.0) ** 2
first.backward()
print("after first:", parameter.grad.item())
second = (parameter + 2.0) ** 2
second.backward()
print("after second, accumulated:", parameter.grad.item())

parameter.grad.zero_()
third = (parameter + 2.0) ** 2
third.backward()
print("after clear:", parameter.grad.item())

import torch

torch.manual_seed(7)
weight = torch.tensor(0.4, dtype=torch.float64, requires_grad=True)
target = torch.tensor(1.7, dtype=torch.float64)

loss = (weight * 2.0 - target) ** 2
loss.backward()
autograd_value = weight.grad.item()

def objective(value):
    return (value * 2.0 - target.item()) ** 2

epsilon = 1e-5
numeric = (objective(weight.item() + epsilon) - objective(weight.item() - epsilon)) / (2 * epsilon)
print("autograd:", autograd_value, "numeric:", numeric)
assert abs(autograd_value - numeric) < 1e-8

import torch

weight = torch.tensor(2.0, requires_grad=True)
input_value = torch.tensor(3.0)

loss_a = (weight * input_value - 1.0) ** 2
loss_a.backward()
first_gradient = weight.grad.item()
print("after first backward:", first_gradient)

weight.grad.zero_()
loss_b = (weight * input_value + 2.0) ** 2
loss_b.backward()
second_gradient = weight.grad.item()
print("after clear and second backward:", second_gradient)

with torch.no_grad():
    prediction = weight * input_value
print("prediction has grad_fn:", prediction.grad_fn)
assert prediction.grad_fn is None

def sgd_step(parameter, gradient, learning_rate):
    if learning_rate <= 0:
        raise ValueError("学习率必须为正")
    return parameter - learning_rate * gradient

parameter = 4.0
for step in range(5):
    gradient = 2 * (parameter - 1.0)
    parameter = sgd_step(parameter, gradient, learning_rate=0.2)
    print(step, parameter, gradient)
assert abs(parameter - 1.0) < 1.0

import torch
from torch import nn

class TinyNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
        self.norm = nn.LayerNorm(3)

    def forward(self, x):
        return self.norm(self.linear(x))

model = TinyNet()
decay, no_decay = [], []
for name, parameter in model.named_parameters():
    (no_decay if name.endswith("bias") or "norm" in name else decay).append(parameter)
optimizer = torch.optim.AdamW([
    {"params": decay, "weight_decay": 1e-2},
    {"params": no_decay, "weight_decay": 0.0},
], lr=3e-4)
print([len(group["params"]) for group in optimizer.param_groups])

import torch

def train_one_epoch(loader, model, loss_fn, optimizer, device):
    model.train()
    total_loss = 0.0
    total_items = 0
    for features, targets in loader:
        features, targets = features.to(device), targets.to(device)
        optimizer.zero_grad(set_to_none=True)
        logits = model(features)
        loss = loss_fn(logits, targets)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
        optimizer.step()
        batch_size = targets.shape[0]
        total_loss += loss.detach().item() * batch_size
        total_items += batch_size
    return total_loss / max(total_items, 1)

def evaluate(loader, model, loss_fn, device):
    model.eval()
    total_loss, total_items = 0.0, 0
    with torch.no_grad():
        for features, targets in loader:
            logits = model(features.to(device))
            loss = loss_fn(logits, targets.to(device))
            total_loss += loss.item() * targets.shape[0]
            total_items += targets.shape[0]
    return total_loss / max(total_items, 1)

def fit(train_loader, valid_loader, model, loss_fn, optimizer, device, epochs=20, patience=3):
    best_loss = float("inf")
    best_state = None
    stale = 0
    history = []
    for epoch in range(1, epochs + 1):
        train_loss = train_one_epoch(train_loader, model, loss_fn, optimizer, device)
        valid_loss = evaluate(valid_loader, model, loss_fn, device)
        history.append({"epoch": epoch, "train_loss": train_loss, "valid_loss": valid_loss})
        if valid_loss < best_loss:
            best_loss = valid_loss
            best_state = {key: value.detach().cpu().clone() for key, value in model.state_dict().items()}
            stale = 0
        else:
            stale += 1
        if stale >= patience:
            break
    if best_state is not None:
        model.load_state_dict(best_state)
    return history, epoch

import torch
from torch import nn

torch.manual_seed(7)
model = nn.Linear(2, 1)
optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
inputs = torch.tensor([[1.0, 0.0], [0.0, 1.0]])
targets = torch.tensor([[1.0], [-1.0]])
criterion = nn.MSELoss()

for step in range(5):
    optimizer.zero_grad(set_to_none=True)
    prediction = model(inputs)
    loss = criterion(prediction, targets)
    loss.backward()
    grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
    optimizer.step()
    print(step, round(loss.item(), 5), round(float(grad_norm), 5))

import torch
from torch.utils.data import Dataset, DataLoader

class TabularDataset(Dataset):
    def __init__(self, rows):
        self.rows = rows

    def __len__(self):
        return len(self.rows)

    def __getitem__(self, index):
        row = self.rows[index]
        features = torch.tensor(row["features"], dtype=torch.float32)
        label = torch.tensor(row["label"], dtype=torch.long)
        return features, label, row["id"]

rows = [{"id": "a", "features": [1.0, 0.2, 3.0], "label": 0},
        {"id": "b", "features": [0.4, 0.8, 1.0], "label": 2}]
loader = DataLoader(TabularDataset(rows), batch_size=2, shuffle=False)
features, labels, ids = next(iter(loader))
print(features.shape, labels.shape, ids)
assert features.shape == (2, 3) and labels.dtype == torch.long

import torch
from torch import nn

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = nn.Linear(4, 2).to(device)
features = torch.randn(3, 4, device=device, dtype=torch.float32)
labels = torch.tensor([0, 1, 0], device=device, dtype=torch.long)

assert next(model.parameters()).device == features.device
assert features.dtype == torch.float32 and labels.dtype == torch.long
model.train()
logits = model(features)
print(device, logits.shape, logits.dtype)
with torch.no_grad():
    evaluation = model(features)
assert evaluation.shape == logits.shape

from pathlib import Path
import torch

def save_checkpoint(path, model, optimizer, epoch, metric, config):
    payload = {
        "model_state_dict": model.state_dict(),
        "optimizer_state_dict": optimizer.state_dict(),
        "epoch": epoch,
        "metric": metric,
        "config": config,
        "rng_state": torch.get_rng_state(),
    }
    temporary = Path(str(path) + ".tmp")
    torch.save(payload, temporary)
    check = torch.load(temporary, map_location="cpu", weights_only=True)
    if check["epoch"] != epoch or check["config"] != config:
        raise ValueError("检查点回读校验失败")
    temporary.replace(path)

# 练习：加载后先检查键，再把 state_dict 放回同一结构

import torch
from torch.nn.utils.rnn import pad_sequence

samples = [
    {"tokens": torch.tensor([4, 8, 2]), "label": 1, "id": "a"},
    {"tokens": torch.tensor([9, 3]), "label": 0, "id": "b"},
    {"tokens": torch.tensor([5, 6, 7, 1]), "label": 1, "id": "c"},
]

def collate(batch, padding_id=0):
    token_rows = [item["tokens"] for item in batch]
    tokens = pad_sequence(token_rows, batch_first=True, padding_value=padding_id)
    lengths = torch.tensor([len(row) for row in token_rows], dtype=torch.long)
    mask = torch.arange(tokens.shape[1]).unsqueeze(0) < lengths.unsqueeze(1)
    labels = torch.tensor([item["label"] for item in batch], dtype=torch.long)
    ids = [item["id"] for item in batch]
    return {"tokens": tokens, "mask": mask, "lengths": lengths, "labels": labels, "ids": ids}

batch = collate(samples)
print(batch["tokens"].shape, batch["mask"].sum(dim=1).tolist())
assert batch["tokens"].shape == (3, 4)
assert batch["mask"].sum().item() == 9

def diagnose(history):
    if len(history) < 3:
        return "样本太少，先继续记录"
    train = [row["train_loss"] for row in history]
    valid = [row["valid_loss"] for row in history]
    if train[-1] > train[0] and valid[-1] > valid[0]:
        return "优化或数据可能有问题"
    if train[-1] < train[0] and valid[-1] > valid[min(len(valid) - 1, 1)]:
        return "检查过拟合、切分与标签"
    return "结合分桶指标与梯度继续判断"

history = [{"train_loss": 1.8, "valid_loss": 1.9},
           {"train_loss": 1.2, "valid_loss": 1.3},
           {"train_loss": 0.8, "valid_loss": 1.5}]
print(diagnose(history))

import torch
from torch import nn

torch.manual_seed(3)
model = nn.Sequential(nn.Linear(4, 4), nn.Dropout(p=0.5))
x = torch.ones(2, 4)

model.train()
train_a = model(x)
train_b = model(x)
print("train equal:", torch.equal(train_a, train_b))

model.eval()
eval_a = model(x)
eval_b = model(x)
print("eval equal:", torch.equal(eval_a, eval_b))
assert torch.equal(eval_a, eval_b)

import torch
from torch import nn

torch.manual_seed(5)
batch = torch.randn(2, 3, 4)
batch_norm = nn.BatchNorm1d(4)
layer_norm = nn.LayerNorm(4)

batch_norm.train()
train_out = batch_norm(batch.reshape(-1, 4)).reshape(2, 3, 4)
batch_norm.eval()
eval_out = batch_norm(batch.reshape(-1, 4)).reshape(2, 3, 4)
layer_out = layer_norm(batch)
print(train_out.shape, eval_out.shape, layer_out.shape)
print("running mean:", batch_norm.running_mean)
assert layer_out.shape == batch.shape

from dataclasses import dataclass, asdict
import json

@dataclass
class EpochRecord:
    epoch: int
    samples_seen: int
    train_loss: float
    valid_loss: float
    valid_metric: float
    learning_rate: float
    mode: str

history = [
    EpochRecord(1, 128, 0.91, 0.98, 0.52, 1e-3, "eval"),
    EpochRecord(2, 256, 0.63, 0.71, 0.68, 1e-3, "eval"),
    EpochRecord(3, 384, 0.41, 0.79, 0.64, 5e-4, "eval"),
]
best = min(history, key=lambda row: row.valid_loss)
with open("curve.json", "w", encoding="utf-8") as handle:
    json.dump([asdict(row) for row in history], handle, ensure_ascii=False, indent=2)
print("best epoch:", best.epoch, "valid loss:", best.valid_loss)

import torch
from torch import nn

block = nn.Sequential(
    nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(kernel_size=2),
)
images = torch.randn(4, 3, 32, 32)
features = block(images)
print("input:", images.shape, "output:", features.shape)
assert features.shape == (4, 16, 16, 16)
params = sum(parameter.numel() for parameter in block.parameters())
print("trainable parameters:", params)

import torch
from torch import nn

vocab_size, embedding_dim = 100, 8
embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=0)
token_ids = torch.tensor([[4, 9, 2, 0], [7, 3, 0, 0]], dtype=torch.long)
hidden = embedding(token_ids)
mask = token_ids.ne(0)
lengths = mask.sum(dim=1)
pooled = (hidden * mask.unsqueeze(-1)).sum(dim=1) / lengths.clamp_min(1).unsqueeze(-1)
print(hidden.shape, mask.shape, lengths.tolist(), pooled.shape)
assert hidden.shape == (2, 4, 8) and pooled.shape == (2, 8)

from math import exp, sqrt, tanh


def recurrent_states(tokens, memory=0.65):
    """用同维度状态演示按顺序递归；这不是完整可训练 RNN。"""
    state = [0.0] * len(tokens[0])
    states = []
    for token in tokens:
        state = [tanh(value + memory * old)
                 for value, old in zip(token, state)]
        states.append(state)
    return states


def dot(left, right):
    return sum(a * b for a, b in zip(left, right))


def attention(query, keys, values):
    scale = sqrt(len(query))
    scores = [dot(query, key) / scale for key in keys]
    peak = max(scores)
    weights = [exp(score - peak) for score in scores]
    total = sum(weights)
    weights = [weight / total for weight in weights]
    context = [sum(weight * value[index]
                   for weight, value in zip(weights, values))
               for index in range(len(values[0]))]
    return weights, context


tokens = [[1.0, 0.0], [0.2, 0.8], [0.0, 1.0]]
states = recurrent_states(tokens)
weights, context = attention([1.0, 0.0], tokens, tokens)
print("RNN final state:", [round(value, 3) for value in states[-1]])
print("attention weights:", [round(value, 3) for value in weights])
print("attention context:", [round(value, 3) for value in context])
assert len(states) == len(tokens)
assert abs(sum(weights) - 1.0) < 1e-12

import torch
from torch import nn

class ImageHead(nn.Module):
    def __init__(self, classes=3):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 8, 3, padding=1), nn.ReLU(),
            nn.AdaptiveAvgPool2d((1, 1)),
        )
        self.classifier = nn.Linear(8, classes)

    def forward(self, images):
        if images.ndim != 4 or images.shape[1] != 1:
            raise ValueError(f"期望 (B,1,H,W)，实际 {tuple(images.shape)}")
        features = self.features(images).flatten(1)
        return self.classifier(features)

model = ImageHead()
logits = model(torch.randn(5, 1, 28, 28))
print(logits.shape)
assert logits.shape == (5, 3)

def conv_output(size, kernel, padding=0, stride=1):
    numerator = size + 2 * padding - kernel
    return numerator // stride + 1

def update_receptive_field(field, jump, kernel, stride=1):
    new_field = field + (kernel - 1) * jump
    new_jump = jump * stride
    return new_field, new_jump

height = 32
field, jump = 1, 1
for kernel, stride, padding in [(3, 1, 1), (3, 2, 1), (3, 1, 1)]:
    height = conv_output(height, kernel, padding, stride)
    field, jump = update_receptive_field(field, jump, kernel, stride)
    print("shape:", height, "receptive field:", field, "jump:", jump)
assert height == 16

import torch
from torch.utils.data import TensorDataset, DataLoader, random_split

def make_xor(n_per_corner=80, noise=0.16, seed=17):
    generator = torch.Generator().manual_seed(seed)
    corners = torch.tensor([[-1., -1.], [-1., 1.], [1., -1.], [1., 1.]])
    labels = torch.tensor([0, 1, 1, 0], dtype=torch.long)
    points = corners.repeat_interleave(n_per_corner, dim=0)
    points = points + noise * torch.randn(points.shape, generator=generator)
    targets = labels.repeat(n_per_corner)
    return points.float(), targets

features, targets = make_xor_data()
dataset = TensorDataset(features, targets)
train, valid, test = random_split(dataset, [220, 50, 50], generator=torch.Generator().manual_seed(9))
train_loader = DataLoader(train, batch_size=32, shuffle=True)
valid_loader = DataLoader(valid, batch_size=64, shuffle=False)
test_loader = DataLoader(test, batch_size=64, shuffle=False)
print(len(train), len(valid), len(test), features.shape)
assert features.shape[1] == 2 and targets.dtype == torch.long

import torch

def confusion_matrix(targets, predictions, classes):
    matrix = torch.zeros(classes, classes, dtype=torch.long)
    for truth, estimate in zip(targets.tolist(), predictions.tolist()):
        matrix[truth, estimate] += 1
    return matrix

def collect_predictions(loader, model, device):
    model.eval()
    all_targets, all_predictions = [], []
    with torch.no_grad():
        for features, targets in loader:
            logits = model(features.to(device))
            all_predictions.append(logits.argmax(dim=1).cpu())
            all_targets.append(targets.cpu())
    return torch.cat(all_targets), torch.cat(all_predictions)

# targets, predictions = collect_predictions(test_loader, model, device)
# print(confusion_matrix(targets, predictions, classes=2))

from dataclasses import dataclass, asdict
import json

@dataclass(frozen=True)
class RunSpec:
    run_id: str
    architecture: str
    activation: str
    learning_rate: float
    dropout: float
    seed: int
    data_version: str

runs = [
    RunSpec("linear-s1", "linear", "none", 1e-3, 0.0, 7, "xor-v1"),
    RunSpec("mlp-s1", "mlp", "relu", 1e-3, 0.0, 7, "xor-v1"),
    RunSpec("mlp-drop-s1", "mlp", "relu", 1e-3, 0.2, 7, "xor-v1"),
]
with open("runs.json", "w", encoding="utf-8") as handle:
    json.dump([asdict(run) for run in runs], handle, ensure_ascii=False, indent=2)
print("saved", len(runs), "run specifications")

checklist = {
    "task_card": True,
    "shape_contract": True,
    "loss_contract": True,
    "train_eval_modes": True,
    "gradient_check": True,
    "seed_runs": 3,
    "error_samples_saved": True,
    "checkpoint_round_trip": True,
}
required = [
    "task_card", "shape_contract", "loss_contract",
    "train_eval_modes", "gradient_check", "error_samples_saved",
    "checkpoint_round_trip",
]
missing = [name for name in required if not checklist[name]]
if checklist["seed_runs"] < 2:
    missing.append("multiple_seed_runs")
if missing:
    raise ValueError(f"进入下一章前仍缺少: {missing}")
print("chapter 5 checklist passed")

from dataclasses import dataclass, asdict
from pathlib import Path
import json

@dataclass(frozen=True)
class Evidence:
    data_version: str
    model_version: str
    seed: int
    best_epoch: int
    valid_metric: float
    checkpoint: str
    limitations: tuple[str, ...]

evidence = Evidence(
    data_version="xor-v1",
    model_version="mlp-relu-h8",
    seed=7,
    best_epoch=42,
    valid_metric=0.98,
    checkpoint="runs/mlp-s1.pt",
    limitations=("toy data", "single split"),
)
Path("evidence.json").write_text(
    json.dumps(asdict(evidence), ensure_ascii=False, indent=2),
    encoding="utf-8",
)
print("evidence saved")