NLP与大模型：让机器人理解语言

1. Transformer：一切大模型的根基

自注意力：序列建模的统一语言

理解这个公式只需要三步：

1. $QK^T$：计算每对token之间的"相似度"。如果序列有100个token，这就产生一个100×100的注意力矩阵——每个token都"看到"了所有其他token。
2. $\frac{1}{\sqrt{d_k}}$：缩放因子，防止点积值过大导致softmax饱和（梯度消失）。这是2017年原始论文最重要的工程trick之一。
3. 乘以$V$：按相似度权重对Value做加权聚合。思路简单但强大——"相似度高的信息获得更高权重"。

多头注意力：让模型同时关注不同方面

单头注意力只能关注一种模式。多头设计让模型同时从多个"子空间"提取信息——就像你同时关注零件的几何形状、配合公差和材料属性。

为什么Transformer统治了具身智能

• 长距离依赖：传统RNN处理序列要一步步传递信息，100个token以外的信息早就衰减了。Transformer一次关注全局。
• 并行计算：训练时所有token同时计算，GPU利用率远高于RNN。
• 多模态统一：文本、图像patches、机器人动作序列——都可以编码为token，用同一个Transformer处理。这就是RT-2、Octo等VLA模型的架构基础。

import torch, torch.nn as nn, torch.nn.functional as F

class MultiHeadAttention(nn.Module):
    """工业级多头注意力——这是你会在每个VLA模型中看到的模块"""
    def __init__(self, d_model=512, n_heads=8):
        super().__init__()
        assert d_model % n_heads == 0
        self.d_k = d_model // n_heads
        self.n_heads = n_heads
        self.Wq = nn.Linear(d_model, d_model)
        self.Wk = nn.Linear(d_model, d_model)
        self.Wv = nn.Linear(d_model, d_model)
        self.Wo = nn.Linear(d_model, d_model)

    def forward(self, q, k, v, mask=None):
        B = q.size(0)
        # 线性投影 + 拆成多头: (B, seq, d) → (B, n_heads, seq, d_k)
        Q = self.Wq(q).view(B, -1, self.n_heads, self.d_k).transpose(1, 2)
        K = self.Wk(k).view(B, -1, self.n_heads, self.d_k).transpose(1, 2)
        V = self.Wv(v).view(B, -1, self.n_heads, self.d_k).transpose(1, 2)
        # 缩放点积注意力
        scores = Q @ K.transpose(-2, -1) / (self.d_k ** 0.5)
        if mask is not None: scores = scores.masked_fill(mask == 0, -1e9)
        attn = F.softmax(scores, dim=-1)
        out = (attn @ V).transpose(1, 2).contiguous().view(B, -1, self.d_k * self.n_heads)
        return self.Wo(out)

2. BERT与指令理解

BERT的核心创新：双向上下文

之前的语言模型（如GPT-1）只能从左到右看文本。BERT通过Masked Language Model (MLM)实现真正的双向理解——就像你读图纸时不仅看左边的标注，还参考右边的剖视图来理解完整设计意图。

在机器人指令上微调BERT

from transformers import AutoTokenizer, AutoModelForSequenceClassification
from transformers import Trainer, TrainingArguments
import torch

# 假设我们有100条标注的机器人指令
# 格式: {"text": "把红色零件放到B区", "label": 2}
# 标签: 0=导航, 1=抓取, 2=放置, 3=拧紧, 4=检测

model_name = "bert-base-chinese"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(
    model_name, num_labels=5
)

def tokenize(examples):
    return tokenizer(examples["text"], padding="max_length",
                        truncation=True, max_length=64)

# 训练参数
training_args = TrainingArguments(
    output_dir="./results", num_train_epochs=5,
    per_device_train_batch_size=16, learning_rate=2e-5,
    evaluation_strategy="epoch", save_strategy="epoch",
    load_best_model_at_end=True,
)

# 推理：实时解析机器人指令
def predict_command(text):
    inputs = tokenizer(text, return_tensors="pt", truncation=True)
    with torch.no_grad():
        logits = model(**inputs).logits
    label = torch.argmax(logits, dim=-1).item()
    labels = ["导航", "抓取", "放置", "拧紧", "检测"]
    return labels[label]

