29 - RNN的原理、API讲解及其逐行代码实现

最新推荐文章于 2023-09-09 10:29:10 发布
最新推荐文章于 2023-09-09 10:29:10 发布
阅读量1.4k 收藏 5
点赞数 2
分类专栏： pytorch python 文章标签： pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scar2016/article/details/124218989
版权
pytorch 同时被 2 个专栏收录
148 篇文章 26 订阅
订阅专栏
python
75 篇文章 2 订阅
订阅专栏

文章目录

1. 模型框架

1.1 记忆单元分类

记忆单元主要是为了存储过去的信息；常见的记忆单元如下：

  • RNN
  • GRU
  • LSTM

1.2 模型类别分类

  • 单向循环
  • 双向循环
  • 多层单向或双向循环

1.3 优缺点

  • 优点：
    （1）可以处理变长序列
    （2）模型大小与序列长度无关
    （3）计算量与序列长度呈线性增长
    （4）考虑历史信息
    （5）便于流式输出
    （6）权重时不变
  • 缺点：
    （1）串行计算比较慢
    （2）无法获取太长的历史信息

1.4 应用场景

  • AI诗歌生成；属于生成任务，one2many型
  • 文本情感分类：many2one
  • 词法识别：many2many
  • 机器翻译：many2many
  • 语言识别生成
  • 语言模型

2. 公式说明

2.1 公式

在这里插入图片描述

  • x t x_t xt​·：表示第 t 时刻的输入
  • h t h_t ht​：表示第 t 时刻的隐藏状态
  • h t − 1 h_{t-1} ht−1​：表示第 t-1 时刻的隐藏状态

2.2 输入输出大小

  • 输入：
    在这里插入图片描述
  • 输出：
    在这里插入图片描述

3. 代码

以下主要有两种实现方式

  1. 基于pytorch API 的实现单/双循环神经网络
  2. 自己根据公式手写的单/双循环神经网络
import torch
from torch import nn

hidden_in = 4
hidden_out = 3
num_layers = 1

# define the RNN layers
rnn_layer = nn.RNN(input_size=hidden_in, hidden_size=hidden_out, num_layers=num_layers,
				   batch_first=True)
batch_size = 2
sequence_length = 4

# random init the input
my_input = torch.randn(batch_size, sequence_length, hidden_in)

# random init the init hidden state
h_prev = torch.zeros(batch_size, hidden_out)
# my_output is all the state of h_n
# h_n is the final state
my_output, h_n = rnn_layer(my_input, h_prev.unsqueeze(0))


# print(f"my_output={my_output}")

# print(f"my_output.shape={my_output.shape}")

# print(f"h_n={h_n}")

# print(f"h_n.shape={h_n.shape}")


# custom_rnn_function
def custom_rnn_function(input, w_ih, w_hh, b_ih, b_hh, h_prev):
	"""
	formula:

	h_t = tanh(w_{ih}*x_t+b_{ih}+w_{hh}*h_{t-1}+b_{hh})
	x_t is the input at time t

	:param input: input(batch_size,sequence_length,hidden_in)
	:param w_ih: weight w_ih (hidden_out,hidden_in)
	:param w_hh: weight w_hh (hidden_out,hidden_out)

	:param b_ih: bias b_ih (hidden_out)
	:param b_hh: bias b_hh (hidden_out)
	:param h_prev: previous hidden h_prev (1,batch_size,hidden_out)
	:return: output ,h_n

	"""
	batch_size, sequence_length, hidden_in = input.shape
	hidden_out, hidden_in = w_ih.shape
	output = torch.zeros(batch_size, sequence_length, hidden_out)
	for t in range(sequence_length):
		# input[:,t,:].shape = [batch_size,hidden_in] -> (batch_size,hidden_in,1)
		x_t = input[:, t, :].unsqueeze(2)

		# w_ih.shape = [hidden_out,hidden_in] -> (batch_size,hidden_out,hidden_in)
		w_ih_batch = w_ih.unsqueeze(0).tile(batch_size, 1, 1)

		# w_hh = [hidden_out,hidden_out] -> (batch_size,hidden_out,hidden_out)
		# h_prev = [batch_size,hidden_out]

		w_hh_batch = w_hh.unsqueeze(0).tile(batch_size, 1, 1)

		# w_ih_times_x.shape=(batch_size,hidden_out,1) -> (batch_size,hidden_out)
		w_ih_times_x = torch.bmm(w_ih_batch, x_t).squeeze(-1)

		# w_hh_times_h.shape =(batch_size,hidden_out,1)->(batch_size,hidden_out)
		# h_prev = [batch_size,hidden_out] -> (batch_size,hidden_out,1)
		# w_hh = [hidden_out,hidden_out] -> (batch_size,hidden_out,hidden_out)
		w_hh_times_h = torch.bmm(w_hh_batch, h_prev.unsqueeze(2)).squeeze(-1)
		h_prev = torch.tanh((w_ih_times_x + b_ih + w_hh_times_h + b_hh))
		output[:, t, :] = h_prev

	return output, h_prev.unsqueeze(0)


