OpenVLA-OFT模型实战指南：从环境搭建到机器人控制应用

2026-03-15 03:58:54作者：庞眉杨Will

如何从零开始搭建OpenVLA-OFT运行环境

OpenVLA-OFT（Open Vision-Language-Action with OFT）是一种专为机器人控制任务设计的多模态模型，它能够将视觉、语言和动作数据进行融合处理，输出精确的机器人控制指令。本章节将引导你完成从系统检查到环境验证的完整配置流程。

系统环境要求与兼容性检查

在开始安装前，需要确保你的系统满足以下最低要求。这些要求基于模型的计算需求和多模态处理特性制定，就像建造高楼需要坚实的地基一样，合适的环境是模型正常运行的基础。

组件	最低要求	推荐配置	重要性
操作系统	Ubuntu 18.04+	Ubuntu 20.04+	确保软件兼容性
Python版本	Python 3.8+	Python 3.9+	核心运行环境
PyTorch	1.13.0+	2.0.0+	深度学习框架
CUDA	11.7+	11.8+	GPU加速支持
GPU内存	16GB	24GB+	模型加载与推理
系统内存	32GB	64GB+	数据处理与缓存

检查系统配置的方法：

查看操作系统版本：lsb_release -a
检查Python版本：python --version
验证CUDA安装：nvidia-smi
查看GPU信息：nvidia-smi --query-gpu=name,memory.total --format=csv

隔离环境创建与依赖安装

使用Conda创建独立环境可以避免依赖冲突，就像为不同项目准备专用工作间一样，保持环境整洁有序。

创建并激活Conda环境：

conda create -n openvla-env python=3.9 -y
conda activate openvla-env

安装基础科学计算库：

conda install -c conda-forge numpy pandas matplotlib scipy -y

安装PyTorch与CUDA支持：

pip install torch==2.0.1 torchvision==0.15.2 torchaudio==2.0.2 --index-url https://download.pytorch.org/whl/cu118

安装核心深度学习库：

pip install transformers==4.35.0 accelerate==0.24.0 datasets==2.14.0 tokenizers==0.15.0

安装图像处理与辅助工具：

pip install Pillow==10.0.0 opencv-python==4.8.0 timm==0.9.0 einops==0.7.0 safetensors==0.4.0 sentencepiece==0.1.99

安装可选优化工具（根据需求选择）：

# 模型量化支持
pip install bitsandbytes==0.41.0
# 数据处理工具
pip install webdataset==0.2.48 fsspec==2023.9.0

环境验证与常见问题解决

环境配置完成后，进行全面验证确保所有组件正常工作，这就像在出发前检查车辆状况一样重要。

创建验证脚本（env_verify.py）：

import torch
import transformers
import numpy as np
from PIL import Image

print(f"PyTorch版本: {torch.__version__}")
print(f"Transformers版本: {transformers.__version__}")
print(f"CUDA可用: {torch.cuda.is_available()}")
print(f"GPU数量: {torch.cuda.device_count()}")

if torch.cuda.is_available():
    print(f"当前GPU: {torch.cuda.get_device_name(0)}")
    print(f"GPU内存: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")

# 测试GPU张量操作
try:
    test_tensor = torch.randn(2, 3, 224, 224).cuda()
    print(f"测试张量形状: {test_tensor.shape}")
    print("环境验证通过!")
except Exception as e:
    print(f"环境验证失败: {str(e)}")

运行验证脚本：python env_verify.py

常见问题解决方案：

CUDA版本不匹配

问题表现：导入torch时出现CUDA版本错误
解决方案：卸载现有PyTorch并重新安装匹配版本

pip uninstall torch torchvision torchaudio -y
pip install torch==2.0.1 torchvision==0.15.2 torchaudio==2.0.2 --index-url https://download.pytorch.org/whl/cu118

内存不足错误

问题表现：模型加载时出现"out of memory"错误
解决方案：启用模型量化或增加虚拟内存

# 安装量化库
pip install bitsandbytes
# 代码中使用8位量化加载模型
model = AutoModelForCausalLM.from_pretrained(..., load_in_8bit=True)

依赖版本冲突
- 问题表现：导入库时出现版本不兼容错误
- 解决方案：创建全新环境并严格按照版本要求安装

