您现在的位置是：网站首页> AI人工智能
大模型本地化部署相关技术收集
- AI人工智能
- 2025-11-29
- 218人已阅读
大模型本地化部署相关技术收集
*本地模型部署工具部署模型，用Agent框架调用部署工具接口实现调用模型*
***多看看Hugingface与阿里魔塔社区查看模型及模型调用例子代码***
原生调用大模型
通过 llama-cpp-python 库加载本地大模型文件，同时启动兼容 OpenAI API 的本地服务
能否将adapter_model.safetensors和原始的Qwen-7B合并成一个safetensors文件
ModelScope Library HugingFace框架及LangChain框架区别
解决 Hugging Face 国内下载慢的问题：用 ModelScope 替代加速模型获取
本地直接调用模型实现
一个典型调用一个图像生成模型Qwen/Qwen-Image代码
LLM（大语言模型）部署Ollama相关（点击进入Ollama官网）
第一次用 Ollama 跑视觉模型：Qwen2.5-VL 7B
LLM（大语言模型）LM Studio技术
ComfyUI(工作流不只是支持图像，支持其他模型）
N8N工作流技术
Dify Agent开发
扣子技术
本地知识库搭建
YOLO
Cherry Studio
Cherry Studio 提供API服务
ChatBox
Page Assist
Ollama打开网络服务
第一次用 Ollama 跑视觉模型：Qwen2.5-VL 7B
前几天在 Mac 上安装了 Ollama，并下载了 Qwen2.5-VL 7B 做了一些测试，整个过程还挺有意思，分享给大家。
1 Mac 安装 Ollama
进入 Ollama 官网 ，我的电脑是 Mac Studio ，所以选择 MacOS 下载 。
下载完成后，双击安装 ，安装完成后界面如下图：
2 下载 Qwen 2.5 VL 7B
Qwen 2.5-VL 是阿里巴巴通义千问团队开发的一款开源的旗舰级视觉语言模型。
它能够处理文本、图像和视频，并具备强大的视觉理解和交互能力。该模型有不同参数规模（如 3B、7B 和 72B），适用于从边缘 AI 到高性能计算的多种场景 。
下载 Qwen 2.5 VL 有两种方式 ：
1、通过命令行请求
ollama pull qwen2.5vl:7b
2、通过 Ollama GUI 界面安装
在 GUI 界面选择模型 ，若未下载会显示下载图标，然后在对话框中输入任意文本即可自动下载。
3 文本/图片体验
下载完模型后，即可在对话框中进行对话。
当然我们也可以通过 ollama 启动模型后展开对话：
ollama run qwen2.5vl:7b
接下来，进行图片检测，图片如下：
检测结果：
我们也可以通过该模型识别图像中的文字、公式或抽取票据、证件、表单中的信息，支持格式化输出文本：
4 程序调用分析图片
我们也可以编写 python 调用 Ollama 接口，同样是分析图片：
同样，Ollama 也支持兼容 OpenAI 的接口协议 ，可以实现流式对话，见下图：
curl http://localhost:11434/api/chat -d '{
"model": "qwen2.5vl:7b",
"messages": [
{ "role": "user", "content": "写一段代码" }
]
}'
效果见下图 ：
5 总结
Qwen 2.5-VL 7B 简直就是“本地视觉小钢炮”，各种图像信息都能一把抓，无论给它截图、票据、图表还是复杂场景，它都能有所作为。
笔者认为它尤其适合在如下场景中发挥作用：
文档和票据解析：发票、合同、报表、扫描件，一次推理即可提取文字并生成结构化数据
表格与图表解析：财务报表、统计图表，快速提取表头和数据，方便后续分析
图片场景理解：仓库、机房、办公室等照片，自动识别物体和整体场景
多模态问答：结合图片和文本内容回答问题，支持科研、教育或产品原型
内容审核与合规检测：识别敏感文字或违规图像，本地部署保护隐私
Ollama的配置修改与接口调用
一、修改环境变量
1.1 配置远程访问
在我们本地部署好ollama之后，仅支持本机访问，我们可以通过修改环境变量让其他人可以远程访问。
在wins电脑上增加环境变量：
OLLAMA_HOST 0.0.0.0:11434
1.2 配置本地模型路径
1.2.1 本地模型默认路径
wins本地模型默认路径：C:\Users\%username%\.ollama\models。
这里 %username% 是当前登录的用户名。例如，如果用户名为 Smqnz，则模型文件的默认存储路径可能是 C:\Users\Smqnz\.ollama\models。
以我的电脑为例：
C:\Users\admin\.ollama\models
1.2.2 修改本地模型默认路径
wins上的环境变量增加：
OLLAMA_MODELS 你想要存放的路径
以下为修改示例：
修改后，重启ollama即可。
1.3 配置允许的http请求来源
OLLAMA_ORIGINS 是 Ollama 中用于配置跨域资源共享（CORS）的环境变量，可以指定哪些来源（域名、IP 地址等）可以访问 Ollama 提供的 API 服务。
如果我们想让它接收任何来源(IP)的http请求的话，我们需要将其设置为*。
OLLAMA_ORIGINS *
这里一定要注意，以上修改的环境变量名称必须为大写，不要随意修改。
二、ollama常用API请求
一般来说，我们可以通过打开命令行窗口直接进行对话。
但是这种方式对于开发者来说并不实用，一般我们需要通过其API进行访问与开发，本次我们就来详细聊一下ollama常见的API
2.1 文本生成API
Ollama 提供了一套功能丰富的文本生成接口，方便用户与本地部署的模型进行交互，以下是其主要的文本生成接口及功能介绍：
接口路径：POST /api/generate
功能：向模型发送提示（prompt），生成文本回复。
请求参数：
model：模型名称，如 “deepseek-r1:7b”。
prompt：输入的提示文本。
stream：是否启用流式输出，默认为 false。
options：可选参数，包括：
temperature：控制生成文本的多样性，取值范围通常为 0 到 1。
max\_tokens：最大生成的 token 数量。
top\_p：Top-p 采样参数。
2.2 对话聊天API
接口路径：POST /api/chat
功能：支持多轮对话，模型会记住上下文。
请求参数：
model：模型名称。
messages：消息列表，包含用户输入和模型回复，格式为 {“role”: “user”, “content”: “用户输入内容”}。
stream：是否启用流式输出，默认为 false。
options：可选参数，与生成文本接口类似。
三、ollama兼容openai的请求
3.1 单轮对话
3.2 多轮对话
可以看到，多轮对话可以通过维护问答列表能够很好地理解上下文的含义。
分享一个手动导入 ollama 本地模型的方法
####【豆包】
Q:Ollama如何实现导入本地模型
A:...
Ollama 本地模型导入全攻略
Ollama 支持三种导入本地模型的方式：从 GGUF 文件导入、从 Safetensors 权重导入、以及导入微调适配器（LoRA）。推荐优先使用GGUF格式，性能与兼容性更佳。
一、从 GGUF 文件导入（推荐）
步骤 1：准备模型文件
确保拥有GGUF格式的模型文件（.gguf）
如无 GGUF 文件，可通过以下方式获取：
使用 Llama.cpp 的 convert_hf_to_gguf.py 将 Hugging Face 的 Safetensors 模型转换为 GGUF
从 Hugging Face 等模型仓库下载预转换的 GGUF 模型
步骤 2：创建 Modelfile在模型文件所在目录创建名为Modelfile的文件，内容如下：
plaintext
FROM /path/to/your_model.gguf
若 Modelfile 与模型文件在同一目录，可简化为：
plaintext
FROM .
步骤 3：导入模型打开终端，执行以下命令：
bash
ollama create my-model-name -f ./Modelfile
其中，my-model-name为你自定义的模型名称，-f指定 Modelfile 路径
步骤 4：验证导入
bash
ollama run my-model-name "Hello, Ollama!"
二、从 Safetensors 权重导入
方式 A：导入完整模型
1.在包含 Safetensors 权重文件的目录中创建 Modelfile：
plaintext
FROM /path/to/safetensors/directory
2.执行创建命令：
bash
ollama create my-safetensors-model -f ./Modelfile
方式 B：导入微调适配器（LoRA）
1.创建 Modelfile，指定基础模型与适配器路径：
plaintext
FROM base-model-name
ADAPTER /path/to/safetensors/adapter
确保 base-model-name 与创建适配器时使用的基础模型一致
2.执行创建命令：
bash
ollama create my-tuned-model -f ./Modelfile
三、高级技巧
模型量化（推荐）
使用量化可显著降低内存占用并提升推理速度：
bash
ollama create my-model --quantize q4_K_M
支持的量化选项包括：q4_0、q4_1、q5_0、q5_1、q8_0以及 K-means 量化：q3_K_M、q4_K_M等
自定义模型参数在 Modelfile 中可添加参数与系统提示：
plaintext
FROM llama3.2
# 设置温度为0.7（更具创造性）
PARAMETER temperature 0.7
# 设置系统提示
SYSTEM """
你是一位专业的翻译专家，将中文翻译成英文。
"""
然后按常规创建模型：
bash
ollama create my-translator-model -f ./Modelfile
四、常见问题与解决方案
导入速度慢：模型文件较大（如 33B 参数）可能需要一些时间，请耐心等待
内存不足：尝试使用量化（如q4_K_M）以减少内存占用；7B 建议≥8GB RAM，13B 建议≥16GB RAM
模型不兼容：确认模型架构受支持（Llama 系列、Mistral 系列、Gemma 系列、Phi-3 等）
五、总结
Ollama 导入本地模型的核心是使用Modelfile声明模型来源，然后通过ollama create完成导入与构建。优先使用GGUF格式并配合量化，可在性能与资源占用间取得良好平衡。
导入流程速记：准备模型文件 → 创建 Modelfile → 执行ollama create → 用ollama run验证。
需要我根据你准备导入的模型格式（GGUF 或 Safetensors）和硬件情况，帮你生成一条可直接复制的量化导入命令吗？如果你告诉我模型路径、目标名称和可用内存，我也可以一并优化参数。
ComfyUI咒语
####【豆包】
Q:ComfyUI熟悉吗？
A:...
Q:详细讲解一下典型节点的连线口，比如模型 lora等
A:...
Ollama API
文本生成API
Ollama 提供了一套功能丰富的文本生成接口，方便用户与本地部署的模型进行交互，以下是其主要的文本生成接口及功能介绍：
接口路径：POST /api/generate
功能：向模型发送提示（prompt），生成文本回复。
请求参数：
model：模型名称，如 “deepseek-r1:7b”。
prompt：输入的提示文本。
stream：是否启用流式输出，默认为 false。
options：可选参数，包括：
temperature：控制生成文本的多样性，取值范围通常为 0 到 1。
max_tokens：最大生成的 token 数量。
top_p：Top-p 采样参数。
对话聊天API
接口路径：POST /api/chat
功能：支持多轮对话，模型会记住上下文。
请求参数：
model：模型名称。
messages：消息列表，包含用户输入和模型回复，格式为 {“role”: “user”, “content”: “用户输入内容”}。
stream：是否启用流式输出，默认为 false。
options：可选参数，与生成文本接口类似。
ollama兼容openai的请求
单轮对话
from openai import OpenAI
client = OpenAI(base_url="http://localhost:11434/v1", # Ollama默认API地址
api_key="test" # 必填字段但会被忽略，随便填写即可
)
response = client.chat.completions.create(model="deepseek-r1:8b", # 替换为已下载的模型名称
messages=[`{"role": "system", "content": "你是一个有帮助的助手"},
{"role": "user", "content": "用50字解释量子计算"}`],
temperature=0.7,
max_tokens=1024)
print(response.choices[0].message.content)
多轮对话
from openai import OpenAI
def run_chat_session():
client = OpenAI(base_url="http://localhost:11434/v1/",api_key="test" # 必填但会被忽略`)
chat_history = []
while True:
user_input = input("用户：")
if user_input.lower() == "exit":
print("AI：对话结束")
break
chat_history.append({"role": "user", "content": user_input})
try:
response = client.chat.completions.create(messages=chat_history,model="deepseek-r1:8b" # 替换成你安装的模型名称)
ai_response = response.choices[0].message.content
print(f"AI：{ai_response}")
chat_history.append({"role": "assistant", "content": ai_response})
except Exception as e:
print(f"错误：{e}")
if __name__ == "__main__":
run_chat_session()
直接用OpenAI SDK成功调用Ollama
from openai import OpenAI
# 注意：这里不再需要加载 OPENAI_API_KEY，因为是本地调用
# 初始化客户端，但将 base_url 指向本地的 Ollama 服务
client = OpenAI(
base_url="http://localhost:11434/v1",
api_key="ollama", # Ollama 的兼容接口需要一个 api_key，但可以是任意非空字符串
)
try:
response = client.chat.completions.create(
messages=[
{
"role": "user",
"content": "用中文，讲个笑话",
}
],
# 这里使用 Ollama 本地的模型名称
model="deepseek-r1:7b",
)
# 解析响应的方式和原版 OpenAI API 完全一样
joke = response.choices[0].message.content
print(joke)
except Exception as e:
print(f"调用本地 Ollama 模型时出错: {e}")
Page Assist介绍
Page Assist是一款专为开发者设计的开源浏览器扩展程序，支持在Chromium和Firefox等主流浏览器中调用本地AI模型，实现网页内容的智能交互与隐私安全的数据处理。
插件安装完成后，接下来就是配置部分了。点击浏览器右上角的插件图标，进入插件的首页。
你会看到一个简单清晰的界面，接下来点击右上角的小齿轮按钮，进入设置页面。
在设置界面，你可以看到UI语言的选择。对于不太熟悉英文的小伙伴，推荐将语言设置为简体中文，这样会更加方便操作。
第四步：配置DeepSeek API
在设置页面的侧边栏，找到“OpenAI兼容API”这一项。
这就是我们要配置DeepSeek的地方。
点击“添加提供商”按钮，在弹出的窗口中选择“DeepSeek”。
接下来，你需要输入从DeepSeek官方获取到的API地址和API KEY，填写完毕后，记得点击“保存”。
保存后，你会看到一个模型列表，勾选上你需要使用的DeepSeek模型。
直接使用Post原始请求调用Ollama
import requests
import json
# 1. 配置你的信息
API_KEY = "ollama" # 替换成你的 API Key
BASE_URL = "http://localhost:11434/v1"
# 2. 定义请求头
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
# 3. 定义请求体 (Prompt)
data = {
"model": "deepseek-r1:7b", # 你可以替换成任何在 Cherry Studio 中配置好的模型，例如 "gemini-pro", "llama3:8b"
"messages": [
{"role": "system", "content": "你是一位 helpful 的助手。"},
{"role": "user", "content": "请用 Python 写一个函数，计算斐波那契数列的第 n 项。"}
],
"temperature": 0.7, # 控制生成结果的随机性
"stream": False # 是否使用流式传输
}
# 4. 发送 POST 请求
try:
print(f"向 {BASE_URL}/chat/completions 发送请求...")
response = requests.post(f"{BASE_URL}/chat/completions", headers=headers, data=json.dumps(data))
# 5. 检查响应状态
response.raise_for_status() # 如果请求失败，会抛出异常
# 6. 解析并打印结果
result = response.json()
print(result)
assistant_message = result['choices'][0]['message']['content']
print("\n" + "=" * 20 + " AI 回复 " + "=" * 20)
print(assistant_message)
print("=" * 52)
except requests.exceptions.RequestException as e:
print(f"请求失败: {e}")
if response:
print(f"错误详情: {response.text}")
调用Ollama的视觉模型qwen2.5vl:7b成功代码
import requests
import base64
import json
# 1. 配置你的信息
API_KEY = "ollama" # 替换成你的 API Key
BASE_URL = "http://localhost:11434"
# 2. 定义请求头
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
with open("e:/11.png","rb") as f:
img64=base64.b64encode(f.read()).decode()
# 3. 定义请求体 (Prompt)
data = {
"model": "qwen2.5vl:7b", # 你可以替换成任何在 Cherry Studio 中配置好的模型，例如 "gemini-pro", "llama3:8b"
"prompt": "详细说明这张图片",
"images": [img64],
"stream": False
}
# 4. 发送 POST 请求
try:
print(f"向 {BASE_URL}/generate发送请求...")
response = requests.post(f"{BASE_URL}/api/generate", headers=headers, json=data)
# 5. 检查响应状态
response.raise_for_status() # 如果请求失败，会抛出异常
# 6. 解析并打印结果
result = response.json()
print(result)
'''
assistant_message = result['choices'][0]['message']['content']
print("\n" + "=" * 20 + " AI 回复 " + "=" * 20)
print(assistant_message)
print("=" * 52)
'''
except requests.exceptions.RequestException as e:
print(f"请求失败: {e}")
if response:
print(f"错误详情: {response.text}")
一个典型调用一个图像生成模型Qwen/Qwen-Image代码
采样方法、采样步数、提示词引导系数、反向提示词、VAE、ControlNet之类的参数如何给
pip install git+https://github.com/huggingface/diffusers
from modelscope import DiffusionPipeline
import torch
import time
import os
# --- 优化点 1: 代码结构和可配置性 ---
# 将配置项集中管理，方便修改
CONFIG = {
"model_name": "Qwen/Qwen-Image",
"prompt": """A coffee shop entrance features a chalkboard sign reading "Qwen Coffee 😊 $2 per cup," with a neon light beside it displaying "通义千问". Next to it hangs a poster showing a beautiful Chinese woman, and beneath the poster is written "π≈3.1415926-53589793-23846264-33832795-02384197".""",
"positive_magic": "Ultra HD, 4K, cinematic composition, best quality, highly detailed, photorealistic",
"negative_prompt": "blurry, low quality, text error, watermark, signature, username, artist name, deformed, ugly, bad anatomy, extra limbs, missing fingers",
"aspect_ratio_key": "16:9", # 可在此处快速切换比例
"num_inference_steps": 50,
"true_cfg_scale": 4.5, # 稍微提高一点，让模型更遵守提示词
"seed": 42, # 固定种子以保证可复现性
}
# 宽高比配置
ASPECT_RATIOS = {
"1:1": (1024, 1024),
"16:9": (1344, 768), # 优化点 2: 使用更标准的、模型更适配的分辨率
"9:16": (768, 1344),
"4:3": (1152, 864),
"3:4": (864, 1152),
}
def main():
"""主函数，封装所有逻辑"""
print("--- Qwen-Image 图片生成 ---")
# --- 优化点 3: 设备和精度自动选择 ---
if torch.cuda.is_available():
device = "cuda"
# 优先使用 bfloat16，如果 GPU 不支持（如旧型号），则回退到 float16
torch_dtype = torch.bfloat16 if torch.cuda.get_device_capability()[0] >= 8 else torch.float16
print(f"检测到 GPU: {torch.cuda.get_device_name(0)}，将使用 {torch_dtype} 精度进行计算。")
else:
device = "cpu"
torch_dtype = torch.float32
print("未检测到 GPU，将使用 CPU 进行计算，这可能会非常慢。")
# --- 优化点 4: 打印完整提示词 ---
full_prompt = CONFIG["prompt"] + " " + CONFIG["positive_magic"]
print(f"\n使用的完整提示词:\n{full_prompt}")
print(f"\n使用的负面提示词:\n{CONFIG['negative_prompt']}")
# --- 优化点 5: 加载模型时显示信息 ---
print(f"\n正在从 ModelScope 加载模型: {CONFIG['model_name']} ... 这可能需要一些时间下载。")
start_time = time.time()
# 加载模型
pipe = DiffusionPipeline.from_pretrained(
CONFIG["model_name"],
torch_dtype=torch_dtype,
use_safetensors=True # 明确使用 safetensors，这是现在推荐的模型存储格式
)
pipe = pipe.to(device)
end_time = time.time()
print(f"模型加载完成，耗时: {end_time - start_time:.2f} 秒。")
# 准备生成参数
width, height = ASPECT_RATIOS[CONFIG["aspect_ratio_key"]]
print(f"\n将生成 {width}x{height} ({CONFIG['aspect_ratio_key']}) 的图片...")
# --- 优化点 6: 统一 Generator 设备 ---
# 确保 Generator 在正确的设备上
generator = torch.Generator(device=device).manual_seed(CONFIG["seed"])
# 执行生成
start_time = time.time()
result = pipe(
prompt=full_prompt,
negative_prompt=CONFIG["negative_prompt"],
width=width,
height=height,
num_inference_steps=CONFIG["num_inference_steps"],
true_cfg_scale=CONFIG["true_cfg_scale"],
generator=generator
)
end_time = time.time()
print(f"图片生成完成，耗时: {end_time - start_time:.2f} 秒。")
# --- 优化点 7: 结果处理和保存 ---
# 从结果中提取图片
image = result.images[0]
# 构建文件名，包含时间戳和分辨率信息，防止覆盖
timestamp = time.strftime("%Y%m%d_%H%M%S")
filename = f"qwen_image_{CONFIG['aspect_ratio_key']}_{timestamp}.png"
# 保存图片
image.save(filename)
print(f"图片已成功保存为: {filename}")
if __name__ == "__main__":
main()
####【豆包】
Q:这个模型Qwen/Qwen-Image格式应该是啥格式的
A:...
Qwen/Qwen-Image 模型的格式是 Safetensors，这是目前 Hugging Face 和 ModelScope 等平台上推荐的模型权重存储格式。
什么是 Safetensors？
Safetensors 是一种安全的张量存储格式，旨在解决传统 PyTorch .bin 格式的一些问题：
安全性：Safetensors 文件不执行任何代码，避免了恶意模型可能包含的代码注入风险。
兼容性：可以在 PyTorch、TensorFlow 等不同框架中轻松加载。
稳定性：文件结构设计更 robust，不易损坏。
元数据：包含完整的张量元数据（形状、 dtype 等），便于检查和调试。
在你的代码中，我已经加入了 use_safetensors=True 来明确指定使用这种格式
pipe = DiffusionPipeline.from_pretrained(
CONFIG["model_name"],
torch_dtype=torch_dtype,
use_safetensors=True # 明确使用 Safetensors 格式
)
模型文件结构
当你第一次运行代码时，模型会被下载到本地缓存目录（通常是 ~/.cache/modelscope 或 ~/.cache/huggingface）。你会看到类似以下的文件结构：
Qwen-Image/
├── model.safetensors # 主模型权重文件
├── model-00001-of-00002.safetensors # 如果模型很大，会分成多个部分
├── model-00002-of-00002.safetensors
├── config.json # 模型配置文件
├── scheduler_config.json # 调度器配置（扩散模型专用）
├── tokenizer.json # 分词器配置
└── ...
.safetensors 文件：包含模型的权重参数（权重、偏置等）。
config.json：定义了模型的架构、层数、隐藏层维度等超参数。
scheduler_config.json：扩散模型的调度器配置，控制生成过程中的噪声预测和去噪步骤。
tokenizer.json：文本分词器的配置，用于将输入的文本提示词转换为模型可理解的数字张量。
与其他格式的区别
Safetensors： 安全、跨框架兼容、稳定 相对较新，某些旧模型可能不支持
PyTorch .bin： 兼容性好（仅限 PyTorch） 可能包含恶意代码，文件易损坏
TensorFlow .ckpt： TensorFlow 原生支持 不兼容 PyTorch
如果遇到格式问题怎么办？
自动转换：如果模型只有 .bin 格式，from_pretrained 会自动将其转换为 Safetensors（需要安装 safetensors 库）。
手动转换：可以使用 transformers 库提供的转换工具：
python
运行
from transformers import AutoModel
model = AutoModel.from_pretrained("Qwen/Qwen-Image", torch_dtype=torch.float16)
model.save_pretrained("qwen-image-safetensors", safe_serialization=True)
安装依赖：确保安装了 safetensors 库：
bash
运行
pip install safetensors
Q:Qwen/Qwen-Image他的文件所在位置及文件名是？
A：...
文件所在位置 (默认缓存路径)
当你运行 DiffusionPipeline.from_pretrained("Qwen/Qwen-Image") 时，modelscope 或 huggingface 库会自动从其模型仓库下载模型文件，并将其缓存到你本地的一个默认目录中。
这个目录的位置取决于你的操作系统：
Linux / macOS:~/.cache/modelscope/hub/Qwen/Qwen-Image/
Windows:C:\Users\<你的用户名>\.cache\modelscope\hub\Qwen\Qwen-Image\
Q:采样方法、采样步数、提示词引导系数、反向提示词、VAE、ControlNet之类的参数如何给
A:...
好的，我们来详细梳理一下 采样方法、采样步数、提示词引导系数、反向提示词、VAE、ControlNet 这些关键参数的作用、可用选项以及如何在 Qwen/Qwen-Image 中进行设置。
1. 采样方法 (Scheduler)
作用：扩散模型生成图片的核心是通过 “去噪” 过程逐步还原图像，采样方法定义了去噪的具体算法，直接影响生成速度和图片质量。
常用采样方法：
PNDM 平衡速度与质量，适合大多数场景 较快 较好
DDIM 速度快，支持少步数生成 最快 中等
DDPM 原始方法，步数多但质量高 最慢 最高
Euler 简单高效，适合快速迭代 快 中等
Euler a Euler 的改进版，增加随机性 快 中等
代码设置：
from diffusers import PNDMParallelScheduler
# 加载模型时指定调度器
pipe = DiffusionPipeline.from_pretrained(
"Qwen/Qwen-Image",
scheduler=PNDMParallelScheduler.from_pretrained("Qwen/Qwen-Image", subfolder="scheduler"),
torch_dtype=torch_dtype
)
# 或者在生成时动态更换
pipe.scheduler = PNDMParallelScheduler.from_config(pipe.scheduler.config)
2. 采样步数 (num_inference_steps)
作用：控制去噪过程的迭代次数。步数越多，图片细节越丰富，但生成时间越长；步数越少，速度越快，但可能出现细节模糊或纹理不自然。
代码设置：
python
运行
image = pipe(
prompt=prompt,
num_inference_steps=50, # 可调整为 20-100
...
).images[0]
推荐范围：
DDIM：20-30 步
PNDM：30-50 步
DDPM：100+ 步
3. 提示词引导系数 (true_cfg_scale /guidance_scale)
作用：控制生成结果与提示词的匹配程度。系数越高，图片越贴合提示词，但可能牺牲创造性和自然度；系数越低，图片越有创意，但可能偏离提示词。
代码设置：
python
运行
image = pipe(
prompt=prompt,
true_cfg_scale=4.5, # Qwen 专用参数
# 其他模型可能用 guidance_scale=7.5
...
).images[0]
推荐范围：
true_cfg_scale (Qwen)：3.0-6.0
guidance_scale (其他模型)：5.0-10.0
技巧：如果生成的图片与提示词偏差较大，可适当提高系数；如果图片过于僵硬，可降低系数。
4. 反向提示词 (negative_prompt)
作用：告诉模型哪些内容不希望出现在图片中，用于规避低质量、不符合预期的元素（如模糊、变形、水印等）。
代码设置：
python
运行
negative_prompt = "blurry, low quality, text error, watermark, signature, username, artist name, deformed, ugly, bad anatomy, extra limbs, missing fingers"
image = pipe(
prompt=prompt,
negative_prompt=negative_prompt,
...
).images[0]
常用反向提示词：
质量相关：blurry, low quality, pixelated, noisy
内容相关：watermark, signature, text, logo
美学相关：deformed, ugly, bad anatomy, extra limbs, missing fingers, disfigured
技巧：根据生成结果的问题，针对性添加反向提示词（如生成的文字错误，可加 text error）。
5. VAE (Variational Autoencoder)
作用：VAE 用于压缩和解压缩图像潜空间（latent space），影响图片的细节还原度和色彩准确性。部分模型会自带优化的 VAE，也可手动替换更优的 VAE。
代码设置：
python
运行
from diffusers import AutoencoderKL
# 加载外部 VAE（如 Stable Diffusion 的 VAE）
vae = AutoencoderKL.from_pretrained(
"stabilityai/sd-vae-ft-mse",
torch_dtype=torch_dtype
)
# 将 VAE 替换到 pipeline 中
pipe.vae = vae
注意：
VAE 需与模型兼容（如 Qwen/Qwen-Image 可能使用自定义 VAE，替换外部 VAE 需测试兼容性）。
优化的 VAE（如 sd-vae-ft-mse）可提升图片细节和色彩，但会增加显存占用。
6. ControlNet
作用：ControlNet 允许通过额外的控制信号（如边缘检测、姿态估计、深度图等）精确控制生成内容的结构，适合需要固定布局或姿态的场景。
代码设置：
python
运行
from diffusers import ControlNetModel, UniPCMultistepScheduler
import cv2
import numpy as np
# 加载 ControlNet 模型（如边缘检测）
controlnet = ControlNetModel.from_pretrained(
"lllyasviel/sd-controlnet-canny",
torch_dtype=torch_dtype
)
# 加载 ControlNet 兼容的调度器
pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
# 准备控制图片（如 Canny 边缘检测结果）
control_image = cv2.imread("control.jpg")
control_image = cv2.Canny(control_image, 100, 200)
control_image = control_image[:, :, None]
control_image = np.concatenate([control_image, control_image, control_image], axis=2)
control_image = Image.fromarray(control_image)
# 生成图片
image = pipe(
prompt=prompt,
control_image=control_image,
controlnet=controlnet,
num_inference_steps=50,
controlnet_conditioning_scale=1.0, # ControlNet 影响强度
...
).images[0]
常用 ControlNet 模型：
lllyasviel/sd-controlnet-canny：边缘检测
lllyasviel/sd-controlnet-openpose：人体姿态估计
lllyasviel/sd-controlnet-depth：深度图控制
lllyasviel/sd-controlnet-seg：语义分割
注意：
ControlNet 需要额外下载模型文件，且会增加显存占用。
控制图片的质量直接影响生成结果，需确保控制信号清晰。
完整示例代码（集成所有参数）
from modelscope import DiffusionPipeline
from diffusers import PNDMParallelScheduler, AutoencoderKL, ControlNetModel
import torch
import cv2
import numpy as np
from PIL import Image
# 配置参数
CONFIG = {
"model_name": "Qwen/Qwen-Image",
"prompt": "A coffee shop entrance...", # 你的提示词
"negative_prompt": "blurry, low quality, text error, watermark, deformed",
"num_inference_steps": 50,
"true_cfg_scale": 4.5,
"seed": 42,
"aspect_ratio": "16:9",
"control_image_path": "control.jpg", # 控制图片路径（可选）
}
# 宽高比配置
ASPECT_RATIOS = {
"1:1": (1024, 1024),
"16:9": (1344, 768),
"9:16": (768, 1344),
}
def main():
# 设备和精度设置
device = "cuda" if torch.cuda.is_available() else "cpu"
torch_dtype = torch.bfloat16 if (torch.cuda.is_available() and torch.cuda.get_device_capability()[0] >= 8) else torch.float16
# 加载采样器
scheduler = PNDMParallelScheduler.from_pretrained(CONFIG["model_name"], subfolder="scheduler")
# 加载模型
pipe = DiffusionPipeline.from_pretrained(
CONFIG["model_name"],
scheduler=scheduler,
torch_dtype=torch_dtype,
use_safetensors=True
)
pipe = pipe.to(device)
# 加载 VAE（可选）
# vae = AutoencoderKL.from_pretrained("stabilityai/sd-vae-ft-mse", torch_dtype=torch_dtype)
# pipe.vae = vae.to(device)
# 加载 ControlNet（可选）
use_controlnet = CONFIG.get("control_image_path") and os.path.exists(CONFIG["control_image_path"])
if use_controlnet:
controlnet = ControlNetModel.from_pretrained(
"lllyasviel/sd-controlnet-canny",
torch_dtype=torch_dtype
).to(device)
pipe.controlnet = controlnet
# 处理控制图片
control_image = cv2.imread(CONFIG["control_image_path"])
control_image = cv2.Canny(control_image, 100, 200)
control_image = control_image[:, :, None]
control_image = np.concatenate([control_image, control_image, control_image], axis=2)
control_image = Image.fromarray(control_image)
else:
control_image = None
# 生成参数
width, height = ASPECT_RATIOS[CONFIG["aspect_ratio"]]
generator = torch.Generator(device=device).manual_seed(CONFIG["seed"])
# 生成图片
image = pipe(
prompt=CONFIG["prompt"],
negative_prompt=CONFIG["negative_prompt"],
width=width,
height=height,
num_inference_steps=CONFIG["num_inference_steps"],
true_cfg_scale=CONFIG["true_cfg_scale"],
generator=generator,
control_image=control_image if use_controlnet else None,
controlnet_conditioning_scale=1.0 if use_controlnet else None,
).images[0]
# 保存图片
image.save("qwen_image_with_params.png")
print("图片已保存为 qwen_image_with_params.png")
if __name__ == "__main__":
import os
main()
总结
采样方法：影响速度和质量，推荐 PNDM 或 DDIM。
采样步数：20-50 步平衡速度和质量。
提示词引导系数：3.0-6.0 控制提示词贴合度。
反向提示词：规避低质量元素，提升图片纯度。
VAE：可选优化，提升细节和色彩。
ControlNet：精确控制图像结构，适合特定场景。
根据你的需求调整这些参数，可以显著提升生成效果！如果有具体场景（如生成特定风格、固定布局），可以进一步针对性优化参数。
A:...
好的，指定本地模型路径非常简单。当你已经下载过模型，或者手动将模型文件放置在某个文件夹后，你只需要在 from_pretrained() 方法中传入该文件夹的绝对路径或相对路径即可。
这样做的好处是：
避免重复下载：如果模型已经存在，from_pretrained 会直接加载，不会再从网络下载。
方便模型管理：你可以将模型文件组织在项目目录下，便于版本控制或分享。
方法一：使用默认缓存路径
如果你是第一次运行代码时自动下载的模型，它会被缓存起来。你可以直接使用这个缓存路径。
1.找到缓存路径：
Linux / macOS: ~/.cache/modelscope/hub/Qwen/Qwen-Image/
Windows: C:\Users\<你的用户名>\.cache\modelscope\hub\Qwen\Qwen-Image\
2.在代码中指定该路径：
from modelscope import DiffusionPipeline
import torch
# 将下面的路径替换成你自己的实际路径
local_model_path = "~/.cache/modelscope/hub/Qwen/Qwen-Image/"
pipe = DiffusionPipeline.from_pretrained(
local_model_path,
torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32
)
pipe = pipe.to("cuda" if torch.cuda.is_available() else "cpu")
# ... 后续代码不变 ...
prompt = "A beautiful landscape..."
image = pipe(prompt).images[0]
image.save("output.png")
方法二：使用自定义本地路径
如果你将模型文件手动复制到了项目目录或其他位置，也可以指定这个路径。
1.假设你的项目结构如下：
my_project/
├── models/
│ └── Qwen-Image/
│ ├── config.json
│ ├── model.safetensors
│ ├── scheduler/
│ └── ... (其他所有模型文件)
└── generate_image.py
2.在 generate_image.py 中指定相对路径：
from modelscope import DiffusionPipeline
import torch
# 使用相对路径
local_model_path = "./models/Qwen-Image/"
pipe = DiffusionPipeline.from_pretrained(
local_model_path,
torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32
)
pipe = pipe.to("cuda" if torch.cuda.is_available() else "cpu")
# ... 后续代码不变 ...
ModelScope Library HugingFace框架及LangChain框架区别
AI 领域非常流行的三个库 / 框架：ModelScope Library、Hugging Face Transformers 和 LangChain。
这三者都与大规模语言模型（LLM） 和深度学习密切相关，但它们的定位、目标和核心功能却有明显的区别。
为了让你看得更清楚，我将从多个维度进行对比，并附上一个总结表格。
1. 核心定位与目标
这是它们最根本的区别，决定了它们各自的应用场景。
ModelScope Library (魔搭社区)
定位: 模型即服务（MaaS）平台与工具链。
目标: 提供一个一站式的平台，让开发者能够方便地发现、下载、使用和管理来自不同机构（如阿里云、达摩院）的预训练模型。它更侧重于模型的分发、部署和产业落地。
形象比喻: 一个模型应用商店 + 配套工具箱。你可以在商店里找到需要的模型，然后用工具箱里的工具去调用和部署它。
Hugging Face Transformers
定位: NLP 模型的通用编程框架和模型库。
目标: 成为 NLP 领域的 “乐高积木”，让开发者能够以统一、简单的 API轻松调用和微调各种最先进的 Transformer 模型（如 BERT, GPT, T5 等）。它更侧重于模型的调用、微调与研究。
形象比喻: 一个高级模型组件库。它提供了标准化的接口来 “玩” 各种最先进的模型核心，但它本身不直接提供复杂的应用流程编排。
LangChain
定位: LLM 应用开发框架。
目标: 解决如何将 LLM 与其他工具（如数据库、搜索引擎、API、文件系统）和知识源结合起来，以构建复杂、强大的 AI 应用。它更侧重于应用层的开发、流程编排和能力扩展。
形象比喻: 一个AI 应用的 “大脑” 或 “操作系统”。它负责决定在什么情况下，调用哪个工具，使用什么数据，来完成用户的复杂任务。
2. 核心功能与组件
ModelScope Library
模型仓库: 提供了丰富的模型资源，涵盖 NLP、计算机视觉、语音等多个领域，尤其在中文模型方面有很强的优势（如通义千问系列）。
统一的调用接口: modelscope.pipelines 提供了类似 Hugging Face pipeline的体验，可以快速实现 inference。
模型训练与微调: 内置了训练框架，支持对模型进行微调，并提供了一些产业级的优化工具。
模型部署: 提供了多种部署选项，方便将模型部署到云端或边缘设备。
特色工具链: 例如，针对大模型的量化、压缩、推理优化等工具，更贴近工业界的需求。
Hugging Face Transformers
pipeline API: 最简单的入口，一行代码即可完成常见 NLP 任务（文本分类、问答、翻译等）。
AutoModel & AutoTokenizer: 自动识别模型类型并加载预训练模型和对应的分词器，极大简化了代码。
模型微调: 提供了 Trainer API 和 TrainingArguments，使得在自定义数据集上微调模型变得非常简单。
社区与 Hub: Hugging Face Hub 是其生态的核心，用户可以共享模型、数据集和演示（Space），形成了一个非常活跃的开源社区。
跨框架支持: 同时支持 PyTorch 和 TensorFlow。
LangChain
LLM Wrappers: 对主流的 LLM（如 OpenAI, Anthropic, Hugging Face 模型）提供了统一的封装，方便切换和调用。
Prompt Templates: 管理和复用提示词模板，支持动态填充。
Chains: 将多个 LLM 调用或工具调用组合成一个流程。例如，一个 “文档问答链” 可能包含：加载文档 -> 分割 -> 检索相关片段 -> 构建 Prompt -> 调用 LLM。
Agents: 让 LLM 能够根据用户需求，自主决定调用哪些工具（如搜索、计算、数据库查询）来完成任务。
Memory: 为 LLM 对话提供记忆能力，使其能够记住之前的对话内容。
Tools: 集成了大量现成的工具，如搜索引擎（Google Search）、数据库（SQL）、文件处理（PDF, CSV）、代码执行等。
3. 典型应用场景
ModelScope Library
快速获取和部署一个中文大模型到你的应用中。
寻找特定领域（如医疗、法律）的预训练模型并进行二次开发。
需要对模型进行量化、压缩以适应生产环境的部署需求。
更倾向于使用阿里云生态内的工具和服务。
Hugging Face Transformers
快速原型验证，用一行代码测试不同模型在特定任务上的效果。
学术研究，复现论文中的模型或进行模型对比实验。
在自定义数据集上对现有模型进行微调，以适应特定任务。
构建相对简单的、以单一模型调用为核心的 NLP 应用。
LangChain
构建一个能够回答关于你公司内部文档问题的知识库问答系统。
开发一个能够联网搜索来获取实时信息的聊天机器人。
创建一个能够分析数据、生成图表和报告的 AI 数据分析助手。
搭建一个需要多步推理和调用外部工具才能完成任务的复杂 AI 应用。
4. 总结对比表格
特性 ModelScope Library Hugging Face Transformers LangChain
核心定位 模型平台与工具链 (MaaS) | NLP 模型框架与库 | LLM 应用开发框架
主要目标 模型分发、部署、产业落地 | 模型调用、微调、研究 | 复杂 AI 应用构建、流程编排
核心优势 中文模型丰富、产业级工具链、阿里云生态 | 社区庞大、模型种类极多、API 简洁、标准化 | 工具集成能力强、擅长复杂流程、记忆与代理
典型用户 企业开发者、追求产业落地的团队 | 研究员、开发者、学生 | AI 应用工程师、全栈开发者
依赖关系 可以调用 Hugging Face 的模型 | 核心是模型本身，不直接依赖其他两个 | 可以封装 ModelScope 或 Hugging Face 的模型作为其 LLM 后端
生态角色 提供模型 “燃料” | 提供模型 “发动机” | 提供应用 “底盘和控制系统”
5.它们之间的关系
这三者并非完全竞争关系，而是可以相互配合使用：
LangChain + Hugging Face: 你可以用 LangChain 来构建一个复杂的问答系统，而其中调用的 LLM 模型可以是来自 Hugging Face Hub 的某个开源模型（例如，通过HuggingFacePipeline封装）。
LangChain + ModelScope: 同样，你也可以在 LangChain 中调用 ModelScope 提供的模型（例如，通过modelscope.pipelines封装）来构建你的应用。
ModelScope + Hugging Face: ModelScope 的模型仓库中也包含了许多 Hugging Face 格式的模型，方便用户下载和使用。
简单来说：
如果你想要一个模型，去 Hugging Face Hub 或 ModelScope。
如果你想要调用和微调一个模型，用 Hugging Face Transformers 或 ModelScope Library。
如果你想要构建一个强大的 AI 应用，用 LangChain 来组织和扩展这些模型的能力。
原生一些咒语
####【豆包】
Q:cherry studio ai 客户端是由哪种语音开发的
A:..
Q:他能直接调用大模型吗
A:...
Q:我的意思是直接调用本地大模型文件
A:...
Q:不用ollama情况下
A:...
A:...
核心方法：用 llama-cpp-python 快速封装（无需 Ollama，直接读本地模型文件）
核心逻辑：通过 llama-cpp-python 库加载本地大模型文件，同时启动兼容 OpenAI API 的本地服务，Cherry Studio 直接连该本地服务即可调用模型。
具体步骤（极简可落地）
1. 安装依赖
bash
运行
# 核心库：加载本地模型+启动OpenAI兼容API
pip install llama-cpp-python[server]
2. 一行命令启动 API 服务（直接读本地模型文件）
bash
运行
# 格式：python -m llama_cpp.server --model 本地模型文件路径 --host 0.0.0.0 --port 8000
# 示例（本地模型是deepseek-r1-7b.Q4_K_M.gguf）：
python -m llama_cpp.server --model ./deepseek-r1-7b.Q4_K_M.gguf --host 0.0.0.0 --port 8000
--model：必填，本地大模型文件路径（支持 gguf 等主流格式）；
--host 0.0.0.0：允许本地设备访问；
--port 8000：API 服务端口（自定义，避免占用即可）。
3. 验证 API 可用性
启动后终端显示 Uvicorn running on http://0.0.0.0:8000，即成功，该服务完全兼容 OpenAI API 规范。
4. Cherry Studio 配置连接
打开 Cherry Studio 设置→模型服务→添加服务商（选 OpenAI）：
API 地址：http://localhost:8000/v1；
API 密钥：随便填非空字符串（本地服务无认证，仅适配格式）；
模型 ID：默认llama-cpp（无需改）；
保存后即可直接调用本地模型。
Q:llama-cpp-python支持哪些大模型
A:。。。
llama-cpp-python 作为 llama.cpp 的 Python 绑定库，支持的大模型覆盖主流国际模型、国产中文模型及多模态模型，且需是 GGUF 格式，具体分类如下：
国际主流模型：核心支持 Meta 的 LLaMA 1/2/3 全系列；还兼容 Mistral 7B、Mixtral MoE，Google 的 Gemma 1/2，微软的 Phi 1/2/3，以及 Falcon、DBRX 等，适配不同性能和场景需求。
国产中文模型：对中文优化模型支持完善，像通义千问 Qwen 系列、百川 Baichuan 1/2、零一万物 Yi 6B/34B、ChatGLM3/GLM4、天鹰 Aquila 1/2 等主流国产开源模型都能良好适配。
多模态模型：支持具备图像理解能力的多模态模型，比如 LLaVA 1.5/1.6、BakLLaVA、MobileVLM，还有中文优化的 Qwen2-VL 等，可实现视觉问答、图像分析等任务。
代码专用模型：也能支持代码生成类模型，例如 DeepSeek Coder、Starcoder 等，适配代码编写与调试相关的推理需求。
Q:如何知道模型是否支持llama-cpp-python
A:...
llama-cpp-python 的模型支持核心看格式和架构，再配合实操验证就能确定，具体方法如下：
1.优先查模型格式：它仅支持 GGUF 格式模型（GGML 格式已淘汰），若模型文件后缀是.gguf，基本能支持。像 Hugging Face 上很多模型会标注 “GGUF” 版本，这类可直接用；若为其他格式，需先转换格式再判断。
2.核对模型架构匹配度：它对 LLaMA 系列衍生架构及主流模型适配性最好，比如 LLaMA 1/2/3、Mistral、Qwen、ChatGLM 等文本模型，还有 LLaVA、Qwen2-VL 等多模态模型。若模型是这类常见架构，支持概率极高；小众架构则需进一步验证。
3.实操测试（最稳妥）：安装 llama-cpp-python 后，用简单代码加载模型测试。若能成功运行无报错，就说明支持。示例代码如下：
python
from llama_cpp import Llama
# 替换为你的本地模型文件路径
llm = Llama(model_path="./你的模型文件.gguf", n_ctx=2048)
# 简单生成测试
output = llm("请说一句问候语", max_tokens=50)
print(output["choices"][0]["text"])
4.查官方与社区信息：可查看 llama.cpp 的 GitHub 官方文档，其支持的模型列表会持续更新；也能在 Hugging Face 模型页面、CSDN 等技术社区搜该模型是否有与 llama-cpp-python 搭配使用的案例，有相关实践记录则说明支持。
Q:llama-cpp是由哪种语言开发的
A:...
Q:为何不用hugging face 框架呢
A:...
Q:小公司如要开发ai应用，哪种方式调用大模型好
A:...
小公司开发 AI 应用，优先按 “从低成本试错到按需深化” 的思路选调用方式，核心推荐 API 调用、智能体平台搭建，数据敏感场景可选轻量化私有部署，具体如下：
1.第三方 API 直接调用（首选，零代码 / 轻开发）：适合预算有限、无专业 AI 团队的小公司，像通义千问、腾讯混元等国内服务商都有成熟接口。按调用 Token 按量付费，月均成本可能低至几十元，还不用维护底层模型。可通过钉钉机器人、Excel 插件快速落地，比如电商小公司用它做客服自动回复，3 天就能上线，能解决 60% 以上的重复咨询问题。缺点是定制化弱，数据需传第三方，适合文案生成、简单客服等通用场景。
2,智能体平台搭建 Agent（轻定制，适配业务流程）：若需串联多环节 AI 任务，比如小红书运营的选题、写文案、生配图等流程，可选用扣子等智能体平台。无需复杂开发，通过可视化操作搭建工作流，调用不同模块完成连贯任务。既能复用现成能力，又能适配碎片化业务场景，缺点是复杂流程需微调适配，适合有明确多步骤业务需求的场景。
3.轻量化私有部署（数据敏感场景，如金融、医疗）：若担心核心数据泄露，可选用 Qwen、ChatGLM 等轻量化开源模型，通过 llama-cpp-python 加载 GGUF 格式模型部署在本地低配服务器。成本比全量私有化低，数据自主可控，还能做简单调优适配业务。不过需要少量技术人员维护，适合客户信息、交易记录等敏感数据处理场景。
4.低代码中间件集成（需对接现有系统）：若要给现有客服、呼叫中心系统加 AI 能力，可选 iSoftCall 这类低代码中间件。支持拖拽式操作集成 30 多种大模型，预置电商、物流等行业模板，不用改造旧设备，3 天左右就能完成上线。按调用量收费，大促时可动态扩容，适合需要快速升级现有业务系统的小公司。
A:...
对现有大模型做行业微调，核心是选适配行业的微调方法、备好专业数据，再按标准化流程落地，小公司也能低成本完成，具体步骤和方案如下：
1.准备行业专属数据（核心前提）：优先收集 “小而精” 的高质量数据，比如医疗领域的病例、诊断报告，法律领域的判例和法条。先清洗去重错误数据，再做标注（如客服数据标注 “问题 - 标准答案”）；数据量不足时可用同义替换等做增强。最后按 7:2:1 划分训练集、验证集、测试集，还需转换成模型支持的格式。
2.选适配的行业微调方案（按成本从低到高选）
2.1QLoRA（小公司首选）：4 位量化 + 低秩矩阵微调，冻结模型主参数，仅训练少量低秩矩阵，单张 RTX 4090 就能微调 70B 级模型，适配医疗、金融等多数行业，兼顾成本和效果。
2.2冻结层微调：冻结模型底层（保留通用知识），仅微调顶层或新增的行业专用层，适合文本分类这类和预训练任务相近的行业场景，比如电商评论情感分析。
2.3RLHF（高要求场景）：先做监督微调，再训练奖励模型（用人类对行业输出的评分数据），最后通过强化学习优化，适合对输出质量要求高的场景，比如高端金融咨询对话模型。
2.4全量微调（算力充足时）：更新模型所有参数，适合行业与通用场景差异极大的情况，比如特殊工业检测文本分析，需多 GPU 集群，小公司一般不优先选。
3.实操训练与调优：用 LlamaFactory 等工具加载基础模型（如医疗选 Qwen - Medical，法律选 ChatGLM - Law），配置超参数（学习率设 1e - 5 左右，避免破坏原模型知识）；用准备好的行业数据训练，过程中监控验证集的准确率、困惑度等指标；若出现过拟合，可减少训练轮次或增加数据增强。
4.验证与落地：用行业测试集测试，比如让医疗模型分析未见过的病例看诊断准确率，法律模型解读新判例看条款引用正确率；达标后保存模型，后续可根据新的行业数据做增量微调，持续适配业务变化。
Q:比如要对qwen模型微调如何标注数据和如何微调给出实际方法和实例数据和代码
A:...
通义千问（Qwen）模型行业微调实操指南（含数据标注 + 代码 + 实例）
核心逻辑：用 QLoRA 轻量化微调（小公司 / 低配 GPU 适配），标注「行业问答式结构化数据」，基于 LlamaFactory 工具快速落地，以「电商售后客服」行业场景为例（适配 Qwen-7B-Chat，单张 RTX 3090/4070 即可运行）。
一、数据标注：电商售后场景实例（核心是结构化格式）
1. 标注原则
数据类型：优先「用户问题 - 系统回复」的问答对（适配对话类微调，贴合 Qwen-Chat 原生任务）；
数据质量：单条数据精准对应行业需求（电商售后：退款、换货、物流、售后维权等场景），无冗余、无错误；
数据量：微调 Qwen-7B，最低 100 条有效数据起步，300-500 条效果达标，1000 条以上效果最优。
2. 实例标注数据（电商售后场景，JSON 格式，保存为 ecommerce_aftersale.json）
[
{
"instruction": "用户咨询订单退款迟迟没到账，该怎么回复？",
"input": "用户：我昨天申请的订单退款，现在还没到账，怎么回事？",
"output": "亲，抱歉给你带来不便~订单退款到账时效通常是1-3个工作日，具体以支付渠道到账为准（微信/支付宝即时到账，银行卡需1-3天）。麻烦你提供下订单号，我马上帮你核查退款进度，若超时未到账，会优先为你加急处理。"
},
{
"instruction": "用户收到商品破损，申请换货的回复话术",
"input": "用户：刚收到的衣服袖口破了，想换货，怎么操作？",
"output": "亲，实在抱歉，商品运输中出现破损是我们的疏忽~换货流程很简单：1. 你先在订单页提交换货申请，上传商品破损部位清晰照片；2. 申请通过后，按系统提示寄回破损商品（运费由我们承担，寄回后记得上传快递单号）；3. 我们收到退回商品后，48小时内为你发出全新同款商品，后续会实时同步发货进度。"
},
{
"instruction": "用户超过7天无理由退货期，想退货的回复",
"input": "用户：我买的鞋子已经收到10天了，不太合脚，想退货可以吗？",
"output": "亲，根据平台售后规则，普通商品无理由退货期限是签收后7天内，你的订单已超出该期限~不过若鞋子无穿着痕迹、吊牌完好且不影响二次销售，可帮你申请特殊退货通道，你补充下商品现状清晰照片，我提交审核，审核通过后就能正常退货；若商品已使用，暂时无法退货，可帮你申请10元无门槛优惠券补偿，你看是否接受？"
},
{
"instruction": "用户咨询物流长时间未更新的处理回复",
"input": "用户：我的订单物流停在昨天下午就没动静了，什么时候能送达？",
"output": "亲，稍等~我马上帮你核查物流状态，物流长时间未更新大概率是中转仓分拣积压导致。我已同步物流方加急处理，预计24小时内会更新物流轨迹，正常情况下3天内可送达。后续物流有最新进展，我会第一时间告知你，若超时未送达，可帮你申请物流延误补偿。"
}
]
3. 数据格式说明
instruction：微调任务指令（明确该条数据的训练目的）；
input：实际用户输入（行业真实场景 query）；
output：标准回复（符合行业需求的精准答案）；
扩展：后续可按此格式补充至 300 + 条，覆盖全售后场景，微调效果更稳。
二、微调实操步骤（全程代码 + 环境配置）
1. 前置环境准备（Windows/Linux 通用，GPU 需支持 CUDA）
（1）安装依赖包
# 核心依赖：LlamaFactory（一站式微调工具，适配Qwen）、PyTorch、transformers
pip install -U llamafactory torch==2.1.0 transformers==4.38.2 accelerate==0.27.1 sentencepiece==0.1.99
（2）下载 Qwen-7B-Chat 基础模型
从 Hugging Face 下载（需注册账号）：https://huggingface.co/Qwen/Qwen-7B-Chat下载后本地路径示例：./models/Qwen-7B-Chat（文件夹内含模型权重、配置文件）。
（3）数据整理
将标注好的 ecommerce_aftersale.json 放在 ./data 目录下；
新建数据配置文件 ./data/ecommerce_aftersale.yaml（告诉 LlamaFactory 数据格式），内容如下：
# ecommerce_aftersale.yaml
dataset_info:
name: ecommerce_aftersale
description: 电商售后客服问答数据集
data_files:
- path: ecommerce_aftersale.json
type: json
columns:
instruction: instruction
input: input
output: output
2. 核心微调代码（Python 脚本，qwen_finetune.py）
用 QLoRA 轻量化微调，仅训练少量参数，低 GPU 显存即可运行（16G 显存足够）：
from llamafactory.train import train
from llamafactory.args import TrainingArguments, ModelArguments, DataArguments, GeneratingArguments
def qwen_qlora_finetune():
# 1. 模型参数（指定基础模型路径、微调方式）
model_args = ModelArguments(
model_name_or_path="./models/Qwen-7B-Chat", # 本地Qwen-7B-Chat路径
adapter_name_or_path="qlora", # 微调方式：QLoRA
load_in_4bit=True, # 4位量化，降低显存占用
bnb_4bit_compute_dtype="float16",
bnb_4bit_quant_type="nf4",
use_flash_attention_2=False, # 无FlashAttention则设为False，有则设为True（更省显存）
)
# 2. 数据参数（指定训练数据）
data_args = DataArguments(
dataset_dir="./data", # 数据目录
dataset="ecommerce_aftersale", # 数据集名称（对应yaml文件name）
max_seq_length=1024, # 单条数据最大长度
train_on_inputs=True, # 基于输入训练回复
instruction_template="qwen", # 适配Qwen模型的指令模板
val_size=0.1, # 从训练数据中拆分10%作为验证集
)
# 3. 训练参数（核心超参数，适配Qwen微调）
training_args = TrainingArguments(
output_dir="./finetune_qwen_e
training_args 的定义似乎被截断了。我将为你补全这段代码，并提供详细的注释和使用说明，帮助你顺利完成微调。
from llamafactory.train import train
from llamafactory.args import TrainingArguments, ModelArguments, DataArguments, GeneratingArguments
def qwen_qlora_finetune():
# 1. 模型参数（指定基础模型路径、微调方式）
model_args = ModelArguments(
model_name_or_path="./models/Qwen-7B-Chat", # 本地Qwen-7B-Chat模型路径
adapter_name_or_path="qlora", # 微调方式：QLoRA（量化低秩适配）
load_in_4bit=True, # 启用4位量化，大幅降低显存占用
bnb_4bit_compute_dtype="float16", # 计算时使用的精度
bnb_4bit_quant_type="nf4", # 量化类型（nf4为推荐值，适配Transformer模型）
use_flash_attention_2=False, # 是否使用FlashAttention-2（需GPU支持，更省显存）
)
# 2. 数据参数（指定训练数据相关配置）
data_args = DataArguments(
dataset_dir="./data", # 数据集根目录
dataset="ecommerce_aftersale", # 数据集名称（需与dataset_dir下的yaml配置文件名一致）
max_seq_length=1024, # 单条数据的最大序列长度（需根据模型能力调整）
train_on_inputs=True, # 是否基于输入训练回复（True表示训练输入+输出的完整序列）
instruction_template="qwen", # 指令模板（适配Qwen模型的输入格式）
val_size=0.1, # 从训练数据中拆分10%作为验证集
)
# 3. 训练参数（核心超参数，控制训练过程）
training_args = TrainingArguments(
output_dir="./finetune_qwen_ecommerce", # 训练结果输出目录
per_device_train_batch_size=4, # 每个设备的训练批次大小（根据显存调整）
per_device_eval_batch_size=4, # 每个设备的验证批次大小
gradient_accumulation_steps=4, # 梯度累积步数（模拟更大批次，需与batch_size配合）
learning_rate=2e-4, # 学习率（QLoRA常用范围：1e-4 ~ 3e-4）
num_train_epochs=3, # 训练轮数（根据数据集大小调整）
logging_steps=10, # 日志打印间隔（每10步打印一次训练信息）
save_steps=100, # 模型保存间隔（每100步保存一次检查点）
evaluation_strategy="steps", # 验证策略（steps：按步数验证；epoch：按轮次验证）
eval_steps=100, # 验证间隔（每100步进行一次验证）
load_best_model_at_end=True, # 训练结束后加载最优模型（基于验证集指标）
metric_for_best_model="loss", # 最优模型的评判指标（loss：损失值；bleu：BLEU分数等）
fp16=True, # 启用混合精度训练（需GPU支持，加速训练并省显存）
remove_unused_columns=False, # 是否移除未使用的列（避免数据处理错误）
report_to="tensorboard", # 训练日志保存方式（tensorboard：可视化训练过程）
seed=42, # 随机种子（保证训练可复现）
)
# 4. 生成参数（控制模型生成文本的行为，仅在评估/推理时使用）
generating_args = GeneratingArguments(
max_new_tokens=512, # 生成文本的最大长度
do_sample=True, # 是否启用采样（True：生成多样化文本；False：贪心解码）
temperature=0.7, # 采样温度（值越高，文本多样性越强；越低，越确定）
top_p=0.9, # 核采样比例（仅保留概率前90%的 tokens，控制生成文本的相关性）
)
# 启动训练
train(
model_args=model_args,
data_args=data_args,
training_args=training_args,
generating_args=generating_args,
)
if __name__ == "__main__":
qwen_qlora_finetune()
关键参数说明
1. 模型参数（ModelArguments）
model_name_or_path：本地预训练模型路径（需提前下载 Qwen-7B-Chat 模型）。
adapter_name_or_path：微调方式（qlora 表示使用量化低秩适配，仅训练部分参数，显存占用低）。
load_in_4bit：启用 4 位量化（将模型权重从 32 位浮点数压缩为 4 位整数，显存占用可降低 75% 左右）。
use_flash_attention_2：若 GPU 支持（如 NVIDIA A100、H100），建议设为 True，可进一步降低显存占用并加速训练。
2. 数据参数（DataArguments）
dataset_dir：数据集根目录，需包含一个与 dataset 同名的 YAML 配置文件（如 ecommerce_aftersale.yaml）。
dataset：数据集名称（需与 YAML 配置文件名一致）。
max_seq_length：单条数据的最大长度（超过该长度会被截断，需根据模型最大上下文长度调整，Qwen-7B-Chat 默认为 8192）。
instruction_template：指令模板（qwen 对应 Qwen 模型的输入格式，如 "<|im_start|>user\n{input}<|im_end|>\n<|im_start|>assistant\n{output}<|im_end|>"）。
3. 训练参数（TrainingArguments）
output_dir：训练结果输出目录，包含模型权重、训练日志、配置文件等。
per_device_train_batch_size：每个设备的训练批次大小（显存不足时可减小，如 2 或 1）。
gradient_accumulation_steps：梯度累积步数（若批次大小为 4，累积步数为 4，相当于模拟批次大小 16）。
learning_rate：学习率（QLoRA 微调的关键参数，需根据数据集大小和模型规模调整）。
num_train_epochs：训练轮数（数据集较小时可增加，如 5~10；较大时可减少，如 2~3）。
fp16：启用混合精度训练（需 GPU 支持，可加速训练并减少显存占用）。
4. 生成参数（GeneratingArguments）
max_new_tokens：模型生成文本的最大长度（需小于 max_seq_length）。
do_sample：是否启用采样（生成多样化回复时设为 True，生成确定性回复时设为 False）。
temperature 和 top_p：控制生成文本的多样性和相关性（需根据实际需求调整）。
前置准备
1. 环境安装
需安装 llamafactory 及相关依赖：
pip install llamafactory torch transformers datasets accelerate peft bitsandbytes
2. 模型下载
从 阿里云 ModelScope 下载 Qwen-7B-Chat 模型，解压后放置到 ./models/Qwen-7B-Chat 目录。
3. 数据集准备
在 ./data 目录下创建 ecommerce_aftersale.yaml 配置文件，内容示例：
dataset_info:
name: ecommerce_aftersale
description: 电商售后对话数据集
language: zh
task: conversation
data_files:
train: train.jsonl
validation: validation.jsonl
准备训练数据（train.jsonl）和验证数据（validation.jsonl），格式为 JSONL（每行一个样本）：
{"instruction": "用户反馈商品质量问题，如何处理？", "input": "我买的衣服有破洞", "output": "亲，非常抱歉给您带来不好的体验！请您先拍照留存破洞位置，然后联系我们的售后客服（电话：XXX-XXXX-XXXX），我们会为您安排退换货或补发服务，运费由我们承担~"}
运行方式
直接运行脚本即可启动训练：
python qwen_qlora_finetune.py
训练过程中，会在 ./finetune_qwen_ecommerce 目录下保存模型权重和训练日志，可通过 TensorBoard 查看训练进度：
tensorboard --logdir ./finetune_qwen_ecommerce/runs
代码中，模型训练完成后，新模型（更准确地说是适配器权重）会保存在由 TrainingArguments 的 output_dir 参数指定的目录中。
根据你的代码：
training_args = TrainingArguments(
output_dir="./finetune_qwen_ecommerce", # 训练结果输出目录
# ... 其他参数
)
所有训练相关的输出，包括最终的模型文件，都会保存在 ./finetune_qwen_ecommerce 这个文件夹里。
在 ./finetune_qwen_ecommerce 目录下，你会找到以下关键文件和子目录：
1.adapter_model.safetensors (或 adapter_model.bin):
这是最重要的文件，包含了你训练出的新模型的核心权重。
它不是一个完整的模型，而是原始 Qwen-7B 模型的一个 “补丁” 或 “插件”。
这个文件很小，对于 QLoRA 来说，通常只有几十到几百兆字节。
2.adapter_config.json:
适配器的配置文件。它记录了 LoRA 的秩（rank）、Alpha 值等超参数。
在加载适配器进行推理时，需要用到这个文件来正确地将适配器权重合并到原始模型中。
3.checkpoint-xxx 文件夹:
在训练过程中，根据 save_steps 的设置（你的代码中是 save_steps=100），训练器会定期保存检查点。
每个检查点文件夹（如 checkpoint-100, checkpoint-200）都包含了该步骤的 adapter_model.safetensors 和 adapter_config.json。
这些检查点可以用于：
断点续训：如果训练中断，可以从最近的检查点恢复。
模型选择：你可以根据验证集的指标（如 eval_loss），选择表现最好的那个检查点作为最终模型。
4.pytorch_model.bin.index.json 和 pytorch_model-00001-of-00002.bin 等:
注意： 如果你是首次运行训练，并且没有使用 --load_best_model_at_end 或类似的参数，可能不会在 output_dir 的根目录看到这些文件。
这些是完整模型的权重文件。通常，它们会出现在检查点文件夹中。当训练结束后，如果启用了 load_best_model_at_end=True，训练器会将最佳模型的权重（包括适配器）复制到 output_dir 的根目录。
如何使用训练好的新模型？
你不能直接加载 adapter_model.safetensors 作为一个独立的模型。你需要先加载原始的 Qwen-7B 模型，然后再加载你训练好的适配器。
这里是一个简单的推理示例：
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
# 1. 定义模型路径
base_model_path = "./models/Qwen-7B-Chat"
adapter_path = "./finetune_qwen_ecommerce" # 这里是你训练的输出目录
# 2. 加载原始模型和分词器
model = AutoModelForCausalLM.from_pretrained(base_model_path, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(base_model_path)
# 3. 加载并融合适配器
model = PeftModel.from_pretrained(model, adapter_path)
# 4. 将模型设置为评估模式
model.eval()
# 5. 准备输入并进行推理
prompt = "用户说他买的衣服有破洞，我该怎么回复？"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=512)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)
总结
核心输出: 训练好的模型权重是 adapter_model.safetensors。
保存位置: 在 ./finetune_qwen_ecommerce 目录下。
最佳实践: 由于你设置了 load_best_model_at_end=True 和 metric_for_best_model="loss"，训练结束后，表现最好的模型适配器会被自动保存到 ./finetune_qwen_ecommerce 的根目录，你直接使用这个目录路径加载即可。
Q:能否将adapter_model.safetensors和原始的Qwen-7B合并成一个safetensors文件
A:...
当然可以将训练好的 adapter_model.safetensors 与原始的 Qwen-7B 模型合并成一个完整的 safetensors 文件。这样做的好处是，你可以像使用一个普通模型一样来使用这个微调后的模型，而无需每次都加载原始模型和适配器两个部分。
这个合并过程需要借助 peft 和 transformers 库。
合并模型的步骤
下面是具体的 Python 代码和步骤说明。
1. 准备环境
确保你已经安装了必要的库：
bash
运行
pip install peft transformers torch safetensors
2. 编写合并脚本
创建一个名为 merge_model.py 的文件，并将以下代码复制进去。请根据你的实际路径修改 base_model_path、adapter_path 和 output_path。
import torch
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
def merge_adapter_and_base_model(base_model_path, adapter_path, output_path):
"""
合并基础模型和 LoRA 适配器。
Args:
base_model_path (str): 原始基础模型的路径。
adapter_path (str): 训练好的适配器模型的路径。
output_path (str): 合并后的完整模型的保存路径。
"""
print(f"正在加载基础模型: {base_model_path}")
# 加载基础模型和分词器
# device_map="auto" 会自动将模型加载到可用的设备（GPU/CPU）
# torch_dtype=torch.bfloat16 建议在支持的GPU上使用，可节省显存
model = AutoModelForCausalLM.from_pretrained(
base_model_path,
device_map="auto",
torch_dtype=torch.bfloat16,
trust_remote_code=True # Qwen模型需要此参数
)
tokenizer = AutoTokenizer.from_pretrained(base_model_path, trust_remote_code=True)
print(f"正在加载适配器: {adapter_path}")
# 加载并融合适配器
model = PeftModel.from_pretrained(model, adapter_path)
print("正在合并模型...")
# 将适配器权重与基础模型权重合并
# 这会返回一个新的、不包含适配器结构的普通模型
merged_model = model.merge_and_unload()
print(f"合并完成，正在保存到: {output_path}")
# 保存合并后的模型和分词器
merged_model.save_pretrained(output_path, safe_serialization=True)
tokenizer.save_pretrained(output_path)
print("所有操作已完成！")
if __name__ == "__main__":
# --- 请根据你的情况修改以下路径 ---
# 1. 原始Qwen-7B模型的路径
base_model_path = "./models/Qwen-7B-Chat"
# 2. 你训练好的适配器模型的路径 (即 training_args.output_dir)
adapter_path = "./finetune_qwen_ecommerce"
# 3. 合并后的完整模型的输出路径
output_path = "./merged_qwen_ecommerce_model"
# 执行合并
merge_adapter_and_base_model(base_model_path, adapter_path, output_path)
3. 运行脚本
在终端中运行这个脚本：
bash
运行
python merge_model.py
脚本会执行以下操作：
1.加载原始的 Qwen-7B-Chat 模型。
2.加载你训练好的 adapter。
3.将 adapter 的权重与原始模型的权重进行计算并合并。
4.将合并后的完整模型保存到 ./merged_qwen_ecommerce_model 目录中。
合并后模型的目录结构
合并完成后，./merged_qwen_ecommerce_model 目录的结构会像这样：
plaintext
merged_qwen_ecommerce_model/
├── config.json
├── configuration_qwen.py
├── model-00001-of-00002.safetensors
├── model-00002-of-00002.safetensors
├── model.safetensors.index.json
├── modeling_qwen.py
├── special_tokens_map.json
├── tokenizer.json
├── tokenizer.model
└── tokenizer_config.json
model-0000x-of-00002.safetensors 文件就是合并后的模型权重，它们是标准的 safetensors 格式。
这个目录现在包含了一个可以独立使用的、完整的、微调后的 Qwen 模型。
如何使用合并后的模型
你可以像使用任何其他 Hugging Face 模型一样来加载和使用它，代码非常简洁：
python
运行
from transformers import AutoModelForCausalLM, AutoTokenizer
# 直接加载合并后的模型
model_path = "./merged_qwen_ecommerce_model"
model = AutoModelForCausalLM.from_pretrained(model_path, device_map="auto", trust_remote_code=True)
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
# 进行推理
prompt = "我的订单号是 #12345，我收到的商品有破损，该怎么办？"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=512)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)
这样，你就成功地将轻量化的适配器训练结果，固化成了一个可以方便部署和分享的完整模型文件。
解决 Hugging Face 国内下载慢的问题：用 ModelScope 替代加速模型获取
如何用 ModelScope 替代 Hugging Face 下载模型？
无论是使用命令行还是ModelScope SDK，模型会下载到~/.cache/modelscope/hub默认路径下。如果需要修改 cache 目录，可以手动设置环境变量：MODELSCOPE_CACHE，完成设置后，模型将下载到该环境变量指定的目录中。
1. 安装 ModelScope SDK
pip install modelscope
2. 使用一行代码下载模型
以 Llama-3-8B 为例（假设该模型已在 ModelScope 上架）：
from modelscope import snapshot_download
model_dir = snapshot_download('LLM-Research/Meta-Llama-3-8B-Instruct')
print(f"模型已下载至: {model_dir}")
3. 加载模型进行推理（以 Transformers 模型为例）
很多 ModelScope 上的模型可以直接用 Hugging Face Transformers 加载：
from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained(model_dir, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(model_dir, trust_remote_code=True)
命令下载示例（以Qwen2-7B）模型为例
下载整个模型repo（到默认cache地址）#
modelscope download --model 'Qwen/Qwen2-7b'
下载整个模型repo到指定目录#
modelscope download --model 'Qwen/Qwen2-7b' --local_dir 'path/to/dir'
指定下载单个文件(以'tokenizer.json'文件为例)#
modelscope download --model 'Qwen/Qwen2-7b' tokenizer.json
指定下载多个个文件#
modelscope download --model 'Qwen/Qwen2-7b' tokenizer.json config.json
指定下载某些文件#
modelscope download --model 'Qwen/Qwen2-7b' --include '*.safetensors'
过滤指定文件#
modelscope download --model 'Qwen/Qwen2-7b' --exclude '*.safetensors'
指定下载cache_dir#
modelscope download --model 'Qwen/Qwen2-7b' --include '*.json' --cache_dir './cache_dir'
模型文件将被下载到'cache_dir/Qwen/Qwen2-7b'。
指定下载local_dir#
modelscope download --model 'Qwen/Qwen2-7b' --include '*.json' --local_dir './local_dir'
模型文件将被下载到'./local_dir'。
如果cache_dir和local_dir参数同时被指定，local_dir优先级高，cache_dir将被忽略
Ollama加载ModelScope模型
ollama run modelscope.cn/Qwen/Qwen2.5-3B-Instruct-GGUF
命令行的具体格式为:
ollama run modelscope.cn/{model-id}
其中model-id的具体格式为{username}/{model}，例如：
ollama run modelscope.cn/Qwen/Qwen2.5-3B-Instruct-GGUF
ollama run modelscope.cn/second-state/gemma-2-2b-it-GGUF
ollama run modelscope.cn/Shanghai_AI_Laboratory/internlm2_5-7b-chat-gguf
一个模型repo下的不同GGUF文件，对应的是不同量化精度与量化方法。默认情况下，如果模型repo里有Q4_K_M版本的话，我们会自动拉取并使用该版本，在推理精度以及推理速度，资源消耗之间做一个较好的均衡。如果没有该版本，我们会选择合适的其他版本。
此外，您也可以显式配置来指定想要使用的版本。例如
ollama run modelscope.cn/Qwen/Qwen2.5-3B-Instruct-GGUF:Q3_K_M
这里命令行最后的:Q3_K_M选项，就指定了使用Q3_K_M精度的GGUF模型版本，这个选项大小写不敏感，也就是说，无论是:Q3_K_M，还是:q3_k_m，都是使用模型repo里的"qwen2.5-3b-instruct-q3_k_m.gguf" 这个模型文件。当然，您也可以直接指定模型文件的全称，这同样是支持的：
ollama run modelscope.cn/Qwen/Qwen2.5-3B-Instruct-GGUF:qwen2.5-3b-instruct-q3_k_m.gguf
视觉多模态模型使用#
除了常见的LLM以外，这种使用方式也支持了包括Llama3.2-Vision在内的视觉多模态模型。这类模型需要确保使用Ollama 0.4.0以上的版本。 例如：
ollama run modelscope.cn/AI-ModelScope/Llama-3.2-11B-Vision-Instruct-GGUF
直接运行llamafile格式模型
直接运行llamafile格式模型
Llamafile是由Mozilla发布开源的，一个将大型语言模型和运行环境全部封装在一个可执行文件中的创新项目。在ModelScope平台上开放的丰富的Llamafile模型，都可以通过ModelScope命令行，直接在Linux/Mac/Windows等不同操作系统环境中，实现一键运行大模型。
无需提前配置或安装任何运行环境，直接安装ModelScope后，即可一键拉起指定的大模型。
pip install modelscope -U
一键运行#
ModelScope平台上目前开放了数百个Llamafile格式的大模型，基本对于头部的大模型，都提供了对应的llamafile格式。您可以在模型页面左侧的框架选项中，选中Lllamfile，即可以直接筛选出Llamafile格式的模型。
同时您也可以通过对应的链接直达列表页。
在选择了您想要使用的模型后，可以如下命令行来调用：
modelscope llamafile --model {model_id}
例如如果要运行Qwen2.5-3B模型：
modelscope llamafile --model Qwen-Llamafile/Qwen2.5-3B-Instruct-llamafile
在Linux环境上：
WebUI访问#
同时llamafile底层基于llama.cpp搭建，在运行的同时，通过默认的http://127.0.0.1:8080/ 地址即可访问其WebUI：
命令行选项#
除了如上基本的用法以外，使用ModelScope命令行拉起llamafile大模型时，还可以指定精度，或指定模型库里的llamafile文件等配置。例如如果要使用不同精度的llamafile文件，可以通过--accuracy参数来指定，例如Q2_K,Q5_0等等。 同时也可以通过--file参数，来直接指定模型库里的llamafile文件名，例如：
比如如下两种调用方式，是等效的，都是选择模型库里，精度为“Q2_K”的模型。
modelscope llamafile --model Qwen-Llamafile/Qwen2.5-3B-Instruct-llamafile --accuracy Q2_K
或
modelscope llamafile --model Qwen-Llamafile/Qwen2.5-3B-Instruct-llamafile --file qwen2.5-3b-instruct-q2_k.llamafile
更多的命令行选项，可以参见ModelScope命令行介绍。
上一篇：优秀的开源项目
下一篇：Comfy UI 技术收集