语义分割

1.语义分割介绍

计算机视觉与机器学习研究者对图像语义分割问题越来越感兴趣。越来越多的应用场景需要精确且高效的分割技术，如自动驾驶、室内导航、甚至虚拟现实与增强现实等。这个需求与视觉相关的各个领域及应用场景下的深度学习技术的发展相符合，包括语义分割及场景理解等…

更多可以参考语义分割概述.

在这个项目中，我们将训练一个深度神经网络，以从Quadcoptor模拟器生成的图像中识别目标人。拥有训练完成的网络后，我们可以通过推理使用它在新图像中找到目标。

在最终的Follow Me项目中，推理步骤必须在仿真中连续运行，就像直升机向其提供图像一样快。在本项目中引入了一些额外的代码抽象和性能增强，这些在进行仿真时是必需的，

环境设置
TensorFlow中的Keras层
具有可分离卷积的编码器
批量归一化
具有双线性上采样的解码器
层级联

本实验使用来自模拟器的实际数据，最后，我们将拥有一个理论上可以正常运行的网络，可以将其整合到Follow Me项目中。我们将需要通过附加层，参数调整甚至收集更多数据来最大化网络性能。

（1）环境设置

在本实验中，课程还是以jupternotebook的形式提供，为了方便我以后使用，我会再将来的内容更改成.py格式。

运行以下命令以克隆实验室存储库：

git clone https://github.com/udacity/RoboND-Segmentation-Lab.git
# Make sure your conda environment is activated!
jupyter notebook

或者进入https://github.com/udacity/RoboND-Segmentation-Lab.git去下载相应的压缩包解压到相应的路径中。其中包括储存库，训练数据和验证数据。

（2）Keras

Keras 是目前使用最为广泛的深度学习工具之一，它的底层可以支持Tensor Flow 、
MXNet、CNTK 和Theano 。如今， Keras 更是被直接引入了TensorFlow 的核心代码库，成为TensorFlow 官方提供的高层封装之一。

选择Keras的优点：

训练例程已简化，并通过标准接口提供。
不必自己管理tensorflow会话。
数据生成器具有标准接口。
这些层是具有语法层()(prev_layer)的类，而不是具有layer(prev_layer)的功能接口，层的命名约定在它们之间是相当标准的。
Keras有额外的层来处理诸如上采样和其他小的特性，而在tensorflow中这些是分散的。
若想要向网络添加新功能，那么需要将功能包装在一个自定义层中，或者编写为lambda层。

（3）编码器

FCN是由编码器和解码器组成的。编码器部分是一个卷积网络，可简化为更深的1x1卷积层，而不是用于图像基本分类的平面全连接层。这种差异具有从图像中保留空间信息的效果。

这里介绍的可分离卷积是一种减少所需参数数量的技术，从而提高了编码器网络的效率。

可分离卷积

可分离卷积，也称为深度可分离卷积，由一个在输入层的每个通道上执行的卷积和一个1x1卷积组成，1x1卷积将前一步的输出通道合并成输出层。

这与我们之前介绍的常规卷积不同，主要是因为减少了参数的数量。让我们考虑一个简单的例子。

设输入形状是32x32x3。需要9个输出通道和形状为3x3x3的过滤器(内核)。在常规卷积中，9个内核遍历3个输入通道。这将导致总共933*3个特征(忽略偏置)。总共243个参数。

在可分卷积的情况下，通过3个输入通道，每个通道有一个内核。这给了我们27个参数(333)和3个特征图。在下一步中，这3个特征映射将被9个1x1卷积遍历。结果总共有27(9*3)个参数。总共有54(27 + 27)个参数!比我们上面得到的243个参数少得多。随着层或通道的大小的增加，这种差异将会更加明显。

参数的减少使得可分卷积在提高运行时性能的同时非常高效，因此对于移动应用程序也非常有用。由于参数较少，它们还具有在一定程度上减少过拟合的额外好处。

可分离卷积相关代码

