LingBot-Depth保姆级教程：从镜像部署到深度图生成，3步搞定机器人视觉

LingBot-Depth保姆级教程：从镜像部署到深度图生成，3步搞定机器人视觉

1. 开始之前：为什么你的机器人需要更好的“眼睛”？

想象一下，你的机器人正在房间里移动，它的“眼睛”——一个普通的RGB-D相机——看到的世界是模糊的、不完整的。墙壁的深度信息缺失了一大块，桌子的边缘看起来像锯齿一样粗糙。这样的视觉数据，怎么指望它能精准地绕过障碍物，或者准确地抓取物体呢？

这就是深度估计与补全技术要解决的问题。传统的深度传感器（比如结构光或ToF相机）在遇到反光表面、透明物体或者远距离场景时，采集的数据往往充满了噪声和空洞。而LingBot-Depth模型，就像给机器人的眼睛戴上了一副“智能眼镜”，能够从模糊的视觉信号中，重建出清晰、完整、度量准确的三维世界。

这个教程将带你从零开始，通过一个预置好的Docker镜像，在10分钟内搭建起一个功能完整的深度图生成服务。无论你是机器人开发者、3D视觉研究者，还是对具身智能感兴趣的爱好者，都能快速上手，让机器人的“视力”提升一个档次。

2. 第一步：一键部署，5分钟启动深度视觉服务

部署AI模型最头疼的是什么？是环境配置、依赖冲突，还是版本不兼容？这些问题，在镜像化部署面前都不再是问题。

2.1 找到并部署镜像

首先，你需要登录到你的云服务器或容器平台。在镜像市场或应用商店中，搜索关键词ins-lingbot-depth-vitl14-v1。这就是我们今天要用的LingBot-Depth预训练镜像。

找到后，直接点击“部署实例”或“启动容器”。系统会自动为你创建一个包含所有必要环境的运行实例。这个过程通常需要1-2分钟，镜像大小约几个GB，包含了Python 3.11、PyTorch 2.6.0、CUDA 12.4等全套依赖。

重要提示：确保你选择的运行底座（或叫“基础镜像”）是insbase-cuda124-pt250-dual-v7。这个底座已经预装了PyTorch 2.6.0和CUDA 12.4，能保证模型以最佳性能在GPU上运行。

2.2 等待启动与验证

实例创建成功后，状态会显示为“运行中”或“已启动”。这时候先别急，模型还需要一点时间加载到GPU显存里。

首次启动时，系统需要将321M参数的ViT-Large/14模型权重加载到显存，这个过程大约需要5-8秒。你可以在实例的日志中看到类似这样的信息：

Loading pretrained weights from /root/models/lingbot-depth... Model loaded successfully on device: cuda:0 FastAPI server starting on port 8000... Gradio WebUI starting on port 7860...

看到这些日志，就说明模型已经准备就绪，两个服务端口也已经打开：

• 端口 8000：FastAPI REST接口，供程序调用
• 端口 7860：Gradio可视化网页，供手动测试和演示

3. 第二步：快速测试，看看模型到底能做什么

模型跑起来了，但它到底行不行？我们来做个快速测试，验证一下核心功能。

3.1 访问可视化测试页面

在实例管理界面，找到你刚部署的LingBot-Depth实例，点击旁边的“HTTP”访问按钮（或者直接在浏览器地址栏输入http://<你的实例IP地址>:7860）。

你会看到一个简洁的Web界面，这就是Gradio构建的可视化测试页面。界面主要分为三个区域：

• 左侧：上传区和参数设置区
• 中间：图像显示区（输入RGB图和输出深度图）
• 右侧：信息显示和结果下载区

3.2 执行单目深度估计测试

我们先从最简单的功能开始：单目深度估计。也就是只给模型一张普通的彩色照片，让它猜出每个像素离相机有多远。

1. 上传测试图片在“Upload RGB Image”区域，点击上传按钮。你可以使用任何图片，但为了快速验证，我建议直接用镜像里自带的示例图片。路径是：/root/assets/lingbot-depth-main/examples/0/rgb.png这是一张室内的场景图，有桌子、椅子和一些杂物。

2. 选择工作模式在“Mode”选项里，确保选中了“Monocular Depth”（单目深度估计）。这个模式不需要深度图输入，完全靠模型从RGB图像中“脑补”出深度信息。

