半监督学习实战记录

最新推荐文章于 2024-05-17 18:09:22 发布
最新推荐文章于 2024-05-17 18:09:22 发布
阅读量1.1k 收藏 13
点赞数 1
文章标签： 学习 深度学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ppppre/article/details/127242680
版权

半监督学习实战记录

使用mmdetection和softTeacher

SSL(Semi-Supervised Learning)半监督学习，由于其可以合理利用大量无标注数据的属性，一直是CV研究的一个重要方向。
论文地址：https://arxiv.org/pdf/2106.09018.pdf

Github地址：https://github.com/microsoft/SoftTeacher

参考论文解析和源码解读：https://zhuanlan.zhihu.com/p/437754834

参考实战项目：https://github.com/Ruikang07/SoftTeacher_nodule_detection

准备数据

该算法是基于fasterRcnn来实现目标检测的，而SoftTeacher通过逐步迭代的学习方式，不断将当前阶段可信的伪标签加入训练。我这个项目是使用10%的标注数据来进行训练，其余进行伪标签训练，所以需要准备标注的数据和未标注的数据集。
本地数据集

配置文件

我直接参考了实战项目的配置文件，并且进行了修改，具体如下：

model = dict(
    type='SoftTeacher',
    model=dict(
        type='FasterRCNN',
        backbone=dict(
            type='ResNet',
            depth=50,
            num_stages=4,
            out_indices=(0, 1, 2, 3),
            frozen_stages=1,
            norm_cfg=dict(type='SyncBN', requires_grad=False),
            norm_eval=True,
            style='caffe',
            init_cfg=dict(
                type='Pretrained',
                checkpoint='open-mmlab://detectron2/resnet50_caffe')),
        neck=dict(
            type='FPN',
            in_channels=[256, 512, 1024, 2048],
            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=2,
                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))),
        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.5),
                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=False,
                    ignore_iof_thr=-1),
                sampler=dict(
                    type='RandomSampler',
                    num=512,
                    pos_fraction=0.25,
                    neg_pos_ub=-1,
                    add_gt_as_proposals=True),
                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))),
    train_cfg=dict(
        use_teacher_proposal=False,
        pseudo_label_initial_score_thr=0.5,
        rpn_pseudo_threshold=0.9,
        cls_pseudo_threshold=0.9,
        reg_pseudo_threshold=0.02,
        jitter_times=10,
        jitter_scale=0.06,
        min_pseduo_box_size=0,
        unsup_weight=2.0),
    test_cfg=dict(inference_on='student'))
dataset_type = 'CocoDataset'
data_root = 'data/coco/'
img_norm_cfg = dict(
    mean=[103.53, 116.28, 123.675], std=[1.0, 1.0, 1.0], to_rgb=False)
