Skip to content

AUTODL_GPU_TRAINING.md

Latest commit

 

History

History
1026 lines (765 loc) · 23.2 KB

AUTODL_GPU_TRAINING.md

File metadata and controls

1026 lines (765 loc) · 23.2 KB
Raw

AutoDL GPU 训练部署指南

本指南详细介绍如何在 AutoDL 平台上部署 Go1 四足机器人强化学习项目，并利用 GPU 进行高速训练。

目录

  1. AutoDL 平台介绍
  2. 创建 GPU 实例
  3. 环境配置
  4. 项目上传
  5. 安装依赖
  6. 开始训练
  7. 监控训练进度
  8. 保存和下载模型
  9. 常见问题解答
  10. 成本优化建议

1. AutoDL 平台介绍

什么是 AutoDL？

AutoDL 是国内领先的 GPU 云计算平台，专为 AI 训练和深度学习任务设计。

核心优势

特性 说明
🚀 国内访问 国内服务器，上传下载速度快，延迟低
💰 性价比高 价格比 AWS/GCP 便宜 30-50%
🎮 多种 GPU 支持 RTX 3090/4090、A100、V100 等
📦 预装环境 提供 PyTorch、TensorFlow 等预配置镜像
🔧 易用管理 Web 终端、JupyterLab、VSCode 远程连接
💾 自动快照 支持数据盘快照，防止数据丢失

AutoDL 与其他平台对比

平台 国内访问 GPU 选择 价格 适合场景
AutoDL ✅ 优秀 丰富 低 个人/小团队训练
阿里云 ✅ 优秀 丰富 中 企业级应用
AWS ⚠️ 一般 最丰富 高 海外业务
Kaggle ❌ 慢 少 免费额度 学习/测试

2. 创建 GPU 实例

步骤 1：注册并登录

  1. 访问 AutoDL 官网
  2. 使用手机号/微信注册账号
  3. 完成实名认证（需要身份证）

步骤 2：充值（可选但推荐）

# 微信/支付宝充值
# 建议充值 50-100 元用于测试
# AutoDL 支持按量付费，用完即停

步骤 3：创建实例

推荐配置（根据预算选择）

GPU 型号 显存 CPU 内存 硬盘 参考价格 推荐场景
RTX 3090 24GB 10核 40GB 50GB ¥1.5-2/小时 入门首选
RTX 4090 24GB 14核 56GB 50GB ¥2.5-3/小时 性能更强
A100 80GB 14核 56GB 50GB ¥5-6/小时 大规模训练
V100 32GB 10核 40GB 50GB ¥3-4/小时 稳定可靠

创建步骤详解

1. 点击 "创建实例"
   └─ 选择 "GPU 实例"

2. 选择镜像
   └─ 推荐: "PyTorch 2.1.0 / Python 3.10 / CUDA 11.8"
   └─ 或者: "Ubuntu 22.04 / Python 3.10"（需要手动安装 CUDA）

3. 选择 GPU
   └─ 推荐: RTX 3090 (性价比最高)
   └─ 数量: 1 (单 GPU 足够训练)

4. 选择 CPU/内存
   └─ 自动匹配（会根据 GPU 型号推荐合适的 CPU/内存）

5. 选择硬盘
   └─ 系统盘: 50GB (足够装环境)
   └─ 数据盘: 可选 50-100GB (存储数据集和模型)

6. 网络设置
   └─ 公网 IP: 勾选 (用于 SSH 连接)
   └─ 端口: 22 (SSH), 6006 (TensorBoard)

7. 付费方式
   └─ 按量付费 (用完关机即可)
   └─ 或者包月 (更便宜，但需长期使用)

8. 点击 "创建实例"

步骤 4：获取连接信息

实例创建后，会显示连接信息：

实例名称: instance-xxx
IP 地址: 123.45.67.89
SSH 端口: 22
用户名: root
密码: xxxxxxxxxxx

