Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.

4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
4 lat temu
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340
  1. import argparse
  2. import json
  3. import os
  4. from pathlib import Path
  5. from threading import Thread
  6. import numpy as np
  7. import torch
  8. import yaml
  9. from tqdm import tqdm
  10. from models.experimental import attempt_load
  11. from utils.datasets import create_dataloader
  12. from utils.general import coco80_to_coco91_class, check_dataset, check_file, check_img_size, check_requirements, \
  13. box_iou, non_max_suppression, scale_coords, xyxy2xywh, xywh2xyxy, set_logging, increment_path, colorstr
  14. from utils.metrics import ap_per_class, ConfusionMatrix
  15. from utils.plots import plot_images, output_to_target, plot_study_txt
  16. from utils.torch_utils import select_device, time_synchronized
  17. def test(data,
  18. weights=None,
  19. batch_size=32,
  20. imgsz=640,
  21. conf_thres=0.001,
  22. iou_thres=0.6, # for NMS
  23. save_json=False,
  24. single_cls=False,
  25. augment=False,
  26. verbose=False,
  27. model=None,
  28. dataloader=None,
  29. save_dir=Path(''), # for saving images
  30. save_txt=False, # for auto-labelling
  31. save_hybrid=False, # for hybrid auto-labelling
  32. save_conf=False, # save auto-label confidences
  33. plots=True,
  34. log_imgs=0, # number of logged images
  35. compute_loss=None):
  36. # Initialize/load model and set device
  37. training = model is not None
  38. if training: # called by train.py
  39. device = next(model.parameters()).device # get model device
  40. else: # called directly
  41. set_logging()
  42. device = select_device(opt.device, batch_size=batch_size)
  43. # Directories
  44. save_dir = Path(increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok)) # increment run
  45. (save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True) # make dir
  46. # Load model
  47. model = attempt_load(weights, map_location=device) # load FP32 model
  48. gs = max(int(model.stride.max()), 32) # grid size (max stride)
  49. imgsz = check_img_size(imgsz, s=gs) # check img_size
  50. # Multi-GPU disabled, incompatible with .half() https://github.com/ultralytics/yolov5/issues/99
  51. # if device.type != 'cpu' and torch.cuda.device_count() > 1:
  52. # model = nn.DataParallel(model)
  53. # Half
  54. half = device.type != 'cpu' # half precision only supported on CUDA
  55. if half:
  56. model.half()
  57. # Configure
  58. model.eval()
  59. is_coco = data.endswith('coco.yaml') # is COCO dataset
  60. with open(data) as f:
  61. data = yaml.load(f, Loader=yaml.SafeLoader) # model dict
  62. check_dataset(data) # check
  63. nc = 1 if single_cls else int(data['nc']) # number of classes
  64. iouv = torch.linspace(0.5, 0.95, 10).to(device) # iou vector for mAP@0.5:0.95
  65. niou = iouv.numel()
  66. # Logging
  67. log_imgs, wandb = min(log_imgs, 100), None # ceil
  68. try:
  69. import wandb # Weights & Biases
  70. except ImportError:
  71. log_imgs = 0
  72. # Dataloader
  73. if not training:
  74. if device.type != 'cpu':
  75. model(torch.zeros(1, 3, imgsz, imgsz).to(device).type_as(next(model.parameters()))) # run once
  76. path = data['test'] if opt.task == 'test' else data['val'] # path to val/test images
  77. dataloader = create_dataloader(path, imgsz, batch_size, gs, opt, pad=0.5, rect=True,
  78. prefix=colorstr('test: ' if opt.task == 'test' else 'val: '))[0]
  79. seen = 0
  80. confusion_matrix = ConfusionMatrix(nc=nc)
  81. names = {k: v for k, v in enumerate(model.names if hasattr(model, 'names') else model.module.names)}
  82. coco91class = coco80_to_coco91_class()
  83. s = ('%20s' + '%12s' * 6) % ('Class', 'Images', 'Targets', 'P', 'R', 'mAP@.5', 'mAP@.5:.95')
  84. p, r, f1, mp, mr, map50, map, t0, t1 = 0., 0., 0., 0., 0., 0., 0., 0., 0.
  85. loss = torch.zeros(3, device=device)
  86. jdict, stats, ap, ap_class, wandb_images = [], [], [], [], []
  87. for batch_i, (img, targets, paths, shapes) in enumerate(tqdm(dataloader, desc=s)):
  88. img = img.to(device, non_blocking=True)
  89. img = img.half() if half else img.float() # uint8 to fp16/32
  90. img /= 255.0 # 0 - 255 to 0.0 - 1.0
  91. targets = targets.to(device)
  92. nb, _, height, width = img.shape # batch size, channels, height, width
  93. with torch.no_grad():
  94. # Run model
  95. t = time_synchronized()
  96. out, train_out = model(img, augment=augment) # inference and training outputs
  97. t0 += time_synchronized() - t
  98. # Compute loss
  99. if compute_loss:
  100. loss += compute_loss([x.float() for x in train_out], targets)[1][:3] # box, obj, cls
  101. # Run NMS
  102. targets[:, 2:] *= torch.Tensor([width, height, width, height]).to(device) # to pixels
  103. lb = [targets[targets[:, 0] == i, 1:] for i in range(nb)] if save_hybrid else [] # for autolabelling
  104. t = time_synchronized()
  105. out = non_max_suppression(out, conf_thres=conf_thres, iou_thres=iou_thres, labels=lb, multi_label=True)
  106. t1 += time_synchronized() - t
  107. # Statistics per image
  108. for si, pred in enumerate(out):
  109. labels = targets[targets[:, 0] == si, 1:]
  110. nl = len(labels)
  111. tcls = labels[:, 0].tolist() if nl else [] # target class
  112. path = Path(paths[si])
  113. seen += 1
  114. if len(pred) == 0:
  115. if nl:
  116. stats.append((torch.zeros(0, niou, dtype=torch.bool), torch.Tensor(), torch.Tensor(), tcls))
  117. continue
  118. # Predictions
  119. predn = pred.clone()
  120. scale_coords(img[si].shape[1:], predn[:, :4], shapes[si][0], shapes[si][1]) # native-space pred
  121. # Append to text file
  122. if save_txt:
  123. gn = torch.tensor(shapes[si][0])[[1, 0, 1, 0]] # normalization gain whwh
  124. for *xyxy, conf, cls in predn.tolist():
  125. xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist() # normalized xywh
  126. line = (cls, *xywh, conf) if save_conf else (cls, *xywh) # label format
  127. with open(save_dir / 'labels' / (path.stem + '.txt'), 'a') as f:
  128. f.write(('%g ' * len(line)).rstrip() % line + '\n')
  129. # W&B logging
  130. if plots and len(wandb_images) < log_imgs:
  131. box_data = [{"position": {"minX": xyxy[0], "minY": xyxy[1], "maxX": xyxy[2], "maxY": xyxy[3]},
  132. "class_id": int(cls),
  133. "box_caption": "%s %.3f" % (names[cls], conf),
  134. "scores": {"class_score": conf},
  135. "domain": "pixel"} for *xyxy, conf, cls in pred.tolist()]
  136. boxes = {"predictions": {"box_data": box_data, "class_labels": names}} # inference-space
  137. wandb_images.append(wandb.Image(img[si], boxes=boxes, caption=path.name))
  138. # Append to pycocotools JSON dictionary
  139. if save_json:
  140. # [{"image_id": 42, "category_id": 18, "bbox": [258.15, 41.29, 348.26, 243.78], "score": 0.236}, ...
  141. image_id = int(path.stem) if path.stem.isnumeric() else path.stem
  142. box = xyxy2xywh(predn[:, :4]) # xywh
  143. box[:, :2] -= box[:, 2:] / 2 # xy center to top-left corner
  144. for p, b in zip(pred.tolist(), box.tolist()):
  145. jdict.append({'image_id': image_id,
  146. 'category_id': coco91class[int(p[5])] if is_coco else int(p[5]),
  147. 'bbox': [round(x, 3) for x in b],
  148. 'score': round(p[4], 5)})
  149. # Assign all predictions as incorrect
  150. correct = torch.zeros(pred.shape[0], niou, dtype=torch.bool, device=device)
  151. if nl:
  152. detected = [] # target indices
  153. tcls_tensor = labels[:, 0]
  154. # target boxes
  155. tbox = xywh2xyxy(labels[:, 1:5])
  156. scale_coords(img[si].shape[1:], tbox, shapes[si][0], shapes[si][1]) # native-space labels
  157. if plots:
  158. confusion_matrix.process_batch(predn, torch.cat((labels[:, 0:1], tbox), 1))
  159. # Per target class
  160. for cls in torch.unique(tcls_tensor):
  161. ti = (cls == tcls_tensor).nonzero(as_tuple=False).view(-1) # prediction indices
  162. pi = (cls == pred[:, 5]).nonzero(as_tuple=False).view(-1) # target indices
  163. # Search for detections
  164. if pi.shape[0]:
  165. # Prediction to target ious
  166. ious, i = box_iou(predn[pi, :4], tbox[ti]).max(1) # best ious, indices
  167. # Append detections
  168. detected_set = set()
  169. for j in (ious > iouv[0]).nonzero(as_tuple=False):
  170. d = ti[i[j]] # detected target
  171. if d.item() not in detected_set:
  172. detected_set.add(d.item())
  173. detected.append(d)
  174. correct[pi[j]] = ious[j] > iouv # iou_thres is 1xn
  175. if len(detected) == nl: # all targets already located in image
  176. break
  177. # Append statistics (correct, conf, pcls, tcls)
  178. stats.append((correct.cpu(), pred[:, 4].cpu(), pred[:, 5].cpu(), tcls))
  179. # Plot images
  180. if plots and batch_i < 3:
  181. f = save_dir / f'test_batch{batch_i}_labels.jpg' # labels
  182. Thread(target=plot_images, args=(img, targets, paths, f, names), daemon=True).start()
  183. f = save_dir / f'test_batch{batch_i}_pred.jpg' # predictions
  184. Thread(target=plot_images, args=(img, output_to_target(out), paths, f, names), daemon=True).start()
  185. # Compute statistics
  186. stats = [np.concatenate(x, 0) for x in zip(*stats)] # to numpy
  187. if len(stats) and stats[0].any():
  188. p, r, ap, f1, ap_class = ap_per_class(*stats, plot=plots, save_dir=save_dir, names=names)
  189. ap50, ap = ap[:, 0], ap.mean(1) # AP@0.5, AP@0.5:0.95
  190. mp, mr, map50, map = p.mean(), r.mean(), ap50.mean(), ap.mean()
  191. nt = np.bincount(stats[3].astype(np.int64), minlength=nc) # number of targets per class
  192. else:
  193. nt = torch.zeros(1)
  194. # Print results
  195. pf = '%20s' + '%12.3g' * 6 # print format
  196. print(pf % ('all', seen, nt.sum(), mp, mr, map50, map))
  197. # Print results per class
  198. if (verbose or (nc < 50 and not training)) and nc > 1 and len(stats):
  199. for i, c in enumerate(ap_class):
  200. print(pf % (names[c], seen, nt[c], p[i], r[i], ap50[i], ap[i]))
  201. # Print speeds
  202. t = tuple(x / seen * 1E3 for x in (t0, t1, t0 + t1)) + (imgsz, imgsz, batch_size) # tuple
  203. if not training:
  204. print('Speed: %.1f/%.1f/%.1f ms inference/NMS/total per %gx%g image at batch-size %g' % t)
  205. # Plots
  206. if plots:
  207. confusion_matrix.plot(save_dir=save_dir, names=list(names.values()))
  208. if wandb and wandb.run:
  209. val_batches = [wandb.Image(str(f), caption=f.name) for f in sorted(save_dir.glob('test*.jpg'))]
  210. wandb.log({"Images": wandb_images, "Validation": val_batches}, commit=False)
  211. # Save JSON
  212. if save_json and len(jdict):
  213. w = Path(weights[0] if isinstance(weights, list) else weights).stem if weights is not None else '' # weights
  214. anno_json = '../coco/annotations/instances_val2017.json' # annotations json
  215. pred_json = str(save_dir / f"{w}_predictions.json") # predictions json
  216. print('\nEvaluating pycocotools mAP... saving %s...' % pred_json)
  217. with open(pred_json, 'w') as f:
  218. json.dump(jdict, f)
  219. try: # https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocoEvalDemo.ipynb
  220. from pycocotools.coco import COCO
  221. from pycocotools.cocoeval import COCOeval
  222. anno = COCO(anno_json) # init annotations api
  223. pred = anno.loadRes(pred_json) # init predictions api
  224. eval = COCOeval(anno, pred, 'bbox')
  225. if is_coco:
  226. eval.params.imgIds = [int(Path(x).stem) for x in dataloader.dataset.img_files] # image IDs to evaluate
  227. eval.evaluate()
  228. eval.accumulate()
  229. eval.summarize()
  230. map, map50 = eval.stats[:2] # update results (mAP@0.5:0.95, mAP@0.5)
  231. except Exception as e:
  232. print(f'pycocotools unable to run: {e}')
  233. # Return results
  234. if not training:
  235. s = f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}" if save_txt else ''
  236. print(f"Results saved to {save_dir}{s}")
  237. model.float() # for training
  238. maps = np.zeros(nc) + map
  239. for i, c in enumerate(ap_class):
  240. maps[c] = ap[i]
  241. return (mp, mr, map50, map, *(loss.cpu() / len(dataloader)).tolist()), maps, t
  242. if __name__ == '__main__':
  243. parser = argparse.ArgumentParser(prog='test.py')
  244. parser.add_argument('--weights', nargs='+', type=str, default='yolov5s.pt', help='model.pt path(s)')
  245. parser.add_argument('--data', type=str, default='data/coco128.yaml', help='*.data path')
  246. parser.add_argument('--batch-size', type=int, default=32, help='size of each image batch')
  247. parser.add_argument('--img-size', type=int, default=640, help='inference size (pixels)')
  248. parser.add_argument('--conf-thres', type=float, default=0.001, help='object confidence threshold')
  249. parser.add_argument('--iou-thres', type=float, default=0.6, help='IOU threshold for NMS')
  250. parser.add_argument('--task', default='val', help="'val', 'test', 'study'")
  251. parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
  252. parser.add_argument('--single-cls', action='store_true', help='treat as single-class dataset')
  253. parser.add_argument('--augment', action='store_true', help='augmented inference')
  254. parser.add_argument('--verbose', action='store_true', help='report mAP by class')
  255. parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
  256. parser.add_argument('--save-hybrid', action='store_true', help='save label+prediction hybrid results to *.txt')
  257. parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
  258. parser.add_argument('--save-json', action='store_true', help='save a cocoapi-compatible JSON results file')
  259. parser.add_argument('--project', default='runs/test', help='save to project/name')
  260. parser.add_argument('--name', default='exp', help='save to project/name')
  261. parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
  262. opt = parser.parse_args()
  263. opt.save_json |= opt.data.endswith('coco.yaml')
  264. opt.data = check_file(opt.data) # check file
  265. print(opt)
  266. check_requirements()
  267. if opt.task in ['val', 'test']: # run normally
  268. test(opt.data,
  269. opt.weights,
  270. opt.batch_size,
  271. opt.img_size,
  272. opt.conf_thres,
  273. opt.iou_thres,
  274. opt.save_json,
  275. opt.single_cls,
  276. opt.augment,
  277. opt.verbose,
  278. save_txt=opt.save_txt | opt.save_hybrid,
  279. save_hybrid=opt.save_hybrid,
  280. save_conf=opt.save_conf,
  281. )
  282. elif opt.task == 'speed': # speed benchmarks
  283. for w in opt.weights:
  284. test(opt.data, w, opt.batch_size, opt.img_size, 0.25, 0.45, save_json=False, plots=False)
  285. elif opt.task == 'study': # run over a range of settings and save/plot
  286. x = list(range(256, 1536 + 128, 128)) # x axis (image sizes)
  287. for w in opt.weights:
  288. f = f'study_{Path(opt.data).stem}_{Path(w).stem}.txt' # filename to save to
  289. y = [] # y axis
  290. for i in x: # img-size
  291. print(f'\nRunning {f} point {i}...')
  292. r, _, t = test(opt.data, w, opt.batch_size, i, opt.conf_thres, opt.iou_thres, opt.save_json,
  293. plots=False)
  294. y.append(r + t) # results and times
  295. np.savetxt(f, y, fmt='%10.4g') # save
  296. os.system('zip -r study.zip study_*.txt')
  297. plot_study_txt(x=x) # plot