最近，DeepSeek 发布了全新的 v3.2-Exp 实验版模型，引起了广泛关注。相比以往版本，这一代模型在保持强大推理与生成能力的同时，通过引入 Sparse Attention（稀疏注意力）机制，成功将 API 成本降低了一半以上。

如果你经常使用大语言模型，就会知道——长上下文处理是最“烧钱”的部分。DeepSeek v3.2 的出现正是为了解决这一痛点，它通过高效稀疏计算结构，让模型在应对长文本任务时既能保持性能，又能大幅提升推理速度与性价比。

在本教程中，我们将带你深入了解如何通过 API 调用并在实际项目中集成该模型，我们还将构建一个 基于 Streamlit 的可视化对比应用，直观展示 不同大语言模型（如 DeepSeek、GLM、Qwen 等）在成本与性能上的差异。

通过本教程，你不仅能快速上手 DeepSeek v3.2 的使用，还能掌握构建多模型对比评测系统的完整思路，为后续的大模型优化与部署打下坚实基础。

一.环境设置

1.获取 DeepSeek API 密钥

要开始使用 DeepSeek v3.2-Exp，你首先需要获取 API 密钥。请按照以下步骤操作：

1. 访问平台：在浏览器中打开 platform.deepseek.com

2. 注册账户：如果你还没有 DeepSeek 账户，点击“注册”按钮创建新账户。你可以使用电子邮箱或第三方平台账号进行注册。

3. 完成验证：按照页面提示完成邮箱验证或手机验证流程。

4. 进入 API 管理：登录成功后，在控制台界面中找到“API 密钥”或“API Keys”管理页面。

5. 创建新密钥：点击“创建新的 API 密钥”按钮，系统会生成一个以 sk- 开头的密钥字符串。

6. 安全保存：重要提示：立即将 API 密钥复制并保存到安全的地方，因为这个密钥只会在创建时显示一次。

2.配置 API 密钥到环境文件

现在我们需要将刚才获取的 DeepSeek API 密钥安全地存储到项目的环境配置文件中。请按照以下步骤操作：

1. 创建或编辑环境文件：在项目根目录下，使用终端命令创建或编辑 .env 文件：

   vi .env

2. 进入编辑模式：按 i 键切换到输入模式（你会看到左下角显示 -- INSERT -- 提示）

3. 输入 API 密钥：在文件中添加以下内容（将 your_api_key_here 替换为你实际获取的密钥）：

   DEEPSEEK_API_KEY=your_api_key_here

4. 保存并退出：

   • 按 Esc 键退出输入模式
   • 输入 :wq 并按回车键执行保存并退出

现在你已经准备好了访问 DeepSeek v3.2-Exp 模型的通行证！接下来我们就可以开始配置开发环境并编写第一个 API 调用代码了。

3.安装安装所需的软件包：

!pip install openai python-dotenv

二.发起你的第一个 API 调用

现在让我们来编写第一个 DeepSeek API 调用代码。虽然我们使用 OpenAI 的 SDK，但只需要调整两个关键参数就能轻松接入 DeepSeek 服务：

from openai import OpenAI

from dotenv import load_dotenv

import os

# 加载环境变量中的 API 密钥

load_dotenv()

# 初始化

client = OpenAI(

api_key=os.getenv("DEEPSEEK_API_KEY"),

base_url="https://api.deepseek.com"

)

# 发送聊天请求

response = client.chat.completions.create(

model="deepseek-chat",

messages=[

{"role": "user", "content": "用一句话解释DeepSeek Sparse Attention"}

]

)

# 打印模型回复

print(response.choices[0].message.content)

DeepSeek Sparse Attention通过只计算最重要的注意力连接，大幅减少了计算量和内存消耗，同时保持了模型的核心性能。

运行上面的代码，你将收到 DeepSeek 模型的第一个回复！这是 v3.2-Exp 的非推理模式，模型会直接处理你的请求并返回最终结果，不会展示内部的推理步骤。这种模式响应速度更快，适合大多数日常对话和任务。

如果你想要了解模型的思考过程，可以使用推理模式。这个模型会先展示完整的思维链，然后再给出最终答案，非常适合学习、调试和复杂问题分析。