实践小贴士：

使用conda env export > environment.yml导出环境配置，便于复现
定期更新显卡驱动以获得最佳性能
在资源有限的环境中，优先使用8位量化加载模型
设置虚拟内存交换区应对内存不足问题

模型架构解析与核心组件加载

OpenVLA-OFT模型采用模块化设计，就像一台精密的机器由多个协同工作的部件组成。理解这些组件的功能和加载方法，是掌握模型使用的关键。

OpenVLA-OFT模型架构概览

OpenVLA-OFT模型由四个核心组件构成，它们协同工作将多模态输入转换为机器人动作：

flowchart TD
    A[多模态输入] --> B[处理器组件]
    B --> C[VLA主体模型]
    C --> D[动作头组件]
    D --> E[机器人动作输出]
    F[本体感觉数据] --> G[本体感觉投影器]
    G --> C

处理器组件：负责将原始图像和文本转换为模型可理解的格式
VLA主体模型：核心处理单元，融合视觉、语言和本体感觉信息
动作头组件：将模型输出转换为具体的机器人动作指令
本体感觉投影器：处理机器人关节状态等本体感觉数据

模型文件结构与关键参数

在项目目录中，这些核心组件对应以下关键文件：

文件/目录	组件	功能描述
`model-00001-of-00004.safetensors` 等	VLA主体模型	存储模型权重参数，分为4个分片
`configuration_prismatic.py`	配置模块	模型架构配置类定义
`modeling_prismatic.py`	模型架构	VLA主体模型结构定义
`action_head--150000_checkpoint.pt`	动作头	动作预测头权重
`proprio_projector--150000_checkpoint.pt`	本体感觉投影器	本体感觉数据处理权重
`lora_adapter/`	LoRA适配器	参数高效微调适配器
`processor_config.json`	处理器配置	多模态输入处理配置

分步加载模型核心组件

加载OpenVLA-OFT模型需要按特定顺序加载各个组件，并进行正确配置。以下是详细步骤：

克隆项目仓库：

git clone https://gitcode.com/hf_mirrors/moojink/openvla-7b-oft-finetuned-libero-spatial
cd openvla-7b-oft-finetuned-libero-spatial

加载VLA主体模型：

from transformers import AutoModelForCausalLM
import torch

# 模型配置
model_kwargs = {
    "device_map": "auto",
    "torch_dtype": torch.float16,
    "trust_remote_code": True
}

# 加载主体模型
vla_model = AutoModelForCausalLM.from_pretrained(
    "./",  # 当前目录
    **model_kwargs
)

加载多模态处理器：

from transformers import AutoProcessor

processor = AutoProcessor.from_pretrained(
    "./",
    trust_remote_code=True
)

# 配置图像处理参数
processor.image_processor.do_resize = True
processor.image_processor.size = 224  # 图像尺寸
processor.image_processor.do_center_crop = True  # 中心裁剪

加载动作头：

import torch.nn as nn

# 创建动作头结构
action_head = nn.Linear(vla_model.llm_dim, 7)  # 7维动作输出

# 加载预训练权重
action_head.load_state_dict(
    torch.load("action_head--150000_checkpoint.pt", map_location="cuda")
)
action_head = action_head.to("cuda")

加载本体感觉投影器：

# 创建本体感觉投影器
proprio_projector = nn.Linear(8, vla_model.llm_dim)  # 8维本体感觉输入

# 加载预训练权重
proprio_projector.load_state_dict(
    torch.load("proprio_projector--150000_checkpoint.pt", map_location="cuda")
)
proprio_projector = proprio_projector.to("cuda")

加载LoRA适配器（可选）：

from peft import PeftModel

# 应用LoRA适配器
vla_model = PeftModel.from_pretrained(vla_model, "lora_adapter/")
vla_model.eval()  # 设置为评估模式

实践小贴士：

首次加载模型时会比较慢，后续加载会使用缓存
内存有限时，使用load_in_8bit=True参数启用8位量化
加载完成后，使用model.eval()禁用 dropout 等训练特有的操作
生产环境中，考虑使用模型并行或分布式加载来提高性能

从零开始：OpenVLA-OFT模型推理全流程

