Kimi-VL-A3B-Thinking代码实例：Python调用vLLM服务+Chainlit前端集成

Kimi-VL-A3B-Thinking代码实例：Python调用vLLM服务+Chainlit前端集成

1. 引言：让图文对话模型触手可及

想象一下，你有一张复杂的图表，或者一张充满文字的店铺招牌照片，你想快速知道里面的内容是什么。传统方法可能需要你手动输入文字描述，或者用专门的OCR工具识别，整个过程繁琐又耗时。

现在，有了Kimi-VL-A3B-Thinking这样的多模态模型，你只需要上传图片，然后用自然语言提问，它就能像真人一样"看懂"图片并回答你的问题。更棒的是，通过vLLM部署和Chainlit前端集成，你可以轻松搭建一个属于自己的图文对话应用。

本文将带你一步步实现这个目标。无论你是开发者、研究人员，还是对AI应用感兴趣的技术爱好者，都能跟着教程快速上手。我们会从模型的基本介绍开始，然后详细讲解如何用Python调用vLLM服务，最后集成一个美观易用的Chainlit前端界面。

2. Kimi-VL-A3B-Thinking模型简介

2.1 模型的核心能力

Kimi-VL-A3B-Thinking是一个专门为图文对话设计的开源模型。它的名字听起来有点复杂，但理解起来很简单：

• Kimi-VL：这是模型的基础版本，VL代表"视觉语言"，说明它能同时处理图像和文字
• A3B：表示激活参数是28亿，这是一个相对轻量的设计，意味着它运行速度快、资源消耗少
• Thinking：这是模型的思考版本，经过特殊训练，具备更强的推理能力

简单来说，这就是一个能"看懂"图片并"思考"回答问题的AI助手。

2.2 模型的技术特点

这个模型有几个值得关注的亮点：

混合专家架构：你可以把它想象成一个专家团队。当遇到不同问题时，模型会自动选择最合适的"专家"来处理，这样既保证了能力，又控制了计算成本。

原生高分辨率视觉编码：很多模型在处理高清图片时需要先压缩，会丢失细节。但Kimi-VL使用MoonViT技术，能直接处理高分辨率图片，保留更多细节信息。

长上下文理解：模型能处理很长的对话历史和复杂的图片内容，这在多轮对话中特别有用。

强大的推理能力：经过特殊训练的"Thinking"版本，在数学推理、图表分析、文档理解等任务上表现突出。

2.3 实际应用场景

这个模型能做什么？举几个例子：

• 文档分析：上传一份扫描的合同或报告，让它帮你总结要点
• 图表解读：给一张复杂的数据图表，让它分析趋势和关键信息
• 商品识别：拍一张店铺招牌或产品包装，让它识别品牌和产品信息
• 作业辅导：上传数学题或物理题的图片，让它一步步讲解解题思路
• 内容创作：根据图片内容生成描述文案或创意故事

3. 环境准备与vLLM服务调用

3.1 检查模型服务状态

在开始编写代码之前，我们需要确认vLLM服务已经正常运行。如果你使用的是预部署的环境，可以通过以下命令检查：

# 查看服务日志，确认模型加载状态
cat /root/workspace/llm.log

如果看到类似下面的输出，说明服务已经启动成功：

INFO 07-28 10:30:15 llm_engine.py:73] Initializing an LLM engine…
INFO 07-28 10:30:20 model_runner.py:155] Loading model weights…
INFO 07-28 10:30:45 model_runner.py:178] Model loaded successfully.
INFO 07-28 10:30:46 llm_engine.py:210] LLM engine initialized.

第一次加载模型可能需要一些时间，请耐心等待。模型加载完成后，服务会在指定端口（通常是8000）监听请求。

3.2 安装必要的Python包

我们需要安装几个Python库来调用服务和构建前端：

pip install requests pillow chainlit opencv-python

这些包的作用分别是：

• requests：用于发送HTTP请求到vLLM服务
• pillow：处理图片文件
• chainlit：构建聊天界面
• opencv-python：可选，用于图片预处理

3.3 基础Python调用代码

让我们先写一个最简单的Python脚本来测试模型服务：

import requests
import base64
from PIL import Image
import io

