GO-1 完整模型部署详细教程

基于你的服务器配置（RTX 4090，24GB 显存）和已成功运行 GO-1 Air 的经验，以下是完整 GO-1 模型的部署教程。这个教程会解决你之前在下载和运行过程中遇到的各种问题。

一、环境准备与验证

1. 激活环境并验证基础配置

conda activate go1_env
cd ~/AgiBot-World

# 验证 GPU 和 CUDA
echo "GPU 信息:"
nvidia-smi --query-gpu=name,memory.total,memory.used --format=csv
echo "CUDA 版本:"
nvcc --version 2>/dev/null || echo "CUDA 未在 PATH 中"

# 验证 PyTorch
python -c "import torch; print(f'PyTorch 版本: {torch.__version__}'); print(f'CUDA 可用: {torch.cuda.is_available()}'); print(f'CUDA 版本: {torch.version.cuda}')"

2. 升级关键依赖

# 确保 flash-attn 版本兼容
pip install --no-build-isolation flash-attn==2.4.2

# 安装可视化依赖
pip install matplotlib tqdm opencv-python==4.8.0.76 rerun-sdk

# 确保 json_numpy 已安装
pip install json-numpy

二、下载完整 GO-1 模型

由于你之前在下载时遇到了各种问题，这里提供几种可靠的下载方法：

方法 1：使用镜像 + token（推荐）

# 创建模型目录
mkdir -p models/GO-1

# 设置你的 Hugging Face token（替换为你的实际 token）
HF_TOKEN="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"

# 使用 hf-mirror 进行加速下载
cd models/GO-1

# 下载关键文件
echo "正在下载配置文件..."
curl -L -H "Authorization: Bearer $HF_TOKEN" \
  https://hf-mirror.com/agibot-world/GO-1/resolve/main/config.json \
  -o config.json

echo "正在下载模型文件（这可能需要一些时间）..."
curl -L -H "Authorization: Bearer $HF_TOKEN" \
  https://hf-mirror.com/agibot-world/GO-1/resolve/main/model-00001-of-00002.safetensors \
  -o model-00001-of-00002.safetensors

curl -L -H "Authorization: Bearer $HF_TOKEN" \
  https://hf-mirror.com/agibot-world/GO-1/resolve/main/model-00002-of-00002.safetensors \
  -o model-00002-of-00002.safetensors

echo "正在下载其他必要文件..."
curl -L -H "Authorization: Bearer $HF_TOKEN" \
  https://hf-mirror.com/agibot-world/GO-1/resolve/main/model.safetensors.index.json \
  -o model.safetensors.index.json

curl -L -H "Authorization: Bearer $HF_TOKEN" \
  https://hf-mirror.com/agibot-world/GO-1/resolve/main/special_tokens_map.json \
  -o special_tokens_map.json

curl -L -H "Authorization: Bearer $HF_TOKEN" \
  https://hf-mirror.com/agibot-world/GO-1/resolve/main/tokenization_internlm2.py \
  -o tokenization_internlm2.py

curl -L -H "Authorization: Bearer $HF_TOKEN" \
  https://hf-mirror.com/agibot-world/GO-1/resolve/main/tokenizer.json \
  -o tokenizer.json

curl -L -H "Authorization: Bearer $HF_TOKEN" \
  https://hf-mirror.com/agibot-world/GO-1/resolve/main/tokenizer_config.json \
  -o tokenizer_config.json

curl -L -H "Authorization: Bearer $HF_TOKEN" \
  https://hf-mirror.com/agibot-world/GO-1/resolve/main/dataset_stats.json \
  -o dataset_stats.json

echo "✅ 完整 GO-1 模型下载完成"

方法 2：使用 wget 重试机制

如果方法 1 不稳定，创建一个带重试功能的下载脚本：

cat > download_go1_model.sh << 'EOF'
#!/bin/bash
# 重试下载 GO-1 模型
set -e

HF_TOKEN="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"
MODEL_DIR="models/GO-1"
MAX_RETRIES=5
RETRY_DELAY=10

