文本相似度（pytorch版本） Bi-Lstm+Attention

最新推荐文章于 2024-07-15 21:34:18 发布
最新推荐文章于 2024-07-15 21:34:18 发布
阅读量2.9k 收藏 19
点赞数 3
分类专栏： 文本相似度 文章标签： lstm pytorch 深度学习 自然语言处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/szn1043862535/article/details/123417160
版权

最近在学习文本相似度方向的知识，顺便做了个实验，摸索了好长时间

网络结构是Bi-LSTM(hidden=128)+Attention+FC

导入相关包
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from word2vec_util import Vocab_size,Embedding_matrix,get_dataloader
定义网络结构
class test_model(nn.Module):
    def __init__(self):
        super(test_model, self).__init__()
        self.Vocab_size = Vocab_size #词典大小
        self.batch_size = 500 
        self.input_size = 300 #和embedding_size作用一样
        self.n_hidden1 = 128 #bi-lstm的隐藏层大小
        self.Embedding_dim = 300 #词嵌入维度，这里我使用了word2vec预训练的词向量
        self.n_class=2 #相似和不相似两种分类
        self.dropout = nn.Dropout(0.5) #dropout设置为0.5，不知道后面起没起作用
        self.Embedding_matrix = Embedding_matrix #词嵌入矩阵，#size=[Vocab_size,embedding_size]，可以自己训练一个词向量矩阵。
        self.word_embeds = nn.Embedding(self.Vocab_size, self.Embedding_dim) #嵌入层
        pretrained_weight = np.array(self.Embedding_matrix) #转换成numpy类型
        self.word_embeds.weight.data.copy_(torch.from_numpy(pretrained_weight)) #将词嵌入矩阵放到网络结构中
        self.Bi_Lstm1 = nn.LSTM(self.Embedding_dim, hidden_size=self.n_hidden1, bidirectional=True) #bi-lstm,hidden_size = 128

        self.fc = nn.Linear(self.n_hidden1*2,self.n_class,bias=False) #根据attention后的输出，全连接层的大小设置为(256,2)
        self.b = nn.Parameter(torch.rand([self.n_class])) #偏置b
        pass
        
    def attention_weight1(self,outputs1,final_state1): #最好debug一步一步看怎么变化
        outputs1  = outputs1.permute(1,0,2)
        hidden = final_state1.view(-1,self.n_hidden1*2,1)
        attention_weights = torch.bmm(outputs1,hidden).squeeze(2) #z=torch.bmm(x,y)针对三维数组相乘，x=[a,b,c],y =[a,c,d], z = [a,b,c],这里的a,b,c,d都是size.
        soft_attention_weights1 = F.softmax(attention_weights,1)
        context1 = torch.bmm(outputs1.transpose(1,2),soft_attention_weights1.unsqueeze(2)).squeeze(2)
        return context1,soft_attention_weights1
        pass

    def forward(self,train_left,train_right):
        train_left = self.word_embeds(train_left).to(device) #train_left为索引，mapping词向量，得到一个词向量矩阵，size(12,300)
        train_right = self.word_embeds(train_right).to(device) #同上

        train_left = train_left.transpose(0,1) #交换维度 ，变为[seq_len,batch_size,embedding_dim]
        train_right = train_right.transpose(0,1)

        hidden_state1 = torch.rand(2,self.batch_size,self.n_hidden1).to(device) #隐藏层单元初始化
        cell_state1 = torch.rand(2,self.batch_size,self.n_hidden1).to(device)

        outputs1_L,(final_state1_L,_) =self.Bi_Lstm1(train_left,(hidden_state1,cell_state1))#左右两边参数共享
        outputs1_L = self.dropout(outputs1_L) #左边输出
        attn_outputs1_L,attention1_L = self.attention_weight1(outputs1_L,final_state1_L)#左右两边attention也共享

        outputs1_R,(final_state1_R,_) =self.Bi_Lstm1(train_right,(hidden_state1,cell_state1))
        outputs1_R = self.dropout(outputs1_R)
        attn_outputs1_R, attention1_R = self.attention_weight1(outputs1_R, final_state1_R)

        outputs1 = attn_outputs1_L #attention后的输出
        outputs2 = attn_outputs1_R

        output = torch.abs(outputs1 - outputs2) #采用的是曼哈顿距离（两个向量相减的绝对值），也可以使用别的距离
        output = self.fc(output)+self.b #全连接，得到二分类
        output = F.softmax(output,dim=1) #softmax函数归一
        return output
        pass
