caffe实战（2）——FCN训练自制数据集的过程和相关文件的配置

于 2020-10-06 20:00:03 发布
阅读量305 收藏 2
点赞数 1
文章标签： python 深度学习 caffe
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44021446/article/details/108275092
版权

1.caffe环境

默认caffe环境已经搭好了，如果没有搭好的可以参考以下链接

https://blog.csdn.net/weixin_44021446/article/details/107783507

2.FCN模型

参考上一篇博客第二部分，这里贴出链接

https://blog.csdn.net/weixin_44021446/article/details/107783507

3.相关文件的修改

3.1 train.prototxt修改

以voc-fcn8s为例，下面先给出我修改后的train.prototxt文件。

在这里插入图片描述

我数据存放的文件路径是：

|- voc-fcn8s
	|- data
		|- test
		|- train
		|- test.txt
		|- train.txt
	|- train.prototxt
	|- val.prototxt
	|- solve.py
	......

大家可以根据自己的实际路径对train.prototxt进行修改。

值得注意的是，这个地方的均值为BGR顺序进行填写的，填的时候需要注意一下顺序。

具体的均值计算可以参考以下链接：
数据集均值计算

接下来修改类别数和输出层
在这里插入图片描述
文件中关于类别数的都要进行对应修改。修改为类别数的时候记住要顺带这修改这个层的名字，与预训练权重的层进行区分，具体可以参考上图，原理是一样的。

3.2 val.prototxt修改

val.prototxt文件等修改和train.prototxt一个原理，这里贴出我的修改后文件。

