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

Giới thiệu bài lab

Ba loss trên tone tổng hợp: đọc số trước khi kết luận

Một chương trình NumPy chạy ngay trong trình duyệt tạo 192 khung sóng sin, dùng A/B/C làm ba nhãn âm giả và hai mức biên độ làm speaker giả. Bạn cần kiến thức mảng NumPy cùng cross-entropy, gradient, AdamW từ hai khóa tiên quyết; hướng dẫn bên dưới nhắc lại các ý cần dùng.

Codec học tái tạo sóng, LM học dự đoán codec ID theo chữ giả và speaker, ASR học nhãn từ Mel. MSE là trung bình bình phương sai số sóng; CE là trung bình −ln xác suất nhãn đúng. Chúng có đơn vị và mục đích khác nhau, nên không so trị số để xếp hạng ba nhiệm vụ.

Bạn sẽ chạy gì?

Tám khối output, mỗi khối có Quan sát, Kết luận và Không chứng minh, cùng bảng ánh xạ về 22 ô ở Tab 01.
Codec tuyến tính 1728 tham số, hai bảng RVQ tám mã; LM MLP 608 tham số chỉ nhìn một mã trước; đầu ASR tuyến tính trên 12 dải Mel.
Bốn bài tập với đáp án đã chạy: giảm bước codec, giảm số bảng mã, giảm bước LM và tính collapse CTC.

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

Đọc MSE codec 0.232382 → 0.001859 và [3,5] mã hoạt động mà không nhầm số mã dùng với ID của một khung.
Đọc CE LM 2.1214 → 0.0015 và CE ASR 0.9248 → 0.0082, đồng thời giải thích vì sao accuracy khung 100% chưa phải nhận dạng lời nói thật.
Phân biệt kiểm đạo hàm decoder, kiểm tiền tố nhân quả và nạp lại codec với kiểm chất lượng giọng hoặc tốc độ phục vụ.

Phạm vi: lab huấn luyện codec, LM mã và ASR theo khung trên tone tổng hợp, không tạo tiếng nói thật. CTC chỉ có ví dụ collapse, còn SFT, LoRA, distillation, preference, sharding và recompute chỉ được giải thích. Nhạc và âm thanh không phải tiếng nói chỉ được nhắc tới, không được giảng dạy.

Cách chạy và đọc

Đọc đầu vào: 164 khung train, 28 validation, seed 17, 8 kHz và 64 mẫu/khung. Các khung đã cùng sample rate và có nhãn căn sẵn; không có resampling hoặc tìm ranh giới tự động.
Dự đoán trước: với tám mã được đoán đều, CE bằng ln 8 ≈ 2.0794. Viết xem bạn mong MSE, CE và codebook usage đổi ra sao sau học.
Chạy toàn file, đối chiếu tám khối với bảng. Mốc mặc định là MSE kiểm định 0.002234, CE LM 0.0015 và dòng PASS; chữ số cuối có thể khác theo NumPy.
Mở bài đọc Lab đầy đủ để làm một bài tập; chỉ sửa một hằng số, chạy lại và giải thích trước khi xem đáp án. LM học 10 bước vẫn PASS nhưng CE còn 1.4325: PASS không phải thước đo chất lượng.

Số bit và khung/giây là tính từ cấu hình; lab không đo độ trễ hay băng thông trên hệ phục vụ.

BẢNG ÁNH XẠ · TỪNG Ô Ở TAB 01: LAB THỰC THI GÌ VÀ CHỈ GIẢI THÍCH GÌ?

