Pi0机器人控制中心进阶教程：集成OpenCV实时视频流替代静态图像上传

Pi0机器人控制中心进阶教程：集成OpenCV实时视频流替代静态图像上传

1. 从静态到动态：为什么需要实时视频流？

如果你已经体验过Pi0机器人控制中心，一定会被它强大的视觉-语言-动作推理能力所震撼。上传三张不同角度的照片，输入一句“捡起红色方块”，它就能预测出机器人下一步该怎么动。这很酷，对吧？

但你可能也发现了问题：每次想让机器人执行新动作，都得重新拍照、上传、等待推理。整个过程像在玩“一帧一帧”的定格动画，离真正的实时操控还差一步。

想象一下这个场景：机器人正在桌上整理积木，你想让它换个方式摆放。按照现在的流程，你需要：

1. 暂停机器人
2. 用相机拍三张新角度的照片
3. 上传到控制中心
4. 等待AI推理
5. 执行新动作

等你完成这些步骤，机器人可能已经错过了最佳操作时机。这就是静态图像上传的局限性——它无法捕捉动态变化的环境。

实时视频流能解决什么？

• 环境变化实时感知：机器人能看到物体移动、位置变化
• 连续动作规划：AI可以根据连续画面预测一系列动作
• 交互更自然：就像你在用眼睛看、用大脑思考一样流畅
• 减少人工干预：不用频繁拍照上传，系统自动获取最新画面

本教程将带你一步步改造Pi0控制中心，让它从“看照片”升级到“看直播”，实现真正的实时视觉反馈。

2. 准备工作：理解现有架构

在动手改造之前，我们先快速回顾一下Pi0控制中心的核心工作流程：

2.1 当前的数据流

静态图像上传 → 图像预处理 → Pi0模型推理 → 动作预测 → 界面显示

关键点在于“静态图像上传”这一步。在app_web.py中，这部分代码大致是这样的：

# 当前的上传组件（简化版） main_camera = gr.Image(label="主视角", type="pil") side_camera = gr.Image(label="侧视角", type="pil") top_camera = gr.Image(label="俯视角", type="pil") # 推理函数 def predict_action(main_img, side_img, top_img, joint_state, instruction): # 1. 图像预处理 processed_images = preprocess_images([main_img, side_img, top_img]) # 2. 调用Pi0模型 action_prediction = pi0_model.predict( images=processed_images, joint_state=joint_state, instruction=instruction ) return action_prediction

2.2 我们需要改变什么

目标是将上面的流程改为：

摄像头实时画面 → OpenCV捕获 → 图像帧提取 → Pi0模型推理 → 动作预测 → 界面显示 ↑ （连续循环）

这意味着我们需要：

1. 接入摄像头：用OpenCV连接物理摄像头或视频文件
2. 实时帧捕获：以固定频率获取最新画面
3. 多路视频处理：同时处理三个视角的视频流
4. 与Gradio集成：让实时画面显示在Web界面上
5. 保持推理性能：确保实时处理不会拖慢AI推理速度

3. 核心改造：集成OpenCV视频流

3.1 安装必要的依赖

首先确保你的环境有OpenCV。如果还没有安装，执行：

pip install opencv-python opencv-contrib-python

对于Pi0控制中心的环境，你可能还需要：

pip install numpy pillow gradio

3.2 创建视频流管理器

我们需要一个专门管理视频流的类。在项目目录下创建video_stream.py：

