语义分割 | segnet 制作自己的数据，如何训练，如何测试,如何评价

本是古典何须时尚 2022-02-20 12:17 747阅读 0赞

本博文介绍如何手把手制作自己的数据集，并使用SegNet网络进行语义分割，如何训练，如何测试自己的分割模型。

\----------------------------------------------------------------------------------------------------------------------------------------------------------

感谢：

1.源码参考cudnn5版本的caffe-segnet，https://github.com/TimoSaemann/caffe-segnet-cudnn5

2.作者的官方指导文档：http://mi.eng.cam.ac.uk/projects/segnet/tutorial.html

3.一份使用指导：https://github.com/TqDavid/SegNet-Tutorial/tree/master/CamVid

4.如果想测试SegNet的效果，这里有官方的在线测试demo: http://mi.eng.cam.ac.uk/projects/segnet/\#demo

5.一份segnet的预训练model

https://github.com/alexgkendall/SegNet-Tutorial/blob/master/Example\_Models/segnet\_model\_zoo.md，以及相对应的  
segnet\_basic\_inference.prototxt  
segnet\_basic\_solver.prototxt  
segnet\_basic\_train.prototxt

6.参考了该博主的文章https://blog.csdn.net/caicai2526/article/details/77170223

7.以及该博主的文章https://blog.csdn.net/hjxu2016/article/details/77994925

8.对于已有mask和image,需要resize,可参考https://blog.csdn.net/u013249853/article/details/79827469

\--------------------------------------------------------------------------------------------------------------------------------------------------------------

言归正传，开始正题。

下载上述caffe-segnet-cudnn5版本的代码，其路径后文称之为caffe\_root,以下的操作都在该caffe\_root目录下进行。

整体目录包含如下文件（夹）：

一、制作自己数据集

SegNet网络需要两个输入，一个是原始图像，三通道的;一个是mask label,也就是待分割目标的标签，mask要求是单通道8位灰度图，格式是uint8, 像素0表示背景，像素1表示目标的位置。 下面分别准备这两样东西。

1. 原始图像就是你自己的照片了，注意一下：如果你不更改SegNet中参数，可以先保持与原作者的图像尺寸一致，后面可以根据自己的情况在更改，一般上采样2x，这里采用与原作者相同的图像尺寸，（360， 480）彩色图片，如果不是这样，建议resize一下，博主自己的图片是灰度的，resize前有一个转成rgb的过程，python代码函数；

\# testdir为自己数据集路径，楼主的图是灰度图，所以有一个转换成rgb的过程，然后保存。  
def resize\_image\_batch():  
file\_list = os.listdir(testdir)  
for item in file\_list:  
\#print(traindir + item)  
imname = testdir + item  
im = cv2.imread(imname, 0)  
im = cv2.resize(im, (480, 360))  
im\_RGB = cv2.cvtColor(im, cv2.COLOR\_GRAY2RGB)  
print(im.shape)  
print(im\_RGB.shape)  
\#print(im)  
print("============================")  
\#print(im\_RGB\[:,:,0\])  
\#print(im\_RGB\[:,:,1\])  
\#print(im\_RGB\[:,:,2\])  
print(im.dtype)  
print(im\_RGB.dtype)  
cv2.imwrite('zht\_test\_use/'+ item, im\_RGB)  
\#print("success!")

2.准备mask。

首先，博主的mask来源是用labelme 得到的。labelme的使用方法，这里不再赘述。简言之，对于每一张图，我们可以得到其

json标注文件， 再通过，labelme\_json\_to\_dataset命令，可以得到最终我们需要的label mask，我们所需的是文件夹下的label.png。

labelme\_json\_to\_dataset批量生成数据集的shell脚本如下;

for item in $(find ./huaweishouji\_20170720\_train\_360x480\_try -iname "\*.json");  
do  
echo $item;  
labelme\_json\_to\_dataset $item;  
done

接下来将lable.png转换成uint8，背景像素是0，目标像素是1的mask..convert\_to\_mask 代码如下：

def convert\_to\_mask():  
file\_list = os.listdir(traindir)  
for item in file\_list:  
item\_list = os.listdir(traindir + item)  
\#print("len(item) : ", len(item\_list))  
for atom in item\_list:  
if atom == "label.png":  
np.set\_printoptions(threshold='nan')  
imname = traindir + item + "/" + atom  
\#print(imname)  
im = io.imread(imname, 1)  
print(imname)  
\#print(im\[:, :\])  
print(im.shape)  
print(im.dtype)  
print("-------------after-----------------")  
img = (im \* 255).astype(np.uint8)  
\_, im\_th= cv2.threshold(img, 0.0000000000000001, 1, cv2.THRESH\_BINARY)  
  
\#print(img.shape)  
  