Giai đoạn	Ô	Bài học (bấm để mở)	Lab NumPy dựng gì (`training-audio-end-to-end.py`)	Cách đọc số liệu & phép kiểm chứng
1	1A–1B	Dữ liệu và ranh giới có sẵn ↗	Tạo 192 khung tone, nhãn A/B/C và hai biên độ giả người nói; 164 train / 28 validation.	Không tải giọng thật; không thực thi resampling, phân đoạn tự động hay lọc chất lượng.
2	1C–1D	Mel và đầu vào ASR ↗	STFT theo khung, 12 bộ lọc Mel, log1p và chuẩn hóa bằng train.	Thống kê train gần 0 sau chuẩn hóa. Không có encoder ngữ cảnh; đặc trưng đi thẳng vào đầu ASR.
3	2A–2E	Học codec RVQ ↗	Encoder tuyến tính 64→12, hai bảng tám mã và decoder 12→64; MSE, commitment, regression bảng mã.	MSE train 0.232382→0.001859, validation 0.002234; mã hoạt động [3,5]/8. Không có GAN hoặc semantic distillation.
4	4C	Backward và AdamW ↗	AdamW viết bằng NumPy; sai phân hữu hạn một phần tử decoder, nơi mã được giữ cố định.	Sai lệch khoảng 2.48e−16 so ngưỡng 1e−6; không kiểm đạo hàm argmin hoặc mọi tham số encoder.
5	3A–3D	LM học mã có điều kiện ↗	MLP tanh 608 tham số nhận chữ giả, speaker, vị trí bảng và một mã trước; nối phẳng, teacher forcing rồi tự sinh.	CE 2.1214→0.0015; MSE sóng sinh kiểm định 0.002234. Không có attention, ngữ cảnh nhiều khung hoặc depth/delay predictor.
6	4A–4B	ASR theo khung và collapse ↗	Đầu tuyến tính Mel→A/B/C, nhãn đã căn sẵn; thêm ví dụ gộp lặp rồi bỏ blank.	CE 0.9248→0.0082; accuracy khung 100% chỉ trên tone. Không tính CTC loss tổng đường hay WER tiếng nói.
7	4D,5C	Nhân quả và đếm mã ↗	Đổi sóng tương lai để kiểm codec không nhìn khung sau; đếm số mã và bit từ cấu hình.	Tiền tố lệch 0; 250 mã/giây, 750 bit/giây lý thuyết. Không đo latency, GPU, sharding hoặc recompute.
8	4E,5A,5B,5D	Nạp codec và nêu phần chưa dựng ↗	Sao chép tham số codec trong RAM và nạp lại; giải thích phần còn lại của checkpoint toàn hệ.	Sóng nạp lại lệch 0; m,v codec chiếm 27648 byte. Không ghi tệp hoặc resume; SFT, LoRA, distillation, preference chỉ là bài đọc.

Hướng dẫn đọc output

Mục tiêu và kiến thức cần nhớ

Bạn cần đọc được mảng NumPy và đã học causal LM, cross-entropy, gradient và AdamW trong LLM Foundations và LLM Training (Text). Nhắc lại: CE bằng −ln xác suất nhãn đúng; gradient là độ nhạy loss theo tham số; AdamW dùng trung bình gradient và bình phương gradient để sửa tham số.

Sau lab, bạn tách được ba mục tiêu: codec tái tạo waveform, LM dự đoán codec ID có điều kiện, ASR dự đoán nhãn chữ từ đặc trưng. PASS chỉ chứng minh các bất đẳng thức và ngưỡng số trong chương trình.

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

Không tải dữ liệu: chương trình tạo 192 khung, mỗi khung 64 mẫu tại 8 kHz. Nhãn A/B/C tương ứng 500/1000/1500 Hz; speaker 0/1 chỉ điều khiển biên độ, thêm pha và nhiễu ngẫu nhiên. Đây là “âm vị” giả để quan sát phép tính, không phải tiếng nói.

Chọn mỗi khung thứ bảy cho kiểm định: 164 khung train và 28 validation; đây không phải split người nói mới. Codec có encoder tuyến tính 64→12, hai codebook tám vector rồi decoder 12→64, tổng 1728 tham số. LM là MLP tanh 608 tham số nhìn điều kiện và một mã trước, không có Transformer. ASR là đầu tuyến tính trên 12 dải Mel.

