TI · Thực hành huấn luyện sinh ảnh

Bài Lab tổng hợp: học vận tốc từ nhiễu tới ảnh hình học

Chạy vòng flow matching NumPy từ ảnh 4×4 tới EMA và sampling, kiểm tra gradient, nhánh CFG rỗng và LoRA bằng các giá trị được tính thật.

LESSON ID ti-end-to-end-lab GROUP Bài Lab tổng hợp

1Định nghĩa

Bài lab này là một thí nghiệm NumPy tự chứa để quan sát một mô hình sinh ảnh thu nhỏ học trường vận tốc từ nhiễu tới dữ liệu. Nó nối dữ liệu, dự đoán, MSE, backward và AdamW thành một vòng, rồi lấy bản trọng số cố định ra sinh ảnh hình học.

Dữ liệu gồm nét ngang/dọc 4×4, bảng nhãn cố định và MLP 1.744 tham số thay DiT. Đường flow cung cấp target, CFG cần nhánh rỗng được học, LoRA đổi một miền nét dày bằng hai ma trận nhỏ. Mỗi khối output nêu quan sát và giới hạn của phép kiểm tra.

Ví dụ đời thường: Xưởng vẽ hai hình đơn giản cho người học thấy giấy, phiếu yêu cầu, thao tác sửa và bức tranh cuối nối nhau ra sao. Xưởng nhỏ giúp kiểm tra mỗi bước, nhưng hoàn thành hai mẫu không đồng nghĩa đã biết vẽ cảnh hay chân dung.

2Luồng

10 giai đoạn lab ánh xạ 24 ô; phần chưa thực thi có nhãn rõ. Giai đoạn 10 không là một lần huấn luyện các phương pháp nâng cao.

Sơ đồ kiến trúc huấn luyện · 24 ô (1A → 5D)

Kiến trúc huấn luyện LLM · Ánh xạ với Bài Lab tổng hợp

Bắt đầu 1A → 1B, tách ảnh sang 1C và chữ sang 1D. Cột 2 tạo trạng thái nhiễu, điều kiện và target để 2D dự đoán; 3A → 3D chấm và sửa trọng số. next batch lặp về dữ liệu, load weights xuống 5A → 5D để sampling không gradient. Cột 4 là các lựa chọn, không phải chuỗi bước bắt buộc. Liên kết Lab trong pop-over nêu phần thực thi và phần chỉ giải thích.

Sơ đồ huấn luyện sinh ảnh gồm 24 ô từ 1A đến 5D

1A1 · Dữ liệu và điều kiện

ảnh + mô tả → một cặp dữ liệu

1A · Cặp ảnh–chú thích

Điểm bắt đầu: nối đúng ảnh với mô tả để học quan hệ giữa chữ và nội dung ảnh.

Nhận gì: Ảnh và chú thích mô tả nội dung cần sinh, trước khi tạo nhiễu.
Làm gì, vì sao: Giữ định danh và nguồn của từng cặp; kiểm tra chữ còn đúng với ảnh để tránh dạy quan hệ sai.
Ra gì: Cặp dữ liệu đi tới 1B để lọc, chia kiểm định và ghép batch.
Ví dụ, cách đọc ô: Một ảnh nét ngang đi cùng nhãn ngang; tráo nhãn dọc làm sai bài toán dù ảnh không hỏng.
Lưu ý: Lab chỉ có ảnh hình học tự tạo; không chứng minh độ phủ dữ liệu ảnh tự nhiên.

Đọc bài 1A · Cặp ảnh–chú thích Lab 1 · Cặp ảnh và điều kiện — Ảnh tổng hợp được tạo thật; không tải ảnh tự nhiên.

Sơ đồ luồng (3 bước)

Tạo đề và target
Ảnh sạch + nhiễu + t + điều kiện, target là z−e.
Học denoiser
Forward, MSE, gradient và AdamW, theo dõi EMA.
Lấy mẫu
Nạp bản sao EMA, Euler và CFG rồi đọc lưới 4×4.

Mã Mermaid

flowchart TD
  step1["Tạo đề và target"]
  step2["Học denoiser"]
  step3["Lấy mẫu"]
  step1 --> step2
  step2 --> step3

3Giải pháp

Chuẩn bị và dự đoán