print(predict_command("把红色零件放到B区"))  # → "放置"

3. CLIP：视觉-语言对齐

对比学习：拉近配对，推远不配对

CLIP在机器人中的杀手级应用

• 开放词汇物体识别：不需要训练"杯子"类。直接给文本"蓝色马克杯"，CLIP在图像中找到匹配区域。
• 抓取候选排序：生成100个候选抓取姿态，用CLIP判断哪个姿态最像"抓住杯子把手"。
• 任务进度判断：当前画面 vs "杯子已放入托盘"——CLIP打分，判断任务是否完成。
• 异常检测："螺丝正确拧入" vs "螺丝歪斜"——即使你从未标注过异常样本。

import torch
from transformers import CLIPProcessor, CLIPModel

model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")

def zero_shot_classify(image, candidates):
    """零样本物体识别：不给训练样本，直接用文字描述分类"""
    inputs = processor(
        text=candidates, images=image,
        return_tensors="pt", padding=True
    )
    with torch.no_grad():
        outputs = model(**inputs)
    # logits_per_image: [1, N]——每个候选文本的匹配分数
    probs = outputs.logits_per_image.softmax(dim=-1)
    for cand, p in zip(candidates, probs[0]):
        print(f"{cand:20s}: {p.item():.4f}")
    return candidates[probs[0].argmax()]

# 机器人看到桌面上的物体，用CLIP判断是什么
candidates = [
    "a red screwdriver on a table",
    "a blue coffee mug",
    "a metal wrench",
    "a black USB cable",
    "nothing, empty table",
]
# result = zero_shot_classify(camera_image, candidates)

4. LLM任务规划：从语言到动作序列

Chain-of-Thought 规划模式

让LLM输出不仅是动作序列，还包括每一步的推理过程：

# LLM规划的典型输入
指令: "把桌上红色杯子里的水倒进水槽，然后把杯子放回原处"

# LLM的Chain-of-Thought输出
思考:
  1. 我需要先定位"红色杯子"和"水槽"
  2. 杯子里面有水，需要先抓取然后移动到水槽上方
  3. 倒水操作需要一个倾斜动作
  4. 倒完水后需要回到桌面原位置

规划动作:
  ["find('red mug')",
   "move_to('red mug')",
   "grasp('red mug')",
   "find('sink')",
   "move_to('sink')",
   "pour(angle=120, duration=3s)",
   "move_to('table original position')",
   "release()"]

构建机器人可执行的JSON规划

直接让LLM输出结构化JSON，机器人控制器直接解析执行：

from openai import OpenAI

system_prompt = """你是一个机器人任务规划器。输出严格的JSON格式。
可用技能: pick(obj), place(obj,loc), move_to(loc), pour(src,tgt),
          open(drawer), close(drawer), push(obj,dir), wipe(surface)
可用物体: mug, plate, spoon, bottle, drawer, cabinet, table, sink
可用位置: left, right, center, top_shelf, bottom_shelf"""

user_instruction = "把蓝色杯子从桌上拿到水槽边，倒掉里面的水，放回桌上原处"

response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": user_instruction}
    ],
    response_format={"type": "json_object"},
    temperature=0.1,  # 低温度 = 确定性输出
)
# 输出: {"plan": [{"action":"find","target":"blue mug","location":"table"},...]}
plan = json.loads(response.choices[0].message.content)
for step in plan["plan"]:
    execute_skill(step)  # 调用机器人技能库

5. Prompt Engineering：为机器人设计指令

结构化Prompt的五个要素

Few-Shot Prompting：用示例教LLM

给LLM看几个"输入→正确输出"的例子，比写复杂规则更有效：

示例 1:
  输入: "拧紧M6螺栓"
  输出: {"tool": "torque_wrench", "target": "M6_bolt", "torque": 12.0, "unit": "Nm"}

示例 2:
  输入: "检查法兰面平整度"
  输出: {"tool": "dial_indicator", "target": "flange_A", "tolerance": 0.02, "unit": "mm"}