def encode_image_to_base64(image_path):
"""将图片转换为base64编码"""
with Image.open(image_path) as img:
# 转换为RGB模式（如果是RGBA）
if img.mode in ('RGBA', 'LA'):
background = Image.new('RGB', img.size, (255, 255, 255))
background.paste(img, mask=img.split()[-1] if img.mode == 'RGBA' else None)
img = background

# 保存到字节流并编码
buffered = io.BytesIO()
img.save(buffered, format="JPEG", quality=95)
img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')
return img_str

def call_kimi_vl(image_path, question, api_url="http://localhost:8000/v1/chat/completions"):
"""调用Kimi-VL模型服务"""

# 准备请求数据
messages = [
{
"role": "user",
"content": [
{"type": "text", "text": question},
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{encode_image_to_base64(image_path)}"
}
}
]
}
]

payload = {
"model": "kimi-vl-a3b-thinking",
"messages": messages,
"max_tokens": 1024,
"temperature": 0.7
}

# 发送请求
try:
response = requests.post(api_url, json=payload)
response.raise_for_status()
result = response.json()

# 提取回复内容
if "choices" in result and len(result["choices"]) > 0:
return result["choices"][0]["message"]["content"]
else:
return "未收到有效回复"

except requests.exceptions.RequestException as e:
return f"请求失败: {str(e)}"
except Exception as e:
return f"处理失败: {str(e)}"

# 测试调用
if __name__ == "__main__":
# 替换为你的图片路径
test_image = "test.jpg"
test_question = "图中店铺名称是什么？"

if os.path.exists(test_image):
answer = call_kimi_vl(test_image, test_question)
print(f"问题: {test_question}")
print(f"回答: {answer}")
else:
print(f"图片文件 {test_image} 不存在，请先准备测试图片")

这段代码做了几件事：

3.4 处理不同类型的图片问题

模型不仅能回答简单的问题，还能处理复杂的推理任务。下面是一些不同场景的调用示例：

def analyze_chart(image_path):
"""分析图表数据"""
question = "请分析这张图表的主要趋势和关键数据点"
return call_kimi_vl(image_path, question)

def extract_text_from_document(image_path):
"""从文档中提取文字信息"""
question = "提取这张图片中的所有文字内容，并按照段落整理"
return call_kimi_vl(image_path, question)

def solve_math_problem(image_path):
"""解决数学问题"""
question = "请解答这道数学题，并给出详细的解题步骤"
return call_kimi_vl(image_path, question)

def describe_scene(image_path):
"""描述场景内容"""
question = "详细描述这张图片中的场景、人物和活动"
return call_kimi_vl(image_path, question)

你可以根据实际需求调整问题，模型会根据图片内容给出相应的回答。

4. Chainlit前端集成实战

4.1 为什么选择Chainlit？

Chainlit是一个专门为AI应用设计的聊天界面框架，它有以下几个优点：

• 开发简单：几行代码就能搭建一个漂亮的聊天界面
• 功能丰富：支持文件上传、图片显示、代码高亮等
• 响应式设计：在电脑和手机上都能良好显示
• 易于扩展：可以方便地添加自定义组件和功能

4.2 创建完整的Chainlit应用

让我们创建一个完整的图文对话应用：

# app.py
import chainlit as cl
import requests
import base64
import io
from PIL import Image
import os
from typing import Optional

# 模型服务配置
MODEL_API_URL = "http://localhost:8000/v1/chat/completions"
MODEL_NAME = "kimi-vl-a3b-thinking"

def encode_image(image: Image.Image) -> str:
"""将PIL图片转换为base64字符串"""
buffered = io.BytesIO()

# 根据图片模式处理
if image.mode in ('RGBA', 'LA', 'P'):
# 处理透明或调色板图片
if image.mode == 'P':
image = image.convert('RGBA')
background = Image.new('RGB', image.size, (255, 255, 255))
if image.mode == 'RGBA':
background.paste(image, mask=image.split()[-1])
else:
background.paste(image)
image = background

# 保存为JPEG
image.save(buffered, format="JPEG", quality=95)
img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')
return img_str