import cv2 import threading import time from queue import Queue from typing import Optional, Tuple import numpy as np class VideoStreamManager: """管理多路视频流的类""" def __init__(self, camera_ids: list = [0, 1, 2], fps: int = 10): """ 初始化视频流管理器 参数: camera_ids: 摄像头ID列表，[主视角, 侧视角, 俯视角] fps: 目标帧率 """ self.camera_ids = camera_ids self.fps = fps self.frame_interval = 1.0 / fps # 存储摄像头对象 self.caps = [] # 存储最新帧 self.latest_frames = [None, None, None] # 线程控制 self.running = False self.threads = [] # 初始化摄像头 self._init_cameras() def _init_cameras(self): """初始化所有摄像头""" print("正在初始化摄像头...") for i, cam_id in enumerate(self.camera_ids): try: cap = cv2.VideoCapture(cam_id) if not cap.isOpened(): print(f"警告: 无法打开摄像头 {cam_id}") self.caps.append(None) else: # 设置摄像头参数（根据你的摄像头调整） cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480) cap.set(cv2.CAP_PROP_FPS, self.fps) self.caps.append(cap) print(f"摄像头 {cam_id} 初始化成功") except Exception as e: print(f"摄像头 {cam_id} 初始化失败: {e}") self.caps.append(None) def _capture_thread(self, camera_index: int): """单个摄像头的捕获线程""" cap = self.caps[camera_index] if cap is None: return last_capture_time = time.time() while self.running: current_time = time.time() # 控制帧率 if current_time - last_capture_time >= self.frame_interval: ret, frame = cap.read() if ret: # 转换颜色空间 BGR -> RGB frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) self.latest_frames[camera_index] = frame_rgb last_capture_time = current_time # 避免CPU占用过高 time.sleep(0.001) def start(self): """启动所有视频流""" if self.running: return self.running = True self.threads = [] for i in range(len(self.caps)): if self.caps[i] is not None: thread = threading.Thread( target=self._capture_thread, args=(i,), daemon=True ) thread.start() self.threads.append(thread) print("视频流已启动") def stop(self): """停止所有视频流""" self.running = False # 等待线程结束 for thread in self.threads: thread.join(timeout=2.0) # 释放摄像头 for cap in self.caps: if cap is not None: cap.release() print("视频流已停止") def get_frames(self) -> list: """获取所有摄像头的最新帧""" return self.latest_frames.copy() def get_frame(self, camera_index: int) -> Optional[np.ndarray]: """获取指定摄像头的最新帧""" if 0 <= camera_index < len(self.latest_frames): return self.latest_frames[camera_index] return None def is_ready(self) -> bool: """检查是否至少有一个摄像头正常工作""" return any(frame is not None for frame in self.latest_frames) # 单例模式，方便全局访问 video_manager = VideoStreamManager()

3.3 修改主程序集成视频流

现在我们需要修改app_web.py，将视频流集成到Gradio界面中。主要改动包括：

3.3.1 添加视频流组件

# 在文件开头导入 from video_stream import video_manager import cv2 from PIL import Image import numpy as np # 修改界面组件定义 def create_interface(): with gr.Blocks(css=css_content, theme=gr.themes.Soft()) as demo: # ... 其他组件保持不变 ... with gr.Row(): with gr.Column(scale=1): # 原来的图像上传组件改为视频显示组件 with gr.Tab("实时视频"): main_video = gr.Image( label="主视角实时画面", interactive=False, height=240 ) side_video = gr.Image( label="侧视角实时画面", interactive=False, height=240 ) top_video = gr.Image( label="俯视角实时画面", interactive=False, height=240 ) with gr.Row(): start_btn = gr.Button("启动摄像头", variant="primary") stop_btn = gr.Button("停止摄像头", variant="secondary") capture_btn = gr.Button("捕获当前画面", variant="primary") # 保留原来的上传标签（兼容模式） with gr.Tab("手动上传"): main_upload = gr.Image(label="主视角", type="pil") side_upload = gr.Image(label="侧视角", type="pil") top_upload = gr.Image(label="俯视角", type="pil") # ... 其他输入组件保持不变 ... # ... 结果面板保持不变 ... return demo

3.3.2 添加视频流控制函数

# 视频流控制函数 def start_video_streams(): """启动所有摄像头""" try: video_manager.start() # 等待摄像头就绪 for _ in range(50): # 最多等待5秒 if video_manager.is_ready(): return "摄像头已启动" time.sleep(0.1) return "摄像头启动，但未检测到画面" except Exception as e: return f"启动失败: {str(e)}" def stop_video_streams(): """停止所有摄像头""" try: video_manager.stop() return "摄像头已停止" except Exception as e: return f"停止失败: {str(e)}" def capture_current_frames(): """捕获当前画面并返回图像""" frames = video_manager.get_frames() # 转换为PIL图像 pil_images = [] for i, frame in enumerate(frames): if frame is not None: pil_img = Image.fromarray(frame) pil_images.append(pil_img) else: pil_images.append(None) # 返回三个图像（用于更新手动上传组件） return pil_images[0], pil_images[1], pil_images[2] def update_video_displays(): """更新视频显示（周期性调用）""" frames = video_manager.get_frames() return frames[0], frames[1], frames[2]