# 推理模式 - 展示思考过程

response = client.chat.completions.create(

model="deepseek-reasoner",

messages=[

{"role": "user", "content": "9.11和9.8哪个数字更大?"}

]

)

# 获取推理过程和最终答案

print("Reasoning:", response.choices[0].message.reasoning_content)

print("Answer:", response.choices[0].message.content)

Reasoning: 首先，用户的问题是：“9.11和9.8哪个数字更大？”这是一个比较两个小数的问题。

我需要比较9.11和9.8。9.11是九点一一，而9.8是九点八。为了更容易比较，我可以将它们视为小数。

9.11相当于9.11，而9.8相当于9.80。因为9.8可以写成9.80，这样我就可以比较小数点后的数字。

比较小数时，先比较整数部分。两个数字的整数部分都是9，所以整数部分相同。

然后比较小数部分。9.11的小数部分是0.11，而9.8的小数部分是0.80。显然，0.80大于0.11，因为80比11大。

所以，9.80大于9.11，因此9.8大于9.11。

为了确认，我可以计算差值：9.8 - 9.11 = 0.69，这是一个正数，所以9.8更大。

因此，答案应该是9.8更大。

现在，我需要以中文回复，因为用户的问题是中文的。所以，我会用中文回答。

Answer: 9.11和9.8比较，9.8更大。

- 9.11 相当于 9.11

- 9.8 相当于 9.80

比较小数时，整数部分相同（都是9），然后比较小数部分：0.80（来自9.8）大于0.11（来自9.11），因此9.8 > 9.11。

三.构建多文档研究助手 - 国产大模型长上下文性能实战对比

现在你已经掌握了 DeepSeek API 的基本调用方法，接下来让我们通过一个真实的应用场景来检验 v3.2 在国产大模型中的实际表现。

核心问题探索：
DeepSeek 的稀疏注意力技术在处理长上下文时，与 GLM-4.6、Qwen3-Max 等主流国产模型相比，在成本和性能方面有哪些优势？

项目设计思路：
我们将构建一个智能对比工具，该工具能够将多篇研究论文加载到单个上下文中，然后向三个国产主流模型发送相同的查询。通过这个实验，你将清晰地看到：

• 每个模型的实际使用成本对比
• 响应速度快慢差异分析
• 回答质量的内容评估

技术方案选择：
传统文档分析系统通常采用 RAG（检索增强生成）技术：将文档切分成小块，进行向量嵌入，然后在提问时只检索相关片段。这种方法适合简单查询，但会丢失文档不同部分之间的关联信息。

而长上下文模型提供了更直接的解决方案：一次性阅读所有内容。不需要文档分块，不需要检索过程，不会丢失任何上下文信息。你将所有文档加载到单个提示中，让模型看到完整的图景。这对于需要跨文档理解的研究任务尤为重要。

这正是测试 DeepSeek 稀疏注意力优势的绝佳场景！

我们将构建一个应用程序，加载三篇研究论文（总计约 57,000 tokens）到单个上下文中，并对比三个国产大模型处理相同查询的表现：

• DeepSeek v3.2-Exp（具备稀疏注意力技术）
• GLM-4.6（智谱最新模型）
• Qwen3-Max（阿里通义千问最强版本）

1.环境搭建

应用架构设计：
整个应用将分为三个核心模块，各司其职：

• 文档加载模块：负责PDF文件的读取和文本预处理
• 模型配置模块：管理不同模型的API配置和成本计算
• 查询处理模块：处理用户问题并调用各个模型

首先创建项目目录并安装所需依赖：

!mkdir -p multi-document-qa && cd multi-document-qa && pip install -q streamlit langchain langchain-openai langchain-community pypdf tiktoken python-dotenv matplotlib pandas

WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable.It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning.

2.创建环境配置文件

获取各平台 API 密钥的途径：

• 智谱GLM：访问 open.bigmodel.cn
• 通义千问：访问 dashscope.aliyun.com

在 .env 文件中继续添加另外两个模型的 API 密钥：