# get the rnn_layers weights data
custom_w_ih = rnn_layer.weight_ih_l0
custom_w_hh = rnn_layer.weight_hh_l0
custom_bias_ih = rnn_layer.bias_ih_l0
custom_bias_hh = rnn_layer.bias_hh_l0

# sent rnn_layers'weight to custom_rnn_function
# if the output and h_n are the same with two function
# so that our custom function is correct.
custom_output, custom_hn = custom_rnn_function(my_input, custom_w_ih, custom_w_hh,
											   custom_bias_ih, custom_bias_hh, h_prev)


# print(f"custom_output={custom_output}")
# print(f"custom_hn={custom_hn}")
# print(f"my_output={my_output}")
# print(f"h_n={h_n}")
# print("check whether custom_output is equal to my_output")
# print(torch.isclose(custom_output, my_output))
# print("check whether custom_hn is equal to h_n")
# print(torch.isclose(custom_hn, h_n))


# custom_rnn_function
def bicstm_rnn_function(input, w_ih, w_hh, b_ih, b_hh, h_prev,
						w_ih_reverse, w_hh_reverse, b_ih_reverse, b_hh_reverse):
	batch_size, sequence_length, hidden_in = input.shape
	hidden_out, hidden_in = w_ih.shape
	output = torch.zeros(batch_size, sequence_length, hidden_out * 2)


	forward_output = custom_rnn_function(input, w_ih, w_hh, b_ih, b_hh, h_prev)[0]
	backward_output = custom_rnn_function(torch.flip(input, [1]), w_ih_reverse, w_hh_reverse, b_ih_reverse,
													 b_hh_reverse,h_prev)[0]
	output[:, :, :hidden_out] = forward_output
	output[:, :, hidden_out:] = torch.flip(backward_output,[1])


	# old
	# return output, output[:, -1, :].reshape((batch_size, 2, hidden_out)).transpose(0, 1)
	return output, torch.cat([forward_output[:,-1,:].unsqueeze(0),backward_output[:,-1,:].unsqueeze(0)],dim=0)


bi_rnn_layer = nn.RNN(input_size=hidden_in, hidden_size=hidden_out, num_layers=num_layers,
					  batch_first=True, bidirectional=True)

bi_h_prev = torch.zeros(2, batch_size, hidden_out)

bi_my_output, bi_h_n = bi_rnn_layer(my_input, bi_h_prev)
print(f"bi_my_output={bi_my_output}")
print(f"bi_h_n={bi_h_n}")

for k, v in bi_rnn_layer.named_parameters():
	print(k, v, v.shape)

bicstm_weight_ih_l0 = bi_rnn_layer.weight_ih_l0
bicstm_weight_hh_l0 = bi_rnn_layer.weight_hh_l0
bicstm_bias_ih_l0 = bi_rnn_layer.bias_ih_l0
bicstm_bias_hh_l0 = bi_rnn_layer.bias_hh_l0
bicstm_weight_ih_l0_reverse = bi_rnn_layer.weight_ih_l0_reverse
bicstm_weight_hh_l0_reverse = bi_rnn_layer.weight_hh_l0_reverse
bicstm_bias_ih_l0_reverse = bi_rnn_layer.bias_ih_l0_reverse
bicstm_bias_hh_l0_reverse = bi_rnn_layer.bias_hh_l0_reverse

