2024-3-6 Bert模型代码总结

        值得注意的是Bert和transformer之间的区别：transformer是一种新型的神经网络架构，而Bert只是这个encoder-decoder中的encoder，

        

from transformers import BertModel, BertTokenizer,BertConfig

1. 从transformers中调入bert

class MyModel(nn.Module):

2. 开始写模型类

    def __init__(self,bert_path, device, num_class):
        super(MyModel, self).__init__()
        self.device = device

        # #不加载大佬的模型文件，只用其参数
        # bert_config = BertConfig.from_pretrained(bert_path)
        # self.bert = BertModel(bert_config)


        self.bert = BertModel.from_pretrained(bert_path)   #根据所传的下载的文件，可以直接读出模型所需的各种参数，就可以创建模型
        self.tokenizer = BertTokenizer.from_pretrained(bert_path)

        self.cls_head = nn.Linear(768,num_class)  #我们的模型=大佬的Bert（encoder） + 微调分类头   我们做的是二分类

3. 模型初始化函数：对原父类的初始化进行改写，self.xxx表示将xxx变为类本身的属性，用调用函数从指定文件调用Bert的结构和参数，并加上自己的分类头，即微调

    def forward(self,text):
        input = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=128, padding="max_length")
        input_ids = input["input_ids"].to(self.device)    #分词器返回一个字典，可以调试另一个文件来查看
        token_type_ids = input["token_type_ids"].to(self.device)
        attention_mask = input["attention_mask"].to(self.device)

        sequence_out, pooler_out = self.bert(     #sequence是encoder之后的，pooler是pool之后的   pool实际上只取了第一个cls的token
                                    input_ids = input_ids
                                    ,token_type_ids = token_type_ids
                                    ,attention_mask = attention_mask
                                    ,return_dict = False    #输出是否要以字典的形式返回
                                )   #分离出来的input_ids,token_type_ids,attention_mask
        out = self.cls_head(pooler_out)   #我们只需要pooler out部分
        return out

 4. 前向过程函数：将我们的文本输入分词器，分词器的几个参数的意思是：传入的文本，返回为张量，允许截断，最大长度为128，padding成128，即不够的填充，多余的截断，得到Bert需要的三类输入，但其实返回的是一个字典，我们从字典中取出输入，并放在gpu上，然后传入Bert中，得到两种输出，分别是未池化和池化后的，我们只要池化之后的，所谓池化在这里只是取第一个token，然后将这个token通过我们的分类头，得到输出

        接下来是数据处理

def read_txt(path):
    data = []
    label = []
    with open(path, "r",encoding="utf-8") as f:
        for i, line in enumerate(f):
            if i == 0:
                continue
            if i>200 and i<7500:   #读所有数据太慢
                continue
            line = line.strip("\n")   #删除两端的换行符
            line = line.split(",",1)    #用第一个参数将一行分开，只分一次，并返回一个列表
            label.append(line[0])
            data.append(line[1])

    return data,label

5.   读文本函数：定义两个列表，将文本以utf-8的编码格式打开，i是读出来的数据的下标，line为这条数据。第一行数据我们不要，我们需要的数据中，再做处理，删除两端的换行符，因为每行的格式实际上是1.xxxxxxxx，1是标签，xxxx为文本数据，我们将二者分开之后，分别存储在列表中，最后返回

class JdDataset(Dataset):
    def __init__(self,data,label):
        self.x = data
        self.y = [int(i) for i in label]   #字符串无法处理，转为整型
        self.y = torch.LongTensor(self.y)   #分类项目转为长整形 必须的

    def __getitem__(self,item):
        return self.x[item],self.y[item]

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

6.  数据集类： 将读出的data和label送给数据集初始化，将data转化成x，将label中的字符数字转化为可以处理的整形类型，并转化为长整型

def get_data_loader(path,batch_size, val_size=0.2):   #验证集比例
    data, label = read_txt(path)
    train_x, val_x, train_y, val_y = train_test_split(data, label,test_size=val_size, shuffle=True, stratify=label)   #将一整坨的数据分为训练集和验证集
    train_set = JdDataset(train_x, train_y)
    val_set = JdDataset(val_x, val_y)
    train_loader = DataLoader(train_set, batch_size)
    val_loader = DataLoader(val_set,batch_size)

    return train_loader, val_loader

7.  数据加载函数： 将数据读出来，将这一整个数据分为训练集和验证集，按我们传入的比例，再生成两个数据集，再生成数据加载器

        接下来是main函数里的

train_loader, val_loader = get_data_loader(data_path, batch_size=batchSize)

model = MyModel(bert_path, device, num_class).to(device)

8. 从这里开始，当我们要得到数据加载器时，这个函数就会调用数据集类和get-loader函数。

trainpara = {'model': model,
             'train_loader': train_loader,
             'val_loader': val_loader,
             'scheduler': scheduler,
             'optimizer': optimizer,
             'learning_rate': learning_rate,
             'warmup_ratio' : 0.1,
             'weight_decay' : 0.0001,
             'use_lookahead' : True,
             'loss': loss,
             'epoch': epoch,
             'device': device,
             'save_path': save_path,
             'max_acc': 0.85,
             'val_epoch' : 1
             }
train_val(trainpara)

9. 训练流程和之前的训练流程一样，超参数的定义省略