3. 生成深度图点击那个大大的“Generate Depth”按钮。

等待2-3秒，神奇的事情发生了：右侧的“Output Depth”区域显示出了一张彩色的热力图。这就是模型生成的深度图，但它为什么是彩色的？

深度图可视化原理： 深度图本身是单通道的灰度图，每个像素值代表距离（单位：米）。但为了让人眼更容易分辨远近，系统用了一种叫做“INFERNO”的配色方案：

• 红色/橙色：表示距离近的物体（比如前景的桌子）
• 蓝色/紫色：表示距离远的物体（比如背景的墙壁）

所以，你看到的彩色图不是艺术创作，而是深度信息的可视化表达。

4. 查看详细信息生成完成后，滚动到页面下方的“Info”区域，你会看到一段JSON格式的信息：

{ "status": "success", "mode": "Monocular Depth", "input_size": "640x480", "depth_range": "0.523m ~ 8.145m", "device": "cuda", "inference_time": "0.087s" }

这告诉我们：

• 模型运行成功（status: success）
• 输入图片分辨率是640x480
• 场景中最近物体距离相机0.523米，最远物体8.145米
• 使用了GPU加速（device: cuda）
• 推理只用了0.087秒

3.3 测试深度补全功能（进阶）

单目深度估计已经很厉害了，但如果我们有一些稀疏的深度数据（比如来自低精度LiDAR或ToF传感器），能不能做得更好？

当然可以！这就是深度补全模式的价值。

1. 准备输入数据

   • 在“Upload RGB Image”区域，再次上传同样的RGB图片（或者用新的）
   • 在“Upload Raw Depth (Optional)”区域，上传稀疏深度图。示例路径：/root/assets/lingbot-depth-main/examples/0/raw_depth.png这张图里，只有部分像素有深度值，其他区域都是空白（值为0）。

2. 设置相机参数展开“Camera Intrinsics”折叠面板，填入相机的内参矩阵。对于示例图片，使用这些值：

   • fx:460.14
   • fy:460.20
   • cx:319.66
   • cy:237.40

   什么是相机内参？简单理解，就是描述相机光学特性的参数，就像人的眼球焦距一样。有了准确的参数，模型才能把像素坐标转换成真实世界的3D坐标。

3. 切换模式并生成

   • 将“Mode”切换到“Depth Completion”（深度补全）
   • 点击“Generate Depth”

这次生成的深度图，你会发现两个明显的变化：

• 边缘更锐利：物体的边界更加清晰明确
• 补全了缺失区域：原来稀疏深度图中空白的地方，现在都被合理地填充了
• 整体更平滑：减少了单目估计时可能出现的“毛刺”和噪声

在“Info”区域，你会看到模式已经变成了“Depth Completion”，而且深度范围可能略有不同，因为补全后的深度值更加准确。

4. 第三步：程序化调用，把深度视觉集成到你的应用

手动测试很直观，但真正的价值在于自动化。你的机器人程序、3D重建流水线，需要能够通过代码调用这个服务。

4.1 理解API接口

LingBot-Depth镜像提供了两种调用方式：

方式一：Gradio WebUI（端口7860）适合手动测试、演示、调试。我们刚才用的就是这种方式。

方式二：FastAPI REST API（端口8000）适合程序化集成。它提供了一个标准的HTTP接口，你的任何程序（Python、Java、C++等）都可以通过发送HTTP请求来获取深度图。

REST API的主要端点是：

POST http://<实例IP>:8000/predict

4.2 编写Python调用代码

下面是一个完整的Python示例，展示如何通过代码调用深度估计服务：