bicstm_output, bicstm_h_n = bicstm_rnn_function(my_input, bicstm_weight_ih_l0, bicstm_weight_hh_l0, bicstm_bias_ih_l0,
												bicstm_bias_hh_l0,
												bi_h_prev[0], bicstm_weight_ih_l0_reverse, bicstm_weight_hh_l0_reverse,
												bicstm_bias_ih_l0_reverse,
												bicstm_bias_hh_l0_reverse)

print("pytorch API rnn")
# bi_my_output, bi_h_n
print(f"bi_my_output={bi_my_output}")
print(f"bi_h_n={bi_h_n}")
print("bicstm_output is equal to bi_my_output")
print(torch.isclose(bicstm_output,bi_my_output))
print(torch.isclose(bicstm_output,bi_my_output).shape)
print("bicstm_h_n is equal to bi_h_n")
print(torch.isclose(bicstm_h_n,bi_h_n))
print(torch.isclose(bicstm_h_n,bi_h_n).shape)

print("custom bidirectional rnn")
print(f"bicstm_output={bicstm_output}")
print(f"bicstm_output.shape={bicstm_output.shape}")
print(f"bicstm_h_n={bicstm_h_n}")
print(f"bicstm_h_n.shape={bicstm_h_n.shape}")
print("*"*50)
print(f"bi_my_output={bi_my_output}")
print(f"bi_my_output.shape={bi_my_output.shape}")
print(f"bi_h_n={bi_h_n}")
print(f"bi_h_n.shape={bi_h_n.shape}")
  • 结果：
bi_my_output=tensor([[[-0.3309, -0.6514,  0.8314, -0.7133, -0.8930, -0.7533],
         [-0.3520, -0.7544,  0.8153, -0.4129, -0.8242, -0.8933],
         [ 0.0365, -0.5342,  0.9046, -0.4952, -0.2890, -0.1609],
         [-0.3345, -0.4509,  0.6656, -0.7710, -0.4374, -0.2100]],

        [[-0.2685, -0.5694,  0.7102, -0.6100, -0.8374, -0.8259],
         [ 0.3823, -0.2883,  0.6636, -0.0259,  0.0331, -0.9175],
         [ 0.0728, -0.1796,  0.6884, -0.3441, -0.0081, -0.3160],
         [ 0.2953, -0.1599,  0.7536, -0.1300, -0.3686,  0.1407]]],
       grad_fn=<TransposeBackward1>)
bi_h_n=tensor([[[-0.3345, -0.4509,  0.6656],
         [ 0.2953, -0.1599,  0.7536]],

        [[-0.7133, -0.8930, -0.7533],
         [-0.6100, -0.8374, -0.8259]]], grad_fn=<StackBackward>)
weight_ih_l0 Parameter containing:
tensor([[-0.2153, -0.3879, -0.2379,  0.3674],
        [-0.3065, -0.1250, -0.3957,  0.0352],
        [ 0.4447, -0.1330,  0.3051,  0.5727]], requires_grad=True) torch.Size([3, 4])
weight_hh_l0 Parameter containing:
tensor([[-0.4278,  0.4842,  0.4345],
        [ 0.1279,  0.3849, -0.0556],
        [-0.2065, -0.4020,  0.4729]], requires_grad=True) torch.Size([3, 3])
bias_ih_l0 Parameter containing:
tensor([-0.4691, -0.4634,  0.5497], requires_grad=True) torch.Size([3])
bias_hh_l0 Parameter containing:
tensor([ 0.1844, -0.0852,  0.3367], requires_grad=True) torch.Size([3])
weight_ih_l0_reverse Parameter containing:
tensor([[-0.0869, -0.5565, -0.0156,  0.2845],
        [-0.4279, -0.1971, -0.3512,  0.3958],
        [ 0.4047,  0.1749, -0.4136,  0.5187]], requires_grad=True) torch.Size([3, 4])
weight_hh_l0_reverse Parameter containing:
tensor([[-0.3453,  0.2386,  0.5089],
        [-0.3314,  0.3804,  0.4880],
        [ 0.5452, -0.0493,  0.3664]], requires_grad=True) torch.Size([3, 3])
