LLM大模型-大模型 API 集成使用、部署本地大模型（huggingface、modelscope）、实现Qwen和Deepseek本地部署

大模型

一、基本介绍

人工智能中的大模型（Large Model / Foundation Model），是指参数规模通常在数十亿甚至千亿以上的深度神经网络。它们依靠大规模数据和高算力平台训练而成，具备强泛化能力和跨任务迁移能力，能够在自然语言处理、计算机视觉、语音、多模态等多个领域展现出较强的性能。
核心特征：

• 参数规模巨大：例如 GPT-3 拥有 1750 亿参数。
• 预训练 + 微调：先在海量通用数据上进行预训练，再通过少量标注数据进行下游任务微调。
• 基于Transformer：多数大模型采用Transformer作为基础结构，具备强大的表示学习能力。
• 通用性：同一个大模型可以通过不同的提示（Prompt）或少量微调，解决问答、翻译、写作、代码生成、图像识别等任务。
• 涌现能力（Emergent Ability）：随着参数规模增大，模型表现出一些在小模型中不具备的新能力，例如零样本推理、复杂逻辑推理。

1.常见的大模型

全球主流大模型与开发公司

公司	代表模型	技术特点	典型应用场景
OpenAI	GPT-4o / GPT-5	多模态输入（文本/图像/音频/视频），推理能力接近人类	科研分析、全媒体创作、跨行业决策支持
Google	Gemini 2.5 Ultra	原生多模态，200万token上下文窗口，深度集成Google生态	全球化协作、实时翻译、大文档分析
Anthropic	Claude 4 Opus	200K~1M tokens长上下文，宪法AI架构确保合规	法律文书、医疗诊断、高安全性对话
xAI	Grok 4	实时信息处理，幽默对话风格，深度整合X平台	社交内容生成、新闻摘要
Meta	Llama 3.1 / Llama 4	开源700亿参数，推理速度提升200%	中小企业定制化AI、学术研究
Moonshot AI	Kimi K2（开源）	万亿参数MoE架构，长文本处理与代码能力强	数据分析、专业文档解读、智能体任务

中国主流大模型与开发公司

公司	代表模型	技术亮点	核心应用领域
阿里巴巴	通义千问 Qwen	中文理解全球领先，百万级上下文窗口	企业服务、电商客服、金融分析
字节跳动	豆包 / 即梦AI/coze	月活6000万+，多模态融合（图像/视频）	教育辅导、短视频创作
百度	文心一言 4.0	数理科学领先，日均调用15亿次	医疗、教育、金融知识图谱
深度求索	DeepSeek R1 / V3	开源6710亿参数模型，推理能力对标GPT-4	编程生成、学术研究、低成本部署
月之暗面	Kimi K2	登顶开源榜，320亿激活参数MoE架构	法律/科研文档分析、工具调用
科大讯飞	讯飞星火	支持30+语言，语音识别行业标杆	教育、医疗、金融语音交互
智谱AI	GLM-4	国内首个视频通话千亿模型	人机交互、知识问答

2.应用方向

好的，下面我挑选了几个经典的应用案例，它们在各自领域中具有代表性，也体现了大模型的强大能力。

2.1 GPT-3 - 文本生成与自然语言理解

• 领域：自然语言处理（NLP）
• 应用：文本生成、对话系统、自动写作、代码生成等。
• 经典实例：
  • OpenAI GPT-3：GPT-3 是目前最为经典的语言生成模型之一，具有 1750 亿个参数。通过简单的提示，它能够生成流畅、自然的文章、对话、广告文案，甚至编写代码。它不仅能理解复杂的上下文，还能在多种任务中表现出色，包括自动写作、智能客服、翻译和问答系统。
  • GitHub Copilot：这款基于 GPT-3 的代码生成工具，能够帮助开发者自动完成代码补全，甚至根据简短的描述生成完整的代码段。开发者通过自然语言提示（例如：“创建一个处理用户登录的 API”），GPT-3 就会自动生成相应的代码。

2.2YOLOv5 - 目标检测

