【目标检测】swin-transformer的模型推理

最新推荐文章于 2024-10-28 00:31:10 发布
最新推荐文章于 2024-10-28 00:31:10 发布
阅读量1.1k 收藏 4
点赞数 1
文章标签： 深度学习 目标检测 pytorch transformer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44747572/article/details/127604916
版权

文章目录

1. 源代码

https://github.com/SwinTransformer/Swin-Transformer-Object-Detection

2. 相关文件

在这里插入图片描述

3. 代码

3.1 infer

from mmdet.apis import init_detector, inference_detector, show_result_pyplot
# import mmcv
import numpy as np
import cv2
import random


def InferResult(img, config_file, checkpoint_file, classes, model):
	result = inference_detector(model, img)

	if isinstance(result, tuple):
		bbox_result, segm_result = result
		if isinstance(segm_result, tuple):
			segm_result = segm_result[0]  # ms rcnn
	else:
		bbox_result, segm_result = result, None

	bboxes = np.vstack(bbox_result)
	labels = [
		np.full(bbox.shape[0], i, dtype=np.int32)
		for i, bbox in enumerate(bbox_result)
	]
	labels = np.concatenate(labels)

	assert bboxes.shape[1] == 5
	scores = bboxes[:, -1]
	inds = scores > 0.3
	bboxes = bboxes[inds, :]
	labels = labels[inds]
	# print(bboxes[:, :4])
	# print(bboxes[:, -1:])
	img, result_label = draw(img, bboxes, classes, labels)
	return img, result_label

def plot_one_box(x, img, label=None, color=None, line_thickness=None):
	# Plots one bounding box on image img
	tl = line_thickness or round(0.002 * (img.shape[0] + img.shape[1]) / 2) + 1  # line/font thickness
	color = color or [random.randint(0, 255) for _ in range(3)]
	c1, c2 = (int(x[0]), int(x[1])), (int(x[2]), int(x[3]))
	cv2.rectangle(img, c1, c2, color, thickness=tl, lineType=cv2.LINE_AA)
	if label:
		tf = max(tl - 1, 1)  # font thickness
		t_size = cv2.getTextSize(label, 0, fontScale=tl / 3, thickness=tf)[0]
		c2 = c1[0] + t_size[0], c1[1] - t_size[1] - 3
		cv2.rectangle(img, c1, c2, color, -1, cv2.LINE_AA)  # filled
		cv2.putText(img, label, (c1[0], c1[1] - 2), 0, tl / 3, [225, 255, 255], thickness=tf, lineType=cv2.LINE_AA)

# show the results
def draw(img, bboxes, classes, labels):
	img = cv2.imread(img)
	colors = [[random.randint(0, 255) for _ in range(3)] for _ in range(len(classes))]
	result_label = []
	for i in range(bboxes.shape[0]):
		xyxy = bboxes[i, :4]
		conf = bboxes[i, -1:]
		label = '%s %.2f' % (classes[labels[i]], conf)
		label = '%s' % (classes[labels[i]])
		result_label.append(label)
		plot_one_box(xyxy, img, label=label, color=colors[0], line_thickness=1)
	result_label = list(set(result_label))
	cv2.imshow('test', img)
	cv2.waitKey()
	return img, result_label

if __name__ == '__main__':
	img = '2.jpg'
	# img = cv2.imread('./2.jpg')
	config_file = 'mask_rcnn_swin_tiny_patch4_window7_mstrain_480-800_adamw_1x_coco.py'
	checkpoint_file = 'epoch_100.pth'
	classes = ['The color of silica gel is abnormal', 'The color of silica gel is normal', 'The door is open', 'The door is close', 'breakage', 'dirt', 'rust', 'foreign object', 'oil leakage', 'animal', 'hat', 'person']
	model = init_detector(config_file, checkpoint_file, device='cuda:0')
	img, result_label = InferResult(img, config_file, checkpoint_file, classes, model)

