01 · 第一天：从噪声里捞出一张图

import torch
torch.manual_seed(0)

CENTERS = torch.tensor([[-2.0, -1.0], [2.0, 1.0]])           # 两团的中心
def make_data(n):
    return CENTERS[torch.randint(0, 2, (n,))] + 0.35 * torch.randn(n, 2)

x0 = make_data(4096)
lab = torch.cdist(x0, CENTERS).argmin(1)                     # 每个点离哪个中心近
print("整体std:", [round(v, 3) for v in x0.std(0).tolist()])
for k in (0, 1):
    g = x0[lab == k]
    print(f"第 {k} 团 {len(g)} 个点  中心 {[round(v,3) for v in g.mean(0).tolist()]}"
          f"  团内std {round(g.std(0).mean().item(), 3)}")

整体std: [2.042, 1.061]
第 0 团 2007 个点  中心 [-2.016, -1.006]  团内std 0.356
第 1 团 2089 个点  中心 [2.007, 0.995]  团内std 0.35

import torch
torch.manual_seed(0)

T = 200
betas = torch.linspace(1e-4, 0.06, T)      # 每一步掺多少新噪声
abar = torch.cumprod(1.0 - betas, dim=0)   # ᾱ_t = (1-β₁)(1-β₂)…(1-β_t)  ⭐ 秘密全在它身上

CENTERS = torch.tensor([[-2.0, -1.0], [2.0, 1.0]])
which = torch.randint(0, 2, (4096,))
x0 = CENTERS[which] + 0.35 * torch.randn(4096, 2)

# ⚠️ 表头用 ASCII：Windows 控制台默认 gbk，打 √ 和 ᾱ 会直接抛 UnicodeEncodeError
print(f"{'t':>4}{'abar':>9}{'sqrt(abar)':>12}{'sqrt(1-abar)':>14}{'两团中心间距':>13}{'整体std':>9}")
for t in (0, 49, 99, 149, 199):
    a = abar[t]
    xt = a.sqrt() * x0 + (1 - a).sqrt() * torch.randn_like(x0)   # ⭐ 一步到位，不用循环
    gap = (xt[which == 0].mean(0) - xt[which == 1].mean(0)).norm()
    print(f"{t:>4}{a:>9.4f}{a.sqrt():>12.3f}{(1-a).sqrt():>14.3f}{gap:>13.3f}{xt.std():>9.3f}")
print("原始两团中心间距:", round((CENTERS[0] - CENTERS[1]).norm().item(), 3))

   t     abar  sqrt(abar)  sqrt(1-abar)       两团中心间距    整体std
   0   0.9999       1.000         0.010        4.493    1.627
  49   0.6869       0.829         0.560        3.709    1.453
  99   0.2198       0.469         0.883        2.117    1.169
 149   0.0324       0.180         0.984        0.799    1.023
 199   0.0022       0.047         0.999        0.205    0.996
原始两团中心间距: 4.472

import math, time, torch
import torch.nn as nn

torch.manual_seed(0)

# ---------- ① 数据：两个高斯团 ----------
CENTERS = torch.tensor([[-2.0, -1.0], [2.0, 1.0]])
def make_data(n):
    return CENTERS[torch.randint(0, 2, (n,))] + 0.35 * torch.randn(n, 2)

# ---------- ② 噪声表 ----------
T = 200
betas = torch.linspace(1e-4, 0.06, T)
alphas = 1.0 - betas
abar = torch.cumprod(alphas, 0)

# ---------- ③ 去噪网络：输入 (x_t, t)，输出「我猜掺进去的噪声是什么」----------
class Denoiser(nn.Module):
    def __init__(self, dim=2, h=128, temb=32):
        super().__init__()
        self.temb = temb
        self.net = nn.Sequential(
            nn.Linear(dim + temb, h), nn.SiLU(),
            nn.Linear(h, h), nn.SiLU(),
            nn.Linear(h, dim))
    def forward(self, x, t):
        half = self.temb // 2
        freq = torch.exp(-math.log(1000.0) * torch.arange(half) / half)
        ang = t[:, None].float() * freq[None, :]
        emb = torch.cat([ang.sin(), ang.cos()], 1)   # 告诉网络「现在噪声有多大」
        return self.net(torch.cat([x, emb], 1))

