长文本分类

文本分类是把文本打上对应的类别标签，在互联网中的应用场景很多，如评论、弹幕等。作为比较强大的预训练模型Bert，用来做文本分类有很好的效果。本文介绍pytorch版本的Bert长文本分类,但由于Bert的输入长度有现在，最长只能输入512个字符，但长文本通常有几千或者几万个字，所以本文采用了两种策略来进行长文本分类，一是取文本开头的512字符输入到Bert，二是对文本先采用文本摘要算法，得到重要的部分再取前面512字符输入到Bert。

文本摘要算法Textrank介绍

Textrank算法的思想来自于PageRank，PageRank是谷歌用来进行网页排序的算法，其思想是赋予每个网页一个权值，然后计算每个网页指向其他网页的权值，之后根据计算的权值求和来进行权值更新，一般，最后按权值来进行排名。
在文本中，就将每一个句子看成一个个体，句子与句子间的链接权值就用句子间的相似度来代替，只需要进行句子间相似度的计算就可以更新权值了，假设向量B是句子的rank权值，每一个元素代表一个句子的排名权值，矩阵A是一个二维矩阵，它的维度数是句子的数量，用矩阵A*向量B来进行迭代，当向量B收敛之后就完成了，向量B中元素的值就代表对应句子的排名权值。

句子相似度计算

句子相似度的计算，一般用两个句子的向量来进行运算，比如计算余弦相似度。然而怎么取句子向量比较重要，句子向量要能充分表示句子的特征，这样计算的相似度才准确。现在一般取句子向量的话，会用到词向量，或者Bert。用词向量的话，是查表找到每一个词的向量，在计算平均，得到句子的向量。而Bert则是输入一个句子，用输出的CLS代表整个句子的向量，当然也可以用Bert获取每个字的向量再求平均获得句子向量。
1、使用glove词向量来获取句子向量并进行Textrank