async def call_model_with_image(image_base64: str, question: str) -> str:
"""调用模型API"""

messages = [
{
"role": "user",
"content": [
{"type": "text", "text": question},
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{image_base64}"
}
}
]
}
]

payload = {
"model": MODEL_NAME,
"messages": messages,
"max_tokens": 2048,
"temperature": 0.7,
"top_p": 0.9
}

try:
response = requests.post(MODEL_API_URL, json=payload, timeout=60)
response.raise_for_status()
result = response.json()

if "choices" in result and len(result["choices"]) > 0:
return result["choices"][0]["message"]["content"]
else:
return "模型返回了空响应"

except requests.exceptions.Timeout:
return "请求超时，请稍后重试"
except requests.exceptions.RequestException as e:
return f"网络请求失败: {str(e)}"
except Exception as e:
return f"处理失败: {str(e)}"

@cl.on_chat_start
async def start_chat():
"""聊天开始时的初始化"""

# 欢迎消息
welcome_msg = """👋 欢迎使用 Kimi-VL 图文对话助手！

我可以帮你：
1. 📷 分析图片内容
2. 📄 解读文档图表
3. 🔍 识别文字信息
4. 🤔 解答图片相关问题

请上传一张图片，然后输入你的问题吧！"""

await cl.Message(content=welcome_msg).send()

# 设置聊天设置
settings = await cl.ChatSettings(
[
cl.input_widget.Slider(
id="temperature",
label="创造性",
initial=0.7,
min=0,
max=1,
step=0.1
),
cl.input_widget.Slider(
id="max_tokens",
label="回答长度",
initial=1024,
min=256,
max=4096,
step=256
)
]
).send()

@cl.on_message
async def handle_message(message: cl.Message):
"""处理用户消息"""

# 获取聊天设置
settings = await cl.ChatSettings.get_by_user(message.user.identifier)
temperature = settings.get("temperature", 0.7)
max_tokens = settings.get("max_tokens", 1024)

# 检查是否有图片
images = [file for file in message.elements if "image" in file.mime]

if not images:
# 如果没有图片，提示用户上传
await cl.Message(
content="请先上传一张图片，然后输入你的问题。"
).send()
return

# 处理第一张图片
image = images[0]
image_data = Image.open(image.path)

# 显示处理中的消息
msg = cl.Message(content="正在分析图片…")
await msg.send()

try:
# 编码图片
image_base64 = encode_image(image_data)

# 调用模型
response = await call_model_with_image(image_base64, message.content)

# 更新消息内容
msg.content = response
await msg.update()

except Exception as e:
error_msg = f"处理过程中出现错误: {str(e)}"
msg.content = error_msg
await msg.update()

@cl.on_settings_update
async def handle_settings_update(settings):
"""处理设置更新"""
await cl.Message(
content=f"设置已更新：创造性={settings['temperature']}，回答长度={settings['max_tokens']}"
).send()

# Chainlit配置文件
# chainlit.md
"""
# Kimi-VL 图文对话助手

这是一个基于 Kimi-VL-A3B-Thinking 模型的图文对话应用。

## 功能特点
– 支持图片上传和分析
– 自然语言提问
– 实时对话交互
– 可调节的回答参数

## 使用方法
1. 点击上传按钮选择图片
2. 在输入框中输入你的问题
3. 等待模型分析并回复

## 示例问题
– 图中有什么？
– 这张图表说明了什么？
– 提取图片中的文字
– 分析这个场景
"""

if __name__ == "__main__":
# 运行Chainlit应用
# 在终端执行：chainlit run app.py
pass

4.3 配置Chainlit界面

为了让界面更美观，我们可以添加一些自定义配置：

# chainlit配置 – 添加到app.py同级目录的chainlit.md文件
"""
# 欢迎使用 Kimi-VL 图文对话助手 🚀

## 🎯 我能做什么？
我是一个多模态AI助手，可以：
– **看图说话**：描述图片内容
– **文字识别**：提取图片中的文字
– **图表分析**：解读数据图表
– **问题解答**：回答关于图片的任何问题

## 📝 使用指南
1. **上传图片**：点击左下角的上传按钮或拖拽图片到聊天窗口
2. **输入问题**：用自然语言描述你想了解的内容
3. **获取答案**：我会分析图片并给出详细回答

## 💡 使用技巧
– 问题越具体，回答越准确
– 可以上传多种格式的图片（JPG、PNG等）
– 支持多轮对话，可以基于之前的回答继续提问

## ⚙️ 参数调节
在右侧设置面板可以调整：
– **创造性**：值越高回答越有创意，值越低回答越保守
– **回答长度**：控制回答的详细程度

开始你的图文对话之旅吧！✨
"""

