Pytorch数据加载的分析

最新推荐文章于 2024-04-09 09:44:59 发布
最新推荐文章于 2024-04-09 09:44:59 发布
阅读量600 收藏 2
点赞数 1
分类专栏： 学习记录
原文链接：https://blog.csdn.net/lgzlgz3102/article/details/107241414?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162641785916780262595706%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=162641785916780262595706&biz_id=0&utm_med
版权

转载自作者公众号机器学习与生成对抗网络
https://blog.csdn.net/lgzlgz3102/article/details/107241414

 知乎作者  巽二

https://zhuanlan.zhihu.com/p/100762487

Pytorch数据加载的效率一直让人头痛，此前我介绍过两个方法，实际使用后数据加载的速度还是不够快，我陆续做了一些尝试，这里做个简单的总结和分析。

1、定位问题

在优化数据加载前，应该先确定是否需要优化数据加载。数据读取并不需要更快，够快就好。一般的，显存占用率很高，利用率却很低的时候，通常会怀疑是数据加载太慢导致，但不是唯一原因，比如模型内大量的循环也会导致GPU利用率低。可以尝试固定数据看看是否可以提高GPU利用率。

确定数据加载需优化后，需要判断是数据加载的哪一部分慢。整个数据处理的流程如下：

  • 读取图片数据（IO，可能存在IO瓶颈）

  • 解码数据（一般是numpy格式，可能存在计算性能瓶颈）

  • 数据增强（可能存在计算性能瓶颈）

  • 类型变换（CPU->GPU，，可能存在数据拷贝瓶颈）

为节省阅读时间，先给结论，数据加载慢主要是由于计算性能的瓶颈，而不是IO瓶颈和数据拷贝瓶颈（测试数据为1920x1080的大图，小图片可能结论不同）。为优化加载速度应该从两个方向下手：

  • 更快的图片解码

  • 更快的数据增强

  • 更强性能的设备，如使用GPU进行数据解码和增强（DALI库）

下面是具体的实验分析，测试环境和数据如下：

  • CPU: Intel(R) Xeon(R) CPU E5-2698 v4 @ 2.20GHz (正常负载，利用率小于30%)

  • GPU: V100 (正常负载，利用率小于30%)

  • 数据集数据840张，尺寸为1920x1080

  • batch size = 64

  • 无特别说明下num_workers=2

  • 迭代10个epoch（13x10个迭代次数）

2. Baseline

不进行任何额外优化下的速度如下：

其中：

  • 无任何额外操作的输出图片为原始大小（1920x1080）

  • 归一化的具体操作为：x = x.permute(0, 3, 1, 2).float().div(255)

  • 转GPU的具体操作为：x = x.cuda()

  • resize为opencv的resize，插值方式为 cv2.INTER_LINEAR

  • 数据增强的操作使用Numpy和Opencv，包括：

  • random resize

  • random crop

  • random filp

  • random HSV

可以明显的看出耗时主要发生在数据读取和数据增强部分，而CPU到GPU的数据转换等耗时较少。

需要注意的一个地方是【crop(8960x540)、转GPU、归一化】和【转GPU、归一化】的耗时差不多，crop的耗时很小，且crop后图片较小，使得转GPU的操作也变快了，最终二者的耗时差不多。

分析将分为以下几个部分：DataLoader 图片读取 * 数据增强

此外由于【CPU转GPU、数据的归一化转秩】和【DataLoader】比较相关，会一起分析。

3. DataLoader

(1) num_workers

显然的是num_workers并不是越多越好，瓶颈在CPU，太多的数据worker不光不能提升，还会占用过多的CPU资源，影响其他程序的速度。

(2) pin_memory

定义DataLoader时单纯的pin_memory无用。

(3) non_blocking

谈到pin_memory就不得不说一下non_blocking=true操作，先来看一下过程吧：


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     1. x = x.cuda(non_blocking=True)
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     2. 进行一些和x无关的操作
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     3. 执行和x有关的操作

在non_blocking=true下，1不会阻塞2，1和2并行。但我们已经知道x.cuda()实际上耗时并不多（181s -> 194s，并不算是耗时的主要原因，就算去掉也不能加速太多。