Tiền đề là tensor/attention từ Foundations và loss–gradient–AdamW từ Training (Text). Nhắc lại: loss là điểm phạt, gradient là độ nhạy, optimizer chọn mức sửa. Mở Tab 02 hoặc chạy file với Python có NumPy; trên máy tác giả dùng /usr/bin/python3 public/labs/llm-training-image/training-image-end-to-end.py.

Dự đoán t=0 và t=1 cho ảnh nào, dấu của u=z−e khi z nhỏ hơn e, và việc bỏ điều kiện có thay target không. Sau đó chạy nguyên cấu hình, đọc Quan sát trước, giải thích bằng Kết luận rồi đọc Không chứng minh.

Đọc từ ảnh sang trọng số mới

Khối 1–2 tương ứng 1A–1D và 2A/2B/2E nhưng VAE/encoder chỉ là phép thay thế. Khối 3 dùng MLP nhận 19 số, trả 16 vận tốc; khối 4 lấy MSE; khối 5 kiểm tra bốn phần tử gradient rồi cập nhật AdamW. Hai đầu nội suy lệch 0 và gradient khớp dưới 1e−7 là điều kiện đúng số học trước khi học dài.

Khối 6 chạy 1.800 bước, so kiểm định cố định trước/sau và giữ EMA. Khối 7 học thêm đối chứng p=0 với cùng khởi tạo/batch; khối 8 học adapter LoRA cho nét dày. Tách dữ liệu và trọng số từng nhánh để không lẫn kết quả thích nghi với checkpoint dùng lấy mẫu ở khối 9.

Đọc trọng số sang ảnh và giới hạn

Khối 9 dùng bản sao EMA từ khối 6, không dùng LoRA nét dày, để sinh hai nét mảnh. Cùng nhiễu được dùng khi so CFG và số bước; số thô ngoài [−1,1] vẫn được in để không giấu sai số. Khối 10 chỉ đếm byte trọng số, không là phép đo hiệu năng hay đầy đủ footprint huấn luyện.

Mở các bài tập bên dưới, đổi một hằng số rồi tự đối chiếu. Các đáp án đến từ những lần chạy biến thể thực tế; các chữ số cuối có thể khác giữa NumPy native và trình duyệt. Các kỹ thuật chưa thực thi được nêu ngay trong bảng và output để bạn không dùng kết quả lab thay thí nghiệm thật.

4Profiling

Đúng số học và điều kiện so sánh
Kiểm tra hai đầu đường, sai phân gradient, finite output và gộp LoRA trước khi đọc loss. So cùng validation triples và ghi seed/cấu hình; bản output mẫu chỉ để đọc số, không thay điều kiện assertion.
Chi phí và phạm vi
Lab không đo GPU hay thời gian. Byte trọng số float64 là 13.952, chưa có activation/gradient/AdamW. Chỉ có hai kiểu nét và một seed; cần nhiều dữ liệu/seed với đánh giá ảnh độc lập trước khi kết luận chất lượng tổng quát.

Mẹo đo lường: ghim số liệu trên workload thật, ghi cả p50/p95/p99 thay vì chỉ trung bình, và luôn ghi lại điều kiện chạy (batch, cache, đồng thời, phần cứng) trước và sau khi tối ưu. Số đo thiếu điều kiện chạy thì không so sánh được.

5Ví dụ

Tự kiểm tra khác biệt hai loss

Vì sao raw kiểm định 0,239795 không bằng minibatch cuối 0,242463? Vì một số đo tập cố định 128 cặp, một số đo batch học mới. Hãy giữ đúng ảnh–nhiễu–t khi so trước/sau.

Đọc một ảnh

Trong ma trận ngang, tìm hàng thứ hai gần +1; ở ma trận dọc tìm cột thứ hai gần +1. Các vị trí còn lại gần −1. Nếu chỉ thấy PASS mà không giải thích được vị trí nét sáng, hãy quay lại khối 1 và công thức Euler ở khối 9.

6Thuật ngữ

MLP: Mạng truyền thẳng, ở lab một lớp tanh giữa hai phép chiếu; không có attention.
EMA: Bản trọng số trung bình trượt theo thời gian học, tách khỏi optimizer.
Null condition: [0,0] trong lab; nhánh dùng khi không cung cấp nhãn lớp.

Glossary (1)

MSE: Tổng bình phương sai số chia số tọa độ được chấm.

7Bài liên quan

