Deep-Learning on NEVERMORE

Transformers

Sat, 26 Oct 2024 15:34:07 +0800

基础部件

基本流程：

tokenizer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


from transformers import AutoTokenizer

# 加载
tokenizer = Autotokenizer.from_pretrained("uer/roberta-base-finetuned-dianping-chinese",trust_remote_code=True)# 从hf加载
tokenizer.save_pretrained("./my_tokenizer")# 保存到本地
tokenizer = AutoTokenizer.from_pretrained("./my_tokenizer")# 从本地加载

# 分词
tokens = tokenizer.tokenize("你好，欢迎使用！")

tokenizer.vocab# 查看词表
tokernizer.vocab_size# 查看词表大小

ids0 = tokenizer.convert_tokens_to_ids(tokens)# 转换成id
# 可通过tokenizer.convert_ids_to_tokens(ids)转换回来，convert_tokens_to_string(tokens)转换回句子

ids1 = tokenizer.encode("你好，欢迎使用！",add_special_tokens=False)# 一步到位
str1 = tokenizer.decode(ids1)# 解码

# 填充和截断，以适应batch长度
input_ids = tokenizer.encode("你好，欢迎使用！",max_length=10,padding="max_length",truncation=True)

model

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


from transformers import AutoModel

# 加载
model = AutoModel.from_pretrained("uer/roberta-base-finetuned-dianping-chinese",trust_remote_code=True)# 从hf加载
model = AutoModel.from_pretrained("./model_name",output_attentions=True)# 从本地加载

# 输出
inputs = tokenizer("你好，欢迎使用！",return_tensors="pt")
outputs = model(**inputs)
outputs.last_hidden_state()# 输出最后一层隐藏层

# 指定model head
from transformers import AutoModelForSequenceClassification
cls_model = AutoModelForSequenceClassification.from_pretrained("uer/roberta-base-finetuned-dianping-chinese",num_labels=3,output_attentions=True)# 指定三分类
# 对基本模型的输出进行任务处理
output_cls = cls_model(**inputs)

dataset

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# 加载数据集
dataset = load_dataset("dataset_name","subtask_name", split="train[10:100]")# (数据集名,[可选]子任务名(有的话),[可选]切片)
# 查看
dataset["train"][:2]
# 划分
dataset.train_test_split(test_size=0.2,stratify_by_column="label")# 按比例划分,label分布均衡
# 数据选取与过滤
datasets["train"].select([1, 5])# 选取第2和第6条数据,返回的类型仍是dataset
filter_dataset = datasets["train"].filter(lambda example: "中国" in example["title"])
# 数据映射
processed_datasets = datasets.map(preprocess_function,batched=True,remove_columns=["text"])# 映射函数,<可选>使用batch处理,去除text列
# 本地保存与加载
processed_datasets.save_to_disk("./processed_data")
processed_datasets = load_from_disk("./processed_data")

实例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88


import torch
from torch.utils.data import Dataset,DataLoader

class MyDataset(Dataset):
 def __init__(self):
 super().__init__()
 self.data = pd.read_csv("./ChnSentiCorp_htl_all.csv")
 self.data = self.data.dropna()

 def __getitem__(self, index):
 return self.data.iloc[index]["review"], self.data.iloc[index]["label"]

 def __len__(self):
 return len(self.data)

# 加载数据集
dataset = MyDataset()

# 划分数据集
from torch.utils.data import random_split
trainset, validset = random_split(dataset, lengths=[0.9, 0.1])

# 定义dataloader
tokenizer = AutoTokenizer.from_pretrained("hfl/rbt3")
def collate_func(batch):
 texts, labels = [], []
 for item in batch:
 texts.append(item[0])
 labels.append(item[1])
 inputs = tokenizer(texts, max_length=128, padding="max_length", truncation=True, return_tensors="pt")
 inputs["labels"] = torch.tensor(labels)
 return inputs

from torch.utils.data import DataLoader
trainloader = DataLoader(trainset, batch_size=32, shuffle=True, collate_fn=collate_func)# shuffle=True表示每个epoch打乱顺序
validloader = DataLoader(validset, batch_size=64, shuffle=False, collate_fn=collate_func)

# optimizer
from torch.optim import Adam

model = AutoModelForSequenceClassification.from_pretrained("hfl/rbt3")
if torch.cuda.is_available():
 model = model.cuda()

optimizer = Adam(model.parameters(), lr=2e-5)

# 训练/评估
def evaluate():
 model.eval()
 acc_num = 0
 with torch.inference_mode():
 for batch in validloader:
 if torch.cuda.is_available():
 batch = {k: v.cuda() for k, v in batch.items()}
 output = model(**batch)
 pred = torch.argmax(output.logits, dim=-1)
 acc_num += (pred.long() == batch["labels"].long()).float().sum()
 return acc_num / len(validset)

def train(epoch=3, log_step=100):
 global_step = 0
 for ep in range(epoch):
 model.train()
 for batch in trainloader:# 训练集
 if torch.cuda.is_available():
 batch = {k: v.cuda() for k, v in batch.items()}
 # 把batch的key和value都转到cuda上
 optimizer.zero_grad()# 清空梯度
 output = model(**batch)
 output.loss.backward()# 反向传播
 optimizer.step()
 if global_step % log_step == 0:
 print(f"ep: {ep}, global_step: {global_step}, loss: {output.loss.item()}")
 global_step += 1
 acc = evaluate()
 print(f"ep: {ep}, acc: {acc}")

train()

sen = "我觉得这家酒店不错，饭很好吃！"
id2_label = {0: "差评！", 1: "好评！"}
model.eval()
with torch.inference_mode():
 inputs = tokenizer(sen, return_tensors="pt")
 inputs = {k: v.cuda() for k, v in inputs.items()}
 logits = model(**inputs).logits
 pred = torch.argmax(logits, dim=-1)
 print(f"输入：{sen}\n模型预测结果:{id2_label.get(pred.item())}")

使用trainer优化实例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
from datasets import load_dataset
import torch
# 加载/划分数据集
dataset = load_dataset("csv", data_files="./ChnSentiCorp_htl_all.csv", split="train")
dataset = dataset.filter(lambda x: x["review"] is not None)
datasets = dataset.train_test_split(test_size=0.1)

# 处理数据集
tokenizer = AutoTokenizer.from_pretrained("hfl/rbt3")

def process_function(examples):
 tokenized_examples = tokenizer(examples["review"], max_length=128, truncation=True)
 tokenized_examples["labels"] = examples["label"]
 return tokenized_examples

tokenized_datasets = datasets.map(process_function, batched=True, remove_columns=datasets["train"].column_names)

# 模型\评估
model = AutoModelForSequenceClassification.from_pretrained("hfl/rbt3")

import evaluate

acc_metric = evaluate.load("accuracy")
f1_metric = evaluate.load("f1")

def eval_metric(eval_predict):
 predictions, labels = eval_predict
 predictions = predictions.argmax(axis=-1)
 acc = acc_metric.compute(predictions=predictions, references=labels)
 f1 = f1_metric.compute(predictions=predictions, references=labels)
 acc.update(f1)
 return acc

# 创建training_arguments
train_args = TrainingArguments(output_dir="./checkpoints", # 输出文件夹
 per_device_train_batch_size=64, # 训练时的batch_size
 per_device_eval_batch_size=128, # 验证时的batch_size
 logging_steps=10, # log 打印的频率
 evaluation_strategy="epoch", # 评估策略
 save_strategy="epoch", # 保存策略
 save_total_limit=3, # 最大保存数
 learning_rate=2e-5, # 学习率
 weight_decay=0.01, # weight_decay
 metric_for_best_model="f1", # 设定评估指标
 load_best_model_at_end=True) # 训练完成后加载最优模型

# 创建trainer
from transformers import DataCollatorWithPadding
trainer = Trainer(model=model,
 args=train_args,
 train_dataset=tokenized_datasets["train"],
 eval_dataset=tokenized_datasets["test"],
 data_collator=DataCollatorWithPadding(tokenizer=tokenizer),
 compute_metrics=eval_metric)

# 训练/评估
trainer.train()
trainer.evaluate(tokenized_datasets["test"])
trainer.predict(tokenized_datasets["test"])

NLP任务实操

命名实体识别(NER)

NER是指识别文本中的实体，如人名、地名、机构名等。
通常，NER任务包括两部分:

实体识别: 识别出文本中的实体，并给予其相应的标签。
实体分类: 将识别出的实体进行分类，如人名、地名、机构名等。

PEFT微调

在创建模型后设置tuning_config,随后model = get_peft_model(model, config)

常见高效微调方法综述见arXiv:2303.15647

Prompt tuning

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


from peft import PromptTuningConfig, get_peft_model, TaskType, PromptTuningInit
# Hard Prompt
config = PromptTuningConfig(task_type=TaskType.CAUSAL_LM,
 prompt_tuning_init=PromptTuningInit.TEXT,
 prompt_tuning_init_text="下面是一段人与机器人的对话。",
 num_virtual_tokens=len(tokenizer("下面是一段人与机器人的对话。")["input_ids"]),
 tokenizer_name_or_path="Langboat/bloom-1b4-zh")
model = get_peft_model(model, config)

# 进行训练...

# 加载训练完的模型
from peft import PeftModel
model = AutoModelForCausalLM.from_pretrained("Langboat/bloom-1b4-zh")# 原模型
peft_model = PeftModel.from_pretrained(model=model, model_id="./output/checkpoint-500/")

P-tuning/Prefix tuning

P-tuning把prompt加在输入embedding层的前缀，而Prefix tuning将kv值作为前缀加在模型的每一层前，而不仅仅是输入层。

原理(类似kv缓存的思想): 因为对于扩展后的KV矩阵，Qm*n,K(m+x)*n,V(m+x)*n而言,Q·KT得m*(m+k)维矩阵，再乘V得m*n维矩阵，和原矩阵相乘维度一样。

1
2
3
4


from peft import PrefixTuningConfig, get_peft_model, TaskType
config = PrefixTuningConfig(task_type=TaskType.CAUSAL_LM, num_virtual_tokens=10, prefix_projection=True)
# prefix_projection默认值为false，表示使用P-Tuning v2， 如果为true，则表示使用 Prefix Tuning
# 其余流程一致

