Pytorch加载本地自己整理好的cifar10数据集，并进行训练

*
– 1.下载数据集
– 2.解压
– 3.复制移动
– 4.修改tv.datasets.CIFAR10源码

使用pytorch在线下载cifar10数据集时，经常报错，而且很慢，倘若下载cifar100,那等待时间可想而知了。为了不浪费时间等待，可以将数据集先下载到本地，在自行加载，下面介绍一种修改源码简单的方法。

1.下载数据集

（随意下载，官网地址：http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz）**

下载以后会有三种，根据你的需求选取一种，我用的是python语言。

; 2.解压

把cifar-10-python.tar.gz解压，得到如下所示目录

3.复制移动

将解压后的cifar-10-python文件内容复制到自己工程下的一个文件夹里（自己随意新建一个数据集文件夹即可）

; 4.修改tv.datasets.CIFAR10源码

如下，可以把“base_folder = ‘cifar-10-batches-py'” 修改成你自己建立的数据集文件夹名称，我这里直接跟它一样了。可以注释掉url 和filename,使用已经下载好的数据集不需要这两个。其中tgz_md5也可注释掉，MD5是一种消息摘要加密算法，torch使用这个估计是为了下载数据集时防止木马病毒入侵篡改文件，由于我们已经下载好，故不需要了。接下来注释掉以下内容。（这些代码是检验数据集的存在和下载数据集的，我们使用本地数据集就不需要这些了）

完整注释如下

class CIFAR10(VisionDataset):

    base_folder = 'cifar-10-batches-py'

    tgz_md5 = 'c58f30108f718f92721af3b95e74349a'
    train_list = [
        ['data_batch_1', 'c99cafc152244af753f735de768cd75f'],
        ['data_batch_2', 'd4bba439e000b95fd0a9bffe97cbabec'],
        ['data_batch_3', '54ebc095f3ab1f0389bbae665268c751'],
        ['data_batch_4', '634d18415352ddfa80567beed471001a'],
        ['data_batch_5', '482c414d41f54cd18b22e5b47cb7c3cb'],
    ]

    test_list = [
        ['test_batch', '40351d587109b95175f43aff81a1287e'],
    ]
    meta = {
        'filename': 'batches.meta',
        'key': 'label_names',
        'md5': '5ff9c542aee3614f3951f8cda6e48888',
    }

    def __init__(
            self,
            root: str,
            train: bool = True,
            transform: Optional[Callable] = None,
            target_transform: Optional[Callable] = None,
            download: bool = False,
    ) -> None:

        super(CIFAR10, self).__init__(root, transform=transform,
                                      target_transform=target_transform)

        self.train = train

        if download:
            self.download()

        """if not self._check_integrity():
            raise RuntimeError('Dataset not found or corrupted.' +
                               ' You can use download=True to download it')"""

        if self.train:
            downloaded_list = self.train_list
        else:
            downloaded_list = self.test_list

        self.data: Any = []
        self.targets = []

        for file_name, checksum in downloaded_list:
            file_path = os.path.join(self.root, self.base_folder, file_name)
            with open(file_path, 'rb') as f:
                entry = pickle.load(f, encoding='latin1')
                self.data.append(entry['data'])
                if 'labels' in entry:
                    self.targets.extend(entry['labels'])
                else:
                    self.targets.extend(entry['fine_labels'])

        self.data = np.vstack(self.data).reshape(-1, 3, 32, 32)
        self.data = self.data.transpose((0, 2, 3, 1))

        self._load_meta()

    def _load_meta(self) -> None:
        path = os.path.join(self.root, self.base_folder, self.meta['filename'])
        """if not check_integrity(path, self.meta['md5']):
            raise RuntimeError('Dataset metadata file not found or corrupted.' +
                               ' You can use download=True to download it')"""
        with open(path, 'rb') as infile:
            data = pickle.load(infile, encoding='latin1')
            self.classes = data[self.meta['key']]
        self.class_to_idx = {_class: i for i, _class in enumerate(self.classes)}

    def __getitem__(self, index: int) -> Tuple[Any, Any]:
"""
        Args:
            index (int): Index

        Returns:
            tuple: (image, target) where target is index of the target class.

"""
        img, target = self.data[index], self.targets[index]

        img = Image.fromarray(img)

        if self.transform is not None:
            img = self.transform(img)

        if self.target_transform is not None:
            target = self.target_transform(target)

        return img, target

    def __len__(self) -> int:
        return len(self.data)

    def extra_repr(self) -> str:
        return "Split: {}".format("Train" if self.train is True else "Test")