4.4 运行Chainlit应用

保存好代码后，在终端中运行：

# 启动Chainlit应用
chainlit run app.py -w

# 或者指定端口运行
chainlit run app.py –port 7860

启动后，打开浏览器访问 http://localhost:7860（或你指定的端口），就能看到聊天界面了。

5. 高级功能与优化技巧

5.1 支持多图片上传

有时候我们需要同时分析多张图片，Chainlit可以轻松实现这个功能：

@cl.on_message
async def handle_multiple_images(message: cl.Message):
"""处理多张图片的消息"""

images = [file for file in message.elements if "image" in file.mime]

if len(images) == 0:
await cl.Message(content="请上传至少一张图片").send()
return

if len(images) > 5:
await cl.Message(content="一次最多上传5张图片").send()
return

# 显示处理进度
progress_msg = cl.Message(content=f"正在处理 {len(images)} 张图片…")
await progress_msg.send()

responses = []
for i, image_file in enumerate(images):
try:
image_data = Image.open(image_file.path)
image_base64 = encode_image(image_data)

# 为每张图片添加编号
question_with_context = f"这是第{i+1}张图片：{message.content}"
response = await call_model_with_image(image_base64, question_with_context)

responses.append(f"**图片{i+1}分析结果：**\\n{response}")

# 更新进度
progress_msg.content = f"已处理 {i+1}/{len(images)} 张图片…"
await progress_msg.update()

except Exception as e:
responses.append(f"**图片{i+1}处理失败：**{str(e)}")

# 发送所有结果
final_response = "\\n\\n".join(responses)
progress_msg.content = final_response
await progress_msg.update()

5.2 添加历史对话记录

让模型能够记住之前的对话内容：

from collections import deque

class ConversationHistory:
"""管理对话历史"""

def __init__(self, max_length=10):
self.history = deque(maxlen=max_length)

def add_message(self, role, content, image_base64=None):
"""添加消息到历史"""
message = {"role": role, "content": []}

if content:
message["content"].append({"type": "text", "text": content})

if image_base64:
message["content"].append({
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{image_base64}"}
})

self.history.append(message)

def get_messages(self):
"""获取所有历史消息"""
return list(self.history)

def clear(self):
"""清空历史"""
self.history.clear()

# 在Chainlit应用中使用
@cl.on_chat_start
async def start_chat_with_history():
"""带历史记录的聊天初始化"""
# 为每个用户创建独立的对话历史
cl.user_session.set("history", ConversationHistory())

welcome_msg = """欢迎！我可以记住我们的对话历史。
你可以连续提问，我会基于之前的对话内容来回答。"""

await cl.Message(content=welcome_msg).send()

@cl.on_message
async def handle_message_with_history(message: cl.Message):
"""处理带历史记录的消息"""

history = cl.user_session.get("history")
images = [file for file in message.elements if "image" in file.mime]

if images:
image_data = Image.open(images[0].path)
image_base64 = encode_image(image_data)

# 将用户消息加入历史
history.add_message("user", message.content, image_base64)
else:
history.add_message("user", message.content)

# 准备包含历史的请求
messages = history.get_messages()

# 调用模型（需要修改call_model_with_image函数以支持消息列表）
response = await call_model_with_messages(messages)

# 将模型回复加入历史
history.add_message("assistant", response)

await cl.Message(content=response).send()

5.3 错误处理与重试机制

在实际使用中，网络或服务可能不稳定，我们需要添加健壮的错误处理：

import time
from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
async def call_model_with_retry(image_base64: str, question: str) -> str:
"""带重试机制的模型调用"""