import requests import base64 import json import cv2 import numpy as np from PIL import Image import io class LingBotDepthClient: def __init__(self, server_url="http://localhost:8000"): self.server_url = server_url self.predict_url = f"{server_url}/predict" def image_to_base64(self, image_path): """将图片转换为base64字符串""" with open(image_path, "rb") as image_file: encoded_string = base64.b64encode(image_file.read()).decode('utf-8') return encoded_string def estimate_monocular_depth(self, rgb_image_path, output_path="depth_result.png"): """ 单目深度估计 :param rgb_image_path: RGB图片路径 :param output_path: 深度图保存路径 :return: 深度图数据（numpy数组） """ # 准备请求数据 rgb_base64 = self.image_to_base64(rgb_image_path) payload = { "mode": "monocular", # 单目模式 "rgb_image": rgb_base64, "return_npy": True # 同时返回原始npy数据 } # 发送请求 response = requests.post(self.predict_url, json=payload) if response.status_code == 200: result = response.json() if result["status"] == "success": # 解码深度图（PNG格式，用于可视化） depth_png_data = base64.b64decode(result["depth_image"]) depth_image = Image.open(io.BytesIO(depth_png_data)) depth_image.save(output_path) print(f"深度图已保存至: {output_path}") # 解码原始深度数据（npy格式，用于后续处理） if "depth_npy" in result: depth_npy_data = base64.b64decode(result["depth_npy"]) depth_array = np.load(io.BytesIO(depth_npy_data)) print(f"深度数据形状: {depth_array.shape}") print(f"深度范围: {depth_array.min():.3f}m ~ {depth_array.max():.3f}m") return depth_array else: print(f"处理失败: {result.get('message', '未知错误')}") else: print(f"请求失败，状态码: {response.status_code}") return None def complete_depth(self, rgb_image_path, depth_image_path, intrinsics, output_path="completed_depth.png"): """ 深度补全 :param rgb_image_path: RGB图片路径 :param depth_image_path: 稀疏深度图路径 :param intrinsics: 相机内参 [fx, fy, cx, cy] :param output_path: 补全深度图保存路径 :return: 补全后的深度数据 """ # 准备请求数据 rgb_base64 = self.image_to_base64(rgb_image_path) depth_base64 = self.image_to_base64(depth_image_path) payload = { "mode": "completion", # 补全模式 "rgb_image": rgb_base64, "depth_image": depth_base64, "intrinsics": intrinsics, "return_npy": True } # 发送请求 response = requests.post(self.predict_url, json=payload) if response.status_code == 200: result = response.json() if result["status"] == "success": # 保存补全后的深度图 depth_png_data = base64.b64decode(result["depth_image"]) depth_image = Image.open(io.BytesIO(depth_png_data)) depth_image.save(output_path) print(f"补全深度图已保存至: {output_path}") # 获取原始数据 if "depth_npy" in result: depth_npy_data = base64.b64decode(result["depth_npy"]) depth_array = np.load(io.BytesIO(depth_npy_data)) return depth_array else: print(f"处理失败: {result.get('message', '未知错误')}") else: print(f"请求失败，状态码: {response.status_code}") return None # 使用示例 if __name__ == "__main__": # 初始化客户端（替换为你的实例IP） client = LingBotDepthClient("http://你的实例IP:8000") # 示例1：单目深度估计 print("=== 测试单目深度估计 ===") depth_data = client.estimate_monocular_depth( rgb_image_path="test_rgb.jpg", output_path="monocular_depth.png" ) # 示例2：深度补全 print("\n=== 测试深度补全 ===") # 相机内参示例（需要根据你的相机调整） camera_intrinsics = [460.14, 460.20, 319.66, 237.40] # [fx, fy, cx, cy] completed_depth = client.complete_depth( rgb_image_path="test_rgb.jpg", depth_image_path="sparse_depth.png", intrinsics=camera_intrinsics, output_path="completed_depth.png" ) # 使用深度数据进行3D点云生成 if depth_data is not None: height, width = depth_data.shape # 生成点云（简单示例） points = [] for v in range(height): for u in range(width): z = depth_data[v, u] if z > 0: # 有效的深度值 # 将像素坐标转换为3D坐标（需要相机内参） # 这里简化处理，实际应用需要完整的内参矩阵 x = (u - camera_intrinsics[2]) * z / camera_intrinsics[0] y = (v - camera_intrinsics[3]) * z / camera_intrinsics[1] points.append([x, y, z]) print(f"生成了 {len(points)} 个3D点")

这段代码做了几件重要的事情：

1. 创建了一个客户端类，封装了与LingBot-Depth服务的通信
2. 实现了单目深度估计和深度补全两种模式的调用
3. 处理了base64编码的图像传输
4. 支持同时获取可视化PNG和原始NPY数据
5. 提供了简单的点云生成示例

4.3 集成到机器人系统

