Pytorch - CNN、RNN、GRU 分类

已于 2024-04-23 15:30:32 修改
阅读量1.5k 收藏 11
点赞数 2
CC 4.0 BY-SA版权
文章标签： pytorch cnn 分类
于 2022-02-19 13:29:23 首次发布
原文链接：https://www.bilibili.com/video/BV1Ky4y1g7Nk?p=3
该博客介绍了使用Pytorch进行姓名分类的教程，涵盖了CNN、RNN和GRU三种模型。首先讲解了数据预处理，将名字转化为字符表示。接着详细阐述了CNN如何实现姓名分类，然后讨论了RNN在姓名分类中的应用，特别是如何利用前一次的记忆。最后，文章探讨了GRU在字符预测任务中的无监督学习方法。源码和教学视频可供参考。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

视频：https://www.bilibili.com/video/BV1Ky4y1g7Nk?p=3
源码：https://github.com/lansinuote/NLP-Toturials

文章目录

数据准备等

对于名字，以字母来处理会比较好。
不像句子可以分词。
这里的字典：字符和数字的对应表，共29个字符；不认识的字符用0表示。包含 - 和 1。

在这里插入图片描述

数据文件

在这里插入图片描述

CNN 实现姓名分类

import numpy as np
import pandas as pd

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

# 1、定义数据集
class SurnameDataset(Dataset):
    def __init__(self, part):
        data = pd.read_csv('./data/surnames/数字化数据.csv')
        data = data[data.part == part]
        self.data = data

    def __getitem__(self, i):
        return self.data.iloc[i, 0], self.data.iloc[i, 1]

    def __len__(self):
        return len(self.data)


train_dataset = SurnameDataset(part='train')
val_dataset = SurnameDataset(part='val')
test_dataset = SurnameDataset(part='test')

print(len(train_dataset)) # 7680
print(len(val_dataset)) # 1640
print(len(test_dataset)) # 1660

# 2、x转one hot编码
def one_hot(data):
    N = len(data)
    #N句话,每句话15个词,每个词是个29维向量
    xs = np.zeros((N, 15, 29))
    ys = np.empty(N)
    for i in range(N):
        x, y = data[i]
        ys[i] = y

        x = x.split(',')
        for j in range(min(15, len(x))):
            xs[i, j, int(x[j]) - 1] = 1

    return torch.FloatTensor(xs), torch.LongTensor(ys)


# 3、数据加载器
train_dataloader = DataLoader(dataset=train_dataset,
                              batch_size=100,
                              shuffle=True,
                              drop_last=True, # 正好100个，不会有尾数
                              collate_fn=one_hot)

val_dataloader = DataLoader(dataset=val_dataset,
                            batch_size=100,
                            shuffle=True,
                            drop_last=True,
                            collate_fn=one_hot)

test_dataloader = DataLoader(dataset=test_dataset,
                             batch_size=100,
                             shuffle=True,
                             drop_last=True,
                             collate_fn=one_hot)

# 4、遍历数据
for i, data in enumerate(train_dataloader):
    x, y = data
    print(x[:2, :2], x.shape)
    print(y[:5], y.shape)
    break

# 5、定义网络模型
class SurnameClassifier(nn.Module):
    def __init__(self):
        super(SurnameClassifier, self).__init__()

        h = 50

        #[b,h,27] -> [b,h,13]
        self.conv1 = nn.Conv1d(in_channels=15,
                               out_channels=h,
                               kernel_size=5,
                               stride=2)

        #[b,h,13] -> [b,h,5]
        self.conv2 = nn.Conv1d(in_channels=h,
                               out_channels=h,
                               kernel_size=5,
                               stride=2)

        #[b,h,5] -> [b,h,1]
        self.conv3 = nn.Conv1d(in_channels=h,
                               out_channels=h,
                               kernel_size=5,
                               stride=1)

        #激活函数
        self.elu = nn.ELU()

        self.convnet = nn.Sequential(self.conv1, self.elu, self.conv2,
                                     self.elu, self.conv3, self.elu)

        self.fc = nn.Linear(h, 18)

    def forward(self, x):
        #out = self.conv1(x)
        #print(out.shape)

        #out = self.conv2(out)
        #print(out.shape)

        #out = self.conv3(out)
        #print(out.shape)

        #[b,h,27] -> [b,h]
        out = self.convnet(x).squeeze(dim=2) # 压缩掉多余的维度 

        #[b,h] -> [b,18]
        out = self.fc(out)
        return out