在utils所提供的仓库的模块中提供了可分离卷积的优化版本。它基于tf.contrib.keras函数定义，可以实现如下：

output = SeparableConv2DKeras(filters, kernel_size, strides, padding, activation)(input)

其中，

input是输入层，

filters 是输出滤波器的数量（深度），

kernel_size是一个数字，指定内核的（宽度，高度），

padding 是“SAME”或“VALID”

activation是激活函数，例如“ relu”。

以下是如何使用上述功能的示例：

output = SeparableConv2DKeras(filters=32, kernel_size=3, strides=2,padding='same', activation='relu')(input)

（4）批处理归一化

批处理归一化是优化网络训练的另一种方法。

批量归一化基于以下思想：我们不仅将输入归一化到网络中，还将输入归一化到网络中的各个层。之所以称为“批处理”归一化，是因为在训练期间，我们使用当前迷你批处理中的值的均值和方差来归一化每一层的输入。

网络是一系列的层，其中一层的输出成为另一层的输入。这意味着我们可以把神经网络中的任何一层想象成更小网络的第一层。

例如，设想一个3层的网络。不要把它看作是一个具有输入、网络的层和输出的单一网络，而是把第1层的输出看作是一个两层网络的输入。这两层网络将由我们原来的网络中的第2层和第3层组成。

同样地，第2层的输出可以被认为是一个单层网络的输入，该网络只包含第3层。
当我们把它看作是一系列相互作用的神经网络时，就很容易想象把每一层的输入归一化会有多大帮助。这就像对任何其他神经网络的输入进行归一化一样，但是在每一层(子网络)都在这么做。

批归一化代码

在中tf.contrib.keras，可以使用以下函数定义来实现批量标准化：

from tensorflow.contrib.keras.python.keras import layers
output = layers.BatchNormalization()(input)

该separable_conv2d_batchnorm()函数在可分离卷积层之后添加批处理归一化层。引入批处理规范化层为我们提供了很多优势。

例如：

网络训练速度更快 – 由于前向传递期间的额外计算，每个训练迭代实际上会更慢。但是，它的收敛速度应该快得多，所以总体上训练应该更快。
允许更高的学习率 – 梯度下降法通常需要较小的学习速率才能使网络收敛。当网络越深，它们的梯度在反向传播时就越小，因此它们需要更多的迭代。使用批处理规范化允许我们使用更高的学习率，这进一步提高了网络训练的速度。
简化了更深层网络的创建 – 由于上述原因，在使用批处理规范化时，更容易构建并且更快地训练更深层的神经网络。
提供一些正则化 – 批处理归一化会给网络增加一些干扰。在某些情况下，例如在Inception模块中，批处理归一化已经被证明与dropout一样有效。

（5）解码器

在前面讲过转置卷积，作为将层向上采样到更高维度或分辨率的一种方法。实际上，有几种方法可以实现向上采样。在本节中，将介绍另一种方法，称为双线性上采样或双线性插值。

双线性上采样

双线性上采样是一种重采样技术，该技术利用与给定像素对角线的四个最接近的已知像素的加权平均值来估计新的像素强度值。加权平均值通常取决于距离。

让我们考虑这样一种情况：有4个已知像素值，因此本质上是2x2灰度图像。需要将此图像上采样为4x4图像。下图更好地说明了此过程。

上面4x4插图中未标记的像素实际上是空白。双线性上采样方法将尝试通过插值来填充所有剩余的像素值。考虑P5P_5P5的情况来理解这个算法。

我们首先使用线性插值计算P12P_{12}P12和P34P_{34}P34的像素值。
P12=P1+W1∗(P2−P1)/W2P_{12}= P_1 + W_1*(P_2 - P_1)/W_2P12=P1+W1∗(P2−P1)/W2
P34=P3+W1∗(P4−P3)/W2P_{34}= P_3 + W_1*(P_4 - P_3)/W_2P34=P3+W1∗(P4−P3)/W2

