精华内容
下载资源
问答
  • 基于BERT的+ X(softmax / CRF / BiLSTM + CRF) 罗伯塔+ X(softmax / CRF / BiLSTM + CRF) 本项目是的项目。 数据集 数据集第二届中文分词任务中的北京大学数据集。 模型 本项目实现了中文分词任务的baseline...
  • 首先定义一个配置文件类,类里边存放BertLSTM的一些超参数 class Config(object): ''' 配置参数 ''' def __init__(self,dataset): self.model_name='Bert RNN Model' # 训练集,测试集,检验集,类别,模型...

    1 配置文件

    首先定义一个配置文件类,类里边存放Bert和LSTM的一些超参数

    class Config(object):
        '''
        配置参数
        '''
        def __init__(self,dataset):
            self.model_name='Bert RNN Model'
            # 训练集,测试集,检验集,类别,模型训练结果保存路径
            # self.train_path=dataset+'/data/dev.txt'
            # self.test_path=dataset+'/data/dev.txt'
            # self.dev_path=dataset+'/data/dev.txt'
    
            self.train_path=dataset+'/data/train.txt'
            self.test_path=dataset+'/data/test.txt'
            self.dev_path=dataset+'/data/dev.txt'
    
            # python 数据结构保存路径
            self.datasetpkl = dataset + '/data/dataset.pkl'
    
            self.class_list=[x.strip() for x in open(dataset+'/data/class.txt').readlines()]
            self.save_path=dataset+'/saved_dict/'+self.model_name+'.ckpt'
    
            # 配置使用检测GPU
            self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
            # 若超过1000还没有提升就提前结束训练
            self.require_improvement=1000
            # 类别数
            self.num_classes = len(self.class_list)
    
            # 整体训练次数
            self.num_epoch=3
            # batch大小
            self.batch_size=128
            #每个序列最大token数
            self.pad_size=32
            #学习率
            self.learning_rate = 1e-5
    
            self.bert_path='bert_pretrain'
            self.tokenizer=BertTokenizer.from_pretrained(self.bert_path) #定义分词器
            self.hidden_size=768  # Bert模型 token的embedding维度 = Bert模型后接自定义分类器(单隐层全连接网络)的输入维度
    
            # RNN 隐含层数量
            self.rnn_hidden_size=256
            # RNN数量
            self.num_layers=256
            # dropout
            self.dropout=0.5
    

    在这个配置文件中,分别定义了一下内容:

    1. 测试集,训练集,开发集的原始数据存放路径
    2. 测试集,训练集,开发集转化成python内的数据结构后的存放路径 类别列表
    3. 模型训练使用的硬件(CPU还是GPU)
    4. 损失函数超过多少次没有提升提前结束训练 epoch数(整个数据集循环训练多少轮)
    5. batch_size
    6. 序列最大token数
    7. 学习率 模型的保存路径(本质上是保存的模型参数)
    8. 分词器
    9. Bert模型的隐含层节点数(经过Bert模型后,词向量的维度)
    10. RNN网络中每层网络的RNN节点数量
    11. RNN网络的层数
    12. dropout比例

    2 定义模型

    我们自定义的模型要继承自 nn.Module

    class Model(nn.Module):
        def __init__(self,config):
            super(Model,self).__init__()
            self.bert=BertModel.from_pretrained(config.bert_path)  #从路径加载预训练模型
            for param in self.bert.parameters():
                param.requires_grad = True # 使参数可更新
    
            # batch_first 参数设置batch维度在前还是序列维度在前(输入输出同步改变)
            # 在每个RNN神经元之间使用 dropout 在单个神经元内部的两个时间步长间不使用 dropout
            self.lstm=nn.LSTM(config.hidden_size,config.rnn_hidden_size,config.num_layers,batch_first=True,dropout=config.dropout,bias=True,bidirectional=True)
            self.dropout=nn.Dropout(config.dropout)
    
            # 双向LSTM要*2 分析LSTM节点数和网络层数时,看成神经元是LSTM全连接网络
            self.fc=nn.Linear(config.rnn_hidden_size*2,config.num_classes) # 自定义全连接层 ,输入数(输入的最后一个维度),输出数(多分类数量),bert模型输出的最后一个维度是768,这里的输入要和bert最后的输出统一
    
        def forward(self,x):
            context=x[0] #128*32 batch_size*seq_length
            mask=x[2]   #128*32 batch_size*seq_length
    
            # 第一个参数 是所有输入对应的输出  第二个参数 是 cls最后接的分类层的输出
            encoder,pooled = self.bert(context,attention_mask=mask,output_all_encoded_layers=False) # output_all_encoded_layers 是否将bert中每层(12层)的都输出,false只输出最后一层【128*768】
            out=self.lstm(encoder) # 128*10
            return out
    

    2.1 init(self,config)函数

    __ init __(self,config)函数中主要进行了如下操作:

    1. 加载预训练bert模型
    2. 将Bert模型中的参数设置为可更新
    3. 定义LSTM网络,参数的意义请参考下文
    4. 定义dropout层
    5. 定义全连接网络层

    其中,nn.LSTM()函数中的几个关键参数的解释如下:

    参数名称作用
    input_size输入数据的形状,这里指word embedding的维度
    hidden_sizeLSTM网络每层LSTM节点数量
    num_layersLSTM网络的网络层数
    biasLSTM网络是否包含bias
    batch_first输入数据的第一个维度是否代表batch编号
    dropoutdropout比例
    bidirectional是否使用双向LSTM网络

    注意:
    如果 bidirectional 参数为True,则LSTM的的输出的最后一个维度为 input_size*2,因为双向LSTM会将两个LSTM网络的输入拼接在一起

    2.2 forward(self,x)函数

    forward(self,x)函数是Bert中一个特殊文章函数,forward(self,x)函数详细解析请看此文章
    这里输入数据的结构为 [输入的token序列,序列真实长度,mask序列],输入数据的格式和数据预处理部分相关,在上一篇文章中已经讲解过数据预处理的代码,这里不做赘述

        def forward(self,x):
            context=x[0] #128*32 batch_size*seq_length
            mask=x[2]   #128*32 batch_size*seq_length
    
            # 第一个参数 是所有输入对应的输出  第二个参数 是 cls最后接的分类层的输出
            encoder,pooled = self.bert(context,attention_mask=mask,output_all_encoded_layers=False) # output_all_encoded_layers 是否将bert中每层(12层)的都输出,false只输出最后一层【128*768】
            out=self.lstm(encoder) # encoder维度[batch_size,pad_size,bert_hidden_size],out的维度为 [batch_size,pad_size,lstm_hidden_size]
            out =self.dropout(out)  
            out =out[:,-1,:]   #只要序列中最后一个token对应的输出,(因为lstm会记录前边token的信息)
            out =self.fc(out)
            return out
    

    forward(self,x)函数中主要进行了一下操作:

    1. 输入数据并得到预训练Bert模型的输出
    2. 得到LSTM模型的输出
    3. 经过dropout层,取每个序列中最后一个token的输出
    4. 将dropout层输入全连接层网络,并得到全连接层网络的输出

    关于bert模块两个返回值的深度解析请参考此文章 ->从源码层面,深入理解 Bert 框架

    展开全文
  • 自然语言处理(NLP)BertLstm结合

    千次阅读 热门讨论 2020-09-08 18:32:34
    本篇文章结合BertLstm,对文本数据进行二分类的研究。 需要的第三方库 pandas numpy torch transformers sklearn 以上这些库需要读者对机器学习、深度学习有一定了解 数据及预训练Bert 预训练好的BertBERT-...

    背景介绍

    自然语言处理(NLP)在深度学习领域是一大分支(其他:CV、语音),经过这些年的发展NLP发展已经很成熟,同时在工业界也慢慢开始普及,谷歌开放的Bert是NLP前进的又一里程碑。本篇文章结合Bert与Lstm,对文本数据进行二分类的研究。

    需要的第三方库

    • pandas
    • numpy
    • torch
    • transformers
    • sklearn

    以上这些库需要读者对机器学习、深度学习有一定了解

    数据及预训练Bert

    • 预训练好的Bert(BERT-wwm, Chinese 中文维基)
      https://github.com/ymcui/Chinese-BERT-wwm
    • 语料
      https://github.com/duo66/Data_for_ML-Deeplearning/blob/master/dianping.csv

    完整过程

    • 数据预处理
    import pandas as pd
    import numpy as np
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    from torch.utils.data import TensorDataset, DataLoader
    
    np.random.seed(2020)
    torch.manual_seed(2020)
    USE_CUDA = torch.cuda.is_available()
    if USE_CUDA:
        torch.cuda.manual_seed(2020)
    
    data=pd.read_csv('./dianping.csv',encoding='utf-8')
    
    #剔除标点符号,\xa0 空格
    def pretreatment(comments):
        result_comments=[]
        punctuation='。,?!:%&~()、;“”&|,.?!:%&~();""'
        for comment in comments:
            comment= ''.join([c for c in comment if c not in punctuation])
            comment= ''.join(comment.split())   #\xa0
            result_comments.append(comment)
        
        return result_comments
    
    result_comments=pretreatment(list(data['comment'].values))
    
    len(result_comments)
    

    2000

    result_comments[:1]
    

    [‘口味不知道是我口高了还是这家真不怎么样我感觉口味确实很一般很一般上菜相当快我敢说菜都是提前做好的几乎都不热菜品酸汤肥牛干辣干辣的还有一股泡椒味着实受不了环境室内整体装修确实不错但是大厅人多太乱服务一般吧说不上好但是也不差价格一般大众价格都能接受人太多了排队很厉害以后不排队也许还会来比如早去路过排队就不值了票据六日没票告我周一到周五可能有票相当不正规在这一点同等价位远不如外婆家’]

    • 利用transformers 先进行分字编码
    from transformers import BertTokenizer,BertModel
    
    tokenizer = BertTokenizer.from_pretrained("./chinese-bert_chinese_wwm_pytorch/data")
    
    result_comments_id=tokenizer(result_comments,padding=True,truncation=True,max_length=200,return_tensors='pt')
    
    result_comments_id
    

    {‘input_ids’: tensor([[ 101, 1366, 1456, …, 0, 0, 0],
    [ 101, 5831, 1501, …, 0, 0, 0],
    [ 101, 6432, 4696, …, 0, 0, 0],
    …,
    [ 101, 7566, 4408, …, 0, 0, 0],
    [ 101, 2207, 6444, …, 0, 0, 0],
    [ 101, 2523, 679, …, 0, 0, 0]]), ‘token_type_ids’: tensor([[0, 0, 0, …, 0, 0, 0],
    [0, 0, 0, …, 0, 0, 0],
    [0, 0, 0, …, 0, 0, 0],
    …,
    [0, 0, 0, …, 0, 0, 0],
    [0, 0, 0, …, 0, 0, 0],
    [0, 0, 0, …, 0, 0, 0]]), ‘attention_mask’: tensor([[1, 1, 1, …, 0, 0, 0],
    [1, 1, 1, …, 0, 0, 0],
    [1, 1, 1, …, 0, 0, 0],
    …,
    [1, 1, 1, …, 0, 0, 0],
    [1, 1, 1, …, 0, 0, 0],
    [1, 1, 1, …, 0, 0, 0]])}

    result_comments_id['input_ids'].shape
    

    torch.Size([2000, 200])

    • 分割数据集
    from sklearn.model_selection import train_test_split
    
    X=result_comments_id['input_ids']
    y=torch.from_numpy(data['sentiment'].values).float()
    
    X_train,X_test, y_train, y_test =train_test_split(X,y,test_size=0.3,shuffle=True,stratify=y,random_state=2020)
    
    len(X_train),len(X_test)
    

    (1400, 600)

    X_valid,X_test,y_valid,y_test=train_test_split(X_test,y_test,test_size=0.5,shuffle=True,stratify=y_test,random_state=2020)
    
    len(X_valid),len(X_test)
    

    (300, 300)

    X_train.shape
    

    torch.Size([1400, 200])

    y_train.shape
    

    torch.Size([1400])

    y_train[:1]
    

    tensor([1.])

    • 数据生成器
    # create Tensor datasets
    train_data = TensorDataset(X_train, y_train)
    valid_data = TensorDataset(X_valid, y_valid)
    test_data = TensorDataset(X_test,y_test)
    
    # dataloaders
    batch_size = 32
    
    # make sure the SHUFFLE your training data
    train_loader = DataLoader(train_data, shuffle=True, batch_size=batch_size,drop_last=True)
    valid_loader = DataLoader(valid_data, shuffle=True, batch_size=batch_size,drop_last=True)
    test_loader = DataLoader(test_data, shuffle=True, batch_size=batch_size,drop_last=True)
    
    • 建立模型
    if(USE_CUDA):
        print('Training on GPU.')
    else:
        print('No GPU available, training on CPU.')
    

    Training on GPU.

    class bert_lstm(nn.Module):
        def __init__(self, hidden_dim,output_size,n_layers,bidirectional=True, drop_prob=0.5):
            super(bert_lstm, self).__init__()
     
            self.output_size = output_size
            self.n_layers = n_layers
            self.hidden_dim = hidden_dim
            self.bidirectional = bidirectional
            
            #Bert ----------------重点,bert模型需要嵌入到自定义模型里面
            self.bert=BertModel.from_pretrained("../chinese-bert_chinese_wwm_pytorch/data")
            for param in self.bert.parameters():
                param.requires_grad = True
            
            # LSTM layers
            self.lstm = nn.LSTM(768, hidden_dim, n_layers, batch_first=True,bidirectional=bidirectional)
            
            # dropout layer
            self.dropout = nn.Dropout(drop_prob)
            
            # linear and sigmoid layers
            if bidirectional:
                self.fc = nn.Linear(hidden_dim*2, output_size)
            else:
                self.fc = nn.Linear(hidden_dim, output_size)
              
            #self.sig = nn.Sigmoid()
     
        def forward(self, x, hidden):
            batch_size = x.size(0)
            #生成bert字向量
            x=self.bert(x)[0]     #bert 字向量
            
            # lstm_out
            #x = x.float()
            lstm_out, (hidden_last,cn_last) = self.lstm(x, hidden)
            #print(lstm_out.shape)   #[32,100,768]
            #print(hidden_last.shape)   #[4, 32, 384]
            #print(cn_last.shape)    #[4, 32, 384]
            
            #修改 双向的需要单独处理
            if self.bidirectional:
                #正向最后一层,最后一个时刻
                hidden_last_L=hidden_last[-2]
                #print(hidden_last_L.shape)  #[32, 384]
                #反向最后一层,最后一个时刻
                hidden_last_R=hidden_last[-1]
                #print(hidden_last_R.shape)   #[32, 384]
                #进行拼接
                hidden_last_out=torch.cat([hidden_last_L,hidden_last_R],dim=-1)
                #print(hidden_last_out.shape,'hidden_last_out')   #[32, 768]
            else:
                hidden_last_out=hidden_last[-1]   #[32, 384]
                
                
            # dropout and fully-connected layer
            out = self.dropout(hidden_last_out)
            #print(out.shape)    #[32,768]
            out = self.fc(out)
            
            return out
        
        def init_hidden(self, batch_size):
            weight = next(self.parameters()).data
            
            number = 1
            if self.bidirectional:
                number = 2
            
            if (USE_CUDA):
                hidden = (weight.new(self.n_layers*number, batch_size, self.hidden_dim).zero_().float().cuda(),
                          weight.new(self.n_layers*number, batch_size, self.hidden_dim).zero_().float().cuda()
                         )
            else:
                hidden = (weight.new(self.n_layers*number, batch_size, self.hidden_dim).zero_().float(),
                          weight.new(self.n_layers*number, batch_size, self.hidden_dim).zero_().float()
                         )
            
            return hidden
    
    output_size = 1
    hidden_dim = 384   #768/2
    n_layers = 2
    bidirectional = True  #这里为True,为双向LSTM
    
    net = bert_lstm(hidden_dim, output_size,n_layers, bidirectional)
    
    #print(net)
    
    • 训练模型
    # loss and optimization functions
    lr=2e-5
    criterion = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(net.parameters(), lr=lr)
    
    # training params
    epochs = 10
    # batch_size=50
    print_every = 7
    clip=5 # gradient clipping
     
    # move model to GPU, if available
    if(USE_CUDA):
        net.cuda()
    
    net.train()
    # train for some number of epochs
    for e in range(epochs):
        # initialize hidden state
        h = net.init_hidden(batch_size)
        counter = 0
     
        # batch loop
        for inputs, labels in train_loader:
            counter += 1
            
            if(USE_CUDA):
                inputs, labels = inputs.cuda(), labels.cuda()
            h = tuple([each.data for each in h])
            net.zero_grad()
            output= net(inputs, h)
            loss = criterion(output.squeeze(), labels.float())
            loss.backward()
            optimizer.step()
     
            # loss stats
            if counter % print_every == 0:
                net.eval()
                with torch.no_grad():
                    val_h = net.init_hidden(batch_size)
                    val_losses = []
                    for inputs, labels in valid_loader:
                        val_h = tuple([each.data for each in val_h])
    
                        if(USE_CUDA):
                            inputs, labels = inputs.cuda(), labels.cuda()
    
                        output = net(inputs, val_h)
                        val_loss = criterion(output.squeeze(), labels.float())
    
                        val_losses.append(val_loss.item())
     
                net.train()
                print("Epoch: {}/{}...".format(e+1, epochs),
                      "Step: {}...".format(counter),
                      "Loss: {:.6f}...".format(loss.item()),
                      "Val Loss: {:.6f}".format(np.mean(val_losses)))
    

    Epoch: 1/10… Step: 7… Loss: 0.679703… Val Loss: 0.685275
    Epoch: 1/10… Step: 14… Loss: 0.713852… Val Loss: 0.674887

    Epoch: 10/10… Step: 35… Loss: 0.078265… Val Loss: 0.370415
    Epoch: 10/10… Step: 42… Loss: 0.171208… Val Loss: 0.323075

    • 测试
    test_losses = [] # track loss
    num_correct = 0
     
    # init hidden state
    h = net.init_hidden(batch_size)
     
    net.eval()
    # iterate over test data
    for inputs, labels in test_loader:
        h = tuple([each.data for each in h])
        if(USE_CUDA):
            inputs, labels = inputs.cuda(), labels.cuda()
        output = net(inputs, h)
        test_loss = criterion(output.squeeze(), labels.float())
        test_losses.append(test_loss.item())
        
        output=torch.nn.Softmax(dim=1)(output)
        pred=torch.max(output, 1)[1]
        
        # compare predictions to true label
        correct_tensor = pred.eq(labels.float().view_as(pred))
        correct = np.squeeze(correct_tensor.numpy()) if not USE_CUDA else np.squeeze(correct_tensor.cpu().numpy())
        num_correct += np.sum(correct)
    
    print("Test loss: {:.3f}".format(np.mean(test_losses)))
     
    # accuracy over all test data
    test_acc = num_correct/len(test_loader.dataset)
    print("Test accuracy: {:.3f}".format(test_acc))
    

    Test loss: 0.442
    Test accuracy: 0.827

    • 直接用训练的模型推断
    def predict(net, test_comments):
        result_comments=pretreatment(test_comments)   #预处理去掉标点符号
        
        #转换为字id
        tokenizer = BertTokenizer.from_pretrained("./chinese-bert_chinese_wwm_pytorch/data")
        result_comments_id=tokenizer(result_comments,padding=True,truncation=True,max_length=120,return_tensors='pt')
        tokenizer_id=result_comments_id['input_ids']
        inputs=tokenizer_id
        batch_size = inputs.size(0)
        
        # initialize hidden state
        h = net.init_hidden(batch_size)
        
        if(USE_CUDA):
            inputs = inputs.cuda()
        
        net.eval()
        with torch.no_grad():
            # get the output from the model
            output= net(inputs, h)
            output=torch.nn.Softmax(dim=1)(output)
            pred=torch.max(output, 1)[1]
            # printing output value, before rounding
            print('预测概率为: {:.6f}'.format(output.item()))
            if(pred.item()==1):
                print("预测结果为:正向")
            else:
                print("预测结果为:负向")
    
    comment1 = ['菜品一般,不好吃!!']
    predict(net, comment1)  
    

    预测概率为: 0.015379
    预测结果为:负向

    comment2 = ['环境不错']
    predict(net, comment2)
    

    预测概率为: 0.972344
    预测结果为:正向

    comment3 = ['服务员还可以,就是菜有点不好吃']
    predict(net, comment3)
    

    预测概率为: 0.581665
    预测结果为:正向

    comment4 = ['服务员还可以,就是菜不好吃']
    predict(net, comment4)
    

    预测概率为: 0.353724
    预测结果为:负向

    • 保存模型
    # 保存
    torch.save(net.state_dict(), './大众点评二分类_parameters.pth')
    
    • 加载保存的模型,进行推断
    output_size = 1
    hidden_dim = 384   #768/2
    n_layers = 2
    bidirectional = True  #这里为True,为双向LSTM
    
    net = bert_lstm(hidden_dim, output_size,n_layers, bidirectional)
    
    net.load_state_dict(torch.load('./大众点评二分类_parameters.pth'))
    

    <All keys matched successfully>

    # move model to GPU, if available
    if(USE_CUDA):
        net.cuda()
    
    comment1 = ['菜品一般,不好吃!!']
    predict(net, comment1)
    

    预测概率为: 0.015379
    预测结果为:负向

    展开全文
  • 浅谈bertlstm

    千次阅读 2020-03-19 11:54:30
    LSTM 概述: lstm是代表性的rnn结构,rnn提出是为了解决时序的问题;典型的例子就是NLP中的句子理解,视频的内容理解;模型结构的设计保证输入顺序按照时序顺序对结果产生影响,当前时间步的输入是当前位置和上一个...
    1. LSTM

    概述:
    lstm是代表性的rnn结构,rnn提出是为了解决时序的问题;典型的例子就是NLP中的句子理解,视频的内容理解;模型结构的设计保证输入顺序按照时序顺序对结果产生影响,当前时间步的输入是当前位置和上一个时间步的输出。

    优点:
    解决了dnn或者是bow词袋模型的问题,不能区分时序

    缺点:
    处理长文本的时候耗时较长,考虑到上下文,一般还采用双向rnn结构;模型效果上,对于长依赖问题效果不好,容易理解 经过很多个step的传递,信息会减弱

    1. BERT
      概述
      bert通过注意力机制实现时序的理解,我认为精妙之处有两点,一点是位置编码融入向量表达,另外一点是就是注意力机制中的QKV矩阵了;残差网络防止网络过于复杂带来的过拟合。

    优点
    注意力机制,也就是每个位置相对另一个位置的权重是可以并行计算的,在计算资源足够的前提下比lstm会快很多;通过设计预训练任务,用海量无监督数据做预训练,模型效果更好

    缺点
    由于网络更加复杂,计算量相对lstm更大,训练收敛更慢

    展开全文
  • bert+lstm+crf ner实体识别

    千次阅读 2020-08-14 17:32:19
    bert预训练中文模型下载:百度云下载地址:https://pan.baidu.com/s/16JJp6NMCjmIT8PqP9OfN4g 包含这些内容的整体下载下来 !pip install kashgari !pip install -i https://pypi.tuna.tsinghua.ed

    参考:
    https://github.com/BrikerMan/Kashgari

    https://eliyar.biz/nlp_chinese_text_classification_in_15mins/

    bert预训练中文模型下载:百度云下载地址:https://pan.baidu.com/s/16JJp6NMCjmIT8PqP9OfN4g
    包含这些内容的整体下载下来
    在这里插入图片描述

    !pip install kashgari

    !pip install -i https://pypi.tuna.tsinghua.edu.cn/simple tensorflow==1.14

    from kashgari.corpus import ChineseDailyNerCorpus
    
    train_x, train_y = ChineseDailyNerCorpus.load_data('train')
    valid_x, valid_y = ChineseDailyNerCorpus.load_data('validate')
    test_x, test_y  = ChineseDailyNerCorpus.load_data('test')
    
    
    print(f"train data count: {len(train_x)}")
    print(f"validate data count: {len(valid_x)}")
    print(f"test data count: {len(test_x)}")
    
    
    
    
    import kashgari
    from kashgari.embeddings import BERTEmbedding
    
    bert_embed = BERTEmbedding('/---刚下载的bert预训练模型目录-/uncased_L-12_H-768_A-12',
                               task=kashgari.LABELING,
                               sequence_length=100)
    
    
    from kashgari.tasks.labeling import BiLSTM_CRF_Model
    
    # 还可以选择 `CNN_LSTM_Model`, `BiLSTM_Model`, `BiGRU_Model` 或 `BiGRU_CRF_Model`
    
    model = BiLSTM_CRF_Model(bert_embed)
    model.fit(train_x,
              train_y,
              x_validate=valid_x,
              y_validate=valid_y,
              epochs=5,
              batch_size=512)
    
    model.evaluate(test_x, test_y)
    
    odel.save('./model')
    
    import random
    import kashgari
    # 加载模型
    loaded_model = kashgari.utils.load_model('cnn_classification_model')
    loaded_model.predict(random.sample(train_x, 10))
    
    # 预测指定样本
    news_sample = """「DeepMind 击败人类职业玩家的方式与他们声称的 AI 使命,以及所声称的『正确』方式完全相反。」
    DeepMind 的人工智能 AlphaStar 一战成名,击败两名人类职业选手。掌声和欢呼之余,它也引起了一些质疑。在前天 DeepMind 举办的 AMA 中,AlphaStar 项目领导者 Oriol Vinyals 和 David Silver、职业玩家 LiquidTLO 与 LiquidMaNa 回答了一些疑问。不过困惑依然存在……
    """
    x = list(jieba.cut(news_sample))
    y = loaded_model.predict([x])
    print(y[0]) # 输出游戏
    
    

    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • PyTorch中的LSTM-CRF 用于序列标记的双向LSTM-CRF的最小PyTorch(1.7.1)实现。 支持的功能: CUDA的小批量培训 嵌入层中的查找,CNN,RNN和/或自我关注 分层递归编码(HRE) 条件随机场(CRF)的PyTorch实现 ...
  • bert-lstm调参记录

    2021-11-07 12:17:42
    昨晚 sent_hidden_size=512:序列长度512(句子长度) batch_size=64 lr=4e-5 其它lr=lr*3 dropout=0.15 epoch=3 第二次选择: #定义全局超参数 ...lstm_dropout=0.5 ...第一次batch_size=32,bert_lr=5e-5,其它lr=
  • 数据集:数据集 选择了其中的10个类别 ##train.py ...from keras.layers import Input, Dense, LSTM, Conv1D, Concatenate,MaxPool1D,Flatten,Dropout,GlobalMaxPooling1D,Bidirectional,Lambda from kera
  • bert+lstm+crf做实体识别

    千次阅读 2019-09-04 15:16:18
    https://github.com/macanv/BERT-BiLSTM-CRF-NER https://github.com/jkszw2014/bert-kbqa-NLPCC2017
  • BERT-BiLSTM-CRF-NER Tensorflow solution of NER task Using BiLSTM-CRF model with Google BERT Fine-tuning 使用谷歌的BERT模型在BLSTM-CRF模型上进行预训练用于中文命名实体识别的Tensorflow代码' 中文文档请...
  • 为解决该问题, 本文提出了一种基于BERT-BiLSTM-CRF模型的研究方法. 首先通过BERT模型预处理生成基于上下文信息的词向量, 其次将训练出来的词向量输入BiLSTM-CRF模型做进一步训练处理. 实验结果表明, 该模型在MSRA...
  • 在实体识别中,bert+lstm+crf也是近来常用的方法。这里的bert可以充当固定的embedding层,也可以用来和其它模型一起训练fine-tune。大家知道输入到bert中的数据需要一定的格式,如在单个句子的前后需要加入"[CLS]"和...
  • 1、Attention机制: ...2、lstm https://www.cnblogs.com/zuotongbin/p/10698843.html 3、transformer https://www.jianshu.com/p/e7d8caa13b21 4、bert https://github.com/google-research/bert ...
  • BERT-BiLSTM-CRF命名实体识别应用

    千次阅读 2020-05-18 14:06:16
    本文将采用BERT+BiLSTM+CRF模型进行命名实体识别(Named Entity Recognition 简称NER),即实体识别。命名实体识别,是指识别文本中具有特定意义的实体,主要包括人名、地名、机构名、专有名词等。 BERT...
  • bert bilstm crf做NER任务

    2021-09-05 11:03:24
    标题在网上看了很多相关代码,不知道为什么特别难跑通,这段时间刚好自己做...以及内置了CNN_LSTM_Model BiLSTM_Model BiLSTM_CRF_Model BiGRU_Model BiGRU_CRF_Model 深度学习模型供选择。 对于我这种新手来说
  • BI-LSTM-CRF模型的PyTorch实现。 特征: 与相比,执行了以下改进: 全面支持小批量计算 完全矢量化的实现。 特别是,删除了“得分句”算法中的所有循环,从而极大地提高了训练效果 支持CUDA 用于非常简单的API ...
  • 自然语言处理之LSTMBERT模型

    千次阅读 2019-07-06 16:38:05
    在序列建模和序列翻译问题中经常使用的网络模型是RNN和LSTM,GRU。RNN处理序列问题时不能并行,将RNN作为解码器时,在第t个时间节点的prediction vector将与在t-1时刻的hidden state有关系,导致计算效率很低。所...
  • BERT只是一个预训练的语言模型,在各大任务上都刷新了榜单。我们本次实验的任务也是一个序列标注问题,简而言之,就是是基于BERT预训练模型,在中文NER(Named Entity Recognition,命名实体识别)任务上进行fine-...
  • class是一个生产bert_lstm的工厂,工厂里有一个初始化函数(init)和两个instance method功能函数(forward,init_hidden) instance method是指工厂里加工初始化后bert_lstm的函数 还有一种class method,是指对...
  • 开头先附上 BERT的论文,还有中文翻译版哦 ,笑纳! 原版: BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding BERT中文翻译PDF版.pdf 1、下载BERT及中文模型 BERT ...
  • 动手实践bert+BiLstm+crf

    万次阅读 热门讨论 2019-06-26 17:08:06
    网上大部分都是使用ChinaPeoplesDailyNerCorpus语料做的,真正应用到自已的语料和需求中还是有一些坑,这里整理记录一下 首先明确语料需要处理成什么格式,贴图理解一下 这里面需要搞清楚几点,我们的语料最小粒度...
  • #lstm的sequence是变长的,注意测试设置batch合理大小,确保不爆内存 #因为使用bertembedding,所以尽量切文本的sequence在500左右,确保内存合理使用???下述代码不是这么做的。 import gluonnlp as nlp import ...
  • 首先使用BERT语言模型进行文本特征提取获取字粒度向量矩阵, BiLSTM用于上下文信息的提取, 同时结合CRF模型提取全局最优序列, 最终得到景点命名实体. 实验表明, 提出的模型性能提升显著, 在实际旅游领域内景点识别的...
  • 领域:文本个性识别技术:BERTLSTM,Attention,CNN 链接: 论文介绍:针对现有模型不能充分提取语义特征,以及单个使用语义或语言学特征来进行预测等不足,使用BERT预训练模型进行句子的特征提取。同时阅读了关于...
  • BERT-BiLSTM-CRF-master.zip

    2020-07-17 10:58:56
    # BERT-BiLSTM-CRF BERT-BiLSTM-CRF的Keras版实现 ## BERT配置 1. 首先需要下载Pre-trained的BERT模型,本文用的是Google开源的中文BERT模型: - ...
  • Pytorch+Google BERT模型(RoBERTa+LSTM+GRU)实战 BERT(Bidirectional Encoder Representations from Transformers)模型的前置基础知识,读者可以参阅以下的文章: Pytorch使用Google BERT模型进行中文文本分类...
  • 机器学习AI算法工程 公众号:datayx Tensorflow solution of NER task Using BiLSTM-CRF model with Google BERT Fine-tuning 现在可以使用下面的命令下载软件包了: pip install bert-base==0.0.7 -i ...
  • bert模型后接TextCNN、LSTM

    千次阅读 热门讨论 2019-10-28 21:18:26
    使用keras_bert来搭建模型 #bert def get_model(): bert_model = load_trained_model_from_checkpoint(config_path, checkpoint_path) for l in bert_model.layers: l.trainable = True T1 = Input(sha...
  • BERT+BiLSTM-CRF-NER用于做ner识别

    万次阅读 多人点赞 2018-12-02 22:10:47
    本周五快下班的时候看到别人写了个bert语言模型作为输入,用于做ner识别,后面可以是cnn或者直接是crf层,bert在这里作为word2vec模型的替换着,原始地址https://github.com/macanv/BERT-BiLSTM-CRF-NER,在这里需要...
  • 用于命名实体识别(或序列标记)的LSTM-CRF模型 该存储库实现了用于命名实体识别的LSTM-CRF模型。 该模型与的模型相同,只是我们没有BiLSTM之后的最后一个tanh层。 我们在CoNLL-2003和OntoNotes 5.0英文数据集上均...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,384
精华内容 2,953
关键字:

bertlstm