Fast R-CNN： 我变快了，也变强了！

最新推荐文章于 2024-06-18 14:18:55 发布
最新推荐文章于 2024-06-18 14:18:55 发布
阅读量631 收藏 2
点赞数

点击“小詹学Python”，选择“置顶”公众号

重磅干货，第一时间送达640?wx_fmt=jpeg

本文经作者授权转载，禁二次转载


来源 | @知乎 Uno Whoiam

原文 | https://zhuanlan.zhihu.com/p/62273673



Fast R-CNN 即 Fast Region-based Convolutional Network，你的直觉没错，它就是R-CNN的升级版。


论文链接：https://arxiv.org/abs/1504.08083


在细说 Fast R-CNN 之前，不妨先看看 R-CNN 有什么令人诟病的地方： 


1. 慢，实在是慢，别说实时检测了，47s的等待让坐在电脑前的记几仿佛是一只智障。 

2. 训练麻烦，AlexNet、SVMs 以及 bounding-box regression 得一个接一个地训练。 

3. 训练占用大量时间和空间（硬盘），除开训练三个模型的时间，SVMs 和 bounding-box regression 的训练样本得用 AlexNet 一次又一次地前向传播提取特征、标注样本数据、保存在硬盘里的哟，每一张图片的每一个proposal都得跑一次哟，想想都觉得恶心。而作者而说明了，需要GPU花2.5天的时间才能处理完5K张VOC07trainval里的图片，产生的训练样本占用的空间得好几百个GB。想想都觉得恶心\呕。顺便温馨提示一下，每张图生成的样本最好单独生成一个文件夹保存，别把这这个数量级的样本放在同一个文件夹里哟，即使是最好的SSD也招架不住这样的文件夹，当你幡然醒悟想要rm -r -f dir 重新来过时，漫长的等待足够让您好好睡一觉了，别问我为什么知道这么多~泪目。


随着 Fast R-CNN 的到来，以上问题也就不复存在辣！相比 R-CNN，除了各种快（见下段原论文引用）Fast R-CNN 有以下几个特性：


Fast R-CNN trains the very deep VGG16 network 9× faster than R-CNN, is 213× faster at test-time, and achieves a higher mAP on PASCAL VOC 2012. Compared to SPPnet, Fast R-CNN trains VGG16 3× faster, tests 10× faster, and is more accurate.


1. 更高的mAP。

2. 不用分段训练，整个网络可以通过使用多任务损失函数，一次性训练好。

3. 训练可以更新网络层中的所有权重。

4. 无需苦逼生成训练样本缓存在硬盘上，节省了空间。


Fast R-CNN 的整体网络如下图所示：


640?wx_fmt=jpeg


接下来按照物体检测的大框架：候选框->特征提取->分类->精调位置。一步步来说吧。


一、提出候选框 


和R-CNN一样，候选框的提出使用 selective search 方法。


selective search：

http://www.huppelen.nl/publications/selectiveSearchDraft.pdf https://blog.csdn.net/mao_kun/article/details/50576003


二、特征提取


使用深度卷积神经网络进行特征提取，在论文中作者分别使用了从小到大三种网络进行实验： 


1. S: CaffeNet 即小型版的 AlexNet 

2. M: VGG_CNN_ M_ 1024 一看名字就知道是小型一点的 VGG 

3. L: VGG-16 


值得注意的是，以上网络的全连接层都被去掉了，这意味着：输入的尺寸大小劳资不用管辣哈哈哈哈哈！！！（想起R-CNN里RBG大神辛辛苦苦想了四种办法将Proposal区域变成 227 x 227 再喂给 AlexNet 就觉得熏疼）


也就是说，特征提取网络最终输出的是 C 层的 Feature Maps 。 


等等，好像有什么不对？我想要得到的是图片中某个Proposal区域的特征向量啊，没特征向量我怎么判断这个Proposal区域到底有没有物体嘛！ 


这就需要用到 ROI max-pooling 了。对于这个细节网上很少有可以把它说清楚的，本文将结合 Pytorch 实现代码，保证让您看得明明白白的。


首先，啥是Proposal区域？在Fast R-CNN中，Proposal区域就是用 selective search 在图片上生成的可能含有被检测物体的框框们，而这个框框，可以用左上角和右下角的坐标表示，即： (x1,y1,x2,y2) ，它们都是 [0,1] 范围内的 float 数，表示框框在图片中的相对位置。 


