Tensoflow学习记录13--用深度学习来做图像分割Fully Convolutional Networks for Semantic Segmentation (FCNs)

最新推荐文章于 2024-01-24 10:25:46 发布
最新推荐文章于 2024-01-24 10:25:46 发布
阅读量427 收藏 1
点赞数
分类专栏： 机器学习 python

1 文章及其地址 
Fully Convolutional Networks for Semantic Segmentation (FCNs) 
http://arxiv.org/pdf/1605.06211v1.pdf

2 总述

感觉就是在vgg网络的基础上，将最后三层全连接改为cnn，即全都为卷积层了，fully convolutional networks，然后再反卷积，使输出与原始图像一致，这样就能画出每个像素点属于哪个类了，即实现了分割。 
这里写图片描述
2.1 如何理解深度学习中的deconvolution networks？ 
https://www.zhihu.com/question/43609045 
2.2 fcn的tensorflow实现 
https://github.com/shekkizh/FCN.tensorflow

3 测试

from __future__ import print_function
import tensorflow as tf
import numpy as np

import TensorflowUtils as utils
import read_MITSceneParsingData as scene_parsing
import datetime
import BatchDatsetReader as dataset
from six.moves import xrange

FLAGS = tf.flags.FLAGS
tf.flags.DEFINE_integer("batch_size", "2", "batch size for training")
tf.flags.DEFINE_string("logs_dir", "logs/", "path to logs directory")
tf.flags.DEFINE_string("data_dir", "Data_zoo/MIT_SceneParsing/", "path to dataset")
tf.flags.DEFINE_float("learning_rate", "1e-4", "Learning rate for Adam Optimizer")
tf.flags.DEFINE_string("model_dir", "Model_zoo/", "Path to vgg model mat")
tf.flags.DEFINE_bool('debug', "False", "Debug mode: True/ False")
tf.flags.DEFINE_string('mode', "train", "Mode train/ test/ visualize")

MODEL_URL = 'http://www.vlfeat.org/matconvnet/models/beta16/imagenet-vgg-verydeep-19.mat'

MAX_ITERATION = int(1e5 + 1)
NUM_OF_CLASSESS = 151
IMAGE_SIZE = 224


def vgg_net(weights, image):
    layers = (
        'conv1_1', 'relu1_1', 'conv1_2', 'relu1_2', 'pool1',

        'conv2_1', 'relu2_1', 'conv2_2', 'relu2_2', 'pool2',

        'conv3_1', 'relu3_1', 'conv3_2', 'relu3_2', 'conv3_3',
        'relu3_3', 'conv3_4', 'relu3_4', 'pool3',

        'conv4_1', 'relu4_1', 'conv4_2', 'relu4_2', 'conv4_3',
        'relu4_3', 'conv4_4', 'relu4_4', 'pool4',

        'conv5_1', 'relu5_1', 'conv5_2', 'relu5_2', 'conv5_3',
        'relu5_3', 'conv5_4', 'relu5_4'
    )

    net = {}
    current = image
    for i, name in enumerate(layers):
        kind = name[:4]
        if kind == 'conv':
            kernels, bias = weights[i][0][0][0][0]
            # matconvnet: weights are [width, height, in_channels, out_channels]
            # tensorflow: weights are [height, width, in_channels, out_channels]
            kernels = utils.get_variable(np.transpose(kernels, (1, 0, 2, 3)), name=name + "_w")
            bias = utils.get_variable(bias.reshape(-1), name=name + "_b")
            current = utils.conv2d_basic(current, kernels, bias)
        elif kind == 'relu':
            current = tf.nn.relu(current, name=name)
            if FLAGS.debug:
                utils.add_activation_summary(current)
        elif kind == 'pool':
            current = utils.avg_pool_2x2(current)
        net[name] = current

    return net


