大模型案例实战 – 模块一操作说明书
模块一：大模型基础
理论通俗讲解
大模型，顾名思义，就是参数量巨大、结构复杂的深度学习模型。它们通常在海量数据上进行训练，能够学习到非常复杂的模式和知识，从而在各种任务中表现出卓越的性能。例如，在自然语言处理（NLP）领域，大模型可以理解、生成和翻译人类语言；在计算机视觉（CV）领域，它们可以识别图像中的物体、理解场景内容。
为什么大模型如此强大？
数据量大： 大模型通常在互联网规模的数据上进行训练，这使得它们能够接触到各种各样的信息，从而学习到更通用、更鲁ocious的特征表示。参数量大： 更多的参数意味着模型拥有更强的学习能力和表达能力，可以捕捉到数据中更细微、更复杂的关联。计算资源： 训练和运行大模型需要强大的计算资源（如GPU集群），这使得它们能够处理大规模的计算任务。
大模型的组成：
一个大模型通常由两部分组成：
参数文件 (Weights/Parameters): 这部分是模型在训练过程中学习到的“知识”，它们以数值矩阵的形式存储。例如，神经网络中的权重和偏置就是参数文件的一部分。这些参数决定了模型如何处理输入数据并生成输出。参数文件通常非常大，是模型的核心。运行时文件 (Runtime Files/Configuration): 这部分包含了模型的结构信息、配置参数、词汇表（对于自然语言处理模型）以及其他运行模型所需的元数据。例如，模型的层数、隐藏层大小、激活函数类型、以及分词器如何将文本转换为模型可以理解的数字表示等信息都属于运行时文件。这些文件相对较小，但对于正确加载和运行模型至关重要。
理解这两部分对于操作和部署大模型至关重要。参数文件是模型“学到了什么”，而运行时文件则告诉我们“如何使用这个模型”。
大模型分词器
在自然语言处理领域，大模型处理的不是原始文本，而是将文本转换为模型可以理解的数字表示。这个转换过程就是由分词器 (Tokenizer) 完成的。
分词器的作用：
分词器将原始文本分解成更小的单元，这些单元被称为“token”。这些token可以是单词、子词（例如“##ing”）、甚至单个字符。然后，分词器会将这些token映射到唯一的数字ID，形成模型可以处理的输入序列。
为什么需要分词器？
统一输入格式： 不同的文本有不同的长度和结构，分词器将其转换为统一的数字序列，方便模型处理。处理生词： 通过子词分词（如WordPiece、BPE），分词器可以将不常见的词分解成已知的子词，从而有效处理生词问题。减少词汇量： 相比于直接使用单词作为token，子词分词可以大大减少词汇表的大小，降低模型的复杂性。
分词器的主要功能：
文本拆分 (Tokenization): 将原始文本拆分成token。转换为ID (Token to ID): 将每个token映射到其对应的数字ID。添加特殊token： 在输入序列的开头和结尾添加特殊token（如
[CLS]
[SEP]
大模型推理
大模型推理 (Inference) 是指使用已经训练好的大模型来对新的输入数据进行预测或生成输出的过程。这与模型训练（学习过程）相对。
推理的流程：
输入准备： 将原始输入数据（如文本、图像）通过分词器（对于文本）或预处理步骤转换为模型可以理解的数字格式。模型加载： 将训练好的模型参数和运行时文件加载到内存中。前向传播： 将准备好的输入数据送入模型，模型会根据其学习到的参数进行计算，并生成输出。输出解析： 将模型的原始输出（通常是数字）转换回人类可读的格式（如文本、标签）。
Hugging Face
pipeline
Hugging Face Transformers 库提供了一个非常方便的
pipeline
pipeline
文本分类 (Sentiment Analysis): 判断文本的情感倾向（积极、消极等）。文本生成 (Text Generation): 根据给定的起始文本生成连贯的后续文本。问答 (Question Answering): 根据给定的上下文和问题，从上下文中提取答案。翻译 (Translation): 将文本从一种语言翻译成另一种语言。摘要 (Summarization): 从长文本中提取关键信息生成简短摘要。
pipeline
实际操作步骤与代码实操案例
案例 1: 认识大模型
操作步骤:
确保您的 Python 环境已安装
transformers
pip install transformers
创建一个 Python 文件，例如
module1_case1.py
module1_case1.py
python module1_case1.py
代码实操案例 (module1_case1.py):
from transformers import AutoModel
# 1. 认识大模型：了解参数文件和运行时文件组成，通过加载开源模型观察二者区别。
# 这里我们以一个小型模型为例，实际大模型文件会非常大
model_name = "bert-base-uncased"
print(f"
--- 案例 1: 认识大模型 ---")
print(f"尝试加载模型: {model_name}")
try:
# AutoModel 会自动下载模型的配置文件和参数文件
model = AutoModel.from_pretrained(model_name)
print(f"模型 {model_name} 加载成功！")
print(f"模型类型: {type(model)}")
print(f"模型配置: {model.config}
")
# 参数文件通常是模型权重，运行时文件包括配置、词汇表等
# 我们可以通过查看模型对象的属性来了解其组成
print("模型参数示例 (部分):")
for name, param in model.named_parameters():
print(f" {name}: {param.shape}")
if "embeddings" in name and "weight" in name:
print(f" (这通常是模型学习到的词嵌入参数，属于参数文件的一部分)")
if "encoder.layer.0.attention.self.query.weight" in name:
print(f" (这是Transformer层中的一个权重参数，属于参数文件的一部分)")
if "pooler.dense.weight" in name:
print(f" (这是池化层的权重参数，属于参数文件的一部分)")
if "bias" in name:
print(f" (这是偏置参数，属于参数文件的一部分)")
if "LayerNorm.weight" in name:
print(f" (这是层归一化参数，属于参数文件的一部分)")
if "LayerNorm.bias" in name:
print(f" (这是层归一化偏置参数，属于参数文件的一部分)")
if "encoder.layer.0.attention.output.dense.weight" in name:
print(f" (这是Transformer层中的输出权重参数，属于参数文件的一部分)")
if "encoder.layer.0.output.dense.weight" in name:
print(f" (这是Transformer层中的前馈网络输出权重参数，属于参数文件的一部分)")
if "encoder.layer.0.output.LayerNorm.weight" in name:
print(f" (这是Transformer层中的层归一化权重参数，属于参数文件的一部分)")
if "encoder.layer.0.output.LayerNorm.bias" in name:
print(f" (这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)")
if "pooler.dense.bias" in name:
print(f" (这是池化层的偏置参数，属于参数文件的一部分)")
if "embeddings.position_embeddings.weight" in name:
print(f" (这是模型学习到的位置嵌入参数，属于参数文件的一部分)")
if "embeddings.token_type_embeddings.weight" in name:
print(f" (这是模型学习到的token类型嵌入参数，属于参数文件的一部分)")
if "embeddings.LayerNorm.weight" in name:
print(f" (这是嵌入层中的层归一化权重参数，属于参数文件的一部分)")
if "embeddings.LayerNorm.bias" in name:
print(f" (这是嵌入层中的层归一化偏置参数，属于参数文件的一部分)")
if "encoder.layer.0.attention.self.key.weight" in name:
print(f" (这是Transformer层中的key权重参数，属于参数文件的一部分)")
if "encoder.layer.0.attention.self.value.weight" in name:
print(f" (这是Transformer层中的value权重参数，属于参数文件的一部分)")
if "encoder.layer.0.attention.output.LayerNorm.weight" in name:
print(f" (这是Transformer层中的层归一化权重参数，属于参数文件的一部分)")
if "encoder.layer.0.attention.output.LayerNorm.bias" in name:
print(f" (这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)")
if "encoder.layer.0.intermediate.dense.weight" in name:
print(f" (这是Transformer层中的中间层权重参数，属于参数文件的一部分)")
if "encoder.layer.0.intermediate.dense.bias" in name:
print(f" (这是Transformer层中的中间层偏置参数，属于参数文件的一部分)")
if "encoder.layer.0.output.dense.bias" in name:
print(f" (这是Transformer层中的输出偏置参数，属于参数文件的一部分)")
print("
模型配置 (Config) 示例 (属于运行时文件的一部分):")
print(f" 词汇表大小 (vocab_size): {model.config.vocab_size}")
print(f" 隐藏层大小 (hidden_size): {model.config.hidden_size}")
print(f" 注意力头数量 (num_attention_heads): {model.config.num_attention_heads}")
print(f" 层数 (num_hidden_layers): {model.config.num_hidden_layers}")
except Exception as e:
print(f"加载模型时发生错误: {e}")
print("请检查模型名称是否正确，或网络连接是否正常。")
运行结果:
--- 案例 1: 认识大模型 ---
尝试加载模型: bert-base-uncased
模型 bert-base-uncased 加载成功！
模型类型: <class 'transformers.models.bert.modeling_bert.BertModel'>
模型配置: BertConfig {
"_name_or_path": "bert-base-uncased",
"architectures": [
"BertForMaskedLM"
],
"attention_probs_dropout_prob": 0.1,
"classifier_dropout": null,
"hidden_act": "gelu",
"hidden_dropout_prob": 0.1,
"hidden_size": 768,
"initializer_range": 0.02,
"intermediate_size": 3072,
"layer_norm_eps": 1e-12,
"max_position_embeddings": 512,
"model_type": "bert",
"num_attention_heads": 12,
"num_hidden_layers": 12,
"pad_token_id": 0,
"position_embedding_type": "absolute",
"transformers_version": "4.33.3",
"type_vocab_size": 2,
"use_cache": true,
"vocab_size": 30522
}
模型参数示例 (部分):
embeddings.word_embeddings.weight: torch.Size([30522, 768])
(这通常是模型学习到的词嵌入参数，属于参数文件的一部分)
embeddings.position_embeddings.weight: torch.Size([512, 768])
(这是模型学习到的位置嵌入参数，属于参数文件的一部分)
embeddings.token_type_embeddings.weight: torch.Size([2, 768])
(这是模型学习到的token类型嵌入参数，属于参数文件的一部分)
embeddings.LayerNorm.weight: torch.Size([768])
(这是嵌入层中的层归一化权重参数，属于参数文件的一部分)
embeddings.LayerNorm.bias: torch.Size([768])
(这是嵌入层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.0.attention.self.query.weight: torch.Size([768, 768])
(这是Transformer层中的一个权重参数，属于参数文件的一部分)
encoder.layer.0.attention.self.query.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.0.attention.self.key.weight: torch.Size([768, 768])
(这是Transformer层中的key权重参数，属于参数文件的一部分)
encoder.layer.0.attention.self.key.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.0.attention.self.value.weight: torch.Size([768, 768])
(这是Transformer层中的value权重参数，属于参数文件的一部分)
encoder.layer.0.attention.self.value.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.0.attention.output.dense.weight: torch.Size([768, 768])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.0.attention.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.0.attention.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.0.attention.output.LayerNorm.bias: torch.Size([768])
(这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.0.intermediate.dense.weight: torch.Size([3072, 768])
(这是Transformer层中的中间层权重参数，属于参数文件的一部分)
encoder.layer.0.intermediate.dense.bias: torch.Size([3072])
(这是Transformer层中的中间层偏置参数，属于参数文件的一部分)
encoder.layer.0.output.dense.weight: torch.Size([768, 3072])
(这是Transformer层中的前馈网络输出权重参数，属于参数文件的一部分)
encoder.layer.0.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.0.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.0.output.LayerNorm.bias: torch.Size([768])
(这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.1.attention.self.query.weight: torch.Size([768, 768])
(这是Transformer层中的query权重参数，属于参数文件的一部分)
encoder.layer.1.attention.self.query.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.1.attention.self.key.weight: torch.Size([768, 768])
(这是Transformer层中的key权重参数，属于参数文件的一部分)
encoder.layer.1.attention.self.key.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.1.attention.self.value.weight: torch.Size([768, 768])
(这是Transformer层中的value权重参数，属于参数文件的一部分)
encoder.layer.1.attention.self.value.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.1.attention.output.dense.weight: torch.Size([768, 768])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.1.attention.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.1.attention.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.1.attention.output.LayerNorm.bias: torch.Size([768])
(这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.1.intermediate.dense.weight: torch.Size([3072, 768])
(这是Transformer层中的中间层权重参数，属于参数文件的一部分)
encoder.layer.1.intermediate.dense.bias: torch.Size([3072])
(这是Transformer层中的中间层偏置参数，属于参数文件的一部分)
encoder.layer.1.output.dense.weight: torch.Size([768, 3072])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.1.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.1.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.1.output.LayerNorm.bias: torch.Size([768])
(这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.2.attention.self.query.weight: torch.Size([768, 768])
(这是Transformer层中的query权重参数，属于参数文件的一部分)
encoder.layer.2.attention.self.query.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.2.attention.self.key.weight: torch.Size([768, 768])
(这是Transformer层中的key权重参数，属于参数文件的一部分)
encoder.layer.2.attention.self.key.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.2.attention.self.value.weight: torch.Size([768, 768])
(这是Transformer层中的value权重参数，属于参数文件的一部分)
encoder.layer.2.attention.self.value.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.2.attention.output.dense.weight: torch.Size([768, 768])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.2.attention.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.2.attention.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.2.attention.output.LayerNorm.bias: torch.Size([768])
(这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.2.intermediate.dense.weight: torch.Size([3072, 768])
(这是Transformer层中的中间层权重参数，属于参数文件的一部分)
encoder.layer.2.intermediate.dense.bias: torch.Size([3072])
(这是Transformer层中的中间层偏置参数，属于参数文件的一部分)
encoder.layer.2.output.dense.weight: torch.Size([768, 3072])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.2.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.2.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.2.output.LayerNorm.bias: torch.Size([768])
(这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.3.attention.self.query.weight: torch.Size([768, 768])
(这是Transformer层中的query权重参数，属于参数文件的一部分)
encoder.layer.3.attention.self.query.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.3.attention.self.key.weight: torch.Size([768, 768])
(这是Transformer层中的key权重参数，属于参数文件的一部分)
encoder.layer.3.attention.self.key.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.3.attention.self.value.weight: torch.Size([768, 768])
(这是Transformer层中的value权重参数，属于参数文件的一部分)
encoder.layer.3.attention.self.value.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.3.attention.output.dense.weight: torch.Size([768, 768])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.3.attention.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.3.attention.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.3.attention.output.LayerNorm.bias: torch.Size([768])
(这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.3.intermediate.dense.weight: torch.Size([3072, 768])
(这是Transformer层中的中间层权重参数，属于参数文件的一部分)
encoder.layer.3.intermediate.dense.bias: torch.Size([3072])
(这是Transformer层中的中间层偏置参数，属于参数文件的一部分)
encoder.layer.3.output.dense.weight: torch.Size([768, 3072])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.3.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.3.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.3.output.LayerNorm.bias: torch.Size([768])
(这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.4.attention.self.query.weight: torch.Size([768, 768])
(这是Transformer层中的query权重参数，属于参数文件的一部分)
encoder.layer.4.attention.self.query.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.4.attention.self.key.weight: torch.Size([768, 768])
(这是Transformer层中的key权重参数，属于参数文件的一部分)
encoder.layer.4.attention.self.key.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.4.attention.self.value.weight: torch.Size([768, 768])
(这是Transformer层中的value权重参数，属于参数文件的一部分)
encoder.layer.4.attention.self.value.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.4.attention.output.dense.weight: torch.Size([768, 768])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.4.attention.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.4.attention.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.4.attention.output.LayerNorm.bias: torch.Size([768])
(这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.4.intermediate.dense.weight: torch.Size([3072, 768])
(这是Transformer层中的中间层权重参数，属于参数文件的一部分)
encoder.layer.4.intermediate.dense.bias: torch.Size([3072])
(这是Transformer层中的中间层偏置参数，属于参数文件的一部分)
encoder.layer.4.output.dense.weight: torch.Size([768, 3072])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.4.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.4.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.4.output.LayerNorm.bias: torch.Size([768])
(这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.5.attention.self.query.weight: torch.Size([768, 768])
(这是Transformer层中的query权重参数，属于参数文件的一部分)
encoder.layer.5.attention.self.query.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.5.attention.self.key.weight: torch.Size([768, 768])
(这是Transformer层中的key权重参数，属于参数文件的一部分)
encoder.layer.5.attention.self.key.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.5.attention.self.value.weight: torch.Size([768, 768])
(这是Transformer层中的value权重参数，属于参数文件的一部分)
encoder.layer.5.attention.self.value.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.5.attention.output.dense.weight: torch.Size([768, 768])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.5.attention.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.5.attention.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.5.attention.output.LayerNorm.bias: torch.Size([768])
(这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.5.intermediate.dense.weight: torch.Size([3072, 768])
(这是Transformer层中的中间层权重参数，属于参数文件的一部分)
encoder.layer.5.intermediate.dense.bias: torch.Size([3072])
(这是Transformer层中的中间层偏置参数，属于参数文件的一部分)
encoder.layer.5.output.dense.weight: torch.Size([768, 3072])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.5.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.5.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.5.output.LayerNorm.bias: torch.Size([768])
(这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.6.attention.self.query.weight: torch.Size([768, 768])
(这是Transformer层中的query权重参数，属于参数文件的一部分)
encoder.layer.6.attention.self.query.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.6.attention.self.key.weight: torch.Size([768, 768])
(这是Transformer层中的key权重参数，属于参数文件的一部分)
encoder.layer.6.attention.self.key.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.6.attention.self.value.weight: torch.Size([768, 768])
(这是Transformer层中的value权重参数，属于参数文件的一部分)
encoder.layer.6.attention.self.value.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.6.attention.output.dense.weight: torch.Size([768, 768])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.6.attention.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.6.attention.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.6.attention.output.LayerNorm.bias: torch.Size([768])
(这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.6.intermediate.dense.weight: torch.Size([3072, 768])
(这是Transformer层中的中间层权重参数，属于参数文件的一部分)
encoder.layer.6.intermediate.dense.bias: torch.Size([3072])
(这是Transformer层中的中间层偏置参数，属于参数文件的一部分)
encoder.layer.6.output.dense.weight: torch.Size([768, 3072])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.6.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.6.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.6.output.LayerNorm.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
(这是层归一化偏置参数，属于参数文件的一部分)
encoder.layer.7.attention.self.query.weight: torch.Size([768, 768])
(这是Transformer层中的query权重参数，属于参数文件的一部分)
encoder.layer.7.attention.self.query.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.7.attention.self.key.weight: torch.Size([768, 768])
(这是Transformer层中的key权重参数，属于参数文件的一部分)
encoder.layer.7.attention.self.key.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.7.attention.self.value.weight: torch.Size([768, 768])
(这是Transformer层中的value权重参数，属于参数文件的一部分)
encoder.layer.7.attention.self.value.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.7.attention.output.dense.weight: torch.Size([768, 768])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.7.attention.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.7.attention.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.7.attention.output.LayerNorm.bias: torch.Size([768])
(这是Transformer层中的层归一化偏置参数，属于参数文件的一部分)
encoder.layer.7.intermediate.dense.weight: torch.Size([3072, 768])
(这是Transformer层中的中间层权重参数，属于参数文件的一部分)
encoder.layer.7.intermediate.dense.bias: torch.Size([3072])
(这是Transformer层中的中间层偏置参数，属于参数文件的一部分)
encoder.layer.7.output.dense.weight: torch.Size([768, 3072])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.7.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.7.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.7.output.LayerNorm.bias: torch.Size([768])
(这是偏式参数，属于参数文件的一部分)
(这是层归一化偏置参数，属于参数文件的一部分)
encoder.layer.8.attention.self.query.weight: torch.Size([768, 768])
(这是Transformer层中的query权重参数，属于参数文件的一部分)
encoder.layer.8.attention.self.query.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.8.attention.self.key.weight: torch.Size([768, 768])
(这是Transformer层中的key权重参数，属于参数文件的一部分)
encoder.layer.8.attention.self.key.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.8.attention.self.value.weight: torch.Size([768, 768])
(这是Transformer层中的value权重参数，属于参数文件的一部分)
encoder.layer.8.attention.self.value.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.8.attention.output.dense.weight: torch.Size([768, 768])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.8.attention.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.8.attention.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.8.attention.output.LayerNorm.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
(这是层归一化偏置参数，属于参数文件的一部分)
encoder.layer.8.intermediate.dense.weight: torch.Size([3072, 768])
(这是Transformer层中的中间层权重参数，属于参数文件的一部分)
encoder.layer.8.intermediate.dense.bias: torch.Size([3072])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.8.output.dense.weight: torch.Size([768, 3072])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.8.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.8.output.LayerNorm.weight: torch.Size([768])
(这是层归一化参数，属于参数文件的一部分)
encoder.layer.8.output.LayerNorm.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
(这是层归一化偏置参数，属于参数文件的一部分)
encoder.layer.9.attention.self.query.weight: torch.Size([768, 768])
(这是Transformer层中的query权重参数，属于参数文件的一部分)
encoder.layer.9.attention.self.query.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.9.attention.self.key.weight: torch.Size([768, 768])
(这是Transformer层中的key权重参数，属于参数文件的一部分)
encoder.layer.9.attention.self.key.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.9.attention.self.value.weight: torch.Size([768, 768])
(这是Transformer层中的value权重参数，属于参数文件的一部分)
encoder.layer.9.attention.self.value.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.9.attention.output.dense.weight: torch.Size([768, 768])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.9.attention.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.9.attention.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.9.attention.output.LayerNorm.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
(这是层归一化偏置参数，属于参数文件的一部分)
encoder.layer.9.intermediate.dense.weight: torch.Size([3072, 768])
(这是Transformer层中的中间层权重参数，属于参数文件的一部分)
encoder.layer.9.intermediate.dense.bias: torch.Size([3072])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.9.output.dense.weight: torch.Size([768, 3072])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.9.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.9.output.LayerNorm.weight: torch.Size([768])
(这是层归一化参数，属于参数文件的一部分)
encoder.layer.9.output.LayerNorm.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
(这是层归一化偏置参数，属于参数文件的一部分)
encoder.layer.10.attention.self.query.weight: torch.Size([768, 768])
(这是Transformer层中的query权重参数，属于参数文件的一部分)
encoder.layer.10.attention.self.query.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.10.attention.self.key.weight: torch.Size([768, 768])
(这是Transformer层中的key权重参数，属于参数文件的一部分)
encoder.layer.10.attention.self.key.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.10.attention.self.value.weight: torch.Size([768, 768])
(这是Transformer层中的value权重参数，属于参数文件的一部分)
encoder.layer.10.attention.self.value.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.10.attention.output.dense.weight: torch.Size([768, 768])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.10.attention.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.10.attention.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.10.attention.output.LayerNorm.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
(这是层归一化偏置参数，属于参数文件的一部分)
encoder.layer.10.intermediate.dense.weight: torch.Size([3072, 768])
(这是Transformer层中的中间层权重参数，属于参数文件的一部分)
encoder.layer.10.intermediate.dense.bias: torch.Size([3072])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.10.output.dense.weight: torch.Size([768, 3072])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.10.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.10.output.LayerNorm.weight: torch.Size([768])
(这是层归一化参数，属于参数文件的一部分)
encoder.layer.10.output.LayerNorm.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
(这是层归一化偏置参数，属于参数文件的一部分)
encoder.layer.11.attention.self.query.weight: torch.Size([768, 768])
(这是Transformer层中的query权重参数，属于参数文件的一部分)
encoder.layer.11.attention.self.query.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.11.attention.self.key.weight: torch.Size([768, 768])
(这是Transformer层中的key权重参数，属于参数文件的一部分)
encoder.layer.11.attention.self.key.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.11.attention.self.value.weight: torch.Size([768, 768])
(这是Transformer层中的value权重参数，属于参数文件的一部分)
encoder.layer.11.attention.self.value.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.11.attention.output.dense.weight: torch.Size([768, 768])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.11.attention.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.11.attention.output.LayerNorm.weight: torch.Size([768])
(这是Transformer层中的层归一化权重参数，属于参数文件的一部分)
encoder.layer.11.attention.output.LayerNorm.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
(这是层归一化偏置参数，属于参数文件的一部分)
encoder.layer.11.intermediate.dense.weight: torch.Size([3072, 768])
(这是Transformer层中的中间层权重参数，属于参数文件的一部分)
encoder.layer.11.intermediate.dense.bias: torch.Size([3072])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.11.output.dense.weight: torch.Size([768, 3072])
(这是Transformer层中的输出权重参数，属于参数文件的一部分)
encoder.layer.11.output.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
encoder.layer.11.output.LayerNorm.weight: torch.Size([768])
(这是层归一化参数，属于参数文件的一部分)
encoder.layer.11.output.LayerNorm.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
(这是层归一化偏置参数，属于参数文件的一部分)
pooler.dense.weight: torch.Size([768, 768])
(这是池化层的权重参数，属于参数文件的一部分)
pooler.dense.bias: torch.Size([768])
(这是偏置参数，属于参数文件的一部分)
(这是池化层的偏置参数，属于参数文件的一部分)
模型配置 (Config) 示例 (属于运行时文件的一部分):
词汇表大小 (vocab_size): 30522
隐藏层大小 (hidden_size): 768
注意力头数量 (num_attention_heads): 12
层数 (num_hidden_layers): 12
案例 2: 大模型分词器
操作步骤:
创建一个 Python 文件，例如
module1_case2.py
module1_case2.py
python module1_case2.py
代码实操案例 (module1_case2.py):
from transformers import AutoTokenizer
# 2. 大模型分词器：了解分词器的作用，通过加载分词器并对文本进行分词，观察分词结果。
model_name = "bert-base-uncased"
text = "Hello, world! This is a test sentence for the tokenizer."
print(f"
--- 2: 大模型分词器 ---")
print(f"尝试加载分词器: {model_name}")
try:
tokenizer = AutoTokenizer.from_pretrained(model_name)
print(f"分词器 {model_name} 加载成功！")
print(f"原始文本: {text}")
# 对文本进行分词
tokens = tokenizer.tokenize(text)
print(f"分词结果 (tokens): {tokens}")
# 将分词结果转换为ID
input_ids = tokenizer.convert_tokens_to_ids(tokens)
print(f"分词结果 (input_ids): {input_ids}")
# 将ID解码回文本
decoded_text = tokenizer.decode(input_ids)
print(f"解码回文本: {decoded_text}")
# 直接编码文本（包含分词、转换为ID、添加特殊token等步骤）
encoded_input = tokenizer(text, return_tensors="pt")
print(f"直接编码结果 (input_ids): {encoded_input.input_ids}")
print(f"直接编码结果 (attention_mask): {encoded_input.attention_mask}")
except Exception as e:
print(f"分词器操作时发生错误: {e}")
print("请检查模型名称是否正确，或网络连接是否正常。")
运行结果:
--- 案例 2: 大模型分词器 ---
尝试加载分词器: bert-base-uncased
tokenizer_config.json: 100%|██████████████████| 48.0/48.0 [00:00<00:00, 302kB/s]
vocab.txt: 100%|█████████████████████████████| 232k/232k [00:00<00:00, 43.0MB/s]
tokenizer.json: 100%|████████████████████████| 466k/466k [00:00<00:00, 34.2MB/s]
分词器 bert-base-uncased 加载成功！
原始文本: Hello, world! This is a test sentence for the tokenizer.
分词结果 (tokens): ['hello', ',', 'world', '!', 'this', 'is', 'a', 'test', 'sentence', 'for', 'the', 'token', '##izer', '.']
分词结果 (input_ids): [7592, 1010, 2088, 999, 2023, 2003, 1037, 3231, 6251, 2005, 1996, 19204, 17629, 1012]
解码回文本: hello, world! this is a test sentence for the tokenizer.
直接编码结果 (input_ids): tensor([[ 101, 7592, 1010, 2088, 999, 2023, 2003, 1037, 3231, 6251,
2005, 1996, 19204, 17629, 1012, 102]])
直接编码结果 (attention_mask): tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])
案例 3: 大模型推理
操作步骤:
创建一个 Python 文件，例如
module1_case3.py
module1_case3.py
python module1_case3.py
代码实操案例 (module1_case3.py):
from transformers import pipeline
# 3. 大模型推理：通过Hugging Face的pipeline功能，快速体验大模型的推理能力。
print(f"
--- 案例 3: 大模型推理 ---")
try:
# 文本分类任务
classifier = pipeline("sentiment-analysis")
text_to_classify = "I love using Hugging Face Transformers!"
classification_result = classifier(text_to_classify)
print(f"
文本分类结果 ("{text_to_classify}"): {classification_result}")
# 文本生成任务
text_generator = pipeline("text-generation", model="gpt2")
text_to_generate = "Once upon a time, in a land far, far away,"
generated_text = text_generator(text_to_generate, max_length=50, num_return_sequences=1)
print(f"
文本生成结果 ("{text_to_generate}"): {generated_text[0]['generated_text']}")
# 问答任务
question_answerer = pipeline("question-answering")
context = "Hugging Face is a company that builds tools for machine learning. Their Transformers library is very popular."
question = "What does Hugging Face do?"
qa_result = question_answerer(question=question, context=context)
print(f"
问答结果 (问题: "{question}", 上下文: "{context}"): {qa_result}")
except Exception as e:
print(f"大模型推理时发生错误: {e}")
print("请检查模型名称是否正确，或网络连接是否正常。")
运行结果:
--- 案例 3: 大模型推理 ---
No model was supplied, defaulted to distilbert/distilbert-base-uncased-finetuned-sst-2-english and revision 714eb0f (https://huggingface.co/distilbert/distilbert-base-uncased-finetuned-sst-2-english).
Using a pipeline without specifying a model name and revision in production is not recommended.
config.json: 100%|█████████████████████████████| 629/629 [00:00<00:00, 4.26MB/s]
model.safetensors: 100%|██████████████████████| 268M/268M [00:01<00:00, 145MB/s]
tokenizer_config.json: 100%|██████████████████| 48.0/48.0 [00:00<00:00, 327kB/s]
vocab.txt: 232kB [00:00, 69.9MB/s]
Device set to use cpu
文本分类结果 ("I love using Hugging Face Transformers!"): [{'label': 'POSITIVE', 'score': 0.9971315860748291}]
config.json: 100%|█████████████████████████████| 665/665 [00:00<00:00, 4.07MB/s]
model.safetensors: 100%|██████████████████████| 548M/548M [00:02<00:00, 189MB/s]
generation_config.json: 100%|███████████████████| 124/124 [00:00<00:00, 985kB/s]
tokenizer_config.json: 100%|██████████████████| 26.0/26.0 [00:00<00:00, 222kB/s]
vocab.json: 100%|██████████████████████████| 1.04M/1.04M [00:00<00:00, 28.9MB/s]
merges.txt: 100%|████████████████████████████| 456k/456k [00:00<00:00, 33.1MB/s]
tokenizer.json: 100%|██████████████████████| 1.36M/1.36M [00:00<00:00, 36.2MB/s]
Device set to use cpu
Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.
Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.
Both `max_new_tokens` (=256) and `max_length`(=50) seem to have been set. `max_new_tokens` will take precedence. Please refer to the documentation for more information. (https://huggingface.co/docs/transformers/main/en/main_classes/text_generation)
文本生成结果 ("Once upon a time, in a land far, far away,"): Once upon a time, in a land far, far away, the gods would show her the way.
"I am about to die," she said, her voice weak and low. Her voice sounded so low, so heavy, so heavy. There was no respite. An hour passed, and the sound of a car was made. It stopped and turned its head slowly, and looked back again.
"We have the answer," she said.
He hesitated.
"You will not allow us to die in this way," she said.
He shook his head. "I could not, I thought, save you from death. I know that you\'t allow death to kill me, but I have decided to give you this life, and I have no choice. I will save you."
"What?"
"I will take you to another place that will not allow death to kill you."
"What do you mean?"
"I will take you to the place that we know will not allow death to kill me."
He nodded, and the car left.
He was never far from the city anymore. The city was always bustling and bustling, even in the absence of the gods. They drove, and the city would fill with them
No model was supplied, defaulted to distilbert/distilbert-base-cased-distilled-squad and revision 564e9b5 (https://huggingface.co/distilbert/distilbert-base-cased-distilled-squad).
Using a pipeline without specifying a model name and revision in production is not recommended.
config.json: 100%|█████████████████████████████| 473/473 [00:00<00:00, 4.79MB/s]
model.safetensors: 100%|██████████████████████| 261M/261M [00:02<00:00, 116MB/s]
tokenizer_config.json: 100%|██████████████████| 49.0/49.0 [00:00<00:00, 514kB/s]
vocab.txt: 213kB [00:00, 32.0MB/s]
tokenizer.json: 436kB [00:00, 54.0MB/s]
Fetching 0 files: 0it [00:00, ?it/s]
Fetching 1 files: 100%|████████████████████████| 1/1 [00:00<00:00, 18315.74it/s]
Fetching 0 files: 0it [00:00, ?it/s]
Device set to use cpu
问答结果 (问题: "What does Hugging Face do?", 上下文: "Hugging Face is a company that builds tools for machine learning. Their Transformers library is very popular."): {'score': 0.8136367797851562, 'start': 31, 'end': 64, 'answer': 'builds tools for machine learning'}
总结
通过本模块的学习和实践，我们对大模型的基础概念、分词器的工作原理以及如何利用Hugging Face
pipeline
希望这份操作说明书能帮助您更好地理解和实践大模型的基础知识。
© 版权声明
文章版权归作者所有，未经允许请勿转载。
相关文章
暂无评论...
