def ensemble(validation_base_path, validation_folder,
validation_predicted_folder):
pkl_files = []
with open('./scores_task1.csv', 'rb') as f:
rows = csv.reader(f, delimiter='\t')
for row in rows:
if '128' in row[0]:
pkl_files.append(validation_base_path + row[0] + '.pkl')
pkl_files_1 = pkl_files[:50]
print len(pkl_files_1)
pkl_scores = []
with open('./results/my_val_scores.csv', 'rb') as f:
rows = csv.reader(f)
for row in rows:
if '128' in row[0]:
pkl_scores.append(
[validation_base_path + row[0] + '.pkl',
float(row[3])])
pkl_scores = sorted(pkl_scores, key=lambda x: x[1], reverse=True)
pkl_files_2 = [x[0] for x in pkl_scores[:50]]
pkl_files = [x for x in pkl_files_1 if x in pkl_files_2]
print len(pkl_files)
mask_pred_challenge_list = []
for pkl_file in tqdm(pkl_files):
try:
mask_pred_challenge = pkl.load(open(pkl_file, 'rb'))
if mask_pred_challenge.max() < 0.5:
print 'garbage model'
continue
mask_pred_challenge_list.append(mask_pred_challenge)
except:
print(pkl_file, 'Not found')
print 'Finally use {} models'.format(len(mask_pred_challenge_list))
mask_pred_challenge_list = np.array(mask_pred_challenge_list)
mask_pred_challenge = np.mean(mask_pred_challenge_list, axis=0)
print mask_pred_challenge.shape
if not os.path.exists(validation_predicted_folder):
os.makedirs(validation_predicted_folder)
cutoff = 0.5
mask_pred_challenge_b = (np.where(mask_pred_challenge >= cutoff, 1, 0) *
255).astype(np.uint8)
challenge_list = ISIC.list_from_folder(validation_folder)
for i in trange(len(challenge_list)):
_, _ = ISIC.show_images_full_sized(
challenge_list,
img_mask_pred_array=mask_pred_challenge_b,
image_folder=validation_folder,
mask_folder=None,
index=i,
output_folder=validation_predicted_folder,
plot=False)
def ensemble(validation_base_path, validation_folder, validation_predicted_folder):
pkl_files = []
with open('./scores_task1.csv', 'rb') as f:
rows = csv.reader(f, delimiter='\t')
for row in rows:
if '128' in row[0]:
pkl_files.append(validation_base_path + row[0] + '.pkl')
pkl_files_1 = pkl_files[:50]
print len(pkl_files_1)
pkl_scores = []
with open('./results/my_val_scores.csv', 'rb') as f:
rows = csv.reader(f)
for row in rows:
if '128' in row[0]:
pkl_scores.append([validation_base_path + row[0] + '.pkl', float(row[3])])
pkl_scores = sorted(pkl_scores, key=lambda x: x[1], reverse=True)
pkl_files_2 = [x[0] for x in pkl_scores[:50]]
pkl_files = [x for x in pkl_files_1 if x in pkl_files_2]
print len(pkl_files)
mask_pred_challenge_list = []
for pkl_file in tqdm(pkl_files):
try:
mask_pred_challenge = pkl.load(open(pkl_file, 'rb'))
if mask_pred_challenge.max() < 0.5:
print 'garbage model'
continue
mask_pred_challenge_list.append(mask_pred_challenge)
except:
print ( pkl_file, 'Not found')
print 'Finally use {} models'.format(len(mask_pred_challenge_list))
mask_pred_challenge_list = np.array(mask_pred_challenge_list)
mask_pred_challenge = np.mean(mask_pred_challenge_list, axis=0)
print mask_pred_challenge.shape
if not os.path.exists(validation_predicted_folder):
os.makedirs(validation_predicted_folder)
cutoff = 0.5
mask_pred_challenge_b = (np.where(mask_pred_challenge>=cutoff, 1, 0) * 255).astype(np.uint8)
challenge_list = ISIC.list_from_folder(validation_folder)
for i in trange(len(challenge_list)):
_, _ = ISIC.show_images_full_sized(challenge_list,
img_mask_pred_array=mask_pred_challenge_b,
image_folder=validation_folder,
mask_folder=None,
index=i,
output_folder=validation_predicted_folder,
plot=False)
def ensemble(validation_base_path, validation_folder, validation_predicted_folder):
pkl_files = []
weights = []
#weight_file = './file_weight_128.csv'
#weight_file = './file_weight_128_144models.csv'
#weight_file = './file_weight_128_144_updated models.csv'
#weight_file = './file_weight_128_144_3rd version models.csv'
weight_file = './10 best models weights for task 1.csv'
#weight_file = './5 best models weights for task 1.csv'
#weight_file = './20 best models weights for task 1.csv'
with open(weight_file, 'rb') as f:
rows = csv.reader(f, delimiter=',')
#next(rows, None)
for row in rows:
if '.pkl' in row[0]:
pkl_files.append(validation_base_path + row[0])
else:
pkl_files.append(validation_base_path + row[0] + '.pkl')
weights.append(float(row[1]))
print (len(pkl_files))
print weights
print np.sum(weights)
mask_pred_challenge_list = []
for i in trange(len(pkl_files)):
mask_pred_challenge = pkl.load(open(pkl_files[i], 'rb'))
mask_pred_challenge_list.append(mask_pred_challenge)
mask_pred_challenge_list = np.array(mask_pred_challenge_list)
print mask_pred_challenge_list.shape
weights = np.array(weights)
mask_pred_challenge = np.dot(mask_pred_challenge_list.transpose(1,2,3,0), weights)
print mask_pred_challenge.shape
if not os.path.exists(validation_predicted_folder):
os.makedirs(validation_predicted_folder)
cutoff = 0.5
mask_pred_challenge_b = (np.where(mask_pred_challenge>=cutoff, 1, 0) * 255).astype(np.uint8)
challenge_list = ISIC.list_from_folder(validation_folder)
for i in trange(len(challenge_list)):
_, _ = ISIC.show_images_full_sized(challenge_list,
img_mask_pred_array=mask_pred_challenge_b,
image_folder=validation_folder,
mask_folder=None,
index=i,
output_folder=validation_predicted_folder,
plot=False)
def predict_challenge(challenge_folder,
challenge_predicted_folder,
mask_pred_challenge=None,
plot=True):
challenge_list = ISIC.list_from_folder(challenge_folder)
challenge_resized_folder = challenge_folder + "_{}_{}".format(
height, width)
if not os.path.exists(challenge_resized_folder):
ISIC.resize_images(challenge_list,
input_image_folder=challenge_folder,
input_mask_folder=None,
output_image_folder=challenge_resized_folder,
output_mask_folder=None,
height=height,
width=width)
challenge_resized_list = [
name.split(".")[0] + ".png" for name in challenge_list
]
challenge_images = ISIC.load_images(
challenge_resized_list,
height,
width,
image_folder=challenge_resized_folder,
mask_folder=None,
remove_mean_imagenet=True,
use_hsv=use_hsv,
remove_mean_samplewise=remove_mean_samplewise)
if remove_mean_dataset:
challenge_images = (challenge_images - train_mean) / train_std
if mask_pred_challenge is None:
mask_pred_challenge = model.predict(challenge_images)
with open(
'{}.pkl'.format(
os.path.join(challenge_predicted_folder, model_name)),
'wb') as f:
pkl.dump(mask_pred_challenge, f)
mask_pred_challenge = np.where(mask_pred_challenge >= 0.5, 1, 0)
mask_pred_challenge = mask_pred_challenge * 255
mask_pred_challenge = mask_pred_challenge.astype(np.uint8)
challenge_predicted_folder = os.path.join(challenge_predicted_folder,
model_name)
if not os.path.exists(challenge_predicted_folder):
os.makedirs(challenge_predicted_folder)
print("Start challenge prediction:")
for i in range(len(challenge_list)):
print(("{}: {}".format(i, challenge_list[i])))
ISIC.show_images_full_sized(image_list=challenge_list,
img_mask_pred_array=mask_pred_challenge,
image_folder=challenge_folder,
mask_folder=None,
index=i,
output_folder=challenge_predicted_folder,
plot=plot)
def predict_challenge(challenge_folder, challenge_predicted_folder, plot=False):
challenge_list = ISIC.list_from_folder(challenge_folder)
challenge_resized_folder = challenge_folder + "_{}_{}".format(height, width)
if not os.path.exists(challenge_resized_folder):
print "Creating resized challenge images for prediction"
ISIC.resize_images(challenge_list,
input_image_folder=challenge_folder,
input_mask_folder=None,
output_image_folder=challenge_resized_folder,
output_mask_folder=None,
height=height, width=width)
challenge_images = ISIC.load_images(challenge_list, height, width, challenge_resized_folder)
if pre_proc:
challenge_images = my_PreProc(challenge_images)
challenge_images = challenge_images - train_mean
model_name = model_filename.split('.')[1].split('/')[2]
try:
if test_aug:
mask_pred_challenge = pkl.load(open(os.path.join(challenge_predicted_folder, model_name + '_testaug.pkl'), 'rb'))
else:
mask_pred_challenge = pkl.load(open(os.path.join(challenge_predicted_folder, model_name + '.pkl'), 'rb'))
except:
model.load_weights(model_filename)
if test_aug:
print "Predicting using test data augmentation"
mask_pred_challenge = np.array([my_predict(model, x) for x in tqdm(challenge_images)])
with open(os.path.join(challenge_predicted_folder, model_name + '_testaug.pkl'), 'wb') as f:
pkl.dump(mask_pred_challenge, f)
else:
print "Predicting"
mask_pred_challenge = model.predict(challenge_images, batch_size=batch_size)
mask_pred_challenge = mask_pred_challenge[:, 0, :, :] # remove channel dimension
with open(os.path.join(challenge_predicted_folder, model_name + '.pkl'), 'wb') as f:
pkl.dump(mask_pred_challenge, f)
mask_pred_challenge = np.where(mask_pred_challenge>=0.5, 1, 0)
mask_pred_challenge = mask_pred_challenge * 255
mask_pred_challenge = mask_pred_challenge.astype(np.uint8)
if not test_aug:
challenge_predicted_folder = os.path.join(challenge_predicted_folder, model_name)
else:
challenge_predicted_folder = os.path.join(challenge_predicted_folder, model_name + '_testaug')
if not os.path.exists(challenge_predicted_folder):
os.makedirs(challenge_predicted_folder)
print "Start predicting masks of original shapes"
imgs = []
mask_preds = []
for i in trange(len(challenge_list)):
img, mask_pred = ISIC.show_images_full_sized(challenge_list,
img_mask_pred_array=mask_pred_challenge,
image_folder=challenge_folder,
mask_folder=None,
index=i,
output_folder=challenge_predicted_folder,
plot=plot)
#imgs.append(img)
#mask_preds.append(mask_pred)
return imgs, mask_preds
nb_epoch = 220
model_name = model
batch_size = 4
monitor_metric = 'val_jacc_coef' #, 'val_jacc_coef_th'
fc_size = 4096 # for unet1,2 8192 is too large for input 256 * 256
initial_epoch = 0
metrics = [jacc_coef, jacc_coef_th]
n_channels = 3
loss = loss_options[loss_param]
optimizer = Adam(lr=1e-5)
print "Using ISIC 2018 dataset"
base_folder = "./datasets/isic2018_{}_{}".format(height, width)
image_folder = os.path.join(base_folder, "image")
mask_folder = os.path.join(base_folder, "mask")
image_names = ISIC.list_from_folder(training_folder)
if not os.path.exists(base_folder):
ISIC.resize_images(image_names,
input_image_folder=training_folder,
input_mask_folder=training_mask_folder,
output_image_folder=image_folder,
output_mask_folder=mask_folder,
height=height, width=width)
train_list, val_list = train_test_split(image_names, test_size=0.1, random_state=0)
#pkl.dump(val_list, open('./datasets/val_list.pkl', 'wb'))
print "Loading images"
train, train_mask = ISIC.load_images(train_list, height, width, image_folder, mask_folder)
val, val_mask = ISIC.load_images(val_list, height, width, image_folder, mask_folder)
print "Done loading images"
def predict_challenge(challenge_folder,
challenge_predicted_folder,
task1predicted_folder,
plot=False):
challenge_list = ISIC.list_from_folder(challenge_folder)
challenge_crop_resized_folder = challenge_folder + "_crop_{}_{}".format(
height, width)
crop_inds_file = os.path.join(challenge_crop_resized_folder, 'inds.pkl')
if not os.path.exists(challenge_crop_resized_folder) or not os.path.isfile(
crop_inds_file):
print "Cropping and resizing images"
inds = ISIC.crop_resize_images(
challenge_list,
input_image_folder=challenge_folder,
input_mask_folder=None,
input_gtcrop_folder=task1predicted_folder,
output_image_folder=challenge_crop_resized_folder,
output_mask_folder=None,
height=height,
width=width)
pkl.dump(inds, open(crop_inds_file, 'wb'))
inds = pkl.load(open(crop_inds_file, 'rb'))
challenge_images = ISIC.load_images(challenge_list, height, width,
challenge_crop_resized_folder)
if pre_proc:
challenge_images = my_PreProc(challenge_images)
challenge_images = challenge_images - train_mean
model_name = model_filename.split('.')[1].split('/')[2]
try:
if test_aug:
mask_pred_challenge = pkl.load(
open(
os.path.join(challenge_predicted_folder,
model_name + '_testaug.pkl'), 'rb'))
else:
mask_pred_challenge = pkl.load(
open(
os.path.join(challenge_predicted_folder,
model_name + '.pkl'), 'rb'))
except:
print 'making prediction...'
model.load_weights(model_filename)
if test_aug:
print "Predicting using test data augmentation"
mask_pred_challenge = np.array(
[my_predict(model, x) for x in tqdm(challenge_images)])
print mask_pred_challenge.shape
else:
mask_pred_challenge = model.predict(challenge_images,
batch_size=batch_size)
mask_pred_challenge = mask_pred_challenge[:, 0, :, :]
print mask_pred_challenge.shape
if do_filter:
print "Using step2 and step1 classifiers"
size_1_2 = 256
challenge_crop_resized_folder = challenge_folder + "_crop_{}_{}".format(
size_1_2, size_1_2)
if not os.path.exists(challenge_crop_resized_folder):
print "Cropping and resizing images"
_ = ISIC.crop_resize_images(
challenge_list,
input_image_folder=challenge_folder,
input_mask_folder=None,
input_gtcrop_folder=task1predicted_folder,
output_image_folder=challenge_crop_resized_folder,
output_mask_folder=None,
height=size_1_2,
width=size_1_2)
challenge_images = ISIC.load_images(challenge_list, size_1_2,
size_1_2,
challenge_crop_resized_folder)
# filter by pre model
pre_cls_model_filename = './weights2018_task2/{}_{}_crop_pre_cls.h5'.format(
'vgg', size_1_2)
pre_cls_model = models.VGG16(size_1_2,
size_1_2,
pretrained=True,
freeze_pretrained=False,
loss='binary_crossentropy',
optimizer=Adam(lr=1e-5),
metrics=['accuracy'])
pre_cls_model.load_weights(pre_cls_model_filename)
step1_mean = pkl.load(
open('./datasets/task2_step1_train_mean.pkl', 'rb'))
prob_pre = pre_cls_model.predict(challenge_images - step1_mean)
print prob_pre.shape
# filter by cls model
cls_model_filename = './weights2018_task2/{}_{}_{}_crop_cls.h5'.format(
attribute, 'vgg', size_1_2)
cls_model = models.VGG16(size_1_2,
size_1_2,
pretrained=True,
freeze_pretrained=False,
loss='binary_crossentropy',
optimizer=Adam(lr=1e-5),
metrics=['accuracy'])
cls_model.load_weights(cls_model_filename)
step2_mean = pkl.load(
open('./datasets/task2_step2_train_mean.pkl', 'rb'))
prob_pred = cls_model.predict(challenge_images - step2_mean)
print prob_pred.shape
# prob product
mask_pred_challenge = mask_pred_challenge * prob_pred[:, np.
newaxis] * prob_pre[:,
np
.
newaxis]
if test_aug:
with open(
os.path.join(challenge_predicted_folder,
model_name + '_testaug.pkl'), 'wb') as f:
pkl.dump(mask_pred_challenge, f)
else:
with open(
os.path.join(challenge_predicted_folder,
model_name + '.pkl'), 'wb') as f:
pkl.dump(mask_pred_challenge, f)
cutoff = 0.5
mask_pred_challenge_256 = (np.where(mask_pred_challenge >= cutoff, 1, 0) *
255).astype(np.uint8)
if test_aug:
challenge_predicted_folder = os.path.join(challenge_predicted_folder,
model_name + '_testaug')
else:
challenge_predicted_folder = os.path.join(challenge_predicted_folder,
model_name)
if not os.path.exists(challenge_predicted_folder):
os.makedirs(challenge_predicted_folder)
print "Start predicting masks of original shapes"
imgs = []
mask_preds = []
for i in trange(len(challenge_list)):
img, mask_pred = ISIC.show_crop_images_full_sized(
challenge_list,
img_mask_pred_array=mask_pred_challenge_256,
image_folder=challenge_folder,
inds=inds,
mask_folder=None,
index=i,
output_folder=challenge_predicted_folder,
attribute=attribute,
plot=plot)
model_name = model
do_filter = True # filter the segment using classifier model
batch_size = 4
monitor_metric = 'val_jacc_coef'
fc_size = 8192
initial_epoch = 0
n_channels = 3
loss = loss_options[loss_param]
optimizer = Adam(lr=1e-5)
print "Using ISIC 2018 dataset"
base_folder = "datasets/isic2018_crop_{}_{}_{}".format(attribute, height,
width)
image_folder = os.path.join(base_folder, "image")
mask_folder = os.path.join(base_folder, "mask")
image_names = ISIC.list_from_folder(training_folder)
if not os.path.exists(base_folder):
print('Cropping and Resizing...')
ISIC.crop_resize_images(image_names,
input_image_folder=training_folder,
input_mask_folder=training_mask_folder,
input_gtcrop_folder=task1gt_folder,
output_image_folder=image_folder,
output_mask_folder=mask_folder,
height=height,
width=width,
attribute=attribute)
train_list, val_list = train_test_split(image_names,
test_size=0.1,
random_state=0)
def predict_challenge(challenge_folder,
challenge_predicted_folder,
plot=False):
challenge_list = ISIC.list_from_folder(challenge_folder)
challenge_resized_folder = challenge_folder + "_{}_{}".format(
height, width)
if not os.path.exists(challenge_resized_folder):
print "Creating resized challenge images for prediction"
ISIC.resize_images(challenge_list,
input_image_folder=challenge_folder,
input_mask_folder=None,
output_image_folder=challenge_resized_folder,
output_mask_folder=None,
height=height,
width=width)
challenge_images = ISIC.load_images(challenge_list, height, width,
challenge_resized_folder)
if pre_proc:
challenge_images = my_PreProc(challenge_images)
challenge_images = challenge_images - train_mean
model_name = model_filename.split('.')[1].split('/')[2]
try:
if test_aug:
mask_pred_challenge = pkl.load(
open(
os.path.join(challenge_predicted_folder,
model_name + '_testaug.pkl'), 'rb'))
else:
mask_pred_challenge = pkl.load(
open(
os.path.join(challenge_predicted_folder,
model_name + '.pkl'), 'rb'))
except:
model.load_weights(model_filename)
if test_aug:
print "Predicting using test data augmentation"
mask_pred_challenge = np.array(
[my_predict(model, x) for x in tqdm(challenge_images)])
with open(
os.path.join(challenge_predicted_folder,
model_name + '_testaug.pkl'), 'wb') as f:
pkl.dump(mask_pred_challenge, f)
else:
print "Predicting"
mask_pred_challenge = model.predict(challenge_images,
batch_size=batch_size)
mask_pred_challenge = mask_pred_challenge[:,
0, :, :] # remove channel dimension
with open(
os.path.join(challenge_predicted_folder,
model_name + '.pkl'), 'wb') as f:
pkl.dump(mask_pred_challenge, f)
mask_pred_challenge = np.where(mask_pred_challenge >= 0.5, 1, 0)
mask_pred_challenge = mask_pred_challenge * 255
mask_pred_challenge = mask_pred_challenge.astype(np.uint8)
if not test_aug:
challenge_predicted_folder = os.path.join(challenge_predicted_folder,
model_name)
else:
challenge_predicted_folder = os.path.join(challenge_predicted_folder,
model_name + '_testaug')
if not os.path.exists(challenge_predicted_folder):
os.makedirs(challenge_predicted_folder)
print "Start predicting masks of original shapes"
imgs = []
mask_preds = []
for i in trange(len(challenge_list)):
img, mask_pred = ISIC.show_images_full_sized(
challenge_list,
img_mask_pred_array=mask_pred_challenge,
image_folder=challenge_folder,
mask_folder=None,
index=i,
output_folder=challenge_predicted_folder,
plot=plot)
#imgs.append(img)
#mask_preds.append(mask_pred)
return imgs, mask_preds
nb_epoch = 220
model_name = model
batch_size = 4
monitor_metric = 'val_jacc_coef' #, 'val_jacc_coef_th'
fc_size = 4096 # for unet1,2 8192 is too large for input 256 * 256
initial_epoch = 0
metrics = [jacc_coef, jacc_coef_th]
n_channels = 3
loss = loss_options[loss_param]
optimizer = Adam(lr=1e-5)
print "Using ISIC 2018 dataset"
base_folder = "./datasets/isic2018_{}_{}".format(height, width)
image_folder = os.path.join(base_folder, "image")
mask_folder = os.path.join(base_folder, "mask")
image_names = ISIC.list_from_folder(training_folder)
if not os.path.exists(base_folder):
ISIC.resize_images(image_names,
input_image_folder=training_folder,
input_mask_folder=training_mask_folder,
output_image_folder=image_folder,
output_mask_folder=mask_folder,
height=height,
width=width)
train_list, val_list = train_test_split(image_names,
test_size=0.1,
random_state=0)
#pkl.dump(val_list, open('./datasets/val_list.pkl', 'wb'))
print "Loading images"
img = img.astype(np.uint8)
img = img.transpose(1, 2, 0)
f, ax = plt.subplots(1, 2)
ax[0].imshow(img)
ax[0].axis("off")
ax[1].imshow(mask, cmap='Greys_r')
ax[1].axis("off")
plt.show()
yield (train_gen, train_mask)
if do_train:
if dataset == 'isicfull':
n_samples = 2000 # per epoch
print("Using ISIC full dataset")
train_list, val_list, test_list = ISIC.train_val_test_from_txt(
isicfull_train_split, isicfull_val_split, isicfull_test_split)
# folders for resized images
base_folder = "datasets/isicfull_{}_{}".format(height, width)
image_folder = os.path.join(base_folder, "image")
mask_folder = os.path.join(base_folder, "mask")
if not os.path.exists(base_folder):
print("Begin resizing...")
ISIC.resize_images(train_list + val_list + test_list,
input_image_folder=isicfull_folder,
input_mask_folder=isicfull_mask_folder,
output_image_folder=image_folder.format(
height, width),
output_mask_folder=mask_folder,
height=height,
width=width)
print("Done resizing...")
def predict_challenge(challenge_folder,
challenge_predicted_folder,
mask_pred_challenge=None,
plot=True,
validation=False):
print(model_filename)
challenge_list = ISIC.list_from_folder(challenge_folder + '/image/')
challenge_resized_folder = challenge_folder + "_{}_{}".format(
height, width)
if not os.path.exists(challenge_resized_folder):
if (validation):
ISIC.resize_images(
challenge_list,
input_image_folder=challenge_folder + '/image/',
input_mask_folder=challenge_folder + '/mask/',
output_image_folder=challenge_resized_folder + '/image/',
output_mask_folder=challenge_resized_folder + '/mask/',
height=height,
width=width)
else:
ISIC.resize_images(challenge_list,
input_image_folder=challenge_folder + '/image/',
input_mask_folder=None,
output_image_folder=challenge_resized_folder +
'/image/',
output_mask_folder=None,
height=height,
width=width)
challenge_resized_list = [
name.split(".")[0] + ".jpg" for name in challenge_list
] #challenge_list
challenge_images = ISIC.load_images(
challenge_resized_list,
height,
width,
image_folder=challenge_resized_folder + '/image/',
mask_folder=None,
remove_mean_imagenet=remove_mean_imagenet,
use_hsv=use_hsv,
remove_mean_samplewise=remove_mean_samplewise,
use_histeq=use_histeq,
use_rgb_histeq=use_rgb_histeq,
use_only_histeq=use_only_histeq,
use_color_en=use_color_en,
use_naik=use_naik,
use_hct=use_hct,
use_only_texture=use_only_texture)
if remove_mean_dataset:
challenge_images = (challenge_images - train_mean) / train_std
if mask_pred_challenge is None:
mask_pred_challenge = model.predict(challenge_images)
mask_pred_challenge = np.where(mask_pred_challenge >= 0.5, 1, 0)
mask_pred_challenge = mask_pred_challenge * 255
mask_pred_challenge = mask_pred_challenge.astype(np.uint8)
if (validation):
dice = 0
jacc = 0
sen = 0
acc = 0
spec = 0
mask_list = ISIC.list_masks_from_folder(challenge_folder +
'/mask/')
for i in range(mask_pred_challenge.shape[0]):
img = mask_pred_challenge[i, :, :, :]
img = post_process(img)
orig_img_filename = os.path.join(challenge_folder + '/image/',
challenge_list[i])
orig_img_size = cv2.imread(orig_img_filename).shape[:2]
resized_mask = cv2.resize(img,
(orig_img_size[1], orig_img_size[0]),
interpolation=cv2.INTER_LINEAR
) #resize the predicted masks
true_mask = ISIC.get_mask(
image_name=mask_list[i],
mask_folder=challenge_folder + '/mask/',
rescale_mask=rescale_mask) # read the original mask
current_dice, current_jacc = dice_jacc_single(
true_mask, resized_mask,
smooth=0) # find the jacc coeff for the resized masks
dice = dice + current_dice
jacc = jacc + current_jacc
# name = os.path.basename(mask_list[i]).split('.')[0] + '.jpg'
# filename = '../results/compare/naik/'+'naik_'+name
# cv2.imwrite(filename,resized_mask)
_, pred_mask = cv2.threshold(resized_mask, 127, 255,
cv2.THRESH_BINARY)
pred_mask = pred_mask / 255
curr_sen = img_sensitivity(true_mask, pred_mask)
curr_acc = img_accuracy(true_mask, pred_mask)
curr_spec = img_specificity(true_mask, pred_mask)
print(curr_sen, curr_spec, curr_acc, current_dice,
current_jacc)
sen = sen + curr_sen
spec = spec + curr_spec
acc = acc + curr_acc
dice = dice / mask_pred_challenge.shape[0]
jacc = jacc / mask_pred_challenge.shape[0]
print("Original size validation dice coef : {:.4f}".format(
dice))
print("Original size validation jacc coef : {:.4f}".format(
jacc))
acc = acc / len(mask_list)
sen = sen / len(mask_list)
spec = spec / len(mask_list)
print("Original size validation acc : {:.4f}".format(acc))
print("Original size validation sensitivity : {:.4f}".format(
sen))
print("Original size validation specificity : {:.4f}".format(
spec))
print(model_filename)
else:
for i in range(mask_pred_challenge.shape[0]):
img = mask_pred_challenge[i, :, :, :]
img = post_process(img)
orig_img_filename = os.path.join(challenge_folder,
challenge_list[i])
orig_img = cv2.imread(orig_img_filename)
orig_img_size = orig_img.shape[:2]
resized_mask = cv2.resize(img,
(orig_img_size[1], orig_img_size[0]),
interpolation=cv2.INTER_LINEAR
) #resize the predicted masks
_, pred_mask = cv2.threshold(resized_mask, 127, 255,
cv2.THRESH_BINARY)
img1_bg = cv2.bitwise_and(orig_img, orig_img, mask=pred_mask)
name = os.path.basename(
challenge_list[i]).split('.')[0] + '.jpg'
filename = '../segmented2017/valid/' + name
cv2.imwrite(filename, img1_bg)
else:
if (validation):
dice = 0
jacc = 0
sen = 0
acc = 0
spec = 0
resized_masks = []
mask_list = ISIC.list_masks_from_folder(challenge_folder +
'/mask/')
for i in range(len(mask_pred_challenge)):
img = mask_pred_challenge[i, :, :, :].astype(np.uint8)
img = post_process(img)
orig_img_filename = os.path.join(challenge_folder + '/image/',
challenge_list[i])
orig_img_size = cv2.imread(orig_img_filename).shape[:2]
resized_mask = cv2.resize(img,
(orig_img_size[1], orig_img_size[0]),
interpolation=cv2.INTER_LINEAR
) #resize the predicted masks
resized_masks.append(resized_mask)
true_mask = ISIC.get_mask(
image_name=mask_list[i],
mask_folder=challenge_folder + '/mask/',
rescale_mask=rescale_mask) # read the original mask
current_dice, current_jacc = dice_jacc_single(
true_mask, resized_mask,
smooth=0) # find the jacc coeff for the resized masks
dice = dice + current_dice
jacc = jacc + current_jacc
_, pred_mask = cv2.threshold(resized_mask, 127, 255,
cv2.THRESH_BINARY)
pred_mask = pred_mask / 255
curr_sen = img_sensitivity(true_mask, pred_mask)
curr_acc = img_accuracy(true_mask, pred_mask)
curr_spec = img_specificity(true_mask, pred_mask)
print(curr_sen, curr_spec, curr_acc, current_dice,
current_jacc)
sen = sen + curr_sen
spec = spec + curr_spec
acc = acc + curr_acc
# name = os.path.basename(challenge_list[i]).split('.')[0] + '_segmentation.png'
# filename = './predicted_masks/'+name
# cv2.imwrite(filename,resized_mask)
dice = dice / mask_pred_challenge.shape[0]
jacc = jacc / mask_pred_challenge.shape[0]
print("Original size validation dice coef : {:.4f}".format(
dice))
print("Original size validation jacc coef : {:.4f}".format(
jacc))
acc = acc / len(mask_list)
sen = sen / len(mask_list)
spec = spec / len(mask_list)
print("Original size validation acc : {:.4f}".format(acc))
print("Original size validation sensitivity : {:.4f}".format(
sen))
print("Original size validation specificity : {:.4f}".format(
spec))
print(model_filename)
# with open('{}.pkl'.format(os.path.join(challenge_predicted_folder,model_name)), 'wb') as f:
# pkl.dump(mask_pred_challenge, f)
# challenge_predicted_folder = os.path.join(challenge_predicted_folder, model_name)
# if not os.path.exists(challenge_predicted_folder):
# os.makedirs(challenge_predicted_folder)
if (plot):
print("Start challenge prediction:")
for i in range(len(challenge_list)):
print("{}: {}".format(i, challenge_list[i]))
ISIC.show_images_full_sized(
image_list=challenge_list,
img_mask_pred_array=mask_pred_challenge,
image_folder=challenge_folder,
mask_folder=None,
index=i,
output_folder=challenge_predicted_folder,
plot=plot)
img = img.astype(np.uint8)
# img = img.transpose(1,2,0)
f, ax = plt.subplots(1, 2)
ax[0].imshow(img)
ax[0].axis("off")
ax[1].imshow(mask, cmap='Greys_r')
ax[1].axis("off")
plt.show()
yield (train_gen, train_mask)
if do_train:
if dataset == 'isicfull':
n_samples = 2000 # per epoch
print("Using ISIC full dataset")
train_list, val_list, test_list = ISIC.train_val_test_from_txt(
isicfull_train_split, isicfull_val_split, isicfull_test_split)
# folders for resized images
base_folder = "datasets/training_{}_{}".format(height, width)
image_folder = os.path.join(base_folder, "image")
mask_folder = os.path.join(base_folder, "mask")
if not os.path.exists(base_folder):
print("Begin resizing...")
ISIC.resize_images(train_list + val_list + test_list,
input_image_folder=isicfull_folder,
input_mask_folder=isicfull_mask_folder,
output_image_folder=image_folder.format(
height, width),
output_mask_folder=mask_folder,
height=height,
width=width)
print("Done resizing...")
height, width = size, size
nb_epoch = 220
model = "vgg"
model_name = model
do_train = True
do_pre = True
do_evaluate = True
batch_size = 16
monitor_metric = 'val_loss'
initial_epoch = 0
n_channels = 3
print "Using ISIC 2018 dataset"
image_names = ISIC.list_from_folder(training_folder)
train_list, val_list = train_test_split(image_names, test_size=0.1, random_state=0)
base_folder = "datasets/isic2018_crop_{}_{}_{}".format(attribute, height, width)
image_folder = os.path.join(base_folder, "image")
mask_folder = os.path.join(base_folder, "mask")
if not os.path.exists(base_folder):
print "Cropping and Resizing..."
ISIC.crop_resize_images(image_names,
input_image_folder=training_folder,
input_mask_folder=training_mask_folder,
input_gtcrop_folder=task1gt_folder,
output_image_folder=image_folder,
output_mask_folder=mask_folder,
height=height, width=width,
attribute=attribute)
def predict_challenge(challenge_folder,
challenge_predicted_folder,
mask_pred_challenge=None,
plot=True,
validation=False):
print(model_filename)
print('Loading model')
model.load_weights(model_filename)
challenge_list = ISIC.list_from_folder(challenge_folder +
"_{}_{}".format(height, width) +
'/image/')
challenge_resized_folder = challenge_folder + "_{}_{}".format(
height, width)
if not os.path.exists(challenge_resized_folder):
if (validation):
ISIC.resize_images(
challenge_list,
input_image_folder=challenge_folder + '/image/',
input_mask_folder=challenge_folder + '/mask/',
output_image_folder=challenge_resized_folder + '/image/',
output_mask_folder=challenge_resized_folder + '/mask/',
height=height,
width=width)
else:
ISIC.resize_images(challenge_list,
input_image_folder=challenge_folder + '/image/',
input_mask_folder=None,
output_image_folder=challenge_resized_folder +
'/image/',
output_mask_folder=None,
height=height,
width=width)
challenge_resized_list = [
name.split(".")[0] + ".jpg" for name in challenge_list
] #challenge_list
challenge_images = ISIC.load_images(
challenge_resized_list,
height,
width,
image_folder=challenge_resized_folder + '/image/',
mask_folder=None,
remove_mean_imagenet=remove_mean_imagenet,
use_hsv=use_hsv,
remove_mean_samplewise=remove_mean_samplewise,
use_histeq=use_histeq,
use_rgb_histeq=use_rgb_histeq,
use_only_histeq=use_only_histeq,
use_color_en=use_color_en,
use_naik=use_naik,
use_hct=use_hct,
use_only_texture=use_only_texture)
if mask_pred_challenge is None:
mask_pred_challenge = model.predict(challenge_images)
print(mask_pred_challenge.shape)
with open(
'{}.pkl'.format(
os.path.join(challenge_predicted_folder, model_name)),
'wb') as f:
pkl.dump(mask_pred_challenge, f)