一个比较常见的用法如下：


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     class DataPrefetcher():    def __init__(self, dataset, batch_size=
     
     64, shuffle=True, num_workers=
     
     2):        self.data_loader = DataLoader(            dataset=dataset,            batch_size=batch_size,            shuffle=shuffle,            pin_memory=True,            num_workers=num_workers,            drop_last=True)        self.loader = iter(self.data_loader)        self.stream = torch.cuda.Stream()        self.preload()
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         def preload(self):        try:            self.next_x, self.next_y = next(self.loader)        except StopIteration:            self.loader = iter(self.data_loader)            self.next_x, self.next_y = next(self.loader)        with torch.cuda.stream(self.stream):            self.next_x = self.next_x.cuda(non_blocking=True)            self.next_y = self.next_y.cuda(non_blocking=True)            self.next_x = self.next_x.permute(
     
     0, 
     
     3, 
     
     1, 
     
     2).float().div(
     
     255)            self.next_y = self.next_y.float()
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         def next(self):        torch.cuda.current_stream().wait_stream(self.stream)        data = (self.next_x, self.next_y)        self.preload()        
     
     return data

DataPrefetcher对DataLoader又包了一层，需要注意pin_memory=True时non_blocking=true才才生效，next()函数直接返回data而无需等待cuda()。实验结果如下，和预期的差不多，并无明显的改善。

说到cuda()，有个小细节需要注意：


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     1. x = x.cuda().permute(0, 3, 1, 2).
     
     float().div(255)
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     2. x = x.permute(0, 3, 1, 2).
     
     float().div(255).cuda()
    
    
    
   
   

 
 
这两种方式的耗时是不一样的

4. 读取图片

读取图片实际上包括了两部分，一个是图片数据读进内存，一个是图片的解码。耗时主要在图片的解码上，常见的优化方法主要是转换图片的格式（如lmdb）、使用解码更快的库。

(1) lmdb 先分析一下lmdb，一个jpg转lmdb的例子：


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     import numpy as npimport cv2import osimport lmdb
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     list_path = 
     
     "img_list/test.txt"img_root = 
     
     './data/test/edu/test/JPEGImages'img_type = 
     
     ".jpg"label_root = 
     
     './data/test/edu/test/labels'label_type = 
     
     ".txt"
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     env_db = lmdb.open(
     
     "./test", map_size=
     
     1024*
     
     1024*
     
     1024*
     
     8)txn = env_db.begin(write=True)
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     for line in open(list_path):    img_name = line.strip() + img_type    img_path = os.path.join(img_root, img_name)    img = cv2.imread(img_path)
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         label_name = line.strip() + label_type    label_path = os.path.join(label_root, label_name)    label = np.loadtxt(label_path).reshape(
     
     -1, 
     
     5)
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     print(img_name)
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         # txn.put(img_name.encode(), img) ### 不编码    txn.put(img_name.encode(), cv2.imencode(
     
     '.jpg', img)[
     
     1])    txn.put(label_name.encode(), label)
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     txn.commit()env_db.
     
     close()

使用cv2.imencode('.jpg', img)对图片数据进行了编码，不然会非常大，840张图片jpg大小为350MB，lmdb不编码为4.86GB。

这里插一句，lmdb文件大小为实际使用大小且小于map_size，但window下生成lmdb大小不正常为map size大小，读取一下后会变成实际大小。

读取的操作如下：


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     img = np.frombuffer(self.txn.get(img_path.encode()), dtype=np.
     
     uint8)
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     img = cv2.imdecode(img, cv2.IMREAD_COLOR)
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     label = np.frombuffer(self.txn.get(label_path.encode())).reshape(
     
     -1, 
     
     5) #lmdb存储后numpy会丢失形状

实验结果如下：

使用lmdb并没加速效果，实际上IO读取无任何优势，只是无解码时省掉了解码时间，但空间占用太多。

(2) hdf5

