YOLO11如何对接摄像头？实时检测部署教程

你是不是也想用YOLO11做个实时监控系统，或者搞个智能摄像头应用？但一看到代码和配置就头疼，不知道从哪下手？

别担心，今天我就带你一步步搞定YOLO11对接摄像头，实现实时目标检测。不管你是想做个安防监控、车辆识别，还是想玩点有趣的AI应用，这篇文章都能帮你快速上手。

1. 环境准备：快速搭建YOLO11运行环境

在开始对接摄像头之前，我们得先把YOLO11的环境准备好。好消息是，现在有现成的镜像可以直接用，省去了很多配置的麻烦。

1.1 获取YOLO11完整环境

YOLO11完整可运行环境已经打包成了深度学习镜像，里面包含了所有需要的依赖和工具。这个镜像基于YOLO11算法构建，提供了完整的计算机视觉开发环境，你不需要自己安装Python、PyTorch、OpenCV这些复杂的库。

这个镜像最大的好处就是开箱即用，不用折腾环境配置。很多人在配置深度学习环境时都会遇到各种版本冲突、依赖问题，这个镜像都帮你解决了。

1.2 两种使用方式

拿到镜像后，你可以用两种方式来使用它：

方式一：通过Jupyter使用

如果你喜欢在浏览器里写代码和运行代码，Jupyter是个不错的选择。它提供了一个交互式的编程环境，你可以一边写代码一边看结果。

使用步骤很简单：

1. 启动镜像后，打开浏览器
2. 输入提供的地址（通常是http://localhost:8888）
3. 输入token或密码（如果有的话）
4. 就可以在网页里创建新的notebook开始编程了

Jupyter的好处是所见即所得，特别适合调试和实验。你可以把代码分成多个单元格，单独运行每个单元格，看看中间结果。

方式二：通过SSH使用

如果你更习惯在终端里操作，或者需要运行一些长时间的任务，SSH方式更适合。通过SSH连接到镜像，就像在本地命令行一样操作。

使用方法：

1. 用SSH客户端（比如PuTTY或者终端）连接
2. 输入主机地址、端口、用户名和密码
3. 连接成功后，就可以在命令行里操作了

SSH方式更灵活，可以运行各种脚本，也方便文件传输。如果你要部署到服务器上，SSH是必须掌握的技能。

两种方式各有优势，你可以根据自己的习惯选择。我个人建议初学者先用Jupyter，因为界面更友好；有经验的开发者可能更喜欢SSH，因为效率更高。

2. YOLO11基础使用：先跑起来看看

在对接摄像头之前，我们先确保YOLO11能正常工作。这就像买了个新电器，先试试基本功能好不好用。

2.1 进入项目目录

首先，我们需要进入YOLO11的项目目录。打开终端（如果你用SSH）或者Jupyter的终端，输入：

cd ultralytics-8.3.9/

这个目录包含了YOLO11的所有源代码、配置文件、示例脚本。ultralytics是YOLO的官方实现库，8.3.9是版本号。

2.2 运行训练脚本测试

为了验证环境是否正常，我们可以先运行一个简单的训练脚本：

python train.py

这个命令会启动YOLO11的训练过程。如果是第一次运行，它会下载预训练模型，然后开始训练。

运行后你会看到类似这样的输出：

• 开始下载预训练权重
• 显示训练配置（数据集、模型大小、训练轮数等）
• 开始训练，显示每一轮的损失值和评估指标
• 训练完成后保存模型文件

看到训练正常进行，就说明环境配置没问题。如果遇到错误，通常是缺少某个依赖库或者权限问题，根据错误信息解决就行。

2.3 理解运行结果

训练完成后，你会得到几个重要的文件：

• 模型权重文件（.pt格式）：这是训练好的模型，可以用来做检测
• 训练日志：记录了训练过程中的各种指标
• 评估结果：模型在验证集上的表现

对于摄像头实时检测来说，我们主要关心模型权重文件。有了这个文件，我们就可以加载模型，对摄像头画面进行检测了。