Lora

通过矩阵分解的方式，将原始权重分解为低秩矩阵，计算时仅优化低秩矩阵，最后把低秩矩阵相乘加到原始权重上作为微调结果。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


from peft import LoraConfig, TaskType, get_peft_model

# 查看target_modules参数要分解的权重层,该参数课传入列表如:
# ["word_embeddings", "encoder.layer.0.attention.self.query", "encoder.layer.0.attention.self.key", "encoder.layer.0.attention.self.value"]
# 也可以传入正则表达式如下
for name, parameter in model.named_parameters():
 print(name)

config = LoraConfig(task_type=TaskType.CAUSAL_LM, target_modules=".*\.1.*query_key_value", modules_to_save=["word_embeddings"])# modules_to_save表示其它要参与训练的权重层

model = get_peft_model(model, config)

# 进行训练...

# 加载训练完的模型
from peft import PeftModel
model = AutoModelForCausalLM.from_pretrained("Langboat/bloom-1b4-zh")
tokenizer = AutoTokenizer.from_pretrained("Langboat/bloom-1b4-zh")

peft_model = PeftModel.from_pretrained(model=model, model_id="./output/checkpoint-500/")
# 合并模型
# peft_model和merge_model的权重相同，p的预训练模型和LoRA微调权重是分开的,LoRA权重在推理时动态加载;而m是成为一个新的完全体模型
merge_model = peft_model.merge_and_unload()
merge_model.save_pretrained("./output/merge_model")# 保存模型

IA3

1
2
3


# 仅记录调用方法
from peft import IA3Config, TaskType, get_peft_model
config = IA3Config(task_type=TaskType.CAUSAL_LM)

使用不同适配器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


import torch
from torch import nn
from peft import LoraConfig, get_peft_model, PeftModel

net1 = nn.Sequential(
 nn.Linear(10, 10),
 nn.ReLU(),
 nn.Linear(10, 2)
)
# 对层0进行Lora微调
config1 = LoraConfig(target_modules=["0"])
model1 = get_peft_model(net1, config1)
model1.save_pretrained("./loraA")
print(model1)
# 对层2进行Lora微调
config2 = LoraConfig(target_modules=["2"])
model2 = get_peft_model(net1, config2)
model2.save_pretrained("./loraB")
print(model2)
# 此时model2会显示层0,层2都被lora,因为net1会记录被A调整的部分
# 但是!!!经验证,实际上loraB只记录了层2的权重调整,因为model2的输入是net1+loraA,输出是net1+loraA+loraB,所以loraB只记录了层2的权重

net1 = nn.Sequential(
 nn.Linear(10, 10),
 nn.ReLU(),
 nn.Linear(10, 2)
)# 上面的net1被使用后调整了,重新定义原网络

# 使用原网络和保存的loraA参数得到PeftModel
model3 = PeftModel.from_pretrained(net1, model_id="./loraA/", adapter_name="loraA")# 此时的模型是net1+loraA(层0的适配器参数)
model3.active_adapter# 显示当前激活的适配器A

# 改用loraB参数
model3.load_adapter("./loraB/", adapter_name="loraB")# 加载loraB,实际模型结构是net1+loraA+loraB,激活的结构是net1+loraA(还没切换)
model3.set_adapter("loraB")# 切换到loraB,loraA被禁用,模型激活结构变为net1+loraB
model3.active_adapter# 显示当前激活的适配器B

with model3.disable_adapter():
 <code># 需要使用with语句关闭适配器

低精度训练

默认单精度fp32,每个参数占4Byte.半精度即fp16(更推荐bf16),每个参数占2Byte.

半精度训练实例

1
2
3
4
5
6


model = AutoModelForCausalLM.from_pretrained("<model name>", low_cpu_mem_usage=True,
 torch_dtype=torch.bfloat16, device_map="auto")# 半精度训练
# 建议加载时用

model = model.half()
# 在fine tuning后把调整的参数也转成半精度

量化

显存占用变少,但是训练推理速度变慢.

INT8 量化即将浮点数$x_f$通过缩放因子scale映射到范围在[-128, 127] 内,用8bit表示即 [x_q = Clip(Round(x_f*scale))] 其中scale=127/浮点数绝对值最大值;Round是四舍五入;
数据中离群值(与其它数值相差很大)的存在会导致丢失很多信息,使用Clip将离群值限制在[-128, 127]范围内.

反量化的过程为: [x_f = x_q/scale]

因此可以采取混合精度量化:
将包含了Emergent Features的几个维度从矩阵中分离出来，对其做高精度的矩阵乘法；其余数值接近的部分进行量化

8bit,4bit量化与QLoRA模型训练

1
2
3
4
5


model = AutoModelForCausalLM.from_pretrained("D:/Pretrained_models/modelscope/Llama-2-7b-ms", low_cpu_mem_usage=True,
 torch_dtype=torch.bfloat16, device_map="auto", load_in_8bit=True)
model = AutoModelForCausalLM.from_pretrained("D:/Pretrained_models/modelscope/Llama-2-13b-ms", low_cpu_mem_usage=True,
 torch_dtype=torch.bfloat16, device_map="auto", load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16,
 bnb_4bit_quant_type="nf4", bnb_4bit_use_double_quant=True)# 启用nf4量化,启用双重量化

分布式训练

各类并行

data parallel: 每个GPU加载完整的模型,训练的数据不同
pipeline parallel: 每个GPU加载模型不同的层
tensor parallel: 把同一层的各部分参数拆分到各个GPU上

3D并行: 图中:2(数据并行)*4(流水并行|横向箭头,代表不同层)*4(张量并行|竖向箭头,同层的不同参数)=32GPUs
解释:模型32层,每8层分成一个流水并行块;每个流水并行块分成4个张量并行块,每个张量并行块有4个GPU,共16个GPU;再乘以2行数据并行=32GPUs

Distributed DataParallel

1
2
3
4


# 指定使用GPU 0, 1和2（不设置device_ids或令其=None，则默认使用所有GPU）
model = nn.DataParallel(model, device_ids=[0, 1, 2])

# 在训练时，需要对loss进行mean()，因为loss需要是标量才可以进行反向传播

Accelerater

Machine Learning

Mon, 21 Oct 2024 15:34:07 +0800

基础概念

张量（Tensor）

张量（tensor）是指具有多个维度的数组，它可以用来表示向量、矩阵、高阶数组等多种数据结构。张量的元素可以是标量、向量、矩阵、张量等。

损失函数

损失函数（loss function）是指用来衡量模型预测值与真实值之间的差距，并反映模型的预测精度的函数。损失函数的选择对模型的训练、优化和泛化能力都有着至关重要的影响。常见的损失函数有：

残差平方和(residual sum of squares, RSS)

公式：$L(y, \hat{y}) = \sum_{i=1}^n (y_i - \hat{y}_i)^2$

梯度下降法

梯度下降法（gradient descent）是一种优化算法，它通过迭代的方式不断更新模型的参数，使得损失函数的值逐渐减小。梯度下降法的基本思想是：沿着损失函数的负梯度方向更新参数，使得损失函数的值减小。

例:softmax计算梯度:

反向传播

反向传播（backpropagation）是指通过计算梯度来更新模型参数的算法。反向传播算法的基本思想是：从输出层开始，沿着损失函数的梯度方向更新参数，直到更新到网络的输入层。

神经网络

CNN

网络结构: 卷积核 -> 激活函数 -> 池化层 -> 全连接层 -> 激活函数 -> 输出层使用卷积核提取图像特征，通过激活函数对特征进行非线性变换，通过池化层对特征进行降维，再通过全连接层进行分类。

RNN

在激活函数的输出重新连接到网络的输入，使得网络能够记住之前的输入，并对当前输入做出更好的预测。但是，这条路径的权重会导致梯度消失(w<1)和梯度爆炸(w>1)的问题。由此提出了LSTM

LSTM

遗忘门、输入门、输出门：

GAN

Transformer

Embedding

词嵌入（embedding）是指将词语转换为固定维度的向量表示的过程。词嵌入可以提高文本分类、文本匹配、文本聚类等任务的性能。常见的词嵌入方法有词向量、词袋模型、GloVe、BERT等。

位置编码:给每个输入值生成特定的位置值序列,保证语序

Self Attention

自注意力机制（self-attention）是指模型通过注意力机制来获取输入序列的全局信息。这有助于为每个输入提供上下文信息，并建立输入间的联系。
自注意力机制使每个token计算与其它token间的相似度(Query Key)，从而得知如it指代的是哪个词之类的信息。
注意,每个token的Q\K\V权重系数都是相同的。

将自注意力模块的输出通过softmax函数,得到每个token的权重,再将权重与value序列相乘,得到最终的嵌入向量。

Encoder-decoder Attention

Pytorch

Mon, 21 Oct 2024 15:34:07 +0800

常用概念

设备相关

1
2
3
4
5


device = torch.device("cuda" if torch.cuda.is_available() else "cpu")# 创建设备
a = torch.ones(2,3)
b = a.clone()
c = a.detach()# 只想使用当前的值,为常数,避免导致原张量梯度更新
d = a.to(device)# "cuda" / "cpu"

流程简述

具体网络详解见第三部分

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


# 1.网络定义
import torch.nn as nn
import torch.optim as optim
# 定义一个简单的全连接神经网络
class SimpleNN(nn.Module):
 def __init__(self):
 super(SimpleNN, self).__init__()
 self.fc1 = nn.Linear(2, 2) # 输入层到隐藏层
 self.fc2 = nn.Linear(2, 1) # 隐藏层到输出层

 def forward(self, x):
 x = torch.relu(self.fc1(x)) # ReLU 激活函数
 x = self.fc2(x)
 return x

# 2.创建网络实例
model = SimpleNN()

# 3. 定义损失函数和优化器
criterion = nn.MSELoss() # 均方误差损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001) # Adam 优化器

# 4. 假设有训练数据 X 和 Y
X = torch.randn(10, 2) # 10 个样本，2 个特征
Y = torch.randn(10, 1) # 10 个目标值