bias_ih_l0_reverse Parameter containing:
tensor([-0.3213, -0.5536,  0.1178], requires_grad=True) torch.Size([3])
bias_hh_l0_reverse Parameter containing:
tensor([-0.0876, -0.2065, -0.4133], requires_grad=True) torch.Size([3])
pytorch API rnn
bi_my_output=tensor([[[-0.3309, -0.6514,  0.8314, -0.7133, -0.8930, -0.7533],
         [-0.3520, -0.7544,  0.8153, -0.4129, -0.8242, -0.8933],
         [ 0.0365, -0.5342,  0.9046, -0.4952, -0.2890, -0.1609],
         [-0.3345, -0.4509,  0.6656, -0.7710, -0.4374, -0.2100]],

        [[-0.2685, -0.5694,  0.7102, -0.6100, -0.8374, -0.8259],
         [ 0.3823, -0.2883,  0.6636, -0.0259,  0.0331, -0.9175],
         [ 0.0728, -0.1796,  0.6884, -0.3441, -0.0081, -0.3160],
         [ 0.2953, -0.1599,  0.7536, -0.1300, -0.3686,  0.1407]]],
       grad_fn=<TransposeBackward1>)
bi_h_n=tensor([[[-0.3345, -0.4509,  0.6656],
         [ 0.2953, -0.1599,  0.7536]],

        [[-0.7133, -0.8930, -0.7533],
         [-0.6100, -0.8374, -0.8259]]], grad_fn=<StackBackward>)
         
# 重点：我们自己计算的结果跟官方定义的API结果一致为True
bicstm_output is equal to bi_my_output
tensor([[[True, True, True, True, True, True],
         [True, True, True, True, True, True],
         [True, True, True, True, True, True],
         [True, True, True, True, True, True]],

        [[True, True, True, True, True, True],
         [True, True, True, True, True, True],
         [True, True, True, True, True, True],
         [True, True, True, True, True, True]]])
torch.Size([2, 4, 6])
bicstm_h_n is equal to bi_h_n
tensor([[[True, True, True],
         [True, True, True]],

        [[True, True, True],
         [True, True, True]]])
         
torch.Size([2, 2, 3])
custom bidirectional rnn
bicstm_output=tensor([[[-0.3309, -0.6514,  0.8314, -0.7133, -0.8930, -0.7533],
         [-0.3520, -0.7544,  0.8153, -0.4129, -0.8242, -0.8933],
         [ 0.0365, -0.5342,  0.9046, -0.4952, -0.2890, -0.1609],
         [-0.3345, -0.4509,  0.6656, -0.7710, -0.4374, -0.2100]],

        [[-0.2685, -0.5694,  0.7102, -0.6100, -0.8374, -0.8259],
         [ 0.3823, -0.2883,  0.6636, -0.0259,  0.0331, -0.9175],
         [ 0.0728, -0.1796,  0.6884, -0.3441, -0.0081, -0.3160],
         [ 0.2953, -0.1599,  0.7536, -0.1300, -0.3686,  0.1407]]],
       grad_fn=<CopySlices>)
bicstm_output.shape=torch.Size([2, 4, 6])
bicstm_h_n=tensor([[[-0.3345, -0.4509,  0.6656],
         [ 0.2953, -0.1599,  0.7536]],

        [[-0.7133, -0.8930, -0.7533],
         [-0.6100, -0.8374, -0.8259]]], grad_fn=<CatBackward>)
bicstm_h_n.shape=torch.Size([2, 2, 3])
**************************************************
bi_my_output=tensor([[[-0.3309, -0.6514,  0.8314, -0.7133, -0.8930, -0.7533],
         [-0.3520, -0.7544,  0.8153, -0.4129, -0.8242, -0.8933],
         [ 0.0365, -0.5342,  0.9046, -0.4952, -0.2890, -0.1609],
         [-0.3345, -0.4509,  0.6656, -0.7710, -0.4374, -0.2100]],

        [[-0.2685, -0.5694,  0.7102, -0.6100, -0.8374, -0.8259],
         [ 0.3823, -0.2883,  0.6636, -0.0259,  0.0331, -0.9175],
         [ 0.0728, -0.1796,  0.6884, -0.3441, -0.0081, -0.3160],
         [ 0.2953, -0.1599,  0.7536, -0.1300, -0.3686,  0.1407]]],
       grad_fn=<TransposeBackward1>)