训练部分
def train(model, device, train_loader, optimizer,criterion,epoch):
    print('Training on {} samples...'.format(len(train_loader.dataset)))
    model.train()
    train_loss = 0
    num_correct = 0
    for batch_idx,(train_left,train_right,lables) in enumerate(train_loader):#返回的是元组，记得加括号
        train_left = train_left.to(device)
        train_right = train_right.to(device)
        lables = lables.to(device)
        optimizer.zero_grad()
        output = model(train_left,train_right)
        loss = criterion(output,lables)
        loss.backward()
        optimizer.step()
        train_loss += float(loss.item())
        true = lables.data.cpu()
        predict = torch.max(output,dim=1)[1].cpu()
        num_correct += torch.eq(predict,true).sum().float().item()
    train_acc = num_correct / len(train_loader.dataset)
    train_loss = train_loss/len(train_loader)
    msg = 'Epoch: {0:>5},  Train Loss: {1:>5.5},  Train Acc: {2:>6.4%}'
    print(msg.format(epoch,train_loss,train_acc))
训练
if __name__ == '__main__':
    Epochs = 60
    Learn_rate = 0.001
    device = torch.device("cuda" if torch.cuda.is_available() else 'cpu')
    dataloder = get_dataloader()
    Bi_LstmModel= test_model().to(device)
    criterion = nn.CrossEntropyLoss().to(device)
    #criterion = ContrastiveLoss().to(device)
    optimizer = optim.Adam(Bi_LstmModel.parameters(),lr=Learn_rate)
    for epoch in range(Epochs):
        train(Bi_LstmModel, device, dataloder, optimizer, criterion,epoch+1)
