【Pytorch学习笔记五】数据预处理自定义torchvision.transforms图片操作方法对图片随机添加黑白噪声并展示结果（实践）

已于 2022-08-22 16:38:20 修改
阅读量1.2k 收藏 5
点赞数 2
分类专栏： Pytorch学习笔记 文章标签： pytorch 学习 python
于 2022-08-22 10:26:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QH2107/article/details/126460799
版权

在这里插入图片描述

使用自定义transforms对图片每个像素位置随机添加黑白噪声并展示结果，具体看下面的代码，只需修改图片路径即可运行。

# -*- coding: utf-8 -*-
import os
import numpy as np
import torch
import random
import math
import torchvision.transforms as transforms
from PIL import Image
from matplotlib import pyplot as plt


# 自定义一个类,对图片每个像素随机添加黑白噪声
class AddNoise(object):
    """
    Args:
        s(float): 噪声率
        p (float): 执行该操作的概率
    """

    def __init__(self, s=0.5, p=0.9):
        assert isinstance(s, float) or (isinstance(p, float))  # 判断输入参数格式是否正确
        self.s = s
        self.p = p

    # transform 会调用该方法
    def __call__(self, img):  # 使得类实例对象可以像调用普通函数那样，以“对象名()”的形式使用并执行对应的代码。
        """
       （PIL全称 Python Imaging Library，是 Python 平台一个功能非常强大而且简单易用的图像处理库。python3叫pillow）
       Args:
            img (PIL Image): PIL Image
        Returns:
            PIL Image: PIL image.
        """
        # 如果随机概率小于 seld.p，则执行 transform
        if random.uniform(0, 1) < self.p:  # random.uniform(参数1，参数2) 返回参数1和参数2之间的任意值
            # 把 image 转为 array
            img_ = np.array(img).copy()
            # 获得 shape，高*宽*通道数
            h, w, c = img_.shape
            # 信噪比
            signal_pct = self.s
            # 噪声的比例 = 1 -信噪比
            noise_pct = (1 - self.s)
            # 选择的值为 (0, 1, 2)，每个取值的概率分别为 [signal_pct, noise_pct/2., noise_pct/2.]
            # 1 为白噪声，2 为 黑噪声
            #numpy.random.choice(a, size=None, replace=True, p=None)解释
            #从a(只要是ndarray都可以，但必须是一维的)中随机抽取数字，并组成指定大小(size)的数组
            #replace:True表示可以取相同数字，False表示不可以取相同数字
            #数组p：与数组a相对应，表示取数组a中每个元素的概率，默认为选取每个元素的概率相同。
            mask = np.random.choice((0, 1, 2), size=(h, w, 1), p=[signal_pct, noise_pct / 2., noise_pct / 2.])
            mask = np.repeat(mask, c, axis=2)
            img_[mask == 1] = 255  # 白噪声
            img_[mask == 2] = 0  # 黑噪声
            # 再转换为 image
            return Image.fromarray(img_.astype('uint8')).convert('RGB')
        # 如果随机概率大于 seld.p，则直接返回原图
        else:
            return img

#指定随机数种子方法
def set_seed(seed=1):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)

# 对 tensor 进行反标准化操作（就是通过均值和方差再转为255*255*255的RGB图像），方便可视化使用。
def transform_invert(img_, transform_train):
    """
    将data 进行反transfrom操作
    :param img_: tensor
    :param transform_train: torchvision.transforms
    :return: PIL image
    """

    # 如果有标准化操作
    if 'Normalize' in str(transform_train):
        # 取出标准化的 transform
        # filter用法：用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新列表。
        # filter(function,iterable)，function -- 判断函数，iterable -- 可迭代对象
        norm_transform = list(filter(lambda x: isinstance(x, transforms.Normalize), transform_train.transforms))
        # 取出均值
        mean = torch.tensor(norm_transform[0].mean, dtype=img_.dtype, device=img_.device)
        # 取出标准差
        std = torch.tensor(norm_transform[0].std, dtype=img_.dtype, device=img_.device)
        # 乘以标准差，加上均值
        #torch.mul(a, b) 是矩阵a和b对应位相乘，a和b的维度必须相等。
        #这里是img_先×方差再加上平均值，与normalize的操作相反
        img_.mul_(std[:, None, None]).add_(mean[:, None, None])

    # 把 C*H*W 变为 H*W*C
    #transpose()函数改变索引值，如（1，0，2），对应（y，x，z）
    img_ = img_.transpose(0, 2).transpose(0, 1)  # C*H*W --> H*W*C
    # 把 0~1 的值变为 0~255
    img_ = np.array(img_) * 255

    # 如果是 RGB 图
    if img_.shape[2] == 3:
        img_ = Image.fromarray(img_.astype('uint8')).convert('RGB')
        # 如果是灰度图
    elif img_.shape[2] == 1:
        img_ = Image.fromarray(img_.astype('uint8').squeeze())
    else:
        raise Exception("Invalid img shape, expected 1 or 3 in axis 2, but got {}!".format(img_.shape[2]))

    return img_


