Pytorch实现基于LSTM的情感分析

news2025/1/21 2:53:57

文章目录

  • 本文参考
    • 导入必要的包
    • 介绍torchnet
    • 做数据的导入
    • 给必要的参数命名
    • 加载文本数据
    • 数据前处理
    • 模型训练
    • 验证

本文参考

PyTorch深度学习项目实战100例

https://weibaohang.blog.csdn.net/article/details/127154284?spm=1001.2014.3001.5501

这段代码是一个基于PyTorch实现的情感分析模型,使用了LSTM(长短时记忆网络)作为核心结构。情感分析是一个自然语言处理任务,旨在确定给定文本的情感或情感极性,例如正面、负面

导入必要的包

介绍torchnet

Torchnet 是一个轻量级框架,旨在为 PyTorch 提供一些抽象和实用工具,以简化常见的深度学习研究任务。Torchnet 的设计是模块化和扩展性的,这使得研究者可以更轻松地尝试新的思路和方法。

!pip install torchnet
!pip install keras
import pickle
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
from tensorflow.keras.preprocessing.sequence import pad_sequences
from sklearn.model_selection import train_test_split
from torch.utils.data import TensorDataset
from torch import optim
from torchnet import meter
from tqdm import tqdm```

做数据的导入

数据+代码

给必要的参数命名

# config file
#模型输入参数,需要自己根据需要调整
num_layers = 3 # LSTM的层数
hidden_dim = 100 # LSTM中的隐层大小
epochs = 20 # 迭代次数
batch_size = 32 # 每个批次样本大小
embedding_dim = 20 # 每个字形成的嵌入向量大小
output_dim = 2 # 输出维度,因为是二分类
lr = 0.003 # 学习率
device = 'cuda:0'
file_path = 'data_single.csv' # 数据路径
input_shape = 180 # 每句话的词的个数,如果不够需要使用0进行填充

加载文本数据


# 加载文本数据
def load_data(file_path, input_shape=20):
    df = pd.read_csv(file_path)

    # 标签及词汇表
    labels, vocabulary = list(df['label'].unique()), list(df['evaluation'].unique())

    # 构造字符级别的特征
    string = ''
    for word in vocabulary:
        string += word

    # 所有的词汇表
    vocabulary = set(string)

    # word2idx 将字映射为索引
    word_dictionary = {word: i + 1 for i, word in enumerate(vocabulary)}
    with open('word_dict.pk', 'wb') as f:
        pickle.dump(word_dictionary, f)
    # idx2word 将索引映射为字
    inverse_word_dictionary = {i + 1: word for i, word in enumerate(vocabulary)}
    # label2idx 将正反面映射为0和1
    label_dictionary = {label: i for i, label in enumerate(labels)}
    with open('label_dict.pk', 'wb') as f:
        pickle.dump(label_dictionary, f)
    # idx2label 将0和1映射为正反面
    output_dictionary = {i: labels for i, labels in enumerate(labels)}

    # 训练数据中所有词的个数
    vocab_size = len(word_dictionary.keys())  # 词汇表大小
    # 标签类别,分别为正、反面
    label_size = len(label_dictionary.keys())  # 标签类别数量

    # 序列填充,按input_shape填充,长度不足的按0补充
    # 将一句话映射成对应的索引 [0,24,63...]
    x = [[word_dictionary[word] for word in sent] for sent in df['evaluation']]
    # 如果长度不够input_shape,使用0进行填充
    x = pad_sequences(maxlen=input_shape, sequences=x, padding='post', value=0)
    # 形成标签0和1
    y = [[label_dictionary[sent]] for sent in df['label']]
    #     y = [np_utils.to_categorical(label, num_classes=label_size) for label in y]
    y = np.array(y)

    return x, y, output_dictionary, vocab_size, label_size, inverse_word_dictionary,word_dictionary,vocabulary

读取数据返回参数

变量名描述
x输入数据
y标签数据
output_dictionary标签的反向映射
vocab_size词汇表大小
label_size标签类别数量
inverse_word_dictionary字符索引的反向映射
word_dictionary字符到索引的映射
vocabulary所有可能的字符集合

创建LSTM 网路结构

LSTM(Long Short-Term Memory)是一种循环神经网络(Recurrent Neural Network,RNN)的变种,它在处理序列数据时具有很好的性能,特别是在长序列上能够更好地捕捉长期依赖关系。下面是关于LSTM网络结构的说明:

背景:LSTM是为了解决传统RNN中的梯度消失和梯度爆炸问题而提出的。它引入了特殊的记忆单元来维护和控制信息的流动,以更好地捕捉序列数据中的长期依赖关系。

LSTM单元:LSTM网络的基本构建单元是LSTM单元。每个LSTM单元包括以下组件:

  • 输入门(Input Gate):控制新信息的输入。
  • 遗忘门(Forget Gate):控制过去信息的遗忘。
  • 输出门(Output Gate):控制输出的生成。
  • 细胞状态(Cell State):用于维护长期依赖关系的记忆。

记忆细胞:LSTM单元内部的细胞状态是其核心。它可以看作一个传送带,可以在不同时间步骤上添加或删除信息。通过输入门、遗忘门和输出门来控制信息的读取、写入和遗忘,以保持对序列中重要信息的长期记忆。

输入门:输入门决定了在当前时间步骤中,新的输入信息中哪些部分将会更新细胞状态。输入门通常由一个Sigmoid激活函数和一个tanh激活函数组成,用于产生0到1之间的权重和-1到1之间的新候选值。

遗忘门:遗忘门决定了哪些信息应该从细胞状态中丢弃。它使用Sigmoid激活函数来产生0到1之间的权重,控制细胞状态中哪些信息应该保留。

输出门:输出门决定了基于当前细胞状态和输入信息,LSTM单元应该输出什么。它使用Sigmoid激活函数来确定输出的哪些部分应该激活,并使用tanh激活函数来生成可能的输出值。
在这里插入图片描述

# 定义网络结构
class LSTM(nn.Module):
    def __init__(self, vocab_size, hidden_dim, num_layers, embedding_dim, output_dim):
        super(LSTM, self).__init__()
        self.hidden_dim = hidden_dim  # 隐层大小
        self.num_layers = num_layers  # LSTM层数
        # 嵌入层,会对所有词形成一个连续型嵌入向量,该向量的维度为embedding_dim
        # 然后利用这个向量来表示该字,而不是用索引继续表示
        self.embeddings = nn.Embedding(vocab_size + 1, embedding_dim)
        # 定义LSTM层,第一个参数为每个时间步的特征大小,这里就是每个字的维度
        # 第二个参数为隐层大小
        # 第三个参数为lstm的层数
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers)
        # 利用全连接层将其映射为2维,即正反面的概率
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        # 1.首先形成嵌入向量
        embeds = self.embeddings(x)
        # 2.将嵌入向量导入到lstm层
        output, (h_n, c_n) = self.lstm(embeds)
        timestep, batch_size, hidden_dim = output.shape
        output = output.reshape(-1, hidden_dim)
        # 3.将其导入全连接层
        output = self.fc(output)  # 形状为batch_size * timestep, 2
        output = output.reshape(timestep, batch_size, -1)
        return output[-1]  # 返回最后一个时间片的输出,维度为 batch_size, 2

数据前处理

# 1.获取训练数据
x, y, output_dictionary, vocab_size, label_size, inverse_word_dictionary,word_dictionary,vocabulary = load_data(file_path, input_shape)

# 2.划分训练、测试数据
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=42)

# 3.将numpy转成tensor
x_train = torch.from_numpy(x_train).to(torch.int32)
y_train = torch.from_numpy(y_train).to(torch.float32)
x_test = torch.from_numpy(x_test).to(torch.int32)
y_test = torch.from_numpy(y_test).to(torch.float32)

# 4.形成训练数据集
train_data = TensorDataset(x_train, y_train)
test_data = TensorDataset(x_test, y_test)

# 5.将数据加载成迭代器
train_loader = torch.utils.data.DataLoader(train_data,
                                           batch_size,
                                           True)

test_loader = torch.utils.data.DataLoader(test_data,
                                          batch_size,
                                          False)

模型训练

# 6.模型训练
model = LSTM(vocab_size=len(inverse_word_dictionary), hidden_dim=hidden_dim, num_layers=num_layers,
             embedding_dim=embedding_dim, output_dim=output_dim)

Configimizer = optim.Adam(model.parameters(), lr=lr) # 优化器
criterion = nn.CrossEntropyLoss() # 多分类损失函数

model.to(device)
loss_meter = meter.AverageValueMeter()

best_acc = 0 # 保存最好准确率
best_model = None # 保存对应最好准确率的模型参数

for epoch in range(epochs):
    model.train() # 开启训练模式
    epoch_acc = 0 # 每个epoch的准确率
    epoch_acc_count = 0 # 每个epoch训练的样本数
    train_count = 0 # 用于计算总的样本数,方便求准确率
    loss_meter.reset()

    train_bar = tqdm(train_loader)  # 形成进度条
    for data in train_bar:
        x_train, y_train = data  # 解包迭代器中的X和Y

        x_input = x_train.long().transpose(1, 0).contiguous()
        x_input = x_input.to(device)
        Configimizer.zero_grad()

        # 形成预测结果
        output_ = model(x_input)

        # 计算损失
        loss = criterion(output_, y_train.long().view(-1))
        loss.backward()
        Configimizer.step()

        loss_meter.add(loss.item())

        # 计算每个epoch正确的个数
        epoch_acc_count += (output_.argmax(axis=1) == y_train.view(-1)).sum()
        train_count += len(x_train)

    # 每个epoch对应的准确率
    epoch_acc = epoch_acc_count / train_count

    # 打印信息
    print("【EPOCH: 】%s" % str(epoch + 1))
    print("训练损失为%s" % (str(loss_meter.mean)))
    print("训练精度为%s" % (str(epoch_acc.item() * 100)[:5]) + '%')

    # 保存模型及相关信息
    if epoch_acc > best_acc:
        best_acc = epoch_acc
        best_model = model.state_dict()

    # 在训练结束保存最优的模型参数
    if epoch == epochs - 1:
        # 保存模型
        torch.save(best_model, './best_model.pkl')       

验证


 # 将输入句子转换为索引
sent = "商品很满意,我还会再光临的"
indexed_sent = [word_dictionary[char] for char in sent if char in word_dictionary]
input_data = torch.tensor(indexed_sent)
input_data = input_data.view(len(input_data), 1)
model = LSTM(vocab_size=len(inverse_word_dictionary), hidden_dim=hidden_dim, num_layers=num_layers,
             embedding_dim=embedding_dim, output_dim=output_dim)

with torch.no_grad():
  predictions = model(input_data)
  predicted_class = torch.argmax(predictions, dim=1).item()

	if predicted_class == 0:
	  print("负面")
	else:
	  print("正面")

弄成函数好调用

# 预测函数,用于对输入的文本进行情感分类预测
def predictions(sent):
    # 将输入文本的字符转换为对应的索引,忽略不在词汇表中的字符
    indexed_sent = [word_dictionary[char] for char in sent if char in word_dictionary]
    
    # 将索引化后的输入数据转换为PyTorch张量
    input_data = torch.tensor(indexed_sent)
    
    # 调整张量的形状,将其变成列向量
    input_data = input_data.view(len(input_data), 1)
    
    # 创建LSTM模型,使用预定义的参数
    model = LSTM(vocab_size=len(inverse_word_dictionary), hidden_dim=hidden_dim, num_layers=num_layers,
                 embedding_dim=embedding_dim, output_dim=output_dim)
    
    # 将模型设置为评估模式,不进行梯度计算
    model.eval()
    
    # 使用不计算梯度的上下文进行模型的前向传播,获取预测结果
    with torch.no_grad():
        predictions = model(input_data)
    
    # 根据预测结果选择具体的类别
    predicted_class = torch.argmax(predictions, dim=1).item()
    
    # 打印预测结果,0代表负面,1代表正面
    if predicted_class == 0:
        print("负面")
    else:
        print("正面")
    
    # 返回预测的类别,并打印出来
    return print("预测值", predicted_class)

测试

 sent = "电视刚安装好,说实话,画质不怎么样,很差!"
 predictions(sent)

结果

负面
预测值 0

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/996910.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

LeetCode(力扣)37. 解数独Python

LeetCode37. 解数独 题目链接代码 题目链接 https://leetcode.cn/problems/sudoku-solver/description/ 代码 class Solution:def solveSudoku(self, board: List[List[str]]) -> None:"""Do not return anything, modify board in-place instead."…

使用数据库表快速生成代码

这里使用的EasyCode插件,直接下载即可,这里需要有数据库的技术与使用idea,会使用起来更流畅! 使用idea连接数据库 右键选择表 勾选你所需要的添加, 鄙人一般除了debug,其他都会勾选上 点击确定,…

【电源专题】不合理接地引发的典型问题及地环路隔离的方法

在文章:【电源专题】接地的类型 中我们讲到因为历史的原因接地在不同时期的概念是不同的。到了如今大规模的集成电路时代,在单板中接地其实是想要一个参考电位,一个等势点。 但是理想终究是理想,在现实接地中,往往因为接地平面的阻抗不是0,而电源电流过大、信号频率过高…

目标检测笔记(十五): 使用YOLOX完成对图像的目标检测任务(从数据准备到训练测试部署的完整流程)

文章目录 一、目标检测介绍二、YOLOX介绍三、源码获取四、环境搭建4.1 环境检测 五、数据集准备六、模型训练七、模型验证八、模型测试 一、目标检测介绍 目标检测(Object Detection)是计算机视觉领域的一项重要技术,旨在识别图像或视频中的…

Linux权限的概念和管理

Linux权限的概念和管理 1. Linux权限的概念2. Linux权限管理2.1 文件访问者的分类(人)2.2 文件类型和访问权限(事物属性)2.2.1 文件类型2.2.2 基本权限 2.3 文件权限值的表示方法2.4文件访问权限的相关设置方法1. chmod&#xff0…

C++的运算符重载介绍

所谓重载,就是赋予新的含义。函数重载(Function Overloading)可以让一个函数名有多种功能,在不同情况下进行不同的操作。运算符重载(Operator Overloading)也是一个道理,同一个运算符可以有不同的功能。 实际上,我们已经在不知不觉中使用了运算符重载。例如,+号可以对…

IDEA控制台取消悬浮全局配置SpringBoot配置https

IDEA控制台取消悬浮 idea 全局配置 SpringBoot(Tomcat) 配置https,同时支持http 利用JDK生成证书 keytool -genkey -alias httpsserver -keyalg RSA -keysize 2048 -keystore server.p12 -validity 3650配置类 Configuration public class TomcatConfig {Value(&quo…

【golang】调度系列之m

调度系列 调度系列之goroutine 上一篇中介绍了goroutine,最本质的一句话就是goroutine是用户态的任务。我们通常说的goroutine运行其实严格来说并不准确,因为任务只能被执行。那么goroutine是被谁执行呢?是被m执行。 在GMP的架构中&#xff…

PC首页资源加载速度由8s降到2s的优化实践

随着需求的不断开发,前端项目不断膨胀,业务提出:你们的首页加载也太慢啦,我都需要7、8秒才能看到内容,于是乎主管就让我联合后端开启优化专项,目标是3s内展示完全首页的内容。 性能指标 开启优化时&#…

G0第28章:Go语言微服务框架

Go-kit Go kit教程04——中间件和日志 本文主要介绍了Go kit 中的中间件,并以日志中间件为例演示了如何设计和实现中间件。 上一篇中,我们对go kit搭建的项目进行了目录结构拆分 中间件 在 go kit 中,它对中间件的定义是一个接收Endpoint…

DataGridView绑定数据更新

1、创建数据类 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;namespace DataGridViewTest {internal class UserData{public string Name { get; set; }public int Weight { get; set; }public int …

“内存炸弹”DDOS拒绝服务攻击

Windows平台演示 最早的内存炸弹是 zip 炸弹,也称为死亡 zip,它是一种恶意计算机文件,旨在使读取该文件的程序崩溃或瘫痪。zip 炸弹不会劫持程序的操作,而是利用解压缩压缩文件所需的时间、磁盘空间或内存。 zip 炸弹的一个示例…

ConnectionError: Error connecting to Visdom server

pip install visdom python -m visdom.server点击网站即可访问

Modelsim仿真问题解疑三:LM_LICENSE_FILE与Vivado命名冲突

现象: modelsim和Vivado同一时间只能使用一个,另一个会报license相关的错误 原因: modelsim和Vivado的环境变量名称都为LM_LICENSE_FILE,值配置为其中一个时会导致另一个值被覆盖 解决: 对LM_LICENSE_FILE同时配置modelsim和v…

win10环境安装使用docker-maxwell

目的:maxwell可以监控mysql数据变化,并同步到kafka、mq或tcp等。 maxwell和canal区别: maxwell更轻量,canal把表结构也输出了 docker bootstrap可导出历史数据,canal不能 环境 :win10,mysql5…

反编译小程序 SyntaxError: Unexpected token ‘}‘ 异常处理

反编译小程序出现异常: SyntaxError: Unexpected token ‘}’ 网上很多都说使用最新版本的反编译 wxappUnpacker-master 包可以进行解析,但是大神已经停止了更新wxappUnpacker-master 包; 查找了网上大部分的wxappUnpacker-master 包&#…

查看mysql数据库的charset和collation

SELECT * FROM information_schema.SCHEMATA WHERE schema_name test_data; 发现: chaset是utf8mb4,collation是utf8mb4_generic_ci 可笑的是我导入sql脚本,要把脚本中所有的utf8mb4改为utf8,将utf8mb4_generic_ci为utf8_unico…

有哪些适合初学者的编程语言?

C语言 那为什么我还要教你C语言呢?因为我想要让你成为一个更好、更强大的程序员。如果你要变得更好,C语言是一个极佳的选择,其原因有二。首先,C语言缺乏任何现代的安全功能,这意味着你必须更为警惕,时刻了…

日志平台搭建第二章:Linux使用docker安装elasticsearch-head

一、elasticsearch-head的安装启动 #下载镜像 docker pull alivv/elasticsearch-head #启动 docker run -d --name eshead -p 9100:9100 alivv/elasticsearch-head 查看日志 docker logs -f eshead 出现如下证明启动成功 浏览器访问9100端口,出现以下页面也说明…

End-to-end 3D Human Pose Estimation with Transformer

基于Transformer的端到端三维人体姿态估计 摘要 基于Transformer的架构已经成为自然语言处理中的常见选择,并且现在正在计算机视觉任务中实现SOTA性能,例如图像分类,对象检测。然而,卷积方法在3D人体姿态估计的许多方法中仍然保…