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 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)
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 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 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 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)
img = resize(img, (IMG_HEIGHT, IMG_WIDTH), mode='constant', preserve_range=True)
X_test[n] = img
print('Done importing images')
#Define IoU metric
def mean_iou(y_true, y_pred):
prec = []
for t in np.arange(0.5, 1.0, 0.05):
y_pred_ = tf.to_int32(y_pred > t)
score, up_opt = tf.metrics.mean_iou(y_true, y_pred_, 2)
K.get_session().run(tf.local_variables_initializer())
with tf.control_dependencies([up_opt]):
score = tf.identity(score)
prec.append(score)
return K.mean(K.stack(prec), axis=0)
# Build U-Net model (transfer model version, must match model in transfer_test_loop.py)
logdir="logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard = TensorBoard(log_dir=logdir)
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=[mean_iou])
transfer_model.summary()
earlystopper = EarlyStopping(patience=patience, verbose=1)
checkpointer = ModelCheckpoint((WorkingDir + '/' + model_name), verbose=1, save_best_only=True)
results = transfer_model.fit(X_train, Y_train, validation_split=val_split, batch_size=batch, epochs=epochs, callbacks=[earlystopper, checkpointer, tensorboard])
# Evaluate how well training went in tensorboard
%load_ext tensorboard
%tensorboard --logdir logs --host=127.0.0.1
check_point = keras.callbacks.ModelCheckpoint(
os.path.join(model_path, config.exp_name + ".h5"),
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='min',
)
callbacks = [check_point, early_stopping, tbCallBack]
while config.batch_size > 1:
# To find a largest batch size that can be fit into GPU
try:
model.fit(x_train,
y_train,
batch_size=config.batch_size,
epochs=config.nb_epoch,
verbose=config.verbose,
shuffle=True,
validation_data=(x_valid, y_valid),
callbacks=callbacks)
break
except tf.errors.ResourceExhaustedError as e:
config.batch_size = int(config.batch_size / 2.0)
print("\n> Batch size = {}".format(config.batch_size))
if config.model == "Unet":
model = Unet(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 == "Nestnet":
# #model1.summary()
# In[20]:
#early_stopping = EarlyStopping(monitor='my_iou_metric', mode = 'max',patience=10, verbose=1)
model_checkpoint = ModelCheckpoint(save_model_name,monitor='my_iou_metric',
mode = 'max', save_best_only=True, verbose=1)
reduce_lr = ReduceLROnPlateau(monitor='my_iou_metric', mode = 'max',factor=0.5, patience=5, min_lr=0.0001, verbose=1)
epochs = 50
batch_size = 32
history = model1.fit(x_train, y_train,
validation_data=[x_valid, y_valid],
epochs=epochs,
batch_size=batch_size,
callbacks=[ model_checkpoint,reduce_lr],
verbose=2)
# In[21]:
model1 = load_model(save_model_name,custom_objects={'my_iou_metric': my_iou_metric})
# model1 = load_model(save_model_name,custom_objects={'my_iou_metric': my_iou_metric, 'lovasz_loss': lovasz_loss, 'my_iou_metric_2': my_iou_metric_2})
# remove layter activation layer and use losvasz loss
input_x = model1.layers[0].input
output_layer = model1.layers[-1].input
model = Model(input_x, output_layer)
c = optimizers.adam(0.0005)
def scheduler(epoch):
if epoch < 10:
return 0.001
else:
return 0.001 * tf.math.exp(0.1 * (10 - epoch))
lr_schedule = tf.keras.callbacks.LearningRateScheduler(scheduler)
start_time = time.time()
# train model
model.fit(
train_sequence_generator,
steps_per_epoch=100,
epochs=1000,
verbose=1,
callbacks=[earlystopper, tensorboard, lr_schedule],
validation_data=validation_sequence_generator,
validation_steps=5
)
end_time = time.time()
if not os.path.exists(f'../../reports/logs_and_plots/{test_name}/'):
os.makedirs(f'../../reports/logs_and_plots/{test_name}/')
with open(f'../../reports/logs_and_plots/{test_name}/{test_name}_log.txt', 'w+') as file:
file.write(f'Training completed in {end_time-start_time:0.1f} seconds.\n')
# save trained model
model.save(f'../../models/{test_name}.h5')
def main():
WEIGHTS_PATH = 'weights'
logger.info("Reading images")
for file in os.listdir(PATH_TO_IMAGES):
if file.endswith(".tiff"):
##### /read an image in the dataset #####
img_path = os.path.join(PATH_TO_IMAGES, file)
img = PIL.Image.open(img_path)
img = img.convert('RGB')
img = np.asarray(img) #[H, W, C]
img = utils.normalize(img)
##### /read an image in the dataset #####
##### read a label in the dataset #####
f_name, f_ext = os.path.splitext(file)
label_path = os.path.join(PATH_TO_LABELS, f_name + ".tif")
assert os.path.isfile(label_path)
label = PIL.Image.open(label_path)
#label = label.convert('RGB')
label = np.asarray(label) #[H, W, num_classes]
##### /read a label in the dataset #####
train_xsz = int(3/4 * img.shape[0]) # use 75% of image as train and 25% for validation
X_DICT_TRAIN[file] = img[:train_xsz, :, :]
#print (X_DICT_TRAIN[file].shape)
Y_DICT_TRAIN[file] = label[:train_xsz, :, :]
#print (Y_DICT_TRAIN[file].shape)
X_DICT_VALIDATION[file] = img[train_xsz:, :, :]
Y_DICT_VALIDATION[file] = label[train_xsz:, :, :]
logger.info("Training set: {} images".format(len(X_DICT_TRAIN)))
logger.info("Training set: {} labels".format(len(Y_DICT_TRAIN)))
logger.info("Validation set: {} images".format(len(X_DICT_VALIDATION)))
logger.info("Validation set: {} labels".format(len(Y_DICT_VALIDATION)))
x_train, y_train = utils.get_patches(X_DICT_TRAIN, Y_DICT_TRAIN, n_patches=TRAIN_SZ, sz=PATCH_SZ)
assert len(x_train) == len(y_train)
logger.info("Generated {} patches for training".format(len(x_train)))
x_val, y_val = utils.get_patches(X_DICT_VALIDATION, Y_DICT_VALIDATION, n_patches=VAL_SZ, sz=PATCH_SZ)
assert len(x_val) == len(y_val)
logger.info("Generated {} patches for validation".format(len(x_val)))
logger.info("########## Training ##########")
# define model
model = Unet()
model = Unet(backbone_name='resnet34', input_shape=(PATCH_SZ, PATCH_SZ, 3), classes=N_CLASSES, encoder_weights=None)
model.compile('Adam', loss=bce_jaccard_loss, metrics=[iou_score])
# load weights (if specified)
if not os.path.exists(WEIGHTS_PATH):
os.makedirs(WEIGHTS_PATH)
WEIGHTS_PATH += "/seg_weights.{epoch:02d}-{val_iou_score:.2f}.hdf5"
########## define callbacks ##########
model_checkpoint = keras.callbacks.ModelCheckpoint(
WEIGHTS_PATH,
monitor='val_loss',
verbose=1,
save_best_only=True,
period=5
)
csv_logger = keras.callbacks.CSVLogger(
'log_unet.csv',
append=True,
separator=';'
)
tensorboard = keras.callbacks.TensorBoard(
log_dir='./tensorboard_unet/',
write_graph=True,
write_images=True
)
########## /define callbacks ##########
# fit model
model.fit(
x=x_train,
y=y_train,
batch_size=BATCH_SIZE,
epochs=N_EPOCHS,
verbose=1, #show an animated progress bar
shuffle=True,
callbacks=[
model_checkpoint,
csv_logger,
tensorboard
],
validation_data=(x_val, y_val),
)
assert train_dataloader[0][0].shape == (BATCH_SIZE, 256, 256, 3)
assert train_dataloader[0][1].shape == (BATCH_SIZE, 256, 256, 21)
NAME = "Model_Unet"
# define callbacks for learning rate scheduling and best checkpoints saving
callbacks = [
keras.callbacks.TensorBoard(log_dir='logs\{}'.format(NAME), update_freq='epoch'),
keras.callbacks.ModelCheckpoint('./best_model_unet.h5', save_weights_only=False, save_best_only=True, \
mode='max', monitor='val_iou_score'),
keras.callbacks.ReduceLROnPlateau(monitor='val_loss', min_lr=0.00000001, patience=2),
metrics
]
!rm - rf / logs
history_unet = model.fit(train_dataloader, steps_per_epoch=len(train_dataloader),
epochs=100, validation_data=test_dataloader, callbacks=callbacks)
# Plot training & validation iou_score values
plt.figure(figsize=(30, 5))
plt.subplot(121)
plt.plot(history_unet.history['iou_score'])
plt.plot(history_unet.history['val_iou_score'])
plt.title('Model iou_score')
plt.ylabel('iou_score')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
# Plot training & validation loss values
plt.subplot(122)
plt.plot(history_unet.history['loss'])
plt.plot(history_unet.history['val_loss'])
focal_loss = sm.losses.CategoricalFocalLoss()
total_loss = dice_loss + (1 * focal_loss)
metrics = [
sm.metrics.IOUScore(threshold=0.5),
sm.metrics.FScore(threshold=0.5)
]
# compile keras model with defined optimozer, loss and metrics
model.compile(optim, total_loss, metrics)
if False:
print("training")
history = model.fit(
train_dataloader,
steps_per_epoch=len(train_dataloader),
epochs=EPOCHS,
callbacks=callbacks,
validation_data=validation_dataloader,
validation_steps=len(validation_dataloader),
)
# Plot training & validation iou_score values
plt.figure(figsize=(30, 5))
plt.subplot(121)
plt.plot(history.history['iou_score'])
plt.plot(history.history['val_iou_score'])
plt.title('Model iou_score')
plt.ylabel('iou_score')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
# Plot training & validation loss values
min_lr=0.00001,
verbose=1),
ModelCheckpoint(comb[combinations] + "_" + BACKBONE + "_" +
name_model + "_temporary_model_IoU" +
str(size) + ".h5",
verbose=1,
save_best_only=True,
save_weights_only=True), time_callback
]
## fit model
if name_model == "PSPNet":
model.fit(x=x_train2,
y=y_train2,
batch_size=n_batch,
epochs=n_epochs,
class_weight=class_weight,
validation_data=(x_val2, y_val2),
callbacks=callbacks)
else:
model.fit(x=x_train,
y=y_train,
batch_size=n_batch,
epochs=n_epochs,
class_weight=class_weight,
validation_data=(x_val, y_val),
callbacks=callbacks)
times = time_callback.times
dic_times = {}
dic_times['times'] = times
savemat(
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),
metrics = ['categorical_accuracy', IOUScore(per_image = False, threshold = 0.5)])
# fit_generator method for image augmentation
model.fit_generator(train_generator,
validation_data=test_generator,
steps_per_epoch=len(X_train) // batch_size,
validation_steps=len(X_test) // batch_size,
epochs=epoch_no,
callbacks=backroom.callbacks)
elapsed_time = time.time()-start_time # measuring modelling time
"_temporary_model_IoU" + str(size) + ".h5",
verbose=1,
save_best_only=True,
save_weights_only=True), time_callback, tensorboard
]
# dataAugmentaion = image.ImageDataGenerator(rotation_range = 30, zoom_range = 0.20,
# fill_mode = "nearest", shear_range = 0.20, horizontal_flip = True,
# width_shift_range = 0.1, height_shift_range = 0.1)
# model.fit_generator(dataAugmentaion.flow(x_train, y_train, batch_size = n_batch), validation_data = (x_val, y_val), steps_per_epoch = len(x_train) // n_batch, epochs = n_epochs)
model.fit(
# x=[np.reshape(x_train[:,:,:,:5],newshape=(y_train.shape[0],y_train.shape[1],y_train.shape[2],5)),np.reshape(x_train[:,:,:,5],newshape=(y_train.shape[0],y_train.shape[1],y_train.shape[2],1))], #reverse dimensions (in load_data_SR) and input from y_train
x=x_train,
y=y_train,
batch_size=n_batch,
epochs=n_epochs,
# class_weight = class_weight,
# validation_data=([np.reshape(x_val[:,:,:,:5],newshape=(x_val.shape[0],x_val.shape[1],x_val.shape[2],5)), np.reshape(x_val[:,:,:,5],newshape=(x_val.shape[0],x_val.shape[1],x_val.shape[2],1))], y_val),callbacks = callbacks
validation_data=(x_val, y_val),
callbacks=callbacks)
## fit model
# if name_model == "PSPNet":
# model.fit(
# x=x_train2,
# y=y_train2,
# batch_size=n_batch,
# epochs=n_epochs,
# class_weight = class_weight,
# validation_data=(x_val2, y_val2),callbacks = callbacks
# )
x_train = preprocess_input(x_train)
x_val = np.reshape(x_train[-2:, :, :, :], (2, 224, 224, 3))
y_val = np.reshape(y_train[-2:, :, :, :], (2, 224, 224, 4))
x_train = x_train[:-2, :, :, :]
y_train = y_train[:-2, :, :, :]
print(x_train.shape)
print(y_train.shape)
model = Unet(BACKBONE,
input_shape=(224, 224, 3),
classes=4,
encoder_weights='imagenet')
adam = optimizers.Adam(lr=0.0005,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=1e-6,
amsgrad=True)
model.compile('Adam', loss=bce_jaccard_loss, metrics=[iou_score])
model.fit(x=x_train,
y=y_train,
batch_size=8,
epochs=30,
validation_data=(x_val, y_val))
model.save('nail_unet.h5', include_optimizer=False)
def run(hyperparams):
print('Running model...')
#### Begin model input ##########################################################################################
def get_model(model_json_fname, modelwtsfname):
# This is only for prediction
if os.path.isfile(model_json_fname):
# Model reconstruction from JSON file
with open(model_json_fname, 'r') as f:
model = model_from_json(f.read())
else:
model = get_unet()
#model.summary()
# Load weights into the new model
model.load_weights(modelwtsfname)
return model
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.sum(
alpha * K.pow(1. - pt_1, gamma) * K.log(pt_1)) - K.sum(
(1 - alpha) * K.pow(pt_0, gamma) * K.log(1. - pt_0))
return focal_loss_fixed
def jaccard_coef(y_true, y_pred):
smooth = 1.0
intersection = K.sum(y_true * y_pred, axis=[-0, -1, 2])
sum_ = K.sum(y_true + y_pred, axis=[-0, -1, 2])
jac = (intersection + smooth) / (sum_ - intersection + smooth)
return K.mean(jac)
def jaccard_coef_int(y_true, y_pred):
smooth = 1.0
y_pred_pos = K.round(K.clip(y_pred, 0, 1))
intersection = K.sum(y_true * y_pred_pos, axis=[-0, -1, 2])
sum_ = K.sum(y_true + y_pred_pos, axis=[-0, -1, 2])
jac = (intersection + smooth) / (sum_ - intersection + smooth)
return K.mean(jac)
def jaccard_coef_loss(y_true, y_pred):
return -K.log(jaccard_coef(y_true, y_pred)) + binary_crossentropy(
y_pred, y_true)
def dice_coef_batch(y_true, y_pred):
smooth = 1.0
intersection = K.sum(y_true * y_pred, axis=[-0, -1, 2])
sum_ = K.sum(y_true + y_pred, axis=[-0, -1, 2])
dice = ((2.0 * intersection) + smooth) / (sum_ + intersection + smooth)
return K.mean(dice)
def dice_coef(y_true, y_pred):
smooth = 1.0
y_true_f = K.flatten(y_true)
y_pred_f = K.flatten(y_pred)
intersection = K.sum(y_true_f * y_pred_f)
dice_smooth = ((2. * intersection) +
smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth)
return (dice_smooth)
def dice_coef_loss(y_true, y_pred):
return -dice_coef(y_true, y_pred)
def dice_coef_batch_loss(y_true, y_pred):
return -dice_coef_batch(y_true, y_pred)
#Define the neural network
def get_unet():
droprate = 0.25
filt_size = 32
inputs = Input((None, None, 1))
conv1 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(inputs)
conv1 = Dropout(droprate)(conv1)
conv1 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
filt_size = filt_size * 2
conv2 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(pool1)
conv2 = Dropout(droprate)(conv2)
conv2 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
filt_size = filt_size * 2
conv3 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(pool2)
conv3 = Dropout(droprate)(conv3)
conv3 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
filt_size = filt_size * 2
conv4 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(pool3)
conv4 = Dropout(droprate)(conv4)
conv4 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
filt_size = filt_size * 2
conv5 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(pool4)
conv5 = Dropout(droprate)(conv5)
conv5 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(conv5)
filt_size = filt_size / 2
up6 = concatenate([
Conv2DTranspose(filt_size, (2, 2), strides=(2, 2),
padding='same')(conv5), conv4
],
axis=3)
conv6 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(up6)
conv6 = Dropout(droprate)(conv6)
conv6 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(conv6)
filt_size = filt_size / 2
up7 = concatenate([
Conv2DTranspose(filt_size, (2, 2), strides=(2, 2),
padding='same')(conv6), conv3
],
axis=3)
conv7 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(up7)
conv7 = Dropout(droprate)(conv7)
conv7 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(conv7)
filt_size = filt_size / 2
up8 = concatenate([
Conv2DTranspose(filt_size, (2, 2), strides=(2, 2),
padding='same')(conv7), conv2
],
axis=3)
conv8 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(up8)
conv8 = Dropout(droprate)(conv8)
conv8 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(conv8)
filt_size = filt_size / 2
up9 = concatenate([
Conv2DTranspose(filt_size, (2, 2), strides=(2, 2),
padding='same')(conv8), conv1
],
axis=3)
conv9 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(up9)
conv9 = Dropout(droprate)(conv9)
conv9 = Conv2D(filt_size, (3, 3), activation='relu',
padding='same')(conv9)
conv10 = Conv2D(1, (1, 1), activation='sigmoid')(conv9)
model = Model(inputs=[inputs], outputs=[conv10])
#model.compile(optimizer=Adam(lr=1e-5), loss=dice_coef_loss, metrics=[dice_coef])
#model.compile(optimizer=Nadam(lr=1e-3), loss=dice_coef_loss, metrics=[dice_coef])
#model.compile(optimizer=Adadelta(), loss=dice_coef_loss, metrics=[dice_coef])
return model
def save_model_to_json(model, model_json_fname):
#model = unet.UResNet152(input_shape=(None, None, 3), classes=1,encoder_weights="imagenet11k")
#model = get_unet()
#model.summary()
# serialize model to JSON
model_json = model.to_json()
with open(model_json_fname, "w") as json_file:
json_file.write(model_json)
def preprocess_data(do_prediction, inputnpyfname, targetnpyfname,
expandChannel, backbone):
# Preprocess the data (beyond what I already did before)
print('-' * 30)
print('Loading and preprocessing data...')
print('-' * 30)
# Load, normalize, and cast the data
imgs_input = (np.load(inputnpyfname).astype('float32') / (2**16 - 1) *
(2**8 - 1)).astype('uint8')
print('Input images information:')
print(imgs_input.shape)
print(imgs_input.dtype)
hist, bins = np.histogram(imgs_input)
print(hist)
print(bins)
if not do_prediction:
imgs_mask_train = np.load(targetnpyfname).astype('uint8')
print('Input masks information:')
print(imgs_mask_train.shape)
print(imgs_mask_train.dtype)
hist, bins = np.histogram(imgs_mask_train)
print(hist)
print(bins)
# Make the grayscale images RGB since that's what the model expects apparently
if expandChannel:
imgs_input = np.stack((imgs_input, ) * 3, -1)
else:
imgs_input = np.expand_dims(imgs_input, 3)
print('New shape of input images:')
print(imgs_input.shape)
if not do_prediction:
imgs_mask_train = np.expand_dims(imgs_mask_train, 3)
print('New shape of masks:')
print(imgs_mask_train.shape)
# Preprocess as per https://github.com/qubvel/segmentation_models
preprocessing_fn = get_preprocessing(backbone)
imgs_input = preprocessing_fn(imgs_input)
# Return appropriate variables
if not do_prediction:
return (imgs_input, imgs_mask_train)
else:
return (imgs_input)
# Import relevant modules and functions
import sys
sys.path.append(hyperparams['segmentation_models_repo'])
import numpy as np
from keras.models import Model
from keras.layers import Input, concatenate, Conv2D, MaxPooling2D, Conv2DTranspose, Dropout
from keras.optimizers import Adam
from keras.callbacks import ModelCheckpoint, ReduceLROnPlateau, EarlyStopping, CSVLogger
from keras.layers.normalization import BatchNormalization
from keras.backend import binary_crossentropy
import keras
import random
import tensorflow as tf
from keras.models import model_from_json
from segmentation_models import Unet
from segmentation_models.backbones import get_preprocessing
K.set_image_data_format(
'channels_last') # TF dimension ordering in this code
# Basically constants
expandChannel = True
modelwtsfname = 'model_weights.h5'
model_json_fname = 'model.json'
csvfname = 'model.csv'
do_prediction = hyperparams['predict']
if not do_prediction: # Train...
print('Training...')
# Parameters
inputnpyfname = hyperparams['images']
labels = hyperparams['labels']
initialize = hyperparams['initialize']
backbone = hyperparams['backbone']
encoder = hyperparams['encoder']
lr = float(hyperparams['lr'])
batch_size = hyperparams['batch_size']
obj_return = hyperparams['obj_return']
epochs = hyperparams['epochs']
# Preprocess the data
imgs_train, imgs_mask_train = preprocess_data(do_prediction,
inputnpyfname, labels,
expandChannel, backbone)
# Load, save, and compile the model
model = Unet(backbone_name=backbone, encoder_weights=encoder)
save_model_to_json(model, model_json_fname)
model.compile(optimizer=Adam(lr=lr),
loss='binary_crossentropy',
metrics=[
'binary_crossentropy', 'mean_squared_error',
dice_coef, dice_coef_batch,
focal_loss()
])
# Load previous weights for restarting, if desired and possible
if os.path.isfile(initialize):
print('-' * 30)
print('Loading previous weights ...')
model.load_weights(initialize)
# Set up the training callback functions
model_checkpoint = ModelCheckpoint(modelwtsfname,
monitor=obj_return,
save_best_only=True)
reduce_lr = ReduceLROnPlateau(monitor=obj_return,
factor=0.1,
patience=100,
min_lr=0.001,
verbose=1)
model_es = EarlyStopping(monitor=obj_return,
min_delta=0.00000001,
patience=100,
verbose=1,
mode='auto')
csv_logger = CSVLogger(csvfname, append=True)
# Train the model
history_callback = model.fit(
imgs_train,
imgs_mask_train,
batch_size=batch_size,
epochs=epochs,
verbose=2,
shuffle=True,
validation_split=0.10,
callbacks=[model_checkpoint, reduce_lr, model_es, csv_logger])
print("Minimum validation loss:")
print(min(history_callback.history[obj_return]))
else: # ...or predict
print('Inferring...')
# Parameters
inputnpyfname = hyperparams['images']
initialize = hyperparams['initialize']
backbone = hyperparams['backbone']
# lr = float(hyperparams['lr']) # this isn't needed but we're keeping it for the U-Net, where it is "needed"
# Preprocess the data
imgs_infer = preprocess_data(do_prediction, inputnpyfname, '',
expandChannel, backbone)
# Load the model
#model = get_model(model_json_fname,initialize)
model = get_model(
os.path.dirname(initialize) + '/' + model_json_fname, initialize)
# Run inference
imgs_test_predict = model.predict(imgs_infer, batch_size=1, verbose=1)
# Save the predicted masks
np.save('mask_predictions.npy',
np.squeeze(np.round(imgs_test_predict).astype('uint8')))
history_callback = None
#### End model input ############################################################################################
return (history_callback)
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),
)
loss='categorical_crossentropy',
metrics=['categorical_accuracy'])
####################################################
############# Training model #######################
####################################################
for i in range(n_save):
print('==============================')
print('in iteration: ', i + 1)
print('==============================')
model.fit(x,
y_train,
validation_data=(X_val, y_val),
callbacks=[TestCallback((X_val, y_val))],
batch_size=1,
epochs=epc_num,
verbose=True)
mname = 'PSPNet_relabeled_' + str(epc_num * (i + 1)) + '.h5'
print('==============================')
print('saving model after epoch ', (i + 1) * epc_num)
print('==============================')
# save_name = model_name+"_noaug_epoch_"+str(10*(i+1))+".h5"
model.save(mname)
# ## Result visualization
# In[5]:
