def main() -> None:
"""
Script to check ground truth masks as one was found to be most of the image and not a tumour
"""
parse_command_line_arguments()
print_num_gpus_available()
# Start recording time.
start_time = time.time()
# df = pd.read_csv("../data/CBIS-DDSM-mask/final_mask_training.csv")
df = pd.read_csv("../data/CBIS-DDSM-mask/shortened_mask_testing.csv")
images = df['img_path'].values
image_masks = df['mask_img_path'].values
i = 0
for image_mask_name in image_masks:
image_bytes_mask = tf.io.read_file(image_mask_name)
image_mask = tfio.image.decode_dicom_image(image_bytes_mask,
color_dim=True)
image_mask = tf.image.resize_with_pad(image_mask,
config.VGG_IMG_SIZE['HEIGHT'],
config.VGG_IMG_SIZE['WIDTH'])
current_min_mask = tf.reduce_min(image_mask)
current_max_mask = tf.reduce_max(image_mask)
image_mask = (image_mask - current_min_mask) / (current_max_mask -
current_min_mask)
array = np.array(image_mask)
sum_arr = sum(sum(sum(array)))
if sum_arr > 200000:
print(image_mask_name)
def main() -> None:
"""
Program entry point. Parses command line arguments to decide which dataset and model to use.
Originally written as a group for the common pipeline. Later amended by Adam Jaamour.
:return: None.
"""
set_random_seeds()
parse_command_line_arguments()
print_num_gpus_available()
# Create label encoder.
l_e = create_label_encoder()
# Run in training mode.
if config.run_mode == "train":
print("-- Training model --\n")
# Start recording time.
start_time = time.time()
# Multi-class classification (mini-MIAS dataset)
if config.dataset == "mini-MIAS":
# Import entire dataset.
images, labels = import_minimias_dataset(data_dir="../data/{}/images_processed".format(config.dataset),
label_encoder=l_e)
# Split dataset into training/test/validation sets (80/20% split).
X_train, X_test, y_train, y_test = dataset_stratified_split(split=0.20, dataset=images, labels=labels)
# Create CNN model and split training/validation set (80/20% split).
model = CnnModel(config.model, l_e.classes_.size)
X_train, X_val, y_train, y_val = dataset_stratified_split(split=0.25,
dataset=X_train,
labels=y_train)
# Calculate class weights.
class_weights = calculate_class_weights(y_train, l_e)
# Data augmentation.
y_train_before_data_aug = y_train
X_train, y_train = generate_image_transforms(X_train, y_train)
y_train_after_data_aug = y_train
np.random.shuffle(y_train)
if config.verbose_mode:
print("Before data augmentation:")
print(Counter(list(map(str, y_train_before_data_aug))))
print("After data augmentation:")
print(Counter(list(map(str, y_train_after_data_aug))))
# Fit model.
if config.verbose_mode:
print("Training set size: {}".format(X_train.shape[0]))
print("Validation set size: {}".format(X_val.shape[0]))
print("Test set size: {}".format(X_test.shape[0]))
model.train_model(X_train, X_val, y_train, y_val, class_weights)
# Binary classification (binarised mini-MIAS dataset)
elif config.dataset == "mini-MIAS-binary":
# Import entire dataset.
images, labels = import_minimias_dataset(data_dir="../data/{}/images_processed".format(config.dataset),
label_encoder=l_e)
# Split dataset into training/test/validation sets (80/20% split).
X_train, X_val, y_train, y_val = dataset_stratified_split(split=0.20, dataset=images, labels=labels)
# Create CNN model and split training/validation set (80/20% split).
model = CnnModel(config.model, l_e.classes_.size)
# model.load_minimias_weights()
# model.load_minimias_fc_weights()
# Fit model.
if config.verbose_mode:
print("Training set size: {}".format(X_train.shape[0]))
print("Validation set size: {}".format(X_val.shape[0]))
model.train_model(X_train, X_val, y_train, y_val, None)
# Binary classification (CBIS-DDSM dataset).
elif config.dataset == "CBIS-DDSM":
images, labels = import_cbisddsm_training_dataset(l_e)
# Split training dataset into training/validation sets (75%/25% split).
X_train, X_val, y_train, y_val = dataset_stratified_split(split=0.25, dataset=images, labels=labels)
train_dataset = create_dataset(X_train, y_train)
validation_dataset = create_dataset(X_val, y_val)
# Calculate class weights.
class_weights = calculate_class_weights(y_train, l_e)
# Create and train CNN model.
model = CnnModel(config.model, l_e.classes_.size)
# model.load_minimias_fc_weights()
# model.load_minimias_weights()
# Fit model.
if config.verbose_mode:
print("Training set size: {}".format(X_train.shape[0]))
print("Validation set size: {}".format(X_val.shape[0]))
model.train_model(train_dataset, validation_dataset, None, None, class_weights)
# Save training runtime.
runtime = round(time.time() - start_time, 2)
# Save the model and its weights/biases.
model.save_model()
model.save_weights()
# Evaluate training results.
print_cli_arguments()
if config.dataset == "mini-MIAS":
model.make_prediction(X_val)
model.evaluate_model(y_val, l_e, 'N-B-M', runtime)
elif config.dataset == "mini-MIAS-binary":
model.make_prediction(X_val)
model.evaluate_model(y_val, l_e, 'B-M', runtime)
elif config.dataset == "CBIS-DDSM":
model.make_prediction(validation_dataset)
model.evaluate_model(y_val, l_e, 'B-M', runtime)
print_runtime("Training", runtime)
# Run in testing mode.
elif config.run_mode == "test":
print("-- Testing model --\n")
# Start recording time.
start_time = time.time()
# Test multi-class classification (mini-MIAS dataset).
if config.dataset == "mini-MIAS":
images, labels = import_minimias_dataset(data_dir="../data/{}/images_processed".format(config.dataset),
label_encoder=l_e)
_, X_test, _, y_test = dataset_stratified_split(split=0.20, dataset=images, labels=labels)
model = load_trained_model()
predictions = model.predict(x=X_test)
runtime = round(time.time() - start_time, 2)
test_model_evaluation(y_test, predictions, l_e, 'N-B-M', runtime)
# Test binary classification (binarised mini-MIAS dataset).
elif config.dataset == "mini-MIAS-binary":
pass
# Test binary classification (CBIS-DDSM dataset).
elif config.dataset == "CBIS-DDSM":
images, labels = import_cbisddsm_testing_dataset(l_e)
test_dataset = create_dataset(images, labels)
model = load_trained_model()
predictions = model.predict(x=test_dataset)
runtime = round(time.time() - start_time, 2)
test_model_evaluation(labels, predictions, l_e, 'B-M', runtime)
print_runtime("Testing", runtime)
def main() -> None:
"""
Program entry point. Parses command line arguments to decide which dataset and model to use.
:return: None.
Script used for training and testing a segmentation model on the CBIS-DDSM dataset
"""
parse_command_line_arguments()
print_num_gpus_available()
# Start recording time.
start_time = time.time()
if config.run_mode == "train":
images, image_masks = import_cbisddsm_segmentation_training_dataset()
if config.patches == "inc":
train_segmentation_network_incremental(images, image_masks)
else:
# Split training dataset into training/validation sets (75%/25% split).
X_train, X_val, y_train, y_val = train_test_split(images,
image_masks,
test_size=0.25,
random_state=config.RANDOM_SEED,
shuffle=True)
if config.patches == "full":
dataset_train = create_dataset_masks(X_train, y_train)
dataset_val = create_dataset_masks(X_val, y_val)
elif config.patches == "patch":
dataset_train = create_dataset_patched(X_train, y_train)
dataset_val = create_dataset_patched(X_val, y_val)
# Run in training mode.
if config.run_mode == "train":
# Create and train CNN model.
model = u_net_res_model(input_height = config.VGG_IMG_SIZE['HEIGHT'], input_width = config.VGG_IMG_SIZE['WIDTH'])
print()
print("TRAINING MODEL...")
print()
model = train_segmentation_network(model, dataset_train, dataset_val, config.EPOCH_1,
config.EPOCH_2)
# Save the model
model.save("../saved_models/segmentation_model-{}_imagesize-{}x{}_filtered_{}.h5".format(config.segmodel, str(config.VGG_IMG_SIZE['HEIGHT']), str(config.VGG_IMG_SIZE['WIDTH']), config.prep))
# print training time
print_runtime("Total", round(time.time() - start_time, 2))
# Evaluate model results.
if config.patches == "full":
y_pred = make_predictions(model, dataset_val)
evaluate_segmentation(y_val, y_pred, threshold = 0.5)
visualise_examples(X_val, y_val, y_pred, threshold = 0.5)
else:
y_pred = make_predictions(model, dataset_val)
evaluate_segmentation(dataset_val, y_pred, threshold = 0.5)
visualise_examples(dataset_val, None, y_pred, threshold = 0.5)
elif config.run_mode == "test":
print()
print("TESTING MODEL...")
print()
model = load_model("../saved_models/segmentation/segmentation_model-RS50_imagesize-1024x640_filtered_Y_dual_loss_dropout.h5", compile=False)
# model.load_weights("../saved_models/segmentation/segmentation_model-upsizing_checkpoint_0_small_start.h5")
images, image_masks = import_cbisddsm_segmentation_testing_dataset()
if config.patches == "inc":
dataset_test = create_dataset_cropped(images, image_masks, config.BATCH_SIZE)
else:
dataset_test = create_dataset_masks(images, image_masks)
training_start_time = time.time()
if config.patches == "full":
y_pred = make_predictions(model, dataset_test)
print_runtime("Total testing time", round(time.time() - training_start_time, 2))
evaluate_segmentation(image_masks, y_pred, threshold = 0.5)
visualise_examples(images, image_masks, y_pred, threshold = 0.5)
else:
y_pred = make_predictions(model, dataset_test)
print_runtime("Total testing time", round(time.time() - training_start_time, 2))
visualise_examples(dataset_test, None, y_pred, threshold = 0.5)
def main() -> None:
"""
Program entry point. Parses command line arguments to decide which dataset and model to use.
:return: None.
"""
parse_command_line_arguments()
print_num_gpus_available()
gpu = tf.config.experimental.list_physical_devices(device_type='GPU')
tf.config.experimental.set_memory_growth(gpu[0], True)
# Start recording time.
start_time = time.time()
# Create label encoder.
l_e = create_label_encoder()
# Multiclass classification (mini-MIAS dataset)
if config.dataset == "mini-MIAS":
# Import entire dataset.
images, chars, labels = import_minimias_dataset(
data_dir="../data/{}/images".format(config.dataset),
label_encoder=l_e)
# Split dataset into training/test/validation sets (60%/20%/20% split).
X_train, X_test, y_train, y_test = dataset_stratified_split(
split=0.20, dataset=images, labels=labels)
X_train, X_val, y_train, y_val = dataset_stratified_split(
split=0.25, dataset=X_train, labels=y_train)
if config.SAMPLING == 'x':
X_train_rebalanced = X_train
y_train_rebalanced = y_train
else:
print(len(y_train))
print(l_e.classes_)
print(y_train.sum(axis=0))
if len(config.CLASS_TYPE.split('-')) == 2:
if config.SAMPLING == 'up':
X_train_rebalanced, y_train_rebalanced = generate_image_transforms_upsample(
X_train, y_train)
elif config.SAMPLING == 'down':
X_train_rebalanced, y_train_rebalanced = generate_image_transforms_downsample(
X_train, y_train)
if len(config.CLASS_TYPE.split(
'-')) != 2 and config.SAMPLING == 'up':
X_train_rebalanced, y_train_rebalanced = generate_image_transforms(
X_train, y_train)
print(len(y_train_rebalanced))
print(l_e.classes_)
print(y_train_rebalanced.sum(axis=0))
# Create and train CNN model.
if config.cnn == "ResNet":
if config.model == 'basic':
model = generate_resnet_model(l_e.classes_.size)
elif config.cnn == "VGG":
if config.model == 'basic':
model = generate_vgg_model(l_e.classes_.size)
else:
model = generate_vgg_model_advance(l_e.classes_.size)
if config.run_mode == "train":
model = train_network(l_e.classes_.size, model, X_train_rebalanced,
y_train_rebalanced, X_val, y_val,
config.BATCH_SIZE, config.EPOCH_1,
config.EPOCH_2)
# Binary classification (CBIS-DDSM dataset).
elif config.dataset == "CBIS-DDSM":
images, labels, density, cc, mlo = import_cbisddsm_training_dataset(
l_e)
images_test, labels_test, density_test, cc_test, mlo_test = import_cbisddsm_testing_dataset(
l_e)
if len(config.model.split('-')) > 1 and config.model.split(
'-')[1] == '3':
if config.run_mode == "train":
X = np.vstack((images, density, cc, mlo))
elif config.run_mode == "test":
X_test = np.vstack(
(images_test, density_test, cc_test, mlo_test))
X_test = X_test.transpose()
else:
if config.run_mode == "train":
X = np.vstack((images, density))
elif config.run_mode == "test":
X_test = np.vstack((images_test, density_test))
X_test = X_test.transpose()
if config.run_mode == "test":
y_test = labels_test
if config.run_mode == "train":
# Split training dataset into training/validation sets (75%/25% split).
X_train, X_val, y_train, y_val = dataset_stratified_split(
split=0.25, dataset=X.transpose(), labels=labels)
# X_train, X_val, y_train, y_val = dataset_stratified_split(split=0.25, dataset=images, labels=labels)
if config.run_mode == "train":
dataset_train = create_dataset(X_train, y_train)
dataset_val = create_dataset(X_val, y_val)
elif config.run_mode == "test":
dataset_test = create_dataset(X_test, y_test)
# Create and train CNN model.
if config.cnn == "ResNet":
if config.model.startswith('basic'):
if len(config.model.split('-')) == 1:
model = generate_resnet_model(l_e.classes_.size)
else:
model = generate_resnet_model_and_density(
l_e.classes_.size)
else:
if len(config.model.split('-')) == 1:
model = generate_resnet_model_advance(l_e.classes_.size)
else:
model = generate_resnet_model_advance_and_density(
l_e.classes_.size)
elif config.cnn == "VGG":
if config.model.startswith('basic'):
if len(config.model.split('-')) == 1:
model = generate_vgg_model(l_e.classes_.size)
else:
model = generate_vgg_model_and_density(l_e.classes_.size)
else:
if len(config.model.split('-')) == 1:
model = generate_vgg_model_advance(l_e.classes_.size)
else:
model = generate_vgg_model_advance_and_density(
l_e.classes_.size)
if config.run_mode == "train":
model = train_network(l_e.classes_.size, model, dataset_train,
None, dataset_val, None, config.BATCH_SIZE,
config.EPOCH_1, config.EPOCH_2)
else:
print_error_message()
try:
# Save the model
# model.save("../saved_models/dataset-{}_model-{}-{}_" + datetime.now().strftime("%d%Y%H%M%S") + ".h5".format(config.dataset, config.model, config.cnn))
if config.run_mode == "train":
save_time = datetime.now().strftime("%Y%m%d%H%M")
model.save_weights(
"/cs/tmp/sjc29/saved_models/dataset-{}_model-{}-{}_{}.h5".
format(config.dataset, config.model, config.cnn, save_time))
print('save_time: ', save_time)
print_runtime("Finish Training", round(time.time() - start_time,
2))
elif config.run_mode == "test":
model.load_weights(
"/cs/tmp/sjc29/saved_models/dataset-{}_model-{}-{}_{}.h5".
format(config.dataset, config.model, config.cnn,
config.MODEL_SAVE_TIME))
except:
print('save/load model error: ' + sys.exc_info()[0])
# print config
print_config()
# Evaluate model results.
if config.dataset == "mini-MIAS":
if config.run_mode == "train":
y_pred = make_predictions(model, X_val)
evaluate(y_val, y_pred, l_e, config.dataset, config.CLASS_TYPE,
'output')
print_runtime("Finish Prediction Validation Set",
round(time.time() - start_time, 2))
elif config.run_mode == "test":
y_pred_test = make_predictions(model, X_test)
evaluate(y_test, y_pred_test, l_e, config.dataset,
config.CLASS_TYPE, 'output_test')
print_runtime("Finish Prediction Testing Set",
round(time.time() - start_time, 2))
elif config.dataset == "CBIS-DDSM":
if config.run_mode == "train":
y_pred = make_predictions(model, dataset_val)
evaluate(y_val, y_pred, l_e, config.dataset, config.CLASS_TYPE,
'output')
print_runtime("Finish Prediction Validation Set",
round(time.time() - start_time, 2))
elif config.run_mode == "test":
y_pred_test = make_predictions(model, dataset_test)
evaluate(y_test, y_pred_test, l_e, config.dataset,
config.CLASS_TYPE, 'output_test')
print_runtime("Finish Prediction Testing Set",
round(time.time() - start_time, 2))
# Print the prediction
# print(y_pred)
# Print training runtime.
print_runtime("Total", round(time.time() - start_time, 2))
def main() -> None:
"""
Program entry point. Parses command line arguments to decide which dataset and model to use.
:return: None.
"""
parse_command_line_arguments()
print_num_gpus_available()
# Start recording time.
start_time = time.time()
images, image_masks = import_cbisddsm_segmentation_training_dataset()
# Split training dataset into training/validation sets (75%/25% split).
X_train, X_val, y_train, y_val = train_test_split(images,
image_masks,
test_size=0.25,
random_state=config.RANDOM_SEED,
shuffle=True)
dataset_train = create_dataset_masks(X_train, y_train)
dataset_val = create_dataset_masks(X_val, y_val)
# # image_ex, mask_ex = parse_function_segmentation_test(X_train[0], y_train[0])
# print(y_train[0])
# image_bytes_mask = tf.io.read_file(y_train[0])
# image_mask = tfio.image.decode_dicom_image(image_bytes_mask, color_dim = True, dtype=tf.uint16)
# image_mask = tf.image.resize_with_pad(image_mask, config.VGG_IMG_SIZE['HEIGHT'], config.VGG_IMG_SIZE['WIDTH'])
# array = np.array(image_mask)
# print(array.shape)
# print(array[0,:,:,0].shape)
# array = array[0,:,:,0]
# image_bytes = tf.io.read_file(X_train[0])
# image = tfio.image.decode_dicom_image(image_bytes, color_dim = True, dtype=tf.uint16)
# image = tf.image.resize_with_pad(image, config.VGG_IMG_SIZE['HEIGHT'], config.VGG_IMG_SIZE['WIDTH'])
# image /= 255
# image = image[0]
# array_2 = np.array(image)
# print(array_2.shape)
# print(array_2[0,:,:,0].shape)
# array_2 = array_2[0,:,:,0]
# fig,ax = plt.subplots(2, figsize=[15,15])
# ax[0].imshow(array_2)
# ax[1].imshow(array)
# plt.savefig('../output/plot_images_examples.png')
# exit()
# Run in training mode.
if config.run_mode == "train":
# Create and train CNN model.
model = u_net_model(input_height = config.VGG_IMG_SIZE['HEIGHT'], input_width = config.VGG_IMG_SIZE['WIDTH'])
model = train_segmentation_network(model, dataset_train, dataset_val, config.EPOCH_1,
config.EPOCH_2)
# Save the model
model.save("../saved_models/segmentation_model-{}_imagesize-{}x{}_filtered_{}.h5".format(config.segmodel, str(config.VGG_IMG_SIZE['HEIGHT']), str(config.VGG_IMG_SIZE['WIDTH']), config.prep))
elif config.run_mode == "test":
model = load_model("../saved_models/segmentation_model-{}_imagesize-{}x{}_filtered_{}.h5".format(config.segmodel, str(config.VGG_IMG_SIZE['HEIGHT']), str(config.VGG_IMG_SIZE['WIDTH']), config.prep), compile=False)
# Evaluate model results.
y_pred = make_predictions(model, dataset_val)
evaluate_segmentation(y_val, y_pred)
visualise_examples(X_val, y_val, y_pred)
# Print training runtime.
print_runtime("Total", round(time.time() - start_time, 2))
def main() -> None:
"""
Program entry point. Parses command line arguments to decide which dataset and model to use.
:return: None.
"""
parse_command_line_arguments()
print_num_gpus_available()
# Start recording time.
start_time = time.time()
# Create label encoder.
l_e = create_label_encoder()
# Run in training mode.
if config.run_mode == "train":
# Multiclass classification (mini-MIAS dataset)
if config.dataset == "mini-MIAS":
# Import entire dataset.
images, labels = import_minimias_dataset(
data_dir="../data/{}/images_processed".format(config.dataset),
label_encoder=l_e)
# Split dataset into training/test/validation sets (60%/20%/20% split).
X_train, X_test, y_train, y_test = dataset_stratified_split(
split=0.20, dataset=images, labels=labels)
X_train_rebalanced, y_train_rebalanced = generate_image_transforms(
X_train, y_train)
X_train, X_val, y_train, y_val = dataset_stratified_split(
split=0.25,
dataset=X_train_rebalanced,
labels=y_train_rebalanced)
# Create and train CNN model.
model = generate_vgg_model(l_e.classes_.size)
model = train_network(model, X_train, y_train, X_val, y_val,
config.BATCH_SIZE, config.EPOCH_1,
config.EPOCH_2)
# Binary classification (CBIS-DDSM dataset).
elif config.dataset == "CBIS-DDSM":
images, labels = import_cbisddsm_training_dataset(l_e)
# Split training dataset into training/validation sets (75%/25% split).
X_train, X_val, y_train, y_val = dataset_stratified_split(
split=0.25, dataset=images, labels=labels)
dataset_train = create_dataset(X_train, y_train)
dataset_val = create_dataset(X_val, y_val)
# Create and train CNN model.
if config.imagesize == "small":
model = generate_vgg_model(l_e.classes_.size)
else:
model = generate_vgg_model_large(l_e.classes_.size)
model = train_network(model, dataset_train, None, dataset_val,
None, config.BATCH_SIZE, config.EPOCH_1,
config.EPOCH_2)
else:
print_error_message()
# Save the model
model.save(
"../saved_models/dataset-{}_model-{}_imagesize-{}.h5".format(
config.dataset, config.model, config.imagesize))
print_runtime("Total training time ", round(time.time() - start_time,
2))
# Evaluate model results.
if config.dataset == "mini-MIAS":
y_pred = make_predictions(model, X_val)
evaluate(y_val, y_pred, l_e, config.dataset, 'N-B-M')
elif config.dataset == "CBIS-DDSM":
y_pred = make_predictions(model, dataset_val)
evaluate(y_val, y_pred, l_e, config.dataset, 'B-M')
elif config.run_mode == "test":
model = load_model(
"../saved_models/classification/classification_basic_small.h5")
images, labels = import_cbisddsm_testing_dataset(l_e)
dataset_test = create_dataset(images, labels)
testing_start_time = time.time()
y_pred = make_predictions(model, dataset_test)
print_runtime("Total testing time ",
round(time.time() - testing_start_time, 2))
evaluate(labels, y_pred, l_e, config.dataset, 'B-M')