Nhiễu, thời gian và mục tiêu flow matching Loss hồi quy: ε, v và vận tốc cần được phân biệt Backward và AdamW: biến loss thành trọng số mới CFG: học điều kiện rỗng và kết hợp hai dự đoán LoRA và DreamBooth: tham số nhỏ, mục tiêu cá nhân hóa Cầu nối suy luận: checkpoint, Euler, CFG và giải mã

8Nguồn

Flow Matching: cơ sở hồi quy trường vận tốc CFG: vì sao cần nhánh không điều kiện

9Bài lab

Huấn luyện trường vận tốc sinh ảnh hình học bằng NumPy

NumPy · mô hình thu nhỏ

Dự đoán hai đầu nội suy, chạy nguyên cấu hình rồi đọc Quan sát / Kết luận / Không chứng minh của từng khối. Đổi một hằng số mỗi lần và đối chiếu bài tập.

1 · Mục tiêu và kiến thức cần dùng

Bạn cần tensor/attention từ LLM Foundations và loss, gradient, AdamW từ LLM Training (Text). Nhắc lại: MSE trung bình bình phương sai số; backward áp quy tắc chuỗi; AdamW dùng m,v để chọn bước sửa. Ở đây ta thêm đường từ nhiễu tới ảnh, EMA và nhánh rỗng cho CFG.

Sau bài, hãy giải thích một mẫu đi từ ảnh sạch và nhiễu tới target vận tốc, loss, gradient, trọng số mới rồi lấy mẫu ra ảnh. Dự đoán trước khi chạy để tách hiểu cơ chế khỏi việc nhìn dòng PASS.

2 · Đầu vào và cấu hình

Ảnh 4×4 có nền −1 và một hàng hoặc cột sáng +1, cộng nhiễu nhỏ độ lệch chuẩn 0,03. Nhãn ngang/dọc thành [1,0]/[0,1]; [0,0] là rỗng. Một hàng dữ liệu có 16 pixel, đầu vào mạng ghép thêm một t và hai điều kiện, tổng 19 số.

MLP tanh 19→48→16 có 1.744 tham số. SEED=17, STEPS=1800, LR=0.003, BATCH=64, DROP_PROB=0.2, EMA_DECAY=0.98; LoRA hạng 2 học thêm 450 bước, sampler 8 bước với CFG_SCALE=1.5. Không tải thư viện ngoài NumPy hoặc truy cập mạng.

VAE được thay bằng ánh xạ đồng nhất và reshape, text encoder bằng bảng tra nhãn, DiT bằng MLP. Không có attention hay encoder hiểu ngôn ngữ được học. Những phép thay thế này giúp tự tính mọi gradient chứ không tái tạo kiến trúc Qwen.

3 · Theo luồng dữ liệu và các khối

Khối 1 tạo cặp ảnh/nhãn, khối 2 rút t và nhiễu e rồi tính z_t=(1−t)e+t·z và target u=z−e. Khóa quy định t=0 là nhiễu, t=1 là sạch; kiểm tra hai đầu trước khi nhìn loss.

Khối 3–5 tính forward, MSE và gradient viết tay, so bốn phần tử với sai phân ±1e−5 rồi thử một bước AdamW. Khối 6 học dài, đo trên 128 cặp ảnh–nhiễu–t cố định và tạo bản EMA trong RAM; khối 7 so dropout với đối chứng cùng batch.

Khối 8 đóng băng denoiser EMA, chỉ học A,B ở W2 để vẽ nét dày và kiểm tra gộp. Khối 9 nạp bản sao EMA, chạy Euler/CFG từ nhiễu mới và in hai ma trận. Khối 10 chỉ đếm byte, nhắc rõ kỹ thuật chưa triển khai. Bảng Tab 02 liệt kê coverage từng nhóm ô.

4 · Cách đọc kết quả thật

MSE trước/sau của cùng tập kiểm định là 2,098029 → 0,239795; EMA là 0,238390. Loss minibatch ở bước 900 là 0,220923 và bước 1800 là 0,242463, nhưng hai batch khác nhau nên không kết luận mô hình xấu đi từ cặp số ấy.

Dropout thực tế 22.946/115.200 lượt mẫu, gần p=0,2; MSE null 0,312712 so với 1,691582 khi p=0. Đây là quan sát trên một seed, đủ thấy nhánh rỗng có cơ hội học, chưa tìm p tối ưu.