def inference(image, keep_prob):
    """
    Semantic segmentation network definition
    :param image: input image. Should have values in range 0-255
    :param keep_prob:
    :return:
    """
    print("setting up vgg initialized conv layers ...")
    model_data = utils.get_model_data(FLAGS.model_dir, MODEL_URL)

    mean = model_data['normalization'][0][0][0]
    mean_pixel = np.mean(mean, axis=(0, 1))

    weights = np.squeeze(model_data['layers'])

    processed_image = utils.process_image(image, mean_pixel)

    with tf.variable_scope("inference"):
        image_net = vgg_net(weights, processed_image)
        conv_final_layer = image_net["conv5_3"]

        pool5 = utils.max_pool_2x2(conv_final_layer)

        W6 = utils.weight_variable([7, 7, 512, 4096], name="W6")
        b6 = utils.bias_variable([4096], name="b6")
        conv6 = utils.conv2d_basic(pool5, W6, b6)
        relu6 = tf.nn.relu(conv6, name="relu6")
        if FLAGS.debug:
            utils.add_activation_summary(relu6)
        relu_dropout6 = tf.nn.dropout(relu6, keep_prob=keep_prob)

        W7 = utils.weight_variable([1, 1, 4096, 4096], name="W7")
        b7 = utils.bias_variable([4096], name="b7")
        conv7 = utils.conv2d_basic(relu_dropout6, W7, b7)
        relu7 = tf.nn.relu(conv7, name="relu7")
        if FLAGS.debug:
            utils.add_activation_summary(relu7)
        relu_dropout7 = tf.nn.dropout(relu7, keep_prob=keep_prob)

        W8 = utils.weight_variable([1, 1, 4096, NUM_OF_CLASSESS], name="W8")
        b8 = utils.bias_variable([NUM_OF_CLASSESS], name="b8")
        conv8 = utils.conv2d_basic(relu_dropout7, W8, b8)
        # annotation_pred1 = tf.argmax(conv8, dimension=3, name="prediction1")

        # now to upscale to actual image size
        deconv_shape1 = image_net["pool4"].get_shape()
        W_t1 = utils.weight_variable([4, 4, deconv_shape1[3].value, NUM_OF_CLASSESS], name="W_t1")
        b_t1 = utils.bias_variable([deconv_shape1[3].value], name="b_t1")
        conv_t1 = utils.conv2d_transpose_strided(conv8, W_t1, b_t1, output_shape=tf.shape(image_net["pool4"]))
        fuse_1 = tf.add(conv_t1, image_net["pool4"], name="fuse_1")

        deconv_shape2 = image_net["pool3"].get_shape()
        W_t2 = utils.weight_variable([4, 4, deconv_shape2[3].value, deconv_shape1[3].value], name="W_t2")
        b_t2 = utils.bias_variable([deconv_shape2[3].value], name="b_t2")
        conv_t2 = utils.conv2d_transpose_strided(fuse_1, W_t2, b_t2, output_shape=tf.shape(image_net["pool3"]))
        fuse_2 = tf.add(conv_t2, image_net["pool3"], name="fuse_2")

        shape = tf.shape(image)
        deconv_shape3 = tf.pack([shape[0], shape[1], shape[2], NUM_OF_CLASSESS])
        W_t3 = utils.weight_variable([16, 16, NUM_OF_CLASSESS, deconv_shape2[3].value], name="W_t3")
        b_t3 = utils.bias_variable([NUM_OF_CLASSESS], name="b_t3")
        conv_t3 = utils.conv2d_transpose_strided(fuse_2, W_t3, b_t3, output_shape=deconv_shape3, stride=8)

        annotation_pred = tf.argmax(conv_t3, dimension=3, name="prediction")

    return tf.expand_dims(annotation_pred, dim=3), conv_t3


def train(loss_val, var_list):
    optimizer = tf.train.AdamOptimizer(FLAGS.learning_rate)
    grads = optimizer.compute_gradients(loss_val, var_list=var_list)
    if FLAGS.debug:
        # print(len(var_list))
        for grad, var in grads:
            utils.add_gradient_summary(grad, var)
    return optimizer.apply_gradients(grads)


