生成任务，大模型

一个生成项目

输入：文字描述（但是给的数据集是一串数字，id，ct描述，医生描述）
输出：诊断报告

一、数据处理

import pandas as pd  #处理表格数据pre_train_file= "data/train.csv"train_df = pd.read_csv(pre_train_file,header=None,names=["id","input","tgt"]) #读入数据print(train_df.head())train_data = train_df.sample(frac=0.9, random_state=0, axis=0)   #采样0.9的比例val_data = train_df[~train_df.index.isin(train_data.index)]       #干啥的，  过来用train_data.to_csv("data/pro_train_data.csv", index=False,header=False)val_data.to_csv("data/pro_val_data.csv", index=False,header=False)

主要是用于从一个CSV文件中读取数据，并将其划分为训练集和验证集，然后将这两个数据集分别保存到新的CSV文件中。

代码逐行解释

导入必要的库

import pandas as pd  # 处理表格数据

pandas：一个强大的数据分析和处理库，特别适合处理表格数据（如CSV文件）。

定义文件路径并读取数据

pre_train_file = "data/train.csv"train_df = pd.read_csv(pre_train_file, header=None, names=["id", "input", "tgt"])  # 读入数据print(train_df.head())

pre_train_file：指定要读取的CSV文件路径。
pd.read_csv：
- header=None：表示CSV文件没有表头（第一行不是列名）。
- names=["id", "input", "tgt"]：为每一列指定名称。
print(train_df.head())：打印前五行数据，以便检查读取是否正确。

数据划分

train_data = train_df.sample(frac=0.9, random_state=0, axis=0)  # 采样0.9的比例val_data = train_df[~train_df.index.isin(train_data.index)]  # 干啥的， 过来用

train_data：
- 使用 sample 方法随机采样90%的数据作为训练集。
- frac=0.9：表示采样的比例为90%。
- random_state=0：设置随机种子以确保结果可重复。
- axis=0：表示沿行方向进行采样（默认行为）。
val_data：
- 使用 ~train_df.index.isin(train_data.index) 来获取不在训练集中的数据作为验证集。
- isin(train_data.index) 返回一个布尔数组，指示哪些索引在训练集中。
- ~ 取反操作符，返回不在训练集中的索引。

保存数据

train_data.to_csv("data/pro_train_data.csv", index=False, header=False)val_data.to_csv("data/pro_val_data.csv", index=False, header=False)

to_csv 方法：
- 将DataFrame保存为CSV文件。
- index=False：不保存行索引。
- header=False：不保存列名。

二、处理词表

import sys
import torch
from collections import Counter
from transformers import BertTokenizer
from transformers import BartConfig
from transformers import BartForConditionalGeneration
from model_utils.config import parse_argsargs = parse_args()         #设置 ，字典， 属性类  config  {}def load_data(path):with open(path, 'r', encoding='utf-8') as f:lines = f.readlines()datas = []for line in lines:line = line.strip().split(",")if len(line) == 3:# 训练集text, target = line[1].split(" "), line[2].split(" ")datas.append(text + target)else:text = line[1].split(" ")datas.append(text)return datastrain_data = load_data('./data/train.csv')token2count = Counter()     #计数工具 哈希表for i in train_data:token2count.update(i)       #不需要知道原理tail = []
ct = 0
for k, v in token2count.items():if v >= ct:tail.append(k)
tail.sort()
vocab = tailvocab.insert(0,"[PAD]")
vocab.insert(100,"[UNK]")
vocab.insert(101,"[CLS]")
vocab.insert(102,"[SEP]")
vocab.insert(103,"[MASK]")
vocab.insert(104,"[EOS]")
# tokenizer = BertTokenizer.from_pretrained(args.pre_model_path)
# vocabs = tokenizer.get_vocab()   #获取模型词表# new_vocabs = list(vocabs.keys())
# print(len(vocabs))
# count = 0
# for v in vocab:         #mn复杂度
#     if v not in vocabs:
#         count += 1
#         new_vocabs.append(v)
# print(len(new_vocabs))
new_vocabs = vocab
with open(args.pre_model_path+'/vocab.txt', 'w', encoding='utf-8') as f:for v in new_vocabs:f.write(f"{v}\n")    #保存model = BartForConditionalGeneration.from_pretrained(args.pre_model_path)      #模型
model.resize_token_embeddings(len(new_vocabs))
state_dict = model.state_dict()
torch.save(state_dict, args.pre_model_path+'/pytorch_model.bin')
bartconfig = BartConfig.from_pretrained(args.pre_model_path)
bartconfig.vocab_size = len(new_vocabs)
bartconfig.save_pretrained(args.pre_model_path)

