【deep_thoughts】30_PyTorch LSTM和LSTMP的原理及其手写复现

已于 2023-03-29 20:27:09 修改
阅读量521 收藏 3
点赞数 3
文章标签： lstm pytorch 深度学习
于 2023-01-07 22:42:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45670134/article/details/128596565
版权

文章目录


视频链接： 30、PyTorch LSTM和LSTMP的原理及其手写复现_哔哩哔哩_bilibili

PyTorch LSTM API：https://pytorch.org/docs/stable/generated/torch.nn.LSTM.html?highlight=lstm#torch.nn.LSTM

LSTM API

首先实例化一些参数：

import torch
import torch.nn as nn

# 定义一些常量
batch_size, seq_len, input_size, h_size = 2, 3, 4, 5
input = torch.randn(batch_size, seq_len, input_size)  # 随机初始化一个输入序列
c_0 = torch.randn(batch_size, h_size)  # 初始值，不会参与训练
h_0 = torch.randn(batch_size, h_size)

调用PyTorch中的 LSTM API：

# 调用官方 LSTM API
lstm_layer = nn.LSTM(input_size, h_size, batch_first=True)  # num_layers默认为1
output, (h_n, c_n) = lstm_layer(input, (h_0.unsqueeze(0), c_0.unsqueeze(0)))  # (D*num_layers=1, b, hidden_size)

看一下返回的结果的形状：

print(output.shape)  # [2,3,5] [b, seq_len, hidden_size]
print(h_n.shape)  # [1,2,5] [num_layers, b, hidden_size]
print(c_n.shape)  # [1,2,5] [num_layers, b, hidden_size]

这里输出一下lstm_layer中的参数名称及其形状：

for name, para in lstm_layer.named_parameters():
    print(name, para.shape)

输出结果如下：

weight_ih_l0 torch.Size([20, 4])  # [4*hidden_size, input_size]
weight_hh_l0 torch.Size([20, 5])  # [4*hidden_size, hidden_size]
bias_ih_l0 torch.Size([20])  # [4*hidden_size]
bias_hh_l0 torch.Size([20])  # [4*hidden_size]

手写 lstm_forward 函数

手写一个lstm_forward函数，实现LSTM的计算原理。官网上的计算公式，如下：
i t = σ ( W i i x t + b i i + W h i h t − 1 + b h i ) f t = σ ( W i f x t + b i f + W h f h t − 1 + b h f ) g t = tanh ( W i g x t + b i g + W h g h t − 1 + b h g ) o t = σ ( W i o x t + b i o + W h o h t − 1 + b h o ) c t = f t ⊙ c t + i t ⊙ g t h t = o t ⊙ tanh ( c t ) \begin{align} &i_t = \sigma(W_{ii}x_t + b_{ii} + W_{hi}h_{t-1} + b_{hi}) \\ &f_t = \sigma(W_{if}x_t + b_{if} + W_{hf}h_{t-1} + b_{hf}) \\ &g_t = \textup{tanh}(W_{ig}x_t + b_{ig} + W_{hg}h_{t-1} + b_{hg}) \\ &o_t = \sigma(W_{io}x_t + b_{io} + W_{ho}h_{t-1} + b_{ho}) \\ &c_t = f_t \odot c_t + i_t \odot g_t \\ &h_t = o_t \odot \textup{tanh}(c_t) \end{align} ​it​=σ(Wii​xt​+bii​+Whi​ht−1​+bhi​)ft​=σ(Wif​xt​+bif​+Whf​ht−1​+bhf​)gt​=tanh(Wig​xt​+big​+Whg​ht−1​+bhg​)ot​=σ(Wio​xt​+bio​+Who​ht−1​+bho​)ct​=ft​⊙ct​+it​⊙gt​ht​=ot​⊙tanh(ct​)​​
这里先将lstm_forward函数中的每个参数的维度写出来：

