huggingface实现中文文本分类

目录

1  自定义数据集

2  分词 

 2.1  重写collate_fn方法¶

3  用BertModel加载预训练模型 

 4  模型试算

 5  定义下游任务¶

6  训练 

7  测试 

#导包
import torch
from datasets import load_from_disk  #用于加载本地磁盘的datasets文件

1  自定义数据集

#自定义数据集
#需要继承 torch.utils.data.Dataset,
#并且实现__init__(self)/__len__(self)/__getitem__(self,i)这些方法
class Dataset(torch.utils.data.Dataset):
    def __init__(self, split):
        #加载本地磁盘的datasets
        self.datasets = load_from_disk('../data/ChnSentiCorp')  #self.datasets是一个字典，包含训练、校验、测试的datatset
        self.dataset = self.datasets[split]  #使用split来区分获取的是训练、校验、测试的datatset中的哪一个
        
    def __len__(self):
        return len(self.dataset)
    
    def __getitem__(self, i):
        """让数据集像列表一样可以根据索引获取数据‘text’与“label”"""
        text = self.dataset[i]['text']
        label = self.dataset[i]['label']
        return text, label
    
dataset = Dataset(split='train')
dataset

 

<__main__.Dataset at 0x2afb31f03a0>

dataset.dataset

 

Dataset({
    features: ['text', 'label'],
    num_rows: 9600
})

len(dataset)

 9600

dataset[0]

 

('选择珠江花园的原因就是方便，有电动扶梯直接到达海边，周围餐馆、食廊、商场、超市、摊位一应俱全。酒店装修一般，但还算整洁。 泳池在大堂的屋顶，因此很小，不过女儿倒是喜欢。 包的早餐是西式的，还算丰富。 服务吗，一般',
 1)

2  分词 

#分词工具导包
from transformers import BertTokenizer

#加载字典和分词工具    huggingface自带的中文词典bert-base-chinese加载进来
tokenizer = BertTokenizer.from_pretrained(r'../data/bert-base-chinese/')
tokenizer

 

