【完结篇】DevOps Agent 从0到1搞强化学习训练实战

VERL（Value-Equivalent Reinforcement Learning）是 Agent Lightning 使用的强化学习算法框架。如何用 Agent Lightning 训练一个专业的 DevOps Architect Agent？GRPO 适合我们的 DevOps 任务（长文本、多步骤）引言：训练一个"会思考"的 DevOps Agent。引言：训练一个"会思考"的 DevO

互联网运维杂谈

67人浏览 · 2025-12-26 08:23:46

互联网运维杂谈 · 2025-12-26 08:23:46 发布

如何用 Agent Lightning 训练一个专业的 DevOps Architect Agent？本文深入解析训练脚本的设计思路与实现细节。

引言：训练一个"会思考"的 DevOps Agent

想象一下，你有一个 DevOps Architect Agent，它不仅能回答 DevOps 问题，还能：

🎯 理解任务上下文：根据任务类型调整输出重点
📊 多维度自我评估：从自动化、可靠性、安全性等维度评估自己的输出
🔄 持续学习改进：通过强化学习不断优化响应质量

今天，我们以 train_devops_agent.py 为核心，深入解析如何设计一套完整的 RL 训练方案。

一、训练架构：三层设计哲学

1.1 整体架构

┌─────────────────────────────────────────────────────────┐
│              训练脚本 (train_devops_agent.py)           │
├─────────────────────────────────────────────────────────┤
│                                                          │
│  ┌──────────────┐    ┌──────────────┐    ┌───────────┐ │
│  │  Agent 层    │───▶│  奖励函数层  │───▶│ 数据集层  │ │
│  │              │    │              │    │           │ │
│  │ DevOpsAgent  │    │ Reward Func  │    │ Tasks     │ │
│  └──────────────┘    └──────────────┘    └───────────┘ │
│         │                    │                  │        │
│         └────────────────────┴──────────────────┘        │
│                           │                              │
│                           ▼                              │
│              ┌────────────────────────┐                  │
│              │   Agent Lightning      │                  │
│              │   VERL/GRPO Trainer   │                  │
│              └────────────────────────┘                  │
│                                                          │
└─────────────────────────────────────────────────────────┘

1.2 核心组件

组件	文件	职责
Agent	`train_devops_agent.py`	封装 LLM 调用，实现 `__call__` 接口
奖励函数	`reward_functions.py`	多维度评估 Agent 输出
数据集	`tasks_dataset.py`	提供 25 个训练任务
训练器	`train_devops_agent.py`	集成 VERL/GRPO 算法

二、Agent 实现：可训练的接口设计

2.1 DevOpsAgent 类设计

class DevOpsAgent:
    """DevOps Architect Agent for RL training."""
    
    def __init__(self, config: Optional[Dict[str, str]] = None):
        self.config = config or LLM_CONFIG
        self.client = OpenAI(
            api_key=self.config["api_key"],
            base_url=self.config["base_url"]
        )
        self.model = self.config["model"]
        self.system_prompt = load_system_prompt()

设计要点：

✅ 配置化：支持自定义 LLM 配置
✅ 系统提示词加载：从 devops-architect.md 加载
✅ OpenAI 兼容：支持标准 OpenAI API 格式

2.2 核心方法：`call`

def __call__(self, task: Dict[str, Any]) -> str:
    """Run the agent on a task and return the response."""
    task_id = task.get("task_id") or task.get("id", "unknown")
    prompt = task.get("prompt") or task.get("desc", "")
    
    # 1. 构建消息
    messages = [
        {"role": "system", "content": self.system_prompt},
        {"role": "user", "content": prompt}
    ]
    
    # 2. 调用 LLM
    response = self.client.chat.completions.create(
        model=self.model,
        messages=messages,
        temperature=0.7,
        max_tokens=2048,
    )
    
    output = response.choices[0].message.content or""
    
    # 3. 计算奖励并发送给训练器
    task_data = task.get("metadata", task)
    reward = calculate_devops_reward(output, task_data)
    
    try:
        agl.emit_reward(reward)  # 发送奖励信号
    except Exception:
        pass# 测试模式下忽略
    
    return output