Web 终端: https://www.autodl.com/terminal/instance-xxx
JupyterLab: https://www.autodl.com/jupyter/instance-xxx

3. 环境配置

步骤 1：连接实例

方式 A：Web 终端（最简单）

  1. 登录 AutoDL 控制台
  2. 点击实例的 "终端" 按钮
  3. 直接在浏览器中操作

方式 B：SSH 连接（推荐）

# Mac/Linux
ssh root@123.45.67.89 -p 22

# Windows (PowerShell)
ssh root@123.45.67.89 -p 22

# 或者使用密码认证
# 输入实例显示的密码

方式 C：VSCode 远程连接

  1. 安装 Remote-SSH 插件
  2. 配置 ~/.ssh/config：
Host autodl-gpu
    HostName 123.45.67.89
    User root
    Port 22
  1. 使用密码或密钥连接

步骤 2：检查 GPU 环境

# 检查 NVIDIA 驱动
nvidia-smi

# 预期输出：
# +-----------------------------------------------------------------------------+
# | NVIDIA-SMI 525.78.01    Driver Version: 525.78.01    CUDA Version: 12.0     |
# |-------------------------------+----------------------+----------------------+
# | GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
# | Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
# |===============================+======================+======================|
# |   0  NVIDIA GeForce ...  On   | 00000000:00:0A.0    |                  0 |
# |  0%   45C    P8     10W / 350W |    50MiB / 24564MiB |      0%      Default |
# +-------------------------------+----------------------+----------------------+

# 检查 CUDA (如果是预装镜像)
nvcc --version

# 检查 Python 版本
python3 --version

# 检查 PyTorch (如果预装)
python3 -c "import torch; print(torch.__version__); print(torch.cuda.is_available())"

步骤 3：配置国内镜像源（加速下载）

# 备份原始源
cp /etc/apt/sources.list /etc/apt/sources.list.bak

# 修改为阿里云镜像 (Ubuntu 22.04)
cat > /etc/apt/sources.list << 'EOF'
deb http://mirrors.aliyun.com/ubuntu/ jammy main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-backports main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-security main restricted universe multiverse
EOF

# 更新
apt-get update -y

# 配置 pip 镜像源
pip3 config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
pip3 config set global.trusted-host pypi.tuna.tsinghua.edu.cn

步骤 4：安装基础依赖

apt-get update && apt-get install -y --no-install-recommends \
    git \
    curl \
    wget \
    vim \
    unzip \
    htop \
    cmake \
    build-essential \
    python3-dev \
    libgl1-mesa-glx \
    libglib2.0-0