messages = [
{
"role": "user",
"content": [
{"type": "text", "text": question},
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{image_base64}"
}
}
]
}
]

payload = {
"model": MODEL_NAME,
"messages": messages,
"max_tokens": 1024,
"temperature": 0.7
}

try:
response = requests.post(
MODEL_API_URL,
json=payload,
timeout=30,
headers={"Content-Type": "application/json"}
)

if response.status_code == 200:
result = response.json()
if "choices" in result and result["choices"]:
return result["choices"][0]["message"]["content"]
else:
raise ValueError("模型返回格式异常")
else:
raise Exception(f"API请求失败: {response.status_code}")

except requests.exceptions.Timeout:
raise Exception("请求超时")
except requests.exceptions.ConnectionError:
raise Exception("连接失败")
except Exception as e:
raise Exception(f"调用失败: {str(e)}")

async def safe_call_model(image_base64: str, question: str) -> str:
"""安全的模型调用，包含完整的错误处理"""

max_retries = 3
for attempt in range(max_retries):
try:
return await call_model_with_retry(image_base64, question)

except Exception as e:
if attempt == max_retries – 1:
# 最后一次尝试也失败
error_msg = f"模型调用失败，已重试{max_retries}次。错误: {str(e)}"

# 根据错误类型提供建议
if "超时" in str(e) or "连接" in str(e):
error_msg += "\\n\\n建议：请检查模型服务是否正常运行，或稍后重试。"
elif "格式异常" in str(e):
error_msg += "\\n\\n建议：可能是模型服务返回数据格式有问题，请检查服务状态。"

return error_msg
else:
# 等待后重试
wait_time = 2 ** attempt # 指数退避
print(f"第{attempt+1}次尝试失败，{wait_time}秒后重试…")
time.sleep(wait_time)

return "模型调用失败，请稍后重试"

5.4 性能优化建议

如果你的应用需要处理大量请求，可以考虑以下优化：

import asyncio
from concurrent.futures import ThreadPoolExecutor
import aiohttp
import async_timeout

# 使用异步HTTP客户端
async def call_model_async(image_base64: str, question: str) -> str:
"""异步调用模型API"""

messages = [
{
"role": "user",
"content": [
{"type": "text", "text": question},
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{image_base64}"
}
}
]
}
]

payload = {
"model": MODEL_NAME,
"messages": messages,
"max_tokens": 1024,
"temperature": 0.7
}

async with aiohttp.ClientSession() as session:
try:
async with async_timeout.timeout(30):
async with session.post(
MODEL_API_URL,
json=payload,
headers={"Content-Type": "application/json"}
) as response:

if response.status == 200:
result = await response.json()
if "choices" in result and result["choices"]:
return result["choices"][0]["message"]["content"]
else:
return "模型返回了空响应"
else:
return f"请求失败，状态码: {response.status}"

except asyncio.TimeoutError:
return "请求超时"
except Exception as e:
return f"请求异常: {str(e)}"

# 图片预处理优化
def optimize_image_processing(image_path, max_size=(1024, 1024)):
"""优化图片处理，减少传输数据量"""

with Image.open(image_path) as img:
# 调整图片大小
img.thumbnail(max_size, Image.Resampling.LANCZOS)

# 转换为RGB模式
if img.mode != 'RGB':
img = img.convert('RGB')

# 优化压缩
buffered = io.BytesIO()

# 根据图片内容选择质量参数
# 如果是文字多的图片，使用高质量压缩
# 如果是自然图片，可以适当降低质量
quality = 85 # 默认质量

img.save(buffered, format="JPEG", quality=quality, optimize=True)

# 检查文件大小
file_size = buffered.tell()
if file_size > 500 * 1024: # 如果大于500KB
# 进一步压缩
quality = 75
buffered = io.BytesIO()
img.save(buffered, format="JPEG", quality=quality, optimize=True)

img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')
return img_str

6. 实际应用案例展示

6.1 案例一：店铺招牌识别

让我们看一个实际的应用场景。假设你拍了一张街边店铺的照片：

# 示例：识别店铺信息
def analyze_shop_sign(image_path):
"""分析店铺招牌"""