# 5. 训练循环
for epoch in range(100): # 训练 100 轮
 optimizer.zero_grad() # 清空之前的梯度
 output = model(X) # 前向传播
 # output可通过激活函数完成对应任务
 # import torch.nn.functional as F 
 # # ReLU 激活
 # output = F.relu(input_tensor)
 # # Sigmoid 激活
 # output = torch.sigmoid(input_tensor)
 # # Tanh 激活
 # output = torch.tanh(input_tensor)
 loss = criterion(output, Y) # 计算损失
 loss.backward() # 反向传播
 optimizer.step() # 更新参数

 # 每 10 轮输出一次损失
 if (epoch+1) % 10 == 0:
 print(f'Epoch [{epoch+1}/100], Loss: {loss.item():.4f}')

# 6.评估
model.eval() # 设置模型为评估模式
with torch.no_grad(): # 在评估过程中禁用梯度计算
 output = model(X_test)
 loss = criterion(output, Y_test)
 print(f'Test Loss: {loss.item():.4f}')

张量操作

张量基本操作

基本属性

张量tensor：
属性：维度，形状，数据类型
0维即单个数字，一维即一维数组
形状指每个维度的大小，如(3,4)表示三行四列

另还有维度数.dim(),启用梯度计算.requires_grad,获取元素总数.numel()等

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


import torch
# 1. 创建张量
x = torch.tensor([[1, 2, 3],[4,5,6]])
x0 = torch.zeros(2, 3)
x1 = torch.ones(2, 3)
xr = torch.randn(2, 3)# rand随机，randn服从正态分布
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
xd = torch.rand(2, 3, device = device)
X = torch.arange(12, dtype=torch.float32).reshape(3,4)# 指定个数\类型\形状
tensor_3d = torch.stack([xd,xd+3,xd+5])# 3维张量即三个二维的堆叠，用stack
# 2. 改变形状
xrs = x.reshape(3, 2)
print(y)
# 3. 查看属性
print(x.shape)
print(x.numel())# number of elements元素总数
X.sum()# 所有元素的和,产生单元素张量
# 4. 索引
X[1:3] # 索引从0开始,区间左闭右开,1:3即1、2,对应第二到第三行
X[:, 1] # 第二列
X[1:3, 1:3] # 第二到第三行,第二到第三列
X == Y # 元素比较,生成布尔张量
X[X>0] # 元素过滤
# 5. 张量连结
X = torch.cat([X, Y], dim=0) # 按行连接
X = torch.cat([X, Y], dim=1) # 按列连接
# 6. 广播机制
# 由于`a`和`b`分别是3*1矩阵和1*2矩阵，如果让它们相加，它们的形状不匹配。
# 将两个矩阵*广播*为一个更大的3*2矩阵，矩阵`a`将复制列，矩阵`b`将复制行，然后再按元素相加
a = torch.tensor([[1], [2], [3]])
b = torch.tensor([4, 5])
print(a + b)# 输出 tensor([[5, 6],[6, 7],[7, 8]])

张量操作

torch.matmul(x, y) 矩阵乘法
torch.dot(x, y) 向量点积（仅适用于 1D 张量）
torch.sum(x) 求和
torch.mean(x) 求均值
torch.max(x) 求最大值
torch.min(x) 求最小值
torch.argmax(x, dim) 返回最大值的索引（指定维度）
torch.softmax(x, dim) 计算softmax（指定维度）

形状操作

x.view(shape) 改变张量的形状（不改变数据）
x.reshape(shape) 类似于 view，但更灵活
x.t() 转置矩阵
x.unsqueeze(dim) 在指定维度添加一个维度，如x从[N]变成[N,1]
x.squeeze(dim) 去掉指定维度为 1 的维度
torch.cat((x, y), dim) 按指定维度连接多个张量

线性代数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


# 1. 矩阵乘法
A = torch.tensor([[1, 2], [3, 4]])
B = torch.tensor([[5, 6], [7, 8]])
C = torch.mm(A, B) # 矩阵乘法
# 2. 按元素乘法
a = torch.tensor([1, 2, 3])
b = torch.tensor([4, 5, 6])
c = a * b # 按元素乘法(hadamard积)
# 3. 向量点积(等同于按元素乘法后求和)
a = torch.tensor([1, 2, 3])
b = torch.tensor([4, 5, 6])
c = torch.dot(a, b) # 向量点积,即torch.sum(a*b)
# 4. 矩阵求逆
A = torch.tensor([[1, 2], [3, 4]])
A_inv = torch.inverse(A) # 矩阵求逆
# 5. 矩阵转置
AT = A.T() # 矩阵转置
# 6. 矩阵降维(沿指定轴sum或mean)
A = torch.arange(20, dtype=torch.float32).reshape(5,4)
A.mean(axis=0), A.sum(axis=0) / A.shape[0]
# 7. 非降维求和
sum_A = A.sum(axis=1, keepdims=True)
# 可利用广播机制
A/sum_A# 获得每一行间独立的概率分布
A.cumsum(axis=0)# 沿某个轴的累计总和,不会降维
# 8. 范数
A = torch.tensor([1, 2])
torch.norm(A, p=2) # 向量的L2范数,即向量元素平方和的平方根
torch.norm(A, p=1) # 向量的L1范数,即向量元素绝对值之和
torch.abs(u).sum() # L1范数的另一种表示形式
# 矩阵的Frobenius范数(矩阵元素平方和的平方根，类似于向量的L2范数)
torch.norm(torch.arange(36,dtype=torch.float32).reshape(4, 9))

导数和梯度

画图

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


# 见chapter0 calculus.py
import numpy as np
import matplotlib.pyplot as plt

# 设置x,y轴的数值
x1 = np.linspace(0, 15, 100)
y1 = np.sin(x1)
y2 = np.cos(x1)

# 在当前绘图对象中画图（x轴,y轴,给所绘制的曲线的名字，画线颜色，画线宽度）
plt.plot(x1, y1, label="$sin(x)$", color="blue", linewidth=2)
plt.plot(x1, y2, label="$cos(x)$", color="red", linewidth=2)

# X和Y坐标轴的表示
plt.xlabel("Domain")
plt.ylabel("Range")

# 图表的标题
plt.title("sin and cos")
# Y轴的范围
plt.ylim(-1.5, 1.5)
# 显示图示
plt.legend()
# 显示图
plt.show()

自动求导

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


import torch
x = torch.arange(4.0)# 数据类型需要为float,才可微分
x.requires_grad_(True) # 等价于x=torch.arange(4.0,requires_grad=True)
y = 2 * torch.dot(x, x)# 2*((x_i)**2)
y.backward() # 自动求导,应为dy/dx=4*x_i
print(x.grad) # 输出梯度张量

##1
#在默认情况下,PyTorch会累积梯度,我们需要清除之前的值 
x.grad.zero_()
y = x.sum()# ATTENTION: 这里的y是标量,因为反向传播需要损失函数上的一个特定的值,从而计算梯度.此时y相当于损失函数,需要是一个值(标量),这样才可以进行backwards()
y.backward()
print(x.grad) # 输出梯度张量

##2 本例只想求偏导数的和，所以传递一个1的梯度是合适的
x.grad.zero_()
y = x * x# hadamard积,按元素
# 等价于y.backward(torch.ones(len(x)))
y.sum().backward()
x.grad

##3 分离计算图
x0 = torch.arange(4.0,requires_grad=True)
# 本例只想求偏导数的和，所以传递一个1的梯度是合适的
y = x0 * x0

# 只希望使用当前y的值,然后计算z=u(y当前的值)*x0,但不希望获取y的梯度,导致z=x*x*x
u = y.detach()# 保存当前y的值,为常数,梯度不会更新
print(u)
z = u * x0
z.sum().backward()
print(x0.grad)
print(x0.grad == u)# u是常数,导数即u

x0.grad.zero_()
y.sum().backward()
print(x0.grad)
print(x0.grad == 2 * x0)# 导数为2*x0

##4 python控制流中的梯度计算
# 该例子想说明,标量在控制流中(循环,条件分支)进行运算仍会记录梯度的变化
import torch
def f(a):
 b = a
 while b.norm() < 1000:# 验证循环对梯度的影响
 b = b * 2
 if b.sum() > 0:# 验证条件分支对梯度的影响
 c = b
 else:
 c = 100 * b
 return c

a = torch.randn(size=(), requires_grad=True)

d = f(a)# d=2^n(b在循环内的次数n)*1或100(根据条件分支判断)*a
d.backward()# 因此d对a的导数就是d/a
print(a.grad)
print(a.grad == d / a)

深度学习计算

GPU相关

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


import torch
# 查看是否有GPU
print(torch.cuda.is_available())
# 设置可见的GPU
import os
os.environ["CUDA_VISIBLE_DEVICES=1,3"]# 仅第二、四个GPU可见，引号可加可不加
## 也可以在运行前!export CUDA_VISIBLE_DEVICES=0.这样设置后程序中的1卡为实际的3卡
# 设置设备
device = torch.device("cpu")
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# 定义张量
x = torch.tensor([[1, 2, 3],[4,5,6]], device=device)
# 张量转移到GPU
x = x.to(device)
# 张量转移到CPU
x = x.to("cpu")

自定义块

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# 可以在自定义块中定义模型参数,并在forward函数中使用这些参数
# 要实现各种层的嵌套,既可以在自定义块的forward函数中嵌套,也可以通过sequential函数来实现
class MLP(nn.Module):
 # 用模型参数声明层。这里，我们声明两个全连接的层
 def __init__(self):
 super().__init__()# 调用MLP的父类Module的构造函数来执行必要的初始化。
 # 这样，在类实例化时也可以指定其他函数参数，例如模型参数params（稍后将介绍）
 self.hidden = nn.Linear(20, 256) # 隐藏层
 self.out = nn.Linear(256, 10) # 输出层

 # 定义模型的前向传播，即如何根据输入X返回所需的模型输出
 def forward(self, X):
 # 注意，这里我们使用ReLU的函数版本，其在nn.functional模块中定义。
 return self.out(F.relu(self.hidden(X)))

自定义顺序块

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# 对应nn.Sequential函数
class MySequential(nn.Module):
 def __init__(self, *args):
 super().__init__()
 for idx, module in enumerate(args):
 # 这里，module是Module子类的一个实例。我们把它保存在'Module'类的成员
 # 变量_modules中。_module的类型是OrderedDict
 self._modules[str(idx)] = module# 该属性存放了各个连接模块的ID

 def forward(self, X):
 # OrderedDict保证了按照成员添加的顺序遍历它们
 for block in self._modules.values():
 X = block(X)# 按顺序传递值
 return X

net = MySequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
# 将两个全连接层与一个ReLU层连接在一起

参数管理

1
2
3
4
5
6


# 参数访问
net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 1))
X = torch.rand(size=(2, 4))

print(net[2].state_dict())# 访问nn.Linear(8, 1)的参数
print(*[(name, param.shape) for name, param in net.named_parameters()])# 访问所有参数

参数初始化

Xavier初始化原理

目的：使得每层的方差相同，从而使得每层的输出方差不变，从而使得每层的输出不受其他层影响。

全连接层输出为oi，该层输入数量为Nin，输出数量为Nout，输入表示为xj，权重表示为wij(不考虑偏置项).

权重wij都是从同一分布中独立抽取的，该分布具有零均值和方差σ2。这并不意味着分布必须是高斯的。现在,让我们假设层xj的输入也具有零均值和方差γ2,它们独立于wij并且彼此独立。

将输出进行表示： [o_i = \sum_{j=1}^{N_{in}} w_{ij} x_j] 则其均值为： [E[o_i] = \sum_{j=1}^{N_{in}} E[w_{ij} x_j] = \sum_{j=1}^{N_{in}} E[w_{ij}] E[x_j] = 0]

方差为： [Var[o_i] = \sum_{j=1}^{N_{in}} Var[w_{ij} x_j] = \sum_{j=1}^{N_{in}} E[w_{ij}^2 x_j^2] - 0 = \sum_{j=1}^{N_{in}} E[w_{ij}^2]E[x_j^2]=N_{in}σ^2γ^2]

保持方差不变的一种方法是设置$N_{in}σ^2 = 1$;
对于反向传播$N_{out}σ^2 = 1$,否则梯度的方差可能会增大.

因此,需要满足$\frac{1}{2}(N_{in}+N_{out})σ^2 = 1$

最终确定方差范围后,wij可以从高斯分布或均匀分布中进行采样。高斯分布采样范围： [w_{ij} \sim \mathcal{N}(0, \sqrt{\frac{2}{N_{in}+N_{out}}})] 均匀分布采样范围： [w_{ij} \sim \mathcal{U}(-\sqrt{\frac{6}{N_{in}+N_{out}}}, \sqrt{\frac{6}{N_{in}+N_{out}}})]

1

nn.init.xavier_uniform_(net.weight)# 函数会自行计算范围，只需传入要初始化的网络权重

关于net.apply

1
2
3
4


def init_normal(m):
 if type(m) == nn.Linear:
 nn.init.normal_(m.weight, mean=0, std=0.01)
 nn.init.zeros_(m.bias)

对于net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 1))使用net.apply(init_normal)和init_normal(net)会有什么区别?

net.apply(init_normal)会递归地遍历模型中的每一层，并对每一层调用init_normal函数;
而init_normal(net)把整个net模型作为参数传递过去,又因为net的类型是sequential,所以会导致类型错误.

自定义层

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# 不带参数的自定义层
# 功能:将输入减去均值,不需要指定网络参数,自适应输入的形状
class CenteredLayer(nn.Module):
 def __init__(self):
 super().__init__()

 def forward(self, X):
 return X - X.mean()

# 带参数的自定义层
# 创建了一个具有in_units输入单元数和out_units输出单元数的线性层,并通过ReLU后输出
class MyLinear(nn.Module):
 def __init__(self, in_units, units):
 super().__init__()
 self.weight = nn.Parameter(torch.randn(in_units, out_units))
 self.bias = nn.Parameter(torch.randn(out_units,))
 def forward(self, X):
 linear = torch.matmul(X, self.weight.data) + self.bias.data
 return F.relu(linear)

保存和加载模型

1
2
3
4
5
6


# 保存模型(张量、list、dict等均可)
net = MLP()
torch.save(net.state_dict(), 'net.params')
# 加载模型
clone_net = MLP()
clone_net.load_state_dict(torch.load('net.params'))

数据加载与处理

Dataset & Dataloader

torch.utils.data.Dataset：数据集的抽象类，需要自定义并实现 len（数据集大小）和 getitem（按索引获取样本）
torch.utils.data.DataLoader：封装 Dataset 的迭代器，提供批处理batch_size、数据打乱shuffle=True、多线程加载num_workers等功能，便于数据输入模型训练

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader

# 自定义数据集
class MyDataset(Dataset):
 def __init__(self, data, labels):
 # 数据初始化
 self.data = data
 self.labels = labels

 def __len__(self):
 # 返回数据集大小
 return len(self.data)

 def __getitem__(self, idx):
 # 按索引返回数据和标签
 sample = self.data[idx]
 label = self.labels[idx]
 return sample, label

# 生成示例数据
data = torch.randn(100, 5) # 100 个样本，每个样本有 5 个特征
labels = torch.randint(0, 2, (100,)) # 100 个标签，取值为 0 或 1

# 实例化数据集
dataset = MyDataset(data, labels)

# 创建 DataLoader 实例，batch_size 设置每次加载的样本数量
dataloader = DataLoader(dataset, batch_size=10, shuffle=True, num_workers=0)
# 遍历 DataLoader
for batch_idx, (batch_data, batch_labels) in enumerate(dataloader):
 print(f"批次 {batch_idx + 1}")
 print("数据:", batch_data)
 print("标签:", batch_labels)
 if batch_idx == 2: # 仅显示前 3 个批次
 break

数据转换

torchvision.transforms提供了基本的数据预处理（如归一化、大小调整等），还能帮助进行数据增强（如随机裁剪、翻转等），提高模型的泛化能力。

基础变换操作：
transforms.ToTensor() 将PIL图像或NumPy数组转换为PyTorch张量，并自动将像素值从[0, 255]归一化到 [0, 1]。 transform = transforms.ToTensor() transforms.Normalize(mean, std) 对图像进行标准化，使数据符合零均值和单位方差。 transform = transforms.Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225]) transforms.Resize(size) 调整图像尺寸，确保输入到网络的图像大小一致。 transform = transforms.Resize((256, 256)) transforms.CenterCrop(size) 从图像中心裁剪指定大小的区域。 transform = transforms.CenterCrop(224)

数据增强操作： transforms.RandomHorizontalFlip(p) 随机水平翻转图像。 transform = transforms.RandomHorizontalFlip(p=0.5) transforms.RandomRotation(degrees) 随机旋转图像。 transform = transforms.RandomRotation(degrees=45) transforms.ColorJitter(brightness, contrast, saturation, hue) 调整图像的亮度、对比度、饱和度和色调。 transform = transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1) transforms.RandomCrop(size) 随机裁剪指定大小的区域。 transform = transforms.RandomCrop(224) transforms.RandomResizedCrop(size) 随机裁剪图像并调整到指定大小。 transform = transforms.RandomResizedCrop(224)

自定义转换：

1
2
3
4
5
6


class CustomTransform:
 def __call__(self, x):
 # 这里可以自定义任何变换逻辑
 return x * 2

transform = CustomTransform()

组合变换： transforms.Compose() 将多个变换组合在一起，按照顺序依次应用。 transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), transforms.Resize((256, 256))])

线性神经网络

线性回归的简洁实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l

true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)

def load_array(data_arrays, batch_size, is_train=True): #@save
 """构造一个PyTorch数据迭代器"""
 dataset = data.TensorDataset(*data_arrays)
 return data.DataLoader(dataset, batch_size, shuffle=is_train)

batch_size = 10
data_iter = load_array((features, labels), batch_size)
next(iter(data_iter))# 输出第一个batch的特征和标签,进行验证

# nn是神经网络的缩写
from torch import nn

net = nn.Sequential(nn.Linear(2, 1))
net[0].weight.data.normal_(0, 0.01)# torch中，带下划线的一般指赋值,这里normal_指用均值0,方差0.01的正态分布给w的data属性(即w的值)赋值
net[0].bias.data.fill_(0)

loss = nn.MSELoss()# 损失函数:平方L2范数
optimizer = torch.optim.SGD(net.parameters(), lr=0.03)# 优化算法和学习率

num_epochs = 3
for epoch in range(num_epochs):
 for X, y in data_iter:
 l = loss(net(X) ,y)# 前向传播及计算损失函数
 optimizer.zero_grad()# 清空累计梯度
 l.backward()# 反向传播
 optimizer.step()# 优化参数
 l = loss(net(features), labels)
 print(f'epoch {epoch + 1}, loss {l:f}')

w = net[0].weight.data
print('w的估计误差：', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b - b)

softmax回归

softmax函数返回一个概率分布,其值在0到1之间,且总和为1.因此softmax回归常用于多类别分类问题.

图像分类数据集

使用Fashion-MNIST数据集,该数据集包含70,000张图像,分为10个类别,每张图像高和宽均为28像素.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


# softmax回归的简洁实现(从零开始实现见工程代码)
import torch
from torch import nn
from d2l import torch as d2l

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

# PyTorch不会隐式地调整输入的形状。因此，在线性层之前定义展平层（flatten），来调整网络输入的形状
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))
## nn.Flatten()将输入的多维张量展平为一维向量.如28*28的图像参数向量将被展平为长784的一维向量

def init_weights(m):# 初始化权重
 if type(m) == nn.Linear:
 nn.init.normal_(m.weight, std=0.01)
net.apply(init_weights)

loss = nn.CrossEntropyLoss(reduction='none')
trainer = torch.optim.SGD(net.parameters(), lr=0.1)

num_epochs = 10
d2l.train_ch6(net, train_iter, test_iter, num_epochs,0.03, 0)
# 包里没ch3的trainer了. d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

多层感知机MLP

多层感知机的简洁实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 网络部分写法
net = nn.Sequential(nn.Flatten(),
 nn.Linear(784, 256),
 nn.ReLU(),
 nn.Linear(256, 10))

def init_weights(m):
 if type(m) == nn.Linear:
 nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights)

权重衰减

权重衰减(weight decay)也被称为L2正则化。使得模型参数不会过大,从而控制复杂度。正则项的权重λ是控制模型复杂度的超参数。

