小白的自我救赎

Dataset类

pytorch数据加载可通过自定义数据集对象实现，数据集对象被抽象为Dataset类，实现自定义数据集需要继承Dataset类，并实现两个python魔法方法。
_len _：使得len(dataset)返回数据集的大小
_getitem _:返回一个样本/一条数据。完成图片的读取工作。
在python类定义中出现 init和self,其作用是什么？
Python中init和self的意义和作用
由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。以学生类为例，通过定义一个特殊的_init _方法，在创建实例的时候，就把name，score等属性绑上去：

Class Student(object):
      def __init__(self,name,score):
      self.name = name
      self.score = score

注意_init _ 方法的第一个参数永远是self，表示创建的实例本身,因此，在_init _方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。有了_init _方法，在创建实例的时候，就不能传入空的参数了，必须传入与_init _方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：
和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。

数据类代码：

class FaceLandmarksDataset(Dataset):#定义类并继承Dataset类
      def __init__(self, csv_file , root_dir, transform=None):
        """
        Args:
            csv_file (string): Path to the csv file with annotations.标签路径
            root_dir (string): Directory with all the images.数据路径
            transform (callable, optional): Optional transform to be applied on a sample.
        """
        self.landmarks_frame = pd.read_csv(csv_file)
        self.root_dir = root_dir
        self.transform = transform#将各种属性通过self就指向创建的实例本身，调用创建类就需要传入这些参数
#即csv_file, root_dir, transform=None等，其他参数可参见Dataset类

    def __len__(self):
        return len(self.landmarks_frame)

    def __getitem__(self, idx):
        if torch.is_tensor(idx):
            idx = idx.tolist()
#当调用此函数时才会真正读图片，root只是指定数据的绝对路径。

        img_name = os.path.join(self.root_dir,
                                self.landmarks_frame.iloc[idx, 0])
        image = io.imread(img_name)
        landmarks = self.landmarks_frame.iloc[idx, 1:]
        landmarks = np.array([landmarks])
        landmarks = landmarks.astype('float').reshape(-1, 2)
        sample = {'image': image, 'landmarks': landmarks}

        if self.transform:
            sample = self.transform(sample)

        return sample

自定义好数据集对象，便可以加载图像

face_dataset = FaceLandmarksDataset(csv_file='faces/face_landmarks.csv',
                                    root_dir='faces/')
face_dataset = FaceLandmarksDataset(csv_file='faces/face_landmarks.csv',
                                    root_dir='faces/')

fig = plt.figure()

for i in range(len(face_dataset)):
    sample = face_dataset[i]#相当于调用face_dataset的__getitem__(i)

    print(i, sample['image'].shape, sample['landmarks'].shape)

    ax = plt.subplot(1, 4, i + 1)
    plt.tight_layout()
    ax.set_title('Sample #{}'.format(i))
    ax.axis('off')
    show_landmarks(**sample)

    if i == 3:
        plt.show()
        break

Transforms

由于实际数据图片的大小都不一样，但在处理神经网络的输入图像的时候都希望它们有一个相对固定的大小。因此，需要一些对图像进行预处理的工作。
Rescale: 缩放图像
RandomCrop: 从图像中随机裁剪，数据增强
ToTensor:将numpy表示的图像转换为torch类表示的图像
用类而不是函数来实现以上这三个功能，主要是考虑到如果用函数的话，每次都需要传入参数，但是用类就可以省掉很多麻烦。我们只需要实现每个类的_call _函数和_init _函数

class Rescale(object):
    """Rescale the image in a sample to a given size.

    Args:
        output_size (tuple or int): Desired output size. If tuple, output is
            matched to output_size. If int, smaller of image edges is matched
            to output_size keeping aspect ratio the same.
    """

    def __init__(self, output_size):
        assert isinstance(output_size, (int, tuple))
        self.output_size = output_size

    def __call__(self, sample):
        image, landmarks = sample['image'], sample['landmarks']

        h, w = image.shape[:2]
        if isinstance(self.output_size, int):
            if h > w:
                new_h, new_w = self.output_size * h / w, self.output_size
            else:
                new_h, new_w = self.output_size, self.output_size * w / h
        else:
            new_h, new_w = self.output_size

        new_h, new_w = int(new_h), int(new_w)

        img = transform.resize(image, (new_h, new_w))

        # h and w are swapped for landmarks because for images,
        # x and y axes are axis 1 and 0 respectively
        landmarks = landmarks * [new_w / w, new_h / h]

        return {'image': img, 'landmarks': landmarks}

