Mô hình Thị giác – Ngôn ngữ – Hành động¶

Mô hình Thị giác – Ngôn ngữ – Hành động (Vision-Language-Action, VLA) thống nhất việc nhìn, hiểu ngôn ngữ và hành động vào một mạng nơ-ron duy nhất. File này bao quát kiến trúc VLA, token hóa hành động, RT-2, Octo, OpenVLA, các chiến lược tiền huấn luyện, tính tổng quát, các mô hình không phụ thuộc bản thể, và các chuẩn đánh giá.

Ở các file trước, ta đã nói về cảm biến (cảm nhận thế giới) và học robot (điều khiển cơ thể). Truyền thống, những thứ này là các đường ống riêng biệt: một mô-đun cảm biến phát hiện vật thể, một mô-đun ngôn ngữ diễn giải lệnh, và một mô-đun điều khiển sinh ra hành động. Mỗi mô-đun được thiết kế, huấn luyện và gỡ lỗi độc lập.
Mô hình Thị giác – Ngôn ngữ – Hành động (VLA) gộp đường ống này thành một mạng nơ-ron duy nhất. Mô hình nhận vào ảnh (thị giác), một chỉ thị ngôn ngữ tự nhiên (ngôn ngữ), và xuất ra các lệnh động cơ (hành động). Một mô hình, từ đầu đến cuối.
Điều này đi theo cùng xu hướng hợp nhất mà ta thấy ở chương 10: cũng như các mô hình đa phương thức đã gộp hiểu thị giác và ngôn ngữ vào một kiến trúc, VLA mở rộng điều này sang hành động vật lý. Ý kiến then chốt là ngôn ngữ cung cấp một giao diện tự nhiên, linh hoạt để chỉ định tác vụ ("nhặt chiếc cốc đỏ lên và đặt lên kệ"), và các mô hình thị giác-ngôn ngữ tiền huấn luyện lớn đã hiểu cả ảnh và các chỉ thị.

Từ Thị giác – Ngôn ngữ sang Hành động¶

Nhắc lại từ chương 10 rằng Mô hình Thị giác – Ngôn ngữ (VLM) như LLaVA và Flamingo nhận một ảnh và văn bản làm đầu vào và sinh văn bản làm đầu ra. Chúng hiểu cảnh, trả lời câu hỏi và tuân theo chỉ thị, tất cả bằng ngôn ngữ.
VLA đặt câu hỏi: còn nếu đầu ra không phải là văn bản mà là hành động của robot? Thay vì sinh ra "Chiếc cốc đỏ ở bên trái bàn", mô hình sinh ra một chuỗi các lệnh động cơ di chuyển cánh tay để cầm chiếc cốc đó.
Ý kiến then chốt về kiến trúc là các hành động có thể được biểu diễn thành các token, cũng giống như từ ngữ. Nếu một VLM sinh ngôn ngữ từng token dùng dự đoán token tiếp theo, thì một VLA sinh các token hành động theo cùng cách. Transformer về cơ bản không quan tâm token đầu ra nghĩa là "cốc" hay "di chuyển cơ cấu kẹp về phía trước 2cm".
Điều này tái định hình điều khiển robot thành một bài toán mô hình hóa chuỗi, thứ mà các transformer xử lý xuất sắc (chương 7). Mô hình học ánh xạ: (quan sát ảnh, chỉ thị ngôn ngữ) \(\\to\) (chuỗi các token hành động).

Kiến trúc VLA¶

Kiến trúc VLA: ảnh camera và chỉ thị ngôn ngữ được mã hóa thành các token, xử lý bởi một backbone LLM, và giải mã thành các hành động của robot