# -*- coding:utf-8 -*-
# 导入所需的库,没有的话用pip install 库名字安装
import numpy as np
import pandas as pd
import nltk
# networkx库内置了常用的图与复杂网络分析算法，可以方便的进行复杂网络数据分析、仿真建模等工作。
import networkx as nx
# 下载一次就行了，第一次下载完再注释掉
#nltk.download('punkt')# 下载停用词，下载一次就行，同上
#nltk.download('stopwords')
# 加载进来
from nltk.corpus import stopwords
import re
# 将用余弦相似度计算两个句子之间的相似度
from sklearn.metrics.pairwise import cosine_similarity
from bs4 import BeautifulSoupdef get_sentences_list(raw_text: str):#BeautifulSoup对象，参数 文档字符串，html解析器，文档编码return [s for s in BeautifulSoup(raw_text, 'html.parser')._all_strings()]# 这里使用glove中文维基的词向量生成一个word_embeddings查找列表
word_embeddings = {}
f = open('glove.txt', encoding='utf-8')
# 按行读取
for line in f:# 按照空格进行分割values = line.split()# values 数组的第一个位置是当前的英语单词word = values[0]coefs = np.asarray(values[1:], dtype='float32')word_embeddings[word] = coefs
f.close()# print("词表：",len(word_embeddings['我']))
# 停用词表
def stopwordslist():stopwords = [line.strip() for line in open('chineseStopWords.txt',encoding = "utf-8").readlines()]return stopwordsdef text_import(text):text_extract = ''sentence_list = []text = get_sentences_list(text)for node in text[0].split('。'):if len(node) != 0:sentence_list.append(node)sentence_num = len(sentence_list)sentences_vectors = []print(len(sentence_list))# print(sentence_list[0])#去除非中文的字符pre_sentences = pd.Series(sentence_list).str.replace('[^\u4e00-\u9fa5]', ' ')stop_words = stopwordslist()# print(stop_words)# 定义移除停用词函数def remove_stopwords(str):# 遍历数组中的每个元素，如果这个元素不在停用词列表，则加入事先准备的字符串中sen = ' '.join([i for i in str if i not in stop_words])return sen# 去除停用词pre_sentences = [remove_stopwords(r.split()) for r in pre_sentences]print(pre_sentences)# 获取句子特征向量，用来计算后面的相似度，这里取每个句子中词向量合并的平均值来作为该句子的特征向量# 所有句子的词向量表示sentences_vectors = []for sen in pre_sentences:# 如果句子长度不为0if len(sen) != 0:v = sum([word_embeddings.get(w, np.zeros((300,))) for w in sen.split()]) / (len(sen.split()) + 1e-2)else:v = np.zeros((300,))sentences_vectors.append(v)# 用上面获取到的句子的向量计算一个相似度矩阵# 这里使用余弦相似度来计算每个句子的相似性# 首先定义一个n乘n的零矩阵，然后用句子间的余弦相似度填充矩阵，这里n是句子的总数。similarity_matrix = np.zeros((len(pre_sentences), len(pre_sentences)))print(len(pre_sentences))for i in range(len(pre_sentences)):for j in range(len(pre_sentences)):# 这里的if用于排序自己与自己计算相似度if i != j:similarity_matrix[i][j] = cosine_similarity(sentences_vectors[i].reshape(1, -1), sentences_vectors[j].reshape(1, -1))# 输出相似度矩阵print(similarity_matrix)# 将上面获得的相似性矩阵sim_mat转换为图结构。这个图的节点为句子，边用句子之间的相似性分数表示。# 在这个图上，使用networkx库提供的PageRank算法来得到句子排名，句子排名越高，说明其越重要，就是摘要nx_graph = nx.from_numpy_array(similarity_matrix)scores = nx.pagerank(nx_graph)print(scores)# 根据排名来选取句子作为摘要# 遍历sentences数组，i是当前的位置角标，s是当前的句子# scores[i]：从scores中取出第i个位置的分数与当前句子组成一对# 将所有的分数，句子信息组成的list赋值给ranked_sentences# sorted：并排序，reverse=True降序ranked_sentences = sorted(((scores[i], s) for i, s in enumerate(sentence_list)), reverse=True)# 排序# for i in range(1):#     print(ranked_sentences[i][1])# # 打印得分最高的前面几个句子，即为摘要,这里修改句子的数量就可以修改摘要for i in range(sentence_num):if len(text_extract) < 512:# 获取文本的摘要text_extract += ranked_sentences[i][1] + '。'else:breakreturn text_extract[:512]text="徐峥，回不到过去徐峥，回不到过去喜剧演员徐峥、爆米花商业片导演徐峥，同时也是文青的徐峥。毒眸《我和我的家乡》的五个单元故事里，若票选最令人印象深刻的角色，《最后一课》单元的中范伟饰演的“范老师”可能是人气最高的。豆瓣高赞短评写道：“范伟把我的泪点掐住了”、“教科书级别的演技”；微博上，范伟雨中奔跑的花絮冲上热搜第一，评论说：“范伟真的厉害，从他跑出教室我就开始哭，一直到单元结束”。也有观众能够指出，范伟动人的表演不止是范伟自己的功劳。作为这个单元的导演，恰好在徐峥的导演方法论里，表演也是重要的话题。“导演对表演，必须达到一种切身的理解，要完全能够站在演员的立场上，为演员的表演提供有帮助的指示。”10月12日，徐峥在丝绸之路国际电影节的大师班上，传递了这样一种观点。对表演的理解深度，或许是徐峥作品里容易诞生“高光演技”的原因之一：从《我和我的祖国》里惊艳的小演员“冬冬”韩昊霖，到《我和我的家乡》里“掐住观众泪点”的范伟，都凭借演技引发了话题。另一方面，叙事功力也是《最后一课》受到好评的另一个原因。豆瓣一则热评写道：“（最后一课）展现出徐峥某个程度的细腻，他很擅长从小的切角去展开一个宏大叙题。”《最后一课》中，村民为帮助身患阿尔兹海默症的范老师，设下“重返1992年”的骗局，最终骗局的败露，也揭示了家乡的发展变化遮掩不住。徐峥在大师班上这般解释如此构思的原因：“因为观众是非常害怕说教的”，所以要通过一个“过去无法重塑”的故事，去展现变化。而毒眸通过徐峥在大师班上的讲述，也感知到《最后一课》与徐峥个人轨迹的某种暗合：从演实验话剧的先锋文艺青年，到家喻户晓的影视演员、商业片导演，近年来的徐峥正在试图回归到更接近个人表达的状态。但过去无法重塑，徐峥要做的不是变回90年代那个文艺青年，而是带着对过去自我的同理心和多年积累的经验，介入到当下青年导演的创作中去——成为青年导演的电影监制。徐峥提到，大部分导演正如当年的自己一样，是因为热爱艺术而投身电影创作的文艺青年，而现在的徐峥和他所成立的真乐道文化，正在通过“监制”这一角色，去服务青年导演，帮助“曾经的徐峥”们缓解创作之外、全产业流程上的压力。某种程度上，范伟饰演的乡村教师，也带着几分徐峥的自我投射：一个人仅凭自己的力量是无法改变“家乡”或者“环境”的，但是把经验分享出来，帮助更多有能力改变的人，环境就会向好的方向变化。文青徐峥“程耳找我拍《犯罪分子》的时候，是在1998年，那时候我也是个文艺青年。”大师班上与青年导演对谈的徐峥，回溯了他的青年时代，但很快又调转话锋：“现在如果让他（程耳）看我的电影，他肯定看不上我，觉得我已经不是一个艺术青年了。”二十年前，徐峥在大众的认知里是《春光灿烂猪八戒》里的猪八戒、《李卫当官》中的李卫。但其实在古装喜剧之外，他还是个演先锋话剧的艺术青年，这一度会让许多观众感到惊诧。但近年来，1999年问世的《犯罪分子》的重新流行，再度将文青时代的徐峥带回观众的视野。这部31分钟的小成本犯罪片拍摄时，导演程耳还在北京电影学院毕业读大四。作品有“北电史上最牛学生作业”之称，豆瓣评分7.4，一条2014年发布的热门短评无不惋惜地评价男主角徐峥：“大脑袋有大智慧，演技真实准确，可惜了现在的被定位。”《 犯罪分子》剧照但彼时观众跨越时空的“惋惜”对徐峥来说，未免来得迟了一些——文青时代的徐峥是不为观众所青睐的。《十三邀》中，徐峥和许知远走进了上海话剧艺术中心——1994年从上海戏剧学院毕业后，徐峥的第一个工作单位。艺术中心进门处的墙上挂满了剧照，徐峥很快从中发现了自己的身影：《拥挤》《艺术》《股票的颜色》......而后者令徐峥在1998年摘得白玉兰戏剧奖最佳男主角。根据徐峥的描述，从戏剧学院毕业后没有人找自己拍戏，所以他一直在演话剧。那时，话剧演员徐峥一度“小有名气”，徐峥还和朋友组建了剧社，并自己担任导演排了两部先锋的实验作品《拥挤》和《母语》。“当时就受到很多质疑，别人说你排的戏看不懂，这那的，当时我就很激动，还会跟人争辩。”徐峥在《十三邀》里说道。但他很快转变了思路，开始反思过于先锋的内容是否有意义，他认为自己应该对作品的传播效果负责任。愿意主动做出这样的改变，是因为徐峥虽然接受过高屋建瓴的戏剧教育、具备做出先锋性表达的能力，但他并不是那类厌弃成功的、忧郁的、纯度很高的文艺青年。徐峥在艺术性和商业化两个方向里同样具有可能性。世纪之交，徐峥开始涉足影视圈，同时也仍然在排话剧，前者所带来的曝光一度让徐峥的话剧事业“沾光”。2000年1月《春光灿烂猪八戒》在各大卫视反复播出，据索福瑞收视数据，该剧在湖南卫视、黑龙江卫视、山东和江西卫视播出的平均收视率均超过20%，最高平均收视达到31%。次年徐峥主演的喜剧话剧《艺术》在宣传不多的情况下，于上海连演15场。尽管徐峥自嘲现在的程耳一定看不上自己，但事实上，2007年程耳和徐峥又再度合作了悬疑惊悚剧《第三个人》。2009年，徐峥主演两部公路片，一部是指向喜剧和商业成功的《人在囧途》，一部是暗黑的《无人区》，后者入围了柏林国际电影节主竞赛单元。《无人区》海报文艺青年的人格从未离开徐峥的躯壳，只是一度被喜剧演员的光环盖住了——面向大众的商业喜剧片、古装电视剧能够辐射的受众，远比话剧和严肃电影来得多。但近年来，随着主演作品《我不是药神》的上映和徐峥个人导演作品中愈发明显的人文表达，他的“前文艺青年”身份不再显得太过违和。《我不是药神》在豆瓣被150万用户打出9.0分，位列豆瓣电影top250第47名——达到了近20年来华语电影鲜少能触碰到的金线。《最后一课》在《家乡》的五个单元之中，口碑亦属于上乘。徐峥延续了执导《我和我的祖国》单元《夺冠》的经验，从小人物的动机和情感出发，反而真实恳切；在叙事上，他在过去与现在的故事线反复切换，用重塑过去来反衬现在；细节也值得咂摸，比如颜料打翻在水里化成了彩虹的颜色、范老师一路走进教室那个调度复杂、明星云集的长镜头。"
# text=" "
print(len(text))
print(text_import(text))