设计亮点：

✅ 可调用接口：实现 __call__ 方法，符合 Agent Lightning 规范
✅ 自动奖励计算：每次调用自动计算奖励
✅ 奖励信号发送：通过 agl.emit_reward() 发送给训练器
✅ 异常处理：测试模式下优雅处理无 tracer 的情况

2.3 日志设计：可观测的训练过程

def setup_logger(debug: bool = False) -> logging.Logger:
    """Setup logger with console and file handlers."""
    logger = logging.getLogger("devops_agent")
    logger.setLevel(logging.DEBUG if debug else logging.INFO)
    
    # 控制台输出（带颜色）
    console_handler = logging.StreamHandler(sys.stdout)
    console_format = logging.Formatter(
        "%(asctime)s | %(levelname)-8s | %(message)s",
        datefmt="%H:%M:%S"
    )
    console_handler.setFormatter(console_format)
    logger.addHandler(console_handler)
    
    # 文件输出（详细）
    log_file = os.path.join(log_dir, f"training_{timestamp}.log")
    file_handler = logging.FileHandler(log_file, encoding="utf-8")
    file_format = logging.Formatter(
        "%(asctime)s | %(levelname)-8s | %(funcName)s:%(lineno)d | %(message)s"
    )
    file_handler.setFormatter(file_format)
    logger.addHandler(file_handler)
    
    return logger

设计要点：

✅ 双重输出：控制台 + 文件
✅ 不同级别：控制台 INFO，文件 DEBUG
✅ 时间戳：便于追踪训练过程
✅ 函数定位：文件日志包含函数名和行号

三、训练模式：RL 训练核心

def run_training(mode: str, model_path: Optional[str] = None, n_runners: int = 4):
    """Run RL training with the specified configuration."""
    
    # 1. 选择配置
    if mode == "ci-fast":
        config = config_ci_fast()  # 快速测试配置
    elif mode == "single-gpu":
        config = config_single_gpu()  # 单 GPU 配置
    else:
        config = verl_default_config()  # 默认配置
    
    # 2. 准备数据集
    train_data = convert_to_training_format()
    val_data = train_data[:5]  # 前 5 个作为验证集
    
    # 3. 初始化算法和训练器
    algorithm = agl.VERL(config)
    trainer = agl.Trainer(algorithm=algorithm, n_runners=n_runners)
    
    # 4. 开始训练
    trainer.fit(devops_agent, train_dataset=train_data, val_dataset=val_data)

使用场景：

✅ 正式 RL 训练
✅ 模型微调
✅ 性能优化

四、VERL 配置详解：训练的核心关注点

4.1 VERL 配置结构概览

VERL（Value-Equivalent Reinforcement Learning）是 Agent Lightning 使用的强化学习算法框架。配置分为 5 个主要部分：

VERL 配置
├── algorithm          # 算法选择（GRPO/PPO）
├── data              # 数据处理配置
├── actor_rollout_ref  # Actor、Rollout、Reference 模型配置
│   ├── rollout       # 推理阶段配置
│   ├── actor         # 训练中的 Actor 模型配置
│   ├── ref           # Reference 模型配置
│   └── model         # 基础模型配置
└── trainer           # 训练器配置

4.2 完整配置解析