3. 摄像头对接：让YOLO11"看"到真实世界

现在到了最核心的部分——让YOLO11连接摄像头，进行实时检测。这其实比很多人想象的要简单。

3.1 准备工作：检查摄像头

在写代码之前，先确保你的摄像头能正常工作：

在Linux/Mac上检查摄像头：

# 查看摄像头设备
ls /dev/video*

# 安装必要的工具
sudo apt-get install v4l-utils

# 查看摄像头详细信息
v4l2-ctl --list-devices

在Windows上检查摄像头：

• 打开"相机"应用，看看能不能正常显示画面
• 或者在设备管理器中查看摄像头是否正常工作

如果摄像头有问题，先解决硬件问题。有时候是驱动没装好，有时候是权限问题（Linux下可能需要把用户加入video组）。

3.2 基础摄像头读取代码

我们先写一个最简单的摄像头读取程序，确保能获取到视频流：

import cv2

# 打开摄像头
# 0表示默认摄像头，如果有多个摄像头可以尝试1,2,3...
cap = cv2.VideoCapture(0)

# 检查摄像头是否成功打开
if not cap.isOpened():
    print("无法打开摄像头")
    exit()

print("摄像头已连接，按'q'键退出")

while True:
    # 读取一帧
    ret, frame = cap.read()
    
    # 如果读取失败，退出循环
    if not ret:
        print("无法读取帧")
        break
    
    # 显示帧
    cv2.imshow('摄像头', frame)
    
    # 按'q'键退出
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 释放摄像头
cap.release()
cv2.destroyAllWindows()

这段代码做了几件事：

1. 用OpenCV的VideoCapture打开摄像头
2. 循环读取每一帧画面
3. 在窗口中显示画面
4. 按q键退出时释放资源

运行这个代码，你应该能看到摄像头画面。如果看不到，可能是摄像头编号不对，或者摄像头被其他程序占用了。

3.3 加载YOLO11模型

能读取摄像头后，接下来加载YOLO11模型：

from ultralytics import YOLO
import cv2

# 加载预训练模型
# 你可以使用官方的预训练模型，或者使用自己训练的模型
model = YOLO('yolo11n.pt')  # 使用YOLO11 nano版本，速度最快

# 如果你想用自己训练的模型
# model = YOLO('runs/detect/train/weights/best.pt')

这里有几个模型可以选择：

• yolo11n.pt：nano版本，最小最快，适合实时检测
• yolo11s.pt：small版本，平衡速度和精度
• yolo11m.pt：medium版本，精度更高
• yolo11l.pt：large版本，精度最高但速度较慢

对于摄像头实时检测，我建议先用nano或small版本，确保流畅度。如果检测精度不够，再换更大的模型。

4. 完整实时检测代码

现在我们把摄像头读取和YOLO11检测结合起来，写一个完整的实时检测程序：

import cv2
from ultralytics import YOLO
import time