def lstm_forward(input, initial_states, w_ih, w_hh, b_ih, b_hh):
    h_0, c_0 = initial_states  # 初始状态  [b_size, hidden_size]
    b_size, seq_len, input_size = input.shape
    h_size = h_0.shape[-1]

    h_prev, c_prev = h_0, c_0
    # 需要将权重w在batch_size维进行扩维并复制，才能和x与h进行相乘
    w_ih_batch = w_ih.unsqueeze(0).tile(b_size, 1, 1)  # [4*hidden_size, in_size]->[b_size, ,]
    w_hh_batch = w_hh.unsqueeze(0).tile(b_size, 1, 1)  # [4*hidden_size, hidden_size]->[b_size, ,]

    output_size = h_size
    output = torch.zeros(b_size, seq_len, output_size)  # 初始化一个输出序列
    for t in range(seq_len):
        x = input[:, t, :]  # 当前时刻的输入向量 [b,in_size]->[b,in_size,1]
        w_times_x = torch.bmm(w_ih_batch, x.unsqueeze(-1)).squeeze(-1)   # bmm:含有批量大小的矩阵相乘
        # [b, 4*hidden_size, 1]->[b, 4*hidden_size]
        # 这一步就是计算了 Wii*xt|Wif*xt|Wig*xt|Wio*xt
        w_times_h_prev = torch.bmm(w_hh_batch, h_prev.unsqueeze(-1)).squeeze(-1)
        # [b, 4*hidden_size, hidden_size]*[b, hidden_size, 1]->[b,4*hidden_size, 1]->[b, 4*hidden_size]
        # 这一步就是计算了 Whi*ht-1|Whf*ht-1|Whg*ht-1|Who*ht-1

        # 分别计算输入门(i)、遗忘门(f)、cell门(g)、输出门(o)  维度均为 [b, h_size]
        i_t = torch.sigmoid(w_times_x[:, :h_size] + w_times_h_prev[:, :h_size] + b_ih[:h_size] + b_hh[:h_size])  # 取前四分之一
        f_t = torch.sigmoid(w_times_x[:, h_size:2*h_size] + w_times_h_prev[:, h_size:2*h_size]
                            + b_ih[h_size:2*h_size] + b_hh[h_size:2*h_size])
        g_t = torch.tanh(w_times_x[:, 2*h_size:3*h_size] + w_times_h_prev[:, 2*h_size:3*h_size]
                         + b_ih[2*h_size:3*h_size] + b_hh[2*h_size:3*h_size])
        o_t = torch.sigmoid(w_times_x[:, 3*h_size:] + w_times_h_prev[:, 3*h_size:]
                            + b_ih[3*h_size:] + b_hh[3*h_size:])
        c_prev = f_t * c_prev + i_t * g_t
        h_prev = o_t * torch.tanh(c_prev)

        output[:, t, :] = h_prev

    return output, (h_prev.unsqueeze(0), c_prev.unsqueeze(0))  # 官方是三维，在第0维扩一维

验证一下 lstm_forward 的准确性：

# 这里使用 lstm_layer 中的参数
# 加了me表示自己手写的
output_me, (h_n_me, c_n_me) = lstm_forward(input, (h_0, c_0), lstm_layer.weight_ih_l0,
                                           lstm_layer.weight_hh_l0, lstm_layer.bias_ih_l0, lstm_layer.bias_hh_l0)

打印一下，看两个的计算结果是否相同：

print("PyTorch API output:")
print(output)  # [2,3,5] [b, seq_len, hidden_size]
print(h_n)  # [1,2,5] [num_layers, b, hidden_size]
print(c_n)  # [1,2,5] [num_layers, b, hidden_size]
print("\nlstm_forward function output:")
print(output_me)  # [2,3,5] [b, seq_len, hidden_size]
print(h_n_me)  # [1,2,5] [num_layers, b, hidden_size]
print(c_n_me)

结果如下，完全一致，说明手写的是对的：

PyTorch API output:
tensor([[[ 0.1671,  0.2493,  0.2603, -0.1448, -0.1951],
         [-0.0680,  0.0478,  0.0218,  0.0735, -0.0604],
         [ 0.0144,  0.0507, -0.0556, -0.2600,  0.1234]],

        [[ 0.4561, -0.0015, -0.0776, -0.0644, -0.5319],
         [ 0.1667,  0.0111,  0.0114, -0.1227, -0.2369],
         [-0.0220,  0.0637, -0.2353,  0.0404, -0.1309]]],
       grad_fn=<TransposeBackward0>)
tensor([[[ 0.0144,  0.0507, -0.0556, -0.2600,  0.1234],
         [-0.0220,  0.0637, -0.2353,  0.0404, -0.1309]]],
       grad_fn=<StackBackward0>)
