R-FCN+ResNet-50训练自己的数据(python版本)

最新推荐文章于 2024-07-29 13:51:54 发布
最新推荐文章于 2024-07-29 13:51:54 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： 深度学习 文章标签： 深度学习 r-fcn python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaogw93/article/details/78328122
版权

一、准备工作

1.下载py-R-FCN

git clone https://github.com/Orpine/py-R-FCN.git
下面把py-R-FCN路径设置为$RFCN_ROOT 
export RFCN_ROOT=/home/liufeng/py-R-FCN
想取消该环境变量则 
reset RFCN_ROOT



2.配置caffe环境

（1）下载微软版本caffe

cd $RFCN_ROOT  
git clone https://github.com/Microsoft/caffe.git

（2）Build Cython 

cd $RFCN_ROOT/lib  
make -j8
（3）Build caffe 和 pycaffe

cd $RFCN_ROOT/caffe  
cp Makefile.config.example Makefile.config


修改Makefile.config:

将下面代码前面的#去掉

# USE_CUDNN:=1

# USE_OPENCV:=1

# WITH_PYTHON_LAYER:=1


把下面的代码

INCLUDE_DIRS := $(PYTHON_INCLUDE) /usr/local/include

LIBRARY_DIRS := $(PYTHON_LIB) /usr/local/lib /usr/lib

改成

INCLUDE_DIRS := $(PYTHON_INCLUDE) /usr/local/include /usr/include/hdf5/serial

LIBRARY_DIRS := $(PYTHON_LIB) /usr/local/lib /usr/lib /usr/lib/x86_64-linux-gnu /usr/lib/x86_64-linux-gnu/hdf5/serial


编译之前最好检查一下python依赖包是否齐全： 

cd caffe/python
for req in $(cat requirements.txt); do sudo pip install $req;done


然后make一下

cd $RFCN_ROOT/caffe  
make -j8 && make pycaffe

如果一切正常的话，python代码会自动添加环境变量 $RFCN_ROOT/caffe/python，否则，你需要自己添加环境变量：

sudo gedit ~/.bashrc

将export PYTHONPATH=~/py-R-FCN/caffe/python:$PYTHONPATH添加到文件的最后

source ~/.bashrc 使更改生效

进入python编程环境，用import caffe 测试。

二、训练自己的数据集

1.下载VOC数据集

在data目录下下载 

wget http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtrainval_06-Nov-2007.tar
wget http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtest_06-Nov-2007.tar
wget http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCdevkit_08-Jun-2007.tar
wget http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar
解压 
tar xvf VOCtrainval_06-Nov-2007.tar
tar xvf VOCtest_06-Nov-2007.tar
tar xvf VOCdevkit_08-Jun-2007.tar
tar xvf VOCtrainval_11-May-2012.tar

把VOCdevkit文件夹重命名为VOCdevkit0712，然后在该文件夹下创建VOC0712文件夹，然后在该文件夹下放你的VOC格式的数据集。

在data/VOCdevkit0712/results文件夹下创建VOC0712文件夹，然后不用管它。


修改$RFCN\experiments\scripts\rfcn_end2end_ohem.sh成如下模式:

case $DATASET in  
  pascal_voc)  
    TRAIN_IMDB="voc_0712_trainval"  
    TEST_IMDB="voc_0712_test"  
    PT_DIR="pascal_voc"  
    ITERS=110000

迭代次数也是在这里修改。


2.下载预训练模型


选用ResNet-50-model.caffemodel。下载地址：链接: https://pan.baidu.com/s/1nvSi4uH 密码: w2tv

在data文件夹下创建imagenet_models文件夹，将下载好的模型放到该文件夹下。


3.修改网络参数


打开$RFCN_ROOT/models/pascal_voc/ResNet-50/rfcn_end2end

修改的参数cls_num指的是你数据集的类别数+1（背景）。比如我有3类，+1类背景，cls_num=4.