和lmdb类似的是hdf5，不压缩同样很大（4.86GB），但使用起来感觉较方便但存在一些bug不建议使用：


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     f = h5py.File(
     
     'test.h5', 
     
     'w')img_dataset = f.create_dataset(
     
     'img', shape=(
     
     840, 
     
     1080, 
     
     1920, 
     
     3), maxshape=(None, 
     
     1080, 
     
     1920, 
     
     3), chunks=(
     
     1, 
     
     1080, 
     
     1920, 
     
     3), dtype=np.
     
     uint8)
     
     for i, line in enumerate(open(list_path)):    img_name = line.strip() + img_type    img_path = os.path.join(img_root, img_name)    img = cv2.imread(img_path)    img_dataset[i, :] = img    
     
     print(img_name, img.shape)f.
     
     close()
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     ### read，h5的多线程读写存在问题，使用压缩无法正常使用f = h5py.File(
     
     'test.h5', 
     
     "r", swmr=True)# f = h5py.File(
     
     'test.h5', 
     
     "r")
     
     for i in 
     
     range(
     
     840):    img = f[
     
     "img"][i, ...]

没有编解码，速度还是有优势的，同时也印证了瓶颈在解码上：

(3) libjpeg-turbo

解码更快的库，主要是使用libjpeg-turbo，分享两个python的封装，jpeg4py和PyTurboJPEG。比较推荐的是PyTurboJPEG，可以指定so位置和缩放图片。

加速非常明显，推荐使用，但这个库比较吃CPU资源，worker开多之后会很卡。

(4) mxnet

mxnet的读取也测试了一下，测试时机器CPU占用发生变化，【数据增强、转GPU、归一化、libjpeg-turbo 】重新测试了一下，速度上无优势。

(5) opencv缩小比例读取

此外，opencv在读取图片时也可以指定缩小比例（1/2，1/4，1/8），提速明显，对部分需要固定缩放的比较友好：


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     img = cv2.imread(img_path, cv2.IMREAD_REDUCED_COLOR_2)
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     img = cv2.imread(img_path, cv2.IMREAD_REDUCED_COLOR_4)
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     img = cv2.imread(img_path, cv2.IMREAD_REDUCED_COLOR_8)

5. 数据增强

(1) 建议 这里先给大家一些建议：

  • opencv一般要比 PIL 快

  • 由于数据增强操作基本是opencv的内置函数，因此cuda的@jit加速是无效的，Cython应该也无加速效果。几个操作的耗时排列应该是这样的，opencv <Cython <jit <pyhton。

  • cv2.UMat()加速几乎无效，测试与不使用无差别，本地测试单图反而比不使用耗时长。

  • 由于图片数据为0~255，部分数值变换可以使用cv2.LUT()查找表直接映射,避免多次计算数值。

  • 尽量提前做好数据处理，减少预处理步骤。

(2) DALI 如果加速还不满意的话，最后还有一个大招，DALLI库，大力出奇迹，极度推荐。我们已经知道瓶颈在CPU的性能上，把这些计算放到GPU上是很合理的。NVIDIA DALI是一个GPU加速的数据增强和图像加载库，支持单个和批处理图像的解码、缩放、Crop、颜色空间转换等，具体支持的操作。

使用DALI完成所有操作的时间如下：

只要我数据加载的够快，GPU就追不上我。加载的部分和pytorch差不多，出来就是gpu的tensor，具体的代码较多，就不放在本文里了。


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     pipeline = DataPipeline(**dataset_dict)pipeline.build()loader = DALIGenericIterator(pipeline, [
     
     "imgs", 
     
     "labels"], img_len, fill_last_batch=False)
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     for j in 
     
     range(epoch):  
     
     for i, data in enumerate(loader):    x = data[
     
     0][
     
     "imgs"]    y = data[
     
     0][
     
     "labels"].cuda()    # train  loader.reset()
    
    
    
   
   

 
 

 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     猜您喜欢
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      戳我，查看GAN的系列专辑~！
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     CVPR 
     
     2020之
     
     117篇GAN论文分类汇总清单
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     2020年
     
     6月
     
     100篇GAN论文汇总
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     2020年
     
     5月
     
     60篇GAN论文汇总
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     超
     
     100篇！CVPR 
     
     2020最全GAN论文梳理汇总！
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     拆解组新的GAN：解耦表征MixNMatch
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     StarGAN第
     
     2版：多域多样性图像生成
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     附下载 | 《可解释的机器学习》中文版
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     附下载 |《TensorFlow 
     
     2.0 深度学习算法实战》
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     附下载 |《计算机视觉中的数学方法》分享
    
    
    
   
   
  17.