"""   def _check_integrity(self) -> bool:
        root = self.root
        for fentry in (self.train_list + self.test_list):
            filename, md5 = fentry[0], fentry[1]
            fpath = os.path.join(root, self.base_folder, filename)
            if not check_integrity(fpath, md5):
                return False
        return True

    def download(self) -> None:
        if self._check_integrity():
            print('Files already downloaded and verified')
            return
        download_and_extract_archive(self.url, self.root, filename=self.filename, md5=self.tgz_md5)"""

如果使用的是cifar100数据集也是一样修改的方法。处理完以后就可以加载训练了，以下是我用CPU跑的LeNet+cifar10，无障碍正常运行。

import torch as t
import torch.nn as nn
import numpy as np
from torch.autograd import Variable
from torch.nn import functional as F
import torchvision as tv
import torchvision.transforms as transforms
from torchvision.transforms import ToPILImage
show = ToPILImage()
from torch import optim

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])

trainset = tv.datasets.CIFAR10(
    root='G:\PYTHONtest\wan\data',
    train=True,
    download=False,
    transform=transform,
)

trainloader = t.utils.data.DataLoader(
    trainset,
    batch_size=4,
    shuffle=True,
    num_workers=2,
)

testset = tv.datasets.CIFAR10(
    'G:\PYTHONtest\wan\data',
    train=False,
    download=False,
    transform=transform,
                              )

