架构师AI杜

Appearance

第13天：国内大模型详解 ​

学习目标 ​

本节将带领读者了解国内主流大模型，掌握文心一言、通义千问、混元、豆包、GLM、Kimi、DeepSeek、Yi的特点，对比国内大模型的差异，并能够调用国内大模型API。

课程内容 ​

1. 文心一言（百度） ​

1.1 模型概述 ​

文心一言是百度开发的大语言模型，于2023年3月发布，采用ERNIE（Enhanced Representation through Knowledge Integration）架构，参数量估计为千亿级。其核心特点包括知识增强预训练、多模态能力、中文优化、企业级应用等，特别适合中文场景和企业级应用。

1.2 架构特点 ​

ERNIE架构：

python
class ERNIEEncoderLayer(nn.Module):
    def __init__(self, d_model, nhead, d_ff, dropout=0.1):
        super().__init__()
        
        # 知识增强注意力
        self.knowledge_attn = KnowledgeEnhancedAttention(d_model, nhead)
        
        # 自注意力
        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
        
        # 前馈网络
        self.ffn = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(d_ff, d_model)
        )
        
        # 层归一化
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.norm3 = nn.LayerNorm(d_model)
        
        # Dropout
        self.dropout1 = nn.Dropout(dropout)
        self.dropout2 = nn.Dropout(dropout)
        self.dropout3 = nn.Dropout(dropout)
    
    def forward(self, x, knowledge_mask=None, attention_mask=None):
        """
        Args:
            x: 输入 [batch_size, seq_len, d_model]
            knowledge_mask: 知识掩码
            attention_mask: 注意力掩码
        
        Returns:
            output: 输出 [batch_size, seq_len, d_model]
        """
        # 知识增强注意力
        knowledge_output = self.knowledge_attn(x, knowledge_mask)
        x = x + self.dropout1(knowledge_output)
        x = self.norm1(x)
        
        # 自注意力
        attn_output, _ = self.self_attn(x, x, x, key_padding_mask=attention_mask)
        x = x + self.dropout2(attn_output)
        x = self.norm2(x)
        
        # 前馈网络
        ffn_output = self.ffn(x)
        x = x + self.dropout3(ffn_output)
        x = self.norm3(x)
        
        return x

class KnowledgeEnhancedAttention(nn.Module):
    def __init__(self, d_model, nhead):
        super().__init__()
        self.d_model = d_model
        self.nhead = nhead
        
        # 知识查询
        self.knowledge_query = nn.Linear(d_model, d_model)
        
        # 知识键
        self.knowledge_key = nn.Linear(d_model, d_model)
        
        # 知识值
        self.knowledge_value = nn.Linear(d_model, d_model)
    
    def forward(self, x, mask=None):
        """
        Args:
            x: 输入 [batch_size, seq_len, d_model]
            mask: 知识掩码
        
        Returns:
            output: 知识增强输出 [batch_size, seq_len, d_model]
        """
        batch_size, seq_len, _ = x.shape
        
        # 计算知识Q、K、V
        Q = self.knowledge_query(x)
        K = self.knowledge_key(x)
        V = self.knowledge_value(x)
        
        # 计算注意力分数
        scores = torch.matmul(Q, K.transpose(-2, -1))
        scores = scores / torch.sqrt(torch.tensor(self.d_model, dtype=torch.float32))
        
        # 应用掩码
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
        
        # 计算注意力权重
        weights = F.softmax(scores, dim=-1)
        
        # 计算输出
        output = torch.matmul(weights, V)
        
        return output

1.3 API调用 ​

安装SDK：

bash
pip install qianfan

调用示例：

python
import qianfan

# 初始化客户端
client = qianfan.ChatCompletion(
    ak="your-access-key",
    sk="your-secret-key"
)

# 调用模型
response = client.do(
    model="ERNIE-Bot-4",
    messages=[
        {"role": "user", "content": "请介绍一下文心一言"}
    ],
    temperature=0.7,
    top_p=0.9,
    max_output_tokens=1000
)

# 获取结果
print(response["result"])

流式输出：

python
# 流式调用
response = client.do(
    model="ERNIE-Bot-4",
    messages=[
        {"role": "user", "content": "请写一首关于春天的诗"}
    ],
    stream=True
)