2、使用在语料上预训练过的Bert来获取句子向量

# 导入所需的库,没有的话用pip install 库名字安装
import numpy as np
import pandas as pd
import nltk
import pickle
import json
# networkx库内置了常用的图与复杂网络分析算法，可以方便的进行复杂网络数据分析、仿真建模等工作。
import networkx as nx
# 下载一次就行了，第一次下载完再注释掉
#nltk.download('punkt')# 下载停用词，下载一次就行，同上
#nltk.download('stopwords')20
# 加载进来
from nltk.corpus import stopwords
import re
# 将用余弦相似度计算两个句子之间的相似度
from sklearn.metrics.pairwise import cosine_similarity
import torch
import tqdm
import bs4
from torch import nn
from tqdm import tqdm
from bs4 import BeautifulSoup
import transformers as tfsBERT_TOKENZIER_PATH ='./chinese_wwm_ext_L-12_H-768_A-12/'
FINETUNED_BERT_ENCODER_PATH ='./预训练模型/finetuned_bert.bin'def get_sentences_list(raw_text: str):#BeautifulSoup对象，参数 文档字符串，html解析器，文档编码return [s for s in BeautifulSoup(raw_text, 'html.parser')._all_strings()]#这里用微调的bert来获取文本的句子向量，再用向量来计算相似度
class MyBertEncoder(nn.Module):"""自定义的Bert编码器"""def __init__(self, tokenizer_path, finetuned_bert_path):super(MyBertEncoder, self).__init__()model_class, tokenizer_class = tfs.BertModel, tfs.BertTokenizerself.tokenizer = tokenizer_class.from_pretrained(tokenizer_path)self.bert = torch.load(finetuned_bert_path)def forward(self, batch_sentences):batch_tokenized = self.tokenizer.batch_encode_plus(batch_sentences, add_special_tokens=True,max_length=512, pad_to_max_length=True)input_ids = torch.tensor(batch_tokenized['input_ids']).cuda()token_type_ids = torch.tensor(batch_tokenized['token_type_ids']).cuda()attention_mask = torch.tensor(batch_tokenized['attention_mask']).cuda()bert_output = self.bert(input_ids=input_ids, token_type_ids=token_type_ids, attention_mask=attention_mask)bert_cls_hidden_state=bert_output[1]# bert_cls_hidden_state = bert_output[0][:, 0, :]return bert_cls_hidden_stateencoder = MyBertEncoder(BERT_TOKENZIER_PATH, FINETUNED_BERT_ENCODER_PATH)def text_import(text):#以下操作不影响梯度with torch.no_grad():encoder.eval()print("我是一个小天使！")text_test = "我是一个小天使！"text_emb = np.array(encoder(text_test).cpu().detach().numpy())print(text_emb[0])text_extract=''sentence_list=[]text=get_sentences_list(text)for node in text[0].split('。'):if len(node)!=0:sentence_list.append(node)sentence_num=len(sentence_list)sentences_vectors = []print(sentence_list)print(sentence_list[0])for sen in sentence_list:# emb=padding_E2E_bert(np.array(encoder(sen).cpu()))emb = np.array(encoder(sen).cpu())# 取cls的向量作为句子向量sentences_vectors.append(emb[0])del emb# 用上面获取到的句子的向量计算一个相似度矩阵# 这里使用余弦相似度来计算每个句子的相似性# 首先定义一个n乘n的零矩阵，然后用句子间的余弦相似度填充矩阵，这里n是句子的总数。similarity_matrix = np.zeros((len(sentence_list), len(sentence_list)))for i in range(len(sentence_list)):for j in range(len(sentence_list)):# 这里的if用于排序自己与自己计算相似度if i != j:similarity_matrix[i][j] = cosine_similarity(sentences_vectors[i].reshape(1, -1), sentences_vectors[j].reshape(1, -1))# 输出相似度矩阵print(similarity_matrix)# 将上面获得的相似性矩阵sim_mat转换为图结构。这个图的节点为句子，边用句子之间的相似性分数表示。# 在这个图上，使用networkx库提供的PageRank算法来得到句子排名，句子排名越高，说明其越重要，就是摘要nx_graph = nx.from_numpy_array(similarity_matrix)scores = nx.pagerank(nx_graph)# 根据排名来选取句子作为摘要# 遍历sentences数组，i是当前的位置角标，s是当前的句子# scores[i]：从scores中取出第i个位置的分数与当前句子组成一对# 将所有的分数，句子信息组成的list赋值给ranked_sentences# sorted：并排序，reverse=True降序ranked_sentences = sorted(((scores[i], s) for i, s in enumerate(sentence_list)), reverse=True)# 排序for i in range(1):print(ranked_sentences[i][1])# 打印得分最高的前面几个句子，即为摘要,这里修改句子的数量就可以修改摘要for i in range(sentence_num):if len(text_extract)<512:#获取文本的摘要text_extract+=ranked_sentences[i][1]+'。'else:breakreturn text_extract[:512]text="这4种家电，有人相见恨晚，有人感觉鸡肋，主要是价格不一样同样一个产品，口碑却两极分化。感觉好用的人，天天喊着“后悔买晚了”；还有一些人，买完就感慨“果然是鸡肋”。在家电里也有一些这样的产品，比如我们今天要说的下面这四种。而且这四种家电有一个共同点——说好用的人，买得都挺贵的。没错，造成这四类家电口碑两极分化的原因，就是价格。如果你想买，请直接买贵的。"
print(text_import(text))