目标函数 = 损失函数 + 正则项：
[{\rm{L(w, b) + }}\frac{\lambda }{2}{\left| w \right|^2}] 使用L2范数的一个原因是它对权重向量的大分量施加了巨大的惩罚。这使得我们的学习算法偏向于在大量特征上均匀分布权重的模型。在实践中,这可能使它们对单个变量中的观测误差更为稳定。

坐标轴对应w的取值绿点表示L(w, b)的最优点,坐标轴原点表示L2范数的最小值.因此距离这两个点越远,惩罚越大. 黄点是两者相制衡得到的惩罚函数最小值,即权重衰减的效果.

更新权重: [{{\rm{w}}{{\rm{t}} + 1}} \leftarrow (1 - \eta \lambda ){{\rm{w}}{\rm{t}}} - \frac{\eta }{B}\sum {\frac{{\partial L(w,b)}}{{\partial w}}} ] 注意$(1 - \eta \lambda)$处,表示先对wt做衰减,在进行更新.

丢弃法(dropout)

对每个中间活性值h以暂退概率p由随机变量h′替换。有概率p置零，其余概率扩大1-p倍，从而保证均值不变。 [h’ = \begin{cases}\frac{h}{1-p}, &\text{以概率 }1-p \ 0, &\text{以概率 }p\end{cases}] 如果通过许多不同的暂退法遮盖后得到的预测结果都是一致的,那么我们可以说网络发挥更稳定。

代码实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# dropout层，连接在全连接层之后，对输出进行丢弃
def dropout_layer(X, pdropout):
 assert 0 <= pdropout <= 1
 # p=1,所有元素都被丢弃 
 if pdropout == 1:
 return torch.zeros_like(X)
 # p=0,所有元素都被保留 
 if pdropout == 0:
 return X
 mask = (torch.rand(X.shape) > pdropout).float()
 return mask * X / (1.0 - pdropout)

# 简洁调用
nn.Dropout(pdropout)

卷积神经网络CNN

CNN专门用于处理具有网格状拓扑结构数据（如图像）
部分主要流程：(卷积-池化)*N-展平-分类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class SimpleCNN(nn.Module):
 def __init__(self):
 super(SimpleCNN, self).__init__()
 # 定义卷积层：输入1通道，输出32通道，卷积核大小3x3
 self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
 # 定义卷积层：输入32通道，输出64通道
 self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
 # 定义全连接层
 self.fc1 = nn.Linear(64 * 7 * 7, 128) # 输入大小 = 特征图大小 * 通道数
 self.fc2 = nn.Linear(128, 10) # 10 个类别

 def forward(self, x):
 x = F.relu(self.conv1(x)) # 第一层卷积 + ReLU
 x = F.max_pool2d(x, 2) # 最大池化
 x = F.relu(self.conv2(x)) # 第二层卷积 + ReLU
 x = F.max_pool2d(x, 2) # 最大池化
 x = x.view(-1, 64 * 7 * 7) # 展平操作
 x = F.relu(self.fc1(x)) # 全连接层 + ReLU
 x = self.fc2(x) # 全连接层输出
 return x

循环神经网络RNN

RNN专门用于处理序列数据，能够捕捉时间序列或有序数据的动态信息，如文本、时间序列或音频

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class SimpleRNN(nn.Module):
 def __init__(self, input_size, hidden_size, output_size):
 super(SimpleRNN, self).__init__()
 # 定义 RNN 层
 self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
 # 定义全连接层
 self.fc = nn.Linear(hidden_size, output_size)

 def forward(self, x):
 # x: (batch_size, seq_len, input_size)
 out, _ = self.rnn(x) # out: (batch_size, seq_len, hidden_size)
 # 取序列最后一个时间步的输出作为模型的输出
 out = out[:, -1, :] # (batch_size, hidden_size)
 out = self.fc(out) # 全连接层
 return out

Transformer

实际使用时，可以直接调用nn.embedding、nn.Transformer、nn.positional_encoding层构成模型，无需自己编写

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class TransformerModel(nn.Module):
 def __init__(self, input_dim, model_dim, num_heads, num_layers, output_dim):
 super(TransformerModel, self).__init__()
 self.embedding = nn.Embedding(input_dim, model_dim)
 self.positional_encoding = nn.Parameter(torch.zeros(1, 1000, model_dim)) # 假设序列长度最大为1000
 self.transformer = nn.Transformer(d_model=model_dim, nhead=num_heads, num_encoder_layers=num_layers)
 self.fc = nn.Linear(model_dim, output_dim)

 def forward(self, src, tgt):
 src_seq_length, tgt_seq_length = src.size(1), tgt.size(1)
 src = self.embedding(src) + self.positional_encoding[:, :src_seq_length, :]# 取实际序列长度的部分
 tgt = self.embedding(tgt) + self.positional_encoding[:, :tgt_seq_length, :]
 transformer_output = self.transformer(src, tgt)
 output = self.fc(transformer_output)
 return output

下面为自己实现各模块：

注意力机制

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


class MultiHeadAttention(nn.Module):
 def __init__(self, d_model, num_heads):
 super(MultiHeadAttention, self).__init__()
 assert d_model % num_heads == 0, "d_model必须能被num_heads整除"

 self.d_model = d_model # 模型维度（如512）
 self.num_heads = num_heads # 注意力头数（如8）
 self.d_k = d_model // num_heads # 每个头的维度（如64）

 # 定义线性变换层（无需偏置）
 self.W_q = nn.Linear(d_model, d_model) # 查询变换
 self.W_k = nn.Linear(d_model, d_model) # 键变换
 self.W_v = nn.Linear(d_model, d_model) # 值变换
 self.W_o = nn.Linear(d_model, d_model) # 输出变换

 def scaled_dot_product_attention(self, Q, K, V, mask=None):
 """
 计算缩放点积注意力
 输入形状：
 Q: (batch_size, num_heads, seq_length, d_k)
 K, V: 同Q
 输出形状： (batch_size, num_heads, seq_length, d_k)
 """
 # 计算注意力分数（Q和K的点积）
 attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)

 # 应用掩码（如填充掩码或未来信息掩码）
 if mask is not None:
 attn_scores = attn_scores.masked_fill(mask == 0, -1e9)

 # 计算注意力权重（softmax归一化）
 attn_probs = torch.softmax(attn_scores, dim=-1)

 # 对值向量加权求和
 output = torch.matmul(attn_probs, V)
 return output

 def split_heads(self, x):
 """
 将输入张量分割为多个头
 输入形状: (batch_size, seq_length, d_model)
 输出形状: (batch_size, num_heads, seq_length, d_k)
 """
 batch_size, seq_length, d_model = x.size()
 return x.view(batch_size, seq_length, self.num_heads, self.d_k).transpose(1, 2)

 def combine_heads(self, x):
 """
 将多个头的输出合并回原始形状
 输入形状: (batch_size, num_heads, seq_length, d_k)
 输出形状: (batch_size, seq_length, d_model)
 """
 batch_size, _, seq_length, d_k = x.size()
 return x.transpose(1, 2).contiguous().view(batch_size, seq_length, self.d_model)

 def forward(self, Q, K, V, mask=None):
 """
 前向传播
 输入形状: Q/K/V: (batch_size, seq_length, d_model)
 输出形状: (batch_size, seq_length, d_model)
 """
 # 线性变换并分割多头
 Q = self.split_heads(self.W_q(Q)) # (batch, heads, seq_len, d_k)
 K = self.split_heads(self.W_k(K))
 V = self.split_heads(self.W_v(V))

 # 计算注意力
 attn_output = self.scaled_dot_product_attention(Q, K, V, mask)

 # 合并多头并输出变换
 output = self.W_o(self.combine_heads(attn_output))
 return output

位置编码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


class PositionWiseFeedForward(nn.Module):
 def __init__(self, d_model, d_ff):
 super(PositionWiseFeedForward, self).__init__()
 self.fc1 = nn.Linear(d_model, d_ff) # 第一层全连接
 self.fc2 = nn.Linear(d_ff, d_model) # 第二层全连接
 self.relu = nn.ReLU() # 激活函数

 def forward(self, x):
 # 前馈网络的计算
 return self.fc2(self.relu(self.fc1(x)))

class PositionalEncoding(nn.Module):
 def __init__(self, d_model, max_seq_length):
 super(PositionalEncoding, self).__init__()
 pe = torch.zeros(max_seq_length, d_model) # 初始化位置编码矩阵
 position = torch.arange(0, max_seq_length, dtype=torch.float).unsqueeze(1)
 div_term = torch.exp(torch.arange(0, d_model, 2).float() * -(math.log(10000.0) / d_model))
 pe[:, 0::2] = torch.sin(position * div_term) # 偶数位置使用正弦函数
 pe[:, 1::2] = torch.cos(position * div_term) # 奇数位置使用余弦函数
 self.register_buffer('pe', pe.unsqueeze(0)) # 注册为缓冲区

 def forward(self, x):
 # 将位置编码添加到输入中
 return x + self.pe[:, :x.size(1)]

Encoder

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class EncoderLayer(nn.Module):
 def __init__(self, d_model, num_heads, d_ff, dropout):
 super(EncoderLayer, self).__init__()
 self.self_attn = MultiHeadAttention(d_model, num_heads) # 自注意力机制
 self.feed_forward = PositionWiseFeedForward(d_model, d_ff) # 前馈网络
 self.norm1 = nn.LayerNorm(d_model) # 层归一化
 self.norm2 = nn.LayerNorm(d_model)
 self.dropout = nn.Dropout(dropout) # Dropout

 def forward(self, x, mask):
 # 自注意力机制
 attn_output = self.self_attn(x, x, x, mask)
 x = self.norm1(x + self.dropout(attn_output)) # 残差连接和层归一化

 # 前馈网络
 ff_output = self.feed_forward(x)
 x = self.norm2(x + self.dropout(ff_output)) # 残差连接和层归一化
 return x

Decoder

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