现在我们的目标是：对于一个Proposal框，在神经网络输出的C 层 Feature Maps找到对应的部分。具体该怎么做呢？如果整张图片的经过特征提取网络生成的 Feature Maps 尺寸是 (C,W,H) ，那么框框对应的坐标是：


640?wx_fmt=png


其中 Floor 表示下取整， Ceil 表示上取整。这个框出来的部分就代表着Proposal区域经过神经网络提取到的特征，另外 C 保持不变，将其平展开成一维向量后就表示Proposal区域的特征向量辣。 


新的问题来了，Proposal框大小不同也就意味着对应的 Feature Maps 上的大小不同，大小不同平铺出来的一维特征向量也不同，那怎么办？ 


这就是 ROI max-pooling 需要做的事情了：将不同尺寸Proposal区域所对应的 Feature Maps 变成相同尺寸的，在 Pytorch 中可以使用 torch.nn.AdaptiveAvgPool2d 来实现，无论输入的 Feature Maps 是什么尺寸，它都可以通过调整stride、padding等参数给你输出成统一大小的尺寸。下面是 Pytorch 代码：


 
 
class SlowROIPool(nn.Module): def __init__(self, output_size): super().__init__() self.maxpool = nn.AdaptiveMaxPool2d(output_size) self.size = output_size def forward(self, images, rois, roi_idx): n = rois.shape[0] h = images.size(2) w = images.size(3) x1 = rois[:,0] y1 = rois[:,1] x2 = rois[:,2] y2 = rois[:,3] x1 = np.floor(x1 * w).astype(int) x2 = np.ceil(x2 * w).astype(int) y1 = np.floor(y1 * h).astype(int) y2 = np.ceil(y2 * h).astype(int)  res = [] for i in range(n): img = images[roi_idx[i]].unsqueeze(0) img = img[:, :, y1[i]:y2[i], x1[i]:x2[i]] img = self.maxpool(img) res.append(img) res = torch.cat(res, dim=0) return res
 def __init__(self, output_size):
 super().__init__()
 self.maxpool = nn.AdaptiveMaxPool2d(output_size)
 self.size = output_size

 def forward(self, images, rois, roi_idx):
 n = rois.shape[0]
 h = images.size(2)
w = images.size(3)
 x1 = rois[:,0]
 y1 = rois[:,1]
 x2 = rois[:,2]
 y2 = rois[:,3]

 x1 = np.floor(x1 * w).astype(int)
 x2 = np.ceil(x2 * w).astype(int)
 y1 = np.floor(y1 * h).astype(int)
 y2 = np.ceil(y2 * h).astype(int)

res = []
for i in range(n):
 img = images[roi_idx[i]].unsqueeze(0)
 img = img[:, :, y1[i]:y2[i], x1[i]:x2[i]]
 img = self.maxpool(img)
res.append(img)
res = torch.cat(res, dim=0)
return res
 
 

 
 
注： 
 
 
代码来源：https://github.com/GitHberChen/Fast-RCNN-Object-Detection-Pytorch/blob/master/README.ipynb
 
 
 images：shape为[N,C,H,W]，为N张图片经VGG输出的 Feature Maps 
 
 
rois：单张图片中包含N组Proposal框的 (x1,y1,x2,y2) 
 
 
roi_idx：rois对应的图片序号
 
 

 
 
三、分类以及边框回归
 
 

 
 
简单，分类通过将上面提取出的特征向量使用全连接网络输出 N+1 类的置信度即可，而边框回归也是通过全连接网络输出 (N+1) x 4 个数。 
 
 

 
 
另外一个细节是，论文中采用了 SVD 对这两个全连接层的计算进行了加速： 
 
 

 
 
（这篇博客写得不错，推荐阅读）
 
 

 
 
图像分类任务中，用于卷积层计算的时间比用于全连接层计算的时间多，而在目标检测任务中，selective search算法提取的建议框比较多【约2k】，几乎有一半的前向计算时间被花费于全连接层，就Fast R-CNN而言，RoI池化层后的全连接层需要进行约2k次【每个建议框都要计算】，因此在Fast R-CNN中可以采用SVD分解加速全连接层计算；
 
 

 
 
具体如何实现呢? 
 
 

 
 
物体分类和窗口回归都是通过全连接层实现的，假设全连接层输入数据为 x ，输出数据为 y ，全连接层参数为 W ，尺寸为 u×v ，那么该层全连接计算为: y=Wx，计算复杂度为 u×v ；
 
 

 
 