训练全部代码

这里给出的是使用glove词向量生成摘要输入到Bert进行分类的代码，使用Bert的话cuda的容量比较大报错，可能也跟我写的代码有关，没有分批处理，也可能因为文章比较长，很难全部过bert的话占用容量很大。这里使用的是华为文本分类比赛用到的数据。具体流程是数据处理，生成摘要，输入Bert，再接一个Lstm。

# -*- coding:utf-8 -*-
import torch
torch.cuda.is_available()
import os
#分配cuda
os.environ["CUDA_VISIBLE_DEVICES"] = '2'
# torch.cuda.set_device(2)
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
from torch.nn import CrossEntropyLoss, MSELoss
import torch.nn.functional as F
import torch.optim as optim
import torchtext
from torchtext.data import  BucketIterator
from torch.utils.data import DataLoader, RandomSampler, SequentialSampler, TensorDataset
from torch.utils.data.distributed import DistributedSampler
from tqdm import tqdm, trangefrom transformers import (WEIGHTS_NAME,AdamW,get_linear_schedule_with_warmup,BertConfig,BertModel,BertPreTrainedModel,BertTokenizer,)from transformers import glue_convert_examples_to_features as convert_examples_to_features
from transformers import glue_output_modes as output_modes
from transformers import glue_processors as processors
from transformers.data.processors.utils import InputExample, DataProcessorimport logging
logger=logging.getLogger(__name__)# from google.colab import drive
# drive.mount('/content/drive')MODEL_CLASSES={"bert":(BertConfig,BertTokenizer),
}#利用微调的bert来进行文本摘要，这里引入bert的encodder
# 导入所需的库,没有的话用pip install 库名字安装
import numpy as np
import pandas as pd
import nltk
import pickle
import json
# networkx库内置了常用的图与复杂网络分析算法，可以方便的进行复杂网络数据分析、仿真建模等工作。
import networkx as nx
# 下载一次就行了，第一次下载完再注释掉
#nltk.download('punkt')# 下载停用词，下载一次就行，同上
#nltk.download('stopwords')20
# 加载进来
from nltk.corpus import stopwords
import re
# 将用余弦相似度计算两个句子之间的相似度
from sklearn.metrics.pairwise import cosine_similarity
import torch
import tqdm
import bs4
from torch import nn
from tqdm import tqdm
from bs4 import BeautifulSoup
import transformers as tfsdef get_sentences_list(raw_text: str):#BeautifulSoup对象，参数 文档字符串，html解析器，文档编码return [s for s in BeautifulSoup(raw_text, 'html.parser')._all_strings()]# 这里使用glove中文维基的词向量生成一个word_embeddings查找列表
word_embeddings = {}
f = open('glove.txt', encoding='utf-8')
# 按行读取
for line in f:# 按照空格进行分割values = line.split()# values 数组的第一个位置是当前的英语单词word = values[0]coefs = np.asarray(values[1:], dtype='float32')word_embeddings[word] = coefs
f.close()
# 停用词表
def stopwordslist():stopwords = [line.strip() for line in open('chineseStopWords.txt').readlines()]return stopwordsdef text_import(text):text_extract = ''sentence_list = []text = get_sentences_list(text)for node in text[0].split('。'):if len(node) != 0:sentence_list.append(node)# sentence_num = len(sentence_list)# if sentence_num>5:#    sentence_list=sentence_list[:5]sentences_vectors = []# print(len(sentence_list))# print(sentence_list[0])#去除非中文的字符pre_sentences = pd.Series(sentence_list).str.replace('[^\u4e00-\u9fa5]', ' ')stop_words = stopwordslist()# print(stop_words)# 定义移除停用词函数def remove_stopwords(str):# 遍历数组中的每个元素，如果这个元素不在停用词列表，则加入事先准备的字符串中sen = ' '.join([i for i in str if i not in stop_words])return sen# 去除停用词pre_sentences = [remove_stopwords(r.split()) for r in pre_sentences]# print(pre_sentences)# 获取句子特征向量，用来计算后面的相似度，这里取每个句子中词向量合并的平均值来作为该句子的特征向量# 所有句子的词向量表示sentences_vectors = []for sen in pre_sentences:# 如果句子长度不为0if len(sen) != 0:v = sum([word_embeddings.get(w, np.zeros((300,))) for w in sen.split()]) / (len(sen.split()) + 1e-2)else:v = np.zeros((300,))sentences_vectors.append(v)# 用上面获取到的句子的向量计算一个相似度矩阵# 这里使用余弦相似度来计算每个句子的相似性# 首先定义一个n乘n的零矩阵，然后用句子间的余弦相似度填充矩阵，这里n是句子的总数。similarity_matrix = np.zeros((len(pre_sentences), len(pre_sentences)))for i in range(len(pre_sentences)):for j in range(len(pre_sentences)):# 这里的if用于排序自己与自己计算相似度if i != j:similarity_matrix[i][j] = cosine_similarity(sentences_vectors[i].reshape(1, -1), sentences_vectors[j].reshape(1, -1))# 输出相似度矩阵# print(similarity_matrix)# 将上面获得的相似性矩阵sim_mat转换为图结构。这个图的节点为句子，边用句子之间的相似性分数表示。# 在这个图上，使用networkx库提供的PageRank算法来得到句子排名，句子排名越高，说明其越重要，就是摘要nx_graph = nx.from_numpy_array(similarity_matrix)scores = nx.pagerank(nx_graph)# print(scores)# 根据排名来选取句子作为摘要# 遍历sentences数组，i是当前的位置角标，s是当前的句子# scores[i]：从scores中取出第i个位置的分数与当前句子组成一对# 将所有的分数，句子信息组成的list赋值给ranked_sentences# sorted：并排序，reverse=True降序ranked_sentences = sorted(((scores[i], s) for i, s in enumerate(sentence_list)), reverse=True)# 排序# for i in range(1):#     print(ranked_sentences[i][1])# # 打印得分最高的前面几个句子，即为摘要,这里修改句子的数量就可以修改摘要for i in range(len(sentence_list)):if len(text_extract) < 512:# 获取文本的摘要text_extract += ranked_sentences[i][1] + '。'else:breakreturn text_extract[:512]#定义十分类的标签以及最大句子长度
my_label_list=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
MAX_SEQ_LENGTH=200#读入文本数据,这里是标签 文本的csv格式
train_raw = pd.read_csv('./new_train_set.csv')
train_raw.head()
# print(train_raw['text'])
# print(train_raw['label'])#对文本里的标签进行编码
from sklearn.preprocessing import LabelEncoder
LE = LabelEncoder()
train_raw['label'] = LE.fit_transform(train_raw['label'])
# print(train_raw.head())train = train_raw.copy()
train = train.reindex(np.random.permutation(train.index))
train.head()#这里处理文本里的内容,对文本的内容处理可以加在这里
import re
def clean_txt(text):text = re.sub("'", "",text)# text=re.sub("(\\W)+"," ",text)text=text.replace(' ','')text.strip()return texttrain['text']  = train.text.apply(clean_txt)
# train['text']  = train.text.apply(text_import)
# print(train.head())
#划分训练集，验证集
from sklearn.model_selection import train_test_split
train, val = train_test_split(train, test_size=0.4, random_state=35)
#数据清洗时，会去掉空行的，导致索引不连续
train.reset_index(drop=True, inplace=True)
# print(train.head(2))
val.reset_index(drop=True, inplace=True)
val.head(2)
print(train.shape,val.shape)
# print(train)
train_l = []  # 分割好的文本
label_l = []  # 每段文本的label
index_l= []
# text = text_import(text)
for idx,row in train.iterrows():try:row['text']=text_import(row['text'])#因为textrank算法有时候计算不收敛，也会导致异常，如果出现异常这里就取原文512except:row['text']=row['text'][:512]train_l.append(row['text'])label_l.append(row['label'])index_l.append(idx)print(len(train_l), len(label_l))
val_l = []
val_label_l = []
val_index_l= []
for idx,row in val.iterrows():try:row['text'] = text_import(row['text'])except:row['text'] = row['text'][:512]val_l.append(row['text'])val_label_l.append(row['label'])val_index_l.append(idx)
print( len(val_l), len(val_label_l))
train_df = pd.DataFrame({'text':train_l, 'label':label_l})
print(train_df.head())
val_df = pd.DataFrame({'text':val_l, 'label':val_label_l})
print(val_df.head())
train_InputExamples = train_df.apply(lambda x: InputExample(guid=None,text_a = x['text'],text_b = None,label = x['label']), axis = 1)val_InputExamples = val_df.apply(lambda x: InputExample(guid=None,text_a = x['text'],text_b = None,label = x['label']), axis = 1)
#定义模型
class BertForClassification(BertPreTrainedModel):def __init__(self, config):super().__init__(config)self.num_labels = 10self.bert = BertModel(config)self.dropout = nn.Dropout(config.hidden_dropout_prob)self.classifier = nn.Linear(config.hidden_size, self.num_labels)self.init_weights()def forward(self,input_ids=None,  # 输入的id,模型会帮你把id转成embeddingattention_mask=None,  # attention里的masktoken_type_ids=None,  # [CLS]A[SEP]B[SEP] 就这个A还是B, 有的话就全1, 没有就0position_ids=None,  # 位置idhead_mask=None,  # 哪个head需要被mask掉inputs_embeds=None,  # 可以选择不输入id,直接输入embeddinglabels=None,  # 做分类时需要的label):outputs = self.bert(input_ids,attention_mask=attention_mask,token_type_ids=token_type_ids,position_ids=position_ids,head_mask=head_mask,inputs_embeds=inputs_embeds,)sequence_output, pooled_output = outputs[:2]pooled_output = self.dropout(pooled_output)logits = self.classifier(pooled_output)outputs = (logits, pooled_output, sequence_output,)if labels is not None:if self.num_labels == 1:#  We are doing regressionloss_fct = MSELoss()loss = loss_fct(logits.view(-1), labels.view(-1))else:loss_fct = CrossEntropyLoss()loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))outputs = (loss,) + outputsreturn outputs  # loss, logits, pooled_output, sequence_output
#载入预训练模型
args={"model_name_or_path": "./chinese_wwm_ext_L-12_H-768_A-12/","config_name": "./chinese_wwm_ext_L-12_H-768_A-12/","tokenizer_name": "./chinese_wwm_ext_L-12_H-768_A-12/",}config_class, tokenizer_class = MODEL_CLASSES["bert"]
model_class=BertForClassificationconfig = config_class.from_pretrained(args["config_name"],finetuning_task="",cache_dir=None,
)
tokenizer = tokenizer_class.from_pretrained(args["tokenizer_name"],do_lower_case=True,cache_dir=None,
)
model = model_class.from_pretrained(args["model_name_or_path"],from_tf=bool(".ckpt" in args["model_name_or_path"]),config=config,cache_dir=None,
)model.to("cuda")#准备训练数据，把example转为feature
train_features = convert_examples_to_features(train_InputExamples,tokenizer,label_list=my_label_list,output_mode="classification",max_length=MAX_SEQ_LENGTH )input_ids = torch.tensor([f.input_ids for f in train_features], dtype=torch.long)
attention_mask = torch.tensor([f.attention_mask for f in train_features], dtype=torch.long)
token_type_ids = torch.tensor([f.token_type_ids for f in train_features], dtype=torch.long)
the_labels = torch.tensor([f.label for f in train_features], dtype=torch.long)#再把feature转为tensordataset
dataset = TensorDataset(input_ids, attention_mask, token_type_ids, the_labels)#定义训练函数
def train_bert(train_dataset, model, tokenizer):no_decay = ["bias", "LayerNorm.weight"]optimizer_grouped_parameters = [{"params": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)],"weight_decay": 0.0,},{"params": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)],"weight_decay": 0.0},]t_total = len(train_dataset)//5optimizer = AdamW(optimizer_grouped_parameters, lr=2e-5, eps=1e-8)# bert里的小技巧, bert里的learning rate是不断变化的,先往上升,再往下降,这个scheduler就是用来设置这个scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=0, num_training_steps=t_total)# *********************logger.info("*****Running training*****")logger.info("  Num examples = %d", len(train_dataset))# logger.info("  Num Epochs = %d", 5)logger.info("  Num Epochs = %d",5)epochs_trained = 0global_step = 0steps_trained_in_current_epoch = 0tr_loss, logging_loss = 0.0, 0.0model.zero_grad()# train_iterator = trange(epochs_trained, 5, desc="Epoch", disable=False)train_iterator = trange(epochs_trained, 5, desc="Epoch", disable=False)for k in train_iterator:  # 共5个epoch# 随机打包train_sampler = RandomSampler(train_dataset)train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=16)epoch_iterator = tqdm(train_dataloader, desc="Iteration", disable=False)for step, batch in enumerate(epoch_iterator):if steps_trained_in_current_epoch > 0:steps_traned_in_current_epoch -= 1continuemodel.train()batch = tuple(t.to("cuda") for t in batch)# 每个batch里是 input_ids, attention_mask, token_type_ids, the_labels# 所以传入模型时,每个参数位置对应好放进去.inputs = {"input_ids": batch[0], "attention_mask": batch[1], "token_type_ids": batch[2], "labels": batch[3]}outputs = model(**inputs)loss = outputs[0]loss.backward()tr_loss += loss.item()if (step + 1) % 1 == 0:torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)optimizer.step()scheduler.step()model.zero_grad()global_step += 1logger.info("average loss:" + str(tr_loss / global_step))return global_step, tr_loss / global_step# 4.训练
train_bert(dataset,model,tokenizer)# 5.保存训练好的模型参数
import os
model.save_pretrained("./model/")
tokenizer.save_pretrained("./model/")
torch.save(args,os.path.join("./model/","training_args.bin"))#开始评估
# 1. 载入训练好的模型
args_eval={"model_name_or_path": "./model/","config_name": "./model/","tokenizer_name": "./model/",}config_class, tokenizer_class = MODEL_CLASSES["bert"]
model_class=BertForClassificationconfig = config_class.from_pretrained(args_eval["config_name"],finetuning_task="",cache_dir=None,
)
tokenizer = tokenizer_class.from_pretrained(args_eval["tokenizer_name"],do_lower_case=True,cache_dir=None,
)
model = model_class.from_pretrained(args_eval["model_name_or_path"],from_tf=bool(".ckpt" in args_eval["model_name_or_path"]),config=config,cache_dir=None,
)model.to("cuda")# 2.定义评估函数函数
from sklearn.metrics import f1_scoredef simple_accuracy(preds, labels):return (preds == labels).mean()
def acc_and_f1(preds, labels):acc = simple_accuracy(preds, labels)f1 = f1_score(y_true=labels, y_pred=preds)return {"acc": acc,"f1": f1,"acc_and_f1": (acc + f1) / 2,}def evaluate(model, tokenizer, eval_dataset):logger.info("***** Running evaluation  *****")logger.info("  Num examples = %d", len(eval_dataset))logger.info("  Batch size = %d", 16)eval_loss = 0.0nb_eval_steps = 0preds = Noneout_label_ids = Noneeval_sampler =RandomSampler(eval_dataset)eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=16)for batch in tqdm(eval_dataloader, desc="Evaluating"):model.eval()batch = tuple(t.to("cuda") for t in batch)with torch.no_grad():inputs = {"input_ids": batch[0], "attention_mask": batch[1], "labels": batch[3]}outputs = model(**inputs)tmp_eval_loss, logits = outputs[:2]eval_loss += tmp_eval_loss.mean().item()nb_eval_steps += 1if preds is None:preds = logits.detach().cpu().numpy()out_label_ids = inputs["labels"].detach().cpu().numpy()else:preds = np.append(preds, logits.detach().cpu().numpy(), axis=0)out_label_ids = np.append(out_label_ids, inputs["labels"].detach().cpu().numpy(), axis=0)eval_loss = eval_loss / nb_eval_stepspreds = np.argmax(preds, axis=1)results = simple_accuracy(preds, out_label_ids)return results,eval_loss# 3.生成评估数据
val_features = convert_examples_to_features(val_InputExamples,tokenizer,label_list=my_label_list,output_mode="classification",max_length=MAX_SEQ_LENGTH )val_input_ids = torch.tensor([f.input_ids for f in val_features], dtype=torch.long)
val_attention_mask = torch.tensor([f.attention_mask for f in val_features], dtype=torch.long)
val_token_type_ids = torch.tensor([f.token_type_ids for f in val_features], dtype=torch.long)
val_the_labels = torch.tensor([f.label for f in val_features], dtype=torch.long)eval_dataset = TensorDataset(val_input_ids, val_attention_mask, val_token_type_ids, val_the_labels)
# 4. 评估结果
results,eval_loss = evaluate(model, tokenizer, eval_dataset)
print()
print("Accuracy: ",results, "Loss: ",eval_loss)args_eval={"model_name_or_path": "./model/","config_name": "./model/","tokenizer_name": "./model/",}config_class, tokenizer_class = MODEL_CLASSES["bert"]
model_class=BertForClassificationconfig = config_class.from_pretrained(args_eval["config_name"],finetuning_task="",cache_dir=None,
)
tokenizer = tokenizer_class.from_pretrained(args_eval["tokenizer_name"],do_lower_case=True,cache_dir=None,
)
model = model_class.from_pretrained(args_eval["model_name_or_path"],from_tf=bool(".ckpt" in args_eval["model_name_or_path"]),config=config,cache_dir=None,
)model.to("cuda")train_features = convert_examples_to_features(train_InputExamples,tokenizer,label_list=my_label_list,output_mode="classification",max_length=MAX_SEQ_LENGTH )val_features = convert_examples_to_features(val_InputExamples,tokenizer,label_list=my_label_list,output_mode="classification",max_length=MAX_SEQ_LENGTH )train_input_ids = torch.tensor([f.input_ids for f in train_features], dtype=torch.long)
train_attention_mask = torch.tensor([f.attention_mask for f in train_features], dtype=torch.long)
train_token_type_ids = torch.tensor([f.token_type_ids for f in train_features], dtype=torch.long)
train_the_labels = torch.tensor([f.label for f in train_features], dtype=torch.long)# 这里一步每个东西都是要传到BERT模型的forward里面的, 要传哪些自己准备好
train_dataset = TensorDataset(train_input_ids, train_attention_mask, train_token_type_ids, train_the_labels)val_input_ids = torch.tensor([f.input_ids for f in val_features], dtype=torch.long)
val_attention_mask = torch.tensor([f.attention_mask for f in val_features], dtype=torch.long)
val_token_type_ids = torch.tensor([f.token_type_ids for f in val_features], dtype=torch.long)
val_the_labels = torch.tensor([f.label for f in val_features], dtype=torch.long)# 这里一步每个东西都是要传到BERT模型的forward里面的, 要传哪些自己准备好
val_dataset = TensorDataset(val_input_ids, val_attention_mask, val_token_type_ids, val_the_labels)#获得编码
def get_prediction(model, tokenizer, dataset):logger.info("***** Running prediction  *****")logger.info("  Num examples = %d", len(dataset))logger.info("  Batch size = %d", 16)pooled_outputs = Nonesampler =SequentialSampler(dataset)dataloader = DataLoader(dataset, sampler=sampler, batch_size=32)for batch in tqdm(dataloader, desc="Evaluating"):model.eval()batch = tuple(t.to("cuda") for t in batch)with torch.no_grad():inputs = {"input_ids": batch[0], "attention_mask": batch[1], "labels": batch[3]}outputs = model(**inputs)pooled_output = outputs[2]if pooled_outputs is None:pooled_outputs = pooled_output.detach().cpu().numpy()else:pooled_outputs = np.append(pooled_outputs, pooled_output.detach().cpu().numpy(), axis=0)return pooled_outputs#取句子的表示cls
train_pooled_outputs = get_prediction(model, tokenizer, train_dataset)
print(train_pooled_outputs.shape)val_pooled_outputs = get_prediction(model, tokenizer, val_dataset)
print(val_pooled_outputs.shape)#这里取出每一句的emb
train_x={}
for l,emb in zip(index_l,train_pooled_outputs):train_x[l]=[emb]
print('训练集的emb数',len(train_x.keys()))
train_l_final = []
label_l_final = []
for k in train_x.keys():train_l_final.append(train_x[k])label_l_final.append(train.loc[k]['label'])
df_train = pd.DataFrame({'emb': train_l_final, 'label': label_l_final, })
print("训练集的emb和label")
print(df_train.head())val_x = {}
for l, emb in zip(val_index_l, val_pooled_outputs):val_x[l] = [emb]val_l_final = []
vlabel_l_final = []
for k in val_x.keys():val_l_final.append(val_x[k])vlabel_l_final.append(val.loc[k]['label'])
df_val = pd.DataFrame({'emb': val_l_final, 'label': vlabel_l_final})
print("验证集的emb和label")
print(df_val.head())# df_val, df_test = train_test_split(df_val, test_size=0.4, random_state=35)
# print(df_train.shape, df_val.shape, df_test.shape)
print(df_train.shape,df_val.shape)
#前面准备好enbeeding后输入lstm，下面搭建lstm
class MyLSTM(nn.Module):def  __init__(self):super(MyLSTM, self).__init__()self.lstm = nn.LSTM(768, 100, batch_first=True)self.fc1 = nn.Linear(100,30)self.fc2 = nn.Linear(30,10)def forward(self, inputs):output, (hidden,cell) = self.lstm(inputs)   # 1 * batch_size * 768hidden = hidden.squeeze(0)  # batch_size * 768hidden = F.relu(self.fc1(hidden))  # batch_size * 30hidden = F.softmax(self.fc2(hidden),dim = 1)  # batch_size * 10return hiddendef cal_accuracy(preds, labels): #计算准确率preds = preds.detach().cpu().numpy()labels = labels.detach().cpu().numpy()preds = np.argmax(preds, axis=1)return (preds == labels).mean()def get_text_and_label_index_iterator(data):for idx, row in data.iterrows():text=row['emb']label=row['label']yield text,labeldef get_iterator_batch(data,batch_size):data_iter = get_text_and_label_index_iterator(data)continue_iterator = Truewhile continue_iterator:data_list = []for _ in range(batch_size):try:#next是获取下一个迭代器对象的方法，直到异常的时候结束data = next(data_iter)data_list.append(data)except StopIteration:continue_iterator = Falsetext_list = []label_list = []for data in data_list:text, label = datatext_list.append(text)label_list.append(label)yield torch.tensor(text_list), torch.tensor(label_list)return Falsedef train_model(model, data, optimizer, loss_fn):  # 训练函数epoch_loss = 0epoch_acc = 0total_len = 0model.train()batch_size=16dataset_iterator = get_iterator_batch(data, batch_size)# for embedding, label in tqdm(iterator, desc="Training",disable=False):for emb,iteration in dataset_iterator:# print(emb)# print(iteration)optimizer.zero_grad()embedding=emblabels=iterationpredictions = model(embedding.float())loss = loss_fn(predictions, labels.view(-1))acc = cal_accuracy(predictions, labels)loss.backward()optimizer.step()epoch_loss += loss.item() * len(labels)epoch_acc += acc.item() * len(labels)total_len += len(labels)return epoch_loss / total_len, epoch_acc / total_lendef evaluate_model(model, data, loss_fn):  # 评估函数epoch_loss = 0epoch_acc = 0total_len = 0batch_size = 16model.eval()with torch.no_grad():dataset_iterator = get_iterator_batch(data, batch_size)for  emb,iteration in dataset_iterator:embedding=emblabel = iterationpredictions = model(embedding.float())loss = loss_fn(predictions, label.view(-1))acc = cal_accuracy(predictions, label)epoch_loss += loss.item() * len(label)epoch_acc += acc.item() * len(label)total_len += len(label)model.train()  # 调回训练模式return epoch_loss / total_len, epoch_acc / total_lenfrom torchtext.data import Iterator, BucketIterator
# train_iter = Iterator(df_train, batch_size=8, device="cuda", sort_key=lambda x: len(x), sort_within_batch=False, repeat=False)
# val_iter=Iterator(df_val, batch_size=8, device="cuda", sort_key=lambda x: len(x), sort_within_batch=False, repeat=False)
lstm_model = MyLSTM()
optimizer = optim.Adam(lstm_model.parameters())
loss_fn = CrossEntropyLoss()N_EPOCHS = 5
best_valid_loss = float('inf')
for epoch in range(N_EPOCHS):train_loss, train_acc = train_model(lstm_model, df_train, optimizer, loss_fn)valid_loss, valid_acc = evaluate_model(lstm_model, df_val, loss_fn)if valid_loss < best_valid_loss:  # 保存DEV(验证集)上效果最好的模型best_valid_loss = valid_loss# torch.save(model_1.state_dict(), 'wordavg-model.pt')print('Epoch-' + str(epoch + 1) + ' :')print(f'\tTrain Loss:{train_loss:.3f}| Train Acc:{train_acc * 100:.2f}%')print(f'\t Val. Loss:{valid_loss:.3f}|  Val. Acc:{valid_acc * 100:.2f}%')# print(f'\t Test. Loss: {valid_loss:.3f} |  Test. Acc: {valid_acc * 100:.2f}%')

