DAMO-YOLO踩坑记录

已于 2024-04-29 15:47:33 修改
阅读量497 收藏 11
点赞数 6
分类专栏： ai 文章标签： python 目标检测 YOLO
于 2024-04-10 18:37:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012077914/article/details/137604860
版权

环境

系统：win10

GPU：NVIDIA RTX4070TI

CUDA：11.8

python版本：3.8

项目配置

1. 从github拉取源码

git clone https://github.com/tinyvision/DAMO-YOLO.git

2. 安装环境依赖

cd DAMO-YOLO/
conda create -n DAMO-YOLO python=3.8 -y
conda activate DAMO-YOLO
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
# 环境依赖readme里面是直接安装requirements
pip install -r requirements.txt
# 也可以使用
python setup.py install

虽然我用pip安装了依赖，但是实际运行时还是因为缺少matplotlib库：

所以进一步安装matplotlib：

pip install matplotlib

3. 修改模型训练样本配置部分源码

项目根目录新建文件夹：module，把从github上下载的预训练权重放进去

在datasets文件夹下创建：对应图像和标签

datasets
|
|--Custom_coco
|   |
|   |--annotations
|   |   |
|   |   |--train_coco_format.json
|   |   |--val_coco_format.json
    |
    |--images
        |
        |--train
        |    |--image001.jpg...
        |
        |--val
            |--image

修改configs/damoyolo_tinynasL20_T.py文件内容

# 在config类的init函数内添加：
self.train.no_aug_epochs = 16
self.train.warmup_epochs = 5
----------上文-------------------
self.train.finetune_path = 'E:\\proj\\lineCheck\\DAMO-YOLO\\model\\damoyolo_tinynasL20_T_420.pth'
self.train.total_epochs = 10
----------下文-------------------
# augment
self.train.augment.transform.image_max_range = (500, 500)
self.train.augment.mosaic_mixup.mixup_prob = 0.15
.
.
.
.
.
.
.
.
.
ZeroHead = {
            'name': 'ZeroHead',
            'num_classes': 1,    #这里修改成你样本的分类数量
            'in_channels': [64, 128, 256],
            'stacked_convs': 0,
            'reg_max': 16,
            'act': 'silu',
            'nms_conf_thre': 0.05,
            'nms_iou_thre': 0.7,
            'legacy': False,
        }
        self.model.head = ZeroHead

        self.dataset.class_names = ['qx']    # 这里写入标签对应的名称

进一步修改damo/config/paths_catalog.py文件内容

