test_flops.py

import argparse
# import json
# import os
# from pathlib import Path
# from threading import Thread

# import numpy as np
import torch
# import yaml
# from tqdm import tqdm

from models.experimental import attempt_load
# from utils.datasets import create_dataloader, create_dataloader_sr
from utils.general import coco80_to_coco91_class, check_dataset, check_file, check_img_size, check_requirements, \
    box_iou, non_max_suppression,weighted_boxes, scale_coords, xyxy2xywh, xywh2xyxy, set_logging, increment_path, colorstr
# from utils.metrics import ap_per_class, ConfusionMatrix
from utils.plots import plot_images, output_to_target, plot_study_txt, ploy_weights, k_means_cpu
from utils.torch_utils import select_device, time_synchronized

import torch.nn as nn
# from torchvision import transforms
# from PIL import Image
# unloader = transforms.ToPILImage()


# def tensor_to_PIL(tensor):
#     image = tensor.cpu().clone()
#     image = image.squeeze(0)
#     image = unloader(image)
#     image.save('a.png')
#     return image

def test(#data,
         weights=None,
         batch_size=32,
         imgsz=640,
         input_mode = None,
        #  conf_thres=0.001,
        #  iou_thres=0.6,  # for NMS
        #  save_json=False,
        #  single_cls=False,
        #  augment=False,
        #  verbose=False,
         model=None,
        #  dataloader=None,
        #  save_dir=Path(''),  # for saving images
        #  save_txt=False,  # for auto-labelling
        #  save_hybrid=False,  # for hybrid auto-labelling
        #  save_conf=False,  # save auto-label confidences
        #  plots=False,
        #  wandb_logger=None,
        #  compute_loss=None,
        #  is_coco=False
        ):
    # 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(opt.device, batch_size=batch_size)

        # Directories
        # save_dir = Path(increment_path(Path(opt.project) / opt.name, exist_ok=opt.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
        #zjq
        # print(model)
        print(model.yaml_file)
        # print(model)

        ############ the code for calculating the params and flops ############
        weights_full_precision = opt.full_weights
        model_full = attempt_load(weights_full_precision, map_location=device)
        import thop
        from utils.thop import profile
        input_image_size = opt.img_size
        input_image = torch.randn(1, 3, input_image_size, input_image_size).to(device)
        flops, params,ops_list, params_list,ops_list_,params_list_ = profile(model_full, inputs=(input_image,input_image,opt.input_mode,False), verbose=False) #ops_list,params_list for convolution
        print('Params: %.4fM'%(params/1e6))
        print('FLOPs: %.2fG'%(flops/1e9))
        module_name = []
        conv_layer = 0
        for idx,(name,m) in enumerate(model_full.named_modules()):
            # print(idx,name)
            if isinstance(m,nn.Conv2d) and "model_up" not in name:
                conv_layer += 1 
                module_name.append(int(name.split('.')[1]))
        ########################################################################
        if opt.bit_width:
            bit_width =  [opt.bit_width]*conv_layer
        else:
            bit_width = []
            for idx,(name,m) in enumerate(model.named_modules()): #k t
                if 'conv.weight_function' in name:
                    # print(name)
                    bit_width.append(m.w_bit)
                    print(len(bit_width), name, m.w_bit)
            
                # print(m.w_bit)
        # print(bit_width)
        ##########################################################333
        # from torchsummaryX import summary
        # print(summary(model, input_image,input_image,input_mode))
        # model=torch.jit.trace(model,(input_image,input_image)).eval()
        # print(model)
        # print('Layers: %.0f'%(len(list(model.modules()))))

        # def constructor(input_res):
        #    input_image = torch.randn(1, *input_res).to(device)
        #    #input_image = torch.ones(()).new_empty((1, *input_res)).cuda()
        #    inputs={'x':input_image,'ir':input_image}
        #    return inputs
        # from ptflops import get_model_complexity_info
        # flops, params = get_model_complexity_info(model, (3, input_image_size, input_image_size),input_constructor=constructor, as_strings=True,print_per_layer_stat=False)
        # print("%s |%s " % (flops,params))

        # gs = max(int(model.stride.max()), 32)  # grid size (max stride)
        # imgsz = check_img_size(imgsz, s=gs)  # check img_size
        # n_bit = 2
        # ploy_weights(model)
        ########## the code for plot ###########
        # conv_idx = 0 
        # for idx,(name,m) in enumerate(model.named_modules()):
        #     # print(idx,name)
        #     if isinstance(m,nn.Conv2d):
        #         print(conv_idx,name)
        #         w = m.weight.data
        #         print(w.shape)
        #         if w.shape[-1]==1:
        #             conv_idx +=1
        #             continue
        #         # feature_cluster(w,"kmeans_{}.png".format(n_bit))
        #         print("weight max:", w.max(), "weight min:",w.min())
        #         if conv_idx ==0 or conv_idx ==6 or conv_idx ==27 or conv_idx ==26 or conv_idx ==52 or conv_idx ==53:
        #             for n_bit in [2,3,4,5]:
        #                 centroids, labels = k_means_cpu(w.cpu().numpy(), n_bit,"kmeans_{}_{}.png".format(conv_idx,n_bit),plot_flag=True)
        #         if conv_idx > 61:
        #             break
        #         conv_idx +=1
        #######################################################################
        # ########## the code for calculating the bit width#############
        The_last_ = params_list.index(0)-1
        if not bit_width:
            bit_width = []
            conv_idx = 0 
            for idx,(name,m) in enumerate(model.named_modules()):
                # print(idx,name)
                if isinstance(m,nn.Conv2d):
                    # print(conv_idx,name)
                    w = m.weight.data
                    # print(w.shape)
                    # print("weight max:", w.max(), "weight min:",w.min())
                    for n_bit in [2,3,4,5,6,7,8]:
                        inertia_distance = k_means_cpu(w.cpu().numpy(), 2 ** n_bit,plot_flag=False)
                        print(n_bit,inertia_distance)
                        if inertia_distance < opt.inter_threshold:
                            bit_width.append(n_bit)
                            break
                        elif n_bit==8:
                            bit_width.append(n_bit)
                    if conv_idx > module_name.index(max(module_name))-2: #The quantization network not includes SR branch and detector
                        break
                    conv_idx +=1
        # bit_width = [8]*47
    
        #####################################################################
        # bit_width = [32]*48
        quan_conv_params, quan_conv_BOPs = 0, 0
        if model.yaml_file=='SRyolo_noFocus_small.yaml':
            The_last_ = params_list.index(0)-1
        else:
            The_last_ = params_list.index(0)-3
        for i in range(The_last_):
            print(ops_list[i])
            quan_conv_params += params_list[i]*bit_width[i]/8
            if i==0:
                quan_conv_BOPs += ops_list[i]*bit_width[i]*32
            else:
                quan_conv_BOPs += ops_list[i]*bit_width[i]*bit_width[i-1]
        if model.yaml_file=='SRyolo_noFocus_small.yaml':
            quan_conv_params += params_list[The_last_]*32/8
            quan_conv_BOPs += ops_list[The_last_]*32*32
        else:
            quan_conv_params += params_list[The_last_-2]*32/8+params_list[The_last_-1]*32/8+params_list[The_last_]*32/8
            quan_conv_BOPs += ops_list[The_last_-2]*32*32+ops_list[The_last_-1]*32*32+ops_list[The_last_]*32*32
        # quan_params = sum(params_list_) + quan_conv_params
        # quan_BOPs = sum(ops_list_) + quan_conv_BOPs
        print('Quantization Params: %.4fMB'%(quan_conv_params/1e6))
        print('Quantization BOPs: %.2fG'%(quan_conv_BOPs/1e9))
        # print('Quantization Params1: %.4fMB'%(quan_params/1e6))
        # print('Quantization BOPs1: %.2fG'%(quan_BOPs/1e9))
        ####################################################################
        print("the bit width is defined as",bit_width)

        # 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().float()


    # Configure
    # model.eval()

    
    # if isinstance(data, str):
    #     is_coco = data.endswith('coco.yaml')
    #     with open(data) as f:
    #         data = yaml.load(f, Loader=yaml.SafeLoader)
    # check_dataset(data)  # check
    # 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 mAP@0.5:0.95 zjq
    # 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': #zjq zhushi
    #     #     model(torch.zeros(1, 3, imgsz, imgsz).to(device).type_as(next(model.parameters())))  # run once
    #     task = opt.task if opt.task in ('train', 'val') else 'val'  # path to train/val/test images
    #     dataloader = create_dataloader_sr(data[task], imgsz, batch_size, gs, opt, pad=0.5, rect=False,
    #                         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' + '%12s' * 6) % ('Class', 'Images', 'Labels', 'P', 'R', 'mAP@.5', 'mAP@.5:.95')
    # p, r, f1, mp, mr, map50, map, t0, t1 = 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, ir, targets, paths, shapes) in enumerate(tqdm(dataloader, desc=s)): #zjq
    #     img = img.to(device, non_blocking=True).float()
    #     # img = img.half() if half else img.float()  # uint8 to fp16/32
    #     img /= 255.0  # 0 - 255 to 0.0 - 1.0
    #     ir = ir.to(device, non_blocking=True).float()
    #     # ir = ir.half() if half else ir.float()  # uint8 to fp16/32
    #     ir /= 255.0  # 0 - 255 to 0.0 - 1.0
    #     targets = targets.to(device)
    #     nb, _, height, width = img.shape  # batch size, channels, height, width

    #     with torch.no_grad():
    #         # Run model
    #         t = time_synchronized()
    #         try:
    #             out, train_out,features = model(img,ir,input_mode=input_mode) #zjq inference and training outputs
    #         except:
    #             out, train_out = model(img,ir,input_mode=input_mode) #zjq inference and training outputs
    #         t0 += 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=conf_thres, iou_thres=iou_thres, labels=lb, multi_label=True)
    #         # out = weighted_boxes(out,image_size=imgsz, conf_thres=conf_thres, iou_thres=iou_thres, labels=lb, multi_label=True)
    #         t1 += 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
    #         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)  # prediction indices
    #                 pi = (cls == pred[:, 5]).nonzero(as_tuple=False).view(-1)  # target 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: #zjq
    #         f = save_dir / f'test_batch{batch_i}_labels.png'  # labels
    #         # f = '/home/data/zhangjiaqing/dataset/VEDAI/train_label/'+paths[0].split('/')[-1].replace('_co','_label') #zjq
    #         if input_mode == 'IR':
    #             Thread(target=plot_images, args=(ir, targets, paths, f, names), daemon=True).start()
    #         else:
    #             Thread(target=plot_images, args=(img, targets, paths, f, names), daemon=True).start()
    #         f = save_dir / f'test_batch{batch_i}_pred.png'  # predictions
    #         if input_mode == 'IR':
    #             Thread(target=plot_images, args=(ir, output_to_target(out), paths, f, names), daemon=True).start()
    #         else:
    #             Thread(target=plot_images, args=(img, output_to_target(out), paths, f, names), daemon=True).start()
    #     # break
    # # 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)  # AP@0.5, AP@0.5: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' + '%12i' * 2 + '%12.3g' * 4  # print format
    # print(pf % ('all', seen, nt.sum(), mp, mr, map50, map))
    # import xlsxwriter
    # workbook = xlsxwriter.Workbook('hello.xlsx') # 建立文件
    # worksheet = workbook.add_worksheet() # 建立sheet， 可以work.add_worksheet('employee')来指定sheet名，但中文名会报UnicodeDecodeErro的错误
    # worksheet.write(0,0, 'all') # 向A1写入
    # worksheet.write(0,1, seen) # 向A1写入
    # worksheet.write(0,2,nt.sum())#向第二行第二例写入guoshun
    # worksheet.write(0,3,mp*100)
    # worksheet.write(0,4,mr*100)
    # worksheet.write(0,5,map50*100)
    # worksheet.write(0,6,map*100)


    # # 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]))
    #         worksheet.write(i+1,0, names[c]) # 向A1写入
    #         worksheet.write(i+1,1, seen) # 向A1写入
    #         worksheet.write(i+1,2,nt[c])#向第二行第二例写入
    #         worksheet.write(i+1,3,p[i]*100)
    #         worksheet.write(i+1,4,r[i]*100)
    #         worksheet.write(i+1,5,ap50[i]*100)
    #         worksheet.write(i+1,6,ap[i]*100)
    #     workbook.close()

    # # Print speeds
    # t = tuple(x / seen * 1E3 for x in (t0, t1, t0 + t1)) + (imgsz, imgsz, batch_size)  # tuple
    # if not training:
    #     print('Speed: %.3f/%.3f/%.3f ms inference/NMS/total per %gx%g image at batch-size %g' % 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
    #         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 (mAP@0.5:0.95, mAP@0.5)
    #     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