• 领域：计算机视觉（CV）
• 应用：实时目标检测、物体识别。
• 经典实例：
  • YOLOv5（You Only Look Once）：YOLOv5 是一种流行的实时目标检测模型，广泛应用于安防监控、无人驾驶、工业自动化等领域。与传统的目标检测模型（如 R-CNN）相比，YOLO 系列模型以其实时性和高效性著称，能够在单张图像中迅速识别并定位多个目标（如行人、车辆、交通标志等）。
  • 自动驾驶：YOLOv5 在自动驾驶中的应用尤为重要。它能够实时识别道路上的车辆、行人、交通标志等，帮助自动驾驶系统做出决策，保证行车安全。

2.3DALL·E 2 - 图像生成

• 领域：计算机视觉（CV）与自然语言处理（NLP）
• 应用：从文本生成图像。
• 经典实例：
  • DALL·E 2：是 OpenAI 推出的一个图像生成模型，可以根据给定的文本描述生成高质量的图像。例如，用户输入文本“一个紫色的猫戴着太阳镜”，DALL·E 2 会自动生成与描述相符的图像。它结合了 GPT-3 和 CLIP 模型的能力，具备强大的文本理解和图像生成能力。
  • 艺术创作与广告设计：DALL·E 2 被广泛应用于广告创作、品牌设计和艺术创作领域。设计师可以通过简单的描述快速生成视觉素材，极大地提升了创作效率和创意空间。

2.4Whisper - 语音识别

• 领域：语音与音频处理
• 应用：语音转文本、多语言语音识别。
• 经典实例：
  • Whisper：是 OpenAI 推出的一个多语言语音识别模型，支持超过 100 种语言的语音转文本功能。Whisper 可以用于自动转录、实时字幕生成、会议记录等场景。相比传统的语音识别系统，Whisper 在嘈杂环境下的准确性更高，能更好地处理不同口音和方言。
  • Google Voice Search：基于 Whisper 或类似技术，Google 提供了精确的语音搜索功能，用户只需说出查询内容，系统即可给出准确的搜索结果。

2.5Tesla Autopilot - 自动驾驶

• 领域：自动驾驶与机器人
• 应用：自动驾驶、实时环境感知。
• 经典实例：
  • Tesla Autopilot：Tesla 的自动驾驶系统集成了多种大模型，如卷积神经网络（CNN）和强化学习算法，用于实时识别和理解道路上的各种元素（如车辆、行人、交通标志、红绿灯等）。该系统通过对环境的实时感知和推理，能够自动驾驶汽车在高速公路、城市街道等复杂环境中行驶。
  • 自主导航：Autopilot 系统还具备自主导航功能，能够基于实时数据进行路径规划和决策，帮助车辆避免碰撞、自动变道、停车等。

3.大模型的开发流程

1. 数据准备
   • 收集大规模语料或图像视频数据
   • 数据清洗与去噪，保证质量和多样性
   • 构建预训练数据集（通用数据 + 行业数据）
2. 模型设计
   • 选择合适的架构（Transformer 是主流）
   • 确定参数规模（亿级、百亿级或更大）
   • 考虑分布式训练策略（模型并行、数据并行、流水线并行）
3. 大规模预训练
   • 使用 GPU/TPU/Ascend 等集群进行训练
   • 采用自监督学习（如 Masked Language Model、下一词预测）
   • 需要分布式优化器（AdamW、ZeRO 等）
4. 微调与对齐
   • 全量微调：在下游任务数据上继续训练
   • 参数高效微调（PEFT）：如 LoRA、Prefix-Tuning、Adapter
   • 人类反馈强化学习（RLHF）：提升模型的对齐性和可控性
5. 部署与应用
   • 模型压缩（蒸馏、剪枝、量化）以降低推理成本
   • 部署到云端或边缘设备
   • 提供 API 或应用层接口（Chatbot、搜索、生成工具等）

二、集成大模型

1.大模型 API 集成使用

大模型 API 的集成使用是现代应用程序中常见的做法，它允许开发者直接利用各平台提供的大模型接口，无需自行训练和部署庞大的深度学习模型。以下是一些主流平台的 大模型 API 集成使用，包括它们的 API 接口、功能和集成方式的详细说明。

2. 集成大模型 API 的基本流程

• 明确需求

  • 确定任务：如文本生成、图像识别、语音识别等。
  • 选择合适的模型和平台：比如 OpenAI GPT、Google Vision、Azure Speech-to-Text。

• 注册与获取 API 密钥

  • 在相关平台（OpenAI、Google Cloud、Azure）注册账号，获取 API 密钥。

