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

长文本分类

文本分类是把文本打上对应的类别标签，在互联网中的应用场景很多，如评论、弹幕等。作为比较强大的预训练模型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 BeautifulSoup

def 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 stopwords

def 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:
        # 如果句子长度不为0
        if 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:
            break

    return 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 tfs

BERT_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.BertTokenizer
        self.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_state

encoder = 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:
                    break

            return 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, trange

from 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, DataProcessor

import 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 tfs



def 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 stopwords

def 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:
        # 如果句子长度不为0
        if 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:
            break

    return 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 text

train['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算法有时候计算不收敛，也会导致异常，如果出现异常这里就取原文512
        except:
             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 = 10

        self.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转成embedding
            attention_mask=None,  # attention里的mask
            token_type_ids=None,  # [CLS]A[SEP]B[SEP] 就这个A还是B, 有的话就全1, 没有就0
            position_ids=None,  # 位置id
            head_mask=None,  # 哪个head需要被mask掉
            inputs_embeds=None,  # 可以选择不输入id,直接输入embedding
            labels=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 regression
                loss_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,) + outputs

        return 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=BertForClassification


config = 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)//5
    optimizer = 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 = 0
    global_step = 0
    steps_trained_in_current_epoch = 0

    tr_loss, logging_loss = 0.0, 0.0
    model.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 -= 1
                continue

            model.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 += 1

        logger.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=BertForClassification


config = 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_score

def 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.0
    nb_eval_steps = 0
    preds = None
    out_label_ids = None

    eval_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 += 1
        if 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_steps

    preds = 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=BertForClassification


config = 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 = None

    sampler =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 * 768
        hidden = hidden.squeeze(0)  # batch_size * 768
        hidden = F.relu(self.fc1(hidden))  # batch_size * 30
        hidden = F.softmax(self.fc2(hidden),dim = 1)  # batch_size * 10
        return hidden

def 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,label

def get_iterator_batch(data,batch_size):
    data_iter = get_text_and_label_index_iterator(data)
    continue_iterator = True
    while continue_iterator:
        data_list = []
        for _ in range(batch_size):
            try:
                #next是获取下一个迭代器对象的方法，直到异常的时候结束
                data = next(data_iter)
                data_list.append(data)
            except StopIteration:
                continue_iterator = False


        text_list = []
        label_list = []

        for data in data_list:
            text, label = data
            text_list.append(text)
            label_list.append(label)

        yield torch.tensor(text_list), torch.tensor(label_list)

    return False





def train_model(model, data, optimizer, loss_fn):  # 训练函数
    epoch_loss = 0
    epoch_acc = 0
    total_len = 0
    model.train()
    batch_size=16

    dataset_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=emb
        labels=iteration

        predictions = 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_len


def evaluate_model(model, data, loss_fn):  # 评估函数
    epoch_loss = 0
    epoch_acc = 0
    total_len = 0
    batch_size = 16

    model.eval()

    with torch.no_grad():
        dataset_iterator = get_iterator_batch(data, batch_size)
        for  emb,iteration in dataset_iterator:
            embedding=emb
            label = iteration
            predictions = 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_len

from 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的那几个输入即可。文本分类任务的扩展是泛化能力和大规模迁移学习，如果遇到很多没有标签的文本怎么处理，互联网每天都会更新大量文本，模型要对这些新的文本有泛化性。数学和逻辑是计算机中的精髓所在，要能抽象问题，用这数学和逻辑的思维和方式来解决问题。需要完整项目的可以邮箱联系我[email protected]，喜欢C++的nlp方向在读硕士欢迎大家一起讨论