def predict(batch_idx, test_imgs, shape, sub_df, backbone, TTA, model):
h, w = shape
test_generator = DataGenerator(batch_idx,
df=test_imgs,
shuffle=False,
mode='predict',
dim=(350, 525),
reshape=shape,
n_channels=3,
base_path='../../dados/test_images/',
target_df=sub_df,
batch_size=43,
n_classes=4,
backbone=backbone)
if TTA:
test_generator.batch_size = 1
tta_model = tta_segmentation(model,
h_flip=True,
v_flip=True,
input_shape=(h, w, 3),
merge='mean')
batch_pred_masks = tta_model.predict_generator(test_generator,
workers=40,
verbose=1)
else:
batch_pred_masks = model.predict_generator(test_generator,
workers=40,
verbose=1)
return batch_pred_masks
def train_neural_net(ids_cat, mapping, use_finger_feature=True):
ids = sorted(list(ids_cat.keys()))
training_gen = DataGenerator(list_ids=ids[:-500],
path='enhanced',
look_up=ids_cat,
mapping=mapping,
finger_feature=use_finger_feature,
binary_mode=True,
batch_size=16,
prop_image=0,
prop_array=.5)
valid_gen = DataGenerator(list_ids=ids[-500:],
path='enhanced',
look_up=ids_cat,
mapping=mapping,
finger_feature=use_finger_feature,
binary_mode=True,
batch_size=16,
prop_image=0,
prop_array=0)
model = Neural_Net(img_size=(512, 512),
num_classes=len(mapping),
finger_feature=use_finger_feature)
model.set_net(relative_size=.2)
model.compile(metrics=['acc'])
lower_lear = ReduceLROnPlateau(monitor='loss',
factor=.33,
patience=10,
verbose=0,
mode='auto',
cooldown=10)
callback_tb = keras.callbacks.TensorBoard()
model.fit(training_generator=training_gen,
validation_generator=valid_gen,
epochs=56,
callbacks=[callback_tb, lower_lear])
model.store_model('logs/model_{}.h5'.format(int(time.time())))
return model
def train(model, uuid, train_config, img_size, nslices, mode='generator'):
cp_name = os.path.join(uuid + "{epoch:02d}.h5")
csv_name = os.path.join(uuid + ".csv")
# set up the metrics list
csv_cb = CSVLogger(csv_name)
# set up the checkpoint
#ckpt_cb = ModelCheckpoint(cp_name, monitor='val_loss', save_best_only=False, save_weights_only=False, period = 1)
time_callback = TimeHistory()
callbacks = []
#callbacks.append(ckpt_cb)
callbacks.append(csv_cb)
callbacks.append(time_callback)
# running in the fit() mode
if mode == "fit":
tic = time.time()
train_in, train_out = load_files(train_config["train_path"],
train_config["ext"])
valid_in, valid_out = load_files(train_config["valid_path"],
train_config["ext"])
logging.info("Time of the loading : " + str(time.time() - tic))
logging.info("start to train")
tic = time.time()
model.fit(train_in,
train_out,
batch_size=train_config["batch_size"],
epochs=train_config["epochs"],
verbose=train_config["verbose"],
shuffle=train_config['shuffle'],
validation_data=(valid_in, valid_out),
callbacks=callbacks)
toc = time.time() - tic
logging.info("It takes " + str(toc) + " to train")
logging.info(time_callback.times)
elif mode == "generator":
# running in the fit_generator mode
logging.info("applying generator mode")
tic = time.time()
# generate a training generator
training_generator = DataGenerator(
dirpath=train_config["train_path"],
img_size=img_size,
batch_size=train_config['batch_size'],
nslice=train_config["nslice"],
ext=train_config["ext"])
# generate a validation generator
validation_generator = DataGenerator(
dirpath=train_config["valid_path"],
img_size=img_size,
batch_size=train_config['batch_size'],
nslice=train_config["nslice"],
ext=train_config["ext"])
logging.info("Time of the step to set up generator: " +
str(time.time() - tic))
# set up the fit generator
model.fit_generator(epochs=train_config["epochs"],
generator=training_generator,
validation_data=validation_generator,
callbacks=callbacks,
max_queue_size=train_config["queue_size"],
workers=train_config["workers"],
use_multiprocessing=train_config["multi_process"],
shuffle=train_config["shuffle"])
return model
def main():
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
K.tensorflow_backend.set_session(sess)
args = parser.parse_args()
MODEL = args.model
EPOCH = args.epoch
BATCH_SIZE = args.batch_size
NUM_WORKER = args.num_worker
db, paths, age_label, gender_label = load_data()
n_fold = 1
print('[K-FOLD] Started...')
kf = KFold(n_splits=10, shuffle=True, random_state=1)
kf_split = kf.split(age_label)
for train_idx, test_idx in kf_split:
model = None
if MODEL == 'ssrnet':
model = AgenderSSRNet(64, [3, 3, 3], 1.0, 1.0)
elif MODEL == 'inceptionv3':
model = AgenderNetInceptionV3()
elif MODEL == 'mobilenetv1':
model = AgenderNetMobileNetV1()
else:
model = AgenderNetMobileNetV2()
train_db = db[train_idx]
train_paths = paths[train_idx]
train_age = age_label[train_idx]
train_gender = gender_label[train_idx]
test_db = db[test_idx]
test_paths = paths[test_idx]
test_age = age_label[test_idx]
test_gender = gender_label[test_idx]
losses = {
"age_prediction": "categorical_crossentropy",
"gender_prediction": "categorical_crossentropy",
}
metrics = {
"age_prediction": mae,
"gender_prediction": "acc",
}
if MODEL == 'ssrnet':
losses = {
"age_prediction": "mae",
"gender_prediction": "mae",
}
metrics = {
"age_prediction": "mae",
"gender_prediction": "binary_accuracy",
}
callbacks = [
ModelCheckpoint(
"train_weight/{}-{epoch:02d}-{val_loss:.4f}-{val_gender_prediction_acc:.4f}-{val_age_prediction_mae:.4f}.h5"
.format(MODEL),
verbose=1,
save_best_only=True,
save_weights_only=True),
CSVLogger('train_log/{}-{}.log'.format(MODEL, n_fold))
]
if MODEL == 'ssrnet':
callbacks = [
ModelCheckpoint(
"train_weight/{}-{epoch:02d}-{val_loss:.4f}-{val_gender_prediction_binary_accuracy:.4f}-{val_age_prediction_mean_absolute_error:.4f}.h5"
.format(MODEL),
verbose=1,
save_best_only=True,
save_weights_only=True),
CSVLogger('train_log/{}-{}.log'.format(MODEL, n_fold)),
DecayLearningRate([30, 60])
]
model.compile(optimizer='adam', loss=losses, metrics=metrics)
model.fit_generator(DataGenerator(model, train_db, train_paths,
train_age, train_gender, BATCH_SIZE),
validation_data=DataGenerator(
model, test_db, test_paths, test_age,
test_gender, BATCH_SIZE),
epochs=EPOCH,
verbose=2,
workers=NUM_WORKER,
use_multiprocessing=True,
max_queue_size=int(BATCH_SIZE * 2),
callbacks=callbacks)
n_fold += 1
del train_db, train_paths, train_age, train_gender
del test_db, test_paths, test_age, test_gender
def train(smmodel,
backbone,
batch_size,
shape=(320, 480),
nfold=0,
pseudo_label=None):
# if shape is None:
# shape = (1400,2100)
train_df, mask_count_df = get_data_preprocessed(pseudo_label)
ros = RandomOverSampler(random_state=random_seed)
skf = StratifiedKFold(n_splits=n_fold_splits,
random_state=random_seed,
shuffle=True)
for n_fold, (train_indices, val_indices) in enumerate(
skf.split(mask_count_df.index, mask_count_df.hasMask)):
# train_indices, _ = ros.fit_resample(train_indices.reshape(-1, 1),
# mask_count_df[mask_count_df.index.isin(train_indices)]['hasMask'])
#
# train_indices = list(itertools.chain.from_iterable(train_indices))
# val_images = mask_count_df[mask_count_df.index.isin(val_indices)]['ImageId'].tolist()
# train_images = mask_count_df[mask_count_df.index.isin(train_indices)]['ImageId'].tolist()
# #
# for classe in ['Fish','Flower','Gravel','Sugar']:
# train_df, mask_count_df = get_data_preprocessed(pseudo_label, classe=classe)
# val_indices = mask_count_df[mask_count_df['ImageId'].isin(val_images)].index
# train_indices = mask_count_df[mask_count_df['ImageId'].isin(train_images)].index
# print('Training class ', classe)
if n_fold >= nfold:
print('Training fold number ', str(n_fold))
train_generator = DataGenerator(
train_indices,
df=mask_count_df,
target_df=train_df,
batch_size=batch_size,
reshape=shape,
augment=True,
n_channels=3,
n_classes=n_classes,
backbone=backbone,
randomcrop=False,
)
val_generator = DataGenerator(
val_indices,
df=mask_count_df,
target_df=train_df,
batch_size=batch_size,
reshape=shape,
augment=False,
n_channels=3,
n_classes=n_classes,
backbone=backbone,
randomcrop=False,
)
# opt = RAdam(lr=0.0003)
opt = Nadam(lr=0.0003)
# opt = RMSprop(lr=0.0003)
# accum_iters = 64 // batch_size
# opt = AdamAccumulate(lr=0.0003, accum_iters=accum_iters)
# optimizer = GradientAccumulation(opt, accumulation_steps=4)
dice_focal_loss = sm_loss()
dice_metric = jaccard()
metrics = [
dice_coef, dice_coef_fish, dice_coef_flower, dice_coef_gravel,
dice_coef_sugar
]
model = get_model(smmodel, backbone, opt, dice_coef_loss_bce,
[dice_coef, dice_metric])
filepath = '../models/best_' + str(smmodel) + '_' + str(
backbone) + '_' + str(n_fold)
# filepath = '../models/best_' + str(smmodel) + '_' + str(backbone) + '_' + str(n_fold) + '_' + classe
ckp = ModelCheckpoint(filepath + '.h5',
monitor='val_f1-score',
verbose=1,
save_best_only=True,
mode='max',
save_weights_only=True)
es = EarlyStopping(monitor='val_f1-score',
min_delta=0.00001,
patience=5,
verbose=1,
mode='max')
rlr = ReduceLROnPlateau(monitor='val_f1-score',
factor=0.2,
patience=3,
verbose=1,
mode='max',
min_delta=0.0001)
swa = SWA(
'../models/best_' + str(smmodel) + '_' + str(backbone) + '_' +
str(n_fold) + '_swa.h5', 10)
history = model.fit_generator(train_generator,
validation_data=val_generator,
callbacks=[ckp, rlr, es, swa],
epochs=epochs,
use_multiprocessing=True,
workers=42)
def multimodel_eval(smmodel,
backbone,
nfold,
maxfold,
shape=(320, 480),
swa=False,
tta=False,
fixshape=True):
h, w = shape
train_df, mask_count_df = get_data_preprocessed()
opt = Nadam(lr=0.0002)
skf = StratifiedKFold(n_splits=n_fold_splits,
random_state=random_seed,
shuffle=True)
oof_data = np.zeros((len(mask_count_df.index), 350, 525, 4),
dtype=np.float16)
oof_predicted_data = np.zeros((len(mask_count_df.index), 350, 525, 4),
dtype=np.float16)
oof_imgname = []
oof_dice = []
classes = ['Fish', 'Flower', 'Gravel', 'Sugar']
cnt_position = 0
for n_fold, (train_indices, val_indices) in enumerate(
skf.split(mask_count_df.index, mask_count_df.hasMask)):
final_pred = np.zeros((len(val_indices), h, w, 4), dtype=np.float32)
y_true = []
if n_fold >= nfold and n_fold <= maxfold:
if n_fold >= 2:
nclass = 4
print(nclass)
else:
nclass = n_classes
print('Evaluating fold number ', str(n_fold))
val_generator = DataGenerator(val_indices,
df=mask_count_df,
shuffle=False,
target_df=train_df,
batch_size=len(val_indices),
reshape=shape,
augment=False,
n_channels=3,
n_classes=4,
backbone=backbone)
_, y_true = val_generator.__getitem__(0)
img_true = val_generator.image_name
oof_imgname.extend(img_true)
val_generator.batch_size = 1
for i, cls in enumerate(classes):
model = get_model(smmodel,
backbone,
opt,
dice_coef_loss_bce, [dice_coef],
nclass=nclass)
filepath = '../models/best_' + str(smmodel) + '_' + str(
backbone) + '_' + str(n_fold) + '_' + cls
if swa:
filepath += '_swa.h5'
else:
filepath += '.h5'
model.load_weights(filepath)
# results = model.evaluate_generator(
# val_generator,
# workers=40,
# verbose=1
# )
# print(results)
if tta:
model = tta_segmentation(model,
h_flip=True,
v_flip=True,
input_shape=(h, w, 3),
merge='mean')
y_pred = model.predict_generator(val_generator,
workers=40,
verbose=1)
final_pred[:, :, :, i] = y_pred[:, :, :, 0]
del y_pred
gc.collect()
print(y_true.shape)
print(final_pred.shape)
print(len(oof_imgname))
d = np_dice_coef(y_true, final_pred)
oof_dice.append(d)
print("Dice: ", d)
for i in range(y_true.shape[0]):
oof_data[cnt_position, :, :, :] = np_resize(
y_true[i, :, :, :].astype(np.float32),
(350, 525)).astype(np.float16)
oof_predicted_data[cnt_position, :, :, :] = np_resize(
final_pred[i, :, :, :].astype(np.float32),
(350, 525)).astype(np.float16)
cnt_position += 1
del y_true, final_pred
gc.collect()
del val_generator, model
gc.collect()
oof_imgname = np.asarray(oof_imgname)
print(oof_data.shape)
print(oof_predicted_data.shape)
print(oof_imgname.shape)
print("CV Final Dice: ", np.mean(oof_dice))
np.save(
'../validations/img_name_' + str(smmodel) + '_' + str(backbone) + '_' +
str(n_fold_splits) + '.npy', oof_imgname)
np.save('../validations/y_true_' + str(n_fold_splits) + '.npy', oof_data)
np.save(
'../validations/' + str(smmodel) + '_' + str(backbone) + '_' +
str(n_fold_splits) + '.npy', oof_predicted_data)
def evaluate(smmodel,
backbone,
nfold,
maxfold,
shape=(320, 480),
swa=False,
tta=False,
fixshape=True):
h, w = shape
train_df, mask_count_df = get_data_preprocessed()
opt = Nadam(lr=0.0002)
skf = StratifiedKFold(n_splits=n_fold_splits,
random_state=random_seed,
shuffle=True)
oof_data = np.zeros((len(mask_count_df.index), 350, 525, 4),
dtype=np.float16)
oof_predicted_data = np.zeros((len(mask_count_df.index), 350, 525, 4),
dtype=np.float16)
oof_imgname = []
# num_cpus = psutil.cpu_count(logical=False)
# ray.init(num_cpus=4)
oof_dice = []
cnt_position = 0
for n_fold, (train_indices, val_indices) in enumerate(
skf.split(mask_count_df.index, mask_count_df.hasMask)):
for i in range(0, len(val_indices), 480):
batch_idx = list(range(i, min(len(val_indices), i + 480)))
model = get_model(smmodel, backbone, opt, dice_coef_loss_bce,
[dice_coef])
if n_fold >= nfold and n_fold <= maxfold:
print('Evaluating fold number ', str(n_fold))
val_generator = DataGenerator(val_indices[batch_idx],
df=mask_count_df,
shuffle=False,
target_df=train_df,
batch_size=len(
val_indices[batch_idx]),
reshape=shape,
augment=False,
n_channels=3,
n_classes=4,
backbone=backbone)
_, y_true = val_generator.__getitem__(0)
img_true = val_generator.image_name
oof_imgname.extend(img_true)
val_generator.batch_size = 1
filepath = '../models/best_' + str(smmodel) + '_' + str(
backbone) + '_' + str(n_fold)
if swa:
filepath += '_swa.h5'
else:
filepath += '.h5'
model.load_weights(filepath)
# results = model.evaluate_generator(
# val_generator,
# workers=40,
# verbose=1
# )
# print(results)
if tta:
model = tta_segmentation(model,
h_flip=True,
v_flip=True,
input_shape=(h, w, 3),
merge='mean')
y_pred = model.predict_generator(val_generator,
workers=40,
verbose=1)
print(y_true.shape)
print(y_pred.shape)
print(len(oof_imgname))
f = []
for i in range(y_true.shape[0]):
for j in range(4):
d1 = np_dice_coef(y_true[i, :, :, j], y_pred[i, :, :,
j])
f.append(d1)
oof_data[cnt_position, :, :, :] = np_resize(
y_true[i, :, :, :].astype(np.float32),
(350, 525)).astype(np.float16)
oof_predicted_data[cnt_position, :, :, :] = np_resize(
y_pred[i, :, :, :].astype(np.float32),
(350, 525)).astype(np.float16)
cnt_position += 1
print("Dice: ", np.mean(f))
oof_dice.append(np.mean(f))
del y_true, y_pred, val_generator, model
gc.collect()
# oof_data = np.asarray(oof_data)
# oof_predicted_data = np.asarray(oof_predicted_data)
oof_imgname = np.asarray(oof_imgname)
print(oof_data.shape)
print(oof_predicted_data.shape)
print(oof_imgname.shape)
print("CV Final Dice: ", np.mean(oof_dice))
np.save('../validations/img_name_' + str(n_fold_splits) + '.npy',
oof_imgname)
np.save('../validations/y_true_' + str(n_fold_splits) + '.npy', oof_data)
np.save(
'../validations/' + str(smmodel) + '_' + str(backbone) + '_' +
str(n_fold_splits) + '.npy', oof_predicted_data)
def main(self):
if self.model_type == 'age_gender':
model = MTLAgeGender().model()
loss = {
'gender': 'binary_crossentropy',
'age': 'categorical_crossentropy'
}
metrics = ['acc']
opt = Adam(lr=self.learning_rate)
age_drawer = DrawGraph(self.model_type, 'age')
gender_drawer = DrawGraph(self.model_type, 'gender')
early_stop_check = MultiOutputEarlyStoppingAndCheckpoint(
['val_gender_acc', 'val_age_acc'], self.model_type, 3)
callbacks = [age_drawer, gender_drawer, early_stop_check]
elif self.model_type == 'age_gender_emotion':
model = MTLAgeGenderEmotion().model()
loss = {
'gender': 'binary_crossentropy',
'age': 'categorical_crossentropy',
'emotion': 'categorical_crossentropy'
}
metrics = ['acc']
opt = Adam(lr=self.learning_rate)
age_drawer = DrawGraph(self.model_type, 'age')
gender_drawer = DrawGraph(self.model_type, 'gender')
emotion_drawer = DrawGraph(self.model_type, 'emotion')
early_stop_check = MultiOutputEarlyStoppingAndCheckpoint(
['val_gender_acc', 'val_age_acc', 'val_emotion_acc'],
self.model_type, 5)
callbacks = [
age_drawer, gender_drawer, emotion_drawer, early_stop_check
]
else:
return None
x_train, y_train = self.load_data()
x_train, x_test, y_train, y_test = train_test_split(
x_train, y_train, test_size=self.split_ratio)
train_data = DataGenerator(x_train,
y_train,
self.model_type,
self.batch_size,
shuffle=True,
augment=True)
val_data = DataGenerator(x_test, y_test, self.model_type,
self.batch_size)
model.compile(optimizer=opt, loss=loss, metrics=metrics)
_ = model.fit_generator(generator=train_data,
validation_data=val_data,
epochs=200,
steps_per_epoch=len(train_data),
validation_steps=len(val_data),
callbacks=callbacks,
verbose=1)
def evaluate(smmodel, backbone, nfold, shape=(320, 480)):
n_splits = 6
# if shape is None:
# shape = (1400,2100)
train_df, mask_count_df = get_data_preprocessed()
skf = StratifiedKFold(n_splits=n_splits, random_state=133)
oof_data = []
oof_predicted_data = []
# num_cpus = psutil.cpu_count(logical=False)
# ray.init(num_cpus=4)
oof_dice = []
for n_fold, (train_indices, val_indices) in enumerate(skf.split(mask_count_df.index, mask_count_df.hasMask)):
if n_fold >= nfold:
print('Evaluating fold number ', str(n_fold))
val_generator = DataGenerator(
val_indices,
df=mask_count_df,
shuffle=False,
target_df=train_df,
batch_size=len(val_indices),
reshape=shape,
augment=False,
n_channels=3,
n_classes=4,
backbone=backbone
)
_, y_true = val_generator.__getitem__(0)
oof_data.extend(y_true.astype(np.float16))
del y_true
gc.collect()
del val_generator
gc.collect()
oof_data = np.asarray(oof_data)
oof_predicted_data = np.load('../predictions/' + str(smmodel) + '_' + str(backbone) + '_' + str(n_splits) + '_oof_tta.npy')
print(oof_data.shape)
print(oof_predicted_data.shape)
print("CV Final Dice: ", np.mean(oof_dice))
now = time.time()
class_params = {}
for class_id in range(4):
print(class_id)
attempts = []
for t in tqdm(range(55, 80, 5)):
t /= 100
for ms in range(10000, 31000, 5000):
d = parallel_post_process(oof_data, oof_predicted_data, class_id, t, ms, shape)
# print(t, ms, np.mean(d))
attempts.append((t, ms, np.mean(d)))
attempts_df = pd.DataFrame(attempts, columns=['threshold', 'size', 'dice'])
attempts_df = attempts_df.sort_values('dice', ascending=False)
print(attempts_df.head())
print('Time: ', time.time() - now)
best_threshold = attempts_df['threshold'].values[0]
best_size = attempts_df['size'].values[0]
class_params[class_id] = (best_threshold, best_size)