• 安装 SDK 或客户端

  • 安装相关 Python 库：

    pip install openai  # OpenAI
    pip install google-cloud  # Google Cloud
    pip install azure-ai-textanalytics  # Azure
    

• 集成模型 API

  • 调用 API 完成任务，如文本生成、图像分析或语音转文本。

  • 示例：调用 OpenAI GPT-3 生成文本

    import openai
    openai.api_key = "your-api-key"
    response = openai.Completion.create(engine="text-davinci-003", prompt="Write a poem", max_tokens=100)
    print(response.choices[0].text.strip())
    

• 处理结果

  • 获取并处理 API 返回的结果，例如提取文本、标签或分类。

• 优化与部署

  • 优化请求频率、批量化请求，提升响应速度。

  • 部署到生产环境，设置错误处理和日志监控。

• 费用控制

  • 监控 API 使用情况，控制费用，避免超支。

集成大模型 API 提供了以下主要优点：

• 节省资源与时间：无需自行训练和维护模型，快速集成和部署。
• 高效与准确：利用预训练模型，提供高准确度和专业化处理。
• 扩展性强：支持多任务、多平台集成，满足复杂需求。
• 降低成本：按需付费，避免了硬件和长期维护成本。
• 高可靠性与维护：由大平台提供，保证服务稳定，自动更新和优化。
• 易于集成与扩展：提供易用的 SDK 和文档，支持与其他服务无缝连接。

这使得开发者能专注于应用层，而无需担心模型和基础设施的复杂性。

2. DeepSeek的API集成

• 注册并获取 API 密钥

  • 在 DeepSeek 的官方网站注册并获取 API 密钥。

  • 需要使用 API 密钥进行身份验证和调用服务。

• 安装 OpenAI 客户端库：

  pip install openai
  

• 构造 对话消息列表

  messages = [{"role": "system", "content": "你是一专业的顶级的ai助手"},{"role": "user", "content": "请帮我写一个大模型部署的笔记"}]
  

  role 表示消息的身份，可以是：

  • system：用来设定助手的整体行为、角色、语气（比如“你是一个专业的ai助手”）。
  • user：表示用户说的话，就是你真正的输入。
  • assistant：通常用来存储模型之前生成的回复。

  content 就是这条消息的文本内容。

• 示例代码：使用 DeepSeek 进行文本生成

  from openai import OpenAI# 创建大模型链接api的客户端
  client = OpenAI(base_url='https://api.deepseek.com',api_key='your-api-key')# 构造 对话消息列表
  messages = [{"role": "system", "content": "你是一专业的顶级的ai助手"},{"role": "user", "content": "请帮我解释大模型部署"}]# 网络请求(
  # 1.把我们的文本发送给base_url
  # 2.deepseek的服务器程序接受数据 并转码为tokenid
  # 3.把tokenid拼接到已经生成的文本中发送给模型 让它继续推理
  # 4.把反复推理生成的tokenid转码为文本
  # 5.把文本返回给客户端
  # )res = client.chat.completions.create(model="deepseek-chat",messages=messages,stream=False)
  print(res.choices[0].message.content)
  # print(res)
  

• 优点：

  • 强大的自然语言理解和生成能力。
  • 支持多种功能，文本生成、图像生成、语音识别等。
  • 易于集成，提供了丰富的文档和 SDK。

• 缺点：

  • 需要付费，使用量大时费用较高。
  • 响应时间可能受限于服务器负载。

3.大模型推理基本 工作流程

请求 → 分词 → 拼接推理 → 逐步生成 → 解码返回

3.1客户端发送请求

在本地写了 messages=[...] 这样的数据结构，然后通过 HTTP 请求（通常是 POST）把这个对话内容发送到大模型服务的 base_url。
请求的格式通常是 JSON，包含模型名称、消息列表、一些参数（如温度、最大长度）。

3.2 服务端接收并转码为 token

大模型不能直接理解自然语言文本，所以 服务器会先把文本分词并转成 token ID（整数表示），这一步叫做 tokenization。
比如：

• “你好” → [1234, 5678]
• “请问今天北京天气怎么样” → [2233, 9988, 3344]

这样，输入就从文字变成了数字序列。

3.3 拼接上下文并输入模型

