精华内容
下载资源
问答
  • Fast-RCNN

    2019-10-10 21:01:23
    代码地址:https://github.com/rbgirshick/fast-rcnn 先说一下性能吧,Fast R-CNN较R-CNN在速度上提升到了5帧/S并且在mAP上也大约提升了3.2%. 好了,现在我们来看看Fast R-CNN的神奇之处吧。Fast R-CNN的框图如下...

    论文:Fast R-CNN

    代码地址:https://github.com/rbgirshick/fast-rcnn

    先说一下性能吧,Fast R-CNN较R-CNN在速度上提升到了5帧/S并且在mAP上也大约提升了3.2%.

    好了,现在我们来看看Fast R-CNN的神奇之处吧。Fast R-CNN的框图如下图所示:

                                 

    从图中我们可以发现,其在RCNN网络的输入上做了些许的改变,也就是提出了ROIPooling层。该

    层可以将输入的不同尺寸的Proposal规范到相同的尺寸中,之后再通过RCNN网络进行前向和反向

    传播。ROIPooling层的原理其实非常的简单,即对输入的Proposal按照一定的尺寸进行均匀分割并

    对每一块进行最大池化运算,例如,输入的Proposal大小为h×w,输出大小为H×W,则分割后每一

    块的大小为(h/H)×(w/W),实际运算时可能会有四舍五入的情况。

    后面的网络结构和RCNN很相似,只是这里的batch size为128,即每张图片采样64个Proposal,并且

    25%的为正样本。

    另外Fast-RCNN中还引入了SVD来提升运算速度,但是这一创新在实际编程时可以通过减少通道数等

    来进行替代。最后Fast-RCNN在VOC上的具体性能可以看下表:

                            

    最后的最后,如果想了解更多关于CV的知识可以关注下方公众号

                                                            

    展开全文
  • RCNN fast-RCNN faster-RCNN

    2018-02-10 22:20:53
    RCNN fast-RCNN faster-RCNN三篇著名目标检测经典论文,打个包方便大家下载~
  • 方便大家查阅经典论文,这个文件里面包涵经典深度学习论文 rcnn fast-rcnn faster-rcnn mask -rcnn yolo系类 以及刚出的DOTA(检测遥感目标)
  • fast-rcnn-master压缩包

    2018-03-26 20:31:34
    fast-rcnn-master压缩包,是在github上下载的神经网络,相关的资料自己找,仅提供安装包
  • CNN也就是众多周知的convolutional neural network, R是region的缩写,意为对图像进行局部区域的处理。 该文的主要亮点在于:,一是利用的region proposals...fast-rcnn和faster-rcnnrcnn方法的改进,大幅提高速度。
  • 包含了RCNNfast-rcnn以及faster-rcnn的相关文献、资料以及matlab代码(包含说明),绝对好东西.运行程序详细看代码说明。
  • 计算机视觉系列-RCNN Fast-RCNN Faster-RCNN( 3) 计算机视觉系列-RCNN Fast-RCNN ( 2) https://duanzhihua.blog.csdn.net/article/details/113453408 计算机视觉系列-RCNN ( 1) ...目录Faster-RCNNFaster RCNN ...
    展开全文
  • RCNN系列之-Fast-RCNN keras实现

    千次阅读 2020-01-28 17:59:13
    https://github.com/xiaoxu1025/fast-rcnn-keras 对于 RCNN 和 Faster-RCNN的实现地址如下 CSDN链接地址: https://blog.csdn.net/xiaoxu1025/article/details/104134569RCNN系列之-RCNN keras实现 ...

    代码地址

    https://github.com/xiaoxu1025/fast-rcnn-keras

    对于 RCNN 和 Faster-RCNN的实现地址如下

    CSDN链接地址:

    https://blog.csdn.net/xiaoxu1025/article/details/104134569  RCNN系列之-RCNN keras实现

    https://blog.csdn.net/xiaoxu1025/article/details/104127684  RCNN系列之-Faster-RCNN keras实现

    github链接地址:

    https://github.com/xiaoxu1025/rcnn-keras

    https://github.com/xiaoxu1025/fast-rcnn-keras

     

    对代码做几点说明:

    1. 数据集采用的是在pascal voc 2. 特征抽取式采用keras自带的vgg16来做特征抽取  3. roi没有参与反向传播

    测试我没有实现,不想写了没啥意思。根据论文所说 For each test RoI r, the forward pass outputs a class posterior probability distribution p and a set of predicted bounding-box offsets relative to r (each of the K classes gets its own refined bounding-box prediction) 和RCNN的实现差不多 也就是对每个类进行非极大值抑制。

    这仅仅是一个简单实现,和大家交流下而已。有兴趣的朋友可以下载下来看一下,有什么见解可以在下面留言。

    我只是跑了一下,然后就暂停了,没有gpu时间太长

     

    训练的代码如下:

    from voc_annotation import VOCAnnotation
    from voc_data import VocData
    from models.model import FastRCNN
    from tensorflow.keras.callbacks import TensorBoard, ModelCheckpoint, ReduceLROnPlateau, EarlyStopping
    from tensorflow.keras.optimizers import SGD
    import config as cfg
    
    if __name__ == '__main__':
        log_dir = 'logs/000/'
    
        voc_train_annotation = VOCAnnotation(2007, 'train', '/Users/lx/segment_data', './data/voc_classes.txt')
        voc_train_data = VocData('./data/2007_train.txt', voc_train_annotation)
    
        voc_val_annotation = VOCAnnotation(2007, 'val', '/Users/lx/segment_data', './data/voc_classes.txt')
        voc_val_data = VocData('./data/2007_val.txt', voc_val_annotation)
    
        # pascal voc 20个类别
        model = FastRCNN(20)
    
        logging = TensorBoard(log_dir=log_dir)
        checkpoint = ModelCheckpoint(log_dir + 'ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5',
                                     monitor='val_loss', save_weights_only=True, save_best_only=True, period=3)
    
        reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3, verbose=1)
        early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verbose=1)
        model.compile(optimizer=SGD(lr=1e-3), loss=lambda y_true, y_pred: y_pred)
        model.build(input_shape=[(None, cfg.DEFAUTL_IMAGE_SIZE, cfg.DEFAUTL_IMAGE_SIZE, 3),
                                 (None, None, 1), (None, None, 5), (None, None, 80),
                                 (None, None, 80), (None, None, 80)])
        batch_size = 1
        model.fit_generator(voc_train_data.data_generator_wrapper(),
                            steps_per_epoch=max(1, voc_train_data.example_nums // batch_size),
                            validation_data=voc_val_data.data_generator_wrapper(),
                            validation_steps=max(1, voc_val_data.example_nums // batch_size),
                            epochs=50,
                            initial_epoch=0,
                            callbacks=[logging, checkpoint])
        model.save_weights(log_dir + 'trained_weights_stage_1.h5')
    

     

    损失函数的实现

    import tensorflow as tf
    import config as cfg
    
    
    def fast_loss(args):
        cls_output, labels, bbox_output, bbox_targets, bbox_inside_weights, bbox_outside_weights = args
        labels = tf.cast(labels, dtype=tf.int32)
        # 分类损失
        cls_loss = tf.reduce_mean(
            tf.nn.sparse_softmax_cross_entropy_with_logits(logits=cls_output, labels=tf.squeeze(labels)))
        diff = tf.multiply(bbox_inside_weights, bbox_output - bbox_targets)
        diff_l1 = smooth_l1(diff, 1.0)
        # 边框回归损失
        roi_bbox_loss = tf.reduce_mean(tf.reduce_sum(tf.multiply(bbox_outside_weights, diff_l1), axis=1))
        roi_bbox_loss = cfg.TRAIN_RPN_BBOX_LAMBDA * roi_bbox_loss
        fast_loss = cls_loss + roi_bbox_loss
        return fast_loss
    
    
    def smooth_l1(x, sigma):
        '''
                          0.5 * (sigma * x)^2  if |x| < 1/sigma^2
          smoothL1(x) = {
                          |x| - 0.5/sigma^2    otherwise
        '''
    
        with tf.variable_scope('smooth_l1'):
            conditional = tf.less(tf.abs(x), 1 / sigma ** 2)
            close = 0.5 * (sigma * x) ** 2
            far = tf.abs(x) - 0.5 / sigma ** 2
            return tf.where(conditional, close, far)
    

    模型的实现:

    from tensorflow.keras import Model
    from models.vgg16_body import get_model_body
    from tensorflow.keras.layers import Dense, Flatten, Dropout, Lambda
    from roi.roi_proposal import roi_proposal
    from fast_loss import fast_loss as loss
    
    
    class FastRCNN(Model):
        def __init__(self, num_classes, keep_prob=0.5):
            super(FastRCNN, self).__init__()
            self._num_classes = num_classes
            self._vgg16 = get_model_body()
            # roi pooling 不参与反向传播
            self._roi_pooling = Lambda(roi_proposal)
            self._flatten = Flatten()
            self._fc1 = Dense(4096, activation='tanh')
            self._dropout1 = Dropout(keep_prob)
            self._fc2 = Dense(4096, activation='tanh')
            self._dropout2 = Dropout(keep_prob)
            # predict k + 1 categories  k个类别加上背景
            # (None, 128, 21)
            self._fc_cls = Dense(num_classes + 1)
            # predict 4 * k 个值 每个类4个坐标回归值
            # (None, 128, 80)
            self._fc_bbox = Dense(num_classes * 4)
            # 计算损失
            self._loss = Lambda(loss, name='fast_loss')
    
        def call(self, inputs, mask=None):
            image_data, labels, regions_target, bbox_targets, bbox_inside_weights, bbox_outside_weights = \
                inputs[0], inputs[1], inputs[2], inputs[3], inputs[4], inputs[5]
            # (None, 36, 36, 512)
            x = self._vgg16(image_data)
            # seletvie_search 貌似有点问题参数可能不对 不能够采样128个满足条件样本
            # (None, 128, 7, 7, 512)
            x = self._roi_pooling([x, regions_target])
            x = self._flatten(x)
            x = self._fc1(x)
            x = self._dropout1(x)
            x = self._fc2(x)
            x = self._dropout2(x)
            # (batch_size, 128, 21)
            cls_output = self._fc_cls(x)
            # (batch_size, 128, 80)
            bbox_output = self._fc_bbox(x)
            loss = self._loss([cls_output, labels, bbox_output, bbox_targets, bbox_inside_weights, bbox_outside_weights])
            return loss
    

    roi pooling的两种实现:

    import tensorflow as tf
    import numpy as np
    import config as cfg
    
    
    def roi_pool(feature_maps, rois, im_dims=(cfg.DEFAUTL_IMAGE_SIZE, cfg.DEFAUTL_IMAGE_SIZE)):
        # 将tensor数据转成numpy计算
        pooled_features = tf.py_function(_roi_pool_py, [feature_maps, rois, im_dims], [tf.float32])
        pooled_features = tf.convert_to_tensor(pooled_features)
        return pooled_features
    
    
    def _roi_pool_py(feature_maps, regions, im_dims):
        """
        roi pooling 真正实现  这里是缩小了16倍
        :param feature_maps: (bath_size, 36, 36, 512)
        :param rois:      (batch_id, x1, y1, x2, y2)
        :param im_dims:
        :return:
        """
        batch_size, height, width, channels = feature_maps.shape
        # assert batch_size == 1, 'mini-batch should be 1'
        # 获得
        region_nums = regions.shape[0]
        arg_top = np.zeros(shape=(region_nums, cfg.POOL_HEIGHT, cfg.POOL_WIDTH, channels), dtype=np.float32)
        for idx, region in enumerate(regions):
            # get image size
            img_w, img_h = im_dims[0], im_dims[1]
            spatial_scale_w = width // img_w
            spatial_scale_h = height // img_h
            roi_batch_ind = region[0]
            # 得到region在特征图上的坐标
            roi_start_w = int(round(region[1] * spatial_scale_w))
            roi_start_h = int(round(region[2] * spatial_scale_h))
            roi_end_w = int(round(region[3] * spatial_scale_w))
            roi_end_h = int(round(region[4] * spatial_scale_h))
            # # roi_batch_ind should be zero
            # if roi_batch_ind < 0 or roi_batch_ind >= batch_size:
            #     continue
            # 得到region在特征图上宽高
            roi_height = max(roi_end_h - roi_start_h + 1, 1)
            roi_width = max(roi_end_w - roi_start_w + 1, 1)
            # 将region在特征图上的宽高进行划分
            sub_roi_width = roi_width / cfg.POOL_WIDTH
            sub_roi_height = roi_height / cfg.POOL_HEIGHT
    
            batch_data = feature_maps[roi_batch_ind, ...]
            # 遍历batch_data数据进行 roi_pooling
            for c in range(channels):
                for ph in range(cfg.POOL_HEIGHT):
                    for pw in range(cfg.POOL_WIDTH):
                        hstart = int(ph * sub_roi_height)
                        wstart = int(pw * sub_roi_width)
                        hend = int((ph + 1) * sub_roi_height)
                        wend = int((pw + 1) * sub_roi_width)
                        # 计算相对于特征图的坐标
                        hstart = min(max(roi_start_h + hstart, 0), height)
                        wstart = min(max(roi_start_w + wstart, 0), width)
                        hend = min(max(roi_start_h + hend, 0), height)
                        wend = min(max(roi_start_w + wend, 0), width)
    
                        for h in range(hstart, hend):
                            for w in range(wstart, wend):
                                if batch_data[h, w, c] > arg_top[idx, ph, pw, c]:
                                    arg_top[idx, ph, pw, c] = batch_data[h, w, c]
        return arg_top
    
    import tensorflow as tf
    import config as cfg
    
    
    def roi_pool_tf(feature_maps, rois, im_dims=(cfg.DEFAUTL_IMAGE_SIZE, cfg.DEFAUTL_IMAGE_SIZE)):
        """
    
        :param feature_maps: (batch_size, 36, 36, 512)
        :param rois: shape (batch_size, 128, 5) -> n * (batch_id, x1, y1, x2, y2)
        :param im_dims:
        :return:
        """
        # Image that the ROI is taken from (minibatch of 1 means these will all be 0)
        box_ind = tf.cast(rois[..., 0], dtype=tf.int32)
    
        # ROI box coordinates. Must be normalized and ordered to [y1, x1, y2, x2]
        # box must be normalized
        boxes = rois[..., 1:]
        normalization = tf.cast(tf.stack([im_dims[1], im_dims[0], im_dims[1], im_dims[0]], axis=0),
                                dtype=tf.float32)
        boxes = tf.div(boxes, normalization)
        boxes = tf.stack([boxes[..., 1], boxes[..., 0], boxes[..., 3], boxes[..., 2]], axis=-1)  # y1, x1, y2, x2
    
        # ROI pool output size
        crop_size = tf.constant([14, 14])
    
        # ROI pool
        pooled_features = tf.image.crop_and_resize(image=feature_maps, boxes=boxes[0, ...], box_ind=box_ind[0, ...], crop_size=crop_size)
        # Max pool to (7x7)
        pooled_features = tf.nn.max_pool(pooled_features, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
        return pooled_features
    

    还有些代码就不贴了,可以自行下载。 

    展开全文
  • 计算机视觉系列-RCNN Fast-RCNN ( 2) 计算机视觉系列-RCNN ( 1) https://duanzhihua.blog.csdn.net/article/details/113419310 目录SPP-NET特征映射金字塔池化层(Spatial Pyramid Pooling)SPP-NET效果Fast-...
    展开全文
  • Fast-RCNN论文翻译

    万次阅读 多人点赞 2018-03-14 08:57:49
    Fast-RCNN论文地址:Fast-RCNNFast-RCNN项目地址:https://github.com/rbgirshick/fast-rcnn摘要本文提出了一种快速的基于区域的卷积网络方法(fast R-CNN)用于目标检测。Fast R-CNN建立在以前使用的深卷积网络有效...
  • 浅谈RCNN、SPP-net、Fast-Rcnn、Faster-Rcnn

    千次阅读 2017-02-06 12:39:20
    浅谈RCNN、SPP-net、Fast-Rcnn、Faster-Rcnn
  • 其中,Fast-RCNN主要在损失函数和分类上对RCNN做了改进,极大的改善了网络的性能,提高了算法的精度和速度。 2.基本概念 2.1 空间金字塔池化 2.2 Fast-RCNN的多任务损失函数 3.网络结构 3.1 Fast-RCNN 直接使用...
  • 目录R-CNNRCNN,Fast-RCNN,Faster-RCNN 比较YOLO V1 R-CNN RCNN,Fast-RCNN,Faster-RCNN 比较 YOLO V1
  • http://closure11.com/rcnn-fast-rcnn-faster-rcnn%E7%9A%84%E4%B8%80%E4%BA%9B%E4%BA%8B/ rbg大神的深度神经网络检测算法系列RCNN、Fast-RCNN、Faster-RCNN可谓是理论与实践的经典范例,论文创新点足够...
  • 从R-CNN到 Fast-RCNN Faster-RCNN 最终到Mask-RCNN的演变过程 首先是R-CNN : R-CNN的全称是Region-CNN,它可以说是是第一个成功将深度学习应用到目标检测上的算法。 传统的目标检测方法大多以图像识别为基础。 ...
  • 目标检测Fast-RCNN

    2021-10-12 08:40:49
    Fast-RCNN是在SPP-net的基础上,将SPP->ROI Pooling,是SPP的一个特例,只使用了6×6的池化核。 分类器由SVM->Softmax,神经网络可以和分类器一起训练。
  • A-Fast-RCNN

    2019-04-10 09:29:11
    [CVPR 17 oral] A-Fast-RCNN: Hard Positive Generation via Adversary for Object Detection 简而言之个人观点:在原本faster-RCNN的基础上,利用ASND网络进行部分遮挡住原始图像,使得训练数据集会出现特殊被...
  • 目标检测3-Fast-RCNN

    2020-04-12 08:34:45
    1. Fast-RCNN简介 1.1 ROI层介绍 1.2 RCNNFast-RCNN对比 Fast-RCNN最后的模型不用训练的SVM分类器,以及单独训练的回归器,而是将两个统一为一个多任务的模型,提升精确度和速度 ...
  • Fast-RCNN简析

    2021-03-10 10:11:42
    RCNNFast-RCNN的基础,发表于2014年,是首度使用深度学习神经网络进行目标检测的算法。论文名字:Rich Feature Hierarchies for Accurate Object Detection and Semantic Segmentation 1、特征提取 相比于SIFT和...
  • rbg大神的深度神经网络检测算法系列RCNNFast-RCNN、Faster-RCNN可谓是理论与实践的经典范例,论文创新点足够,在github上开源的代码更是造福广大码农,本文以当前最新Faster-RCNN的python实现...
  • Fast-rcnn配置运行

    2017-02-24 14:01:15
    配置运行步骤一、Git fast-rcnn源码 git clone –recursive https://github.com/rbgirshick/fast-rcnn.git 二、进fast-rcnn/lib目录进行编译 cd /home/服务器的名字/fast-rcnn/lib make 目录如下: 三、编译...
  • Fast-Rcnn介绍

    千次阅读 2017-07-05 15:07:54
    Fast-RCNN之所以称为Fast,较RCNN快在proposals获取:RCNN将一张图上的所有proposals都输入到CNN中,而Fast-RCNN利用卷积的平移不变形,一次性将所有的proposals投影到卷积后的feature maps上, 极大的减少了运算量;...
  • RCNN, Fast-RCNN, Faster-RCNN

    2017-05-17 21:37:25
    http://closure11.com/rcnn-fast-rcnn-faster-rcnn%E7%9A%84%E4%B8%80%E4%BA%9B%E4%BA%8B/Faster-RCNN 论文笔记Faster RCNN由两个模块组成: 1.deep fully convolutional network that proposes regions 2.Fast R-...
  • Fast-rcnn总结

    2017-05-23 21:43:53
    Fast-rcnn总结
  • Fast-RCNN目标检测算法

    2020-09-26 10:51:10
    Fast-Rcnn 核心思想:简化Rcnn中计算的复杂度 网络结构: 输入图片直接输入到卷积神经网络中得到特征图(而不是RCNN中先进行区域选择),在特征图中使用Slective search(RCNN是直接使用对原图选择区域)提出...
  • fast-rcnn logo识别

    2019-01-24 16:56:40
    1,下载编译fast-rcnn fast-rcnn下载地址 Clone the Fast R-CNN repository #Make sure to clone with --recursive(这样clone下来的是包含rgb大神的caffe版本) git clone --recursive ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,111
精华内容 5,244
关键字:

fast-rcnn