def notebook_init(verbose=True):
# Check system software and hardware
print("Checking setup...")
import os
import shutil
from yolov5.utils.general import check_requirements, emojis, is_colab
from yolov5.utils.torch_utils import select_device # imports
check_requirements(("psutil", "IPython"))
import psutil
from IPython import display # to display images and clear console output
if is_colab():
shutil.rmtree(
"/content/sample_data", ignore_errors=True
) # remove colab /sample_data directory
if verbose:
# System info
# gb = 1 / 1000 ** 3 # bytes to GB
gib = 1 / 1024 ** 3 # bytes to GiB
ram = psutil.virtual_memory().total
total, used, free = shutil.disk_usage("/")
display.clear_output()
s = f"({os.cpu_count()} CPUs, {ram * gib:.1f} GB RAM, {(total - free) * gib:.1f}/{total * gib:.1f} GB disk)"
else:
s = ""
select_device(newline=False)
print(emojis(f"Setup complete ✅ {s}"))
return display
def __init__(self, weights,service_name, image_size=640, nms_conf_thresh=0.4, nms_iou_thresh=0.5, device=""):
try:
from yolov5.utils.general import set_logging
from yolov5.utils.torch_utils import select_device
from yolov5.models.experimental import attempt_load
from yolov5.utils.general import check_img_size
from yolov5.utils.general import non_max_suppression
from yolov5.utils.general import scale_coords
from yolov5.utils.datasets import letterbox
except ImportError:
raise
self.device = select_device(device)
self.conf_thresh = nms_conf_thresh
self.iou_thresh = nms_iou_thresh
self.half = self.device.type != 'cpu'
self.model = attempt_load(weights, map_location=self.device)
self.image_size = check_img_size(image_size, s=self.model.stride.max())
if self.half:
self.model.half() # to FP16
self.names = self.model.module.names if hasattr(self.model, 'module') else self.model.names
self.currently_busy = Event()
# Base class must be called at the end due to self.service_server.spin()
BaseDetectionServer.__init__(self, service_name=service_name)
def __init__(self):
self.conf = self.DETECTION_THRESHOLD
self.device = select_device()
self.model = DetectMultiBackend(paths.yolo_model, device=self.device)
self.model.model.half()
self.model.warmup(imgsz=(1, 3, *self.IMG_SIZE), half=True)
def __init__(self, transform, opt, save_img=False):
self.opt = opt
self.debug = opt.debug
self.save_txt = opt.save_txt
self.view_img = opt.view_img
self.transform = transform
self.save_img = save_img
self.fourcc = 'mp4v'
self.resolution = (
1920, 1080
) # Can also be set to False to get standard camera resolution
self.vid_writer = None
self.vid_path = None
self.out = self.create_dir(opt.output)
self.webcam = self.check_webcam(opt.source)
self.device = select_device(opt.device)
self.half = self.device.type != 'cpu' # half precision only supported on CUDA
self.model, self.imgsz, self.class_names = self.load_model()
self.overlay_images = self.get_overlay_icons()
self.banner_icon = self.get_banner_icon()
self.dataset = self.set_dataloader()
self.meta_data_writer = self.get_meta_data_writer()
set_logging()
def process_sample(image_filepath):
rospy.loginfo('Starting yolo sample node...')
rospy.init_node('sample', anonymous=True)
rospy.loginfo('Loading model...')
device = select_device('')
half = device.type != 'cpu' # half precision only supported on CUDA
# Load model
imgsz = 224
model = attempt_load(f'{os.path.dirname(__file__)}/yolov5/runs/train/exp4/weights/best.pt', map_location=device)
imgsz = check_img_size(imgsz, s=model.stride.max())
if half:
model.half()
rospy.loginfo('Reading image...')
im = cv2.imread(image_filepath)
if (im is None):
rospy.loginfo('Failed to read image.')
return
rospy.loginfo('Running inference...')
preds = detect(model, im)
rospy.loginfo('Predictions:')
for pred in preds:
rospy.loginfo(f' Class: {pred[0]}')
rospy.loginfo(f' Confidence: {pred[1]}')
rospy.loginfo(f' Bounds: {pred[2]}')
def custom(path_or_model='path/to/model.pt', autoshape=True):
"""YOLOv5-custom model from https://github.com/ultralytics/yolov5
Arguments (3 options):
path_or_model (str): 'path/to/model.pt'
path_or_model (dict): torch.load('path/to/model.pt')
path_or_model (nn.Module): torch.load('path/to/model.pt')['model']
Returns:
pytorch model
"""
model = torch.load(path_or_model) if isinstance(
path_or_model, str) else path_or_model # load checkpoint
if isinstance(model, dict):
model = model['ema' if model.get('ema') else 'model'] # load model
hub_model = Model(model.yaml).to(next(model.parameters()).device) # create
hub_model.load_state_dict(model.float().state_dict()) # load state_dict
hub_model.names = model.names # class names
if autoshape:
hub_model = hub_model.autoshape(
) # for file/URI/PIL/cv2/np inputs and NMS
device = select_device('0' if torch.cuda.is_available() else
'cpu') # default to GPU if available
return hub_model.to(device)
def load_model(self, weights: str, device: str = 'cuda') -> None:
device = select_device(device)
model = attempt_load(weights, map_location=device) # load FP32 model
half = device.type != 'cpu' # half precision only supported on CUDA
if half:
model.half() # to FP16
self.model = model
self.device = device
self.half = half
def load_model(self,dev="cpu"):
# Initialize
set_logging()
device = select_device(dev)
# Load model
# model = attempt_load("yolov5_model/yolov5x.pt", map_location=device) # load FP32 model
model = torch.hub.load('ultralytics/yolov5', 'custom', path_or_model='yolov5_model/yolov5x.pt')
stride = int(model.stride.max()) # model stride
imgsz = check_img_size(640, s=stride) # check img_size
# Run inference
if device.type != 'cpu':
model(torch.zeros(1, 3, imgsz, imgsz).to(device).type_as(next(model.parameters())))
return model,stride,device,imgsz
def load_models(self, weights_file_path, **kwargs):
"""
加载模型
:param model_file_path: weights文件路径
:param kwargs: 其它控制参数
"""
# 选择设备
device = torch_utils.select_device()
# 加载模型
model = experimental.attempt_load([
weights_file_path,
],
map_location=device)
model.float().eval()
self.model = model
self.device = device
def __init__(self):
rospy.loginfo('Starting yolo video node...')
rospy.init_node('yolo', anonymous=True)
self.bridge = CvBridge()
self.pointcloud = None
self.saved = False
rospy.loginfo('Loading model...')
device = select_device('')
half = device.type != 'cpu' # half precision only supported on CUDA
# Load model
imgsz = 224
self.model = attempt_load(
f'{os.path.dirname(__file__)}/yolov5/runs/train/exp4/weights/best.pt',
map_location=device)
imgsz = check_img_size(imgsz, s=self.model.stride.max())
if half:
self.model.half()
# Can you recycle dict
class_dict = dict()
class_dict['Cardboard'] = True
class_dict['Chips Bag'] = False
class_dict['Disposable Cup'] = False
class_dict['Napkin'] = False
class_dict['Plastic Bottle'] = True
class_dict['Plastic Container'] = True
class_dict['Soda Can'] = True
self.class_dict = class_dict
# Subscribe to pointcloud to make predictions
rospy.loginfo('Subscribing to camera pointcloud topic...')
rospy.Subscriber('camera/depth_registered/points', PointCloud2,
self.process_pointcloud)
rospy.loginfo('Awaiting images...')
# Create publisher to publish predictions
self.predict_pub = rospy.Publisher('yolo/detections',
String,
queue_size=10)
# Create publisher to publish markers to RViz
self.rviz_pub = rospy.Publisher('visualization_marker',
Marker,
queue_size=10)
def main(opt, callbacks=Callbacks()):
# Checks
if RANK in [-1, 0]:
print_args(FILE.stem, opt)
check_git_status()
check_requirements(exclude=['thop'])
# Resume
if opt.resume and not check_wandb_resume(opt): # resume an interrupted run
ckpt = opt.resume if isinstance(
opt.resume,
str) else get_latest_run() # specified or most recent path
assert os.path.isfile(
ckpt), 'ERROR: --resume checkpoint does not exist'
with open(Path(ckpt).parent.parent / 'opt.yaml', errors='ignore') as f:
opt = argparse.Namespace(**yaml.safe_load(f)) # replace
opt.cfg, opt.weights, opt.resume = '', ckpt, True # reinstate
LOGGER.info(f'Resuming training from {ckpt}')
else:
opt.data, opt.cfg, opt.hyp, opt.weights, opt.project = \
check_file(opt.data), check_yaml(opt.cfg), check_yaml(opt.hyp), str(opt.weights), str(opt.project) # checks
assert len(opt.cfg) or len(
opt.weights), 'either --cfg or --weights must be specified'
opt.save_dir = str(
increment_path(Path(opt.project) / opt.name,
exist_ok=opt.exist_ok))
# DDP mode
device = select_device(opt.device, batch_size=opt.batch_size)
if LOCAL_RANK != -1:
assert torch.cuda.device_count(
) > LOCAL_RANK, 'insufficient CUDA devices for DDP command'
assert opt.batch_size % WORLD_SIZE == 0, '--batch-size must be multiple of CUDA device count'
assert not opt.image_weights, '--image-weights argument is not compatible with DDP training'
torch.cuda.set_device(LOCAL_RANK)
device = torch.device('cuda', LOCAL_RANK)
dist.init_process_group(
backend="nccl" if dist.is_nccl_available() else "gloo")
# Train
train(opt.hyp, opt, device, callbacks)
if WORLD_SIZE > 1 and RANK == 0:
LOGGER.info('Destroying process group... ')
dist.destroy_process_group()
def __init__(self, args):
print('Initialize DeepSORT & YOLO-V5')
# ***************** Initialize ******************************************************
self.args = args
self.img_size = args.img_size # image size in detector, default is 640
self.frame_interval = args.frame_interval # frequency
self.device = select_device(args.device)
self.half = self.device.type != 'cpu' # half precision only supported on CUDA
# create video capture ****************
if args.display:
cv2.namedWindow("test", cv2.WINDOW_NORMAL)
cv2.resizeWindow("test", args.display_width, args.display_height)
if args.cam != -1:
print("Using webcam " + str(args.cam))
self.vdo = cv2.VideoCapture(args.cam)
else:
self.vdo = cv2.VideoCapture()
# ***************************** initialize DeepSORT **********************************
cfg = get_config()
cfg.merge_from_file(args.config_deepsort)
use_cuda = self.device.type != 'cpu' and torch.cuda.is_available()
self.deepsort = build_tracker(cfg, use_cuda=use_cuda)
# ***************************** initialize YOLO-V5 **********************************
self.detector = torch.load(
args.weights,
map_location=self.device)['model'].float() # load to FP32
self.detector.to(self.device).eval()
if self.half:
self.detector.half() # to FP16
self.names = self.detector.module.names if hasattr(
self.detector, 'module') else self.detector.names
print('Done..')
if self.device == 'cpu':
warnings.warn("Running in cpu mode which maybe very slow!",
UserWarning)
def __init__(self):
if not ModelLoader._instance:
print("ModelLoader.__init__ method called but nothing is created")
else:
print("ModelLoader instance already created", self.getInstance())
before = time.time()
self.__device = select_device('0')
# weights='yolov5/runs/train/exp/weights/best.pt'
weights = 'yolov5/runs/train/exp/weights/best.pt'
self.__model =attempt_load(weights, map_location=self.__device)
self.__modelc = load_classifier(name="resnet50", n=2)
self.__retrival = ImageRetrievalClass("MobileNetV3",True,False)
self.__retrival.buildModel(shape_img=(256,256,3))
after = time.time()
self.__elapsed_time = after-before
def create(name, pretrained, channels, classes, autoshape, verbose):
"""Creates a specified YOLOv5 model
Arguments:
name (str): name of model, i.e. 'yolov5s'
pretrained (bool): load pretrained weights into the model
channels (int): number of input channels
classes (int): number of model classes
Returns:
pytorch model
"""
try:
set_logging(verbose=verbose)
cfg = list((Path(__file__).parent /
'models').rglob(f'{name}.yaml'))[0] # model.yaml path
model = Model(cfg, channels, classes)
if pretrained:
fname = f'{name}.pt' # checkpoint filename
attempt_download(fname) # download if not found locally
ckpt = torch.load(fname, map_location=torch.device('cpu')) # load
msd = model.state_dict() # model state_dict
csd = ckpt['model'].float().state_dict(
) # checkpoint state_dict as FP32
csd = {k: v
for k, v in csd.items()
if msd[k].shape == v.shape} # filter
model.load_state_dict(csd, strict=False) # load
if len(ckpt['model'].names) == classes:
model.names = ckpt['model'].names # set class names attribute
if autoshape:
model = model.autoshape(
) # for file/URI/PIL/cv2/np inputs and NMS
device = select_device('0' if torch.cuda.is_available() else
'cpu') # default to GPU if available
return model.to(device)
except Exception as e:
help_url = 'https://github.com/ultralytics/yolov5/issues/36'
s = 'Cache maybe be out of date, try force_reload=True. See %s for help.' % help_url
raise Exception(s) from e
def sweep():
wandb.init()
# Get hyp dict from sweep agent
hyp_dict = vars(wandb.config).get("_items")
# Workaround: get necessary opt args
opt = parse_opt(known=True)
opt.batch_size = hyp_dict.get("batch_size")
opt.save_dir = str(
increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok))
opt.epochs = hyp_dict.get("epochs")
opt.nosave = True
opt.data = hyp_dict.get("data")
opt.weights = str(opt.weights)
opt.cfg = str(opt.cfg)
opt.data = str(opt.data)
opt.hyp = str(opt.hyp)
opt.project = str(opt.project)
device = select_device(opt.device, batch_size=opt.batch_size)
# train
train(hyp_dict, opt, device, callbacks=Callbacks())
def load_info(config_deepsort, device, imgsz, out, weights):
# initialize deepsort
cfg = get_config()
cfg.merge_from_file(config_deepsort)
deepsort = DeepSort(cfg.DEEPSORT.REID_CKPT,
max_dist=cfg.DEEPSORT.MAX_DIST,
min_confidence=cfg.DEEPSORT.MIN_CONFIDENCE,
nms_max_overlap=cfg.DEEPSORT.NMS_MAX_OVERLAP,
max_iou_distance=cfg.DEEPSORT.MAX_IOU_DISTANCE,
max_age=cfg.DEEPSORT.MAX_AGE,
n_init=cfg.DEEPSORT.N_INIT,
nn_budget=cfg.DEEPSORT.NN_BUDGET,
use_cuda=True)
# Initialize
device = select_device(device)
if not os.path.exists(out):
os.makedirs(out) # make new output folder
half = device.type != 'cpu' # half precision only supported on CUDA
# Load model
model = torch.load(weights,
map_location=device)['model'].float() # load to FP32
model.to(device).eval()
if half:
model.half() # to FP16
# Get names and colors
names = model.module.names if hasattr(model, 'module') else model.names
# Run inference
t0 = time.time()
img = torch.zeros((1, 3, imgsz, imgsz), device=device) # init img
_ = model(img.half() if half else img
) if device.type != 'cpu' else None # run once
return t0, half, device, model, names, deepsort
def __init__(self,
weights_path,
img_size=640,
device='',
conf_thres=0.5,
iou_thres=0.5,
classes=None):
self._weights_path = weights_path
self._img_size = img_size
self._device = select_device(device)
self._conf_thres = conf_thres
self._iou_thres = iou_thres
self._classes = classes
self._half = self._device.type != 'cpu' # half precision only supported on CUDA
# Load model
self._model = attempt_load(
self._weights_path, map_location=self._device) # load FP32 model
self._img_size = check_img_size(
self._img_size, s=self._model.stride.max()) # check img_size
if self._half:
self._model.half() # to FP16
def _create(
name,
pretrained=True,
channels=3,
classes=80,
autoshape=True,
verbose=True,
device=None,
):
"""Creates or loads a YOLOv5 model
Arguments:
name (str): model name 'yolov5s' or path 'path/to/best.pt'
pretrained (bool): load pretrained weights into the model
channels (int): number of input channels
classes (int): number of model classes
autoshape (bool): apply YOLOv5 .autoshape() wrapper to model
verbose (bool): print all information to screen
device (str, torch.device, None): device to use for model parameters
Returns:
YOLOv5 model
"""
from pathlib import Path
from yolov5.models.common import AutoShape, DetectMultiBackend
from yolov5.models.yolo import Model
from yolov5.utils.downloads import attempt_download
from yolov5.utils.general import (
LOGGER,
check_requirements,
intersect_dicts,
logging,
)
from yolov5.utils.torch_utils import select_device
if not verbose:
LOGGER.setLevel(logging.WARNING)
check_requirements(exclude=("tensorboard", "thop", "opencv-python"))
name = Path(name)
path = name.with_suffix(
".pt") if name.suffix == "" else name # checkpoint path
try:
device = select_device(("0" if torch.cuda.is_available() else "cpu"
) if device is None else device)
if pretrained and channels == 3 and classes == 80:
model = DetectMultiBackend(
path, device=device) # download/load FP32 model
# model = models.experimental.attempt_load(path, map_location=device) # download/load FP32 model
else:
cfg = list(
(Path(__file__).parent /
"models").rglob(f"{path.stem}.yaml"))[0] # model.yaml path
model = Model(cfg, channels, classes) # create model
if pretrained:
ckpt = torch.load(attempt_download(path),
map_location=device) # load
csd = (ckpt["model"].float().state_dict()
) # checkpoint state_dict as FP32
csd = intersect_dicts(csd,
model.state_dict(),
exclude=["anchors"]) # intersect
model.load_state_dict(csd, strict=False) # load
if len(ckpt["model"].names) == classes:
model.names = ckpt[
"model"].names # set class names attribute
if autoshape:
model = AutoShape(model) # for file/URI/PIL/cv2/np inputs and NMS
return model.to(device)
except Exception as e:
help_url = "https://github.com/ultralytics/yolov5/issues/36"
s = f"{e}. Cache may be out of date, try `force_reload=True` or see {help_url} for help."
raise Exception(s) from e
def detect(self, Image=None):
out, source, weights, view_img, save_txt, imgsz = \
self.output, self.source, self.weights, self.view_img, self.save_txt, self.img_size
webcam = source == '0' or source.startswith(
'rtsp') or source.startswith('http') or source.endswith('.txt')
# Initialize
device = torch_utils.select_device(self.device)
# if os.path.exists(out):
# shutil.rmtree(out) # delete output folder
# os.makedirs(out) # make new output folder
half = device.type != 'cpu' # half precision only supported on CUDA
# Load model
google_utils.attempt_download(weights)
model = torch.load(
weights, map_location=device)['model'].float() # load to FP32
# torch.save(torch.load(weights, map_location=device), weights) # update model if SourceChangeWarning
# model.fuse()
model.to(device).eval()
if half:
model.half() # to FP16
# Second-stage classifier
classify = False
if classify:
modelc = torch_utils.load_classifier(name='resnet101',
n=2) # initialize
modelc.load_state_dict(
torch.load('weights/resnet101.pt',
map_location=device)['model']) # load weights
modelc.to(device).eval()
# Set Dataloader
vid_path, vid_writer = None, None
if webcam:
view_img = True
cudnn.benchmark = True # set True to speed up constant image size inference
dataset = LoadStreams(source, img_size=imgsz)
else:
save_img = True
dataset = LoadImages(source, img_size=imgsz)
# Get names and colors
names = model.module.names if hasattr(model, 'module') else model.names
colors = [[random.randint(0, 255) for _ in range(3)]
for _ in range(len(names))]
# Run inference
t0 = time.time()
# img = torch.zeros((1, 3, imgsz, imgsz), device=device) # init img
im0s = np.frombuffer(Image.data, dtype=np.uint8).reshape(
Image.height, Image.width,
-1).astype('float32') # Added by Prasanth Suresh
# # run once
# _ = model(img.half() if half else img) if device.type != 'cpu' else None
img = letterbox(im0s, new_shape=imgsz)[0]
img = img[:, :, ::-1].transpose(2, 0, 1)
img = np.ascontiguousarray(img)
# # for path, img, im0s, vid_cap in dataset:
vid_cap = None
path = 'img.jpg'
img = torch.from_numpy(img).to(device)
img = img.half() if half else img.float() # uint8 to fp16/32
img /= 255.0 # 0 - 255 to 0.0 - 1.0
if img.ndimension() == 3:
img = img.unsqueeze(0)
# Inference
t1 = torch_utils.time_synchronized()
pred = model(img, augment=self.augment)[0]
# Apply NMS
pred = non_max_suppression(pred,
self.conf_thres,
self.iou_thres,
classes=self.classes,
agnostic=self.agnostic_nms)
t2 = torch_utils.time_synchronized()
# Apply Classifier
if classify:
pred = apply_classifier(pred, modelc, img, im0s)
# print('**** pred: ',pred)
''' Sorting the bounding boxes according to ascending x values '''
if pred[0] != None:
pred[0] = pred[0].cpu().numpy()
pred[0] = pred[0][pred[0][:, 0].argsort()]
pred[0] = torch.from_numpy(pred[0])
print('**** Sorted pred: \n', pred)
# Process detections
for i, det in enumerate(pred): # detections per image
if webcam: # batch_size >= 1
p, s, im0 = path[i], '%g: ' % i, im0s[i].copy()
else:
p, s, im0 = path, '', im0s
if det != None:
self.bounding_boxes.append(det)
save_path = str(Path(out) / Path(p).name)
s += '%gx%g ' % img.shape[2:] # print string
# normalization gain whwh
gn = torch.tensor(im0.shape)[[1, 0, 1, 0]]
if det is not None and len(det):
# Rescale boxes from img_size to im0s size
det[:, :4] = scale_coords(img.shape[2:], det[:, :4],
im0.shape).round()
# Print results
for c in det[:, -1].unique():
n = (det[:, -1] == c).sum() # detections per class
s += '%g %ss, ' % (n, names[int(c)]) # add to string
# Write results
minx = 0
miny = 0
maxx = 0
maxy = 0
for *xyxy, conf, cls in det:
tlx, tly, brx, bry = int(xyxy[0]), int(xyxy[1]), int(
xyxy[2]), int(xyxy[3])
if tlx < minx:
minx = tlx
if tly < miny:
miny = tly
if bry > maxy:
maxy = bry
if brx > maxx:
maxx = brx # crop_img = img[y:y+h, x:x+w]
if save_txt: # Write to file
xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) /
gn).view(-1).tolist() # normalized xywh
with open(save_path[:save_path.rfind('.')] + '.txt',
'a') as file:
file.write(('%g ' * 5 + '\n') %
(cls, *xywh)) # label format
if save_img or view_img: # Add bbox to image
label = '%s %.2f' % (names[int(cls)], conf)
plot_one_box(xyxy,
im0,
label=label,
color=colors[int(cls)],
line_thickness=3)
# Stream results
if view_img:
cv2.imshow(p, im0)
if cv2.waitKey(1) == ord('q'): # q to quit
raise StopIteration
# Save results (image with detections)
if save_img:
if dataset.mode == 'images':
cv2.imwrite(save_path, im0)
else:
if vid_path != save_path: # new video
vid_path = save_path
if isinstance(vid_writer, cv2.VideoWriter):
vid_writer.release(
) # release previous video writer
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
vid_writer = cv2.VideoWriter(
save_path, cv2.VideoWriter_fourcc(*self.fourcc),
fps, (w, h))
vid_writer.write(im0)
if save_txt or save_img:
print('Results saved to %s' % os.getcwd() + os.sep + out)
if platform == 'darwin': # MacOS
os.system('open ' + save_path)
################################ END OF COMMENTED OUT FOR LOOP TO RESTOR INDENT LATER ################################
print('Done. (%.3fs)' % (time.time() - t0))
return self.bounding_boxes
# if __name__ == '__main__':
# parser = argparse.ArgumentParser()
# parser.add_argument('--weights', type=str,
# default='weights/yolov5s.pt', help='model.pt path')
# # file/folder, 0 for webcam
# parser.add_argument('--source', type=str,
# default='inference/images', help='source')
# parser.add_argument('--output', type=str, default='inference/output',
# help='output folder') # output folder
# parser.add_argument('--img-size', type=int, default=640,
# help='inference size (pixels)')
# parser.add_argument('--conf-thres', type=float,
# default=0.4, help='object confidence threshold')
# parser.add_argument('--iou-thres', type=float,
# default=0.5, help='IOU threshold for NMS')
# parser.add_argument('--fourcc', type=str, default='mp4v',
# help='output video codec (verify ffmpeg support)')
# parser.add_argument('--device', default='',
# help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
# parser.add_argument('--view-img', action='store_true',
# help='display results')
# parser.add_argument('--save-txt', action='store_true',
# help='save results to *.txt')
# parser.add_argument('--classes', nargs='+',
# type=int, help='filter by class')
# parser.add_argument('--agnostic-nms', action='store_true',
# help='class-agnostic NMS')
# parser.add_argument('--augment', action='store_true',
# help='augmented inference')
# opt = parser.parse_args()
# opt.img_size = check_img_size(opt.img_size)
# print(opt)
# with torch.no_grad():
# detect()
# Update all models
# for opt.weights in ['yolov5s.pt', 'yolov5m.pt', 'yolov5l.pt', 'yolov5x.pt', 'yolov3-spp.pt']:
# detect()
# create_pretrained(opt.weights, opt.weights)
def detect(opt, save_img=False):
out, source, weights, view_img, save_txt, imgsz = \
opt.output, opt.source, opt.weights, opt.view_img, opt.save_txt, opt.img_size
webcam = source == '0' or source.startswith('rtsp') or source.startswith(
'http') or source.endswith('.txt')
# initialize deepsort
cfg = get_config()
cfg.merge_from_file(opt.config_deepsort)
deepsort = DeepSort(cfg.DEEPSORT.REID_CKPT,
max_dist=cfg.DEEPSORT.MAX_DIST,
min_confidence=cfg.DEEPSORT.MIN_CONFIDENCE,
nms_max_overlap=cfg.DEEPSORT.NMS_MAX_OVERLAP,
max_iou_distance=cfg.DEEPSORT.MAX_IOU_DISTANCE,
max_age=cfg.DEEPSORT.MAX_AGE,
n_init=cfg.DEEPSORT.N_INIT,
nn_budget=cfg.DEEPSORT.NN_BUDGET,
use_cuda=True)
# Initialize
device = select_device(opt.device)
if os.path.exists(out):
shutil.rmtree(out) # delete output folder
os.makedirs(out) # make new output folder
half = device.type != 'cpu' # half precision only supported on CUDA
# Load model
model = attempt_load(weights, map_location=device) # load FP32 model
stride = int(model.stride.max()) # model stride
imgsz = check_img_size(imgsz, s=stride) # check img_size
names = model.module.names if hasattr(
model, 'module') else model.names # get class names
if half:
model.half() # to FP16
# Set Dataloader
vid_path, vid_writer = None, None
if webcam:
view_img = True
cudnn.benchmark = True # set True to speed up constant image size inference
dataset = LoadStreams(source, img_size=imgsz)
else:
view_img = True
save_img = True
dataset = LoadImages(source, img_size=imgsz)
# Get names and colors
names = model.module.names if hasattr(model, 'module') else model.names
# Run inference
t0 = time.time()
img = torch.zeros((1, 3, imgsz, imgsz), device=device) # init img
# run once
_ = model(img.half() if half else img) if device.type != 'cpu' else None
save_path = str(Path(out))
txt_path = str(Path(out)) + '/results.txt'
for frame_idx, (path, img, im0s, vid_cap) in enumerate(dataset):
img = torch.from_numpy(img).to(device)
img = img.half() if half else img.float() # uint8 to fp16/32
img /= 255.0 # 0 - 255 to 0.0 - 1.0
if img.ndimension() == 3:
img = img.unsqueeze(0)
# Inference
t1 = time_synchronized()
pred = model(img, augment=opt.augment)[0]
# Apply NMS
pred = non_max_suppression(pred,
opt.conf_thres,
opt.iou_thres,
classes=opt.classes,
agnostic=opt.agnostic_nms)
t2 = time_synchronized()
# Process detections
for i, det in enumerate(pred): # detections per image
if webcam: # batch_size >= 1
p, s, im0 = path[i], '%g: ' % i, im0s[i].copy()
else:
p, s, im0 = path, '', im0s
s += '%gx%g ' % img.shape[2:] # print string
save_path = str(Path(out) / Path(p).name)
if det is not None and len(det):
# Rescale boxes from img_size to im0 size
det[:, :4] = scale_coords(img.shape[2:], det[:, :4],
im0.shape).round()
# Print results
for c in det[:, -1].unique():
n = (det[:, -1] == c).sum() # detections per class
s += '%g %ss, ' % (n, names[int(c)]) # add to string
bbox_xywh = []
confs = []
# Adapt detections to deep sort input format
for *xyxy, conf, cls in det:
x_c, y_c, bbox_w, bbox_h = bbox_rel(*xyxy)
obj = [x_c, y_c, bbox_w, bbox_h]
bbox_xywh.append(obj)
confs.append([conf.item()])
xywhs = torch.Tensor(bbox_xywh)
confss = torch.Tensor(confs)
# Pass detections to deepsort
outputs = deepsort.update(xywhs, confss, im0)
# draw boxes for visualization
if len(outputs) > 0:
bbox_xyxy = outputs[:, :4]
identities = outputs[:, -1]
draw_boxes(im0, bbox_xyxy, identities)
# Write MOT compliant results to file
if save_txt and len(outputs) != 0:
for j, output in enumerate(outputs):
bbox_left = output[0]
bbox_top = output[1]
bbox_w = output[2]
bbox_h = output[3]
identity = output[-1]
with open(txt_path, 'a') as f:
f.write(('%g ' * 10 + '\n') %
(frame_idx, identity, bbox_left, bbox_top,
bbox_w, bbox_h, -1, -1, -1,
-1)) # label format
else:
deepsort.increment_ages()
# Print time (inference + NMS)
print('%sDone. (%.3fs)' % (s, t2 - t1))
# Stream results
if view_img:
cv2.imshow(p, im0)
if cv2.waitKey(1) == ord('q'): # q to quit
raise StopIteration
# Save results (image with detections)
if save_img:
print('saving img!')
if dataset.mode == 'images':
cv2.imwrite(save_path, im0)
else:
print('saving video!')
if vid_path != save_path: # new video
vid_path = save_path
if isinstance(vid_writer, cv2.VideoWriter):
vid_writer.release(
) # release previous video writer
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
vid_writer = cv2.VideoWriter(
save_path, cv2.VideoWriter_fourcc(*opt.fourcc),
fps, (w, h))
vid_writer.write(im0)
if save_txt or save_img:
print('Results saved to %s' % os.getcwd() + os.sep + out)
if platform == 'darwin': # MacOS
os.system('open ' + save_path)
print('Done. (%.3fs)' % (time.time() - t0))
def __init__(self):
self.count = 0
self.root = tk.Tk()
self.out = "inference/output"
self.source = "inference/images"
self.weights = "yolov5/weights/yolov5s.pt"
self.view_img = False
self.save_txt = False
self.imgsz = 1088
self.iou_thres = 0.5
self.classes = [0, 1, 2, 3, 5, 7]
self.conf_thres = 0.4
self.fourcc = "mp4v"
self.config_deepsort = "deep_sort_pytorch/configs/deep_sort.yaml"
self.device = ""
self.agnostic_nms = False
self.augment = False
self.two_w, self.three_w, self.four_w, self.truck, self.bus, self.total = (
None,
None,
None,
None,
None,
None,
)
self.count = 0
self.fps = None
font = ("Arial", 25)
self.root.resizable(0, 0)
self.panel = tk.Frame(self.root)
self.panel.pack(side="top", padx=10, pady=10)
self.canvas = tk.Label(self.panel,
text="loading...",
anchor="center",
font=font,
fg="blue")
self.canvas.pack(side="left", padx=10, pady=10)
self.counting_result = tk.Frame(self.root)
self.counting_result.pack(side="bottom", padx=10, pady=10)
self.Quit_btn = tk.Button(
self.counting_result,
text="Quit",
font=("Arial", 12),
command=self.onClose,
bg="red",
fg="white",
width=6,
)
self.Quit_btn.grid(row=2, column=5)
# set a callback to handle when the window is closed
self.root.wm_title("Traffic")
self.root.wm_protocol("WM_DELETE_WINDOW", self.onClose)
# Open camera source
# self.vid = oneCameraCapture.cameraCapture()
self.vs = cv2.VideoCapture("traffic3.mp4")
self.webcam = (self.source == "0" or self.source.startswith("rtsp")
or self.source.startswith("http")
or self.source.endswith(".txt"))
# initialize deepsort
cfg = get_config()
cfg.merge_from_file(self.config_deepsort)
self.deepsort = DeepSort(
cfg.DEEPSORT.REID_CKPT,
max_dist=cfg.DEEPSORT.MAX_DIST,
min_confidence=cfg.DEEPSORT.MIN_CONFIDENCE,
nms_max_overlap=cfg.DEEPSORT.NMS_MAX_OVERLAP,
max_iou_distance=cfg.DEEPSORT.MAX_IOU_DISTANCE,
max_age=cfg.DEEPSORT.MAX_AGE,
n_init=cfg.DEEPSORT.N_INIT,
nn_budget=cfg.DEEPSORT.NN_BUDGET,
use_cuda=True,
)
# Initialize
self.device = select_device(self.device)
if os.path.exists(self.out):
shutil.rmtree(self.out) # delete output folder
os.makedirs(self.out) # make new output folder
self.half = self.device.type != "cpu" # half precision only supported on CUDA
# Load model
self.model = torch.hub.load("ultralytics/yolov5",
"yolov5s",
pretrained=True)
self.source = "traffic3.mp4"
self.save_path = str(Path(self.out))
self.txt_path = str(Path(self.out)) + "/results.txt"
self.points = [[5, 100], [400, 100], [730, 300], [5, 300]]
self.pts = np.array(self.points, np.int32)
self.pts_arr = self.pts.reshape((-1, 1, 2))
self.isClosed = True
self.delay = 100
self.update()
def test(
data,
weights=None, # model.pt path(s)
batch_size=32, # batch size
imgsz=640, # inference size (pixels)
conf_thres=0.001, # confidence threshold
iou_thres=0.6, # NMS IoU threshold
task='val', # train, val, test, speed or study
device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu
single_cls=False, # treat as single-class dataset
augment=False, # augmented inference
verbose=False, # verbose output
save_txt=False, # save results to *.txt
save_hybrid=False, # save label+prediction hybrid results to *.txt
save_conf=False, # save confidences in --save-txt labels
save_json=False, # save a cocoapi-compatible JSON results file
project='runs/test', # save to project/name
name='exp', # save to project/name
exist_ok=False, # existing project/name ok, do not increment
half=True, # use FP16 half-precision inference
model=None,
dataloader=None,
save_dir=Path(''),
plots=True,
wandb_logger=None,
compute_loss=None,
):
# Initialize/load model and set device
training = model is not None
if training: # called by train.py
device = next(model.parameters()).device # get model device
else: # called directly
set_logging()
device = select_device(device, batch_size=batch_size)
# Directories
save_dir = increment_path(Path(project) / name,
exist_ok=exist_ok) # increment run
(save_dir / 'labels' if save_txt else save_dir).mkdir(
parents=True, exist_ok=True) # make dir
# Load model
model = attempt_load(weights, map_location=device) # load FP32 model
gs = max(int(model.stride.max()), 32) # grid size (max stride)
imgsz = check_img_size(imgsz, s=gs) # check image size
# Multi-GPU disabled, incompatible with .half() https://github.com/ultralytics/yolov5/issues/99
# if device.type != 'cpu' and torch.cuda.device_count() > 1:
# model = nn.DataParallel(model)
# Half
half &= device.type != 'cpu' # half precision only supported on CUDA
if half:
model.half()
# Configure
model.eval()
if isinstance(data, str):
with open(data) as f:
data = yaml.safe_load(f)
check_dataset(data) # check
is_coco = data['val'].endswith('coco/val2017.txt') # COCO dataset
nc = 1 if single_cls else int(data['nc']) # number of classes
iouv = torch.linspace(0.5, 0.95,
10).to(device) # iou vector for [email protected]:0.95
niou = iouv.numel()
# Logging
log_imgs = 0
if wandb_logger and wandb_logger.wandb:
log_imgs = min(wandb_logger.log_imgs, 100)
# Dataloader
if not training:
if device.type != 'cpu':
model(
torch.zeros(1, 3, imgsz, imgsz).to(device).type_as(
next(model.parameters()))) # run once
task = task if task in (
'train', 'val', 'test') else 'val' # path to train/val/test images
dataloader = create_dataloader(data[task],
imgsz,
batch_size,
gs,
single_cls,
pad=0.5,
rect=True,
prefix=colorstr(f'{task}: '))[0]
seen = 0
confusion_matrix = ConfusionMatrix(nc=nc)
names = {
k: v
for k, v in enumerate(
model.names if hasattr(model, 'names') else model.module.names)
}
coco91class = coco80_to_coco91_class()
s = ('%20s' + '%11s' * 6) % ('Class', 'Images', 'Labels', 'P', 'R',
'[email protected]', '[email protected]:.95')
p, r, f1, mp, mr, map50, map, t0, t1, t2 = 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.
loss = torch.zeros(3, device=device)
jdict, stats, ap, ap_class, wandb_images = [], [], [], [], []
for batch_i, (img, targets, paths,
shapes) in enumerate(tqdm(dataloader, desc=s)):
t_ = time_synchronized()
img = img.to(device, non_blocking=True)
img = img.half() if half else img.float() # uint8 to fp16/32
img /= 255.0 # 0 - 255 to 0.0 - 1.0
targets = targets.to(device)
nb, _, height, width = img.shape # batch size, channels, height, width
t = time_synchronized()
t0 += t - t_
# Run model
out, train_out = model(
img, augment=augment) # inference and training outputs
t1 += time_synchronized() - t
# Compute loss
if compute_loss:
loss += compute_loss([x.float() for x in train_out],
targets)[1][:3] # box, obj, cls
# Run NMS
targets[:, 2:] *= torch.Tensor([width, height, width,
height]).to(device) # to pixels
lb = [targets[targets[:, 0] == i, 1:]
for i in range(nb)] if save_hybrid else [] # for autolabelling
t = time_synchronized()
out = non_max_suppression(out,
conf_thres,
iou_thres,
labels=lb,
multi_label=True,
agnostic=single_cls)
t2 += time_synchronized() - t
# Statistics per image
for si, pred in enumerate(out):
labels = targets[targets[:, 0] == si, 1:]
nl = len(labels)
tcls = labels[:, 0].tolist() if nl else [] # target class
path = Path(paths[si])
seen += 1
if len(pred) == 0:
if nl:
stats.append((torch.zeros(0, niou, dtype=torch.bool),
torch.Tensor(), torch.Tensor(), tcls))
continue
# Predictions
if single_cls:
pred[:, 5] = 0
predn = pred.clone()
scale_coords(img[si].shape[1:], predn[:, :4], shapes[si][0],
shapes[si][1]) # native-space pred
# Append to text file
if save_txt:
gn = torch.tensor(shapes[si][0])[[1, 0, 1, 0
]] # normalization gain whwh
for *xyxy, conf, cls in predn.tolist():
xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) /
gn).view(-1).tolist() # normalized xywh
line = (cls, *xywh,
conf) if save_conf else (cls,
*xywh) # label format
with open(save_dir / 'labels' / (path.stem + '.txt'),
'a') as f:
f.write(('%g ' * len(line)).rstrip() % line + '\n')
# W&B logging - Media Panel plots
if len(
wandb_images
) < log_imgs and wandb_logger.current_epoch > 0: # Check for test operation
if wandb_logger.current_epoch % wandb_logger.bbox_interval == 0:
box_data = [{
"position": {
"minX": xyxy[0],
"minY": xyxy[1],
"maxX": xyxy[2],
"maxY": xyxy[3]
},
"class_id": int(cls),
"box_caption": "%s %.3f" % (names[cls], conf),
"scores": {
"class_score": conf
},
"domain": "pixel"
} for *xyxy, conf, cls in pred.tolist()]
boxes = {
"predictions": {
"box_data": box_data,
"class_labels": names
}
} # inference-space
wandb_images.append(
wandb_logger.wandb.Image(img[si],
boxes=boxes,
caption=path.name))
wandb_logger.log_training_progress(
predn, path,
names) if wandb_logger and wandb_logger.wandb_run else None
# Append to pycocotools JSON dictionary
if save_json:
# [{"image_id": 42, "category_id": 18, "bbox": [258.15, 41.29, 348.26, 243.78], "score": 0.236}, ...
image_id = int(
path.stem) if path.stem.isnumeric() else path.stem
box = xyxy2xywh(predn[:, :4]) # xywh
box[:, :2] -= box[:, 2:] / 2 # xy center to top-left corner
for p, b in zip(pred.tolist(), box.tolist()):
jdict.append({
'image_id':
image_id,
'category_id':
coco91class[int(p[5])] if is_coco else int(p[5]),
'bbox': [round(x, 3) for x in b],
'score':
round(p[4], 5)
})
# Assign all predictions as incorrect
correct = torch.zeros(pred.shape[0],
niou,
dtype=torch.bool,
device=device)
if nl:
detected = [] # target indices
tcls_tensor = labels[:, 0]
# target boxes
tbox = xywh2xyxy(labels[:, 1:5])
scale_coords(img[si].shape[1:], tbox, shapes[si][0],
shapes[si][1]) # native-space labels
if plots:
confusion_matrix.process_batch(
predn, torch.cat((labels[:, 0:1], tbox), 1))
# Per target class
for cls in torch.unique(tcls_tensor):
ti = (cls == tcls_tensor).nonzero(as_tuple=False).view(
-1) # target indices
pi = (cls == pred[:, 5]).nonzero(as_tuple=False).view(
-1) # prediction indices
# Search for detections
if pi.shape[0]:
# Prediction to target ious
ious, i = box_iou(predn[pi, :4], tbox[ti]).max(
1) # best ious, indices
# Append detections
detected_set = set()
for j in (ious > iouv[0]).nonzero(as_tuple=False):
d = ti[i[j]] # detected target
if d.item() not in detected_set:
detected_set.add(d.item())
detected.append(d)
correct[
pi[j]] = ious[j] > iouv # iou_thres is 1xn
if len(
detected
) == nl: # all targets already located in image
break
# Append statistics (correct, conf, pcls, tcls)
stats.append(
(correct.cpu(), pred[:, 4].cpu(), pred[:, 5].cpu(), tcls))
# Plot images
if plots and batch_i < 3:
f = save_dir / f'test_batch{batch_i}_labels.jpg' # labels
Thread(target=plot_images,
args=(img, targets, paths, f, names),
daemon=True).start()
f = save_dir / f'test_batch{batch_i}_pred.jpg' # predictions
Thread(target=plot_images,
args=(img, output_to_target(out), paths, f, names),
daemon=True).start()
# Compute statistics
stats = [np.concatenate(x, 0) for x in zip(*stats)] # to numpy
if len(stats) and stats[0].any():
p, r, ap, f1, ap_class = ap_per_class(*stats,
plot=plots,
save_dir=save_dir,
names=names)
ap50, ap = ap[:, 0], ap.mean(1) # [email protected], [email protected]:0.95
mp, mr, map50, map = p.mean(), r.mean(), ap50.mean(), ap.mean()
nt = np.bincount(stats[3].astype(np.int64),
minlength=nc) # number of targets per class
else:
nt = torch.zeros(1)
# Print results
pf = '%20s' + '%11i' * 2 + '%11.3g' * 4 # print format
print(pf % ('all', seen, nt.sum(), mp, mr, map50, map))
# Print results per class
if (verbose or (nc < 50 and not training)) and nc > 1 and len(stats):
for i, c in enumerate(ap_class):
print(pf % (names[c], seen, nt[c], p[i], r[i], ap50[i], ap[i]))
# Print speeds
t = tuple(x / seen * 1E3 for x in (t0, t1, t2)) # speeds per image
if not training:
shape = (batch_size, 3, imgsz, imgsz)
print(
f'Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {shape}'
% t)
# Plots
if plots:
confusion_matrix.plot(save_dir=save_dir, names=list(names.values()))
if wandb_logger and wandb_logger.wandb:
val_batches = [
wandb_logger.wandb.Image(str(f), caption=f.name)
for f in sorted(save_dir.glob('test*.jpg'))
]
wandb_logger.log({"Validation": val_batches})
if wandb_images:
wandb_logger.log({"Bounding Box Debugger/Images": wandb_images})
# Save JSON
if save_json and len(jdict):
w = Path(weights[0] if isinstance(weights, list) else weights
).stem if weights is not None else '' # weights
anno_json = '../coco/annotations/instances_val2017.json' # annotations json
pred_json = str(save_dir / f"{w}_predictions.json") # predictions json
print('\nEvaluating pycocotools mAP... saving %s...' % pred_json)
with open(pred_json, 'w') as f:
json.dump(jdict, f)
try: # https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocoEvalDemo.ipynb
check_requirements(['pycocotools'])
from pycocotools.coco import COCO
from pycocotools.cocoeval import COCOeval
anno = COCO(anno_json) # init annotations api
pred = anno.loadRes(pred_json) # init predictions api
eval = COCOeval(anno, pred, 'bbox')
if is_coco:
eval.params.imgIds = [
int(Path(x).stem) for x in dataloader.dataset.img_files
] # image IDs to evaluate
eval.evaluate()
eval.accumulate()
eval.summarize()
map, map50 = eval.stats[:
2] # update results ([email protected]:0.95, [email protected])
except Exception as e:
print(f'pycocotools unable to run: {e}')
# Return results
model.float() # for training
if not training:
s = f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}" if save_txt else ''
print(f"Results saved to {save_dir}{s}")
maps = np.zeros(nc) + map
for i, c in enumerate(ap_class):
maps[c] = ap[i]
return (mp, mr, map50, map,
*(loss.cpu() / len(dataloader)).tolist()), maps, t
def detect(opt, save_img=False):
out, source, weights, view_img, save_txt, imgsz = opt.output, opt.source, opt.weights, opt.view_img, opt.save_txt, opt.img_size
webcam = source == '0' or source.startswith('rtsp') or source.startswith(
'http') or source.endswith('.txt')
global counter
global features
# initialize deepsort
cfg = get_config()
cfg.merge_from_file(opt.config_deepsort)
deepsort = DeepSort(cfg.DEEPSORT.REID_CKPT,
max_dist=cfg.DEEPSORT.MAX_DIST,
min_confidence=cfg.DEEPSORT.MIN_CONFIDENCE,
nms_max_overlap=cfg.DEEPSORT.NMS_MAX_OVERLAP,
max_iou_distance=cfg.DEEPSORT.MAX_IOU_DISTANCE,
max_age=cfg.DEEPSORT.MAX_AGE,
n_init=cfg.DEEPSORT.N_INIT,
nn_budget=cfg.DEEPSORT.NN_BUDGET,
use_cuda=True)
# Initialize
device = select_device(opt.device)
if os.path.exists(out):
shutil.rmtree(out) # delete output folder
os.makedirs(out) # make new output folder
half = device.type != 'cpu' # half precision only supported on CUDA. Make faster cmputation with lower precision.
#Write headers into csv file
with open(str(Path(args.output)) + '/results.csv', 'a') as f:
f.write("Time,People Count Changed,TotalCount,ActivePerson,\n")
#Initialize the scheduler for every 2 secs
scheduler = BackgroundScheduler()
scheduler.start()
scheduler.add_job(func=write_csv,
args=[opt.output],
trigger=IntervalTrigger(seconds=2))
# Load model
model = torch.load(weights,
map_location=device)['model'].float() # load to FP32
model.to(device).eval()
if half:
model.half() # to FP16
# Set Dataloader
vid_path, vid_writer = None, None
if webcam:
view_img = True
cudnn.benchmark = True # set True to speed up constant image size inference
dataset = LoadStreams(source, img_size=imgsz)
else:
view_img = True
save_img = True
dataset = LoadImages(source, img_size=imgsz)
# Get names and colors
names = model.module.names if hasattr(model, 'module') else model.names
# Run inference
t0 = time.time()
img = torch.zeros((1, 3, imgsz, imgsz), device=device) # init img
_ = model(img.half() if half else img
) if device.type != 'cpu' else None # run once
save_path = str(Path(out))
txt_path = str(Path(out)) + '/results.csv'
for frame_idx, (path, img, im0s, vid_cap) in enumerate(dataset):
img = torch.from_numpy(img).to(device)
img = img.half() if half else img.float() # uint8 to fp16/32
img /= 255.0 # 0 - 255 to 0.0 - 1.0
if img.ndimension() == 3:
img = img.unsqueeze(0)
# Inference
t1 = time_synchronized()
pred = model(img, augment=opt.augment)[0]
# Apply NMS
pred = non_max_suppression(pred,
opt.conf_thres,
opt.iou_thres,
classes=opt.classes,
agnostic=opt.agnostic_nms)
t2 = time_synchronized()
# Process detections
for i, det in enumerate(pred): # detections per image
if webcam: # batch_size >= 1
p, s, im0 = path[i], '%g: ' % i, im0s[i].copy()
else:
p, s, im0 = path, '', im0s
s += '%gx%g ' % img.shape[2:] # print string
save_path = str(Path(out) / Path(p).name)
if det is not None and len(det):
# Rescale boxes from img_size to im0(640) size
det[:, :4] = scale_coords(img.shape[2:], det[:, :4],
im0.shape).round()
# Print results
for c in det[:, -1].unique():
n = (det[:, -1] == c).sum() # detections per class
s += '%g %ss, ' % (n, names[int(c)]) # add to string
bbox_xywh = []
confs = []
# Adapt detections to deep sort input format
for *xyxy, conf, cls in det:
img_h, img_w, _ = im0.shape
x_c, y_c, bbox_w, bbox_h = bbox_rel(img_w, img_h, *xyxy)
obj = [x_c, y_c, bbox_w, bbox_h]
bbox_xywh.append(obj)
confs.append([conf.item()])
xywhs = torch.Tensor(bbox_xywh)
confss = torch.Tensor(confs)
# Pass detections to deepsort
outputs = deepsort.update(xywhs, confss, im0)
# draw boxes for visualization
if len(outputs) > 0:
bbox_xyxy = outputs[:, :4]
identities = outputs[:, -1]
draw_boxes(im0, bbox_xyxy, identities)
features['identities'] = identities
if save_txt and len(outputs) != 0:
for j, output in enumerate(outputs):
bbox_left = output[0]
bbox_top = output[1]
bbox_w = output[2]
bbox_h = output[3]
identity = output[-1]
# with open(txt_path, 'a') as f:
# f.write(f"{datetime.now()},{changes if changes != counter else 0},{counter},{len(identities)},\n") # label format
# Print time (inference + NMS)
print('%sDone. (%.3fs)' % (s, t2 - t1), end='\r')
# Write Counter on img
cv2.putText(im0, "Counter : " + str(counter), (10, 20),
cv2.FONT_HERSHEY_PLAIN, 2, [1, 190, 200], 2)
# Stream results
# if view_img:
# cv2.imshow(p, im0)
# if cv2.waitKey(1) == ord('q'): # q to quit
# raise StopIteration
# Save results (image with detections)
if save_img:
if dataset.mode == 'images':
print('saving img!')
cv2.imwrite(save_path, im0)
else:
# print('saving video!')
if vid_path != save_path: # new video
vid_path = save_path
if isinstance(vid_writer, cv2.VideoWriter):
vid_writer.release(
) # release previous video writer. Issues with video writer. Fix later
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
vid_writer = cv2.VideoWriter(
save_path, cv2.VideoWriter_fourcc(*opt.fourcc),
fps, (w, h))
vid_writer.write(im0)
if save_txt or save_img:
print('Results saved to %s' % os.getcwd() + os.sep + out)
print('Done. (%.3fs)' % (time.time() - t0))
def detect(opt, save_img=False):
ct = CentroidTracker()
out, source, weights, view_img, save_txt, imgsz = \
opt.output, opt.source, opt.weights, opt.view_img, opt.save_txt, opt.img_size
webcam = source == '0' or source.startswith(
'rtsp') or source.startswith('http') or source.endswith('.txt')
# initialize deepsort
cfg = get_config()
cfg.merge_from_file(opt.config_deepsort)
deepsort = DeepSort(cfg.DEEPSORT.REID_CKPT,
max_dist=cfg.DEEPSORT.MAX_DIST, min_confidence=cfg.DEEPSORT.MIN_CONFIDENCE,
nms_max_overlap=cfg.DEEPSORT.NMS_MAX_OVERLAP, max_iou_distance=cfg.DEEPSORT.MAX_IOU_DISTANCE,
max_age=cfg.DEEPSORT.MAX_AGE, n_init=cfg.DEEPSORT.N_INIT, nn_budget=cfg.DEEPSORT.NN_BUDGET,
use_cuda=True)
# Initialize
device = select_device(opt.device)
if os.path.exists(out):
shutil.rmtree(out) # delete output folder
os.makedirs(out) # make new output folder
half = device.type != 'cpu' # half precision only supported on CUDA
now = datetime.datetime.now().strftime("%Y/%m/%d/%H:%M:%S") # current time
# Load model
model = torch.load(weights, map_location=device)[
'model'].float() # load to FP32
model.to(device).eval()
# =============================================================================
filepath_mask = 'D:/Internship Crime Detection/YOLOv5 person detection/AjnaTask/Mytracker/yolov5/weights/mask.pt'
model_mask = torch.load(filepath_mask, map_location = device)['model'].float()
model_mask.to(device).eval()
if half:
model_mask.half()
names_m = model_mask.module.names if hasattr(model_mask, 'module') else model_mask.names
# =============================================================================
if half:
model.half() # to FP16
# Set Dataloader
vid_path, vid_writer = None, None
if webcam:
view_img = True
cudnn.benchmark = True # set True to speed up constant image size inference
dataset = LoadStreams(source, img_size=imgsz)
else:
view_img = False
save_img = True
dataset = LoadImages(source, img_size=imgsz)
# Get names and colors
names = model.module.names if hasattr(model, 'module') else model.names
# Run inference
t0 = time.time()
img = torch.zeros((1, 3, imgsz, imgsz), device=device) # init img
# run once
_ = model(img.half() if half else img) if device.type != 'cpu' else None
save_path = str(Path(out))
txt_path = str(Path(out)) + '/results.txt'
memory = {}
people_counter = 0
in_people = 0
out_people = 0
people_mask = 0
people_none = 0
time_sum = 0
# now_time = datetime.datetime.now().strftime('%Y/%m/%d %H:%M:%S')
colors = [[random.randint(0, 255) for _ in range(3)] for _ in names]
for frame_idx, (path, img, im0s, vid_cap) in enumerate(dataset):
img = torch.from_numpy(img).to(device)
img = img.half() if half else img.float() # uint8 to fp16/32
img /= 255.0 # 0 - 255 to 0.0 - 1.0
if img.ndimension() == 3:
img = img.unsqueeze(0)
# Inference
t1 = time_synchronized()
pred = model(img, augment=opt.augment)[0]
# =============================================================================
pred_mask = model_mask(img)[0]
# =============================================================================
# Apply NMS
pred = non_max_suppression(
pred, opt.conf_thres, opt.iou_thres, classes=opt.classes, agnostic=opt.agnostic_nms)
# =============================================================================
pred_mask = non_max_suppression(pred_mask, 0.4, 0.5, classes = [0, 1, 2], agnostic = None)
if pred_mask is None:
continue
classification = torch.cat(pred_mask)[:, -1]
if len(classification) == 0:
print("----",None)
continue
index = int(classification[0])
mask_class = names_m[index]
print("MASK CLASS>>>>>>> \n", mask_class)
# =============================================================================
# Create the haar cascade
# cascPath = "D:/Internship Crime Detection/YOLOv5 person detection/AjnaTask/Mytracker/haarcascade_frontalface_alt2.xml"
# faceCascade = cv2.CascadeClassifier(cascPath)
t2 = time_synchronized()
# Process detections
for i, det in enumerate(pred): # detections per image
if webcam: # batch_size >= 1
p, s, im0 = path[i], '%g: ' % i, im0s[i].copy()
else:
p, s, im0 = path, '', im0s
s += '%gx%g ' % img.shape[2:] # print string
save_path = str(Path(out) / Path(p).name)
img_center_y = int(im0.shape[0]//2)
# line = [(int(im0.shape[1]*0.258),int(img_center_y*1.3)),(int(im0.shape[1]*0.55),int(img_center_y*1.3))]
# print("LINE>>>>>>>>>", line,"------------")
# line = [(990, 672), (1072, 24)]
line = [(1272, 892), (1800, 203)]
# [(330, 468), (704, 468)]
print("LINE>>>>>>>>>", line,"------------")
cv2.line(im0,line[0],line[1],(0,0,255),5)
# =============================================================================
# gray = cv2.cvtColor(im0, cv2.COLOR_BGR2GRAY)
# # Detect faces in the image
# faces = faceCascade.detectMultiScale(
# gray,
# scaleFactor=1.1,
# minNeighbors=5,
# minSize=(30, 30)
# )
# # Draw a rectangle around the faces
# for (x, y, w, h) in faces:
# cv2.rectangle(im0, (x, y), (x+w, y+h), (0, 255, 0), 2)
# text_x = x
# text_y = y+h
# cv2.putText(im0, mask_class, (text_x, text_y), cv2.FONT_HERSHEY_COMPLEX_SMALL,
# 1, (0, 0, 255), thickness=1, lineType=2)
# =============================================================================
if det is not None and len(det):
# Rescale boxes from img_size to im0 size
det[:, :4] = scale_coords(
img.shape[2:], det[:, :4], im0.shape).round()
# Print results
for c in det[:, -1].unique():
n = (det[:, -1] == c).sum() # detections per class
s += '%g %ss, ' % (n, names[int(c)]) # add to string
bbox_xywh = []
confs = []
bbox_xyxy = []
rects = [] # Is it correct?
# Adapt detections to deep sort input format
for *xyxy, conf, cls in det:
x_c, y_c, bbox_w, bbox_h = bbox_rel(*xyxy)
# label = f'{names[int(cls)]}'
xyxy_list = torch.tensor(xyxy).view(1,4).view(-1).tolist()
plot_one_box(xyxy, im0, label='person', color=colors[int(cls)], line_thickness=3)
rects.append(xyxy_list)
obj = [x_c, y_c, bbox_w, bbox_h,int(cls)]
#cv2.circle(im0,(int(x_c),int(y_c)),color=(0,255,255),radius=12,thickness = 10)
bbox_xywh.append(obj)
# bbox_xyxy.append(rec)
confs.append([conf.item()])
xywhs = torch.Tensor(bbox_xywh)
confss = torch.Tensor(confs)
# Pass detections to deepsort
outputs = ct.update(rects) # xyxy
# outputs = deepsort.update(xywhs, confss, im0) # deepsort
index_id = []
previous = memory.copy()
memory = {}
boxes = []
names_ls = []
# draw boxes for visualization
if len(outputs) > 0:
# print('output len',len(outputs))
for id_,centroid in outputs.items():
# boxes.append([output[0],output[1],output[2],output[3]])
# index_id.append('{}-{}'.format(names_ls[-1],output[-2]))
index_id.append(id_)
boxes.append(centroid)
memory[index_id[-1]] = boxes[-1]
i = int(0)
print(">>>>>>>",boxes)
for box in boxes:
# extract the bounding box coordinates
# (x, y) = (int(box[0]), int(box[1]))
# (w, h) = (int(box[2]), int(box[3]))
x = int(box[0])
y = int(box[1])
# GGG
if index_id[i] in previous:
previous_box = previous[index_id[i]]
(x2, y2) = (int(previous_box[0]), int(previous_box[1]))
# (w2, h2) = (int(previous_box[2]), int(previous_box[3]))
p0 = (x,y)
p1 = (x2,y2)
cv2.line(im0, p0, p1, (0,255,0), 3) # current frame obj center point - before frame obj center point
if intersect(p0, p1, line[0], line[1]):
people_counter += 1
print('==============================')
print(p0,"---------------------------",p0[1])
print('==============================')
print(line[1][1],'------------------',line[0][0],'-----------------', line[1][0],'-------------',line[0][1])
# if p0[1] <= line[1][1]:
# in_people +=1
# else:
# # if mask_class == 'mask':
# # print("COUNTING MASK..", mask_class)
# # people_mask += 1
# # if mask_class == 'none':
# # people_none += 1
# out_people +=1
if p0[1] >= line[1][1]:
in_people += 1
if mask_class == 'mask':
people_mask += 1
else:
people_none += 1
else:
out_people += 1
i += 1
# Write MOT compliant results to file
if save_txt and len(outputs) != 0:
for j, output in enumerate(outputs):
bbox_left = output[0]
bbox_top = output[1]
bbox_w = output[2]
bbox_h = output[3]
identity = output[-1]
with open(txt_path, 'a') as f:
f.write(('%g ' * 10 + '\n') % (frame_idx, identity, bbox_left,
bbox_top, bbox_w, bbox_h, -1, -1, -1, -1)) # label format
else:
deepsort.increment_ages()
cv2.putText(im0, 'Person [down][up] : [{}][{}]'.format(out_people,in_people),(130,50),cv2.FONT_HERSHEY_COMPLEX,1.0,(0,0,255),3)
cv2.putText(im0, 'Person [mask][no_mask] : [{}][{}]'.format(people_mask, people_none), (130,100),cv2.FONT_HERSHEY_COMPLEX,1.0,(0,0,255),3)
# Print time (inference + NMS)
print('%sDone. (%.3fs)' % (s, t2 - t1))
time_sum += t2-t1
# Stream results
if view_img:
cv2.imshow(p, im0)
if cv2.waitKey(1) == ord('q'): # q to quit
raise StopIteration
# Save results (image with detections)
if save_img:
if dataset.mode == 'images':
# im0= cv2.resize(im0,(0,0),fx=0.5,fy=0.5,interpolation=cv2.INTER_LINEAR)
cv2.imwrite(save_path, im0)
else:
if vid_path != save_path: # new video
vid_path = save_path
if isinstance(vid_writer, cv2.VideoWriter):
vid_writer.release() # release previous video writer
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
vid_writer = cv2.VideoWriter(
save_path, cv2.VideoWriter_fourcc(*opt.fourcc), fps, (w, h))
vid_writer.write(im0)
if save_txt or save_img:
print('Results saved to %s' % os.getcwd() + os.sep + out)
if platform == 'darwin': # MacOS
os.system('open ' + save_path)
print('Done. (%.3fs)' % (time.time() - t0))
logger.info('Resuming training from %s' % ckpt)
else:
# opt.hyp = opt.hyp or ('hyp.finetune.yaml' if opt.weights else 'hyp.scratch.yaml')
opt.data, opt.cfg, opt.hyp = check_file(opt.data), check_file(
opt.cfg), check_file(opt.hyp) # check files
assert len(opt.cfg) or len(
opt.weights), 'either --cfg or --weights must be specified'
opt.img_size.extend(
[opt.img_size[-1]] *
(2 - len(opt.img_size))) # extend to 2 sizes (train, test)
log_dir = increment_dir(Path(opt.logdir) / 'exp',
opt.name) # runs/exp1
# DDP mode
device = select_device(opt.device, batch_size=opt.batch_size)
if opt.local_rank != -1:
assert torch.cuda.device_count() > opt.local_rank
torch.cuda.set_device(opt.local_rank)
device = torch.device('cuda', opt.local_rank)
dist.init_process_group(backend='nccl',
init_method='env://') # distributed backend
assert opt.batch_size % opt.world_size == 0, '--batch-size must be multiple of CUDA device count'
opt.batch_size = opt.total_batch_size // opt.world_size
# Hyperparameters
with open(opt.hyp) as f:
hyp = yaml.load(f, Loader=yaml.FullLoader) # load hyps
if 'box' not in hyp:
warn(
'Compatibility: %s missing "box" which was renamed from "giou" in %s'
def detect(
weights="yolov5s.pt",
source="yolov5/data/images",
img_size=640,
conf_thres=0.75,
iou_thres=0.45,
device="",
view_img=False,
save_txt=False,
save_conf=False,
classes=None,
agnostic_nms=False,
augment=False,
update=False,
project="runs/detect",
name="exp",
exist_ok=False,
save_img=False,
):
"""
Args:
weights: str
model.pt path(s)
source: str
file/folder, 0 for webcam
img_size: int
inference size (pixels)
conf_thres: float
object confidence threshold
iou_thres: float
IOU threshold for NMS
device: str
cuda device, i.e. 0 or 0,1,2,3 or cpu
view_img: bool
display results
save_txt: bool
save results to *.txt
save_conf: bool
save confidences in save_txt labels
classes: int
filter by class: [0], or [0, 2, 3]
agnostic-nms: bool
class-agnostic NMS
augment: bool
augmented inference
update: bool
update all models
project: str
save results to project/name
name: str
save results to project/name
exist_ok: bool
existing project/name ok, do not increment
"""
source, weights, view_img, save_txt, imgsz = (
source,
weights,
view_img,
save_txt,
img_size,
)
webcam = (
source.isnumeric()
or source.endswith(".txt")
or source.lower().startswith(("rtsp://", "rtmp://", "http://"))
)
# Directories
save_dir = Path(
increment_path(Path(project) / name, exist_ok=exist_ok)
) # increment run
(save_dir / "labels" if save_txt else save_dir).mkdir(
parents=True, exist_ok=True
) # make dir
# Initialize
set_logging()
device = select_device(device)
half = device.type != "cpu" # half precision only supported on CUDA
# Load model
model = attempt_load(weights, map_location=device) # load FP32 model
imgsz = check_img_size(imgsz, s=model.stride.max()) # check img_size
if half:
model.half() # to FP16
# Second-stage classifier
classify = False
if classify:
modelc = load_classifier(name="resnet101", n=2) # initialize
modelc.load_state_dict(
torch.load("weights/resnet101.pt", map_location=device)["model"]
).to(device).eval()
# Set Dataloader
vid_path, vid_writer = None, None
if webcam:
view_img = True
cudnn.benchmark = True # set True to speed up constant image size inference
dataset = LoadStreams(source, img_size=imgsz)
else:
save_img = True
dataset = LoadImages(source, img_size=imgsz)
# Get names and colors
names = model.module.names if hasattr(model, "module") else model.names
colors = [[random.randint(0, 255) for _ in range(3)] for _ in names]
# Run inference
t0 = time.time()
img = torch.zeros((1, 3, imgsz, imgsz), device=device) # init img
_ = model(img.half() if half else img) if device.type != "cpu" else None # run once
for path, img, im0s, vid_cap in dataset:
img = torch.from_numpy(img).to(device)
img = img.half() if half else img.float() # uint8 to fp16/32
img /= 255.0 # 0 - 255 to 0.0 - 1.0
if img.ndimension() == 3:
img = img.unsqueeze(0)
# Inference
t1 = time_synchronized()
pred = model(img, augment=augment)[0]
# Apply NMS
pred = non_max_suppression(
pred,
conf_thres,
iou_thres,
classes=classes,
agnostic=agnostic_nms,
)
t2 = time_synchronized()
# Apply Classifier
if classify:
pred = apply_classifier(pred, modelc, img, im0s)
# Process detections
for i, det in enumerate(pred): # detections per image
if webcam: # batch_size >= 1
p, s, im0, frame = path[i], "%g: " % i, im0s[i].copy(), dataset.count
else:
p, s, im0, frame = path, "", im0s, getattr(dataset, "frame", 0)
p = Path(p) # to Path
save_path = str(save_dir / p.name) # img.jpg
txt_path = str(save_dir / "labels" / p.stem) + (
"" if dataset.mode == "image" else f"_{frame}"
) # img.txt
s += "%gx%g " % img.shape[2:] # print string
gn = torch.tensor(im0.shape)[[1, 0, 1, 0]] # normalization gain whwh
if len(det):
# Rescale boxes from img_size to im0 size
det[:, :4] = scale_coords(img.shape[2:], det[:, :4], im0.shape).round()
# Print results
for c in det[:, -1].unique():
n = (det[:, -1] == c).sum() # detections per class
s += f"{n} {names[int(c)]}s, " # add to string
# Write results
for *xyxy, conf, cls in reversed(det):
if save_txt: # Write to file
xywh = (
(xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn)
.view(-1)
.tolist()
) # normalized xywh
line = (
(cls, *xywh, conf) if save_conf else (cls, *xywh)
) # label format
with open(txt_path + ".txt", "a") as f:
f.write(("%g " * len(line)).rstrip() % line + "\n")
if save_img or view_img: # Add bbox to image
label = f"{names[int(cls)]} {conf:.2f}"
plot_one_box(
xyxy,
im0,
label=label,
color=colors[int(cls)],
line_thickness=3,
)
# Print time (inference + NMS)
print(f"{s}Done. ({t2 - t1:.3f}s)")
# Stream results
if view_img:
cv2.imshow(str(p), im0)
# Save results (image with detections)
if save_img:
if dataset.mode == "image":
cv2.imwrite(save_path, im0)
else: # 'video'
if vid_path != save_path: # new video
vid_path = save_path
if isinstance(vid_writer, cv2.VideoWriter):
vid_writer.release() # release previous video writer
fourcc = "mp4v" # output video codec
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
vid_writer = cv2.VideoWriter(
save_path, cv2.VideoWriter_fourcc(*fourcc), fps, (w, h)
)
vid_writer.write(im0)
if save_txt or save_img:
s = (
f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}"
if save_txt
else ""
)
print(f"Results saved to {save_dir}{s}")
print(f"Done. ({time.time() - t0:.3f}s)")
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--weights',
type=str,
default='yolov5s.pt',
help='initial weights path')
parser.add_argument('--cfg', type=str, default='', help='model.yaml path')
#parser.add_argument('--data', type=str, default='yolov5/data/coco128.yaml', help='data.yaml path')
#parser.add_argument('--hyp', type=str, default='yolov5/data/hyp.scratch.yaml', help='hyperparameters path')
parser.add_argument('--data', type=str, default='', help='data.yaml path')
parser.add_argument('--hyp',
type=str,
default='',
help='hyperparameters path')
parser.add_argument('--epochs', type=int, default=300)
parser.add_argument('--batch-size',
type=int,
default=16,
help='total batch size for all GPUs')
parser.add_argument('--img-size',
nargs='+',
type=int,
default=[640, 640],
help='[train, test] image sizes')
parser.add_argument('--rect',
action='store_true',
help='rectangular training')
parser.add_argument('--resume',
nargs='?',
const=True,
default=False,
help='resume most recent training')
parser.add_argument('--nosave',
action='store_true',
help='only save final checkpoint')
parser.add_argument('--notest',
action='store_true',
help='only test final epoch')
parser.add_argument('--noautoanchor',
action='store_true',
help='disable autoanchor check')
parser.add_argument('--evolve',
action='store_true',
help='evolve hyperparameters')
parser.add_argument('--bucket', type=str, default='', help='gsutil bucket')
parser.add_argument('--cache-images',
action='store_true',
help='cache images for faster training')
parser.add_argument('--image-weights',
action='store_true',
help='use weighted image selection for training')
parser.add_argument('--device',
default='',
help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
parser.add_argument('--multi-scale',
action='store_true',
help='vary img-size +/- 50%%')
parser.add_argument('--single-cls',
action='store_true',
help='train multi-class data as single-class')
parser.add_argument('--adam',
action='store_true',
help='use torch.optim.Adam() optimizer')
parser.add_argument('--sync-bn',
action='store_true',
help='use SyncBatchNorm, only available in DDP mode')
parser.add_argument('--local_rank',
type=int,
default=-1,
help='DDP parameter, do not modify')
parser.add_argument('--workers',
type=int,
default=8,
help='maximum number of dataloader workers')
parser.add_argument('--project',
default='runs/train',
help='save to project/name')
parser.add_argument('--entity', default=None, help='W&B entity')
parser.add_argument('--name', default='exp', help='save to project/name')
parser.add_argument('--exist-ok',
action='store_true',
help='existing project/name ok, do not increment')
parser.add_argument('--quad', action='store_true', help='quad dataloader')
parser.add_argument('--linear-lr', action='store_true', help='linear LR')
parser.add_argument('--label-smoothing',
type=float,
default=0.0,
help='Label smoothing epsilon')
parser.add_argument('--upload_dataset',
action='store_true',
help='Upload dataset as W&B artifact table')
parser.add_argument('--bbox_interval',
type=int,
default=-1,
help='Set bounding-box image logging interval for W&B')
parser.add_argument('--save_period',
type=int,
default=-1,
help='Log model after every "save_period" epoch')
parser.add_argument('--artifact_alias',
type=str,
default="latest",
help='version of dataset artifact to be used')
opt = parser.parse_args()
# Set DDP variables
opt.world_size = int(
os.environ['WORLD_SIZE']) if 'WORLD_SIZE' in os.environ else 1
opt.global_rank = int(os.environ['RANK']) if 'RANK' in os.environ else -1
set_logging(opt.global_rank)
if opt.global_rank in [-1, 0]:
check_git_status()
#check_requirements()
# Resume
wandb_run = check_wandb_resume(opt)
if opt.resume and not wandb_run: # resume an interrupted run
ckpt = opt.resume if isinstance(
opt.resume,
str) else get_latest_run() # specified or most recent path
assert os.path.isfile(
ckpt), 'ERROR: --resume checkpoint does not exist'
apriori = opt.global_rank, opt.local_rank
with open(Path(ckpt).parent.parent / 'opt.yaml') as f:
opt = argparse.Namespace(**yaml.safe_load(f)) # replace
opt.cfg, opt.weights, opt.resume, opt.batch_size, opt.global_rank, opt.local_rank = \
'', ckpt, True, opt.total_batch_size, *apriori # reinstate
logger.info('Resuming training from %s' % ckpt)
else:
opt.hyp = opt.hyp or str(
Path(__file__).parent / 'data' /
('hyp.finetune.yaml' if opt.weights else 'hyp.scratch.yaml'))
opt.data = opt.data or str(Path(__file__).parent / 'data/coco128.yaml')
opt.data, opt.cfg, opt.hyp = check_file(opt.data), check_file(
opt.cfg), check_file(opt.hyp) # check files
assert len(opt.cfg) or len(
opt.weights), 'either --cfg or --weights must be specified'
opt.img_size.extend(
[opt.img_size[-1]] *
(2 - len(opt.img_size))) # extend to 2 sizes (train, test)
opt.name = 'evolve' if opt.evolve else opt.name
opt.save_dir = str(
increment_path(Path(opt.project) / opt.name,
exist_ok=opt.exist_ok | opt.evolve))
# DDP mode
opt.total_batch_size = opt.batch_size
device = select_device(opt.device, batch_size=opt.batch_size)
if opt.local_rank != -1:
assert torch.cuda.device_count() > opt.local_rank
torch.cuda.set_device(opt.local_rank)
device = torch.device('cuda', opt.local_rank)
dist.init_process_group(backend='nccl',
init_method='env://') # distributed backend
assert opt.batch_size % opt.world_size == 0, '--batch-size must be multiple of CUDA device count'
opt.batch_size = opt.total_batch_size // opt.world_size
# Hyperparameters
with open(opt.hyp) as f:
hyp = yaml.safe_load(f) # load hyps
# Train
logger.info(opt)
if not opt.evolve:
tb_writer = None # init loggers
if opt.global_rank in [-1, 0]:
prefix = colorstr('tensorboard: ')
logger.info(
f"{prefix}Start with 'tensorboard --logdir {opt.project}', view at http://localhost:6006/"
)
tb_writer = SummaryWriter(opt.save_dir) # Tensorboard
train(hyp, opt, device, tb_writer)
# Evolve hyperparameters (optional)
else:
# Hyperparameter evolution metadata (mutation scale 0-1, lower_limit, upper_limit)
meta = {
'lr0':
(1, 1e-5, 1e-1), # initial learning rate (SGD=1E-2, Adam=1E-3)
'lrf':
(1, 0.01, 1.0), # final OneCycleLR learning rate (lr0 * lrf)
'momentum': (0.3, 0.6, 0.98), # SGD momentum/Adam beta1
'weight_decay': (1, 0.0, 0.001), # optimizer weight decay
'warmup_epochs': (1, 0.0, 5.0), # warmup epochs (fractions ok)
'warmup_momentum': (1, 0.0, 0.95), # warmup initial momentum
'warmup_bias_lr': (1, 0.0, 0.2), # warmup initial bias lr
'box': (1, 0.02, 0.2), # box loss gain
'cls': (1, 0.2, 4.0), # cls loss gain
'cls_pw': (1, 0.5, 2.0), # cls BCELoss positive_weight
'obj': (1, 0.2, 4.0), # obj loss gain (scale with pixels)
'obj_pw': (1, 0.5, 2.0), # obj BCELoss positive_weight
'iou_t': (0, 0.1, 0.7), # IoU training threshold
'anchor_t': (1, 2.0, 8.0), # anchor-multiple threshold
'anchors': (2, 2.0, 10.0), # anchors per output grid (0 to ignore)
'fl_gamma':
(0, 0.0, 2.0), # focal loss gamma (efficientDet default gamma=1.5)
'hsv_h': (1, 0.0, 0.1), # image HSV-Hue augmentation (fraction)
'hsv_s': (1, 0.0,
0.9), # image HSV-Saturation augmentation (fraction)
'hsv_v': (1, 0.0, 0.9), # image HSV-Value augmentation (fraction)
'degrees': (1, 0.0, 45.0), # image rotation (+/- deg)
'translate': (1, 0.0, 0.9), # image translation (+/- fraction)
'scale': (1, 0.0, 0.9), # image scale (+/- gain)
'shear': (1, 0.0, 10.0), # image shear (+/- deg)
'perspective':
(0, 0.0, 0.001), # image perspective (+/- fraction), range 0-0.001
'flipud': (1, 0.0, 1.0), # image flip up-down (probability)
'fliplr': (0, 0.0, 1.0), # image flip left-right (probability)
'mosaic': (1, 0.0, 1.0), # image mixup (probability)
'mixup': (1, 0.0, 1.0)
} # image mixup (probability)
assert opt.local_rank == -1, 'DDP mode not implemented for --evolve'
opt.notest, opt.nosave = True, True # only test/save final epoch
# ei = [isinstance(x, (int, float)) for x in hyp.values()] # evolvable indices
yaml_file = Path(
opt.save_dir) / 'hyp_evolved.yaml' # save best result here
if opt.bucket:
os.system('gsutil cp gs://%s/evolve.txt .' %
opt.bucket) # download evolve.txt if exists
for _ in range(300): # generations to evolve
if Path('evolve.txt').exists(
): # if evolve.txt exists: select best hyps and mutate
# Select parent(s)
parent = 'single' # parent selection method: 'single' or 'weighted'
x = np.loadtxt('evolve.txt', ndmin=2)
n = min(5, len(x)) # number of previous results to consider
x = x[np.argsort(-fitness(x))][:n] # top n mutations
w = fitness(x) - fitness(x).min() # weights
if parent == 'single' or len(x) == 1:
# x = x[random.randint(0, n - 1)] # random selection
x = x[random.choices(range(n),
weights=w)[0]] # weighted selection
elif parent == 'weighted':
x = (x * w.reshape(
n, 1)).sum(0) / w.sum() # weighted combination
# Mutate
mp, s = 0.8, 0.2 # mutation probability, sigma
npr = np.random
npr.seed(int(time.time()))
g = np.array([x[0] for x in meta.values()]) # gains 0-1
ng = len(meta)
v = np.ones(ng)
while all(
v == 1
): # mutate until a change occurs (prevent duplicates)
v = (g * (npr.random(ng) < mp) * npr.randn(ng) *
npr.random() * s + 1).clip(0.3, 3.0)
for i, k in enumerate(hyp.keys()): # plt.hist(v.ravel(), 300)
hyp[k] = float(x[i + 7] * v[i]) # mutate
# Constrain to limits
for k, v in meta.items():
hyp[k] = max(hyp[k], v[1]) # lower limit
hyp[k] = min(hyp[k], v[2]) # upper limit
hyp[k] = round(hyp[k], 5) # significant digits
# Train mutation
results = train(hyp.copy(), opt, device)
# Write mutation results
print_mutation(hyp.copy(), results, yaml_file, opt.bucket)
# Plot results
plot_evolution(yaml_file)
print(
f'Hyperparameter evolution complete. Best results saved as: {yaml_file}\n'
f'Command to train a new model with these hyperparameters: $ python train.py --hyp {yaml_file}'
)
def run(
weights=ROOT / 'yolov5s.pt', # model.pt path(s)
source=ROOT / 'data/images', # file/dir/URL/glob, 0 for webcam
data=ROOT / 'data/coco128.yaml', # dataset.yaml path
imgsz=(640, 640), # inference size (height, width)
conf_thres=0.25, # confidence threshold
iou_thres=0.45, # NMS IOU threshold
max_det=1000, # maximum detections per image
device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu
view_img=False, # show results
save_txt=False, # save results to *.txt
save_conf=False, # save confidences in --save-txt labels
save_crop=False, # save cropped prediction boxes
nosave=False, # do not save images/videos
classes=None, # filter by class: --class 0, or --class 0 2 3
agnostic_nms=False, # class-agnostic NMS
augment=False, # augmented inference
visualize=False, # visualize features
update=False, # update all models
project=ROOT / 'runs/detect', # save results to project/name
name='exp', # save results to project/name
exist_ok=False, # existing project/name ok, do not increment
line_thickness=3, # bounding box thickness (pixels)
hide_labels=False, # hide labels
hide_conf=False, # hide confidences
half=False, # use FP16 half-precision inference
dnn=False, # use OpenCV DNN for ONNX inference
):
source = str(source)
save_img = not nosave and not source.endswith(
'.txt') # save inference images
is_file = Path(source).suffix[1:] in (IMG_FORMATS + VID_FORMATS)
is_url = source.lower().startswith(
('rtsp://', 'rtmp://', 'http://', 'https://'))
webcam = source.isnumeric() or source.endswith('.txt') or (is_url
and not is_file)
if is_url and is_file:
source = check_file(source) # download
# Directories
save_dir = increment_path(Path(project) / name,
exist_ok=exist_ok) # increment run
(save_dir / 'labels' if save_txt else save_dir).mkdir(
parents=True, exist_ok=True) # make dir
# Load model
device = select_device(device)
model = DetectMultiBackend(weights, device=device, dnn=dnn, data=data)
stride, names, pt, jit, onnx, engine = model.stride, model.names, model.pt, model.jit, model.onnx, model.engine
imgsz = check_img_size(imgsz, s=stride) # check image size
# Half
half &= (
pt or jit or onnx or engine
) and device.type != 'cpu' # FP16 supported on limited backends with CUDA
if pt or jit:
model.model.half() if half else model.model.float()
# Dataloader
if webcam:
view_img = check_imshow()
cudnn.benchmark = True # set True to speed up constant image size inference
dataset = LoadStreams(source, img_size=imgsz, stride=stride, auto=pt)
bs = len(dataset) # batch_size
else:
dataset = LoadImages(source, img_size=imgsz, stride=stride, auto=pt)
bs = 1 # batch_size
vid_path, vid_writer = [None] * bs, [None] * bs
# Run inference
model.warmup(imgsz=(1 if pt else bs, 3, *imgsz), half=half) # warmup
dt, seen = [0.0, 0.0, 0.0], 0
for path, im, im0s, vid_cap, s in dataset:
t1 = time_sync()
im = torch.from_numpy(im).to(device)
im = im.half() if half else im.float() # uint8 to fp16/32
im /= 255 # 0 - 255 to 0.0 - 1.0
if len(im.shape) == 3:
im = im[None] # expand for batch dim
t2 = time_sync()
dt[0] += t2 - t1
# Inference
visualize = increment_path(save_dir / Path(path).stem,
mkdir=True) if visualize else False
pred = model(im, augment=augment, visualize=visualize)
t3 = time_sync()
dt[1] += t3 - t2
# NMS
pred = non_max_suppression(pred,
conf_thres,
iou_thres,
classes,
agnostic_nms,
max_det=max_det)
dt[2] += time_sync() - t3
# Second-stage classifier (optional)
# pred = utils.general.apply_classifier(pred, classifier_model, im, im0s)
# Process predictions
for i, det in enumerate(pred): # per image
seen += 1
if webcam: # batch_size >= 1
p, im0, frame = path[i], im0s[i].copy(), dataset.count
s += f'{i}: '
else:
p, im0, frame = path, im0s.copy(), getattr(dataset, 'frame', 0)
p = Path(p) # to Path
save_path = str(save_dir / p.name) # im.jpg
txt_path = str(save_dir / 'labels' / p.stem) + (
'' if dataset.mode == 'image' else f'_{frame}') # im.txt
s += '%gx%g ' % im.shape[2:] # print string
gn = torch.tensor(im0.shape)[[1, 0, 1,
0]] # normalization gain whwh
imc = im0.copy() if save_crop else im0 # for save_crop
annotator = Annotator(im0,
line_width=line_thickness,
example=str(names))
if len(det):
# Rescale boxes from img_size to im0 size
det[:, :4] = scale_coords(im.shape[2:], det[:, :4],
im0.shape).round()
# Print results
for c in det[:, -1].unique():
n = (det[:, -1] == c).sum() # detections per class
s += f"{n} {names[int(c)]}{'s' * (n > 1)}, " # add to string
# Write results
for *xyxy, conf, cls in reversed(det):
if save_txt: # Write to file
xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) /
gn).view(-1).tolist() # normalized xywh
line = (cls, *xywh,
conf) if save_conf else (cls,
*xywh) # label format
with open(txt_path + '.txt', 'a') as f:
f.write(('%g ' * len(line)).rstrip() % line + '\n')
if save_img or save_crop or view_img: # Add bbox to image
c = int(cls) # integer class
label = None if hide_labels else (
names[c]
if hide_conf else f'{names[c]} {conf:.2f}')
annotator.box_label(xyxy, label, color=colors(c, True))
if save_crop:
save_one_box(xyxy,
imc,
file=save_dir / 'crops' / names[c] /
f'{p.stem}.jpg',
BGR=True)
# Stream results
im0 = annotator.result()
if view_img:
cv2.imshow(str(p), im0)
cv2.waitKey(1) # 1 millisecond
# Save results (image with detections)
if save_img:
if dataset.mode == 'image':
cv2.imwrite(save_path, im0)
else: # 'video' or 'stream'
if vid_path[i] != save_path: # new video
vid_path[i] = save_path
if isinstance(vid_writer[i], cv2.VideoWriter):
vid_writer[i].release(
) # release previous video writer
if vid_cap: # video
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
else: # stream
fps, w, h = 30, im0.shape[1], im0.shape[0]
save_path = str(Path(save_path).with_suffix(
'.mp4')) # force *.mp4 suffix on results videos
vid_writer[i] = cv2.VideoWriter(
save_path, cv2.VideoWriter_fourcc(*'mp4v'), fps,
(w, h))
vid_writer[i].write(im0)
# Print time (inference-only)
LOGGER.info(f'{s}Done. ({t3 - t2:.3f}s)')
# Print results
t = tuple(x / seen * 1E3 for x in dt) # speeds per image
LOGGER.info(
f'Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {(1, 3, *imgsz)}'
% t)
if save_txt or save_img:
s = f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}" if save_txt else ''
LOGGER.info(f"Results saved to {colorstr('bold', save_dir)}{s}")
if update:
strip_optimizer(weights) # update model (to fix SourceChangeWarning)
return nn.Sequential(*layers), sorted(save)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--cfg',
type=str,
default='yolov5s.yaml',
help='model.yaml')
parser.add_argument('--device',
default='',
help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
opt = parser.parse_args()
opt.cfg = check_file(opt.cfg) # check file
set_logging()
device = select_device(opt.device)
# Create model
model = Model(opt.cfg).to(device)
model.train()
# Profile
# img = torch.rand(8 if torch.cuda.is_available() else 1, 3, 320, 320).to(device)
# y = model(img, profile=True)
# Tensorboard (not working https://github.com/ultralytics/yolov5/issues/2898)
# from torch.utils.tensorboard import SummaryWriter
# tb_writer = SummaryWriter('.')
# logger.info("Run 'tensorboard --logdir=models' to view tensorboard at http://localhost:6006/")
# tb_writer.add_graph(torch.jit.trace(model, img, strict=False), []) # add model graph
# tb_writer.add_image('test', img[0], dataformats='CWH') # add model to tensorboard
def mainFunc(args):
# Set the main function flag
print("Main Function Start...")
# Check the GPU device
print("Number of available GPUs: {}".format(torch.cuda.device_count()))
# Check whether using the distributed runing for the network
is_distributed = initDistributed(args)
master = True
if is_distributed and os.environ["RANK"]:
master = int(
os.environ["RANK"]) == 0 # check whether this node is master node
# Configuration for device setting
set_logging()
if is_distributed:
device = torch.device('cuda:{}'.format(args.local_rank))
else:
device = select_device(args.device)
half = device.type != 'cpu' # half precision only supported on CUDA
# Load the configuration
config = loadConfig(args.config)
# CuDNN related setting
if torch.cuda.is_available():
cudnn.benchmark = config.DEVICE.CUDNN.BENCHMARK
cudnn.deterministic = config.DEVICE.CUDNN.DETERMINISTIC
cudnn.enabled = config.DEVICE.CUDNN.ENABLED
# Configurations for dirctories
save_img, save_dir, source, yolov5_weights, view_img, save_txt, imgsz = \
False, Path(args.save_dir), args.source, args.weights, args.view_img, args.save_txt, args.img_size
webcam = source.isnumeric() or source.startswith(
('rtsp://', 'rtmp://', 'http://')) or source.endswith('.txt')
if save_dir == Path('runs/detect'): # if default
os.makedirs('runs/detect', exist_ok=True) # make base
save_dir = Path(increment_dir(save_dir / 'exp',
args.name)) # increment run
os.makedirs(save_dir / 'labels' if save_txt else save_dir,
exist_ok=True) # make new dir
# Load yolov5 model for human detection
model_yolov5 = attempt_load(config.MODEL.PRETRAINED.YOLOV5,
map_location=device)
imgsz = check_img_size(imgsz,
s=model_yolov5.stride.max()) # check img_size
if half:
model_yolov5.half() # to FP16
# Second-stage classifier
classify = False
if classify:
model_classifier = load_classifier(name='resnet101', n=2) # initialize
model_classifier.load_state_dict(
torch.load('weights/resnet101.pt',
map_location=device)['model']) # load weights
model_classifier.to(device).eval()
# Load resnet model for human keypoints estimation
model_resnet = eval('pose_models.' + config.MODEL.NAME.RESNET +
'.get_pose_net')(config, is_train=False)
if config.EVAL.RESNET.MODEL_FILE:
print('=> loading model from {}'.format(config.EVAL.RESNET.MODEL_FILE))
model_resnet.load_state_dict(torch.load(config.EVAL.RESNET.MODEL_FILE),
strict=False)
else:
print('expected model defined in config at EVAL.RESNET.MODEL_FILE')
model_resnet.to(device)
model_resnet.eval()
# Set Dataloader
vid_path, vid_writer = None, None
if webcam:
view_img = True
dataset = LoadStreams(source, img_size=imgsz)
else:
save_img = True
dataset = LoadImages(source, img_size=imgsz)
pose_transform = transforms.Compose(
[ # input transformation for 2d human pose estimation
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
# Get names and colors
names = model_yolov5.module.names if hasattr(
model_yolov5, 'module') else model_yolov5.names
colors = [[random.randint(0, 255) for _ in range(3)]
for _ in range(len(names))]
# Construt filters for filtering 2D/3D human keypoints
# filters_2d = constructFilters((1,16,2), freq=25, mincutoff=1, beta=0.01) # for test
# filters_3d = constructFilters((1,16,3), freq=25, mincutoff=1, beta=0.01)
# Run the yolov5 and resnet for 2d human pose estimation
# with torch.no_grad():
# Run inference
t0 = time.time()
img = torch.zeros((1, 3, imgsz, imgsz), device=device) # init img
_ = model_yolov5(img.half() if half else img
) if device.type != 'cpu' else None # run once
# Process every video frame
for path, img, im0s, vid_cap in dataset:
img = torch.from_numpy(img).to(device)
img = img.half() if half else img.float() # uint8 to fp16/32
img /= 255.0 # 0 - 255 to 0.0 - 1.0
if img.ndimension() == 3:
img = img.unsqueeze(0)
# Inference
t1 = time_synchronized()
pred_boxes = model_yolov5(img, augment=args.augment)[0]
# Apply NMS
pred_boxes = non_max_suppression(pred_boxes,
args.conf_thres,
args.iou_thres,
classes=args.classes,
agnostic=args.agnostic_nms)
t2 = time_synchronized()
# Can not find people and move to next frame
if pred_boxes[0] is None:
# show the frame with no human detected
cv2.namedWindow("2D Human Pose Estimation", cv2.WINDOW_NORMAL)
cv2.imshow("2D Human Pose Estimation", im0s[0].copy())
# wait manual operations
# with kb.Listener(on_press=on_press) as listener:
# listener.join()
# return
# if kb.is_pressed('t'):
# return
print("No Human Detected and Move on.")
print("-" * 30)
continue
# Print time (inference + NMS)
detect_time = t2 - t1
detect_fps = 1.0 / detect_time
print("Human Detection Time: {}, Human Detection FPS: {}".format(
detect_time, detect_fps))
# Apply Classifier
if classify: # false
pred_boxes = apply_classifier(pred_boxes, model_classifier, img,
im0s)
# Estimate 2d human pose(multiple person)
centers = []
scales = []
for id, boxes in enumerate(pred_boxes):
if boxes is not None and len(boxes):
boxes[:, :4] = scale_coords(img.shape[2:], boxes[:, :4],
im0s[id].copy().shape).round()
# convert tensor to list format
boxes = np.delete(boxes.cpu().numpy(), [-2, -1], axis=1).tolist()
for l in range(len(boxes)):
boxes[l] = [tuple(boxes[l][0:2]), tuple(boxes[l][2:4])]
# convert box to center and scale
for box in boxes:
center, scale = box_to_center_scale(box, imgsz, imgsz)
centers.append(center)
scales.append(scale)
t3 = time_synchronized()
pred_pose_2d = get_pose_estimation_prediction(config,
model_resnet,
im0s[0],
centers,
scales,
transform=pose_transform,
device=device)
t4 = time_synchronized()
# Print time (2d human pose estimation)
estimate_time = t4 - t3
estimate_fps = 1.0 / estimate_time
print("Pose Estimation Time: {}, Pose Estimation FPS: {}".format(
estimate_time, estimate_fps))
# Filter the predicted 2d human pose(multiple person)
t5 = time_synchronized()
# if False: # for test
if config.EVAL.RESNET.USE_FILTERS_2D:
# construct filters for every keypoints of every person in 2D
filters_2d = constructFilters(pred_pose_2d.shape,
freq=1,
mincutoff=1,
beta=0.01)
print("Shape of filters_2d: ({}, {}, {})".format(
len(filters_2d), len(filters_2d[0]),
len(filters_2d[0][0]))) # for test
for per in range(pred_pose_2d.shape[0]):
for kp in range(pred_pose_2d.shape[1]):
for coord in range(pred_pose_2d.shape[2]):
pred_pose_2d[per][kp][coord] = filters_2d[per][kp][
coord](pred_pose_2d[per][kp][coord])
t6 = time_synchronized()
# Print time (filter 2d human pose)
filter_time_2d = t6 - t5
filter_fps_2d = 1.0 / filter_time_2d
print("Filter 2D Pose Time: {}, Filter 2D Pose FPS: {}".format(
filter_time_2d, filter_fps_2d))
# Process detections and estimations in 2D
for i, box in enumerate(pred_boxes):
if webcam: # batch_size >= 1
p, s, im0 = Path(path[i]), '%g: ' % i, im0s[i].copy()
else:
p, s, im0 = Path(path), '', im0s
save_path = str(save_dir / p.name)
txt_path = str(save_dir / 'labels' / p.stem) + (
'_%g' % dataset.frame if dataset.mode == 'video' else '')
s += '%gx%g ' % img.shape[2:] # print string
gn = torch.tensor(im0.shape)[[1, 0, 1,
0]] # normalization gain whwh
if box is not None and len(box):
# Rescale boxes from img_size to im0 size
box[:, :4] = scale_coords(img.shape[2:], box[:, :4],
im0.shape).round()
# Print results
for c in box[:, -1].unique():
n = (box[:, -1] == c).sum() # detections per class
s += '%g %ss, ' % (n, names[int(c)]) # add to string
# Write results
for *xyxy, conf, cls in reversed(box):
if save_txt: # Write to file
xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) /
gn).view(-1).tolist() # normalized xywh
line = (cls, *xywh, conf) if args.save_conf else (
cls, *xywh) # label format
with open(txt_path + '.txt', 'a') as f:
f.write(('%g ' * len(line) + '\n') % line)
# Add bbox to image
if save_img or view_img:
label = '%s %.2f' % (names[int(cls)], conf)
plot_one_box(xyxy,
im0,
label=label,
color=colors[int(cls)],
line_thickness=3)
# Draw joint keypoints, number orders and human skeletons for every detected people in 2D
for person in pred_pose_2d:
# draw the human keypoints
for idx, coord in enumerate(person):
x_coord, y_coord = int(coord[0]), int(coord[1])
cv2.circle(im0, (x_coord, y_coord), 1, (0, 0, 255), 5)
cv2.putText(im0, str(idx), (x_coord, y_coord),
cv2.FONT_HERSHEY_SIMPLEX, 0.6,
(255, 255, 255), 2, cv2.LINE_AA)
# draw the human skeletons in PACIFIC mode
for skeleton in PACIFIC_SKELETON_INDEXES:
cv2.line(im0, (int(person[skeleton[0]][0]),
int(person[skeleton[0]][1])),
(int(person[skeleton[1]][0]),
int(person[skeleton[1]][1])), skeleton[2], 2)
# Print time (inference + NMS + estimation)
print('%sDone. (%.3fs)' % (s, t4 - t1))
# Stream results
if view_img:
detect_text = "Detect FPS:{0:0>5.2f}/{1:0>6.2f}ms".format(
detect_fps, detect_time * 1000)
estimate_text = "Estimate FPS:{0:0>5.2f}/{1:0>6.2f}ms".format(
estimate_fps, estimate_time * 1000)
cv2.putText(im0, detect_text, (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2,
cv2.LINE_AA)
cv2.putText(im0, estimate_text, (10, 60),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2,
cv2.LINE_AA)
cv2.namedWindow("2D Human Pose Estimation", cv2.WINDOW_NORMAL)
cv2.imshow("2D Human Pose Estimation", im0)
if cv2.waitKey(1) & 0xFF == ord('q'): # q to quit
return
# goto .mainFunc
# Save results (image with detections)
if save_img:
if dataset.mode == 'images':
cv2.imwrite(save_path, im0)
else:
if vid_path != save_path: # new video
vid_path = save_path
if isinstance(vid_writer, cv2.VideoWriter):
vid_writer.release(
) # release previous video writer
fourcc = 'mp4v' # output video codec
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
vid_writer = cv2.VideoWriter(
save_path, cv2.VideoWriter_fourcc(*fourcc), fps,
(w, h))
vid_writer.write(im0)
# Print time (inference + NMS + estimation + 2d filtering)
all_process_time = t6 - t1
all_process_fps = 1.0 / all_process_time
print("All Process Time: {}, All Process FPS: {}".format(
all_process_time, all_process_fps))
print("-" * 30)
# Goto label
# label .mainFunc
# Print saving results
if save_txt or save_img:
print('Results saved to %s' % save_dir)
# Release video reader and writer, then destory all opencv windows
dataset.vid_cap.release()
vid_writer.release()
cv2.destroyAllWindows()
print('Present 2D Human Pose Inference Done. Total Time:(%.3f seconds)' %
(time.time() - t0))