（1）修改class-aware/train_ohem.prototxt
layer {  
  name: 'input-data'  
  type: 'Python'  
  top: 'data'  
  top: 'im_info'  
  top: 'gt_boxes'  
  python_param {  
    module: 'roi_data_layer.layer'  
    layer: 'RoIDataLayer'  
    param_str: "'num_classes': 4" #cls_num  
  }  
}  
layer {  
  name: 'roi-data'  
  type: 'Python'  
  bottom: 'rpn_rois'  
  bottom: 'gt_boxes'  
  top: 'rois'  
  top: 'labels'  
  top: 'bbox_targets'  
  top: 'bbox_inside_weights'  
  top: 'bbox_outside_weights'  
  python_param {  
    module: 'rpn.proposal_target_layer'  
    layer: 'ProposalTargetLayer'  
    param_str: "'num_classes': 4" #cls_num  
  }  
}  
layer {  
    bottom: "conv_new_1"  
    top: "rfcn_cls"  
    name: "rfcn_cls"  
    type: "Convolution"  
    convolution_param {  
        num_output: 196 #cls_num*(score_maps_size^2)  4*(7^2)
        kernel_size: 1  
        pad: 0  
        weight_filler {  
            type: "gaussian"  
            std: 0.01  
        }  
        bias_filler {  
            type: "constant"  
            value: 0  
        }  
    }  
    param {  
        lr_mult: 1.0  
    }  
    param {  
        lr_mult: 2.0  
    }  
}  
layer {  
    bottom: "conv_new_1"  
    top: "rfcn_bbox"  
    name: "rfcn_bbox"  
    type: "Convolution"  
    convolution_param {  
        num_output: 786 #4*cls_num*(score_maps_size^2)  4*196
        kernel_size: 1  
        pad: 0  
        weight_filler {  
            type: "gaussian"  
            std: 0.01  
        }  
        bias_filler {  
            type: "constant"  
            value: 0  
        }  
    }  
    param {  
        lr_mult: 1.0  
    }  
    param {  
        lr_mult: 2.0  
    }  
}  
layer {  
    bottom: "rfcn_cls"  
    bottom: "rois"  
    top: "psroipooled_cls_rois"  
    name: "psroipooled_cls_rois"  
    type: "PSROIPooling"  
    psroi_pooling_param {  
        spatial_scale: 0.0625  
        output_dim: 4  #cls_num  
        group_size: 7  
    }  
}  
layer {  
    bottom: "rfcn_bbox"  
    bottom: "rois"  
    top: "psroipooled_loc_rois"  
    name: "psroipooled_loc_rois"  
    type: "PSROIPooling"  
    psroi_pooling_param {  
        spatial_scale: 0.0625  
        output_dim: 16 #4*cls_num  
        group_size: 7  
    }  
}

（2）修改class-aware/test.prototxt

layer {  
    bottom: "conv_new_1"  
    top: "rfcn_cls"  
    name: "rfcn_cls"  
    type: "Convolution"  
    convolution_param {  
        num_output: 196 #cls_num*(score_maps_size^2)  
        kernel_size: 1  
        pad: 0  
        weight_filler {  
            type: "gaussian"  
            std: 0.01  
        }  
        bias_filler {  
            type: "constant"  
            value: 0  
        }  
    }  
    param {  
        lr_mult: 1.0  
    }  
    param {  
        lr_mult: 2.0  
    }  
}  
layer {  
    bottom: "conv_new_1"  
    top: "rfcn_bbox"  
    name: "rfcn_bbox"  
    type: "Convolution"  
    convolution_param {  
        num_output: 786 #4*cls_num*(score_maps_size^2)  
        kernel_size: 1  
        pad: 0  
        weight_filler {  
            type: "gaussian"  
            std: 0.01  
        }  
        bias_filler {  
            type: "constant"  
            value: 0  
        }  
    }  
    param {  
        lr_mult: 1.0  
    }  
    param {  
        lr_mult: 2.0  
    }  
}  
layer {  
    bottom: "rfcn_cls"  
    bottom: "rois"  
    top: "psroipooled_cls_rois"  
    name: "psroipooled_cls_rois"  
    type: "PSROIPooling"  
    psroi_pooling_param {  
        spatial_scale: 0.0625  
        output_dim: 4  #cls_num  
        group_size: 7  
    }  
}  
layer {  
    bottom: "rfcn_bbox"  
    bottom: "rois"  
    top: "psroipooled_loc_rois"  
    name: "psroipooled_loc_rois"  
    type: "PSROIPooling"  
    psroi_pooling_param {  
        spatial_scale: 0.0625  
        output_dim: 16  #4*cls_num  
        group_size: 7  
    }  
}  
layer {  
    name: "cls_prob_reshape"  
    type: "Reshape"  
    bottom: "cls_prob_pre"  
    top: "cls_prob"  
    reshape_param {  
        shape {  
            dim: -1  
            dim: 4  #cls_num  
        }  
    }  
}  
layer {  
    name: "bbox_pred_reshape"  
    type: "Reshape"  
    bottom: "bbox_pred_pre"  
    top: "bbox_pred"  
    reshape_param {  
        shape {  
            dim: -1  
            dim: 16  #4*cls_num  
        }  
    }  
}

（3）修改train_agnostic.prototxt

layer {  
  name: 'input-data'  
  type: 'Python'  
  top: 'data'  
  top: 'im_info'  
  top: 'gt_boxes'  
  python_param {  
    module: 'roi_data_layer.layer'  
    layer: 'RoIDataLayer'  
    param_str: "'num_classes': 4"  #cls_num  
  }  
}  
layer {  
    bottom: "conv_new_1"  
    top: "rfcn_cls"  
    name: "rfcn_cls"  
    type: "Convolution"  
    convolution_param {  
        num_output: 196 #cls_num*(score_maps_size^2)   ###  
        kernel_size: 1  
        pad: 0  
        weight_filler {  
            type: "gaussian"  
            std: 0.01  
        }  
        bias_filler {  
            type: "constant"  
            value: 0  
        }  
    }  
    param {  
        lr_mult: 1.0  
    }  
    param {  
        lr_mult: 2.0  
    }  
}  
layer {  
    bottom: "rfcn_cls"  
    bottom: "rois"  
    top: "psroipooled_cls_rois"  
    name: "psroipooled_cls_rois"  
    type: "PSROIPooling"  
    psroi_pooling_param {  
        spatial_scale: 0.0625  
        output_dim: 4 #cls_num   ###  
        group_size: 7  
    }  
}

（4）修改train_agnostic_ohem.prototxt

layer {  
  name: 'input-data'  
  type: 'Python'  
  top: 'data'  
  top: 'im_info'  
  top: 'gt_boxes'  
  python_param {  
    module: 'roi_data_layer.layer'  
    layer: 'RoIDataLayer'  
    param_str: "'num_classes': 4" #cls_num ###  
  }  
}  
layer {  
    bottom: "conv_new_1"  
    top: "rfcn_cls"  
    name: "rfcn_cls"  
    type: "Convolution"  
    convolution_param {  
        num_output: 196 #cls_num*(score_maps_size^2)   ###  
        kernel_size: 1  
        pad: 0  
        weight_filler {  
            type: "gaussian"  
            std: 0.01  
        }  
        bias_filler {  
            type: "constant"  
            value: 0  
        }  
    }  
    param {  
        lr_mult: 1.0  
    }  
    param {  
        lr_mult: 2.0  
    }  
} 
layer {  
    bottom: "rfcn_cls"  
    bottom: "rois"  
    top: "psroipooled_cls_rois"  
    name: "psroipooled_cls_rois"  
    type: "PSROIPooling"  
    psroi_pooling_param {  
        spatial_scale: 0.0625  
        output_dim: 4 #cls_num   ###  
        group_size: 7  
    }  
}

（5）修改test_agnostic.prototxt

layer {  
    bottom: "conv_new_1"  
    top: "rfcn_cls"  
    name: "rfcn_cls"  
    type: "Convolution"  
    convolution_param {  
        num_output: 196 #cls_num*(score_maps_size^2) ###  
        kernel_size: 1  
        pad: 0  
        weight_filler {  
            type: "gaussian"  
            std: 0.01  
        }  
        bias_filler {  
            type: "constant"  
            value: 0  
        }  
    }  
    param {  
        lr_mult: 1.0  
    }  
    param {  
        lr_mult: 2.0  
    }  
}  
layer {  
    bottom: "rfcn_cls"  
    bottom: "rois"  
    top: "psroipooled_cls_rois"  
    name: "psroipooled_cls_rois"  
    type: "PSROIPooling"  
    psroi_pooling_param {  
        spatial_scale: 0.0625  
        output_dim: 4 #cls_num   ###  
        group_size: 7  
    }  
}  
layer {  
    name: "cls_prob_reshape"  
    type: "Reshape"  
    bottom: "cls_prob_pre"  
    top: "cls_prob"  
    reshape_param {  
        shape {  
            dim: -1  
            dim: 4 #cls_num   ###  
        }  
    }  
}


4.修改代码


(1) $RFCN/lib/datasets/pascal_voc.py

 
class pascal_voc(imdb):  
    def __init__(self, image_set, year, devkit_path=None):  
        imdb.__init__(self, 'voc_' + year + '_' + image_set)  
        self._year = year  
        self._image_set = image_set  
        self._devkit_path = self._get_default_path() if devkit_path is None \  
                            else devkit_path  
        self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year)  
        self._classes = ('__background__', # always index 0  
                         '你的标签1','你的标签2',你的标签3','你的标签4'  
                      )

(2) $RFCN_ROOT/lib/datasets/imdb.py

在一行代码为 boxes[:, 2] = widths[i] - oldx1 - 1下加入代码： 
for b in range(len(boxes)):
    if boxes[b][2]< boxes[b][0]:
        boxes[b][0] = 0


5.开始训练


cd $RFCN_ROOT  
./experiments/scripts/rfcn_end2end_ohem.sh 0 ResNet-50 pascal_voc

6.demo


将训练得到的模型($ RFCN_ROOT/output/rfcn_end2end_ohem/voc_0712_trainval里最后的caffemodel)拷贝到$ RFCN_ROOT/data/rfcn_models下，然后打开$ RFCN_ROOT/tools/demo_rfcn.py，将CLASSES修改成你的标签，NETS修改成你的model，im_names修改成你的测试图片(放在data/demo下),最后： 
cd $RFCN_ROOT  
./tools/demo_rfcn.py --net ResNet-50