bi_my_output.shape=torch.Size([2, 4, 6])
bi_h_n=tensor([[[-0.3345, -0.4509,  0.6656],
         [ 0.2953, -0.1599,  0.7536]],

        [[-0.7133, -0.8930, -0.7533],
         [-0.6100, -0.8374, -0.8259]]], grad_fn=<StackBackward>)
bi_h_n.shape=torch.Size([2, 2, 3])

Process finished with exit code 0

4. 小结

关于单循环神经网络来说，我们需要注意的各个权重的矩阵大小，输入的大小问题。对于双循环神经网络来说，有两个顺序反向，第一个顺序是输入的反向，第二个是输出的反向。具体详见上述代码。

取个名字真难呐
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Transformer 综合讲解15-20章
chu227的博客
11-15 417
第15章: Question Generation综合案例源码、测试及调试 1，从Text到Multiple choice question数学原理、使用的Transformer知识、架构设计 1，自动生成错误的问题选项 2，使用GPT2自动生成对错二分类的问题 3，使用Transformer生成多选题目 4，使用Transformer自动生成完形填空题目 5，使用Transformer基于特定内容生成问题 6，完整案例调试分析 7，使用fastAPI部署、测试Transformer案例
pytorch入门10--循环神经网络（RNN）
qq_51476492的博客
03-15 2468
RNN
Pytorch RNN API使用以及手动编写
weixin_44936816的博客
03-22 894
Pytorch RNN API使用以及手动编写
【NLP】RNN理解（Pytorch实现）
myaijarvis notebook
05-03 2850
【参考：【循环神经网络】5分钟搞懂RNN，3D动画深入浅出_哔哩哔哩_bilibili】 参数理解 上面这张图最能表明RNN的运行原理 【参考：pytorch中RNN参数的详细解释_lwgkzl的博客-CSDN博客】 自己的笔记 【参考：【PyTorch深度学习实践 | 刘二大人】B站视频教程笔记_myaijarvis的博客-CSDN博客】 多层、双向RNN 【参考：循环神经网络的改进：多层RNN、双向RNN与预训练_DeepGeGe的博客-CSDN博客】 ...
一文读懂官方给出torch.nn.RNN API的参数及手写RNN API复现
最新发布
xinxin的博客
09-09 853
此外，`torch.nn.RNN`还返回一个包含最后一个时间步的隐藏状态的张量，通常称为`h_n`。
LLaMA的解读与其微调(含LLaMA 2)：Alpaca-LoRA/Vicuna/BELLE/中文LLaMA/姜子牙
热门推荐
结构之法 算法之道
03-22 6万+
还开始研究一系列开源模型(包括各自对应的模型架构、训练方法、训练数据、本地私有化部署、硬件配置要求、微调等细节)​该项目部分一开始是作为此文《》的第4部分，但但随着研究深入 为避免该文篇幅又过长，将把『第4部分 开源项目』抽取出来 独立成本文。
[论文阅读] RNN 在阿里DIEN中的应用
罗西的思考
11-07 362
本文基于阿里推荐DIEN代码，梳理了下RNN一些概念，以及TensorFlow中的部分源码。本博客旨在帮助小伙伴们详细了解每一步骤以及为什么要这样做。
PyTorch学习笔记:GRU的原理及其手写复现
qq_73462282的博客
08-16 407
首先再开始之前,我想问一下在座的各位实现过GRU的源码吗,不会的扣1,会的小伙伴们扣脚指头,嘿嘿,开玩笑的,我也不知道,那么接下来我们一起学习如何写吧!其次 ,对于上一篇LSTM,其实还存在另外一种四个门都存在c(t-1),有兴趣的小伙伴可以 自行修改代码以实现或者可以查看视频讲解需要注意的,例如LSTM存在prej_size,存在俩个初始状态(在原公式中找下标有t-1的)
5-RNN-02_RNN基本api
01-06
tf.nn.rnn_cell_impl # 定义rnn细胞核具体是如何实现的 tf.nn.dynamic_rnn() # 单向动态rnn。 tf.nn.bidirectional_dynamic_rnn() # 双向动态rnn tf.nn.static_rnn() # 单向静态rnn tf.nn.static_bidirectional_rnn...
wtte-rnn-examples:WTTE-RNN的实现示例
05-11
`wtte-rnn-examples-master`这个压缩包很可能是WTTE-RNN模型的实现代码库，通常会包含模型的定义、训练脚本以及可能的数据预处理和结果评估部分。通过这个代码库，我们可以更深入地理解WTTE-RNN的工作原理，学习如何...
pytorch-polygon-rnn:Pytorch实现的Polygon-RNN（http
05-03
pytorch-polygon-rnn Pytorch实现。 注意，我使用另一种方法来处理第一个顶点，而不是像本文中那样训练另一个模型。 与原纸的不同 我使用两个虚拟起始顶点来处理第一个顶点，如图像标题所示。 我需要在ConvLSTM层...
wtte-rnn：WTTE-RNN：流失和事件预测时间的框架
02-06
WTTE-RNN是一种算法和关于如何实现的哲学。快速直观的介绍Jupyter笔记本：，Gianmario Spacagna的“故障时间”。 韩文安装Python查看。 如果这看起来，则可以将其作为内嵌式内联找到思想和基础您具有包含许多时间...
深度学习-循环神经网络RNN-RNN代码实现-学习RNN的学习笔记
06-14
本资源主要是使用pytorch构建RNN项目代码的测试结果展示和个人对每一步代码的见解注释，以及代码运行过程中生成的数据格式展示，还包含代码用到的部分函数介绍。 RNN相关文章分为循环神经网络原理介绍，链接地址：...
李沐动手学深度学习pytorch :问题：找不到d2l包，No module named ‘d2l’
scar2016的博客
03-21 3万+
下载d2lzh_pytorch 直接百度云： 链接：https://pan.baidu.com/s/1ndV7qloDG7vIGrZmEdasWw 提取码：hwn4 将文件夹 d2lzh_pytorch 【记住这个是 小写 L 不是 数字 1 】 放到anaconda 你自己创建的环境下： C:\ProgramData\Anaconda3\envs\pytorchzc\Lib\site-packages 重点：要放到自己创建的环境下，别放错了。 在Anaconda Prompt 下查看环境: conda.
pytorch中 reshape函数解析
scar2016的博客
03-24 2万+
1.reshape(m,n) 即： 将矩阵变成 m x n列矩阵 1.1代码： import torch x = torch.arange(12) # 生成一维行向量 ，从1到11 x 1.1结果： tensor([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) 1.2代码： x.reshape(3,4) # 将矩阵x变成 3行4列矩阵 1.2结果： tensor([[ 0, 1, 2, 3], [ 4, 5, 6, 7]
jupyter notebook内核挂掉了，需要重启
scar2016的博客
04-14 2万+
在运行如下代码时： %matplotlib inline import numpy as np from IPython import display from d2l import torch as d2l def f(x): return 3*x**2-4*x def numerical_lim(f, x, h): return (f(x + h) - f(x)) / h h = 0.1 for i in range(5): print(f'h={h:.5f}, numer
yolov5-调用GPU
scar2016的博客
07-22 1万+
文章目录1.遇到问题2.解决方式 1.遇到问题 在调试yolov5时，我们发现在运行detect.py时发现提示是：using CPU 2.解决方式 将device中的default =“CPU”改成默认“ ”；注意：在模块：if name == ‘main’:中 更改前： parser.add_argument('--device', default='CPU', help='cuda device, i.e. 0 or 0,1,2,3 or cpu') 更改后： parser.add_argume
torch.rand&torch.randn介绍
scar2016的博客
04-16 7396
文章目录1.torch.rand介绍1. 1 descreption描述1.2 Keyword Arguments参数介绍1.3 example举例:2.torch.randn 介绍2.1 descreption描述2.2 Keyword Arguments参数介绍2.3example 举例： 1.torch.rand介绍 从[0,1]均匀分布中随机抽取数据，返回张量 torch.rand(*size, *, out=None,dtype=None, layou
LSTM-RNN模型如何实现分类
05-21
LSTM-RNN模型可以用于分类任务，通常有以下步骤： 1. 数据预处理：将输入数据转化为模型可以接受的形式，例如将文本数据转化为词向量表示。 2. 模型构建：使用LSTM-RNN模型构建分类器。LSTM-RNN模型可以接受序列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值