layer {
  name: "data"
  type: "Python"
  top: "data"
  top: "label"
  python_param {
    module: "voc_layers"
    layer: "VOCSegDataLayer"
    param_str: "{\'voc_dir\': \'./data\', \'seed\': 1337, \'split\': \'test\', \'mean\': (147.304, 144.651, 138.971)}"
  }
}
layer {
  name: "conv1_1"
  type: "Convolution"
  bottom: "data"
  top: "conv1_1"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 64
    pad: 100
    kernel_size: 3
    stride: 1
  }
}
layer {
  name: "relu1_1"
  type: "ReLU"
  bottom: "conv1_1"
  top: "conv1_1"
}
layer {
  name: "conv1_2"
  type: "Convolution"
  bottom: "conv1_1"
  top: "conv1_2"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 64
    pad: 1
    kernel_size: 3
    stride: 1
  }
}
layer {
  name: "relu1_2"
  type: "ReLU"
  bottom: "conv1_2"
  top: "conv1_2"
}
layer {
  name: "pool1"
  type: "Pooling"
  bottom: "conv1_2"
  top: "pool1"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "conv2_1"
  type: "Convolution"
  bottom: "pool1"
  top: "conv2_1"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 128
    pad: 1
    kernel_size: 3
    stride: 1
  }
}
layer {
  name: "relu2_1"
  type: "ReLU"
  bottom: "conv2_1"
  top: "conv2_1"
}
layer {
  name: "conv2_2"
  type: "Convolution"
  bottom: "conv2_1"
  top: "conv2_2"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 128
    pad: 1
    kernel_size: 3
    stride: 1
  }
}
layer {
  name: "relu2_2"
  type: "ReLU"
  bottom: "conv2_2"
  top: "conv2_2"
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "conv2_2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "conv3_1"
  type: "Convolution"
  bottom: "pool2"
  top: "conv3_1"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 256
    pad: 1
    kernel_size: 3
    stride: 1
  }
}
layer {
  name: "relu3_1"
  type: "ReLU"
  bottom: "conv3_1"
  top: "conv3_1"
}
layer {
  name: "conv3_2"
  type: "Convolution"
  bottom: "conv3_1"
  top: "conv3_2"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 256
    pad: 1
    kernel_size: 3
    stride: 1
  }
}
layer {
  name: "relu3_2"
  type: "ReLU"
  bottom: "conv3_2"
  top: "conv3_2"
}
layer {
  name: "conv3_3"
  type: "Convolution"
  bottom: "conv3_2"
  top: "conv3_3"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 256
    pad: 1
    kernel_size: 3
    stride: 1
  }
}
layer {
  name: "relu3_3"
  type: "ReLU"
  bottom: "conv3_3"
  top: "conv3_3"
}
layer {
  name: "pool3"
  type: "Pooling"
  bottom: "conv3_3"
  top: "pool3"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "conv4_1"
  type: "Convolution"
  bottom: "pool3"
  top: "conv4_1"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 512
    pad: 1
    kernel_size: 3
    stride: 1
  }
}
layer {
  name: "relu4_1"
  type: "ReLU"
  bottom: "conv4_1"
  top: "conv4_1"
}
layer {
  name: "conv4_2"
  type: "Convolution"
  bottom: "conv4_1"
  top: "conv4_2"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 512
    pad: 1
    kernel_size: 3
    stride: 1
  }
}
layer {
  name: "relu4_2"
  type: "ReLU"
  bottom: "conv4_2"
  top: "conv4_2"
}
layer {
  name: "conv4_3"
  type: "Convolution"
  bottom: "conv4_2"
  top: "conv4_3"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 512
    pad: 1
    kernel_size: 3
    stride: 1
  }
}
layer {
  name: "relu4_3"
  type: "ReLU"
  bottom: "conv4_3"
  top: "conv4_3"
}
layer {
  name: "pool4"
  type: "Pooling"
  bottom: "conv4_3"
  top: "pool4"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "conv5_1"
  type: "Convolution"
  bottom: "pool4"
  top: "conv5_1"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 512
    pad: 1
    kernel_size: 3
    stride: 1
  }
}
layer {
  name: "relu5_1"
  type: "ReLU"
  bottom: "conv5_1"
  top: "conv5_1"
}
layer {
  name: "conv5_2"
  type: "Convolution"
  bottom: "conv5_1"
  top: "conv5_2"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 512
    pad: 1
    kernel_size: 3
    stride: 1
  }
}
layer {
  name: "relu5_2"
  type: "ReLU"
  bottom: "conv5_2"
  top: "conv5_2"
}
layer {
  name: "conv5_3"
  type: "Convolution"
  bottom: "conv5_2"
  top: "conv5_3"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 512
    pad: 1
    kernel_size: 3
    stride: 1
  }
}
layer {
  name: "relu5_3"
  type: "ReLU"
  bottom: "conv5_3"
  top: "conv5_3"
}
layer {
  name: "pool5"
  type: "Pooling"
  bottom: "conv5_3"
  top: "pool5"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "fc6"
  type: "Convolution"
  bottom: "pool5"
  top: "fc6"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 4096
    pad: 0
    kernel_size: 7
    stride: 1
  }
}
layer {
  name: "relu6"
  type: "ReLU"
  bottom: "fc6"
  top: "fc6"
}
layer {
  name: "drop6"
  type: "Dropout"
  bottom: "fc6"
  top: "fc6"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc7"
  type: "Convolution"
  bottom: "fc6"
  top: "fc7"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 4096
    pad: 0
    kernel_size: 1
    stride: 1
  }
}
layer {
  name: "relu7"
  type: "ReLU"
  bottom: "fc7"
  top: "fc7"
}
layer {
  name: "drop7"
  type: "Dropout"
  bottom: "fc7"
  top: "fc7"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "score_fr_n2"
  type: "Convolution"
  bottom: "fc7"
  top: "score_fr"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 2
    pad: 0
    kernel_size: 1
    
  }
}
layer {
  name: "upscore2_n2"
  type: "Deconvolution"
  bottom: "score_fr"
  top: "upscore2"
  param {
    lr_mult: 0
  }
  convolution_param {
    num_output: 2
    bias_term: false
    kernel_size: 4
    stride: 2
  }
}
layer {
  name: "score_pool4_n2"
  type: "Convolution"
  bottom: "pool4"
  top: "score_pool4"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 2
    pad: 0
    kernel_size: 1
    
  }
}
layer {
  name: "score_pool4c"
  type: "Crop"
  bottom: "score_pool4"
  bottom: "upscore2"
  top: "score_pool4c"
  crop_param {
    axis: 2
    offset: 5
  }
}
layer {
  name: "fuse_pool4"
  type: "Eltwise"
  bottom: "upscore2"
  bottom: "score_pool4c"
  top: "fuse_pool4"
  eltwise_param {
    operation: SUM
  }
}
layer {
  name: "upscore_pool4_n2"
  type: "Deconvolution"
  bottom: "fuse_pool4"
  top: "upscore_pool4"
  param {
    lr_mult: 0
  }
  convolution_param {
    num_output: 2
    bias_term: false
    kernel_size: 4
    stride: 2
  }
}
layer {
  name: "score_pool3_n2"
  type: "Convolution"
  bottom: "pool3"
  top: "score_pool3"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 2
    pad: 0
    kernel_size: 1
    
  }
}
layer {
  name: "score_pool3c"
  type: "Crop"
  bottom: "score_pool3"
  bottom: "upscore_pool4"
  top: "score_pool3c"
  crop_param {
    axis: 2
    offset: 9
  }
}
layer {
  name: "fuse_pool3"
  type: "Eltwise"
  bottom: "upscore_pool4"
  bottom: "score_pool3c"
  top: "fuse_pool3"
  eltwise_param {
    operation: SUM
  }
}
layer {
  name: "upscore8_n2"
  type: "Deconvolution"
  bottom: "fuse_pool3"
  top: "upscore8"
  param {
    lr_mult: 0
  }
  convolution_param {
    num_output: 2
    bias_term: false
    kernel_size: 16
    stride: 8
  }
}
layer {
  name: "score"
  type: "Crop"
  bottom: "upscore8"
  bottom: "data"
  top: "score"
  crop_param {
    axis: 2
    offset: 31
  }
}
layer {
  name: "loss"
  type: "SoftmaxWithLoss"
  bottom: "score"
  bottom: "label"
  top: "loss"
  loss_param {
    ignore_label: 255
    normalize: false
  }
}

3.3 修改voc_layers.py文件

我的voc_layers.py文件还是直接给出来，文件中需要注意的地方我以注释的方式标出来，大家要根据自己的路径修改。

# -*- coding: utf-8 -*-
import caffe
 
import numpy as np
from PIL import Image
 
import random
 
class VOCSegDataLayer(caffe.Layer):
    """
    Load (input image, label image) pairs from PASCAL VOC
    one-at-a-time while reshaping the net to preserve dimensions.
    Use this to feed data to a fully convolutional network.
    """
 
    def setup(self, bottom, top):
        """
        Setup data layer according to parameters:
        - voc_dir: path to PASCAL VOC year dir
        - split: train / val / test
        - mean: tuple of mean values to subtract
        - randomize: load in random order (default: True)
        - seed: seed for randomization (default: None / current time)
        for PASCAL VOC semantic segmentation.
        example
        params = dict(voc_dir="/path/to/PASCAL/VOC2011",
            mean=(104.00698793, 116.66876762, 122.67891434),
            split="val")
        """
        # config
        params = eval(self.param_str)
        self.voc_dir = params['voc_dir']
        self.split = params['split']
        self.mean = np.array(params['mean'])
        self.random = params.get('randomize', True)
        self.seed = params.get('seed', None)
 
        # two tops: data and label
        if len(top) != 2:
            raise Exception("Need to define two tops: data and label.")
        # data layers have no bottoms
        if len(bottom) != 0:
            raise Exception("Do not define a bottom.")
 
        # load indices for images and labels
        split_f  = '{}/{}.txt'.format(self.voc_dir,
                self.split)#读入val.prototxt中数据层的voc_dir参数与split参数，笔者将test.txt直接放在了voc_dir下面，这样直接就能读取到test.txt文件中的内容
        self.indices = open(split_f, 'r').read().splitlines()#在这里获取test.txt中每一行的值(不带后缀的测试图像/标签名称)
        self.idx = 0
 
        # make eval deterministic
        if 'train' not in self.split:
            self.random = False
 
        # randomization: seed and pick
        if self.random:
            random.seed(self.seed)
            self.idx = random.randint(0, len(self.indices)-1)
 
 
    def reshape(self, bottom, top):
        # load image + label image pair
        self.data = self.load_image(self.indices[self.idx])
        self.label = self.load_label(self.indices[self.idx])
        # reshape tops to fit (leading 1 is for batch dimension)
        top[0].reshape(1, *self.data.shape)
        top[1].reshape(1, *self.label.shape)
 
 
    def forward(self, bottom, top):
        # assign output
        top[0].data[...] = self.data
        top[1].data[...] = self.label
 
        # pick next input
        if self.random:
            self.idx = random.randint(0, len(self.indices)-1)
        else:
            self.idx += 1
            if self.idx == len(self.indices):
                self.idx = 0
 
 
    def backward(self, top, propagate_down, bottom):
        pass
 
 
    def load_image(self, idx):
        """
        Load input image and preprocess for Caffe:
        - cast to float
        - switch channels RGB -> BGR
        - subtract mean
        - transpose to channel x height x width order
        """
        im = Image.open('{}/test/image/{}.png'.format(self.voc_dir, idx))#读入val.prototxt中数据层的voc_dir参数与test.txt中的某行内容，结合图片路径和图片格式，然后直接就能读取到一张图片，请大家按照自己的测试图片路径配置。
        in_ = np.array(im, dtype=np.float32)
        in_ = in_[:,:,::-1]
        in_ -= self.mean#印证了数据层中mean是按照BGR的顺序从前到后排列的
        in_ = in_.transpose((2,0,1))
        return in_
 
 
    def load_label(self, idx):
        """
        Load label image as 1 x height x width integer array of label indices.
        The leading singleton dimension is required by the loss.
        """
        im = Image.open('{}/test/label/{}.png'.format(self.voc_dir, idx))#读入val.prototxt中数据层的voc_dir参数与test.txt中的同一行内容，结合标签路径和标签格式，然后直接就能读取到一张同上文中测试图片对应的标签，请大家按照自己的测试标签路径配置。
        label = np.array(im, dtype=np.uint8)
        label = label[np.newaxis, ...]
        return label
 
 
class SBDDSegDataLayer(caffe.Layer):
    """
    Load (input image, label image) pairs from the SBDD extended labeling
    of PASCAL VOC for semantic segmentation
    one-at-a-time while reshaping the net to preserve dimensions.
    Use this to feed data to a fully convolutional network.
    """
 
    def setup(self, bottom, top):
        """
        Setup data layer according to parameters:
        - sbdd_dir: path to SBDD `dataset` dir
        - split: train / seg11valid
        - mean: tuple of mean values to subtract
        - randomize: load in random order (default: True)
        - seed: seed for randomization (default: None / current time)
        for SBDD semantic segmentation.
        N.B.segv11alid is the set of segval11 that does not intersect with SBDD.
        Find it here: https://gist.github.com/shelhamer/edb330760338892d511e.
        example
        params = dict(sbdd_dir="/path/to/SBDD/dataset",
            mean=(104.00698793, 116.66876762, 122.67891434),
            split="valid")
        """
        # config
        params = eval(self.param_str)
        self.sbdd_dir = params['sbdd_dir']
        self.split = params['split']
        self.mean = np.array(params['mean'])
        self.random = params.get('randomize', True)
        self.seed = params.get('seed', None)
 
        # two tops: data and label
        if len(top) != 2:
            raise Exception("Need to define two tops: data and label.")
        # data layers have no bottoms
        if len(bottom) != 0:
            raise Exception("Do not define a bottom.")
 
        # load indices for images and labels
        split_f  = '{}/{}.txt'.format(self.sbdd_dir,
                self.split)#读入train.prototxt中数据层的sbdd_dir参数与split参数，笔者将train.txt直接放在了voc_dir下面，这样直接就能读取到train.txt文件中的内容
        self.indices = open(split_f, 'r').read().splitlines()#在这里获取train.txt中每一行的值(不带后缀的训练图像/标签名称)
        self.idx = 0
 
        # make eval deterministic
        if 'train' not in self.split:
            self.random = False
 
        # randomization: seed and pick
        if self.random:
            random.seed(self.seed)
            self.idx = random.randint(0, len(self.indices)-1)
 
 
    def reshape(self, bottom, top):
        # load image + label image pair
        self.data = self.load_image(self.indices[self.idx])
        self.label = self.load_label(self.indices[self.idx])
        # reshape tops to fit (leading 1 is for batch dimension)
        top[0].reshape(1, *self.data.shape)
        top[1].reshape(1, *self.label.shape)
 
 
    def forward(self, bottom, top):
        # assign output
        top[0].data[...] = self.data
        top[1].data[...] = self.label
 
        # pick next input
        if self.random:
            self.idx = random.randint(0, len(self.indices)-1)
        else:
            self.idx += 1
            if self.idx == len(self.indices):
                self.idx = 0
 
 
    def backward(self, top, propagate_down, bottom):
        pass
 
 
    def load_image(self, idx):
        """
        Load input image and preprocess for Caffe:
        - cast to float
        - switch channels RGB -> BGR
        - subtract mean
        - transpose to channel x height x width order
        """
        im = Image.open('{}/train/image/{}.png'.format(self.sbdd_dir, idx))#读入train.prototxt中数据层的sdbb_dir参数与train.txt中的某行内容，结合图片路径和图片格式，然后直接就能读取到一张图片，请大家按照自己的训练图片路径配置。
        in_ = np.array(im, dtype=np.float32)
        in_ = in_[:,:,::-1]
        in_ -= self.mean#印证了数据层中mean是按照BGR的顺序从前到后排列的
        in_ = in_.transpose((2,0,1))
        return in_
 
#由于笔者的标签是.png格式，因此笔者重写了load_label函数，将.mat换成.png，并将format中的self.voc_dir换成了self.sbdd_dir，从这里可以看到，标签与图片是什么格式的都可以，只要能读取到即可。
    def load_label(self, idx):
        """
        Load label image as 1 x height x width integer array of label indices.
        The leading singleton dimension is required by the loss.
        """
        im = Image.open('{}/train/label/{}.png'.format(self.sbdd_dir, idx))#读入train.prototxt中数据层的sbdd_dir参数与train.txt中的同一行内容，结合标签路径和标签格式，然后直接就能读取到一张同上文中训练图片对应的标签，请大家按照自己的训练标签路径配置。
        label = np.array(im, dtype=np.uint8)
        label = label[np.newaxis, ...]
        return label
 
#笔者将原来读取mat的函数注释掉了
"""
    def load_label(self, idx):
        import scipy.io
        mat = scipy.io.loadmat('{}/cls/{}.mat'.format(self.sbdd_dir, idx))
        label = mat['GTcls'][0]['Segmentation'][0].astype(np.uint8)
        label = label[np.newaxis, ...]
        return label
"""

voc_layers.py文件是数据层，该文件协定了训练/测试的时候的数据读取。里面有两个类，一个叫VOCSegDataLayer，用于测试时的数据读取，一个叫SBDDSegDataLayer，用于训练时的数据读取。

在上面的代码中，读者朋友们可以看到，在数据层中我们写的sbdd_dir/voc_dir只是存放数据的根文件夹名称，split参数是训练/测试的txt文件名。而在voc_layers.py文件中，请读者朋友们注意上面的注释，这两个参数只是为了被当成字符串传入去读取数据集txt文件中的内容或者读取一张图片。

注意： 将修改好的voc_layer.py文件复制到caffe路径下的python文件夹中。

这个地方参考
FCN训练不收敛的原因分析和最详细的FCN训练与测试自己的数据程序配置

3.4 修改solver.py文件

import sys
sys.path.append('/home/fly/caffe/python')
import caffe
import surgery, score

import numpy as np
import os
import sys

try:
    import setproctitle
    setproctitle.setproctitle(os.path.basename(os.getcwd()))
except:
    pass

weights = '/home/fly/fcn.berkeleyvision.org/voc-fcn8s/fcn16s-heavy-pascal.caffemodel'

# init
caffe.set_device(int(0))
caffe.set_mode_gpu()

solver = caffe.SGDSolver('/home/fly/fcn.berkeleyvision.org/voc-fcn8s/solver.prototxt')
solver.net.copy_from(weights)

# surgeries
interp_layers = [k for k in solver.net.params.keys() if 'up' in k]
surgery.interp(solver.net, interp_layers)

# scoring
val = np.loadtxt('./data/test.txt', dtype=str)

for _ in range(20):
    solver.step(5000)
    score.seg_tests(solver, False, val, layer='score')

