diff --git a/.gitignore b/.gitignore index 1867e88..d109088 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ *.profile +/.vscode/ *.egg-info .cache @@ -18,5 +19,6 @@ dist/ *starting_kit.html *.pkl +*.h5 .DS_Store diff --git a/download_data.py b/download_data.py index adbb33b..c636f47 100644 --- a/download_data.py +++ b/download_data.py @@ -1,26 +1,186 @@ +"""Fetcher for RAMP data stored in OSF + +To adapt it for another challenge, change the CHALLENGE_NAME and upload +public/private data as `tar.gz` archives in dedicated OSF folders named after +the challenge. +""" +import tarfile +import argparse +from zlib import adler32 from pathlib import Path +from osfclient.api import OSF +from osfclient.exceptions import UnauthorizedException + +PUBLIC_PROJECT = "t4uf8" + +CHALLENGE_NAME = 'map_estimation' +RAMP_FOLDER_CONFIGURATION = { + 'public': dict( + code='t4uf8', + files=['public.tar.gz.001', 'public.tar.gz.002', 'public.tar.gz.003'], + data_checksum=1199509737, + ), + 'private': dict( + code='g5t7q', + files=["test.h5", "private_test.h5"], + data_checksum=None, + ) +} + + +def get_connection_info(code, username=None, password=None): + "Get connection to OSF and info relative to public/private data." + osf = OSF(username=username, password=password) + + try: + project = osf.project(code) + store = project.storage('osfstorage') + except UnauthorizedException: + raise ValueError("Invalid credentials for RAMP private storage.") + return store + + +def get_one_element(container, name): + "Get one element from OSF container with a comprehensible failure error." + elements = [f for f in container if f.name == name] + container_name = ( + container.name if hasattr(container, 'name') else CHALLENGE_NAME + ) + assert len(elements) == 1, ( + f'There is no element named {name} in {container_name} from the RAMP ' + 'OSF account.' + ) + return elements[0] + + +def hash_folder(folder_path): + """Return the Adler32 hash of an entire directory.""" + folder = Path(folder_path) + + # Recursively scan the folder and compute a checksum + checksum = 1 + for f in sorted(folder.rglob('*')): + if f.is_file(): + checksum = adler32(f.read_bytes(), checksum) + else: + checksum = adler32(f.name.encode(), checksum) + + return checksum -from sklearn.datasets import load_digits -from sklearn.model_selection import train_test_split -DATA_PATH = Path('data') +def checksum_data(data_dir, cksum, raise_error=False): + print("Checking the data...", end='', flush=True) + local_checksum = hash_folder(data_dir) + if raise_error and cksum != local_checksum: + raise ValueError( + f"The checksum does not match. Expecting {cksum} but " + f"got {local_checksum}. The archive seems corrupted. Try to " + f"remove {data_dir} and re-run this command." + ) + print("Done.") + + return cksum == local_checksum + + +def download_split_archive_from_osf(folder, split_files, data_dir): + """ + Merge split files, extract the tar.gz file, and delete the merged file. + + Args: + split_files (list of Path): Ordered list of split file paths. + extract_path (str): Directory where files will be extracted. + """ + output_tar = (data_dir / split_files[0]).with_suffix("") + assert "001" not in output_tar.name, output_tar.name + + N = len(split_files) + with open(output_tar, 'wb') as f: + for i, fname in enumerate(split_files): + print(f"Downloading {output_tar.name} ({i+1}/{N})...\r") + osf_file = get_one_element(folder.files, fname) + osf_file.write_to(f) + print("Downloading done.".ljust(40)) + return output_tar + + +def download_from_osf(folder, filename, data_dir): + # Download the archive in the data + target_path = data_dir / filename + osf_file = get_one_element(folder.files, filename) + print(f"Downloading {filename}...\r", end='', flush=True) + with open(target_path, 'wb') as f: + osf_file.write_to(f) + print("Downloading done.".ljust(40)) + return target_path + + +def setup_data(private_data=None, username=None, password=None): + "Download and uncompress the data from OSF." + public_data_path = Path("./data/") + if private_data is not None: + chunk = 'private' + data_path = Path(private_data) + else: + chunk = 'public' + data_path = public_data_path + + config = RAMP_FOLDER_CONFIGURATION[chunk] + cksum = config['data_checksum'] + + if not data_path.exists() or cksum is None: + data_path.mkdir(exist_ok=True) + elif checksum_data(data_path, cksum, raise_error=False): + print("Data already downloaded and verified.") + return + + # Get the connection to OSF and find the folder in the OSF project + print("Checking the data URL...", end='', flush=True) + store = get_connection_info( + config['code'], username=username, password=password + ) + challenge_folder = get_one_element(store.folders, CHALLENGE_NAME) + print('Ok.') + + # Download the public data + if chunk == 'public': + archive = download_split_archive_from_osf( + challenge_folder, config['files'], data_path + ) + with tarfile.open(archive) as tar: + tar.extractall(data_path) + # Remove intermediate folder public + [f.rename(data_path / f.name) + for f in (data_path / "public").glob("*")] + (data_path / "public").rmdir() + archive.unlink() -if __name__ == '__main__': - if not DATA_PATH.exists(): - DATA_PATH.mkdir() + checksum_data(data_path, cksum, raise_error=True) + else: + private_test = download_from_osf( + challenge_folder, "private_test.h5", data_path + ) + download_from_osf(challenge_folder, "test.h5", public_data_path) + private_test.rename(data_path / "test.h5") + (public_data_path / "train.h5").symlink_to(private_data / "train.h5") - # Load the data - print('Loading the data...', end='', flush=True) - X_df, y = load_digits(return_X_y=True, as_frame=True) - X_df['target'] = y - X_train, X_test = train_test_split( - X_df, test_size=0.2, random_state=57, shuffle=True, - stratify=y +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=f'Data loader for the {CHALLENGE_NAME} challenge on RAMP.' ) + parser.add_argument('--private-data', type=Path, default=None, + help='If this flag is used, download the private data ' + 'from OSF. This requires the username and password ' + 'options to be provided.') + parser.add_argument('--username', type=str, default=None, + help='Username for downloading private OSF data.') + parser.add_argument('--password', type=str, default=None, + help='Password for downloading private OSF data.') + args = parser.parse_args() - # Save the data - X_train.to_csv(DATA_PATH / 'X_train.csv', index=False) - X_test.to_csv(DATA_PATH / 'X_test.csv', index=False) - print('done') + if args.private_data is not None: + setup_data(private_data=args.private_data, username=args.username, + password=args.password) + else: + setup_data() diff --git a/img/GA_monitor_1.png b/img/GA_monitor_1.png new file mode 100644 index 0000000..8dd5cbf Binary files /dev/null and b/img/GA_monitor_1.png differ diff --git a/img/cuff.avif b/img/cuff.avif new file mode 100644 index 0000000..432b304 Binary files /dev/null and b/img/cuff.avif differ diff --git a/img/ecg.avif b/img/ecg.avif new file mode 100644 index 0000000..7444010 Binary files /dev/null and b/img/ecg.avif differ diff --git a/img/ppg.png b/img/ppg.png new file mode 100644 index 0000000..cd8f464 Binary files /dev/null and b/img/ppg.png differ diff --git a/map_estimation_starting_kit.ipynb b/map_estimation_starting_kit.ipynb new file mode 100644 index 0000000..0489da5 --- /dev/null +++ b/map_estimation_starting_kit.ipynb @@ -0,0 +1,936 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + " \n", + " \n", + "
\n", + "\n", + "# Non-invasive estimation of the MAP using PPG\n", + "\n", + " Thomas Moreau (Inria) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "
\n", + "\"Monitor\n", + "
\n", + "\n", + "\n", + "## Introduction\n", + "\n", + "The continuous monitoring of blood pressure is a major challenge in the general anesthesia field. Indeed, the monitoring of blood pressure is essential to ensure that the patient is stable during the operation. However, the current methods to measure blood pressure are either non-invasive, but non-continuous, or invasive, which can lead to complications, and expensive, making them inadapted in many situations.\n", + "\n", + "\n", + "
\n", + "\"Cuff\n", + "
\n", + "\n", + "A potential solution to this problem is to use non-invasive monitoring signals which are routinely collected, like the electrocardiogram (ECG) photoplethysmogram (PPG) signal, to estimate the mean arterial pressure (MAP) using AI. The PPG signal is a non-invasive signal that can be easily acquired using a pulse oximeter. The MAP is a measure of the average blood pressure in an individual's arteries during one cardiac cycle.\n", + "\n", + "
\n", + "\"ECG\n", + "\"PPG\n", + "
\n", + "\n", + "The goal of this challenge is to estimate the MAP from the non-invasive signals. The dataset consists of window of 10 seconds of PPG and ECG signals, with the related patient information (age, gender, weight, height, etc.) and the MAP measured with an invasive method.\n", + "\n", + "A particular aspect of this challenge is the fact that we would like to have a\n", + "method that can generalize well to new patients in other hospitals. This is a\n", + "major issue in the medical field, where the data distribution can change and\n", + "it is very costly to collect new data.\n", + "\n", + "For this reason, the challenge is a domain adaptation challenge. For training,\n", + "you have access to a dataset composed of data from 2 different domains:\n", + "\n", + "- The \"source\" domain `'v'`, which corresponds to data collected in a first hospital.\n", + " For this data, you have access to all the data and the labels (i.e. the MAP).\n", + "- The \"target\" domain `'m'`, composed of data collected in a second hospital.\n", + " For this data, you have access to the data, but not the labels. In order to make it possible to test that everything is working properly, we give you the labels for 100 segments of the target domain in the test set.\n", + "\n", + "The goal is therefore to generalize from the source domain to the target domain.\n", + "\n", + "#### Extra resources\n", + "\n", + "For this challenge, you can take a look at the following resources:\n", + "\n", + "- [`skada`](https://scikit-adaptation.github.io/): a library for domain adaptation (DA) with a scikit-learn and PyTorch/skorch compatible API. This library implement many existing DA methods and can be used to implement your own methods." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exploratory data analysis\n", + "\n", + "This notebook provides a simple exploratory data analysis of the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "pd.set_option('display.max_columns', None)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the data\n", + "\n", + "The data is composed of 10 seconds windows of PPG and ECG signals, and the goal is to predict the MAP from these signals.\n", + "\n", + "For this challenge, the data is large (>20Gb) so it cannot be loaded directly\n", + "when not enough RAM is available.\n", + "In this case, the data can be loaded in chunks (using `start/stop` arguments of `get_train_data`) or without all the high frequency waveforms (`load_waveform=False`).\n", + "\n", + "In this notebook, we first load all the data without the waveforms to\n", + "illustrate the data distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[0;32m/home/tom/Work/ramp/map_estimation/problem.py\u001b[0m(46)\u001b[0;36m_load_data\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m 45 \u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mipdb\u001b[0m\u001b[0;34m;\u001b[0m \u001b[0mipdb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m---> 46 \u001b[0;31m \u001b[0mX_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_hdf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"data\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstop\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 47 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\n" + ] + } + ], + "source": [ + "import problem\n", + "X_df, y = problem.get_train_data(load_waveform=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " \n", + "Let's first look at the data available." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There are 564000 segment in this dataset.\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
n_segsubjectagegenderdomainheightweightbmiid
0688p00075078.0Mv162.050.619.31.0
1688p00075078.0Mv162.050.619.31.0
2688p00075078.0Mv162.050.619.31.0
3688p00075078.0Mv162.050.619.31.0
4688p00075078.0Mv162.050.619.31.0
\n", + "
" + ], + "text/plain": [ + " n_seg subject age gender domain height weight bmi id\n", + "0 688 p000750 78.0 M v 162.0 50.6 19.3 1.0\n", + "1 688 p000750 78.0 M v 162.0 50.6 19.3 1.0\n", + "2 688 p000750 78.0 M v 162.0 50.6 19.3 1.0\n", + "3 688 p000750 78.0 M v 162.0 50.6 19.3 1.0\n", + "4 688 p000750 78.0 M v 162.0 50.6 19.3 1.0" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(f\"There are {X_df.shape[0]} segment in this dataset.\")\n", + "X_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The data has two types of features:\n", + "- Some patient information like the subject identifier, the age, the gender and the number of segment for this patient.\n", + "- The PPG and ECG signals in the segment.\n", + "\n", + "We first start by looking at the statistics of the data:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There are 2254 unique subjects in the train set.\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+MAAAGHCAYAAADbfoO1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABbF0lEQVR4nO3de1hVZf7//9dOZQsKOxBhs43UzCENtdJPik7h+TCiNXYmScrRJk8fQqeyptSmETOzg87Y4WtqHqKa0qk0Ao/lCIoWJWZmk6YWiCluPALi/fujH+vTFlQw2CA+H9e1rot1r/de615rAzcv1tpr2YwxRgAAAAAAwGsuq+kOAAAAAABwqSGMAwAAAADgZYRxAAAAAAC8jDAOAAAAAICXEcYBAAAAAPAywjgAAAAAAF5GGAcAAAAAwMsI4wAAAAAAeBlhHAAAAAAALyOM45zmz58vm82mhg0b6ocffiizvHv37oqMjKyBnklr166VzWbTv/71rxrZfmXt3r1bAwcOVFBQkGw2mxISEry27ePHj2vy5Mlau3ZtmWWl7/Hu3burtQ9Tp07VsmXLqnUbtYW3julvsXv3btlsNs2fP7+muwLASxjTq05NjukXqw0bNmjy5Mk6fPhwTXfFK1q0aKH4+Pia7sY5xcfHq0WLFjXdjUsaYRwVUlhYqL/+9a813Y2L2sMPP6yNGzfqjTfeUHp6uh5++GGvbfv48eOaMmVKuWF84MCBSk9PV1hYWLX24VIK4xeDsLAwpaena+DAgTXdFQBexpj+29XkmH6x2rBhg6ZMmXLJhPGLwZNPPqmlS5fWdDcuafVrugO4OPTv319LlizRhAkT1KFDh5rujledOHFCDRs2lM1m+03ryc7O1o033qhbb721ajpWRZo2baqmTZvWdDdqrePHj8vPz6+mu1Hl7Ha7unTpUtPdAFADGNPr7piOqmeM0cmTJ+Xr61vTXalyrVq1qukuXPI4M44KeeSRR9SkSRM9+uij56w716WvNptNkydPtuYnT54sm82mr776SnfccYccDoeCgoKUmJioU6dOaceOHerfv7/8/f3VokULTZ8+vdxtnjx5UomJiXI6nfL19VV0dLS++OKLMnWbN2/W4MGDFRQUpIYNG+r666/XO++841FTeglfamqqHnjgATVt2lR+fn4qLCw86z7v2bNHQ4cOVUhIiOx2u9q0aaPnn39ep0+flvR/l9599913+vjjj2Wz2c57CbPNZtOYMWP06quv6ne/+53sdrvatm2r5ORkj7oDBw5o1KhRatu2rRo3bqyQkBD17NlTn332mVWze/duK2xPmTLF2n7ppVNnu6R65cqV6tWrlwICAuTn56du3bpp1apVHjWl7+G2bdt0zz33yOFwKDQ0VA888IDcbrfH/hw7dkwLFiywtt+9e3dJv4TdCRMmqGXLlmrYsKGCgoLUqVMnvfXWW2c9Pr/ud1pamu6//34FBQWpUaNGGjRokL7//vsy9ZXZn88//1y33367AgMDzztQZWRkqFu3bmrYsKFcLpcmTpyo4uLiMnWnT5/W9OnTdc0118hutyskJET33Xef9u3b51FXeploenq6unbtKl9fX7Vo0ULz5s2TJC1fvlw33HCD/Pz81K5dO6WkpHi8/rvvvtP999+v1q1by8/PT82aNdOgQYO0detWj7ryflYr+n4CuLgxpnt3TH/33XfVuXNnORwO+fn56aqrrtIDDzzgUVNQUGCNhT4+PmrWrJkSEhJ07Ngxj7rDhw9r+PDhCgoKUuPGjTVw4EB9//331fJ+VLRPpX+zLFy4UG3atJGfn586dOigjz76yKM/f/nLXyRJLVu2tI5b6RV7q1evVvfu3dWkSRP5+vrqyiuv1G233abjx4+f9bhKv1wKHhMTo6VLl6p9+/Zq2LChrrrqKr388su/eX9eeeUVtWnTRna7XQsWLDhrH4qLi/XII4/I6XTKz89Pv//977Vp06Zya7Ozs3XLLbcoMDBQDRs21HXXXVdm3aXfY0uWLNGjjz6qsLAwNW7cWIMGDdL+/ft15MgRjRw5UsHBwQoODtb999+vo0ePeqzjH//4h26++WaFhISoUaNGateunaZPn17m75PyLlOvyPuJKmSAc5g3b56RZDIzM81LL71kJJlVq1ZZy6Ojo821115rze/atctIMvPmzSuzLklm0qRJ1vykSZOMJBMREWH+9re/mbS0NPPII48YSWbMmDHmmmuuMS+//LJJS0sz999/v5Fk3nvvPev1a9asMZJMeHi4ueWWW8yHH35oFi1aZK6++moTEBBg/vvf/1q1q1evNj4+Puamm24yb7/9tklJSTHx8fFl+lq6v82aNTMjR440H3/8sfnXv/5lTp06Ve7xycvLM82aNTNNmzY1r7zyiklJSTFjxowxksxDDz1kjDHG7Xab9PR043Q6Tbdu3Ux6erpJT083J0+ePOtxL92vtm3bmrfeest88MEHpn///kaSeffdd626b775xjz00EMmOTnZrF271nz00Udm+PDh5rLLLjNr1qwxxhhz8uRJk5KSYiSZ4cOHW9v/7rvvPPZ5165d1noXLlxobDabufXWW837779vPvzwQxMTE2Pq1atnVq5cWe57+NRTT5m0tDQzc+ZMY7fbzf3332/VpaenG19fX/OHP/zB2v62bduMMcY8+OCDxs/Pz8ycOdOsWbPGfPTRR2batGlm1qxZZz0+v+53eHi4eeCBB8zHH39sXnvtNRMSEmLCw8NNfn7+Be9P8+bNzaOPPmrS0tLMsmXLztqHbdu2GT8/P+t9+ve//2369etnrrzyyjLHdOTIkdb3dkpKinnllVdM06ZNTXh4uDlw4IBVFx0dbZo0aWIiIiLM3LlzzSeffGJiYmKMJDNlyhTTrl0789Zbb5kVK1aYLl26GLvdbn788Ufr9evWrTPjx483//rXv8y6devM0qVLza233mp8fX3NN998Y9WV97Na0fcTwMWJMd37Y/qGDRuMzWYzd999t1mxYoVZvXq1mTdvnomLi7Nqjh07Zq677joTHBxsZs6caVauXGleeukl43A4TM+ePc3p06eNMcaUlJSY3//+96Zhw4Zm2rRpJjU11UyZMsW0bt26yt+Pivap9HuhRYsW5sYbbzTvvPOOWbFihenevbupX7++9b7t3bvXjB071kgy77//vnXc3G632bVrl2nYsKHp06ePWbZsmVm7dq1ZvHixiYuL8xjLy9O8eXPTrFkzc+WVV5o33njDrFixwtx7771GknnuuecueH+aNWtm2rdvb5YsWWJWr15tsrOzz9qHYcOGGZvNZv7yl7+Y1NRUM3PmTNOsWTMTEBBghg0bZtV98803xt/f37Rq1cq8+eabZvny5eaee+4xksyzzz5r1ZX+LDRv3tzEx8dbfzM0btzY9OjRw/Tp08dMmDDBpKammmeffdbUq1fPjB071qNPDz/8sJkzZ45JSUkxq1evNi+88IIJDg4uM5YPGzbMNG/e3KOtIu8nqg5hHOf064G7sLDQXHXVVaZTp07WL62qGLiff/55j7rrrrvO+mVdqri42DRt2tQMGTLEaiv9ZXXDDTd4/BLdvXu3adCggfnTn/5ktV1zzTXm+uuvN8XFxR7biomJMWFhYaakpMRjf++7774KHZ/HHnvMSDIbN270aH/ooYeMzWYzO3bssNqaN29uBg4cWKH1SjK+vr4mNzfXajt16pS55pprzNVXX33W1506dcoUFxebXr16mT/+8Y9W+4EDB8oc/1JnhvFjx46ZoKAgM2jQII+6kpIS06FDB3PjjTdabaXv4fTp0z1qR40aZRo2bOjxvjRq1MhjUCoVGRlpbr311rPu09mU9vvX+2mMMf/5z3+MJPPMM89c8P489dRTFerDXXfdddb36dfHdPv27UaSGTVqlMfrN27caCSZxx9/3GqLjo42kszmzZuttoMHD5p69eoZX19fj+CdlZVlJJmXX375rH08deqUKSoqMq1btzYPP/yw1X6uMF6R9xPAxYcx/dyqY0yfMWOGkWQOHz581pqkpCRz2WWXmczMTI/2f/3rX0aSWbFihTHGmOXLlxtJZs6cOWVeX9XvR0X7ZMwv3wuhoaGmoKDAasvNzTWXXXaZSUpKstqee+65Mv+o/vU6s7KyznqMzqZ58+bGZrOVeW2fPn1MQECAOXbs2AXtj8PhMIcOHTrv9kvH91+Pr8YYs3jxYiPJ4++eu+++29jtdrNnzx6P2gEDBhg/Pz/re6T0Z+HMv1sSEhKMJDNu3DiP9ltvvdUEBQWdtY8lJSWmuLjYvPnmm6ZevXoe+3W2MF6R9xNVg8vUUWE+Pj565plntHnz5jKXgv0WMTExHvNt2rSRzWbTgAEDrLb69evr6quvLvfur7GxsR6f/WrevLm6du2qNWvWSPrlst1vvvlG9957ryTp1KlT1vSHP/xBOTk52rFjh8c6b7vttgr1ffXq1Wrbtq1uvPFGj/b4+HgZY7R69eoKrac8vXr1UmhoqDVfr1493XXXXfruu+88Lm1+5ZVXdMMNN6hhw4aqX7++GjRooFWrVmn79u0XtN0NGzbo0KFDGjZsmMexOn36tPr376/MzMwyl3QNHjzYY759+/Y6efKk8vLyzru9G2+8UR9//LEee+wxrV27VidOnKhUf0vf11Jdu3ZV8+bNrff/Qvanou//mjVrzvo+nVknqcxdVW+88Ua1adOmzOXyYWFh6tixozUfFBSkkJAQXXfddXK5XFZ7mzZtJMnj5+LUqVOaOnWq2rZtKx8fH9WvX18+Pj7auXNnhb8nfsv7CeDiwJheVnWM6f/zP/8jSbrzzjv1zjvv6McffyxT89FHHykyMlLXXXedx/7069fP41LudevWWev6tXvuuees27/Q96OifSrVo0cP+fv7W/OhoaEKCQkp9z0+03XXXScfHx+NHDlSCxYsKPejZudy7bXXlrn3QWxsrAoKCvT5559f0P707NlTgYGB59126fflmX+L3Hnnnapf3/PWXKtXr1avXr0UHh7u0R4fH6/jx48rPT3do728905SmRuvtmnTRocOHfK4VP2LL77Q4MGD1aRJE9WrV08NGjTQfffdp5KSEn377bfn3a/f8n6icgjjqJS7775bN9xwg5544olyPxd7IYKCgjzmfXx85Ofnp4YNG5ZpP3nyZJnXO53OctsOHjwoSdq/f78kacKECWrQoIHHNGrUKEnSzz//7PH6it5Z/ODBg+XWlgam0j5ciLPt16/XO3PmTD300EPq3Lmz3nvvPWVkZCgzM1P9+/evdKgtVXq8br/99jLH69lnn5UxRocOHfJ4TZMmTTzm7Xa7JFWoDy+//LIeffRRLVu2TD169FBQUJBuvfVW7dy5s0L9rej7X5n9qcz7f6736dd1Z1uvy+Uq831y5s+E9Mv3f3k/K5I8fi4SExP15JNP6tZbb9WHH36ojRs3KjMzUx06dKjw98RveT8BXDwY0z1Vx5h+8803a9myZTp16pTuu+8+XXHFFYqMjPS4L8r+/fv11Vdfldkff39/GWOs/Tl48KDq169f5hj/+h/CZ7rQ96OifSp15rgh/TJ2VGTcaNWqlVauXKmQkBCNHj1arVq1UqtWrfTSSy+d97VSxf5equz+VOZ7prw+1K9fv8wxqez319nG/PP9LbBnzx7ddNNN+vHHH/XSSy/ps88+U2Zmpv7xj39IqthY/lveT1QOd1NHpdhsNj377LPq06ePXnvttTLLS3+5n3lzlN8SSs8nNze33LbSXyTBwcGSpIkTJ2rIkCHlriMiIsJjvqJ3WW3SpIlycnLKtP/0008e274QZ9uv0u1K0qJFi9S9e3fNmTPHo+7IkSMXvN3SPs+aNeusd9s+18BfWY0aNdKUKVM0ZcoU7d+/3zpLPmjQIH3zzTfnff3ZjtPVV18t6cL2pzLv/7nep1/XSVJOTo6uuOIKj2U//fTTb/o+OdOiRYt03333aerUqR7tP//8sy6//PIq2w6Aix9juqfqGtNvueUW3XLLLSosLFRGRoaSkpIUGxurFi1aKCoqSsHBwfL19dUbb7xR7utLt9ukSROdOnVKhw4d8ghk5R2z36qifaoqN910k2666SaVlJRo8+bNmjVrlhISEhQaGqq77777nK+tyN9Lld2fynzPlG6vWbNmVvupU6fK/JxU59+Mv7Zs2TIdO3ZM77//vpo3b261Z2VlVcn6UbU4M45K6927t/r06aOnn366zN0bQ0ND1bBhQ3311Vce7f/+97+rrT9vvfWWjDHW/A8//KANGzZYd+uOiIhQ69at9eWXX6pTp07lTr++FKcyevXqpa+//tq6DKrUm2++KZvNph49elzwfq1atco6AyBJJSUlevvtt9WqVSsr0NlsNuusZamvvvqqzKVOlTmz2a1bN11++eX6+uuvz3q8Sv8LWxkV+Y9qaGio4uPjdc8992jHjh3nvYuqJC1evNhjfsOGDfrhhx+s97+69kf65TKus71Pv9azZ09JvwTlX8vMzNT27dvVq1evC9p+ecr7nli+fHm5l0YCAGP6/6nOMV36ZRyMjo7Ws88+K0nWXeJjYmL03//+V02aNCl3f0rvdh0dHS1JZcaYM5+0UhUq2qfKqMjfIvXq1VPnzp2ts7hnvhfl2bZtm7788kuPtiVLlsjf31833HBDte2PJOv78sy/Rd555x2dOnXKo61Xr15avXq1Fb5Lvfnmm/Lz86uyx42W/iPh138LGGP0+uuvV8n6UbU4M44L8uyzz6pjx47Ky8vTtddea7XbbDYNHTpUb7zxhlq1aqUOHTpo06ZNWrJkSbX1JS8vT3/84x81YsQIud1uTZo0SQ0bNtTEiROtmldffVUDBgxQv379FB8fr2bNmunQoUPavn27Pv/8c7377rsXtO2HH35Yb775pgYOHKinn35azZs31/Lly/XPf/5TDz30kH73u99d8H4FBwerZ8+eevLJJ9WoUSP985//1DfffOMx6MbExOhvf/ubJk2apOjoaO3YsUNPP/20WrZs6TEI+Pv7q3nz5vr3v/+tXr16KSgoSMHBweUOPo0bN9asWbM0bNgwHTp0SLfffrtCQkJ04MABffnllzpw4ECZM/EV0a5dO61du1YffvihwsLC5O/vr4iICHXu3FkxMTFq3769AgMDtX37di1cuFBRUVEVer735s2b9ac//Ul33HGH9u7dqyeeeELNmjWzLlesrv2RpL/+9a/64IMP1LNnTz311FPy8/PTP/7xjzKfQY+IiNDIkSM1a9YsXXbZZRowYIB2796tJ598UuHh4Xr44YcvaPvliYmJ0fz583XNNdeoffv22rJli5577rkyZ+QBoBRj+i+qY0x/6qmntG/fPvXq1UtXXHGFDh8+rJdeekkNGjSwwnVCQoLee+893XzzzXr44YfVvn17nT59Wnv27FFqaqrGjx+vzp07q3///urWrZvGjx+vgoICdezYUenp6XrzzTclSZddVnXn2Crap8po166dJOmll17SsGHD1KBBA0VERGjx4sVavXq1Bg4cqCuvvFInT560zmD37t37vOt1uVwaPHiwJk+erLCwMC1atEhpaWl69tlnrb8jqmN/pF8+rz106FC9+OKLatCggXr37q3s7GzNmDFDAQEBHrWTJk3SRx99pB49euipp55SUFCQFi9erOXLl2v69OlyOByV3n55+vTpIx8fH91zzz165JFHdPLkSc2ZM0f5+flVsn5ULcI4Lsj111+ve+65p9wB+fnnn5ckTZ8+XUePHlXPnj310UcfXfB/Hc9n6tSpyszM1P3336+CggLdeOONSk5O9ng+dI8ePbRp0yb9/e9/V0JCgvLz89WkSRO1bdu2zI1QKqNp06basGGDJk6cqIkTJ6qgoEBXXXWVpk+frsTExN+0X4MHD9a1116rv/71r9qzZ49atWqlxYsXe9wc7IknntDx48c1d+5cTZ8+XW3bttUrr7yipUuXlrkZydy5c/WXv/xFgwcPVmFhoYYNG1bus2MlaejQobryyis1ffp0Pfjggzpy5Ih1A7Ezb0JWUS+99JJGjx6tu+++W8ePH1d0dLTWrl2rnj176oMPPtALL7yg48ePq1mzZrrvvvv0xBNPVGi9c+fO1cKFC3X33XersLBQPXr00EsvveRxCV917I8kRUZGauXKlRo/fryGDRumwMBAxcXF6bbbbtPIkSM9aufMmaNWrVpp7ty5+sc//iGHw6H+/fsrKSmp3M9mXajSP/KSkpJ09OhR3XDDDXr//ff117/+tcq2AaBuYUz/RXWM6Z07d9bmzZv16KOP6sCBA7r88svVqVMnrV692vrHR6NGjfTZZ59p2rRpeu2117Rr1y7rWdu9e/e2jvVll12mDz/8UOPHj9e0adNUVFSkbt26adGiRerSpUuVfhSpon2qjO7du2vixIlasGCBXn/9dZ0+fVpr1qzRddddp9TUVE2aNEm5ublq3LixIiMj9cEHH6hv377nXe91112n+++/X5MmTdLOnTvlcrk0c+ZMj390V8f+lJo7d65CQ0M1f/58vfzyy7ruuuv03nvvlbm8PiIiQhs2bNDjjz+u0aNH68SJE2rTpo3mzZv3m/4WOdM111yj9957T3/96181ZMgQNWnSRLGxsUpMTPS4cR9qB5v59bVAAGoFm82m0aNHa/bs2TXdlVpr/vz5uv/++5WZmalOnTrVdHcAAKgRS5Ys0b333qv//Oc/6tq1a013x6tatGihyMhIffTRRzXdFeCCcGYcAAAAuAi89dZb+vHHH9WuXTtddtllysjI0HPPPaebb775kgviQF1AGAcAAAAuAv7+/kpOTtYzzzyjY8eOKSwsTPHx8XrmmWdqumsALgCXqQMAAAAA4GU82gwAAAAAAC8jjAMAAAAA4GWEcQAAAAAAvKzO3sDt9OnT+umnn+Tv7y+bzVbT3QEAQMYYHTlyRC6XS5ddxv/DfyvGegBAbVOZsb7OhvGffvpJ4eHhNd0NAADK2Lt3r6644oqa7sZFj7EeAFBbVWSsr7Nh3N/fX9IvByEgIKCGewMAgFRQUKDw8HBrjMJvw1gPAKhtKjXWm0qYOnWq6dSpk2ncuLFp2rSpueWWW8w333zjUXP69GkzadIkExYWZho2bGiio6NNdna2R83JkyfNmDFjTJMmTYyfn58ZNGiQ2bt3r0fNoUOHzNChQ01AQIAJCAgwQ4cONfn5+RXuq9vtNpKM2+2uzC4CAFBtqntsmjRpkpHkMYWGhlrLvTlG//DDDyYmJsb4+fmZJk2amLFjx5rCwkKPmq+++srcfPPNpmHDhsblcpkpU6aY06dPV3h/GesBALVNZcamSn1gbd26dRo9erQyMjKUlpamU6dOqW/fvjp27JhVM336dM2cOVOzZ89WZmamnE6n+vTpoyNHjlg1CQkJWrp0qZKTk7V+/XodPXpUMTExKikpsWpiY2OVlZWllJQUpaSkKCsrS3FxcZXpLgAAl5xrr71WOTk51rR161ZrmbfG6JKSEg0cOFDHjh3T+vXrlZycrPfee0/jx4+3agoKCtSnTx+5XC5lZmZq1qxZmjFjhmbOnFnNRwgAgFrit6T+vLw8I8msW7fOGPPLf9ydTqeZNm2aVXPy5EnjcDjMK6+8Yowx5vDhw6ZBgwYmOTnZqvnxxx/NZZddZlJSUowxxnz99ddGksnIyLBq0tPTjaQyZ+LPhv+WAwBqG2+cGe/QoUO5y7w5Rq9YscJcdtll5scff7Rq3nrrLWO32619/+c//2kcDoc5efKkVZOUlGRcLleFz44z1gMAaptqOzN+JrfbLUkKCgqSJO3atUu5ubnq27evVWO32xUdHa0NGzZIkrZs2aLi4mKPGpfLpcjISKsmPT1dDodDnTt3tmq6dOkih8Nh1ZypsLBQBQUFHhMAAJeanTt3yuVyqWXLlrr77rv1/fffS/LuGJ2enq7IyEi5XC6rpl+/fiosLNSWLVusmujoaNntdo+an376Sbt37y533xjrAQB1yQWHcWOMEhMT9fvf/16RkZGSpNzcXElSaGioR21oaKi1LDc3Vz4+PgoMDDxnTUhISJlthoSEWDVnSkpKksPhsCburgoAuNR07txZb775pj755BO9/vrrys3NVdeuXXXw4EGvjtG5ubllthMYGCgfH59z1pTOM9YDAC4FFxzGx4wZo6+++kpvvfVWmWVnPuvTGHPe53+eWVNe/bnWM3HiRLndbmvau3dvRXYDAIA6Y8CAAbrtttvUrl079e7dW8uXL5ckLViwwKrx1hh9ITXGmLO+VmKsBwDULRcUxseOHasPPvhAa9as8Xh2mtPplFT2P9p5eXnWf7udTqeKioqUn59/zpr9+/eX2e6BAwfK/Be9lN1uV0BAgMcEAMClrFGjRmrXrp127tzp1THa6XSW2U5+fr6Ki4vPWZOXlyep7Nn7Uoz1AIC6pFJh3BijMWPG6P3339fq1avVsmVLj+UtW7aU0+lUWlqa1VZUVKR169apa9eukqSOHTuqQYMGHjU5OTnKzs62aqKiouR2u7Vp0yarZuPGjXK73VYNAAA4t8LCQm3fvl1hYWFeHaOjoqKUnZ2tnJwcqyY1NVV2u10dO3a0aj799FMVFRV51LhcLrVo0aLqDwYAALVNZe4M99BDDxmHw2HWrl1rcnJyrOn48eNWzbRp04zD4TDvv/++2bp1q7nnnntMWFiYKSgosGr+/Oc/myuuuMKsXLnSfP7556Znz56mQ4cO5tSpU1ZN//79Tfv27U16erpJT0837dq1MzExMRXuK3dYBQDUNtU9No0fP96sXbvWfP/99yYjI8PExMQYf39/s3v3bmOM98boU6dOmcjISNOrVy/z+eefm5UrV5orrrjCjBkzxqo5fPiwCQ0NNffcc4/ZunWref/9901AQICZMWNGhfeXsR4AUNtUZmyqVBiXVO40b948q+b06dNm0qRJxul0Grvdbm6++WazdetWj/WcOHHCjBkzxgQFBRlfX18TExNj9uzZ41Fz8OBBc++99xp/f3/j7+9v7r33XpOfn1/hvjJAAwBqm+oem+666y4TFhZmGjRoYFwulxkyZIjZtm2btdybY/QPP/xgBg4caHx9fU1QUJAZM2aMx2PMjDHmq6++MjfddJOx2+3G6XSayZMnV/ixZsYw1gMAap/KjE02Y/7/u6XUMQUFBXI4HHK73XymDABQKzA2VS2OJwCgtqnM2PSbnjMOAAAAAAAqjzAOAAAAAICX1a/pDgBATWjx2PKa7gIqYPe0gTXdBQDARYzxvva7lMd6zowDAAAAAOBlhHEAAAAAALyMMA4AAAAAgJcRxgEAAAAA8DLCOAAAAAAAXkYYBwAAAADAywjjAAAAAAB4GWEcAAAAAAAvI4wDAAAAAOBlhHEAAAAAALyMMA4AAAAAgJcRxgEAAAAA8DLCOAAAAAAAXkYYBwAAAADAywjjAAAAAAB4GWEcAAAAAAAvI4wDAAAAAOBlhHEAAAAAALyMMA4AAAAAgJcRxgEAAAAA8DLCOAAAAAAAXkYYBwAAAADAywjjAAAAAAB4WaXD+KeffqpBgwbJ5XLJZrNp2bJlHsttNlu503PPPWfVdO/evczyu+++22M9+fn5iouLk8PhkMPhUFxcnA4fPnxBOwkAAAAAQG1S6TB+7NgxdejQQbNnzy53eU5Ojsf0xhtvyGaz6bbbbvOoGzFihEfdq6++6rE8NjZWWVlZSklJUUpKirKyshQXF1fZ7gIAAAAAUOvUr+wLBgwYoAEDBpx1udPp9Jj/97//rR49euiqq67yaPfz8ytTW2r79u1KSUlRRkaGOnfuLEl6/fXXFRUVpR07digiIqKy3QYAAAAAoNao1s+M79+/X8uXL9fw4cPLLFu8eLGCg4N17bXXasKECTpy5Ii1LD09XQ6HwwriktSlSxc5HA5t2LChOrsMAAAAAEC1q/SZ8cpYsGCB/P39NWTIEI/2e++9Vy1btpTT6VR2drYmTpyoL7/8UmlpaZKk3NxchYSElFlfSEiIcnNzy91WYWGhCgsLrfmCgoIq3BMAAAAAAKpOtYbxN954Q/fee68aNmzo0T5ixAjr68jISLVu3VqdOnXS559/rhtuuEHSLzeCO5Mxptx2SUpKStKUKVOqsPcAAAAAAFSPartM/bPPPtOOHTv0pz/96by1N9xwgxo0aKCdO3dK+uVz5/v37y9Td+DAAYWGhpa7jokTJ8rtdlvT3r17f9sOAAAAAABQTaotjM+dO1cdO3ZUhw4dzlu7bds2FRcXKywsTJIUFRUlt9utTZs2WTUbN26U2+1W165dy12H3W5XQECAxwQAAAAAQG1U6cvUjx49qu+++86a37Vrl7KyshQUFKQrr7xS0i+f13733Xf1/PPPl3n9f//7Xy1evFh/+MMfFBwcrK+//lrjx4/X9ddfr27dukmS2rRpo/79+2vEiBHWI89GjhypmJgY7qQOAAAAALjoVfrM+ObNm3X99dfr+uuvlyQlJibq+uuv11NPPWXVJCcnyxije+65p8zrfXx8tGrVKvXr108REREaN26c+vbtq5UrV6pevXpW3eLFi9WuXTv17dtXffv2Vfv27bVw4cIL2UcAAAAAAGqVSp8Z7969u4wx56wZOXKkRo4cWe6y8PBwrVu37rzbCQoK0qJFiyrbPQAAAAAAar1qfc44AAAAAAAoizAOAAAAAICXEcYBAAAAAPAywjgAAAAAAF5GGAcAAAAAwMsI4wAAAAAAeBlhHAAAAAAALyOMAwAAAADgZYRxAAAAAAC8jDAOAAAAAICXEcYBAAAAAPAywjgAAAAAAF5GGAcAoA5KSkqSzWZTQkKC1WaM0eTJk+VyueTr66vu3btr27ZtHq8rLCzU2LFjFRwcrEaNGmnw4MHat2+fR01+fr7i4uLkcDjkcDgUFxenw4cPe9Ts2bNHgwYNUqNGjRQcHKxx48apqKjIo2br1q2Kjo6Wr6+vmjVrpqefflrGmCo9DgAA1FaEcQAA6pjMzEy99tprat++vUf79OnTNXPmTM2ePVuZmZlyOp3q06ePjhw5YtUkJCRo6dKlSk5O1vr163X06FHFxMSopKTEqomNjVVWVpZSUlKUkpKirKwsxcXFWctLSko0cOBAHTt2TOvXr1dycrLee+89jR8/3qopKChQnz595HK5lJmZqVmzZmnGjBmaOXNmNR4ZAABqj/o13QEAAFB1jh49qnvvvVevv/66nnnmGavdGKMXX3xRTzzxhIYMGSJJWrBggUJDQ7VkyRI9+OCDcrvdmjt3rhYuXKjevXtLkhYtWqTw8HCtXLlS/fr10/bt25WSkqKMjAx17txZkvT6668rKipKO3bsUEREhFJTU/X1119r7969crlckqTnn39e8fHx+vvf/66AgAAtXrxYJ0+e1Pz582W32xUZGalvv/1WM2fOVGJiomw2m5ePHAAA3sWZcQAA6pDRo0dr4MCBVpgutWvXLuXm5qpv375Wm91uV3R0tDZs2CBJ2rJli4qLiz1qXC6XIiMjrZr09HQ5HA4riEtSly5d5HA4PGoiIyOtIC5J/fr1U2FhobZs2WLVREdHy263e9T89NNP2r17d7n7VlhYqIKCAo8JAICLFWEcAIA6Ijk5WZ9//rmSkpLKLMvNzZUkhYaGerSHhoZay3Jzc+Xj46PAwMBz1oSEhJRZf0hIiEfNmdsJDAyUj4/POWtK50trzpSUlGR9Tt3hcCg8PLzcOgAALgaEcQAA6oC9e/fqf//3f7Vo0SI1bNjwrHVnXv5tjDnvJeFn1pRXXxU1pTdvO1t/Jk6cKLfbbU179+49Z78BAKjNCOMAANQBW7ZsUV5enjp27Kj69eurfv36WrdunV5++WXVr1//rGed8/LyrGVOp1NFRUXKz88/Z83+/fvLbP/AgQMeNWduJz8/X8XFxeesycvLk1T27H0pu92ugIAAjwkAgIsVYRwAgDqgV69e2rp1q7KysqypU6dOuvfee5WVlaWrrrpKTqdTaWlp1muKioq0bt06de3aVZLUsWNHNWjQwKMmJydH2dnZVk1UVJTcbrc2bdpk1WzcuFFut9ujJjs7Wzk5OVZNamqq7Ha7OnbsaNV8+umnHo87S01NlcvlUosWLar+AAEAUMtwN3UAAOoAf39/RUZGerQ1atRITZo0sdoTEhI0depUtW7dWq1bt9bUqVPl5+en2NhYSZLD4dDw4cM1fvx4NWnSREFBQZowYYLatWtn3RCuTZs26t+/v0aMGKFXX31VkjRy5EjFxMQoIiJCktS3b1+1bdtWcXFxeu6553To0CFNmDBBI0aMsM5mx8bGasqUKYqPj9fjjz+unTt3aurUqXrqqae4kzoA4JJAGAcA4BLxyCOP6MSJExo1apTy8/PVuXNnpaamyt/f36p54YUXVL9+fd155506ceKEevXqpfnz56tevXpWzeLFizVu3DjrruuDBw/W7NmzreX16tXT8uXLNWrUKHXr1k2+vr6KjY3VjBkzrBqHw6G0tDSNHj1anTp1UmBgoBITE5WYmOiFIwEAQM2zmdK7pdQxBQUFcjgccrvdfKYMQBktHlte011ABeyeNrCmu1ClGJuqFscTwPkw3td+l/JYz2fGAQAAAADwMsI4AAAAAABeRhgHAAAAAMDLCOMAAAAAAHhZpcP4p59+qkGDBsnlcslms2nZsmUey+Pj42Wz2TymLl26eNQUFhZq7NixCg4OVqNGjTR48GDt27fPoyY/P19xcXFyOBxyOByKi4vT4cOHK72DAAAAAADUNpUO48eOHVOHDh08HmFypv79+ysnJ8eaVqxY4bE8ISFBS5cuVXJystavX6+jR48qJiZGJSUlVk1sbKyysrKUkpKilJQUZWVlKS4urrLdBQAAAACg1qn0c8YHDBigAQMGnLPGbrfL6XSWu8ztdmvu3LlauHChevfuLUlatGiRwsPDtXLlSvXr10/bt29XSkqKMjIy1LlzZ0nS66+/rqioKO3YsUMRERGV7TYAAAAAALVGtXxmfO3atQoJCdHvfvc7jRgxQnl5edayLVu2qLi4WH379rXaXC6XIiMjtWHDBklSenq6HA6HFcQlqUuXLnI4HFYNAAAAAAAXq0qfGT+fAQMG6I477lDz5s21a9cuPfnkk+rZs6e2bNkiu92u3Nxc+fj4KDAw0ON1oaGhys3NlSTl5uYqJCSkzLpDQkKsmjMVFhaqsLDQmi8oKKjCvQIAAAAAoOpUeRi/6667rK8jIyPVqVMnNW/eXMuXL9eQIUPO+jpjjGw2mzX/66/PVvNrSUlJmjJlym/oOQAAAAAA3lHtjzYLCwtT8+bNtXPnTkmS0+lUUVGR8vPzPery8vIUGhpq1ezfv7/Mug4cOGDVnGnixIlyu93WtHfv3ireEwAAAAAAqka1h/GDBw9q7969CgsLkyR17NhRDRo0UFpamlWTk5Oj7Oxsde3aVZIUFRUlt9utTZs2WTUbN26U2+22as5kt9sVEBDgMQEAAAAAUBtV+jL1o0eP6rvvvrPmd+3apaysLAUFBSkoKEiTJ0/WbbfdprCwMO3evVuPP/64goOD9cc//lGS5HA4NHz4cI0fP15NmjRRUFCQJkyYoHbt2ll3V2/Tpo369++vESNG6NVXX5UkjRw5UjExMdxJHQAAAABw0at0GN+8ebN69OhhzScmJkqShg0bpjlz5mjr1q168803dfjwYYWFhalHjx56++235e/vb73mhRdeUP369XXnnXfqxIkT6tWrl+bPn6969epZNYsXL9a4ceOsu64PHjz4nM82BwAAAADgYlHpMN69e3cZY866/JNPPjnvOho2bKhZs2Zp1qxZZ60JCgrSokWLKts9AAAAAABqvWr/zDgAAAAAAPBEGAcAAAAAwMsI4wAAAAAAeBlhHAAAAAAALyOMAwAAAADgZYRxAAAAAAC8jDAOAAAAAICXEcYBAAAAAPAywjgAAAAAAF5GGAcAAAAAwMsI4wAAAAAAeBlhHAAAAAAALyOMAwAAAADgZYRxAAAAAAC8jDAOAAAAAICXEcYBAAAAAPAywjgAAAAAAF5GGAcAAAAAwMsI4wAAAAAAeBlhHAAAAAAALyOMAwAAAADgZYRxAAAAAAC8jDAOAAAAAICXEcYBAAAAAPAywjgAAAAAAF5GGAcAAAAAwMsI4wAAAAAAeFmlw/inn36qQYMGyeVyyWazadmyZday4uJiPfroo2rXrp0aNWokl8ul++67Tz/99JPHOrp37y6bzeYx3X333R41+fn5iouLk8PhkMPhUFxcnA4fPnxBOwkAAAAAQG1S6TB+7NgxdejQQbNnzy6z7Pjx4/r888/15JNP6vPPP9f777+vb7/9VoMHDy5TO2LECOXk5FjTq6++6rE8NjZWWVlZSklJUUpKirKyshQXF1fZ7gIAAAAAUOvUr+wLBgwYoAEDBpS7zOFwKC0tzaNt1qxZuvHGG7Vnzx5deeWVVrufn5+cTme569m+fbtSUlKUkZGhzp07S5Jef/11RUVFaceOHYqIiKhstwEAAAAAqDWq/TPjbrdbNptNl19+uUf74sWLFRwcrGuvvVYTJkzQkSNHrGXp6elyOBxWEJekLl26yOFwaMOGDeVup7CwUAUFBR4TAAAAAAC1UaXPjFfGyZMn9dhjjyk2NlYBAQFW+7333quWLVvK6XQqOztbEydO1JdffmmdVc/NzVVISEiZ9YWEhCg3N7fcbSUlJWnKlCnVsyMAAAAAAFShagvjxcXFuvvuu3X69Gn985//9Fg2YsQI6+vIyEi1bt1anTp10ueff64bbrhBkmSz2cqs0xhTbrskTZw4UYmJidZ8QUGBwsPDq2JXAAAAAACoUtUSxouLi3XnnXdq165dWr16tcdZ8fLccMMNatCggXbu3KkbbrhBTqdT+/fvL1N34MABhYaGlrsOu90uu91eJf0HAAAAAKA6VflnxkuD+M6dO7Vy5Uo1adLkvK/Ztm2biouLFRYWJkmKioqS2+3Wpk2brJqNGzfK7Xara9euVd1lAADqhDlz5qh9+/YKCAhQQECAoqKi9PHHH1vLjTGaPHmyXC6XfH191b17d23bts1jHYWFhRo7dqyCg4PVqFEjDR48WPv27fOoqcjjR/fs2aNBgwapUaNGCg4O1rhx41RUVORRs3XrVkVHR8vX11fNmjXT008/LWNM1R4UAABqqUqH8aNHjyorK0tZWVmSpF27dikrK0t79uzRqVOndPvtt2vz5s1avHixSkpKlJubq9zcXGsA/u9//6unn35amzdv1u7du7VixQrdcccduv7669WtWzdJUps2bdS/f3+NGDFCGRkZysjI0IgRIxQTE8Od1AEAOIsrrrhC06ZN0+bNm7V582b17NlTt9xyixW4p0+frpkzZ2r27NnKzMyU0+lUnz59PG6impCQoKVLlyo5OVnr16/X0aNHFRMTo5KSEqvmfI8fLSkp0cCBA3Xs2DGtX79eycnJeu+99zR+/HirpqCgQH369JHL5VJmZqZmzZqlGTNmaObMmV44UgAA1DybqeS/oNeuXasePXqUaR82bJgmT56sli1blvu6NWvWqHv37tq7d6+GDh2q7OxsHT16VOHh4Ro4cKAmTZqkoKAgq/7QoUMaN26cPvjgA0nS4MGDNXv27DJ3ZT+bgoICORwOud3u814mD+DS0+Kx5TXdBVTA7mkDa7oLVaomxqagoCA999xzeuCBB+RyuZSQkKBHH31U0i9nwUNDQ/Xss8/qwQcflNvtVtOmTbVw4ULdddddkqSffvpJ4eHhWrFihfr166ft27erbdu2Ho8fzcjIUFRUlL755htFRETo448/VkxMjPbu3SuXyyVJSk5OVnx8vPLy8hQQEKA5c+Zo4sSJ2r9/v/Uxs2nTpmnWrFnat2/fWe8R82uM9QDOh/G+9ruUx/pKf2a8e/fu57yE7HzZPjw8XOvWrTvvdoKCgrRo0aLKdg8AAOiXs9Pvvvuujh07pqioKO3atUu5ubnq27evVWO32xUdHa0NGzbowQcf1JYtW1RcXOxR43K5FBkZqQ0bNqhfv37nffxoRESE0tPTFRkZaQVxSerXr58KCwu1ZcsW9ejRQ+np6YqOjva430u/fv00ceJE7d69+6z/3AcAoK6o9ueMAwAA79m6dasaN24su92uP//5z1q6dKnatm1rPRr0zBuhhoaGWstyc3Pl4+OjwMDAc9ac7/Gjubm5ZbYTGBgoHx+fc9aUzp/tMaaFhYUqKCjwmAAAuFgRxgEAqEMiIiKUlZWljIwMPfTQQxo2bJi+/vpra/mZl3+f67GhZ6upyONHL6Sm9Oq6s/UnKSnJummcw+HgEaYAgIsaYRwAgDrEx8dHV199tTp16qSkpCR16NBBL730kpxOp6SyZ53z8vKsM9JOp1NFRUXKz88/Z835Hj/qdDrLbCc/P1/FxcXnrMnLy5NU9ux9qYkTJ8rtdlvT3r17z39AAACopQjjAADUYcYYFRYWqmXLlnI6nUpLS7OWFRUVad26ddZjQzt27KgGDRp41OTk5Cg7O9uqqcjjR6OiopSdna2cnByrJjU1VXa7XR07drRqPv30U4/HnaWmpsrlcqlFixbl7ovdbrce21Y6AQBwsSKMAwBQRzz++OP67LPPtHv3bm3dulVPPPGE1q5dq3vvvVc2m00JCQmaOnWqli5dquzsbMXHx8vPz0+xsbGSJIfDoeHDh2v8+PFatWqVvvjiCw0dOlTt2rVT7969JVXs8aN9+/ZV27ZtFRcXpy+++EKrVq3ShAkTNGLECCtAx8bGym63Kz4+XtnZ2Vq6dKmmTp2qxMTECt1JHQCAi12l76YOAABqp/379ysuLk45OTlyOBxq3769UlJS1KdPH0nSI488ohMnTmjUqFHKz89X586dlZqaKn9/f2sdL7zwgurXr68777xTJ06cUK9evTR//nzVq1fPqlm8eLHGjRtn3XW99PGjperVq6fly5dr1KhR6tatm3x9fRUbG6sZM2ZYNQ6HQ2lpaRo9erQ6deqkwMBAJSYmKjExsboPEwAAtUKlnzN+seDZowDOheeOXhwu5WeP4vw4ngDOh/G+9ruUx3ouUwcAAAAAwMsI4wAAAAAAeBlhHAAAAAAALyOMAwAAAADgZYRxAAAAAAC8jDAOAAAAAICXEcYBAAAAAPAywjgAAAAAAF5GGAcAAAAAwMsI4wAAAAAAeBlhHAAAAAAALyOMAwAAAADgZYRxAAAAAAC8jDAOAAAAAICXEcYBAAAAAPAywjgAAAAAAF5GGAcAAAAAwMsI4wAAAAAAeBlhHAAAAAAALyOMAwAAAADgZZUO459++qkGDRokl8slm82mZcuWeSw3xmjy5MlyuVzy9fVV9+7dtW3bNo+awsJCjR07VsHBwWrUqJEGDx6sffv2edTk5+crLi5ODodDDodDcXFxOnz4cKV3EAAAAACA2qbSYfzYsWPq0KGDZs+eXe7y6dOna+bMmZo9e7YyMzPldDrVp08fHTlyxKpJSEjQ0qVLlZycrPXr1+vo0aOKiYlRSUmJVRMbG6usrCylpKQoJSVFWVlZiouLu4BdBAAAAACgdqlf2RcMGDBAAwYMKHeZMUYvvviinnjiCQ0ZMkSStGDBAoWGhmrJkiV68MEH5Xa7NXfuXC1cuFC9e/eWJC1atEjh4eFauXKl+vXrp+3btyslJUUZGRnq3LmzJOn1119XVFSUduzYoYiIiAvdXwAAAAAAalyVfmZ8165dys3NVd++fa02u92u6OhobdiwQZK0ZcsWFRcXe9S4XC5FRkZaNenp6XI4HFYQl6QuXbrI4XBYNWcqLCxUQUGBxwQAAAAAQG1UpWE8NzdXkhQaGurRHhoaai3Lzc2Vj4+PAgMDz1kTEhJSZv0hISFWzZmSkpKsz5c7HA6Fh4f/5v0BAAAAAKA6VMvd1G02m8e8MaZM25nOrCmv/lzrmThxotxutzXt3bv3AnoOAAAAAED1q9Iw7nQ6JanM2eu8vDzrbLnT6VRRUZHy8/PPWbN///4y6z9w4ECZs+6l7Ha7AgICPCYAAAAAAGqjKg3jLVu2lNPpVFpamtVWVFSkdevWqWvXrpKkjh07qkGDBh41OTk5ys7OtmqioqLkdru1adMmq2bjxo1yu91WDQAAAAAAF6tK30396NGj+u6776z5Xbt2KSsrS0FBQbryyiuVkJCgqVOnqnXr1mrdurWmTp0qPz8/xcbGSpIcDoeGDx+u8ePHq0mTJgoKCtKECRPUrl076+7qbdq0Uf/+/TVixAi9+uqrkqSRI0cqJiaGO6kDAAAAAC56lQ7jmzdvVo8ePaz5xMRESdKwYcM0f/58PfLIIzpx4oRGjRql/Px8de7cWampqfL397de88ILL6h+/fq68847deLECfXq1Uvz589XvXr1rJrFixdr3Lhx1l3XBw8efNZnmwMAAAAAcDGxGWNMTXeiOhQUFMjhcMjtdvP5cQBltHhseU13ARWwe9rAmu5ClWJsqlocTwDnw3hf+13KY3213E0dAAAAAACcHWEcAAAAAAAvI4wDAAAAAOBlhHEAAAAAALyMMA4AAAAAgJcRxgEAAAAA8DLCOAAAAAAAXkYYBwAAAADAywjjAAAAAAB4GWEcAAAAAAAvI4wDAAAAAOBlhHEAAAAAALyMMA4AAAAAgJcRxgEAAAAA8DLCOAAAAAAAXkYYBwAAAADAywjjAAAAAAB4GWEcAAAAAAAvI4wDAAAAAOBlhHEAAOqIpKQk/c///I/8/f0VEhKiW2+9VTt27PCoMcZo8uTJcrlc8vX1Vffu3bVt2zaPmsLCQo0dO1bBwcFq1KiRBg8erH379nnU5OfnKy4uTg6HQw6HQ3FxcTp8+LBHzZ49ezRo0CA1atRIwcHBGjdunIqKijxqtm7dqujoaPn6+qpZs2Z6+umnZYypuoMCAEAtRRgHAKCOWLdunUaPHq2MjAylpaXp1KlT6tu3r44dO2bVTJ8+XTNnztTs2bOVmZkpp9OpPn366MiRI1ZNQkKCli5dquTkZK1fv15Hjx5VTEyMSkpKrJrY2FhlZWUpJSVFKSkpysrKUlxcnLW8pKREAwcO1LFjx7R+/XolJyfrvffe0/jx462agoIC9enTRy6XS5mZmZo1a5ZmzJihmTNnVvORAgCg5tlMHf33c0FBgRwOh9xutwICAmq6OwBqmRaPLa/pLqACdk8bWNNdqFLeHpsOHDigkJAQrVu3TjfffLOMMXK5XEpISNCjjz4q6Zez4KGhoXr22Wf14IMPyu12q2nTplq4cKHuuusuSdJPP/2k8PBwrVixQv369dP27dvVtm1bZWRkqHPnzpKkjIwMRUVF6ZtvvlFERIQ+/vhjxcTEaO/evXK5XJKk5ORkxcfHKy8vTwEBAZozZ44mTpyo/fv3y263S5KmTZumWbNmad++fbLZbOfcP8Z6AOfDeF/7XcpjPWfGAQCoo9xutyQpKChIkrRr1y7l5uaqb9++Vo3dbld0dLQ2bNggSdqyZYuKi4s9alwulyIjI62a9PR0ORwOK4hLUpcuXeRwODxqIiMjrSAuSf369VNhYaG2bNli1URHR1tBvLTmp59+0u7du8vsT2FhoQoKCjwmAAAuVoRxAADqIGOMEhMT9fvf/16RkZGSpNzcXElSaGioR21oaKi1LDc3Vz4+PgoMDDxnTUhISJlthoSEeNScuZ3AwED5+Pics6Z0vrTm15KSkqzPqDscDoWHh1fgSAAAUDsRxgEAqIPGjBmjr776Sm+99VaZZWde/m2MOe8l4WfWlFdfFTWln54r77UTJ06U2+22pr17956zzwAA1GaEcQAA6pixY8fqgw8+0Jo1a3TFFVdY7U6nU1LZs855eXnWGWmn06mioiLl5+efs2b//v1ltnvgwAGPmjO3k5+fr+Li4nPW5OXlSSp79l765ZL6gIAAjwkAgItVlYfxFi1ayGazlZlGjx4tSYqPjy+zrEuXLh7rqMgjVQAAgCdjjMaMGaP3339fq1evVsuWLT2Wt2zZUk6nU2lpaVZbUVGR1q1bp65du0qSOnbsqAYNGnjU5OTkKDs726qJioqS2+3Wpk2brJqNGzfK7XZ71GRnZysnJ8eqSU1Nld1uV8eOHa2aTz/91ONxZ6mpqXK5XGrRokUVHRUAAGqnKg/jmZmZysnJsabSwfyOO+6wavr37+9Rs2LFCo91VOSRKgAAwNPo0aO1aNEiLVmyRP7+/srNzVVubq5OnDgh6ZdLvxMSEjR16lQtXbpU2dnZio+Pl5+fn2JjYyVJDodDw4cP1/jx47Vq1Sp98cUXGjp0qNq1a6fevXtLktq0aaP+/ftrxIgRysjIUEZGhkaMGKGYmBhFRERIkvr27au2bdsqLi5OX3zxhVatWqUJEyZoxIgR1hnt2NhY2e12xcfHKzs7W0uXLtXUqVOVmJh43svmAQC42NWv6hU2bdrUY37atGlq1aqVoqOjrTa73W5dKncmt9utuXPnauHChdagv2jRIoWHh2vlypXq169fVXcZAIA6Yc6cOZKk7t27e7TPmzdP8fHxkqRHHnlEJ06c0KhRo5Sfn6/OnTsrNTVV/v7+Vv0LL7yg+vXr684779SJEyfUq1cvzZ8/X/Xq1bNqFi9erHHjxll3XR88eLBmz55tLa9Xr56WL1+uUaNGqVu3bvL19VVsbKxmzJhh1TgcDqWlpWn06NHq1KmTAgMDlZiYqMTExKo+NAAA1DrV+pzxoqIiuVwuJSYm6vHHH5f0y2Xqy5Ytk4+Pjy6//HJFR0fr73//u3VX1tWrV6tXr146dOiQx51cO3TooFtvvVVTpkyp0LZ59iiAc+G5oxeHS/nZozg/jieA82G8r/0u5bG+ys+M/9qyZct0+PBh67/xkjRgwADdcccdat68uXbt2qUnn3xSPXv21JYtW2S32yv0SJXyFBYWqrCw0Jrn2aMAAAAAgNqqWsP43LlzNWDAALlcLqvtrrvusr6OjIxUp06d1Lx5cy1fvlxDhgw567rO99iVpKSkCp81BwAAAACgJlXbo81++OEHrVy5Un/605/OWRcWFqbmzZtr586dkir2SJXy8OxRAAAAAMDFotrC+Lx58xQSEqKBA8/9GYCDBw9q7969CgsLk1SxR6qUh2ePAgAAAAAuFtVymfrp06c1b948DRs2TPXr/98mjh49qsmTJ+u2225TWFiYdu/erccff1zBwcH64x//KMnzkSpNmjRRUFCQJkyY4PFIFQAAAAAALmbVEsZXrlypPXv26IEHHvBor1evnrZu3ao333xThw8fVlhYmHr06KG333670o9UAQAAAADgYlUtYbxv374q74lpvr6++uSTT877+oYNG2rWrFmaNWtWdXQPAAAAAIAaVW2fGQcAAAAAAOUjjAMAAAAA4GWEcQAAAAAAvIwwDgAAAACAlxHGAQAAAADwMsI4AAAAAABeRhgHAAAAAMDLCOMAAAAAAHgZYRwAAAAAAC8jjAMAAAAA4GWEcQAAAAAAvIwwDgAAAACAlxHGAQAAAADwMsI4AAAAAABeRhgHAAAAAMDLCOMAAAAAAHgZYRwAAAAAAC8jjAMAAAAA4GWEcQAAAAAAvIwwDgAAAACAlxHGAQAAAADwMsI4AAAAAABeRhgHAAAAAMDLCOMAAAAAAHgZYRwAAAAAAC8jjAMAAAAA4GWEcQAAAAAAvKzKw/jkyZNls9k8JqfTaS03xmjy5MlyuVzy9fVV9+7dtW3bNo91FBYWauzYsQoODlajRo00ePBg7du3r6q7CgAAAABAjaiWM+PXXnutcnJyrGnr1q3WsunTp2vmzJmaPXu2MjMz5XQ61adPHx05csSqSUhI0NKlS5WcnKz169fr6NGjiomJUUlJSXV0FwAAAAAAr6pfLSutX9/jbHgpY4xefPFFPfHEExoyZIgkacGCBQoNDdWSJUv04IMPyu12a+7cuVq4cKF69+4tSVq0aJHCw8O1cuVK9evXrzq6DAAAAACA11TLmfGdO3fK5XKpZcuWuvvuu/X9999Lknbt2qXc3Fz17dvXqrXb7YqOjtaGDRskSVu2bFFxcbFHjcvlUmRkpFUDAAAAAMDFrMrPjHfu3Flvvvmmfve732n//v165pln1LVrV23btk25ubmSpNDQUI/XhIaG6ocffpAk5ebmysfHR4GBgWVqSl9fnsLCQhUWFlrzBQUFVbVLAAAAAABUqSoP4wMGDLC+bteunaKiotSqVSstWLBAXbp0kSTZbDaP1xhjyrSd6Xw1SUlJmjJlym/oOQAAAAAA3lHtjzZr1KiR2rVrp507d1qfIz/zDHdeXp51ttzpdKqoqEj5+flnrSnPxIkT5Xa7rWnv3r1VvCcAAAAAAFSNag/jhYWF2r59u8LCwtSyZUs5nU6lpaVZy4uKirRu3Tp17dpVktSxY0c1aNDAoyYnJ0fZ2dlWTXnsdrsCAgI8JgAAAAAAaqMqv0x9woQJGjRokK688krl5eXpmWeeUUFBgYYNGyabzaaEhARNnTpVrVu3VuvWrTV16lT5+fkpNjZWkuRwODR8+HCNHz9eTZo0UVBQkCZMmKB27dpZd1cHAAAAAOBiVuVhfN++fbrnnnv0888/q2nTpurSpYsyMjLUvHlzSdIjjzyiEydOaNSoUcrPz1fnzp2Vmpoqf39/ax0vvPCC6tevrzvvvFMnTpxQr169NH/+fNWrV6+quwsAAAAAgNfZjDGmpjtRHQoKCuRwOOR2u7lkHUAZLR5bXtNdQAXsnjawprtQpRibqhbHE8D5MN7XfpfyWF/tnxkHAAAAAACeCOMAAAAAAHgZYRwAAAAAAC8jjAMAAAAA4GWEcQAA6ohPP/1UgwYNksvlks1m07JlyzyWG2M0efJkuVwu+fr6qnv37tq2bZtHTWFhocaOHavg4GA1atRIgwcP1r59+zxq8vPzFRcXJ4fDIYfDobi4OB0+fNijZs+ePRo0aJAaNWqk4OBgjRs3TkVFRR41W7duVXR0tHx9fdWsWTM9/fTTqqP3lQUAoAzCOAAAdcSxY8fUoUMHzZ49u9zl06dP18yZMzV79mxlZmbK6XSqT58+OnLkiFWTkJCgpUuXKjk5WevXr9fRo0cVExOjkpISqyY2NlZZWVlKSUlRSkqKsrKyFBcXZy0vKSnRwIEDdezYMa1fv17Jycl67733NH78eKumoKBAffr0kcvlUmZmpmbNmqUZM2Zo5syZ1XBkAACofar8OeMAAKBmDBgwQAMGDCh3mTFGL774op544gkNGTJEkrRgwQKFhoZqyZIlevDBB+V2uzV37lwtXLhQvXv3liQtWrRI4eHhWrlypfr166ft27crJSVFGRkZ6ty5syTp9ddfV1RUlHbs2KGIiAilpqbq66+/1t69e+VyuSRJzz//vOLj4/X3v/9dAQEBWrx4sU6ePKn58+fLbrcrMjJS3377rWbOnKnExETZbDYvHDEAAGoOZ8YBALgE7Nq1S7m5uerbt6/VZrfbFR0drQ0bNkiStmzZouLiYo8al8ulyMhIqyY9PV0Oh8MK4pLUpUsXORwOj5rIyEgriEtSv379VFhYqC1btlg10dHRstvtHjU//fSTdu/eXfUHAACAWoYwDgDAJSA3N1eSFBoa6tEeGhpqLcvNzZWPj48CAwPPWRMSElJm/SEhIR41Z24nMDBQPj4+56wpnS+tOVNhYaEKCgo8JgAALlaEcQAALiFnXv5tjDnvJeFn1pRXXxU1pTdvO1t/kpKSrJvGORwOhYeHn7PfAADUZoRxAAAuAU6nU1LZs855eXnWGWmn06mioiLl5+efs2b//v1l1n/gwAGPmjO3k5+fr+Li4nPW5OXlSSp79r7UxIkT5Xa7rWnv3r3n33EAAGopwjgAAJeAli1byul0Ki0tzWorKirSunXr1LVrV0lSx44d1aBBA4+anJwcZWdnWzVRUVFyu93atGmTVbNx40a53W6PmuzsbOXk5Fg1qampstvt6tixo1Xz6aefejzuLDU1VS6XSy1atCh3H+x2uwICAjwmAAAuVoRxAADqiKNHjyorK0tZWVmSfrlpW1ZWlvbs2SObzaaEhARNnTpVS5cuVXZ2tuLj4+Xn56fY2FhJksPh0PDhwzV+/HitWrVKX3zxhYYOHap27dpZd1dv06aN+vfvrxEjRigjI0MZGRkaMWKEYmJiFBERIUnq27ev2rZtq7i4OH3xxRdatWqVJkyYoBEjRlgBOjY2Vna7XfHx8crOztbSpUs1depU7qQOALhk8GgzAADqiM2bN6tHjx7WfGJioiRp2LBhmj9/vh555BGdOHFCo0aNUn5+vjp37qzU1FT5+/tbr3nhhRdUv3593XnnnTpx4oR69eql+fPnq169elbN4sWLNW7cOOuu64MHD/Z4tnm9evW0fPlyjRo1St26dZOvr69iY2M1Y8YMq8bhcCgtLU2jR49Wp06dFBgYqMTERKvPAADUdTZTereUOqagoEAOh0Nut5vL2ACU0eKx5TXdBVTA7mkDa7oLVYqxqWpxPAGcD+N97Xcpj/Vcpg4AAAAAgJcRxgEAAAAA8DLCOAAAAAAAXkYYBwAAAADAywjjAAAAAAB4GWEcAAAAAAAvI4wDAAAAAOBl9Wu6A6ikyY6a7gEqYrK7pnsAALhYMdZfHBjrAfxGnBkHAAAAAMDLCOMAAAAAAHgZYRwAAAAAAC8jjAMAAAAA4GVVHsaTkpL0P//zP/L391dISIhuvfVW7dixw6MmPj5eNpvNY+rSpYtHTWFhocaOHavg4GA1atRIgwcP1r59+6q6uwAAAAAAeF2Vh/F169Zp9OjRysjIUFpamk6dOqW+ffvq2LFjHnX9+/dXTk6ONa1YscJjeUJCgpYuXark5GStX79eR48eVUxMjEpKSqq6ywAAAAAAeFWVP9osJSXFY37evHkKCQnRli1bdPPNN1vtdrtdTqez3HW43W7NnTtXCxcuVO/evSVJixYtUnh4uFauXKl+/fpVdbcBAAAAAPCaav/MuNv9yzMYg4KCPNrXrl2rkJAQ/e53v9OIESOUl5dnLduyZYuKi4vVt29fq83lcikyMlIbNmwodzuFhYUqKCjwmAAAAAAAqI2qNYwbY5SYmKjf//73ioyMtNoHDBigxYsXa/Xq1Xr++eeVmZmpnj17qrCwUJKUm5srHx8fBQYGeqwvNDRUubm55W4rKSlJDofDmsLDw6tvxwAAAAAA+A2q/DL1XxszZoy++uorrV+/3qP9rrvusr6OjIxUp06d1Lx5cy1fvlxDhgw56/qMMbLZbOUumzhxohITE635goICAjkAAAAAoFaqtjPjY8eO1QcffKA1a9boiiuuOGdtWFiYmjdvrp07d0qSnE6nioqKlJ+f71GXl5en0NDQctdht9sVEBDgMQEAAAAAUBtVeRg3xmjMmDF6//33tXr1arVs2fK8rzl48KD27t2rsLAwSVLHjh3VoEEDpaWlWTU5OTnKzs5W165dq7rLAAAAAAB4VZVfpj569GgtWbJE//73v+Xv7299xtvhcMjX11dHjx7V5MmTddtttyksLEy7d+/W448/ruDgYP3xj3+0aocPH67x48erSZMmCgoK0oQJE9SuXTvr7uoAAAAAAFysqjyMz5kzR5LUvXt3j/Z58+YpPj5e9erV09atW/Xmm2/q8OHDCgsLU48ePfT222/L39/fqn/hhRdUv3593XnnnTpx4oR69eql+fPnq169elXdZQAAAAAAvKrKw7gx5pzLfX199cknn5x3PQ0bNtSsWbM0a9asquoaAAAAAAC1QrU/ZxwAAAAAAHgijAMAAAAA4GWEcQAAAAAAvIwwDgAAAACAlxHGAQAAAADwMsI4AAAAAABeRhgHAAAAAMDLCOMAAAAAAHgZYRwAAAAAAC8jjAMAAAAA4GWEcQAAAAAAvIwwDgAAAACAlxHGAQAAAADwMsI4AAAAAABeRhgHAAAAAMDLCOMAAAAAAHgZYRwAAAAAAC8jjAMAAAAA4GWEcQAAAAAAvIwwDgAAAACAlxHGAQAAAADwMsI4AAAAAABeRhgHAAAAAMDLCOMAAAAAAHgZYRwAAAAAAC8jjAMAAAAA4GWEcQAAAAAAvKzWh/F//vOfatmypRo2bKiOHTvqs88+q+kuAQCAKsRYDwC4FNXqMP72228rISFBTzzxhL744gvddNNNGjBggPbs2VPTXQMAAFWAsR4AcKmq1WF85syZGj58uP70pz+pTZs2evHFFxUeHq45c+bUdNcAAEAVYKwHAFyq6td0B86mqKhIW7Zs0WOPPebR3rdvX23YsKFMfWFhoQoLC615t9stSSooKKjejnpboanpHqAi6tr3XR10uvB4TXcBFVDXfoeX7o8x/C6XGOvPirH+4lDXvu/qKMb72q+u/Q6vzFhfa8P4zz//rJKSEoWGhnq0h4aGKjc3t0x9UlKSpkyZUqY9PDy82voInNU0R033AKgTHC/WdA+qx5EjR+Rw8HuCsR4XNcZ6oEpcymN9rQ3jpWw2m8e8MaZMmyRNnDhRiYmJ1vzp06d16NAhNWnSpNx61A4FBQUKDw/X3r17FRAQUNPdAS5a/CxdHIwxOnLkiFwuV013pVZhrK/b+P0EVB1+nmq/yoz1tTaMBwcHq169emX+M56Xl1fmP+iSZLfbZbfbPdouv/zy6uwiqlBAQAC/UIAqwM9S7ccZ8f/DWH9p4fcTUHX4eardKjrW19obuPn4+Khjx45KS0vzaE9LS1PXrl1rqFcAAKCqMNYDAC5ltfbMuCQlJiYqLi5OnTp1UlRUlF577TXt2bNHf/7zn2u6awAAoAow1gMALlW1OozfddddOnjwoJ5++mnl5OQoMjJSK1asUPPmzWu6a6gidrtdkyZNKnPZIYDK4WcJFyvG+rqP309A1eHnqW6xGZ6vAgAAAACAV9Xaz4wDAAAAAFBXEcYBAAAAAPAywjgAAAAAAF5GGAcAAAAAwMsI4wBwkbr//vu1atUqcR9OAADqJsb6uo0wDgAXqYMHD2rgwIG64oorNH78eGVlZdV0lwAAQBVirK/beLQZasTJkyf11VdfKS8vT6dPn/ZYNnjw4BrqFXDxOXz4sN555x0tWbJEn332mSIiIjR06FDFxsaqRYsWNd09AJcwxnqgajDW112EcXhdSkqK7rvvPv38889lltlsNpWUlNRAr4CL3759+/TWW2/pjTfe0M6dO3Xq1Kma7hKASxRjPVA9GOvrFi5Th9eNGTNGd9xxh3JycnT69GmPicEZuDDFxcXavHmzNm7cqN27dys0NLSmuwTgEsZYD1Q9xvq6hzAOr8vLy1NiYiK/QIAqsGbNGo0YMUKhoaEaNmyY/P399eGHH2rv3r013TUAlzDGeqDqMNbXXfVrugO49Nx+++1au3atWrVqVdNdAS5qV1xxhQ4ePKh+/frp1Vdf1aBBg9SwYcOa7hYAMNYDVYSxvm7jM+PwuuPHj+uOO+5Q06ZN1a5dOzVo0MBj+bhx42qoZ8DF5bXXXtMdd9yhwMDAmu4KAHhgrAeqBmN93UYYh9f9v//3//TnP/9Zvr6+atKkiWw2m7XMZrPp+++/r8HeAQCA34qxHgDOjzAOr3M6nRo3bpwee+wxXXYZty0AAKCuYawHgPPjtyO8rqioSHfddReDMwAAdRRjPQCcH78h4XXDhg3T22+/XdPdAAAA1YSxHgDOj7upw+tKSko0ffp0ffLJJ2rfvn2Zm7rMnDmzhnoGAACqAmM9AJwfnxmH1/Xo0eOsy2w2m1avXu3F3gAAgKrGWA8A50cYBwAAAADAy/jMOAAAAAAAXkYYBwAAAADAywjjAAAAAAB4GWEcqKO6d++uhISEGu3D2rVrZbPZdPjw4RrtBwAAdRXjPXDxIowDqDZdu3ZVTk6OHA5HTXcFAABUE8Z74MLwnHEA1cbHx0dOp7OmuwEAAKoR4z1wYTgzDtQBx44d03333afGjRsrLCxMzz//vMfy/Px83XfffQoMDJSfn58GDBignTt3Wsvnz5+vyy+/XB999JEiIiLk5+en22+/XceOHdOCBQvUokULBQYGauzYsSopKbFet2jRInXq1En+/v5yOp2KjY1VXl6etfzMy9ZKt/PJJ5+oTZs2aty4sfr376+cnJzqPUAAANQBjPdA3UIYB+qAv/zlL1qzZo2WLl2q1NRUrV27Vlu2bLGWx8fHa/Pmzfrggw+Unp4uY4z+8Ic/qLi42Ko5fvy4Xn75ZSUnJyslJUVr167VkCFDtGLFCq1YsUILFy7Ua6+9pn/961/Wa4qKivS3v/1NX375pZYtW6Zdu3YpPj7+nH09fvy4ZsyYoYULF+rTTz/Vnj17NGHChCo/JgAA1DWM90AdYwBc1I4cOWJ8fHxMcnKy1Xbw4EHj6+tr/vd//9d8++23RpL5z3/+Yy3/+eefja+vr3nnnXeMMcbMmzfPSDLfffedVfPggw8aPz8/c+TIEautX79+5sEHHzxrXzZt2mQkWa9Zs2aNkWTy8/PPup1//OMfJjQ09LcdBAAA6jjGe6Du4cw4cJH773//q6KiIkVFRVltQUFBioiIkCRt375d9evXV+fOna3lTZo0UUREhLZv3261+fn5qVWrVtZ8aGioWrRoocaNG3u0/fqytC+++EK33HKLmjdvLn9/f3Xv3l2StGfPnrP298zthIWFeawTAACUxXgP1D2EceAiZ4y5oOXGGNlsNmu+QYMGHsttNlu5badPn5b0y+fW+vbtq8aNG2vRokXKzMzU0qVLJf1yOdvZlLfO8+0DAACXOsZ7oO4hjAMXuauvvloNGjRQRkaG1Zafn69vv/1WktS2bVudOnVKGzdutJYfPHhQ3377rdq0aXPB2/3mm2/0888/a9q0abrpppt0zTXX8B9vAACqCeM9UPcQxoGLXOPGjTV8+HD95S9/0apVq5Sdna34+HhddtkvP96tW7fWLbfcohEjRmj9+vX68ssvNXToUDVr1ky33HLLBW/3yiuvlI+Pj2bNmqXvv/9eH3zwgf72t79V1W4BAIBfYbwH6h7COFAHPPfcc7r55ps1ePBg9e7dW7///e/VsWNHa/m8efPUsWNHxcTEKCoqSsYYrVixoswlZJXRtGlTzZ8/X++++67atm2radOmacaMGVWxOwAAoByM90DdYjN8eAMAAAAAAK/izDgAAAAAAF5GGAcAAAAAwMsI4wAAAAAAeBlhHAAAAAAALyOMAwAAAADgZYRxAAAAAAC8jDAOAAAAAICXEcYBAAAAAPAywjgAAAAAAF5GGAcAAAAAwMsI4wAAAAAAeBlhHAAAAAAAL/v/AGSxHYMya/QeAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\n", + " f\"There are {X_df['subject'].nunique()} unique subjects in the train set.\"\n", + ")\n", + "# Display the number of subject/segments for each domain\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n", + "X_df.groupby(\"domain\")['subject'].apply(lambda x: x.nunique()).plot.bar(\n", + " ax=axes[0], color=[\"C1\", \"C0\"], title=\"Number of patients per domain\"\n", + ")\n", + "X_df.groupby(\"domain\").size().plot.bar(\n", + " ax=axes[1], color=[\"C1\", \"C0\"], title=\"Number of segments per domain\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "We now look at the demographic information of the patients:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n", + "bins = np.linspace(0, 100, 21)\n", + "for i, domain in enumerate([\"v\", \"m\"]):\n", + " X_ = X_df.query(\"domain == @domain\")\n", + " X_[\"age\"].hist(\n", + " ax=axes[0], bins=bins, density=True, alpha=0.5,\n", + " label=domain, color=f\"C{i}\"\n", + " )\n", + " (X_[\"gender\"].value_counts() / len(X_)).plot(\n", + " kind=\"bar\", ax=axes[1], label=domain, alpha=0.5, color=f\"C{i}\"\n", + " )\n", + "plt.legend()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Now let's check the distribution of the target\n", + "plt.hist(y[y != -1], bins=40, density=True, alpha=0.5, label=\"v\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see here that the distribution is skewed. Indeed, the international guidelines for anesthesiologist recommend a MAP between 70 and 105 mmHg, and to avoid having hypotension during the procedure.\n", + "As this data is observational, we see that we have very few data points with a MAP below 70 mmHg, which might be a problem for the model to learn the distribution of the MAP.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we turn to the high-frequency signals contained in the data.\n", + "To avoid loading the entire dataset, we will load only the first 1000 rows of\n", + "the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[0;32m/home/tom/Work/ramp/map_estimation/problem.py\u001b[0m(46)\u001b[0;36m_load_data\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m 45 \u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mipdb\u001b[0m\u001b[0;34m;\u001b[0m \u001b[0mipdb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m---> 46 \u001b[0;31m \u001b[0mX_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_hdf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"data\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstop\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 47 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "> \u001b[0;32m/home/tom/Work/ramp/map_estimation/problem.py\u001b[0m(46)\u001b[0;36m_load_data\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m 45 \u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mipdb\u001b[0m\u001b[0;34m;\u001b[0m \u001b[0mipdb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m---> 46 \u001b[0;31m \u001b[0mX_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_hdf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"data\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstop\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 47 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
n_segsubjectagegenderdomainheightweightbmiidecgppg
0688p00075078.0Mv162.050.619.31.0[0.3688673837817671, 0.3620627421921535, 0.365...[0.40960445864963035, 0.36931866813001185, 0.3...
1688p00075078.0Mv162.050.619.31.0[0.25735809742643956, 0.23910011930527947, 0.2...[0.36706728559046503, 0.4034043141571599, 0.35...
2688p00075078.0Mv162.050.619.31.0[0.13428866369506492, 0.14334834365416743, 0.1...[0.7494333513716098, 0.8147798178151058, 0.799...
3688p00075078.0Mv162.050.619.31.0[0.17744878960204316, 0.18312116528072353, 0.2...[0.2668839934294831, 0.26939094339014175, 0.25...
4688p00075078.0Mv162.050.619.31.0[0.6703874816047055, 0.5075806829705767, 0.444...[0.27162392568169147, 0.2647447495713346, 0.24...
....................................
5639942582p02522532.0FmNaNNaNNaN2.0[0.5277368679430535, 0.5429553264604811, 0.527...[0.8159817351598173, 0.8589041095890412, 0.889...
5639952582p02522532.0FmNaNNaNNaN2.0[0.514367816091954, 0.5340038314176245, 0.5536...[0.31778290993071595, 0.3196304849884527, 0.31...
5639962582p02522532.0FmNaNNaNNaN2.0[0.33526927138331575, 0.3405491024287223, 0.34...[0.3029958285930982, 0.2684869169510808, 0.237...
5639972582p02522532.0FmNaNNaNNaN2.0[0.5840182648401827, 0.5981735159817352, 0.607...[0.25532900834105654, 0.23076923076923078, 0.2...
5639982582p02522532.0FmNaNNaNNaN2.0[0.1767180925666199, 0.0, 0.06217858812529219,...[0.8779527559055119, 0.8503937007874017, 0.825...
\n", + "

200 rows × 11 columns

\n", + "
" + ], + "text/plain": [ + " n_seg subject age gender domain height weight bmi id \\\n", + "0 688 p000750 78.0 M v 162.0 50.6 19.3 1.0 \n", + "1 688 p000750 78.0 M v 162.0 50.6 19.3 1.0 \n", + "2 688 p000750 78.0 M v 162.0 50.6 19.3 1.0 \n", + "3 688 p000750 78.0 M v 162.0 50.6 19.3 1.0 \n", + "4 688 p000750 78.0 M v 162.0 50.6 19.3 1.0 \n", + "... ... ... ... ... ... ... ... ... ... \n", + "563994 2582 p025225 32.0 F m NaN NaN NaN 2.0 \n", + "563995 2582 p025225 32.0 F m NaN NaN NaN 2.0 \n", + "563996 2582 p025225 32.0 F m NaN NaN NaN 2.0 \n", + "563997 2582 p025225 32.0 F m NaN NaN NaN 2.0 \n", + "563998 2582 p025225 32.0 F m NaN NaN NaN 2.0 \n", + "\n", + " ecg \\\n", + "0 [0.3688673837817671, 0.3620627421921535, 0.365... \n", + "1 [0.25735809742643956, 0.23910011930527947, 0.2... \n", + "2 [0.13428866369506492, 0.14334834365416743, 0.1... \n", + "3 [0.17744878960204316, 0.18312116528072353, 0.2... \n", + "4 [0.6703874816047055, 0.5075806829705767, 0.444... \n", + "... ... \n", + "563994 [0.5277368679430535, 0.5429553264604811, 0.527... \n", + "563995 [0.514367816091954, 0.5340038314176245, 0.5536... \n", + "563996 [0.33526927138331575, 0.3405491024287223, 0.34... \n", + "563997 [0.5840182648401827, 0.5981735159817352, 0.607... \n", + "563998 [0.1767180925666199, 0.0, 0.06217858812529219,... \n", + "\n", + " ppg \n", + "0 [0.40960445864963035, 0.36931866813001185, 0.3... \n", + "1 [0.36706728559046503, 0.4034043141571599, 0.35... \n", + "2 [0.7494333513716098, 0.8147798178151058, 0.799... \n", + "3 [0.2668839934294831, 0.26939094339014175, 0.25... \n", + "4 [0.27162392568169147, 0.2647447495713346, 0.24... \n", + "... ... \n", + "563994 [0.8159817351598173, 0.8589041095890412, 0.889... \n", + "563995 [0.31778290993071595, 0.3196304849884527, 0.31... \n", + "563996 [0.3029958285930982, 0.2684869169510808, 0.237... \n", + "563997 [0.25532900834105654, 0.23076923076923078, 0.2... \n", + "563998 [0.8779527559055119, 0.8503937007874017, 0.825... \n", + "\n", + "[200 rows x 11 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_v, y = problem.get_train_data(start=0, stop=100)\n", + "X_m, y_m = problem.get_train_data(start=-101, stop=-1)\n", + "X_df = pd.concat([X_v, X_m], axis=0)\n", + "y = np.concatenate([y, y_m])\n", + "\n", + "X_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The waveforms are stored as specific columns containing numpy arrays. \n", + "They contain:\n", + "- **ECG:** the electrocardiogram signal, which is a measure of the electrical activity of the heart.\n", + "- **PPG:** the photoplethysmogram signal, which is a measure of the blood volume changes in the arteries.\n", + "\n", + "We can plot them to see what they look like, and display the MAP value for each segment. \n", + "Note that in this context, we do not have access to the MAP value for the target domain `m`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(4, 2, figsize=(10, 12))\n", + "plt.subplots_adjust(hspace=0.5)\n", + "idx = np.random.choice(min(100, len(X_m), len(X_v)), size=8, replace=False)\n", + "for i, ax in enumerate(axes.ravel()):\n", + " d = \"v\" if i % 2 == 0 else \"m\"\n", + " X_, y_ = (X_v, y) if i % 2 == 0 else (X_m, y_m)\n", + "\n", + " ax.plot(X_.iloc[idx[i]]['ecg'], c=f\"C{i % 2}\")\n", + " ax.set_title(f\"Seg {idx[i]} (domain = {d}) - MAP: {y_[idx[i]]:.1f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(4, 2, figsize=(10, 12))\n", + "plt.subplots_adjust(hspace=0.5)\n", + "idx = np.random.choice(min(100, len(X_m), len(X_v)), size=8, replace=False)\n", + "for i, ax in enumerate(axes.ravel()):\n", + " d = \"v\" if i % 2 == 0 else \"m\"\n", + " X_, y_ = (X_v, y) if i % 2 == 0 else (X_m, y_m)\n", + "\n", + " ax.plot(X_.iloc[idx[i]]['ppg'], c=f\"C{i % 2}\")\n", + " ax.set_title(f\"Seg {idx[i]} (domain = {d}) - MAP: {y_[idx[i]]:.1f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Challenge evaluation\n", + "\n", + "For this challenge, the metric used to evaluate the performance of the model is the mean absolute error (MAE) between the predicted MAP and the true MAP, defined as:\n", + "\n", + "$$\n", + "MAE = \\frac{1}{n} \\sum_{i=1}^{n} |y_{pred}^i - y_{true}^i|\n", + "$$\n", + "\n", + "Here, we take the MAE over the test set, which is composed of signals coming\n", + "from domain `m`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A first model without the waveforms\n", + "\n", + "We can start by building a simple model without the waveforms to see how well we can predict the MAP from the demographic information and the low-frequency signals." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Score on train: 25.072366472232403\n", + "Score on test: 25.072366472232403\n" + ] + } + ], + "source": [ + "from sklearn.pipeline import make_pipeline\n", + "from sklearn.compose import make_column_transformer\n", + "from sklearn.preprocessing import OrdinalEncoder\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.linear_model import Ridge\n", + "\n", + "\n", + "from sklearn import set_config\n", + "set_config(transform_output=\"pandas\")\n", + "\n", + "from sklearn.metrics import mean_absolute_error\n", + "\n", + "\n", + "X_df, y = problem.get_train_data(load_waveform=False)\n", + "X_df_test, y_test = problem.get_test_data(load_waveform=False)\n", + "\n", + "\n", + "\n", + "class IgnoreAdapter(RandomForestRegressor):\n", + " def fit(self, X, y):\n", + " X = X[~y.isna()]\n", + " y = y[~y.isna()]\n", + " return super().fit(X, y)\n", + "\n", + " def predict(self, X):\n", + " return super().predict(X.drop(columns=[\"domain\"]))\n", + "\n", + "\n", + "clf = make_pipeline(\n", + " make_column_transformer(\n", + " (\"passthrough\", [\"age\"]),\n", + " (OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value=-1), [\"gender\"]),\n", + " ),\n", + " RandomForestRegressor(n_estimators=50)\n", + " # Ridge(alpha=1)\n", + ")\n", + "clf.fit(X_df, y)\n", + "print(f\"Score on train: {mean_absolute_error(clf.predict(X_df), y)}\")\n", + "print(f\"Score on test: {mean_absolute_error(clf.predict(X_df_test), y_test)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Submission format\n", + "\n", + "Here, you should describe the submission format. This is the format the participants should follow to submit their predictions on the RAMP plateform.\n", + "\n", + "This section also show how to use the `ramp-workflow` library to test the submission locally." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The pipeline workflow\n", + "\n", + "The input data are stored in a dataframe. To go from a dataframe to a numpy array we will a scikit-learn column transformer. The first example we will write will just consist in selecting a subset of columns we want to work with." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# %load submissions/starting_kit/estimator.py\n", + "\n", + "from sklearn.pipeline import make_pipeline\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.linear_model import LogisticRegression\n", + "\n", + "\n", + "def get_estimator():\n", + " pipe = make_pipeline(\n", + " StandardScaler(),\n", + " LogisticRegression()\n", + " )\n", + "\n", + " return pipe\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing using a scikit-learn pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import problem\n", + "from sklearn.model_selection import cross_val_score\n", + "\n", + "X_df, y = problem.get_train_data()\n", + "\n", + "scores = cross_val_score(get_estimator(), X_df, y, cv=5, scoring='accuracy')\n", + "print(scores)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Submission\n", + "\n", + "To submit your code, you can refer to the [online documentation](https://paris-saclay-cds.github.io/ramp-docs/ramp-workflow/stable/using_kits.html)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.12.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/problem.py b/problem.py index 9cb2cbd..2401c8a 100644 --- a/problem.py +++ b/problem.py @@ -1,48 +1,98 @@ import rampwf as rw +import os +import h5py +import numpy as np import pandas as pd from pathlib import Path -from sklearn.model_selection import StratifiedShuffleSplit +from sklearn.model_selection import GroupShuffleSplit -problem_title = 'Template RAMP kit to create data challenges' - -_prediction_label_names = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +problem_title = 'MAP estimation from non-invasive monitoring' # A type (class) which will be used to create wrapper objects for y_pred -Predictions = rw.prediction_types.make_multiclass( - label_names=_prediction_label_names -) +Predictions = rw.prediction_types.make_regression() # An object implementing the workflow workflow = rw.workflows.Estimator() + +class MAE(rw.score_types.BaseScoreType): + is_lower_the_better = True + minimum = 0.0 + maximum = float('inf') + + def __init__(self, name='mae', precision=4): + self.name = name + self.precision = precision + + def __call__(self, y_true, y_pred): + mask = y_true != -1 + return np.mean(np.abs((y_true - y_pred)[mask])) + + score_types = [ - rw.score_types.Accuracy(name='accuracy', precision=4), + MAE(name='mean_absolute_error', precision=5), ] def get_cv(X, y): - cv = StratifiedShuffleSplit(n_splits=8, test_size=0.2, random_state=57) - return cv.split(X, y) + cv = GroupShuffleSplit(n_splits=1, test_size=1, random_state=37298) + return cv.split(X, y, groups=X["subject"]) -def load_data(path='.', file='X_train.csv'): - path = Path(path) / "data" - X_df = pd.read_csv(path / file) +def _load_data(file, start=None, stop=None, load_waveform=True): + X_df = pd.read_hdf(file, key="data", start=start, stop=stop) - y = X_df['target'] - X_df = X_df.drop(columns=['target']) + y = X_df['map'] + X_df = X_df.drop(columns=['map', 'sbp', 'dbp'], errors='ignore') - return X_df, y + if load_waveform: + with h5py.File(file, 'r') as f: + X_df['ecg'] = list(f['ecg'][start:stop]) + X_df['ppg'] = list(f['ppg'][start:stop]) + # Replace None value in y by `-1 + y = y.fillna(-1).values -# READ DATA -def get_train_data(path='.'): - file = 'X_train.csv' - return load_data(path, file) + return X_df, y -def get_test_data(path='.'): - file = 'X_test.csv' - return load_data(path, file) +# READ DATA +def get_train_data(path='.', start=None, stop=None, load_waveform=True): + + # Avoid loading the data if it is already loaded + # We use a global variable in rw as the problem.py module is created + # dynamically and the global variables are not always reused. + hash_train = hash((str(path), start, stop, load_waveform)) + if getattr(rw, "HASH_TRAIN", -1) == hash_train: + return rw.X_TRAIN, rw.Y_TRAIN + + rw.HASH_TRAIN = hash_train + + file = 'train.h5' + file = Path(path) / "data" / file + if os.environ.get("RAMP_TEST_MODE", False): + X_v, y_v = _load_data(file, 0, 1000, load_waveform=load_waveform) + X_m, y_m = _load_data(file, -1001, -1, load_waveform=load_waveform) + rw.X_TRAIN = pd.concat([X_v, X_m], axis=0) + rw.Y_TRAIN = np.concatenate([y_v, y_m], axis=0) + else: + rw.X_TRAIN, rw.Y_TRAIN = _load_data(file, start, stop, load_waveform) + return rw.X_TRAIN, rw.Y_TRAIN + + +def get_test_data(path='.', start=None, stop=None, load_waveform=True): + + hash_test = hash((str(path), start, stop, load_waveform)) + if getattr(rw, "HASH_TEST", -1) == hash_test: + return rw.X_TRAIN, rw.Y_TRAIN + + rw.HASH_TEST = hash_test + + file = 'test.h5' + file = Path(path) / "data" / file + if os.environ.get("RAMP_TEST_MODE", False): + start, stop = 0, 100 + rw.X_TEST, rw.Y_TEST = _load_data(file, start, stop, load_waveform) + return rw.X_TEST, rw.Y_TEST diff --git a/requirements.txt b/requirements.txt index a74e3a2..83d63af 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,3 +3,5 @@ numpy pandas matplotlib scikit-learn +physiocurve +pytables diff --git a/submissions/starting_kit/estimator.py b/submissions/starting_kit/estimator.py index 2d787a3..d9a3c4b 100644 --- a/submissions/starting_kit/estimator.py +++ b/submissions/starting_kit/estimator.py @@ -1,13 +1,27 @@ - +from sklearn import set_config from sklearn.pipeline import make_pipeline -from sklearn.preprocessing import StandardScaler -from sklearn.linear_model import LogisticRegression +from sklearn.compose import make_column_transformer +from sklearn.ensemble import RandomForestRegressor +from sklearn.preprocessing import OrdinalEncoder + +set_config(transform_output="pandas") + + +class IgnoreDomain(RandomForestRegressor): + def fit(self, X, y): + # Ignore the samples with missing target + X = X[y != -1] + y = y[y != -1] + return super().fit(X, y) def get_estimator(): - pipe = make_pipeline( - StandardScaler(), - LogisticRegression() + return make_pipeline( + make_column_transformer( + ("passthrough", ["age"]), + (OrdinalEncoder( + handle_unknown='use_encoded_value', unknown_value=-1 + ), ["gender"]), + ), + IgnoreDomain(n_estimators=50) ) - - return pipe diff --git a/template_starting_kit.ipynb b/template_starting_kit.ipynb deleted file mode 100644 index c0cc708..0000000 --- a/template_starting_kit.ipynb +++ /dev/null @@ -1,169 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
\n", - " \n", - " \n", - "
\n", - "\n", - "# Template Kit for RAMP challenge\n", - "\n", - " Thomas Moreau (Inria) " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Introduction\n", - "\n", - "Describe the challenge, in particular:\n", - "\n", - "- Where the data comes from?\n", - "- What is the task this challenge aims to solve?\n", - "- Why does it matter?" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exploratory data analysis\n", - "\n", - "The goal of this section is to show what's in the data, and how to play with it.\n", - "This is the first set in any data science project, and here, you should give a sense of the data the participants will be working with.\n", - "\n", - "You can first load and describe the data, and then show some interesting properties of it." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "pd.set_option('display.max_columns', None)\n", - "\n", - "# Load the data\n", - "\n", - "import problem\n", - "X_df, y = problem.get_train_data()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Challenge evaluation\n", - "\n", - "A particularly important point in a challenge is to describe how it is evaluated. This is the section where you should describe the metric that will be used to evaluate the participants' submissions, as well as your evaluation strategy, in particular if there is some complexity in the way the data should be split to ensure valid results." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Submission format\n", - "\n", - "Here, you should describe the submission format. This is the format the participants should follow to submit their predictions on the RAMP plateform.\n", - "\n", - "This section also show how to use the `ramp-workflow` library to test the submission locally." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## The pipeline workflow\n", - "\n", - "The input data are stored in a dataframe. To go from a dataframe to a numpy array we will use a scikit-learn column transformer. The first example we will write will just consist in selecting a subset of columns we want to work with." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# %load submissions/starting_kit/estimator.py\n", - "\n", - "from sklearn.pipeline import make_pipeline\n", - "from sklearn.preprocessing import StandardScaler\n", - "from sklearn.linear_model import LogisticRegression\n", - "\n", - "\n", - "def get_estimator():\n", - " pipe = make_pipeline(\n", - " StandardScaler(),\n", - " LogisticRegression()\n", - " )\n", - "\n", - " return pipe\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Testing using a scikit-learn pipeline" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0.97222222 0.96527778 0.97212544 0.95121951 0.96167247]\n" - ] - } - ], - "source": [ - "from sklearn.model_selection import cross_val_score\n", - "\n", - "scores = cross_val_score(get_estimator(), X_df, y, cv=5, scoring='accuracy')\n", - "print(scores)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Submission\n", - "\n", - "To submit your code, you can refer to the [online documentation](https://paris-saclay-cds.github.io/ramp-docs/ramp-workflow/stable/using_kits.html)." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "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.12.6" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -}