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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

训练全部代码

这里给出的是使用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}%')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818

分类结果

总结

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