model = Denoiser()
opt = torch.optim.Adam(model.parameters(), lr=2e-3)

# ---------- ④ 训练：唯一的损失就是「噪声猜得准不准」----------
t0, run = time.time(), 0.0
for step in range(4000):
    x0 = make_data(256)
    t = torch.randint(0, T, (256,))
    eps = torch.randn_like(x0)
    a = abar[t][:, None]
    xt = a.sqrt() * x0 + (1 - a).sqrt() * eps     # 前向加噪，一步到位
    loss = ((model(xt, t) - eps) ** 2).mean()     # ⭐ 全部训练目标就这一行
    opt.zero_grad(); loss.backward(); opt.step()
    run = loss.item() if step == 0 else 0.99 * run + 0.01 * loss.item()
    if step % 1000 == 0 or step == 3999:
        print(f"step {step:4d}  平滑后的 loss {run:.4f}")
print(f"训练用时 {time.time() - t0:.1f} 秒")

# ---------- ⑤ 采样：从纯噪声倒着走 200 步 ----------
@torch.no_grad()
def sample(n):
    x = torch.randn(n, 2)                          # t = T-1，纯噪声
    for i in reversed(range(T)):
        t = torch.full((n,), i, dtype=torch.long)
        mean = (x - betas[i] / (1 - abar[i]).sqrt() * model(x, t)) / alphas[i].sqrt()
        x = mean if i == 0 else mean + betas[i].sqrt() * torch.randn_like(x)
    return x

# ---------- ⑥ 对照：不迭代，直接从纯噪声反解一次 ----------
@torch.no_grad()
def one_shot(n):
    x = torch.randn(n, 2)
    t = torch.full((n,), T - 1, dtype=torch.long)
    return (x - (1 - abar[-1]).sqrt() * model(x, t)) / abar[-1].sqrt()

def report(name, pts):
    d = torch.cdist(pts, CENTERS); lab = d.argmin(1)
    hit = (d.min(1).values < 1.0).float().mean() * 100     # ⭐ 落在任一团 1.0 半径内的比例
    c = [[round(v, 2) for v in pts[lab == k].mean(0).tolist()] for k in (0, 1)]
    s = [round(pts[lab == k].std(0).mean().item(), 3) for k in (0, 1)]
    print(f"{name:16s} 落在团里 {hit:5.1f}%   两团中心 {c[0]} {c[1]}   "
          f"团内std {s}   整体std {[round(v, 2) for v in pts.std(0).tolist()]}")

torch.manual_seed(1)
report("真实数据", make_data(4000))
report("走完 200 步", sample(4000))
report("只走 1 步反解", one_shot(4000))
report("什么都不做", torch.randn(4000, 2))

step    0  平滑后的 loss 1.0095
step 1000  平滑后的 loss 0.2697
step 2000  平滑后的 loss 0.2605
step 3000  平滑后的 loss 0.2596
step 3999  平滑后的 loss 0.2600
训练用时 17.3 秒
真实数据             落在团里  98.2%   两团中心 [-1.99, -1.0] [1.99, 0.99]   团内std [0.349, 0.355]   整体std [2.02, 1.06]
走完 200 步         落在团里  97.4%   两团中心 [-2.05, -0.93] [2.05, 1.04]   团内std [0.37, 0.365]   整体std [2.08, 1.05]
只走 1 步反解         落在团里  15.8%   两团中心 [-0.36, -0.71] [1.01, 0.33]   团内std [0.63, 0.736]   整体std [0.99, 0.84]
什么都不做            落在团里  10.6%   两团中心 [-0.72, -0.33] [0.71, 0.34]   团内std [0.819, 0.825]   整体std [1.0, 1.0]