在这里插入图片描述

3.5 修改solover.prototxt文件

这个地方完用图片给出来

在这里插入图片描述

4.运行FCN去训练自制数据集

经过上面的配置，接下来我们可以去运行FCN去训练自制数据集。

运行方法是：python solver.py

在这里插入图片描述在这里插入图片描述

到这里，关于FCN训练自制数据集的过程和相关文件的配置就结束了。我们可以出上面看出来，loss在慢慢减小。如果你的loss减小效果不理想的话，可以尝试去调参，选择自己合适等超参数。

感谢以下博客的分享：

1.FCN训练不收敛的原因分析和最详细的FCN训练与测试自己的数据程序配置


2.FCN模型训练中遇到的困难


3.FCN语义分割训练自己数据不收敛处理记录

TF.Y
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
新版caffe FCN的使用教程
隐匿人海的博客
07-07 1万+
引言FCN的出现，大幅度改变了近两年来的CNN方向。之前我曾写过caffe版本FCN的使用。最近做实验正好要用到FCN，发现FCN的code已有较大改动。因此，记录一下新版FCN的使用和需要注意的地方。新版FCN的更新内容FCN的实现是caffe-future，现在主要的函数也已经合并到官方版本的caffe中。而FCN的训练测试代码在此处下载。总的来说，让大家对于FCN的使用更加简便，而无需自己将太
基于caffe的fcn网络的训练
xxiaozr的博客
07-02 7291
论文解读： global information 可以揭露 what , local information 揭露 where deep 分类网络当做预训练，微调网络，whole image 当做输入，whole image ground truth 是标签 损失函数是在最后一层的 spatial map上的 pixel 的 loss 和，在每一个 pixel 使用 softmax loss...
FCN训练自己的数据集
绅商的博客
01-11 7027
本人研究生，最近在做关于FCN的课题，因为要实现论文中的算法，所以自己要实现FCN，也参考了很多网络上的博客，自己做个小的总结，以及遇到的一些问题解决方案。 一、CAFFE的安装 这里我不赘述，因为有很多教程，大家可以参考： http://blog.csdn.net/Tang_DH/article/details/52556636 http://blog.csdn.net/xierha
配置FCN 8s voc数据集
koreyoshichen的博客
01-16 971
按着博文http://blog.csdn.net/u012968002/article/details/78958090 的流程走的  主要是各种路径要搞清楚 参见http://blog.csdn.net/supe_king/article/details/58121993 中间出现在网上找的方法个版本不管用  后来发现 还是路径的问题。 solve.py  的路径好确定  关键是train.
语义分割caffe-fcn算法
05-10
语义分割caffe-fcn算法，该算法使用pynotebook实现，分享方便实用
caffe训练5类图像数据集.zip
03-30
"caffe训练5类图像数据集.zip" 提供了一个针对5种不同类别的图像训练集，这五类分别是大巴车、恐龙、大象、鲜花和马，每种类别包含100张图片，这些图片被划分为训练集和测试集，其中训练集有80张，测试集有20张。...
数据集-使用caffe SSD制作VOC07112 lmdb数据集.pdf
最新发布
02-09
数据集 数据集_使用caffe SSD制作VOC07112 lmdb数据集
CAFFE.zip_caffe_caffe 批量测试_fcn_fcn caffe python_fcn 批量
07-15
在IT行业中，尤其是在深度学习领域，Caffe是一个广泛使用的开源框架，它专为速度和效率而设计。...记得在执行代码前，确保你的环境已经正确配置了Caffe库，并且拥有训练好的FCN模型及待测试的图像数据集。
caffe测试所用mnist数据集以及配置所需依赖包
04-21
5. **训练模型**：运行Caffe的`caffe train`命令，指定网络配置文件和解决器配置文件，以及数据源的数据库路径。 6. **测试模型**：训练完成后，使用`test`命令评估模型在测试集上的性能。 7. **使用Python接口**...
Windows下caffe安装详解(仅CPU) 训练测试mnist数据集
12-13
在Windows 7 64位环境下安装Caffe并进行CPU训练和测试MNIST数据集是一项初学者常会遇到的任务。Caffe是一个流行的深度学习框架，主要用于图像处理和计算机视觉任务，而MNIST数据集则是经典的图像分类问题，包含了...
caffe随记（八）---使用caffe训练FCN的pascalcontext-fcn32s模型（pascal-context数据集）
朝花&夕拾
08-14 4777
本篇讨论利用caffe进行FCN训练（采用的是pascal-context数据集） 补充：如何用FCN训练好的模型进行图像分割？参考我的另一篇博文： caffe随记（九）---利用FCN和已有的model进行图像语义分割；  http://blog.csdn.net/teeyohuang/article/details/77539912； 链接失效的话可以去我的博文目录里面查找，博
windows下训练FCN模型所遇到的问题
qq_34220460的博客
04-19 3784
在windows上借助caffe框架训练FCN模型
caffe随记（九）---利用FCN和已有的model进行图像语义分割
朝花&夕拾
08-24 3112
1、下载caffemodel 本例中我们使用的是pascalcontext-fcn32的模型，这个下载链接在它的文件夹里有，就是url那个文件 下载  pascalcontext-fcn32s-heavy.caffemodel 这个文件 2、增加python的路径 本次我使用的方法是 vim ~/.bashrc 在最后一行添加python路径，如下图，请根据自己的路径修改路径
caffe学习笔记28-全卷积网络FCN笔记
YiLiang
03-05 2455
caffe学习记录
R-FCN修改训练自己的数据
jicong44的博客
07-09 1418
源码链接：https://github.com/YuwenXiong/py-R-FCN 一 train_agnostic_ohem.prototxt 修改为对应的类别： 根据设置的anchor个数修改 根据设置的anchor个数修改 根据设置的anchor个数修改 这里只有两类，表示前景和背景： 根据设置的类别个数修改 不用改，只用与区分前景和背景 根...
caffe下使用FCN网络训练自制数据集实现语义分割
SUJI的博客
09-25 2579
       上周我尝试用自制数据集训练了一下FCN网络，特此记录。首先，要感谢我的几位师弟帮忙对图片进行标注，这部分工作量还是蛮大的，非常考验细心和耐心。 一、拍摄图片 首先我们拍摄了300张图片，同一类三种不同外观和形状的物体，每一种100张，拍摄的图片力求背景要多样化，而且物体也要分布在图片的不同位置。当然，这些图片的数量还是太少了，本次实验主要是走通FCN训练的流程。 二、Label...