print(im\_th.shape)  
print(im\_th.dtype)  
\#print(im\_th\[ :, :\])  
print(item\[:-5\] + ".png")  
cv2.imwrite(train\_write\_dir + item\[:-5\] + '.png', im\_th )  
\#print(im\[:,:,0\])  
\#print(im\[:,:,1\])  
\#print(im\[:,:,2\])  
\#im\_RGB = cv2.cvtColor(im, cv2.COLOR\_GRAY2RGB)  
\#print(traindir + item)  
\#imname = traindir + item  
\#im = cv2.imread(imname, 0)  
\#im = cv2.resize(im, (480, 360))  
\#im\_RGB = cv2.cvtColor(im, cv2.COLOR\_GRAY2RGB)  
  
\#print(im.shape)  
\#print(im\_RGB.shape)  
\#print(im)  
\#print("============================")  
\#print(im\_RGB\[:,:,0\])  
\#print(im\_RGB\[:,:,1\])  
\#print(im\_RGB\[:,:,2\])  
\#print(im.dtype)  
\#print(im\_RGB.dtype)  
\#cv2.imwrite('huaweishouji\_20170720\_test\_360x480/'+ item, im\_RGB)  
def check\_mask():  
file\_list = os.listdir(train\_write\_dir)  
for item in file\_list:  
np.set\_printoptions(threshold='nan')  
\#item\_list = os.listdir(test\_write\_dir)  
imname = train\_write\_dir + item  
\#print("len(item) : ", len(item\_list))  
print(item)

check\_mask（）是检验函数。验证背景是0，目标是1，且为uint8编码。

将上述原始图像和mask，划分出训练集和测试集，分别放置在caffe\_root/data/mydata/train和test下。mydata/下的结构是如图，

，其中train/和test/ 结构如下：，image/和mask/下分别是上面得到的图像和mask文件。注意图像和mask名称保持一致。

3.准备上面mydata/下的train.txt和test.txt，然后我们需要制作一个txt的列表，左边是原图的根目录路径，右边是mask图的根目录路径，中间以空格隔开，一定要注意，mask的路径和原图的路径一定要对，列表形式如下：

/home/hjxu/caffe\_examples/segnet\_xu/data/test/image/8900\_11800.tiff /home/hjxu/caffe\_examples/segnet\_xu/data/test/mask/8500\_10200\_ConfidenceMap.png  
/home/hjxu/caffe\_examples/segnet\_xu/data/test/image/10100\_9800.tiff /home/hjxu/caffe\_examples/segnet\_xu/data/test/mask/8900\_11800\_ConfidenceMap.png  
/home/hjxu/caffe\_examples/segnet\_xu/data/test/image/8900\_9000.tiff /home/hjxu/caffe\_examples/segnet\_xu/data/test/mask/9300\_10200\_ConfidenceMap.png  
/home/hjxu/caffe\_examples/segnet\_xu/data/test/image/8900\_10200.tiff /home/hjxu/caffe\_examples/segnet\_xu/data/test/mask/8900\_9000\_ConfidenceMap.png

具体的shell脚本

\#!/usr/bin/env sh  
DATA\_train=/home/ccf/CCF/Cell\_segnet/data/data\_train\_enhancement/train/image  
MASK\_train=/home/ccf/CCF/Cell\_segnet/data/data\_train\_enhancement/train/mask  
DATA\_test=/home/ccf/CCF/Cell\_segnet/data/data\_train\_enhancement/test/image  
MASK\_test=/home/ccf/CCF/Cell\_segnet/data/data\_train\_enhancement/test/mask  
MY=/home/ccf/CCF/Cell\_segnet/data/data\_train\_enhancement  
  
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#  
rm -rf $MY/train.txt  
  
echo "Create train.txt"  
find $DATA\_train/ -name "\*.tif">>$MY/img.txt  
find $MASK\_train/ -name "\*.tif">>$MY/mask.txt  
paste -d " " $MY/img.txt $MY/mask.txt>$MY/train.txt  
  
rm -rf $MY/img.txt  
rm -rf $MY/mask.txt  
  
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#  
rm -rf $MY/test.txt  
  
echo "Create test.txt"  
find $DATA\_test/ -name "\*.tif">>$MY/img.txt  
find $MASK\_test/ -name "\*.tif">>$MY/mask.txt  
paste -d " " $MY/img.txt $MY/mask.txt>$MY/test.txt  
  
rm -rf $MY/img.txt  
rm -rf $MY/mask.txt

可以适当修改，以适应自己的路径。

二、训练

训练之前，在训练的时候我们可以根据自己训练的要求更改分割的类型，segnet对原来是11中类型，在博主只有两种类型，这就会遇到对网络的修改，同时数据输入的也是一样原来的是360\*480，网络中的修改根据个人的要求以及效果进行修改，修改输出层参数num\_output为2，以及class-weighting，只有两个。要注意的是上采样upsample这个参数的修改，以及最后的class\_weighting，对于class\_weighting个数以及参数是根据自己的数据以及要求设定，输出几个类别class\_weighting就有几个，对于class\_weighting参数的确定是根据训练数据的mask中每一种类型的label确定的，就算方法：（all\_label/class）/label,下面是计算的matlab算法代码：