def verl_default_config() -> Dict[str, Any]:
    """Default VERL configuration for DevOps agent training."""
    return {
        # ============================================================
        # 1. Algorithm: 算法选择
        # ============================================================
        "algorithm": {
            "adv_estimator": "grpo",      # GRPO vs PPO
            "use_kl_in_reward": False,    # 是否在奖励中使用 KL 散度
        },
        
        # ============================================================
        # 2. Data: 数据处理配置
        # ============================================================
        "data": {
            "train_batch_size": 16,           # 训练批次大小
            "max_prompt_length": 8192,       # 最大 prompt 长度
            "max_response_length": 4096,      # 最大响应长度
            "truncation": "error",           # 超长处理策略
        },
        
        # ============================================================
        # 3. Actor/Rollout/Ref: 模型推理和训练配置
        # ============================================================
        "actor_rollout_ref": {
            # 3.1 Rollout: 推理阶段配置
            "rollout": {
                "tensor_model_parallel_size": 1,  # 张量并行大小
                "n": 4,                           # 每个 prompt 生成 n 个响应
                "log_prob_micro_batch_size_per_gpu": 4,  # 每个 GPU 的微批次大小
                "multi_turn": {"format": "hermes"},       # 多轮对话格式
                "name": "vllm",                          # 推理引擎（vLLM）
                "gpu_memory_utilization": 0.6,          # GPU 内存利用率
                "engine_kwargs": {
                    "vllm": {
                        "enable_auto_tool_choice": True,  # 启用自动工具选择
                        "tool_call_parser": "hermes",    # 工具调用解析器
                    }
                },
            },
            
            # 3.2 Actor: 训练中的 Actor 模型配置
            "actor": {
                "ppo_mini_batch_size": 16,              # PPO 小批次大小
                "ppo_micro_batch_size_per_gpu": 4,      # 每个 GPU 的微批次大小
                "optim": {"lr": 1e-6},                  # 优化器学习率
                "use_kl_loss": False,                   # 是否使用 KL 损失
                "kl_loss_coef": 0.0,                    # KL 损失系数
                "entropy_coeff": 0,                     # 熵系数（探索性）
                "clip_ratio_low": 0.2,                  # PPO clip 下界
                "clip_ratio_high": 0.3,                 # PPO clip 上界
                "fsdp_config": {                        # FSDP 分布式训练配置
                    "param_offload": True,               # 参数卸载到 CPU
                    "optimizer_offload": True,           # 优化器卸载到 CPU
                },
            },
            
            # 3.3 Ref: Reference 模型配置（用于计算 KL 散度）
            "ref": {
                "log_prob_micro_batch_size_per_gpu": 8,  # Reference 模型批次大小
                "fsdp_config": {"param_offload": True},  # FSDP 配置
            },
            
            # 3.4 Model: 基础模型配置
            "model": {
                "path": "Qwen/Qwen2.5-7B-Instruct",     # 模型路径
                "use_remove_padding": True,              # 移除 padding
                "enable_gradient_checkpointing": True,    # 梯度检查点（节省内存）
            },
        },
        
        # ============================================================
        # 4. Trainer: 训练器配置
        # ============================================================
        "trainer": {
            "n_gpus_per_node": 1,        # 每个节点的 GPU 数量
            "val_before_train": True,    # 训练前验证
            "critic_warmup": 0,          # Critic 预热轮数
            "logger": ["console"],       # 日志输出（console/wandb）
            "project_name": "AgentLightning",  # 项目名称
            "experiment_name": "devops_architect",  # 实验名称
            "nnodes": 1,                 # 节点数量
            "save_freq": 50,             # 模型保存频率（epoch）
            "test_freq": 10,             # 测试频率（epoch）
            "total_epochs": 100,         # 总训练轮数
        },
    }

4.3 关键配置项详解

4.3.1 Algorithm 配置

配置项	值	说明	关注点
`adv_estimator`	`"grpo"`	优势估计器：GRPO vs PPO	GRPO 通常更稳定，适合长文本生成
`use_kl_in_reward`	`False`	是否在奖励中加入 KL 散度惩罚	设为 `False` 让 Agent 更自由探索

调优建议：

如果训练不稳定，尝试 "ppo" 或启用 use_kl_in_reward
GRPO 适合我们的 DevOps 任务（长文本、多步骤）

4.3.2 Data 配置

配置项	值	说明	关注点
`train_batch_size`	`16`	训练批次大小	内存 vs 速度：越大越快但需要更多内存
`max_prompt_length`	`8192`	最大 prompt 长度	根据系统提示词长度调整
`max_response_length`	`4096`	最大响应长度	DevOps 任务通常需要较长响应
`truncation`	`"error"`	超长处理策略	`"error"` 确保不丢失信息

