def generate_training_data_vol(jobs, case): print("Generating Training Data (Volume)...") images_fn, labels_fn, regint_fn = get_filenames(path, im_name, lb_name, ro_name) kernels = generate_kernels() for i in range(len(images_fn)): if i == case: create_volume_info(images_fn, labels_fn, regint_fn, kernels, i, jobs) break
def generate_training_data_vol(jobs, case): print("Generating Training Data (Volume)...") images_fn, labels_fn, regint_fn = get_filenames(path, im_name, lb_name, ro_name) kernels = generate_kernels() for i in range(len(images_fn)): if i == case: create_volume_info(images_fn, labels_fn, regint_fn, kernels, i, jobs) break
def generate_training_data(jobs): print("Generating Training Data...") slice_infos = [] images_fn, labels_fn, regint_fn = get_filenames(path, im_name, lb_name, ro_name) kernels = generate_kernels() slice_infos = Parallel(n_jobs=jobs)(delayed(create_sliceinfo_w)(images_fn, labels_fn, regint_fn, kernels, i) for i in range(len(images_fn))) with open(pickle, 'wb') as f: dill.dump(slice_infos, f)
def generate_training_data(jobs): print("Generating Training Data...") slice_infos = [] images_fn, labels_fn, regint_fn = get_filenames(path, im_name, lb_name, ro_name) kernels = generate_kernels() slice_infos = Parallel(n_jobs=jobs)(delayed(create_sliceinfo_w)(images_fn, labels_fn, regint_fn, kernels, i) for i in range(len(images_fn))) with open(pickle, 'wb') as f: dill.dump(slice_infos, f)
def create_sliceinfos_w(images_fn, labels_fn): print("Creating weighted Slice Infos...") kernels = generate_kernels() # create gabor kernels slice_infos = [] if len(sys.argv) < 2: for i in range(len(images_fn)): slice_infos.append( create_sliceinfo_w(images_fn, labels_fn, kernels, i)) else: slice_infos = Parallel(n_jobs=int(sys.argv[1]))( delayed(create_sliceinfo_w)(images_fn, labels_fn, kernels, i) for i in range(len(images_fn))) return slice_infos
def rf_reconstruct(slice_infos, i): feats, labels = generate_training_feats(slice_infos, i) labels = np.array(labels) RF = train_rf_classifier(feats, labels, no_trees) test_sl = slice_infos[i] image = test_sl.slice_im kernels = generate_kernels() # break the image into patches; all of these will be classified patch_size = (psize, psize) # _a stands for "all" patches_a = extract_patches_2d(image, patch_size) # _p stands for "predict" # dump the RF fn_rf = 'rf.joblib' joblib.dump(RF, fn_rf) # check each patch if len(sys.argv) >= 2: #patches_p = Parallel(n_jobs=int(sys.argv[1]))(delayed(classify_patch)(RF, kernels, patches_a, i) for i in range(len(patches_a))) patches_p = Parallel(n_jobs=int(sys.argv[1]))( delayed(classify_patch_w)(fn_rf, kernels, patches_a, i) for i in range(len(patches_a))) else: patches_p = [] for i in range(len(patches_a)): patches_p.append(classify_patch(RF, kernels, patches_a, i)) # reconstruct based on the patch recons_im = reconstruct_from_patches_2d(np.asarray(patches_p), image.shape) print(recons_im.shape) # save patches_p to the drive, because it took so much work to make! with open(recons, 'wb') as f: dill.dump(recons_im, f)
def test_rf_feats_fullspec(slice_infos, i): feats, labels = generate_training_feats(slice_infos, i) RF = train_rf_classifier(feats, labels, no_trees) test_sl = slice_infos[i] image = test_sl.slice_im label = test_sl.slice_lb patches_m, patches_n = extract_roi_patches(image, label, psize) patches_n = patches_n plabels_m = ['M' for m in patches_m] plabels_n = ['N' for n in patches_n] kernels = generate_kernels() tot = len(patches_m) + len(patches_n) res1 = [] res2 = [] t0 = time() if len(sys.argv) >= 2: res1 = Parallel(n_jobs=int(sys.argv[1]))( delayed(check_classify)(RF, kernels, p, plabels_m[i], i, tot) for i, p in enumerate(patches_m)) res2 = Parallel(n_jobs=int(sys.argv[1]))( delayed(check_classify)(RF, kernels, p, plabels_n[i], i, tot) for i, p in enumerate(patches_n)) else: for i, p in enumerate( patches_m): # go through each patch, and classify it! res1.append(check_classify(RF, kernels, p, plabels_m[i], i, tot)) pass dt = time() - t0 print(res1.count(True) + res2.count(True)) print("Finished in {:.2f} seconds.".format(dt))
def rf_reconstruct2(jobs, slice_infos, i): t0 = time() feats, labels = generate_training_feats(slice_infos, i) labels = np.array(labels) print(feats.shape, labels.shape) RF = train_rf_classifier(feats, labels, no_trees) dt1 = time() - t0 t0 = time() test_sl = slice_infos[i] image = test_sl.slice_im rimage = test_sl.slice_ro kernels = generate_kernels() dt2 = time() - t0 t0 = time() # break the image into patches; all of these will be classified patch_size = (psize, psize) # _a stands for "all" patches_a = extract_patches_2d(image, patch_size) # _p stands for "predict" patches_r = extract_patches_2d(rimage, patch_size) # _r stands for "registered" dt3 = time() - t0 t0 = time() # dump the RF #fn_rf = 'rf.joblib' #joblib.dump(RF, fn_rf) dt4 = time() - t0 t0 = time() chunk_size = len(patches_a) / float(jobs) chunk_size = int(chunk_size / 8) # save the Random Forest classifier to disk fn_rf = "tmp/rf.pkl" fd_rf = open(fn_rf, 'wb') dill.dump(RF, fd_rf) fd_rf.close() # save the kernels to disk fn_kern = "tmp/kern.pkl" fd_kern = open(fn_kern, 'wb') dill.dump(kernels, fd_kern) fd_kern.close() # list which will contain the filenames of the patch chunks fn_chunks = [] # break both patch groups into chunk-sized sets and save each of them # to disk for j in range(0, len(patches_a), int(chunk_size)): # determine the bounds of this chunk a = j b = j + int(chunk_size) if b >= len(patches_a): b = len(patches_a) - 1 # create a chunk patches_a_chunk = patches_a[a:b] patches_r_chunk = patches_r[a:b] # put it together chunk = [(a, b, len(patches_a)), patches_a_chunk, patches_r_chunk] # generate a filename for this chunk fn_chunk = "tmp/" + "patches_" + str(a) + "_" + str(b) + ".pkl" fn_chunks.append(fn_chunk) # serialise it to disk fd_chunk = open(fn_chunk, 'wb') dill.dump(chunk, fd_chunk) fd_chunk.close() # check each patch if len(sys.argv) >= 2: #patches_p = Parallel(n_jobs=jobs)(delayed(classify_patch)(RF, kernels, patches_a, i) for i in range(len(patches_a))) #patches_p = Parallel(n_jobs=jobs)(delayed(classify_patch_w)(fn_rf, kernels, patches_a, i) for i in range(len(patches_a))) #patches_x = Parallel(n_jobs=jobs)(delayed(classify_patch_p)(fn_rf, kernels, patches_a, patches_r, i, i+int(chunk_size)) for i in range(0, len(patches_a), int(chunk_size))) #patches_x = Parallel(n_jobs=jobs)(delayed(classify_patch_f)(rf_pkl, kernels_pkl, patches_a_pkl, patches_r_pkl, i, i+int(chunk_size)) for i in range(0, len(patches_a), int(chunk_size))) patches_x = Parallel(n_jobs=jobs)( delayed(classify_patch_group)(fn_rf, fn_kern, fn_chunk) for fn_chunk in fn_chunks) patches_p = [] for group in patches_x: patches_p.extend(group) else: patches_p = [] for i in range(len(patches_a)): patches_p.append(classify_patch_w(RF, kernels, patches_a, i)) dt5 = time() - t0 t0 = time() # reconstruct based on the patch recons_im = reconstruct_from_patches_2d(np.asarray(patches_p), image.shape) dt6 = time() - t0 t0 = time() print( "Completed Reconstruction {}/{}: {} DT: {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f}" .format(i, len(slice_infos), recons, dt1, dt2, dt3, dt4, dt5, dt6)) # save reconstruction! with open(recons, 'wb') as f: dill.dump(recons_im, f)
def process(filename, filename_label, slice_no): # Grab the image image_slice, orientation_slice = get_nifti_slice(filename, slice_no) if SHOW_IMG: plt.imshow(image_slice, cmap = plt.cm.gray) plt.show() # Grab the labels label_slice, orientation_label = get_nrrd_data(filename_label, slice_no) if SHOW_IMG: plt.imshow(label_slice, cmap=plt.cm.gray) plt.show() # Show the mask if SHOW_IMG: print("Masked version: ") mask = np.where(label_slice == 0, label_slice, image_slice) plt.imshow(mask, cmap=plt.cm.gray) plt.show() # Extract patches in ROI patches_mask, patches_nonmask = extract_roi_patches(image_slice, label_slice, PATCH_SIZE) # Get the decomposed patches eigens_mask = get_eigenpatches(patches_mask, PATCH_SIZE, MAX_EIGEN) eigens_nonmask = get_eigenpatches(patches_nonmask, PATCH_SIZE, MAX_EIGEN) # Show the eigens, if you want if SHOW_IMG: show_eigenpatches(eigens_mask) # Generate Gabor Kernels kernels = generate_kernels() # Show the Gabors if SHOW_IMG: plot_gabor(eigens_mask) # Store all the features and Gabor responses all_features_mask = [] all_powers_mask = [] complete_features_mask = [] all_features_nonmask = [] all_powers_nonmask = [] complete_features_nonmask = [] for eigen in eigens_mask: all_features_mask.append(compute_feats(eigen, kernels)) all_powers_mask.append(compute_powers(eigen, kernels)) for eigen in eigens_nonmask: all_features_nonmask.append(compute_feats(eigen, kernels)) all_powers_nonmask.append(compute_powers(eigen, kernels)) # for patch in patches_mask: # complete_features_mask.append(compute_feats(patch, kernels)) # # for patch in patches_nonmask: # complete_features_nonmask.append(compute_feats(patch, kernels)) return SliceInfo(filename, slice_no, image_slice, orientation_slice, label_slice, orientation_label, kernels, patches_mask, eigens_mask, all_features_mask, all_powers_mask, patches_nonmask, eigens_nonmask, all_features_nonmask, all_powers_nonmask)
def process(filename, filename_label, slice_no): # Grab the image image_slice, orientation_slice = get_nifti_slice(filename, slice_no) image_slice = normalise(image_slice) if SHOW_IMG: plt.imshow(image_slice, cmap=plt.cm.gray) plt.show() # Grab the labels label_slice, orientation_label = get_nrrd_data(filename_label, slice_no) #if SHOW_IMG: # plt.imshow(label_slice, cmap=plt.cm.gray) # plt.show() # Show the mask if SHOW_IMG: print("Masked version: ") mask = np.where(label_slice == 0, label_slice, image_slice) plt.imshow(mask, cmap=plt.cm.gray) plt.show() # Extract patches in ROI patches_mask, patches_nonmask = extract_roi_patches( image_slice, label_slice, PATCH_SIZE) # Get the decomposed patches eigens_mask = get_randoms(patches_mask, MAX_EIGEN) eigens_nonmask = get_randoms(patches_nonmask, MAX_EIGEN) # Show the eigens, if you want if SHOW_IMG: show_eigenpatches(eigens_mask) # Generate Gabor Kernels kernels = generate_kernels() # Show the Gabors if SHOW_IMG: plot_gabor(eigens_mask) # Store all the features and Gabor responses all_features_mask = [] all_powers_mask = [] all_features_nonmask = [] all_powers_nonmask = [] for eigen in eigens_mask: all_features_mask.append(compute_feats(eigen, kernels)) all_powers_mask.append(compute_powers(eigen, kernels)) for eigen in eigens_nonmask: all_features_nonmask.append(compute_feats(eigen, kernels)) all_powers_nonmask.append(compute_powers(eigen, kernels)) return SliceInfo(filename, slice_no, image_slice, orientation_slice, label_slice, orientation_label, kernels, patches_mask, eigens_mask, all_features_mask, all_powers_mask, patches_nonmask, eigens_nonmask, all_features_nonmask, all_powers_nonmask)
def rf_reconstruct2(jobs, slice_infos, i): t0 = time() feats, labels = generate_training_feats(slice_infos, i) labels = np.array(labels) print(feats.shape, labels.shape) RF = train_rf_classifier(feats, labels, no_trees) dt1 = time() - t0 t0 = time() test_sl = slice_infos[i] image = test_sl.slice_im rimage = test_sl.slice_ro kernels = generate_kernels() dt2 = time() - t0 t0 = time() # break the image into patches; all of these will be classified patch_size = (psize, psize) # _a stands for "all" patches_a = extract_patches_2d(image, patch_size) # _p stands for "predict" patches_r = extract_patches_2d(rimage, patch_size) # _r stands for "registered" dt3 = time() - t0 t0 = time() # dump the RF #fn_rf = 'rf.joblib' #joblib.dump(RF, fn_rf) dt4 = time() - t0 t0 = time() chunk_size = len(patches_a) / float(jobs) chunk_size = int(chunk_size / 8) # save the Random Forest classifier to disk fn_rf = "tmp/rf.pkl" fd_rf = open(fn_rf, 'wb') dill.dump(RF, fd_rf) fd_rf.close() # save the kernels to disk fn_kern = "tmp/kern.pkl" fd_kern = open(fn_kern, 'wb') dill.dump(kernels, fd_kern) fd_kern.close() # list which will contain the filenames of the patch chunks fn_chunks = [] # break both patch groups into chunk-sized sets and save each of them # to disk for j in range(0, len(patches_a), int(chunk_size)): # determine the bounds of this chunk a = j b = j + int(chunk_size) if b >= len(patches_a): b = len(patches_a) - 1 # create a chunk patches_a_chunk = patches_a[a:b] patches_r_chunk = patches_r[a:b] # put it together chunk = [(a, b, len(patches_a)), patches_a_chunk, patches_r_chunk] # generate a filename for this chunk fn_chunk = "tmp/" + "patches_" + str(a) + "_" + str(b) + ".pkl" fn_chunks.append(fn_chunk) # serialise it to disk fd_chunk = open(fn_chunk, 'wb') dill.dump(chunk, fd_chunk) fd_chunk.close() # check each patch if len(sys.argv) >= 2: #patches_p = Parallel(n_jobs=jobs)(delayed(classify_patch)(RF, kernels, patches_a, i) for i in range(len(patches_a))) #patches_p = Parallel(n_jobs=jobs)(delayed(classify_patch_w)(fn_rf, kernels, patches_a, i) for i in range(len(patches_a))) #patches_x = Parallel(n_jobs=jobs)(delayed(classify_patch_p)(fn_rf, kernels, patches_a, patches_r, i, i+int(chunk_size)) for i in range(0, len(patches_a), int(chunk_size))) #patches_x = Parallel(n_jobs=jobs)(delayed(classify_patch_f)(rf_pkl, kernels_pkl, patches_a_pkl, patches_r_pkl, i, i+int(chunk_size)) for i in range(0, len(patches_a), int(chunk_size))) patches_x = Parallel(n_jobs=jobs)(delayed(classify_patch_group)(fn_rf, fn_kern, fn_chunk) for fn_chunk in fn_chunks) patches_p = [] for group in patches_x: patches_p.extend(group) else: patches_p = [] for i in range(len(patches_a)): patches_p.append(classify_patch_w(RF, kernels, patches_a, i)) dt5 = time() - t0 t0 = time() # reconstruct based on the patch recons_im = reconstruct_from_patches_2d(np.asarray(patches_p), image.shape) dt6 = time() - t0 t0 = time() print("Completed Reconstruction {}/{}: {} DT: {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f}".format(i, len(slice_infos), recons, dt1, dt2, dt3, dt4, dt5, dt6)) # save reconstruction! with open(recons, 'wb') as f: dill.dump(recons_im, f)