# 下面开始调用上面的方法
set_seed(1)  # 设置随机种子为1
# 参数设置
MAX_EPOCH = 10  # 最大迭代次数
BATCH_SIZE = 1  # 批大小
LR = 0.01  # 学习率/步长
log_interval = 10  # 日志更新间隔
val_interval = 1
#定义normalize标准化的平均值和方差
norm_mean = [0.485, 0.456, 0.406]  # normalize各个通道的平均值
norm_std = [0.229, 0.224, 0.225]  # normalize各个通道数的方差
#定义对图片的操作组合，上一个教程有详细介绍方法
train_transform = transforms.Compose([  # 定义transforms组
    # 缩放到 (224, 224) 大小，会拉伸
    transforms.Resize((224, 224)),

    # 1 CenterCrop 中心裁剪
    # transforms.CenterCrop(512),     # 512
    # transforms.CenterCrop(196),     # 512

    # 2 RandomCrop
    # transforms.RandomCrop(224, padding=16),
    # transforms.RandomCrop(224, padding=(16, 64)),
    # transforms.RandomCrop(224, padding=16, fill=(255, 0, 0)),
    # transforms.RandomCrop(512, pad_if_needed=True),
    # transforms.RandomCrop(224, padding=64, padding_mode='edge'),
    # transforms.RandomCrop(224, padding=64, padding_mode='reflect'),
    # transforms.RandomCrop(1024, padding=1024, padding_mode='symmetric'),

    # 3 RandomResizedCrop
    # transforms.RandomResizedCrop(size=224, scale=(0.08, 1)),#scale在(0.08, 1)范围内缩放
    # transforms.RandomResizedCrop(size=224, scale=(0.5, 0.5)),

    # 4 FiveCrop
    # transforms.FiveCrop(112),
    # 返回的是 tuple，因此需要转换为 tensor
    #沿着一个新维度对输入张量序列进行连接，序列中所有的张量都应该为相同形状
    # transforms.Lambda(lambda crops: torch.stack([(transforms.ToTensor()(crop)) for crop in crops])),

    # 5 TenCrop
    # transforms.TenCrop(112, vertical_flip=False),
    # transforms.Lambda(lambda crops: torch.stack([(transforms.ToTensor()(crop)) for crop in crops])),

    # 1 Horizontal Flip
    # transforms.RandomHorizontalFlip(p=1),

    # 2 Vertical Flip
    # transforms.RandomVerticalFlip(p=1),

    # 3 RandomRotation
    # transforms.RandomRotation(90),
    # transforms.RandomRotation((90), expand=True),
    # transforms.RandomRotation(30, center=(0, 0)),
    # transforms.RandomRotation(30, center=(0, 0), expand=True),   # expand only for center rotation

    # 1 Pad
    # transforms.Pad(padding=32, fill=(255, 0, 0), padding_mode='constant'),
    # transforms.Pad(padding=(8, 64), fill=(255, 0, 0), padding_mode='constant'),
    # transforms.Pad(padding=(8, 16, 32, 64), fill=(255, 0, 0), padding_mode='constant'),
    # transforms.Pad(padding=(8, 16, 32, 64), fill=(255, 0, 0), padding_mode='symmetric'),

    # 2 ColorJitter
    # transforms.ColorJitter(brightness=0.5),
    # transforms.ColorJitter(contrast=0.5),
    # transforms.ColorJitter(saturation=0.5),
    # transforms.ColorJitter(hue=0.3),

    # 3 Grayscale
    # transforms.Grayscale(num_output_channels=3),

    # 4 Affine
    # transforms.RandomAffine(degrees=30),
    # transforms.RandomAffine(degrees=0, translate=(0.2, 0.2), fillcolor=(255, 0, 0)),
    # transforms.RandomAffine(degrees=0, scale=(0.7, 0.7)),
    # transforms.RandomAffine(degrees=0, shear=(0, 0, 0, 45)),
    # transforms.RandomAffine(degrees=0, shear=90, fillcolor=(255, 0, 0)),

    # 5 Erasing
    # transforms.ToTensor(),
    # transforms.RandomErasing(p=1, scale=(0.02, 0.33), ratio=(0.3, 3.3), value=(254/255, 0, 0)),
    # transforms.RandomErasing(p=1, scale=(0.02, 0.33), ratio=(0.3, 3.3), value='fads43'),

    # 1 RandomChoice
    # transforms.RandomChoice([transforms.RandomVerticalFlip(p=1), transforms.RandomHorizontalFlip(p=1)]),

    # 2 RandomApply
    # transforms.RandomApply([transforms.RandomAffine(degrees=0, shear=45, fillcolor=(255, 0, 0)),
    #                         transforms.Grayscale(num_output_channels=3)], p=0.5),
    # 3 RandomOrder
    # transforms.RandomOrder([transforms.RandomRotation(15),
    #                         transforms.Pad(padding=32),
    #                         transforms.RandomAffine(degrees=0, translate=(0.01, 0.1), scale=(0.9, 1.1))]),

    # 调用自定义transforms方法
    AddNoise(0.5, p=0.5),  # 调用上面的类中的__Call__()
    transforms.ToTensor(), #
    transforms.Normalize(norm_mean, norm_std),
])