CODEC_STEPS=400, LM_STEPS=350, ASR_STEPS=200, LR=0.01, BETA=0.1, seed 17. Dùng NumPy với co chỉ số einsum cho các ma trận nhỏ. Chạy trong trình duyệt hoặc /usr/bin/python3 public/labs/llm-training-audio/training-audio-end-to-end.py.

Bản đồ tám khối output

Khối 1 ↔ 1A–1B: sóng và nhãn đã cùng sample rate, ranh giới có sẵn; không thực thi resampling hay lọc chất lượng. Khối 2 ↔ 1C: STFT, bộ lọc Mel và log1p; đầu encoder ngữ cảnh 1D chỉ được thay bằng đặc trưng trực tiếp.

Khối 3 ↔ 2A–2E: encoder học latent, RVQ chọn mã rồi decoder dựng lại sóng; MSE, commitment và mã hoạt động là các chỉ số khác nhau. Khối 4 ↔ 4C: AdamW và kiểm đạo hàm decoder; không kiểm argmin hoặc tuyên bố straight-through là gradient thật.

Khối 5 ↔ 3A–3D: đóng băng codec, dùng nhãn text giả và speaker để dự đoán mã, chấm CE và tự sinh mã để dựng sóng. Khối 6 ↔ 4A–4B: ASR theo khung đã căn nhãn, kèm ví dụ collapse CTC; không huấn luyện CTC tổng đường.

Khối 7 ↔ 4D,5C: kiểm không nhìn tương lai theo khung và tính lý thuyết số mã/bit. Khối 8 ↔ 4E,5A,5B,5D: kiểm nạp lại bản sao codec trong RAM; pretraining lớn, SFT, LoRA, distillation và preference chỉ được giải thích, chưa chạy.

Đọc các con số theo đúng câu hỏi

Ở khối 3, so MSE ban đầu 0.232382 với sau học 0.001859 và kiểm định 0.002234. Các số cùng đơn vị bình phương biên độ sóng; commitment 0.004943 nằm trong không gian latent nên không so lớn nhỏ trực tiếp với MSE. Mã hoạt động [3,5] nghĩa ba và năm mã được dùng ở từng bảng, không phải hai ID của một khung.

Ở khối 5, CE ban đầu 2.1214 gần ln 8 ≈ 2.0794; sau học 0.0015 cho thấy xác suất mã đúng tăng trên dữ liệu đơn giản. CE kiểm định dùng teacher forcing, còn MSE 0.002234 của sóng sinh dùng mã tự dự đoán. Hai phép đo trả lời hai câu hỏi khác nhau.

Ở khối 6, accuracy 100% chỉ trên 28 khung tone kiểm định. Collapse giữ hai A khi có blank xen giữa: gộp lặp trước rồi bỏ blank. Khối 7 tính 125 khung/giây × hai codebook = 250 mã/giây, mỗi mã log2(8)=3 bit nên 750 bit/giây chưa có header; đây không phải băng thông được đo.

Bằng chứng và giới hạn

Các assert kiểm MSE và hai CE giảm, sai lệch gradient decoder <1e−6 và hai sai lệch nhân quả/nạp lại <1e−12. Không kiểm mọi gradient của codec, không đo thời gian, không tổng hợp giọng thật và không thực thi đầy đủ mọi ô sơ đồ.

Mỗi ví dụ TTS chỉ một khung, token trước chỉ nằm trong khung đó; không học thời lượng câu hay dừng câu. ASR có nhãn từng khung, không có decoder văn bản hay CTC forward–backward. Các phần chưa dựng được ghi rõ trong bảng và output, không dùng PASS để suy ra chất lượng Qwen.

Trình chạy Lab trực tiếp · `training-audio-end-to-end.py`

training-audio-end-to-end.pyPYTHON