# 在DatasetCatalog里面吧DATASETS里的数据集路径进行修改，与上面设置的数据集路径一致
DATA_DIR = 'datasets' # 这里设置root
DATASETS = {
        'coco_2017_train': { # 训练集
            'img_dir': 'Custom_coco/images/train', # 基于root的数据集图片
            'ann_file': 'Custom_coco/annotations/train_coco_format.json' # 基于root的数据集标签
        },
        'coco_2017_val': { # 验证集
            'img_dir': 'Custom_coco/images/val',
            'ann_file': 'Custom_coco/annotations/val_coco_format.json'
        },
        'coco_2017_test_dev': { # 测试集
            'img_dir': 'Custom_coco/images/val',
            'ann_file': 'Custom_coco/annotations/val_coco_format.json'
        },

将train.py从tools文件夹移动到根目录下并将nccl改成gloo，因为nccl是在linux系统下用的

torch.distributed.init_process_group(backend='gloo', init_method='env://')

4. 开始训练

# 官网给出的训练命令：
python -m torch.distributed.launch --nproc_per_node=8 tools/train.py -f configs/damoyolo_tinynasL20_T.py
# 单卡环境且因为找不到damo包路径所以吧train.py移动到了根目录，所以改成
python -m torch.distributed.launch --nproc_per_node=1 train.py -f configs/damoyolo_tinynasL20_T.py
# 又显示命令行参数错误，所以按照要求加上use_env变成：
python -m torch.distributed.launch --nproc_per_node=1 --use_env train.py -f configs/damoyolo_tinynasL20_T.py

一些坑

一开始提示找不到damo包：把train.py拖到root
然后是：matplotlib没有安装： pip install matplotlib

再然后是：error:unrecognized argument: --local-rank=0， 在调用train.py前加上--use_env

最后是numpy版本过高导致.float不可用，要么用正确的numpy版本，要么改位于pycocotools的cocoeval.py代码：

# 此为下策，因为直接改动了源码，不知道会出现什么问题，但是能用

# 这里是因为训练时报错说不接受浮点
self.iouThrs = np.linspace(.5, 0.95, int(np.round((0.95 - .5) / .05)) + 1, endpoint=True)
self.recThrs = np.linspace(.0, 1.00, int(np.round((1.00 - .0) / .01)) + 1, endpoint=True)

# 这里是因为np.float不可用
tp_sum = np.cumsum(tps, axis=1).astype(dtype=np.float64)
fp_sum = np.cumsum(fps, axis=1).astype(dtype=np.float64)

网上可以找txt转coco的标签格式转换脚本，我用的是：
这个大佬写的（感谢）

最后跑起来了：

验证+推理

跑了一个晚上，算是得到了pth权重文件，然后尝试验证和推理。有遇到了一些坑，记录一下。。。

验证

验证环节按readme的说法是使用eval.py完成的，和train的问题一样找不到damo包。挪到根目录，在调用前加上--use_env。

python -m torch.distributed.launch --nproc_per_node=1 --use_env eval.py -f configs/damoyolo_tinynasL20_T.py -c workdirs/damoyolo_tinynasL20_T/epoch_300_ckpt.pth --fuse

一切顺利，得到结果，感觉不是很好，还是要继续调参。。。

(DAMO-YOLO) PS E:\proj\DAMO-YOLO> python -m torch.distributed.launch --nproc_per_node=1 --use_env eval.py -f configs/damoyolo_tinynasL20_T.py -c workdirs/damoyolo_tinyn
asL20_T/epoch_300_ckpt.pth --fuse
[2024-04-11 09:49:49,208] torch.distributed.elastic.multiprocessing.redirects: [WARNING] NOTE: Redirects are currently not supported in Windows or MacOs.
C:\Users\chonpsk\.conda\envs\DAMO-YOLO\lib\site-packages\torch\distributed\launch.py:183: FutureWarning: The module torch.distributed.launch is deprecated
and will be removed in future. Use torchrun.
Note that --use-env is set by default in torchrun.
If your script expects `--local-rank` argument to be set, please
change it to read from `os.environ['LOCAL_RANK']` instead. See
https://pytorch.org/docs/stable/distributed.html#launch-utility for
further instructions

  warnings.warn(
[W socket.cpp:697] [c10d] The client socket has failed to connect to [kubernetes.docker.internal]:29500 (system error: 10049 - 在其上下文中，该请求的地址无效。).
[W socket.cpp:697] [c10d] The client socket has failed to connect to [kubernetes.docker.internal]:29500 (system error: 10049 - 在其上下文中，该请求的地址无效。).
2024-04-11 09:49:51 | INFO     | __main__:93 - Args: Namespace(ckpt='workdirs/damoyolo_tinynasL20_T/epoch_300_ckpt.pth', conf=None, config_file='configs/damoyolo_tinynasL20_T.py'
, fuse=True, local_rank=0, nms=None, opts=[], seed=None, test=False, tsize=None)
2024-04-11 09:49:51 | INFO     | __main__:102 - loading checkpoint from workdirs/damoyolo_tinynasL20_T/epoch_300_ckpt.pth
2024-04-11 09:49:51 | INFO     | __main__:110 - loaded checkpoint done.
2024-04-11 09:49:54 | INFO     | __main__:117 - Model Summary: backbone's params(M): 2.17, flops(G): 7.97, latency(ms): 1.125
neck's params(M): 5.71, flops(G): 8.24, latency(ms): 3.125
head's params(M): 0.28, flops(G): 0.89, latency(ms): 1.125
total latency(ms): 5.640, total flops(G): 17.10, total params(M): 8.16

2024-04-11 09:49:54 | INFO     | __main__:122 -         Fusing model...
2024-04-11 09:49:54 | INFO     | torchvision.datasets.coco:36 - loading annotations into memory...
2024-04-11 09:49:54 | INFO     | torchvision.datasets.coco:36 - Done (t=0.00s)
2024-04-11 09:49:54 | INFO     | pycocotools.coco:89 - creating index...
2024-04-11 09:49:54 | INFO     | pycocotools.coco:89 - index created!
2024-04-11 09:49:54 | INFO     | damo.apis.detector_inference:75 - Start evaluation on coco_2017_val dataset(160 images).
100%|##############################################################################################################################################| 2/2 [00:09<00:00,  4.70s/it] 
2024-04-11 09:50:04 | INFO     | damo.apis.detector_inference:87 - Total run time: 0:00:09.420176 (0.058876097202301025 s / img per device, on 1 devices)
2024-04-11 09:50:04 | INFO     | damo.apis.detector_inference:92 - Model inference time: 0:00:00.856720 (0.005354499816894532 s / img per device, on 1 devices)
2024-04-11 09:50:04 | INFO     | damo.dataset.datasets.evaluation.coco.coco_eval:42 - Preparing results for COCO format
2024-04-11 09:50:04 | INFO     | damo.dataset.datasets.evaluation.coco.coco_eval:45 - Preparing bbox results
2024-04-11 09:50:04 | INFO     | damo.dataset.datasets.evaluation.coco.coco_eval:49 - Evaluating predictions
2024-04-11 09:50:04 | INFO     | damo.dataset.datasets.evaluation.coco.coco_eval:231 - Loading and preparing results...
2024-04-11 09:50:04 | INFO     | damo.dataset.datasets.evaluation.coco.coco_eval:231 - DONE (t=0.01s)
2024-04-11 09:50:04 | INFO     | pycocotools.coco:362 - creating index...
2024-04-11 09:50:04 | INFO     | pycocotools.coco:362 - index created!
2024-04-11 09:50:04 | INFO     | damo.dataset.datasets.evaluation.coco.coco_eval:236 - Running per image evaluation...
2024-04-11 09:50:04 | INFO     | damo.dataset.datasets.evaluation.coco.coco_eval:236 - Evaluate annotation type *bbox*
2024-04-11 09:50:04 | INFO     | damo.dataset.datasets.evaluation.coco.coco_eval:236 - DONE (t=0.10s).
2024-04-11 09:50:04 | INFO     | damo.dataset.datasets.evaluation.coco.coco_eval:237 - Accumulating evaluation results...
2024-04-11 09:50:04 | INFO     | damo.dataset.datasets.evaluation.coco.coco_eval:237 - DONE (t=0.02s).
2024-04-11 09:50:04 | INFO     | pycocotools.cocoeval:463 -  Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.473
2024-04-11 09:50:04 | INFO     | pycocotools.cocoeval:464 -  Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.895
2024-04-11 09:50:04 | INFO     | pycocotools.cocoeval:465 -  Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.409
2024-04-11 09:50:04 | INFO     | pycocotools.cocoeval:466 -  Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.340
2024-04-11 09:50:04 | INFO     | pycocotools.cocoeval:467 -  Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.503
2024-04-11 09:50:04 | INFO     | pycocotools.cocoeval:468 -  Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.621
2024-04-11 09:50:04 | INFO     | pycocotools.cocoeval:469 -  Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.215
2024-04-11 09:50:04 | INFO     | pycocotools.cocoeval:470 -  Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.584
2024-04-11 09:50:04 | INFO     | pycocotools.cocoeval:472 -  Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.544
2024-04-11 09:50:04 | INFO     | pycocotools.cocoeval:473 -  Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.611
2024-04-11 09:50:04 | INFO     | damo.dataset.datasets.evaluation.coco.coco_eval:59 - OrderedDict([('bbox', OrderedDict([('AP', 0.4730805870212621), ('AP50', 0.895090459391299), 
('AP75', 0.4091130859655121), ('APs', 0.3403641442326747), ('APm', 0.5026130249143416), ('APl', 0.6209136920203059)]))])

推理

推理的使用遇到了一个小坑，在运行时突然告诉我numpy数组被定义为只读的，不可被操作。

2024-04-11 10:13:31.168 | ERROR    | __main__:<module>:356 - An error has been caught in function '<module>', process 'MainProcess' (980), thread 'MainThread' (23684):
Traceback (most recent call last):

> File "demo.py", line 356, in <module>
    main()
    └ <function main at 0x000001C91010F820>

  File "demo.py", line 321, in main
    vis_res = infer_engine.visualize(origin_img, bboxes, scores, cls_inds, conf=args.conf, save_name=os.path.basename(args.path), save_result=args.save_result)
              │            │         │           │       │       │              │    │               │  │    │        │    │                  │    └ True
              │            │         │           │       │       │              │    │               │  │    │        │    │                  └ Namespace(camid=0, conf=0.6, confi
g_file='./configs/damoyolo_tinynasL20_T.py', device='cuda', end2end=False, engine='workdirs...
              │            │         │           │       │       │              │    │               │  │    │        │    └ 'datasets/Custom_coco/images/val/66_crop_0.jpg'      
              │            │         │           │       │       │              │    │               │  │    │        └ Namespace(camid=0, conf=0.6, config_file='./configs/damoyo
lo_tinynasL20_T.py', device='cuda', end2end=False, engine='workdirs...
              │            │         │           │       │       │              │    │               │  │    └ <function basename at 0x000001C95AD39EE0>
              │            │         │           │       │       │              │    │               │  └ <module 'ntpath' from 'C:\\Users\\chonpsk\\.conda\\envs\\DAMO-YOLO\\lib\
\ntpath.py'>
              │            │         │           │       │       │              │    │               └ <module 'os' from 'C:\\Users\\chonpsk\\.conda\\envs\\DAMO-YOLO\\lib\\os.py'
>
              │            │         │           │       │       │              │    └ 0.6
              │            │         │           │       │       │              └ Namespace(camid=0, conf=0.6, config_file='./configs/damoyolo_tinynasL20_T.py', device='cuda', en
d2end=False, engine='workdirs...
              │            │         │           │       │       └ tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,        
              │            │         │           │       │                 0., 0., 0., 0...
              │            │         │           │       └ tensor([0.6785, 0.6641, 0.6581, 0.6514, 0.6470, 0.6399, 0.5757, 0.5683, 0.5609,
              │            │         │           │                 0.5585, 0.5564, 0.5532, 0.5524, 0.521...
              │            │         │           └ tensor([[309.0302, 229.5414, 322.8981, 261.2090],
              │            │         │                     [267.1926,  28.5143, 280.6399,  46.0551],
              │            │         │                     [307.3100, 135.57...
              │            │         └ array([[[255, 255, 255],
              │            │                   [255, 255, 255],
              │            │                   [255, 255, 255],
              │            │                   ...,
              │            │                   [255, 255, 255],
              │            │                   [255...
              │            └ <function Infer.visualize at 0x000001C91010F700>
              └ <__main__.Infer object at 0x000001C95AE46550>

  File "demo.py", line 249, in visualize
    vis_img = vis(image, bboxes, scores, cls_inds, conf, self.class_names)
              │   │      │       │       │         │     │    └ ['qx']
              │   │      │       │       │         │     └ <__main__.Infer object at 0x000001C95AE46550>
              │   │      │       │       │         └ 0.6
              │   │      │       │       └ tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
              │   │      │       │                 0., 0., 0., 0...
              │   │      │       └ tensor([0.6785, 0.6641, 0.6581, 0.6514, 0.6470, 0.6399, 0.5757, 0.5683, 0.5609,
              │   │      │                 0.5585, 0.5564, 0.5532, 0.5524, 0.521...
              │   │      └ tensor([[309.0302, 229.5414, 322.8981, 261.2090],
              │   │                [267.1926,  28.5143, 280.6399,  46.0551],
              │   │                [307.3100, 135.57...
              │   └ array([[[255, 255, 255],
              │             [255, 255, 255],
              │             [255, 255, 255],
              │             ...,
              │             [255, 255, 255],
              │             [255...
              └ <function vis at 0x000001C910064DC0>

  File "E:\proj\DAMO-YOLO\damo\utils\visualize.py", line 30, in vis
    cv2.rectangle(img, (x0, y0), (x1, y1), color, 2)
    │   │         │     │   │     │   │    └ [0, 113, 188]
    │   │         │     │   │     │   └ 261
    │   │         │     │   │     └ 322
    │   │         │     │   └ 229
    │   │         │     └ 309
    │   │         └ array([[[255, 255, 255],
    │   │                   [255, 255, 255],
    │   │                   [255, 255, 255],
    │   │                   ...,
    │   │                   [255, 255, 255],
    │   │                   [255...
    │   └ <built-in function rectangle>
    └ <module 'cv2' from 'C:\\Users\\chonpsk\\.conda\\envs\\DAMO-YOLO\\lib\\site-packages\\cv2\\__init__.py'>

cv2.error: OpenCV(4.9.0) :-1: error: (-5:Bad argument) in function 'rectangle'
> Overload resolution failed:
>  - img marked as output argument, but provided NumPy array marked as readonly
>  - Expected Ptr<cv::UMat> for argument 'img'
>  - img marked as output argument, but provided NumPy array marked as readonly
>  - Expected Ptr<cv::UMat> for argument 'img'

于是进一步修改源码：

# damo/utils/visualize.py

def vis(img, boxes, scores, cls_ids, conf=0.5, class_names=None):
    # 根据报错定位到这里的img时只读的，所以把原来需要直接操作img的地方注释掉，改用拷贝数据
    img_copy = np.copy(img)
    for i in range(len(boxes)):
        box = boxes[i]
        cls_id = int(cls_ids[i])
        score = scores[i]
        if score < conf:
            continue
        x0 = int(box[0])
        y0 = int(box[1])
        x1 = int(box[2])
        y1 = int(box[3])

        color = (_COLORS[cls_id] * 255).astype(np.uint8).tolist()
        text = '{}:{:.1f}%'.format(class_names[cls_id], score * 100)
        txt_color = (0, 0, 0) if np.mean(_COLORS[cls_id]) > 0.5 else (255, 255,
                                                                      255)
        font = cv2.FONT_HERSHEY_SIMPLEX

        txt_size = cv2.getTextSize(text, font, 0.4, 1)[0]

       
        # 第一处
        cv2.rectangle(img_copy, (x0, y0), (x1, y1), color, 2)
        # cv2.rectangle(img, (x0, y0), (x1, y1), color, 2)

        txt_bk_color = (_COLORS[cls_id] * 255 * 0.7).astype(np.uint8).tolist()

        # 第二处
        # cv2.rectangle(img, (x0, y0 + 1),
        #               (x0 + txt_size[0] + 1, y0 + int(1.5 * txt_size[1])),
        #               txt_bk_color, -1)
        cv2.rectangle(img_copy, (x0, y0 + 1),
                      (x0 + txt_size[0] + 1, y0 + int(1.5 * txt_size[1])),
                      txt_bk_color, -1)
        
        # 第三处
        # cv2.putText(img,
        #             text, (x0, y0 + txt_size[1]),
        #             font,
        #             0.4,
        #             txt_color,
        #             thickness=1)
        cv2.putText(img_copy,
                    text, (x0, y0 + txt_size[1]),
                    font,
                    0.4,
                    txt_color,
                    thickness=1)
    # 最后返回处理后的拷贝数据
    # return img
    return img_copy

 运行：（和上面一样的操作，挪到根目录下）

readme里面说推理支持图像、视频和摄像头。这里使用图片。选择模型，导入对应的权重文件。设置conf为0.6（置信度大于60%才被识别，否则被抛弃）， 图片尺寸640，640（这里只接受2^n大小的图片否则报拼接错误），cuda推理加速，图片路径path

python demo.py image -f ./configs/damoyolo_tinynasL20_T.py --engine workdirs/damoyolo_tinynasL20_T/epoch_300_ckpt.pth --conf 0.6 --infer_size 640 640 --device cuda --path datasets/Custom_coco/images/val/199_crop_3.jpg

 
最后关于拼接错误的问题，我没有继续研究，暂且把报错信息放在这里。怎么会是63呢？怎么辉石呢？

2024-04-11 09:59:15.302 | ERROR    | __main__:<module>:356 - An error has been caught in function '<module>', process 'MainProcess' (12708), thread 'MainThread' (25264):
Traceback (most recent call last):

> File "demo.py", line 356, in <module>
    main()
    └ <function main at 0x00000204F6D40820>

  File "demo.py", line 320, in main
    bboxes, scores, cls_inds = infer_engine.forward(origin_img)
                               │            │       └ array([[[255, 255, 255],
                               │            │                 [255, 255, 255],
                               │            │                 [255, 255, 255],
                               │            │                 ...,
                               │            │                 [255, 255, 255],
                               │            │                 [255...
                               │            └ <function Infer.forward at 0x00000204F6D40670>
                               └ <__main__.Infer object at 0x00000204C1D46550>

  File "demo.py", line 234, in forward
    output = self.model(image)
             │    │     └ <damo.structures.image_list.ImageList object at 0x00000204F6F42DF0>
             │    └ Detector(
             │        (backbone): TinyNAS(
             │          (block_list): ModuleList(
             │            (0): Focus(
             │              (conv): ConvBNAct(
             │                (conv):...
             └ <__main__.Infer object at 0x00000204C1D46550>

  File "C:\Users\chonpsk\.conda\envs\DAMO-YOLO\lib\site-packages\torch\nn\modules\module.py", line 1511, in _wrapped_call_impl
    return self._call_impl(*args, **kwargs)
           │    │           │       └ {}
           │    │           └ (<damo.structures.image_list.ImageList object at 0x00000204F6F42DF0>,)
           │    └ <function Module._call_impl at 0x00000204EC534EE0>
           └ Detector(
               (backbone): TinyNAS(
                 (block_list): ModuleList(
                   (0): Focus(
                     (conv): ConvBNAct(
                       (conv):...

  File "C:\Users\chonpsk\.conda\envs\DAMO-YOLO\lib\site-packages\torch\nn\modules\module.py", line 1520, in _call_impl
    return forward_call(*args, **kwargs)
           │             │       └ {}
           │             └ (<damo.structures.image_list.ImageList object at 0x00000204F6F42DF0>,)
           └ <bound method Detector.forward of Detector(
               (backbone): TinyNAS(
                 (block_list): ModuleList(
                   (0): Focus(
                     (c...

  File "E:\proj\lineCheck\DAMO-YOLO\damo\detectors\detector.py", line 56, in forward
    fpn_outs = self.neck(feature_outs)
               │         └ [tensor([[[[0.3254, 0.0000, 0.1727,  ..., 0.1379, 0.0000, 2.4748],
               │                     [0.7851, 0.0000, 0.0000,  ..., 0.0000, 0.0000, 2...
               └ Detector(
                   (backbone): TinyNAS(
                     (block_list): ModuleList(
                       (0): Focus(
                         (conv): ConvBNAct(
                           (conv):...

  File "C:\Users\chonpsk\.conda\envs\DAMO-YOLO\lib\site-packages\torch\nn\modules\module.py", line 1511, in _wrapped_call_impl
    return self._call_impl(*args, **kwargs)
           │    │           │       └ {}
           │    │           └ ([tensor([[[[0.3254, 0.0000, 0.1727,  ..., 0.1379, 0.0000, 2.4748],
           │    │                       [0.7851, 0.0000, 0.0000,  ..., 0.0000, 0.0000, ...
           │    └ <function Module._call_impl at 0x00000204EC534EE0>
           └ GiraffeNeckV2(
               (upsample): Upsample(scale_factor=2.0, mode='nearest')
               (bu_conv13): ConvBNAct(
                 (conv): Conv2d(192, 192...

  File "C:\Users\chonpsk\.conda\envs\DAMO-YOLO\lib\site-packages\torch\nn\modules\module.py", line 1520, in _call_impl
    return forward_call(*args, **kwargs)
           │             │       └ {}
           │             └ ([tensor([[[[0.3254, 0.0000, 0.1727,  ..., 0.1379, 0.0000, 2.4748],
           │                         [0.7851, 0.0000, 0.0000,  ..., 0.0000, 0.0000, ...
           └ <bound method GiraffeNeckV2.forward of GiraffeNeckV2(
               (upsample): Upsample(scale_factor=2.0, mode='nearest')
               (bu_conv13):...

  File "E:\proj\lineCheck\DAMO-YOLO\damo\base_models\necks\giraffe_fpn_btn.py", line 113, in forward
    x5 = torch.cat([x2, x45], 1)
         │     │    │   └ tensor([[[[1.4854, 1.4854, 1.4719,  ..., 0.6666, 0.1078, 0.1078],
         │     │    │               [1.4854, 1.4854, 1.4719,  ..., 0.6666, 0.1078, 0....
         │     │    └ tensor([[[[0.3254, 0.0000, 0.1727,  ..., 0.1379, 0.0000, 2.4748],
         │     │                [0.7851, 0.0000, 0.0000,  ..., 0.0000, 0.0000, 2....
         │     └ <built-in method cat of type object at 0x00007FFAACDD2D50>
         └ <module 'torch' from 'C:\\Users\\chonpsk\\.conda\\envs\\DAMO-YOLO\\lib\\site-packages\\torch\\__init__.py'>

RuntimeError: Sizes of tensors must match except in dimension 1. Expected size 63 but got size 64 for tensor number 1 in the list.

chonpsk
关注
  • 6
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
openvino2022部署最新版yolov5v6.1模型demo
07-06
openvino2022部署最新版yolov5v6.1模型demo openvino 2022.1.0 openvino-dev 2022.1.0 openvino-telemetry 2022.1.1 torch 1.8.1 torchvision 0.9.1
YOLO系列的综述文章分享
10-23
自YOLOv1发布以来，该框架经历了多次迭代和优化，发展出了如YOLOv2、YOLOv3、YOLOv4、PP-YOLO、YOLOX、YOLOR、DAMO-YOLO以及结合Transformer的YOLO变体。 1. YOLO基础与架构 YOLO的核心理念在于将目标检测视为一个...
阿里达摩院开源DAMO-YOLO：超越了一众YOLO系列方法
datayx的文章
12-19 761
向AI转型的程序员都关注了这个号????????????1.简介DAMO-YOLO是一个兼顾速度与精度的目标检测框架，其效果超越了目前的一众YOLO系列方法，在实现SOTA的同时，保持了很高的推理速度。DAMO-YOLO是在YOLO框架基础上引入了一系列新技术，对整个检测框架进行了大幅的修改。具体包括：基于NAS搜索的新检测backbone结构，更深的neck结构，精简的head结构，以及引入蒸馏技术实现效果的进一...
阿里达摩院开源DAMO-YOLO：兼顾速度与精度的新目标检测框架
weixin_40920183的博客
11-29 1121
作者丨陈威华 阿里达摩院智能计算实验室编辑丨极市平台1.简介DAMO-YOLO是一个兼顾速度与精度的目标检测框架，其效果超越了目前的一众YOLO系列方法，在实现SOTA的同时，保持了很高的推理速度。DAMO-YOLO是在YOLO框架基础上引入了一系列新技术，对整个检测框架进行了大幅的修改。具体包括：基于NAS搜索的新检测backbone结构，更深的neck结构，精简的head结构，以及引入蒸馏技术...
【论文精读】DAMO-YOLO：兼顾速度与精度的高效目标检测框架（ A Report on Real-Time Object Detection Design）
慕溪同学的博客
03-28 2026
DAMO-YOLO是阿里巴巴达摩院在2022年提出的一种模型，这里建议大家可以直接看4.3部分的特征网络融合部分，该网络是在GFPN特征网络上进行改进的，因为GFPN有很多上采样操作并且并行化比较低，导致了Flops高效Latency低效；因为我使用该方法去替换了yolov5中Neck部分的PANet融合方法，确实有所涨点
Talk预告 | 阿里巴巴达摩院算法工程师许贤哲：DAMO-YOLO：兼顾速度与精度的高效目标检测框架
TechBeat人工智能社区博客
12-14 595
北京时间12月15日(周四) 20:00，准时开播！
DAMO-YOLO训练自己的数据集，使用onnxruntime推理部署
weixin_45921929的博客
09-10 857
DAMO-YOLO训练自己的数据集，使用onnxruntime推理部署
阿里达摩院开源DAMO-YOLO
qq_34717531的博客
11-14 254
DAMO-YOLO是一个兼顾速度与精度的目标检测框架，其效果超越了目前的一众YOLO系列方法，在实现SOTA的同时，保持了很高的推理速度。DAMO-YOLO是在YOLO框架基础上引入了一系列新技术，对整个检测框架进行了大幅的修改。具体包括：基于NAS搜索的新检测backbone结构，更深的neck结构，精简的head结构，以及引入蒸馏技术实现效果的进一步提升。模型之外，DAMO-YOLO还提供高效的训练策略以及便捷易用的部署工具，能够快速解决工业落地中的实际问题！
DAMO-YOLO | 超越所有YOLO，5行代码即可体验
limingmin2020的博客
11-29 4902
DAMO-YOLO是阿里新推出来的目标检测框架，兼顾模型速度与精度，其效果超越了目前的一众 YOLO 系列方法，且推理速度更快。
ONNXRuntime部署DAMO-YOLO目标检测.zip
02-08
标题中的"ONNXRuntime部署DAMO-YOLO目标检测"揭示了本次讨论的核心内容，即使用ONNXRuntime来运行DAMO-YOLO模型进行目标检测。ONNXRuntime是一个高性能的推理引擎，用于多种机器学习框架的模型，如TensorFlow、...
ONNXRuntime部署DAMO-YOLO目标检测包含C++和Python源码+模型+说明.zip
最新发布
05-02
这个资源包"ONNXRuntime部署DAMO-YOLO目标检测包含C++和Python源码+模型+说明.zip"提供了在ONNXRuntime上运行DAMO-YOLO（达摩院YOLO）目标检测模型的详细步骤，包括C++和Python两种编程语言的实现。DAMO-YOLO是阿里...
gpibvc.rar_Agilent8960_GPIB-Damo_cmu200_gpib-32_ni-488.2
07-14
"gpibvc.rar_Agilent8960_GPIB-Damo_cmu200_gpib-32_ni-488.2"这个压缩包文件名揭示了与GPIB相关的几个关键元素。 1. **Agilent 8960**：这是一款功能强大的射频通信测试系统，常用于无线通信设备的性能验证。通过...
GPIB-0.1.tar.gz_GPIB_GPIB-Damo.rar_ieee488_仪器 GPIB_仪器接口
07-15
在本压缩包中，"GPIB-0.1.tar.gz" 和 "GPIB_GPIB-Damo.rar" 提供了GPIB接口驱动程序的代码，适用于对仪器设备进行通信和控制。 GPIB接口允许最多15台设备在一个总线上互相通信，通常包括示波器、函数发生器、数字...
GPIB.rar_GPIB_GPIB-Damo.rar_gpib labview_labview gp_labview g
07-14
在本压缩包中，"GPIB.rar" 和 "GPIB_Damo.rar" 可能包含了GPIB通信相关的软件或驱动程序，而 "gpib labview_labview gp_labview g" 这些标签则表明了这些资源与LabVIEW编程环境以及LabVIEW中的GPIB模块有关。...
yolo_reid_retinaface
04-16
标题 "yolo_reid_retinaface" 暗示了一个集成解决方案，结合了 YOLO (You Only Look Once) 目标检测算法、ReID (Person Re-Identification) 技术以及 RetinaFace 人脸检测模型。这个项目可能是为了毕业设计而创建的...
DAMO-YOLO：一种平衡速度和准确性的新目标检测框架
weixin_42010722的博客
06-26 2045
DAMO-YOLO是一种考虑了速度和准确性的目标检测框架，其效果超越了当前的YOLO系列方法，并在保持高推理速度的同时实现了SOTA。DAMO-YOLO在YOLO框架的基础上引入了一系列新技术，并对整个检测框架进行了重要修改。具体来说，它包括基于NAS搜索的新的检测主干结构，更深的中间结构，简化的头部结构，以及引入蒸馏技术以进一步改善效果。除了模型之外，DAMO-YOLO还提供了高效的训练策略和方便易用的部署工具，帮助您快速解决工业领域的实际问题！
YOLO家族再度升级——阿里达摩院DAMO-YOLO重磅来袭
Together_CZ的博客
11-30 1422
YOLO家族再度升级——阿里达摩院DAMO-YOLO重磅来袭
DAMO-YOLO 论文学习
calvinpaean的博客
07-25 466
工业界追求高性能、低延迟的目标检测算法，研究人员于是聚焦于单阶段目标检测，探索高效的网络结构和训练策略。YOLOv5/v6/v7、YOLOX 和 PP-YOLOE 在 COCO 数据集上实现了不错的精度-速度平衡，得到广泛应用，但它们仍有提升空间。
yolov7添加damo-yolo GFPN
08-28
您好！对于将Damo-YOLO GFPN集成到YOLOv7中，您可以按照以下步骤操作： 1. 下载Damo-YOLO GFPN的代码和权重文件。 2. 将Damo-YOLO GFPN的代码文件复制到YOLOv7的代码目录中。 3. 在YOLOv7的模型定义文件中（通常是yolov7.py），将Damo-YOLO GFPN的网络结构部分添加到YOLOv7模型中。确保将相应的层和连接正确添加。 4. 加载Damo-YOLO GFPN的权重文件，以便在YOLOv7模型中使用。 5. 进行训练和测试前的配置，例如设置超参数、数据集路径等。 6. 开始训练和测试YOLOv7模型。 请注意，具体实施步骤可能因您使用的库和框架而有所不同，我提供的是一般流程。确保您在添加新功能时参考相关文档，并根据需要进行必要的调整。 希望这些信息对您有所帮助！如果您有更多问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值