最近做实验，用Keras改网络的朋友可以参考下
数据读入data.py
from __future__ import print_function
from keras.preprocessing.image import ImageDataGenerator
import numpy as np
import os
import cv2
import glob
import skimage.io as io
import skimage.transform as trans
from skimage import img_as_ubyte
Sky = [128,128,128]
Building = [128,0,0]
Pole = [192,192,128]
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]
COLOR_DICT = np.array([Sky, Building, Pole, Road, Pavement,
Tree, SignSymbol, Fence, Car, Pedestrian, Bicyclist, Unlabelled])
def adjustData(img,mask,flag_multi_class,num_class):
if(flag_multi_class):
img = img / 255
mask = mask[:,:,:,0] if(len(mask.shape) == 4) else mask[:,:,0]
new_mask = np.zeros(mask.shape + (num_class,))
for i in range(num_class):
#for one pixel in the image, find the class in mask and convert it into one-hot vector
#index = np.where(mask == i)
#index_mask = (index[0],index[1],index[2],np.zeros(len(index[0]),dtype = np.int64) + i) if (len(mask.shape) == 4) else (index[0],index[1],np.zeros(len(index[0]),dtype = np.int64) + i)
#new_mask[index_mask] = 1
new_mask[mask == i,i] = 1
new_mask = np.reshape(new_mask,(new_mask.shape[0],new_mask.shape[1]*new_mask.shape[2],new_mask.shape[3])) if flag_multi_class else np.reshape(new_mask,(new_mask.shape[0]*new_mask.shape[1],new_mask.shape[2]))
mask = new_mask
elif(np.max(img) > 1):
img = img / 255.0
mask = mask /255.0
mask[mask > 0.5] = 1
mask[mask <= 0.5] = 0
return (img,mask)
def trainGenerator(batch_size,train_path,image_folder,mask_folder,aug_dict,image_color_mode = "rgb",
mask_color_mode = "grayscale",image_save_prefix = "image",mask_save_prefix = "mask",
flag_multi_class = False,num_class = 2,save_to_dir = None,target_size = (256,256),seed = 1):
'''
can generate image and mask at the same time
use the same seed for image_datagen and mask_datagen to ensure the transformation for image and mask is the same
if you want to visualize the results of generator, set save_to_dir = "your path"
mask_color_mode = "grayscale"
'''
image_datagen = ImageDataGenerator(**aug_dict)
mask_datagen = ImageDataGenerator(**aug_dict)
image_generator = image_datagen.flow_from_directory(
train_path,
classes = [image_folder],
class_mode = None,
color_mode = image_color_mode,
target_size = target_size,
batch_size = batch_size,
save_to_dir = save_to_dir,
save_prefix = image_save_prefix,
seed = seed)
mask_generator = mask_datagen.flow_from_directory(
train_path,
classes = [mask_folder],
class_mode = None,
color_mode = mask_color_mode,
target_size = target_size,
batch_size = batch_size,
save_to_dir = save_to_dir,
save_prefix = mask_save_prefix,
seed = seed)
train_generator = zip(image_generator, mask_generator)
for (img,mask) in train_generator:
img,mask = adjustData(img,mask,flag_multi_class,num_class)
yield (img,mask)
def testGenerator(test_path,num_image = 30,target_size = (448,448),flag_multi_class = False,as_gray = True):
imgs = os.listdir(test_path)
for im in imgs:
# img = io.imread(os.path.join(test_path,im),as_gray = as_gray)
img = io.imread(os.path.join(test_path,im))
img = img / 255.0
# img = trans.resize(img,target_size)
# img = np.reshape(img,img.shape+(1,)) if (not flag_multi_class) else img
img = np.reshape(img,(1,)+img.shape)
yield img
# for i in range(num_image):
# img = io.imread(os.path.join(test_path,"%d.png"%i),as_gray = as_gray)
# img = img / 255
# img = trans.resize(img,target_size)
# img = np.reshape(img,img.shape+(1,)) if (not flag_multi_class) else img
# img = np.reshape(img,(1,)+img.shape)
# yield img
def geneTrainNpy(image_path,mask_path,flag_multi_class = False,num_class = 2,image_prefix = "image",mask_prefix = "mask",image_as_gray = True,mask_as_gray = True):
image_name_arr = glob.glob(os.path.join(image_path,"%s*.png"%image_prefix))
image_arr = []
mask_arr = []
for index,item in enumerate(image_name_arr):
img = io.imread(item,as_gray = image_as_gray)
img = np.reshape(img,img.shape + (1,)) if image_as_gray else img
mask = io.imread(item.replace(image_path,mask_path).replace(image_prefix,mask_prefix),as_gray = mask_as_gray)
mask = np.reshape(mask,mask.shape + (1,)) if mask_as_gray else mask
img,mask = adjustData(img,mask,flag_multi_class,num_class)
image_arr.append(img)
mask_arr.append(mask)
image_arr = np.array(image_arr)
mask_arr = np.array(mask_arr)
return image_arr,mask_arr
def labelVisualize(num_class,color_dict,img):
img = img[:,:,0] if len(img.shape) == 3 else img
img_out = np.zeros(img.shape + (3,))
for i in range(num_class):
img_out[img == i,:] = color_dict[i]
return img_out / 255.0
def saveResult(save_path,npyfile,names,flag_multi_class = False,num_class = 2):
# for i,item in enumerate(npyfile):
# img = labelVisualize(num_class,COLOR_DICT,item) if flag_multi_class else item[:,:,0]
# io.imsave(os.path.join(save_path,"%d_predict.png"%i),img)
for i,item in enumerate(npyfile):
if flag_multi_class:
img = labelVisualize(num_class,COLOR_DICT,item)
else:
img = item[:,:,0]
# img = cv2.resize(img, (500, 500), interpolation = cv2.INTER_NEAREST)
# print(np.max(img), np.min(img))
img[img>0.5] = 255
img[img<=0.5] = 0
io.imsave(os.path.join(save_path,"%s"%names[i]),img)
# name = names[i].split('.')[0]
# io.imsave(os.path.join(save_path,"%s.tif"%name),img_as_ubyte(img))
精度评定eval.py
# -*- coding: utf-8 -*-
import os
import cv2
import numpy as np
from sklearn.metrics import confusion_matrix
class IOUMetric:
"""
Class to calculate mean-iou using fast_hist method
"""
def __init__(self, num_classes):
self.num_classes = num_classes
self.hist = np.zeros((num_classes, num_classes))
def _fast_hist(self, label_pred, label_true):
mask = (label_true >= 0) & (label_true < self.num_classes)
hist = np.bincount(
self.num_classes * label_true[mask].astype(int) +
label_pred[mask], minlength=self.num_classes ** 2).reshape(self.num_classes, self.num_classes)
return hist
def evaluate(self, predictions, gts):
for lp, lt in zip(predictions, gts):
assert len(lp.flatten()) == len(lt.flatten())
self.hist += self._fast_hist(lp.flatten(), lt.flatten())
# miou
iou = np.diag(self.hist) / (self.hist.sum(axis=1) + self.hist.sum(axis=0) - np.diag(self.hist))
miou = np.nanmean(iou)
# mean acc
acc = np.diag(self.hist).sum() / self.hist.sum()
acc_cls = np.nanmean(np.diag(self.hist) / self.hist.sum(axis=1))
freq = self.hist.sum(axis=1) / self.hist.sum()
fwavacc = (freq[freq > 0] * iou[freq > 0]).sum()
return acc, acc_cls, iou, miou, fwavacc
if __name__ == '__main__':
label_path = 'D:/wcs/dense_seg/build/test/labels/'
predict_path = 'D:/wcs/dense_seg/re/'
pres = os.listdir(predict_path)
labels = []
predicts = []
for im in pres:
if im[-4:] == '.png':
label_name = im.split('.')[0] + '.png'
lab_path = os.path.join(label_path, label_name)
pre_path = os.path.join(predict_path, im)
label = cv2.imread(lab_path,0)
pre = cv2.imread(pre_path,0)
label[label>0] = 1
pre[pre>0] = 1
labels.append(label)
predicts.append(pre)
el = IOUMetric(2)
acc, acc_cls, iou, miou, fwavacc = el.evaluate(predicts, labels)
print('acc: ',acc)
print('acc_cls: ',acc_cls)
print('iou: ',iou)
print('miou: ',miou)
print('fwavacc: ',fwavacc)
pres = os.listdir(predict_path)
init = np.zeros((2,2))
for im in pres:
lb_path = os.path.join(label_path, im)
pre_path = os.path.join(predict_path, im)
lb = cv2.imread(lb_path,0)
pre = cv2.imread(pre_path,0)
lb[lb>0] = 1
pre[pre>0] = 1
lb = lb.flatten()
pre = pre.flatten()
confuse = confusion_matrix(lb, pre)
init += confuse
precision = init[1][1]/(init[0][1] + init[1][1])
recall = init[1][1]/(init[1][0] + init[1][1])
accuracy = (init[0][0] + init[1][1])/init.sum()
f1_score = 2*precision*recall/(precision + recall)
print('class_accuracy: ', precision)
print('class_recall: ', recall)
print('accuracy: ', accuracy)
print('f1_score: ', f1_score)
1.训练，测试代码DenseNet.py
import numpy as np
import keras
from keras.engine import Layer
import keras.backend as K
from keras.models import Model, save_model, load_model
from keras.layers import Input, Dense, Dropout, BatchNormalization, LeakyReLU, concatenate
from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, GlobalAveragePooling2D
from keras.models import *
from keras.layers import *
from data import *
from keras.models import load_model
from keras.optimizers import *
from keras.callbacks import ModelCheckpoint, TensorBoard, LearningRateScheduler
def DenseLayer(x, nb_filter, bn_size=4, alpha=0.0, drop_rate=0.2):
# Bottleneck layers
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(bn_size*nb_filter, (1, 1), strides=(1,1), padding='same')(x)
# Composite function
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (3, 3), strides=(1,1), padding='same')(x)
if drop_rate: x = Dropout(drop_rate)(x)
return x
def DenseBlock(x, nb_layers, growth_rate, drop_rate=0.2):
for ii in range(nb_layers):
conv = DenseLayer(x, nb_filter=growth_rate, drop_rate=drop_rate)
x = concatenate([x, conv], axis=3)
return x
def TransitionLayer(x, compression=0.5, alpha=0.0, is_max=1):
nb_filter = int(x.shape.as_list()[-1]*compression)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (1, 1), strides=(1,1), padding='same')(x)
if is_max != 0: x = MaxPooling2D(pool_size=(2, 2), strides=2)(x)
else: x = AveragePooling2D(pool_size=(2, 2), strides=2)(x)
return x
IMAGE_ORDERING = 'channels_last'
def dense_seg(n_classes=1, input_size = (256,256,1), pretrained_weights = None):
growth_rate = 12
drop_rate = 0.2
inpt = Input(input_size)
x = Conv2D(growth_rate*2, (3, 3), strides=1, padding='same')(inpt)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=0.1)(x)
x = DenseBlock(x, 12, growth_rate, drop_rate=0.2)
x = TransitionLayer(x)
x = DenseBlock(x, 12, growth_rate, drop_rate=0.2)
x = TransitionLayer(x)
x = DenseBlock(x, 12, growth_rate, drop_rate=0.2)
x = TransitionLayer(x)
x = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x)
x = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x)
x = (Conv2D( 256, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x)
x = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x)
x = (Conv2D( 128, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x)
x = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x)
x = (Conv2D( 64, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Conv2D(n_classes , (3, 3) , padding='same', data_format=IMAGE_ORDERING )(x)
x = Conv2D(1, 1, activation = 'sigmoid')(x)
model = Model(inpt, x)
model.compile(optimizer = Adam(lr = 5e-5), loss = 'binary_crossentropy', metrics = ['accuracy'])
model.summary()
if(pretrained_weights):
model.load_weights(pretrained_weights)
return model
def scheduler(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 1 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.95)
print("lr changed to {}".format(lr * 0.95))
return K.get_value(model.optimizer.lr)
if __name__ == '__main__':
data_gen_args = dict(
# rotation_range=0.2,
# width_shift_range=0.05,
# height_shift_range=0.05,
# shear_range=0.05,
# zoom_range=0.1,
horizontal_flip=True,
vertical_flip=True,
fill_mode='nearest')
data_gen_args = dict()
train_Gene = trainGenerator(3,'./build/train','images','labels',data_gen_args,save_to_dir = None)
model = dense_seg(input_size = (256,256,3), pretrained_weights = './logs/build_1.h5')
reduce_lr = LearningRateScheduler(scheduler)
model_checkpoint = ModelCheckpoint(os.path.join('./logs/', 'build_2.h5'), monitor='accuracy',verbose=1, save_best_only=True)
tensorboard = TensorBoard(log_dir='./logs', histogram_freq=0,write_graph=True, write_images=False)
model.fit_generator(train_Gene,
# validation_data=val_Gene,
# validation_steps=4,
steps_per_epoch=1644,
epochs=40,
shuffle=True,
callbacks=[reduce_lr, model_checkpoint, tensorboard])
# callbacks=[model_checkpoint, tensorboard])
# path = 'D:/wcs/dense_seg/build/test/images/'
# save_path = 'D:/wcs/dense_seg/re/'
# names = os.listdir(path)
# model = load_model('./logs/build_3.h5')
# testGene = testGenerator(path)
# results = model.predict_generator(testGene,360,verbose=1)
# saveResult(save_path,results,names)
acc: 0.9409253862169054
acc_cls: 0.8964666522092115
iou: [0.93015432 0.72302761]
miou: 0.826590963614625
fwavacc: 0.8914602548522483
class_accuracy: 0.7147935949168034
class_recall: 0.7003612432690246
accuracy: 0.8504329528087138
f1_score: 0.7075038254590356
2.训练，测试代码DenseNet2.py
import numpy as np
import keras
from keras.engine import Layer
import keras.backend as K
from keras.models import Model, save_model, load_model
from keras.layers import Input, Dense, Dropout, BatchNormalization, LeakyReLU, concatenate
from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, GlobalAveragePooling2D
from keras.models import *
from keras.layers import *
from data import *
from keras.models import load_model
from keras.optimizers import *
from keras.callbacks import ModelCheckpoint, TensorBoard, LearningRateScheduler
def DenseLayer(x, nb_filter, bn_size=4, alpha=0.0, drop_rate=0.2):
# Bottleneck layers
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(bn_size*nb_filter, (1, 1), strides=(1,1), padding='same')(x)
# Composite function
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (3, 3), strides=(1,1), padding='same')(x)
if drop_rate: x = Dropout(drop_rate)(x)
return x
def DenseBlock(x, nb_layers, growth_rate, drop_rate=0.2):
for ii in range(nb_layers):
conv = DenseLayer(x, nb_filter=growth_rate, drop_rate=drop_rate)
x = concatenate([x, conv], axis=3)
return x
def TransitionLayer(x, compression=0.5, alpha=0.0, is_max=1):
nb_filter = int(x.shape.as_list()[-1]*compression)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (1, 1), strides=(1,1), padding='same')(x)
if is_max != 0: x = MaxPooling2D(pool_size=(2, 2), strides=2)(x)
else: x = AveragePooling2D(pool_size=(2, 2), strides=2)(x)
return x
#=================================================== residual_block =================================================
def BatchActivate(x):
x = BatchNormalization()(x)
x = Activation('relu')(x)
return x
def convolution_block(x, filters, size, strides=(1,1), padding='same', activation=True):
x = Conv2D(filters, size, strides=strides, padding=padding)(x)
if activation == True:
x = BatchActivate(x)
return x
# residual_block
def residual_block(blockInput, num_filters=16, batch_activate = False):
x = BatchActivate(blockInput)
x = convolution_block(x, num_filters, (3,3) )
x = convolution_block(x, num_filters, (3,3), activation=False)
x = Add()([x, blockInput])
if batch_activate:
x = BatchActivate(x)
return x
#=================================================== residual_block =================================================
IMAGE_ORDERING = 'channels_last'
def dense_seg(n_classes=1, input_size = (256,256,1), pretrained_weights = None):
growth_rate = 12
drop_rate = 0.2
inpt = Input(input_size)
x = Conv2D(growth_rate*2, (3, 3), strides=1, padding='same')(inpt)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=0.1)(x)
x = DenseBlock(x, 12, growth_rate, drop_rate=0.2)
x = TransitionLayer(x)
x = DenseBlock(x, 12, growth_rate, drop_rate=0.2)
x = TransitionLayer(x)
x = DenseBlock(x, 12, growth_rate, drop_rate=0.2)
x = TransitionLayer(x)
x = residual_block(x, num_filters=129)
x = residual_block(x, num_filters=129, batch_activate = True)
x = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x)
x = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x)
x = (Conv2D( 256, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x)
x = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x)
x = (Conv2D( 128, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x)
x = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x)
x = (Conv2D( 64, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Conv2D(n_classes , (3, 3) , padding='same', data_format=IMAGE_ORDERING )(x)
x = Conv2D(1, 1, activation = 'sigmoid')(x)
model = Model(inpt, x)
model.summary()
model.compile(optimizer = Adam(lr = 1e-3), loss = 'binary_crossentropy', metrics = ['accuracy'])
if(pretrained_weights):
model.load_weights(pretrained_weights)
return model
def scheduler(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 1 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.95)
print("lr changed to {}".format(lr * 0.95))
return K.get_value(model.optimizer.lr)
def scheduler2(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 50 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.5)
print("lr changed to {}".format(lr * 0.5))
return K.get_value(model.optimizer.lr)
if __name__ == '__main__':
data_gen_args = dict(
# rotation_range=0.2,
# width_shift_range=0.05,
# height_shift_range=0.05,
# shear_range=0.05,
# zoom_range=0.1,
horizontal_flip=True,
vertical_flip=True,
fill_mode='nearest')
data_gen_args = dict()
train_Gene = trainGenerator(6,'./build/train','images','labels',data_gen_args,save_to_dir = None)
model = dense_seg(input_size = (256,256,3), pretrained_weights = None)
reduce_lr = LearningRateScheduler(scheduler2)
model_checkpoint = ModelCheckpoint(os.path.join('./logs/', 'build_rs.h5'), monitor='acc',verbose=1, save_best_only=True)
tensorboard = TensorBoard(log_dir='./logs', histogram_freq=0,write_graph=True, write_images=False)
model.fit_generator(train_Gene,
# validation_data=val_Gene,
# validation_steps=4,
steps_per_epoch=822,
epochs=100,
shuffle=True,
callbacks=[reduce_lr, model_checkpoint, tensorboard])
# callbacks=[model_checkpoint, tensorboard])
# path = './build/test/images/'
# save_path = './re/'
# names = os.listdir(path)
# model = load_model('./logs/build_rs.h5')
# testGene = testGenerator(path)
# results = model.predict_generator(testGene,360,verbose=1)
# saveResult(save_path,results,names)
acc: 0.9393964979383681
acc_cls: 0.892688597872882
iou: [0.9284631 0.71606213]
miou: 0.822262613439277
fwavacc: 0.8887837334801199
class_accuracy: 0.7258091400593357
class_recall: 0.7072045651261849
accuracy: 0.8603447808159722
f1_score: 0.7163860825655127
3.训练，测试代码DenseNet3.py
import numpy as np
import keras
from keras.engine import Layer
import keras.backend as K
from keras.models import Model, save_model, load_model
from keras.layers import Input, Dense, Dropout, BatchNormalization, LeakyReLU, concatenate
from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, GlobalAveragePooling2D
from keras.models import *
from keras.layers import *
from data import *
from keras.models import load_model
from keras.optimizers import *
from keras.callbacks import ModelCheckpoint, TensorBoard, LearningRateScheduler
def DenseLayer(x, nb_filter, bn_size=4, alpha=0.0, drop_rate=0.2):
# Bottleneck layers
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(bn_size*nb_filter, (1, 1), strides=(1,1), padding='same')(x)
# Composite function
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (3, 3), strides=(1,1), padding='same')(x)
if drop_rate: x = Dropout(drop_rate)(x)
return x
def DenseBlock(x, nb_layers, growth_rate, drop_rate=0.2):
for ii in range(nb_layers):
conv = DenseLayer(x, nb_filter=growth_rate, drop_rate=drop_rate)
x = concatenate([x, conv], axis=3)
return x
def TransitionLayer(x, compression=0.5, alpha=0.0, is_max=1):
nb_filter = int(x.shape.as_list()[-1]*compression)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (1, 1), strides=(1,1), padding='same')(x)
if is_max != 0: x = MaxPooling2D(pool_size=(2, 2), strides=2)(x)
else: x = AveragePooling2D(pool_size=(2, 2), strides=2)(x)
return x
#=================================================== residual_block =================================================
def BatchActivate(x):
x = BatchNormalization()(x)
x = Activation('relu')(x)
return x
def convolution_block(x, filters, size, strides=(1,1), padding='same', activation=True):
x = Conv2D(filters, size, strides=strides, padding=padding)(x)
if activation == True:
x = BatchActivate(x)
return x
# residual_block
def residual_block(blockInput, num_filters=16, batch_activate = False):
x = BatchActivate(blockInput)
x = convolution_block(x, num_filters, (3,3) )
x = convolution_block(x, num_filters, (3,3), activation=False)
x = Add()([x, blockInput])
if batch_activate:
x = BatchActivate(x)
return x
#=================================================== residual_block =================================================
IMAGE_ORDERING = 'channels_last'
def dense_seg(n_classes=1, input_size = (256,256,1), pretrained_weights = None):
growth_rate = 12
drop_rate = 0.2
inpt = Input(input_size)
x = Conv2D(growth_rate*2, (3, 3), strides=1, padding='same')(inpt)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=0.1)(x)
x = DenseBlock(x, 12, growth_rate, drop_rate=0.2)
x = TransitionLayer(x)
x = residual_block(x, num_filters=84)
x = residual_block(x, num_filters=84, batch_activate = True)
x = DenseBlock(x, 12, growth_rate, drop_rate=0.2)
x = TransitionLayer(x)
x = residual_block(x, num_filters=114)
x = residual_block(x, num_filters=114, batch_activate = True)
x = DenseBlock(x, 12, growth_rate, drop_rate=0.2)
x = TransitionLayer(x)
x = residual_block(x, num_filters=129)
x = residual_block(x, num_filters=129, batch_activate = True)
x = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x)
x = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x)
x = (Conv2D( 256, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x)
x = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x)
x = (Conv2D( 128, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x)
x = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x)
x = (Conv2D( 64, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2D(n_classes , (3, 3) , padding='same', data_format=IMAGE_ORDERING )(x)
x = Conv2D(1, 1, activation = 'sigmoid')(x)
model = Model(inpt, x)
model.summary()
model.compile(optimizer = Adam(lr = 1e-3), loss = 'binary_crossentropy', metrics = ['accuracy'])
if(pretrained_weights):
model.load_weights(pretrained_weights)
return model
def scheduler(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 1 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.95)
print("lr changed to {}".format(lr * 0.95))
return K.get_value(model.optimizer.lr)
def scheduler2(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 50 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.5)
print("lr changed to {}".format(lr * 0.5))
return K.get_value(model.optimizer.lr)
if __name__ == '__main__':
data_gen_args = dict(
# rotation_range=0.2,
# width_shift_range=0.05,
# height_shift_range=0.05,
# shear_range=0.05,
# zoom_range=0.1,
horizontal_flip=True,
vertical_flip=True,
fill_mode='nearest')
data_gen_args = dict()
train_Gene = trainGenerator(6,'./build/train','images','labels',data_gen_args,save_to_dir = None)
val_Gene = trainGenerator(6,'./build/val','images','labels',data_gen_args,save_to_dir = None)
model = dense_seg(input_size = (256,256,3), pretrained_weights = None)
reduce_lr = LearningRateScheduler(scheduler2)
model_checkpoint = ModelCheckpoint(os.path.join('./logs/', 'build_rs2.h5'), monitor='acc',verbose=1, save_best_only=True)
tensorboard = TensorBoard(log_dir='./logs', histogram_freq=0,write_graph=True, write_images=False)
model.fit_generator(train_Gene,
validation_data=val_Gene,
validation_steps=4,
steps_per_epoch=822,
epochs=100,
shuffle=True,
callbacks=[reduce_lr, model_checkpoint, tensorboard])
# callbacks=[model_checkpoint, tensorboard])
# path = './build/test/images/'
# save_path = './re/'
# names = os.listdir(path)
# model = load_model('./logs/build_rs2.h5')
# testGene = testGenerator(path)
# results = model.predict_generator(testGene,360,verbose=1)
# saveResult(save_path,results,names)
acc: 0.9390493604871962
acc_cls: 0.8824207140325924
iou: [0.92846515 0.70824372]
miou: 0.8183544369524303
fwavacc: 0.8873248187124734
class_accuracy: 0.7283347863724868
class_recall: 0.6865863005739034
accuracy: 0.8562536445453013
f1_score: 0.7068446306556696
4.训练，测试代码DenseNet4.py
import numpy as np
import keras
from keras.engine import Layer
import keras.backend as K
from keras.models import Model, save_model, load_model
from keras.layers import Input, Dense, Dropout, BatchNormalization, LeakyReLU, concatenate
from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, GlobalAveragePooling2D
from keras.models import *
from keras.layers import *
from data import *
from keras.models import load_model
from keras.optimizers import *
from keras.callbacks import ModelCheckpoint, TensorBoard, LearningRateScheduler
import pickle
def DenseLayer(x, nb_filter, bn_size=4, alpha=0.0, drop_rate=0.2):
# Bottleneck layers
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(bn_size*nb_filter, (1, 1), strides=(1,1), padding='same')(x)
# Composite function
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (3, 3), strides=(1,1), padding='same')(x)
if drop_rate: x = Dropout(drop_rate)(x)
return x
def DenseBlock(x, nb_layers, growth_rate, drop_rate=0.2):
for ii in range(nb_layers):
conv = DenseLayer(x, nb_filter=growth_rate, drop_rate=drop_rate)
x = concatenate([x, conv], axis=3)
return x
def TransitionLayer(x, compression=0.5, alpha=0.0, is_max=1):
nb_filter = int(x.shape.as_list()[-1]*compression)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (1, 1), strides=(1,1), padding='same')(x)
if is_max != 0: x = MaxPooling2D(pool_size=(2, 2), strides=2)(x)
else: x = AveragePooling2D(pool_size=(2, 2), strides=2)(x)
return x
#=================================================== residual_block =================================================
def BatchActivate(x):
x = BatchNormalization()(x)
x = Activation('relu')(x)
return x
def convolution_block(x, filters, size, strides=(1,1), padding='same', activation=True):
x = Conv2D(filters, size, strides=strides, padding=padding)(x)
if activation == True:
x = BatchActivate(x)
return x
# residual_block
def residual_block(blockInput, num_filters=16, batch_activate = False):
x = BatchActivate(blockInput)
x = convolution_block(x, num_filters, (3,3) )
x = convolution_block(x, num_filters, (3,3), activation=False)
x = Add()([x, blockInput])
if batch_activate:
x = BatchActivate(x)
return x
#=================================================== residual_block =================================================
IMAGE_ORDERING = 'channels_last'
def dense_seg(n_classes=1, input_size = (256,256,1), pretrained_weights = None):
growth_rate = 12
drop_rate = 0.2
inpt = Input(input_size)
x = Conv2D(growth_rate*2, (3, 3), strides=1, padding='same')(inpt)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=0.1)(x)
x = DenseBlock(x, 12, growth_rate, drop_rate=0.2)
x = TransitionLayer(x)
x = residual_block(x, num_filters=84)
x = residual_block(x, num_filters=84, batch_activate = True)
x = DenseBlock(x, 12, growth_rate, drop_rate=0.2)
x = TransitionLayer(x)
x = residual_block(x, num_filters=114)
x = residual_block(x, num_filters=114, batch_activate = True)
x = DenseBlock(x, 12, growth_rate, drop_rate=0.2)
x = TransitionLayer(x)
x = residual_block(x, num_filters=129)
x = residual_block(x, num_filters=129, batch_activate = True)
x = Conv2DTranspose(256, (3, 3), strides=(2, 2), padding="same")(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2DTranspose(128, (3, 3), strides=(2, 2), padding="same")(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2DTranspose(64, (3, 3), strides=(2, 2), padding="same")(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2D(n_classes , (3, 3) , padding='same', data_format=IMAGE_ORDERING )(x)
x = Conv2D(1, 1, activation = 'sigmoid')(x)
model = Model(inpt, x)
model.summary()
model.compile(optimizer = Adam(lr = 1e-3), loss = 'binary_crossentropy', metrics = ['accuracy'])
if(pretrained_weights):
model.load_weights(pretrained_weights)
return model
def scheduler(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 1 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.95)
print("lr changed to {}".format(lr * 0.95))
return K.get_value(model.optimizer.lr)
def scheduler2(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 50 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.5)
print("lr changed to {}".format(lr * 0.5))
return K.get_value(model.optimizer.lr)
if __name__ == '__main__':
# batchsize = 3
# train_path = './build/train'
# val_path = './build/val'
# train_num = len(os.listdir(train_path+'/images/'))
# val_num = len(os.listdir(val_path+'/images/'))
# data_gen_args = dict(
# # rotation_range=0.2,
# # width_shift_range=0.05,
# # height_shift_range=0.05,
# # shear_range=0.05,
# # zoom_range=0.1,
# horizontal_flip=True,
# vertical_flip=True,
# fill_mode='nearest')
# data_gen_args = dict()
# train_Gene = trainGenerator(batchsize,train_path,'images','labels',data_gen_args,save_to_dir = None)
# val_Gene = trainGenerator(batchsize,val_path,'images','labels',data_gen_args,save_to_dir = None)
# model = dense_seg(input_size = (256,256,3), pretrained_weights = None)
# reduce_lr = LearningRateScheduler(scheduler)
# model_checkpoint = ModelCheckpoint(os.path.join('./logs/', 'build_rs4.h5'), monitor='accuracy',verbose=1, save_best_only=True)
# tensorboard = TensorBoard(log_dir='./logs', histogram_freq=0,write_graph=True, write_images=False)
# history = model.fit_generator(train_Gene,
# validation_data=val_Gene,
# validation_steps=int(val_num/batchsize),
# steps_per_epoch=int(train_num/batchsize),
# epochs=100,
# shuffle=True,
# callbacks=[reduce_lr, model_checkpoint, tensorboard])
# # callbacks=[model_checkpoint, tensorboard])
# with open('log.txt','wb') as file_txt:
# pickle.dump(history.history,file_txt)
path = './build/test/images/'
save_path = './re/'
names = os.listdir(path)
model = load_model('./logs/build_rs4.h5')
testGene = testGenerator(path)
results = model.predict_generator(testGene,360,verbose=1)
saveResult(save_path,results,names)
acc: 0.9403639899359809
acc_cls: 0.8869246829429505
iou: [0.9298605 0.71518819]
miou: 0.8225243449167414
fwavacc: 0.8897568190548629
class_accuracy: 0.7288344948843302
class_recall: 0.6927176304620091
accuracy: 0.8573885764435327
f1_score: 0.7103172585700902
5.训练，测试代码DenseNet5.py
import numpy as np
import keras
from keras.engine import Layer
import keras.backend as K
from keras.models import Model, save_model, load_model
from keras.layers import Input, Dense, Dropout, BatchNormalization, LeakyReLU, concatenate
from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, GlobalAveragePooling2D
from keras.models import *
from keras.layers import *
from data import *
from keras.models import load_model
from keras.optimizers import *
from keras.callbacks import ModelCheckpoint, TensorBoard, LearningRateScheduler
import pickle
def DenseLayer(x, nb_filter, bn_size=4, alpha=0.0, drop_rate=0.2):
# Bottleneck layers
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(bn_size*nb_filter, (1, 1), strides=(1,1), padding='same')(x)
# Composite function
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (3, 3), strides=(1,1), padding='same')(x)
if drop_rate: x = Dropout(drop_rate)(x)
return x
def DenseBlock(x, nb_layers, growth_rate, drop_rate=0.2):
for ii in range(nb_layers):
conv = DenseLayer(x, nb_filter=growth_rate, drop_rate=drop_rate)
x = concatenate([x, conv], axis=3)
return x
def TransitionLayer(x, compression=0.5, alpha=0.0, is_max=1):
nb_filter = int(x.shape.as_list()[-1]*compression)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (1, 1), strides=(1,1), padding='same')(x)
if is_max != 0: x = MaxPooling2D(pool_size=(2, 2), strides=2)(x)
else: x = AveragePooling2D(pool_size=(2, 2), strides=2)(x)
return x
#=================================================== residual_block =================================================
def BatchActivate(x):
x = BatchNormalization()(x)
x = Activation('relu')(x)
return x
def convolution_block(x, filters, size, strides=(1,1), padding='same', activation=True):
x = Conv2D(filters, size, strides=strides, padding=padding)(x)
if activation == True:
x = BatchActivate(x)
return x
# residual_block
def residual_block(blockInput, num_filters=16, batch_activate = False):
x = BatchActivate(blockInput)
x = convolution_block(x, num_filters, (3,3) )
x = convolution_block(x, num_filters, (3,3), activation=False)
x = Add()([x, blockInput])
if batch_activate:
x = BatchActivate(x)
return x
#=================================================== residual_block =================================================
IMAGE_ORDERING = 'channels_last'
def dense_seg(n_classes=1, input_size = (256,256,1), pretrained_weights = None):
growth_rate = 12
drop_rate = 0.2
inpt = Input(input_size)
x = Conv2D(growth_rate*2, (3, 3), strides=1, padding='same')(inpt)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=0.1)(x)
x1_1 = DenseBlock(x, 12, growth_rate, drop_rate=drop_rate)
x1_1 = TransitionLayer(x1_1)
x1_2 = residual_block(x, num_filters=24)
x1_2 = residual_block(x1_2, num_filters=24, batch_activate = True)
x1_2 = MaxPooling2D(pool_size=(2, 2), strides=2)(x1_2)
x1_2 = Conv2D(84, (1, 1), strides=(1,1), padding='same')(x1_2)
x1_3 = convolution_block(x, 84, (3,3))
x1_3 = (BatchNormalization())(x1_3)
x1_3 = MaxPooling2D(pool_size=(2, 2), strides=2)(x1_3)
x1 = concatenate([x1_1, x1_2, x1_3], axis=-1)
x2_1 = DenseBlock(x1, 12, growth_rate, drop_rate=drop_rate)
x2_1 = TransitionLayer(x2_1)
x2_2 = residual_block(x1, num_filters=252)
x2_2 = residual_block(x2_2, num_filters=252, batch_activate = True)
x2_2 = MaxPooling2D(pool_size=(2, 2), strides=2)(x2_2)
x2_2 = Conv2D(198, (1, 1), strides=(1,1), padding='same')(x2_2)
x2_3 = convolution_block(x1, 198, (3,3))
x2_3 = (BatchNormalization())(x2_3)
x2_3 = MaxPooling2D(pool_size=(2, 2), strides=2)(x2_3)
x2 = concatenate([x2_1, x2_2, x2_3], axis=-1)
x3_1 = DenseBlock(x2, 12, growth_rate, drop_rate=drop_rate)
x3_1 = TransitionLayer(x3_1)
x3_2 = residual_block(x2, num_filters=594)
x3_2 = residual_block(x3_2, num_filters=594, batch_activate = True)
x3_2 = MaxPooling2D(pool_size=(2, 2), strides=2)(x3_2)
x3_2 = Conv2D(369, (1, 1), strides=(1,1), padding='same')(x3_2)
x3_3 = convolution_block(x2, 369, (3,3))
x3_3 = (BatchNormalization())(x3_3)
x3_3 = MaxPooling2D(pool_size=(2, 2), strides=2)(x3_3)
x3 = concatenate([x3_1, x3_2, x3_3], axis=-1)
x4 = MaxPooling2D(pool_size=(2, 2), strides=2)(x3)
x4 = Conv2D(512, (1, 1), strides=(1,1), padding='same')(x4)
x4 = MaxPooling2D(pool_size=(2, 2), strides=2)(x4)
x4 = Conv2D(512, (1, 1), strides=(1,1), padding='same')(x4)
x = Conv2DTranspose(256, (3, 3), strides=(2, 2), padding="same")(x4)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2DTranspose(128, (3, 3), strides=(2, 2), padding="same")(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2DTranspose(64, (3, 3), strides=(2, 2), padding="same")(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2DTranspose(32, (3, 3), strides=(2, 2), padding="same")(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2DTranspose(16, (3, 3), strides=(2, 2), padding="same")(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2D(n_classes , (3, 3) , padding='same', data_format=IMAGE_ORDERING )(x)
x = Conv2D(1, 1, activation = 'sigmoid')(x)
model = Model(inpt, x)
model.summary()
model.compile(optimizer = Adam(lr = 1e-3), loss = 'binary_crossentropy', metrics = ['accuracy'])
if(pretrained_weights):
model.load_weights(pretrained_weights)
return model
def scheduler(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 1 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.95)
print("lr changed to {}".format(lr * 0.95))
return K.get_value(model.optimizer.lr)
def scheduler2(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 50 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.5)
print("lr changed to {}".format(lr * 0.5))
return K.get_value(model.optimizer.lr)
if __name__ == '__main__':
batchsize = 4
train_path = './build/train'
val_path = './build/val'
train_num = len(os.listdir(train_path+'/images/'))
val_num = len(os.listdir(val_path+'/images/'))
data_gen_args = dict(
# rotation_range=0.2,
# width_shift_range=0.05,
# height_shift_range=0.05,
# shear_range=0.05,
# zoom_range=0.1,
horizontal_flip=True,
vertical_flip=True,
fill_mode='nearest')
# data_gen_args = dict()
train_Gene = trainGenerator(batchsize,train_path,'images','labels',data_gen_args,save_to_dir = None)
val_Gene = trainGenerator(batchsize,val_path,'images','labels',data_gen_args,save_to_dir = None)
model = dense_seg(input_size = (256,256,3), pretrained_weights = None)
reduce_lr = LearningRateScheduler(scheduler)
model_checkpoint = ModelCheckpoint(os.path.join('./logs/', 'build_rs5.h5'), monitor='accuracy',verbose=1, save_best_only=True)
tensorboard = TensorBoard(log_dir='./logs', histogram_freq=0,write_graph=True, write_images=False)
history = model.fit_generator(train_Gene,
validation_data=val_Gene,
validation_steps=int(val_num/batchsize),
steps_per_epoch=int(train_num/batchsize),
epochs=100,
shuffle=True,
callbacks=[reduce_lr, model_checkpoint, tensorboard])
# callbacks=[model_checkpoint, tensorboard])
with open('log5.txt','wb') as file_txt:
pickle.dump(history.history,file_txt)
# path = './build/test/images/'
# save_path = './re/'
# names = os.listdir(path)
# model = load_model('./logs/build_rs5.h5')
# testGene = testGenerator(path)
# results = model.predict_generator(testGene,360,verbose=1)
# saveResult(save_path,results,names)
acc: 0.9294767167833117
acc_cls: 0.8555872543966359
iou: [0.91820562 0.66146861]
miou: 0.7898371140804237
fwavacc: 0.8702436829466755
class_accuracy: 0.6986921915315005
class_recall: 0.6386589756330122
accuracy: 0.8301194862083152
f1_score: 0.667328148779939
6.训练，测试代码DenseNet6.py
import numpy as np
import keras
from keras.engine import Layer
import keras.backend as K
from keras.models import Model, save_model, load_model
from keras.layers import Input, Dense, Dropout, BatchNormalization, LeakyReLU, concatenate
from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, GlobalAveragePooling2D
from keras.models import *
from keras.layers import *
from data import *
from keras.models import load_model
from keras.optimizers import *
from keras.callbacks import ModelCheckpoint, TensorBoard, LearningRateScheduler
import pickle
def DenseLayer(x, nb_filter, bn_size=4, alpha=0.0, drop_rate=0.2):
# Bottleneck layers
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(bn_size*nb_filter, (1, 1), strides=(1,1), padding='same')(x)
# Composite function
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (3, 3), strides=(1,1), padding='same')(x)
if drop_rate: x = Dropout(drop_rate)(x)
return x
def DenseBlock(x, nb_layers, growth_rate, drop_rate=0.2):
for ii in range(nb_layers):
conv = DenseLayer(x, nb_filter=growth_rate, drop_rate=drop_rate)
x = concatenate([x, conv], axis=3)
return x
def TransitionLayer(x, compression=0.5, alpha=0.0, is_max=1):
nb_filter = int(x.shape.as_list()[-1]*compression)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (1, 1), strides=(1,1), padding='same')(x)
if is_max != 0: x = MaxPooling2D(pool_size=(2, 2), strides=2)(x)
else: x = AveragePooling2D(pool_size=(2, 2), strides=2)(x)
return x
#=================================================== residual_block =================================================
def BatchActivate(x):
x = BatchNormalization()(x)
x = Activation('relu')(x)
return x
def convolution_block(x, filters, size, strides=(1,1), padding='same', activation=True):
x = Conv2D(filters, size, strides=strides, padding=padding)(x)
if activation == True:
x = BatchActivate(x)
return x
# residual_block
def residual_block(blockInput, num_filters=16, batch_activate = False):
x = BatchActivate(blockInput)
x = convolution_block(x, num_filters, (3,3) )
x = convolution_block(x, num_filters, (3,3), activation=False)
x = Add()([x, blockInput])
if batch_activate:
x = BatchActivate(x)
return x
#=================================================== residual_block =================================================
IMAGE_ORDERING = 'channels_last'
def dense_seg(n_classes=1, input_size = (256,256,1), pretrained_weights = None):
growth_rate = 12
drop_rate = 0.5
inpt = Input(input_size)
x = Conv2D(growth_rate*2, (3, 3), strides=1, padding='same')(inpt)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=0.1)(x)
x = Conv2D(256, (1, 1), strides=(1,1), padding='same')(x)
# print('x0: ',x.shape)
x1 = DenseBlock(x, 12, growth_rate, drop_rate=drop_rate)
x1 = TransitionLayer(x1)
x1 = Conv2D(128, (1, 1), strides=(1,1), padding='same')(x1)
# print('x1: ',x1.shape)
x2 = DenseBlock(x1, 12, growth_rate, drop_rate=drop_rate)
x2 = TransitionLayer(x2)
x2 = Conv2D(64, (1, 1), strides=(1,1), padding='same')(x2)
# print('x2: ',x2.shape)
x3 = DenseBlock(x2, 12, growth_rate, drop_rate=drop_rate)
x3 = TransitionLayer(x3)
x3 = Conv2D(32, (1, 1), strides=(1,1), padding='same')(x3)
# print('x3: ',x3.shape)
xu1 = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x3)
xu1 = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(xu1)
xu1 = (Conv2D( 256, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(xu1)
xu1 = (BatchNormalization())(xu1)
xu1 = concatenate([xu1,x2], axis=-1)
xu1 = Conv2D(256, (1, 1), strides=(1,1), padding='same')(xu1)
xu1 = Dropout(drop_rate)(xu1)
# print('xu1: ',xu1.shape)
xu2 = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(xu1)
xu2 = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(xu2)
xu2 = (Conv2D( 128, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(xu2)
xu2 = (BatchNormalization())(xu2)
xu2 = concatenate([xu2,x1], axis=-1)
xu2 = Conv2D(128, (1, 1), strides=(1,1), padding='same')(xu2)
xu2 = Dropout(drop_rate)(xu2)
# print('xu2: ',xu2.shape)
xu3 = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(xu2)
xu3 = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(xu3)
xu3 = (Conv2D( 64, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(xu3)
xu3 = (BatchNormalization())(xu3)
xu3 = concatenate([xu3,x], axis=-1)
xu3 = Conv2D(64, (1, 1), strides=(1,1), padding='same')(xu3)
xu3 = Dropout(drop_rate)(xu3)
# print('xu3: ',xu3.shape)
x = Conv2D(n_classes , (3, 3) , padding='same', data_format=IMAGE_ORDERING )(xu3)
x = Conv2D(1, 1, activation = 'sigmoid')(x)
model = Model(inpt, x)
model.compile(optimizer = Adam(lr = 1e-3), loss = 'binary_crossentropy', metrics = ['accuracy'])
# model.compile(optimizer = Adam(lr = 1e-3), loss = dice_coef_loss, metrics = ['accuracy'])
model.summary()
if(pretrained_weights):
model.load_weights(pretrained_weights)
return model
def scheduler(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 1 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.95)
print("lr changed to {}".format(lr * 0.95))
return K.get_value(model.optimizer.lr)
def scheduler2(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 50 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.5)
print("lr changed to {}".format(lr * 0.5))
return K.get_value(model.optimizer.lr)
if __name__ == '__main__':
batchsize = 1
train_path = './build/train'
val_path = './build/val'
train_num = len(os.listdir(train_path+'/images/'))
val_num = len(os.listdir(val_path+'/images/'))
data_gen_args = dict(
# rotation_range=0.2,
# width_shift_range=0.05,
# height_shift_range=0.05,
# shear_range=0.05,
# zoom_range=0.1,
horizontal_flip=True,
vertical_flip=True,
fill_mode='nearest')
# data_gen_args = dict()
train_Gene = trainGenerator(batchsize,train_path,'images','labels',data_gen_args,save_to_dir = None)
val_Gene = trainGenerator(batchsize,val_path,'images','labels',data_gen_args,save_to_dir = None)
model = dense_seg(input_size = (256,256,3), pretrained_weights = None)
reduce_lr = LearningRateScheduler(scheduler)
model_checkpoint = ModelCheckpoint(os.path.join('./logs/', 'build_rs6.h5'), monitor='accuracy',verbose=1, save_best_only=True)
tensorboard = TensorBoard(log_dir='./logs', histogram_freq=0,write_graph=True, write_images=False)
history = model.fit_generator(train_Gene,
validation_data=val_Gene,
validation_steps=int(val_num/batchsize),
steps_per_epoch=int(train_num/batchsize),
epochs=100,
shuffle=True,
callbacks=[reduce_lr, model_checkpoint, tensorboard])
# callbacks=[model_checkpoint, tensorboard])
with open('log6.txt','wb') as file_txt:
pickle.dump(history.history,file_txt)
# path = './build/test/images/'
# save_path = './re/'
# names = os.listdir(path)
# model = load_model('./logs/build_rs6.h5')
# testGene = testGenerator(path)
# results = model.predict_generator(testGene,360,verbose=1)
# saveResult(save_path,results,names)
recall 升高的了
acc: 0.9166478051079644
acc_cls: 0.8929823318931407
iou: [0.90079919 0.65714938]
miou: 0.7789742816432312
fwavacc: 0.8552821167439204
class_accuracy: 0.6636710526703985
class_recall: 0.7313568242734099
accuracy: 0.8405633087895342
f1_score: 0.6958719054511978
7.训练，测试代码DenseNet7.py
import tensorflow as tf
import numpy as np
import keras
from keras.engine import Layer
import keras.backend as K
from keras.models import Model, save_model, load_model
from keras.layers import Input, Dense, Dropout, BatchNormalization, LeakyReLU, concatenate
from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, GlobalAveragePooling2D
from keras.models import *
from keras.layers import *
from data import *
from keras.models import load_model
from keras.optimizers import *
from keras.callbacks import ModelCheckpoint, TensorBoard, LearningRateScheduler
def DenseLayer(x, nb_filter, bn_size=4, alpha=0.0, drop_rate=0.2):
# Bottleneck layers
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(bn_size*nb_filter, (1, 1), strides=(1,1), padding='same')(x)
# Composite function
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (3, 3), strides=(1,1), padding='same')(x)
if drop_rate: x = Dropout(drop_rate)(x)
return x
def DenseBlock(x, nb_layers, growth_rate, drop_rate=0.2):
for ii in range(nb_layers):
conv = DenseLayer(x, nb_filter=growth_rate, drop_rate=drop_rate)
x = concatenate([x, conv], axis=3)
return x
def TransitionLayer(x, compression=0.5, alpha=0.0, is_max=1):
nb_filter = int(x.shape.as_list()[-1]*compression)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (1, 1), strides=(1,1), padding='same')(x)
if is_max != 0: x = MaxPooling2D(pool_size=(2, 2), strides=2)(x)
else: x = AveragePooling2D(pool_size=(2, 2), strides=2)(x)
return x
IMAGE_ORDERING = 'channels_last'
def dense_seg(n_classes=1, input_size = (256,256,1), pretrained_weights = None):
growth_rate = 12
drop_rate = 0.3
inpt = Input(input_size)
x = Conv2D(growth_rate*2, (3, 3), strides=1, padding='same')(inpt)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=0.1)(x)
x = DenseBlock(x, 12, growth_rate, drop_rate=drop_rate)
x = TransitionLayer(x)
x = DenseBlock(x, 12, growth_rate, drop_rate=drop_rate)
x = TransitionLayer(x)
x = DenseBlock(x, 12, growth_rate, drop_rate=drop_rate)
x = TransitionLayer(x)
x1 = Conv2D(512, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(2,2))(x)
x2 = Conv2D(512, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(3,3))(x)
x3 = Conv2D(512, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(4,4))(x)
x = concatenate([x1,x2,x3], axis=-1)
x = Conv2D(512, (1, 1), strides=(1,1), padding='same')(x)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=0.1)(x)
x = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x)
x = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x)
x = (Conv2D( 256, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x)
x = (BatchNormalization())(x)
x = LeakyReLU(alpha=0.1)(x)
x = Dropout(drop_rate)(x)
x = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x)
x = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x)
x = (Conv2D( 128, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x)
x = (BatchNormalization())(x)
x = LeakyReLU(alpha=0.1)(x)
x = Dropout(drop_rate)(x)
x = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x)
x = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x)
x = (Conv2D( 64, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x)
x = (BatchNormalization())(x)
x = LeakyReLU(alpha=0.1)(x)
x = Dropout(drop_rate)(x)
x = Conv2D(n_classes , (3, 3) , padding='same', data_format=IMAGE_ORDERING )(x)
x = Conv2D(1, 1, activation = 'sigmoid')(x)
model = Model(inpt, x)
model.compile(optimizer = Adam(lr = 1e-3), loss = 'binary_crossentropy', metrics = ['accuracy'])
# model.compile(optimizer = Adam(lr = 1e-3), loss = dice_coef_loss, metrics = ['accuracy'])
model.summary()
if(pretrained_weights):
model.load_weights(pretrained_weights)
return model
def scheduler(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 1 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.95)
print("lr changed to {}".format(lr * 0.95))
return K.get_value(model.optimizer.lr)
def focal_loss(gamma=2., alpha=.25):
def focal_loss_fixed(y_true, y_pred):
pt_1 = tf.where(tf.equal(y_true, 1), y_pred, tf.ones_like(y_pred))
pt_0 = tf.where(tf.equal(y_true, 0), y_pred, tf.zeros_like(y_pred))
return -K.mean(alpha * K.pow(1. - pt_1, gamma) * K.log(pt_1)) - K.mean((1 - alpha) * K.pow(pt_0, gamma) * K.log(1. - pt_0))
return focal_loss_fixed
def dice_coef(y_true, y_pred, smooth=1):
intersection = K.sum(y_true * y_pred, axis=[1,2,3])
union = K.sum(y_true, axis=[1,2,3]) + K.sum(y_pred, axis=[1,2,3])
return K.mean( (2. * intersection + smooth) / (union + smooth), axis=0)
def dice_coef_loss(y_true, y_pred):
return 1 - dice_coef(y_true, y_pred, smooth=1)
if __name__ == '__main__':
data_gen_args = dict(
# rotation_range=0.2,
# width_shift_range=0.05,
# height_shift_range=0.05,
# shear_range=0.05,
# zoom_range=0.1,
horizontal_flip=True,
vertical_flip=True,
fill_mode='nearest')
# data_gen_args = dict()
train_Gene = trainGenerator(3,'./build/train','images','labels',data_gen_args,save_to_dir = None)
val_Gene = trainGenerator(3,'./build/val','images','labels',data_gen_args,save_to_dir = None)
model = dense_seg(input_size = (256,256,3), pretrained_weights = None)
reduce_lr = LearningRateScheduler(scheduler)
model_checkpoint = ModelCheckpoint(os.path.join('./logs/', 'build_rs7.h5'), monitor='accuracy',verbose=1, save_best_only=True)
tensorboard = TensorBoard(log_dir='./logs', histogram_freq=0,write_graph=True, write_images=False)
model.fit_generator(train_Gene,
validation_data=val_Gene,
validation_steps=48,
steps_per_epoch=300,
epochs=100,
shuffle=True, callbacks=[reduce_lr, model_checkpoint, tensorboard])
# callbacks=[model_checkpoint, tensorboard])
# path = './build/test/images/'
# save_path = './re/'
# names = os.listdir(path)
# # model = load_model('./logs/build_rs7.h5',custom_objects={'dice_coef_loss':dice_coef_loss})
# model = load_model('./logs/build_rs7.h5')
# testGene = testGenerator(path)
# results = model.predict_generator(testGene,360,verbose=1)
# saveResult(save_path,results,names)
acc: 0.9278492397732205
acc_cls: 0.8774149621308626
iou: [0.91522934 0.67355827]
miou: 0.7943938026578184
fwavacc: 0.8700819236810907
class_accuracy: 0.6912663769660737
class_recall: 0.6827610913136113
accuracy: 0.8393043175374926
f1_score: 0.6869874101085913
8.训练，测试代码DenseNet8.py
import numpy as np
import keras
from keras.engine import Layer
import keras.backend as K
from keras.models import Model, save_model, load_model
from keras.layers import Input, Dense, Dropout, BatchNormalization, LeakyReLU, concatenate
from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, GlobalAveragePooling2D
from keras.models import *
from keras.layers import *
from data import *
from keras.models import load_model
from keras.optimizers import *
from keras.callbacks import ModelCheckpoint, TensorBoard, LearningRateScheduler
import pickle
def DenseLayer(x, nb_filter, bn_size=4, alpha=0.0, drop_rate=0.2):
# Bottleneck layers
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(bn_size*nb_filter, (1, 1), strides=(1,1), padding='same')(x)
# Composite function
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (3, 3), strides=(1,1), padding='same')(x)
if drop_rate: x = Dropout(drop_rate)(x)
return x
def DenseBlock(x, nb_layers, growth_rate, drop_rate=0.2):
for ii in range(nb_layers):
conv = DenseLayer(x, nb_filter=growth_rate, drop_rate=drop_rate)
x = concatenate([x, conv], axis=3)
return x
def TransitionLayer(x, compression=0.5, alpha=0.0, is_max=1):
nb_filter = int(x.shape.as_list()[-1]*compression)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (1, 1), strides=(1,1), padding='same')(x)
if is_max != 0: x = MaxPooling2D(pool_size=(2, 2), strides=2)(x)
else: x = AveragePooling2D(pool_size=(2, 2), strides=2)(x)
return x
#=================================================== residual_block =================================================
def BatchActivate(x):
x = BatchNormalization()(x)
x = Activation('relu')(x)
return x
def convolution_block(x, filters, size, strides=(1,1), padding='same', activation=True):
x = Conv2D(filters, size, strides=strides, padding=padding)(x)
if activation == True:
x = BatchActivate(x)
return x
# residual_block
def residual_block(blockInput, num_filters=16, batch_activate = False):
x = BatchActivate(blockInput)
x = convolution_block(x, num_filters, (3,3) )
x = convolution_block(x, num_filters, (3,3), activation=False)
x = Add()([x, blockInput])
if batch_activate:
x = BatchActivate(x)
return x
#=================================================== residual_block =================================================
IMAGE_ORDERING = 'channels_last'
def dense_seg(n_classes=1, input_size = (256,256,1), pretrained_weights = None):
growth_rate = 12
drop_rate = 0.2
inpt = Input(input_size)
x = Conv2D(growth_rate*2, (3, 3), strides=1, padding='same')(inpt)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=0.1)(x)
x1_1 = DenseBlock(x, 12, growth_rate, drop_rate=drop_rate)
x1_1 = TransitionLayer(x1_1)
x1_2 = Conv2D(512, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(2,2))(x)
x1_2 = BatchNormalization(axis=3)(x1_2)
x1_2 = LeakyReLU(alpha=0.1)(x1_2)
x1_2 = MaxPooling2D(pool_size=(2, 2), strides=2)(x1_2)
x1_2 = Conv2D(84, (1, 1), strides=(1,1), padding='same')(x1_2)
x1_2 = BatchNormalization(axis=3)(x1_2)
x1_2 = LeakyReLU(alpha=0.1)(x1_2)
x2_1 = DenseBlock(x1_1, 12, growth_rate, drop_rate=drop_rate)
x2_1 = TransitionLayer(x2_1)
x2_2 = Conv2D(256, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(2,2))(x1_2)
x2_2 = BatchNormalization(axis=3)(x2_2)
x2_2 = LeakyReLU(alpha=0.1)(x2_2)
x2_2 = MaxPooling2D(pool_size=(2, 2), strides=2)(x2_2)
x2_2 = Conv2D(114, (1, 1), strides=(1,1), padding='same')(x2_2)
x2_2 = BatchNormalization(axis=3)(x2_2)
x2_2 = LeakyReLU(alpha=0.1)(x2_2)
x3_1 = DenseBlock(x2_1, 12, growth_rate, drop_rate=drop_rate)
x3_1 = TransitionLayer(x3_1)
x3_2 = Conv2D(128, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(2,2))(x2_2)
x3_2 = BatchNormalization(axis=3)(x3_2)
x3_2 = LeakyReLU(alpha=0.1)(x3_2)
x3_2 = MaxPooling2D(pool_size=(2, 2), strides=2)(x3_2)
x3_2 = Conv2D(129, (1, 1), strides=(1,1), padding='same')(x3_2)
x3_2 = BatchNormalization(axis=3)(x3_2)
x3_2 = LeakyReLU(alpha=0.1)(x3_2)
x3 = concatenate([x3_1, x3_2], axis=-1)
x = Conv2DTranspose(256, (3, 3), strides=(2, 2), padding="same")(x3)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2DTranspose(128, (3, 3), strides=(2, 2), padding="same")(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2DTranspose(64, (3, 3), strides=(2, 2), padding="same")(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2D(n_classes , (3, 3) , padding='same', data_format=IMAGE_ORDERING )(x)
x = Conv2D(1, 1, activation = 'sigmoid')(x)
model = Model(inpt, x)
model.summary()
model.compile(optimizer = Adam(lr = 1e-3), loss = 'binary_crossentropy', metrics = ['accuracy'])
if(pretrained_weights):
model.load_weights(pretrained_weights)
return model
def scheduler(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 1 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.95)
print("lr changed to {}".format(lr * 0.95))
return K.get_value(model.optimizer.lr)
def scheduler2(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 50 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.5)
print("lr changed to {}".format(lr * 0.5))
return K.get_value(model.optimizer.lr)
if __name__ == '__main__':
batchsize = 6
train_path = './build/train'
val_path = './build/val'
train_num = len(os.listdir(train_path+'/images/'))
val_num = len(os.listdir(val_path+'/images/'))
data_gen_args = dict(
# rotation_range=0.2,
# width_shift_range=0.05,
# height_shift_range=0.05,
# shear_range=0.05,
# zoom_range=0.1,
horizontal_flip=True,
vertical_flip=True,
fill_mode='nearest')
# data_gen_args = dict()
train_Gene = trainGenerator(batchsize,train_path,'images','labels',data_gen_args,save_to_dir = None)
val_Gene = trainGenerator(batchsize,val_path,'images','labels',data_gen_args,save_to_dir = None)
model = dense_seg(input_size = (256,256,3), pretrained_weights = None)
reduce_lr = LearningRateScheduler(scheduler)
model_checkpoint = ModelCheckpoint(os.path.join('./logs/', 'build_rs8.h5'), monitor='accuracy',verbose=1, save_best_only=True)
tensorboard = TensorBoard(log_dir='./logs', histogram_freq=0,write_graph=True, write_images=False)
history = model.fit_generator(train_Gene,
validation_data=val_Gene,
validation_steps=int(val_num/batchsize),
steps_per_epoch=int(train_num/batchsize),
epochs=100,
shuffle=True,
callbacks=[reduce_lr, model_checkpoint, tensorboard])
# callbacks=[model_checkpoint, tensorboard])
with open('log5.txt','wb') as file_txt:
pickle.dump(history.history,file_txt)
# path = './build/test/images/'
# save_path = './re/'
# names = os.listdir(path)
# model = load_model('./logs/build_rs8.h5')
# testGene = testGenerator(path)
# results = model.predict_generator(testGene,360,verbose=1)
# saveResult(save_path,results,names)
acc: 0.937930679321289
acc_cls: 0.9001486436661168
iou: [0.92638038 0.71652779]
miou: 0.8214540879946295
fwavacc: 0.887177090545547
class_accuracy: 0.71579127662083
class_recall: 0.7213452663372042
accuracy: 0.8590701559315557
f1_score: 0.7185575394431779
9.训练，测试代码DenseNet9.py
import numpy as np
import keras
from keras.engine import Layer
import keras.backend as K
from keras.models import Model, save_model, load_model
from keras.layers import Input, Dense, Dropout, BatchNormalization, LeakyReLU, concatenate
from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, GlobalAveragePooling2D
from keras.models import *
from keras.layers import *
from data import *
from keras.models import load_model
from keras.optimizers import *
from keras.callbacks import ModelCheckpoint, TensorBoard, LearningRateScheduler
import pickle
def DenseLayer(x, nb_filter, bn_size=4, alpha=0.0, drop_rate=0.2):
# Bottleneck layers
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(bn_size*nb_filter, (1, 1), strides=(1,1), padding='same')(x)
# Composite function
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (3, 3), strides=(1,1), padding='same')(x)
if drop_rate: x = Dropout(drop_rate)(x)
return x
def DenseBlock(x, nb_layers, growth_rate, drop_rate=0.2):
for ii in range(nb_layers):
conv = DenseLayer(x, nb_filter=growth_rate, drop_rate=drop_rate)
x = concatenate([x, conv], axis=3)
return x
def TransitionLayer(x, compression=0.5, alpha=0.0, is_max=1):
nb_filter = int(x.shape.as_list()[-1]*compression)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (1, 1), strides=(1,1), padding='same')(x)
if is_max != 0: x = MaxPooling2D(pool_size=(2, 2), strides=2)(x)
else: x = AveragePooling2D(pool_size=(2, 2), strides=2)(x)
return x
#=================================================== residual_block =================================================
def BatchActivate(x):
x = BatchNormalization()(x)
x = Activation('relu')(x)
return x
def convolution_block(x, filters, size, strides=(1,1), padding='same', activation=True):
x = Conv2D(filters, size, strides=strides, padding=padding)(x)
if activation == True:
x = BatchActivate(x)
return x
# residual_block
def residual_block(blockInput, num_filters=16, batch_activate = False):
x = BatchActivate(blockInput)
x = convolution_block(x, num_filters, (3,3) )
x = convolution_block(x, num_filters, (3,3), activation=False)
x = Add()([x, blockInput])
if batch_activate:
x = BatchActivate(x)
return x
#=================================================== residual_block =================================================
IMAGE_ORDERING = 'channels_last'
def dense_seg(n_classes=1, input_size = (256,256,1), pretrained_weights = None):
growth_rate = 12
drop_rate = 0.2
inpt = Input(input_size)
x = Conv2D(growth_rate*2, (3, 3), strides=1, padding='same')(inpt)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=0.1)(x)
x1_1 = DenseBlock(x, 12, growth_rate, drop_rate=drop_rate)
x1_1 = TransitionLayer(x1_1)
x1_2 = Conv2D(512, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(2,2))(x)
x1_2 = BatchNormalization(axis=3)(x1_2)
x1_2 = LeakyReLU(alpha=0.1)(x1_2)
x1_2 = MaxPooling2D(pool_size=(2, 2), strides=2)(x1_2)
x1_2 = Conv2D(84, (1, 1), strides=(1,1), padding='same')(x1_2)
x1_2 = BatchNormalization(axis=3)(x1_2)
x1_2 = LeakyReLU(alpha=0.1)(x1_2)
x2_1 = DenseBlock(x1_1, 12, growth_rate, drop_rate=drop_rate)
x2_1 = TransitionLayer(x2_1)
x2_2 = Conv2D(256, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(2,2))(x1_2)
x2_2 = BatchNormalization(axis=3)(x2_2)
x2_2 = LeakyReLU(alpha=0.1)(x2_2)
x2_2 = MaxPooling2D(pool_size=(2, 2), strides=2)(x2_2)
x2_2 = Conv2D(114, (1, 1), strides=(1,1), padding='same')(x2_2)
x2_2 = BatchNormalization(axis=3)(x2_2)
x2_2 = LeakyReLU(alpha=0.1)(x2_2)
x3_1 = DenseBlock(x2_1, 12, growth_rate, drop_rate=drop_rate)
x3_1 = TransitionLayer(x3_1)
x3_2 = Conv2D(128, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(2,2))(x2_2)
x3_2 = BatchNormalization(axis=3)(x3_2)
x3_2 = LeakyReLU(alpha=0.1)(x3_2)
x3_2 = MaxPooling2D(pool_size=(2, 2), strides=2)(x3_2)
x3_2 = Conv2D(129, (1, 1), strides=(1,1), padding='same')(x3_2)
x3_2 = BatchNormalization(axis=3)(x3_2)
x3_2 = LeakyReLU(alpha=0.1)(x3_2)
x3 = concatenate([x3_1, x3_2], axis=-1)
#======================================================================#
x_a = Conv2DTranspose(256, (3, 3), strides=(2, 2), padding="same")(x3)
x_a = (BatchNormalization())(x_a)
x_a = Dropout(drop_rate)(x_a)
x_a = Activation('relu')(x_a)
x_a = Conv2DTranspose(128, (3, 3), strides=(2, 2), padding="same")(x_a)
x_a = (BatchNormalization())(x_a)
x_a = Dropout(drop_rate)(x_a)
x_a = Activation('relu')(x_a)
x_a = Conv2DTranspose(64, (3, 3), strides=(2, 2), padding="same")(x_a)
x_a = (BatchNormalization())(x_a)
x_a = Dropout(drop_rate)(x_a)
x_a = Activation('relu')(x_a)
#=======================================================================#
x_b = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x3)
x_b = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x_b)
x_b = (Conv2D( 256, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x_b)
x_b = (BatchNormalization())(x_b)
x_b = Dropout(drop_rate)(x_b)
x_b = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x_b)
x_b = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x_b)
x_b = (Conv2D( 128, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x_b)
x_b = (BatchNormalization())(x_b)
x_b = Dropout(drop_rate)(x_b)
x_b = (UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x_b)
x_b = (ZeroPadding2D( (1,1), data_format=IMAGE_ORDERING))(x_b)
x_b = (Conv2D( 64, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(x_b)
x_b = (BatchNormalization())(x_b)
x_b = Dropout(drop_rate)(x_b)
x = concatenate([x_a, x_b], axis=-1)
x = Conv2D(n_classes , (3, 3) , padding='same', data_format=IMAGE_ORDERING )(x)
x = Conv2D(1, 1, activation = 'sigmoid')(x)
model = Model(inpt, x)
model.summary()
model.compile(optimizer = Adam(lr = 1e-3), loss = 'binary_crossentropy', metrics = ['accuracy'])
if(pretrained_weights):
model.load_weights(pretrained_weights)
return model
def scheduler(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 1 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.95)
print("lr changed to {}".format(lr * 0.95))
return K.get_value(model.optimizer.lr)
def scheduler2(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 50 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.5)
print("lr changed to {}".format(lr * 0.5))
return K.get_value(model.optimizer.lr)
if __name__ == '__main__':
batchsize = 2
train_path = './build/train'
val_path = './build/val'
train_num = len(os.listdir(train_path+'/images/'))
val_num = len(os.listdir(val_path+'/images/'))
data_gen_args = dict(
# rotation_range=0.2,
# width_shift_range=0.05,
# height_shift_range=0.05,
# shear_range=0.05,
# zoom_range=0.1,
horizontal_flip=True,
vertical_flip=True,
fill_mode='nearest')
# data_gen_args = dict()
train_Gene = trainGenerator(batchsize,train_path,'images','labels',data_gen_args,save_to_dir = None)
val_Gene = trainGenerator(batchsize,val_path,'images','labels',data_gen_args,save_to_dir = None)
model = dense_seg(input_size = (256,256,3), pretrained_weights = None)
reduce_lr = LearningRateScheduler(scheduler)
model_checkpoint = ModelCheckpoint(os.path.join('./logs/', 'build_rs9.h5'), monitor='accuracy',verbose=1, save_best_only=True)
tensorboard = TensorBoard(log_dir='./logs', histogram_freq=0,write_graph=True, write_images=False)
history = model.fit_generator(train_Gene,
validation_data=val_Gene,
validation_steps=int(val_num/batchsize),
steps_per_epoch=int(train_num/batchsize),
epochs=100,
shuffle=True,
callbacks=[reduce_lr, model_checkpoint, tensorboard])
# callbacks=[model_checkpoint, tensorboard])
with open('log9.txt','wb') as file_txt:
pickle.dump(history.history,file_txt)
# path = './build/test/images/'
# save_path = './re/'
# names = os.listdir(path)
# model = load_model('./logs/build_rs9.h5')
# testGene = testGenerator(path)
# results = model.predict_generator(testGene,360,verbose=1)
# saveResult(save_path,results,names)
acc: 0.9380671183268229
acc_cls: 0.879003939340906
iou: [0.92742855 0.70299867]
miou: 0.8152136113144722
fwavacc: 0.8855020229207873
class_accuracy: 0.7149182730751146
class_recall: 0.6721084856304297
accuracy: 0.8443759685390991
f1_score: 0.6928527295529191
10.训练，测试代码DenseNet10.py
import numpy as np
import keras
from keras.engine import Layer
import keras.backend as K
from keras.models import Model, save_model, load_model
from keras.layers import Input, Dense, Dropout, BatchNormalization, LeakyReLU, concatenate
from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, GlobalAveragePooling2D
from keras.models import *
from keras.layers import *
from data import *
from keras.models import load_model
from keras.optimizers import *
from keras.callbacks import ModelCheckpoint, TensorBoard, LearningRateScheduler
import pickle
def DenseLayer(x, nb_filter, bn_size=4, alpha=0.0, drop_rate=0.2):
# Bottleneck layers
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(bn_size*nb_filter, (1, 1), strides=(1,1), padding='same')(x)
# Composite function
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (3, 3), strides=(1,1), padding='same')(x)
if drop_rate: x = Dropout(drop_rate)(x)
return x
def DenseBlock(x, nb_layers, growth_rate, drop_rate=0.2):
for ii in range(nb_layers):
conv = DenseLayer(x, nb_filter=growth_rate, drop_rate=drop_rate)
x = concatenate([x, conv], axis=3)
return x
def TransitionLayer(x, compression=0.5, alpha=0.0, is_max=1):
nb_filter = int(x.shape.as_list()[-1]*compression)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=alpha)(x)
x = Conv2D(nb_filter, (1, 1), strides=(1,1), padding='same')(x)
if is_max != 0: x = MaxPooling2D(pool_size=(2, 2), strides=2)(x)
else: x = AveragePooling2D(pool_size=(2, 2), strides=2)(x)
return x
#=================================================== residual_block =================================================
def BatchActivate(x):
x = BatchNormalization()(x)
x = Activation('relu')(x)
return x
def convolution_block(x, filters, size, strides=(1,1), padding='same', activation=True):
x = Conv2D(filters, size, strides=strides, padding=padding)(x)
if activation == True:
x = BatchActivate(x)
return x
# residual_block
def residual_block(blockInput, num_filters=16, batch_activate = False):
x = BatchActivate(blockInput)
x = convolution_block(x, num_filters, (3,3) )
x = convolution_block(x, num_filters, (3,3), activation=False)
x = Add()([x, blockInput])
if batch_activate:
x = BatchActivate(x)
return x
#=================================================== residual_block =================================================
IMAGE_ORDERING = 'channels_last'
def dense_seg(n_classes=1, input_size = (256,256,1), pretrained_weights = None):
growth_rate = 12
drop_rate = 0.5
inpt = Input(input_size)
x = Conv2D(growth_rate*2, (3, 3), strides=1, padding='same')(inpt)
x = BatchNormalization(axis=3)(x)
x = LeakyReLU(alpha=0.1)(x)
x1_1 = DenseBlock(x, 12, growth_rate, drop_rate=drop_rate)
x1_1 = TransitionLayer(x1_1)
x1_2 = Conv2D(512, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(2,2))(x)
x1_2 = BatchNormalization(axis=3)(x1_2)
x1_2 = LeakyReLU(alpha=0.1)(x1_2)
x1_2 = MaxPooling2D(pool_size=(2, 2), strides=2)(x1_2)
x1_2 = Conv2D(84, (1, 1), strides=(1,1), padding='same')(x1_2)
x1_2 = BatchNormalization(axis=3)(x1_2)
x1_2 = LeakyReLU(alpha=0.1)(x1_2)
x1_3 = Conv2D(512, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(3,3))(x)
x1_3 = BatchNormalization(axis=3)(x1_3)
x1_3 = LeakyReLU(alpha=0.1)(x1_3)
x1_3 = MaxPooling2D(pool_size=(2, 2), strides=2)(x1_3)
x1_3 = Conv2D(84, (1, 1), strides=(1,1), padding='same')(x1_3)
x1_3 = BatchNormalization(axis=3)(x1_3)
x1_3 = LeakyReLU(alpha=0.1)(x1_3)
x2_1 = DenseBlock(x1_1, 12, growth_rate, drop_rate=drop_rate)
x2_1 = TransitionLayer(x2_1)
x2_2 = Conv2D(256, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(2,2))(x1_2)
x2_2 = BatchNormalization(axis=3)(x2_2)
x2_2 = LeakyReLU(alpha=0.1)(x2_2)
x2_2 = MaxPooling2D(pool_size=(2, 2), strides=2)(x2_2)
x2_2 = Conv2D(114, (1, 1), strides=(1,1), padding='same')(x2_2)
x2_2 = BatchNormalization(axis=3)(x2_2)
x2_2 = LeakyReLU(alpha=0.1)(x2_2)
x2_3 = Conv2D(256, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(3,3))(x1_3)
x2_3 = BatchNormalization(axis=3)(x2_3)
x2_3 = LeakyReLU(alpha=0.1)(x2_3)
x2_3 = MaxPooling2D(pool_size=(2, 2), strides=2)(x2_3)
x2_3 = Conv2D(114, (1, 1), strides=(1,1), padding='same')(x2_3)
x2_3 = BatchNormalization(axis=3)(x2_3)
x2_3 = LeakyReLU(alpha=0.1)(x2_3)
x3_1 = DenseBlock(x2_1, 12, growth_rate, drop_rate=drop_rate)
x3_1 = TransitionLayer(x3_1)
x3_2 = Conv2D(128, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(2,2))(x2_2)
x3_2 = BatchNormalization(axis=3)(x3_2)
x3_2 = LeakyReLU(alpha=0.1)(x3_2)
x3_2 = MaxPooling2D(pool_size=(2, 2), strides=2)(x3_2)
x3_2 = Conv2D(129, (1, 1), strides=(1,1), padding='same')(x3_2)
x3_2 = BatchNormalization(axis=3)(x3_2)
x3_2 = LeakyReLU(alpha=0.1)(x3_2)
x3_3 = Conv2D(128, (3,3), padding='same', data_format=IMAGE_ORDERING, dilation_rate=(3,3))(x2_3)
x3_3 = BatchNormalization(axis=3)(x3_3)
x3_3 = LeakyReLU(alpha=0.1)(x3_3)
x3_3 = MaxPooling2D(pool_size=(2, 2), strides=2)(x3_3)
x3_3 = Conv2D(129, (1, 1), strides=(1,1), padding='same')(x3_3)
x3_3 = BatchNormalization(axis=3)(x3_3)
x3_3 = LeakyReLU(alpha=0.1)(x3_3)
x3 = concatenate([x3_1, x3_2, x3_3], axis=-1)
x = Conv2DTranspose(256, (3, 3), strides=(2, 2), padding="same")(x3)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2DTranspose(128, (3, 3), strides=(2, 2), padding="same")(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2DTranspose(64, (3, 3), strides=(2, 2), padding="same")(x)
x = (BatchNormalization())(x)
x = Dropout(drop_rate)(x)
x = Activation('relu')(x)
x = Conv2D(n_classes , (3, 3) , padding='same', data_format=IMAGE_ORDERING )(x)
x = Conv2D(1, 1, activation = 'sigmoid')(x)
model = Model(inpt, x)
model.summary()
model.compile(optimizer = Adam(lr = 1e-3), loss = 'binary_crossentropy', metrics = ['accuracy'])
if(pretrained_weights):
model.load_weights(pretrained_weights)
return model
def scheduler(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 1 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.95)
print("lr changed to {}".format(lr * 0.95))
return K.get_value(model.optimizer.lr)
def scheduler2(epoch):
# 每隔100个epoch，学习率减小为原来的1/10
if epoch % 50 == 0 and epoch != 0:
lr = K.get_value(model.optimizer.lr)
K.set_value(model.optimizer.lr, lr * 0.5)
print("lr changed to {}".format(lr * 0.5))
return K.get_value(model.optimizer.lr)
if __name__ == '__main__':
batchsize = 4
train_path = './build/train'
val_path = './build/val'
train_num = len(os.listdir(train_path+'/images/'))
val_num = len(os.listdir(val_path+'/images/'))
data_gen_args = dict(
# rotation_range=0.2,
# width_shift_range=0.05,
# height_shift_range=0.05,
# shear_range=0.05,
# zoom_range=0.1,
horizontal_flip=True,
vertical_flip=True,
fill_mode='nearest')
# data_gen_args = dict()
train_Gene = trainGenerator(batchsize,train_path,'images','labels',data_gen_args,save_to_dir = None)
val_Gene = trainGenerator(batchsize,val_path,'images','labels',data_gen_args,save_to_dir = None)
model = dense_seg(input_size = (256,256,3), pretrained_weights = None)
reduce_lr = LearningRateScheduler(scheduler)
model_checkpoint = ModelCheckpoint(os.path.join('./logs/', 'build_rs10.h5'), monitor='accrucy',verbose=1, save_best_only=True)
tensorboard = TensorBoard(log_dir='./logs', histogram_freq=0,write_graph=True, write_images=False)
history = model.fit_generator(train_Gene,
validation_data=val_Gene,
validation_steps=int(val_num/batchsize),
steps_per_epoch=int(train_num/batchsize),
epochs=100,
shuffle=True,
callbacks=[reduce_lr, model_checkpoint, tensorboard])
# callbacks=[model_checkpoint, tensorboard])
with open('log10.txt','wb') as file_txt:
pickle.dump(history.history,file_txt)
# path = './build/test/images/'
# save_path = './re/'
# names = os.listdir(path)
# model = load_model('./logs/build_rs10_62.h5')
# testGene = testGenerator(path)
# results = model.predict_generator(testGene,360,verbose=1)
# saveResult(save_path,results,names)
acc: 0.9184202829996745
acc_cls: 0.8946685491779769
iou: [0.90287524 0.66238032]
miou: 0.7826277821720478
fwavacc: 0.8579475503821734
class_accuracy: 0.6671062660205629
class_recall: 0.7323654282192458
accuracy: 0.8421045939127604
f1_score: 0.6982142878527884
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