class DecoderLayer(nn.Module):
 def __init__(self, d_model, num_heads, d_ff, dropout):
 super(DecoderLayer, self).__init__()
 self.self_attn = MultiHeadAttention(d_model, num_heads) # 自注意力机制
 self.cross_attn = MultiHeadAttention(d_model, num_heads) # 交叉注意力机制
 self.feed_forward = PositionWiseFeedForward(d_model, d_ff) # 前馈网络
 self.norm1 = nn.LayerNorm(d_model) # 层归一化
 self.norm2 = nn.LayerNorm(d_model)
 self.norm3 = nn.LayerNorm(d_model)
 self.dropout = nn.Dropout(dropout) # Dropout

 def forward(self, x, enc_output, src_mask, tgt_mask):
 # 自注意力机制
 attn_output = self.self_attn(x, x, x, tgt_mask)
 x = self.norm1(x + self.dropout(attn_output)) # 残差连接和层归一化

 # 交叉注意力机制
 attn_output = self.cross_attn(x, enc_output, enc_output, src_mask)
 x = self.norm2(x + self.dropout(attn_output)) # 残差连接和层归一化

 # 前馈网络
 ff_output = self.feed_forward(x)
 x = self.norm3(x + self.dropout(ff_output)) # 残差连接和层归一化
 return x

整体架构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


class Transformer(nn.Module):
 def __init__(self, src_vocab_size, tgt_vocab_size, d_model, num_heads, num_layers, d_ff, max_seq_length, dropout):
 super(Transformer, self).__init__()
 self.encoder_embedding = nn.Embedding(src_vocab_size, d_model) # 编码器词嵌入
 self.decoder_embedding = nn.Embedding(tgt_vocab_size, d_model) # 解码器词嵌入
 self.positional_encoding = PositionalEncoding(d_model, max_seq_length) # 位置编码

 # 编码器和解码器层
 self.encoder_layers = nn.ModuleList([EncoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)])
 self.decoder_layers = nn.ModuleList([DecoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)])

 self.fc = nn.Linear(d_model, tgt_vocab_size) # 最终的全连接层
 self.dropout = nn.Dropout(dropout) # Dropout

 def generate_mask(self, src, tgt):
 # 源掩码：屏蔽填充符（假设填充符索引为0）
 # 形状：(batch_size, 1, 1, seq_length)
 src_mask = (src != 0).unsqueeze(1).unsqueeze(2)

 # 目标掩码：屏蔽填充符和未来信息
 # 形状：(batch_size, 1, seq_length, 1)
 tgt_mask = (tgt != 0).unsqueeze(1).unsqueeze(3)
 seq_length = tgt.size(1)
 # 生成上三角矩阵掩码，防止解码时看到未来信息
 nopeak_mask = (1 - torch.triu(torch.ones(1, seq_length, seq_length), diagonal=1)).bool()
 tgt_mask = tgt_mask & nopeak_mask # 合并填充掩码和未来信息掩码
 return src_mask, tgt_mask

 def forward(self, src, tgt):
 # 生成掩码
 src_mask, tgt_mask = self.generate_mask(src, tgt)

 # 编码器部分
 src_embedded = self.dropout(self.positional_encoding(self.encoder_embedding(src)))
 enc_output = src_embedded
 for enc_layer in self.encoder_layers:
 enc_output = enc_layer(enc_output, src_mask)

 # 解码器部分
 tgt_embedded = self.dropout(self.positional_encoding(self.decoder_embedding(tgt)))
 dec_output = tgt_embedded
 for dec_layer in self.decoder_layers:
 dec_output = dec_layer(dec_output, enc_output, src_mask, tgt_mask)

 # 最终输出
 output = self.fc(dec_output)
 return output

优化算法

计算机视觉

激活函数

Sun, 20 Oct 2024 21:01:22 +0800

激活函数

引入激活函数是为了增加神经网络模型的非线性。若没有激活函数的每层都相当于矩阵相乘。没有激活函数的神经网络叠加了若干层之后，还是一个线性变换，与单层感知机无异。

常见激活函数

sigmoid函数

$$\sigma(x) = \frac{1}{1+e^{-x}}$$ 其导数为： $$\sigma’(x) = \frac{\exp(-x)}{(1+e^{-x})^2} = \sigma(x)(1-\sigma(x))$$ 图像：

优点：

Sigmoid 函数的输出范围是 0 到 1。预测值非常接近0/1，可以用于表示二分类的类别或者用于表示置信度。
梯度平滑，便于求导，也防止模型训练过程中出现突变的梯度

缺点：

Sigmoid 函数的输出不是以 0 为中心的，可能导致模型输出的均值偏离 0。
Sigmoid 函数在计算过程中容易出现梯度消失的问题。
Sigmoid 函数需要计算指数函数，计算量大，效率低。

softmax函数（归一化指数函数）

$$softmax(x_i) = \frac{\exp(x_i)}{\sum_{j}\exp(x_j)}$$

特点：

Softmax函数常用于多类分类问题的输出层激活函数。对于长度为K的任意实向量，Softmax函数可以将其压缩为长度为K，值在[0,1]范围内，并且向量中元素的总和为1的实向量（即概率分布向量）。其值反映了该向量中各个元素的概率。

输出层使用例：

tanh函数

$$tanh(x) = \frac{\exp(x)-\exp(-x)}{\exp(x)+\exp(-x)}$$ 其导数为： $$tanh’(x) = 1-tanh^2(x)$$ 实际上，tanh函数就是将sigmoid函数的输出拉伸到-1到1之间。
[tanh(x) = 2\sigma(2x)-1]

图像：

优点：

函数以 0 为中心，输出范围是 -1 到 1。
tanh 函数的导数在 0 处梯度为1，因此可以减轻梯度饱和问题。

缺点：

仍存在梯度饱和的问题。
仍是指数运算。

softsign函数（更平滑的tanh函数）

$$softsign(x) = \frac{x}{1+|x|}$$ 其导数为： $$softsign’(x) = \frac{1}{1+|x|^2}$$

图像：

优点：

曲线更平坦、梯度下降更慢，表明它可以更高效地学习
可以更好的减轻梯度饱和问题。

缺点：

计算更麻烦

ReLU函数（线性整流函数）

$$ReLU(x) = max(0,x)$$

图像：

优点：

计算简单，速度快。
输入为正时，不存在梯度饱和。

缺点：

输出不是以 0 为中心，可能导致模型输出的均值偏离0。
Dead ReLU问题：当神经元的输入为负数，则该神经元的梯度为0，输出恒为0，不再对输入数据有所响应，导致其后参数不再更新。

需要注意的是，虽然Leaky ReLU和ELU函数都能解决ReLU函数的死亡问题，但实践中并未表明他们比ReLU函数效果更好。

softplus函数（ReLU的平滑版本）

$$softplus(x) = \ln(1+e^x)$$

图像：

特点：

Softplus 是一个平滑函数，在所有点上都可微。这意味着它在反向传播时不会出现像 ReLU 那样的导数不连续问题。
Softplus 在整个定义域上都有非零梯度，因此在反向传播中不会出现梯度消失的问题。
计算复杂。

Leaky ReLU函数

$$Leaky\ ReLU(x) = max(\alpha x,x)$$

图像：

优点：

解决了ReLU函数的死亡问题。
同ReLU函数一样，输入为正时，不存在梯度饱和。

缺点：

$\alpha$值需要人为设定，不易调参，一般取0.01。
有些近似线性，导致在复杂分类中效果不好。

PReLU函数

$$PReLU(x) = max(\alpha x,x)$$ 与Leaky ReLU激活函数不同的是，PRelu激活函数负半轴的斜率参数α 是通过学习得到的，而不是手动设置的恒定值。

各性质类似于Leaky ReLU激活函数。

ELU函数