有了API接口，你可以轻松地将深度视觉能力集成到各种应用中：

机器人导航系统：

# 伪代码示例：使用深度图进行障碍物检测 class RobotNavigation: def __init__(self, depth_client): self.depth_client = depth_client def detect_obstacles(self, rgb_image): # 获取深度图 depth_map = self.depth_client.estimate_monocular_depth(rgb_image) # 分析深度图，检测障碍物 obstacles = [] height, width = depth_map.shape # 简单阈值检测：距离小于1米的区域视为障碍物 obstacle_mask = depth_map < 1.0 # 将障碍物位置转换为机器人坐标系 # ... 具体的坐标转换逻辑 return obstacles def plan_path(self, current_position, target_position, obstacles): # 基于深度信息和障碍物位置规划路径 # ... 路径规划算法 return path

3D重建流水线：

# 伪代码示例：从视频序列重建3D场景 class SceneReconstructor: def __init__(self, depth_client): self.depth_client = depth_client self.point_clouds = [] def process_frame(self, frame, camera_pose): # 估计当前帧的深度 depth_map = self.depth_client.estimate_monocular_depth(frame) # 将深度图转换为点云 point_cloud = self.depth_to_pointcloud(depth_map, camera_pose) # 添加到全局点云 self.point_clouds.append(point_cloud) return point_cloud def reconstruct_scene(self): # 融合所有点云，重建完整3D场景 merged_cloud = merge_point_clouds(self.point_clouds) # 保存为PLY或OBJ格式 save_to_ply(merged_cloud, "reconstructed_scene.ply") return merged_cloud

5. 实战技巧与最佳实践

掌握了基本用法后，我们来看看如何让模型发挥最佳效果，以及在实际项目中需要注意什么。

5.1 输入图像的最佳实践

模型的性能很大程度上取决于输入图像的质量。以下是一些实用建议：

分辨率选择： LingBot-Depth基于ViT-L/14架构，对输入尺寸比较敏感。最佳实践是使用14的倍数作为分辨率，比如：

• 448×448
• 560×560
• 672×672
• 896×896

如果你的原始图像不是这些尺寸，建议在保持宽高比的前提下，调整到最接近的14倍数尺寸。

图像预处理：

def preprocess_image(image_path, target_size=(448, 448)): """预处理输入图像""" # 读取图像 img = cv2.imread(image_path) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # 保持宽高比调整大小 h, w = img.shape[:2] scale = min(target_size[0]/h, target_size[1]/w) new_h, new_w = int(h * scale), int(w * scale) img_resized = cv2.resize(img, (new_w, new_h)) # 填充到目标尺寸（保持14的倍数） pad_h = (target_size[0] - new_h) // 2 pad_w = (target_size[1] - new_w) // 2 img_padded = np.pad(img_resized, ((pad_h, target_size[0]-new_h-pad_h), (pad_w, target_size[1]-new_w-pad_w), (0, 0)), mode='constant') return img_padded, (scale, pad_h, pad_w)

深度图格式： 如果使用深度补全模式，需要注意稀疏深度图的格式：

• 数据类型：16位无符号整数（uint16）或32位浮点数（float32）
• 单位：米（如果是毫米需要除以1000）
• 无效值：用0或NaN表示缺失的深度值

5.2 相机内参的获取与校准

深度补全和3D点云重建需要准确的相机内参。如何获取这些参数？

方法一：相机标定使用棋盘格或AprilTag进行相机标定，这是最准确的方法：

import cv2 import numpy as np def calibrate_camera(images, pattern_size=(9, 6), square_size=0.025): """相机标定获取内参""" # 准备标定板角点 obj_points = [] # 3D点 img_points = [] # 2D点 # 生成标定板的世界坐标 objp = np.zeros((pattern_size[0]*pattern_size[1], 3), np.float32) objp[:, :2] = np.mgrid[0:pattern_size[0], 0:pattern_size[1]].T.reshape(-1, 2) objp *= square_size for img in images: gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 查找角点 ret, corners = cv2.findChessboardCorners(gray, pattern_size, None) if ret: obj_points.append(objp) img_points.append(corners) # 相机标定 ret, camera_matrix, dist_coeffs, rvecs, tvecs = cv2.calibrateCamera( obj_points, img_points, gray.shape[::-1], None, None ) return camera_matrix, dist_coeffs