LoRA 128 tham số giảm loss miền nét dày 3,201654 → 0,275528, giữ nền lệch 0 và gộp lệch cỡ 3e−15. Euler 8 bước với s=1,5 cho MSE hình mẫu 0,017335; s=1 cho 0,017168. Scale lớn hơn không tự làm lỗi nhỏ hơn.

5 · Kết luận và điều chưa chứng minh

PASS kiểm tra hai đầu nội suy, bốn phần tử gradient lệch dưới 1e−7, loss kiểm định giảm, copy EMA nạp lại đúng, LoRA giữ nền/gộp lệch dưới 1e−12 và giảm loss, sampler trả giá trị hữu hạn. Nó không so output từng chữ số với file mẫu.

Lab không đo tốc độ, peak GPU, thẩm mỹ, đa dạng ảnh tự nhiên hoặc hiểu tiếng Việt. Không triển khai VAE/DiT thật, aspect buckets, mixed precision/recompute, curriculum resolution, DreamBooth, ControlNet, student distillation hay Diffusion-DPO. Sampler ít bước vẫn dùng checkpoint chưa chưng cất.

Ảnh kiểm định mới vẫn chỉ từ hai kiểu nét đã định, nên đây là kiểm định số học trong phân phối nhỏ. Khả năng sinh cảnh, bố cục nhiều vật thể và cá nhân hóa trên ảnh thật cần thí nghiệm khác.

Kết quả mong đợiMốc mặc định: 1.744 tham số, MSE kiểm định 2,098029 → 0,239795; EMA 0,238390; LoRA 128 tham số, gốc không đổi; cuối output có PASS nêu đúng các assertion. Các chữ số cuối có thể lệch theo môi trường NumPy.

Tải training-image-end-to-end.py ↓

training-image-end-to-end.pyPYTHON

"""Lab sinh ảnh 4×4 bằng flow matching; chỉ cần NumPy, không tải dữ liệu.
Tiền đề: biết MSE, quy tắc chuỗi và AdamW từ LLM Training (Text).
Đây là mạng truyền thẳng thu nhỏ, không phải DiT hay VAE đã huấn luyện.
"""
import numpy as np

SEED = 17
STEPS = 1800
LR = 0.003
DROP_PROB = 0.2
EMA_DECAY = 0.98
LORA_RANK = 2
LORA_STEPS = 450
SAMPLE_STEPS = 8
CFG_SCALE = 1.5
BATCH = 64
HIDDEN = 48
D = 16

def section(n, title, observe, conclusion, limit):
    print("\n[%d · %s]" % (n, title))
    print("Quan sát: " + observe)
    print("Kết luận: " + conclusion)
    print("Không chứng minh: " + limit)

def templates(thick=False):
    x = -np.ones((2, 4, 4))
    x[0, 1, :] = 1
    x[1, :, 1] = 1
    if thick:
        x[0, 2, :] = 1
        x[1, :, 2] = 1
    return x.reshape(2, D)

def batch(rng, n=BATCH, thick=False):
    labels = rng.integers(0, 2, n)
    clean = templates(thick)[labels] + rng.normal(0, 0.03, (n, D))
    noise = rng.normal(size=(n, D))
    t = rng.uniform(0, 1, (n, 1))
    c = np.eye(2)[labels]
    mask = rng.random((n, 1))
    return clean, noise, t, c, mask

def interpolate(b, drop=DROP_PROB):
    clean, noise, t, c, mask = b
    cond = c * (mask >= drop)
    zt = (1-t)*noise + t*clean  # t=0: nhiễu; t=1: ảnh sạch.
    return np.concatenate([zt, t, cond], axis=1), clean-noise

def init():
    rng = np.random.default_rng(SEED)
    return dict(W1=rng.normal(0, 0.16, (D+3, HIDDEN)), b1=np.zeros(HIDDEN),
                W2=rng.normal(0, 0.1, (HIDDEN, D)), b2=np.zeros(D))

def copy(p):
    return {k: v.copy() for k, v in p.items()}

def mm(a, b):
    # Tổng tích tường minh: tránh cảnh báo BLAS giả trên một số bản NumPy macOS.
    return np.einsum("ij,jk->ik", a, b, optimize=False)

def forward(p, x):
    h = np.tanh(mm(x, p['W1']) + p['b1'])
    return mm(h, p['W2']) + p['b2'], h