tensor([[[ 0.0223,  0.1574, -0.1572, -0.4663,  0.2110],
         [-0.0382,  0.6440, -0.4334,  0.0779, -0.3198]]],
       grad_fn=<StackBackward0>)

lstm_forward function output:
tensor([[[ 0.1671,  0.2493,  0.2603, -0.1448, -0.1951],
         [-0.0680,  0.0478,  0.0218,  0.0735, -0.0604],
         [ 0.0144,  0.0507, -0.0556, -0.2600,  0.1234]],

        [[ 0.4561, -0.0015, -0.0776, -0.0644, -0.5319],
         [ 0.1667,  0.0111,  0.0114, -0.1227, -0.2369],
         [-0.0220,  0.0637, -0.2353,  0.0404, -0.1309]]], grad_fn=<CopySlices>)
tensor([[[ 0.0144,  0.0507, -0.0556, -0.2600,  0.1234],
         [-0.0220,  0.0637, -0.2353,  0.0404, -0.1309]]],
       grad_fn=<UnsqueezeBackward0>)
tensor([[[ 0.0223,  0.1574, -0.1572, -0.4663,  0.2110],
         [-0.0382,  0.6440, -0.4334,  0.0779, -0.3198]]],
       grad_fn=<UnsqueezeBackward0>)

LSTMP

# 定义一些常量
batch_size, seq_len, input_size, h_size = 2, 3, 4, 5
proj_size = 3  # 要比hidden_size小

input = torch.randn(batch_size, seq_len, input_size)
c_0 = torch.randn(batch_size, h_size)
h_0 = torch.randn(batch_size, proj_size)  # 注意这里从原来的 h_size 换成了 proj_size

# 调用官方 LSTM API
lstm_layer = nn.LSTM(input_size, h_size, batch_first=True, proj_size=proj_size)  
output, (h_n, c_n) = lstm_layer(input, (h_0.unsqueeze(0), c_0.unsqueeze(0)))

打印一下返回的结果的形状：

print(output.shape)  # [2,3,3] [b, seq_len, proj_size]
print(h_n.shape)  # [1,2,3] [num_layers, b, proj_size]
print(c_n.shape)  # [1,2,5] [num_layers, b, hidden_size]

这里输出一下lstm_layer中的参数名称及其形状：

for name, para in lstm_layer.named_parameters():
    print(name, para.shape)

输出结果如下输出结果如下：

weight_ih_l0 torch.Size([20, 4])  # [4*hidden_size, input_size]
weight_hh_l0 torch.Size([20, 3])  # [4*hidden_size, proj_size]
bias_ih_l0 torch.Size([20])
bias_hh_l0 torch.Size([20])
weight_hr_l0 torch.Size([3, 5])  # 这个参数就是对 hidden_state 进行压缩的 [hidden_size, proj_size]

修改 lstm_forward 函数

修改lstm_forward函数，从而能够实现LSTMP：