train_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(type='LoadAnnotations', with_bbox=True),
    dict(
        type='Sequential',
        transforms=[
            dict(
                type='RandResize',
                img_scale=[(1333, 400), (1333, 1200)],
                multiscale_mode='range',
                keep_ratio=True),
            dict(type='RandFlip', flip_ratio=0.5),
            dict(
                type='OneOf',
                transforms=[
                    dict(type='Identity'),
                    dict(type='AutoContrast'),
                    dict(type='RandEqualize'),
                    dict(type='RandSolarize'),
                    dict(type='RandColor'),
                    dict(type='RandContrast'),
                    dict(type='RandBrightness'),
                    dict(type='RandSharpness'),
                    dict(type='RandPosterize')
                ])
        ],
        record=True),
    dict(type='Pad', size_divisor=32),
    dict(
        type='Normalize',
        mean=[103.53, 116.28, 123.675],
        std=[1.0, 1.0, 1.0],
        to_rgb=False),
    dict(type='ExtraAttrs', tag='sup'),
    dict(type='DefaultFormatBundle'),
    dict(
        type='Collect',
        keys=['img', 'gt_bboxes', 'gt_labels'],
        meta_keys=('filename', 'ori_shape', 'img_shape', 'img_norm_cfg',
                   'pad_shape', 'scale_factor', 'tag'))
]
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=[103.53, 116.28, 123.675],
                std=[1.0, 1.0, 1.0],
                to_rgb=False),
            dict(type='Pad', size_divisor=32),
            dict(type='ImageToTensor', keys=['img']),
            dict(type='Collect', keys=['img'])
        ])
]
data = dict(
    samples_per_gpu=2,
    workers_per_gpu=2,
    train=dict(
        type='SemiDataset',
        sup=dict(
            type='CocoDataset',
            ann_file='data/coco/annotations/instances_train2017.json',
            img_prefix='data/coco/train2017/',
            classes = ('cat', 'dog'),
            pipeline=[
                dict(type='LoadImageFromFile'),
                dict(type='LoadAnnotations', with_bbox=True),
                dict(
                    type='Sequential',
                    transforms=[
                        dict(
                            type='RandResize',
                            img_scale=[(1333, 400), (1333, 1200)],
                            multiscale_mode='range',
                            keep_ratio=True),
                        dict(type='RandFlip', flip_ratio=0.5),
                        dict(
                            type='OneOf',
                            transforms=[
                                dict(type='Identity'),
                                dict(type='AutoContrast'),
                                dict(type='RandEqualize'),
                                dict(type='RandSolarize'),
                                dict(type='RandColor'),
                                dict(type='RandContrast'),
                                dict(type='RandBrightness'),
                                dict(type='RandSharpness'),
                                dict(type='RandPosterize')
                            ])
                    ],
                    record=True),
                dict(type='Pad', size_divisor=32),
                dict(
                    type='Normalize',
                    mean=[103.53, 116.28, 123.675],
                    std=[1.0, 1.0, 1.0],
                    to_rgb=False),
                dict(type='ExtraAttrs', tag='sup'),
                dict(type='DefaultFormatBundle'),
                dict(
                    type='Collect',
                    keys=['img', 'gt_bboxes', 'gt_labels'],
                    meta_keys=('filename', 'ori_shape', 'img_shape',
                               'img_norm_cfg', 'pad_shape', 'scale_factor',
                               'tag'))
            ],
            filter_empty_gt=False),
        unsup=dict(
            type='CocoDataset',
            ann_file='data/coco/annotations/instances_unlabeled2017.json',
            img_prefix='data/coco/unlabeled2017/',
            classes = ('cat', 'dog'),
            pipeline=[
                dict(type='LoadImageFromFile'),
                dict(type='PseudoSamples', with_bbox=True),
                dict(
                    type='MultiBranch',
                    unsup_student=[
                        dict(
                            type='Sequential',
                            transforms=[
                                dict(
                                    type='RandResize',
                                    img_scale=[(1333, 400), (1333, 1200)],
                                    multiscale_mode='range',
                                    keep_ratio=True),
                                dict(type='RandFlip', flip_ratio=0.5),
                                dict(
                                    type='ShuffledSequential',
                                    transforms=[
                                        dict(
                                            type='OneOf',
                                            transforms=[
                                                dict(type='Identity'),
                                                dict(type='AutoContrast'),
                                                dict(type='RandEqualize'),
                                                dict(type='RandSolarize'),
                                                dict(type='RandColor'),
                                                dict(type='RandContrast'),
                                                dict(type='RandBrightness'),
                                                dict(type='RandSharpness'),
                                                dict(type='RandPosterize')
                                            ]),
                                        dict(
                                            type='OneOf',
                                            transforms=[{
                                                'type': 'RandTranslate',
                                                'x': (-0.1, 0.1)
                                            }, {
                                                'type': 'RandTranslate',
                                                'y': (-0.1, 0.1)
                                            }, {
                                                'type': 'RandRotate',
                                                'angle': (-30, 30)
                                            },
                                                        [{
                                                            'type':
                                                            'RandShear',
                                                            'x': (-30, 30)
                                                        }, {
                                                            'type':
                                                            'RandShear',
                                                            'y': (-30, 30)
                                                        }]])
                                    ]),
                                dict(
                                    type='RandErase',
                                    n_iterations=(1, 5),
                                    size=[0, 0.2],
                                    squared=True)
                            ],
                            record=True),
                        dict(type='Pad', size_divisor=32),
                        dict(
                            type='Normalize',
                            mean=[103.53, 116.28, 123.675],
                            std=[1.0, 1.0, 1.0],
                            to_rgb=False),
                        dict(type='ExtraAttrs', tag='unsup_student'),
                        dict(type='DefaultFormatBundle'),
                        dict(
                            type='Collect',
                            keys=['img', 'gt_bboxes', 'gt_labels'],
                            meta_keys=('filename', 'ori_shape', 'img_shape',
                                       'img_norm_cfg', 'pad_shape',
                                       'scale_factor', 'tag',
                                       'transform_matrix'))
                    ],
                    unsup_teacher=[
                        dict(
                            type='Sequential',
                            transforms=[
                                dict(
                                    type='RandResize',
                                    img_scale=[(1333, 400), (1333, 1200)],
                                    multiscale_mode='range',
                                    keep_ratio=True),
                                dict(type='RandFlip', flip_ratio=0.5)
                            ],
                            record=True),
                        dict(type='Pad', size_divisor=32),
                        dict(
                            type='Normalize',
                            mean=[103.53, 116.28, 123.675],
                            std=[1.0, 1.0, 1.0],
                            to_rgb=False),
                        dict(type='ExtraAttrs', tag='unsup_teacher'),
                        dict(type='DefaultFormatBundle'),
                        dict(
                            type='Collect',
                            keys=['img', 'gt_bboxes', 'gt_labels'],
                            meta_keys=('filename', 'ori_shape', 'img_shape',
                                       'img_norm_cfg', 'pad_shape',
                                       'scale_factor', 'tag',
                                       'transform_matrix'))
                    ])
            ],
            filter_empty_gt=False)),
    val=dict(
        type='CocoDataset',
        ann_file='data/coco/annotations/instances_val2017.json',
        img_prefix='data/coco/val2017/',
        classes = ('cat', 'dog'),
        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=[103.53, 116.28, 123.675],
                        std=[1.0, 1.0, 1.0],
                        to_rgb=False),
                    dict(type='Pad', size_divisor=32),
                    dict(type='ImageToTensor', keys=['img']),
                    dict(type='Collect', keys=['img'])
                ])
        ],
        filter_empty_gt=False),
    test=dict(
        type='CocoDataset',
        ann_file='data/coco/annotations/instances_val2017.json',
        img_prefix='data/coco/val2017/',
        classes = ('cat', 'dog'),
        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=[103.53, 116.28, 123.675],
                        std=[1.0, 1.0, 1.0],
                        to_rgb=False),
                    dict(type='Pad', size_divisor=32),
                    dict(type='ImageToTensor', keys=['img']),
                    dict(type='Collect', keys=['img'])
                ])
        ]),
    sampler=dict(
        train=dict(
            type='DistributedGroupSemiBalanceSampler',
            sample_ratio=[1, 9],
            by_prob=True,
            epoch_length=2000)))