for chunk in response:
    print(chunk["result"], end="", flush=True)

1.4 应用场景 ​

适合场景：

文心一言适合的场景包括知识问答、文本生成、代码生成、多模态理解、企业应用等方面。在这些场景下，文心一言能够提供高质量的服务。

不适合场景：

文心一言不适合的场景包括实时对话（延迟较高）、长文本处理（上下文限制）等方面。在这些场景下，文心一言的性能可能无法满足需求。

2. 通义千问（阿里） ​

2.1 模型概述 ​

基本信息：

通义千问的基本信息包括开发者（阿里云）、发布时间（2023年4月）、架构（Transformer Decoder）、参数量（72B（Qwen-72B））等方面。

核心特点：

通义千问的核心特点包括多尺寸模型系列、强大的中文能力、开源友好、多模态支持等方面。

2.2 模型系列 ​

Qwen系列：

Qwen系列包括Qwen-0.5B（超轻量级）、Qwen-1.8B（轻量级）、Qwen-7B（小型）、Qwen-14B（中型）、Qwen-72B（大型）、Qwen-110B（超大型）等版本。

Qwen-VL：多模态版本

2.3 API调用 ​

安装SDK：

bash
pip install dashscope

调用示例：

python
from dashscope import Generation

# 配置API Key
import dashscope
dashscope.api_key = "your-api-key"

# 调用模型
response = Generation.call(
    model="qwen-max",
    prompt="请介绍一下通义千问",
    max_tokens=1000,
    temperature=0.7,
    top_p=0.9
)

# 获取结果
print(response.output.text)

流式输出：

python
# 流式调用
response = Generation.call(
    model="qwen-max",
    prompt="请写一个Python函数计算斐波那契数列",
    stream=True,
    result_format='message'
)

for chunk in response:
    if chunk.output.choices:
        print(chunk.output.choices[0].message.content, end="", flush=True)

2.4 本地部署 ​

使用Hugging Face：

python
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# 加载模型
model_name = "Qwen/Qwen-7B-Chat"
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto",
    trust_remote_code=True
).eval()

# 生成文本
prompt = "请介绍一下通义千问"
inputs = tokenizer(prompt, return_tensors="pt")
inputs = inputs.to(model.device)

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=500,
        temperature=0.7,
        top_p=0.9
    )

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

2.5 应用场景 ​

适合场景：

通义千问的适合场景包括代码生成、文本生成、知识问答、多语言处理、本地部署等方面。

3. 混元（腾讯） ​

3.1 模型概述 ​

基本信息：

混元的基本信息包括开发者（腾讯）、发布时间（2023年9月）、架构（Transformer）、参数量（未公开）等方面。

核心特点：

混元的核心特点包括多模态能力、腾讯生态集成、企业级服务、中文优化等方面。

3.2 API调用 ​

调用示例：

python
import requests
import json

# 配置
url = "https://hunyuan.tencentcloudapi.com/"
secret_id = "your-secret-id"
secret_key = "your-secret-key"

# 请求
payload = {
    "Model": "hunyuan-lite",
    "Messages": [
        {
            "Role": "user",
            "Content": "请介绍一下混元大模型"
        }
    ],
    "Stream": False
}

# 发送请求
response = requests.post(
    url,
    headers={
        "Content-Type": "application/json",
        "Authorization": f"Bearer {secret_id}.{secret_key}"
    },
    data=json.dumps(payload)
)

# 获取结果
result = response.json()
print(result["Response"]["Reply"])

3.3 应用场景 ​

适合场景：

混元的适合场景包括腾讯生态应用、多模态处理、企业服务、内容生成等方面。

4. 豆包（字节跳动） ​

4.1 模型概述 ​

基本信息：

豆包的基本信息包括开发者（字节跳动）、发布时间（2023年）、架构（Transformer）、参数量（未公开）等方面。

核心特点：

豆包的核心特点包括对话能力强、推荐算法结合、多模态支持、移动端优化等方面。

4.2 API调用 ​

调用示例：

python
import requests
import json

# 配置
url = "https://ark.cn-beijing.volces.com/api/v3/chat/completions"
api_key = "your-api-key"