model = SurnameClassifier()
model(torch.randn(2, 15, 29))

def test(dataloader):

    model.eval()

    correct = 0
    total = 0
    for i, data in enumerate(dataloader):
        x, y = data

        y_pred = model(x)
        y_pred = y_pred.argmax(axis=1)

        correct += (y_pred == y).sum().item()
        total += len(y)

    return correct / total


test(val_dataloader)

loss_func = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

model.train()
for epoch in range(10):
    for i, data in enumerate(train_dataloader):
        x, y = data

        optimizer.zero_grad()
        y_pred = model(x)

        loss = loss_func(y_pred, y)
        loss.backward()
        optimizer.step()

    if epoch % 1 == 0:
        accurecy = test(val_dataloader)
        print(epoch, loss.item(), accurecy)

test(test_dataloader) # 0.659375

RNN 计算过程
拿本次的词和上一次的记忆作为输入。
在这里插入图片描述

RNN 实现姓名分类

字典和数据都和前面使用 CNN 对姓名分类一样；
这里不将名字变为 One-hot，而是切割为字；后面补 0。

import numpy as np
import pandas as pd

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

# 1、定义数据
class SurnameDataset(Dataset):
    def __init__(self, part):
        data = pd.read_csv('./data/surnames/数字化数据.csv')
        data = data[data.part == part]
        self.data = data

    def __getitem__(self, i):
        return self.data.iloc[i, 0], self.data.iloc[i, 1]

    def __len__(self):
        return len(self.data)


train_dataset = SurnameDataset(part='train')
val_dataset = SurnameDataset(part='val')
test_dataset = SurnameDataset(part='test')

print(len(train_dataset))
print(len(val_dataset))
print(len(test_dataset))


# 2、数据转 tensor 
def to_tensor(data):
    N = len(data)
    #N句话,每句话15个词
    xs = np.zeros((N, 15))
    ys = np.empty(N)
    for i in range(N):
        x, y = data[i]
        ys[i] = y

        x = x.split(',') + [0] * 15
        x = x[:15]
        xs[i] = x

    return torch.LongTensor(xs), torch.LongTensor(ys)


# 3、数据加载器
train_dataloader = DataLoader(dataset=train_dataset,
                              batch_size=100,
                              shuffle=True,
                              drop_last=True,
                              collate_fn=to_tensor)

val_dataloader = DataLoader(dataset=val_dataset,
                            batch_size=100,
                            shuffle=True,
                            drop_last=True,
                            collate_fn=to_tensor)

test_dataloader = DataLoader(dataset=test_dataset,
                             batch_size=100,
                             shuffle=True,
                             drop_last=True,
                             collate_fn=to_tensor)

# 4、遍历数据
for i, data in enumerate(train_dataloader):
    x, y = data
    print(x[:5], x.shape)
    print(y[:5], y.shape)
    break

# 5、定义网络模型
class SurnameClassifier(nn.Module):
    def __init__(self):
        super(SurnameClassifier, self).__init__()

        self.embedding = nn.Embedding(num_embeddings=30,
                                      embedding_dim=50,
                                      padding_idx=0)

        self.rnn_cell = nn.RNNCell(50, 100) # 输入50维，输出100维；
        # 这里使用 rnn cell，但先不使用 rnn 层。rnn层可以一次处理一整句话。

        self.fc1 = nn.Linear(in_features=100, out_features=100)
        self.fc2 = nn.Linear(in_features=100, out_features=18)

    # 网络计算函数
    def forward(self, x):

        b = x.shape[0]

        #[b,15] -> [b,15,20] # 多一个维度，20 
        embed = self.embedding(x)

        #[b,15,20] -> [b,30]
        out = torch.zeros((b, 100))
        for i in range(15):
            out = self.rnn_cell(embed[:, i, :], out) # 得到记忆

        #[b,30] -> [b,18]
        out = F.relu(self.fc1(F.dropout(out, 0.5))) 
        out = self.fc2(F.dropout(out, 0.5))

        return out