"""Lab tín hiệu tổng hợp: codec RVQ, LM codec token và nhận dạng theo khung.
Chỉ cần NumPy; không tải dữ liệu hay mô hình. Đây không phải bộ tổng hợp tiếng nói.
"""
import numpy as np

SEED = 17
CODEC_STEPS = 400
LM_STEPS = 350
ASR_STEPS = 200
LR = 0.01
CODEBOOKS = 2
CODES = 8
BETA = 0.1
SAMPLE_RATE = 8000
FRAME = 64
rng = np.random.default_rng(SEED)

def mm(a, b):
    return np.einsum("ij,jk->ik", a, b, optimize=False)

def block(n, title, observation, conclusion, limit):
    print(f"\n[{n} · {title}]")
    print("Quan sát:", observation)
    print("Kết luận:", conclusion)
    print("Không chứng minh:", limit)

class AdamW:
    """m nhớ hướng trung bình; v nhớ bình phương độ lớn gradient."""
    def __init__(self, params):
        self.m = {k: np.zeros_like(v) for k, v in params.items()}
        self.v = {k: np.zeros_like(v) for k, v in params.items()}
        self.t = 0

def step(self, params, grads):
        self.t += 1
        for k in params:
            g = grads[k]
            self.m[k] = 0.9 * self.m[k] + 0.1 * g
            self.v[k] = 0.999 * self.v[k] + 0.001 * g*g
            params[k] -= LR * ((self.m[k]/(1-0.9**self.t)) /
                              (np.sqrt(self.v[k]/(1-0.999**self.t))+1e-8)
                              + 0.001 * params[k])

def ce(logits, target):
    logits = logits - logits.max(axis=1, keepdims=True)
    prob = np.exp(logits)
    prob /= prob.sum(axis=1, keepdims=True)
    loss = -np.log(prob[np.arange(len(target)), target] + 1e-12).mean()
    grad = prob.copy()
    grad[np.arange(len(target)), target] -= 1
    return float(loss), grad / len(target), prob

# Mỗi hàng là một khung của một "âm vị" giả A/B/C, không phải âm vị ngôn ngữ.
labels = np.tile(np.arange(3), 64)
speakers = np.repeat(np.arange(2), 96)
t = np.arange(FRAME) / SAMPLE_RATE
freq = np.array([500., 1000., 1500.])
phase = rng.normal(0, 0.08, len(labels))
wave = ((0.6 + 0.15*speakers[:, None]) *
        np.sin(2*np.pi*freq[labels, None]*t + phase[:, None]) +
        rng.normal(0, 0.015, (len(labels), FRAME)))
# Chia trước khi học. Tập cuối chứa cả ba nhãn và cả hai biên độ.
# Tránh chọn chỉ nhãn A khi nhãn lặp chu kỳ 3.
valid = np.arange(len(labels)) % 7 == 0
train = ~valid
x = wave[train]
print("LAB HUẤN LUYỆN AUDIO · seed", SEED)
print("Cần biết: cross-entropy chấm xác suất nhãn đúng; gradient là đạo hàm; AdamW dùng gradient để sửa tham số.")
block(1, "Dữ liệu sóng và nhãn", f"{len(wave)} khung, {train.sum()} học / {valid.sum()} kiểm định; "
      f"{SAMPLE_RATE} mẫu/giây, {FRAME} mẫu/khung, {SAMPLE_RATE/FRAME:.1f} khung/giây.",
      "Mỗi khung có nhãn A/B/C và mã người nói giả 0/1; chia tập trước khi khớp tham số.",
      "Giọng người thật, resampling hay phân đoạn tự động; dữ liệu đã cùng tần số lấy mẫu và có ranh giới sẵn.")

