NestedVLA: Hợp nhất kỹ năng RL bằng hypernetwork

Bạn có ba policy robot được fine-tune từ cùng một checkpoint: một policy hoạt động tốt trên MetaWorld, một trên ManiSkill và một trên CALVIN. Làm thế nào giữ được năng lực của cả ba mà không lưu ba bản đầy đủ của cùng một VLA? Lấy trung bình trọng số nghe có vẻ hợp lý, nhưng những thay đổi có ích cho một môi trường có thể phá hỏng môi trường khác.

NestedVLA dùng hypernetwork để sinh phần cập nhật action expert theo task, thay vì ép mọi kỹ năng vào một bộ trọng số trung bình. Bài này giải thích phương pháp, đối chiếu với code thật và hướng dẫn một thí nghiệm PyTorch nhỏ. Kết quả robot được dẫn từ paper; ví dụ tensor bên dưới chỉ minh họa thuật toán, không tái lập benchmark.

Nguồn chính là NestedVLA: Learning to Consolidate and Generate Skills for Vision-Language-Action Models của Guodong Du và Wanyu Lin, NeurIPS 2026, cùng bản paper v3 và repo chính thức. Phạm vi code được kiểm tra ngày 26/10/2026: repo cung cấp thuật toán lõi, chưa kèm simulator, checkpoint, dataset benchmark hay launch script thực nghiệm.

1. Ba khái niệm cần hiểu trước

VLA là Vision-Language-Action: mô hình nhận quan sát thị giác và chỉ dẫn ngôn ngữ để tạo hành động. Trong backbone π0.5 được paper sử dụng, phần VLM xử lý thông tin thị giác/ngôn ngữ, còn action expert tạo hành động liên tục. Nếu mới bắt đầu, bạn có thể đọc cách một mô hình VLA nối ảnh, ngôn ngữ và hành động trước khi đi vào không gian trọng số.

RL là quá trình cải thiện policy thông qua tương tác và reward. Trong nghiên cứu này, RL được dùng ở giai đoạn học các policy chuyên biệt. Sau đó, NestedVLA học lại cấu trúc cập nhật trọng số của chúng. Training hypernetwork là regression trên parameter delta; đây không phải một vòng RL mới trong simulator.

Hypernetwork là mạng neural tạo trọng số cho mạng khác. Một policy thông thường ánh xạ quan sát sang action. Generator của NestedVLA ánh xạ task ID và địa chỉ patch sang các giá trị cập nhật trọng số. Sau khi ráp các cập nhật vào backbone, policy được khôi phục mới nhận ảnh, trạng thái robot và instruction để điều khiển.

Ví dụ trực giác: mỗi kỹ năng là một bộ chỉnh sửa cho cùng cuốn sổ hướng dẫn. Gộp bằng averaging cố viết một bản chỉnh sửa dùng chung. NestedVLA học cách viết lại bản chỉnh sửa phù hợp khi bạn chọn kỹ năng. Nó vẫn cần task identity; không có bằng chứng rằng chỉ một instruction bất kỳ sẽ tự tạo ra kỹ năng chưa từng học.

2. Ý tưởng paper: lưu thay đổi thay vì nhân bản model

Gọi checkpoint gốc là Theta_base và checkpoint fine-tune cho task m là Theta_m. Task vector được tính bằng phép trừ theo từng tham số:

tau_m = Theta_m - Theta_base

action_m = action_base + generated_action_delta(m)
VLM_m    = VLM_base    + stored_compressed_VLM_delta(m)

Điều kiện quan trọng là mọi checkpoint phải xuất phát từ cùng base và tương thích về tên, shape, ý nghĩa tham số. Hai mô hình cùng số chiều nhưng khác phiên bản backbone không tự động có task vector hợp lệ để hợp nhất.

Paper tách task vector thành hai phần. Action-expert delta được generator học và sinh lại. VLM delta được nén và giữ riêng cho từng task. Vì vậy, câu “một hypernetwork chứa toàn bộ các kỹ năng” cần hiểu có điều kiện: hệ thống vẫn lưu compressed VLM residual, mask và các thành phần riêng theo task. Nó không loại bỏ toàn bộ thông tin phụ thuộc task.

Nguồn: Figure 1, paper NestedVLA. Sơ đồ phân biệt trọng số được gộp với cập nhật được sinh theo task.

Động cơ tách VLM rất thực tế. Trong sanity test ở Appendix F, tác giả giữ action expert thật của từng task nhưng merge VLM; CALVIN vẫn rơi về 0% hoàn thành chuỗi với các baseline được thử. Giữ action expert tốt chưa đủ nếu phần biểu diễn đầu vào đã bị thay đổi sai.

3. Nén delta và chia thành patch