使用P12和P34，我们可以得到P5:
P5=P12+H1∗(P34−P12)/H2P_5 = P_{12}+ H_1*(P_{34}- P_{12})/H_2P5=P12+H1∗(P34−P12)/H2

为了简单起见，我们假设H_2 = W_2 = 1

将P34和P12代入后，P5像素值的最终方程为:
P5=P1∗(1−W1)∗(1−H1)+P2∗W1∗(1−H1)+P3∗H1∗(1−W1)+P4∗W1∗H1P_5 = P_1 * (1 - W_1) * (1 - H_1) + P_2 * W_1 * (1 - H_1) + P_3 * H_1 * (1 - W_1) + P_4 * W_1* H_1P5=P1∗(1−W1)∗(1−H1)+P2∗W1∗(1−H1)+P3∗H1∗(1−W1)+P4∗W1∗H1

虽然数学变得更加复杂，上面的技术也可以扩展到RGB图像。

双线性上采样器代码

已在utils所提供的repo 的模块中提供了双线性上采样器的优化版本，可以按以下方式实现：

output = BilinearUpSampling2D(row, col)(input)

其中，

input是输入层，

row 是输出层各行的上采样系数，

col 是输出层各列的上采样系数，并且

output 是输出层。

以下是如何使用上述功能的示例：

output = BilinearUpSampling2D((2,2))(input)

双线性升采样方法没有像体系结构中的转置卷积那样有助于学习，并且容易丢失一些更详细的细节，但有助于提高性能。

（6）层级联

前面介绍了跳跃连接，这是一种很好的方法，可以在我们解码或将层提升到原始大小时保留前一层的一些更精细的细节。在前面，我们讨论了实现此目的的一种方法，即使用元素添加操作添加两个层。我们现在将学习另一个简单的技术，我们将连接两个层，而不是添加它们。

连接两个层，上采样层和一个比上采样层具有更多空间信息的层，向我们展示了相同的功能。实现此功能也非常简单。

使用tf.contrib.keras函数定义，它可以实现如下：

from tensorflow.contrib.keras.python.keras import layers
output = layers.concatenate(inputs)

其中，

inputs 是要连接的图层的列表。

可以使用类似的格式在decoder_block()函数中实现上述操作:

output = layers.concatenate([input_layer_1, input_layer_2])

层级联的另一个好处是，它提供了一定的灵活性，因为与必须添加它们时不同，输入层的深度不需要匹配。这也有助于简化实施。

虽然层级联本身对模型有帮助，但通常最好在此步骤之后添加一些常规或可分离的卷积层，以使模型能够更好地从之前的图层中学习那些更精细的空间细节。

3. 交并比（IoU）

交并比（IoU）是一个重要的指标，该指标可以帮助评估语义分割网络的性能。

IoU函数的定义为：预测边界和实际边界交集的面积比并集的面积。
IntersectionSet(AND)UnionSet(OR)≤1\frac{Intersection \ Set(AND)}{Union\ Set(OR)} \le 1Union Set(OR)Intersection Set(AND)≤1

TensorFlow IoU

让我们看一下tf.metrics.mean_iou函数。与所有其他TensorFlow度量函数一样，它返回度量结果的Tensor和Tensor Operation来生成结果。在这种情况下，它将返回mean_iou结果和update_op更新操作。确保update_op从获得结果之前运行mean_iou。

sess.run(update_op)
sess.run(mean_iou)

TensorFlow度量函数的另一个特征是使用本地TensorFlow变量。这些是临时TensorFlow变量，必须通过运行进行初始化 tf.local_variables_initializer()。这类似于tf.global_variables_initializer()，但针对不同的TensorFlow变量。

程序如下：