完成这个步骤后，你的项目就具备了访问三大国产大模型的能力，为后续的多模型对比实验做好了准备！

3.下载研究论文数据

让我们下载三篇关于注意力机制的研究论文作为测试数据：

!mkdir documents

!cd documents && curl -L -o selective-attention.pdf "https://arxiv.org/pdf/2410.02703"

!cd documents && curl -L -o differential-transformer.pdf "https://arxiv.org/pdf/2410.05258"

!cd documents && curl -L -o sparse-attention-long-range.pdf "https://arxiv.org/pdf/2406.16747"

  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current

                                 Dload  Upload   Total   Spent    Left  Speed

100 2392k  100 2392k    0     0  1463k      0  0:00:01  0:00:01 --:--:-- 1463k

  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current

                                 Dload  Upload   Total   Spent    Left  Speed

100 1052k  100 1052k    0     0   824k      0  0:00:01  0:00:01 --:--:--  824k

  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current

                                 Dload  Upload   Total   Spent    Left  Speed

100 2152k  100 2152k    0     0  1733k      0  0:00:01  0:00:01 --:--:-- 1733k

这三篇论文将作为我们测试长上下文处理能力的知识库，总计约 57,000 tokens，适合检验各模型在真实研究场景下的表现。

4.创建文档加载模块

现在创建 document_loader.py 文件，模块核心功能是：

文档处理流程：

• 自动扫描指定目录中的所有 PDF 文件
• 使用 PyPDFLoader 逐页提取文本内容
• 用文档分隔符将各论文内容拼接成连贯的长文本

Token 计数机制：

• 采用 tiktoken 库配合 GPT-4 编码器进行精确计数
• 这种计数方式在所有模型提供商间都具有良好的一致性，因为大多使用相似的分词方法
• 为后续的成本计算和性能分析提供准确的基准数据

# document_loader.py

from langchain_community.document_loaders import PyPDFLoader

import tiktoken

from pathlib import Path

def load_documents(documents_dir="documents"):

docs_path = Path(documents_dir)

pdf_files = list(docs_path.glob("*.pdf"))

all_text = ""

document_names = []

# 加载指定目录下的所有 PDF文件并拼接成一个完整文本

for pdf_file in sorted(pdf_files):

loader = PyPDFLoader(str(pdf_file))

pages = loader.load()

doc_text = "\n\n".join([page.page_content for page in pages])

all_text += f"\n\n=== Document: {pdf_file.name} ===\n\n{doc_text}"

document_names.append(pdf_file.name)

encoding = tiktoken.encoding_for_model("gpt-4")

token_count = len(encoding.encode(all_text))

return all_text, token_count, document_names

def count_tokens(text, model="gpt-4"):

encoding = tiktoken.encoding_for_model(model)

return len(encoding.encode(text))

该模块确保了多文档加载的自动化处理，并为长上下文性能对比实验准备了标准化的测试数据。

5.创建模型配置模块

创建 model_config.py 文件，统一管理模型配置和定价信息，这里我统计了不同厂家的收费情况：
 

 

import os

import requests

from langchain_openai import ChatOpenAI

from langchain_community.chat_models import ChatZhipuAI # 用于GLM模型

# 模型定价

MODEL_PRICING = {

"deepseek-chat": {"input": 2, "output": 3, "name": "DeepSeek v3.2-Exp"},

"glm-4.6": {"input": 4, "output": 16, "name": "GLM-4.6"},

"qwen3-max": {"input": 6, "output": 24, "name": "Qwen3-Max"},

}

def get_model(model_name):

"""通过 LangChain 的统一接口按名称初始化一个聊天模型"""

if model_name == "deepseek-chat":

return ChatOpenAI(

model="deepseek-chat",

temperature=0,

api_key=os.getenv("DEEPSEEK_API_KEY"),

base_url="https://api.deepseek.com"

)

elif model_name == "glm-4.6":

return ChatZhipuAI(

model="glm-4.6",

temperature=0,

api_key=os.getenv("ZHIPUAI_API_KEY")

)

elif model_name == "qwen3-max":

return ChatOpenAI(

model="qwen3-max",

temperature=0,

api_key=os.getenv("DASHSCOPE_API_KEY"),

base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"

)

