Bài Lab tổng hợp — LLM Training (Image)

Giới thiệu bài lab

Bài Lab tổng hợp: học trường vận tốc trên ảnh hình học 4×4

Bạn sẽ chạy một chương trình NumPy tự chứa, không tải mô hình hay ảnh từ mạng. Dữ liệu là hai hình nét ngang/dọc và nhãn hai chiều; denoiser là mạng truyền thẳng 1.744 tham số. Lab giữ đúng bài toán học vận tốc từ nhiễu tới ảnh để bạn kiểm tra được từng phép tính.

Trước khi chạy, nhắc lại: MSE là trung bình bình phương sai số, gradient là đạo hàm của loss theo trọng số, còn AdamW dùng gradient cùng lịch sử của nó để sửa trọng số. Bài mới ở đây là tạo đầu vào nhiễu và đáp án vận tốc, EMA và nhánh rỗng cho CFG. Bạn cần hai khóa tiên quyết Foundations và Training (Text).

Bài lab gồm

10 khối [n · Giai đoạn], mỗi khối có Quan sát / Kết luận / Không chứng minh; bảng phía dưới chỉ rõ phần nào là phép thay thế thu nhỏ và phần nào chưa được thực thi.
Một tập kiểm định cố định 128 cặp ảnh–nhiễu–thời gian: seed 17, ảnh 4×4, đầu vào 19 số → 48 số tầng ẩn → 16 vận tốc. Hai cột điều kiện lần lượt chỉ ngang và dọc; cả hai bằng 0 nghĩa là rỗng.
Kiểm tra bốn phần tử gradient bằng sai phân hữu hạn, vòng AdamW 1.800 bước, bản sao EMA, đối chứng học có/không bỏ điều kiện và LoRA hạng 2 chỉ học 128 tham số.
Lấy mẫu Euler 8 bước từ cùng nhiễu, so CFG scale 0, 1 và 1,5, in ma trận ảnh thô; cuối cùng đếm byte trọng số theo kiểu số.

Làm xong, bạn có thể

Giải thích z_t=(1-t)e+t·z và u=z-e bằng hai đầu t=0/t=1, rồi dùng đúng dấu cộng khi lấy mẫu Euler.
Đối chiếu MSE kiểm định 2,098029 → 0,239795 ở cấu hình mặc định, tách loss từng minibatch khỏi loss của tập kiểm định giữ nguyên.
Đọc đối chứng dropout: MSE nhánh rỗng 0,312712 so với 1,691582 khi không huấn luyện trên điều kiện rỗng; kết luận trong giới hạn một seed.
Xác nhận LoRA giữ trọng số gốc và gộp adapter vẫn cho cùng đầu ra trong sai số số học; tránh đồng nhất phép này với một thí nghiệm DreamBooth.
Thay một hằng số, dự đoán, chạy lại, so với đáp án đã được kiểm chứng bằng lần chạy biến thể; nêu điều dòng PASS thực sự kiểm tra.

Phạm vi: lab huấn luyện mô hình SINH ẢNH hình học bằng flow matching, không huấn luyện encoder hiểu ảnh ViT/CLIP/VLM. MLP thay DiT, ánh xạ đồng nhất thay VAE và bảng tra nhãn thay text encoder. Không chạy ControlNet, chưng cất, Diffusion-DPO, mixed precision hay huấn luyện nhiều độ phân giải. Sampler 8 bước chưa chưng cất; PASS chỉ xác nhận các điều kiện số trong mã.

Cách chạy và đọc số

Đọc bảng ánh xạ rồi phần hướng dẫn: cột 4 của sơ đồ chủ yếu là kiến thức để thiết kế thí nghiệm thật, không nên tìm kết quả thực thi của chúng trong lab thu nhỏ.
Dự đoán hai đầu đường nội suy và dấu của u trước khi Chạy. Ở khối 2, sai lệch hai đầu phải bằng 0; nếu đổi chiều thời gian thì phải đổi cả target và sampler.
Chạy nguyên cấu hình. Đọc khối 4–6 để so loss cùng điều kiện; khối 7 đối chứng dropout; khối 8 kiểm tra gốc/gộp LoRA; khối 9 đọc 16 giá trị mỗi ảnh và so cùng nhiễu đầu vào.
Chỉ sửa một hằng số trong mỗi lần thử. Dùng các bài tập ở trang bài đọc Lab đầy đủ để giảm số bước học, bỏ dropout, giảm hạng LoRA hoặc giảm số bước Euler rồi giải thích số thay đổi.

