深度学习--LSTM网络、使用方法、实战情感分类问题

这篇具有很好参考价值的文章主要介绍了深度学习--LSTM网络、使用方法、实战情感分类问题。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

深度学习--LSTM网络、使用方法、实战情感分类问题

1.LSTM基础

长短期记忆网络(Long Short-Term Memory,简称LSTM),是RNN的一种,为了解决RNN存在长期依赖问题而设计出来的。

LSTM的基本结构:

网络图

2.LSTM的具体说明

LSTM与RNN的结构相比,在参数更新的过程中,增加了三个门,由左到右分别是遗忘门(也称记忆门)、输入门、输出门。

图片来源:

https://www.elecfans.com/d/672083.html

深度学习--LSTM网络、使用方法、实战情感分类问题

1.点乘操作决定多少信息可以传送过去,当为0时,不传送;当为1时,全部传送。

2.1 遗忘门

对于输入xt和ht-1,遗忘门会输出一个值域为[0, 1]的数字,放进Ct−1中。当为0时,全部删除;当为1时,全部保留。

2.2 输入门

对于对于输入xt和ht-1,输入门会选择信息的去留,并且通过tanh激活函数更新临时Ct

通过遗忘门和输入门输出累加,更新最终的Ct

2.3输出门

通过Ct和输出门,更新memory

3.PyTorch的LSTM使用方法

  1. __ init __(input _ size, hidden_size,num _layers)

  2. LSTM.foward():

​ out,[ht,ct] = lstm(x,[ht-1,ct-1])

​ x:[一句话单词数,batch几句话,表示的维度]

​ h/c:[层数,batch,记忆(参数)的维度]

​ out:[一句话单词数,batch,参数的维度]

import torch
import torch.nn as nn

lstm = nn.LSTM(input_size = 100,hidden_size = 20,num_layers = 4)
print(lstm)
#LSTM(100, 20, num_layers=4)

x = torch.randn(10,3,100)
out,(h,c)=lstm(x)

print(out.shape,h.shape,c.shape)
#torch.Size([10, 3, 20]) torch.Size([4, 3, 20]) torch.Size([4, 3, 20])

单层使用方法:

cell = nn.LSTMCell(input_size = 100,hidden_size=20)

x = torch.randn(10,3,100)
h = torch.zeros(3,20)
c = torch.zeros(3,20)

for xt in x:
    h,c = cell(xt,[h,c])
    
print(h.shape,c.shape)

#torch.Size([3, 20]) torch.Size([3, 20])

LSTM实战--情感分类问题

Google CoLab环境,需要魔法。文章来源地址https://www.toymoban.com/news/detail-425912.html

import torch
from torch import nn, optim
from torchtext import data, datasets

print('GPU:', torch.cuda.is_available())

torch.manual_seed(123)

TEXT = data.Field(tokenize='spacy')
LABEL = data.LabelField(dtype=torch.float)
train_data, test_data = datasets.IMDB.splits(TEXT, LABEL)

print('len of train data:', len(train_data))
print('len of test data:', len(test_data))

print(train_data.examples[15].text)
print(train_data.examples[15].label)

# word2vec, glove
TEXT.build_vocab(train_data, max_size=10000, vectors='glove.6B.100d')
LABEL.build_vocab(train_data)


batchsz = 30
device = torch.device('cuda')
train_iterator, test_iterator = data.BucketIterator.splits(
    (train_data, test_data),
    batch_size = batchsz,
    device=device
)