R-FCN算法的Caffe实现
AI之路
06-03 3215
本博文介绍如何在Caffe上实现R-FCN，关于R-FN的算法讲解和Caffe代码详解可以参考另外一篇博客：Object Detection算法——R-FCN算法及Caffe代码详解git地址：https://github.com/Orpine/py-R-FCN 基本上按照这个git上的readme.md的流程进行并假设你本机的Caffe本来就可以正常使用，接下来详细讲解可能会遇到的坑：1、先从g
NetScope：基于 prototxt 可视化模型结构
Houchaoqun_XMU的博客
03-06 1702
NetScope：基于 prototxt 可视化模型结构。如果一个神经网络中，只有卷积层，输入的图像大小是可以任意的。如FCN，全卷积网络。如果一个神经网络中，既有卷积层，也有全连接层，那么输入的图像的大小必须是固定的。目前大部分常见的神经网络模型都带有全连接层，如LeNet、AlexNet、ResNet、google-net等等。
caffe下用FCN做图像分割,如何制作训练集?
玩也行的博客
03-07 7241
默认排序 铁胆火车侠 铁胆火车侠 西嗯嗯调参狗 / 博士申了三次 14 人赞同了该回答鉴于有太多人询问具体细节， 末尾更新了一下原答案：直接调用GitHub - shelhamer/fcn.berkeleyvision.org: Fully Convolutional Networks for Semantic Segmentation by Jonathan Long*, Evan She
"Caffe深度学习训练全过程及应用实例
总之，Caffe是一款功能强大且易于使用的深度学习框架，它的深度学习训练全过程包括了数据预处理、网络模型构建、训练参数配置、模型训练、模型评估和模型预测等多个步骤。通过掌握这些步骤，用户可以使用Caffe进行...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值