BertTokenizer(name_or_path='../data/bert-base-chinese/', vocab_size=21128, model_max_length=512, is_fast=False, padding_side='right', truncation_side='right', special_tokens={'unk_token': '[UNK]', 'sep_token': '[SEP]', 'pad_token': '[PAD]', 'cls_token': '[CLS]', 'mask_token': '[MASK]'}, clean_up_tokenization_spaces=True),  added_tokens_decoder={
	0: AddedToken("[PAD]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	100: AddedToken("[UNK]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	101: AddedToken("[CLS]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	102: AddedToken("[SEP]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	103: AddedToken("[MASK]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
}

 2.1  重写collate_fn方法¶

自定义取数据的方法 

def collate_fn(data):
    #从传入的数据集data（dataset）中分离出文本句子sents和标签labels
    sents = [i[0] for i in data]
    labels = [i[1] for i in data]
    
    #编码：完成句子的分词操作
    data = tokenizer.batch_encode_plus(batch_text_or_text_pairs=sents,
                                       truncation=True,      #文本超过最大长度会被截断
                                       padding='max_length',  #不足最大长度，补充《pad》
                                       return_tensors='pt',   #返回的数据是pythorch类型
                                       return_length='True')
    
    #获取编码之后的数字 索引
    input_ids = data['input_ids']
    attention_mask = data['attention_mask']
    token_type_ids = data['token_type_ids']
    labels = torch.LongTensor(labels)   #labels在pythorch中一般设置成long类型
    
    return input_ids, attention_mask, token_type_ids, labels

#创建数据加载器
loader = torch.utils.data.DataLoader(
    dataset=dataset,  #将数据集传进来
    batch_size=16,    #一批数据16个
    collate_fn=collate_fn,  #传入自定义的取数据的方法
    shuffle=True,    #打乱数据
    drop_last=True   #最后一批数据若不满足16个数据，就删除
)

for i, (input_ids, attention_mask, token_type_ids, labels) in enumerate(loader):
    break   #只完成赋值，不输出打印

print(len(loader))

600

print(input_ids.shape, attention_mask.shape, token_type_ids.shape, labels.shape)

 

torch.Size([16, 512]) torch.Size([16, 512]) torch.Size([16, 512]) torch.Size([16])

3  用BertModel加载预训练模型 

#Bert模型导包
from transformers import BertModel


#加载预训练模型
pretrained = BertModel.from_pretrained('../data/bert-base-chinese/')

#固定bert的参数：  遍历参数，修改每一个参数的requires_grad_，使其不能进行求导、梯度下降
for param in pretrained.parameters():
    param.requires_grad_(False)  #变量最右边添加下划线，表示直接修改变量的原始属性

 4  模型试算

out = pretrained(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)


out.last_hidden_state.shape  
#torch.Size([16, 512, 768])
#16：一批数据有16个
#512：一个句子的长度
#768：yincan


#torch.Size([16, 512, 768])


out.last_hidden_state[:, 0].shape  #获取cls特殊词的输出结果


#torch.Size([16, 768])

 5  定义下游任务¶

class Model(torch.nn.Module):
    def __init__(self, pretrained_model):
        super().__init__()
        #预训练模型层
        self.pretrained_model = pretrained_model
        #输出层：全连接层
        #768:表示将上一层预训练模型层768个的输出结果作为全连接层的输入数据
        #2：表示二分类问题就会有两个输出结果
        self.fc = torch.nn.Linear(768, 2)
        
        
    #前向传播
    def forward(self, input_ids, attention_mask, token_type_ids):
        with torch.no_grad():
            out = pretrained(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
            
        #在Bert中，获取cls特殊词的输出结果来做分类任务
        out = self.fc(out.last_hidden_state[:, 0])
        out.softmax(dim=1)
        return out
    
#声明模型
model = Model(pretrained)
#创建模型：输入参数
model(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids).shape

#torch.Size([16, 2])  16个句子对，2个分类结果

torch.Size([16, 2]) 

torch.cuda.is_available()

 True

#设置设备
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
device

 device(type='cuda', index=0)

6  训练 

# AdamW  梯度下降的优化算法  在Adam的基础上稍微改进了一点
from transformers import AdamW  


#训练
optimizer = AdamW(model.parameters(), lr=5e-4)  #设置优化器
#声明损失函数
loss = torch.nn.CrossEntropyLoss()

#建模
model = Model(pretrained)
#模型训练
model.train()
#将模型传到设备上
model.to(device)
for i, (input_ids, attention_mask, token_type_ids, labels) in enumerate(loader):
    #把传入的数据都传到设备上
    input_ids = input_ids.to(device)
    attention_mask = attention_mask.to(device)
    token_type_ids = token_type_ids.to(device)
    labels = labels.to(device)
    
    out = model(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
    
    #计算损失函数
    l = loss(out, labels)  #out：预测值   labels：真实值
    #用损失函数来反向传播
    l.backward()
    #梯度更新
    optimizer.step()
    #梯度清零
    optimizer.zero_grad()
    
    #每隔5次，计算一下准确率
    if i % 5 == 0:
        out = out.argmax(dim=1)  #计算预测值
        #计算准确率
        accuracy =(out == labels).sum().item() / len(labels)   #item()是拿到求和之后的数字
        print(i, l.item(), accuracy)
        
    if i == 100:
        break  

 

0 0.6882429718971252 0.5
5 0.7822732329368591 0.3125
10 0.7996063828468323 0.25
15 0.7967076301574707 0.3125
20 0.839418888092041 0.3125
25 0.6795901656150818 0.5625
30 0.7707732319831848 0.3125
35 0.6784831285476685 0.4375
40 0.728607177734375 0.375
45 0.7425007224082947 0.375
50 0.6188052892684937 0.5625
55 0.7185056805610657 0.375
60 0.8377469778060913 0.1875
65 0.7717736959457397 0.3125
70 0.7421607375144958 0.4375
75 0.7337921857833862 0.375
80 0.8023619651794434 0.3125
85 0.7294195890426636 0.5625
90 0.7909258008003235 0.3125
95 0.7105788588523865 0.4375
100 0.7786014676094055 0.5

7  测试 

model.eval()用于将模型设置为评估模式。‌ 在评估模式下，模型将关闭一些在训练过程中使用的特性，如‌Dropout和BatchNorm层的训练模式，以确保模型在推理时能够给出准确的结果。使用model.eval()可以帮助我们更好地评估模型的性能，并发现潜在的问题。 

def test():
    model.eval()
    correct = 0
    total = 0
    
    loader_test = torch.utils.data.DataLoader(dataset = Dataset('validation'),
                                              batch_size = 32,
                                              collate_fn=collate_fn,
                                              shuffle=True,
                                              drop_last=True)
    for i, (input_ids, attention_mask, token_type_ids, labels) in enumerate(loader_test):
        #输入的数据传入到设备上
        input_ids = input_ids.to(device)
        attention_mask = attention_mask.to(device)
        token_type_ids = token_type_ids.to(device)
        labels = labels.to(device)
        
        if i == 5:
            break
        print(i)
        with torch.no_grad():
            out = model(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
        out = out.argmax(dim=1)
        correct += (out==labels).sum().item()
        total += len(labels)
    print(correct / total)
test()

 

0
1
2
3
4
0.40625