方法二：从相机规格中估算如果无法进行标定，可以从相机规格中估算：

• fx = fy = 焦距（mm）× 传感器宽度（像素）/ 传感器物理宽度（mm）
• cx = 图像宽度 / 2
• cy = 图像高度 / 2

方法三：使用默认值对于快速测试，可以使用近似值。大多数消费级相机的fx/fy在500-1000之间，cx/cy在图像中心附近。

5.3 性能优化技巧

如果你的应用对实时性要求很高，可以考虑以下优化：

批量处理： 如果需要处理多张图像，尽量使用批量模式：

# 伪代码：批量处理 def batch_process(images_list, batch_size=4): """批量处理图像""" results = [] for i in range(0, len(images_list), batch_size): batch = images_list[i:i+batch_size] # 准备批量数据 batch_rgb = [] batch_depth = [] # 如果有的话 batch_intrinsics = [] # 如果有的话 for img_info in batch: # 预处理每张图像... pass # 批量推理（需要服务端支持批量接口） batch_results = client.batch_predict(batch_rgb, batch_depth, batch_intrinsics) results.extend(batch_results) return results

分辨率权衡：

• 高分辨率（如896×896）：精度更高，细节更丰富，但速度慢，显存占用大
• 低分辨率（如224×224）：速度快，显存占用小，但精度较低
• 建议：根据应用需求选择平衡点。机器人导航可能更需要速度，3D重建可能更需要精度。

使用FP16精度： 模型支持半精度浮点数（FP16）推理，可以显著减少显存占用并提高速度：

# 在API调用中启用FP16 payload = { "mode": "monocular", "rgb_image": rgb_base64, "use_fp16": True # 启用FP16 }

6. 常见问题与解决方案

在实际使用中，你可能会遇到一些问题。这里列出了一些常见问题及其解决方法。

6.1 部署与启动问题

问题：实例启动失败，提示端口冲突

• 原因：8000或7860端口已被其他程序占用
• 解决：修改镜像的启动配置，使用其他端口，或者在部署时指定不同的端口映射

问题：模型加载很慢（超过30秒）

• 原因：首次加载需要下载模型权重，或者网络较慢
• 解决：
  1. 检查网络连接
  2. 如果是内网环境，可以提前下载权重文件到本地
  3. 确保有足够的GPU显存（至少4GB）

问题：WebUI可以访问，但API调用失败

• 原因：防火墙或安全组设置阻止了8000端口
• 解决：检查服务器的安全组规则，确保8000端口对调用端开放

6.2 模型推理问题

问题：深度图全是黑色或白色

• 原因：输入图像格式不正确，或者深度值范围异常
• 解决：
  1. 检查输入图像是否为RGB格式（不是BGR或灰度）
  2. 确保图像值范围在0-255之间
  3. 对于深度补全模式，检查稀疏深度图是否包含有效的深度值

问题：深度估计结果不准确（物体距离明显错误）

• 原因：
  1. 图像分辨率不合适（不是14的倍数）
  2. 场景超出模型训练范围（如极端近距离或远距离）
  3. 图像内容过于特殊（如纯色墙面、纹理缺乏）
• 解决：
  1. 将图像调整到推荐分辨率（448×448等）
  2. 确保场景在0.1m-10m范围内（室内场景最佳）
  3. 对于纹理缺乏的场景，可以尝试深度补全模式（如果有稀疏深度）

问题：深度补全效果不佳，缺失区域填充不合理

• 原因：
  1. 稀疏深度图质量太差（有效点太少或分布不均）
  2. 相机内参不准确
  3. RGB图像与深度图未对齐
• 解决：
  1. 确保稀疏深度图至少有5%的有效像素，且分布相对均匀
  2. 重新校准相机内参
  3. 检查RGB和深度图是否来自同一视角，必要时进行配准

6.3 性能与资源问题

问题：推理速度慢（单张图超过1秒）

• 原因：
  1. 使用CPU模式而非GPU
  2. 输入图像分辨率过高
  3. 服务器性能不足
• 解决：
  1. 确认实例使用了GPU（检查日志中的"device: cuda"）
  2. 降低输入图像分辨率
  3. 升级服务器配置，使用更好的GPU