clear;  
clc;  
Path='C:\\\\Users\\\\xxxxx\\\\Desktop\\\\mask\\\\'  
% save\_mask\_path='/home/ccf/CCF/Cell\_segnet/data/mask\_change/'  
files=dir(Path);  
  
%element = \[\];  
for k=3:length(files)  
k  
subpath=\[Path,files(k).name\];  
name=files(k).name;  
image=imread(subpath);  
I=image;  
name  
I  
img=uint8(zeros(360,480));  
\[x,y\]=find(I==0);  
for i=1:length(x)  
img(x(i),y(i))=0;  
end  
\[x,y\]=find(I==1);  
for i=1:length(x)  
img(x(i),y(i))=1;  
end  
% imwrite(img,\[save\_mask\_path,name\]);  
label\_num=double(unique(img));  
element(:,1)=\[0;1\];  
if (length(element(:,1))==length(label\_num))  
element(:,1)=label\_num;  
end  
for j=1:length(label\_num)  
a=label\_num(j);  
e=length(find(img==a));  
element(j,i-1)=e;  
end  
end  
num=element(:,2:end);  
sum\_num=sum(num,2);  
median=sum(sum\_num)/length(sum\_num);  
class\_weighting=median./sum\_num;  
total=\[element(:,1),class\_weighting\];  
save('class\_weight.mat','total');

最后查看class\_weighting中保存的值即可，博主是2类，所有最后生成的class\_weighting有两个值，ignore\_label=2，num\_outout = 2;完毕。

训练模型需要的东西：

预训练模型：