1. 导入必要的库

import sys
import torch
from collections import Counter
from transformers import BertTokenizer
from transformers import BartConfig
from transformers import BartForConditionalGeneration
from model_utils.config import parse_args

sys：用于系统相关的操作（如命令行参数）。
torch：PyTorch的核心库，用于深度学习模型。
Counter：来自 collections 模块，用于统计元素出现的次数。
BertTokenizer, BartConfig, BartForConditionalGeneration：来自 transformers 库，分别用于分词、配置和加载预训练模型。
parse_args：自定义函数，用于解析命令行参数或配置文件，返回一个包含配置参数的对象。

2. 解析参数

args = parse_args()  # 设置，字典，属性类 config {}

parse_args：调用自定义函数解析配置参数，并将其存储在 args 对象中。假设 args 包含诸如 pre_model_path 等路径信息。

3. 定义数据加载函数

def load_data(path):with open(path, 'r', encoding='utf-8') as f:lines = f.readlines()datas = []for line in lines:line = line.strip().split(",")if len(line) == 3:# 训练集text, target = line[1].split(" "), line[2].split(" ")datas.append(text + target)else:text = line[1].split(" ")datas.append(text)return datas

load_data 函数：
- 打开指定路径的文件并读取每一行。
- 使用 strip() 去除每行的前后空白字符，并使用 split(",") 将其按逗号分割为列表。
- 如果列表长度为3（假设是训练集），则将第二列和第三列的数据拆分为单词列表，并合并后添加到 datas 列表中。
- 如果列表长度不为3，则仅处理第二列的数据，并将其拆分为单词列表后添加到 datas 列表中。
- 返回 datas 列表。

4. 加载数据

train_data = load_data('./data/train.csv')

调用 load_data 函数加载训练数据，并将结果存储在 train_data 变量中。

5. 统计词频

token2count = Counter()  # 计数工具 哈希表for i in train_data:token2count.update(i)  # 不需要知道原理

token2count：使用 Counter 类创建一个哈希表来统计每个单词出现的次数。
遍历 train_data 中的每一行数据，并使用 update 方法更新 token2count，记录每个单词出现的次数。

6. 创建词汇表

tail = []
ct = 0
for k, v in token2count.items():if v >= ct:tail.append(k)
tail.sort()
vocab = tailvocab.insert(0, "[PAD]")
vocab.insert(100, "[UNK]")
vocab.insert(101, "[CLS]")
vocab.insert(102, "[SEP]")
vocab.insert(103, "[MASK]")
vocab.insert(104, "[EOS]")

tail：筛选出频率大于等于 ct 的单词，并按字母顺序排序。注意这里 ct 设为0，因此所有单词都会被包含进来。
vocab：将 tail 赋值给 vocab。
插入特殊标记：在 vocab 中插入一些特殊的标记符号（如 [PAD], [UNK], [CLS], [SEP], [MASK], [EOS]），这些标记在自然语言处理任务中具有特定含义。

7. 保存词汇表

new_vocabs = vocab
with open(args.pre_model_path + '/vocab.txt', 'w', encoding='utf-8') as f:for v in new_vocabs:f.write(f"{v}\n")  # 保存

new_vocabs：直接赋值为 vocab。
保存词汇表：将词汇表中的每个单词写入 vocab.txt 文件中，文件路径由 args.pre_model_path 指定。