3.3.3 修改推理函数支持视频流

def predict_action(main_img, side_img, top_img, joint_state, instruction, use_live_video=False): """ 预测机器人动作 参数: use_live_video: 是否使用实时视频流 """ # 如果使用实时视频，从视频管理器获取最新帧 if use_live_video: frames = video_manager.get_frames() if frames[0] is not None: main_img = Image.fromarray(frames[0]) if frames[1] is not None: side_img = Image.fromarray(frames[1]) if frames[2] is not None: top_img = Image.fromarray(frames[2]) # 检查是否有有效的图像输入 if main_img is None or side_img is None or top_img is None: return "错误: 请提供所有视角的图像", None, None try: # 图像预处理 processed_images = preprocess_images([main_img, side_img, top_img]) # 调用Pi0模型（这里需要根据你的实际模型调整） # action_prediction = pi0_model.predict(...) # 模拟预测结果 action_prediction = { 'joint_actions': [0.1, -0.2, 0.3, 0.05, -0.1, 0.15], 'confidence': 0.87 } # 格式化为显示 action_text = "预测动作:\n" for i, action in enumerate(action_prediction['joint_actions']): action_text += f"关节{i+1}: {action:.3f}\n" action_text += f"\n置信度: {action_prediction['confidence']:.2%}" # 这里可以添加特征可视化数据 features = generate_feature_visualization(processed_images) return action_text, features, "success" except Exception as e: return f"推理错误: {str(e)}", None, "error"

3.3.4 设置事件处理

# 在demo创建后设置事件处理 demo = create_interface() # 视频控制事件 start_btn.click( fn=start_video_streams, outputs=gr.Textbox(label="状态", visible=True) ) stop_btn.click( fn=stop_video_streams, outputs=gr.Textbox(label="状态", visible=True) ) capture_btn.click( fn=capture_current_frames, outputs=[main_upload, side_upload, top_upload] ) # 添加一个周期性更新视频显示的函数 def video_update_loop(): """周期性更新视频显示""" while True: frames = video_manager.get_frames() yield frames[0], frames[1], frames[2] time.sleep(0.1) # 100ms更新一次 # 创建实时视频更新 demo.load( fn=lambda: (None, None, None), outputs=[main_video, side_video, top_video] ) # 添加一个定时器定期更新视频（需要Gradio支持） # 注意：Gradio的gr.Timer在较新版本中可用

4. 完整集成方案

4.1 创建新的主程序文件

为了保持代码清晰，建议创建一个新的主程序文件app_web_live.py，整合所有改动：