Delta dày đặc của một mô hình hàng tỷ tham số là target quá lớn. NestedVLA giữ các phần tử có độ lớn cao thông qua top-K mask rồi áp dụng rescale. Trong cấu hình chính của paper, keep ratio là 10% theo module và hệ số rescale là 1.1.

compressed_delta = alpha * delta * mask
mask[i] = 1 nếu phần tử i thuộc nhóm được giữ
mask[i] = 0 ở các vị trí còn lại

Mask được tính trước và đóng băng. Generator không phải khám phá đồng thời vị trí nào cần giữ và giá trị ở vị trí đó. Khi inference, đầu ra bị nhân mask lần nữa; giá trị ngoài support không được đưa vào action expert.

Tiếp theo, mỗi tensor trọng số được xem như ma trận rồi chia thành những ô vuông. Paper dùng patch 256 × 256. Tensor quá nhỏ hoặc cạnh không chia hết sẽ được padding; khi decode, phần padding bị cắt bỏ để khôi phục shape ban đầu.

Mỗi patch có địa chỉ gồm bốn trường: loại tham số, chỉ số transformer layer, hàng patch và cột patch. Đây là patch của trọng số, không phải patch ảnh từ camera. Một tensor attention và một tensor MLP có thể có cùng tọa độ ô nhưng vẫn được phân biệt bằng loại tham số và layer.

Code công khai có DeltaTokenizer.encode() và decode() để làm bước này. Hàm patch_scales() tính RMS cho từng patch, có ngưỡng nhỏ để tránh chia cho zero; standardize() đưa target về thang đo dễ học hơn. Khi sinh delta, destandardize() trả nó về đơn vị ban đầu. Cần giữ scales theo từng task, thay vì dùng nhầm scales của task đầu tiên.

4. Kiến trúc paper và những gì repo thực sự có

Trong paper, task ID đi qua embedding và một encoder Conv2D nhỏ, sau đó global average pooling tạo task feature. Feature này được broadcast đến mọi patch rồi nối với embedding địa chỉ patch. Một shared fully connected trunk, đường LoRA riêng theo task và output head riêng theo task tạo giá trị cho từng ô trọng số.

Nguồn: Figure 3, paper NestedVLA. Đây là kiến trúc nghiên cứu; bản core release đơn giản hơn.

Không nên mặc định code public trùng hoàn toàn với Figure 3. Đối chiếu model.py, compression.py và paper cho thấy:

Những khác biệt này đủ lớn để không gắn kết quả 66.7% trực tiếp cho ví dụ README. Core release hữu ích để hiểu API và xây dựng prototype, nhưng tái lập paper cần bổ sung kiến trúc, pipeline và cấu hình còn thiếu.

5. Cài đặt môi trường nhỏ trước

Theo pyproject.toml, package yêu cầu Python từ 3.10 và PyTorch từ 2.0. Tạo môi trường riêng; nếu dùng GPU, cài bản PyTorch phù hợp CUDA theo môi trường của bạn. CPU đủ để thử các tensor nhỏ trong bài.

Các lệnh sau dành cho người đọc chạy trên máy thực hành. Cài trực tiếp source archive giúp tránh cần thao tác Git:

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install torch
python -m pip install "https://github.com/WanyuGroup/NeurIPS2026-NestedVLA/archive/refs/heads/main.zip"
python -c "from nested_vla import DeltaTokenizer, NestedVLAGenerator; print('Import OK')"

Nhánh main có thể thay đổi sau ngày viết bài. Khi làm thí nghiệm nghiêm túc, hãy ghi lại revision nguồn và phiên bản dependency thực tế; README hiện tại không phải bảo đảm tương thích vĩnh viễn.

Đừng bắt đầu bằng patch 256 trên tensor vài chục phần tử: padding sẽ chiếm phần lớn target. Ví dụ tiếp theo chọn patch 4 và các ma trận chia hết cho 4 để tập trung vào quy trình encode, mask, training và decode.

6. Training hypernetwork bằng API PyTorch

Chạy toàn bộ khối Python dưới đây trong cùng một phiên. Dữ liệu là ba task vector tổng hợp, không phải trajectory robot. out_of_mask_weight=0.0 tắt penalty bên ngoài mask để minh họa mục tiêu chỉ học các vị trí được giữ. Loss của API vẫn lấy trung bình trên toàn bộ tensor, khác cách chuẩn hóa theo số vị trí được giữ trong công thức paper.

import torch
from nested_vla import (
    DeltaTokenizer, NestedVLAGenerator, make_topk_mask,
)

torch.manual_seed(7)
torch.set_num_threads(1)

# Ba task có cùng tên, shape và thứ tự tham số.
base = {
    "layers.0.attn.weight": torch.randn(8, 8),
    "layers.1.mlp.weight": torch.randn(8, 12),
}
deltas = [
    {name: 0.02 * torch.randn_like(value)
     for name, value in base.items()}
    for _ in range(3)
]