def lstm_forward(input, initial_states, w_ih, w_hh, b_ih, b_hh, w_hr=None):
    h_0, c_0 = initial_states  # 初始状态  [b, proj_size][b, hidden_size]
    b_size, seq_len, input_size = input.shape
    h_size = c_0.shape[-1]

    h_prev, c_prev = h_0, c_0
    # 需要将权重w在batch_size维进行扩维并复制，才能和x与h进行相乘
    w_ih_batch = w_ih.unsqueeze(0).tile(b_size, 1, 1)  # [4*hidden_size, in_size]->[b_size, ,]
    w_hh_batch = w_hh.unsqueeze(0).tile(b_size, 1, 1)  # [4*hidden_size, hidden_size]->[b_size, ,]


    if w_hr is not None:
        proj_size = w_hr.shape[0]
        output_size = proj_size
        w_hr_batch = w_hr.unsqueeze(0).tile(b_size, 1, 1)  # [proj_size, hidden_size]->[b_size, ,]
    else:
        output_size = h_size

    output = torch.zeros(b_size, seq_len, output_size)  # 初始化一个输出序列
    for t in range(seq_len):
        x = input[:, t, :]  # 当前时刻的输入向量 [b,in_size]->[b,in_size,1]
        w_times_x = torch.bmm(w_ih_batch, x.unsqueeze(-1)).squeeze(-1)   # bmm:含有批量大小的矩阵相乘
        # [b, 4*hidden_size, 1]->[b, 4*hidden_size]
        # 这一步就是计算了 Wii*xt|Wif*xt|Wig*xt|Wio*xt
        w_times_h_prev = torch.bmm(w_hh_batch, h_prev.unsqueeze(-1)).squeeze(-1)
        # [b, 4*hidden_size, hidden_size]*[b, hidden_size, 1]->[b,4*hidden_size, 1]->[b, 4*hidden_size]
        # 这一步就是计算了 Whi*ht-1|Whf*ht-1|Whg*ht-1|Who*ht-1

        # 分别计算输入门(i)、遗忘门(f)、cell门(g)、输出门(o)  维度均为 [b, h_size]
        i_t = torch.sigmoid(w_times_x[:, :h_size] + w_times_h_prev[:, :h_size] + b_ih[:h_size] + b_hh[:h_size])  # 取前四分之一
        f_t = torch.sigmoid(w_times_x[:, h_size:2*h_size] + w_times_h_prev[:, h_size:2*h_size]
                            + b_ih[h_size:2*h_size] + b_hh[h_size:2*h_size])
        g_t = torch.tanh(w_times_x[:, 2*h_size:3*h_size] + w_times_h_prev[:, 2*h_size:3*h_size]
                         + b_ih[2*h_size:3*h_size] + b_hh[2*h_size:3*h_size])
        o_t = torch.sigmoid(w_times_x[:, 3*h_size:] + w_times_h_prev[:, 3*h_size:]
                            + b_ih[3*h_size:] + b_hh[3*h_size:])
        c_prev = f_t * c_prev + i_t * g_t
        h_prev = o_t * torch.tanh(c_prev)  # [b_size, h_size]

        if w_hr is not None:  # 对 h_prev 进行压缩，做projection
            h_prev = torch.bmm(w_hr_batch, h_prev.unsqueeze(-1))  # [b,proj_size,hidden_size]*[b,h_size,1]=[b,proj_size,1]
            h_prev = h_prev.squeeze(-1)  # [b, proj_size]

        output[:, t, :] = h_prev

    return output, (h_prev.unsqueeze(0), c_prev.unsqueeze(0))  # 官方是三维，在第0维扩一维

验证一下 lstm_forward 的准确性：

output_me, (h_n_me, c_n_me) = lstm_forward(input, (h_0, c_0), lstm_layer.weight_ih_l0, lstm_layer.weight_hh_l0,
                                           lstm_layer.bias_ih_l0, lstm_layer.bias_hh_l0, lstm_layer.weight_hr_l0)

print("PyTorch API output:")
print(output)  # [2,3,3] [b, seq_len, proj_size]
print(h_n)  # [1,2,3] [num_layers, b, proj_size]
print(c_n)  # [1,2,5] [num_layers, b, hidden_size]
print("\nlstm_forward function output:")
print(output_me)  # [2,3,3] [b, seq_len, proj_size]
print(h_n_me)  # [1,2,3] [num_layers, b, proj_size]
print(c_n_me)  # [1,2,5] [num_layers, b, hidden_size]

输出的结果如下，完全一致，说明手写的是对的：

PyTorch API output:
tensor([[[ 0.0392, -0.3149, -0.1264],
         [ 0.0141, -0.2619, -0.0760],
         [ 0.0306, -0.2166,  0.0915]],

        [[-0.0777, -0.1205, -0.0555],
         [-0.0646, -0.0926,  0.0391],
         [-0.0456, -0.0576,  0.1849]]], grad_fn=<TransposeBackward0>)
tensor([[[ 0.0306, -0.2166,  0.0915],
         [-0.0456, -0.0576,  0.1849]]], grad_fn=<StackBackward0>)
tensor([[[ 1.9913, -0.2683, -0.1221,  0.1751, -0.6072],
         [-0.2383, -0.2253, -0.0385, -0.8820, -0.1794]]],
       grad_fn=<StackBackward0>)

lstm_forward function output:
tensor([[[ 0.0392, -0.3149, -0.1264],
         [ 0.0141, -0.2619, -0.0760],
         [ 0.0306, -0.2166,  0.0915]],

        [[-0.0777, -0.1205, -0.0555],
         [-0.0646, -0.0926,  0.0391],
         [-0.0456, -0.0576,  0.1849]]], grad_fn=<CopySlices>)
