该节博客主要讲解网络的训练流程，以及其中的代码阅读与学习。主要涉及数据的读取与处理和模型的训练，涉及文件有data_loaders.py。

首先我们先来阅读data_loaders.py文件中的代码，了解整个数据读取和处理的流程。

1. 数据的处理流程（data_loaders.py）

  1. def mch(**kwargs):
  2.     return munch.Munch(dict(**kwargs))
  4. def configure_metadata(metadata_root):
  5.     metadata = mch()
  6.     metadata.image_ids = os.path.join(metadata_root, 'image_ids.txt')
  7.     metadata.image_ids_proxy = os.path.join(metadata_root,
  8.                                             'image_ids_proxy.txt')
  9.     metadata.class_labels = os.path.join(metadata_root, 'class_labels.txt')
  10.     metadata.image_sizes = os.path.join(metadata_root, 'image_sizes.txt')
  11.     metadata.localization = os.path.join(metadata_root, 'localization.txt')
  12.     return metadata

以上是读取数据.txt文件的函数，一般txt文本存储着图片的路径，名称（id），标签（label）等的数据形式，截图如下：
image.png
以上的代码就是把路径复制给字典变量。

1）def get_image_ids(metadata, proxy=False)

  1. def get_image_ids(metadata, proxy=False):
  2.     """
  3.     image_ids.txt has the structure
  5.     <path>
  6.     path/to/image1.jpg
  7.     path/to/image2.jpg
  8.     path/to/image3.jpg
  9.     ...
  10.     """
  11.     image_ids = []
  12.     suffix = '_proxy' if proxy else ''
  13.     with open(metadata['image_ids' + suffix]) as f:
  14.         for line in f.readlines():
  15.             image_ids.append(line.strip('\n'))
  16.     return image_ids

处理image_ids.txt文件，内容如下：
image.png
把每一行的图片的id存储到一个list里面。这里都比较简单。

2）def get_class_labels(metadata)

  1. def get_class_labels(metadata):
  2.     """
  3.     image_ids.txt has the structure
  5.     <path>,<integer_class_label>
  6.     path/to/image1.jpg,0
  7.     path/to/image2.jpg,1
  8.     path/to/image3.jpg,1
  9.     ...
  10.     """
  11.     class_labels = {}
  12.     with open(metadata.class_labels) as f:
  13.         for line in f.readlines():
  14.             image_id, class_label_string = line.strip('\n').split(',')
  15.             class_labels[image_id] = int(class_label_string)
  16.     return class_labels

返回数据类型为一个字典，字典的key为image_id，value为class_labels。如图所示：
image.png

3）def get_bounding_boxes(metadata)

  1. def get_bounding_boxes(metadata):
  2.     """
  3.     localization.txt (for bounding box) has the structure
  5.     <path>,<x0>,<y0>,<x1>,<y1>
  6.     path/to/image1.jpg,156,163,318,230
  7.     path/to/image1.jpg,23,12,101,259
  8.     path/to/image2.jpg,143,142,394,248
  9.     path/to/image3.jpg,28,94,485,303
  10.     ...
  12.     One image may contain multiple boxes (multiple boxes for the same path).
  13.     """
  14.     boxes = {}
  15.     with open(metadata.localization) as f:
  16.         for line in f.readlines():
  17.             image_id, x0s, x1s, y0s, y1s = line.strip('\n').split(',')
  18.             x0, x1, y0, y1 = int(x0s), int(x1s), int(y0s), int(y1s)
  19.             if image_id in boxes:
  20.                 boxes[image_id].append((x0, x1, y0, y1))
  21.             else:
  22.                 boxes[image_id] = [(x0, x1, y0, y1)]
  23.     return boxes

这个函数应该是在evaluate的时候用于检测模型的效果，在train的过程中用不到。

返回的boxes也是一个字典，其形式为： {image_id: [(x0, x1, y0, y1)]}

4）def get_mask_paths(metadata)

  1. def get_mask_paths(metadata):
  2.     """
  3.     localization.txt (for masks) has the structure
  5.     <path>,<link_to_mask_file>,<link_to_ignore_mask_file>
  6.     path/to/image1.jpg,path/to/mask1a.png,path/to/ignore1.png
  7.     path/to/image1.jpg,path/to/mask1b.png,
  8.     path/to/image2.jpg,path/to/mask2a.png,path/to/ignore2.png
  9.     path/to/image3.jpg,path/to/mask3a.png,path/to/ignore3.png
  10.     ...
  12.     One image may contain multiple masks (multiple mask paths for same image).
  13.     One image contains only one ignore mask.
  14.     """
  15.     mask_paths = {}
  16.     ignore_paths = {}
  17.     with open(metadata.localization) as f:
  18.         for line in f.readlines():
  19.             image_id, mask_path, ignore_path = line.strip('\n').split(',')
  20.             if image_id in mask_paths:
  21.                 mask_paths[image_id].append(mask_path)
  22.                 assert (len(ignore_path) == 0)
  23.             else:
  24.                 mask_paths[image_id] = [mask_path]
  25.                 ignore_paths[image_id] = ignore_path
  26.     return mask_paths, ignore_paths

在训练的过程中用不到，在后面的笔记中看到了再学习，Mark一下！！！！

