From fd116ebb3a7f54235626719e392d98ff6d1a769c Mon Sep 17 00:00:00 2001 From: Roman Kh <rhudor@gmail.com> Date: Wed, 22 Nov 2017 15:01:35 +0300 Subject: [PATCH] Initial public release --- .gitattributes | 6 + .gitignore | 6 + .gitmodules | 3 + CONTRIBUTING.md | 38 + LICENSE | 4 +- MANIFEST.in | 16 + README.md | 98 +- cardio/__init__.py | 8 + cardio/batch/__init__.py | 3 + cardio/batch/ecg_batch.py | 1057 ++ cardio/batch/ecg_batch_tools.py | 525 + cardio/batch/ecg_dataset.py | 35 + cardio/batch/kernels.py | 40 + cardio/batch/utils.py | 58 + cardio/dataset | 1 + cardio/models/__init__.py | 6 + cardio/models/dirichlet_model/__init__.py | 3 + .../models/dirichlet_model/dirichlet_model.py | 237 + .../dirichlet_model_training.ipynb | 1018 ++ cardio/models/fft_model/__init__.py | 3 + cardio/models/fft_model/fft_model.py | 53 + .../models/fft_model/fft_model_training.ipynb | 311 + cardio/models/hmm/__init__.py | 2 + cardio/models/hmm/hmm.py | 105 + cardio/models/hmm/hmmodel_training.ipynb | 660 ++ cardio/models/keras_custom_objects.py | 202 + cardio/models/layers.py | 84 + cardio/models/metrics.py | 207 + cardio/pipelines/__init__.py | 3 + cardio/pipelines/pipelines.py | 306 + cardio/tests/data/A00001.hea | 2 + cardio/tests/data/A00001.mat | Bin 0 -> 18024 bytes cardio/tests/data/A00002.hea | 2 + cardio/tests/data/A00002.mat | Bin 0 -> 18024 bytes cardio/tests/data/A00004.hea | 2 + cardio/tests/data/A00004.mat | Bin 0 -> 18024 bytes cardio/tests/data/A00005.hea | 2 + cardio/tests/data/A00005.mat | Bin 0 -> 36024 bytes cardio/tests/data/A00008.hea | 2 + cardio/tests/data/A00008.mat | Bin 0 -> 36024 bytes cardio/tests/data/A00013.hea | 2 + cardio/tests/data/A00013.mat | Bin 0 -> 18024 bytes cardio/tests/data/REFERENCE.csv | 8528 +++++++++++++++++ cardio/tests/test_ecgbatch.py | 416 + docs/Makefile | 20 + docs/api/cardio.batch.rst | 56 + docs/api/cardio.models.rst | 25 + docs/api/cardio.pipelines.rst | 27 + docs/api/cardio.rst | 11 + docs/conf.py | 183 + docs/index.rst | 104 + docs/intro/batch.rst | 79 + docs/intro/dirichlet_model.png | Bin 0 -> 24064 bytes docs/intro/fft_model.PNG | Bin 0 -> 27702 bytes docs/intro/hmmodel.png | Bin 0 -> 57474 bytes docs/intro/intro.rst | 11 + docs/intro/introduction.rst | 77 + docs/intro/models.rst | 197 + docs/intro/pipelines.rst | 36 + docs/make.bat | 36 + pylintrc | 19 + requirements-shippable.txt | 5 + requirements.txt | 7 + setup.py | 54 + shippable.yml | 29 + tutorials/Code_from_article.ipynb | 384 + tutorials/I.CardIO.ipynb | 350 + tutorials/II.Pipelines.ipynb | 332 + tutorials/III.Models.ipynb | 366 + 69 files changed, 16459 insertions(+), 3 deletions(-) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 .gitmodules create mode 100644 CONTRIBUTING.md create mode 100644 MANIFEST.in create mode 100644 cardio/__init__.py create mode 100644 cardio/batch/__init__.py create mode 100644 cardio/batch/ecg_batch.py create mode 100644 cardio/batch/ecg_batch_tools.py create mode 100644 cardio/batch/ecg_dataset.py create mode 100644 cardio/batch/kernels.py create mode 100644 cardio/batch/utils.py create mode 160000 cardio/dataset create mode 100644 cardio/models/__init__.py create mode 100644 cardio/models/dirichlet_model/__init__.py create mode 100644 cardio/models/dirichlet_model/dirichlet_model.py create mode 100644 cardio/models/dirichlet_model/dirichlet_model_training.ipynb create mode 100644 cardio/models/fft_model/__init__.py create mode 100644 cardio/models/fft_model/fft_model.py create mode 100644 cardio/models/fft_model/fft_model_training.ipynb create mode 100644 cardio/models/hmm/__init__.py create mode 100644 cardio/models/hmm/hmm.py create mode 100644 cardio/models/hmm/hmmodel_training.ipynb create mode 100644 cardio/models/keras_custom_objects.py create mode 100644 cardio/models/layers.py create mode 100644 cardio/models/metrics.py create mode 100644 cardio/pipelines/__init__.py create mode 100644 cardio/pipelines/pipelines.py create mode 100644 cardio/tests/data/A00001.hea create mode 100644 cardio/tests/data/A00001.mat create mode 100644 cardio/tests/data/A00002.hea create mode 100644 cardio/tests/data/A00002.mat create mode 100644 cardio/tests/data/A00004.hea create mode 100644 cardio/tests/data/A00004.mat create mode 100644 cardio/tests/data/A00005.hea create mode 100644 cardio/tests/data/A00005.mat create mode 100644 cardio/tests/data/A00008.hea create mode 100644 cardio/tests/data/A00008.mat create mode 100644 cardio/tests/data/A00013.hea create mode 100644 cardio/tests/data/A00013.mat create mode 100644 cardio/tests/data/REFERENCE.csv create mode 100644 cardio/tests/test_ecgbatch.py create mode 100644 docs/Makefile create mode 100644 docs/api/cardio.batch.rst create mode 100644 docs/api/cardio.models.rst create mode 100644 docs/api/cardio.pipelines.rst create mode 100644 docs/api/cardio.rst create mode 100644 docs/conf.py create mode 100644 docs/index.rst create mode 100644 docs/intro/batch.rst create mode 100644 docs/intro/dirichlet_model.png create mode 100644 docs/intro/fft_model.PNG create mode 100644 docs/intro/hmmodel.png create mode 100644 docs/intro/intro.rst create mode 100644 docs/intro/introduction.rst create mode 100644 docs/intro/models.rst create mode 100644 docs/intro/pipelines.rst create mode 100644 docs/make.bat create mode 100644 pylintrc create mode 100644 requirements-shippable.txt create mode 100644 requirements.txt create mode 100644 setup.py create mode 100644 shippable.yml create mode 100644 tutorials/Code_from_article.ipynb create mode 100644 tutorials/I.CardIO.ipynb create mode 100644 tutorials/II.Pipelines.ipynb create mode 100644 tutorials/III.Models.ipynb diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..cf0de3e --- /dev/null +++ b/.gitattributes @@ -0,0 +1,6 @@ +# Set the default behavior, in case people don't have core.autocrlf set. +* text=auto + +# Explicitly declare text files you want to always be normalized on checkout. +*.py text +*.sh text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5c83664 --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +*.pyc +.cache/* +__pycache__ +__pycache__/* +*/__pycache__/* +.ipynb_checkpoints diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..00e720c --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "cardio/dataset"] + path = cardio/dataset + url = https://github.com/analysiscenter/dataset.git diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..c503af4 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,38 @@ +- Перед любыми операциями с репозиториями у каждого пользователя должно быть настроено имя и адрес почты: +```bash +git config --global user.name "Firstname Lastnameov" +git config --global user.email f.lastnameov@analysiscenter.ru +``` +Причем email **должен совпадать** с email'ом, который указан в вашем github-аккаунте (в нем может быть несколько email'ов). + +- В корневом каталоге каждого репозитория должен быть размещен файл README.md с кратким описанием проекта, структуры исходного кода, инструкцией по установке и ссылками на документацию. + +- Все содержательные файлы рекомендуется размещать в подкаталогах, а в корневом хранить только описательные (README.md, INSTALL.md и т.п.), +инсталляционные (setup.py, requirements.txt и т.п.), а также конфигурационные и make-файлы. + +- Имена файлов должны содержать только латинские буквы. Пробелы в наименованиях файлов не допускаются. + +- Коммиты в ветку `master` не допускаются. Она должна быть защищена от удаления и изменения истории +(Settings - Branches - Protected branches). + +- Изменения в исходном коде и файлах репозитория рекомендуется производить только в рамках задач (issues). +Для каждого изменения исполнитель открывает отдельную ветку с наименованием вида <iTASK-ID>-<short branch name> (например, `i15-dataset` или `i22-HMM`). + +- В рамках одной задачи можно создавать несколько веток в одном репозитории. + +- Если у вас нет задачи, имеет смысл ее открыть и явным образом завести в issues. + +- Коммиты в рабочие ветки рекомендуется делать регулярно, чтобы каждый коммит содержал не слишком объемные, +но вместе с тем завершенные и независимые от всего остального изменения в репозитории +(лучше закоммитить 3 измененных строки, чем сразу 300). + +- Коммит должен содержать однострочный англоязычный комментарий (длиной 20-60 символов), +отражающий содержание включенных в него изменений исходного кода и файлов. + +- Более подробное описание изменений следует сохранять в файле HISTORY.md, размещенном в корневом каталоге репозитория. + +- Выполнив задачу и завершив все изменения, исполнитель открывает pull request на слияние рабочей и продуктивной ветки (например, master). + +- Перед слиянием рабочая ветка не должна отставать от продуктивной (что можно проверить с помощью `git status`). Для этого следует предварительно синхронизировать рабочую ветку (`git pull`). + +- После слияния рабочая ветка удаляется. diff --git a/LICENSE b/LICENSE index 261eeb9..8dada3e 100644 --- a/LICENSE +++ b/LICENSE @@ -178,7 +178,7 @@ APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" + boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a @@ -186,7 +186,7 @@ same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright [yyyy] [name of copyright owner] + Copyright {yyyy} {name of copyright owner} Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000..cbec3e5 --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,16 @@ +include MANIFEST.in +include LICENSE +include README.md +include setup.py + +recursive-include cardio * +recursive-include docs * +recursive-include tutorials * +recursive-exclude docs/_build * + +global-exclude *.pyc *.pyo *.pyd +global-exclude *.git +global-exclude *.so +global-exclude *~ +global-exclude \#* +global-exclude .DS_Store diff --git a/README.md b/README.md index 3495262..ccdb02b 100644 --- a/README.md +++ b/README.md @@ -1 +1,97 @@ -# cardio \ No newline at end of file +# CardIO + +CardIO is a library that works with electrocardiograms (ECG). With CardIO you can + +* load and save signal in various formats +* resample, crop, filter and flip signal +* allocate PQ, QT, QRS segments +* calculate heart rate and other standard ECG characteristics +* apply complex transformations like fft and wavelets, or any other custom functions. +* recognize heart diseases from ECG +* efficiently work with large datasets that do not even fit into memory +* easily arrange new custom actions into pipelines +* do end-to-end ECG processing +* build, train and test custom models for deep research + +… and do everything under a single API. + +For more details see [the documentation and tutorials](https://analysiscenter.github.io/cardio/). + +## About CardIO + +The library is based on [Dataset](https://github.com/analysiscenter/dataset/). We suggest to read Dataset's [documentation](https://analysiscenter.github.io/dataset/) to learn more. + +CardIO has three modules: [```batch```](https://analysiscenter.github.io/cardio/intro/batch.html) [```models```](https://analysiscenter.github.io/cardio/intro/models.html) and [```pipelines```](https://analysiscenter.github.io/cardio/intro/pipeline.html). + +Module ```batch``` contains low-level actions for ECG processing. +Actions are included in ```EcgBatch``` class that also defines how +to store ECGs. From these actions you can biuld new pipelines. You can also +write custom action and include it in ```EcgBatch```. + +In ```models``` we provide several models that were elaborated to learn the most important problems in ECG: +* how to recognize specific features of ECG like R-peaks, P-wave, T-wave +* how to recognize heart diseases from ECG, for example - atrial fibrillation. + +Module ```pipelines``` contains high-level methods that +* train model to allocate PQ, QT, QRS segments +* calculate heart rate +* train model to find probabilities of heart diseases. + +Under the hood these methods contain many actions that load signals, filter it and do complex caclulations. Using pipelines you do not think about this part of work and simply pass ECG datasets and get results. + +## Basic usage + +Here is an example of pipeline that loads ECG signals, makes some preprocessing and learns model over 50 epochs. +```python +train_ppl = ( + dtst.train + .pipeline + .init_model("dynamic", DirichletModel, name="dirichlet", + config=model_config) + .init_variable("loss_history", init=list) + .load(components=["signal", "meta"], fmt="wfdb") + .load(components="target", fmt="csv", src=LABELS_PATH) + .drop_labels(["~"]) + .replace_labels({"N": "NO", "O": "NO"}) + .flip_signals() + .random_resample_signals("normal", loc=300, scale=10) + .random_split_signals(2048, {"A": 9, "NO": 3}) + .binarize_labels() + .train_model("dirichlet", make_data=make_data, fetches="loss", save_to=V("loss_history"), mode="a") + .run(batch_size=100, shuffle=True, drop_last=True, n_epochs=50) +) +``` + +As a result of this pipeline one obtains a trained model. + +## Installation + +> `CardIO` module is in the beta stage. Your suggestions and improvements are very welcome. + +> `CardIO` supports python 3.5 or higher. + +### Installation as python package + +With [pipenv](https://docs.pipenv.org/): + + pipenv install git+https://github.com/analysiscenter/cardio.git#egg=cardio + +With [pip](https://pip.pypa.io/en/stable/): + + pip3 install git+https://github.com/analysiscenter/cardio.git + +After that just import `cardio`: +```python +import cardio +``` + +### Installation as a project repository: + + git clone --recursive https://github.com/analysiscenter/ecg.git + +Flag `--recursive` is used to clone submodules. + +## Citing CardIO +Please cite CardIO in your publications if it helps your research. + + Khudorozhkov R., Illarionov E., Kuvaev A., Podvyaznikov D. CardIO library for data science research of heart signals. 2017. diff --git a/cardio/__init__.py b/cardio/__init__.py new file mode 100644 index 0000000..cab46e6 --- /dev/null +++ b/cardio/__init__.py @@ -0,0 +1,8 @@ +""" ECG package """ +import sys + +from .batch import * # pylint: disable=wildcard-import +from . import dataset # pylint: disable=wildcard-import + + +__version__ = '0.1.0' diff --git a/cardio/batch/__init__.py b/cardio/batch/__init__.py new file mode 100644 index 0000000..db5b769 --- /dev/null +++ b/cardio/batch/__init__.py @@ -0,0 +1,3 @@ +""" ECG Batch """ +from .ecg_batch import EcgBatch +from .ecg_dataset import EcgDataset diff --git a/cardio/batch/ecg_batch.py b/cardio/batch/ecg_batch.py new file mode 100644 index 0000000..74dc8e8 --- /dev/null +++ b/cardio/batch/ecg_batch.py @@ -0,0 +1,1057 @@ +"""Contains ECG Batch class.""" +# pylint: disable=too-many-lines + +import copy + +import dill +import numpy as np +import pandas as pd +import scipy +import matplotlib.pyplot as plt + +from .. import dataset as ds +from . import kernels +from . import ecg_batch_tools as bt +from .utils import LabelBinarizer + + +class EcgBatch(ds.Batch): # pylint: disable=too-many-public-methods,too-many-instance-attributes + """Batch class for ECG signals storing. + + Contains ECG signals and additional metadata along with various processing + methods. + + Parameters + ---------- + index : DatasetIndex + Unique identifiers of ECGs in a dataset. + preloaded : tuple, optional + Data to put in the batch if given. Defaults to ``None``. + unique_labels : 1-D ndarray, optional + Array with unique labels in a dataset. + + Attributes + ---------- + index : DatasetIndex + Unique identifiers of ECGs in a dataset. + signal : 1-D ndarray + Array of 2-D ndarrays with ECG signals in channels first format. + annotation : 1-D ndarray + Array of dicts with different types of annotations. + meta : 1-D ndarray + Array of dicts with metadata about signals. + target : 1-D ndarray + Array with signals' labels. + unique_labels : 1-D ndarray + Array with unique labels in a dataset. + label_binarizer : LabelBinarizer + Object for label one-hot encoding. + + Note + ---- + Some batch methods take ``index`` as the first argument after self. You + should not specify it in your code, it will be passed automatically by + ``inbatch_parallel`` decorator. For example, ``resample_signal`` method + with ``index`` and ``fs`` arguments should be called as + ``batch.resample_signal(fs)``. + """ + + def __init__(self, index, preloaded=None, unique_labels=None): + super().__init__(index, preloaded) + self.signal = np.array([np.array([]) for _ in range(len(index))] + [None])[:-1] + self.annotation = np.array([{} for _ in range(len(index))]) + self.meta = np.array([{} for _ in range(len(index))]) + self.target = np.array([None for _ in range(len(index))]) + self._unique_labels = None + self._label_binarizer = None + self.unique_labels = unique_labels + + def _reraise_exceptions(self, results): + """Reraise all exceptions in the ``results`` list. + + Parameters + ---------- + results : list + Post function computation results. + + Raises + ------ + RuntimeError + If any paralleled action raised an ``Exception``. + """ + if ds.any_action_failed(results): + all_errors = self.get_errors(results) + raise RuntimeError("Cannot assemble the batch", all_errors) + + @staticmethod + def _check_2d(signal): + """Check if given signal is 2-D. + + Parameters + ---------- + signal : ndarray + Signal to check. + + Raises + ------ + ValueError + If given signal is not two-dimensional. + """ + if signal.ndim != 2: + raise ValueError("Each signal in batch must be 2-D ndarray") + + @property + def components(self): + """tuple of str: Data components names.""" + return "signal", "annotation", "meta", "target" + + @property + def unique_labels(self): + """1-D ndarray: Unique labels in a dataset.""" + return self._unique_labels + + @unique_labels.setter + def unique_labels(self, val): + """Set unique labels value to ``val``. Updates + ``self.label_binarizer`` instance. + + Parameters + ---------- + val : 1-D ndarray + New unique labels. + """ + self._unique_labels = val + if self.unique_labels is None or len(self.unique_labels) == 0: + self._label_binarizer = None + else: + self._label_binarizer = LabelBinarizer().fit(self.unique_labels) + + @property + def label_binarizer(self): + """LabelBinarizer: Label binarizer object for unique labels in a + dataset.""" + return self._label_binarizer + + def update(self, signal=None, annotation=None, meta=None, target=None): + """Update batch components. + + Parameters + ---------- + signal : ndarray, optional + New ``signal`` component. + annotation : ndarray, optional + New ``annotation`` component. + meta : ndarray, optional + New ``meta`` component. + target : ndarray, optional + New ``target`` component. + + Returns + ------- + batch : EcgBatch + Updated batch. Changes batch components inplace. + """ + if signal is not None: + self.signal = np.asarray(signal) + if annotation is not None: + self.annotation = np.asarray(annotation) + if meta is not None: + self.meta = np.asarray(meta) + if target is not None: + self.target = np.asarray(target) + return self + + def deepcopy(self): + """Return a deep copy of the batch. + + Constructs a new ``EcgBatch`` instance and then recursively copies all + the objects found in the original batch, except the ``pipeline``, + which remains unchanged. + + Returns + ------- + batch : EcgBatch + A deep copy of the batch. + """ + pipeline = self.pipeline # pylint: disable=access-member-before-definition + self.pipeline = None # pylint: disable=attribute-defined-outside-init + dump_batch = dill.dumps(self) + self.pipeline = pipeline # pylint: disable=attribute-defined-outside-init + + restored_batch = dill.loads(dump_batch) + restored_batch.pipeline = pipeline + return restored_batch + + @classmethod + def merge(cls, batches, batch_size=None): + """Concatenate a list of ``EcgBatch`` instances and split the result + into two batches of sizes ``batch_size`` and ``sum(lens of batches) - + batch_size`` respectively. + + Parameters + ---------- + batches : list + List of ``EcgBatch`` instances. + batch_size : positive int, optional + Length of the first resulting batch. If ``None``, equals the + length of the concatenated batch. + + Returns + ------- + new_batch : EcgBatch + Batch of no more than ``batch_size`` first items from the + concatenation of input batches. Contains a deep copy of input + batches' data. + rest_batch : EcgBatch + Batch of the remaining items. Contains a deep copy of input + batches' data. + + Raises + ------ + ValueError + If ``batch_size`` is non-positive or non-integer. + """ + batches = [batch for batch in batches if batch is not None] + if len(batches) == 0: + return None, None + total_len = np.sum([len(batch) for batch in batches]) + if batch_size is None: + batch_size = total_len + elif not isinstance(batch_size, int) or batch_size < 1: + raise ValueError("Batch size must be positive int") + indices = np.arange(total_len) + + data = [] + for comp in batches[0].components: + data.append(np.concatenate([batch.get(component=comp) for batch in batches])) + data = copy.deepcopy(data) + + new_indices = indices[:batch_size] + new_batch = cls(ds.DatasetIndex(new_indices), unique_labels=batches[0].unique_labels) + new_batch._data = tuple(comp[:batch_size] for comp in data) # pylint: disable=protected-access, attribute-defined-outside-init, line-too-long + if total_len <= batch_size: + rest_batch = None + else: + rest_indices = indices[batch_size:] + rest_batch = cls(ds.DatasetIndex(rest_indices), unique_labels=batches[0].unique_labels) + rest_batch._data = tuple(comp[batch_size:] for comp in data) # pylint: disable=protected-access, attribute-defined-outside-init, line-too-long + return new_batch, rest_batch + + @ds.action + def load(self, src=None, fmt=None, components=None, ann_ext=None, *args, **kwargs): + """Load given batch components from source. + + Parameters + ---------- + src : misc, optional + Source to load components from. + fmt : str, optional + Source format. + components : str or array-like, optional + Components to load. + ann_ext : str, optional + Extension of the annotation file. + + Returns + ------- + batch : EcgBatch + Batch with loaded components. Changes batch data inplace. + """ + if components is None: + components = self.components + components = np.asarray(components).ravel() + if (fmt == "csv" or fmt is None and isinstance(src, pd.Series)) and np.all(components == "target"): + return self._load_labels(src) + elif fmt == "wfdb": + return self._load_wfdb(src=src, components=components, ann_ext=ann_ext, *args, **kwargs) + else: + return super().load(src, fmt, components, *args, **kwargs) + + @ds.inbatch_parallel(init="indices", post="_assemble_load", target="threads") + def _load_wfdb(self, index, src=None, components=None, ann_ext=None): + """Load given components from wfdb files. + + Parameters + ---------- + src : misc, optional + Source to load components from. If ``None``, path from + ``FilesIndex`` is used. + components : iterable, optional + Components to load. + ann_ext: str, optional + Extension of the annotation file. + + Returns + ------- + batch : EcgBatch + Batch with loaded components. Changes batch data inplace. + + Raises + ------ + ValueError + If source path is not specified and batch's ``index`` is not a + ``FilesIndex``. + """ + if src is not None: + path = src[index] + elif isinstance(self.index, ds.FilesIndex): + path = self.index.get_fullpath(index) # pylint: disable=no-member + else: + raise ValueError("Source path is not specified") + return bt.load_wfdb(path, components, ann_ext) + + def _assemble_load(self, results, *args, **kwargs): + """Concatenate results of different workers and update self. + + Parameters + ---------- + results : list + Workers' results. + + Returns + ------- + batch : EcgBatch + Assembled batch. Changes components inplace. + """ + _ = args, kwargs + self._reraise_exceptions(results) + components = kwargs.get("components", None) + if components is None: + components = self.components + for comp, data in zip(components, zip(*results)): + if comp == "signal": + data = np.array(data + (None,))[:-1] + else: + data = np.array(data) + setattr(self, comp, data) + return self + + def _load_labels(self, src): + """Load labels from csv file or ``pandas.Series``. + + Parameters + ---------- + src : str or Series + Path to csv file or ``pandas.Series``. The file should contain two + columns: ECG index and label. It shouldn't have a header. + + Returns + ------- + batch : EcgBatch + Batch with loaded labels. Changes ``self.target`` inplace. + + Raises + ------ + TypeError + If src is not a string or ``Series``. + RuntimeError + If ``unique_labels`` was undefined and the batch was not created + by a ``Pipeline``. + """ + if not isinstance(src, (str, pd.Series)): + raise TypeError("Unsupported type of source") + if isinstance(src, str): + src = pd.read_csv(src, header=None, names=["index", "label"], index_col=0)["label"] + self.update(target=src[self.indices].values) + if self.unique_labels is None: + if self.pipeline is None: + raise RuntimeError("Batch with undefined unique_labels must be created in a pipeline") + ds_indices = self.pipeline.dataset.indices + self.unique_labels = np.sort(src[ds_indices].unique()) + return self + + def _filter_batch(self, keep_mask): + """Drop elements from batch with corresponding ``False`` values in + ``keep_mask``. + + Parameters + ---------- + keep_mask : bool 1-D ndarray + Filtering mask. + + Returns + ------- + batch : EcgBatch + Filtered batch. Creates a new ``EcgBatch`` instance. + + Raises + ------ + SkipBatchException + If all batch data was dropped. This exception is caught in the + ``Pipeline``. + """ + indices = self.indices[keep_mask] + if len(indices) == 0: + raise ds.SkipBatchException("All batch data was dropped") + res_batch = self.__class__(ds.DatasetIndex(indices), unique_labels=self.unique_labels) + res_batch.update(self.signal[keep_mask], self.annotation[keep_mask], + self.meta[keep_mask], self.target[keep_mask]) + return res_batch + + @ds.action + def drop_labels(self, drop_list): + """Drop elements whose labels are in ``drop_list``. + + Parameters + ---------- + drop_list : list + Labels to be dropped from batch. + + Returns + ------- + batch : EcgBatch + Filtered batch. Creates a new ``EcgBatch`` instance. + """ + drop_arr = np.asarray(drop_list) + self.unique_labels = np.setdiff1d(self.unique_labels, drop_arr) + keep_mask = ~np.in1d(self.target, drop_arr) + return self._filter_batch(keep_mask) + + @ds.action + def keep_labels(self, keep_list): + """Keep elements whose labels are in ``keep_list``. + + Parameters + ---------- + keep_list : list + Labels to be kept in batch. + + Returns + ------- + batch : EcgBatch + Filtered batch. Creates a new ``EcgBatch`` instance. + """ + keep_arr = np.asarray(keep_list) + self.unique_labels = np.intersect1d(self.unique_labels, keep_arr) + keep_mask = np.in1d(self.target, keep_arr) + return self._filter_batch(keep_mask) + + @ds.action + def replace_labels(self, replace_dict): + """Replace labels with corresponding values in ``replace_dict``. + + Parameters + ---------- + replace_dict : dict + Dictionary containing ``(old label : new label)`` pairs. + + Returns + ------- + batch : EcgBatch + Batch with replaced labels. Changes ``self.target`` inplace. + """ + self.unique_labels = np.array(sorted({replace_dict.get(t, t) for t in self.unique_labels})) + return self.update(target=[replace_dict.get(t, t) for t in self.target]) + + @ds.action + def binarize_labels(self): + """Binarize labels in batch in a one-vs-all fashion. + + Returns + ------- + batch : EcgBatch + Batch with binarized labels. Changes ``self.target`` inplace. + """ + return self.update(target=self.label_binarizer.transform(self.target)) + + @ds.action + def drop_short_signals(self, min_length, axis=-1): + """Drop short signals from batch. + + Parameters + ---------- + min_length : positive int + Minimal signal length. + axis : int, optional + Axis along which length is calculated. Default value is -1. + + Returns + ------- + batch : EcgBatch + Filtered batch. Creates a new ``EcgBatch`` instance. + """ + keep_mask = np.array([sig.shape[axis] >= min_length for sig in self.signal]) + return self._filter_batch(keep_mask) + + @staticmethod + def _pad_signal(signal, length, pad_value): + """Pad signal with ``pad_value`` to the left along axis 1 (signal + axis). + + Parameters + ---------- + signal : 2-D ndarray + Signals to pad. + length : positive int + Length of padded signal along axis 1. + pad_value : float + Padding value. + + Returns + ------- + signal : 2-D ndarray + Padded signals. + """ + pad_len = length - signal.shape[1] + sig = np.pad(signal, ((0, 0), (pad_len, 0)), "constant", constant_values=pad_value) + return sig + + @staticmethod + def _get_segmentation_arg(arg, arg_name, target): + """Get segmentation step or number of segments for a given signal. + + Parameters + ---------- + arg : int or dict + Segmentation step or number of segments. + arg_name : str + Argument name. + target : hashable + Signal target. + + Returns + ------- + arg : positive int + Segmentation step or number of segments for given signal. + + Raises + ------ + KeyError + If ``arg`` dict has no ``target`` key. + ValueError + If ``arg`` is not int or dict. + """ + if isinstance(arg, int): + return arg + elif isinstance(arg, dict): + arg = arg.get(target) + if arg is None: + raise KeyError("Undefined {} for target {}".format(arg_name, target)) + else: + return arg + else: + raise ValueError("Unsupported {} type".format(arg_name)) + + @staticmethod + def _check_segmentation_args(signal, target, length, arg, arg_name): + """Check values of segmentation parameters. + + Parameters + ---------- + signal : 2-D ndarray + Signals to segment. + target : hashable + Signal target. + length : positive int + Length of each segment along axis 1. + arg : positive int or dict + Segmentation step or number of segments. + arg_name : str + Argument name. + + Returns + ------- + arg : positive int + Segmentation step or number of segments for given signal. + + Raises + ------ + ValueError + If: + * given signal is not two-dimensional, + * ``arg`` is not int or dict, + * ``length`` or ``arg`` for a given signal is negative or + non-integer. + KeyError + If ``arg`` dict has no ``target`` key. + """ + EcgBatch._check_2d(signal) + if (length <= 0) or not isinstance(length, int): + raise ValueError("Segment length must be positive integer") + arg = EcgBatch._get_segmentation_arg(arg, arg_name, target) + if (arg <= 0) or not isinstance(arg, int): + raise ValueError("{} must be positive integer".format(arg_name)) + return arg + + @ds.action + @ds.inbatch_parallel(init="indices", target="threads") + def split_signals(self, index, length, step, pad_value=0): + """Split 2-D signals along axis 1 (signal axis) with given ``length`` + and ``step``. + + If signal length along axis 1 is less than ``length``, it is padded to + the left with ``pad_value``. + + Parameters + ---------- + length : positive int + Length of each segment along axis 1. + step : positive int or dict + Segmentation step. If ``step`` is dict, segmentation step is + fetched by signal's target key. + pad_value : float, optional + Padding value. Defaults to 0. + + Returns + ------- + batch : EcgBatch + Batch of split signals. Changes ``self.signal`` and ``self.meta`` + inplace. + + Raises + ------ + ValueError + If: + * given signal is not two-dimensional, + * ``step`` is not int or dict, + * ``length`` or ``step`` for a given signal is negative or + non-integer. + KeyError + If ``step`` dict has no signal's target key. + """ + i = self.get_pos(None, "signal", index) + step = self._check_segmentation_args(self.signal[i], self.target[i], length, step, "step size") + if self.signal[i].shape[1] < length: + tmp_sig = self._pad_signal(self.signal[i], length, pad_value) + self.signal[i] = tmp_sig[np.newaxis, ...] + else: + self.signal[i] = bt.split_signals(self.signal[i], length, step) + self.meta[i]["siglen"] = length + + @ds.action + @ds.inbatch_parallel(init="indices", target="threads") + def random_split_signals(self, index, length, n_segments, pad_value=0): + """Split 2-D signals along axis 1 (signal axis) ``n_segments`` times + with random start position and given ``length``. + + If signal length along axis 1 is less than ``length``, it is padded to + the left with ``pad_value``. + + Parameters + ---------- + length : positive int + Length of each segment along axis 1. + n_segments : positive int or dict + Number of segments. If ``n_segments`` is dict, number of segments + is fetched by signal's target key. + pad_value : float, optional + Padding value. Defaults to 0. + + Returns + ------- + batch : EcgBatch + Batch of split signals. Changes ``self.signal`` and ``self.meta`` + inplace. + + Raises + ------ + ValueError + If: + * given signal is not two-dimensional, + * ``n_segments`` is not int or dict, + * ``length`` or ``n_segments`` for a given signal is negative + or non-integer. + KeyError + If ``n_segments`` dict has no signal's target key. + """ + i = self.get_pos(None, "signal", index) + n_segments = self._check_segmentation_args(self.signal[i], self.target[i], length, + n_segments, "number of segments") + if self.signal[i].shape[1] < length: + tmp_sig = self._pad_signal(self.signal[i], length, pad_value) + self.signal[i] = np.tile(tmp_sig, (n_segments, 1, 1)) + else: + self.signal[i] = bt.random_split_signals(self.signal[i], length, n_segments) + self.meta[i]["siglen"] = length + + def _safe_fs_resample(self, index, fs): + """Resample 2-D signal along axis 1 (signal axis) to given sampling + rate. + + New sampling rate is guaranteed to be positive float. + + Parameters + ---------- + fs : positive float + New sampling rate. + + Raises + ------ + ValueError + If given signal is not two-dimensional. + """ + i = self.get_pos(None, "signal", index) + self._check_2d(self.signal[i]) + new_len = max(1, int(fs * self.signal[i].shape[1] / self.meta[i]["fs"])) + self.meta[i]["fs"] = fs + self.meta[i]["siglen"] = new_len + self.signal[i] = bt.resample_signals(self.signal[i], new_len) + + @ds.action + @ds.inbatch_parallel(init="indices", target="threads") + def resample_signals(self, index, fs): + """Resample 2-D signals along axis 1 (signal axis) to given sampling + rate. + + Parameters + ---------- + fs : positive float + New sampling rate. + + Returns + ------- + batch : EcgBatch + Resampled batch. Changes ``self.signal`` and ``self.meta`` + inplace. + + Raises + ------ + ValueError + If given signal is not two-dimensional. + ValueError + If sampling rate is negative or non-numeric. + """ + if fs <= 0: + raise ValueError("Sampling rate must be a positive float") + self._safe_fs_resample(index, fs) + + @ds.action + @ds.inbatch_parallel(init="indices", target="threads") + def random_resample_signals(self, index, distr, **kwargs): + """Resample 2-D signals along axis 1 (signal axis) to a new sampling + rate, sampled from given distribution. + + Parameters + ---------- + distr : str or callable + NumPy distribution name or callable to sample from. + kwargs : misc + Distribution parameters. If new sampling rate is negative, the + signal is left unchanged. + + Returns + ------- + batch : EcgBatch + Resampled batch. Changes ``self.signal`` and ``self.meta`` + inplace. + + Raises + ------ + ValueError + If given signal is not two-dimensional. + ValueError + If ``distr`` is not a string or a callable. + """ + if hasattr(np.random, distr): + distr_fn = getattr(np.random, distr) + fs = distr_fn(**kwargs) + elif callable(distr): + fs = distr_fn(**kwargs) + else: + raise ValueError("Unknown type of distribution parameter") + if fs <= 0: + fs = self[index].meta["fs"] + self._safe_fs_resample(index, fs) + + @ds.action + def convolve_signals(self, kernel, padding_mode="edge", axis=-1, **kwargs): + """Convolve signals with given ``kernel``. + + Parameters + ---------- + kernel : 1-D array_like + Convolution kernel. + padding_mode : str or function, optional + ``np.pad`` padding mode. + axis : int, optional + Axis along which signals are sliced. Default value is -1. + kwargs : misc + Any additional named argments to ``np.pad``. + + Returns + ------- + batch : EcgBatch + Convolved batch. Changes ``self.signal`` inplace. + + Raises + ------ + ValueError + If ``kernel`` is not one-dimensional or has non-numeric ``dtype``. + """ + for i in range(len(self.signal)): + self.signal[i] = bt.convolve_signals(self.signal[i], kernel, padding_mode, axis, **kwargs) + return self + + @ds.action + @ds.inbatch_parallel(init="indices", target="threads") + def band_pass_signals(self, index, low=None, high=None, axis=-1): + """Reject frequencies outside given range. + + Parameters + ---------- + low : positive float, optional + High-pass filter cutoff frequency (in Hz). + high : positive float, optional + Low-pass filter cutoff frequency (in Hz). + axis : int, optional + Axis along which signals are sliced. Default value is -1. + + Returns + ------- + batch : EcgBatch + Filtered batch. Changes ``self.signal`` inplace. + """ + i = self.get_pos(None, "signal", index) + self.signal[i] = bt.band_pass_signals(self.signal[i], self.meta[i]["fs"], low, high, axis) + + @ds.action + @ds.inbatch_parallel(init="indices", target="threads") + def flip_signals(self, index, window_size=None, threshold=0): + """Flip 2-D signals whose R-peaks are directed downwards. + + Each element of ``self.signal`` must be a 2-D ndarray. Signals are + flipped along axis 1 (signal axis). For each subarray of + ``window_size`` length skewness is calculated and compared with + ``threshold`` to decide whether this subarray should be flipped or + not. Then the mode of the result is calculated to make the final + decision. + + Parameters + ---------- + window_size : int, optional + Signal is split into K subarrays of ``window_size`` length. If it + is not possible, data in the end of the signal is removed. If + ``window_size`` is not given, the whole array is checked without + splitting. + threshold : float, optional + If skewness of a subarray is less than the ``threshold``, it + "votes" for flipping the signal. Default value is 0. + + Returns + ------- + batch : EcgBatch + Batch with flipped signals. + + Raises + ------ + ValueError + If given signal is not two-dimensional. + """ + i = self.get_pos(None, "signal", index) + self._check_2d(self.signal[i]) + sig = bt.band_pass_signals(self.signal[i], self.meta[i]["fs"], low=5, high=50) + sig = bt.convolve_signals(sig, kernels.gaussian(11, 3)) + + if window_size is None: + window_size = sig.shape[1] + + number_of_splits = sig.shape[1] // window_size + sig = sig[:, : window_size * number_of_splits] + + splits = np.split(sig, number_of_splits, axis=-1) + votes = [np.where(scipy.stats.skew(subseq, axis=-1) < threshold, -1, 1).reshape(-1, 1) for subseq in splits] + mode_of_votes = scipy.stats.mode(votes)[0].reshape(-1, 1) + self.signal[i] *= mode_of_votes + + @ds.action + @ds.inbatch_parallel(init="indices", target='threads') + def wavelet_transform_signal(self, index, cwt_scales, cwt_wavelet): + """Generate wavelet transformation of signal and write to annotation. + + Parameters + ---------- + cwt_scales : array_like + Scales to use for Continuous Wavelet Transformation. + cwt_wavelet : Wavelet object or name + Wavelet to use in CWT. + + Returns + ------- + batch : EcgBatch + ``EcgBatch`` with wavelet transform of signals. + """ + i = self.get_pos(None, "signal", index) + self._check_2d(self.signal[i]) + + self.annotation[i]["wavelets"] = bt.wavelet_transform(self.signal[i], + cwt_scales, + cwt_wavelet) + + @ds.action + @ds.inbatch_parallel(init="indices", target='threads') + def calc_ecg_parameters(self, index): + """Calculate ECG report parameters and write it to meta component. + + Calculates PQ, QT, QRS intervals and heart rate value based on + annotation and writes it in ``meta``. Also writes to ``meta`` + locations of the starts and ends of those intervals. + + Returns + ------- + batch : EcgBatch + Batch with report parameters stored in ``meta`` component. + """ + i = self.get_pos(None, "signal", index) + + self.meta[i]["hr"] = bt.calc_hr(self.signal[i], + self.annotation[i]['hmm_annotation'], + np.float64(self.meta[i]['fs']), + bt.R_STATE) + + self.meta[i]["pq"] = bt.calc_pq(self.annotation[i]['hmm_annotation'], + np.float64(self.meta[i]['fs']), + bt.P_STATES, + bt.Q_STATE, + bt.R_STATE) + + self.meta[i]["qt"] = bt.calc_qt(self.annotation[i]['hmm_annotation'], + np.float64(self.meta[i]['fs']), + bt.T_STATES, + bt.Q_STATE, + bt.R_STATE) + + self.meta[i]["qrs"] = bt.calc_qrs(self.annotation[i]['hmm_annotation'], + np.float64(self.meta[i]['fs']), + bt.S_STATE, + bt.Q_STATE, + bt.R_STATE) + + self.meta[i]["qrs_segments"] = np.vstack(bt.find_intervals_borders(self.annotation[i]['hmm_annotation'], + bt.QRS_STATES)) + + self.meta[i]["p_segments"] = np.vstack(bt.find_intervals_borders(self.annotation[i]['hmm_annotation'], + bt.P_STATES)) + + self.meta[i]["t_segments"] = np.vstack(bt.find_intervals_borders(self.annotation[i]['hmm_annotation'], + bt.T_STATES)) + + def show_ecg(self, index=None, start=0, end=None, annotate=False, subplot_size=(10, 4)): + """Plot an ECG signal. + + Optionally highlight QRS complexes along with P and T waves. Each + channel is displayed on a separate subplot. + + Parameters + ---------- + index : element of ``self.indices``, optional + Index of a signal to plot. If undefined, the first ECG in the + batch is used. + start : int, optional + The start point of the displayed part of the signal (in seconds). + end : int, optional + The end point of the displayed part of the signal (in seconds). + annotate : bool, optional + Specifies whether to highlight ECG segments on the plot. + subplot_size : tuple + Width and height of each subplot in inches. + + Raises + ------ + ValueError + If the chosen signal is not two-dimensional. + """ + i = 0 if index is None else self.get_pos(None, "signal", index) + signal, annotation, meta = self.signal[i], self.annotation[i], self.meta[i] + self._check_2d(signal) + + fs = meta["fs"] + num_channels = signal.shape[0] + start = np.int(start * fs) + end = signal.shape[1] if end is None else np.int(end * fs) + + figsize = (subplot_size[0], subplot_size[1] * num_channels) + _, axes = plt.subplots(num_channels, 1, squeeze=False, figsize=figsize) + for channel, (ax,) in enumerate(axes): + ax.plot((np.arange(start, end) / fs), signal[channel, start:end]) + ax.set_xlabel("Time (sec)") + ax.set_ylabel("Amplitude ({})".format(meta["units"][channel] if "units" in meta else "mV")) + ax.grid("on", which="major") + + if annotate: + def fill_segments(segment_states, color): + """Fill ECG segments with a given color.""" + starts, ends = bt.find_intervals_borders(signal_states, segment_states) + for start_t, end_t in zip((starts + start) / fs, (ends + start) / fs): + for (ax,) in axes: + ax.axvspan(start_t, end_t, color=color, alpha=0.3) + + signal_states = annotation["hmm_annotation"][start:end] + fill_segments(bt.QRS_STATES, "red") + fill_segments(bt.P_STATES, "green") + fill_segments(bt.T_STATES, "blue") + plt.tight_layout() + plt.show() + + @ds.action + def write_to_annotation(self, key, value): + """ + Writes values from value to annotation under defined key. + + It is supposed that length of batch and value are the same. + + Parameters + ---------- + key: misc + Key of the annotation dict to save value under. + value: iterable + Source of the values to write to annotation dict. + + Returns + ------- + batch : EcgBatch + Batch with modified annotation component. + + Raises + ------ + ValueError + If length of the batch does not correspond to length of the value. + """ + value = getattr(self, value) + + if len(self) != len(value): + raise ValueError("Length of the value %i is not equal to batch length %i" % (len(value), len(self))) + + for i in range(len(self)): + self.annotation[i][key] = value[i] + return self + + @ds.action + def ravel(self): + """Join a sequence of arrays along axis 0. + + Returns + ------- + batch : same class as self + Batch with signals joined along signal axis 0. + + Notes + ----- + This method creates new ``EcgBatch`` instance with empty ``meta`` and + ``annotation`` components. + """ + x = np.concatenate(self.signal) + x = list(x) + x.append([]) + x = np.array(x)[:-1] + y = np.concatenate([np.tile(item.target, (item.signal.shape[0], 1)) for item in self]) + new_index = ds.DatasetIndex(np.arange(len(x), dtype=int)) + out_batch = self.__class__(new_index) + return out_batch.update(signal=x, target=y) + + @ds.action + @ds.inbatch_parallel(init="indices", target="threads") + def slice_signal(self, index, slice_index): + """Slice signal + + Parameters + ---------- + slice_index : slice obj + Starting index, stopping index and the step + + Returns + ------- + batch : EcgBatch + Batch with each sliced signal. Changes ``self.signal`` inplace. + """ + i = self.get_pos(None, "signal", index) + self.signal[i] = self.signal[i][slice_index] diff --git a/cardio/batch/ecg_batch_tools.py b/cardio/batch/ecg_batch_tools.py new file mode 100644 index 0000000..4e1147f --- /dev/null +++ b/cardio/batch/ecg_batch_tools.py @@ -0,0 +1,525 @@ +"""Сontains ECG processing tools.""" + +import os +import numpy as np + +import pywt +from numba import njit + +import wfdb + +# Constants + +# This is the mapping from inner HMM states to human-understandable +# cardiological terms. +P_STATES = np.array([14, 15, 16], np.int64) +T_STATES = np.array([5, 6, 7, 8, 9, 10], np.int64) +QRS_STATES = np.array([0, 1, 2], np.int64) +Q_STATE = np.array([0], np.int64) +R_STATE = np.array([1], np.int64) +S_STATE = np.array([2], np.int64) + + +def load_wfdb(path, components, ann_ext=None): + """Load given components from wfdb file. + + Parameters + ---------- + path : str + Path to .hea file. + components : iterable + Components to load. + ann_ext: str + Extension of the annotation file. + + Returns + ------- + ecg_data : list + List of ecg data components. + """ + path = os.path.splitext(path)[0] + record = wfdb.rdsamp(path) + signal = record.__dict__.pop("p_signals").T + meta = record.__dict__ + if "annotation" in components and ann_ext is not None: + annotation = wfdb.rdann(path, ann_ext) + annot = {"annsamp": annotation.annsamp, + "anntype": annotation.anntype} + else: + annot = {} + + data = {"signal": signal, + "annotation": annot, + "meta": meta} + return [data[comp] for comp in components] + + +@njit(nogil=True) +def split_signals(signals, length, step): + """Split signals along axis 1 with given ``length`` and ``step``. + + Parameters + ---------- + signals : 2-D ndarray + Signals to split. + length : positive int + Length of each segment along axis 1. + step : positive int + Segmentation step. + + Returns + ------- + signals : 3-D ndarray + Split signals stacked along new axis with index 0. + """ + res = np.empty(((signals.shape[1] - length) // step + 1, signals.shape[0], length), dtype=signals.dtype) + for i in range(res.shape[0]): + res[i, :, :] = signals[:, i * step : i * step + length] + return res + + +@njit(nogil=True) +def random_split_signals(signals, length, n_segments): + """Split signals along axis 1 ``n_segments`` times with random start + position and given ``length``. + + Parameters + ---------- + signals : 2-D ndarray + Signals to split. + length : positive int + Length of each segment along axis 1. + n_segments : positive int + Number of segments. + + Returns + ------- + signals : 3-D ndarray + Split signals stacked along new axis with index 0. + """ + res = np.empty((n_segments, signals.shape[0], length), dtype=signals.dtype) + for i in range(res.shape[0]): + ix = np.random.randint(0, signals.shape[1] - length + 1) + res[i, :, :] = signals[:, ix : ix + length] + return res + + +@njit(nogil=True) +def resample_signals(signals, new_length): + """Resample signals to new length along axis 1 using linear interpolation. + + Parameters + ---------- + signals : 2-D ndarray + Signals to resample. + new_length : positive int + New signals shape along axis 1. + + Returns + ------- + signals : 2-D ndarray + Resampled signals. + """ + arg = np.linspace(0, signals.shape[1] - 1, new_length) + x_left = arg.astype(np.int32) # pylint: disable=no-member + x_right = x_left + 1 + x_right[-1] = x_left[-1] + alpha = arg - x_left + y_left = signals[:, x_left] + y_right = signals[:, x_right] + return y_left + (y_right - y_left) * alpha + + +def convolve_signals(signals, kernel, padding_mode="edge", axis=-1, **kwargs): + """Convolve signals with given ``kernel``. + + Parameters + ---------- + signals : ndarray + Signals to convolve. + kernel : array_like + Convolution kernel. + padding_mode : str or function + ``np.pad`` padding mode. + axis : int + Axis along which signals are sliced. + kwargs : misc + Any additional named argments to ``np.pad``. + + Returns + ------- + signals : ndarray + Convolved signals. + + Raises + ------ + ValueError + If ``kernel`` is not one-dimensional or has non-numeric ``dtype``. + """ + kernel = np.asarray(kernel) + if len(kernel.shape) == 0: + kernel = kernel.ravel() + if len(kernel.shape) != 1: + raise ValueError("Kernel must be 1-D array") + if not np.issubdtype(kernel.dtype, np.number): + raise ValueError("Kernel must have numeric dtype") + pad = len(kernel) // 2 + + def conv_func(x): + """Convolve padded signal.""" + x_pad = np.pad(x, pad, padding_mode, **kwargs) + conv = np.convolve(x_pad, kernel, "same") + if pad > 0: + conv = conv[pad:-pad] + return conv + + signals = np.apply_along_axis(conv_func, arr=signals, axis=axis) + return signals + + +def band_pass_signals(signals, freq, low=None, high=None, axis=-1): + """Reject frequencies outside given range. + + Parameters + ---------- + signals : ndarray + Signals to filter. + freq : positive float + Sampling rate. + low : positive float + High-pass filter cutoff frequency (Hz). + high : positive float + Low-pass filter cutoff frequency (Hz). + axis : int + Axis along which signals are sliced. + + Returns + ------- + signals : ndarray + Filtered signals. + + Raises + ------ + ValueError + If ``freq`` is negative or non-numeric. + """ + if freq <= 0: + raise ValueError("Sampling rate must be a positive float") + sig_rfft = np.fft.rfft(signals, axis=axis) + sig_freq = np.fft.rfftfreq(signals.shape[axis], 1 / freq) + mask = np.zeros(len(sig_freq), dtype=bool) + if low is not None: + mask |= (sig_freq <= low) + if high is not None: + mask |= (sig_freq >= high) + slc = [slice(None)] * signals.ndim + slc[axis] = mask + sig_rfft[slc] = 0 + return np.fft.irfft(sig_rfft, n=signals.shape[axis], axis=axis) + + +def wavelet_transform(signal, cwt_scales, cwt_wavelet): + """Generate wavelet transformation from the signal. + + Parameters + ---------- + signal : numpy.array + Ecg signal. + cwt_scales : array_like + Scales to use for Continuous Wavele Transformation. + cwt_wavelet : Wavelet object or name + Wavelet to use in CWT. + + Returns + ------- + features : numpy.array + Features generated by wavelet from the signal. + """ + # NOTE: Currently works on first lead signal only + sig = signal[0, :] + + cwtmatr = pywt.cwt(sig, np.array(cwt_scales), cwt_wavelet)[0] + wavelets = ((cwtmatr - np.mean(cwtmatr, axis=1).reshape(-1, 1)) / + np.std(cwtmatr, axis=1).reshape(-1, 1)).T + + return wavelets + + +@njit(nogil=True) +def find_intervals_borders(hmm_annotation, inter_val): + """Find starts and ends of the intervals. + + This function finds starts and ends of continuous intervals of values + from inter_val in hmm_annotation. + + Parameters + ---------- + hmm_annotation : numpy.array + Annotation for the signal from hmm_annotation model. + inter_val : array_like + Values that form interval of interest. + + Returns + ------- + starts : 1-D ndarray + Indices of the starts of the intervals. + ends : 1-D ndarray + Indices of the ends of the intervals. + """ + intervals = np.zeros(hmm_annotation.shape, dtype=np.int8) + for val in inter_val: + intervals = np.logical_or(intervals, (hmm_annotation == val).astype(np.int8)).astype(np.int8) + masque = np.diff(intervals) + starts = np.where(masque == 1)[0] + 1 + ends = np.where(masque == -1)[0] + 1 + if np.any(inter_val == hmm_annotation[:1]): + ends = ends[1:] + if np.any(inter_val == hmm_annotation[-1:]): + starts = starts[:-1] + return starts, ends + + +@njit(nogil=True) +def find_maxes(signal, starts, ends): + """ Find index of the maximum of the segment. + + Parameters + ---------- + signal : 2-D ndarray + ECG signal. + starts : 1-D ndarray + Indices of the starts of the intervals. + ends : 1-D ndarray + Indices of the ens of the intervals. + + Returns + ------- + maxes : 1-D ndarray + Indices of max values of each interval. + + Notes + ----- + Currently works with first lead only. + """ + + maxes = np.empty(starts.shape, dtype=np.float64) + for i in range(maxes.shape[0]): + maxes[i] = starts[i] + np.argmax(signal[0][starts[i]:ends[i]]) + + return maxes + + +@njit(nogil=True) +def calc_hr(signal, hmm_annotation, fs, r_state=R_STATE): + """ Calculate heart rate based on HMM prediction. + + Parameters + ---------- + signal : 2-D ndarray + ECG signal. + hmm_annotation : 1-D ndarray + Annotation for the signal from hmm_annotation model. + fs : float + Sampling rate of the signal. + r_state : 1-D ndarray + Array with values that represent R peak. + Default value is R_STATE, which is a constant of this module. + + Returns + ------- + hr_val : float + Heart rate in beats per minute. + """ + + starts, ends = find_intervals_borders(hmm_annotation, r_state) + # NOTE: Currently works on first lead signal only + maxes = find_maxes(signal, starts, ends) + diff = maxes[1:] - maxes[:-1] + hr_val = (np.median(diff / fs) ** -1) * 60 + + return hr_val + + +@njit(nogil=True) +def calc_pq(hmm_annotation, fs, p_states=P_STATES, q_state=Q_STATE, r_state=R_STATE): + """ Calculate PQ based on HMM prediction. + + Parameters + ---------- + hmm_annotation : numpy.array + Annotation for the signal from hmm_annotation model. + fs : float + Sampling rate of the signal. + p_states : 1-D ndarray + Array with values that represent P peak. + Default value is P_STATES, which is a constant of this module. + q_state : 1-D ndarray + Array with values that represent Q peak. + Default value is Q_STATE, which is a constant of this module. + r_state : 1-D ndarray + Array with values that represent R peak. + Default value is R_STATE, which is a constant of this module. + + Returns + ------- + pq_val : float + Duration of PQ interval in seconds. + """ + + p_starts, _ = find_intervals_borders(hmm_annotation, p_states) + q_starts, _ = find_intervals_borders(hmm_annotation, q_state) + r_starts, _ = find_intervals_borders(hmm_annotation, r_state) + + p_final = - np.ones(r_starts.shape[0] - 1) + q_final = - np.ones(r_starts.shape[0] - 1) + + maxlen = hmm_annotation.shape[0] + + if not p_starts.shape[0] * q_starts.shape[0] * r_starts.shape[0]: + return 0.00 + + temp_p = np.zeros(maxlen) + temp_p[p_starts] = 1 + temp_q = np.zeros(maxlen) + temp_q[q_starts] = 1 + + for i in range(len(r_starts) - 1): + low = r_starts[i] + high = r_starts[i + 1] + + inds_p = np.where(temp_p[low:high])[0] + low + inds_q = np.where(temp_q[low:high])[0] + low + + if inds_p.shape[0] == 1 and inds_q.shape[0] == 1: + p_final[i] = inds_p[0] + q_final[i] = inds_q[0] + + p_final = p_final[p_final > -1] + q_final = q_final[q_final > -1] + + intervals = q_final - p_final + + return np.median(intervals) / fs + + +@njit(nogil=True) +def calc_qt(hmm_annotation, fs, t_states=T_STATES, q_state=Q_STATE, r_state=R_STATE): + """ Calculate QT interval based on HMM prediction. + + Parameters + ---------- + hmm_annotation : numpy.array + Annotation for the signal from hmm_annotation model. + fs : float + Sampling rate of the signal. + t_states : 1-D ndarray + Array with values that represent T peak. + Default value is T_STATES, which is a constant of this module. + q_state : 1-D ndarray + Array with values that represent Q peak. + Default value is Q_STATE, which is a constant of this module. + r_state : 1-D ndarray + Array with values that represent R peak. + Default value is R_STATE, which is a constant of this module. + + Returns + ------- + qt_val : float + Duration of QT interval in seconds. + """ + + _, t_ends = find_intervals_borders(hmm_annotation, t_states) + q_starts, _ = find_intervals_borders(hmm_annotation, q_state) + r_starts, _ = find_intervals_borders(hmm_annotation, r_state) + + t_final = - np.ones(r_starts.shape[0] - 1) + q_final = - np.ones(r_starts.shape[0] - 1) + + maxlen = hmm_annotation.shape[0] + + if not t_ends.shape[0] * q_starts.shape[0] * r_starts.shape[0]: + return 0.00 + + temp_t = np.zeros(maxlen) + temp_t[t_ends] = 1 + temp_q = np.zeros(maxlen) + temp_q[q_starts] = 1 + + for i in range(len(r_starts) - 1): + low = r_starts[i] + high = r_starts[i + 1] + + inds_t = np.where(temp_t[low:high])[0] + low + inds_q = np.where(temp_q[low:high])[0] + low + + if inds_t.shape[0] == 1 and inds_q.shape[0] == 1: + t_final[i] = inds_t[0] + q_final[i] = inds_q[0] + + t_final = t_final[t_final > -1][1:] + q_final = q_final[q_final > -1][:-1] + + intervals = t_final - q_final + + return np.median(intervals) / fs + + +@njit(nogil=True) +def calc_qrs(hmm_annotation, fs, s_state=S_STATE, q_state=Q_STATE, r_state=R_STATE): + """ Calculate QRS interval based on HMM prediction. + + Parameters + ---------- + hmm_annotation : numpy.array + Annotation for the signal from hmm_annotation model. + fs : float + Sampling rate of the signal. + s_state : 1-D ndarray + Array with values that represent S peak. + Default value is S_STATE, which is a constant of this module. + q_state : 1-D ndarray + Array with values that represent Q peak. + Default value is Q_STATE, which is a constant of this module. + r_state : 1-D ndarray + Array with values that represent R peak. + Default value is R_STATE, which is a constant of this module. + + Returns + ------- + qrs_val : float + Duration of QRS complex in seconds. + """ + _, s_ends = find_intervals_borders(hmm_annotation, s_state) + q_starts, _ = find_intervals_borders(hmm_annotation, q_state) + r_starts, _ = find_intervals_borders(hmm_annotation, r_state) + + s_final = - np.ones(r_starts.shape[0] - 1) + q_final = - np.ones(r_starts.shape[0] - 1) + + maxlen = hmm_annotation.shape[0] + + if not s_ends.shape[0] * q_starts.shape[0] * r_starts.shape[0]: + return 0.00 + + temp_s = np.zeros(maxlen) + temp_s[s_ends] = 1 + temp_q = np.zeros(maxlen) + temp_q[q_starts] = 1 + + for i in range(len(r_starts) - 1): + low = r_starts[i] + high = r_starts[i + 1] + + inds_s = np.where(temp_s[low:high])[0] + low + inds_q = np.where(temp_q[low:high])[0] + low + + if inds_s.shape[0] == 1 and inds_q.shape[0] == 1: + s_final[i] = inds_s[0] + q_final[i] = inds_q[0] + + s_final = s_final[s_final > -1][1:] + q_final = q_final[q_final > -1][:-1] + + intervals = s_final - q_final + + return np.median(intervals) / fs diff --git a/cardio/batch/ecg_dataset.py b/cardio/batch/ecg_dataset.py new file mode 100644 index 0000000..b4310b8 --- /dev/null +++ b/cardio/batch/ecg_dataset.py @@ -0,0 +1,35 @@ +"""Contains ECG Dataset class.""" + +from .. import dataset as ds +from .ecg_batch import EcgBatch + + +class EcgDataset(ds.Dataset): + """ECG Dataset class. + + Contains indices of ECGs to perform actions from specified batch class on. + + Parameters + ---------- + index : DatasetIndex or None, optional + Unique identifiers of ECGs in a dataset. If ``index`` is not given, it + is constructed by instantiating ``index_class`` with ``args`` and + ``kwargs``. + batch_class : type, optional + Class of batches, constructed by a dataset. Must be inherited from + ``Batch``. + preloaded : tuple, optional + Data to put in created batches. Defaults to ``None``. + index_class : type, optional + Class of built index if ``index`` is not given. Must be inherited from + ``DatasetIndex``. + args : misc, optional + Additional positional argments to ``index_class.__init__``. + kwargs : misc, optional + Additional named argments to ``index_class.__init__``. + """ + + def __init__(self, index=None, batch_class=EcgBatch, preloaded=None, index_class=ds.FilesIndex, *args, **kwargs): + if index is None: + index = index_class(*args, **kwargs) + super().__init__(index, batch_class, preloaded) diff --git a/cardio/batch/kernels.py b/cardio/batch/kernels.py new file mode 100644 index 0000000..312408f --- /dev/null +++ b/cardio/batch/kernels.py @@ -0,0 +1,40 @@ +"""Contains kernel generation functions.""" + +import numpy as np + + +def _check_kernel_size(size): + """Check if kernel size is a positive integer.""" + if not isinstance(size, int) or size < 1: + raise ValueError("Kernel size must be a positive integer") + + +def gaussian(size, sigma=None): + """Create a 1-D Gaussian kernel. + + Parameters + ---------- + size : positive int + Kernel size. + sigma : positive float, optional + Standard deviation of Gaussian distribution. Controls the degree of + smoothing. If ``None``, it is set to ``(size + 1) / 6``. + + Returns + ------- + kernel : 1-D ndarray + Gaussian kernel. + + Raises + ------ + ValueError + If ``size`` or ``sigma`` is negative or non-numeric. + """ + _check_kernel_size(size) + if sigma is None: + sigma = (size + 1) / 6 + elif not isinstance(sigma, (int, float)) or sigma <= 0: + raise ValueError("Sigma must be a positive integer or float") + i = np.arange(size) - (size - 1) / 2 + kernel = np.exp(-i**2 / (2 * sigma**2)) + return kernel / sum(kernel) diff --git a/cardio/batch/utils.py b/cardio/batch/utils.py new file mode 100644 index 0000000..d65319b --- /dev/null +++ b/cardio/batch/utils.py @@ -0,0 +1,58 @@ +"""Miscellaneous ECG Batch utils.""" + +import numpy as np +from sklearn.preprocessing import LabelBinarizer as LB + + +class LabelBinarizer(LB): + """Encode categorical features using a one-hot scheme. + + Unlike ``sklearn.preprocessing.LabelBinarizer``, each label will be + encoded using ``n_classes`` numbers even for binary problems. + """ + # pylint: disable=invalid-name + + def transform(self, y): + """Transform ``y`` using one-hot encoding. + + Parameters + ---------- + y : 1-D ndarray of shape ``[n_samples,]`` + Class labels. + + Returns + ------- + Y : 2-D ndarray of shape ``[n_samples, n_classes]`` + One-hot encoded labels. + """ + Y = super().transform(y) + if len(self.classes_) == 1: + Y = 1 - Y # pylint: disable=redefined-variable-type + if len(self.classes_) == 2: + Y = np.hstack((1 - Y, Y)) + return Y + + def inverse_transform(self, Y, threshold=None): + """Transform one-hot encoded labels back to class labels. + + Parameters + ---------- + Y : 2-D ndarray of shape ``[n_samples, n_classes]`` + One-hot encoded labels. + threshold : float, optional + The threshold used in the binary and multi-label cases. If + ``None``, it is assumed to be half way between ``neg_label`` and + ``pos_label``. + + Returns + ------- + y : 1-D ndarray of shape ``[n_samples,]`` + Class labels. + """ + if len(self.classes_) == 1: + y = super().inverse_transform(1 - Y, threshold) + elif len(self.classes_) == 2: + y = super().inverse_transform(Y[:, 1], threshold) + else: + y = super().inverse_transform(Y, threshold) + return y diff --git a/cardio/dataset b/cardio/dataset new file mode 160000 index 0000000..6f94bb9 --- /dev/null +++ b/cardio/dataset @@ -0,0 +1 @@ +Subproject commit 6f94bb9e86bbe980e1ab20cd7a6739c5cebaadfe diff --git a/cardio/models/__init__.py b/cardio/models/__init__.py new file mode 100644 index 0000000..1a93a25 --- /dev/null +++ b/cardio/models/__init__.py @@ -0,0 +1,6 @@ +"""Contains ECG models and custom functions.""" + +from .dirichlet_model import * # pylint: disable=wildcard-import +from .fft_model import * # pylint: disable=wildcard-import +from . import metrics +from .hmm import * # pylint: disable=wildcard-import diff --git a/cardio/models/dirichlet_model/__init__.py b/cardio/models/dirichlet_model/__init__.py new file mode 100644 index 0000000..477579a --- /dev/null +++ b/cardio/models/dirichlet_model/__init__.py @@ -0,0 +1,3 @@ +"""Contains dirichlet model class.""" + +from .dirichlet_model import DirichletModel, concatenate_ecg_batch diff --git a/cardio/models/dirichlet_model/dirichlet_model.py b/cardio/models/dirichlet_model/dirichlet_model.py new file mode 100644 index 0000000..09539cd --- /dev/null +++ b/cardio/models/dirichlet_model/dirichlet_model.py @@ -0,0 +1,237 @@ +"""Contains Dirichlet model class.""" + +from itertools import zip_longest + +import numpy as np +import tensorflow as tf + +from ..layers import conv1d_block, resnet1d_block +from ...dataset.dataset.models.tf import TFModel + + +def concatenate_ecg_batch(batch, model, return_targets=True): + """Concatenate batch signals and (optionally) targets. + + Parameters + ---------- + batch : EcgBatch + Batch to concatenate. + model : BaseModel + A model to get the resulting arguments. + return_targets : bool + Specifies whether to return concatenated targets. + + Returns + ------- + kwargs : dict + Named argments for model's train or predict method. Has the following + structure: + "feed_dict" : dict + "signals" : 3-D ndarray + Concatenated signals. + "targets" : 2-D ndarray, optional + Concatenated targets. + "split_indices" : 1-D ndarray + Split indices to undo the concatenation. + """ + _ = model + x = np.concatenate(batch.signal) + split_indices = np.cumsum([item.signal.shape[0] for item in batch])[:-1] + res_dict = {"feed_dict": {"signals": x}, "split_indices": split_indices} + if return_targets: + y = np.concatenate([np.tile(item.target, (item.signal.shape[0], 1)) for item in batch]) + res_dict["feed_dict"]["targets"] = y + return res_dict + + +class DirichletModelBase(TFModel): + """Dirichlet model class. + + The model predicts Dirichlet distribution parameters from which class + probabilities are sampled. + + Configuration + ------------- + Model config must contain the following keys: + "input_shape" : tuple + Input signals's shape without the batch dimension. + "class_names" : array_like + Class names. + "loss" : None + The model has a predefined loss, so you should leave it ``None``. + """ + + def _build(self, config=None): # pylint: disable=too-many-locals + """Build Dirichlet model.""" + input_shape = self.config["input_shape"] + class_names = self.config["class_names"] + + with self: # pylint: disable=not-context-manager + self.store_to_attr("class_names", tf.constant(class_names)) + + signals = tf.placeholder(tf.float32, shape=(None,) + input_shape, name="signals") + self.store_to_attr("signals", signals) + signals_channels_last = tf.transpose(signals, perm=[0, 2, 1], name="signals_channels_last") + + k = 0.001 + targets = tf.placeholder(tf.float32, shape=(None, len(class_names)), name="targets") + self.store_to_attr("targets", targets) + targets_soft = (1 - 2 * k) * targets + k + + block = conv1d_block("conv", signals_channels_last, is_training=self.is_training, + filters=8, kernel_size=5) + + block_config = [ + (8, 3, True), + (8, 3, False), + (8, 3, True), + (8, 3, False), + (12, 3, True), + (12, 3, False), + (12, 3, True), + (12, 3, False), + (16, 3, True), + (16, 3, False), + (16, 3, False), + (16, 3, True), + (16, 3, False), + (16, 3, False), + (20, 3, True), + (20, 3, False), + ] + for i, (filters, kernel_size, downsample) in enumerate(block_config): + block = resnet1d_block("block_" + str(i + 1), block, is_training=self.is_training, + filters=filters, kernel_size=kernel_size, downsample=downsample) + + with tf.variable_scope("global_max_pooling"): # pylint: disable=not-context-manager + block = tf.reduce_max(block, axis=1) + + with tf.variable_scope("dense"): # pylint: disable=not-context-manager + dense = tf.layers.dense(block, len(class_names), use_bias=False, name="dense") + bnorm = tf.layers.batch_normalization(dense, training=self.is_training, name="batch_norm", fused=True) + act = tf.nn.softplus(bnorm, name="activation") + + parameters = tf.identity(act, name="parameters") + self.store_to_attr("parameters", parameters) + predictions = tf.identity(act, name="predictions") + self.store_to_attr("predictions", predictions) + loss = tf.reduce_mean(tf.lbeta(parameters) - + tf.reduce_sum((parameters - 1) * tf.log(targets_soft), axis=1), name="loss") + tf.losses.add_loss(loss) + + +class DirichletModel(DirichletModelBase): + """Dirichlet model with overloaded train and predict methods. + + ``train`` method is identical to ``DirichletModelBase.train``, but also + accepts ``args`` and ``kwargs``. + ``predict`` method splits the resulting tensor for ``parameters`` fetch + using ``split_indices``. It also splits and aggregates results for + ``predictions`` fetch to get class probabilities. + """ + + @staticmethod + def _get_dirichlet_mixture_stats(alpha): + """Get mean and variance vectors of the mixture of Dirichlet + distributions with equal weights and given parameters. + + Parameters + ---------- + alpha : 2-D ndarray + Dirichlet distribution parameters along axis 1 for each mixture + component. + + Returns + ------- + mean : 1-D ndarray + Mean of the mixture. + var : 1-D ndarray + Variance of the mixture. + """ + alpha_sum = np.sum(alpha, axis=1)[:, np.newaxis] + comp_m1 = alpha / alpha_sum + comp_m2 = (alpha * (alpha + 1)) / (alpha_sum * (alpha_sum + 1)) + mean = np.mean(comp_m1, axis=0) + var = np.mean(comp_m2, axis=0) - mean**2 + return mean, var + + def train(self, fetches=None, feed_dict=None, use_lock=False, *args, **kwargs): + """Train the model with the data provided. + + The only difference between ``DirichletModel.train`` and + ``TFModel.train`` is that the former also accepts ``args`` and + ``kwargs``. + + Parameters + ---------- + fetches : tf.Operation or tf.Tensor or array-like sequence of them + Graph element to evaluate in addition to ``train_step``. + feed_dict : dict + A dictionary that maps graph elements to values. + use_lock : bool + If ``True``, the whole train step is locked, thus allowing for + multithreading. + + Returns + ------- + output : same structure as ``fetches`` + Calculated values for each element in ``fetches``. + """ + _ = args, kwargs + return super().train(fetches, feed_dict, use_lock) + + def predict(self, fetches=None, feed_dict=None, split_indices=None): # pylint: disable=arguments-differ + """Get predictions on the data provided. + + Parameters + ---------- + fetches : tf.Operation or tf.Tensor or array-like sequence of them + Graph element to evaluate. + If ``fetches`` contains ``parameters`` tensor, the corresponding + output is split using ``split_indices``. + If ``fetches`` contains ``predictions`` tensor, the corresponding + output is split using ``split_indices`` and then aggregated to get + class probabilities. + feed_dict : dict + A dictionary that maps graph elements to values. + split_indices : 1-D ndarray + Indices used to split ``parameters`` and ``predictions`` tensors. + + Returns + ------- + output : same structure as ``fetches`` + Calculated values for each element in ``fetches``. + """ + if isinstance(fetches, (list, tuple)): + fetches_list = list(fetches) + else: + fetches_list = [fetches] + output = super().predict(fetches_list, feed_dict) + for i, fetch in enumerate(fetches_list): + if fetch == "parameters": + output[i] = np.split(output[i], split_indices) + elif fetch == "predictions": + class_names = self.class_names.eval(session=self.session) # pylint: disable=no-member + class_names = [c.decode("utf-8") for c in class_names] + n_classes = len(class_names) + max_var = (n_classes - 1) / n_classes**2 + alpha = np.split(output[i], split_indices) + targets = feed_dict.get("targets") + targets = [] if targets is None else [t[0] for t in np.split(targets, split_indices)] + res = [] + for a, t in zip_longest(alpha, targets): + mean, var = self._get_dirichlet_mixture_stats(a) + uncertainty = var[np.argmax(mean)] / max_var + predictions_dict = {"target_pred": dict(zip(class_names, mean)), + "uncertainty": uncertainty} + if t is not None: + predictions_dict["target_true"] = dict(zip(class_names, t)) + res.append(predictions_dict) + output[i] = res + if isinstance(fetches, list): + pass + elif isinstance(fetches, tuple): + output = tuple(output) + else: + output = output[0] + return output diff --git a/cardio/models/dirichlet_model/dirichlet_model_training.ipynb b/cardio/models/dirichlet_model/dirichlet_model_training.ipynb new file mode 100644 index 0000000..f644590 --- /dev/null +++ b/cardio/models/dirichlet_model/dirichlet_model_training.ipynb @@ -0,0 +1,1018 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dirichlet model training" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook we will train Dirichlet model for atrial fibrillation detection." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Table of contents" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* [Dataset initialization](#Dataset-initialization)\n", + "* [Training pipeline](#Training-pipeline)\n", + "* [Saving the model](#Saving-the-model)\n", + "* [Testing pipeline](#Testing-pipeline)\n", + "* [Predicting pipeline](#Predicting-pipeline)\n", + "* [Analyzing the uncertainty](#Analyzing-the-uncertainty)\n", + "* [Visualizing predictions](#Visualizing-predictions)\n", + " * [Certain prediction](#Certain-prediction)\n", + " * [Uncertain prediction](#Uncertain-prediction)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "from functools import partial\n", + "\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from scipy.stats import beta\n", + "\n", + "sys.path.append(os.path.join(\"..\", \"..\", \"..\"))\n", + "import cardio.dataset as ds\n", + "from cardio import EcgDataset\n", + "from cardio.dataset import B, V, F\n", + "from cardio.models.dirichlet_model import DirichletModel, concatenate_ecg_batch\n", + "from cardio.models.metrics import f1_score, classification_report, confusion_matrix" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Seaborn plotting parameters setting:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "sns.set(\"talk\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By default, TensorFlow attempts to allocate almost the entire memory on all of the available GPUs. Executing this instruction makes only the GPU with id 0 visible for TensorFlow in this process." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "env: CUDA_VISIBLE_DEVICES=0\n" + ] + } + ], + "source": [ + "%env CUDA_VISIBLE_DEVICES=0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dataset initialization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we need to specify paths to ECG signals and their labels:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "SIGNALS_PATH = \"D:\\\\Projects\\\\data\\\\ecg\\\\training2017\\\\\"\n", + "SIGNALS_MASK = SIGNALS_PATH + \"*.hea\"\n", + "LABELS_PATH = SIGNALS_PATH + \"REFERENCE.csv\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's create an ECG dataset and perform a train/test split:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "eds = EcgDataset(path=SIGNALS_MASK, no_ext=True, sort=True)\n", + "eds.cv_split(0.8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training pipeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Dirichlet model builder expects model config to contain input signals' shape and class names:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5, allow_growth=True)\n", + "\n", + "model_config = {\n", + " \"session\": {\"config\": tf.ConfigProto(gpu_options=gpu_options)},\n", + " \"input_shape\": F(lambda batch: batch.signal[0].shape[1:]),\n", + " \"class_names\": F(lambda batch: batch.label_binarizer.classes_),\n", + " \"loss\": None,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "N_EPOCH = 1000\n", + "BATCH_SIZE = 256" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Model training pipeline is composed of:\n", + "* model initialization with the config defined above\n", + "* data loading, preprocessing (e.g. flipping) and augmentation (e.g. resampling)\n", + "* train step execution\n", + "\n", + "Let's create a template pipeline, then link it to our training dataset and run:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "template_train_ppl = (\n", + " ds.Pipeline()\n", + " .init_model(\"dynamic\", DirichletModel, name=\"dirichlet\", config=model_config)\n", + " .init_variable(\"loss_history\", init=list)\n", + " .load(components=[\"signal\", \"meta\"], fmt=\"wfdb\")\n", + " .load(components=\"target\", fmt=\"csv\", src=LABELS_PATH)\n", + " .drop_labels([\"~\"])\n", + " .replace_labels({\"N\": \"NO\", \"O\": \"NO\"})\n", + " .flip_signals()\n", + " .random_resample_signals(\"normal\", loc=300, scale=10)\n", + " .random_split_signals(2048, {\"A\": 9, \"NO\": 3})\n", + " .binarize_labels()\n", + " .train_model(\"dirichlet\", make_data=concatenate_ecg_batch,\n", + " fetches=\"loss\", save_to=V(\"loss_history\"), mode=\"a\")\n", + " .run(batch_size=BATCH_SIZE, shuffle=True, drop_last=True, n_epochs=N_EPOCH, lazy=True)\n", + ")\n", + "\n", + "train_ppl = (eds.train >> template_train_ppl).run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Training loss is stored in \"loss_history\" pipeline variable. Let's take a look at its plot:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4gAAAEOCAYAAADLxjkiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n/w/G2ZMkAT/nCwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x28d625d2080>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "train_loss = [np.mean(l) for l in np.array_split(train_ppl.get_variable(\"loss_history\"), N_EPOCH)]\n", + "\n", + "fig = plt.figure(figsize=(15, 4))\n", + "plt.plot(train_loss)\n", + "plt.xlabel(\"Epochs\")\n", + "plt.ylabel(\"Training loss\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see, training loss almost reaches a plateau by the end of the training." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Saving the model" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<ecg.dataset.dataset.pipeline.Pipeline at 0x28d6564ad68>" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "MODEL_PATH = \"D:\\\\Projects\\\\data\\\\ecg\\\\dirichlet_model\"\n", + "train_ppl.save_model(\"dirichlet\", path=MODEL_PATH)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing pipeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Testing pipeline is almost identical to the training one. The differences lie in the absence of signal resampling and the modified segmentation procedure. Notice, that the model is imported from the training pipeline, rather than being constructed from scratch." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "template_test_ppl = (\n", + " ds.Pipeline()\n", + " .import_model(\"dirichlet\", train_ppl)\n", + " .init_variable(\"predictions_list\", init_on_each_run=list)\n", + " .load(components=[\"signal\", \"meta\"], fmt=\"wfdb\")\n", + " .load(components=\"target\", fmt=\"csv\", src=LABELS_PATH)\n", + " .drop_labels([\"~\"])\n", + " .replace_labels({\"N\": \"NO\", \"O\": \"NO\"})\n", + " .flip_signals()\n", + " .split_signals(2048, 2048)\n", + " .binarize_labels()\n", + " .predict_model(\"dirichlet\", make_data=concatenate_ecg_batch,\n", + " fetches=\"predictions\", save_to=V(\"predictions_list\"), mode=\"e\")\n", + " .run(batch_size=BATCH_SIZE, shuffle=False, drop_last=False, n_epochs=1, lazy=True)\n", + ")\n", + "\n", + "test_ppl = (eds.test >> template_test_ppl).run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now \"predictions_list\" pipeline variable stores model predictions and true targets for all signals labeled with \"A\", \"O\" and \"N\" in the testing dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will use [F1-score](https://en.wikipedia.org/wiki/F1_score) with macro averaging to measure classification performance:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "predictions = test_ppl.get_variable(\"predictions_list\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.90342902903869682" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f1_score(predictions)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " A 0.85 0.81 0.83 171\n", + " NO 0.98 0.98 0.98 1484\n", + "\n", + "avg / total 0.96 0.96 0.96 1655\n", + "\n" + ] + } + ], + "source": [ + "print(classification_report(predictions))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Also take a look at the more detailed report - the confusion matrix:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style>\n", + " .dataframe thead tr:only-child th {\n", + " text-align: right;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: left;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th>True</th>\n", + " <th>A</th>\n", + " <th>NO</th>\n", + " <th>All</th>\n", + " </tr>\n", + " <tr>\n", + " <th>Pred</th>\n", + " <th></th>\n", + " <th></th>\n", + " <th></th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>A</th>\n", + " <td>138</td>\n", + " <td>25</td>\n", + " <td>163</td>\n", + " </tr>\n", + " <tr>\n", + " <th>NO</th>\n", + " <td>33</td>\n", + " <td>1459</td>\n", + " <td>1492</td>\n", + " </tr>\n", + " <tr>\n", + " <th>All</th>\n", + " <td>171</td>\n", + " <td>1484</td>\n", + " <td>1655</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + "True A NO All\n", + "Pred \n", + "A 138 25 163\n", + "NO 33 1459 1492\n", + "All 171 1484 1655" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "confusion_matrix(predictions)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The model misclassifies 33 patients with atrial fibrillation and 25 patients with normal and other rhythms. All other patients were classified correctly." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We’ve already obtained good classification performance. Let’s see if we can do even better." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analyzing the uncertainty" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to class probabilities the model returns its uncertainty in the prediction, which varies from 0 (absolutely sure) to 1 (absolutely unsure). You can see the uncertainty histogram on the plot below:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2oAAAEOCAYAAAD40eRuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x28dfa7d6f98>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "uncertainty = [d[\"uncertainty\"] for d in predictions]\n", + "\n", + "fig = plt.figure(figsize=(15, 4))\n", + "sns.distplot(uncertainty, hist=True, norm_hist=True, kde=False)\n", + "plt.xlabel(\"Model uncertainty\")\n", + "plt.xlim(-0.05, 1.05)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The figure above shows, that the model is almost always certain in its predictions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compare the metrics for the full testing dataset above with the same metrics for 90% most certain predictions:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "q = 90\n", + "thr = np.percentile(uncertainty, q)\n", + "certain_predictions = [d for d in predictions if d[\"uncertainty\"] <= thr]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.95671826175423291" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f1_score(certain_predictions)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " A 0.95 0.89 0.92 102\n", + " NO 0.99 1.00 0.99 1387\n", + "\n", + "avg / total 0.99 0.99 0.99 1489\n", + "\n" + ] + } + ], + "source": [ + "print(classification_report(certain_predictions))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style>\n", + " .dataframe thead tr:only-child th {\n", + " text-align: right;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: left;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th>True</th>\n", + " <th>A</th>\n", + " <th>NO</th>\n", + " <th>All</th>\n", + " </tr>\n", + " <tr>\n", + " <th>Pred</th>\n", + " <th></th>\n", + " <th></th>\n", + " <th></th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>A</th>\n", + " <td>91</td>\n", + " <td>5</td>\n", + " <td>96</td>\n", + " </tr>\n", + " <tr>\n", + " <th>NO</th>\n", + " <td>11</td>\n", + " <td>1382</td>\n", + " <td>1393</td>\n", + " </tr>\n", + " <tr>\n", + " <th>All</th>\n", + " <td>102</td>\n", + " <td>1387</td>\n", + " <td>1489</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + "True A NO All\n", + "Pred \n", + "A 91 5 96\n", + "NO 11 1382 1393\n", + "All 102 1387 1489" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "confusion_matrix(certain_predictions)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can observe a significant increase in precision, recall and F1-score for the atrial fibrillation class. Now only 16 signals were misclassified." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Predicting pipeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's predict class probabilities for a new, unobserved ECG signal.<br>\n", + "Besides, we will load pretrained model from MODEL_PATH directory instead of importing it from another pipeline:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "SIGNALS_PATH = \"D:\\\\Projects\\\\data\\\\ecg\\\\training2017\\\\\"\n", + "MODEL_PATH = \"D:\\\\Projects\\\\data\\\\ecg\\\\dirichlet_model\"\n", + "\n", + "BATCH_SIZE = 100" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5, allow_growth=True)\n", + "\n", + "model_config = {\n", + " \"session\": {\"config\": tf.ConfigProto(gpu_options=gpu_options)},\n", + " \"build\": False,\n", + " \"load\": {\"path\": MODEL_PATH},\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Restoring parameters from D:\\Projects\\data\\ecg\\dirichlet_model\\model-26000\n" + ] + } + ], + "source": [ + "template_predict_ppl = (\n", + " ds.Pipeline()\n", + " .init_model(\"static\", DirichletModel, name=\"dirichlet\", config=model_config)\n", + " .init_variable(\"predictions_list\", init_on_each_run=list)\n", + " .load(fmt=\"wfdb\", components=[\"signal\", \"meta\"])\n", + " .flip_signals()\n", + " .split_signals(2048, 2048)\n", + " .predict_model(\"dirichlet\", make_data=partial(concatenate_ecg_batch, return_targets=False),\n", + " fetches=\"predictions\", save_to=V(\"predictions_list\"), mode=\"e\")\n", + " .run(batch_size=BATCH_SIZE, shuffle=False, drop_last=False, n_epochs=1, lazy=True)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to create a dataset with a single ECG in it, then link it to the template predicting pipeline defined above and run it. Model prediction will be stored in the \"predictions_list\" variable." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "signal_name = \"A00001.hea\"\n", + "signal_path = SIGNALS_PATH + signal_name\n", + "predict_eds = EcgDataset(path=signal_path, no_ext=True, sort=True)\n", + "predict_ppl = (predict_eds >> template_predict_ppl).run()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'target_pred': {'A': 0.020024037, 'NO': 0.97997594},\n", + " 'uncertainty': 0.0063641071319580078}]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predict_ppl.get_variable(\"predictions_list\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The length of the resulting list equals the length of the index of the dataset (1 in out case)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualizing predictions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's look at the target Dirichlet mixture density for a given signal. The pipeline below stores the signal and Dirichlet distribution parameters in its variables in addition to the predicted class probabilities." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Restoring parameters from D:\\Projects\\data\\ecg\\dirichlet_model\\model-26000\n" + ] + } + ], + "source": [ + "template_full_predict_ppl = (\n", + " ds.Pipeline()\n", + " .init_model(\"static\", DirichletModel, name=\"dirichlet\", config=model_config)\n", + " .init_variable(\"signals\", init_on_each_run=list)\n", + " .init_variable(\"predictions_list\", init_on_each_run=list)\n", + " .init_variable(\"parameters_list\", init_on_each_run=list)\n", + " .load(fmt=\"wfdb\", components=[\"signal\", \"meta\"])\n", + " .update_variable(\"signals\", value=B(\"signal\"))\n", + " .flip_signals()\n", + " .split_signals(2048, 2048)\n", + " .predict_model(\"dirichlet\", make_data=partial(concatenate_ecg_batch, return_targets=False),\n", + " fetches=[\"predictions\", \"parameters\"],\n", + " save_to=[V(\"predictions_list\"), V(\"parameters_list\")], mode=\"e\")\n", + " .run(batch_size=BATCH_SIZE, shuffle=False, drop_last=False, n_epochs=1, lazy=True)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def predict_and_visualize(signal_path):\n", + " predict_eds = EcgDataset(path=signal_path, no_ext=True, sort=True)\n", + " \n", + " full_predict_ppl = (predict_eds >> template_full_predict_ppl).run()\n", + " signal = full_predict_ppl.get_variable(\"signals\")[0][0][0][:2000].ravel()\n", + " predictions = full_predict_ppl.get_variable(\"predictions_list\")[0]\n", + " parameters = full_predict_ppl.get_variable(\"parameters_list\")[0]\n", + " \n", + " print(predictions)\n", + "\n", + " x = np.linspace(0.001, 0.999, 1000)\n", + " y = np.zeros_like(x)\n", + " for alpha in parameters:\n", + " y += beta.pdf(x, *alpha)\n", + " y /= len(parameters)\n", + " \n", + " fig, (ax1, ax2) = plt.subplots(1, 2, gridspec_kw={\"width_ratios\": [2.5, 1]}, figsize=(15, 4))\n", + "\n", + " ax1.plot(signal)\n", + "\n", + " ax2.plot(x, y)\n", + " ax2.fill_between(x, y, alpha=0.3)\n", + " ax2.set_ylim(ymin=0)\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Certain prediction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, let’s look at the healthy person’s ECG. The signal is shown on the left plot. Note that it has a clear quasi periodic structure. The right plot shows the pdf of the mixture distributions with atrial fibrillation probability plotted on the horizontal axis. The model is absolutely certain in the absence of AF: almost all the probability density is concentrated around 0." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'target_pred': {'A': 0.016624907, 'NO': 0.98337513}, 'uncertainty': 0.0040795803070068359}\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3kAAAD8CAYAAADKZW0jAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhBBCCBGR/w99CXYaiTlNiAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x28d040262e8>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predict_and_visualize(SIGNALS_PATH + \"A00150.hea\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Uncertain prediction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And now comes an ECG with irregular structure, which may be caused by a disease or some measurement errors. The probability density on the right plot is almost equally concentrated around 0 and 1. This is an example of an uncertain prediction." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'target_pred': {'A': 0.49125454, 'NO': 0.50874543}, 'uncertainty': 0.77499103546142578}\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA24AAAEACAYAAADLMCVkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQuIcBW6EEEIIIYQQEuf+P8CM1PyJK9jBAAAAAElFTkSuQmCC\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x28d06b46c88>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predict_and_visualize(SIGNALS_PATH + \"A01505.hea\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.6.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/cardio/models/fft_model/__init__.py b/cardio/models/fft_model/__init__.py new file mode 100644 index 0000000..403dfb6 --- /dev/null +++ b/cardio/models/fft_model/__init__.py @@ -0,0 +1,3 @@ +"""Contains fft model class.""" + +from .fft_model import FFTModel diff --git a/cardio/models/fft_model/fft_model.py b/cardio/models/fft_model/fft_model.py new file mode 100644 index 0000000..2dac49d --- /dev/null +++ b/cardio/models/fft_model/fft_model.py @@ -0,0 +1,53 @@ +""" Contains fft_model architecture """ + +from keras.layers import Input, Conv1D, Lambda, \ + MaxPooling1D, MaxPooling2D, \ + Dense, GlobalMaxPooling2D +from keras.layers.core import Dropout +import keras.backend as K +import tensorflow as tf + +from ...dataset.dataset.models.keras import KerasModel +from ..keras_custom_objects import RFFT, Crop, Inception2D + +class FFTModel(KerasModel):#pylint: disable=too-many-locals + ''' + FFT inception model. Includes initial convolution layers, then FFT transform, then + a series of inception blocks. + ''' + def _build(self, **kwargs):#pylint: disable=too-many-locals + ''' + Build model + ''' + with tf.variable_scope('fft_model'):#pylint: disable=not-context-manager + x = Input(kwargs['input_shape']) + + conv_1 = Conv1D(4, 4, activation='relu')(x) + mp_1 = MaxPooling1D()(conv_1) + conv_2 = Conv1D(8, 4, activation='relu')(mp_1) + mp_2 = MaxPooling1D()(conv_2) + conv_3 = Conv1D(16, 4, activation='relu')(mp_2) + mp_3 = MaxPooling1D()(conv_3) + conv_4 = Conv1D(32, 4, activation='relu')(mp_3) + + fft_1 = RFFT()(conv_4) + crop_1 = Crop(begin=0, size=128)(fft_1) + to2d = Lambda(K.expand_dims)(crop_1) + + incept_1 = Inception2D(4, 4, 3, 3, activation='relu')(to2d) + mp2d_1 = MaxPooling2D(pool_size=(4, 2))(incept_1) + + incept_2 = Inception2D(4, 8, 3, 3, activation='relu')(mp2d_1) + mp2d_2 = MaxPooling2D(pool_size=(4, 2))(incept_2) + + incept_3 = Inception2D(4, 12, 3, 3, activation='relu')(mp2d_2) + + pool = GlobalMaxPooling2D()(incept_3) + + fc_1 = Dense(8, kernel_initializer='uniform', activation='relu')(pool) + drop = Dropout(0.2)(fc_1) + + fc_2 = Dense(2, kernel_initializer='uniform', + activation='softmax')(drop) + + return x, fc_2 diff --git a/cardio/models/fft_model/fft_model_training.ipynb b/cardio/models/fft_model/fft_model_training.ipynb new file mode 100644 index 0000000..089933e --- /dev/null +++ b/cardio/models/fft_model/fft_model_training.ipynb @@ -0,0 +1,311 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mon Nov 13 15:59:24 2017 \r\n", + "+-----------------------------------------------------------------------------+\r\n", + "| NVIDIA-SMI 375.26 Driver Version: 375.26 |\r\n", + "|-------------------------------+----------------------+----------------------+\r\n", + "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\r\n", + "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\r\n", + "|===============================+======================+======================|\r\n", + "| 0 GeForce GTX 1080 Off | 0000:02:00.0 Off | N/A |\r\n", + "| 23% 49C P2 57W / 200W | 8028MiB / 8113MiB | 72% Default |\r\n", + "+-------------------------------+----------------------+----------------------+\r\n", + "| 1 GeForce GTX 1080 Off | 0000:03:00.0 Off | N/A |\r\n", + "| 0% 46C P0 46W / 200W | 0MiB / 8112MiB | 0% Default |\r\n", + "+-------------------------------+----------------------+----------------------+\r\n", + " \r\n", + "+-----------------------------------------------------------------------------+\r\n", + "| Processes: GPU Memory |\r\n", + "| GPU PID Type Process name Usage |\r\n", + "|=============================================================================|\r\n", + "+-----------------------------------------------------------------------------+\r\n" + ] + } + ], + "source": [ + "!nvidia-smi" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "env: CUDA_VISIBLE_DEVICES=1\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "from sklearn.metrics import f1_score\n", + "import tensorflow as tf\n", + "import numpy as np\n", + "import sys\n", + "import os\n", + "\n", + "sys.path.append(os.path.join(\"..\", \"..\", \"..\"))\n", + "import cardio.dataset as ds\n", + "from cardio import EcgBatch\n", + "from cardio.dataset import F, V, B\n", + "from cardio.models.fft_model import FFTModel\n", + "\n", + "%env CUDA_VISIBLE_DEVICES=1\n", + "config = tf.ConfigProto()\n", + "config.gpu_options.per_process_gpu_memory_fraction = 0.33\n", + "config.gpu_options.allow_growth=True" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "model_config = {\n", + " \"input_shape\": F(lambda batch: batch.signal[0].shape),\n", + " \"loss\": \"binary_crossentropy\",\n", + " \"optimizer\": \"adam\"\n", + "}\n", + "\n", + "def make_data(batch, **kwagrs):\n", + " return {'x': np.array(list(batch.signal)), 'y': batch.target}\n", + " \n", + "train_pipeline = (ds.Pipeline()\n", + " .init_model(\"dynamic\", FFTModel, name=\"fft_model\", config=model_config)\n", + " .init_variable(\"loss_history\", init=list)\n", + " .load(fmt=\"wfdb\", components=[\"signal\", \"meta\"])\n", + " .load(src=\"/notebooks/data/ECG/training2017/REFERENCE.csv\",\n", + " fmt=\"csv\", components=\"target\")\n", + " .drop_labels([\"~\"])\n", + " .replace_labels({\"N\": \"NO\", \"O\": \"NO\"})\n", + " .random_resample_signals(\"normal\", loc=300, scale=10)\n", + " .drop_short_signals(4000)\n", + " .split_signals(3000, 3000)\n", + " .binarize_labels()\n", + " .apply_transform('signal', 'signal', np.transpose, axes=[0, 2, 1])\n", + " .ravel()\n", + " .train_model('fft_model', make_data=make_data,\n", + " save_to=V(\"loss_history\"), mode=\"a\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "index = ds.FilesIndex(path=\"/notebooks/data/ECG/training2017/*.hea\", no_ext=True, sort=True)\n", + "eds = ds.Dataset(index, batch_class=EcgBatch)\n", + "eds.cv_split(0.8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fft_trained = (eds.train >> train_pipeline).run(batch_size=300, shuffle=True,\n", + " drop_last=True, n_epochs=150, prefetch=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Show loss and metric on train" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQ2TuQgiRIVcLSAPFklZH0gAAAABJRU5ErkJggg==\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x7f01a7ff07f0>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "loss = pd.DataFrame(fft_trained.get_variable(\"loss_history\"), columns=[\"loss\"])\n", + "loss[\"avr loss\"] = pd.DataFrame(loss).rolling(center=True, window=100).mean()\n", + "loss.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Save model" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "from cardio.models.keras_custom_objects import RFFT, Crop, Inception2D\n", + "(fft_trained.get_model_by_name(\"fft_model\")\n", + " .save(\"/notebooks/e_illarionov/ecg_repo/model_dump/fft_latest\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def make_pivot(pipeline, variable_name):\n", + " cropes = np.array([x[0] for x in pipeline.get_variable(\"shapes\")])\n", + " pos = np.vstack([np.pad(np.cumsum(cropes)[:-1], pad_width=(1, 0), mode='constant'), cropes]).T\n", + " labels = np.array(pipeline.get_variable(variable_name)) \n", + " return np.array([labels[s: s + i].mean(axis=0) for s, i in pos])\n", + "\n", + "test_pipeline = (ds.Pipeline()\n", + " .import_model(\"fft_model\", fft_trained)\n", + " .init_variable(\"true_labels\", init=list)\n", + " .init_variable(\"pred_labels\", init=list)\n", + " .init_variable(\"shapes\", init=list)\n", + " .init_variable(\"pivot_true_labels\", init=list)\n", + " .init_variable(\"pivot_pred_labels\", init=list)\n", + " .load(fmt=\"wfdb\", components=[\"signal\", \"meta\"])\n", + " .load(src=\"/notebooks/data/ECG/training2017/REFERENCE.csv\",\n", + " fmt=\"csv\", components=\"target\")\n", + " .drop_labels([\"~\"])\n", + " .replace_labels({\"N\": \"NO\", \"O\": \"NO\"})\n", + " .drop_short_signals(4000)\n", + " .split_signals(3000, 3000)\n", + " .binarize_labels()\n", + " .apply_transform('signal', 'signal', np.transpose, axes=[0, 2, 1])\n", + " .update_variable(\"shapes\", F(lambda batch: [x.shape for x in batch.signal]), mode='w')\n", + " .ravel()\n", + " .update_variable(\"true_labels\", B('target'), mode='w')\n", + " .predict_model('fft_model', make_data=make_data, save_to=V(\"pred_labels\"), mode=\"w\")\n", + " .update_variable(\"pivot_true_labels\", F(lambda batch: make_pivot(batch.pipeline, 'true_labels')), mode='e')\n", + " .update_variable(\"pivot_pred_labels\", F(lambda batch: make_pivot(batch.pipeline, 'pred_labels')), mode='e'))" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "res_test = (eds.test >> test_pipeline).run(batch_size=300, shuffle=False, drop_last=False,\n", + " n_epochs=1, prefetch=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.873158788453\n" + ] + } + ], + "source": [ + "print(f1_score(np.array(res_test.get_variable(\"pivot_true_labels\"))[:, 0],\n", + " np.rint(res_test.get_variable(\"pivot_pred_labels\"))[:, 0], average='macro'))" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0.0 0.96 0.99 0.98 1447\n", + " 1.0 0.91 0.67 0.77 159\n", + "\n", + "avg / total 0.96 0.96 0.96 1606\n", + "\n" + ] + } + ], + "source": [ + "from sklearn.metrics import classification_report\n", + "print(classification_report(np.array(res_test.get_variable(\"pivot_true_labels\"))[:, 0],\n", + " np.rint(res_test.get_variable(\"pivot_pred_labels\"))[:, 0]))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/cardio/models/hmm/__init__.py b/cardio/models/hmm/__init__.py new file mode 100644 index 0000000..7ce941c --- /dev/null +++ b/cardio/models/hmm/__init__.py @@ -0,0 +1,2 @@ +"""Contains HMM annotation model class.""" +from .hmm import HMModel diff --git a/cardio/models/hmm/hmm.py b/cardio/models/hmm/hmm.py new file mode 100644 index 0000000..d60accd --- /dev/null +++ b/cardio/models/hmm/hmm.py @@ -0,0 +1,105 @@ +""" HMModel """ + +import numpy as np +import dill + +from ...dataset.dataset.models.base import BaseModel + + +class HMModel(BaseModel): + """ + Hidden Markov Model. + + This implementation is based on hmmlearn API. It is supposed + that estimators of HMModel are model classes of hmmlearn. + """ + + def __init__(self, *args, **kwargs): + self.estimator = None + super().__init__(*args, **kwargs) + + def build(self, *args, **kwargs): + """ + Set up estimator as an attribute and make initial settings. + + Uses estimator from model config variable as estimator. + If config contains key "init_params", sets up initial + values `means_`, `covars_`, `transmat_` and `startprob_` + of the estimator as defined in "init_params". + """ + _ = args, kwargs + self.estimator = self.get("estimator", self.config) + init_params = self.get("init_params", self.config) + if init_params is not None: + if "m" not in self.estimator.init_params: + self.estimator.means_ = init_params["means_"] + if "c" not in self.estimator.init_params: + self.estimator.covars_ = init_params["covars_"] + if "t" not in self.estimator.init_params: + self.estimator.transmat_ = init_params["transmat_"] + if "s" not in self.estimator.init_params: + self.estimator.startprob_ = init_params["startprob_"] + + def save(self, path, *args, **kwargs): # pylint: disable=arguments-differ + """Save HMModel with dill. + + Parameters + ---------- + path : str + Path to the location where to save the model. + """ + if self.estimator is not None: + with open(path, "wb") as file: + dill.dump(self.estimator, file) + else: + raise ValueError("HMM estimator does not exist. Check your cofig for 'estimator'.") + + def load(self, path, *args, **kwargs): # pylint: disable=arguments-differ + """Load HMModel from file with dill. + + Parameters + ---------- + path : str + Path to the model. + """ + with open(path, "rb") as file: + self.estimator = dill.load(file) + + def train(self, X, *args, **kwargs): + """ Train the model using data provided. + + Parameters + ---------- + X : array + An array of observations to learn from. Also, it is expected + that kwargs contain key "lenghts", which define lengths of + sequences. + + For more details and other parameters look at the documentation for the estimator used. + """ + lengths = kwargs.get("lengths", None) + self.estimator.fit(X, lengths) + return list(self.estimator.monitor_.history) + + def predict(self, X, *args, **kwargs): + """ Predict with the data provided + + Parameters + ---------- + X : array + An array of observations to make predictions from. + + For more details and other parameters look at the documentation for the estimator used. + + Returns + ------- + output: array + Predicted value per observation. + """ + lengths = kwargs.get("lengths", None) + preds = self.estimator.predict(X, lengths) + if lengths: + output = np.array(np.split(preds, np.cumsum(lengths)[:-1]) + [None])[:-1] + else: + output = preds + return output diff --git a/cardio/models/hmm/hmmodel_training.ipynb b/cardio/models/hmm/hmmodel_training.ipynb new file mode 100644 index 0000000..f31f6fb --- /dev/null +++ b/cardio/models/hmm/hmmodel_training.ipynb @@ -0,0 +1,660 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# HMModel trainig" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook we will train Hidden Markov Model for ECG signal annotation to find P-wave, QRS complex and T-wave." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Table of contents" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "* [Setting up](#Setting-up)\n", + "* [Helper functions](#Helper-functions)\n", + "* [Dataset initialization](#Dataset-initialization)\n", + "* [Preprocessing](#Preprocessing)\n", + "* [Training](#Training)\n", + "* [Prediction](#Prediction)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setting up" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "\n", + "import os\n", + "import sys\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from hmmlearn import hmm\n", + "\n", + "sys.path.append(os.path.join(\"..\", \"..\", \"..\"))\n", + "import cardio.dataset as ds\n", + "from cardio import EcgBatch\n", + "from cardio.dataset import B, V, F\n", + "from cardio.models.hmm import HMModel\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Helper functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here are helper functions to generate data for learning, to get values from pipeline, and to perform calculation of initial parameters of the HMM." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def prepare_batch(batch, model):\n", + " X = np.concatenate([ann[\"wavelets\"] for ann in batch.annotation])\n", + " lengths = [ann[\"wavelets\"].shape[0] for ann in batch.annotation]\n", + " return {\"X\": X, \"lengths\": lengths}\n", + "\n", + "def get_wavelets(batch):\n", + " return [ann[\"wavelets\"] for ann in batch.annotation]\n", + "\n", + "def get_annsamples(batch):\n", + " return [ann[\"annsamp\"] for ann in batch.annotation]\n", + "\n", + "def get_anntypes(batch):\n", + " return [ann[\"anntype\"] for ann in batch.annotation]\n", + "\n", + "def get_batch(batch):\n", + " return [batch]\n", + "\n", + "def unravel_annotation(annsamp, anntype, length):\n", + " begin = -1\n", + " end = -1\n", + " s = 'none'\n", + " states = {'N':0, 'st':1,'t':2, 'iso':3, 'p':4, 'pq': 5}\n", + " annot = -1 * np.ones(length)\n", + "\n", + " for j in range(len(annsamp)):\n", + " if anntype[j] == '(':\n", + " begin=annsamp[j]\n", + " if (end > 0) & (s != 'none'):\n", + " if s == 'N':\n", + " annot[end:begin] = states['st']\n", + " elif s == 't':\n", + " annot[end:begin] = states['iso']\n", + " elif s == 'p':\n", + " annot[end:begin] = states['pq']\n", + " elif anntype[j] == ')':\n", + " end = annsamp[j]\n", + " if (begin > 0) & (s != 'none'):\n", + " annot[begin:end] = states[s] \n", + " else: \n", + " s = anntype[j]\n", + " \n", + " return annot\n", + "\n", + "def prepare_means_covars(wavelets, clustering, states=[3, 5, 11, 14, 17, 19], num_states=19, num_features=3):\n", + " \"\"\"This function is specific to the task and the model configuration, thus contains hardcode.\n", + " \"\"\"\n", + " means = np.zeros((num_states, num_features))\n", + " covariances = np.zeros((num_states, num_features, num_features))\n", + " \n", + " # Prepearing means and variances\n", + " last_state = 0\n", + " unique_clusters = len(np.unique(clustering)) - 1 # Excuding value -1, which represents undefined state\n", + " for state, cluster in zip(states, np.arange(unique_clusters)):\n", + " value = wavelets[clustering == cluster, :]\n", + " means[last_state:state, :] = np.mean(value, axis=0)\n", + " covariances[last_state:state, :, :] = value.T.dot(value) / np.sum(clustering == cluster)\n", + " last_state = state\n", + " \n", + " return means, covariances\n", + "\n", + "def prepare_transmat_startprob():\n", + " \"\"\" This function is specific to the task and the model configuration, thus contains hardcode.\n", + " \"\"\"\n", + " # Transition matrix - each row should add up tp 1\n", + " transition_matrix = np.diag(19 * [14/15.0]) + np.diagflat(18 * [1/15.0], 1) + np.diagflat([1/15.0], -18)\n", + " \n", + " # We suppose that absence of P-peaks is possible\n", + " transition_matrix[13,14]=0.9*1/15.0\n", + " transition_matrix[13,17]=0.1*1/15.0\n", + "\n", + " # Initial distribution - should add up to 1\n", + " start_probabilities = np.array(19 * [1/np.float(19)])\n", + " \n", + " return transition_matrix, start_probabilities " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dataset initialization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we need to specify paths to ECG signals:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "SIGNALS_PATH = \"/notebooks/dpodvyaznikov/clada/ecg_report/Intenship_submit/QT/ecg_copy\"\n", + "SIGNALS_MASK = os.path.join(SIGNALS_PATH, \"*.hea\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next step is to create dataset and perform train/test split:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "index = ds.FilesIndex(path=SIGNALS_MASK, no_ext=True, sort=True)\n", + "dtst = ds.Dataset(index, batch_class=EcgBatch)\n", + "dtst.cv_split(0.9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Preprocessing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to calculate initial parameters for the model to ease the learning process.\n", + "To do it, we will define template pipeline that loads data and accumulates the data we need for initial parameters in pipeline variables:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true, + "scrolled": false + }, + "outputs": [], + "source": [ + "template_ppl_inits = (\n", + " ds.Pipeline()\n", + " .init_variable(\"annsamps\", init_on_each_run=list)\n", + " .init_variable(\"anntypes\", init_on_each_run=list)\n", + " .init_variable(\"wavelets\", init_on_each_run=list)\n", + " .load(fmt='wfdb', components=[\"signal\", \"annotation\", \"meta\"], ann_ext='pu1')\n", + " .wavelet_transform_signal(cwt_scales=[4,8,16], cwt_wavelet=\"mexh\")\n", + " .update_variable(\"annsamps\", ds.F(get_annsamples), mode='e')\n", + " .update_variable(\"anntypes\", ds.F(get_anntypes), mode='e')\n", + " .update_variable(\"wavelets\", ds.F(get_wavelets), mode='e')\n", + " .run(batch_size=20, shuffle=False, drop_last=False, n_epochs=1, lazy=True)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we link the dataset to the template pipeline:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "ppl_inits = (dtst.train >> template_ppl_inits).run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we get values from pipeline variables and perform calculation of the models' initial parameters: means, covariances, transition matrix and initial probabilities." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "lengths = [wavelet.shape[0] for wavelet in ppl_inits.get_variable(\"wavelets\")]\n", + "wavelets = np.concatenate(ppl_inits.get_variable(\"wavelets\"))\n", + "anntype = ppl_inits.get_variable(\"anntypes\")\n", + "annsamp = ppl_inits.get_variable(\"annsamps\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After this, we unravel the annotation with helper function so that each observation has it's own label: 0 for QRS complex, 1 for ST segment, 2 for T-wave, 3 for ISO segment, 4 for P-wave, 5 for PQ segment and -1 for all other observations." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "unravelled = np.concatenate([unravel_annotation(samp, types, length) for samp, types, length in zip(annsamp, anntype, lengths)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now using unravelled annotation calculate means and covariances for the states of the model:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "means, covariances = prepare_means_covars(wavelets, unravelled, states = [3, 5, 11, 14, 17, 19], num_features = 3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And, finally, define matrix of transitions between states and probabilities of the states:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "transition_matrix, start_probabilities = prepare_transmat_startprob()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In config we first specify that we want model to be build from scratch rather than loaded. Next, pass the desired estimator and initial parameters that we calculated in previous section." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "config_train = {\n", + " 'build': True,\n", + " 'estimator': hmm.GaussianHMM(n_components=19, n_iter=25, covariance_type=\"full\", random_state=42,\n", + " init_params='', verbose=False),\n", + " 'init_params': {'means_': means, 'covars_': covariances, 'transmat_': transition_matrix,\n", + " 'startprob_': start_probabilities}\n", + " }" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Training pipeline consists of the following actions:\n", + "* Model initialization (building)\n", + "* Data loading\n", + "* Preprocessing (e.g. wavelet transformation)\n", + "* Train step on current batch data\n", + "\n", + "Let's create template pipeline:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "ppl_train_template = (\n", + " ds.Pipeline()\n", + " .init_model(\"dynamic\", HMModel, \"HMM\", config=config_train)\n", + " .load(fmt='wfdb', components=[\"signal\", \"annotation\", \"meta\"], ann_ext='pu1')\n", + " .wavelet_transform_signal(cwt_scales=[4,8,16], cwt_wavelet=\"mexh\")\n", + " .train_model(\"HMM\", make_data=prepare_batch)\n", + " .run(batch_size=20, shuffle=False, drop_last=False, n_epochs=1, lazy=True)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we link this template to the dataset and run:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "ppl_train = (dtst.train >> ppl_train_template).run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From resulting pipeline we can save the trained model to file." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "ppl_train.save_model(\"HMM\", path=\"../models/hmmodel.dll\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Prediction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this config we tell that we want to load existing model from specified path:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "config_predict = {\n", + " 'build': False,\n", + " 'load': {'path': \"../models/hmmodel.dll\"}\n", + " }" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Prediction pipeline is somewhat more complex and composed of:\n", + "* Model initialization (loading)\n", + "* Initialization of pipeline variable\n", + "* Data loading\n", + "* Preprocesing\n", + "* Calculation of ECG parameters, such as HR\n", + "* Update of the variable\n", + "\n", + "Template for this pipeline looks like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "template_ppl_predict = (\n", + " ds.Pipeline()\n", + " .init_model(\"static\", HMModel, \"HMM\", config=config_predict)\n", + " .init_variable(\"batch\", init_on_each_run=list)\n", + " .load(fmt=\"wfdb\", components=[\"signal\", \"annotation\", \"meta\"], ann_ext=\"pu1\")\n", + " .wavelet_transform_signal(cwt_scales=[4,8,16], cwt_wavelet=\"mexh\")\n", + " .predict_model(\"HMM\", make_data=prepare_batch, save_to=ds.B(\"_temp\"), mode='w')\n", + " .write_to_annotation(\"hmm_annotation\", \"_temp\")\n", + " .calc_ecg_parameters()\n", + " .update_variable(\"batch\", ds.F(get_batch), mode='e')\n", + " .run(batch_size=20, shuffle=False, drop_last=False, n_epochs=1, lazy=True)\n", + "\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's link pipieline to dataset and run:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": true, + "scrolled": false + }, + "outputs": [], + "source": [ + "ppl_predict = (dtst.test >> template_ppl_predict).run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can access values from pipeline variable. In this pipeline we have accumulated all the batches in this variable - let's take a look at some of them. First, select one the batches from pipeline variable:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "batch = ppl_predict.get_variable(\"batch\")[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, select fifth and nineth signal from that batch:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "example_1 = 5\n", + "example_2 = 9" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can look at the plots with annotated ECG segments and the heart rate, calculated based on this annotation:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Heart rate: 78 bpm\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm0AAAHjCAYAAABxWSiLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRVEURZkH/P/BYZfn57x+zAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x7f6337dc32e8>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "batch.show_ecg(batch.indices[example_1], 0, 5, True)\n", + "print(\"Heart rate: %d bpm\" %batch.meta[example_1][\"hr\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Heart rate: 72 bpm\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm0AAAHjCAYAAABxWSiLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x7f6316f69710>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "batch.show_ecg(batch.indices[example_2], 0, 5, True)\n", + "print(\"Heart rate: %d bpm\" %batch.meta[example_2][\"hr\"])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [default]", + "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.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/cardio/models/keras_custom_objects.py b/cardio/models/keras_custom_objects.py new file mode 100644 index 0000000..fd86205 --- /dev/null +++ b/cardio/models/keras_custom_objects.py @@ -0,0 +1,202 @@ +""" Contains keras custom objects """ + +import tensorflow as tf +from keras.engine.topology import Layer +from keras.layers import Input, Conv2D, Lambda, MaxPooling2D +from keras.layers.merge import Concatenate +import keras.backend as K + +class RFFT(Layer): + ''' + Keras layer for one-dimensional discrete Fourier Transform for real input. + Computes rfft transforn on each slice along last dim. + + Input shape + 3D tensor (batch_size, signal_length, nb_channels) + + Output shape + 3D tensor (batch_size, int(signal_length / 2), nb_channels) + ''' + def __init__(self, *agrs, **kwargs): + super(RFFT, self).__init__(*agrs, **kwargs) + + def rfft(self, x, fft_fn): + ''' + Computes one-dimensional discrete Fourier Transform on each slice along last dim. + Returns amplitude spectrum. + + Parameters + ---------- + x : tensor + 3D tensor (batch_size, signal_length, nb_channels) + fft_fn : function + Function that performs fft + + Returns + ------- + out : 3D tensor + Computed fft(x). 3D tensor (batch_size, signal_length // 2, nb_channels) + ''' + resh = K.cast(K.map_fn(K.transpose, x), dtype='complex64') + spec = K.abs(K.map_fn(fft_fn, resh)) + out = K.cast(K.map_fn(K.transpose, spec), dtype='float32') + shape = tf.shape(out) + new_shape = [shape[0], shape[1] // 2, shape[2]] + out_real = tf.slice(out, [0, 0, 0], new_shape) + return out_real + + def call(self, x): + ''' + Implements Keras call method. + ''' + return Lambda(self.rfft, arguments={'fft_fn': K.tf.fft})(x) + + def compute_output_shape(self, input_shape): + '''' + Implements Keras compute_output_shape method. + ''' + if input_shape[1] is None: + return input_shape + else: + return (input_shape[0], input_shape[1] // 2, input_shape[2]) + + +class Crop(Layer): + ''' + Keras layer returns cropped signal. + + Input shape + 3D tensor (batch_size, signal_length, nb_channels) + + Output shape + 3D tensor (batch_size, size, nb_channels) + + Parameters + ---------- + begin : int + Begin of the cropped segment + size : int + Size of the cropped segment + + Attributes + ---------- + begin : int + Begin of the cropped segment + size : int + Size of the cropped segment + ''' + def __init__(self, begin, size, *agrs, **kwargs): + self.begin = begin + self.size = size + super(Crop, self).__init__(*agrs, **kwargs) + + def call(self, x): + ''' + Implements Keras call method. + ''' + return x[:, self.begin: self.begin + self.size, :] + + def compute_output_shape(self, input_shape): + ''' + Implements Keras compute_output_shape method. + ''' + return (input_shape[0], self.size, input_shape[2]) + + +class Inception2D(Layer):#pylint: disable=too-many-instance-attributes + ''' + Keras layer implements inception block. + + Input shape + 4D tensor (batch_size, width, height, nb_channels) + + Output shape + 4D tensor (batch_size, width, height, 3 * nb_filters + base_dim) + + Parameters + ---------- + base_dim : int + nb_filters for the first convolution layers. + nb_filters : int + nb_filters for the second convolution layers. + kernel_size_1 : int + Kernel_size for the second convolution layer. + kernel_size_2 : int + Kernel_size for the second convolution layer. + activation : string + Activation function for each convolution. Default is 'linear'. + + Attributes + ---------- + base_dim : int + nb_filters for the first convolution layers. + nb_filters : int + nb_filters for the second convolution layers. + kernel_size_1 : int + Kernel_size for the second convolution layer. + kernel_size_2 : int + Kernel_size for the second convolution layer. + activation : string + Activation function for each convolution. Default is 'linear'. + ''' + def __init__(self, base_dim, nb_filters,#pylint: disable=too-many-arguments + kernel_size_1, kernel_size_2, + activation=None, *agrs, **kwargs): + self.base_dim = base_dim + self.nb_filters = nb_filters + self.kernel_size_1 = kernel_size_1 + self.kernel_size_2 = kernel_size_2 + self.activation = activation if activation is not None else 'linear' + self.layers = {} + super(Inception2D, self).__init__(*agrs, **kwargs) + + def build(self, input_shape): + ''' + Implements Keras build method + ''' + x = Input(input_shape[1:]) + self.layers.update({'conv_1': Conv2D(self.base_dim, (1, 1), activation=self.activation, padding='same')}) + _ = self.layers['conv_1'](x) + + self.layers.update({'conv_2': Conv2D(self.base_dim, (1, 1), activation=self.activation, padding='same')}) + out = self.layers['conv_2'](x) + self.layers.update({'conv_2a': Conv2D(self.nb_filters, (self.kernel_size_1, self.kernel_size_1), + activation=self.activation, padding='same')}) + out = self.layers['conv_2a'](out) + + self.layers.update({'conv_3': Conv2D(self.base_dim, (1, 1), activation=self.activation, padding='same')}) + out = self.layers['conv_3'](x) + self.layers.update({'conv_3a': Conv2D(self.nb_filters, (self.kernel_size_2, self.kernel_size_2), + activation=self.activation, padding='same')}) + out = self.layers['conv_3a'](out) + + self.layers.update({'conv_4': Conv2D(self.nb_filters, (1, 1), activation=self.activation, padding='same')}) + _ = self.layers['conv_4'](x) + + for layer in self.layers.values(): + self.trainable_weights.extend(layer.trainable_weights) + + return super(Inception2D, self).build(input_shape) + + def call(self, x): + ''' + Implements Keras call method + ''' + conv_1 = self.layers['conv_1'](x) + + conv_2 = self.layers['conv_2'](x) + conv_2a = self.layers['conv_2a'](conv_2) + + conv_3 = self.layers['conv_3'](x) + conv_3a = self.layers['conv_3a'](conv_3) + + pool = MaxPooling2D(strides=(1, 1), padding='same')(x) + conv_4 = self.layers['conv_4'](pool) + + return Concatenate(axis=-1)([conv_1, conv_2a, conv_3a, conv_4]) + + def compute_output_shape(self, input_shape): + ''' + Implements Keras compute_output_shape method + ''' + return (*input_shape[:-1], self.base_dim + 3 * self.nb_filters) diff --git a/cardio/models/layers.py b/cardio/models/layers.py new file mode 100644 index 0000000..40280d5 --- /dev/null +++ b/cardio/models/layers.py @@ -0,0 +1,84 @@ +"""Contains helper functions for tensorflow layers creation.""" + +import tensorflow as tf + + +def conv1d_block(scope, input_layer, is_training, filters, kernel_size, pool_size=2, pool_stride=2, act_fn=tf.nn.relu): + """Create conv1d -> max_pooling1d -> batch_normalization -> activation layer. + + Parameters + ---------- + scope : str + Variable scope name. + input_layer : 3-D Tensor + Input tensor with channels_last ordering. + is_training : 0-D Tensor with bool dtype + True for training phase and False for inference. + filters : int + The number of filters in the convolution. + kernel_size : int + The length of the convolution kernel. + pool_size : int + The size of the pooling window. + pool_stride : int + The strides of the pooling operation. + act_fn : callable + Activation function. + + Returns + ------- + tensor : Tensor + Output tensor. + """ + with tf.variable_scope(scope): # pylint: disable=not-context-manager + conv = tf.layers.conv1d(input_layer, filters, kernel_size, padding="same", + data_format="channels_last", use_bias=False, name="conv") + pool = tf.layers.max_pooling1d(conv, pool_size, pool_stride, + data_format="channels_last", name="pool") + bnorm = tf.layers.batch_normalization(pool, training=is_training, name="batch_norm", fused=True) + act = act_fn(bnorm, name="activation") + return act + + +def resnet1d_block(scope, input_layer, is_training, filters, kernel_size, downsample=False, act_fn=tf.nn.relu): + """Create 1-D resnet block with two consequent convolutions and shortcut connection. + + Parameters + ---------- + scope : str + Variable scope name. + input_layer : 3-D Tensor + Input tensor with channels_last ordering. + is_training : 0-D Tensor with bool dtype + True for training phase and False for inference. + filters : int + The number of filters in both convolutions. + kernel_size : int + The length of the convolution's kernels. + downsample : bool + Specifies whether to reduce the spatial dimension by the factor of two. + act_fn : callable + Activation function. + + Returns + ------- + tensor : Tensor + Output tensor. + """ + with tf.variable_scope(scope): # pylint: disable=not-context-manager + strides = 2 if downsample else 1 + conv = tf.layers.conv1d(input_layer, filters, kernel_size, strides, padding="same", + data_format="channels_last", use_bias=False, name="conv_1") + bnorm = tf.layers.batch_normalization(conv, training=is_training, name="batch_norm_1", fused=True) + act = act_fn(bnorm, name="act_1") + conv = tf.layers.conv1d(act, filters, kernel_size, padding="same", + data_format="channels_last", use_bias=False, name="conv_2") + if downsample: + input_layer = tf.layers.max_pooling1d(input_layer, 2, 2, data_format="channels_last", name="pool") + if input_layer.get_shape()[-1] != conv.get_shape()[-1]: + input_layer = tf.layers.conv1d(input_layer, conv.get_shape()[-1], 1, padding="same", + data_format="channels_last", use_bias=False, name="conv_3") + conv = conv + input_layer + bnorm = tf.layers.batch_normalization(conv, training=is_training, name="batch_norm_2", fused=True) + act = act_fn(bnorm, name="act_2") + return act diff --git a/cardio/models/metrics.py b/cardio/models/metrics.py new file mode 100644 index 0000000..ec54a62 --- /dev/null +++ b/cardio/models/metrics.py @@ -0,0 +1,207 @@ +"""Contains metric functions.""" + +import numpy as np +import pandas as pd +from sklearn import metrics + + +__all__ = ["f1_score", "auc", "classification_report", "confusion_matrix", "calculate_metrics"] + + +def get_class_prob(predictions_dict): + """Get true and predicted targets from predictions_dict. + + Parameters + ---------- + predictions_dict : dict + Dict of model predictions. Must contain "target_true" and "target_pred" keys with corresponding + dict values of the form class_label : probability. + + Returns + ------- + true_dict : dict + True target - value for "target_true" key from the predictions_dict. + pred_dict : dict + Predicted target - value for "target_pred" key from the predictions_dict. + """ + true_dict = predictions_dict.get("target_true") + pred_dict = predictions_dict.get("target_pred") + if true_dict is None or pred_dict is None: + raise ValueError("Each element of predictions list must be a dict with target_true and target_pred keys") + return true_dict, pred_dict + + +def get_labels(predictions_list): + """Get true and predicted class labels from predictions_list. + + Parameters + ---------- + predictions_list : list + List, containing dicts of model predictions. Each dict must contain "target_true" and "target_pred" keys + with corresponding dict values of the form class_label : probability. + + Returns + ------- + true_labels : 1-D ndarray + True class labels. + pred_labels : 1-D ndarray + Predicted class labels. + """ + true_labels = [] + pred_labels = [] + for predictions_dict in predictions_list: + true_dict, pred_dict = get_class_prob(predictions_dict) + true_labels.append(max(true_dict, key=true_dict.get)) + pred_labels.append(max(pred_dict, key=pred_dict.get)) + return np.array(true_labels), np.array(pred_labels) + + +def get_probs(predictions_list): + """Get true and predicted class probabilities from predictions_list. + + Parameters + ---------- + predictions_list : list + List, containing dicts of model predictions. Each dict must contain "target_true" and "target_pred" keys + with corresponding dict values of the form class_label : probability. + + Returns + ------- + true_probs : 2-D ndarray + True class probabilities. + pred_probs : 2-D ndarray + Predicted class probabilities. + """ + true_probs = [] + pred_probs = [] + for predictions_dict in predictions_list: + true_dict, pred_dict = get_class_prob(predictions_dict) + true_probs.append([true_dict[key] for key in sorted(true_dict.keys())]) + pred_probs.append([pred_dict[key] for key in sorted(pred_dict.keys())]) + return np.array(true_probs), np.array(pred_probs) + + +def f1_score(predictions_list, labels=None, average="macro", **kwargs): + """Compute the F1 score. + + Parameters + ---------- + predictions_list : list + List, containing dicts of model predictions. Each dict must contain "target_true" and "target_pred" keys + with corresponding dict values of the form class_label : probability. + average : str or None + sklearn.metrics.f1_score average parameter, which determines the type of averaging performed on the data. + **kwargs : misc + Other sklearn.metrics.f1_score keyword arguments. + + Returns + ------- + f1_score : float or array of floats + F1 score for each class or weighted average of the F1 scores. + """ + true_labels, pred_labels = get_labels(predictions_list) + if labels is None: + labels = sorted(set(true_labels) | set(pred_labels)) + return metrics.f1_score(true_labels, pred_labels, labels=labels, average=average, **kwargs) + + +def auc(predictions_list, average="macro", **kwargs): + """Compute area under the ROC curve. + + Parameters + ---------- + predictions_list : list + List, containing dicts of model predictions. Each dict must contain "target_true" and "target_pred" keys + with corresponding dict values of the form class_label : probability. + average : str or None + sklearn.metrics.roc_auc_score average parameter, which determines the type of averaging performed on the data. + **kwargs : misc + Other sklearn.metrics.roc_auc_score keyword arguments. + + Returns + ------- + auc : float or array of floats + AUC for each class or weighted average of the AUCs. + """ + return metrics.roc_auc_score(*get_probs(predictions_list), average=average, **kwargs) + + +def classification_report(predictions_list, **kwargs): + """Build a text report showing the main classification metrics. + + Parameters + ---------- + predictions_list : list + List, containing dicts of model predictions. Each dict must contain "target_true" and "target_pred" keys + with corresponding dict values of the form class_label : probability. + **kwargs : misc + Other sklearn.metrics.classification_report keyword arguments. + + Returns + ------- + report : string + Text summary of the precision, recall and F1 score for each class. + """ + return metrics.classification_report(*get_labels(predictions_list), **kwargs) + + +def confusion_matrix(predictions_list, margins=True, **kwargs): + """Compute confusion matrix from correct and estimated targets. + + Parameters + ---------- + predictions_list : list + List, containing dicts of model predictions. Each dict must contain "target_true" and "target_pred" keys + with corresponding dict values of the form class_label : probability. + margins : bool + Specifies whether to add row and column margins with subtotals. + **kwargs : misc + Other pandas.crosstab keyword arguments. + + Returns + ------- + crosstab : DataFrame + Classifier confusion matrix. + """ + true, pred = get_labels(predictions_list) + true = pd.Series(true, name="True") + pred = pd.Series(pred, name="Pred") + return pd.crosstab(pred, true, margins=margins, **kwargs) + + +METRICS_DICT = { + "f1_score": f1_score, + "auc": auc, + "classification_report": classification_report, + "confusion_matrix": confusion_matrix, +} + + +def calculate_metrics(metrics_list, predictions_list): + """Calculate metrics from metrics_list. + + Parameters + ---------- + metrics_list : list + List of metrics. Each element can be either str with metric name or callable. + predictions_list : list + List, containing dicts of model predictions. Each dict must contain "target_true" and "target_pred" keys + with corresponding dict values of the form class_label : probability. + + Returns + ------- + metrics_res : list + List containing results for every metric in metrics_list. + """ + metrics_res = [] + for metric in metrics_list: + if isinstance(metric, str): + metric_fn = METRICS_DICT.get(metric) + if metric_fn is None: + raise KeyError("Unknown metric name {}".format(metric)) + elif callable(metric): + metric_fn = metric + else: + raise ValueError("Unknown metric type") + metrics_res.append(metric_fn(predictions_list)) + return metrics_res diff --git a/cardio/pipelines/__init__.py b/cardio/pipelines/__init__.py new file mode 100644 index 0000000..552a764 --- /dev/null +++ b/cardio/pipelines/__init__.py @@ -0,0 +1,3 @@ +"""Contains ECG pipelines.""" + +from .pipelines import * # pylint: disable=wildcard-import diff --git a/cardio/pipelines/pipelines.py b/cardio/pipelines/pipelines.py new file mode 100644 index 0000000..8686b98 --- /dev/null +++ b/cardio/pipelines/pipelines.py @@ -0,0 +1,306 @@ +"""Contains pipelines.""" + +from functools import partial +import numpy as np + +import tensorflow as tf +from hmmlearn import hmm + +import cardio.dataset as ds +from cardio.dataset import F, V +from cardio.models.dirichlet_model import DirichletModel, concatenate_ecg_batch +from cardio.models.hmm import HMModel + + +def dirichlet_train_pipeline(labels_path, batch_size=256, n_epochs=1000, gpu_options=None): + """Train pipeline for Dirichlet model. + + This pipeline trains Dirichlet model to find propability of artrial fibrillation. + It works with dataset that generates bathes of class EcgBatch. + + Parameters + ---------- + labels_path : str + Path to csv file with true labels. + batch_size : int + Number of samples per gradient update. + Default value is 256. + n_epochs : int + Number of times to iterate over the training data arrays. + Default value is 1000. + gpu_options : GPUOptions + Magic attribute generated for tf.ConfigProto "gpu_options" proto field. + Default value is None. + + Returns + ------- + pipeline : Pipeline + Output pipeline. + """ + + model_config = { + "session": {"config": tf.ConfigProto(gpu_options=gpu_options)}, + "input_shape": F(lambda batch: batch.signal[0].shape[1:]), + "class_names": F(lambda batch: batch.label_binarizer.classes_), + "loss": None, + } + + return (ds.Pipeline() + .init_model("dynamic", DirichletModel, name="dirichlet", config=model_config) + .init_variable("loss_history", init=list) + .load(components=["signal", "meta"], fmt="wfdb") + .load(components="target", fmt="csv", src=labels_path) + .drop_labels(["~"]) + .replace_labels({"N": "NO", "O": "NO"}) + .flip_signals() + .random_resample_signals("normal", loc=300, scale=10) + .random_split_signals(2048, {"A": 9, "NO": 3}) + .binarize_labels() + .train_model("dirichlet", make_data=concatenate_ecg_batch, + fetches="loss", save_to=V("loss_history"), mode="a") + .run(batch_size=batch_size, shuffle=True, drop_last=True, n_epochs=n_epochs, lazy=True)) + +def dirichlet_predict_pipeline(model_path, batch_size=100, gpu_options=None): + """Pipeline for prediction with Dirichlet model. + + This pipeline finds propability of artrial fibrillation according to Dirichlet model. + It works with dataset that generates bathes of class EcgBatch. + + Parameters + ---------- + model_path : str + path to pretrained Dirichlet model + batch_size : int + Number of samples in batch. + Default value is 100. + gpu_options : GPUOptions + Magic attribute generated for tf.ConfigProto "gpu_options" proto field. + Default value is None. + + Returns + ------- + pipeline : Pipeline + Output pipeline. + """ + + model_config = { + "session": {"config": tf.ConfigProto(gpu_options=gpu_options)}, + "build": False, + "load": {"path": model_path}, + } + + return (ds.Pipeline() + .init_model("static", DirichletModel, name="dirichlet", config=model_config) + .init_variable("predictions_list", init_on_each_run=list) + .load(fmt="wfdb", components=["signal", "meta"]) + .flip_signals() + .split_signals(2048, 2048) + .predict_model("dirichlet", make_data=partial(concatenate_ecg_batch, return_targets=False), + fetches="predictions", save_to=V("predictions_list"), mode="e") + .run(batch_size=batch_size, shuffle=False, drop_last=False, n_epochs=1, lazy=True)) + +def hmm_preprocessing_pipeline(batch_size=20): + """Pipeline for prediction with hmm model. + + This pipeline prepares data for hmm_train_pipeline. + It works with dataset that generates bathes of class EcgBatch. + + Parameters + ---------- + batch_size : int + Number of samples in batch. + Default value is 100. + + Returns + ------- + pipeline : Pipeline + Output pipeline. + """ + + def get_wavelets(batch): + """Get wavelets from annotation + """ + return [ann["wavelets"] for ann in batch.annotation] + + def get_annsamples(batch): + """Get annsamples from annotation + """ + return [ann["annsamp"] for ann in batch.annotation] + + def get_anntypes(batch): + """Get anntypes from annotation + """ + return [ann["anntype"] for ann in batch.annotation] + + return (ds.Pipeline() + .init_variable("annsamps", init_on_each_run=list) + .init_variable("anntypes", init_on_each_run=list) + .init_variable("wavelets", init_on_each_run=list) + .load(fmt='wfdb', components=["signal", "annotation", "meta"], ann_ext='pu1') + .wavelet_transform_signal(cwt_scales=[4, 8, 16], cwt_wavelet="mexh") + .update_variable("annsamps", ds.F(get_annsamples), mode='e') + .update_variable("anntypes", ds.F(get_anntypes), mode='e') + .update_variable("wavelets", ds.F(get_wavelets), mode='e') + .run(batch_size=batch_size, shuffle=False, drop_last=False, n_epochs=1, lazy=True)) + +def hmm_train_pipeline(hmm_preprocessed, batch_size=20): + """Train pipeline for Hidden Markov Model. + + This pipeline trains hmm model to isolate QRS, PQ and QT segments. + It works with dataset that generates bathes of class EcgBatch. + + Parameters + ---------- + hmm_preprocessed : Pipeline + Pipeline with precomputed hmm features through hmm_preprocessing_pipeline + batch_size : int + Number of samples in batch. + Default value is 20. + + Returns + ------- + pipeline : Pipeline + Output pipeline. + """ + + def prepare_batch(batch, model): + """Prepare data for training + """ + _ = model + x = np.concatenate([ann["wavelets"] for ann in batch.annotation]) + lengths = [ann["wavelets"].shape[0] for ann in batch.annotation] + return {"X": x, "lengths": lengths} + + def prepare_means_covars(wavelets, clustering, states=[3, 5, 11, 14, 17, 19], num_states=19, num_features=3):#pylint: disable=dangerous-default-value + """This function is specific to the task and the model configuration, thus contains hardcode. + """ + means = np.zeros((num_states, num_features)) + covariances = np.zeros((num_states, num_features, num_features)) + + # Prepearing means and variances + last_state = 0 + unique_clusters = len(np.unique(clustering)) - 1 # Excuding value -1, which represents undefined state + for state, cluster in zip(states, np.arange(unique_clusters)): + value = wavelets[clustering == cluster, :] + means[last_state:state, :] = np.mean(value, axis=0) + covariances[last_state:state, :, :] = value.T.dot(value) / np.sum(clustering == cluster) + last_state = state + + return means, covariances + + def prepare_transmat_startprob(): + """ This function is specific to the task and the model configuration, thus contains hardcode. + """ + # Transition matrix - each row should add up tp 1 + transition_matrix = np.diag(19 * [14/15.0]) + np.diagflat(18 * [1/15.0], 1) + np.diagflat([1/15.0], -18) + + # We suppose that absence of P-peaks is possible + transition_matrix[13, 14] = 0.9*1/15.0 + transition_matrix[13, 17] = 0.1*1/15.0 + + # Initial distribution - should add up to 1 + start_probabilities = np.array(19 * [1/np.float(19)]) + + return transition_matrix, start_probabilities + + def unravel_annotation(annsamp, anntype, length): + """Unravel annotation + """ + begin = -1 + end = -1 + s = 'none' + states = {'N':0, 'st':1, 't':2, 'iso':3, 'p':4, 'pq':5} + annot = -1 * np.ones(length) + + for j, samp in enumerate(annsamp): + if anntype[j] == '(': + begin = samp + if (end > 0) & (s != 'none'): + if s == 'N': + annot[end:begin] = states['st'] + elif s == 't': + annot[end:begin] = states['iso'] + elif s == 'p': + annot[end:begin] = states['pq'] + elif anntype[j] == ')': + end = samp + if (begin > 0) & (s != 'none'): + annot[begin:end] = states[s] + else: + s = anntype[j] + + return annot + + lengths = [wavelet.shape[0] for wavelet in hmm_preprocessed.get_variable("wavelets")] + wavelets = np.concatenate(hmm_preprocessed.get_variable("wavelets")) + anntype = hmm_preprocessed.get_variable("anntypes") + annsamp = hmm_preprocessed.get_variable("annsamps") + + unravelled = np.concatenate([unravel_annotation(samp, types, length) for + samp, types, length in zip(annsamp, anntype, lengths)]) + means, covariances = prepare_means_covars(wavelets, unravelled, states=[3, 5, 11, 14, 17, 19], num_features=3) + transition_matrix, start_probabilities = prepare_transmat_startprob() + + config_train = { + 'build': True, + 'estimator': hmm.GaussianHMM(n_components=19, n_iter=25, covariance_type="full", random_state=42, + init_params='', verbose=False), + 'init_params': {'means_': means, 'covars_': covariances, 'transmat_': transition_matrix, + 'startprob_': start_probabilities} + } + + return (ds.Pipeline() + .init_model("dynamic", HMModel, "HMM", config=config_train) + .load(fmt='wfdb', components=["signal", "annotation", "meta"], ann_ext='pu1') + .wavelet_transform_signal(cwt_scales=[4, 8, 16], cwt_wavelet="mexh") + .train_model("HMM", make_data=prepare_batch) + .run(batch_size=batch_size, shuffle=False, drop_last=False, n_epochs=1, lazy=True)) + +def hmm_predict_pipeline(model_path, batch_size=20): + """Pipeline for prediction with hmm model. + + This pipeline isolates QRS, PQ and QT segments. + It works with dataset that generates bathes of class EcgBatch. + + Parameters + ---------- + model_path : str + Path to pretrained hmm model. + batch_size : int + Number of samples in batch. + Default value is 20. + + Returns + ------- + pipeline : Pipeline + Output pipeline. + """ + + def prepare_batch(batch, model): + """Prepare data for train + """ + _ = model + x = np.concatenate([ann["wavelets"] for ann in batch.annotation]) + lengths = [ann["wavelets"].shape[0] for ann in batch.annotation] + return {"X": x, "lengths": lengths} + + def get_batch(batch): + """Get batch list + """ + return [batch] + + config_predict = { + 'build': False, + 'load': {'path': model_path} + } + + return (ds.Pipeline() + .init_model("static", HMModel, "HMM", config=config_predict) + .init_variable("batch", init_on_each_run=list) + .load(fmt="wfdb", components=["signal", "meta"]) + .wavelet_transform_signal(cwt_scales=[4, 8, 16], cwt_wavelet="mexh") + .predict_model("HMM", make_data=prepare_batch, save_to=ds.B("_temp"), mode='w') + .write_to_annotation("hmm_annotation", "_temp") + .calc_ecg_parameters() + .update_variable("batch", ds.F(get_batch), mode='e') + .run(batch_size=batch_size, shuffle=False, drop_last=False, n_epochs=1, lazy=True)) diff --git a/cardio/tests/data/A00001.hea b/cardio/tests/data/A00001.hea new file mode 100644 index 0000000..b09908f --- /dev/null +++ b/cardio/tests/data/A00001.hea @@ -0,0 +1,2 @@ +A00001 1 300 9000 2014-05-08 05:05:15 +A00001.mat 16+24 1000/mV 16 0 -127 0 0 ECG diff --git a/cardio/tests/data/A00001.mat b/cardio/tests/data/A00001.mat new file mode 100644 index 0000000000000000000000000000000000000000..3fc05975fe574d932ec7b4518a73f168fd540ae8 GIT binary patch literal 18024 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 P<zc~kYjG>`QRMsoF4=ew literal 0 HcmV?d00001 diff --git a/cardio/tests/data/A00002.hea b/cardio/tests/data/A00002.hea new file mode 100644 index 0000000..6dccf3e --- /dev/null +++ b/cardio/tests/data/A00002.hea @@ -0,0 +1,2 @@ +A00002 1 300 9000 2014-05-16 11:05:25 +A00002.mat 16+24 1000/mV 16 0 128 0 0 ECG diff --git a/cardio/tests/data/A00002.mat b/cardio/tests/data/A00002.mat new file mode 100644 index 0000000000000000000000000000000000000000..864fab561c3f9a09258c7aea40d293cbbe4e3505 GIT binary patch literal 18024 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𝔘BI8XTganG%^&E4 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 literal 0 HcmV?d00001 diff --git a/cardio/tests/data/A00004.hea b/cardio/tests/data/A00004.hea new file mode 100644 index 0000000..66c7b6d --- /dev/null +++ b/cardio/tests/data/A00004.hea @@ -0,0 +1,2 @@ +A00004 1 300 9000 2014-05-01 11:05:48 +A00004.mat 16+24 1000/mV 16 0 519 0 0 ECG diff --git a/cardio/tests/data/A00004.mat b/cardio/tests/data/A00004.mat new file mode 100644 index 0000000000000000000000000000000000000000..75d082d5316ebdc58bd895d51709c5124308d42f GIT binary patch literal 18024 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 literal 0 HcmV?d00001 diff --git a/cardio/tests/data/A00005.hea b/cardio/tests/data/A00005.hea new file mode 100644 index 0000000..c7fd2af --- /dev/null +++ b/cardio/tests/data/A00005.hea @@ -0,0 +1,2 @@ +A00005 1 300 18000 2013-12-23 08:12:08 +A00005.mat 16+24 1000/mV 16 0 -188 0 0 ECG diff --git a/cardio/tests/data/A00005.mat b/cardio/tests/data/A00005.mat new file mode 100644 index 0000000000000000000000000000000000000000..220c4f18b17942147720497fc98493f2b1d2a2ed GIT binary patch literal 36024 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 S&mbq36~t&4;>hdS-~R{Hi`O0i literal 0 HcmV?d00001 diff --git a/cardio/tests/data/A00008.hea b/cardio/tests/data/A00008.hea new file mode 100644 index 0000000..3541991 --- /dev/null +++ b/cardio/tests/data/A00008.hea @@ -0,0 +1,2 @@ +A00008 1 300 18000 2013-11-24 06:11:36 +A00008.mat 16+24 1000/mV 16 0 -187 0 0 ECG diff --git a/cardio/tests/data/A00008.mat b/cardio/tests/data/A00008.mat new file mode 100644 index 0000000000000000000000000000000000000000..11edfa48a12f457239f170b1999c2dd157be7ddc GIT binary patch literal 36024 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 EKVyIVH~;_u literal 0 HcmV?d00001 diff --git a/cardio/tests/data/A00013.hea b/cardio/tests/data/A00013.hea new file mode 100644 index 0000000..6eba513 --- /dev/null +++ b/cardio/tests/data/A00013.hea @@ -0,0 +1,2 @@ +A00013 1 300 9000 2014-06-10 10:06:01 +A00013.mat 16+24 1000/mV 16 0 3 0 0 ECG diff --git a/cardio/tests/data/A00013.mat b/cardio/tests/data/A00013.mat new file mode 100644 index 0000000000000000000000000000000000000000..0553a0a2dcb2d4eade2d7c19153c648e03601d08 GIT binary patch literal 18024 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 literal 0 HcmV?d00001 diff --git a/cardio/tests/data/REFERENCE.csv b/cardio/tests/data/REFERENCE.csv new file mode 100644 index 0000000..003a111 --- /dev/null +++ b/cardio/tests/data/REFERENCE.csv @@ -0,0 +1,8528 @@ +A00001,N +A00002,N +A00003,N +A00004,A +A00005,A +A00006,N +A00007,N +A00008,O +A00009,A +A00010,N +A00011,N +A00012,N +A00013,O +A00014,N +A00015,A +A00016,N +A00017,O +A00018,N +A00019,N +A00020,O +A00021,N +A00022,~ +A00023,O +A00024,O +A00025,N +A00026,N +A00027,A +A00028,N +A00029,O +A00030,O +A00031,N +A00032,N +A00033,N +A00034,~ +A00035,N +A00036,N +A00037,N +A00038,O +A00039,N +A00040,N +A00041,O +A00042,N +A00043,O +A00044,N +A00045,N +A00046,N +A00047,O +A00048,N +A00049,N +A00050,N +A00051,N +A00052,N +A00053,N +A00054,A +A00055,O +A00056,~ +A00057,N +A00058,O +A00059,N +A00060,N +A00061,O +A00062,N +A00063,N +A00064,N +A00065,O +A00066,O +A00067,A +A00068,N +A00069,O +A00070,O +A00071,A +A00072,N +A00073,N +A00074,O +A00075,O +A00076,N +A00077,O +A00078,O +A00079,N +A00080,N +A00081,N +A00082,O +A00083,O +A00084,N +A00085,N +A00086,N +A00087,A +A00088,O +A00089,N +A00090,A +A00091,N +A00092,O +A00093,N +A00094,N +A00095,N +A00096,O +A00097,N +A00098,N +A00099,N +A00100,O +A00101,A +A00102,A +A00103,O +A00104,N +A00105,N +A00106,~ +A00107,A +A00108,O +A00109,N +A00110,O +A00111,N +A00112,N +A00113,N +A00114,O +A00115,O +A00116,N +A00117,N +A00118,N +A00119,O +A00120,O +A00121,O +A00122,N +A00123,O +A00124,N +A00125,~ +A00126,O +A00127,N +A00128,A +A00129,N +A00130,N +A00131,O +A00132,A +A00133,O +A00134,N +A00135,N +A00136,O +A00137,A +A00138,O +A00139,~ +A00140,N +A00141,A +A00142,N +A00143,N +A00144,N +A00145,O +A00146,N +A00147,N +A00148,N +A00149,N +A00150,N +A00151,N +A00152,N +A00153,N +A00154,N +A00155,A +A00156,A +A00157,N +A00158,O +A00159,O +A00160,N +A00161,O +A00162,O +A00163,N +A00164,~ +A00165,N +A00166,N +A00167,N +A00168,N +A00169,N +A00170,O +A00171,N +A00172,N +A00173,N +A00174,N +A00175,N +A00176,O +A00177,N +A00178,N +A00179,N +A00180,N +A00181,O +A00182,N +A00183,N +A00184,N +A00185,N +A00186,O +A00187,O +A00188,N +A00189,O +A00190,N +A00191,N +A00192,N +A00193,N +A00194,N +A00195,O +A00196,~ +A00197,N +A00198,O +A00199,N +A00200,N +A00201,~ +A00202,N +A00203,O +A00204,O +A00205,~ +A00206,N +A00207,N +A00208,A +A00209,O +A00210,N +A00211,O +A00212,O +A00213,O +A00214,N +A00215,O +A00216,A +A00217,A +A00218,O +A00219,N +A00220,O +A00221,N +A00222,N +A00223,N +A00224,N +A00225,A +A00226,N +A00227,N +A00228,N +A00229,N +A00230,N +A00231,A +A00232,N +A00233,N +A00234,N +A00235,N +A00236,N +A00237,N +A00238,N +A00239,N +A00240,N +A00241,N +A00242,N +A00243,O +A00244,N +A00245,N +A00246,O +A00247,A +A00248,N +A00249,N +A00250,N +A00251,O +A00252,O +A00253,A +A00254,N +A00255,O +A00256,N +A00257,N +A00258,N +A00259,O +A00260,O +A00261,N +A00262,N +A00263,N +A00264,A +A00265,N +A00266,N +A00267,A +A00268,O +A00269,N +A00270,O +A00271,A +A00272,N +A00273,N +A00274,N +A00275,N +A00276,N +A00277,N +A00278,O +A00279,N +A00280,N +A00281,N +A00282,O +A00283,N +A00284,N +A00285,O +A00286,O +A00287,N +A00288,O +A00289,N +A00290,N +A00291,O +A00292,N +A00293,O +A00294,N +A00295,N +A00296,O +A00297,N +A00298,O +A00299,N +A00300,O +A00301,A +A00302,N +A00303,N +A00304,N +A00305,N +A00306,N +A00307,~ +A00308,O +A00309,N +A00310,O +A00311,N +A00312,N +A00313,N +A00314,N +A00315,N +A00316,N +A00317,O +A00318,N +A00319,N +A00320,N +A00321,A +A00322,N +A00323,N +A00324,O +A00325,O +A00326,O +A00327,O +A00328,N +A00329,O +A00330,N +A00331,N +A00332,N +A00333,N +A00334,N +A00335,O +A00336,N +A00337,O +A00338,N +A00339,N +A00340,O +A00341,N +A00342,O +A00343,O +A00344,O +A00345,O +A00346,N +A00347,N +A00348,O +A00349,N +A00350,N +A00351,N +A00352,N +A00353,O +A00354,N +A00355,N +A00356,N +A00357,N +A00358,N +A00359,N +A00360,N +A00361,N +A00362,O +A00363,N +A00364,N +A00365,N +A00366,N +A00367,N +A00368,N +A00369,N +A00370,~ +A00371,N +A00372,N +A00373,O +A00374,N +A00375,A +A00376,N +A00377,N +A00378,N +A00379,O +A00380,N +A00381,N +A00382,N +A00383,N +A00384,O +A00385,O +A00386,N +A00387,N +A00388,N +A00389,O +A00390,N +A00391,N +A00392,N +A00393,N +A00394,O +A00395,A +A00396,O +A00397,A +A00398,N +A00399,O +A00400,O +A00401,N +A00402,O +A00403,N +A00404,A +A00405,A +A00406,O +A00407,N +A00408,N +A00409,N +A00410,N +A00411,N +A00412,O +A00413,O +A00414,N +A00415,N +A00416,N +A00417,N +A00418,N +A00419,N +A00420,N +A00421,N +A00422,A +A00423,N +A00424,N +A00425,N +A00426,N +A00427,O +A00428,O +A00429,N +A00430,O +A00431,O +A00432,A +A00433,N +A00434,O +A00435,N +A00436,N +A00437,N +A00438,A +A00439,A +A00440,N +A00441,A +A00442,N +A00443,O +A00444,O +A00445,~ +A00446,N +A00447,N +A00448,N +A00449,N +A00450,N +A00451,O +A00452,N +A00453,O +A00454,N +A00455,N +A00456,A +A00457,N +A00458,N +A00459,N +A00460,N +A00461,O +A00462,N +A00463,N +A00464,N +A00465,A +A00466,O +A00467,N +A00468,O +A00469,N +A00470,O +A00471,N +A00472,N +A00473,A +A00474,~ +A00475,N +A00476,N +A00477,O +A00478,N +A00479,N +A00480,N +A00481,N +A00482,O +A00483,N +A00484,O +A00485,O +A00486,A +A00487,N +A00488,N +A00489,N +A00490,N +A00491,N +A00492,N +A00493,A +A00494,N +A00495,N +A00496,N +A00497,O +A00498,O +A00499,N +A00500,N +A00501,N +A00502,O +A00503,O +A00504,N +A00505,N +A00506,N +A00507,N +A00508,N +A00509,A +A00510,N +A00511,O +A00512,N +A00513,N +A00514,N +A00515,N +A00516,N +A00517,N +A00518,N +A00519,A +A00520,A +A00521,O +A00522,O +A00523,O +A00524,~ +A00525,N +A00526,N +A00527,N +A00528,N +A00529,O +A00530,O +A00531,N +A00532,N +A00533,O +A00534,N +A00535,O +A00536,O +A00537,~ +A00538,N +A00539,O +A00540,N +A00541,N +A00542,A +A00543,N +A00544,O +A00545,O +A00546,N +A00547,N +A00548,N +A00549,O +A00550,N +A00551,A +A00552,N +A00553,N +A00554,O +A00555,N +A00556,O +A00557,O +A00558,N +A00559,O +A00560,N +A00561,O +A00562,O +A00563,N +A00564,N +A00565,O +A00566,N +A00567,A +A00568,N +A00569,N +A00570,O +A00571,N +A00572,O +A00573,N +A00574,N +A00575,N +A00576,N +A00577,O +A00578,N +A00579,N +A00580,N +A00581,N +A00582,N +A00583,N +A00584,O +A00585,~ +A00586,N +A00587,A +A00588,N +A00589,A +A00590,N +A00591,~ +A00592,A +A00593,O +A00594,N +A00595,N +A00596,N +A00597,N +A00598,N +A00599,N +A00600,N +A00601,N +A00602,N +A00603,O +A00604,N +A00605,O +A00606,N +A00607,N +A00608,O +A00609,N +A00610,N +A00611,A +A00612,O +A00613,A +A00614,A +A00615,N +A00616,N +A00617,N +A00618,N +A00619,~ +A00620,N +A00621,A +A00622,N +A00623,O +A00624,A +A00625,A +A00626,O +A00627,N +A00628,N +A00629,~ +A00630,N +A00631,N +A00632,N +A00633,N +A00634,O +A00635,N +A00636,N +A00637,N +A00638,O +A00639,N +A00640,O +A00641,N +A00642,N +A00643,A +A00644,N +A00645,N +A00646,O +A00647,N +A00648,A +A00649,O +A00650,O +A00651,N +A00652,N +A00653,O +A00654,N +A00655,N +A00656,O +A00657,O +A00658,N +A00659,O +A00660,~ +A00661,N +A00662,A +A00663,N +A00664,O +A00665,N +A00666,A +A00667,N +A00668,N +A00669,N +A00670,A +A00671,N +A00672,N +A00673,O +A00674,N +A00675,O +A00676,N +A00677,N +A00678,N +A00679,O +A00680,A +A00681,N +A00682,N +A00683,N +A00684,O +A00685,N +A00686,N +A00687,O +A00688,O +A00689,N +A00690,~ +A00691,A +A00692,N +A00693,O +A00694,N +A00695,N +A00696,O +A00697,O +A00698,O +A00699,O +A00700,~ +A00701,A +A00702,O +A00703,N +A00704,A +A00705,~ +A00706,A +A00707,A +A00708,N +A00709,O +A00710,N +A00711,N +A00712,O +A00713,N +A00714,N +A00715,N +A00716,O +A00717,N +A00718,O +A00719,O +A00720,N +A00721,N +A00722,A +A00723,O +A00724,O +A00725,A +A00726,N +A00727,N +A00728,N +A00729,N +A00730,N +A00731,N +A00732,O +A00733,A +A00734,O +A00735,N +A00736,N +A00737,O +A00738,N +A00739,A +A00740,O +A00741,O +A00742,O +A00743,N +A00744,O +A00745,O +A00746,O +A00747,N +A00748,N +A00749,N +A00750,N +A00751,N +A00752,N +A00753,N +A00754,O +A00755,N +A00756,N +A00757,N +A00758,N +A00759,O +A00760,N +A00761,~ +A00762,N +A00763,N +A00764,N +A00765,N +A00766,O +A00767,O +A00768,O +A00769,O +A00770,O +A00771,N +A00772,A +A00773,O +A00774,~ +A00775,N +A00776,O +A00777,N +A00778,N +A00779,N +A00780,N +A00781,N +A00782,O +A00783,N +A00784,N +A00785,O +A00786,O +A00787,O +A00788,O +A00789,O +A00790,N +A00791,N +A00792,N +A00793,O +A00794,N +A00795,A +A00796,N +A00797,N +A00798,A +A00799,N +A00800,N +A00801,N +A00802,N +A00803,N +A00804,N +A00805,N +A00806,N +A00807,O +A00808,N +A00809,N +A00810,N +A00811,O +A00812,N +A00813,~ +A00814,N +A00815,N +A00816,N +A00817,O +A00818,N +A00819,O +A00820,O +A00821,N +A00822,N +A00823,N +A00824,N +A00825,N +A00826,O +A00827,N +A00828,N +A00829,N +A00830,N +A00831,N +A00832,N +A00833,N +A00834,N +A00835,O +A00836,N +A00837,A +A00838,N +A00839,N +A00840,O +A00841,N +A00842,N +A00843,N +A00844,O +A00845,N +A00846,N +A00847,N +A00848,O +A00849,O +A00850,O +A00851,O +A00852,N +A00853,N +A00854,N +A00855,O +A00856,N +A00857,N +A00858,N +A00859,N +A00860,A +A00861,N +A00862,N +A00863,N +A00864,N +A00865,N +A00866,N +A00867,A +A00868,O +A00869,A +A00870,N +A00871,N +A00872,O +A00873,A +A00874,N +A00875,O +A00876,N +A00877,N +A00878,O +A00879,N +A00880,N +A00881,N +A00882,O +A00883,N +A00884,N +A00885,A +A00886,O +A00887,O +A00888,A +A00889,O +A00890,N +A00891,O +A00892,O +A00893,N +A00894,O +A00895,N +A00896,N +A00897,N +A00898,O +A00899,N +A00900,N +A00901,N +A00902,O +A00903,O +A00904,O +A00905,N +A00906,O +A00907,N +A00908,O +A00909,N +A00910,N +A00911,N +A00912,N +A00913,O +A00914,O +A00915,N +A00916,O +A00917,O +A00918,N +A00919,O +A00920,N +A00921,N +A00922,N +A00923,O +A00924,O +A00925,A +A00926,N +A00927,O +A00928,N +A00929,N +A00930,O +A00931,O +A00932,A +A00933,A +A00934,N +A00935,O +A00936,N +A00937,N +A00938,N +A00939,A +A00940,N +A00941,N +A00942,N +A00943,N +A00944,O +A00945,N +A00946,N +A00947,N +A00948,N +A00949,N +A00950,N +A00951,A +A00952,N +A00953,N +A00954,A +A00955,N +A00956,O +A00957,O +A00958,O +A00959,O +A00960,N +A00961,N +A00962,O +A00963,N +A00964,A +A00965,N +A00966,N +A00967,N +A00968,O +A00969,N +A00970,N +A00971,O +A00972,A +A00973,N +A00974,A +A00975,O +A00976,N +A00977,O +A00978,N +A00979,O +A00980,N +A00981,N +A00982,A +A00983,O +A00984,~ +A00985,N +A00986,N +A00987,N +A00988,~ +A00989,O +A00990,N +A00991,O +A00992,N +A00993,O +A00994,N +A00995,N +A00996,N +A00997,O +A00998,N +A00999,N +A01000,N +A01001,N +A01002,N +A01003,N +A01004,N +A01005,A +A01006,~ +A01007,N +A01008,N +A01009,N +A01010,N +A01011,N +A01012,N +A01013,A +A01014,N +A01015,N +A01016,N +A01017,N +A01018,N +A01019,A +A01020,N +A01021,N +A01022,N +A01023,N +A01024,A +A01025,O +A01026,N +A01027,O +A01028,N +A01029,A +A01030,O +A01031,O +A01032,N +A01033,N +A01034,N +A01035,N +A01036,O +A01037,O +A01038,N +A01039,N +A01040,O +A01041,A +A01042,A +A01043,N +A01044,N +A01045,A +A01046,N +A01047,N +A01048,~ +A01049,O +A01050,N +A01051,N +A01052,A +A01053,N +A01054,N +A01055,N +A01056,A +A01057,O +A01058,N +A01059,N +A01060,N +A01061,N +A01062,N +A01063,~ +A01064,N +A01065,O +A01066,N +A01067,N +A01068,O +A01069,N +A01070,~ +A01071,O +A01072,O +A01073,O +A01074,N +A01075,A +A01076,A +A01077,N +A01078,O +A01079,A +A01080,N +A01081,O +A01082,N +A01083,N +A01084,O +A01085,N +A01086,N +A01087,A +A01088,O +A01089,N +A01090,N +A01091,O +A01092,A +A01093,O +A01094,O +A01095,O +A01096,N +A01097,N +A01098,N +A01099,O +A01100,O +A01101,N +A01102,N +A01103,O +A01104,A +A01105,N +A01106,N +A01107,O +A01108,N +A01109,N +A01110,N +A01111,N +A01112,N +A01113,N +A01114,N +A01115,O +A01116,~ +A01117,N +A01118,N +A01119,N +A01120,N +A01121,N +A01122,N +A01123,N +A01124,O +A01125,N +A01126,N +A01127,N +A01128,N +A01129,A +A01130,O +A01131,O +A01132,N +A01133,O +A01134,O +A01135,N +A01136,O +A01137,N +A01138,N +A01139,N +A01140,N +A01141,N +A01142,N +A01143,N +A01144,N +A01145,O +A01146,N +A01147,N +A01148,N +A01149,N +A01150,N +A01151,N +A01152,O +A01153,A +A01154,O +A01155,N +A01156,O +A01157,N +A01158,O +A01159,N +A01160,~ +A01161,N +A01162,N +A01163,A +A01164,O +A01165,N +A01166,N +A01167,O +A01168,N +A01169,~ +A01170,N +A01171,A +A01172,N +A01173,O +A01174,N +A01175,O +A01176,N +A01177,O +A01178,O +A01179,N +A01180,O +A01181,N +A01182,O +A01183,O +A01184,N +A01185,N +A01186,O +A01187,O +A01188,O +A01189,N +A01190,N +A01191,O +A01192,A +A01193,O +A01194,N +A01195,N +A01196,N +A01197,N +A01198,A +A01199,N +A01200,N +A01201,O +A01202,N +A01203,O +A01204,N +A01205,N +A01206,N +A01207,N +A01208,N +A01209,O +A01210,A +A01211,N +A01212,N +A01213,O +A01214,N +A01215,N +A01216,O +A01217,A +A01218,O +A01219,O +A01220,O +A01221,N +A01222,N +A01223,N +A01224,O +A01225,N +A01226,O +A01227,N +A01228,N +A01229,N +A01230,A +A01231,N +A01232,N +A01233,N +A01234,N +A01235,O +A01236,O +A01237,O +A01238,N +A01239,N +A01240,A +A01241,O +A01242,N +A01243,N +A01244,A +A01245,O +A01246,~ +A01247,N +A01248,N +A01249,N +A01250,O +A01251,O +A01252,O +A01253,~ +A01254,N +A01255,N +A01256,O +A01257,N +A01258,A +A01259,A +A01260,N +A01261,N +A01262,N +A01263,O +A01264,N +A01265,N +A01266,N +A01267,A +A01268,A +A01269,N +A01270,~ +A01271,N +A01272,N +A01273,N +A01274,O +A01275,~ +A01276,N +A01277,N +A01278,N +A01279,O +A01280,O +A01281,O +A01282,N +A01283,N +A01284,N +A01285,N +A01286,O +A01287,N +A01288,O +A01289,N +A01290,A +A01291,O +A01292,O +A01293,N +A01294,O +A01295,O +A01296,N +A01297,N +A01298,O +A01299,~ +A01300,O +A01301,A +A01302,A +A01303,A +A01304,O +A01305,N +A01306,N +A01307,N +A01308,O +A01309,A +A01310,O +A01311,N +A01312,N +A01313,A +A01314,N +A01315,N +A01316,O +A01317,O +A01318,O +A01319,N +A01320,N +A01321,N +A01322,O +A01323,N +A01324,A +A01325,A +A01326,A +A01327,O +A01328,N +A01329,N +A01330,N +A01331,N +A01332,O +A01333,O +A01334,O +A01335,N +A01336,N +A01337,N +A01338,O +A01339,N +A01340,O +A01341,N +A01342,A +A01343,O +A01344,N +A01345,O +A01346,N +A01347,N +A01348,N +A01349,N +A01350,O +A01351,N +A01352,O +A01353,N +A01354,O +A01355,A +A01356,O +A01357,O +A01358,N +A01359,N +A01360,N +A01361,N +A01362,N +A01363,A +A01364,N +A01365,O +A01366,O +A01367,N +A01368,N +A01369,N +A01370,A +A01371,A +A01372,N +A01373,O +A01374,N +A01375,O +A01376,A +A01377,N +A01378,N +A01379,N +A01380,N +A01381,N +A01382,N +A01383,A +A01384,N +A01385,N +A01386,A +A01387,N +A01388,N +A01389,N +A01390,N +A01391,N +A01392,N +A01393,N +A01394,O +A01395,A +A01396,N +A01397,N +A01398,N +A01399,N +A01400,O +A01401,N +A01402,N +A01403,N +A01404,N +A01405,A +A01406,N +A01407,O +A01408,N +A01409,N +A01410,O +A01411,N +A01412,O +A01413,O +A01414,O +A01415,N +A01416,N +A01417,N +A01418,O +A01419,O +A01420,A +A01421,N +A01422,N +A01423,N +A01424,O +A01425,N +A01426,N +A01427,~ +A01428,N +A01429,~ +A01430,N +A01431,N +A01432,N +A01433,A +A01434,N +A01435,N +A01436,O +A01437,N +A01438,O +A01439,N +A01440,N +A01441,N +A01442,N +A01443,A +A01444,N +A01445,N +A01446,N +A01447,N +A01448,N +A01449,A +A01450,A +A01451,N +A01452,O +A01453,N +A01454,O +A01455,N +A01456,N +A01457,N +A01458,O +A01459,O +A01460,O +A01461,O +A01462,N +A01463,N +A01464,N +A01465,N +A01466,O +A01467,A +A01468,N +A01469,O +A01470,N +A01471,O +A01472,N +A01473,O +A01474,O +A01475,O +A01476,O +A01477,O +A01478,O +A01479,N +A01480,N +A01481,N +A01482,N +A01483,N +A01484,O +A01485,N +A01486,N +A01487,O +A01488,N +A01489,N +A01490,N +A01491,A +A01492,N +A01493,N +A01494,O +A01495,N +A01496,N +A01497,N +A01498,O +A01499,N +A01500,N +A01501,A +A01502,~ +A01503,N +A01504,N +A01505,O +A01506,N +A01507,N +A01508,N +A01509,N +A01510,O +A01511,A +A01512,N +A01513,N +A01514,N +A01515,O +A01516,O +A01517,O +A01518,O +A01519,A +A01520,N +A01521,~ +A01522,A +A01523,N +A01524,N +A01525,O +A01526,O +A01527,O +A01528,N +A01529,~ +A01530,O +A01531,O +A01532,O +A01533,N +A01534,N +A01535,N +A01536,O +A01537,N +A01538,N +A01539,N +A01540,O +A01541,N +A01542,N +A01543,O +A01544,O +A01545,N +A01546,O +A01547,N +A01548,N +A01549,N +A01550,A +A01551,N +A01552,O +A01553,N +A01554,N +A01555,N +A01556,N +A01557,N +A01558,N +A01559,N +A01560,N +A01561,O +A01562,A +A01563,O +A01564,O +A01565,O +A01566,N +A01567,~ +A01568,N +A01569,N +A01570,N +A01571,O +A01572,N +A01573,N +A01574,N +A01575,N +A01576,O +A01577,O +A01578,~ +A01579,N +A01580,N +A01581,O +A01582,N +A01583,O +A01584,A +A01585,~ +A01586,O +A01587,O +A01588,O +A01589,A +A01590,O +A01591,O +A01592,O +A01593,N +A01594,A +A01595,N +A01596,N +A01597,N +A01598,O +A01599,N +A01600,N +A01601,N +A01602,O +A01603,N +A01604,N +A01605,N +A01606,O +A01607,A +A01608,O +A01609,N +A01610,N +A01611,N +A01612,N +A01613,N +A01614,O +A01615,N +A01616,N +A01617,N +A01618,A +A01619,O +A01620,O +A01621,N +A01622,O +A01623,N +A01624,A +A01625,N +A01626,N +A01627,O +A01628,N +A01629,A +A01630,N +A01631,N +A01632,O +A01633,O +A01634,O +A01635,O +A01636,O +A01637,N +A01638,N +A01639,O +A01640,N +A01641,O +A01642,A +A01643,O +A01644,N +A01645,N +A01646,N +A01647,O +A01648,N +A01649,O +A01650,N +A01651,O +A01652,N +A01653,O +A01654,O +A01655,N +A01656,N +A01657,N +A01658,N +A01659,N +A01660,N +A01661,N +A01662,A +A01663,N +A01664,N +A01665,N +A01666,N +A01667,O +A01668,O +A01669,O +A01670,N +A01671,N +A01672,O +A01673,N +A01674,N +A01675,N +A01676,O +A01677,N +A01678,N +A01679,O +A01680,N +A01681,N +A01682,O +A01683,N +A01684,N +A01685,A +A01686,N +A01687,N +A01688,N +A01689,N +A01690,O +A01691,A +A01692,O +A01693,A +A01694,N +A01695,N +A01696,N +A01697,N +A01698,N +A01699,N +A01700,N +A01701,O +A01702,N +A01703,~ +A01704,N +A01705,N +A01706,~ +A01707,~ +A01708,N +A01709,O +A01710,N +A01711,A +A01712,N +A01713,N +A01714,N +A01715,A +A01716,O +A01717,N +A01718,A +A01719,N +A01720,O +A01721,N +A01722,O +A01723,O +A01724,N +A01725,N +A01726,O +A01727,~ +A01728,N +A01729,N +A01730,N +A01731,O +A01732,N +A01733,N +A01734,N +A01735,N +A01736,N +A01737,O +A01738,N +A01739,N +A01740,N +A01741,N +A01742,N +A01743,N +A01744,O +A01745,N +A01746,O +A01747,A +A01748,N +A01749,N +A01750,~ +A01751,N +A01752,N +A01753,A +A01754,N +A01755,~ +A01756,N +A01757,O +A01758,N +A01759,N +A01760,N +A01761,O +A01762,N +A01763,~ +A01764,O +A01765,A +A01766,N +A01767,N +A01768,N +A01769,N +A01770,N +A01771,N +A01772,~ +A01773,N +A01774,A +A01775,N +A01776,A +A01777,O +A01778,N +A01779,N +A01780,N +A01781,N +A01782,N +A01783,N +A01784,A +A01785,O +A01786,A +A01787,N +A01788,N +A01789,N +A01790,O +A01791,N +A01792,N +A01793,N +A01794,N +A01795,O +A01796,N +A01797,N +A01798,O +A01799,N +A01800,N +A01801,O +A01802,N +A01803,N +A01804,N +A01805,~ +A01806,N +A01807,N +A01808,N +A01809,O +A01810,N +A01811,A +A01812,N +A01813,O +A01814,O +A01815,N +A01816,N +A01817,N +A01818,N +A01819,N +A01820,O +A01821,N +A01822,O +A01823,N +A01824,O +A01825,O +A01826,O +A01827,N +A01828,A +A01829,O +A01830,N +A01831,A +A01832,N +A01833,~ +A01834,O +A01835,N +A01836,O +A01837,N +A01838,O +A01839,O +A01840,N +A01841,N +A01842,O +A01843,N +A01844,A +A01845,N +A01846,O +A01847,N +A01848,N +A01849,N +A01850,N +A01851,N +A01852,O +A01853,A +A01854,N +A01855,N +A01856,N +A01857,N +A01858,N +A01859,N +A01860,O +A01861,N +A01862,N +A01863,N +A01864,N +A01865,N +A01866,N +A01867,N +A01868,N +A01869,A +A01870,N +A01871,N +A01872,O +A01873,O +A01874,N +A01875,N +A01876,O +A01877,N +A01878,N +A01879,N +A01880,O +A01881,N +A01882,N +A01883,A +A01884,N +A01885,N +A01886,N +A01887,O +A01888,~ +A01889,N +A01890,O +A01891,O +A01892,A +A01893,O +A01894,N +A01895,N +A01896,N +A01897,O +A01898,N +A01899,N +A01900,N +A01901,N +A01902,O +A01903,O +A01904,N +A01905,N +A01906,N +A01907,O +A01908,N +A01909,O +A01910,N +A01911,N +A01912,N +A01913,O +A01914,N +A01915,N +A01916,O +A01917,~ +A01918,O +A01919,O +A01920,N +A01921,O +A01922,N +A01923,N +A01924,N +A01925,O +A01926,N +A01927,N +A01928,O +A01929,O +A01930,A +A01931,N +A01932,A +A01933,N +A01934,N +A01935,N +A01936,N +A01937,O +A01938,~ +A01939,N +A01940,N +A01941,A +A01942,N +A01943,N +A01944,O +A01945,N +A01946,O +A01947,N +A01948,N +A01949,N +A01950,N +A01951,A +A01952,N +A01953,N +A01954,O +A01955,O +A01956,N +A01957,N +A01958,N +A01959,N +A01960,N +A01961,O +A01962,O +A01963,N +A01964,N +A01965,~ +A01966,~ +A01967,N +A01968,N +A01969,N +A01970,O +A01971,N +A01972,N +A01973,N +A01974,O +A01975,N +A01976,N +A01977,N +A01978,N +A01979,N +A01980,N +A01981,A +A01982,N +A01983,O +A01984,N +A01985,N +A01986,A +A01987,N +A01988,N +A01989,N +A01990,N +A01991,A +A01992,N +A01993,N +A01994,N +A01995,N +A01996,N +A01997,O +A01998,N +A01999,O +A02000,N +A02001,N +A02002,O +A02003,O +A02004,O +A02005,O +A02006,N +A02007,O +A02008,N +A02009,N +A02010,N +A02011,O +A02012,O +A02013,N +A02014,~ +A02015,N +A02016,N +A02017,N +A02018,N +A02019,O +A02020,N +A02021,N +A02022,N +A02023,N +A02024,O +A02025,N +A02026,N +A02027,O +A02028,N +A02029,N +A02030,N +A02031,O +A02032,~ +A02033,N +A02034,N +A02035,O +A02036,O +A02037,N +A02038,N +A02039,N +A02040,N +A02041,N +A02042,A +A02043,N +A02044,O +A02045,N +A02046,N +A02047,A +A02048,N +A02049,O +A02050,N +A02051,A +A02052,N +A02053,O +A02054,N +A02055,~ +A02056,O +A02057,A +A02058,N +A02059,N +A02060,O +A02061,N +A02062,O +A02063,N +A02064,N +A02065,N +A02066,O +A02067,O +A02068,O +A02069,~ +A02070,A +A02071,N +A02072,A +A02073,N +A02074,N +A02075,N +A02076,N +A02077,O +A02078,N +A02079,N +A02080,N +A02081,A +A02082,N +A02083,N +A02084,O +A02085,N +A02086,N +A02087,N +A02088,N +A02089,N +A02090,O +A02091,O +A02092,O +A02093,N +A02094,N +A02095,N +A02096,N +A02097,N +A02098,O +A02099,N +A02100,N +A02101,O +A02102,A +A02103,O +A02104,A +A02105,O +A02106,N +A02107,O +A02108,N +A02109,N +A02110,A +A02111,O +A02112,O +A02113,~ +A02114,O +A02115,N +A02116,N +A02117,O +A02118,O +A02119,A +A02120,N +A02121,O +A02122,N +A02123,N +A02124,N +A02125,N +A02126,A +A02127,N +A02128,N +A02129,O +A02130,N +A02131,N +A02132,N +A02133,~ +A02134,N +A02135,N +A02136,N +A02137,N +A02138,N +A02139,N +A02140,N +A02141,N +A02142,N +A02143,N +A02144,N +A02145,N +A02146,N +A02147,N +A02148,N +A02149,N +A02150,A +A02151,N +A02152,O +A02153,O +A02154,N +A02155,N +A02156,N +A02157,O +A02158,O +A02159,A +A02160,N +A02161,N +A02162,N +A02163,O +A02164,O +A02165,A +A02166,N +A02167,N +A02168,~ +A02169,N +A02170,O +A02171,O +A02172,N +A02173,N +A02174,N +A02175,N +A02176,O +A02177,O +A02178,N +A02179,N +A02180,O +A02181,~ +A02182,N +A02183,O +A02184,N +A02185,N +A02186,N +A02187,O +A02188,N +A02189,N +A02190,A +A02191,N +A02192,O +A02193,O +A02194,O +A02195,N +A02196,~ +A02197,A +A02198,N +A02199,N +A02200,N +A02201,N +A02202,O +A02203,N +A02204,N +A02205,O +A02206,N +A02207,N +A02208,N +A02209,N +A02210,N +A02211,N +A02212,O +A02213,O +A02214,O +A02215,N +A02216,N +A02217,~ +A02218,A +A02219,N +A02220,N +A02221,N +A02222,O +A02223,O +A02224,A +A02225,N +A02226,O +A02227,N +A02228,O +A02229,N +A02230,N +A02231,N +A02232,O +A02233,O +A02234,N +A02235,O +A02236,N +A02237,N +A02238,N +A02239,N +A02240,N +A02241,N +A02242,O +A02243,N +A02244,N +A02245,O +A02246,N +A02247,O +A02248,A +A02249,N +A02250,N +A02251,N +A02252,~ +A02253,O +A02254,O +A02255,O +A02256,N +A02257,O +A02258,N +A02259,O +A02260,N +A02261,N +A02262,N +A02263,N +A02264,N +A02265,O +A02266,N +A02267,N +A02268,O +A02269,N +A02270,O +A02271,N +A02272,N +A02273,O +A02274,N +A02275,N +A02276,N +A02277,N +A02278,O +A02279,A +A02280,O +A02281,N +A02282,N +A02283,N +A02284,O +A02285,N +A02286,O +A02287,N +A02288,N +A02289,A +A02290,A +A02291,A +A02292,N +A02293,N +A02294,O +A02295,O +A02296,O +A02297,N +A02298,N +A02299,O +A02300,O +A02301,O +A02302,O +A02303,O +A02304,O +A02305,N +A02306,N +A02307,A +A02308,N +A02309,N +A02310,N +A02311,O +A02312,N +A02313,N +A02314,O +A02315,O +A02316,O +A02317,N +A02318,O +A02319,N +A02320,O +A02321,N +A02322,O +A02323,A +A02324,N +A02325,A +A02326,A +A02327,N +A02328,N +A02329,N +A02330,A +A02331,N +A02332,N +A02333,O +A02334,O +A02335,N +A02336,N +A02337,O +A02338,N +A02339,N +A02340,N +A02341,N +A02342,O +A02343,N +A02344,N +A02345,N +A02346,N +A02347,N +A02348,O +A02349,O +A02350,N +A02351,N +A02352,N +A02353,A +A02354,N +A02355,A +A02356,N +A02357,N +A02358,O +A02359,N +A02360,N +A02361,O +A02362,N +A02363,O +A02364,~ +A02365,N +A02366,N +A02367,N +A02368,N +A02369,O +A02370,O +A02371,N +A02372,~ +A02373,N +A02374,N +A02375,A +A02376,N +A02377,N +A02378,N +A02379,O +A02380,O +A02381,N +A02382,N +A02383,N +A02384,N +A02385,N +A02386,N +A02387,O +A02388,O +A02389,N +A02390,O +A02391,A +A02392,O +A02393,N +A02394,N +A02395,N +A02396,O +A02397,N +A02398,N +A02399,O +A02400,A +A02401,A +A02402,A +A02403,N +A02404,N +A02405,N +A02406,N +A02407,N +A02408,O +A02409,O +A02410,O +A02411,~ +A02412,N +A02413,N +A02414,N +A02415,N +A02416,N +A02417,N +A02418,O +A02419,~ +A02420,N +A02421,N +A02422,N +A02423,O +A02424,N +A02425,A +A02426,A +A02427,N +A02428,O +A02429,A +A02430,N +A02431,N +A02432,O +A02433,O +A02434,O +A02435,N +A02436,O +A02437,O +A02438,O +A02439,A +A02440,O +A02441,O +A02442,A +A02443,N +A02444,N +A02445,N +A02446,O +A02447,N +A02448,N +A02449,N +A02450,N +A02451,A +A02452,N +A02453,N +A02454,N +A02455,A +A02456,A +A02457,N +A02458,N +A02459,N +A02460,A +A02461,A +A02462,O +A02463,O +A02464,A +A02465,N +A02466,N +A02467,O +A02468,N +A02469,N +A02470,N +A02471,O +A02472,N +A02473,N +A02474,A +A02475,A +A02476,N +A02477,O +A02478,N +A02479,~ +A02480,N +A02481,N +A02482,N +A02483,A +A02484,N +A02485,N +A02486,N +A02487,N +A02488,O +A02489,N +A02490,O +A02491,N +A02492,N +A02493,A +A02494,N +A02495,N +A02496,N +A02497,N +A02498,O +A02499,A +A02500,N +A02501,A +A02502,A +A02503,N +A02504,N +A02505,O +A02506,A +A02507,N +A02508,N +A02509,A +A02510,N +A02511,N +A02512,N +A02513,N +A02514,~ +A02515,N +A02516,N +A02517,N +A02518,N +A02519,A +A02520,N +A02521,N +A02522,O +A02523,N +A02524,N +A02525,N +A02526,N +A02527,N +A02528,N +A02529,O +A02530,N +A02531,O +A02532,A +A02533,N +A02534,N +A02535,O +A02536,A +A02537,N +A02538,A +A02539,N +A02540,N +A02541,O +A02542,N +A02543,N +A02544,O +A02545,N +A02546,N +A02547,N +A02548,N +A02549,A +A02550,A +A02551,O +A02552,O +A02553,N +A02554,N +A02555,N +A02556,N +A02557,A +A02558,N +A02559,A +A02560,O +A02561,N +A02562,N +A02563,N +A02564,N +A02565,N +A02566,N +A02567,N +A02568,O +A02569,N +A02570,N +A02571,N +A02572,N +A02573,N +A02574,O +A02575,~ +A02576,O +A02577,O +A02578,N +A02579,N +A02580,N +A02581,N +A02582,N +A02583,N +A02584,O +A02585,N +A02586,N +A02587,A +A02588,N +A02589,N +A02590,N +A02591,N +A02592,N +A02593,N +A02594,A +A02595,N +A02596,N +A02597,N +A02598,N +A02599,N +A02600,N +A02601,O +A02602,O +A02603,N +A02604,N +A02605,N +A02606,N +A02607,~ +A02608,N +A02609,N +A02610,N +A02611,A +A02612,N +A02613,N +A02614,~ +A02615,O +A02616,N +A02617,O +A02618,N +A02619,N +A02620,N +A02621,N +A02622,N +A02623,N +A02624,N +A02625,N +A02626,N +A02627,N +A02628,N +A02629,O +A02630,O +A02631,O +A02632,O +A02633,N +A02634,O +A02635,N +A02636,O +A02637,N +A02638,N +A02639,N +A02640,N +A02641,N +A02642,N +A02643,O +A02644,A +A02645,N +A02646,N +A02647,N +A02648,N +A02649,A +A02650,O +A02651,N +A02652,N +A02653,N +A02654,O +A02655,N +A02656,N +A02657,N +A02658,O +A02659,N +A02660,N +A02661,N +A02662,N +A02663,N +A02664,N +A02665,N +A02666,N +A02667,N +A02668,O +A02669,N +A02670,N +A02671,N +A02672,N +A02673,N +A02674,N +A02675,O +A02676,O +A02677,A +A02678,N +A02679,O +A02680,O +A02681,N +A02682,N +A02683,O +A02684,N +A02685,O +A02686,A +A02687,O +A02688,O +A02689,N +A02690,O +A02691,N +A02692,N +A02693,~ +A02694,A +A02695,A +A02696,O +A02697,O +A02698,N +A02699,O +A02700,N +A02701,O +A02702,~ +A02703,N +A02704,O +A02705,O +A02706,~ +A02707,N +A02708,O +A02709,O +A02710,N +A02711,N +A02712,N +A02713,N +A02714,N +A02715,N +A02716,N +A02717,~ +A02718,N +A02719,O +A02720,N +A02721,N +A02722,A +A02723,N +A02724,O +A02725,O +A02726,N +A02727,A +A02728,N +A02729,O +A02730,~ +A02731,N +A02732,O +A02733,O +A02734,O +A02735,N +A02736,N +A02737,N +A02738,A +A02739,N +A02740,~ +A02741,O +A02742,N +A02743,N +A02744,N +A02745,N +A02746,N +A02747,O +A02748,O +A02749,N +A02750,~ +A02751,O +A02752,N +A02753,N +A02754,N +A02755,N +A02756,N +A02757,A +A02758,N +A02759,O +A02760,N +A02761,N +A02762,N +A02763,N +A02764,A +A02765,N +A02766,N +A02767,N +A02768,N +A02769,N +A02770,N +A02771,O +A02772,~ +A02773,N +A02774,N +A02775,O +A02776,A +A02777,N +A02778,N +A02779,N +A02780,O +A02781,N +A02782,A +A02783,N +A02784,A +A02785,~ +A02786,N +A02787,O +A02788,N +A02789,N +A02790,N +A02791,O +A02792,O +A02793,N +A02794,N +A02795,N +A02796,N +A02797,N +A02798,O +A02799,N +A02800,N +A02801,O +A02802,O +A02803,N +A02804,O +A02805,A +A02806,O +A02807,A +A02808,N +A02809,N +A02810,O +A02811,N +A02812,N +A02813,N +A02814,N +A02815,N +A02816,N +A02817,N +A02818,O +A02819,A +A02820,N +A02821,~ +A02822,N +A02823,N +A02824,N +A02825,N +A02826,O +A02827,O +A02828,O +A02829,~ +A02830,O +A02831,N +A02832,O +A02833,~ +A02834,O +A02835,O +A02836,N +A02837,N +A02838,N +A02839,N +A02840,O +A02841,O +A02842,N +A02843,N +A02844,O +A02845,A +A02846,N +A02847,N +A02848,N +A02849,N +A02850,N +A02851,N +A02852,O +A02853,A +A02854,O +A02855,N +A02856,A +A02857,N +A02858,N +A02859,O +A02860,N +A02861,N +A02862,O +A02863,N +A02864,N +A02865,N +A02866,O +A02867,O +A02868,O +A02869,N +A02870,O +A02871,N +A02872,A +A02873,N +A02874,~ +A02875,N +A02876,N +A02877,O +A02878,N +A02879,A +A02880,N +A02881,O +A02882,N +A02883,O +A02884,N +A02885,O +A02886,N +A02887,O +A02888,O +A02889,O +A02890,N +A02891,N +A02892,A +A02893,O +A02894,A +A02895,A +A02896,N +A02897,N +A02898,A +A02899,A +A02900,A +A02901,N +A02902,N +A02903,N +A02904,N +A02905,N +A02906,A +A02907,N +A02908,N +A02909,N +A02910,N +A02911,O +A02912,O +A02913,N +A02914,O +A02915,O +A02916,N +A02917,N +A02918,A +A02919,N +A02920,O +A02921,N +A02922,O +A02923,N +A02924,N +A02925,N +A02926,A +A02927,N +A02928,N +A02929,N +A02930,N +A02931,N +A02932,O +A02933,O +A02934,O +A02935,N +A02936,N +A02937,A +A02938,N +A02939,N +A02940,N +A02941,N +A02942,A +A02943,O +A02944,N +A02945,A +A02946,N +A02947,O +A02948,O +A02949,N +A02950,N +A02951,N +A02952,N +A02953,N +A02954,N +A02955,~ +A02956,N +A02957,N +A02958,N +A02959,N +A02960,O +A02961,~ +A02962,N +A02963,O +A02964,N +A02965,A +A02966,N +A02967,N +A02968,N +A02969,N +A02970,N +A02971,N +A02972,N +A02973,O +A02974,O +A02975,N +A02976,O +A02977,N +A02978,A +A02979,N +A02980,O +A02981,N +A02982,N +A02983,O +A02984,O +A02985,N +A02986,O +A02987,N +A02988,O +A02989,N +A02990,N +A02991,N +A02992,N +A02993,O +A02994,N +A02995,O +A02996,N +A02997,~ +A02998,N +A02999,O +A03000,N +A03001,O +A03002,N +A03003,N +A03004,A +A03005,O +A03006,O +A03007,N +A03008,N +A03009,N +A03010,O +A03011,N +A03012,A +A03013,A +A03014,O +A03015,O +A03016,O +A03017,O +A03018,N +A03019,N +A03020,N +A03021,O +A03022,N +A03023,N +A03024,N +A03025,N +A03026,N +A03027,N +A03028,N +A03029,N +A03030,N +A03031,A +A03032,N +A03033,N +A03034,A +A03035,N +A03036,N +A03037,N +A03038,N +A03039,~ +A03040,N +A03041,N +A03042,N +A03043,N +A03044,O +A03045,N +A03046,A +A03047,O +A03048,N +A03049,N +A03050,~ +A03051,N +A03052,N +A03053,N +A03054,N +A03055,A +A03056,N +A03057,N +A03058,N +A03059,N +A03060,N +A03061,N +A03062,N +A03063,A +A03064,O +A03065,N +A03066,N +A03067,N +A03068,N +A03069,N +A03070,N +A03071,O +A03072,O +A03073,N +A03074,N +A03075,N +A03076,O +A03077,N +A03078,A +A03079,O +A03080,A +A03081,A +A03082,O +A03083,O +A03084,N +A03085,N +A03086,N +A03087,O +A03088,N +A03089,O +A03090,O +A03091,N +A03092,N +A03093,N +A03094,N +A03095,O +A03096,N +A03097,N +A03098,N +A03099,N +A03100,N +A03101,A +A03102,N +A03103,O +A03104,N +A03105,N +A03106,N +A03107,N +A03108,N +A03109,N +A03110,O +A03111,O +A03112,O +A03113,O +A03114,N +A03115,N +A03116,O +A03117,~ +A03118,~ +A03119,N +A03120,N +A03121,N +A03122,N +A03123,N +A03124,N +A03125,N +A03126,A +A03127,O +A03128,A +A03129,N +A03130,N +A03131,N +A03132,N +A03133,N +A03134,N +A03135,N +A03136,N +A03137,O +A03138,N +A03139,N +A03140,N +A03141,N +A03142,O +A03143,N +A03144,N +A03145,N +A03146,N +A03147,N +A03148,O +A03149,~ +A03150,N +A03151,N +A03152,A +A03153,O +A03154,A +A03155,N +A03156,O +A03157,N +A03158,N +A03159,N +A03160,N +A03161,A +A03162,O +A03163,N +A03164,N +A03165,N +A03166,N +A03167,O +A03168,N +A03169,O +A03170,N +A03171,N +A03172,N +A03173,N +A03174,O +A03175,N +A03176,N +A03177,O +A03178,N +A03179,N +A03180,N +A03181,O +A03182,O +A03183,~ +A03184,N +A03185,A +A03186,N +A03187,A +A03188,N +A03189,N +A03190,N +A03191,N +A03192,O +A03193,N +A03194,N +A03195,O +A03196,N +A03197,N +A03198,O +A03199,~ +A03200,N +A03201,N +A03202,O +A03203,N +A03204,N +A03205,N +A03206,N +A03207,N +A03208,O +A03209,N +A03210,O +A03211,N +A03212,A +A03213,N +A03214,O +A03215,~ +A03216,O +A03217,N +A03218,N +A03219,N +A03220,O +A03221,A +A03222,N +A03223,A +A03224,N +A03225,O +A03226,N +A03227,N +A03228,O +A03229,O +A03230,A +A03231,N +A03232,N +A03233,O +A03234,N +A03235,N +A03236,N +A03237,N +A03238,N +A03239,~ +A03240,N +A03241,A +A03242,N +A03243,N +A03244,N +A03245,O +A03246,A +A03247,N +A03248,N +A03249,N +A03250,O +A03251,O +A03252,N +A03253,N +A03254,O +A03255,N +A03256,N +A03257,N +A03258,O +A03259,N +A03260,N +A03261,N +A03262,O +A03263,N +A03264,N +A03265,N +A03266,O +A03267,O +A03268,N +A03269,~ +A03270,N +A03271,O +A03272,N +A03273,A +A03274,N +A03275,O +A03276,O +A03277,N +A03278,O +A03279,N +A03280,N +A03281,N +A03282,N +A03283,O +A03284,N +A03285,N +A03286,O +A03287,O +A03288,N +A03289,N +A03290,O +A03291,O +A03292,N +A03293,O +A03294,O +A03295,A +A03296,N +A03297,N +A03298,N +A03299,N +A03300,O +A03301,N +A03302,N +A03303,N +A03304,N +A03305,N +A03306,A +A03307,N +A03308,O +A03309,O +A03310,A +A03311,O +A03312,N +A03313,N +A03314,N +A03315,N +A03316,O +A03317,N +A03318,O +A03319,A +A03320,N +A03321,N +A03322,N +A03323,N +A03324,O +A03325,N +A03326,N +A03327,N +A03328,N +A03329,O +A03330,O +A03331,N +A03332,O +A03333,O +A03334,N +A03335,O +A03336,N +A03337,N +A03338,N +A03339,O +A03340,N +A03341,O +A03342,A +A03343,N +A03344,N +A03345,N +A03346,A +A03347,N +A03348,N +A03349,N +A03350,N +A03351,N +A03352,~ +A03353,N +A03354,O +A03355,O +A03356,N +A03357,N +A03358,A +A03359,N +A03360,N +A03361,N +A03362,N +A03363,~ +A03364,N +A03365,O +A03366,N +A03367,N +A03368,O +A03369,N +A03370,O +A03371,O +A03372,N +A03373,O +A03374,A +A03375,N +A03376,N +A03377,N +A03378,N +A03379,N +A03380,N +A03381,N +A03382,A +A03383,N +A03384,N +A03385,N +A03386,N +A03387,N +A03388,N +A03389,A +A03390,N +A03391,A +A03392,O +A03393,O +A03394,N +A03395,N +A03396,N +A03397,N +A03398,N +A03399,O +A03400,N +A03401,N +A03402,N +A03403,O +A03404,N +A03405,N +A03406,O +A03407,N +A03408,~ +A03409,N +A03410,O +A03411,N +A03412,N +A03413,N +A03414,N +A03415,N +A03416,O +A03417,O +A03418,O +A03419,N +A03420,N +A03421,O +A03422,O +A03423,N +A03424,O +A03425,N +A03426,N +A03427,O +A03428,N +A03429,N +A03430,N +A03431,N +A03432,N +A03433,N +A03434,N +A03435,N +A03436,O +A03437,A +A03438,N +A03439,O +A03440,N +A03441,N +A03442,N +A03443,~ +A03444,N +A03445,N +A03446,A +A03447,O +A03448,N +A03449,N +A03450,N +A03451,N +A03452,N +A03453,N +A03454,N +A03455,N +A03456,N +A03457,N +A03458,N +A03459,N +A03460,A +A03461,O +A03462,N +A03463,O +A03464,O +A03465,N +A03466,N +A03467,A +A03468,A +A03469,A +A03470,N +A03471,N +A03472,N +A03473,N +A03474,O +A03475,O +A03476,N +A03477,N +A03478,N +A03479,N +A03480,N +A03481,O +A03482,N +A03483,N +A03484,N +A03485,N +A03486,O +A03487,N +A03488,N +A03489,~ +A03490,O +A03491,N +A03492,N +A03493,O +A03494,N +A03495,N +A03496,O +A03497,A +A03498,A +A03499,A +A03500,O +A03501,A +A03502,A +A03503,A +A03504,N +A03505,N +A03506,O +A03507,N +A03508,A +A03509,N +A03510,N +A03511,N +A03512,N +A03513,O +A03514,O +A03515,N +A03516,O +A03517,O +A03518,N +A03519,O +A03520,N +A03521,O +A03522,N +A03523,N +A03524,N +A03525,O +A03526,N +A03527,A +A03528,O +A03529,N +A03530,N +A03531,N +A03532,O +A03533,N +A03534,N +A03535,N +A03536,N +A03537,O +A03538,O +A03539,O +A03540,O +A03541,~ +A03542,N +A03543,N +A03544,N +A03545,N +A03546,O +A03547,N +A03548,A +A03549,~ +A03550,N +A03551,O +A03552,O +A03553,N +A03554,N +A03555,N +A03556,O +A03557,N +A03558,N +A03559,N +A03560,N +A03561,N +A03562,N +A03563,N +A03564,N +A03565,~ +A03566,N +A03567,A +A03568,N +A03569,A +A03570,N +A03571,O +A03572,N +A03573,N +A03574,N +A03575,O +A03576,A +A03577,O +A03578,O +A03579,O +A03580,~ +A03581,N +A03582,O +A03583,O +A03584,A +A03585,N +A03586,N +A03587,N +A03588,N +A03589,N +A03590,N +A03591,O +A03592,A +A03593,N +A03594,N +A03595,N +A03596,~ +A03597,O +A03598,O +A03599,N +A03600,N +A03601,O +A03602,N +A03603,N +A03604,N +A03605,A +A03606,A +A03607,N +A03608,N +A03609,O +A03610,A +A03611,N +A03612,O +A03613,N +A03614,O +A03615,O +A03616,O +A03617,N +A03618,N +A03619,O +A03620,O +A03621,O +A03622,N +A03623,N +A03624,O +A03625,N +A03626,N +A03627,N +A03628,A +A03629,A +A03630,O +A03631,N +A03632,N +A03633,O +A03634,A +A03635,A +A03636,N +A03637,N +A03638,N +A03639,N +A03640,O +A03641,N +A03642,N +A03643,O +A03644,N +A03645,N +A03646,O +A03647,N +A03648,N +A03649,N +A03650,N +A03651,N +A03652,N +A03653,O +A03654,N +A03655,N +A03656,N +A03657,A +A03658,N +A03659,O +A03660,A +A03661,O +A03662,N +A03663,N +A03664,O +A03665,O +A03666,N +A03667,O +A03668,N +A03669,O +A03670,A +A03671,A +A03672,N +A03673,N +A03674,N +A03675,N +A03676,N +A03677,O +A03678,N +A03679,N +A03680,N +A03681,N +A03682,N +A03683,O +A03684,N +A03685,~ +A03686,N +A03687,O +A03688,N +A03689,N +A03690,N +A03691,A +A03692,O +A03693,N +A03694,N +A03695,N +A03696,O +A03697,N +A03698,N +A03699,N +A03700,N +A03701,O +A03702,N +A03703,N +A03704,N +A03705,O +A03706,N +A03707,A +A03708,O +A03709,N +A03710,N +A03711,N +A03712,N +A03713,N +A03714,O +A03715,N +A03716,N +A03717,O +A03718,N +A03719,~ +A03720,N +A03721,O +A03722,N +A03723,O +A03724,O +A03725,O +A03726,N +A03727,O +A03728,N +A03729,N +A03730,O +A03731,N +A03732,O +A03733,N +A03734,N +A03735,N +A03736,O +A03737,N +A03738,~ +A03739,~ +A03740,O +A03741,N +A03742,O +A03743,N +A03744,N +A03745,~ +A03746,A +A03747,N +A03748,N +A03749,N +A03750,N +A03751,N +A03752,O +A03753,N +A03754,N +A03755,N +A03756,O +A03757,O +A03758,O +A03759,N +A03760,A +A03761,N +A03762,N +A03763,O +A03764,N +A03765,N +A03766,O +A03767,N +A03768,N +A03769,N +A03770,N +A03771,O +A03772,N +A03773,O +A03774,N +A03775,O +A03776,N +A03777,N +A03778,O +A03779,N +A03780,O +A03781,O +A03782,A +A03783,N +A03784,N +A03785,N +A03786,N +A03787,N +A03788,N +A03789,O +A03790,N +A03791,N +A03792,A +A03793,O +A03794,O +A03795,N +A03796,N +A03797,O +A03798,O +A03799,N +A03800,N +A03801,N +A03802,O +A03803,N +A03804,N +A03805,O +A03806,N +A03807,O +A03808,O +A03809,N +A03810,O +A03811,N +A03812,O +A03813,N +A03814,~ +A03815,N +A03816,O +A03817,O +A03818,N +A03819,N +A03820,O +A03821,N +A03822,O +A03823,N +A03824,N +A03825,N +A03826,O +A03827,A +A03828,O +A03829,~ +A03830,O +A03831,O +A03832,N +A03833,O +A03834,A +A03835,N +A03836,A +A03837,O +A03838,A +A03839,N +A03840,N +A03841,A +A03842,O +A03843,N +A03844,A +A03845,N +A03846,O +A03847,O +A03848,~ +A03849,O +A03850,N +A03851,O +A03852,A +A03853,N +A03854,N +A03855,N +A03856,N +A03857,A +A03858,N +A03859,N +A03860,N +A03861,O +A03862,O +A03863,A +A03864,N +A03865,N +A03866,N +A03867,N +A03868,N +A03869,O +A03870,O +A03871,N +A03872,O +A03873,N +A03874,N +A03875,N +A03876,N +A03877,N +A03878,N +A03879,O +A03880,O +A03881,N +A03882,N +A03883,N +A03884,N +A03885,N +A03886,N +A03887,N +A03888,N +A03889,N +A03890,O +A03891,N +A03892,N +A03893,N +A03894,N +A03895,N +A03896,N +A03897,N +A03898,O +A03899,N +A03900,N +A03901,N +A03902,N +A03903,N +A03904,O +A03905,A +A03906,N +A03907,N +A03908,N +A03909,N +A03910,A +A03911,N +A03912,N +A03913,O +A03914,O +A03915,N +A03916,N +A03917,N +A03918,N +A03919,O +A03920,O +A03921,N +A03922,N +A03923,N +A03924,O +A03925,N +A03926,N +A03927,N +A03928,N +A03929,N +A03930,N +A03931,O +A03932,N +A03933,N +A03934,~ +A03935,O +A03936,O +A03937,O +A03938,O +A03939,A +A03940,N +A03941,N +A03942,N +A03943,N +A03944,O +A03945,N +A03946,~ +A03947,O +A03948,N +A03949,N +A03950,N +A03951,N +A03952,N +A03953,N +A03954,A +A03955,N +A03956,N +A03957,N +A03958,N +A03959,O +A03960,A +A03961,N +A03962,N +A03963,N +A03964,N +A03965,O +A03966,N +A03967,N +A03968,N +A03969,O +A03970,O +A03971,N +A03972,N +A03973,N +A03974,N +A03975,N +A03976,O +A03977,O +A03978,N +A03979,A +A03980,O +A03981,N +A03982,N +A03983,A +A03984,N +A03985,N +A03986,O +A03987,N +A03988,N +A03989,N +A03990,N +A03991,N +A03992,N +A03993,N +A03994,O +A03995,N +A03996,O +A03997,N +A03998,N +A03999,O +A04000,N +A04001,O +A04002,O +A04003,O +A04004,N +A04005,O +A04006,N +A04007,N +A04008,N +A04009,N +A04010,N +A04011,N +A04012,N +A04013,O +A04014,O +A04015,N +A04016,A +A04017,N +A04018,O +A04019,A +A04020,~ +A04021,O +A04022,N +A04023,N +A04024,N +A04025,A +A04026,N +A04027,N +A04028,N +A04029,O +A04030,A +A04031,O +A04032,N +A04033,N +A04034,N +A04035,N +A04036,N +A04037,N +A04038,O +A04039,O +A04040,N +A04041,N +A04042,N +A04043,N +A04044,N +A04045,N +A04046,N +A04047,O +A04048,A +A04049,O +A04050,N +A04051,N +A04052,O +A04053,N +A04054,N +A04055,O +A04056,N +A04057,O +A04058,N +A04059,N +A04060,N +A04061,N +A04062,O +A04063,O +A04064,N +A04065,N +A04066,N +A04067,N +A04068,N +A04069,A +A04070,N +A04071,N +A04072,N +A04073,N +A04074,O +A04075,N +A04076,N +A04077,N +A04078,O +A04079,N +A04080,N +A04081,O +A04082,O +A04083,N +A04084,N +A04085,O +A04086,~ +A04087,N +A04088,N +A04089,N +A04090,N +A04091,N +A04092,O +A04093,N +A04094,N +A04095,N +A04096,O +A04097,N +A04098,O +A04099,N +A04100,N +A04101,N +A04102,N +A04103,O +A04104,O +A04105,N +A04106,N +A04107,N +A04108,O +A04109,O +A04110,O +A04111,N +A04112,N +A04113,O +A04114,N +A04115,N +A04116,N +A04117,A +A04118,N +A04119,N +A04120,N +A04121,N +A04122,A +A04123,A +A04124,N +A04125,N +A04126,N +A04127,N +A04128,A +A04129,O +A04130,O +A04131,N +A04132,N +A04133,~ +A04134,N +A04135,O +A04136,A +A04137,~ +A04138,N +A04139,N +A04140,N +A04141,N +A04142,N +A04143,N +A04144,N +A04145,N +A04146,N +A04147,N +A04148,N +A04149,O +A04150,O +A04151,N +A04152,O +A04153,N +A04154,N +A04155,N +A04156,N +A04157,N +A04158,N +A04159,O +A04160,N +A04161,N +A04162,N +A04163,N +A04164,O +A04165,N +A04166,N +A04167,O +A04168,O +A04169,N +A04170,~ +A04171,N +A04172,N +A04173,O +A04174,O +A04175,O +A04176,O +A04177,O +A04178,N +A04179,N +A04180,N +A04181,N +A04182,N +A04183,N +A04184,O +A04185,O +A04186,~ +A04187,N +A04188,N +A04189,N +A04190,N +A04191,N +A04192,N +A04193,N +A04194,N +A04195,O +A04196,O +A04197,N +A04198,O +A04199,N +A04200,O +A04201,A +A04202,N +A04203,N +A04204,N +A04205,N +A04206,N +A04207,A +A04208,N +A04209,O +A04210,N +A04211,N +A04212,N +A04213,N +A04214,O +A04215,O +A04216,~ +A04217,N +A04218,A +A04219,N +A04220,A +A04221,N +A04222,O +A04223,N +A04224,N +A04225,N +A04226,N +A04227,O +A04228,O +A04229,N +A04230,A +A04231,~ +A04232,O +A04233,N +A04234,N +A04235,N +A04236,N +A04237,N +A04238,O +A04239,N +A04240,O +A04241,O +A04242,O +A04243,N +A04244,~ +A04245,N +A04246,N +A04247,N +A04248,N +A04249,O +A04250,O +A04251,~ +A04252,O +A04253,N +A04254,O +A04255,N +A04256,N +A04257,~ +A04258,O +A04259,O +A04260,N +A04261,A +A04262,N +A04263,N +A04264,O +A04265,N +A04266,O +A04267,N +A04268,O +A04269,N +A04270,N +A04271,O +A04272,A +A04273,N +A04274,O +A04275,N +A04276,N +A04277,N +A04278,N +A04279,O +A04280,N +A04281,N +A04282,~ +A04283,N +A04284,O +A04285,N +A04286,O +A04287,N +A04288,O +A04289,N +A04290,O +A04291,N +A04292,N +A04293,O +A04294,N +A04295,N +A04296,O +A04297,N +A04298,N +A04299,A +A04300,N +A04301,N +A04302,N +A04303,~ +A04304,N +A04305,N +A04306,N +A04307,N +A04308,O +A04309,O +A04310,O +A04311,N +A04312,N +A04313,N +A04314,N +A04315,O +A04316,O +A04317,N +A04318,O +A04319,N +A04320,O +A04321,N +A04322,O +A04323,N +A04324,O +A04325,~ +A04326,N +A04327,N +A04328,N +A04329,~ +A04330,N +A04331,O +A04332,N +A04333,N +A04334,N +A04335,O +A04336,N +A04337,N +A04338,N +A04339,N +A04340,N +A04341,N +A04342,N +A04343,N +A04344,N +A04345,O +A04346,O +A04347,N +A04348,N +A04349,A +A04350,A +A04351,N +A04352,N +A04353,N +A04354,N +A04355,N +A04356,O +A04357,O +A04358,N +A04359,N +A04360,O +A04361,O +A04362,O +A04363,O +A04364,N +A04365,O +A04366,~ +A04367,N +A04368,N +A04369,O +A04370,O +A04371,N +A04372,O +A04373,N +A04374,O +A04375,N +A04376,N +A04377,N +A04378,N +A04379,N +A04380,N +A04381,N +A04382,N +A04383,A +A04384,O +A04385,N +A04386,O +A04387,O +A04388,N +A04389,N +A04390,N +A04391,N +A04392,N +A04393,N +A04394,N +A04395,N +A04396,N +A04397,N +A04398,A +A04399,N +A04400,O +A04401,N +A04402,N +A04403,N +A04404,N +A04405,N +A04406,N +A04407,O +A04408,N +A04409,N +A04410,N +A04411,N +A04412,N +A04413,N +A04414,O +A04415,O +A04416,N +A04417,O +A04418,O +A04419,N +A04420,N +A04421,O +A04422,N +A04423,N +A04424,~ +A04425,N +A04426,N +A04427,O +A04428,O +A04429,O +A04430,N +A04431,A +A04432,N +A04433,O +A04434,N +A04435,O +A04436,N +A04437,N +A04438,N +A04439,N +A04440,O +A04441,O +A04442,N +A04443,O +A04444,N +A04445,N +A04446,N +A04447,N +A04448,N +A04449,N +A04450,N +A04451,O +A04452,~ +A04453,N +A04454,A +A04455,N +A04456,N +A04457,N +A04458,O +A04459,N +A04460,O +A04461,N +A04462,N +A04463,O +A04464,N +A04465,N +A04466,O +A04467,N +A04468,N +A04469,O +A04470,O +A04471,O +A04472,N +A04473,A +A04474,N +A04475,N +A04476,O +A04477,N +A04478,N +A04479,N +A04480,N +A04481,N +A04482,N +A04483,N +A04484,N +A04485,N +A04486,N +A04487,N +A04488,N +A04489,N +A04490,N +A04491,O +A04492,N +A04493,A +A04494,O +A04495,O +A04496,O +A04497,N +A04498,N +A04499,N +A04500,N +A04501,O +A04502,N +A04503,~ +A04504,N +A04505,N +A04506,N +A04507,N +A04508,A +A04509,O +A04510,N +A04511,N +A04512,O +A04513,~ +A04514,O +A04515,N +A04516,A +A04517,N +A04518,N +A04519,O +A04520,O +A04521,O +A04522,~ +A04523,N +A04524,O +A04525,N +A04526,N +A04527,O +A04528,N +A04529,O +A04530,N +A04531,O +A04532,N +A04533,O +A04534,N +A04535,N +A04536,N +A04537,N +A04538,N +A04539,O +A04540,N +A04541,O +A04542,N +A04543,N +A04544,O +A04545,O +A04546,N +A04547,N +A04548,N +A04549,N +A04550,O +A04551,N +A04552,N +A04553,N +A04554,N +A04555,~ +A04556,N +A04557,O +A04558,N +A04559,N +A04560,A +A04561,N +A04562,O +A04563,N +A04564,N +A04565,N +A04566,O +A04567,N +A04568,O +A04569,O +A04570,N +A04571,O +A04572,N +A04573,A +A04574,O +A04575,O +A04576,O +A04577,N +A04578,N +A04579,N +A04580,N +A04581,O +A04582,N +A04583,N +A04584,O +A04585,N +A04586,O +A04587,A +A04588,O +A04589,N +A04590,N +A04591,A +A04592,O +A04593,N +A04594,A +A04595,N +A04596,A +A04597,O +A04598,N +A04599,N +A04600,O +A04601,N +A04602,N +A04603,N +A04604,A +A04605,O +A04606,N +A04607,O +A04608,N +A04609,N +A04610,N +A04611,N +A04612,A +A04613,N +A04614,N +A04615,N +A04616,N +A04617,N +A04618,N +A04619,N +A04620,N +A04621,O +A04622,N +A04623,O +A04624,N +A04625,N +A04626,N +A04627,N +A04628,N +A04629,N +A04630,O +A04631,N +A04632,N +A04633,N +A04634,N +A04635,O +A04636,N +A04637,N +A04638,A +A04639,N +A04640,N +A04641,O +A04642,N +A04643,O +A04644,~ +A04645,N +A04646,N +A04647,N +A04648,N +A04649,N +A04650,N +A04651,N +A04652,O +A04653,O +A04654,N +A04655,N +A04656,N +A04657,N +A04658,A +A04659,N +A04660,N +A04661,O +A04662,N +A04663,O +A04664,N +A04665,O +A04666,N +A04667,O +A04668,N +A04669,N +A04670,N +A04671,N +A04672,N +A04673,~ +A04674,O +A04675,~ +A04676,~ +A04677,N +A04678,O +A04679,O +A04680,N +A04681,N +A04682,O +A04683,N +A04684,N +A04685,~ +A04686,N +A04687,N +A04688,N +A04689,N +A04690,N +A04691,N +A04692,N +A04693,O +A04694,N +A04695,N +A04696,N +A04697,A +A04698,N +A04699,N +A04700,N +A04701,~ +A04702,O +A04703,N +A04704,A +A04705,N +A04706,N +A04707,~ +A04708,N +A04709,N +A04710,O +A04711,N +A04712,A +A04713,N +A04714,N +A04715,O +A04716,N +A04717,N +A04718,N +A04719,O +A04720,O +A04721,N +A04722,O +A04723,O +A04724,N +A04725,N +A04726,N +A04727,N +A04728,N +A04729,O +A04730,N +A04731,N +A04732,O +A04733,N +A04734,O +A04735,~ +A04736,O +A04737,O +A04738,O +A04739,N +A04740,N +A04741,O +A04742,O +A04743,N +A04744,N +A04745,O +A04746,N +A04747,N +A04748,N +A04749,N +A04750,O +A04751,N +A04752,N +A04753,O +A04754,N +A04755,N +A04756,~ +A04757,N +A04758,N +A04759,N +A04760,N +A04761,O +A04762,A +A04763,O +A04764,N +A04765,N +A04766,N +A04767,N +A04768,N +A04769,O +A04770,N +A04771,A +A04772,N +A04773,N +A04774,N +A04775,N +A04776,N +A04777,N +A04778,N +A04779,N +A04780,O +A04781,N +A04782,N +A04783,O +A04784,N +A04785,N +A04786,N +A04787,N +A04788,N +A04789,N +A04790,N +A04791,N +A04792,N +A04793,N +A04794,N +A04795,N +A04796,O +A04797,O +A04798,N +A04799,N +A04800,N +A04801,N +A04802,N +A04803,O +A04804,N +A04805,~ +A04806,N +A04807,N +A04808,N +A04809,O +A04810,N +A04811,N +A04812,~ +A04813,N +A04814,N +A04815,A +A04816,A +A04817,N +A04818,N +A04819,~ +A04820,O +A04821,N +A04822,O +A04823,N +A04824,N +A04825,O +A04826,N +A04827,N +A04828,O +A04829,O +A04830,O +A04831,N +A04832,O +A04833,N +A04834,N +A04835,O +A04836,O +A04837,N +A04838,O +A04839,N +A04840,O +A04841,N +A04842,N +A04843,N +A04844,O +A04845,N +A04846,O +A04847,N +A04848,N +A04849,N +A04850,N +A04851,N +A04852,O +A04853,~ +A04854,N +A04855,N +A04856,N +A04857,N +A04858,O +A04859,N +A04860,N +A04861,A +A04862,O +A04863,A +A04864,N +A04865,O +A04866,N +A04867,O +A04868,N +A04869,O +A04870,N +A04871,N +A04872,O +A04873,~ +A04874,O +A04875,O +A04876,N +A04877,O +A04878,N +A04879,N +A04880,N +A04881,N +A04882,N +A04883,N +A04884,N +A04885,N +A04886,N +A04887,N +A04888,O +A04889,O +A04890,~ +A04891,A +A04892,O +A04893,O +A04894,N +A04895,O +A04896,N +A04897,A +A04898,N +A04899,~ +A04900,N +A04901,A +A04902,N +A04903,N +A04904,O +A04905,A +A04906,N +A04907,N +A04908,N +A04909,O +A04910,N +A04911,N +A04912,O +A04913,~ +A04914,O +A04915,O +A04916,~ +A04917,N +A04918,~ +A04919,N +A04920,N +A04921,N +A04922,N +A04923,N +A04924,A +A04925,N +A04926,N +A04927,O +A04928,N +A04929,N +A04930,N +A04931,O +A04932,N +A04933,O +A04934,N +A04935,N +A04936,A +A04937,N +A04938,N +A04939,O +A04940,N +A04941,~ +A04942,A +A04943,A +A04944,O +A04945,N +A04946,~ +A04947,N +A04948,~ +A04949,N +A04950,N +A04951,O +A04952,A +A04953,N +A04954,N +A04955,O +A04956,N +A04957,N +A04958,N +A04959,N +A04960,O +A04961,N +A04962,O +A04963,N +A04964,N +A04965,N +A04966,~ +A04967,N +A04968,N +A04969,N +A04970,O +A04971,O +A04972,N +A04973,O +A04974,N +A04975,N +A04976,O +A04977,O +A04978,N +A04979,N +A04980,O +A04981,O +A04982,O +A04983,N +A04984,N +A04985,N +A04986,O +A04987,N +A04988,N +A04989,O +A04990,N +A04991,N +A04992,N +A04993,N +A04994,N +A04995,N +A04996,N +A04997,N +A04998,O +A04999,O +A05000,N +A05001,N +A05002,N +A05003,N +A05004,O +A05005,A +A05006,N +A05007,N +A05008,N +A05009,N +A05010,O +A05011,N +A05012,O +A05013,N +A05014,A +A05015,O +A05016,O +A05017,O +A05018,~ +A05019,O +A05020,O +A05021,N +A05022,N +A05023,N +A05024,N +A05025,N +A05026,O +A05027,O +A05028,N +A05029,O +A05030,O +A05031,N +A05032,O +A05033,N +A05034,N +A05035,N +A05036,N +A05037,O +A05038,N +A05039,O +A05040,N +A05041,N +A05042,N +A05043,A +A05044,O +A05045,O +A05046,O +A05047,O +A05048,N +A05049,A +A05050,O +A05051,N +A05052,N +A05053,~ +A05054,O +A05055,N +A05056,~ +A05057,N +A05058,N +A05059,A +A05060,O +A05061,N +A05062,N +A05063,~ +A05064,O +A05065,N +A05066,O +A05067,O +A05068,O +A05069,N +A05070,O +A05071,N +A05072,O +A05073,N +A05074,N +A05075,N +A05076,~ +A05077,N +A05078,N +A05079,O +A05080,N +A05081,A +A05082,N +A05083,N +A05084,N +A05085,N +A05086,O +A05087,N +A05088,N +A05089,~ +A05090,O +A05091,N +A05092,N +A05093,O +A05094,N +A05095,N +A05096,O +A05097,N +A05098,O +A05099,O +A05100,~ +A05101,N +A05102,N +A05103,O +A05104,N +A05105,N +A05106,N +A05107,N +A05108,O +A05109,N +A05110,N +A05111,N +A05112,N +A05113,O +A05114,N +A05115,N +A05116,A +A05117,N +A05118,N +A05119,A +A05120,N +A05121,N +A05122,N +A05123,O +A05124,N +A05125,O +A05126,N +A05127,N +A05128,N +A05129,O +A05130,N +A05131,N +A05132,O +A05133,N +A05134,~ +A05135,O +A05136,N +A05137,N +A05138,A +A05139,O +A05140,A +A05141,N +A05142,N +A05143,N +A05144,O +A05145,N +A05146,N +A05147,O +A05148,N +A05149,A +A05150,O +A05151,N +A05152,N +A05153,O +A05154,N +A05155,N +A05156,N +A05157,N +A05158,N +A05159,N +A05160,O +A05161,N +A05162,N +A05163,~ +A05164,N +A05165,N +A05166,O +A05167,O +A05168,N +A05169,N +A05170,O +A05171,O +A05172,A +A05173,N +A05174,N +A05175,O +A05176,O +A05177,N +A05178,O +A05179,N +A05180,O +A05181,O +A05182,N +A05183,N +A05184,N +A05185,N +A05186,O +A05187,N +A05188,N +A05189,~ +A05190,A +A05191,N +A05192,N +A05193,N +A05194,N +A05195,N +A05196,N +A05197,O +A05198,N +A05199,N +A05200,A +A05201,O +A05202,N +A05203,N +A05204,N +A05205,N +A05206,O +A05207,O +A05208,O +A05209,N +A05210,N +A05211,O +A05212,N +A05213,O +A05214,O +A05215,N +A05216,O +A05217,O +A05218,N +A05219,N +A05220,O +A05221,N +A05222,N +A05223,N +A05224,O +A05225,N +A05226,N +A05227,N +A05228,A +A05229,N +A05230,A +A05231,N +A05232,O +A05233,~ +A05234,O +A05235,N +A05236,N +A05237,A +A05238,A +A05239,A +A05240,N +A05241,O +A05242,O +A05243,O +A05244,O +A05245,N +A05246,N +A05247,O +A05248,N +A05249,N +A05250,N +A05251,N +A05252,O +A05253,N +A05254,A +A05255,N +A05256,O +A05257,N +A05258,O +A05259,N +A05260,N +A05261,N +A05262,N +A05263,N +A05264,N +A05265,A +A05266,O +A05267,N +A05268,A +A05269,O +A05270,A +A05271,N +A05272,N +A05273,N +A05274,O +A05275,N +A05276,O +A05277,O +A05278,N +A05279,N +A05280,O +A05281,A +A05282,O +A05283,A +A05284,N +A05285,O +A05286,N +A05287,N +A05288,N +A05289,A +A05290,N +A05291,N +A05292,N +A05293,A +A05294,N +A05295,N +A05296,N +A05297,O +A05298,N +A05299,N +A05300,O +A05301,O +A05302,O +A05303,N +A05304,N +A05305,O +A05306,O +A05307,N +A05308,O +A05309,O +A05310,O +A05311,O +A05312,O +A05313,N +A05314,N +A05315,N +A05316,O +A05317,N +A05318,N +A05319,O +A05320,N +A05321,N +A05322,N +A05323,N +A05324,N +A05325,O +A05326,N +A05327,O +A05328,N +A05329,O +A05330,N +A05331,O +A05332,O +A05333,N +A05334,N +A05335,N +A05336,O +A05337,N +A05338,N +A05339,N +A05340,O +A05341,~ +A05342,N +A05343,O +A05344,N +A05345,N +A05346,N +A05347,N +A05348,N +A05349,N +A05350,O +A05351,O +A05352,O +A05353,N +A05354,N +A05355,~ +A05356,O +A05357,N +A05358,N +A05359,O +A05360,O +A05361,N +A05362,O +A05363,N +A05364,O +A05365,~ +A05366,A +A05367,O +A05368,N +A05369,N +A05370,N +A05371,N +A05372,N +A05373,O +A05374,N +A05375,N +A05376,O +A05377,N +A05378,N +A05379,O +A05380,N +A05381,O +A05382,N +A05383,O +A05384,N +A05385,N +A05386,N +A05387,N +A05388,N +A05389,N +A05390,O +A05391,N +A05392,A +A05393,O +A05394,N +A05395,N +A05396,N +A05397,N +A05398,O +A05399,N +A05400,O +A05401,O +A05402,N +A05403,N +A05404,N +A05405,N +A05406,N +A05407,N +A05408,~ +A05409,N +A05410,A +A05411,N +A05412,N +A05413,N +A05414,N +A05415,O +A05416,N +A05417,N +A05418,N +A05419,O +A05420,O +A05421,N +A05422,N +A05423,N +A05424,N +A05425,O +A05426,N +A05427,N +A05428,O +A05429,N +A05430,N +A05431,A +A05432,N +A05433,A +A05434,O +A05435,O +A05436,O +A05437,O +A05438,N +A05439,N +A05440,N +A05441,N +A05442,O +A05443,O +A05444,O +A05445,N +A05446,N +A05447,N +A05448,O +A05449,N +A05450,N +A05451,N +A05452,N +A05453,O +A05454,O +A05455,N +A05456,N +A05457,N +A05458,A +A05459,A +A05460,N +A05461,N +A05462,O +A05463,N +A05464,O +A05465,A +A05466,N +A05467,N +A05468,N +A05469,N +A05470,A +A05471,O +A05472,N +A05473,N +A05474,N +A05475,N +A05476,A +A05477,N +A05478,N +A05479,N +A05480,N +A05481,O +A05482,N +A05483,O +A05484,O +A05485,O +A05486,A +A05487,N +A05488,N +A05489,O +A05490,N +A05491,N +A05492,O +A05493,N +A05494,O +A05495,A +A05496,N +A05497,N +A05498,N +A05499,N +A05500,A +A05501,N +A05502,O +A05503,~ +A05504,N +A05505,N +A05506,N +A05507,~ +A05508,N +A05509,O +A05510,N +A05511,A +A05512,N +A05513,N +A05514,O +A05515,A +A05516,N +A05517,O +A05518,N +A05519,N +A05520,O +A05521,N +A05522,O +A05523,O +A05524,A +A05525,N +A05526,N +A05527,O +A05528,O +A05529,N +A05530,N +A05531,N +A05532,N +A05533,N +A05534,N +A05535,N +A05536,N +A05537,N +A05538,N +A05539,O +A05540,O +A05541,N +A05542,O +A05543,N +A05544,N +A05545,N +A05546,O +A05547,A +A05548,N +A05549,O +A05550,N +A05551,O +A05552,N +A05553,N +A05554,N +A05555,N +A05556,O +A05557,O +A05558,O +A05559,N +A05560,N +A05561,N +A05562,N +A05563,N +A05564,A +A05565,N +A05566,N +A05567,N +A05568,O +A05569,N +A05570,A +A05571,~ +A05572,A +A05573,N +A05574,N +A05575,N +A05576,N +A05577,N +A05578,O +A05579,N +A05580,N +A05581,N +A05582,N +A05583,N +A05584,N +A05585,O +A05586,O +A05587,O +A05588,N +A05589,O +A05590,O +A05591,O +A05592,~ +A05593,O +A05594,O +A05595,O +A05596,N +A05597,O +A05598,O +A05599,O +A05600,O +A05601,N +A05602,N +A05603,O +A05604,N +A05605,N +A05606,N +A05607,N +A05608,O +A05609,O +A05610,N +A05611,N +A05612,N +A05613,N +A05614,O +A05615,N +A05616,O +A05617,N +A05618,O +A05619,O +A05620,O +A05621,N +A05622,N +A05623,N +A05624,O +A05625,N +A05626,O +A05627,O +A05628,O +A05629,N +A05630,O +A05631,O +A05632,O +A05633,N +A05634,N +A05635,N +A05636,N +A05637,O +A05638,O +A05639,O +A05640,O +A05641,N +A05642,N +A05643,O +A05644,O +A05645,N +A05646,N +A05647,N +A05648,O +A05649,N +A05650,N +A05651,N +A05652,N +A05653,O +A05654,O +A05655,O +A05656,N +A05657,N +A05658,N +A05659,O +A05660,N +A05661,N +A05662,N +A05663,A +A05664,N +A05665,O +A05666,N +A05667,O +A05668,O +A05669,N +A05670,A +A05671,N +A05672,N +A05673,N +A05674,O +A05675,N +A05676,N +A05677,N +A05678,N +A05679,O +A05680,O +A05681,N +A05682,N +A05683,O +A05684,O +A05685,O +A05686,O +A05687,N +A05688,N +A05689,O +A05690,N +A05691,N +A05692,N +A05693,O +A05694,O +A05695,O +A05696,O +A05697,N +A05698,N +A05699,N +A05700,N +A05701,N +A05702,N +A05703,A +A05704,N +A05705,N +A05706,N +A05707,O +A05708,O +A05709,N +A05710,N +A05711,N +A05712,O +A05713,N +A05714,O +A05715,O +A05716,N +A05717,N +A05718,N +A05719,N +A05720,O +A05721,N +A05722,N +A05723,N +A05724,N +A05725,N +A05726,A +A05727,N +A05728,N +A05729,O +A05730,O +A05731,N +A05732,O +A05733,N +A05734,O +A05735,O +A05736,N +A05737,N +A05738,N +A05739,N +A05740,N +A05741,O +A05742,N +A05743,N +A05744,N +A05745,N +A05746,O +A05747,N +A05748,N +A05749,O +A05750,O +A05751,N +A05752,N +A05753,N +A05754,N +A05755,N +A05756,N +A05757,N +A05758,O +A05759,N +A05760,O +A05761,N +A05762,N +A05763,N +A05764,O +A05765,O +A05766,~ +A05767,O +A05768,O +A05769,N +A05770,N +A05771,O +A05772,N +A05773,N +A05774,O +A05775,O +A05776,O +A05777,N +A05778,O +A05779,N +A05780,N +A05781,N +A05782,O +A05783,O +A05784,N +A05785,N +A05786,N +A05787,O +A05788,O +A05789,O +A05790,N +A05791,N +A05792,N +A05793,N +A05794,N +A05795,N +A05796,O +A05797,N +A05798,O +A05799,N +A05800,N +A05801,O +A05802,N +A05803,N +A05804,O +A05805,N +A05806,N +A05807,O +A05808,N +A05809,N +A05810,N +A05811,N +A05812,N +A05813,N +A05814,N +A05815,N +A05816,N +A05817,O +A05818,O +A05819,O +A05820,N +A05821,N +A05822,~ +A05823,O +A05824,N +A05825,O +A05826,N +A05827,N +A05828,N +A05829,O +A05830,N +A05831,O +A05832,O +A05833,N +A05834,N +A05835,N +A05836,N +A05837,N +A05838,O +A05839,N +A05840,O +A05841,O +A05842,O +A05843,N +A05844,N +A05845,O +A05846,O +A05847,N +A05848,O +A05849,N +A05850,O +A05851,N +A05852,N +A05853,N +A05854,N +A05855,N +A05856,N +A05857,O +A05858,N +A05859,N +A05860,N +A05861,N +A05862,N +A05863,N +A05864,O +A05865,N +A05866,N +A05867,O +A05868,N +A05869,O +A05870,O +A05871,O +A05872,N +A05873,N +A05874,O +A05875,N +A05876,N +A05877,N +A05878,N +A05879,N +A05880,N +A05881,O +A05882,O +A05883,N +A05884,O +A05885,N +A05886,O +A05887,N +A05888,N +A05889,O +A05890,N +A05891,N +A05892,N +A05893,N +A05894,N +A05895,O +A05896,O +A05897,N +A05898,N +A05899,N +A05900,O +A05901,O +A05902,O +A05903,N +A05904,N +A05905,N +A05906,N +A05907,O +A05908,N +A05909,O +A05910,N +A05911,O +A05912,N +A05913,O +A05914,N +A05915,N +A05916,O +A05917,O +A05918,N +A05919,N +A05920,N +A05921,O +A05922,O +A05923,O +A05924,O +A05925,O +A05926,N +A05927,O +A05928,N +A05929,N +A05930,N +A05931,A +A05932,N +A05933,N +A05934,N +A05935,A +A05936,N +A05937,N +A05938,N +A05939,N +A05940,N +A05941,N +A05942,O +A05943,O +A05944,N +A05945,N +A05946,O +A05947,N +A05948,N +A05949,N +A05950,O +A05951,N +A05952,N +A05953,O +A05954,O +A05955,A +A05956,O +A05957,N +A05958,N +A05959,N +A05960,~ +A05961,O +A05962,O +A05963,N +A05964,N +A05965,O +A05966,O +A05967,O +A05968,N +A05969,O +A05970,O +A05971,O +A05972,O +A05973,O +A05974,O +A05975,N +A05976,N +A05977,N +A05978,O +A05979,N +A05980,O +A05981,O +A05982,N +A05983,O +A05984,O +A05985,N +A05986,O +A05987,A +A05988,N +A05989,O +A05990,N +A05991,N +A05992,~ +A05993,N +A05994,O +A05995,N +A05996,O +A05997,O +A05998,N +A05999,N +A06000,O +A06001,N +A06002,O +A06003,O +A06004,O +A06005,O +A06006,N +A06007,N +A06008,O +A06009,N +A06010,O +A06011,N +A06012,O +A06013,O +A06014,N +A06015,O +A06016,N +A06017,N +A06018,N +A06019,N +A06020,O +A06021,O +A06022,N +A06023,O +A06024,N +A06025,N +A06026,N +A06027,N +A06028,N +A06029,O +A06030,O +A06031,N +A06032,N +A06033,O +A06034,N +A06035,N +A06036,N +A06037,N +A06038,N +A06039,N +A06040,O +A06041,N +A06042,O +A06043,O +A06044,N +A06045,N +A06046,N +A06047,N +A06048,~ +A06049,N +A06050,O +A06051,N +A06052,N +A06053,N +A06054,O +A06055,O +A06056,N +A06057,A +A06058,N +A06059,N +A06060,O +A06061,N +A06062,N +A06063,N +A06064,O +A06065,N +A06066,N +A06067,O +A06068,N +A06069,O +A06070,N +A06071,O +A06072,O +A06073,O +A06074,N +A06075,N +A06076,N +A06077,N +A06078,O +A06079,N +A06080,N +A06081,N +A06082,N +A06083,N +A06084,O +A06085,N +A06086,O +A06087,N +A06088,N +A06089,O +A06090,O +A06091,N +A06092,O +A06093,N +A06094,N +A06095,O +A06096,N +A06097,N +A06098,N +A06099,N +A06100,A +A06101,O +A06102,N +A06103,~ +A06104,N +A06105,O +A06106,N +A06107,N +A06108,O +A06109,N +A06110,O +A06111,N +A06112,O +A06113,N +A06114,N +A06115,N +A06116,O +A06117,N +A06118,N +A06119,O +A06120,N +A06121,O +A06122,N +A06123,O +A06124,N +A06125,N +A06126,O +A06127,N +A06128,N +A06129,N +A06130,N +A06131,N +A06132,O +A06133,N +A06134,O +A06135,O +A06136,N +A06137,N +A06138,N +A06139,N +A06140,O +A06141,O +A06142,N +A06143,N +A06144,N +A06145,N +A06146,O +A06147,N +A06148,N +A06149,N +A06150,N +A06151,N +A06152,N +A06153,N +A06154,O +A06155,O +A06156,O +A06157,~ +A06158,O +A06159,N +A06160,O +A06161,N +A06162,N +A06163,N +A06164,N +A06165,N +A06166,N +A06167,N +A06168,N +A06169,O +A06170,O +A06171,N +A06172,N +A06173,N +A06174,N +A06175,N +A06176,O +A06177,N +A06178,N +A06179,N +A06180,~ +A06181,N +A06182,O +A06183,N +A06184,N +A06185,N +A06186,O +A06187,N +A06188,O +A06189,N +A06190,O +A06191,N +A06192,N +A06193,O +A06194,O +A06195,O +A06196,N +A06197,N +A06198,N +A06199,N +A06200,N +A06201,O +A06202,O +A06203,O +A06204,N +A06205,N +A06206,N +A06207,N +A06208,O +A06209,N +A06210,O +A06211,N +A06212,O +A06213,A +A06214,O +A06215,N +A06216,N +A06217,O +A06218,O +A06219,N +A06220,N +A06221,N +A06222,O +A06223,~ +A06224,O +A06225,N +A06226,O +A06227,N +A06228,N +A06229,N +A06230,O +A06231,O +A06232,N +A06233,N +A06234,N +A06235,N +A06236,O +A06237,O +A06238,O +A06239,O +A06240,O +A06241,~ +A06242,O +A06243,N +A06244,N +A06245,O +A06246,O +A06247,O +A06248,O +A06249,N +A06250,O +A06251,O +A06252,N +A06253,O +A06254,N +A06255,N +A06256,N +A06257,N +A06258,N +A06259,N +A06260,O +A06261,O +A06262,~ +A06263,N +A06264,N +A06265,N +A06266,O +A06267,N +A06268,O +A06269,O +A06270,N +A06271,O +A06272,O +A06273,O +A06274,O +A06275,N +A06276,N +A06277,N +A06278,O +A06279,N +A06280,O +A06281,O +A06282,O +A06283,N +A06284,N +A06285,O +A06286,O +A06287,O +A06288,O +A06289,O +A06290,O +A06291,N +A06292,O +A06293,N +A06294,N +A06295,N +A06296,N +A06297,O +A06298,O +A06299,O +A06300,O +A06301,O +A06302,N +A06303,O +A06304,O +A06305,N +A06306,O +A06307,O +A06308,N +A06309,N +A06310,N +A06311,N +A06312,O +A06313,N +A06314,N +A06315,N +A06316,N +A06317,O +A06318,O +A06319,N +A06320,N +A06321,O +A06322,O +A06323,O +A06324,N +A06325,O +A06326,N +A06327,N +A06328,N +A06329,O +A06330,N +A06331,O +A06332,O +A06333,N +A06334,N +A06335,O +A06336,N +A06337,N +A06338,O +A06339,O +A06340,O +A06341,N +A06342,N +A06343,O +A06344,O +A06345,N +A06346,O +A06347,O +A06348,N +A06349,N +A06350,N +A06351,N +A06352,N +A06353,O +A06354,N +A06355,N +A06356,O +A06357,O +A06358,O +A06359,N +A06360,N +A06361,N +A06362,N +A06363,N +A06364,N +A06365,N +A06366,N +A06367,O +A06368,O +A06369,O +A06370,A +A06371,N +A06372,N +A06373,O +A06374,O +A06375,N +A06376,N +A06377,O +A06378,N +A06379,N +A06380,N +A06381,N +A06382,N +A06383,N +A06384,N +A06385,N +A06386,O +A06387,O +A06388,O +A06389,A +A06390,N +A06391,O +A06392,N +A06393,N +A06394,N +A06395,N +A06396,O +A06397,A +A06398,N +A06399,N +A06400,A +A06401,O +A06402,N +A06403,O +A06404,A +A06405,N +A06406,A +A06407,N +A06408,N +A06409,N +A06410,N +A06411,N +A06412,N +A06413,O +A06414,N +A06415,O +A06416,O +A06417,O +A06418,N +A06419,N +A06420,N +A06421,O +A06422,O +A06423,A +A06424,N +A06425,N +A06426,N +A06427,N +A06428,O +A06429,N +A06430,O +A06431,A +A06432,O +A06433,N +A06434,O +A06435,~ +A06436,O +A06437,N +A06438,~ +A06439,N +A06440,O +A06441,N +A06442,N +A06443,N +A06444,O +A06445,N +A06446,N +A06447,N +A06448,N +A06449,N +A06450,N +A06451,O +A06452,O +A06453,N +A06454,O +A06455,O +A06456,O +A06457,N +A06458,N +A06459,N +A06460,O +A06461,N +A06462,N +A06463,N +A06464,N +A06465,N +A06466,N +A06467,N +A06468,N +A06469,N +A06470,N +A06471,N +A06472,O +A06473,N +A06474,N +A06475,N +A06476,N +A06477,O +A06478,N +A06479,O +A06480,N +A06481,A +A06482,N +A06483,O +A06484,N +A06485,O +A06486,N +A06487,N +A06488,N +A06489,O +A06490,N +A06491,N +A06492,N +A06493,A +A06494,N +A06495,N +A06496,O +A06497,N +A06498,N +A06499,N +A06500,N +A06501,~ +A06502,O +A06503,N +A06504,O +A06505,N +A06506,N +A06507,N +A06508,N +A06509,N +A06510,O +A06511,O +A06512,~ +A06513,O +A06514,O +A06515,O +A06516,O +A06517,O +A06518,N +A06519,~ +A06520,O +A06521,N +A06522,N +A06523,N +A06524,O +A06525,N +A06526,A +A06527,O +A06528,N +A06529,N +A06530,N +A06531,A +A06532,O +A06533,O +A06534,~ +A06535,N +A06536,A +A06537,O +A06538,N +A06539,N +A06540,N +A06541,O +A06542,N +A06543,N +A06544,N +A06545,A +A06546,O +A06547,N +A06548,O +A06549,O +A06550,N +A06551,A +A06552,N +A06553,N +A06554,O +A06555,N +A06556,O +A06557,N +A06558,O +A06559,O +A06560,N +A06561,N +A06562,O +A06563,N +A06564,N +A06565,N +A06566,N +A06567,N +A06568,N +A06569,N +A06570,N +A06571,O +A06572,N +A06573,~ +A06574,N +A06575,N +A06576,A +A06577,N +A06578,O +A06579,N +A06580,N +A06581,N +A06582,N +A06583,N +A06584,O +A06585,N +A06586,N +A06587,O +A06588,~ +A06589,N +A06590,A +A06591,N +A06592,N +A06593,N +A06594,N +A06595,~ +A06596,O +A06597,N +A06598,N +A06599,N +A06600,N +A06601,N +A06602,N +A06603,N +A06604,N +A06605,A +A06606,N +A06607,N +A06608,O +A06609,O +A06610,A +A06611,O +A06612,N +A06613,O +A06614,O +A06615,N +A06616,N +A06617,N +A06618,N +A06619,N +A06620,O +A06621,N +A06622,~ +A06623,A +A06624,N +A06625,O +A06626,O +A06627,A +A06628,N +A06629,O +A06630,O +A06631,A +A06632,N +A06633,O +A06634,N +A06635,N +A06636,N +A06637,A +A06638,O +A06639,O +A06640,N +A06641,N +A06642,O +A06643,N +A06644,N +A06645,N +A06646,N +A06647,O +A06648,O +A06649,A +A06650,A +A06651,N +A06652,N +A06653,N +A06654,N +A06655,O +A06656,N +A06657,N +A06658,O +A06659,N +A06660,O +A06661,O +A06662,N +A06663,A +A06664,O +A06665,N +A06666,A +A06667,N +A06668,N +A06669,N +A06670,N +A06671,A +A06672,N +A06673,N +A06674,N +A06675,N +A06676,A +A06677,A +A06678,N +A06679,N +A06680,O +A06681,N +A06682,N +A06683,O +A06684,N +A06685,O +A06686,N +A06687,A +A06688,O +A06689,N +A06690,A +A06691,N +A06692,O +A06693,O +A06694,O +A06695,A +A06696,N +A06697,N +A06698,N +A06699,A +A06700,A +A06701,N +A06702,N +A06703,N +A06704,O +A06705,O +A06706,N +A06707,N +A06708,N +A06709,N +A06710,N +A06711,N +A06712,N +A06713,A +A06714,N +A06715,O +A06716,N +A06717,O +A06718,N +A06719,N +A06720,N +A06721,A +A06722,N +A06723,N +A06724,O +A06725,A +A06726,A +A06727,O +A06728,O +A06729,N +A06730,N +A06731,N +A06732,N +A06733,N +A06734,A +A06735,O +A06736,A +A06737,O +A06738,~ +A06739,N +A06740,N +A06741,O +A06742,O +A06743,A +A06744,N +A06745,N +A06746,N +A06747,O +A06748,O +A06749,N +A06750,N +A06751,N +A06752,N +A06753,N +A06754,O +A06755,A +A06756,O +A06757,O +A06758,N +A06759,O +A06760,O +A06761,A +A06762,O +A06763,N +A06764,O +A06765,N +A06766,A +A06767,O +A06768,N +A06769,~ +A06770,N +A06771,N +A06772,O +A06773,O +A06774,A +A06775,N +A06776,~ +A06777,N +A06778,N +A06779,A +A06780,N +A06781,~ +A06782,A +A06783,N +A06784,N +A06785,N +A06786,A +A06787,N +A06788,N +A06789,O +A06790,N +A06791,N +A06792,N +A06793,O +A06794,O +A06795,O +A06796,N +A06797,N +A06798,N +A06799,O +A06800,N +A06801,O +A06802,N +A06803,N +A06804,A +A06805,N +A06806,N +A06807,O +A06808,O +A06809,N +A06810,N +A06811,O +A06812,N +A06813,N +A06814,N +A06815,N +A06816,O +A06817,N +A06818,A +A06819,O +A06820,A +A06821,N +A06822,N +A06823,O +A06824,O +A06825,N +A06826,O +A06827,N +A06828,N +A06829,N +A06830,~ +A06831,O +A06832,N +A06833,N +A06834,O +A06835,N +A06836,A +A06837,O +A06838,N +A06839,N +A06840,N +A06841,~ +A06842,N +A06843,N +A06844,N +A06845,O +A06846,N +A06847,O +A06848,N +A06849,N +A06850,O +A06851,O +A06852,N +A06853,N +A06854,N +A06855,O +A06856,N +A06857,N +A06858,N +A06859,N +A06860,A +A06861,A +A06862,~ +A06863,N +A06864,N +A06865,N +A06866,O +A06867,N +A06868,A +A06869,A +A06870,N +A06871,N +A06872,N +A06873,N +A06874,~ +A06875,N +A06876,N +A06877,O +A06878,N +A06879,N +A06880,N +A06881,O +A06882,O +A06883,N +A06884,N +A06885,A +A06886,N +A06887,O +A06888,O +A06889,N +A06890,O +A06891,N +A06892,O +A06893,N +A06894,A +A06895,N +A06896,N +A06897,~ +A06898,A +A06899,O +A06900,A +A06901,O +A06902,N +A06903,N +A06904,O +A06905,A +A06906,N +A06907,O +A06908,N +A06909,N +A06910,N +A06911,A +A06912,A +A06913,N +A06914,O +A06915,N +A06916,O +A06917,A +A06918,~ +A06919,O +A06920,O +A06921,O +A06922,N +A06923,A +A06924,N +A06925,A +A06926,N +A06927,N +A06928,N +A06929,N +A06930,N +A06931,N +A06932,A +A06933,N +A06934,N +A06935,~ +A06936,N +A06937,N +A06938,A +A06939,N +A06940,N +A06941,N +A06942,N +A06943,N +A06944,N +A06945,N +A06946,N +A06947,N +A06948,O +A06949,N +A06950,N +A06951,N +A06952,N +A06953,O +A06954,N +A06955,A +A06956,N +A06957,N +A06958,N +A06959,N +A06960,N +A06961,N +A06962,A +A06963,O +A06964,O +A06965,N +A06966,O +A06967,O +A06968,O +A06969,O +A06970,A +A06971,O +A06972,N +A06973,N +A06974,N +A06975,A +A06976,N +A06977,O +A06978,N +A06979,N +A06980,N +A06981,A +A06982,~ +A06983,N +A06984,A +A06985,N +A06986,O +A06987,O +A06988,N +A06989,O +A06990,N +A06991,A +A06992,O +A06993,N +A06994,N +A06995,O +A06996,O +A06997,O +A06998,A +A06999,N +A07000,N +A07001,~ +A07002,N +A07003,O +A07004,A +A07005,O +A07006,O +A07007,N +A07008,N +A07009,N +A07010,N +A07011,N +A07012,N +A07013,O +A07014,O +A07015,N +A07016,N +A07017,O +A07018,O +A07019,N +A07020,N +A07021,N +A07022,N +A07023,N +A07024,N +A07025,N +A07026,N +A07027,~ +A07028,A +A07029,O +A07030,O +A07031,N +A07032,N +A07033,N +A07034,N +A07035,N +A07036,A +A07037,N +A07038,O +A07039,N +A07040,N +A07041,N +A07042,A +A07043,N +A07044,N +A07045,A +A07046,O +A07047,N +A07048,N +A07049,O +A07050,N +A07051,N +A07052,N +A07053,N +A07054,N +A07055,N +A07056,N +A07057,N +A07058,N +A07059,N +A07060,N +A07061,O +A07062,O +A07063,A +A07064,O +A07065,N +A07066,O +A07067,O +A07068,O +A07069,O +A07070,A +A07071,O +A07072,O +A07073,N +A07074,N +A07075,N +A07076,O +A07077,N +A07078,N +A07079,N +A07080,N +A07081,N +A07082,N +A07083,O +A07084,O +A07085,N +A07086,N +A07087,O +A07088,N +A07089,N +A07090,N +A07091,O +A07092,A +A07093,A +A07094,N +A07095,N +A07096,A +A07097,N +A07098,N +A07099,O +A07100,A +A07101,A +A07102,N +A07103,N +A07104,N +A07105,N +A07106,N +A07107,N +A07108,N +A07109,~ +A07110,N +A07111,N +A07112,N +A07113,N +A07114,N +A07115,N +A07116,N +A07117,N +A07118,A +A07119,O +A07120,N +A07121,N +A07122,A +A07123,N +A07124,N +A07125,N +A07126,N +A07127,N +A07128,N +A07129,N +A07130,N +A07131,N +A07132,O +A07133,O +A07134,N +A07135,O +A07136,~ +A07137,O +A07138,~ +A07139,~ +A07140,N +A07141,N +A07142,N +A07143,A +A07144,O +A07145,O +A07146,N +A07147,N +A07148,O +A07149,N +A07150,O +A07151,N +A07152,N +A07153,N +A07154,~ +A07155,O +A07156,O +A07157,O +A07158,N +A07159,O +A07160,N +A07161,A +A07162,O +A07163,A +A07164,N +A07165,N +A07166,O +A07167,N +A07168,A +A07169,N +A07170,N +A07171,O +A07172,O +A07173,N +A07174,N +A07175,N +A07176,N +A07177,O +A07178,N +A07179,O +A07180,~ +A07181,N +A07182,N +A07183,~ +A07184,N +A07185,O +A07186,N +A07187,O +A07188,N +A07189,N +A07190,N +A07191,N +A07192,N +A07193,N +A07194,O +A07195,O +A07196,A +A07197,N +A07198,~ +A07199,N +A07200,N +A07201,N +A07202,O +A07203,O +A07204,N +A07205,A +A07206,A +A07207,N +A07208,O +A07209,N +A07210,N +A07211,N +A07212,A +A07213,O +A07214,O +A07215,O +A07216,N +A07217,O +A07218,A +A07219,O +A07220,N +A07221,N +A07222,N +A07223,N +A07224,A +A07225,N +A07226,O +A07227,N +A07228,N +A07229,O +A07230,N +A07231,N +A07232,N +A07233,O +A07234,N +A07235,N +A07236,A +A07237,O +A07238,N +A07239,N +A07240,O +A07241,N +A07242,N +A07243,A +A07244,N +A07245,O +A07246,N +A07247,O +A07248,N +A07249,O +A07250,N +A07251,O +A07252,O +A07253,A +A07254,O +A07255,A +A07256,A +A07257,N +A07258,A +A07259,N +A07260,N +A07261,O +A07262,N +A07263,O +A07264,N +A07265,O +A07266,N +A07267,N +A07268,N +A07269,N +A07270,A +A07271,O +A07272,N +A07273,N +A07274,O +A07275,A +A07276,N +A07277,O +A07278,N +A07279,N +A07280,O +A07281,A +A07282,N +A07283,O +A07284,A +A07285,A +A07286,O +A07287,N +A07288,N +A07289,O +A07290,O +A07291,A +A07292,O +A07293,A +A07294,A +A07295,N +A07296,N +A07297,O +A07298,N +A07299,N +A07300,N +A07301,A +A07302,O +A07303,N +A07304,A +A07305,N +A07306,O +A07307,A +A07308,O +A07309,N +A07310,N +A07311,N +A07312,N +A07313,N +A07314,O +A07315,N +A07316,O +A07317,N +A07318,N +A07319,N +A07320,~ +A07321,O +A07322,~ +A07323,N +A07324,A +A07325,N +A07326,N +A07327,N +A07328,O +A07329,O +A07330,N +A07331,~ +A07332,N +A07333,N +A07334,N +A07335,N +A07336,N +A07337,N +A07338,O +A07339,N +A07340,N +A07341,N +A07342,N +A07343,A +A07344,N +A07345,N +A07346,N +A07347,N +A07348,O +A07349,N +A07350,O +A07351,N +A07352,N +A07353,N +A07354,N +A07355,O +A07356,~ +A07357,N +A07358,O +A07359,N +A07360,N +A07361,N +A07362,N +A07363,O +A07364,N +A07365,N +A07366,A +A07367,O +A07368,N +A07369,N +A07370,N +A07371,A +A07372,N +A07373,N +A07374,~ +A07375,N +A07376,N +A07377,N +A07378,N +A07379,N +A07380,N +A07381,A +A07382,~ +A07383,N +A07384,N +A07385,N +A07386,N +A07387,O +A07388,O +A07389,N +A07390,N +A07391,N +A07392,N +A07393,N +A07394,N +A07395,O +A07396,N +A07397,N +A07398,N +A07399,N +A07400,N +A07401,N +A07402,N +A07403,N +A07404,N +A07405,O +A07406,N +A07407,N +A07408,O +A07409,O +A07410,N +A07411,N +A07412,N +A07413,N +A07414,N +A07415,N +A07416,N +A07417,O +A07418,N +A07419,O +A07420,N +A07421,O +A07422,N +A07423,A +A07424,N +A07425,N +A07426,N +A07427,N +A07428,A +A07429,A +A07430,O +A07431,N +A07432,A +A07433,N +A07434,N +A07435,A +A07436,N +A07437,N +A07438,O +A07439,N +A07440,O +A07441,O +A07442,N +A07443,N +A07444,N +A07445,O +A07446,O +A07447,N +A07448,N +A07449,N +A07450,O +A07451,N +A07452,N +A07453,N +A07454,N +A07455,N +A07456,O +A07457,N +A07458,N +A07459,N +A07460,O +A07461,N +A07462,O +A07463,N +A07464,O +A07465,O +A07466,N +A07467,A +A07468,N +A07469,N +A07470,N +A07471,~ +A07472,N +A07473,A +A07474,N +A07475,N +A07476,N +A07477,N +A07478,N +A07479,N +A07480,N +A07481,O +A07482,N +A07483,N +A07484,O +A07485,O +A07486,O +A07487,N +A07488,N +A07489,~ +A07490,N +A07491,N +A07492,O +A07493,O +A07494,N +A07495,N +A07496,A +A07497,O +A07498,A +A07499,N +A07500,O +A07501,A +A07502,N +A07503,N +A07504,N +A07505,N +A07506,O +A07507,N +A07508,N +A07509,N +A07510,O +A07511,N +A07512,N +A07513,N +A07514,N +A07515,N +A07516,N +A07517,O +A07518,A +A07519,N +A07520,N +A07521,N +A07522,O +A07523,N +A07524,O +A07525,N +A07526,O +A07527,O +A07528,N +A07529,N +A07530,N +A07531,O +A07532,N +A07533,O +A07534,N +A07535,N +A07536,N +A07537,O +A07538,N +A07539,O +A07540,O +A07541,N +A07542,O +A07543,N +A07544,N +A07545,N +A07546,N +A07547,O +A07548,N +A07549,O +A07550,O +A07551,N +A07552,N +A07553,N +A07554,A +A07555,N +A07556,O +A07557,N +A07558,N +A07559,N +A07560,O +A07561,N +A07562,A +A07563,A +A07564,O +A07565,O +A07566,N +A07567,O +A07568,~ +A07569,N +A07570,O +A07571,N +A07572,O +A07573,N +A07574,O +A07575,N +A07576,N +A07577,O +A07578,N +A07579,N +A07580,O +A07581,O +A07582,N +A07583,O +A07584,N +A07585,N +A07586,N +A07587,O +A07588,N +A07589,N +A07590,N +A07591,N +A07592,~ +A07593,N +A07594,N +A07595,N +A07596,N +A07597,O +A07598,N +A07599,N +A07600,A +A07601,N +A07602,O +A07603,O +A07604,N +A07605,O +A07606,O +A07607,A +A07608,N +A07609,A +A07610,O +A07611,N +A07612,N +A07613,N +A07614,N +A07615,N +A07616,~ +A07617,O +A07618,O +A07619,N +A07620,O +A07621,N +A07622,N +A07623,N +A07624,N +A07625,~ +A07626,A +A07627,O +A07628,O +A07629,N +A07630,N +A07631,~ +A07632,O +A07633,O +A07634,N +A07635,N +A07636,O +A07637,O +A07638,O +A07639,N +A07640,N +A07641,O +A07642,N +A07643,O +A07644,N +A07645,N +A07646,N +A07647,N +A07648,A +A07649,O +A07650,N +A07651,N +A07652,N +A07653,N +A07654,N +A07655,N +A07656,A +A07657,A +A07658,O +A07659,O +A07660,N +A07661,A +A07662,N +A07663,N +A07664,A +A07665,N +A07666,A +A07667,N +A07668,N +A07669,N +A07670,O +A07671,N +A07672,O +A07673,N +A07674,O +A07675,N +A07676,N +A07677,N +A07678,O +A07679,O +A07680,N +A07681,N +A07682,N +A07683,N +A07684,N +A07685,N +A07686,O +A07687,N +A07688,A +A07689,O +A07690,N +A07691,O +A07692,N +A07693,N +A07694,N +A07695,N +A07696,O +A07697,N +A07698,N +A07699,N +A07700,N +A07701,O +A07702,A +A07703,O +A07704,N +A07705,N +A07706,N +A07707,N +A07708,O +A07709,N +A07710,A +A07711,O +A07712,N +A07713,O +A07714,A +A07715,N +A07716,N +A07717,N +A07718,A +A07719,N +A07720,O +A07721,N +A07722,A +A07723,O +A07724,~ +A07725,N +A07726,O +A07727,~ +A07728,~ +A07729,N +A07730,N +A07731,O +A07732,A +A07733,O +A07734,O +A07735,N +A07736,~ +A07737,O +A07738,N +A07739,N +A07740,O +A07741,O +A07742,O +A07743,N +A07744,A +A07745,N +A07746,N +A07747,A +A07748,N +A07749,N +A07750,N +A07751,N +A07752,O +A07753,N +A07754,O +A07755,N +A07756,O +A07757,N +A07758,N +A07759,N +A07760,O +A07761,N +A07762,N +A07763,N +A07764,N +A07765,A +A07766,A +A07767,N +A07768,O +A07769,N +A07770,N +A07771,A +A07772,O +A07773,O +A07774,N +A07775,N +A07776,O +A07777,O +A07778,N +A07779,O +A07780,N +A07781,O +A07782,N +A07783,N +A07784,A +A07785,O +A07786,~ +A07787,O +A07788,N +A07789,O +A07790,O +A07791,N +A07792,N +A07793,N +A07794,~ +A07795,N +A07796,O +A07797,O +A07798,N +A07799,O +A07800,N +A07801,O +A07802,O +A07803,N +A07804,N +A07805,N +A07806,O +A07807,N +A07808,O +A07809,O +A07810,A +A07811,N +A07812,N +A07813,N +A07814,A +A07815,O +A07816,O +A07817,N +A07818,~ +A07819,N +A07820,N +A07821,O +A07822,A +A07823,N +A07824,N +A07825,O +A07826,N +A07827,O +A07828,N +A07829,N +A07830,O +A07831,O +A07832,N +A07833,O +A07834,N +A07835,N +A07836,A +A07837,N +A07838,A +A07839,N +A07840,O +A07841,A +A07842,N +A07843,N +A07844,N +A07845,A +A07846,N +A07847,N +A07848,N +A07849,N +A07850,O +A07851,N +A07852,N +A07853,O +A07854,N +A07855,N +A07856,N +A07857,O +A07858,N +A07859,~ +A07860,A +A07861,N +A07862,N +A07863,N +A07864,N +A07865,O +A07866,N +A07867,O +A07868,N +A07869,~ +A07870,A +A07871,A +A07872,N +A07873,A +A07874,O +A07875,N +A07876,N +A07877,N +A07878,O +A07879,O +A07880,O +A07881,O +A07882,N +A07883,O +A07884,N +A07885,N +A07886,N +A07887,O +A07888,A +A07889,N +A07890,O +A07891,O +A07892,O +A07893,~ +A07894,O +A07895,O +A07896,A +A07897,N +A07898,A +A07899,O +A07900,O +A07901,A +A07902,O +A07903,A +A07904,A +A07905,N +A07906,N +A07907,N +A07908,O +A07909,N +A07910,N +A07911,N +A07912,N +A07913,O +A07914,O +A07915,O +A07916,N +A07917,N +A07918,N +A07919,N +A07920,O +A07921,O +A07922,N +A07923,O +A07924,A +A07925,N +A07926,N +A07927,A +A07928,O +A07929,N +A07930,A +A07931,N +A07932,N +A07933,N +A07934,O +A07935,N +A07936,O +A07937,N +A07938,O +A07939,O +A07940,O +A07941,N +A07942,O +A07943,N +A07944,N +A07945,N +A07946,N +A07947,A +A07948,N +A07949,N +A07950,A +A07951,N +A07952,O +A07953,N +A07954,O +A07955,N +A07956,N +A07957,A +A07958,N +A07959,O +A07960,N +A07961,O +A07962,N +A07963,O +A07964,N +A07965,N +A07966,O +A07967,N +A07968,O +A07969,A +A07970,N +A07971,O +A07972,N +A07973,O +A07974,N +A07975,N +A07976,O +A07977,O +A07978,O +A07979,N +A07980,O +A07981,N +A07982,A +A07983,~ +A07984,A +A07985,O +A07986,O +A07987,N +A07988,O +A07989,N +A07990,O +A07991,N +A07992,O +A07993,N +A07994,N +A07995,N +A07996,O +A07997,N +A07998,O +A07999,N +A08000,N +A08001,N +A08002,N +A08003,A +A08004,N +A08005,O +A08006,N +A08007,O +A08008,O +A08009,N +A08010,O +A08011,N +A08012,A +A08013,A +A08014,N +A08015,N +A08016,N +A08017,O +A08018,A +A08019,O +A08020,N +A08021,~ +A08022,N +A08023,A +A08024,O +A08025,A +A08026,N +A08027,O +A08028,N +A08029,N +A08030,O +A08031,N +A08032,N +A08033,N +A08034,N +A08035,~ +A08036,O +A08037,O +A08038,A +A08039,O +A08040,O +A08041,O +A08042,O +A08043,~ +A08044,N +A08045,O +A08046,~ +A08047,A +A08048,O +A08049,N +A08050,O +A08051,N +A08052,N +A08053,A +A08054,O +A08055,N +A08056,O +A08057,N +A08058,O +A08059,O +A08060,O +A08061,O +A08062,N +A08063,A +A08064,A +A08065,A +A08066,N +A08067,A +A08068,N +A08069,N +A08070,O +A08071,O +A08072,N +A08073,N +A08074,N +A08075,N +A08076,O +A08077,N +A08078,N +A08079,N +A08080,N +A08081,O +A08082,N +A08083,A +A08084,N +A08085,A +A08086,O +A08087,O +A08088,N +A08089,N +A08090,O +A08091,N +A08092,N +A08093,O +A08094,N +A08095,N +A08096,O +A08097,N +A08098,N +A08099,N +A08100,N +A08101,O +A08102,N +A08103,N +A08104,O +A08105,N +A08106,N +A08107,N +A08108,N +A08109,N +A08110,N +A08111,N +A08112,~ +A08113,A +A08114,O +A08115,N +A08116,N +A08117,N +A08118,O +A08119,N +A08120,N +A08121,N +A08122,N +A08123,N +A08124,~ +A08125,N +A08126,O +A08127,N +A08128,N +A08129,A +A08130,N +A08131,N +A08132,A +A08133,~ +A08134,O +A08135,N +A08136,N +A08137,N +A08138,N +A08139,O +A08140,N +A08141,N +A08142,O +A08143,N +A08144,N +A08145,N +A08146,O +A08147,O +A08148,O +A08149,O +A08150,N +A08151,N +A08152,N +A08153,O +A08154,A +A08155,N +A08156,A +A08157,N +A08158,N +A08159,O +A08160,~ +A08161,N +A08162,N +A08163,O +A08164,O +A08165,N +A08166,O +A08167,O +A08168,N +A08169,N +A08170,N +A08171,~ +A08172,N +A08173,N +A08174,N +A08175,O +A08176,O +A08177,N +A08178,N +A08179,O +A08180,N +A08181,O +A08182,N +A08183,N +A08184,N +A08185,O +A08186,N +A08187,N +A08188,N +A08189,N +A08190,O +A08191,N +A08192,N +A08193,A +A08194,O +A08195,A +A08196,N +A08197,N +A08198,N +A08199,N +A08200,O +A08201,N +A08202,N +A08203,O +A08204,~ +A08205,N +A08206,N +A08207,~ +A08208,O +A08209,O +A08210,O +A08211,N +A08212,N +A08213,~ +A08214,N +A08215,N +A08216,O +A08217,O +A08218,N +A08219,O +A08220,N +A08221,O +A08222,N +A08223,N +A08224,N +A08225,N +A08226,N +A08227,A +A08228,N +A08229,O +A08230,O +A08231,N +A08232,N +A08233,N +A08234,N +A08235,N +A08236,A +A08237,N +A08238,N +A08239,N +A08240,N +A08241,O +A08242,A +A08243,N +A08244,N +A08245,N +A08246,O +A08247,O +A08248,A +A08249,O +A08250,O +A08251,O +A08252,N +A08253,O +A08254,N +A08255,N +A08256,O +A08257,N +A08258,~ +A08259,N +A08260,N +A08261,N +A08262,O +A08263,N +A08264,N +A08265,N +A08266,O +A08267,O +A08268,O +A08269,O +A08270,N +A08271,N +A08272,N +A08273,O +A08274,N +A08275,N +A08276,O +A08277,N +A08278,O +A08279,A +A08280,N +A08281,~ +A08282,N +A08283,A +A08284,N +A08285,O +A08286,N +A08287,N +A08288,N +A08289,N +A08290,A +A08291,O +A08292,O +A08293,O +A08294,O +A08295,N +A08296,A +A08297,N +A08298,N +A08299,O +A08300,N +A08301,O +A08302,N +A08303,O +A08304,A +A08305,A +A08306,N +A08307,A +A08308,N +A08309,O +A08310,O +A08311,O +A08312,O +A08313,O +A08314,O +A08315,N +A08316,N +A08317,O +A08318,N +A08319,N +A08320,O +A08321,N +A08322,N +A08323,N +A08324,N +A08325,N +A08326,N +A08327,N +A08328,A +A08329,O +A08330,N +A08331,O +A08332,O +A08333,N +A08334,N +A08335,N +A08336,O +A08337,N +A08338,N +A08339,O +A08340,N +A08341,N +A08342,N +A08343,O +A08344,N +A08345,N +A08346,N +A08347,N +A08348,N +A08349,N +A08350,N +A08351,N +A08352,N +A08353,A +A08354,N +A08355,N +A08356,N +A08357,N +A08358,N +A08359,O +A08360,N +A08361,O +A08362,N +A08363,N +A08364,N +A08365,O +A08366,N +A08367,N +A08368,N +A08369,N +A08370,N +A08371,A +A08372,~ +A08373,N +A08374,N +A08375,O +A08376,N +A08377,~ +A08378,~ +A08379,N +A08380,N +A08381,N +A08382,N +A08383,O +A08384,N +A08385,N +A08386,O +A08387,N +A08388,O +A08389,O +A08390,N +A08391,O +A08392,A +A08393,N +A08394,N +A08395,N +A08396,O +A08397,N +A08398,O +A08399,O +A08400,O +A08401,O +A08402,~ +A08403,N +A08404,O +A08405,A +A08406,N +A08407,O +A08408,~ +A08409,O +A08410,O +A08411,N +A08412,O +A08413,N +A08414,A +A08415,O +A08416,N +A08417,N +A08418,N +A08419,N +A08420,N +A08421,N +A08422,A +A08423,N +A08424,N +A08425,O +A08426,N +A08427,O +A08428,O +A08429,N +A08430,N +A08431,O +A08432,O +A08433,O +A08434,O +A08435,N +A08436,A +A08437,O +A08438,N +A08439,O +A08440,N +A08441,N +A08442,N +A08443,N +A08444,N +A08445,N +A08446,N +A08447,N +A08448,N +A08449,N +A08450,O +A08451,A +A08452,O +A08453,O +A08454,N +A08455,N +A08456,O +A08457,N +A08458,O +A08459,N +A08460,N +A08461,N +A08462,N +A08463,O +A08464,~ +A08465,N +A08466,A +A08467,N +A08468,~ +A08469,N +A08470,O +A08471,O +A08472,N +A08473,O +A08474,N +A08475,N +A08476,N +A08477,N +A08478,O +A08479,O +A08480,N +A08481,O +A08482,N +A08483,N +A08484,O +A08485,N +A08486,A +A08487,O +A08488,N +A08489,~ +A08490,O +A08491,N +A08492,O +A08493,~ +A08494,N +A08495,A +A08496,N +A08497,N +A08498,O +A08499,O +A08500,A +A08501,O +A08502,N +A08503,N +A08504,O +A08505,N +A08506,N +A08507,N +A08508,N +A08509,N +A08510,O +A08511,O +A08512,N +A08513,N +A08514,A +A08515,N +A08516,O +A08517,N +A08518,N +A08519,O +A08520,O +A08521,O +A08522,N +A08523,A +A08524,N +A08525,O +A08526,N +A08527,N +A08528,N diff --git a/cardio/tests/test_ecgbatch.py b/cardio/tests/test_ecgbatch.py new file mode 100644 index 0000000..c427c77 --- /dev/null +++ b/cardio/tests/test_ecgbatch.py @@ -0,0 +1,416 @@ +"""Module for testing ecg_batch methods +""" + +import os +import sys +import random +import numpy as np +import pytest + +sys.path.append(os.path.join(".")) + +from cardio.batch import ecg_batch_tools as bt #pylint: disable=no-name-in-module,import-error +from cardio import EcgBatch, EcgDataset, dataset as ds #pylint: disable=no-name-in-module + +random.seed(170720143422) + +@pytest.fixture(scope="module") +def setup_module_load(request): + """ + Fixture to setup module. Performs check for presence of test files, + creates initial batch object. + """ + path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'data') + files = ["A00001.hea", "A00001.mat", "A00002.hea", "A00002.mat", + "A00004.hea", "A00004.mat", "A00005.hea", "A00005.mat", + "A00008.hea", "A00008.mat", "A00013.hea", "A00013.mat", "REFERENCE.csv"] + # TODO: make better test for presence of files .hea and + # REFERENCE.csv + + if np.all([os.path.isfile(os.path.join(path, file)) for file in files]): + ind = ds.FilesIndex(path=os.path.join(path, '*.hea'), no_ext=True, sort=True) + else: + raise FileNotFoundError("Test files not found in 'tests/data/'!") + + def teardown_module_load(): + """ + Teardown module + """ + + request.addfinalizer(teardown_module_load) + return ind, path + +@pytest.fixture() +def setup_class_methods(request): + """ + Fixture to setup class to test EcgBatch methods separately. + """ + path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'data/') + ind = ds.FilesIndex(path=os.path.join(path, '*.hea'), no_ext=True, sort=True) + batch_loaded = (EcgBatch(ind, unique_labels=["A", "O", "N"]) + .load(fmt="wfdb", components=["signal", "annotation", "meta"])) + + def teardown_class_methods(): + """ + Teardown class + """ + + request.addfinalizer(teardown_class_methods) + return batch_loaded + +@pytest.fixture(scope="class") +def setup_class_dataset(request): + """ + Fixture to setup class to test EcgBatch methods in pipeline. + """ + path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'data/') + ecg_dataset = EcgDataset(path=os.path.join(path, '*.hea'), no_ext=True, sort=True) + + def teardown_class_dataset(): + """ + Teardown class + """ + + request.addfinalizer(teardown_class_dataset) + return ecg_dataset + +@pytest.fixture(scope="class") +def setup_class_pipeline(request): + """ + Fixture to setup class to test EcgBatch methods in pipeline. + """ + path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'data/') + target_path = os.path.join(path, "REFERENCE.csv") + ecg_pipeline = (EcgDataset(path=os.path.join(path, '*.hea'), no_ext=True, sort=True) + .p + .load(src=None, fmt="wfdb", components=["signal", "annotation", "meta"]) + .load(src=target_path, fmt="csv", components=["target"])) + + def teardown_class_pipeline(): + """ + Teardown class + """ + + request.addfinalizer(teardown_class_pipeline) + return ecg_pipeline + + +class TestEcgBatchLoad(): + """ + Class for test of load / dump methods. + """ + + def test_load_wfdb(self, setup_module_load): #pylint: disable=redefined-outer-name + """ + Testing wfdb loader. + """ + # Arrange + ind = setup_module_load[0] + batch = EcgBatch(ind) + # Act + batch = batch.load(fmt="wfdb", components=["signal", "annotation", "meta"]) + # Assert + assert isinstance(batch.signal, np.ndarray) + assert isinstance(batch.meta, np.ndarray) + assert isinstance(batch.annotation, np.ndarray) + assert batch.signal.shape == (6,) + assert batch.annotation.shape == (6,) + assert batch.meta.shape == (6,) + assert isinstance(batch.signal[0], np.ndarray) + assert isinstance(batch.annotation[0], dict) + assert isinstance(batch.meta[0], dict) + del batch + + +class TestEcgBatchSingleMethods: + """ + Class for testing other single methods of EcgBatch class + """ + def test_update(self): + """ + Testing update + """ + new_inds = ["A00001", "A00004"] + ind = ds.DatasetIndex(index=new_inds) + batch = EcgBatch(ind) + + seq1 = np.array([1, 2, 3]).reshape(1, -1) + seq2 = np.array([1, 2, 3, 4]).reshape(1, -1) + signal = np.array([seq1, seq2, []], dtype=object)[:-1] + annotation = np.array([{}] * len(new_inds)) + meta = np.array([{"new_meta":True}, {"new_meta":True}]) + target = np.array(["N", "A"]) + batch.update(signal, annotation, meta, target) + assert batch.signal[0].shape == (1, 3) + assert batch.signal[1].shape == (1, 4) + assert batch["A00001"].meta["new_meta"] + assert batch["A00004"].meta["new_meta"] + assert batch["A00001"].target == "N" + assert batch["A00004"].target == "A" + + @pytest.mark.usefixtures("setup_class_methods") + def tets_drop_short_signal(self, setup_class_methods): #pylint: disable=redefined-outer-name + """ + Testing of drop_short_signals + """ + + # Arrange + batch = setup_class_methods + + # Act + batch = batch.drop_short_signals(17000, axis=-1) + + # Assert + assert batch.signal.shape == (2,) + assert np.all([True if sig.shape[-1] > 17000 else False for sig in batch.signal]) + + @pytest.mark.usefixtures("setup_class_methods") + def test_split_signals(self, setup_class_methods): #pylint: disable=redefined-outer-name + """ + Testing split_signals. + """ + batch = setup_class_methods + batch = batch.split_signals(4500, 4499) + assert batch.indices.shape == (6,) + assert batch.signal[0].shape == (2, 1, 4500) + + @pytest.mark.usefixtures("setup_class_methods") + def test_resample_signals(self, setup_class_methods):#pylint: disable=redefined-outer-name + """ + Testing resample_signal. + """ + batch = setup_class_methods + batch = batch.resample_signals(150) + + assert batch.meta[0]['fs'] == 150 + assert batch.signal[0].shape == (1, 4500) + + @pytest.mark.usefixtures("setup_class_methods") + def test_band_pass_signals(self, setup_class_methods): #pylint: disable=redefined-outer-name + """ + Testing band_pass_signals. + """ + batch = setup_class_methods + batch = batch.band_pass_signals(0.5, 5) + + assert batch.signal.shape == (6,) + assert batch.signal[0].shape == (1, 9000) + + @pytest.mark.usefixtures("setup_class_methods") + def test_flip_signals(self, setup_class_methods): #pylint: disable=redefined-outer-name + """ + Testing flip_signals. + """ + batch = setup_class_methods + + batch = batch.flip_signals() + assert batch.indices.shape == (6,) + + +@pytest.mark.usefixtures("setup_class_dataset") +class TestEcgBatchDataset: + """ + Class to test EcgBathc load in pipeline + """ + @pytest.mark.xfail + def test_cv_split(self, setup_class_dataset): #pylint: disable=redefined-outer-name + """ + Testing cv_split. + """ + ecg_dtst = setup_class_dataset + ecg_dtst.cv_split(shares=0.5) + assert ecg_dtst.train.indices.shape == (3,) + assert ecg_dtst.test.indices.shape == (3,) + assert isinstance(ecg_dtst.train, ds.Dataset) + assert isinstance(ecg_dtst.test, ds.Dataset) + + ecg_dtst.cv_split(shares=[0.5, 0.49]) + assert ecg_dtst.train.indices.shape == (3,) + assert ecg_dtst.test.indices.shape == (2,) + assert ecg_dtst.validation.indices.shape == (1,) + assert isinstance(ecg_dtst.train, ds.Dataset) + assert isinstance(ecg_dtst.test, ds.Dataset) + assert isinstance(ecg_dtst.validation, ds.Dataset) + + def test_pipeline_load(self, setup_class_dataset, setup_module_load): #pylint: disable=redefined-outer-name + """ + Testing load in pipeline. + """ + ecg_dtst = setup_class_dataset + path = setup_module_load[1] + target_path = os.path.join(path, "REFERENCE.csv") + + ppln = (ecg_dtst.p + .load(fmt="wfdb", components=["signal", "annotation", "meta"]) + .load(src=target_path, fmt="csv", components=["target"])) + + batch_size = 2 + epochs = ecg_dtst.indices.shape[0] // batch_size + + assert epochs == 3 + + for _ in range(epochs): + ppln_batch = ppln.next_batch(batch_size, shuffle=False) + assert ppln_batch.indices.shape == (batch_size,) + assert ppln_batch.signal.shape == (batch_size,) + assert np.unique(ppln_batch.target).shape == (1,) + + first_indice = ppln_batch.indices[0] + assert isinstance(ppln_batch[first_indice], ds.components.EcgBatchComponents) #pylint: disable=no-member + + + +@pytest.mark.usefixtures("setup_class_pipeline") +class TestEcgBatchPipelineMethods: + """ + Class to test EcgBatch methods in pipeline. + """ + + def test_pipeline_1(self, setup_class_pipeline): #pylint: disable=redefined-outer-name + """ + Testing typical pipeline. + """ + ecg_ppln = setup_class_pipeline + ppln = (ecg_ppln + .drop_labels(["A"]) + .flip_signals() + .split_signals(4500, 4499) + .replace_labels({"A":"A", "N":"NonA", "O":"NonA"})) + + batch = ppln.next_batch(len(ppln), shuffle=False) + assert len(batch) == 4 + assert batch.signal[0].shape == (2, 1, 4500) + assert np.unique(batch.target)[0] == "NonA" + + def test_pipeline_2(self, setup_class_pipeline): #pylint: disable=redefined-outer-name + """ + Testing typical pipeline. + """ + ecg_ppln = setup_class_pipeline + ppln = (ecg_ppln + .drop_short_signals(17000, axis=-1) + .band_pass_signals(0.5, 50) + .resample_signals(150) + .binarize_labels()) + + batch = ppln.next_batch(len(ppln), shuffle=False) + + assert len(batch) == 2 + assert batch.meta[0]["fs"] == 150 + assert np.all([True if sig.shape[-1] == 9000 else False for sig in batch.signal]) + assert batch.target.shape == (2, 3) + + def test_get_signal_with_meta(self, setup_module_load): #pylint: disable=redefined-outer-name + """ + Testing get_signal_meta. + """ + # Arrange + ppln = (ds.Pipeline() + .init_variable(name="signal", init_on_each_run=list()) + .load(fmt='wfdb', components=["signal", "meta"]) + .flip_signals() + .update_variable("signal", ds.B("signal"), mode='a') + .run(batch_size=2, shuffle=False, + drop_last=False, n_epochs=1, lazy=True)) + + dtst = EcgDataset(setup_module_load[0]) + + # Act + (dtst >> ppln).run() + signal_var = ppln.get_variable("signal") + + # Assert + assert len(signal_var) == 3 + assert len(signal_var[0]) == 2 + assert signal_var[0][0].shape == (1, 9000) + +class TestIntervalBatchTools: + """ + Class for testing batch tools that involved in intervals calculation + """ + def test_find_interval_borders(self): #pylint: disable=redefined-outer-name + """ + Testing find_interval_borders. + """ + # Arrange + hmm_annotation = np.array([1, 1, 1, 2, 2, 2, 3, 3, 3, 0, + 0, 0, 4, 4, 4, 0, 0, 0, 1, 1, + 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, + 4, 4, 4, 4, 0, 0, 0, 1, 1, 1]*2, + dtype=np.int64) + + # Act + starts_3, ends_3 = bt.find_intervals_borders(hmm_annotation, + np.array([3], dtype=np.int64)) + + starts_12, ends_12 = bt.find_intervals_borders(hmm_annotation, + np.array([1, 2], dtype=np.int64)) + + # Assert + assert np.all(np.equal(starts_3, np.array([6, 25, 46, 65]))) + assert np.all(np.equal(ends_3, np.array([9, 30, 49, 70]))) + + assert np.all(np.equal(starts_12, np.array([18, 37, 58]))) + assert np.all(np.equal(ends_12, np.array([25, 46, 65]))) + + def test_find_maxes(self): #pylint: disable=redefined-outer-name + """ + Testing find_maxes. + """ + # Arrange + hmm_annotation = np.array([1, 1, 1, 2, 2, 2, 3, 3, 3, 0, + 0, 0, 4, 4, 4, 0, 0, 0, 1, 1, + 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, + 4, 4, 4, 4, 0, 0, 0, 1, 1, 1]*2, + dtype=np.int64) + + # 9 is the max for interval of 3's + # 8 is the max for interval of 1's and 2's + signal = np.array([1, 1, 1, 2, 2, 8, 3, 9, 3, 0, + 0, 0, 4, 4, 4, 0, 0, 0, 1, 8, + 1, 2, 2, 2, 2, 9, 3, 3, 3, 3, + 4, 4, 4, 4, 0, 0, 0, 1, 1, 1]*2, + dtype=np.float64).reshape(1, -1) + + # Act + starts_3, ends_3 = bt.find_intervals_borders(hmm_annotation, + np.array([3], dtype=np.int64)) + + starts_12, ends_12 = bt.find_intervals_borders(hmm_annotation, + np.array([1, 2], dtype=np.int64)) + + maxes_3 = bt.find_maxes(signal, starts_3, ends_3) + maxes_12 = bt.find_maxes(signal, starts_12, ends_12) + + # Assert + assert np.all(np.equal(maxes_3, np.array([7, 25, 47, 65]))) + assert np.all(np.equal(maxes_12, np.array([19, 45, 59]))) + + def test_calc_hr(self): + """ + Testing calc_hr. + """ + # Arrange + fs = 18.0 + + R_STATE = np.array([3], dtype=np.int64) # pylint: disable=invalid-name + + hmm_annotation = np.array([1, 1, 1, 2, 2, 2, 3, 3, 3, 0, + 0, 0, 4, 4, 4, 0, 0, 0, 1, 1, + 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, + 4, 4, 4, 4, 0, 0, 0, 1, 1, 1]*2, + dtype=np.int64) + + # 9 is the max for interval of 3's + # 8 is the max for interval of 1's and 2's + signal = np.array([1, 1, 1, 2, 2, 8, 3, 9, 3, 0, + 0, 0, 4, 4, 4, 0, 0, 0, 1, 8, + 1, 2, 2, 2, 2, 9, 3, 3, 3, 3, + 4, 4, 4, 4, 0, 0, 0, 1, 1, 1]*2, + dtype=np.float64).reshape(1, -1) + + # Act + hr = bt.calc_hr(signal, hmm_annotation, fs, R_STATE) # pylint: disable=invalid-name + + # Arrange + assert hr == 60 diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 0000000..63c63dc --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line. +SPHINXOPTS = +SPHINXBUILD = python -msphinx +SPHINXPROJ = CardIO +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) \ No newline at end of file diff --git a/docs/api/cardio.batch.rst b/docs/api/cardio.batch.rst new file mode 100644 index 0000000..0d045ab --- /dev/null +++ b/docs/api/cardio.batch.rst @@ -0,0 +1,56 @@ +Batch +===== + +.. autoclass:: cardio.batch.EcgBatch + :show-inheritance: + +Methods +------- + +Input/output methods +^^^^^^^^^^^^^^^^^^^^ + .. automethod:: cardio.batch.EcgBatch.load + .. automethod:: cardio.batch.EcgBatch.dump + .. automethod:: cardio.batch.EcgBatch.show_ecg + +Batch modifications +^^^^^^^^^^^^^^^^^^^ + .. automethod:: cardio.batch.EcgBatch.update + .. automethod:: cardio.batch.EcgBatch.apply_transform + +Batch processing +^^^^^^^^^^^^^^^^ + .. automethod:: cardio.batch.EcgBatch.merge + .. automethod:: cardio.batch.EcgBatch.deepcopy + +Label processing +^^^^^^^^^^^^^^^^ + .. automethod:: cardio.batch.EcgBatch.drop_labels + .. automethod:: cardio.batch.EcgBatch.keep_labels + .. automethod:: cardio.batch.EcgBatch.replace_labels + .. automethod:: cardio.batch.EcgBatch.binarize_labels + +Signal processing +^^^^^^^^^^^^^^^^^ + .. automethod:: cardio.batch.EcgBatch.convolve_signals + .. automethod:: cardio.batch.EcgBatch.band_pass_signals + .. automethod:: cardio.batch.EcgBatch.drop_short_signals + .. automethod:: cardio.batch.EcgBatch.flip_signals + .. automethod:: cardio.batch.EcgBatch.ravel + .. automethod:: cardio.batch.EcgBatch.slice_signal + .. automethod:: cardio.batch.EcgBatch.split_signals + .. automethod:: cardio.batch.EcgBatch.random_split_signals + .. automethod:: cardio.batch.EcgBatch.resample_signals + .. automethod:: cardio.batch.EcgBatch.random_resample_signals + +Complex ECG processing +^^^^^^^^^^^^^^^^^^^^^^ + .. automethod:: cardio.batch.EcgBatch.wavelet_transform_signal + .. automethod:: cardio.batch.EcgBatch.calc_ecg_parameters + + +EcgDataset +========== + +.. autoclass:: cardio.batch.EcgDataset + :show-inheritance: \ No newline at end of file diff --git a/docs/api/cardio.models.rst b/docs/api/cardio.models.rst new file mode 100644 index 0000000..979d3eb --- /dev/null +++ b/docs/api/cardio.models.rst @@ -0,0 +1,25 @@ +====== +Models +====== + +DirichletModel +-------------- + +.. autoclass:: cardio.models.DirichletModel + :members: + :inherited-members: + :show-inheritance: + +HMModel +------- + +.. autoclass:: cardio.models.HMModel + :members: + :show-inheritance: + +FFT model +--------- + +.. autoclass:: cardio.models.FFTModel + :members: + :show-inheritance: diff --git a/docs/api/cardio.pipelines.rst b/docs/api/cardio.pipelines.rst new file mode 100644 index 0000000..3a4f67a --- /dev/null +++ b/docs/api/cardio.pipelines.rst @@ -0,0 +1,27 @@ +Pipelines +========= + +dirichlet_train_pipeline +------------------------ + +.. autofunction:: cardio.pipelines.dirichlet_train_pipeline + +dirichlet_predict_pipeline +-------------------------- + +.. autofunction:: cardio.pipelines.dirichlet_predict_pipeline + +hmm_preprocessing_pipeline +-------------------------- + +.. autofunction:: cardio.pipelines.hmm_preprocessing_pipeline + +hmm_train_pipeline +------------------ + +.. autofunction:: cardio.pipelines.hmm_train_pipeline + +hmm_predict_pipeline +-------------------- + +.. autofunction:: cardio.pipelines.hmm_predict_pipeline diff --git a/docs/api/cardio.rst b/docs/api/cardio.rst new file mode 100644 index 0000000..7541e55 --- /dev/null +++ b/docs/api/cardio.rst @@ -0,0 +1,11 @@ +=== +API +=== + +.. toctree:: + :maxdepth: 2 + :titlesonly: + + cardio.batch + cardio.models + cardio.pipelines \ No newline at end of file diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..55109b1 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,183 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +# +# CardIO documentation build configuration file, created by +# hand on Tue Nov 9 12:49:55 2017. +# +# This file is execfile()d with the current directory set to its +# containing dir. +# +# Note that not all possible configuration values are present in this +# autogenerated file. +# +# All configuration values have a default; values that are commented out +# serve to show the default. + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +import os +import sys +sys.path.insert(0, os.path.join("..")) +import cardio + + +extensions = [ + 'sphinx.ext.autodoc', + 'sphinx.ext.doctest', + 'sphinx.ext.coverage', + 'sphinx.ext.mathjax', + 'sphinx.ext.viewcode', + 'sphinx.ext.githubpages', + 'sphinx.ext.intersphinx', + 'sphinx.ext.napoleon', +] + +napoleon_use_rtype = False + +templates_path = ['_templates'] + +source_suffix = ['.rst', '.md'] + +source_parsers = { +} + +master_doc = 'index' + +project = 'CardIO' +copyright = '2017, Analysis Center' +author = 'Analysis Center' + + +# The full version, including alpha/beta/rc tags. +release = cardio.__version__ +# The short X.Y version. +version = '.'.join(release.split('.')[:2]) + +# The language for content autogenerated by Sphinx. Refer to documentation +# for a list of supported languages. +# +# This is also used if you do content translation via gettext catalogs. +# Usually you set "language" from the command line for these cases. +language = None + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This patterns also effect to html_static_path and html_extra_path +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] + +# The name of the Pygments (syntax highlighting) style to use. +pygments_style = 'sphinx' + +# If true, `todo` and `todoList` produce output, else they produce nothing. +todo_include_todos = False + + +# -- Options for HTML output ---------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = 'classic' +#html_theme = 'nature' +#html_theme = 'sphinx_rtd_theme' + +#html_theme_options = { +# "rightsidebar": "false" +#} + + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ['_static'] + +# Custom sidebar templates, must be a dictionary that maps document names +# to template names. +# +# This is required for the alabaster theme +# refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars +""" +html_theme = 'alabaster' +html_sidebars = { + '**': [ + 'about.html', + 'navigation.html', + 'relations.html', # needs 'show_related': True theme option to display + 'searchbox.html', + 'donate.html', + ] +} +""" + +autoclass_content = 'class' +add_module_names = False + +intersphinx_mapping = { + 'python': ('https://docs.python.org/3', None), + 'numpy': ('http://docs.scipy.org/doc/numpy/', None), + 'scipy': ('http://docs.scipy.org/doc/scipy/reference/', None), + 'pandas': ('http://pandas-docs.github.io/pandas-docs-travis/', None), + 'dataset': ('https://analysiscenter.github.io/dataset/', None), +} + +viewcode_import = True + +# -- Options for HTMLHelp output ------------------------------------------ + +# Output file base name for HTML help builder. +htmlhelp_basename = 'CardIOdoc' + + +# -- Options for LaTeX output --------------------------------------------- + +latex_elements = { + # The paper size ('letterpaper' or 'a4paper'). + # + # 'papersize': 'letterpaper', + + # The font size ('10pt', '11pt' or '12pt'). + # + # 'pointsize': '10pt', + + # Additional stuff for the LaTeX preamble. + # + # 'preamble': '', + + # Latex figure (float) alignment + # + # 'figure_align': 'htbp', +} + +# Grouping the document tree into LaTeX files. List of tuples +# (source start file, target name, title, +# author, documentclass [howto, manual, or own class]). +latex_documents = [ + (master_doc, 'CardIO.tex', 'CardIO Documentation', + author, 'manual'), +] + + +# -- Options for manual page output --------------------------------------- + +# One entry per manual page. List of tuples +# (source start file, name, description, authors, manual section). +man_pages = [ + (master_doc, 'cardio', 'CardIO Documentation', + [author], 1) +] + + +# -- Options for Texinfo output ------------------------------------------- + +# Grouping the document tree into Texinfo files. List of tuples +# (source start file, target name, title, author, +# dir menu entry, description, category) +texinfo_documents = [ + (master_doc, 'CardIO', 'CardIO Documentation', + author, 'CardIO', 'One line description of project.', + 'Miscellaneous'), +] + +#github_doc_root = 'http://github.com/analysiscenter/cardio/' \ No newline at end of file diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000..5296b64 --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,104 @@ +=================================== +Welcome to CardIO's documentation! +=================================== +`CardIO` is a library designed to build end-to-end machine learning models for deep research of electrocardiograms. + +Main features: + +* load and save signal in a number of formats +* resample, crop and flip signal +* filter signal +* allocate PQ, QT, QRS segments +* calculate heart rate and find other standard ECG characteristics +* apply complex transformations like fft and wavelets, or any other custom functions. +* recognize heart diseases from ECG +* efficiently work with large datasets that do not even fit into memory +* easily arrange new custom actions into pipelines +* do end-to-end ECG processing +* build, train and test custom models for deep research + +… and do everything under a single API. + +The library is based on `Dataset <https://github.com/analysiscenter/dataset>`_. We suggest to read Dataset's documentation to learn more, however, you may skip it for the first reading. + +CardIO has three modules: :doc:`batch <./api/cardio.batch>`, :doc:`models <./api/cardio.models>` and :doc:`pipelines <api/cardio.pipelines>`. + +Module batch contains low-level actions for ECG processing. Actions are included in EcgBatch class that also defines how to store ECGs. From these actions you can build new pipelines. You can also write custom action and include it in EcgBatch. + +In models we provide several models that were elaborated to learn the most important problems in ECG: + +* how to recognize specific features of ECG like R-peaks, P-wave, T-wave +* how to recognize heart diseases from ECG, for example - atrial fibrillation. + +Module pipelines contains high-level methods that build pipelines for model training and prediction, preprocessing, etc. + + +Contents +======== +.. toctree:: + :maxdepth: 2 + :titlesonly: + + intro/intro + api/cardio + + +Basic usage +=========== + +Here is an example of pipeline that loads ECG signals, makes some preprocessing and learns model over 50 epochs: + +.. code-block :: python + + train_ppl = ( + dtst.train + .pipeline + .init_model("dynamic", DirichletModel, name="dirichlet", + config=model_config) + .init_variable("loss_history", init=list) + .load(components=["signal", "meta"], fmt="wfdb") + .load(components="target", fmt="csv", src=LABELS_PATH) + .drop_labels(["~"]) + .replace_labels({"N": "NO", "O": "NO"}) + .flip_signals() + .random_resample_signals("normal", loc=300, scale=10) + .random_split_signals(2048, {"A": 9, "NO": 3}) + .binarize_labels() + .train_model("dirichlet", make_data=make_data, + fetches="loss", save_to=V("loss_history"), mode="a") + .run(batch_size=100, shuffle=True, drop_last=True, + n_epochs=50) +) + +As a result of this pipeline one obtains a trained model. + +Installation +============ + +With `pipenv <https://docs.pipenv.org/>`_:: + + pipenv install git+https://github.com/analysiscenter/cardio.git#egg=cardio + +With `pip <https://pip.pypa.io/en/stable/>`_:: + + pip3 install git+https://github.com/analysiscenter/cardio.git + + +After that just import `cardio`:: + + import cardio + + +.. note:: `CardIO` module is in the beta stage. Your suggestions and improvements are very welcome. + +.. note:: `CardIO` supports python 3.5 or higher. + +.. note:: When cloning repo from GitHub use flag ``--recursive`` to make sure that ``Dataset`` submodule is also cloned. + +Citing CardIO +============== +Please cite CardIO in your publications if it helps your research. + +``` +Khudorozhkov R., Illarionov E., Kuvaev A., Podvyaznikov D. CardIO library for data science research of heart signals. 2017. +``` \ No newline at end of file diff --git a/docs/intro/batch.rst b/docs/intro/batch.rst new file mode 100644 index 0000000..4ebfd28 --- /dev/null +++ b/docs/intro/batch.rst @@ -0,0 +1,79 @@ +===== +Batch +===== + +This module stores batch class for ECG and various actions on ECG batch. + +EcgBatch +--------- + +EcgBatch is the main class that defines how to store ECG data and contains actions +that can be applied to ECG in preprocessing stage. + +Attributes of EcgBatch: + +* ``signal``, stores ECG signals in numpy array +* ``annotation``, array of dicts with different types of annotations, e.g. array of R-peaks +* ``meta``, array of dicts with metadata about ECG records, e.g. signal frequency +* ``target``, array of labels assigned to ECG records +* ``unique_labels``, array of all possible target labels in dataset. + +Actions of EcgBatch allows e.g.: + +* load ECG records from wfdb or blosc format +* segment, flip and resample signals +* filter signals +* allocate PQ, QT, QRS segments +* dump results. + +If you use pipeline you don't have a direct access to the EcgBatch objects, but you can create an object with ``next_batch`` method of :class:`Pipeline <dataset.Pipeline>` class: + +.. code-block:: python + + from cardio import EcgBatch + import cardio.dataset as ds + + index = ds.FilesIndex(path="path/to/data/", no_ext=True, sort=True) + dtst = ds.Dataset(index, batch_class=EcgBatch) + + template_ppln = ( + ds.Pipeline() + .load(fmt="wfdb", components=["signal", "meta"]) + .wavelet_transform_signal(cwt_scales=[4,8,16], cwt_wavelet="mexh") + ) + + ppln = (dtst >> template_ppln) + batch = ppln.next_batch(10) # create instance of EcgBatch class with size 10 + +Other capabilities +------------------ + +Batch module also contains several submodules that support functionality of EcgBacth and not included in API. +You can find brief description of those submodules below. To learn more see the source code. + +ecg_batch_tools +~~~~~~~~~~~~~~~ + +Contains general methods for signal processing that are exploited in EcgBatch actions. +Most of those methods support multiprocessing and are written with ``numba``. +If you want to explore those methods or use them outside EcgBatch simply write + +.. code-block:: python + + from cardio.batch import ecg_batch_tools as bt + + +kernels +~~~~~~~ + +This submodule contains kernel generation functions for signal convolution. + + +utils +~~~~~ + +Miscellaneous ECG Batch utils. + +API +--- +See :doc:`Batch API <../api/cardio.batch>` \ No newline at end of file diff --git a/docs/intro/dirichlet_model.png b/docs/intro/dirichlet_model.png new file mode 100644 index 0000000000000000000000000000000000000000..eb7d1a6c4405ef67b91d588168c9e8bda293d3a4 GIT binary patch literal 24064 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 Bi!1;D literal 0 HcmV?d00001 diff --git a/docs/intro/fft_model.PNG b/docs/intro/fft_model.PNG new file mode 100644 index 0000000000000000000000000000000000000000..31286b929f16c102b4723598ba8ff2e2773c2f03 GIT binary patch literal 27702 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 literal 0 HcmV?d00001 diff --git a/docs/intro/hmmodel.png b/docs/intro/hmmodel.png new file mode 100644 index 0000000000000000000000000000000000000000..6339584331aa2ef0894b8124059dd3fa1f710830 GIT binary patch literal 57474 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 RX1EK0s-otzQU&w3{{>Kk60iUO literal 0 HcmV?d00001 diff --git a/docs/intro/intro.rst b/docs/intro/intro.rst new file mode 100644 index 0000000..570accc --- /dev/null +++ b/docs/intro/intro.rst @@ -0,0 +1,11 @@ +Intro +======== + +.. toctree:: + :maxdepth: 2 + :titlesonly: + + introduction + batch + models + pipelines diff --git a/docs/intro/introduction.rst b/docs/intro/introduction.rst new file mode 100644 index 0000000..97ea4ab --- /dev/null +++ b/docs/intro/introduction.rst @@ -0,0 +1,77 @@ +============ +Introduction +============ + +This section describes briefly capabilities of the CardIO framework. + + +:doc:`Batch <./batch>` +---------------------- +The main class the CardIO is EcgBatch. It contains the I/O and preprocessing :func:`actions <dataset.action>` that allow to load and prepare data for the modeling. + +.. code-block :: python + + from cardio import EcgBatch + from dataset import FilesIndex, Dataset + ecg_index = FilesIndex(path='path/to/ecg/*', no_ext=True) # set up the index + dtst = Dataset(index=ecg_index, batch_class=EcgBatch) # init the dataset with ECG files + +:doc:`Models <./models>` +------------------------ +This module contain model suited to classify whether ECG signal is normal or pathological, to annotate segments of the signal (e.g., P-wave). + +.. code-block:: python + + template_dirichlet_train = ( + ds.Pipeline() + .init_model("dynamic", DirichletModel, name="dirichlet", config=model_config) + .init_variable("loss_history", init=list) + .load(components=["signal", "meta"], fmt="wfdb") + .load(src='./path/to/taret/', fmt="csv", components="target") + .drop_labels(["~"]) + .replace_labels({"N": "NO", "O": "NO"}) + .flip_signals() + .random_resample_signals("normal", loc=300, scale=10) + .random_split_signals(2048, {"A": 9, "NO": 3}) + .binarize_labels() + .train_model("dirichlet", make_data=make_data, + fetches="loss", save_to=V("loss_history"), mode="a") + .run(batch_size=100, shuffle=True, drop_last=True, n_epochs=100, lazy=True) + ) + +:doc:`Pipelines <./pipelines>` +------------------------------ +Pipelines were designed to ease usage of exhisting models make final code simpler. + +.. code-block:: python + + from cardio.pipelines import hmm_predict_pipeline + res = (data >> hmm_train_pipeline(model_path)).run() + +Under the hood this function contains a list of actions: + +.. code-block:: python + + template_hmm_predict = ( + ds.Pipeline() + .init_model("dynamic", HMModel, "HMM", config=config_train) + .load(fmt='wfdb', components=["signal", "annotation", "meta"], ann_ext='pu1') + .wavelet_transform_signal(cwt_scales=[4,8,16], cwt_wavelet="mexh") + .train_model("HMM", make_data=make_data) + .run(batch_size=20, shuffle=False, drop_last=False, n_epochs=1, lazy=True) + ) + res = (data >> template_hmm_predict).run() + +Tutorials +--------- + +There are three tutorials: + +* `CardIO <https://github.com/analysiscenter/cardio/blob/master/tutorials/I.CardIO.ipynb>`_ +In this tutorail we briefly introduce some instances of `Dataset <https://github.com/analysiscenter/dataset>`_ and show capabilities of the CardIO's EcgBatch class. + +* `Pipelines <https://github.com/analysiscenter/cardio/blob/master/tutorials/II.Pipelines.ipynb>`_ +In this tutorial we show how to create pipelines, use them for preprocessing and add your custom action to the EcgBatch with ease. + +* `Models <https://github.com/analysiscenter/cardio/blob/master/tutorials/III.Models.ipynb>`_ +This tutorial shows how to embed models in pipelines to perform training and prediction. \ No newline at end of file diff --git a/docs/intro/models.rst b/docs/intro/models.rst new file mode 100644 index 0000000..b41dc75 --- /dev/null +++ b/docs/intro/models.rst @@ -0,0 +1,197 @@ +====== +Models +====== + +This is a place where ECG models live. You can write your own model or exploit provided models. + +We have a number of built-in :doc:`models <../api/cardio.models>` for ECG classification and annotation: + +DirichletModel +-------------- + +This model is used to predcit probability of atrial fibrillation. It predicts Dirichlet distribution parameters from which class probabilities are sampled. + +.. image:: dirichlet_model.png + +How to use +~~~~~~~~~~ + +.. code-block :: python + + dirichlet_train_ppl = ( + ds.Pipeline() + .init_model("dynamic", DirichletModel, name="dirichlet", config=model_config) + .init_variable("loss_history", init=list) + .load(components=["signal", "meta"], fmt="wfdb") + .load(src='./path/to/taret/', fmt="csv", components="target") + .drop_labels(["~"]) + .replace_labels({"N": "NO", "O": "NO"}) + .flip_signals() + .random_resample_signals("normal", loc=300, scale=10) + .random_split_signals(2048, {"A": 9, "NO": 3}) + .binarize_labels() + .train_model("dirichlet", make_data=make_data, + fetches="loss", save_to=V("loss_history"), mode="a") + .run(batch_size=100, shuffle=True, drop_last=True, n_epochs=100, lazy=True) + ) + +HMModel +------- + +Hidden Markov Model is used to annotate ECG signal. This allows to calculate number of +important parameters, important for diagnosing. +This model allows to detect P and T waves; Q, R, S peaks; PQ and ST segments. The model +has a total of 19 states, the mapping of them to the segments of ECG signal can be found in ``cardio.batch.ecg_batch_tools`` submodule. + +.. image:: hmmodel.png + +How to use +~~~~~~~~~~ + +.. code-block :: python + + HMM_train_ppl = ( + ds.Pipeline() + .init_model("dynamic", HMModel, "HMM", config=config_train) + .load(fmt='wfdb', components=["signal", "annotation", "meta"], ann_ext='pu1') + .wavelet_transform_signal(cwt_scales=[4,8,16], cwt_wavelet="mexh") + .train_model("HMM", make_data=make_data) + .run(batch_size=20, shuffle=False, drop_last=False, n_epochs=1, lazy=True) + ) + +FFTModel +-------- + +FFT model learns to classify ECG signals using signal spectrum. At first step it convolves signal with a number of 1D kernels. +Then for each channel it applies fast fourier transform. +The result is considered as 2D image and is processed with a number of Inception2 blocks +to resulting output, which is a predicted class. See below the model architecture: + +.. image:: fft_model.PNG + +How to use +~~~~~~~~~~ +We applied this model to arrhythmia prediction from single-lead ECG. Train pipeline we used for the fft model looks as follows: + +.. code-block :: python + + train_pipeline = ( + ds.Pipeline() + .init_model("dynamic", FFTModel, name="fft_model", config=model_config) + .init_variable("loss_history", init=list) + .init_variable("true_targets", init=list) + .load(fmt="wfdb", components=["signal", "meta"]) + .load(src='./path/to/taret/', fmt="csv", components="target") + .drop_labels(["~"]) + .replace_labels({"N": "NO", "O": "NO"}) + .random_resample_signals("normal", loc=300, scale=10) + .drop_short_signals(4000) + .split_signals(3000, 3000) + .binarize_labels() + .apply(np.transpose , axes=[0, 2, 1]) + .ravel() + .get_targets('true_targets') + .train_model('fft_model', make_data=make_data, + save_to=V("loss_history"), mode="a") + .run(batch_size=100, shuffle=True, + drop_last=True, n_epochs=100, prefetch=0, lazy=True) + ) + + +Below you can find a guide how to build your own model with Keras framework. More details you can find in our :ref:`tutorials <tutorials>` + +How to build a model with Keras +------------------------------- + +Any custom Keras model starts with base model :class:`KerasModel <dataset.KerasModel>`. In most cases you simply create +a new class that inherit KerasModel and define a sequence of layers within the _build method. +Once it is done you can include train and predict actions into pipeline. + +For example, let's build a simple fully-connected network. It will accept signal with shape (1000, ) and return shape (2, ). +First, we import KerasModel: + +.. code-block :: python + + from ...dataset.dataset.models.keras import KerasModel + +Second, define our model architecture. Note that _build should return input and output layers. + +.. code-block :: python + + class SimpleModel(KerasModel): + def _build(self, **kwargs): + ''' + Build model + ''' + x = Input(1000) + out = Dense(2)(x) + return x, out + +Third, we specify model configuration (loss and optimizer) and initialize model in pipeline. +We suppose that batch has a component named 'signal' (this will be our input tensor) and a component +named 'target' (this will be our output tensor). + +.. code-block :: python + + model_config = { + "loss": "binary_crossentropy", + "optimizer": "adam" + } + + template_simplemodel_train = ( + ds.Pipeline() + .init_model("static", SimpleModel, name="simple_model", config=model_config) + .init_variable("loss_history", init=list) + ... + some data preprocessing + ... + .train_model('simple_model', x=B('signal'), y=B('target'), + save_to=V("loss_history"), mode="a") + .run(batch_size=100, shuffle=True, + drop_last=True, n_epochs=100, prefetch=0, lazy=True) + ) + +From now on ``train_pipeline`` contains compiled model and is ready for training. + +Other capabilities +------------------ + +Aside of the classes described above, module ``models`` contains other submodules and files. + +Training notebooks +~~~~~~~~~~~~~~~~~~ + +There are example notebooks for each model described above in ``models``. Those notebooks are used as tests and also provide examples of use. + +keras_custom_objects +~~~~~~~~~~~~~~~~~~~~ + +This submodule contains custom layers used in keras models. +To use those layers you can write + +.. code-block:: python + + from cardio.batch import keras_custom_objects as kco + +layers +~~~~~~ + +``layers`` submodule stores helper functions to create tensorflow layers and blocks. +The usage is similar to keras_custom_objects: + +.. code-block:: python + + from cardio.batch import layers + +metrics +~~~~~~~ + +In this module you can find hepler functions to calculate metrics of existing models. + +.. code-block:: python + + from cardio.batch import metrics + +API +--- +See :doc:`Models API <../api/cardio.models>` \ No newline at end of file diff --git a/docs/intro/pipelines.rst b/docs/intro/pipelines.rst new file mode 100644 index 0000000..ce42a3c --- /dev/null +++ b/docs/intro/pipelines.rst @@ -0,0 +1,36 @@ +========= +Pipelines +========= + +This module contains pipelines that we used to train models and make predictions. You can use them as-is to train similar models or +adjust them in order to get better perfomance. + +How to use +---------- +Working with pipelines consists of 3 simple steps. First, we import desired pipeline, e.g. dirichlet_train_pipeline: +:: + from cardio.pipelines import dirichlet_train_pipeline + +Second, we specify its parameters, e.g. path to file with labels: +:: + pipeline = dirichlet_train_pipeline(labels_path='some_path') + +Third, we pass dataset to the pipeline and run caclulation: +:: + (dataset >> pipeline).run(batch_size=100, n_epochs=10) + +Result is typically a trained model or some values stored in pipeline variable (e.g. model predicitons). + +Available pipelines +------------------- +At this moment the module contains following pipelines: + +* dirichlet_train_pipeline +* dirichlet_predict_pipeline +* hmm_preprocessing_pipeline +* hmm_train_pipeline +* hmm_predict_pipeline + +API +--- +See :doc:`Pipelines API <../api/cardio.pipelines>` \ No newline at end of file diff --git a/docs/make.bat b/docs/make.bat new file mode 100644 index 0000000..526f37d --- /dev/null +++ b/docs/make.bat @@ -0,0 +1,36 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=python -msphinx +) +set SOURCEDIR=. +set BUILDDIR=_build +set SPHINXPROJ=CardIO + +if "%1" == "" goto help + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The Sphinx module was not found. Make sure you have Sphinx installed, + echo.then set the SPHINXBUILD environment variable to point to the full + echo.path of the 'sphinx-build' executable. Alternatively you may add the + echo.Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.http://sphinx-doc.org/ + exit /b 1 +) + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% + +:end +popd diff --git a/pylintrc b/pylintrc new file mode 100644 index 0000000..315cf79 --- /dev/null +++ b/pylintrc @@ -0,0 +1,19 @@ +[MASTER] +extension-pkg-whitelist=numpy +init-hook='import sys; sys.path.append(".")' + +[FORMAT] +max-line-length=120 +max-attributes=8 +max-args=8 +max-locals=20 +good-names=ax,im,ix,a,b,_,n,s,fs,i,j,k,t,x,y,z,lc,rc + +[MESSAGE CONTROL] +disable=no-value-for-parameter,no-self-use,too-few-public-methods,unsubscriptable-object,no-method-argument,no-member + +[TYPECHECK] +ignored-modules=numpy, keras + +[MISCELLANEOUS] +notes= diff --git a/requirements-shippable.txt b/requirements-shippable.txt new file mode 100644 index 0000000..e202b6e --- /dev/null +++ b/requirements-shippable.txt @@ -0,0 +1,5 @@ +dill +wfdb +PyWavelets +hmmlearn +Keras>=2.0.0 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..bd0b987 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,7 @@ +dill +wfdb +pytest +PyWavelets +hmmlearn +tf +Keras>=2.0.0 diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..d37167b --- /dev/null +++ b/setup.py @@ -0,0 +1,54 @@ +""" +CardIO is a library that works with electrocardiograms. +Documentation - https://analysiscenter.github.io/cardio/ +""" + +from setuptools import setup, find_packages +import re + +with open('cardio/__init__.py', 'r') as f: + version = re.search(r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]', f.read(), re.MULTILINE).group(1) + + +with open('docs/index.rst', 'r') as f: + long_description = f.read() + + +setup( + name='cardio', + packages=find_packages(exclude=['tutorials']), + version=version, + url='https://github.com/analysiscenter/cardio', + license='Apache License 2.0', + author='Data Analysis Center team', + author_email='cardio@analysiscenter.ru', + description='A framework for deep research of electrocardiograms', + long_description=long_description, + zip_safe=False, + platforms='any', + install_requires=[ + 'numpy>=1.10', + 'wfdb>=1.2.2.', + 'dill>=0.2.7.1', + 'pywavelets>=0.5.2', + 'scikit-learn>=0.19.0' + ], + extras_require={ + 'tensorflow': ['tensorflow>=1.4'], + 'tensorflow-gpu': ['tensorflow-gpu>=1.4'], + 'keras': ['keras>=2.0.0'], + 'hmmlearn': ['hmmlearn>=0.2.0'] + }, + classifiers=[ + 'Development Status :: 4 - Beta', + 'Intended Audience :: Developers', + 'Intended Audience :: Science/Research', + 'License :: OSI Approved :: Apache Software License', + 'Operating System :: OS Independent', + 'Programming Language :: Python', + 'Programming Language :: Python :: 3', + 'Programming Language :: Python :: 3.5', + 'Programming Language :: Python :: 3.6', + 'Topic :: Scientific/Engineering' + ], +) diff --git a/shippable.yml b/shippable.yml new file mode 100644 index 0000000..5676c31 --- /dev/null +++ b/shippable.yml @@ -0,0 +1,29 @@ +language: none + +env: + global: + - DOCKER_ACC=analysiscenter1 + - DOCKER_REPO=ds-py3 + - TAG="latest" + +build: + pre_ci_boot: + image_name: $DOCKER_ACC/$DOCKER_REPO + image_tag: $TAG + ci: + - pip3 install -r requirements-shippable.txt + - find ./cardio -not -path "./cardio/dataset/*" -iname "*.py" | xargs -r pylint3 -rn --rcfile pylintrc + - pytest -v --junitxml=shippable/testresults/pytests.xml + +integrations: + hub: + - integrationName: DockerHub analysiscenter.ru + type: docker + + notifications: + - integrationName: Slack analysiscenter.ru + type: slack + recipients: + - "#commits" + on_success: always + on_failure: always diff --git a/tutorials/Code_from_article.ipynb b/tutorials/Code_from_article.ipynb new file mode 100644 index 0000000..1b8803b --- /dev/null +++ b/tutorials/Code_from_article.ipynb @@ -0,0 +1,384 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook is a part of article [CardIO framework for deep research of electrocardiograms](https://medium.com/data-analysis-center/cardio-framework-for-deep-research-of-electrocardiograms-2a38a0673b8e) and contains code blocks from this article." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Some general imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "env: CUDA_VISIBLE_DEVICES=0\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "sys.path.append(\"..\")\n", + "\n", + "import cardio.dataset as ds\n", + "from cardio import EcgBatch\n", + "from cardio.models.metrics import classification_report\n", + "\n", + "%env CUDA_VISIBLE_DEVICES=0\n", + "import tensorflow as tf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create indices from filenames" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "index = ds.FilesIndex(path=\"../cardio/tests/data/*.hea\", no_ext=True, sort=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check which indices are in list of indices" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['A00001' 'A00002' 'A00004' 'A00005' 'A00008' 'A00013']\n" + ] + } + ], + "source": [ + "print(index.indices)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "eds = ds.Dataset(index, batch_class=EcgBatch)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Generate batch" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "batch = eds.next_batch(batch_size=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Fill batch with data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "batch_with_data = batch.load(fmt=\"wfdb\", components=[\"signal\", \"meta\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot short segment of ECG with index 'A00001'" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAEYCAYAAABBfQDEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x7f64c4cd7208>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "batch_with_data.show_ecg('A00001', start=10, end=15)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For detection of QRS intervals, P-waves and T-waves we need to train model first.\n", + "\n", + "Download the [QT Database](https://www.physionet.org/physiobank/database/qtdb/) with labeled ECGs. Let ```SIGNALS_PATH``` be the folder where database is saved." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from cardio.pipelines import hmm_preprocessing_pipeline, hmm_train_pipeline\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "SIGNALS_PATH = \"path_to_QT_database\" #set path to QT database\n", + "SIGNALS_MASK = os.path.join(SIGNALS_PATH, \"*.hea\")\n", + "\n", + "index = ds.FilesIndex(path=SIGNALS_MASK, no_ext=True, sort=True)\n", + "dtst = ds.Dataset(index, batch_class=EcgBatch)\n", + "\n", + "pipeline = hmm_preprocessing_pipeline()\n", + "ppl_inits = (dtst >> pipeline).run()\n", + "\n", + "pipeline = hmm_train_pipeline(ppl_inits)\n", + "ppl_train = (dtst >> pipeline).run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Save model" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "ppl_train.save_model(\"HMM\", path=\"model_dump.dll\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's make prediction with hmm model" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from cardio.pipelines import hmm_predict_pipeline\n", + "\n", + "res = (eds >> hmm_predict_pipeline(\"model_dump.dll\")).run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot ECG signal with detected QRS intervals, P-waves and T-waves" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAEYCAYAAABBfQDEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nEEIIIYQdCZCFEEIIIYSw8/8BwAVQlebphYUAAAAASUVORK5CYII=\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x7f64c4ccddd8>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "batch = res.get_variable(\"batch\")[0]\n", + "batch.show_ecg('A00001', start=10, end=15, annotate=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For detection of atrial fibrillation we need to train another model.\n", + "Download the PhysioNet short single lead ECG database from [here](https://physionet.org/challenge/2017/). Let AF_SIGNALS_PATH be the folder where database is saved." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from cardio.pipelines import dirichlet_train_pipeline\n", + "\n", + "gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.33, allow_growth=True)\n", + "\n", + "AF_SIGNALS_PATH = \"path_to_PhysioNet_database\" #set path to PhysioNet database\n", + "AF_SIGNALS_MASK = os.path.join(AF_SIGNALS_PATH, \"*.hea\")\n", + "AF_SIGNALS_REF = os.path.join(AF_SIGNALS_PATH, \"REFERENCE.csv\")\n", + "\n", + "index = ds.FilesIndex(path=AF_SIGNALS_MASK, no_ext=True, sort=True)\n", + "afds = ds.Dataset(index, batch_class=EcgBatch)\n", + "\n", + "pipeline = dirichlet_train_pipeline(AF_SIGNALS_REF, gpu_options=gpu_options)\n", + "train_ppl = (afds >> pipeline).run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Save model" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "model_path = \"af_model_dump\"\n", + "train_ppl.save_model(\"dirichlet\", path=model_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from cardio.pipelines import dirichlet_predict_pipeline\n", + "\n", + "pipeline = dirichlet_predict_pipeline(model_path, gpu_options=gpu_options)\n", + "res = (eds >> pipeline).run()\n", + "pred = res.get_variable(\"predictions_list\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get predicted probalilities for artrial fibrillation" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['0.02', '0.02', '0.87', '0.61', '0.03', '0.02']\n" + ] + } + ], + "source": [ + "print([\"{:.2f}\".format(x[\"target_pred\"][\"A\"]) for x in pred])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.6.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tutorials/I.CardIO.ipynb b/tutorials/I.CardIO.ipynb new file mode 100644 index 0000000..4819020 --- /dev/null +++ b/tutorials/I.CardIO.ipynb @@ -0,0 +1,350 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Preliminary: getting ECG data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this and following tutorials you will work with ECG data throught CardIO framework. \n", + "\n", + "We suggest loading ECG data from the PhysioNet database of short single lead ECG recording. Follow this [link](https://physionet.org/challenge/2017/) and find archive \"training2017.zip\" or use [direct](https://physionet.org/challenge/2017/training2017.zip) link. However, if you do not want to load large dataset now, you can find several ECGs from that database in folder cardio/tests/data (this folder is icluded in CardIO repository).\n", + "\n", + "The PhysioNet archive contains 8.528 ECGs in [wfdb](https://www.physionet.org/physiotools/wpg/wpg_35.htm) format. Each ECG has a unique index ranging from \"A00001\" to \"A08528\". According to wbdf format ECG record consists of several files with the same name but different extensions. We will work with files with ```.hea``` and ```.mat``` extensions. File ```.hea``` contains signal, while ```.mat``` contains meta information about the signal (e.g. sample rate). \n", + "\n", + "Since the PhysioNet acrhive was prepared for arrhythmia classification challenge, it also contains REFERENCE.csv file, where each ECG index is labeled with one of four classes:\n", + "* Normal rhythm\n", + "* AF\n", + "* Other rhythm\n", + "* Noise\n", + "\n", + "Read [here](https://physionet.org/challenge/2017/) more about PhysioNet database." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create a dataset of ECGs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In Notebook 1 we explain how to create a [dataset](https://github.com/analysiscenter/dataset/) of ECGs and give very basic examples how to use dataset. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Index ECG" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Working with ECG begins with ```FilesIndex```. ```FilesIndex``` contains index and location of each ECG record we want to process. \n", + "\n", + "Let all ECGs be stored in wfdb format in folder with path '../cardio/tests/data/' (if you cloned the CardIO repository from [Git](https://github.com/analysiscenter/cardio), this path will actually contain several examples of ECGs). Let's create a new ```FilesIndex``` with all ECGs from this folder." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"..\")\n", + "\n", + "import cardio.dataset as ds\n", + "index = ds.FilesIndex(path=\"../cardio/tests/data/*.hea\", no_ext=True, sort=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now each ECG is indexed with its filename. Indices are stored in ```index.indices```:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['A00001' 'A00002' 'A00004' 'A00005' 'A00008' 'A00013']\n" + ] + } + ], + "source": [ + "print(index.indices)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Init dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have ```index``` that knows which ECGs we want to process. CardIO processes data grouped in batches of class [EcgBatch](https://analysiscenter.github.io/cardio/intro/batch.html). To generate proper batches we create a dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from cardio import EcgBatch\n", + "eds = ds.Dataset(index, batch_class=EcgBatch)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the same result can be obtained in a shorter way:\n", + "```python\n", + "from cardio import EcgDataset\n", + "eds = EcgDataset(path=\"../cardio/tests/data/*.hea\", no_ext=True, sort=True)\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Start using dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's generate a first batch of some size, say 6:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "batch = eds.next_batch(batch_size=6)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "However ```batch``` still does not contain any data, only indices and paths to ECGs. To fill it with data we need to apply load action. Next section shows how to apply actions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Apply actions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Any preprocess typically begins with loading of data. Therefore, we start with an example how to apply action [```load```](https://analysiscenter.github.io/cardio/api/cardio.batch.html#cardio.batch.EcgBatch.load). \n", + "\n", + "Note that paths to ECGs are already stored in batch, so simply inticate data format, which is wfdb, and components of wbdf file we want to load. We load components ```signal``` and ```meta```:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "batch_with_data = batch.load(fmt=\"wfdb\", components=[\"signal\", \"meta\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now ```batch_with_data``` contatains loaded ECGs. Any ECG record can be accessed by its index, e.g. ```batch_with_data['A00001']```. ECG components, signal and meta, can be accessed as ```batch_with_data['A00001'].signal``` and ```batch_with_data['A00001'].meta``` correspondingly." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's plot signal from ECG with index```'A00001'```:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAEYCAYAAABBfQDEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzsvXecJcV1NvzU3Mmbc4INwJIRApZFRgLGSka2LFnWZyvY\nfpEtCQfJQX5tv0hYCQUjIQkrIFmAULCQkJGFhGBZ2IW9G9nM7myYDbOzYWZ2cg433/r+6K7u6r7d\nd7qqerrvnenn99u9M3f69KnuSk+dOucUoZQiQoQIESJEiBAhQoQIGirCLkCECBEiRIgQIUKECKWE\niCBHiBAhQoQIESJEiMAhIsgRIkSIECFChAgRInCICHKECBEiRIgQIUKECBwighwhQoQIESJEiBAh\nAoeIIEeIECFChAgRIkSIwCEiyBEiRIgQIUKECBEicIgIcoQIESJEiBAhQoQIHCKCHCFChAgRIkSI\nECECh8qwCxAkFi5cSFevXh2ozrGxMcyYMSNQnREKEdVD+IjqIHxEdVAaiOohfER1UBoIox4OHDjQ\nSyldNNF1oRJkQsgTAN4JoJtSer3D3wmAbwL4fQDjAD5EKT2o/+0eAP+uX/pFSumPJ9K3evVq7N+/\n36/ie0I8HkdDQ0OgOiMUIqqH8BHVQfiI6qA0ENVD+IjqoDQQRj0QQs57uS5sF4sfAbi7yN/fAWCt\n/u9eAN8DAELIfACfBXAbgPUAPksImTepJY0QIUKECBEiRIgwLRAqQaaUbgPQX+SSdwP4CdWwG8Bc\nQsgyAL8HYBOltJ9SOgBgE4oT7QgRIkSIECFChAgRPKHUfZBXAGjlfm/Tv3P7vgCEkHuhWZ+xZMkS\nxOPxSSmoG0ZHRwPXGaEQUT2Ej6gOwkdUB6WBqB7CR1QHpYFSrodSJ8jKoJQ+CuBRAFi3bh0N2tcl\n8nMqDUT1ED6iOggfUR2UBqJ6CB9RHZQGSrkewvZBngjtAC7lfr9E/87t+wgRIkSIECFChAgRlFDq\nBPlZAP+HaHgDgCFKaQeAFwG8nRAyTw/Oe7v+XYQIESJEiBAhQoQISgg7zdvPATQAWEgIaYOWmaIK\nACil/wVgA7QUb83Q0rz9pf63fkLIFwDs02/1AKW0WLBfhAgRIkSIECFChAieECpBppR+YIK/UwAf\nc/nbEwCemIxyRYgQIUKECAwjyQwGxjJYuaA+7KJEiBAhIJS6i0WECBEiRIgQKt73/d2486EtYRcj\nQoRJxw92nMUjW5rDLkZJICLIETzjQt84BsfTYRdDGK9dGMDGs5mwixEhQoQyxfGO4bCLECFCIPjC\nc8fx0Isnwy5GSSAiyBE8486HtuBtD28LuxjCeM93d+Gpk/LEftPxLvzqYJuPJYoQIUKECBEilDKm\nfB7kCP6iZyQVdhECx0d/sh8A8Mc3XxJySSJEiBAhQoQIQSCyIEeIECFChAgekM/TsIsQQce9P9mP\n5xs7wi5GhCmMiCBHmDbQkqJE8Iq2gXF89jdHkYtIQYQIAICoJ5QOXjrehY/97GDYxYgwhRER5AjT\nBhE/FsO/PH0YP371PPafi1KMR4gARIvsCBGmEyKCHCEwtA8mQrVGRlObGAgIACAbWZAjuCCfp1h9\n3/P4793nwy5KIJjqPSGZyeGZ19qihUCECIgIcoSA0DWcxBsffAVfffFEaGUIa9B/9UwfBsbKLz1e\nZUwjyJlcPuSSRChVjCSzAICvvhBev47gH7668SQ+8YvD2HqqJ+yiTBpGU1kcah0MuxgRygARQS5D\npLN5tA2Mh10MIYwktTzEm451hVaGMOhxMpPDBx7bjft+1RiCdjUQQsIugjTO9Y5h+2n5ST5+shvf\neeW0jyWamsixRWf5NhUhTHXDas+olqVoKDF188b/zX8fwB89shOpXGlXZj5Pkczkwi7GtEZEkMsQ\nn/zVEbzpK1swlsqGXRTPqNDJVphDUhiTG3NPeLmpO3jlIeP7W8/ghSPhRJk3fC2Ov/jBXmn5D/1w\nH7720ikfSzQ1wXZlpjpxZKBl4mTx870X8NTeC8JyFfpCJz+FK/Rwm2Y9zpb4xtjnf3sMV396Y5Q5\nJUREeZDLEGz7ayyVxYyaqAq9IozJbSpPNBPhP/Rt93MP/kHIJYkwWWBz93Rp5+XymJ/81REAwPvX\nrxSSi+kMudS9qlTc5dgzljrvfHKPtsDJ5imqK6bJFk2JIbIglyGqmG9oqfdwDqVQ0jAmt3KZUEsN\n5/vG8MiW5ihYqMTBFp1RNU0NxPSdvlK3Wqq0N+MZS/sRjV3X6bL4LEVEBLkMUVEmg1iE8k4LFWbZ\nP/Lj/XjoxZPoGEqGVoYIHjDNLMhTHWxuyZV4faqUjoVWlPrYXKGzsyiLUHiICHIZo5xiqMqoqL6C\njcHlPMSFEazHJoUoSKW0wdp1OY1FKihxTqWMCsPForQfdDosyNhiJSvh7/LT3efx+PYWv4s07RAR\n5DJEqa98nVAKJQ7jtU2HgXwywPhW9PZKG9OtecvEMSTSObT0jE5CafxHTGcEQY1blFK8dKxTmASq\nFK9cjBZsDJRZq/z7r4/ii883+Vqe6YiIIJcxynFyCtPQFEaQXhlWUYRpiLFUVspaXy5ZHQCgdzSF\nz/7mqJFyUgYyY+7Hf3YQb/76VqRLPW0CuGxDAVXry03duPe/D+C78TNCcioEvnxarIZyNIhNFUQE\nuYwR9RsxREF6ESI447rPvoi7HtoiLBfGTvzq+57HR368T1juF/ta8eNXz+N/D7RJ65Z53B3NvQCm\n/m7SwFha2BLcrx+gdKE/+Lz+QdXGY9ta8J+b5VNGTu1WU9qICHIZgnWYchpwS6GoYRTBzBNbAi+g\njGD4toZaiumFruGUsAxr1yTgmtoskVe8b1QjY1HQkztkh6lkJoebvrAJn332mJAc83kWDThXc7EI\nNvPKlzY04T83ix86VI7z/FRDRJDLGOXUbVQIYjKTw/WffREbFA+dCIOkllMdlSLK+TS/6QCVLnWh\nbxw9I+KkXBZ+NCWVMaSceI7ou0rp7iPPHrooJMd8nkWzZoTlYhGKoaNM2k33SBKr73see8/2h10U\n3xAR5DIE66PltLJUKWnPSAqjqSy++Nzx0Mogi3Kqo1JCOVvcW3pG8UeP7JzSx/XaIUM+73xoC279\n0mb/CzOJUCJX5cJ0JGAcMCLYbyskcxKrkVw5uf94oQlrPrkh8LGpXFrNwfMDAIDHplD2jIgglzHK\niUOolLXCp1OEwvRBLqOqKkCogZXl1Mh1fOeVZhxqHcSm412B6v1e/Aw+/1uxLW5VlGH1+JIBQQbl\n4NkhS+JZPw3KfcUPw4PoHX648xwAIBFw6slyMbLUVMYAoCyCUb0iVIJMCLmbEHKSENJMCLnP4e8P\nE0IO6f9OEUIGub/luL89G2zJw0UYic5VdRmdfJrtmJfH0Fa6UH1/YRBs87jeYCeKr2w8YUziQaGc\nrKJm6kAVhqwgKtgWs7k87n/mCFpDCGATBS34YZL1heCDXK37gwRFAA3jSvl0MQBTKyd6ZViKCSEx\nAI8AeBuANgD7CCHPUkqNfXRK6Se46/8ewE3cLRKU0tcHVd5SguliEbzOsOR9QRh5kMvBbFTC8KPd\nTaUBu9RQEv3aI3zxQVYYRESHgsb2ITy55wKaOobxq797o7ReEcgGW1LGGQPqa0q+4Mq6FW8gqi9Y\nddIop8WyV4RpQV4PoJlS2kIpTQN4CsC7i1z/AQA/D6RkZYIgG6TyoKJwB7+sgFOxA09VUIef1O4T\nYTLAdoaiNYgHSFosE5ngdiKkXSyg1g5E5fyYEkRvYVie1VULodyMLFNpLAjNggxgBYBW7vc2ALc5\nXUgIWQVgDYBXuK9rCSH7AWQBPEgp/bWL7L0A7gWAJUuWIB6Pq5dcAKOjo77rTKa0yO+9e/ehc3ZM\nSDado6iOiTdh/uhRmec5N6T5bY2PjwvL94xrE0QylVJ6lzt27MTMavnuK6O7Wy87qJx8mOjvTwAA\nGhsPI39Rfqhgzy3SFxIJTfeePfvQNkt+HR+Pxw2XB1l5UXR2av3z5MmTiI+JBay0j+Yxkqa4er5Y\nv+ZRrMwT1YHo83aMau07l8tJt++g5FpbtXppPnMG8XzrBFc7Q2YMyeuuNtt37DBkvfSF88M5z9e6\nQVTuYrv2jk6fPo146pxnuZG0Th7zeSGdxy9mAQDd3V1CcsNp+fkom9V0jo2JzUW5nFYfO3buxGyJ\neUS0nLm8pm/37t04Uy83BqrMOaKyjd3ae+3r7xeSnQyO5BfCJMgieD+AX1JKee/4VZTSdkLIZQBe\nIYQcoZQWHMdDKX0UwKMAsG7dOtrQ0BBIgRni8Tj81lmzazOQSuGWdetw3fI5nuU2He/CvT/Zj2c/\n/ka87pK5QjrT2Tzw0gsAIPU8R9qGgFd3oL6+Xlj+Qt84sG0Lampq5N7lxucBALe/8Y2YP6NaWl5G\n97neMWBbHCBy8mHi8eY9QF8vbrzxRtyxdpH4DWzvTaQv1O3bAoyPY92tt+KqpbOkdd95112oiklM\nLgp1/lzPYaC9DVdfdTUabr1USHb1fZrecw/+gbBeL2V2rQPJ523uHgV2bEVlZaX4u5J9x5Jyu8ab\ngHMtuPyyy9Fw1+VSOmXGkIrNLwD5vEXWS1842j4E7NqBmTNnoqHhDqnyir6jzYNHgNYLuHLtWjT8\nzmrPcn2jKeCVzaiIVQjpHDrUDjQewuLFS9DQcNPEAjp6dX2A+DPGtrwIZLOYMUNsLoq9shHI5XD7\n7bdj4cwa7wol6yL2sqbvttvegJUL6oVkVcYvWdlcUxdwcD8WzJ+Phob1nuUmgyP5hTBdLNoB8LPH\nJfp3Tng/bO4VlNJ2/bMFQBxW/+RpAdFtpu2newCY6ViEdClvdav47vnkYhGCw2ReMiCklBBm2ZXb\nnbIPs8INptJeoyvKr2GHlQdXdhwLshnJPh7bYAzqwJgwgvTY5UGNh2zsK5csFlMRYRLkfQDWEkLW\nEEKqoZHggmwUhJCrAcwD8Cr33TxCSI3+80IAbwSgliS3jCCbB9nMVSmvUxbmACqhW0217/cpdZ1+\nI4wB2mjjiu6Xkd/55KKc5m4/qFsY+XdDgWBEY9D9zI8gPdk7RHmQpw9Cc7GglGYJIR8H8CKAGIAn\nKKXHCCEPANhPKWVk+f0AnqLWVnkNgO8TQvLQSP6DfPaL6QLRfhoj8umnwrTE+WWFDTMPcjkjzEcI\n34Isnv1gKtS5V0yjR1VGWeX0ljWvBoRwx6SA9ZVTu8HUOv00VB9kSukGABts333G9vvnHOR2Abhh\nUgtXwmDdRdSyp9Ju1V0sFGTLa3ywgA1u5ThmGHUepotFyHVfxk0vEJRjFouwDgqZym3J2CEMqCEo\nHTWtmF846DGpXJJYhD1WTwaik/TKGEG2xzAtyOWc5i3MMaNnJIW192/AaxfEfc55lLObQqg+yNMA\nZfV62AFLKiknA4yloAGTTgtK3sXCh3tIywXzrOYzllMnm1qICHIZwjgRKsDZSdUPtSQsLyGMM2Fa\n2Ha39CGTo3h8+1kpeRZwE/CBcAD8C1AJc+ejnKyqsigrguwHQrA+l8Puk0qMiZy+4Bc5YZ1sN+36\nWAkhIshlCNPFInidYcj7lsXCl7sI6gxxcKvUgzKzkgyXTSRhvrew/c5l5MvZ4i4K41nLgMT5AZma\nZQS3HLIRlE3gWkhuMkDw42G5uFgwTKWhICLIZYwgxySqaEVkpwHJOPD7ZcEMY34Kc1KsYFlLVDNB\nhPgMYS7MNPkym50CRhlwPgNsRyQ0H+SyeldiMN1BBF0zQvADVs1iEfTJdtEYFB4iglyGkE3zpjao\nhBik59MAEYoPcgmMbbJbtIYV17+iSJRB1bWnBCogQkkgbFcF8cQQ5dN2A3c7UPJ1sX2WOMJwcZNB\nmbxOIUQEuYwRqAU5xK1uk6iF5wddjvDreaXcDHxSrmqsUbYgy9xA0ppWjijHLBYqCCVIL4S3K/qU\nQZN5P4y48u4k6ro96TE+y2vimkrDXkSQyxiiJESl4aoH6alksVBSbd7Hn9sIwSAQoYwafpEX8Tfn\n34IqWhSVMqbb+1V5XmGCLK8qcAQdpKd2UIhcbIUpVz7+1hHUEBHksgSL8BeUCjGTRCkE6YWBUii6\nsouFxDP4dzy46g1C1j/FUU6vJ8zUYDKyYY574j7IwTLkcN2+pra+CCYiglzGCHIl65dFMNSjpkMY\nafzegh4YS+MTvziE3tHUhNf6tUWr4GWgDHUXC1XfeXn5KbTT6Aoa8A5J2D7lQe6ElRMxUrUgi59W\nGd6OZNDVUi4uFmH3zclARJDLEGaQXpA61ZSZrgYKsqpEL4T+67fKb758Gs+81o6NRzs965a2ILMt\nxVAtyOG6WMileZs+CPpZVca8sHwjZd2FwjiFU76/lI/bARubZMeWoC37U5B3lg0iglzGCHLFFuZO\ndzkPEJNV9lR24tBm/3y3g/dBNnWXt/xUR/DbzeHGMgSZ5i3M/LfC/rkBl3U6BOkxlLOLYbkjIshl\njPLKYqEysfljSQnFguyzFai6UuuyGQ/JjRmxDeO9hZlBwyofXnDp9ECw76fcDk0A+GwEgnJhtj1B\n3YaLheRgE2QKPHViHFC9UMtHycMs59RxLosIcojoG03hmdfapOVlV5Yyrgp+HTUtp5vJqiGUPMg+\n34/NP+Pp3MS6FX2QQ82bzbZBQ8y/rYqplO7IDSYxCkpf2D7IwckGnRmChzCZD3qh5ENu4DAOKSkH\nfbIol3KKoDLsAkxnfOxnB7G7pR/r1yzAirl1wvLlddS0ugVZFWF0YOMEQZ+muVRGmxlGkpkJrzUe\nV9oH2XYfAfjWNkPwIfZR/ZRHOU2KfpB4qXHMsAQK+iCH2PpET4tjhFU42E7yGdXmE0k522dQKJdd\nrHIppwgiC3KI6B1NAwDGUlkhOaOjBtggVY/XVAuq0D5VI+XD6L5+60xmNMvxaNJ7m5F+a2xil6g8\nZdcG26f8fYJvt1NxonBD0M+qYkEOu1rKKYtFUBbkMK24pe6DLJuvOSyUSzlFEBHkEFFZoVEXL/6k\nThAfxMKDylZsqaS5kSOK/pYhk9NuOOphURUmUfPLghx2HuQSaXolC/Z6gjsgQv0eKutsuawmVEo2\nnO6rVlbRVys7L4S5eIiyWDhDJVNVqSIiyCUAeR/R4HpOuEF6arr9KINsOfwm9zl9L9MLQWZQtrzL\nPIJPrhFh+yBLZfBQ1FlOkLcAygn6QU7UfOtVZAXdFqgke/QBwsaXgNuBH+NqqVuQGcL2u/eKcgyg\nnQgRQS4ByHb2IBukcpCeiqxfBDkEeaPsPs1xWb3Shz24WKgczgLwW3ziT14qJ+mFLV8O8OPYXnGd\ncvrCnoRVdpHEMzWEB9HnLMt2IO2LHFmQnTAVXcsighwi5FPiyG2DmXoldMqpMuUVOo9fWzdhWMH9\nHjOyzMXCU5BeeO/NL8tt6D7IMjKShMh6j+AmGxWyYRo5xRqZ9AIqbBcLdfWe4fcpnF6gSlhF24E8\nsQ7BguxDv5ZBqbgYTgRVg0wpIiLIJQD5QSlIF4vg3RMMWSXN/t1JztPA3zpiFmQhFwtJXSpEz6+0\ngGGfpKekW0FWjbQKWv9CcH+S1Rj2drPKYlHcr9efRaIMZMsq64MsijAPCgkaYS20g9pFKGVEBDlE\nqK60gpwsVAckNbJQKhbk4HXaYfggC7hYqELJtSQE3b7KBzjB+CUr2leVyLi0e5is72n5QjjNWwgW\nOTbGitZP8MF2wTNk2WBLWfixE+XH7pBnXZKp/koZEUGO4BFqo4JJcsV7j2mdCDfNm4ovrl9jBrMg\nj6VzSE9w3DQb4CpkXXmkpJhun6z1IbjFOJZDSndYeoOz/ASdpitsC7JMzci6xAV9CAvAkTJxSSl9\nsvUZ6lHTQfsgK/VPBdlJvr4cECpBJoTcTQg5SQhpJoTc5/D3DxFCegghh/R/H+H+dg8h5LT+755g\nS14aCNbFIjx5/7JYBC/vdw3luJmhZzTlTbfsQSHGxB7UdOl0n3BdLJS21EMgnrz+IHWJNrFyJcjB\n1ov6s0pniZDehRD1QZZDqK5TAetW2+FRkBXeRfDHkFVKCO0kPUJIDMAjAN4GoA3APkLIs5TS47ZL\nf0Ep/bhNdj6AzwJYB60NHNBlBwIoum9glgHpyUIwfXJYWzWA/ETK6y7LrRufB1MWpAcAXcPJoicw\n+nYCoYSMX0TGjyNlVRAeyQ1Obxg+jtLP58M7DcuyL+22oKCT0mByzwed5i2MhZK8dV1Vb3kstKei\nCTlMC/J6AM2U0hZKaRrAUwDe7VH29wBsopT266R4E4C7J6mckw7xI0itn0FA3ZLHXCzkZVURRhCB\n/0F6ecyfUQ0A6B72ZkFWXtHLWFH9svqryqv71UjopLKi3D0UZAU1+3E6nWi/DjM4SwXB7oTJWn9N\nOdndBNkgPVEE7aJjuYesnPSzyi4m5RHknBf27s5kIDQLMoAVAFq539sA3OZw3XsJIXcCOAXgE5TS\nVhfZFU5KCCH3ArgXAJYsWYJ4PK5ecgGMjo666hwdTQAA9u8/gP7mmOd7ZjJaiq+mpibER5o9y7W2\naYTqzJkziOcueJYDgAvDOeNnmXd47KIWVFbsfbjhSJcmm0wklOpv37796Jwlvybcum0bamJiTKCx\nWyt7Pp/3pe0NDCUwKwb0A9hx4Ahqe0+4XtvUqrWTzs5OxOPimyvDw1r7bDp5AvGxM0KyvQnT9Mue\nW6TuUyntGPYjR46gqrtJSDeP3Xt2o6Vevs537tqFebVi8t3dSQDAyZMnER9vkdIr09YM2a3bUO0i\n61QHiaw5sYm20cN6+06n00Kysjr7k4XtyitaL2ht6kxLC+KkTUiWYd++fegQHEMYbzh48CBGzmrj\nvJe+cKRTe7fDw8NCz8oTlXg8jliF93bU0anNES2C76ipT5sfMhmxdnDqvDZGdXV1CckxfYDcfAQA\n4+Ni8wl7rwcOHsRQi/f5mmFLPC4UD8II9eHDjSAdclSt2FgwsexW47RfLzihzzc9vT1C71WGEwSF\nMAmyF/wWwM8ppSlCyF8D+DGAN4vcgFL6KIBHAWDdunW0oaHB90IWQzweh5vOmY3bgeFhvP7mm3Hz\nynme71m17SUgk8GVV12FhltXepbbOnIMOH8OV1xxBRretMazHAAcuzgE7NoBAK7PUwwDr7UBjYcx\nc+ZMNDTcISSbPNoBvHYQdXV1Urqx8XkAwC23rMO1y2dLy99xxx2orxbrMpnjXcDB/YjFKuTKbsND\njduxZHYt2kZ7MHfpSjQ0XOV67cU9F4BjR7B82VI0NNworOtbx3cCg4O46sqr0LDeezsDgNb+cWDr\nFgBmeynWF+yo3rEZSKdw3fXXo+G6pUK6ARh1tn79bVi9cIa0/O23344ls2uFRJ++eBDo7MDaK69E\nw22rpPTKtDUme+edd6K2ynkCd6qD4WQG2PwSAPG+nWvS2nd1dbWQ7FBCTmf7YAKIvyIsBwCvJpqA\nsy1YvXoNGhrWCsmyd7vu1nW4eqngGPLi8wAFbrrpJqxbPR+At74w2ngROPQa5s6Zg4aG2z2ry+Up\n8OIGAMCdd92Fqph3Qv9CbyPQ1ir8jqrP9AL79gi3g5YdZ4Gm41iyZAkaGm7yLFfVrOkDJOYjvS5F\n5xPy0gaAUtx00824ZZX3+Zrpu+uuBqHFCtN3ww03oOGaJd71cTrvuONO1FULknkme+edqKn0Ltu+\n5zxw7CgWL1qEhoZbPMuJzAtBI0wXi3YAl3K/X6J/Z4BS2kcpZfvIjwO4xatsOUE8b6n1Mwio6lJJ\nASObhN6OMAK+/D7wIZenqIoRLJpZg67hZNFr/Tr9UOYu6o+t7i9q3kVBXurhFWRV9ErKhlLOgH1W\nrfcISTYgXXy/DypPtWxKujCD9BQci+SkAnZDAYKNZSjrWCEXhEmQ9wFYSwhZQwipBvB+AM/yFxBC\nlnG/vgsA22t9EcDbCSHzCCHzALxd/66soBykV0YEOSx/TD/vo8CVpLH1VA8Otw4av2dyeVRWVGDx\n7Bp0jUzggxxi/mj/fN/88X2X1x70NKpBZXEjKutPKqhgTtLzhxgFG/Qka9CQzf/O6wnqCOhyDNKT\n9bMOatEhm5PaojPQQKXIB9k3UEqzhJCPQyO2MQBPUEqPEUIeALCfUvosgH8ghLwLQBaa2+WHdNl+\nQsgXoJFsAHiAUtof+EP4BPmAFTnLswz8CtKTQRhHrjohjKOm73liLwDg3IN/AECzIFfGCBbPqkXb\nwHhRWTMKPnjLu3LWE592ScKwIFMfTMhqgTmC1ytZVIMNPPKDGIVxMArg/26SG/yxIIsJ+kHmheTk\nxHxBUFZvP7JmiI8F8m3Hr/mmlBCqDzKldAOADbbvPsP9/EkAn3SRfQLAE5NawEkGa0iyFh/ZjiPT\nfJWJikLn8Ss6NhQLss+5IbN5ilgFweLZNTh4oXjgHcuZHIoFOcQUc9ZyhKc/rF0T2fylMpDdVg3D\ngmzIlknarDDyysqmwlNd8IgfUR08RVZtPsFZ86njz17ALx7FU/1NPQtydJJeCUB+sgjOeqPuz+pD\n5wlhYaqyogb8t3Tk8hSVFQSLZ9WgfyyNTM49UbDK6YVAsGTATd4vX2ZpaYVdA6WyB/juVXu2lFRA\nu2ZWnWqGBVUE57agrlPF8igkJyWlIqh+i6B8iU0XTPmdYtHdEl5XkEfWlyoiglwCkD0MIS/ZIsM4\nGU2FLPjlYqHsKiBlSRWXKQbNglyBWbVVAIDxdG4CCXlQ26eQrG8WZFWCq6g/BPcDQHUrX+z6MHwc\nQ8kJ68fCRUW/sNuCnB6Li4Vkjn3RlyS7Qyh/1HR4bKzUXSyo6y9isuJH1k89RAS5BCC99SJ6fYjO\n/ioRrmEG6VGFyUZWphiyuTwqKwhqq7Sum8y4E2TfJpEQfK9VA2KM+6iJy+mUnNh4KFljAjQhS5MF\nWTkf3EFCC3pSsObJqpElZcKWR7DdKjl9ovBjaJMmrAJyqvOHqD5AcYHE7z6IqTWfdeq4IEcEuRQg\nv90YnL4wswH4leZNZmJUmWw0ndqnX6lvsnqQXp2e5zZRxIJMfdItU3N+bbeFuXMhrdOHFHXi26ry\nk6JS0Jri32RMAAAgAElEQVQPVk4xOTl9AFcv8rcINKuJ8YoU/LvF10rU8ulZJ0vjKaovRAuy/OLO\nu6TFp1dQoWwWCyUXG+7ZgnIJKmVEBLkEEJQPsrllrkYUZRDWVrXlPhIyKpMN4F/ZGZgPMiPIyWwR\nguyTTjnfa9UFFdMd3sJM06+iOzhZvyZFURiWQ0G5IBf3dllfAv0CkJV1LbO2BTlyFVSQni9uBNKQ\nbYQClyrOHzJyFpIrKmuxCInJlkq2KT8REeQSgOzgEOT2lKy/s6lTvvP4tXMjZznnfw5/icx8kGs9\nWJD9y/4hfh9Zv3pTp5q8X/eRWkwaJEOBeCoQFNF6V+nasjskYVgOzSC94KzAVlk5g4aEIul7yAYy\nygYEqxLrMCCiOu/D/KESpKckG1R7LWFEBLkEEPRkITMhKluQlWR9s4UGLu17kJ7hg6wT5CI+yMq6\nJSdLTcYvcl7e8tJ6hd0kVKxG6qRTXE5Wn5wcoG5Y0GSDW/TI5hZWyYMs+45UXW2Ccs2w3mPy5VR3\nIEX12a+X9SWX0auaNakUUTQPMiHkEmgn3N0BYDmABICjAJ4H8AKlVNFOFAFQGVwk9SlYxWRh+tPJ\n5EGWFnUug6SMnA+yf9tO+TxFngKxCoK6ai8+yP7oVn1vcjrVrX3+yMvLBLkdr+RiEcIiIGjfZV6n\nPycHTr6sNIFTUMrGWvF+o7ZQCkabP/cIKthOVl94QXra59Shx0UIMiHkhwBWAHgOwFcAdAOoBXAl\ngLsB3E8IuY9Sui2Igk5FsMYrTHQlBzEVHzzVFbsKUfRtu11CRmWwAfwlHzn9ZlUxgvrqACzI7D4y\nMn7pDt2CrEKmgrc2yuhVeUeyh1mEkaaL6QzPgixaL+rvVvqwB0liLQrZbDWhpnmTtCBLuzxL7gLI\n6OQvVwkUniooZkH+OqX0qMP3RwH8ihBSDWDl5BRreiHobUopXaryIUzCfpRBZbCRFHEFOxkvVlFh\nBOkVy4Osank3LaHiT6F+sAzTrXQbZagsDtTcAZSEhRBKHmRJfUplVdQNBLwr4IMeWZ0qmRNk9AVl\nXXfSPZlyKj69DOIHdvALJDGoBBVOt4NC3qG7WDiCUpqmlDZPQpmmHaQTwgsKmumngreEqk1KOkFW\ndrGQeW75AUNWpxuyen1XVnAW5GIuFiGGTfilOcyFmSqCJGJKW6OC1zvpDeqoaT9S0vlBsuVkxaTZ\n+C4cAKmUxUDNoivbDsQDS9U7trwPsndBFX9wGX12PeL1KC8btjFjMlCMIC8H8CohZDsh5O8IIYuC\nKtT0g6QFWVabhKCyRVCB5IZJtlQGDFmdbsjqx0rHKgjqq7XNHy8WZFn4YfWXV87KoHYf9XYbjm4V\nwhDkdrUfqcjE5FSs3XLkz3qP4GT9sSDLkaugFllG8cqIXAlZkCXlZPXZBYT7toLFO0y3l8mCK0Gm\nlH4CmgvFvwO4AUAjIWQjIeQeQsisoAo4HeDHkaJeIDv4yco46ZaBaoo5pTIobpGZCwP10AXDghzT\nTtIjBEiks8WUAwiHKIfp/+ynvEpvCYtMBemDLE+MwrMgqyDYLBbap8rpdOIW5MJ7eJNTq88wyJj0\nHQQE+TQGQaV58+OgGBnhqUePJ0jzRjVspZT+LYBLADwM4J8AdAVRuOkCeT+xYPRpMoqWOJWAJSXN\namVQSXsjK+OGnOFiUQFCtMNCvFiQ1Y258gsDeZ32HyTvE6IFOUjwk6JwaqcQGHIYo4GKi5m6dnl3\nB9HYCz9SdQW1yDIC1QXzYYXrOuVduYq7iyGnslhWcc8QU2vu0AjKlTKKpnljIITcAC3d2/sA9AL4\n5GQWarpBejtVtPEbnzKER1jEAsMaoiIbwpnJeYUBQ1bGDbwPMgDUV8cwXiyLhS9hSeG6loSRpk1V\n3uyeopOTPLFR2lYXU2WBbO7TcH2Q1e8hJxsM6bSOWZJzhDApY+1AUE7agiymp5juyZTjyyl9Yq7g\n9X7kwbbfx5Os5LhXyiiW5m0tNFL8fgA5AE8BeDultCWgsk0byHaAQC3IIZAsU9afDidHdqjjz97l\nJZS6IJfTbhbTCXJddWyCk/T8KYOMuF8nLyqXPUR5pQAZYQueutVQBkFZxRhU2pV8jl8TQe6EyQa+\nWcYphYWWCJgFWNjaLTmX+XJQiKycgKBKXWjvkgaWUQTwJ5Zh6tDj4hbkjQB+DuB9LuneIvgEcR8j\n9hncCk/16GA/UkmFcuCForyfB4Vk9EqojGl3m1lThaFExvV6WX9Ct/sIyaip9PE+qhZoiUWRpGa+\nX4oTBkFlIcsGZU2zyvqw6ArwXflB4GTboPDcIqiHQXYRH66LhXeo7EDKtlcVFxultiMrWMJwJciU\n0sv53wkhs/nrKaX9k1iuaQXZgAjZwU/Kkioh4wQZNwlZS4odqq4lYRJFgM+DrL2Iq5bMxKstfUV0\nU8unKFTkw8yDrGJNLbxXcLLWjCmii+ZwLMjSRDdgYq0pZfdQvkUg0n68W1lSLtuG5AMKRQm5+siq\neriJp2sVY1i0ewhezwmIL3T48sq116mUzaJokB4AEEL+mhDSCaARwAH93/7JLth0gOkTF7QFWUhM\nl1GcGkLYxi0sg4wMN2DIlMTHwSKru1hUVmjd9voVc9A1nMLAWLqo6lBIok86lRc1asVQajNqR8QK\n6rT8LDcuyICJqmRakFIoAfP9KoxFQVqQpQmV/JglfcS7rCWYBekpLCaDhohq61gkVmjmrhJkoB0v\nINz+fJpvSglegvT+BcD1lNLeyS7MdIVog2KWRHkfIRmLoLCIo7xckJ5fFmQ1maAtyPaBMWcL0ls0\nqwYA0D+exrwZ1a7y0lxEiYzIy6qWQbXOrPcKjkypWP6UAnPUGqmcmOR79cP6q7YgCG6h70cqPNld\nDJVtfSE5Q19wizrjHrJyAoJqAXNq87wmK2pBlocKvyhVTGhBBnAGwPhkF2Q6Q8QSzAepyDZ+ucFF\n1YIcjqz1PsFbI/MKKwM7GcjqPsgx3Qd5br1Git0syLI7DX5APfuEPLlXmSAKyqFA0EVFlcqt0E7D\nSMEovb2tUFY/glbDcLkRdUtTOf1Tvu1qn7IBhSrHKUtD+hbeBf3YzVIhueKLMuefRWSnmwX5kwB2\nEUL2AEixLyml/zBppZpmEGlPOa71yQ4qUpbUUC1xugVZMdQtDLLlx4qcwZ7mbVat1n1HUs6Hhfiw\no6zfJ/gdB7PswS9qVJGXLLvKxKaSTkqlrqSPQ/bBOiouSy2fXmENnlRZTARjJVXxZZfNHqNaVlki\nr4LgLchiGs0sFkJiNiOaoKyCS6FsXZYyvFiQvw/gFQC7YfogH/BDOSHkbkLISUJIMyHkPoe//zMh\n5DghpJEQ8jIhZBX3txwh5JD+71k/yhMWRDpOLq8wWCus8HxzsVCwpCofRqdgDZQUVyKpBQTZluat\ntjIGAEi55EJWTbsTps+6cR8JmbxPhAZQe3Y1C7KgToVgoDDiA4I6PZSHfL1w95DWLk9WxIc9lbZQ\neA8vkD5y3HAjkF+0yEJ6XBS5VsEiK6OvUL/CIl1yDJpuFuQqSuk/+62YEBID8AiAtwFoA7CPEPIs\npfQ4d9lrANZRSscJIX8L4KvQDisBgASl9PV+lysMBOXTpOIjpOxXJGmZkJVxvI9UwJf8+9Z0ysOu\njy2OqmLaura2SvtMZorn4PPtVDsRGeUdB/n7WGSUyyFvwRaeYPhjaSWtN0xaXlYM7BnFd3eCZwvS\n9eLTloSslVRYTqmMupVd9GQ7SX2hpnmTbYICcr54gij4Z4u3Hd6CLCorK1m68GJBfoEQci8hZBkh\nZD7754Pu9QCaKaUtlNI0tINI3s1fQCndQill/s+7oR13PeUgMkHlLNsnkqtDm9i53rEJ7+Ub4ZGQ\n9SuXsDo5VyPYoih0sdB9kLmDQgAgOUkWZAa5hYE/DUbOrUV+kLfrlNttkVuIqgXahWNBlg2gDcOC\nLF8v5s9+uIqJXi+bJ1+TFRI1FxHC7iBy70VWnx8+yPIWZO+SvqR5E5TLKY0F/M9ybSDMDCN+w4sF\n+QP6J3+8NAVwmaLuFQBaud/bANxW5PoPA3iB+72WELIfQBbAg5TSXzsJEULuBXAvACxZsgTxeFyl\nzMIYHR111Tk6mgAAnDx5EvGEtwMKxzJm62ttb0c87j25SGdnEgBw/kIr4vEuAMC+ziweOZTCP91c\ng9cvdm8Oxy6afq4y7/DsOS2QbGhoSFj+nC47PDyiVH+NR44g1tUkJNM9bppS9uzdh7aZXtaUJk6f\n1Q7yyOaywmVPZM26jsfjONSt1cHh1w5iuCWG0bT29yPHT2LpeGH7aWvXQga6urqk3htrn2fPnUU8\n3i4ke7i7sL0U6wt25PXFwKnTzYhnzgvp5t/boUOHkWmLCcnzk++BAwcwcEZMvn9Ae2/nz19APN7p\nWW44berdu28fumZ719vDtdO9e/ehfZZzO3Wqg5P95gJLtJ006+07kUgIycrqbHRoV17R3aONfx2d\nnUKy6ZxZL42NR1DRKTaGMBw/3oQ5g6cBeOsLbNzr7+8XKm/riNkWdu/ZjZZ672MWa7sdHZ2Ixwc8\ny506L9cO2i9qY1R//4CQ3Olz5gFJsnNCMpmUkj127Dhm9p/ydG3nmHxdsDGw+cwZxPMXPMt1jHJj\nwb596HAZC5xgme/27MUFgfmuVZ9vevv6hN6ryLwQNCYkyJTSNUEUpBgIIX8OYB2Au7ivV1FK2wkh\nlwF4hRByhFJ6xi5LKX0UwKMAsG7dOtrQ0BBEkQ3E43G46ZzZuB0YHsYVV16Jhjes8nS/gbE08PIm\nAMDy5cvR0HCD57L88uJBoLMDl1xyCRoargUAbP71EQAXMHv55Wh4k3tVDx1qBxoPAYDr8xTD3uQJ\noOUMZs2ejYaGNwrJHkifBM40Y+asWWhoeJOwbmx8HgBw3XXXo+G6pUKi5/vGgG1xAMCtt96KK5fM\nEpI/VXEGOHkClZWVwu9tOJkBNr8EQHvnyaOdwMEDWH/rOly3fI52zPQrG3HJ6svQ0HB5gfymgSPA\nhQtYtHgJGhpuEtINADMPbwdGhrFq1Wo0NFwpJJs53gUc3G+UHSjeF+yo2PQCkMvj8iuuKNounTDC\nvbfX3fg63LF2kZB8NpcHXtTW4jfdfDNuWjlPSP67J18F+vtx6cqVaGi42rNc72gKeGUzAOCWW9bh\n+hVzPMte6BsHtm0BAKy79VZctdS5nTrVQV1LH7B3NwDxvn26ogU42YS6ujoh2VpO51133eU5U0P6\nmNYHZMr60/P7gO5uLBHsD8lMDti0EQBw/fU3oOHaJUJ62fhzzTXXoOGmFQC89QU2Zs6bNx8NDcVs\nR1YcvzgM7NwOALjtttuwasEMz7Lf09vukqVL0dBwo2e5czvPAk3HhdvBC72NQFsr5sydi4aG3/Es\n17y9BTihLVSE5yO9Pmpqa8VkWT1eey0ablzuSaSlZxTYvhUAsH79bVi90HtdsDHwsssuQ8NdheO7\nG5q7R4Ad2wAA69atwzXLZnuWPdfLzXfr1+OKxTM9y24e1Oab+fPno6FhvWc5kXkhaLguDwghRZkI\nIWQ2IeR6Bd3tAC7lfr9E/86u560A7gfwLkopn0WjXf9sARAHIM4ASgUiQXqWACQ5NbyY1wC4nOK+\niYpPqZLvtIJPlSbv/LOMvLCszQ/QzIOsdduaSuaD7OxiwVSrHuur4hYjC9ngHU03dx+p9iYuw0M2\nE4BfJ9qp+S/L6RX2QJasIz/8pUVvoXKAi9t9vF3PdIq60ilssUvKyaaky0tuy4fh2ysjp5Jdxuke\noterjUGS7XWauFi8lxDyVQAboWWt6AFQC+AKAL8LYBWA/6ugex+AtYSQNdCI8fsBfJC/gBByE7Qs\nGndTSru57+cBGKeUpgghCwG8EVoAX1mBNSSvHaBzKInfHr7IycsNnLxYOquxsIkCvey+z7IDoQpJ\nVSU7KuQckCTo4ioddQPm4kiP0UNFBUF1ZQWSWReCLMsICuQlSGqIjmjKiyJFH2ZpYqPiO+pyH296\n5etK2o9Tuo7UFxGy5E+TVXhXkvWi5EcqJspl+hAlR5ILpYIfvMqpzUcSKiWhvrhS8c8WP2qa+9kH\nA1y5w5UgU0o/oQfjvRfAnwBYBiABoAnA9ymlO1QUU0qzhJCPA3gRQAzAE5TSY4SQBwDsp5Q+C+Ah\nADMBPK13gAuU0ncBuAbA9wkheWhW8Adt2S/KCl4H3Y/+ZD+OtA9xcqJ69E+uCSd062PCxQrppItS\niZRrCiZklZWpyorYLqGiX+UEQeN3/UVUcC+/trICybQbQdY/JYcsFUtATkWY061qtVc+HEalzSlY\nb8StjSqyQpdbwFQJH2ZhuQeF1x6iZu1mn6ILF38syKKysoReLdCK/SCvU0ZOZdcjT4GYxAAbRNCc\nqoFGRk40A4lVFz+OyMn6leKzFFDUB5lS2g/gMf2f76CUbgCwwfbdZ7if3+oitwuAd+fbEofXhnii\nc9gmJzeJ8mLDCS3YwW2bnkGZ8Ng+xWTlrc8qmQHsMkG7WNjbBbPisywWgJbJws36LzvBMqi9d+4+\nEhYes73ILKhULcCKiypJS4pKvl2Vdmo/zECkruS3jeXqyI+yKtWL0mJCjgQquVgISZrXSy/QAjpJ\nr3ARoJrjSEC3SBYLy6Wyhgr5xbLSbonCDthUgVhIfoRJgdd2lclZr/TDb2tIJ8gJFyskg8XFQkwt\nANP6qUIywzgq2mo9CnYEsOtjixSLBbkqVsTFwvoprF9BXuU0J6cyCMm4/iKuU669yllSlI6RV3jJ\nqotIGci+Y1/IqqRlTEpYQdIfC7KorNoiQn5jUYEECupUlhNqr+p9S83FJkhyrWaQKUVEBLkE4GVw\nGHM4TphSoLFtEH/xgz0G0S0G01XB1NczosU9TuxiIT95A4oWQYV9VVWyo5JTUpPxp+yA+R54C3Jt\nZWzCID1pFwsFedXT7GQnaj90q1ugrZ9B6LVQONEJ1eVnT7K+WJBFLHLy70g22Fd1DDGFBS9n47Wg\nmjACrWTHGNkgPYtuWeIZgD5VA42MnFo+deefPck66C93RAS5BOClPR1uG7T8HqsgoJTiRzvPYfvp\nXsRPdrtIWjRx/2uTDSPI42krAe8YSuD+Z44Y36takFWskWZ5xWVVg+xU/Lk0/dqnTBCJe5AeR5Cr\nY0hMkouFirxye2GfIViA/QrsVNreVCLXogRQfvErS2xkCb3KQUmsL4v2ab+yWEhb81QWPJKy4gsl\n7VPYlUp2EcC1A2lCFoCYHxbkYOMR5MeRaWlBJoTUE0I+TQh5TP99LSHknZNftOkDL4140/EuVFdW\nYGaN5ja+dHYt8pRiULccn+8bLyau69E+mbqRVBZZ/ctxm4vFo9ta8OSeC9h0vMsiy8uLQKXzqKR5\nUx2g/PRhFtdt+90hSG9WTaWW99dRueVDHAryflndVI561uSllHL3kmlz7DZiskqnZKqQa8sR12KQ\n3zaWtThy9xCWlRtHVAin5T6Csqw9CBMVlcWpD+5BIjB26ETbu5Q2f+4hnR5O2gdZ7PqwYhnM+WLq\nMGQvFuQfAkgBYFm82wF8cdJKNA3hpTmd7hrFtctmY8M/3IFff+yNqK6sAAVwoV8jxv1j6Yn12CaI\noXGTWNkJMusczMKsbIlV2DJXsT6rDBaavNpzyw4Wu5p78c3N1tOanIL05tRVubrX5CUnOwYVK25O\n9b0p1bk80SyQF1fP+SDLycnoVSmz0pas7NY6T8oFbqFWVjk5VZcdu37venU5FYIkSsolx2lpH2RJ\nF4sw/OYNfQLX+tG3xEmugk4lg468EaxU4eWo6csppe8jhHwAACil40RmvzhCAVg78jLoXhxK4Kol\ns7ByQT1WLqgHAZDK5LWTb+CNINt9I3liZQ/Sq6myHkJhtW5NqMpBtzxZU/FHVfWdVn9ucRlAS+k3\nZqsTFqMZ47rf7LoqIxOJHSoEV5OTs2AB6u9NBcoEl/9ZkaCLQMXf3Wr5EbT+Uf5nQUueQeJEdcot\noFSCZmXHEeUdCYf7eLtelqzKv6McW7hIElZRZiBrJaeSbVaFPJqC3i9VWazI9y3LXQRlfViAiomV\nNLxYkNOEkDroz00IuRyaRTmCT/DSELuGklg6p9b4nRDgbO+Y4SIx6hDEV6DHpm9QtyAvmlVT4IOc\n09nYcFL7XvXch5yCL69TcKFXqJIz5YAtI3uHmLSdHPP3quB67Zy6Kgwnso73N7f65UALfhCQ9cnC\nE2oeY8juljDdgpOTxaqqQhiERKV3GHhZJRIXEOGQrReVxYflPpJkRdiPVGFxSiV1yp8eqX8Kzg+y\nuy2qO4qaXEALOuMeQmK+ZKLQ9EsS8ynEkL0Q5M9CO03vUkLIkwBeBvBvk1qqaYaJBt3e0RTG0jms\nmFtnfFdBCE51jwAAZtZUFhDc4nq0T2ZBXjantsCCPKbfj/m3qvviqk8sUgRVsdyqp2hl8/Jlt8Mp\nSG92XSXSubxjLmTVxO0qbjHWID0VAqaXJU/xew9vw+PbWzzLMO2isJADBYKtZvkTg/Udy03EgILV\nSJIY2fVPLKc++auQBhXIE3o5ORlZw6IrW1YxMdOAIChnbbNyhFUWwS3o2LuRW1hpsqI6zZ/ldzym\nDkOekCBTSjcB+GMAHwLwcwDrKKXxyS3W9MJEDfHA+QEAwOsvnWt8V0EIKNUsydevmF3gQ1xMj2FB\nTmhuGcvm1GLclipsNKX9bliQFQmPWpCeoVheFnLlVs7/TCVnjiJl4YP05tRVAYCjH7KqajV/NH/u\nw0SHEhmc7BrBlzY0eZBxJlEtPaNiSiH37uz9zCv8Og0vSKuR2cYUJnGBAquMQ7L9wY2Ufy9+Bl98\nzvsBrrJ61RZaYtI5RVImf3iVKbfrTC+OXxx2EynQI7Jj4o8FWe5qWRcLlfMOxIMnFRbpkuNeKcOV\nIBNCbmb/AKwC0AHgIoCV+ncRfMJEbfjA+QFUxypw/Yo5xneMI106rx7zZ1R7Ish2kmpakOswns7h\nN4fa0TGUAGDmXR7RCbJqPmDmYqEUsCWuVnmrX3a7sm1gHKvvex67W/o0WXHVrmWxB+kBLgQZ1voW\nhawPHOBjYJOtrXq5ldMkGD/ZjTd/fSteONIhJi+1KJMlGdwvktYbCVFfyLXoFrnswtMXC5eKiwVX\n2q9sPIHHd5yVu5HI5YJyKmO17IFOskYMFlfB6/vgY3vw+9/aXlSOuvSVs71jRevXbfEsAmkLsuQs\noLbgFZXl9YouBeQWSaWMYkF6X9c/awGsA3AYWpDq6wDsh5nVIoIiinWcb24+jUe3teCWVfNQWxUz\nvmdxkmsXz0RdVeWEJ+EBhdaeofEMaiorcMm8OqSzefzjU4ewZuEMrJxfj1fP9OnXpLH1VI9a6iDw\nk5OKrAxR4+8jrls24GHv2X4AQGPbkK5bTHkFKRysDBcLBwvysEOqt7yxKFGDCkmU0e/ktzfo4SAc\nR936j6w9n+4exTtE5H3aLXlix1nUVsXwwdtWusqp7Fb4QRy1+3gT7h9L40e7zlnKzJDN5ZHNU8t4\nVajT+efxdBb11e7Tkh+Tv9qxxuxTYqEveL2sBVntVEXI6ZR0g5PdlncinvGT3fjQD/fhkQ/ejD94\n3TIXfbycHGSPmhapFrfg8mwuDwqgKua++a+04FUZg3yab0oJrm+ZUvq7lNLfhWY5vplSuo5SeguA\nm6CleougiIlS3CQzOTysp/r66B2XWf42o1qbfK5YMhMzamKGz3Ax2CfuwfEM5tZXYc3CGcY1Z3vH\nsPVUD9K6yfdw2xDueWIv/md/W0G5h8YzON01MqFei25PV/sna7EYSMjLWmPsA5io7gJ5ygfpcT7I\ntboFebyYBVnWciH/3nOSabwA5wHey0mRTvrshG9g3EM6RId75fMUf/GDPdhQxAKdzuaRzOQcdzwe\neO44PvXMkQnK7dzWRpKZCetQ7bAP8T7ywG+P4Vsvn8bWUz0FOj/2s4O4+tMbi8o75Xx+vrED137m\nRZwqMqY4Wbiau0fxR4/sNHa/3GXF2/ORtiG8cqKL06l9tujZgyaCyg6WtA+yQt9z8kF+en8rfnWw\nzUXCqke07TF9KoGl7Mcdp3sBwLX9tA2M43QX52ZFzTJ88LHd+OUB92d0q8d0No9U1t045da3zvSM\nOi4uTbmCYiKXp/ij7+7EvT/Z7ypXqFN/v3mKJ/ecL2pIo5Q6jn0AcG4CyzyvawoZkD0F6V1FKTVG\ndkrpUQDXTF6RpiFcWhTLQfzV974Od1+/1PI3lrVi7eJZmFtfjaFEBtkJUkXYJ+6RVAazaquwfs18\nXDq/zlUOADqHk+Z99M9bvrgJb3t4G/pGJ05qopKJwnDPkOh4qkF2TivqYxeH8O5Hdhr146zXqktU\ndXWltWvmdQsy714BFHexkJ1g/ZBXCXRzmlTECHKhPMvY0j3soa061PmZnlFsP92Lf/j5a65yf/y9\nnbjlC5sKfPHSWW/+B/yEyd7BeDqLGz73Er48ge911gfLD2CWuWs4iR/uPOvqw8gW0H16ekn+sheP\naYSycyhZIGfodCAc3992BoC2SHeDU93+8kAbDrUO4vnG4u4zTiTu4mACzzVedJX5w+/swOd+a/oZ\nM8ktJ8yTS4vVr9WC6K1mcnmK5u4RR1ed0VTW9Wh5Q95lB2QoMfFCy6wXapTlX3/ZiH/+n8PF5RyC\n7Z5rvIj1X9rsuHi36/P6bijViB7vUsjucV4/E6Aq5pxr7k1f2YI//M4O817655H2Iew604evvXjS\nVa/b7s6bvx7Hm76yxVUu77AQPNc7hrd8fWtBnnseTgves71jONo+jC0ne1zl7LKssFtP9eD+Z47i\n6y+5P+P7Ht2Nf3narGd2n8a2QTR8LY6f720tqlc1a1IpwgtBbiSEPE4IadD/PQagcbILNh0w0Tn0\nbPJZMLO64G+MGF2xeCYWzaoBpRPnQrZbkBPpHOqrY5hVW4Xt//ZmfPGPrvdUbibPJuWTnRNbkZ0S\n0OPnM7AAACAASURBVG863oXHtk2clSCrz+D8YJ9I5yYkHg++cAKff/aYWW7ub6OpLDITLCie3t+K\nHc29prx+g8e3n8Xh1kG8qvsXO2EsZTt4xTZsTDQh1FQWWqBzeat7BeA1SE9uyDK3TU35hzedwtP7\niw+UgHViEA3IslzCdiu45yt2j8a2QbQNJAqu7RrRyFr3iDtpc9Svg/WtbBGrz9H2YYylc9xkquvm\nFpfFgmacrEZNHVqw0g93nitaZpW809Thl//3v434/G+P43iHc7BUTM81yBblTm2ssW3QVafTIqhD\nJ9SjSffdMCdizeo4NcF44OQ+8t7v7cLHf/aaI+l0Ivi81ZqhWIpNXqNXK+lzjRfx1m9sMyyifLHf\n9e0d+NufHigq72Tt7B5O4sbPv4RHJxhv7RZdvu0WI+am+4qp+5O/OoLukRROOlh0E+kcdjb3FmzL\n80Yep36+s7kP9z9zFP+9+7x5nf55QT9NdrhI++HB5Ab0vs0bgeywxgeYv7QNJIoaSpwWrsf0AMTd\nuhueE/hFDrvF4AS7X5RSrL1/A77zSnOBTta3nFzxGPae7beOnfrnxUFN9jeHijsOmGsrrux56ikF\nbanCC0H+SwDHAPyj/u+4/l0ERTgRmHyeGpMo63gLZ9YUyH76ndfiQ7evxrXLZmPxLO3v3UU6KsCR\nVMM6lbP4Cb7nphX424bL8ZarFwMw3TgKC24dvNoGi29t8jr5GeOjP9mPL21omjDS1kiVxl12zWc2\n4k++/2pRuf/aegYvHTe3R5luSimu/+yL+NSv3Le8KdUsJz/ggnDYM7CBqtiEMZqyDkR82Tce7cTa\n+18oOrDaXSzylCJPqSUHMqAdFAK4WVgL39vm4114au8FV71OZWafqWwO33z5NP71lxOvj3MOBKix\nJ4vXfe4lz1vhvCx/GErC5b1TSvGu7+zEX/5oX8HfGNmZqI9oOgsJ/USDfDc3ubIAV/YYvFuHW9l5\nXfzPR3Qf9rn1hYtkQBsvNh7ttGzz+nFoB7O0t7v0bbZMY4tUXiVbw3U5EI5cnqKpY9hxZ2dcf2/F\nFvqWNS017wm498eNRzvwnu/u5MifqZwRByedp7sLiR2T7OV2zVyPeodzW54Iu1s04mQPTE2kc2jp\nHZvQgui00GKZkJ55zZnkUEoxOJ4u2OnjCVNvkZ1CJ797FuDt1N/v//UR/Nnje3C2b8wix5Pb4URh\nn8s5tG2qz0fsXl5SnvIo1icZJqpHtz7n5KLH3qPdCGLR57CrM8hZ4p3cOnpGU8jkKA5eMBem/E4U\ngKL+/XYwvUN6tis3l5BDrYNYfd/zOH5Rj7fh/vb3T72GN38t7ilGqhThJc1bklL6MKX0Pfq/hyml\nE5thIkwIJwvyPT/ciw88thuAOcHwB4QwXL9iDj73rutQXVmBRQZBLl4t9m2wZEazIDPMqKnE/7v7\natx22XwAwJpFM+y30OWpJe9usQmtcyiJn+4+z52YpIG3FLgNvEOJDD7y4/04pVuo7WPQ4VZ3C5Vb\nuQHzeO6ni/ic8RODKW9FsS3kEZsVg5f9XrwZ2TwtWn4nH+RcnhZYkGMVBLNqKp2D9GwEFwA+8pP9\nuK/IwsCtzACs/ntuMpTi8k9twH9uPm35DgB+2pTGSCprWEXd71H4M78AcJo4AWfLEZNnW7IXBxMT\nuiI5EYyJCDLvkzpSQJDNsheLFXBaVBzVrU1uk+nmpi78zU8PWCzMTHbLyW78f9/bhROdE73vQmvV\njBptXOhwIcjM04cdaGMe+EAdJ3SGT//mKN7xze1oGxgvKC8LPO4rMp44kfl+fQHi5l/+Nz89iNcu\nDBrjlBOXcSJJju44tvYEFPZ1y+UOC4GJUGlzo2JSPBEvdi8n/+5zunW1xiVw8uFNp/D6BzYZ75Dd\ngXefm8h/VfvUfud355z6JUvjZi4CNEGeTHcMF7Y9p11DSilS2bzxN6eMTk7vyz42FIPTmMQvyNys\n1lbjj/Yze+ZsrkgdOrRzPlDZySDS2u8wZ9nGT7dxxMlIZRqENNmMC0F+RvdPv6jPh/yC7vnGDnSP\npPBa60CB3Hfjzbjvf0vbGWHC5QQh5CwcFk2U0sscLo8gALuFbjSVxXZ9W20kmUH3cBIVBFgww9l6\nxMAsyMUskkChH/B4OoflcwsHzHtuX41Fs2owt67a0RpHqXWwLkaQv/j8cTzX2IHLdbLNdPMnxXWP\npLB4duEiYMORDmxu6ir43m5pczr53MmaxMQO61a5YjjmkIeTTc5sXCtmCS2YNLkexKyYxUiX3dcY\n0Ca+CofvZ9dVubhYsEVJ4cCWyxf6M7vK65+t/SapGUtlMaOmcPj4zaGLBZYG9ht7/51DxdtphjOf\n8BlXGIYSGcdF44BDO2TyiUwOVTGCTI6ibSCB1QudF39aOQsZcjESBFjfjV03vzU6lsoBs5zv4ZTm\njREJt0Ag5gLBkzlW/Kf2XsD+8wN4bNtZfP1Pb3Qtu5M1t1LfquhwWQRWFPQ56+Rv/5nht4c1f9/z\nfRxB1i2AzMrVP+bcPjTyXWiRY+PPgIuvKyHatX02gszfK+Vw0I7TbgOr07F0DtWxCqRzede28bGf\nHcS1y2Y7/q0Y7P2SlZMnYQPjGcy3zQuprOZ25mTtZAuSjIsbyrf0bXl7kB5PHp1O9xxKZPDgC00F\nc8BFbmE1XCR+gJFa1gb7Rs37XBxM4Oql1vdn35kDtGfky+lE5J0W1ezdeLEgZ/OFrh+8YWcslTXc\n3axyhe2VvQ+3zDzffvk0rr/ETOlqLjjNdzOazGKxbRw55+C7by6utOd3W6Dbz0HgZVk5x13mq35b\nv2Ptjw+WPNc7jtsvt8p9daPmD3333e5jcdjwYm9fx/1cC+BPAMyfnOJML5jEQfvpJGfpae1P4EzP\nGJbPrUNlkZQugOmCMVEAkt2Km8jkUOfgRlFTGcN7broEALD3U2/BF55vMiY2Js9bLPlBzY6D+tYe\nKxvTzW+DuVl+2LagodeBXPePpbHAwQXF0X9Q/2Rkpt7NhQRw9r1klgNdf/uguwXZTn55kspIRzEf\nart/NHOxcCK12nHTYkF6faPOixIedqLLE5COoSSuWDyzQObpA4X+yUw/Kzo7oMYJQ4mMhegakwMn\n4xaw1+/Qjnhrz8r59TjTM4a+sVRRguyUQoqfnJwWF44EmVmQx3iC7DzJbDnRjf3nTZ/EPNXIIAtY\nc7PeOW17sjKzXZB955x9HZOZHN7xze3G4lWT1cDa70W3XRJbM2TP2seRW6cFYE1lBUZg7Z9sR4o9\nitOCu3c0hXVf3GwpK5uI2fjjFgxmb//s/fCkyr4A6RlJObqIsDIm0lksmVOD1v6Eo4vFaCqL5xs7\nLIGD/Bb7v20bx72xFnzkjkI7k9vClX+fnUPJAoL8/kd347ULg7h+hUkqmU5GWJ36jqNVVv/kiZMT\nQXrpWKcleIvVCV/WYgTZ1Fe4wHIaX5380ym1klwnIt/rsugCtLoshu+8chpfe8kMqGPvhjdIOfXr\nz/zmqOU9MDk2dzq9l86hJL6+yRq8Z2SN4q53WpSd63MgyLb6cFvMOZXfTszddnrt7cJ0lzHL2zpQ\nOD6WAyYkyJRSeyTSfxJCDgD4zOQUafrAnnaIHxAu9I/jwPkBrF8z8VqktiqGOXVV6Jkgm4TdTyyZ\nyaGuSK5SAFg8u9bRgs1bM9wsPoA5cNm3nfkO6WaBtk/s7D3xA0VL75gjQT56sdBKzJ6fTXyJTM7V\nknrcQd5ucSg28O/kgvsA87n5iThVZKvfTpDdXCwAjSA7HxRi/eRdC9ys9jzsCyp+ITPkQHIppWhs\ndXhv+sOzebhYRor/88RenOcGer7Oa6sqkMzkXeVbepwmCO0zmclh2Zw6nOkZc9z6ZxhKZCy7DwbB\n4AjdqIO16FyfkwVZA28pctrOTWfzBTs1lGp1lMjkMKeuykj1Zt8tYcGg/AKClblLX5Re6B9Hz0jK\ncMViaBsYx9neMUvWCPvk5ta3M7btYda3+EW6E1FhrkMWFyZqtWz1Oiy4mVvOmZ7CtsGIipcUflpZ\n9fJxYxAf4HeqawRvf3ibo6w5fuWwbE6tTpALyYVT+ktGAl842onucYovPt+EP7ttVYGRwr77Zeww\ncnq6hpO4drnVuvqa7nt6tJ1f3GvCbFHu5J/b0lvoOmX3Cwec69MetMpvrzM4uX9VxuxWcu2T7yvt\nNje38XQWn/7NMdhBQS0k14nwOs0xxu5S2qx7p/mAJ8d8WXmCbF8MDicz+Mmr5y3f8TvF7Bo7nE77\nNMaR8eIE2clAZix49evd5ixHgmwYBzSZgfGM4/uxj0l2q3UxvUBxd6GwMaEPMn+iHiFkHSHkb+DN\n8hxhArB2wfx/+ECfl5u60DmcxO9cvsDTvRbNqpnQgmwn5OPpiQkyUOjiQSk1Gv+M6ljBFgt/nX3b\n09ii5LI8OG2NDyUylm1Y7X7aJ9/Z3Pxi7dZnXp4RZEqdI4MptQY62OUZQXZzkdhysrtga5q98w5u\nEVTcglxIQLQgPQGCbHOR4Bc1XrI52C3QfD05+dz1jKSMhZClHPrneJZNSM7W0KHxDA63DlomAtOH\nLosVc7VUhG5W2NcuONQ5tMVGJkcNtwy3rXgAuPHzL+EvfrCnQD/vi+tU74fbBnGdjbA4+eI6ld3J\nR5jCtPpdsXgm8tRMrQZoEftbT/UYxJifrCm0Oh9KpI0yOU28TpMs65+sjw2MOb+rAquR/slSbc2r\nr3J8Vrbws6eNnGjBzGeNMOSoNnYyy5bTwqfbKTOBjagAVoLM65pbb10Isfczksxgud4endqD064a\naw8nuN2p8/2Fi7qLNr9v062DsyAXybjgpJMFWzqR3DPd7mn1LC4WDs9pX/A5Weed3BsqKwpjLADt\nYCoAWDK7xmLB/9bLpy0pyHjkqZXkjqYKn9ExFamuczzDkWsP7hasrfMLOft7OOWQ2cm05przh933\n12kXjM3b1oW2Q5tzWgRQa9txsyA7+lDb5ktN3mmn0r5I0p9Tv2dVjBR1UXPwbioZeMli8XXu338A\nuBnAn05moaYL7IS1dzRtrM6ePtCGygqCd9jyH7th8awaDxZk7ZPq27cJW5CeGy6dXw8AmF1baZSX\ndZRVC2a4WpkuFNl25gd7p87DJqm13Da+ffIGnCPNAefUc+w9876F9kGlYyiB+Mke9I+lceUSqwuB\naXHQBziXTt9VJD0UP/m5+ZVuPNpZQBIo3C3Is+sqi6d5M0imeU2Xh3zApgVZ+xyYwILByPEam/sC\nIzJMxC0opsmRKJp1XoyQAM6LJUqpYZFbphNkt3RJjADwz8nazMVB50niqxtPYPV9z+N83zjedu0S\nx7Lz/dLJB9CpLiilRjtbMluz/LL29tPd53HnQ1twzxN7DVcFux/xeDqHTI4abjBOk6dbm6GUGhOm\n27uyW2tZG7vQP46qGMEVi2cW1NPgeNrROkypuWBeMbfOkSDvd1rwgmIwkUFWt2o5WZDd5AArEU9l\nnIngqgWFbTmTy2MklcUl87T26EQanMrCqogfF51cwU7bFgNOu268XGv/OG778uaC+zCdI8kMRpJZ\nzKypRDqbL3DLcXYl0cc67r041YvduGH6Lmtlra6sKLCUaou3wu8AbZEzozqGefXVRvtpbBvENzad\nwoYjnc7PqM9lgNZXnKyVTu2O8bIkNx7ZiadTXA8razELclOR+YfPcmMfDxzjKLjxe5Ye9+FE5J3m\nYS9Wa8Ca19te3ouDScM9zmnMcBuP2XywfG5dgV6+DZZyggsvBPnD7FQ9SunbKKX3AvC2lxWhKAwL\nMlvlpbKYXVtpbN/evGqea3onOxbNqhHKYpHK5kEpUOuBIL/zdcvw+Xddh4+/+Qqj3GyyXrWgHv0u\nPsiNRYLheAuyU6dlAQfvuXmF8Z25/avpJsTdgtzcPWoEL9pvMJzIYJ5uGbJbet7NpQl76zVLnMQN\nwuU2MDhtGDlttyddls5/92RhnlPNxcLZP9HNgmxfgPHXFNtteOFIB972ja3GIMz7oi3Uc3LzpCCb\nyyObyxuEbvWCemvZoe04sHK4WZAdT2XkJgdGSNwsyB3DCYfdDvM9L5pVg1gFcXWxcDqgwljYDCVw\nme7/yhYHzd2jRl7ZxbNq8OdvWGW1OOplP983ZhDVcQfrltMknKfmQmLpbO25hxIZ5PMUX9l4wrjO\nKRc3hdnOlupuNE67FW4Emc/lbF0UZfAvTx/GrubegnfF2tpQIoM5ddWYVVtlIRtP7DiLB57TDtxY\nu7hw4cmIwiXz6jCayhakrXvZIVgX1Hx3axfPxHg6V7Do3H9uALVVFeDXlbwvMANvQeYX0DdywVK6\nSnQMJkEpsHrhDM2n2mGx6EiQObIyt0YrED8OprI5bDreVZBBxyBWXL/hSe2LxzpdF7yUmu4Vl7M2\nmGYEjeKxbS040j6E6liFJXsGT3Tn1lehsoI4+qAWLJTAntFc8PCE9dUzfXjwhRMO7Uf7HExkMLe+\nGjNqKo1yTnRABaXmMy2dU1fQrn91sA0PcIe92AvrFOB3rncMf/74HkfiyGAP0uNxwiGGhfURfuy0\nzyH9Djs2xvg9nsayubWWclpli7S5ZKEFuXs4iVdOdCF+shvffPm0o2w6m0fXSBLX6MGm/LvN5vLI\n52nBszOd7DmXzakt6CO8cSlVJJtH2PBCkH/p8TthEELuJoScJIQ0E0Luc/h7DSHkF/rf9xBCVnN/\n+6T+/UlCyO/5UZ6gYU+NM5bOor7aJMh2C2YxaH6KxYMNjNQx1Oxg9R5cLCpjFbjn9tWoq2YWZDP5\n98oF9RhL5/CjnWdxtN1KiI+2D6G6ssLiR223MADaFlwuT/GOb27Hk3vOo3s4iaaOYRACfPhNa/Dd\nP7sZ7379cjPIQe+kr7tkrqPz/9B4Bt0jKVy/onByA7RJaaVuGWKDyu6WPvzmULsxOc6fUY11q+c5\nyvMuFk7pcdg9/+QWLdCxurLC0YrrFhzilE2HUuc8yIBW98lM4ZGnpgW50PJebDH1qWeOWKxYrDj9\n42ms1HcT+Lb27kd24m9+etAYKK9bbn3veWpdBLlFUrtZXTK5PEZTWSyZXYsK4my9zucpOoeSeIPN\nJUkLANPeS53uq+8WJHjGxf8vkc5hJJk1iN1IMoMD5/vx1m9sRTZP8e0P3ITdn3wLFs6swar59RZZ\nSinO944b2QycFlXtg04BLKZVjFm+hxIZDCY0a+BH71ijXeXSVpjll/mZO+1WOFnaKKjx/aXz65DI\n5Iz39+SeC/jlgTZ88PE9hW4qrF+nsphRE8OMmkqD/DV1DOOB547jVwfbsXBmNf503aW28poEg+1W\nDYxpwZq/+7U4HnjuuONiksIkyFcu0UL6n9yt5fhu7ddcUJ7YeRZvuGyBxWecEZUebnFsIcgc+bxk\nXp3h2sMKy7bBF82swazaSsNSlszk8NPd59E+mHB2sTDcy3iCrMnm9fHvo/oxwnwOemObXL/2skUz\nODcxip/tMfOa/9519kU9Nd4RW7gyQri5qRtf2tCEZ15rR0UFMLO2kpODce2M6kosnFljWcgl0jlQ\nSgss4Ob2utY+Vsyts2zff+Cx3fi+vqis5oLPeX/X2XVVqK+OGe3n1TPWeI6/fONqm07TaLFsdq3l\nEKh8nuKf/+ewxT3J1Kk/Cx+IqL+bB184gR3Nvfg3hzRkvA8yWxDzJHFgLI0n9zjkmtd3Z9oGEsau\nkH0scxqXDet6IoOlc7S2uO20mQv7UOsg1n9pc9E4CKaH7/MffHwP/upH+/GhH2oGoSc/cptNlqJr\nWFsM2glyMpPD3d/cjnt+uLcgVzqry9FkFvXVMcytqy7YZeHnAwebQcnAlSATQq4mhLwXwBxCyB9z\n/z4ELZuFEgghMQCPAHgHgGsBfIAQcq3tsg8DGKCUXgHgYQBf0WWvBfB+ANcBuBvAd/X7lRUK0q6l\ncphZU2kM4Jct9E6QKysqiuZV1PSZW+ZsUHDKYuEGw75AzQ7HCNPnfnsc7/z2DvzBt7bjfw+0IZnJ\nIX6yB9csm21cw4MNfrNrtRy+3SMaKb7/maNY/+WX8fiOs1gwowY1lTH8/g3LUF9dWUAyr1oyEx1D\nSVBK8YXnjuOPv7sTzd0j+MdfaMcBv+Eya4Ajb8FhZWJR9+9/dDf+8alDxrVLZ9cWlJtS7RCXBBfc\nyMheUg/4+/ufv4aHXjyJmTWVxqAyu9acnNkAVVtV4cnfjS97sSA9/r00d4/iXd/ZYVgRWavgg3+K\nHZhR4DduWJAzWDa3DpUVxHiOzqEkjl0cxuamLiPinY+i1+StW6pOLhYXBxP4xb5WR1mma25dFRZw\nE/V4OmuQmb6xNDI5iltW2hY1FJa2PreuytWC7BbkN2JM9ubigL927ZKZhm/4pVybyVOKvjEt9zN7\nLifr9ylH1xBzEct8p//qR/vw4R9rk9kNl8wtOI6cl2UZHdhE7HTKnKO1ilvMrJqvLSLZ+zrIuSss\nnV2LN12x0JTTP8fSOdRXV2JuXRX6RlOglBqLrdm1lfjxX63H1cus+akoeGu59qyjqSwOnB/A2d4x\nI8fzu25cXlDWnlGt/pkx4YHnjmPrqR7c8VXNBQUA/vEtazGDOyCBlbV3hLcg89ZZ8/vFs2rx+D3r\n8Knfv9qQZXXITiFlY+EjW5rx778+ig89sbfATYKVF9DGvjmMIOvjx68PtVva1BsuMxd6rLzjqSwI\nAVYvmIFOvYw7mnstObjZQoGXZeVdpAczs3f9/a1njOuSmbwjYR1OZDGrthILZ1UbFtNMLo/bvrwZ\naz65AS/bLKz2Lf1lc2qN/stbPa9eOgsr5pkLD/60uHn1VZhdW2Ucjd05nDSs22+/domjKxN7JmZh\nZTq3nnI/VMVpR4uNU3wKy7uvs7o5snfTO5oyXHCMfOB5irse2gIAuMqhLrpHUhhP53DDirkAzLGF\nUoqn97ficNtgQVwQP/6yxdqGI504cL4fo6ksvryhyRjPl9nSXzJuwfSMpc0FL+/qs37NfGOHjtfL\nyC+by9hY8NPd59HcPYrtp3sLxlO+DcyqrdQWkXofSaRz+JenDyPO1Uu6TC3IVwF4J4C5AP6Q+3cz\ngI/6oHs9gGZKaQulNA3gKQDvtl3zbgA/1n/+JYC3EC1k8t0AnqKUpiilZwE06/crK9i3wMfSWdTX\nxAwLpNtBHU6oqiSOq2SLvrz5yQaUWg8WZAbGzSi0xl9fHSs45e/YxWH836cP4+pPb8TJrhG84/ql\nlk5rt4Ysm6P5JzltEfJbWJpufdDWO/vaxbOQzubRP5bGD3acxcELg3jrN7Yhrp80Vegioflej6Wz\nuFQfDPpG045bU3XVMYMQGfLQiBjbXoX+HnJ5ipu/sAl/9vhuIx3e1Utn4QPrV+Iz77wW79XdRDTf\nzgxiFQQLZtRYAksmQp5S5Kh7HmTAnBT+c/MpNLYNGZH/bMBiJGn5nFrn4CVXsO32NObXV2PejGrj\nnW3jBrq/1C0Rly2ybaFTs2z11THH7cE3feUV5PIUb7narLO6qphG9nTZOfVVhq9993AS//TUIdz5\n0Bb819YzeNNXXgFQ2GcozIVBbWUMc+sLCXJLzyg++pP9ePWM09HhlPOl0yffZNbiQ3fpPLOdLOes\njZTCyMhxxeKZqKmsMIhDPk9xoW9cCwg9P2AhJ6zcbJflqqXaRDswnjEyFSycWY1/ePMViFUQ3HXl\nIqssNV0sFs/SLcg2C2xr/zge3myNzmd6WVDVSt3iODCeRvdw0nIq5e2XO1tlx9NZzKiOYfXCGRhO\nZjEwnsExfQt/7/1vxXXL5xSkB6TU3JFiLjzj6axlEXf75QsKF6yghqWW37X48vNNxs+/uPcNuGnl\nPMvOi9NuDns/3375NDYeM31dl8yuxTXLZuO9N19iyLKxa0ZNJWbXVmLf2X78z75WfPuVZsQqCE53\nj+KVE90G2bdj1MGC/LM9Fwz3oJrKCstCy9xh1Ky5S+fUGhZku9VwrZ2Uca46CwyCnEUyk8NBW1Dr\nqgWFOocTmkV30UwzxuX4xWHXgzF4i2V1ZQUWzqrBsJ6Bhem7fNEMPPy+1xsxLby+ntEUFs6swZqF\nM3C2dwwf/vF+JDN53LJKW/i+4bIFBXMOpWbQIlsgdA4nsbulzzGPvx2JTM5wn2LB3VVclo1/etva\nAn2srCvn16OCmOPbp545guFkFn/1xjX467suK5BjriWv0113WF/bd24A//rLRhxtHy7cudSNI8PJ\nDBbNNF3IDrcO4Q1ffhl7uSOr2aKVjxfK5vIYS+eMd/isPkct4t7jfN2txaIXZszMOl324mAC+TzF\nD3eew7pV83DtstlYt2qeZZfFdCXR/N75ReSmpi788kAbPv3ro8b1pWxBds1GQSn9DYDfEEJ+h1Ja\n/ExfOawAwDsXtQG4ze0aSmmWEDIEYIH+/W6b7Ao4gBByL4B7AWDJkiWIx+N+lN0zRkdHXXUmU9qA\n09bWjni8Fx09CdTEgHGdOPWcOYp4hxcvGOBiaxqZbL7o8yWS2iDS09uDHa9qE23LqSbEBwv9j5xw\nulUbBHbt2oXT5zKoJnlcOGVNu1MbA66aH8PhHq3Vr81dwLZOczBNplKIx+M41qxNbFW5cbR3j+Hl\nXfsddbLn6biYQiqdRTwex/HTKdTGgESXtlX3mSe3WmTWzKnAmy+txLmj1sHx9OlmvJg4B0qB3o4L\nmFEFHDl9Fo/2FG6H0cQw9uzabvmusbER505oA+ccaAPdK9tfRTavWTDYEbHXL4zhncsT2LNrOy4D\n0HhRe9Yt8TiamtOoi1GQbBJn2zoQjxcGEa2ZU4GzQ1ZCs3PnLnR1pZBMFNbxxT7tXT+/dQ9uXFSJ\nji4r+R0eHkY8HsehNq3+ZlWk0dqbstwnTykSWa3+7Gi/2IFXtvRhaDyDoZ6LqEUOJ89fRDzej6cP\nFRLtY6/tw5rZFWgdySP7/7f33uFxVdf+/rumqcuWLFmWe5OxcQe5G1u26ZBACCmkEQI/UiA9seM0\nQwAAIABJREFU+SakNwI3N8lNbgq5XBIuN+VCCjWhGdsiAWxwx7333iRbXTOzf3+cMmdGI1kjWxpZ\nXu/z6NGUc+bsmb3POWuv/VlrGVi2bBlbT9k36QzDsarTcceuDxvXg5R5OnZJMNEI+/bt46VGK5fs\ngR2biTY0s/jgaab+cJG73YMvxDS5Dfvix+OWLVuo2medQ9s2rSdS38y+KkNlZSVbT0VYdSRMxMDC\nPclv+OvWb+DgDqvPTx2wxtvajVvitlm+9DX3ceYZTyquI0d48TVrefjojg1k+KJs2bWXysoj/H1n\nE3/d2kzFwAAnasPcPDLI09tjfb5+wwaO1VnPd69veW7s2vQ243J9/PbqbN46fBrvGbBu/TrONFk/\n6M6N1qrI5m3bqYzu5b/X1PDN11+gqjH55OyNN5ayv8Z6L3zK+t0r31jOuuPxd7FSc5wNVbHXwpEI\nlZWVHDluXcPOHLQMtydf/hcLNzcxNB+WvW6dT4lpnZYuXeZeL47us7yab7y1ks0nY5/fz3eak4fi\nJThvvLGUdfvtCcfBDVw5OMAre8NsOXKG8hI/t40OUb93HZV7oaY2Nk6d82HHnkbyQnCmCdZv2UZl\neA8/WWid10PyfQzM9XFm99tU7hP399y6bRsHgtZ4WL9mJSX+ZtaeDrtL8d+ensH/bmxie1WUuaVR\nnvBIUXfs3MkS9lHT0EwIQ0CEjdt2Uek7wOaDtUzpF2DqpZkYYMuRWEnouro6Kisr2b67kQARao4f\n4lRtM4uXLGHJpvjJ/Zl9m+Oer1mzhiP2ODq+3xq/b7y5glUBIWrg/xsfIicoFGX52HyyFueKWVVV\nRWVlJfuP1dEvx0e4SThw3Orjyn1tFP5oaqKyspItuxrJ9EU5fnAvzRHDS4sq+dYb9eQE4f9NNBzZ\nsopwfb1nP+t6dLiqjtG5TUSwLkSLbQ/15LxarijPZEjTbnat3x13zGVvvslrO5opzBTCR7YDcMN/\nvkaGH7ID8LnLM3ngzQam9PPz1mGP5rvRauvh4/VkB4VBeT7+vnwbZdF97NwXm5ztWh8fE7Jjxw4q\nzT63rf1zhH+u283Q6EGeWF5Pn0zhitwjHD4YH1S4Zu1aTtvjyHfKuuf8c8Va5HCQ53fF+jEvHC9V\nPHjoEC8uOoExcPTAXr5UnsmPVzTw16WbqWmMMtXzvYK11u/VKxjldAOsW7ee5gPWb1mWWctK4Lml\nG+lbs4PiYBPOKKs+eYxVb74Rd9y1a9dyqNZq7/7Nq8kPwRvrtuM/tZsDVQ3cODjKlH5+oibMJ1+x\n+rJvtlBrj9c9hxowzYYTh/dT0xhm8ZIlPLGupTOqqqa+y+2y9tKqgSwi/88Y8yPgAyJyW+L7xpjP\ndGrLzhPGmIeBhwHKy8tNRUVFlx6/srKS1o4Z+NdCaGqitH9/KirG8+CafzKgMJsBJfDyxiPcck3F\nWYuEOKwNb8Ps3MoVc+a2mmg+8Por0NBInz5FjJ04HJYuZcrkScwuK0q6fSKH3toLG9YxfcYMnj+6\ngb7NtSyYfTn3v2ndnhd+fo7rwfjZK1sZVpTDgkkDkM1HeGyjdZMPhTKoqKjgjbpNZO3Zw6jB/fjn\n1uOUDCmD1dasMj8zwKfmjWR4UQ4V9vLWK1XrWHvyMBUVFfz92Fr6VJ/g9huv4KcrX+Yfu+Iv2M99\n4SpyndnwS/9wXx8xciSTJ5TCK4uYeOklrDi5i8xeeRwPBijIPsIvbruMzKCPv6zYzycrRlhe4hdj\n+48fP94Kdlq6iismjGTZoS2MmTDZSt32xirACgT7+5eubNE3bN/K3LkVPH14DUV1VQwsyKauKUxF\nxawWv/OP1v6LK/tnsWjzEddbMWPmTP5+ZB01UkdFxZy47ac3R/iP1S9zOqs/FRWX8tiut+BIzLOb\nl5dHRcVs9i/bA+vXM354f/66cj93vlzHa1+ZxwvrDvPU6gNsO3qGJ+6eAS+/Hvf5pf1KuWzaaMxL\nC5k4poxq/zEOVtWTM3Q8y19cypjS/Ljy0VfPm8O7rg3wt5X7+eJf1jJ12jQOrzkI67YyeXg/lu8+\nGXdOvLDuELCKH717Au+dMojRY49SkBPiQ4+8yYCBg5D8DGAzH7huDm//7W02nUwSsGVz3ZXzeF/V\n2zyxwjK0y0aNsryoy1cwe1o528K7eGv3SebOncv3fvIqO4+37UkfO3as5Sld+iZzpk7mv9e9RZ/S\nQZacaesu/D6J+y5zoobr557hU39YRXHffHL75sG6rbzrmrn8ZuM/yS/sTUXFZH6+8XWgikrbwLvz\n2ml8Kuhj57FaPvGHlYwZcymBI2eQbdu5an4Fvyk5zKOv7+ZN21t0/bzZFNgex7w9p/j1mjc8bR5n\nBXqt38g1FbO577WF9C4ZyIgJQ3n9xSU48ftfunoUDc1Rfrlke2wsTZ9u5R9ftZZ5U8bz562rCPYd\nhqk/BRzmIzOG8IFpg7mkJI//eGUblfusybXP56OiooIfrf0Xpb2zuGn+GH62qpIfvGn9vvfMG0FF\nxejYD+s5L6dPn87BVQdg01bmT7+MX69ZyqhLx7F301HYbnlWv3DLLFbuOcWfNsdkUNNnzGD9v3aS\nu38/C+bPY8F8Sw+/dl8V8yaN5N3zRrrbht54BWyHRK59Pvzl4Cr6Np2muaqeotJBVFSMcc/3Swf3\n5aEPXe7uf6q2CRYvZOTIkVYu57fXM3/OTAYfqeHlR6y0gP3yM/nIOxdww/xGFm48wk2TBvDEt150\nP2PY0GHMmD2cyEsvkp8VIj9bKCzpx8zZY6l58QUmjx7OJxdY3spH/rWTZ3ZYnvDMrCwqKir426HV\nFDRUM2H0YJ7dsYnLp83mV5uXA7FJ9q3XzuXrr8WOOXHiRKvo0YZNzC6fyG/XL+eSsRPs1bm13Lpg\nurtCUVXXxNb/Xcn2YzX06pXLzNnTOPLyi9w8ZSgASw/tZM6cubz58hbAmsj4BN5bPojHl1vnWyAY\ndNtaWFfFZeNG8Jet62gsGsXRujXcM28E11xpjYPfbF0KJ07a+4WYMmM2jS++xORLR7JgdF8eWhvL\nRX3VrMtdDyjAh8+sZ+fxGl7ffoIpU6fy9IF1jOhneM+10/jm69b3b4zAJ+aO4O7rRvPhGyJkBn0M\nu+/52JgIhaioqOB7KysZUppPv/xMHntjN59e0hAnSbp2QQW8Ettv2PARTJkxhMYXX2LSmJEUV9Xx\n1KoDrG4oxrCXv947l2FFORhjeP7IWzSGo7y16yQTJkywVpTe3sC7r5rJj1cs5tH1TXzqpjk8eWgj\nBdnHuOuK4dw2dTCz1x9m46FqFm86Skm/IiZNGQWLFjNp7CW8b8ogfrzieTaesNr4y49VcM3P/smw\nohyGDu8HmzdTWtSbfWdOMnbsWCsWZ/ESLh8/muO+w7yy6Sgjhw5kzbHd7nfKLyziqvmXw8LY9xw/\nfgIcqIbNW7l6/lwe3b6Mep+Q2a8/sJ73XTXdXS2MLLTOm3GDi9l1vJaKigp+vvF1BmQEGD+qmGd2\nbGLy1Flsfu1V3jmxP6W9Mnl16zE2Hz7D1pogX+liu6y9tJXP2FmnSu7aO3cOAN5ojYH2a8m22S8i\nAaAXcKKd+3Z7nGVaN3F9k1W+99/ePYFjNY3tNo4hlni9ORLF70sum3A1z8SW3TqiQTbGysM6uDCb\nPjmxZRrv8t7nrhzlPnai8K1j2wJ+O5hn9sginlx1gMfe2O1uc83YfnxibnxdSkHigs3y7Gwfd8wa\nyqOv7+bn75/EsTONXFFWHDOOgac+NZPGcJT3P7zMlYYA5GYEGFKY7aYOmjas0J0olA+NaZd9Ep8P\n2Cnm4izl1TSE3UDBmyb15xZ7KTau7Y40xZZY5GcFKcoNsXJv8vyjjeEIGQEfPhE3sNIN0kuiQc4M\n+pk2rNCVOyQGNDntdy76TrBZJGqY8cDiuG3/x9MPXhxZQkF2kDmjivn+3zfynt8sxe8TfnDzON79\nUMxAc1IHxr63VRiiV4YwpE82/1h3KK5U9ZItR8nPDHCLLUWZN7qvtT/WeNl3so7CnBCFOVZ2BC9f\nvW40d80exjU/+ycfmTEUgO/dPJYPTh/MO3/5upVxxS5Pm5sZoHd2iP2n6pn+wKKksp7hRTlxmk5r\n/7C7f1bIz3+9anniinJDLPpiRdz+Pp9Y5XHFOs8OVddTlGtp6a3ANeuzElME9uuVSXFehptOyWBJ\nOXJDAUSEa8eVcvWl/Rj+NesG5pU3OEvjw4tz2HmsNn6cZwbICvr57Wu7+O1ru+KOedOkASzZ0lJD\n6iwXOxKLH9iSheHFOXz3nWPdwgC5GbFrR2yMRcgI+lroGWcMj5+Elw8pcFOwGQNHzjTQJyfkfq+6\npgiHqxu4tDSf5z97BdAyn240amVHyfMs1TvBiYklnh1dZ3bIHwtAs8dgfmaQ6rrmuEI6iaeZdyw7\ny8W5GQEu9yyHl9k66D65Gbx/6mAS8eqBMwNCbkaAmoawqwX1StG8/euVO+R5shztO1XH2/ur+Pic\n4RgsqVBGIP567s2G0sfNQGPpu3MzAnFyl97ZIf78iRl84L+X0RSOcqCqnkjUMLw4l6q6JsJRw/8t\n38tDlTHt8mMfm8qGg7HJsRO0fKS6gb55mcy7xDqXf2ePvTllMTnQ6H75LNt5kktK8jh6psGNLSjO\nzYirdPn43dPjjGOA7988jmfWHOD17ZZn9WBVA5MG9W4hGXQkO8597k93TeOu/11BXVPEDaI9fqaR\n3sODDCzIIhw1LYqftCyEEcu9XZyXQf/emfxh2V4eX76X0f3y3DSXIsLv75zGyj0nefdDS62Ue3b/\n986KSSV+XbmdZ9ce5MoxJdxjT+o+MM0aP7M2L46T9eRmWteDEcU5btGcPrkZLP+65ZQ5VdfMK5uO\n8sm5I3hr10kMMSlRflbQDdp1dP2XlOQxaVBvbp85NOn3rGuKEAr4CPp9DCvK4S8r97uSDm/hob98\nYgavbjnGoeoGtoStlZ5jZxoZ2ifHlQAu3XmCE7VNzBtdzLsmD+Sr141m2H3Ps7Oq+yZCbtUCM8Y8\nZ/9/LNnfeTj2cqBMRIaJSAgr6O7ZhG2eBW63H98KLDaWlfQs8H47y8UwoAx46zy0qUuJJdiOBell\nh/yEAr74yOl24GgYEyuwOfxy8Tb3pPYGALWnUIiDc/5EjWH3iVqGFeWQn3X2mjHxGmTrv3Nzun58\nKRDL/fnoHVP49jvHJj2282tV27o4gK9fP4Yn7p7OTZMGcNcVw11viMPkwQVugIExxjVMckIBPjBt\niLtda5kVlt63gP+8bbLb9j0nasnLDLgBGPf8cRVPrz5AQXaQn79/cgs9KHgmFjhpsIIU51nBZsmq\nCDVFooQCvriAPEPyKk8Oc8qK2Xa0hoNV9S2+izMpcbS4oxJ+I8AKxMnN4KnVLeeZTr5ZsAonvGvy\nANdgrfxSBZcPKeDn75/Ea1+Zx7b7r3MvtF7N+v6qOooyhSlDC4lEDW/ZVRLDkShLthxjzqjiFhNC\nETsQ60yjq5fzGkNgee0Cfh+LvljB7TOHAlapdCewzaupzcsMuBf1ROP4ztnDKMoNcWNiIBixMZOX\nEZ9O77pxpS0q6rlttw9+sLrB1S7nZwY5VdfE6YZmt6CGQ6xssPWjGWPdhAs9mkOv/tz7uCg3gyc/\nNZOfvncSYBkpNY1hMuwbW6K20GFgQZar6431VSwHcqLm91RtU9xN1B8n7LX+NTRH3eM6PHrHFGaN\njM8u8ugdU/jGDWPcYx493UDf/Ez3vD5c3cDh6ga3HwEu7Z/PL26bzP+79hL3tRpb5+jgPE4c4yP7\nWs9zMgKxbBJN1vXWSZPozRX99Rvi48XF6RcsIzwU8JEV9JMR8LPw89aKzsdmDyOR+GwUseDkTD9u\n8NJKu8T45MG93W29GXi8eZsLc0KMt/WrD7ywieaIYe6oYr52/RgeuX1Ki+M3R6OWkeP3UdY3j5yQ\nn3v+tIo/vrmXmSP6JL2eONdap3z6oIIsCux0o19/an3ctkMKc+KCkJ2r2YGqegYUZNGvVyYTBvZi\nrZ3y05sj/UvXXMLv75zKtOGFRA1xRmfQ7yM/M8AVZUVxAYteHGdB1M6m4QToeSlISJM6c2QRG75r\nJb0yxroOnG4IM6okr0XpboDv3dTyXmQS2upkaTKGpNd/7zld2xjGJ1aQtoNjrAZa6wvjKcxlj+/H\nPhYLufL7hIDfR8Dvozgvgz9/fIYbC+Fta2FOiA9PHxL3+VFj+LdbJ7hVGb2xEE1hQ11T2HV4JAaA\nes+7KUML+dI1l9jVTiM0R6IcOW2dv44e+hu27niK7YASEZbdt4CvTT/nnA+dRlsSi+eIjfcWGGPe\neS4HtjXF9wIvAX7gd8aYDSLyPWCFMeZZ4LfA70VkO3ASy4jG3u7PwEYgDNxjjOnGUu/kOLaREzzn\neJA7guNBbi2TRXy5TEO9XT0oNQ+ydYyNB0/TGI4ytCjHvWF6T/hEvLlhYwGJVrR7ZtDPgtF93Who\nx+PQ8tix32vPiTq3wmDA72NaKxdQd1/Pdcc7E58+vA9P3D2dnyzcytevH5N035L8TIbZkcqWsdVM\nQXaIwX2y+WTFCB6q3MHmw2e4zHNzS8QxLqvqmqmua6Z/ryyK8zJoaLaCJ3IT+rwpbEWUe9ttBemR\nNEgPYM6oYu5/fhN/enNvi1RiiUF6oz3Gw5euHsVtUweTkxHgh89valEe1dnfyXfaK8syjF/5giXl\ncQzEmya1DAEQz41h9/E6BmZZBrLfJ6zac4rLhxRw28PLOHamkRsnlLbYPxTw0RSJsvtErRsIlxil\n3Te/ZZlx77Exhj0nrOIVhdkh3jGxlIf/ucPN1PHLD0zmTEOYd182kG/eeCnPrzvU4rvXuEFZfuaP\n7svizUdZ8Y0rKWwjR7mIYDAcqorlTx7SJ5uFG4/wy8Xb4/ISr/vO1a6h4u3zTYdOt8gZ/I/PzE6a\n8uyywQVucZ0mOy2eM65yQn6SxfKLCLNHFvGZBWX4BH72yjbXg+xkaPCyICHo9T3lA9l+9AyN4SjP\nrT3I6YZmDlXXM9C+Of/o1gn4RZKe03mZQdej6RgqJfkZlORnMqok1/ValyWkunzHREse5OxX2xSO\nS0/2mw9dziubjtA/YZx89bpL6Ncrg70n692qarWNYfrlZxLOslZ2HIPwkY+Ut3RQeFaBTtmZFpxr\nX1lJHlt+cG0L7y1Y3r1a+3O96TEzbQ3wos1HeW37cXpnB+OyFo0pzeepT83kkdd2sXafFS9iFS/K\nY3S/fEb2zeX17ScIBXxxK15gBYQ6Y6E5HKW+KUxWyE9WyM9P3juRH724BRHLQE2Gs1rn5GMeWJid\n1IGw7L4F9OuVSa8D8bm/w5Eoh0/HJoblQwp5e7+V8tPrdczNCHBFWTGLNh2NS0fnbLP6W1fTyuXO\naqf93vGaRpoiUfrbKdD++okZ3PobK2yqIKflBNY7yXMKTZWV5LaoXjp3VLG7KpWI09ai3BClvWJj\nJTG1qLedzmQ9L9MaO3+4cxrPrDnA4s1HOVHb5E7wE/f1rjw4hUIGFrTMDOXF55nwOjUFhvbJoTgv\ng4yAz70XJAb2L/7SXJZsOcY3n15PYzhCbWPEzQAzKeEel+hxBms1s6E5ws5jtTRHDJeU5LnXESew\nu7/n9+rXK5PNbXVymmnLGvtxZx/cGPM88HzCa9/yPG4A3tPKvvcD93dqAzsZb6WySNTQ0BxtV2W7\nZATb8CAnFiLwLhMmeuTaxB7Hd//eClqYYKeqWfzFuXE3qRa7ibDw83P4+aJtbiDbaU9VoEduL4/T\nhiUjKxSgvinCuv3VHD7dEOdtaWez41JYOcbDtOF9+PPHZ7S9v+fm6DU8vnLtaHpnBXnghc1Jb44O\nj75uLS/e9+Tb7Dxeyw0TSt1I7GNnGpMbyLbEwsEYyzOYzMsAVpqrsr65PLX6QIv0ca6B3Gwtl/XL\nz2TiwF7cctnAuIvy3FHFroHslRoYYmnDnAIrybwtiTjNP1TdwIGqeuaMDpEV8jOqJI+391fzs4Xb\n2HDwNMV5GS2ML7Amb9X1zew8VutmJClJyAzQWqYA59iRqOEf6w5yRVkxPp8wsCCbt75+JVf82xIO\nn7aWZb03mxYR8sTLFX79wcs40xBusV2L44O99FvPLDuyfGz/fB5fvo+H/7mTK8f0ZfLgApbvPhln\niDp93tgcZdfxWneFxSExx7SXDDvtW1M4anlW7XMysUhI7+wg37VXaQJ+H1+4ahRP2ysHUTsln+MV\nfPqeWQT9Qkl+ZotrRX5mkAdumcC/v7SZqIGVu08RNbgT1sR8xy1/o5gH8MjpBlcW8YvbLuOTf1zJ\nzmO1SR0GsRWZlhKLQYXZ3DGrpSd3ZN88fnDzeO56bIUrB6lripBtf/6izUc5dmYd0NIQAI/BYaxl\n7ETPZGvnv/fcjnomW1mBWOGNxnCUOaOKW0x+Jw8uICOwxz1/T9Q2upOKWSP6sP1oDZeU5LVI9/c/\nd0zh7f3VfOqPq2iOGNdTDnDtuFKuHddyMurFMcqcfOF9ckJxBauuH9+PD00b4nr3vauIBiuVWSRq\n3CxAlw3pze9et+5NyYwq53hOlgzn3Gpttczdzx4JjgfWmTyXDy1k2rBC3tx1skU/JR7TySoxsji3\nxapSoqzD/Y5JjHmHEcUtU7N606NWeYpUzS4rOmv8j0+syYqTjtTrbJo/um8LKZH3+4E15nafqCMn\n5HflJgN6Z8XJyLwMLMhmwei+fBNrlbm+Oew60S4bXMDY/vlxkppEnPSlTk2ES/vnt7j+tObk6Y60\nlcXCDYy2JRCjscbUFjstm3KOOBILSycWW/rvCM7SSLJUbzsTCiBYy4R26qxWlojbg5PbNTGtVzLK\nSvLs5VPrO5+obWKkvZ+I8P2bxrpBR8kozAnSFInyqyXbycsM8K7JSZOWJMW5KBuMW1Uq0RPZHgx2\n6hrPDXnuJcU88MLmuPReiQR8lif0lU1HCfqFmyYNcNM07bGlKl5iBnL8sS19efKLi4jwmQVlfPr/\nVidtN1h93jvL8l48c+/sFts5XvlxA/K5/+bxPLf2IP9YdwhjrNzKfp/ELXmfDed3f9Ou9nZJgTVG\nJwzoxRMr9vH69uO8t3wg37tpXNySvEN2MMCGA9WEo8aVzswuK6LQk2bO673x4hiaS3ee4MjpRr5x\nQ2y8BP0+fvfRKTz39sEWnsLhSVIrnmkIE/L7XCOoPakRRawxXtsUcY9x44T+/HLJdob0yeHH75mY\ntEqm07t7TtYSNS3LdrdFbJJsLeU6xllp7ywOego6/OoDl7lGu7e94Gifm12jZ9Kgs09EHY/jsl0n\nCPqFywYnNyxa7Gcfs64pwtEzje5qwCX98lj8xQoWbjyS1Ejx6oFrG8MpncvOkjVY/ZoT8jOkMJtF\nm4+y7WgNI4pzkk5+vNeQU7VN8RUT2yDg957Exk1HVpAhNHlyL7+vlcmEYwTWNoZpaI66E9OZI4t4\nbOmeFnpZsIwcxxvaFIlYedtTdLxYKwnOuPfFGZo/ec+kuM+Lk1gY4+bOdTzIZba8JYmazP2OjpTK\nJ+2bfENsHCy00w96r8GPfWwqL204zMSBycevM4E9ZecCL8wJxQXmPX3PLMZ7vMHeVU4r/3YTIrRY\nRRpU2PJ65B07J2sb210d12ln1FirpiLxnuPffbSlpMbBkT9FolH2n6pjUGG2247ffXQK/7loG0+u\nPpDUwHaubw3NjgfZb3+m8I/PXMHE777MzBHJV20zA36iBt7YcYK8jAAji3MJR40tvYhScUkyCUr3\n5azWmIjcAPwGK2xVgGEi8nFjzAud3biejnPB8OaqzM7ooAc54ATptbwKJeastCptNZObEUhqmLRG\nYtWfZN6AtnAuSmcamtl5rIbrx8USsH+4laUsh0I7GHDNviouLc1vsfx7tuNiH/u1bccpzsto90UY\nYsaW40H2ei1H98vnoQ9exqw2PAGGWJ88cvsURvbNpbRXJiKwem8VFQlL0I4G2TvTjkatVYaMNqQs\niXmf3ePbA+1kXVOb3zs7FODlz8+htFcmeZlBJg7qzQvrD2Mw/GvbMcYN6EV2ChM4p/XLdp0kNyPA\noDyr7eMHWgZyOGq4Y9awVg3OzJCfLXb5acdALsrNYNU3r2Ld/mpe3Xq01Ru/4zH71zYrzdr80fG/\n8aX9813dnZei3AwevWMKb++r5j9e2UokGqWmsbnNFZLk313cnKoTbSOzICfEa1+Z3+Y555xSjmcr\nFQPZ8SRuP1rDos1HXU/VF68exZf/8rZruLQowe7BKQ6Q6KlvC8cb99auk0wY2DtlY+zGX1hp8hLH\nZmJBCO/xIObdT0WW5ozJB57fxPGaRrJDAT6zoIxXtx5j3YHqNg0qgCdXHWDz4TPcML5tL6zDpypG\n8Ik/rHLbu+tYLSLQJ0viVnrmJNWuxgx65zxwxsPMEX0Y3S/PLWCSiDMWmsOGeo8HuT1Y8qDYRElE\n7GtCgM8uKGvRv95Jc9TEcuc6gZpOEOmHprcMXATLO+8Y1k45+PaQuJnXQM4M+pPKvhK/Y3W9dR8M\n+H2ud/6GCaUtJoYPfehyquubmXL/K5a3+0wjfXJCbtzE7z5aziubjia9LzkrO7WNETYePN3quG6r\nnXtP1NEvP7PddQucPM7NYUsq4w2aHVqUw0/fN4mrx/ZL6sF25JIN4aitQY4/v9Z+++qksTPWvlb7\nnl5zgOvHl+LzCSGfsPG71yKSus2QbtpjHf0EmGeMqTDGzAXmYVW1U84Rb4YCN/l8hz3I1sBMJrFw\novgdnOWzVL3H3kpsL39+ThtbJse5ka7aW0XUwNRhbWuHvTgVwQ6fbjjr8nYizgW3oTnKq1uPcfOk\n/imdqI5R2hiOJr0hXze+NM6LkkimZ/nVSeSekxFgeFFOXHo0sAzh5ogh5Pe1yFgRjpr4wKgEskL+\nFnINL1aVqrYnBqM8mjGw+mz70RrW7q/mxnYaBQ7OxfKtXSe5fEiB2w9OJHtRbkacHjoKP+g0AAAg\nAElEQVQRpwx6wCctqkqOH9iLe+eXJdvNPXZeRoC6pgilvTJTMqLmXdKXW8utbCSuXCHF2ICAX4hE\nrX50igIAZ52QOu9vPhxvELUH56b4h2WWTMbRWc8cUcTT98TSCfZNYvw650Ndk1UlMLGYR1uIWB7A\nzYfOxH3X9uznJTEIqNX9PNr2Myn2jc9uq1PuOCvkIxTwuXrcqxOqpnn3g1i/bD7c+jKzl2vHlbLr\ngettIxBW7T3FqL55ZAaEMZ6x31pVRMG6Zi7aZHlJHcMtLzPIi5+bwxVlyQ1rZyw0RaLUN0VSCsb2\n2Z6M0x6pTWbQz9pvXc1dVwxvsX1Jfia/v3Mq143rhyGmXXYM1sygn1XfvIrvvnNc8uP5hOaoYc3e\nKi7pl1wykIzE8VPQTq8+WNKrqkYTdx/MDgV47t7ZPHjL+BbbhwI+dwLnBL5570PzR5fww3e13A9i\nq7RPrtrPqbrmFpP1thCBY2caeHL1gZRkhc6KcmM4ws7jtUlXea8d1y/puePcr361ZDvLd59KOrlq\n7f7pGNeRqIkLWPT55IIzjqF9BvIZY8x2z/OdwJnWNlbaj7eSnhPd3HENsn1BTFJSNjGlVNRYmtL2\nLhM6fMCTuiiVpXaHzIAl4F++6yR+n6R0wntP8FS8v2DN4AU4fLqecNQkLX19tv3BMpCtylKpGUtf\nuyEWAOj1jvTvndWi5LMjkckIxkssosbyILemQXZI1qfOODtZ25Q0aKUtRODt/dX4fcLNKchaAIZ6\nKnOVe5bKB/fJ5r8+fDmP3z2tzYumcy6MKM5t1YBoC8cjlEw2cTa8fe7VnbcXJ8vJxEG9UqpW6Yzt\nncdqKcgOprQc6/xGzhjylmb2Tobzk3jDD1dbRs37/msZdU2RdsmmHJwerG+OpGZYex7/+eMzWsg+\nWsPpm8PVDdQ0hlPK+CPizR5kyZ8A5pQV8cZX53PtuOQGcmbQFxfh/9EkOufWj2kZB1FjWL33FJcN\nsa57j94xlVsvH8in549sY1/Ly/mrJTu46tKSdnv2nbY2NEdYuvNE0jLqrR4T3GVy79htSzt6RVkx\ngwuz3RWIguxgnOexMCfUqmd4YEEWTeEoO4/XcnUK3tXEe2WqBthrB8KctrMKOYwf2KvV1Umv9v3A\nqfavsjifX7n1GEG/tLrSl4ysoN+N2/nw9KHt3s+ZaO88XktTOOrKGduDzyeEAj53xTg7hWtfhme8\nTBtW2MaWFwbtueusEJHnReSjInI78BywXERuEZFbOrl9PRar7LH1OOoptZrqUq5DMOHm6MWRWCy9\nbz6TBvW2Rf/t19E5eDXCeR3ItpFje/TW7q9iVEleSl69Us/FqC29bzKcZar/e8tKZp+foufc0Z7W\nNVqlc1ORd4ClX0tGn5xQXDltiGWacNIyORjTtgbZ4cFbJjCmND9OW+aMs6okwUVnw1nRmDassEVA\nytnw5jJNLIF7zdh+buqt1nCMw8TUfe3FaW8qXliHkCfg7XR9OOXz0vGktkfD6yUz6HcN2FTbHfSs\nLlwztsRNTwjxHspkhoQjzXKW/UekcOztnhiHRE9/W3ibUd5KQFQyHB3mzxdZRUpS+Z286SIhFosg\nIm1eV0TELVf9tetHt0iXddbjYkkWTjeE3UCuwpwQP37PRL54dfJsEtZ+4srvzhb06MUxkH5lF4Hx\nprA7a1tFWHegmpO1TVaRkXbvaP22b+48kdIEa/rwPrbh2Jf3TWn/d/ROWFJ1mji8sulo3ISpLZzx\n2hiOsvHQ6aQSrWRkh/wE/dbKRf/eWSnVN3CMa79PWg0aTIZjDzgrlCNSmLgCZHjaGIm2P0+xd6Ui\n1ft0d6Q9PZUJHAHmAhXAMSALeAdwY6e1rIfjja2IK0bQwTRvzoBuTuJBrmuyci/2y890c8serm6I\nK+CRKh1ZLnG+26ZDZxiRolfP5xPXozqkT2oe4HPFkVh857mNAPRO0cBu7YLoFK1w0jhBbAUgI+Dj\n+zePc72wBtrlQZ5dVsQLn70izlPs7FtVn7qB7EwmkqUvOhtBv8/t8470mTOB66iB3MtOxt9apou2\niC1RWimrUv2MWy4fyB2zhvLBaakZUgBFtmGfipEBMc8PJI+mT4XBKfTXnhMx7+SIvikYq7ZPrjAn\nlFJku7MC9Oauk5T1zW1Vv5uMgM/nBigX5Wa0qVNNxEmv15FzQSSW5ioVY86JLQGYMrT9BpIzDhyZ\nze/vnNrW5nE45Z1TxSdCUzjKjmO1bq7b9jCqJI+V37yKR26fklJMjMPAgixe+cLclPdzcGQzZ8O5\n5zmFUmaNaN+Kh4i43ubEAjpnw7kGDirISmkVzVlRdrzPqXiQgTh9/OHqtquNehnaJ3b+t1dL3p05\n6y9ujLmjjb+PdUUjeyLeWWvUo0HuqIHszBiTBek1NkfJDPoREYJ+K5H30TOxPJVdheOFO17T2KEZ\nv7P8ObadM/fWSNV4yExI4ZSqRCPoT36hcNJT3fSr1zlkL3E7KwChgI9L+uXx+ausioSuxKKdN5CA\nx5tojOFEjZV6qaSVvMGt4Xi0O+KFBfj4HEuz2BFvwkdnDuXqS0tS8ip5cZbiU5EpODgGcnV9Mwer\n6lPu8/zMIN9+x9g4L3p7cUZLaymc2sKpZJYss8NXrh3NJyYm7/+IZ8Ye9Eur2UGS7xt7XJxCfMAO\n2/OciuEH0Cs76GrX31s+KCXDIT8r4K7afPPGMSkFFH75mksY2iebqSkYfw6CcKLGMpDbytaTiFNx\nLVW5jXci/ZVrR7eqVT4bD3/48rNvZOMcMeT3cfecllrltmgrhqM1nEncnbOHddiDDKSUEclhwei+\nLYrftIVjOA46S/7iREbbmuxUr2He1aSi3Ax6pbha7M2O0pjE6dYaHXVmdFfak8ViGPBpYKh3+3Mt\nFHKx470hxeVa7aiB3EYe5MZw1NWShfw+tp+oIWpaT5HVFk/fMyupzrk9eL2IHTFaHrhlAh+ePpQh\nfTpmrDltSNUD5DVwv3HDmFYDeVrfP/kN3Ju/dcYDi9n94A3ub+vc9N0UQca6aJ3Ng+zg1ecZcNNL\npZKdAGBIYTZr91WlfGF3uHf+SO6YPaxD43pQYTYPf6S8Q8eFWL9ldEC/7PMJIb+PZTtPEI4aylM0\n4s4FZ0m9I5MS58bWJ4mh+smKEVRW7mtzP7Bu5ql4f2aO6MOmQ6f52fsmpbSy5MQxfHRm+/W8Dr/9\n6BR++I9NKckOIN4QS/X6d8+8kW4p4JTxepCzQ5xq526OBzFVeZO3HzqiwQe4oqwopWudM2ZumFB6\nTgZreyntlcWG717T4bgdsIom/futE1Le76vXjU5prDvX3VTH3LxL+vLThVsZlOIE3bsiMzKFVZ2W\nxy/mvlaKaCUjFPAxfkCvdgfcdnfac9d6Gqui3XNA9y2a3Q3ZeuQMO6sjVCR5z8RJLIynWldHDWTr\nhEg222tojrhGQijgc42lZKU5z0aqmkovoz0RyqlEHDv0ygq6uXo7yrP3tMz/eza8F8JbLx+Y8tJR\nawZyMmPVNZDtrCSxFHWmzVLTidw+c6hdaMFPVV0zmw9Zy4ipLtt/4apRFOVmdNhAFJEOT/rOFed3\nT5Yrtj2EAj7e3l+NT1ovGtAZOMubyXKqtpc+KRooXp1hslLkbfHV60Zz+4yhKckyAN5z+UDKhxSk\nPCbBKnbwqw9elvJ+XsOtI7nQO0rQJ24O9sKc9hvIjiQq1Ymtl1RXzMaU5rPp0OmUJ5aOEZcYV9GZ\ndPR+6TC8OCclTbBDqnEsN04s5W+r9qe8WjJuQD73v2ucm/mnI6QSOJvIfdePSdnYfe7Tqd9juyvt\nGRkNxpj/NMYsMca86vx1est6AP/+0hYeXZ88OCLisZCdhPciHc9ikRFo24PsGsiei0FJXtdKLApz\nQu73O9cLW0dJdakpkY4sBbZm1E73lMh2ZCMtPcjW+06hkPZ6kKcP78NLn5/DgIJsK0ft7pMUZAdT\n1n4PLcrhW++4NKVMDN2F99tZV1pLan82nElrYuq7zuYjdgDY2crJtoWTwaO9eC8bpSkaY0G/L2Xj\nGKzJU0eM43PBW/zhXIzOVBlalENNY5jskD+lDEDTR/ShMCfUasnjtnAmAKnKgz67wPKSpxpncs3Y\nfkwc1Jt7O+pl70KczCF9O3gPTKkCLZYneM23rmJmOzO1OIgIH5w2JGUPMsAHplnXv6HnsOKaasxK\nT6M9BvLPReTbIjJDRC5z/jq9ZT2AoJ0LNRmJGuQzDWFyQ4EO5wpsS2LR0ByJSSwCXm1S1w/+L9v5\nRjua7zndnM8ymSX5mWz63rXcMKGUentZvSli/Xf6yeeRWKTiQXbba6e1enr1AcqHFl6QuSg7yuVD\nCtj94A3nJMkB+GCKGQvOlc9fNYrN37+2Q5MSZyLcJye1JXmv/KkrDceuZoKnEEhHUgd2lKl2yquJ\nA3unFIg2oHcWK79xZUrFJRz+cNc0HvlIecrf07k1pXqp65UV5Jl7ZrmlxrszznfsqAGYSl5ph47I\nCs+FSfZYn9zOypbJSDXTVU+jPVbKeODDwHxiEgtjP1faIOj3kSRmDgDjsWONsdLwFJ6DwepcdJPp\ng+M8yJ6LZSrBIueLj8wYSlnfvJQCHM4Hn70sg/z+I7r0mIkk8+RkhfzkhPyu7tSb5g1iEouoMYSj\nJuUob8EqUwp0KLhIIeWUXueKiHTYY/+z903iqdUHUr6xvbd8EPc9uQ7oeYE2XlKt8ne+uGPmMNYf\nqO6Qhrmjk9oRxbkdymYyq6yIcQPy20w/d6FTXW9l90g1p73DheBoeE/5QKYNLzwnB0FHsor0JNoz\nOt4DDDfGtD+RogJYmQSSxbPtPVHHnH9f4j6PGqtaTlslYM9GqE2JRcTN5esM+N7ZwbQMfr9Pkpa3\n7Gwm9w1QMTv1YCCHgE/omJLV4qXPzWk1g0R2KEBdk7Wc31aQXkc8yN4L+Ye62NBTup7rxpdyXYoV\nD8E6L/941zRW7TnV7oIdFyqP3jGFrjZvBvfJ5i+fmNnFR+0Y+ZlB/v7pK9LdjE7FyRqVqnRqbP/8\ntMVUpIqInPPq2cVOe3p6PdAb6FhyxIuYoF+SepD/ump/wiuGY2cazyny0/UgJzlgQ3PU1UzFlmAv\nbm1Rqqz+1lV0MNYLaNsrl5XEg5yRoEG2PMjt1yA7OFvfOKE0bd4z5cJg1siiHm8cg6UHVS5upgwr\n5MnVB9yKl+3lmXtmXRDe43Nl2X0LaAxHzr5hD6c9BnJvYLOILAfc8FRN83Z2Aq1okFfvjY9hjhq7\nytk5GK2hs0gsigLxGuRkaaCU1unMIK2ckJ9w1NAUjrb0IHu2C0dS9yA7H6ATotSZOLAX+0/Vp7sZ\niqKcZ95XPgj/8e2MH5hays+OZLy4EEklkLQn0x4D+dud3ooeStDvI5zE63jsTHwanKhxqpx13Ahr\nS2JhBenFZ7FIR4CekpwsO2CxvikSV0kPYkF6jgY51Qu0U60s+wJZFuxOPHNvz0lXpChKDJ9P6Jt9\ncRi7Ssc5610zMaWbiMwGbgM01dtZCPp9JLFXOV7TyPunDGJ2WREPVe7gdH0zkag5p5QqfrsUczID\nua4p7KZXc6QYThleJf04fVPXHPZILOw8yLYH2Mnlm6rEwslvm6PyCkVRFEVpN+2aQonIZBH5dxHZ\nDXwf2NSpreohBHwxDXJzJMrz6w4RiRpO1jZRnJfBjRP6kxHwccxOrH6uaWCCfp9bqthLXVOEbNtL\n6Tgg81PM46h0Ho6BXNsYocnWfSV6kMP2QEpVYuFom7Mv0LR6iqIoipIOWr1risgoLE/xbcBx4AlA\njDHzuqhtFzwBO82bMYZfLNrGfy7ezg/fNZ6oieUazQr5OWxXWDoXiQVYMotkGuT6pogboFVrG0yp\nVgJSOo9sj8SiMUGD7GiInZWBVD3ITlW2nAz1ICuKoihKe2nLrbQZ+BdwozFmO4CIfL5LWtVDCNnl\nn5sjhj++uReA9QerARhYYJWRzQr6aba9g+ealDvk97WQWDRHooSjhmw7r+ppO/9jqpWAlM6jlz1Z\nOVnX1DKLhb2NszKQqge5Xj3IiqIoipIybUksbgEOAUtE5L9FZAF0efrICxonoOpwdQMnaq000psO\nnQZiZWQzPAUBzofEojkhKtBZYnc8yE4FoAG9s87pWMr5Y1iRlatyx9EamsJR/D5xx06ixCLV3NVO\n/6sHWVEURVHaT6tuJWPM08DTIpID3AR8DugrIg8BTxljXu6iNl6wOMvh33lug/vahoOOgRzzIDsU\npVgeNpFQoKUG2fEY59tpyr5w9SgG98nWXKDdiKLcEL2ygmw/VkNOyO9mGoFYkF5zRz3IzepBVhRF\nUZRUOas7yhhTa4z5kzHmHcBAYDXwlXM5qIgUishCEdlm/29RLFxEJonIUhHZICJvi8j7PO/9j4js\nEpE19t+kc2lPZ+HoSBdvPoqIJYFoCkcpyg25pWSdqjxBv3S47KVD0C8tDOTjdgBgUZ7lnc4OBfjI\njKH4Us2nq3QaIsLIvrlsP1pjlQUPxk5Lx4PcUQ1yg6NBVgNZURRFUdpNSuu1xphTxpiHjTELzvG4\nXwUWGWPKgEX280TqgI8YY8YC1wI/E5Henve/bIyZZP+tOcf2dAoBX+znfeGzV1Bsl5IeYMsrAPra\n5Yezgv5zrtAT9PtobI43kJ2cy8W5mvi7OzOyOJedxyyJhaM/hpimqbmDWSycrbWKnqIoiqK0n3Rl\nyr4JeMx+/Bhwc+IGxpitxpht9uODWKWui7usheeBgD9mzJT1zXODsQZ69L/97GwWySrupUphToiT\ntfFFSI4leJCV7snIvrkcr2niyOmGWAYLaJnFwp+agXzVpSWApvVTFEVRlFRI112zxBhzyH58GChp\na2MRmQqEgB2el+8XkW9he6CNMY2t7Hs3cDdASUkJlZWV59j09rP7UBiAvCD865+vYhqtsrVNp4+5\n7Th8wloCbwxHzrltUt/IzhPxn7NiuxUcuGHlMrZcxLKKmpqaLu37VDl9xBorG/YdJyC4bd180hof\nGzdvAWDr5s1UVm9v9+dOzzEMmJbJxlXL2Hh+m5wy3b0PLga0D7oH2g/pR/uge9Cd+6HTDGQReQXo\nl+Str3ufGGOMiLTqPhWRUuD3wO3GGEc/cB+WYR0CHsbSRH8v2f7GmIftbSgvLzcVFRWpfZFzIHf3\nSX69dimjBxRQUTGTP+xZwaaTR5gwajgVFWUAjK5u4EfLF1GUm8m5tm1nYBev/30joydPd2upv3pm\nA7n79nPl/Is7fXVlZeU5/76dSf7eU/xi9RucaIDR/fKoqLgCgKydJ+CtZQwZNgI2bmLCuLFUjC9N\nc2s7Rnfvg4sB7YPugfZD+tE+6B50537oNAPZGHNla++JyBERKTXGHLIN4KOtbJcP/AP4ujFmmeez\nHe9zo4g8CnzpPDb9vDG2fy+ml/r59k3jAKtgCEBhbkzu0K9XJt+88VLmlBWd8/EuH2LFOq7cc4ob\nJlhGVGM4SmZQa853d4pzLS16JGriJBZOMGViuj5FURRFUTqPdFlOzwK3249vB55J3EBEQsBTwP8a\nY/6a8F6p/V+w9MvrO7W1HSQr5OcTEzMZU5oPQMQxkBPyHd85exhlJXnnfLxL++cTCvhYu7/Kfa2h\nOUJGQI2q7o4TwAmxzCYQC7KrbbIkGN60gIqiKIqidA7pMpAfBK4SkW3AlfZzRKRcRB6xt3kvMAf4\naJJ0bn8UkXXAOqAI+EHXNr9jOMZNRid5dIN+H4MKsthzotZ9rbE52mnHU84fmUG/G8RZ4JlAOYlN\ntCKeoiiKonQdabnbGmNOAC1SxRljVgB32Y//APyhlf3nd2oDO4nvvHMsBTkhZo44dzlFaxTlZnCq\nttl93tAcIVM9yBcExXkZVNc3x5Ucd1L/1TY6Egud7CiKoihKZ6N32y6kJD+TH75rvFskpDPIyQhQ\n1xx2nzeEI6pBvkAosrXpvbM8BrL9v86RWKgHWVEURVE6HbWcehhZIb8b0AWWxKIzDXLl/BGyPf29\nPRILp5JerROkp32pKIqiKJ2OGsg9jOyg39WrguNBVqPqQqDRLgs9oCBWSMbRINc1Wh7kbM1ioSiK\noiidjhrIPYzsBA9yQ7OmebtQuHKMVS9nZN9c9zUhluZNhLgy1IqiKIqidA4qaOxhZGcE4jzIjWFN\n83ahcOfsYbxjYn+3yAvEPMi1TWEyA343aE9RFEVRlM5D3VE9jOygn6ZIlOaIVXSwsTmqXscLBJ9P\n4oxjiGmQD1bVU5QXSraboiiKoijnGbWcehhOpTVHZtEYVgP5Qsbpz+aIYVhR7lm2VhRFURTlfKCW\nUw/DKSThyCyawlEyNEjvgiXHE5Q3rE92GluiKIqiKBcPaiD3MJwsB/XNjgc5Qsiv3Xyhku0pOz24\nT04aW6IoiqIoFw9qOfUwnJRuDc0RwpEoUaOZDy5kvHmPvQVEFEVRFEXpPNRy6mE4Kd3qmyM0hq1A\nvZAayBcsfl8sa0VupiadURRFUZSuQC2nHobjcWxoitBkG8jqQe4Z5GWogawoiqIoXYFaTj0MJ+tB\nQzjmQdYgvZ6BepAVRVEUpWtQA7mH4WiQ65uirgdZg/QubByVRa56kBVFURSlS1DLqYfhSCwsDbKV\nySJDS01f0AR8Vv+pB1lRFEVRuga1nHoY3iwWrsRCS01f0IwbkA+oB1lRFEVRugq94/YwnCwWDc0R\nquqaAeil6cEuaH57+xTePlDtFoFRFEVRFKVzUQ9yDyOmQY5wqq4JgIJsNZAvZApyQswdVZzuZiiK\noijKRYMayD2MoN9H0C80hCMcO9MIQJ/cjDS3SlEURVEU5cJB12x7IJkBP/VNUQ4215MV9KsHWVEU\nRVEUJQXUQO6BZIb81NulpntnBxGRs++kKIqiKIqiAGog90gygz4amq1Kek7hEEVRFEVRFKV9pEWD\nLCKFIrJQRLbZ/wta2S4iImvsv2c9rw8TkTdFZLuIPCEioa5rffcn5PfRFIlS1xQmWw1kRVEURVGU\nlEhXkN5XgUXGmDJgkf08GfXGmEn23zs9r/8b8B/GmJHAKeDOzm3uhUXQ7yMciVLXFNHUYIqiKIqi\nKCmSLgP5JuAx+/FjwM3t3VEsQe184K8d2f9iIOj30Rwx1DdH1IOsKIqiKIqSImKM6fqDilQZY3rb\njwU45TxP2C4MrAHCwIPGmKdFpAhYZnuPEZFBwAvGmHGtHOtu4G6AkpKSyx9//PFO+U6tUVNTQ25u\nbpce8wfL6sn0CycbovTP9XHv5MwuPX53JB39oMSjfZB+tA+6B9oP6Uf7oHuQjn6YN2/eSmNM+dm2\n67T1dxF5BeiX5K2ve58YY4yItGalDzHGHBCR4cBiEVkHVKfSDmPMw8DDAOXl5aaioiKV3c+ZyspK\nuvqYv96yFJ/AqUg9Qwb0oaJiYpcevzuSjn5Q4tE+SD/aB90D7Yf0o33QPejO/dBpBrIx5srW3hOR\nIyJSaow5JCKlwNFWPuOA/X+niFQCk4G/Ab1FJGCMCQMDgQPn/QtcwIT8PuqbI9RqkJ6iKIqiKErK\npEuD/Cxwu/34duCZxA1EpEBEMuzHRcAsYKOxNCFLgFvb2v9iJugXT5CeGsiKoiiKoiipkC4D+UHg\nKhHZBlxpP0dEykXkEXubMcAKEVmLZRA/aIzZaL/3FeALIrId6AP8tktb380J+H00NEdpCkc1i4Wi\nKIqiKEqKpMV6MsacABYkeX0FcJf9+A1gfCv77wSmdmYbL2RCfh+nG5oB1IOsKIqiKIqSIunyICud\nSMAvVNdbBrJW0lMURVEURUkNNZB7IEG/j7qmCKAeZEVRFEVRlFRRA7kHEvTHujUrqAayoiiKoihK\nKqiB3AMJ+sV9nKkGsqIoiqIoSkqogdwD8XqQMwLaxYqiKIqiKKmg1lMPJODxIGcEtYsVRVEURVFS\nQa2nHkgozoOsEgtFURRFUZRUUAO5B6ISC0VRFEVRlI6j1lMPxCuxCKmBrCiKoiiKkhJqPfVAVGKh\nKIqiKIrScdRA7oEEfJ4gPfUgK4qiKIqipIRaTz2QoMco1iwWiqIoiqIoqaHWUw/EG6TnlVsoiqIo\niqIoZ0etpx6It5JeQA1kRVEURVGUlFDrqQcSVKNYURRFURSlw6gl1QMJ+LRbFUVRFEVROopaUj2Q\nUEDOvpGiKIqiKIqSFDWQeyAqsVAURVEURek4akn1QFRioSiKoiiK0nHUkuqBqMRCURRFURSl46iB\n3ANRD7KiKIqiKErHUUuqB6IaZEVRFEVRlI6TFktKRApFZKGIbLP/FyTZZp6IrPH8NYjIzfZ7/yMi\nuzzvTer6b9F9UYmFoiiKoihKx0mXq/GrwCJjTBmwyH4ehzFmiTFmkjFmEjAfqANe9mzyZed9Y8ya\nLmn1BUJm0J/uJiiKoiiKolywpMtAvgl4zH78GHDzWba/FXjBGFPXqa3qIRTlZqS7CYqiKIqiKBcs\nYozp+oOKVBljetuPBTjlPG9l+8XAT40xf7ef/w8wA2jE9kAbYxpb2fdu4G6AkpKSyx9//PHz+VXO\nSk1NDbm5uV16TICPL6zl+mFBbhoZ6vJjd0fS1Q9KDO2D9KN90D3Qfkg/2gfdg3T0w7x581YaY8rP\ntl2nGcgi8grQL8lbXwce8xrEInLKGNNCh2y/Vwq8DfQ3xjR7XjsMhICHgR3GmO+drU3l5eVmxYoV\nKX+Xc6GyspKKioouPabSEu2H9KN9kH60D7oH2g/pR/uge5COfhCRdhnIgc5qgDHmytbeE5EjIlJq\njDlkG7tH2/io9wJPOcax/dmH7IeNIvIo8KXz0mhFURRFURTloiddGuRngdvtx7cDz7Sx7W3A/3lf\nsI1qR55xM7C+E9qoKIqiKIqiXISky0B+ELhKRLYBV9rPEZFyEXnE2UhEhgKDgFcT9v+jiKwD1gFF\nwA+6oM2KoiiKoijKRUCnSSzawhhzAliQ5PUVwF2e57uBAUm2m9+Z7VMURVEURbtDd0cAAAc8SURB\nVFEuXrTkmqIoiqIoiqJ4UANZURRFURRFUTyogawoiqIoiqIoHtRAVhRFURRFURQPaiAriqIoiqIo\nioe0lJpOFyJyDNjTxYctAo538TGVlmg/pB/tg/SjfdA90H5IP9oH3YN09MMQY0zx2Ta6qAzkdCAi\nK9pT0lDpXLQf0o/2QfrRPugeaD+kH+2D7kF37geVWCiKoiiKoiiKBzWQFUVRFEVRFMWDGsidz8Pp\nboACaD90B7QP0o/2QfdA+yH9aB90D7ptP6gGWVEURVEURVE8qAdZURRFURRFUTyogawoiqIoiqIo\nHtRA7kRE5FoR2SIi20Xkq+luz8WIiOwWkXUiskZEVqS7PRcLIvI7ETkqIus9rxWKyEIR2Wb/L0hn\nG3s6rfTBd0TkgH0+rBGR69PZxp6OiAwSkSUislFENojIZ+3X9VzoQtroBz0fuggRyRSRt0Rkrd0H\n37VfHyYib9p20hMiEkp3Wx1Ug9xJiIgf2ApcBewHlgO3GWM2prVhFxkishsoN8ZoQvguRETmADXA\n/xpjxtmv/Qg4aYx50J4wFhhjvpLOdvZkWumD7wA1xpgfp7NtFwsiUgqUGmNWiUgesBK4Gfgoei50\nGW30w3vR86FLEBEBcowxNSISBF4DPgt8AXjSGPO4iPwGWGuMeSidbXVQD3LnMRXYbozZaYxpAh4H\nbkpzmxSlSzDG/BM4mfDyTcBj9uPHsG5QSifRSh8oXYgx5pAxZpX9+AywCRiAngtdShv9oHQRxqLG\nfhq0/wwwH/ir/Xq3OhfUQO48BgD7PM/3oydkOjDAyyKyUkTuTndjLnJKjDGH7MeHgZJ0NuYi5l4R\neduWYOjSfhchIkOBycCb6LmQNhL6AfR86DJExC8ia4CjwEJgB1BljAnbm3QrO0kNZKWnM9sYcxlw\nHXCPveyspBljabtU39X1PASMACYBh4CfpLc5Fwcikgv8DficMea09z09F7qOJP2g50MXYoyJGGMm\nAQOxVtlHp7lJbaIGcudxABjkeT7Qfk3pQowxB+z/R4GnsE5KJT0csbWAjibwaJrbc9FhjDli36Si\nwH+j50OnY+st/wb80RjzpP2yngtdTLJ+0PMhPRhjqoAlwAygt4gE7Le6lZ2kBnLnsRwosyM0Q8D7\ngWfT3KaLChHJsQMyEJEc4Gpgfdt7KZ3Is8Dt9uPbgWfS2JaLEscos3kXej50KnZg0m+BTcaYn3re\n0nOhC2mtH/R86DpEpFhEetuPs7ASGGzCMpRvtTfrVueCZrHoROyUMT8D/MDvjDH3p7lJFxUiMhzL\nawwQAP6kfdA1iMj/ARVAEXAE+DbwNPBnYDCwB3ivMUaDyDqJVvqgAms52QC7gY97tLDKeUZEZgP/\nAtYBUfvlr2HpX/Vc6CLa6Ifb0POhSxCRCVhBeH4s5+yfjTHfs+/TjwOFwGrgQ8aYxvS1NIYayIqi\nKIqiKIriQSUWiqIoiqIoiuJBDWRFURRFURRF8aAGsqIoiqIoiqJ4UANZURRFURRFUTyogawoiqIo\niqIoHgJn30RRFEXpTESkD7DIftoPiADH7Od1xpiZnXDMycC9xpg7z9Pn3YvV1t+dj89TFEVJJ5rm\nTVEUpRshIt8BaowxP+7k4/wF+IExZu15+rxs4HVjzOTz8XmKoijpRCUWiqIo3RgRqbH/V4jIqyLy\njIjsFJEHReSDIvKWiKwTkRH2dsUi8jcRWW7/zUrymXnABMc4FpG5IrLG/lvtqUD5Zfsz3haR73r2\n/4j92loR+T2AMaYO2C0iWq5XUZQLHpVYKIqiXDhMBMYAJ4GdwCPGmKki8lng08DngJ8D/2GMeU1E\nBgMv2ft4KSe+rO6XgHuMMa+LSC7QICJXA2XAVECAZ0VkDnAC+AYw0xhzXEQKPZ+zArgCeOu8fmtF\nUZQuRg1kRVGUC4flTilcEdkBvGy/vg6YZz++ErhURJx98kUk1xhT4/mcUmIaZ4DXgZ+KyB+BJ40x\n+20D+Wqs8q8AuVgG80TgL8aY4wAJJZKPAqPP/WsqiqKkFzWQFUVRLhwaPY+jnudRYtdzHzDdGNPQ\nxufUA5nOE2PMgyLyD+B64HURuQbLa/yAMea/vDuKyKfb+NxM+7MVRVEuaFSDrCiK0rN4GUtuAYCI\nTEqyzSZgpGebEcaYdcaYfwOWY3mBXwI+ZksuEJEBItIXWAy8x868QYLEYhTx0g1FUZQLEjWQFUVR\nehafAcrtILqNwCcSNzDGbAZ6OcF4wOdEZL2IvA00Ay8YY14G/gQsFZF1wF+BPGPMBuB+4FURWQv8\n1PPRs4CFnfbNFEVRughN86YoinIRIiKfB84YYx45T583GfiCMebD5+PzFEVR0ol6kBVFUS5OHiJe\n03yuFAHfPI+fpyiKkjbUg6woiqIoiqIoHtSDrCiKoiiKoige1EBWFEVRFEVRFA9qICuKoiiKoiiK\nBzWQFUVRFEVRFMWDGsiKoiiKoiiK4uH/ByhyA0FklYN8AAAAAElFTkSuQmCC\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x7feebf24e978>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "batch_with_data.show_ecg('A00001')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Any other action can be applied to ```batch_with_data``` in the same way as ```load```. Let's consider e.g. action [```flip_signals```](https://analysiscenter.github.io/cardio/api/cardio.batch.html#cardio.batch.EcgBatch.flip_signals). It flips signals whose R-peaks are directed downwards.\n", + "\n", + "Note that ```flip_signals``` modifies batch inplace, so we create copy of the batch:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "original_batch = batch_with_data.deepcopy()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And then apply ```flip_signal``` action:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<cardio.batch.ecg_batch.EcgBatch at 0x7feebf24e828>" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch_with_data.flip_signals()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can compare results. Let's consider signal with index 'A00013', whose R-peaks were originally directed downwards:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAEYCAYAAABBfQDEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nJBKJRCKRSKSK/wvAWDtNVjPe7QAAAABJRU5ErkJggg==\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x7fee6eea5dd8>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAEYCAYAAABBfQDEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhUKhUCgUJpRAVigUCoVCoVAoTPx/BGxKglStIOUAAAAASUVORK5CYII=\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x7fee6e63f0f0>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "original_batch.show_ecg('A00013')\n", + "\n", + "batch_with_data.show_ecg('A00013')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Reading [documentation](https://analysiscenter.github.io/cardio/api/cardio.ecg_batch.html) on EcgBatch you will find more actions that can be applied to batches.\n", + "\n", + "Summarizing, in Notebook 1 we learned:\n", + "* how to get ECG data\n", + "* how to create datasets\n", + "* how to apply actions.\n", + "\n", + "In the next [Notebook 2](https://github.com/analysiscenter/cardio/blob/hmm_model_update/tutorials/II.Pipelines.ipynb) we will combine actions in pipeline." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [default]", + "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.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tutorials/II.Pipelines.ipynb b/tutorials/II.Pipelines.ipynb new file mode 100644 index 0000000..dfac23e --- /dev/null +++ b/tutorials/II.Pipelines.ipynb @@ -0,0 +1,332 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Define and run pipelines" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In Notebook 2 we learn pipelines. Pipeline is a sequence of actions we want to apply to [batch](https://analysiscenter.github.io/cardio/api/cardio.ecg_batch.html). At first we describe what we want to do with batch. Then at some point in our code we pass dataset to pipeline and calculations actually run." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define pipeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following example shows how to define a pipeline. It simply lists actions:\n", + "* load data\n", + "* resample signal to new fs\n", + "* drop signals that are too short\n", + "* generate segments with specified length and step size from signal\n", + "* save result in [blosc](http://blosc.org/) format." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"..\")\n", + "\n", + "import cardio.dataset as ds\n", + "\n", + "path_to_dump = './'\n", + "\n", + "preprocess_pipeline = (ds.Pipeline()\n", + " .load(fmt=\"wfdb\", components=[\"signal\", \"meta\"])\n", + " .random_resample_signals(\"normal\", loc=300, scale=10)\n", + " .drop_short_signals(4000)\n", + " .split_signals(3000, 3000)\n", + " .dump(fmt='blosc', dst=path_to_dump))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that when we run pipeline batches will be generated and __destroyed__ inside the pipeline. To have access to processed data we include ```dump``` action. This action is unnecessary e.g. in model training. The other options is to save result to pipeline variable. See [here](https://analysiscenter.github.io/dataset/intro/pipeline.html) more features of pipelines." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run pipeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's create an ECG dataset that will be passed to the pipeline (see [Notebook 1](https://github.com/analysiscenter/cardio/blob/master/tutorials/I.CardIO.ipynb) for dataset): " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from cardio import EcgDataset\n", + "eds = EcgDataset(path=\"../cardio/tests/data/*.hea\", no_ext=True, sort=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To start calculation we pass ECG dataset into the pipeline and call an action ```run```. It will iterate over dataset with given batch size until no ECGs are left:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<cardio.dataset.dataset.pipeline.Pipeline at 0x7f064e0c07b8>" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(eds >> preprocess_pipeline).run(batch_size=3, shuffle=False, drop_last=False, n_epochs=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As a result we obtain dump of processed ECGs located in folder ```path_to_dump```." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Add custom action" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Suppose you want to include in pipeline a new action called ```add_value``` that adds given value to each signal. Any new action should be defined in ```Batch``` and have decorator ```@action```.\n", + "\n", + "To demonstrate how it works let's create a new class ```MyEcgBatch``` with ```EcgBatch``` class as parent. In ```MyEcgBatch``` we define method ```add_value``` and decorate it with ```@action```. We add also optional decorator ```@inbatch_parallel``` that splits batch into individual ECGs and process each ECG in a separate thread. Being decorated ```add_value``` obtains index of ECG and every parameter passed from pipeline. From index it obtains position of corresponding signal in batch and adds value to the signal. Let's combine it all together:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from cardio import EcgBatch\n", + "\n", + "class MyEcgBatch(EcgBatch):\n", + " \"\"\"Class for storing batch of ECG signals.\"\"\"\n", + "\n", + " @ds.action\n", + " @ds.inbatch_parallel(init=\"indices\", target=\"threads\")\n", + " def add_value(self, index, value):\n", + " i = self.get_pos(None, \"signal\", index)\n", + " self.signal[i] += value" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's apply ```add_value``` to some batch and check the effect. Create new batch with data:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "eds = EcgDataset(path=\"../cardio/tests/data/*.hea\", no_ext=True, sort=True, batch_class=MyEcgBatch)\n", + "batch = eds.next_batch(100)\n", + "batch_with_data = batch.load(fmt=\"wfdb\", components=[\"signal\", \"meta\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Remember some signal from batch:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "ecg_id = 'A00001'\n", + "original_signal = batch_with_data[ecg_id].signal.copy()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Apply ```add_value``` with value -1 to batch:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "batch_transformed = batch_with_data.add_value(-1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compare results:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD8CAYAAAB+UHOxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x7f064e0c0ac8>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transformed_signal = batch_transformed[ecg_id].signal\n", + "\n", + "import matplotlib.pyplot as plt\n", + "plt.plot(original_signal.ravel(), label='before add')\n", + "plt.plot(transformed_signal.ravel(), label='after add')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can include ```add_value``` in pipeline:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "preprocess_pipeline = (ds.Pipeline()\n", + " .load(fmt=\"wfdb\", components=[\"signal\", \"meta\"])\n", + " .random_resample_signals(\"normal\", loc=300, scale=10)\n", + " .drop_short_signals(4000)\n", + " .split_signals(3000, 3000)\n", + " .add_value(-1)\n", + " .dump(fmt='blosc', dst=path_to_dump))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run modified pipeline:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<cardio.dataset.dataset.pipeline.Pipeline at 0x7f064e0c0b00>" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(eds >> preprocess_pipeline).run(batch_size=3, shuffle=False, drop_last=False, n_epochs=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Summarizing, in Notebook 2 we learned:\n", + "* how to construct and run pipelines\n", + "* how to add custom actions.\n", + "\n", + "In the next [Notebook 3](https://github.com/analysiscenter/cardio/blob/master/tutorials/III.Models.ipynb) we will work with models." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tutorials/III.Models.ipynb b/tutorials/III.Models.ipynb new file mode 100644 index 0000000..5e452b9 --- /dev/null +++ b/tutorials/III.Models.ipynb @@ -0,0 +1,366 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Run models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In Notebook 3 we will learn how to train built-in ECG models and make predictions. We consider [FFTModel](https://analysiscenter.github.io/cardio/intro/models.html#fftmodel) as an example. This model learns to recognize atrial fibrillation (AF) from single lead ECG signal. Input of the model is ECG signal and its meta, output is probability of signal being AF and non-AF. See more on ecg models [here](https://analysiscenter.github.io/cardio/api/cardio.models.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Some necessary imports before to start. We import ```dataset``` that will generate batches, ```EcgBatch``` that will store ECG and ```FFTModel``` that contains model we will train." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ] + } + ], + "source": [ + "import sys\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.metrics import f1_score\n", + "\n", + "import tensorflow as tf\n", + "\n", + "sys.path.append(\"..\")\n", + "from cardio import EcgDataset\n", + "from cardio.dataset import F, V, B\n", + "from cardio.models.fft_model import FFTModel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we create an ECG dataset (see [Notebook 1](https://github.com/analysiscenter/cardio/blob/master/tutorials/I.CardIO.ipynb) for details):" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# PATH_TO_DATA = \n", + "eds = EcgDataset(path=PATH_TO_DATA, no_ext=True, sort=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Usually we want to divide the whole dataset into 2 parts that will be used for train and validation. Method ```cv_split``` do this job:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "eds.cv_split(0.8, shuffle=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now 80% of the dataset are in ```eds.train``` and the rest are in ```eds.test```." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train pipeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's define a train pipeline. Pipeline is a sequence of actions that we want to apply, namely\n", + "* initialize model, adjust it to the input signal shape, specify loss and optimizer\n", + "* initialize variable that will store loss history\n", + "* load signal, meta and target labels\n", + "* drop noise signals\n", + "* replace all non-AF labels with \"NO\" label\n", + "* resample signal\n", + "* drop too short signals\n", + "* generate a number of segments from each signal\n", + "* binarize labels to 0 and 1\n", + "* prepare signal to expected model input format\n", + "* train model." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# PATH_TO_LABELS = \n", + "gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.33, allow_growth=True)\n", + "\n", + "model_config = {\n", + " \"session\": {\"config\": tf.ConfigProto(gpu_options=gpu_options)}\n", + " \"input_shape\": F(lambda batch: batch.signal[0].shape),\n", + " \"loss\": \"binary_crossentropy\",\n", + " \"optimizer\": \"adam\"\n", + "}\n", + "\n", + "def make_data(batch, **kwagrs):\n", + " return {'x': np.array(list(batch.signal)), 'y': batch.target}\n", + "\n", + "train_pipeline = (ds.Pipeline()\n", + " .init_model(\"dynamic\", FFTModel, name=\"fft_model\", config=model_config)\n", + " .init_variable(\"loss_history\", init=list)\n", + " .load(fmt=\"wfdb\", components=[\"signal\", \"meta\"])\n", + " .load(src=PATH_TO_LABELS,\n", + " fmt=\"csv\", components=\"target\")\n", + " .drop_labels([\"~\"])\n", + " .replace_labels({\"N\": \"NO\", \"O\": \"NO\"})\n", + " .random_resample_signals(\"normal\", loc=300, scale=10)\n", + " .drop_short_signals(4000)\n", + " .split_signals(3000, 3000)\n", + " .binarize_labels()\n", + " .apply_transform('signal', 'signal', np.transpose, axes=[0, 2, 1])\n", + " .ravel()\n", + " .train_model('fft_model', make_data=make_data, save_to=V(\"loss_history\"), mode=\"a\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we only have to pass the dataset to pipeline and run the calculation. Depending on your hardware training precess may take a while. Reduce ```n_epochs``` if you do not want to wait long:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "fft_trained = (eds.train >> train_pipeline).run(batch_size=300, shuffle=True,\n", + " drop_last=True, n_epochs=150)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As a result we obtain ```fft_trained``` that contains trained model. Let's make a prediction!" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSpVAGtyVUqoE0uCulFIl0P8DqYmZK+zrSaQAAAAASUVORK5CYII=\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x7fe43973fba8>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "loss = pd.DataFrame(fft_trained.get_variable(\"loss_history\"), columns=[\"loss\"])\n", + "loss[\"avr loss\"] = pd.DataFrame(loss).rolling(center=True, window=100).mean()\n", + "loss.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test pipeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Test pipeline is very similar to train pipeline except several things. First, rather than initialize a new model we import pretrained model from train_pipeline. Alternative option would be importing model from model dump. Second, we add new vairable ```true_targets``` than will keep targets from batch. Finally, we call model predict rather than model train." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "test_pipeline = (ds.Pipeline()\n", + " .import_model(\"fft_model\", fft_trained)\n", + " .init_variable(\"pred_labels\", init=list)\n", + " .init_variable(\"true_labels\", init=list)\n", + " .load(fmt=\"wfdb\", components=[\"signal\", \"meta\"])\n", + " .load(src=PATH_TO_LABELS,\n", + " fmt=\"csv\", components=\"target\")\n", + " .drop_labels([\"~\"])\n", + " .replace_labels({\"N\": \"NO\", \"O\": \"NO\"})\n", + " .drop_short_signals(4000)\n", + " .split_signals(3000, 3000)\n", + " .binarize_labels()\n", + " .apply_transform('signal', 'signal', np.transpose, axes=[0, 2, 1])\n", + " .ravel()\n", + " .update_variable(\"true_labels\", B('target'), mode='e')\n", + " .predict_model('fft_model', make_data=make_data, save_to=V(\"pred_labels\"), mode=\"e\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's run prediction pipeline. Note we set ```n_epochs=1```:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "res_test = (eds.test >> test_pipeline).run(batch_size=300, shuffle=False, drop_last=False,\n", + " n_epochs=1, prefetch=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can access true labels as ```res_test.get_variable(\"true_targets\")``` and predicted class probabilities\n", + "as ```res_test.get_variable(\"pred_targets\")```. Consider several predicted values:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[array([ 5.06362630e-05, 9.99949336e-01], dtype=float32),\n", + " array([ 1.66804796e-07, 9.99999881e-01], dtype=float32),\n", + " array([ 4.09237236e-06, 9.99995947e-01], dtype=float32),\n", + " array([ 1.92002275e-07, 9.99999762e-01], dtype=float32),\n", + " array([ 1.68746810e-05, 9.99983072e-01], dtype=float32),\n", + " array([ 1.29509147e-07, 9.99999881e-01], dtype=float32),\n", + " array([ 0.02815608, 0.97184396], dtype=float32),\n", + " array([ 0.00730084, 0.99269921], dtype=float32),\n", + " array([ 0.07173456, 0.92826551], dtype=float32),\n", + " array([ 8.36696709e-04, 9.99163270e-01], dtype=float32)]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res_test.get_variable(\"pred_labels\")[:10]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here each column corresponds to class probality (AF or non-AF). To get class prediction we simply take most probable class. Metrics f1_score allows to estimate model quality: " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.83683720930232552" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f1_score(np.array(res_test.get_variable(\"true_labels\"))[:, 0],\n", + " np.rint(res_test.get_variable(\"pred_labels\"))[:, 0], average='macro')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is the end of Notebook 3. Here we learned:\n", + "* how to train models\n", + "* how to test model quality.\n", + "\n", + "See previous topics in [Notebook 1](https://github.com/analysiscenter/cardio/blob/master/tutorials/I.CardIO.ipynb) and [Notebook 2](https://github.com/analysiscenter/cardio/blob/master/tutorials/II.Pipelines.ipynb)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}