# Bộ lọc tam giác có tâm cách đều trên thang Mel, áp lên năng lượng FFT cửa sổ Hann.
nfft = FRAME
hz = np.fft.rfftfreq(nfft, 1/SAMPLE_RATE)
mel = lambda f: 2595*np.log10(1+f/700)
inv_mel = lambda m: 700*(10**(m/2595)-1)
edges = inv_mel(np.linspace(mel(0), mel(SAMPLE_RATE/2), 14))
filters = np.stack([np.maximum(0, np.minimum((hz-edges[i])/(edges[i+1]-edges[i]),
                  (edges[i+2]-hz)/(edges[i+2]-edges[i+1]))) for i in range(12)])
power = abs(np.fft.rfft(wave*np.hanning(FRAME), axis=1))**2
features = np.log1p(mm(power, filters.T))
mean, std = features[train].mean(0), features[train].std(0)+1e-6
features = (features-mean)/std
block(2, "Đặc trưng Mel thu nhỏ", f"Mỗi khung -> {features.shape[1]} dải; trung bình chuẩn hóa tập học "
      f"lệch 0 tối đa {abs(features[train].mean(0)).max():.2e}.",
      "Năng lượng theo dải giúp nhận dạng phân biệt cao độ; thống kê chuẩn hóa chỉ học từ tập train.",
      "Đây là log1p năng lượng Mel của khung 8 ms, không phải cấu hình log-Mel tiêu chuẩn cho tiếng nói.")

p = {'enc': rng.normal(0, .06, (FRAME, 12)),
     'dec': rng.normal(0, .06, (12, FRAME)),
     'books': rng.normal(0, .15, (CODEBOOKS, CODES, 12))}

def codec(inp, params):
    z = mm(inp, params['enc'])
    residual = z.copy()
    q = np.zeros_like(z)
    ids, residuals = [], []
    for book in params['books']:
        residuals.append(residual.copy())
        idx = ((residual[:, None, :]-book[None, :, :])**2).sum(2).argmin(1)
        chosen = book[idx]
        q += chosen
        residual -= chosen
        ids.append(idx)
    return mm(q, params['dec']), z, q, np.stack(ids, axis=1), residuals

def codec_grads(inp, params):
    recon, z, q, ids, residuals = codec(inp, params)
    err = recon-inp
    mse = float(np.mean(err**2))
    dr = 2*err/err.size
    dq = mm(dr, params['dec'].T)
    # Argmin không khả vi: straight-through truyền đạo hàm của q sang z như đồng nhất.
    dz = dq + 2*BETA*(z-q)/z.size
    db = np.zeros_like(params['books'])
    for j in range(CODEBOOKS):
        # Nhánh codebook regression dùng residual đã dừng gradient.
        np.add.at(db[j], ids[:, j], dq + 2*(params['books'][j, ids[:, j]]-residuals[j])/z.size)
    return mse, {'enc': mm(inp.T, dz), 'dec': mm(q.T, dr), 'books': db}

before = codec_grads(x, p)[0]
opt = AdamW(p)
for _ in range(CODEC_STEPS):
    _, grads = codec_grads(x, p)
    opt.step(p, grads)
recon, z, q, ids, _ = codec(wave, p)
after = np.mean((recon[train]-x)**2)
val_mse = np.mean((recon[valid]-wave[valid])**2)
usage = [int(len(np.unique(ids[train, j]))) for j in range(CODEBOOKS)]
commitment = np.mean((z[train]-q[train])**2)
block(3, "Codec RVQ học tái tạo", f"MSE học {before:.6f} -> {after:.6f}; kiểm định {val_mse:.6f}; "
      f"mã hoạt động {usage}/{CODES}; commitment {commitment:.6f}.",
      "Encoder tuyến tính học latent, RVQ cộng mã của các bảng để sửa phần dư, decoder tuyến tính dựng lại sóng. MSE là sai số bình phương trung bình.",
      "MSE thấp không bảo đảm nghe tự nhiên. Không có discriminator, loss cảm nhận hay semantic distillation; c0 ở đây không được dạy ngữ nghĩa.")

