小白学Pytorch系列--Torch.nn API Padding Layers(4)

最新推荐文章于 2024-05-03 15:48:17 发布
最新推荐文章于 2024-05-03 15:48:17 发布
阅读量525 收藏 3
点赞数
分类专栏： PyTorch框架 文章标签： pytorch 深度学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42486623/article/details/129773287
版权

小白学Pytorch系列–Torch.nn API Padding Layers(4)

方法注释
nn.ReflectionPad1d使用输入边界的反射来填充输入张量。
nn.ReflectionPad2d使用输入边界的反射来填充输入张量。
nn.ReflectionPad3d使用输入边界的反射来填充输入张量。
nn.ReplicationPad1d使用输入边界的复制来填充输入张量。
nn.ReplicationPad2d使用输入边界的复制来填充输入张量。
nn.ReplicationPad3d使用输入边界的复制来填充输入张量。
nn.ZeroPad2d用零填充输入张量边界。
nn.ConstantPad1d用常值填充输入张量边界
nn.ConstantPad2d用常值填充输入张量边界。
nn.ConstantPad3d用常值填充输入张量边界。

nn.ReflectionPad1d


>>> m = nn.ReflectionPad1d(2)
>>> input = torch.arange(8, dtype=torch.float).reshape(1, 2, 4)
>>> input
tensor([[[0., 1., 2., 3.],
         [4., 5., 6., 7.]]])
>>> m(input)
tensor([[[2., 1., 0., 1., 2., 3., 2., 1.],
         [6., 5., 4., 5., 6., 7., 6., 5.]]])
>>> # using different paddings for different sides
>>> m = nn.ReflectionPad1d((3, 1))
>>> m(input)
tensor([[[3., 2., 1., 0., 1., 2., 3., 2.],
         [7., 6., 5., 4., 5., 6., 7., 6.]]])

nn.ReflectionPad2d

>>> m = nn.ReflectionPad2d(2)
>>> input = torch.arange(9, dtype=torch.float).reshape(1, 1, 3, 3)
>>> input
tensor([[[[0., 1., 2.],
          [3., 4., 5.],
          [6., 7., 8.]]]])
>>> m(input)
tensor([[[[8., 7., 6., 7., 8., 7., 6.],
          [5., 4., 3., 4., 5., 4., 3.],
          [2., 1., 0., 1., 2., 1., 0.],
          [5., 4., 3., 4., 5., 4., 3.],
          [8., 7., 6., 7., 8., 7., 6.],
          [5., 4., 3., 4., 5., 4., 3.],
          [2., 1., 0., 1., 2., 1., 0.]]]])
>>> # using different paddings for different sides
>>> m = nn.ReflectionPad2d((1, 1, 2, 0))
>>> m(input)
tensor([[[[7., 6., 7., 8., 7.],
          [4., 3., 4., 5., 4.],
          [1., 0., 1., 2., 1.],
          [4., 3., 4., 5., 4.],
          [7., 6., 7., 8., 7.]]]])

nn.ReflectionPad3d

>>> m = nn.ReflectionPad3d(1)
>>> input = torch.arange(8, dtype=torch.float).reshape(1, 1, 2, 2, 2)
>>> m(input)
tensor([[[[[7., 6., 7., 6.],
           [5., 4., 5., 4.],
           [7., 6., 7., 6.],
           [5., 4., 5., 4.]],
          [[3., 2., 3., 2.],
           [1., 0., 1., 0.],
           [3., 2., 3., 2.],
           [1., 0., 1., 0.]],
          [[7., 6., 7., 6.],
           [5., 4., 5., 4.],
           [7., 6., 7., 6.],
           [5., 4., 5., 4.]],
          [[3., 2., 3., 2.],
           [1., 0., 1., 0.],
           [3., 2., 3., 2.],
           [1., 0., 1., 0.]]]]])

nn.ReplicationPad1d


>>> m = nn.ReplicationPad1d(2)
>>> input = torch.arange(8, dtype=torch.float).reshape(1, 2, 4)
>>> input
tensor([[[0., 1., 2., 3.],
         [4., 5., 6., 7.]]])
>>> m(input)
tensor([[[0., 0., 0., 1., 2., 3., 3., 3.],
         [4., 4., 4., 5., 6., 7., 7., 7.]]])
