学习pytorch中归一化transforms.Normalize

最新推荐文章于 2024-04-30 11:17:49 发布
最新推荐文章于 2024-04-30 11:17:49 发布
阅读量1.1w 收藏 113
点赞数 19
分类专栏： 语义分割 文章标签： 计算机视觉 pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36998053/article/details/122319485
版权

torchvison:计算机视觉工具包

包含

  1. torchvison.transforms(常用的图像预处理方法)；
  2. torchvision.datasets(常用数据集的dataset实现，MNIST,CIFAR-10,ImageNet等)；
  3. torchvison.model(常用的模型预训练，AlexNet,VGG,ResNet,GoogleNet等)。

torchvision.transforms

常用的数据预处理方法，提升泛化能力。包括：数据中心化、数据标准化、缩放、裁剪、旋转、填充、噪声添加、灰度变换、线性变换、放射变换、亮度、饱和度和对比度变换等

数据标准化——transforms.Normalize

功能：逐channel的对图像进行标准化（均值变为0，标准差变为1），可以加快模型的收敛

  • output=(input-mean)/std
  • mean:各通道的均值
  • std:各通道的标准差
  • inplace:是否原地操作

问题：究竟是什么意思？(0.5,0.5,0.5),(0.5,0.5,0.5)又是怎么来的呢？

transform.ToTensor(),
transform.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))

1、transform.ToTensor() 

原始的PILImage格式或者numpy.array格式的数据格式化为可被pytorch快速处理的张量类型

  • 是将输入的数据shape W，H，C---> C，W，H。   从opencv读到的图片是通道数在第三个维度，现在经过ToTensor操作cv2图片变成了torch image类型，也就是通道在第一个维度。

  • 将所有数除以255，将数据归一化到[0,1]

  • 示例：

import torch
import numpy as np
from torchvision import transforms
import cv2
# 自定义图片数组，数据类型一定要转为‘uint8’,不然transforms.ToTensor()不会归一化
data = np.array([
                [[1,1,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1]],
                [[2,2,2],[2,2,2],[2,2,2],[2,2,2],[2,2,2]],
                [[3,3,3],[3,3,3],[3,3,3],[3,3,3],[3,3,3]],
                [[4,4,4],[4,4,4],[4,4,4],[4,4,4],[4,4,4]],
                [[5,5,5],[5,5,5],[5,5,5],[5,5,5],[5,5,5]]
        ],dtype='uint8')
print(data)
print(data.shape)   #（5，5，3）
data = transforms.ToTensor()(data)
print(data)
print(data.shape)	#（3，5，5）

输出：
tensor([[[0.0039, 0.0039, 0.0039, 0.0039, 0.0039],
         [0.0078, 0.0078, 0.0078, 0.0078, 0.0078],
         [0.0118, 0.0118, 0.0118, 0.0118, 0.0118],
         [0.0157, 0.0157, 0.0157, 0.0157, 0.0157],
         [0.0196, 0.0196, 0.0196, 0.0196, 0.0196]],

        [[0.0039, 0.0039, 0.0039, 0.0039, 0.0039],
         [0.0078, 0.0078, 0.0078, 0.0078, 0.0078],
         [0.0118, 0.0118, 0.0118, 0.0118, 0.0118],
         [0.0157, 0.0157, 0.0157, 0.0157, 0.0157],
         [0.0196, 0.0196, 0.0196, 0.0196, 0.0196]],

        [[0.0039, 0.0039, 0.0039, 0.0039, 0.0039],
         [0.0078, 0.0078, 0.0078, 0.0078, 0.0078],
         [0.0118, 0.0118, 0.0118, 0.0118, 0.0118],
         [0.0157, 0.0157, 0.0157, 0.0157, 0.0157],
         [0.0196, 0.0196, 0.0196, 0.0196, 0.0196]]])

2、 transforms.Normalize()

x = (x - mean) / std

即同一纬度的数据减去这一维度的平均值，再除以标准差，将归一化后的数据变换到[-1,1]之间。可真是这样吗？？

  • 求解mean和std

我们需要求得一批数据的mean和std，代码如下：

import torch
import numpy as np
from torchvision import transforms