tensor([[[ 0.0306, -0.2166,  0.0915],
         [-0.0456, -0.0576,  0.1849]]], grad_fn=<UnsqueezeBackward0>)
tensor([[[ 1.9913, -0.2683, -0.1221,  0.1751, -0.6072],
         [-0.2383, -0.2253, -0.0385, -0.8820, -0.1794]]],
       grad_fn=<UnsqueezeBackward0>)
研2菜鸟
关注
lstm 三 模型压缩lstmp
qq_44944990的博客
04-23 526
lstm 三 模型压缩lstmp
30 - LSTM,LSTMP手撸代码
scar2016的博客
04-19 807
文章目录1. 原理2. 代码3. 小结 1. 原理 2. 代码 import torch from torch import nn bs,T,i_size,h_size = 2,3,4,5 h0 = torch.randn((bs,h_size)) c0 = torch.randn((bs,h_size)) init_state = (h0,c0) input = torch.randn((bs,T,i_size)) lstm_layer = nn.LSTM(input_size=i_size,hid
PyTorch学习笔记:LSTM和LSTMP的原理及其手写复现
qq_73462282的博客
08-14 1429
首先再开始之前,我想问一下在座的各位实现过LSTM吗,不会的扣1,会的小伙伴们扣脚指头,嘿嘿,开玩笑的,我也不知道,那么接下来我们一起学习如何写吧!30、PyTorch LSTM和LSTMP的原理及其手写复现_哔哩哔哩_bilibili循环神经网络(超详细|附代码训练)_后来后来啊的博客-CSDN博客长短时记忆网络(LSTM)(超详细 |附训练代码)_后来后来啊的博客-CSDN博客递归神经网络(超详细|附训练代码)_后来后来啊的博客-CSDN博客。
（pytorch进阶之路五）RNN/LSTM/LSTMP/GRU
qq_19841133的博客
07-10 616
写在前面：RNN老生常谈也太简单可以跳过了，只是留一个档…现在主要用的是RNN的变体，GRU或者LSTM模型有单向、双向、多个单向双向叠加，nn RNN API中num_layers就是设置堆叠多少层，如果设置双向，那么输出大小是hidden size * 2所谓的循环神经网络，在对一个序列进行建模的时候，再算每一个表征的时候，考虑上过去的历史信息，历史信息就通过记忆单元保存，每个时刻都存记忆单元中去获取历史信息，辅助当前时刻去做一个预测。双向有两条链，FL和BL，FL输出与当前输入和过去记忆单元有关，BL
PyTorch LSTM和LSTMP的原理及其手写复现
zik的博客
05-20 2628
关于LSTM的原理以及公式其实在这篇博客一步一步详解LSTM网络【从RNN到LSTM到GRU等，直至attention】讲的非常清晰明了了。这里就是写出LSTM的pytorch的实现，包括API和手写。在看代码之前有必要了解输入输出有哪些，以及他们的特性。将多层长短期记忆 (LSTM) RNN 应用于输入序列。
deep-thoughts:第21周的模块活动
03-22
在本周的"deep-thoughts"模块活动中，我们聚焦于JavaScript这一编程语言，它在现代Web开发中扮演着至关重要的角色。JavaScript是一种轻量级、解释型的编程语言，主要应用于客户端的网页交互，但随着Node.js的出现，...
【巴克莱-2024研报】Global_Macro_Thoughts_It_s_all_happening.pdf
最新发布
11-09
行业研究报告、行业调查报告、研报
【巴克莱-2024研报-】Global_Macro_Thoughts_Bull_in_China_s_shop.pdf
11-02
行业研究报告、行业调查报告、研报
【巴克莱-2024研报-】Global_Macro_Thoughts_What_s_not_to_like_.pdf
10-25
行业研究报告
The_Forgotten_Thoughts_Web站点：一个网站，展示Veer Surendra Sai工业大学的年轻和才华横溢的作家的思想和诗歌
02-15
【标题】中的"The_Forgotten_Thoughts_Web站点"是一个以展示Veer Surendra Sai工业大学学生作品为主的在线平台，特别关注年轻和有才华的作家。这个网站旨在成为他们发表思想、诗歌和其他创意作品的窗口，促进文学...
百度LSTM建模与CTC训练_贾磊
10-30
《LSTM and CTC training for speech recognition from Baidu》，百度语音技术部贾磊介绍百度语音识别技术的最新进展（2015.10.26）。
pytorch实现LSTM（附code）
ting_qifengl的博客
01-23 6万+
最近搞了一个NASA PCoE的IGBT加速老化数据，想基于pytorch框架写一个LSTM模型进行IGBT退化状态的预测，于是有了这篇文章。 注：LSTM的原理就不多讲了，网上一大堆，不懂的自己去百度，本文主要侧重代码实现。 一、数据集介绍 本数据集是NASA PCoE研究中心公布的IGBT加速老化数据集。数据集含有四种实验条件下的IGBT加速老化数据，以下是实验条件： （1）新设备的源测量单元（SMU data for new devices） 该文件中含有一组原始实验条件下的电气特性数据，分
LSTM模型
zakexu的专栏
09-17 3万+
（一）NN模型（neural network） 1.NN模型是复杂神经网络模型的基础计算单元，广泛使用于各种神经网络模型中，如下所示： 2.NN模型常见的激活函数主要有3种：sigmoid函数，tanh函数，以及ReLU（rectified linear unit）函数，分别如下： 3.NN模型若放在输出层，不同的任务使用不同的激活函数： （1）multi-class：使用
【NLP】LSTM理解（Pytorch实现）
myaijarvis notebook
05-03 2114
【参考：详解LSTM - 知乎】 手动实现 【参考：30、PyTorch LSTM和LSTMP的原理及其手写复现_哔哩哔哩_bilibili】 单层单向 【参考：30 - LSTM,LSTMP手撸代码_取个名字真难呐的博客-CSDN博客】 import torch from torch import nn torch.manual_seed(0) # 设置随机种子，随机函数生成的结果会相同 batch_size = 2 # 批次大小 seq_len = 3 # 输入序列长度 input_siz
LSTM 优化之路
JPing的专栏
07-11 2万+
本文首发于滴滴云公众号：https://mp.weixin.qq.com/s/H0AKuKn1XQDEa06jDm3Nug导读谈到神经网络，相信是当下比较火的一个词。它的发展不是一蹴而就，而是通过各代人的智慧，经过一次一次的优化，迭代才慢慢建立起当下的各种网络结构，从最简单的 MLP，到 CNN，RNN，再到增强网络，对抗网络。每一种网络结构的诞生，都是为了解决某一类特定场景的问题。本文中涉及的 ...
知乎--LSTM（挺全的）
战斗蜗牛的专栏
05-12 7万+
首页发现话题 登录 加入知乎 有哪些LSTM(Long Short Term Memory)和RNN(Recurrent)网络的教程？ 关注问题写回答 互联网 机器学习 深度学习（Deep
PLSTM的TensorFlow实现与解释
机器学习杂货铺1号店
04-09 2246
PLSTM的TensorFlow实现与解释 前言 * 我们在上篇文章《TensorFlow中的LSTM源码理解与二次开发》中已经提到了lstm cell在tensorflow中的实现。这篇博文主要介绍了如何在TensorFlow中通过修改lstm cell来定制自己的lstm网络，并且以 《NTU RGB+D: A Large Scale Dataset for 3D Human Acti...
Python中的__init__()和__call__()函数
热门推荐
正西风落叶下长安
04-20 10万+
在Python的class中有一些函数往往具有特殊的意义。__init__()和__call__()就是class很有用的两类特殊的函数。 __init__() 在Python中，__init__()函数的意义等同于类的构造器（同理，__del__()等同于类的析构函数）。因此，__init__()方法的作用是创建一个类的实例。 __call__() Python中的函数是一级对象...
[Pytorch]pytorch中的LSTM模型
心有猛虎 细嗅蔷薇
03-03 2万+
公式表示 Pytorch中LSTM的公式表示为： 定义 Pytorch中LSTM的定义如下： class torch.nn.LSTM(*args, **kwargs) 参数列表 输入数据格式： input(seq_len, batch, input_size) h0(num_layers * num_directions, batch, hidden_size) c...
算子融合 pytorch
08-23
- *1* *2* *3* [【deep_thoughts】16_PyTorch中进行卷积残差模块算子融合](https://blog.csdn.net/qq_45670134/article/details/129883225)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值