分类结果

总结

使用 Bert在很多自然语言处理任务上取得了不错效果，主要是Bert获取的文本向量可以充分表示文本的特征，让我们后面提取特征和分类有不错的效果，tensorflow和pytorch版本的bert，都只需要按照要求将文本数据转为为bert的那几个输入即可。文本分类任务的扩展是泛化能力和大规模迁移学习，如果遇到很多没有标签的文本怎么处理，互联网每天都会更新大量文本，模型要对这些新的文本有泛化性。数学和逻辑是计算机中的精髓所在，要能抽象问题，用这数学和逻辑的思维和方式来解决问题。需要完整项目的可以邮箱联系我974128464@qq.com，喜欢C++的nlp方向在读硕士欢迎大家一起讨论

Bert超长文本分类、文本摘要相关推荐

基于句子嵌入的无监督文本摘要（附代码实现）
©PaperWeekly· 作者|高开远学校|上海交通大学研究方向|自然语言处理本文主要介绍的是一个对多种语言的邮件进行无监督摘要抽取的项目,非常详细.文本摘要也是非常有意思的 NLP 任务之一 ...
bert做文本摘要_Fine-tune BERT for Summarization: BERT和文本摘要
BERT论文系列导读导读文本摘要主要分为抽取式文本摘要和生成式文本摘要,抽取式文本摘要因为发展的时间比较长,因此在工业界应用的范围比较广.比较常用的抽取式文本摘要的算法就是Textrank,但是呢 ...
广告行业中那些趣事系列2：BERT实战NLP文本分类任务(附github源码)
微信公众号:数据拾光者.愿结交更多的小伙伴,一同走人生路. 摘要:上一篇广告中那些趣事系列1:广告统一兴趣建模流程,我们了解了如何为广告主圈人群以及如何刻画用户的兴趣度.要想给用户打标签,我们需要构建 ...
手把手教 | 使用Bert预训练模型文本分类（内附源码）
作者:GjZero 标签:Bert, 中文分类, 句子向量本文约1500字,建议阅读8分钟. 本文从实践入手,带领大家进行Bert的中文文本分类和作为句子向量进行使用的教程. Bert介绍 Bert ...
bert使用做文本分类_使用BERT进行深度学习的多类文本分类
bert使用做文本分类 Most of the researchers submit their research papers to academic conference because its ...
使用BERT做中文文本相似度计算与文本分类
转载请注明出处,原文地址: https://terrifyzhao.github.io/2018/11/29/使用BERT做中文文本相似度计算.html 简介最近Google推出了NLP大杀器BER ...
【实战】使用Bert微调完成文本二分类
使用Bert微调完成文本二分类 1.训练前准备指定训练和预测的gpu 读取数据.分析数据构造训练数据 2.模型定义.训练和测试代码定义模型测试代码训练代码 3.微调 4.预测.批量预测实验 ...
bert模型可以做文本主题识别吗_GitHub - jkszw2014/TextClassify_with_BERT: 使用BERT模型做文本分类；面向工业用途...
TextClassify_with_BERT 使用BERT模型做文本分类:面向工业用途自己研究了当前开源的使用BERT做文本分类的许多存储库,各有各的缺点.通病就是面向学术,不考虑实际应用. 使用t ...
自动文本摘要(automatic text summarization)目前的研究方法分类
2019独角兽企业重金招聘Python工程师标准>>> 自动文本摘要通常可分为两类,分别是抽取式(extractive)和生成式(abstractive). (1)抽取式摘要判断原 ...

Bert超长文本分类、文本摘要

Bert大规模超长文本分类