Thực hành tiếng nói

Lab tổng hợp · huấn luyện audio bằng NumPy

Chạy ba mục tiêu học trên tone tổng hợp, đọc số thật và phân biệt kiểm tra cơ chế với chất lượng tiếng nói.

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

1Định nghĩa

Bài lab huấn luyện audio thu nhỏ là một chương trình NumPy tự tạo tín hiệu để tách và quan sát ba bài toán: tái tạo sóng, đoán mã audio và nhận dạng nhãn từ audio.

Bạn dùng kiến thức causal LM và vòng huấn luyện của hai khóa tiên quyết; CE chấm xác suất nhãn đúng, gradient truyền sai số và AdamW sửa tham số. Codec RVQ tạo nhãn cho LM, còn ASR đi từ Mel trực tiếp đến nhãn khung, không nhận đầu ra của LM.

Ví dụ đời thường: ba bàn thực hành dùng chung các mẫu âm: một bàn nén rồi khôi phục, một bàn nhìn chữ giả để chọn mã, một bàn nghe tone để gắn nhãn. Kết quả của mỗi bàn cần cách chấm khác nhau.

2Luồng

Tám khối là thứ tự chương trình toy; các nhánh ASR và codec trên sơ đồ độc lập.

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

Huấn luyện tiếng nói · Ba mục tiêu và ánh xạ với lab

Bắt đầu 1A → 1B, rồi rẽ ba nhánh: codec 2A → 2B → 2C học sóng bằng loss ở 2D; TTS 3A → 3B → 3C → 3D học mã từ chữ và giọng; ASR 1C → 1D → 4A → 4B học chữ từ audio. 2E là chẩn đoán. 4C là vòng cập nhật dùng lại theo nhánh, 4D–4E và 5A–5B là kỹ thuật hoặc lựa chọn học. 5C → 5D nối hợp đồng streaming sang checkpoint và suy luận. Di chuột, Tab hoặc bấm ô để đọc năm phần.

Sơ đồ kiến trúc huấn luyện tiếng nói gồm 22 ô từ 1A đến 5D

1A1 · Dữ liệu tiếng nói chung

sóng + lời + người nói → manifest đã chia tập

1A · Audio và bản chép lời

Chọn cặp tiếng nói và bản chép lời, giữ thông tin người nói và tách tập để đo khả năng khái quát.

Nhận gì: Bản ghi tiếng nói, transcript, người nói và nguồn có quyền dùng.
Làm gì, vì sao: Ghép đúng đoạn sóng với lời được nói; chia tập theo nguồn/người nói trước khi học để tránh rò dữ liệu.
Ra gì: Audio cho codec/ASR, chữ và giọng làm điều kiện cho TTS; không phải một nhãn chung cho ba nhánh.
Ví dụ, cách đọc ô: Lab: 192 khung tone có nhãn A/B/C và hai biên độ giả giọng, tách 164 học / 28 kiểm định.
Lưu ý: Chia theo khung tone không mô phỏng người nói chưa gặp.

Đọc bài 1A · Audio và bản chép lời Lab 1 · thực thi trên dữ liệu tổng hợp: Dữ liệu sóng và nhãn

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

Tạo và biểu diễn audio
Tạo sóng cùng nhãn, tách tập, lấy năng lượng Mel.
Học ba bài toán
Codec học sóng; LM học mã; ASR học nhãn khung, với ba loss khác nhau.
Kiểm giới hạn
Kiểm gradient decoder, không nhìn tương lai và nạp lại codec; ghi phần chưa triển khai.

Mã Mermaid

flowchart TD
  step1["Tạo và biểu diễn audio"]
  step2["Học ba bài toán"]
  step3["Kiểm giới hạn"]
  step1 --> step2
  step2 --> step3

3Giải pháp

Bắt đầu bằng một dự đoán

Viết dự đoán MSE codec sẽ đổi ra sao và CE đoán đều tám mã bằng bao nhiêu. Mở hướng dẫn đầu vào trước khi chạy: nhãn A/B/C chỉ tương ứng ba tần số, speaker giả chỉ là biên độ.