Một VLA điển hình có ba thành phần:
- Bộ mã hóa thị giác (vision encoder): xử lý các ảnh camera thành các token thị giác. Thường là một ViT tiền huấn luyện (chương 8) hoặc bộ mã hóa SigLIP (chương 10). Ảnh được chia thành các patch, mỗi patch được embed thành một token, hoàn toàn giống như trong các transformer thị giác chuẩn.
- Backbone mô hình ngôn ngữ: một LLM tiền huấn luyện (ví dụ LLaMA, PaLM) xử lý chuỗi đan xen các token thị giác và token ngôn ngữ. Đây là nơi lập luận diễn ra: mô hình hiểu "nhặt chiếc cốc đỏ lên" bằng cách chú ý đến cả chỉ thị và các đặc trưng thị giác.
- Đầu hành động (action head): ánh xạ đầu ra của LLM sang các hành động của robot. Có thể là một MLP đơn giản ánh xạ trạng thái ẩn cuối sang các giá trị hành động liên tục, hoặc một lược đồ token hóa chuyển các hành động thành các token rời rạc được dự đoán bởi từ vựng hiện có của LLM.
Kiến trúc trông như sau:

\[\\text{Image} \\xrightarrow{\\text{ViT}} \\text{visual tokens} \\quad + \\quad \\text{Instruction} \\xrightarrow{\\text{tokeniser}} \\text{language tokens} \\quad \\xrightarrow{\\text{LLM}} \\quad \\text{action tokens}\]

Các token thị giác và token ngôn ngữ được nối (hoặc đan xen) và đưa vào backbone transformer, thứ sinh ra các token hành động theo kiểu tự hồi quy. Đây là cùng kiến trúc với một VLM (chương 10), nhưng phương thức đầu ra là hành động thay vì văn bản.

Token hóa hành động¶

Các hành động của robot là liên tục: vận tốc khớp, vị trí cơ cấu cuối, độ rộng cơ cấu kẹp. Chúng phải được chuyển thành các token rời rạc để LLM sinh ra chúng.

Token hóa hành động: các giá trị hành động liên tục được phân c bins thành các chỉ số rời rạc mà LLM sinh ra như các token

Cách tiếp cận đơn giản nhất là rời rạc hóa đều (uniform discretisation). Mỗi chiều hành động được chia thành \(N\) bins bao phủ dải các giá trị hợp lệ. Ví dụ, nếu vận tốc x nằm từ -0,1 đến 0,1 m/s và ta dùng 256 bins, mỗi bin đại diện cho \(\\frac{0,2}{256} \approx 0,8\) mm/s. Một giá trị hành động được ánh xạ đến chỉ số bin gần nhất, trở thành một token.
Với 7 chiều hành động (6 DoF + cơ cấu kẹp) và mỗi chiều 256 bins, từ vựng hành động có \(7 \\times 256 = 1792\) token. Chúng được thêm vào từ vựng văn bản hiện có của LLM. Mô hình sinh một token hành động cho mỗi chiều, theo kiểu tự hồi quy, giống hệt việc sinh từ.
Gộp hành động (action chunking) dự đoán nhiều bước thời gian tương lai cùng một lúc thay vì một hành động đơn. Nếu kích thước đoạn là \(H\), mô hình xuất ra \(H \\times d\) token (với \(d\) là số chiều hành động). Điều này rất quan trọng cho các chuyển động mượt mà, mạch lạc theo thời gian. Dự đoán từng bước một có thể sinh ra hành vi giật cục vì mỗi dự đoán là độc lập. Gộp buộc mô hình phải lập kế hoạch một quỹ đạo ngắn, nắm bắt được cấu trúc thời gian.
Các cách tiếp cận tinh vi hơn dùng token hóa học được qua VQ-VAE (chương 10). Một bộ mã hóa VQ-VAE ánh xạ một chuỗi các hành động liên tục sang một chuỗi các chỉ số sổ codebook rời rạc, và bộ giải mã tái tạo các hành động liên tục từ các chỉ số này. LLM khi đó sinh ra các chỉ số sổ codebook thay vì các giá trị chia bins đều. Điều này tương tự cách các bộ token hóa ảnh (chương 10) nén thông tin thị giác thành một code rời rạc nhỏ gọn.

Các mô hình VLA chủ chốt¶