示例 3:
  输入: "组装轴承到轴上"
  输出: {"tool": "bearing_press", "target": "bearing_6205", "location": "shaft_end",
         "warning": "确保轴清洁无毛刺，轴承加热到80°C"}

现在处理新指令: "把端盖装到壳体上并用M4螺钉固定"
→ LLM根据示例的模式自动生成正确答案

6. RAG：让机器人随时查阅知识库

RAG的三个阶段

RAG在机器人中的典型场景

• 维护场景：机器人检测到异常振动 → 检索维修手册中的"轴承故障诊断"章节 → LLM根据手册内容生成排故步骤
• 新物体操作：遇到从未见过的工具 → 检索物品数据库中的操作说明 → 生成抓取和操作策略
• 安全合规：在危险区域作业前 → 检索安全规程文档 → LLM判断当前操作是否合规
• 多语言支持：中文指令"拧紧" → 检索英文手册 "tighten to 12 Nm" → 跨语言知识融合

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter

# 1. 构建索引：将维修手册分块向量化
with open("robot_maintenance_manual.txt") as f:
    manual = f.read()

splitter = RecursiveCharacterTextSplitter(
    chunk_size=500, chunk_overlap=100,
    separators=["\n\n", "\n", "。", "；"]
)
chunks = splitter.split_text(manual)

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma.from_texts(chunks, embeddings)

# 2. 运行时检索：机器人遇到未知情况
query = "关节3电机过热报警，温度超过85°C如何处理"
docs = vectorstore.similarity_search(query, k=3)

# 3. 增强LLM：将检索结果注入Prompt
context = "\n\n".join([d.page_content for d in docs])
augmented_prompt = f"""参考以下维修手册内容回答机器人的操作问题：
{context}

当前问题: {query}
请给出具体操作步骤，每步标注预计耗时和安全注意事项。"""

# response = llm.invoke(augmented_prompt)

7. 多模态微调：LoRA与量化

LoRA：低秩适应的核心思想

原始权重 $W$ 冻结不动。可训练的 $B$ 和 $A$ 是两个小矩阵，乘积 $BA$ 的秩远小于 $W$。对于 $d \times d$ 的矩阵，全量微调训练 $d^2$ 个参数，LoRA只需 $2 \cdot d \cdot r$（$r \ll d$）。当 $d=4096, r=16$，参数量从 16M 降到 131K——减少 99.2%。

from peft import LoraConfig, get_peft_model, TaskType
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
import torch

# 1. 加载基座模型（4-bit量化为节省显存）
model_name = "Qwen/Qwen2.5-7B-Instruct"  # 中文能力强，适合工业指令
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True,  # 4-bit量化 → 7B模型仅需 ~5GB 显存
)

# 2. 配置LoRA：只训练注意力层的投影矩阵
lora_config = LoraConfig(
    r=16,       # 低秩维度（越大容量越大，但训练越慢）
    lora_alpha=32,  # 缩放因子（通常 α = 2×r）
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.05,
    task_type=TaskType.CAUSAL_LM,
)

lora_model = get_peft_model(model, lora_config)
lora_model.print_trainable_parameters()
# 输出: trainable params: 41,943,040 || all params: 7,615,571,968 || trainable%: 0.55%

# 3. 准备机器人指令数据集（100-500条即可）
robot_instructions = [
    {"input": "检测到工件偏移0.3mm，需要修正",
     "output": '{"action":"offset_correct","axis":"XY","value":0.3,"tool":"vacuum_gripper"}'},
    {"input": "力矩超限报警，关节4",
     "output": '{"action":"emergency_stop","joint":4,"check":"collision_detect"}'},
]

# 4. 训练（单块RTX 3090即可）
training_args = TrainingArguments(
    output_dir="./robot-llm-lora", num_train_epochs=3,
    per_device_train_batch_size=4, gradient_accumulation_steps=4,
    learning_rate=2e-4, fp16=True, logging_steps=10,
    save_strategy="epoch",
)

trainer = Trainer(model=lora_model, args=training_args, train_dataset=dataset)
trainer.train()

# 5. 保存：LoRA权重只有 ~10MB，而不是完整模型的 14GB
lora_model.save_pretrained("./robot-llm-lora-final")

量化：用精度换可行性