精华内容
下载资源
问答
  • fcn模型的搭建代码,可以根据这个代码实现fcn的搭建以及训练,测试
  • FCN代码解读

    2020-08-27 10:51:56
    1、全卷积神经网络FCN-TensorFlow代码精析https://blog.csdn.net/qq_16761599/article/details/80069824 很好 2、[深度学习] FCN在TensorFlow上的实现 ...

    参考博文:

    1、全卷积神经网络FCN-TensorFlow代码精析 https://blog.csdn.net/qq_16761599/article/details/80069824  很好

    2、[深度学习] FCN在TensorFlow上的实现   https://blog.csdn.net/weixin_41028208/article/details/81568310

    3、FCN8s 代码解析  https://blog.csdn.net/guvcolie/article/details/77145852

    4、【实验】FCN.tensorflow  https://zhuanlan.zhihu.com/p/32053317  里面有系列介绍文章 适合我这样的小白

    里面已经介绍的很详细,参考博文阅读就行,目前只能理解个大概,剩下的是实验验证,待后续。

    展开全文
  • FCN代码实践【1】

    千次阅读 2019-01-02 10:45:08
    我修改的fcn代码Github地址:https://github.com/yeLer/fcn 论文地址:https://arxiv.org/abs/1411.4038 这里说明一下这个文件和文件夹都是做什么的, data:是官方提供的四个数据集相关的文件,我们允许代码所...

    FCN 官方Github 地址:shelhamer/fcn.berkeleyvision.org

    我修改的fcn代码Github地址:https://github.com/yeLer/fcn

    论文地址:https://arxiv.org/abs/1411.4038

    这里说明一下这个文件和文件夹都是做什么的,

    data:是官方提供的四个数据集相关的文件,我们允许代码所下载的数据集都会放到这个里面

    demo:是官方代码提供的演示效果

    nyud,pascalcontext,sififlow,voc等四个数据集名称开头的文件夹是分别对应的caffe网络及训练参数文件,你拿对应的名称可以做对应的实验

    nyud_layer.py,pascalcontext_layer.py,sififlow_layer.py,voc_layer.py分别是四个数据集对应的训练层,需要哪个用哪个。

    infer.py:测试需要的文件

    score.py:求取分割得分的文件

    surgery.py:权重转换文件

    vis.py:可视化文件

    官方开源代码提供了PASCAL VOC models,SIFT Flow models,PASCAL-Context models的完整(32s,16s,8s)的代码,但对于NYUD只提供了32s的代码,这里我们就以NYUD作为例子说明一下FCN-8s训练的完整过程。

    源代码下载和数据集预处理

    进入到你的工程目录,下载官方源代码:

    git clone https://github.com/shelhamer/fcn.berkeleyvision.org.git

    下载VGG16的预训练模型并放在FCN源码文件夹中的ilsvrc-nets文件夹下:

    cd /fcn.berkeleyvision.org/ilsvrc-nets
    wget http://www.robots.ox.ac.uk/~vgg/software/very_deep/caffe/VGG_ILSVRC_16_layers.caffemodel

    获取与其相对应的deploy文件,同样也放到ilsvrc-nets文件夹下:

    wget https://gist.githubusercontent.com/ksimonyan/211839e770f7b538e2d8/raw/0067c9b32f60362c74f4c445a080beed06b07eb3/VGG_ILSVRC_16_layers_deploy.prototxt

    下载数据集:

    cd data/nyud/
    wget http://people.eecs.berkeley.edu/~sgupta/cvpr13/data.tgz
    tar -xvf data.tgz

     解压以后的文件夹名称分别为benchmarkData, colorImage, pointCloud.

    由于图片路径的变化,需要将colorImage重命名为images

    其中benchmarkData/groundTruth中储存这所有我们需要的分割的真值,colorImage文件夹储存着原始的RGB文件.由于源代码设置的groundTruth路径和现有的路径不一样,所以我们要把groundTruth文件copy到指定路径:

    mkdir segmentation
    cp data/benchmarkData/groundTruth/*.mat segmentation/

     我们还要合并train.txt和val.txt: 在nyud文件夹中新建一个空白的.txt文件并命名为trainval.txt,然后将train.txt和val.txt中的内容Copy过去.这个时候nyud文件夹应为是这个样子:

     FCN-32s网络训练:

    • 把要用到的.py文件Copy到nyud-fcn32s-color文件夹:包括nyud_layer.py,infer.py,score.py,surgery.py和vis.py
    • 修改solver.prototxt文件,下面是我个人的文件内容,关于相关参数的含义请参考:Caffe学习系列:solver及其配置
    train_net: "trainval.prototxt"
    test_net: "test.prototxt"
    test_iter: 200
    # make test net, but don't invoke it from the solver itself
    test_interval: 999999999
    display: 20
    average_loss: 20
    lr_policy: "fixed"
    # lr for unnormalized softmax
    base_lr: 1e-10
    # high momentum
    momentum: 0.99
    # no gradient accumulation
    iter_size: 1
    max_iter: 300000
    weight_decay: 0.0005
    snapshot: 5000
    snapshot_prefix: "snapshot/train"
    test_initialization: false

    其中打红色箭头的是该文件夹下默认有的py文件。

    我们对solve.py文件作出的修改如下:

    #coding: utf-8
    import caffe
    import surgery, score
    
    import numpy as np
    import os
    import sys
    
    try:
        import setproctitle
        setproctitle.setproctitle(os.path.basename(os.getcwd()))
    	#获得当前路径(返回最后的文件名)
        #比如os.getcwd()获得的当前路径为/home/bxx-yll/fcn,则os.path.basename()为fcn;
        #setproctitle是用来修改进程入口名称,如C++中入口为main()函数
    except:
        pass
    
    # weights = '../ilsvrc-nets/vgg16-fcn.caffemodel'
    vgg_weights = '../ilsvrc-nets/VGG_ILSVRC_16_layers.caffemodel'  #用来fine-tune的FCN参数
    vgg_proto = '../ilsvrc-nets/VGG_ILSVRC_16_layers_deploy.prototxt'    #VGGNet模型
    
    # init
    # caffe.set_device(int(sys.argv[1]))
    #获取命令行参数,其中sys.argv[0]为文件名,argv[1]为紧随其后的那个参数
    caffe.set_device(1) #GPU型号id,这里指定第二块GPU
    caffe.set_mode_gpu()
    
    # solver = caffe.SGDSolver('solver.prototxt')
    # solver.net.copy_from(weights)  # 这个方法仅仅是从vgg-16模型中拷贝参数,但是并没有改造原先的网络,这才是不收敛的根源
    solver = caffe.SGDSolver('solver.prototxt') #调用SGD(随即梯度下降)Solver方法,solver.prototxt为所需参数
    vgg_net = caffe.Net(vgg_proto, vgg_weights, caffe.TRAIN)  #vgg_net是原来的VGGNet模型(包括训练好的参数)
    surgery.transplant(solver.net, vgg_net)  #FCN模型(参数)与原来的VGGNet模型之间的转化
    del vgg_net  #删除VGGNet模型  
    
    # surgeries
    interp_layers = [k for k in solver.net.params.keys() if 'up' in k]   #interp_layers为upscore层
    surgery.interp(solver.net, interp_layers)  #将upscore层中每层的权重初始化为双线性内核插值。
    
    # scoring
    test = np.loadtxt('../data/nyud/test.txt', dtype=str)  #载入测试图片信息
    
    for _ in range(50):
        solver.step(2000)   #每2000次训练迭代执行后面的函数
        score.seg_tests(solver, False, test, layer='score')  #测试图片
    
    • 同时由于路径原因,需要修改nyud_layers.py中load_label function 的内容:

    在setup方法中加上红线指向的class_map定义 ,然后修改load_label方法

    # self.class_map = scipy.io.loadmat('{}/data/benchmarkData/metadata/classMapping40.mat'.format(self.nyud_dir))['mapClass'].astype(np.uint8)
    
    def load_label(self, idx):
            """
            Load label image as 1 x height x width integer array of label indices.
            Shift labels so that classes are 0-39 and void is 255 (to ignore it).
            The leading singleton dimension is required by the loss.
            """
            # label = scipy.io.loadmat('{}/segmentation/img_{}.mat'.format(self.nyud_dir, idx))['segmentation'].astype(np.uint8)
    	label = scipy.io.loadmat('{}/segmentation/img_{}.mat'.format(self.nyud_dir, idx))['groundTruth'][0,0][0,0]['SegmentationClass'].astype(np.uint16)
    	for (x,y), value in np.ndenumerate(label):
    		label[x,y] = self.class_map[0][value-1]
    	label = label.astype(np.uint8)
            label -= 1  # rotate labels
            label = label[np.newaxis, ...]
            return label
    

     

    • 以上配置全部结束,开始进行模型训练:
    cd nyud-fcn32s-color
    mkdir snapshot
    python solve.py

     大概迭代150000次以后,就可以达到论文描述的精度,这里我只训练了100000次。

    可以看到和原论文中的准确率已经很接近了。

    接下来利用生成的模型进行测试,修改infer.py文件如下,这里会用到测试时的deploy.prototxt文件。

    #!/usr/bin/env python
    # encoding: utf-8
    '''
    @author: lele Ye
    @contact: 1750112338@qq.com
    @software: pycharm 2018.2
    @file: infer.py
    @time: 2019/1/2 15:59
    @desc:
    '''
    import numpy as np
    from PIL import Image
    import matplotlib.pyplot as plt
    import scipy.io
    
    CAFFE_ROOT = "/home/bxx-yll/caffe"
    import sys
    
    sys.path.insert(0, CAFFE_ROOT + '/python')
    import caffe
    
    # the demo image is "2007_000129" from PASCAL VOC
    
    # load image, switch to BGR, subtract mean, and make dims C x H x W for Caffe
    im = Image.open('../demo/image.jpg')
    in_ = np.array(im, dtype=np.float32)
    in_ = in_[:, :, ::-1]
    in_ -= np.array((104.00698793, 116.66876762, 122.67891434))
    in_ = in_.transpose((2, 0, 1))
    
    # 加载网络文件,与模型文件,并设置为测试模式
    net = caffe.Net('./deploy.prototxt', './snapshot/train_iter_100000.caffemodel', caffe.TEST)
    # shape for input (data blob is N x C x H x W), set data
    net.blobs['data'].reshape(1, *in_.shape)
    net.blobs['data'].data[...] = in_
    
    # run net and take argmax for prediction
    net.forward()
    out = net.blobs['score'].data[0].argmax(axis=0)
    scipy.io.savemat('./out.mat', {'X': out})
    
    # visualize segmentation in PASCAL VOC colors
    plt.imshow(out)
    plt.show()
    plt.axis('off')
    plt.savefig('../demo/testout_32s.png')
    

    没有deploy文件,可以参考如下方法:
    首先,根据你利用的模型,例如模型是nyud-fcn32s-color的,那么你就去nyud-fcn32s-color的文件夹,里面有trainval.prototxt文件,将文件打开,全选,复制,新建一个名为deploy.prototxt文件,粘贴进去,然后ctrl+F 寻找所有名为loss的layer 将这个layer统统删除,并去除第一层的python层。

    实际上去除的是:

    layer {
      name: "data"
      type: "Python"
      top: "data"
      top: "label"
      python_param {
        module: "nyud_layers"
        layer: "NYUDSegDataLayer"
        param_str: "{\'tops\': [\'color\', \'label\'], \'seed\': 1337, \'nyud_dir\': \'../data/nyud\', \'split\': \'trainval\'}"
      }
    }
    
    layer {
      name: "loss"
      type: "SoftmaxWithLoss"
      bottom: "score"
      bottom: "label"
      top: "loss"
      loss_param {
        ignore_label: 255
        normalize: false
      }
    }

    然后在第一层添加的是:

    layer {
      name: "input"
      type: "Input"
      top: "data"
      input_param {
        # These dimensions are purely for sake of example;
        # see infer.py for how to reshape the net to the given input size.
        shape { dim: 1 dim: 3 dim: 480 dim: 640 }
      }
    }

    运行效果,由于我的迭代次数不够,没有完全收敛,可以看到与论文的效果还是有差距:

    展开全文
  • FCN代码实现

    千次阅读 2019-03-07 13:24:15
    仅仅针对TensorFlow平台 下载代码参考:...即下载:https://github.com/shekkizh/FCN.tensorflow 代码解释:https://blog.csdn.net/MOU_IT/article/details/81073149 运行时出现...

    仅仅针对TensorFlow平台

    下载代码参考:https://blog.csdn.net/scutjy2015/article/details/70230379

    即下载:https://github.com/shekkizh/FCN.tensorflow

    代码解释:https://blog.csdn.net/MOU_IT/article/details/81073149

     

    运行时出现如下error:

    解析发现如下log处就出错了,file为0 0

    发现原因是MITSceneParsing.pickle size太小,正常size应该是4595KB。

    MITSceneParsing.pickle可在如下处下载

    https://download.csdn.net/download/sousky/11004386

    展开全文
  • FCN代码解析

    千次阅读 多人点赞 2017-04-09 16:20:00
    FCN代码解析

    网上有许多FCN网络的安装和训练教程,但却没有代码解读的详细教程,这让我这种刚刚入门深度学习的萌新不知所措;为了弄清楚FCN,不知走了多少弯路,想把它记录下来,给自己看看,也希望能帮助到那些和我一样刚刚入门的人。
    以下只是小弟的一些拙见,若有错误与不足欢迎指出~
    话不多说,上代码:


    首先是solve.py文件,fcn没有用sh脚本去写训练文件,应该是和他自己写的surgery.py和score.py有关;里面有两个问题我希望有大牛可以帮忙解决:
    1. for _ in range(50):
    solver.step(2000)
    发现设置完这个以后solver.prototxt中设置的 max_iter失效;
    2. score.seg_tests(solver, False, test, layer=’score_sem’, gt=’sem’)
    score.seg_tests(solver, False, test, layer=’score_geo’, gt=’geo’)
    语义分割和几何分割的解读

    #solve.py
    
    import caffe
    import surgery, score
    
    import numpy as np
    import os                  #os模块封装了操作系统的目录和文件操作
    import sys
    
    try:
        import setproctitle
        setproctitle.setproctitle(os.path.basename(os.getcwd()#获得当前路径)#返回最后的文件名)
        #比如os.getcwd()获得的当前路径为/home/zhangrf/fcn,则os.path.basename()为fcn;
        #setproctitle是用来修改进程入口名称,如C++中入口为main()函数
    except:
        pass
    
    weights = '../ilsvrc-nets/vgg16-fcn.caffemodel'                   #用来fine-tune的FCN参数
    vgg_weights = '../ilsvrc-nets/vgg16-fcn.caffemodel'               #训练好的VGGNet参数
    vgg_proto = '../ilsvrc-nets/VGG_ILSVRC_16_layers_deploy.prototxt' #VGGNet模型
    
    # init
    #caffe.set_device(int(sys.argv[1]))
    #获取命令行参数,其中sys.argv[0]为文件名,argv[1]为紧随其后的那个参数
    caffe.set_device(0) #GPU型号
    caffe.set_mode_gpu() #用GPU模式运行
    
    #solver.net.copy_from(weights)
    solver = caffe.SGDSolver('solver.prototxt') #调用SGD(随即梯度下降)Solver方法,solver.prototxt为所需参数
    vgg_net = caffe.Net(vgg_proto,vgg_weights,caffe.TRAIN) #vgg_net是原来的VGGNet模型(包括训练好的参数)
    surgery.transplant(solver.net,vgg_net) #FCN模型(参数)与原来的VGGNet模型之间的转化
    del vgg_net #删除VGGNet模型  
    
    
    # surgeries
    interp_layers = [k for k in solver.net.params.keys() if 'up' in k] #interp_layers为upscore层
    surgery.interp(solver.net, interp_layers) #将upscore层中每层的权重初始化为双线性内核插值。
    
    # scoring
    test = np.loadtxt('../data/sift-flow/test.txt', dtype=str) #载入测试图片信息
    
    for _ in range(50):
        solver.step(2000) #每2000次训练迭代执行后面的函数
        # N.B. metrics on the semantic labels are off b.c. of missing classes;
        # score manually from the histogram instead for proper evaluation
        score.seg_tests(solver, False, test, layer='score_sem', gt='sem') #测试图片语义特征
        score.seg_tests(solver, False, test, layer='score_geo', gt='geo') #测试图片几何特征
    

    surgery.py是精髓,全连接层参数到全卷积层的参数转化是靠它完成的,每一步都很巧妙,如沐春风~

    #surgery.py
    
    from __future__ import division #导入python未来支持的语言特征division(精确除法)
    import caffe #导入caffe
    import numpy as np #导入模块numpy并以np作为别名
    
    def transplant(new_net#FCN, net#VGGNet, suffix=''): #用于将VGGNet的参数转化给FCN(包括全连接层的参数)
        """
        Transfer weights by copying matching parameters, coercing parameters of
        incompatible shape, and dropping unmatched parameters.
        通过复制匹配的参数,强制转换不兼容形状的参数和丢弃不匹配的参数来达到传输(转化)权重的目的;
    
        The coercion is useful to convert fully connected layers to their
        equivalent convolutional layers, since the weights are the same and only
        the shapes are different.
        因为权重的个数是一样的仅仅是Blob的形状不一样,所以强制转换对于将全连接层转换为等效的卷积层是有用的;
    
        In particular, equivalent fully connected and convolution layers have shapes O x I and O x I x H x W respectively for O
        outputs channels, I input channels, H kernel height, and W kernel width.
        参数数量为O*I*H*W
        Both  `net` to `new_net` arguments must be instantiated `caffe.Net`s.
        参数一对一
        """
        for p in net.params: #net.params是字典形式,存放了所有的key-value,p为key
            p_new = p + suffix #将p赋给p_new
            if p_new not in new_net.params: #用来丢弃fc8(因为FCN中没有fc8)
                print 'dropping', p
                continue
            for i in range(len(net.params[p])):
                if i > (len(new_net.params[p_new]) - 1): #感觉没啥用?
                    print 'dropping', p, i
                    break
                if net.params[p][i].data.shape!= new_net.params[p_new][i].data.shape: 
                #Blob不一样转换(这边就是全连接层和卷积层的转换,很精髓!!!)
                    print 'coercing', p, i, 'from', net.params[p][i].data.shape, 'to', new_net.params[p_new][i].data.shape
                else: #形状一样则直接copy
                    print 'copying', p, ' -> ', p_new, i
                new_net.params[p_new][i].data.flat = net.params[p][i].data.flat #将参数按顺序赋值(flat函数只要保证参数个数相同,不用保证数组形状完全一样)
    
    def upsample_filt(size):
        """
        Make a 2D bilinear kernel suitable for upsampling of the given (h, w) size.
        上采样卷积核的制作
        """
        factor = (size + 1) // 2
        if size % 2 == 1:
            center = factor - 1
        else:
            center = factor - 0.5
        og = np.ogrid[:size, :size] #生成一列向量和一行向量
        return (1 - abs(og[0] - center) / factor) * \ #(64*1)的列向量和(1*64)行向量相乘则得到一个64*64的数组
               (1 - abs(og[1] - center) / factor)
    
    def interp(net, layers):
        """
        Set weights of each layer in layers to bilinear kernels for interpolation.
        将每一层的权重设置为双线性内核插值。
        """
        for l in layers:
            m, k, h, w = net.params[l][0].data.shape
            if m != k and k != 1:
                print 'input + output channels need to be the same or |output| == 1'
                raise
            if h != w:
                print 'filters need to be square'
                raise
            filt = upsample_filt(h) #初始化卷积核的参数(64*64*1)
            net.params[l][0].data[range(m), range(k), :, :] = filt #这边很关键!!!只有对于对应层的那层filter有参数,其余都为0,而且有filter参数的那层还都是相等的~
            #因为前一层已经是个分类器了,对分类器进行特征组合没有任何意义!所以这一层的上采样效果上而言只是对应的上采样(属于猴子还是属于猴子)
    
    def expand_score(new_net, new_layer, net, layer):#这个函数干啥用的没看懂- -貌似solve.py里没有这个函数的调用
        """
        Transplant an old score layer's parameters, with k < k' classes, into a new
        score layer with k classes s.t. the first k' are the old classes.
        """
        old_cl = net.params[layer][0].num
        new_net.params[new_layer][0].data[:old_cl][...] = net.params[layer][0].data
        new_net.params[new_layer][1].data[0,0,0,:old_cl][...] = net.params[layer][1].data

    score.py是评估文件,fcn不用caffe框架自带的test测试,而是自己写了个评估文件,里面有许多评估指标。不过小弟才疏学浅,对于很多评估指标的概念完全没接触过,比方说IU的概念,overall accuracy和mean accuracy的区别,希望有大牛可以科普,这部分由于对概念的不知以及数据量的巨大,没有很好的解读~实在有愧

    #score.py
    
    from __future__ import division
    import caffe
    import numpy as np
    import os
    import sys
    from datetime import datetime
    from PIL import Image
    
    def fast_hist(a, b, n):
        k = (a >= 0) & (a < n)
        return np.bincount(n * a[k].astype(int) + b[k], minlength=n**2).reshape(n, n)
    
    def compute_hist(net, save_dir#False, dataset, layer='score', gt='label'):
        n_cl = net.blobs[layer].channels #3通道的图
        if save_dir:
            os.mkdir(save_dir)
        hist = np.zeros((n_cl, n_cl)) #创建一个二维数组hist[3][3],元素都为0
        loss = 0
        for idx in dataset:
            net.forward()
            hist += fast_hist(net.blobs[gt].data[0, 0].flatten() #将数据拉为1列,
                                    net.blobs[layer].data[0].argmax(0).flatten(),
                                    n_cl)
            if save_dir: #是否需要保存图片
                im = Image.fromarray(net.blobs[layer].data[0].argmax(0).astype(np.uint8), mode='P')
                im.save(os.path.join(save_dir, idx + '.png'))
            # compute the loss as well
            loss += net.blobs['loss'].data.flat[0]
        return hist, loss / len(dataset)
    
    def seg_tests(solver#配置文件, save_format#False, dataset#test文件, layer='score'#实验输出, gt='label'#真实输出):
        print '>>>', datetime.now(), 'Begin seg tests'
        solver.test_nets[0].share_with(solver.net) #将solver.net复制给solver.test_net[0]
        do_seg_tests(solver.test_nets[0], solver.iter, save_format, dataset, layer, gt)
    
    def do_seg_tests(net, iter#累计迭代次数, save_format, dataset, layer='score', gt='label'):
        n_cl = net.blobs[layer].channels
        if save_format:
            save_format = save_format.format(iter) #format函数用来格式化数据;如果save_format为TRUE,则为1
        hist, loss = compute_hist(net, save_format, dataset, layer, gt)
        # mean loss
        print '>>>', datetime.now(), 'Iteration', iter, 'loss', loss #平均误差
        # overall accuracy
        acc = np.diag(hist).sum() / hist.sum()
        print '>>>', datetime.now(), 'Iteration', iter, 'overall accuracy', acc
        # per-class accuracy
        acc = np.diag(hist) / hist.sum(1)
        print '>>>', datetime.now(), 'Iteration', iter, 'mean accuracy', np.nanmean(acc)
        # per-class IU
        iu = np.diag(hist) / (hist.sum(1) + hist.sum(0) - np.diag(hist))
        print '>>>', datetime.now(), 'Iteration', iter, 'mean IU', np.nanmean(iu)
        freq = hist.sum(1) / hist.sum()
        print '>>>', datetime.now(), 'Iteration', iter, 'fwavacc', \
                (freq[freq > 0] * iu[freq > 0]).sum()
        return hist

    以上是我对fcn代码的一点拙见,这次经历也让我明白,未接触过的代码并不可怕,只要沉下心来,一条一条的进行调试,你也可以知其所以然,发现其中奥秘。在研究生生涯开始之际写下我的第一篇博客,希望自己能在今后的学习生涯中保持这份初心,送给自己,也送给看过这篇博客的有缘人。

    展开全文
  • 代码地址:wkentaro/pytorch-fcn: PyTorch Implementation of Fully Convolutional Networks. (Training code to reproduce the original result is available.) (github.com)
  • FCN全卷积网络源代码

    2018-09-23 16:48:23
    FCN代码,这个代码非常适合配合FCN论文进行学习,适合初学者阅读学习深度学习网络构建框架。
  • 深度学习图像分割算法—FCN代码实现

    万次阅读 多人点赞 2019-02-21 10:30:51
    官方源代码:https://github.com/shelhamer/fcn.berkeleyvision.org截图如下 data文件夹:官方提供的四个数据集相关的文件,允许代码下载的数据集放在这个文件夹中 demo:官方代码提供的演示效果 nyud、...
  • fcn全卷积网络代码

    2018-11-23 12:09:56
    多了一个全连接层,也就是在VGG的第五层加上三层全连接,其中前五层的Weight和Bias直接用VGG的参数当做初始值(迁移学习),后面三层参数高斯初始化设置. 然后使用三层"反卷积"接在第八层之后,这里的参数都是使用高斯初始...
  • pytorch-fcn PyTorch实现。 要求 > = 0.2.0 > = 0.1.8 > = 6.1.5 安装 git clone https://github.com/wkentaro/pytorch-fcn.git cd pytorch-fcn pip install . # or pip install torchfcn 训练 参见。 准确性 在...
  • 关于FCN代码实现(实践篇)2016-10-14 15:143277人阅读 评论(2)收藏举报版权声明:本文为博主原创文章,未经博主允许不得转载。1.FCN做图像语义分割--测试和训练(matlab)...
  • R-FCN代码

    2018-06-05 09:59:55
    基于res-net网络的R-FCN框架,深度学习框架为caffe,编程语言为Python
  • tensorflow实现FCN_源代码,可以在自己的电脑上跑程序
  • fcn代码实践【2】

    2019-01-02 20:13:33
    FCN-16s网络的训练,由于没有对应的源代码,所以一切的东西都要我们自己来做,官方提供了其他dataset的源代码,我们可以依照这些内容生成相应的训练文件.我们可以先比较一下voc-fcn16s和voc-fcn32s 相对应的net.py...
  • MALSTM-FCN_TensorflowKeras2 MALSTM-FCN基本实现 这是MALSTM-FCN的Tensorflow2实现,用于时间序列分类。 可在作者的存储库网页上找到与Tensorflow1和Keras兼容的原始存储库: : 请参考上面的网页以获取有关模型...
  • FCN论文简述与代码实现

    千次阅读 多人点赞 2019-02-24 12:37:41
    FCN代码实现   FCN论文简述 论文地址 FCN是Fully Convolutional Networks的缩写,论文的全称是Fully Convolutional Networks for Semantic Segmentation。我觉得论文的主要贡献在于两点: 提出了一种全卷积...
  • 多分类,FCN代码,cuda8.0、cudnn5.1、TensorFlow1.4.0,资源包含了对github代码的修改
  • FCN 运行步骤

    2018-08-27 21:19:33
    此文件描述了FCN 代码工程的运行步骤,讲述了所需要的配置环境,和每一步运行后的结果,最终给出了训练模型结束后的分割结果。
  • GRU_FCN_分类-源码

    2021-02-08 12:00:33
    Vanilla_GRU_分类
  • 本人想实现FCN网络,训练自己的数据集,在调通tensorflow实现FCN代码的情况下,了解了程序实现神经网络的大致流程,对于调试代码也掌握了一些技巧,鉴于我的数据在tensorflow实现FCN的程序中跑出来的结果不甚理想,...
  • 代码地址 https://github.com/xiaoxu1025/r-fcn 对于看了论文一知半解的朋友可以看看我的RCNN系列的实现。 CSDN链接地址: https://blog.csdn.net/xiaoxu1025/article/details/104134569RCNN系列之-RCNN keras...
  • 对于LSTM-FCN和ALSTM-FCN模型的代码可以在这里找到 。 安装 下载存储库并应用pip install -r requirements.txt安装所需的库。 具有Tensorflow后端的Keras已用于开发模型,并且目前不支持Theano或CNTK后端。 权重...
  • FCN代码测试问题

    2018-06-22 15:25:46
    在这篇文章的基础下配置caffe运行FCN:点击打开链接 这篇讲的挺细,但是voc-fac32s训练存在几个小问题,如下: 问题1: Traceback (most recent call last): File "solve.py", line 19, in <module>...
  • 用于对象检测和分割的Mask R-CNN +用于语义分割的FCN 该软件伴随着我的论文项目“在深度卷积神经网络中使用上下文提示进行对象检测”期间进行的工作。 所提出的架构是一个两阶段的实现,包括对Python 3,Keras和...
  • FCN详解与pytorch简单实现(附详细代码解读)

    万次阅读 多人点赞 2020-03-14 11:13:03
    理解FCN需要有CNN基础 0.基于CNN的分割方法与FCN的比较 传统的基于CNN的分割方法:为了对一个像素分类,使用该像素周围的一个图像块作为CNN的输入用于训练和预测。这种方法有几个缺点: 一是存储开销很大。例如对每...
  • 注意这是非官方版本的代码 main.py是进行train的文件,如果你想进行训练可以修改这里的代码。 testCheckpoint.py是进行test的文件,就是测试ckpt文件中保存参数的shape的一个文件,这是与整个模型独立的一个文件,...
  • FCN—tensorflow版本代码超详解

    千次阅读 热门讨论 2018-12-17 22:49:22
    FCN—tensorflow版本代码详解

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,150
精华内容 4,060
关键字:

fcn代码