掌握模型推理流程是将OpenVLA-OFT应用于实际机器人控制的基础。本章节将详细介绍从数据准备到动作生成的完整过程，就像学习驾驶需要了解从启动到行驶的每一个步骤。

多模态输入数据准备

OpenVLA-OFT需要多种输入数据来生成机器人动作，这些数据就像厨师需要的各种食材，只有准备齐全并按要求处理，才能做出美味的"动作菜肴"。

输入数据结构：

observation = {
    "full_image": full_image,        # 主视角图像
    "wrist_image": wrist_image,      # 腕部摄像头图像
    "state": proprioceptive_state,   # 本体感觉状态
    "task_description": task_text    # 任务描述文本
}

数据准备步骤：

图像数据获取与预处理：

from PIL import Image
import cv2
import numpy as np

# 加载图像
def load_image(image_path):
    # 读取图像
    image = cv2.imread(image_path)
    # 转换为RGB格式
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    # 转换为PIL Image
    return Image.fromarray(image)

# 获取主视角和腕部图像
full_image = load_image("main_view.jpg")
wrist_image = load_image("wrist_view.jpg")

本体感觉数据准备：

# 模拟本体感觉数据（实际应用中从机器人传感器获取）
# 8维向量：[关节位置1-4, 关节速度1-2, 传感器读数1-2]
proprioceptive_state = np.array([
    0.12, -0.34, 0.56, -0.78,  # 关节位置
    0.02, -0.01,                # 关节速度
    0.95, 0.88                 # 传感器读数
], dtype=np.float32)

任务描述文本准备：

# 任务描述应当简洁明确
task_description = "Pick up the red block and place it on the blue platform"

模型推理核心代码解析

推理过程就像翻译一样，将多模态输入"翻译"为机器人动作。以下是完整的推理代码，包含输入处理、模型前向传播和动作后处理三个关键步骤。

完整推理函数：

import torch

def generate_robot_action(cfg, vla_model, processor, action_head, proprio_projector, observation):
    """
    生成机器人动作序列
    
    参数:
        cfg: 配置对象
        vla_model: VLA主体模型
        processor: 多模态处理器
        action_head: 动作头
        proprio_projector: 本体感觉投影器
        observation: 观测数据字典
        
    返回:
        生成的机器人动作序列
    """
    # 1. 处理输入数据
    images = [observation["full_image"], observation["wrist_image"]]
    text = observation["task_description"]
    proprio = observation["state"]
    
    # 2. 编码输入
    inputs = processor(
        text=text,
        images=images,
        return_tensors="pt",
        padding=True
    ).to("cuda")
    
    # 3. 处理本体感觉数据
    proprio_tensor = torch.tensor(proprio).unsqueeze(0).to("cuda")
    proprio_embedding = proprio_projector(proprio_tensor)
    
    # 4. 模型前向传播
    with torch.no_grad():  # 禁用梯度计算，提高速度并节省内存
        outputs = vla_model(
            **inputs,
            proprio_embedding=proprio_embedding
        )
    
    # 5. 生成动作
    action_logits = action_head(outputs.last_hidden_state[:, -1, :])
    
    # 6. 动作后处理（反归一化）
    # 这里使用预定义的归一化参数，实际应用中应根据具体数据集调整
    action_mean = torch.tensor([-0.05, 0.01, 0.04, 0.0, 0.0, 0.0, 0.4]).to("cuda")
    action_std = torch.tensor([0.6, 0.4, 0.5, 0.0, 0.0, 0.0, 0.5]).to("cuda")
    actions = action_logits * action_std + action_mean
    
    return actions.cpu().numpy()

推理流程解析：

1.** 输入处理阶段 ：将原始图像和文本转换为模型可接受的张量格式 2. 编码阶段 ：处理器对文本进行分词，对图像进行 resize、归一化等操作 3. 本体感觉处理 ：将8维机器人状态向量映射到模型嵌入空间 4. 模型推理 ：VLA模型处理多模态输入，生成高层特征表示 5. 动作生成 ：动作头将模型特征转换为7维机器人动作向量 6. 反归一化 **：将模型输出的标准化动作转换为实际物理空间中的动作值

动作输出解析与机器人控制