class RandomCrop(object):
    """Crop randomly the image in a sample.

    Args:
        output_size (tuple or int): Desired output size. If int, square crop
            is made.
    """

    def __init__(self, output_size):
        assert isinstance(output_size, (int, tuple))
        if isinstance(output_size, int):
            self.output_size = (output_size, output_size)
        else:
            assert len(output_size) == 2
            self.output_size = output_size

    def __call__(self, sample):
        image, landmarks = sample['image'], sample['landmarks']

        h, w = image.shape[:2]
        new_h, new_w = self.output_size

        top = np.random.randint(0, h - new_h)
        left = np.random.randint(0, w - new_w)

        image = image[top: top + new_h,
                      left: left + new_w]

        landmarks = landmarks - [left, top]

        return {'image': image, 'landmarks': landmarks}


class ToTensor(object):
    """Convert ndarrays in sample to Tensors."""

    def __call__(self, sample):
        image, landmarks = sample['image'], sample['landmarks']

        # swap color axis because
        # numpy image: H x W x C
        # torch image: C X H X W
        image = image.transpose((2, 0, 1))
        return {'image': torch.from_numpy(image),
                'landmarks': torch.from_numpy(landmarks)}

pytorch提供了torchvision.transforms.Compose将Rescale和RandomCrop两个变换组合起来，太感人了。。。
例如，我们需要将图像的较短边调整到256，然后从中随机截取224的正方形图像

scale = Rescale(256)
crop = RandomCrop(128)
composed = transforms.Compose([Rescale(256),
                               RandomCrop(224)])

综上，可以把数据加载和Transform集成起来，以前可能是我们先读入数据，然后对数据进行预处理，如裁剪。或者先预处理在读入图像，费时费力。有了torchvision.transforms.Compose便可以动态的读取处理图像。
每次抽取一个样本，都会有以下步骤：
从文件中读取图片；
将转换应用于读入的图片；
由于做了随机选取的操作，还起到了数据增强的效果。
其实只要把Transform的部分作为形参传入dataset就可以了，其他的都不变，利用for循环来依次获得数据集样本

transformed_dataset = FaceLandmarksDataset(csv_file='faces/face_landmarks.csv',
                                           root_dir='faces/',
                                           transform=transforms.Compose([
                                               Rescale(256),
                                               RandomCrop(224),
                                               ToTensor()
                                           ]))
for i in range(len(transformed_dataset)):
    sample = transformed_dataset[i]

DataLoader类

以上已经实现了dataset与transform的合并，也实现了用for循环来获取每一个样本数据，还需要确定:
1.按照batch_size获得批量数据；
2.打乱数据顺序；
3.用多线程multiprocessing来加载数据；
torch.utils.data.DataLoader这个类可以解决了以上所有的问题
按照要求设置DataLoader的参数即可:
第一个参数传入transformed_dataset，即已经用了transform的Dataset实例
第二个参数传入batch_size，表示每个batch包含多少个数据
第三个参数传入shuffle，布尔型变量，表示是否打乱
第四个参数传入num_workers表示使用几个线程来加载数据
如下即实现了DataLoader函数的使用，及批样本数据的展示。

ataloader = DataLoader(transformed_dataset, batch_size=4,
                        shuffle=True, num_workers=4)


# Helper function to show a batch
def show_landmarks_batch(sample_batched):
    """Show image with landmarks for a batch of samples."""
    images_batch, landmarks_batch = \
            sample_batched['image'], sample_batched['landmarks']
    batch_size = len(images_batch)
    im_size = images_batch.size(2)

    grid = utils.make_grid(images_batch)
    plt.imshow(grid.numpy().transpose((1, 2, 0)))

    for i in range(batch_size):
        plt.scatter(landmarks_batch[i, :, 0].numpy() + i * im_size,
                    landmarks_batch[i, :, 1].numpy(),
                    s=10, marker='.', c='r')

        plt.title('Batch from dataloader')

for i_batch, sample_batched in enumerate(dataloader):
    print(i_batch, sample_batched['image'].size(),
          sample_batched['landmarks'].size())

    # observe 4th batch and stop.
    if i_batch == 3:
        plt.figure()
        show_landmarks_batch(sample_batched)
        plt.axis('off')
        plt.ioff()
        plt.show()
        break

总结，对于普通数据，如何加载：
1.首先，定义数据集的类（myDataset），这个类要继承dataset这个抽象类，并实现_len _以及_getitem _这两个函数，通常情况还包括初始函数_init _.

2.实现用于特定图像预处理的功能，并封装成类。当然常用的一些变换可以在torchvision中找到。用torchvision.transforms.Compose将它们进行组合成(transform)

3.transform作为上面myDataset类的参数传入，并得到实例化myDataset得到（transformed_dataset）对象。

4.最后，将transformed_dataset作为torch.utils.data.DataLoader类的形参，并根据需求设置自己是否需要打乱顺序，批大小...