>>> # using different paddings for different sides
>>> m = nn.ReplicationPad1d((3, 1))
>>> m(input)
tensor([[[0., 0., 0., 0., 1., 2., 3., 3.],
         [4., 4., 4., 4., 5., 6., 7., 7.]]])

nn.ReplicationPad2d

>>> m = nn.ReplicationPad2d(2)
>>> input = torch.arange(9, dtype=torch.float).reshape(1, 1, 3, 3)
>>> input
tensor([[[[0., 1., 2.],
          [3., 4., 5.],
          [6., 7., 8.]]]])
>>> m(input)
tensor([[[[0., 0., 0., 1., 2., 2., 2.],
          [0., 0., 0., 1., 2., 2., 2.],
          [0., 0., 0., 1., 2., 2., 2.],
          [3., 3., 3., 4., 5., 5., 5.],
          [6., 6., 6., 7., 8., 8., 8.],
          [6., 6., 6., 7., 8., 8., 8.],
          [6., 6., 6., 7., 8., 8., 8.]]]])
>>> # using different paddings for different sides
>>> m = nn.ReplicationPad2d((1, 1, 2, 0))
>>> m(input)
tensor([[[[0., 0., 1., 2., 2.],
          [0., 0., 1., 2., 2.],
          [0., 0., 1., 2., 2.],
          [3., 3., 4., 5., 5.],
          [6., 6., 7., 8., 8.]]]])

nn.ReplicationPad3d

>>> m = nn.ReplicationPad3d(3)
>>> input = torch.randn(16, 3, 8, 320, 480)
>>> output = m(input)
>>> # using different paddings for different sides
>>> m = nn.ReplicationPad3d((3, 3, 6, 6, 1, 1))
>>> output = m(input)

nn.ZeroPad2d

>>> m = nn.ZeroPad2d(2)
>>> input = torch.randn(1, 1, 3, 3)
>>> input
tensor([[[[-0.1678, -0.4418,  1.9466],
          [ 0.9604, -0.4219, -0.5241],
          [-0.9162, -0.5436, -0.6446]]]])
>>> m(input)
tensor([[[[ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000],
          [ 0.0000,  0.0000, -0.1678, -0.4418,  1.9466,  0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.9604, -0.4219, -0.5241,  0.0000,  0.0000],
          [ 0.0000,  0.0000, -0.9162, -0.5436, -0.6446,  0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000]]]])
>>> # using different paddings for different sides
>>> m = nn.ZeroPad2d((1, 1, 2, 0))
>>> m(input)
tensor([[[[ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000],
          [ 0.0000, -0.1678, -0.4418,  1.9466,  0.0000],
          [ 0.0000,  0.9604, -0.4219, -0.5241,  0.0000],
          [ 0.0000, -0.9162, -0.5436, -0.6446,  0.0000]]]])

nn.ConstantPad1d

>>> m = nn.ConstantPad1d(2, 3.5)
>>> input = torch.randn(1, 2, 4)
>>> input
tensor([[[-1.0491, -0.7152, -0.0749,  0.8530],
         [-1.3287,  1.8966,  0.1466, -0.2771]]])
>>> m(input)
tensor([[[ 3.5000,  3.5000, -1.0491, -0.7152, -0.0749,  0.8530,  3.5000,
           3.5000],
         [ 3.5000,  3.5000, -1.3287,  1.8966,  0.1466, -0.2771,  3.5000,
           3.5000]]])
>>> m = nn.ConstantPad1d(2, 3.5)
>>> input = torch.randn(1, 2, 3)
>>> input
tensor([[[ 1.6616,  1.4523, -1.1255],
         [-3.6372,  0.1182, -1.8652]]])
>>> m(input)
tensor([[[ 3.5000,  3.5000,  1.6616,  1.4523, -1.1255,  3.5000,  3.5000],
         [ 3.5000,  3.5000, -3.6372,  0.1182, -1.8652,  3.5000,  3.5000]]])
>>> # using different paddings for different sides
>>> m = nn.ConstantPad1d((3, 1), 3.5)
>>> m(input)
tensor([[[ 3.5000,  3.5000,  3.5000,  1.6616,  1.4523, -1.1255,  3.5000],
         [ 3.5000,  3.5000,  3.5000, -3.6372,  0.1182, -1.8652,  3.5000]]])