def main(argv=None):
    keep_probability = tf.placeholder(tf.float32, name="keep_probabilty")
    image = tf.placeholder(tf.float32, shape=[None, IMAGE_SIZE, IMAGE_SIZE, 3], name="input_image")
    annotation = tf.placeholder(tf.int32, shape=[None, IMAGE_SIZE, IMAGE_SIZE, 1], name="annotation")

    pred_annotation, logits = inference(image, keep_probability)
    tf.summary.image("input_image", image, max_outputs=2)
    tf.summary.image("ground_truth", tf.cast(annotation, tf.uint8), max_outputs=2)
    tf.summary.image("pred_annotation", tf.cast(pred_annotation, tf.uint8), max_outputs=2)
    loss = tf.reduce_mean((tf.nn.sparse_softmax_cross_entropy_with_logits(logits,
                                                                          tf.squeeze(annotation, squeeze_dims=[3]),
                                                                          name="entropy")))
    tf.summary.scalar("entropy", loss)

    trainable_var = tf.trainable_variables()
    if FLAGS.debug:
        for var in trainable_var:
            utils.add_to_regularization_and_summary(var)
    train_op = train(loss, trainable_var)

    print("Setting up summary op...")
    summary_op = tf.summary.merge_all()

    print("Setting up image reader...")
    train_records, valid_records = scene_parsing.read_dataset(FLAGS.data_dir)
    print(len(train_records))
    print(len(valid_records))

    print("Setting up dataset reader")
    image_options = {'resize': True, 'resize_size': IMAGE_SIZE}
    if FLAGS.mode == 'train':
        train_dataset_reader = dataset.BatchDatset(train_records, image_options)
    validation_dataset_reader = dataset.BatchDatset(valid_records, image_options)

    sess = tf.Session()

    print("Setting up Saver...")
    saver = tf.train.Saver()
    summary_writer = tf.summary.FileWriter(FLAGS.logs_dir, sess.graph)

    sess.run(tf.initialize_all_variables())
    ckpt = tf.train.get_checkpoint_state(FLAGS.logs_dir)
    if ckpt and ckpt.model_checkpoint_path:
        saver.restore(sess, ckpt.model_checkpoint_path)
        print("Model restored...")

    if FLAGS.mode == "train":
        for itr in xrange(MAX_ITERATION):
            train_images, train_annotations = train_dataset_reader.next_batch(FLAGS.batch_size)
            feed_dict = {image: train_images, annotation: train_annotations, keep_probability: 0.85}

            sess.run(train_op, feed_dict=feed_dict)

            if itr % 10 == 0:
                train_loss, summary_str = sess.run([loss, summary_op], feed_dict=feed_dict)
                print("Step: %d, Train_loss:%g" % (itr, train_loss))
                summary_writer.add_summary(summary_str, itr)

            if itr % 500 == 0:
                valid_images, valid_annotations = validation_dataset_reader.next_batch(FLAGS.batch_size)
                valid_loss = sess.run(loss, feed_dict={image: valid_images, annotation: valid_annotations,
                                                       keep_probability: 1.0})
                print("%s ---> Validation_loss: %g" % (datetime.datetime.now(), valid_loss))
                saver.save(sess, FLAGS.logs_dir + "model.ckpt", itr)

    elif FLAGS.mode == "visualize":
        valid_images, valid_annotations = validation_dataset_reader.get_random_batch(FLAGS.batch_size)
        pred = sess.run(pred_annotation, feed_dict={image: valid_images, annotation: valid_annotations,
                                                    keep_probability: 1.0})
        valid_annotations = np.squeeze(valid_annotations, axis=3)
        pred = np.squeeze(pred, axis=3)

        for itr in range(FLAGS.batch_size):
            utils.save_image(valid_images[itr].astype(np.uint8), FLAGS.logs_dir, name="inp_" + str(5+itr))
            utils.save_image(valid_annotations[itr].astype(np.uint8), FLAGS.logs_dir, name="gt_" + str(5+itr))
            utils.save_image(pred[itr].astype(np.uint8), FLAGS.logs_dir, name="pred_" + str(5+itr))
            print("Saved image: %d" % itr)


if __name__ == "__main__":
    tf.app.run()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223

需要修改一些函数名，版本更新后有变化。

报错：

    image = misc.imread(filename)
AttributeError: 'module' object has no attribute 'imread'
  • 1
  • 2
  • 3

解决办法，要安装pillow

pip install pillow
  • 1

以及一些改动的地方 
1

    summary_writer = tf.train.SummaryWriter(FLAGS.logs_dir, sess.graph)
    #summary_writer = tf.summary.FileWriter(FLAGS.logs_dir, sess.graph)
  • 1
  • 2
  • 3

