def run(parameters):
"""
Outputs the predictions as csv file
"""
random_number_generator = np.random.RandomState(parameters["seed"])
model, device = load_model(parameters)
model_input = load_inputs(
image_path=parameters["cropped_mammogram_path"],
metadata_path=parameters["metadata_path"],
use_heatmaps=parameters["use_heatmaps"],
benign_heatmap_path=parameters["heatmap_path_benign"],
malignant_heatmap_path=parameters["heatmap_path_malignant"],
)
assert model_input.metadata["full_view"] == parameters["view"]
all_predictions = []
# set up hook
activation = {'out_resnet': []}
# out_shape = [0,256]
# activation = {'out_resnet': torch.empty(out_shape)}
handle = model.all_views_avg_pool.register_forward_hook(
tools.get_activation(activation, 'out_resnet'))
# handle = model.view_resnet.layer_list[4][1].conv2.register_forward_hook(tools.get_activation(activation, 'out_resnet'))
for datum in tqdm.tqdm(exam_list):
for short_file_path in datum[view]:
loaded_image = loading.load_image(
image_path=os.path.join(parameters["image_path"],
short_file_path + image_extension),
view=view,
horizontal_flip=datum["horizontal_flip"],
)
loaded_image_dict[view].append(loaded_image)
for data_batch in tools.partition_batch(range(parameters["num_epochs"]),
parameters["batch_size"]):
batch = []
for _ in data_batch:
batch.append(
process_augment_inputs(
model_input=model_input,
random_number_generator=random_number_generator,
parameters=parameters,
))
tensor_batch = batch_to_tensor(batch, device)
y_hat = model(tensor_batch)
predictions = np.exp(y_hat.cpu().detach().numpy())[:, :2, 1]
all_predictions.append(predictions)
agg_predictions = np.concatenate(all_predictions, axis=0).mean(0)
predictions_dict = {
"benign": float(agg_predictions[0]),
"malignant": float(agg_predictions[1]),
}
print(json.dumps(predictions_dict))
def get_all_prob(all_patches, minibatch_size, model, device, parameters):
"""
Gets predictions for all sampled patches
"""
all_prob = np.zeros((len(all_patches), parameters['number_of_classes']))
for i, minibatch in enumerate(tools.partition_batch(all_patches, minibatch_size)):
minibatch_prob = prediction_by_batch(minibatch, model, device, parameters)
all_prob[i * minibatch_size: i * minibatch_size + minibatch_prob.shape[0]] = minibatch_prob
return all_prob.astype(np.float32)
def run(parameters):
"""
Outputs the predictions as csv file
"""
random_number_generator = np.random.RandomState(parameters["seed"])
model, device = load_model(parameters)
model_input = load_inputs(
image_path=parameters["cropped_mammogram_path"],
metadata_path=parameters["metadata_path"],
use_heatmaps=parameters["use_heatmaps"],
benign_heatmap_path=parameters["heatmap_path_benign"],
malignant_heatmap_path=parameters["heatmap_path_malignant"],
)
assert model_input.metadata["full_view"] == parameters["view"]
all_predictions = []
for data_batch in tools.partition_batch(range(parameters["num_epochs"]),
parameters["batch_size"]):
batch = []
for _ in data_batch:
batch.append(
process_augment_inputs(
model_input=model_input,
random_number_generator=random_number_generator,
parameters=parameters,
))
tensor_batch = batch_to_tensor(batch, device)
with torch.no_grad():
y_hat = model(tensor_batch)
predictions = np.exp(y_hat.cpu().detach().numpy())[:, :2, 1]
all_predictions.append(predictions)
agg_predictions = np.concatenate(all_predictions, axis=0).mean(0)
predictions_dict = {
"benign": float(agg_predictions[0]),
"malignant": float(agg_predictions[1]),
}
print(json.dumps(predictions_dict))
return json.dumps(predictions_dict)
def run(parameters):
"""
Outputs the predictions as csv file
"""
random_number_generator = np.random.RandomState(parameters["seed"])
sess, x, y = load_model(parameters)
model_input = load_inputs(
image_path=parameters["cropped_mammogram_path"],
metadata_path=parameters["metadata_path"],
use_heatmaps=parameters["use_heatmaps"],
benign_heatmap_path=parameters["heatmap_path_benign"],
malignant_heatmap_path=parameters["heatmap_path_malignant"],
)
assert model_input.metadata["full_view"] == parameters["view"]
all_predictions = []
for data_batch in tools.partition_batch(range(parameters["num_epochs"]),
parameters["batch_size"]):
batch = []
for _ in data_batch:
batch.append(
process_augment_inputs(
model_input=model_input,
random_number_generator=random_number_generator,
parameters=parameters,
))
x_data = batch_to_inputs(batch)
with sess.as_default():
y_hat = sess.run(y, feed_dict={x: x_data})
predictions = np.exp(y_hat)[:, :, 1]
all_predictions.append(predictions)
agg_predictions = np.concatenate(all_predictions, axis=0).mean(0)
predictions_dict = {
"benign": float(agg_predictions[0]),
"malignant": float(agg_predictions[1]),
}
print(json.dumps(predictions_dict))
def run_model(model, device, exam_list, parameters):
"""
Returns predictions of image only model or image+heatmaps model.
Prediction for each exam is averaged for a given number of epochs.
"""
random_number_generator = np.random.RandomState(parameters["seed"])
image_extension = ".hdf5" if parameters["use_hdf5"] else ".png"
with torch.no_grad():
predictions_ls = []
for datum in tqdm.tqdm(exam_list):
predictions_for_datum = []
loaded_image_dict = {view: [] for view in VIEWS.LIST}
loaded_heatmaps_dict = {view: [] for view in VIEWS.LIST}
for view in VIEWS.LIST:
for short_file_path in datum[view]:
loaded_image = loading.load_image(
image_path=os.path.join(
parameters["image_path"],
short_file_path + image_extension),
view=view,
horizontal_flip=datum["horizontal_flip"],
)
if parameters["use_heatmaps"]:
loaded_heatmaps = loading.load_heatmaps(
benign_heatmap_path=os.path.join(
parameters["heatmaps_path"], "heatmap_benign",
short_file_path + ".hdf5"),
malignant_heatmap_path=os.path.join(
parameters["heatmaps_path"],
"heatmap_malignant",
short_file_path + ".hdf5"),
view=view,
horizontal_flip=datum["horizontal_flip"],
)
else:
loaded_heatmaps = None
loaded_image_dict[view].append(loaded_image)
loaded_heatmaps_dict[view].append(loaded_heatmaps)
for data_batch in tools.partition_batch(
range(parameters["num_epochs"]), parameters["batch_size"]):
batch_dict = {view: [] for view in VIEWS.LIST}
for _ in data_batch:
for view in VIEWS.LIST:
image_index = 0
if parameters["augmentation"]:
image_index = random_number_generator.randint(
low=0, high=len(datum[view]))
cropped_image, cropped_heatmaps = loading.augment_and_normalize_image(
image=loaded_image_dict[view][image_index],
auxiliary_image=loaded_heatmaps_dict[view]
[image_index],
view=view,
best_center=datum["best_center"][view]
[image_index],
random_number_generator=random_number_generator,
augmentation=parameters["augmentation"],
max_crop_noise=parameters["max_crop_noise"],
max_crop_size_noise=parameters[
"max_crop_size_noise"],
)
if loaded_heatmaps_dict[view][image_index] is None:
batch_dict[view].append(cropped_image[:, :,
np.newaxis])
else:
batch_dict[view].append(
np.concatenate([
cropped_image[:, :, np.newaxis],
cropped_heatmaps,
],
axis=2))
tensor_batch = {
view: torch.tensor(np.stack(batch_dict[view])).permute(
0, 3, 1, 2).to(device)
for view in VIEWS.LIST
}
output = model(tensor_batch)
batch_predictions = compute_batch_predictions(
output, mode=parameters["model_mode"])
pred_df = pd.DataFrame(
{k: v[:, 1]
for k, v in batch_predictions.items()})
pred_df.columns.names = ["label", "view_angle"]
predictions = pred_df.T.reset_index().groupby(
"label").mean().T[LABELS.LIST].values
predictions_for_datum.append(predictions)
predictions_ls.append(
np.mean(np.concatenate(predictions_for_datum, axis=0), axis=0))
return np.array(predictions_ls)
def run_sub_model(model, exam_list, parameters):
"""
Returns predictions of image only model or image+heatmaps model.
Prediction for each exam is averaged for a given number of epochs.
"""
if (parameters["device_type"] == "gpu") and torch.has_cudnn:
device = torch.device(f"cuda:{parameters["gpu_number"]}")
else:
device = torch.device("cpu")
sub_model = sub_model.to(device)
# F: sets model in evaluation mode. It has an effect in certain modules: e.g. Dropout or BatchNorm Layers
sub_model.eval()
random_number_generator = np.random.RandomState(parameters["seed"])
image_extension = ".hdf5" if parameters["use_hdf5"] else ".png"
with torch.no_grad():
predictions_ls = []
for datum in tqdm.tqdm(exam_list):
predictions_for_datum = []
loaded_image_dict = {view: [] for view in VIEWS.LIST}
loaded_heatmaps_dict = {view: [] for view in VIEWS.LIST}
for view in VIEWS.LIST:
# F: for one exam, all images of a specific view
for short_file_path in datum[view]:
loaded_image = loading.load_image(
image_path=os.path.join(parameters["image_path"], short_file_path + image_extension),
view=view,
horizontal_flip=datum["horizontal_flip"],
)
loaded_image_dict[view].append(loaded_image)
print(f"length loaded_image: {len(loaded_image_dict)}")
for data_batch in tools.partition_batch(range(parameters["num_epochs"]), parameters["batch_size"]):
print(f"num_epochs: {parameters['num_epochs']}")
print(f"batch_size: {parameters['batch_size']}")
tmp = tools.partition_batch(range(parameters["num_epochs"]), parameters["batch_size"])
print(f"partition_batch: {tmp}")
batch_dict = {view: [] for view in VIEWS.LIST}
for _ in data_batch:
for view in VIEWS.LIST:
image_index = 0
# F: they use different augmentation for each view
if parameters["augmentation"]:
image_index = random_number_generator.randint(low=0, high=len(datum[view]))
cropped_image, cropped_heatmaps = loading.augment_and_normalize_image(
image=loaded_image_dict[view][image_index],
auxiliary_image=loaded_heatmaps_dict[view][image_index],
view=view,
best_center=datum["best_center"][view][image_index],
random_number_generator=random_number_generator,
augmentation=parameters["augmentation"],
max_crop_noise=parameters["max_crop_noise"],
max_crop_size_noise=parameters["max_crop_size_noise"],
)
# print(f"cropped_image: {image_index} of m in minibatch: {_} size: {cropped_image.shape}")
else:
# F: e.g. batch_dict[view][:,:,1] is the first heatmap
batch_dict[view].append(np.concatenate([
cropped_image[:, :, np.newaxis],
cropped_heatmaps,
], axis=2))
# print(f"batch_dict_view: {len(batch_dict[view])}")
# print(f"batch_img_size: {batch_dict[view][_].shape}")
tensor_batch = {
# F: result of np.stack has one more dimension:
# F: 4 dimensions: batch_data_i, y_pixels, x_pixels, channels
view: torch.tensor(np.stack(batch_dict[view])).permute(0, 3, 1, 2).to(device)
for view in VIEWS.LIST
}
# print(f"layer_names: {model.state_dict().keys()}")
# Print model's state_dict
output = model(tensor_batch)
batch_predictions = compute_batch_predictions(output)
print(f"batch_predictions: \n {batch_predictions}")
print(len(batch_predictions.keys()))
# F: they pick value 1, disregarding value 0 which is the complement of that (prob = 1)
pred_df = pd.DataFrame({k: v[:, 1] for k, v in batch_predictions.items()})
pred_df.columns.names = ["label", "view_angle"]
# print(f"pred_df.head: {pred_df.head()}")
# F: complicated way of grouping by label and calculating the mean
predictions = pred_df.T.reset_index().groupby("label").mean().T[LABELS.LIST].values
predictions_for_datum.append(predictions)
print(f"predictions: {predictions}")
exit()
predictions_ls.append(np.mean(np.concatenate(predictions_for_datum, axis=0), axis=0))
def run_model(model, device, exam_list, parameters):
"""
Returns predictions of image only model or image+heatmaps model.
Prediction for each exam is averaged for a given number of epochs.
"""
random_number_generator = np.random.RandomState(parameters["seed"])
image_extension = ".hdf5" if parameters["use_hdf5"] else ".png"
with torch.no_grad():
predictions_ls = []
for datum in tqdm.tqdm(exam_list):
predictions_for_datum = []
# F: VIEWS is an adhoc class
# F: VIEWS.LIST : list of views as string
loaded_image_dict = {view: [] for view in VIEWS.LIST}
loaded_heatmaps_dict = {view: [] for view in VIEWS.LIST}
for view in VIEWS.LIST:
# F: for one exam, all images of a specific view
for short_file_path in datum[view]:
loaded_image = loading.load_image(
image_path=os.path.join(
parameters["image_path"],
short_file_path + image_extension),
view=view,
horizontal_flip=datum["horizontal_flip"],
)
if parameters["use_heatmaps"]:
loaded_heatmaps = loading.load_heatmaps(
benign_heatmap_path=os.path.join(
parameters["heatmaps_path"], "heatmap_benign",
short_file_path + ".hdf5"),
malignant_heatmap_path=os.path.join(
parameters["heatmaps_path"],
"heatmap_malignant",
short_file_path + ".hdf5"),
view=view,
horizontal_flip=datum["horizontal_flip"],
)
else:
loaded_heatmaps = None
loaded_image_dict[view].append(loaded_image)
loaded_heatmaps_dict[view].append(loaded_heatmaps)
# print(f"length loaded_image: {len(loaded_image_dict)}")
for data_batch in tools.partition_batch(
range(parameters["num_epochs"]), parameters["batch_size"]):
# print(f"num_epochs: {parameters['num_epochs']}")
# print(f"batch_size: {parameters['batch_size']}")
tmp = tools.partition_batch(range(parameters["num_epochs"]),
parameters["batch_size"])
# print(f"partition_batch: {tmp}")
batch_dict = {view: [] for view in VIEWS.LIST}
for _ in data_batch:
for view in VIEWS.LIST:
image_index = 0
# F: they use different augmentation for each view
if parameters["augmentation"]:
image_index = random_number_generator.randint(
low=0, high=len(datum[view]))
cropped_image, cropped_heatmaps = loading.augment_and_normalize_image(
image=loaded_image_dict[view][image_index],
auxiliary_image=loaded_heatmaps_dict[view]
[image_index],
view=view,
best_center=datum["best_center"][view]
[image_index],
random_number_generator=random_number_generator,
augmentation=parameters["augmentation"],
max_crop_noise=parameters["max_crop_noise"],
max_crop_size_noise=parameters[
"max_crop_size_noise"],
)
# print(f"cropped_image: {image_index} of m in minibatch: {_} size: {cropped_image.shape}")
if loaded_heatmaps_dict[view][image_index] is None:
batch_dict[view].append(cropped_image[:, :,
np.newaxis])
# F: e.g. batch_dict[view][_].shape = (2974, 1748, 1)
else:
# F: e.g. batch_dict[view][:,:,1] is the first heatmap
batch_dict[view].append(
np.concatenate([
cropped_image[:, :, np.newaxis],
cropped_heatmaps,
],
axis=2))
# print(f"batch_dict_view: {len(batch_dict[view])}")
# print(f"batch_img_size: {batch_dict[view][_].shape}")
tensor_batch = {
# F: result of np.stack has one more dimension:
# F: 4 dimensions: batch_data_i, y_pixels, x_pixels, channels
view: torch.tensor(np.stack(batch_dict[view])).permute(
0, 3, 1, 2).to(device)
for view in VIEWS.LIST
}
# print(f"layer_names: {model.state_dict().keys()}")
# Print model's state_dict
# print("Model's state_dict:")
# for param_tensor in model.state_dict():
# print(param_tensor, "\t", model.state_dict()[param_tensor].size())
output = model(tensor_batch)
batch_predictions = compute_batch_predictions(
output, mode=parameters["model_mode"])
# print(f"batch_predictions: \n {batch_predictions}")
# print(len(batch_predictions.keys()))
# F: they pick value 1, disregarding value 0 which is the complement of that (prob = 1)
pred_df = pd.DataFrame(
{k: v[:, 1]
for k, v in batch_predictions.items()})
pred_df.columns.names = ["label", "view_angle"]
# print(f"pred_df.head: {pred_df.head()}")
# F: complicated way of grouping by label and calculating the mean
predictions = pred_df.T.reset_index().groupby(
"label").mean().T[LABELS.LIST].values
predictions_for_datum.append(predictions)
# print(f"predictions: {predictions}")
predictions_ls.append(
np.mean(np.concatenate(predictions_for_datum, axis=0), axis=0))
return np.array(predictions_ls)