问题：显存不足（Out of Memory）

• 原因：输入图像太大，或批量处理时batch size太大
• 解决：
  1. 减小输入图像尺寸
  2. 启用FP16模式减少显存占用
  3. 如果是批量处理，减小batch size

问题：API响应时间不稳定

• 原因：服务器负载波动，或网络延迟
• 解决：
  1. 监控服务器资源使用情况
  2. 考虑使用连接池复用HTTP连接
  3. 对于实时应用，可以在客户端实现请求队列和超时重试

6.4 结果处理问题

问题：深度图与RGB图像尺寸不匹配

• 原因：模型输出尺寸可能与输入不同（取决于具体实现）
• 解决：

# 调整深度图尺寸以匹配RGB def align_depth_to_rgb(rgb_image, depth_map): """将深度图调整到与RGB图像相同尺寸""" rgb_h, rgb_w = rgb_image.shape[:2] depth_h, depth_w = depth_map.shape if (rgb_h, rgb_w) != (depth_h, depth_w): # 使用最近邻插值保持深度值不变 depth_aligned = cv2.resize(depth_map, (rgb_w, rgb_h), interpolation=cv2.INTER_NEAREST) return depth_aligned return depth_map

问题：深度值单位混淆（米 vs 毫米）

• 原因：不同传感器和数据集使用不同的深度单位
• 解决：明确约定并统一单位

# 单位转换工具函数 def convert_depth_units(depth_map, from_unit='mm', to_unit='m'): """深度单位转换""" if from_unit == 'mm' and to_unit == 'm': return depth_map / 1000.0 elif from_unit == 'm' and to_unit == 'mm': return depth_map * 1000.0 elif from_unit == 'cm' and to_unit == 'm': return depth_map / 100.0 else: return depth_map # 相同单位或无转换

问题：点云重建后坐标不对

• 原因：相机内参使用错误，或坐标转换公式有误
• 解决：仔细检查相机内参和坐标转换代码

def depth_to_pointcloud(depth_map, intrinsics): """将深度图转换为点云""" h, w = depth_map.shape fx, fy, cx, cy = intrinsics # 生成像素网格 u = np.arange(w) v = np.arange(h) u, v = np.meshgrid(u, v) # 计算3D坐标 z = depth_map x = (u - cx) * z / fx y = (v - cy) * z / fy # 创建点云（过滤无效点） valid_mask = z > 0 points = np.stack([x[valid_mask], y[valid_mask], z[valid_mask]], axis=-1) return points

7. 总结：让机器人拥有真正的三维视觉

通过这个保姆级教程，你应该已经掌握了LingBot-Depth模型的完整使用流程。从镜像部署到API调用，从单目估计到深度补全，我们一步步拆解了每个环节。

回顾一下关键要点：

1. 部署简单：通过预置镜像，你可以在几分钟内搭建起一个生产级的深度视觉服务，无需担心环境配置和依赖冲突。

2. 功能强大：模型支持两种核心模式——单目深度估计让你从一张普通照片就能获得3D信息，深度补全则能融合稀疏深度数据生成更精确的结果。

3. 易于集成：提供REST API接口，可以轻松集成到现有的机器人系统、3D重建流水线或其他视觉应用中。

4. 性能优秀：在GPU上单张图像推理只需不到0.1秒，满足大多数实时应用的需求。

在实际项目中，你可以根据具体需求选择合适的使用方式：

• 快速原型验证：使用WebUI手动测试，快速验证想法
• 系统集成开发：通过API接口程序化调用，实现自动化处理
• 批量数据处理：编写脚本批量处理图像序列或视频帧

虽然模型在大多数室内场景下表现良好，但也要注意它的局限性。对于室外大尺度场景、极端光照条件或特殊材质表面，可能需要额外的预处理或后处理。不过，对于机器人导航、AR/VR、3D重建等常见应用，LingBot-Depth已经能够提供相当可靠的深度感知能力。

现在，你的机器人拥有了更清晰的"眼睛"，能够更准确地感知三维世界。无论是避障导航、物体抓取，还是场景理解，高质量的深度信息都是实现智能交互的关键基础。开始动手试试吧，看看深度视觉能为你的项目带来哪些新的可能性。

获取更多AI镜像

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