# Sai phân hữu hạn chỉ kiểm decoder với mã đã chọn cố định: không giả vờ kiểm đạo hàm argmin.
_, grads = codec_grads(x, p)
eps = 1e-5
p['dec'][0, 0] += eps
plus = codec_grads(x, p)[0]
p['dec'][0, 0] -= 2*eps
minus = codec_grads(x, p)[0]
p['dec'][0, 0] += eps
grad_error = abs((plus-minus)/(2*eps)-grads['dec'][0, 0])
block(4, "Backward và AdamW", f"Sai lệch gradient decoder với sai phân hữu hạn {grad_error:.2e}; "
      f"AdamW đã cập nhật {opt.t} bước; {sum(v.size for v in p.values())} tham số codec.",
      "Backward truyền độ nhạy của loss; AdamW giữ m và v để đổi độ nhạy thành bước sửa. Đạo hàm decoder khớp phép đo nhiễu nhỏ.",
      "Không kiểm chứng argmin khả vi: straight-through là đạo hàm thay thế, không phải đạo hàm thật của phép chọn mã.")

# LM nhỏ: text + speaker + vị trí codebook + token trước -> tanh -> phân phối mã kế.
# Token trước chỉ là quá khứ của chuỗi đã làm phẳng (frame, codebook), không thấy mã đích.
def lm_rows(token_ids):
    rows, targets, row_train = [], [], []
    for i in range(len(wave)):
        previous = CODES  # BOS riêng cho mỗi ví dụ một khung.
        for j in range(CODEBOOKS):
            rows.append(np.r_[np.eye(3)[labels[i]], np.eye(2)[speakers[i]],
                              np.eye(CODEBOOKS)[j], np.eye(CODES+1)[previous]])
            targets.append(token_ids[i, j])
            row_train.append(train[i])
            previous = token_ids[i, j]
    return np.array(rows), np.array(targets), np.array(row_train)

lm_x, lm_y, lm_train = lm_rows(ids)
lm = {'w': rng.normal(0, .1, (lm_x.shape[1], 24)), 'b': np.zeros(24),
      'out': rng.normal(0, .1, (24, CODES)), 'bias': np.zeros(CODES)}

def lm_forward(inp):
    h = np.tanh(mm(inp, lm['w'])+lm['b'])
    return h, mm(h, lm['out'])+lm['bias']

initial_ce = ce(lm_forward(lm_x[lm_train])[1], lm_y[lm_train])[0]
lm_opt = AdamW(lm)
for _ in range(LM_STEPS):
    h, logits = lm_forward(lm_x[lm_train])
    _, dl, _ = ce(logits, lm_y[lm_train])
    dh = (mm(dl, lm['out'].T))*(1-h*h)
    lm_opt.step(lm, {'w': mm(lm_x[lm_train].T, dh), 'b': dh.sum(0),
                     'out': mm(h.T, dl), 'bias': dl.sum(0)})
final_ce = ce(lm_forward(lm_x[lm_train])[1], lm_y[lm_train])[0]
val_ce = ce(lm_forward(lm_x[~lm_train])[1], lm_y[~lm_train])[0]
# Suy luận tự hồi quy: c1 nhận c0 vừa sinh, không nhận c0 đáp án.
generated = []
for label, speaker in zip(labels[valid], speakers[valid]):
    prev, codes = CODES, []
    for j in range(CODEBOOKS):
        inp = np.r_[np.eye(3)[label], np.eye(2)[speaker], np.eye(CODEBOOKS)[j], np.eye(CODES+1)[prev]][None]
        prev = int(lm_forward(inp)[1].argmax(1)[0])
        codes.append(prev)
    generated.append(codes)
