大语言模型（LLM）
6/10/25About 18 min
大语言模型（LLM）作为当前人工智能领域的热点，其入门知识涵盖了从基本概念到核心技术、应用方式等多个方面。以下是入门LLM必备的概念和知识点梳理：
一、基础概念
什么是语言模型 (Language Model, LM)？
- 定义： 一种机器学习模型，旨在预测并生成符合语法和语义规律的语言序列。简单来说，它能预测下一个词或下一个字符是什么。
- 发展： 从早期的N-gram模型、统计语言模型，到后来的循环神经网络（RNN）、长短期记忆网络（LSTM），再到现在的基于Transformer的深度学习模型。
- 简单示例： 以N-gram模型为例，它基于前N-1个词预测下一个词：
# 简单的二元语法(Bigram)模型示例 from collections import defaultdict import random class BigramModel: def __init__(self): self.bigrams = defaultdict(list) def train(self, text): words = text.split() for i in range(len(words)-1): self.bigrams[words[i]].append(words[i+1]) def generate(self, start_word, length=5): current = start_word result = [current] for _ in range(length): if current in self.bigrams: next_word = random.choice(self.bigrams[current]) result.append(next_word) current = next_word else: break return ' '.join(result) # 使用示例 model = BigramModel() model.train("我 喜欢 编程 我 想 学习 编程 语言") print(model.generate("我")) # 可能输出：我 喜欢 编程 我 想什么是大型语言模型 (Large Language Model, LLM)？
- "大"在哪里：
- 模型规模大： 拥有数亿到数万亿的参数（parameters），这些参数是模型在训练过程中学习到的数值，决定了模型如何处理和生成文本。
- 训练数据量大： 在海量的文本数据上进行预训练（pre-training），这些数据通常包含互联网上的各种文本，如书籍、文章、网页、代码等。
- 核心能力： 理解和生成人类语言，并具备一定的通用知识、逻辑推理能力和任务泛化能力。
- 常见模型规模对比：
模型名称 参数量 典型应用场景 GPT-3 175B 通用文本生成、对话 GPT-4 未公开(1T+估计) 更强的推理和创造能力 LLaMA 2-7B 7B 轻量级应用、设备端部署 Claude 2 未公开 专业写作、代码生成 Gemini Ultra 未公开 多模态理解与生成- "大"在哪里：
什么是Transformer架构？
- LLM的基石： 绝大多数现代LLM都基于Transformer架构。
- 核心机制：
- 自注意力机制 (Self-Attention Mechanism)： 这是Transformer最核心的创新。它允许模型在处理序列中的每个词时，能够"关注"到序列中的其他所有词，并根据它们之间的相关性来分配不同的"注意力权重"。这使得模型能够捕捉到长距离的依赖关系，解决传统RNN/LSTM中长文本处理的局限性。
- 编码器-解码器 (Encoder-Decoder) 结构： 原始Transformer包含编码器（处理输入序列）和解码器（生成输出序列）。许多LLM（如GPT系列）主要使用解码器部分进行文本生成。
- 简化的自注意力机制实现：
import numpy as np def simplified_self_attention(sequence, d_k=64): # sequence: [seq_len, d_model] seq_len = len(sequence) # 生成查询(Q)、键(K)、值(V)矩阵 Q = sequence # 简化版本直接使用输入 K = sequence V = sequence # 计算注意力分数 scores = np.dot(Q, K.T) / np.sqrt(d_k) # 应用softmax获得注意力权重 attention_weights = np.exp(scores) / np.sum(np.exp(scores), axis=1, keepdims=True) # 加权求和得到输出 output = np.dot(attention_weights, V) return output, attention_weightsToken (词元) 和 Tokenization (词元化)
- Token： LLM处理的最小文本单元。它可能是一个完整的单词、一个词的一部分、一个标点符号，甚至是中文字符或字词。模型不是直接处理字符或单词，而是将它们转换为Token。
- Tokenization： 将原始文本拆分成Token的过程。常见的Tokenization方法有BPE (Byte Pair Encoding)、WordPiece等。
- 上下文窗口 (Context Window/Context Length)： LLM能够处理的Token的最大数量。这个限制决定了模型在一次输入中可以"看到"多少信息。
- 使用tiktoken进行Token计数示例：
import tiktoken def count_tokens(text, model="gpt-3.5-turbo"): """计算文本中的token数量""" encoding = tiktoken.encoding_for_model(model) tokens = encoding.encode(text) return len(tokens) # 使用示例 text = "你好，世界！Hello, World!" token_count = count_tokens(text) print(f"文本包含 {token_count} 个token") # 输出token数量
二、LLM 的工作原理与阶段
预训练 (Pre-training)
- 目的： 让模型从大量无标签文本中学习通用的语言模式、语法、语义、事实知识。
- 方式： 通常采用无监督学习。最常见的目标是"下一个词预测"（Next Token Prediction），即根据前文预测下一个词是什么，或者"掩码语言模型"（Masked Language Model），即预测被遮盖的词。
- 结果： 得到一个"基础模型"（Base Model），它拥有强大的语言理解和生成能力，但可能还不擅长遵循特定指令。
- 简单的掩码语言模型示例：
import torch import torch.nn as nn class SimpleMaskedLM(nn.Module): def __init__(self, vocab_size, embed_size): super().__init__() self.embedding = nn.Embedding(vocab_size, embed_size) self.linear = nn.Linear(embed_size, vocab_size) def forward(self, x): # x: [batch_size, seq_len] embedded = self.embedding(x) # [batch_size, seq_len, embed_size] output = self.linear(embedded) # [batch_size, seq_len, vocab_size] return output # 使用示例 vocab_size = 10000 embed_size = 256 model = SimpleMaskedLM(vocab_size, embed_size) # 假设输入是一个批次的token序列 batch_size, seq_len = 32, 50 input_tokens = torch.randint(0, vocab_size, (batch_size, seq_len)) output = model(input_tokens)指令微调 (Instruction Fine-tuning / Supervised Fine-tuning, SFT)
- 目的： 让基础模型学会理解和遵循人类指令，并生成符合指令的回答。
- 方式： 在少量高质量的"指令-回答"对数据集上进行有监督学习。
- 结果： 得到一个"指令模型"（Instruct Model），它比基础模型更易用，能更好地响应用户提示。
- 指令数据集示例：
instruction_dataset = [ { "instruction": "将以下文本翻译成英文", "input": "我喜欢编程", "output": "I like programming" }, { "instruction": "总结以下文本的主要内容", "input": "人工智能是计算机科学的一个分支，致力于开发能够模拟人类智能的系统。", "output": "人工智能是模拟人类智能的计算机系统。" } ] # 使用transformers库进行微调的示例代码 from transformers import Trainer, TrainingArguments def prepare_dataset(examples): # 将指令、输入和输出组合成模型所需的格式 prompts = [ f"指令：{ex['instruction']}\n输入：{ex['input']}\n输出：" for ex in examples ] return { "input_ids": tokenizer(prompts, truncation=True, padding=True)["input_ids"], "labels": tokenizer([ex["output"] for ex in examples])["input_ids"] }人类反馈强化学习 (Reinforcement Learning from Human Feedback, RLHF)
- 目的： 进一步优化指令模型，使其回答更符合人类偏好、更安全、更无害。
- 方式：
- 奖励模型 (Reward Model)： 收集人类对模型生成回答的偏好排序数据，训练一个奖励模型来预测人类对不同回答的评分。
- 强化学习： 使用奖励模型作为奖励函数，通过强化学习（如PPO算法）微调指令模型，使其生成更高奖励的回答。
- 结果： 得到一个经过RLHF优化的模型，如ChatGPT、Gemini等。
- 简化的RLHF流程示例：
import torch.nn.functional as F class RewardModel(nn.Module): def __init__(self, base_model): super().__init__() self.base_model = base_model self.reward_head = nn.Linear(768, 1) # 假设基础模型输出维度为768 def forward(self, input_ids): # 获取基础模型的隐藏状态 hidden_states = self.base_model(input_ids).last_hidden_state # 计算奖励分数 reward = self.reward_head(hidden_states[:, -1, :]) # 使用最后一个token的表示 return reward def ppo_train_step(policy_model, reward_model, optimizer, input_ids, epsilon=0.2): # 生成初始回答 with torch.no_grad(): old_outputs = policy_model(input_ids) old_probs = F.softmax(old_outputs.logits, dim=-1) # 计算新策略 new_outputs = policy_model(input_ids) new_probs = F.softmax(new_outputs.logits, dim=-1) # 计算奖励 rewards = reward_model(input_ids) # 计算比率 ratio = new_probs / old_probs # PPO裁剪目标 surr1 = ratio * rewards surr2 = torch.clamp(ratio, 1 - epsilon, 1 + epsilon) * rewards policy_loss = -torch.min(surr1, surr2).mean() # 更新模型 optimizer.zero_grad() policy_loss.backward() optimizer.step() return policy_loss.item()
三、LLM 的关键应用与技巧
提示工程 (Prompt Engineering)
- 核心： 设计和优化输入给LLM的"提示词"（Prompt），以引导模型生成期望的输出。
- 重要性： 掌握有效的提示工程技巧是使用LLM的关键，能极大提升模型性能。
- 常见技巧：
- 清晰具体： 明确告诉模型做什么。
- 角色扮演： 让模型扮演特定角色（例如，"你是一个专业的程序员"）。
- Few-shot Learning (少量样本学习)： 在提示中提供几个示例，让模型模仿示例的风格或格式。
- Chain-of-Thought (CoT) / Reasoning (思维链/推理)： 引导模型逐步思考，展示其推理过程，有助于解决复杂问题。
- Self-Correction (自我纠正)： 让模型检查自己的输出并进行修正。
- 提示工程示例：
from openai import OpenAI client = OpenAI() def generate_with_prompt(prompt_template, **kwargs): """使用模板生成提示词""" prompt = prompt_template.format(**kwargs) response = client.chat.completions.create( model="gpt-3.5-turbo", messages=[{"role": "user", "content": prompt}] ) return response.choices[0].message.content # 1. 基础提示 basic_prompt = "将以下文本翻译成英文：{text}" # 2. Few-shot示例 few_shot_prompt = """ 示例1： 输入：这本书很有趣 输出：This book is very interesting 示例2： 输入：我明天要去北京 输出：I will go to Beijing tomorrow 现在请翻译： 输入：{text} 输出： """ # 3. Chain-of-Thought提示 cot_prompt = """ 让我们一步步解决这个数学问题： 问题：{problem} 思考步骤： 1) 首先，让我们理解问题中的已知条件 2) 然后，确定解决问题的方法 3) 接下来，按步骤计算 4) 最后，验证答案的合理性 请开始解答： """ # 4. 角色扮演提示 role_prompt = """ 你是一位经验丰富的Python开发者。请帮我优化以下代码，重点关注： 1) 代码性能 2) 可读性 3) Python最佳实践 代码： {code} 请提供优化建议和改进后的代码： """检索增强生成 (Retrieval Augmented Generation, RAG)
- 目的： 解决LLM知识时效性、专业领域知识不足以及"幻觉"（Hallucination）问题。
- 原理：
- 用户提出问题。
- 系统从外部知识库（如文档、数据库）中检索相关信息。
- 将检索到的信息作为"上下文"与用户问题一起输入给LLM。
- LLM基于这些上下文生成回答。
- 核心： 向量数据库 (Vector Database) 和嵌入 (Embeddings) 技术用于高效检索。
- RAG实现示例：
from sentence_transformers import SentenceTransformer from sklearn.metrics.pairwise import cosine_similarity import numpy as np class SimpleRAG: def __init__(self): # 初始化编码器模型 self.encoder = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2') self.knowledge_base = [] self.embeddings = [] def add_knowledge(self, documents): """添加文档到知识库""" self.knowledge_base.extend(documents) # 计算文档的嵌入向量 new_embeddings = self.encoder.encode(documents) if len(self.embeddings) == 0: self.embeddings = new_embeddings else: self.embeddings = np.vstack([self.embeddings, new_embeddings]) def retrieve(self, query, top_k=3): """检索相关文档""" # 计算查询的嵌入向量 query_embedding = self.encoder.encode([query])[0] # 计算相似度 similarities = cosine_similarity([query_embedding], self.embeddings)[0] # 获取最相关的文档 top_indices = np.argsort(similarities)[-top_k:][::-1] return [self.knowledge_base[i] for i in top_indices] def generate_answer(self, query): """生成回答""" # 检索相关文档 relevant_docs = self.retrieve(query) # 构建提示词 prompt = f""" 基于以下参考信息回答问题： 参考信息： {' '.join(relevant_docs)} 问题：{query} 请提供准确的回答： """ # 使用LLM生成回答 response = client.chat.completions.create( model="gpt-3.5-turbo", messages=[{"role": "user", "content": prompt}] ) return response.choices[0].message.content # 使用示例 rag = SimpleRAG() # 添加知识 documents = [ "Python是一种高级编程语言，以其简洁的语法和丰富的库而闻名。", "Python的创始人是Guido van Rossum，他于1991年发布了Python的第一个版本。", "Python广泛应用于Web开发、数据科学、人工智能等领域。" ] rag.add_knowledge(documents) # 回答问题 question = "Python的主要应用领域有哪些？" answer = rag.generate_answer(question) print(answer)工具使用 (Tool Usage / Function Calling)
- 目的： 拓展LLM的能力边界，让它能够与外部世界交互，执行特定操作。
- 原理： LLM不仅能生成文本，还能根据用户意图识别出需要调用的外部工具（API、函数、搜索引擎、计算器等），并生成调用这些工具所需的参数。
- Agent (智能体) 概念： 结合LLM、工具、记忆、规划等模块，形成能够自主感知、思考、行动的AI Agent。
- 函数调用示例：
import json from datetime import datetime import requests # 定义可用的工具函数 def get_weather(city: str) -> str: """获取指定城市的天气信息""" # 这里使用模拟数据，实际应用中应该调用天气API return f"{city}的天气晴朗，温度25℃" def calculate_age(birth_year: int) -> int: """计算年龄""" current_year = datetime.now().year return current_year - birth_year def search_web(query: str) -> str: """搜索网络信息""" # 这里使用模拟数据，实际应用中应该调用搜索API return f"关于'{query}'的搜索结果..." # 工具函数注册 AVAILABLE_TOOLS = { "get_weather": { "description": "获取指定城市的天气信息", "parameters": { "type": "object", "properties": { "city": {"type": "string", "description": "城市名称"} }, "required": ["city"] } }, "calculate_age": { "description": "根据出生年份计算年龄", "parameters": { "type": "object", "properties": { "birth_year": {"type": "integer", "description": "出生年份"} }, "required": ["birth_year"] } }, "search_web": { "description": "搜索网络信息", "parameters": { "type": "object", "properties": { "query": {"type": "string", "description": "搜索关键词"} }, "required": ["query"] } } } def process_with_tools(user_input: str): """处理用户输入，调用合适的工具""" # 调用LLM判断需要使用的工具 response = client.chat.completions.create( model="gpt-3.5-turbo", messages=[ {"role": "system", "content": "你是一个助手，可以使用以下工具：" + json.dumps(AVAILABLE_TOOLS, ensure_ascii=False)}, {"role": "user", "content": user_input} ], functions=list(AVAILABLE_TOOLS.items()), function_call="auto" ) # 解析LLM的响应 message = response.choices[0].message if message.function_call: # 获取要调用的函数和参数 func_name = message.function_call.name func_args = json.loads(message.function_call.arguments) # 调用相应的函数 if func_name == "get_weather": result = get_weather(**func_args) elif func_name == "calculate_age": result = calculate_age(**func_args) elif func_name == "search_web": result = search_web(**func_args) return result else: return message.content # 使用示例 queries = [ "北京今天天气怎么样？", "2000年出生的人今年多大了？", "请帮我搜索关于Python的信息" ] for query in queries: result = process_with_tools(query) print(f"问题：{query}") print(f"回答：{result}\n")
四、LLM 的局限性与挑战
幻觉 (Hallucination)： LLM可能生成听起来合理但实际上是错误或虚构的信息。
- 示例：
# 幻觉检测示例 def detect_hallucination(question: str, answer: str, knowledge_base: list) -> bool: """ 简单的幻觉检测：检查答案是否有知识库支持 """ # 将答案分成句子 sentences = answer.split('。') # 检查每个句子是否能在知识库中找到相关支持 for sentence in sentences: if sentence.strip(): found_support = False for knowledge in knowledge_base: # 使用简单的文本匹配（实际应用中应该使用更复杂的语义匹配） if any(key in knowledge for key in sentence.split()): found_support = True break if not found_support: return True # 可能存在幻觉 return False # 答案有知识库支持 # 使用示例 knowledge_base = [ "OpenAI成立于2015年。", "GPT-3于2020年发布。", "Transformer架构由Google在2017年提出。" ] question = "OpenAI是什么时候成立的？" answer1 = "OpenAI成立于2015年，是一家人工智能研究公司。" answer2 = "OpenAI成立于2010年，由马斯克创立。" # 包含错误信息 print(f"答案1可能存在幻觉：{detect_hallucination(question, answer1, knowledge_base)}") print(f"答案2可能存在幻觉：{detect_hallucination(question, answer2, knowledge_base)}")知识截止日期 (Knowledge Cutoff)： LLM的知识基于其训练数据的截止日期，无法获取最新信息（RAG可缓解）。
- 解决方案示例：
from datetime import datetime import requests class DynamicKnowledgeBase: def __init__(self): self.static_knowledge = {} # 模型的基础知识 self.dynamic_knowledge = {} # 实时获取的知识 def get_current_info(self, topic: str) -> str: """获取实时信息（示例实现）""" # 这里应该实现实际的API调用 current_time = datetime.now().strftime("%Y-%m-%d") return f"关于{topic}的最新信息（更新时间：{current_time}）" def answer_question(self, question: str) -> str: """回答问题，结合静态和动态知识""" # 判断是否需要实时信息 current_year = datetime.now().year if str(current_year) in question or "最新" in question or "现在" in question: # 获取实时信息 topic = question.replace("最新", "").replace("现在", "") current_info = self.get_current_info(topic) # 构建提示词 prompt = f""" 问题：{question} 最新信息：{current_info} 请基于最新信息回答问题。 """ # 调用LLM（示例） return f"基于最新数据的回答：{prompt}" else: # 使用模型的基础知识回答 return "基于模型训练数据的回答" # 使用示例 kb = DynamicKnowledgeBase() print(kb.answer_question("2024年的AI发展趋势是什么？"))计算资源消耗： 训练和运行LLM需要庞大的计算资源。
- 优化示例：
import torch from transformers import AutoModelForCausalLM, AutoTokenizer def optimize_model_inference(model_name: str, device: str = 'cuda'): """模型推理优化示例""" # 1. 模型量化 model = AutoModelForCausalLM.from_pretrained( model_name, device_map="auto", torch_dtype=torch.float16 # 使用FP16量化 ) # 2. 批处理优化 def batch_generate(prompts: list, batch_size: int = 4): """批量生成回答""" results = [] for i in range(0, len(prompts), batch_size): batch = prompts[i:i + batch_size] inputs = tokenizer(batch, return_tensors="pt", padding=True) # 使用torch.cuda.amp进行自动混合精度 with torch.cuda.amp.autocast(): outputs = model.generate(**inputs) results.extend(tokenizer.batch_decode(outputs)) return results # 3. 模型裁剪（示例） def prune_model(model, pruning_ratio=0.3): """移除不重要的权重""" for name, module in model.named_modules(): if isinstance(module, torch.nn.Linear): # 获取权重的绝对值 weights = module.weight.data.abs() # 计算阈值 threshold = torch.quantile(weights, pruning_ratio) # 将小于阈值的权重置为0 mask = weights > threshold module.weight.data *= mask return model # 4. 模型蒸馏示例框架 class DistillationTrainer: def __init__(self, teacher_model, student_model): self.teacher = teacher_model self.student = student_model def distill(self, input_ids, temperature=2.0): # 教师模型输出 with torch.no_grad(): teacher_logits = self.teacher(input_ids).logits / temperature # 学生模型输出 student_logits = self.student(input_ids).logits / temperature # 计算蒸馏损失（KL散度） loss = torch.nn.functional.kl_div( torch.nn.functional.log_softmax(student_logits, dim=-1), torch.nn.functional.softmax(teacher_logits, dim=-1), reduction='batchmean' ) return loss偏见 (Bias)： 训练数据中存在的偏见可能被LLM学习并放大，导致不公平或歧视性的输出。
可解释性 (Interpretability)： LLM是一个"黑盒"，其决策过程难以完全理解。
安全与伦理： 如何防止LLM被滥用，以及如何确保其符合伦理规范。
- 安全检查示例：
class SafetyChecker: def __init__(self): # 敏感词库（示例） self.sensitive_words = { "个人信息": ["身份证", "银行卡", "密码"], "有害内容": ["暴力", "歧视", "违法"], "安全风险": ["漏洞", "攻击", "注入"] } def check_content(self, text: str) -> dict: """检查内容安全性""" results = {category: [] for category in self.sensitive_words} # 检查每个类别的敏感词 for category, words in self.sensitive_words.items(): for word in words: if word in text: results[category].append(word) return results def is_safe(self, text: str) -> bool: """判断内容是否安全""" results = self.check_content(text) return all(len(matches) == 0 for matches in results.values()) def filter_sensitive(self, text: str) -> str: """过滤敏感内容""" filtered_text = text for category, words in self.sensitive_words.items(): for word in words: filtered_text = filtered_text.replace(word, "*" * len(word)) return filtered_text # 使用示例 checker = SafetyChecker() text = "这是一个包含银行卡信息的文本，可能存在安全漏洞。" print(f"安全检查结果：{checker.check_content(text)}") print(f"是否安全：{checker.is_safe(text)}") print(f"过滤后的文本：{checker.filter_sensitive(text)}")
五、其他重要概念
参数量 (Parameters)： 衡量LLM大小的重要指标。
- 参数统计示例：
def count_parameters(model: torch.nn.Module) -> dict: """统计模型参数量""" total_params = 0 trainable_params = 0 non_trainable_params = 0 # 遍历所有参数 for param in model.parameters(): num_params = param.numel() total_params += num_params if param.requires_grad: trainable_params += num_params else: non_trainable_params += num_params return { "总参数量": total_params, "可训练参数量": trainable_params, "固定参数量": non_trainable_params, "参数量（GB）": total_params * 4 / (1024**3) # 假设FP32 }模型蒸馏 (Knowledge Distillation)： 训练一个更小的模型（学生模型）来模仿大型模型（教师模型）的行为，以降低部署成本和推理延迟。
- 蒸馏过程示例：
import torch.nn as nn class SimpleDistillation: def __init__(self, teacher_model, student_model, temperature=2.0): self.teacher = teacher_model self.student = student_model self.temperature = temperature def distillation_loss(self, student_logits, teacher_logits, labels=None, alpha=0.5): """计算蒸馏损失""" # 软目标损失 soft_loss = nn.KLDivLoss(reduction='batchmean')( nn.functional.log_softmax(student_logits / self.temperature, dim=-1), nn.functional.softmax(teacher_logits / self.temperature, dim=-1) ) * (self.temperature ** 2) if labels is not None: # 硬目标损失 hard_loss = nn.CrossEntropyLoss()(student_logits, labels) # 综合损失 return alpha * hard_loss + (1 - alpha) * soft_loss return soft_loss def train_step(self, inputs, optimizer, labels=None): """训练步骤""" # 教师模型推理 with torch.no_grad(): teacher_outputs = self.teacher(**inputs) # 学生模型训练 student_outputs = self.student(**inputs) # 计算损失 loss = self.distillation_loss( student_outputs.logits, teacher_outputs.logits, labels ) # 反向传播 optimizer.zero_grad() loss.backward() optimizer.step() return loss.item()量化 (Quantization)： 降低模型权重精度，以减少模型大小和内存占用，加速推理。
- 量化示例：
def quantize_model(model, quantization_type="dynamic"): """模型量化示例""" if quantization_type == "dynamic": # 动态量化 quantized_model = torch.quantization.quantize_dynamic( model, {torch.nn.Linear}, # 量化线性层 dtype=torch.qint8 ) elif quantization_type == "static": # 静态量化 model.qconfig = torch.quantization.get_default_qconfig('fbgemm') torch.quantization.prepare(model, inplace=True) # 此处应该进行校准 torch.quantization.convert(model, inplace=True) return model def compare_model_sizes(original_model, quantized_model): """比较原始模型和量化后模型的大小""" def get_size_mb(model): torch.save(model.state_dict(), "temp.pt") size_mb = os.path.getsize("temp.pt") / (1024 * 1024) os.remove("temp.pt") return size_mb original_size = get_size_mb(original_model) quantized_size = get_size_mb(quantized_model) print(f"原始模型大小: {original_size:.2f} MB") print(f"量化后模型大小: {quantized_size:.2f} MB") print(f"压缩比: {original_size/quantized_size:.2f}x")Base Model vs. Instruct Model：
- Base Model： 仅经过预训练，擅长补全文本，但可能不擅长遵循指令。
- Instruct Model： 在Base Model基础上经过指令微调和RLHF，更擅长理解和执行指令。
- 模型对比示例：
def compare_models(base_model, instruct_model, prompts: list): """比较基础模型和指令模型的输出差异""" results = [] for prompt in prompts: # 基础模型输出 base_output = base_model.generate(prompt) # 指令模型输出 instruct_output = instruct_model.generate( f"请执行以下指令：{prompt}" ) results.append({ "提示词": prompt, "基础模型输出": base_output, "指令模型输出": instruct_output }) return results # 使用示例 test_prompts = [ "解释什么是机器学习", "写一个Python函数计算斐波那契数列", "总结这段文字的主要内容" ] # 比较输出 for result in compare_models(base_model, instruct_model, test_prompts): print(f"\n提示词：{result['提示词']}") print(f"基础模型：{result['基础模型输出']}") print(f"指令模型：{result['指令模型输出']}")
入门LLM，建议从理解Transformer架构和提示工程开始，结合实际操作（例如使用OpenAI API或Google AI Studio）来加深理解。同时，关注RAG和Agent等应用范式，因为它们是当前LLM应用落地的主要方向。
六、实践资源
开源模型：
- LLaMA 2
- Mistral
- ChatGLM
- Baichuan
开发框架：
- Hugging Face Transformers
- LangChain
- LlamaIndex
- FastChat
部署工具：
- ONNX Runtime
- TensorRT
- vLLM
- Text Generation Inference
学习资源：
- Hugging Face课程
- FastAI课程
- DeepLearning.AI课程
- Stanford CS324 LLM课程
通过这些资源，你可以逐步深入了解LLM的原理和应用，并开始构建自己的AI应用。记住，LLM技术发展迅速，保持学习和实践的习惯很重要。