# 这里以上述创建的单数据为例子
data = np.array([
                [[1,1,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1]],
                [[2,2,2],[2,2,2],[2,2,2],[2,2,2],[2,2,2]],
                [[3,3,3],[3,3,3],[3,3,3],[3,3,3],[3,3,3]],
                [[4,4,4],[4,4,4],[4,4,4],[4,4,4],[4,4,4]],
                [[5,5,5],[5,5,5],[5,5,5],[5,5,5],[5,5,5]]
        ],dtype='uint8')

#将数据转为C,W,H，并归一化到[0，1]
data = transforms.ToTensor()(data)
# 需要对数据进行扩维，增加batch维度
data = torch.unsqueeze(data,0)

nb_samples = 0.
#创建3维的空列表
channel_mean = torch.zeros(3)   #tensor([0., 0., 0.])
channel_std = torch.zeros(3)    #tensor([0., 0., 0.])

print(data.shape)  # torch.Size([1,3,5,5])
# tensor([[[[0.0039, 0.0039, 0.0039, 0.0039, 0.0039],
          [0.0078, 0.0078, 0.0078, 0.0078, 0.0078],
          [0.0118, 0.0118, 0.0118, 0.0118, 0.0118],
          [0.0157, 0.0157, 0.0157, 0.0157, 0.0157],
          [0.0196, 0.0196, 0.0196, 0.0196, 0.0196]],
         [[0.0039, 0.0039, 0.0039, 0.0039, 0.0039],
          [0.0078, 0.0078, 0.0078, 0.0078, 0.0078],
          [0.0118, 0.0118, 0.0118, 0.0118, 0.0118],
          [0.0157, 0.0157, 0.0157, 0.0157, 0.0157],
          [0.0196, 0.0196, 0.0196, 0.0196, 0.0196]],
         [[0.0039, 0.0039, 0.0039, 0.0039, 0.0039],
          [0.0078, 0.0078, 0.0078, 0.0078, 0.0078],
          [0.0118, 0.0118, 0.0118, 0.0118, 0.0118],
          [0.0157, 0.0157, 0.0157, 0.0157, 0.0157],
          [0.0196, 0.0196, 0.0196, 0.0196, 0.0196]]]])


N, C, H, W = data.shape[:4]   #N=1  C=3  H=5   W=5
data = data.view(N, C, -1)    #将w,h维度的数据展平，为batch，channel,data,然后对三个维度上的数分别求和和标准差
 
print(data.shape)   #torch.Size([1, 3, 25])
#tensor([[[0.0039, 0.0039, 0.0039, 0.0039, 0.0039, 0.0078, 0.0078, 0.0078,
          0.0078, 0.0078, 0.0118, 0.0118, 0.0118, 0.0118, 0.0118, 0.0157,
          0.0157, 0.0157, 0.0157, 0.0157, 0.0196, 0.0196, 0.0196, 0.0196,
          0.0196],
         [0.0039, 0.0039, 0.0039, 0.0039, 0.0039, 0.0078, 0.0078, 0.0078,
          0.0078, 0.0078, 0.0118, 0.0118, 0.0118, 0.0118, 0.0118, 0.0157,
          0.0157, 0.0157, 0.0157, 0.0157, 0.0196, 0.0196, 0.0196, 0.0196,
          0.0196],
         [0.0039, 0.0039, 0.0039, 0.0039, 0.0039, 0.0078, 0.0078, 0.0078,
          0.0078, 0.0078, 0.0118, 0.0118, 0.0118, 0.0118, 0.0118, 0.0157,
          0.0157, 0.0157, 0.0157, 0.0157, 0.0196, 0.0196, 0.0196, 0.0196,
          0.0196]]])


#展平后，w,h属于第二维度，对他们求平均，sum(0)为将同一纬度的数据累加
channel_mean += data.mean(2).sum(0)  #tensor([0.0118, 0.0118, 0.0118])

#展平后，w,h属于第二维度，对他们求标准差，sum(0)为将同一纬度的数据累加
channel_std += data.std(2).sum(0)   #tensor([0.0057, 0.0057, 0.0057])

#获取所有batch的数据，这里为1
nb_samples += N

