crnn的网络由cnn（卷积层）和rnn（循环层）组合而成，cnn负责图像特征提取、rnn负责文字的序列特征提取。由于项目的字符特性（即共有7个字符，第一个是汉字，第二个是字母，其余是字母和数字），我们是不是可以将rnn网络去除，只保留cnn网络并对cnn进行改进，以达到车牌识别的目的呢？这是笔者在进行这个项目时突然冒出的一个想法，由于时间原因并没有进行验证。这里我们就按照CRNN论文对网络进行构建，以期对crnn网络理解更加深入。

CRNN网络的构建代码：

import torchimport torch.nn.functional as Fclass Vgg_16(torch.nn.Module):    def __init__(self):        super(Vgg_16, self).__init__()        self.convolution1 = torch.nn.Conv2d(1, 64, 3, padding=1)        self.pooling1 = torch.nn.MaxPool2d(2, stride=2)        self.convolution2 = torch.nn.Conv2d(64, 128, 3, padding=1)        self.pooling2 = torch.nn.MaxPool2d(2, stride=2)        self.convolution3 = torch.nn.Conv2d(128, 256, 3, padding=1)        self.convolution4 = torch.nn.Conv2d(256, 256, 3, padding=1)        self.pooling3 = torch.nn.MaxPool2d((1, 2), stride=(2, 1)) # notice stride of the non-square pooling        self.convolution5 = torch.nn.Conv2d(256, 512, 3, padding=1)        self.BatchNorm1 = torch.nn.BatchNorm2d(512)        self.convolution6 = torch.nn.Conv2d(512, 512, 3, padding=1)        self.BatchNorm2 = torch.nn.BatchNorm2d(512)        self.pooling4 = torch.nn.MaxPool2d((1, 2), stride=(2, 1))        self.convolution7 = torch.nn.Conv2d(512, 512, 2)    def forward(self, x):        x = F.relu(self.convolution1(x), inplace=True)        x = self.pooling1(x)        x = F.relu(self.convolution2(x), inplace=True)        x = self.pooling2(x)        x = F.relu(self.convolution3(x), inplace=True)        x = F.relu(self.convolution4(x), inplace=True)        x = self.pooling3(x)        x = self.convolution5(x)        x = F.relu(self.BatchNorm1(x), inplace=True)        x = self.convolution6(x)        x = F.relu(self.BatchNorm2(x), inplace=True)        x = self.pooling4(x)        x = F.relu(self.convolution7(x), inplace=True)        return x  # b*512x1x22class RNN(torch.nn.Module):    def __init__(self, class_num, hidden_unit):        super(RNN, self).__init__()        self.Bidirectional_LSTM1 = torch.nn.LSTM(512, hidden_unit, bidirectional=True)        self.embedding1 = torch.nn.Linear(hidden_unit * 2, 512)        self.Bidirectional_LSTM2 = torch.nn.LSTM(512, hidden_unit, bidirectional=True)        self.embedding2 = torch.nn.Linear(hidden_unit * 2, class_num)    def forward(self, x):        x = self.Bidirectional_LSTM1(x)   # LSTM output: output, (h_n, c_n)        T, b, h = x<0>.size()   # x<0>: (seq_len, batch, num_directions * hidden_size)        x = self.embedding1(x<0>.view(T * b, h))  # pytorch view() reshape as         x = x.view(T, b, -1)  # <22, b, 512>        x = self.Bidirectional_LSTM2(x)        T, b, h = x<0>.size()        x = self.embedding2(x<0>.view(T * b, h))        x = x.view(T, b, -1)        return x  # <22,b,class_num># output: class CRNN(torch.nn.Module):    def __init__(self, class_num, hidden_unit=256):        super(CRNN, self).__init__()        self.cnn = torch.nn.Sequential()        self.cnn.add_module('vgg_16', Vgg_16())        self.rnn = torch.nn.Sequential()        self.rnn.add_module('rnn', RNN(class_num, hidden_unit))    def forward(self, x):        x = self.cnn(x)        b, c, h, w = x.size()        # print(x.size())  #: b,c,h,w,(64, 512, 1, 22)        assert h == 1   # 特征图的高度必须是1        x = x.squeeze(2)  # 去除h维度, b *512 * width        x = x.permute(2, 0, 1)  #  =         # x = x.transpose(0, 2)        # x = x.transpose(1, 2)        x = self.rnn(x)        # print(x.size())  # (22, 64, 67)        return x

5.4. ctc损失函数