5）def get_image_sizes

  1. def get_image_sizes(metadata):
  2.     """
  3.     image_sizes.txt has the structure
  5.     <path>,<w>,<h>
  6.     path/to/image1.jpg,500,300
  7.     path/to/image2.jpg,1000,600
  8.     path/to/image3.jpg,500,300
  9.     ...
  10.     """
  11.     image_sizes = {}
  12.     with open(metadata.image_sizes) as f:
  13.         for line in f.readlines():
  14.             image_id, ws, hs = line.strip('\n').split(',')
  15.             w, h = int(ws), int(hs)
  16.             image_sizes[image_id] = (w, h)
  17.     return image_sizes
  19. # 返回同样是一个字典：
  20. # type: {image_id：(w, h)}

6）Class WSOLImageLabelDataset(Dataset)

这里才是真正的数据的加载过程。

  1. # 继承自Pytorch的Dataset类
  2. class WSOLImageLabelDataset(Dataset):
  3.     def __init__(self, data_root, metadata_root, transform, proxy,
  4.                  num_sample_per_class=0):
  5.         self.data_root = data_root
  6.         self.metadata = configure_metadata(metadata_root)
  7.         self.transform = transform
  8.         self.image_ids = get_image_ids(self.metadata, proxy=proxy)
  9.         self.image_labels = get_class_labels(self.metadata)
  10.         self.num_sample_per_class = num_sample_per_class
  12.         self._adjust_samples_per_class()
  14.     def _adjust_samples_per_class(self):
  15.         if self.num_sample_per_class == 0:
  16.             return
  17.         image_ids = np.array(self.image_ids)
  18.         image_labels = np.array([self.image_labels[_image_id]
  19.                                  for _image_id in self.image_ids])
  20.         # 把对应image_id的图像标签全部提取出来，构成一个array
  21.         unique_labels = np.unique(image_labels)
  22.         # np.unique 该函数是去除数组中的重复数字，并进行排序之后输出
  23.         # 相当于unique_labels里面保存着多少类别的标签
  25.         new_image_ids = []
  26.         new_image_labels = {}
  27.         for _label in unique_labels:
  28.             indices = np.where(image_labels == _label)[0]
  29.             # np.where(condition): 返回image_labels 符合condition的array
  30.             # 对每一个类的数据进行随机抽样
  31.             sampled_indices = np.random.choice(
  32.                 indices, self.num_sample_per_class, replace=False)
  33.             sampled_image_ids = image_ids[sampled_indices].tolist()
  34.             # 对每一类随机抽取的图片id进行收集
  35.             sampled_image_labels = image_labels[sampled_indices].tolist()
  36.             #  对每一类随机抽取的图片label进行收集  
  37.             new_image_ids += sampled_image_ids
  38.             new_image_labels.update(
  39.                 **dict(zip(sampled_image_ids, sampled_image_labels)))
  40.             # 将随机抽取的图片的id和label进行整合成字典
  42.         self.image_ids = new_image_ids
  43.         self.image_labels = new_image_labels
  45.     def __getitem__(self, idx):
  46.         image_id = self.image_ids[idx]
  47.         image_label = self.image_labels[image_id]
  48.         image = Image.open(os.path.join(self.data_root, image_id))
  49.         image = image.convert('RGB')
  50.         image = self.transform(image)
  51.         return image, image_label, image_id
  53.     def __len__(self):
  54.         return len(self.image_ids)

7）def get_data_loader

  1. def get_data_loader(data_roots, metadata_root, batch_size, workers,
  2.                     resize_size, crop_size, proxy_training_set,
  3.                     num_val_sample_per_class=0):
  4.     dataset_transforms = dict(
  5.         train=transforms.Compose([
  6.             transforms.Resize((resize_size, resize_size)),
  7.             transforms.RandomCrop(crop_size),
  8.             transforms.RandomHorizontalFlip(),
  9.             transforms.ToTensor(),
  10.             transforms.Normalize(_IMAGE_MEAN_VALUE, _IMAGE_STD_VALUE)
  11.         ]),
  12.         val=transforms.Compose([
  13.             transforms.Resize((crop_size, crop_size)),
  14.             transforms.ToTensor(),
  15.             transforms.Normalize(_IMAGE_MEAN_VALUE, _IMAGE_STD_VALUE)
  16.         ]),
  17.         test=transforms.Compose([
  18.             transforms.Resize((crop_size, crop_size)),
  19.             transforms.ToTensor(),
  20.             transforms.Normalize(_IMAGE_MEAN_VALUE, _IMAGE_STD_VALUE)
  21.         ]))
  23.     loaders = {
  24.         split: DataLoader(
  25.             WSOLImageLabelDataset(
  26.                 data_root=data_roots[split],
  27.                 metadata_root=os.path.join(metadata_root, split),
  28.                 transform=dataset_transforms[split],
  29.                 proxy=proxy_training_set and split == 'train',
  30.                 num_sample_per_class=(num_val_sample_per_class
  31.                                       if split == 'val' else 0)
  32.             ),
  33.             batch_size=batch_size,
  34.             shuffle=split == 'train',
  35.             num_workers=workers)
  36.         for split in _SPLITS
  37.     }
  38.     return loaders