# 清理缓存
rm -rf /var/lib/apt/lists/*

4. 项目上传

方式 A：使用 git（推荐）

# 在实例上克隆项目
cd /root
git clone https://github.com/your-username/go1_rl_project.git

# 或者克隆私有仓库（需要配置 SSH key）
ssh-keygen -t ed25519 -C "autodl"
# 复制公钥到 GitHub/GitLab
cat ~/.ssh/id_ed25519.pub

# 然后克隆私有仓库
git clone git@github.com:your-username/go1_rl_project.git

方式 B：使用 scp 命令

# 在本地电脑执行
scp -P 22 -r /path/to/your/local/project root@123.45.67.89:/root/

# 例如：
scp -P 22 -r ~/ros2_ws/src/go1_rl root@123.45.67.89:/root/

方式 C：使用 rsync（推荐大文件）

# 在本地电脑执行
rsync -avz -e "ssh -p 22" /path/to/your/local/project/ root@123.45.67.89:/root/project/

# 支持断点续传
rsync -avz -e "ssh -p 22" --partial /path/to/your/local/project/ root@123.45.67.89:/root/project/

方式 D：使用 AutoDL 文件管理器

1. 登录 AutoDL 控制台
2. 进入实例详情
3. 点击 "文件管理"
4. 直接拖拽文件上传
5. 或者使用 Web 终端的上传功能

方式 E：使用 JupyterLab

# 在实例上启动 JupyterLab
jupyter lab --ip=0.0.0.0 --port=8888 --no-browser

# 或者通过 AutoDL 控制台直接打开
# 上传功能: File -> Upload Files

5. 安装依赖

完整安装脚本

# 进入项目目录
cd /root/go1_rl

# 创建虚拟环境（推荐）
python3 -m venv venv
source venv/bin/activate

# 升级 pip
pip install --upgrade pip setuptools wheel

# 安装 PyTorch (根据 CUDA 版本选择)
# CUDA 11.8
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# CUDA 12.1
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# 或者自动检测并安装（推荐）
pip install torch torchvision torchaudio

# 安装项目依赖
pip install pybullet stable-baselines3[extra] gymnasium numpy matplotlib opencv-python-headless

# 验证安装
python3 -c "
import torch
import pybullet as p
print(f'PyTorch version: {torch.__version__}')
print(f'CUDA available: {torch.cuda.is_available()}')
print(f'CUDA version: {torch.version.cuda}')
print(f'GPU count: {torch.cuda.device_count()}')
if torch.cuda.is_available():
    print(f'GPU name: {torch.cuda.get_device_name(0)}')
    print(f'GPU memory: {torch.cuda.get_device_properties(0).total_mem / 1024**3:.1f} GB')
print(f'PyBullet version: {p.__version__}')
"

验证 GPU 加速

# 创建测试脚本
cat > test_gpu.py << 'EOF'
import torch
import time

# 测试 GPU 矩阵乘法
print(f"GPU: {torch.cuda.get_device_name(0)}")
print(f"显存: {torch.cuda.get_device_properties(0).total_mem / 1024**3:.1f} GB")

# 小矩阵测试
a = torch.randn(1000, 1000, device='cuda')
b = torch.randn(1000, 1000, device='cuda')

start = time.time()
for _ in range(100):
    c = torch.mm(a, b)
torch.cuda.synchronize()
gpu_time = time.time() - start
print(f"GPU 100x (1000x1000) 矩阵乘法: {gpu_time:.3f} 秒")

# CPU 测试
a_cpu = a.cpu()
b_cpu = b.cpu()

start = time.time()
for _ in range(100):
    c_cpu = torch.mm(a_cpu, b_cpu)
cpu_time = time.time() - start
print(f"CPU 100x (1000x1000) 矩阵乘法: {cpu_time:.3f} 秒")

# 加速比
print(f"GPU 加速比: {cpu_time/gpu_time:.1f}x")
EOF

# 运行测试
python3 test_gpu.py

# 预期输出（RTX 3090）：
# GPU: NVIDIA GeForce RTX 3090
# 显存: 24.0 GB
# GPU 100x (1000x1000) 矩阵乘法: 0.025 秒
# CPU 100x (1000x1000) 矩阵乘法: 2.500 秒
# GPU 加速比: 100.0x

6. 开始训练

基础训练命令

cd /root/go1_rl

# 激活虚拟环境
source venv/bin/activate

# 最简单的训练
python3 scripts/train.py \
    --algorithm PPO \
    --total-timesteps 100000

# GPU 训练（推荐）
python3 scripts/train.py \
    --algorithm PPO \
    --total-timesteps 2000000 \
    --n-envs 16 \
    --device cuda

# 参数说明：
# --algorithm: PPO, SAC, TD3
# --total-timesteps: 总训练步数
# --n-envs: 并行环境数（GPU 上可以多开）
# --device: cpu 或 cuda
# --batch-size: 批量大小
# --learning-rate: 学习率

推荐配置（RTX 3090/4090）

# 高性能配置
python3 scripts/train.py \
    --algorithm PPO \
    --total-timesteps 5000000 \
    --n-envs 32 \
    --batch-size 512 \
    --learning-rate 3e-4 \
    --device cuda

# SAC 配置（样本效率更高）
python3 scripts/train.py \
    --algorithm SAC \
    --total-timesteps 3000000 \
    --n-envs 8 \
    --batch-size 256 \
    --device cuda

后台运行（关键！）

注意：关闭 Web 终端或 SSH 连接后，训练会停止！必须使用后台运行方式。

方式 A：nohup（最简单）

# 创建日志目录
mkdir -p logs models

# 后台运行
nohup python3 scripts/train.py \
    --algorithm PPO \
    --total-timesteps 2000000 \
    --n-envs 16 \
    --device cuda \
    > logs/train_$(date +%Y%m%d_%H%M%S).log 2>&1 &

# 记录 PID（方便后续管理）
echo $! > train.pid

# 查看进程
ps aux | grep train.py

方式 B：tmux（推荐，更灵活）

# 安装 tmux（如果没有）
apt-get install -y tmux

# 创建新会话
tmux new -s training

# 在 tmux 会话中运行训练
python3 scripts/train.py \
    --algorithm PPO \
    --total-timesteps 2000000 \
    --n-envs 16 \
    --device cuda

# 分离会话（保持运行）
# 按 Ctrl+B，然后按 D

# 重新连接会话
tmux attach -t training

# 查看所有会话
tmux ls

# 杀死会话
tmux kill-session -t training

方式 C：screen（另一个选择）

# 创建新会话
screen -S training

# 运行训练
python3 scripts/train.py ...

# 分离（Ctrl+A，然后按 D）
screen -d

# 重新连接
screen -r training

监控 GPU 使用

# 实时监控 GPU
watch -n 1 nvidia-smi

# 或者使用更友好的工具
# pip install gpustat
gpustat -i

# 查看温度、功耗、显存占用
nvidia-smi --query-gpu=temperature.gpu,power.draw,memory.used,memory.total,utilization.gpu --format=csv

恢复训练

如果训练中断，可以从检查点恢复：

# 查看已保存的检查点
ls -la logs/checkpoints/

# 从检查点恢复
python3 scripts/train.py \
    --resume logs/checkpoints/checkpoint_1000000_steps.zip \
    --total-timesteps 5000000 \
    --device cuda

7. 监控训练进度

查看日志

# 实时查看
tail -f logs/train_20240101_120000.log

# 查看最后 100 行
tail -n 100 logs/train_20240101_120000.log

# 搜索特定信息
grep "reward" logs/train_20240101_120000.log
grep "loss" logs/train_20240101_120000.log
grep "saved" logs/train_20240101_120000.log

使用 TensorBoard

# 启动 TensorBoard
tensorboard --logdir=logs/tensorboard --port=6006 --host=0.0.0.0

# 然后在本地浏览器访问
# 方式 1: 直接访问 http://instance-ip:6006
# 方式 2: SSH 端口转发
ssh -L 6006:localhost:6006 -p 22 root@instance-ip
# 然后在本地浏览器访问 http://localhost:6006

# 方式 3: AutoDL 控制台提供的 Web 服务
# 进入实例 -> 端口映射 -> 添加 6006 端口 -> 访问映射后的 URL

使用 AutoDL 监控功能

1. 登录 AutoDL 控制台
2. 进入实例详情
3. 查看：
   - CPU 使用率
   - 内存占用
   - GPU 使用率
   - 显存占用
   - 网络流量
   - 磁盘使用

自动保存检查点

训练脚本通常会自动保存检查点，但可以手动触发：

# 发送信号给训练进程
kill -USR1 $(cat train.pid)

# 或者修改训练脚本增加保存频率
# 在 callbacks.py 中配置

8. 保存和下载模型

保存模型

训练脚本会自动保存：

# 自动保存位置
ls -la logs/checkpoints/

# 模型文件
best_model.zip
final_model.zip
checkpoint_*.zip

下载模型

方式 A：使用 scp

# 在本地电脑执行
scp -P 22 root@instance-ip:/root/go1_rl/logs/checkpoints/best_model.zip ./

# 下载整个目录
scp -r -P 22 root@instance-ip:/root/go1_rl/logs/ ./

方式 B：使用 rsync

# 支持断点续传
rsync -avz -e "ssh -p 22" root@instance-ip:/root/go1_rl/logs/checkpoints/ ./models/

# 只下载最新的模型
rsync -avz --progress -e "ssh -p 22" \
    root@instance-ip:/root/go1_rl/logs/checkpoints/best_model.zip ./

方式 C：使用 AutoDL 文件管理

1. 登录 AutoDL 控制台
2. 进入实例详情
3. 点击 "文件管理"
4. 导航到 /root/go1_rl/logs/checkpoints/
5. 下载需要的文件

方式 D：使用云存储（推荐大文件）

# 安装阿里云 OSS 工具
wget https://gosspublic.alicdn.com/ossutil/v2.2.19/ossutil-v2.2.19-linux-amd64.zip
unzip ossutil-v2.2.19-linux-amd64.zip
./ossutil config

# 上传到 OSS
./ossutil cp -r /root/go1_rl/logs/checkpoints/ oss://your-bucket/go1_rl/

# 或者使用 AWS S3
pip install awscli
aws configure
aws s3 cp /root/go1_rl/logs/checkpoints/best_model.zip s3://your-bucket/go1_rl/

测试训练好的模型

# 在实例上测试
python3 scripts/test.py \
    --model-path logs/checkpoints/best_model.zip \
    --episodes 100 \
    --render

# 下载到本地后测试
python3 scripts/test.py \
    --model-path ./best_model.zip \
    --episodes 100 \
    --render

9. 常见问题解答

Q1: 忘记关闭实例，被扣费了怎么办？

# 立即关机
# 在 AutoDL 控制台点击 "关机" 或 "释放"
# 或者在实例上执行：
shutdown -h now

# 设置自动关机（重要！）
# AutoDL 控制台 -> 实例设置 -> 自动关机时间
# 建议设置为 24 小时，训练完立即关机

Q2: 训练速度慢怎么办？

# 检查 GPU 是否被正确使用
nvidia-smi  # 查看 GPU 利用率（应该接近 100%）

# 如果 GPU 利用率低，可能是：
# 1. CPU 瓶颈 - 增加 n-envs
python3 scripts/train.py --n-envs 32  # 增加并行环境

# 2. 数据加载慢 - 检查 I/O
iostat -x 1

# 3. PyBullet 渲染 - 使用 headless 模式（默认）

# 查看系统资源
htop  # CPU/内存监控

Q3: 显存不足怎么办？

# 错误信息: CUDA out of memory

# 解决方案 1: 减少 batch size
python3 scripts/train.py --batch-size 128  # 默认可能是 256

# 解决方案 2: 减少并行环境数
python3 scripts/train.py --n-envs 8  # 从 16 减到 8

# 解决方案 3: 使用梯度累积（需要修改代码）
# 在 stable-baselines3 中设置 n_steps

# 解决方案 4: 使用更小的模型
# 修改 hidden_dims 参数

Q4: 如何避免数据丢失？

# 1. 定期备份
# 创建自动备份脚本
cat > backup.sh << 'EOF'
#!/bin/bash
BACKUP_DIR="/root/go1_rl/backups"
mkdir -p $BACKUP_DIR
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
tar -czf $BACKUP_DIR/checkpoints_$TIMESTAMP.tar.gz /root/go1_rl/logs/checkpoints/
# 上传到云存储
./ossutil cp $BACKUP_DIR/checkpoints_$TIMESTAMP.tar.gz oss://your-bucket/backups/
EOF
chmod +x backup.sh

# 2. 添加定时任务
crontab -e
# 每小时备份一次
0 * * * * /root/go1_rl/backup.sh

# 3. 使用 AutoDL 快照功能
# 控制台 -> 数据盘快照 -> 创建快照

Q5: 如何在多 GPU 上训练？

# AutoDL 支持多 GPU 实例
# 创建实例时选择 2 或 4 张 GPU

# 修改训练脚本支持多 GPU
# 使用 PyTorch DDP
torchrun --nproc_per_node=2 scripts/train.py

# 或者使用 stable-baselines3 的多进程支持
python3 scripts/train.py --device cuda:0,1

# 简单方案：每张 GPU 训练一个不同的模型
# 终端 1: CUDA_VISIBLE_DEVICES=0 python3 scripts/train.py
# 终端 2: CUDA_VISIBLE_DEVICES=1 python3 scripts/train.py

Q6: 实例 IP 变了怎么办？

# AutoDL 的公网 IP 在重启后可能会变
# 使用 AutoDL 提供的连接信息重新获取 IP

# 或者绑定域名（高级）
# 在阿里云购买域名 -> 解析到实例 IP
# 使用动态 DNS（DDNS）自动更新

Q7: 如何查看实时训练曲线？

# 方式 1: TensorBoard（推荐）
tensorboard --logdir=logs/tensorboard --port=6006

# 方式 2: 简单 Python 脚本
python3 -c "
import matplotlib.pyplot as plt
import pandas as pd
data = pd.read_csv('logs/training_metrics.csv')
plt.plot(data['timesteps'], data['reward'])
plt.savefig('training_curve.png')
"

# 方式 3: AutoDL JupyterLab
# 创建 notebook，读取日志并可视化

10. 成本优化建议

实例配置优化

❌ 不必要的高配置：
- 训练小模型不需要 A100
- 初学者不需要多 GPU

✅ 推荐配置：
- 入门训练: RTX 3090 (24GB) - ¥1.5-2/小时
- 进阶训练: RTX 4090 (24GB) - ¥2.5-3/小时
- 大规模: A100 80GB - ¥5-6/小时

付费方式选择

方式 优点 缺点 适合
按量付费 灵活，用完即停 单价高 短期任务
包月 便宜 30-50% 需要长期使用 长期项目
** spot 实例** 便宜 70-90% 可能被回收 可中断任务

节省技巧

# 1. 用完立即关机（最重要！）
# AutoDL 按开机时间计费
# 训练完立刻关机

# 2. 设置自动关机
# 控制台 -> 实例设置 -> 闲置自动关机

# 3. 使用 spot 实例
# 被回收时自动保存检查点
# 重新开机后从检查点恢复

# 4. 优化训练参数
# 先用小步数测试
python3 scripts/train.py --total-timesteps 10000  # 快速验证

# 再用大步数正式训练
python3 scripts/train.py --total-timesteps 5000000  # 正式训练

# 5. 共享实例
# 多个项目共用一个实例
# 使用 tmux/screen 隔离

# 6. 清理不需要的文件
du -sh /root/*  # 查看磁盘占用
rm -rf ~/.cache/*  # 清理缓存
pip cache purge  # 清理 pip 缓存

成本估算示例

任务 GPU 时间 单价 费用
测试 10k steps RTX 3090 5分钟 ¥2/小时 ¥0.17
小规模训练 100k RTX 3090 30分钟 ¥2/小时 ¥1.0
中等训练 1M RTX 3090 3小时 ¥2/小时 ¥6.0
大规模训练 10M RTX 3090 30小时 ¥2/小时 ¥60.0

附录：完整训练脚本

一键训练脚本

#!/bin/bash
# train_on_autodl.sh

# 参数配置
ALGORITHM="PPO"
TOTAL_TIMESTEPS=2000000
N_ENVS=16
BATCH_SIZE=256
LEARNING_RATE=3e-4
DEVICE="cuda"
LOG_DIR="logs"
MODEL_DIR="models"

# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

echo -e "${GREEN}=== AutoDL GPU 训练脚本 ===${NC}"

# 检查 GPU
echo -e "${YELLOW}[1/5] 检查 GPU...${NC}"
if ! nvidia-smi &> /dev/null; then
    echo -e "${RED}错误: 没有检测到 GPU${NC}"
    exit 1
fi
echo -e "${GREEN}✓ GPU 检测成功${NC}"

# 检查 Python 环境
echo -e "${YELLOW}[2/5] 检查 Python 环境...${NC}"
if [ ! -d "venv" ]; then
    echo "创建虚拟环境..."
    python3 -m venv venv
fi
source venv/bin/activate

# 检查依赖
python3 -c "import torch" &> /dev/null || {
    echo "安装依赖..."
    pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
    pip install pybullet stable-baselines3[extra] gymnasium numpy
}
echo -e "${GREEN}✓ 依赖检查完成${NC}"

# 创建目录
echo -e "${YELLOW}[3/5] 创建输出目录...${NC}"
mkdir -p $LOG_DIR/tensorboard $LOG_DIR/checkpoints $MODEL_DIR
echo -e "${GREEN}✓ 目录创建完成${NC}"

# GPU 信息
echo -e "${YELLOW}[4/5] GPU 信息...${NC}"
nvidia-smi --query-gpu=name,memory.total --format=csv,noheader

# 开始训练
echo -e "${YELLOW}[5/5] 开始训练...${NC}"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
LOG_FILE="$LOG_DIR/train_$TIMESTAMP.log"

echo "训练配置:"
echo "  算法: $ALGORITHM"
echo "  总步数: $TOTAL_TIMESTEPS"
echo "  并行环境: $N_ENVS"
echo "  批量大小: $BATCH_SIZE"
echo "  学习率: $LEARNING_RATE"
echo "  设备: $DEVICE"
echo "  日志文件: $LOG_FILE"
echo ""

# 后台运行
nohup python3 scripts/train.py \
    --algorithm $ALGORITHM \
    --total-timesteps $TOTAL_TIMESTEPS \
    --n-envs $N_ENVS \
    --batch-size $BATCH_SIZE \
    --learning-rate $LEARNING_RATE \
    --device $DEVICE \
    > $LOG_FILE 2>&1 &

PID=$!
echo $PID > train.pid

echo -e "${GREEN}✓ 训练已启动，PID: $PID${NC}"
echo -e "${GREEN}✓ 日志文件: $LOG_FILE${NC}"
echo ""
echo "常用命令:"
echo "  查看日志: tail -f $LOG_FILE"
echo "  查看进程: ps aux | grep train.py"
echo "  停止训练: kill $PID"
echo "  查看 GPU: watch -n 1 nvidia-smi"
echo ""
echo -e "${YELLOW}⚠️ 重要: 训练完成后记得关机！${NC}"

使用方法

# 赋予执行权限
chmod +x train_on_autodl.sh

# 运行脚本
./train_on_autodl.sh

# 或者修改参数后运行
ALGORITHM=SAC TOTAL_TIMESTEPS=5000000 ./train_on_autodl.sh

总结流程图

1. 创建 AutoDL GPU 实例
   └─ 选择镜像 + GPU 型号 + 配置

2. 连接实例
   └─ SSH / Web 终端 / VSCode

3. 环境配置
   └─ 检查 GPU + 配置镜像源 + 安装依赖

4. 上传项目
   └─ git clone / scp / AutoDL 文件管理

5. 安装依赖
   └─ PyTorch + CUDA + 项目依赖

6. 开始训练
   └─ 使用 tmux/nohup 后台运行

7. 监控训练
   └─ 查看日志 + TensorBoard

8. 下载模型
   └─ scp / rsync / 云存储

9. 关机省钱 ⭐
   └─ 用完立即关机！

祝训练顺利！🚀

如有问题，可参考 AutoDL 官方文档或联系技术支持。