""" Pi0机器人控制中心 - 实时视频流版本 基于OpenCV实现多摄像头实时画面捕获 """ import gradio as gr import cv2 import numpy as np from PIL import Image import time import threading import json import torch from datetime import datetime # 自定义模块 from video_stream import VideoStreamManager # 初始化视频流管理器 video_manager = VideoStreamManager(camera_ids=[0, 1, 2], fps=15) # CSS样式（保持原有样式） css_content = """ /* 原有CSS样式保持不变 */ .container { max-width: 100% !important; padding: 20px; } """ class Pi0LiveController: """Pi0实时控制器""" def __init__(self, config_path="config.json"): self.config = self.load_config(config_path) self.model = None self.is_running = False # 加载模型（根据实际情况实现） # self.load_model() def load_config(self, config_path): """加载配置文件""" try: with open(config_path, 'r') as f: return json.load(f) except: # 默认配置 return { "model": "pi0-vla", "input_size": [224, 224], "joint_count": 6 } def preprocess_image(self, image): """预处理图像供模型使用""" if image is None: return None # 转换为numpy数组 if isinstance(image, Image.Image): img_np = np.array(image) else: img_np = image # 调整大小 target_size = self.config["input_size"] img_resized = cv2.resize(img_np, (target_size[1], target_size[0])) # 归一化等处理 img_normalized = img_resized.astype(np.float32) / 255.0 # 转换为模型需要的格式 # 这里需要根据实际模型调整 return img_normalized def predict(self, images, joint_state, instruction): """执行预测""" # 这里实现实际的模型推理 # 目前返回模拟数据 # 模拟处理时间 time.sleep(0.1) # 模拟预测结果 return { 'actions': np.random.randn(6).tolist(), 'confidence': 0.85 + np.random.rand() * 0.1, 'timestamp': datetime.now().isoformat() } def create_interface(): """创建Gradio界面""" controller = Pi0LiveController() with gr.Blocks(css=css_content, theme=gr.themes.Soft(), title="Pi0机器人控制中心 - 实时版") as demo: # 标题和状态栏 gr.Markdown("# Pi0机器人控制中心 - 实时视频流版") with gr.Row(): status_display = gr.Textbox( label="系统状态", value="就绪", interactive=False ) with gr.Row(): with gr.Column(scale=1): # 视频控制面板 gr.Markdown("## 📹 视频流控制") with gr.Row(): start_btn = gr.Button(" 启动摄像头", variant="primary") stop_btn = gr.Button("⏹ 停止摄像头", variant="secondary") capture_btn = gr.Button("📸 捕获画面", variant="primary") video_status = gr.Textbox(label="视频状态", interactive=False) # 实时视频显示 gr.Markdown("### 实时画面") with gr.Row(): main_video = gr.Image( label="主视角", interactive=False, height=200, show_label=True ) side_video = gr.Image( label="侧视角", interactive=False, height=200, show_label=True ) top_video = gr.Image( label="俯视角", interactive=False, height=200, show_label=True ) # 手动上传（备用） gr.Markdown("### 手动上传（备用）") with gr.Row(): main_upload = gr.Image(label="主视角", type="pil") side_upload = gr.Image(label="侧视角", type="pil") top_upload = gr.Image(label="俯视角", type="pil") with gr.Column(scale=1): # 控制输入面板 gr.Markdown("## 🎮 控制输入") # 关节状态输入 gr.Markdown("### 关节当前状态") joint_inputs = [] with gr.Row(): for i in range(6): joint_inputs.append( gr.Number( label=f"关节{i+1}", value=0.0, minimum=-3.14, maximum=3.14 ) ) # 任务指令 gr.Markdown("### 任务指令") instruction_input = gr.Textbox( label="输入指令", placeholder="例如：捡起红色方块，放到蓝色区域", lines=2 ) # 推理模式选择 gr.Markdown("### 推理设置") with gr.Row(): use_live_video = gr.Checkbox( label="使用实时视频", value=True, interactive=True ) auto_predict = gr.Checkbox( label="自动连续推理", value=False, interactive=True ) predict_btn = gr.Button(" 执行推理", variant="primary", size="lg") with gr.Row(): with gr.Column(scale=1): # 结果输出面板 gr.Markdown("## 推理结果") action_output = gr.Textbox( label="预测动作", interactive=False, lines=8 ) confidence_display = gr.Number( label="置信度", interactive=False ) # 特征可视化（占位） gr.Markdown("### 视觉特征") feature_display = gr.Plot(label="特征图") with gr.Column(scale=1): # 日志和历史 gr.Markdown("## 操作日志") log_display = gr.Textbox( label="日志", interactive=False, lines=15, max_lines=20 ) # ========== 事件处理 ========== # 视频控制 def start_cameras(): try: video_manager.start() time.sleep(1) # 等待摄像头初始化 # 检查摄像头状态 frames = video_manager.get_frames() ready_cams = sum(1 for f in frames if f is not None) return f"摄像头已启动 ({ready_cams}/3 个摄像头就绪)" except Exception as e: return f"启动失败: {str(e)}" def stop_cameras(): try: video_manager.stop() return "摄像头已停止" except Exception as e: return f"停止失败: {str(e)}" def capture_frames(): frames = video_manager.get_frames() pil_images = [] for frame in frames: if frame is not None: pil_images.append(Image.fromarray(frame)) else: pil_images.append(None) # 同时更新手动上传组件 return pil_images[0], pil_images[1], pil_images[2] # 视频流更新函数 def update_video_stream(): frames = video_manager.get_frames() return frames[0], frames[1], frames[2] # 推理函数 def execute_prediction(*args): # 解析参数 joint_values = args[:6] instruction = args[6] use_live = args[7] # 获取图像 if use_live: frames = video_manager.get_frames() images = [] for frame in frames: if frame is not None: images.append(Image.fromarray(frame)) else: images.append(None) else: images = [args[8], args[9], args[10]] # 手动上传的图像 # 检查图像 if any(img is None for img in images): return "错误: 请确保所有视角都有图像", 0.0, "请检查摄像头或上传图像" # 执行预测 try: result = controller.predict(images, joint_values, instruction) # 格式化输出 action_text = "预测的关节动作:\n" for i, action in enumerate(result['actions']): action_text += f"关节{i+1}: {action:.4f}\n" # 日志 log_entry = f"[{datetime.now().strftime('%H:%M:%S')}] 执行推理\n" log_entry += f"指令: {instruction}\n" log_entry += f"置信度: {result['confidence']:.2%}\n" return action_text, result['confidence'], log_entry except Exception as e: error_msg = f"推理错误: {str(e)}" return error_msg, 0.0, error_msg # 绑定事件 start_btn.click( fn=start_cameras, outputs=video_status ) stop_btn.click( fn=stop_cameras, outputs=video_status ) capture_btn.click( fn=capture_frames, outputs=[main_upload, side_upload, top_upload] ) # 推理按钮 predict_inputs = joint_inputs + [ instruction_input, use_live_video, main_upload, side_upload, top_upload ] predict_btn.click( fn=execute_prediction, inputs=predict_inputs, outputs=[action_output, confidence_display, log_display] ) # 实时视频更新（使用Gradio的流式更新） # 注意：这需要Gradio的gr.Timer组件，具体实现取决于Gradio版本 return demo def main(): """主函数""" print("启动Pi0机器人控制中心（实时视频流版）...") # 创建界面 demo = create_interface() # 启动服务 demo.launch( server_name="0.0.0.0", server_port=8080, share=False, debug=True ) if __name__ == "__main__": main()