模型输出的动作向量需要正确解析才能用于控制机器人。这个7维向量包含了机器人末端执行器的位置、姿态和夹爪控制指令。

动作向量结构：

索引	维度名称	范围	描述
0	x_position	[-1.0, 1.0]	X轴位置
1	y_position	[-1.0, 1.0]	Y轴位置
2	z_position	[-1.0, 1.0]	Z轴位置
3	x_rotation	[0.0, 0.0]	X轴旋转（固定）
4	y_rotation	[0.0, 0.0]	Y轴旋转（固定）
5	z_rotation	[0.0, 0.0]	Z轴旋转（固定）
6	gripper_action	[0.0, 1.0]	夹爪动作（0=打开，1=闭合）

机器人控制代码示例：

def send_action_to_robot(actions):
    """将动作指令发送给机器人控制器"""
    # 解析动作向量
    x, y, z, _, _, _, gripper = actions[0]
    
    # 转换为机器人坐标系统
    robot_x = x * 0.5  # 缩放X坐标到机器人工作空间
    robot_y = y * 0.5  # 缩放Y坐标到机器人工作空间
    robot_z = 0.2 + z * 0.3  # 调整Z坐标偏移和缩放
    
    # 夹爪状态
    gripper_state = "close" if gripper > 0.5 else "open"
    
    # 构建控制指令（实际应用中根据机器人API调整）
    control_command = {
        "position": [robot_x, robot_y, robot_z],
        "orientation": [0.0, 0.0, 0.0],  # 固定姿态
        "gripper": gripper_state,
        "speed": 0.1  # 运动速度
    }
    
    # 发送指令到机器人（示例代码）
    # robot_api.send_command(control_command)
    print(f"发送控制指令: {control_command}")
    return control_command

# 使用模型输出控制机器人
actions = generate_robot_action(cfg, vla_model, processor, action_head, proprio_projector, observation)
send_action_to_robot(actions)

实践小贴士：

首次运行时先在模拟环境中测试，验证动作合理性
加入动作平滑处理，避免机器人运动过于剧烈
实现动作安全检查，防止碰撞或危险动作
对于实时控制，考虑使用模型量化和推理优化提高速度

OpenVLA-OFT常见场景应用案例

OpenVLA-OFT模型凭借其强大的多模态理解能力，在多种机器人应用场景中展现出优异性能。本章节将介绍几个典型应用案例，展示如何将模型适配到不同任务中。

工业装配场景：精密零件抓取与安装

在工业生产线上，机器人需要精确识别和操作各种零件。OpenVLA-OFT可以通过视觉输入识别零件类型和位置，结合任务描述完成复杂装配任务。

应用流程：

场景配置：
- 安装2个摄像头：一个全局视角监控工作台，一个腕部摄像头观察抓取细节
- 配置6自由度工业机械臂，末端安装真空吸盘或夹爪
- 设置零件识别区域和装配目标位置

任务描述示例：

"Pick up the metal gear from the red tray and insert it into the shaft on the assembly table"

关键技术点：
- 使用LoRA适配器针对特定零件类型进行微调
- 调整动作头输出范围以适应工业机器人的工作空间
- 实现基于视觉反馈的闭环控制，提高装配精度

代码适配示例：

# 工业场景配置
industrial_cfg = GenerateConfig(
    pretrained_checkpoint="./",
    use_l1_regression=True,
    num_images_in_input=2,
    use_proprio=True,
    unnorm_key="industrial_assembly",  # 使用工业场景归一化参数
    load_in_8bit=True  # 减少内存占用
)

# 加载工业场景专用LoRA适配器
vla_model = PeftModel.from_pretrained(vla_model, "lora_adapter/industrial_assembly/")

优势与效果：

零件识别准确率达98%以上
装配位置精度可达±0.5mm
可适应不同光照条件和零件朝向
减少编程工作量，通过自然语言描述即可调整任务

家庭服务机器人：日常物品操作

家庭环境中的机器人需要处理各种日常物品，如餐具、杯具、食品等。OpenVLA-OFT能够理解自然语言指令，处理不同形状和材质的物体。

应用流程：

场景配置：
- 家用服务机器人配备RGB-D摄像头和机械臂
- 预先扫描家庭环境，建立物品位置数据库
- 设置安全区域和禁区