if __name__ == '__main__':
    parser = argparse.ArgumentParser(prog='test.py')
    parser.add_argument('--weights', nargs='+', type=str, default=['runs/train/use/exp96_8bs_150e_0.1_disloss6_400_nwpu/weights/best.pt'], help='model.pt path(s)') #runs/train/exp60/weights/best.pt
    #runs/train/1000epoch/conv/exp32/weights/best.pt runs/train/exp89/weights/best.pt
    parser.add_argument('--full_weights', nargs='+', type=str, default=['runs/train/use/exp95_8bs_150e_nwpu/weights/best.pt'], help='model.pt path(s)')
    parser.add_argument('--bit_width', type=int,default=None, help='bit-width')
    # parser.add_argument('--data', type=str, default='data/SRvedai.yaml', help='*.data path')
    parser.add_argument('--batch-size', type=int, default=8, help='size of each image batch')
    parser.add_argument('--img-size', type=int, default=512, help='inference size (pixels)')
    # parser.add_argument('--hr_input', default=False,action='store_true', help='high resolution input(1024*1024)') #if use SR,please set True
    parser.add_argument('--input_mode', type=str, default='RGB') #RGB IR RGB+IR RGB+IR+fusion RGB+IR+SAM
    
    parser.add_argument('--inter-threshold', type=float, default=0.1, help='the kmeans inter distance threshold')
    # parser.add_argument('--conf-thres', type=float, default=0.001, help='object confidence threshold')
    # parser.add_argument('--iou-thres', type=float, default=0.6, help='IOU threshold for NMS')
    parser.add_argument('--task', default='val', help='train, val, test, speed or study')
    parser.add_argument('--device', default='1', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
    # parser.add_argument('--single-cls', action='store_true', help='treat as single-class dataset')
    # parser.add_argument('--augment', action='store_true', help='augmented inference')
    # parser.add_argument('--verbose', action='store_true', help='report mAP by class')
    # parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
    # parser.add_argument('--save-hybrid', action='store_true', help='save label+prediction hybrid results to *.txt')
    # parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
    # parser.add_argument('--save-json', action='store_true', help='save a cocoapi-compatible JSON results file')
    # parser.add_argument('--project', default='runs/test', help='save to project/name')
    # 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')
    opt = parser.parse_args()
    # opt.save_json |= opt.data.endswith('coco.yaml')
    # opt.data = check_file(opt.data)  # check file
    print(opt)
    check_requirements()
    if opt.task in ('train', 'val', 'test'):  # run normally
        test(#opt.data,
            opt.weights,
            opt.batch_size,
            opt.img_size,
            opt.input_mode,
            # opt.conf_thres,
            # opt.iou_thres,
            # opt.save_json,
            # opt.single_cls,
            # opt.augment,
            # opt.verbose,
            # save_txt=opt.save_txt | opt.save_hybrid,
            # save_hybrid=opt.save_hybrid,
            # save_conf=opt.save_conf,
            )