调优建议：

如果 OOM（内存不足），减小 train_batch_size
如果响应被截断，增加 max_response_length

4.3.3 Rollout 配置（推理阶段）

配置项	值	说明	关注点
`n`	`4`	每个 prompt 生成 n 个响应	多样性 vs 成本：越多越好但成本高
`gpu_memory_utilization`	`0.6`	GPU 内存利用率	0.6-0.8 是安全范围
`log_prob_micro_batch_size_per_gpu`	`4`	每个 GPU 的微批次大小	影响推理速度

调优建议：

n=4 是平衡点：足够多样性，成本可控
如果 GPU 内存不足，降低 gpu_memory_utilization 到 0.4-0.5

4.3.4 Actor 配置（训练阶段）

配置项	值	说明	关注点
`ppo_mini_batch_size`	`16`	PPO 小批次大小	通常等于 `train_batch_size`
`ppo_micro_batch_size_per_gpu`	`4`	每个 GPU 的微批次大小	影响训练速度和内存
`optim.lr`	`1e-6`	学习率	关键参数：太小训练慢，太大不稳定
`clip_ratio_low/high`	`0.2/0.3`	PPO clip 范围	控制策略更新幅度
`entropy_coeff`	`0`	熵系数	0 表示不鼓励探索

调优建议：

学习率：从 1e-6 开始，如果训练慢可尝试 2e-6，不稳定则降低到 5e-7
Clip 范围：[0.2, 0.3] 是保守设置，可以尝试 [0.1, 0.4] 增加更新幅度
熵系数：如果 Agent 输出过于单一，可以设置 0.01-0.1 鼓励探索

4.3.5 Model 配置

配置项	值	说明	关注点
`path`	`"Qwen/Qwen2.5-7B-Instruct"`	模型路径	可以是 HuggingFace ID 或本地路径
`enable_gradient_checkpointing`	`True`	梯度检查点	节省内存：用时间换空间
`use_remove_padding`	`True`	移除 padding	提高训练效率

调优建议：

如果内存不足，确保 enable_gradient_checkpointing=True
7B 模型是平衡点：性能好且资源需求适中

4.3.6 Trainer 配置

配置项	值	说明	关注点
`total_epochs`	`100`	总训练轮数	根据数据集大小调整
`save_freq`	`50`	模型保存频率	避免丢失训练进度
`test_freq`	`10`	测试频率	定期评估训练效果
`val_before_train`	`True`	训练前验证	记录基线性能

调优建议：

save_freq 应该小于 total_epochs，避免训练中断丢失进度
test_freq 可以设置更频繁（如 5）以便及时发现问题

4.4 配置调优流程

1. 基线配置
   ├─ 使用默认配置开始训练
   └─ 记录初始性能

2. 内存优化（如果 OOM）
   ├─ 降低 train_batch_size (16 → 8)
   ├─ 降低 gpu_memory_utilization (0.6 → 0.4)
   ├─ 启用 gradient_checkpointing
   └─ 启用 FSDP param_offload

3. 速度优化（如果训练太慢）
   ├─ 增加 train_batch_size (16 → 32)
   ├─ 增加 ppo_micro_batch_size_per_gpu (4 → 8)
   └─ 降低 n (4 → 2)  # 减少推理次数

4. 性能优化（如果奖励不提升）
   ├─ 调整学习率 (1e-6 → 2e-6)
   ├─ 调整 clip_ratio (0.2/0.3 → 0.1/0.4)
   └─ 增加 entropy_coeff (0 → 0.01)

4.5 三种预设配置对比

配置项	默认配置	CI 快速配置	单 GPU 配置
用途	生产环境训练	CI/CD 验证	个人开发
`total_epochs`	100	1	100
`train_batch_size`	16	4	4
`gpu_memory_utilization`	0.6	0.4	0.4
`ppo_mini_batch_size`	16	16	4
`ppo_micro_batch_size_per_gpu`	4	4	1
训练时间	~数小时	~数分钟	~数小时
资源需求	多 GPU	单 GPU	单 GPU