8. 加载预训练模型并调整词汇表大小

model = BartForConditionalGeneration.from_pretrained(args.pre_model_path)  # 模型
model.resize_token_embeddings(len(new_vocabs))
state_dict = model.state_dict()
torch.save(state_dict, args.pre_model_path + '/pytorch_model.bin')bartconfig = BartConfig.from_pretrained(args.pre_model_path)
bartconfig.vocab_size = len(new_vocabs)
bartconfig.save_pretrained(args.pre_model_path)

加载预训练模型：使用 BartForConditionalGeneration.from_pretrained 加载预训练模型。
调整词汇表大小：使用 resize_token_embeddings 方法调整模型的嵌入层大小以适应新的词汇表。
保存模型状态：将模型的状态字典保存到 pytorch_model.bin 文件中，文件路径由 args.pre_model_path 指定。
更新配置：更新 BartConfig 中的 vocab_size 属性，并保存配置。

三、自监督预训练

from model_utils.pre_data import PreTrainDataset, loadData, MLM_Data
from torch.utils.data import DataLoader, Dataset
from model_utils.models import preModel
import logging        #日志
import os
from model_utils.config import parse_args
from model_utils.utils import setup_device, setup_seed, setup_logging, build_optimizer
import torch
import time
# os.environ['CUDA_VISIBLE_DEVICES']='0'def train_and_validate(args):# 1. load data  modelmodel = preModel(args)     #加载预训练模型optimizer, scheduler = build_optimizer(args, model)# model = model.to(args.device)use_pre = Falseif use_pre:checkpoint = torch.load(args.pre_file, map_location='cpu')new_KEY = model.load_state_dict(checkpoint['model_state_dict'],strict=False)if args.device == 'cuda':if args.paral == True:model = torch.nn.parallel.DataParallel(model.to(args.device))else:model = model.to(args.device)# model = BalancedDataParallel(16, model, dim=0).to(args.device)# model = model.to(args.device)#-------ema here-----------------all_data = loadData(args.data_path)train_MLM_data = MLM_Data(all_data, args)train_dataloader = DataLoader(train_MLM_data, batch_size=args.batch_size, shuffle=True,collate_fn=train_MLM_data.collate)step = 0start_time = time.time()num_total_steps = len(train_dataloader) * args.max_epochsfor epoch in range(args.max_epochs):    #开始训练了for batch in train_dataloader:model.train()loss= model(batch)loss = loss.mean()loss.backward()optimizer.step()optimizer.zero_grad()scheduler.step()step += 1if step % args.print_steps == 0:time_per_step = (time.time() - start_time) / max(1, step)remaining_time = time_per_step * (num_total_steps - step)remaining_time = time.strftime('%H:%M:%S', time.gmtime(remaining_time))logging.info(f"Epoch {epoch} step {step} eta {remaining_time}: loss {loss:.3f}")logging.info(f"VAL_Epoch {epoch} step {step}: loss {loss:.3f}")if epoch % 5 == 0:torch.save({'epoch': epoch, 'model_state_dict': model.module.state_dict()},f'{args.savedmodel_path}/lr{args.learning_rate}epoch{epoch}loss{loss:.3f}pre_model.bin')def main():args = parse_args()           #设置   字典setup_logging()setup_device(args)setup_seed(args)os.makedirs(args.savedmodel_path, exist_ok=True)logging.info("Training/evaluation parameters: %s", args)         #LINUXtrain_and_validate(args)if __name__ == '__main__':main()

实现了一个完整的训练和验证流程，包括数据加载、模型初始化、训练循环、日志记录以及模型保存等功能

1. 导入必要的库

from model_utils.pre_data import PreTrainDataset, loadData, MLM_Data
from torch.utils.data import DataLoader, Dataset
from model_utils.models import preModel
import logging        # 日志
import os
from model_utils.config import parse_args
from model_utils.utils import setup_device, setup_seed, setup_logging, build_optimizer
import torch
import time

