可视化理解pytorch中transforms的具体作用

最新推荐文章于 2024-05-15 16:34:48 发布
最新推荐文章于 2024-05-15 16:34:48 发布
阅读量5.3k 收藏 47
点赞数 27
分类专栏： ❤️ 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteapoy/article/details/106121752
版权

pytorch的图像处理库 torchvision 的 transforms 集成了随机翻转、旋转、增强对比度、转化为tensor、转化为图像等功能，用于数据增强，非常便捷。但是，初学者在学习 transforms 时，可能会好奇图像在经过transforms后究竟变成了什么样子，以下利用 matplotlib 来绘制图像，增强理解。

实验环境

  • jupyter notebook
  • python3
  • matplotlib库
  • pytorch库（这里以1.2.0作为演示）
  • pillow库（这里以7.1.2作为演示）
  • torchvision库（这里以0.4.2作为演示）

官方文档

torchvision官方文档：点此查看

常用的方法：

  • Color Jittering：对颜色的数据增强：图像亮度、饱和度、对比度变化（此处对色彩抖动的理解不知是否得当）；
  • PCA Jittering：首先按照RGB三个颜色通道计算均值和标准差，再在整个训练集上计算协方差矩阵，进行特征分解，得到特征向量和特征值，用来做PCA Jittering；
  • Random Scale：尺度变换；
  • Random Crop：采用随机图像差值方式，对图像进行裁剪、缩放；包括Scale Jittering方法（VGG及ResNet模型使用）或者尺度和长宽比增强变换；
  • Horizontal/Vertical Flip：水平/垂直翻转；
  • Shift：平移变换；
  • Rotation/Reflection：旋转/仿射变换；
  • Noise：高斯噪声、模糊处理；

可视化

加载所需库

import torch
import numpy as np
import matplotlib.pyplot as plt
from torchvision import transforms
from torchvision.datasets.folder import default_loader
#在jupyter notebook中显示图片
%matplotlib inline

加载图片

img_path = 'D:/12-GitHub/datasets/flickr8k/images\\667626_18933d713e.jpg'
x=default_loader(img_path)
print(x.size)
x

在这里插入图片描述
图片长500像素，宽375像素

定义transform和对应的图片情况

初级版

首先，尝试最简单的transforms.ToTensor()。

transform = transforms.Compose([
    transforms.ToTensor(), #将图片变成 Tensor，并且把数值normalize到[0,1]
])

img = transform(x)
print(img.size())
img

Out:

torch.Size([3, 375, 500])
tensor([[[0.9529, 0.9490, 0.9020,  ..., 0.4941, 0.4667, 0.5922],
         [0.8588, 0.8000, 0.9569,  ..., 0.6627, 0.6078, 0.4275],
         [0.9843, 0.8275, 0.7961,  ..., 0.5725, 0.5922, 0.5529],
         ...,
         [0.9059, 0.9176, 0.9412,  ..., 0.4980, 0.6980, 0.6235],
         [0.9216, 0.8902, 0.9373,  ..., 0.8078, 0.8549, 0.7686],
         [0.9765, 0.9373, 0.9294,  ..., 0.9216, 0.8275, 0.9961]],

        [[0.9569, 0.9569, 0.9176,  ..., 0.6314, 0.6000, 0.7216],
         [0.8667, 0.8196, 0.9804,  ..., 0.8000, 0.7412, 0.5569],
         [1.0000, 0.8627, 0.8353,  ..., 0.7176, 0.7333, 0.6941],
         ...,
         [0.9137, 0.9020, 0.8941,  ..., 0.5569, 0.7569, 0.6824],
         [0.8863, 0.8549, 0.8941,  ..., 0.8431, 0.8902, 0.8039],
         [0.8941, 0.8706, 0.8941,  ..., 0.9255, 0.8314, 1.0000]],

        [[1.0000, 1.0000, 0.9529,  ..., 0.6039, 0.6039, 0.7490],
         [0.9137, 0.8353, 0.9804,  ..., 0.7725, 0.7373, 0.5765],
         [1.0000, 0.8510, 0.8000,  ..., 0.6902, 0.7176, 0.6863],
         ...,
         [0.9098, 0.9059, 0.9098,  ..., 0.5686, 0.7686, 0.6941],
         [0.8980, 0.8667, 0.9098,  ..., 0.8627, 0.9098, 0.8235],
         [0.9216, 0.8941, 0.9059,  ..., 0.9451, 0.8510, 1.0000]]])