RT-2 (Robotic Transformer 2, Google DeepMind) là VLA quy mô lớn đầu tiên. Nó lấy một VLM tiền huấn luyện (PaLM-E hoặc PaLI-X, lên đến 55B tham số) và tinh chỉnh nó trên dữ liệu minh chứng robot. Các hành động được biểu diễn thành các chuỗi ký tự: chuỗi token "1 128 91 241 5 101 127" mã hóa một hành động 7 chiều (mỗi số là một chỉ số bin).
RT-2 đã chứng minh một tính chất đáng chú ý: các năng lực nổi lên (emergent capabilities) từ backbone VLM chuyển giao sang robot học. Mô hình có thể tuân theo các chỉ thị liên quan đến những khái niệm nó chưa từng thấy trong dữ liệu robot (ví dụ "chuyển quả chuối sang nước mà tên bắt đầu bằng chữ A" đòi hỏi nhận dạng vật thể thị giác + kiến thức thế giới + hành động). Sự hiểu ngôn ngữ và lập luận thị giác của VLM "có được miễn phí".
Giới hạn của RT-2 là nó được huấn luyện trên dữ liệu từ một bản thể robot duy nhất (một cánh tay cụ thể với một cơ cấu kẹp cụ thể). Nó không tổng quát hóa sang các robot khác.
Octo (UC Berkeley) là một VLA mã nguồn mở, không phụ thuộc bản thể (embodiment-agnostic) được thiết kế để hoạt động trên nhiều nền tảng robot khác nhau. Các đổi mới then chốt là:
- Một đầu hành động khuếch tán thay vì dự đoán token tự hồi quy. Đầu hành động lấy đầu ra của transformer và sinh ra các hành động qua một quy trình khuếch tán khử nhiễu (chương 8). Cách này xử lý tự nhiên các phân bố hành động đa phương thức (xem sơ đồ dưới), nơi có nhiều cách hợp lệ để hoàn thành một tác vụ.

Các phân bố hành động đa phương thức: hồi quy lấy trung bình hai đường đi hợp lệ thành một đường không hợp lệ xuyên qua chướng ngại

- **Không gian quan sát và hành động linh hoạt**: Octo dùng các bộ token hóa riêng cho từng cấu hình robot. Nó được tiền huấn luyện trên tập dữ liệu Open X-Embodiment, chứa các minh chứng từ 22 bản thể robot khác nhau.

- **Tinh chỉnh hiệu quả**: Octo có thể tinh chỉnh cho một robot mới chỉ với ít nhất 100 minh chứng, giúp nó thiết thực cho các lab có dữ liệu hạn chế.

OpenVLA (Stanford, UC Berkeley) theo cách tiếp cận tinh chỉnh một VLM mã nguồn mở hiện có (dựa trên Llama) cho robot. Nó dùng một backbone 7B tham số, token hóa hành động đều (256 bins mỗi chiều), và huấn luyện trên dữ liệu Open X-Embodiment. Điểm mạnh của nó là sự đơn giản: kiến trúc là một VLM chuẩn với các token hành động được nối vào từ vựng, khiến nó dễ huấn luyện và triển khai với hạ tầng LLM hiện có.
\(\\pi_0\) (Physical Intelligence) đại diện cho trạng thái nghệ thuật. Nó dùng một backbone VLM tiền huấn luyện với một đầu hành động khớp luồng (flow matching, chương 8). Flow matching sinh ra các hành động bằng cách học một trường vận tốc vận chuyển nhiễu đến các phân bố hành động, tạo ra các quỹ đạo hành động mượt mà, mạch lạc theo thời gian. \(\\pi_0\) đã chứng minh tính tổng quát đáng kinh ngạc, thực hiện các tác vụ trên nhiều bản thể robot kể cả thao tác hai tay và điều khiển bàn tay khéo léo.

Các công thức tiền huấn luyện¶