2

    #tf.summary.image("input_image", image, max_outputs=2)
    tf.image_summary("input_image", image, max_images=2)
    tf.image_summary("ground_truth", tf.cast(annotation, tf.uint8), max_images=2)
    #tf.summary.image("ground_truth", tf.cast(annotation, tf.uint8), max_outputs=2)
    tf.image_summary("pred_annotation", tf.cast(pred_annotation, tf.uint8), max_images=2)
    #tf.summary.image("pred_annotation", tf.cast(pred_annotation, tf.uint8), max_outputs=2)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

3

    tf.scalar_summary("entropy", loss)
    #tf.summary.scalar("entropy", loss)
  • 1
  • 2
  • 3

4

    summary_op = tf.merge_all_summaries()
    #summary_op = tf.summary.merge_all()
  • 1
  • 2
  • 3

5

    summary_writer = tf.train.SummaryWriter(FLAGS.logs_dir, sess.graph)
    #summary_writer = tf.summary.FileWriter(FLAGS.logs_dir, sess.graph)
  • 1
  • 2
  • 3
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_16949707/article/details/56011484
luckyboy101
关注
专栏目录
Fully convolutional networks for semantic segmentation
11-17
完全卷积网络（Fully Convolutional Networks, FCN）是一种用于图像处理的深度学习模型，它能够实现像素级别的分类，即语义分割任务。传统的卷积神经网络（CNN）主要用于图像分类等任务，而FCN通过去除全连接层并...
源码解析-图像分割-FCN网络
weixin_30617797的博客
06-16 468
FCN网络简介 FCN网络出自文章Fully Convolutional Networks for Semantic Segmentation。传统的CNN网络多以全连接层结尾，用于图像级别的分类问题。而语义分割(Semantic Segmentation)问题需要对图像中的每个像素点进行分类。全连接层虽然能够获取全局语义信息，但是却会破坏像素点的局部位置信息。FCN网络率先使用卷积层替代全连接层...
Fully Convolutional Networks for semantic Segmentation（深度学习经典论文翻译）
weixin_30328063的博客
01-04 1890
摘要 卷积网络在特征分层领域是非常强大的视觉模型。我们证明了经过端到端、像素到像素训练的卷积网络超过语义分割中最先进的技术。我们的核心观点是建立“全卷积”网络，输入任意尺寸，经过有效的推理和学习产生相应尺寸的输出。我们定义并指定全卷积网络的空间，解释它们在空间范围内dense prediction任务(预测每个像素所属的类别)和获取与先验模型联系的应用。我们改编当前的分类网络(AlexNet...
FCNs
Ryan.D
08-05 2282
标题 FCNs：Fully Convolutional Networks 全卷积网络可用来做语义级别的图像分割以及对象检测，由encoder（vgg，resnet，预训练模型提取特征），decoder（实现每个像素的分割或预测）组成 1x1 Convolution 保留空间信息 Transposed Convolutions 在decoder阶段调换前向传播和反向传播，保...
Tensorflow的C++应用
SHIJIE15138的博客
11-26 1246
将Keras训练的.hdf5模型固化为.pb模型 from tensorflow.python.framework import graph_io from keras.models import load_model from keras import backend as K import tensorflow as tf def freeze_session(session,...
Fully-Convolutional-Networks-for-Semantic-Segmentation:2020 CVPR项目，全卷积网络在语义分割中的应用
03-28
全卷积网络（Fully Convolutional Networks，FCNs）是深度学习领域中一种重要的图像处理技术，主要用于图像的语义分割任务。语义分割是指将图像的每个像素分配到一个预定义的类别，如人、车、建筑等，旨在理解图像...
U-Net Convolutional Networks for Biomedical Image Segmentation.pdf
06-06
该网络架构的核心特点在于其对称的收缩路径（contracting path）和扩张路径（expanding path），这样的设计允许它在极少量的训练样本下进行高效的学习，同时在图像分割任务中达到了非常高的准确度。 在介绍中，文章...
pytorch-semantic-segmentation：用于语义分割的PyTorch
02-05
PyTorch用于语义分割 该存储库包含一些用于语义分割的模型以及在PyTorch中实现的训练和测试模型的管道 楷模 Vanilla FCN：分别为VGG，ResNet和DenseNet版本的FCN32，FCN16，FCN8（ ） U-Net（ ） SegNet（ ） ...
深度学习500问之图像分割-附笔记
08-31
第九章主要讨论的是深度学习在图像分割领域的应用和相关算法。图像分割是计算机视觉中的一个核心任务，它涉及预测图像中每一个像素的类别或物体归属。根据深度学习的方法，图像分割可以大致分为语义分割和实例分割。...
深度学习之图像分割——入门篇
最新发布
2301_79285641的博客
01-24 8073
图像分割（Image Segmentation）是一种计算机视觉领域的技术，旨在将图像分成若干个特定的、具有语义意义性质的区域。图像分割可以用于许多领域，包括目标检测、图像编辑、医学图像分析等。它是由图像处理到图像分析的关键步骤。
C++ 调用tensorflow
koibiki的博客
03-08 4452
１.安装protobuf 3.6 ＃　安装依赖软件 sudo apt-get install autoconf automake libtool curl make g++ unzip ＃　克隆版本为3.6.0的protobuf源码 git clone -b v3.6.0 https://github.com/protocolbuffers/protobuf.git ＃　下载　protobuf...
如何用C++实现自己的Tensorflow
热门推荐
CSDN研发技术
11-10 3万+
原文：How To Write Your Own Tensorflow in C++ 作者：Ray Zhang 翻译：无阻我飞扬 摘要：TensorFlow是由谷歌基于DistBelief进行研发的第二代人工智能学习系统，其命名来源于本身的运行原理，它完全开源，作者通过自己的一个小项目，阐述了如何用C++实现自己的TensorFlow，这篇文章看起来可能会有点晦涩，你需要对相关知识有所了
Tensorflow c++源码编译（踩坑版）
zqwwwm的博客
12-14 5980
在实际项目部署过程中，会需要tensorflow c或者c++版本， 网上一通查，说自己编译会各种坑，投机取巧。。在拿到别人编译好的c和c++版本调用报错后，开始痛定思痛，躲不过的坑 自己来趟好了。。 先说下电脑环境： linux18.04 cuda 10.0 cudnn 7.6.5 make 4.1 protobuf 3.7 ############环境安装############# 怕tensorflow版本高 容易出错，保守选择 tensroflow 1.13.1版本， 并选择
Tensorflow 模型 C++部署实战
03-26
因公司要求个人不得授课和兼职原因，麻烦请把我的课程全部下架，联系不到你们的客服，谢谢！
全卷积神经网络FCN-TensorFlow代码精析
Eternity的博客
04-24 2万+
FCN-TensorFlow完整代码Github：https://github.com/EternityZY/FCN-TensorFlow.git这里解析所有代码 并加入详细注释注意事项：请按照代码中要求，将VGG-19模型和训练集下载好，运行下载很慢。MODEL_URL =  'http://www.vlfeat.org/matconvnet/models/beta16/imagenet-vgg...
tensorflow2.0入门实例四（FCN模型建立）
weixin_43162240的博客
10-21 1万+
做东西，最重要的就是动手了，所以这篇文章主要教大家动手跑了一个fcn32s和fcn8s的例子，这个例子的数据集选用自动驾驶相关竞赛的kitti数据集。这篇文章适合入门级选手，在文章中不再讲述fcn的结构，直接百度就可以搜到。 文章使用的是tensorflow2.0框架，该框架集成了keras，在模型的训练方面极其简洁，不像tf1.x那么复杂，综合其他深度学习框架，发现这个是最适合新手使用的一种。 ...
用TensorFlow和TFSlim实现图像分类与分割
u010197508的博客
06-08 5204
TensorFlow TF-Slim 图像分类 图像分割
TensorFlow实现FCN分割图片（使用自己的数据集）
weixin_43798120的博客
06-11 1万+
一、复现FCN 1、在github上下载fcn的tensorflow版本实现 https://github.com/shekkizh/FCN.tensorflow 2、代码的实现有四个python文件，分别是FCN.py、BatchDatasetReader.py、TensorFlowUtils.py、read_MITSceneParsingData.py，将这四个文件放在一个当前目录下。 3...
fully convolutional networks for semantic segmentation
03-17
完全卷积网络（Fully Convolutional Networks, FCN）是用于语义分割的一种深度学习模型。它通过将全连接层替换为卷积层来保留输入图像的空间信息，并通过上采样或反卷积操作来恢复高分辨率的分割结果。这种模型在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值