You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

67 lines
2.5KB

  1. # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
  2. """
  3. Auto-batch utils
  4. """
  5. from copy import deepcopy
  6. import numpy as np
  7. import torch
  8. from utils.general import LOGGER, colorstr, emojis
  9. from utils.torch_utils import profile
  10. def check_train_batch_size(model, imgsz=640, amp=True):
  11. # Check YOLOv5 training batch size
  12. with torch.cuda.amp.autocast(amp):
  13. return autobatch(deepcopy(model).train(), imgsz) # compute optimal batch size
  14. def autobatch(model, imgsz=640, fraction=0.9, batch_size=16):
  15. # Automatically estimate best batch size to use `fraction` of available CUDA memory
  16. # Usage:
  17. # import torch
  18. # from utils.autobatch import autobatch
  19. # model = torch.hub.load('ultralytics/yolov5', 'yolov5s', autoshape=False)
  20. # print(autobatch(model))
  21. # Check device
  22. prefix = colorstr('AutoBatch: ')
  23. LOGGER.info(f'{prefix}Computing optimal batch size for --imgsz {imgsz}')
  24. device = next(model.parameters()).device # get model device
  25. if device.type == 'cpu':
  26. LOGGER.info(f'{prefix}CUDA not detected, using default CPU batch-size {batch_size}')
  27. return batch_size
  28. # Inspect CUDA memory
  29. gb = 1 << 30 # bytes to GiB (1024 ** 3)
  30. d = str(device).upper() # 'CUDA:0'
  31. properties = torch.cuda.get_device_properties(device) # device properties
  32. t = properties.total_memory / gb # GiB total
  33. r = torch.cuda.memory_reserved(device) / gb # GiB reserved
  34. a = torch.cuda.memory_allocated(device) / gb # GiB allocated
  35. f = t - (r + a) # GiB free
  36. LOGGER.info(f'{prefix}{d} ({properties.name}) {t:.2f}G total, {r:.2f}G reserved, {a:.2f}G allocated, {f:.2f}G free')
  37. # Profile batch sizes
  38. batch_sizes = [1, 2, 4, 8, 16]
  39. try:
  40. img = [torch.zeros(b, 3, imgsz, imgsz) for b in batch_sizes]
  41. results = profile(img, model, n=3, device=device)
  42. except Exception as e:
  43. LOGGER.warning(f'{prefix}{e}')
  44. # Fit a solution
  45. y = [x[2] for x in results if x] # memory [2]
  46. p = np.polyfit(batch_sizes[:len(y)], y, deg=1) # first degree polynomial fit
  47. b = int((f * fraction - p[1]) / p[0]) # y intercept (optimal batch size)
  48. if None in results: # some sizes failed
  49. i = results.index(None) # first fail index
  50. if b >= batch_sizes[i]: # y intercept above failure point
  51. b = batch_sizes[max(i - 1, 0)] # select prior safe point
  52. fraction = np.polyval(p, b) / t # actual fraction predicted
  53. LOGGER.info(emojis(f'{prefix}Using batch-size {b} for {d} {t * fraction:.2f}G/{t:.2f}G ({fraction * 100:.0f}%) ✅'))
  54. return b