evaluation = dict(interval=10000, metric='bbox', type='SubModulesDistEvalHook')
optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
optimizer_config = dict(grad_clip=None)
lr_config = dict(
    policy='step',
    warmup='linear',
    warmup_iters=500, 
    warmup_ratio=0.001,
    step=[2000, 4000]) 
runner = dict(type='IterBasedRunner', max_iters=5000)
checkpoint_config = dict(interval=200, by_epoch=False, max_keep_ckpts=20)
log_config = dict(
    interval=50, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
custom_hooks = [
    dict(type='NumClassCheckHook'),
    dict(type='WeightSummary'),
    dict(type='MeanTeacher', momentum=0.999, interval=1, warm_up=0)
]
dist_params = dict(backend='nccl')
log_level = 'INFO'
load_from = None
resume_from = None
workflow = [('train', 1)]
opencv_num_threads = 0
mp_start_method = 'fork'
mmdet_base = '../../thirdparty/mmdetection/configs/_base_'
strong_pipeline = [
    dict(
        type='Sequential',
        transforms=[
            dict(
                type='RandResize',
                img_scale=[(1333, 400), (1333, 1200)],
                multiscale_mode='range',
                keep_ratio=True),
            dict(type='RandFlip', flip_ratio=0.5),
            dict(
                type='ShuffledSequential',
                transforms=[
                    dict(
                        type='OneOf',
                        transforms=[
                            dict(type='Identity'),
                            dict(type='AutoContrast'),
                            dict(type='RandEqualize'),
                            dict(type='RandSolarize'),
                            dict(type='RandColor'),
                            dict(type='RandContrast'),
                            dict(type='RandBrightness'),
                            dict(type='RandSharpness'),
                            dict(type='RandPosterize')
                        ]),
                    dict(
                        type='OneOf',
                        transforms=[{
                            'type': 'RandTranslate',
                            'x': (-0.1, 0.1)
                        }, {
                            'type': 'RandTranslate',
                            'y': (-0.1, 0.1)
                        }, {
                            'type': 'RandRotate',
                            'angle': (-30, 30)
                        },
                                    [{
                                        'type': 'RandShear',
                                        'x': (-30, 30)
                                    }, {
                                        'type': 'RandShear',
                                        'y': (-30, 30)
                                    }]])
                ]),
            dict(
                type='RandErase',
                n_iterations=(1, 5),
                size=[0, 0.2],
                squared=True)
        ],
        record=True),
    dict(type='Pad', size_divisor=32),
    dict(
        type='Normalize',
        mean=[103.53, 116.28, 123.675],
        std=[1.0, 1.0, 1.0],
        to_rgb=False),
    dict(type='ExtraAttrs', tag='unsup_student'),
    dict(type='DefaultFormatBundle'),
    dict(
        type='Collect',
        keys=['img', 'gt_bboxes', 'gt_labels'],
        meta_keys=('filename', 'ori_shape', 'img_shape', 'img_norm_cfg',
                   'pad_shape', 'scale_factor', 'tag', 'transform_matrix'))
]
weak_pipeline = [
    dict(
        type='Sequential',
        transforms=[
            dict(
                type='RandResize',
                img_scale=[(1333, 400), (1333, 1200)],
                multiscale_mode='range',
                keep_ratio=True),
            dict(type='RandFlip', flip_ratio=0.5)
        ],
        record=True),
    dict(type='Pad', size_divisor=32),
    dict(
        type='Normalize',
        mean=[103.53, 116.28, 123.675],
        std=[1.0, 1.0, 1.0],
        to_rgb=False),
    dict(type='ExtraAttrs', tag='unsup_teacher'),
    dict(type='DefaultFormatBundle'),
    dict(
        type='Collect',
        keys=['img', 'gt_bboxes', 'gt_labels'],
        meta_keys=('filename', 'ori_shape', 'img_shape', 'img_norm_cfg',
                   'pad_shape', 'scale_factor', 'tag', 'transform_matrix'))
]
unsup_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(type='PseudoSamples', with_bbox=True),
    dict(
        type='MultiBranch',
        unsup_student=[
            dict(
                type='Sequential',
                transforms=[
                    dict(
                        type='RandResize',
                        img_scale=[(1333, 400), (1333, 1200)],
                        multiscale_mode='range',
                        keep_ratio=True),
                    dict(type='RandFlip', flip_ratio=0.5),
                    dict(
                        type='ShuffledSequential',
                        transforms=[
                            dict(
                                type='OneOf',
                                transforms=[
                                    dict(type='Identity'),
                                    dict(type='AutoContrast'),
                                    dict(type='RandEqualize'),
                                    dict(type='RandSolarize'),
                                    dict(type='RandColor'),
                                    dict(type='RandContrast'),
                                    dict(type='RandBrightness'),
                                    dict(type='RandSharpness'),
                                    dict(type='RandPosterize')
                                ]),
                            dict(
                                type='OneOf',
                                transforms=[{
                                    'type': 'RandTranslate',
                                    'x': (-0.1, 0.1)
                                }, {
                                    'type': 'RandTranslate',
                                    'y': (-0.1, 0.1)
                                }, {
                                    'type': 'RandRotate',
                                    'angle': (-30, 30)
                                },
                                            [{
                                                'type': 'RandShear',
                                                'x': (-30, 30)
                                            }, {
                                                'type': 'RandShear',
                                                'y': (-30, 30)
                                            }]])
                        ]),
                    dict(
                        type='RandErase',
                        n_iterations=(1, 5),
                        size=[0, 0.2],
                        squared=True)
                ],
                record=True),
            dict(type='Pad', size_divisor=32),
            dict(
                type='Normalize',
                mean=[103.53, 116.28, 123.675],
                std=[1.0, 1.0, 1.0],
                to_rgb=False),
            dict(type='ExtraAttrs', tag='unsup_student'),
            dict(type='DefaultFormatBundle'),
            dict(
                type='Collect',
                keys=['img', 'gt_bboxes', 'gt_labels'],
                meta_keys=('filename', 'ori_shape', 'img_shape',
                           'img_norm_cfg', 'pad_shape', 'scale_factor', 'tag',
                           'transform_matrix'))
        ],
        unsup_teacher=[
            dict(
                type='Sequential',
                transforms=[
                    dict(
                        type='RandResize',
                        img_scale=[(1333, 400), (1333, 1200)],
                        multiscale_mode='range',
                        keep_ratio=True),
                    dict(type='RandFlip', flip_ratio=0.5)
                ],
                record=True),
            dict(type='Pad', size_divisor=32),
            dict(
                type='Normalize',
                mean=[103.53, 116.28, 123.675],
                std=[1.0, 1.0, 1.0],
                to_rgb=False),
            dict(type='ExtraAttrs', tag='unsup_teacher'),
            dict(type='DefaultFormatBundle'),
            dict(
                type='Collect',
                keys=['img', 'gt_bboxes', 'gt_labels'],
                meta_keys=('filename', 'ori_shape', 'img_shape',
                           'img_norm_cfg', 'pad_shape', 'scale_factor', 'tag',
                           'transform_matrix'))
        ])
]
fp16 = dict(loss_scale='dynamic')
work_dir = './work_dirs/myModel2'
cfg_name = 'soft_teacher_faster_rcnn_r50_caffe_fpn_coco_nodule'
load_from = 'iter_180000.pth'
# gpu_ids = range(0, 1)