服务器会把你刚转好的 token ID 拼接到当前上下文里（也就是之前的系统提示、历史对话），形成一个完整的“输入序列”。
然后把这个序列送进大模型的推理引擎，模型会根据已有的 token，预测下一个最可能的 token。

3.4 逐步生成 token

大模型不会一次性吐出整段话，而是 逐个 token 地预测。
流程像这样：

• 输入 [1234, 5678] → 模型预测下一个 token = 4321
• 输入 [1234, 5678, 4321] → 预测下一个 token = 8765
• …
  反复执行，直到遇到 终止符 (EOS token) 或达到最大长度。

3.5 把 token 解码回文本

当服务器得到一串输出 token ID 后，会通过 解码器（detokenizer） 把数字再转回文字。
比如 [4321, 8765, 9999] → “会下雨，请注意带伞”。

3.6 返回给客户端

最终，服务器把这段文本通过网络返回给你，你的程序就能 print() 出模型的回答。

4.输出模式

在大模型的 API 集成 中，通常会遇到 流式（streaming） 和 非流式（non-streaming） 两种模式。它们的主要区别在于 数据传输 和 响应的处理方式。

4.1非流式（Non-streaming）

非流式 模式指的是客户端发送请求后，等待服务端处理并返回完整的响应。客户端必须等待所有数据处理完毕后才能收到完整的结果。

流程：

• 请求：客户端向服务端发送请求，包含所有必要的信息（如输入数据、模型参数等）。
• 处理：服务端开始处理请求，执行推理（如文本生成、图像分析等）。
• 返回：服务端处理完毕后，将完整的结果返回给客户端。客户端接收到完整响应后进行进一步处理。

特点：

• 延迟：由于客户端要等待服务端返回完整的结果，因此响应时间较长。
• 易于实现：适用于返回较小数据的任务，如文本生成、语音识别等。
• 适用场景：当不需要实时获取部分数据时，或者任务较短时，非流式模式非常合适。

import openai
openai.api_key = "your-api-key"response = openai.Completion.create(engine="text-davinci-003",prompt="Write a short story about a robot learning to love",max_tokens=100
)print(response.choices[0].text.strip())  # 返回完整的文本结果

---

4.2 流式（Streaming）

流式 模式指的是客户端在发送请求后，服务端可以 实时地 返回部分处理结果。客户端可以逐步接收到数据，而不必等待所有结果处理完毕。

流程：

• 请求：客户端发送请求并等待响应开始。
• 处理：服务端开始处理请求，逐步生成并返回部分结果（例如逐个 token 或逐帧的结果）。
• 返回：服务端会在处理的过程中持续推送结果，客户端可以实时处理每一部分数据。

特点：

• 低延迟：因为服务端逐步返回结果，客户端可以在很短的时间内收到部分响应。
• 实时性：适合需要实时反馈的应用，如实时聊天、流媒体生成等。
• 复杂实现：客户端和服务端都需要支持流式传输，通常需要 WebSocket 或 HTTP/2 等技术。

import openaiopenai.api_key = "your-api-key"response = openai.Completion.create(engine="text-davinci-003",prompt="Write a short story about a robot learning to love",max_tokens=100,stream=True  # 开启流式模式
)for part in response:  # 实时处理每一部分返回的数据print(part["choices"][0]["text"], end="")

4.3 对比

流式 vs 非流式对比

特性	流式（Streaming）	非流式（Non-streaming）
响应时间	较低的延迟，部分结果实时返回	较长的延迟，等待完整的结果返回
适用场景	实时反馈、实时交互（如聊天机器人、视频流生成）	一次性获取完整结果（如大文本生成、文件转换）
实现复杂性	较复杂，需要支持流式传输协议（如 WebSocket、HTTP2）	简单，只需一次完整的请求和响应
客户端处理方式	客户端逐步处理部分数据	客户端等待完整结果返回后处理
网络传输	实时传输数据，一次性较小的响应数据	一次性返回完整数据，可能包含较大的响应体

• 非流式模式适合需要一次性处理完整任务并返回结果的场景，适用于任务相对简单、响应时间要求不严格的应用。
• 流式模式则更适用于实时交互或需要逐步返回结果的应用，能够大大降低延迟和提高用户体验，但实现更为复杂，通常需要支持流式传输的协议。

三、部署本地大模型