tokenizer = DeltaTokenizer.from_state_dict(deltas[0], patch_size=4)
encoded = [tokenizer.encode(delta) for delta in deltas]
for name, value in tokenizer.decode(encoded[0]).items():
    assert torch.equal(value, deltas[0][name])

masks = torch.stack([
    make_topk_mask(patches, keep_ratio=0.25)
    for patches in encoded
])
scales = torch.stack([
    tokenizer.patch_scales(patches) for patches in encoded
])
targets = torch.stack([
    tokenizer.standardize(patches, scale)
    for patches, scale in zip(encoded, scales)
])

model = NestedVLAGenerator(
    tokenizer.metadata, num_tasks=3,
    task_dim=16, slot_dim=8, hidden_dim=64,
    grid_channels=4, grid_size=4,
    out_of_mask_weight=0.0,
)
optimizer = torch.optim.AdamW(model.parameters(), lr=3e-3)
task_ids = torch.arange(3, dtype=torch.long)

model.train()
for step in range(500):
    optimizer.zero_grad(set_to_none=True)
    prediction = model(task_ids)
    loss = model.masked_loss(prediction, targets, masks)
    loss.backward()
    optimizer.step()
    if step % 100 == 0:
        print(step, float(loss.detach()))

model.eval()
generated = model.generate_delta(
    task_id=1, tokenizer=tokenizer,
    mask=masks[1], scales=scales[1],
)
reference = tokenizer.decode(encoded[1] * masks[1])
error = torch.sqrt(torch.stack([
    (generated[name] - reference[name]).square().mean()
    for name in reference
]).mean())
print("Sparse-target RMSE:", float(error))

# Luôn cộng vào base nguyên bản, không cộng dồn vào policy trước.
materialized = {
    name: base[name] + generated[name] for name in base
}
for name in base:
    assert materialized[name].shape == base[name].shape
print("Shapes:", {name: tuple(x.shape)
                  for name, x in materialized.items()})

Mục tiêu đầu tiên là import thành công, tokenizer round-trip chính xác, loss hữu hạn và output có shape đúng. Loss thường giảm khi tối ưu bài toán nhỏ, nhưng bài này không đưa ra log chạy hay ngưỡng hội tụ đã đo. Kết quả cụ thể phụ thuộc phiên bản và tối ưu; không suy ra robot sẽ thành công từ một giá trị RMSE nhỏ.

Chọn keep ratio 0.25 trong demo để mỗi patch 4 × 4 giữ bốn vị trí. Đây là thông số giảng giải, không phải cấu hình 10% của paper. Target so sánh là delta đã mask; so với dense delta sẽ trộn lẫn lỗi nén và lỗi generator.

7. Đưa checkpoint thật vào quy trình

Khi đã hiểu demo, thay phần tạo delta ngẫu nhiên bằng phép trừ giữa state dict fine-tune và base, chỉ trên các khóa action expert do framework của bạn xác định. Trước phép trừ, kiểm tra tên và shape; chuyển các tensor cần thiết về float32 để tránh mất độ chính xác khi lấy hiệu hai giá trị gần nhau.

Không lọc action expert bằng một chuỗi tên đoán mò. Hãy xem cấu trúc model thực tế, vì tên module thay đổi giữa framework. Loại bỏ buffer không phải trọng số cần học, giữ thứ tự khóa ổn định và xác nhận các checkpoint cùng base bằng metadata của thí nghiệm.

VLM residual là nhánh riêng cần trích xuất, nén và lưu. Core release không cung cấp một loader đầy đủ cho π0.5 hoặc bước tự tìm các khóa VLM/action expert. Nếu bỏ nhánh VLM rồi gọi đó là tái lập NestedVLA, bạn đang đánh giá một hệ thống khác.

Để nối phần RL vào thí nghiệm, tham khảo quy trình training VLA bằng RL. Trong paper, các policy nguồn được fine-tune độc lập bằng FlowSDE, và closed-loop evaluation dùng RLinf. Consolidation không cần pooling lại dữ liệu RL gốc, nhưng vẫn cần các checkpoint đã học tốt và môi trường đánh giá để kiểm tra hành vi.

Cấu hình generator trong nghiên cứu gồm 6,000 bước, batch size 3, learning rate nền 3e-4, warmup 600 bước và cosine tail 1,500 bước. Task weights là 1.0, 0.4, 1.0 tương ứng MetaWorld, ManiSkill, CALVIN. Paper báo cáo một A6000 48 GB, khoảng 10 giờ cho một run và peak GPU memory 42.6 GB. Đây là chi phí consolidation, không phải tổng chi phí thu thập policy bằng RL.