Các VLA hưởng lợi rất lớn từ các backbone VLM tiền huấn luyện, vốn đã hiểu các cảnh thị giác và ngôn ngữ. Quy trình huấn luyện thường theo các giai đoạn:
1. Tiền huấn luyện VLM: huấn luyện (hoặc dùng sẵn) một mô hình thị giác-ngôn ngữ trên hàng tỷ cặp ảnh-văn bản từ internet (CLIP, SigLIP, huấn luyện kiểu LLaVA như đã nói ở chương 10).
2. Đồng huấn luyện dữ liệu robot: tinh chỉnh VLM trên một hỗn hợp dữ liệu internet và dữ liệu minh chứng robot. Dữ liệu internet ngăn quên thảm khốc (catastrophic forgetting) sự hiểu thị giác và ngôn ngữ, trong khi dữ liệu robot dạy việc sinh hành động. Tỷ lệ trộn quan trọng: quá nhiều dữ liệu robot làm suy giảm hiểu ngôn ngữ, quá ít thì không học được hành động.
3. Tinh chỉnh theo tác vụ cụ thể: tinh chỉnh tùy chọn trên các minh chứng cho một tác vụ hoặc robot cụ thể, thường dùng LoRA (chương 10) để giữ số lượng tham số có thể huấn luyện nhỏ.
Lượng dữ liệu robot nhỏ hơn nhiều so với dữ liệu internet. Một VLM có thể được tiền huấn luyện trên hàng tỷ ảnh, nhưng các tập dữ liệu robot lớn nhất (Open X-Embodiment) chỉ chứa vài triệu khung hình trên tất cả các bản thể. Sự khan hiếm dữ liệu này là lý do bắt đầu từ một VLM tiền huấn luyện là thiết yếu: các biểu diễn thị giác và ngôn ngữ chuyển giao, và chỉ có ánh xạ hành động cần học từ dữ liệu robot hạn chế.

Tính tổng quát¶

Lời hứa của các VLA là tính tổng quát (generalisation): thực hiện các tác vụ chưa thấy trong huấn luyện, với các vật thể chưa thấy, trong các môi trường chưa thấy, tuân theo các chỉ thị chưa thấy.
Các VLA tổng quát hóa theo một số trục:
- Các vật thể mới: backbone VLM nhận dạng các vật thể từ tiền huấn luyện internet. Nếu mô hình biết "cái tua vít" trông như thế nào từ ảnh web, nó có thể thao tác một cái dù không minh chứng robot nào từng có tua vít.
- Các chỉ thị mới: hiểu ngôn ngữ tổ hợp cho phép mô hình tuân theo các tổ hợp mới của các khái niệm đã biết. "Xếp khối xanh lên khối xanh lá" vẫn hoạt động dù huấn luyện chỉ cho thấy xếp các khối đỏ, vì mô hình hiểu các tính từ màu từ tiền huấn luyện ngôn ngữ.
- Các môi trường mới: ở một mức độ nào đó, các VLA chuyển giao qua các miền thị giác (các bàn khác nhau, ánh sáng, nền khác nhau) vì bộ mã hóa thị giác được tiền huấn luyện trên các ảnh web đa dạng. Nhưng điều này có giới hạn: một robot được huấn luyện trong lab có thể chật vật trong một căn bếp bừa bộn.
- Các bản thể mới: đây là trục khó nhất. Các robot khác nhau có không gian hành động khác nhau (góc khớp so với vận tốc cơ cấu cuối), các cảm biến khác nhau (camera cổ tay so với camera trên cao), và các khả năng vật lý khác nhau. Các mô hình không phụ thuộc bản thể như Octo và \(\\pi_0\) giải quyết điều này bằng các bộ token hóa linh hoạt và tiền huấn luyện trên nhiều loại robot.
Tính tổng quát được đánh giá trên các tác vụ giữ lại (held-out tasks): robot được yêu cầu thực hiện các tác vụ nó chưa từng được huấn luyện. Tỷ lệ thành công 50–80% trên các tác vụ mới được coi là kết quả mạnh, so với >90% trên các tác vụ trong phân bố. Khoảng cách này đang thu hẹp khi các mô hình được mở rộng và tập dữ liệu robot tăng lên.

