def __init__(
self, x_set, y_set, parameters
): # x_set = path to exam_list_cropped, y_set= path to xls file
# INPUT
val_split = parameters["validation_split"] # split rate
train_split = 1 - val_split
total_patients = len(pickling.unpickle_from_file(x_set))
number_patients_for_training = int((total_patients) * (train_split))
if parameters["training"] == True: # if doing the validation split
x_set = pickling.unpickle_from_file(
x_set
)[:
number_patients_for_training] # list of dictionaries from exam_list_cropped.pkl
else:
x_set = pickling.unpickle_from_file(
x_set)[number_patients_for_training:]
y_set = get_output_dict(
xls_path=y_set,
images_path=parameters["image_path"]) # get output dict
self.random_number_generator = np.random.RandomState(
parameters["seed"])
self.x, self.y = x_set, y_set
self.batch_size = parameters['batch_size']
self.parameters = parameters
def load_inputs(image_path,
metadata_path,
use_heatmaps,
benign_heatmap_path=None,
malignant_heatmap_path=None):
"""
Load a single input example, optionally with heatmaps
"""
if use_heatmaps:
assert benign_heatmap_path is not None
assert malignant_heatmap_path is not None
else:
assert benign_heatmap_path is None
assert malignant_heatmap_path is None
metadata = pickling.unpickle_from_file(metadata_path)
image = loading.load_image(
image_path=image_path,
view=metadata["full_view"],
horizontal_flip=metadata["horizontal_flip"],
)
if use_heatmaps:
heatmaps = loading.load_heatmaps(
benign_heatmap_path=benign_heatmap_path,
malignant_heatmap_path=malignant_heatmap_path,
view=metadata["full_view"],
horizontal_flip=metadata["horizontal_flip"],
)
else:
heatmaps = None
return ModelInput(image=image, heatmaps=heatmaps, metadata=metadata)
def __init__(self, data_dir, file_data_list,
data_list_index=0, channels=3, randomly_select_image_from_exam=False,
reject_unknowns=True, before_first_adverse_event_only=True, include_post_inh_admission_cases=False, labels_in_pkl_loader=[], transform=None, multiclass=False):
"""
Args:
data_dir: path to image directory.
image_list_file: path to the file containing images
with corresponding labels.
transform: optional transform to be applied on a sample.
"""
self.channels = channels
data_list = list(unpickle_from_file(file_data_list)[data_list_index])
exam_list_per_patient = get_exams(data_list, reject_unknowns, before_first_adverse_event_only, include_post_inh_admission_cases)
self.flattened_exam_list, self.patient_to_exam_indices_dict = flatten_exams_list(exam_list_per_patient)
self.data_dir = data_dir
self.randomly_select_image_from_exam = randomly_select_image_from_exam
if multiclass:
assert labels_in_pkl_loader == ['label_24', 'label_48', 'label_72','label_96']
self.labels_in_pkl_loader = labels_in_pkl_loader
self.labels = []
for exam in self.flattened_exam_list:
if multiclass:
vectorized_label = self.map_to_multicls(exam['label'])
else:
vectorized_label = self.vectorize_label(exam['label'])
self.labels.append(vectorized_label)
self.transform = transform
def produce_heatmaps(model, device, parameters):
"""
Generates heatmaps for all exams
"""
# Load exam info
exam_list = pickling.unpickle_from_file(parameters['data_file'])
# Create heatmaps
making_heatmap_with_large_minibatch_potential(parameters, model, exam_list, device)
def get_optimal_center_single(cropped_mammogram_path, metadata_path):
"""
Get optimal center for single example
"""
metadata = pickling.unpickle_from_file(metadata_path)
image = reading_images.read_image_png(cropped_mammogram_path)
optimal_center = get_optimal_centers.extract_center(metadata, image)
metadata["best_center"] = optimal_center
pickling.pickle_to_file(metadata_path, metadata)
def convert_output_results(input_data_folder, heatmaps_path,
data_path, output_data_folder):
exam_list = pickling.unpickle_from_file(data_path)
os.makedirs(os.path.dirname(output_data_folder), exist_ok=True)
dcm_files = glob.glob(os.path.join(input_data_folder,"**","*.dcm"), recursive=True)
image_extension = ".png"
for datum in tqdm.tqdm(exam_list):
loaded_heatmaps_dict = {view: [] for view in VIEWS.LIST}
for view in VIEWS.LIST:
for short_file_path in datum[view]:
loaded_heatmaps = loading.load_heatmaps(
benign_heatmap_path=os.path.join(heatmaps_path, "heatmap_benign",
short_file_path + image_extension),
malignant_heatmap_path=os.path.join(heatmaps_path, "heatmap_malignant",
short_file_path + image_extension),
view=view,
horizontal_flip=datum["horizontal_flip"],
)
loaded_heatmaps_dict[view].append(loaded_heatmaps)
loaded_heatmaps = np.stack([loaded_heatmaps[:,:,1:2],
loaded_heatmaps[:,:,0:1],
np.zeros(loaded_heatmaps[:,:,1:2].shape)],
axis=2)[:,:,:,0].astype(np.uint8)
laterality = view.split("-")[0]
projection_view = view.split("-")[1]
dcm_file = find_view(dcm_files, laterality, projection_view)
ds = pydicom.read_file(dcm_file)
pixel_array = ds.pixel_array
pixel_array = (pixel_array - np.min(pixel_array)) / float(np.max(pixel_array) - np.min(pixel_array)) * 255
pixel_array = np.expand_dims(pixel_array.astype(np.uint8), axis=2)
pixel_array = np.stack([pixel_array, pixel_array, pixel_array], axis=2)[:,:,:,0]
coords = datum["window_location"][view][0]
if laterality == "R":
loaded_heatmaps = np.fliplr(loaded_heatmaps)
sub_pixel_array = pixel_array[coords[0]:coords[1],coords[2]:coords[3],0:3]
bg = Image.fromarray(sub_pixel_array)
fg = Image.fromarray(loaded_heatmaps)
blended = Image.blend(bg, fg, 0.25)
pixel_array[coords[0]:coords[1],coords[2]:coords[3],0:3] = np.asarray(blended)
sc_image = SCImage()
sc_image.create_empty_iod()
sc_image.initiate()
sc_image.set_dicom_attribute("PatientName", ds.PatientName)
sc_image.set_dicom_attribute("PatientID", ds.PatientID)
sc_image.set_dicom_attribute("AccessionNumber", ds.AccessionNumber)
sc_image.set_dicom_attribute("StudyID", ds.StudyID)
sc_image.set_dicom_attribute("StudyInstanceUID", ds.StudyInstanceUID)
sc_image.set_dicom_attribute("StudyDate", ds.StudyDate if "StudyDate" in ds else "")
sc_image.set_dicom_attribute("StudyTime", ds.StudyTime if "StudyTime" in ds else "")
sc_image.set_dicom_attribute("StudyDescription", ds.StudyTime if "StudyDescription" in ds else "")
sc_image.set_dicom_attribute("SeriesDescription", f"Original {view} + heatmap")
# sc_image.add_pixel_data(loaded_heatmaps)
sc_image.add_pixel_data(pixel_array)
output_file = os.path.join(output_data_folder, "SC_" + view + ".dcm")
sc_image.write_to_file(output_file)
def produce_heatmaps(parameters):
"""
Generate heatmaps for single example
"""
random.seed(parameters['seed'])
image_path = parameters["cropped_mammogram_path"]
model, device = run_producer.load_model(parameters)
metadata = pickling.unpickle_from_file(parameters['metadata_path'])
patches, case = run_producer.sample_patches_single(
image_path=image_path,
view=metadata["view"],
horizontal_flip=metadata['horizontal_flip'],
parameters=parameters,
)
all_prob = run_producer.get_all_prob(
all_patches=patches,
minibatch_size=parameters["minibatch_size"],
model=model,
device=device,
parameters=parameters)
heatmap_malignant, _ = run_producer.probabilities_to_heatmap(
patch_counter=0,
all_prob=all_prob,
image_shape=case[0],
length_stride_list=case[4],
width_stride_list=case[3],
patch_size=parameters['patch_size'],
heatmap_type=parameters['heatmap_type'][0],
)
heatmap_benign, patch_counter = run_producer.probabilities_to_heatmap(
patch_counter=0,
all_prob=all_prob,
image_shape=case[0],
length_stride_list=case[4],
width_stride_list=case[3],
patch_size=parameters['patch_size'],
heatmap_type=parameters['heatmap_type'][1],
)
heatmap_malignant = loading.flip_image(
image=heatmap_malignant,
view=metadata["view"],
horizontal_flip=metadata["horizontal_flip"],
)
heatmap_benign = loading.flip_image(
image=heatmap_benign,
view=metadata["view"],
horizontal_flip=metadata["horizontal_flip"],
)
saving_images.save_image_as_hdf5(
image=heatmap_malignant,
filename=parameters["heatmap_path_malignant"],
)
saving_images.save_image_as_hdf5(
image=heatmap_benign,
filename=parameters["heatmap_path_benign"],
)
def load_run_save(data_path, output_path, parameters):
"""
Outputs the predictions as csv file
"""
exam_list = pickling.unpickle_from_file(data_path)
model, device = load_model(parameters)
predictions = run_model(model, device, exam_list, parameters)
os.makedirs(os.path.dirname(output_path), exist_ok=True)
# Take the positive prediction
df = pd.DataFrame(predictions, columns=LABELS.LIST)
df.to_csv(output_path, index=False, float_format='%.4f')
def main(cropped_exam_list_path, data_prefix, output_exam_list_path, num_processes=1):
exam_list = pickling.unpickle_from_file(cropped_exam_list_path)
data_list = data_handling.unpack_exam_into_images(exam_list, cropped=True)
optimal_centers = get_optimal_centers(
data_list=data_list,
data_prefix=data_prefix,
num_processes=num_processes
)
data_handling.add_metadata(exam_list, "best_center", optimal_centers)
os.makedirs(os.path.dirname(output_exam_list_path), exist_ok=True)
pickling.pickle_to_file(output_exam_list_path, exam_list)
def load_run_save(model_path, data_path, output_path, parameters):
"""
Outputs the predictions as csv file
"""
input_channels = 3 if parameters["use_heatmaps"] else 1
model = models.SplitBreastModel(input_channels)
model.load_state_dict(torch.load(model_path)["model"])
exam_list = pickling.unpickle_from_file(data_path)
predictions = run_model(model, exam_list, parameters)
os.makedirs(os.path.dirname(output_path), exist_ok=True)
# Take the positive prediction
df = pd.DataFrame(predictions, columns=LABELS.LIST)
df.to_csv(output_path, index=False, float_format='%.4f')
def crop_mammogram(input_data_folder, exam_list_path, cropped_exam_list_path,
output_data_folder, num_processes, num_iterations,
buffer_size):
"""
In parallel, crops mammograms in DICOM format found in input_data_folder and save as png format in
output_data_folder and saves new image list in cropped_image_list_path
"""
# list of exams (one dictionary per exam)
exam_list = pickling.unpickle_from_file(exam_list_path)
# list per image (one dictionary per image). It contains same information than in list of exams + cropped information if present.
image_list = data_handling.unpack_exam_into_images(exam_list)
if os.path.exists(output_data_folder):
# Prevent overwriting to an existing directory
print("Error: the directory to save cropped images already exists.")
return
else:
os.makedirs(output_data_folder)
crop_mammogram_one_image_func = partial(
crop_mammogram_one_image_short_path,
input_data_folder=input_data_folder,
output_data_folder=output_data_folder,
num_iterations=num_iterations,
buffer_size=buffer_size,
)
with Pool(num_processes) as pool:
cropped_image_info = pool.map(crop_mammogram_one_image_func,
image_list)
# F: cropped image info returns a list. Each entry is the return of a single execution
# F: of crop_mammogram_one_image_func.
# F: each dict defined contains the information of all images
window_location_dict = dict([x[0] for x in cropped_image_info])
rightmost_points_dict = dict([x[1] for x in cropped_image_info])
bottommost_points_dict = dict([x[2] for x in cropped_image_info])
distance_from_starting_side_dict = dict([x[3] for x in cropped_image_info])
data_handling.add_metadata(exam_list, "window_location",
window_location_dict)
data_handling.add_metadata(exam_list, "rightmost_points",
rightmost_points_dict)
data_handling.add_metadata(exam_list, "bottommost_points",
bottommost_points_dict)
data_handling.add_metadata(exam_list, "distance_from_starting_side",
distance_from_starting_side_dict)
pickling.pickle_to_file(cropped_exam_list_path, exam_list)
def crop_mammogram(input_data_folder, exam_list_path,
cropped_exam_list_path, output_data_folder,
num_processes, num_iterations, buffer_size):
"""
In parallel, crops mammograms in DICOM format found in input_data_folder and save as png format in
output_data_folder and saves new image list in cropped_image_list_path
"""
exam_list = pickling.unpickle_from_file(exam_list_path)
image_list = data_handling.unpack_exam_into_images(exam_list)
if os.path.exists(output_data_folder):
# Prevent overwriting to an existing directory
print(
"Error: the directory to save cropped images already exists."
)
return
else:
os.makedirs(output_data_folder)
#global crop_mammogram_one_image_func
crop_mammogram_one_image_func = partial(
crop_mammogram_one_image_short_path,
input_data_folder=input_data_folder,
output_data_folder=output_data_folder,
num_iterations=num_iterations,
buffer_size=buffer_size,
)
with Pool(num_processes) as pool:
cropped_image_info = pool.map(
crop_mammogram_one_image_func, image_list)
window_location_dict = dict([x[0] for x in cropped_image_info])
rightmost_points_dict = dict(
[x[1] for x in cropped_image_info])
bottommost_points_dict = dict(
[x[2] for x in cropped_image_info])
distance_from_starting_side_dict = dict(
[x[3] for x in cropped_image_info])
data_handling.add_metadata(exam_list, "window_location",
window_location_dict)
data_handling.add_metadata(exam_list, "rightmost_points",
rightmost_points_dict)
data_handling.add_metadata(exam_list, "bottommost_points",
bottommost_points_dict)
data_handling.add_metadata(exam_list,
"distance_from_starting_side",
distance_from_starting_side_dict)
pickling.pickle_to_file(cropped_exam_list_path, exam_list)
def crop_mammogram():
id_patient = request.args.get('id')
input_data_folder = 'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/sample_data/' + id_patient
# exam_list_path='C:/Users/ultra/PycharmProjects/breast_cancer_classifier/sample_data/exam_list_before_cropping.pkl'
exam_list_path = 'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/sample_data/filename.pkl'
cropped_exam_list_path = 'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/cropping/sample_output/' + id_patient + '/' + id_patient + '.pkl'
output_data_folder = 'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/cropping/sample_output/' + id_patient
num_processes = 10
num_iterations = 100
buffer_size = 50
exam_list = pickling.unpickle_from_file(exam_list_path)
image_list = data_handling.unpack_exam_into_images(exam_list)
if os.path.exists(output_data_folder):
# Prevent overwriting to an existing directory
print("Error: the directory to save cropped images already exists.")
sh.rmtree(
'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/cropping/sample_output/cropped_images'
)
os.makedirs(output_data_folder)
crop_mammogram_one_image_func = partial(
crop_mammogram_one_image,
input_data_folder=input_data_folder,
output_data_folder=output_data_folder,
num_iterations=num_iterations,
buffer_size=buffer_size,
)
with Pool(num_processes) as pool:
cropped_image_info = pool.map(crop_mammogram_one_image_func,
image_list)
window_location_dict = dict([x[0] for x in cropped_image_info])
rightmost_points_dict = dict([x[1] for x in cropped_image_info])
bottommost_points_dict = dict([x[2] for x in cropped_image_info])
distance_from_starting_side_dict = dict([x[3] for x in cropped_image_info])
data_handling.add_metadata(exam_list, "window_location",
window_location_dict)
data_handling.add_metadata(exam_list, "rightmost_points",
rightmost_points_dict)
data_handling.add_metadata(exam_list, "bottommost_points",
bottommost_points_dict)
data_handling.add_metadata(exam_list, "distance_from_starting_side",
distance_from_starting_side_dict)
pickling.pickle_to_file(cropped_exam_list_path, exam_list)
return jsonify("Done")
def run_single_model(model_path, data_path, parameters, turn_on_visualization):
"""
Load a single model and run on sample data
"""
# construct model
model = gmic.GMIC(parameters)
# load parameters
if parameters["device_type"] == "gpu":
model.load_state_dict(torch.load(model_path), strict=False)
else:
model.load_state_dict(torch.load(model_path, map_location="cpu"),
strict=False)
# load metadata
exam_list = pickling.unpickle_from_file(data_path)
# run the model on the dataset
output_df = run_model(model, exam_list, parameters, turn_on_visualization)
return output_df
def main():
parser = argparse.ArgumentParser(
description='Run image-only model or image+heatmap model')
parser.add_argument('--model-mode',
default=MODELMODES.VIEW_SPLIT,
type=str)
parser.add_argument('--model-path', required=True)
parser.add_argument('--data-path', required=True)
parser.add_argument('--image-path', required=True)
parser.add_argument('--output-path', required=True)
parser.add_argument('--batch-size', default=1, type=int)
parser.add_argument('--seed', default=0, type=int)
parser.add_argument('--use-heatmaps', action="store_true")
parser.add_argument('--heatmaps-path')
parser.add_argument('--use-augmentation', action="store_true")
parser.add_argument('--use-hdf5', action="store_true")
parser.add_argument('--num-epochs', default=1, type=int)
parser.add_argument('--device-type', default="cpu", choices=['gpu', 'cpu'])
parser.add_argument("--gpu-number", type=int, default=0)
args = parser.parse_args()
parameters = {
"device_type": args.device_type,
"gpu_number": args.gpu_number,
"max_crop_noise": (100, 100),
"max_crop_size_noise": 100,
"image_path": args.image_path,
"batch_size": args.batch_size,
"seed": args.seed,
"augmentation": args.use_augmentation,
"num_epochs": args.num_epochs,
"use_heatmaps": args.use_heatmaps,
"heatmaps_path": args.heatmaps_path,
"use_hdf5": args.use_hdf5,
"model_mode": args.model_mode,
"model_path": args.model_path,
}
exam_list = pickling.unpickle_from_file(args.data_path)
load_run_save(
data_path=args.data_path,
output_path=args.output_path,
parameters=parameters,
)
def main():
id_patient = request.args.get('id');
cropped_exam_list_path='C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/cropping/sample_output/'+id_patient+'/'+id_patient+'.pkl'
data_prefix='C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/cropping/sample_output/'+id_patient
output_exam_list_path='sample_output/'+id_patient+'.pkl'
num_processes = 10
id_patient = request.args.get('id');
exam_list = pickling.unpickle_from_file(cropped_exam_list_path)
data_list = data_handling.unpack_exam_into_images(exam_list, cropped=True)
optimal_centers = get_optimal_centers(
data_list=data_list,
data_prefix=data_prefix,
num_processes=num_processes
)
data_handling.add_metadata(exam_list, "best_center", optimal_centers)
os.makedirs(os.path.dirname(output_exam_list_path), exist_ok=True)
pickling.pickle_to_file(output_exam_list_path, exam_list)
return jsonify("Done")
def __init__(self, data_dir, file_data_list, uncertainty_label,
data_list_index=0, channels=3, randomly_select_image_from_exam=False, transform=None):
'''
Args:
data_dir: path to image directory.
image_list_file: path to the file containing images
with corresponding labels.
transform: optional transform to be applied on a sample.
'''
self.data_dir = data_dir
self.uncertainty_label = uncertainty_label
self.channels = channels
self.randomly_select_image_from_exam = randomly_select_image_from_exam
self.transform = transform
data_list = unpickle_from_file(file_data_list)[data_list_index]
exam_list_per_patient = get_exams(data_list, False, False, False)
self.flattened_exam_list, self.patient_to_exam_indices_dict = flatten_exams_list(exam_list_per_patient)
self.labels = []
for exam in self.flattened_exam_list:
self.labels.append(self.vectorize_label(exam['label']))
self.labels = np.array(self.labels)
def load_model_and_produce_heatmaps(parameters):
"""
Loads trained patch classifier and generates heatmaps for all exams
"""
# set random seed at the beginning of program
random.seed(parameters['seed'])
if (parameters["device_type"] == "gpu") and torch.has_cudnn:
device = torch.device("cuda:{}".format(parameters["gpu_number"]))
else:
device = torch.device("cpu")
model = models.ModifiedDenseNet121(num_classes=parameters['number_of_classes'])
model.load_from_path(parameters["initial_parameters"])
model = model.to(device)
model.eval()
# Load exam info
exam_list = pickling.unpickle_from_file(parameters['data_file'])
# Create heatmaps
making_heatmap_with_large_minibatch_potential(parameters, model, exam_list, device)
def crop_mammogram():
id_patient = request.args.get('id')
input_data_folder = 'C:/Users/ultra/PycharmProjects/BIRADS_classifier-master/images/' + id_patient
# exam_list_path='C:/Users/ultra/PycharmProjects/breast_cancer_classifier/sample_data/exam_list_before_cropping.pkl'
exam_list_path = 'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/sample_data/filename.pkl'
cropped_exam_list_path = 'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/cropping/sample_output/' + id_patient + '/' + id_patient + '.pkl'
output_data_folder = 'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/cropping/sample_output/' + id_patient
num_processes = 10
num_iterations = 100
buffer_size = 50
exam_list = pickling.unpickle_from_file(exam_list_path)
image_list = data_handling.unpack_exam_into_images(exam_list)
if os.path.exists(output_data_folder):
# Prevent overwriting to an existing directory
print("Error: the directory to save cropped images already exists.")
sh.rmtree(
'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/cropping/sample_output/'
+ id_patient)
os.makedirs(output_data_folder)
crop_mammogram_one_image_func = ps(
crop_mammogram_one_image,
input_data_folder=input_data_folder,
output_data_folder=output_data_folder,
num_iterations=num_iterations,
buffer_size=buffer_size,
)
with Pool(num_processes) as pool:
cropped_image_info = pool.map(crop_mammogram_one_image_func,
image_list)
window_location_dict = dict([x[0] for x in cropped_image_info])
rightmost_points_dict = dict([x[1] for x in cropped_image_info])
bottommost_points_dict = dict([x[2] for x in cropped_image_info])
distance_from_starting_side_dict = dict([x[3] for x in cropped_image_info])
data_handling.add_metadata(exam_list, "window_location",
window_location_dict)
data_handling.add_metadata(exam_list, "rightmost_points",
rightmost_points_dict)
data_handling.add_metadata(exam_list, "bottommost_points",
bottommost_points_dict)
data_handling.add_metadata(exam_list, "distance_from_starting_side",
distance_from_starting_side_dict)
pickling.pickle_to_file(cropped_exam_list_path, exam_list)
###NEXT####
cropped_exam_list_path = 'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/cropping/sample_output/' + id_patient + '/' + id_patient + '.pkl'
data_prefix = 'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/cropping/sample_output/' + id_patient
output_exam_list_path = 'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/optimal_centers/sample_output/' + id_patient + '.pkl'
num_processes = 10
id_patient = request.args.get('id')
exam_list = pickling.unpickle_from_file(cropped_exam_list_path)
data_list = data_handling.unpack_exam_into_images(exam_list, cropped=True)
optimal_centers = get_optimal_centers(data_list=data_list,
data_prefix=data_prefix,
num_processes=num_processes)
data_handling.add_metadata(exam_list, "best_center", optimal_centers)
os.makedirs(os.path.dirname(output_exam_list_path), exist_ok=True)
pickling.pickle_to_file(output_exam_list_path, exam_list)
###NEXT #####
parser = argparse.ArgumentParser(
description='Run image-only model or image+heatmap model')
# parser.add_argument('--model-path', required=True)
# parser.add_argument('--data-path', required=True)
# parser.add_argument('--image-path', required=True)
# parser.add_argument('--output-path', required=True)
parser.add_argument('--batch-size', default=1, type=int)
parser.add_argument('--seed', default=0, type=int)
parser.add_argument('--use-heatmaps', action="store_true")
parser.add_argument('--heatmaps-path')
parser.add_argument('--use-augmentation', action="store_true")
parser.add_argument('--use-hdf5', action="store_true")
# parser.add_argument('--num-epochs', default=1, type=int)
# parser.add_argument('--device-type', default="cpu", choices=['gpu', 'cpu'])
# parser.add_argument("--gpu-number", type=int, default=0)
args = parser.parse_args()
parameters = {
"device_type":
'gpu',
"gpu_number":
0,
"max_crop_noise": (100, 100),
"max_crop_size_noise":
100,
"image_path":
'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/cropping/sample_output/'
+ id_patient,
"batch_size":
args.batch_size,
"seed":
args.seed,
"augmentation":
args.use_augmentation,
"num_epochs":
10,
"use_heatmaps":
args.use_heatmaps,
"heatmaps_path":
args.heatmaps_path,
# "heatmaps_path": 'C:/Users/ultra/jPycharmProjects/breast_cancer_classifier/src/cropping/sample_output/heatmaps_'+id_patient,
"use_hdf5":
args.use_hdf5
}
# load_run_save(
# model_path='C:/Users/ultra/PycharmProjects/breast_cancer_classifier/models/sample_image_model.p',
# data_path='C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/optimal_centers/sample_output/' + id_patient + '.pkl',
# # output_path='C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/optimal_centers/sample_output/image_predictions.csv',
# output_path='C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/optimal_centers/sample_output/' + id_patient + '.csv',
# parameters=parameters,
# )
return load_run_save(
model_path=
'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/models/sample_image_model.p',
data_path=
'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/optimal_centers/sample_output/'
+ id_patient + '.pkl',
# output_path='C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/optimal_centers/sample_output/image_predictions.csv',
output_path=
'C:/Users/ultra/PycharmProjects/breast_cancer_classifier/src/optimal_centers/sample_output/'
+ id_patient + '.csv',
parameters=parameters,
)
import os, sys
# print(sys.path)
current_dir = os.path.dirname(os.path.abspath(__file__))
# appending parent dir of current_dir to sys.path
sys.path.append(os.path.dirname(current_dir))
from multiprocessing import Pool
import argparse
from functools import partial
import scipy.ndimage
import numpy as np
import pandas as pd
import src.utilities.pickling as pickling
import src.utilities.reading_images as reading_images
import src.utilities.saving_images as saving_images
import src.utilities.data_handling as data_handling
# list of exams (one dictionary per exam)
exam_list = pickling.unpickle_from_file('exam_list_before_cropping.pkl')
cropped_exam_list_path = '../sample_output/cropped_images/cropped_exam_list_test.pkl'
print(exam_list)
exam_list[0]['L-CC'] = []
# list per image (one dictionary per image). It contains same information than in list of exams + cropped information if present.
image_list = data_handling.unpack_exam_into_images(exam_list)
pickling.pickle_to_file(cropped_exam_list_path, exam_list)