mkdir -p $MODEL_DIR
cd $MODEL_DIR

files=(
  "config.json"
  "model-00001-of-00002.safetensors"
  "model-00002-of-00002.safetensors"
  "model.safetensors.index.json"
  "special_tokens_map.json"
  "tokenization_internlm2.py"
  "tokenizer.json"
  "tokenizer_config.json"
  "dataset_stats.json"
)

base_url="https://hf-mirror.com/agibot-world/GO-1/resolve/main/"

echo "🚀 开始下载 GO-1 模型文件..."

for file in "${files[@]}"; do
  echo "📥 下载: $file"
  retry_count=0
  
  while [ $retry_count -lt $MAX_RETRIES ]; do
    if curl -L -H "Authorization: Bearer $HF_TOKEN" \
      "${base_url}${file}" \
      -o "$file" --progress-bar; then
      echo "✅ $file 下载成功"
      break
    else
      retry_count=$((retry_count+1))
      echo "❌ 下载失败，重试 $retry_count/$MAX_RETRIES..."
      sleep $RETRY_DELAY
    fi
    
    if [ $retry_count -eq $MAX_RETRIES ]; then
      echo "❌ $file 下载失败超过最大重试次数"
      exit 1
    fi
  done
done

echo "🎉 所有文件下载成功！"
EOF

chmod +x download_go1_model.sh
./download_go1_model.sh

三、验证模型完整性

# 检查文件是否完整
cd ~/AgiBot-World/models/GO-1
echo "正在验证文件完整性..."

# 检查关键文件是否存在
required_files=(
  "config.json"
  "model-00001-of-00002.safetensors"
  "model-00002-of-00002.safetensors"
  "model.safetensors.index.json"
  "dataset_stats.json"
)

missing_files=0
for file in "${required_files[@]}"; do
  if [ -f "$file" ]; then
    echo "✅ $file 存在 - 大小: $(du -h $file | cut -f1)"
  else
    echo "❌ $file 不存在"
    missing_files=$((missing_files+1))
  fi
done

if [ $missing_files -eq 0 ]; then
  echo "✅ 所有关键文件已验证，GO-1 模型准备就绪"
else
  echo "❌ 有 $missing_files 个关键文件缺失，请重新下载"
  exit 1
fi

四、创建 GO-1 专用推理脚本

cat > go1_inference.py << 'EOF'
#!/usr/bin/env python
import numpy as np
import os
import sys
import torch
import time
import json
import cv2
from tqdm import tqdm
from evaluate.deploy import GO1Infer
import matplotlib.pyplot as plt

def check_environment():
    """检查环境配置"""
    print("🔍 环境检查...")
    
    # 检查 GPU
    if torch.cuda.is_available():
        gpu_name = torch.cuda.get_device_name(0)
        gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
        print(f"✅ GPU: {gpu_name}, 总显存: {gpu_memory:.1f}GB")
        
        # 检查显存是否足够（GO-1 完整版需要 ~14GB）
        if gpu_memory < 14:
            print("⚠️  警告: 显存可能不足，GO-1 完整版推荐至少 14GB 显存")
    else:
        print("❌ CUDA 不可用，GO-1 需要 GPU 加速")
        sys.exit(1)
    
    # 检查模型路径
    model_path = "./models/GO-1"
    if not os.path.exists(model_path):
        print(f"❌ 模型路径不存在: {model_path}")
        sys.exit(1)
    print(f"✅ 模型路径: {model_path}")