pipeline的部分基本可以无视掉，主要修改model和data以及其他的一些参数。

训练

在windows的cmd上，输入python tools/train.py myModel.py就可以训练了。

预测

在windows的cmd上，输入python demo/image_demo.py 'D:\\learn\\AI\\SoftTeacher-main\\data\\coco\\testJPEG\\*.jpg' myModel2.py work_dirs\\myModel2\\latest.pth --output work_dirs/就可以预测。
预测结果：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
但是有些预测结果不太理想，比如：
在这里插入图片描述
可能还需要更多的数据来训练，或者是更多的epoch，会有更好的效果。

遇到的问题

  • 配置文件的evaluation，训练到interval的值时候，要进行评估，就会报错，改了好久都不行，所以我直接无视了evaluation。
  • data里train的classes = ('cat', 'dog'),要分别加到sup和unsup里面，因为这是两个不同的数据集，看源码解读可以知道，train返回两个dataset，所以需要两个classes。
  • 预测的时候glob.glob(args.img)识别不了，也不知道是什么问题，所以我直接在源文件里注明了路径
  • 制作未标注的数据集的json文件，只需要images信息，不需要annotations信息。
砂糖B
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
半监督学习
驽马十驾，功在不舍；锲而不舍，金石可镂。
06-21 1413
在使用机器学习进行训练前，往往需要大量数据及其标签。而对数据进行标注需要花费人力，因此未标注的数据容易获得，同时这些数据中也隐含了对分类有用的信息。半监督学习(semi-supervised learning)可以结合已标注数据以及未标注的数据，以实现更准确的分类。本文结合sklearn实现，介绍Label Spreading的具体过程。Learning with Local and Global Consistency中提到，半监督学习满足两个一致性的先验假设，即：如果仅使用有标签的数据进行有监督学习，则
Softvengers--Teacher-Version
04-04
Softvengers--教师版
半监督目标检测
Highlight_Jin的博客
02-03 1174
半监督学习框架
mmdetection开发记录
小白的博客
01-24 250
安装mmdetection 检查json文件正确性，运行vis_by_json.py,修改annFile='/data/datasets/BONA_coco/coco/annotations/train.json' 修改imgIds=0 修改img_path= /data/datasets/BONA_coco/coco\ 显示结果正确 返回softteacher,修改soft_teacher_faster_rcnn_r50_caffe_fpn_coco_full_720k.py文件 设置
端到端的半监督目标检测模型-Soft Teacher
weixin_43480889的博客
06-09 421
soft teacher模型的介绍。
从视觉到语言：半监督式学习的大规模实际运用
数据派THU
08-23 647
来源：TensorFlow 本文约2300字，建议阅读5分钟Noisy Student 半监控式蒸馏的实践应用案例。 监督式学习 (Supervised Learning)，即使用已知...
「半监督学习系列」1. 统计机器学习导论
大数据与人工智能
12-29 248
点击上方“数据与智能”，“星标或置顶公众号”第一时间获取好内容来源 | 「Introduction to Semi-Supervised Learning」Morgan & c...
【机器学习】聚类_K-means算法基础认识与手机分类,图像切割,半监督学习实战
qq_61260911的博客
04-10 1432
本文将对kmeans介绍，算法理解，基础操作，手机分类模型，图像切割，半监督算法等实战案例去学习kmeans算法K均值聚类（k-means clustering）是一种常见的无监督机器学习算法，可用于将数据集划分为多个不同的聚类。该算法的基本思想是：将数据集分成k个簇（cluster），每个簇的中心点是簇中所有点的均值。通过迭代的方式不断优化每个簇的中心点，使得同一簇内的点距离中心点最小，不同簇之间的距离最大。
mmdetection3.2.0 半监督自定义数据集配置
Meng_zw的博客
11-23 833
github上mmdetection/configs/_base_/datasets /semi_coco_detection.py里的train_dataloader的type是ConcatDataset,如果data的type是ConcatDataset，则要保持两个数据集的metainfo一样。一开始把metainfo放在train_dataloader里，把metainfo放在两个数据集中，
机器学习实战源码.zip
03-26
机器学习实战源码 适合机器学习初学者加深形象的理解，而不是仅限于理论 内含4个实战项目，代码精到，注释准确详细
keras深度学习实战.7z
06-25
keras深度学习实战开源代码，感觉比较有用的是最用一张的非线性模型构建方式
机器学习实战,机器学习实战 pdf,Python
09-10
机器学习实战中文英文pdf+数据集+代码
End-to-End Semi-Supervised Object Detection with Soft Teacher 解读
hbr365的博客
11-30 3564
End-to-End Semi-Supervised Object Detection with Soft Teacher 解读
（1）D2系：半监督目标检测训练自己的数据集unbiased-teacher
zhang2h的博客
01-03 2040
相关：最近再做半监督目标检测的课题，记录一下当前一些算法的复现，目前仅复现了D2系的unbiased-teacher 和改进版mix-unmix算法，mmcv系的soft teacher ，pseco和Instant-teacher。后续复现成功后会有补充。文中的方式是基于ubuntu 系统的conda安装的COCO数据集格式。
人工智能大模型原理与应用实战：半监督学习应用示例
禅与计算机程序设计艺术
11-03 137
作者：禅与计算机程序设计艺术 1.背景介绍 随着社会信息化的发展、移动互联网的普及、物联网的加持以及人类对科技产品的关注，人工智能技术在社会生活各个领域的应用已经越来越广泛。其实现的手段之一便是通过大数据处理和分析人类大量数据所产生的信息，使计算机能够实现自动决策、自动分类、自动推断等功能。而半监督
【半监督学习】2、Soft Teacher | 端到端半监督目标检测器
呆呆的猫的博客
03-15 2079
本文主要介绍 ICCV2021 的半监督目标检测方法 Soft Teacher
ICCV2021-Soft Teacher-End-to-End Semi-Supervised Object Detection with Soft Teacher
weixin_42096202的博客
11-23 6722
前言： SSL(Semi-Supervised Learning)半监督学习，由于其可以合理利用大量无标注数据的属性，一直是CV研究的一个重要方向。最近看到微软在ICCV2021发表的一篇新论文Soft Teacher，在结合sota的检测和实例分割网络之后，直接刷榜相关的LeaderBoard，所以及时跟进一下。 SSL目前在分类和检测网络上应用的比较广泛，常用多阶段的学习方式，具体来说就是先基于标注好的数据训练一个基准网络；然后对未标注的数据推理输出结果，通过设置较高的阈值得到对应的伪标签（图.
FME学习之旅---day27
最新发布
summer_corner的博客
05-17 191
我们付出一些成本，时间的或者其他，最终总能收获一些什么。
mtalab深度学习实战
01-10
MATLAB深度学习实战是一本针对MATLAB用户的实用书籍，着重介绍了深度学习的理论和实践应用。 这本书从基础知识开始，包括神经网络的基本原理、常用的深度学习算法和优化方法等内容。书中详细介绍了如何利用MATLAB进行深度学习任务，包括数据准备、模型构建、训练和评估等方面。 在完成了理论部分的学习后，读者可以通过实践部分来巩固所学知识。书中提供了丰富的实例，包括图像分类、目标检测、语音识别等多个领域的应用案例。每个案例都详细介绍了数据集的准备、模型的创建和训练等步骤，并给出了代码示例，供读者参考和运行。 此外，书中还介绍了MATLAB的深度学习工具箱，这个工具箱为MATLAB用户提供了丰富的深度学习函数和工具，大大方便了实践过程中的开发和调试。 总的来说，MATLAB深度学习实战通过理论与实践相结合的方式，帮助读者了解深度学习的基本概念和实际应用，同时提供了丰富的示例和工具，使读者能够掌握MATLAB在深度学习中的应用技巧。无论是初学者还是有一定基础的学习者，都可以通过这本书来提升自己在深度学习领域的实力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值