结果
length of vocabs:5956
5956
Found 5956 word vectors.
average_length: 6.520725
max_length: 12
Training on 100000 samples...
Epoch:     1,  Train Loss: 0.64095,  Train Acc: 62.9720%
Training on 100000 samples...
Epoch:     2,  Train Loss: 0.58864,  Train Acc: 70.8260%
Training on 100000 samples...
Epoch:     3,  Train Loss: 0.55469,  Train Acc: 74.9770%
Training on 100000 samples...
Epoch:     4,  Train Loss: 0.52636,  Train Acc: 78.2610%
Training on 100000 samples...
Epoch:     5,  Train Loss: 0.50418,  Train Acc: 80.7080%
Training on 100000 samples...
Epoch:     6,  Train Loss: 0.48491,  Train Acc: 82.8620%
Training on 100000 samples...
Epoch:     7,  Train Loss: 0.46984,  Train Acc: 84.5690%
Training on 100000 samples...
Epoch:     8,  Train Loss: 0.456,  Train Acc: 85.9410%
Training on 100000 samples...
Epoch:     9,  Train Loss: 0.44567,  Train Acc: 87.0060%
Training on 100000 samples...
Epoch:    10,  Train Loss: 0.43607,  Train Acc: 88.0130%
Training on 100000 samples...
Epoch:    11,  Train Loss: 0.42797,  Train Acc: 88.8480%
Training on 100000 samples...
Epoch:    12,  Train Loss: 0.42026,  Train Acc: 89.5970%
Training on 100000 samples...
Epoch:    13,  Train Loss: 0.41379,  Train Acc: 90.2630%
Training on 100000 samples...
Epoch:    14,  Train Loss: 0.40766,  Train Acc: 90.8920%
Training on 100000 samples...
Epoch:    15,  Train Loss: 0.40276,  Train Acc: 91.3650%
Training on 100000 samples...
Epoch:    16,  Train Loss: 0.39678,  Train Acc: 91.9920%
Training on 100000 samples...
Epoch:    17,  Train Loss: 0.39264,  Train Acc: 92.3740%
Training on 100000 samples...
Epoch:    18,  Train Loss: 0.38861,  Train Acc: 92.7450%
Training on 100000 samples...
Epoch:    19,  Train Loss: 0.38506,  Train Acc: 93.0790%
Training on 100000 samples...
Epoch:    20,  Train Loss: 0.3821,  Train Acc: 93.4100%
Training on 100000 samples...
Epoch:    21,  Train Loss: 0.37889,  Train Acc: 93.7120%
Training on 100000 samples...
Epoch:    22,  Train Loss: 0.37757,  Train Acc: 93.8200%
Training on 100000 samples...
Epoch:    23,  Train Loss: 0.37417,  Train Acc: 94.0930%
Training on 100000 samples...
Epoch:    24,  Train Loss: 0.3715,  Train Acc: 94.4140%
Training on 100000 samples...
Epoch:    25,  Train Loss: 0.36956,  Train Acc: 94.5810%
Training on 100000 samples...
Epoch:    26,  Train Loss: 0.36763,  Train Acc: 94.7730%
Training on 100000 samples...
Epoch:    27,  Train Loss: 0.36562,  Train Acc: 94.9750%
Training on 100000 samples...
Epoch:    28,  Train Loss: 0.36378,  Train Acc: 95.1200%
Training on 100000 samples...
Epoch:    29,  Train Loss: 0.36189,  Train Acc: 95.3260%
Training on 100000 samples...
Epoch:    30,  Train Loss: 0.36093,  Train Acc: 95.4330%
Training on 100000 samples...
Epoch:    31,  Train Loss: 0.35879,  Train Acc: 95.6250%
Training on 100000 samples...
Epoch:    32,  Train Loss: 0.35819,  Train Acc: 95.6460%
Training on 100000 samples...
Epoch:    33,  Train Loss: 0.35632,  Train Acc: 95.8660%
Training on 100000 samples...
Epoch:    34,  Train Loss: 0.35541,  Train Acc: 95.9820%
Training on 100000 samples...
Epoch:    35,  Train Loss: 0.35451,  Train Acc: 96.0200%
Training on 100000 samples...
Epoch:    36,  Train Loss: 0.35287,  Train Acc: 96.1810%
Training on 100000 samples...
Epoch:    37,  Train Loss: 0.35191,  Train Acc: 96.2920%
Training on 100000 samples...
Epoch:    38,  Train Loss: 0.35084,  Train Acc: 96.4330%
Training on 100000 samples...
Epoch:    39,  Train Loss: 0.35073,  Train Acc: 96.3850%
Training on 100000 samples...
Epoch:    40,  Train Loss: 0.34976,  Train Acc: 96.5080%
Training on 100000 samples...
Epoch:    41,  Train Loss: 0.34839,  Train Acc: 96.6140%
Training on 100000 samples...
Epoch:    42,  Train Loss: 0.34836,  Train Acc: 96.6310%
Training on 100000 samples...
Epoch:    43,  Train Loss: 0.34741,  Train Acc: 96.6780%
Training on 100000 samples...
Epoch:    44,  Train Loss: 0.34707,  Train Acc: 96.6900%
Training on 100000 samples...
Epoch:    45,  Train Loss: 0.34599,  Train Acc: 96.8830%
Training on 100000 samples...
Epoch:    46,  Train Loss: 0.34547,  Train Acc: 96.9310%
Training on 100000 samples...
Epoch:    47,  Train Loss: 0.34464,  Train Acc: 96.9570%
Training on 100000 samples...
Epoch:    48,  Train Loss: 0.34371,  Train Acc: 97.0530%
Training on 100000 samples...
Epoch:    49,  Train Loss: 0.3439,  Train Acc: 97.0470%
Training on 100000 samples...
Epoch:    50,  Train Loss: 0.34344,  Train Acc: 97.0800%
Training on 100000 samples...
Epoch:    51,  Train Loss: 0.34239,  Train Acc: 97.1990%
Training on 100000 samples...
Epoch:    52,  Train Loss: 0.34175,  Train Acc: 97.2850%
Training on 100000 samples...
Epoch:    53,  Train Loss: 0.34119,  Train Acc: 97.3100%
Training on 100000 samples...
Epoch:    54,  Train Loss: 0.34126,  Train Acc: 97.2960%
Training on 100000 samples...
Epoch:    55,  Train Loss: 0.34068,  Train Acc: 97.3470%
Training on 100000 samples...
Epoch:    56,  Train Loss: 0.34012,  Train Acc: 97.3980%
Training on 100000 samples...
Epoch:    57,  Train Loss: 0.33972,  Train Acc: 97.4420%
Training on 100000 samples...
Epoch:    58,  Train Loss: 0.3399,  Train Acc: 97.4150%
Training on 100000 samples...
Epoch:    59,  Train Loss: 0.33941,  Train Acc: 97.4970%
Training on 100000 samples...
Epoch:    60,  Train Loss: 0.33927,  Train Acc: 97.4890%
栽娃
关注
  • 3
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
基于Pytorch的中文问题相似度实战
CSDN 精品推荐
11-06 1679
本项目使用的是科大讯飞中文问题相似度挑战赛数据集数据集下载链接。输入层：输入层负责读入两个语句信息嵌入层：使用embedding将句子进行嵌入表达表示层：采用lstm获取语义信息，使用最后一个隐层进行表达语义信息匹配层：使用余弦相似度计算两个表示层向量的相似度得分层：使用全连接层将相似度向量映射成概率。
TextMatch:基于Pytorch的，中文语义相似度匹配模型（ABCNN，Albert，Bert，BIMPM，DecomposableAttention，DistilBert，ESIM，RE2，Roberta，SiaGRU，XlNet）
03-20
基于Pytorch的中文语义相似度匹配模型 基于Pytorch的中文语义相似度匹配模型 本项目将持续更新，对比目前业界主流文本匹配模型在中文的效果 运行环境：python3.7，pytorch1.2，transformers2.5.1 数据集采用LCQMC数据（将一个句子对进行分类，判断两个句子的语义是否相同（二分类任务）），因数据存在涉嫌嫌疑，故不提供下载，需要者可向官方提出数据申请 ，将数据解压到数据文件夹即可。模型评价指标为：ACC，AUC以及预测总计耗时。 嵌入：本项目输入都统一采用分字策略，故通过维基百科中文语料，训练了字向量作为嵌入。训练语料，矢量模型以及词表，可通过百度网盘下载。链接： : 提取码：s830 模型文件：本项目训练的模型文件（不一定最优，可通过超参继续调优），也可通过网盘下载。链接： : 提取码：s830 测试集结果对比： 模型 行政协调会 AUC 耗时（s
基于双向长短时记忆神经网络(Bi-LSTM)的数据回归预测
最新发布
yuchunyu12的博客
07-15 1177
LSTM网络虽然能防止RNN网络的梯度消失或者爆炸情况的出现，但是神经网络训练中，LSTM网络的单向传播结构限制了对时序数据的充分利用。相较于传统的单向LSTM，BiLSTM的双向结构能够有效地提高数据利用率，弥补了传统LSTM在处理时序数据时的局限性。回归预测：通过在训练过程中优化模型参数，Bi-LSTM可以预测时间序列中下一个时间步的数值，或者进行更长期的预测。各位有什么急需的代码，欢迎后台留言~不定时更新科研技巧类推文，可以一起探讨科研，写作，文献，代码等诸多学术问题，我们一起进步。
Bi-LSTM + Attention模型
永远飞翔的鸟
06-06 3483
虽然看了一些很好的blog了解了LSTM的内部机制，但对框架中的lstm输入输出和各个参数还是没有一个清晰的认识，今天打算彻底把理论和实现联系起来，再分析一下pytorch中的LSTM实现。 先说理论部分。一个非常有名的blog把原理讲得很清楚，推荐参考。总之就是这些公式： 简单来说就是，LSTM一共有三个门，输入门，遗忘门，输出门，分别为三个门的程度参数，是对输入的常规RNN操作。公式里可以看到LSTM的输出有两个，细胞状态和隐状态，是经输入、遗忘门的产物，也就是当前c...
EasyBert:基于Pytorch的Bert应用，包括命名实体识别、情感分析、文本分类以及文本相似度等
04-22
EasyBert 基于Pytorch的Bert应用，包括命名实体识别、情感分析、文本分类以及文本相似度等(后续更新其他方向相关模块)，并有相关数据与深度训练优化方式api。各个子项目大都为开源工作，本项目仅做相应处理以及提供一个已训练的预测接口，方便需求者进行快速的使用。本项目仅作为学习与研究使用，若存在侵权行为，请原作者务必联系我进行协商处理。 使用示例 使用前需下载相应的已训练模型，并导入相应位置 模型下载地址： 在此目录下各以需求名命名的文件中提供相应的使用演示，本阶段所训练的模型效果可以满足相应任务的基本需求。 现阶段通过各任务接口的时间相对慢，大都是在模型加载阶段。若想提升相应的速度，请使用者在接受相应精度损失的前提下更换AlBert进行相应任务的重新预训练。 依赖项 环境依赖 python >= 3.7 Pytorch >= 1.14 transformers >= 2.8.0
文本分类实战—— Bi-LSTM + Attention模型
SeaSky_Steven的博客
03-03 4388
1 大纲概述 　　文本分类这个系列将会有十篇左右，包括基于word2vec预训练的文本分类，与及基于最新的预训练模型（ELMo，BERT等）的文本分类。总共有以下系列： 　　word2vec预训练词向量 　　textCNN 模型 　　charCNN 模型 　　Bi-LSTM 模型 　　Bi-LSTM + Attention 模型 　　RCNN 模型 　　Adversarial LS...
pytorch-sentiment-analysis-classification:情感分析分类的PyTorch教程（RNN，LSTM，Bi-LSTM，LSTM + Attention，CNN）
05-24
情感分析分类 先决条件 安装依赖项 pip install -r requirements.txt 安装Spacy英语数据 python -m spacy download en 框架 火炬 数据集 Cornell MR（电影评论）数据集 ... LSTM 双LSTM LSTM +注意 有线电视新闻网
ChineseNRE:中文实体关系抽取，pytorch，bilstm+attention
05-10
ChineseNRE 本项目使用 python 2.7 pytorch 0.4.0 中文实体关系抽取，对实体关系抽取不了解的可以先看。顺便求star～ ...模型使用的是lstm+attention模型。特征使用词向量+位置向量。 训练前先运行dat
CoupletAI:基于CNN + Bi-LSTM + Attention的自动对对联系统
03-11
用PyTorch实现的自动对对联系统，支持多种模型。一般而言，给定一句话生成另一句话是序列生成问题，本项目根据上下联字数不同的特点将其转化为序列标注问题，即用下联去标注上联。 依存关系 python 3.6+ pytorch ...
Pytorch框架基于Bert构建词向量+Bi-LSTM+Attention实现情感分类任务python源码+数据集.zip
05-24
Pytorch框架基于Bert构建词向量+Bi-LSTM+Attention实现情感分类任务python源码+数据集.zip个人经导师指导并认可通过的高分毕业设计项目，评审分98分。主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的...
基于Pytorch的Bert应用，包括命名实体识别、情感分析、文本分类以及文本相似度等
07-08
基于Pytorch的Bert应用，包括命名实体识别、情感分析、文本分类以及文本相似度等(后续更新其他方向相关模块)，并有相关数据与深度训练优化方式api。各个子项目大都为开源工作，本项目仅做相应处理以及提供一个已训练的预测接口，方便需求者进行快速的使用。本项目仅作为学习与研究使用，若存在侵权行为，请原作者务必联系我进行协商处理。
pytorch-fsim:Pytorch中特征相似性指标度量的可微实现
03-06
pytorch-fsim Pytorch中特征相似性指标度量的可微实现
BiLSTM_Attention.rar
12-04
BiLSTM+Attention网络PyTorch实现 100%能跑通 有训练好的网络结构 有代码 也可自己训练
word2vec Pytorch实现文本数据
04-04
里面包含三个文件，text8.dev.txt、text8.test.txt、text8.train.txt。
【自然语言NLP】TensorFlow使用LSTM实现文本匹配任务
CSDN 精品推荐
01-14 789
在NLP自然语言处理领域，有时我们需要计算不同文本之间的相似度，将不同文本进行编码，然后处理成Embedding定长表示向量，然后使用LSTM进行输出文本表示，定义多个多输入源数据进行计算。 句子1：我不爱吃剁椒鱼头，但是我爱吃鱼头 句子2：我爱吃土豆，但是不爱吃地瓜 同样使用LSTM网络，把每个句子抽象成一个向量表示，通过计算这两个向量之间的相似度，就可以快速完成文本相似度计算任务。在实际场景里，我们也通常使用LSTM网络的最后一步hidden结果，将一个句子抽象成一个向量，然后通过向量点积，或者co
深度学习解决NLP问题：语义相似度计算
weixin_30512785的博客
11-02 2638
在NLP领域，语义相似度的计算一直是个难题：搜索场景下query和Doc的语义相似度、feeds场景下Doc和Doc的语义相似度、机器翻译场景下A句子和B句子的语义相似度等等。本文通过介绍DSSM、CNN-DSSM、LSTM-DSSM等深度学习模型在计算语义相似度上的应用，希望给读者带来帮助。 1. 背景 以搜索引擎和搜索广告为例，最重要的也最难解决的问题是语义相似度，这里主要体现在...
Attention + BiLSTM
weixin_44585519的博客
12-20 4916
Attention + BiLSTM摘要引文基本原理模型原理图模型解释思考参考资料 摘要 暂无 引文 关系抽取从本质上看是一个多分类问题，对于这样一个问题来说最重要的工作无非特征的提取和分类模型的选择。 存在的问题及此模型提出的解决方法 NLP特征提取难度大 双向LSTM结合Attention机制，能在长时保留信息的基础上，自动发现那些对于分类起到关键作用的词，避免了传统的任务中复杂的特征工程。 基本原理 模型原理图 模型解释 模型结构 输入层：将句子拆分成词语输入到模型中 Embed
pytorch 句子相似度
随笔
07-31 2539
文章目录1.根据向量1.1 embedding层介绍1.2 相似度计算1.2.1 字面距离相似度度量1.2.2 语义相似性2. 一些简单方法2.1 编辑距离2.2 杰卡德系数计算2.3 Word2Vec 计算 1.根据向量 1.1 embedding层介绍 做nlp很多时候要用到嵌入层，pytorch中自带了这个层，那么什么是embedding层？ 用最通俗的语言讲就是在nlp里，embedding层就是句子、词转为向量，比如把单词表[‘你’，‘好’，‘吗’] 编码成 ‘你’ --------------
Bi-LSTM-Attention概述及torch实现
WGS.
09-06 1343
Bi-LSTM-Attention概述，及torch实现
基于pytorch搭建cnn-lstm-attention
05-16
下面是基于PyTorch搭建CNN-LSTM-Attention的示例代码： ```python import torch import torch.nn as nn import torch.nn.functional as F class CNN_LSTM_Attention(nn.Module): def __init__(self, vocab_size, embedding_dim, hidden_dim, num_layers, dropout, output_dim, kernel_sizes, num_filters, bidirectional): super().__init__() # 定义嵌入层 self.embedding = nn.Embedding(vocab_size, embedding_dim) # 定义卷积层 self.convs = nn.ModuleList([ nn.Conv2d(in_channels=1, out_channels=num_filters, kernel_size=(fs, embedding_dim)) for fs in kernel_sizes ]) # 定义LSTM层 self.lstm = nn.LSTM(num_filters * len(kernel_sizes), hidden_dim, num_layers=num_layers, dropout=dropout, bidirectional=bidirectional) # 定义attention层 self.attention = nn.Linear(hidden_dim * 2 if bidirectional else hidden_dim, 1) # 定义全连接层 self.fc = nn.Linear(hidden_dim * 2 if bidirectional else hidden_dim, output_dim) # 定义dropout self.dropout = nn.Dropout(dropout) def forward(self, text): # text: [batch_size, sent_len] # 嵌入 embedded = self.embedding(text) # embedded: [batch_size, sent_len, emb_dim] # 变形 embedded = embedded.unsqueeze(1) # embedded: [batch_size, 1, sent_len, emb_dim] # 卷积 conved = [F.relu(conv(embedded)).squeeze(3) for conv in self.convs] # conved: [batch_size, num_filters, sent_len - fs + 1] # 池化 pooled = [F.max_pool1d(conv, conv.shape[2]).squeeze(2) for conv in conved] # pooled: [batch_size, num_filters] # 拼接 cat = self.dropout(torch.cat(pooled, dim=1)) # cat: [batch_size, num_filters * len(kernel_sizes)] # LSTM output, (hidden, cell) = self.lstm(cat.unsqueeze(0)) # output: [1, batch_size, hidden_dim * num_directions], hidden: [num_layers * num_directions, batch_size, hidden_dim], cell: [num_layers * num_directions, batch_size, hidden_dim] # attention attention_weights = F.softmax(self.attention(output.squeeze(0)), dim=1) # attention_weights: [batch_size, 1, hidden_dim * num_directions] attention_output = torch.bmm(attention_weights.transpose(1, 2), output.transpose(0, 1)).squeeze(1) # attention_output: [batch_size, hidden_dim * num_directions] # 全连接 return self.fc(self.dropout(attention_output)) ``` 此模型采用了CNN-LSTM-Attention结构，其中包含了嵌入层、卷积层、LSTM层、attention层和全连接层。在前向传播过程中，先将输入的文本通过嵌入层转换为词向量，然后通过多个不同大小的卷积核提取文本的不同特征，接着通过最大池化操作将各个特征的值取最大，最后将各个特征拼接起来输入到LSTM层中进行序列建模。在LSTM层之后，通过attention层对LSTM层的输出进行加权平均，得到文本的表示，最后通过全连接层输出分类结果。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值