$$ELU(x) = \left{ \begin{array}{ll} \alpha(e^x-1) & x<0 \ x & x\geq0 \end{array} \right. $$

图像：

优点：

ELU试图将激活函数的输出均值接近于零，使正常梯度更接近于单位自然梯度，从而加快学习速度。
ELU 在较小的输入下会饱和至负值，从而减少前向传播的变异和信息。
输出是以 0 为中心，输出范围是 -1 到 1。

缺点：

计算指数函数，效率低。

SELU函数

$$SELU(x) = \lambda\left{ \begin{array}{ll} \alpha(e^x-1) & x<0 \ x & x\geq0 \end{array} \right. $$

图像：

特点：

SELU 允许构建一个映射 g，其性质能够实现 SNN(自归一化神经网络)。
SELU函数通过调整均值和方差来实现内部的归一化，这种内部归一化比外部归一化更快，这使得网络能够更快得收敛

PS: SNN网络激活函数的要求：

负值和正值，以便控制均值；
饱和区域（导数趋近于零），以便抑制更低层中较大的方差；
大于 1 的斜率，以便在更低层中的方差过小时增大方差；
连续曲线。

swish函数

$$swish(x) = x\sigma(x)$$

图像：

特点：

与sigmoid函数类似，但更平滑，在优化和泛化中起了重要作用。
其无界性有助于防止慢速训练期间，梯度逐渐接近 0 并导致饱和。

LLM_flow

Wed, 25 Sep 2024 22:49:25 +0800

前置

服务器使用指南

选择GPU的几种方式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 设置可见GPU
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "0，1"
#n为GPU编号，从0开始。需要在import torch前设置
import torch

device = torch.device("cuda:0")# 只能指定单卡

# 指定使用GPU 0, 1和2（不设置device_ids或令其=None，则默认使用所有GPU）
model = nn.DataParallel(model, device_ids=[0, 1, 2])

pytorch安装

使用pip安装比conda更靠谱，指令见(https://pytorch.org/get-started/locally/) cuda版本等细节见土堆教程。 (pip临时代理： –proxy=http://)

下载预训练模型

注意：需要使用git lfs clone以下载模型参数文件。

git clone
git clone url –depth=1:只下载最近一次commit
(-c http.proxy="http://127.0.0.1:7890" # 临时代理)
lfs下载大文件时，其文件大小会增加，但进度条百分比和网速会卡住，当下完完整的一个大文件后才更新进度，耐心等待即可。

huggingface下载：

1.(推荐)

1
2
3
4
5
6
7
8
9


sudo apt install aria2
wget https://hf-mirror.com/hfd/hfd.sh
chmod +x hfd.sh
export HF_ENDPOINT=https://hf-mirror.com
# 下载模型(下载速度慢可以取消下载后断点重连)
./hfd.sh <model_name> --tool aria2c -x 4 [可选]--hf_username <username> --hf_token <apikey>
# 代理：--all-proxy=http://
# 下载数据集
./hfd.sh <dataset_name> --dataset --tool aria2c -x 4 [可选]--hf_username <username> --hf_token <apikey>

1
2
3
4
5
6
7
8


pip install -U huggingface_hub
# 设置环境变量为镜像源(建议写入/.bashrc)
export HF_ENDPOINT=https://hf-mirror.com
# 下载模型
huggingface-cli download --resume-download <model_name> --local-dir <local_dir_name>
# 下载数据集
huggingface-cli download --repo-type dataset --resume-download <dataset_name> --local-dir <local_dir_name>
## 可以添加--local-dir-use-symlinks False禁用软链接，下载路径下所见即所得

选择clone repository（三个点展开），使用提供的git clone命令下载到本地。

魔搭社区下载：
参考见上。

推理(inference)

概述

推理(inference)是指模型对输入数据进行预测，得到模型输出结果。
推理过程可以分为三个步骤：

加载模型参数：加载模型参数，包括模型结构和模型参数。
输入数据预处理：对输入数据进行预处理，如tokenizing、padding等。
模型推理：使用模型进行推理，得到模型输出结果。

微调(finetune)

介绍

序言

用好大模型的第一个层次，是掌握提示词工程(Prompt Engineering)，用好大模型的第二个层次，是大模型的微调(Fine Tuning)

Prompt Engineering 的方式会把Prompt搞得很长微调通过自有数据，优化模型在特定任务上的性能，减少幻觉。

技术路线

从参数规模的角度，大模型的微调分成两条技术路线：

全量微调FFT(Full Fine Tuning)：对全量的参数，进行全量的训练。
参数高效微调PEFT(Parameter-Efficient Fine Tuning)：只对部分的参数进行训练，如Lora。

从训练的方法的角度

监督式微调SFT(Supervised Fine Tuning)，主要是用人工标注的数据，用传统机器学习中监督学习的方法，对大模型进行微调；
基于人类反馈的强化学习微调RLHF(Reinforcement Learning with Human Feedback)，这个方案的主要特点是把人类的反馈，通过强化学习的方式，引入到对大模型的微调中去，让大模型生成的结果，更加符合人类的一些期望；
基于AI反馈的强化学习微调RLAIF(Reinforcement Learning with AI Feedback)，这个原理大致跟RLHF类似，但是反馈的来源是AI。

微调流程

Lora参考流程

数据集

instruction字段通常用于描述任务类型或给出指令
input字段包含模型需要处理的文本数据
output字段则包含对应输入的正确答案或期望输出

常用中文微调数据集可能包括：中文问答数据集（如CMRC 2018、DRCD等），用于训练问答系统。中文情感分析数据集（如ChnSentiCorp、Fudan News等），用于训练情感分类模型。中文文本相似度数据集（如LCQMC、BQ Corpus等），用于训练句子对匹配和相似度判断任务。中文摘要生成数据集（如LCSTS、NLPCC等），用于训练文本摘要生成模型。中文对话数据集（如LCCC、ECDT等），用于训练聊天机器人或对话系统。

训练过程

评估与迭代

Lora训练示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


import torch ​
import torch.nn as nn​
import torch.nn.functional as F​
import math​
​
class LoRALinear(nn.Module):​
 def __init__(self, in_features, out_features, merge, rank=16, lora_alpha=16, dropout=0.5):​
 super(LoRALinear, self).__init__()​
 self.in_features = in_features​
 self.out_features = out_features​
 self.merge = merge​
 self.rank = rank​
 self.dropout_rate = dropout​
 self.lora_alpha = lora_alpha​
 ​
 self.linear = nn.Linear(in_features, out_features)​
 if rank > 0:​
 self.lora_b = nn.Parameter(torch.zeros(out_features, rank))​
 self.lora_a = nn.Parameter(torch.zeros(rank, in_features))​
 self.scale = self.lora_alpha / self.rank​
 self.linear.weight.requires_grad = False​
 ​
 if self.dropout_rate > 0:​
 self.dropout = nn.Dropout(self.dropout_rate)​
 else:​
 self.dropout = nn.Identity()​
 ​
 self.initial_weights()​
 ​
 def initial_weights(self):​
 nn.init.kaiming_uniform_(self.lora_a, a=math.sqrt(5))​
 nn.init.zeros_(self.lora_b)​
 ​
 def forward(self, x):​
 if self.rank > 0 and self.merge:​
 output = F.linear(x, self.linear.weight + self.lora_b @ self.lora_a * self.scale, self.linear.bias)​
 output = self.dropout(output)​
 return output​
 else:​
 return self.dropout(self.linear(x))​
​

量化(quantization)

降低精度，减少模型大小，提升推理速度。

蒸馏(distillation)

让小模型学习大模型的知识，提升小模型的性能。

部署(deployment)

vllm部署

评估(evaluation)

wandb

Thu, 19 Sep 2024 14:36:30 +0800

(https://docs.wandb.ai/quickstart/)

安装库

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


pip install wandb
# 创建账户
wandb login
# 初始化
# Inside my model training code
import wandb
wandb.init(project="my-project")
# 声明超参数
wandb.config.dropout = 0.2
wandb.config.hidden_layer_size = 128
# 记录日志
def my_train_loop():
 for epoch in range(10):
 loss = 0 # change as appropriate :)
 wandb.log({'epoch': epoch, 'loss': loss})
# 保存文件
# by default, this will save to a new subfolder for files associated
# with your run, created in wandb.run.dir (which is ./wandb by default)
wandb.save("mymodel.h5")

# you can pass the full path to the Keras model API
model.save(os.path.join(wandb.run.dir, "mymodel.h5"))

使用wandb以后，模型输出，log和要保存的文件将会同步到cloud。

PyTorch应用wandb

我们以一个最简单的神经网络为例展示wandb的用法：

首先导入必要的库

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


from __future__ import print_function
import argparse
import random # to set the python random seed
import numpy # to set the numpy random seed
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
# Ignore excessive warnings
import logging

logging.propagate = False
logging.getLogger().setLevel(logging.ERROR)

# WandB – Import the wandb library
import wandb

使用前的准备

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128


# 登陆你的wandb账户：
# WandB – Login to your wandb account so you can log all your metrics
!wandb login

# 定义Convolutional Neural Network：

class Net(nn.Module):
 def __init__(self):
 super(Net, self).__init__()

 # In our constructor, we define our neural network architecture that we'll use in the forward pass.
 # Conv2d() adds a convolution layer that generates 2 dimensional feature maps
 # to learn different aspects of our image.
 self.conv1 = nn.Conv2d(3, 6, kernel_size=5)
 self.conv2 = nn.Conv2d(6, 16, kernel_size=5)

 # Linear(x,y) creates dense, fully connected layers with x inputs and y outputs.
 # Linear layers simply output the dot product of our inputs and weights.
 self.fc1 = nn.Linear(16 * 5 * 5, 120)
 self.fc2 = nn.Linear(120, 84)
 self.fc3 = nn.Linear(84, 10)

 def forward(self, x):
 # Here we feed the feature maps from the convolutional layers into a max_pool2d layer.
 # The max_pool2d layer reduces the size of the image representation our convolutional layers learnt,
 # and in doing so it reduces the number of parameters and computations the network needs to perform.
 # Finally we apply the relu activation function which gives us max(0, max_pool2d_output)
 x = F.relu(F.max_pool2d(self.conv1(x), 2))
 x = F.relu(F.max_pool2d(self.conv2(x), 2))

 # Reshapes x into size (-1, 16 * 5 * 5)
 # so we can feed the convolution layer outputs into our fully connected layer.
 x = x.view(-1, 16 * 5 * 5)

 # We apply the relu activation function and dropout to the output of our fully connected layers.
 x = F.relu(self.fc1(x))
 x = F.relu(self.fc2(x))
 x = self.fc3(x)

 # Finally we apply the softmax function to squash the probabilities of each class (0-9)
 # and ensure they add to 1.
 return F.log_softmax(x, dim=1)

# 定义训练函数
def train(config, model, device, train_loader, optimizer, epoch):
 # switch model to training mode. This is necessary for layers like dropout, batchNorm etc.
 # which behave differently in training and evaluation mode.
 model.train()

 # we loop over the data iterator, and feed the inputs to the network and adjust the weights.
 for batch_id, (data, target) in enumerate(train_loader):
 if batch_id > 20:
 break
 # Loop the input features and labels from the training dataset.
 data, target = data.to(device), target.to(device)

 # Reset the gradients to 0 for all learnable weight parameters
 optimizer.zero_grad()

 # Forward pass: Pass image data from training dataset, make predictions
 # about class image belongs to (0-9 in this case).
 output = model(data)

 # Define our loss function, and compute the loss
 loss = F.nll_loss(output, target)

 # Backward pass:compute the gradients of loss,the model's parameters
 loss.backward()

 # update the neural network weights
 optimizer.step()

# 定义测试函数
# wandb.log用来记录一些日志(accuracy,loss and epoch), 便于随时查看网路的性能
def test(args, model, device, test_loader, classes):
 model.eval()
 # switch model to evaluation mode.
 # This is necessary for layers like dropout, batchNorm etc. which behave differently in training and evaluation mode
 test_loss = 0
 correct = 0
 example_images = []

 with torch.no_grad():
 for data, target in test_loader:
 # Load the input features and labels from the test dataset
 data, target = data.to(device), target.to(device)

 # Make predictions: Pass image data from test dataset,
 # make predictions about class image belongs to(0-9 in this case)
 output = model(data)

 # Compute the loss sum up batch loss
 test_loss += F.nll_loss(output, target, reduction='sum').item()

 # Get the index of the max log-probability
 pred = output.max(1, keepdim=True)[1]
 correct += pred.eq(target.view_as(pred)).sum().item()

 # Log images in your test dataset automatically,
 # along with predicted and true labels by passing pytorch tensors with image data into wandb.
 example_images.append(wandb.Image(
 data[0], caption="Pred:{} Truth:{}".format(classes[pred[0].item()], classes[target[0]])))

 # wandb.log(a_dict) logs the keys and values of the dictionary passed in and associates the values with a step.
 # You can log anything by passing it to wandb.log(),
 # including histograms, custom matplotlib objects, images, video, text, tables, html, pointclounds and other 3D objects.
 # Here we use it to log test accuracy, loss and some test images (along with their true and predicted labels).
 wandb.log({
 "Examples": example_images,
 "Test Accuracy": 100. * correct / len(test_loader.dataset),
 "Test Loss": test_loss
 })

# 初始化一个wandb run，并设置超参数：
# Initialize a new run
wandb.init(project="pytorch-intro")
wandb.watch_called = False # Re-run the model without restarting the runtime, unnecessary after our next release

# config is a variable that holds and saves hyper parameters and inputs
config = wandb.config # Initialize config
config.batch_size = 4 # input batch size for training (default:64)
config.test_batch_size = 10 # input batch size for testing(default:1000)
config.epochs = 50 # number of epochs to train(default:10)
config.lr = 0.1 # learning rate(default:0.01)
config.momentum = 0.1 # SGD momentum(default:0.5)
config.no_cuda = False # disables CUDA training
config.seed = 42 # random seed(default:42)
config.log_interval = 10 # how many batches to wait before logging training status

主函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


def main():
 use_cuda = not config.no_cuda and torch.cuda.is_available()
 device = torch.device("cuda:0" if use_cuda else "cpu")
 kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}

 # Set random seeds and deterministic pytorch for reproducibility
 # random.seed(config.seed) # python random seed
 torch.manual_seed(config.seed) # pytorch random seed
 # numpy.random.seed(config.seed) # numpy random seed
 torch.backends.cudnn.deterministic = True

 # Load the dataset: We're training our CNN on CIFAR10.
 # First we define the transformations to apply to our images.
 transform = transforms.Compose([
 transforms.ToTensor(),
 transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
 ])

 # Now we load our training and test datasets and apply the transformations defined above
 train_loader = DataLoader(datasets.CIFAR10(
 root='./data',
 train=True,
 download=True,
 transform=transform
 ), batch_size=config.batch_size, shuffle=True, **kwargs)

 test_loader = DataLoader(datasets.CIFAR10(
 root='./data',
 train=False,
 download=True,
 transform=transform
 ), batch_size=config.batch_size, shuffle=False, **kwargs)

 classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
 # Initialize our model, recursively go over all modules and convert their parameters
 # and buffers to CUDA tensors (if device is set to cuda)
 model = Net().to(device)
 optimizer = optim.SGD(model.parameters(), lr=config.lr, momentum=config.momentum)

 # wandb.watch() automatically fetches all layer dimensions, gradients, model parameters
 # and logs them automatically to your dashboard.
 # using log="all" log histograms of parameter values in addition to gradients
 wandb.watch(model, log="all")
 for epoch in range(1, config.epochs + 1):
 train(config, model, device, train_loader, optimizer, epoch)
 test(config, model, device, test_loader, classes)

 # Save the model checkpoint. This automatically saves a file to the cloud
 torch.save(model.state_dict(), 'model.h5')
 wandb.save('model.h5')


if __name__ == '__main__':
 main()

LLM趋势及个人生涯分享--李沐

Sat, 24 Aug 2024 21:01:10 +0800

第一部分：LLM

继上一次的深度学习浪潮，现在兴起的是语言模型浪潮。

语言模型可以分为三块：算力、数据和算法。(丹炉、药材、炼丹术)

算力

算力的发展趋势

长期来看，算力的成本将持续降低，大模型训练成本也会不断下降，所以大模型本身也不是一个能保值的东西，价值会随着时间降低，也某种意义上受摩尔定律的影响(训练会两倍两倍地变便宜，今天训练一个模型，一年之后它的价值会减半)。

大模型不是特别有性价比的东西。你要想清楚，从长期来看，你的模型能带来什么价值，让你能够保值。

100B 到 500B 会是未来主流的一个大势。你可以做更大，但是它很多时候是用 MoE 做的，它的有效大小（每次激活的大小）可能也就是 500B 的样子。

PS：对于模型开发者来说，要想在模型的参数量、预训练上想取得突破是不明智的，头部企业的突破速度不是小团队可以想象的。更应该关注模型的后训练、应用部署。

算力的瓶颈

通信带宽：分布式训练要求多卡间的通信延迟足够小。由于供电、散热的问题，芯片间需要保持一定距离，导致了通信延迟。
即使是使用光纤以光速传输，一米距离传输带来的几纳秒延迟对性能影响也很大。

内存：大模型训练需要大量的内存，目前最大的单个内存芯片可以达到192GB。
内存占面积大，一个芯片划一块给算力，划一块给内存之后就放不下什么东西了。这会严重限制模型大小。
(在这一块，虽然英伟达是领先者，但其实英伟达是不如 AMD 的，甚至不如 Google 的 TPU)

数据

当前数据质量的提升比数量提升更重要。

数据决定了模型的上限，算法决定了模型的下限。
就目前来说，我们离 AGI 还很远， AGI 能够做自主的学习，我们目前的模型就是填鸭式状态。
Claude团队花了很大的力气来做数据，在数据上用了很多年。所以，想让模型在某一个方面做得特别好，需要先把相关数据准备好。大家还是用了 70-80% 时间在数据上。

数据质量的提升还来自于：

标注数据：语言模型的训练数据需要大量的标注数据，比如训练集、验证集、测试集。
领域数据：语言模型的训练数据需要包含领域相关的文本，比如新闻、科技、医疗等。
多样性：语言模型的训练数据需要包含各种语言、方言、口音等多样性的文本。

趋势

End-to-end和多模态是当前大模型的趋势。

目前语言模型已经达到了较高的水平，大约在 80 到 85 分之间。音频模型在可接受的水平，处于能用阶段，大约在 70-80 分之间。但在视频生成方面，尤其是生成具有特定功能的视频尚显不足，整体水平大约在 50 分左右。

技术层面

多模态技术

多模态技术的发展趋势在于整合不同类型的模态信息。
由于文本是信息密度最高的，也是最容易获得的。
一是可以借助强大的文本模型进行泛化。二是可以通过文本来定制和控制其他模态的输出，比如用简单的文本指令控制图片、视频和声音的生成。

预训练与后训练

预训练是用大量的文本数据训练一个通用语言模型，后训练是用这个通用语言模型来训练特定任务的模型。

预训练是工程问题，后训练才是技术问题
在预训练方面，现在已经变成一个因为大而导致很多工程问题的困难，这其实还是算法上探索不够，得清楚如何改进算法。
对于后训练，高质量的数据和改进的算法能够极大地提升模型效果。高质量的数据一定是结构化的，并且与应用场景高度相关，以保证数据的多样性和实用性。

垂直模型也需要通用维度

为什么要做垂直模型呢？因为通用模型的问题还是一个指数问题，你要实现的任务，通用模型不一定能完成。
通用模型是通用维度，需要各个方面都有提升，如果刚好满足你的要求，需要指数级的数据，并且模型会变得很大。

但是就算是一个很垂直领域的模型，它的通用能力也是不能差的。比如说你要在某一个学科里面拿第一，你别的科目也不能差到哪里去。

模型评估

自然语言很难评价其正确性、逻辑性和风格。通常我们不想让人来评估，因为比较昂贵，但使用模型评估会带来偏差。
有一个好的评估可以解决 50% 的问题。因为一旦评估解决了，那你就能够进行优化。第二评估解决了，表示你拥有了一些数据。

应用层面

人机交互

人机交互的方式可能会发生改变。以往人机交互都是通过键鼠和屏幕完成的，未来的语音控制系统将能够处理更加复杂和具体的任务。
手机的 killer APP 是什么吗？短视频。语言模型的killer APP是什么？这个还是未知。

对人类的替代

数据越多的领域，就越能被自动化。
当前大模型在简单的文科任务上已经能很好地代替人类。因为文科任务是最能简单快速采集大量数据的。在简单理科任务和复杂文科任务上能力正在突破。
而当前想要替代蓝领，还非常遥远。工厂需要投放大量传感器，做好数字化基础设施建设，数据收集和整理方案成熟起来，才有大模型落地的希望。而这一切当前看来还很难，但一旦实现就会是重大变革。

第二部分：职业规划建议

几种身份的区别

目标和动机的差异 大厂的目标是升职加薪，PhD的目标就是博士毕业，创业的目标就是套现退出

优缺点分析 晚上不用做噩梦，但逐渐成为螺丝钉。
好处是，可以在一个相对简单的环境里学习各种从业知识、有相对稳定的收入和空余时间；坏处就是停留在打工人或者职业经理人的思维。

好处是，在几年的时间里可以专心探索某一个领域；
坏处是，很少有实验室能参与大项目的研发，并且需要有很强的自我驱动力。要真的热爱研究，不然坚持不下去，你会觉得研究这个东西到底有什么意义，写这篇论文要干嘛。
其实，你可以这样想：我写这篇文章就是为了练习写作，等到更厉害、更大的成果做出来后，写作不能给我拉后腿。你要有一个更远大的目标，是真的热爱它。
PS：读不了一点

驱动力的来源

欲望是越底层越好，名、利、权，都是底层的欲望。恐惧是可以让你抑郁的恐惧，也是让你感受到生死的恐惧。

你需要把欲望和恐惧转变成积极向上的动机，你的动机一定是正确的，符合价值观的，因为逃避、放纵满足不了欲望，也缓解不了恐惧，唯一克服它的办法是，把它变成一个积极向上、符合社会价值的一个动机。

有了动机之后就得想，我要解决什么问题，你的问题可能就是你的动机本身。

举例来说，语言模型为什么能运作？没人知道，这是一个很有学术价值的东西。语言模型能不能孵化出新的应用？这是商业价值上的问题。实在不行的话，也可以思考语言模型在某个产品上如何落地。

一个提升自我的方法 为什么目标没达成？

可能是因为懒，那么你得直面懒的问题。我怎么能让自己勤奋一点？找一个学习伙伴，每天在图书馆待着，要大家相互监督等。
还有可能是因为蠢，这就有两种解决方案。一种是换一个方向，去擅长的领域；一种是既然绕不开，那就花别人两倍的时间。
无论是因为懒还是蠢，你都得对自己狠，最后拼的就是你对自己有多狠。

你要形成一个习惯，定个闹钟，每周一晚上花 30 分钟对自己进行总结，每个季度要总结，翻看之前你的写的周记，看看这个季度的目标是否完成，下个季度要做什么。

选择比努力更重要，但选择的前提是搞清楚你的目标是什么。