path_img = os.path.join("F:\\Desktop", "24110307_8.jpg")  # 图片位置
img = Image.open(path_img).convert('RGB')  # 0~255
img = transforms.Resize((224, 224))(img)
img_tensor = train_transform(img) # 执行定义的transforms组内的图片操作

## 展示单张图片
# 这里把转换后的 tensor 再转换为图片
convert_img = transform_invert(img_tensor, train_transform)
#绘制图像
plt.rcParams["font.sans-serif"]=["SimHei"]# 用来正常显示中文标签
plt.rcParams["axes.unicode_minus"]=False
plt.rcParams['figure.dpi'] = 300 #分辨率
plt.figure(figsize=(6,2.5)) # 表示figure 的大小为宽、长（单位为inch）
plt.subplot(1, 2, 1)
plt.imshow(img) #原始图像
plt.subplot(1, 2, 2)
plt.imshow(convert_img) #转换后的图像
plt.show()
# plt.pause(0.5)
plt.close()

## 展示 FiveCrop 和 TenCrop 的图片
# ncrops, c, h, w = img_tensor.shape
# columns=2 # 两列
# rows= math.ceil(ncrops/2) # 计算多少行
# # 把每个 tensor ([c,h,w]) 转换为 image
# for i in range(ncrops):
#     img = transform_invert(img_tensor[i], train_transform)
#     plt.subplot(rows, columns, i+1)
#     plt.imshow(img)
# plt.show()

运行结果：

image-20220822101457742

其它的注释的transforms图片操作方法都可以试一试。
参考资料：https://pytorch.zhangxiann.com/2-tu-pian-chu-li-yu-shu-ju-jia-zai/2.3-er-shi-er-zhong-transforms-tu-pian-shu-ju-yu-chu-li-fang-fa

欢迎关注个人公众号【智能建造小硕】（分享计算机编程、人工智能、智能建造、日常学习和科研经验等，欢迎大家关注交流。）