model = SurnameClassifier()
model(torch.ones(2, 15).long())

# 预测函数
def test(dataloader):

    model.eval()

    correct = 0
    total = 0
    for i, data in enumerate(dataloader):
        x, y = data

        y_pred = model(x)
        y_pred = y_pred.argmax(dim=1)

        correct += (y_pred == y).sum().item()
        total += len(y)

    return correct / total


test(val_dataloader)


loss_func = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

model.train()
for epoch in range(20):
    for i, data in enumerate(train_dataloader):
        x, y = data

        optimizer.zero_grad()
        y_pred = model(x)

        loss = loss_func(y_pred, y)
        loss.backward()
        optimizer.step()

    if epoch % 1 == 0:
        accurecy = test(val_dataloader)
        print(epoch, loss.item(), accurecy)


test(test_dataloader)

GRU 实现字符预测

三大循环神经网络

在这里插入图片描述

这里的字符预测，是无监督学习

#定义数据
class SurnameDataset(Dataset):
    def __init__(self, part):
        data = pd.read_csv('./data/surnames/数字化数据.csv')
        data = data[data.part == part]

        #去掉少于3个字符的名字
        def filter_by_len(line):
            return len(line.x.split(',')) >= 3

        data = data[data.apply(filter_by_len, axis=1)]

        self.data = data

    def __getitem__(self, i):
        return self.data.iloc[i, 0], self.data.iloc[i, 1]

    def __len__(self):
        return len(self.data)


train_dataset = SurnameDataset(part='train')
val_dataset = SurnameDataset(part='val')
test_dataset = SurnameDataset(part='test')

print(len(train_dataset))
print(len(val_dataset))
print(len(test_dataset))

def to_tensor(data):
    N = len(data)
    #N句话,每句话14个词
    xs = np.zeros((N, 14))
    #尾字母
    ys = np.empty(N)

    for i in range(N):
        x, y = data[i]

        x = x.split(',')
        
        #取x的最后一个字母作为y
        ys[i] = x[-1]

        #x去掉最后一个字母
        x = x[:-1]
        
        #反转后补0，在前面补0，切割到14位的长度
        x = x[::-1] + ['0'] * 14
        
        #切割到14位长度
        x = x[:14]
        
        #反转回来
        x = x[::-1]
        xs[i] = x

    return torch.LongTensor(xs), torch.LongTensor(ys)


#数据加载器
train_dataloader = DataLoader(dataset=train_dataset,
                              batch_size=100,
                              shuffle=True,
                              drop_last=True,
                              collate_fn=to_tensor)

val_dataloader = DataLoader(dataset=val_dataset,
                            batch_size=100,
                            shuffle=True,
                            drop_last=True,
                            collate_fn=to_tensor)

test_dataloader = DataLoader(dataset=test_dataset,
                             batch_size=100,
                             shuffle=True,
                             drop_last=True,
                             collate_fn=to_tensor)

#遍历数据
sample = None
for i, data in enumerate(train_dataloader):
    sample = data
    x, y = data
    print(x[:3], x.shape)
    print(y[:3], y.shape)
    break

#定义网络模型
class SurnameClassifier(nn.Module):
    def __init__(self):
        super(SurnameClassifier, self).__init__()

        self.embedding = nn.Embedding(num_embeddings=30,
                                      embedding_dim=50,
                                      padding_idx=0)

        self.rnn = nn.GRU(input_size=50, hidden_size=100, batch_first=True) # 输入是 50维的向量，记忆是100维；

        self.fc1 = nn.Linear(in_features=100, out_features=100)
        self.fc2 = nn.Linear(in_features=100, out_features=30)

    def forward(self, x):

        #[b,14] -> [b,14,50]
        embed = self.embedding(x)

        #[b,14,50] -> [b,14,100],[1,b,100]
        out, h = self.rnn(embed)

        #[b,100] -> [b,30]
        out = F.relu(self.fc1(F.dropout(h.squeeze(), 0.2)))
        out = self.fc2(F.dropout(out, 0.2))

        return out


model = SurnameClassifier()
model(sample[0])