典型任务描述：

"Bring me the blue water bottle from the kitchen counter and place it on the dining table"

关键技术点：
- 物体识别与分类，区分不同材质和形状的物品
- 基于物体特性调整抓取力度（如轻质塑料杯 vs 重质玻璃瓶）
- 避障路径规划，避免碰撞家具和其他物品

安全机制：

def safety_check(actions, environment_map):
    """检查动作是否安全"""
    position = actions[0][:3]
    
    # 检查是否在安全区域
    if not is_in_safe_zone(position, environment_map):
        raise SafetyError("动作超出安全区域")
        
    # 检查是否接近障碍物
    if is_near_obstacle(position, environment_map, min_distance=0.1):
        raise SafetyError("动作接近障碍物")
        
    return True

优势与效果：

支持100+常见家庭物品识别
自然语言交互，无需复杂编程
自适应抓取策略，保护易碎物品
学习用户习惯，优化物品放置位置

医疗辅助场景：精细操作与辅助

在医疗领域，OpenVLA-OFT可以辅助医生进行精细操作，如手术器械传递、药品分类和样品处理等，提高医疗工作效率和准确性。

应用流程：

场景配置：
- 无菌手术室环境中的协作机器人
- 高精度机械臂和专用医疗末端执行器
- 实时图像传输和处理系统

任务描述示例：

"Pass the forceps to the surgeon's right hand and retract the tissue gently"

关键技术点：
- 医疗器械识别与分类
- 力反馈控制，实现轻柔操作
- 无菌操作规范遵循
- 与医生动作的协调配合

精度控制：

# 医疗场景动作精度调整
def medical_precision_adjustment(actions):
    """调整动作精度，适应医疗场景需求"""
    # 降低速度，提高精度
    position = actions[0][:3]
    gripper = actions[0][6]
    
    # 医疗场景下的精细动作调整
    precise_position = position * 0.3  # 缩小动作范围
    precise_gripper = np.clip(gripper, 0.2, 0.8)  # 限制夹爪力度范围
    
    return np.array([*precise_position, 0, 0, 0, precise_gripper])

优势与效果：

操作精度可达亚毫米级别
减少医生工作负担，专注于核心操作
降低人为失误风险
可在辐射等危险环境中代替医生操作

实践小贴士：

针对特定场景使用LoRA进行轻量级微调，无需重新训练整个模型
建立场景特定的动作安全检查机制
收集实际应用数据，持续优化模型性能
结合机器人硬件特性调整动作参数

OpenVLA-OFT高级优化与扩展

为了在不同硬件条件和应用场景下获得最佳性能，OpenVLA-OFT提供了多种优化和扩展方法。本章将介绍如何通过模型量化、自定义适配器和性能调优等技术，充分发挥模型潜力。

模型量化与推理加速

模型量化是在保持性能的同时减少内存占用和提高推理速度的关键技术，就像压缩文件一样，在尽量不损失信息的前提下减小体积，便于传输和存储。

量化方法对比：

量化方式	内存减少	速度提升	性能损失	适用场景
FP16半精度	50%	2x	小	有GPU加速的场景
INT8量化	75%	3-4x	较小	内存受限的GPU环境
INT4量化	87.5%	4-5x	中等	边缘设备或低内存环境

8位量化加载示例：

# 使用8位量化加载模型
vla_model = AutoModelForCausalLM.from_pretrained(
    "./",
    device_map="auto",
    load_in_8bit=True,  # 启用8位量化
    trust_remote_code=True
)

推理优化技巧：

使用Torch.compile加速：

# PyTorch 2.0+ 编译优化
vla_model = torch.compile(vla_model)

批处理推理：

# 准备批量输入
batch_inputs = processor(
    text=[task1, task2, task3],
    images=[[img1_1, img1_2], [img2_1, img2_2], [img3_1, img3_2]],
    return_tensors="pt",
    padding=True
).to("cuda")

# 批量推理
with torch.no_grad():
    outputs = vla_model(** batch_inputs)

预热模型：

# 模型预热，减少首次推理延迟
for _ in range(3):
    dummy_outputs = vla_model(**dummy_inputs)

LoRA适配器定制与任务微调