3.2 mask_rcnn_swin_tiny_patch4_window7_mstrain_480-800_adamw_1x_coco

model = dict(
    type='MaskRCNN',
    pretrained=None,
    backbone=dict(
        type='SwinTransformer',
        embed_dim=96,
        depths=[2, 2, 6, 2],
        num_heads=[3, 6, 12, 24],
        window_size=7,
        mlp_ratio=4.0,
        qkv_bias=True,
        qk_scale=None,
        drop_rate=0.0,
        attn_drop_rate=0.0,
        drop_path_rate=0.1,
        ape=False,
        patch_norm=True,
        out_indices=(0, 1, 2, 3),
        use_checkpoint=False),
    neck=dict(
        type='FPN',
        in_channels=[96, 192, 384, 768],
        out_channels=256,
        num_outs=5),
    rpn_head=dict(
        type='RPNHead',
        in_channels=256,
        feat_channels=256,
        anchor_generator=dict(
            type='AnchorGenerator',
            scales=[8],
            ratios=[0.5, 1.0, 2.0],
            strides=[4, 8, 16, 32, 64]),
        bbox_coder=dict(
            type='DeltaXYWHBBoxCoder',
            target_means=[0.0, 0.0, 0.0, 0.0],
            target_stds=[1.0, 1.0, 1.0, 1.0]),
        loss_cls=dict(
            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
        loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
    roi_head=dict(
        type='StandardRoIHead',
        bbox_roi_extractor=dict(
            type='SingleRoIExtractor',
            roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0),
            out_channels=256,
            featmap_strides=[4, 8, 16, 32]),
        bbox_head=dict(
            type='Shared2FCBBoxHead',
            in_channels=256,
            fc_out_channels=1024,
            roi_feat_size=7,
            num_classes=12,
            bbox_coder=dict(
                type='DeltaXYWHBBoxCoder',
                target_means=[0.0, 0.0, 0.0, 0.0],
                target_stds=[0.1, 0.1, 0.2, 0.2]),
            reg_class_agnostic=False,
            loss_cls=dict(
                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
            loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
        mask_roi_extractor=dict(
            type='SingleRoIExtractor',
            roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0),
            out_channels=256,
            featmap_strides=[4, 8, 16, 32]),
        mask_head=dict(
            type='FCNMaskHead',
            num_convs=4,
            in_channels=256,
            conv_out_channels=256,
            num_classes=12,
            loss_mask=dict(
                type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))),
    train_cfg=dict(
        rpn=dict(
            assigner=dict(
                type='MaxIoUAssigner',
                pos_iou_thr=0.7,
                neg_iou_thr=0.3,
                min_pos_iou=0.3,
                match_low_quality=True,
                ignore_iof_thr=-1),
            sampler=dict(
                type='RandomSampler',
                num=256,
                pos_fraction=0.5,
                neg_pos_ub=-1,
                add_gt_as_proposals=False),
            allowed_border=-1,
            pos_weight=-1,
            debug=False),
        rpn_proposal=dict(
            nms_pre=2000,
            max_per_img=1000,
            nms=dict(type='nms', iou_threshold=0.7),
            min_bbox_size=0),
        rcnn=dict(
            assigner=dict(
                type='MaxIoUAssigner',
                pos_iou_thr=0.5,
                neg_iou_thr=0.5,
                min_pos_iou=0.5,
                match_low_quality=True,
                ignore_iof_thr=-1),
            sampler=dict(
                type='RandomSampler',
                num=512,
                pos_fraction=0.25,
                neg_pos_ub=-1,
                add_gt_as_proposals=True),
            mask_size=28,
            pos_weight=-1,
            debug=False)),
    test_cfg=dict(
        rpn=dict(
            nms_pre=1000,
            max_per_img=1000,
            nms=dict(type='nms', iou_threshold=0.7),
            min_bbox_size=0),
        rcnn=dict(
            score_thr=0.05,
            nms=dict(type='nms', iou_threshold=0.5),
            max_per_img=100,
            mask_thr_binary=0.5)))
dataset_type = 'CocoDataset'
data_root = 'data/coco/'
img_norm_cfg = dict(
    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
train_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
    dict(type='RandomFlip', flip_ratio=0.5),
    dict(
        type='AutoAugment',
        policies=[[{
            'type':
            'Resize',
            'img_scale': [(480, 1333), (512, 1333), (544, 1333), (576, 1333),
                          (608, 1333), (640, 1333), (672, 1333), (704, 1333),
                          (736, 1333), (768, 1333), (800, 1333)],
            'multiscale_mode':
            'value',
            'keep_ratio':
            True
        }],
                  [{
                      'type': 'Resize',
                      'img_scale': [(400, 1333), (500, 1333), (600, 1333)],
                      'multiscale_mode': 'value',
                      'keep_ratio': True
                  }, {
                      'type': 'RandomCrop',
                      'crop_type': 'absolute_range',
                      'crop_size': (384, 600),
                      'allow_negative_crop': True
                  }, {
                      'type':
                      'Resize',
                      'img_scale': [(480, 1333), (512, 1333), (544, 1333),
                                    (576, 1333), (608, 1333), (640, 1333),
                                    (672, 1333), (704, 1333), (736, 1333),
                                    (768, 1333), (800, 1333)],
                      'multiscale_mode':
                      'value',
                      'override':
                      True,
                      'keep_ratio':
                      True
                  }]]),
    dict(
        type='Normalize',
        mean=[123.675, 116.28, 103.53],
        std=[58.395, 57.12, 57.375],
        to_rgb=True),
    dict(type='Pad', size_divisor=32),
    dict(type='DefaultFormatBundle'),
    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels', 'gt_masks'])
]
test_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(
        type='MultiScaleFlipAug',
        img_scale=(1333, 800),
        flip=False,
        transforms=[
            dict(type='Resize', keep_ratio=True),
            dict(type='RandomFlip'),
            dict(
                type='Normalize',
                mean=[123.675, 116.28, 103.53],
                std=[58.395, 57.12, 57.375],
                to_rgb=True),
            dict(type='Pad', size_divisor=32),
            dict(type='ImageToTensor', keys=['img']),
            dict(type='Collect', keys=['img'])
        ])
]
data = dict(
    samples_per_gpu=3,
    workers_per_gpu=0,
    train=dict(
        type='CocoDataset',
        ann_file='data/coco/annotations/instances_train2017.json',
        img_prefix='data/coco/train2017/',
        pipeline=[
            dict(type='LoadImageFromFile'),
            dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
            dict(type='RandomFlip', flip_ratio=0.5),
            dict(
                type='AutoAugment',
                policies=[[{
                    'type':
                    'Resize',
                    'img_scale': [(480, 1333), (512, 1333), (544, 1333),
                                  (576, 1333), (608, 1333), (640, 1333),
                                  (672, 1333), (704, 1333), (736, 1333),
                                  (768, 1333), (800, 1333)],
                    'multiscale_mode':
                    'value',
                    'keep_ratio':
                    True
                }],
                          [{
                              'type': 'Resize',
                              'img_scale': [(400, 1333), (500, 1333),
                                            (600, 1333)],
                              'multiscale_mode': 'value',
                              'keep_ratio': True
                          }, {
                              'type': 'RandomCrop',
                              'crop_type': 'absolute_range',
                              'crop_size': (384, 600),
                              'allow_negative_crop': True
                          }, {
                              'type':
                              'Resize',
                              'img_scale': [(480, 1333), (512, 1333),
                                            (544, 1333), (576, 1333),
                                            (608, 1333), (640, 1333),
                                            (672, 1333), (704, 1333),
                                            (736, 1333), (768, 1333),
                                            (800, 1333)],
                              'multiscale_mode':
                              'value',
                              'override':
                              True,
                              'keep_ratio':
                              True
                          }]]),
            dict(
                type='Normalize',
                mean=[123.675, 116.28, 103.53],
                std=[58.395, 57.12, 57.375],
                to_rgb=True),
            dict(type='Pad', size_divisor=32),
            dict(type='DefaultFormatBundle'),
            dict(
                type='Collect',
                keys=['img', 'gt_bboxes', 'gt_labels', 'gt_masks'])
        ]),
    val=dict(
        type='CocoDataset',
        ann_file='data/coco/annotations/instances_val2017.json',
        img_prefix='data/coco/val2017/',
        pipeline=[
            dict(type='LoadImageFromFile'),
            dict(
                type='MultiScaleFlipAug',
                img_scale=(1333, 800),
                flip=False,
                transforms=[
                    dict(type='Resize', keep_ratio=True),
                    dict(type='RandomFlip'),
                    dict(
                        type='Normalize',
                        mean=[123.675, 116.28, 103.53],
                        std=[58.395, 57.12, 57.375],
                        to_rgb=True),
                    dict(type='Pad', size_divisor=32),
                    dict(type='ImageToTensor', keys=['img']),
                    dict(type='Collect', keys=['img'])
                ])
        ]),
    test=dict(
        type='CocoDataset',
        ann_file='data/coco/annotations/instances_test2017.json',
        img_prefix='data/coco/val2017/',
        pipeline=[
            dict(type='LoadImageFromFile'),
            dict(
                type='MultiScaleFlipAug',
                img_scale=(1333, 800),
                flip=False,
                transforms=[
                    dict(type='Resize', keep_ratio=True),
                    dict(type='RandomFlip'),
                    dict(
                        type='Normalize',
                        mean=[123.675, 116.28, 103.53],
                        std=[58.395, 57.12, 57.375],
                        to_rgb=True),
                    dict(type='Pad', size_divisor=32),
                    dict(type='DefaultFormatBundle'),
                    dict(type='Collect', keys=['img'])
                ])
        ]))
evaluation = dict(interval=1, metric='bbox')
optimizer = dict(
    type='AdamW',
    lr=0.0001,
    betas=(0.9, 0.999),
    weight_decay=0.05,
    paramwise_cfg=dict(
        custom_keys=dict(
            absolute_pos_embed=dict(decay_mult=0.0),
            relative_position_bias_table=dict(decay_mult=0.0),
            norm=dict(decay_mult=0.0))))
optimizer_config = dict(
    grad_clip=None,
    type='DistOptimizerHook',
    update_interval=1,
    coalesce=True,
    bucket_size_mb=-1,
    use_fp16=True)
lr_config = dict(
    policy='step',
    warmup='linear',
    warmup_iters=500,
    warmup_ratio=0.001,
    step=[8, 11])
runner = dict(type='EpochBasedRunnerAmp', max_epochs=100)
checkpoint_config = dict(interval=2)
log_config = dict(interval=10, hooks=[dict(type='TextLoggerHook')])
custom_hooks = [dict(type='NumClassCheckHook')]
dist_params = dict(backend='nccl')
log_level = 'INFO'
load_from = 'mask_rcnn_swin_12.pth'
resume_from = None
workflow = [('train', 1)]
fp16 = None
work_dir = './work_dirs\mask_rcnn_swin_tiny_patch4_window7_mstrain_480-800_adamw_1x_coco'
gpu_ids = range(0, 1)
模型推理:Swin-Transformer图像分类
shengyin714959的博客
07-24 341
硬件：寒武纪 MLU370 AI 加速卡框架：Pytorch 1.6 、MagicMind 0.14.0系统环境：寒武纪云平台MagicMind除了提供大量的内置算子（如conv、pool等），还提供自定义算子开发功能，来满足用户的业务需求和性能需求。当MagicMind Parser 解析原生 PyTorch 模型某个算子失败时，可编写自定义PluginOp，替换 PyTorch 原生网络中对应算子，以使模型能被 MagicMind Parser 正常解析。
37、记录使用 Swin Transformer主干网络去实现分类，并转化NCNN、TNN、MNN模型以及部署
sxj731533730
01-20 8932
基本思想:最近手中有个swim transformer模型，想移植手机端进行推理一下，随手记录一下遇到的问题 一、首先我fork了大佬的代码，查阅主代码结构是华为分类垃圾的源码,然后作者参考了swin_transformer的架构做了修改，修改参考来自Swin-Transformer/swin_transformer.py at 5d2aede42b4b12cb0e7a2448b58820aeda604426 · microsoft/Swin-Transformer · GitHub （1）首先将模..
详解Swin Transformer核心实现
hellozhxy的博客
10-19 1512
最后，将图像补回原来的大小，这一步是方便代码的编写，并且对窗口中原本不相邻的区域不做注意力运算。注意，窗口是由黑框决定的。通过这两步，美妙的事情发生了，我们首先在第一步建立了[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]各自窗口之间的联系，然后在第二步建立了[4,7,10,13]之间的联系。首先，我们对每个颜色内的窗口进行自注意力运算，如[1,2,3,4]，[5,6,7,8]，[9,10,11,12]，[13,14,15,16]每个列表内的元素做自注意力运算。
2021：Swin Transformer: Hierarchical Vision Transformer using Shifted Windows
weixin_42653320的博客
03-07 3355
摘要 本文提出一种新的视觉Transformer----Swin Transformer，它可以成为计算机视觉的通用主干。从语言到视觉采用Transformer的挑战来自于这两个领域之间的差异，比如视觉实体的规模变化很大，以及图像中像素比文本中单词的高分辨率。为解决这些差异，我们提出了一个分层Transformer，其表示是由移动窗口计算的。移动的窗口方案将自注意力计算限制在非重叠的局部窗口上，同时允许跨窗口连接，从而提高了效率。这种层次结构具有在不同尺度上建模的灵活性，并且对图像大小具有...
【CV学习笔记】transformer-tensorrt加速
Rex大居
05-01 3970
1、前言 transformer在逐渐在cv领域有更多的应用，于是准备利用tensorrt对VIT、SWIN、DETR进行加速，基本做法是现将torch的模型转成ONNX，然后再将ONNX模型转化为engine，其中SWIN在onnx转engine时出现问题，VIT、DETR均未发现问题，其中tensorrt加速以及transformer原理可参考如下两个repo 手写AI:https://github.com/shouxieai/tensorRT_Pro 霹雳吧啦Wz:https://github.com
Swin-T-使用Pytorch实现Swin-Transformer目标检测算法-优质项目实战.zip
10-21
本项目利用Pytorch框架实现了Swin-T模型，并将其应用于目标检测任务中，称之为Swin-Transformer目标检测算法。Pytorch是一个流行的深度学习框架，因其易于使用和灵活的设计而受到广泛欢迎。通过使用Pytorch，研究...
Swin-Transformer模型和参数
qq_43275608的博客
10-28 1195
Swin Transformer（Swin 的意思是 Shifted window）最初在 arxiv 中描述，能够作为计算机视觉的通用骨干。它基本上是一个分层 Transformer，其表示通过位移窗口计算。位移窗口方案通过将自注意力计算限制在不重叠的局部窗口中，同时允许跨窗口连接，从而提高了效率。
Swin-Transformer 图像分类网络实战项目：MIT-BIH心电图像分类数据集迁移学习项目
03-05
基于Swin-Transformer网络对MIT-BIH心电图像分类数据集迁移学习项目，包含代码、数据集和训练好的权重文件，可直接运行。 这里不是数据的全部，原数据转换后的图像有9W张，这里只使用了一小部分子集来训练 项目总...
Swin-Transformer（code and 论文）.zip
12-29
Transformer以其自注意力机制在自然语言处理(NLP)中取得了巨大成功，Swin-Transformer则是将这种机制应用于图像处理，创建了一个层次化的、窗口化的Transformer模型。 论文“Swin Transformer: Hierarchical Vision...
字符识别-基于Swin-Transformer实现的OCR字符识别算法-附项目源码-优质项目实战.zip
10-20
项目的核心是利用Swin-Transformer模型来构建一个端到端的光学字符识别（OCR）系统。相较于传统的基于规则或简单机器学习的OCR系统，基于深度学习的OCR系统能够自动从大量数据中学习到更复杂的特征表示，从而提高...
Swin-Transformer图像分类
weixin_45977690的博客
09-13 4632
本机为Ubuntu系统，为了训练自己的数据集，在原代码的基础上做了一点小调整： 原代码中每个epoch保存一个模型，调整为只保存表现最佳的模型和最后一个epoch的模型；原代码训练的ImageNet数据集，数据类别比较多，输出了两个评估指标：Top-1 Acc和Top-5 Acc，但我自己数据集只有3个类别，调整为输出Top-1 Acc和Top-2 Acc；原代码没有推理脚本，简单补充了一个
Pytorch版本Swin-Transformer目标检测训练自己的数据集
weixin_45977690的博客
09-30 8801
linux系统的Swin-Transformer纯目标检测
2024年最新Swin Transformer实战：使用 Swin Transformer实现图像分类。
2301_82243883的博客
05-02 2281
CUDA版本：11.22、创建虚拟环境swin。
win11下Swin-Transformer-Object-Detection-master测试成功
impact_10的博客
05-05 1419
仅作为个人学习记录使用，侵权直接删除！！！ 转自这里（侵权删） 前期准备 PyCharm 2021.3（只是IDE，版本不同也没关系） 显卡 3060 12G Cuda 11.1 （与显卡、Pytorch要求合适即可） Python 3.8 Anaconda3 2021.05（版本无限制） VS2019 环境安装 VS 2019 建议安装2019版本 VS 2019 安装 VS 2019下载地址 直接去VS官网下载，第一步下载的时候可能需要翻墙，后面下载的时候不用翻墙，安装时只勾选桌面端的C++部分就可
【目标检测/实例分割】Mask R-CNN简介与Swin Transformer实践测试
兴趣使然的创作者
09-23 5715
Mask R-CNN是何凯明大神继Faster-RCNN后的又一力作，在的基础上，集成了物体检测和实例分割两大功能。
Swin-Transformer中MSA和W-MSA模块计算复杂度推导（非常详细，最新）
热门推荐
qq_45588019的博客
01-20 1万+
在Swin-Transformer一文中，MSA与W-MSA两个公式的计算复杂度分析
Swin Transformer Object Detection 目标检测-1——环境搭建详细教程
Beyonderwei的博客
03-22 1万+
文章目录一、所需软件（包）介绍二、环境安装0. 版本选择1. VS 2019 安装2. 创建conda 虚拟环境方案一（直接创建）方案二（指定目录创建）3. pytorch 安装4. 安装其他必要的Python包5. 安装mmcv6. 安装mmdetection7. 安装 apex8. 拉取代码9. 测试工程10. 常见问题 视频教程完整版：我在B站录的教学视频     一、所需软件（包）介绍 VS 2017-2019 ，用里面的一个编译软件去编译文件，用于安装mmcv，因为
Swin Transformer 代码学习笔记(目标检测)
athrunsunny的博客
05-23 1万+
为了方便将img_scale设置为[(224,224)]，此时的数据集中的图片会进行resize，并且将短边padding成32的倍数，按最长边与224的比例缩放最短边，即 x=短边 / (500/224)，x即为缩放后的实际长度，比如输入时500*287（w*h）的图片，缩放后的短边长为287 * 224 / 500 = 129，由于输入的图像尺寸需要是32的倍数，此时需要向上取整，所以padding后的短边长为160。接下来把这部分代码拆分出来解读。主体位于SwinTransformer类中。
深度学习之目标检测（Swin Transformer for Object Detection）
qq_41627642的博客
05-06 7721
1、MMdetection系列版本 2、 MMDetection和MMCV兼容版本 MMDetection version MMCV version master mmcv-full>=1.3.17, <1.6.0 2.24.1 mmcv-full>=1.3.17, <1.6.0 2.24.0 mmcv-full>=1.3.17, <1.6.0 2.23.0 mmcv-full>=1.3.17, <1.5.
Swin-transformer目标检测推理
最新发布
03-22
### 使用 Swin Transformer 进行目标检测的推理实现 为了使用 Swin Transformer 进行目标检测的推理，可以按照以下方式构建流程。以下是基于官方文档和社区实践总结的方法。 #### 1. 安装依赖环境 在开始之前，确保已安装所需的 Python 库以及 PyTorch 和 torchvision 的正确版本。如果遇到安装问题，可参考相关资源[^5]来下载适合 CUDA 版本的预编译包并验证其功能。 ```bash pip install torch==1.8.0+cu111 torchvision==0.9.0+cu111 torchaudio===0.8.0 -f https://download.pytorch.org/whl/torch_stable.html ``` #### 2. 下载模型权重文件 对于 Swin Transformer 结合 Mask R-CNN 架构的目标检测任务，需先获取训练好的模型权重文件。可以通过如下命令下载： ```bash wget https://download.openmmlab.com/mmdetection/v2.0/swin/mask_rcnn_swin-t-p4-w7_fpn_1x_coco/mask_rcnn_swin-t-p4-w7_fpn_1x_coco_20210902_120937-9d6b7cfa.pth ``` 此链接提供了 COCO 数据集上预训练的 Swin-Tiny 模型权重[^4]。 #### 3. 配置解析器参数 通过 `argparse` 设置脚本运行所需的基础配置项。例如，在测试阶段可能需要指定输入图像路径、输出目录以及其他超参设置。 ```python import argparse def parse_args(): parser = argparse.ArgumentParser('Swin Transformer Test Script', add_help=False) parser.add_argument('--config-file', type=str, default="configs/swin_t_mask_rcnn.py", help='path to config file') parser.add_argument('--input-image', type=str, required=True, help='path to input image') parser.add_argument('--output-dir', type=str, default="./outputs/", help='directory to save results') return parser.parse_args() ``` 上述代码片段展示了如何定义一个简单的命令行接口用于接收外部传入的关键字参数[^2]。 #### 4. 加载模型与前向传播 加载预训练模型并对单张图片执行预测操作。这里假设已经准备好了一个 MMDetection 格式的配置文件 (`swin_t_mask_rcnn.py`) 来描述网络结构及其初始化细节。 ```python from mmdet.apis import init_detector, inference_detector import mmcv # 初始化探测器实例 args = parse_args() model = init_detector(args.config_file, checkpoint='mask_rcnn_swin-t-p4-w7_fpn_1x_coco_20210902_120937-9d6b7cfa.pth') # 对给定图像进行推断 image_path = args.input_image result = inference_detector(model, image_path) # 可视化结果保存到磁盘 out_file = f"{args.output_dir}/detected_{mmcv.imfrombytes(mmcv.imread(image_path)).shape[:2]}_.png" model.show_result(image_path, result, out_file=out_file, score_thr=0.3) ``` 以上部分实现了从读取用户提供的图像数据直至完成物体识别并将标注后的效果图存储至本地的功能。 #### 5. 调整优化选项 (可选) 如果有特殊需求比如改变窗口大小或者调整特征金字塔层数，则可以根据具体应用场景修改对应的 YAML 或者 Python 配置文件中的字段值后再重新启动整个过程即可。 --- ### 注意事项 - 如果计划部署于 GPU 上加速计算速度，请确认显存容量充足且驱动程序兼容最新框架版本。 - 当处理大规模视频流时考虑采用批量模式进一步提升效率减少延迟时间开销。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

只搬烫手的砖

你的鼓励将是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值