# 请求
payload = {
    "model": "ep-2024xxxx",
    "messages": [
        {
            "role": "user",
            "content": "请介绍一下豆包大模型"
        }
    ],
    "temperature": 0.7,
    "max_tokens": 1000
}

# 发送请求
response = requests.post(
    url,
    headers={
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    },
    data=json.dumps(payload)
)

# 获取结果
result = response.json()
print(result["choices"][0]["message"]["content"])

4.3 应用场景 ​

适合场景：

豆包的适合场景包括对话系统、内容推荐、短视频生成、移动应用等方面。

5. GLM（智谱AI） ​

5.1 模型概述 ​

基本信息：

GLM的基本信息包括开发者（智谱AI（清华大学））、发布时间（2023年）、架构（GLM（General Language Model））、参数量（130B（GLM-130B））等方面。

核心特点：

GLM的核心特点包括自研架构、开源友好、多模态支持、强大的中文能力等方面。

5.2 GLM架构 ​

GLM架构特点：

python
class GLMDecoderLayer(nn.Module):
    def __init__(self, d_model, nhead, d_ff, dropout=0.1):
        super().__init__()
        
        # 双向注意力（编码器）
        self.bilateral_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
        
        # 自回归注意力（解码器）
        self.autoregressive_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
        
        # 前馈网络
        self.ffn = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(d_ff, d_model)
        )
        
        # 层归一化
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.norm3 = nn.LayerNorm(d_model)
        
        # Dropout
        self.dropout1 = nn.Dropout(dropout)
        self.dropout2 = nn.Dropout(dropout)
        self.dropout3 = nn.Dropout(dropout)
    
    def forward(self, x, mask=None):
        """
        Args:
            x: 输入 [batch_size, seq_len, d_model]
            mask: 注意力掩码
        
        Returns:
            output: 输出 [batch_size, seq_len, d_model]
        """
        # 双向注意力
        bilateral_output, _ = self.bilateral_attn(x, x, x, key_padding_mask=mask)
        x = x + self.dropout1(bilateral_output)
        x = self.norm1(x)
        
        # 自回归注意力
        causal_mask = torch.triu(torch.ones(x.size(1), x.size(1)), diagonal=1)
        causal_mask = causal_mask.masked_fill(causal_mask == 1, float('-inf'))
        autoregressive_output, _ = self.autoregressive_attn(x, x, x, attn_mask=causal_mask)
        x = x + self.dropout2(autoregressive_output)
        x = self.norm2(x)
        
        # 前馈网络
        ffn_output = self.ffn(x)
        x = x + self.dropout3(ffn_output)
        x = self.norm3(x)
        
        return x

5.3 API调用 ​

安装SDK：

bash
pip install zhipuai

调用示例：

python
from zhipuai import ZhipuAI

# 初始化客户端
client = ZhipuAI(api_key="your-api-key")

# 调用模型
response = client.chat.completions.create(
    model="glm-4",
    messages=[
        {"role": "user", "content": "请介绍一下GLM大模型"}
    ],
    temperature=0.7,
    max_tokens=1000
)

# 获取结果
print(response.choices[0].message.content)

流式输出：

python
# 流式调用
response = client.chat.completions.create(
    model="glm-4",
    messages=[
        {"role": "user", "content": "请写一个Python冒泡排序"}
    ],
    stream=True
)

for chunk in response:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

5.4 本地部署 ​

使用Hugging Face：

python
from transformers import AutoTokenizer, AutoModel
import torch

# 加载模型
model_name = "THUDM/chatglm3-6b"
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModel.from_pretrained(
    model_name,
    trust_remote_code=True
).half().cuda()
model = model.eval()

# 生成文本
response, history = model.chat(tokenizer, "请介绍一下GLM大模型", history=[])
print(response)

5.5 应用场景 ​

适合场景：

GLM的适合场景包括代码生成、知识问答、文本生成、多模态处理、本地部署等方面。

6. Kimi（月之暗面） ​

6.1 模型概述 ​

基本信息：

Kimi的基本信息包括开发者（月之暗面）、发布时间（2023年）、架构（Transformer）、参数量（未公开）等方面。

核心特点：

Kimi的核心特点包括超长上下文（200万token）、强大的记忆能力、多模态支持、文件处理能力强等方面。