4.2 创建启动脚本

创建start_live.sh启动脚本：

#!/bin/bash # Pi0机器人控制中心 - 实时视频流版启动脚本 echo "========================================" echo "Pi0机器人控制中心 - 实时视频流版" echo "========================================" # 检查依赖 echo "检查Python依赖..." python -c "import gradio, cv2, torch, numpy, PIL" 2>/dev/null if [ $? -ne 0 ]; then echo "缺少依赖，正在安装..." pip install gradio opencv-python torch numpy Pillow fi # 检查摄像头 echo "检查摄像头..." python -c " import cv2 for i in range(3): cap = cv2.VideoCapture(i) if cap.isOpened(): print(f'摄像头 {i}: 可用') cap.release() else: print(f'摄像头 {i}: 不可用') " # 启动应用 echo "启动应用..." python app_web_live.py echo "应用已启动" echo "访问地址: http://localhost:8080"

5. 实际应用与调试技巧

5.1 摄像头配置建议

不同的摄像头可能需要不同的配置。在VideoStreamManager类中，你可以调整这些参数：

# 在_init_cameras方法中调整 cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640) # 宽度 cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480) # 高度 cap.set(cv2.CAP_PROP_FPS, 15) # 帧率 cap.set(cv2.CAP_PROP_BRIGHTNESS, 0.5) # 亮度 cap.set(cv2.CAP_PROP_CONTRAST, 0.5) # 对比度

5.2 处理常见问题

问题1：摄像头无法打开

解决方案：

# 尝试不同的摄像头ID camera_ids = [0, 1, 2, 10, 20] # 有些系统摄像头ID不连续 # 或者使用视频文件测试 cap = cv2.VideoCapture("test_video.mp4")

问题2：画面延迟严重

解决方案：

# 降低分辨率和帧率 cap.set(cv2.CAP_PROP_FRAME_WIDTH, 320) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 240) cap.set(cv2.CAP_PROP_FPS, 10) # 使用多线程处理，避免阻塞主线程

问题3：内存泄漏