PreTrainDataset, loadData, MLM_Data：自定义模块，用于数据处理。
DataLoader, Dataset：PyTorch提供的类，用于数据加载和管理。
preModel：自定义模型类。
logging：用于记录日志信息。
os：用于操作系统相关的操作（如文件路径处理）。
parse_args：自定义函数，解析命令行参数或配置文件。
setup_device, setup_seed, setup_logging, build_optimizer：自定义工具函数，分别用于设置设备、随机种子、日志记录和优化器构建。
torch：PyTorch核心库。
time：用于时间相关操作。

2. 定义训练和验证函数

def train_and_validate(args):# 1. 加载数据和模型model = preModel(args)     # 加载预训练模型optimizer, scheduler = build_optimizer(args, model)use_pre = Falseif use_pre:checkpoint = torch.load(args.pre_file, map_location='cpu')new_KEY = model.load_state_dict(checkpoint['model_state_dict'], strict=False)if args.device == 'cuda':if args.paral == True:model = torch.nn.parallel.DataParallel(model.to(args.device))else:model = model.to(args.device)all_data = loadData(args.data_path)train_MLM_data = MLM_Data(all_data, args)train_dataloader = DataLoader(train_MLM_data, batch_size=args.batch_size, shuffle=True, collate_fn=train_MLM_data.collate)step = 0start_time = time.time()num_total_steps = len(train_dataloader) * args.max_epochsfor epoch in range(args.max_epochs):    # 开始训练了for batch in train_dataloader:model.train()loss = model(batch)loss = loss.mean()loss.backward()optimizer.step()optimizer.zero_grad()scheduler.step()step += 1if step % args.print_steps == 0:time_per_step = (time.time() - start_time) / max(1, step)remaining_time = time_per_step * (num_total_steps - step)remaining_time = time.strftime('%H:%M:%S', time.gmtime(remaining_time))logging.info(f"Epoch {epoch} step {step} eta {remaining_time}: loss {loss:.3f}")logging.info(f"VAL_Epoch {epoch} step {step}: loss {loss:.3f}")if epoch % 5 == 0:torch.save({'epoch': epoch, 'model_state_dict': model.module.state_dict()},f'{args.savedmodel_path}/lr{args.learning_rate}epoch{epoch}loss{loss:.3f}pre_model.bin')

解释

加载数据和模型：
- 使用 preModel 类加载预训练模型。
- 使用 build_optimizer 函数构建优化器和学习率调度器。
- 如果 use_pre 为真，则从指定路径加载预训练模型的权重。
- 根据 args.device 和 args.paral 参数决定是否使用多GPU并行训练。
数据加载：
- 使用 loadData 函数加载所有数据。
- 使用 MLM_Data 类将数据转换为适合训练的数据集格式。
- 使用 DataLoader 创建数据加载器，支持批量加载和数据打乱。
训练循环：
- 对每个epoch进行遍历。
- 对每个batch进行前向传播计算损失，反向传播更新权重。
- 记录训练进度和剩余时间，并在特定步数时打印日志。
- 每隔5个epoch保存一次模型。

3. 主函数

def main():args = parse_args()           # 设置   字典setup_logging()setup_device(args)setup_seed(args)os.makedirs(args.savedmodel_path, exist_ok=True)logging.info("Training/evaluation parameters: %s", args)         # LINUXtrain_and_validate(args)if __name__ == '__main__':main()

main 函数：
- 调用 parse_args 解析命令行参数。
- 调用 setup_logging 配置日志记录。
- 调用 setup_device 和 setup_seed 分别设置设备和随机种子。
- 创建保存模型的目录（如果不存在）。
- 打印训练和评估参数。
- 调用 train_and_validate 函数开始训练和验证过程。

四、微调