若将W进行SVD分解，并用前t个特征值近似代替，即:
 
 

 
 
640?wx_fmt=png
 
 

 
 
那么原来的前向传播分解成两步:
 
 

 
 
640?wx_fmt=png
 
 

 
 
计算复杂度为 u×t+v×t ，若 t<min(u,v)t<min(u,v) ，则这种分解会大大减少计算量；
 
 

 
 
在实现时，相当于把一个全连接层拆分为两个全连接层，第一个全连接层不含偏置，第二个全连接层含偏置；实验表明，SVD分解全连接层能使mAP只下降0.3%的情况下提升30%的速度，同时该方法也不必再执行额外的微调操作。
 
 

 
 
作者：WoPawn 
 
 
来源：CSDN 
 
 
原文：https://blog.csdn.net/WoPawn/article/details/52463853
 
 

 
 
四、损失函数
 
 

 
 
Fast R-CNN 虽是 two-stage 算法，但可以通过 one-stage 训练好，这意味着，损失函数包含多个任务目标：
 
 

 
 
640?wx_fmt=png
 
 
640?wx_fmt=jpeg
 
 

 
 
最后附上 Fast R-CNN 结构图和具体细节：
 
 

 
 
640?wx_fmt=jpeg
 
 

 
 
 
 
RCNN ( (seq): Sequential ( (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True) (2): ReLU (inplace) (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True) (5): ReLU (inplace) (6): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1)) (7): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (8): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True) (9): ReLU (inplace) (10): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (11): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True) (12): ReLU (inplace) (13): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1)) (14): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (15): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True) (16): ReLU (inplace) (17): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (18): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True) (19): ReLU (inplace) (20): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (21): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True) (22): ReLU (inplace) (23): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1)) (24): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (25): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True) (26): ReLU (inplace) (27): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (28): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True) (29): ReLU (inplace) (30): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (31): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True) (32): ReLU (inplace) (33): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1)) (34): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (35): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True) (36): ReLU (inplace) (37): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (38): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True) (39): ReLU (inplace) (40): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (41): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True) (42): ReLU (inplace) ) (roipool): SlowROIPool ( (maxpool): AdaptiveMaxPool2d (output_size=(7, 7)) ) (feature): Sequential ( (0): Linear (25088 -> 4096) (1): ReLU (inplace) (2): Dropout (p = 0.5) (3): Linear (4096 -> 4096) (4): ReLU (inplace) (5): Dropout (p = 0.5) ) (cls_score): Linear (4096 -> 21) (bbox): Linear (4096 -> 84) (cel): CrossEntropyLoss ( ) (sl1): SmoothL1Loss ( ))
 (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
 (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
 (2): ReLU (inplace)
 (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
 (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
 (5): ReLU (inplace)
 (6): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
 (7): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
 (8): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
 (9): ReLU (inplace)
 (10): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
 (11): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
 (12): ReLU (inplace)
 (13): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
 (14): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
 (15): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
 (16): ReLU (inplace)
 (17): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
 (18): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
 (19): ReLU (inplace)
 (20): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
 (21): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
 (22): ReLU (inplace)
 (23): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
 (24): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
 (25): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
 (26): ReLU (inplace)
 (27): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
 (28): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
 (29): ReLU (inplace)
 (30): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
 (31): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
 (32): ReLU (inplace)
 (33): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
 (34): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
 (35): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
 (36): ReLU (inplace)
 (37): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
 (38): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
 (39): ReLU (inplace)
 (40): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
 (41): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
 (42): ReLU (inplace)
 )
 (roipool): SlowROIPool (
 (maxpool): AdaptiveMaxPool2d (output_size=(7, 7))
 )
 (feature): Sequential (
 (0): Linear (25088 -> 4096)
 (1): ReLU (inplace)
 (2): Dropout (p = 0.5)
 (3): Linear (4096 -> 4096)
 (4): ReLU (inplace)
 (5): Dropout (p = 0.5)
 )
 (cls_score): Linear (4096 -> 21)
 (bbox): Linear (4096 -> 84)
 (cel): CrossEntropyLoss (
 )
 (sl1): SmoothL1Loss (
 )
)
 
 

 
 
参考链接：
 
 
https://github.com/GitHberChen/Fast-RCNN-Object-Detection-Pytorch/blob/master/README.ipynb
 
 

 
 

 
 
最新干货，我在看❤️
 


                

        

        

    




    

      

        

            

              
                
                  小詹学 Python
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
Fast R-CNN浅解

				
			

			

				

					shine的博客
				

				

					09-03
					
					329
					
				

			

		

		

			
				
使用VGG16作为网络的backbone，训练速度比R-CNN快了9倍，测试速度快了213倍，并且在PASCAL VOC 2012上实现了更高的map；

与SPP Net相比，Fast R-CNN训练速度快了3倍，测试速度快了10倍，并且准确率更高；

——单阶段训练算法----分类与边框回归的loss合并，梯度回传

算法流程

一张图像生成1k~2k个候选区域（使用Selective Search方法）

将图像输入网络得到相应的特征图，将SS算法生成的候选框投影到特征图获得相应的特征矩阵

将每个特

			
		

	



                

              
                



	

		

			

				
					
【论文速度】Fast RCNN

				
			

			

				

					你好tesseract的专栏
				

				

					05-15
					
					314
					
				

			

		

		

			
				
https://blog.csdn.net/wopawn/article/details/52463853https://blog.csdn.net/u011718701/article/details/53748724 翻译：https://alvinzhu.xyz/2017/10/10/fast-r-cnn/ 创新点（相较于R-CNN） 1）共享计算结果：ROIpooling（前向、后向）——...

			
		

	



                


  
              

                


	

		

			

				
					
目标检测—Fast RCNN

					
最新发布

				
			

			

				

					2301_79573948的博客
				

				

					06-18
					
					2612
					
				

			

		

		

			
				
R-CNN是Ross Girshick大神的一大杰作，14年发表在CVPR上，目前已有超过2万的引用量，在目标检测领域有着里程碑式的意义。

			
		

	





	

		

			

				
					
faster RCNN 快速理解

				
			

			

				

					如雨繁辰‘s  blog
				

				

					04-15
					
					380
					
				

			

		

		

			
				
今天复习详细读了Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks，大致简单梳理下



rcnn 到fast rcnn 到 faster rcnn演变：https://www.cnblogs.com/skyfsm/p/6806246.html

简单说就是这一类都是在一张图中取多个候选图，...

			
		

	



		

			
		



	

		

			

				
					
目标检测算法Fast R-CNN详解

				
			

			

				

					春有百花秋有月，夏有凉风冬有雪！
				

				

					05-27
					
					1147
					
				

			

		

		

			
				
前面我们一起学了SPP-Net和R-CNN的相关知识，如下：目标检测算法SPP-Net详解目标检测R-CNN通俗详解由于每期都是逐步改进，重复的不在赘述，所以建议先阅读前面的，这期我们继...

			
		

	





	

		

			

				
					
Faster-RCNN.pytorch的搭建、使用过程详解（适配PyTorch 1.0以上版本）

				
			

			

				

					Yale-曼陀罗
				

				

					11-27
					
					3万+
					
				

			

		

		

			
				
Faster-RCNN.pytorch的搭建、使用过程详解引言faster-rcnn pytorch代码下载faster-rcnn pytorch配置过程
引言
本文主要介绍（1）如何跑通源代码；（2）配置过程中遇到的错误调试过程；（3）成功训练自己的数据集。
faster-rcnn pytorch代码下载

pytorch0.4.0版源码：https://github.com/jwyang/faster-rcnn.pytorch.git
pytorch1.0.0版源码：https://github.com

			
		

	





	

		

			

				
					
强化特征提取能力的航拍图像目标检测算法.pdf

				
			

			

				

					12-15
				

			

		

		

			
				
二阶方法，如R-CNN系列（包括R-CNN、Fast R-CNN），通过候选区域生成和特征提取，提高了检测精度，但增加了计算复杂度，导致检测速度下降。  近年来，深度学习，尤其是卷积神经网络（CNN），因其在特征提取上的强大...

			
		

	





	

		

			

				
					
论文研究-基于机器视觉的螺孔在线质量检测系统设计 .pdf

				
			

			

				

					08-14
				

			

		

		

			
				
本文选取液力变矩器作为研究对象，针对其螺孔质量检测过程中的目标识别和机械手路径规划问题，提出了基于Fast R-CNN模型的深度学习机器视觉检测系统开发方案。Fast R-CNN（Fast Region-based Convolutional Neural ...

			
		

	





	

		

			

				
					
深度学习 之 目标检测.pdf

				
			

			

				

					05-24
				

			

		

		

			
				
- **Fast R-CNN**：改进了R-CNN的速度，提高了整体性能。 - **Faster R-CNN**：引入了Region Proposal Network (RPN)，进一步提升了检测速度和精度。 - **R-FCN**：利用全卷积网络提高检测速度，同时保持高精度。 - ...

			
		

	





	

		

			

				
					
深度卷积应用于目标检测算法综述.docx

				
			

			

				

					11-28
				

			

		

		

			
				
此后，基于深度学习的目标检测算法，如R-CNN、Fast R-CNN、Faster R-CNN、YOLO（You Only Look Once）和Mask R-CNN等，逐渐成为研究的热点。这些方法通过自动学习高层语义特征，提高了目标检测的准确性和速度，解决...

			
		

	





	

		

			

				
					
[ 目标检测 ] 经典网络模型2——Fast R-CNN 详解与复现

				
			

			

				

					A_John 的博客
				

				

					05-08
					
					7904
					
				

			

		

		

			
				
[ 目标检测 ] 经典网络模型2——Fast R-CNN 详解与复现
1、Fast Region-based Convolutional Network；
2、Fast R-CNN详解；
3、Fast R-CNN复现；
Fast R-CNN 是一种基于区域卷积网络的快速目标检测方法 ；
Fast R-CNN 比 R-CNN 快 9倍，在测试时快 213倍，在 PASCAL VOC 2012 上实现了更高的映射 ；
基于此作者提出了一种单阶段训练算法 (single-stage training)......

			
		

	





	

		

			

				
					
为什么使用CNN（cnn的优势）

				
			

			

				

					m0_54342473的博客
				

				

					02-11
					
					1867
					
				

			

		

		

			
				
参考博客：
https://blog.csdn.net/weixin_44177568/article/details/102812050



			
		

	





	

		

			

				
					
RCNN系列（二）——要更快的fast-rcnn

				
			

			

				

					与贰的博客
				

				

					07-29
					
					1437
					
				

			

		

		

			
				
俗话讲天下武功唯快不破，网络也是这样。RCNN比传统框架在mAP上提高到了66%，这得益于它引入了RP+CNN的特殊结构，促使他的准确率得到大幅度的提升，但是他的速度却十分的被大家所诟病。试想一下，两千个建议框，每个都需要针对性的提取特征图，这个过程很慢，很慢，很慢。



所以呢，就思考能不能更快，更强。显而易见，这种东西是存在的。于是名字很俗气，但是更快更强的fast r-cnn就这么被提出来...

			
		

	





	

		

			

				
					
Fast RCNN的训练与测试

				
			

			

				

					葉的博客
				

				

					03-12
					
					5001
					
				

			

		

		

			
				
1.准备工作1.1软件准备首先，需要安装Caffe和pycaffe。caffe原作者网页：//caffe.berkeleyvision.org/installation.html注意：必须在Makefile.config配置文件中打开Python层支持。# In your Makefile.config, make sure to have this lineuncomm...

			
		

	





	

		

			

				
					
Fast RCNN算法详解

					
热门推荐

				
			

			

				

					AI之路
				

				

					06-03
					
					11万+
					
				

			

		

		

			
				
这篇博文来介绍Fast RCNN，是RCNN算法的升级版。RCNN系列算法看完后才写的这篇博客，相信初学者会比较容易这篇算法。论文：Fast R-CNN 
论文链接解决的问题： 
之所以提出Fast R-CNN，主要是因为R-CNN存在以下几个问题：1、训练分多步。通过上一篇博文我们知道R-CNN的训练先要fine tuning一个预训练的网络，然后针对每个类别都训练一个SVM分类器，最后还要用re

			
		

	





	

		

			

				
					
目标检测：速度和准确性比较（Fater R-CNN，R-FCN，SSD，FPN，RetinaNet和YOLOv3）

				
			

			

				

					zero的博客
				

				

					11-14
					
					8484
					
				

			

		

		

			
				
点击上方“AI算法与图像处理”，选择加"星标"或“置顶”重磅干货，第一时间送达推荐文章【点击下面可直接跳转】：文章来源：https://zhuanlan.zhihu.co...

			
		

	





	

		

			

				
					
Object Detection(2):Fast R-CNN

				
			

			

				

					fish的专栏
				

				

					10-15
					
					1494
					
				

			

		

		

			
				
RCNN后续,fast-rcnn

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值