夕阳赖在墙头
关注
专栏目录
FCN + ResNet50
weixin_42717395的博客
03-18 7625
为了解决语义级别的图像分割问题，FCN（全卷积网络）对图像进行了像素级的分类。FCN在经过前级的卷积下采样后，采用了反卷积层对卷积得到的最后一个feature map进行上采样，使它恢复到输入图像的尺寸。FCN对每个像素都进行分类，同时保留了原始输入图像的空间信息。最后逐像素计算softmax分类损失，下图为FCN的结构示意图： 我们此次采用了Caffe这一深度学习框架对FCN进行了实现，分...
R-FCN+ResNet-50用自己的数据集训练模型(python版本)
热门推荐
小咸鱼_的博客
11-17 4万+
说明： 本文假设你已经做好数据集，格式和VOC2007一致，并且Linux系统已经配置好caffe所需环境（博客里教程很多），下面是训练的一些修改。 py-R-FCN源码下载地址： https://github.com/Orpine/py-R-FCN 也有Matlab版本： https://github.com/daijifeng001/R-FCN 本文用到的是pyth
ResNet50_ResNet_resnet50_pythonresnet50_
10-01
Resnet50卷积神经网络训练模型，python语言编程，粗略训练，入门难度。
ResNet50：通过构建ResNet训练自己的数据集
最新发布
2302_82050581的博客
07-29 595
然后就到了最重要的构建resnet50网络的环节，如果要使用预训练的训练权重有完全不同的方法，预训练的权重在torchvision上有传入的代码，imagenet同理也有。先进行设备检查，tensorflow和pytorch的cuda不一样，pytorch上的cuda有效不代表tf上就可以。加载训练集和验证集，由于imagenet上的训练集很大，可以直接从训练集中划分，或者使用自带的验证集。数据集选择imagenet上的100类别，可以直接下载，不用额外传入。
keras resnet 训练自己的数据
04-30
keras resnet 迁移训练数据 和 读取数据
利用python一层一层可视化卷积神经网络，以ResNet50为例
qq_38410428的博客
12-27 1万+
引言 一直以来，卷积神经网络对人们来说都是一个黑箱，我们只知道它识别图片准确率很惊人，但是具体是怎么做到的，它究竟使用了什么特征来分辨图像，我们一无所知。无数的学者、研究人员都想弄清楚CNN内部运作的机制，甚至试图找到卷积神经网络和生物神经网络的联系。2013年，纽约大学的Matthew Zeiler和Rob Fergus的论文Visualizing and Understanding Conv...
resnet50代码_使用Python代码进行图像分类的顶级4个预训练模型
weixin_39584529的博客
11-27 1183
介绍人脑可以轻松识别和区分图像中的对象。例如，给定猫和狗的图像，在十亿分之一秒之内，我们就将两者区别开来，而我们的大脑则意识到了这种差异。如果机器模仿这种行为，那么它与我们所能获得的人工智能非常接近。随后，计算机视觉领域旨在模仿人类视觉系统，并且有许多里程碑打破了这方面的障碍。此外，如今的机器可以轻松地区分不同的图像，检测物体和面部，甚至生成不存在的人的图像！令人着迷，不是吗？当我从Compute...
py-R-FCN的ResNet50和ResNet101预训练模型
02-21
ResNet-50和ResNet-101是ResNet的不同版本，分别具有50层和101层的深度。更深层次的网络可以捕获更复杂的特征，但同时训练难度也会增加。ResNet系列在ImageNet分类任务上取得了很好的性能，并且被广泛应用于各种...
R-FCN + ResNet + Python + 训练自己的模型
I AM BACK
01-08 9059
安装MS Caffe 测试Demo 训练自己的模型的准备工作 训练 参考链接安装MS Caffe假设你已经装好了CUDA，cudnn，caffe等等。 这一步感觉和faster rcnn很像，都需要独特版本的caffe。这里的版本就是Microsoft的caffe。 pip install cython pip install easydict apt-get install py
py-R-FCN的预训练模型
01-08
解压后获得的两个预训练模型文件——`resnet50_rfcn_final.caffemodel`和`resnet101_rfcn_final.caffemodel`，分别基于ResNet-50和ResNet-101架构。ResNet是由He等人在2015年提出的，通过引入残差块解决了深度网络...
Nvidia jetson-inference Hello AI World Networks — FCN-ResNet18-MHP-640x360.zip
05-18
在FCN-ResNet18-MHP网络中，ResNet18是基础的网络结构，它通过残差块(Residual Block)解决了深度网络训练中的梯度消失问题，提升了模型的训练效果。 ResNet18是ResNet系列的一个变种，具有18个卷积层，相比于更深...
RESNet50+FCN模型文件
03-06
RESNet50+FCN train模型文件
RESNET、GOOGLENET等Python代码实现
07-19
懒得描述了，ResNet,GoogleNet等网络结构的Python实现，很好的资源
残差网络Python程序实现
12-02
此程序是一个残差网络的程序，此文件中含有的功能可以让初学者用来学习和了解残差网络的基本原理和实现过程
python res_利用python一层一层可视化卷积神经网络，以ResNet50为例
weixin_39861918的博客
12-04 900
引言一直以来，卷积神经网络对人们来说都是一个黑箱，我们只知道它识别图片准确率很惊人，但是具体是怎么做到的，它究竟使用了什么特征来分辨图像，我们一无所知。无数的学者、研究人员都想弄清楚CNN内部运作的机制，甚至试图找到卷积神经网络和生物神经网络的联系。2013年，纽约大学的Matthew Zeiler和Rob Fergus的论文Visualizing and Understanding Convol...
初探TVM--通过TVM的python接口编译优化resnet50
shaojie_wang的博客
12-16 2540
通过TVM的python接口编译优化resnet50
【Python】OpenCV-使用ResNet50进行图像分类
linjiuxiansheng的博客
03-04 942
如何使用ResNet50模型对图像进行分类。
Python基于卷积神经网络分类模型(ResNet50分类算法)实现生活垃圾分类项目实战
张陈亚的博客
07-04 973
Python基于卷积神经网络分类模型(ResNet50分类算法)实现生活垃圾分类项目实战
DL with python(17)——tensorflow实现ResNet
qq_36108664的博客
07-30 486
本文涉及到的是中国大学慕课《人工智能实践：Tensorflow笔记》第五讲第15节的内容，对tensorflow环境下经典卷积神经网络的搭建进行介绍，其基础是DL with python(14)——tensorflow实现CNN的“八股”中的代码，将其中第三步的代码替换为本文中的代码均可直接运行，其他部分无需改变。 经典的卷积神经网络有以下几种，这里介绍结构较为复杂的ResNet，其实现的方法也相对困难。 ResNet ResNet诞生于2015年，当年ImageNet竞赛冠军，Top5错误率为3.57%
PS-FCN什么神经网络
11-29
PS-FCN是一种用于语义分割的神经网络，它是基于Fully Convolutional Networks (FCN)的改进版本。PS-FCN的全称是Pyramid Scene Parsing Network，它在FCN的基础上增加了金字塔池化模块，可以更好地处理不同尺度的物体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值