（2-3）目标检测和识别：基于深度学习的YOLO算法

 def run(

    
     weights=ROOT / 'yolov5s.pt',  # model path or triton URL
    
     source=ROOT / 'data/images',  # file/dir/URL/glob/screen/0(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
    
     vid_stride=1,  # video frame-rate stride
    
 ):

    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('.streams') or (is_url and not is_file)
    
     screenshot = source.lower().startswith('screen')
    
     if is_url and is_file:
    
     source = check_file(source)  # download
    
  
    
     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
    
  
    
     # 加载模型
    
     device = select_device(device)
    
     model = DetectMultiBackend(weights, device=device, dnn=dnn, data=data, fp16=half)
    
     stride, names, pt = model.stride, model.names, model.pt
    
     imgsz = check_img_size(imgsz, s=stride)  # check image size
    
  
    
     # Dataloader
    
     bs = 1  # batch_size
    
     if webcam:
    
     view_img = check_imshow(warn=True)
    
     dataset = LoadStreams(source, img_size=imgsz, stride=stride, auto=pt, vid_stride=vid_stride)
    
     bs = len(dataset)
    
     elif screenshot:
    
     dataset = LoadScreenshots(source, img_size=imgsz, stride=stride, auto=pt)
    
     else:
    
     dataset = LoadImages(source, img_size=imgsz, stride=stride, auto=pt, vid_stride=vid_stride)
    
     vid_path, vid_writer = [None] * bs, [None] * bs
    
  
    
     # Run inference
    
     model.warmup(imgsz=(1 if pt or model.triton else bs, 3, *imgsz))  # warmup
    
     seen, windows, dt = 0, [], (Profile(), Profile(), Profile())
    
     for path, im, im0s, vid_cap, s in dataset:
    
     with dt[0]:
    
         im = torch.from_numpy(im).to(model.device)
    
         im = im.half() if model.fp16 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
    
  
    
     # Inference
    
     with dt[1]:
    
         visualize = increment_path(save_dir / Path(path).stem, mkdir=True) if visualize else False
    
         pred = model(im, augment=augment, visualize=visualize)
    
  
    
     # NMS
    
     with dt[2]:
    
         pred = non_max_suppression(pred, conf_thres, iou_thres, classes, agnostic_nms, max_det=max_

 def train(hyp, opt, device, callbacks):  # hyp is path/to/hyp.yaml or hyp dictionary

    
     save_dir, epochs, batch_size, weights, single_cls, evolve, data, cfg, resume, noval, nosave, workers, freeze = \
    
     Path(opt.save_dir), opt.epochs, opt.batch_size, opt.weights, opt.single_cls, opt.evolve, opt.data, opt.cfg, \
    
     opt.resume, opt.noval, opt.nosave, opt.workers, opt.freeze
    
     callbacks.run('on_pretrain_routine_start')
    
  
    
     # Directories
    
     w = save_dir / 'weights'  # weights dir
    
     (w.parent if evolve else w).mkdir(parents=True, exist_ok=True)  # make dir
    
     last, best = w / 'last.pt', w / 'best.pt'
    
  
    
     # Hyperparameters
    
     if isinstance(hyp, str):
    
     with open(hyp, errors='ignore') as f:
    
         hyp = yaml.safe_load(f)  # load hyps dict
    
     LOGGER.info(colorstr('hyperparameters: ') + ', '.join(f'{k}={v}' for k, v in hyp.items()))
    
     opt.hyp = hyp.copy()  # for saving hyps to checkpoints
    
  
    
     # Save run settings
    
     if not evolve:
    
     yaml_save(save_dir / 'hyp.yaml', hyp)
    
     yaml_save(save_dir / 'opt.yaml', vars(opt))
    
  
    
     # Loggers
    
     data_dict = None
    
     if RANK in {-1, 0}:
    
     loggers = Loggers(save_dir, weights, opt, hyp, LOGGER)  # loggers instance
    
  
    
     # Register actions
    
     for k in methods(loggers):
    
         callbacks.register_action(k, callback=getattr(loggers, k))
    
  
    
     # Process custom dataset artifact link
    
     data_dict = loggers.remote_dataset
    
     if resume:  # If resuming runs from remote artifact
    
         weights, epochs, hyp, batch_size = opt.weights, opt.epochs, opt.hyp, opt.batch_size

     plots = not evolve and not opt.noplots  # create plots

    
     cuda = device.type != 'cpu'
    
     init_seeds(opt.seed + 1 + RANK, deterministic=True)
    
     with torch_distributed_zero_first(LOCAL_RANK):
    
     data_dict = data_dict or check_dataset(data)  # check if None
    
     train_path, val_path = data_dict['train'], data_dict['val']
    
     nc = 1 if single_cls else int(data_dict['nc'])  # number of classes
    
     names = {0: 'item'} if single_cls and len(data_dict['names']) != 1 else data_dict['names']  # class names
    
     is_coco = isinstance(val_path, str) and val_path.endswith('coco/val2017.txt')  # COCO dataset
    
  
    
     # Model
    
     check_suffix(weights, '.pt')  # check weights
    
     pretrained = weights.endswith('.pt')
    
     if pretrained:
    
     with torch_distributed_zero_first(LOCAL_RANK):
    
         weights = attempt_download(weights)  # download if not found locally
    
     ckpt = torch.load(weights, map_location='cpu')  # load checkpoint to CPU to avoid CUDA memory leak
    
     model = Model(cfg or ckpt['model'].yaml, ch=3, nc=nc, anchors=hyp.get('anchors')).to(device)  # create
    
     exclude = ['anchor'] if (cfg or hyp.get('anchors')) and not resume else []  # exclude keys
    
     csd = ckpt['model'].float().state_dict()  # checkpoint state_dict as FP32
    
     csd = intersect_dicts(csd, model.state_dict(), exclude=exclude)  # intersect
    
     model.load_state_dict(csd, strict=False)  # load
    
     LOGGER.info(f'Transferred {len(csd)}/{len(model.state_dict())} items from {weights}')  # report
    
     else:
    
     model = Model(cfg, ch=3, nc=nc, anchors=hyp.get('anchors')).to(device)  # create
    
     amp = check_amp(model)  # check AMP
    
  
    
     # Freeze
    
     freeze = [f'model.{x}.' for x in (freeze if len(freeze) > 1 else range(freeze[0]))]  # layers to freeze
    
     for k, v in model.named_parameters():
    
     v.requires_grad = True  # train all layers
    
     # v.register_hook(lambda x: torch.nan_to_num(x))  # NaN to 0 (commented for erratic training results)
    
     if any(x in k for x in freeze):
    
         LOGGER.info(f'freezing {k}')
    
         v.requires_grad = False
    
  
    
     # Image size
    
     gs = max(int(model.stride.max()), 32)  # grid size (max stride)
    
     imgsz = check_img_size(opt.imgsz, gs, floor=gs * 2)  # verify imgsz is gs-multiple
    
  
    
     # Batch size
    
     if RANK == -1 and batch_size == -1:  # single-GPU only, estimate best batch size
    
     batch_size = check_train_batch_size(model, imgsz, amp)
    
     loggers.on_params_update({'batch_size': batch_size})
    
  
    
     # Optimizer
    
     nbs = 64  # nominal batch size
    
     accumulate = max(round(nbs / batch_size), 1)  # accumulate loss before optimizing
    
     hyp['weight_decay'] *= batch_size * accumulate / nbs  # scale weight_decay
    
     optimizer = smart_optimizer(model, opt.optimizer, hyp['lr0'], hyp['momentum'], hyp['weight_decay'])
    
  
    
     # Scheduler
    
     if opt.cos_lr:
    
     lf = one_cycle(1, hyp['lrf'], epochs)  # cosine 1->hyp['lrf']
    
     else:
    
     lf = lambda x: (1 - x / epochs) * (1.0 - hyp['lrf']) + hyp['lrf']  # linear
    
     scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lf)  # plot_lr_scheduler(optimizer, scheduler, epochs)
    
  
    
     # EMA
    
     ema = ModelEMA(model) if RANK in {-1, 0} else None
    
  
    
     # Resume
    
     best_fitness, start_epoch = 0.0, 0
    
     if pretrained:
    
     if resume:
    
         best_fitness, start_epoch, epochs = smart_resume(ckpt, optimizer, ema, weights, epochs, resume)
    
     del ckpt, csd

     train_loader, dataset = create_dataloader(train_path,

    
                                           imgsz,
    
                                           batch_size // WORLD_SIZE,
    
                                           gs,
    
                                           single_cls,
    
                                           hyp=hyp,
    
                                           augment=True,
    
                                           cache=None if opt.cache == 'val' else opt.cache,
    
                                           rect=opt.rect,
    
                                           rank=LOCAL_RANK,
    
                                           workers=workers,
    
                                           image_weights=opt.image_weights,
    
                                           quad=opt.quad,
    
                                           prefix=colorstr('train: '),
    
                                           shuffle=True,
    
                                           seed=opt.seed)
    
     labels = np.concatenate(dataset.labels, 0)
    
     mlc = int(labels[:, 0].max())  # max label class
    
     assert mlc < nc, f'Label class {mlc} exceeds nc={nc} in {data}. Possible class labels are 0-{nc - 1}'
    
  
    
     # Process 0
    
     if RANK in {-1, 0}:
    
     val_loader = create_dataloader(val_path,
    
                                    imgsz,
    
                                    batch_size // WORLD_SIZE * 2,
    
                                    gs,
    
                                    single_cls,
    
                                    hyp=hyp,
    
                                    cache=None if noval else opt.cache,
    
                                    rect=True,
    
                                    rank=-1,
    
                                    workers=workers * 2,
    
                                    pad=0.5,
    
                                    prefix=colorstr('val: '))[0]
    
  
    
     if not resume:
    
         if not opt.noautoanchor:
    
             check_anchors(dataset, model=model, thr=hyp['anchor_t'], imgsz=imgsz)  # run AutoAnchor
    
         model.half().float()  # pre-reduce anchor precision
    
  
    
     callbacks.run('on_pretrain_routine_end', labels, names)
    
  
    
     # DDP mode
    
     if cuda and RANK != -1:
    
     model = smart_DDP(model)
    
  
    
     # Model attributes
    
     nl = de_parallel(model).model[-1].nl  # number of detection layers (to scale hyps)
    
     hyp['box'] *= 3 / nl  # scale to layers
    
     hyp['cls'] *= nc / 80 * 3 / nl  # scale to classes and layers
    
     hyp['obj'] *= (imgsz / 640) ** 2 * 3 / nl  # scale to image size and layers
    
     hyp['label_smoothing'] = opt.label_smoothing
    
     model.nc = nc  # attach number of classes to model
    
     model.hyp = hyp  # attach hyperparameters to model
    
     model.class_weights = labels_to_class_weights(dataset.labels, nc).to(device) * nc  # attach class weights
    
     model.names = names
    
  
    
     # Start training
    
     t0 = time.time()
    
     nb = len(train_loader)  # number of batches
    
     nw = max(round(hyp['warmup_epochs'] * nb), 100)  # number of warmup iterations, max(3 epochs, 100 iterations)
    
     # nw = min(nw, (epochs - start_epoch) / 2 * nb)  # limit warmup to < 1/2 of training
    
     last_opt_step = -1
    
     maps = np.zeros(nc)  # mAP per class
    
     results = (0, 0, 0, 0, 0, 0, 0)  # P, R, mAP@.5, mAP@.5-.95, val_loss(box, obj, cls)
    
     scheduler.last_epoch = start_epoch - 1  # do not move
    
     scaler = torch.cuda.amp.GradScaler(enabled=amp)
    
     stopper, stop = EarlyStopping(patience=opt.patience), False
    
     compute_loss = ComputeLoss(model)  # init loss class
    
     callbacks.run('on_train_start')
    
     LOGGER.info(f'Image sizes {imgsz} train, {imgsz} val\n'
    
             f'Using {train_loader.num_workers * WORLD_SIZE} dataloader workers\n'
    
             f"Logging results to {colorstr('bold', save_dir)}\n"
    
             f'Starting training for {epochs} epochs...')
    
     for epoch in range(start_epoch, epochs):  # epoch ------------------------------------------------------------------
    
     callbacks.run('on_train_epoch_start')
    
     model.train()
    
  
    
     # Update image weights (optional, single-GPU only)
    
     if opt.image_weights:
    
         cw = model.class_weights.cpu().numpy() * (1 - maps) ** 2 / nc  # class weights
    
         iw = labels_to_image_weights(dataset.labels, nc=nc, class_weights=cw)  # image weights
    
         dataset.indices = random.choices(range(dataset.n), weights=iw, k=dataset.n)  # rand weighted idx
    
  
    
     # Update mosaic border (optional)
    
     # b = int(random.uniform(0.25 * imgsz, 0.75 * imgsz + gs) // gs * gs)
    
     # dataset.mosaic_border = [b - imgsz, -b]  # height, width borders
    
  
    
     mloss = torch.zeros(3, device=device)  # mean losses
    
     if RANK != -1:
    
         train_loader.sampler.set_epoch(epoch)
    
     pbar = enumerate(train_loader)
    
     LOGGER.info(('\n' + '%11s' * 7) % ('Epoch', 'GPU_mem', 'box_loss', 'obj_loss', 'cls_loss', 'Instances', 'Size'))
    
     if RANK in {-1, 0}:
    
         pbar = tqdm(pbar, total=nb, bar_format=TQDM_BAR_FORMAT)  # progress bar
    
     optimizer.zero_grad()
    
     for i, (imgs, targets, paths, _) in pbar:  # batch -------------------------------------------------------------
    
         callbacks.run('on_train_batch_start')
    
         ni = i + nb * epoch  # number integrated batches (since train start)
    
         imgs = imgs.to(device, non_blocking=True).float() / 255  # uint8 to float32, 0-255 to 0.0-1.0
    
  
    
         # Warmup
    
         if ni <= nw:
    
             xi = [0, nw]  # x interp
    
             # compute_loss.gr = np.interp(ni, xi, [0.0, 1.0])  # iou loss ratio (obj_loss = 1.0 or iou)
    
             accumulate = max(1, np.interp(ni, xi, [1, nbs / batch_size]).round())
    
             for j, x in enumerate(optimizer.param_groups):
    
                 # bias lr falls from 0.1 to lr0, all other lrs rise from 0.0 to lr0
    
                 x['lr'] = np.interp(ni, xi, [hyp['warmup_bias_lr'] if j == 0 else 0.0, x['initial_lr'] * lf(epoch)])
    
                 if 'momentum' in x:
    
                     x['momentum'] = np.interp(ni, xi, [hyp['warmup_momentum'], hyp['momentum']])
    
  
    
         # Multi-scale
    
         if opt.multi_scale:
    
             sz = random.randrange(int(imgsz * 0.5), int(imgsz * 1.5) + gs) // gs * gs  # size
    
             sf = sz / max(imgs.shape[2:])  # scale factor
    
             if sf != 1:
    
                 ns = [math.ceil(x * sf / gs) * gs for x in imgs.shape[2:]]  # new shape (stretched to gs-multiple)
    
                 imgs = nn.functional.interpolate(imgs, size=ns, mode='bilinear', align_corners=False)
    
  
    
         # Forward
    
         with torch.cuda.amp.autocast(amp):
    
             pred = model(imgs)  # forward
    
             loss, loss_items = compute_loss(pred, targets.to(device))  # loss scaled by batch_size
    
             if RANK != -1:
    
                 loss *= WORLD_SIZE  # gradient averaged between devices in DDP mode
    
             if opt.quad:
    
                 loss *= 4.
    
  
    
         # Backward
    
         scaler.scale(loss).backward()
    
  
    
         # Optimize - https://pytorch.org/docs/master/notes/amp_examples.html
    
         if ni - last_opt_step >= accumulate:
    
             scaler.unscale_(optimizer)  # unscale gradients
    
             torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=10.0)  # clip gradients
    
             scaler.step(optimizer)  # optimizer.step
    
             scaler.update()
    
             optimizer.zero_grad()
    
             if ema:
    
                 ema.update(model)
    
             last_opt_step = ni
    
  
    
         # Log
    
         if RANK in {-1, 0}:
    
             mloss = (mloss * i + loss_items) / (i + 1)  # update mean losses
    
             mem = f'{torch.cuda.memory_reserved() / 1E9 if torch.cuda.is_available() else 0:.3g}G'  # (GB)
    
             pbar.set_description(('%11s' * 2 + '%11.4g' * 5) %
    
                                  (f'{epoch}/{epochs - 1}', mem, *mloss, targets.shape[0], imgs.shape[-1]))
    
             callbacks.run('on_train_batch_end', model, ni, imgs, targets, paths, list(mloss))
    
             if callbacks.stop_training:
    
                 return
    
         # end batch -------------------------------

         fi = fitness(np.array(results).reshape(1, -1))  # weighted combination of [P, R, mAP@.5, mAP@.5-.95]

    
         stop = stopper(epoch=epoch, fitness=fi)  # early stop check
    
         if fi > best_fitness:
    
             best_fitness = fi
    
         log_vals = list(mloss) + list(results) + lr
    
         callbacks.run('on_fit_epoch_end', log_vals, epoch, best_fitness, fi)
    
  
    
         # Save model
    
         if (not nosave) or (final_epoch and not evolve):  # if save
    
             ckpt = {
    
                 'epoch': epoch,
    
                 'best_fitness': best_fitness,
    
                 'model': deepcopy(de_parallel(model)).half(),
    
                 'ema': deepcopy(ema.ema).half(),
    
                 'updates': ema.updates,
    
                 'optimizer': optimizer.state_dict(),
    
                 'opt': vars(opt),
    
                 'git': GIT_INFO,  # {remote, branch, commit} if a git repo
    
                 'date': datetime.now().isoformat()}
    
  
    
             # Save last, best and delete
    
             torch.save(ckpt, last)
    
             if best_fitness == fi:
    
                 torch.save(ckpt, best)
    
             if opt.save_period > 0 and epoch % opt.save_period == 0:
    
                 torch.save(ckpt, w / f'epoch{epoch}.pt')
    
             del ckpt
    
             callbacks.run('on_model_save', last, epoch, final_epoch, best_fitness, fi)
    
  
    
     # EarlyStopping
    
     if RANK != -1:  # if DDP training
    
         broadcast_list = [stop if RANK == 0 else None]
    
         dist.broadcast_object_list(broadcast_list, 0)  # broadcast 'stop' to all ranks
    
         if RANK != 0:
    
             stop = broadcast_list[0]
    
     if stop:
    
         break  # must break all DDP ranks
    
  
    
     # end epoch ----------------------------------------------------------------------------------------------------
    
     # end training -----------------------------------------------------------------------------------------------------
    
     if RANK in {-1, 0}:
    
     LOGGER.info(f'\n{epoch - start_epoch + 1} epochs completed in {(time.time() - t0) / 3600:.3f} hours.')
    
     for f in last, best:
    
         if f.exists():
    
             strip_optimizer(f)  # strip optimizers
    
             if f is best:
    
                 LOGGER.info(f'\nValidating {f}...')
    
                 results, _, _ = validate.run(
    
                     data_dict,
    
                     batch_size=batch_size // WORLD_SIZE * 2,
    
                     imgsz=imgsz,
    
                     model=attempt_load(f, device).half(),
    
                     iou_thres=0.65 if is_coco else 0.60,  # best pycocotools at iou 0.65
    
                     single_cls=single_cls,
    
                     dataloader=val_loader,
    
                     save_dir=save_dir,
    
                     save_json=is_coco,
    
                     verbose=True,
    
                     plots=plots,
    
                     callbacks=callbacks,
    
                     compute_loss=compute_loss)  # val best model with plots
    
                 if is_coco:
    
                     callbacks.run('on_fit_epoch_end', list(mloss) + list(results) + lr, epoch, best_fitness, fi)
    
  
    
     callbacks.run('on_train_end', last, best, epoch, results)
    
  
    
     torch.cuda.empty_cache()
    
     return results

 def save_one_txt(predn, save_conf, shape, file):

    
     # Save one txt result
    
     gn = torch.tensor(shape)[[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(file, 'a') as f:
    
         f.write(('%g ' * len(line)).rstrip() % line + '\n')

 def save_one_json(predn, jdict, path, class_map):

    
     # Save one JSON result {"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(predn.tolist(), box.tolist()):
    
     jdict.append({
    
         'image_id': image_id,
    
         'category_id': class_map[int(p[5])],
    
         'bbox': [round(x, 3) for x in b],
    
         'score': round(p[4], 5)})

 def process_batch(detections, labels, iouv):

    
     correct = np.zeros((detections.shape[0], iouv.shape[0])).astype(bool)
    
     iou = box_iou(labels[:, 1:], detections[:, :4])
    
     correct_class = labels[:, 0:1] == detections[:, 5]
    
     for i in range(len(iouv)):
    
     x = torch.where((iou >= iouv[i]) & correct_class)  # IoU > threshold and classes match
    
     if x[0].shape[0]:
    
         matches = torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]), 1).cpu().numpy()  # [label, detect, iou]
    
         if x[0].shape[0] > 1:
    
             matches = matches[matches[:, 2].argsort()[::-1]]
    
             matches = matches[np.unique(matches[:, 1], return_index=True)[1]]
    
             # matches = matches[matches[:, 2].argsort()[::-1]]
    
             matches = matches[np.unique(matches[:, 0], return_index=True)[1]]
    
         correct[matches[:, 1].astype(int), i] = True
    
     return torch.tensor(correct, dtype=torch.bool, device=iouv.device)

    python detect.py --weights yolov5s.pt --img 640 --conf 0.25 --source data/images

 import cv2

    
  
    
 # 加载预训练的模型和标签
    
 model = cv2.dnn.readNetFromCaffe('deploy.prototxt', 'model.caffemodel')
    
 with open('labels.txt', 'r') as f:
    
     labels = f.read().splitlines()
    
  
    
 # 读取图像
    
 image = cv2.imread('999.jpg')
    
  
    
 # 创建一个blob（二进制大对象）从图像进行前处理
    
 blob = cv2.dnn.blobFromImage(image, 0.007843, (300, 300), (127.5, 127.5, 127.5), swapRB=True, crop=False)
    
  
    
 # 将blob输入到模型中进行推理
    
 model.setInput(blob)
    
 detections = model.forward()
    
  
    
 # 处理检测结果
    
 for i in range(detections.shape[2]):
    
     confidence = detections[0, 0, i, 2]
    
     if confidence > 0.1:  # 设定置信度阈值为0.5
    
     class_id = int(detections[0, 0, i, 1])
    
     label = labels[class_id]
    
     x1 = int(detections[0, 0, i, 3] * image.shape[1])
    
     y1 = int(detections[0, 0, i, 4] * image.shape[0])
    
     x2 = int(detections[0, 0, i, 5] * image.shape[1])
    
     y2 = int(detections[0, 0, i, 6] * image.shape[0])
    
  
    
     # 在图像上绘制检测结果
    
     cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
    
     cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
    
  
    
 # 显示图像
    
 cv2.imshow('SSD Object Detection', image)
    
 cv2.waitKey(0)
    
 cv2.destroyAllWindows()