questions = [
"图中店铺名称是什么？",
"这家店主要经营什么业务？",
"招牌上还有哪些重要信息？",
"根据招牌设计，你觉得这家店的定位是什么？"
]

results = []
for question in questions:
answer = call_kimi_vl(image_path, question)
results.append(f"**问题：** {question}\\n**回答：** {answer}\\n")

return "\\n".join(results)

# 实际调用
shop_analysis = analyze_shop_sign("shop_sign.jpg")
print(shop_analysis)

模型可能会返回这样的分析结果：

• 店铺名称：XX咖啡
• 主营业务：精品咖啡、轻食简餐
• 其他信息：营业时间8:00-22:00，提供WiFi
• 店铺定位：面向年轻白领的休闲咖啡厅

6.2 案例二：数据图表分析

对于数据图表，模型能提供深入的分析：

def analyze_data_chart(image_path):
"""分析数据图表"""

analysis_prompt = """请分析这张数据图表：
1. 图表展示的主要趋势是什么？
2. 有哪些关键的数据点或转折点？
3. 基于数据，你能得出什么结论或建议？
4. 图表的设计有什么优点或可以改进的地方？"""

return call_kimi_vl(image_path, analysis_prompt)

# 实际调用
chart_analysis = analyze_data_chart("sales_chart.png")
print(chart_analysis)

6.3 案例三：文档内容提取

处理扫描文档或照片中的文字：

def extract_document_content(image_path):
"""提取文档内容并整理"""

extraction_prompt = """请提取这张图片中的所有文字内容，并按照以下格式整理：
1. 文档标题（如果有）
2. 主要章节或段落
3. 关键数据或要点
4. 联系信息（如果有）

保持原文的格式和顺序，不要添加额外内容。"""

return call_kimi_vl(image_path, extraction_prompt)

# 实际调用
document_content = extract_document_content("document_photo.jpg")
print(document_content)

7. 总结与下一步建议

7.1 本文要点回顾

通过本文的讲解，我们完成了从零开始搭建Kimi-VL图文对话应用的完整流程：

7.2 可能遇到的问题与解决方案

在实际使用中，你可能会遇到一些问题，这里提供一些常见问题的解决方法：

问题1：模型服务连接失败

• 检查vLLM服务是否正常运行：curl http://localhost:8000/health
• 确认端口号是否正确
• 查看服务日志排查错误

问题2：图片上传后无响应

• 检查图片格式是否支持（JPG、PNG等）
• 确认图片大小是否合适（建议小于5MB）
• 查看网络连接是否正常

问题3：回答质量不理想

• 尝试调整temperature参数（0.3-0.9之间）
• 提供更具体的问题描述
• 确保图片清晰度足够

问题4：响应速度慢

• 优化图片大小和格式
• 考虑使用异步调用
• 检查服务器资源是否充足

7.3 进一步学习建议

如果你对这个应用感兴趣，想要进一步深入，可以考虑以下方向：

功能扩展

• 添加批量处理功能，一次上传多张图片进行分析
• 集成OCR功能，与专门的文字识别工具结合使用
• 添加导出功能，将对话记录保存为PDF或Markdown

性能优化

• 实现图片缓存机制，避免重复编码
• 使用WebSocket实现实时流式响应
• 添加负载均衡，支持多实例部署

应用场景拓展

• 结合RAG技术，构建基于图片的智能问答系统
• 开发浏览器插件，实现网页图片的快速分析
• 集成到现有工作流中，如客服系统、内容审核等

模型调优

• 学习如何微调模型以适应特定领域
• 探索不同的提示词工程技巧
• 了解模型量化技术，进一步优化性能

7.4 最后的建议

Kimi-VL-A3B-Thinking作为一个开源的多模态模型，为开发者提供了强大的图文理解能力。通过本文的实践，你应该已经掌握了如何将它集成到自己的应用中。

记住，技术的价值在于解决实际问题。不妨思考一下：

• 你工作中哪些场景需要处理图片和文字？
• 这个技术能帮你自动化哪些重复性工作？
• 如何结合你的业务需求，创造更有价值的应用？

从一个小功能开始，逐步完善，你会发现AI技术能为你的工作和生活带来实实在在的改变。

获取更多AI镜像

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