4.6 配置选择指南

选择默认配置，如果：

✅ 有多个 GPU 可用
✅ 需要完整训练流程
✅ 追求最佳性能

选择 CI 快速配置，如果：

✅ 在 CI/CD 流水线中验证
✅ 快速测试配置是否正确
✅ 资源有限但需要快速反馈

选择单 GPU 配置，如果：

✅ 只有单个 GPU
✅ 个人开发环境
✅ 需要长时间训练但资源受限

五、数据集集成：无缝对接

5.1 数据集格式转换

def convert_to_training_format() -> List[Dict[str, Any]]:
    """将任务转换为 Agent Lightning 训练格式"""
    training_data = []
    for task in ALL_TASKS:
        training_data.append({
            "task_id": task["id"],
            "prompt": task["desc"],  # Agent 接收的提示
            "task_type": task["type"],
            "difficulty": task["difficulty"],
            "expected_outputs": task.get("expected_outputs", []),
            "metadata": task,  # 完整任务信息，用于奖励计算
        })
    return training_data

设计要点：

✅ 格式统一：转换为 Agent Lightning 标准格式
✅ 保留元数据：metadata 字段保留完整任务信息
✅ 便于扩展：易于添加新任务

5.2 数据集使用流程

# 1. 加载数据集
train_data = convert_to_training_format()
val_data = train_data[:5]  # 验证集

# 2. 传递给训练器
trainer.fit(
    devops_agent, 
    train_dataset=train_data, 
    val_dataset=val_data
)

# 3. Agent 内部使用
def __call__(self, task: Dict[str, Any]) -> str:
    prompt = task.get("prompt")  # 从数据集获取提示
    output = self.run(prompt)
    
    # 使用 metadata 计算奖励
    task_data = task.get("metadata", task)
    reward = calculate_devops_reward(output, task_data)
    
    return output

六、奖励函数集成：自动评估

6.1 奖励计算流程

# 在 Agent.__call__ 中
def __call__(self, task: Dict[str, Any]) -> str:
    # 1. 执行任务
    output = self.run(prompt)
    
    # 2. 计算奖励
    task_data = task.get("metadata", task)
    reward = calculate_devops_reward(output, task_data)
    
    # 3. 发送奖励信号
    agl.emit_reward(reward)
    
    return output

6.2 奖励函数调用链

Agent.__call__()
    │
    ├─▶ self.run(prompt)  # 生成输出
    │
    └─▶ calculate_devops_reward(output, task_data)
            │
            ├─▶ evaluate_automation(output, task)
            ├─▶ evaluate_reliability(output, task)
            ├─▶ evaluate_security(output, task)
            ├─▶ evaluate_observability(output, task)
            ├─▶ evaluate_documentation(output, task)
            └─▶ check_expected_outputs(output, expected_outputs)
                    │
                    └─▶ 加权求和 → final_reward
                            │
                            └─▶ agl.emit_reward(reward)

七、训练流程：端到端执行

7.1 训练前准备

# 1. 快速验证（可选）
python train_devops_agent.py --mode test

# 2. 基线评估（可选）
python train_devops_agent.py --mode eval

7.2 开始训练

# 默认训练（生产环境）
python train_devops_agent.py --mode train

# CI 快速验证
python train_devops_agent.py --mode ci-fast

# 单 GPU 训练
python train_devops_agent.py --mode single-gpu

# 自定义模型路径
python train_devops_agent.py --mode train --model your-model-path

# 自定义 runner 数量
python train_devops_agent.py --mode train --n-runners 8

7.3 训练日志示例