import tensorflow as tfdef mean_iou(ground_truth, prediction, num_classes):iou, iou_op = tf.metrics.mean_iou(ground_truth, prediction, num_classes)return iou, iou_opground_truth = tf.constant([[0, 0, 0, 0],[1, 1, 1, 1],[2, 2, 2, 2],[3, 3, 3, 3]], dtype=tf.float32)
prediction = tf.constant([[0, 0, 0, 0],[1, 0, 0, 1],[1, 2, 2, 1],[3, 3, 0, 3]], dtype=tf.float32)iou, iou_op = mean_iou(ground_truth, prediction, 4)with tf.Session() as sess:sess.run(tf.global_variables_initializer())# 需要初始化本地变量来运行' tf.metrics.mean_iou 'sess.run(tf.local_variables_initializer())sess.run(iou_op)# should be 0.53869print("Mean IoU =", sess.run(iou))

程序注释：

tf.metrics.mean_iou(labels,predictions,num_classes,weights=None,metrics_collections=None,updates_collections=None,name=None
)

labels：一个Tensor地面实况的具有形状[批量大小]和类型的标签int32或int64。如果张量等级> 1，则张量将被展平。
predictions：Tensor语义标签的预测结果A ，其形状为[批量大小]且类型为int32或int64。如果张量等级> 1，则张量将被展平。
num_classes：预测任务可以具有的标签数量。必须提供此值，因为将分配维度= [num_classes，num_classes]的混淆矩阵。
weights：Tensor等级为0或与等级相同的可选labels，并且必须向广播labels（即，所有尺寸必须为1，或与相应labels尺寸相同）。
metrics_collections：mean_iou 应添加到集合的可选列表。
updates_collections：update_op应该添加可选的收藏列表。
name：可选的variable_scope名称。

4.语义分割实例

我们将建立一个深度学习网络，定位一个特定的人类目标在一个图像里。前提是一个四轴飞行器(模拟)正在寻找一个目标，然后一旦找到目标就会跟随。在这种情况下，仅仅说目标出现在图像中是不够的，而是要知道目标在图像中的位置，以便直升机可以调整其方向以便跟踪。

因此，一个图像分类网络不足以解决这个问题。相反，需要一个语义分割网络，以便目标可以被明确地定位在图像中。

猜测是tensorflow版本的问题，程序频繁报错，查了一天错之后也没有实质性的进展，因此将tensorflow版本更改到与推荐的版本一致。

pip install tensorflow==1.2.1

（1）引入函数

import os
import glob
import sys
import tensorflow as tffrom scipy import misc
import numpy as npfrom tensorflow.contrib.keras.python import keras
from tensorflow.contrib.keras.python.keras import layers, modelsfrom tensorflow import imagefrom utils import scoring_utils
# 引入可分卷积函数
from utils.separable_conv2d import SeparableConv2DKeras, BilinearUpSampling2D
from utils import data_iterator
from utils import plotting_tools
from utils import model_tools

来自utils的六个文件是课程自带的，之前使用tensorflow1.13.0的时候，程序不停的出错。个人猜测是因为升级后的tensorflow的各个函数的位置更改造成的。这个问题确实很遭人心，函数的位置的更改，导致了对以后程序的复现难度上升。而且出一些很玄学的bug。

（2）FCN层

可分卷积函数：

def separable_conv2d_batchnorm(input_layer, filters, strides=1):output_layer = SeparableConv2DKeras(filters=filters,kernel_size=3, strides=strides,padding='same', activation='relu')(input_layer)output_layer = layers.BatchNormalization()(output_layer) return output_layer

常规卷积函数：

def conv2d_batchnorm(input_layer, filters, kernel_size=3, strides=1):output_layer = layers.Conv2D(filters=filters, kernel_size=kernel_size, strides=strides, padding='same', activation='relu')(input_layer)output_layer = layers.BatchNormalization()(output_layer) return output_layer

这两种卷积都可以使用，正如之前提到的，但是可分卷积函数在训练的时候速度较快。在tensorflow==1.13.0中，separable_conv2d_batchnorm函数一直会报错如下：

TypeError: __call__() got an unexpected keyword argument 'partition_info'