#获取同一batch的均值和标准差
channel_mean /= nb_samples
channel_std /= nb_samples

print(channel_mean, channel_std)   #tensor([0.0118, 0.0118, 0.0118]) tensor([0.0057, 0.0057, 0.0057])

以此便可求得均值和标准差。我们再带入公式：

x = (x - mean) / std
  • 自己实现：
data = np.array([
                [[1,1,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1]],
                [[2,2,2],[2,2,2],[2,2,2],[2,2,2],[2,2,2]],
                [[3,3,3],[3,3,3],[3,3,3],[3,3,3],[3,3,3]],
                [[4,4,4],[4,4,4],[4,4,4],[4,4,4],[4,4,4]],
                [[5,5,5],[5,5,5],[5,5,5],[5,5,5],[5,5,5]]
        ],dtype='uint8')
data = transforms.ToTensor()(data)
print(data)
#tensor([[[0.0039, 0.0039, 0.0039, 0.0039, 0.0039],
         [0.0078, 0.0078, 0.0078, 0.0078, 0.0078],
         [0.0118, 0.0118, 0.0118, 0.0118, 0.0118],
         [0.0157, 0.0157, 0.0157, 0.0157, 0.0157],
         [0.0196, 0.0196, 0.0196, 0.0196, 0.0196]],
        [[0.0039, 0.0039, 0.0039, 0.0039, 0.0039],
         [0.0078, 0.0078, 0.0078, 0.0078, 0.0078],
         [0.0118, 0.0118, 0.0118, 0.0118, 0.0118],
         [0.0157, 0.0157, 0.0157, 0.0157, 0.0157],
         [0.0196, 0.0196, 0.0196, 0.0196, 0.0196]],
        [[0.0039, 0.0039, 0.0039, 0.0039, 0.0039],
         [0.0078, 0.0078, 0.0078, 0.0078, 0.0078],
         [0.0118, 0.0118, 0.0118, 0.0118, 0.0118],
         [0.0157, 0.0157, 0.0157, 0.0157, 0.0157],
         [0.0196, 0.0196, 0.0196, 0.0196, 0.0196]]])

for i in range(3):
    data[i,:,:] = (data[i,:,:] - channel_mean[i]) / channel_std[i]
print(data)

输出：
tensor([[[-1.3856, -1.3856, -1.3856, -1.3856, -1.3856],
         [-0.6928, -0.6928, -0.6928, -0.6928, -0.6928],
         [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000],
         [ 0.6928,  0.6928,  0.6928,  0.6928,  0.6928],
         [ 1.3856,  1.3856,  1.3856,  1.3856,  1.3856]],

        [[-1.3856, -1.3856, -1.3856, -1.3856, -1.3856],
         [-0.6928, -0.6928, -0.6928, -0.6928, -0.6928],
         [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000],
         [ 0.6928,  0.6928,  0.6928,  0.6928,  0.6928],
         [ 1.3856,  1.3856,  1.3856,  1.3856,  1.3856]],

        [[-1.3856, -1.3856, -1.3856, -1.3856, -1.3856],
         [-0.6928, -0.6928, -0.6928, -0.6928, -0.6928],
         [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000],
         [ 0.6928,  0.6928,  0.6928,  0.6928,  0.6928],
         [ 1.3856,  1.3856,  1.3856,  1.3856,  1.3856]]])
  • 官方实现
data = np.array([
                [[1,1,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1]],
                [[2,2,2],[2,2,2],[2,2,2],[2,2,2],[2,2,2]],
                [[3,3,3],[3,3,3],[3,3,3],[3,3,3],[3,3,3]],
                [[4,4,4],[4,4,4],[4,4,4],[4,4,4],[4,4,4]],
                [[5,5,5],[5,5,5],[5,5,5],[5,5,5],[5,5,5]]
        ],dtype='uint8')
data = transforms.ToTensor()(data)
data = transforms.Normalize(channel_mean, channel_std)(data)
print(data)