nn.ConstantPad3d

>>> m = nn.ConstantPad3d(3, 3.5)
>>> input = torch.randn(16, 3, 10, 20, 30)
>>> output = m(input)
>>> # using different paddings for different sides
>>> m = nn.ConstantPad3d((3, 3, 6, 6, 0, 1), 3.5)
>>> output = m(input)
发呆的比目鱼
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
池化和反池化、卷积层的理解layers.Conv2D,可视化卷积padding
moonlightpeng的博客
11-02 453
关于池化和反池化的理解 - 程序员大本营
池化层和Padding简介
qq_38312365的博客
08-07 2542
1、池化层的理解 pooling池化的作用则体现在降采样：保留显著特征、降低特征维度，增大kernel的感受野。另外一点值得注意：pooling也可以提供一些旋转不变性。 池化层可对提取到的特征信息进行降维，一方面使特征图变小，简化网络计算复杂度并在一定程度上避免过拟合的出现；一方面进行特征压缩，提取主要特征。   最大池采样在计算机视觉中的价值体现在两个方面：   (1)、它减小了来自上层隐藏层的计算复杂度；   (2)、这些池化单元具有平移不变性，即使图像有小的位移，提取到的特征依然会保持不变。由于增强
pytorch笔记：ReplicationPad1d
最新发布
qq_40206371的博客
05-03 413
可以是一个整数或一个元组。，那么填充后的序列将是。被复制了两次，右边的。
PyTorch基础知识
K2SO4的博客
02-17 215
PyTorch基础知识学习笔记
5-2 Pytorch中的模型层layers
hxhabcd123的博客
09-17 455
pytorch中的模型层
PyTorch里面的torch.nn.Parameter()详解
09-18
在PyTorch中，`torch.nn.Parameter()`是一个非常关键的类，它用于创建可学习的参数。这些参数通常是神经网络模型中的权重和偏置，它们在训练过程中会被优化算法更新以最小化损失函数。本文将深入探讨`torch.nn....
Python库 | pytorch-lightning-0.8.1.tar.gz
04-14
资源分类：Python库 所属语言：Python 资源全名：pytorch-lightning-0.8.1.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
Python库 | alexnet_pytorch-0.1.5-py2.py3-none-any.whl
05-27
资源分类：Python库 所属语言：Python 使用前提：需要解压 资源全名：alexnet_pytorch-0.1.5-py2.py3-none-any.whl 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
Python库 | wgangp_pytorch-0.1.2-py2.py3-none-any.whl
04-27
资源分类：Python库 所属语言：Python 使用前提：需要解压 资源全名：wgangp_pytorch-0.1.2-py2.py3-none-any.whl 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
pytorch1.0中torch.nn.Conv2d用法详解
09-18
在PyTorch 1.0中，`torch.nn.Conv2d`是用于执行二维卷积操作的核心模块。它是深度学习模型，尤其是计算机视觉任务中不可或缺的一部分。本文将深入讲解`nn.Conv2d`的主要功能、参数及其用法。 首先，`nn.Conv2d`的...
简单易懂掌握 PyTorch 的填充技术：深入理解反射、复制、零值和常数填充
CDBmax的博客
01-03 1903
本文详细介绍了 PyTorch 框架中的多个填充类，用于在深度学习模型中处理不同维度的数据。这些填充方法对于保持卷积神经网络中数据的空间维度至关重要，尤其在图像处理、音频信号处理等领域中有广泛应用。每种填充方法都有其特定的应用场景和注意事项，如数据类型一致性、边界效应的考虑等。文章通过具体的代码示例展示了如何在 PyTorch 中使用这些填充类，并解释了它们的工作原理。
torch.nn.ReflectionPad2d()的用法简介
LionZYT的博客
09-08 1万+
最近在看Pix2PixHD的源码时，发现里面有几处用了nn.ReflectionPad2d()这个函数，查阅了官方文档和网上的资料后，终于弄明白了这个函数的用处。 函数用途：对输入图像以最外围像素为对称轴，做四周的轴对称镜像填充。 填充顺序：左->右->上->下 对于一个4维的Tensor，当只指定一个padding参数时，则表示对四周采用相同的填充行数。 # 对四周都填充3行 nn.ReflectionPad2d(3) 以下为计算实例： >>...
unknown builtin op: aten::Tensor
jacke121的专栏
06-26 3180
unknown builtin op: aten::Tensor @torch.jit.script_method def forward(self, x, targets=None): 错误代码： detections=torch.Tensor()#.cuda()
Pytorch（3）：Layers
My Blogs
03-18 1309
文章目录Convolution layers 卷积层nn.Conv2d 卷积nn.ConvTranspose 转置卷积Pooling Layer 池化层nn.MaxPool2dnn.AvgPool2dnn.MaxUnpool2dLinear Layer 线性层nn.Linear[Activation Layer 激活函数层](https://pytorch.org/docs/stable/nn.h...
opencv学习——padding扩充边界
ei1990的博客
10-26 1万+
import cv2 import numpy as np import matplotlib.pylab as plt import scipy.misc as misc ''' src - input image top, bottom, left, right - border width in number of pixels in corresponding directions bord
keras.layers.Conv2D中的padding解析
qq_40527427的博客
05-14 2779
池化层：“SAME”表示超过边界用0填充，使得输出和输入保持相同大小，“VALID”表示不超过边界，通常会丢失一些信息。 If padding == "SAME": output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides[i]) If padding == "VALID": output_spatial_shape[i] ...
tensorflow中tf.layers.conv2d-Padding
ningning52107的博客
05-07 2478
https://tensorflow.google.cn/api_docs/python/tf/layers/conv2d?hl=zh-cn tensorflow手册链接 tf.layers.conv2d( inputs, filters, kernel_size, strides=(1, 1), padding='valid', data_fo...
详解卷积神经网络(CNN)
热门推荐
qq_25762497的博客
04-04 25万+
卷积神经网络（Convolutional Neural Network, CNN）是一种前馈神经网络，它的人工神经元可以响应一部分覆盖范围内的周围单元，对于大型图像处理有出色表现。
torch.nn.Module 转换为TensorFlow
06-07
将一个 PyTorch 的 nn.Module 转换为 TensorFlow 的代码需要进行一定的手动编写。由于两个框架的底层实现方式不同，因此不能直接转换。以下是一个简单的例子，将一个简单的 PyTorch 模型转换为 TensorFlow 的代码： ```python import tensorflow as tf import torch # 定义 PyTorch 模型 class PyTorchModel(torch.nn.Module): def __init__(self): super(PyTorchModel, self).__init__() self.conv = torch.nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1) self.relu = torch.nn.ReLU() self.pool = torch.nn.MaxPool2d(kernel_size=2, stride=2) self.fc = torch.nn.Linear(32*8*8, 10) def forward(self, x): x = self.conv(x) x = self.relu(x) x = self.pool(x) x = x.view(-1, 32*8*8) x = self.fc(x) return x # 加载 PyTorch 模型 model = PyTorchModel() model.load_state_dict(torch.load('model.pt')) # 转换为 TensorFlow 模型 tf_model = tf.keras.Sequential([ tf.keras.layers.Conv2D(32, kernel_size=3, strides=1, padding='same', input_shape=(32, 32, 3)), tf.keras.layers.ReLU(), tf.keras.layers.MaxPool2D(pool_size=2, strides=2), tf.keras.layers.Flatten(), tf.keras.layers.Dense(10) ]) # 将 PyTorch 模型的参数赋值给 TensorFlow 模型 for i, layer in enumerate(tf_model.layers): if hasattr(layer, 'kernel_initializer') and hasattr(layer.kernel_initializer, 'assign'): layer.kernel_initializer.assign(torch.tensor(model.state_dict()[f'fc.weight'].numpy())) if hasattr(layer, 'bias_initializer') and hasattr(layer.bias_initializer, 'assign'): layer.bias_initializer.assign(torch.tensor(model.state_dict()[f'fc.bias'].numpy())) # 进行预测 x = tf.random.normal((1, 32, 32, 3)) tf_output = tf_model(x) print(tf_output) ``` 需要注意的是，这只是一个简单的例子，实际转换可能会更复杂，需要根据具体的模型进行编写。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

发呆的比目鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值