class CameraDetector:
    def __init__(self, camera_id=0, model_path='yolo11n.pt'):
        """
        初始化摄像头检测器
        
        参数:
            camera_id: 摄像头ID，0表示默认摄像头
            model_path: YOLO模型路径
        """
        # 加载YOLO模型
        print(f"加载模型: {model_path}")
        self.model = YOLO(model_path)
        
        # 打开摄像头
        print(f"打开摄像头 {camera_id}")
        self.cap = cv2.VideoCapture(camera_id)
        
        if not self.cap.isOpened():
            raise Exception(f"无法打开摄像头 {camera_id}")
        
        # 获取摄像头参数
        self.frame_width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))
        self.frame_height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
        self.fps = self.cap.get(cv2.CAP_PROP_FPS)
        
        print(f"摄像头分辨率: {self.frame_width}x{self.frame_height}")
        print(f"摄像头FPS: {self.fps}")
        
        # 性能统计
        self.frame_count = 0
        self.start_time = time.time()
        
    def run(self):
        """运行实时检测"""
        print("开始实时检测，按'q'键退出")
        
        while True:
            # 读取一帧
            ret, frame = self.cap.read()
            if not ret:
                print("无法读取帧，退出")
                break
            
            # 使用YOLO进行检测
            results = self.model(frame, verbose=False)
            
            # 在帧上绘制检测结果
            annotated_frame = results[0].plot()
            
            # 显示FPS
            self.frame_count += 1
            elapsed_time = time.time() - self.start_time
            fps = self.frame_count / elapsed_time
            
            cv2.putText(annotated_frame, f"FPS: {fps:.1f}", (10, 30),
                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            
            # 显示结果
            cv2.imshow('YOLO11实时检测', annotated_frame)
            
            # 按'q'键退出
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
        
        # 清理资源
        self.cap.release()
        cv2.destroyAllWindows()
        print("检测结束")
        
    def get_detection_info(self, frame):
        """
        获取检测的详细信息
        
        参数:
            frame: 输入图像帧
            
        返回:
            detections: 检测结果列表
        """
        results = self.model(frame, verbose=False)
        detections = []
        
        for result in results:
            boxes = result.boxes
            if boxes is not None:
                for box in boxes:
                    # 获取边界框坐标
                    x1, y1, x2, y2 = box.xyxy[0].tolist()
                    
                    # 获取置信度
                    confidence = box.conf[0].item()
                    
                    # 获取类别
                    class_id = int(box.cls[0].item())
                    class_name = result.names[class_id]
                    
                    detections.append({
                        'bbox': [x1, y1, x2, y2],
                        'confidence': confidence,
                        'class_id': class_id,
                        'class_name': class_name
                    })
        
        return detections

# 使用示例
if __name__ == "__main__":
    # 创建检测器实例
    # 使用默认摄像头和nano模型
    detector = CameraDetector(camera_id=0, model_path='yolo11n.pt')
    
    # 开始实时检测
    detector.run()

这段代码做了很多事情，我解释一下关键部分：

1. CameraDetector类 我把功能封装成了一个类，这样更清晰也更容易复用。类里面包含了初始化、运行检测、获取详细信息等方法。

2. 实时检测循环 在run()方法里，我们不断从摄像头读取帧，用YOLO检测，然后显示结果。这是一个典型的实时处理循环。

3. 性能统计 我加了FPS（每秒帧数）显示，这样你能知道检测速度。对于实时应用，FPS很重要，一般要保持在15以上才流畅。

4. 详细检测信息 get_detection_info()方法返回每个检测目标的详细信息，包括位置、置信度、类别等。如果你需要记录检测结果或者做进一步处理，这个方法很有用。

5. 实际应用与优化技巧

代码能跑了，但你可能还会遇到一些问题，或者想让效果更好。下面是一些实际应用中的技巧。

5.1 提高检测速度

如果觉得检测速度不够快，可以试试这些方法：

# 方法1：使用更小的模型
model = YOLO('yolo11n.pt')  # 最快

# 方法2：降低输入图像分辨率
results = model(frame, imgsz=320)  # 使用320x320分辨率

# 方法3：使用半精度推理（如果GPU支持）
results = model(frame, half=True)

# 方法4：跳过某些帧（对于变化不快的场景）
skip_frames = 2  # 每3帧处理1帧
frame_count = 0

while True:
    ret, frame = cap.read()
    frame_count += 1
    
    if frame_count % (skip_frames + 1) == 0:
        # 处理这一帧
        results = model(frame)
        # ... 绘制结果
    else:
        # 直接显示原帧
        cv2.imshow('Camera', frame)

5.2 处理多个摄像头

如果你有多个摄像头，可以这样处理：

import threading
import cv2
from ultralytics import YOLO

class MultiCameraDetector:
    def __init__(self, camera_ids=[0, 1]):
        self.camera_ids = camera_ids
        self.models = {}
        self.caps = {}
        
        # 为每个摄像头创建模型和捕获对象
        for cam_id in camera_ids:
            # 每个摄像头可以共用同一个模型，也可以使用不同的模型
            self.models[cam_id] = YOLO('yolo11n.pt')
            self.caps[cam_id] = cv2.VideoCapture(cam_id)
            
            if not self.caps[cam_id].isOpened():
                print(f"无法打开摄像头 {cam_id}")
    
    def detect_camera(self, camera_id):
        """单个摄像头的检测线程"""
        cap = self.caps[camera_id]
        model = self.models[camera_id]
        
        while True:
            ret, frame = cap.read()
            if not ret:
                break
            
            # 检测
            results = model(frame, verbose=False)
            annotated_frame = results[0].plot()
            
            # 显示
            cv2.imshow(f'Camera {camera_id}', annotated_frame)
            
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
        
        cap.release()
    
    def run(self):
        """启动所有摄像头检测"""
        threads = []
        
        for cam_id in self.camera_ids:
            thread = threading.Thread(target=self.detect_camera, args=(cam_id,))
            thread.start()
            threads.append(thread)
        
        # 等待所有线程结束
        for thread in threads:
            thread.join()
        
        cv2.destroyAllWindows()

# 使用两个摄像头
detector = MultiCameraDetector(camera_ids=[0, 1])
detector.run()

5.3 保存检测结果

有时候我们需要保存检测结果，比如做监控录像：

def run_with_recording(self, output_path='output.mp4'):
    """运行检测并保存视频"""
    # 设置视频编码器和输出参数
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter(output_path, fourcc, 20.0, 
                         (self.frame_width, self.frame_height))
    
    while True:
        ret, frame = self.cap.read()
        if not ret:
            break
        
        # 检测
        results = self.model(frame)
        annotated_frame = results[0].plot()
        
        # 写入视频文件
        out.write(annotated_frame)
        
        # 显示
        cv2.imshow('Detection', annotated_frame)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    # 释放资源
    self.cap.release()
    out.release()
    cv2.destroyAllWindows()
    print(f"视频已保存到: {output_path}")

5.4 常见问题解决

问题1：摄像头打不开

• 检查摄像头ID是否正确（尝试0,1,2...）
• 检查摄像头是否被其他程序占用
• Linux下检查用户是否有摄像头访问权限

问题2：检测速度太慢

• 换用更小的模型（yolo11n）
• 降低输入图像分辨率
• 使用GPU加速（如果有的话）
• 跳帧处理

问题3：检测精度不够

• 换用更大的模型（yolo11l）
• 使用自定义训练的数据集
• 调整置信度阈值：results = model(frame, conf=0.5)

问题4：内存不足

• 降低图像分辨率
• 定期清理不需要的变量
• 使用torch.cuda.empty_cache()清理GPU缓存

6. 进阶应用：让检测更有用

基本的摄像头检测会了，我们来看看怎么把它用到实际项目中。

6.1 人数统计应用

假设你想统计房间里的人数：

class PeopleCounter:
    def __init__(self):
        self.model = YOLO('yolo11n.pt')
        self.cap = cv2.VideoCapture(0)
        self.people_count = 0
        self.total_people = 0
    
    def count_people(self, frame):
        """统计画面中的人数"""
        results = self.model(frame, classes=[0])  # 只检测人（COCO数据集中人的类别ID是0）
        
        current_count = 0
        if len(results) > 0 and results[0].boxes is not None:
            current_count = len(results[0].boxes)
        
        # 更新统计
        if current_count != self.people_count:
            self.people_count = current_count
            self.total_people += abs(current_count - self.people_count)
        
        return current_count
    
    def run(self):
        while True:
            ret, frame = self.cap.read()
            if not ret:
                break
            
            # 统计人数
            count = self.count_people(frame)
            
            # 在画面上显示统计信息
            cv2.putText(frame, f"当前人数: {count}", (10, 30),
                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            cv2.putText(frame, f"总人次: {self.total_people}", (10, 70),
                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            
            # 显示
            cv2.imshow('People Counter', frame)
            
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
        
        self.cap.release()
        cv2.destroyAllWindows()

6.2 车辆检测与跟踪

对于交通监控场景：

class VehicleTracker:
    def __init__(self):
        # 加载模型，只检测车辆相关类别
        # COCO数据集中：2-汽车, 3-摩托车, 5-公交车, 7-卡车
        self.model = YOLO('yolo11n.pt')
        self.cap = cv2.VideoCapture(0)
        
        # 跟踪器，记录车辆位置
        self.tracked_vehicles = {}
        self.next_id = 0
    
    def track_vehicles(self, frame):
        """检测并跟踪车辆"""
        # 检测车辆
        results = self.model(frame, classes=[2, 3, 5, 7])
        
        current_vehicles = []
        if len(results) > 0 and results[0].boxes is not None:
            for box in results[0].boxes:
                x1, y1, x2, y2 = box.xyxy[0].tolist()
                confidence = box.conf[0].item()
                class_id = int(box.cls[0].item())
                
                # 计算中心点
                center_x = (x1 + x2) / 2
                center_y = (y1 + y2) / 2
                
                current_vehicles.append({
                    'bbox': [x1, y1, x2, y2],
                    'center': (center_x, center_y),
                    'class_id': class_id,
                    'confidence': confidence
                })
        
        # 简单的跟踪逻辑（实际应用中可以用更复杂的跟踪算法）
        # 这里只是示例：如果车辆中心点距离很近，认为是同一个车辆
        updated_tracks = {}
        
        for vehicle in current_vehicles:
            center = vehicle['center']
            matched = False
            
            for track_id, track_info in self.tracked_vehicles.items():
                old_center = track_info['center']
                # 计算距离
                distance = ((center[0] - old_center[0])**2 + 
                           (center[1] - old_center[1])**2)**0.5
                
                # 如果距离小于阈值，认为是同一个车辆
                if distance < 50:  # 阈值可以根据实际情况调整
                    updated_tracks[track_id] = {
                        'bbox': vehicle['bbox'],
                        'center': center,
                        'class_id': vehicle['class_id'],
                        'confidence': vehicle['confidence']
                    }
                    matched = True
                    break
            
            # 如果没有匹配到，认为是新车辆
            if not matched:
                updated_tracks[self.next_id] = {
                    'bbox': vehicle['bbox'],
                    'center': center,
                    'class_id': vehicle['class_id'],
                    'confidence': vehicle['confidence']
                }
                self.next_id += 1
        
        self.tracked_vehicles = updated_tracks
        return current_vehicles
    
    def run(self):
        while True:
            ret, frame = self.cap.read()
            if not ret:
                break
            
            # 检测和跟踪车辆
            vehicles = self.track_vehicles(frame)
            
            # 在画面上绘制结果
            for track_id, vehicle in self.tracked_vehicles.items():
                x1, y1, x2, y2 = vehicle['bbox']
                
                # 绘制边界框
                cv2.rectangle(frame, (int(x1), int(y1)), 
                             (int(x2), int(y2)), (0, 255, 0), 2)
                
                # 显示ID和类别
                label = f"ID:{track_id}"
                cv2.putText(frame, label, (int(x1), int(y1)-10),
                           cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
            
            # 显示统计信息
            cv2.putText(frame, f"车辆数: {len(vehicles)}", (10, 30),
                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            cv2.putText(frame, f"跟踪数: {len(self.tracked_vehicles)}", (10, 70),
                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            
            cv2.imshow('Vehicle Tracker', frame)
            
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
        
        self.cap.release()
        cv2.destroyAllWindows()

6.3 区域入侵检测

安防监控常用功能：

class IntrusionDetector:
    def __init__(self):
        self.model = YOLO('yolo11n.pt')
        self.cap = cv2.VideoCapture(0)
        
        # 定义监控区域（示例：画面中心的一个矩形区域）
        self.monitor_area = {
            'x1': 200, 'y1': 150,
            'x2': 400, 'y2': 350
        }
        
        self.intrusion_count = 0
    
    def check_intrusion(self, detections):
        """检查是否有入侵到监控区域"""
        intrusions = []
        
        for detection in detections:
            x1, y1, x2, y2 = detection['bbox']
            
            # 计算检测框中心点
            center_x = (x1 + x2) / 2
            center_y = (y1 + y2) / 2
            
            # 检查中心点是否在监控区域内
            if (self.monitor_area['x1'] <= center_x <= self.monitor_area['x2'] and
                self.monitor_area['y1'] <= center_y <= self.monitor_area['y2']):
                intrusions.append(detection)
        
        return intrusions
    
    def run(self):
        print("监控区域入侵检测已启动")
        print("按'q'键退出")
        
        while True:
            ret, frame = self.cap.read()
            if not ret:
                break
            
            # 绘制监控区域
            cv2.rectangle(frame, 
                         (self.monitor_area['x1'], self.monitor_area['y1']),
                         (self.monitor_area['x2'], self.monitor_area['y2']),
                         (0, 0, 255), 2)
            cv2.putText(frame, "监控区域", 
                       (self.monitor_area['x1'], self.monitor_area['y1']-10),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
            
            # 检测人
            results = self.model(frame, classes=[0], verbose=False)
            
            detections = []
            if len(results) > 0 and results[0].boxes is not None:
                for box in results[0].boxes:
                    x1, y1, x2, y2 = box.xyxy[0].tolist()
                    confidence = box.conf[0].item()
                    
                    detections.append({
                        'bbox': [x1, y1, x2, y2],
                        'confidence': confidence,
                        'class_name': 'person'
                    })
            
            # 检查入侵
            intrusions = self.check_intrusion(detections)
            
            if intrusions:
                self.intrusion_count += 1
                # 发出警报（这里用控制台输出模拟）
                print(f"警报！检测到{len(intrusions)}人入侵监控区域")
                
                # 在画面上标记入侵者
                for intrusion in intrusions:
                    x1, y1, x2, y2 = intrusion['bbox']
                    cv2.rectangle(frame, (int(x1), int(y1)), 
                                 (int(x2), int(y2)), (0, 0, 255), 3)
                    cv2.putText(frame, "INTRUSION!", (int(x1), int(y1)-10),
                               cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
            
            # 显示统计信息
            cv2.putText(frame, f"检测到人数: {len(detections)}", (10, 30),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
            cv2.putText(frame, f"入侵次数: {self.intrusion_count}", (10, 60),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
            
            cv2.imshow('Intrusion Detection', frame)
            
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
        
        self.cap.release()
        cv2.destroyAllWindows()
        print(f"监控结束，总入侵次数: {self.intrusion_count}")

7. 总结

通过这篇文章，你应该已经掌握了YOLO11对接摄像头进行实时检测的完整流程。我们从环境准备开始，一步步实现了摄像头读取、模型加载、实时检测，还探讨了几个实际应用场景。

关键要点回顾：

1. 环境搭建很简单：使用预制的YOLO11镜像，省去了复杂的配置过程
2. 摄像头对接不复杂：用OpenCV的VideoCapture几行代码就能搞定
3. 实时检测有技巧：选择合适的模型、调整分辨率、合理跳帧都能提升性能
4. 应用场景很丰富：从基础检测到人数统计、车辆跟踪、入侵检测，YOLO11都能胜任

给初学者的建议：

• 先从最简单的代码开始，确保摄像头能正常读取
• 使用yolo11n这种小模型，确保实时性
• 慢慢增加功能，不要一开始就想做太复杂的应用
• 多调试，遇到问题先看错误信息，大部分问题都有解决方案

下一步可以尝试：

• 训练自己的数据集，让模型识别特定物体
• 结合其他传感器，比如红外、雷达
• 部署到边缘设备，比如树莓派、Jetson Nano
• 开发Web界面，远程查看检测结果

实时目标检测是一个很有意思的方向，既有技术挑战，又有实际应用价值。希望这篇文章能帮你快速入门，做出自己的AI摄像头应用。

---

获取更多AI镜像

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