generated = np.array(generated)
gen_q = sum(p['books'][j, generated[:, j]] for j in range(CODEBOOKS))
gen_wave = mm(gen_q, p['dec'])
gen_mse = np.mean((gen_wave-wave[valid])**2)
block(5, "LM dự đoán codec token", f"Cross-entropy học {initial_ce:.4f} -> {final_ce:.4f}; "
      f"kiểm định teacher-forced {val_ce:.4f}; MSE sóng sinh tự hồi quy {gen_mse:.6f}; mã đầu {generated[0].tolist()}.",
      "Text giả A/B/C và speaker làm điều kiện; codebook j và token trước giúp đoán mã kế. Loss là trung bình -ln xác suất mã đúng. Codec được đóng băng khi học LM.",
      "LM này chỉ nhớ một token trước qua MLP, không có attention hay trí nhớ qua nhiều khung. Teacher forcing không đo lỗi tích lũy khi sinh.")

asr = {'w': rng.normal(0, .1, (12, 3)), 'b': np.zeros(3)}
asr_opt = AdamW(asr)
asr_before = ce(mm(features[train], asr['w'])+asr['b'], labels[train])[0]
for _ in range(ASR_STEPS):
    _, dl, _ = ce(mm(features[train], asr['w'])+asr['b'], labels[train])
    asr_opt.step(asr, {'w': mm(features[train].T, dl), 'b': dl.sum(0)})
asr_after = ce(mm(features[train], asr['w'])+asr['b'], labels[train])[0]
acc = np.mean((mm(features[valid], asr['w'])+asr['b']).argmax(1)==labels[valid])
# Chỉ minh họa collapse CTC, không học CTC: blank=3; gộp lặp TRƯỚC khi bỏ blank.
path = [0, 0, 3, 0, 1, 1, 3, 2]
collapsed = [v for i, v in enumerate(path) if (i == 0 or v != path[i-1]) and v != 3]
block(6, "ASR theo khung và căn chỉnh", f"CE học {asr_before:.4f} -> {asr_after:.4f}; "
      f"độ đúng khung kiểm định {acc:.1%}; collapse {path} -> {collapsed}.",
      "Đầu tuyến tính nhận Mel và đoán nhãn theo khung đã căn sẵn. Ví dụ collapse giữ hai A ngăn bởi blank; CTC thật cộng xác suất mọi đường hợp lệ.",
      "Không huấn luyện CTC, encoder ngữ cảnh hay decoder văn bản; accuracy khung không phải WER của tiếng nói thật.")

# Codec độc lập từng khung: đổi tương lai không ảnh hưởng các khung trước.
changed = wave.copy()
changed[10:] += 0.4
prefix_error = np.max(abs(codec(changed, p)[0][:10]-recon[:10]))
flat_rate = SAMPLE_RATE/FRAME*CODEBOOKS
raw_bits = SAMPLE_RATE*16
code_bits = flat_rate*np.log2(CODES)
block(7, "Hợp đồng streaming và bộ nhớ", f"Đổi tương lai: lệch tiền tố {prefix_error:.1e}; "
      f"{flat_rate:.0f} mã/giây khi làm phẳng; {code_bits:.0f} bit/giây mã so với PCM16 {raw_bits} bit/giây (tính lý thuyết).",
      "Codec không nhìn khung sau nên có thể phát sau khi đủ 64 mẫu. Nhiều codebook làm tăng số quyết định nếu nối phẳng; depth predictor là cách tổ chức khác.",
      "Không đo độ trễ phần cứng, băng thông tệp hay chất lượng; chưa tính header. Không thực thi sharding/recompute hay delay/depth predictor.")