部署本地大模型 的意思是将一个已经训练好的大型模型下载到你本地的机器上，并在本地环境中进行推理（推理是指模型根据输入数据生成输出结果的过程）。与云端模型服务不同，本地部署意味着你将整个模型以及相关的资源（例如分词器、配置文件等）存储在本地计算机或服务器上，并且直接在本地进行计算和推理。

1.核心步骤

1. 下载预训练的大模型：你将一个预训练的大型模型从在线源（如 Hugging Face、TensorFlow Hub 等）下载到本地。
2. 加载模型到本地环境：在本地机器上通过相关框架（如 PyTorch、TensorFlow、Hugging Face Transformers 等）加载并使用该模型。
3. 本地推理：在本地执行模型推理，不需要依赖云端计算资源，可以在本地机器或服务器上直接运行推理。
4. 优化与部署：为了提高推理性能，可以使用优化方法（如模型量化、GPU 加速）来加速推理过程。

2.本地下载大模型

2.1 下载transformers

Transformers 是由 Hugging Face 提供的一个开源库，主要用于自然语言处理（NLP）任务，特别是加载、训练和应用预训练的大规模神经网络模型。

pip install transformers

我们将会使用其中的AutoTokenizer、AutoModelForCausalLM：

• AutoTokenizer：负责文本 ↔ token ↔ 数字 ID 的转换
• AutoModelForCausalLM：加载一个可用于文本生成的语言模型（GPT 类）
• 一起使用就能从字符串输入，到模型推理，再到字符串输出。

2.2 huggingface途径下载Qwen

官网:HF-Mirror

国内官网镜像:HF-Mirror

查找下载对应的模型

---

2.2.1 方式一：手动下载

# 打开命令行:
# 1. 激活虚拟环境 (conda activate xxx)
# 2. 运行指令来安装 huggingface_hub 插件
pip install huggingface_hub # 设置加速镜像
set HF_ENDPOINT=https://hf-mirror.com  # 设置国内镜像源# 使用 huggingface-cli 下载模型到本地目录 ./models
huggingface-cli download Qwen/Qwen3-0.6B --local-dir ./models

2.2.2 方式二：代码自动下载

from transformers import AutoModelForCausalLM, AutoTokenizer
import os# 设置 Hugging Face 镜像源，使用国内镜像加速模型下载
os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"# 模型名称，或者本地路径
model_name = "Qwen/Qwen3-0.6B"# 加载 Tokenizer 和 大模型
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name,  # 模型名称（也可以使用本地路径）torch_dtype="auto",  # 自动选择数据类型，通常是 FP16 或 FP32device_map="auto",  # 自动选择设备（GPU 或 CPU）cache_dir="./models"  # 模型下载缓存目录
)

1. os.environ["HF_ENDPOINT"]：通过设置 HF_ENDPOINT 环境变量为 国内镜像源（https://hf-mirror.com），加速 Hugging Face 上模型的下载。默认情况下，Hugging Face 的模型下载源在国外，通过设置国内镜像，可以减少下载时间。
2. AutoTokenizer.from_pretrained(model_name)：使用 AutoTokenizer 加载预训练模型的分词器。model_name 可以是模型名称或本地路径。如果是名称，Hugging Face 会自动下载模型对应的分词器。
3. AutoModelForCausalLM.from_pretrained(model_name)：使用 AutoModelForCausalLM 加载一个 因果语言模型（Causal Language Model）。这里模型的名称是 Qwen/Qwen3-0.6B，也可以指定本地路径加载已下载的模型。
4. torch_dtype="auto"：自动选择模型的数据类型（通常是 FP32 或 FP16），FP16 可以加速推理并减少内存使用。
5. device_map="auto"：自动选择设备（GPU 或 CPU），根据系统的硬件配置，优先使用 GPU（如果可用）。
6. cache_dir="./models"：指定下载路径，如果该目录不存在，会自动创建。

2.3 modelscope

官网:模型库首页 · 魔搭社区

在 ModelScope 中，也有类似 Hugging Face 的两种方式来获取和使用模型：Python 代码直接加载 和 命令行下载到本地。

2.3.1 方式一：命令行下载到本地（手动下载）

#1.安装工具
pip install modelscope
#2.下载模型
modelscope download --model Qwen/Qwen3-0.6B
#2.或者指定模型下载路径
modelscope download --model Qwen/Qwen3-0.6B  --local_dir ./model