6.2 API调用 ​

调用示例：

python
import requests
import json

# 配置
url = "https://api.moonshot.cn/v1/chat/completions"
api_key = "your-api-key"

# 请求
payload = {
    "model": "moonshot-v1-128k",
    "messages": [
        {
            "role": "user",
            "content": "请介绍一下Kimi大模型"
        }
    ],
    "temperature": 0.7,
    "max_tokens": 1000
}

# 发送请求
response = requests.post(
    url,
    headers={
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    },
    data=json.dumps(payload)
)

# 获取结果
result = response.json()
print(result["choices"][0]["message"]["content"])

6.3 文件上传 ​

上传文件：

python
# 上传文件
files = {
    "file": ("document.pdf", open("document.pdf", "rb"), "application/pdf")
}

response = requests.post(
    "https://api.moonshot.cn/v1/files",
    headers={
        "Authorization": f"Bearer {api_key}"
    },
    files=files
)

file_id = response.json()["id"]

# 使用文件
payload = {
    "model": "moonshot-v1-128k",
    "messages": [
        {
            "role": "system",
            "content": "你是一个文档分析助手"
        },
        {
            "role": "user",
            "content": f"请分析这个文件：file://{file_id}"
        }
    ]
}

response = requests.post(
    url,
    headers={
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    },
    data=json.dumps(payload)
)

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

6.4 应用场景 ​

适合场景：

Kimi的适合场景包括长文档处理、知识库问答、文件分析、多轮对话、复杂推理等方面。

7. DeepSeek（深度求索） ​

7.1 模型概述 ​

基本信息：

DeepSeek的基本信息包括开发者（深度求索）、发布时间（2023年）、架构（Transformer + MoE）、参数量（67B（DeepSeek-V2））等方面。

核心特点：

DeepSeek的核心特点包括MoE架构、开源友好、强大的代码能力、高性价比等方面。

7.2 API调用 ​

调用示例：

python
import requests
import json

# 配置
url = "https://api.deepseek.com/chat/completions"
api_key = "your-api-key"

# 请求
payload = {
    "model": "deepseek-chat",
    "messages": [
        {
            "role": "user",
            "content": "请介绍一下DeepSeek大模型"
        }
    ],
    "temperature": 0.7,
    "max_tokens": 1000
}

# 发送请求
response = requests.post(
    url,
    headers={
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    },
    data=json.dumps(payload)
)

# 获取结果
result = response.json()
print(result["choices"][0]["message"]["content"])

7.3 本地部署 ​

使用Hugging Face：

python
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# 加载模型
model_name = "deepseek-ai/DeepSeek-V2.5"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto",
    torch_dtype=torch.float16
)

# 生成文本
prompt = "请介绍一下DeepSeek大模型"
inputs = tokenizer(prompt, return_tensors="pt")
inputs = inputs.to(model.device)

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=500,
        temperature=0.7,
        top_p=0.9
    )

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

7.4 应用场景 ​

适合场景：

DeepSeek的适合场景包括代码生成、数学推理、知识问答、本地部署、高性价比应用等方面。

8. Yi（零一万物） ​

8.1 模型概述 ​

基本信息：

Yi的基本信息包括开发者（零一万物）、发布时间（2023年）、架构（Transformer）、参数量（34B（Yi-34B））等方面。

核心特点：

Yi的核心特点包括多尺寸模型、开源友好、多语言支持、强大的中文能力等方面。

8.2 模型系列 ​

Yi系列：

Yi系列包括Yi-6B（小型）、Yi-9B（中型）、Yi-34B（大型）、Yi-VL（多模态版本）等版本。

8.3 本地部署 ​

使用Hugging Face：

python
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# 加载模型
model_name = "01-ai/Yi-34B-Chat"
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto",
    torch_dtype=torch.float16,
    trust_remote_code=True
)

# 生成文本
prompt = "请介绍一下Yi大模型"
inputs = tokenizer(prompt, return_tensors="pt")
inputs = inputs.to(model.device)

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=500,
        temperature=0.7,
        top_p=0.9
    )

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

8.4 应用场景 ​

适合场景：