Các giá trị tham chiếu đến từ /usr/bin/python3 với NumPy trên máy tác giả. Trình duyệt có thể lệch vài chữ số cuối do phép toán dấu phẩy động; không dùng so chuỗi số tuyệt đối làm tiêu chí đúng.

BẢNG ÁNH XẠ · THỰC THI, PHÉP THAY THẾ HAY CHỈ GIẢI THÍCH?

Giai đoạn	Ô	Bài học (bấm để mở)	Phần lab thực thi và giới hạn (`training-image-end-to-end.py`)	Cách đọc số liệu & phép kiểm chứng
1	1A, 1B, 1D	Cặp ảnh và điều kiện ↗	Tạo hai kiểu nét 4×4 và điều kiện hai cột; ảnh đồng kích thước, không có lọc/buckets hay encoder chữ thật.	128 ảnh kiểm định, mỗi ảnh 16 số; điều kiện 128×2. [0,0] là rỗng, không phải lớp thứ ba.
2	1C, 2A, 2B, 2E	Latent và đường nội suy ↗	Ánh xạ đồng nhất thay VAE, t đều, nhiễu Gaussian, z_t=(1−t)e+t·z và u=z−e.	Hai đầu lệch 0; t đầu 0,022645, trạng thái đầu 0,377643 và target đầu −1,423406. Không kiểm chứng nén VAE.
3	2D	Forward denoiser ↗	MLP tanh thay DiT, ghép pixel, t và điều kiện để dự đoán vận tốc; không có attention.	Input 128×19, hidden 128×48, output 128×16; 1.744 tham số; vận tốc đầu chưa học 0,309156.
4	3A	MSE và gradient ↗	MSE vận tốc và gradient, trung bình trên batch cùng 16 pixel; ε/v chỉ được giải thích ở bài học.	MSE đầu 2,098029; baseline zero 1,970198; chuẩn gradient W1 là 0,519508.
5	3B, 3C	Backward và AdamW ↗	Gradient viết tay; sai phân hữu hạn trên phần tử lớn nhất của mỗi tensor; AdamW giữ m,v.	Bốn gradient lệch lớn nhất 3,047e−11; sau một bước MSE 1,998582, W1 đổi lớn nhất 0,003017.
6	3D, 5A	Vòng học và EMA ↗	1.800 bước, EMA và bản sao weights-only trong RAM; không ghi file hay resume optimizer.	Cùng tập kiểm định: 2,098029→0,239795; EMA 0,238390; nạp lại EMA lệch 0.
7	2C	Bỏ điều kiện để học CFG ↗	Học có dropout p=0,2 và đối chứng p=0 với cùng khởi tạo/các batch; so nhánh rỗng.	22.946/115.200 mẫu bị bỏ điều kiện; MSE null 0,312712 so với 1,691582 không dropout, trên một seed.
8	4D	LoRA trên denoiser ↗	LoRA hạng 2 trên W2 cố định, thích nghi miền nét dày; DreamBooth chỉ được giải thích.	128 tham số adapter, MSE 3,201654→0,275528; nền lệch 0; gộp/unmerged lệch cỡ 3e−15.
9	5B, 5C, 5D	Checkpoint sang Euler và CFG ↗	Euler 8 bước với CFG, cùng nhiễu để so; reshape thay decoder. Có liên kết Qwen, không chạy Qwen.	MSE hình mẫu scale 1,5 là 0,017335; scale 1 là 0,017168; scale 0 là 0,450787. RMS so 64 bước 0,024457.
10	4A, 4B, 4C, 4E, 4F, 4G	Quy mô và ranh giới phương pháp ↗	Chỉ đếm byte trọng số và giải thích ranh giới. Không chạy mixed precision/recompute, đổi resolution, full fine-tuning, ControlNet, distillation hay DPO.	13.952 byte float64; tính cùng số phần tử float32=6.976 và float16=3.488 byte. Chưa gồm activation/gradient/m,v, không là peak GPU.

Hướng dẫn đọc output

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.

Trình chạy Lab trực tiếp · `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.

Nguồn công bố tham chiếu

Latent Diffusion ↗Tách bộ nén ảnh cố định với mạng dự đoán gỡ nhiễu Flow Matching ↗Học trường vận tốc trên đường nối nhiễu với dữ liệu DiT ↗Dùng Transformer trên các patch của latent ảnh Rectified Flow Transformer ↗Điều kiện chữ và lựa chọn lấy mẫu thời gian khi học Classifier-Free Guidance ↗Kết hợp nhánh có điều kiện và nhánh rỗng khi sinh ảnh

Danh sách bài học (18)