• 指定目录：用 --local-dir ./models 指定存放路径。
• 自动创建文件夹：如果指定目录不存在，会自动创建。
• 离线使用：下载完成后，可以在 Python 里通过指定本地路径来加载模型，而不需要联网。

2.3.2 方式二：Python 代码直接加载（自动下载）

在 ModelScope 框架下用本地下载的大模型进行文本生成

from modelscope import AutoModelForCausalLM, AutoTokenizermodel_name = "Qwen/Qwen3-0.6B"
#model_name = "./model" #修改为自定义下载的路径
model = AutoModelForCausalLM.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)

• 自动下载：运行代码时，如果本地没有该模型，会自动从 ModelScope 官方仓库下载。
• 缓存目录：默认会存放在 ~/.cache/modelscope（Linux/macOS）或 C:\Users\<用户名>\.cache\modelscope（Windows）。

---

2.3.3 使用本地大模型生成对话

整体实现流程

用户问题 → 格式化对话 → Token化 → 模型生成 → 解析输出 → 分离思维与回答

步骤1: 问题输入格式化

prompt = "请写一个关于大模型部署的文章"
messages = [{"role": "user", "content": prompt}]

• 转换：原始问题 → 结构化对话格式
• 目的：让模型理解这是用户提问

步骤2: 应用聊天模板

text = tokenizer.apply_chat_template(messages, tokenize=False, ...)

• 转换：结构化对话 → 带特殊标记的文本字符串
• 示例输出：<|user|>请写...<|end|><|assistant|><|think|>

步骤3: 文本Token化

model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

• 转换：文本字符串 → 数字Token张量
• 包含：input_ids (Token ID序列), attention_mask (注意力掩码)

步骤4: 模型生成

generated_ids = model.generate(**model_inputs, max_new_tokens=512)

• 转换：输入Token → 扩展的输出Token序列
• 过程：模型自回归地预测下一个Token

步骤5: 截取新生成内容

output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist()

• 转换：完整生成序列 → 仅新生成部分
• 目的：去除输入部分，只保留模型新生成的内容

步骤6: 分离思维与回答

# 查找思维结束标记
index = len(output_ids) - output_ids[::-1].index(151668)thinking_content = tokenizer.decode(output_ids[:index], ...)
content = tokenizer.decode(output_ids[index:], ...)

• 转换：Token序列 → 可读文本
• 分离：内部思考过程 vs 最终回答内容

核心转换流程

原始问题文本↓ (格式化)
结构化对话消息↓ (模板化)
带特殊标记的提示文本↓ (Token化)
数字Token序列（输入）↓ (模型推理)
数字Token序列（完整输出）↓ (截取处理)
数字Token序列（新生成部分）↓ (解码分离)
{"thinking": "内部思考文本","answer": "最终回答文本"
}

【完整代码】