ctc损失函数（转录层）是为了解决训练时字符无法对齐的问题。ctc引入blank字符，解决有些位置没有字符的问题；通过递推，快速计算梯度。
pytorch中的ctc损失函数：CTCLoss — PyTorch 2.0 documentation

5.5. 网络的训练

下面我们来crnn+ctc网络的训练，训练过程和普通的cnn网络没有多大的区别。唯一需要注意的是ctc损失函数的构建，这里我建议读者在进行这部分代码阅读前一定要仔细阅读pytorch官方文档的ctc损失函数部分。下面是训练的核心代码：

import argparseimport copyimport osimport lib.alphabets as alphabetsimport torchimport randomimport numpy as npfrom lib import dataset, convertfrom torchvision import transformsfrom torch.utils.data import DataLoaderfrom net.CRNN_Net import CRNNimport torch.optim as optimfrom tqdm import tqdmimport timetrain_data_path = "./data/CCPD_plate_data/train/train_lmdb"val_data_path = "./data/CCPD_plate_data/val/val_lmdb"weight = "./runs/train/trainbest_weights.pth"def parse_opt(known=False):    parser = argparse.ArgumentParser()    parser.add_argument('--train_data', type=str, default=train_data_path)    parser.add_argument('--val_data', type=str, default=val_data_path)    parser.add_argument('--image_size', type=tuple, default=(32, 100))    parser.add_argument('--batch_size', type=int, default=64)    parser.add_argument('--epochs', type=int, default=2)    parser.add_argument('--alphabet', type=str, default=alphabets.alphabets)    parser.add_argument('--project', default='./runs/train/')    parser.add_argument('--random_seed', type=int, default=111)    parser.add_argument('--using_cuda', type=bool, default=True)    parser.add_argument('--num_workers', type=int, default=0)    parser.add_argument('--pin_memory', type=bool, default=True)    parser.add_argument('--optimizer', type=str, default="RMSprop")    parser.add_argument('--lr', type=float, default=0.0001)    parser.add_argument('--load_weight', type=bool, default=False)    parser.add_argument('--weight_path', type=str, default=weight)    opt = parser.parse_known_args()<0> if known else parser.parse_args()    return optdef weights_init(m):    class_name = m.__class__.__name__    if class_name.find('Conv') != -1:        m.weight.data.normal_(0.0, 0.02)    elif class_name.find('BatchNorm') != -1:        m.weight.data.normal_(1.0, 0.02)        m.bias.data.fill_(0)def train_and_eval(model, epochs, loss_func, optimizer, train_loader, val_loader):    # 初始化参数    lst = <>    t_start = time.time()    best_weights = copy.deepcopy(model.state_dict())    best_acc = 0.0    for epoch in range(epochs):        logs = "-" * 100 + "\n"        # train        model.train()        running_loss, running_acc = 0.0, 0.0        train_bar = tqdm(train_loader)        train_bar.desc = f"第{epoch + 1}次训练，Processing"        for inputs, labels in train_bar:            logs += "*" * 50 + "\n"            inputs = inputs.to(device)  # 数据放到device中            optimizer.zero_grad()            outputs = model(inputs)            # 计算这个batch的损失值            # print(type(labels))            text, text_length = converter.ocr_encode(text=labels)            # print(text)            # print(text_length)            text, text_length = text.to(device), text_length.to(device)  # 数据放到device中            outputs_length = torch.full(size=(outputs.size(1),), fill_value=outputs.size(0), device=device,                                        dtype=torch.long)            loss = loss_func(outputs, text, outputs_length, text_length)            running_loss += loss.item() * outputs.size(1)            # 计算这个batch正确识别的字符数            preds_size = torch.IntTensor( * outputs.size(1))            _, preds = outputs.max(2)            preds = preds.transpose(1, 0).contiguous().view(-1)            # print(preds.view(64, 22))            # print(preds_size)            sim_preds = converter.ocr_decode(preds.data, preds_size.data)            # print(len(sim_preds), sim_preds)            counter, lst = 0, <>            for i in labels:                lst.append(i.decode("utf-8", "strict"))            # print(lst)            for pred, target in zip(sim_preds, lst):                # print(pred, target)                if pred == target:                    counter += 1            logs += f"target:{lst}\n"            logs += f"pred:{sim_preds}\n"            logs += "*" * 50 + "\n"            running_acc = counter+running_acc            # 反向传播            loss.backward()            # 参数更新            optimizer.step()        # 计算本epoch的损失值和正确率        train_loss = running_loss / len(train_dataset)        train_acc = running_acc / len(train_dataset)        train_state = f"第{epoch + 1}次训练，train_loss:{train_loss:.6f}, train_acc:{train_acc:.6f}\n"        logs += train_state        # eval        model.eval()        running_loss, running_acc = 0.0, 0.0        with torch.no_grad():            eval_bar = tqdm(val_loader)            eval_bar.desc = f"第{epoch + 1}次评估，Processing"            for inputs, labels in eval_bar:                inputs = inputs.to(device)                outputs = model(inputs).to(device)                # 计算这个batch的损失值                text, text_length = converter.ocr_encode(text=labels)                text, text_length = text.to(device), text_length.to(device)  # 数据放到device中                outputs_length = torch.full(size=(outputs.size(1),), fill_value=outputs.size(0), device=device,                                            dtype=torch.long)                loss = loss_func(outputs, text, outputs_length, text_length)                running_loss += loss.item() * outputs.size(1)                # 计算这个batch正确识别的字符数                preds_size = torch.IntTensor( * outputs.size(1))                _, preds = outputs.max(2)                preds = preds.transpose(1, 0).contiguous().view(-1)                sim_preds = converter.ocr_decode(preds.data, preds_size.data)                counter, lst = 0, <>                for i in labels:                    lst.append(i.decode("utf-8", "strict"))                for pred, target in zip(sim_preds, lst):                    if pred == target:                        counter += 1                running_acc = counter+running_acc        # 计算本epoch的损失值和正确率        val_loss = running_loss / len(val_dataset)        val_acc = running_acc / len(val_dataset)        val_state = f"第{epoch + 1}次评估，val_loss:{val_loss:.6f}, val_acc:{val_acc:.6f}\n"        logs += val_state        logs += "-" * 100 + "\n"        print(logs)        lst.append(logs)        if val_acc > best_acc:            best_acc = val_acc            best_weights = copy.deepcopy(model.state_dict())    t_end = time.time()    total_time = t_end - t_start    result = f"{epochs}次训练与评估共计用时{total_time // 60:.0f}m{total_time % 60:.0f}s\n最高正确率是{best_acc:.6f}"    print(result)    lst.append(result)    # 加载最佳的模型权重    model.load_state_dict(best_weights)    return model, lstif __name__ == "__main__":    opt = parse_opt()    print(type(opt.train_data))    if not os.path.exists(opt.project):        os.makedirs(opt.project)    print(opt.epochs)    if torch.cuda.is_available() and opt.using_cuda:        device = torch.device('cuda:0')        # torch.backends.cudnn.deterministic = True        print("使用单个gpu进行训练")    else:        device = torch.device('cpu')        print("使用cpu进行训练")    # 随机种子    random.seed(opt.random_seed)    np.random.seed(opt.random_seed)    torch.manual_seed(opt.random_seed)    # 数据增强    transformer = {"train": transforms.Compose(),                   "val": transforms.Compose()}    # 制作数据集    train_dataset = dataset.LmdbDataset(root=opt.train_data, transform=transformer<"train">)    train_loader = DataLoader(train_dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers,                              pin_memory=opt.pin_memory)    val_dataset = dataset.LmdbDataset(root=opt.val_data, transform=transformer<"val">)    val_loader = DataLoader(val_dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers,                            pin_memory=opt.pin_memory)    n_class = len(opt.alphabet) + 1    print(f"字母表的长度是{n_class}")  # 包含blank    # 字符与标签转换器    converter = convert.StrLabelConverter(opt.alphabet)    # crnn网络    net = CRNN(n_class)    net.apply(weights_init)    net = net.to(device)    if opt.load_weight:        net.load_state_dict(torch.load(opt.weight_path, map_location=device))    print(net)    # ctc损失函数    ctc = torch.nn.CTCLoss()    # 优化器    if opt.optimizer == "RMSprop":        optimizer = optim.RMSprop(net.parameters(), lr=opt.lr)    elif opt.optimizer == "Adadelta":        optimizer = optim.Adadelta(net.parameters(), lr=opt.lr)    elif opt.optimizer == "Adam":        optimizer = optim.Adam(net.parameters(), lr=opt.lr)    # 训练和评估    best_model, log = train_and_eval(net, opt.epochs, ctc, optimizer, train_loader, val_loader)    best_weights = best_model.state_dict()    torch.save(best_weights, opt.project + "best_weights.pth")    with open(opt.project + "logs.txt", "w") as f:        for i in log:            f.write(i)