class RNN(nn.Module):
    
    def __init__(self, vocab_size, embedding_dim, hidden_dim):
        """
        """
        super(RNN, self).__init__()
        
        # [0-10001] => [100]
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        # [100] => [256]
        self.rnn = nn.LSTM(embedding_dim, hidden_dim, num_layers=2, 
                           bidirectional=True, dropout=0.5)
        # [256*2] => [1]
        self.fc = nn.Linear(hidden_dim*2, 1)
        self.dropout = nn.Dropout(0.5)
        
        
    def forward(self, x):
        """
        x: [seq_len, b] vs [b, 3, 28, 28]
        """
        # [seq, b, 1] => [seq, b, 100]
        embedding = self.dropout(self.embedding(x))
        
        # output: [seq, b, hid_dim*2]
        # hidden/h: [num_layers*2, b, hid_dim]
        # cell/c: [num_layers*2, b, hid_di]
        output, (hidden, cell) = self.rnn(embedding)
        
        # [num_layers*2, b, hid_dim] => 2 of [b, hid_dim] => [b, hid_dim*2]
        hidden = torch.cat([hidden[-2], hidden[-1]], dim=1)
        
        # [b, hid_dim*2] => [b, 1]
        hidden = self.dropout(hidden)
        out = self.fc(hidden)
        
        return out

rnn = RNN(len(TEXT.vocab), 100, 256)

pretrained_embedding = TEXT.vocab.vectors
print('pretrained_embedding:', pretrained_embedding.shape)
rnn.embedding.weight.data.copy_(pretrained_embedding)
print('embedding layer inited.')

optimizer = optim.Adam(rnn.parameters(), lr=1e-3)
criteon = nn.BCEWithLogitsLoss().to(device)
rnn.to(device)

import numpy as np

def binary_acc(preds, y):
    """
    get accuracy
    """
    preds = torch.round(torch.sigmoid(preds))
    correct = torch.eq(preds, y).float()
    acc = correct.sum() / len(correct)
    return acc

def train(rnn, iterator, optimizer, criteon):
    
    avg_acc = []
    rnn.train()
    
    for i, batch in enumerate(iterator):
        
        # [seq, b] => [b, 1] => [b]
        pred = rnn(batch.text).squeeze(1)
        # 
        loss = criteon(pred, batch.label)
        acc = binary_acc(pred, batch.label).item()
        avg_acc.append(acc)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        if i%10 == 0:
            print(i, acc)
        
    avg_acc = np.array(avg_acc).mean()
    print('avg acc:', avg_acc)
    
    
def eval(rnn, iterator, criteon):
    
    avg_acc = []
    
    rnn.eval()
    
    with torch.no_grad():
        for batch in iterator:

            # [b, 1] => [b]
            pred = rnn(batch.text).squeeze(1)

            #
            loss = criteon(pred, batch.label)

            acc = binary_acc(pred, batch.label).item()
            avg_acc.append(acc)
        
    avg_acc = np.array(avg_acc).mean()
    
    print('>>test:', avg_acc)

for epoch in range(10):
    
    eval(rnn, test_iterator, criteon)
    train(rnn, train_iterator, optimizer, criteon)

