怎么盗号网站怎么做,住房和城乡建设厅焊工证,网站布局选择,2345浏览器免费版比赛链接#xff1a;讯飞开放平台
来源#xff1a;DataWhale AI夏令营3#xff08;NLP#xff09; Roberta-base#xff08;BERT的改进#xff09;
①Roberta在预训练的阶段中没有对下一句话进行预测#xff08;NSP#xff09;
②采用了动态掩码 ③使用字符级和词级…比赛链接讯飞开放平台
来源DataWhale AI夏令营3NLP Roberta-baseBERT的改进
①Roberta在预训练的阶段中没有对下一句话进行预测NSP
②采用了动态掩码 ③使用字符级和词级别表征的混合文本编码。
论文https://arxiv.org/pdf/1907.11692.pdf DataWhale Topline的改进 特征1平均池化MeanPooling(768维) - 全连接层fc(128维) 特征2末隐藏层Last_hidden (768维) - 全连接层fc(128维) 运行方式阿里云机器学习平台PAI-交互式建模DSW
镜像选择pytorch:1.12-gpu-py39-cu113-ubuntu20.04
上传代码解压指令
unzip [filename]
运行py脚本指令遇到网络错误重新运行即可
python [python_filename] ① 数据处理模块
导入需要的模块
from transformers import AutoTokenizer #文本分词
import pandas as pd
import numpy as np
from tqdm import tqdm #显示进度条
import torch
from torch.nn.utils.rnn import pad_sequence
#填充序列保证向量中各序列维度的大小一样MAX_LENGTH 128 #定义最大序列长度为128
训练集制作
def get_train(model_name, model_dict):model_index model_dict[model_name] # 获取模型索引train pd.read_csv(./dataset/train.csv) #读取训练数据为DataFrametrain[content] train[title] train[author] train[abstract] #将标题、作者和摘要拼接为训练内容tokenizer AutoTokenizer.from_pretrained(model_name, max_lengthMAX_LENGTH, cache_dirf./premodels/{model_name}_saved) # 实例化分词器对象# 通过分词器对训练数据进行分词并获取输入ID、注意力掩码和标记类型ID这个可有可无input_ids_list, attention_mask_list, token_type_ids_list [], [], []y_train [] # 存储训练数据的标签for i in tqdm(range(len(train[content]))): # 遍历训练数据sample train[content][i] # 获取样本内容tokenized tokenizer(sample, truncationlongest_first) #分词处理【最长优先方式】截断input_ids, attention_mask tokenized[input_ids], tokenized[attention_mask] # 获取输入ID和注意力掩码input_ids, attention_mask torch.tensor(input_ids), torch.tensor(attention_mask) # 转换为PyTorch张量try:token_type_ids tokenized[token_type_ids] # 获取标记类型IDtoken_type_ids torch.tensor(token_type_ids) # 转换为PyTorch张量except:token_type_ids input_ids #异常处理input_ids_list.append(input_ids) # 将输入ID添加到列表中attention_mask_list.append(attention_mask) # 将注意力掩码添加到列表中token_type_ids_list.append(token_type_ids) # 将标记类型ID添加到列表中y_train.append(train[label][i]) # 将训练数据的标签添加到列表中# 保存 对下述对象进行填充保证向量中各序列维度的大小一样生成张量# 输入 ID input_ids_tensor、# 注意力掩码 attention_mask_tensor# 标记类型ID token_type_ids_tensorinput_ids_tensor pad_sequence(input_ids_list, batch_firstTrue, padding_value0)attention_mask_tensor pad_sequence(attention_mask_list, batch_firstTrue, padding_value0)token_type_ids_tensor pad_sequence(token_type_ids_list, batch_firstTrue, padding_value0) x_train torch.stack([input_ids_tensor, attention_mask_tensor, token_type_ids_tensor], dim1) # 将输入张量堆叠为一个张量x_train x_train.numpy() # 转换为NumPy数组ndarraynp.save(f./models_input_files/x_train{model_index}.npy, x_train) #保存训练数据y_train np.array(y_train) # 转换为NumPy数组ndarraynp.save(f./models_input_files/y_train{model_index}.npy, y_train) #保存标签数据
测试集制作
def get_test(model_name, model_dict):model_index model_dict[model_name] # 获取模型索引test pd.read_csv(./dataset/testB.csv) # 从CSV文件中读取测试数据为DataFrametest[content] test[title] test[author] test[abstract] # 将标题、作者和摘要拼接为测试内容tokenizer AutoTokenizer.from_pretrained(model_name, max_lengthMAX_LENGTH,cache_dirf./premodels/{model_name}_saved) # 实例化分词器对象# 通过分词器对测试数据进行分词创建输入ID、注意力掩码和标记类型ID列表进行记录可有可无input_ids_list, attention_mask_list, token_type_ids_list [], [], []for i in tqdm(range(len(test[content]))): # 遍历测试数据sample test[content][i] # 获取样本内容tokenized tokenizer(sample, truncationlongest_first) # 分词处理使用最长优先方式截断input_ids, attention_mask tokenized[input_ids], tokenized[attention_mask] # 获取输入ID和注意力掩码input_ids, attention_mask torch.tensor(input_ids), torch.tensor(attention_mask) # 转换为PyTorch张量try:token_type_ids tokenized[token_type_ids] # 获取标记类型IDtoken_type_ids torch.tensor(token_type_ids) # 转换为PyTorch张量except:token_type_ids input_ids #异常处理input_ids_list.append(input_ids) # 将输入ID添加到列表中attention_mask_list.append(attention_mask) # 将注意力掩码添加到列表中token_type_ids_list.append(token_type_ids) # 将标记类型ID添加到列表中# 保存对输入ID、注意力掩码、标记类型ID进行填充保证向量中各序列维度的大小一样生成张量input_ids_tensor pad_sequence(input_ids_list, batch_firstTrue, padding_value0) attention_mask_tensor pad_sequence(attention_mask_list, batch_firstTrue, padding_value0)token_type_ids_tensor pad_sequence(token_type_ids_list, batch_firstTrue, padding_value0) x_test torch.stack([input_ids_tensor, attention_mask_tensor, token_type_ids_tensor], dim1) # 将输入张量堆叠为一个张量x_test x_test.numpy() # 转换为NumPy数组np.save(f./models_input_files/x_test{model_index}.npy, x_test) # 保存测试数据
划分训练集和验证集
def split_train(model_name, model_dict):# 训练集:验证集 9 : 1split_rate 0.90# 处理样本内容model_index model_dict[model_name] # 获取模型索引train np.load(f./models_input_files/x_train{model_index}.npy) # 加载训练数据state np.random.get_state() # 获取随机数状态保证样本间的随机是可重复的# 或者也可以设置经典随机种子random_seed42np.random.shuffle(train) # 随机打乱训练数据数据洗牌val train[int(train.shape[0] * split_rate):] # 划分验证集 validationtrain train[:int(train.shape[0] * split_rate)] # 划分训练集 train setnp.save(f./models_input_files/x_train{model_index}.npy, train) # 保存训练集np.save(f./models_input_files/x_val{model_index}.npy, val) # 保存验证集train np.load(f./models_input_files/y_train{model_index}.npy) # 加载标签数据# 处理样本标签np.random.set_state(state) # 恢复随机数状态让样本标签的随机可重复np.random.shuffle(train) # 随机打乱标签数据val train[int(train.shape[0] * split_rate):] # 划分验证集 validationtrain train[:int(train.shape[0] * split_rate)] # 划分训练集 train setnp.save(f./models_input_files/y_train{model_index}.npy, train) # 保存训练集标签np.save(f./models_input_files/y_val{model_index}.npy, val) # 保存验证集标签print(split done.)
数据处理主函数
if __name__ __main__:model_dict {xlm-roberta-base:1,roberta-base:2, bert-base-uncased:3, microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract-fulltext:4, dmis-lab/biobert-base-cased-v1.2:5, marieke93/MiniLM-evidence-types:6,microsoft/MiniLM-L12-H384-uncased:7, cambridgeltl/SapBERT-from-PubMedBERT-fulltext:8,microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract:9,microsoft/BiomedNLP-PubMedBERT-large-uncased-abstract:10}model_name roberta-baseget_train(model_name, model_dict) #读取训练集get_test(model_name, model_dict) #读取测试集split_train(model_name, model_dict) #划分训练集和测试集 ② 模型训练
导入需要的模块
import numpy as np
import torch
import torch.nn as nn
from sklearn import metrics
import os
import time
from transformers import AutoModel, AutoConfig
# 导入AutoModel和AutoConfig类用于加载预训练模型
from tqdm import tqdm #显示进度条超参数类可修改的所有超参数
class opt:seed 42 # 随机种子batch_size 16 # 批处理大小set_epoch 5 # 训练轮数 early_stop 5 # 提前停止epoch数learning_rate 1e-5 # 学习率weight_decay 2e-6 # 权重衰减,L2正则化device torch.device(cuda if torch.cuda.is_available() else cpu) # 选择设备,GPU或CPUgpu_num 1 # GPU个数use_BCE False # 是否使用BCE损失函数models [xlm-roberta-base, roberta-base, bert-base-uncased, microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract-fulltext, dmis-lab/biobert-base-cased-v1.2, marieke93/MiniLM-evidence-types, microsoft/MiniLM-L12-H384-uncased,cambridgeltl/SapBERT-from-PubMedBERT-fulltext, microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract,microsoft/BiomedNLP-PubMedBERT-large-uncased-abstract] # 模型名称列表model_index 2 # 根据上面选择使用的模型这里填对应的模型索引model_name models[model_index-1] # 使用的模型名称continue_train False # 是否继续训练show_val False # 是否显示验证过程定义模型类
# 定义模型
class MODEL(nn.Module):def __init__(self, model_index):super(MODEL, self).__init__()# 若是第一次下载权重则下载至同级目录的./premodels/内以防占主目录的存储空间self.model AutoModel.from_pretrained(opt.models[model_index-1], cache_dir./premodels/opt.models[model_index-1]_saved, from_tfFalse) # 加载预训练语言模型# 加载模型配置可以直接获得模型最后一层的维度而不需要手动修改config AutoConfig.from_pretrained(opt.models[model_index-1], cache_dir./premodels/opt.models[model_index-1]_saved) # 获取配置last_dim config.hidden_size # 最后一层的维度if opt.use_BCE:out_size 1 # 损失函数如果使用BCE,则输出大小为1else :out_size 2 # 否则则使用CE,输出大小为2feature_size 128 # 设置特征的维度大小self.fc1 nn.Linear(last_dim, feature_size) # 全连接层1self.fc2 nn.Linear(last_dim, feature_size) # 全连接层2self.classifier nn.Linear(feature_size, out_size) # 分类器self.dropout nn.Dropout(0.3) # Dropout层def forward(self, x): #BPinput_ids, attention_mask, token_type_ids x[:,0],x[:,1],x[:,2] # 获取输入x self.model(input_ids, attention_mask) # 通过模型all_token x[0] # 全部序列分词的表征向量pooled_output x[1] # [CLS]的表征向量一个全连接层Tanh激活函数feature1 all_token.mean(dim1) # 对全部序列分词的表征向量取均值feature1 self.fc1(feature1) # 再输入进全连接层得到feature1feature2 pooled_output # [CLS]的表征向量一个全连接层Tanh激活函数feature2 self.fc2(feature2) # 再输入进全连接层得到feature2feature 0.5*feature1 0.5*feature2 # 加权融合特征feature self.dropout(feature) # Dropoutx self.classifier(feature) # 分类return x 数据加载
def load_data():#数据集路径train_data_path fmodels_input_files/x_train{model_index}.npytrain_label_path fmodels_input_files/y_train{model_index}.npyval_data_path fmodels_input_files/x_val{model_index}.npy# 验证集val_label_path fmodels_input_files/y_val{model_index}.npy# 验证集标签test_data_path fmodels_input_files/x_test{model_index}.npy# 测试集输入#数据集读取#datatorch.tensor([path],allow_pickleTrue).tolist())train_data torch.tensor(np.load(train_data_path , allow_pickleTrue).tolist())train_label torch.tensor(np.load(train_label_path , allow_pickleTrue).tolist()).long() val_data torch.tensor(np.load(val_data_path , allow_pickleTrue).tolist()) val_label torch.tensor(np.load(val_label_path , allow_pickleTrue).tolist()).long()test_data torch.tensor(np.load(test_data_path , allow_pickleTrue).tolist()) #构造训练集、验证集、测试集train_dataset torch.utils.data.TensorDataset(train_data , train_label) val_dataset torch.utils.data.TensorDataset(val_data , val_label) test_dataset torch.utils.data.TensorDataset(test_data) return train_dataset, val_dataset, test_dataset # 返回数据集
模型预训练
def model_pretrain(model_index, train_loader, val_loader):# 超参数设置set_epoch opt.set_epoch # 训练轮数early_stop opt.early_stop # 提前停止epoch数learning_rate opt.learning_rate # 学习率weight_decay opt.weight_decay # 权重衰减device opt.device # 设备 gpu_num opt.gpu_num # GPU个数continue_train opt.continue_train # 是否继续训练model_save_dir checkpoints # 模型保存路径# 是否要继续训练若是则加载模型进行训练若否则跳过训练直接对测试集进行推理if not continue_train:# 判断最佳模型是否已经存在,若存在则直接读取,若不存在则进行训练if os.path.exists(fcheckpoints/best_model{model_index}.pth): best_model MODEL(model_index)best_model.load_state_dict(torch.load(fcheckpoints/best_model{model_index}.pth)) # 加载模型return best_modelelse:pass# 模型初始化model MODEL(model_index).to(device) if continue_train:model.load_state_dict(torch.load(fcheckpoints/best_model{model_index}.pth)) # 继续训练加载模型# 优化器初始化if device ! cpu and gpu_num 1: # 多张显卡optimizer torch.optim.AdamW(model.module.parameters(), lrlearning_rate, weight_decayweight_decay)optimizer torch.nn.DataParallel(optimizer, device_idslist(range(gpu_num))) # 多GPUelse: # 单张显卡optimizer torch.optim.AdamW(model.parameters(), lrlearning_rate, weight_decayweight_decay) # 单GPU# 损失函数初始化if opt.use_BCE:loss_func nn.BCEWithLogitsLoss() # BCE损失else:loss_func nn.CrossEntropyLoss() # 交叉熵损失CE# 模型训练best_epoch 0 # 最佳epochbest_train_loss 100000 # 最佳训练损失train_acc_list [] # 训练准确率列表train_loss_list [] # 训练损失列表val_acc_list [] # 验证准确率列表 val_loss_list [] # 验证损失列表start_time time.time() # 训练开始时间for epoch in range(set_epoch): # 轮数model.train() # 模型切换到训练模式train_loss 0 # 训练损失train_acc 0 # 训练准确率for x, y in tqdm(train_loader): # 遍历训练集# 训练前先将数据放到GPU上x x.to(device)y y.to(device)outputs model(x) # 前向传播if opt.use_BCE: # BCE损失loss loss_func(outputs, y.float().unsqueeze(1)) else: # 交叉熵损失loss loss_func(outputs, y)train_loss loss.item() # 累加训练损失optimizer.zero_grad() # 清空梯度loss.backward() # 反向传播if device ! cpu and gpu_num 1: # 多GPU更新optimizer.module.step() else:optimizer.step() # 单GPU更新if not opt.use_BCE: # 非BCE损失_, predicted torch.max(outputs.data, 1) # 预测结果else:predicted (outputs 0.5).int() # 预测结果predicted predicted.squeeze(1) train_acc (predicted y).sum().item() # 计算训练准确率average_mode binary# 计算F1、Precision、Recalltrain_f1 metrics.f1_score(y.cpu(), predicted.cpu(), averageaverage_mode)train_pre metrics.precision_score(y.cpu(), predicted.cpu(), averageaverage_mode)train_recall metrics.recall_score(y.cpu(), predicted.cpu(), averageaverage_mode)train_loss / len(train_loader) # 平均所有步数的训练损失作为一个epoch的训练损失train_acc / len(train_loader.dataset) # 平均所有步数训练准确率作为一个epoch的准确率train_acc_list.append(train_acc) # 添加训练准确率train_loss_list.append(train_loss) # 添加训练损失print(-*50)print(Epoch [{}/{}]\n Train Loss: {:.4f}, Train Acc: {:.4f}.format(epoch 1, set_epoch, train_loss, train_acc))print(Train-f1: {:.4f}, Train-precision: {:.4f} Train-recall: {:.4f}.format(train_f1, train_pre, train_recall))if opt.show_val: # 显示验证过程# 验证model.eval() # 模型切换到评估模式val_loss 0 # 验证损失val_acc 0 # 验证准确率for x, y in tqdm(val_loader): # 遍历验证集# 训练前先将数据放到GPU上x x.to(device) y y.to(device)outputs model(x) # 前向传播if opt.use_BCE: # BCE损失loss loss_func(outputs, y.float().unsqueeze(1))else: # 交叉熵损失 loss loss_func(outputs, y)val_loss loss.item() # 累加验证损失if not opt.use_BCE: # 非BCE损失_, predicted torch.max(outputs.data, 1) else:predicted (outputs 0.5).int() # 预测结果predicted predicted.squeeze(1)val_acc (predicted y).sum().item() # 计算验证准确率#计算F1、Precision、Recallval_f1 metrics.f1_score(y.cpu(), predicted.cpu(), averageaverage_mode)val_pre metrics.precision_score(y.cpu(), predicted.cpu(), averageaverage_mode)val_recall metrics.recall_score(y.cpu(), predicted.cpu(), averageaverage_mode)val_loss / len(val_loader) # 平均验证损失val_acc / len(val_loader.dataset) # 平均验证准确率val_acc_list.append(val_acc) # 添加验证准确率val_loss_list.append(val_loss) # 添加验证损失print(\nVal Loss: {:.4f}, Val Acc: {:.4f}.format(val_loss, val_acc))print(Val-f1: {:.4f}, Val-precision: {:.4f} Val-recall: {:.4f}.format(val_f1, val_pre, val_recall))if train_loss best_train_loss: # 更新最佳训练损失best_train_loss train_lossbest_epoch epoch 1if device cuda and gpu_num 1: # 多GPU保存模型torch.save(model.module.state_dict(), f{model_save_dir}/best_model{model_index}.pth)else:torch.save(model.state_dict(), f{model_save_dir}/best_model{model_index}.pth) # 单GPU保存模型# 提前停止判断if epoch1 - best_epoch early_stop: print(f{early_stop} epochs later, the loss of the validation set no longer continues to decrease, so the training is stopped early.)end_time time.time()print(fTotal time is {end_time - start_time}s.)breakbest_model MODEL(model_index) # 初始化最佳模型best_model.load_state_dict(torch.load(fcheckpoints/best_model{model_index}.pth)) # 加载模型参数return best_model # 返回最佳模型
模型推理
def model_predict(model, model_index, test_loader):device cudamodel.to(device) # 模型到GPUmodel.eval() # 切换到评估模式test_outputs Nonewith torch.no_grad(): # 禁用梯度计算for i, data in enumerate(tqdm(test_loader)):data data[0].to(device) # 测试数据到GPUoutputs model(data) # 前向传播if i 0: test_outputs outputs # 第一个batch直接赋值else:test_outputs torch.cat([test_outputs, outputs], dim0) # 其余batch拼接del data, outputs # 释放不再需要的Tensor# 保存预测结果 if not opt.use_BCE: test_outputs torch.softmax(test_outputs, dim1) # 转换为概率torch.save(test_outputs, f./models_prediction/{model_index}_prob.pth) # 保存概率
模型训练主函数
def run(model_index):# 固定随机种子seed opt.seed torch.seed seednp.random.seed(seed)torch.manual_seed(seed)torch.cuda.manual_seed(seed)torch.cuda.manual_seed_all(seed)torch.backends.cudnn.deterministic Truetrain_dataset, val_dataset, test_dataset load_data() # 加载数据集# 打印数据集信息print(-数据集信息:)print(f-训练集样本数:{len(train_dataset)},测试集样本数:{len(test_dataset)})train_labels len(set(train_dataset.tensors[1].numpy()))# 查看训练样本类别均衡状况print(f-训练集的标签种类个数为:{train_labels}) numbers [0] * train_labelsfor i in train_dataset.tensors[1].numpy():numbers[i] 1print(f-训练集各种类样本的个数:)for i in range(train_labels):print(f-{i}的样本个数为:{numbers[i]})batch_size opt.batch_size # 批处理大小# 构建DataLoadertrain_loader torch.utils.data.DataLoader(datasettrain_dataset, batch_sizebatch_size, shuffleTrue) val_loader torch.utils.data.DataLoader(datasetval_dataset, batch_sizebatch_size, shuffleTrue)test_loader torch.utils.data.DataLoader(datasettest_dataset, batch_sizebatch_size, shuffleFalse)best_model model_pretrain(model_index, train_loader, val_loader)# 使用验证集评估模型model_predict(best_model, model_index, test_loader) # 模型推理if __name__ __main__:model_index opt.model_index # 获取模型索引run(model_index) # 运行程序 ③ 模型评估
import torch
import pandas as pd
from models_training import MODEL # 从本地文件models_training.py中导入MODEL类
from tqdm import tqdm
from sklearn.metrics import classification_report
import numpy as np# 推理
def inference(model_indexs, use_BCE):device cuda # 设备选择为cudafor model_index in model_indexs:# 加载模型model MODEL(model_index).to(device) # 创建MODEL类的实例并将模型移至设备(device)model.load_state_dict(torch.load(fcheckpoints/best_model{model_index}.pth)) # 加载模型的权重参数model.eval() # 切换到评估模式# 加载val数据val_data_path fmodels_input_files/x_val{model_index}.npy # val数据的路径val_data torch.tensor(np.load(val_data_path, allow_pickleTrue).tolist()) # 加载val数据并转换为Tensor格式val_dataset torch.utils.data.TensorDataset(val_data) # 创建val数据集val_loader torch.utils.data.DataLoader(datasetval_dataset, batch_size32, shuffleFalse) # 创建val数据的数据加载器val_outputs None # 初始化val_outputs变量with torch.no_grad(): # 禁用梯度计算for i, data in enumerate(tqdm(val_loader)): # 遍历val_loader显示进度条data data[0].to(device) # 将数据移至GPUoutputs model(data) # 模型推理获取输出if i 0:val_outputs outputs # 若为第一次迭代直接赋值给val_outputselse:val_outputs torch.cat([val_outputs, outputs], dim0) # 否则在dim0上拼接val_outputs和outputsdel data, outputs # 释放不再需要的Tensor对象# 输出预测概率if not use_BCE:val_outputs torch.softmax(val_outputs, dim1) # 对val_outputs进行softmax操作torch.save(val_outputs, fevaluate_prediction/{model_index}_prob.pth) # 保存预测概率结果def run(model_indexs, use_BCE):# 读取所有的model_prob.pth并全加在一起avg_pred None # 初始化avg_pred变量for i in model_indexs:pred torch.load(fevaluate_prediction/{i}_prob.pth).data # 加载预测概率结果if use_BCE:# 选取大于0.5的作为预测结果pred (pred 0.5).int() # 将大于0.5的值转换为整数0或1pred pred.reshape(-1) # 将预测结果进行形状重塑else:# 选取最大的概率作为预测结果pred torch.argmax(pred, dim1) # 获取最大概率的索引作为预测结果pred pred.cpu().numpy() # 将预测结果转移到CPU上并转换为NumPy数组# to_evaluate# 读取真实标签val_label_path fmodels_input_files/y_val{i}.npy # 真实标签的路径y_true np.load(val_label_path) # 加载真实标签# 分类报告print(fmodel_index {i}:)print(classification_report(y_true, pred, digits4)) # 打印分类报告包括精确度、召回率等指标zero_acc 0; one_acc 0 # 初始化0类和1类的准确率zero_num 0; one_num 0 # 初始化0类和1类的样本数量for i in range(pred.shape[0]):if y_true[i] 0:zero_num 1 # 统计0类的样本数量elif y_true[i] 1:one_num 1 # 统计1类的样本数量if pred[i] y_true[i]:if pred[i] 0:zero_acc 1 # 统计0类的正确预测数量elif pred[i] 1:one_acc 1 # 统计1类的正确预测数量zero np.sum(pred 0) / pred.shape[0] # 计算预测为0类的样本占比zero_acc / zero_num # 计算0类的正确率print(f预测0类占比{zero} 0类正确率{zero_acc})one np.sum(pred 1) / pred.shape[0] # 计算预测为1类的样本占比one_acc / one_num # 计算1类的正确率print(f预测1类占比{one} 1类正确率{one_acc})print(- * 80)if __name__ __main__:use_BCE False # 是否使用BCE损失函数的标志这里我只用交叉熵CE所以是Falseinference([2], use_BCEuse_BCE) # 进行推理传入模型索引和use_BCE标志model_indexs [2] # 模型索引列表run(model_indexs, use_BCEuse_BCE) # 进行运行传入模型索引和use_BCE标志 ④ 测试集推理
import torch
import pandas as pd
import warnings # 过滤警告
warnings.filterwarnings(ignore)def run(model_indexs, use_BCE):# 记录模型数量model_num len(model_indexs)# 读取所有的model_prob.pth并全加在一起for i in model_indexs:# 加载模型在训练完成后对测试集推理所得的预测文件pred torch.load(f./models_prediction/{i}_prob.pth, map_locationcpu).data# 这里的操作是将每个模型对测试集推理的概率全加在一起if i model_indexs[0]:avg_pred predelse:avg_pred pred# 取平均avg_pred / model_num # 使用全加在一起的预测概率除以模型数量if use_BCE:# 选取概率大于0.5的作为预测结果pred (avg_pred 0.5).int()pred pred.reshape(-1)else:# 后处理 - 根据标签数目的反馈对预测阈值进行调整pred[:, 0][pred[:, 0]0.001] 1pred[:, 1][pred[:, 1]0.999] 1.2# 选取最大的概率作为预测结果pred torch.argmax(avg_pred, dim1)pred pred.cpu().numpy()# to_submit# 读取test.csv文件test pd.read_csv(./dataset/testB_submit_exsample.csv)# 开始写入预测结果for i in range(len(pred)):test[label][i] pred[i]print(test[label].value_counts())# 保存为提交文件test.to_csv(fsubmit.csv,indexFalse)if __name__ __main__:run([2], use_BCEFalse)# run([1,2,3,4,5,6,7,8,9,10], use_BCEFalse)模型优化的思路
超参数调整、最大序列长度调整、损失函数更改、模型参数冻结
特征工程、模型集成、对比学习、提示学习サ ChatGML2-6B
LLMs自回归模型
Pretrained prompt、finetune RLHF 强化对齐学习 LoRA低秩适应冻结预训练好的模型权重参数在冻结原模型参数的情况下通过往模型中加入额外的网络层并只训练这些新增的网络层参数。
「instruction -- 」「input: X」「output: Y」
P-tuning v2在原有的大型语言模型上添加一些新的参数这些新的参数可以帮助模型更好地理解和处理特定的任务。
微调应用垂直领域、个性化 在阿里云Pytorch环境中克隆代码、下载chatglm2-6b模型
安装依赖并且运行训练脚本。
xfg_train.sh
CUDA_VISIBLE_DEVICES0 python src/train_bash.py \--model_name_or_path chatglm2-6b \ 本地模型的目录--stage sft \ 微调方法--use_v2 \ 使用glm2模型微调默认值true--do_train \ 是否训练默认值true--dataset paper_label \ 数据集名字--finetuning_type lora \ --lora_rank 8 \ LoRA 微调中的秩大小--output_dir ./output/label_xfg \ 输出lora权重存放目录--per_device_train_batch_size 4 \ 用于训练的批处理大小--gradient_accumulation_steps 4 \ 梯度累加次数--lr_scheduler_type cosine \--logging_steps 10 \ 日志输出间隔--save_steps 1000 \ 断点保存间隔--learning_rate 5e-5 \ 学习率--num_train_epochs 4.0 \ 训练轮数--fp16 是否使用 fp16 半精度 默认值False
导入数据
import pandas as pd
train_df pd.read_csv(./csv_data/train.csv)
testB_df pd.read_csv(./csv_data/testB.csv)
制作数据集
res [] #存储数据样本for i in range(len(train_df)):# 遍历训练数据的每一行paper_item train_df.loc[i] # 获取当前行的数据# 创建一个字典包含LoRA的指令、输入和输出信息tmp {instruction: Please judge whether it is a medical field paper according to the given paper title and abstract, output 1 or 0, the following is the paper title and abstract --,input: ftitle:{paper_item[1]},abstract:{paper_item[3]},output: str(paper_item[5])}res.append(tmp) # 将字典添加到结果列表中import json #用于保存数据集# 将制作好的数据集保存到data目录下
with open(./data/paper_label.json, modew, encodingutf-8) as f:json.dump(res, f, ensure_asciiFalse, indent4)
修改data/data_info.json
{paper_label: {file_name: paper_label.json}
}
加载训练好的LoRA权重进行预测
from peft import PeftModel
from transformers import AutoTokenizer, AutoModel, GenerationConfig, AutoModelForCausalLM# 定义预训练模型的路径
model_path ../chatglm2-6b
model AutoModel.from_pretrained(model_path, trust_remote_codeTrue).half().cuda()
tokenizer AutoTokenizer.from_pretrained(model_path, trust_remote_codeTrue)# 加载 label lora权重
model PeftModel.from_pretrained(model, ./output/label_xfg).half()
model model.eval()# 使用加载的模型和分词器进行聊天生成回复
response, history model.chat(tokenizer, 你好, history[])
response
预测函数
def predict(text):# 使用加载的模型和分词器进行聊天生成回复response, history model.chat(tokenizer, fPlease judge whether it is a medical field paper according to the given paper title and abstract, output 1 or 0, the following is the paper title and abstract --{text}, history[],temperature0.01)return response
预测导出csv
from tqdm import tqdm #预测过程的进度条label [] #存储预测结果for i in tqdm(range(len(testB_df))): # 遍历测试集中的每一条样本test_item testB_df.loc[i] # 测试集中的每一条样本# 构建预测函数的输入prompttest_input ftitle:{test_item[1]},author:{test_item[2]},abstract:{test_item[3]}label.append(int(predict(test_input)))# 预测结果存入lable列表testB_df[label] label # 把label列表存入testB_df# task1虽然只需要label但需要有一个keywords列用个随意的字符串代替
testB_df[Keywords] [tmp for _ in range(2000)]# 制作submit提交submit
submit testB_df[[uuid, Keywords, label]]
submit.to_csv(submit.csv, indexFalse)
提交结果 ライト
