diff --git a/data/ground_truth/ground_truth_0.png b/data/ground_truth/ground_truth_0.png new file mode 100644 index 0000000..ede0447 Binary files /dev/null and b/data/ground_truth/ground_truth_0.png differ diff --git a/data/ground_truth/ground_truth_1.png b/data/ground_truth/ground_truth_1.png new file mode 100644 index 0000000..5248107 Binary files /dev/null and b/data/ground_truth/ground_truth_1.png differ diff --git a/data/ground_truth/ground_truth_10.png b/data/ground_truth/ground_truth_10.png new file mode 100644 index 0000000..cc85f03 Binary files /dev/null and b/data/ground_truth/ground_truth_10.png differ diff --git a/data/ground_truth/ground_truth_11.png b/data/ground_truth/ground_truth_11.png new file mode 100644 index 0000000..e8cb1b6 Binary files /dev/null and b/data/ground_truth/ground_truth_11.png differ diff --git a/data/ground_truth/ground_truth_12.png b/data/ground_truth/ground_truth_12.png new file mode 100644 index 0000000..e4f94e9 Binary files /dev/null and b/data/ground_truth/ground_truth_12.png differ diff --git a/data/ground_truth/ground_truth_13.png b/data/ground_truth/ground_truth_13.png new file mode 100644 index 0000000..8094f85 Binary files /dev/null and b/data/ground_truth/ground_truth_13.png differ diff --git a/data/ground_truth/ground_truth_14.png b/data/ground_truth/ground_truth_14.png new file mode 100644 index 0000000..0acce25 Binary files /dev/null and b/data/ground_truth/ground_truth_14.png differ diff --git a/data/ground_truth/ground_truth_15.png b/data/ground_truth/ground_truth_15.png new file mode 100644 index 0000000..c1c0a1a Binary files /dev/null and b/data/ground_truth/ground_truth_15.png differ diff --git a/data/ground_truth/ground_truth_16.png b/data/ground_truth/ground_truth_16.png new file mode 100644 index 0000000..5f877e9 Binary files /dev/null and b/data/ground_truth/ground_truth_16.png differ diff --git a/data/ground_truth/ground_truth_17.png b/data/ground_truth/ground_truth_17.png new file mode 100644 index 0000000..16bcc3d Binary files /dev/null and b/data/ground_truth/ground_truth_17.png differ diff --git a/data/ground_truth/ground_truth_18.png b/data/ground_truth/ground_truth_18.png new file mode 100644 index 0000000..df7db5f Binary files /dev/null and b/data/ground_truth/ground_truth_18.png differ diff --git a/data/ground_truth/ground_truth_19.png b/data/ground_truth/ground_truth_19.png new file mode 100644 index 0000000..6a82d06 Binary files /dev/null and b/data/ground_truth/ground_truth_19.png differ diff --git a/data/ground_truth/ground_truth_2.png b/data/ground_truth/ground_truth_2.png new file mode 100644 index 0000000..f91bcc8 Binary files /dev/null and b/data/ground_truth/ground_truth_2.png differ diff --git a/data/ground_truth/ground_truth_20.png b/data/ground_truth/ground_truth_20.png new file mode 100644 index 0000000..a0f0ada Binary files /dev/null and b/data/ground_truth/ground_truth_20.png differ diff --git a/data/ground_truth/ground_truth_21.png b/data/ground_truth/ground_truth_21.png new file mode 100644 index 0000000..a752884 Binary files /dev/null and b/data/ground_truth/ground_truth_21.png differ diff --git a/data/ground_truth/ground_truth_22.png b/data/ground_truth/ground_truth_22.png new file mode 100644 index 0000000..7e9d910 Binary files /dev/null and b/data/ground_truth/ground_truth_22.png differ diff --git a/data/ground_truth/ground_truth_23.png b/data/ground_truth/ground_truth_23.png new file mode 100644 index 0000000..7562ad9 Binary files /dev/null and b/data/ground_truth/ground_truth_23.png differ diff --git a/data/ground_truth/ground_truth_24.png b/data/ground_truth/ground_truth_24.png new file mode 100644 index 0000000..3526663 Binary files /dev/null and b/data/ground_truth/ground_truth_24.png differ diff --git a/data/ground_truth/ground_truth_25.png b/data/ground_truth/ground_truth_25.png new file mode 100644 index 0000000..776b618 Binary files /dev/null and b/data/ground_truth/ground_truth_25.png differ diff --git a/data/ground_truth/ground_truth_26.png b/data/ground_truth/ground_truth_26.png new file mode 100644 index 0000000..de80b95 Binary files /dev/null and b/data/ground_truth/ground_truth_26.png differ diff --git a/data/ground_truth/ground_truth_27.png b/data/ground_truth/ground_truth_27.png new file mode 100644 index 0000000..c683f70 Binary files /dev/null and b/data/ground_truth/ground_truth_27.png differ diff --git a/data/ground_truth/ground_truth_28.png b/data/ground_truth/ground_truth_28.png new file mode 100644 index 0000000..ccd0aa7 Binary files /dev/null and b/data/ground_truth/ground_truth_28.png differ diff --git a/data/ground_truth/ground_truth_29.png b/data/ground_truth/ground_truth_29.png new file mode 100644 index 0000000..6352730 Binary files /dev/null and b/data/ground_truth/ground_truth_29.png differ diff --git a/data/ground_truth/ground_truth_3.png b/data/ground_truth/ground_truth_3.png new file mode 100644 index 0000000..c157573 Binary files /dev/null and b/data/ground_truth/ground_truth_3.png differ diff --git a/data/ground_truth/ground_truth_4.png b/data/ground_truth/ground_truth_4.png new file mode 100644 index 0000000..0e2dc13 Binary files /dev/null and b/data/ground_truth/ground_truth_4.png differ diff --git a/data/ground_truth/ground_truth_5.png b/data/ground_truth/ground_truth_5.png new file mode 100644 index 0000000..496ffd8 Binary files /dev/null and b/data/ground_truth/ground_truth_5.png differ diff --git a/data/ground_truth/ground_truth_6.png b/data/ground_truth/ground_truth_6.png new file mode 100644 index 0000000..5f56f9a Binary files /dev/null and b/data/ground_truth/ground_truth_6.png differ diff --git a/data/ground_truth/ground_truth_7.png b/data/ground_truth/ground_truth_7.png new file mode 100644 index 0000000..79d855d Binary files /dev/null and b/data/ground_truth/ground_truth_7.png differ diff --git a/data/ground_truth/ground_truth_8.png b/data/ground_truth/ground_truth_8.png new file mode 100644 index 0000000..3b662aa Binary files /dev/null and b/data/ground_truth/ground_truth_8.png differ diff --git a/data/ground_truth/ground_truth_9.png b/data/ground_truth/ground_truth_9.png new file mode 100644 index 0000000..e4c6fd3 Binary files /dev/null and b/data/ground_truth/ground_truth_9.png differ diff --git a/data2/pretrained/checkpoint.bkp b/data2/pretrained/checkpoint.bkp new file mode 100644 index 0000000..55f239e Binary files /dev/null and b/data2/pretrained/checkpoint.bkp differ diff --git a/data2/pretrained/checkpoint.pickle b/data2/pretrained/checkpoint.pickle new file mode 100644 index 0000000..f53322d Binary files /dev/null and b/data2/pretrained/checkpoint.pickle differ diff --git a/data2/pretrained/checkpoint_crop.bkp b/data2/pretrained/checkpoint_crop.bkp new file mode 100644 index 0000000..b674190 Binary files /dev/null and b/data2/pretrained/checkpoint_crop.bkp differ diff --git a/data2/pretrained/checkpoint_crop.pickle b/data2/pretrained/checkpoint_crop.pickle new file mode 100644 index 0000000..075dcab Binary files /dev/null and b/data2/pretrained/checkpoint_crop.pickle differ diff --git a/data2/pretrained/checkpoint_smooth_1.bkp b/data2/pretrained/checkpoint_smooth_1.bkp new file mode 100644 index 0000000..11e143b Binary files /dev/null and b/data2/pretrained/checkpoint_smooth_1.bkp differ diff --git a/data2/pretrained/checkpoint_smooth_1.pickle b/data2/pretrained/checkpoint_smooth_1.pickle new file mode 100644 index 0000000..7cef984 Binary files /dev/null and b/data2/pretrained/checkpoint_smooth_1.pickle differ diff --git a/data2/pretrained/checkpoint_smooth_10.bkp b/data2/pretrained/checkpoint_smooth_10.bkp new file mode 100644 index 0000000..f402d52 Binary files /dev/null and b/data2/pretrained/checkpoint_smooth_10.bkp differ diff --git a/data2/pretrained/checkpoint_smooth_10.pickle b/data2/pretrained/checkpoint_smooth_10.pickle new file mode 100644 index 0000000..e1aad34 Binary files /dev/null and b/data2/pretrained/checkpoint_smooth_10.pickle differ diff --git a/data2/pretrained/test_molecule_list.pickle b/data2/pretrained/test_molecule_list.pickle new file mode 100644 index 0000000..1a55e73 Binary files /dev/null and b/data2/pretrained/test_molecule_list.pickle differ diff --git a/deepom/aligner.py b/deepom/aligner.py index e0d962f..19f4960 100644 --- a/deepom/aligner.py +++ b/deepom/aligner.py @@ -13,6 +13,10 @@ class Aligner: path_stop: tuple[float, float] = None path: ndarray = None align_params: dict = {} + image_len = 0 + + def add_offset(self,offset): + self.offset = offset def make_alignment(self, qry, ref): assert is_sorted(qry) and is_sorted(ref) @@ -52,10 +56,10 @@ def _compute_score_matrix( loc_factor: float = 500, skip_r_factor: float = 10, skip_q_factor: float = 10, - dp_band_size: int = 5 + dp_band_size: int = 5, ): assert 2 <= len(rvec) <= 10 ** 9 - assert 2 <= len(qvec) <= 200 + assert 2 <= len(qvec) <= 1000 len_r = len(rvec) len_q = len(qvec) diff --git a/deepom/benchmark.py b/deepom/benchmark.py new file mode 100644 index 0000000..11ee3a0 --- /dev/null +++ b/deepom/benchmark.py @@ -0,0 +1,273 @@ +from deepom.bionano_compare import DataPrep, BionanoCompare, QryItem, AlignmentItem, AccuracyItem +from concurrent.futures import ThreadPoolExecutor, as_completed + +import numpy +import pandas +from numpy import ndarray +from numpy.random import default_rng +from pandas import Series, DataFrame +from tqdm.auto import tqdm + +from deepom import bionano_utils, localizer, aligner +from deepom.aligner import Aligner +from deepom.bionano_utils import XMAPItem, BionanoRefAlignerRun, MoleculeSelector, BNXItemCrop, BionanoFileData +from deepom.localizer import LocalizerModule, LocalizerOutputItem +from deepom.utils import Config, Paths, asdict_recursive, nested_dict_filter_types, pickle_dump, \ + pickle_load, git_commit, timestamp_str_iso_8601 + +from matplotlib import pyplot +from matplotlib.pyplot import eventplot, imshow, figure, xlim, savefig, gca +from matplotlib.ticker import PercentFormatter +import matplotlib + +from statsmodels.stats.proportion import proportion_confint +from IPython.display import display +# compares two localizers on the bionano dataset +class LocalizerBenchmark: + nominal_scale = Config.BIONANO_NOMINAL_SCALE + confidence_alpha = 0.05 + # cmap_filepath = Config.REF_CMAP_FILE + parallel = True + def __init__(self,first_localizer,second_localizer): + self.localizers = [first_localizer,second_localizer] + self.test_molecules_ids = self._load_test_molecule_list() + self.data_prep = DataPrep(num_crops_per_size=5,top_mol_num=10, test_id_list=self.test_molecules_ids) # 512 x 100 + self.executor = ThreadPoolExecutor() + self.refs = self._make_refs() + self.run_name = "benchmark" + self.output_file_base = Paths().out_file_mkdir("bionano_compare", self.run_name, self.run_name) + + + @classmethod + def _make_refs(self): + compare = BionanoCompare() + compare.read_cmap() + compare.make_refs() + return compare.refs + + @classmethod + def _load_test_molecule_list(self): + try: + return pickle_load(Config.TEST_LIST_FILE.with_suffix(".pickle")) + except FileNotFoundError: + return None + + + def run_aligner(self, localizer_index): + self.aligner_items = list(self.aligner_alignment_items_top(self.localizer_qry_items(localizer_index))) + print(f"{len(self.aligner_items)=}") + + + def aligner_alignment_items_top(self, qry_items): + items = self.aligner_alignment_items(qry_items) + alignment_df = DataFrame(map(vars, items)) + yield from ( + alignment_df["alignment_item"].loc[index] for index in + alignment_df.groupby("molecule_id")["score"].idxmax() + ) + + def aligner_alignment_items(self, qry_items): + tasks = [] + for qry_item in tqdm(qry_items, desc="qry items", total=len(self.data_prep.crop_items) * 2): + try: + for ref_id, ref in self.refs.items(): + if self.parallel: + tasks.append(self.executor.submit(self.align, qry_item, ref, ref_id)) + else: + yield self.align(qry_item, ref, ref_id) + except AssertionError: + print("task failed") + + if self.parallel: + for task in tqdm(as_completed(tasks), desc="alignments", + total=len(self.data_prep.crop_items) * len(self.refs) * 2): + try: + yield task.result() + except AssertionError: + print("task failed") + + + def localizer_qry_items(self, localizer_index): + inference_items = self.executor.map(lambda crop_item: self.crop_inference(crop_item, localizer_index), self.data_prep.crop_items) + first = True + for inference_item in inference_items: + scale = self.nominal_scale + + locvec = numpy.sort(inference_item.loc_pred) + image_len = inference_item.image_input.shape[-1] + + #print for check + # if first: + figure(figsize=(30, 3)) + target_width = 5 + source_width = inference_item.image_input.shape[0] // 2 + 1 + image_input = inference_item.image_input[source_width - target_width // 2: source_width + target_width // 2 + 1] + imshow(inference_item.image_input, aspect="auto", cmap="gray") + eventplot([inference_item.loc_pred], colors=["r"]) + # first = False + + def _qry_item(orientation, locs): + qry_item = QryItem() + qry_item.locs = numpy.sort(locs) + qry_item.qry = qry_item.locs * scale + qry_item.scale = scale + qry_item.orientation = orientation + qry_item.crop_item = inference_item.crop_item + #qry_item.inference_item = inference_item + return qry_item + + yield _qry_item(orientation="+", locs=locvec) + yield _qry_item(orientation="-", locs=numpy.sort(image_len - locvec)) + + def crop_inference(self, crop_item,localizer_index): + image_input = crop_item.segment_image[0] + target_width = self.localizers[localizer_index].image_channels + source_width = image_input.shape[0] // 2 + 1 + image_input = image_input[source_width - target_width // 2: source_width + target_width // 2 + 1] + # if localizer_index == 0: + # image_input = crop_item.segment_image[0] + inference_item = self.localizers[localizer_index].inference_item(image_input) + inference_item.crop_item = crop_item + return inference_item + + def run_aligners(self): + print("starting to run aligners") + with self.executor: + self.run_aligner(0) #ours + self.output_pickle_dump(self.aligner_items, ".aligner1.pickle") + # self.run_aligner(1) #yevgeni's + # self.output_pickle_dump(self.aligner_items, ".aligner2.pickle") + + def run_benchmark(self): + self.data_prep.selector.run_ids = None + self.data_prep.make_crops() + self.run_aligners() + + + def align(self, qry_item, ref, ref_id): + + aligner = Aligner() + aligner.align_params = {} + aligner.make_alignment(qry=qry_item.qry, ref=ref) + alignment_item = AlignmentItem() + alignment_item.alignment = aligner.path + alignment_item.molecule_id = qry_item.crop_item.molecule_id + alignment_item.ref_id = ref_id + alignment_item.orientation = qry_item.orientation + alignment_item.score = aligner.score + alignment_item.alignment_ref = aligner.alignment_ref + alignment_item.alignment_qry = aligner.alignment_qry + alignment_item.ref_lims = alignment_item.alignment_ref[[0, -1]] + alignment_item.qry_lims = alignment_item.alignment_qry[[0, -1]] + alignment_item.crop_item = qry_item.crop_item + alignment_item.qry_item = qry_item + alignment_item.alignment_item = alignment_item + return alignment_item + + def output_pickle_dump(self, obj, suffix): + file = self.output_file_base.with_suffix(suffix) + print(file) + pickle_dump(file, obj) + + + +################################################## + + + def read_compute_results(self): + file_base = Paths().out_path("bionano_compare", self.run_name, self.run_name) + try: + self.aligner_items1 = pickle_load(file_base.with_suffix(".aligner1.pickle")) + except FileNotFoundError: + pass + try: + self.aligner_items2 = pickle_load(file_base.with_suffix(".aligner2.pickle")) + except FileNotFoundError: + pass + try: + self.bionano_items = pickle_load(file_base.with_suffix(".bionano.pickle")) + except FileNotFoundError: + pass + +################################################# + + def plot_a(self): + self.plot_compare_init() + self.plot_aligner_accuracy() + + def plot_compare_init(self): + ax = pyplot.gca() + ax.yaxis.set_major_locator(matplotlib.ticker.MultipleLocator(.1)) + ax.yaxis.set_major_formatter(PercentFormatter(xmax=1)) + + pyplot.xlabel("Fragment Length (kb)") + pyplot.ylabel("Success Rate") + pyplot.legend() + + pyplot.xscale("log") + ax.xaxis.set_major_formatter(matplotlib.ticker.FuncFormatter(lambda x, y: int(x // 1000))) + ax.xaxis.set_minor_locator(matplotlib.ticker.MultipleLocator(10000)) + ax.xaxis.set_minor_formatter(matplotlib.ticker.NullFormatter()) + pyplot.grid(which="both") + pyplot.xticks(numpy.stack([20, 50, 100, 200, 400]) * 1000) + + + def plot_aligner_accuracy(self): + self.aligner_accuracy_items1 = list(self.accuracy_items(self.aligner_items1)) + self.aligner_accuracy_items2 = list(self.accuracy_items(self.aligner_items2)) + self.aligner_accuracy1 = self.plot_accuracy(self.aligner_accuracy_items1, label="Aligner1") + self.aligner_accuracy2 = self.plot_accuracy(self.aligner_accuracy_items2, label="Aligner2") + + + def accuracy_items(self, alignment_items): + alignment_item: AlignmentItem + + for alignment_item in alignment_items: + crop_item = alignment_item.crop_item + + accuracy_item = AccuracyItem() + accuracy_item.len_bp = crop_item.crop_size_bp + accuracy_item.num_bnx_labels = len(crop_item.original_locs_crop) + if alignment_item.qry_item: + accuracy_item.num_qry_labels = len(alignment_item.qry_item.qry) + accuracy_item.parent_orientation = crop_item.parent_bnx_item.xmap_item.orientation + accuracy_item.parent_ref_id = int(crop_item.parent_bnx_item.xmap_item.ref_id) + accuracy_item.correct_seq = ( + (alignment_item.ref_id == accuracy_item.parent_ref_id) and + (alignment_item.orientation == accuracy_item.parent_orientation) + ) + + accuracy_item.parent_ref_lims = alignment_item.crop_item.parent_bnx_item.xmap_item.ref_lims + accuracy_item.overlap_fraction = self.overlap_fraction(parent_seg=accuracy_item.parent_ref_lims, crop_seg=alignment_item.ref_lims) + + accuracy_item.correct = accuracy_item.correct_seq and (accuracy_item.overlap_fraction > 0) + accuracy_item.alignment_item = alignment_item + accuracy_item.accuracy_item = accuracy_item + yield accuracy_item + + + def overlap_fraction(self, parent_seg, crop_seg): + (x, y), (a, b) = sorted(parent_seg), sorted(crop_seg) + assert (a < b) and (x < y) + intersection = max(0, min(b, y) - max(a, x)) + overlap = intersection / (b - a) + return overlap + + + def plot_accuracy(self, accuracy_items, label): + df = DataFrame(map(vars, accuracy_items)) + # print(df) + correct = df.groupby("len_bp")["correct"] + num_successes = correct.sum() + # print(f"num_successes: {num_successes}") + num_observarions = correct.count() + acc = (num_successes / num_observarions) + len_bp = acc.index.values + pyplot.plot(len_bp, acc.values, marker='.', label=label) + + ci = numpy.stack([ + proportion_confint(count=count, nobs=nobs, alpha=self.confidence_alpha, method='beta') + for count, nobs in zip(num_successes, num_observarions) + ]) + pyplot.fill_between(len_bp, ci.T[0], ci.T[1], alpha=0.2) + return acc \ No newline at end of file diff --git a/deepom/bionano_compare.py b/deepom/bionano_compare.py index d422533..520472d 100644 --- a/deepom/bionano_compare.py +++ b/deepom/bionano_compare.py @@ -22,19 +22,25 @@ class DataPrep: - crop_size_range_bp = 10 * 1000, 450 * 1000 - num_crops_per_size = 512 - num_sizes = 24 + # crop_size_range_bp = 10 * 1000, 450 * 1000 + # num_crops_per_size = 512 + # num_sizes = 24 nominal_scale = Config.BIONANO_NOMINAL_SCALE - def __init__(self): + def __init__(self, crop_size_range_bp = (400 * 1000, 450 * 1000), num_crops_per_size=512, num_sizes=1, top_mol_num=512, test_id_list=[]): + # crop_size_range_bp = (10 * 1000, 450 * 1000), num_sizes=24 self.rng = default_rng(seed=0) - self.selector = MoleculeSelector() + self.selector = MoleculeSelector(filter_data=True, filter_ids=test_id_list) + self.crop_size_range_bp = crop_size_range_bp + self.num_crops_per_size = num_crops_per_size + self.num_sizes = num_sizes + self.top_mol_num = top_mol_num def crops_df(self): return DataFrame(map(vars, self.crop_items)) def make_crops(self): + self.selector.top_mol_num = self.top_mol_num self.selector.select_molecules() self.crop_sizes_bp = numpy.geomspace(*self.crop_size_range_bp, self.num_sizes)[::-1] diff --git a/deepom/bionano_dataset.py b/deepom/bionano_dataset.py new file mode 100644 index 0000000..569dee3 --- /dev/null +++ b/deepom/bionano_dataset.py @@ -0,0 +1,4 @@ +from torch.utils.data import TensorDataset +from torch.utils.data.dataloader import DataLoader + + diff --git a/deepom/bionano_utils.py b/deepom/bionano_utils.py index 28d7f4f..9bdf9f3 100644 --- a/deepom/bionano_utils.py +++ b/deepom/bionano_utils.py @@ -13,10 +13,12 @@ from pandas import DataFrame, Series from sqlalchemy import create_engine from tqdm.auto import tqdm +from IPython.display import display from deepom.config import Config from deepom.utils import timestamp_str_iso_8601, Paths, cached_func, is_sorted from deepom.utils_cached import read_jxr, read_jxr_segment +from deepom.localizer import SimulatedDataItem def parse_bionano_file_line(row): @@ -116,7 +118,7 @@ def bnx_to_text(self): ] return "\n".join(lines_data) - def parse_bnx(self, row): + def parse_bnx(self, row, read_image=True): self.molecule_id = row["MoleculeID"] self.locs = Series(parse_bionano_file_line(row["1"])[1:-1]).astype(float).values self.bnx_record = row @@ -129,6 +131,44 @@ def parse_bnx(self, row): self.xmap_item.xmap_record = self.bnx_record self.xmap_item.parse_values() + self.bionano_image = BionanoImage() + self.bionano_image.bnx_item = self + + if read_image: + self.bionano_image.read_bionano_image() + + def plot_simulated(self): + pyplot.subplots(figsize=(30, 3)) + im, = self.bionano_image.segment_image + pyplot.gca().pcolorfast((0, im.shape[-1]), (-.5, .5), im, cmap='gray') + pyplot.eventplot(self.simulated.fragment_sitevec / self.simulated.scale + self.simulated.strand_image_offset[0], + lineoffsets=-.2, linelengths=.4, colors='r', alpha=.5) + pyplot.grid(False) + + + def make_simulated_image(self, refs: dict, rng): + xmap_item = self.xmap_item + simulated = SimulatedDataItem() + simulated.rng = rng + simulated.label_eff = 1 + simulated.lat_size_min = 9 + simulated.stray_density = 1e-9 + simulated.scale = Config.BIONANO_NOMINAL_SCALE + reference_lims = xmap_item.ref_lims + reference_positions = refs[xmap_item.ref_id] + start, stop = reference_positions.searchsorted(reference_lims) + reference_positions = reference_positions[start:stop + 1] + if xmap_item.orientation == "+": + simulated.fragment_sitevec = reference_positions - reference_positions[0] + elif xmap_item.orientation == "-": + simulated.fragment_sitevec = numpy.sort(reference_positions[-1] - reference_positions) + else: + raise ValueError + simulated.xmap_item = xmap_item + simulated.make_params() + simulated.make_fragment_image() + self.simulated = simulated + self.bionano_image.segment_image = simulated.image class BionanoImage: bnx_item: BNXItem @@ -179,6 +219,7 @@ class MoleculeSelector: bionano_images_dir = Config.BIONANO_IMAGES_DIR xmap_file_data: 'BionanoFileData' bnx_file_data: 'BNXFileData' + top_mol_num: int = 512 top_mols_by: str = "Confidence" same_fov = True @@ -193,10 +234,15 @@ class MoleculeSelector: max_id = None scan_ids = None jxr_channel = 3 + - def __init__(self): + def __init__(self, filter_data=False, filter_ids=[],read_images=True): self.bnx_file_data = BNXFileData() self.xmap_file_data = BionanoFileData() + self.filter_data = filter_data + self.filter_ids = filter_ids + self.simulated_mode = False + self.read_images = read_images def read_files(self): self.bnx_file_data.parse_header() @@ -287,6 +333,7 @@ def select_molecules(self): assert df["JXRFileExists"].all() df = df[df["JXRFileExists"]] + self.selected_df = df def _items(): @@ -294,8 +341,11 @@ def _items(): bnx_item = BNXItem() bnx_item.meta_fields = self.bnx_file_data.names bnx_item.block_fields = self.bnx_file_data.block_fields - bnx_item.parse_bnx(row) - yield bnx_item + bnx_item.parse_bnx(row,read_image=self.read_images) + if self.filter_data is False: + yield bnx_item + elif (bnx_item.xmap_item.ref_id in self.filter_ids): + yield bnx_item self.selected = list(tqdm(_items(), desc="selected")) diff --git a/deepom/common_types.py b/deepom/common_types.py new file mode 100644 index 0000000..1901f22 --- /dev/null +++ b/deepom/common_types.py @@ -0,0 +1,25 @@ +from typing import NamedTuple, Union +from torch import Tensor +from numpy import ndarray + +class LocalizerEnum: + BG = 0 + FG = 1 + + +class LocalizerLosses(NamedTuple): + label_loss: Union[ndarray, Tensor] + loc_loss: Union[ndarray, Tensor] + + +class LocalizerGT(NamedTuple): + label_target: Union[ndarray, Tensor] + loc_target: Union[ndarray, Tensor] + +class LocalizerOutputs(NamedTuple): + label_output: Union[ndarray, Tensor] + loc_output: Union[ndarray, Tensor] + +class DataItem(NamedTuple): + molecule: Union[ndarray, Tensor] + ground_truth: LocalizerGT \ No newline at end of file diff --git a/deepom/config.py b/deepom/config.py index e8f8c0a..c048bc9 100644 --- a/deepom/config.py +++ b/deepom/config.py @@ -12,11 +12,13 @@ class Config: REFALIGNER = HOME_DIR / "bionano_sw/tools/pipeline/Solve3.7_03302022_283/RefAligner/1.0/RefAligner" BIONANO_RUN_DIR = DATA_DIR / "bionano_runs/2022-04-19" REF_CMAP_FILE = BIONANO_RUN_DIR / "hg38_DLE1_0kb_0labels.cmap" - BNXDB_FILE = BIONANO_RUN_DIR / "bnx.db" + BNXDB_FILE = HOME_DIR / "bnx.db" #we should copy this, mnt, to file server BNX_FILE = BIONANO_RUN_DIR / "T1_chip2_channels_swapped.bnx" XMAP_FILE = BIONANO_RUN_DIR / "exp_refineFinal1.xmap" BIONANO_IMAGES_DIR = BIONANO_RUN_DIR - + + GROUND_TRUTH_DIR = DATA_DIR / "ground_truth" + EVALUATION_DIR = OUT_DIR/ "eval_images" BIONANO_BNX_SCALE = 375 BIONANO_NOMINAL_SCALE = 335 NM_PER_BP_NOMINAL = 0.34 @@ -28,8 +30,12 @@ class Config: LOCALIZER_TRAINING_OUTPUT_DIR = OUT_DIR / "LocalizerModule" CHECKPOINT_SEARCH_DIR = Path(__file__).parent.parent / "data/pretrained" CHECKPOINT_FILE: str = "checkpoint.pickle" + + SECOND_CHECKPOINT_SEARCH_DIR = Path(__file__).parent.parent / "data2/pretrained" + TEST_LIST_FILE = SECOND_CHECKPOINT_SEARCH_DIR / "test_molecule_list" - + MY_LOCALIZER_TRAINING_OUTPUT_DIR = OUT_DIR / "DataLocalizer" + class Consts: PI = numpy.pi _2PI = PI * 2 diff --git a/deepom/data_fetcher.py b/deepom/data_fetcher.py new file mode 100644 index 0000000..b94a264 --- /dev/null +++ b/deepom/data_fetcher.py @@ -0,0 +1,235 @@ +from scipy.interpolate import interp1d +from deepom.bionano_utils import MoleculeSelector + +from deepom.config import Config +from deepom.localizer import LocalizerModule +from deepom.common_types import LocalizerEnum +import monai + +from deepom.aligner import Aligner +from deepom.utils import generate_name +from deepom.my_utils import get_aligner, get_scaler_from_aligner, overlap_percentage, overlap_fraction, fp_precentage, fn_precentage +import numpy as np + +from deepom.bionano_compare import BionanoCompare +from matplotlib.pyplot import eventplot, imshow, figure, xlim, savefig, close, title + +from deepom.config import Config +from threading import Lock, Thread +from pathlib import Path +from numba import njit,jit +import os + + +class DataFetcher(): + + def __init__(self, num_molecules: int,plot_size = 500,threshold = 0.99): + #Plot location and bounds data + self.save_path = "../data/ground_truth/"+generate_name("gt") + self.plot_size = plot_size + + self.selector = MoleculeSelector(read_images=False) + self.num_molecules = num_molecules + self.selector.top_mol_num = num_molecules + self.loaded_molecules = False #To cache molecules + + self.refs = self._make_refs() + self.localizer = self._make_localizer() + self.low_confidence_mols = [] + self.threshold = threshold + self.rng = np.random.default_rng() + + + def get_molecules_from_file(self): + + if self.loaded_molecules: + return + self.selector.select_molecules() + self.loaded_molecules = True + + @classmethod + def _make_refs(self): + compare = BionanoCompare() + compare.read_cmap() + compare.make_refs() + return compare.refs + + @classmethod + def _make_localizer(self): + localizer_module = LocalizerModule() + localizer_module.checkpoint_search_dir = Config.CHECKPOINT_SEARCH_DIR + localizer_module.load_checkpoint = True + localizer_module.init_ensure_module() + return localizer_module + + def create_localization(self,mol_index): + image_input = self.selector.selected[mol_index].bionano_image.segment_image[0] + target_width = self.localizer.image_channels + source_width = image_input.shape[0] // 2 + 1 + image_input = image_input[source_width - target_width // 2: source_width + target_width // 2 + 1] + inference_item = self.localizer.inference_item(image_input) + return inference_item + + def get_best_aligner(self,inference_item,mol_index): + ref_id = self._get_ref_id(mol_index) + + aligner_reg = get_aligner() + aligner_rev = get_aligner() + + qry = inference_item.loc_pred * 335 + inverted_qry = np.sort((inference_item.image.shape[-1] - inference_item.loc_pred)*335) + + aligner_reg.make_alignment(qry=qry, ref=self.refs[ref_id]) + aligner_rev.make_alignment(qry=inverted_qry, ref=self.refs[ref_id]) + + regular_overlap = self._get_overlap(aligner_reg,mol_index) + reverse_overlap = self._get_overlap(aligner_rev,mol_index) + rev = False + (rev,aligner) = (False,aligner_reg) if regular_overlap > reverse_overlap else (True,aligner_rev) + # print(f"best overlap for mol number {mol_index} is: {max(regular_overlap,reverse_overlap)}") + offset = inference_item.image.shape[-1] - inference_item.loc_pred[-1] + aligner.add_offset(offset) + aligner.image_len = inference_item.image.shape[-1] + overlap = max(regular_overlap,reverse_overlap) + return rev,aligner,overlap + + def interpolate_ground_truth(self,aligner,mol_index,rev): + ref_id = self._get_ref_id(mol_index) + scaler = get_scaler_from_aligner(aligner) + + z = aligner.alignment_ref + y = (z-z[0]) / (scaler*335) + x = aligner.alignment_qry/335 + if rev == True: + y = np.sort(aligner.image_len-y)-aligner.offset + x = np.sort(aligner.image_len-x) + else: + y = y+aligner.alignment_qry[0] /335 + + interp_func = interp1d(x=y,y=x,bounds_error = False, fill_value = "extrapolate") + + ref = self.refs[ref_id] + start, end = aligner.alignment_ref[[0, -1]] + start_index = np.argmax(ref >= start) + end_index = np.argmin(ref <= end) + ref_crop = ref[start_index:end_index] + + z_hat = (ref_crop-ref_crop[0]) / (scaler*335) + if rev == True: + z_hat = np.sort(aligner.image_len-z_hat)-aligner.offset + else: + z_hat = z_hat+x[0] + + y_hat = interp_func(z_hat) + return y_hat + + + def generate_ground_truth_plots(self): + self.get_molecules_from_file() + + for molecule_index in range(self.num_molecules): + inference_item = self.create_localization(molecule_index) + rev,aligner,_ = self.get_best_aligner(inference_item,molecule_index) + ground_truth = self.interpolate_ground_truth(aligner,molecule_index,rev) + overlap = self._get_overlap(aligner,molecule_index) + + + self.save_ground_truth_plot(inference_item,ground_truth,molecule_index, + aligner.score,overlap) + #print(f"generated molecule number {molecule_index}") + + def generate_ground_truth(self, molecule_index): + self.get_molecules_from_file() + # self.selector.selected[molecule_index].make_simulated_image(self.refs, self.rng) + + inference_item = self.create_localization(molecule_index) + + rev,aligner,overlap = self.get_best_aligner(inference_item,molecule_index) + if overlap < self.threshold: + return (None,None,None) + ground_truth = self.interpolate_ground_truth(aligner,molecule_index,rev) #y_hat + mol = self.selector.selected[molecule_index] + + shape = inference_item.image.shape[-1] + + labeled_index = ground_truth.astype(int) + pos_in_pixel = ground_truth - labeled_index + + assert ((pos_in_pixel >= 0) & (pos_in_pixel <= 1) & (ground_truth >= 0) & (ground_truth < shape)).all() + assert len(pos_in_pixel) == len(ground_truth) + + a = np.full(shape, fill_value=LocalizerEnum.BG, dtype=int) + b = np.full(shape, fill_value=.5, dtype=float) + + a[labeled_index] = LocalizerEnum.FG + b[labeled_index] = pos_in_pixel + # print(f"GT for mol number {molecule_index}: is of length {shape}") + return mol,a,b + + def generate_ground_truth_simulated(self, molecule_index): + self.get_molecules_from_file() + self.selector.selected[molecule_index].make_simulated_image(self.refs, self.rng) + mol = self.selector.selected[molecule_index] + locations = mol.simulated.emitter_coords[...,1] + labeled_index = locations.astype(int) + pos_in_pixel = locations - labeled_index + shape = mol.bionano_image.segment_image[0].shape[-1] + + a = np.full(shape, fill_value=LocalizerEnum.BG, dtype=int) + b = np.full(shape, fill_value=.5, dtype=float) + + a[labeled_index] = LocalizerEnum.FG + b[labeled_index] = pos_in_pixel + # print(f"GT for mol number {molecule_index}: is of length {shape}") + return mol,a,b + + def generate_ground_truth_plots_simulated(self): + self.get_molecules_from_file() + for molecule_index in range(self.num_molecules): + figure(figsize=(30, 3)) + mol, a, b = self.generate_ground_truth_simulated(molecule_index) + image_input = mol.bionano_image.segment_image[0] + target_width = self.localizer.image_channels + source_width = image_input.shape[0] // 2 + 1 + image_input = image_input[source_width - target_width // 2: source_width + target_width // 2 + 1] + imshow(image_input, aspect="auto", cmap="gray") + locations = mol.simulated.emitter_coords[...,1] + print(locations.shape) + eventplot([locations], colors=["r"]) + + if not os.path.isdir(self.save_path): + os.makedirs(self.save_path) + savefig(Path(self.save_path) / (f"simulated_ground_truth_{molecule_index}.png")) + close() + + + def save_ground_truth_plot(self,inference_item,ground_truth,mol_index,score,overlap): + print(mol_index) + figure(figsize=(30, 3)) + + fp = fp_precentage(ground_truth, inference_item.loc_pred, 0.5) + fn = fn_precentage(ground_truth, inference_item.loc_pred, 0.5) + + image_input = self.selector.selected[mol_index].bionano_image.segment_image[0] + target_width = self.localizer.image_channels + source_width = image_input.shape[0] // 2 + 1 + image_input = image_input[source_width - target_width // 2: source_width + target_width // 2 + 1] + imshow(image_input, aspect="auto", cmap="gray") + eventplot([inference_item.loc_pred,ground_truth], colors=["b", "r"]) + color = 'black' + if overlap < self.threshold : #conservative estimate + color= 'red' + self.low_confidence_mols.append(mol_index) + title(f"mol index: {mol_index} score: {score}, overlap: {overlap}, fp: {fp}, fn: {fn}",color = color) + if not os.path.isdir(self.save_path): + os.makedirs(self.save_path) + savefig(Path(self.save_path) / (f"ground_truth_{mol_index}.png")) + # savefig(f'ground_truth_{mol_index}.png') + # (Path("../../DeepOM-Paper/figures") / ("simulation_figure" + ext), bbox_inches='tight') + close() # Don't want to have too many figure instances open + + def _get_ref_id(self,mol_index): + return self.selector.selected[mol_index].xmap_item.ref_id + + def _get_overlap(self,aligner,mol_index): + return overlap_percentage(self.selector.selected[mol_index].xmap_item.ref_lims, aligner.alignment_ref[[0,-1]]) diff --git a/deepom/dataloader.py b/deepom/dataloader.py new file mode 100644 index 0000000..f054f80 --- /dev/null +++ b/deepom/dataloader.py @@ -0,0 +1,27 @@ +import torch + + +class Dataset(torch.utils.data.Dataset): + 'Characterizes a dataset for PyTorch' + + def __init__(self, list_IDs, labels, dataset_name=""): + 'Initialization' + self.labels = labels + self.list_IDs = list_IDs + self.dataset_name = dataset_name + + def __len__(self): + 'Denotes the total number of samples' + return len(self.list_IDs) + + def __getitem__(self, index): + 'Generates one sample of data' + # Select sample + ID = self.list_IDs[index] + + # Load data and get label + # Expects to get data as a pytorch tensor + X = torch.load('data/' + ID + '.pt') + y = self.labels[ID] + + return X, y diff --git a/deepom/localizer.py b/deepom/localizer.py index f7421fb..4a1fb2e 100644 --- a/deepom/localizer.py +++ b/deepom/localizer.py @@ -118,30 +118,33 @@ def random_sample(self, x, size): return x.rvs(random_state=self.rng, size=size) def make_params(self): - assert self.sitevec is not None - assert is_sorted(self.sitevec) - assert len(self.sitevec) >= 2 - for key, val in vars(self).items(): if isinstance(val, RandomSample): setattr(self, key, val.random_sample(self.rng)) - if self.offset is None: - offset_start, offset_stop = self.sitevec.min(), self.sitevec.max() - self.fragment_len - - if offset_start < offset_stop: - self.offset = self.rng.integers(offset_start, offset_stop) - else: - self.offset = offset_start - def make_image(self): self.make_params() self.make_fragment() + self.make_fragment_image() + + def make_fragment_image(self): self.make_emitter_coords() self.make_emitter_field() self.make_image_readout() def make_fragment(self): + assert self.sitevec is not None + assert is_sorted(self.sitevec) + assert len(self.sitevec) >= 2 + + if self.offset is None: + offset_start, offset_stop = self.sitevec.min(), self.sitevec.max() - self.fragment_len + + if offset_start < offset_stop: + self.offset = self.rng.integers(offset_start, offset_stop) + else: + self.offset = offset_start + start, stop = self.offset, self.offset + self.fragment_len start_i, stop_i = self.sitevec.searchsorted([start, stop]) self.fragment_sitevec_indices = numpy.arange(start_i, stop_i) @@ -149,6 +152,7 @@ def make_fragment(self): assert is_sorted(self.fragment_sitevec) + def make_emitter_coords(self): self.make_labeled_coords() self.make_stray_coords() @@ -157,6 +161,7 @@ def make_emitter_coords(self): self.stray_coords, ]) + def make_labeled_coords(self): assert len(self.fragment_sitevec) start_offset, end_offset = self.strand_image_offset @@ -373,7 +378,7 @@ def __init__(self): self.checkpoint_search_dir = None self.log_metrics_every = 1 - self.device = torch.device('cuda') + self.device = torch.device('cpu') self.dtype = torch.float32 self.lr = 1e-3 self.batch_size = 1 @@ -431,7 +436,7 @@ def step_events(self, step_item): if self.checkpoint_every is not None: checkpoint_every = max(1, self.checkpoint_every // self.batch_size) - if self.step_index % checkpoint_every == 0: + if self.step_index % 100 == 0: self.checkpoint_save() def _module_build(self): @@ -668,10 +673,11 @@ def _inference_forward(self, module_input: ndarray): def inference_item(self, segment_3d): image_input = self.image_input(segment_3d) + # print("original image input shape"+ str(image_input.shape[-1:])) with inference_eval(self.module): output_tensor = self._inference_forward(image_input) - + item = copy(self.module_output_item) item.image = segment_3d item.image_input = image_input @@ -705,7 +711,7 @@ def loss_func(self, output, target): loss_tuple = LocalizerLosses( label_loss=label_criterion(label_output, targets.label_target.long()[:, None]), - loc_loss=(mask * bce(outputs.loc_output, targets.loc_target)).mean() / mask_mean, + loc_loss=((mask * bce(outputs.loc_output, targets.loc_target)).mean() / mask_mean)*0, ) return { Keys.LOSS_TENSOR: torch.stack(loss_tuple).mean(), diff --git a/deepom/localizer2.py b/deepom/localizer2.py new file mode 100644 index 0000000..4a1fb2e --- /dev/null +++ b/deepom/localizer2.py @@ -0,0 +1,767 @@ +import itertools +import shutil +from copy import copy +from inspect import currentframe +from traceback import print_exc +from typing import NamedTuple, Union + +import monai +import more_itertools +import numpy +import torch +import wandb +from matplotlib import pyplot +from monai.data import list_data_collate, IterableDataset, DataLoader +from monai.losses import DiceCELoss +from monai.networks.nets import BasicUNet +from monai.transforms import Compose, SelectItemsd, SpatialPad, SpatialCrop, AddChannel, ScaleIntensity, SqueezeDim, \ + DivisiblePad, ToNumpy +from monai.utils import convert_to_tensor, Method +from numpy import ndarray +from numpy.random import default_rng +from scipy import ndimage +from scipy.stats import gamma +from scipy.stats._distn_infrastructure import rv_generic +from skimage.exposure import rescale_intensity +from torch import Tensor +from torch.optim import Adam +from tqdm.auto import tqdm + +from deepom.utils import uniform_range, Config, uniform_central_range, is_sorted, gaussian_density, filter_valid_coords, \ + Paths, generate_name, path_mkdir, asdict_recursive, nested_dict_filter_types, find_file, num_module_params, \ + inference_eval, numpy_sigmoid, set_names + + +@set_names +class Keys: + MODULE_INPUT = None + MODULE_OUTPUT: str = None + MODULE_TARGET = None + LOSS_TENSOR = None + LOSSES = None + LOSS = None + TRAIN: str = None + BATCH_ITEMS = None + DATA_ITEM = None + DATA_ITEM_INDEX = None + + +class DataItem: + def __init__(self): + self.labeled_coords = None + self.align_locs = None + self.align_sites = None + self.fragment_coords = None + self.locvec = None + self.sitevec = None + self.image = None + self.nominal_scale = None + self.segment_name = None + + +class RandomSample: + def __init__(self, distrib: rv_generic = None, size=None): + self.distrib = distrib + self.size = size + + def random_sample(self, random_state, size=None): + if size is None: + size = self.size + + return self.distrib.rvs(random_state=random_state, size=size) + + +class SimulatedDataItem(DataItem): + def __init__(self): + super().__init__() + self.rng = default_rng() + + self.segment_name = f'{type(self).__name__}' + + self.time_size = 1 + self.emitter_p = uniform_range(0.5, 1) + self.time_sigma = 1 + + self.nominal_scale = Config.BIONANO_NOMINAL_SCALE + self.offset = None + self.lon_size_min = 1 + self.lat_size_min = 3 + self.label_eff = RandomSample(uniform_range(0.9, 1)) + self.angle = 0 + self.scale = RandomSample(uniform_central_range(center=self.nominal_scale, margin=5)) + self.strand_image_offset = RandomSample(uniform_range(5, 10), size=2) + self.psf_sigma = RandomSample(uniform_range(1.2, 1.5)) + + self.stray_density = 1e-3 + self.emitter_intensity_distrib = gamma(2, .5, 1e-1) + self.bg_distrib = gamma(100, 0, .3e-2) + + self.fragment_len = RandomSample(uniform_range(self.nominal_scale * 100, self.nominal_scale * 150)) + + self.stray_coords = None + self.visible_mask = None + self.fragment_coords = None + self.image_fg = None + self.image_bg = None + self.emitter_intensity = None + self.emitter_field = None + self.intensity_field = None + self.labeled_coords = None + self.emitter_coords = None + self.labeled_mask = None + self.fragment_sitevec = None + self.fragment_sitevec_indices = None + self.lon_size = None + self.lat_size = None + + def random_sample(self, x, size): + return x.rvs(random_state=self.rng, size=size) + + def make_params(self): + for key, val in vars(self).items(): + if isinstance(val, RandomSample): + setattr(self, key, val.random_sample(self.rng)) + + def make_image(self): + self.make_params() + self.make_fragment() + self.make_fragment_image() + + def make_fragment_image(self): + self.make_emitter_coords() + self.make_emitter_field() + self.make_image_readout() + + def make_fragment(self): + assert self.sitevec is not None + assert is_sorted(self.sitevec) + assert len(self.sitevec) >= 2 + + if self.offset is None: + offset_start, offset_stop = self.sitevec.min(), self.sitevec.max() - self.fragment_len + + if offset_start < offset_stop: + self.offset = self.rng.integers(offset_start, offset_stop) + else: + self.offset = offset_start + + start, stop = self.offset, self.offset + self.fragment_len + start_i, stop_i = self.sitevec.searchsorted([start, stop]) + self.fragment_sitevec_indices = numpy.arange(start_i, stop_i) + self.fragment_sitevec = self.sitevec[self.fragment_sitevec_indices] + + assert is_sorted(self.fragment_sitevec) + + + def make_emitter_coords(self): + self.make_labeled_coords() + self.make_stray_coords() + self.emitter_coords = numpy.concatenate([ + self.labeled_coords, + self.stray_coords, + ]) + + + def make_labeled_coords(self): + assert len(self.fragment_sitevec) + start_offset, end_offset = self.strand_image_offset + + # todo: add off-target labels + self.labeled_mask = self.rng.binomial(n=1, p=self.label_eff, size=len(self.fragment_sitevec)).astype(bool) + + r = (self.fragment_sitevec - self.fragment_sitevec[0]) / self.scale + assert is_sorted(r) + + x = r * numpy.cos(self.angle) + start_offset + y = r * numpy.sin(self.angle) + + self.lon_size = int(max(self.lon_size_min, x.max() + start_offset + end_offset)) + assert self.lon_size > 0 + + self.lat_size = int(max(self.lat_size_min, y.max())) + y = y + self.lat_size / 2 + assert self.lat_size > 0 + + self.fragment_coords = numpy.stack([y, x]).T + shape = (self.lat_size, self.lon_size) + assert ( + (y >= 0) & + (y < shape[0]) & + (x >= 0) & + (x < shape[1]) + ).all() + + self.visible_mask = self.labeled_mask + + assert len(self.fragment_coords) == len(self.fragment_sitevec) == len(self.visible_mask) + + self.labeled_coords = self.fragment_coords[self.visible_mask] + + def make_emitter_field(self): + emitter_field = numpy.zeros((int(self.time_size), int(self.lat_size), int(self.lon_size)), dtype=float) + + assert len(self.emitter_coords) + + num_emitters = len(self.emitter_coords) + + emitter_intensity = self.random_sample( + self.emitter_intensity_distrib, + size=(self.time_size, num_emitters) + ) + + # todo: add exponential bleaching + if self.time_size > 1: + emitter_p = self.random_sample(self.emitter_p, size=num_emitters) + time_mask = self.rng.binomial(n=1, p=emitter_p[None, :], size=(self.time_size, num_emitters)) + time_mask = ndimage.gaussian_filter1d(time_mask, axis=0, sigma=self.time_sigma) + time_mask = (time_mask > .5).astype(int) + emitter_intensity = emitter_intensity * time_mask + + # todo: vectorize + for t in range(self.time_size): + emitter_field[t] = gaussian_density(self.emitter_coords, emitter_intensity[t], + shape=(self.lat_size, self.lon_size), sigma=self.psf_sigma) + self.emitter_intensity = emitter_intensity + self.emitter_field = emitter_field + + def make_image_readout(self): + self.image_fg = rescale_intensity(self.emitter_field) + if self.bg_distrib is not None: + self.image_bg = self.random_sample(self.bg_distrib, size=self.image_fg.shape) + self.image = rescale_intensity(self.image_fg + self.image_bg) + + def make_stray_coords(self): + assert self.lat_size + assert self.lon_size + assert self.stray_density + + num_stray = int(self.lat_size * self.lon_size * self.stray_density) + if num_stray > 0: + _coords = self.rng.uniform(low=(0, 0), high=(self.lat_size, self.lon_size), size=(num_stray, 2)) + self.stray_coords = filter_valid_coords(_coords, (self.lat_size, self.lon_size)) + else: + self.stray_coords = numpy.empty((0, 2)) + + +class LocalizerTrainDataItem(SimulatedDataItem): + def __init__(self): + super().__init__() + self.targets = None + self.label_target = None + self.loc_target = None + + def make_target(self): + self.make_image() + + assert (self.labeled_coords is not None) and len(self.labeled_coords) + + labeled_pos = self.labeled_coords.T[1] + stray_pos = self.stray_coords.T[1] + shape = self.image.shape[-1] + + labeled_index = labeled_pos.astype(int) + pos_in_pixel = labeled_pos - labeled_index + + assert ((pos_in_pixel >= 0) & (pos_in_pixel <= 1) & (labeled_pos >= 0) & (labeled_pos < shape)).all() + assert len(pos_in_pixel) == len(labeled_pos) + + self.targets = LocalizerTargets( + label_target=numpy.full(shape, fill_value=LocalizerEnum.BG, dtype=int), + loc_target=numpy.full(shape, fill_value=.5, dtype=float), + ) + self.targets.label_target[stray_pos.astype(int)] = LocalizerEnum.STRAY + self.targets.label_target[labeled_index] = LocalizerEnum.FG + self.targets.loc_target[labeled_index] = pos_in_pixel + self.target = numpy.stack(self.targets) + + +class TaskMixin: + def __init__(self): + self.run_name = None + self.run_root_dir = None + self.tqdm_enable = True + self.paths_config = Paths() + self.task_name = type(self).__name__ + self.task_root_dir = self.paths_config.out_path(self.task_name) + + self.seed = None + self.axes_iter = None + + self.wandb_mode = None + + self.test_mode_enable = False + self.log_wandb_enable = False + self.log_debug_enable = False + self.tqdm = None + self.step_index = 0 + + def init_task(self): + # order important! + self.generate_random_task_name() + self.init_rng() + self.init_log() + + def task_steps(self): + try: + self.init_task() + for step in self._task_steps(): + self.step_index += 1 + self.tqdm.update() + yield step + finally: + if self.log_wandb_enable: + wandb.finish() + + def generate_random_task_name(self): + self.run_name = generate_name(self.task_name) + if self.test_mode_enable: + self.task_root_dir = self.task_root_dir / Config.TEST_DIR + self.run_root_dir = (self.task_root_dir / self.run_name) + + def init_log(self): + self.tqdm = tqdm(desc=self.run_name, disable=not self.tqdm_enable) + + if self.log_wandb_enable: + path_mkdir(self.run_root_dir) + wandb.init( + name=self.run_name, dir=str(self.run_root_dir), + mode=self.wandb_mode, + project=Config.PROJECT_NAME, + ) + wandb.config.update(self.task_params_dict()) + + def init_rng(self): + monai.utils.set_determinism(seed=self.seed) + self.rng = default_rng(seed=self.seed) + + def _log_debug(self, *args): + if not self.log_debug_enable: + return + func_name = currentframe().f_back.f_code.co_name + items = (self.task_name, func_name, *args) + if self.tqdm is None: + print(items) + else: + self.tqdm.write(' '.join(map(str, items))) + + def log_wandb_figure(self, figure=pyplot, key=Config.WANDB_FIGURE): + if self.log_wandb_enable: + wandb.log({key: figure}) + + def task_params_dict(self): + data = asdict_recursive(self, include_modules=[self.__module__], prefix=Config.WANDB_PREFIX) + data = nested_dict_filter_types(data) + return data + + def _task_steps(self): + raise NotImplementedError + + def run(self): + more_itertools.consume(self.task_steps()) + + def log_shapes(self, item: dict): + for key, val in item.items(): + if hasattr(val, 'shape'): + self._log_debug(f'{key}.shape={val.shape}') + + +class TrainerMixin(TaskMixin): + def __init__(self): + super().__init__() + self.optimizer = None + self.validation_every = 2000 + self.log_images_every = 1000 + self.log_metrics_every = None + self.checkpoint_every = 10000 + self.module = None + self.load_checkpoint = False + self.checkpoint_search_dir = None + self.log_metrics_every = 1 + + self.device = torch.device('cpu') + self.dtype = torch.float32 + self.lr = 1e-3 + self.batch_size = 1 + self.log_tqdm_postfix = {} + + def init_task(self): + super().init_task() + self.init_ensure_module() + self.init_validation() # also inits the module + self.init_optimizer() + + def init_optimizer(self): + self.optimizer = Adam(self.module.parameters(), lr=self.lr) + + def _task_steps(self): + self.module.train() + self.__train_data_loader = self._train_data_loader() + for batch in self.__train_data_loader: + yield self._training_step(batch) + + def _training_step(self, data_item: dict): + self.optimizer.zero_grad() + + output_item = {Keys.MODULE_OUTPUT: self.module_forward(data_item[Keys.MODULE_INPUT])} + loss_item = self.loss_func(output_item[Keys.MODULE_OUTPUT], data_item[Keys.MODULE_TARGET]) + + loss_item[Keys.LOSS_TENSOR].backward() + self.optimizer.step() + + step_item = data_item | output_item | loss_item + self.step_events(step_item) + + return step_item + + def make_metrics(self, step_item): + loss_metric = step_item[Keys.LOSS_TENSOR].detach().item() + metrics_item = {Keys.LOSS: loss_metric} + return metrics_item + + def step_events(self, step_item): + log_metrics_every = max(1, self.log_metrics_every // self.batch_size) + log_images_every = max(1, self.log_images_every // self.batch_size) + validation_every = max(1, self.validation_every // self.batch_size) + + if self.step_index % log_images_every == 0: + self.log_train_batch(step_item) + + if self.step_index % validation_every == 0: + self.validation_step() + + if self.step_index % log_metrics_every == 0: + metrics_item = self.make_metrics(step_item) + self._log_update_tqdm_postfix(metrics_item) + self.log_metrics({Keys.TRAIN: metrics_item}) + + if self.checkpoint_every is not None: + checkpoint_every = max(1, self.checkpoint_every // self.batch_size) + if self.step_index % 100 == 0: + self.checkpoint_save() + + def _module_build(self): + raise NotImplementedError + + def _data_collate(self, items: list): + items_to_batch = Compose([ + SelectItemsd(keys=[Keys.MODULE_INPUT, Keys.MODULE_TARGET], allow_missing_keys=True) + ])(items) + batch = list_data_collate(items_to_batch) | {Keys.BATCH_ITEMS: items} + return batch + + def init_validation(self): + pass + + def _checkpoint_load(self): + if self.load_checkpoint: + try: + if self.checkpoint_search_dir is None: + search_dir = self.task_root_dir + else: + search_dir = self.checkpoint_search_dir + + file = find_file(search_dir=search_dir, suffix=Config.CHECKPOINT_FILE) + except (ValueError, RuntimeError): + print_exc() + raise + else: + print('loading checkpoint: ', file, '\n\n') + self.module.load_state_dict(torch.load(file, map_location=self.device)) + + def log_metrics(self, metrics_dict): + if self.log_wandb_enable: + wandb.log(metrics_dict, step=self.step_index) + + def _log_update_tqdm_postfix(self, metrics_dict): + self.log_tqdm_postfix |= metrics_dict + self.tqdm.set_postfix(self.log_tqdm_postfix) + + def _on_log_init_end(self): + if self.log_wandb_enable: + wandb.watch(models=self.module, log="all", log_graph=True) + + def checkpoint_save(self): + checkpoint_file = self.paths_config.out_file_mkdir(self.run_root_dir, Config.CHECKPOINT_FILE) + if checkpoint_file.exists(): + shutil.copy(checkpoint_file, checkpoint_file.with_suffix('.bkp')) + self._log_update_tqdm_postfix({"ckpt": self.step_index}) + torch.save(self.module.state_dict(), checkpoint_file) + + def _train_data_loader(self): + dataset = IterableDataset(itertools.count(), transform=lambda i: self.train_item() | {Keys.DATA_ITEM_INDEX: i}) + return DataLoader(dataset, batch_size=self.batch_size, num_workers=0, collate_fn=self._data_collate) + + def train_item(self): + raise NotImplementedError + + def loss_func(self, output, target): + raise NotImplementedError + + def log_train_batch(self, output_batch): + pass + + def validation_step(self): + pass + + def _module_apply(self, data_batch: dict): + return data_batch | {Keys.MODULE_OUTPUT: self.module_forward(data_batch[Keys.MODULE_INPUT])} + + def to_tensor(self, obj): + return convert_to_tensor(obj, device=self.device, dtype=self.dtype) + + def module_forward(self, module_input): + return Compose([ + self.to_tensor, + self.module, + ])(module_input) + + def init_ensure_module(self): + if self.module is None: + self.module = self._module_build() + self._checkpoint_load() + self.module.to(self.device) + self.__num_module_params = num_module_params(self.module) + + +class SimulatedGenomeItem: + def __init__(self): + self.rng = default_rng() + self.sitevec = None + self.genome_len = None + self.sparsity = None + + def make_genome(self): + assert self.genome_len + assert self.sparsity + + sitevec = numpy.flatnonzero(self.rng.binomial(n=1, p=1 / self.sparsity, size=self.genome_len)) + assert len(sitevec) + sitevec.sort() + self.sitevec = sitevec + + +class LocalizerLosses(NamedTuple): + label_loss: Union[ndarray, Tensor] + loc_loss: Union[ndarray, Tensor] + + +class LocalizerEnum: + BG = 0 + STRAY = 1 + FG = 2 + + +class LocalizerTargets(NamedTuple): + label_target: Union[ndarray, Tensor] + loc_target: Union[ndarray, Tensor] + + +class LocalizerOutputs(NamedTuple): + label_bg: Union[ndarray, Tensor] + label_stray: Union[ndarray, Tensor] + label_fg: Union[ndarray, Tensor] + loc_output: Union[ndarray, Tensor] + + +class LocalizerModule(TrainerMixin): + def __init__(self): + super().__init__() + self.divisible_size = 16 + self.min_spatial_size = 32 + self.load_checkpoint = False + self.checkpoint_search_dir = Config.CHECKPOINT_SEARCH_DIR + self.upsample = "pixelshuffle" + + self.image_channels = 5 + self.unet_channel_divider = 1 + self.out_channels = len(LocalizerOutputs.__annotations__) + + self.image_data = LocalizerTrainDataItem() + sparsity = 4 ** 6 + self.nominal_scale = self.image_data.nominal_scale + + self.module_output_item = LocalizerOutputItem() + self.module_output_item.nominal_scale = self.nominal_scale + + nominal_num_labels_fragment = 16 + nominal_fragment_len = sparsity * nominal_num_labels_fragment + self.image_data.fragment_len = nominal_fragment_len + + self.genome_data = SimulatedGenomeItem() + self.genome_data.sparsity = sparsity + nominal_num_labels = nominal_num_labels_fragment * 2 + self.genome_data.genome_len = sparsity * nominal_num_labels + + self.batch_image_size = int(nominal_fragment_len / self.nominal_scale) + + def init_task(self): + super().init_task() + + def _resize_pad_or_crop_end(self, size): + return Compose([ + SpatialPad(spatial_size=size, method=Method.END), + SpatialCrop(roi_slices=[slice(0, s) for s in size]), + ]) + + def image_input(self, segment_3d, spatial_size=None): + image_2d = segment_3d.reshape((-1, segment_3d.shape[-1])) + return Compose([ + AddChannel(), + ScaleIntensity(), + self._resize_pad_or_crop_end((self.image_channels, spatial_size)), + SqueezeDim(), + ])(image_2d) + + def train_item(self): + data = self.make_data() + + module_input = self.image_input(data.image, self.batch_image_size) + + module_target = Compose([ + self._resize_pad_or_crop_end(module_input.shape[-1:]), + ])(data.target) + + item = { + Keys.DATA_ITEM: data, + Keys.MODULE_INPUT: module_input, + Keys.MODULE_TARGET: module_target, + } + return item + + def make_data(self): + self.image_data.lat_size_min = self.image_channels + self.image_data.rng = self.rng + self.genome_data.rng = self.rng + + for trial in itertools.count(): + try: + genome_data = copy(self.genome_data) + genome_data.make_genome() + + image_data = copy(self.image_data) + image_data.sitevec = genome_data.sitevec + image_data.make_target() + except AssertionError: + if trial > Config.MAX_RETRIES: + raise + else: + return image_data + + def validation_item(self): + data = self.make_data() + item = self.inference_item(data.image) + item.data_item = data + loss_item = self.loss_func(item.output_tensor, data.target) + item.loss_item = loss_item + item.metrics = self.make_metrics(loss_item) + return item + + def _inference_forward(self, module_input: ndarray): + x = Compose([ + SpatialPad(spatial_size=self.min_spatial_size, method=Method.END), + DivisiblePad(k=self.divisible_size, method=Method.END) + ])(module_input) + + x = self.module_forward(x[None]) + x = Compose([ + ToNumpy(), + SqueezeDim(), + self._resize_pad_or_crop_end(module_input.shape[-1:]), + ])(x) + + return x + + def inference_item(self, segment_3d): + image_input = self.image_input(segment_3d) + # print("original image input shape"+ str(image_input.shape[-1:])) + + with inference_eval(self.module): + output_tensor = self._inference_forward(image_input) + + item = copy(self.module_output_item) + item.image = segment_3d + item.image_input = image_input + item.make_pred(output_tensor) + return item + + def loss_func(self, output, target): + if len(output.shape) == 2: + output = output[None] + + if len(target.shape) == 2: + target = target[None] + + assert output.shape[-1:] == target.shape[-1:] + + targets = LocalizerTargets(*torch.unbind(self.to_tensor(target), dim=1)) + outputs = LocalizerOutputs(*torch.unbind(self.to_tensor(output), dim=1)) + + label_criterion = DiceCELoss(softmax=True, to_onehot_y=True, include_background=False) + bce = torch.nn.BCEWithLogitsLoss(reduction='none') + + label_output = torch.stack([ + outputs.label_bg, + outputs.label_stray, + outputs.label_fg, + ], dim=1) + + mask = (targets.label_target > 0).float() + mask_mean = mask.mean() + assert mask_mean > 0 + + loss_tuple = LocalizerLosses( + label_loss=label_criterion(label_output, targets.label_target.long()[:, None]), + loc_loss=((mask * bce(outputs.loc_output, targets.loc_target)).mean() / mask_mean)*0, + ) + return { + Keys.LOSS_TENSOR: torch.stack(loss_tuple).mean(), + Keys.LOSSES: loss_tuple._asdict(), + } + + def make_metrics(self, step_item): + metrics_item = super().make_metrics(step_item) + return metrics_item | {k: v.detach().item() for k, v in step_item[Keys.LOSSES].items()} + + def _module_build(self): + features = numpy.stack([32, 32, 64, 128, 256, 32]) // self.unet_channel_divider + return BasicUNet( + spatial_dims=1, + features=tuple(features), + in_channels=self.image_channels, + out_channels=self.out_channels, + upsample=self.upsample, + ) + + def run_training(self): + self.log_wandb_enable = True + self.batch_size = 256 + self.checkpoint_search_dir = Config.CHECKPOINT_SEARCH_DIR + self.task_root_dir = Config.LOCALIZER_TRAINING_OUTPUT_DIR + self.run() + + +class LocalizerOutputItem: + def __init__(self): + self.image = None + self.image_input = None + self.loc_pred_delta = None + self.loc_pred = None + self.output_tensor = None + self.label_pred = None + self.outputs = None + + def make_pred(self, output_tensor): + self.output_tensor = output_tensor + self.outputs = LocalizerOutputs(*output_tensor) + self.label_pred = numpy.stack([ + self.outputs.label_bg, + self.outputs.label_stray, + self.outputs.label_fg, + ]).argmax(axis=0) + self.loc_pred_delta = numpy_sigmoid(self.outputs.loc_output) + indices = numpy.flatnonzero(self.label_pred == LocalizerEnum.FG) + self.loc_pred = indices + self.loc_pred_delta[indices] + + +if __name__ == '__main__': + LocalizerModule().run_training() diff --git a/deepom/localizer_real_data.py b/deepom/localizer_real_data.py new file mode 100644 index 0000000..5810f73 --- /dev/null +++ b/deepom/localizer_real_data.py @@ -0,0 +1,545 @@ +import torch +import wandb +import itertools +import shutil +from copy import copy +from inspect import currentframe +from traceback import print_exc +from typing import NamedTuple, Union +from monai.utils import convert_to_tensor,Method, set_determinism +from monai.losses import DiceCELoss +from monai.networks.nets import BasicUNet +from monai.transforms import Compose, SelectItemsd, SpatialPad, SpatialCrop, AddChannel, ScaleIntensity, SqueezeDim, \ + DivisiblePad, ToNumpy +import numpy +from matplotlib.pyplot import eventplot, imshow, figure, xlim, savefig, gca +from numpy import ndarray, stack, int_ +from numpy.random import default_rng +from tqdm.auto import tqdm, trange +from torch import Tensor, from_numpy +from torch.optim import Adam, SGD +from torch.optim.lr_scheduler import ReduceLROnPlateau +from deepom.config import Config +from deepom.aligner import Aligner +from deepom.localizer import LocalizerModule +from deepom.bionano_utils import XMAPItem, BionanoRefAlignerRun, MoleculeSelector, BNXItemCrop, BionanoFileData +from deepom.data_fetcher import DataFetcher +from deepom.my_utils import dice_loss, MetaBase, torch_temporary_seed, fp_precentage ,fn_precentage +from deepom.utils import path_mkdir, generate_name, Paths, asdict_recursive, nested_dict_filter_types, inference_eval, numpy_sigmoid, find_file, num_module_params, pickle_dump, pickle_load +from deepom.common_types import LocalizerEnum, LocalizerLosses, LocalizerGT, LocalizerOutputs, DataItem + +from torch.utils.data import TensorDataset +from torch.utils.data.dataloader import DataLoader + + +class LocalizerOutputItem: + def __init__(self): + self.image = None + self.image_input = None + self.loc_pred_delta = None + self.loc_pred = None + self.output_tensor = None + self.label_pred = None + self.outputs = None + + + def make_pred(self, output_tensor): + self.output_tensor = output_tensor + self.outputs = LocalizerOutputs(*output_tensor) + self.label_pred = torch.sigmoid(self.outputs.label_output) > 0.5 + self.loc_pred_delta = numpy_sigmoid(self.outputs.loc_output) + indices = numpy.flatnonzero(self.label_pred.numpy()) + self.loc_pred = indices + self.loc_pred_delta[indices] + + +class DataLocalizer(metaclass=MetaBase): + def __init__(self): + self.image_channels = 5 + self.divisible_size = 16 + self.min_spatial_size = 32 + self.out_channels = len(LocalizerOutputs.__annotations__) + self.upsample = "pixelshuffle" + self.unet_channel_divider = 1 + self.net = self._module_build() + self.device = "cuda" if torch.cuda.is_available() else "cpu" + self.net.to(self.device) + self.dtype = torch.float32 + self.lr = 1e-3 + self.optimizer = Adam(self.net.parameters(), lr=self.lr) + self.scheduler = ReduceLROnPlateau(self.optimizer, 'min') + self.log_metrics_every = 100 + self.batch_size = 1 + self.epochs = 5 + self.log_images_every = 1000 + self.validation_every = None + self.checkpoint_every = 100 + self.nominal_scale = Config.BIONANO_NOMINAL_SCALE + + self.module_output_item = LocalizerOutputItem() + self.module_output_item.nominal_scale = self.nominal_scale + + self.top_mol_num = 1 #Amount of actual images loaded by the datafetcher + # self.molecule_amount = 240 #Amount of samples to be used in the dataset + self.test_data_ratio = 0 #Validation to train set ratios + self.genome_size = 24 + self.threshold = 0.99 + self.data_fetcher = DataFetcher(self.top_mol_num, self.threshold) + self.simulated_images = True + + # Reproducability + self.seed = 42 + self.name_seed = 343 + self.init_rng() + # Logging Info + self.run_name = None + self.run_root_dir = None + + self.step_index = 0 + self.tqdm = None + self.tqdm_enable = True + self.log_wandb_enable = True + self.log_tqdm_postfix = {} + + self.paths_config = Paths() + self.task_name = type(self).__name__ #DataLocalizer + self.task_root_dir = Config.LOCALIZER_TRAINING_OUTPUT_DIR + self.data_root_dir = Config.GROUND_TRUTH_DIR + self.checkpoint_search_dir = Config.SECOND_CHECKPOINT_SEARCH_DIR + self.load_checkpoint = False + self.save_data = True + self.best_loss = numpy.inf + self.early_stopping = 200 + self.num_stagnant_epochs = 0 + self.stop_training = False + + self.eval_localizer = self.data_fetcher.localizer #yevgeni's + self.checkpoint_file = Config.CHECKPOINT_FILE + self.dice_smooth = 100 + self.test_data = None + + def init_rng(self): + + set_determinism(seed=self.seed) + self.rng = default_rng(seed=self.seed) + + def _init_refs(): + cmap_file_data = BionanoFileData() + cmap_file_data.file = Config.REF_CMAP_FILE + cmap_file_data.read_bionano_file() + + return Series({ + ref_id: ref_df[ref_df["LabelChannel"] == 1]["Position"].values + for ref_id, ref_df in cmap_file_data.file_df.groupby("CMapId") + }) + + def _module_build(self): + features = stack([32, 64, 64, 128, 256, 32]) // self.unet_channel_divider + return BasicUNet( + spatial_dims=1, + features=tuple(features), + in_channels=self.image_channels, + out_channels=self.out_channels, + upsample=self.upsample, + ) + + def init_ensure_module(self): + self.net = self._module_build() + self._checkpoint_load() + self.net.to(self.device) + self.__num_module_params = num_module_params(self.net) + + def _checkpoint_load(self): + if self.load_checkpoint: + try: + if self.checkpoint_search_dir is None: + search_dir = self.task_root_dir + print("no checkpoint dir found") + else: + search_dir = self.checkpoint_search_dir + print(f"search dir is {search_dir}") + file = find_file(search_dir=search_dir, suffix=self.checkpoint_file) + except (ValueError, RuntimeError): + print_exc() + raise + else: + print('loading checkpoint: ', file, '\n\n') + self.net.load_state_dict(torch.load(file, map_location=self.device)) + + + def loss_func(self, output, target): + + outputs = LocalizerOutputs(*torch.unbind(self.to_tensor(output), dim=1)) + + bce = torch.nn.BCEWithLogitsLoss(reduction='none') + + # label_output = torch.stack([ + # outputs.label_output, + # ], dim=1) + + # print(f"Target label target shape {target.label_target.shape}") + + mask = (target.label_target > 0).astype(float) + mask_mean = mask.mean() + assert mask_mean > 0 + + self.__logger.debug(f"Label output shape {outputs.label_output.shape}") + self.__logger.debug(f"{target.label_target[:, None].shape}") + label_output = torch.sigmoid(outputs.label_output) + # loc_weight = 0.01 + loss_tuple = LocalizerLosses( + label_loss=dice_loss(label_output, from_numpy(target.label_target),self.dice_smooth), + loc_loss=((from_numpy(mask) * bce(torch.flatten(outputs.loc_output), + from_numpy(target.loc_target))).mean() / mask_mean), + ) + + label_pred = (label_output > 0.5).type(torch.int8) + loc_pred_delta = numpy_sigmoid(outputs.loc_output.detach())[0] + indices = numpy.flatnonzero(label_pred.detach().numpy()) + # print(f"indices {indices}") + prediction = indices + loc_pred_delta[indices] + + gt_indices = numpy.flatnonzero(target.label_target) + ground_truth = from_numpy(gt_indices + target.loc_target[gt_indices]) + + # print(f"prediction: {prediction} ") + # print(f"ground truth : {ground_truth}") + # print(f"sanity check: {prediction") + + fp = fp_precentage(prediction, ground_truth) + fn = fn_precentage(prediction, ground_truth) + return { + "loss_tensor": torch.stack(loss_tuple).mean(), + "losses": loss_tuple._asdict(), + "false_positive": fp, + "false_negative": fn + } + + def step_events(self, step_item): + self.step_index +=1 + self.tqdm.update() + log_metrics_every = max(1, self.log_metrics_every // self.batch_size) + log_images_every = max(1, self.log_images_every // self.batch_size) + #validation_every = max(1, self.validation_every // self.batch_size) + + # if self.step_index % log_images_every == 0: + # self.log_train_batch(step_item) + + + if self.step_index % log_metrics_every == 0: + metrics_item = step_item + self._log_update_tqdm_postfix({"total loss":metrics_item["loss_tensor"].item()}) + self.log_metrics({"train": metrics_item}) + self.scheduler.step(metrics_item["loss_tensor"].item()) + if (self.best_loss > metrics_item["loss_tensor"].item()): + self.best_loss = metrics_item["loss_tensor"].item() + if self.checkpoint_every is not None: + checkpoint_every = max(1, self.checkpoint_every // self.batch_size) + if self.step_index % checkpoint_every == 0: + self.checkpoint_save() + + if self.early_stopping is not None: + self.num_stagnant_epochs = 0 + + else: + self.num_stagnant_epochs += 1 + + if self.early_stopping is not None and self.num_stagnant_epochs >= self.early_stopping: + self.stop_training = True + + def validation_step(self,step_item,image_input,target:LocalizerGT): + # print(len(image_input)) + our_fp = step_item["false_positive"] + our_fn = step_item["false_negative"] + prediction = numpy.flatnonzero(self.eval_localizer.inference_item(image_input).loc_pred) + + gt_indices = numpy.flatnonzero(target.label_target) + ground_truth = (gt_indices + target.loc_target[gt_indices]) + # print(prediction) + # print(ground_truth) + eval_fp = fp_precentage(prediction, ground_truth) + eval_fn = fn_precentage(prediction, ground_truth) + + print(f" our fp: {our_fp}, eval fp {eval_fp}") + print(f" our fn: {our_fn}, eval fn {eval_fn}") + + + def checkpoint_save(self): + checkpoint_file = self.paths_config.out_file_mkdir(self.checkpoint_search_dir, self.checkpoint_file) + print(f"saving model in {checkpoint_file}") + if checkpoint_file.exists(): + shutil.copy(checkpoint_file, checkpoint_file.with_suffix('.bkp')) + self._log_update_tqdm_postfix({"ckpt": self.step_index}) + torch.save(self.net.state_dict(), checkpoint_file) + + + + def _resize_pad_or_crop_end(self, size): + return Compose([ + SpatialPad(spatial_size=size, method=Method.END), + SpatialCrop(roi_slices=[slice(0, s) for s in size]), + ]) + + def image_input(self, segment_3d, spatial_size=None): + image_2d = segment_3d.reshape((-1, segment_3d.shape[-1])) + return Compose([ + AddChannel(), + ScaleIntensity(), + self._resize_pad_or_crop_end((self.image_channels, spatial_size)), + SqueezeDim(), + ])(image_2d) + + def generate_random_task_name(self): + with torch_temporary_seed(self.name_seed): + self.run_name = generate_name(self.task_name) + # if self.test_mode_enable: + # self.task_root_dir = self.task_root_dir / Config.TEST_DIR + self.run_root_dir = (self.task_root_dir / self.run_name) + + def task_params_dict(self): + data = asdict_recursive(self, include_modules=[self.__module__], prefix=Config.WANDB_PREFIX) + data = nested_dict_filter_types(data) + return data + + def init_log(self): + self.tqdm = tqdm(desc=self.run_name, disable=not self.tqdm_enable) + + if self.log_wandb_enable: + path_mkdir(self.run_root_dir) + wandb.init( + name=self.run_name, dir=str(self.run_root_dir), + mode=None, + project=Config.PROJECT_NAME, + ) + wandb.config.update(self.task_params_dict()) + + def log_metrics(self, metrics_dict): + if self.log_wandb_enable: + self.__logger.debug(metrics_dict) + wandb.log(metrics_dict, step=self.step_index) + + def _log_update_tqdm_postfix(self, metrics_dict): + self.log_tqdm_postfix |= metrics_dict + self.tqdm.set_postfix(self.log_tqdm_postfix) + + + def to_tensor(self, x): + return convert_to_tensor(x, device=self.device, dtype=self.dtype) + + def forward(self, x): + return self.net(self.to_tensor(x)) + + def _train_step(self, data): + segment_image = data.molecule.bionano_image.segment_image[0] + segment_image[0:3] = 0 + segment_image[-3:] = 0 + image_input = self.image_input(data.molecule.bionano_image.segment_image[0]) + x = Compose([ + SpatialPad(spatial_size=self.min_spatial_size, method=Method.END), + DivisiblePad(k=self.divisible_size, method=Method.END) + ])(image_input) + #print(data.ground_truth.label_target.shape[0],x.shape[-1]) + x, data = self.crop_to_min(x, data) + #print(data.ground_truth.label_target.shape[0],x.shape[-1]) + # data = Compose([ + # self._resize_pad_or_crop_end(x.shape[-1:]), + # ])(data.ground_truth) + # print(f"ground_truth shape: {data.ground_truth.shape}, input shape: {x.shape}") + self.__logger.debug("gt :"+ str(data.ground_truth.label_target.shape)) + + self.optimizer.zero_grad() + + output = self.forward(x[None]) + loss = self.loss_func(output, data.ground_truth) + + loss["loss_tensor"].backward() + self.optimizer.step() + + step_item = loss + + self.step_events(step_item) + + if self.validation_every is not None and self.step_index % self.validation_every == 0: + self.validation_step(step_item,data.molecule.bionano_image.segment_image[0][:x.shape[-1]],data.ground_truth) + + def crop_to_min(self, x, mol): + if x.shape[-1]< mol.ground_truth.label_target.shape[0]: + a = mol.ground_truth.label_target[:x.shape[-1]] + b = mol.ground_truth.loc_target[:x.shape[-1]] + ground_truth = LocalizerGT(a,b) + item = DataItem(mol.molecule, ground_truth) + return x, item + else: + x = x[:,0:mol.ground_truth.label_target.shape[0]] + return x, mol + + + def get_ground_truth(self,mol_index): + if self.simulated_images: + return self.data_fetcher.generate_ground_truth_simulated(mol_index) + else: + return self.data_fetcher.generate_ground_truth(mol_index) + + def prepare_data(self): + num_of_test_molecules = round(self.genome_size * self.test_data_ratio) + molecule_index_list = range(1, self.genome_size+1) # by default, list from 1 to 24 + test_molecules_ids = self.rng.choice(molecule_index_list, size= num_of_test_molecules, replace = False) + train_molecules_ids = [i for i in molecule_index_list if i not in test_molecules_ids] + + # saving test molecule id list for benchmark use + self.output_test_list_pickle(test_molecules_ids) + print(f"test_molecules_ids: {test_molecules_ids}") + train_data = [] + test_data = [] + + for mol_index in trange(self.top_mol_num,desc="Creating Ground Truth Data",unit="molecules"): + mol, a, b = self.get_ground_truth(mol_index) + if mol != None: + ground_truth = LocalizerGT(a,b) + item = DataItem(mol, ground_truth) + + if mol.xmap_item.ref_id in train_molecules_ids: + train_data.append(item) + else: + test_data.append(item) + + print("train data size: " + str(len(train_data))) + print("test data size: " + str(len(test_data))) + + if self.save_data: + self.output_pickle_dump(train_data,f".train_data_simulated_images_{self.top_mol_num}.pickle") + self.output_pickle_dump(test_data,f".test_data_simulated_images_{self.top_mol_num}.pickle") + + self.test_data = test_data + return train_data, test_data + + + def train(self, train_data): + try: + self.generate_random_task_name() + self.init_rng() + self.init_log() + self.stop_training = False + + + for epoch in trange(self.epochs): + with tqdm(train_data,unit="batch") as train_data_tqdm: + for batch in train_data_tqdm: + train_data_tqdm.set_description(f"Epoch {epoch}") + self._train_step(batch) + if self.stop_training: + break + + + finally: + if self.log_wandb_enable: + wandb.finish() + + + def _train_data_loader(self,data): + dataset = TensorDataset(torch.Tensor(data)) + print(len(data)) + self.train_data_loader = DataLoader(dataset, batch_size=self.batch_size, num_workers=0) + + def _data_collate(self, items: list): + items_to_batch = Compose([ + SelectItemsd(keys=[Keys.MODULE_INPUT, Keys.MODULE_TARGET], allow_missing_keys=True) + ])(items) + batch = list_data_collate(items_to_batch) | {Keys.BATCH_ITEMS: items} + return batch + + def _inference_forward(self, module_input: ndarray): + x = Compose([ + SpatialPad(spatial_size=self.min_spatial_size, method=Method.END), + DivisiblePad(k=self.divisible_size, method=Method.END) + ])(module_input) + + # zeroing first and last pixel rows + # x[0] = 0 + # x[-1] = 0 + + x = self.forward(x[None]) + x = Compose([ + ToNumpy(), + SqueezeDim(), + self._resize_pad_or_crop_end(module_input.shape[-1:]), + ])(x) + + return x + + def inference_item(self, segment_3d): + segment_3d[0:3] = 0 + segment_3d[-3:] = 0 + figure(figsize=(30, 3)) + target_width = 5 + source_width = segment_3d.shape[0] // 2 + 1 + print_input = segment_3d[source_width - target_width // 2: source_width + target_width // 2 + 1] + # segment_3d[source_width - target_width // 2: source_width + target_width // 2 + 1][0] = 0 + # segment_3d[source_width - target_width // 2: source_width + target_width // 2 + 1][-1] = 0 + imshow(segment_3d, aspect="auto", cmap="gray") + + print(f"shape segment: {segment_3d.shape}") + + + image_input = self.image_input(segment_3d) + figure(figsize=(30, 3)) + target_width = 5 + source_width = image_input.shape[0] // 2 + 1 + print_input = image_input[source_width - target_width // 2: source_width + target_width // 2 + 1] + imshow(print_input, aspect="auto", cmap="gray") + + print(f"image_input size: {image_input.shape}") + + # image_input[0] = 0 + # image_input[-1] = 0 + + print(f"image_input size: {type(image_input)}") + + with inference_eval(self.net): + output_tensor = self._inference_forward(image_input) + + item = copy(self.module_output_item) + item.image = segment_3d + item.image_input = image_input + item.make_pred(self.to_tensor(output_tensor)) + + return item + + def output_pickle_dump(self, obj, suffix): + file = Config.GROUND_TRUTH_DIR.with_suffix(suffix) + print(file) + pickle_dump(file, obj) + + def pickle_load(self,file): + return pickle_load(file) + + def output_test_list_pickle(self, obj): + file = Config.TEST_LIST_FILE.with_suffix(".pickle") + print(f"test list file: {file}") + pickle_dump(file, obj) + + def validate_predictions(self): + self.tqdm = tqdm(desc="validating predictions", disable=not self.tqdm_enable) + + fp_yvg = [] + fp_our = [] + fn_yvg = [] + fn_our = [] + + with tqdm(self.test_data) as test_data: + for item in test_data: + image = item.molecule.bionano_image.segment_image[0] + gt_indices = numpy.flatnonzero(item.ground_truth.label_target) + ground_truth = (gt_indices + item.ground_truth.loc_target[gt_indices]) + + our_pred = self.inference_item(image).loc_pred + yvg_pred = self.eval_localizer.inference_item(image).loc_pred + + fp_yvg.append(fp_precentage(yvg_pred, ground_truth)) + fn_yvg.append(fn_precentage(yvg_pred, ground_truth)) + fp_our.append(fp_precentage(our_pred, ground_truth)) + fn_our.append(fn_precentage(our_pred, ground_truth)) + self.tqdm.update() + + + print(f"means yevgeni: fp={numpy.array(fp_yvg).mean()}, fn={numpy.array(fn_yvg).mean()}") + print(f"means ours: fp={numpy.array(fp_our).mean()}, fn={numpy.array(fn_our).mean()}") diff --git a/deepom/my_utils.py b/deepom/my_utils.py new file mode 100644 index 0000000..8cf83cd --- /dev/null +++ b/deepom/my_utils.py @@ -0,0 +1,157 @@ +from deepom.aligner import Aligner + +import numpy +from numba import njit +from numpy import ndarray +import torch +from deepom.utils import is_sorted, ndargmax +import logging +import sys +from contextlib import contextmanager + +def get_aligner(): + aligner = Aligner() + aligner.align_params = {} + return aligner + + +def get_scaler_from_aligner(aligner): + return (aligner.alignment_ref[-1]-aligner.alignment_ref[0]) /\ + (aligner.alignment_qry[-1]-aligner.alignment_qry[0]) + +def plot_sequences(image,ref,qry,max_index,save=False,name = "plot"): + figure(figsize=(30, 3)) + imshow(image, aspect="auto", cmap="gray") + eventplot([inference_item.loc_pred, selector.selected[i].locs / 375], colors=["b", "r"]) + eventplot([ref,qry], colors=["b", "r"]) + max_index = max(max_index, len(image)) + +def overlap_percentage(xlist,ylist): + + assert is_sorted(xlist) and is_sorted(ylist) + + # print(f"xlist :{len(xlist)}") + # print(f"ylist :{len(ylist)}") + min1 = xlist[0] + max1 = xlist[-1] + min2 = ylist[0] + max2 = ylist[-1] + + overlap = max(0, min(max1, max2) - max(min1, min2)) + length = max1-min1 + max2-min2 + lengthx = max1-min1 + lengthy = max2-min2 + + return 2*overlap/length + +def overlap_fraction(parent_seg, crop_seg): + (x, y), (a, b) = sorted(parent_seg), sorted(crop_seg) + assert (a < b) and (x < y) + intersection = max(0, min(b, y) - max(a, x)) + overlap1 = intersection / (b - a) + overlap2 = intersection / (y - x) + overlap = min(overlap1,overlap2) + return overlap + +def fp_precentage(prediction, gt, delta=1): + try: + misaligned = 0 + for x in prediction: + if x > gt[-1]: + # print(x) + misaligned += 1 + continue + for y in gt: + if y > x+delta: + # print(x) + misaligned += 1 + break + if y>=x-delta and y<=x+delta: + break + return (misaligned)/(len(prediction)) + except Exception as e: + print("got exception in fp percentage ") + return 1 + +def fn_precentage(prediction, gt, delta=1): + return fp_precentage(gt, prediction, delta) + +''' +Loss functions and Neural Network Related Utils +''' +def dice_loss(y_pred,y_true,smooth=100): + return 1 - dice_coef(y_pred,y_true,smooth) + +def dice_coef(y_pred,y_true, smooth=100): + y_true_f = torch.flatten(y_true) + y_pred_f = torch.flatten(y_pred) + intersection = torch.sum(y_true_f * y_pred_f) + dice = (2. * intersection + smooth) / (torch.sum(y_true_f) + torch.sum(y_pred_f) + smooth) + return dice + + +# def tversky(prediction, ground_truth, weight_map=None, alpha=0.5, beta=0.5): + +# prediction = tf.to_float(prediction) +# if len(ground_truth.shape) == len(prediction.shape): +# ground_truth = ground_truth[..., -1] +# one_hot = labels_to_one_hot(ground_truth, tf.shape(prediction)[-1]) +# one_hot = tf.sparse_tensor_to_dense(one_hot) + +# p0 = prediction +# p1 = 1 - prediction +# g0 = one_hot +# g1 = 1 - one_hot + +# if weight_map is not None: +# num_classes = prediction.shape[1].value +# weight_map_flattened = tf.reshape(weight_map, [-1]) +# weight_map_expanded = tf.expand_dims(weight_map_flattened, 1) +# weight_map_nclasses = tf.tile(weight_map_expanded, [1, num_classes]) +# else: +# weight_map_nclasses = 1 + +# tp = tf.reduce_sum(weight_map_nclasses * p0 * g0) +# fp = alpha * tf.reduce_sum(weight_map_nclasses * p0 * g1) +# fn = beta * tf.reduce_sum(weight_map_nclasses * p1 * g0) + +# EPSILON = 0.00001 +# numerator = tp +# denominator = tp + fp + fn + EPSILON +# score = numerator / denominator +# return 1.0 - tf.reduce_mean(score) +''' +Logger meta class +''' + +@contextmanager +def torch_temporary_seed(seed: int): + """ + A context manager which temporarily sets torch's random seed, then sets the random + number generator state back to its previous state. + :param seed: The temporary seed to set. + """ + + default_state = torch.random.get_rng_state() + + try: + torch.random.manual_seed(seed) + yield + finally: + torch.random.set_rng_state(default_state) + + + +class MetaBase(type): + def __init__(cls, *args): + super().__init__(*args) + + # Explicit name mangling + logger_attribute_name = '_' + cls.__name__ + '__logger' + + # Logger name derived accounting for inheritance for the bonus marks + logger_name = '.'.join([c.__name__ for c in cls.mro()[-2::-1]]) + + setattr(cls, logger_attribute_name, logging.getLogger(logger_name)) + + \ No newline at end of file diff --git a/deepom/train.py b/deepom/train.py new file mode 100755 index 0000000..f6da3f9 --- /dev/null +++ b/deepom/train.py @@ -0,0 +1,73 @@ +#!/usr/bin/env python +import argparse + +from deepom.localizer_real_data import DataLocalizer +import timeit +import sys +import numpy +from deepom.config import Config + + + +def train_model(train_size,batch_size,simulated,create_data,epochs,checkpoint_file): + localizer = DataLocalizer() + localizer.top_mol_num = train_size + localizer.checkpoint_file = checkpoint_file if checkpoint_file.endswith(".pickle") else checkpoint_file+".pickle" + localizer.simulated_images = simulated + assert localizer.simulated_images + if create_data: + train_data, test_data = localizer.prepare_data() + else: + train_file_name = ".train_data_" + if simulated: + train_file_name+="simulated_" + + train_file_name+= "images_512.pickle" + + print(train_file_name) + try: + train_data = localizer.pickle_load(Config.GROUND_TRUTH_DIR.with_suffix(train_file_name)) + except FileNotFoundError: + pass + localizer.log_wandb_enable = True + localizer.epochs = epochs + localizer.train(train_data) + if localizer.stop_training == True: + print("Model stopped training early") + else: + print("training complete") +# test_data = localizer.pickle_load(Config.GROUND_TRUTH_DIR.with_suffix(".test_data_simulated_images_512.pickle")) + + +def check_positive(value): + ivalue = int(value) + if ivalue <= 0: + raise argparse.ArgumentTypeError("%s is an invalid positive int value" % value) + return ivalue + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument("train_size", help="the number of samples the model will train on", type=check_positive, default=512) + parser.add_argument("-v", "--verbose", action="store_true") + parser.add_argument("-s", "--simulated", action="store_true", default=True,help="should the model train on real or simulated data") + parser.add_argument("batch_size", help="the batch size per step",type=int,default=1) + parser.add_argument("-d", "--create-data", action="store_true", default=False,help="should new data be created before training") + parser.add_argument("checkpoint_name",type=str,default=Config.CHECKPOINT_FILE) + args = parser.parse_args() + # parser.add_argument("epochs", type=check_positive, help="number of training epochs", default=10) + + train_size = args.train_size + simulated = args.simulated + batch_size = args.batch_size + create_data = args.create_data + checkpoint_name = args.checkpoint_name + epochs = 500 + print(f"train size {train_size}") + print(f"simulated {simulated}") + print(f"batch size {batch_size}") + print(f"create_data {create_data}") + print(f"checkpoint_name {checkpoint_name}") + train_model(train_size,batch_size,simulated,create_data,epochs,checkpoint_name) + + + \ No newline at end of file diff --git a/deepom/utils.py b/deepom/utils.py index f07f79e..8906ce6 100644 --- a/deepom/utils.py +++ b/deepom/utils.py @@ -230,7 +230,7 @@ def is_sorted(a): def numpy_sigmoid(x): - return torch.sigmoid(torch.from_numpy(x)).numpy() + return torch.sigmoid(x).numpy() def set_names(cls): diff --git a/figures/benchmark_figure.ipynb b/figures/benchmark_figure.ipynb index 4ca2e5c..3b0c2ab 100644 --- a/figures/benchmark_figure.ipynb +++ b/figures/benchmark_figure.ipynb @@ -14,7 +14,9 @@ }, { "data": { - "text/plain": "" + "text/plain": [ + "" + ] }, "execution_count": 1, "metadata": {}, @@ -22,8 +24,10 @@ }, { "data": { - "text/plain": "
", - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEGCAYAAABy53LJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAAsTAAALEwEAmpwYAABwnklEQVR4nO2dd3gc1fW/37O76l3uRe69FzCdYHoCoQdISHBCeiHwS0INPYFAypceEkIoCb2E3gzGBtMMNq5yk4tsdVm9a8uc3x+zknalXWklrSSX+z7PPjNzy9w7q9WeveWcj6gqBoPBYDBEimOgO2AwGAyGAwtjOAwGg8HQLYzhMBgMBkO3MIbDYDAYDN3CGA6DwWAwdAvXQHegrxk8eLCOGzduoLvRKfX19SQlJQ10N4Lojz5Fu41o3K+n9+hOvWiXjUaZzvJ7khcqvbdl26f1pExn19HI6+q8J/nhjpGUieQIhMxbs2ZNmaoO6fAHA1DVg/q1cOFC3d9Zvnz5QHehA/3Rp2i3EY379fQe3akX7bLRKNNZfk/yQqX3tmz7tJ6U6ew6GnldnfckP9wxkjKRHMPlAas1zPeqmaoyGAwGQ7foM8MhIo+KSKmIbApIyxSR90Qkx3/M8KeLiNwnIjtEZIOILPCnTxWRNf60o/xpLhF5X0QS+6rvBoPBYAhPX444HgdOb5d2LbBMVScDy/zXAF8HJvtfPwEe8qf/FLgC+AbwO3/az4EnVbWhz3puMBgMhrD02eK4qn4kIuPaJZ8NnOA/fwJYAVzjT/+Pf17tcxFJF5ERgAdI9L88IpIOfJOOBqlbeDwe8vPzaWpq6s1tokZaWhpbtmwZ6G4E0R99inYb0bhfT+/RnXrRLhuNMp3l9ySvJT0+Pp7Ro0cTExPTaf8MBxaifRirym843lDVWf7rKlVN958LUKmq6SLyBnCnqn7sz1uGbVBKgf8AcdijjyXA66q6oot2f4I9cmHYsGELn3322aD85ORkhg0bRlpaGnY3Bhafz4fT6RzobgTRH32KdhvRuF9P79GdetEuG40yneX3JM/n8+FwOKiurqakpIS6ujrq6upITk7uUDZUeiRpPSnT2XU08ro670l+uGMkZSI5AiHzFi9evEZVD+vwB4O+3VUFjAM2BVxXtcuv9B/fAI4NSF8GHNau7CTgOWAY8F//+ZSu+hBqV9XmzZvVsqwO6QNFTU3NQHehA/3Rp2i3EY379fQe3akX7bLRKNNZfk/yWtIty9LNmzerqtlV1dN8s6sKSvxTUPiPpf70AiAroNxof1ogtwM3AL8GHgGuBm7uaUf2h5GGwXCwY/7PDk7623C8hj3dhP/4akD6pf7dVUcC1apa1FJJRL4GFKpqDvZ6h+V/mZ1VBoPB0M/05XbcZ4DPgKkiki8iPwTuBE4RkRzgZP81wFvALmAH8C/gFwH3EeyRxh/8SQ8D9wJvAn/tq/73NU6nk3nz5jFz5kyOPvpo/va3v2FZVtTbcbvdXHnllUyaNInJkydz9tlnk5+f35ovInz3u99tvfZ6vQwZMoRvfetbUe+LwWCIDJ+lqEJdsxefpZTVNeO1lJKaJrw+pai6kcKqRjw+Jb+yAY/PYm95A26fRW5ZPW6vxa59dX3Wv77cVfXtMFknhSirwC/D3EeBUwKutwALotHHgSQhIYF169YBsGvXLn7yk59QU1PDrbfeGtV2rr/+empra9m2bRtOp5PHHnuM8847j1WrViEiJCUlsWnTJhobG0lISOC9995j1KhRUe2DwWBoo9nro9lr4bOU0pomPJbi9lns3FdHs9diU0E1qtDk9bF7Xz1un0VRVRMen0VpTTMey6Ks1g2A17KorPfgtZTqRg8+S6lt8uJTZU1uJat2ukkZXxn1ZzCe4xGyZk8lDy7fwZo90f8jDBkyhIcffpgHHngAVcXn83HVVVdx+OGHM2fOHP75z3+2lv3LX/7Smn7zzfYST25uLtOmTeOSSy5h+vTpXHDBBTQ0NNDQ0MBjjz3G3Xff3brz5Qc/+AFxcXF88MEHrff8xje+wZtvvgnAM888w7e/Hc7mGwyGnuKzFI9PySmpY0+ZPTooqWmmos6Nz1Iamn1Yao80AvH4lJU5+3h2q4d3NhWxvdLHV3sqWbW7nDUlPj7YWsrHBV7e3FDI+3u9vLA6j/9udnPt/zbyYo6HSx75nB2Vvqg+y0Ef5LArbn09m82FNZ2WqW3ysLW4FkvBITBteAop8eH3pc8YmcrN35zZrX5MmDABn89HaWkpr776KmlpaXz55Zc0NzdzzDHHcOqpp5KTk0NOTg5ffPEFqspZZ53FRx99xJgxY9i2bRv//ve/OeaYY7jsssv4+9//zqmnnsqYMWNITU0Nauuwww4jOzubk06yB38XX3wxt912G2eeeSYbNmzgsssuY/ny5d3qv8FgCI/PUraX1OK1LLYU1rCxoJphXotRqtQ1e8mrtcjfVc72PC+e8t3sq20if18z1Z+toqrBA2wD4MOCnfYNv8puu/mm7fZx6y77mLMnqG2P12JrhTEc/U5NkxfL/yvAUvu6M8PRW5YuXcqGDRt48cUXAaiuriYnJ4elS5eydOlS5s+fD9h7uHNychgzZgxZWVkcc8wxAHz3u9/lvvvu49RTT42ovTlz5pCbm8szzzzDN77xjb55KIPhEKTJ46OwqhG3z8LrUzbs8/HPDza0fp/cu/Yz3L6WtU3bkTLWWcSQlDhSXcKU0ZnkFe1jW6WFAgIcNcLBOUfPIsbpoHzPZrImz6Zs9yayps6lbOd6xk5fyKdffsn96314vRYxLgfTMqPrk3XIG45IRgZr9lRyySOf4/H/Ee69eD4Lx2ZEtR+7du3C6XQydOhQVJX777+f0047LajMu+++y3XXXcdPf/rToPTc3NwO2x5FhIkTJ7J3715qa2tJSUlpe541azjzzDODyp911ln87ne/Y8WKFZSXl0f12QyGQw3LUrw+ZUdpXevU05e5Ffx7k6fVaABMHJLE0ZMG46jOZ/q0GXiKtzJ9zmGICPlbVjN6+mQ++rySXeu8eL0WLpeDY0a5mD7CnkWIL3cwMj0BK17ISIyl3iXEuhxMSnNy+5kTWZW9k2+ffDi1u9dH9fnMGkcELBybwVM/OpLfnDqVp350ZNSNRllZGT/72c/41a9+hYhw2mmn8dBDD+HxeADYvn079fX1nHbaaTz66KOt3p4FBQWUltquMHv37uWzzz4D4Omnn+bYY48lKSmJJUuW8Jvf/Aafzx6q/uc//6GhoYETTzwxqA+XXXYZN998M7Nnz47qsxkMhxrVjR62l9bisSxU7cXw57Z5uO2NzaTFQYxTcAjEOOCyY8ZzzrxRLBjqZPKwFFJjpcOPwAlpDm4/exbfnOji9rOmMzFVcLhrcDZVIJaXmLoCHD43cVU7cHibiC/biMPXyLz4Qs6cGBv17yswI46IWTg2I6p/gMbGRubNm4fH48HhcLR+wQP86Ec/Ijc3lwULFqCqDBkyhFdeeYVTTz2VLVu2cNRRRwF2mIAnn3wSp9PJ1KlTefDBB7nsssuYMWMGP//5zwH405/+xO9+9zumTJmCw+Fg2rRpvPzyyx0+nKNHj+bXv/511J7PYDjUaPb6cHvtbbEt7Cmv5y/vbmNPhY+z547kpMxymjOn+tc4ipjmHzmgIN4mRC2cTZWI5UF8HmJrcnH4mjkiuZj0LC+zUorYVNHMIHc+DhEK8TLYUUuBWAyO95LnEIamxJFX4mB4ajwFVfV98qzGcAwQLSMAoMNUksPh4I477uCOO+7oUO+KK67giiuuCErLzc3F5XLx5JNPdigfFxfH/fffz/333x+yHy2jl0BOOOEEFi5cGPGzGAyHOqU1TZTWNuPzz0upKsvzvLy8Yh1JcS5+NS+G046dQP6WCiale5idrOzZ4yGuYhtieXD6Gkmr20mx5Wa4lhDjclDssJiY6qPIKYxJc7HL6WBEWjzbnLZRAHA5HAxOjsXpcJCZGIvTIaQluHA4hJTqbYzZ8znkRd9P2hgOg8FgiADbKU9RQLEXvpu9Fs1ee1ttC1UNbu5dlsPqPV4OG5vBFSdNpm7PBgDE8pLmKSEhxkGhA8akOYlxxlCwr4aszAR2FlWTmRRrlxXB5fDPDJRkMyZ/JQw+DhgU3DF3A4kNeZC3hxHFOdDQzOzdG6FqPeNReOJFUmffQltg8t5jDMdBwLhx49i0aVPXBQ0GQyuqiqWwr7aZBreXZq/F1uIaVLEd8Dy+Vme8Ro8vaNt+k8dHTok9WrcCHC+yy308+dla6pu9XDTFxSWnzEBEqANc9cXE4GVUuj1acIgQH9PFMrPlZXDZKvjsAcZbXtj7AjMz5sNeF9SXcmx1MXzSwCJ/8akA4iDVEQ8oAuBzk14V3e8HYzgMBsMhgWUpltphO+qbvTS4fTR7fRRX27o8lioeb5sRUOjgjBcOt9fiic9yeW29h7GZifzhrFm49m1pXUsUy8vo2BpKHA4oyYbCdaQ2ZYE7FeqKyazYBpvdjM/dBcV1UFfCkZWF8GkVs9TerisA6iOzagPIWEgZQXHcZEZnjWNzVRwzpk3ms0LhqHnT2LjqUxZsvh3L58HhjKUqfVYU30ljOAwGw0GK12fhU6WwqpEGt5cmjz2tVBowrRQNiuos7nphHbnlDZww2smvzpxLnMtJ/j47P7GpmDjxkRLnIrPiK/j0r6AW8wE22mXm+O+VJU5IHgbJQ6lKn8Xw0ePILalmXNFbqOVFnLGsn/F7Fhx1PAA7sosZPXM4pdnFzBg+nObyYnC4qEmdAmf+H7kbPmfCiZdSszO6gqkDYjhE5Argx9hG9F+qeo+IZGJrbIwDcoELVbVSRM4HbgMqgHNUtVxEJgJ3qOpFA9F/g8Gw/1Ld6KGkpolmj4Xba1Fe5+6yztaiGj7O9XJsek3bTqcQqNphQxo8yhe55SzNLmF1rpvkeOWmM2cwonEXca42Z7tUdzGj4uvJEwF3A1N3/As0IJjp6EUw5TS+2hfDgjnT+Wi3hxNmjbT7lF3M8JnDyc0uZtxhp7J73UomzDuOmrJB7bsVmmEz2Tt2NBOyFsHOFZHViZB+NxwiMgvbaCwC3MA7fgXAn2Drkd8pItdi65FfA1wOHA6cB3wHuB/4I3bEXIPBYGjFUiWvoiHiKaYGj/LC6jyeXLUHS+G1nRsYmZGAS4TGxmasVV/i8Vk0uz14l3+CN9B7z+/pLcCvT5zE4eMyyd+yqzU3Bi9j4hoQEcTywHs3EOupAkcMqA9LXDgXLoFhM6lpLoakISDFoTs6bCZ7Rw9iwrDhUBamTD8yEA6A04FVqtqgql7gQ2yjcDa2Djn+4zn+cwtbOrZFd/w4oNivzXHA0hJWfe7cuRx33HF8+umnABQWFnLBBRcMcO+CWbFiRQdP876492uvvcadd97ZRY2+5Y477mDUqFHMmzePyZMnc95557F58+Y+aevjjz9m0aJFTJs2jWnTpvHwww+35t1yyy2ICDt37mxNu+eeexARVq9eHfJ+ZWVlxMTE8I9//CMofdy4ca3RAI4++ug+eJL9g7pmL26v1anR8FrKpoJqnvx8D797YT2/+6iZ/3y+p9Wb217XUEamJzAmVZg7Oo2jJw7iqJFOzp43im8fnsWlR45l1iAHLZ5QAuwJ8N0QgSxnOS4sRAC1mJ7zdyj4iq2Tfw7fvAcO+yHrZ94Aw7oX0y4sIhCbDA4npIwAZywMmhyde4dqTvtQczxkgyLTsQWcjgIasWViVwPf09B65Kdg63YUAt8FXgAuVtWKTtroVHM8LS2NSZMmRfnJuseIESMoKrK1qpYuXcrdd9/N22+/PaB9CiRQS3rlypXcd999vPDCC1Fv49NPP43avX0+H6qKyxV6IL1y5UqeeuqpDl+sgdx+++2kpKS0OkO+9NJLXHPNNXz++ecMHjy407a7oyNeVlbG4sWLefrpp5k3bx7l5eWce+65XH/99Zx++unccccdvP7665xzzjlcc801AJxyyinU1NTw0EMPsWDBgqD7OZ1OHnnkEV544QUcDkfQZ2nWrFl88MEHDB06tEf9706e1+vF5XIFpe/YsYPq6uo+1Ry3FNxeH+6mBmLi2/wW3I0NlPni2VJhsbXCYnulD7clCDAuVZiSapGRGMNLO2zdC6dDuHJBLBPSHHgC7uVpd9/tpQ08kO3AZ4HToVy5IK61TnJCHA71UdfkITnOxaTdTzC66B12jv0OWwZ/nWR/nLu6Jk+H87BpCTHUNXpIToynrqGZ5KQEEAd19fUkJ6ccXJrj4V7AD4E1wEfAQ8A9hNEjb5d2KXAlcCTwIrboU2JnbYXTHO82e1epfvRX+xgFkpKSWs+feOIJPfvss1VVdffu3Tpz5kxVVW1sbNTvf//7OmvWLJ03b55+8MEHqqr62GOP6bnnnqunnXaaTpo0Sa+66qrWe/3sZz/ThQsX6owZM/Smm25qTR87dqzedNNNOn/+fJ01a5Zu2bJFVVXLy8v17LPP1tmzZ+sRRxyh69evV9VgLenly5frGWec0eEZnn76aZ01a5bOnDlTr7766tb0t99+W+fPn69z5szRE088UVVVV61apUceeaTOmzdPjzrqKN26davW1NQE3fuxxx7TX/7yl6qqOnfu3NZXfHy8rlixQuvq6vQHP/iBHn744Tpv3jx95ZVXWut985vf1OOPP16PP/74sO/58uXLdcmSJZ39WfTaa6/Vv/zlL0Fp3/ve9/See+5RVdXVq1fr8ccfrwsWLNBTTz1VCwsLVVV13bp1etppp+mCBQv02GOPbX1/lyxZoj/96U914cKFOnnyZH399de1pqZGb7jhBr3xxhuD2nn//ff12GOPVVXVm2++WW+88UadP3++qqru2LFDv/71r+vXvvY1/fLLL4PqtfytjjvuOF21apVOnDhR8/LyWvPHjh2ru3fvVtW2z53P59Of//znOnXqVD355JP1lFNO0RdeeKG1fOBnZfXq1aqqId//mpqa1vd/8eLFre9/4OenrzXHG91ezS6o1g15VfrW0vf10ZW79DsPf67nPvixzrnxDR17jf066o739Xv3va3//HCnfrqjrLX8hrwqff6Lvfrrh9/R57/YqxvyqoLy2p+3XD//xV698eWN+sALS3VDXpXmlNToB++9q1rwlWrBV7p86Vuqb/xW9eZU3fvPi1Xz19hpgfmB58XZuvz9d1Qr96rWFOvyD95Xba7fLzXHB2RxXFX/DfwbQETuAPLx65GralE7PXL85RKB7wOnAW9gT29dAFyCbUB6xtvXQvHGzss010DJJntRSxwwbBbEhV9AY/hs+HrnUy4tIUeampooKioK0sdo4cEHH0RE2LhxI1u3buXUU09l+3Y7hPK6detYu3YtcXFxTJ06lcsvv5ysrCxuv/12MjMz8fl8nHTSSWzYsIE5c+w9G4MHD+arr77i73//O3/961955JFHuPnmm5k/fz6vvPIKH3zwAZdeemmrwFRnFBYWcs0117BmzRoyMjI49dRTeeWVVzjmmGP48Y9/zEcffcT48eOpqLAHhtOmTWPlypW4XC7ef/99rr/+eh5//PGw92/pw+uvv86f//xnjj76aG6++WZOPPFEHn30Uaqqqli0aBEnn3wyAF999RWffPIJY8eO7bLv3WXBggVs3boVj8fD5ZdfzquvvsqQIUN47rnn+P3vf8+jjz7KFVdcwb/+9S8mT57MqlWr+MUvftH6N83NzeWLL75g586dLF68mLVr15Kdnc2SJUuC2mkJd99Camoqo0ePZtOmTbz66qtcdNFFPPbYYyH7mJeXR1FREYsWLeLCCy/kueee47e//W3YZ/rf//5Hbm4umzdvprS0lOnTp/OTn/ykNT/ws3LffffxxBNPcPvtt3d4/z/66CPAfv83bNhAZmZmj9/nntDs9bG7rB6ff65pTYmXRza1TS1OzRC+d8xE5melMzQ13g4cOKHj4vK0EakkV7kY3cnCeKg600akkr+lhPTEGEZRSr62RYQYXrICdvwLJp3MzqHfJaslzE9MIsSlgLMcMieCKw62V8OwGbClFNKz7HKyBWL3T3XsgdpVNVRVS0VkDLYBOBIYj61DfifBeuQtXAXcp6oeEUnAno7sH93xpuq2nRBq2dedGY4ICFQAfP/997n00ks7OPF9/PHHXH755YD9xTt27NhWw3HSSSeRlpYGwIwZM9izZw9ZWVk8//zzPPzww3i9XoqKiti8eXOr4TjvvPMAWLhwIf/73/9a23jppZcAOPHEEykvL6empqZDLKv2fPnll5xwwgkMGTIEgEsuuYSPPvoIp9PJ8ccfz/jx4wFav0iqq6tZsmQJOTk5iEhrAMfOyMnJ4aqrrmL58uXExMSwdOlSXnvtNf76V1sxuKmpib179wL2NE64L60jjjiC5uZm6urqqKioYN68eQDcddddHSIQh0L907nbtm1j06ZNnHKKLUjp8/kYMWIEdXV1rFq1Kkhut7m5bcvnhRdeiMPhYPLkyUyYMKH1bxgJ559/Ps8++yzvvvsuy5YtC2s4nnvuOS688ELA1le57LLLOjUcH3/8Md/61rdwOBwMHz6c4447Lig/8LPSMo0Y6v1vkSHu7P3vKxTYXVaP12f/fWqbPDy7zdua7xCYlunktJnD+7QfMU4HWbIPGgNE3vZ8ytQdD8Pow+Fr18BWf8RpEXvtweEAx3aI7933yEAxUH4cL4nIIMAD/FJVq0TkTuB5vzb5HuDClsIiMhJYpKotuqr3A18CVbQtoveMLkYGAOR9AU+cBT63veh0/iOQtajrehFyxBFHUFZWxr59+yKuExcX13rudDrxer3s3r2bv/71r3z55ZdkZGTw/e9/n6ampg51Wsr3JzfeeCOLFy/m5ZdfJjc3lxNOOKHT8nV1dVx44YX861//YsSIEYD9Bf7SSy8xderUoLKrVq0iKSkp7L1WrVoF2Avxjz/+eKcjnVCsXbuWww47DFVl5syZrVGIW6ipqSEtLS3sSC1UyPsZM2awZs0azj777Nb0NWvWMHNm8GLp6aefzk033cRhhx3WQZArkGeeeYbi4mKeeuopwB4R5uTkMHlyzxZIQ31WQr3/tbW1bNq0qdP3vy/w+uytti0Oex6fxR1vbaHRY0ef9VmKy+lgSkZk+39E2jy5RezotU4RUhNcOEQodgiZybE4/OVKnA6Gp8WTEOOgfJsHGgOWXIs3wfu3UJs8ntRTbgWnX7vH4bJHF44DPyj5gDyBqh6nqjNUda6qLvOnlavqSao6WVVP1oDFb1UtVNUzAq5fUNWZqnqMqkb+bdtTshbBktfgxN/bxygaDbDDpvt8PgYNCh5CH3fcca1fBNu3b2fv3r0dvjQDqampISkpibS0NEpKSiJabA9sY8WKFQwePLjTL6gWFi1axIcffkhZWRk+n49nnnmGr33taxx55JF89NFH7N69G6B1qqq6urpVyzySL+7LLruMH/zgB0G/hE877TTuv//+1hHA2rVru7xPb3nppZdYunQp3/72t5k6dSr79u1rNRwej4fs7GxSU1MZO3Zs6y9zVWX9+jb9gxdeeAHLsti5cye7du1i8uTJ/PKXv+Txxx9vNTbl5eVcc801XH311UHtJyYmctddd/H73/8+bB9zcnKoq6ujoKCA3NxccnNzue6663jmmWfC1jnmmGN46aWXsCyLkpISVq5c2eV7MRDvfyh8lrK7rL411Ieq8sAHO9hUWMP3ZsRwxzmz+e4RY7n97FlMSAv/Fed02LGgxmQmMn1EKnEuB5OHpTBpaDIThiQT63IwdlASWZmJxDgdjEpPYERaAsNS43E5hCGJTpIb8sBqm55KbMiHd6+D5KFsnHGNPS3VQsZ4oPOR/IGC8RyPlKxFUTUYLWscYE95PPHEEx12rvziF7/g5z//ObNnz8blcvH4448HjTTaM3fuXObPn8+0adOCFAE745ZbbuGyyy5jzpw5JCYm8sQTT4Qst2zZMkaPHt16/cILL3DnnXeyePFiVJUzzjij9dfzww8/zHnnnYdlWQwdOpT33nuPq6++miVLlvDHP/6RM844I2QbLezZs4cXX3yR7du38+ijjwLwyCOPcOONN3LllVcyZ84cLMti/PjxvPHGG10+Y3e5++67efLJJ6mvr2/dkdQyJffiiy/y61//murqarxeL1deeSUzZ87kkUce4aqrruKPf/wjHo+Hiy++mLlz5wIwZswYFi1aRE1NDf/4xz+Ij48nJSWFJ598kh//+MfU1taiqlx55ZV885vf7NCfiy++uNP+vvjii5x77rlBaeeffz4XXXQRN910U8g6559/PsuWLWPGjBlkZWUxb9681qnPcIR6/zszTn2B5TcaTZ42J7rnV+fxwbZSvrNoDEeklDLav/YAkF8VXN8hwpCUOFLiXSTFuSjd7iAtsZtqnqpgeaF0MwSsaVBXypzsO8AVC9/4C569AUbCGQtxHXeUHbCEWzU/WF5R21XVhwTuQNlf6I8+RbuNaNyvp/cIV2/JkiWtu5V60kYkZXtapra2VlVVy8rKdNy4cVpUVNTt+4fL66tdVTtLa4N2Nt33/nYde80buuTRVbp+b2WH3U9vL31fd++r07LaJm32+MLuzArVZsi8xirVks0dd0TtXKF692z13DZMdcMLwbumqvI63REVeN6dHVORlDmodlUZDIaB58wzz6Sqqgq3280111zD8OF9u4jcG1QVt9eivrntF/6OKot71+Ywc2Qqvz5xcltAQYH0xBhS4mMoj3EybnAU1l9UoXynvcOyHQ5fM7z7B6gtZOP065g/aGJbZlwqpI4CdvS+D/sRxnAYDH1Idxfi+5MVK1a0ntfW1g5cRyIgv7KxVSQJoLCqkX9scDMsNYHff2M6Mc62tYyszETSEro5/RQOywe1ReBtCmk0sLzM2HYvVG6GU26lumFKW54IZIyzjwcZB/7yfg/RgA+hwWDoG6Lxf5Zf2UBVQ9v27ZpGD7e+bvu73HTmDFLi24xEjNMRRaPhX8eoD7P/pngTvPILBld+BcdeCeOPb8sTp38HVWTRBA40DknDER8fT3l5uTEeBkMfoqqUl5cTHx/fo/qWpeRXNlBZ32Y0PD6LO97eQmltMz+fE8vI9ITWvJR4V5tiXm9oroXSreDz2MYjBIPKv4DXfw1l27HECYMCQxj5RxoHyQ6qUBySU1WjR48mPz+/W34TfUlTU1OP/7n6iv7oU7TbiMb9enqP7tSLdtlolOksvyd5Lenx8fFBu/EiRYFdZXU0utt2T6kq932QQ3ZhDb87dSoTfXta82JdDrIyE8ntdkvtWq3YDU1V4YtYXsh+mZnb/hHgFKxQuK4tYGHqqAPWsS9SDknDERMT0+rZvD+wYsUK5s+fP9DdCKI/+hTtNqJxv57eozv1ol02GmU6y+9JXm/+FtUNHpo9viCjAfDmbh8rdu/ju0eO5WtThpC/xTYcIjB2UCLOno42LAvqSsDT1LnR2LcNVv4NyrZTmzKFtIZcsLyouGDkPLuMwwnJQ3rWjwOIQ9JwGAyG/Q9VpbC6iYo6N+0nkZdvK+XN3V5OmjaUCxcGj2CyMhOJj+nhWoL6YN8WOypEONwNTNz1BHz6LsSnw8m3sLZhKicMqYDCdaxvymLBsJkQmwLO6p714wDDGA6DwTDgNHt95FU0dBhlAGwqqOa+ZTlMyXDwy8WTgkK4DEmJ69liuKcRqgvA6+7caOR+Ap/cy+j6fTDjLDj8R3aAwuxie2pq2ExqsovBGedf18jvfl8OQIzhMBgMA4rPUnaU1mF1tBl8tL2Ue5ftICMphp/MlqBtt04Rhqf1YE2rKg8ayqHDuCaA+n3M3PI3qPgSMsazdsKvWnW+Q5I5HpyHztfpgOyqEpH/JyLZIrJJRJ4RkXgRGS8iq0Rkh4g8JyKx/rKX+8u9FZB2rIjcPRB9NxgM0UFVKaxqxO2zQhqNT3aU8Zel23H7LKoaPJQ0tH3Rx7ocxLq6+fVVXwbeRmgoI6zRsHyw6X/w/BIyq9bBoh/D+f+iJnVK6PJghxiJSQiffxDS74ZDREYBvwYOU9VZgBO4GLgLuFtVJwGV2GJPYOttzAE+BU7zqwPeCPyhv/tuMBiiQ7PXx8599ZTXhZ4m2lLu4//eaws/77OU7ZW2dWlZDI+8sTp7Ybs6L/wgoySbSTsfgxcvg0/vg2Ez+XL+X2HeJXZU23CkjrZ9Ng4xBmps5QISRMSDradRBJwIfMef/wRwC7Y6oAAx/nIebPnYt7UT6ViDwbD/Ut3oIb+yIeQoQ1V5ZV0Bj63zMCwljvIGd4cQ6VkZES6G+zz2+kV5TuflCr6Ct65iVEvAwoU/gAWX0rS5JHwdERg8BWL7N5z8/kK/a44DiMgVwO3YmuNLgSuAz/2jDUQkC9s4zBKR7wG/AbKBn2MLPJ2mqmGVgLrSHN/fCKfFPJD0R5+i3UY07tfTe3SnXrTLRqNMZ/k9yQunGR6XkIS3ncVo0fN2+5Sntnr4othi7iDl+7PiKay3RxpTMhxkxTWRkJhMjFM6bSM5Odn2t/B5gjS8gQ7XiSVfMn/3Q8T4GgCwcJA79kL2jj4npP43AA4XdY3NrW0H9qOr857khztGUuag0RwHMoAPgCHYI4lXsEcROwLKZAGbQtS9CVu46SxszfG7AUdn7YWKjru/ES5q6EDSH32KdhvRuF9P79GdetEuG40yneX3JK99umVZ+u57y4Ii1wZGuX1/c7Ge+NflOu6aN/T3L2/UN999r0O5d99bppZlddr28uXLVWtLQup6B13nvKf6xFmqN6eq/mWK6q2D1HdzuuptQ1S/+m9oTfCSzapNtR3a7s65iY7bc04GdqtfgElE/gccA6SLiEtVvcBooCCwUoAK4G0i8iH21NYNwEnAe/35AAaDoXsU1zQFBSkMZHulxaOfrsfjs7jhjBksGp9J/pbgaaIYlxDrcnQpaQxAbXH4PLVg86uw6mGw3OwacxETTvkRlG0nd91KJsw7rs0DPBCHCwZPPSjU+6LBQBiOvcCRIpKIPVV1ErAaWA5cADxLaM3xP2CPOAD6V3PcYDD0mOpGD2W1HRfBVZW3Nhbx8Fo3I9ISuOGM6YzO6PjvLAJjM5PoxBy0YXmCxZUCqdjF/I1/gtocGLUAjv0Ne/NdTHDGwLCZ7B09iAnD2oWWd8ZB+hjbsc8YjVb63XCo6ioReRH4CvACa4GHgTeBZ0Xkj/60f7fUEZH5/rpf+ZOeBjYCecCf+6/3BoOhOzR7feRXNnRI9/gsHlqxk/e2lDB7sIPfnzuXpLjQX0ejMxJIiI1gMdzrBl+IoITeJljzBGx4ngRnIpxwPUw+xbZI+Z2YI4cLhkwzBiMEA7KrSlVvBm5ul7wLCKnNqqpraduei6reA9zTR90zGAxRQFXJq+i4e6q8rpk/vb2VbSW1XHR4FsenlIY1GsNS40hPjI2swbqORiCjcj288LitqTH1G3yRdi7HTpnc+X3MKKNLDh1XR4PB0K8UVjd1CCGytaiGO97eQqPHx3Vfn8bREweTv6VjlGrBHmlkJEVoNDxN0ODfoV+SDXs+hX3bmFuwGtKy4Mx7YOQ8vNldTHglDYGUkcZgdIExHAaDIer4LKUiwLlva1ENT25ws6lsA0NS4vnD2bMYOyi0D4TTIcS6nJEbDYDaQkBJrdkOn93WqqNROHQxI795HTi7uJczzhZeSut+CPhDEWM4DAZDVGny+PD42kYaW4tquO7ljXgtRQR+9rUJYY1GXIyDsYMSKd0eMjs0zXXQZEelHVz+RZv4kjhoShjWtdFIGgopI0BKu9HooY0ZjxkMhqhhWcreioagyB4f5uzDa9kpAuzaVx+yblKck4lDkolzdTOER21R62lio38XvzjAEUNV6ozw9Vzx/lHGKDM11U3MiMNgMESNgqpGmj1to40mj48vdpcDttFwOR3MHpXWoV5GUgyj0hMi89MIpLEK3Lb3M1V5DKpcBxNOhEETYeQ8asoGhagkkDwUkoeDdBJWxBAWYzgMBkNUKK9rpqohOBLQIyt3sa/WzY+Pm0Bp4V6OnTeDaSOCZVVjnI6Q/hsREejst+ZxLEcszmMuh4QMO62s3WK4CAyefMjGmIoWxnAYDIZe0+j2UVTdFJT28Y4y3t1cwvkLRnPW3JHkxxYyOsBoiNjqfeU9lnz12WHSASp2wc4PyB99FmNbjEYQAsnDwFVtjEYUMBN7BoOhV/gsZU9FPYERRcobLR74IIcpw5L57hFjOtRxOYWJQ5J7pt4Htk64FTC6Wf0YxCSSN/KbHcu6EuxItqkjetaWoQNmxGEwGHpFXkUDHm+b1fBZyqPZHhQHV506DZcz+PdpQqyDMZlJ3RdiCqShjFZLtW8b5K6EhT/AGxMYLVfAGQNDptrDG0PUMCMOg8HQY7yWUtsUHObj6S/2sqta+cUJkzpIu6bEu5gwOLl3RsPyBa9trH4U4lJh9gVtaTGJtsFwuIzR6AOM4TAYDD2irtmL1xfsGb4hv4oXVudx1AgnX5syJCjP5XAwbnASjp6uabQ2XNIWyLB4I+Stgrnfblu7iE2xp6YOMTnX/mQgpGOnisi6gFeNiFwpIpki8p6I5PiPGf7y5/v1yVeKyCB/2kQRea6/+24wGGw8Pou8dv4a1Y0e/vbedkamJ3DR1OBZ8IRYZ6sAU6/wuqE+IETJ6kftHVQzz2lLSxluRhl9TL8bDlXdpqrzVHUesBBoAF4GrgWWqepkYJn/GuBy4HDgn7RJy/4RW4vDYDD0My3BC70+DUq7d9l2aho9XH3aVOICjIS9eypKv/7rim1NDSC9ahMUroX5320bXYgD4vYvNc2DkYGeqjoJ2Kmqe4CzsbXG8R/P8Z9bQBx+zXEROQ4oVtUuhIQNBkNfUFDVSH1zsObF6xuK+DK3kh8cM54JQ4K/uEemJ3TfGzwUqm2BDFUZv/c5OyjhtDPbyjh7uEvL0C0GRHO8tXGRR4GvVPUBEalS1XR/ugCVqpouIqcAdwKF2BKzLwAXq2pFJ/c1muO9xGiO9129A1lz3GtpUBwqT1MDxZ54/vylm+mDHPx8Tgwi0qoj7nQIsf5dVd3VJ++QVlvTqvudWbGWOVvuYtvEH1E0/GS7gDhsbfCAeu3v09l1NPKM5njfa4/HAmXAMP91Vbv8yhB1LgWuBI7E1hz/F5DYWTtGc7xnGM3xvqt3oGqOVzW4O+iAv/z2e3r0n5bp/FuX6srt+4J0xDcXVqvH6+uyjbDa4YE01bZpgOevUb1voTbcMUl176o2TfGm2g71unMdjbxDRXN8IKeqvo492mgJFlMiIiMA/MegUJV+qdnvAw8Ct2LLy34MXNJfHTYYDlUa3F7yKjoq+T2/zUthVSO/PXVKB2e+0RkJHXw4ekxAIENyV0J5Drljzm+bmopNMWsb/chAGo5vA88EXL+GbQwgtOb4VcB9qurBaI4bDP2GAnvKG4I8wwE+2r6PT4t8fOuwLOaMTg/KczkcpMRHab0hMJCh5bN3UqVlUTrk2LYyKcNDVjX0DQNiOEQkCTgF+F9A8p3AKSKSA5zsv24pPxJYpKqv+JPuB74EfoatP24wGPoAn6W4vVbQDiqA4pomHlyxgwlpwrcPzwrKi4txRGfrLdgL4oHOfruWQ2UuHPYDVPwL7ma00e8MlOZ4PTCoXVo59i6rUOULgTMCrl/AXiQ3GAx9hKqtrWG1G2psKqjmb+9tw7KUy2bGBE1HiUBWRiKF0epEXWlrIENRH6x5HDInwIQTYLN/NtuMNvqdgd6OazAY9lMKq5uoaxdOZGtRDb9/ZRNldW68llLtDq4zNDWOhNgobL0FqM73S8LaDCtdaacddpntrwFmtDFAGMNhMBg6UFbXHKQZ3sLL6wpaRyCWKtsr27bmJsU5GZoS36FOt7F84GsO9hD3eRiX96Idf2rsMW3pZrQxIBjDYTAYgqhp8lBU1dQhfUtRDat2lSMCDrHV/KZk2F8hDgc9F2MKxOuGshw7bHog294ivrkMDvthWzgR4yU+YJiw6gaDoZVGt4+95R233ZbWNHHHW1sYmhrPT4+fwK599cwelUZy1XYARqUn9C7iLYC73hZksoKnx/A2w1f/pSp1KumjD29LN17iA4YxHAaDAbADF+aW13fYdtvkVf781hY8Pos7zpxNVkYiC8dmApBfBemJMaQnxvau8YYKqNoLhIhksfk1aChj96xfML9ltBGbAlLduzYNPcZMVRkMBgD2lNd32HZrqfLEZg97yuu56rRpZLWbjhIRRqb3MoCh5YGqPYQ0Gp4GWPcUjFpIddqMtnSztjGgdGk4xOa7InKT/3qMiCzq+64ZDIb+wu21aHRbHdKfXrWXdfssLjtmPAvHdtTyjnU6cPZYM9yCit3g84Yv8/k/oKnK3n7b2qjZSTXQRDLi+DtwFLanN0AtdtgPg8FwEFBY1YgvRLDTD7fv47nVeRwz0slZc0d2yB+cEkuPNZl8HijfYRuFcOxYBltes88/fYDUGns9xYw2Bp5IDMcRqvpLoAlAVSuxAxQaDIYDnH21zZSH2Ha7vaSWe5dtZ+bIVC6e6kLaCSMlxDoYntrDrbeeRijbDp76sEXSqrfAh3e1JVge0ms2m9HGfkIkhsMjIk78E5AiMgQ7RpTBYDiAqah3U1zdcdtteV0zt7+5hYzEWK77+nRc7YYVIvbW2/bGJCKaqu3ttr6OxqqVHe8zN/t2iE8HZ6y97dYRQ1XqDDPa2E+IZFfVfdgKfUNF5HbgAuDGPu2VwWDoU6obPRRWNXZIb/L4+ONbW2j0+PjzWXNIS4ihtl2ZrMxE4mN64B1uee3ttuFQhbX/hdWPUpM6nfRz7oLqPChcByPnUVM+xIw29hO6NByq+pSIrMGOIyXAOaq6pTeNikg68AgwC3skcxmwDXgOGAfkAheqaqWInA/cBlT42y4XkYnAHap6UW/6YTAcitQ2eWy98HbLGqrKfR/ksLO0jhvOmM64wUkd6g5LjesQPj0iagrtdY1wWF746G+w/W2YdArrh1zK1+JTIX4mDJtpl6mq7H67hj4hkl1V/1XVrar6oKo+oKpbROS/vWz3XuAdVZ0GzAW2YDTHDYY+p8HtDRkiHeC51XmszCljydHjWDR+UIf81AQXQ7u7rqEKlXugriRsEZe3Ht6+2jYaC5bA4utRRzvjFJvSFp/KMOBEMlU1M/DCv96xsKcNikgacDy2KBOq6gbcInI2cIK/2BPACuAajOa4wRAVmjw+cstCG42vSn08tXEvi6cO4bz5ozrkx8c4OvhwdIllQVWuva4Rjtpi5m+8GRqL4IRrYcrpoculDAfyu9e+oc8IazhE5DrgeiBBRGqwp6kA3MDDvWhzPLAPeExE5gJrgCuwJWRbZL6KgWH+8z8B79NOc7wX7RsMhxwK7C6rx2d1tBo799XxRLaHqcNS+NXiyR0WvQVhzKBEHN3de1uxs02AKRT7tsE71xHnboJv/BlGhfk9anZS7XeIhvr5EVhA5E+qel3UGhQ5DPgcOEZVV4nIvUANcLmqpgeUq1TVjHZ1LwUy/fV/B1QCV6hqQ7tyPwF+AjBs2LCFzz77bLS63ycEis/vL/RHn6LdRjTu19N7dKdetMt2VUaB2tpaYuI7jhg27PPxWLaHGFF+f2Q8aXHtjQZ4mhpJSQl9/9BtK3W1tSS3UwCsa/K0pg2qWMOMbffhiUnh84m/g4xxYcviigNxdGgrVNtdlensOhp5XZ33JD/cMZIykRyBkHmLFy9eo6qHEYpwYuSBLyADWIQ9xXQ8cHwk9cLcaziQG3B9HPAm9uL4CH/aCGBbu3qJwAdADPAukIQtMfvjztpbuHCh7u8Eis/vL/RHn6LdRjTu19N7dKdetMt2Vsbrs3R7cY2+tfR93ZBXFfT676e5Ou6aN3TsNW/oxOve0Oe/2NuhzL7apk7v3yHP06RanK3Ll76lWvBV0Ks17d0bVG9JV33gcNWc9zovW7YjbFuh+tVVmc6uo5HX1XlP8sMdIykTyTFcHrBaw3yvdrnGISI/wp5KGg2sA44EPgNO7KpuGENVLCJ5IjJVVbdh79ba7H8twZaM7VRzXESM5rjB0AWWpeSW19Pk6eh25fFZ/H3FjtboUJYFGwuqmTYitbVMRlIMg5PjIm/Q3WBPT7WPbgtQks2YvI+gqNSWfx17DJx4A8QkYM9MhyA+DdLHRd6+od+IZHH8CuxdTZ+r6mIRmQbc0ct2LweeEpFYYBfwA+wdXs+LyA+BPcCFLYUDNMdv9Se1aI5XAef0si8Gw0GHqrKnooGGZl+HPEuVe97PobC6CZdDsFRxCsweldZaJjHOyajuBC9srrXjTmnH9ijJhjd+w3hfs309YbFtNByd+II4XLZErGG/JBLD0aSqTSKCiMSp6lYRmdqbRlV1HRBq7sxojhsMUSCvorGD7CvYBuVfK3fxUc4+Lj1qLLNHprGxoJph3qLW0UaMSxiT2Q3P8MZKe8ttqOi2AHmrwNfs310jMGhS50YjdRQ4Tcj0/ZlIDEe+32HvFeA9EanEHhEYDIb9kPzKBqobQzvbPb86jzc2FHHOvJFcsGA0IsK0Eankb7H9LERgbGYSMc4IfSYsL1Tmhs9vKIecZQAogjhjYeS8MIUFMsZCQgb2zLVhfyUSz/Fz/ae3iMhyIA14u097ZTAYekRxdROV9aGNxtubinhyle2r8YNjxoccUYzOSCAhNsJwIrXFnXuD1xTBW7+Fxgo46lfsLixjwrzj2jzBAxGnPTVltt0eEHRLAVBVPxSRU4G3gFP6pksGg6EnFFc3sa+2OWTeVyU+Htm0k8PGZvDrEyfjCGE0hqTERa7kV50P9fvCZifV74XX7rKDGZ75fzB0BnsdxUwYFiJIoQgMngIxPYy2a+h3wo5HReREEdkuInUi8qSIzBaR1dgOeQ/1XxcNBkNX7C6rD2s01udV8Vi2h2nDU7jm9Gm4QkxDOUUYnhbhF3dDRadGg5Js5m28FRD45n0wdEb4sjGJtp+GMRoHFJ1NZP4N24luEPAi9hbcx1V1oar+rz86ZzAYOqfB7aXJa4VcCAfIKanl9re2MDRRuOnMmSGj2sbFOIh1Rbim4fNCTUH4/Lwv4M3f4olJgbPvh8zx4cvGpcKgybQFpTAcKHT2aVFVXaGqzar6ClCgqg/0U78MBkMXlNU1s2tffYuDbAcKKhu55fVsUuJdXD4/luT4jjPTDgeMyeyGK1R1Xmg/DYCdy+Hd6yFtNGtn3wIpI8LfJ3GwvabhMIELD0Q6W+NIF5HzAssGXptRh8EwMFiWUlDVSFVD+IXp8rpmbnxtEyLCbWfNQouzO5QRgXGDkiLX1misDC/1uvk1+PhuGD4LTrsDz47w6n6kjISUYeHzDfs9nRmOD4FvBlx/FHCtgDEcBkM/0+TxsbeigeYQ3uAt1DZ5uOm1bOqavNxx7mxGZSSQ3845WwTGDEokKS7C/TE+r70g3h5VWPskfPkIjDkSTr4FXPFAGMORPhYSMyNr07DfEvZTo6o/6M+OGAyGzqlu8JBf1YDViXBzk8fHbW9sprCqkVvOmsmkoaG3t45KTyA1vhuCTKGmqFSZmPskFL4Jk062w6I7wnyliNNeBDdG46CgW9txDQZD/6OqFFU3UV7XiU43sKmgmvuX51BY1cS1p09j7uj0kOWGpcWRkRThtluww4i0n6KyvPDRX8kqfAdmngdH/yq80JLDBZkTQSoib9OwX2MMh8GwH6PArrL6kDGnAtlUUM3vX9mIpeByCIPCGIbBKbEMTenG1left6OTX+Fa+PgeqNrD7qwLGH/0L+25r1A4Y22jYbbbHlSYLQ0Gw35KXbOXZo/VpdGoblbufn87LRpNliobCzrGekpPjGFEWjcCFwLU5BMkGViSDW/+Fqr2gMNFZfqc8EbDFW9vtzVG46AjEs3xb4lIiv/8BhH5n4gs6E2jIpIrIhtFZJ3fqRARyRSR90Qkx3/M8KefLyLZIrJSRAb50yaKyHO96YPBsD9TXtdMblk9Gi5woJ9NBdXc8UUzlQ1uXA7BIeByOoIi3YLt4Dc6o5tGo7HK3kkVSPbLoP5FFrVIrwkTU0octtFwdWNKzHDAEMlU1Y2q+oKIHAucDPwF23P8iF62vVhVywKurwWWqeqdInKt//oa7BDshwPnAd/BDqn+R+CGXrZvMOyXNHl8FFU3hdQGb0FVeWVdAY9/msvgBOGO8+fR6PaxsaCa2aPSgnQ1EuOcxLockUe7BbB8HXdRNdXA3lWA2KMMRwxVqSG8wmNTwFUNTjMTfrASyV+2ZZx8BvCwqr4pIn/sg76cDZzgP38CWIFtOCwgDluwySMixwHFqprTB30wGAacwqrGTo1Gg9vLfcty+GRnOUdNGMS3suoYOygJIMhgAMTHOBg3KIm87naiOh+sdmsbnz0Angb42jV21NuR86gpGxRcplV8KcTWXcNBQySa428ABdhBDRcAjcAXqjq3x42K7MbWC1fgn6r6sIhUqV9zXOyfRpWqmi4ip2CrAhYC38XW4bhYVcNu0TCa473HaI73Xb3Oyvosxe1r22/raWoI0govqrd4eIOHkgblnEkuThnjxNvcGFJPXESIczmQCPoXlK8+8Lbt4Kpr8jC2YQOzt/yF3NHnkTv2wqC8Vm1wh9NeDA/TXrg+RFrWaI4fQJrj2L/0zwMma5se+Kld1evinqP8x6HAemwd86p2ZSpD1LsUuBJbvvZF4F9AYmdtGc3xnmE0x/uuXriyHq9PswuqgzS/A7XCH/wgR6fe8JbOveVdffKz3JBlWl7ZBdXa6PZG3L/WfJ9XtWhjkP73yreeV71rguq981T3rgqtDV6V1+UzhutDpGWN5nj3ywyY5rjfULypqs0icgIwB/hPBPXCoqoF/mOpiLwMLAJKRGSEqhaJyAigNLCOiCQC3wdOA97ANmYXAJf4DYjBcEBTVN2Ez+o4A+D1WTz2aS6vrS9k2vAUrj19GoM60QIXgfGDuxFKJJAQU1QTd//X1tQ47XZwhnAaTBkBKSHCpRsOWiLZjvsS4BORScDDQBbwdE8bFJGkgF1aScCpwCbgNWCJv9gS4NV2Va8C7lNVD5CAPc1lYY+IDIYDmrpmb8jYU9XNyu9f2cRr6ws5c84I7jh3dpdGY+ygxMjFmAJpqrYNRCB7VzGi9EOY+x0YEkIx2hljjMYhSCQjDktVvf4Ah/er6v0isrYXbQ4DXvbv8HABT6vqOyLyJfC8iPwQW5q2dSJVREYCi1T1Vn/S/cCXQBVwTi/6YjAMOKpKYVVjh/TsQnurbbPl4benTOGEqUO7vFdWRiIp3QklEkj7XVTuOlj5F+oTRpO08NJ2hQXSx4DDaIMfikRiODwi8m3s9YWWIIc9/GSCqu4COiysq2o5cFKYOoXYu7parl/AXiQ3GA54Smubg4IWbimq5vnV+azZU8mQBOGO8+e27poKh4htNNISe/iv6XPbr0A++zs0VLB19h9Y6Gznj5E53t5BZTgkicRw/AD4GXC7qu4WkfHAf/u2WwbDoUGTxxek3Le1qIbrX96E11IcAhdPdXVpNBwiTBqa3LM1DbD9M6x23un5X8K2t2Dut6lNnhiclzTUGI1DnC7XOFR1M7Y/xVf+692qeldfd8xgOBQoaOezsSq3Am/AAvme2s63y6clxBDncvTcaFg+O/JtIO56+PAv9lTUwu8H57niOxdoMhwSRBJy5JvAOuAd//U8EXmtj/tlMBz0VNS7O8Sh2lZcC9AaOmRKRuh/UREYkR7PmEG92BuiCpW5HaeoVv0DGspsRz9Xu4X49DFGtc8Q0VTVLdjbZVcAqOo6EZnQh30yGA56vD6L4uqmoLQvdpezsaCa02YOZ1hKHLNHpZFctb1DXZdTGJPZDRGmcNQUQHNNcFrBGtjyOsy5EIbNDM5LGgqxnU+bGQ4NIlocV9XqdnFuOpGSMRgMXdHeZ6PB7eWhD3cxJjORnx4/gRin/as+vyq4XlKck6zMxNb8HlNfBvX7gtPcDfDhnyEtCw77YXCemaIyBBDJpy9bRL4DOEVksojcD3zax/0yGA5aLNUOPhtPrdpLeV0zly+eFNYoDEmJY/zgpN4bjeba0DKwXzwMdaXwtavNFJWhUyL5JFwOzASasR3/qrHDfhgMhm5iWYrHF7zgvb2kltfXF/L12SM6BCkE+/t6zKBEhqfFdy/CbSg8TVCxG9qFa0+vzobNr8Cs82H47OA6TpeZojIE0eVUlao2AL/3vwwGQy8orW3GCthG5fVZPLB8B5lJsSw5amyH8i1bbeNcPdw1FYjlg4pddhDDQDyNTM35J6SOhEU/Cs5zxYOjx25bhoOUSHZVvSci6QHXGSLybp/2ymA4CGny+Ciraw5Ke3V9IbvL6vnp1yaSGBv8Oy490d5qGxWjAfZIw9fcMf2Lf5HQXOrfRRWo1uf3DjcY2hHJVNVgVa1quVDVSuyotgaDoRu099koqm7k6S/2ctSEQRw1IVjXYlhqHFmZUQzD5vOAu7ZjevYrkP0/SgcdASPaBXRINruoDKGJxHBYItL6s0NExtJ+gtRgMHRKe58NVeXvK3biFOGnxwfvbk+MczI0NYo63XX7wPJ2TN/7GXxyDwCDKtfaeuItuBLMLipDWCIxHL8HPhaR/4rIk8BHwHW9bVhEnCKy1i8UhYiMF5FVIrJDRJ4TkVh/+uUisklE3gpIO1ZE7u5tHwyG/sDjsyiqDg5iuGL7PtblVbHk6HFB0W5FYFR6N7XBO6OpxvbXaI+3GVa2/QuJ5YXCdS1X9hRVbxfiDQctkYQceQdb+e854FlgoapGY43jCmBLwPVdwN2qOglbHbBlI/kl2BognwKn+dUBbwT+EIU+GAx9TlFVE1aA51OdW3lk5S6mDU/h67OCQ5IPTYnrefiQ9niabM/w9hMEqvDhXVBfCg4XiAN1uGDkPDs/eRjEGrUCQ3giWRw/F9sJ8A1VfQPwisg5vWlUREZjR7t9xH8twInYqn5ga463tCHY0XgTAQ+2fOzb2ol0rMGwv1BR76a6Mdhn48UcD/VuH79aPAlHwK/6+BgHQ1LCa210C5839A4qgDWPw84PYNFP4Jv3wmE/ZP3MG2xPcVeC0dcwdEkkmuPrVHVeu7S1qjq/x42KvAj8CUgBfoet7Pe5f7SBiGRhG4dZIvI94DdANvBzbIGn0/yCTuHubzTHe4nRHO99PVVo9vqCfu9vqfBx31oPp49zcvbEtm2uAsS5nB1mhyLpT8gy3mbQtmFOizb4sNKVTM95kKKhJ7Bt0k9bp6NatcNdcSDBvyc760NvdcS7U9Zojh9YmuMbQqRt7KpeJ/c7E/i7//wEbBnYwcCOgDJZwKYQdW/CHomchT06uRtwdNae0RzvGUZzvHf1PF6fbikK1g//Yle5HnH7+3r4LW/q6t0VQXmFVQ097k+HMpV7gnTBW7XB1zyueusg1X9+LbR2eHVht/vQWx3x7pQ1muPdL9NXmuORLI6vFpH/E5GJ/tf/AWsiqBeOY4CzRCQXe83kROBeIF1EWjayjwaCVvQCVABfAX4LXIStABhS/MlgGEjyKhvxeINH8899mUdxTRPfmeYi1tX2rxfrcjAsJUq7qOpKoaG8Q3J8YzG8e4M9DXXyrR21w0XMFJUhYiINOeLGXhx/Djv0yC972qCqXqeqo1V1HHAx8IGqXgIsBy7wFwulOf4H7BEHGM1xw35MSU0TdU3B2193l9Xzv7X5nDx9KFMzgxe/R2Uk4HBEYQdTuB1UzbXM2fJn+/z0P0F8+7AmAs44s4vKEDGRhBypB67th75cAzwrIn8E1gL/bskQkfn+vnzlT3oa2AjkAX/uh74ZDBFR0+ShtCbYO9tnKQ8szyElPoYfHD2emtz1rXkZSTEk9zY8OoDXDVV7OqZbXnjvZuKbSuDM/4O00R3LpAwHqep9HwyHDF1+YkVkOSEc/lT1xN42rqoraNP52IWt+xGq3FratueiqvcA9/S2fYMhmjR7feRVNASlbS2q4fk1eWwvqeO3p0whNSGGFgUMl1MYkRYln42qPR2d/FTh47uh8Cu2Tf4F09t7hgPEJtvbb9kanX4YDgki+anzu4DzeOB8IIQbqsFwaJNX0RDkr7G1qIbrX9mIx6eI2GFEAhmVkYAzGlNUlgfcdR3TNzwHW9+E+d+lJPF4prfPd8VDxngzRWXoNpFMVbVfCP9ERL7oo/4YDAckHp9FoztY32x9flVrCHUBNhXUMH1EGmBrhafGRyHqbFON7bPRntyVsOqfMGExHHYZbC4Nzne4IHOCHTLdYOgmkUxVZQZcOoCFQFqf9chgOMCoqHfjtTr6Q+0uqwdso+FyOpg9Ks1/LYxMj8IuKp8n9LrGvm3wwe0wdBqccG0HvwzEYRuN9mJNBkOERPJzYw32GodgT1HtJmC9wWA4lGl0+yisauyQ/sHWEj7ZWc5xkwYzfnASs0eltYo0xTgFV29V/FTtcCLt1zXqSuHd6yE+DU69PYRxEMgYZ6LeGnpFJFNV4/ujIwbDgYbXZ7Gnoj4oVDrAjtI6Hli+gzmj0vjtqVOD1jGS412UR2Ndo7a447pGwRpYfjs018O5D0FiZsd6aaNto2Iw9IKwP3tE5HARGR5wfamIvCoi97WbvjIYDknyQzj5VTd6uP2tLaQnxnL16dOCjEbUIt821UBdcXBa8UZ46ypoqLBDjXg6joJIGgpJg3vfvuGQp7Px8j+xHf8QkeOBO4H/YGuOP9z3XTMY9l9Ka5qobefk57OUu97ZSk2jh+u/Pp20hODF7+Fp8UEe4z0i3LrG6sfbYlOpLyBEuh+HE9JG9a5tg8FPZ1NVTm2LQHsR8LCqvgS8JCLr+rxnBsN+Sm2Th5KajhKsj32ym40F1fy/k6cwaWhw8L3EOCeDk6OwGF3Z0V8jo3I9FK5pWwR3xLSFSAfbV8NZ3fu2DQY/nRoOEXGpqhc7HtRPIqxnMBy0uL0WeRUdp4FWFfl4dXMh35wzghOnBSsrR22Kqqaoo/xrXSkztj9g+2McczmUbLGNxrCZdn6LrwYhQpEYDD2kMwPwDPChiJQBjcBKABGZhD1dZTAcUvgsZW9FPb52W2937qvjqa0eZo1M5bJjOu4liYo4U3Ntx3UNnwfevxlRL5xyG6RnwcgFbfnGV8PQR4T9RKnq7SKyDBgBLPWH2QV7XeTy/uicwbC/UFHvpri6qYPRqG70cMdbW0iOgWtOn9Zhm21KvKv3+uE+jz1F1Z7P/w6lW9g29UpmpmcF5xlfDUMf0ulKnap+rqov+wMdtqRtDwg22G1EJF5EvhCR9SKSLSK3+tON5rhhv6PR7WNHaR0FlY0djIbPUv7y7lYqG9z8ZE4s6YmxQflxMQ6yMqMQvLlqrx1WJJAdyyD7ZZj9LfYNPrJjnfSxxlfD0Gf0cotHj2gGTlTVucA84HQRORKjOW7Yj/D6LAqqGtlRWkejO4T8KvDEZ7msz6/mFydMYlxq8L+S0yGMHZTY+1hUlheaa4LTKnPho7/AsFlwxE871knLgoT03rVrMHRCvxsOv3BVi+dSjP+lGM1xw35CeV0z20vqqKhzhy3z4fZ9vLy2gDNmj+Dk6cOC8kRgzKBE4lxRWNfwtRtpeBrgvZshJgFOvtlexwjE+GoY+oEuNcf7pFERJ3Yok0nAg8BfMJrjA92NIA5FzXFLoa6ulpj4zqeX8mst/rzazdhU4cr5sTgdgqepobVerNPR6Ugj4n56m6hrdNta4ACqTN9+P0PLPmP9zBuoSrd3TrXqhTuc4IwNeauu2uyJrnhneUZz/BDXHO/LF5COrfx3LEZzfL/iUNIc93h9mldRrxvyqvStpe8HaYG3f328fZ8uuv09XXDbUv1wW2lreku9gsrQ2uER9dPnVW2sUq0uUC3Z3KYF3qIN/u4Nqjenqr7x24564SVbVH2+Hr83PdEV7yzPaI4f3JrjA7pPT1Wr/EJRR+HXHFfbb6QzzfHbRORD7KmtG7B9TN7r564bDgJU1d4tVdMUpKMRjuzCau5dlkNZbTN3nT+XjHaL4cnxLkakdWMHlddtx5ty19svb4gwIS2UZNu7qMYcBfO+HZwnQOZ4cAzEkqXhUKTfDYeIDAE8fqORAJyCvTDeojn+LEZz3NDHNLp9FFQ1dNDQCMfavZXc8no2loLLIS0j4FYcIozJTEQ6E0XyNNoGwue2DYEv/BpKcGer4P1bIGkILL6+XZh0v1642XZr6EcGYsQxAnjCv87hAJ5X1TdEZDNGc9zQD1TUuymsauwQ1TYUPkt5f0sJ/1q5i5bduJYqGwuqW8OkOxydrGu0hD9vrrVjSAFYvsiNhlrwwR+hqQrOfhDiUoLzU0cavXBDv9PvhkNVNwDzQ6QbzXFDn6KqFFQ1Ulkfdl9FEBsLqnlk5S52ldUzblAiBVW2L0eQKJPAmMxE9oUbaNQW21/6PWTc3hehYDUc/zsYPCU4MyEDkocCm3t8f4OhJ5hYBIZDArfXYm9FQ1ifjECKa5p4/JPdfLKznCEpcVx92lSOnTSYbcW1bCyoDhJlGp4WT0o4CVhPI9SV9LzTe1cxLv9/MOV0mHpGcF5MIqSN6fm9DYZeYAyH4aCnrtnL3vKGDp7f7Wl0+3h1p4dlK9bgEOGSI8Zw7vxRrf4Y00akthoMgMzk2M4j3lblYS/FdZOSbNi9Era8Rl3iGJKPvdIe2rTgcNmBC81iuGGAMIbDcFCzr7aZkpqmTtczLFWWby3lP5/toaLBxwlTh7DkqHGdGoWkOCcjO9tBVbcPPPXh88NRtAHe+m2r49+e8ecy0xXYjl/61RXaX8Ng6A+M4TAclFiWvZ5R1dD5esbWohoeXrmLnNI6pgxL5ocz4Pgjp3ZaJ9bl6HwHldcNtYWRdbSpGko3Q3E2lGbbSn6tehtCQnO7qa7UUR0XyA2GfsYYDsNBR7PXx97yBpo84bfafr6rnKe/2Mvusnoyk2L5fydP4YSpQyjcuqbTezscMHZQYocouEFU57Wp8ZVk22p8I+fB0OlQmcuI4s9gX56dV51nlxMHDJoEY4+GPZ/a9R0xVKXOaLtvQiYkD4nsTTAY+hBjOAwHFTVNHvIqGjp16Hvmi708/cVeAJwi/ObkKczNSu/y3iKQlZnYubZGQ0VbUMKSbHjj/9lbb8Xvb+FtYipAfBoMnQlTT7ePQ6ba8ada6vmNTU3ZIDstJgnSzWK4Yf/AGA7DQYPXUvaUNYTNd3stHvl4F29vahNEUpTtJbVdGo70xBiGpsZ1HrjQ54WagIAHBWva/DVU7bWJmeeyqmYoRyycF7zgHciwmW0KfmXFthRs5vjw5Q2GfsYYDsMBj89S8ioa8PjCDzMKqxq5852t7C6r54QpQ/h0VzlenxXkkxGKpDgnI9ISSIiNINJtTX6wHnj9Pv+J2MEHj74chs2kMbu4e0YgYxw4w2z5NRgGAGM4DAc0zV4fe8obaO5kPWNlzj7u/2AHLodw05kzOHxcJmcU1XTwyQgkPsbBsLR4UsP5aLRHfdBY2XZdvgO2vW1LuY5aGKwD3h2csRC3f0VONhiM4TAcsNQ3e9nTiX9G4NTUtOEpXH3aNIak2Fts2/tktCAIozISyEiM6TzuVCCWL1g3w+eG5XdAXKqtmREffkTTKYmDwVHds7oGQx9iDIfhgKSqwU1+Zfh4U4VVjdz17lZ27avnvPmj+N6RYzvdCeVwwJDkOMpjHGQmddNHoqaQoI6seRwqdsHpf+q50YhNgbTRwM6e1TcY+pCBiI6bBfwHGIbtVvuwqt4rIpnAc8A4IBe4UFUrReR84DagAjhHVctFZCJwh6pe1N/9Nww8JTVNlNY0h83/eEcZ9y3LwekQbjxjBovGZ4YtKwKZSbEMTYnD5XR0P+pTcx00lLVdF2+C9c/C1G/YIdAjQZx2CJHYRP8xyaxpGPZrBmLE4QV+q6pfiUgKsEZE3gO+DyxT1TtF5FrgWuAa4HLgcOA84DvA/cAfsbU4DIcQqkp+ZXinPo+l/OPDnby5sYipw1K4+vSpDE0J792dlhDDsLQudkp13qE2PwywY1Ot+JMd/vyoX4apJLbPRuJg20DEJEJMNzQ8DIb9gIGIjlsEFPnPa0VkCzAKOBs4wV/sCWAFtuGwgDj8muMichxQrKo5/dtzw0Di9VnsqWigoTl0kMKi6kb+stpNXm0R584fxaWdTE25nEJWZiLJcb38+NcWg7ep7XrVP+3tuGfebRuFFuLTITa5bUSx/UNIz+pd2wbDADIgmuOtjYuMAz4CZgF7VTXdny5Apaqmi8gpwJ1AIfBd4AXgYlWt6OS+RnO8l+xPmuOKvdBthfmsvr3bw1u7fTgdymUzY5kzJPwIwukQYjtZ64j4uVWDjEZ86VccmfNn8kZ8nZ0TlrSVC6ED3p33NpKy0ShjNMeN5vgBoTkOJANrgPP811Xt8itD1LkUuBI4Eltz/F9AYmftGM3xnrG/aI7XNXk0u6A6pP732j2V+r1/f65jr3lDx17zhk667g19/ou9IctuKqjSirrmqPRJLUu1dFub7veuD7Xp9nGqd89S3fNZW3rJ5pA64N15byMpG40yRnPcaI53R3N8QOIyi0gM8BLwlKr+z59cIiIj/PkjgNJ2dRKx10EeBG7Flpf9GLikn7pt6Gcq693sLqsPud22ptHDLa9n89H2toVpn2WLL7UnMc7JpKHJZHR3t1Q46ttFvv30fmLdVXDC9QESrv4otib0ueEgpN8/1f5pqH8DW1T1/wKyXsM2BhBac/wq4D5V9WA0xw96Smqawm633V1Wx29eWMemgmouXDiaWJcDh4DTQZAXuAgMS41jwuCkni+At8fbDLVFAZ1ZCTlL2TP6HBg6rS09bXRb7CmD4SBjIHZVHQN8D9goIuv8addjr2M8LyI/BPYAF7ZUEJGRwCJVvdWfdD/wJVAFnNMvvTb0C9rFzqmVOfu4Z1kOKXEu7jp/DlOGpXD4uEw2FlQzzFvU6tQX63KQlZlAYmyUP+LV+W2RbxsrYeXfYNBk9mSdx7iWMvFpkDQ4uu0aDPsRA7Gr6mMgnEvuSWHqFAJnBFy/gL1IbjiI8PhseddQO6d8lvLfz3N56asCZoxI5drTp7VOPbV4gedvsbUrMpJiGJmWgMMRxaCAjZVQWwLeRvta1TYa7no48//QIv+/kjMW0sdGr12DYT/EeI4b9gvqm73srWjA6+s4N1Xb5OEv725jbV4VX581nB8fN4GYEDujBGHMoETSEqLoPNdY5d922xicnrMUcj+GI34GmROgqJi2dY0oTYsZDPspxnAYBpzO5F1zy+q5/a0tlNU1c/mJkzh1xvCQ90iOdxEX44ie0Wiqtg2GJ0SY9rpS+OQ+GD4bZn+rLT1lRLD/hsFwkGIMh2FA2VveQHVj+PWMe5flkBTn4k/nzWba8BBBCQWGp8UzODmOPdHokFqwb3t4vXC14MO77Gi4J1zbNrpwOCBlWDR6YDDs9xjDYRgQmjw+mr1WSKNhr2fs4aWv8pk+PIVrvz49ZODBuBgHWRmJkWlldNmhGqgrsXdNhTMaAJtftQWajv1/tv432EJLzrjwdQyGgwxjOAz9TnWDh/yqhg6e4FuLali9p5K1eZVsL6nj9JnD+cnxodcz0hNjGJUehQXw5lp7Sspd13XZncvh0wdgyHSYflZbesZYoCxsNYPhYMMYDkO/oaoU1zRRVuvukLe1qIbrX9mIx784fv6CUXz/6PEdyonAqPSE3jvzeRqhugDctV2XdTfAl49Att9XtWInlG62hZmSh0NcSu/6YjAcYBjDYegXPD6LvIoG6kNstbVUeW51XqvRECAphP9FfIyDrMxE4mN6OTXVXAsVu+11is5orIJNL8HmV+w6rR32QuE6yDoCUkIv1hsMBzPGcBj6nM622lbUu7nn/e2szauiZdYplA54ZnIsI9PiI1flC0dDBVTtxQ48EIbaItjwPGx9C3zNMO44GHMEfHI/WB57TWPUQttfo7f9MRgOQIzhMPQpZXXNFFeH3mq7fp+Ppz/5iiavxS9OmMi4QYlsKqgJ0gF3OGB0RpR8M+pK7bDn4ajYxfTtj8Knn9qaGZNOgbkX+9cwgIzx9khj5DyY9g1wRSn2lcFwgGEMh6FPaPL42FfbHDJ0SJPHx6Of7ObtTR4mDE7id6dOJSvTDjk2fUTbSCMxzklWRiKxriiEVKsugPrSjumqULwR1j0NeZ8z2BEHsy6A2RdA8tDgssNm2q+kIT2XhDUYDgKM4TD0GstS6t1eGt0+6t0+GtxeLCt02V376vjr0m3kVTZy8hgnvzhjbshdU0NS4hiWGtf7qSlVqNpjhwwJpHgjbH4dyndA5S7bEBx2GZ85jubYeZPC3y8msW0brsFwiGIMh6HbuL0WDW4vDX4j0eSxQk5FBWKp8uq6Av7z2R5SE2L4w9mzGFy3o4PRcDmF0RkJpMRHYWrK8kFlLjTXBKfvXA7LbqN1nWP2hXD4ZeCKx5tdHP5+rgQ7pIhZ1zAc4gyI4RCRR4EzgVJVneVPywSeA8YBucCFqlopIucDtwEVwDmqWi4iE4E7VPWigej/oYbba1HT5KGh2UeDx4vH2z3VyPK6Zu5ZlsO6vCqOnJDJ5Ysnk5oQQ/6W4HLpiTGMSIsPK/naLXweqNjVMWTI3s9hxR20Gg1x2KMNVzjdb/FHux0CcfuXSqPBMFAM1IjjceAB4D8BadcCy1T1ThG51n99DXA5cDhwHvAd7JDqfwRu6M8OH4q0rFNUN3q6HFGE47Nd5dz/QQ5ur8WvFk/i1BnDOkw/xbiEkekJpEZjlAG293f5TntHVAuqsO4p+PLfkDrSFmOyvPYOqZHzOt7DEQOJg+zw6M4oBk00GA4CBsRwqOpHfr3xQM4GTvCfPwGswDYcFhCHLdjkEZHjgGJVzemXzh6C1DV7cXstckoi8KYOw7q8Sv7z2R5ySuuYOMReAB+d0VFza1ByLMNT46MXAt1db480LG9bmqcBVtwJuz+CSSfD8b+zDUvLDqlhM9vKisPeZpuQYaakDIYwiPb0p2RvG7YNxxsBU1VVqpruPxdszfF0ETkFW+SpEPgutg7Hxapa0cm9fwL8BGDYsGELn3322b58lF4TKD4/kPhU8foUSxVPUwMx8ZGJK/ospbBe2VNjsadG2VbpY58/CrlD4Mr5MUzOCHbac4jgbmwgJSV6z11XW0tyfPBvoYTGYmZt/SuJDQXsHHcJ+SPPCG0QHE5wuKirb+jR36I7f8Nol41Gmc7ye5IXKr23Zdun9aRMZ9fRyOvqvCf54Y6RlInkCITMW7x48RpVPazDHwwIKUTeHy/stYxNAddV7fIrQ9S5FLgSOBJ4EfgXkNhZOwsXLtT9nUDx+f7Gsiwtr2vWbcU1uiGvqvX11tL3W8+f/2Kv3vjyRn3+i726bm+lvrWhUO99f7v+6qk1etrdH+rk69/Ssde8oWOveUNn3vSOHnnH+63X4699Q298eWPrvTbmV2lJTaNaltXxuX0+1epC1Zoi1bp9qg2Vqk21qu5GVa+n8wepL9flS99SLfiq7fX5Q6q3j1S9Y7TqqoeD8wq+Ui3OVq0tCbp3T/8W3akX7bLRKNNZfk/yQqX3tmz7tJ6U6ew6GnldnfckP9wxkjKRHMPlAas1zPfq/rSrqkRERqhqkYiMAII23YtIIvB94DTgDew1jwuAS7ANiKEb+Cylot5NWV1zSI/uFrILq7nhlU14LUUEYp0Omr32Xts4l4OJQ5L5+qzhTB6WwuShyYxIi2dbcS2/f3UTXp8V5AWeFOdkVEZCaP1vy2dPMXUVbNDhCnjZowRUoTFgAKoK65+GLx6BQRPglD9C6oi2fHHamuCJmRG/XwaDoY39yXC8BizBnpZaArzaLv8q4D5V9YhIAva2GAt77cMQIV6fRVmdm/L65rC+FgB1buXFNfm8uCYPr2UbFlUYOyiR02cOZ/LQFLIyE3GGWJuYNiKV28+excaCamaPSmPGqFRGpCWEDI0OgM9rBw4MJZrUHssbvH7RHk8DfPhn2LUCJiyGr10NMQlt+bEpkD7GeH0bDL1goLbjPoO9ED5YRPKBm7ENxvMi8kNgD3BhQPmRwCJVvdWfdD/wJVAFnNNvHT+AaXT7KKvreofU9pJa3txYxEfbm/FauUwYnMTeCjsEusvp4MfHTmgNB9IZLTrgaQkxjEiPD+nkB9jbZst3dpRm7QHxjcXwynW2w98RP4M5FwWsZ4i9m6q9N7jBYOg2A7Wr6tthsk4KU74QOCPg+gXsRXJDJ6gqNY1eyuqbaQgRlbYFt9fi4x37eHNjEdtL6oiPcXD0CCcXHj+HsYOS2FpU0zp6iMRoxLocxMc4yEiK7WKLrUJZTtu22aINkLsSRsyF0YeDK0JxpJJs2PI6h+1cAa4Y+PqfYXTAmp4rwY43FTjyMBgMPWZ/mqoyRAmvz6Ki3k15vbvT9YvSmibe3lTM0s3F1DR5GZWewE+Pn8CJ04ZSsXMdowfZ+tkto4f2OBwQH+O0Xy4HCbFO4l3OyLbWepvtV4vR2Ps5vHMdoLDR/5vAGWtrXbS+Um0nvLjUtrSmavjqv6A+nAgsvjbYaCQNtUcaZmutwRA1jOE4iIhkOmpzUTXvbS6hsKqRrcW2xsSi8ZmcOXskc0antTrntd/rHBfjIN7lJD7GQVyMk4QYZ8+DD3oa7emplk6WboVlf6At1LnYX/6ZE22hpaZaO2xIXTGU+c+9TR1uqwhS7Y9+64y1/TGMt7fBEHWM4TjAiXQ6al9tMy+szuOd7OLWr+cTpw7hkiPHMjQldLiNhFgHaQmxpCfGhF+j6C7uBnshvGWBe+tb8MndEJsMltveXeWIgYXfD3bMa4/PY4srFa6FD+8Ey4eKy3boS8i0d005oqBFbjAYOmAMxwGI22vR7PXR4PZR0cl0VKPbx2e7yvhgaykb8quDpIscYutctDcaMS4hPSGWMpeTSUOjLInaXGdvuVUf+NxM2fEIlLxviyKddBNU54f25g6FM8beTjvpJFuFr3Ad65uzWDDtTEhIj26/DQZDEMZwdILl34YatXAY3aTFQDR5go+dbaO1VNmYX80HW0v5dFcZTR6LYalxXHx4FmMGJXL3+zkd/CscDkhLiCE9MZbkOPsjsTXaj9xc6zcalh0n6r2bGVm6GeZ+Gw7/kT06iE+HsUfbU1hq2aMP9fmPFmFV+4bNhDFHUbNxrzEaBkM/YAxHJ9Q22ZKnIhDjdOB0CC6H4HIKLofDfxRcTgcuh+B0SNCUju1laX/dqar/CIoGrUGoQm2Tp1sGoj15lQ0s31rK8m37KKtrJjHWyfGTh3DitKHMGJHaunYxOCnO3iE1Oo1F4zNJT4glJd7Vt8axqdrW+EbtnVPv3wyeRrKnXsnMI86xy8Sm2NNLMeGi1AKWFWBIAo4tEW7J67tnMBgMrRjDEQGq9q//SBGhU1+J9jR5feSWReD8FsDWohq+3FOB22uxuaiG7SV1OATmj8ngB0eP44gJmSE9tBeMy+DE6UNJS4iJLHy5qv0FLQ57aNJdGiuhco89Ysh+GT570PbiPvNu9hXG2+sZqSMj8+J2OACHiVZrMAwwxnD0AdGOG+n2WhRUNZJf2UBeRQPZhbZfRUszw1PjuOyYcXxtytBg72zLh1N8pMY5SI4VkmMEl/jAaoQGX4jpIG079zZC0Xr/FJEfcdhf9A4XOANDf8S0hf9wxrSlN1baznjeJlj5f5CzFMYeA4uvsxfDi8tg6HSziG0wHGAYw9EJ6/OqeH9LScSObz1lV7XFZ6vzmDQ0mcRYF3l+A5FX2UB+ZSMlNU1YLbpD2DGfWoyGAzh9YjwXTfAg7j3QbBHnVJJihKRYB/ExTsQLdBKlIyRKm9EoyQ5etPY1Q0cp8dDUFsHSG+3tt4ddBvO/axuNtCxwVhujYTAcgBjDEYaVOftY8vgXqNo7kOaMSmdIahxxLof/5Ww9j225jnFQXN3E7rJ6RqYlMDglliaPRZPHR7PXPjb5j80eH40ei8qGZnLL3Ch7gtp3OYRR6fFMzIxl8fgExqYIY5KVrCQvO6t8XL28AY8FMQ5YMMhDsjSSlOAkKc5FjLOT9YoWIzB8NgyaaMd28jQGHO3XiOIi8MXa0qvb37VHIg6nHcZj8FS/I16KbQTiUmwt7kAjUJINW96A3R/ac3en/8kebaSMgOQhffI3MxgM/YMxHGFYtauidcrJUti5r5a8ynqavRbNXgtPJx7Z4Yh1CvEuId7l8DvUOWho9gW6vbF4QiLfmxnPiAQvbUsQbf4ZgjBnqIsnF2zDkf8lacPHMSFhFI599baPhMd/dNfbL09D27GhAhrKIurrVICd7RItH6x7upMHTLINicMFNYXYwxaxt9pO/TqkjjLrEwbDQcB+ZThE5HTgXsAJPKK2jOxTwGxs0afr/eVuwNbyeKWv+rJ42lD+tXIXHp9FjAP+eFwcMwa3vV0+S3Fb0OxVmn3Q7FNe3e4mf2c2Rzq2sMqazvgps/jWtFjiXUKck5CRZDeXeXlyeTaLZAurmc45E+YxLtWHCyW+aR9xjSXE1Bfjqi/CWVeE1BYhVXmMbwnVUQm00+5GnP4v8SSITYSYJHvx2fIFGA6BrEUw7lh7tBCTEPT6dFc9R88aA+W74K2rwPLYBuHEG+3F7OZaOwR667Gu7Vi6hTZNb7FDi2SMi/JfyGAwDBT7jeEQESfwIHAKkA98KSJvAY2qOkdE3hORNOww6keo6h/7sj8Lx2bwwqnNVG56j/jRcxkzchb43Di89rSOeBoQbyPiaQBPAw5vIxOtXYyKfRsnPnw4KWk+kbSC4SBOxOEAEUQc9tZYhxNwMKa+hDNjXsaBf+fS1snI+hqoKwlemHbG2NM8KSPBGQelm7G/nB0w82yYdX7bL35nnH1/cQS/ijfAKz+zw5g7Y+DoX8OoBYC0Kyu4S9bC8DkwYp79pb/nUxhzJIycb/erZSFdrY6vwrXw8k/97cTaTnoGg+GgYb8xHMAiYIeq7gIQkWexI+ImiIgDiMGes7kNOwx737J9KXM++D6gUPokfOXAlv8ITybY802AAx+ji9+D4m60qRY0VcLIBfbicfoY+5UxzjYazhj7i71wHTxzkR12wxkDi34KWUd0vV128CTbVyJ3JYw7zh5xhEOcft8IYMLX7FekZIyzp6UiacdgMBxwDJjmeHtE5ALgdFX9kf/6e8AR2PuBTgD+CywDLlfVH3Zxr15rjo/d/Qzj9jyLYP+ur0qbRWXmfLyuBHzOBHzOxIBz+5XQkMfsTXcglhd1uFg/5zZq0qYgaiGqgCJ+D2j7aJFas52Zm+5E1GfXmfsHatKmddm/1OqtpFdtoip9VkTlu0t/6KBHu41o3K+n9zCa412nG81xozneFxrkF2Cva7Rcfw94oF2Z14GRwO+B54Efd3XfHmuO712l+odhqrdk2Me9qyKv99FfIy+vqmteeajbdfqa/tBBj3Yb0bif0RyPTp7RHDea4/1FAZAVcD3anwaAiJwNrAGSgYmqeqGIvCsiT6lq99yuIyFrESx5rfvTLVmLuj01U5M2DY47oft9NBgMhgFgfzIcXwKTRWQ8tsG4GPgOgIjEAFdir3lMpi3anROIBaJvOKBHRsBgMBgOdqIkstB7VNUL/Ap4F3uD6fOqmu3P/iXwhH9ksQFIFJGNwBpVrRqI/hoMBsOhyv404kBV3wLeCpF+T8C5AuE0yw0Gg8HQx+w3Iw6DwWAwHBgYw2EwGAyGbmEMh8FgMBi6hTEcBoPBYOgW+43neF8hIvugXczy/Y/BQGRha/uPNKD6AGsjGu9jT/vUnXrRLhvJc3d1n87ye5IXKr23ZdunhXru9mW6cx2NvK7Oe5Lf/hj43OHKdOdImLzJqtqSH0w4z0Dz6lev+bAemgPYp4cPtDai8T72tE/dqRftspE8d1f36Sy/J3mh0ntbtn1aqOcOUSbi62jkdXXek/wQx9URlIn42FWZUK/9ajuuYb/i9YOkje7S0z51p15fle3NfTrL70leqPTelo3kvWhfpjvX0cjr6rwn+aHyuirT3WOk7QGHwFTVgYCIrNZwwcQMEXOovo/muQ8t9ofnNovj+wcPD3QHDhIO1ffRPPehxYA/txlxGAwGg6FbmBGHwWAwGLqFMRwGg8Fg6BbGcPQzIpIlIstFZLOIZIvIFf70TL+ueo7/mDHQfd3fEZFcEdkoIutEZLU/7aB7H0XkUREpFZFNAWkhn1Ns7hORHSKyQUQWDFzPe0d3/1cOpmcHEBGniKwVkTf81+NFZJX/+Z4TkVh/epz/eoc/f1xf980Yjv7HC/xWVWcARwK/FJEZwLXAMlWdjC2Re+0A9vFAYrGqzgvYZXIwvo+PA6e3Swv3nF/H1qyZjC2f/FA/9bEv6O7/ysH07ABXYEtMtHAXcLeqTgIqgRYJ7R8Clf70u/3l+pbOnILMq+9fwKvAKcA2YIQ/bQSwbaD7tr+/gFxgcLu0g/J9BMYBm7p6TuCfwLdDlTvQX139rxxMz46tgLoMOBF4AxBsb3GXP/8o4F3/+bvAUf5zl7+c9GX/zIhjAPEPKecDq4BhqlrkzyoGhg1Uvw4gFFgqImtE5Cf+tEPlfQz3nKOAvIBy+f60A5oI/1cOpme/B7gasPzXg4AqtQXvIPjZWp/bn1/tL99nGM/xAUJEkoGXgCtVtUZEWvNUVUXE7JPummNVtUBEhgLvicjWwMxD5X082J/zUPtfEZEzgVJVXSMiJwxwd0JiRhwDgF9D/SXgKVX9nz+5RERG+PNHAKUD1b8DBVUt8B9LgZeBRRw672O45ywAsgLKjfanHZB083/lYHn2Y4CzRCQXeBZ7uupeIF1EWn7sBz5b63P789OA8r7soDEc/YzYP5f+DWxR1f8LyHoNWOI/X4I9n2sIg4gkiUhKyzlwKrCJQ+d9DPecrwGX+ncYHQlUB0zrHFD04H/loHh2Vb1OVUer6jjgYuADVb0EWA5c4C/W/rlb3o8L/OX7dhQ20ItAh9oLOBZ7bn4DsM7/+gb2nOQyIAd4H8gc6L7uzy9gArDe/8oGfu9PP+jeR+AZoAjwYM9t/zDcc2Ivoj4I7AQ2AocNdP978dzd+l85mJ494D04AXjDfz4B+ALYAbwAxPnT4/3XO/z5E/q6XybkiMFgMBi6hZmqMhgMBkO3MIbDYDAYDN3CGA6DwWAwdAtjOAwGg8HQLYzhMBgMBkO3MIbDcMAgIj5/JNyW17iB7lM4RGSeiHwjTN4JLRFP+6jtdBH5RU/aE5F7ROR4/3muiAxulz8uMEpvu7xnRWRyb/puODAwhsNwINGodiTcllduS4bf6Wt/+jzPw/Y5GAjSgV90Vag9IjIIOFJVP+phuw9hx1cyHOTsT/9oBkO38P/63SYi/8H2Gs8SkYdEZLVfv+HWgLLfEJGt/oCI9wVoHNwiIk+IyEoR2SMi54nIn8XW+XjHH/ICEVkoIh/6678bEPJihYjcJSJfiMh2ETnOr5NwG3CRf2R0UYTPc6qIfCYiX4nIC/4YTS2//G/1p28UkWn+9CFi61Fki8gj/v4PBu4EJvrb/ov/9ski8qL/PXhKAgM+tXE+8E6IfiWIyNsi8mN/kst/jy3+eyb601cCJweExTAcpBjDYTiQSAiYpnrZnzYZ+LuqzlTVPdge5IcBc4CvicgcEYnHDrn9dVVdCAxpd9+J2PGAzgKeBJar6mygETjDbzzuBy7w138UuD2gvktVFwFXAjerqhu4CXjOPzJ6rqsH83/h3wCcrKoLgNXAbwKKlPnTHwJ+50+7GTu8xEzgRWCMP/1aYKe/7av8afP9/ZuB7YF8TIhuHAOsaZeWDLwOPKOq//KnTcV+z6cDNfhHN6pqYXsvz+3qeQ0HNsZwGA4kAqeqzvWn7VHVzwPKXCgiXwFrgZnYX5TTgF2quttf5pl2931bVT3YYSqctP3q3oitgzEVmIUdgXcd9hf86ID6LcH31vjL94Qj/X39xN/GEmBsF20cix0ED1V9B1vcJxxfqGq+/8t9XZh+jgD2tUt7FXhMVf8TkJanqp/4z5/096OFUmBkJ/0wHASYIaXhQKe+5URExmP/Gj9cVStF5HHsOD5d0Qz2L2YR8WhbHB4L+39EgGxVPaqz+oCPnv9PCfCeqn67j9poDjgPd49GOr5fnwCni8jTAe9L+zhFgdfx/vsYDmLMiMNwMJGKbUiqRWQYtpQo2EpwEwJ2YUW05hDANmCIiBwFdqhvEZnZRZ1aIKUbbXwOHCMik/xtJInIlC7qfAJc6C9/KtCir97dtlvYAkxql3YT9kjmwYC0MS3vBfAd4OOAvCnY602GgxhjOAwHDaq6HnuKaivwNPYXK6raiD0P/46IrMH+Yq3uxn3d2OGq7xKR9dhTPUd3UW05MKOTxfGTRCS/5YX9hf194BkR2QB8hj3F1hm3Aqf6t8d+C1sNr1ZVy7GnvDYFLI5HwpvY0VjbcwX2+tKf/dfbsPW/t2Abq4cA/Ma6UVWLu9Gm4QDERMc1HBKISLKq1vl3Ez0I5Kjq3QPdr94gInGAT1W9/hHAQ6o6r5f3/Bg4U1WrelD3/wE1qvrv3vTBsP9j1jgMhwo/FpElQCz2qOSfA9yfaDAGeN7vv+IGftxF+Uj4rf++VT2oWwX8Nwp9MOznmBGHwWAwGLqFWeMwGAwGQ7cwhsNgMBgM3cIYDoPBYDB0C2M4DAaDwdAtjOEwGAwGQ7f4/zgJa1nDVg1qAAAAAElFTkSuQmCC\n" + "image/png": "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\n", + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" @@ -47,7 +51,10 @@ "cell_type": "code", "execution_count": 2, "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, "outputs": [ { @@ -59,7 +66,9 @@ }, { "data": { - "text/plain": "" + "text/plain": [ + "" + ] }, "execution_count": 2, "metadata": {}, @@ -67,8 +76,10 @@ }, { "data": { - "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n", + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" @@ -91,6 +102,12 @@ { "cell_type": "code", "execution_count": 3, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "name": "stderr", @@ -101,7 +118,9 @@ }, { "data": { - "text/plain": "" + "text/plain": [ + "" + ] }, "execution_count": 3, "metadata": {}, @@ -109,8 +128,10 @@ }, { "data": { - "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n", + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" @@ -130,10 +151,7 @@ "report_b.plot_bionano_accuracy()\n", "# pyplot.xlim(None, 400e3)\n", "pyplot.legend()\n" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", @@ -150,8 +168,10 @@ }, { "data": { - "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n", + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" @@ -203,7 +223,9 @@ "outputs": [ { "data": { - "text/plain": "" + "text/plain": [ + "" + ] }, "execution_count": 5, "metadata": {}, @@ -211,8 +233,10 @@ }, { "data": { - "text/plain": "
", - "image/png": "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\n" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEGCAYAAABrQF4qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAAsTAAALEwEAmpwYAAAU20lEQVR4nO3dfbBlVX3m8e+D3YAIykv3MB0abZhgxoYhAa6IE18oa8YASYkaJ5E4o2AMU6JWXsqZwjCWiRnLipoqpaIiOgQxCBID6jg46KAOVkqIt0XaBgRaFGgk0qhokHIU+M0fezWevt7X7nP79l39/VSduvustc7ea911znP32fvcfVJVSJL6tddSd0CStLgMeknqnEEvSZ0z6CWpcwa9JHVuxVJ3YKpVq1bVunXrlrobkrSsbNiw4YGqWj1d3W4X9OvWrWNycnKpuyFJy0qSu2aq89CNJHXOoJekzhn0ktQ5g16SOmfQS1LnDHpJ6pxBL0mdM+glqXMGvSR1zqCXpM4Z9JLUOYNekjpn0EtS5wx6SeqcQS9JnTPoJalzBr0kdc6gl6TOGfSS1DmDXpI6Z9BLUucMeknqnEEvSZ0z6CWpcwa9JHVuzqBPclGS+5NsmqE+Sc5PsjnJxiTHT6l/cpItSf56XJ2WJM3ffPboLwZOmaX+VOCodjsbeP+U+r8ArtuRzkmSdt6cQV9V1wHfn6XJ6cAlNbgeODDJGoAkJwCHAp8dR2clSQs3jmP0hwH3jNzfAhyWZC/gr4A3zrWCJGcnmUwyuXXr1jF0SZK0zWKejD0HuLqqtszVsKourKqJqppYvXr1InZJkvY8K8awjnuBw0fur21lzwaem+QcYH9g7yQPVdW5Y9imJGmexhH0nwJen+Ry4FnAD6vqPuAV2xokOROYMOQladebM+iTXAacDKxKsgV4C7ASoKouAK4GTgM2Aw8DZy1WZyVJCzdn0FfVGXPUF/C6OdpczPAxTUnSLuZ/xkpS5wx6SeqcQS9JnTPoJalzBr0kdc6gl6TOGfSS1DmDXpI6Z9BLUucMeknqnEEvSZ0z6CWpcwa9JHXOoJekzhn0ktQ5g16SOmfQS1LnDHpJ6pxBL0mdM+glqXMGvSR1zqCXpM4Z9JLUOYNekjpn0EtS5wx6SeqcQS9JnTPoJalzBr0kdc6gl6TOzRn0SS5Kcn+STTPUJ8n5STYn2Zjk+Fb+a0m+nOTmVv674+68JGlu89mjvxg4ZZb6U4Gj2u1s4P2t/GHglVV1dHv8u5McuMM9lSTtkBVzNaiq65Ksm6XJ6cAlVVXA9UkOTLKmqm4fWcd3ktwPrAYe3Mk+S5IWYBzH6A8D7hm5v6WVPS7JicDewDfHsD1J0gIs+snYJGuAjwBnVdVjM7Q5O8lkksmtW7cudpckaY8yjqC/Fzh85P7aVkaSJwP/Czivqq6faQVVdWFVTVTVxOrVq8fQJUnSNuMI+k8Br2yfvjkJ+GFV3Zdkb+AqhuP3Hx/DdiRJO2DOk7FJLgNOBlYl2QK8BVgJUFUXAFcDpwGbGT5pc1Z76O8AzwMOSXJmKzuzqr42vu5LkuYyn0/dnDFHfQGvm6b8b4G/3fGuSZLGwf+MlaTOGfSS1DmDXpI6Z9BLUucMeknqnEEvSZ0z6CWpcwa9JHXOoJekzhn0ktQ5g16SOmfQS1LnDHpJ6pxBL0mdM+glqXMGvSR1zqCXpM4Z9JLUOYNekjpn0EtS5wx6SeqcQS9JnTPoJalzBr0kdc6gl6TOGfSS1DmDXpI6Z9BLUucMeknqnEEvSZ0z6CWpc3MGfZKLktyfZNMM9UlyfpLNSTYmOX6k7lVJ7mi3V42z45Kk+ZnPHv3FwCmz1J8KHNVuZwPvB0hyMPAW4FnAicBbkhy0M52dy0dvuJv/9D9u4KM33L2Ym+nChrt+wHu/sJkNd/1gqbuiRdTDa2JPea4u5jhXzNWgqq5Lsm6WJqcDl1RVAdcnOTDJGuBk4HNV9X2AJJ9j+INx2U73ehofveFu/vSqrwPwpTse4MLrvsmhT953MTa17P3zT37GN/7pn3msYK/Av/6XB3DAviuXulsas+/+6Cd8+3sPA8v3NbGnPFe3jbMK9lm5F5e+5iROeNr49ovHcYz+MOCekftbWtlM5b8gydlJJpNMbt26dYc68ZlN9213//s//ukOrWdP8KOfPMJjNSw/VsN99Wfqa2A5vib2lOfqtnEW8LNHHuP6O7831vXPuUe/K1TVhcCFABMTE7Uj6zj1mDV86Y4HHr9/7qnP4Pee9dTxdLAzG+76Aa/40PX87JHHWLliL97z8uPGuveg3cPou1xYnq+JPeW5OnWcJx15yFjXP46gvxc4fOT+2lZ2L8Phm9HyL45he9Pa9gT+zKb7OPWYNcvuCb0rnfC0g7j0NSdx/Z3f46QjD+nyhaM+XhN7ynN1sceZ4dD6HI2GY/Sfrqpjpqn7TeD1wGkMJ17Pr6oT28nYDcC2T+F8FThh2zH7mUxMTNTk5OSCBiFJe7okG6pqYrq6Offok1zGsGe+KskWhk/SrASoqguAqxlCfjPwMHBWq/t+kr8AvtJW9da5Ql6SNH7z+dTNGXPUF/C6GeouAi7asa5JksbB/4yVpM4Z9JLUOYNekjpn0EtS5wx6SeqcQS9JnTPoJalzBr0kdc6gl6TOGfSS1DmDXpI6Z9BLUucMeknqnEEvSZ0z6CWpcwa9JHXOoJekzhn0ktQ5g16SOmfQS1LnDHpJ6pxBL0mdM+glqXMGvSR1zqCXpM4Z9JLUOYNekjpn0EtS5wx6SeqcQS9JnZtX0Cc5JcltSTYnOXea+qcluTbJxiRfTLJ2pO4dSW5OcmuS85NknAOQJM1uzqBP8gTgvcCpwHrgjCTrpzR7F3BJVR0LvBV4e3vsvwV+HTgWOAZ4JvD8sfVekjSn+ezRnwhsrqo7q+qnwOXA6VParAc+35a/MFJfwL7A3sA+wErguzvbaUnS/M0n6A8D7hm5v6WVjboJeGlbfglwQJJDqurLDMF/X7tdU1W37lyXJUkLMa6TsW8Enp/kRoZDM/cCjyb5ZeAZwFqGPw4vSPLcqQ9OcnaSySSTW7duHVOXJEkwv6C/Fzh85P7aVva4qvpOVb20qo4DzmtlDzLs3V9fVQ9V1UPAZ4BnT91AVV1YVRNVNbF69eodG4kkaVrzCfqvAEclOSLJ3sDLgU+NNkiyKsm2db0JuKgt382wp78iyUqGvX0P3UjSLjRn0FfVI8DrgWsYQvqKqro5yVuTvKg1Oxm4LcntwKHA21r5x4FvAl9nOI5/U1X9z/EOQZI0m1TVUvdhOxMTEzU5ObnU3ZCkZSXJhqqamK7O/4yVpM4Z9JLUOYNekjpn0EtS5wx6SeqcQS9JnTPoJalzBr0kdc6gl6TOGfSS1DmDXpI6Z9BLUucMeknqnEEvSZ0z6CWpcwa9JHXOoJekzhn0ktQ5g16SOmfQS1LnDHpJ6pxBL0mdM+glqXMGvSR1zqCXpM4Z9JLUOYNekjpn0EtS5wx6SeqcQS9JnTPoJalz8wr6JKckuS3J5iTnTlP/tCTXJtmY5ItJ1o7UPTXJZ5PcmuSWJOvG2H9J0hzmDPokTwDeC5wKrAfOSLJ+SrN3AZdU1bHAW4G3j9RdAryzqp4BnAjcP46OS5LmZz579CcCm6vqzqr6KXA5cPqUNuuBz7flL2yrb38QVlTV5wCq6qGqengsPZckzct8gv4w4J6R+1ta2aibgJe25ZcAByQ5BHg68GCSK5PcmOSd7R3CdpKcnWQyyeTWrVsXPgpJ0ozGdTL2jcDzk9wIPB+4F3gUWAE8t9U/EzgSOHPqg6vqwqqaqKqJ1atXj6lLkiSYX9DfCxw+cn9tK3tcVX2nql5aVccB57WyBxn2/r/WDvs8AnwCOH4M/ZYkzdN8gv4rwFFJjkiyN/By4FOjDZKsSrJtXW8CLhp57IFJtu2mvwC4Zee7LUmarzmDvu2Jvx64BrgVuKKqbk7y1iQvas1OBm5LcjtwKPC29thHGQ7bXJvk60CAD459FJKkGaWqlroP25mYmKjJycml7oYkLStJNlTVxHR1/mesJHXOoJekzhn0ktQ5g16SOmfQS1LnDHpJ6pxBL0mdM+glqXMGvSR1zqCXpM4Z9JLUOYNekjpn0EtS5wx6SeqcQS9JnTPoJalzBr0kdc6gl6TOGfSS1DmDXpI6Z9BLUucMeknqnEEvSZ0z6CWpc6mqpe7DdpJsBe7aiVWsAh4YU3eWkuPYvTiO3U8vYxnXOJ5WVaunq9jtgn5nJZmsqoml7sfOchy7F8ex++llLLtiHB66kaTOGfSS1Lkeg/7Cpe7AmDiO3Yvj2P30MpZFH0d3x+glSdvrcY9ekjTCoJekznUT9ElOSXJbks1Jzl3q/gAkOTzJF5LckuTmJH/Yyg9O8rkkd7SfB7XyJDm/jWFjkuNH1vWq1v6OJK8aKT8hydfbY85PkkUczxOS3Jjk0+3+EUluaNv+WJK9W/k+7f7mVr9uZB1vauW3JfmNkfJdMn9JDkzy8STfSHJrkmcvx/lI8sftObUpyWVJ9l0u85HkoiT3J9k0UrboczDTNsY8jne259bGJFclOXCkbkG/6x2ZzxlV1bK/AU8AvgkcCewN3ASs3w36tQY4vi0fANwOrAfeAZzbys8F/rItnwZ8BghwEnBDKz8YuLP9PKgtH9Tq/rG1TXvsqYs4nj8BPgp8ut2/Anh5W74AeG1bPge4oC2/HPhYW17f5mYf4Ig2Z0/YlfMHfBh4TVveGzhwuc0HcBjwLeCJI/Nw5nKZD+B5wPHAppGyRZ+DmbYx5nG8EFjRlv9yZBwL/l0vdD5n7etivJh29Q14NnDNyP03AW9a6n5N089PAv8euA1Y08rWALe15Q8AZ4y0v63VnwF8YKT8A61sDfCNkfLt2o2572uBa4EXAJ9uL6IHRp7Uj88BcA3w7La8orXL1HnZ1m5XzR/wFIaAzJTyZTUfDEF/D0PIrWjz8RvLaT6AdWwfkIs+BzNtY5zjmFL3EuDS6X6Hc/2ud+T1NVs/ezl0s+2Jv82WVrbbaG+vjgNuAA6tqvta1T8Bh7blmcYxW/mWacoXw7uB/wo81u4fAjxYVY9Ms+3H+9vqf9jaL3R843YEsBX4mwyHoD6U5Ekss/moqnuBdwF3A/cx/H43sPzmY9SumIOZtrFYXs3wjgIWPo4deX3NqJeg360l2R/4e+CPqupHo3U1/FnerT/jmuS3gPurasNS92UnrWB4q/3+qjoO+DHDW/jHLZP5OAg4neEP1y8BTwJOWdJOjdGumIPF3kaS84BHgEsXaxsL0UvQ3wscPnJ/bStbcklWMoT8pVV1ZSv+bpI1rX4NcH8rn2kcs5WvnaZ83H4deFGSbwOXMxy+eQ9wYJIV02z78f62+qcA35tjHLti/rYAW6rqhnb/4wzBv9zm498B36qqrVX1M+BKhjlabvMxalfMwUzbGKskZwK/Bbyi/UFhjv5OV/49Fj6fMxv38cOluDHsqd3JsIez7YTG0btBvwJcArx7Svk72f6k0Dva8m+y/Ymnf2zlBzMcWz6o3b4FHNzqpp54Om2Rx3QyPz8Z+3dsf7LonLb8OrY/WXRFWz6a7U9I3clwMmqXzR/wJeBX2vKftblYVvMBPAu4GdivbefDwBuW03zwi8foF30OZtrGmMdxCnALsHpKuwX/rhc6n7P2czFeTEtxYzg7fzvDGezzlro/rU/PYXh7uBH4WrudxnA87VrgDuD/jDxBA7y3jeHrwMTIul4NbG63s0bKJ4BN7TF/zRwnZcYwppP5edAf2V5Um9uTcp9Wvm+7v7nVHzny+PNaX29j5BMpu2r+gF8DJtucfKKFxLKbD+DPgW+0bX2kBciymA/gMoZzCz9jeJf1+7tiDmbaxpjHsZnh+PnX2u2CHf1d78h8znTzEgiS1LlejtFLkmZg0EtS5wx6SeqcQS9JnTPoJalzBr2WTJK1ST7Zrib4zSTv2XaFvintfinJx+exvqtHrxa4wL78WZI3tuWLkzyc5ICR+ncnqSSr5ljPQzuy/VnWt2706ogLbZPki0mW/Rdoa+cY9FoS7dKxVwKfqKqjgKcD+wNvm9JuRVV9p6peNtc6q+q0qnpwTF3czHCZAZLsxfDfwLvFf1tLC2XQa6m8APhJVf0NQFU9Cvwx8Ook5yT5VJLPA9eO7rEm2S/JFRmu8X9Vux73RKv7dpJVrf2tST6Y4Zrtn03yxNbmD5J8JclNSf4+yX4z9O9y4Hfb8snAPzBcu4S2nj/JcC34TUn+aLoVJPkvbVsbk/z5SPkrW9lNST7Syi5O8rKRNr/wziDD9wG8c2Sd/3maNk9Mcnkb/1XAE2cYn/YgBr2WytEMV1x8XA0XfLubn1987GVV9fwpjzsH+EFVrQfeDJwww/qPAt5bVUcDDwK/3cqvrKpnVtWvArcy/DfjdG4HVrcLiJ3BEPzA8MUWwFkMlyI4CfiDJMeNPjjJC1sfTmT4b9wTkjwvydHAfwNe0PrwhzNsfzq/D/ywqp4JPLNt94gpbV4LPFxVzwDewsy/H+1BVszdRFoSn6uq709T/hyGC6pRVZuSbJzh8d+qqq+15Q0M1yQBOCbJf2f4wpH9Ga7tPZMrGa4l8ixgdO/5OcBVVfVjgCRXAs8Fbhxp88J221a2P0Pw/yrwd1X1QBvDdGOcyQuBY0f2/J/S1nn7SJvnAee3dW+c5fejPYhBr6VyC7DdcfckTwaeynCI5Mc7uf7/N7L8KD8/hHEx8OKquqldZfDkWdbxMYY/Eh+uqseysG8FDPD2qvrAdoXJG2Zo/wjtHXY7J/ALJ6XbOt9QVdv9cZrXV8lpj+ahGy2Va4H9krwShuPPwF8xBPHDszzuH4DfaY9ZD/ybBW73AOC+dvnoV8zWsKruYrgQ1fumVH0JeHE7X/Akhm8S+tKUNtcwnG/Yv/X1sCT/Avg88B+SHNLKD27tv83PD7O8CFg5TZeuAV7b+k6Sp7ftj7oO+L1Wfwxw7Gxj1J7BPXotiaqqJC8B3pfkzQw7HVcDf8pwTHwm7wM+nOQWhqs33szwDTvz9WaGb/na2n4eMFvjqXvkreyrSS5muHIgwIeq6sYpbT6b5BnAl9s7gYeA/1hVNyd5G/B/kzzKcGjnTOCDwCeT3AT8b6Z/R/MhhkNQX22fWtoKvHhKm/czfIPWrQznIJb7l8VoDLx6pZaVtue/sqp+kuRfMVxu9leq6qdL3DVpt+UevZab/YAvtMMXYfgyBkNemoV79JLUOU/GSlLnDHpJ6pxBL0mdM+glqXMGvSR17v8D7J9FM3iphy0AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" @@ -235,7 +259,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.9.10 ('om')", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -249,9 +273,8 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.10" + "version": "3.9.13" }, - "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "ba88cba0bd1684bf681f0a514929985c4631defba69dd57c081f0ebc100d81ea" @@ -259,5 +282,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/find_ip.py b/find_ip.py new file mode 100644 index 0000000..59ea705 --- /dev/null +++ b/find_ip.py @@ -0,0 +1,5 @@ +import socket +s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) +s.connect(("8.8.8.8", 80)) +print(s.getsockname()[0]) +s.close() \ No newline at end of file diff --git a/jupyter-lab.sh b/jupyter-lab.sh new file mode 100755 index 0000000..d0c56e6 --- /dev/null +++ b/jupyter-lab.sh @@ -0,0 +1,21 @@ +#!/bin/bash + +### +# CS236781: Deep Learning +# jupyter-lab.sh +# +# This script is intended to help you run jupyter lab on the course servers. +# +# Example usage: +# +# 1. First, activate the relevant conda env +# $ conda activate cs236781-hwN +# +# 2. Run this script on a compute node: +# $ srun -c 2 --gres=gpu:1 --pty jupyter-lab.sh +# + + +unset XDG_RUNTIME_DIR + +xvfb-run -a -s "-screen 0 1440x900x24" jupyter lab --no-browser --ip=$(python find_ip.py) --port-retries=100 diff --git a/tutorial/00.ipynb b/tutorial/00.ipynb index 708f092..e2d798a 100644 --- a/tutorial/00.ipynb +++ b/tutorial/00.ipynb @@ -7,12 +7,14 @@ "outputs": [ { "data": { - "text/plain": "selected: 0it [00:00, ?it/s]", "application/vnd.jupyter.widget-view+json": { + "model_id": "c12c821cffd04029aa2976744cb6e303", "version_major": 2, - "version_minor": 0, - "model_id": "e8987c07e145468fa1cdb2b0f5d28c11" - } + "version_minor": 0 + }, + "text/plain": [ + "selected: 0it [00:00, ?it/s]" + ] }, "metadata": {}, "output_type": "display_data" @@ -26,6 +28,15 @@ "selector.select_molecules()" ] }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Yevgeni's part " + ] + }, { "cell_type": "code", "execution_count": 2, @@ -33,36 +44,62 @@ "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" + "image/png": "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\n", + "text/plain": [ + "
" + ] }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "selector.selected[0].plot_bnx_item()" + "selector.selected[2].plot_bnx_item()" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "text/plain": "1 [14453.0, 19686.0, 22554.0, 31191.0, 33547.0, ...\n2 [15924.0, 22064.0, 28594.0, 34027.0, 34664.0, ...\n3 [12734.0, 13105.0, 17438.0, 20151.0, 26344.0, ...\n4 [12985.0, 14575.0, 23028.0, 27375.0, 35689.0, ...\n5 [19314.0, 19924.0, 22572.0, 48655.0, 52154.0, ...\n6 [76216.0, 78491.0, 80268.0, 84078.0, 92283.0, ...\n7 [10487.0, 12916.0, 15501.0, 17193.0, 18142.0, ...\n8 [61805.0, 66488.0, 70256.0, 73189.0, 79269.0, ...\n9 [14566.0, 19799.0, 22667.0, 30973.0, 33330.0, ...\n10 [18514.0, 19074.0, 29291.0, 29794.0, 32222.0, ...\n11 [60457.0, 62233.0, 66043.0, 73015.0, 81386.0, ...\n12 [14568.0, 19721.0, 24617.0, 33245.0, 35595.0, ...\n13 [16004725.0, 16010361.0, 16021642.0, 16136233....\n14 [16004725.0, 16010361.0, 16021642.0, 16031132....\n15 [17050953.0, 17052426.0, 17058646.0, 17060180....\n16 [14134.0, 19375.0, 28229.0, 38092.0, 44607.0, ...\n17 [66653.0, 70073.0, 84695.0, 84709.0, 90870.0, ...\n18 [18868.0, 19428.0, 29621.0, 30124.0, 32552.0, ...\n19 [61294.0, 64162.0, 72800.0, 75156.0, 79187.0, ...\n20 [70156.0, 70892.0, 78032.0, 80876.0, 81845.0, ...\n21 [5010514.0, 5015860.0, 5019820.0, 5022073.0, 5...\n22 [10514803.0, 10516334.0, 10530198.0, 10532311....\n23 [11554.0, 12933.0, 16630.0, 24178.0, 223951.0,...\n24 [11554.0, 12933.0, 16630.0, 24178.0, 223951.0,...\ndtype: object" + "text/plain": [ + "1 [14453.0, 19686.0, 22554.0, 31191.0, 33547.0, ...\n", + "2 [15924.0, 22064.0, 28594.0, 34027.0, 34664.0, ...\n", + "3 [12734.0, 13105.0, 17438.0, 20151.0, 26344.0, ...\n", + "4 [12985.0, 14575.0, 23028.0, 27375.0, 35689.0, ...\n", + "5 [19314.0, 19924.0, 22572.0, 48655.0, 52154.0, ...\n", + "6 [76216.0, 78491.0, 80268.0, 84078.0, 92283.0, ...\n", + "7 [10487.0, 12916.0, 15501.0, 17193.0, 18142.0, ...\n", + "8 [61805.0, 66488.0, 70256.0, 73189.0, 79269.0, ...\n", + "9 [14566.0, 19799.0, 22667.0, 30973.0, 33330.0, ...\n", + "10 [18514.0, 19074.0, 29291.0, 29794.0, 32222.0, ...\n", + "11 [60457.0, 62233.0, 66043.0, 73015.0, 81386.0, ...\n", + "12 [14568.0, 19721.0, 24617.0, 33245.0, 35595.0, ...\n", + "13 [16004725.0, 16010361.0, 16021642.0, 16136233....\n", + "14 [16004725.0, 16010361.0, 16021642.0, 16031132....\n", + "15 [17050953.0, 17052426.0, 17058646.0, 17060180....\n", + "16 [14134.0, 19375.0, 28229.0, 38092.0, 44607.0, ...\n", + "17 [66653.0, 70073.0, 84695.0, 84709.0, 90870.0, ...\n", + "18 [18868.0, 19428.0, 29621.0, 30124.0, 32552.0, ...\n", + "19 [61294.0, 64162.0, 72800.0, 75156.0, 79187.0, ...\n", + "20 [70156.0, 70892.0, 78032.0, 80876.0, 81845.0, ...\n", + "21 [5010514.0, 5015860.0, 5019820.0, 5022073.0, 5...\n", + "22 [10514803.0, 10516334.0, 10530198.0, 10532311....\n", + "23 [11554.0, 12933.0, 16630.0, 24178.0, 223951.0,...\n", + "24 [11554.0, 12933.0, 16630.0, 24178.0, 223951.0,...\n", + "dtype: object" + ] }, - "execution_count": 3, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from deepom.bionano_compare import BionanoCompare\n", - "\n", + " \n", "compare = BionanoCompare()\n", "compare.read_cmap()\n", "compare.make_refs()\n", @@ -79,7 +116,7 @@ "output_type": "stream", "text": [ "BasicUNet features: (32, 32, 64, 128, 256, 32).\n", - "loading checkpoint: /home/ynogin/DeepOM/data/pretrained/checkpoint.pickle \n", + "loading checkpoint: /home/deepom/DeepOM/data/pretrained/checkpoint.pickle \n", "\n", "\n" ] @@ -88,6 +125,7 @@ "source": [ "from deepom.config import Config\n", "from deepom.localizer import LocalizerModule\n", + "import monai\n", "\n", "localizer_module = LocalizerModule()\n", "localizer_module.checkpoint_search_dir = Config.CHECKPOINT_SEARCH_DIR\n", @@ -100,9 +138,20 @@ "execution_count": 5, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/deepom/miniconda3/envs/deepom/lib/python3.9/site-packages/monai/utils/deprecate_utils.py:107: FutureWarning: : Class `AddChannel` has been deprecated since version 0.8. please use MetaTensor data type and monai.transforms.EnsureChannelFirst instead.\n", + " warn_deprecated(obj, msg, warning_category)\n" + ] + }, { "data": { - "text/plain": "(0.0, 500.0)" + "text/plain": [ + "[,\n", + " ]" + ] }, "execution_count": 5, "metadata": {}, @@ -110,61 +159,526 @@ }, { "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" + "image/png": "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\n", + "text/plain": [ + "
" + ] }, + "metadata": {}, "output_type": "display_data" } ], "source": [ "from matplotlib.pyplot import eventplot, imshow, figure, xlim\n", - "\n", + "i=3\n", + "#good molecules: 0,7,6\n", "figure(figsize=(30, 3))\n", - "image_input = selector.selected[0].bionano_image.segment_image[0]\n", + "image_input = selector.selected[i].bionano_image.segment_image[0]\n", "target_width = localizer_module.image_channels\n", "source_width = image_input.shape[0] // 2 + 1\n", "image_input = image_input[source_width - target_width // 2: source_width + target_width // 2 + 1]\n", "imshow(image_input, aspect=\"auto\", cmap=\"gray\")\n", "inference_item = localizer_module.inference_item(image_input)\n", - "eventplot([inference_item.loc_pred, selector.selected[0].locs / 375], colors=[\"b\", \"r\"])\n", - "xlim([0, 500])" + "eventplot([inference_item.loc_pred, selector.selected[i].locs / 375], colors=[\"b\", \"r\"])\n", + "# xlim([0, 500])" ] }, { "cell_type": "code", "execution_count": 6, + "metadata": {}, "outputs": [ { "data": { - "text/plain": "(array([58098802., 58680228.]), array([58098802., 58671662.]))" + "text/plain": [ + "5" + ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], + "source": [ + "image_input.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 13.62765551, 14.69124418, 23.33261916, 24.51522267,\n", + " 25.50928301, 26.58675516, 30.57306689, 31.59910369,\n", + " 39.75977594, 53.46091932, 54.76914692, 59.69638968,\n", + " 60.32009465, 62.13172352, 81.36835283, 92.25711015,\n", + " 104.64738894, 136.74546587, 177.50475317, 183.28804687,\n", + " 184.38054922, 194.34272605, 202.60690212, 203.20942205,\n", + " 210.70013279, 220.84153754, 221.66309744, 222.1707582 ,\n", + " 227.25238493, 238.62885648, 253.79309464, 254.39727512,\n", + " 289.1616852 , 300.50595552, 302.67289424, 303.17812455,\n", + " 318.45596069, 345.80586493, 361.65986097, 378.6508916 ,\n", + " 384.55221623, 385.60984963, 393.8283971 , 394.72864676,\n", + " 417.32794437, 434.66052061, 436.82654315, 452.78752726,\n", + " 460.70751959, 469.79502082, 470.47018319, 472.43312231,\n", + " 484.77677447, 485.26909918, 506.55482447, 507.62342405,\n", + " 531.48677334, 532.27867573, 544.57513833, 545.683079 ,\n", + " 571.50059468, 573.39070004, 580.68801707, 625.09858536,\n", + " 641.90912002, 662.49586284, 664.47526345, 665.58178395,\n", + " 673.77827388, 688.83857065, 689.67820913, 696.64106244,\n", + " 698.35934952, 704.81717694, 713.52115536, 714.225042 ,\n", + " 725.5085426 , 726.71889669, 734.64316005, 736.24394959,\n", + " 769.62940079, 770.67075402, 795.58865517, 800.66904682,\n", + " 801.47147375, 802.28625613, 809.4571307 , 810.19663729,\n", + " 814.56565148, 818.6598841 , 819.42343786, 833.58003873,\n", + " 847.33934107, 875.86981428, 892.07858589, 914.399288 ,\n", + " 915.81143552, 927.34197298, 945.30678874, 954.30603004,\n", + " 979.41674182, 1006.23423088, 1007.62674797, 1026.50637466,\n", + " 1027.46480256, 1034.53963119, 1043.4956795 , 1073.77183861,\n", + " 1103.18495062, 1106.407848 , 1132.91151232, 1157.78690499,\n", + " 1173.8553763 , 1179.19440801, 1181.50089288, 1193.47073808,\n", + " 1266.34698594, 1271.88704669, 1331.35273421, 1346.87199515,\n", + " 1364.45881298, 1371.19480506, 1373.74786121, 1379.19523534,\n", + " 1388.37259352, 1398.89153105, 1455.18788372, 1470.42331028,\n", + " 1486.68467534, 1507.52701181, 1540.74915057, 1546.67920989,\n", + " 1609.50428236, 1633.55969316, 1680.39748034])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inference_item.loc_pred" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[383.94174896, 438.72989656, 428.95707327, ..., 352.79875754,\n", + " 370.84626992, 333.61155199],\n", + " [369.3935238 , 410.62972932, 416.44276819, ..., 335.21174937,\n", + " 369.14969057, 331.46528203],\n", + " [356.32925793, 380.88318202, 383.35976819, ..., 318.36574273,\n", + " 321.7592158 , 337.55566412],\n", + " ...,\n", + " [341.4815472 , 340.04637107, 323.09475669, ..., 302.42101605,\n", + " 346.78199445, 325.21036221],\n", + " [325.1487856 , 331.30338666, 315.24091029, ..., 294.87585741,\n", + " 341.2244638 , 322.77018471],\n", + " [340.31373312, 333.02659735, 321.54666912, ..., 303.3535465 ,\n", + " 331.55681085, 309.6041115 ]]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selector.selected[i].bionano_image.segment_image" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([70523527., 71052014.]), array([8232631., 8555209.]))" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from deepom.aligner import Aligner\n", + "from deepom.my_utils import overlap_percentage\n", + "import numpy as np\n", + "\n", + "ref_id = selector.selected[i].xmap_item.ref_id\n", + "aligner_reg = Aligner()\n", + "aligner_reg.align_params = {}\n", + "\n", + "aligner_rev = Aligner()\n", + "aligner_rev.align_params = {}\n", "\n", - "ref_id = selector.selected[0].xmap_item.ref_id\n", - "aligner = Aligner()\n", - "aligner.align_params = {}\n", - "# qry = selector.selected[0].locs / 375 * 335\n", "qry = inference_item.loc_pred * 335\n", - "aligner.make_alignment(qry=qry, ref=compare.refs[ref_id])\n", - "selector.selected[0].xmap_item.ref_lims, aligner.alignment_ref[[0, -1]], # aligner.alignment_qry" + "\n", + "inverted_qry = np.sort((inference_item.loc_pred[-1] - inference_item.loc_pred)*335) #not sure, need to make sure its correct\n", + "\n", + "aligner_reg.make_alignment(qry=qry, ref=compare.refs[ref_id])\n", + "selector.selected[i].xmap_item.ref_lims, aligner_reg.alignment_ref[[0, -1]] # aligner.alignment_qry" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([70523527., 71052014.]), array([70525302., 71052014.]))" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } ], + "source": [ + "aligner_rev.make_alignment(qry=inverted_qry, ref=compare.refs[ref_id])\n", + "selector.selected[i].xmap_item.ref_lims, aligner_rev.alignment_ref[[0, -1]], # aligner.alignment_qry" + ] + }, + { + "cell_type": "code", + "execution_count": 11, "metadata": { - "collapsed": false - } + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 99.8317852841028)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "regular_overlap = overlap_percentage(selector.selected[i].xmap_item.ref_lims, aligner_reg.alignment_ref[[0, -1]])\n", + "reverse_overlap = overlap_percentage(selector.selected[i].xmap_item.ref_lims, aligner_rev.alignment_ref[[0, -1]])\n", + "\n", + "aligner = aligner_reg if regular_overlap > reverse_overlap else aligner_rev\n", + "\n", + "regular_overlap*100, reverse_overlap*100" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "ename": "ImportError", + "evalue": "cannot import name 'getAligner' from 'deepom.my_utils' (/home/deepom/DeepOM/deepom/my_utils.py)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mImportError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [12], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mscipy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01minterpolate\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m interp1d\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mdeepom\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mmy_utils\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m getAligner , get_scaler_from_aligner\n", + "\u001b[0;31mImportError\u001b[0m: cannot import name 'getAligner' from 'deepom.my_utils' (/home/deepom/DeepOM/deepom/my_utils.py)" + ] + } + ], + "source": [ + "import numpy\n", + "from scipy.interpolate import interp1d\n", + "from deepom.my_utils import getAligner , get_scaler_from_aligner" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "scaler = get_scaler_from_aligner(aligner)\n", + "\n", + "z = aligner.alignment_ref\n", + "y = (z-z[0]) / (scaler*335)\n", + "y = y+aligner.alignment_qry[0] /335\n", + "x = aligner.alignment_qry/335\n", + "f = interp1d(x=y,y=x)\n", + "\n", + "# a = numpy.zeros_like(aligner.alignment_ref)\n", + "# b = numpy.zeros_like(aligner.alignment_ref)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# scaler = scaler = get_scaler_from_aligner(aligner_rev)\n", + "\n", + "# z = aligner_rev.alignment_ref\n", + "# y = (z-z[0]) / (scaler*335)\n", + "# y = y+aligner_rev.alignment_qry[0] /335\n", + "# x = aligner_rev.alignment_qry/335\n", + "# f = interp1d(x=y,y=x)\n", + "\n", + "# a = numpy.zeros_like(aligner.alignment_ref)\n", + "# b = numpy.zeros_like(aligner.alignment_ref)\n", + "\n", + "# ref = compare.refs[ref_id]\n", + "# start, end = aligner_rev.alignment_ref[[0, -1]]\n", + "# start_index = np.argmax(ref >= start)\n", + "# end_index = np.argmin(ref <= end)\n", + "# ref_crop = ref[start_index:end_index]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ref = compare.refs[ref_id]\n", + "start, end = aligner.alignment_ref[[0, -1]]\n", + "start_index = np.argmax(ref >= start)\n", + "end_index = np.argmin(ref <= end)\n", + "ref_crop = ref[start_index:end_index]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "z_hat = (ref_crop-ref_crop[0]) / (scaler*335)\n", + "z_hat = z_hat+x[0]\n", + "y_hat = f(z_hat)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "figure(figsize=(30, 3))\n", + "image_input = selector.selected[i].bionano_image.segment_image[0]\n", + "target_width = localizer_module.image_channels\n", + "source_width = image_input.shape[0] // 2 + 1\n", + "image_input = image_input[source_width - target_width // 2: source_width + target_width // 2 + 1]\n", + "imshow(image_input, aspect=\"auto\", cmap=\"gray\")\n", + "eventplot([inference_item.loc_pred, x,y_hat], colors=[\"g\", \"b\", \"r\"])\n", + "xlim([0, 800])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Our Part" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from deepom.utils import Config\n", + "from deepom.bionano_compare import DataPrep\n", + "from deepom.bionano_utils import BNXItemCrop, BionanoFileData\n", + "from numpy.random import default_rng\n", + "from deepom.localizer import LocalizerModule\n", + "from deepom.aligner import Aligner\n", + "from deepom.my_utils import getAligner\n", + "from matplotlib.pyplot import eventplot, imshow, figure, xlim\n", + "from pandas import Series, DataFrame\n", + "import numpy as np\n", + "from tqdm import tqdm, tnrange , tqdm_notebook\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from deepom.config import Config\n", + "from deepom.localizer import LocalizerModule\n", + "import monai\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "crop_size_bp = 50 *1000\n", + "crop_size = int(crop_size_bp / Config.BIONANO_NOMINAL_SCALE)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "localizer_module = LocalizerModule()\n", + "localizer_module.checkpoint_search_dir = Config.CHECKPOINT_SEARCH_DIR\n", + "localizer_module.load_checkpoint = True\n", + "localizer_module.init_ensure_module()\n", + "localizer_module.rng = default_rng(seed=42)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cmap_file_data = BionanoFileData()\n", + "cmap_file_data.file = Config.REF_CMAP_FILE\n", + "cmap_file_data.read_bionano_file()\n", + "\n", + "refs = Series({\n", + " ref_id: ref_df[ref_df[\"LabelChannel\"] == 1][\"Position\"].values\n", + " for ref_id, ref_df in cmap_file_data.file_df.groupby(\"CMapId\")\n", + " })" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Iterate over selected molecules, crop localize and align" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "rng = default_rng(seed=42)\n", + "mol_ranks = dict.fromkeys(range(24),0)\n", + "\n", + "for i, mol in tqdm_notebook(enumerate(selector.selected)):\n", + "\n", + " \n", + " image_len = mol.bionano_image.segment_image.shape[-1]\n", + " start = rng.integers(0,image_len - crop_size)\n", + " stop = start + crop_size\n", + " \n", + " segment_image = mol.bionano_image.segment_image[...,start: stop]\n", + " crop = BNXItemCrop(mol, (start, stop), i)\n", + " crop.crop_size_pixels = crop_size\n", + " crop.crop_size_bp = crop_size_bp\n", + " crop.segment_image = segment_image\n", + " \n", + " # finished croping image. moving to locolaizer\n", + " \n", + " figure(figsize=(30, 3))\n", + " image_input = crop.segment_image[0]\n", + " target_width = localizer_module.image_channels\n", + " source_width = image_input.shape[0] // 2 + 1\n", + " image_input = image_input[source_width - target_width // 2: source_width + target_width // 2 + 1]\n", + " # imshow(image_input, aspect=\"auto\", cmap=\"gray\")\n", + " inference_item = localizer_module.inference_item(image_input)\n", + " # eventplot([inference_item.loc_pred, selector.selected[0].locs / 375], colors=[\"b\", \"r\"])\n", + " # xlim([0, 50])\n", + " \n", + " # run analyzer for each molecule, saving all results\n", + " qry = inference_item.loc_pred * 335\n", + " inverted_qry = np.sort((stop - inference_item.loc_pred)*335) #not sure, need to make sure its correct\n", + " \n", + "\n", + " \n", + " len_ref = range(1,len(refs)+1)\n", + " scores = {}\n", + " for j in tqdm_notebook(len_ref,desc = str(i+1)):\n", + " \n", + " aligner1 = getAligner()\n", + " aligner1.make_alignment(qry=qry, ref=refs[j])\n", + " score = aligner1.score\n", + " \n", + " aligner2 = getAligner()\n", + " aligner2.make_alignment(qry=inverted_qry, ref=refs[j])\n", + " \n", + " scores[str(j)] = max(score , aligner2.score)\n", + " scores[str(j)] = score\n", + "\n", + " scores = dict(sorted(scores.items(), key=lambda score: -score[1]))\n", + " mol_rank = list(scores.keys()).index(str(mol.xmap_item.ref_id))\n", + " mol_ranks[mol_rank] += 1 \n", + "\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mol_ranks[0]/sum(mol_ranks)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "localizer_module.image_data.targets" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = 2 + 3" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.9.10 ('om')", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -178,9 +692,8 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.10" + "version": "3.9.13" }, - "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "ba88cba0bd1684bf681f0a514929985c4631defba69dd57c081f0ebc100d81ea" @@ -188,5 +701,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/tutorial/Benchmark.ipynb b/tutorial/Benchmark.ipynb new file mode 100644 index 0000000..fbd3cf2 --- /dev/null +++ b/tutorial/Benchmark.ipynb @@ -0,0 +1,282 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 7, + "id": "e6d5dc29-7aaf-4642-b2b6-0bba818c1a4a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n", + "BasicUNet features: (32, 32, 64, 128, 256, 32).\n", + "loading checkpoint: /home/deepom/DeepOM/data/pretrained/checkpoint.pickle \n", + "\n", + "\n", + "BasicUNet features: (32, 64, 64, 128, 256, 32).\n", + "BasicUNet features: (32, 32, 64, 128, 256, 32).\n", + "loading checkpoint: /home/deepom/DeepOM/data/pretrained/checkpoint.pickle \n", + "\n", + "\n", + "BasicUNet features: (32, 64, 64, 128, 256, 32).\n", + "search dir is /home/deepom/DeepOM/data2/pretrained\n", + "loading checkpoint: /home/deepom/DeepOM/data2/pretrained/checkpoint_smooth_10.pickle \n", + "\n", + "\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "from deepom.benchmark import LocalizerBenchmark\n", + "from deepom.config import Config\n", + "from deepom.localizer import LocalizerModule\n", + "from deepom.localizer_real_data import DataLocalizer\n", + "import monai\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "#Ignores warnings, probably a good idea to remove if debugging \n", + "\n", + "localizer_yvg = LocalizerModule()\n", + "\n", + "localizer_yvg.checkpoint_search_dir = Config.CHECKPOINT_SEARCH_DIR\n", + "localizer_yvg.load_checkpoint = True\n", + "localizer_yvg.init_ensure_module()\n", + "\n", + "localizer_our = DataLocalizer()\n", + "\n", + "localizer_our.checkpoint_search_dir = Config.SECOND_CHECKPOINT_SEARCH_DIR\n", + "localizer_our.checkpoint_file = \"checkpoint_smooth_10.pickle\"\n", + "localizer_our.load_checkpoint = True\n", + "localizer_our.init_ensure_module()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "624e64dc-be7c-45d3-bd17-0278dfbf4e45", + "metadata": {}, + "outputs": [], + "source": [ + "benchmark = LocalizerBenchmark(localizer_our, localizer_yvg)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "aeff6721-f385-4809-8346-d9445d3e5502", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "68ca766678cc46678fffcce613f856bc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "selected: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "crop_sizes [400000.]\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f6a098942a584726b1ae91290a3638f8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "crops: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "starting to run aligners\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8b9e67a67c4441f1bd59f80eb497f74b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "qry items: 0%| | 0/10 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "benchmark.run_benchmark()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "9993c26e-5a62-44f9-82c3-ef575640651c", + "metadata": {}, + "outputs": [], + "source": [ + "benchmark.read_compute_results()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "77641d4e-5d6c-47c0-8495-ef606251f79d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-02-06 14:46:42,251 - No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import pyplot\n", + "\n", + "benchmark.plot_a()\n", + "pyplot.legend()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/GroundTruth.ipynb b/tutorial/GroundTruth.ipynb new file mode 100644 index 0000000..7b14ee5 --- /dev/null +++ b/tutorial/GroundTruth.ipynb @@ -0,0 +1,368 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4e0f6df9", + "metadata": {}, + "source": [ + "## Ground Truth Generation Notebook." + ] + }, + { + "cell_type": "markdown", + "id": "f5cf3885", + "metadata": {}, + "source": [ + "This notebook generates a pre configured number of molecules and shows their alignments" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8cb058b7", + "metadata": {}, + "outputs": [], + "source": [ + "Molecule = 1 #Pick molecule Number between 0 and 512" + ] + }, + { + "cell_type": "markdown", + "id": "464f7ac2", + "metadata": { + "tags": [] + }, + "source": [ + "### Imports " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "53264c07", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import numpy\n", + "from scipy.interpolate import interp1d\n", + "from deepom.bionano_utils import MoleculeSelector\n", + "\n", + "from deepom.config import Config\n", + "from deepom.localizer import LocalizerModule\n", + "import monai\n", + "\n", + "from deepom.aligner import Aligner\n", + "from deepom.my_utils import get_aligner, overlap_percentage, get_scaler_from_aligner\n", + "import numpy as np\n", + "\n", + "from deepom.bionano_compare import BionanoCompare\n", + "from matplotlib.pyplot import eventplot, imshow, figure, xlim, title\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "965b0136", + "metadata": {}, + "source": [ + "### selector Creation" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4b286ce7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "KeyboardInterrupt\n", + "\n" + ] + } + ], + "source": [ + "#Need To check about Caching\n", + "selector = MoleculeSelector()\n", + "selector.top_mol_num = 5\n", + "selector.select_molecules()" + ] + }, + { + "cell_type": "markdown", + "id": "abceb2f3", + "metadata": {}, + "source": [ + "### Refs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6a15cd4b", + "metadata": {}, + "outputs": [], + "source": [ + "compare = BionanoCompare()\n", + "compare.read_cmap()\n", + "compare.make_refs()\n", + "compare.refs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23fe066a-09c1-41f2-8a10-6241a11e7fb6", + "metadata": {}, + "outputs": [], + "source": [ + "selector.selected[Molecule].locs" + ] + }, + { + "cell_type": "markdown", + "id": "31b6af01", + "metadata": {}, + "source": [ + "### Localizer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3251d1ea", + "metadata": {}, + "outputs": [], + "source": [ + "localizer_module = LocalizerModule()\n", + "localizer_module.checkpoint_search_dir = Config.CHECKPOINT_SEARCH_DIR\n", + "localizer_module.load_checkpoint = True\n", + "localizer_module.init_ensure_module()\n", + "\n", + "image_input = selector.selected[Molecule].bionano_image.segment_image[0]\n", + "target_width = localizer_module.image_channels\n", + "source_width = image_input.shape[0] // 2 + 1\n", + "image_input = image_input[source_width - target_width // 2: source_width + target_width // 2 + 1]\n", + "inference_item = localizer_module.inference_item(image_input)" + ] + }, + { + "cell_type": "markdown", + "id": "a9f5abe0", + "metadata": {}, + "source": [ + "### Alignment" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "820e3eb8", + "metadata": {}, + "outputs": [], + "source": [ + "ref_id = selector.selected[Molecule].xmap_item.ref_id\n", + "\n", + "aligner_reg = get_aligner()\n", + "aligner_rev = get_aligner()\n", + "\n", + "qry = inference_item.loc_pred * 335\n", + "offset = image_input.shape[-1]-inference_item.loc_pred[-1]\n", + "inverted_qry = np.sort((image_input.shape[-1] - inference_item.loc_pred)*335)#not sure, need to make sure its correct\n", + "\n", + "aligner_reg.make_alignment(qry=qry, ref=compare.refs[ref_id])\n", + "aligner_rev.make_alignment(qry=inverted_qry, ref=compare.refs[ref_id])" + ] + }, + { + "cell_type": "markdown", + "id": "e8f49c6a", + "metadata": {}, + "source": [ + "### Selecting the best orientation based on overlap percentage" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a2bb5a1", + "metadata": {}, + "outputs": [], + "source": [ + "regular_overlap = overlap_percentage(selector.selected[Molecule].xmap_item.ref_lims, aligner_reg.alignment_ref[[0, -1]])\n", + "print(\"regular overlap: \"+str(regular_overlap))\n", + "print(\"regular score: \"+str(aligner_reg.score))\n", + "\n", + "reverse_overlap = overlap_percentage(selector.selected[Molecule].xmap_item.ref_lims, aligner_rev.alignment_ref[[0, -1]])\n", + "print(\"reverse ovelap: \"+str(reverse_overlap))\n", + "print(\"reverse score: \"+str(aligner_rev.score))\n", + "\n", + "aligner = aligner_reg if regular_overlap > reverse_overlap else aligner_rev\n", + "\n", + "selector.selected[Molecule].xmap_item.ref_lims, aligner.alignment_ref" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b610c004", + "metadata": {}, + "outputs": [], + "source": [ + "scaler = get_scaler_from_aligner(aligner)\n", + "\n", + "z = aligner.alignment_ref\n", + "y = (z-z[0]) / (scaler*335)\n", + "y = y+aligner.alignment_qry[0]/335\n", + "x = aligner.alignment_qry/335\n", + "func = interp1d(x=y,y=x)\n", + "\n", + "ref = compare.refs[ref_id]\n", + "start, end = aligner.alignment_ref[[0, -1]]\n", + "start_index = np.argmax(ref >= start)\n", + "end_index = np.argmin(ref <= end)\n", + "ref_crop = ref[start_index:end_index]\n", + "\n", + "z_hat = (ref_crop-ref_crop[0]) / (scaler*335)\n", + "z_hat = z_hat+x[0]\n", + "y_hat = func(z_hat)" + ] + }, + { + "cell_type": "markdown", + "id": "f0b03262", + "metadata": { + "tags": [] + }, + "source": [ + "### Plot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "70f42797", + "metadata": {}, + "outputs": [], + "source": [ + "figure(figsize=(30, 3))\n", + "image_input = selector.selected[Molecule].bionano_image.segment_image[0]\n", + "target_width = localizer_module.image_channels\n", + "source_width = image_input.shape[0] // 2 + 1\n", + "image_input = image_input[source_width - target_width // 2: source_width + target_width // 2 + 1]\n", + "imshow(image_input, aspect=\"auto\", cmap=\"gray\")\n", + "eventplot([inference_item.loc_pred, x,y_hat], colors=[\"g\", \"b\", \"r\"])\n", + "#xlim([0, 800])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "55c22440-da6c-46bb-b516-81de12696e6a", + "metadata": {}, + "outputs": [], + "source": [ + "z = aligner.alignment_ref\n", + "y = (z-z[0]) / (scaler*335)\n", + "y_rev = np.sort(image_input.shape[-1]-y)-offset\n", + "\n", + "x = aligner.alignment_qry/335\n", + "x_rev = np.sort(image_input.shape[-1]-x)\n", + "\n", + "func_rev = interp1d(x=y_rev,y=x_rev, bounds_error=False, fill_value='extrapolate')\n", + "\n", + "ref = compare.refs[ref_id]\n", + "start, end = aligner.alignment_ref[[0, -1]]\n", + "start_index = np.argmax(ref >= start)\n", + "end_index = np.argmin(ref <= end)\n", + "ref_crop = ref[start_index:end_index]\n", + "\n", + "z_hat = (ref_crop-ref_crop[0]) / (scaler*335)\n", + "z_hat_rev = np.sort(image_input.shape[-1]-z_hat)-offset\n", + "\n", + "print(z_hat_rev)\n", + "\n", + "y_hat = func_rev(z_hat_rev)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6864fe55-35c5-4a48-b527-0299b78104bc", + "metadata": {}, + "outputs": [], + "source": [ + "figure(figsize=(30, 3))\n", + "image_input = selector.selected[Molecule].bionano_image.segment_image[0]\n", + "target_width = localizer_module.image_channels\n", + "source_width = image_input.shape[0] // 2 + 1\n", + "image_input = image_input[source_width - target_width // 2: source_width + target_width // 2 + 1]\n", + "imshow(image_input, aspect=\"auto\", cmap=\"gray\")\n", + "eventplot([inference_item.loc_pred, x_rev, y_hat], colors=[\"g\", \"b\", \"r\"])\n", + "xlim([0,800])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "971c9513", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "from deepom.data_fetcher import DataFetcher\n", + "num_mols = 20\n", + "data_fetcher = DataFetcher(num_molecules=num_mols)\n", + "# data_fetcher.generate_ground_truth_plots_simulated()\n", + "data_fetcher.generate_ground_truth_plots()\n", + "# data_fetcher.generate_ground_truth_simulated(2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "56933794", + "metadata": {}, + "outputs": [], + "source": [ + "# import image module\n", + "from IPython.display import Image,display\n", + " \n", + "# get the image\n", + "for img_index in range(num_mols):\n", + " display(Image(url=f\"{data_fetcher.save_path}/ground_truth_{img_index}.png\"))\n", + " \n", + " " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/LocalizerTutorial.ipynb b/tutorial/LocalizerTutorial.ipynb new file mode 100644 index 0000000..dd9b4d6 --- /dev/null +++ b/tutorial/LocalizerTutorial.ipynb @@ -0,0 +1,54 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "72628ee2-fbe2-4b1b-aa7e-c277d5da8bc1", + "metadata": {}, + "outputs": [], + "source": [ + "from deepom.bionano_utils import MoleculeSelector\n", + "from deepom.utils import Config\n", + "from deepom.bionano_compare import DataPrep\n", + "from deepom.bionano_utils import BNXItemCrop, BionanoFileData\n", + "from numpy.random import default_rng\n", + "from deepom.localizer import LocalizerModule\n", + "from deepom.aligner import Aligner\n", + "from deepom.my_utils import getAligner\n", + "from matplotlib.pyplot import eventplot, imshow, figure, xlim\n", + "from pandas import Series, DataFrame\n", + "import numpy as np\n", + "from tqdm import tqdm, tnrange , tqdm_notebook\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "from deepom.config import Config\n", + "from deepom.localizer import LocalizerModule\n", + "import monai\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/overlap_comparsion.ipynb b/tutorial/overlap_comparsion.ipynb new file mode 100644 index 0000000..13839a9 --- /dev/null +++ b/tutorial/overlap_comparsion.ipynb @@ -0,0 +1,299 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 8, + "id": "12aceee1-37e6-4f1c-8e06-9005807ea1ba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n", + "env: \"WANDB_NOTEBOOK_NAME\"=\"Real Data Training \" #for WandB, change the second param as required.\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "%env \"WANDB_NOTEBOOK_NAME\" \"Real Data Training \" #for WandB, change the second param as required.\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "from deepom.localizer_real_data import DataLocalizer\n", + "from deepom.data_fetcher import DataFetcher\n", + "#Ignores warnings, probably a good idea to remove if debugging \n", + "\n", + "import timeit\n", + "import logging\n", + "import sys\n", + "import numpy\n", + "from deepom.config import Config\n", + "logging.getLogger().setLevel(logging.WARNING)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6e34bef7-e109-42c9-825a-9d5331866f08", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BasicUNet features: (32, 32, 64, 128, 256, 32).\n", + "loading checkpoint: /home/deepom/DeepOM/data/pretrained/checkpoint.pickle \n", + "\n", + "\n" + ] + } + ], + "source": [ + "\n", + "num_mols = 10\n", + "data_fetcher = DataFetcher(num_molecules=num_mols)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e0493877-f3b8-4adb-98bb-7a60482e77dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + " mol locs scaled : [ 35.25066667 65.21066667 85.392 92.60533333 106.46133333\n", + " 113.76266667 118.25866667 126.76 172.76 187.04\n", + " 196.61866667 242.848 275.04266667 280.61066667 292.83733333\n", + " 324.936 357.64266667 393.29066667 404.44533333 416.43466667\n", + " 430.37866667 448.496 453.12 473.22133333 483.504\n", + " 490.53066667 496.86666667 542.264 547.86666667 567.296\n", + " 574.256 595.632 601.472 629.336 663.248\n", + " 670.56 677.33333333 702.54666667 715.79466667 756.992\n", + " 796.88266667 806.19466667 817.856 822.45066667 830.37066667\n", + " 840.968 850.77066667 861.14666667 907.61866667 911.664\n", + " 932.936 935.608 954.18666667 971.44533333 984.136\n", + " 999.112 1008.26933333 1035.928 1077.46666667 1089.22933333\n", + " 1105.84533333 1112.33866667 1127.51733333 1130.296 1135.07733333\n", + " 1142.888 1148.13066667 1182.27466667 1192.05066667 1199.176\n", + " 1241.00533333 1246.48533333 1282.67466667 1307.20266667 1323.05866667\n", + " 1339.82133333 1363.712 1369.09066667 1375.784 1387.112\n", + " 1391.92 1397.47466667 1409.48533333 1450.544 1475.01866667\n", + " 1516.24533333 1539.296 1551.976 1557.8 1576.448\n", + " 1617.03466667 1628.70933333 1650.47733333 1657.416 1670.66666667\n", + " 1678.02133333] alignment ref: [ 2623.54729138 5551.88462898 9797.85912752 12246.25618428\n", + " 18866.63419694 20283.41466129 22931.87930107 23623.54025558\n", + " 36255.31213015 37434.95054141 43122.52945945 45040.46202391\n", + " 49124.44881588 57157.00667813 70856.43450707 79328.65596816\n", + " 92817.39261568 96975.08952081 98903.25103492 100561.89533025\n", + " 104352.57388994 106352.23943174 108241.74894899 116032.46072143\n", + " 121723.12692314 126879.05999839 127099.64845836 135401.56277061\n", + " 147359.03028406 149216.12481534 162916.03477091 165445.26488721\n", + " 169103.89847331 180170.80437817 181956.05999589 184528.98085691\n", + " 186108.67144406 186366.77622616 187820.53740293 192334.09818769\n", + " 194499.67573971 199806.99635506 203867.19943166 218205.79548717\n", + " 226724.85184923 227569.59792554 230523.44590753 235281.47928447\n", + " 239573.03361326 245320.49197704 251343.28119338 252870.39064623\n", + " 259459.28973198 259817.2191754 261181.81741729 276324.73692924\n", + " 277097.06789821 280297.92467147 283507.44343042 286852.01425195\n", + " 289415.67711819 291353.94641131 295094.02556174 298221.15600318\n", + " 310241.97426707 311294.70521212 311928.55690718 325041.74904287\n", + " 329354.41389054 337791.15335405 340153.41318965 342803.02923858\n", + " 354155.04835129 363009.0672642 363618.30900639 365759.92277063\n", + " 372416.05523318 374638.79752189 380690.35263836 381433.36302847\n", + " 381692.65358388 383539.59460545 398496.58082098 400698.04695994\n", + " 402925.09949021 406265.76963469 413088.25219065 414516.76958442\n", + " 414937.22459406 420861.27123088 428549.56170112 429660.52869216\n", + " 430565.14099568 433223.94319862 445256.50332391 456102.46909022\n", + " 466915.77063553 470506.72436029 470920.40929019 471149.19035852\n", + " 472881.86106309 483609.09654662 499189.13379401 502369.62752387\n", + " 507419.82995406 522523.38859096 524882.77536482 525428.34250778\n", + " 526780.6146276 528528.81585762 529397.45211631 533681.86542809\n", + " 535918.84802863 536481.43536657 537436.94238454 543159.48936522]\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n" + ] + } + ], + "source": [ + "data_fetcher.generate_ground_truth_plots()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4deafce5-2a8b-45e5-8395-d0b839466191", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# import image module\n", + "from IPython.display import Image,display\n", + " \n", + "# get the image\n", + "for img_index in range(num_mols):\n", + " display(Image(url=f\"../data/ground_truth/ground_truth_{img_index}.png\"))\n", + " \n", + " " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/real_data_training.ipynb b/tutorial/real_data_training.ipynb new file mode 100644 index 0000000..6ca2aca --- /dev/null +++ b/tutorial/real_data_training.ipynb @@ -0,0 +1,15790 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "69556c88", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "env: \"WANDB_NOTEBOOK_NAME\"=\"Real Data Training \" #for WandB, change the second param as required.\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "%env \"WANDB_NOTEBOOK_NAME\" \"Real Data Training \" #for WandB, change the second param as required.\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "from deepom.localizer_real_data import DataLocalizer\n", + "#Ignores warnings, probably a good idea to remove if debugging \n", + "\n", + "import timeit\n", + "import logging\n", + "import sys\n", + "import numpy\n", + "from deepom.config import Config\n", + "logging.getLogger().setLevel(logging.WARNING)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "77e6d3d9", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BasicUNet features: (32, 64, 64, 128, 256, 32).\n", + "BasicUNet features: (32, 32, 64, 128, 256, 32).\n", + "loading checkpoint: /home/deepom/DeepOM/data/pretrained/checkpoint.pickle \n", + "\n", + "\n" + ] + } + ], + "source": [ + "localizer = DataLocalizer()\n", + "\n", + "# train_data, test_data = localizer.prepare_data()\n", + "train_data = localizer.pickle_load(Config.GROUND_TRUTH_DIR.with_suffix(\".train_data_simulated_images_512.pickle\"))\n", + "test_data = localizer.pickle_load(Config.GROUND_TRUTH_DIR.with_suffix(\".test_data_simulated_images_512.pickle\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3d315e15-f508-4b96-b5c1-c32eacd3d69b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "shape segment: (9, 1570)\n", + "image_input size: (5, 1570)\n", + "image_input size: \n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "image = test_data[0].molecule.bionano_image.segment_image[0]\n", + "\n", + "localizer.inference_item(image)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6e1b359f-2a69-4d76-9981-d336f4a3afca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "shape segment: (9, 1570)\n", + "image_input size: (5, 1570)\n", + "image_input size: (5, 1570)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "image = test_data[0].molecule.bionano_image.segment_image[0]\n", + "\n", + "localizer.inference_item(image)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2230575d-fa17-4aba-b716-a6e05d6653bc", + "metadata": {}, + "outputs": [], + "source": [ + "# train_data[0].plot_simulated()\n", + "# segment_3d = test_data[0].molecule.bionano_image.segment_image[0]\n", + "# inference_item = localizer.inference_item(segment_3d)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "80946dc9-26ee-41a3-b0b8-a11f10333761", + "metadata": {}, + "outputs": [], + "source": [ + "num_train_sumples = 5" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b179e4f-22c6-4be1-8ca8-ee17ea6def0c", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c06f33cf593c4945a842355ba1072e99", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "DataLocalizer-20230206-accurate-dingo: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "wandb version 0.13.9 is available! To upgrade, please run:\n", + " $ pip install wandb --upgrade" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.13.5" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /home/deepom/out/LocalizerModule/DataLocalizer-20230206-accurate-dingo/wandb/run-20230206_175349-j5dnihdy" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run DataLocalizer-20230206-accurate-dingo to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "56daa822bcd84cd2a6c75450b4074b6e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/10000 [00:00 1\u001b[0m rng \u001b[38;5;241m=\u001b[39m \u001b[43mdefault_rng\u001b[49m()\n", + "\u001b[0;31mNameError\u001b[0m: name 'default_rng' is not defined" + ] + } + ], + "source": [ + "rng = default_rng()\n", + "\n", + "# selector.selected[0].make_simulated_image(refs=compare.refs, rng=rng)\n", + "# molecule = selector.selected[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4b146eaa-a801-4ea0-aa5a-d7a980ba46e5", + "metadata": {}, + "outputs": [], + "source": [ + "from deepom.bionano_utils import BNXItem\n", + "from matplotlib.pyplot import eventplot, imshow, figure, xlim, savefig, gca\n", + "from numpy.random import default_rng\n", + "\n", + "segment_3d = molecule.bionano_image.segment_image[0]\n", + "figure(figsize=(30, 3))\n", + "image_input = segment_3d\n", + "target_width = 5\n", + "source_width = image_input.shape[0] // 2 + 1\n", + "image_input = image_input[source_width - target_width // 2: source_width + target_width // 2 + 1]\n", + "imshow(image_input, aspect=\"auto\", cmap=\"gray\")\n", + "# gca().pcolorfast((0, image_input.shape[-1]), (-.5, .5), image_input, cmap='gray')\n", + "\n", + "eventplot(molecule.locs / 375, colors=[\"b\"])\n", + "# molecule = selector.selected[0] \n", + "# molecule.plot_bnx_item()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7ce30a36-ae92-4d77-8364-87c2e0e325ab", + "metadata": {}, + "outputs": [], + "source": [ + "image_input.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "194952c8-d409-47af-aad9-4534441ef729", + "metadata": {}, + "outputs": [], + "source": [ + "bnx_item: \"BNXItem\" = selector.selected[0]\n", + "bnx_item.make_simulated_image(refs=compare.refs, rng=rng)\n", + "bnx_item.plot_simulated()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aab77deb-4e85-4390-b553-ef2d4a91c132", + "metadata": {}, + "outputs": [], + "source": [ + "bnx_item.bionano_image.segment_image[0].shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "326810ff-39e0-42da-be6e-ed7cea104d3c", + "metadata": {}, + "outputs": [], + "source": [ + "imshow(bnx_item.bionano_image.segment_image[0], aspect=\"auto\", cmap=\"gray\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c5c2757-425c-4bf9-9d44-58395b7f5af4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c83727fb-575a-442a-934a-7dedf09dafde", + "metadata": {}, + "outputs": [], + "source": [ + "molecule = selector.selected[0]\n", + "segment_3d = molecule.bionano_image.segment_image[0]\n", + "figure(figsize=(30, 3))\n", + "image_input = segment_3d\n", + "target_width = 5\n", + "source_width = image_input.shape[0] // 2 + 1\n", + "image_input = image_input[source_width - target_width // 2: source_width + target_width // 2 + 1]\n", + "imshow(image_input, aspect=\"auto\", cmap=\"gray\")\n", + "\n", + "eventplot(molecule.locs / 375, colors=[\"b\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "91df0bc4-e326-4263-8213-ccc72d20d11f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/tests.ipynb b/tutorial/tests.ipynb new file mode 100644 index 0000000..3230956 --- /dev/null +++ b/tutorial/tests.ipynb @@ -0,0 +1,59 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "78a9a0d2-4c9a-4490-9de4-e18f6605cac8", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "import deepom.my_utils as utils" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c2a4ca4f-6dd1-441a-9818-3363552c6f19", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n" + ] + } + ], + "source": [ + "prediction = [3.2, 10, 14.5, 20, 24]\n", + " \n", + "gt = [3,15,20, 28, 30]\n", + "\n", + "print(utils.fn_precentage(prediction, prediction))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}