Các mô hình không phụ thuộc bản thể¶

Lĩnh vực này đang hướng tới một mô hình, nhiều robot. Thay vì huấn luyện một chính sách riêng cho mỗi robot, một VLA duy nhất xử lý nhiều bản thể.
Điều này đòi hỏi giải quyết bài toán không khớp không gian hành động. Một cánh tay 7-DoF với cơ cấu kẹp hàm song song có 7 chiều hành động. Thiết lập hai tay có 14. Một con bốn chân có 12. Một robot người máy có 30+. Token hóa hành động phải đủ linh hoạt để xử lý tất cả những thứ này.
Các giải pháp gồm:
- Vector hành động có đệm (padded): dùng không gian hành động lớn nhất và đệm các không gian nhỏ hơn bằng số không.
- Đầu hành động riêng cho từng bản thể: một backbone transformer chia sẻ với các MLP nhỏ riêng cho mỗi loại robot.
- Các biểu diễn hành động đã chuẩn hóa: biểu diễn mọi hành động trong một khung chung (ví dụ vận tốc cơ cấu cuối trong khung thế giới) để các robot khác nhau sinh ra các chuyển động cơ cấu cuối tương tự thì chia sẻ cùng các token hành động.
Backbone chia sẻ học được sự hiểu thị giác và ngôn ngữ chung, cộng với các chiến lược thao tác chung (tiếp cận từ trên, căn chỉnh với vật thể, đóng cơ cấu kẹp). Các thành phần riêng cho bản thể chỉ cần dịch các chiến lược bậc cao này sang các lệnh động cơ cụ thể.

Các chuẩn và đánh giá¶

Đánh giá các VLA đặc biệt thách thức vì nó đòi hỏi các thí nghiệm robot vật lý (hoặc mô phỏng độ trung thực cao).
SIMPLER (Simulated Manipulation Policy Evaluation for Robot learning) cung cấp các môi trường mô phỏng chuẩn hóa để so sánh hiệu năng VLA mà không cần phần cứng vật lý. Nó tương quan tốt với tỷ lệ thành công trong thế giới thực và cho phép đánh giá có thể tái lập.
Đánh giá trong thế giới thực vẫn là tiêu chuẩn vàng. Quy trình điển hình:
1. Định nghĩa một tập các tác vụ với các tiêu chí thành công rõ ràng (vật thể chạm vị trí mục tiêu, chọn đúng vật thể, tác vụ hoàn thành trong giới hạn thời gian).
2. Chạy \(N\) lượt thử mỗi tác vụ (thường 10–50).
3. Báo cáo tỷ lệ thành công với các khoảng tin cậy.
4. Bao gồm các tác vụ giữ lại (chưa từng huấn luyện) để đo tính tổng quát.
Tập dữ liệu và chuẩn Open X-Embodiment tổng hợp dữ liệu robot từ 22 tổ chức trên nhiều nền tảng robot. Nó cung cấp một định dạng chuẩn hóa để chia sẻ các minh chứng và một bộ đánh giá chung cho chuyển giao liên bản thể.

Bài tập lập trình (dùng CoLab hoặc notebook)¶

Triển khai token hóa hành động: rời rạc hóa các hành động liên tục thành các bins và tái tạo chúng. Quan sát lỗi lượng tử hóa theo số lượng bin.

import jax.numpy as jnp

# Continuous action: 7 dimensions (6 DoF + gripper)
action_true = jnp.array([0.023, -0.051, 0.012, 0.1, -0.03, 0.005, 0.8])
action_min = jnp.array([-0.1, -0.1, -0.1, -0.5, -0.5, -0.5, 0.0])
action_max = jnp.array([ 0.1,  0.1,  0.1,  0.5,  0.5,  0.5, 1.0])

