精华内容
下载资源
问答
  • lstm分类模型
    千次阅读
    2020-09-25 14:24:08

    github链接:https://github.com/fangxiaozhu/Classification-model

    需求描述:基于构建简单的多分类模型需求,使用的是keras深度学习库实现的,实现代码简单可用,模型优点是训练速度快,准确率达97%,适合粗粒度分类。

    实现步骤:1、预处理数据:包括构建自定义词典、分词、去停用词等,处理成类似这样的训练数据格式

    2、预训练word2vec模型:这里使用的是26万相关业务语料训练,保存成query.all.split.pkl模型,然后用pickle反序列化的方式进行加载。

    3、得到训练集和验证集:用train_test_split按照0.15的比例将数据集划分为训练集和测试集,将文字通过word2vec字典转为词向量,根据句子最大长度进行padding补零,再转为numpy矩阵;将label转为one_hot向量,转为numpy矩阵。

    4、加载sklearn中的model,自定义模型的输入和输出,输入的形状是句子最大长度;定义一个embedding层,lstm层,dropout层,全连接层(50层),激活函数是sigmoid,再过一个dropout层和全连接层(sigmoid),得到模型的输出。

    5、训练和验证模型后,将模型保存到本地,这里用的是tensorflow的方式进行模型保存

    更多相关内容
  • 【项目实战】Python实现深度神经网络RNN-LSTM分类模型(医学疾病诊断) 资料说明:包括数据集+源代码+Word文档说明。 资料内容包括: 1)项目背景; 2)收集数据; 3)数据预处理; 4)探索数据分析; 5)特征工程; 6...
  • LSTM分类模型

    千次阅读 2022-03-14 23:03:59
    LSTM分类模型 本文主要固定一个文本分类的流程。分为三个部分: 数据处理。对分类文本数据集做简单的预处理。 模型数据准备。处理上一步的结果,得到模型的输入样本。 模型搭建和训练流程。 程序架构如下: 主要...

    LSTM文本分类模型

    本文主要固定一个文本分类的流程。分为三个部分:

    • 数据处理。对分类文本数据集做简单的预处理。
    • 模型数据准备。处理上一步的结果,得到模型的输入样本。
    • 模型搭建和训练流程。模型使用BiLSTM;训练过程可以使用cpu或者GPU。traniner.py的use_cuda参数来控制。

    程序架构如下:
    在这里插入图片描述

    主要包括一个原始的分类文件(头条新闻)。

    一个预处理脚本prepare_data.py

    一个数据处理脚本data_loader.py

    一个训练过程脚本trainer.py

    一个模型文件lstm_model.py–使用BiLSTM

    分类流程

    数据预处理

    将原始的文本进行预处理,原始文件形式如下:

    在这里插入图片描述

    处理后文件如下,形式为 内容文本\t类别名称

    只需要运行 prepare_data.py即可生成处理后的文件。注意输入路径。具体代码为

    # -*- coding: utf-8 -*-
    """
    @Time : 2022/2/26 11:44
    @Auth : hcb
    @File :prepare_data.py
    @IDE :PyCharm
    @Motto:ABC(Always Be Coding)
    """
    import os
    from tqdm import tqdm
    
    
    class PrepareData(object):
        def __init__(self):
            self.base_dir = os.path.join(os.path.dirname(__file__), "raw_data")
            self.raw_data_path = os.path.join(self.base_dir, "toutiao_cat_data.txt")
            self.prepared_data_path = os.path.join(self.base_dir, "toutiao_prepared.txt")
    
        def obtain_raw_data(self):
            """"""
            with open(self.raw_data_path, "r", encoding="utf8") as reader:
                all_lines = reader.readlines()
            prepared_data = []
            print("正在处理数据...")
            for line in tqdm(all_lines):
                info = self.deal_data(line)
                if info:
                    prepared_data.append(info)
            # 保存处理好的数据
            with open(self.prepared_data_path, "w", encoding="utf8") as writer:
                for info in prepared_data:
                    # print(info)
                    writer.write(info + "\n")
    
        @staticmethod
        def deal_data(line):
            """"""
            line_split = line.split("_!_")
            label_name = line_split[2]
            content = line_split[3]
            desc = line_split[4]
    
            text = content + " " + desc
            text = text.replace("\t", " ")
            text = text.replace("\n", " ")
    
            if text and label_name:
                return text + "\t" + label_name
            else:
                return None
    
    
    if __name__ == '__main__':
        prepared_obj = PrepareData()
        prepared_obj.obtain_raw_data()
    

    模型数据生成

    将上一步的文件进一步处理,得到模型的输入–训练和测试。中间涉及词典生成、自定义数据类等操作。目标是self.train_dataloader和self.test_dataloader。具体程序为:

    # -*- coding: utf-8 -*-
    """
    @Time : 2022/2/26 11:44
    @Auth : hcb
    @File :data_loader.py
    @IDE :PyCharm
    @Motto:ABC(Always Be Coding)
    """
    import torch
    import os
    import jieba
    from torch.utils.data import DataLoader, Dataset
    import numpy as np
    from tqdm import tqdm
    from sklearn.cross_validation import train_test_split
    
    
    class BaseData():
    
        __doc__ = "生产训练集和测试集数据迭代器"
    
        def __init__(self, args):
            self.base_dir = os.path.join(os.path.dirname(__file__), "raw_data")
            self.raw_data_path = os.path.join(self.base_dir, "toutiao_prepared.txt")
            # self.prepared_data_path = os.path.join(self.base_dir, "toutiao_prepared.txt")
            self.use_char = True
    
            self.word2id = {}
            self.id2word = {}
            self.label2id = {}
            self.id2label = {}
    
            self.batch_size = args.batch_size
            self.max_seq_len = args.max_seq_len
            self.enforced_sorted = True
            self.train_dataloader = None
            self.test_dataloader = None
            self.trainset_idx, self.testset_idx = self.obtain_dataset()  # 主程序
            self.obtain_dataloader()
    
        def obtain_dataset(self):
            """
            处理数据
            :return: 训练集和测试集的索引矩阵
            """
            with open(self.raw_data_path, "r", encoding="utf8") as reader:
                all_lines = reader.readlines()
            # 处理成样本和标签
            dataset = []
            for line in tqdm(all_lines, desc="处理数据"):
                sample_text, sample_label = self.clean_data(line)
                dataset.append((sample_text, sample_label))
            # 划分训练集和测试集
            train_set, test_set = train_test_split(dataset, test_size=0.5, random_state=10)  # 选总数据一半作为数据集
            train_set, test_set = train_test_split(train_set, test_size=0.15, random_state=10)
            # 根据训练集构建vocab
            self.build_vocab(train_set)
            trainset_idx = self.trans_data(train_set)
            testset_idx = self.trans_data(test_set)
    
            return trainset_idx, testset_idx
    
        def obtain_dataloader(self):
            """
            根据索引矩阵生产数据的迭代器
            :return:
            train_dataloader: 训练集迭代器
            test_dataloader: 测试集迭代器
            """
            train_dataset = MyData(self.trainset_idx)
            test_dataset = MyData(self.testset_idx)
            # droplast设为True 防止最后一个batch数量不足
            self.train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=self.batch_size, drop_last=True,
                                               collate_fn=self.coll_batch)
            self.test_dataloader = DataLoader(test_dataset, shuffle=True, batch_size=self.batch_size, drop_last=True,
                                              collate_fn=self.coll_batch)
    
        def clean_data(self, line):
            """
            分词并清洗数据
            :param line:
            :return:
            sample_text:  ["刘亦菲", "漂亮",“美女”]
            label: "娱乐"
            """
            text, label = line.split("\t")[0], line.split("\t")[1]
            if self.use_char:
                sample_text = list(text)
            else:
                sample_text = jieba.lcut(text)
            return sample_text, label
    
        def build_vocab(self, data_info):
            """
            构建词汇表字典
            :param data_info:
            :return:
            """
            tokens = []
            labels = set()
            for text, label in data_info:
                tokens.extend(text)
                labels.add(label)
    
            tokens = sorted(set(tokens))
            tokens.insert(0, "<pad>")
            tokens.insert(1, "<unk>")
            labels = sorted(labels)
    
            self.word2id = {word:idx for idx, word in enumerate(tokens)}
            self.id2word = {idx:word for idx, word in enumerate(tokens)}
            self.label2id = {label: idx for idx, label in enumerate(labels)}
            self.id2label = {idx: label for idx, label in enumerate(labels)}
    
        def trans_data(self, data_set):
            """
            根据词汇表字典将文本转成索引矩阵
            :param data_set:
            :return:
            """
            data_set_idx = []
            for text, label in data_set:
                text_idx = [self.word2id[word] if word in self.word2id else self.word2id["<unk>"] for word in text]
                label_idx = self.label2id[label]
                data_set_idx.append((text_idx, label_idx))
            return data_set_idx
    
        def coll_batch(self, batch):
            """
            对每个batch进行处理
            :param batch:
            :return:
            """
            # 每条样本的长度
            current_len = [len(data[0]) for data in batch]
            if self.enforced_sorted:
                index_sort = list(reversed(np.argsort(current_len)))
                batch = [batch[index] for index in index_sort]
                current_len = [min(current_len[index], self.max_seq_len) for index in index_sort]
            # 对每个batch进行padding
    
            max_length = min(max(current_len), self.max_seq_len)
            batch_x = []
            batch_y = []
            for item in batch:
                sample = item[0]
                if len(sample) > max_length:
                    sample = sample[0:max_length]
                else:
                    sample.extend([0] * (max_length-len(sample)))
                batch_x.append(sample)
                batch_y.append([item[1]])
            return {"sample": torch.tensor(batch_x), "label": torch.tensor(batch_y), "length": current_len}
    
    
    class MyData(Dataset):
        def __init__(self, data_set):
            self.data = data_set
    
        def __getitem__(self, index):
            return self.data[index]
    
        def __len__(self):
            return len(self.data)
    
    
    # if __name__ == '__main__':
    #     data_obj = BaseData(args=1)
    
    

    模型构造

    本程序只是为了搭建一个分类的流程框架。模型选用了简单的lstm模型。后续可以自己更换其他模型。

    lstm_model.py

    # -*- coding: utf-8 -*-
    """
    @Time : 2022/2/26 14:30
    @Auth : hcb
    @File :lstm_model.py
    @IDE :PyCharm
    @Motto:ABC(Always Be Coding)
    """
    import torch
    import torch.nn as nn
    import torch.autograd as autograd
    import torch.nn.functional as F
    from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
    
    
    class LSTMClassifier(nn.Module):
    
        def __init__(self, args):
            super(LSTMClassifier, self).__init__()
            self.args = args
            self.hidden_dim = args.hidden_dim
            self.word_embeddings = nn.Embedding(args.vocab_num, args.embedding_dim)
            self.lstm = nn.LSTM(args.embedding_dim, args.hidden_dim, batch_first=True, bidirectional=True)
            self.hidden2label = nn.Linear(args.hidden_dim * 2, args.class_num)
            self.hidden = self.init_hidden()
    
        def init_hidden(self):
            # the first is the hidden h
            # the second is the cell  c
            if self.args.use_cuda:
                return (autograd.Variable(torch.zeros(2, self.args.batch_size, self.hidden_dim)).cuda(),
                        autograd.Variable(torch.zeros(2, self.args.batch_size, self.hidden_dim)).cuda())
            else:
                return (autograd.Variable(torch.zeros(2, self.args.batch_size, self.hidden_dim)),
                        autograd.Variable(torch.zeros(2, self.args.batch_size, self.hidden_dim)))
    
        def forward(self, sentence, lengths=None):
            """"""
            if not lengths:
                self.hidden = self.init_hidden()
                embeds = self.word_embeddings(sentence)
                x = embeds
                lstm_out, self.hidden = self.lstm(x, self.hidden)
                y = self.hidden2label(lstm_out[:,-1])  # 分类选择所有行的最后一个隐层
                log_probs = F.log_softmax(y)
            else:
                self.hidden = self.init_hidden()
                embeds = self.word_embeddings(sentence)
                x = embeds
                x_pack = pack_padded_sequence(x, lengths, batch_first=True, enforce_sorted=True)
                lstm_out, self.hidden = self.lstm(x_pack, self.hidden)
                lstm_out, output_lens  = pad_packed_sequence(lstm_out, batch_first=True)
                y = self.hidden2label(lstm_out[:,-1])  # 分类选择所有行的最后一个隐层
                log_probs = F.log_softmax(y)
    
            return log_probs
    

    训练过程

    最终是开始训练和测试:

    # -*- coding: utf-8 -*-
    """
    @Time : 2022/2/26 14:38
    @Auth : hcb
    @File :trainer.py
    @IDE :PyCharm
    @Motto:ABC(Always Be Coding)
    """
    import argparse
    import os
    from data_loader import BaseData
    from models import lstm_model
    import torch.nn as nn
    import torch.nn.functional as F
    from torch.optim import Adam
    from tqdm import tqdm
    import torch
    from sklearn.metrics import classification_report
    
    
    def train(args):
        # 定义模型优化器 损失函数等
        model = lstm_model.LSTMClassifier(args)
        if args.use_cuda:
            model = model.cuda()
        optimizer = Adam(model.parameters(), lr=args.lr)
        loss_function = nn.NLLLoss()
    
        train_dataloader = args.dataloader.train_dataloader
        test_dataloader = args.dataloader.test_dataloader
        model.train()
        for epoch in tqdm(range(args.epoch_num)):
            print(f"epoch {epoch}...")
            for train_info in tqdm(train_dataloader):
                optimizer.zero_grad()
                # model.hidden = model.init_hidden()
                data = train_info["sample"]
                label = train_info["label"]
                length = train_info["length"]
                if args.use_cuda:
                    data = data.cuda()
                    label = label.cuda()
                # print("data_size", data.size())
                predict_label = model(data)
                label = label.view(args.batch_size,)  # [30, 1] --> [30]
                loss_batch = loss_function(predict_label, label)
                loss_batch.backward()
                # print("loss", loss_batch)
    
                optimizer.step()
            print(f"evaluation...epoch_{epoch}:")
            true_label, pred_label = [], []
            loss_sum = 0.0
            with torch.no_grad():
                for test_info in test_dataloader:
                    data = test_info["sample"]
                    label = test_info["label"]
                    length = test_info["length"]
                    # 保存真实标签
                    label_list = label.view(1, -1).squeeze().numpy().tolist()
                    true_label.extend(label_list)
                    if args.use_cuda:
                        data = data.cuda()
                        label = label.cuda()
    
                    predict_label = model(data)
                    predict_label_list = torch.argmax(predict_label, dim=1).cpu().numpy().tolist()
                    pred_label.extend(predict_label_list)
    
                    label = label.view(args.batch_size, )
                    loss_sum += loss_function(predict_label, label)
            print(classification_report(true_label, pred_label))
            print(f"epoch:{epoch} test data loss: {loss_sum}.")
    
    
    def main():
        args = argparse.ArgumentParser()
    
        args.add_argument("--model", default="lstm", choices=["textcnn", "lstm"])
        args.add_argument("--batch_size", type=int, default=50)
        args.add_argument("--lr", type=float, default=0.001)
        args.add_argument("--max_seq_len", type=int, default=80)
        args.add_argument("--enforced_sorted", type=bool, default=True)
        args.add_argument("--embedding_dim", type=int, default=128)
        args.add_argument("--hidden_dim", type=int, default=128)
        args.add_argument("--num_layer", type=int, default=2)
        args.add_argument("--epoch_num", type=int, default=5)
        args.add_argument("--use_cuda", type=bool, default=True)
    
        args = args.parse_args()
    
        data_load = BaseData(args)
        setattr(args, "dataloader", data_load)
        setattr(args, "vocab_num", len(data_load.word2id))
        setattr(args, "class_num", len(data_load.label2id))
    
        train(args)
    
    
    if __name__ == '__main__':
        main()
    

    备注

    程序可以正常运行,后续还会优化扩展。头条数据可以从这里下载:

    分类数据

    展开全文
  • pytorch实现lstm分类模型

    千次阅读 2020-12-03 18:12:03
    教程原文在这里Tutorial,这篇文章中用LSTM实现了一个简单的词类标注模型。下面是一些具体的解析: # Author: Robert Guthrie import torch import torch.nn as nn import torch.nn.functional as F import torch....

    教程原文在这里Tutorial,这篇文章中用LSTM实现了一个简单的词类标注模型。下面是一些具体的解析:

    # Author: Robert Guthrie
    
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    import torch.optim as optim
    
    torch.manual_seed(1)
    # 引用库函数
    

    我们首先了解如何初始化一个nn.LSTM实例, 以及它的输入输出。初始化nn.LSTM实例, 可以设定的参数如下:
    在这里插入图片描述
    常用的是前两个,用来描述LSTM输入的词向量维度和输出的向量的维度(与hidden state相同),其中num_layer指的是这样的结构:
    在这里插入图片描述
    这种称作stacked LSTM,如上就是两层LSTM堆叠起来。bi-direction指的是双向,双向的LSTM会从正反两个方向读句子,依次输入词向量, 两个方向的hidden state也并不是公共的,如下图:
    在这里插入图片描述
    对应到下面代码的第一行,就是创建了一个输入输出的维度均为3、单层单向的LSTM网络。

    lstm = nn.LSTM(3, 3)  # Input dim is 3, output dim is 3
    inputs = [torch.randn(1, 3) for _ in range(5)]  # make a sequence of length 5
    

    这个网络的输入输出怎么样呢?LSTM的基本功能是接收一个句子(一个词向量序列),从第一个词开始逐个后移,移到每一个词的时候,根据hidden state、cell state以及当前的词向量计算输出,并更新hidden state 和cell state,因此输入首先是一个词向量列,同时也可以设定一开始的hidden state和cell state,如果不设定那就自动初始化为0。而输出有三个,一个是每一步的输出构成的序列,这里每一个输出对应句子中的每一个词,第二个输出是最后的hidden state,第三个则是最后的cell state,具体的输入输出如下图:
    在这里插入图片描述

    # initialize the hidden state.
    hidden = (torch.randn(1, 1, 3),
              torch.randn(1, 1, 3))
              
    for i in inputs:
        # Step through the sequence one element at a time.
        # after each step, hidden contains the hidden state.
        out, hidden = lstm(i.view(1, 1, -1), hidden)
    
    # alternatively, we can do the entire sequence all at once.
    # the first value returned by LSTM is all of the hidden states throughout
    # the sequence. the second is just the most recent hidden state
    # (compare the last slice of "out" with "hidden" below, they are the same)
    # The reason for this is that:
    # "out" will give you access to all hidden states in the sequence
    # "hidden" will allow you to continue the sequence and backpropagate,
    # by passing it as an argument  to the lstm at a later time
    # Add the extra 2nd dimension
    inputs = torch.cat(inputs).view(len(inputs), 1, -1)
    hidden = (torch.randn(1, 1, 3), torch.randn(1, 1, 3))  # clean out hidden state
    out, hidden = lstm(inputs, hidden)
    print(out)
    print(hidden)
    

    如上,hidden实际上是(h0, c0),它的三个维度的含义是(num_layer*num_direction, batch_size, hidden_size),第一维和第三维都是由LSTM实例的参数确定的,batch_size倒是很特别,如果hidden的第二个维度不为1,那难道不同的batch的hidden state不会公用吗?
    LSTM的输入维度也很有意思,三个维度的含义为:(sequence_len, batch_size, input_size),第三个维度就是词向量embedding长度,sequence len是句长,batch_size是分批的大小,这跟我们一般常用表示方式(batch_size, sequence_len, input_size) 相反。而且我们看到使用时总是配合tensor.view这个方法, 这个方法其实就是tensor的reshape, 它究竟会让tensor怎样重新排列呢?我们可以看下面的结果:

    	input = np.array([11, 12, 21, 22, 31, 32])
        input_tensor = torch.from_numpy(input)
        print(input_tensor.view(2, 3, 1))
    

    输出:

    tensor([[[11],
             [12],
             [21]],
    
            [[22],
             [31],
             [32]]])
    

    按照LSTM的理解,这样的input就是3个长为2的句子为一批,每一个词向量维度都是1。我们的第一个句子是[11, 22],第二个是[12, 31],这就有一个问题,原本是连续输入的单词,现在反而被隔开了,假设我们的输入数据是一句话连着一句话,LSTM反而会理解为每一个句子的开头连成一句话。比如上面,LSTM神经网络就是先输入i = [[11], [12], [21]],这三者没有先后顺序,而是平行地进行向量运算:在这里插入图片描述
    联想到刚刚h的维度是(batch_size, hidden_size)(不考虑双向和stack),更加可以说明这里batch中各个矩阵运算其实就是平行的)

    然后再输入每句话的第二个词[[22], [31], [32]]这时,会分别利用到前面三个的hidden state、cell state并且更新。
    其实我觉得这样设计还挺迷的🤔,如果要保持原句的样式,输入的时候是不是要把句子拆开,把同一批的开头放在一起、第二个词放在一起···
    接下来正式开始词类标注标注的模型实例。我们实际上训练时可以这样做:先将输入向量拆分成batch x sentence x embedding这样的常规形式,也就是tensor = tensor.view(-1, sentence_len, input_size),这样分批时就可以直接将batch=tensor(i*batch_size: (i+1)*batch_size, :, :)送进LSTM,送进LSTM时对前两维做一个转置就好了:output = LSTM(batch.transpose(0, 1)),这样做还保证了连续性(contiguous)。
    其实除了batch之外也没什么好说的,而这个实例的batch恰好是1🤷‍♀️:

    def prepare_sequence(seq, to_ix):
        idxs = [to_ix[w] for w in seq]
        return torch.tensor(idxs, dtype=torch.long)
    
    
    training_data = [
        ("The dog ate the apple".split(), ["DET", "NN", "V", "DET", "NN"]),
        ("Everybody read that book".split(), ["NN", "V", "DET", "NN"])
    ]
    word_to_ix = {}
    for sent, tags in training_data:
        for word in sent:
            if word not in word_to_ix:
                word_to_ix[word] = len(word_to_ix)
    print(word_to_ix)
    tag_to_ix = {"DET": 0, "NN": 1, "V": 2}
    
    # These will usually be more like 32 or 64 dimensional.
    # We will keep them small, so we can see how the weights change as we train.
    EMBEDDING_DIM = 6
    HIDDEN_DIM = 6
    

    上面就是把每个单词编了号,用数字代表单词,当然这个数字不能直接用于训练,还需要embedding(不过这个embedding也没啥,毕竟总共才两句话)
    输出:

    {'The': 0, 'dog': 1, 'ate': 2, 'the': 3, 'apple': 4, 'Everybody': 5, 'read': 6, 'that': 7, 'book': 8}
    

    接下来我们用nn.LSTM和全连接神经网络层nn.Linear来搭建我们的神经网络模型:

    class LSTMTagger(nn.Module):
    
        def __init__(self, embedding_dim, hidden_dim, vocab_size, tagset_size):
            super(LSTMTagger, self).__init__()
            self.hidden_dim = hidden_dim
    
            self.word_embeddings = nn.Embedding(vocab_size, embedding_dim)
    
            # The LSTM takes word embeddings as inputs, and outputs hidden states
            # with dimensionality hidden_dim.
            self.lstm = nn.LSTM(embedding_dim, hidden_dim)
    
            # The linear layer that maps from hidden state space to tag space
            self.hidden2tag = nn.Linear(hidden_dim, tagset_size)
    
        def forward(self, sentence):
            embeds = self.word_embeddings(sentence)
            lstm_out, _ = self.lstm(embeds.view(len(sentence), 1, -1))
            tag_space = self.hidden2tag(lstm_out.view(len(sentence), -1))
            tag_scores = F.log_softmax(tag_space, dim=1)
            return tag_scores
    

    vocab_size 指的是我们的词库大小,两句话总共8个词所以是8。target_size是我们自己定义的输出维度,我们的LSTM不直接输出,而是经过一个全连接神经网络之后再输出,这个过程可以改变维度。由于是词类标注,其实就是多分类任务,我们输出的维度和可能的分类数量一样,输出每一个维度可以理解为此分类的得分score,得分越高就代表此分类是正确分类的可能性越大。

    model = LSTMTagger(EMBEDDING_DIM, HIDDEN_DIM, len(word_to_ix), len(tag_to_ix))
    loss_function = nn.NLLLoss()
    optimizer = optim.SGD(model.parameters(), lr=0.1)
    
    # See what the scores are before training
    # Note that element i,j of the output is the score for tag j for word i.
    # Here we don't need to train, so the code is wrapped in torch.no_grad()
    with torch.no_grad():
        inputs = prepare_sequence(training_data[0][0], word_to_ix)
        tag_scores = model(inputs)
        print(tag_scores)
    ## 这里只是用完全没训练过的LSTM来预测一下。
    
    for epoch in range(300):  # again, normally you would NOT do 300 epochs, it is toy data
        for sentence, tags in training_data:
            # Step 1. Remember that Pytorch accumulates gradients.
            # We need to clear them out before each instance
            model.zero_grad()
    
            # Step 2. Get our inputs ready for the network, that is, turn them into
            # Tensors of word indices.
            sentence_in = prepare_sequence(sentence, word_to_ix)
            targets = prepare_sequence(tags, tag_to_ix)
    
            # Step 3. Run our forward pass.
            tag_scores = model(sentence_in)
    
            # Step 4. Compute the loss, gradients, and update the parameters by
            #  calling optimizer.step()
            loss = loss_function(tag_scores, targets)
            loss.backward()
            optimizer.step()
    
    # See what the scores are after training
    with torch.no_grad():
        inputs = prepare_sequence(training_data[0][0], word_to_ix)
        tag_scores = model(inputs)
    
        # The sentence is "the dog ate the apple".  i,j corresponds to score for tag j
        # for word i. The predicted tag is the maximum scoring tag.
        # Here, we can see the predicted sequence below is 0 1 2 0 1
        # since 0 is index of the maximum value of row 1,
        # 1 is the index of maximum value of row 2, etc.
        # Which is DET NOUN VERB DET NOUN, the correct sequence!
        print(tag_scores)
    

    上面的loss function是nn.NLLLoss,这是一个多分类误差函数类,每一个实例的输入输出如下:
    在这里插入图片描述
    input是N个长为C的向量,代表一批中的N个实例在C个标签下的打分,而target是这N个标签的正确分类。

    展开全文
  • 基于临床医学越来越多的检测数据,通过建立一个机器学习模型来进行更加智能地预测已成为当今时代的使命。本模型也是基于一些历史的疾病数据进行建模、预测。 2.收集数据 本数据是模拟数据,分为两部分数据: 训练...

    说明:这是一个机器学习实战项目(附带数据+代码+视频+文档),如需数据+完整代码可以直接到文章最后获取。

    1.项目背景

           随着互联网+的不断深入,我们已步入人工智能时代,机器学习作为人工智能的一个分支越来越多地被应用于各行各业,其中在临床医学检测中也得到了越来越多的应用。基于临床医学越来越多的检测数据,通过建立一个机器学习模型来进行更加智能地预测已成为当今时代的使命。本模型也是基于一些历史的疾病数据进行建模、预测。

    2.收集数据

    本数据是模拟数据,分为两部分数据:

    训练数据集:data.csv

    测试数据集:test.csv

    在实际应用中,根据自己的数据进行替换即可。

    特征数据:age、gender、body_mass_index、heart_failure hypertension、       chronic_obstructic_pulmonary_disease、       chronic_liver_disease、……renal_toxic_drug        

    标签数据:acute_kidney_disease

    3.数据预处理

    1)原始数据描述

    2)数据完整性、数据类型查看:

    3)数据缺失值个数:

      

    可以看到数据不存在缺失值。

    4.探索性数据分析

    1)显示age特征的分布情况:

    2)显示gender特征的分布情况:

    3)显示heart_failure特征的分布情况:

    剩下的其它特征,可以自行分析。

    4)相关性分析

      

    说明:正值是正相关、负值时负相关,值越大变量之间的相关性越强。

    5.特征工程

    1)特征数据和标签数据拆分,acute_kidney_disease为标签数据,除acute_kidney_disease之外的为特征数据;

    2)数据集拆分,分为训练集和尝试集

    数据集已提前分好,直接读取即可。

    6.LSTM建模  

    1)神经网路LSTM简单介绍:

    LSTM网络是RNN的一个变体,也是目前更加通用的循环神经网络结构,全程为Long Short-Term Memory,翻译成中文叫作”长 ‘短记忆’”网络。读的时候,”长”后面要稍作停顿,不要读成”长短”记忆网络,因为那样的话,就不知道记忆到底是长还是短。本质上,它还是短记忆网络,只是用某种方法把”短记忆”尽可能延长了一些。

    简而言之,LSTM就是携带一条记忆轨道的循环神经网络,是专门针对梯度消失问题所做的改进。它增加的记忆轨道是一种携带信息跨越多个时间步的方法。可以先想象有一条平行于时间序列处理过程的传送带,序列中的信息可以在任意位置”跳”上传送带,然后被传送到更晚的时间步,并在需要时原封不动地”跳”过去,接受处理。这就是LSTM原理:就像大脑中的记忆存储器,保存信息以便后面使用,我们回忆过去,较早期的信息就又浮现在脑海中,不会随着时间的流逝而消失得无影无踪。

    这个思路和残差连接非常相似,其区别在于,残差连接解决的是层与层之间得梯度消失问题,而LSTM解决的是循环层与神经元层内循环处理过程中的消息消失问题。

    简单来说,C轨道将携带着跨越时间步的信息。它在不同的时间步的值为Ct,这些信息将与输入连接和循环连接进行运算(即与权重矩阵进行点积,然后加上一个偏置,以及加一个激活过程),从而影响传递到下一个时间步的状态如右图所示。

    LSTM-增加了一条记忆轨道,携带序列中较早的信息

    2)建立LSTM分类模型,模型参数如下:

    编号

    参数

    1

    loss='binary_crossentropy'

    2

    optimizer='adam'

    3

    metrics=['acc']

    其它参数根据具体数据,具体设置。

    3)神经网络结构及概要

    神经网络结构图:

    神经网络概要:

    可以看到每层网络的类型、形状和参数。

    7.模型评估

    1)评估指标主要采用查准率、查全率、F1

    编号

    评估指标名称

    评估指标值

    1

    查准率

    98.74%

    2

    查全率

    100.00%

    3

    F1

    99.37%

    通过上述表格可以看出,此模型效果良好。

    2)损失和准确率图

     loss = history.history['loss']
        val_loss = history.history['val_loss']
        epochs = range(1, len(loss) + 1)
        plt.figure(figsize=(12, 4))
        plt.subplot(1, 2, 1)
        plt.plot(epochs, loss, 'r', label='Training loss')
        plt.plot(epochs, val_loss, 'b', label='Test loss')
        plt.title('Training and Test loss')
        plt.xlabel('Epochs')
        plt.ylabel('Loss')
        plt.legend()
        acc = history.history['acc']
        val_acc = history.history['val_acc']
        plt.subplot(1, 2, 2)
        plt.plot(epochs, acc, 'r', label='Training acc')
        plt.plot(epochs, val_acc, 'b', label='Test acc')
        plt.title('Training and Test accuracy')
        plt.xlabel('Epochs')
        plt.ylabel('Accuracy')
        plt.legend()
    

    3)ROC曲线绘制

    训练集ROC曲线图:

    fpr, tpr, threshold = roc_curve(y_data, y_score)
    
        roc_auc = auc(fpr, tpr)
    
        plt.figure()
        lw = 2
        plt.plot(fpr, tpr, color='darkorange',
                 lw=lw, label='ROC curve (area = %0.2f)' % roc_auc)
        plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
        plt.xlim([0.0, 1.0])
        plt.ylim([0.0, 1.05])
        plt.xlabel('False Positive Rate')
        plt.ylabel('True Positive Rate')
        plt.title(title + ' RNN-LSTM Model ')
        plt.legend(loc="lower right")

    测试集ROC曲线图:

    8.临床应用

    根据测试集的特征数据,来预测这些患者是否会有相关疾病;根据预测结果:针对将来可能会患有此种疾病的人员,提前进行预防。

    预测结果如下:

     本次机器学习项目实战所需的资料,项目资源如下:【项目实战】Python实现深度神经网络RNN-LSTM分类模型(医学疾病诊断).zip_rnn神经网络模型python-Python文档类资源-CSDN下载

    有疑问可以添加博主微信:zy10178083 

    展开全文
  • 使用LSTM进行音频分类使用基于LSTM模型对城市声音音频数据集进行分类。要求pytorch == 1.0.1 scipy == 1.2.0 火炬视觉== 0.2.1 熊猫== 0.24.1 numpy == 1.14.3 torchaudio == 0.2 librosa == 0.6.3 pydub = = ...
  • 有一个19200*303的数据集,要求利用pytorch建立一个lstm的五分类模型。 预测Loc HRR Wind的值(五分类) 初学,还理不太清模型的结构和相应的维度。 batch=30 步长=15 希望帮忙理一理思路,或者推荐相似的案例学习...
  • Pytorch《LSTM模型

    千次阅读 2020-10-13 17:19:15
    这里定义的LSTM模型是用了三层深度模型,双向的,输出层增加了线性转换。 完整代码如下: import torch import torch.nn as nn import torch.optim as optim import torchvision from torchvision import transforms...
  • Keras:我的第一个LSTM分类网络模型

    千次阅读 2020-08-16 18:33:16
    使用Keras训练一个简单的LSTM分类网络模型,用于找到数列中是否包含3个连续递增或者递减的子数列。比如 [ 0.1, 0.2, 0.3, 0.5, 0.3, 0.2 ] 数列对应的标签为[ 0, 0, 1, 1 , 0, 1 ]。 特诊 设 [x1, x2, x3]中x3的...
  • 基于pytorch的LSTM模型构建

    千次阅读 2021-12-24 14:25:21
    上文我们利用pytorch构建了BP神经网络,LeNet,这次我们利用LSTM网络实现对MNIST数据集的分类,具体的数据获取方法本文不详细介绍,这里只要讲解搭建LSTM网络的方法以及参数设置。 这里我们只用一层LSTM网络+全连接...
  • Pytorch实现的LSTM模型结构

    万次阅读 多人点赞 2021-03-27 19:25:40
    LSTM模型结构1、LSTM模型结构2、LSTM网络3、LSTM的输入结构4、Pytorch中的LSTM4.1、pytorch中定义的LSTM模型4.2、喂给LSTM的数据格式4.3、LSTM的output格式5、LSTM和其他网络组合 1、LSTM模型结构 BP网络和CNN网络...
  • LSTM模型搭建

    万次阅读 2020-12-08 10:48:45
    def LSTM_Classifier(self, train, trainLabel, test, testLabel, val_test, val_label, new_test=None): train, test = np.array(train), np.array(test) train, test = train.reshape(train.shape[0], 1, train...
  • PyTorch搭建LSTM实现服装分类(FashionMNIST)

    多人点赞 热门讨论 2022-06-23 17:59:54
    LSTM + FashionMNIST
  • LSTM模型结构讲解

    千次阅读 多人点赞 2019-11-29 11:29:32
    人类并不是每时每刻都从一片空白的大脑开始他们的思考。在你阅读这篇文章时候,你都...例如,假设你希望对电影中的每个时间点的时间类型进行分类。传统的神经网络应该很难来处理这个问题——使用电影中先前的事件推...
  • BILSTM模型介绍

    千次阅读 2021-12-08 15:05:56
    LSTM模型是由在RNN基础上增加了输入门,遗忘门,单元状态,输出门组成。在网络训练过程中,可通过门结构来添加或移除信息,不同神经网络都可通过单元状态上的门结构来决定去记住或遗忘哪些相关信息。 LSTM的计算...
  • 【深度学习】-Imdb数据集情感分析之模型对比(4)- CNN-LSTM
  • 利用tensorflow实现的循环神经网络RNN(本程序使用了LSTM)来做语言模型,并输出其困惑度。 #语言模型主要是根据一段给定的文本来预测下一个词最有可能是什么。困惑度用于评价语言模型。困惑度越小,则模型的性能越...
  • LSTM: nn.LSTM(input_size, hidden_size, num_layers=1, nonlinearity=tanh, bias=True, batch_first=False, dropout=0, bidirectional=False)   input_size:表示输入 xt 的特征维度 ...
  • LSTM模型详解

    万次阅读 多人点赞 2018-03-08 15:37:47
    (一)LSTM模型理解1.长短期记忆模型(long-short term memory)是一种特殊的RNN模型,是为了解决RNN模型梯度弥散的问题而提出的;在传统的RNN中,训练算法使用的是BPTT,当时间比较长时,需要回传的残差会指数下降...
  • 今天小编就为大家分享一篇pytorch实现用CNN和LSTM对文本进行分类方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 五、CNN-LSTM数据驱动模型

    千次阅读 2022-03-02 21:16:08
    CNN-LSTM数据驱动模型 6.1 基本原理 深度学习是机器学习前沿且热门的理论,而其中的两大框架卷积神经网络(CNN)以及长短期记忆网络(LSTM)是深度学习的代表,CNN能过够通过使用卷积核从样本数据中提取出其潜在的...
  • 本文通过训练双向长短期记忆网络BiLSTM与注意力机制相结合的多层文本分类模型,将其应用到招聘信息分类中.该模型包括One-hot词向量输入层、BiLSTM层、注意力机制层和输出层.其中One-hot层构建招聘词典,节省了大量...
  • RNN与LSTM模型

    千次阅读 2019-03-20 20:14:15
    RNN 简介 前馈神经网络的两个局限 难以捕捉到数据之间长距离的依赖关系,即使CNN也只能捕捉到局部或短距离的关系 当训练样本输入是连续序列...比如在文本分类中,它模拟了人阅读一篇文章的顺序,从前到后阅读文章中...
  • 先运行main.py进行文本序列化,再train.py模型训练 dataset.py from torch.utils.data import DataLoader,Dataset import torch import os from utils import tokenlize import config class ImdbDataset(Dataset): ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,301
精华内容 13,720
关键字:

lstm分类模型