Yi的适合场景包括文本生成、知识问答、多语言处理、本地部署、开源应用等方面。

实践任务 ​

任务：调用5个国内模型API对比 ​

目标：调用5个国内大模型API，对比输出结果

要求：

  1. 选择5个国内大模型
  2. 准备相同的输入
  3. 调用API获取输出
  4. 对比分析结果

代码框架：

python
import requests
import json

# 配置
models = {
    "文心一言": {
        "url": "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions",
        "api_key": "your-api-key",
        "model": "ERNIE-Bot-4"
    },
    "通义千问": {
        "url": "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation",
        "api_key": "your-api-key",
        "model": "qwen-max"
    },
    "GLM": {
        "url": "https://open.bigmodel.cn/api/paas/v4/chat/completions",
        "api_key": "your-api-key",
        "model": "glm-4"
    },
    "Kimi": {
        "url": "https://api.moonshot.cn/v1/chat/completions",
        "api_key": "your-api-key",
        "model": "moonshot-v1-128k"
    },
    "DeepSeek": {
        "url": "https://api.deepseek.com/chat/completions",
        "api_key": "your-api-key",
        "model": "deepseek-chat"
    }
}

# 准备输入
prompt = "请用Python写一个快速排序算法"

# 调用模型
results = {}
for model_name, config in models.items():
    try:
        payload = {
            "model": config["model"],
            "messages": [
                {"role": "user", "content": prompt}
            ],
            "temperature": 0.7,
            "max_tokens": 1000
        }
        
        response = requests.post(
            config["url"],
            headers={
                "Content-Type": "application/json",
                "Authorization": f"Bearer {config['api_key']}"
            },
            data=json.dumps(payload)
        )
        
        result = response.json()
        results[model_name] = result["choices"][0]["message"]["content"]
        
        print(f"{model_name}调用成功")
    except Exception as e:
        print(f"{model_name}调用失败: {e}")
        results[model_name] = None

# 对比结果
for model_name, result in results.items():
    print(f"\n{'='*50}")
    print(f"{model_name}:")
    print(f"{'='*50}")
    print(result)

课后作业 ​

作业1：国内大模型对比表 ​

题目：创建国内大模型对比表

要求：

  1. 对比文心一言、通义千问、混元、豆包、GLM、Kimi、DeepSeek、Yi
  2. 从架构、参数量、特点、API价格、应用场景等方面对比
  3. 生成对比报告

作业2：模型性能测试 ​

题目：测试国内大模型的性能

要求：

  1. 设计测试任务（代码生成、文本生成、知识问答等）
  2. 测试不同模型的表现
  3. 分析性能差异

作业3：成本分析 ​

题目：分析国内大模型的使用成本

要求：

  1. 调研各模型的API价格
  2. 计算不同使用场景的成本
  3. 提供成本优化建议

参考资料 ​

官方文档 ​

  1. 文心一言: https://cloud.baidu.com/doc/WENXINWORKSHOP/index.html
  2. 通义千问: https://help.aliyun.com/zh/dashscope/
  3. GLM: https://open.bigmodel.cn/dev/api
  4. Kimi: https://platform.moonshot.cn/docs
  5. DeepSeek: https://platform.deepseek.com/api-docs/

开源模型 ​

  1. Qwen: https://huggingface.co/Qwen
  2. GLM: https://huggingface.co/THUDM
  3. Yi: https://huggingface.co/01-ai
  4. DeepSeek: https://huggingface.co/deepseek-ai

在线资源 ​

  1. ModelScope: https://modelscope.cn/

    • 阿里模型库

  2. WiseModel: https://wisemodel.cn/

    • 智谱模型库

扩展阅读 ​

模型评估 ​

模型评估基准包括C-Eval（中文大模型评估基准）、CMMLU（中文多任务语言理解）、AGIEval（通用智能评估）等。

模型优化 ​

模型优化技术包括量化（减少模型大小）、蒸馏（知识迁移）、微调（适配特定任务）等方法。

下节预告 ​

下一节我们将学习国外大模型详解，深入了解GPT、Claude、Gemini、Llama等国外大模型的特点和应用。

架构师AI杜公众号二维码

扫描二维码关注"架构师AI杜"公众号，获取更多技术内容和最新动态