def train():
training_generator = get_training_generator()
for epoch_index in range(epochs):
# Why iterating over epochs instead of passing them correctly as a parameter of fit_generator?
# The problem is that I need to clean the graph regularly, or I will get a memory error
# And I did not find a way to clean the memory from used operations without resetting the whole graph
# But resetting the whole graph also requires to re-load the wholes weights
# This is obviously not an acceptable long-term solution. To see the issue on github:
# https://github.com/tensorflow/tensorflow/issues/31419
graph = tf.Graph()
K.clear_session()
gen = training_generator(graph,
starting_index=epoch_index * steps_per_epoch)
with graph.as_default():
if (epoch_index == 0):
unet = Unet(
"resnet34",
encoder_weights="imagenet",
classes=1,
activation="sigmoid",
input_shape=(tf_image_size, tf_image_size, 3),
)
unet.compile(optimizer=Adam(lr=learning_rate),
loss=calculate_loss)
else:
unet = load_model(
file_path,
custom_objects={"calculate_loss": calculate_loss})
unet.fit_generator(gen, steps_per_epoch=steps_per_epoch, epochs=1)
save_model(unet, file_path)
def train():
#load images
images = []
for image in os.listdir(im_path):
imi = cv.imread(os.path.join(im_path, image))
images.append(imi)
#load masks
masks = []
for mask in os.listdir(mask_path):
mask_in = cv.imread(os.path.join(mask_path, mask), 0)
ret_val, threshed_mask = cv.threshold(mask_in, 37, 1, cv.THRESH_BINARY)
masks.append(threshed_mask)
model = Unet('resnet34',
encoder_weights='imagenet',
input_shape=(128, 128, 3))
model.compile('Adam',
loss=bce_jaccard_loss,
metrics=[iou_score, 'accuracy'])
model.summary()
hist = model.fit(x=np.array(images).reshape(-1, 128, 128, 3),
y=np.array(masks).reshape(-1, 128, 128, 1),
batch_size=10,
epochs=15)
#save model
filename = 'trained_model.h5'
model.save(filename, include_optimizer=False)
class Dense_Unet():
def __init__(self, img_shape):
self.img_shape = img_shape
def compile_dense(self):
self.model = Unet(backbone_name='inceptionv3',
input_shape=self.img_shape,
input_tensor=None,
encoder_weights=None,
freeze_encoder=False,
skip_connections='default',
decoder_block_type='upsampling',
decoder_filters=(256, 128, 64, 32, 16),
decoder_use_batchnorm=True,
n_upsample_blocks=5,
upsample_rates=(2, 2, 2, 2, 2),
classes=4,
activation='softmax')
sgd = SGD(lr=0.1, momentum=0.9, decay=5e-6, nesterov=False)
adam = Adam(lr=0.01,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0,
amsgrad=False)
self.model.compile(
adam, gen_dice_loss,
[dice_whole_metric, dice_core_metric, dice_en_metric])
return (self.model)
def U_net(self):
# Build U-Net model
transfer_model = Unet(backbone_name=backbone, input_shape=(None, None, 3), classes=1,
activation='relu', encoder_weights='imagenet', encoder_freeze=True)
transfer_model.compile(optimizer='Adam', loss='binary_crossentropy', metrics=[self.mean_iou])
transfer_model.load_weights(self.modelPath)
transfer_model.summary()
return transfer_model
def train_stage_1(x_train, y_train, x_valid, y_valid):
opt = optimizers.adam(lr=0.001)
model = Unet(backbone_name=BACKBONE,
encoder_weights='imagenet',
freeze_encoder=True)
model.compile(loss=bce_dice_jaccard_loss,
optimizer=opt,
metrics=[my_iou_metric])
model_checkpoint = ModelCheckpoint(
OUTPUT_DIR + "/{}/models/{}_fold_{}_stage1.model".format(
BASE_NAME, BASE_NAME, CUR_FOLD_INDEX),
monitor='val_my_iou_metric',
mode='max',
save_best_only=True,
verbose=1)
reduce_lr = ReduceLROnPlateau(monitor='val_my_iou_metric',
mode='max',
factor=0.5,
patience=6,
min_lr=0.00001,
verbose=1)
early_stopping = EarlyStopping(monitor='val_my_iou_metric',
mode='max',
patience=20,
verbose=1)
logger = CSVLogger(OUTPUT_DIR + '/{}/logs/{}_fold_{}_stage1.log'.format(
BASE_NAME, BASE_NAME, CUR_FOLD_INDEX))
model.fit_generator(
TrainGenerator(x_train,
y_train,
batch_size=int(np.ceil(BATCH_SIZE / (len(AUGS) + 1))),
img_size_target=IMG_SIZE_TARGET),
steps_per_epoch=int(
np.ceil(len(x_train) / int(np.ceil(BATCH_SIZE /
(len(AUGS) + 1))))),
epochs=WARM_EPOCHS,
validation_data=ValidGenerator(x_valid,
y_valid,
batch_size=BATCH_SIZE,
img_size_target=IMG_SIZE_TARGET),
callbacks=[model_checkpoint],
shuffle=True)
segmentation_utils.set_trainable(model)
model.fit_generator(
TrainGenerator(x_train,
y_train,
batch_size=int(np.ceil(BATCH_SIZE / (len(AUGS) + 1))),
img_size_target=IMG_SIZE_TARGET),
steps_per_epoch=int(
np.ceil(len(x_train) / int(np.ceil(BATCH_SIZE /
(len(AUGS) + 1))))),
epochs=EPOCHS,
validation_data=ValidGenerator(x_valid,
y_valid,
batch_size=BATCH_SIZE,
img_size_target=IMG_SIZE_TARGET),
callbacks=[early_stopping, model_checkpoint, reduce_lr, logger],
shuffle=True)
def model_init(path_1, path_2):
model = Unet(BACKBONE_NAME, input_shape=(None, None, 1), classes=1, encoder_weights=None)
model.compile(optimizer=OPTIMIZER, loss=LOSS, metrics=[my_iou])
history = model.fit_generator(train_generator,
steps_per_epoch=TRAIN_STEPS_PER_EPOCH,
validation_data=valid_generator,
validation_steps=VALID_STEPS_PER_EPOCH,
callbacks=callbacks,
epochs=50)
def get_model(net_name,
num_class,
weight_path,
input_shape=[],
weighted_loss=False):
number_class = num_class
if net_name == 'psp':
model_name = 'pspnet101_cityscapes'
input_shape = (473, 473, 3)
model = pspnet.PSPNet101(nb_classes=num_class,
input_shape=input_shape,
weights=model_name)
model = model.model
elif net_name == 'psp_50':
input_shape = (473, 473, 3)
model_name = 'pspnet50_ade20k'
#output_mode='sigmoid'
model = pspnet.PSPNet50(nb_classes=num_class,
input_shape=input_shape,
weights=model_name)
model = model.model
elif net_name[-1:] == 'c':
if net_name == 'unet_rgbh_c' or net_name == 'unet_rgbc_c':
if len(input_shape) < 3:
input_shape = [512, 512, 4]
elif net_name == 'unet_rgb_c':
if len(input_shape) < 3:
input_shape = [512, 512, 3]
elif net_name == 'unet_msi_c':
if len(input_shape) < 3:
input_shape = [512, 512, 3]
elif net_name == 'unet_msih_c' or net_name == 'unet_msic_c':
if len(input_shape) < 3:
input_shape = [512, 512, 9]
from keras.layers import Input
input_tensor = Input(shape=(input_shape[0], input_shape[1],
input_shape[2]))
model = Unet(input_shape=input_shape,
input_tensor=input_tensor,
backbone_name=params.BACKBONE,
encoder_weights=None,
classes=num_class)
if weighted_loss:
loss = my_class_weighted_loss
else:
loss = params.SEMANTIC_LOSS
lr = params.LEARN_RATE
optimizer = Adam(lr=lr, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
if (len(weight_path) > 2):
model.load_weights(weight_path, True)
print('use pre-trained weights', weight_path)
model.compile(optimizer, loss=loss, metrics=[categorical_accuracy])
model.summary()
return model, input_shape
def train_unet_mobilenetv2(saveModelFn, tensorboardPath):
# train_imgDir = "/home/xiping/mydisk2/imglib/my_imglib/coco/train2014_person"
train_imgDir = "/coco/train2014_person"
(train_data, train_mask_data), (val_data,
val_mask_data) = get_data(train_imgDir,
maxNum=12000,
valMaxNum=1000)
# print(train_data.shape)
# print(mask_data.shape)
# print(mask_data[0])
# cv2.imwrite("xx.bmp", mask_data[1]*255)
# exit(0)
print("================================")
BACKBONE = 'mobilenetv2'
# define model
model = Unet(
BACKBONE,
classes=1,
input_shape=(224, 224,
3), # specific inputsize for callback save model
activation='sigmoid', #sigmoid,softmax
encoder_weights='imagenet')
# Show network structure.
# model.summary()
model.compile('Adam', loss='jaccard_loss', metrics=['iou_score'])
# model.compile('SGD', loss="bce_dice_loss", metrics=["dice_score"])
# model.compile('SGD', loss="bce_jaccard_loss", metrics=["iou_score"])
# model.compile('adam', loss="binary_crossentropy", metrics=["iou_score"])
checkpointer = ModelCheckpoint(
filepath=
"weights.epoch={epoch:02d}-val_loss={val_loss:.2f}-val_iou_score={val_iou_score:.2f}.hdf5",
verbose=1,
save_best_only=True)
print("================================")
print("Start train...")
# fit model
# if you use data generator use model.fit_generator(...) instead of model.fit(...)
# more about `fit_generator` here: https://keras.io/models/sequential/#fit_generator
model.fit(
x=train_data,
y=train_mask_data,
batch_size=32,
epochs=200,
validation_data=(
val_data,
val_mask_data), # callback save middle model need input val data
callbacks=[TensorBoard(log_dir=tensorboardPath), checkpointer])
model.save(saveModelFn)
def main():
with open('/home/rbuddhad/NIH-XRAY/test_sml.txt') as f1:
lines1 = f1.readlines()
test_datagen = ImageDataGenerator()
test_batches = test_datagen.flow_from_directory(TEST_DATASET_PATH,
target_size=(1024, 1024),
shuffle=True,
class_mode=None,
batch_size=BATCH_SIZE)
test_crops_orig = crop_generator(test_batches, CROP_LENGTH, lines1) # 224
model = Unet(backbone_name='resnet18', encoder_weights=None)
model.load_weights('best_model1.h5')
model.compile(optimizer='Adam',
loss='mean_squared_error',
metrics=['mae', 'mean_squared_error'])
model.summary()
# callbacks = [EarlyStopping(monitor='val_loss', patience=10),
# ModelCheckpoint(filepath='best_model1.h5', monitor='val_loss', save_best_only=True),
# TensorBoard(log_dir='./logs', histogram_freq=0, write_graph=True, write_images=True)]
# model.fit_generator(generator=test_crops_orig,
# steps_per_epoch=100,
# validation_data=valid_crops_orig,
# callbacks=callbacks,
# validation_steps=200,
# epochs=1000,
# shuffle=True)
# model.predict(generator=test_crops_orig,
# steps=2,
# verbose=1)
# model.save('unet2.h5')
predict = model.predict_generator(generator=test_crops_orig,
steps=1,
verbose=1)
# predict = model.predict()
print(predict.shape, 'predict_batch_size')
for i in range(50):
plt.imshow(predict[i, :, :, 0], cmap='gray', vmin=0, vmax=1)
plt.show()
def train(x_train: NpArray, x_valid: NpArray, y_train: NpArray, y_valid: NpArray,
fold: int = -1) -> None:
preprocessing_fn = get_preprocessing('resnet34')
x_train = preprocessing_fn(x_train)
x_valid = preprocessing_fn(x_valid)
model = Unet(backbone_name='resnet34', encoder_weights='imagenet')
model.compile('Adam', 'binary_crossentropy', metrics=[my_iou_metric])
model.summary()
model_name = make_output_path("models/fold%d.hdf5" % fold)
model_checkpoint = ModelCheckpoint(model_name, monitor='val_my_iou_metric',
mode='max', save_best_only=True, verbose=1)
reduce_lr = ReduceLROnPlateau(monitor='val_my_iou_metric', mode='max',
factor=0.5, patience=5, min_lr=3e-6, verbose=1)
model.fit(x_train, y_train, validation_data=[x_valid, y_valid], epochs=EPOCHS,
batch_size=BATCH_SIZE, callbacks=[model_checkpoint, reduce_lr],
verbose=VERBOSE)
def main():
train_datagen = ImageDataGenerator(rescale=1 / 255)
train_batches = train_datagen.flow_from_directory(DATASET_PATH,
target_size=(1024, 1024),
shuffle=True,
class_mode=None,
batch_size=BATCH_SIZE)
valid_datagen = ImageDataGenerator(rescale=1 / 255)
valid_batches = valid_datagen.flow_from_directory(DATASET_PATH,
target_size=(1024, 1024),
shuffle=False,
class_mode=None,
batch_size=BATCH_SIZE)
train_crops = crop_generator(train_batches, CROP_LENGTH) #224
valid_crops = crop_generator(valid_batches, CROP_LENGTH)
batch_x_random_crop, batch_y_targeted_crop = next(train_crops)
valid_x, valid_y = next(valid_crops)
in_painted_x = in_painting_mask(batch_x_random_crop, batch_y_targeted_crop)
valid_in_x = in_painting_mask(valid_x, valid_y)
batch_x_random_crop = rgb2gray(batch_x_random_crop)
batch_x_random_crop = np.reshape(
batch_x_random_crop, (batch_x_random_crop.shape[0], 224, 224, 1))
valid_x = rgb2gray(valid_x)
valid_x = np.reshape(valid_x, (valid_x.shape[0], 224, 224, 1))
model = Unet(backbone_name='resnet18',
encoder_weights='imagenet',
decoder_block_type='transpose') # build U-Net
model.compile(optimizer='Adam', loss='mean_squared_error')
model.summary()
model.fit(x=in_painted_x,
y=batch_x_random_crop,
validation_data=(valid_in_x, valid_x),
validation_steps=5,
steps_per_epoch=5,
epochs=1)
def seg_model(preprocess_type, input_size, pretrained_weights, activation,
loss):
classes = 4 if activation == 'sigmoid' else 5
model = Unet(preprocess_type,
encoder_weights='imagenet',
input_shape=input_size,
classes=classes,
activation=activation)
adam = keras.optimizers.Adam(lr=1e-4)
model.compile(optimizer=adam, loss=loss, metrics=[dice_coef])
model.summary()
if (pretrained_weights):
model.load_weights(pretrained_weights)
return model
def get_compiled_unet(config, label_encoder, loss='categorical_crossentropy', predict_logits=False, large=True):
'''
Input: config dict, label_encoder, loss (string or callable), predict_logits (boolean)
Output: compiled Unet model
'''
activation = 'linear' if predict_logits else 'softmax'
n_bands = len(config['s1_input_bands']) + len(config['s2_input_bands'])
decoder_filters = (256,128,64,32,16) if large else (64,32,32,32,32)
model = Unet(
backbone_name=config['unet_params']['backbone_name'],
encoder_weights=None,
activation=activation,
input_shape=(None, None, n_bands),
classes=len(label_encoder.classes_),
decoder_filters=decoder_filters
)
model.compile(loss=loss,
optimizer=Nadam(lr=config['unet_params']['learning_rate']),
metrics=['accuracy'])
return model
def build_model():
model = Unet(backbone_name='mobilenetv2',
input_shape=(224, 224, 3),
classes=1,
activation='sigmoid',
encoder_weights=weight_mobilenetv2_path,
encoder_freeze=True,
encoder_features='default',
decoder_block_type='upsampling',
decoder_filters=(256, 128, 64, 32, 16),
decoder_use_batchnorm=True)
#model.compile(loss='binary_crossentropy', optimizer=RMSprop(lr=0.0001), metrics=['acc'])
#model.compile(loss='binary_crossentropy', optimizer=SGD(lr=1e-4, momentum=0.9), metrics=['acc'])
model.compile(loss='binary_crossentropy',
optimizer=Adam(lr=0.0001),
metrics=['acc'])
model.summary()
return model
def unet_train():
callbacks = [
# EarlyStopping(patience=10, verbose=1),
# ReduceLROnPlateau(factor=0.1, patience=3, min_lr=0.00001, verbose=1),
ModelCheckpoint('unet_' + checkpoint,
verbose=1,
monitor='loss',
save_best_only=True,
save_weights_only=True)
]
model = Unet(backbone_name=backbone,
encoder_weights=None,
input_shape=input_shape)
model.compile('Adam', 'binary_crossentropy', ['binary_accuracy'])
results = model.fit(X_train,
y_train,
callbacks=callbacks,
epochs=100,
verbose=1,
validation_data=(X_valid, y_valid))
plotting(results)
def generate_compiled_segmentation_model(model_name, model_parameters, num_classes, loss, optimizer,
weights_to_load=None):
# These are the only model, loss, and optimizer currently supported
assert model_name == 'Unet'
assert loss == 'cross_entropy'
assert optimizer == 'adam'
model = Unet(input_shape=(None, None, 1), classes=num_classes, **model_parameters)
crossentropy = binary_crossentropy if num_classes == 1 else categorical_crossentropy
loss_fn = crossentropy
model.compile(optimizer=Adam(),
loss=loss_fn,
metrics=[accuracy, iou_score, jaccard_loss, dice_loss])
if weights_to_load:
model.load_weights(weights_to_load)
return model
def get_model(self, net_name, input_shape, number_class, class_weight,
weight_path):
from segmentation_models import pspnet #PSPNet
if net_name == 'psp':
model_name = 'pspnet101_cityscapes'
input_shape = (473, 473, 9)
model = pspnet.PSPNet101(nb_classes=number_class,
input_shape=input_shape,
weights=model_name)
model = model.model
if net_name == 'psp_50':
input_shape = (473, 473, 9)
model_name = 'pspnet50_ade20k'
#output_mode='sigmoid'
pspnet = pspnet.PSPNet101(nb_classes=number_class,
input_shape=input_shape,
weights=model_name)
model = model.model
elif net_name == 'unet':
input_shape = [256, 256, 9]
from keras.layers import Input
input_tensor = Input(shape=(input_shape[0], input_shape[1],
input_shape[2]))
model = Unet(input_shape=input_shape,
input_tensor=input_tensor,
backbone_name=params.BACKBONE,
encoder_weights=None,
classes=number_class)
##[1.0,10.0,10.0,20.,30.]
weights = np.array(class_weight)
# loss = weighted_categorical_crossentropy(weights)
loss = my_weighted_loss
# loss=params.SEMANTIC_LOSS
optimizer = Adam(lr=1E-3, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
if (len(weight_path) > 2):
model.load_weights(weight_path)
model.compile(optimizer, loss=loss)
model.summary()
return model
def resnet(self):
"""
Load model and weights
:return: neural network model
"""
#define model
# model = Unet(backbone_name='resnet34', input_shape=(None, None, 3), encoder_weights=None, classes=1, encoder_freeze=False)
# model.load_weights(self.data_path + '/weights/true_weights.hdf5')
# model.compile('Adam', 'dice_loss', metrics=['iou_score'])
model = Unet(
backbone_name='resnet18',
input_shape=(None, None, 3),
decoder_filters=(64, 32, 32, 16, 4),
encoder_weights='imagenet',
classes=1,
encoder_freeze=True,
)
model.load_weights(self.data_path + '/weights/new.hdf5')
model.compile('Adam', 'bce_jaccard_loss', metrics=['iou_score'])
return model
def train_net():
args = parser.parse_args()
final_path = args.model_final_path
checkpoint_path = args.model_checkpoint_path
dataset_path = args.dataset_path
with tf.device("/gpu:0"):
backbone = 'resnet50'
preprocess_input = get_preprocessing(backbone)
# load your data
x_train, y_train, x_val, y_val = from_directory_datagen(dataset_path)
# preprocess input
x_train = preprocess_input(x_train)
x_val = preprocess_input(x_val)
# define model
model = Unet(backbone, encoder_weights='imagenet', input_shape=(256, 256, 3))
model.compile(optimizer=tf.keras.optimizers.Adam(lr=1e-3), loss=dice_loss,
metrics=[f1_score, iou_score])
check_point = [ModelCheckpoint(checkpoint_path + 'model-{epoch:03d}-{val_f1-score:03f}.h5', verbose=1,
monitor='val_f1-score',
save_best_only=True, mode='max')]
# fit model
model.fit(
x=(pair for pair in zip(x_train, y_train)),
epochs=10,
steps_per_epoch=x_train.n // x_train.batch_size,
validation_data=(pair for pair in zip(x_val, y_val)),
validation_steps=x_val.n // x_val.batch_size,
verbose=1,
shuffle=True,
callbacks=check_point,
)
model.save(final_path + 'final_model.h5')
def main():
image_path = "image" #加载训练图片
im_start = 0 #确定编号
im_end = 29
im_array = load_png_files(image_path, im_start, im_end)
im_array = im_array[:, :, :, np.newaxis] # 需要加代表图片的通道数,这里是黑白图片所以是1,因此直接加一维
print("train_image shape : " + im_array.shape)
label_path = "label" #加载训练图片对应的标签图片
la_start = 0
la_end = 29
la_array = load_png_files(label_path, la_start, la_end)
la_array = la_array[:, :, :, np.newaxis]
print("train_label shape : " + la_array.shape)
test_path = "test" #加载测试集的图片
te_start = 0
te_end = 4
te_array = load_png_files(test_path, te_start, te_end)
te_array = te_array[:, :, :, np.newaxis]
print("test_image shape : " + te_array.shape)
model = Unet('resnet34', input_shape=(512, 512, 1),
encoder_weights=None) #1代表通道数
model.compile('Adam', loss='binary_crossentropy', metrics=['accuracy'])
model.fit(
x=im_array,
y=la_array,
batch_size=10,
epochs=8,
validation_split=0.2, #取训练集中的0.2作为验证集
shuffle=True)
model.save("model_v1.h5") #保存模型
print("Saved model to disk")
print("done!!!!!")
def network_setup():
global preprocess, model, idx, train_batches, valid_batches
# LOAD UNET WITH PRETRAINING FROM IMAGENET
preprocess = get_preprocessing(
'resnet34') # for resnet, img = (img-110.0)/1.0
model = Unet('resnet34',
input_shape=(img_resize_shape[0], img_resize_shape[1],
in_channels),
classes=out_channels,
activation='sigmoid')
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=[dice_coef])
# TRAIN AND VALIDATE MODEL
idx = int(0.8 * len(train2))
print()
train_batches = DataGenerator(train2.iloc[:idx],
shuffle=True,
preprocess=preprocess)
valid_batches = DataGenerator(train2.iloc[idx:], preprocess=preprocess)
history = model.fit_generator(train_batches,
validation_data=valid_batches,
epochs=epochs,
verbose=1)
intersection = K.sum(y_true_f * y_pred_f)
return (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) +
smooth)
from segmentation_models import Unet
from segmentation_models.backbones import get_preprocessing
# LOAD UNET WITH PRETRAINING FROM IMAGENET
preprocess = get_preprocessing('resnet34') # for resnet, img = (img-110.0)/1.0
model = Unet('resnet34',
input_shape=(128, 800, 3),
classes=4,
activation='sigmoid')
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=[dice_coef])
# TRAIN AND VALIDATE MODEL
idx = int(0.8 * len(train2))
print()
train_batches = DataGenerator(train2.iloc[:idx],
shuffle=True,
preprocess=preprocess)
valid_batches = DataGenerator(train2.iloc[idx:], preprocess=preprocess)
history = model.fit_generator(train_batches,
validation_data=valid_batches,
epochs=30,
verbose=2)
# PLOT TRAINING
plt.figure(figsize=(15, 5))
#Data augmentation
x_train = np.append(x_train, [np.fliplr(x) for x in x_train], axis=0)
y_train = np.append(y_train, [np.fliplr(x) for x in y_train], axis=0)
x_train = np.repeat(x_train, 3, axis=3)
x_valid = np.repeat(x_valid, 3, axis=3)
# In[14]:
from segmentation_models import Unet
model1 = Unet(backbone_name='resnet152', encoder_weights='imagenet')
c = optimizers.adam(lr=0.0001)
model1.compile(loss='binary_crossentropy',
optimizer=c,
metrics=[my_iou_metric])
# In[15]:
model_checkpoint = ModelCheckpoint(save_model_name,
monitor='val_my_iou_metric',
mode='max',
save_best_only=True,
verbose=1)
epochs = 60
BATCH_SIZE = 8
steps_per_epoch = x_train.shape[0] // BATCH_SIZE
schedule = SGDRScheduler(min_lr=1e-5,
def train(backbone,
load_pretrain,
data_path,
split_path,
save_path,
n_split=5,
seed=960630,
batch_size=4,
fold=0):
# split by all data
get_train_val_split(data_path=data_path + 'image_set/',
save_path=split_path,
n_splits=n_split,
seed=seed)
# split by folders
# get_train_val_split(data_path=data_path+'images/',
# save_path=split_path,
# n_splits=n_split,
# seed=seed)
if load_pretrain is not None:
model = load_model(load_pretrain, compile=False)
elif backbone is not None:
model = Unet(backbone, classes=1, encoder_weights='imagenet')
else:
model = Unet(classes=1, encoder_weights='imagenet')
model.compile('Adam', loss=bce_jaccard_loss, metrics=[iou_score])
model.summary()
# split by all images
train_data = Carotid_DataGenerator(
df_path=split_path +
'split/train_fold_{}_seed_{}.csv'.format(fold, seed),
image_path=data_path + 'image_set/',
mask_path=data_path + '/mask_set/',
batch_size=batch_size,
target_shape=(512, 512),
augmentation=True,
shuffle=False)
val_data = Carotid_DataGenerator(
df_path=split_path +
'split/val_fold_{}_seed_{}.csv'.format(fold, seed),
image_path=data_path + 'image_set/',
mask_path=data_path + '/mask_set/',
batch_size=batch_size,
target_shape=(512, 512),
augmentation=True,
shuffle=False)
# split by folder
# train_data = Carotid_DataGenerator(
# df_path=split_path+'split/train_fold_{}_seed_{}.csv'.format(fold, seed),
# image_path=data_path + 'images/',
# mask_path=data_path + '/masks/',
# batch_size=batch_size,
# target_shape=(512, 512),
# augmentation=True,
# shuffle=False)
# val_data = Carotid_DataGenerator(
# df_path=split_path + 'split/val_fold_{}_seed_{}.csv'.format(fold, seed),
# image_path=data_path + 'images/',
# mask_path=data_path + '/masks/',
# batch_size=batch_size,
# target_shape=(512, 512),
# augmentation=True,
# shuffle=False)
callbacks = [
EarlyStopping(monitor='val_loss',
patience=8,
verbose=1,
min_delta=1e-4),
ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
patience=4,
verbose=1,
epsilon=1e-4),
ModelCheckpoint(monitor='val_loss',
filepath=save_path,
verbose=True,
save_best_only=True)
]
model.fit_generator(train_data,
validation_data=val_data,
epochs=10,
callbacks=callbacks,
verbose=1)
iou = K.mean(iou * class_weights)
return iou
test_images = []
labels = []
for i in range(100):
test_images.append(np.random.rand(128, 128, 3))
rand = np.random.randint(10, size=(128, 128))
labels.append(rand)
test_images = np.array(test_images)
labels = np.array(labels)
x_train, x_val, y_train, y_val = train_test_split(test_images,
labels,
test_size=0.33,
random_state=42)
y_train = to_categorical(y_train)
y_val = to_categorical(y_val)
print(x_train.shape)
print(y_train.shape)
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=[iou_score])
model.fit(
x=x_train,
y=y_train,
batch_size=16,
epochs=100,
validation_data=(x_val, y_val),
)
elif config.model == "Nestnet":
model = Nestnet(backbone_name=config.backbone,
encoder_weights=config.weights,
decoder_block_type=config.decoder_block_type,
classes=config.nb_class,
activation=config.activation)
elif config.model == "Xnet":
model = Xnet(backbone_name=config.backbone,
encoder_weights=config.weights,
decoder_block_type=config.decoder_block_type,
classes=config.nb_class,
activation=config.activation)
else:
raise
model.compile(optimizer="Adam",
loss=bce_dice_loss,
metrics=["binary_crossentropy", mean_iou, dice_coef])
# plot_model(model, to_file=os.path.join(model_path, config.exp_name+".png"))
if os.path.exists(os.path.join(model_path, config.exp_name + ".txt")):
os.remove(os.path.join(model_path, config.exp_name + ".txt"))
with open(os.path.join(model_path, config.exp_name + ".txt"), 'w') as fh:
model.summary(positions=[.3, .55, .67, 1.],
print_fn=lambda x: fh.write(x + '\n'))
shutil.rmtree(os.path.join(logs_path, config.exp_name), ignore_errors=True)
if not os.path.exists(os.path.join(logs_path, config.exp_name)):
os.makedirs(os.path.join(logs_path, config.exp_name))
tbCallBack = TensorBoard(
log_dir=os.path.join(logs_path, config.exp_name),
histogram_freq=0,
####################################################### IMPORTANT SETTINGS!!!!!
learning_rate = 0.002
batch_size = 100
epoch_no = 10
####################################################### IMPORTANT SETTINGS!!!!!
optimizer = Adam(lr=learning_rate)
model = Unet(backbone_name='efficientnetb7',
classes = len(mask_label_dict.keys()),
activation = 'softmax',
encoder_weights = 'imagenet',
encoder_freeze = True) # freezing weights as pre-trained weights are used
model.compile(optimizer,
loss = JaccardLoss(per_image = False),
metrics = ['categorical_accuracy', IOUScore(per_image = False, threshold = 0.5)])
# creating generators for the image augmentation
train_generator = backroom.UnetSequence(X_train, y_train_multidim, batch_size, augmentations = backroom.train_augmentation)
test_generator = backroom.UnetSequence(X_test, y_test_multidim, batch_size, augmentations = None)
start_time = time.time() # measuring modelling time
# basic .fit method
model.fit(X_train, y_train_multidim, epochs = 2, batch_size = batch_size, validation_data = (X_test, y_test_multidim))
set_trainable(model, recompile = False) # Set all layers of model trainable, so that encode_freeze is lifted. Recompile = True does not work with Tensorflow 2.0
model.compile(optimizer,
loss = JaccardLoss(per_image = False),
num_val_samples = len(df_val)
train_batch_size = BATCH_SIZE
val_batch_size = BATCH_SIZE
# determine numtrain steps
train_steps = np.ceil(num_train_samples / train_batch_size)
# determine num val steps
val_steps = np.ceil(num_val_samples / val_batch_size)
# Initialize the generators
train_gen = train_generator(batch_size=BATCH_SIZE)
val_gen = val_generator(batch_size=BATCH_SIZE)
model.compile(
Adam(lr=0.0001),
loss=dice_loss,
metrics=[iou_score],
)
filepath = "model.h5"
earlystopper = EarlyStopping(patience=5, verbose=1)
checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1,
save_best_only=True, mode='min')
reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=2,
verbose=1, mode='min')
def build_model(BACKBONE, Config, encoder_weights=None, freeze_encoder=False, inference=False):
from segmentation_models import Unet
if Config.num_classes == 1:
activation = 'sigmoid'
else:
activation = 'softmax'
# define model
model = Unet(BACKBONE, input_shape=Config.input_shape, classes=Config.num_classes, activation=activation, encoder_weights=encoder_weights, encoder_freeze=freeze_encoder)
if Config.class_mode == 'liver_lesion_pyramid':
out3 = model.layers[-1].output
out2 = model.get_layer('decoder_stage3_relu2').output
out2 = Conv2D(Config.num_classes, (1, 1), activation='sigmoid', name='pred2')(out2)
out1 = model.get_layer('decoder_stage2_relu2').output
out1 = Conv2D(Config.num_classes, (1, 1), activation='sigmoid', name='pred1')(out1)
out0 = model.get_layer('decoder_stage1_relu2').output
out0 = Conv2D(Config.num_classes, (1, 1), activation='sigmoid', name='pred0')(out0)
model = Model(inputs=[model.input], outputs=[out0, out1, out2, out3])
# Compile (Training mode)
if inference:
return model
else:
if Config.class_mode == 'liver' or Config.class_mode == 'lesion':
loss = focal_tversky
# optimizer = 'Adam'
optimizer = SGD(lr=Config.init_lr, momentum=0.9, decay=1e-4, nesterov=False)
metrics = [dice_coef]
elif Config.class_mode == 'liver_lesion':
loss = weighted_categorical_crossentropy(Config.weights)
# loss = combined_dice_wp_crossentropy(Config.weights)
optimizer = 'Adam'
# optimizer = SGD(lr=Config.init_lr, momentum=0.9, decay=1e-4, nesterov=False)
metrics = ['accuracy', dice_coef_liver, dice_coef_lesion]
elif Config.class_mode == 'lesion_combined':
loss1 = weighted_categorical_crossentropy(Config.weights)
loss2 = dice_coef_loss
# loss2 = tversky_loss
loss ={'softmax_output': loss1, 'sigmoid_output': loss2}# loss_weights
optimizer = 'Adam'
metrics = {'softmax_output': [dice_coef_liver, dice_coef_lesion],
'sigmoid_output': [dice_coef, dice_coef_lesion]}
model.compile(optimizer=optimizer, loss=loss, metrics=metrics)
return model
elif Config.class_mode == 'liver_lesion_pyramid':
loss = {'pred0': weighted_categorical_crossentropy(Config.weights),
'pred1': weighted_categorical_crossentropy(Config.weights),
'pred2': weighted_categorical_crossentropy(Config.weights),
'softmax': weighted_categorical_crossentropy(Config.weights)}
optimizer = 'Adam'
metrics = [dice_coef_lesion]
else:
ValueError(' Please define a valid class_mode in config: liver / lesion / liver_lesion / lesion_pyramid / liver_lesion_pyramid / lesion_combined')
model.compile(optimizer=optimizer, loss=loss, metrics=metrics)
return model
def train_track3(self, net='unet', check_folder=params.CHECKPOINT_DIR):
os.environ["CUDA_VISIBLE_DEVICES"] = params.GPUS
if os.path.exists(check_folder) == 0:
os.mkdir(check_folder)
CHECKPOINT_DIR = check_folder
CHECKPOINT_PATH = os.path.join(check_folder,
'weights.{epoch:02d}.hdf5')
data_folder = 'C:/TrainData/Track3/Train/patch_473/'
img_train, dsm_train, lable_train, img_val, dsm_val, label_val = load_all_data_files(
data_folder)
num_training_sample = len(img_train)
batch_size = 1
n_batch_per_epoch = num_training_sample // batch_size
num_val_sample = len(img_val)
n_batch_per_epoch_val = num_val_sample // batch_size
nb_epoch = 200
NUM_CATEGORIES = 5
train_generator = input_generator_RGBH(img_train, dsm_train,
lable_train, batch_size)
val_generator = input_generator_RGBH(img_val, dsm_val, label_val,
batch_size)
if net == 'psp':
from segmentation_models import pspnet #PSPNet
model_name = 'pspnet101_cityscapes'
input_shape = (473, 473, 9)
model = pspnet.PSPNet101(nb_classes=NUM_CATEGORIES,
input_shape=input_shape,
weights=model_name)
model = model.model
elif net == 'unet':
input_shape = [256, 256, 9]
from keras.layers import Input
input_tensor = Input(shape=(input_shape[0], input_shape[1],
input_shape[2]))
model = Unet(input_shape=input_shape,
input_tensor=input_tensor,
backbone_name=params.BACKBONE,
encoder_weights=None,
classes=2)
model.load_weights(
os.path.join('./checkpoint_track3-1/', 'weights.80.hdf5'))
from keras.optimizers import Adam, SGD
from keras.callbacks import ModelCheckpoint, CSVLogger
#loss=params.SEMANTIC_LOSS
# loss=my_weighted_loss
weights = np.array([1.0, 10.0, 10.0, 20., 30.])
loss = weighted_categorical_crossentropy(weights)
optimizer = Adam(lr=1E-3, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
model.compile(optimizer, loss=loss)
model.summary()
csv_logger = CSVLogger(os.path.join(CHECKPOINT_DIR, 'train.csv'))
checkpoint = ModelCheckpoint(filepath=CHECKPOINT_PATH,
monitor='loss',
verbose=1,
save_best_only=False,
save_weights_only=True,
mode='auto',
period=params.MODEL_SAVE_PERIOD)
callbacks = [csv_logger, checkpoint]
model.fit_generator(train_generator,
steps_per_epoch=n_batch_per_epoch,
validation_data=val_generator,
validation_steps=n_batch_per_epoch_val,
epochs=nb_epoch,
callbacks=callbacks)