def test(dataloader):

    model.eval()

    correct = 0
    total = 0
    for i, data in enumerate(dataloader):
        x, y = data

        y_pred = model(x)
        y_pred = y_pred.argmax(dim=1)

        correct += (y_pred == y).sum().item()
        total += len(y)

    return correct / total


test(val_dataloader)

# -----------

loss_func = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

model.train()
for epoch in range(20):
    for i, data in enumerate(train_dataloader):
        x, y = data

        optimizer.zero_grad()
        y_pred = model(x)

        loss = loss_func(y_pred, y)
        loss.backward()
        optimizer.step()

    if epoch % 1 == 0:
        accurecy = test(val_dataloader)
        print(epoch, loss.item(), accurecy)


test(test_dataloader)

2022-02-19(六) 下雨

python关键词对联_对联（代码1：CNN+GRU+Attention网络、PyTorch）
weixin_39835925的博客
03-02 1405
功能：对对联，输入上联得到下联。网络：CNN+GRU+Attention环境：python3.7 + PyTorch 1.3.1环境安装安装anaconda环境：AIPyTorch13cdsource /home/zyb/zyb/anaconda3/etc/profile.d/conda.shcdconda create --name AIPyTorch13 python=3.7.4 ipyker...
PyTorch实战：使用GRU实现名字分类问题
Ma Sizhou
07-22 9396
目录一、GRU介绍二、分类问题介绍三、PyTorch实现1、模型理解2、代码 一、GRU介绍 GRU（Gate Recurrent Unit）是循环神经网络（Recurrent Neural Network, RNN）的一种，和LSTM（Long-Short Term Memory）一样，也是为了解决长期记忆和反向传播中的梯度等问题而提出来的。我们在实验中选择GRU是因为它的实验效果与LSTM相似，但是更易于计算。 网上很多都使用画图来说明，我感觉不是很好，被一大堆的 “门” 给搞乱了，实际上看着公式更好理
RNN（pytorch）的维度问题——用GRU实现文本分类（参考刘二大人）
weixin_41168304的博客
05-03 2937
最近学LSTM的时候对于其中各种输入输出都有点懵，然后参考了刘二大人关于pytorch实践以及下面这篇文章Pytorch深度学习实践（b站刘二大人）P13讲 (RNN循环神经网络高级篇)_努力学习的朱朱的博客-CSDN博客代码把维度问题整理了一下 一、pytorch中embedding在做什么？ 我们先看下面这一段代码： import torch embedding = torch.nn.Embedding(10, 3) print(embedding.weight) # 根据索引取embeddi
GRU-Attention分类预测模型：强大的多分类预测工具
gitblog_06732的博客
05-23 871
GRU-Attention分类预测模型：强大的多分类预测工具 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 在当今机器学习领域，分类问题是最常见的问题类型之一。为了解决多特征输入单输出的分类问题，我们开源了GRU-Attention分类预测模型。该模型融合了门控循环单元（GRU）的优越特性与注意力机制的高效信息筛选能力，为二分类及多分类任务提供了一种强大的解决方案。 ...
GRU_FCN_分类
02-08
Vanilla_GRU_分类
Pytorch的CNN，RNN&LSTM
qq_36102055的博客
04-25 1220
可以看到有两个参数，一个是wi=(5, 3)一个是wh=(5, 5)，第一个参数wi用于乘以输入的数据，而第二个参数wh用于和隐藏层的向量相乘，在结合官方给出的RNN计算，我们就可以手动模拟以下RNN的推理过程了，RNN有两个输出，一个是out_put,一个是h_0。由于输出通道要除以groups，所以输入通道的数目会减少，此时每一个卷积核要负责的输入通道也就减少了，也就是说，卷积核的参数数目会减少groups倍，这就是分组卷积的意义。padding：填充，同样的可以是一个元组。一共有4个5x5的数据。
Pytorch代码，EMD-CNN-GRU时间序列风速气候预测（完整源码和数据）
最新发布
07-06
GRU是一种循环神经网络(RNN)的变体，相比于传统的RNN，它在处理长期依赖问题上有更好的表现，因为它具有更新门和重置门这两个额外的门结构。这使得GRU能够更好地捕捉时间序列数据的动态特征，保持长期依赖信息的同时...
深度学习之RNN,LSTM,GRU,CNN-GRU,ABLSTM(pytorch实现)
Dog_King_的博客
04-27 4061
RNN模型最重要的贡献就是引入了隐藏层，隐状态存储的都是前一些时刻的相关特征信息，也是隐状态让模型有了记忆的能力。计算公式就类似于线性层。t时刻的H是由t-1时刻的H（也就是记忆的之前的信息），加上Xt（当前时刻的特征）GRU模型和前面的RNN模型很像，包括输入特征、隐藏态、输出。但是又有了改进，主要改进了隐藏态H的计算方法，通过门控制隐状态。这里引进了门，就是数电那种逻辑电路。这里引入了重置门和更新门，都是根据上一个时刻的隐藏态和t时刻的特征X计算得出。GRU还引入了候选隐状态。
d2l-pytorch-slides:自动生成的笔记本幻灯片
04-01
2. **深度学习模型**：这里会涉及常见的神经网络结构，如卷积神经网络（CNN）用于图像识别，循环神经网络（RNN）及其变种LSTM、GRU处理序列数据，以及Transformer在自然语言处理中的应用。 3. **优化算法**：讲解...
pytorchcnn-rnn视频分类
01-17
### 使用PyTorch实现CNN-RNN进行视频分类 #### 构建模型架构 在视频分类任务中，CNN负责提取每一帧中的空间特征，而RNN则捕捉这些帧之间的时序依赖关系。这种组合能够有效利用视频的空间与时序信息。 ```python ...
GRU实现预测分类任务
qq_45754104的博客
07-26 2718
pytorch实现预测分类任务
pytorch实现用CNN和LSTM对文本进行分类方式
09-18
今天小编就为大家分享一篇pytorch实现用CNN和LSTM对文本进行分类方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
本文简单教学一下Pytorch实现对数据的DNN、RNN、CNN等操作（基于面向对象的CPU版本）
qq_45134942的博客
06-08 1086
主要写了一些Pytorch的常用代码
pytorch 实现gru_知识干货-动手学深度学习(pytorch)-13 循环神经网络进阶
weixin_42512719的博客
12-05 446
GRURNN存在的问题：梯度较容易出现衰减或爆炸（BPTT）⻔控循环神经⽹络：捕捉时间序列中时间步距离较⼤的依赖关系RNN:GRU:载入数据集import os os.listdir('/home/kesci/input') import numpy as np import torch from torch import nn, optim import torch.nn.functional ...
Pytorch利用GRU、LSTM实现中文情感分类
qq_45622118的博客
03-17 2424
Pytorch利用GRU、LSTM实现中文情感分类
GRU时间序列数据分类预测
weixin_39915444的博客
10-12 5188
GRU实现
pytorch入门：pytorch实现 LSTM ,GRU,RNN
AI路漫漫
01-27 2266
pytorch实现 LSTM ,GRU,RNN
【GRU分类】基于注意力机制门控循环单元attention-GRU实现数据多维输入单输出分类附matlab代码
matlab_dingdang的博客
09-08 725
在机器学习和深度学习领域，分类问题一直是一个重要的研究方向。分类任务的目标是将输入数据分为不同的类别，以便能够对未知数据进行准确的分类。在这个博文中，我们将介绍一种基于注意力机制门控循环单元（attention-GRU）的方法，用于实现数据多维输入单输出分类。GRU是一种循环神经网络（RNN）的变种，它在处理序列数据时具有优秀的性能。与传统的循环神经网络相比，GRU具有更少的参数和更好的训练效率。在分类问题中，我们通常需要将输入数据表示为一个固定长度的向量，以便能够使用传统的分类算法进行处理。
【GRU分类】基于门控循环单元GRU实现故障分类附matlab代码
m0_60703264的博客
03-02 905
在工业生产过程中，设备故障的及时发现和诊断对于确保生产安全和提高生产效率至关重要。传统的故障分类方法通常基于专家知识和经验规则，存在主观性强、泛化能力差等问题。随着深度学习技术的快速发展，基于深度学习的故障分类方法逐渐成为研究热点，其中门控循环单元（GRU）凭借其强大的时序建模能力和较好的泛化性能，在故障分类领域展现出良好的应用前景。GRU（Gated Recurrent Unit）是一种循环神经网络（RNN）的变体，由Cho等人于2014年提出。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值