Segnet Basic model file: segnet\_basic\_camvid.prototxt weights: \[http://mi.eng.cam.ac.uk/~agk34/resources/SegNet/segnet\_basic\_camvid.caffemodel\]

solver.prototxt如下所示，train.prototxt就不贴了，因为有些长。

net: "examples/segnet/segnet\_train.prototxt" \# Change this to the absolute path to your model file  
test\_initialization: false  
test\_iter: 1  
test\_interval: 10000000  
base\_lr: 0.01 \#0.1  
lr\_policy: "step"  
gamma: 1.0  
stepsize: 50 \#10000000  
display: 20  
momentum: 0.9  
max\_iter: 50000  
weight\_decay: 0.0005  
snapshot: 50\#1000  
snapshot\_prefix: "examples/segnet/segnet\_train/segnet\_basic/seg" \# Change this to the absolute path to where you wish to output solver snapshots  
solver\_mode: GPU

\#!bin/sh  
./build/tools/caffe train -gpu 2,3 -solver examples/segnet/segnet\_solver.prototxt -weights examples/segnet/segnet\_train/premodel/segnet\_basic\_camvid.caffemodel \# This will begin training SegNet-Basic on GPU 0

上面就是训练脚本了。完毕。

三、测试

1.生成含bn层的推理模型，脚本是：

\#!bin/sh  
echo "------------------generating bn statistics is begin-----------------------------"  
python generate\_bn\_statistics.py examples/segnet/segnet\_train.prototxt examples/segnet/segnet\_train/segnet\_basic/seg\_iter\_15700.caffemodel models/inference \# compute BN statistics for SegNet  
echo "------------------generating bn statistics is end-----------------------------"

generate\_bn\_statistics.py如下：

\#-\*-coding:utf8-\*-  
\#!/usr/bin/env python  
import os  
import numpy as np  
from skimage.io import ImageCollection  
from argparse import ArgumentParser  
  
  
  
  
caffe\_root = '/data/xxxxxx/caffe-segnet-cudnn/caffe-segnet-cudnn5/' \# Change this to the absolute directoy to SegNet Caffe  
import sys  
sys.path.insert(0, caffe\_root + 'python')  
  
import caffe  
from caffe.proto import caffe\_pb2  
from google.protobuf import text\_format  
  
  
def extract\_dataset(net\_message):  
assert net\_message.layer\[0\].type == "DenseImageData"  
source = net\_message.layer\[0\].dense\_image\_data\_param.source  
with open(source) as f:  
data = f.read().split()  
ims = ImageCollection(data\[::2\])  
labs = ImageCollection(data\[1::2\])  
assert len(ims) == len(labs) > 0  
return ims, labs  
  
  
def make\_testable(train\_model\_path):  
\# load the train net prototxt as a protobuf message  
with open(train\_model\_path) as f:  
train\_str = f.read()  
train\_net = caffe\_pb2.NetParameter()  
text\_format.Merge(train\_str, train\_net)  
  
\# add the mean, var top blobs to all BN layers  
for layer in train\_net.layer:  
if layer.type == "BN" and len(layer.top) == 1:  
layer.top.append(layer.top\[0\] + "-mean")  
layer.top.append(layer.top\[0\] + "-var")  
  
\# remove the test data layer if present  
if train\_net.layer\[1\].name == "data" and train\_net.layer\[1\].include:  
train\_net.layer.remove(train\_net.layer\[1\])  
if train\_net.layer\[0\].include:  
\# remove the 'include \{phase: TRAIN\}' layer param  
train\_net.layer\[0\].include.remove(train\_net.layer\[0\].include\[0\])  
return train\_net  
  
  
def make\_test\_files(testable\_net\_path, train\_weights\_path, num\_iterations,  
in\_h, in\_w):  
\# load the train net prototxt as a protobuf message  
with open(testable\_net\_path) as f:  
testable\_str = f.read()  
testable\_msg = caffe\_pb2.NetParameter()  
text\_format.Merge(testable\_str, testable\_msg)  
  
bn\_layers = \[l.name for l in testable\_msg.layer if l.type == "BN"\]  
bn\_blobs = \[l.top\[0\] for l in testable\_msg.layer if l.type == "BN"\]  
bn\_means = \[l.top\[1\] for l in testable\_msg.layer if l.type == "BN"\]  
bn\_vars = \[l.top\[2\] for l in testable\_msg.layer if l.type == "BN"\]  
  
net = caffe.Net(testable\_net\_path, train\_weights\_path, caffe.TEST)  
  
\# init our blob stores with the first forward pass  
res = net.forward()  
bn\_avg\_mean = \{bn\_mean: np.squeeze(res\[bn\_mean\]).copy() for bn\_mean in bn\_means\}  
bn\_avg\_var = \{bn\_var: np.squeeze(res\[bn\_var\]).copy() for bn\_var in bn\_vars\}  
  
\# iterate over the rest of the training set  
for i in xrange(1, num\_iterations):  
res = net.forward()  
for bn\_mean in bn\_means:  
bn\_avg\_mean\[bn\_mean\] += np.squeeze(res\[bn\_mean\])  
for bn\_var in bn\_vars:  
bn\_avg\_var\[bn\_var\] += np.squeeze(res\[bn\_var\])  
print 'progress: \{\}/\{\}'.format(i, num\_iterations)  
  
\# compute average means and vars  
for bn\_mean in bn\_means:  
bn\_avg\_mean\[bn\_mean\] /= num\_iterations  
for bn\_var in bn\_vars:  
bn\_avg\_var\[bn\_var\] /= num\_iterations  
  
for bn\_blob, bn\_var in zip(bn\_blobs, bn\_vars):  
m = np.prod(net.blobs\[bn\_blob\].data.shape) / np.prod(bn\_avg\_var\[bn\_var\].shape)  
bn\_avg\_var\[bn\_var\] \*= (m / (m - 1))  
  
\# calculate the new scale and shift blobs for all the BN layers  
scale\_data = \{bn\_layer: np.squeeze(net.params\[bn\_layer\]\[0\].data)  
for bn\_layer in bn\_layers\}  
shift\_data = \{bn\_layer: np.squeeze(net.params\[bn\_layer\]\[1\].data)  
for bn\_layer in bn\_layers\}  
  
var\_eps = 1e-9  
new\_scale\_data = \{\}  
new\_shift\_data = \{\}  
for bn\_layer, bn\_mean, bn\_var in zip(bn\_layers, bn\_means, bn\_vars):  
gamma = scale\_data\[bn\_layer\]  
beta = shift\_data\[bn\_layer\]  
Ex = bn\_avg\_mean\[bn\_mean\]  
Varx = bn\_avg\_var\[bn\_var\]  
new\_gamma = gamma / np.sqrt(Varx + var\_eps)  
new\_beta = beta - (gamma \* Ex / np.sqrt(Varx + var\_eps))  
  
new\_scale\_data\[bn\_layer\] = new\_gamma  
new\_shift\_data\[bn\_layer\] = new\_beta  
print "New data:"  
print new\_scale\_data.keys()  
print new\_shift\_data.keys()  
  
\# assign computed new scale and shift values to net.params  
for bn\_layer in bn\_layers:  
net.params\[bn\_layer\]\[0\].data\[...\] = new\_scale\_data\[bn\_layer\].reshape(  
net.params\[bn\_layer\]\[0\].data.shape  
)  
net.params\[bn\_layer\]\[1\].data\[...\] = new\_shift\_data\[bn\_layer\].reshape(  
net.params\[bn\_layer\]\[1\].data.shape  
)  
  
\# build a test net prototxt  
test\_msg = testable\_msg  
\# replace data layers with 'input' net param  
data\_layers = \[l for l in test\_msg.layer if l.type.endswith("Data")\]  
for data\_layer in data\_layers:  
test\_msg.layer.remove(data\_layer)  
test\_msg.input.append("data")  
test\_msg.input\_dim.append(1)  
test\_msg.input\_dim.append(3)  
test\_msg.input\_dim.append(in\_h)  
test\_msg.input\_dim.append(in\_w)  
\# Set BN layers to INFERENCE so they use the new stat blobs  
\# and remove mean, var top blobs.  
for l in test\_msg.layer:  
if l.type == "BN":  
if len(l.top) > 1:  
dead\_tops = l.top\[1:\]  
for dl in dead\_tops:  
l.top.remove(dl)  
l.bn\_param.bn\_mode = caffe\_pb2.BNParameter.INFERENCE  
\# replace output loss, accuracy layers with a softmax  
dead\_outputs = \[l for l in test\_msg.layer if l.type in \["SoftmaxWithLoss", "Accuracy"\]\]  
out\_bottom = dead\_outputs\[0\].bottom\[0\]  
for dead in dead\_outputs:  
test\_msg.layer.remove(dead)  
test\_msg.layer.add(  
name="prob", type="Softmax", bottom=\[out\_bottom\], top=\['prob'\]  
)  
return net, test\_msg  
  
  
def make\_parser():  
p = ArgumentParser()  
p.add\_argument('train\_model')  
p.add\_argument('weights')  
p.add\_argument('out\_dir')  
return p  
  
  
if \_\_name\_\_ == '\_\_main\_\_':  
caffe.set\_mode\_gpu()  
p = make\_parser()  
args = p.parse\_args()  
  
\# build and save testable net  
if not os.path.exists(args.out\_dir):  
os.makedirs(args.out\_dir)  
print "Building BN calc net..."  
testable\_msg = make\_testable(args.train\_model)  
BN\_calc\_path = os.path.join(  
args.out\_dir, '\_\_for\_calculating\_BN\_stats\_' + os.path.basename(args.train\_model)  
)  
with open(BN\_calc\_path, 'w') as f:  
f.write(text\_format.MessageToString(testable\_msg))  
  
\# use testable net to calculate BN layer stats  
print "Calculate BN stats..."  
train\_ims, train\_labs = extract\_dataset(testable\_msg)  
train\_size = len(train\_ims)  
minibatch\_size = testable\_msg.layer\[0\].dense\_image\_data\_param.batch\_size  
num\_iterations = train\_size // minibatch\_size + train\_size % minibatch\_size  
in\_h, in\_w =(360, 480) \#记得修改和自己图片一样的大小  
test\_net, test\_msg = make\_test\_files(BN\_calc\_path, args.weights, num\_iterations,  
in\_h, in\_w)  
  
\# save deploy prototxt  
\#print "Saving deployment prototext file..."  
\#test\_path = os.path.join(args.out\_dir, "deploy.prototxt")  
\#with open(test\_path, 'w') as f:  
\# f.write(text\_format.MessageToString(test\_msg))  
  
print "Saving test net weights..."  
test\_net.save(os.path.join(args.out\_dir, "test\_weights\_15750.caffemodel")) \#记得修改迭代多少次命名  
print "done"

2.生成预测图片

脚本：

\#!bin/sh  
echo "-------------------test segmentation is begin---------------------"  
python test\_segmentation.py --model models/inference/segmentation\_inference.prototxt --weights models/inference/test\_weights\_15750.caffemodel --iter 26 \#12250 \#15750 \# Test SegNet  
echo "-------------------test segmentation is end---------------------"

test\_segmentation.py

\#-\*-coding=utf8-\*-  
import numpy as np  
import matplotlib.pyplot as plt  
import os.path  
import json  
import scipy  
import argparse  
import math  
import pylab  
from sklearn.preprocessing import normalize  
import cv2  
caffe\_root = '/data/xxxxxx/caffe-segnet-cudnn/caffe-segnet-cudnn5/' \# Change this to the absolute directoy to SegNet Caffe  
import sys  
sys.path.insert(0, caffe\_root + 'python')  
  
import caffe  
  
\# Import arguments  
parser = argparse.ArgumentParser()  
parser.add\_argument('--model', type=str, required=True)  
parser.add\_argument('--weights', type=str, required=True)  
parser.add\_argument('--iter', type=int, required=True)  
args = parser.parse\_args()  
  
caffe.set\_mode\_gpu()  
  
net = caffe.Net(args.model,  
args.weights,  
caffe.TEST)  
  
  
for i in range(0, args.iter):  
  
net.forward()  
print(i)  
image = net.blobs\['data'\].data  
\#print(image.shape)  
label = net.blobs\['label'\].data  
\#print(label.shape)  
predicted = net.blobs\['prob'\].data \#predicted: float32  
  
\# convert np.float64 to np.uint8  
\#image = (image\* 50000).astype(np.uint8)  
\#lahel = (label \* 50000).astype(np.uint8)  
\#predicted = (predicted \* 50000).astype(np.uint8)  
  
\#print(predicted.shape)  
image = np.squeeze(image\[0,:,:,:\])  
output = np.squeeze(predicted\[0,:,:,:\])  
ind = np.argmax(output, axis=0)  
cv2.imwrite(str(i%26) + "predicted.png", ind \* 100)\# predicted: float32, this predicated is kuoda \* 100  
r = ind.copy()  
g = ind.copy()  
b = ind.copy()  
r\_gt = label.copy()  
g\_gt = label.copy()  
b\_gt = label.copy()  
\#print(output.shape)  
\#print(output.dtype)  
\#print(output)  
\# Sky = \[128,128,128\]  
\# Building = \[128,0,0\]  
\# Pole = \[192,192,128\]  
\# Road\_marking = \[255,69,0\]  
\# Road = \[128,64,128\]  
\# Pavement = \[60,40,222\]  
\# Tree = \[128,128,0\]  
\# SignSymbol = \[192,128,128\]  
\# Fence = \[64,64,128\]  
\# Car = \[64,0,128\]  
\# Pedestrian = \[64,64,0\]  
\# Bicyclist = \[0,128,192\]  
\# Unlabelled = \[0,0,0\]  
  
\# label\_colours = np.array(\[Sky, Building, Pole, Road, Pavement, Tree, SignSymbol, Fence, Car, Pedestrian, Bicyclist, Unlabelled\])  
BG = \[0,0,0\]  
M = \[0,255,0\]  
label\_colours = np.array(\[BG, M\])  
for l in range(0,2):  
r\[ind==l\] = label\_colours\[l,0\]  
g\[ind==l\] = label\_colours\[l,1\]  
b\[ind==l\] = label\_colours\[l,2\]  
r\_gt\[label==l\] = label\_colours\[l,0\]  
g\_gt\[label==l\] = label\_colours\[l,1\]  
b\_gt\[label==l\] = label\_colours\[l,2\]  
\# we do not normalize  
rgb = np.zeros((ind.shape\[0\], ind.shape\[1\], 3))  
rgb\[:,:,0\] = r\#/255.0  
rgb\[:,:,1\] = g\#/255.0  
rgb\[:,:,2\] = b\#/255.0  
rgb\_gt = np.zeros((ind.shape\[0\], ind.shape\[1\], 3))  
rgb\_gt\[:,:,0\] = r\_gt\#/255.0  
rgb\_gt\[:,:,1\] = g\_gt\#/255.0  
rgb\_gt\[:,:,2\] = b\_gt\#/255.0  
  
image = image\#/255.0  
  
image = np.transpose(image, (1,2,0))  
output = np.transpose(output, (1,2,0))  
image = image\[:,:,(2,1,0)\]  
  
  
\#scipy.misc.toimage(rgb, cmin=0.0, cmax=255).save(IMAGE\_FILE+'\_segnet.png') \#保存文件  
  
cv2.imwrite(str(i%26)+'image.png', image.astype(np.uint8))  
cv2.imwrite(str(i%26)+'rgb\_gt.png', rgb\_gt.astype(np.uint8))  
cv2.imwrite(str(i%26)+'rgb.png', rgb.astype(np.uint8))  
  
  
\#plt.figure()  
\#plt.imshow(image,vmin=0, vmax=1) \#显示源文件  
\#plt.figure()  
\#plt.imshow(rgb\_gt,vmin=0, vmax=1) \#给的mask图片，如果测试的图片没有mask，可以随便放个图片列表，省的修改代码  
\#plt.figure()  
\#plt.imshow(rgb,vmin=0, vmax=1) \# 预测图片  
\#plt.show()  
  
  
print 'Success!'

四、mean IOU 评价的计算

\#!/usr/bin/python  
  
import numpy as np  
from skimage import io  
import cv2  
  
def pixel\_accuracy(eval\_segm, gt\_segm):  
'''  
sum\_i(n\_ii) / sum\_i(t\_i)  
'''  
  
check\_size(eval\_segm, gt\_segm)  
  
cl, n\_cl = extract\_classes(gt\_segm)  
eval\_mask, gt\_mask = extract\_both\_masks(eval\_segm, gt\_segm, cl, n\_cl)  
  
sum\_n\_ii = 0  
sum\_t\_i = 0  
  
for i, c in enumerate(cl):  
curr\_eval\_mask = eval\_mask\[i, :, :\]  
curr\_gt\_mask = gt\_mask\[i, :, :\]  
  
sum\_n\_ii += np.sum(np.logical\_and(curr\_eval\_mask, curr\_gt\_mask))  
sum\_t\_i += np.sum(curr\_gt\_mask)  
  
if (sum\_t\_i == 0):  
pixel\_accuracy\_ = 0  
else:  
pixel\_accuracy\_ = sum\_n\_ii / sum\_t\_i  
  
return pixel\_accuracy\_  
  
def mean\_accuracy(eval\_segm, gt\_segm):  
'''  
(1/n\_cl) sum\_i(n\_ii/t\_i)  
'''  
  
check\_size(eval\_segm, gt\_segm)  
  
cl, n\_cl = extract\_classes(gt\_segm)  
eval\_mask, gt\_mask = extract\_both\_masks(eval\_segm, gt\_segm, cl, n\_cl)  
  
accuracy = list(\[0\]) \* n\_cl  
  
for i, c in enumerate(cl):  
curr\_eval\_mask = eval\_mask\[i, :, :\]  
curr\_gt\_mask = gt\_mask\[i, :, :\]  
  
n\_ii = np.sum(np.logical\_and(curr\_eval\_mask, curr\_gt\_mask))  
t\_i = np.sum(curr\_gt\_mask)  
  
if (t\_i != 0):  
accuracy\[i\] = n\_ii / t\_i  
  
mean\_accuracy\_ = np.mean(accuracy)  
return mean\_accuracy\_  
  
def mean\_IU(eval\_segm, gt\_segm):  
'''  
(1/n\_cl) \* sum\_i(n\_ii / (t\_i + sum\_j(n\_ji) - n\_ii))  
'''  
  
check\_size(eval\_segm, gt\_segm)  
  
cl, n\_cl = union\_classes(eval\_segm, gt\_segm)  
\_, n\_cl\_gt = extract\_classes(gt\_segm)  
eval\_mask, gt\_mask = extract\_both\_masks(eval\_segm, gt\_segm, cl, n\_cl)  
  
IU = list(\[0\]) \* n\_cl  
  
for i, c in enumerate(cl):  
curr\_eval\_mask = eval\_mask\[i, :, :\]  
curr\_gt\_mask = gt\_mask\[i, :, :\]  
  
if (np.sum(curr\_eval\_mask) == 0) or (np.sum(curr\_gt\_mask) == 0):  
continue  
  
n\_ii = np.sum(np.logical\_and(curr\_eval\_mask, curr\_gt\_mask))  
t\_i = np.sum(curr\_gt\_mask)  
n\_ij = np.sum(curr\_eval\_mask)  
  
IU\[i\] = n\_ii / (t\_i + n\_ij - n\_ii)  
  
mean\_IU\_ = np.sum(IU) / n\_cl\_gt  
return mean\_IU\_  
  
def frequency\_weighted\_IU(eval\_segm, gt\_segm):  
'''  
sum\_k(t\_k)^(-1) \* sum\_i((t\_i\*n\_ii)/(t\_i + sum\_j(n\_ji) - n\_ii))  
'''  
  
check\_size(eval\_segm, gt\_segm)  
  
cl, n\_cl = union\_classes(eval\_segm, gt\_segm)  
eval\_mask, gt\_mask = extract\_both\_masks(eval\_segm, gt\_segm, cl, n\_cl)  
  
frequency\_weighted\_IU\_ = list(\[0\]) \* n\_cl  
  
for i, c in enumerate(cl):  
curr\_eval\_mask = eval\_mask\[i, :, :\]  
curr\_gt\_mask = gt\_mask\[i, :, :\]  
  
if (np.sum(curr\_eval\_mask) == 0) or (np.sum(curr\_gt\_mask) == 0):  
continue  
  
n\_ii = np.sum(np.logical\_and(curr\_eval\_mask, curr\_gt\_mask))  
t\_i = np.sum(curr\_gt\_mask)  
n\_ij = np.sum(curr\_eval\_mask)  
  
frequency\_weighted\_IU\_\[i\] = (t\_i \* n\_ii) / (t\_i + n\_ij - n\_ii)  
  
sum\_k\_t\_k = get\_pixel\_area(eval\_segm)  
  
frequency\_weighted\_IU\_ = np.sum(frequency\_weighted\_IU\_) / sum\_k\_t\_k  
return frequency\_weighted\_IU\_  
  
'''  
Auxiliary functions used during evaluation.  
'''  
def get\_pixel\_area(segm):  
return segm.shape\[0\] \* segm.shape\[1\]  
  
def extract\_both\_masks(eval\_segm, gt\_segm, cl, n\_cl):  
eval\_mask = extract\_masks(eval\_segm, cl, n\_cl)  
gt\_mask = extract\_masks(gt\_segm, cl, n\_cl)  
  
return eval\_mask, gt\_mask  
  
def extract\_classes(segm):  
cl = np.unique(segm)  
n\_cl = len(cl)  
  
return cl, n\_cl  
  
def union\_classes(eval\_segm, gt\_segm):  
eval\_cl, \_ = extract\_classes(eval\_segm)  
gt\_cl, \_ = extract\_classes(gt\_segm)  
  
cl = np.union1d(eval\_cl, gt\_cl)  
n\_cl = len(cl)  
  
return cl, n\_cl  
  
def extract\_masks(segm, cl, n\_cl):  
h, w = segm\_size(segm)  
masks = np.zeros((n\_cl, h, w))  
  
for i, c in enumerate(cl):  
masks\[i, :, :\] = segm == c  
  
return masks  
  
def segm\_size(segm):  
try:  
height = segm.shape\[0\]  
width = segm.shape\[1\]  
except IndexError:  
raise  
  
return height, width  
  
def check\_size(eval\_segm, gt\_segm):  
h\_e, w\_e = segm\_size(eval\_segm)  
h\_g, w\_g = segm\_size(gt\_segm)  
  
if (h\_e != h\_g) or (w\_e != w\_g):  
raise EvalSegErr("DiffDim: Different dimensions of matrices!")  
  
'''  
Exceptions  
'''  
class EvalSegErr(Exception):  
def \_\_init\_\_(self, value):  
self.value = value  
  
def \_\_str\_\_(self):  
return repr(self.value)  
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#now we do some eval.  
\# test image only 1 image  
def eval\_segm(preddir, gtdir):  
pred = io.imread(preddir, 1)  
gt = io.imread(gtdir, 1)  
pred = (pred ).astype(np.uint8)  
np.set\_printoptions(threshold='nan')  
\#print(pred\[10:50,:\])  
\_, pred\_th= cv2.threshold(pred, 0.0000000000000001, 1, cv2.THRESH\_BINARY)  
\#print(gt\[10:50,:\])  
gt = (gt).astype(np.uint8)  
\_, gt\_th= cv2.threshold(gt, 0.0000000000000001, 1, cv2.THRESH\_BINARY)  
  
pixel\_accu = pixel\_accuracy(pred\_th, gt\_th)  
mean\_accu = mean\_accuracy(pred\_th, gt\_th)  
mean\_iou = mean\_IU(pred\_th, gt\_th)  
fw\_iou = frequency\_weighted\_IU(pred\_th, gt\_th)  
print("pixel\_accu is: ", pixel\_accu)  
print("mean\_accu is: ", mean\_accu)  
print("mean\_iou is: ",mean\_iou)  
print("fw\_iou is: ", fw\_iou)  
return pixel\_accu, mean\_accu, mean\_iou, fw\_iou  
\# test batch image  
def eval\_batch(rootdir):  
res\_sum = \[\]  
pixel\_accu = 0.0  
mean\_accu = 0.0  
mean\_iou = 0.0  
fw\_iou = 0.0  
  
for i in range(16):  
preddir = rootdir + str(i)+"predicted.png"  
gtdir = rootdir + str(i) + "rgb\_gt.png"  
print("===============%d==================", i)  
resperimage = eval\_segm(preddir, gtdir)  
res\_sum.append(resperimage)  
\# compute avg eval metrics  
print("==================avg eval seg=========================")  
len\_res\_sum = len(res\_sum)  
for i in range(len\_res\_sum):  
pixel\_accu += res\_sum\[i\]\[0\]  
mean\_accu += res\_sum\[i\]\[1\]  
mean\_iou += res\_sum\[i\]\[2\]  
fw\_iou += res\_sum\[i\]\[3\]  
print("avg pixel\_accu : ", pixel\_accu / len\_res\_sum, "avg mean\_accu : ", mean\_accu / len\_res\_sum,\\  
"avg mean\_iou : ", mean\_iou / len\_res\_sum, "avg fw\_iou : ", fw\_iou/len\_res\_sum)  
  
\# get the contours of huizibiao  
def get\_contour(imagedir, preddir):  
\#np.set\_printoptions(threshold='nan')  
  
pred = io.imread(preddir, 1)  
print(pred.dtype)  
\#print(pred\[:,10:50\])  
pred = (pred ).astype(np.uint8)  
\#print(" ")  
image = io.imread(imagedir, 1) \# because it is float64  
print(image.dtype)  
print(image.shape)  
\#print(image\[:,10:50\])  
image = (image\* 255).astype(np.uint8)  
\#cv2.imwrite("image.png",image)  
\_, pred\_th= cv2.threshold(pred, 0.0000000000000001, 1, cv2.THRESH\_BINARY)  
contours, \_ = cv2.findContours(pred\_th,cv2.RETR\_EXTERNAL, cv2.CHAIN\_APPROX\_NONE)  
  
pred\_contours = image  
  
for i in range(len(contours)):  
cv2.drawContours(pred\_contours, contours\[i\], -1, (0, 255, 0), 1)  
  
return pred\_contours  
\# batch test contours of huizibiao  
def get\_contour\_batch(rootdir):  
for i in range(16):  
preddir = rootdir + str(i)+"predicted.png"  
imagedir = rootdir + str(i) + "image.png"  
print("=================================", i)  
cv2.imwrite(str(i)+"image\_countours.png", get\_contour(imagedir, preddir))  
  
if \_\_name\_\_ == "\_\_main\_\_":  
'''  
\# test only one image.  
preddir = "/data/xxxxxx/caffe-segnet-cudnn/caffe-segnet-cudnn5/test\_result/3\_iter7700/2/predicted.png"  
gtdir = "/data/xxxxx/caffe-segnet-cudnn/caffe-segnet-cudnn5/test\_result/3\_iter7700/2/rgb\_gt.png"  
eval\_segm(preddir, gtdir)  
'''  
  
\# test batch image  
\#rootdir = "/data/xxxxxxxx/caffe-segnet-cudnn/caffe-segnet-cudnn5/test\_result/116/iter17w/"  
rootdir = "/data/xxxxxxxx/caffe-segnet-cudnn/caffe-segnet-cudnn5/"  
\#eval\_batch(rootdir)  
  
\#draw contours on the one image  
\#preddir = "/data/xxxxx/caffe-segnet-cudnn/caffe-segnet-cudnn5/0predicted.png"  
\#imagedir = "/data/xxxxx/caffe-segnet-cudnn/caffe-segnet-cudnn5/0image.png"  
\#get\_contour(imagedir, preddir)  
  
\#test batch  
get\_contour\_batch(rootdir)

楼主最后的mean IOU 是95.19%。

至此完毕。  
\---------------------  
作者：努力努力再努力tq  
来源：CSDN  
原文：https://blog.csdn.net/u012426298/article/details/81386817  
版权声明：本文为博主原创文章，转载请附上博文链接！