from modelscope import AutoModelForCausalLM,AutoTokenizer
'''
用户问题 → 格式化对话 → Token化 → 模型生成 → 解析输出 → 分离思维与回答
'''
model_name = '../models/qwen3'
tokenizers = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name,torch_dtype="auto",device_map="auto",)prompt = "请写一个关于大模型部署的文章"
messages = [{"role": "user", "content": prompt}
]
text = tokenizers.apply_chat_template(messages,tokenize = False,add_generation_prompt= True,# 添加生成提示enable_thinking=True,)
# 文本转数字
model_inputs = tokenizers([text], return_tensors="pt").to(model.device)
# 文本生成
generated_ids = model.generate(**model_inputs,max_new_tokens=512,)
output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist()# 解析思维内容
try:# 查找思维结束标记 </think>（对应token 151668）index = len(output_ids) - output_ids[::-1].index(151668)
except ValueError:index = 0# 获取思维链部分（从开始到</think>标记）
thinking_content = tokenizers.decode(output_ids[:index], skip_special_tokens=True).strip("\n")
# 获取最终回答部分（从</think>标记到结束）
content = tokenizers.decode(output_ids[index:], skip_special_tokens=True).strip("\n")print("thinking content:", thinking_content)  # 模型的内部思考过程
print("content:", content)                    # 最终的回答

2.4 DeepSeek本地部署

支持的模型版本

DeepSeek-Coder 系列（代码专用）

• DeepSeek-Coder 1.3B：需要 4GB 显存，消费级GPU可运行
• DeepSeek-Coder 6.7B：需要 16GB 显存，RTX 4090及以上
• DeepSeek-Coder 33B：需要 66GB 显存，需要多卡部署

DeepSeek-LLM 系列（通用大模型）

• DeepSeek-LLM 7B：需要 16GB 显存
• DeepSeek-LLM 67B：需要 140GB 显存，需要多卡部署

DeepSeek-V2 系列（最新版本）

• 稀疏MoE架构，参数利用率高
• 显存需求可变，根据激活参数数量决定

2.4.1 模型下载

通过huggingface下载：

• 从huggingface找到你要下载的模型

  

• 安装huggingface的下载工具(python库)：

  pip install huggingface_hub
  

• 下载模型文件

  set HF_ENDPOINT=https://hf-mirror.com  # 加速下载设置
  huggingface-cli download deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B --local-dir ./deepseek  # 下载模型文件
  

通过modelscope下载：

• 确保已安装 modelscope 库：

pip install modelscope

• 给当前命令行窗口 “临时配置” ModelScope 的国内镜像源

set MODEL_SCOPE_REPOSITORY_URL=https://mirror.aliyun.com/modelscope/hub/

• 下载模型文件

modelscope download --model deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B --local_dir ./my_model_path

2.4.2 deepseek部署

使用 Transformers 库

安装依赖：

pip install transformers accelerate torch

加载模型代码：

from transformers import AutoModelForCausalLM, AutoTokenizer# 选择模型
model_name = "deepseek-ai/deepseek-llm-7b"  # 7B版本
# model_name = "deepseek-ai/deepseek-coder-6.7b"  # 代码专用版本# 加载tokenizer和模型
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(model_name,torch_dtype="auto",      # 自动选择数据类型device_map="auto",       # 自动分配设备trust_remote_code=True   # 信任远程代码
)# 设置为评估模式
model.eval()

2.4.3 推理示例代码

def generate_text(prompt, max_length=512):inputs = tokenizer(prompt, return_tensors="pt").to(model.device)with torch.no_grad():outputs = model.generate(**inputs,max_length=max_length,temperature=0.7,do_sample=True,top_p=0.9,pad_token_id=tokenizer.eos_token_id)return tokenizer.decode(outputs[0], skip_special_tokens=True)# 使用示例
prompt = "请用Python写一个快速排序算法"
result = generate_text(prompt)
print(result)

2.4.4 非流式推理

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch# 一：加载模型
model_path = r"./modeldir"  # 模型路径
device = "cuda:0" if torch.cuda.is_available() else "cpu"
torch_dtype = torch.float16  # 指定模型参数类型为float16
model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch_dtype).to(device
)  # 加载模型并移动到GPU
tokenizer = AutoTokenizer.from_pretrained(model_path)  # 加载分词器# 二：设置生成参数和输入消息
gen_kwargs = {"max_length": 1024,  # 生成的最大长度"do_sample": True,  # 是否使用概率采样"top_k": 10,  # 在前K个候选词中随机采样，越大越随机"temperature": 0.7,  # 生成丰富性，越大越有创造力"top_p": 0.8,  # 从top_k中累积概率超过阈值 p 的最小 token 集合中采样，越大越随机"repetition_penalty": 1.2,  # 重复惩罚系数，越大越不容易重复
}
# 定义消息内容
messages = [{"role": "system", "content": "你是AI助手"},{"role": "user", "content": "明月几时有"},
]# 三：将输入数据转换为模型可接受的格式
inputs = tokenizer.apply_chat_template(messages,add_generation_prompt=True,tokenize=True,return_tensors="pt",return_dict=True,
).to(device
)  # 将输入数据移动到GPU# 四：生成输出
outputs = model.generate(**inputs, **gen_kwargs)  # 生成输出
outputs = outputs[:, inputs["input_ids"].shape[1] :]  # 截取生成的输出
result = tokenizer.decode(outputs[0], skip_special_tokens=True)  # 解码输出# 五：打印结果
print(result)  # 打印结果

2.4.5 流式推理

流式输出的核心，关键逻辑有 3 个：