def create_valid_input():
    """创建符合模型要求的输入"""
    # 创建符合规格的摄像头图像
    def create_camera_image():
        # 创建具有纹理的随机图像
        img = np.random.randint(0, 255, (224, 224, 3), dtype=np.uint8)
        
        # 添加一些结构，使其看起来像真实图像
        cv2.rectangle(img, (50, 50), (174, 174), (100, 150, 200), -1)
        cv2.circle(img, (112, 112), 30, (200, 100, 50), -1)
        cv2.putText(img, "GO-1", (80, 120), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
        
        return img
    
    top_img = create_camera_image()
    right_img = create_camera_image()
    left_img = create_camera_image()
    
    # 确保图像是连续的
    top_img = np.ascontiguousarray(top_img)
    right_img = np.ascontiguousarray(right_img)
    left_img = np.ascontiguousarray(left_img)
    
    # 机器人状态 (14 维)
    state = np.zeros(14, dtype=np.float32)
    # 前7维: 关节位置 (弧度)
    state[0:7] = np.random.uniform(-1.57, 1.57, 7)
    # 后7维: 关节速度
    state[7:14] = np.random.uniform(-0.5, 0.5, 7)
    
    return {
        "top": top_img,
        "right": right_img,
        "left": left_img,
        "instruction": "fold the shirt",
        "state": state,
        "ctrl_freqs": np.array([30], dtype=np.float32)
    }

def visualize_inference(process, output_dir="go1_full_visualization"):
    """可视化推理过程"""
    os.makedirs(output_dir, exist_ok=True)
    
    # 创建视频写入器
    width, height = 672, 224  # 3个224x224图像并排
    fps = 10
    video_path = os.path.join(output_dir, "go1_full_inference.mp4")
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    video_writer = cv2.VideoWriter(video_path, fourcc, fps, (width, height))
    
    actions_history = []
    
    print("🎬 生成可视化推理结果...")
    for frame_idx in tqdm(range(200)):  # 200帧
        # 获取下一组输入
        payload = process()
        
        # 运行推理
        start_time = time.time()
        actions = model.inference(payload)
        inference_time = time.time() - start_time
        
        actions_history.append(actions)
        
        # 创建可视化帧
        combined_frame = np.hstack([payload["top"], payload["right"], payload["left"]])
        
        # 添加文本
        cv2.putText(combined_frame, f"Frame: {frame_idx+1}/200", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
        cv2.putText(combined_frame, "GO-1 Full Model Inference", (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
        cv2.putText(combined_frame, f"Task: {payload['instruction']}", (10, 90), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 0), 1)
        cv2.putText(combined_frame, f"Inference time: {inference_time:.3f}s", (10, 120), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 255), 1)
        
        # 转换为 BGR 用于 OpenCV
        combined_frame = cv2.cvtColor(combined_frame, cv2.COLOR_RGB2BGR)
        
        # 保存帧
        video_writer.write(combined_frame)
        
        # 每20帧保存一个关键帧
        if frame_idx % 20 == 0:
            frame_path = os.path.join(output_dir, f"frame_{frame_idx:04d}.jpg")
            cv2.imwrite(frame_path, combined_frame)
    
    # 释放资源
    video_writer.release()
    
    # 保存动作历史
    actions_path = os.path.join(output_dir, "actions_history.npy")
    np.save(actions_path, np.array(actions_history))
    
    # 生成动作图表
    plot_actions(actions_history, output_dir)
    
    print(f"\n✅ 视频已保存到: {video_path}")
    print(f"✅ 关键帧已保存到: {output_dir}/frame_*.jpg")
    print(f"✅ 动作数据已保存到: {actions_path}")
    print(f"✅ 动作图表已保存到: {output_dir}/actions_plot.png")
    
    return video_path

def plot_actions(actions_history, output_dir):
    """绘制动作历史图表"""
    actions_array = np.array(actions_history)
    
    plt.figure(figsize=(12, 8))
    for i in range(min(8, actions_array.shape[1])):  # 只显示前8个维度
        plt.plot(actions_array[:, i], label=f'Action {i+1}', linewidth=2)
    
    plt.title('GO-1 Full Model Actions Over Time', fontsize=16, fontweight='bold')
    plt.xlabel('Frame', fontsize=12)
    plt.ylabel('Action Value', fontsize=12)
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.tight_layout()
    
    plot_path = os.path.join(output_dir, "actions_plot.png")
    plt.savefig(plot_path, dpi=300, bbox_inches='tight')
    plt.close()

def main():
    print("🚀 开始 GO-1 完整模型推理测试...")
    
    # 环境检查
    check_environment()
    
    # 模型路径
    model_path = "./models/GO-1"
    data_stats_path = "./models/GO-1/dataset_stats.json"
    
    print(f"🧠 加载 GO-1 完整模型...")
    print(f"   模型路径: {model_path}")
    print(f"   数据统计: {data_stats_path}")
    
    # 加载模型
    try:
        global model
        model = GO1Infer(
            model_path=model_path,
            data_stats_path=data_stats_path
        )
        print("✅ GO-1 完整模型加载成功！")
    except Exception as e:
        print(f"❌ 模型加载失败: {str(e)}")
        import traceback
        traceback.print_exc()
        sys.exit(1)
    
    # 创建输入生成器
    def input_generator():
        return create_valid_input()
    
    # 生成可视化
    output_dir = "go1_full_visualization"
    video_path = visualize_inference(input_generator, output_dir)
    
    # 压缩结果
    zip_file = "go1_full_results.zip"
    os.system(f"zip -r {zip_file} {output_dir}")
    print(f"📦 结果已压缩到: {zip_file}")
    
    print("\n🎉 GO-1 完整模型推理测试完成！")
    print("\n💡 后续步骤:")
    print("1. 下载生成的视频和图表: scp ubuntu@your_server:~/AgiBot-World/go1_full_results.zip ./")
    print("2. 查看动作数据: python -c 'import numpy as np; print(np.load(\"go1_full_visualization/actions_history.npy\").shape)'")
    print("3. 远程部署: python evaluate/deploy.py --model_path ./models/GO-1 --data_stats_path ./models/GO-1/dataset_stats.json --port 8080")

if __name__ == "__main__":
    main()
EOF

chmod +x go1_inference.py

五、优化资源使用（针对 RTX 4090 24GB）

cat > optimize_go1.sh << 'EOF'
#!/bin/bash
echo "🔧 优化 GO-1 模型资源使用..."

# 设置 PyTorch 环境变量
export PYTORCH_CUDA_ALLOC_CONF="max_split_size_mb:128"
export CUDA_LAUNCH_BLOCKING=0
export TORCH_USE_CUDA_DSA=1

# 设置 Flash Attention 环境
export FLASH_ATTENTION_INLINE_KERNELS=1
export FLASH_ATTENTION_FORCE_DROPOUT=0

# 设置内存限制
export MAX_JOBS=4
export TF_GPU_ALLOCATOR=cuda_malloc_async

# 设置内存交换
sudo sysctl vm.swappiness=10
sudo sysctl vm.vfs_cache_pressure=50

echo "✅ 资源优化设置完成"
EOF

chmod +x optimize_go1.sh
source optimize_go1.sh

六、运行 GO-1 推理测试

# 激活优化设置
source optimize_go1.sh

# 运行推理测试
python go1_inference.py

# 检查结果
ls -la go1_full_visualization/
ls -la go1_full_results.zip

七、预期成功输出

成功运行后，你将看到类似以下的输出：

🚀 开始 GO-1 完整模型推理测试...
🔍 环境检查...
✅ GPU: NVIDIA GeForce RTX 4090, 总显存: 23.7GB
✅ 模型路径: ./models/GO-1
🧠 加载 GO-1 完整模型...
   模型路径: ./models/GO-1
   数据统计: ./models/GO-1/dataset_stats.json
✅ GO-1 完整模型加载成功！

🎬 生成可视化推理结果...
100%|███████████████████████████████████████████████████████| 200/200 [03:45<00:00,  1.13s/it]

✅ 视频已保存到: go1_full_visualization/go1_full_inference.mp4
✅ 关键帧已保存到: go1_full_visualization/frame_*.jpg
✅ 动作数据已保存到: go1_full_visualization/actions_history.npy
✅ 动作图表已保存到: go1_full_visualization/actions_plot.png
📦 结果已压缩到: go1_full_results.zip

🎉 GO-1 完整模型推理测试完成！

💡 后续步骤:
1. 下载生成的视频和图表: scp ubuntu@your_server:~/AgiBot-World/go1_full_results.zip ./
2. 查看动作数据: python -c 'import numpy as np; print(np.load("go1_full_visualization/actions_history.npy").shape)'
3. 远程部署: python evaluate/deploy.py --model_path ./models/GO-1 --data_stats_path ./models/GO-1/dataset_stats.json --port 8080

八、下载和查看结果

在本地机器上执行：

# 下载结果
scp ubuntu@your_server_ip:~/AgiBot-World/go1_full_results.zip ./

# 解压
unzip go1_full_results.zip

# 查看视频（需要视频播放器）
xdg-open go1_full_visualization/go1_full_inference.mp4  # Linux
open go1_full_visualization/go1_full_inference.mp4     # macOS

# 查看动作图表
xdg-open go1_full_visualization/actions_plot.png

九、远程部署（可选）

如果你想将 GO-1 模型部署为远程服务：

# 启动服务器
python evaluate/deploy.py \
  --model_path ./models/GO-1 \
  --data_stats_path ./models/GO-1/dataset_stats.json \
  --port 8080

# 在另一个终端中，使用客户端测试
cat > go1_client_test.py << 'EOF'
import json_numpy
import numpy as np
import requests
import time

json_numpy.patch()

# 创建测试输入
payload = {
    "top": np.random.randint(0, 255, (224, 224, 3), dtype=np.uint8),
    "right": np.random.randint(0, 255, (224, 224, 3), dtype=np.uint8),
    "left": np.random.randint(0, 255, (224, 224, 3), dtype=np.uint8),
    "instruction": "fold the shirt",
    "state": np.random.uniform(-3.14, 3.14, (14,)).astype(np.float32),
    "ctrl_freqs": np.array([30], dtype=np.float32)
}

# 发送请求
print("📡 发送请求到 GO-1 服务器...")
start_time = time.time()
response = requests.post("http://localhost:8080/act", json=payload)
inference_time = time.time() - start_time

if response.status_code == 200:
    actions = np.array(response.json())
    print(f"✅ 收到动作: {actions.shape}")
    print(f"⏱️  推理时间: {inference_time:.3f} 秒")
    print(f"📊 动作值: {actions[:5]}...")
else:
    print(f"❌ 请求失败，状态码: {response.status_code}")
    print(f"错误信息: {response.text}")
EOF

python go1_client_test.py

关键说明

1. 资源需求：

   • GO-1 完整模型推理需要约 14GB 显存
   • 你的 RTX 4090 (24GB) 完全足够
   • 优化脚本确保内存高效使用

2. 下载问题：

   • 使用 hf-mirror.com 镜像加速
   • 添加重试机制应对网络不稳定
   • 处理大文件分块下载

3. 可视化方案：

   • 生成 MP4 视频文件
   • 创建动作值变化图表
   • 保存关键帧截图
   • 所有结果打包成 ZIP 下载

4. 文件结构：

   go1_full_results.zip
   └── go1_full_visualization/
       ├── go1_full_inference.mp4    # 200帧推理视频
       ├── frame_0000.jpg            # 关键帧截图
       ├── frame_0020.jpg
       ├── ...
       ├── actions_history.npy       # 保存的14维动作数据
       └── actions_plot.png          # 动作值变化图表
   

5. 故障处理：

   • 详细的错误检查和报告
   • 环境验证步骤
   • 资源优化设置
   • 备用下载方法

这个教程专为你的服务器环境优化，解决了你之前在下载和运行过程中遇到的各种问题。完成这些步骤后，你将拥有一个完全功能的 GO-1 完整模型推理系统，并能可视化其输出结果。

如果在任何步骤遇到问题，请告诉我具体的错误信息，我会提供针对性的解决方案。