else:

raise ValueError(f"Unknown model name: {model_name}")

def calculate_cost(model_name, input_tokens, output_tokens):

"""根据输入和输出的 token 使用量计算总成本。"""

pricing = MODEL_PRICING.get(model_name)

if not pricing:

raise ValueError(f"Pricing not defined for model: {model_name}")

input_cost = (input_tokens / 1_000_000) * pricing["input"]

output_cost = (output_tokens / 1_000_000) * pricing["output"]

total_cost = input_cost + output_cost

return total_cost

5.创建查询处理模块

创建 query_handler.py 文件，实现模型查询和指标追踪功能：

# query_handler.py

import time

from langchain_core.messages import SystemMessage, HumanMessage

from model_config import get_model, calculate_cost, MODEL_PRICING

def query_model(model_name, context, question):

model = get_model(model_name)

system_prompt = f"""Use the given context to answer the question.

If you don't know the answer, say you don't know. Keep the answer concise.

Context:

{context}"""

messages = [

SystemMessage(content=system_prompt),

HumanMessage(content=question)

]

start_time = time.time()

在我们的查询处理中，系统提示词包含了总计约57,000个token的研究论文内容，这正好凸显了DeepSeek v3.2稀疏注意力的革命性突破。传统的注意力机制需要处理每个token与其他所有token之间的关联关系，当面对长文档时会产生指数级增长的计算开销和成本压力；而DeepSeek v3.2的稀疏注意力则通过智能地跳过不重要的token连接，只计算那些真正相关的注意力关联，从而在保持模型核心性能的同时大幅降低了计算复杂度和API调用成本，为长上下文处理提供了一个既高效又经济实用的解决方案。

try:

# 调用模型

response = model.invoke(messages)

elapsed_time = time.time() - start_time

# 提取 token 统计

if hasattr(response, 'response_metadata') and 'token_usage' in response.response_metadata:

token_usage = response.response_metadata['token_usage']

input_tokens = token_usage.get('prompt_tokens', 0)

output_tokens = token_usage.get('completion_tokens', 0)

elif hasattr(response, 'usage_metadata'):

input_tokens = response.usage_metadata.get('input_tokens', 0)

output_tokens = response.usage_metadata.get('output_tokens', 0)

else:

input_tokens = 0

output_tokens = 0

# 计算总费用

cost = calculate_cost(model_name, input_tokens, output_tokens)

return {

"model": MODEL_PRICING[model_name]["name"],

"response": response.content,

"input_tokens": input_tokens,

"output_tokens": output_tokens,

"total_tokens": input_tokens + output_tokens,

"cost": cost,

"time": elapsed_time,

"error": None

}

except Exception as e:

elapsed_time = time.time() - start_time

error_msg = str(e)

# 友好错误提示

if "402" in error_msg or "Insufficient Balance" in error_msg:

error_msg = "Insufficient Balance - Please add credits to your DeepSeek account at https://platform.deepseek.com"

elif "401" in error_msg or "Unauthorized" in error_msg:

error_msg = "Invalid API key - Please check your API key in .env file"

return {

"model": MODEL_PRICING[model_name]["name"],

"response": f"Error: {error_msg}",

"input_tokens": 0,

"output_tokens": 0,

"total_tokens": 0,

"cost": 0,

"time": elapsed_time,

"error": error_msg

}

6.创建Streamlit应用界面

现在我们来构建 app.py 主应用文件，这是整个多模型对比平台的用户界面核心。这个文件将导入所有必要的功能模块——包括文档加载、模型查询和配置管理，初始化Streamlit页面设置，创建侧边栏的文档管理区域和主内容区的模型选择界面，最终形成一个完整的交互式Web应用，让用户能够直观地加载研究论文、选择对比模型、提出问题并实时查看各模型在回答质量、响应速度和成本效益方面的全方位对比结果。

import streamlit as st

import pandas as pd

import matplotlib.pyplot as plt

from document_loader import load_documents, count_tokens

from query_handler import query_model

from model_config import check_deepseek_balance

from dotenv import load_dotenv

# Load environment variables

load_dotenv()