输出：
tensor([[[-1.3856, -1.3856, -1.3856, -1.3856, -1.3856],
         [-0.6928, -0.6928, -0.6928, -0.6928, -0.6928],
         [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000],
         [ 0.6928,  0.6928,  0.6928,  0.6928,  0.6928],
         [ 1.3856,  1.3856,  1.3856,  1.3856,  1.3856]],

        [[-1.3856, -1.3856, -1.3856, -1.3856, -1.3856],
         [-0.6928, -0.6928, -0.6928, -0.6928, -0.6928],
         [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000],
         [ 0.6928,  0.6928,  0.6928,  0.6928,  0.6928],
         [ 1.3856,  1.3856,  1.3856,  1.3856,  1.3856]],

        [[-1.3856, -1.3856, -1.3856, -1.3856, -1.3856],
         [-0.6928, -0.6928, -0.6928, -0.6928, -0.6928],
         [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000],
         [ 0.6928,  0.6928,  0.6928,  0.6928,  0.6928],
         [ 1.3856,  1.3856,  1.3856,  1.3856,  1.3856]]])

我们观察数据发现，通过求解的均值和标准差，求得的标准化的值，并非在[-1,1]

结论：

经过这样处理后的数据符合标准正态分布，即均值为0，标准差为1。使模型更容易收敛。并非是归于[-1,1]！！

Normalize之前，数据分布是在[0,1]

Normalize之后：

  • ①如果mean = std=（0.5，0.5，0.5），那么Normalize之后，数据分布是【-1，1】；因为最小值=（0-mean）/std=(0-0.5)/0.5=-1。同理最大值的等于1。
  • ②如果mean为数据的计算的mean，std也是数据计算的std。那么Normalize之后根据公式（x-mean）/std，结合均值和方差的性质，可以算出新数据的均值会变成0，方差会变成1。

总结：
如果是Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))，确实是归一化到【-1，1】
如果是Normalize(channel_mean, channel_std)，才是均值为0，标准差为1。

transforms 数据增强

数据增强又称为数据增广，数据扩增，它是对训练集进行变换，使训练集更丰富，从而让模型更具泛化能力。

transforms——裁剪

  1. transforms.CenterCrop  

  • 功能：从图像中心裁剪图片
  • size：所需裁剪图片尺寸

    2、transforms.RandomCrop

  • 功能：从图片中随机裁剪出尺寸为size的图片
  • size：所需裁剪图片尺寸
  • padding：设置填充大小。当为a时，上下左右均填充a个像素，当为（a,b）时，上下填充b个像素，左右填充a个像素。当为（a,b,c,d）时，左上右下分别填充abcd
  • pad_if_need：若图像小于设定size，则填充
  • padding_mode：填充模式：（1）constant像素值由fill设定（默认模式）；（2）edge像素值由图像边缘像素决定（3）reflect镜像填充，最后一个像素不镜像，eg，[1,2,3,4]->[3,2,1,2,3,4,3,2];(4)symmetric镜像填充，最后一个像素镜像，eg，[1,2,3,4]->[2,1,1,2,3,4,4,3]
  • fill：constant时，设置填充的像素值

transforms——翻转和旋转

  1. RandomHorizontalFlip 水平翻转
  2. RandomVerticalFlip  垂直翻转
  3. RandomRotation  随机旋转图像

自定义tansfroms方法

class Compose(object):
    def __call__(self,img):
        for t in self.transforms:
               img = t(img)
        return img

transforms方法是在Compose类的__call__方法中被调用的，对一组transforms方法进行for循环，每次循序的挑选并执行transforms方法。

  • 自定义transforms要素：

  1. 仅接收一个参数，返回一个参数
  2. 注意上下游的输出和输入，数据类型必须匹配

通过类实现多参数传入，下图为自定义transforms的基本参数，一个init，一个call

class YourTransforms(object):
    def __init__(self,...):
        ...
    def __call__(self,img):
        ...
        return img

椒盐噪声

  • 椒盐噪声又称为又称为脉冲噪声，是一种随机出现的白点或者黑点，白点称为盐噪声，黑点称为椒噪声。
  • 信噪比（SNR）：衡量噪声的比例，图像中为图像像素的占比

class AddPepperNoise(object):
	def __init__(self, snr, p):
		self.snr = snr
		self.p = p
	
	def __call__(self, img):
		'''
		添加椒盐噪声具体实现过程
		'''
		return img

