• YOLO V5源码详解

    1.数据读取

            首先读取图片以及标签路径，并将标签存入缓存，对单标签情况、特定类别、以及是否保持长方形等情况分别进行处理。

            如果需要进行mosaic 数据增强，首先找到中心点，将图片分别放置于四个位置，进行裁剪或者拼接以适应，并对labels进行调整。同时，对进行过mosaic数据增强过的图像，再进行copy_paste数据增强和旋转、平移、缩放数据增强。

             同时，还可以进行其他数据增强方式，比如mix up,hsv等

     代码如下：

    1. class LoadImagesAndLabels(Dataset):
    2.     # YOLOv5 train_loader/val_loader, loads images and labels for training and validation
    3.     cache_version = 0.6  # dataset labels *.cache version
    4.     rand_interp_methods = [cv2.INTER_NEAREST, cv2.INTER_LINEAR, cv2.INTER_CUBIC, cv2.INTER_AREA, cv2.INTER_LANCZOS4]
    5.  
    6.     def __init__(self,
    7.                  path,
    8.                  img_size=640,
    9.                  batch_size=16,
    10.                  augment=False,
    11.                  hyp=None,
    12.                  rect=False,
    13.                  image_weights=False,
    14.                  cache_images=False,  # 缓存图片
    15.                  single_cls=False,
    16.                  stride=32,
    17.                  pad=0.0,
    18.                  prefix=''):
    19.         self.img_size = img_size
    20.         self.augment = augment
    21.         self.hyp = hyp
    22.         self.image_weights = image_weights
    23.         self.rect = False if image_weights else rect
    24.         self.mosaic = self.augment and not self.rect  # load 4 images at a time into a mosaic (only during training)
    25.         self.mosaic_border = [-img_size // 2, -img_size // 2] # 拼接过程中按照什么中心点进行拼接
    26.         self.stride = stride
    27.         self.path = path
    28.         self.albumentations = Albumentations() if augment else None
    29.  
    30.         try:
    31.             f = []  # image files
    32.             for p in path if isinstance(path, list) else [path]:  # window和linux
    33.                 p = Path(p)  # os-agnostic
    34.                 if p.is_dir():  # dir
    35.                     f += glob.glob(str(p / '**' / '*.*'), recursive=True) # 获取指定路径
    36.                     # f = list(p.rglob('*.*'))  # pathlib
    37.                 elif p.is_file():  # file
    38.                     with open(p) as t:
    39.                         t = t.read().strip().splitlines() # 读取图片路径
    40.                         parent = str(p.parent) + os.sep  # 指定系统分隔符
    41.                         # 相对地址转绝对地址
    42.                         f += [x.replace('./', parent) if x.startswith('./') else x for x in t]  # local to global path
    43.                         # f += [p.parent / x.lstrip(os.sep) for x in t]  # local to global path (pathlib)
    44.                 else:
    45.                     raise FileNotFoundError(f'{prefix}{p} does not exist')
    46.             self.im_files = sorted(x.replace('/', os.sep) for x in f if x.split('.')[-1].lower() in IMG_FORMATS) # 排序
    47.             # self.img_files = sorted([x for x in f if x.suffix[1:].lower() in IMG_FORMATS])  # pathlib
    48.             assert self.im_files, f'{prefix}No images found'
    49.         except Exception as e:
    50.             raise Exception(f'{prefix}Error loading data from {path}: {e}\nSee {HELP_URL}')
    51.  
    52.         # Check cache
    53.         self.label_files = img2label_paths(self.im_files)  # labels
    54.         # 设置缓存
    55.         cache_path = (p if p.is_file() else Path(self.label_files[0]).parent).with_suffix('.cache')
    56.         try:
    57.             cache, exists = np.load(cache_path, allow_pickle=True).item(), True  # load dict
    58.             assert cache['version'] == self.cache_version  # matches current version
    59.             assert cache['hash'] == get_hash(self.label_files + self.im_files)  # identical hash
    60.         except Exception:
    61.             cache, exists = self.cache_labels(cache_path, prefix), False  # run cache ops
    62.  
    63.         # Display cache
    64.         nf, nm, ne, nc, n = cache.pop('results')  # found, missing, empty, corrupt, total
    65.         if exists and LOCAL_RANK in {-1, 0}:
    66.             d = f"Scanning '{cache_path}' images and labels... {nf} found, {nm} missing, {ne} empty, {nc} corrupt"
    67.             tqdm(None, desc=prefix + d, total=n, initial=n, bar_format=BAR_FORMAT)  # display cache results
    68.             if cache['msgs']:
    69.                 LOGGER.info('\n'.join(cache['msgs']))  # display warnings
    70.         assert nf > 0 or not augment, f'{prefix}No labels in {cache_path}. Can not train without labels. See {HELP_URL}'
    71.  
    72.         # Read cache
    73.         [cache.pop(k) for k in ('hash', 'version', 'msgs')]  # remove items 去除不需要的信息
    74.         labels, shapes, self.segments = zip(*cache.values())
    75.         self.labels = list(labels) # 标签信息
    76.         self.shapes = np.array(shapes, dtype=np.float64) # 图片大小
    77.         self.im_files = list(cache.keys())  # update 图片文件名称
    78.         self.label_files = img2label_paths(cache.keys())  # update 标签文件名称
    79.         n = len(shapes)  # number of images
    80.         bi = np.floor(np.arange(n) / batch_size).astype(np.int)  # batch index
    81.         nb = bi[-1] + 1  # number of batches
    82.         self.batch = bi  # batch index of image
    83.         self.n = n
    84.         self.indices = range(n) # 索引
    85.  
    86.         # Update labels 筛选标签以仅包括这些类（可选）
    87.         include_class = []  # filter labels to include only these classes (optional)
    88.         include_class_array = np.array(include_class).reshape(1, -1)
    89.         for i, (label, segment) in enumerate(zip(self.labels, self.segments)):
    90.             if include_class:
    91.                 j = (label[:, 0:1] == include_class_array).any(1)
    92.                 self.labels[i] = label[j]
    93.                 if segment:
    94.                     self.segments[i] = segment[j]
    95.             if single_cls:  # single-class training, merge all classes into 0
    96.                 self.labels[i][:, 0] = 0
    97.                 if segment:
    98.                     self.segments[i][:, 0] = 0
    99.  
    100.         # Rectangular Training
    101.         if self.rect:
    102.             # Sort by aspect ratio
    103.             s = self.shapes  # wh
    104.             ar = s[:, 1] / s[:, 0]  # aspect ratio
    105.             irect = ar.argsort()
    106.             self.im_files = [self.im_files[i] for i in irect]
    107.             self.label_files = [self.label_files[i] for i in irect]
    108.             self.labels = [self.labels[i] for i in irect]
    109.             self.shapes = s[irect]  # wh
    110.             ar = ar[irect]
    111.  
    112.             # Set training image shapes
    113.             shapes = [[1, 1]] * nb
    114.             for i in range(nb):
    115.                 ari = ar[bi == i]
    116.                 mini, maxi = ari.min(), ari.max()
    117.                 if maxi < 1:
    118.                     shapes[i] = [maxi, 1]
    119.                 elif mini > 1:
    120.                     shapes[i] = [1, 1 / mini]
    121.  
    122.             self.batch_shapes = np.ceil(np.array(shapes) * img_size / stride + pad).astype(np.int) * stride
    123.  
    124.         # Cache images into RAM/disk for faster training (WARNING: large datasets may exceed system resources)
    125.         # 将图像缓存到RAM/磁盘中以加快训练（警告：大型数据集可能超过系统资源）
    126.         self.ims = [None] * n
    127.         self.npy_files = [Path(f).with_suffix('.npy') for f in self.im_files]
    128.         if cache_images:
    129.             gb = 0  # Gigabytes of cached images
    130.             self.im_hw0, self.im_hw = [None] * n, [None] * n
    131.             fcn = self.cache_images_to_disk if cache_images == 'disk' else self.load_image
    132.             results = ThreadPool(NUM_THREADS).imap(fcn, range(n))
    133.             pbar = tqdm(enumerate(results), total=n, bar_format=BAR_FORMAT, disable=LOCAL_RANK > 0)
    134.             for i, x in pbar:
    135.                 if cache_images == 'disk':
    136.                     gb += self.npy_files[i].stat().st_size
    137.                 else:  # 'ram'
    138.                     self.ims[i], self.im_hw0[i], self.im_hw[i] = x  # im, hw_orig, hw_resized = load_image(self, i)
    139.                     gb += self.ims[i].nbytes
    140.                 pbar.desc = f'{prefix}Caching images ({gb / 1E9:.1f}GB {cache_images})'
    141.             pbar.close()
    142.  
    143.     def cache_labels(self, path=Path('./labels.cache'), prefix=''):
    144.         # Cache dataset labels, check images and read shapes
    145.         x = {}  # dict
    146.         nm, nf, ne, nc, msgs = 0, 0, 0, 0, []  # number missing, found, empty, corrupt, messages
    147.         desc = f"{prefix}Scanning '{path.parent / path.stem}' images and labels..."
    148.         with Pool(NUM_THREADS) as pool:
    149.             pbar = tqdm(pool.imap(verify_image_label, zip(self.im_files, self.label_files, repeat(prefix))),
    150.                         desc=desc,
    151.                         total=len(self.im_files),
    152.                         bar_format=BAR_FORMAT)
    153.             for im_file, lb, shape, segments, nm_f, nf_f, ne_f, nc_f, msg in pbar:
    154.                 nm += nm_f
    155.                 nf += nf_f
    156.                 ne += ne_f
    157.                 nc += nc_f
    158.                 if im_file:
    159.                     x[im_file] = [lb, shape, segments]
    160.                 if msg:
    161.                     msgs.append(msg)
    162.                 pbar.desc = f"{desc}{nf} found, {nm} missing, {ne} empty, {nc} corrupt"
    163.  
    164.         pbar.close()
    165.         if msgs:
    166.             LOGGER.info('\n'.join(msgs))
    167.         if nf == 0:
    168.             LOGGER.warning(f'{prefix}WARNING: No labels found in {path}. See {HELP_URL}')
    169.         x['hash'] = get_hash(self.label_files + self.im_files)
    170.         x['results'] = nf, nm, ne, nc, len(self.im_files)
    171.         x['msgs'] = msgs  # warnings
    172.         x['version'] = self.cache_version  # cache version
    173.         try:
    174.             np.save(path, x)  # save cache for next time
    175.             path.with_suffix('.cache.npy').rename(path)  # remove .npy suffix
    176.             LOGGER.info(f'{prefix}New cache created: {path}')
    177.         except Exception as e:
    178.             LOGGER.warning(f'{prefix}WARNING: Cache directory {path.parent} is not writeable: {e}')  # not writeable
    179.         return x
    180.  
    181.     def __len__(self):
    182.         return len(self.im_files)
    183.  
    184.     # def __iter__(self):
    185.     #     self.count = -1
    186.     #     print('ran dataset iter')
    187.     #     #self.shuffled_vector = np.random.permutation(self.nF) if self.augment else np.arange(self.nF)
    188.     #     return self
    189.  
    190.     def __getitem__(self, index):
    191.         index = self.indices[index]  # linear, shuffled, or image_weights
    192.  
    193.         hyp = self.hyp
    194.         mosaic = self.mosaic and random.random() < hyp['mosaic']
    195.         if mosaic:
    196.             # Load mosaic  mosaic数据增强
    197.             img, labels = self.load_mosaic(index)
    198.             shapes = None
    199.  
    200.             # MixUp augmentation
    201.             if random.random() < hyp['mixup']:
    202.                 img, labels = mixup(img, labels, *self.load_mosaic(random.randint(0, self.n - 1)))
    203.  
    204.         else:
    205.             # 不进行mosaic的操作
    206.             # Load image
    207.             img, (h0, w0), (h, w) = self.load_image(index)
    208.  
    209.             # Letterbox
    210.             shape = self.batch_shapes[self.batch[index]] if self.rect else self.img_size  # final letterboxed shape
    211.             img, ratio, pad = letterbox(img, shape, auto=False, scaleup=self.augment)
    212.             shapes = (h0, w0), ((h / h0, w / w0), pad)  # for COCO mAP rescaling
    213.  
    214.             labels = self.labels[index].copy()
    215.             if labels.size:  # normalized xywh to pixel xyxy format
    216.                 labels[:, 1:] = xywhn2xyxy(labels[:, 1:], ratio[0] * w, ratio[1] * h, padw=pad[0], padh=pad[1])
    217.  
    218.             if self.augment:
    219.                 img, labels = random_perspective(img,
    220.                                                  labels,
    221.                                                  degrees=hyp['degrees'],
    222.                                                  translate=hyp['translate'],
    223.                                                  scale=hyp['scale'],
    224.                                                  shear=hyp['shear'],
    225.                                                  perspective=hyp['perspective'])
    226.  
    227.         nl = len(labels)  # number of labels
    228.         if nl:
    229.             # x1,y1,x2,y2 转换为x,y,w,h
    230.             labels[:, 1:5] = xyxy2xywhn(labels[:, 1:5], w=img.shape[1], h=img.shape[0], clip=True, eps=1E-3)
    231.  
    232.         if self.augment:
    233.             # Albumentations 数据增强
    234.             img, labels = self.albumentations(img, labels)
    235.             nl = len(labels)  # update after albumentations
    236.  
    237.             # HSV color-space
    238.             augment_hsv(img, hgain=hyp['hsv_h'], sgain=hyp['hsv_s'], vgain=hyp['hsv_v'])
    239.  
    240.             # Flip up-down  翻转操作
    241.             if random.random() < hyp['flipud']:
    242.                 img = np.flipud(img)
    243.                 if nl:
    244.                     labels[:, 2] = 1 - labels[:, 2]
    245.  
    246.             # Flip left-right
    247.             if random.random() < hyp['fliplr']:
    248.                 img = np.fliplr(img)
    249.                 if nl:
    250.                     labels[:, 1] = 1 - labels[:, 1]
    251.  
    252.             # Cutouts
    253.             # labels = cutout(img, labels, p=0.5)
    254.             # nl = len(labels)  # update after cutout
    255.  
    256.         labels_out = torch.zeros((nl, 6))
    257.         if nl:
    258.             labels_out[:, 1:] = torch.from_numpy(labels)
    259.  
    260.         # Convert
    261.         img = img.transpose((2, 0, 1))[::-1]  # HWC to CHW, BGR to RGB
    262.         # ascontiguousarray函数将一个内存不连续存储的数组转换为内存连续存储的数组，使得运行速度更快
    263.         img = np.ascontiguousarray(img)
    264.  
    265.         return torch.from_numpy(img), labels_out, self.im_files[index], shapes
    266.  
    267.     def load_image(self, i):
    268.         # Loads 1 image from dataset index 'i', returns (im, original hw, resized hw)
    269.         im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i],
    270.         if im is None:  # not cached in RAM
    271.             if fn.exists():  # load npy
    272.                 im = np.load(fn)
    273.             else:  # read image
    274.                 im = cv2.imread(f)  # BGR
    275.                 assert im is not None, f'Image Not Found {f}'
    276.             h0, w0 = im.shape[:2]  # orig hw
    277.             r = self.img_size / max(h0, w0)  # ratio
    278.             if r != 1:  # if sizes are not equal
    279.                 interp = cv2.INTER_LINEAR if (self.augment or r > 1) else cv2.INTER_AREA   # 插值方式
    280.                 im = cv2.resize(im, (int(w0 * r), int(h0 * r)), interpolation=interp)
    281.             return im, (h0, w0), im.shape[:2]  # im, hw_original, hw_resized
    282.         else:
    283.             return self.ims[i], self.im_hw0[i], self.im_hw[i]  # im, hw_original, hw_resized
    284.  
    285.     def cache_images_to_disk(self, i):
    286.         # Saves an image as an *.npy file for faster loading
    287.         f = self.npy_files[i]
    288.         if not f.exists():
    289.             np.save(f.as_posix(), cv2.imread(self.im_files[i]))
    290.  
    291.     def load_mosaic(self, index):
    292.         # YOLOv5 4-mosaic loader. Loads 1 image + 3 random images into a 4-image mosaic
    293.         labels4, segments4 = [], []
    294.         s = self.img_size
    295.         yc, xc = (int(random.uniform(-x, 2 * s + x)) for x in self.mosaic_border)  # mosaic center x, y
    296.         indices = [index] + random.choices(self.indices, k=3)  # 3 additional image indices
    297.         random.shuffle(indices)
    298.         for i, index in enumerate(indices):
    299.             # Load image  加载图片，并将长边resize成(640,640)
    300.             img, _, (h, w) = self.load_image(index)
    301.  
    302.             # place img in img4
    303.             if i == 0:  # top left
    304.                 img4 = np.full((s * 2, s * 2, img.shape[2]), 114, dtype=np.uint8)  # base image with 4 tiles
    305.                 x1a, y1a, x2a, y2a = max(xc - w, 0), max(yc - h, 0), xc, yc  # xmin, ymin, xmax, ymax (large image)
    306.                 x1b, y1b, x2b, y2b = w - (x2a - x1a), h - (y2a - y1a), w, h  # xmin, ymin, xmax, ymax (small image)
    307.             elif i == 1:  # top right
    308.                 x1a, y1a, x2a, y2a = xc, max(yc - h, 0), min(xc + w, s * 2), yc
    309.                 x1b, y1b, x2b, y2b = 0, h - (y2a - y1a), min(w, x2a - x1a), h
    310.             elif i == 2:  # bottom left
    311.                 x1a, y1a, x2a, y2a = max(xc - w, 0), yc, xc, min(s * 2, yc + h)
    312.                 x1b, y1b, x2b, y2b = w - (x2a - x1a), 0, w, min(y2a - y1a, h)
    313.             elif i == 3:  # bottom right
    314.                 x1a, y1a, x2a, y2a = xc, yc, min(xc + w, s * 2), min(s * 2, yc + h)
    315.                 x1b, y1b, x2b, y2b = 0, 0, min(w, x2a - x1a), min(y2a - y1a, h)
    316.  
    317.             img4[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b]  # img4[ymin:ymax, xmin:xmax]
    318.             padw = x1a - x1b
    319.             padh = y1a - y1b
    320.  
    321.             # Labels
    322.             labels, segments = self.labels[index].copy(), self.segments[index].copy()
    323.             if labels.size:
    324.                 # 将xywh转换为x1,y1,x2,y2并加上padw,padh
    325.                 labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padw, padh)  # normalized xywh to pixel xyxy format
    326.                 segments = [xyn2xy(x, w, h, padw, padh) for x in segments]
    327.             labels4.append(labels)
    328.             segments4.extend(segments)
    329.  
    330.         # Concat/clip labels  将标签限制在0，2s
    331.         labels4 = np.concatenate(labels4, 0)
    332.         for x in (labels4[:, 1:], *segments4):
    333.             np.clip(x, 0, 2 * s, out=x)  # clip when using random_perspective()
    334.         # img4, labels4 = replicate(img4, labels4)  # replicate
    335.  
    336.         # Augment
    337.         # copy_pase数据增强
    338.         img4, labels4, segments4 = copy_paste(img4, labels4, segments4, p=self.hyp['copy_paste'])
    339.         # 数据增强，旋转、平移、缩放
    340.         img4, labels4 = random_perspective(img4,
    341.                                            labels4,
    342.                                            segments4,
    343.                                            degrees=self.hyp['degrees'],
    344.                                            translate=self.hyp['translate'],
    345.                                            scale=self.hyp['scale'],
    346.                                            shear=self.hyp['shear'],
    347.                                            perspective=self.hyp['perspective'],
    348.                                            border=self.mosaic_border)  # border to remove
    349.  
    350.         return img4, labels4
    351.  
    352.     def load_mosaic9(self, index):
    353.         # YOLOv5 9-mosaic loader. Loads 1 image + 8 random images into a 9-image mosaic
    354.         labels9, segments9 = [], []
    355.         s = self.img_size
    356.         indices = [index] + random.choices(self.indices, k=8)  # 8 additional image indices
    357.         random.shuffle(indices)
    358.         hp, wp = -1, -1  # height, width previous
    359.         for i, index in enumerate(indices):
    360.             # Load image
    361.             img, _, (h, w) = self.load_image(index)
    362.  
    363.             # place img in img9
    364.             if i == 0:  # center
    365.                 img9 = np.full((s * 3, s * 3, img.shape[2]), 114, dtype=np.uint8)  # base image with 4 tiles
    366.                 h0, w0 = h, w
    367.                 c = s, s, s + w, s + h  # xmin, ymin, xmax, ymax (base) coordinates
    368.             elif i == 1:  # top
    369.                 c = s, s - h, s + w, s
    370.             elif i == 2:  # top right
    371.                 c = s + wp, s - h, s + wp + w, s
    372.             elif i == 3:  # right
    373.                 c = s + w0, s, s + w0 + w, s + h
    374.             elif i == 4:  # bottom right
    375.                 c = s + w0, s + hp, s + w0 + w, s + hp + h
    376.             elif i == 5:  # bottom
    377.                 c = s + w0 - w, s + h0, s + w0, s + h0 + h
    378.             elif i == 6:  # bottom left
    379.                 c = s + w0 - wp - w, s + h0, s + w0 - wp, s + h0 + h
    380.             elif i == 7:  # left
    381.                 c = s - w, s + h0 - h, s, s + h0
    382.             elif i == 8:  # top left
    383.                 c = s - w, s + h0 - hp - h, s, s + h0 - hp
    384.  
    385.             padx, pady = c[:2]
    386.             x1, y1, x2, y2 = (max(x, 0) for x in c)  # allocate coords
    387.  
    388.             # Labels
    389.             labels, segments = self.labels[index].copy(), self.segments[index].copy()
    390.             if labels.size:
    391.                 labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padx, pady)  # normalized xywh to pixel xyxy format
    392.                 segments = [xyn2xy(x, w, h, padx, pady) for x in segments]
    393.             labels9.append(labels)
    394.             segments9.extend(segments)
    395.  
    396.             # Image
    397.             img9[y1:y2, x1:x2] = img[y1 - pady:, x1 - padx:]  # img9[ymin:ymax, xmin:xmax]
    398.             hp, wp = h, w  # height, width previous
    399.  
    400.         # Offset
    401.         yc, xc = (int(random.uniform(0, s)) for _ in self.mosaic_border)  # mosaic center x, y
    402.         img9 = img9[yc:yc + 2 * s, xc:xc + 2 * s]
    403.  
    404.         # Concat/clip labels
    405.         labels9 = np.concatenate(labels9, 0)
    406.         labels9[:, [1, 3]] -= xc
    407.         labels9[:, [2, 4]] -= yc
    408.         c = np.array([xc, yc])  # centers
    409.         segments9 = [x - c for x in segments9]
    410.  
    411.         for x in (labels9[:, 1:], *segments9):
    412.             np.clip(x, 0, 2 * s, out=x)  # clip when using random_perspective()
    413.         # img9, labels9 = replicate(img9, labels9)  # replicate
    414.  
    415.         # Augment
    416.         img9, labels9 = random_perspective(img9,
    417.                                            labels9,
    418.                                            segments9,
    419.                                            degrees=self.hyp['degrees'],
    420.                                            translate=self.hyp['translate'],
    421.                                            scale=self.hyp['scale'],
    422.                                            shear=self.hyp['shear'],
    423.                                            perspective=self.hyp['perspective'],
    424.                                            border=self.mosaic_border)  # border to remove
    425.  
    426.         return img9, labels9
    427.  
    428.     @staticmethod
    429.     def collate_fn(batch):
    430.         im, label, path, shapes = zip(*batch)  # transposed
    431.         for i, lb in enumerate(label):
    432.             lb[:, 0] = i  # add target image index for build_targets()
    433.         return torch.stack(im, 0), torch.cat(label, 0), path, shapes
    434.  
    435.     @staticmethod
    436.     def collate_fn4(batch):
    437.         img, label, path, shapes = zip(*batch)  # transposed
    438.         n = len(shapes) // 4
    439.         im4, label4, path4, shapes4 = [], [], path[:n], shapes[:n]
    440.  
    441.         ho = torch.tensor([[0.0, 0, 0, 1, 0, 0]])
    442.         wo = torch.tensor([[0.0, 0, 1, 0, 0, 0]])
    443.         s = torch.tensor([[1, 1, 0.5, 0.5, 0.5, 0.5]])  # scale
    444.         for i in range(n):  # zidane torch.zeros(16,3,720,1280)  # BCHW
    445.             i *= 4
    446.             if random.random() < 0.5:
    447.                 im = F.interpolate(img[i].unsqueeze(0).float(), scale_factor=2.0, mode='bilinear',
    448.                                    align_corners=False)[0].type(img[i].type())
    449.                 lb = label[i]
    450.             else:
    451.                 im = torch.cat((torch.cat((img[i], img[i + 1]), 1), torch.cat((img[i + 2], img[i + 3]), 1)), 2)
    452.                 lb = torch.cat((label[i], label[i + 1] + ho, label[i + 2] + wo, label[i + 3] + ho + wo), 0) * s
    453.             im4.append(im)
    454.             label4.append(lb)
    455.  
    456.         for i, lb in enumerate(label4):
    457.             lb[:, 0] = i  # add target image index for build_targets()
    458.  
    459.         return torch.stack(im4, 0), torch.cat(label4, 0), path4, shapes4

    2.模型配置文件读取 

            depth_multiple表示网络的深度，表示在网络层的数量，非1的层乘以该系数，width_multiple表示网络的深度，网络最终的输出通道数乘以该系数即可得到网络的最终通道数。YOLO提供了不同版本的模型，对于不同版本的模型，最大的不同的在于以上两个系数。

            anchor表示网络的先验框

            对于网络参数，from表示输入来自于哪一层的输出，number表示网络层的层数，module表示网络层的名称。args表示网络的超参数。

    1. # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
    2.  
    3. # Parameters
    4. nc: 80  # number of classes
    5. depth_multiple: 0.33  # model depth multiple
    6. width_multiple: 0.50  # layer channel multiple
    7. anchors:
    8.   - [10,13, 16,30, 33,23]  # P3/8
    9.   - [30,61, 62,45, 59,119]  # P4/16
    10.   - [116,90, 156,198, 373,326]  # P5/32
    11.  
    12. # YOLOv5 v6.0 backbone
    13. backbone:
    14.   # [from, number, module, args]
    15.   [[-1, 1, Conv, [64, 6, 2, 2]],  # 0-P1/2
    16.    [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
    17.    [-1, 3, C3, [128]],
    18.    [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
    19.    [-1, 6, C3, [256]],
    20.    [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
    21.    [-1, 9, C3, [512]],
    22.    [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
    23.    [-1, 3, C3, [1024]],
    24.    [-1, 1, SPPF, [1024, 5]],  # 9
    25.   ]
    26.  
    27. # YOLOv5 v6.0 head
    28. head:
    29.   [[-1, 1, Conv, [512, 1, 1]],
    30.    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
    31.    [[-1, 6], 1, Concat, [1]],  # cat backbone P4
    32.    [-1, 3, C3, [512, False]],  # 13
    33.  
    34.    [-1, 1, Conv, [256, 1, 1]],
    35.    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
    36.    [[-1, 4], 1, Concat, [1]],  # cat backbone P3
    37.    [-1, 3, C3, [256, False]],  # 17 (P3/8-small)
    38.  
    39.    [-1, 1, Conv, [256, 3, 2]],
    40.    [[-1, 14], 1, Concat, [1]],  # cat head P4
    41.    [-1, 3, C3, [512, False]],  # 20 (P4/16-medium)
    42.  
    43.    [-1, 1, Conv, [512, 3, 2]],
    44.    [[-1, 10], 1, Concat, [1]],  # cat head P5
    45.    [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)
    46.  
    47.    [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
    48.   ]

    读取代码：

    1. def parse_model(d, ch):  # model_dict, input_channels(3)
    2.     # ch (list):表示各层输出通道数
    3.     LOGGER.info(f"\n{'':>3}{'from':>18}{'n':>3}{'params':>10}  {'module':<40}{'arguments':<30}") # 打印表头
    4.     # 读取相应数据 anchors:锚框，nc:类别 gd：深度系数 gw 宽度系数
    5.     anchors, nc, gd, gw = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple']
    6.     na = (len(anchors[0]) // 2) if isinstance(anchors, list) else anchors  # number of anchors
    7.     no = na * (nc + 5)  # number of outputs = anchors * (classes + 5)
    8.  
    9.     layers, save, c2 = [], [], ch[-1]  # layers, savelist, ch out
    10.     for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']):  # from, number, module, args
    11.         m = eval(m) if isinstance(m, str) else m  # eval strings
    12.         for j, a in enumerate(args):
    13.             try:
    14.                 args[j] = eval(a) if isinstance(a, str) else a  # eval strings
    15.             except NameError:
    16.                 pass
    17.  
    18.         n = n_ = max(round(n * gd), 1) if n > 1 else n  # depth gain
    19.         if m in (Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, SPPF, DWConv, MixConv2d, Focus, CrossConv,
    20.                  BottleneckCSP, C3, C3TR, C3SPP, C3Ghost, nn.ConvTranspose2d, DWConvTranspose2d, C3x):
    21.             c1, c2 = ch[f], args[0]
    22.             if c2 != no:  # if not output
    23.                 c2 = make_divisible(c2 * gw, 8) # 输出通道
    24.  
    25.             args = [c1, c2, *args[1:]] # 更新配置参数
    26.             # 对应层需要重复
    27.             if m in [BottleneckCSP, C3, C3TR, C3Ghost, C3x]:
    28.                 args.insert(2, n)  # number of repeats
    29.                 n = 1
    30.         elif m is nn.BatchNorm2d:
    31.             args = [ch[f]] # batch_normal层，上一层的输出维度
    32.         elif m is Concat:
    33.             c2 = sum(ch[x] for x in f) # concat层：通道数之和
    34.         elif m is Detect:
    35.             args.append([ch[x] for x in f])  # detect：通道数之和
    36.             if isinstance(args[1], int):  # 整数表示number of anchors
    37.                 args[1] = [list(range(args[1] * 2))] * len(f) # 初始化一个anchors矩阵
    38.         elif m is Contract:
    39.             c2 = ch[f] * args[0] ** 2
    40.         elif m is Expand:
    41.             c2 = ch[f] // args[0] ** 2
    42.         else:
    43.             c2 = ch[f]
    44.         # 构建对应层的模型
    45.         m_ = nn.Sequential(*(m(*args) for _ in range(n))) if n > 1 else m(*args)  # module
    46.         t = str(m)[8:-2].replace('__main__.', '')  # module type
    47.         np = sum(x.numel() for x in m_.parameters())  # number params
    48.         m_.i, m_.f, m_.type, m_.np = i, f, t, np  # attach index, 'from' index, type, number params
    49.         LOGGER.info(f'{i:>3}{str(f):>18}{n_:>3}{np:10.0f}  {t:<40}{str(args):<30}')  # print
    50.         # 保存不等于-1的x的x%i
    51.         save.extend(x % i for x in ([f] if isinstance(f, int) else f) if x != -1)  # append to savelist
    52.         layers.append(m_)
    53.         if i == 0:
    54.             ch = []
    55.         ch.append(c2)
    56.     return nn.Sequential(*layers), sorted(save)

     3.网络结构（yolox.pt）

    （1）前两层

            网络前两层一层为6*6的卷积，strides为2，padding为（2，2），第二层为3*3的卷积，strides为2，padding为2,特征维度变换为3*640*640-->80*320*320-->160*160*160

    (2) C3模块

            C3层有两个路径，第一个短路径， 只有一个1*1的卷积，将特征图从c1降维成c1*e，第二条路径是n个bottleneck模块，每个bottomneck包含两个卷积，第一个卷积为1*1的卷积，将通道数降维成c1-->c1*e，第二层为3*3的卷积，将通道数由c1*e-->c2,最后再做一层3*3的卷积，调整通道数。其中，bottleneck都采用残差连接。经过c3模块，特征图大小不变，通道数由c1变成c2，最后，再经过3*3的卷积，将特征图大小减半。

            

     （3）SPPF模块

            SPPF是SPP的快速版本，有四条路径，第一条路径，1*1的卷积，将特征图通道数由c1变成c1//2【1】，第二条路径，对【1】的结果经过5*5的最大池化，pading为2【2】，第三条路径，对【2】的结果，经过5*5的最大池化，pading为2【3】，第四条路径，经过 5*5的最大池化，pad为2【4】。将四条路径的结果融合，再做一层1*1的卷积。

     4.PAN流程

            PAN实现了双向通信，将高维特征与低维特征进行融合，三个特征图大小分别下采样8倍，16倍和32倍。首先，将高维特征进行上采样，与低维特征融合，然后再通过卷积实现从低维特征到高维特征的融合 

            假设网络输入为256*256,网络各层输出如下：对于上采样部分，

            对于缩小32倍的特征图：将第10层输出进行上采样后，与第6层输出concat，输出大小为1,1280,16,16【1】

            对于缩小8倍的特征图，将【1】的结果，经过一层C3层，此时维度变为：将通道数由1280变为640，再经过一层卷积层，将通道数变为320，再经过上采样，与第四层的结果相连接，输出维度为1，640,32,32【2】

            下采样部分：

            对于【2】，首先，经过一层C3层，将维度变为1,320,32,32，然后经过一层3*3的卷积，与第14层的结果相连，即【1】经过C3和1*1的卷积后的结果相连，维度为1,640,16,16。【3】

            对于【3】，经过一层C3层和1*1的卷积，通道数保持不变，与第10层的结果相连，即为32层特征图上采样之前的结果。此时特征图为1,1280,8,8，再经过一层C3模块。【4】

            对于【2】【3】【4】层结果，分别做预测  

    1. models.common.Conv 网络层数  0 输出: torch.Size([1, 80, 128, 128])
    2. models.common.Conv 网络层数  1 输出: torch.Size([1, 160, 64, 64])
    3. models.common.C3 网络层数  2 输出: torch.Size([1, 160, 64, 64])
    4. models.common.Conv 网络层数  3 输出: torch.Size([1, 320, 32, 32])
    5. models.common.C3 网络层数  4 输出: torch.Size([1, 320, 32, 32])
    6. models.common.Conv 网络层数  5 输出: torch.Size([1, 640, 16, 16])
    7. models.common.C3 网络层数  6 输出: torch.Size([1, 640, 16, 16])
    8. models.common.Conv 网络层数  7 输出: torch.Size([1, 1280, 8, 8])
    9. models.common.C3 网络层数  8 输出: torch.Size([1, 1280, 8, 8])
    10. models.common.SPPF 网络层数  9 输出: torch.Size([1, 1280, 8, 8])
    11. models.common.Conv 网络层数  10 输出: torch.Size([1, 640, 8, 8])
    12. torch.nn.modules.upsampling.Upsample 网络层数  11 输出: torch.Size([1, 640, 16, 16])
    13. models.common.Concat 网络层数  12 输出: torch.Size([1, 1280, 16, 16])
    14. models.common.C3 网络层数  13 输出: torch.Size([1, 640, 16, 16])
    15. models.common.Conv 网络层数  14 输出: torch.Size([1, 320, 16, 16])
    16. torch.nn.modules.upsampling.Upsample 网络层数  15 输出: torch.Size([1, 320, 32, 32])
    17. models.common.Concat 网络层数  16 输出: torch.Size([1, 640, 32, 32])
    18. models.common.C3 网络层数  17 输出: torch.Size([1, 320, 32, 32])
    19. models.common.Conv 网络层数  18 输出: torch.Size([1, 320, 16, 16])
    20. models.common.Concat 网络层数  19 输出: torch.Size([1, 640, 16, 16])
    21. models.common.C3 网络层数  20 输出: torch.Size([1, 640, 16, 16])
    22. models.common.Conv 网络层数  21 输出: torch.Size([1, 640, 8, 8])
    23. models.common.Concat 网络层数  22 输出: torch.Size([1, 1280, 8, 8])
    24. models.common.C3 网络层数  23 输出: torch.Size([1, 1280, 8, 8])

    代码如下：

    1. class Model(nn.Module):
    2.     # YOLOv5 model
    3.     def __init__(self, cfg='yolov5s.yaml', ch=3, nc=None, anchors=None):  # model, input channels, number of classes
    4.         super().__init__()
    5.         if isinstance(cfg, dict):
    6.             self.yaml = cfg  # model dict
    7.         else:  # is *.yaml
    8.             import yaml  # for torch hub
    9.             self.yaml_file = Path(cfg).name
    10.             with open(cfg, encoding='ascii', errors='ignore') as f:
    11.                 self.yaml = yaml.safe_load(f)  # model dict
    12.  
    13.         # Define model
    14.         ch = self.yaml['ch'] = self.yaml.get('ch', ch)  # input channels
    15.         if nc and nc != self.yaml['nc']:
    16.             LOGGER.info(f"Overriding model.yaml nc={self.yaml['nc']} with nc={nc}")
    17.             self.yaml['nc'] = nc  # override yaml value
    18.         if anchors:
    19.             LOGGER.info(f'Overriding model.yaml anchors with anchors={anchors}')
    20.             self.yaml['anchors'] = round(anchors)  # override yaml value
    21.         # 根据参数、构建模型  self.save:保留需要连接的层
    22.         self.model, self.save = parse_model(deepcopy(self.yaml), ch=[ch])  # model, savelist
    23.         self.names = [str(i) for i in range(self.yaml['nc'])]  # default names
    24.         self.inplace = self.yaml.get('inplace', True)
    25.  
    26.         # Build strides, anchors
    27.         m = self.model[-1]  # Detect()
    28.         if isinstance(m, Detect):
    29.             s = 256  # 2x min stride
    30.             m.inplace = self.inplace
    31.             # ch:input channels s:
    32.             m.stride = torch.tensor([s / x.shape[-2] for x in self.forward(torch.zeros(1, ch, s, s))])  # forward
    33.             check_anchor_order(m)  # must be in pixel-space (not grid-space) 检查顺序是否正确
    34.             m.anchors /= m.stride.view(-1, 1, 1) # 各特征层的anchors
    35.             self.stride = m.stride # [8,16,32]
    36.             self._initialize_biases()  # only run once
    37.  
    38.         # Init weights, biases
    39.         initialize_weights(self)
    40.         self.info()
    41.         LOGGER.info('')
    42.  
    43.     def forward(self, x, augment=False, profile=False, visualize=False):
    44.         if augment:
    45.             return self._forward_augment(x)  # augmented inference, None
    46.         return self._forward_once(x, profile, visualize)  # single-scale inference, train
    47.  
    48.     def _forward_augment(self, x):
    49.         img_size = x.shape[-2:]  # height, width
    50.         s = [1, 0.83, 0.67]  # scales
    51.         f = [None, 3, None]  # flips (2-ud, 3-lr)
    52.         y = []  # outputs
    53.         for si, fi in zip(s, f):
    54.             xi = scale_img(x.flip(fi) if fi else x, si, gs=int(self.stride.max()))
    55.             yi = self._forward_once(xi)[0]  # forward
    56.             # cv2.imwrite(f'img_{si}.jpg', 255 * xi[0].cpu().numpy().transpose((1, 2, 0))[:, :, ::-1])  # save
    57.             yi = self._descale_pred(yi, fi, si, img_size)
    58.             y.append(yi)
    59.         y = self._clip_augmented(y)  # clip augmented tails
    60.         return torch.cat(y, 1), None  # augmented inference, train
    61.  
    62.     def _forward_once(self, x, profile=False, visualize=False):
    63.         y, dt = [], []  # outputs
    64.         for m in self.model:
    65.             if m.f != -1:  # if not from previous layer
    66.                 x = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f]  # from earlier layers
    67.             if profile:
    68.                 self._profile_one_layer(m, x, dt)
    69.             x = m(x)  # run
    70.             print(m.type,"网络层数 ",m.i,"输出:",x.shape)
    71.             y.append(x if m.i in self.save else None)  # save output
    72.             if visualize:
    73.                 feature_visualization(x, m.type, m.i, save_dir=visualize)
    74.         return x
    75.  
    76.     def _descale_pred(self, p, flips, scale, img_size):
    77.         # de-scale predictions following augmented inference (inverse operation)
    78.         if self.inplace:
    79.             p[..., :4] /= scale  # de-scale
    80.             if flips == 2:
    81.                 p[..., 1] = img_size[0] - p[..., 1]  # de-flip ud
    82.             elif flips == 3:
    83.                 p[..., 0] = img_size[1] - p[..., 0]  # de-flip lr
    84.         else:
    85.             x, y, wh = p[..., 0:1] / scale, p[..., 1:2] / scale, p[..., 2:4] / scale  # de-scale
    86.             if flips == 2:
    87.                 y = img_size[0] - y  # de-flip ud
    88.             elif flips == 3:
    89.                 x = img_size[1] - x  # de-flip lr
    90.             p = torch.cat((x, y, wh, p[..., 4:]), -1)
    91.         return p
    92.  
    93.     def _clip_augmented(self, y):
    94.         # Clip YOLOv5 augmented inference tails
    95.         nl = self.model[-1].nl  # number of detection layers (P3-P5)
    96.         g = sum(4 ** x for x in range(nl))  # grid points
    97.         e = 1  # exclude layer count
    98.         i = (y[0].shape[1] // g) * sum(4 ** x for x in range(e))  # indices
    99.         y[0] = y[0][:, :-i]  # large
    100.         i = (y[-1].shape[1] // g) * sum(4 ** (nl - 1 - x) for x in range(e))  # indices
    101.         y[-1] = y[-1][:, i:]  # small
    102.         return y
    103.  
    104.     def _profile_one_layer(self, m, x, dt):
    105.         c = isinstance(m, Detect)  # is final layer, copy input as inplace fix
    106.         o = thop.profile(m, inputs=(x.copy() if c else x,), verbose=False)[0] / 1E9 * 2 if thop else 0  # FLOPs
    107.         t = time_sync()
    108.         for _ in range(10):
    109.             m(x.copy() if c else x)
    110.         dt.append((time_sync() - t) * 100)
    111.         if m == self.model[0]:
    112.             LOGGER.info(f"{'time (ms)':>10s} {'GFLOPs':>10s} {'params':>10s}  module")
    113.         LOGGER.info(f'{dt[-1]:10.2f} {o:10.2f} {m.np:10.0f}  {m.type}')
    114.         if c:
    115.             LOGGER.info(f"{sum(dt):10.2f} {'-':>10s} {'-':>10s}  Total")
    116.  
    117.     def _initialize_biases(self, cf=None):  # initialize biases into Detect(), cf is class frequency
    118.         # https://arxiv.org/abs/1708.02002 section 3.3
    119.         # cf = torch.bincount(torch.tensor(np.concatenate(dataset.labels, 0)[:, 0]).long(), minlength=nc) + 1.
    120.         m = self.model[-1]  # Detect() module
    121.         for mi, s in zip(m.m, m.stride):  # from
    122.             b = mi.bias.view(m.na, -1).detach()  # conv.bias(255) to (3,85)
    123.             b[:, 4] += math.log(8 / (640 / s) ** 2)  # obj (8 objects per 640 image)
    124.             b[:, 5:] += math.log(0.6 / (m.nc - 0.999999)) if cf is None else torch.log(cf / cf.sum())  # cls
    125.             mi.bias = torch.nn.Parameter(b.view(-1), requires_grad=True)
    126.  
    127.     def _print_biases(self):
    128.         m = self.model[-1]  # Detect() module
    129.         for mi in m.m:  # from
    130.             b = mi.bias.detach().view(m.na, -1).T  # conv.bias(255) to (3,85)
    131.             LOGGER.info(
    132.                 ('%6g Conv2d.bias:' + '%10.3g' * 6) % (mi.weight.shape[1], *b[:5].mean(1).tolist(), b[5:].mean()))
    133.  
    134.     # def _print_weights(self):
    135.     #     for m in self.model.modules():
    136.     #         if type(m) is Bottleneck:
    137.     #             LOGGER.info('%10.3g' % (m.w.detach().sigmoid() * 2))  # shortcut weights
    138.  
    139.     def fuse(self):  # fuse model Conv2d() + BatchNorm2d() layers
    140.         LOGGER.info('Fusing layers... ')
    141.         for m in self.model.modules():
    142.             if isinstance(m, (Conv, DWConv)) and hasattr(m, 'bn'):
    143.                 m.conv = fuse_conv_and_bn(m.conv, m.bn)  # update conv
    144.                 delattr(m, 'bn')  # remove batchnorm
    145.                 m.forward = m.forward_fuse  # update forward
    146.         self.info()
    147.         return self
    148.  
    149.     def info(self, verbose=False, img_size=640):  # print model information
    150.         model_info(self, verbose, img_size)
    151.  
    152.     def _apply(self, fn):
    153.         # Apply to(), cpu(), cuda(), half() to model tensors that are not parameters or registered buffers
    154.         self = super()._apply(fn)
    155.         m = self.model[-1]  # Detect()
    156.         if isinstance(m, Detect):
    157.             m.stride = fn(m.stride)
    158.             m.grid = list(map(fn, m.grid))
    159.             if isinstance(m.anchor_grid, list):
    160.                 m.anchor_grid = list(map(fn, m.anchor_grid))
    161.         return self

    4.训练参数解释 

     

    --weights:初始权重
--cfg:模型配置文件
--data:数据配置文件
--hyp:学习率等超参数文件
--epochs:迭代次数
-imgsz：图像大小
--rect：长方形训练策略，不resize成正方形
--resume:恢复最近的培训,从last.pt开始
--nosave:只保存最后的检查点
--noval：仅在最后一次epochs进行验证
--noautoanchor：禁用AutoAnchor
--noplots：不保存打印文件
--evolve：为x个epochs进化超参数
--bucket:上传操作
--cache:在ram或硬盘中缓存数据
--image-weights:使用加权图像选择进行训练（类别加权）
--single-cls：单类别标签置0 
--device：gpu设置  
--multi-scale:改变img大小+/-50%,能够被32整除
--optimizer:学习率优化器
--sync-bn：使用SyncBatchNorm，仅在DDP模式中支持，跨gpu时使用
--workers:最大 dataloader 的线程数 (per RANK in DDP mode)
--project：保存文件的地址
--name：保存日志文件的名称
----exist-ok:现有项目/名称确定，不递增
--quad
--cos-lr:余弦学习率调度
--label-smoothing：
--patience：经过多少个epoch损失不再下降，就停止迭代
--freeze：迁移学习，冻结训练
--save-period：每x个周期保存一个检查点（如果＜1，则禁用）
--seed：
--local_rank：gpu编号

     

           

  • 相关阅读:
    iOS代码混淆工具推荐：IPA Guard详细介绍
    CSRF防范介绍之一
    无代码开发打印模板入门教程
    java数据结构与算法刷题-----LeetCode572. 另一棵树的子树（经典题，树字符串化KMP）
    【历史上的今天】8 月 15 日：苹果推出初代 iMac；谷歌收购摩托罗拉移动；Fuchsia 首次发布
    【Java-框架-SpringMVC】(01) SpringMVC框架的简单创建与使用，快速上手 - 简易版
    动态内存开辟（上）
    算法随想录算法训练营第四十三天|300.最长递增子序列 674. 最长连续递增序列 718. 最长重复子数组
    【毕业设计】远程智能浇花灌溉系统 - stm32 单片机 嵌入式 物联网
    Git的使用
  • 原文地址：https://blog.csdn.net/qq_52053775/article/details/126425760