import logging
import os
import time
import torch
from transformers import PretrainedBartModel
from model_utils.config import parse_args
from model_utils.data import create_dataloaders
from model_utils.models import myModel
from model_utils.score import CiderD, CE
from model_utils.utils import setup_device, setup_seed, setup_logging, build_optimizer,array2str
from torch.cuda.amp import autocast as ac
from tqdm import tqdm as tqdmos.environ['CUDA_VISIBLE_DEVICES']='0'# 不需要完全理解，  知道每一块在做什么就行   知道之后，  以后再用到， 搬过去就行def validate(model, loader, args, output_file=None, beam=1, n=-1):res, gts = [], {}tot = 0for (source, targets) in tqdm(loader):if n>0 and tot>n:breaksource = source.cuda()pred = model(source[:, :args. input_l])pred = pred.cpu().detach().numpy()#print(pred.shape)for i in range(pred.shape[0]):# res.append({'image_id':tot, 'caption': [array2str(pred[i][2:], args)]})# gts[tot] = [array2str(targets[i][1:], args)]res.append({'image_id':tot, 'caption': [array2str(pred[i], args)]})gts[tot] = [array2str(targets[i][1:], args)]tot += 1CiderD_scorer = CiderD(df='corpus', sigma=15)cider_score, cider_scores = CiderD_scorer.compute_score(gts, res)return cider_scoredef train_and_validate(args):# 1. load datatrain_dataloader, val_dataloader = create_dataloaders(args)model = myModel(args)use_pre = Trueif use_pre:print('use_pre')checkpoint = torch.load(args.my_pre_model_path, map_location='cpu')new_KEY = model.load_state_dict(checkpoint['model_state_dict'],strict=True)optimizer, scheduler = build_optimizer(args, model)model = model.to(args.device)#-------ema here-----------------model.train()#-------------------------------# loss, results = validate(model, val_dataloader)# 3. trainingstep = 0best_score = args.best_score     #评估指标  准确率for epoch in range(args.max_epochs):for (source, targets) in tqdm(train_dataloader):source = source.cuda()targets = targets.cuda()model.train()pred = model(source[:, :args. input_l], targets[:, :args.output_l])loss  = CE(pred[:, :-1], targets[:, 1:])loss = loss.mean()loss.backward()optimizer.step()model.zero_grad()scheduler.step()step += 1if epoch % 1 == 0:cider_score = validate(model, val_dataloader, args)logging.info(f"Epoch {epoch} step {step}: loss {loss:.3f}, cider_score {cider_score}")if cider_score >= best_score:best_score = cider_scoretorch.save({'epoch': epoch, 'model_state_dict': model.state_dict()},f'{args.savedmodel_path}/model_epoch_{epoch}_cider_score_{cider_score}.bin')def main():args = parse_args()setup_logging()setup_device(args)setup_seed(args)os.makedirs(args.savedmodel_path, exist_ok=True)logging.info("Training/evaluation parameters: %s", args)train_and_validate(args)if __name__ == '__main__':main()

实现了一个完整的训练和验证流程，包括数据加载、模型初始化、训练循环、验证评估以及模型保存等功能。

1. 导入必要的库

import logging
import os
import time
import torch
from transformers import PretrainedBartModel
from model_utils.config import parse_args
from model_utils.data import create_dataloaders
from model_utils.models import myModel
from model_utils.score import CiderD, CE
from model_utils.utils import setup_device, setup_seed, setup_logging, build_optimizer, array2str
from torch.cuda.amp import autocast as ac
from tqdm import tqdm as tqdmos.environ['CUDA_VISIBLE_DEVICES'] = '0'

logging：用于记录日志信息。
os：用于操作系统相关的操作（如文件路径处理）。
time：用于时间相关操作。
torch：PyTorch核心库。
PretrainedBartModel：来自 transformers 库的预训练模型基类。
parse_args：自定义函数，解析命令行参数或配置文件。
create_dataloaders：自定义函数，创建数据加载器。
myModel：自定义模型类。
CiderD, CE：自定义评分函数，分别用于计算CIDEr-D分数和交叉熵损失。
setup_device, setup_seed, setup_logging, build_optimizer, array2str：自定义工具函数，分别用于设置设备、随机种子、日志记录、构建优化器和数组转字符串。
autocast：用于混合精度训练。
tqdm：用于显示进度条。

2. 定义验证函数