testloader = t.utils.data.DataLoader(
    testset,
    batch_size=4,
    shuffle=False,
    num_workers=2,
)

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)

        self.fc1 = nn.Linear(16*5*5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(x.size()[0], -1)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
if __name__ == '__main__':
    for epoch in range(60):
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            inputs, labels = data
            inputs, labels = Variable(inputs), Variable(labels)
            optimizer.zero_grad()

            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            running_loss += loss.item()
            if i % 2000 == 1999:
                print('[%d, %5d] loss: %.3f' \
                      % (epoch + 1, i+1, running_loss / 2000))
                running_loss = 0.0
    print('Finished Training')

Original: https://blog.csdn.net/qq_43448116/article/details/121364771
Author: 鳌拜他哥熬夜
Title: Pytorch加载本地自己整理好的cifar10或cifar100数据集，并进行训练

---

---

相关阅读

Title: 单目深度估计–深度学习篇

文章目录

• 一：深度估计应用背景
  *
• 1.深度估计的定义
• 2.深度估计的应用场景
• 3.几种深度估计的方法
• 4.使用深度学习估计的优缺点
• 二：单目深度估计模型
  *
• 1.使用的数据集
• 2.整体网络架构
• 3.分模块解析
  –
  • Ⅰ：层级
  • Ⅱ：ASPP
  • Ⅲ：特征图减法操作
  • Ⅳ：特征融合
  • Ⅴ：Coarse-to-Fine
  • Ⅵ：权重参数预处理WS与pre_act操作
  • Ⅶ：损失函数

一：深度估计应用背景

1.深度估计的定义

假设我们有一张2d图片I I I,我们需要一个函数 F F F 来求取其相对应的深度d d d．这个过程可以写为：

d = F ( I ) d = F(I)d =F (I )

这里的深度信息d d d其实就代表着 由3D物体投射而来的2D图像中每个像素点与相机的实际距离。

但是众所周知, F F F是非常复杂的函数，因为从单张图片中获取具体的深度相当于从二维图像推测出三维空间，即使人眼在两只眼睛来定位自然世界的物体的情况下也依然会有问题存在，更何况使用单张照片了。所以传统的深度估计在单目深度估计上效果并不好，人们更着重于研究立体视觉 (Stereo Vision)，即从多张图片中得到深度信息．因为两张图片就可以根据视角的变化得到图片之间disparity的变化，从而达到求取深度的目的。话说多了，先往后看。

2.深度估计的应用场景

除了上面两张图片中提到的应用场景，深度估计还可以运用于3D重建，障碍物检测，SLAM等一系列需要深度信息的下游任务中。因此， 可见深度估计往往作为上游任务存在，重要性不言而喻。

; 3.几种深度估计的方法

• 利用激光雷达或结构光在物体表面的反射获取深度点云
  这种方法可谓是”土豪法”，直接利用传感器扫一扫，便可获得高精度点云深度信息，但是价格昂贵！
• 传统的双目测距
  双目立体视觉，由两个摄像头组成，像人的眼睛能看到三维的物体，获取物体长度、宽度信息，和深度的信息。摄像头的位置是一般手动标定（比如张正友相机标定算法），然后通过目标点在图像坐标系和世界坐标系中的位置来推导相机内外参数矩阵的过程，往往是一个坐标转换的过程。
• 传统的单目测距
  单目视觉是能获取二维的物体信息，即长度、宽度，所以如果想要测距，需要拍摄出几张不同角度（时序）的图像，再通过Mobileye单目测距等一系列方法，进行求解。同时，计算量复杂，而且精度不如双目高，往往是在条件艰难的时候使用。

4.使用深度学习估计的优缺点

前面铺垫完了几种传统领域的几种常见方法，现在开始聊聊今天的主角–深度学习单目估计。顾名思义，深度学习深度学习，第一反应End2End，把图像往训练好的网络里一扔，不需要任何人工参与，直接得出最后的深度图，一个词， 方便！同时，我们只需要单目相机，一个词， 成本低！

那有什么缺点呢，首先是80m以内的深度估计精度还行，但是再远误差就很大了，可见 精度低、估计距离局限性，都是它的缺点。当然，还有一个深度学习一直绕不走的问题， 需要大量训练集，在一些缺少训练数据的环境里显然是不容忽视的问题。

但是毕竟和时代前沿技术搭边了，咱们就来好好唠一唠，下面进入正题。

二：单目深度估计模型

1.使用的数据集

这里讲解的深度估计模型，使用的是 KITTI数据集，取景于城市、乡村的道路上，该数据集 在多个研究领域内被广泛使用，具体见下图：

; 2.整体网络架构

深度估计模型是输入一张图像，输出一张包含深度信息的图片，所以 是一种生成模型，那么必然离不开编码和解码这个核心过程了，见下图：

当然，真正的网络架构没有这么简单，但都是围绕编码-解码进行的，下面展示CVPR最近发布的一种网络架构，我将逐模块地讲解这个”庞然大物”：

3.分模块解析

Ⅰ：层级

其实就是经过几层池化后，每次缩一半，这里的backbone使用的是Resnet101。和U-net等网络的操作相似，主要是为了后面的操作，如图：

; Ⅱ：ASPP

作者在backbone的最后一个特征图做了ASPP，这里什么是ASPP不再赘述了，就是 空洞卷积和SPP的结合，之所以用ASPP 目的就是加点特征多样性，同时保留一定的分辨率（也是图像分割领域常规操作）。如图所示：

Ⅲ：特征图减法操作

在深度估计研究领域，物体的轮廓深度信息是一个挑战，作者为了有效解决这个问题， 进行了神操作，将两张特征图A − B A-B A −B相减（特征图B是上采样后和A一样尺寸的特征图），提取出了差异特征，得到轮廓特征图L。如下图：

; Ⅳ：特征融合

进行一顿叠加， 首先充分利用高层特征图与本层特征图的融合，得到中间特征图X，来增加特征的多尺度性。 接着拼接高层的预测结果R”和本层的轮廓图L，大杂烩乱炖后得到本层预测结果R。每层都是这样操作，如图所示：

Ⅴ：Coarse-to-Fine

最后是细节”雕琢”的阶段，对每一层的R进行融合，得到最后的预测结果R”’，如图所示：

; Ⅵ：权重参数预处理WS与pre_act操作

在真个网络中还加入了一些细节，首先是加入了权重标准化 WS操作，让权重参数分布更均匀一些，不然经过ReLU后大量权重会被杀死（笔者提出疑问，那这样为什么不换一下激励函数，比如Mish，Leaky ReLU，Swish啥的？？），接着还加入了 pre_act，就是先对x进行ReLU,然后再进入卷积层，比较佛系，对于他们的实验，确实准确度有了质的飞跃，如下图所示：

Ⅶ：损失函数

化简后的损失函数中的 d d d 其实就是每个像素点预测深度和真实深度的差值，重点是后面的d i d j di dj d i d j求和是什么意思，前面为什么还加了个负号。举个例子，大家就理解了，找出两个像素点，预测值和真实值的差值分别是d 1 d1 d 1和d 2 d2 d 2，如果两个差值都是负数，那么相乘是个正值，前面加个负号，那么代表不被惩罚，相反的如果两者异号则被惩罚。可见损失函数中这一项的目的是，希望得到的预测值要么都是低了一点，要么都高了一点，而不是这里预测大了，那里预测小了，这样效果其实更糟糕，模型更不可靠。

至此我对利用深度学习进行单目深度估计的原理，进行了简单讲解，希望对大家有所帮助，有不懂的地方或者建议，欢迎大家在下方留言评论。

我是努力在CV泥潭中摸爬滚打的江南咸鱼，我们一起努力，不留遗憾！

Original: https://blog.csdn.net/weixin_43702653/article/details/123831009
Author: 江南綿雨
Title: 单目深度估计–深度学习篇