checkpoint = {k: v.copy() for k, v in p.items()}
reload_error = np.max(abs(codec(wave, checkpoint)[0]-recon))
block(8, "Checkpoint và giới hạn phương pháp", f"Nạp lại bản sao tham số codec: lệch {reload_error:.1e}; "
      f"LM có {sum(v.size for v in lm.values())} tham số; optimizer codec giữ {sum(v.nbytes for v in opt.m.values())*2} byte cho m và v.",
      "Checkpoint suy luận cần codec, LM, bảng nhãn và cấu hình. Muốn tiếp tục học phải giữ thêm trạng thái AdamW, bước và RNG. Bản sao ở đây chỉ kiểm codec, không ghi tệp.",
      "Không thực thi pretraining quy mô lớn, SFT hội thoại, LoRA, distillation hay preference; chúng được dạy ở bài đọc. Không chứng minh chất lượng Qwen3-Omni hoặc Qwen3-TTS.")
assert np.isfinite(after) and after < before
assert final_ce < initial_ce and asr_after < asr_before
assert grad_error < 1e-6 and prefix_error < 1e-12 and reload_error < 1e-12
print("\nPASS · MSE codec và CE của LM/ASR giảm; gradient decoder, tiền tố nhân quả và nạp lại codec đạt ngưỡng đã nêu.")

Python outputSẵn sàng.

Thử thay đổi và tự đối chiếu

Giảm số bước codec

Đổi CODEC_STEPS từ 400 xuống 60. Dự đoán MSE cuối trước khi chạy; so cả train, validation và mã hoạt động.

Đáp án sau khi tự thử

Đã chạy seed 17: MSE train 0.023338, validation 0.027875, mã hoạt động vẫn [3,5]. So mặc định 0.001859/0.002234: ít bước giữ sai số cao hơn trong trường hợp này; cùng số mã hoạt động không nghĩa cùng tái tạo. Nhãn codec đổi nên CE LM cũng đổi; không cô lập riêng năng lực LM.

Một codebook

Đổi CODEBOOKS từ 2 xuống 1; giữ các hằng số còn lại. Tính trước số mã và bit mỗi giây rồi chạy.

Đáp án sau khi tự thử

Đã chạy: 125 mã/giây và 375 bit/giây lý thuyết, bằng một nửa cấu hình hai bảng. MSE train 0.003881, validation 0.004295; bốn mã hoạt động. Thay cấu trúc cũng thay đường lấy số ngẫu nhiên nên đây là so hai cấu hình cụ thể, không bằng chứng Q luôn quyết định chất lượng.

LM học ít bước

Chỉ đổi LM_STEPS từ 350 xuống 10. Codec đã học có đổi không? Đọc CE và sóng sinh.

Đáp án sau khi tự thử

Đã chạy: codec giữ MSE 0.001859; CE LM còn 1.4325, kiểm định teacher-forced 1.4489 và MSE sóng sinh 0.008533. So mặc định 0.0015 và 0.002234: codec tốt chưa đủ, LM cũng phải dự đoán đúng mã. CE vẫn giảm nên PASS không bảo đảm chất lượng cao.

Thứ tự collapse CTC

Tự tính đường A,A,blank,A rồi so với cách “bỏ blank trước, gộp sau”. Không cần đổi chương trình.

Đáp án sau khi tự thử

Gộp lặp liền nhau trước: A,blank,A; bỏ blank: A,A. Bỏ blank trước tạo A,A,A rồi gộp thành A, làm mất một nhãn. Lab chỉ minh họa phép collapse, không tính CTC loss.

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

EnCodec ↗Codec RVQ và các mục tiêu tái tạo tiếng nói. Qwen3-TTS ↗Nối backbone ngôn ngữ với tokenizer và sinh tiếng nói. CTC ↗Học từ transcript khi chưa biết căn chỉnh từng khung. Qwen3-Omni ↗Cầu từ mô hình nhiều phương thức tới sinh audio streaming.

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

Ba loss trên tone tổng hợp: đọc số trước khi kết luận

Bạn sẽ chạy gì?

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

Cách chạy và đọc

Hướng dẫn đọc output

Trình chạy Lab trực tiếp · training-audio-end-to-end.py

Thử thay đổi và tự đối chiếu

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

Trình chạy Lab trực tiếp · `training-audio-end-to-end.py`