def validate(model, loader, args, output_file=None, beam=1, n=-1):res, gts = [], {}tot = 0for (source, targets) in tqdm(loader):if n > 0 and tot > n:breaksource = source.cuda()pred = model(source[:, :args.input_l])pred = pred.cpu().detach().numpy()for i in range(pred.shape[0]):res.append({'image_id': tot, 'caption': [array2str(pred[i], args)]})gts[tot] = [array2str(targets[i][1:], args)]tot += 1CiderD_scorer = CiderD(df='corpus', sigma=15)cider_score, cider_scores = CiderD_scorer.compute_score(gts, res)return cider_score

解释

输入参数：
- model: 需要验证的模型。
- loader: 数据加载器。
- args: 命令行参数或配置对象。
- output_file: 输出文件路径（可选）。
- beam: 束搜索宽度（可选，默认为1）。
- n: 验证样本数限制（可选，默认为-1，表示不限制）。
逻辑：
- 初始化结果列表 res 和真实标签字典 gts。
- 使用 tqdm 显示进度条遍历数据加载器中的每个批次 (source, targets)。
- 将 source 移动到 GPU 并进行前向传播得到预测结果 pred。
- 将预测结果和真实标签转换为字符串格式并添加到 res 和 gts 中。
- 使用 CiderD 计算预测结果与真实标签之间的 CIDEr-D 分数。
- 返回 CIDEr-D 分数。

3. 定义训练和验证函数

def train_and_validate(args):# 1. load datatrain_dataloader, val_dataloader = create_dataloaders(args)model = myModel(args)use_pre = Trueif use_pre:print('use_pre')checkpoint = torch.load(args.my_pre_model_path, map_location='cpu')new_KEY = model.load_state_dict(checkpoint['model_state_dict'], strict=True)optimizer, scheduler = build_optimizer(args, model)model = model.to(args.device)model.train()step = 0best_score = args.best_score  # 评估指标 准确率for epoch in range(args.max_epochs):for (source, targets) in tqdm(train_dataloader):source = source.cuda()targets = targets.cuda()model.train()pred = model(source[:, :args.input_l], targets[:, :args.output_l])loss = CE(pred[:, :-1], targets[:, 1:])loss = loss.mean()loss.backward()optimizer.step()model.zero_grad()scheduler.step()step += 1if epoch % 1 == 0:cider_score = validate(model, val_dataloader, args)logging.info(f"Epoch {epoch} step {step}: loss {loss:.3f}, cider_score {cider_score}")if cider_score >= best_score:best_score = cider_scoretorch.save({'epoch': epoch, 'model_state_dict': model.state_dict()},f'{args.savedmodel_path}/model_epoch_{epoch}_cider_score_{cider_score}.bin')

解释

加载数据：
- 使用 create_dataloaders 函数加载训练和验证数据加载器。
初始化模型和优化器：
- 使用 myModel 类加载模型。
- 如果 use_pre 为真，则从指定路径加载预训练模型的权重。
- 使用 build_optimizer 函数构建优化器和学习率调度器。
- 将模型移动到指定设备（CPU或GPU）。
训练循环：
- 对每个epoch进行遍历。
- 对每个batch进行前向传播计算损失，反向传播更新权重。
- 每个epoch结束后调用 validate 函数计算验证集上的 CIDEr-D 分数。
- 如果当前 CIDEr-D 分数优于历史最佳分数，则保存模型。

4. 主函数

def main():args = parse_args()  # 设置   字典setup_logging()setup_device(args)setup_seed(args)os.makedirs(args.savedmodel_path, exist_ok=True)logging.info("Training/evaluation parameters: %s", args)  # LINUXtrain_and_validate(args)if __name__ == '__main__':main()

解释

主函数：
- 调用 parse_args 解析命令行参数。
- 调用 setup_logging 配置日志记录。
- 调用 setup_device 和 setup_seed 分别设置设备和随机种子。
- 创建保存模型的目录（如果不存在）。
- 打印训练和评估参数。
- 调用 train_and_validate 函数开始训练和验证过程。

