简单的句子分类
    之前的代码随便改一下就行
    本次亮点有

    1. 正负情感评论，分别读取后Random处理是本次的亮点
    2. 使用了下载后的数据集，之前都是默认位置（服务器网速太慢）https://zhuanlan.zhihu.com/p/147144376

    对于数据处理的还是有点随便，可能影响了最后的最优解
    最后正确率85%左右

    1. import numpy as np
    2. import time
    3. import copy
    4. import torch.nn as nn
    5. import torch.nn.functional as F
    6. import torch.optim as optim
    7. import torch.autograd as autograd
    8. import torch.nn.functional
    9. from torch.utils.data import Dataset, DataLoader
    10. from torchvision import transforms
    11. import warnings
    12. import torch
    13. import time
    14. import argparse
    16. import os
    18. from transformers import BertTokenizer
    19. from transformers import BertForSequenceClassification
    20. from transformers import BertConfig
    21. #from transformers import BertPreTrainedModel
    24. from transformers import BertModel
    27. print("----import successfully----")
    29. USE_CUDA = torch.cuda.is_available()
    30. #USE_CUDA=False
    32. tokenizer = BertTokenizer.from_pretrained("../../pretrain_model")
    33. pos_lines = open('../../data/classification/rt-polarity.pos', encoding='gb18030', errors='ignore').read().strip().split('\n')
    34. neg_lines = open('../../data/classification/rt-polarity.neg', encoding='gb18030', errors='ignore').read().strip().split('\n')
    35. print("----load data successfully----")
    36. train_data={}
    37. train_data['label']=[]
    38. train_data['text'] =[]
    40. class mydata:
    41.     def __init__(self,data,label):
    42.         self.data=data
    43.         self.label=label
    45. data=[]
    47. for i in pos_lines:
    48.     data.append(mydata(i,1))
    49. for i in neg_lines:
    50.     data.append(mydata(i,0))
    51. #input_ids = torch.tensor(tokenizer.encode("美国", add_special_tokens=True)).unsqueeze(0)  # Batch size 1
    52. import random
    53. random.shuffle(data)
    55. for i in data:
    56.     train_data['text'].append(tokenizer.encode(i.data, add_special_tokens=False))
    57.     train_data['label'].append(i.label)
    58. data_list=[]
    59. max_len=40
    62. for x in train_data['text']:
    63.     if len(x)>=max_len:
    64.         x=x[0:39]
    65.     while len(x)<max_len:
    66.         x.append(0)
    67.     x.append(102)
    68.     l = x
    69.     x = [101]
    70.     x.extend(l)
    71.     #x=torch.tensor(x)
    72.     data_list.append(x)
    73. eval_list=data_list[8000:]
    74. eval_label=train_data['label'][8000:]
    75. data_list=data_list[0:8000]
    76. train_label=train_data['label'][0:8000]
    78. print("datalabel len: ",len(data_list))
    79. print("datalist len: ",len(train_label))
    82. print("evallabel len: ",len(eval_label))
    83. print("evallist len: ",len(eval_list))
    84. train_label=torch.tensor(train_label)
    85. traindata_tensor = torch.Tensor(data_list)
    87. eval_label=torch.tensor(eval_label)
    88. eval_tensor = torch.Tensor(eval_list)
    91. #USE_CUDA=False
    92. if USE_CUDA:
    93.     print("using GPU")
    94.     traindata_tensor =traindata_tensor.cuda()
    95.     train_label = train_label.cuda()
    96.     eval_tensor=eval_tensor.cuda()
    97.     eval_label = eval_label.cuda()
    99. def get_train_args():
    100.     parser=argparse.ArgumentParser()
    101.     parser.add_argument('--batch_size',type=int,default=1,help = '每批数据的数量')
    102.     parser.add_argument('--nepoch',type=int,default=30,help = '训练的轮次')
    103.     parser.add_argument('--lr',type=float,default=0.001,help = '学习率')
    104.     parser.add_argument('--gpu',type=bool,default=True,help = '是否使用gpu')
    105.     parser.add_argument('--num_workers',type=int,default=2,help='dataloader使用的线程数量')
    106.     parser.add_argument('--num_labels',type=int,default=2,help='分类类数')
    107.     parser.add_argument('--data_path',type=str,default='./data',help='数据路径')
    108.     opt=parser.parse_args()
    109.     print(opt)
    110.     return opt
    112. def get_model(opt):
    113.     model = BertForSequenceClassification.from_pretrained("../../pretrain_model",num_labels=opt.num_labels)
    114.     #model = bert_.BertForSequenceClassification.from_pretrained('bert-base-cased', num_labels=opt.num_labels)
    115.     #model = bert_LSTM.Net()
    116.     return model
    118. def out_put(net,batchsize):
    119.     test_list = []
    120.     test_data['text'] = [(tokenizer.encode(x, add_special_tokens=False)) for x in test_data.text]
    121.     max_len = 40
    122.     i=0
    123.     for x in test_data.text:
    124.         i+=1
    125.         if len(x) >= max_len:
    126.             x = x[0:39]
    127.         while len(x) < max_len:
    128.             x.append(0)
    129.         x.append(102)
    130.         l = x
    131.         x = [101]
    132.         x.extend(l)
    133.         # x=torch.tensor(x)
    134.         test_list.append(x)
    136.     print(i)
    137.     test_data_tensor = torch.Tensor(test_list)
    139.     if USE_CUDA:
    140.         print("using GPU to out")
    141.         test_data_tensor = test_data_tensor.cuda()
    142.     result=[]
    143.     with torch.no_grad():
    144.         result_dataset = torch.utils.data.TensorDataset(test_data_tensor)
    145.         result_dataloader = torch.utils.data.DataLoader(result_dataset, batch_size=batchsize, shuffle=False)
    146.         index=0
    147.         for X in result_dataloader:
    148.             X=X[0]
    149.             #print(type(X))
    150.             #print(X.shape)
    151.             if X.shape[0]!=batchsize:
    152.                 break
    153.             X = X.long()
    154.             outputs = net(X)
    155.             logits = outputs[:2]
    156.             _, predicted = torch.max(logits[0].data, 1)
    157.             #print("predicttype",type(predicted))
    158.             #print(predicted)
    160.             for i in range(len(predicted)):
    161.                 result.append(i)
    162.     print(len(result))
    163.     while len(result)<3263:
    164.         result.append(0)
    165.     df_output = pd.DataFrame()
    166.     aux = pd.read_csv(base_path + 'test.csv')
    167.     df_output['id'] = aux['id']
    168.     df_output['target'] = result
    169.     df_output[['id', 'target']].to_csv(base_path + 's1mple.csv', index=False)
    170.     print("reset the result csv")
    173. def eval(net,eval_data, eval_label,batch_size,pre):
    174.     net.eval()
    175.     #print("enter",net.state_dict()["classifier.bias"])
    176.     dataset = torch.utils.data.TensorDataset(eval_data, eval_label)
    177.     train_iter = torch.utils.data.DataLoader(dataset, batch_size, shuffle=False)
    178.     total=0
    179.     correct=0
    180.     with torch.no_grad():
    181.         index = 0
    182.         for X, y in train_iter:
    183.             X = X.long()
    184.             if X.size(0)!= batch_size:
    185.                 break
    186.             outputs= net(X, labels=y)
    187.             #print("enter2", net.state_dict()["classifier.bias"])
    188.             loss, logits = outputs[:2]
    189.             _, predicted = torch.max(logits.data, 1)
    190.             total += X.size(0)
    191.             correct += predicted.data.eq(y.data).cpu().sum()
    192.     s = (((1.0*correct.numpy())/total))
    193.     print("Eval right: ",correct.item()," total ",total,"Acc:",s)
    194.     return s
    197. def train(net, train_data, train_label,eval_tensor,eval_label,num_epochs, learning_rate,  batch_size):
    198.     net.train()
    199.     optimizer = optim.SGD(net.parameters(), lr=learning_rate,weight_decay=0)
    200.     dataset = torch.utils.data.TensorDataset(train_data, train_label)
    201.     train_iter = torch.utils.data.DataLoader(dataset, batch_size, shuffle=True)
    202.     pre=0
    205.     for epoch in range(num_epochs):
    206.         correct = 0
    207.         total=0
    208.         iter = 0
    209.         for X, y in train_iter:
    210.             iter += 1
    211.             X = X.long()
    212.             if X.size(0)!= batch_size:
    213.                 break
    214.             optimizer.zero_grad()
    215.             #print(type(y))
    216.             #print(y)
    217.             outputs= net(X, labels=y)
    218.             #print(y)
    219.             loss, logits = outputs[0],outputs[1]
    220.             _, predicted = torch.max(logits.data, 1)
    221.             #print("predicted",predicted)
    222.             #print("answer", y)
    223.             loss.backward()
    224.             optimizer.step()
    225.             #print(outputs[1].shape)
    226.             #print(output)
    227.             #print(outputs[1])
    228.             total += X.size(0)
    229.             correct += predicted.data.eq(y.data).cpu().sum()
    230.             s = ("Acc:%.3f" %((1.0*correct.numpy())/total))
    232.         print("Train Epoch ", str(epoch),"loss: ", loss.mean().item(),"Acc:", s)
    233.         torch.save(net.state_dict(), 'model.pth')
    234.         pre=eval(net,eval_tensor, eval_label,batch_size,pre)
    235.     return
    237. opt = get_train_args()
    238. model=get_model(opt)
    239. #print(model)
    240. if USE_CUDA:
    241.     model=model.cuda()
    242. #model.load_state_dict(torch.load('model.pkl'))
    244. train(model,traindata_tensor,train_label,eval_tensor,eval_label,5,0.0008,16)
    245. #model = torch.load('model.pkl')

    image.png