解决方案：

# 确保正确释放资源 def cleanup(self): self.running = False for cap in self.caps: if cap is not None: cap.release() cv2.destroyAllWindows()

5.3 性能优化建议

1. 降低图像分辨率：Pi0模型通常需要224x224的输入，没必要用高清画面
2. 使用硬件加速：如果支持，使用CUDA或OpenCL加速图像处理
3. 异步处理：图像捕获、预处理、推理使用不同的线程
4. 缓存机制：缓存预处理结果，避免重复计算

# 示例：异步处理架构 import asyncio import concurrent.futures class AsyncVideoProcessor: def __init__(self): self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=3) async def process_frame_async(self, frame): loop = asyncio.get_event_loop() # 在后台线程中处理 processed = await loop.run_in_executor( self.executor, self.preprocess_frame, frame ) return processed

6. 扩展功能：让系统更智能

6.1 添加运动检测

在连续视频流中，我们可以检测环境变化，只在必要时触发推理：

class MotionDetector: """运动检测器""" def __init__(self, threshold=0.1): self.threshold = threshold self.prev_frame = None def detect_motion(self, current_frame): if self.prev_frame is None: self.prev_frame = current_frame return False # 计算帧间差异 diff = cv2.absdiff(self.prev_frame, current_frame) gray = cv2.cvtColor(diff, cv2.COLOR_RGB2GRAY) _, thresh = cv2.threshold(gray, 30, 255, cv2.THRESH_BINARY) # 计算运动比例 motion_ratio = np.sum(thresh > 0) / thresh.size self.prev_frame = current_frame return motion_ratio > self.threshold

6.2 添加自动截图功能

当检测到重要事件时自动保存画面：

def auto_capture_on_event(frame, event_type="motion"): """根据事件自动截图""" timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") filename = f"capture_{event_type}_{timestamp}.jpg" # 保存图像 cv2.imwrite(f"captures/{filename}", cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)) # 记录到日志 log_event(f"自动截图: {filename} - {event_type}") return filename

6.3 集成语音控制

结合语音识别，实现真正的自然交互：

# 需要安装 speech_recognition import speech_recognition as sr class VoiceController: """语音控制器""" def __init__(self): self.recognizer = sr.Recognizer() self.microphone = sr.Microphone() def listen_for_command(self): with self.microphone as source: print("正在聆听...") audio = self.recognizer.listen(source, timeout=3) try: command = self.recognizer.recognize_google(audio, language='zh-CN') print(f"识别到指令: {command}") return command except sr.UnknownValueError: return None except sr.RequestError: return "网络错误"

7. 总结与下一步

通过本教程，我们成功将Pi0机器人控制中心从静态图像上传升级到了实时视频流处理。现在你的系统可以：

1. 实时感知环境：通过多摄像头获取连续画面
2. 动态响应变化：根据环境变化调整机器人动作
3. 更自然的交互：减少手动操作，提高效率
4. 扩展性强：为后续功能（如运动检测、语音控制）打下基础

7.1 关键收获

• 理解了视频流处理的基本原理：从摄像头捕获到画面显示的完整流程
• 掌握了OpenCV与Gradio的集成方法：如何将实时画面嵌入Web界面
• 学会了多线程编程技巧：避免视频捕获阻塞主程序
• 了解了性能优化策略：平衡画面质量与处理速度

7.2 可以继续探索的方向

1. 更高效的视频编码：使用H.264/H.265压缩减少带宽
2. 云端视频处理：将视频流发送到云端进行AI分析
3. 多机器人协同：一个控制中心管理多个机器人
4. 增强现实叠加：在视频画面上叠加机器人动作预测
5. 历史回放功能：录制和回放机器人操作过程

7.3 实际部署建议

1. 测试阶段：先用单个摄像头测试，逐步增加
2. 性能监控：监控CPU、内存、GPU使用情况
3. 故障恢复：添加摄像头断开重连机制
4. 用户培训：制作简单的操作指南给最终用户

实时视频流的集成让Pi0机器人控制中心真正具备了"眼睛"，能够实时观察世界并做出反应。这不仅是技术上的升级，更是向真正智能机器人控制系统迈出的重要一步。

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。