五、inference

from tqdm import tqdm
import csv
from model_utils.utils import to_device, array2str
from model_utils.models import myModel
from model_utils.data import create_dataloaders
import torch
from model_utils.config import parse_argsdef inference(args):test_loader = create_dataloaders(args,test=True)model = myModel(args)print(args.ckpt_file)checkpoint = torch.load(args.ckpt_file, map_location='cpu')model.load_state_dict(checkpoint['model_state_dict'],strict=False)model.to('cuda:0')model.eval()fp = open(args.test_output_csv, 'w', newline='')writer = csv.writer(fp)tot = 0for source in tqdm(test_loader):source = to_device(source, 'cuda:0')pred = model(source)pred = pred.cpu().numpy()for i in range(pred.shape[0]):writer.writerow([tot, array2str(pred[i][2:], args)])tot += 1fp.close()if __name__ == '__main__':args = parse_args()inference(args)

实现了一个推理（inference）流程，包括数据加载、模型加载、前向传播以及结果保存等功能。

1. 导入必要的库

from tqdm import tqdm
import csv
from model_utils.utils import to_device, array2str
from model_utils.models import myModel
from model_utils.data import create_dataloaders
import torch
from model_utils.config import parse_args

tqdm：用于显示进度条。
csv：用于处理CSV文件的读写操作。
to_device：自定义函数，将数据移动到指定设备（CPU或GPU）。
array2str：自定义函数，将数组转换为字符串。
myModel：自定义模型类。
create_dataloaders：自定义函数，创建数据加载器。
torch：PyTorch核心库。
parse_args：自定义函数，解析命令行参数或配置文件。

2. 定义推理函数

def inference(args):test_loader = create_dataloaders(args, test=True)model = myModel(args)print(args.ckpt_file)checkpoint = torch.load(args.ckpt_file, map_location='cpu')model.load_state_dict(checkpoint['model_state_dict'], strict=False)model.to('cuda:0')model.eval()fp = open(args.test_output_csv, 'w', newline='')writer = csv.writer(fp)tot = 0for source in tqdm(test_loader):source = to_device(source, 'cuda:0')pred = model(source)pred = pred.cpu().numpy()for i in range(pred.shape[0]):writer.writerow([tot, array2str(pred[i][2:], args)])tot += 1fp.close()

解释

加载测试数据：
- 使用 create_dataloaders 函数加载测试数据加载器，设置 test=True 表示加载测试集。
初始化模型并加载权重：
- 使用 myModel 类加载模型。
- 打印预训练模型路径 args.ckpt_file。
- 使用 torch.load 加载预训练模型的权重，并使用 load_state_dict 方法加载到模型中。
- 将模型移动到 GPU（cuda:0），并设置为评估模式（model.eval()）。
推理过程：
- 打开输出 CSV 文件，并创建 CSV 写入器。
- 使用 tqdm 显示进度条遍历测试数据加载器中的每个批次 source。
- 将 source 移动到 GPU 并进行前向传播得到预测结果 pred。
- 将预测结果转换为 NumPy 数组，并逐个样本写入 CSV 文件。

3. 主函数

if __name__ == '__main__':args = parse_args()inference(args)

主函数：
- 调用 parse_args 解析命令行参数。
- 调用 inference 函数开始推理过程。

生成任务，大模型

一个生成项目

一、数据处理

代码逐行解释

导入必要的库

定义文件路径并读取数据

数据划分

保存数据

二、处理词表

1. 导入必要的库

2. 解析参数

3. 定义数据加载函数

4. 加载数据

5. 统计词频

6. 创建词汇表

7. 保存词汇表

8. 加载预训练模型并调整词汇表大小

三、自监督预训练

1. 导入必要的库

2. 定义训练和验证函数

解释

3. 主函数

四、微调

1. 导入必要的库

2. 定义验证函数

解释

3. 定义训练和验证函数

解释

4. 主函数

解释

五、inference

1. 导入必要的库

2. 定义推理函数

解释

3. 主函数

相关文章