for n_bins in [16, 64, 256, 1024]:
    # Tokenise: map continuous value to bin index
    normalised = (action_true - action_min) / (action_max - action_min)
    tokens = jnp.clip((normalised * n_bins).astype(int), 0, n_bins - 1)

    # Detokenise: map bin index back to continuous value
    reconstructed = (tokens + 0.5) / n_bins * (action_max - action_min) + action_min

    error = jnp.linalg.norm(action_true - reconstructed)
    print(f"bins={n_bins:4d}  tokens={tokens}  error={error:.6f}")

Mô phỏng gộp hành động so với dự đoán từng bước. Sinh một quỹ đạo mượt mà, thêm nhiễu vào các dự đoán từng bước, và so sánh với dự đoán theo đoạn.

import jax
import jax.numpy as jnp
import matplotlib.pyplot as plt

# Ground truth smooth trajectory (e.g., reaching motion)
t = jnp.linspace(0, 2 * jnp.pi, 100)
gt_x = jnp.sin(t)
gt_y = 1 - jnp.cos(t)

# Single-step: each prediction has independent noise
rng = jax.random.PRNGKey(42)
noise_ss = jax.random.normal(rng, (100, 2)) * 0.05
single_step = jnp.stack([gt_x, gt_y], axis=1) + noise_ss
# Cumulative drift from single-step errors
single_step_cumulative = jnp.cumsum(noise_ss, axis=0) * 0.3 + jnp.stack([gt_x, gt_y], axis=1)

# Chunked (chunk_size=10): noise is correlated within chunks, smoother
chunk_size = 10
rng2 = jax.random.PRNGKey(7)
chunks = []
for i in range(0, 100, chunk_size):
    chunk_noise = jax.random.normal(jax.random.fold_in(rng2, i), (2,)) * 0.05
    chunk = jnp.stack([gt_x[i:i+chunk_size], gt_y[i:i+chunk_size]], axis=1)
    chunks.append(chunk + chunk_noise)
chunked = jnp.concatenate(chunks, axis=0)

plt.figure(figsize=(8, 4))
plt.plot(gt_x, gt_y, "k-", linewidth=2, label="Ground truth")
plt.plot(single_step_cumulative[:, 0], single_step_cumulative[:, 1],
         "r-", alpha=0.7, label="Single-step (drifts)")
plt.plot(chunked[:, 0], chunked[:, 1], "b-", alpha=0.7, label="Chunked (stable)")
plt.legend(); plt.axis("equal"); plt.grid(True)
plt.title("Action Chunking vs Single-Step Prediction")
plt.show()

Trực quan hóa cách phân bố hành động của một VLA có thể đa phương thức. Dùng một hỗn hợp Gaussian 2D đơn giản để chỉ ra tại sao các đầu hành động khuếch tán/khớp luồng preferable hơn hồi quy.

import jax
import jax.numpy as jnp
import matplotlib.pyplot as plt

# Two valid ways to reach around an obstacle: left or right
rng = jax.random.PRNGKey(0)
k1, k2 = jax.random.split(rng)

mode1 = jax.random.normal(k1, (200, 2)) * 0.15 + jnp.array([-1.0, 0.5])
mode2 = jax.random.normal(k2, (200, 2)) * 0.15 + jnp.array([ 1.0, 0.5])
samples = jnp.concatenate([mode1, mode2])

# Regression predicts the mean = average of modes (invalid!)
mean_pred = samples.mean(axis=0)

plt.figure(figsize=(6, 5))
plt.scatter(samples[:, 0], samples[:, 1], s=5, alpha=0.5, label="True action distribution")
plt.plot(*mean_pred, "rx", markersize=15, markeredgewidth=3, label="Regression mean (invalid!)")
plt.plot(-1, 0.5, "g^", markersize=12, label="Mode 1 (go left)")
plt.plot(1, 0.5, "b^", markersize=12, label="Mode 2 (go right)")
plt.legend(); plt.grid(True)
plt.title("Multimodal Actions: Why Regression Fails")
plt.xlabel("Action dim 1"); plt.ylabel("Action dim 2")
plt.show()