到了这里,关于深度学习--LSTM网络、使用方法、实战情感分类问题的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【深度学习 AIGC】stable diffusion webUI 使用过程,参数设置,教程,使用方法

    如果你想使用docker快速启动这个项目,你可以按下面这么操作(显卡支持CUDA11.8)。如果你不懂docker,请参考别的教程。 模型文件即checkpoint已包含了与vae相关的参数。然而,稳定扩散官方和novelai泄露的文件都包含了额外的vae,用于改进面部或其他细节。因此,加载vae文件实

    2024年02月05日
    浏览(53)
  • python中的lstm:介绍和基本使用方法

    python中的lstm:介绍和基本使用方法 未使用插件 LSTM(Long Short-Term Memory)是一种循环神经网络(RNN)的变体,专门用于处理序列数据。LSTM 可以记忆序列中的长期依赖关系,这使得它非常适合于各种自然语言处理(NLP)和时间序列预测任务。 在 Python 中,你可以使用深度学习框

    2024年02月12日
    浏览(41)
  • 【linux命令讲解大全】045.网络数据分析利器:深度解读 tcpdump 抓包工具的使用方法

    tcpdump是一款在Linux上的抓包工具,用于嗅探网络数据。 补充说明 tcpdump命令是一款抓包、嗅探器工具。它可以打印所有经过网络接口的数据包的头信息,并可使用-w选项将数据包保存到文件中,以便以后进行分析。 语法 选项 -a:尝试将网络和广播地址转换成名称 -c 数据包数

    2024年02月10日
    浏览(51)
  • 【动手学深度学习】--长短期记忆网络LSTM

    学习视频:长短期记忆网络(LSTM)【动手学深度学习v2】 官方笔记:长短期记忆网络(LSTM) 长期以来,隐变量模型存在着长期信息保存和短期输入缺失的问题,解决这一问题的最早方法之一是长短期存储器(LSTM),它有许多与GRU一样的属性,有趣的是,长短期记忆网络的设计

    2024年02月09日
    浏览(61)
  • 基于LSTM深度学习网络的时间序列分析matlab仿真

    目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 5.算法完整程序工程   matlab2022a        LSTM是一种循环神经网络(RNN)的变体,专门设计用于处理序列数据。LSTM网络通过记忆单元和门控机制来捕捉时间序列中的长期依赖关系,避免了传统RNN中

    2024年02月12日
    浏览(55)
  • 【深度学习实验】循环神经网络(四):基于 LSTM 的语言模型训练

    目录 一、实验介绍 二、实验环境 1. 配置虚拟环境 2. 库版本介绍 三、实验内容 0. 导入必要的工具包 1. RNN与梯度裁剪 2. LSTM模型 3. 训练函数 a. train_epoch b. train 4. 文本预测 5. GPU判断函数 6. 训练与测试 7. 代码整合         经验是智慧之父,记忆是智慧之母。 ——谚语    

    2024年02月07日
    浏览(48)
  • 【深度学习】详解利用Matlab和Python中 LSTM 网络实现序列分类

    🔗 运行环境:Matlab、Python 🚩 撰写作者:左手の明天 🥇 精选专栏:《python》 🔥  推荐专栏:《算法研究》 🔐####  防伪水印——左手の明天 #### 🔐 💗 大家好🤗🤗🤗,我是 左手の明天 !好久不见💗 💗今天分享 Matlab深度学习 ——  LSTM 网络实现序列分类 💗

    2024年01月22日
    浏览(47)
  • 使用OpenCV工具包成功实现人脸检测与人脸识别,包括传统视觉和深度学习方法(附完整代码,吐血整理......)

    要实现人脸识别功能,首先要进行人脸检测,判断出图片中人脸的位置,才能进行下一步的操作。 参考链接: 1、OpenCV人脸检测 2、【OpenCV-Python】32.OpenCV的人脸检测和识别——人脸检测 3、【youcans 的图像处理学习课】23. 人脸检测:Haar 级联检测器 4、OpenCV实战5:LBP级联分类器

    2024年02月12日
    浏览(46)
  • 使用OpenCV工具包成功实现人脸检测与人脸识别,包括传统视觉和深度学习方法(附完整代码,模型下载......)

    要实现人脸识别功能,首先要进行人脸检测,判断出图片中人脸的位置,才能进行下一步的操作。 参考链接: 1、OpenCV人脸检测 2、【OpenCV-Python】32.OpenCV的人脸检测和识别——人脸检测 3、【youcans 的图像处理学习课】23. 人脸检测:Haar 级联检测器 4、OpenCV实战5:LBP级联分类器

    2024年02月08日
    浏览(45)
  • 深度学习-循环神经网络-RNN实现股价预测-LSTM自动生成文本

    基于文本内容及其前后信息进行预测 基于目标不同时刻状态进行预测 基于数据历史信息进行预测 序列模型:输入或者输出中包含有序列数据的模型 突出数据的前后序列关系 两大特点: 输入(输出)元素之间是具有顺序关系。不同的顺序,得到的结果应该是不同的,比如“

    2024年01月24日
    浏览(53)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包