# Page config

st.set_page_config(

page_title="多文档研究助手",

page_icon="📚",

layout="wide"

)

# Title

st.title("📚 多文档研究助手")

st.markdown("跨模型长上下文性能对比：DeepSeek v3.2-Exp vs. Qwen3-Max vs. GLM-4.6")

构建应用的侧边栏功能，提供了文档加载管理和API状态监控两大核心模块。当用户点击载入文档按钮时，系统会加载指定目录下的所有PDF研究论文，并实时显示文档数量、总token数以及具体的文件列表；同时用户还可以查询DeepSeek API的账户余额状态，系统会智能判断余额是否充足并给出相应的提示信息，确保API服务的正常可用性。

with st.sidebar:

st.header("📄 已加载文档")

if st.button("载入文档"):

with st.spinner("正在加载文档..."):

context, token_count, doc_names = load_documents("documents")

st.session_state.context = context

st.session_state.token_count = token_count

st.session_state.doc_names = doc_names

if "token_count" in st.session_state:

st.success(f"✅ 载入文档数量： {len(st.session_state.doc_names)} ")

st.metric("Token 总数", f"{st.session_state.token_count:,}")

st.write("**文档列表:**")

for name in st.session_state.doc_names:

st.write(f"• {name}")

# Check DeepSeek balance

st.divider()

st.header("💰 API 状态")

if st.button("查询 DeepSeek 余额"):

with st.spinner("正在查询余额..."):

balance_info = check_deepseek_balance()

if balance_info:

is_available = balance_info.get('is_available', False)

balances = balance_info.get('balance_infos', [])

if balances and len(balances) > 0:

total = balances[0].get('total_balance', '0.00')

if is_available and float(total) > 0:

st.success(f"✅ 账户余额: ￥{total}")

else:

st.error(f"⚠️ 账户余额不足: ￥{total}")

st.info("💡 请前往 https://platform.deepseek.com 添加额度")

else:

st.warning("无法查询余额")

构建应用的核心交互逻辑，首先检查用户是否已加载文档，如未加载则提示用户先完成文档准备；在文档就绪后界面会提供三列复选框供用户选择要对比的DeepSeek、Qwen和GLM模型，同时提供预设问题示例和自定义问题输入框，当用户点击提问按钮后系统会并行调用所选模型的API接口，将所有查询结果存储在会话状态中为后续的对比展示做好准备。

if "context" not in st.session_state:

st.subheader("请输入您的问题")

# Pre-defined questions

sample_questions = [

"比较这些文档中描述的注意力机制的主要方法",

"稀疏注意力和密集注意力之间的主要区别是什么？",

"总结所有文档中的共同主题"

]

question_choice = st.selectbox(

"选择示例问题，或输入自定义问题：",

["自定义问题"] + sample_questions

)

if question_choice == "自定义问题":

question = st.text_area("输入您的问题:", height=100)

else:

question = st.text_area("输入您的问题:", value=question_choice, height=100)

# Query button

if st.button("🚀 提问", type="primary"):

if not question:

st.error("问题不能为空")

else:

selected_models = []

if use_deepseek_v32:

selected_models.append("deepseek-chat")

if use_qwen3_max:

selected_models.append("qwen3-max")

if use_glm_4_6:

selected_models.append("glm-4.6")

if not selected_models:

st.error("请至少选择一个模型")

else:

results = []

# Query each model

for model_name in selected_models:

with st.spinner(f"正在查询 {model_name}..."):

result = query_model(

model_name,

st.session_state.context,

question

)

results.append(result)

# Store results

st.session_state.results = results

st.session_state.question = question

查询完成后会在页面中显示一个清晰的结果区域，首先以可折叠面板的形式展示每个模型的回答内容并同时显示对应的费用和响应时间，然后通过数据表格直观呈现所有模型的详细性能指标对比，包括输入输出token数量、总token消耗、API调用成本和响应时间等关键数据，让用户能够快速评估各模型的表现差异。

if "results" in st.session_state:

st.divider()

st.subheader("📊 结果")

results = st.session_state.results

# Display responses

st.markdown("### 回答")

for result in results:

with st.expander(f"**{result['model']}** - ￥{result['cost']:.4f} | {result['time']:.2f}s"):

if result['error']:

st.error(f"Error: {result['error']}")

else:

st.write(result['response'])

# Metrics comparison

st.markdown("### 性能对比")

# Create metrics dataframe

metrics_df = pd.DataFrame([

{

"Model": r['model'],

"Input Tokens": r['input_tokens'],

"Output Tokens": r['output_tokens'],

"Total Tokens": r['total_tokens'],

"Cost (￥)": f"￥{r['cost']:.4f}",

"Time (s)": f"{r['time']:.2f}"

}

for r in results

])

st.dataframe(metrics_df, use_container_width=True)

通过matplotlib创建一个包含四组可视化图表的综合对比面板，分别从成本对比、响应时间、token使用情况以及成本时间权衡关系四个维度进行直观展示，其中成本和时间采用柱状图直接比较各模型的数值差异，token使用通过分组柱状图显示输入输出的分布情况，散点图则清晰展现了成本与响应时间之间的权衡关系，最终通过Streamlit将整个图表面板渲染在Web界面上，为用户提供全方位的模型性能视觉分析。

fig, axes = plt.subplots(2, 2, figsize=(12, 10))

# Cost comparison

axes[0, 0].bar([r['model'] for r in results], [r['cost'] for r in results], color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'][:len(results)])

axes[0, 0].set_title('Cost Comparison')

axes[0, 0].set_ylabel('Cost (￥)')

axes[0, 0].tick_params(axis='x', rotation=45)

# Time comparison

axes[0, 1].bar([r['model'] for r in results], [r['time'] for r in results], color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'][:len(results)])

axes[0, 1].set_title('Response Time Comparison')

axes[0, 1].set_ylabel('Time (seconds)')

axes[0, 1].tick_params(axis='x', rotation=45)

# Token usage

models = [r['model'] for r in results]

input_tokens = [r['input_tokens'] for r in results]

output_tokens = [r['output_tokens'] for r in results]

x = range(len(models))

width = 0.35

axes[1, 0].bar([i - width/2 for i in x], input_tokens, width, label='Input', color='#1f77b4')

axes[1, 0].bar([i + width/2 for i in x], output_tokens, width, label='Output', color='#ff7f0e')

axes[1, 0].set_title('Token Usage Comparison')

axes[1, 0].set_ylabel('Tokens')

axes[1, 0].set_xticks(x)

axes[1, 0].set_xticklabels(models, rotation=45, ha='right')

axes[1, 0].legend()

# Cost vs Time scatter

axes[1, 1].scatter([r['cost'] for r in results], [r['time'] for r in results], s=100, alpha=0.6, color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'][:len(results)])

for i, r in enumerate(results):

axes[1, 1].annotate(r['model'], (r['cost'], r['time']), fontsize=8, ha='right')

axes[1, 1].set_title('Cost vs Time Trade-off')

axes[1, 1].set_xlabel('Cost (￥)')

axes[1, 1].set_ylabel('Time (seconds)')

axes[1, 1].grid(True, alpha=0.3)

plt.tight_layout()

st.pyplot(fig)

在结果分析的最终部分提供核心发现总结，通过自动计算找出所有对比模型中成本最低的性价比冠军和响应速度最快的性能优胜者，并以醒目的指标卡片形式并排展示这两个关键结论，帮助用户快速把握各模型在经济效益和响应效率方面的突出表现。

st.markdown("### 🔍 核心发现")

if len(results) > 1:

cheapest = min(results, key=lambda x: x['cost'])

fastest = min(results, key=lambda x: x['time'])

col1, col2 = st.columns(2)

with col1:

st.metric("性价比最高", cheapest['model'], f"￥{cheapest['cost']:.4f}")

with col2:

st.metric("响应速度最快", fastest['model'], f"{fastest['time']:.2f}s")

7.启动应用

在终端中进入项目目录，执行命令即可启动多模型对比平台，此时你可以开始加载研究文档、选择对比模型并提出问题，实时查看各大型语言模型在长上下文处理任务中的性能表现和成本差异。

streamlit run app.py