大量的尝试后，这个错误还是不能规避掉。个人猜测是因为tensorflow的版本冲突。果然在退回了版本和引入keras的位置后，程序正常运行。

def bilinear_upsample(input_layer):output_layer = BilinearUpSampling2D((2,2))(input_layer)return output_layer

双线性上采样也是另一个bug出现的地方，这个bug的原因是在后面的layerc.concatenate函数中，两层的shape不匹配。但是比较玄学的是，当我将它们print出来之后，两者的shape完全一样，但是根据报的错误来显示，双线性上采样完全没有起作用，输出维度和采样之前完全一样。

这个错误最终我也没有解决掉，猜测和上面的可分卷积函数出现的错误一样。因为这两者都采用了utils中的辅助函数SeparableConv2DKeras，这也很好的提醒了我，对于函数的使用，尤其是在tensorflow中，一定要注意版本的问题。

# 编码器模块
def encoder_block(input_layer, filters, strides):# TODO Create a separable convolution layer using the separable_conv2d_batchnorm() function.output_layer = separable_conv2d_batchnorm(input_layer, filters, strides)return output_layer# 解码器模块
def decoder_block(small_ip_layer, large_ip_layer, filters):# TODO Upsample the small input layer using the bilinear_upsample() function.upsampled = bilinear_upsample(small_ip_layer)print('upsampled_shape:', upsampled.shape)print('large_input_shape:', large_ip_layer.shape)# TODO Concatenate the upsampled and large input layers using layers.concatenateconcat_layer = layers.concatenate([upsampled, large_ip_layer])print('concat_layer_shape:', concat_layer.shape)# TODO Add some number of separable convolution layersoutput_layer = separable_conv2d_batchnorm(concat_layer, filters)return output_layer

之后我们就可以将上采样和可分卷积整合到编码器和解码器之中了。

（3）建立模型

# 构建FCN模型
def fcn_model(inputs, num_classes):# TODO Add Encoder Blocks.# Remember that with each encoder layer, the depth of your model (the number of filters) increases.# TODO 添加编码器模块。# 请记住，对于每个编码器层，模型的深度(过滤器的数量)都会增加。mid_layer_0 = encoder_block(inputs, filters=32, strides=2)print('mid_layer_0:', mid_layer_0)# TODO 使用conv2d_batchnorm()添加1x1卷积层。mid_layer_1 = conv2d_batchnorm(mid_layer_0, 32, 3, 1)print('mid_layer_1:', mid_layer_1)# TODO: 添加与编码器块数量相同的解码器块数量x = decoder_block(mid_layer_1, inputs, 32)# 该函数返回模型的输出层。“x”是从最后一个decoder_block()中获得的最后一层return layers.Conv2D(num_classes, 3, activation='softmax', padding='same')(x)

再有了上采样和可分卷积之后，我们就可以搭建我们的FCN模型

（4）训练

# 输入图片宽度
image_hw = 128
# 输入图片shape
image_shape = (image_hw, image_hw, 3)
inputs = layers.Input(image_shape)
num_classes = 3# Call fcn_model()
output_layer = fcn_model(inputs, num_classes)

建立完整的模型，有了模型之后我们就可以使用keras进行训练了。

learning_rate = 0.001 # 学习率
batch_size = 32 # 批大小
num_epochs = 5 # 训练轮数
steps_per_epoch = 200 # 每轮训练步数
validation_steps = 50 # 验证部署
workers = 2 # 最多启动的进程数

定义一些超参数，解释如上。