def loss_grad(p, x, y):
    pred, h = forward(p, x)
    delta = 2*(pred-y)/y.size  # MSE trung bình cả batch và 16 pixel.
    dh = (mm(delta, p['W2'].T))*(1-h*h)
    g = dict(W1=mm(x.T, dh), b1=dh.sum(axis=0), W2=mm(h.T, delta), b2=delta.sum(axis=0))
    return float(np.mean((pred-y)**2)), g

def adamw(p, g, m, v, step, lr=LR):
    for k in p:
        m[k] = 0.9*m[k] + 0.1*g[k]
        v[k] = 0.999*v[k] + 0.001*g[k]*g[k]
        update = (m[k]/(1-0.9**step))/(np.sqrt(v[k]/(1-0.999**step))+1e-8)
        decay = 0.01*p[k] if k.startswith('W') else 0
        p[k] -= lr*(update+decay)

def mse(p, x, y):
    return float(np.mean((forward(p, x)[0]-y)**2))

def train(drop):
    p = init()
    ema = copy(p)
    m = {k: np.zeros_like(v) for k, v in p.items()}
    v = copy(m)
    rng = np.random.default_rng(SEED+1)
    nulls = 0
    trace = []
    for step in range(1, STEPS+1):
        b = batch(rng)
        nulls += int((b[4] < drop).sum())
        x, y = interpolate(b, drop)
        loss, g = loss_grad(p, x, y)
        adamw(p, g, m, v, step)
        for k in p:
            ema[k] = EMA_DECAY*ema[k] + (1-EMA_DECAY)*p[k]
        if step in [1, STEPS//2, STEPS]:
            trace.append((step, loss))
    return p, ema, trace, nulls

def sample(p, initial, labels, steps=SAMPLE_STEPS, scale=CFG_SCALE):
    z = initial.copy()
    c = np.eye(2)[labels]
    for j in range(steps):
        t = np.full((len(z), 1), j/steps)
        v_c = forward(p, np.concatenate([z, t, c], axis=1))[0]
        v_u = forward(p, np.concatenate([z, t, np.zeros_like(c)], axis=1))[0]
        velocity = v_u + scale*(v_c-v_u)
        z += velocity/steps
    return z

def main():
    print("LLM Training (Image) · Lab NumPy · seed=%d" % SEED)
    print("Ảnh 4×4, hai nhãn 'ngang'/'dọc'; 16 số mỗi ảnh. Không tải mô hình hay ảnh thật.")
    print("MLP = mạng truyền thẳng: [16 pixel + 1 thời gian + 2 điều kiện] → %d → 16 vận tốc." % HIDDEN)
    print("Giữ kiến thức loss/gradient/AdamW; VAE và bộ mã hóa chữ ở đây là ánh xạ cố định, không được học.")
    print("Cách đọc số: MSE là trung bình bình phương sai số; RMS là căn của trung bình bình phương độ lệch giữa hai kết quả đang so.")
    print("Mọi số Quan sát được tính trong lần chạy này; loss thấp chưa nói ảnh đẹp hay mô hình hiểu tiếng Việt.")
    b = batch(np.random.default_rng(SEED+2), 128)
    clean, noise, t, cond, mask = b
    section(1, "Cặp ảnh và điều kiện", "ảnh=%s; điều kiện=%s; tổng pixel mỗi mẫu=%d; nhãn đầu=%s" %
            (clean.shape, cond.shape, D, 'ngang' if cond[0, 0] else 'dọc'),
            "Mỗi hàng điều kiện có hai cột: [1,0] chỉ nét ngang, [0,1] chỉ nét dọc; [0,0] là điều kiện rỗng.",
            "Bảng tra nhãn không phải CLIP/VLM; lab không dạy bộ mã hóa hiểu ảnh hay tiếng Việt.")
    identity_error = float(np.max(np.abs(clean.reshape(-1, 4, 4).reshape(-1, D)-clean)))
    x, y = interpolate(b)
    endpoint = max(float(np.max(np.abs((1-0)*noise+0*clean-noise))),
                   float(np.max(np.abs((1-1)*noise+1*clean-clean))))
    section(2, "Latent và đường nội suy", "ánh xạ thay VAE lệch=%.1e; hai đầu đường lệch=%.1e; t đầu=%.6f; z_t[0,0]=%.6f; u[0,0]=%.6f" %
            (identity_error, endpoint, t[0, 0], x[0, 0], y[0, 0]),
            "e là nhiễu Gaussian chuẩn (trung bình 0, độ lệch chuẩn 1); t=0 là nhiễu, t=1 là sạch. z_t=(1-t)e+t·z có đạo hàm u=z-e; ánh xạ đồng nhất giữ nguyên pixel.",
            "Phép reshape không nén và không phải VAE thật; encoder VAE thật cần được huấn luyện trước rồi đóng băng.")
    p0 = init()
    pred, h = forward(p0, x)
    nparam = sum(v.size for v in p0.values())
    section(3, "Forward denoiser", "đầu vào=%s; tầng ẩn=%s; đầu ra=%s; tham số=%d; vận tốc đầu=%.6f" %
            (x.shape, h.shape, pred.shape, nparam, pred[0, 0]),
            "Denoiser nhận ảnh nhiễu, thời gian và điều kiện cùng lúc, trả 16 vận tốc để dịch từng pixel.",
            "Mạng tanh này không có attention; chỉ thay vai trò denoiser của ô DiT, không kiểm chứng DiT.")
    initial_loss, g = loss_grad(p0, x, y)
    section(4, "MSE và gradient", "MSE ban đầu=%.6f; MSE dự đoán zero=%.6f; chuẩn gradient W1=%.6f" %
            (initial_loss, float(np.mean(y*y)), np.linalg.norm(g['W1'])),
            "Lấy trung bình bình phương sai số trên mọi mẫu và pixel; zero chỉ là baseline cùng mục tiêu vận tốc.",
            "MSE vận tốc không phải điểm thẩm mỹ; ε-prediction và v-prediction có mục tiêu và trọng số thời gian khác.")
    errors = []
    for k in p0:
        idx = np.unravel_index(np.argmax(np.abs(g[k])), g[k].shape)
        old = p0[k][idx]
        p0[k][idx] = old+1e-5
        plus = mse(p0, x, y)
        p0[k][idx] = old-1e-5
        minus = mse(p0, x, y)
        p0[k][idx] = old
        errors.append(abs((plus-minus)/2e-5-g[k][idx]))
    q = copy(p0)
    moments = {k: np.zeros_like(v) for k, v in q.items()}
    adamw(q, g, moments, copy(moments), 1)
    max_error = max(errors)
    section(5, "Backward và AdamW", "sai phân hữu hạn lớn nhất=%.3e; MSE sau một bước=%.6f; đổi W1 lớn nhất=%.6f" %
            (max_error, mse(q, x, y), np.max(np.abs(q['W1']-p0['W1']))),
            "Kiểm tra phần tử gradient lớn nhất trong từng tensor bằng dịch ±1e-5; AdamW dùng trung bình trượt và suy giảm trọng số tách riêng.",
            "Chỉ kiểm tra bốn phần tử, không phải chứng minh mọi gradient; một bước giảm không bảo đảm mọi bước đều giảm.")
    p, ema, trace, nulls = train(DROP_PROB)
    final_loss = mse(p, x, y)
    ema_loss = mse(ema, x, y)
    snapshot = copy(ema)
    reload_error = float(np.max(np.abs(forward(snapshot, x)[0]-forward(ema, x)[0])))
    section(6, "Vòng học và EMA", "trace (bước, loss minibatch)=%s; kiểm định cố định %.6f → %.6f; EMA=%.6f; nạp lại lệch=%.1e" %
            ([(s, round(l, 6)) for s, l in trace], initial_loss, final_loss, ema_loss, reload_error),
            "So trước/sau trên cùng 128 cặp ảnh–nhiễu–t; EMA là trung bình trọng số qua các bước, không phải trung bình các ảnh đầu ra.",
            "EMA không bảo đảm loss tốt hơn; checkpoint trong RAM chỉ mô phỏng weights-only, không lưu optimizer hay RNG để tiếp tục chính xác.")
    p_no, ema_no, _, zero_nulls = train(0)
    x_null, y_null = interpolate(b, 1)
    x_cond, _ = interpolate(b, 0)
    delta = float(np.sqrt(np.mean((forward(ema, x_cond)[0]-forward(ema, x_null)[0])**2)))
    null_with = mse(ema, x_null, y_null)
    null_without = mse(ema_no, x_null, y_null)
    section(7, "Bỏ điều kiện để học CFG", "null=%d/%d (%.4f); đối chứng p=0 có %d null; MSE null có dropout=%.6f, không dropout=%.6f; RMS có/rỗng=%.6f" %
            (nulls, BATCH*STEPS, nulls/(BATCH*STEPS), zero_nulls, null_with, null_without, delta),
            "Hai lần học dùng cùng khởi tạo và các batch. Dropout cho mô hình gặp [0,0], tạo nhánh không điều kiện dùng trong CFG (hướng dẫn không cần classifier).",
            "So sánh chỉ trên một seed; p=0 vẫn trả số cho null nhưng chưa được huấn luyện trên null. Không suy ra p tối ưu.")
    frozen = copy(ema)
    adapter_rng = np.random.default_rng(SEED+4)
    adapter = dict(A=adapter_rng.normal(0, 0.05, (HIDDEN, LORA_RANK)), B=np.zeros((LORA_RANK, D)))
    am = {k: np.zeros_like(v) for k, v in adapter.items()}
    av = copy(am)
    adapt_eval = batch(np.random.default_rng(SEED+5), 128, True)
    ax, ay = interpolate(adapt_eval, 0)
    baseline_adapt = mse(frozen, ax, ay)
    for step in range(1, LORA_STEPS+1):
        lx, ly = interpolate(batch(adapter_rng, thick=True), 0)
        base_pred, lh = forward(frozen, lx)
        residual = base_pred+mm(mm(lh, adapter['A']), adapter['B'])-ly
        dl = 2*residual/ly.size
        ag = dict(A=mm(lh.T, mm(dl, adapter['B'].T)), B=mm(mm(lh, adapter['A']).T, dl))
        adamw(adapter, ag, am, av, step, lr=0.006)
    merged = copy(frozen)
    merged['W2'] += mm(adapter['A'], adapter['B'])
    after_adapt = mse(merged, ax, ay)
    unmerged = forward(frozen, ax)[0]+mm(mm(forward(frozen, ax)[1], adapter['A']), adapter['B'])
    merge_error = float(np.max(np.abs(unmerged-forward(merged, ax)[0])))
    frozen_error = max(float(np.max(np.abs(frozen[k]-ema[k]))) for k in frozen)
    section(8, "LoRA trên denoiser", "hạng=%d; adapter=%d so với %d tham số gốc; MSE nét dày %.6f → %.6f; gốc lệch=%.1e; gộp lệch=%.3e" %
            (LORA_RANK, sum(a.size for a in adapter.values()), nparam, baseline_adapt, after_adapt, frozen_error, merge_error),
            "Chỉ A,B được cập nhật; hạng r là chiều trung gian của A·B, W2 mới = W2 + A·B. Dữ liệu mới có hai hàng/cột sáng, nên đây là thích nghi miền bằng ít tham số.",
            "Không phải thí nghiệm DreamBooth trên ảnh cá nhân; LoRA là cách chọn tham số, DreamBooth là cách tổ chức mục tiêu cá nhân hóa.")
    initial_noise = np.random.default_rng(SEED+6).normal(size=(2, D))
    labels = np.array([0, 1])
    generated = sample(snapshot, initial_noise, labels)
    no_cfg = sample(snapshot, initial_noise, labels, scale=1)
    null_generated = sample(snapshot, initial_noise, labels, scale=0)
    dense = sample(snapshot, initial_noise, labels, steps=64)
    pixels = generated.reshape(2, 4, 4)  # Bộ giải mã đồng nhất.
    section(9, "Checkpoint sang Euler và CFG", "bước=%d; scale=%.2f; MSE với hình mẫu=%.6f; scale=1: %.6f; scale=0: %.6f; RMS so 64 bước=%.6f" %
            (SAMPLE_STEPS, CFG_SCALE, np.mean((generated-templates())**2), np.mean((no_cfg-templates())**2),
             np.mean((null_generated-templates())**2), np.sqrt(np.mean((generated-dense)**2))),
            "Euler cộng Δt·v với Δt=1/số bước. CFG dùng v_rỗng + scale·(v_có-v_rỗng); scale=1 trả nhánh có điều kiện. Đây là sampler ít bước chưa chưng cất.",
            "Ít bước không đồng nghĩa distillation; chưa đo tốc độ GPU, FID hay chất lượng ảnh thật; không dùng vòng token/KV cache.")
    for label, image in zip(['ngang', 'dọc'], pixels):
        print("Ảnh lấy mẫu '%s', số thô (chưa cắt về [-1,1]):" % label)
        print(np.array2string(image, precision=3, suppress_small=True))
    weights_bytes = sum(a.nbytes for a in p.values())
    section(10, "Quy mô và ranh giới phương pháp", "trọng số float64=%d byte; cùng số phần tử float32=%d, float16=%d byte (tính từ dtype)" %
            (weights_bytes, nparam*4, nparam*2),
            "Đếm trọng số không gồm activation, gradient hay AdamW. Pretraining, fine-tuning, ControlNet, distillation và Diffusion-DPO đổi dữ liệu, nhánh học hoặc loss của vòng này.",
            "Lab không thực thi mixed precision, checkpointing, đổi độ phân giải, ControlNet, distillation hay DPO; đọc bài tương ứng để thiết kế thí nghiệm thật.")
    assert endpoint < 1e-12 and identity_error == 0
    assert max_error < 1e-7
    assert np.isfinite(final_loss) and final_loss < initial_loss
    assert reload_error == 0 and frozen_error == 0 and merge_error < 1e-12
    assert after_adapt < baseline_adapt
    assert np.isfinite(generated).all()
    print("PASS chỉ xác nhận các điều kiện vừa nêu trên dữ liệu hình học, không chứng nhận chất lượng sinh ảnh hay hiệu năng.")
    print("\nPASS · Hai đầu nội suy đúng; 4 gradient khớp sai phân <1e-7; loss kiểm định giảm; EMA nạp lại đúng; LoRA giảm loss và giữ gốc; gộp lệch <1e-12; Euler hữu hạn.")

if __name__ == '__main__':
    main()

Python outputSẵn sàng.

Bài tập 1 · Giảm số bước học

Dự đoán kiểm định cuối sẽ cao hay thấp hơn khi sửa STEPS=300 thay vì 1800, giữ phần còn lại. Chạy lại và phân biệt MSE kiểm định với loss minibatch cuối.

Đối chiếu sau khi tự trả lời

Lần chạy biến thể cho MSE kiểm định 0,364621, cao hơn 0,239795 mặc định; EMA 0,364829. Loss minibatch cuối 0,278246 đo batch khác. Với ít lần cập nhật hơn, mạng chưa khớp bài toán bằng cấu hình mặc định; không suy ra cứ học lâu là luôn tốt.

Bài tập 2 · Không học nhánh rỗng

Sửa DROP_PROB=0.0. Dự đoán số null và MSE null của mô hình chính so với đối chứng p=0; sau đó đọc CFG scale=1,5 trong khối 9.

Đối chiếu sau khi tự trả lời

Số null bằng 0; MSE null cả hai là 1,691582 vì hai lần học lúc này cùng cấu hình. MSE hình mẫu khi s=1,5 là 0,156528, so với 0,017335 mặc định; s=1 vẫn 0,025766. Null chưa được học làm hiệu có/rỗng thiếu tin cậy, nhưng đây chỉ là một seed. Không dùng scalar kiểm định toàn bộ để che lỗi nhánh rỗng.

Bài tập 3 · LoRA hạng 1

Trả cấu hình mặc định rồi sửa LORA_RANK=1. Tính trước số tham số từ r·(48+16), dự đoán khả năng học hai kiểu nét dày và chạy.

Đối chiếu sau khi tự trả lời

64 tham số, thay vì 128 ở hạng 2. Lần chạy hạng 1 cho MSE thích nghi 1,330747 so với 0,275528 mặc định. Nền vẫn lệch 0 và gộp khớp cỡ 1e−15; số tham số ít hơn là thật, nhưng chất lượng không ngang nhau trên dữ liệu này.

Bài tập 4 · Hai bước Euler

Trả cấu hình mặc định rồi sửa SAMPLE_STEPS=2. Trước khi chạy, dự đoán cả MSE tới hình mẫu và RMS so bản 64 bước. Kiểm tra xem ít bước có tự là distillation không.

Đối chiếu sau khi tự trả lời

MSE hình mẫu 0,003630 thấp hơn 0,017335 của 8 bước, nhưng RMS so bản 64 bước tăng từ 0,024457 lên 0,139368. Hai tiêu chí đo hai thứ: gần hình mẫu so với gần nghiệm tham chiếu của trường đã học. Hai mẫu không đủ kết luận 2 bước tốt hơn nói chung; không có student được học nên chưa phải distillation.