6. 模型推理部分

由于在检测部分使用的是yolov5，而yolov5拥有一套完整的代码，因此我们可以在yolov5的.detect基础上调整得到需要的推理代码。下面是推理的核心代码：

import argparseimport osimport sysfrom pathlib import Pathimport numpy as npimport cv2import torchimport torch.backends.cudnn as cudnnFILE = Path(__file__).resolve()ROOT = FILE.parents<0>  # YOLOv5 root directoryif str(ROOT) not in sys.path:    sys.path.append(str(ROOT))  # add ROOT to PATHROOT = Path(os.path.relpath(ROOT, Path.cwd()))  # relativefrom torchvision import transformsfrom my_utils import correction, box_label, Annotatorfrom crnn_ctc.net import CRNN_Net as ocr_netfrom crnn_ctc.lib import convert, alphabetsfrom yolov5.utils.augmentations import letterboxfrom yolov5.models.common import DetectMultiBackendfrom yolov5.utils.datasets import IMG_FORMATS, VID_FORMATS, LoadImages, LoadStreamsfrom yolov5.utils.general import (LOGGER, check_file, check_img_size, check_imshow, check_requirements, colorstr,                                  increment_path, non_max_suppression, print_args, scale_coords, strip_optimizer,                                  xyxy2xywh)from yolov5.utils.torch_utils import select_device, time_sync@torch.no_grad()def run(weights_vehicle=ROOT / 'weights/vehicle_yolov5s.pt',        weights_ccpd=ROOT / 'weights/ccpd_yolov5s.pt',        weights_plate=ROOT / 'weights/plate_crnn.pth',        source=ROOT / 'test/images',  # file/dir/URL/glob, 0 for webcam        data=ROOT / 'test/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        save_txt=False,  # save results to *.txt        save_img=True,        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        project=ROOT / 'test/runs',  # save results to project/name        name='exp',  # save results to project/name        exist_ok=False,  # existing project/name ok, do not increment        half=False,  # use FP16 half-precision inference        dnn=False,  # use OpenCV DNN for ONNX inference        ):    source = str(source)    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    # 加载vehicle模型    device = select_device(device)    model = DetectMultiBackend(weights_vehicle, 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    # 加载ccpd模型    model_ccpd = DetectMultiBackend(weights_ccpd, device=device, dnn=dnn, data=data)    # 加载ocr模型    model_ocr = ocr_net.CRNN(class_num=67)    model_ocr.load_state_dict(torch.load(weights_plate, map_location=device))    model_ocr.eval()    # 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:        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 =  * bs,  * bs    # 开始推理    model.warmup(imgsz=(1 if pt else bs, 3, *imgsz), half=half)  # warmup    model_ccpd.warmup(imgsz=(1, 3, 320, 320), half=half)    dt, seen = <0.0, 0.0, 0.0>, 0    # 七种边界框的颜色，六类车辆、一类车牌    np.random.seed(1)    colors = np.random.randint(0, 255, size=(len(names)+1, 3))    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  # 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        for i, det in enumerate(pred):  # 每张图片            seen += 1            if webcam:  # batch_size >= 1                p, im0, frame = path, im0s.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            s += '%gx%g ' % im.shape<2:>  # print string            annotator = Annotator(im0, line_width=3, pil=True, 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}{'s' * (n > 1)}, "  # add to string                # Write results                for *xyxy, conf, cls in reversed(det):  # 在图片中检测到的车辆边界框                    pt1 = (int(xyxy<0>), int(xyxy<1>))                    pt2 = (int(xyxy<2>), int(xyxy<3>))                    # 截取锚框内的图像，源图像的拷贝是im0，锚框左上坐标是pt1，右下坐标是pt2                    im0_vehicle = im0:pt2<1>, pt1<0>:pt2<0>>                    im_vehicle = letterbox(im0_vehicle, new_shape=(320, 320))<0>                    im_vehicle = im_vehicle.transpose((2, 0, 1))<::-1>  # HWC to CHW, BGR to RGB                    im_vehicle = np.ascontiguousarray(im_vehicle)                    im_vehicle = torch.from_numpy(im_vehicle).to(device)                    im_vehicle = im_vehicle.half() if half else im_vehicle.float()  # uint8 to fp16/32                    im_vehicle /= 255  # 0 - 255 to 0.0 - 1.0                    if len(im_vehicle.shape) == 3:                        im_vehicle = im_vehicle  # expand for batch dim                    pred_ccpd = model_ccpd(im_vehicle, augment=augment, visualize=visualize)                    pred_ccpd = non_max_suppression(pred_ccpd, conf_thres, iou_thres, classes, agnostic_nms,                                                    max_det=max_det)                    for ii, det_ccpd in enumerate(pred_ccpd):   # 每个车牌                        if len(det_ccpd):                            # Rescale boxes from 320*320 to im0_vehicle size                            det_ccpd<:, :4> = scale_coords(im_vehicle.shape<2:>, det_ccpd<:, :4>,                                                           im0_vehicle.shape).round()                            # Write results                            for *xyxy, conf, clss in reversed(det_ccpd):    # 每个车牌的边界框                                pt11 = (int(xyxy<0>), int(xyxy<1>))                                pt22 = (int(xyxy<2>), int(xyxy<3>))                                # 截取且矫正车牌                                im0_plate = im0_vehicle:pt22<1>, pt11<0>:pt22<0>>                                # im0_plate = correction(im0_plate)                                # 图像灰度化且转为张量                                im0_plate = cv2.cvtColor(im0_plate, cv2.COLOR_BGR2GRAY)                                im0_plate = cv2.resize(im0_plate, (100, 32))                                im0_plate = transforms.ToTensor()(im0_plate).to(device)                                im0_plate = im0_plate.view(1, 1, 32, 100)                                result = model_ocr(im0_plate)                                converter = convert.StrLabelConverter(alphabets.alphabets)                                preds_size = torch.IntTensor( * result.size(1))                                _, preds = result.max(2)                                preds = preds.transpose(1, 0).contiguous().view(-1)                                plate = converter.ocr_decode(preds.data, preds_size.data)                                # plate标签、ccpd边界框在源图中的 坐标                                color = colors<6>                                target = str(plate)                                pt1_ccpd, pt2_ccpd = (pt1<0> + pt11<0>, pt1<1> + pt11<1>), (                                pt1<0> + pt22<0>, pt1<1> + pt22<1>)                                # 可视化                                annotator.box_label(pt1_ccpd+pt2_ccpd, target, color=tuple(color))                    # vehicle标签、边界框坐标                    c = int(cls)                    color = colors                    label = f'{names} {conf:.2f}'                    pt1_vehicle, pt2_vehicle = pt1, pt2                    annotator.box_label(pt1_vehicle + pt2_vehicle, label, color=tuple(color))            # 保存每一张测试结果            im0 = annotator.result()            if save_img:                # cv2.imshow("111", im0)                # cv2.waitKey()                # cv2.destroyAllWindows()                if dataset.mode == 'image':                    cv2.imwrite(save_path, im0)                else:  # 'video' or 'stream'                    if vid_path != save_path:  # new video                        vid_path = save_path                        if isinstance(vid_writer, cv2.VideoWriter):                            vid_writer.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 = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))                    vid_writer.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)def parse_opt():    parser = argparse.ArgumentParser()    parser.add_argument('--weights_vehicle', nargs='+', type=str, default=ROOT / 'weights/vehicle_yolov5s.pt',                        help='model path(s)')    parser.add_argument('--weights_ccpd', nargs='+', type=str, default=ROOT / 'weights/ccpd_yolov5s.pt',                        help='model path(s)')    parser.add_argument('--weights_plate', nargs='+', type=str, default=ROOT / 'weights/plate_crnn.pth',                        help='model path(s)')    parser.add_argument('--source', type=str, default=ROOT / 'test/video', help='file/dir/URL/glob, 0 for webcam')    parser.add_argument('--data', type=str, default=ROOT / 'test/coco128.yaml', help='(optional) dataset.yaml path')    parser.add_argument('--imgsz', '--img', '--img-size', nargs='+', type=int, default=<640>, help='inference size h,w')    parser.add_argument('--conf-thres', type=float, default=0.25, help='confidence threshold')    parser.add_argument('--iou-thres', type=float, default=0.45, help='NMS IoU threshold')    parser.add_argument('--max-det', type=int, default=1000, help='maximum detections per image')    parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')    parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')    parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --classes 0, or --classes 0 2 3')    parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')    parser.add_argument('--augment', action='store_true', help='augmented inference')    parser.add_argument('--visualize', action='store_true', help='visualize features')    parser.add_argument('--project', default=ROOT / 'runs/detect', help='save results to project/name')    parser.add_argument('--name', default='exp', help='save results to project/name')    parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')    parser.add_argument('--half', action='store_true', help='use FP16 half-precision inference')    parser.add_argument('--dnn', action='store_true', help='use OpenCV DNN for ONNX inference')    opt = parser.parse_args()    opt.imgsz *= 2 if len(opt.imgsz) == 1 else 1  # expand    return optdef main(opt):    check_requirements(exclude=('tensorboard', 'thop'))    return run(**vars(opt))if __name__ == "__main__":    opt = parse_opt()    points = main(opt)

7. 效果展示与项目总结

7.1. 效果展示