• TextIteratorStreamer：绑定分词器，模型每生成一个（或一组）token，它会立即转换为文本片段并放入迭代队列。
• 多线程（Thread）：模型生成是耗时操作（尤其是长文本），用子线程运行 model.generate，主线程可以同时从 streamer 中读取实时结果，避免 “等全部生成完才返回”。
• 生成器（yield）：通过 yield new_text 逐片段返回结果，调用方可以通过循环实时获取每一段生成的文本（而非等待完整结果）。

from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
import torch
from threading import Threadclass DeepSeek:def __init__(self, model_path, device, torch_dtype):# 初始化时加载模型和分词器（与非流式逻辑一致）self.device = deviceself.model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch_dtype).to(device)  # 加载模型并移动到指定设备（GPU/CPU）self.tokenizer = AutoTokenizer.from_pretrained(model_path)  # 加载配套分词器def inference(self,messages,gen_kwargs):# 1. 输入预处理：将对话消息转换为模型可接受的张量格式（与非流式一致）inputs = self.tokenizer.apply_chat_template(messages,tokenize=True,add_special_tokens=True,# 自动添加“助手回复前缀”add_generation_prompt=True,return_tensors="pt",return_dict=True).to(self.device)# 2. 创建流式输出对象：实时捕获生成的文本片段streamer = TextIteratorStreamer(self.tokenizer, skip_special_tokens=True  # 自动跳过<bos>/<eos>等特殊符号)# 3. 整合生成参数：加入 streamer 指定流式输出generation_kwargs = dict(**inputs, **gen_kwargs, streamer=streamer)# 4. 启动多线程：在后台运行模型生成（关键！避免主线程阻塞）thread = Thread(target=self.model.generate, kwargs=generation_kwargs)thread.start()  # 模型在子线程中开始生成文本# 5. 流式返回结果：逐片段yield生成的文本generated_text = ""for new_text in streamer:  # streamer 会实时迭代返回模型生成的文本片段generated_text += new_textyield new_text  # 用yield实现“生成一段、返回一段”（生成器特性）if __name__ == "__main__":# 1. 模型初始化（与非流式一致）model_path = r"../models/qwen3"device = "cuda" if torch.cuda.is_available() else "cpu"    torch_dtype = torch.float16  # 用float16节省显存deepseek = DeepSeek(model_path, device, torch_dtype)# 2. 配置生成参数和对话消息（与非流式参数格式一致）gen_kwargs = {"max_length": 1024,"do_sample": True,"top_k": 10,"temperature": 0.7,"top_p": 0.8,"repetition_penalty": 1.2,}messages = [{"role": "system", "content": "你是一名人工智能助手"},{"role": "user", "content": "请简要介绍一下你自己"},]# 3. 调用流式推理并打印结果response = deepseek.inference(messages, gen_kwargs)  # response 是生成器对象result = ""for chunk in response:  # 循环迭代获取实时生成的文本片段（chunk）result += chunkprint(result)  # 每获取一段就打印一次（实现“实时刷新”效果）

• 调用 inference 方法后，得到的 response 是一个生成器对象（而非完整文本），需要通过 for chunk in response 逐段获取结果。
• 打印逻辑：每获取一个 chunk（如 “我”→“我是”→“我是基于”→…），就累加并打印当前完整内容，最终呈现 “文本实时生成、逐步拼接” 的视觉效果。

两者核心区别对比表

对比维度	流式输出（当前代码）	非流式输出（典型逻辑）
1. 结果返回方式	逐片段返回：用 yield 生成器实时返回文本片段（如 “我”→“我是”→“我是 AI”）	一次性返回：等模型生成完所有文本后，返回完整字符串
2. 线程模型	多线程：子线程运行模型生成，主线程实时读取结果（无阻塞）	单线程：主线程等待模型生成完成（全程阻塞，期间无法做其他操作）
3. 用户体验	实时交互感：生成过程可见（类似 ChatGPT 的 “打字” 效果），等待感弱	全量等待：需等完整文本生成后才显示，长文本时等待时间长（如 10 秒后一次性出结果）
4. 内存与资源占用	内存占用更平稳：生成的片段实时释放，无需缓存完整文本（适合长文本生成）	内存占用峰值高：需缓存完整生成的文本张量（长文本时可能占用更多显存 / 内存）
5. 核心依赖与逻辑	依赖 TextIteratorStreamer + Thread，需处理生成器迭代	无