8. Inference: materialize policy rồi mới điều khiển

Khi chọn task, query generator một lần, khôi phục action delta bằng scales và mask tương ứng, lấy compressed VLM residual cùng task rồi cộng cả hai vào base nguyên bản. Sau đó chạy forward của policy với preprocessing, tokenizer ngôn ngữ, normalization trạng thái và action decoder đúng framework.

Không cần sinh hàng trăm triệu trọng số lại ở mỗi timestep nếu task chưa đổi. Có thể cache policy đã materialize, nhưng phải tính chi phí bộ nhớ thực tế. Khi chuyển task, dựng lại từ base hoặc dùng bản sao sạch; cộng delta B lên trọng số đã chứa delta A sẽ tạo một policy ngoài thiết kế.

Nếu sử dụng alpha, quy định rõ target đã được nhân alpha hay chưa. generate_delta() hiện chỉ destandardize và nhân mask, không tự nhân 1.1. Nhân hệ số cả trước training lẫn sau decode sẽ scale hai lần. Demo giữ alpha bằng 1 để tránh đánh đồng API tối giản với recipe của paper.

Đối với triển khai, các bước kiểm tra policy trước khi deploy vẫn cần thiết. Việc khôi phục đúng shape không xác nhận camera frame, đơn vị action hay giới hạn actuator. Hãy kiểm tra closed-loop trong simulator phù hợp trước khi xem xét robot thật.

9. Kết quả: đọc cả mức tăng và khoảng cách còn lại

Bảng dưới trích các hàng tiêu biểu từ Table 1 của paper v3. Các giá trị là phần trăm; storage được chuẩn hóa theo một checkpoint đầy đủ.

Mức tăng 41.1 là điểm phần trăm so với Free-Merging, không phải “nhanh hơn 41.1%” hay cải thiện latency. NestedVLA còn kém bộ checkpoint độc lập 13.8 điểm trung bình. ManiSkill chỉ cách 0.9 điểm, nhưng MetaWorld vẫn cách 34.4 điểm.

Hai benchmark đầu dùng success_once: đạt mục tiêu tại một thời điểm trong rollout được tính thành công. CALVIN dùng success_at_end cho toàn bộ chuỗi năm subtask. Trung bình ba cột là chỉ số tổng hợp của paper, không phải một success rate duy nhất trên mọi trajectory có cùng định nghĩa. Paper đánh giá ba seeds, độ lệch chuẩn điển hình khoảng 2.7%.

Table 3 giúp xác định nút thắt. Ngay cả delta thật sau top-K 10%, không cần generator, cũng chỉ đạt 48.4% trên MetaWorld. Nâng keep ratio lên 20% đưa mức ideal lên 60.2%. Vì vậy, tăng kích thước hypernetwork chưa chắc giải quyết được thông tin đã mất ở bước nén.

Ablation còn cho thấy đường LoRA không mặc nhiên có lợi: biến thể bỏ LoRA đạt loss thấp hơn ở mốc 2,000 bước. Đây là kết quả regression trong một cấu hình cụ thể, không đủ để kết luận mọi VLA nên bỏ LoRA. Tương tự, storage 1.5× là số liệu cho ba policy; khi thêm task, residual, mask và thành phần generator riêng vẫn tăng.

10. Một lộ trình thực hành có thể kiểm chứng

Hãy làm theo ba tầng. Đầu tiên, dùng tensor nhỏ để kiểm tra encode/decode, loss và task-specific reconstruction. Tiếp theo, với checkpoint thật, đánh giá riêng compressed ground-truth delta trước khi training generator; bước này đo trần chất lượng do sparsity quyết định. Cuối cùng, thay ground-truth bằng generated delta và chạy cùng rollout seeds, cùng normalization, cùng success metric.

Nếu tầng thứ hai đã thất bại, sửa ngân sách nén trước khi tăng số bước train. Nếu tầng thứ hai tốt nhưng tầng thứ ba kém, kiểm tra mask, scales, thứ tự khóa và khả năng của generator. Nếu weight reconstruction tốt nhưng rollout kém, quay lại preprocessing, VLM residual và độ nhạy của action expert.

NestedVLA đáng chú ý vì biến việc hợp nhất kỹ năng thành một bài toán sinh cập nhật có điều kiện. Giá trị thực tế của nó nằm ở khả năng tái sử dụng các policy đã học độc lập; mức sẵn sàng triển khai phải được xác định bằng code, checkpoint và closed-loop evaluation thực tế, không chỉ bằng sơ đồ kiến trúc.

Bài viết liên quan

• OpenVLA: hiểu kiến trúc Vision-Language-Action
• SimpleVLA-RL: quy trình training
• VLA và LeRobot: PEFT, kiểm tra và deploy policy