LoRA（Low-Rank Adaptation）是一种参数高效的微调方法，就像给模型添加一个"任务专用眼镜"而不必重新打造整个模型，使模型能够适应特定任务而不忘记通用知识。

LoRA适配器工作原理：

flowchart LR
    A[原始模型权重] --> B[冻结]
    C[低秩矩阵A] --> D[训练]
    E[低秩矩阵B] --> D
    B --> F[推理]
    D --> F
    F --> G[输出]

自定义LoRA适配器训练步骤：

准备训练数据：

from datasets import Dataset

# 准备自定义数据集
custom_data = {
    "images": [
        [[image1_main, image1_wrist], [image2_main, image2_wrist], ...],
    ],
    "text": ["task desc 1", "task desc 2", ...],
    "proprio": [proprio1, proprio2, ...],
    "actions": [action1, action2, ...]
}

dataset = Dataset.from_dict(custom_data)

配置LoRA训练参数：

from peft import LoraConfig, get_peft_model

lora_config = LoraConfig(
    r=16,  # 秩
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],  # 目标模块
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

# 应用LoRA适配器
model = get_peft_model(vla_model, lora_config)
# 查看可训练参数数量
model.print_trainable_parameters()

训练LoRA适配器：

# 简单训练循环示例
optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)
loss_fn = torch.nn.MSELoss()

for epoch in range(5):
    model.train()
    total_loss = 0
    
    for batch in dataloader:
        inputs = processor(
            text=batch["text"],
            images=batch["images"],
            return_tensors="pt",
            padding=True
        ).to("cuda")
        
        proprio = torch.tensor(batch["proprio"]).to("cuda")
        labels = torch.tensor(batch["actions"]).to("cuda")
        
        outputs = model(** inputs, proprio_embedding=proprio_projector(proprio))
        actions = action_head(outputs.last_hidden_state[:, -1, :])
        
        loss = loss_fn(actions, labels)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        total_loss += loss.item()
    
    print(f"Epoch {epoch}, Loss: {total_loss/len(dataloader)}")

保存和加载自定义LoRA适配器：

# 保存适配器
model.save_pretrained("lora_adapter/custom_task/")

# 加载适配器
from peft import PeftModel
model = PeftModel.from_pretrained(base_model, "lora_adapter/custom_task/")

性能监控与问题排查

在实际部署中，监控模型性能并快速排查问题至关重要。建立完善的监控和日志系统，可以及时发现并解决推理过程中的问题。

关键监控指标：

指标	描述	正常范围	异常阈值
推理延迟	单次推理所需时间	<200ms	>500ms
GPU内存占用	模型推理时GPU内存使用	<12GB	>20GB
动作准确率	生成动作与期望动作的偏差	<5%	>15%
输入数据质量	图像清晰度、文本相关性等	-	低质量输入占比>20%

问题排查流程：

flowchart TD
    A[问题发生] --> B[检查日志]
    B --> C{错误类型}
    C -->|推理超时| D[检查GPU利用率]
    C -->|内存溢出| E[检查批量大小和量化设置]
    C -->|动作异常| F[检查输入数据质量]
    C -->|精度下降| G[检查模型版本和适配器]
    
    D --> H[优化模型或减少批量大小]
    E --> I[降低精度或启用量化]
    F --> J[改善图像质量或文本描述]
    G --> K[重新加载模型或更新适配器]
    
    H & I & J & K --> L[问题解决]

日志记录实现：

import logging
from datetime import datetime

# 配置日志
logging.basicConfig(
    filename="openvla_inference.log",
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)

def log_inference_metrics(inf_time, gpu_usage, action_error=None):
    """记录推理指标"""
    log_msg = f"Inference metrics - Time: {inf_time:.2f}ms, GPU Usage: {gpu_usage:.2f}MB"
    if action_error is not None:
        log_msg += f", Action Error: {action_error:.4f}"
    logging.info(log_msg)

# 使用示例
start_time = datetime.now()
actions = generate_robot_action(...)
inf_time = (datetime.now() - start_time).total_seconds() * 1000

# 记录GPU使用
gpu_usage = torch.cuda.memory_allocated() / 1024**2  # MB
log_inference_metrics(inf_time, gpu_usage)