1015号居民
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
情感分析-火炬：IMDb数据集上的火炬情感分析
02-04
目录第一个笔记本涵盖了从原始数据集中加载数据，特征提取和分析，文本预处理以及训练/验证/测试集准备的过程。第二篇教程包含有关如何设置词汇对象的说明，该对象将负责以下任务： 创建数据集的词汇表。 根据稀有词...
pytorch permute维度转换方法
12-25
permute prediction = input.view(bs, self.num_anchors, self.bbox_attrs, in_h, in_w).permute(0, 1, 3, 4, 2).contiguous() 转置： import torch x = torch.linspace(1, 9, steps=9).view(3, 3) b=x.permute(1,0) print(b) print(b.permute(1,0)) 以上这篇pytorch permute维度转换方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持软件开发网
permute()函数
weixin_45135154的博客
07-03 462
import torch a = torch.randn(3,2,4) b = a.permute(1,2,0) print(a) print("a.shape", a.shape) print("(3,2,4)-->(2,4,3)") print(b) print("b.shape", b.shape) tensor([[[-0.3183, 1.2260, 0.4502, 1.1955], [ 0.0197, -0.7851, 0.0231, -1.3826]],
Pytorch permute()的简单用法
xiongxyowo的博客
01-18 777
作用：调换Tensor中各维度的顺序 输入：数组，用来表示调换后的各维度顺序。一开始没修改的顺序其实就是[0，1，2…] 例子：有一个6×7×8×9的Tensor，我们想将其第2维(8)和第三维(9)给调换顺序 import torch x = torch.empty([6, 7, 8, 9]) print(x.size()) x = x.permute([0, 1, 3, 2]) print(x.size()) 输出： torch.Size([6, 7, 8, 9]) torch.Size([6, 7
Pytorch 最全入门介绍，Pytorch入门看这一篇就够了_pytorch csdn
最新发布
m0_58477260的博客
04-09 1030
在这一部分，我们将会对Pytorch做一个简单的介绍，包括它的历史、优点以及使用场景等。DataLoader类提供了对数据集的并行加载，可以有效地加载大量数据，并提供了多种数据采样方式。常用的参数有：dataset：加载的数据集（Dataset对象）batch_size：batch大小shuffle：是否每个epoch时都打乱数据num_workers：使用多进程加载的进程数，0表示不使用多进程# 数据转换])# 下载并加载训练集# 下载并加载测试集。
permute
qq_51753728的博客
08-24 119
操作可以帮助我们重新排列数组的维度，以满足特定计算或数据处理需求。以下是一个具体的例子，假设我们有一个表示图像数据的张量，其维度为。，这样我们就能够更方便地在深度学习模型中使用这个张量，尤其是在需要对通道维度进行操作的情况下，比如卷积操作。操作允许我们在不改变数据本身的情况下，重新组织张量的维度，以适应特定的计算需求或模型结构。，其中 32 是批量大小，64x64 是图像尺寸，3 是 RGB 通道。，我们可能希望将通道维度与高度维度交换，以便在某些操作中更方便。当涉及到多维数组（如张量）时，
【input.view().permute().contiguous()】 Pytorch中tensor.view().permute().contiguous()函数理解
计算机视觉方面的点点滴滴，欢迎一起讨论
04-07 1626
文章目录1 何处用到2 view()3 permute()4 contiguous()5 感谢链接 1 何处用到 yolov3中有一行这样的代码，在此记录一下三个函数的含义 例子中batch_size为int，len(self.anchors_mask[i])=3，self.bbox_attrs=25(voc数据集)，input_height, input_width两个参数也均为int。 prediction = input.view(batch_size, len(self.anchors_mask[i
torch中permute()函数用法
热门推荐
ac不知深的博客
10-18 4万+
前言：本文只讨论二维三维中的permute用法 最近的Attention学习中的一个permute函数让我不理解 这个光说太抽象 我就结合代码与图片解释一下 首先创建一个三维数组小实例 import torch x = torch.linspace(1, 30, steps=30).view(3,2,5) # 设置一个三维数组 print(x) print(x.size()) # 查看数组的维数 这里为了防止出现维数数值相同的巧合局面（例如三维数组（3,3,3）或者（2,4,4）等） 输出
Pytorch项目实战 ：基于RNN的实现情感分析
02-22
Pytorch项目实战 ：基于RNN的实现情感分析 ├──1 Word2Sequence的初始化函数.mp4 31.70M ├──10 RNN模型的预测.mp4 20.75M ├──11 循环神经网络基本原理和模型改进.mp4 67.78M ├──2 语料库词频统计.mp4 26....
PyTorch的语音工具包
03-14
1. **音频数据加载**： - torchaudio可以方便地加载多种格式的音频文件，如WAV、MP3、FLAC等，并将其转换为PyTorch的Tensor格式，便于后续在模型中使用。 2. **音频变换**： - torchaudio提供了一系列音频信号...
胶囊网络python-pytorch版本
05-24
胶囊网络python-pytorch版本，参考博客：https://blog.csdn.net/m0_46384757/article/details/121559514
Pytorch中的语义分割
03-14
在PyTorch中，语义分割是一种计算机视觉任务，旨在将图像中的每个像素分配到对应的语义类别上，实现对图像中不同物体和区域的像素... - 使用PyTorch中的 DataLoader 加载数据集，定义模型、优化器和损失函数，......
PyTorch 模型性能分析和优化 - 第 3 部分
冷冻工厂
08-29 770
例如，在布尔掩码的情况下，如果我们的掩码非常稀疏并且原始张量非常大，那么应用掩码所节省的计算量可能会超过主机设备同步的成本。这里的 PyTorch 文档不太友好，但根据我们之前的经验，我们可以假设，由于我们使用了大小不确定的张量，我们再次遭受主机设备同步事件的困扰。然而，在我们的例子中，我们实际上不需要知道唯一标签的值，我们只需要知道唯一标签的数量。在我们的玩具示例中，我们能够找到有问题的运算符的等效替代方案，这些运算符使用固定大小的张量并避免需要同步事件。那么，话不多说，让我们看看我们的模型的表现如何。
Pytorch基础 - 7. torch.transpose() 和 torch.permute()
Aaron_neil的博客
04-14 2368
按照上面数组的方式进行理解，x的原维度表示数组 array = [3, 4, 5, 8]，转置后的维度 = [array[1], array[0], array[3], array[2]] = [4, 3, 8, 5]就是把原来的维度比作一个数组 list=[3, 4]，permute中的数表示数组对应的index，则转置后的x为 [list[1], list[0]] = [4, 3]示例：将shape为[3, 4]的张量，通过transpose()转换成维度为[4, 3]的张量。示例1：进行二维转置。
python中permute_PyTorch中permute的用法详解
weixin_39991055的博客
12-10 2032
PyTorch中permute的用法详解permute(dims)将tensor的维度换位。参数：参数是一系列的整数，代表原来张量的维度。比如三维就有0，1，2这些dimension。例：import torchimport numpy as npa=np.array([[[1,2,3],[4,5,6]]])unpermuted=torch.tensor(a)print(unpermuted.si...
torch中permute()函数的结果怎么从原张量来的
凉面&凉粉的博客
08-24 674
理解pytorch的permute函数的变换
Pytorch使用permute后再reshape会修改张量的值，维度虽然对齐但仍需小心
qq_43601378的博客
09-26 757
permute函数和reshape函数
学习笔记1——常用的注意力机制（即插即用）
daige123的博客
07-12 1万+
常用的即插即用的注意力机制原理及代码
Reshape与Permute的踩坑记录
ODIMAYA的博客
04-01 1786
最近做简单的网络训练，需要自写DataLoader，涉及到了图像数据的预处理，主要集中在getItem()函数里面。 上代码： 由于用到了BCEWithLogitsLoss，这个损失函数要求label与pred的维度保持一致，即label也需要有channel这一维度，所以涉及到了reshape与permute两个函数 这里不用to_tensor,不需要归一化，因此需要手动处理维度 先用reshape，再astensor image = cv2.imread(image_path) label = cv2.
pytorch数据分析
06-10
1.数据加载：使用PyTorch中的DataLoader加载数据集，可以使用torchvision.datasets获取许多常用的数据集。 2.数据清洗：对数据进行清洗和预处理，以确保数据集适合模型的输入。 3.模型构建：在PyTorch中构建模型，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值