2025-12-18 14:30:22 | INFO | DevOps Agent Trainer started
2025-12-18 14:30:22 | INFO | Mode: train
2025-12-18 14:30:22 | INFO | ============================================================
2025-12-18 14:30:22 | INFO | DevOps Agent Training - Mode: train
2025-12-18 14:30:22 | INFO | ============================================================
2025-18 14:30:22 | INFO | Loading configuration for mode: train
2025-12-18 14:30:22 | INFO | 
2025-12-18 14:30:22 | INFO | Training Configuration:
2025-12-18 14:30:22 | INFO |   Model: Qwen/Qwen2.5-7B-Instruct
2025-12-18 14:30:22 | INFO |   Algorithm: grpo
2025-12-18 14:30:22 | INFO |   Batch Size: 16
2025-12-18 14:30:22 | INFO |   Total Epochs: 100
2025-12-18 14:30:22 | INFO |   Test Freq: 10
2025-12-18 14:30:22 | INFO |   Runners: 4
2025-12-18 14:30:22 | INFO | 
2025-12-18 14:30:22 | INFO | Loading dataset...
2025-12-18 14:30:22 | INFO | Training samples: 25
2025-12-18 14:30:22 | INFO | Validation samples: 5
2025-12-18 14:30:22 | INFO | 
2025-12-18 14:30:22 | INFO | Initializing VERL algorithm...
2025-12-18 14:30:23 | INFO | Initializing Trainer...
2025-12-18 14:30:23 | INFO | 
2025-12-18 14:30:23 | INFO | ============================================================
2025-12-18 14:30:23 | INFO | Starting Training Loop
2025-12-18 14:30:23 | INFO | ============================================================

八、设计亮点总结

8.1 架构设计亮点

清晰的职责分离

Agent：负责 LLM 调用
奖励函数：负责评估
数据集：负责任务管理
训练器：负责算法执行

可观测性设计
- 双重日志：控制台 + 文件
- 详细分解：奖励分数分解
- 结果保存：JSON 格式便于分析
灵活的配置系统
- 三种预设配置：默认、CI、单 GPU
- 支持自定义模型路径
- 支持调整训练参数
8.2 实现细节亮点
1. 异常处理
```
try:
    agl.emit_reward(reward)
except Exception:
    pass  # 测试模式下忽略
```
2. 日志分级
- 控制台：INFO 级别，简洁输出
- 文件：DEBUG 级别，详细记录

结果保存

results.append({
    "task_id": task["id"],
    "reward": breakdown["final_reward"],
    "breakdown": breakdown,  # 详细分解
    "elapsed_seconds": elapsed,
})

九、实践建议

9.1 训练前准备
1. 检查配置
- ✅ 确认 LLM 配置正确（LLM_CONFIG）
- ✅ 确认数据集路径正确
- ✅ 确认奖励函数正常
- ✅ 确认 VERL 配置合理（内存、批次大小等）
资源检查
- ✅ GPU 内存是否足够（建议 24GB+）
- ✅ 磁盘空间是否足够（模型检查点）
- ✅ 网络连接（如果使用 HuggingFace 模型）
9.2 训练过程监控
1. 查看日志
```
tail -f logs/training_*.log
```
2. 检查结果
```
cat results/eval_results_*.json | jq '.summary'
```
3. 调整 VERL 配置
- 内存不足：降低 train_batch_size、gpu_memory_utilization
- 训练太慢：增加 train_batch_size、ppo_micro_batch_size_per_gpu
- 奖励不提升：调整学习率、clip_ratio、entropy_coeff
- 训练不稳定：降低学习率、启用 use_kl_in_reward
9.3 训练后分析
1. 对比基线
- 训练前 vs 训练后奖励分数
- 不同任务类型的改进情况
分析失败案例
- 找出低分任务
- 分析奖励分解
- 优化奖励函数
十、总结

通过 train_devops_agent.py 的设计，我们实现了一个完整的 RL 训练方案：