"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
# Define the Keras model and compile it for training
model = models.Model(inputs=inputs, outputs=output_layer)model.compile(optimizer=keras.optimizers.Adam(learning_rate), loss='categorical_crossentropy')# Data iterators for loading the training and validation data
train_iter = data_iterator.BatchIteratorSimple(batch_size=batch_size,data_folder=os.path.join('..', 'data', 'train'),image_shape=image_shape,shift_aug=True)val_iter = data_iterator.BatchIteratorSimple(batch_size=batch_size,data_folder=os.path.join('..', 'data', 'validation'),image_shape=image_shape)logger_cb = plotting_tools.LoggerPlotter()
callbacks = [logger_cb]model.fit_generator(train_iter,steps_per_epoch = steps_per_epoch, # the number of batches per epoch,epochs = num_epochs, # the number of epochs to train for,validation_data = val_iter, # validation iteratorvalidation_steps = validation_steps, # the number of batches to validate oncallbacks=callbacks,workers = workers)

使用keras训练自定义的模型。

完整程序如下，其中还包括了验证和预测部分：


import os
import glob
import sys
import tensorflow as tffrom scipy import misc
import numpy as npfrom tensorflow.contrib.keras.python import keras
from tensorflow.contrib.keras.python.keras import layers, modelsfrom tensorflow import imagefrom utils import scoring_utils
# 引入可分卷积函数
from utils.separable_conv2d import SeparableConv2DKeras, BilinearUpSampling2D
from utils import data_iterator
from utils import plotting_tools
from utils import model_tools# # 两种方法构建编码器
# 使用可分卷积构建编码器
def separable_conv2d_batchnorm(input_layer, filters, strides=1):output_layer = SeparableConv2DKeras(filters=filters, kernel_size=3, strides=strides,padding='same', activation='relu')(input_layer)output_layer = layers.BatchNormalization()(output_layer)return output_layer# 使用常规卷积构建编码器
def conv2d_batchnorm(input_layer, filters, kernel_size=3, strides=1):output_layer = layers.Conv2D(filters=filters, kernel_size=kernel_size, strides=strides,padding='same', activation='relu')(input_layer)output_layer = layers.BatchNormalization()(output_layer)return output_layer# # 构建上采样函数
# 使用双线性上采样
def bilinear_upsample(input_layer):output_layer = BilinearUpSampling2D((2,2))(input_layer)return output_layer# # 建立模型
# 使用separable_conv2d_batchnorm（）函数创建一个可分离的卷积层。
# 该filters参数定义输出层的大小或深度。例如32或64。
def encoder_block(input_layer, filters, strides):# TODO Create a separable convolution layer using the separable_conv2d_batchnorm() function.output_layer = separable_conv2d_batchnorm(input_layer, filters, strides)return output_layer# 解码器模块
def decoder_block(small_ip_layer, large_ip_layer, filters):# TODO Upsample the small input layer using the bilinear_upsample() function.upsampled = bilinear_upsample(small_ip_layer)print('upsampled_shape:', upsampled.shape)print('large_input_shape:', large_ip_layer.shape)# TODO Concatenate the upsampled and large input layers using layers.concatenateconcat_layer = layers.concatenate([upsampled, large_ip_layer])print('concat_layer_shape:', concat_layer.shape)# TODO Add some number of separable convolution layersoutput_layer = separable_conv2d_batchnorm(concat_layer, filters)return output_layer# 构建FCN模型
def fcn_model(inputs, num_classes):# TODO Add Encoder Blocks.# Remember that with each encoder layer, the depth of your model (the number of filters) increases.# TODO 添加编码器模块。# 请记住，对于每个编码器层，模型的深度(过滤器的数量)都会增加。mid_layer_0 = encoder_block(inputs, filters=32, strides=2)print('mid_layer_0:', mid_layer_0)# TODO 使用conv2d_batchnorm()添加1x1卷积层。mid_layer_1 = conv2d_batchnorm(mid_layer_0, 32, 3, 1)print('mid_layer_1:', mid_layer_1)# TODO: 添加与编码器块数量相同的解码器块数量x = decoder_block(mid_layer_1, inputs, 32)# 该函数返回模型的输出层。“x”是从最后一个decoder_block()中获得的最后一层return layers.Conv2D(num_classes, 3, activation='softmax', padding='same')(x)# # 训练
# 以下单元格将利用您创建的模型并根据输入和类数定义输出层，随后将定义用于编译和训练模型的超参数
image_hw = 128
image_shape = (image_hw, image_hw, 3)
inputs = layers.Input(image_shape)
num_classes = 3# Call fcn_model()
output_layer = fcn_model(inputs, num_classes)# 定义超参数。
#
# batch_size：一次通过网络传播的训练样本/图像的数量。
# num_epochs：整个训练数据集通过网络传播的次数。
# steps_per_epoch：在1个时期内通过网络的训练图像的批次数。一种建议值是基于训练数据集中的图片总数除以batch_size。
# validation_steps：在1个时期内通过网络的验证图像的批数。这与steps_per_epoch相似，只不过validation_steps用于验证数据集。这里提供了默认值。
# worker：最多启动的进程数。这会影响训练速度，并取决于硬件配置。
learning_rate = 0.001
batch_size = 32
num_epochs = 2
steps_per_epoch = 200
validation_steps = 50
workers = 8"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
# Define the Keras model and compile it for training
model = models.Model(inputs=inputs, outputs=output_layer)model.compile(optimizer=keras.optimizers.Adam(learning_rate), loss='categorical_crossentropy')# Data iterators for loading the training and validation data
train_iter = data_iterator.BatchIteratorSimple(batch_size=batch_size,data_folder=os.path.join('..', 'data', 'train'),image_shape=image_shape,shift_aug=True)val_iter = data_iterator.BatchIteratorSimple(batch_size=batch_size,data_folder=os.path.join('..', 'data', 'validation'),image_shape=image_shape)logger_cb = plotting_tools.LoggerPlotter()
callbacks = [logger_cb]model.fit_generator(train_iter,steps_per_epoch = steps_per_epoch, # the number of batches per epoch,epochs = num_epochs, # the number of epochs to train for,validation_data = val_iter, # validation iteratorvalidation_steps = validation_steps, # the number of batches to validate oncallbacks=callbacks,workers = workers)# Save your trained model weights
weight_file_name = 'model_weights'
model_tools.save_network(model, weight_file_name)run_number = 'run1'
validation_path, output_path = model_tools.write_predictions_grade_set(model,run_number,'validation')im_files = plotting_tools.get_im_file_sample(run_number,validation_path)
for i in range(3):im_tuple = plotting_tools.load_images(im_files[i])plotting_tools.show_images(im_tuple)scoring_utils.score_run(validation_path, output_path)

input_shape: (?, 128, 128, 3)
encoder_shape: (?, 32, 32, 64)
1x1_shape: (?, 32, 32, 128)
upsampled_shape: (?, 64, 64, 128)
large_input_shape: (?, 64, 64, 32)
concat_layer_shape: (?, 64, 64, 160)
upsampled_shape: (?, 128, 128, 64)
large_input_shape: (?, 128, 128, 3)
concat_layer_shape: (?, 128, 128, 67)
output_shape: Tensor("batch_normalization_5/batchnorm/add_1:0", shape=(?, 128, 128, 32), dtype=float32)

Epoch 1/2
200/200 [==============================] - 823s - loss: 0.3584 - val_loss: 0.1122
Epoch 2/5
200/200 [==============================] - 836s - loss: 0.0561 - val_loss: 0.0936
Epoch 3/5
200/200 [==============================] - 833s - loss: 0.0501 - val_loss: 0.0782
Epoch 4/5
200/200 [==============================] - 925s - loss: 0.0465 - val_loss: 0.0716
Epoch 5/5
200/200 [==============================] - 829s - loss: 0.0456 - val_loss: 0.0640

（5）预测

以上是给出的某张验证图像。

这张是经过训练后的模型的输出，可以看出模型大致可以分出轮廓。

（6）评价

number of validation samples intersection over the union evaulated on 1184
average intersection over union for background is 0.9858371822735106
average intersection over union for other people is 0.14932455085825228
average intersection over union for hero is 0.0684055264892006
global average intersection over union is 0.40118908654032115

综合来看，这个模型的正确率还是很低的，因为模型比较简单，可以选择增加模型深度来获取更好的输出，在这里我因为时间关系，只能简单的构建模型然后训练了。

Udacity机器人软件工程师课程笔记（三十) - 语义分割与实例实现 - 使用keras实现语义分割相关推荐

Udacity机器人软件工程师课程笔记（十六）-机械臂仿真控制实例（其一）-Gazebo、RViz和Moveit！
机械臂仿真控制实例目录环境设置项目工具介绍 Gazebo (1)Gazebo组件 (2)Gazebo界面统一机器人描述格式(URDF) RViz Moveit! 1.环境设置对于此项目,使用 ...
Udacity机器人软件工程师课程笔记（十五）-运动学-正向运动学和反向运动学(其二)-DH参数等
正向运动学和反向运动学目录 2D中的旋转矩阵 sympy包旋转的合成旋转矩阵中的欧拉角平移齐次变换及其逆变换齐次变换的合成 Denavit-Hartenberg 参数 DH参数分配算法正 ...
Udacity机器人软件工程师课程笔记（十）-ROS-Catkin-包（package）和gazebo
包和gazebo仿真 1.添加包 (1)克隆simple_arm包克隆现有的包并将其添加到我们新创建的工作区. 首先导航到src目录,然后从其github仓库克隆本课程 simple_arm 的包. ...
Udacity机器人软件工程师课程笔记（十九) - 3D感知介绍 - 主动/被动式传感器、RGB-D相机、点云
3D感知介绍目录传感器 RGB-D相机点云 1.传感器主动式传感器是指向目标发射电磁波,然后收集从目标反射回来的电磁波信息的传感器,如合成孔径雷达等. 被动式传感器指只能收集地而目标反时来自太 ...
Udacity机器人软件工程师课程笔记（十八）-机械臂仿真控制实例（其三）-KR210机械臂反向运动学
机械臂仿真控制实例(其二)-KR210正向运动学目录反向运动学概述为Kuka KR210创建IK解算器 1.反向运动学概述 KR210的最后三个关节是满足三个相邻的关节轴线在单点处相交的旋转关节 ...
Udacity机器人软件工程师课程笔记（十四）-运动学-正向运动学和反向运动学(其一)
正向运动学和反向运动学目录 2D中的旋转矩阵 sympy包旋转的合成旋转矩阵中的欧拉角平移齐次变换及其逆变换齐次变换的合成 Denavit-Hartenberg 参数 DH参数分配算法正 ...
Udacity机器人软件工程师课程笔记（十二）-ROS-编写更复杂的ROS节点(arm_mover节点和 look_away 节点)
更复杂的ROS节点 1. Arm_mover节点为了打好更好的基础,这是在Arm_mover节点还需要学习的内容自定义消息生成服务参数启动文件为了理解上述内容,我们将编写另一个名为arm_ ...
Udacity机器人软件工程师课程笔记（五）-样本搜索和找回-基于漫游者号模拟器-自主驾驶
9.自主驾驶在接下来的环节中,我们要实现漫游者号的自动驾驶功能. 完成这个功能我们需要四个程序,第一个为感知程序,其对摄像头输入的图片进行变换处理和坐标变换使用.第二个程序为决策程序,功能是帮助漫游 ...
Udacity机器人软件工程师课程笔记（七）-ROS介绍和Turtlesim包的使用
Robotics Software engineer笔记 1.ROS简介与虚拟机配置 (1)ROS简介 ROS是一款机器人软件框架,即机器人操作系统(Robot Operating System). ...
Udacity机器人软件工程师课程笔记（三十六) - GraphSLAM
一.引入 GraphSLAM是解决完整的slam问题的slam算法.这意味着该算法将恢复整个路径和地图,而不仅仅是最近的姿势和地图.这种差异使它可以考虑当前姿势与先前姿势之间的依赖性.适用于我们的Gr ...

Udacity机器人软件工程师课程笔记（三十) - 语义分割与实例实现 - 使用keras实现语义分割