DaYinYi
关注
  • 19
    点赞
  • 踩
  • 113
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
pytorch实现手写数字识别 - MNIST数据集（全连接神经网络）.html
05-23
目录： 代码 相关说明 关于MNIST数据集 关于二分类与多分类 关于神经网络处理过程 softmax函数 关于MNIST数据集的处理举例 代码流程 关于transforms.ToTensor 关于transforms.Normalize 9.代码中transform的对应关系 关于x.view 设计模型 batch size设置技巧 谈谈batchsize参数 关于x.view(-1, 784) 关于torch.nn.Linear和relu的举例测试 学习课程：《PyTorch深度学习实践》完结合集（B站 刘二大人） https://www.bilibili.com/video/BV1Y7411d7Ys 一位大佬的专栏笔记：bit452的专栏：PyTorch 深度学习实践 https://blog.csdn.net/bit452/category_10569531.html
Pytorch中的transforms.Normalize()介绍
欢迎来到道的世界
03-22 2万+
1.数据标准化  Normalize()函数的作用是将数据转换为标准高斯分布，即逐个channelchannelchannel的对图像进行标准化（均值变为000，标准差为111），可以加快模型的收敛，具体的采 meanmeanmean：各通道的均值 stdstdstd：各通道的标准差 inplaceinplaceinplace：是否原地操作 output[channel]=input[channel]−mean[channel]std[channel]output[channel]=\frac{input
Pytorch框架学习（6）——transforms与normalize
aidanmo的博客
01-28 9806
图像预处理Transforms与normalize 文章目录图像预处理Transforms与normalize1. transforms运行机制2. 数据标准化——transforms.normalize 1. transforms运行机制 torchvision工具包中包含三个主要模块，今天主要学习transforms torchvision.transforms:常用的数据预处理方法，提升...
pytorch | transforms.Normalize()介绍
m0_57195758的博客
03-29 93
pytorch | transforms.Normalize()介绍
torch-mnist-batch-normalization:MNIST数据集上的Torch7批处理归一化示例
05-21
火炬mnist批处理规范化 MNIST数据集上的Torch7批处理归一化示例 我使用torch7来测试“批量归一化”文章第4.1节中的技术。 主要区别在于数据，我使用的MNIST数据集的图片尺寸为32x32px。 批处理规范化：克里斯汀·塞格迪（Christian Szegedy），谢尔盖·艾菲（Sergey Ioffe），通过减少内部协变量偏移来加速深层网络训练（2015年2月11日）
PyTorch数据集标准化-Torchvision.Transforms.Normalize()(pytorch系列-31)
peacefairy的博客
08-15 1万+
PyTorch数据集归一化- torchvision.transforms.Normalize() 在本集中，我们将学习如何规范化数据集。我们将看到如何在代码中执行数据集归一化，还将看到归一化如何影响神经网络训练过程。 数据归一化 数据归一化的概念是一个通用概念，指的是将数据集的原始值转换为新值的行为。新值通常是相对于数据集本身进行编码的，并以某种方式进行缩放。 特征缩放 出于这个原因，有时数据归一化的另一个名称是特征缩放。这个术语指的是，在对数据进行归一化时，我们经常会将给定数据集的不同特征转化为相近的
pytorch方法测试详解——归一化(BatchNorm2d)
09-18
今天小编就为大家分享一篇pytorch方法测试详解——归一化(BatchNorm2d)，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
关于pytorch中transform.Normalize的理解
weixin_40676212的博客
01-30 4313
之前对于使用pytorch中的transforms.Normalize进行图像的标准化原理一直存在困扰，今天通过学习以下文章明白了一些，做一个记录。 参考链接地址：(21条消息) pytorch中归一化transforms.Normalize的真正计算过程_月光下的小白菜的博客-CSDN博客_transform里的normalize 在训练中使用图像标准化主要是为了在梯度下降中算法可以更好的进行寻优，对于这一原理可以参考吴恩达的以下课程。 课程链接：【中英字幕】...
transform.normalize
A2000613的博客
01-10 5069
本文介绍了在深度学习过程中，对数据进行预处理的Normalize
transforms.Normalize（）
qimo601的专栏
09-20 2万+
transforms.Normalize：数据标准化，即均值为0，标准差为1。
PyTorch数据归一化处理：transforms.Normalize及计算图像数据集的均值和方差
热门推荐
紫芝的博客
05-10 4万+
计算图像数据集的均值和方差1.使用PyTorch计算图像数据集的均值和方差(推荐)2.使用opencv和numpy计算图像数据集的均值和方差3.计算某个目录下所有图片的均值和方差参考资料 1.使用PyTorch计算图像数据集的均值和方差(推荐) Pytorch图像预处理时，通常使用transforms.Normalize(mean, std)对图像按通道进行标准化，即减去均值，再除以方差。这样做可以加快模型的收敛速度。其中参数mean和std分别表示图像每个通道的均值和方差序列。 Imagenet数据集的均
pytorch 归一化与反归一化实例
12-23
ToTensor中就有转到0-1之间了。 # -*- coding:utf-8 -*- import time import torch from torchvision import transforms import cv2 ... transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.
深度学习PyTorch极简入门PDF教程.pdf
03-12
深度学习PyTorch极简入门PDF教程
pytorch-1.0.2.tar.gz
03-12
pytorch-1.0.2.tar.gz
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
计算机视觉的应用29-卷积神经网络(CNN)中的变种：分组卷积、转置卷积、空洞卷积的计算过程
weixin_42878111的博客
04-27 1261
大家好，我是微学AI，今天给大家介绍一下计算机视觉的应用29-卷积神经网络(CNN)中的变种：分组卷积、转置卷积、空洞卷积的计算过程。分组卷积将输入通道分为几组，对每组独立进行卷积操作，以减少计算量和模型参数。转置卷积也称为反卷积，它通过将输入特征图的元素扩展到更高维度的输出特征图来执行上采样。空洞卷积通过在输入特征图上引入“空洞”或“间隙”来增加感受野，从而在不增加额外参数的情况下扩大卷积核的有效覆盖范围。
计算机视觉——OpenCV 使用分水岭算法进行图像分割
知来者逆的博客
04-26 746
分水岭算法通过模拟自然地形来实现图像中物体的分类。在这一过程中，每个像素的灰度值被视作其高度，灰度值较高的像素形成山脊，即分水岭，而二值化阈值则相当于水平面，低于这个水平面的区域会被“淹没”。
计算机视觉（CV）简介
最新发布
longe20111104的博客
04-30 511
快速准确的处理是一个挑战，因为它需要处理大量的数据并做出准确的判断。特征选择和提取：从图像中选择和提取有用的特征是计算机视觉技术的关键挑战之一。不同的图像可能包含不同的特征，如纹理、颜色、形状等，如何选择和提取这些特征是一个复杂的问题。可以处理复杂的图像特征：计算机视觉技术可以识别和分析图像中的复杂特征，比如物体、人物、背景等。它可以在几秒钟内识别和分析图像中的信息，并根据这些信息做出相应的决策。复杂性和多样性：计算机视觉技术需要处理复杂和多样化的图像数据，包括不同的光照条件、角度、尺寸和分辨率等。
PotatoPie 4.0 实验教程(29) —— FPGA实现摄像头图像均值滤波处理
ICMakerChipdebug的博客
04-26 791
图像均值滤波处理是一种常见的图像处理技术，用于降低图像中噪声的影响并平滑图像。该方法通过在图像中滑动一个固定大小的窗口（通常是一个正方形或矩形），将窗口中所有像素的值取平均来计算窗口中心像素的新值。这种操作会使图像中的高频噪声减弱，并且可以使图像的轮廓变得更加模糊，从而使得图像更加平滑。图像均值滤波的理论依据是基于局部区域的像素值平均化。当图像中的一个像素值受到噪声的影响时，它的值可能会与其周围像素的值不一致。通过取局部区域像素值的平均，可以有效地减小噪声的影响，从而得到更加平滑的图像。
pytorch transforms.normalize
04-10
pytorch中的transforms.normalize是一个图像预处理方法，用来对输入的数据进行归一化处理。它需要指定均值和标准差，这些值将用来标准化输入数据。此函数可以用于图像分类、目标检测等机器学习任务中。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值