精华内容
下载资源
问答
  • PyTorch的BERT中文文本分类 此存储库包含用于中文文本分类的预训练BERT模型的PyTorch实现。 代码结构 在项目的根目录,您将看到: ├── pybert | └── callback | | └── lrscheduler.py  | | └── ...
  • BERT文本分类数据

    2021-01-11 21:27:54
    BERT文本分类代码对应的数据
  • pytorch-bert文本分类

    2021-06-18 14:50:26
    基于bert预训练模型和pytorch深度学习框架实现文本分类
  • 本文主要介绍使用Prompt的MLM文本分类 bert4keras的代码实现,用以丰富bert4keras框架的例子 关于prompt的原理的文章网上有很多优秀的文章可以自行百度。 github地址 hgliyuhao/Prompt4Classification (github.com...

    本文主要介绍使用Prompt的MLM文本分类 bert4keras的代码实现,用以丰富bert4keras框架的例子 关于prompt的原理的文章网上有很多优秀的文章可以自行百度。

    github地址

    hgliyuhao/Prompt4Classification (github.com)

    transformers,torch 实现的版本可以参考 

    基于Prompt的MLM文本分类_u013546508的博客-CSDN博客

    数据介绍

    剧烈运动后咯血,是怎么了?剧烈运动后为什么会咯血?1
    剧烈运动后咯血,是怎么了?剧烈运动后咯血,应该怎么处理?0

    每条数据是包含两句话 和一个标签 ,如果标签为1证明两句话意思相同 为0则证明意思不同

    所以是一个分类任务

    模型设计

    使用mlm模型,将分类任务转换成一个填空任务,再根据填空的结果决定分类结果。

    根据任务和数据特点设计Prompt:两句话意思【mask】同。

    所以对应模型的输入是 两句话意思【mask】同 :text1 ;text2

    对应的label 如果标签为1 label 为‘相’,标签为0 label 为 ‘不’

    因为在预测的时候是使用生成模型,为了确定mask结果的任务,所以Prompt要位于句子开头

    代码细节

    由于需要使用mlm 要在引入模型的时候加入with_mlm=True

    model = build_transformer_model(
        config_path,
        checkpoint_path,
        with_mlm=True,
        keep_tokens=keep_tokens,  # 只保留keep_tokens中的字,精简原字表
    )

    下面重点说一下输入输出格式

    class data_generator(DataGenerator):
    
        def __iter__(self, random=False):
    
            """单条样本格式为
                输入:[CLS]两句话意思[MASK]同,text1,text2[SEP]
                输出:'相'或者'不'
            """
            idxs = list(range(len(self.data)))
            if random:
                np.random.shuffle(idxs)
            batch_token_ids, batch_segment_ids, batch_a_token_ids = [], [], []
            
            for i in idxs:
    
                data = self.data[i]
                text = "两句话意思相同"
                text1 = data[0]
                text2 = data[1]
                label = data[2]
    
                final_text = text + ':' + text1 + ',' + text2            
                token_ids, segment_ids = tokenizer.encode(final_text, maxlen=maxlen)
                
                # mask掉'相'字
                token_ids[6] = tokenizer._token_mask_id
    
                if label == 0:
                    a_token_ids, _ = tokenizer.encode('不')
                else:
                    a_token_ids, _ = tokenizer.encode('相')   
    
                batch_token_ids.append(token_ids)
                batch_segment_ids.append(segment_ids)
                batch_a_token_ids.append(a_token_ids[1:])
    
                if len(batch_token_ids) == self.batch_size or i == idxs[-1]:
                    batch_token_ids = sequence_padding(batch_token_ids)
                    batch_segment_ids = sequence_padding(batch_segment_ids)
                    batch_a_token_ids = sequence_padding(
                        batch_a_token_ids, 1
                    )
                    yield [batch_token_ids, batch_segment_ids], batch_a_token_ids
                    batch_token_ids, batch_segment_ids, batch_a_token_ids = [], [], []

    token_ids[6] = tokenizer._token_mask_id  是将 "两句话意思相同" 转换成"两句话意思【mask】同"

    batch_a_token_ids.append(a_token_ids[1:]) 这里(a_token_ids[1:] 是为了将cls 去掉

    batch_a_token_ids = sequence_padding(batch_a_token_ids, 1) 这里是设置生成文本的长度,因为我们这个任务只需要预测结果为‘相’或者为‘不’所以 长度设置为1

    结尾

    最近看了很多对prompt的文章,大家对于这种方法都很认可,认为它在很多任务中是有优势的,后面也会多对prompt尝试吧。

    展开全文
  • self.dense = nn.Linear(768, 15) #bert默认的隐藏单元数是768, 输出单元是2,表示二分类 def forward(self, batch_sentences): batch_tokenized = self.tokenizer.batch_encode_plus(batch_sentences, padding=...

    数据集请看 我这个博客:https://download.csdn.net/download/qq_38735017/15727270 

    https://blog.csdn.net/a553181867/article/details/105389757/?utm_medium=distribute.pc_relevant.none-task-blog-baidulandingword-2&spm=1001.2101.3001.4242 https://blog.csdn.net/a553181867/article/details/105389757/?utm_medium=distribute.pc_relevant.none-task-blog-baidulandingword-2&spm=1001.2101.3001.4242

    https://huggingface.co/transformers/preprocessing.html

    import torch
    from torch import nn
    from torch import optim
    import transformers as tfs
    import math
    import numpy as np
    import pandas as pd
    from sklearn.metrics import f1_score
    import warnings
    
    warnings.filterwarnings('ignore')

     

    train_df = pd.read_csv('TNEWS_train1128.csv', delimiter='\t', header=None)
    #print(train_df.shape) (63360, 3) #标号一列 ,句子是一列  情感分类是一列 
    #类别一共是15类 {100, 101, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116}
    # train_set=train_df[2:60000]
    # lang=[]
    # for i in train_set[2]:
      
    #     lang.append(i)
    # print(set(lang))
    # print(len(set(lang)))
    #句子的平均长度是22
    
    def read_batch_data (act,end):
        train_set = train_df[int(act):int(end)]   #取其中的3000条数据作为我们的数据集
        batch_train_inputs=np.array(train_set[1])
        batch_train_targets=np.array(train_set[2])
        return batch_train_inputs,batch_train_targets
    
    
    

     

    model_class, tokenizer_class, pretrained_weights = (tfs.BertModel, tfs.BertTokenizer, 'bert-base-chinese')
    #                                                    模型             分词器            词汇表  
    tokenizer = tokenizer_class.from_pretrained(pretrained_weights)#定义分词器
    
    model = model_class.from_pretrained(pretrained_weights)#定义模型
    class BertClassificationModel(nn.Module):
        def __init__(self):
            super(BertClassificationModel, self).__init__()   
            model_class, tokenizer_class, pretrained_weights = (tfs.BertModel, tfs.BertTokenizer, 'bert-base-chinese')         
            self.tokenizer = tokenizer_class.from_pretrained(pretrained_weights)
            self.bert = model_class.from_pretrained(pretrained_weights)
            self.dense = nn.Linear(768, 15)  #bert默认的隐藏单元数是768, 输出单元是2,表示二分类
        def forward(self, batch_sentences):
            batch_tokenized = self.tokenizer.batch_encode_plus(batch_sentences, padding=True, truncation=True, max_length=50)      #tokenize、add special token、pad
    #         padding=True, truncation=True, max_length=42
            input_ids = torch.tensor(batch_tokenized['input_ids'])
            attention_mask = torch.tensor(batch_tokenized['attention_mask'])
            bert_output = self.bert(input_ids, attention_mask=attention_mask)
            bert_cls_hidden_state = bert_output[0][:,0,:]       #提取[CLS]对应的隐藏状态
            linear_output = self.dense(bert_cls_hidden_state)
            return linear_output

     

    label_index={'100':0, '101':1, '102':2, '103':3, '104':4, '106':5, '107':6,"108":7,"109":8,"110":9,"112":10,"113":11,"114":12,"115":13,"116":14}
    #类别一共是15类 {100, 101, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116}
    epochs = 6
    lr = 0.01
    bert_classifier_model = BertClassificationModel()
    optimizer = optim.SGD(bert_classifier_model.parameters(), lr=lr, momentum=0.9)
    criterion = nn.CrossEntropyLoss()

     

    for epoch in range(epochs):
        print("第",epoch,"个epoch")
        for i in range(1,860,1):
            inputs,targets=read_batch_data (i,i+64)
            a=[]
            for q in targets:
    #             print(q)
                idx=label_index[str(q)]
                a.append(idx)
            labels = torch.tensor(a)  
            optimizer.zero_grad()
            outputs = bert_classifier_model(inputs)
    #         print(outputs.size())
            loss = criterion(outputs, labels) # 交叉熵损失函数 必须是两个tensor进行计算啊
            
            loss.backward()
            optimizer.step()
    #         print("第",i,"batch","loss",loss.item())
        
        torch.save(bert_classifier_model.state_dict(), 'TNEWStrainModel'+str(epoch)+'.pth') 
    #模型加载:
    bert_classifier_mode = BertClassificationModel()
    bert_classifier_mode.load_state_dict(torch.load('TNEWStrainModel0.pth'))
    bert_classifier_mode.eval() 
    label_index={'100':0, '101':1, '102':2, '103':3, '104':4, '106':5, '107':6,"108":7,"109":8,"110":9,"112":10,"113":11,"114":12,"115":13,"116":14}
    #类别一共是15类 {100, 101, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116}
    def test(): #     一条一条的进行测试:
        y_pred=[]
        y_true=[]
        for i in range(20000,21000,1):
            
            with torch.no_grad():
                inputs,targets=read_batch_data (i,i+1)
                a=[]
                for q in targets:
    
                    idx=label_index[str(q)]
                    a.append(idx)
    #             labels = torch.tensor(a)  
                optimizer.zero_grad()
                outputs = bert_classifier_model(inputs)
                #         print(outputs.size())
                outputs=outputs.view(1,-1)
                outputs=np.argmax(outputs)
                y_pred.append(outputs.item())
                y_true.append(a[0]) # 一次只测试一个数据 
        return y_true, y_pred
    
    
    y_true, y_pred=test()
    print(len(y_pred))
    # print(y_true)
    Fa=f1_score(y_true, y_pred, average='macro') 
    # Faw=f1_score(y_true, y_pred, average='weighted') 
    print(Fa)
    # print(Faw)
    
    me v:18340082396

     

     

     

     

    展开全文
  • Bert文本分类(基于keras-bert实现)

    万次阅读 多人点赞 2019-10-25 17:48:34
    二、Bert 模型文本分类 1、数据准备 2、代码实现 3、分类过程与结果 一、Bert 预训练模型准备 中文预训练模型下载 当Bert遇上Keras:这可能是Bert最简单的打开姿势 keras-bert 不同模型的性能对比如下(可根据...

    目录

    一、Bert 预训练模型准备

    二、Bert 模型文本分类

    1、数据准备

    2、代码实现

    3、分类过程与结果


    一、Bert 预训练模型准备

    中文预训练模型下载      当Bert遇上Keras:这可能是Bert最简单的打开姿势      keras-bert

    不同模型的性能对比如下(可根据自己的数据选择合适的模型,模型越大需要训练的时间越长)

    模型开发集测试集
    BERT83.1 (82.7) / 89.9 (89.6)82.2 (81.6) / 89.2 (88.8)
    ERNIE73.2 (73.0) / 83.9 (83.8)71.9 (71.4) / 82.5 (82.3)
    BERT-wwm84.3 (83.4) / 90.5 (90.2)82.8 (81.8) / 89.7 (89.0)
    BERT-wwm-ext85.0 (84.5) / 91.2 (90.9)83.6 (83.0) / 90.4 (89.9)
    RoBERTa-wwm-ext86.6 (85.9) / 92.5 (92.2)85.6 (85.2) / 92.0 (91.7)
    RoBERTa-wwm-ext-large89.6 (89.1) / 94.8 (94.4)89.6 (88.9) / 94.5 (94.1)

    二、Bert 模型文本分类

    1、数据准备

    使用的仍是用户评论情感极性判别的数据

    训练集:data_train.csv ,样本数为82025,情感极性标签(0:负面、1:中性、2:正面) 

    测试集:data_test.csv ,样本数为35157

    评论数据主要包括:食品餐饮类,旅游住宿类,金融服务类,医疗服务类,物流快递类;部分数据如下:

    2、代码实现

    import pandas as pd
    import codecs, gc
    import numpy as np
    from sklearn.model_selection import KFold
    from keras_bert import load_trained_model_from_checkpoint, Tokenizer
    from keras.metrics import top_k_categorical_accuracy
    from keras.layers import *
    from keras.callbacks import *
    from keras.models import Model
    import keras.backend as K
    from keras.optimizers import Adam
    from keras.utils import to_categorical
    
    #读取训练集和测试集
    train_df=pd.read_csv('data/data_train.csv', sep='\t', names=['id', 'type', 'contents', 'labels']).astype(str)
    test_df=pd.read_csv('data/data_test.csv', sep='\t', names=['id', 'type', 'contents']).astype(str)
    
    maxlen = 100  #设置序列长度为120,要保证序列长度不超过512
    
    #预训练好的模型
    config_path = 'chinese_roberta_wwm_large_ext_L-24_H-1024_A-16/bert_config.json'
    checkpoint_path = 'chinese_roberta_wwm_large_ext_L-24_H-1024_A-16/bert_model.ckpt'
    dict_path = 'chinese_roberta_wwm_large_ext_L-24_H-1024_A-16/vocab.txt'
    
    #将词表中的词编号转换为字典
    token_dict = {}
    with codecs.open(dict_path, 'r', 'utf8') as reader:
        for line in reader:
            token = line.strip()
            token_dict[token] = len(token_dict)
    
    #重写tokenizer        
    class OurTokenizer(Tokenizer):
        def _tokenize(self, text):
            R = []
            for c in text:
                if c in self._token_dict:
                    R.append(c)
                elif self._is_space(c):
                    R.append('[unused1]')  # 用[unused1]来表示空格类字符
                else:
                    R.append('[UNK]')  # 不在列表的字符用[UNK]表示
            return R
    tokenizer = OurTokenizer(token_dict)
    
    #让每条文本的长度相同,用0填充
    def seq_padding(X, padding=0):
        L = [len(x) for x in X]
        ML = max(L)
        return np.array([
            np.concatenate([x, [padding] * (ML - len(x))]) if len(x) < ML else x for x in X
        ])
    
    #data_generator只是一种为了节约内存的数据方式
    class data_generator:
        def __init__(self, data, batch_size=32, shuffle=True):
            self.data = data
            self.batch_size = batch_size
            self.shuffle = shuffle
            self.steps = len(self.data) // self.batch_size
            if len(self.data) % self.batch_size != 0:
                self.steps += 1
    
        def __len__(self):
            return self.steps
    
        def __iter__(self):
            while True:
                idxs = list(range(len(self.data)))
    
                if self.shuffle:
                    np.random.shuffle(idxs)
    
                X1, X2, Y = [], [], []
                for i in idxs:
                    d = self.data[i]
                    text = d[0][:maxlen]
                    x1, x2 = tokenizer.encode(first=text)
                    y = d[1]
                    X1.append(x1)
                    X2.append(x2)
                    Y.append([y])
                    if len(X1) == self.batch_size or i == idxs[-1]:
                        X1 = seq_padding(X1)
                        X2 = seq_padding(X2)
                        Y = seq_padding(Y)
                        yield [X1, X2], Y[:, 0, :]
                        [X1, X2, Y] = [], [], []
    
    #计算top-k正确率,当预测值的前k个值中存在目标类别即认为预测正确                 
    def acc_top2(y_true, y_pred):
        return top_k_categorical_accuracy(y_true, y_pred, k=2)
    
    #bert模型设置
    def build_bert(nclass):
        bert_model = load_trained_model_from_checkpoint(config_path, checkpoint_path, seq_len=None)  #加载预训练模型
    
        for l in bert_model.layers:
            l.trainable = True
    
        x1_in = Input(shape=(None,))
        x2_in = Input(shape=(None,))
    
        x = bert_model([x1_in, x2_in])
        x = Lambda(lambda x: x[:, 0])(x) # 取出[CLS]对应的向量用来做分类
        p = Dense(nclass, activation='softmax')(x)
    
        model = Model([x1_in, x2_in], p)
        model.compile(loss='categorical_crossentropy',
                      optimizer=Adam(1e-5),    #用足够小的学习率
                      metrics=['accuracy', acc_top2])
        print(model.summary())
        return model
    
    #训练数据、测试数据和标签转化为模型输入格式
    DATA_LIST = []
    for data_row in train_df.iloc[:].itertuples():
        DATA_LIST.append((data_row.contents, to_categorical(data_row.labels, 3)))
    DATA_LIST = np.array(DATA_LIST)
    
    DATA_LIST_TEST = []
    for data_row in test_df.iloc[:].itertuples():
        DATA_LIST_TEST.append((data_row.contents, to_categorical(0, 3)))
    DATA_LIST_TEST = np.array(DATA_LIST_TEST)
    
    #交叉验证训练和测试模型
    def run_cv(nfold, data, data_labels, data_test):
        kf = KFold(n_splits=nfold, shuffle=True, random_state=520).split(data)
        train_model_pred = np.zeros((len(data), 3))
        test_model_pred = np.zeros((len(data_test), 3))
    
        for i, (train_fold, test_fold) in enumerate(kf):
            X_train, X_valid, = data[train_fold, :], data[test_fold, :]
    
            model = build_bert(3)
            early_stopping = EarlyStopping(monitor='val_acc', patience=3)   #早停法,防止过拟合
            plateau = ReduceLROnPlateau(monitor="val_acc", verbose=1, mode='max', factor=0.5, patience=2) #当评价指标不在提升时,减少学习率
            checkpoint = ModelCheckpoint('./bert_dump/' + str(i) + '.hdf5', monitor='val_acc',verbose=2, save_best_only=True, mode='max', save_weights_only=True) #保存最好的模型
    
            train_D = data_generator(X_train, shuffle=True)
            valid_D = data_generator(X_valid, shuffle=True)
            test_D = data_generator(data_test, shuffle=False)
            #模型训练
            model.fit_generator(
                train_D.__iter__(),
                steps_per_epoch=len(train_D),
                epochs=5,
                validation_data=valid_D.__iter__(),
                validation_steps=len(valid_D),
                callbacks=[early_stopping, plateau, checkpoint],
            )
    
            # model.load_weights('./bert_dump/' + str(i) + '.hdf5')
    
            # return model
            train_model_pred[test_fold, :] = model.predict_generator(valid_D.__iter__(), steps=len(valid_D), verbose=1)
            test_model_pred += model.predict_generator(test_D.__iter__(), steps=len(test_D), verbose=1)
    
            del model
            gc.collect()   #清理内存
            K.clear_session()   #clear_session就是清除一个session
            # break
    
        return train_model_pred, test_model_pred
    
    #n折交叉验证
    train_model_pred, test_model_pred = run_cv(2, DATA_LIST, None, DATA_LIST_TEST)
    
    test_pred = [np.argmax(x) for x in test_model_pred]
    
    #将测试集预测结果写入文件
    output=pd.DataFrame({'id':test_df.id,'sentiment':test_pred})
    output.to_csv('data/results.csv', index=None)
    
    

    3、分类过程与结果

    在服务器上跑了两天,终于完成了……

    最终提交结果F1-score达到了94.90%,比使用的其他模型效果都好。

    直接看排名结果,一下子上升到了第一,哈哈哈

     

     

    展开全文
  • Bert实战--文本分类(一)

    千次阅读 2020-02-20 15:05:44
    使用Bert预训练模型进行文本分类 bert文本分类,简单来说就是将每句话的第一个位置加入了特殊分类嵌入[CLS]。而该[CLS]包含了整个句子的信息,它的最终隐藏状态(即,Transformer的输出)被用作分类任务的聚合序列...

    使用Bert预训练模型进行文本分类

    bert做文本分类,简单来说就是将每句话的第一个位置加入了特殊分类嵌入[CLS]。而该[CLS]包含了整个句子的信息,它的最终隐藏状态(即,Transformer的输出)被用作分类任务的聚合序列表示。

    下载bert预训练模型

    Google提供了多种预训练好的bert模型,有针对不同语言的和不同模型大小的。我们的任务是针对临床试验筛选标准进行分类,是中文模型,所以我们下载的是Bert-Base, Chinese这个模型Bert模型下载链接
    该模型解压后的目录包含bert_config.json(模型的超参数),bert_model.ckpt.data-00000-of-00001,bert_model.ckpt.index,bert_model_ckpt.meta(保存预训练模型与权重的 ckpt 文件)和vocab.txt(词表)五个文件。

    在自己的数据集微调过程

    任务介绍

    根据预先给定的44个类别和一系列中文临床试验筛选标准的描述句子,判断该中文临床医学描述句子属于的类别。
    在这里插入图片描述

    评价指标

    本任务的评价指标包括宏观准确率(Macro Precision)、宏观召回率(Macro Recall)、Average F1值。最终排名以Average F1值为基准。假设我们有n个类别,C1, … …, Ci, … …, Cn。
    宏观准确率Pi=正确预测为类别Ci的样本个数/预测为Ci类样本的个数
    召回率Ri=正确预测为类别Ci的样本个数/真实的Ci类样本的个数
    平均F1=(1/n)求和[(2Pi*Ri)/(Pi+Ri)]

    前期数据分析

    训练集数据22962条
    验证机数据7682条
    测试集数据7697条
    统计每个句子的长度,看大部分的句子长度为多少,则将最长的句子设为多少
    句子最长为341个字,最短为2个字

    前期数据准备
    1. 我的数据格式如下:
      要先对数据进行一定的处理,初略观察数据集,数据集中包含无用的标点符号、数字,去除这些部分,同时对文本进行分词去除掉停用词。最后得到 label+句子的格式,中间用’\t’分隔
      在这里插入图片描述

    将数据集中的后两列提取出来,同时把句子中的停用词去除,得到的结果写入到train_data.csv中

    #将训练集提取标签和句子
    将训练集提取标签和句子,并过滤停用词
    lines=open(train_path,encoding='utf-8').read().split('\n')
    with open(new_train,'w',encoding='utf-8')as w:
        content=''
        for i in range(len(lines)-1):
            output=''
            item=lines[i].split('\t')
            content += str(item[1])
            content += '\t'
            seg=jieba.cut(str(item[2]),cut_all=False)
            for j in seg:
                if j not in stopwordset:
                    output+=j
            content += str(output)
            content += '\n'
            # print(content)
        w.write(str(content))
    w.close()
    

    得到处理后的数据如下:
    在这里插入图片描述
    2. 我们需要在run_classifiler.py中定义自己任务的DataProcessor子类,根据我们数据集的格式重写获取训练集、开发集、测试集的样本数据的方法以及获取标签的方法
    在这里插入图片描述
    我们可以仿照Cola处理器来写我们自己文本分类的处理器
    在这里插入图片描述
    我自己文本分类的处理器,一共分为44个类别

    class classification(DataProcessor):
        def get_train_examples(self, data_dir):
            return self._create_examples(
                self._read_tsv(os.path.join(data_dir, "train_data.csv")), "train")
    
        def get_dev_examples(self, data_dir):
            return self._create_examples(
                    self._read_tsv(os.path.join(data_dir, "val_data.csv")), "dev")
    
        def get_test_examples(self, data_dir):
            return self._create_examples(
                    self._read_tsv(os.path.join(data_dir, "test_data.csv")), "test")
    
        def get_labels(self):#一共有44个标签
            return ['Disease', 'Symptom','Sign','Pregnancy-related Activity','Neoplasm Status','Non-Neoplasm Disease Stage','Allergy Intolerance',
                     'Organ or Tissue Status','Life Expectancy', 'Oral related','Pharmaceutical Substance or Drug','Therapy or Surgery','Device',
                     'Nursing','Diagnostic', 'Laboratory Examinations','Risk Assessment','Receptor Status','Age','Special Patient Characteristic',
                     'Literacy','Gender','Education', 'Address','Ethnicity','Consent','Enrollment in other studies','Researcher Decision',
                     'Capacity','Ethical Audit','Compliance with Protocol','Addictive Behavior', 'Bedtime','Exercise',
                     'Diet','Alcohol Consumer','Sexual related', 'Smoking Status','Blood Donation','Encounter','Disabilities','Healthy',
                     'Data Accessible','Multiple']
        def _create_examples(self, lines, set_type):
            """Creates examples for the training and dev sets."""
            examples = []
            for (i, line) in enumerate(lines):
                guid = "%s-%s" % (set_type, i)
                if set_type=="test":
                    text_a = tokenization.convert_to_unicode(line[0])
                    label = "Disease"#当是测试集的时候,标签默认为disease
                else:
                    text_a = tokenization.convert_to_unicode(line[1])
                    label = tokenization.convert_to_unicode(line[0])
                examples.append(
                        InputExample(guid=guid, text_a=text_a, text_b=None, label=label))
    
            return examples
    
    1. 在run_classifiler.py中修改main函数,将自己写的文本分类处理器加入到processors中
      processors = {
          "cola": ColaProcessor,
          "mnli": MnliProcessor,
          "mrpc": MrpcProcessor,
          "xnli": XnliProcessor,
          "task":classification,
      }
    
    1. 执行run_classifiler.py
      在这里插入图片描述
      需要必填参数data_dir,task_name,vocab_file,bert_config_file,output_dir。参数do_train,do_eval和do_predict分别控制了是否进行训练,评估和预测,可以按需将其设置为True或者False
    2. 参数的设置
    python run_classifier.py 
      --data_dir=data 
      --task_name=classification
      --vocab_file=chinese_L-12_H-768_A-12R/vocab.txt 
      --bert_config_file=chinese_L-12_H-768_A-12/bert_config.json 
      --output_dir=output
      --do_train=true 
      --do_eval=false
      --init_checkpoint=chinese_L-12_H-768_A-12/bert_model.ckpt 
      --max_seq_length=200 (句子的最大长度,可以根据数据集大部分数据的长度来设计)
      --train_batch_size=16 (如果内存太小可以适当缩小,每轮喂入的多少条数据)
      --learning_rate=5e-5
      --num_train_epochs=2.0
    
    1. 可以增加验证集的指标在分类时,我们可能还需要看auc,recall,precision的值。
       def metric_fn(per_example_loss, label_ids, logits, is_real_example):
            predictions = tf.argmax(logits, axis=-1, output_type=tf.int32)
            #求loggits[batch size,num_labels]的行最大值的下标
            accuracy = tf.metrics.accuracy(
                labels=label_ids, predictions=predictions, weights=is_real_example)
            auc=tf.metrics.auc(labels=label_ids,predictions=predictions,weights=is_real_example)
            precision=tf.metrics.precision(labels=label_ids,predictions=predictions,weights=is_real_example)
            recall=tf.metrics.recall(labels=label_ids,predictions=predictions,weights=is_real_example)
            f1_score=tf.metrics.mean((2*precision*recall)/(precision+recall))
            loss = tf.metrics.mean(values=per_example_loss, weights=is_real_example) #求加权平均loss
            return {
                "eval_accuracy": accuracy,
                "eval_auc":auc,
                "eval_precision":precision,
                "eval_recall":recall,
                "eval_f1":f1_score,
                "eval_loss": loss,
            }
    

    成功运行

    python run_classifier.py  -—bert_config_file=chinese_L-12_H-768_A-12/bert_config.json --vocab_file=chinese_L-12_H-768_A-12/vocab.txt --init_checkpoint=chinese_L-12_H-768_A-12/bert_model.ckpt
    

    在这里插入图片描述
    将输入转为特征
    在这里插入图片描述
    从init_checkpoint读取参数
    在这里插入图片描述
    因为自己电脑cpu跑的原因,所以选择了部分数据,训练的轮次也设得很小,效果不是很好。
    在这里插入图片描述

    参考
    教程:使用Bert预训练模型文本分类
    BERT文本分类使用指南
    文本分类实战(十)—— BERT 预训练模型

    展开全文
  • bert textcnn用于文本分类

    千次阅读 2020-09-23 15:13:25
    使用keras_bert来加载构建bert模型
  • bert中文预训练模型下载地址: 链接:https://pan.baidu.com/s/14JcQXIBSaWyY7bRWdJW7yg 提取码:mvtl 复制run_classifier.py,命名为run_cnews_cls.py。添加自定义的Processor class MyProcessor(D
  • 目录理论Transformer原理基于预训练语言模型的词表示基于Bert的文本分类Bert PretrainBert Finetune 理论 Transformer原理 Transformer是在"Attention is All You Need"中提出的,模型的编码部分是一组编码器的堆叠...
  • 基于Pytorch的Bert应用,包括命名实体识别、情感分析、文本分类以及文本相似度等(后续更新其他方向相关模块),并有相关数据与深度训练优化方式api。各个子项目大都为开源工作,本项目仅做相应处理以及提供一个已训练...
  • 首先定义一个配置文件类,类里边存放Bert和LSTM的一些超参数 class Config(object): ''' 配置参数 ''' def __init__(self,dataset): self.model_name='Bert RNN Model' # 训练集,测试集,检验集,类别,模型...
  • 新闻文本分类之旅 BERT

    千次阅读 2020-08-22 11:01:25
    预训练BERT以及相关代码下载地址: 链接: https://pan.baidu.com/s/1zd6wN7elGgp1NyuzYKpvGQ 提取码: tmp5 我们知道BERT模型的输入有三部分:token embedding,segment embedding以及position embedding。 词向量的...
  • 基于pytorch的 BERT中文文本分类

    万次阅读 2019-05-05 16:46:09
    转载一篇基于 pytorch 的BERT文本分类: https://blog.csdn.net/Real_Brilliant/article/details/84880528
  • 利用bert进行文本分类

    千次阅读 2020-01-13 17:51:11
    实现利用bert预训练模型进行中文新闻分类,使用的数据集情况: 其中,train.txt, dev.txt, test.txt内容格式为每一行为“内容 Tab 标签”: class.txt内容为10类的新闻标签,如上面的0就代表finance这一类。 2、...
  • 最近使用Bert实现了文本分类,模型使用的是bert的base版本。本文记录一下实现过程。 数据集:cnews,包含三个文件,分别是cnews.train.txt、cnews.test.txt、cnews.val.txt。类别包含10类,分别是:体育、娱乐、家居...
  • bert模型文本分类

    千次阅读 2019-01-11 16:12:57
    bert模型文本分类,实际这个东西google官方已经提供了代码,做文本分类实际是一个最简单的问题,下面用官方代码改了下,可以在低版本的tensorflow上运行,至于数据格式不再做多谈,就是input、inputmask、label,...
  • 基于BERT的超长文本分类模型

    千次阅读 2020-10-29 16:38:53
    基于BERT的超长文本分类模型 0.Abstract 1.任务介绍 数据集 评估方法 测试集 2.数据初步处理 3.Baseline模型 4. 数据进一步处理 分割文本 4.最终模型 ...
  • 本文基于Google开源的BERT代码进行了进一步的简化,方便生成句向量与做文本分类
  • Pytorch之Bert中文文本分类(二)

    千次阅读 2019-09-29 16:12:13
    本文主要是针对入门级别的Bert使用,包括英文文本分类和中文文本分类。 这部分主要使用Bert进行情感分析,属于中文文本分类,同样使用BertForSequenceClassification 数据集中包括三个情感分类等级[-1,0,1] 流程和...
  • 谷歌BERT文本分类教程
  • NLP之BERT中文文本分类超详细教程

    万次阅读 多人点赞 2019-04-24 14:38:35
    bert模型是Google在2018年10月发布的语言表示模型,Bert在NLP领域横扫了11项任务的最优结果,可以说是现今最近NLP中最重要的突破。Bert模型的全称是Bidirectional Encoder Representations from Transformers,是...
  • Transformer文本分类源码详解 参考论文 https://arxiv.org/abs/1706.03762 https://arxiv.org/abs/1810.04805 在本文中,我将以run_classifier.py以及MRPC数据集为例介绍关于bert以及transformer的源码,官方代码...
  • Bert实战之文本分类(附代码)

    千次阅读 2019-12-16 17:44:34
    Bert 是 Google 在 2018 年 10 月提出的一种利用大规模语料进行训练的语言模型,其通过Mask LM和sentence-level这两个子任务进行预训练。 2、Bert怎么用 2.1 fine-tune(微调) 通过加载预训练好的 Bert 模型,将...
  • 一行代码使用BERT生成句向量,BERT文本分类、文本相似度计算
  • 导读:bert性能优化的方法比较多,这一问题在NLP算法面试中时常被提起,平时做项目过程中,对bert模型进行优化也是经常遇到的。 对bert进行优化前,需要了解bert是个什么鬼,bert简言之是一个语言模型,它由Google...
  • 使用keras-bert实现 谭松波 酒店评论 文本分类(情感分析)-附件资源
  • Datawhale零基础入门NLP赛事-Task6TransformerBert模型基于Bert文本分类 本笔记是参加Datawhale零基础入门NLP赛事的学习笔记。 Transformer Transformer是在"Attention is All You Need"中提出的,模型的编码部分...
  • 自然语言处理(NLP): 12 BERT文本分类

    千次阅读 多人点赞 2020-04-08 23:03:57
    BERT介绍 BERT 论文阅读 来自论文《https://arxiv.org/pdf/1810.04805.pdf》 BERT说:“我要用 transformer 的 encoders” Ernie不屑道:“呵呵,你不能像Bi-Lstm一样考虑文章” BERT自信回答道:“我们会用masks” ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,287
精华内容 4,114
关键字:

文本分类bert