精华内容
下载资源
问答
  • LSTM实现自然语言处理中的情感分析,其中包含了分词,词序列化,词向量,LSTM建模
  • 自然语言处理 | (15)使用Pytorch实现RNN(LSTM)语言模型-附件资源
  • 说明:本文依据《中文自然语言处理入门实战》完成。目前网上有不少转载的课程,我是从GitChat上购买。这一课开始讲深度学习部分的RNN(LSTM和GRU),之前也在教程中学过,但是仅仅是实现了一个LSTM,然后使用RNN构建了...
    b77d9cd45540de33c87d28474078aeef.png

    说明:本文依据《中文自然语言处理入门实战》完成。目前网上有不少转载的课程,我是从GitChat上购买。

    这一课开始讲深度学习部分的RNN(LSTM和GRU),之前也在教程中学过,但是仅仅是实现了一个LSTM,然后使用RNN构建了一个词向量模型用来做词嵌入预测。

    第十一课 使用LSTM生成古诗

    这次课是运用LSTM实现一个诗词生成模型,我看了一下源代码,貌似比较粗糙,这里会先按照源代码跑一遍流程,然后从github上找了另一个star2000+的项目来实现。

    之前因为我的疏忽,没有看到教程中的Github地址,在这里列出来。

    语料库使用教程提供的爬取处理后的语料,四万首古诗,题材、长度不限,大概8mb左右。

    1.模型参数配置

    预先定义模型参数和加载语料以及模型保存名称,通过类 Config 实现。

    import osimport randomimport kerasfrom keras.callbacks import LambdaCallbackfrom keras.engine.saving import load_modelfrom keras import *from keras.layers import *from keras.optimizers import Adamclass Config(object): poetry_file = r"C:甥敳獲01Desktop机器学习作业sklearn+tensorflowdatasetspoetry.txt" weight_file = r"C:甥敳獲01Desktop机器学习作业sklearn+tensorflowdatasetspoetry_model.h5" # 根据前六个字预测第七个字 max_len = 6 batch_size = 512 learning_rate = 0.001

    2.文本预处理

    教程中使用了传统的One-Hot形式来生成词向量。

    def preprocess_file(Config): # 语料文本内容 files_content = '' with open(Config.poetry_file, 'r', encoding='utf-8') as f: for line in f: # 每行的末尾加上"]"符号代表一首诗结束 for char in puncs: line = line.replace(char, "") files_content += line.strip() + "]" words = sorted(list(files_content)) words.remove(']') counted_words = {} for word in words: if word in counted_words: counted_words[word] += 1 else: counted_words[word] = 1 # 去掉低频字 erase = [] for key in counted_words: if counted_words[key] <= 2: erase.append(key) for key in erase: del counted_words[key] del counted_words[']'] wordPairs = sorted(counted_words.items(), key=lambda x: -x[1]) words, _ = zip(*wordPairs) # word到id的映射 word2num = dict((c, i + 1) for i, c in enumerate(words)) num2word = dict((i, c) for i, c in enumerate(words)) word2numF = lambda x: word2num.get(x, 0) return word2numF, num2word, words, files_content

    3.构建模型,通过 PoetryModel 类实现

    puncs = [']', '[', '(', ')', '{', '}', ':', '《', '》']class PoetryModel(object): def __init__(self,config): self.model = None self.do_train = True self.loaded_model = False self.config = Config self.word2numF, self.num2word, self.words, self.files_content = preprocess_file(self.config) if os.path.exists(self.config.weight_file): self.model = load_model(self.config.weight_file) self.model.summary() else: self.train() self.do_train = False self.loaded_model = True def build_model(self): input_tensor = Input(shape=(self.config.max_len,)) embedd = Embedding(len(self.num2word) + 1, 300, input_length=self.config.max_len)(input_tensor) # lstm = Bidirectional(GRU(128, return_sequences=True))(embedd) # dropout = Dropout(0.6)(lstm) lstm = Bidirectional(GRU(128, return_sequences=True))(embedd) dropout = Dropout(0.6)(lstm) flatten = Flatten()(lstm) dense = Dense(len(self.words), activation='softmax')(flatten) self.model = Model(inputs=input_tensor, outputs=dense) optimizer = Adam(lr=self.config.learning_rate) self.model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy']) # sample 函数,在训练过程的每个 epoch 迭代中采样。 def sample(self, preds, temperature=1.0): # 当temperature=1.0时,模型输出正常 # 当temperature=0.5时,模型输出比较open # 当temperature=1.5时,模型输出比较保守 # 在训练的过程中可以看到temperature不同,结果也不同 preds = np.asarray(preds).astype('float64') preds = np.log(preds) / temperature exp_preds = np.exp(preds) preds = exp_preds / np.sum(exp_preds) probas = np.random.multinomial(1, preds, 1) return np.argmax(probas) def generate_sample_result(self, epoch, logs): print("==================Epoch {}=====================".format(epoch)) for diversity in [0.5, 1.0, 1.5]: start_index = random.randint(0, len(self.files_content) - self.config.max_len - 1) generated = '' sentence = self.files_content[start_index: start_index + self.config.max_len] generated += sentence for i in range(20): x_pred = np.zeros((1, self.config.max_len)) for t, char in enumerate(sentence[-6:]): x_pred[0, t] = self.word2numF(char) preds = self.model.predict(x_pred, verbose=0)[0] next_index = self.sample(preds, diversity) next_char = self.num2word[next_index] generated += next_char sentence = sentence + next_char print(sentence) def predict(self, text): if not self.loaded_model: return with open(self.config.poetry_file, 'r', encoding='utf-8') as f: file_list = f.readlines() random_line = random.choice(file_list) # 如果给的text不到四个字,则随机补全 if not text or len(text) != 4: for _ in range(4 - len(text)): random_str_index = random.randrange(0, len(self.words)) text += self.num2word.get(random_str_index) if self.num2word.get(random_str_index) not in [',', '。', ','] else self.num2word.get( random_str_index + 1) seed = random_line[-(self.config.max_len):-1] res = '' seed = 'c' + seed for c in text: seed = seed[1:] + c for j in range(5): x_pred = np.zeros((1, self.config.max_len)) for t, char in enumerate(seed): x_pred[0, t] = self.word2numF(char) preds = self.model.predict(x_pred, verbose=0)[0] next_index = self.sample(preds, 1.0) next_char = self.num2word[next_index] seed = seed[1:] + next_char res += seed return res def data_generator(self): i = 0 while 1: x = self.files_content[i:i + self.config.max_len] y = self.files_content[i + self.config.max_len] puncs = [']', '[', '(', ')', '{', '}', ':', '《', '》', ':'] if len([i for i in puncs if i in x]) != 0: i += 1 continue if len([i for i in puncs if i in y]) != 0: i += 1 continue y_vec = np.zeros( shape=(1, len(self.words)), dtype=np.bool ) y_vec[0, self.word2numF(y)] = 1.0 x_vec = np.zeros( shape=(1, self.config.max_len), dtype=np.int32 ) for t, char in enumerate(x): x_vec[0, t] = self.word2numF(char) yield x_vec, y_vec i += 1 def train(self): number_of_epoch = 10 if not self.model: self.build_model() self.model.summary() self.model.fit_generator( generator=self.data_generator(), verbose=True, steps_per_epoch=self.config.batch_size, epochs=number_of_epoch, callbacks=[ keras.callbacks.ModelCheckpoint(self.config.weight_file, save_weights_only=False), LambdaCallback(on_epoch_end=self.generate_sample_result) ] )

    4.训练模型

    if __name__ == '__main__': model = PoetryModel(Config) text = input("text:") sentence = model.predict(text) print(sentence)

    5.训练结果

    一共进行了10次迭代,对比可以发现生成的越来越像人话了……

    ==================Epoch 0=====================

    西将,犹能射无不不宁烽叫锥聘王瘢襦猿锋顾洪竹摽俘泮谈

    。]嘉兴郭里。箓迤于尺濑。蚤缨魄无乡。梡巅损场坌。餔

    遂安舒。清流琊渡样苟趢邦蓄结鞘奸轺教鲐舲喉僧泄狄元溱

    ==================Epoch 5=====================

    痕露,微思月不无不。归未灯知花。耕散别惊忧。每兽片何

    静言念终始,木杳志钱山不乎_那蹈惜罗边霾雨忆惊清解璇

    。]槠楠无冬。朝妖掇忘散。报子捃况乡桎渚郇岑介不脍囊

    ==================Epoch 9=====================

    君俦。白发虽遥视。汉不梨母石。兮叶右无不。暂晚乡奇律

    寿。全胜汉武轻。诗渴肩刈油。铿银断怡著。怡处升脉池。

    拜舞归,轻纨杼饵依不鹢挚玖德茅赖泉舷弩郡趢艰陌涴齾臣

    我们可以随意输入一个关键字来生成诗句

    text:雨

    雨零伤来臾。箭牧归劳肝。昨当痕门忘。八龙鉴良清。

    展开全文
  • 理论与实战结合, 基于深度学习主流框架Tensorflow实例演示如何用深度学习来进行文本分类任务,其中涉及深度学习主流架构LSTM模型以及自然语言处理中流行的word2vec词向量建模方法,分模块解读如何用框架一步步完成...
  • 本篇博客我们将使用pytorch实现一下循环神经网络模型(LSTM). 完整代码 1.数据预处理 # 实现参考 https://github.com/pytorch/examples/tree/master/word_language_model #! pip install torch #安装torch import...

    本篇博客我们将使用pytorch实现一下循环神经网络模型(LSTM).

    完整代码

    1.数据预处理

    # 实现参考 https://github.com/pytorch/examples/tree/master/word_language_model
    #! pip install torch #安装torch
    import torch
    import torch.nn as nn
    import numpy as np
    from torch.nn.utils import clip_grad_norm_
    
    class Dictionary(object):
        '''
        构建word2id,id2word两个字典
        '''
        def __init__(self):
            self.word2idx = {} #字典 词到索引的映射
            self.idx2word = {} #字典  索引到词的映射
            self.idx = 0
        
        def add_word(self, word):
            if not word in self.word2idx: #如果词到索引的映射字典中 不包含该词 则添加
                self.word2idx[word] = self.idx 
                self.idx2word[self.idx] = word #同时创建索引到词的映射
                self.idx += 1
        
        def __len__(self):
            return len(self.word2idx) #词到索引映射的字典大小
    
    
    class Corpus(object):
        '''
        基于训练语料,构建字典(word2id,id2word)
        '''
        def __init__(self):
            self.dictionary = Dictionary() #创建字典类对象
    
        def get_data(self, path, batch_size=20):
            # 添加词到字典
            with open(path, 'r') as f:#读取文件
                tokens = 0
                for line in f:  #遍历文件中的每一行
                    words = line.split() + ['<eos>'] #以空格分隔 返回列表 并添加一个结束符<eos>
                    tokens += len(words)
                    for word in words: #将每个单词添加到字典中
                        self.dictionary.add_word(word)  
            
            # 对文件做Tokenize
            ids = torch.LongTensor(tokens)
            token = 0
            with open(path, 'r') as f:
                for line in f:
                    words = line.split() + ['<eos>']
                    for word in words:
                        ids[token] = self.dictionary.word2idx[word]
                        token += 1
            num_batches = ids.size(0) // batch_size
            ids = ids[:num_batches*batch_size]
            return ids.view(batch_size, -1)

    2.RNN(LSTM)语言模型

    # 有gpu的情况下使用gpu
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    #device = torch.device('cpu')
    • 超参数设置
    # 超参数的设定
    embed_size = 128    # 词嵌入的维度
    hidden_size = 1024  # 使用RNN变种LSTM单元   LSTM的hidden size
    num_layers = 1      #循环单元/LSTM单元的层数
    num_epochs = 5      # 迭代轮次
    num_samples = 1000  # 测试语言模型生成句子时的样本数
    batch_size = 20     # 一批样本的数量
    seq_length = 30     # 一个样本/序列长度
    learning_rate = 0.002 # 学习率
    • 加载数据集
    # 加载数据集
    corpus = Corpus()
    ids = corpus.get_data('data/train.txt', batch_size)
    vocab_size = len(corpus.dictionary)
    num_batches = ids.size(1) // seq_length
    • LSTM语言模型
    # RNN语言模型
    class RNNLM(nn.Module): #RNNLM类继承nn.Module类
        def __init__(self, vocab_size, embed_size, hidden_size, num_layers):
            super(RNNLM, self).__init__()
            #嵌入层 one-hot形式(vocab_size,1) -> (embed_size,1)
            self.embed = nn.Embedding(vocab_size, embed_size)
            #LSTM单元/循环单元
            self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True)
            #输出层的全联接操作  
            self.linear = nn.Linear(hidden_size, vocab_size)
            
        def forward(self, x, h):
            # 词嵌入
            x = self.embed(x)
            
            # LSTM前向运算
            out,(h,c) = self.lstm(x,h)
    
            # 每个时间步骤上LSTM单元都会有一个输出,batch_size个样本并行计算(每个样本/序列长度一致)  out (batch_size,sequence_length,hidden_size)
            # 把LSTM的输出结果变更为(batch_size*sequence_length, hidden_size)的维度
            out = out.reshape(out.size(0)*out.size(1),out.size(2))
            # 全连接
            out = self.linear(out) #(batch_size*sequence_length, hidden_size)->(batch_size*sequence_length, vacab_size)
            
            return out,(h,c)
    
    model = RNNLM(vocab_size, embed_size, hidden_size, num_layers).to(device)
    • 损害函数和优化
    # 损失构建与优化
    criterion = nn.CrossEntropyLoss() #交叉熵损失
    #使用Adam优化方法 最小化损失 优化更新模型参数 
    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
    • 训练
    # 反向传播过程“截断”(不复制gradient)
    def detach(states):
        return [state.detach() for state in states] 
    
    # 训练模型
    for epoch in range(num_epochs):
        # 初始化为0
        states = (torch.zeros(num_layers,batch_size,hidden_size).to(device),
                 torch.zeros(num_layers,batch_size,hidden_size).to(device))
        
        for i in range(0, ids.size(1) - seq_length, seq_length):
            # 获取一个mini batch的输入和输出(标签)
            inputs = ids[:,i:i+seq_length].to(device)
            targets = ids[:,(i+1):(i+1)+seq_length].to(device) # 输出相对输入错一位,往后顺延一个单词
            
            # 前向运算
            states = detach(states)
            outputs,states = model(inputs,states)
            loss = criterion(outputs,targets.reshape(-1))
            
            # 反向传播与优化
            model.zero_grad()
            loss.backward()
            clip_grad_norm_(model.parameters(),0.5)
    
            step = (i+1) // seq_length
            if step % 100 == 0:
                print ('全量数据迭代轮次 [{}/{}], Step数[{}/{}], 损失Loss: {:.4f}, 困惑度/Perplexity: {:5.2f}'
                       .format(epoch+1, num_epochs, step, num_batches, loss.item(), np.exp(loss.item())))
    • 测试
    # 测试语言模型
    with torch.no_grad():
        with open('sample.txt', 'w') as f:
            # 初始化为0
            state = (torch.zeros(num_layers, 1, hidden_size).to(device),
                     torch.zeros(num_layers, 1, hidden_size).to(device))
    
            # 随机选择一个词作为输入
            prob = torch.ones(vocab_size)
            input = torch.multinomial(prob, num_samples=1).unsqueeze(1).to(device)
    
            for i in range(num_samples):
                # 从输入词开始,基于语言模型前推计算
                output, state = model(input, state)
    
                # 做预测
                prob = output.exp()
                word_id = torch.multinomial(prob, num_samples=1).item()
    
                # 填充预估结果(为下一次预估储备输入数据)
                input.fill_(word_id)
    
                # 写出输出结果
                word = corpus.dictionary.idx2word[word_id]
                word = '\n' if word == '<eos>' else word + ' '
                f.write(word)
    
                if (i+1) % 100 == 0:
                    print('生成了 [{}/{}] 个词,存储到 {}'.format(i+1, num_samples, 'sample.txt'))
    
    # 存储模型的保存点(checkpoints)
    torch.save(model.state_dict(), 'model.ckpt')

     

     

     

     

    展开全文
  • 理论与实战结合, 基于深度学习主流框架Tensorflow实例演示如何用深度学习来进行文本分类任务,其中涉及深度学习主流架构LSTM模型以及自然语言处理中流行的word2vec词向量建模方法,分模块解读如何用框架一步步完成...
    展开全文
  • 理论与实战结合, 基于深度学习主流框架Tensorflow实例演示如何用深度学习来进行文本分类任务,其中涉及深度学习主流架构LSTM模型以及自然语言处理中流行的word2vec词向量建模方法,分模块解读如何用框架一步步完成...
    展开全文
  • 理论与实战结合, 基于深度学习主流框架Tensorflow实例演示如何用深度学习来进行文本分类任务,其中涉及深度学习主流架构LSTM模型以及自然语言处理中流行的word2vec词向量建模方法,分模块解读如何用框架一步步完成...
  • 理论与实战结合, 基于深度学习主流框架Tensorflow实例演示如何用深度学习来进行文本分类任务,其中涉及深度学习主流架构LSTM模型以及自然语言处理中流行的word2vec词向量建模方法,分模块解读如何用框架一步步完成...
  • 1,self.hidden_dim))) def forward(self, sentence): embeds = self.word_embedding(sentence) lstm_out, self.hidden = self.lstm(embeds.view(len(sentence),1,-1), self.hidden) tag_space = self.hidden2...
  • 课程基于PyTorch主流框架实现,其中涉及深度学习主流框架LSTM模型以及自然语言处理的词向量;彻底掌握中文情感分析。 适用人群 想要从事NLP的在校学生、NLP研发工程师 自然语言处理从业者、深度学习爱好者 课程简介 ...
  • LSTM百度百科 长短期记忆网络(LSTM,Long Short-Term Memory)是一种时间循环神经网络,是为了...了解LSTM自然语言处理中的使用 代码: from keras.datasets import imdb # 导入模型 from keras import Sequentia
  •        ...之后介绍了基于LSTM情感分类模型,其中包括LSTM的基本原理、如何搭建LSTM网络、并演示了LSTM情感分类模型的训练和预测。最后通过改变交叉熵函数对模型进行了优化。 
  • 文章目录前言一、LSTM凭什么可以替换RNN?二、LSTM的神秘之处是什么?三、一些细节1.脏数据2.dropout3.未知词条4.字符级建模5.使用one-hot向量6.数据集较小总结 前言 前文提到过用CNN、RNN、来解决隐藏在文本背后的...
  • 自然语言处理 (NLP)问题都是序列化的。 前馈神经网络,在单次前馈中对到来数据处理,假定所有输入独立,模式丢失。 循环神经网络(recurrent neural network,RNN)对时间显式建模神经网络。 RNN神经元可接收其他神经元...
  • tparam={lstm_U, lstm_w, lstm_b} 之前lstm初始化时赋好的值 self.params=lstm赋好的self.params 对于filter_sizes中的每一个元素(以2为例): filter_shape=(num_filters,1,filter_size,proj_size)=(500,1,2,...
  • 目录==参考资料====框架构成==*RNN和LSTM区别**RNN模型**LSTM模型*==程序实现==pytorch实现lstm输入==模型输入====模型输出== 参考资料 LSTM原理详解 lstm讲解视频 框架构成 RNN和LSTM区别 RNN没法回忆起久远的回忆...
  • LSTM】 为了解决长期依赖的问题,对RNN进行改进提出了LSTMLSTM通过设计门限结构解决长期依赖问题,在标准RNN的基础上增加了四个神经网络层,通过LSTM网络包括四个输入:当前时刻的输入信息、遗忘门、输入门、输...
  • 自然语言处理LSTM和BERT模型

    千次阅读 2019-07-06 16:38:05
    在序列建模和序列翻译问题中经常使用的网络模型是RNN和LSTM,GRU。RNN处理序列问题时不能并行,将RNN作为解码器时,在第t个时间节点的prediction vector将与在t-1时刻的hidden state有关系,导致计算效率很低。所...
  • 自然语言处理实战—LSTM情感分析 在中国知网从事自然语言处理和知识图谱的开...
  • 关于语言模型:官网提供案例供参考 https://pytorch.org/tutorials/advanced/dynamic_quantization_tutorial.html?highlight=lstm 主要内容: 自定义CrossEntropyLoss,主要把padding的数据不进行loss 计算(默认0...
  • 自然语言处理11——RNN与LSTM

    千次阅读 2019-04-27 09:51:54
    文章目录1. 循环神经网络RNN(Recurrent Neural Network)1.1 循环神经网络的... LSTM与GRU2.1 LSTM2.2 GRU3. Text-RNN3.1 Text-RNN的原理3.2 利用Text-RNN模型来进行文本分类 1. 循环神经网络RNN(Recurrent Neural ...
  • 自然语言处理(NLP)Bert与Lstm结合

    千次阅读 热门讨论 2020-09-08 18:32:34
    自然语言处理(NLP)在深度学习领域是一大分支(其他:CV、语音),经过这些年的发展NLP发展已经很成熟,同时在工业界也慢慢开始普及,谷歌开放的Bert是NLP前进的又一里程碑。本篇文章结合Bert与Lstm,对文本数据...
  • RNN在自然语言处理的文本处理上取得了很大的成功。 双向LSTM可以捕获上下文的内容,从而使得分类效果更佳。 在本文的这次分类中,本文使用了IMDB电影评价的数据集,最终的模型可以将正面情感和负面情感通过双向LSTM...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,212
精华内容 484
关键字:

lstm自然语言处理