deeplearning-image-segmentation
deeplearning-image-segmentation copied to clipboard
Published
20 hours ago •
jayboxyz
jayboxyz
语义分割模型代码
先看个他人训练遥感图像数据的一些操作：
【天池直播间】图像语义分割在遥感影像中的应用_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili
创新点：
随机切割：
膨胀预测：
一、图像切割
写在前面，先熟悉如下一些函数：https://www.cnblogs.com/lemonbit/p/6864179.html
- x0 = random.randrange(0, w - crop_W + 1, 16) #randrange()方法返回指定递增基数集合中的一个随机数，基数默认值为1
- if np.random.randint(0, 2) == 0: #randint()生成在半开半闭区间[low,high)上离散均匀分布的整数值 0、1
- numpy.random.random(size=None) 生成[0,1)之间的浮点数
1、滑动裁剪
2、随机裁剪 random crop
# 随机窗口采样
def generate_train_dataset(image_num = 1000,
train_image_path='dataset/train/images/',
train_label_path='dataset/train/labels/'):
'''
该函数用来生成训练集，切图方法为随机切图采样
:param image_num: 生成样本的个数
:param train_image_path: 切图保存样本的地址
:param train_label_path: 切图保存标签的地址
:return:s
'''
# 用来记录所有的子图的数目
g_count = 1
images_path = ['dataset/origin/1.png', 'dataset/origin/2.png',
'dataset/origin/3.png', 'dataset/origin/4.png']
labels_path = ['dataset/origin/1_class.png', 'dataset/origin/2_class.png',
'dataset/origin/3_class.png', 'dataset/origin/4_class.png']
# 每张图片生成子图的个数
image_each = image_num // len(images_path)
image_path, label_path = [], []
for i in tqdm(range(len(images_path))):
count = 0
image = cv2.imread(images_path[i])
label = cv2.imread(labels_path[i], cv2.CAP_MODE_GRAY)
X_height, X_width = image.shape[0], image.shape[1]
while count < image_each:
random_width = random.randint(0, X_width - size - 1)
random_height = random.randint(0, X_height - size - 1)
image_ogi = image[random_height: random_height + size, random_width: random_width + size,:]
label_ogi = label[random_height: random_height + size, random_width: random_width + size]
image_d, label_d = data_augment(image_ogi, label_ogi)
image_path.append(train_image_path+'%05d.png' % g_count)
label_path.append(train_label_path+'%05d.png' % g_count)
cv2.imwrite((train_image_path+'%05d.png' % g_count), image_d)
cv2.imwrite((train_label_path+'%05d.png' % g_count), label_d)
count += 1
g_count += 1
df = pd.DataFrame({'image': image_path, 'label': label_path})
# df.to_csv('dataset/path_list.csv', index=False)
df.to_csv('dataset/'+ path_list, index=False)
二、数据增强
使用 python 图像处理库进行数据增强：
1、pil 库：图片处理库PIL
这是第一份
# 以下函数都是一些数据增强的函数
def gamma_transform(img, gamma):
gamma_table = [np.power(x / 255.0, gamma) * 255.0 for x in range(size)]
gamma_table = np.round(np.array(gamma_table)).astype(np.uint8)
return cv2.LUT(img, gamma_table)
def random_gamma_transform(img, gamma_vari):
log_gamma_vari = np.log(gamma_vari)
alpha = np.random.uniform(-log_gamma_vari, log_gamma_vari)
gamma = np.exp(alpha)
return gamma_transform(img, gamma)
def rotate(xb, yb, angle):
M_rotate = cv2.getRotationMatrix2D((size /2, size / 2), angle, 1)
xb = cv2.warpAffine(xb, M_rotate, (size, size))
yb = cv2.warpAffine(yb, M_rotate, (size, size))
return xb, yb
def blur(img):
img = cv2.blur(img, (3, 3))
return img
def add_noise(img):
for i in range(size): # 添加点噪声
temp_x = np.random.randint(0, img.shape[0])
temp_y = np.random.randint(0, img.shape[1])
img[temp_x][temp_y] = 255
return img
def data_augment(xb, yb):
if np.random.random() < 0.25:
xb, yb = rotate(xb, yb, 90)
if np.random.random() < 0.25:
xb, yb = rotate(xb, yb, 180)
if np.random.random() < 0.25:
xb, yb = rotate(xb, yb, 270)
if np.random.random() < 0.25:
xb = cv2.flip(xb, 1) # flipcode > 0：沿y轴翻转
yb = cv2.flip(yb, 1)
if np.random.random() < 0.25:
xb = random_gamma_transform(xb, 1.0)
if np.random.random() < 0.25:
xb = blur(xb)
# 双边过滤
if np.random.random() < 0.25:
xb =cv2.bilateralFilter(xb,9,75,75)
# 高斯滤波
if np.random.random() < 0.25:
xb = cv2.GaussianBlur(xb,(5,5),1.5)
if np.random.random() < 0.2:
xb = add_noise(xb)
return xb, yb
这里来自【深度学习中的数据增强与实现 https://www.jianshu.com/p/3e9f4812abbc】
# -*- coding:utf-8 -*-
"""数据增强
1. 翻转变换 flip
2. 随机修剪 random crop
3. 色彩抖动 color jittering
4. 平移变换 shift
5. 尺度变换 scale
6. 对比度变换 contrast
7. 噪声扰动 noise
8. 旋转变换/反射变换 Rotation/reflection
author: XiJun.Gong
date:2016-11-29
"""
from PIL import Image, ImageEnhance, ImageOps, ImageFile
import numpy as np
import random
import threading, os, time
import logging
logger = logging.getLogger(__name__)
ImageFile.LOAD_TRUNCATED_IMAGES = True
class DataAugmentation:
"""
包含数据增强的八种方式
"""
def __init__(self):
pass
@staticmethod
def openImage(image):
return Image.open(image, mode="r")
@staticmethod
def randomRotation(image, mode=Image.BICUBIC):
"""
对图像进行随机任意角度(0~360度)旋转
:param mode 邻近插值,双线性插值,双三次B样条插值(default)
:param image PIL的图像image
:return: 旋转转之后的图像
"""
random_angle = np.random.randint(1, 360)
return image.rotate(random_angle, mode)
@staticmethod
def randomCrop(image):
"""
对图像随意剪切,考虑到图像大小范围(68,68),使用一个一个大于(36*36)的窗口进行截图
:param image: PIL的图像image
:return: 剪切之后的图像
"""
image_width = image.size[0]
image_height = image.size[1]
crop_win_size = np.random.randint(40, 68)
random_region = (
(image_width - crop_win_size) >> 1, (image_height - crop_win_size) >> 1, (image_width + crop_win_size) >> 1,
(image_height + crop_win_size) >> 1)
return image.crop(random_region)
@staticmethod
def randomColor(image):
"""
对图像进行颜色抖动
:param image: PIL的图像image
:return: 有颜色色差的图像image
"""
random_factor = np.random.randint(0, 31) / 10. # 随机因子
color_image = ImageEnhance.Color(image).enhance(random_factor) # 调整图像的饱和度
random_factor = np.random.randint(10, 21) / 10. # 随机因子
brightness_image = ImageEnhance.Brightness(color_image).enhance(random_factor) # 调整图像的亮度
random_factor = np.random.randint(10, 21) / 10. # 随机因1子
contrast_image = ImageEnhance.Contrast(brightness_image).enhance(random_factor) # 调整图像对比度
random_factor = np.random.randint(0, 31) / 10. # 随机因子
return ImageEnhance.Sharpness(contrast_image).enhance(random_factor) # 调整图像锐度
@staticmethod
def randomGaussian(image, mean=0.2, sigma=0.3):
"""
对图像进行高斯噪声处理
:param image:
:return:
"""
def gaussianNoisy(im, mean=0.2, sigma=0.3):
"""
对图像做高斯噪音处理
:param im: 单通道图像
:param mean: 偏移量
:param sigma: 标准差
:return:
"""
for _i in range(len(im)):
im[_i] += random.gauss(mean, sigma)
return im
# 将图像转化成数组
img = np.asarray(image)
img.flags.writeable = True # 将数组改为读写模式
width, height = img.shape[:2]
img_r = gaussianNoisy(img[:, :, 0].flatten(), mean, sigma)
img_g = gaussianNoisy(img[:, :, 1].flatten(), mean, sigma)
img_b = gaussianNoisy(img[:, :, 2].flatten(), mean, sigma)
img[:, :, 0] = img_r.reshape([width, height])
img[:, :, 1] = img_g.reshape([width, height])
img[:, :, 2] = img_b.reshape([width, height])
return Image.fromarray(np.uint8(img))
@staticmethod
def saveImage(image, path):
image.save(path)
def makeDir(path):
try:
if not os.path.exists(path):
if not os.path.isfile(path):
# os.mkdir(path)
os.makedirs(path)
return 0
else:
return 1
except Exception, e:
print str(e)
return -2
def imageOps(func_name, image, des_path, file_name, times=5):
funcMap = {"randomRotation": DataAugmentation.randomRotation,
"randomCrop": DataAugmentation.randomCrop,
"randomColor": DataAugmentation.randomColor,
"randomGaussian": DataAugmentation.randomGaussian
}
if funcMap.get(func_name) is None:
logger.error("%s is not exist", func_name)
return -1
for _i in range(0, times, 1):
new_image = funcMap[func_name](image)
DataAugmentation.saveImage(new_image, os.path.join(des_path, func_name + str(_i) + file_name))
opsList = {"randomRotation", "randomCrop", "randomColor", "randomGaussian"}
def threadOPS(path, new_path):
"""
多线程处理事务
:param src_path: 资源文件
:param des_path: 目的地文件
:return:
"""
if os.path.isdir(path):
img_names = os.listdir(path)
else:
img_names = [path]
for img_name in img_names:
print img_name
tmp_img_name = os.path.join(path, img_name)
if os.path.isdir(tmp_img_name):
if makeDir(os.path.join(new_path, img_name)) != -1:
threadOPS(tmp_img_name, os.path.join(new_path, img_name))
else:
print 'create new dir failure'
return -1
# os.removedirs(tmp_img_name)
elif tmp_img_name.split('.')[1] != "DS_Store":
# 读取文件并进行操作
image = DataAugmentation.openImage(tmp_img_name)
threadImage = [0] * 5
_index = 0
for ops_name in opsList:
threadImage[_index] = threading.Thread(target=imageOps,
args=(ops_name, image, new_path, img_name,))
threadImage[_index].start()
_index += 1
time.sleep(0.2)
if __name__ == '__main__':
threadOPS("/home/pic-image/train/12306train",
"/home/pic-image/train/12306train3")
U-Net
## https://github.com/HLearning/unet_keras/blob/master/unet.py
def vgg10_unet(input_shape=(256,256,3), weights='imagenet'):
vgg16_model = VGG16(input_shape=input_shape, weights=weights, include_top=False)
block4_pool = vgg16_model.get_layer('block4_pool').output
block5_conv1 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block4_pool)
block5_conv2 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block5_conv1)
block5_drop = Dropout(0.5)(block5_conv2)
block6_up = Conv2D(512, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
UpSampling2D(size=(2, 2))(block5_drop))
block6_merge = concatenate(axis=3)([vgg16_model.get_layer('block4_conv3').output, block6_up])
block6_conv1 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block6_merge)
block6_conv2 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block6_conv1)
block6_conv3 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block6_conv2)
block7_up = Conv2D(256, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
UpSampling2D(size=(2, 2))(block6_conv3))
block7_merge = concatenate(axis=3)([vgg16_model.get_layer('block3_conv3').output, block7_up])
block7_conv1 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block7_merge)
block7_conv2 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block7_conv1)
block7_conv3 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block7_conv2)
block8_up = Conv2D(128, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
UpSampling2D(size=(2, 2))(block7_conv3))
block8_merge = concatenate(axis=3)([vgg16_model.get_layer('block2_conv2').output, block8_up])
block8_conv1 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block8_merge)
block8_conv2 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block8_conv1)
block9_up = Conv2D(64, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
UpSampling2D(size=(2, 2))(block8_conv2))
block9_merge = concatenate(axis=3)([vgg16_model.get_layer('block1_conv2').output, block9_up])
block9_conv1 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block9_merge)
block9_conv2 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block9_conv1)
block10_conv1 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block9_conv2)
block10_conv2 = Conv2D(1, 1, activation='sigmoid')(block10_conv1)
model = Model(inputs=vgg16_model.input, outputs=block10_conv2)
return model
segunet：
# https://github.com/ykamikawa/tf-keras-SegUNet
def segunet(input_shape, n_labels, kernel=3, pool_size=(2, 2), output_mode="softmax"):
inputs = Input(shape=input_shape)
# encoder 400-> 200
conv_1 = Convolution2D(64, (kernel, kernel), padding="same")(inputs)
conv_1 = BatchNormalization()(conv_1)
conv_1 = Activation("elu")(conv_1)
conv_2 = Convolution2D(64, (kernel, kernel), padding="same")(conv_1)
conv_2 = BatchNormalization()(conv_2)
conv_2 = Activation("elu")(conv_2)
pool_1, mask_1 = MaxPoolingWithArgmax2D(pool_size)(conv_2)
#200->100
conv_3 = Convolution2D(128, (kernel, kernel), padding="same")(pool_1)
conv_3 = BatchNormalization()(conv_3)
conv_3 = Activation("elu")(conv_3)
conv_4 = Convolution2D(128, (kernel, kernel), padding="same")(conv_3)
conv_4 = BatchNormalization()(conv_4)
conv_4 = Activation("elu")(conv_4)
pool_2, mask_2 = MaxPoolingWithArgmax2D(pool_size)(conv_4)
#100->50
conv_5 = Convolution2D(256, (kernel, kernel), padding="same")(pool_2)
conv_5 = BatchNormalization()(conv_5)
conv_5 = Activation("elu")(conv_5)
conv_6 = Convolution2D(256, (kernel, kernel), padding="same")(conv_5)
conv_6 = BatchNormalization()(conv_6)
conv_6 = Activation("elu")(conv_6)
conv_7 = Convolution2D(256, (kernel, kernel), padding="same")(conv_6)
conv_7 = BatchNormalization()(conv_7)
conv_7 = Activation("elu")(conv_7)
pool_3, mask_3 = MaxPoolingWithArgmax2D(pool_size)(conv_7)
# 50->25
conv_8 = Convolution2D(512, (kernel, kernel), padding="same")(pool_3)
conv_8 = BatchNormalization()(conv_8)
conv_8 = Activation("elu")(conv_8)
conv_9 = Convolution2D(512, (kernel, kernel), padding="same")(conv_8)
conv_9 = BatchNormalization()(conv_9)
conv_9 = Activation("elu")(conv_9)
conv_10 = Convolution2D(512, (kernel, kernel), padding="same")(conv_9)
conv_10 = BatchNormalization()(conv_10)
conv_10 = Activation("elu")(conv_10)
pool_4, mask_4 = MaxPoolingWithArgmax2D(pool_size)(conv_10)
# 25->13
# conv_11 = Convolution2D(512, (kernel, kernel), padding="same")(pool_4)
# conv_11 = BatchNormalization()(conv_11)
# conv_11 = Activation("relu")(conv_11)
# conv_12 = Convolution2D(512, (kernel, kernel), padding="same")(conv_11)
# conv_12 = BatchNormalization()(conv_12)
# conv_12 = Activation("relu")(conv_12)
# conv_13 = Convolution2D(512, (kernel, kernel), padding="same")(conv_12)
# conv_13 = BatchNormalization()(conv_13)
# conv_13 = Activation("relu")(conv_13)
#
# pool_5, mask_5 = MaxPoolingWithArgmax2D(pool_size)(conv_13) #13x13
print("Build enceder done..")
# between encoder and decoder
conv_11 = Convolution2D(512, (kernel, kernel), padding="same")(pool_4)
conv_11 = BatchNormalization()(conv_11)
conv_11 = Activation("elu")(conv_11)
conv_12 = Convolution2D(512, (kernel, kernel), padding="same")(conv_11)
conv_12 = BatchNormalization()(conv_12)
conv_12 = Activation("elu")(conv_12)
conv_13 = Convolution2D(512, (kernel, kernel), padding="same")(conv_12)
conv_13 = BatchNormalization()(conv_13)
conv_13 = Activation("elu")(conv_13)
# between encoder and decoder
# conv_14 = Convolution2D(512, (kernel, kernel), padding="same")(pool_5)
# conv_14 = BatchNormalization()(conv_14)
# conv_14 = Activation("relu")(conv_14)
# conv_15 = Convolution2D(512, (kernel, kernel), padding="same")(conv_14)
# conv_15 = BatchNormalization()(conv_15)
# conv_15 = Activation("relu")(conv_15)
# conv_16 = Convolution2D(512, (kernel, kernel), padding="same")(conv_15)
# conv_16 = BatchNormalization()(conv_16)
# conv_16 = Activation("relu")(conv_16)
# decoder 25->50
unpool_1 = MaxUnpooling2D(pool_size)([conv_13, mask_4])
concat_1 = Concatenate()([unpool_1, conv_10])
conv_17 = Convolution2D(512, (kernel, kernel), padding="same")(concat_1)
conv_17 = BatchNormalization()(conv_17)
conv_17 = Activation("elu")(conv_17)
conv_18 = Convolution2D(512, (kernel, kernel), padding="same")(conv_17)
conv_18 = BatchNormalization()(conv_18)
conv_18 = Activation("elu")(conv_18)
conv_19 = Convolution2D(256, (kernel, kernel), padding="same")(conv_18)
conv_19 = BatchNormalization()(conv_19)
conv_19 = Activation("elu")(conv_19)
unpool_2 = MaxUnpooling2D(pool_size)([conv_19, mask_3]) #50->100
concat_2 = Concatenate()([unpool_2, conv_7])
conv_20 = Convolution2D(256, (kernel, kernel), padding="same")(concat_2)
conv_20 = BatchNormalization()(conv_20)
conv_20 = Activation("elu")(conv_20)
conv_21 = Convolution2D(256, (kernel, kernel), padding="same")(conv_20)
conv_21 = BatchNormalization()(conv_21)
conv_21 = Activation("elu")(conv_21)
conv_22 = Convolution2D(128, (kernel, kernel), padding="same")(conv_21)
conv_22 = BatchNormalization()(conv_22)
conv_22 = Activation("elu")(conv_22)
unpool_3 = MaxUnpooling2D(pool_size)([conv_22, mask_2]) #100->200
concat_3 = Concatenate()([unpool_3, conv_4])
conv_23 = Convolution2D(128, (kernel, kernel), padding="same")(concat_3)
conv_23 = BatchNormalization()(conv_23)
conv_23 = Activation("elu")(conv_23)
conv_24 = Convolution2D(64, (kernel, kernel), padding="same")(conv_23)
conv_24 = BatchNormalization()(conv_24)
conv_24 = Activation("elu")(conv_24)
# conv_25 = Convolution2D(64, (kernel, kernel), padding="same")(conv_24)
# conv_25 = BatchNormalization()(conv_25)
# conv_25 = Activation("relu")(conv_25)
unpool_4 = MaxUnpooling2D(pool_size)([conv_24, mask_1]) #200->400
concat_4 = Concatenate()([unpool_4, conv_2])
# conv_26 = Convolution2D(128, (kernel, kernel), padding="same")(concat_4)
# conv_26 = BatchNormalization()(conv_26)
# conv_26 = Activation("relu")(conv_26)
# conv_27 = Convolution2D(64, (kernel, kernel), padding="same")(conv_26)
# conv_27 = BatchNormalization()(conv_27)
# conv_27 = Activation("relu")(conv_27)
#
# unpool_5 = MaxUnpooling2D(pool_size)([conv_27, mask_1])
# concat_5 = Concatenate()([unpool_5, conv_])
conv_28 = Convolution2D(64, (kernel, kernel), padding="same")(concat_4)
conv_28 = BatchNormalization()(conv_28)
conv_28 = Activation("elu")(conv_28)
conv_29 = Convolution2D(n_labels, (1, 1), padding="valid")(conv_28)
conv_29 = BatchNormalization()(conv_29)
conv_29 = Reshape((input_shape[0] * input_shape[1], n_labels), input_shape=(input_shape[0], input_shape[1], n_labels))(conv_29)
outputs = Activation(output_mode)(conv_29)
print("Build decoder done..")
segunet = Model(inputs=inputs, outputs=outputs, name="SegUNet")
return segunet
AttResUNet：
https://github.com/MoleImg/Attention_UNet/blob/master/AttResUNet.py
def Attention_ResUNet(dropout_rate=0.0, batch_norm=True):
SegNet
直接用的 UpSampling2D
def SegNet():
model = Sequential()
#encoder
model.add(Conv2D(64, (3, 3), strides=(1, 1), input_shape=(None, None, 4), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(64, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2)))
#(128,128)
model.add(Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2)))
#(64,64)
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2)))
#(32,32)
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2)))
#(16,16)
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2)))
#(8,8)
#decoder
model.add(UpSampling2D(size=(2, 2)))
#(16,16)
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(UpSampling2D(size=(2, 2)))
#(32,32)
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(UpSampling2D(size=(2, 2)))
#(64,64)
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(UpSampling2D(size=(2, 2)))
#(128,128)
model.add(Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(UpSampling2D(size=(2, 2)))
#(256,256)
model.add(Conv2D(64, (3, 3), strides=(1, 1), input_shape=(None, None, 4), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(64, (3, 3), strides=(1, 1), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(n_label, (1, 1), strides=(1, 1), padding='same'))
model.add(Reshape((n_label, -1)))
#axis=1和axis=2互换位置，等同于np.swapaxes(layer,1,2)
model.add(Permute((2, 1)))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])
model.summary()
return model
segnet：
def SegNet_(input_shape, num_classes):
img_input = Input(input_shape)
#encoder (256, 256)
x = Conv2D(64, (3, 3), activation="relu", padding="same")(img_input)
x = BatchNormalization()(x)
x = Conv2D(64, (3, 3), activation="relu", padding="same")(x)
x = BatchNormalization()(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
#(128, 128)
x = Conv2D(128, (3, 3), activation="relu", padding="same")(x)
x = BatchNormalization()(x)
x = Conv2D(128, (3, 3), activation="relu", padding="same")(x)
x = BatchNormalization()(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
#(64, 64)
x = Conv2D(256, (3, 3), activation="relu", padding="same")(x)
x = BatchNormalization()(x)
x = Conv2D(256, (3, 3), activation="relu", padding="same")(x)
x = BatchNormalization()(x)
x = Conv2D(256, (3, 3), activation="relu", padding="same")(x)
x = BatchNormalization()(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
#(32, 32)
x = Conv2D(512, (3, 3), activation="relu", padding="same")(x)
x = BatchNormalization()(x)
x = Conv2D(512, (3, 3), activation="relu", padding="same")(x)
x = BatchNormalization()(x)
x = Conv2D(512, (3, 3), activation="relu", padding="same")(x)
x = BatchNormalization()(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
# (16, 16)
x = Conv2D(512, (3, 3), activation="relu", padding="same")(x)
x = BatchNormalization()(x)
x = Conv2D(512, (3, 3), activation="relu", padding="same")(x)
x = BatchNormalization()(x)
x = Conv2D(512, (3, 3), activation="relu", padding="same")(x)
x = BatchNormalization()(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
# (8, 8)
#decoder
#(16, 16)
y = Conv2D(512, (3, 3), activation="relu", padding="same")(UpSampling2D(size=(2, 2))(x))
y = BatchNormalization()(y)
y = Conv2D(512, (3, 3), activation="relu", padding="same")(y)
y = BatchNormalization()(y)
y = Conv2D(512, (3, 3), activation="relu", padding="same")(y)
y = BatchNormalization()(y)
# (32, 32)
y = Conv2D(512, (3, 3), activation="relu", padding="same")(UpSampling2D(size=(2, 2))(y))
y = BatchNormalization()(y)
y = Conv2D(512, (3, 3), activation="relu", padding="same")(y)
y = BatchNormalization()(y)
y = Conv2D(512, (3, 3), activation="relu", padding="same")(y)
y = BatchNormalization()(y)
# (64, 64)
y = Conv2D(256, (3, 3), activation="relu", padding="same")(UpSampling2D(size=(2, 2))(y))
y = BatchNormalization()(y)
y = Conv2D(256, (3, 3), activation="relu", padding="same")(y)
y = BatchNormalization()(y)
y = Conv2D(256, (3, 3), activation="relu", padding="same")(y)
y = BatchNormalization()(y)
# (128, 128)
y = Conv2D(128, (3, 3), activation="relu", padding="same")(UpSampling2D(size=(2, 2))(y))
y = BatchNormalization()(y)
y = Conv2D(128, (3, 3), activation="relu", padding="same")(y)
y = BatchNormalization()(y)
# (256, 256)
y = Conv2D(64, (3, 3), activation="relu", padding="same")(UpSampling2D(size=(2, 2))(y))
y = BatchNormalization()(y)
y = Conv2D(64, (3, 3), activation="relu", padding="same")(y)
y = BatchNormalization()(y)
y = Conv2D(n_label, (1, 1), padding="same")(y)
# y = Reshape((-1, n_label))(y)
y = Reshape((n_label, -1))(y)
y = Permute((2, 1))(y) # axis=1和axis=2互换位置
y = Activation("softmax")(y)
model = Model(inputs=img_input, outputs=y)
model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])
model.summary()
return model