AI大模型“小龙虾”实战：OpenClaw从零入门到云端部署全攻略

# 更新驱动（预装版本可能旧）
sudo apt update && sudo apt install -y nvidia-driver-535
# 验证
nvidia-smi  # 应显示A10，显存24GB

sudo apt install -y python3-pip python3-venv
python3 -m venv openclaw_env
source openclaw_env/bin/activate
pip install --upgrade pip setuptools wheel

# PyTorch 2.1 + CUDA 12.1
pip install torch==2.1.0 torchvision==0.16.0 torchaudio==2.1.0 --index-url https://download.pytorch.org/whl/cu121

# Transformers 及微调工具
pip install transformers==4.38.2 datasets accelerate peft bitsandbytes

# 推理引擎（vLLM 0.4.2）
pip install vllm==0.4.2

# 部署服务
pip install fastapi uvicorn prometheus-client python-multipart

from datasets import load_dataset

dataset = load_dataset("YeungNLP/firefly-train-1.1M", split="train")
# 取前10万条
dataset = dataset.shuffle(seed=42).select(range(100000))

# 打印一条样本
print(dataset[0]['input'])   # 用户问题
print(dataset[0]['target'])  # 模型回答

def format_chatml(example):
    return {
        "text": f"<|im_start|>user\n{example['input']}<|im_end|>\n<|im_start|>assistant\n{example['target']}<|im_end|>"
    }

formatted_dataset = dataset.map(format_chatml)
formatted_dataset.save_to_disk("./data/firefly_10k_chatml")

from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
import torch

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True
)

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2-7B-Instruct",
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True
)
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-7B-Instruct", trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token

from peft import LoraConfig, get_peft_model

lora_config = LoraConfig(
    r=8,
    lora_alpha=16,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.1,
    bias="none",
    task_type="CAUSAL_LM"
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()  # 约 8.4M 可训练参数（仅占0.12%）

from transformers import TrainingArguments, Trainer

training_args = TrainingArguments(
    output_dir="./qwen_lora_checkpoint",
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    warmup_ratio=0.03,
    num_train_epochs=1,
    logging_steps=50,
    save_steps=500,
    fp16=True,
    dataloader_pin_memory=False,
    report_to=None
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=formatted_dataset.select(range(90000)),
    eval_dataset=formatted_dataset.select(range(90000, 100000)),
    tokenizer=tokenizer,
    data_collator=lambda data: tokenizer.pad([d['text'] for d in data], return_tensors="pt", padding=True)
)
trainer.train()

from peft import PeftModel
import torch

base_model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2-7B-Instruct",
    torch_dtype=torch.float16,
    device_map="cpu"  # 合并时用CPU避免显存爆炸
)
lora_model = PeftModel.from_pretrained(base_model, "./qwen_lora_checkpoint/checkpoint-1000")
merged_model = lora_model.merge_and_unload()
merged_model.save_pretrained("./qwen_merged_10k")
tokenizer.save_pretrained("./qwen_merged_10k")

import asyncio
from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import StreamingResponse
from vllm import AsyncLLMEngine, SamplingParams
from vllm.engine.arg_utils import AsyncEngineArgs
import json
import time
from prometheus_client import Counter, Histogram, generate_latest

app = FastAPI(title="OpenClaw Inference Service")

# ---------- 初始化vLLM引擎 ----------
engine_args = AsyncEngineArgs(
    model="./qwen_merged_10k",
    tokenizer="./qwen_merged_10k",
    tensor_parallel_size=1,
    dtype="float16",
    max_num_seqs=32,
    max_num_batched_tokens=4096,
    enable_prefix_caching=True
)
engine = AsyncLLMEngine.from_engine_args(engine_args)

# ---------- 令牌桶限流（每秒10个请求，突发20） ----------
from asyncio import Semaphore
sem = Semaphore(20)

# ---------- 指标 ----------
request_counter = Counter("openclaw_requests_total", "Total requests")
latency_hist = Histogram("openclaw_latency_seconds", "Request latency")

# ---------- 生成函数 ----------
async def generate_stream(prompt: str, max_tokens=512, temperature=0.7):
    sampling_params = SamplingParams(
        temperature=temperature,
        max_tokens=max_tokens,
        stop_token_ids=[151645]  # Qwen的<|im_end|>
    )
    request_id = f"req_{int(time.time())}"
    async for result in engine.generate(prompt, sampling_params, request_id):
        yield f"data: {json.dumps({'text': result.outputs[0].text, 'finished': result.finished}, ensure_ascii=False)}\n\n"

# ---------- API端点 ----------
@app.post("/v1/chat/completions")
async def chat_completion(request: Request):
    body = await request.json()
    prompt = body.get("prompt")
    if not prompt:
        raise HTTPException(400, "Missing 'prompt'")
    max_tokens = body.get("max_tokens", 512)
    temperature = body.get("temperature", 0.7)
    stream = body.get("stream", True)

    # 限流
    if not sem.locked():
        await sem.acquire()
        try:
            request_counter.inc()
            start = time.time()
            if stream:
                return StreamingResponse(generate_stream(prompt, max_tokens, temperature),
                                         media_type="text/event-stream")
            else:
                # 非流式：收集全部输出
                final_text = ""
                async for chunk in generate_stream(prompt, max_tokens, temperature):
                    data = json.loads(chunk.removeprefix("data: ").strip())
                    final_text += data['text']
                    if data['finished']:
                        break
                latency_hist.observe(time.time() - start)
                return {"text": final_text}
        finally:
            sem.release()
    else:
        raise HTTPException(429, "Too many requests, please retry later.")

@app.get("/metrics")
async def metrics():
    return generate_latest()

nohup uvicorn openclaw_server:app --host 0.0.0.0 --port 8080 --workers 1 > server.log 2>&1 &

from locust import HttpUser, task, between

class OpenClawUser(HttpUser):
    wait_time = between(0.5, 1.5)
    @task
    def chat(self):
        self.client.post("/v1/chat/completions", 
                         json={"prompt": "请解释什么是注意力机制", "max_tokens": 256, "stream": False})

FROM nvidia/cuda:12.1-base-ubuntu22.04
RUN apt update && apt install -y python3-pip && pip3 install vllm fastapi uvicorn
COPY ./qwen_merged_10k /model
COPY openclaw_server.py /app/
WORKDIR /app
CMD ["uvicorn", "openclaw_server:app", "--host", "0.0.0.0", "--port", "8080"]