智能建造小硕
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
PyTorch学习笔记（二）图像数据预处理
12-21
Environment OS: macOS Mojave Python version: 3.7 PyTorch version: 1.4.0 IDE: PyCharm 文章目录0. 写在前面1. 基本变换类1.1 填充1.2 擦除1.3 缩放1.4 裁剪1.5 旋转1.6 翻转1.7 颜色1.8 仿射变换和线性变换1.9 归一化和标准化1.10. Lambda2. 组合变换类3. 自定义图像数据增强 0. 写在前面 本文记录了使用 PyTorch 实现图像数据预处理的方法，包括数据增强和标准化。主要的工具为 torchvision.transform 模块中的各种类，要求传入的图片为 PI
YOLOv5代码详解（train.py部分）
热门推荐
Liaojiajia-Blog
07-02 3万+
1. train.py 1.1 使用nvidia的apex接口计算混合精度训练 mixed_precision = True try: # Mixed precision training https://github.com/NVIDIA/apex from apex import amp except: print('Apex recommended for faster mixed precision training: https://github.com/NVIDIA/apex'
Python实现对图像加噪(高斯噪声 椒盐噪声)
qq_39931336的博客
02-26 1490
展示如何给图像叠加不同等级的椒盐噪声和高斯噪声的代码，相应的叠加噪声的已编为对应的类，可实例化使用。以下主要展示自己编写的：#代码中的noisef为信号等级，例如我需要0.7的噪声，传入参数我传入的是1-0.7"""增加椒盐噪声Args:p (float): 概率值，依概率执行该操作"""self.p = p"""Args:Returns:"""img_[mask == 1] = 255 # 盐噪声。
PyTorch 生成随机数Tensor（标准分布、标准正态、离散正态……）
MarsLee_U的博客
06-02 2万+
在使用PyTorch做实验时经常会用到生成随机数Tensor的方法，比如：torch.rand()torch.randn()torch.normal()torch.linespace()均匀分布torch.rand(*sizes, out=None) → Tensor返回一个张量，包含了从区间[0, 1)的均匀分布中抽取的一组随机数。张量的形状由参数sizes定义。参数:sizes (int…) ...
【PyTorch学习笔记_02】--- Opencv笔记（图像预处理使用）
灵寒谷的博客
11-03 885
Opencv操作
chatgpt赋能python：PyTorch添加噪声：什么是噪声？为什么添加噪声很重要？
sc17332889342的博客
07-01 1288
本文由chatgpt生成，文章没有在chatgpt生成的基础上进行任何的修改。以上只是chatgpt能力的冰山一角。作为通用的Aigc大模型，只是展现它原本的实力。对于颠覆工作方式的ChatGPT，应该选择拥抱而不是抗拒，未来属于“会用”AI的人。🧡AI职场汇报智能办公文案写作效率提升教程 🧡专注于AI+职场+办公方向。下图是课程的整体大纲下图是AI职场汇报智能办公文案写作效率提升教程中用到的ai工具。
Pytorch数据预处理——选择与自定义transforms（通过向图片上添加椒盐噪声、高斯噪声增来强数据的数据增强方法）
记录学习的小白
05-05 6199
前言 这篇笔记是学习pytorch的数据预处理方式transforms，这篇笔记包括两个要点，第一是在已经选好transform方法transform1,transform2,transform3...，并且都设置好参数数的前提下，如何在每次迭代的时候选择不同组的transform方法或者使用不同的调用顺序，第二是如何自定义transform方法 ，虽然pytorch提供了很多transform方法，但有时可能也需要自己定义。本笔记提供了在图片上添加椒盐和高斯噪声 的数据增强方法。本笔记的知识框架主要来源
torchvision.transforms用法介绍
星之所望的博客
02-17 1654
pytorch源码解读之torchvision.transforms PyTorch框架中有一个非常重要且好用的包：torchvision，该包主要由3个子包组成，分别是：torchvision.datasets、torchvision.models、torchvision.transforms。这3个子包的具体介绍可以参考官网：http://pytorch.org/docs/master/to...
pyrtorch图片处理：torchvision.transforms常用方法
iotflh的博客
10-28 1022
transforms.Compose() 串联多个图片变换的操作。 transforms.Resize() 将图片转换到制定大小。 Resize(224) 将图片短边缩放到224，长边做等比缩放 Resize([224,224])将图片缩放到224*224 transforms.CenterCrop（） 图片裁剪，从中心位置裁剪指定大小的图片。 transforms.ToTensor() （1） transforms.ToTensor() 将numpy的ndarray或PIL.Image.
PyTorch学习之数据增强（image transformations）
mingo_敏
01-17 2万+
位于torchvision.transforms下面。 0 torchvision.transforms.Compose(transforms) 1 常见变换 1-1 Resize torchvision.transforms.Resize(size, interpolation=2) 1-2 标准化 torchvision.transforms.Normalize(mean, std) 1-3 ...
Pytorch为模型参数添加噪声
volcan的博客
03-20 3315
如何为模型添加噪声
Pytorch学习笔记——文本预处理
01-06
文本预处理 1、概述 文本数据：有用内容和无用内容 文章：单词、符号、空格、乱码等 思想：我们需要对无用信息进行过滤，而计算机无法直接处理单词等有用信息，我们需要把他们转换成数字。将单词映射到不同的数字，...
基于pytorch+Resnet50网络对皮肤病图片进行二分类源码++数据集+全部数据资料.zip
03-12
基于pytorch+Resnet50网络对皮肤病图片进行二分类源码+全部数据资料.zip数据集说明 数据集存放目录为： used_dataset , 共200张图片，标签为：benign(良性）、malignant(患病)。 基于pytorch+Resnet50网络对皮肤病...
PyTorch-1.4.0+torchvision-0.5.0.zip
07-18
用于深度学习的环境搭建，本人配置为Win10_64+CUDA10.0+Python3.7.1，亲测可用。
Pytorch中的self.parameters()
xy_optics的博客
05-06 94
当你定义一个 PyTorch 模型类时，你会将模型的各个层（如全连接层、卷积层等）定义在。是更常用的选择，因为它提供了模型参数及其名称的完整信息，方便了保存和加载模型的状态。是一个模型方法，它返回模型中所有需要优化的参数。这些参数通常是模型中的权重和偏置项。方法中，这些层中的参数都会被 PyTorch 自动识别为模型的可训练参数。则更适用于需要直接对参数进行操作的情况，比如初始化参数或手动更新参数等。通常情况下，当你需要保存或加载模型的参数时，方法就是用来访问这些可训练参数的。在 PyTorch 中，
pytorch中的数据集处理部分data_transforms = { ‘train‘: transforms.Compose([...])...
最新发布
AndrewPerfect的博客
05-06 323
在PyTorch的深度学习框架中，是一个非常常用的工具，它用于将多个数据转换（或称为“变换”）组合成一个单一的转换流程。这通常用于预处理输入数据，比如图像，以符合模型的训练要求。当你看到这样的代码时，这通常是在一个字典中定义数据预处理流程，其中'train'是键，表示这是用于训练数据的预处理流程。例如，以下是一个常见的图像预处理流程，它使用了在这个例子中，ToTensor()当你使用这样的预处理流程时，你可以确保你的模型在训练时接收到经过适当预处理的数据。
archive
m0_72827793的博客
05-06 527
就拿时间这个变量来说，我们一般认为时间是连续的，它确实是连续的，但是，我们用科学的测量，是没法把时间测成连续的，也就是说，我们哪怕用微秒纳秒也不能严格满足连续的定义，然而，这并不妨碍我们进行计算。哪怕我们肉眼见到的物质，不也是有原子组成，原子不仅仅不是最小的，而且还存在间隔。RNN 跟传统神经网络最大的区别在于每次都会将前一次的输出结果，带到下一次的隐藏层中，一起训练。RNN，会将之前的结果带入下一次，这个符合连续型的数据，所以这个用来处理视频。对于图片，可以把像素看成每一个点，所以选择CNN无疑的。
深度学习之基于Pytorch姿态估计的仰卧起坐计数系统
Q1744828575的博客
05-06 923
一、项目背景仰卧起坐作为一种常见的健身动作，被广泛用于腹部肌肉的锻炼。然而，对于仰卧起坐的数量和质量的监控，传统的方法往往依赖于人工计数或简单的机械计数器，这些方法不仅效率低下，而且容易出错。随着深度学习技术的快速发展，特别是姿态估计技术的不断成熟，为仰卧起坐计数提供了新的解决方案。本项目旨在利用PyTorch深度学习框架和姿态估计技术，开发一个高效、准确的仰卧起坐计数系统。二、项目目标。
torch.unique_consecutive
weixin_43903164的博客
05-06 64
就是将原始的torch去除重复的部分。
python如何让图片镜像翻转_[PyTorch 学习笔记] 2.3 二十二种 transforms 图片数据预处理方法
06-10
可以使用PIL库中的transpose()方法来实现图片的镜像翻转。具体操作如下： 1. 首先，导入必要的库： ``` from PIL import Image import torchvision.transforms as transforms ``` 2. 定义一个transforms对象，使用transforms.RandomHorizontalFlip()方法来实现图片的镜像翻转。代码如下： ``` transform = transforms.Compose([ transforms.RandomHorizontalFlip(), transforms.ToTensor() ]) ``` 3. 加载图片，并应用transforms对象来进行镜像翻转。代码如下： ``` img = Image.open('image.jpg') img = transform(img) ``` 其中，'image.jpg'是待处理的图片文件名。 通过以上步骤，就可以实现对图片的镜像翻转预处理操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

智能建造小硕

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

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

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

打赏作者

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

抵扣说明：

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

余额充值