核心特点
1. 模块化设计：Agent、奖励函数、数据集分离
2. 可观测性：详细的日志和结果保存
3. 灵活性：多种配置模式适应不同场景
4. 易用性：简单的命令行接口
关键设计决策
- ✅ 自动奖励计算：Agent 内部自动计算奖励
- ✅ 元数据传递：通过 metadata 字段传递完整任务信息
- ✅ 异常处理：优雅处理测试模式下的异常
- ✅ 日志分级：不同场景使用不同日志级别
下一步优化
1. 扩展数据集：从 25 个任务扩展到 100+
2. 优化奖励函数：根据训练效果调整权重
3. 增加评估指标：除了奖励分数，增加其他指标
4. 自动化流程：CI/CD 集成训练流程
附录：快速开始
```
# 1. 进入目录
cd Agent-lightning/examples/devops

# 2. 开始训练（推荐）
python train_devops_agent.py --mode train

# 3. 单 GPU 训练
python train_devops_agent.py --mode single-gpu

# 4. 查看训练日志
tail -f logs/training_*.log

# 5. 监控训练进度
# 查看控制台输出或日志文件中的奖励分数变化
```
相关文件：
- train_devops_agent.py：训练脚本
- reward_functions.py：奖励函数
- tasks_dataset.py：训练数据集
- devops-architect.md：Agent 系统提示词

全球具身智能开发者社区

立足具身智能前沿赛道，致力于搭建全球化、开源化、全栈式技术交流与实践共创平台。

更多推荐

开源聚势·具身启智，杭州这场沙龙给出中国具身智能产业化新答案

全球具身智能开发者社区

YoMo安全机制详解：TLS v1.3如何保护你的AI代理通信

在当今AI驱动的分布式系统中，安全通信已成为不可忽视的核心需求。YoMo作为Serverless AI Agent Framework，采用TLS v1.3加密协议构建了强大的安全防护机制，确保AI代理在地理分布式边缘计算环境中的通信安全。本文将深入解析YoMo的TLS实现原理、配置方法及最佳实践，帮助开发者构建安全可靠的AI应用。## 为什么TLS v1.3是AI代理通信的理想选择TLS

全球具身智能开发者社区

InternScenes开源数据集

数据集介绍 InternScenes 是上海人工智能实验室发布的大规模、可模拟室内场景数据集，论文收录于 NeurIPS 2025。具身人工智能的发展高度依赖于具有场景多样性和逼真布局的大规模、可模拟3D场景数据集。然而，现有数据集通常存在以下不足：数据规模或多样性有限、布局经过"净化"处理导致小物体缺失，以及严重的物体碰撞问题。为解决上述问题，InternScenes 整合

全球具身智能开发者社区

所有评论(0)

查看更多评论

互联网运维杂谈

@hrZUVu

已为社区贡献3条内容

【完结篇】DevOps Agent 从0到1搞强化学习训练实战

互联网运维杂谈

引言：训练一个"会思考"的 DevOps Agent

一、训练架构：三层设计哲学

1.1 整体架构

1.2 核心组件

二、Agent 实现：可训练的接口设计

2.1 DevOpsAgent 类设计

2.2 核心方法：__call__

2.3 日志设计：可观测的训练过程

三、训练模式：RL 训练核心

四、VERL 配置详解：训练的核心关注点

4.1 VERL 配置结构概览

4.2 完整配置解析

4.3 关键配置项详解

4.3.1 Algorithm 配置

4.3.2 Data 配置

4.3.3 Rollout 配置（推理阶段）

4.3.4 Actor 配置（训练阶段）

4.3.5 Model 配置

4.3.6 Trainer 配置

4.4 配置调优流程

4.5 三种预设配置对比

4.6 配置选择指南

五、数据集集成：无缝对接

5.1 数据集格式转换

5.2 数据集使用流程

六、奖励函数集成：自动评估

6.1 奖励计算流程

6.2 奖励函数调用链

七、训练流程：端到端执行

7.1 训练前准备

7.2 开始训练

7.3 训练日志示例

八、设计亮点总结

8.1 架构设计亮点

8.2 实现细节亮点

九、实践建议

9.1 训练前准备

9.2 训练过程监控

9.3 训练后分析

十、总结

核心特点

关键设计决策

下一步优化

附录：快速开始

所有评论(0)

温馨提示：您尚未绑定手机号

互联网运维杂谈

2.2 核心方法：`call`