先跑通一次训练，
再按需要查写法。

import torch

x = torch.tensor([[1., 2.], [3., 4.]])
print(x.shape, x.dtype, x.device)          # torch.Size([2,2]) torch.float32 cpu

# 和 numpy 几乎一样
x @ x.T          # 矩阵乘
x.sum(dim=0)     # 沿维度求和
x.view(-1)       # view 要求尺寸/步幅兼容；reshape 必要时会复制

# 三个高频操作
x.unsqueeze(1)   # 加一个维度 (2,2) → (2,1,2)
x.squeeze()      # 去掉所有大小为1的维度
torch.cat([x, x], dim=0)   # 拼接

import torch
w = torch.tensor([2.0], requires_grad=True)
loss = (w * 3 - 6) ** 2
loss.backward()          # 自动算梯度
print(w.grad)            # tensor([0.]) —— w=2 时正好是最优

import torch.nn as nn

# 写法1：Sequential —— 简单直筒结构
model = nn.Sequential(
    nn.Linear(30, 64), nn.ReLU(), nn.Dropout(0.2),
    nn.Linear(64, 32), nn.ReLU(),
    nn.Linear(32, 1),               # ⭐ 二分类不加 Sigmoid
)

# 写法2：继承 Module —— 需要控制前向逻辑时
class Net(nn.Module):
    def __init__(self, in_dim, n_class):
        super().__init__()
        self.backbone = nn.Sequential(nn.Linear(in_dim,64), nn.ReLU())
        self.head = nn.Linear(64, n_class)
    def forward(self, x):
        h = self.backbone(x)
        return self.head(h)          # 可以在这加残差、多分支等

from torch.utils.data import TensorDataset, DataLoader, Dataset
import torch
import numpy as np

# 简单情况：数据已在内存
X_tensor = torch.tensor([[1., 2.], [3., 4.], [5., 6.], [7., 8.]])
y_tensor = torch.tensor([[0.], [0.], [1.], [1.]])
ds = TensorDataset(X_tensor, y_tensor)
loader = DataLoader(ds, batch_size=32, shuffle=True,
                    num_workers=0)   # 先跑通，再按瓶颈调整
print(next(iter(loader))[0].shape)    # torch.Size([4, 2])

# 自定义 Dataset：数据要现读现处理时
class MyDataset(Dataset):
    def __init__(self, paths, labels, transform=None):
        self.paths, self.labels, self.transform = paths, labels, transform
    def __len__(self):
        return len(self.paths)
    def __getitem__(self, i):
        x = torch.as_tensor(np.load(self.paths[i]), dtype=torch.float32)
        if self.transform: x = self.transform(x)
        return x, self.labels[i]

import numpy as np, torch, torch.nn as nn
from torch.utils.data import TensorDataset, DataLoader
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42)
X_train, X_val, y_train, y_val = train_test_split(
    X_train, y_train, test_size=0.25, stratify=y_train, random_state=42)
scaler = StandardScaler().fit(X_train)
Xtr, Xva, Xte = [torch.tensor(scaler.transform(a), dtype=torch.float32)
                 for a in (X_train, X_val, X_test)]
ytr, yva, yte = [torch.tensor(a, dtype=torch.float32).reshape(-1, 1)
                 for a in (y_train, y_val, y_test)]
loader = DataLoader(TensorDataset(Xtr, ytr), batch_size=32,
                    shuffle=True, num_workers=0)

def make_model():
    return nn.Sequential(nn.Linear(30, 64), nn.ReLU(),
                         nn.Linear(64, 32), nn.ReLU(), nn.Linear(32, 1))

def set_seed(s=42):
    import random
    random.seed(s); np.random.seed(s); torch.manual_seed(s)
    torch.cuda.manual_seed_all(s)
set_seed()

device = "cuda" if torch.cuda.is_available() else "cpu"
model = make_model().to(device)
criterion = nn.BCEWithLogitsLoss()
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.01)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=60)

# ========== 第0步：先证明能过拟合 10 个样本（第11章）⭐ ==========
tx, ty = Xtr[:10].to(device), ytr[:10].to(device)
model.train()
for step in range(301):
    optimizer.zero_grad()
    loss = criterion(model(tx), ty)
    loss.backward(); optimizer.step()
print(f"10样本过拟合检查: loss={loss.item():.5f} "
      f"{'小样本拟合通过' if loss.item()<0.01 else '待排查：容量、学习率、标签与训练步数'}")

# ========== 正式训练 + 早停 ==========
set_seed(); model = make_model().to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.01)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=60)

best, wait, patience, best_state = float("inf"), 0, 10, None
for ep in range(60):
    # --- 训练 ---
    model.train()                     # ⭐ 开启 Dropout/BN 训练模式
    total = 0.0
    for xb, yb in loader:
        xb, yb = xb.to(device), yb.to(device)
        optimizer.zero_grad()                                   # ⭐ 必须
        loss = criterion(model(xb), yb)
        loss.backward()
        gn = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0).item()
        optimizer.step()
        total += loss.item() * len(xb)
    scheduler.step()

    # --- 验证 ---
    model.eval()                      # ⭐ 关闭 Dropout，BN 用running统计
    with torch.no_grad():             # ⭐ 不建计算图，省显存加速
        val_loss = criterion(model(Xva.to(device)), yva.to(device)).item()

    print(f"ep {ep:<3} train {total/len(Xtr):.4f} | val {val_loss:.4f} "
          f"| lr {optimizer.param_groups[0]['lr']:.2e} | grad {gn:.2f}")   # 第11章六个数字

    # --- 早停 ---
    if val_loss < best:
        best, wait = val_loss, 0
        best_state = {k: v.clone() for k, v in model.state_dict().items()}
    else:
        wait += 1
        if wait >= patience:
            # 跳出循环后统一恢复最佳权重
            print(f"早停于 ep {ep}"); break

# 早停或跑满轮数，都恢复验证损失最小的一份权重
model.load_state_dict(best_state)
model.eval()
with torch.no_grad():
    test_logits = model(Xte.to(device))
    test_acc = ((test_logits > 0) == yte.to(device)).float().mean().item()
print(f"恢复最佳权重后的测试准确率：{test_acc:.1%}")

# 1. CUDA 混合精度：收益取决于硬件和算子，不保证显存减半
import torch
scaler = torch.amp.GradScaler()
with torch.amp.autocast("cuda"):
    loss = criterion(model(xb), yb)
scaler.scale(loss).backward()
scaler.step(optimizer); scaler.update()

# 2. 梯度累积（小显存模拟大 batch）
loss = criterion(model(xb), yb) / accum
loss.backward()
if (i+1) % accum == 0:
    optimizer.step(); optimizer.zero_grad()

# 3. 编译加速（PyTorch 2.0+）
model = torch.compile(model)