从 (500,375) 变成了 (3, 375, 500) 的 tensor，接下来是绘图：

plt.figure(figsize=(8,8))
img = transform(x)
img = img.numpy().transpose((1,2,0))
img = np.clip(img,0,1)
plt.imshow(img)

在这里插入图片描述

中级版 - 归一化

然后，尝试加入transforms.Normalize()。

transform = transforms.Compose([
    transforms.ToTensor(), #将图片变成 Tensor，并且把数值normalize到[0,1]
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

img = transform(x)
print(img.size())
img

这里Normalize的数值是经验性的，从ImageNet中总结出来的，[0.485, 0.456, 0.406]是均值mean，[0.229, 0.224, 0.225]是方差std。

Out:

torch.Size([3, 375, 500])
tensor([[[ 2.0434,  2.0263,  1.8208,  ...,  0.0398, -0.0801,  0.4679],
         [ 1.6324,  1.3755,  2.0605,  ...,  0.7762,  0.5364, -0.2513],
         [ 2.1804,  1.4954,  1.3584,  ...,  0.3823,  0.4679,  0.2967],
         ...,
         [ 1.8379,  1.8893,  1.9920,  ...,  0.0569,  0.9303,  0.6049],
         [ 1.9064,  1.7694,  1.9749,  ...,  1.4098,  1.6153,  1.2385],
         [ 2.1462,  1.9749,  1.9407,  ...,  1.9064,  1.4954,  2.2318]],

        [[ 2.2360,  2.2360,  2.0609,  ...,  0.7829,  0.6429,  1.1856],
         [ 1.8333,  1.6232,  2.3410,  ...,  1.5357,  1.2731,  0.4503],
         [ 2.4286,  1.8158,  1.6933,  ...,  1.1681,  1.2381,  1.0630],
         ...,
         [ 2.0434,  1.9909,  1.9559,  ...,  0.4503,  1.3431,  1.0105],
         [ 1.9209,  1.7808,  1.9559,  ...,  1.7283,  1.9384,  1.5532],
         [ 1.9559,  1.8508,  1.9559,  ...,  2.0959,  1.6758,  2.4286]],

        [[ 2.6400,  2.6400,  2.4308,  ...,  0.8797,  0.8797,  1.5245],
         [ 2.2566,  1.9080,  2.5529,  ...,  1.6291,  1.4722,  0.7576],
         [ 2.6400,  1.9777,  1.7511,  ...,  1.2631,  1.3851,  1.2457],
         ...,
         [ 2.2391,  2.2217,  2.2391,  ...,  0.7228,  1.6117,  1.2805],
         [ 2.1868,  2.0474,  2.2391,  ...,  2.0300,  2.2391,  1.8557],
         [ 2.2914,  2.1694,  2.2217,  ...,  2.3960,  1.9777,  2.6400]]])

数值和之前有一些不一样了，把它画出来看看

plt.figure(figsize=(8,8))
img = transform(x)
img=img.numpy().transpose((1,2,0))
#img = np.clip(img,0,1)
plt.imshow(img)

在这里插入图片描述
看起来像是曝光过度的图片，把它还原成正常图片：

plt.figure(figsize=(8,8))
img = transform(x)
img=img.numpy().transpose((1,2,0))
mean = np.array([0.485,0.456,0.406])
std = np.array([0.229,0.224,0.225])
img = std*img+mean
img = np.clip(img,0,1)
plt.imshow(img)

在这里插入图片描述

中级版 - 翻转与旋转

继续加入随机翻转 transforms.RandomHorizontalFlip()、随机旋转transforms.RandomRotation() 的操作。

transform = transforms.Compose([
    # transforms.ToPILImage(), # 如果是numpy请取消注释
    transforms.RandomHorizontalFlip(), #随机翻转图片
    transforms.RandomRotation(15), #随机旋转图片
    transforms.ToTensor(), #将图片变成 Tensor，并且把数值normalize到[0,1]
])

img = transform(x)
print(img.size())
img

Out:

torch.Size([3, 375, 500])
tensor([[[0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.],
         ...,
         [0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.]],

        [[0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.],
         ...,
         [0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.]],

        [[0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.],
         ...,
         [0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.]]])

怎么看起来好多地方都是0？让我们可视化看看：

# 多次运行此部分代码，可实现多次随机
plt.figure(figsize=(8,8))
img = transform(x)
img=img.numpy().transpose((1,2,0))
img = np.clip(img,0,1)
plt.imshow(img)

在这里插入图片描述
可以看到，因为随机旋转，所以有一些地方是黑色的。再让我们多随机几次（只需要重复运行img = transform(x)，即上方代码，不需要重新运行transform的定义）看看：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

中级版 - 调整亮度、灰度、饱和度、对比度

brightness是亮度，contrast是对比度，saturation是饱和度，hue是色调

transform = transforms.Compose([
    # transforms.ToPILImage(), # 如果是numpy请取消注释
#     transforms.RandomHorizontalFlip(), #随机翻转图片
#     transforms.RandomRotation(15), #随机旋转图片
    transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1),
    transforms.RandomGrayscale(),
    transforms.ToTensor(), #将图片变成 Tensor，并且把数值normalize到[0,1]    
#     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

img = transform(x)
print(img.size())
img

Out:

torch.Size([3, 375, 500])
tensor([[[0.9020, 0.8980, 0.8588,  ..., 0.4314, 0.4000, 0.5333],
         [0.8196, 0.7333, 0.8902,  ..., 0.5961, 0.5412, 0.3608],
         [0.9176, 0.7569, 0.7333,  ..., 0.5059, 0.5294, 0.4902],
         ...,
         [0.8392, 0.8510, 0.8745,  ..., 0.4353, 0.6314, 0.5569],
         [0.8549, 0.8235, 0.8706,  ..., 0.7412, 0.7882, 0.7020],
         [0.9098, 0.8706, 0.8627,  ..., 0.8667, 0.7725, 0.9176]],

        [[0.8902, 0.8863, 0.8392,  ..., 0.5255, 0.4627, 0.5765],
         [0.7922, 0.7412, 0.9020,  ..., 0.6863, 0.6118, 0.4118],
         [0.9176, 0.7922, 0.7686,  ..., 0.6039, 0.6118, 0.5608],
         ...,
         [0.8510, 0.8431, 0.8314,  ..., 0.4588, 0.6549, 0.5804],
         [0.8196, 0.7961, 0.8275,  ..., 0.7451, 0.7922, 0.7098],
         [0.8392, 0.8196, 0.8275,  ..., 0.8549, 0.7608, 0.9176]],

        [[0.9176, 0.9176, 0.8902,  ..., 0.5686, 0.5412, 0.6863],
         [0.8510, 0.7686, 0.9137,  ..., 0.7373, 0.6784, 0.5137],
         [0.9176, 0.8000, 0.7569,  ..., 0.6549, 0.6706, 0.6314],
         ...,
         [0.8510, 0.8353, 0.8275,  ..., 0.5059, 0.7059, 0.6314],
         [0.8157, 0.7922, 0.8275,  ..., 0.8000, 0.8471, 0.7608],
         [0.8235, 0.8039, 0.8235,  ..., 0.8784, 0.7882, 0.9176]]])

绘图：

plt.figure(figsize=(8,8))
img = transform(x)
img=img.numpy().transpose((1,2,0))
# img = np.clip(img,0,1)
plt.imshow(img)

在这里插入图片描述

同样多随机几次看看：
在这里插入图片描述
在这里插入图片描述

高级版

说是高级版，实际上是把所有东西都混合进来

transform = transforms.Compose([
    # transforms.ToPILImage(), # 如果是numpy请取消注释
    transforms.RandomHorizontalFlip(), #随机翻转图片
    transforms.RandomRotation(15), #随机旋转图片
    transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1),
    transforms.RandomGrayscale(),
    transforms.ToTensor(), #将图片变成 Tensor，并且把数值normalize到[0,1]    
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

img = transform(x)
print(img.size())
img

Out:

torch.Size([3, 375, 500])
tensor([[[-2.1179, -2.1179, -2.1179,  ..., -2.1179, -2.1179, -2.1179],
         [-2.1179, -2.1179, -2.1179,  ..., -2.1179, -2.1179, -2.1179],
         [-2.1179, -2.1179, -2.1179,  ..., -2.1179, -2.1179, -2.1179],
         ...,
         [-2.1179, -2.1179, -2.1179,  ..., -2.1179, -2.1179, -2.1179],
         [-2.1179, -2.1179, -2.1179,  ..., -2.1179, -2.1179, -2.1179],
         [-2.1179, -2.1179, -2.1179,  ..., -2.1179, -2.1179, -2.1179]],

        [[-2.0357, -2.0357, -2.0357,  ..., -2.0357, -2.0357, -2.0357],
         [-2.0357, -2.0357, -2.0357,  ..., -2.0357, -2.0357, -2.0357],
         [-2.0357, -2.0357, -2.0357,  ..., -2.0357, -2.0357, -2.0357],
         ...,
         [-2.0357, -2.0357, -2.0357,  ..., -2.0357, -2.0357, -2.0357],
         [-2.0357, -2.0357, -2.0357,  ..., -2.0357, -2.0357, -2.0357],
         [-2.0357, -2.0357, -2.0357,  ..., -2.0357, -2.0357, -2.0357]],

        [[-1.8044, -1.8044, -1.8044,  ..., -1.8044, -1.8044, -1.8044],
         [-1.8044, -1.8044, -1.8044,  ..., -1.8044, -1.8044, -1.8044],
         [-1.8044, -1.8044, -1.8044,  ..., -1.8044, -1.8044, -1.8044],
         ...,
         [-1.8044, -1.8044, -1.8044,  ..., -1.8044, -1.8044, -1.8044],
         [-1.8044, -1.8044, -1.8044,  ..., -1.8044, -1.8044, -1.8044],
         [-1.8044, -1.8044, -1.8044,  ..., -1.8044, -1.8044, -1.8044]]])

plt.figure(figsize=(8,8))
img = transform(x)
img=img.numpy().transpose((1,2,0))
# img = np.clip(img,0,1)
plt.imshow(img)

在这里插入图片描述

有人可能会问，处理成这样的图片，看起来似乎不太美妙，真的可以用来训练吗？这个问题，大概只有模型自己知道吧，毕竟图片是给人看的，图像在模型内部只是一堆数据而已。

iteapoy
关注
  • 27
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
可视化学习笔记8-使用python transforms数据增强后效果图（附结果图）
LZL2020LZL的博客
03-12 6344
from torchvision import transforms import PIL.Image as Image import matplotlib.pyplot as plt import numpy as np image = Image.open("try/0.jpg") transform = transforms.Compose([ transforms.RandomResizedCrop(224),
第58步 深度学习图像识别：Transformer可视化（Pytorch）
qq_30452897的博客
08-19 2200
第58步 深度学习图像识别：Transformer可视化（Pytorch）
pytorch初学笔记（三）Tranforms的使用
CV在读
10-28 3240
Python __call__()方法（详解版） (biancheng.net)call()方法是Python中一个很特殊的方法。凡是可调用对象，都可以通过调用__call__()方法来调用该对象。如果类中定义了__call__()方法，那么该类的实例对象也将成为可调用对象。该对象被调用时，将执行__call__()方法中的代码。该方法的功能类似于在类中重载 () 运算符，使得类实例对象可以像调用普通函数那样，以“对象名()”的形式使用。
Pytorch中常见的transforms用法
最新发布
Modaa_的博客
05-15 923
transforms是torchvision中的一个模块（torchvision是Pytorch的计算机视觉工具包），该模块定义了很多用于图像预处理的类，如归一化（Normalize类），尺寸变化（Resize类），转换为tensor格式（ToTensor类），通过实例化该工具类，可以方便地对图像进行各种变换操作。
PyTorch快速入门教程【小土堆】-Transforms的使用
weixin_42182290的博客
05-02 1461
常用的transforms
基于Transformer的DETR的注意力权重可视化，非CAM可视化技术
Flying Bulldog 的博客
05-03 2493
神经网络的可视化可以客观的解释“黑盒” ，所以一直以来都是论文中必不可少的工作。 对于深度卷积神经网络，一般用CAM进行可视化研究。遗憾的是，基于Transformer的神经网络可视化，CAM并不奏效。所以，本文章提供一套基于DETR的可视化代码。 注意：本文章为了贯彻简洁高效的思想，没有对源代码做任何的改动，仅仅添加了两个py文件对图像进行检测和可视化操作。
Pytorch学习笔记（3）———transforms变换
weixin_44783002的博客
09-11 723
Why transforms? 一般情况下收集到的图像样本在尺寸，亮度等方面存在差异，在深度学习中，我们希望样本分布是独立同分布的，因此需要对样本进行归一化预处理。 有时候只能获取到少量的样本数据，获取数量较多的样本不容易。但是样本数量太少训练的模型精度会比较低，为了解决这样的问题，往往需要做数据增加data arguement， 数据增加的途径就是通过一些变换达到目的。 pytorch中的transforms 在pytorch中，transforms位于 torchvision.transforms
Python Unet网络结构pytorch简单实现+torchsummary可视化（可以直接运行）
12-21
标题中的“Python Unet网络结构pytorch简单实现+torchsummary可视化（可以直接运行）”表明了本文将介绍如何在Python环境中，使用PyTorch框架来实现Unet网络，并结合torchsummary库进行模型可视化，且提供的代码可以...
pytorch中的inference使用实例
12-20
transforms`，这是一个由多个转换组成的转换流水线，常见的包括`RandomSizedCrop(224)`，用于随机裁剪图像至指定大小（在这个例子中是224x224像素），以及`ToTensor()`，将PIL（Python Imaging Library）格式的图像...
pytorch绘制并显示loss曲线和acc曲线，LeNet5识别图像准确率
09-18
在PyTorch中，训练深度学习模型时，记录并可视化损失(loss)曲线和准确率(acc)曲线对于理解和优化模型性能至关重要。本篇文章将介绍如何利用PyTorch和TensorboardX来绘制这些曲线，并以LeNet5为例展示图像分类任务的...
utils推导，pytorch模块运行，可以DEBUG一步步详细理解
11-17
2. **可视化工具**：在目标检测中，可视化是理解和调试模型的重要手段。`utils.visdom`（如果使用Visdom库）或`utils.plot`等函数可以将预测结果与真实边界框对比显示，帮助我们直观地理解模型性能。 3. **损失函数...
使用 PyTorch 中的 torchvision 模块加载预训练的 Mask R-CNN 模型
03-25
你可以遍历这些结果来解析和可视化它们： ```python for i in range(outputs[0].num_instances): box = outputs[0].rois[i].detach().cpu().numpy().tolist() score = outputs[0].scores[i].item() class_id = ...
transforms.Compose,transforms.ToTensor(),transforms.Normalize()的含义与原理
qq_41795143的博客
02-09 1万+
transforms.Compose,transforms.ToTensor(),transforms.Normalize()的含义与原理 1.问题描述 问题来源于pytorch神经网络的示例代码： transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) 作用主要是读取CIFAR10数
pytorch中数据预处理模块：transforms详解
十年以上架构设计经验，专注于软件架构和人工智能领域，对机器视觉、NLP、音视频等领域都有涉猎
12-10 3423
对于视觉方向的图像处理方面，PyTorch提供了很好的预处理接口，对于图像的转换处理，使用 torchvision.tranforms 模块使得这些操作非常高效。
系统学习Pytorch笔记三：Pytorch数据读取机制(DataLoader)与图像预处理模块(transforms)
热门推荐
Miracle8070
04-17 6万+
Pytorch官方英文文档：https://pytorch.org/docs/stable/torch.html? Pytorch中文文档：https://pytorch-cn.readthedocs.io/zh/latest/ 1. 写在前面 疫情在家的这段时间，想系统的学习一遍Pytorch基础知识，因为我发现虽然直接Pytorch实战上手比较快，但是关于一些内部的原理知识其实并不是太懂，这样...
PyTorch - transforms.ColorJitter 改变图像的属性：亮度（brightness）、对比度（contrast）、饱和度（saturation）和色调（hue)
flyfish
09-28 6万+
PyTorch - transforms.ColorJitter 改变图像的属性：亮度（brightness）、对比度（contrast）、饱和度（saturation）和色调（hue) flyfish jitter的意思 v. 紧张不安 / 抖动 / 战战兢兢 / 神经过敏 n. 紧张不安 / 晃动 / 偏移 / 振动 这里抖动或者偏移 是随机变化的含义 下面以亮度brightness举例，假设brightness设置为0.5 brightness_change = transforms.ColorJit
Pytorch：torchvision.transforms图像增强方法和参数介绍
qq_34741153的博客
08-07 2589
最近在使用pytorch构建网络，用到了torchvision.transforms图像增强方法。博主也在网上查找该方法的介绍，也有博主总结得很好，但只是介绍了方法名称，对方法具体的效果没有做详细介绍。本文将对各方法的参数做详细介绍，以求对方法的效果有更直观的印象。 另外，博主第一次写博客，本文将随着博主的学习推进持续更新，希望大家喜欢~ 修改亮度、对比度、饱和度、色调：transforms.ColorJitter 功能：随机修改亮度、对比度、饱和度、色调 参数： brightness：亮度因.
Pytorch中transforms.Compose()的使用
qq_33287871的博客
03-22 1万+
torchvision介绍 torchvision是pytorch的一个图形库，它服务于PyTorch深度学习框架的，主要用来构建计算机视觉模型。torchvision.transforms主要是用于常见的一些图形变换。以下是torchvision的构成： torchvision.datasets: 一些加载数据的函数及常用的数据集接口； torchvision.models: 包含常用的模型结构（含预训练模型），例如AlexNet、VGG、ResNet等； torchvision.transforms:
torchvision.transforms
weixin_44296865的博客
11-20 1170
torchvision.transforms是pytorch中的图像预处理包,包含了一些常用的图像变换，主要实现对数据集的预处理、数据增强、数据转换成tenser等一系列操作。一般用Compose把多个步骤整合到一起。
可视化pytorch
07-27
你可以使用一些库来可视化 PyTorch 中的数据和模型。下面是一些常用的可视化库和技术： 1. TensorBoardX: 这是一个用于将 PyTorch 数据可视化的库，它是 TensorFlow 的 TensorBoard 的一个兼容版本。你可以使用它来绘制训练过程中的损失曲线、准确率、学习率等。它还支持可视化模型结构、梯度直方图和嵌入向量等功能。 2. Matplotlib: 这是一个广泛使用的绘图库，可以用来绘制各种图形，例如折线图、柱状图、散点图等。你可以使用 Matplotlib 来可视化训练过程中的损失曲线、模型预测结果等。 3. Seaborn: 这是一个基于 Matplotlib 的统计数据可视化库，它提供了更高级的绘图功能。你可以使用 Seaborn 来绘制热力图、分布图、箱线图等，以更直观地分析数据。 4. PyTorch 自带的可视化工具: PyTorch 也提供了一些内置的可视化工具，例如 torchvision.utils.make_grid 函数可以将图像网格化显示，torchvision.transforms.ToPILImage 函数可以将张量转换为图像对象。 这些工具和库可以帮助你在 PyTorch 中进行数据和模型的可视化，提高你对模型训练过程和结果的理解和分析能力。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

iteapoy

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

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

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

打赏作者

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

抵扣说明：

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

余额充值