Chạy và đọc bằng chứng

Chạy toàn file rồi đối chiếu tám giai đoạn với sơ đồ. Mỗi khối có Quan sát, Kết luận và Không chứng minh; đọc đủ cả ba trước khi diễn giải PASS.

Thử một thay đổi

Chọn một bài tập ở dưới, sửa đúng một hằng số, ghi lại các con số và trả lời vì sao. Đối chiếu đáp án đã chạy; không biến sự khác nhau trong một seed thành kết luận cho tiếng nói thật.

4Profiling

Mốc đúng của lần chạy mặc định
Seed 17: 192 khung, 164 học và 28 kiểm định; MSE codec 0.232382 → 0.001859, kiểm định 0.002234; [3,5] mã hoạt động trên tám mã mỗi bảng; CE của LM 2.1214 → 0.0015; CE ASR 0.9248 → 0.0082, accuracy khung 100%; gradient decoder lệch dưới 1e−6, tiền tố và nạp lại codec lệch dưới 1e−12; cuối output là PASS. Chữ số cuối có thể khác theo NumPy.
Tính so sánh
Giữ seed, dữ liệu, sample rate và cấu trúc cố định khi so một thay đổi. Không đo speedup hoặc chất lượng cảm nhận từ thời gian chạy toy; số bit là tính lý thuyế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ụ

Ba mục tiêu không phải một pipeline nối tiếp

Codec dựng lại sóng bằng MSE; LM học ID mã bằng CE; ASR dùng đặc trưng Mel và nhãn khung. ASR không chờ codec hoặc LM, còn mã codec được đóng băng trong khi LM học.

Giới hạn PASS

Giảm LM_STEPS xuống 10 vẫn có PASS nhưng CE còn 1.4325. Dòng PASS chỉ kiểm giảm loss và ngưỡng số; tự kiểm: có thể dùng nó để nói mô hình đọc tiếng Việt tự nhiên không? Không.

6Thuật ngữ

Tone tổng hợp: Sóng sin được tạo bằng chương trình; nhãn giả giúp quan sát phép tính, không đại diện tiếng nói thật.

Glossary (1)

Teacher forcing: Khi học, vị trí sau nhận mã đúng quá khứ; khi sinh, nhận mã chính mô hình dự đoán.

7Bài liên quan

2A–2B · Encoder codec và lượng tử hóa phần dư RVQ 3B · Backbone ngôn ngữ dự đoán codec token 4B · Căn chỉnh: CTC hoặc decoder cross-entropy 5C–5D · Huấn luyện nhân quả, checkpoint và cầu sang suy luận

8Nguồn

EnCodec · đối chiếu codec thực với codec tuyến tính của lab CTC · vì sao collapse không thay CTC loss

9Bài lab

Huấn luyện audio thu nhỏ: codec, LM và ASR

NumPy · tone tổng hợp · tám giai đoạn

Dự đoán trước khi chạy: codec chưa học có MSE cao hơn hay thấp hơn sau học? Với tám mã, CE đoán đều là ln 8. Chạy toàn file, đọc Quan sát → Kết luận → Không chứng minh ở từng khối. Đổi một hằng số mỗi lần rồi đối chiếu bài tập.

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.

Kết quả mong đợiSeed 17: 192 khung, 164 học và 28 kiểm định; MSE codec 0.232382 → 0.001859, kiểm định 0.002234; [3,5] mã hoạt động trên tám mã mỗi bảng; CE của LM 2.1214 → 0.0015; CE ASR 0.9248 → 0.0082, accuracy khung 100%; gradient decoder lệch dưới 1e−6, tiền tố và nạp lại codec lệch dưới 1e−12; cuối output là PASS. Chữ số cuối có thể khác theo NumPy.

Tải 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.

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.

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

Đã 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.

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

Đã 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.

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

Đã 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.

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

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.