From 1d573dfb3fa069c6389fa8a943bbc36aecf1c284 Mon Sep 17 00:00:00 2001 From: batukav Date: Fri, 6 Jun 2025 16:03:09 +0200 Subject: [PATCH 01/17] initial commit for the scaffold splitting functionality --- scikit_mol/conversions.py | 71 ++++ .../notebooks/scaffold_split_planning.ipynb | 307 ++++++++++++++++++ 2 files changed, 378 insertions(+) create mode 100644 scikit_mol/notebooks/scaffold_split_planning.ipynb diff --git a/scikit_mol/conversions.py b/scikit_mol/conversions.py index fbfbbdb..ee3cd32 100644 --- a/scikit_mol/conversions.py +++ b/scikit_mol/conversions.py @@ -1,11 +1,14 @@ from collections.abc import Sequence from typing import Optional, Union +from types import ModuleType +import rdkit import numpy as np from numpy.typing import NDArray from rdkit import Chem from rdkit.rdBase import BlockLogs from sklearn.base import BaseEstimator, TransformerMixin +from rdkit.Chem.Scaffolds import MurckoScaffold from scikit_mol._constants import DOCS_BASE_URL from scikit_mol.core import ( @@ -127,3 +130,71 @@ def inverse_transform(self, X_mols_list, y=None): raise ValueError(f"Invalid Mols found: {fails}.") return np.array(X_out).reshape(-1, 1) + + +class MolToScaffoldTransformer(SmilesToMolTransformer): + """ + Transformer for converting SMILES strings to molecular scaffolds. + First converts SMILES to RDKit mol objects, then extracts the scaffold. + """ + + def __init__( + self, + n_jobs: Optional[None] = None, + safe_inference_mode: bool = False, + scaffold_transformer: ModuleType = MurckoScaffold, + ): + super().__init__(n_jobs, safe_inference_mode) + self.scaffold_transformer = scaffold_transformer + + # Question: How generic should be the scaffold transformer? + # For now, just for demonstration I'm using the MurckoScaffold class + + def transform( + self, X_smiles_list: Sequence[str] + ) -> NDArray[Union[Chem.Mol, InvalidMol]]: + # First step: convert SMILES to molecules using parent class + mols = super().transform(X_smiles_list, y=None).flatten() + + self.mols = mols # to be deleted + # Second step: convert molecules to scaffolds + scaffolds = ( + [] + ) # TODO: this will be very slow for large datasets, improve efficiency via initializing list + for mol in mols: + if isinstance(mol, Chem.Mol): + try: + scaffold = self.scaffold_transformer.GetScaffoldForMol(mol) + scaffolds.append(scaffold) + except Exception as e: + scaffolds.append( + InvalidMol(str(self), f"Error creating scaffold: {e}") + ) + else: + scaffolds.append(mol) # Keep InvalidMol objects as is + + self.scaffolds = np.array(scaffolds).reshape(-1, 1).flatten() + return np.array(scaffolds).reshape(-1, 1) + + def get_unique_scaffold_ids(self) -> NDArray[np.int_]: + + scaffold_smiles = self._create_smiles_from_mol() + # Get unique labels + _, labels = np.unique(scaffold_smiles, return_inverse=True) + + return labels + + def _create_smiles_from_mol(self): + + if type(self.scaffolds) == rdkit.Chem.rdchem.Mol: + return Chem.MolToSmiles(self.scaffolds) + elif type(self.scaffolds) == np.ndarray: + scaffold_smiles = [] + for scaffold in self.scaffolds: + scaffold_smiles.append(Chem.MolToSmiles(scaffold)) + + return scaffold_smiles + else: + raise RuntimeError("Unknown data type ") + # Keep scaffold_smiles ?? + # self.scaffold_smiles = scaffold_smiles diff --git a/scikit_mol/notebooks/scaffold_split_planning.ipynb b/scikit_mol/notebooks/scaffold_split_planning.ipynb new file mode 100644 index 0000000..b045c0f --- /dev/null +++ b/scikit_mol/notebooks/scaffold_split_planning.ipynb @@ -0,0 +1,307 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# import the usual suspects\n", + "import os\n", + "import rdkit\n", + "from rdkit import Chem\n", + "import pandas as pd\n", + "from time import time\n", + "import numpy as np\n", + "import sys\n", + "sys.path.append('..')\n", + "from conversions import MolToScaffoldTransformer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "## import dataset ##" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "csv_file = \"../../tests/data/SLC6A4_active_excapedb_subset.csv\"\n", + "data = pd.read_csv(csv_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "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", + "
Ambit_InchiKeySMILESpXC50
0RBCQCVSMIQCOMN-PCQZLOAONA-NC12C([C@@H](OC(C=3C=CC(=CC3)F)C=4C=CC(=CC4)F)C...6.26000
1ALZTYVXVRZIERJ-UHFFFAOYNA-NO(C1=NC=C2C(CN(CC2=C1)C)C3=CC=C(OC)C=C3)CCCN(C...7.18046
2MOEMPBAHOJKXBG-MRXNPFEDNA-NO=S(=O)(N(CC=1C=CC2=CC=CC=C2C1)[C@@H]3CCNC3)C7.77000
3HEKGBDCRHYILPL-QWOVJGMINA-NC1(=C2C(CCCC2O)=NC=3C1=CC=CC3)NCC=4C=CC(=CC4)Cl5.24000
4SNNRWIBSGBMYRF-UKRRQHHQNA-NC1NC[C@@H](C1)[C@H](OC=2C=CC(=NC2C)OC)CC(C)C9.12000
\n", + "
" + ], + "text/plain": [ + " Ambit_InchiKey \\\n", + "0 RBCQCVSMIQCOMN-PCQZLOAONA-N \n", + "1 ALZTYVXVRZIERJ-UHFFFAOYNA-N \n", + "2 MOEMPBAHOJKXBG-MRXNPFEDNA-N \n", + "3 HEKGBDCRHYILPL-QWOVJGMINA-N \n", + "4 SNNRWIBSGBMYRF-UKRRQHHQNA-N \n", + "\n", + " SMILES pXC50 \n", + "0 C12C([C@@H](OC(C=3C=CC(=CC3)F)C=4C=CC(=CC4)F)C... 6.26000 \n", + "1 O(C1=NC=C2C(CN(CC2=C1)C)C3=CC=C(OC)C=C3)CCCN(C... 7.18046 \n", + "2 O=S(=O)(N(CC=1C=CC2=CC=CC=C2C1)[C@@H]3CCNC3)C 7.77000 \n", + "3 C1(=C2C(CCCC2O)=NC=3C1=CC=CC3)NCC=4C=CC(=CC4)Cl 5.24000 \n", + "4 C1NC[C@@H](C1)[C@H](OC=2C=CC(=NC2C)OC)CC(C)C 9.12000 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "transformer = MolToScaffoldTransformer()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "mols = transformer.transform(data['SMILES'])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "data['scaffolds'] = mols.reshape(len(mols))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "transformer.scaffolds[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "data['scaffold_smiles'] = transformer._create_smiles_from_mol()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "data['scaffold_ids'] = transformer.get_unique_scaffold_ids()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 86\n", + "1 78\n", + "2 153\n", + "3 102\n", + "4 158\n", + "Name: scaffold_ids, dtype: int64" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['scaffold_ids'].head()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "161" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(data['scaffold_ids'].unique())" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1\n", + "1 c1ccc(C2CNCc3ccncc32)cc1\n", + "2 c1ccc2cc(CN[C@@H]3CCNC3)ccc2c1\n", + "3 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", + "4 c1cncc(OC[C@@H]2CCNC2)c1\n", + " ... \n", + "195 c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1\n", + "196 c1ccc(OC(c2ccccc2)C2CCCNC2)cc1\n", + "197 c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CC...\n", + "198 c1ccc(C2[C@H]3CNC[C@@H]23)cc1\n", + "199 c1ccc(C(c2ccccc2)c2ccncc2)cc1\n", + "Name: scaffold_smiles, Length: 200, dtype: object" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['scaffold_smiles']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "scikit_mol", + "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.13.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 7feae9625ee88966b27acae6bbb2ffad02d2dc8c Mon Sep 17 00:00:00 2001 From: batukav Date: Fri, 6 Jun 2025 16:14:09 +0200 Subject: [PATCH 02/17] add example for the GroupShuffleSplit --- .../notebooks/scaffold_split_planning.ipynb | 73 +++++++++++++------ 1 file changed, 49 insertions(+), 24 deletions(-) diff --git a/scikit_mol/notebooks/scaffold_split_planning.ipynb b/scikit_mol/notebooks/scaffold_split_planning.ipynb index b045c0f..e7bea22 100644 --- a/scikit_mol/notebooks/scaffold_split_planning.ipynb +++ b/scikit_mol/notebooks/scaffold_split_planning.ipynb @@ -24,10 +24,8 @@ "source": [] }, { - "cell_type": "code", - "execution_count": 2, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ "## import dataset ##" ] @@ -160,27 +158,6 @@ "data['scaffolds'] = mols.reshape(len(mols))" ] }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "transformer.scaffolds[0]" - ] - }, { "cell_type": "code", "execution_count": 9, @@ -275,6 +252,54 @@ "data['scaffold_smiles']" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "## scaffold split ##" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection._split import GroupShuffleSplit\n", + "\n", + "# Question: \n", + "X = data['Ambit_InchiKey']\n", + "y = data['SMILES'] # some random label, does not matter\n", + "groups = data['scaffold_smiles']\n", + "gss = GroupShuffleSplit(n_splits=1, test_size=0.2, random_state=42)\n", + "train_idx, test_idx = next(gss.split(X, y, groups=groups))\n", + "\n", + "X_train, X_test = X[train_idx], X[test_idx]\n", + "y_train, y_test = y[train_idx], y[test_idx]" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "set()" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "set(groups[train_idx]).intersection(set(groups[test_idx]))" + ] + }, { "cell_type": "code", "execution_count": null, From 76ec0fcaba99b0fac98e32d447affa6f6f00a380 Mon Sep 17 00:00:00 2001 From: Batuhan Kav Date: Mon, 7 Jul 2025 15:19:09 +0200 Subject: [PATCH 03/17] update gitignore to ignore windsurf rules file --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index 62293e8..132073c 100644 --- a/.gitignore +++ b/.gitignore @@ -142,3 +142,6 @@ sandbox/ # PyCharm settings .idea + +# Windsurf +.windsurfrules From 1203fe52133e0fcda90935b888010ed125ba2ae9 Mon Sep 17 00:00:00 2001 From: Batuhan Kav Date: Mon, 7 Jul 2025 15:21:55 +0200 Subject: [PATCH 04/17] A working example of the StratifiedGroupShuffleSplit for the scikit-mol. After the review is complete, I'll continue with the proper implementation --- .../notebooks/scaffold_split_planning.ipynb | 1427 ++++++++++++++++- 1 file changed, 1405 insertions(+), 22 deletions(-) diff --git a/scikit_mol/notebooks/scaffold_split_planning.ipynb b/scikit_mol/notebooks/scaffold_split_planning.ipynb index e7bea22..f486f82 100644 --- a/scikit_mol/notebooks/scaffold_split_planning.ipynb +++ b/scikit_mol/notebooks/scaffold_split_planning.ipynb @@ -15,7 +15,9 @@ "import numpy as np\n", "import sys\n", "sys.path.append('..')\n", - "from conversions import MolToScaffoldTransformer" + "from conversions import MolToScaffoldTransformer\n", + "import matplotlib.pyplot as plt\n", + "import time" ] }, { @@ -27,12 +29,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## import dataset ##" + "# Scaffold split planning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## personal notes/tests to understand the concepts ##" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### import dataset ###" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -42,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -122,7 +138,7 @@ "4 C1NC[C@@H](C1)[C@H](OC=2C=CC(=NC2C)OC)CC(C)C 9.12000 " ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -133,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -142,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -151,7 +167,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -160,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -169,7 +185,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -178,7 +194,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -192,7 +208,7 @@ "Name: scaffold_ids, dtype: int64" ] }, - "execution_count": 11, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -203,7 +219,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -212,7 +228,7 @@ "161" ] }, - "execution_count": 16, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -223,7 +239,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -243,7 +259,7 @@ "Name: scaffold_smiles, Length: 200, dtype: object" ] }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -254,7 +270,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -263,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -282,7 +298,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -291,7 +307,7 @@ "set()" ] }, - "execution_count": 21, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -300,6 +316,1373 @@ "set(groups[train_idx]).intersection(set(groups[test_idx]))" ] }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Do we need another train_test_split function? \n", + "# seems like there's a discussion here\n", + "# https://github.com/scikit-learn/scikit-learn/issues/9193" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import StratifiedGroupKFold, BaseCrossValidator, GroupShuffleSplit,StratifiedShuffleSplit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### train_test_split example ####" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "train_inds, test_inds = next(GroupShuffleSplit().split(X, y, groups))\n", + "X_train, X_test, y_train, y_test = X[train_inds], X[test_inds], y[train_inds], y[test_inds]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 RBCQCVSMIQCOMN-PCQZLOAONA-N\n", + "2 MOEMPBAHOJKXBG-MRXNPFEDNA-N\n", + "3 HEKGBDCRHYILPL-QWOVJGMINA-N\n", + "4 SNNRWIBSGBMYRF-UKRRQHHQNA-N\n", + "5 UZCRUMOKTIFCRO-UHFFFAOYNA-N\n", + " ... \n", + "195 PIKWEFAACQLYMF-UHFFFAOYNA-N\n", + "196 AUZWJAMWJZUPHQ-UHFFFAOYNA-N\n", + "197 JCEWQICHOLLRDL-WUFINQPMNA-N\n", + "198 NGRIUVQYFBDXMT-JYAVWHMHNA-N\n", + "199 ZWLWOTHDIGRTNE-UHFFFAOYNA-N\n", + "Name: Ambit_InchiKey, Length: 157, dtype: object" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 C12C([C@@H](OC(C=3C=CC(=CC3)F)C=4C=CC(=CC4)F)C...\n", + "2 O=S(=O)(N(CC=1C=CC2=CC=CC=C2C1)[C@@H]3CCNC3)C\n", + "3 C1(=C2C(CCCC2O)=NC=3C1=CC=CC3)NCC=4C=CC(=CC4)Cl\n", + "4 C1NC[C@@H](C1)[C@H](OC=2C=CC(=NC2C)OC)CC(C)C\n", + "5 FC(F)(F)C=1C(CN(C2CCNCC2)CC(CC)CC)=CC=CC1\n", + " ... \n", + "195 C1=CC=C2C=CC(=CC2=C1)C(N3N=NC(=N3)C=4C=CC=CC4)...\n", + "196 C(OC1=CC=C(C=C1)Cl)(C=2C=CC(=CC2)F)C3CNCCC3\n", + "197 O(C1=CC=2[C@@H]3N(C[C@H](C2C=C1)C4=CC=C(N5N=CC...\n", + "198 C1NC[C@@H]2[C@H]1[C@@]2(CCOCC)C3=CC(=C(C=C3)Cl)Cl\n", + "199 C(C1=CC=NC=C1)(C2=CC=CC=C2)C3=CC=CC=C3\n", + "Name: SMILES, Length: 157, dtype: object" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_train" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "set()" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "set(groups[train_inds]).intersection(set(groups[test_inds]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### stratifiedgroupkfold ####" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "X = data['Ambit_InchiKey']\n", + "y = data['pXC50'].astype(int) # some random label, does not matter\n", + "groups = data['scaffold_smiles']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fold 0:\n", + "Train: index=\n", + "[ 0 2 3 5 6 8 9 11 13 14 15 20 22 24 25 27 31 32\n", + " 33 34 35 36 38 39 40 41 43 44 46 47 48 51 52 53 54 55\n", + " 56 57 59 60 62 63 65 66 67 68 69 72 74 75 76 79 80 82\n", + " 83 84 85 86 87 88 90 92 93 95 97 98 99 102 103 104 105 106\n", + " 107 108 109 110 111 112 113 114 115 116 117 119 120 121 122 123 124 125\n", + " 128 129 130 131 133 137 139 142 143 144 145 148 149 150 151 152 153 154\n", + " 156 158 161 163 164 166 167 168 169 170 172 173 174 175 176 177 180 182\n", + " 184 188 189 190 191 192 193 194 197 198]\n", + "group=\n", + "0 c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1\n", + "2 c1ccc2cc(CN[C@@H]3CCNC3)ccc2c1\n", + "3 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", + "5 c1ccc(CNC2CCNCC2)cc1\n", + "6 c1ccc(C2(COCc3ccccn3)CCNCC2)cc1\n", + " ... \n", + "192 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", + "193 c1ccc(Oc2ncccc2C2CCNCC2)cc1\n", + "194 c1ccc(Oc2ccccc2)cc1\n", + "197 c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CC...\n", + "198 c1ccc(C2[C@H]3CNC[C@@H]23)cc1\n", + "Name: scaffold_smiles, Length: 136, dtype: object\n", + "Test: index=\n", + "[ 1 4 7 10 12 16 17 18 19 21 23 26 28 29 30 37 42 45\n", + " 49 50 58 61 64 70 71 73 77 78 81 89 91 94 96 100 101 118\n", + " 126 127 132 134 135 136 138 140 141 146 147 155 157 159 160 162 165 171\n", + " 178 179 181 183 185 186 187 195 196 199]\n", + "group=\n", + "1 c1ccc(C2CNCc3ccncc32)cc1\n", + "4 c1cncc(OC[C@@H]2CCNC2)c1\n", + "7 c1ccc(CN2CCC(CCOC(c3ccccc3)c3ccccc3)CC2)cc1\n", + "10 c1ccc(-c2ccccc2CCCN2CCN(CC(c3ccccc3)N3CCNCC3)C...\n", + "12 C(=C/c1ccsc1)\\CN1CCN(C[C@@H]2ON=C3c4ccccc4OC[C...\n", + " ... \n", + "186 c1ccc(Oc2ccc3c(c2)CCS3)cc1\n", + "187 c1ccc([C@@H]2C[C@H]3CCC(N3)[C@@H]2c2ccccc2)cc1\n", + "195 c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1\n", + "196 c1ccc(OC(c2ccccc2)C2CCCNC2)cc1\n", + "199 c1ccc(C(c2ccccc2)c2ccncc2)cc1\n", + "Name: scaffold_smiles, Length: 64, dtype: object\n", + "Fold 1:\n", + "Train: index=\n", + "[ 0 1 3 4 5 6 7 8 9 10 12 13 14 15 16 17 18 19\n", + " 20 21 22 23 25 26 28 29 30 35 37 39 40 41 42 43 45 47\n", + " 49 50 52 53 54 55 56 57 58 59 61 64 69 70 71 72 73 74\n", + " 75 77 78 79 81 85 86 89 90 91 93 94 95 96 99 100 101 102\n", + " 103 104 106 108 114 115 118 119 120 122 123 126 127 128 129 130 131 132\n", + " 134 135 136 138 139 140 141 145 146 147 148 149 151 153 155 156 157 159\n", + " 160 162 165 166 170 171 176 177 178 179 180 181 183 185 186 187 189 190\n", + " 192 195 196 197 198 199]\n", + "group=\n", + "0 c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1\n", + "1 c1ccc(C2CNCc3ccncc32)cc1\n", + "3 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", + "4 c1cncc(OC[C@@H]2CCNC2)c1\n", + "5 c1ccc(CNC2CCNCC2)cc1\n", + " ... \n", + "195 c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1\n", + "196 c1ccc(OC(c2ccccc2)C2CCCNC2)cc1\n", + "197 c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CC...\n", + "198 c1ccc(C2[C@H]3CNC[C@@H]23)cc1\n", + "199 c1ccc(C(c2ccccc2)c2ccncc2)cc1\n", + "Name: scaffold_smiles, Length: 132, dtype: object\n", + "Test: index=\n", + "[ 2 11 24 27 31 32 33 34 36 38 44 46 48 51 60 62 63 65\n", + " 66 67 68 76 80 82 83 84 87 88 92 97 98 105 107 109 110 111\n", + " 112 113 116 117 121 124 125 133 137 142 143 144 150 152 154 158 161 163\n", + " 164 167 168 169 172 173 174 175 182 184 188 191 193 194]\n", + "group=\n", + "2 c1ccc2cc(CN[C@@H]3CCNC3)ccc2c1\n", + "11 c1ccc([C@H]2CC3CCC2CC3)cc1\n", + "24 c1ccc(CCCN2CCN(CCCN(c3ccccc3)c3ccccc3)CC2)cc1\n", + "27 c1ccc(CCN[C@H]2CC[C@@H](c3c[nH]c4ccccc43)CC2)cc1\n", + "31 c1ccc(C2OCc3ccccc32)cc1\n", + " ... \n", + "184 O=C(/C=C/c1ccccc1)N1CCN(CCOC(c2ccccc2)c2ccccc2...\n", + "188 c1ccc(CN2CCC(c3ccccc3)CC2)cc1\n", + "191 c1ccc2c(c1)CC(NCCCCn1ccc3ccccc31)CO2\n", + "193 c1ccc(Oc2ncccc2C2CCNCC2)cc1\n", + "194 c1ccc(Oc2ccccc2)cc1\n", + "Name: scaffold_smiles, Length: 68, dtype: object\n", + "Fold 2:\n", + "Train: index=\n", + "[ 1 2 4 7 10 11 12 16 17 18 19 21 23 24 26 27 28 29\n", + " 30 31 32 33 34 36 37 38 42 44 45 46 48 49 50 51 58 60\n", + " 61 62 63 64 65 66 67 68 70 71 73 76 77 78 80 81 82 83\n", + " 84 87 88 89 91 92 94 96 97 98 100 101 105 107 109 110 111 112\n", + " 113 116 117 118 121 124 125 126 127 132 133 134 135 136 137 138 140 141\n", + " 142 143 144 146 147 150 152 154 155 157 158 159 160 161 162 163 164 165\n", + " 167 168 169 171 172 173 174 175 178 179 181 182 183 184 185 186 187 188\n", + " 191 193 194 195 196 199]\n", + "group=\n", + "1 c1ccc(C2CNCc3ccncc32)cc1\n", + "2 c1ccc2cc(CN[C@@H]3CCNC3)ccc2c1\n", + "4 c1cncc(OC[C@@H]2CCNC2)c1\n", + "7 c1ccc(CN2CCC(CCOC(c3ccccc3)c3ccccc3)CC2)cc1\n", + "10 c1ccc(-c2ccccc2CCCN2CCN(CC(c3ccccc3)N3CCNCC3)C...\n", + " ... \n", + "193 c1ccc(Oc2ncccc2C2CCNCC2)cc1\n", + "194 c1ccc(Oc2ccccc2)cc1\n", + "195 c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1\n", + "196 c1ccc(OC(c2ccccc2)C2CCCNC2)cc1\n", + "199 c1ccc(C(c2ccccc2)c2ccncc2)cc1\n", + "Name: scaffold_smiles, Length: 132, dtype: object\n", + "Test: index=\n", + "[ 0 3 5 6 8 9 13 14 15 20 22 25 35 39 40 41 43 47\n", + " 52 53 54 55 56 57 59 69 72 74 75 79 85 86 90 93 95 99\n", + " 102 103 104 106 108 114 115 119 120 122 123 128 129 130 131 139 145 148\n", + " 149 151 153 156 166 170 176 177 180 189 190 192 197 198]\n", + "group=\n", + "0 c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1\n", + "3 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", + "5 c1ccc(CNC2CCNCC2)cc1\n", + "6 c1ccc(C2(COCc3ccccn3)CCNCC2)cc1\n", + "8 c1ccc2c(N3CCN(CCCc4csc5ccccc45)CC3)cccc2c1\n", + " ... \n", + "189 c1ccc2c(CCCN3CCN(CCCc4c[nH]c5ccccc45)CC3)c[nH]...\n", + "190 c1ccc2sc(C3CCN(CCCOc4cccc5occc45)CC3)cc2c1\n", + "192 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", + "197 c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CC...\n", + "198 c1ccc(C2[C@H]3CNC[C@@H]23)cc1\n", + "Name: scaffold_smiles, Length: 68, dtype: object\n" + ] + } + ], + "source": [ + "sgkf = StratifiedGroupKFold(n_splits=3, shuffle=True, random_state=42)\n", + "for i, (train_index, test_index) in enumerate(sgkf.split(X, y, groups)):\n", + "\n", + " print(f\"Fold {i}:\")\n", + " print(f\"Train: index=\\n{train_index}\")\n", + " print(f\"group=\\n{groups[train_index]}\")\n", + " print(f\"Test: index=\\n{test_index}\")\n", + " print(f\"group=\\n{groups[test_index]}\")\n", + " assert(len(set(groups[train_index]).intersection(set(groups[test_index]))) == 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fold 0:\n", + "Train: index=\n", + "[ 0 1 3 5 6 8 9 11 12 15 16 17 19 20 21 23 26 27\n", + " 28 29 30 31 34 35 39 40 43 46 47 48 49 51 52 53 56 57\n", + " 59 60 61 62 63 64 65 68 71 72 73 74 75 76 77 78 79 80\n", + " 81 82 83 84 85 88 89 91 93 94 95 96 97 99 101 103 105 108\n", + " 109 110 114 115 116 118 119 121 122 123 124 126 129 131 132 133 134 135\n", + " 136 137 139 140 141 143 144 145 146 147 148 149 150 151 152 153 156 157\n", + " 159 160 162 163 164 165 166 167 169 171 172 173 174 176 177 178 180 186\n", + " 187 190 192 193 195 197 198]\n", + "group=\n", + "0 c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1\n", + "1 c1ccc(C2CNCc3ccncc32)cc1\n", + "3 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", + "5 c1ccc(CNC2CCNCC2)cc1\n", + "6 c1ccc(C2(COCc3ccccn3)CCNCC2)cc1\n", + " ... \n", + "192 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", + "193 c1ccc(Oc2ncccc2C2CCNCC2)cc1\n", + "195 c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1\n", + "197 c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CC...\n", + "198 c1ccc(C2[C@H]3CNC[C@@H]23)cc1\n", + "Name: scaffold_smiles, Length: 133, dtype: object\n", + "Test: index=\n", + "[ 2 4 7 10 13 14 18 22 24 25 32 33 36 37 38 41 42 44\n", + " 45 50 54 55 58 66 67 69 70 86 87 90 92 98 100 102 104 106\n", + " 107 111 112 113 117 120 125 127 128 130 138 142 154 155 158 161 168 170\n", + " 175 179 181 182 183 184 185 188 189 191 194 196 199]\n", + "group=\n", + "2 c1ccc2cc(CN[C@@H]3CCNC3)ccc2c1\n", + "4 c1cncc(OC[C@@H]2CCNC2)c1\n", + "7 c1ccc(CN2CCC(CCOC(c3ccccc3)c3ccccc3)CC2)cc1\n", + "10 c1ccc(-c2ccccc2CCCN2CCN(CC(c3ccccc3)N3CCNCC3)C...\n", + "13 c1ccc2c(c1)CCNC2CCc1c[nH]c2ccccc12\n", + " ... \n", + "189 c1ccc2c(CCCN3CCN(CCCc4c[nH]c5ccccc45)CC3)c[nH]...\n", + "191 c1ccc2c(c1)CC(NCCCCn1ccc3ccccc31)CO2\n", + "194 c1ccc(Oc2ccccc2)cc1\n", + "196 c1ccc(OC(c2ccccc2)C2CCCNC2)cc1\n", + "199 c1ccc(C(c2ccccc2)c2ccncc2)cc1\n", + "Name: scaffold_smiles, Length: 67, dtype: object\n", + "Fold 1:\n", + "Train: index=\n", + "[ 0 2 3 4 6 7 9 10 11 12 13 14 17 18 19 21 22 23\n", + " 24 25 26 28 29 31 32 33 34 36 37 38 40 41 42 44 45 47\n", + " 48 49 50 51 52 54 55 56 58 60 63 64 65 66 67 68 69 70\n", + " 71 75 78 79 80 81 85 86 87 90 92 98 99 100 102 104 106 107\n", + " 108 109 110 111 112 113 114 117 118 119 120 122 123 124 125 127 128 130\n", + " 132 134 135 138 139 141 142 143 144 145 146 147 148 150 154 155 158 159\n", + " 161 166 167 168 170 174 175 177 179 180 181 182 183 184 185 186 187 188\n", + " 189 191 192 194 195 196 197 199]\n", + "group=\n", + "0 c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1\n", + "2 c1ccc2cc(CN[C@@H]3CCNC3)ccc2c1\n", + "3 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", + "4 c1cncc(OC[C@@H]2CCNC2)c1\n", + "6 c1ccc(C2(COCc3ccccn3)CCNCC2)cc1\n", + " ... \n", + "194 c1ccc(Oc2ccccc2)cc1\n", + "195 c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1\n", + "196 c1ccc(OC(c2ccccc2)C2CCCNC2)cc1\n", + "197 c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CC...\n", + "199 c1ccc(C(c2ccccc2)c2ccncc2)cc1\n", + "Name: scaffold_smiles, Length: 134, dtype: object\n", + "Test: index=\n", + "[ 1 5 8 15 16 20 27 30 35 39 43 46 53 57 59 61 62 72\n", + " 73 74 76 77 82 83 84 88 89 91 93 94 95 96 97 101 103 105\n", + " 115 116 121 126 129 131 133 136 137 140 149 151 152 153 156 157 160 162\n", + " 163 164 165 169 171 172 173 176 178 190 193 198]\n", + "group=\n", + "1 c1ccc(C2CNCc3ccncc32)cc1\n", + "5 c1ccc(CNC2CCNCC2)cc1\n", + "8 c1ccc2c(N3CCN(CCCc4csc5ccccc45)CC3)cccc2c1\n", + "15 O=S1(=O)Nc2ccccc2N1c1ccccc1\n", + "16 O=C1NCc2ccc3c(c21)CC(NCCCc1c[nH]c2ccccc12)CO3\n", + " ... \n", + "176 c1ccc(C2CC3CCC(C2)N3)cc1\n", + "178 c1ccc(C2CNCc3ccncc32)cc1\n", + "190 c1ccc2sc(C3CCN(CCCOc4cccc5occc45)CC3)cc2c1\n", + "193 c1ccc(Oc2ncccc2C2CCNCC2)cc1\n", + "198 c1ccc(C2[C@H]3CNC[C@@H]23)cc1\n", + "Name: scaffold_smiles, Length: 66, dtype: object\n", + "Fold 2:\n", + "Train: index=\n", + "[ 1 2 4 5 7 8 10 13 14 15 16 18 20 22 24 25 27 30\n", + " 32 33 35 36 37 38 39 41 42 43 44 45 46 50 53 54 55 57\n", + " 58 59 61 62 66 67 69 70 72 73 74 76 77 82 83 84 86 87\n", + " 88 89 90 91 92 93 94 95 96 97 98 100 101 102 103 104 105 106\n", + " 107 111 112 113 115 116 117 120 121 125 126 127 128 129 130 131 133 136\n", + " 137 138 140 142 149 151 152 153 154 155 156 157 158 160 161 162 163 164\n", + " 165 168 169 170 171 172 173 175 176 178 179 181 182 183 184 185 188 189\n", + " 190 191 193 194 196 198 199]\n", + "group=\n", + "1 c1ccc(C2CNCc3ccncc32)cc1\n", + "2 c1ccc2cc(CN[C@@H]3CCNC3)ccc2c1\n", + "4 c1cncc(OC[C@@H]2CCNC2)c1\n", + "5 c1ccc(CNC2CCNCC2)cc1\n", + "7 c1ccc(CN2CCC(CCOC(c3ccccc3)c3ccccc3)CC2)cc1\n", + " ... \n", + "193 c1ccc(Oc2ncccc2C2CCNCC2)cc1\n", + "194 c1ccc(Oc2ccccc2)cc1\n", + "196 c1ccc(OC(c2ccccc2)C2CCCNC2)cc1\n", + "198 c1ccc(C2[C@H]3CNC[C@@H]23)cc1\n", + "199 c1ccc(C(c2ccccc2)c2ccncc2)cc1\n", + "Name: scaffold_smiles, Length: 133, dtype: object\n", + "Test: index=\n", + "[ 0 3 6 9 11 12 17 19 21 23 26 28 29 31 34 40 47 48\n", + " 49 51 52 56 60 63 64 65 68 71 75 78 79 80 81 85 99 108\n", + " 109 110 114 118 119 122 123 124 132 134 135 139 141 143 144 145 146 147\n", + " 148 150 159 166 167 174 177 180 186 187 192 195 197]\n", + "group=\n", + "0 c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1\n", + "3 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", + "6 c1ccc(C2(COCc3ccccn3)CCNCC2)cc1\n", + "9 c1ccc2c(c1)CCOC2CCN1CCC(c2c[nH]c3ccccc23)CC1\n", + "11 c1ccc([C@H]2CC3CCC2CC3)cc1\n", + " ... \n", + "186 c1ccc(Oc2ccc3c(c2)CCS3)cc1\n", + "187 c1ccc([C@@H]2C[C@H]3CCC(N3)[C@@H]2c2ccccc2)cc1\n", + "192 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", + "195 c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1\n", + "197 c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CC...\n", + "Name: scaffold_smiles, Length: 67, dtype: object\n" + ] + } + ], + "source": [ + "sgkf = StratifiedGroupKFold(n_splits=3, shuffle=False)\n", + "for i, (train_index, test_index) in enumerate(sgkf.split(X, y, groups)):\n", + "\n", + " print(f\"Fold {i}:\")\n", + " print(f\"Train: index=\\n{train_index}\")\n", + " print(f\"group=\\n{groups[train_index]}\")\n", + " print(f\"Test: index=\\n{test_index}\")\n", + " print(f\"group=\\n{groups[test_index]}\")\n", + " assert(len(set(groups[train_index]).intersection(set(groups[test_index]))) == 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "scaffold_smiles\n", + "c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1 3\n", + "c1ccc(-c2cnc([C@H]3[C@@H](c4ccccc4)C[C@@H]4CC[C@H]3N4)s2)cc1 3\n", + "c1ccc(Cc2ccccc2)cc1 2\n", + "c1ccc(C2(COCc3ccccn3)CCNCC2)cc1 2\n", + "c1ccc(-c2cncc3c2CNCC3)cc1 2\n", + "c1ccc2c(C3CC3)cccc2c1 2\n", + "c1ccc(C2CCc3ccccc32)cc1 2\n", + "c1ccc(C2CCNCC2)cc1 2\n", + "c1ccc2c(C3CCCC3)c[nH]c2c1 2\n", + "C(#Cc1ccc(COc2ccccc2)cc1)CCN1CCCCC1 1\n", + "c1ccc([C@@H]2CC3CCC(N3)[C@@H]2c2ccccc2)cc1 1\n", + "c1ccc([C@H]2CC3CCC2CC3)cc1 1\n", + "c1ccc2c(c1)CCOC2CCN1CCC(c2c[nH]c3ccccc23)CC1 1\n", + "O=C(Nc1ccc(NC(=O)[C@H]2C3CCC(C[C@@H]2c2ccc(-c4ccsc4)cc2)N3)cc1)[C@@H]1C2CCC(C[C@@H]1c1ccc(-c3ccsc3)cc1)N2 1\n", + "C(=C/c1ccsc1)\\CN1CCN(C[C@@H]2ON=C3c4ccccc4OC[C@H]32)CC1 1\n", + "C(=C/c1ccccc1)\\CN1CCN(CCN(Cc2ccccc2)c2ccccn2)CC1 1\n", + "c1ccc2c(c1)CCN([C@H]1CC[C@H](c3c[nH]c4ccccc43)CC1)C2 1\n", + "c1ccc(C2OCc3ccccc32)cc1 1\n", + "C=C1C2CCC(C[C@@H]1OC(c1ccccc1)c1ccccc1)N2 1\n", + "c1ccc(CC[C@@H]2CCCO2)cc1 1\n", + "O=C(NCCCCN1CCN(c2ccccc2)CC1)c1c[nH]c(-c2ccccc2)c1 1\n", + "c1ccc(O[C@@H]2CCOc3ccccc32)cc1 1\n", + "c1ccc2c3c([nH]c2c1)[C@@H]1C[C@@H]2CC[C@@H]1N(CC3)C2 1\n", + "c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1 1\n", + "c1cc(N2CCN([C@H]3CC[C@@H](c4c[nH]c5ccccc54)CC3)CC2)c2cc[nH]c2c1 1\n", + "c1ccc(C2CNCc3cc(OCCCN4CCN(c5ccncc5)CC4)ccc32)cc1 1\n", + "c1ccc(CCNCCNCCOC(c2ccccc2)c2ccccc2)cc1 1\n", + "C(COC(c1ccccc1)c1ccccc1)=C1CC2CCC(C1)N2CCCc1ccccc1 1\n", + "O=C(OCCc1ccccc1)[C@@H]1C2CCC(C[C@@H]1OC(c1ccccc1)c1ccccc1)N2 1\n", + "c1cnc2c(N3CCN(CCCc4csc5ccccc45)CC3)cccc2c1 1\n", + "O=C1OC2(CCC(N3CCC(Cc4ccccc4)CC3)CC2)c2ccc3c(c21)OCO3 1\n", + "c1ccc(C2CC2)c(CN[C@H]2CCNC2)c1 1\n", + "c1ccc(C(OCCN2CC3CCC(C2)N3)c2ccccc2)cc1 1\n", + "c1ccc(C2CNCc3cc(OCC4CCNCC4)ncc32)cc1 1\n", + "C=C(c1ccccc1)c1cccnc1 1\n", + "c1ccc2c(c1)CC(NCCCCc1c[nH]c3ccccc13)CO2 1\n", + "C(=[SH]Cc1ncno1)C1CNCCC1c1ccccc1 1\n", + "O=C(NCCN1CCN(c2ccccc2)CC1)c1c[nH]c(-c2ccccc2)c1 1\n", + "C(#Cc1ccc(Oc2ccccc2)cc1)CCN1CCCCC1 1\n", + "c1ccc(COC2(c3ccccc3)CNC2)cc1 1\n", + "c1ccc2c(c1)CCN2 1\n", + "O=C(NCCCN1CCN(c2ccccc2)CC1)c1cn(C2CCCC2)cn1 1\n", + "C(=C/c1ccccc1)\\CN1CCN(C[C@@H]2ON=C3c4ccccc4NC[C@H]32)CC1 1\n", + "O=C1CCc2c(CCN3CCN(c4cccc5ncccc45)CC3)cccc2N1 1\n", + "c1ccc(CN[C@@H]2CC[C@H](C(c3ccccc3)c3ccccc3)NC2)cc1 1\n", + "O=c1c2ccccc2[nH]c2ccccc12 1\n", + "c1ccc(Cc2cc([C@@H]3C4CCC(C[C@@H]3c3ccccc3)N4)on2)cc1 1\n", + "c1ccc(O[C@H]2CCc3ccccc32)cc1 1\n", + "c1ccc2c(CCCCNCCOc3cccc4[nH]ccc34)c[nH]c2c1 1\n", + "O=C1COc2ccc(CCCCN3CCN(c4cccc5ncccc45)CC3)cc2N1 1\n", + "c1ccc(CCN2CCN(c3cccc4ncccc34)CC2)cc1 1\n", + "c1ccc(OC(c2ccccn2)[C@H]2CCNC2)cc1 1\n", + "c1ccc(Oc2ccc3c(c2)CCS3)cc1 1\n", + "c1ccc([C@@H]2C[C@H]3CCC(N3)[C@@H]2c2ccccc2)cc1 1\n", + "c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1 1\n", + "c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CCOCC5)ccc43)cc2)c1 1\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "groups[test_index].value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### showcase ###" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.random.rand(1000)\n", + "y = np.random.randint(0,3,1000)\n", + "groups = y[np.random.permutation(len(y))]\n", + "#groups[0:90] = 0\n", + "#y[0:90] = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([0, 1, 2]), array([340, 326, 334]))\n", + "[np.float64(0.34), np.float64(0.32625), np.float64(0.33375)]\n", + "[np.float64(0.34), np.float64(0.325), np.float64(0.335)]\n", + "(array([0, 1, 2]), array([68, 65, 67]))\n", + "800 200\n", + "[np.float64(0.34), np.float64(0.32625), np.float64(0.33375)]\n", + "[np.float64(0.34), np.float64(0.325), np.float64(0.335)]\n", + "(array([0, 1, 2]), array([68, 65, 67]))\n", + "800 200\n", + "[np.float64(0.34), np.float64(0.32625), np.float64(0.33375)]\n", + "[np.float64(0.34), np.float64(0.325), np.float64(0.335)]\n", + "(array([0, 1, 2]), array([68, 65, 67]))\n", + "800 200\n", + "[np.float64(0.34), np.float64(0.32625), np.float64(0.33375)]\n", + "[np.float64(0.34), np.float64(0.325), np.float64(0.335)]\n", + "(array([0, 1, 2]), array([68, 65, 67]))\n", + "800 200\n", + "[np.float64(0.34), np.float64(0.32625), np.float64(0.33375)]\n", + "[np.float64(0.34), np.float64(0.325), np.float64(0.335)]\n", + "(array([0, 1, 2]), array([68, 65, 67]))\n", + "800 200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/peptid/uv_venvs/scikit_mol_cedenoruel/lib/python3.11/site-packages/sklearn/model_selection/_split.py:2425: UserWarning: The groups parameter is ignored by StratifiedShuffleSplit\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "sss = StratifiedShuffleSplit(n_splits=5, test_size=0.2)\n", + "print(np.unique(y,return_counts=True))\n", + "for i, (train_index, test_index) in enumerate(sss.split(x, y, groups)):\n", + " y_train_counts, y_test_counts = np.unique(y[train_index], return_counts=True),np.unique(y[test_index], return_counts=True)\n", + " print([i/sum(y_train_counts[1]) for i in y_train_counts[1]])\n", + " print([i/sum(y_test_counts[1]) for i in y_test_counts[1]])\n", + " print(y_test_counts)\n", + " print(len(y[train_index]), len(y[test_index]))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([0, 1, 2]), array([340, 326, 334]))\n", + "(array([0, 1, 2]), array([340, 326, 334]))\n", + "Train: (array([0, 1, 2]), array([215, 230, 221]))\n", + "Test: (array([0, 1, 2]), array([125, 96, 113]))\n", + "Train groups: (array([0, 1]), array([340, 326]))\n", + "Test groups: (array([2]), array([334]))\n", + "666 334\n", + "0\n", + "Train: (array([0, 1, 2]), array([223, 228, 223]))\n", + "Test: (array([0, 1, 2]), array([117, 98, 111]))\n", + "Train groups: (array([0, 2]), array([340, 334]))\n", + "Test groups: (array([1]), array([326]))\n", + "674 326\n", + "0\n", + "Train: (array([0, 1, 2]), array([215, 230, 221]))\n", + "Test: (array([0, 1, 2]), array([125, 96, 113]))\n", + "Train groups: (array([0, 1]), array([340, 326]))\n", + "Test groups: (array([2]), array([334]))\n", + "666 334\n", + "0\n", + "Train: (array([0, 1, 2]), array([242, 194, 224]))\n", + "Test: (array([0, 1, 2]), array([ 98, 132, 110]))\n", + "Train groups: (array([1, 2]), array([326, 334]))\n", + "Test groups: (array([0]), array([340]))\n", + "660 340\n", + "0\n", + "Train: (array([0, 1, 2]), array([242, 194, 224]))\n", + "Test: (array([0, 1, 2]), array([ 98, 132, 110]))\n", + "Train groups: (array([1, 2]), array([326, 334]))\n", + "Test groups: (array([0]), array([340]))\n", + "660 340\n", + "0\n" + ] + } + ], + "source": [ + "# groups are splitted, stratification is not granted, exact test_size is not respected, fails quite miserably for imbalanced data\n", + "sss = GroupShuffleSplit(n_splits=5, test_size=0.2)\n", + "print(np.unique(y, return_counts=True))\n", + "print(np.unique(groups, return_counts=True))\n", + "for i, (train_index, test_index) in enumerate(sss.split(x, y, groups)):\n", + " y_train_counts, y_test_counts, groups_train_counts, groups_test_counts = np.unique(y[train_index], return_counts=True),np.unique(y[test_index], return_counts=True),np.unique(groups[train_index], return_counts=True),np.unique(groups[test_index], return_counts=True)\n", + " print(f\"Train: {y_train_counts}\")\n", + " print(f\"Test: {y_test_counts}\")\n", + " print(f\"Train groups: {groups_train_counts}\")\n", + " print(f\"Test groups: {groups_test_counts}\")\n", + " print(len(y[train_index]), len(y[test_index]))\n", + " print(len(set(groups[train_index]).intersection(set(groups[test_index]))))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([0, 1, 2]), array([340, 326, 334]))\n", + "Train counts: (array([0, 1, 2]), array([242, 194, 224]))\n", + "Test counts: (array([0, 1, 2]), array([ 98, 132, 110]))\n", + "Groups train counts: (array([1, 2]), array([326, 334]))\n", + "Groups test counts: (array([0]), array([340]))\n", + "660 340\n", + "0\n", + "Train counts: (array([0, 1, 2]), array([215, 230, 221]))\n", + "Test counts: (array([0, 1, 2]), array([125, 96, 113]))\n", + "Groups train counts: (array([0, 1]), array([340, 326]))\n", + "Groups test counts: (array([2]), array([334]))\n", + "666 334\n", + "0\n", + "Train counts: (array([0, 1, 2]), array([223, 228, 223]))\n", + "Test counts: (array([0, 1, 2]), array([117, 98, 111]))\n", + "Groups train counts: (array([0, 2]), array([340, 334]))\n", + "Groups test counts: (array([1]), array([326]))\n", + "674 326\n", + "0\n", + "Train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", + "Test counts: (array([], dtype=int64), array([], dtype=int64))\n", + "Groups train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", + "Groups test counts: (array([], dtype=int64), array([], dtype=int64))\n", + "1000 0\n", + "0\n", + "Train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", + "Test counts: (array([], dtype=int64), array([], dtype=int64))\n", + "Groups train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", + "Groups test counts: (array([], dtype=int64), array([], dtype=int64))\n", + "1000 0\n", + "0\n" + ] + } + ], + "source": [ + "sss = StratifiedGroupKFold(n_splits=5)\n", + "groups_counts = np.unique(groups, return_counts=True)\n", + "print(groups_counts)\n", + "for i, (train_index, test_index) in enumerate(sss.split(x, y, groups)):\n", + " y_train_counts, y_test_counts, groups_train_counts, groups_test_counts = np.unique(y[train_index], return_counts=True),np.unique(y[test_index], return_counts=True),np.unique(groups[train_index], return_counts=True),np.unique(groups[test_index], return_counts=True)\n", + " print(f\"Train counts: {y_train_counts}\")\n", + " print(f\"Test counts: {y_test_counts}\")\n", + " print(f\"Groups train counts: {groups_train_counts}\")\n", + " print(f\"Groups test counts: {groups_test_counts}\")\n", + " print(len(y[train_index]), len(y[test_index]))\n", + " print(len(set(groups[train_index]).intersection(set(groups[test_index]))))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([0, 1, 2]), array([340, 326, 334]))\n", + "Train counts: (array([0, 1, 2]), array([242, 194, 224]))\n", + "Test counts: (array([0, 1, 2]), array([ 98, 132, 110]))\n", + "Groups train counts: (array([1, 2]), array([326, 334]))\n", + "Groups test counts: (array([0]), array([340]))\n", + "660 340\n", + "0\n", + "Train counts: (array([0, 1, 2]), array([215, 230, 221]))\n", + "Test counts: (array([0, 1, 2]), array([125, 96, 113]))\n", + "Groups train counts: (array([0, 1]), array([340, 326]))\n", + "Groups test counts: (array([2]), array([334]))\n", + "666 334\n", + "0\n", + "Train counts: (array([0, 1, 2]), array([223, 228, 223]))\n", + "Test counts: (array([0, 1, 2]), array([117, 98, 111]))\n", + "Groups train counts: (array([0, 2]), array([340, 334]))\n", + "Groups test counts: (array([1]), array([326]))\n", + "674 326\n", + "0\n", + "Train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", + "Test counts: (array([], dtype=int64), array([], dtype=int64))\n", + "Groups train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", + "Groups test counts: (array([], dtype=int64), array([], dtype=int64))\n", + "1000 0\n", + "0\n", + "Train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", + "Test counts: (array([], dtype=int64), array([], dtype=int64))\n", + "Groups train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", + "Groups test counts: (array([], dtype=int64), array([], dtype=int64))\n", + "1000 0\n", + "0\n" + ] + } + ], + "source": [ + "sss = StratifiedGroupKFold(n_splits=5, shuffle=True, random_state=65)\n", + "groups_counts = np.unique(groups, return_counts=True)\n", + "print(groups_counts)\n", + "for i, (train_index, test_index) in enumerate(sss.split(x, y, groups)):\n", + " y_train_counts, y_test_counts, groups_train_counts, groups_test_counts = np.unique(y[train_index], return_counts=True),np.unique(y[test_index], return_counts=True),np.unique(groups[train_index], return_counts=True),np.unique(groups[test_index], return_counts=True)\n", + " print(f\"Train counts: {y_train_counts}\")\n", + " print(f\"Test counts: {y_test_counts}\")\n", + " print(f\"Groups train counts: {groups_train_counts}\")\n", + " print(f\"Groups test counts: {groups_test_counts}\")\n", + " print(len(y[train_index]), len(y[test_index]))\n", + " print(len(set(groups[train_index]).intersection(set(groups[test_index]))))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## StratifiedGroupShuffleSplit ##" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import time\n", + "from collections import defaultdict\n", + "from sklearn.model_selection._split import BaseShuffleSplit\n", + "from sklearn.utils.validation import _num_samples\n", + "from sklearn.utils import check_random_state\n", + "class StratifiedGroupShuffleSplit(BaseShuffleSplit):\n", + " \"\"\"Stratified ShuffleSplit cross-validator with non-overlapping groups.\"\"\"\n", + "\n", + " def __init__(self, n_splits=5, *, test_size=0.2, train_size=None, random_state=None):\n", + " super().__init__(\n", + " n_splits=n_splits,\n", + " test_size=test_size,\n", + " train_size=train_size,\n", + " random_state=random_state,\n", + " )\n", + "\n", + " def _iter_indices(self, X, y, groups):\n", + " if y is None:\n", + " raise ValueError(\"StratifiedGroupShuffleSplit requires 'y' for stratification.\")\n", + "\n", + " n_samples = _num_samples(X)\n", + " \n", + " if isinstance(self.test_size, float):\n", + " n_test = int(self.test_size * n_samples)\n", + " else:\n", + " n_test = int(self.test_size)\n", + "\n", + " unique_groups, group_indices = np.unique(groups, return_inverse=True)\n", + " n_groups = len(unique_groups)\n", + " classes, y_indices = np.unique(y, return_inverse=True)\n", + " n_classes = len(classes)\n", + " overall_class_counts = np.bincount(y_indices, minlength=n_classes)\n", + "\n", + " group_info = defaultdict(lambda: {\n", + " \"class_counts\": np.zeros(n_classes, dtype=int),\n", + " \"indices\": [],\n", + " \"size\": 0\n", + " })\n", + " for i, group_idx in enumerate(group_indices):\n", + " class_idx = y_indices[i]\n", + " group_info[group_idx][\"class_counts\"][class_idx] += 1\n", + " group_info[group_idx][\"indices\"].append(i)\n", + " for i in range(n_groups):\n", + " group_info[i][\"size\"] = len(group_info[i][\"indices\"])\n", + "\n", + "\n", + " rng = check_random_state(self.random_state)\n", + "\n", + " for _ in range(self.n_splits):\n", + " available_groups = list(range(n_groups))\n", + " test_groups = []\n", + " \n", + " current_test_size = 0\n", + " current_test_counts = np.zeros(n_classes, dtype=int)\n", + "\n", + " # Phase 1: Greedily add only \"safe\" groups that do not exceed n_test\n", + " while available_groups:\n", + " safe_candidates = []\n", + " for group_idx in available_groups:\n", + " group_data = group_info[group_idx]\n", + " if current_test_size + group_data[\"size\"] <= n_test:\n", + " prospective_counts = current_test_counts + group_data[\"class_counts\"]\n", + " prospective_size = current_test_size + group_data[\"size\"]\n", + " ideal_counts = overall_class_counts * (prospective_size / n_samples)\n", + " error = np.sum((prospective_counts - ideal_counts) ** 2)\n", + " safe_candidates.append({'error': error, 'id': group_idx})\n", + "\n", + " if not safe_candidates:\n", + " # No more groups can be added without overshooting\n", + " break\n", + " \n", + " safe_candidates.sort(key=lambda x: x['error'])\n", + " pool_size = min(5, len(safe_candidates))\n", + " candidate_pool = [cand['id'] for cand in safe_candidates[:pool_size]]\n", + " best_group = rng.choice(candidate_pool)\n", + "\n", + " test_groups.append(best_group)\n", + " available_groups.remove(best_group)\n", + " group_data = group_info[best_group]\n", + " current_test_counts += group_data[\"class_counts\"]\n", + " current_test_size += group_data[\"size\"]\n", + "\n", + " # Phase 2: Decide if a single overshoot is better than the current undershoot\n", + " if available_groups and current_test_size < n_test:\n", + " overshoot_candidates = []\n", + " for group_idx in available_groups:\n", + " group_data = group_info[group_idx]\n", + " prospective_size = current_test_size + group_data[\"size\"]\n", + " # We only care about the size difference now\n", + " overshoot_candidates.append({'id': group_idx, 'size': prospective_size})\n", + "\n", + " if overshoot_candidates:\n", + " # Find the group that causes the smallest overshoot\n", + " overshoot_candidates.sort(key=lambda x: x['size'])\n", + " best_overshoot_group = overshoot_candidates[0]\n", + " \n", + " undershoot_error = n_test - current_test_size\n", + " overshoot_error = best_overshoot_group['size'] - n_test\n", + "\n", + " if overshoot_error < undershoot_error:\n", + " # If overshooting is closer to the target, add the group\n", + " test_groups.append(best_overshoot_group['id'])\n", + "\n", + " test_indices = np.concatenate([group_info[g_idx][\"indices\"] for g_idx in test_groups]) if test_groups else []\n", + " all_indices = np.arange(n_samples)\n", + " train_indices = np.setdiff1d(all_indices, test_indices, assume_unique=True)\n", + " \n", + " yield train_indices, test_indices\n", + "\n", + " def get_n_splits(self, X=None, y=None, groups=None):\n", + " return self.n_splits\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "==================== Running Test: BALANCED Dataset ====================\n", + "\n", + "Checking for group overlap...\n", + "SUCCESS: No overlapping groups found between train and test sets.\n", + "\n", + "Dataset Sizes and Ratios:\n", + " - Train set size: 7008 (70.08%)\n", + " - Test set size: 2992 (29.92%)\n", + "\n", + "Class Distribution Ratios:\n", + " - Full Dataset:\n", + " - Class 0: 25.00%\n", + " - Class 1: 25.00%\n", + " - Class 2: 25.00%\n", + " - Class 3: 25.00%\n", + " - Train Set:\n", + " - Class 0: 25.07%\n", + " - Class 1: 24.97%\n", + " - Class 2: 24.91%\n", + " - Class 3: 25.04%\n", + " - Test Set:\n", + " - Class 0: 24.83%\n", + " - Class 1: 25.07%\n", + " - Class 2: 25.20%\n", + " - Class 3: 24.90%\n", + "\n", + "Generating class distribution histograms...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "==================== Running Test: IMBALANCED Dataset ====================\n", + "\n", + "Checking for group overlap...\n", + "SUCCESS: No overlapping groups found between train and test sets.\n", + "\n", + "Dataset Sizes and Ratios:\n", + " - Train set size: 7003 (70.03%)\n", + " - Test set size: 2997 (29.97%)\n", + "\n", + "Class Distribution Ratios:\n", + " - Full Dataset:\n", + " - Class 0: 90.00%\n", + " - Class 1: 4.00%\n", + " - Class 2: 3.00%\n", + " - Class 3: 3.00%\n", + " - Train Set:\n", + " - Class 0: 90.12%\n", + " - Class 1: 3.91%\n", + " - Class 2: 3.00%\n", + " - Class 3: 2.97%\n", + " - Test Set:\n", + " - Class 0: 89.72%\n", + " - Class 1: 4.20%\n", + " - Class 2: 3.00%\n", + " - Class 3: 3.07%\n", + "\n", + "Generating class distribution histograms...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "==================== Running Test: Varying Test Ratios (N=100,000) ====================\n", + "\n", + "--- Scenario: BALANCED ---\n", + "Full Dataset Distribution:\n", + " - Full Dataset:\n", + " - Class 0: 25.00%\n", + " - Class 1: 25.00%\n", + " - Class 2: 25.00%\n", + " - Class 3: 25.00%\n", + "\n", + "-- Testing with test_size = 0.1 --\n", + "Train size: 90054, Test size: 9946\n", + " - Test Set:\n", + " - Class 0: 25.01%\n", + " - Class 1: 25.17%\n", + " - Class 2: 24.91%\n", + " - Class 3: 24.91%\n", + "\n", + "-- Testing with test_size = 0.2 --\n", + "Train size: 79969, Test size: 20031\n", + " - Test Set:\n", + " - Class 0: 25.02%\n", + " - Class 1: 25.25%\n", + " - Class 2: 24.93%\n", + " - Class 3: 24.80%\n", + "\n", + "-- Testing with test_size = 0.3 --\n", + "Train size: 69810, Test size: 30190\n", + " - Test Set:\n", + " - Class 0: 25.06%\n", + " - Class 1: 25.15%\n", + " - Class 2: 24.90%\n", + " - Class 3: 24.88%\n", + "\n", + "-- Testing with test_size = 0.4 --\n", + "Train size: 59851, Test size: 40149\n", + " - Test Set:\n", + " - Class 0: 25.00%\n", + " - Class 1: 25.11%\n", + " - Class 2: 24.95%\n", + " - Class 3: 24.93%\n", + "\n", + "--- Scenario: IMBALANCED ---\n", + "Full Dataset Distribution:\n", + " - Full Dataset:\n", + " - Class 0: 90.00%\n", + " - Class 1: 4.00%\n", + " - Class 2: 3.00%\n", + " - Class 3: 3.00%\n", + "\n", + "-- Testing with test_size = 0.1 --\n", + "Train size: 90069, Test size: 9931\n", + " - Test Set:\n", + " - Class 0: 90.01%\n", + " - Class 1: 4.02%\n", + " - Class 2: 3.03%\n", + " - Class 3: 2.94%\n", + "\n", + "-- Testing with test_size = 0.2 --\n", + "Train size: 80145, Test size: 19855\n", + " - Test Set:\n", + " - Class 0: 89.97%\n", + " - Class 1: 4.00%\n", + " - Class 2: 3.00%\n", + " - Class 3: 3.04%\n", + "\n", + "-- Testing with test_size = 0.3 --\n", + "Train size: 70047, Test size: 29953\n", + " - Test Set:\n", + " - Class 0: 90.00%\n", + " - Class 1: 3.97%\n", + " - Class 2: 3.01%\n", + " - Class 3: 3.01%\n", + "\n", + "-- Testing with test_size = 0.4 --\n", + "Train size: 60008, Test size: 39992\n", + " - Test Set:\n", + " - Class 0: 89.98%\n", + " - Class 1: 3.97%\n", + " - Class 2: 3.02%\n", + " - Class 3: 3.03%\n", + "\n", + "==================== Running Test: Varying Absolute Test Sizes (N=50,000) ====================\n", + "\n", + "--- Scenario: BALANCED ---\n", + "Full Dataset Distribution:\n", + " - Full Dataset:\n", + " - Class 0: 25.00%\n", + " - Class 1: 25.00%\n", + " - Class 2: 25.00%\n", + " - Class 3: 25.00%\n", + "\n", + "-- Testing with test_size = 1000 --\n", + "Requested test size: 1000, Actual test size: 978\n", + " - Test Set:\n", + " - Class 0: 24.03%\n", + " - Class 1: 26.07%\n", + " - Class 2: 25.26%\n", + " - Class 3: 24.64%\n", + "\n", + "-- Testing with test_size = 3000 --\n", + "Requested test size: 3000, Actual test size: 2987\n", + " - Test Set:\n", + " - Class 0: 24.74%\n", + " - Class 1: 25.04%\n", + " - Class 2: 24.87%\n", + " - Class 3: 25.34%\n", + "\n", + "-- Testing with test_size = 5000 --\n", + "Requested test size: 5000, Actual test size: 4985\n", + " - Test Set:\n", + " - Class 0: 25.16%\n", + " - Class 1: 25.06%\n", + " - Class 2: 24.93%\n", + " - Class 3: 24.85%\n", + "\n", + "-- Testing with test_size = 7000 --\n", + "Requested test size: 7000, Actual test size: 6941\n", + " - Test Set:\n", + " - Class 0: 24.88%\n", + " - Class 1: 25.13%\n", + " - Class 2: 25.05%\n", + " - Class 3: 24.94%\n", + "\n", + "-- Testing with test_size = 9000 --\n", + "Requested test size: 9000, Actual test size: 8918\n", + " - Test Set:\n", + " - Class 0: 24.89%\n", + " - Class 1: 25.08%\n", + " - Class 2: 24.99%\n", + " - Class 3: 25.03%\n", + "\n", + "--- Scenario: IMBALANCED ---\n", + "Full Dataset Distribution:\n", + " - Full Dataset:\n", + " - Class 0: 90.00%\n", + " - Class 1: 4.00%\n", + " - Class 2: 3.00%\n", + " - Class 3: 3.00%\n", + "\n", + "-- Testing with test_size = 1000 --\n", + "Requested test size: 1000, Actual test size: 964\n", + " - Test Set:\n", + " - Class 0: 90.35%\n", + " - Class 1: 3.73%\n", + " - Class 2: 3.01%\n", + " - Class 3: 2.90%\n", + "\n", + "-- Testing with test_size = 3000 --\n", + "Requested test size: 3000, Actual test size: 2916\n", + " - Test Set:\n", + " - Class 0: 90.05%\n", + " - Class 1: 3.98%\n", + " - Class 2: 3.09%\n", + " - Class 3: 2.88%\n", + "\n", + "-- Testing with test_size = 5000 --\n", + "Requested test size: 5000, Actual test size: 4913\n", + " - Test Set:\n", + " - Class 0: 89.97%\n", + " - Class 1: 3.97%\n", + " - Class 2: 3.07%\n", + " - Class 3: 2.99%\n", + "\n", + "-- Testing with test_size = 7000 --\n", + "Requested test size: 7000, Actual test size: 6907\n", + " - Test Set:\n", + " - Class 0: 90.04%\n", + " - Class 1: 3.97%\n", + " - Class 2: 2.97%\n", + " - Class 3: 3.03%\n", + "\n", + "-- Testing with test_size = 9000 --\n", + "Requested test size: 9000, Actual test size: 8991\n", + " - Test Set:\n", + " - Class 0: 89.95%\n", + " - Class 1: 4.03%\n", + " - Class 2: 3.04%\n", + " - Class 3: 2.99%\n", + "\n", + "==================== Running Runtime Analysis ====================\n", + "Testing with N = 1000...\n", + " -> Execution time: 0.0193 seconds\n", + "Testing with N = 10000...\n", + " -> Execution time: 0.0234 seconds\n", + "Testing with N = 100000...\n", + " -> Execution time: 0.0794 seconds\n", + "Testing with N = 1000000...\n", + " -> Execution time: 0.7114 seconds\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_class_distribution(ax, y_data, title):\n", + " \"\"\"Helper function to plot class distribution histograms.\"\"\"\n", + " classes, counts = np.unique(y_data, return_counts=True)\n", + " ax.bar(classes, counts, color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'])\n", + " ax.set_title(title)\n", + " ax.set_xlabel('Class Label')\n", + " ax.set_ylabel('Frequency')\n", + " ax.set_xticks(classes)\n", + "\n", + "def print_dist_ratios(name, data, all_classes):\n", + " \"\"\"Helper function to print class distribution ratios.\"\"\"\n", + " classes, counts = np.unique(data, return_counts=True)\n", + " ratios = counts / len(data)\n", + " dist_map = dict(zip(classes, ratios))\n", + " print(f\" - {name}:\")\n", + " for cls in all_classes:\n", + " ratio_val = dist_map.get(cls, 0)\n", + " print(f\" - Class {cls}: {ratio_val:.2%}\")\n", + "\n", + "def run_test_scenario(scenario=\"balanced\", n_samples=10000):\n", + " \"\"\"Runs a full test scenario for either a balanced or imbalanced dataset.\"\"\"\n", + " print(f\"\\n{'='*20} Running Test: {scenario.upper()} Dataset {'='*20}\")\n", + " \n", + " # 1. Generate Data\n", + " if scenario == \"balanced\":\n", + " n_classes = 4\n", + " y = np.repeat(np.arange(n_classes), n_samples // n_classes)\n", + " else: # imbalanced\n", + " y = np.array([0]*int(n_samples*0.9) + [1]*int(n_samples*0.04) + \n", + " [2]*int(n_samples*0.03) + [3]*int(n_samples*0.03))\n", + " \n", + " all_classes = np.unique(y)\n", + " n_groups = 50\n", + " groups = np.random.randint(0, n_groups, size=n_samples)\n", + " X = np.random.rand(n_samples, 3)\n", + " \n", + " p = np.random.permutation(n_samples)\n", + " X, y, groups = X[p], y[p], groups[p]\n", + "\n", + " # 2. Perform a split\n", + " sgss = StratifiedGroupShuffleSplit(n_splits=1, test_size=0.3, random_state=42)\n", + " train_index, test_index = next(sgss.split(X, y, groups))\n", + "\n", + " # 3. Check for group overlap\n", + " train_groups = np.unique(groups[train_index])\n", + " test_groups = np.unique(groups[test_index])\n", + " intersection = np.intersect1d(train_groups, test_groups)\n", + " print(f\"\\nChecking for group overlap...\")\n", + " if len(intersection) == 0:\n", + " print(\"SUCCESS: No overlapping groups found between train and test sets.\")\n", + " else:\n", + " print(f\"FAILURE: Found {len(intersection)} overlapping groups.\")\n", + "\n", + " # 4. Print size ratios\n", + " train_ratio = len(train_index) / n_samples\n", + " test_ratio = len(test_index) / n_samples\n", + " print(f\"\\nDataset Sizes and Ratios:\")\n", + " print(f\" - Train set size: {len(train_index)} ({train_ratio:.2%})\")\n", + " print(f\" - Test set size: {len(test_index)} ({test_ratio:.2%})\")\n", + "\n", + " # 5. Print class distribution ratios\n", + " print(\"\\nClass Distribution Ratios:\")\n", + " print_dist_ratios(\"Full Dataset\", y, all_classes)\n", + " print_dist_ratios(\"Train Set\", y[train_index], all_classes)\n", + " print_dist_ratios(\"Test Set\", y[test_index], all_classes)\n", + "\n", + " # 6. Create histograms\n", + " print(\"\\nGenerating class distribution histograms...\")\n", + " fig, axes = plt.subplots(1, 3, figsize=(18, 5), sharey=True)\n", + " fig.suptitle(f'Class Distribution Comparison ({scenario.capitalize()} Dataset)', fontsize=16)\n", + " \n", + " plot_class_distribution(axes[0], y, 'Full Dataset')\n", + " plot_class_distribution(axes[1], y[train_index], 'Training Set')\n", + " plot_class_distribution(axes[2], y[test_index], 'Test Set')\n", + " \n", + " plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n", + " plt.show()\n", + "\n", + "def run_runtime_analysis():\n", + " \"\"\"Measures and plots the execution time for different dataset sizes.\"\"\"\n", + " print(f\"\\n{'='*20} Running Runtime Analysis {'='*20}\")\n", + " sample_sizes = [1000, 10000, 100000, 1000000]\n", + " execution_times = []\n", + "\n", + " for n in sample_sizes:\n", + " print(f\"Testing with N = {n}...\")\n", + " y = np.repeat([0, 1], n // 2)\n", + " groups = np.random.randint(0, 100, size=n)\n", + " X = np.random.rand(n, 3)\n", + " \n", + " sgss = StratifiedGroupShuffleSplit(n_splits=1, test_size=0.3, random_state=42)\n", + " \n", + " start_time = time.time()\n", + " next(sgss.split(X, y, groups))\n", + " end_time = time.time()\n", + " \n", + " duration = end_time - start_time\n", + " execution_times.append(duration)\n", + " print(f\" -> Execution time: {duration:.4f} seconds\")\n", + "\n", + " plt.figure(figsize=(10, 6))\n", + " plt.plot(sample_sizes, execution_times, marker='o', linestyle='-')\n", + " plt.title('StratifiedGroupShuffleSplit Runtime Analysis')\n", + " plt.xlabel('Number of Samples (N)')\n", + " plt.ylabel('Execution Time (seconds)')\n", + " plt.xscale('log')\n", + " plt.yscale('log')\n", + " plt.grid(True, which=\"both\", ls=\"--\")\n", + " plt.show()\n", + "\n", + "def run_ratio_sweep_test():\n", + " \"\"\"Tests the splitter with various test ratios for a fixed N.\"\"\"\n", + " print(f\"\\n{'='*20} Running Test: Varying Test Ratios (N=100,000) {'='*20}\")\n", + " n_samples = 100000\n", + " test_ratios = [0.1, 0.2, 0.3, 0.4]\n", + "\n", + " for scenario in [\"balanced\", \"imbalanced\"]:\n", + " print(f\"\\n--- Scenario: {scenario.upper()} ---\")\n", + " if scenario == \"balanced\":\n", + " y = np.repeat(np.arange(4), n_samples // 4)\n", + " else:\n", + " y = np.array([0]*int(n_samples*0.9) + [1]*int(n_samples*0.04) + \n", + " [2]*int(n_samples*0.03) + [3]*int(n_samples*0.03))\n", + " \n", + " all_classes = np.unique(y)\n", + " groups = np.random.randint(0, 50, size=n_samples)\n", + " X = np.random.rand(n_samples, 3)\n", + " p = np.random.permutation(n_samples)\n", + " X, y, groups = X[p], y[p], groups[p]\n", + "\n", + " print(\"Full Dataset Distribution:\")\n", + " print_dist_ratios(\"Full Dataset\", y, all_classes)\n", + "\n", + " for ratio in test_ratios:\n", + " print(f\"\\n-- Testing with test_size = {ratio} --\")\n", + " sgss = StratifiedGroupShuffleSplit(n_splits=1, test_size=ratio, random_state=42)\n", + " train_index, test_index = next(sgss.split(X, y, groups))\n", + " \n", + " print(f\"Train size: {len(train_index)}, Test size: {len(test_index)}\")\n", + " print_dist_ratios(\"Test Set\", y[test_index], all_classes)\n", + "\n", + "def run_absolute_size_sweep_test():\n", + " \"\"\"Tests the splitter with various absolute test sizes for a fixed N.\"\"\"\n", + " print(f\"\\n{'='*20} Running Test: Varying Absolute Test Sizes (N=50,000) {'='*20}\")\n", + " n_samples = 50000\n", + " test_sizes = range(1000, 10000, 2000)\n", + "\n", + " for scenario in [\"balanced\", \"imbalanced\"]:\n", + " print(f\"\\n--- Scenario: {scenario.upper()} ---\")\n", + " if scenario == \"balanced\":\n", + " y = np.repeat(np.arange(4), n_samples // 4)\n", + " else:\n", + " y = np.array([0]*int(n_samples*0.9) + [1]*int(n_samples*0.04) + \n", + " [2]*int(n_samples*0.03) + [3]*int(n_samples*0.03))\n", + " \n", + " all_classes = np.unique(y)\n", + " groups = np.random.randint(0, 50, size=n_samples)\n", + " X = np.random.rand(n_samples, 3)\n", + " p = np.random.permutation(n_samples)\n", + " X, y, groups = X[p], y[p], groups[p]\n", + "\n", + " print(\"Full Dataset Distribution:\")\n", + " print_dist_ratios(\"Full Dataset\", y, all_classes)\n", + "\n", + " for size in test_sizes:\n", + " print(f\"\\n-- Testing with test_size = {size} --\")\n", + " sgss = StratifiedGroupShuffleSplit(n_splits=1, test_size=size, random_state=42)\n", + " train_index, test_index = next(sgss.split(X, y, groups))\n", + " \n", + " print(f\"Requested test size: {size}, Actual test size: {len(test_index)}\")\n", + " print_dist_ratios(\"Test Set\", y[test_index], all_classes)\n", + "\n", + "if __name__ == '__main__':\n", + " # Run the original detailed scenarios with plots\n", + " run_test_scenario(scenario=\"balanced\")\n", + " run_test_scenario(scenario=\"imbalanced\")\n", + " \n", + " # Run the new sweep tests\n", + " run_ratio_sweep_test()\n", + " run_absolute_size_sweep_test()\n", + "\n", + " # Run the performance benchmark\n", + " run_runtime_analysis()\n" + ] + }, { "cell_type": "code", "execution_count": null, @@ -310,7 +1693,7 @@ ], "metadata": { "kernelspec": { - "display_name": "scikit_mol", + "display_name": "scikit_mol_cedenoruel", "language": "python", "name": "python3" }, @@ -324,7 +1707,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.4" + "version": "3.11.2" } }, "nbformat": 4, From 54eddeceed593f4e97bbe14cdadd036cd5abfa95 Mon Sep 17 00:00:00 2001 From: batukav Date: Mon, 7 Jul 2025 21:57:39 +0200 Subject: [PATCH 05/17] update the notebook with more test cases. --- .../notebooks/scaffold_split_planning.ipynb | 1054 ++++------------- 1 file changed, 215 insertions(+), 839 deletions(-) diff --git a/scikit_mol/notebooks/scaffold_split_planning.ipynb b/scikit_mol/notebooks/scaffold_split_planning.ipynb index f486f82..30d544d 100644 --- a/scikit_mol/notebooks/scaffold_split_planning.ipynb +++ b/scikit_mol/notebooks/scaffold_split_planning.ipynb @@ -48,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -58,98 +58,16 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "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", - "
Ambit_InchiKeySMILESpXC50
0RBCQCVSMIQCOMN-PCQZLOAONA-NC12C([C@@H](OC(C=3C=CC(=CC3)F)C=4C=CC(=CC4)F)C...6.26000
1ALZTYVXVRZIERJ-UHFFFAOYNA-NO(C1=NC=C2C(CN(CC2=C1)C)C3=CC=C(OC)C=C3)CCCN(C...7.18046
2MOEMPBAHOJKXBG-MRXNPFEDNA-NO=S(=O)(N(CC=1C=CC2=CC=CC=C2C1)[C@@H]3CCNC3)C7.77000
3HEKGBDCRHYILPL-QWOVJGMINA-NC1(=C2C(CCCC2O)=NC=3C1=CC=CC3)NCC=4C=CC(=CC4)Cl5.24000
4SNNRWIBSGBMYRF-UKRRQHHQNA-NC1NC[C@@H](C1)[C@H](OC=2C=CC(=NC2C)OC)CC(C)C9.12000
\n", - "
" - ], - "text/plain": [ - " Ambit_InchiKey \\\n", - "0 RBCQCVSMIQCOMN-PCQZLOAONA-N \n", - "1 ALZTYVXVRZIERJ-UHFFFAOYNA-N \n", - "2 MOEMPBAHOJKXBG-MRXNPFEDNA-N \n", - "3 HEKGBDCRHYILPL-QWOVJGMINA-N \n", - "4 SNNRWIBSGBMYRF-UKRRQHHQNA-N \n", - "\n", - " SMILES pXC50 \n", - "0 C12C([C@@H](OC(C=3C=CC(=CC3)F)C=4C=CC(=CC4)F)C... 6.26000 \n", - "1 O(C1=NC=C2C(CN(CC2=C1)C)C3=CC=C(OC)C=C3)CCCN(C... 7.18046 \n", - "2 O=S(=O)(N(CC=1C=CC2=CC=CC=C2C1)[C@@H]3CCNC3)C 7.77000 \n", - "3 C1(=C2C(CCCC2O)=NC=3C1=CC=CC3)NCC=4C=CC(=CC4)Cl 5.24000 \n", - "4 C1NC[C@@H](C1)[C@H](OC=2C=CC(=NC2C)OC)CC(C)C 9.12000 " - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "data.head()" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -158,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -167,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -176,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -185,7 +103,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -194,83 +112,34 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 86\n", - "1 78\n", - "2 153\n", - "3 102\n", - "4 158\n", - "Name: scaffold_ids, dtype: int64" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "data['scaffold_ids'].head()" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "161" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "len(data['scaffold_ids'].unique())" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1\n", - "1 c1ccc(C2CNCc3ccncc32)cc1\n", - "2 c1ccc2cc(CN[C@@H]3CCNC3)ccc2c1\n", - "3 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", - "4 c1cncc(OC[C@@H]2CCNC2)c1\n", - " ... \n", - "195 c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1\n", - "196 c1ccc(OC(c2ccccc2)C2CCCNC2)cc1\n", - "197 c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CC...\n", - "198 c1ccc(C2[C@H]3CNC[C@@H]23)cc1\n", - "199 c1ccc(C(c2ccccc2)c2ccncc2)cc1\n", - "Name: scaffold_smiles, Length: 200, dtype: object" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "data['scaffold_smiles']" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -279,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -298,27 +167,16 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "set()" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "set(groups[train_idx]).intersection(set(groups[test_idx]))" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -329,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -345,7 +203,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -355,82 +213,27 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 RBCQCVSMIQCOMN-PCQZLOAONA-N\n", - "2 MOEMPBAHOJKXBG-MRXNPFEDNA-N\n", - "3 HEKGBDCRHYILPL-QWOVJGMINA-N\n", - "4 SNNRWIBSGBMYRF-UKRRQHHQNA-N\n", - "5 UZCRUMOKTIFCRO-UHFFFAOYNA-N\n", - " ... \n", - "195 PIKWEFAACQLYMF-UHFFFAOYNA-N\n", - "196 AUZWJAMWJZUPHQ-UHFFFAOYNA-N\n", - "197 JCEWQICHOLLRDL-WUFINQPMNA-N\n", - "198 NGRIUVQYFBDXMT-JYAVWHMHNA-N\n", - "199 ZWLWOTHDIGRTNE-UHFFFAOYNA-N\n", - "Name: Ambit_InchiKey, Length: 157, dtype: object" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "X_train" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 C12C([C@@H](OC(C=3C=CC(=CC3)F)C=4C=CC(=CC4)F)C...\n", - "2 O=S(=O)(N(CC=1C=CC2=CC=CC=C2C1)[C@@H]3CCNC3)C\n", - "3 C1(=C2C(CCCC2O)=NC=3C1=CC=CC3)NCC=4C=CC(=CC4)Cl\n", - "4 C1NC[C@@H](C1)[C@H](OC=2C=CC(=NC2C)OC)CC(C)C\n", - "5 FC(F)(F)C=1C(CN(C2CCNCC2)CC(CC)CC)=CC=CC1\n", - " ... \n", - "195 C1=CC=C2C=CC(=CC2=C1)C(N3N=NC(=N3)C=4C=CC=CC4)...\n", - "196 C(OC1=CC=C(C=C1)Cl)(C=2C=CC(=CC2)F)C3CNCCC3\n", - "197 O(C1=CC=2[C@@H]3N(C[C@H](C2C=C1)C4=CC=C(N5N=CC...\n", - "198 C1NC[C@@H]2[C@H]1[C@@]2(CCOCC)C3=CC(=C(C=C3)Cl)Cl\n", - "199 C(C1=CC=NC=C1)(C2=CC=CC=C2)C3=CC=CC=C3\n", - "Name: SMILES, Length: 157, dtype: object" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "y_train" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "set()" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "set(groups[train_inds]).intersection(set(groups[test_inds]))" ] @@ -444,7 +247,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -455,139 +258,9 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Fold 0:\n", - "Train: index=\n", - "[ 0 2 3 5 6 8 9 11 13 14 15 20 22 24 25 27 31 32\n", - " 33 34 35 36 38 39 40 41 43 44 46 47 48 51 52 53 54 55\n", - " 56 57 59 60 62 63 65 66 67 68 69 72 74 75 76 79 80 82\n", - " 83 84 85 86 87 88 90 92 93 95 97 98 99 102 103 104 105 106\n", - " 107 108 109 110 111 112 113 114 115 116 117 119 120 121 122 123 124 125\n", - " 128 129 130 131 133 137 139 142 143 144 145 148 149 150 151 152 153 154\n", - " 156 158 161 163 164 166 167 168 169 170 172 173 174 175 176 177 180 182\n", - " 184 188 189 190 191 192 193 194 197 198]\n", - "group=\n", - "0 c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1\n", - "2 c1ccc2cc(CN[C@@H]3CCNC3)ccc2c1\n", - "3 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", - "5 c1ccc(CNC2CCNCC2)cc1\n", - "6 c1ccc(C2(COCc3ccccn3)CCNCC2)cc1\n", - " ... \n", - "192 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", - "193 c1ccc(Oc2ncccc2C2CCNCC2)cc1\n", - "194 c1ccc(Oc2ccccc2)cc1\n", - "197 c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CC...\n", - "198 c1ccc(C2[C@H]3CNC[C@@H]23)cc1\n", - "Name: scaffold_smiles, Length: 136, dtype: object\n", - "Test: index=\n", - "[ 1 4 7 10 12 16 17 18 19 21 23 26 28 29 30 37 42 45\n", - " 49 50 58 61 64 70 71 73 77 78 81 89 91 94 96 100 101 118\n", - " 126 127 132 134 135 136 138 140 141 146 147 155 157 159 160 162 165 171\n", - " 178 179 181 183 185 186 187 195 196 199]\n", - "group=\n", - "1 c1ccc(C2CNCc3ccncc32)cc1\n", - "4 c1cncc(OC[C@@H]2CCNC2)c1\n", - "7 c1ccc(CN2CCC(CCOC(c3ccccc3)c3ccccc3)CC2)cc1\n", - "10 c1ccc(-c2ccccc2CCCN2CCN(CC(c3ccccc3)N3CCNCC3)C...\n", - "12 C(=C/c1ccsc1)\\CN1CCN(C[C@@H]2ON=C3c4ccccc4OC[C...\n", - " ... \n", - "186 c1ccc(Oc2ccc3c(c2)CCS3)cc1\n", - "187 c1ccc([C@@H]2C[C@H]3CCC(N3)[C@@H]2c2ccccc2)cc1\n", - "195 c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1\n", - "196 c1ccc(OC(c2ccccc2)C2CCCNC2)cc1\n", - "199 c1ccc(C(c2ccccc2)c2ccncc2)cc1\n", - "Name: scaffold_smiles, Length: 64, dtype: object\n", - "Fold 1:\n", - "Train: index=\n", - "[ 0 1 3 4 5 6 7 8 9 10 12 13 14 15 16 17 18 19\n", - " 20 21 22 23 25 26 28 29 30 35 37 39 40 41 42 43 45 47\n", - " 49 50 52 53 54 55 56 57 58 59 61 64 69 70 71 72 73 74\n", - " 75 77 78 79 81 85 86 89 90 91 93 94 95 96 99 100 101 102\n", - " 103 104 106 108 114 115 118 119 120 122 123 126 127 128 129 130 131 132\n", - " 134 135 136 138 139 140 141 145 146 147 148 149 151 153 155 156 157 159\n", - " 160 162 165 166 170 171 176 177 178 179 180 181 183 185 186 187 189 190\n", - " 192 195 196 197 198 199]\n", - "group=\n", - "0 c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1\n", - "1 c1ccc(C2CNCc3ccncc32)cc1\n", - "3 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", - "4 c1cncc(OC[C@@H]2CCNC2)c1\n", - "5 c1ccc(CNC2CCNCC2)cc1\n", - " ... \n", - "195 c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1\n", - "196 c1ccc(OC(c2ccccc2)C2CCCNC2)cc1\n", - "197 c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CC...\n", - "198 c1ccc(C2[C@H]3CNC[C@@H]23)cc1\n", - "199 c1ccc(C(c2ccccc2)c2ccncc2)cc1\n", - "Name: scaffold_smiles, Length: 132, dtype: object\n", - "Test: index=\n", - "[ 2 11 24 27 31 32 33 34 36 38 44 46 48 51 60 62 63 65\n", - " 66 67 68 76 80 82 83 84 87 88 92 97 98 105 107 109 110 111\n", - " 112 113 116 117 121 124 125 133 137 142 143 144 150 152 154 158 161 163\n", - " 164 167 168 169 172 173 174 175 182 184 188 191 193 194]\n", - "group=\n", - "2 c1ccc2cc(CN[C@@H]3CCNC3)ccc2c1\n", - "11 c1ccc([C@H]2CC3CCC2CC3)cc1\n", - "24 c1ccc(CCCN2CCN(CCCN(c3ccccc3)c3ccccc3)CC2)cc1\n", - "27 c1ccc(CCN[C@H]2CC[C@@H](c3c[nH]c4ccccc43)CC2)cc1\n", - "31 c1ccc(C2OCc3ccccc32)cc1\n", - " ... \n", - "184 O=C(/C=C/c1ccccc1)N1CCN(CCOC(c2ccccc2)c2ccccc2...\n", - "188 c1ccc(CN2CCC(c3ccccc3)CC2)cc1\n", - "191 c1ccc2c(c1)CC(NCCCCn1ccc3ccccc31)CO2\n", - "193 c1ccc(Oc2ncccc2C2CCNCC2)cc1\n", - "194 c1ccc(Oc2ccccc2)cc1\n", - "Name: scaffold_smiles, Length: 68, dtype: object\n", - "Fold 2:\n", - "Train: index=\n", - "[ 1 2 4 7 10 11 12 16 17 18 19 21 23 24 26 27 28 29\n", - " 30 31 32 33 34 36 37 38 42 44 45 46 48 49 50 51 58 60\n", - " 61 62 63 64 65 66 67 68 70 71 73 76 77 78 80 81 82 83\n", - " 84 87 88 89 91 92 94 96 97 98 100 101 105 107 109 110 111 112\n", - " 113 116 117 118 121 124 125 126 127 132 133 134 135 136 137 138 140 141\n", - " 142 143 144 146 147 150 152 154 155 157 158 159 160 161 162 163 164 165\n", - " 167 168 169 171 172 173 174 175 178 179 181 182 183 184 185 186 187 188\n", - " 191 193 194 195 196 199]\n", - "group=\n", - "1 c1ccc(C2CNCc3ccncc32)cc1\n", - "2 c1ccc2cc(CN[C@@H]3CCNC3)ccc2c1\n", - "4 c1cncc(OC[C@@H]2CCNC2)c1\n", - "7 c1ccc(CN2CCC(CCOC(c3ccccc3)c3ccccc3)CC2)cc1\n", - "10 c1ccc(-c2ccccc2CCCN2CCN(CC(c3ccccc3)N3CCNCC3)C...\n", - " ... \n", - "193 c1ccc(Oc2ncccc2C2CCNCC2)cc1\n", - "194 c1ccc(Oc2ccccc2)cc1\n", - "195 c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1\n", - "196 c1ccc(OC(c2ccccc2)C2CCCNC2)cc1\n", - "199 c1ccc(C(c2ccccc2)c2ccncc2)cc1\n", - "Name: scaffold_smiles, Length: 132, dtype: object\n", - "Test: index=\n", - "[ 0 3 5 6 8 9 13 14 15 20 22 25 35 39 40 41 43 47\n", - " 52 53 54 55 56 57 59 69 72 74 75 79 85 86 90 93 95 99\n", - " 102 103 104 106 108 114 115 119 120 122 123 128 129 130 131 139 145 148\n", - " 149 151 153 156 166 170 176 177 180 189 190 192 197 198]\n", - "group=\n", - "0 c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1\n", - "3 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", - "5 c1ccc(CNC2CCNCC2)cc1\n", - "6 c1ccc(C2(COCc3ccccn3)CCNCC2)cc1\n", - "8 c1ccc2c(N3CCN(CCCc4csc5ccccc45)CC3)cccc2c1\n", - " ... \n", - "189 c1ccc2c(CCCN3CCN(CCCc4c[nH]c5ccccc45)CC3)c[nH]...\n", - "190 c1ccc2sc(C3CCN(CCCOc4cccc5occc45)CC3)cc2c1\n", - "192 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", - "197 c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CC...\n", - "198 c1ccc(C2[C@H]3CNC[C@@H]23)cc1\n", - "Name: scaffold_smiles, Length: 68, dtype: object\n" - ] - } - ], + "outputs": [], "source": [ "sgkf = StratifiedGroupKFold(n_splits=3, shuffle=True, random_state=42)\n", "for i, (train_index, test_index) in enumerate(sgkf.split(X, y, groups)):\n", @@ -602,139 +275,9 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Fold 0:\n", - "Train: index=\n", - "[ 0 1 3 5 6 8 9 11 12 15 16 17 19 20 21 23 26 27\n", - " 28 29 30 31 34 35 39 40 43 46 47 48 49 51 52 53 56 57\n", - " 59 60 61 62 63 64 65 68 71 72 73 74 75 76 77 78 79 80\n", - " 81 82 83 84 85 88 89 91 93 94 95 96 97 99 101 103 105 108\n", - " 109 110 114 115 116 118 119 121 122 123 124 126 129 131 132 133 134 135\n", - " 136 137 139 140 141 143 144 145 146 147 148 149 150 151 152 153 156 157\n", - " 159 160 162 163 164 165 166 167 169 171 172 173 174 176 177 178 180 186\n", - " 187 190 192 193 195 197 198]\n", - "group=\n", - "0 c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1\n", - "1 c1ccc(C2CNCc3ccncc32)cc1\n", - "3 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", - "5 c1ccc(CNC2CCNCC2)cc1\n", - "6 c1ccc(C2(COCc3ccccn3)CCNCC2)cc1\n", - " ... \n", - "192 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", - "193 c1ccc(Oc2ncccc2C2CCNCC2)cc1\n", - "195 c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1\n", - "197 c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CC...\n", - "198 c1ccc(C2[C@H]3CNC[C@@H]23)cc1\n", - "Name: scaffold_smiles, Length: 133, dtype: object\n", - "Test: index=\n", - "[ 2 4 7 10 13 14 18 22 24 25 32 33 36 37 38 41 42 44\n", - " 45 50 54 55 58 66 67 69 70 86 87 90 92 98 100 102 104 106\n", - " 107 111 112 113 117 120 125 127 128 130 138 142 154 155 158 161 168 170\n", - " 175 179 181 182 183 184 185 188 189 191 194 196 199]\n", - "group=\n", - "2 c1ccc2cc(CN[C@@H]3CCNC3)ccc2c1\n", - "4 c1cncc(OC[C@@H]2CCNC2)c1\n", - "7 c1ccc(CN2CCC(CCOC(c3ccccc3)c3ccccc3)CC2)cc1\n", - "10 c1ccc(-c2ccccc2CCCN2CCN(CC(c3ccccc3)N3CCNCC3)C...\n", - "13 c1ccc2c(c1)CCNC2CCc1c[nH]c2ccccc12\n", - " ... \n", - "189 c1ccc2c(CCCN3CCN(CCCc4c[nH]c5ccccc45)CC3)c[nH]...\n", - "191 c1ccc2c(c1)CC(NCCCCn1ccc3ccccc31)CO2\n", - "194 c1ccc(Oc2ccccc2)cc1\n", - "196 c1ccc(OC(c2ccccc2)C2CCCNC2)cc1\n", - "199 c1ccc(C(c2ccccc2)c2ccncc2)cc1\n", - "Name: scaffold_smiles, Length: 67, dtype: object\n", - "Fold 1:\n", - "Train: index=\n", - "[ 0 2 3 4 6 7 9 10 11 12 13 14 17 18 19 21 22 23\n", - " 24 25 26 28 29 31 32 33 34 36 37 38 40 41 42 44 45 47\n", - " 48 49 50 51 52 54 55 56 58 60 63 64 65 66 67 68 69 70\n", - " 71 75 78 79 80 81 85 86 87 90 92 98 99 100 102 104 106 107\n", - " 108 109 110 111 112 113 114 117 118 119 120 122 123 124 125 127 128 130\n", - " 132 134 135 138 139 141 142 143 144 145 146 147 148 150 154 155 158 159\n", - " 161 166 167 168 170 174 175 177 179 180 181 182 183 184 185 186 187 188\n", - " 189 191 192 194 195 196 197 199]\n", - "group=\n", - "0 c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1\n", - "2 c1ccc2cc(CN[C@@H]3CCNC3)ccc2c1\n", - "3 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", - "4 c1cncc(OC[C@@H]2CCNC2)c1\n", - "6 c1ccc(C2(COCc3ccccn3)CCNCC2)cc1\n", - " ... \n", - "194 c1ccc(Oc2ccccc2)cc1\n", - "195 c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1\n", - "196 c1ccc(OC(c2ccccc2)C2CCCNC2)cc1\n", - "197 c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CC...\n", - "199 c1ccc(C(c2ccccc2)c2ccncc2)cc1\n", - "Name: scaffold_smiles, Length: 134, dtype: object\n", - "Test: index=\n", - "[ 1 5 8 15 16 20 27 30 35 39 43 46 53 57 59 61 62 72\n", - " 73 74 76 77 82 83 84 88 89 91 93 94 95 96 97 101 103 105\n", - " 115 116 121 126 129 131 133 136 137 140 149 151 152 153 156 157 160 162\n", - " 163 164 165 169 171 172 173 176 178 190 193 198]\n", - "group=\n", - "1 c1ccc(C2CNCc3ccncc32)cc1\n", - "5 c1ccc(CNC2CCNCC2)cc1\n", - "8 c1ccc2c(N3CCN(CCCc4csc5ccccc45)CC3)cccc2c1\n", - "15 O=S1(=O)Nc2ccccc2N1c1ccccc1\n", - "16 O=C1NCc2ccc3c(c21)CC(NCCCc1c[nH]c2ccccc12)CO3\n", - " ... \n", - "176 c1ccc(C2CC3CCC(C2)N3)cc1\n", - "178 c1ccc(C2CNCc3ccncc32)cc1\n", - "190 c1ccc2sc(C3CCN(CCCOc4cccc5occc45)CC3)cc2c1\n", - "193 c1ccc(Oc2ncccc2C2CCNCC2)cc1\n", - "198 c1ccc(C2[C@H]3CNC[C@@H]23)cc1\n", - "Name: scaffold_smiles, Length: 66, dtype: object\n", - "Fold 2:\n", - "Train: index=\n", - "[ 1 2 4 5 7 8 10 13 14 15 16 18 20 22 24 25 27 30\n", - " 32 33 35 36 37 38 39 41 42 43 44 45 46 50 53 54 55 57\n", - " 58 59 61 62 66 67 69 70 72 73 74 76 77 82 83 84 86 87\n", - " 88 89 90 91 92 93 94 95 96 97 98 100 101 102 103 104 105 106\n", - " 107 111 112 113 115 116 117 120 121 125 126 127 128 129 130 131 133 136\n", - " 137 138 140 142 149 151 152 153 154 155 156 157 158 160 161 162 163 164\n", - " 165 168 169 170 171 172 173 175 176 178 179 181 182 183 184 185 188 189\n", - " 190 191 193 194 196 198 199]\n", - "group=\n", - "1 c1ccc(C2CNCc3ccncc32)cc1\n", - "2 c1ccc2cc(CN[C@@H]3CCNC3)ccc2c1\n", - "4 c1cncc(OC[C@@H]2CCNC2)c1\n", - "5 c1ccc(CNC2CCNCC2)cc1\n", - "7 c1ccc(CN2CCC(CCOC(c3ccccc3)c3ccccc3)CC2)cc1\n", - " ... \n", - "193 c1ccc(Oc2ncccc2C2CCNCC2)cc1\n", - "194 c1ccc(Oc2ccccc2)cc1\n", - "196 c1ccc(OC(c2ccccc2)C2CCCNC2)cc1\n", - "198 c1ccc(C2[C@H]3CNC[C@@H]23)cc1\n", - "199 c1ccc(C(c2ccccc2)c2ccncc2)cc1\n", - "Name: scaffold_smiles, Length: 133, dtype: object\n", - "Test: index=\n", - "[ 0 3 6 9 11 12 17 19 21 23 26 28 29 31 34 40 47 48\n", - " 49 51 52 56 60 63 64 65 68 71 75 78 79 80 81 85 99 108\n", - " 109 110 114 118 119 122 123 124 132 134 135 139 141 143 144 145 146 147\n", - " 148 150 159 166 167 174 177 180 186 187 192 195 197]\n", - "group=\n", - "0 c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1\n", - "3 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", - "6 c1ccc(C2(COCc3ccccn3)CCNCC2)cc1\n", - "9 c1ccc2c(c1)CCOC2CCN1CCC(c2c[nH]c3ccccc23)CC1\n", - "11 c1ccc([C@H]2CC3CCC2CC3)cc1\n", - " ... \n", - "186 c1ccc(Oc2ccc3c(c2)CCS3)cc1\n", - "187 c1ccc([C@@H]2C[C@H]3CCC(N3)[C@@H]2c2ccccc2)cc1\n", - "192 c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1\n", - "195 c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1\n", - "197 c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CC...\n", - "Name: scaffold_smiles, Length: 67, dtype: object\n" - ] - } - ], + "outputs": [], "source": [ "sgkf = StratifiedGroupKFold(n_splits=3, shuffle=False)\n", "for i, (train_index, test_index) in enumerate(sgkf.split(X, y, groups)):\n", @@ -749,77 +292,9 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "scaffold_smiles\n", - "c1ccc(CNc2c3c(nc4ccccc24)CCCC3)cc1 3\n", - "c1ccc(-c2cnc([C@H]3[C@@H](c4ccccc4)C[C@@H]4CC[C@H]3N4)s2)cc1 3\n", - "c1ccc(Cc2ccccc2)cc1 2\n", - "c1ccc(C2(COCc3ccccn3)CCNCC2)cc1 2\n", - "c1ccc(-c2cncc3c2CNCC3)cc1 2\n", - "c1ccc2c(C3CC3)cccc2c1 2\n", - "c1ccc(C2CCc3ccccc32)cc1 2\n", - "c1ccc(C2CCNCC2)cc1 2\n", - "c1ccc2c(C3CCCC3)c[nH]c2c1 2\n", - "C(#Cc1ccc(COc2ccccc2)cc1)CCN1CCCCC1 1\n", - "c1ccc([C@@H]2CC3CCC(N3)[C@@H]2c2ccccc2)cc1 1\n", - "c1ccc([C@H]2CC3CCC2CC3)cc1 1\n", - "c1ccc2c(c1)CCOC2CCN1CCC(c2c[nH]c3ccccc23)CC1 1\n", - "O=C(Nc1ccc(NC(=O)[C@H]2C3CCC(C[C@@H]2c2ccc(-c4ccsc4)cc2)N3)cc1)[C@@H]1C2CCC(C[C@@H]1c1ccc(-c3ccsc3)cc1)N2 1\n", - "C(=C/c1ccsc1)\\CN1CCN(C[C@@H]2ON=C3c4ccccc4OC[C@H]32)CC1 1\n", - "C(=C/c1ccccc1)\\CN1CCN(CCN(Cc2ccccc2)c2ccccn2)CC1 1\n", - "c1ccc2c(c1)CCN([C@H]1CC[C@H](c3c[nH]c4ccccc43)CC1)C2 1\n", - "c1ccc(C2OCc3ccccc32)cc1 1\n", - "C=C1C2CCC(C[C@@H]1OC(c1ccccc1)c1ccccc1)N2 1\n", - "c1ccc(CC[C@@H]2CCCO2)cc1 1\n", - "O=C(NCCCCN1CCN(c2ccccc2)CC1)c1c[nH]c(-c2ccccc2)c1 1\n", - "c1ccc(O[C@@H]2CCOc3ccccc32)cc1 1\n", - "c1ccc2c3c([nH]c2c1)[C@@H]1C[C@@H]2CC[C@@H]1N(CC3)C2 1\n", - "c1ccc(CCCCCN2C3CCC2CC(OC(c2ccccc2)c2ccccc2)C3)cc1 1\n", - "c1cc(N2CCN([C@H]3CC[C@@H](c4c[nH]c5ccccc54)CC3)CC2)c2cc[nH]c2c1 1\n", - "c1ccc(C2CNCc3cc(OCCCN4CCN(c5ccncc5)CC4)ccc32)cc1 1\n", - "c1ccc(CCNCCNCCOC(c2ccccc2)c2ccccc2)cc1 1\n", - "C(COC(c1ccccc1)c1ccccc1)=C1CC2CCC(C1)N2CCCc1ccccc1 1\n", - "O=C(OCCc1ccccc1)[C@@H]1C2CCC(C[C@@H]1OC(c1ccccc1)c1ccccc1)N2 1\n", - "c1cnc2c(N3CCN(CCCc4csc5ccccc45)CC3)cccc2c1 1\n", - "O=C1OC2(CCC(N3CCC(Cc4ccccc4)CC3)CC2)c2ccc3c(c21)OCO3 1\n", - "c1ccc(C2CC2)c(CN[C@H]2CCNC2)c1 1\n", - "c1ccc(C(OCCN2CC3CCC(C2)N3)c2ccccc2)cc1 1\n", - "c1ccc(C2CNCc3cc(OCC4CCNCC4)ncc32)cc1 1\n", - "C=C(c1ccccc1)c1cccnc1 1\n", - "c1ccc2c(c1)CC(NCCCCc1c[nH]c3ccccc13)CO2 1\n", - "C(=[SH]Cc1ncno1)C1CNCCC1c1ccccc1 1\n", - "O=C(NCCN1CCN(c2ccccc2)CC1)c1c[nH]c(-c2ccccc2)c1 1\n", - "C(#Cc1ccc(Oc2ccccc2)cc1)CCN1CCCCC1 1\n", - "c1ccc(COC2(c3ccccc3)CNC2)cc1 1\n", - "c1ccc2c(c1)CCN2 1\n", - "O=C(NCCCN1CCN(c2ccccc2)CC1)c1cn(C2CCCC2)cn1 1\n", - "C(=C/c1ccccc1)\\CN1CCN(C[C@@H]2ON=C3c4ccccc4NC[C@H]32)CC1 1\n", - "O=C1CCc2c(CCN3CCN(c4cccc5ncccc45)CC3)cccc2N1 1\n", - "c1ccc(CN[C@@H]2CC[C@H](C(c3ccccc3)c3ccccc3)NC2)cc1 1\n", - "O=c1c2ccccc2[nH]c2ccccc12 1\n", - "c1ccc(Cc2cc([C@@H]3C4CCC(C[C@@H]3c3ccccc3)N4)on2)cc1 1\n", - "c1ccc(O[C@H]2CCc3ccccc32)cc1 1\n", - "c1ccc2c(CCCCNCCOc3cccc4[nH]ccc34)c[nH]c2c1 1\n", - "O=C1COc2ccc(CCCCN3CCN(c4cccc5ncccc45)CC3)cc2N1 1\n", - "c1ccc(CCN2CCN(c3cccc4ncccc34)CC2)cc1 1\n", - "c1ccc(OC(c2ccccn2)[C@H]2CCNC2)cc1 1\n", - "c1ccc(Oc2ccc3c(c2)CCS3)cc1 1\n", - "c1ccc([C@@H]2C[C@H]3CCC(N3)[C@@H]2c2ccccc2)cc1 1\n", - "c1ccc(-c2nnn(Cc3ccc4ccccc4c3)n2)cc1 1\n", - "c1cnn(-c2ccc([C@@H]3CN4CCC[C@@H]4c4cc(OCCCN5CCOCC5)ccc43)cc2)c1 1\n", - "Name: count, dtype: int64" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "groups[test_index].value_counts()" ] @@ -833,7 +308,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -846,45 +321,9 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(array([0, 1, 2]), array([340, 326, 334]))\n", - "[np.float64(0.34), np.float64(0.32625), np.float64(0.33375)]\n", - "[np.float64(0.34), np.float64(0.325), np.float64(0.335)]\n", - "(array([0, 1, 2]), array([68, 65, 67]))\n", - "800 200\n", - "[np.float64(0.34), np.float64(0.32625), np.float64(0.33375)]\n", - "[np.float64(0.34), np.float64(0.325), np.float64(0.335)]\n", - "(array([0, 1, 2]), array([68, 65, 67]))\n", - "800 200\n", - "[np.float64(0.34), np.float64(0.32625), np.float64(0.33375)]\n", - "[np.float64(0.34), np.float64(0.325), np.float64(0.335)]\n", - "(array([0, 1, 2]), array([68, 65, 67]))\n", - "800 200\n", - "[np.float64(0.34), np.float64(0.32625), np.float64(0.33375)]\n", - "[np.float64(0.34), np.float64(0.325), np.float64(0.335)]\n", - "(array([0, 1, 2]), array([68, 65, 67]))\n", - "800 200\n", - "[np.float64(0.34), np.float64(0.32625), np.float64(0.33375)]\n", - "[np.float64(0.34), np.float64(0.325), np.float64(0.335)]\n", - "(array([0, 1, 2]), array([68, 65, 67]))\n", - "800 200\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/peptid/uv_venvs/scikit_mol_cedenoruel/lib/python3.11/site-packages/sklearn/model_selection/_split.py:2425: UserWarning: The groups parameter is ignored by StratifiedShuffleSplit\n", - " warnings.warn(\n" - ] - } - ], + "outputs": [], "source": [ "sss = StratifiedShuffleSplit(n_splits=5, test_size=0.2)\n", "print(np.unique(y,return_counts=True))\n", @@ -898,48 +337,9 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(array([0, 1, 2]), array([340, 326, 334]))\n", - "(array([0, 1, 2]), array([340, 326, 334]))\n", - "Train: (array([0, 1, 2]), array([215, 230, 221]))\n", - "Test: (array([0, 1, 2]), array([125, 96, 113]))\n", - "Train groups: (array([0, 1]), array([340, 326]))\n", - "Test groups: (array([2]), array([334]))\n", - "666 334\n", - "0\n", - "Train: (array([0, 1, 2]), array([223, 228, 223]))\n", - "Test: (array([0, 1, 2]), array([117, 98, 111]))\n", - "Train groups: (array([0, 2]), array([340, 334]))\n", - "Test groups: (array([1]), array([326]))\n", - "674 326\n", - "0\n", - "Train: (array([0, 1, 2]), array([215, 230, 221]))\n", - "Test: (array([0, 1, 2]), array([125, 96, 113]))\n", - "Train groups: (array([0, 1]), array([340, 326]))\n", - "Test groups: (array([2]), array([334]))\n", - "666 334\n", - "0\n", - "Train: (array([0, 1, 2]), array([242, 194, 224]))\n", - "Test: (array([0, 1, 2]), array([ 98, 132, 110]))\n", - "Train groups: (array([1, 2]), array([326, 334]))\n", - "Test groups: (array([0]), array([340]))\n", - "660 340\n", - "0\n", - "Train: (array([0, 1, 2]), array([242, 194, 224]))\n", - "Test: (array([0, 1, 2]), array([ 98, 132, 110]))\n", - "Train groups: (array([1, 2]), array([326, 334]))\n", - "Test groups: (array([0]), array([340]))\n", - "660 340\n", - "0\n" - ] - } - ], + "outputs": [], "source": [ "# groups are splitted, stratification is not granted, exact test_size is not respected, fails quite miserably for imbalanced data\n", "sss = GroupShuffleSplit(n_splits=5, test_size=0.2)\n", @@ -957,47 +357,9 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(array([0, 1, 2]), array([340, 326, 334]))\n", - "Train counts: (array([0, 1, 2]), array([242, 194, 224]))\n", - "Test counts: (array([0, 1, 2]), array([ 98, 132, 110]))\n", - "Groups train counts: (array([1, 2]), array([326, 334]))\n", - "Groups test counts: (array([0]), array([340]))\n", - "660 340\n", - "0\n", - "Train counts: (array([0, 1, 2]), array([215, 230, 221]))\n", - "Test counts: (array([0, 1, 2]), array([125, 96, 113]))\n", - "Groups train counts: (array([0, 1]), array([340, 326]))\n", - "Groups test counts: (array([2]), array([334]))\n", - "666 334\n", - "0\n", - "Train counts: (array([0, 1, 2]), array([223, 228, 223]))\n", - "Test counts: (array([0, 1, 2]), array([117, 98, 111]))\n", - "Groups train counts: (array([0, 2]), array([340, 334]))\n", - "Groups test counts: (array([1]), array([326]))\n", - "674 326\n", - "0\n", - "Train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", - "Test counts: (array([], dtype=int64), array([], dtype=int64))\n", - "Groups train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", - "Groups test counts: (array([], dtype=int64), array([], dtype=int64))\n", - "1000 0\n", - "0\n", - "Train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", - "Test counts: (array([], dtype=int64), array([], dtype=int64))\n", - "Groups train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", - "Groups test counts: (array([], dtype=int64), array([], dtype=int64))\n", - "1000 0\n", - "0\n" - ] - } - ], + "outputs": [], "source": [ "sss = StratifiedGroupKFold(n_splits=5)\n", "groups_counts = np.unique(groups, return_counts=True)\n", @@ -1014,47 +376,9 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(array([0, 1, 2]), array([340, 326, 334]))\n", - "Train counts: (array([0, 1, 2]), array([242, 194, 224]))\n", - "Test counts: (array([0, 1, 2]), array([ 98, 132, 110]))\n", - "Groups train counts: (array([1, 2]), array([326, 334]))\n", - "Groups test counts: (array([0]), array([340]))\n", - "660 340\n", - "0\n", - "Train counts: (array([0, 1, 2]), array([215, 230, 221]))\n", - "Test counts: (array([0, 1, 2]), array([125, 96, 113]))\n", - "Groups train counts: (array([0, 1]), array([340, 326]))\n", - "Groups test counts: (array([2]), array([334]))\n", - "666 334\n", - "0\n", - "Train counts: (array([0, 1, 2]), array([223, 228, 223]))\n", - "Test counts: (array([0, 1, 2]), array([117, 98, 111]))\n", - "Groups train counts: (array([0, 2]), array([340, 334]))\n", - "Groups test counts: (array([1]), array([326]))\n", - "674 326\n", - "0\n", - "Train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", - "Test counts: (array([], dtype=int64), array([], dtype=int64))\n", - "Groups train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", - "Groups test counts: (array([], dtype=int64), array([], dtype=int64))\n", - "1000 0\n", - "0\n", - "Train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", - "Test counts: (array([], dtype=int64), array([], dtype=int64))\n", - "Groups train counts: (array([0, 1, 2]), array([340, 326, 334]))\n", - "Groups test counts: (array([], dtype=int64), array([], dtype=int64))\n", - "1000 0\n", - "0\n" - ] - } - ], + "outputs": [], "source": [ "sss = StratifiedGroupKFold(n_splits=5, shuffle=True, random_state=65)\n", "groups_counts = np.unique(groups, return_counts=True)\n", @@ -1078,7 +402,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -1192,6 +516,34 @@ " train_indices = np.setdiff1d(all_indices, test_indices, assume_unique=True)\n", " \n", " yield train_indices, test_indices\n", + " \n", + " def split(self, X, y, groups=None):\n", + " \"\"\"Generates indices to split data into training and test set.\n", + "\n", + " Parameters\n", + " ----------\n", + " X : array-like of shape (n_samples, n_features)\n", + " Training data, where `n_samples` is the number of samples\n", + " and `n_features` is the number of features.\n", + "\n", + " y : array-like of shape (n_samples,), optional\n", + " The target variable for supervised learning problems.\n", + " Stratification is done based on the y labels.\n", + "\n", + " groups : array-like of shape (n_samples,), optional\n", + " Group labels for the samples used while splitting the dataset into\n", + " train/test set. Each group will be kept together in either the\n", + " train set or the test set.\n", + "\n", + " Yields\n", + " ------\n", + " train : ndarray\n", + " The training set indices for that split.\n", + "\n", + " test : ndarray\n", + " The testing set indices for that split.\n", + " \"\"\"\n", + " yield from self._iter_indices(X, y, groups)\n", "\n", " def get_n_splits(self, X=None, y=None, groups=None):\n", " return self.n_splits\n" @@ -1199,7 +551,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -1209,12 +561,16 @@ "\n", "==================== Running Test: BALANCED Dataset ====================\n", "\n", + "Checking if indices are reproducible with the same random state\n", + "SUCCESS: Train indices are reproducible.\n", + "SUCCESS: Test indices are reproducible.\n", + "\n", "Checking for group overlap...\n", "SUCCESS: No overlapping groups found between train and test sets.\n", "\n", "Dataset Sizes and Ratios:\n", - " - Train set size: 7008 (70.08%)\n", - " - Test set size: 2992 (29.92%)\n", + " - Train set size: 7031 (70.31%)\n", + " - Test set size: 2969 (29.69%)\n", "\n", "Class Distribution Ratios:\n", " - Full Dataset:\n", @@ -1223,22 +579,22 @@ " - Class 2: 25.00%\n", " - Class 3: 25.00%\n", " - Train Set:\n", - " - Class 0: 25.07%\n", - " - Class 1: 24.97%\n", - " - Class 2: 24.91%\n", - " - Class 3: 25.04%\n", + " - Class 0: 25.03%\n", + " - Class 1: 25.05%\n", + " - Class 2: 24.90%\n", + " - Class 3: 25.02%\n", " - Test Set:\n", - " - Class 0: 24.83%\n", - " - Class 1: 25.07%\n", - " - Class 2: 25.20%\n", - " - Class 3: 24.90%\n", + " - Class 0: 24.92%\n", + " - Class 1: 24.89%\n", + " - Class 2: 25.23%\n", + " - Class 3: 24.96%\n", "\n", "Generating class distribution histograms...\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABv4AAAHgCAYAAABtiBpNAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAdhdJREFUeJzs3Xd4FGX79vEzdZNACi0JkRaC9CY99BIIRWpEikgoiiWgiIryPEpVEVQQpSlKU/hZAQWRXqQqvQkISFEhgEASagjJ/f6RN/uwJKGEJBs2389x7HGwM/fMXrM7u7nYc2fGyRhjBAAAAAAAAAAAAOCB5mzvAgAAAAAAAAAAAADcP4I/AAAAAAAAAAAAwAEQ/AEAAAAAAAAAAAAOgOAPAAAAAAAAAAAAcAAEfwAAAAAAAAAAAIADIPgDAAAAAAAAAAAAHADBHwAAAAAAAAAAAOAACP4AAAAAAAAAAAAAB0DwBwAAAAAAAAAAADgAgj8AAIAHwPLly9W7d2+VLl1aPj4+slgsKly4sJo3b67x48fr7NmzNuNnzpwpJycn9erVyz4FZ5Jjx47JycnJ5ubi4iI/Pz+VLFlSbdu21TvvvKPjx4/fdj0py+YEKdtUokSJVPNyUp0pSpQoIScnJx07dszepdyVX3/9Vc8995wqVKggPz8/ubu7y9/fX40aNdJbb72lEydO2LvEB05O3C8zy0svvSRnZ2dt3brVZnqvXr1SffY4OTnJw8NDISEh6tOnj/bu3ZuptTRu3FhOTk5as2ZNpq73QZWRz560XjdPT08FBASoZs2a6tevn3788UfduHEj6wp3UE899ZRcXV21Z88ee5cCAACAOyD4AwAAyMH+/fdfNW/eXC1atNDMmTOVkJCgJk2aKCIiQuXKldPGjRs1aNAglSxZUr/++qu9y81SERERioyM1JNPPqlmzZopMDBQK1as0H//+18FBwfr2Wef1aVLl7Ls8W8X2D2oUr4knzlzpr1LuW9XrlxR9+7dVadOHU2dOlXnz59X/fr11blzZz3yyCPavXu33nzzTT388MNasGCBvctFDrB//35NnDhRERERqlGjRppjQkJCFBkZab2FhYXp8uXLmjFjhqpVq6aFCxdmc9W4Gze/bimv75kzZzRt2jS1b99epUqV0sqVKzP1MR+0H0ncbM2aNXJyclLjxo3THTN8+HC5ubnphRdeyL7CAAAAkCGu9i4AAAAAaYuNjVX9+vV18OBBlS1bVp9++qkaNGhgMyY+Pl6zZs3SsGHDdOrUKTtVmj3ef//9VKHb1atXNWPGDL3++uv65JNP9Pvvv2v58uWyWCw24/bv35+Nld7eQw89pP3798vNzc3epdyVlStXKiEhQQ899JC9S0lXQkKCwsPDtX79ehUuXFhTp05Vu3btbMbcuHFD8+fP13/+858H8ot5e8pJ75/M9Oqrr+rGjRsaPnx4umPq16+fKhi/du2aIiMj9c033+jpp5/W33//LVdX/mudk6T1uknSrl279Prrr2vJkiUKDw/X/Pnz1bZt2+wv8AFUpEgRPfXUU5o4caJ+/PHHVJ+xAAAAyDk44g8AACCHGjBggA4ePKgSJUpow4YNqUI/SbJYLOrXr5927typcuXK2aFK+/L09NTzzz+vNWvWyMPDQ+vWrdPYsWNTjStbtqzKli1rhwpTc3NzU9myZRUSEmLvUu5KSEiIypYtm6ODylGjRmn9+vXy8/PThg0b0vxC2tXVVZ07d9aOHTvUqFEjO1T54MpJ75/M8scff2jx4sWqU6eOKlSocE/Lenh46O2335YknT59Wvv27cuKEpEFqlSposWLF6tLly5KTExUZGSk4uLi7F3WA6Nv376SpA8//NC+hQAAAOC2CP4AAAByoD///FNz586VJI0bN0758+e/7fiAgACVKVPmrtY9b948PfXUU6pYsaLy5csnDw8PBQcHq0+fPjp48GCay8THx+u9995T9erV5e3tLXd3dwUGBqpmzZoaPHiwzp8/bzP+0KFD6tOnj4KDg2WxWJQ3b14VL15cbdq00YwZM+6qzntRrVo1DRgwQJI0fvz4VNdvSu8aZadOndKLL76o0qVLy8PDQ15eXipatKiaNWum999/3zquV69eCg4OliQdP3481TWkUgwfPlxOTk4aPny4Tpw4ob59+6po0aJyc3OzXm/xbk8ZOm3aNFWvXl158uSRn5+fWrdurc2bN6c59k7XYLv12mEpNcyaNUuS1Lt3b5vtufkIqNudvu7KlSt69913Va1aNXl7e8vLy0sVKlTQG2+8oQsXLqQaf/O2G2P06aefWrfR19dXLVq00KZNm277vNzq4sWLmjBhgiRp6NCh1tcpPXnz5tUjjzySavrSpUv16KOPyt/fX+7u7goKClKXLl1SXfstxc3P6ebNm9WmTRsVKFBA3t7eatSokdatW2cdu2TJEjVr1kz58uVT3rx51bx5c23fvj3VOm9+fm7cuKGxY8eqQoUK8vT0VMGCBfX444/rwIEDadbz22+/afDgwapVq5YCAwPl7u6ugIAAtW3bVitWrEhzmZuvBXr+/HkNHDhQISEhslgsNqf8u9/3z611Pv744woKCrJef7Ft27Zavnx5muNvPh3t0aNH9eSTTyowMFAWi0UhISF64403FB8fn+aytzNp0iQZYzJ8HdTAwEDrv2/9vLl48aKmTZumTp066eGHH1aePHmUJ08eVapUSf/9738VExNzT4919uxZffTRR2rdurWCg4Pl6ekpHx8f1ahRQ2PGjNG1a9fSXO7m1+37779X/fr15ePjozx58qhevXpavHhxuo9548YNTZ8+XWFhYSpYsKAsFouKFCmisLAwffzxx2kus3LlSnXq1EmFCxe2vrYdO3a87Xv6999/V+fOnVWwYEF5enqqYsWKev/995WYmHgPz9C9cXJy0qRJk+Tp6akLFy5o2rRpNvPv9flOeR+lXGs2ODjY5vP05ms2ZsffXyn5aPgPPvhAderUkZ+fnzw8PFSmTBkNHjxY586dsxnbuHFjNWnSRJK0du1am9pv/TtVtWpVValSRatXr3bYI4EBAAAcggEAAECOM2HCBCPJ+Pn5mRs3btzz8jNmzDCSTGRkZKp5Li4uxsvLy9SoUcN06tTJtGvXzpQsWdJIMnny5DEbNmywGZ+YmGiaNWtmJBkfHx/TqlUr061bNxMWFmaKFy9uJJkdO3ZYx+/Zs8f4+PgYSaZMmTKmU6dOpnPnziY0NNTkzZvXVKlS5a634+jRo0aSkWSOHj1627G7du2yjt20aZPNvJTpNzt16pQJCgoykkyxYsVM+/btTZcuXUyDBg1M/vz5ja+vr3XstGnTTEREhPU5ioyMtLmlGDZsmJFkunfvbvLnz28CAwNNRESE6dSpk3n55Zdttql48eKptiGlzpdeesk4OTmZ+vXrm27dupmKFSsaScbV1dXMmzcv3eXS06hRIyPJrF692hhjzNmzZ01kZKQJCQkxkky9evVstmf+/PnWZVNe41uf/3PnzpmqVata94t27dqZiIgIU7BgQSPJBAcHp1rm5m2PjIw0bm5upmnTpubxxx83pUuXNpKMxWIxmzdvTndbbvXDDz8YScbJycn8+++/d73czd544w3rOurVq2e6detm3TYXFxfz+eefp1om5Tl95ZVXjKurq3nkkUdMly5drMtZLBazYcMGM3HiROPs7Gzq1q1rs5158+Y1hw4dSvf56dSpk3FzczNhYWGma9eu1vdo3rx5zcaNG1PV06xZM+Ps7GwqVapkWrdubTp37myqVatm3Tc+/PDDVMukfE60adPGBAcHm3z58pl27dqZzp07myeeeMI67n7fPyk+/fRT4+zsbCSZRx55xHTr1s3UrVvXuv7hw4enWiYyMtJIMi+++KLx8fExxYsXN48//rgJCwsznp6eRpLp0KFDuq9teooVK2YkmcOHD6c5P+Vx0/oMNcaYlStXGknG3d3dxMTE2Mxbt26dkWQKFSpk6tevb7p06WJatGhhChQoYCSZUqVKpbmv3vo+TfHFF18YSeahhx4yjRo1Ml27djXNmjUzefPmNZJMaGiouXbtWqr1pTyvQ4cOte7bXbp0MVWqVLHu72l9nsTExJj69esbScbNzc00atTIdOvWzTRp0sQUKlQozc+al19+2Ugyzs7OplatWqZz586mdu3axsnJybi4uJjp06enWmbdunUmT548RpIpWbKk6dq1qwkLCzNubm4mIiIi3c+e27nT63azjh07GkkmPDzcZvq9Pt/r1q0zkZGR1m2JiIiw+Tzdv3+/dWxW//01xph//vnHVKpUyUgy+fPnN2FhYaZjx47W8SVKlDDHjh2zjh89erQJDw83kkxAQIBN7Sl/t272yiuvGEnmnXfeueNzDAAAAPsg+AMAAMiBnnzySSPJNG3aNEPL3y74++qrr8ylS5dspiUlJZlJkyYZSaZChQomKSnJOm/t2rXWL+rj4uJSrW/Lli02X2L37t3bSDJvvfVWqrFXrlwxa9euvevtuJfgLzEx0bi7uxtJ5rPPPrOZl1ZwMWLECCPJ9OvXz2Z7jTHm+vXrZsWKFWnWklZglyIl+JNkevTokeaX8XcT/Hl6epqVK1fazBs7dqyRZHx9fc3p06fvuH03Sy9QSPmSfMaMGekum96X7126dDGSTO3atW1e/4sXL5pWrVoZSaZu3bppbnvK9h88eNA678aNG6ZPnz5GkmnRokW69dzqzTfftAYHGfHzzz8bScbDw8MsW7bMZt5nn31mDT/27t1rMy/lOXVycjJffPGFzbxBgwZZg++8efPa7Es3btywhshPPfWUzXI3Pz8FCxY0u3btslluwIAB1ufu1n1r8eLF5uTJk6m2b+PGjcbHx8e4ubmZv//+22ZeyueEJNOsWTMTGxub5nOUGe+f3bt3G1dXV+Pk5GRmz56dqvaU9+6tr0HKPirJ/Pe//7X5IcSePXusYUtaYWh6Dh8+bA3m0pNegPTvv/+aH374wZQoUcJIMq+99lqqZf/66y+zYsUKk5iYaDP98uXLpmfPnkaSef7551Mtl9779Pfff0/1YwZjjDl//rxp0aKFkWTGjh2ban7K8+bn55cqTE/5rCpdunSq5Tp16mT9zL/1fZ+QkGAWLFhgM+3TTz+1Bpo377PGJP/98Pb2Nu7u7uaPP/6wTr969aopWrSokWQGDhxo87ru2rXL+gOCrAz+3nrrLSPJFClSxGZ6Rp/vuwkqs/rvb1JSkqlXr56RZPr27WuzTEJCgjWgbdKkic16Vq9ebSSZRo0apVt7innz5lk/MwAAAJAzEfwBAADkQC1btjSSTNeuXTO0/O2Cv9sJDQ01ksy+ffus07755hsjybzwwgt3tY7WrVsbSWb79u339NhpuZfgzxhjAgMDjSQzZswYm+lpBRfPP/+8kZTmES+3q+Vugr/8+fOnOgrobtaTUufAgQPTXLZGjRpGknn77bfTXC49mR38HT9+3Dg7OxsnJ6dUX/QbY8zff/9tPDw8jCSbI1hufj1//PHHVMudOnXKSMlHy12/fj3dmm727LPPGkmmTp06dzX+VilH0wwaNCjN+Y8++qiRZJ5++mmb6SnPaefOnVMtc+7cOet2vvrqq6nmb9u2zUjJR0Xe7ObnJ60j9K5du2YeeughI8nMmTPnrrdxyJAhRpKZNGmSzfSUzwk3Nzdz5MiRdJfPjPdP3759jSTTqVOnNOf379/fSDLNmze3mZ6yj1avXj1VwGjM/17/kSNH3lUdxhjz7bffGkmmYcOG6Y65OXBM6xYYGGhmzZp114+Z4vLly8bV1TXN0DG99+ntHDx40EgyNWvWTDUvpdaPPvoo1bxr164ZX19fI8mcOHHCOn3nzp3WIPzWoDgtiYmJ1iM/t27dmuaYlB8t3Hz02JdffmkkmaJFi6b5Xh8/fnyWB39Tp061/tDibt3u+c7IEYo3y4y/vyk/ZKhatapJSEhINT8xMdF6BPmePXus0+8l+Et5DvLly3dXNQEAACD7uQoAAAC5zuHDh7VkyRIdPnxYFy9etF5P6fTp05KkgwcPqnz58pKSr5/n4uKi6dOnq3Tp0tZrOKWnVq1aWrx4sZ577jmNGDFCjRo1koeHR9ZvlKSkpCRJuu317lLUqlVLkydP1uuvvy5jjFq0aKG8efNmSh1hYWHy9fXN8PKRkZFpTu/Zs6e2bt2qNWvW6D//+U+G13+/fvnlFyUlJalatWqqXLlyqvkPPfSQwsPD9cMPP2j16tWqW7euzXxXV1e1bNky1XKBgYHKly+fLly4oHPnztlcRy0r3LhxQxs2bJCkdK/11rdvXy1atEirV69Oc37r1q1TTcufP78KFCigc+fOpTn/4YcfliSdPHky3drS2gcsFou6dOmicePGac2aNerevbvN/HPnzumnn37S3r17deHCBSUkJEhKvuampHSvIfbII4+oZMmS6daSlnt9/6Rc5+x2z/PEiRO1bt06JSYmysXFxWb+o48+mub7uly5cpKkf/75565rT/mcK1CgwB3HhoSEqH79+tb7ly5d0h9//KE9e/ZoyJAhKliwYJqvsSRt3LhR69at04kTJ3TlyhUZYyRJ7u7uOnv2rC5cuKB8+fLdVc2JiYlas2aNNm7cqFOnTunq1asyyT/klZT+aytJbdu2TTXNYrGoZMmS2rFjh/755x8VLVpUUvL1KCWpTZs2euihh+5Y144dO3Ty5EmFhISoevXqaY5JuV7kxo0brdNS9ofHH39cbm5uqZaJjIzUSy+9dMfHvx+3+3txP8/3nWTl39+ffvpJkhQRESFX19Rf9zg7O6thw4bau3evNm7cqIoVK95z/SnvmwsXLuj69etyd3e/53UAAAAgaxH8AQAA5ECFChWSJJ05cyZT15uYmKj+/fvrk08+sX6BmZa4uDjrv0NCQjR+/Hi9+uqr6t+/v/r376/ixYsrNDRUjz76qDp37mzzxd+rr76q9evXa8WKFWrZsqXc3NxUpUoVNWzYUF27dlXNmjUzdZtu3raYmBhJycHLnTz55JNavny55syZo4iICLm4uKh8+fKqX7++HnvsMTVt2jTDtZQoUSLDy0pScHDwbaf//fff97X++5USsqRXp5S839w89maFCxdO88t+SfLx8dGFCxd07dq1u6rlft4r586dsz5Oettyu+2QpGLFiqU5PW/evDp37lya8729vSVJ8fHxaS7r5+cnPz+/NOeltw9MmzZNL730ki5fvpzmcpLt+/pmGdlf7/X9c6d9JuV5vnbtms6dOyd/f3+b+ek9zz4+Ptbl7lZsbKzNsrdTv359zZw5M9X0H3/8UZ06dVLbtm21adMm1apVyzrvzJkzioiI0Pr162+77ri4uLsK/g4dOqSOHTtq3759t11Xeu7luTt+/LgkqWzZsnesS5L+/PNPSdKRI0fu+IOLs2fPWv+dsv+mtz/ky5dPvr6+1tcqK/z777+SUv+9uN/nOz3Z8fc35fV488039eabb962nptfj3tx8/smJiYm1XsVAAAA9uds7wIAAACQWsqRE9u3b7ceDZAZJkyYoKlTpyogIEBz587VsWPHbI5k6NatmySl+lJywIABOn78uD799FP17NlTLi4u+uqrr9SjRw+VL19ep06dso718vLS8uXL9dtvv2nkyJFq1qyZ/vjjD40bN061atVSVFRUpm3Pzfbu3avr169LkipVqnTH8c7Ozvryyy+1b98+jR07Vo8++qhOnTqlKVOmqFmzZmrXrl2Gn3tPT88MLXe3bvelcVpSjmzJKZydM++/ISnvlaNHj+rcuXOZtt67dadtycxtvdnN+8C2bdv0zDPPKD4+XmPGjNHvv/+uS5cuKSkpScYYffLJJ6mWuVlG9tesfP+k93iZJSVUzUh4k6Jdu3Zq3769kpKS9N5779nMe+qpp7R+/XqFhoZq2bJlOn36tK5fv279nE05Yutu38ePPfaY9u3bp0cffVS//PKL/v33X+v60guPb5ZV+6D0v8+WwMBARUZG3vbWvn37LKsjI7Zv3y4p9d+L+32+05Mdf39TXo/69evf8fWoUKFChrbj5jD2bo9YBQAAQPbiiD8AAIAc6NFHH9WgQYMUExOjH3/8UR07dsyU9X7zzTeSpE8++UTt2rVLNT/llIBpCQgI0NNPP62nn35aknTgwAH16dNHmzZt0uuvv65Zs2bZjK9Zs6b16L4bN25owYIF6tmzpyZPnqzHHntMTZo0yZRtSvHll19KSj4NWXqnnEtL+fLlVb58eb366qsyxmjVqlXq3r27Fi5cqNmzZ6t3796ZWufdOHr0qKpWrZpq+rFjxyRJRYoUsZnu5uamhIQEXbx40Xo02c1SjuLJLCmnAEw5uiQtKfPu5nSB96NJkyby9vbWxYsXNXv27Hs6PWCBAgVksVgUHx+vP//8M83TlmbXdtwsJiZGMTExaR71l9Y+8O2338oYowEDBmjw4MGplrnd+/p+3e3756GHHtKRI0f0559/pnl6wZTn2cPD466O2L0fKUco3W9QnHJ61P3791unXb58WYsXL5azs7MWL16c6jW8fPmyoqOj7/oxDhw4oN27d8vf31/z589PdfrGzH5tU44OPHDgwF2NTzlFaIECBdI8MjI9Ke+nlP35VjExMVl+tN/SpUslSS1atLBOz8rnOzv+/qa8Hu3bt9crr7yS4VpvJ+V9ky9fvnSP3AYAAIB9ccQfAABADhQSEmL99f/LL7+s8+fP33b8mTNn7uqaQynrKV68eKp5+/bt086dO++6xrJly+q1116TpDsu5+rqqscee0zh4eF3Nf5ebd++XRMnTpQkDRo0KNX1we6Wk5OTmjVrZr122s11ppxO7caNG/dX7F344osvbjs95ZpZKVK+RL85gEixe/du/fXXX2muL6Pb1LBhQzk7O2vnzp3atWtXqvmnTp2yXissswPeW/n4+OiFF16QJI0cOVJHjx697fhLly5px44dkpL3y5Trt6UXWkyfPl1S1m/HrdLaB65fv66vv/5aku0+cLv39bVr1/T9999nTZG3uN37J6XeOz3PDRo0SPPaZJmpWrVqktJ+v9yLI0eOSJLNtQ1jY2OVmJgoHx+fNIPbL7/88p6O2E15bYOCgtJ8XlJ+8JBZUq69uXjx4ttegzJFzZo1VbBgQf3++++3PTXmrRo1aiQpOQxLuRblzWbPnn3X67pXxhj1799fV69eVf78+dW3b1/rvPt5vu/0eZodf39btWol6X8/Brhb9/K3YO/evZJ0Tz+wAQAAQPYi+AMAAMihPv74Y5UqVUpHjx5V/fr107xe1PXr1zV9+nQ98sgjd/Uldrly5SRJkyZNsjn946lTp9SzZ880v/RbtWqVFi9enOrLWWOMFi1aJMn2i8zJkyenGUJGR0dr69atqcbfj6tXr2rKlClq3Lixrl27psaNG9/1UQ6zZ8/Wtm3bUk2/ePGi1qxZk6rOQoUKyd3dXdHR0XcMYu/XlClTrDWkGD9+vH777Td5e3vbfFEtSWFhYZKkESNG2JyK7tixY4qMjEz3C+CUo8bu5Qt7KfmooM6dO8sYo2eeecbmyKnLly+rX79+unbtmurWrau6deve07ozYujQoapbt65iYmJUv359LVy4MNWYxMREzZ8/X9WrV9fatWut019++WVJyc/5ypUrbZaZOXOmfvzxR7m5uenFF1/M2o24xahRo6xfsEvJp/B77bXX9Pfff6to0aKKiIiwzkt5X8+aNUsXL160Tr927Zqef/75O4ahGXGv758XX3xRrq6uWrBgQarwZNmyZdbTkWbVUUo3K1mypIoVK6azZ8/q8OHDGVrHwoUL9eOPP0qSzSksAwIClC9fPsXExKQKbzdv3qwhQ4bc0+OULl1aLi4u2rNnT6rPhIULF2r8+PEZqj89VatWVfv27XX16lW1b99eJ06csJl/48YN63ZLyUcbDxs2TMYYdezYMc2/U4mJiVq1apU2b95snfbYY4/poYce0okTJzRkyBCbv0d79+7VW2+9lanblWL37t1q3bq1vv76a7m4uOjLL7+0OUr6fp7vO32eZsff3/bt26tmzZr67bff1Lt37zSv43fhwgVNnTrV5vFSaj906FCaQezNNm7cKEn3dR1cAAAAZC1O9QkAAJBD5cuXTxs2bFCXLl20Zs0aNWjQQMHBwapcubK8vLx0+vRp/fbbb7p06ZJ8fHwUFBR0x3X+5z//0ZIlSzRt2jStXr1a1apVU1xcnNauXauSJUuqY8eOmj9/vs0yu3fv1ksvvSQfHx9Vq1ZNQUFBunr1qrZv367jx4/L19dXI0eOtI7/9NNPFRUVpeDgYFWsWFE+Pj46e/as1q1bp6tXr6pp06ZpnubsTl555RXrkTWXL1/WyZMntX37dl27dk3Ozs569tln9f7771uPXLiTefPmKTIyUkFBQapatary5cunCxcuaMOGDYqNjVXFihWtp1WTkr/gbteunb777jtVrVpV9evXl5eXlyTps88+u+ftuZ1nnnlGTZs2VYMGDfTQQw9p79692rNnj1xcXDR9+nQFBgbajP/Pf/6j7777TosXL1bp0qVVs2ZNnT17Vlu2bFG9evVUt25d65e1N+vQoYNGjBihjz76SHv37lXRokXl7Oysdu3a3fE1mjRpkg4cOKBff/1VISEhatKkiVxdXbV27VqdPXtWwcHBmjNnTqY+L+lxd3fX0qVL1bdvX33zzTdq166dChcurOrVq8vHx0fnzp3Tli1bdP78eVksFgUHB1uXbdWqld544w299dZbat68uerVq6dixYrpwIED2r59u1xcXDR16tQMXw8rI4oVK6bq1aurWrVqaty4sQoUKKAtW7boyJEjypMnj+bOnSsPDw/r+N69e2vChAnasWOHgoOD1aBBA7m4uFjfcy+++KImTJiQqTXe6/unUqVKmjRpkp577jk9+eSTGj9+vMqWLavjx49r48aNMsZo+PDhNqddzEodOnTQRx99pOXLl6tUqVLpjlu/fr169eplvX/p0iUdOnRIu3fvliQ1a9bM5vSyLi4uGjp0qF566SX17NlTkyZNUsmSJXXixAlt3LhRPXr00C+//HLXp98tWLCg+vfvrwkTJqhZs2Zq0KCBgoKCdPDgQW3fvt2672amGTNmqHXr1tq8ebMefvhh1a1bV0FBQYqOjtaePXt09uxZmx8T9O/fXydOnNB7772nBg0aqEKFCipVqpQ8PT0VHR2tnTt3KiYmRlOmTFGdOnUkJV9Xcs6cOWrdurU++OADLViwQDVr1tS5c+e0Zs0atW3bVtu2bcvwaYpvft1u3LihmJgY7d2717q+4OBgff7556mO5L2f5zsiIkKrV69Wjx491KJFC+v171599VWVKVMmW/7+Ojs7a8GCBWrTpo1mzZql7777TlWqVFGxYsV0/fp1/fnnn9qzZ48SExPVq1cv61GNxYoVU40aNbR161ZVqlRJNWrUkIeHhwoWLKh3333XpqYVK1ZIUo67ZiMAAABuYgAAAJDj/fzzz6Znz56mVKlSJm/evMbNzc0EBgaa5s2bmw8//NCcO3fOZvyMGTOMJBMZGZlqXbt37zbt2rUzhQsXNh4eHubhhx82gwcPNnFxcSYyMtJIMjNmzLCOP3z4sBk+fLhp1qyZKVasmPHw8DD58uUzlStXNq+//rr566+/bNa/aNEi89xzz5lHHnnEFCpUyLi7u5siRYqYxo0bm1mzZpnr16/f9XYfPXrUSLK5OTs7Gx8fH1OiRAnz6KOPmrffftscP378tutJWfZmv/zyixk4cKCpVauWCQwMNO7u7iYwMNCEhoaajz/+2Fy6dCnVes6dO2eeeeYZU6xYMePm5pZqvcOGDTOSzLBhw+64TcWLF79tnVOmTDFVq1Y1np6exsfHx7Rs2dJs2LAh3fX+/vvvplOnTiZfvnzGYrGYMmXKmLfeestcv37dNGrUyEgyq1evTrXc/PnzTb169Yy3t7dxcnJKVX/x4sWNJHP06NFUy16+fNmMHj3aVK1a1Xh5eRkPDw9Trlw585///MecP3/+nrb9bh7vbmzatMn069fPlCtXzvj4+BhXV1dTsGBB07BhQ/P222+bv//+O83lfv75Z9O6dWtToEAB4+rqagIDA03nzp3Nr7/+mub42z2nd7Mdae2TNz8/CQkJ5u233zZly5Y1FovF5M+f30RERJh9+/alub6zZ8+a559/3oSEhBiLxWKCgoJMjx49zKFDh9L9PLjd58Sdas3I+8cYYzZv3mwee+wxExgYaFxdXU2BAgVMmzZtzLJly9Icn9ZnUka24VYHDx40Tk5OplatWrd93Ftvrq6uxt/f3zRv3tzMnDnTJCYmprn8ggULTN26dY2fn5/JmzevqVGjhpk8ebJJSkpKd99Ib59KSkoyn3/+ualevbrJmzev8fX1NfXr1zdfffWVMSbt1+d20+/0eMYYEx8fb6ZMmWIaNGhg/Pz8rJ/jzZs3N5MmTUpzfRs2bDBPPPGEKV68uLFYLMbb29uULl3adOjQwXz22Wdpfibs2bPHdOrUyeTPn99YLBZTrlw5M3r0aJOQkJChz4K0XjeLxWL8/f1N9erVzdNPP21++OEHk5CQkO46Mvp8JyYmmtGjR5sKFSoYDw8P67ibn9+s/vub4tq1a2bq1KmmSZMm1s80f39/U7VqVRMVFWWWLl2aapnjx4+b7t27m8KFCxtXV9c0P6u3b99uJJkmTZrc5lUAAACAvTkZcw8nfgcAAAAAZIljx44pODhYxYsX17Fjx+xdjsN79NFH9dNPP2n37t2qVKmSvcsBcrwBAwZo4sSJ+uGHHzJ05D4AAACyB9f4AwAAAADkOmPHjpWrq6tGjBhh71KAHO+vv/7SZ599psaNGxP6AQAA5HAEfwAAAACAXKd8+fLq37+/vv/+e23dutXe5QA52ogRI5SQkJDp1wsFAABA5uNUnwAAAACQA3CqTwAAAADA/SL4AwAAAAAAAAAAABwAp/oEAAAAAAAAAAAAHADBHwAAAAAAAAAAAOAACP4AAAAAAAAAAAAAB0DwBwAAAAAAAAAAADgAgj8AAAAAAAAAAADAARD8AQAAAAAAAAAAAA6A4A8AAAAAAAAAAABwAAR/AAAAAAAAAAAAgAMg+AMAAAAAAAAAAAAcAMEfAAAAAAAAAAAA4AAI/gAAAAAAAAAAAAAHQPAHAAAAAAAAAAAAOACCPwAAAAAAAAAAAMABEPwBAAAAAAAAAAAADoDgDwAAAAAAAAAAAHAABH8AAAAAAAAAAACAAyD4AwAAAAAAAAAAABwAwR8AAAAAAAAAAADgAAj+AAAAAAAAAAAAAAdA8AcAAAAAAAAAAAA4AII/AAAAAAAAAAAAwAEQ/AEAAAAAAAAAAAAOgOAPAAAAAAAAAAAAcAAEfwAAAAAAAAAAAIADIPgDAAAAAAAAAAAAHADBHwAAAAAAAAAAAOAACP4AAAAAAAAAAAAAB0DwBwAAAAAAAAAAADgAgj8AAAAAAAAAAADAARD8AQAAAAAAAAAAAA6A4A8AAAAAAAAAAABwAAR/AAAAAAAAAAAAgAMg+AMAAAAAAAAAAAAcAMEfAAAAAAAAAAAA4AAI/gAAAAAAAAAAAAAHQPAHAAAAAAAAAAAAOACCPwAAAAAAAAAAAMABEPwBAAAAAAAAAAAADoDgDwAAAAAAAAAAAHAABH8AAAAAAAAAAACAAyD4AwAAAAAAAAAAABwAwR8AAAAAAAAAAADgAAj+AAAAAAAAAAAAAAdA8AcAAAAAAAAAAAA4AII/ALnGmjVr5OTkpDVr1lin9erVSyVKlLBbTQAAADnJ/fRGw4cPl5OTU+YWBAAAAAC4JwR/AHK0mTNnysnJKc3b66+/nm11NG7c2Pq4zs7O8vHxUZkyZfTkk09q+fLl97XuyZMna+bMmZlT6H06efKkhg8frp07d9q7FAAAcJP0+qFbbzf/wCm3WbhwoRo1aiR/f395eXmpZMmSevzxx7VkyZIMre+dd97RggULMrdIAABgd9nZV125ckXDhw+/p3UdO3ZMvXv3VkhIiDw8PBQYGKiGDRtq2LBhGaph8eLFGj58eIaWBfBgcrV3AQBwN0aOHKng4GCbaRUrVszWGooUKaLRo0dLki5fvqzDhw9r3rx5+vLLL/X444/ryy+/lJub2z2vd/LkySpYsKB69eqVyRXfu5MnT2rEiBEqUaKEqlatau9yAADA//fFF1/Y3J89e7aWL1+eanq5cuXu63GmTZumpKSkDC37xhtvZOsPs272/vvv69VXX1WjRo00ZMgQeXl56fDhw1qxYoW++uortWzZ8p7X+c477+ixxx5Thw4dMr9gAABgN9nVV0nJwd+IESMkJf+o/E4OHz6smjVrytPTU3369FGJEiV06tQpbd++XWPGjLGu614sXrxYkyZNIvwDchGCPwAPhFatWqlGjRp2rcHX11c9evSwmfbuu+/qhRde0OTJk1WiRAmNGTPGTtUBAABHdmsPsnnzZi1fvjzV9FtduXJFXl5ed/04GfkRUwpXV1e5umb/fzFv3LihUaNGqXnz5lq2bFmq+WfOnMn2mgAAQM6V0b4qO4wfP16XLl3Szp07Vbx4cZt59DQA7han+gTwwHNyckrzV0slSpTI8qPoXFxc9NFHH6l8+fKaOHGiYmNjrfNmzJihpk2byt/fXxaLReXLl9eUKVNS1bhv3z6tXbvWeiqJlF+AnT9/Xq+88ooqVaqkvHnzysfHR61atdKuXbtS1fHxxx+rQoUK8vLyUr58+VSjRg3NnTvXZsw///yjPn36KCAgQBaLRRUqVND06dOt89esWaOaNWtKknr37m2tJ6echhQAANxe48aNVbFiRW3btk0NGzaUl5eX/vOf/0iSfvjhB7Vp00ZBQUGyWCwKCQnRqFGjlJiYaLOOW6/xd+zYMTk5Oen999/Xp59+qpCQEFksFtWsWVNbtmyxWTata/w5OTmpf//+WrBggSpWrGjtQdI6/eaaNWtUo0YNeXh4KCQkRJ988sldXTfw33//VVxcnOrVq5fmfH9/f5v78fHxGjZsmEqVKiWLxaKiRYtq8ODBio+Pt6n78uXLmjVrlrUnyglnZwAAANkjKSlJH374oSpUqCAPDw8FBATomWee0YULF2zGbd26VeHh4SpYsKA8PT0VHBysPn36SEruowoVKiRJGjFihLWnuN2Rd0eOHFGRIkVShX5S6p5Gkn7++Wc1aNBAefLkkbe3t9q0aaN9+/ZZ5/fq1UuTJk2SZHuKUwCOjSP+ADwQYmNj9e+//9pMK1iwoJ2qseXi4qJu3brpzTff1Pr169WmTRtJ0pQpU1ShQgW1a9dOrq6uWrhwoZ5//nklJSUpKipKkvThhx9qwIAByps3r/773/9KkgICAiRJf/75pxYsWKDOnTsrODhYp0+f1ieffKJGjRrp999/V1BQkKTkU3K98MILeuyxx/Tiiy/q2rVr2r17t3799Vd1795dknT69GnVqVPH+uVboUKF9PPPP6tv376Ki4vTwIEDVa5cOY0cOVJDhw5Vv3791KBBA0lS3bp1s/X5BAAAGXfu3Dm1atVKXbt2VY8ePax9xcyZM5U3b14NGjRIefPm1apVqzR06FDFxcXpvffeu+N6586dq4sXL+qZZ56Rk5OTxo4dq06dOunPP/+841GC69ev17x58/T888/L29tbH330kSIiInTixAkVKFBAkrRjxw61bNlShQsX1ogRI5SYmKiRI0davyy7HX9/f3l6emrhwoUaMGCA8ufPn+7YpKQktWvXTuvXr1e/fv1Urlw57dmzR+PHj9cff/xhvabfF198oaeeekq1atVSv379JEkhISF3rAUAADiGZ555RjNnzlTv3r31wgsv6OjRo5o4caJ27NihDRs2yM3NTWfOnFGLFi1UqFAhvf766/Lz89OxY8c0b948SVKhQoU0ZcoUPffcc+rYsaM6deokSapcuXK6j1u8eHGtWLFCq1atUtOmTW9b4xdffKHIyEiFh4drzJgxunLliqZMmaL69etrx44dKlGihJ555hmdPHkyzVOZAnBgBgBysBkzZhhJad5SSDLDhg1LtWzx4sVNZGSk9f7q1auNJLN69WrrtMjISFO8ePE71tGoUSNToUKFdOfPnz/fSDITJkywTrty5UqqceHh4aZkyZI20ypUqGAaNWqUauy1a9dMYmKizbSjR48ai8ViRo4caZ3Wvn3729ZmjDF9+/Y1hQsXNv/++6/N9K5duxpfX19rrVu2bDGSzIwZM267PgAAYF9RUVHm1v/ONWrUyEgyU6dOTTU+rb7kmWeeMV5eXubatWvWabf2RkePHjWSTIECBcz58+et03/44QcjySxcuNA6bdiwYalqkmTc3d3N4cOHrdN27dplJJmPP/7YOq1t27bGy8vL/PPPP9Zphw4dMq6urqnWmZahQ4caSSZPnjymVatW5u233zbbtm1LNe6LL74wzs7OZt26dTbTp06daiSZDRs2WKflyZPHppcEAACO6da+at26dUaSmTNnjs24JUuW2ExP+S5oy5Yt6a777Nmz6X5vlZa9e/caT09PI8lUrVrVvPjii2bBggXm8uXLNuMuXrxo/Pz8zNNPP20zPTo62vj6+tpMT6tvBODYONUngAfCpEmTtHz5cptbTpI3b15J0sWLF63TPD09rf9OOWKxUaNG+vPPP21OCZoei8UiZ+fkj+nExESdO3dOefPmVZkyZbR9+3brOD8/P/3999+pTreVwhij77//Xm3btpUxRv/++6/1Fh4ertjYWJv1AQCAB5fFYlHv3r1TTb+5L7l48aL+/fdfNWjQQFeuXNGBAwfuuN4uXbooX7581vspZwb4888/77hsWFiYzdFylStXlo+Pj3XZxMRErVixQh06dLCe0UCSSpUqpVatWt1x/VLy6bPmzp2rRx55REuXLtV///tfVa9eXdWqVdP+/fut47799luVK1dOZcuWtemJUn5Rv3r16rt6PAAA4Li+/fZb+fr6qnnz5jb9QvXq1ZU3b15rv+Dn5ydJWrRokRISEjLlsStUqKCdO3eqR48eOnbsmCZMmKAOHTooICBA06ZNs45bvny5YmJi1K1bN5saXVxcVLt2bXoaIJfjVJ8AHgi1atVSjRo17F1Gui5duiRJ8vb2tk7bsGGDhg0bpk2bNunKlSs242NjY+Xr63vbdSYlJWnChAmaPHmyjh49anMNnpTTYknSa6+9phUrVqhWrVoqVaqUWrRooe7du1uvc3P27FnFxMTo008/1aeffprmY3GBaAAAHMNDDz0kd3f3VNP37dunN954Q6tWrVJcXJzNvLv5QVKxYsVs7qeEgLde5+Zulk1ZPmXZM2fO6OrVqypVqlSqcWlNS0+3bt3UrVs3xcXF6ddff9XMmTM1d+5ctW3bVnv37pWHh4cOHTqk/fv3p3sKUXoiAABw6NAhxcbGpnlNPel//UKjRo0UERGhESNGaPz48WrcuLE6dOig7t27y2KxZPjxS5curS+++EKJiYn6/ffftWjRIo0dO1b9+vVTcHCwwsLCdOjQIUlK93SgPj4+GX58AA8+gj8ADuvmoCyr7d27V9L/vpw6cuSImjVrprJly2rcuHEqWrSo3N3dtXjxYo0fP15JSUl3XOc777yjN998U3369NGoUaOUP39+OTs7a+DAgTbLlytXTgcPHtSiRYu0ZMkSff/995o8ebKGDh2qESNGWMf26NFDkZGRaT7W7c4vDwAAHhw3H9mXIiYmRo0aNZKPj49GjhypkJAQeXh4aPv27Xrttdfuqi9xcXFJc7oxJkuXzQgfHx81b95czZs3l5ubm2bNmqVff/1VjRo1UlJSkipVqqRx48aluWzRokWzpCYAAPDgSEpKkr+/v+bMmZPm/JQfEDk5Oem7777T5s2btXDhQi1dulR9+vTRBx98oM2bN1vPDpVRLi4uqlSpkipVqqTQ0FA1adJEc+bMUVhYmLV/++KLLxQYGJhqWVdXvvYHcjM+AQA88PLly6eYmBibadevX9epU6ey5fETExM1d+5ceXl5qX79+pKkhQsXKj4+Xj/++KPNr9zTOtWCk5NTmuv97rvv1KRJE33++ec202NiYlSwYEGbaXny5FGXLl3UpUsXXb9+XZ06ddLbb7+tIUOGqFChQvL29lZiYqLCwsJuuy3p1QIAAB5ca9as0blz5zRv3jw1bNjQOv3o0aN2rOp//P395eHhocOHD6eal9a0e1GjRg3NmjXL2heGhIRo165datas2R37HvoiAAByp5CQEK1YsUL16tVL80dVt6pTp47q1Kmjt99+W3PnztUTTzyhr776Sk899VSm9RMpZ8G6uaeRkvsovusBcCuu8QfggRcSEqJffvnFZtqnn36aLUf8JSYm6oUXXtD+/fv1wgsvWE+lkPLL9pt/yR4bG6sZM2akWkeePHlSBZcp67j1l/Dffvut/vnnH5tp586ds7nv7u6u8uXLyxijhIQEubi4KCIiQt9//731yMSbnT171qYWSWnWAwAAHkxp9SXXr1/X5MmT7VWSDRcXF4WFhWnBggU6efKkdfrhw4f1888/33H5K1euaNOmTWnOS1m+TJkykqTHH39c//zzj801clJcvXpVly9ftt5Pr0cDAACO7fHHH1diYqJGjRqVat6NGzes/cGFCxdSfW9TtWpVSVJ8fLwkycvLS9Ldf8+ybt26NK8XuHjxYkn/62nCw8Pl4+Ojd955J83xfNcD5G4c8QfggffUU0/p2WefVUREhJo3b65du3Zp6dKlqY6Ku1+xsbH68ssvJSV/wXT48GHNmzdPR44cUdeuXW0awhYtWsjd3V1t27bVM888o0uXLmnatGny9/dPdSRi9erVNWXKFL311lsqVaqU/P391bRpUz366KMaOXKkevfurbp162rPnj2aM2eOSpYsabN8ixYtFBgYqHr16ikgIED79+/XxIkT1aZNG+s1B999912tXr1atWvX1tNPP63y5cvr/Pnz2r59u1asWKHz589LSg5R/fz8NHXqVHl7eytPnjyqXbu2goODM/W5BAAA2adu3brKly+fIiMj9cILL8jJyUlffPFFlp1qMyOGDx+uZcuWqV69enruueeUmJioiRMnqmLFitq5c+dtl71y5Yrq1q2rOnXqqGXLlipatKhiYmK0YMECrVu3Th06dNAjjzwiSXryySf1zTff6Nlnn9Xq1atVr149JSYm6sCBA/rmm2+0dOlS6y/qq1evrhUrVmjcuHEKCgpScHCwateundVPBQAAsLNGjRrpmWee0ejRo7Vz5061aNFCbm5uOnTokL799ltNmDBBjz32mGbNmqXJkyerY8eOCgkJ0cWLFzVt2jT5+PiodevWkpJPw16+fHl9/fXXKl26tPLnz6+KFSuqYsWKaT72mDFjtG3bNnXq1Ml6WZbt27dr9uzZyp8/vwYOHCgp+dTmU6ZM0ZNPPqlq1aqpa9euKlSokE6cOKGffvpJ9erV08SJEyUl9zSS9MILLyg8PFwuLi7q2rVrFj+LAOzKAEAONmPGDCPJbNmyJd0xiYmJ5rXXXjMFCxY0Xl5eJjw83Bw+fNgUL17cREZGWsetXr3aSDKrV6+2TouMjDTFixe/Yx2NGjUykqy3vHnzmocfftj06NHDLFu2LM1lfvzxR1O5cmXj4eFhSpQoYcaMGWOmT59uJJmjR49ax0VHR5s2bdoYb29vI8k0atTIGGPMtWvXzMsvv2wKFy5sPD09Tb169cymTZtMo0aNrGOMMeaTTz4xDRs2NAUKFDAWi8WEhISYV1991cTGxtrUc/r0aRMVFWWKFi1q3NzcTGBgoGnWrJn59NNPbcb98MMPpnz58sbV1dVIMjNmzLjj8wMAALJXVFSUufW/c40aNTIVKlRIc/yGDRtMnTp1jKenpwkKCjKDBw82S5cuvWNvdPToUSPJvPfee6nWKckMGzbMen/YsGGpapJkoqKiUi17a59mjDErV640jzzyiHF3dzchISHms88+My+//LLx8PBI51lIlpCQYKZNm2Y6dOhgihcvbiwWi/Hy8jKPPPKIee+990x8fLzN+OvXr5sxY8aYChUqGIvFYvLly2eqV69uRowYYdM/HThwwDRs2NB4enoaSanqBQAAjiGtvsoYYz799FNTvXp14+npaby9vU2lSpXM4MGDzcmTJ40xxmzfvt1069bNFCtWzFgsFuPv728effRRs3XrVpv1bNy40VSvXt24u7un6p9utWHDBhMVFWUqVqxofH19jZubmylWrJjp1auXOXLkSKrxq1evNuHh4cbX19d4eHiYkJAQ06tXL5sabty4YQYMGGAKFSpknJyc0txWAI7FyZgc9DNPAAAAAAD+vw4dOmjfvn06dOiQvUsBAAAAgAcC1/gDAAAAANjd1atXbe4fOnRIixcvVuPGje1TEAAAAAA8gDjiDwAAAABgd4ULF1avXr1UsmRJHT9+XFOmTFF8fLx27Nihhx9+2N7lAQAAAMADwdXeBQAAAAAA0LJlS/3f//2foqOjZbFYFBoaqnfeeYfQDwAAAADuAUf8AQAAAAAAAAAAAA6Aa/wBAAAAAAAAAAAADoDgDwAAAAAAAAAAAHAAXOPvLiQlJenkyZPy9vaWk5OTvcsBAAAOzhijixcvKigoSM7OOet3WvRFAAAgu+TknkiiLwIAANnnXvoigr+7cPLkSRUtWtTeZQAAgFzmr7/+UpEiRexdhg36IgAAkN1yYk8k0RcBAIDsdzd9EcHfXfD29paU/IT6+PjYuRoAAODo4uLiVLRoUWsPkpPQFwEAgOySk3siib4IAABkn3vpiwj+7kLK6Rp8fHxo5AAAQLbJiaeMoi8CAADZLSf2RBJ9EQAAyH530xflvBOkAwAAAAAAAAAAALhnBH8AAAAAAAAAAACAAyD4AwAAAAAAAAAAABwAwR8AAAAAAAAAAADgAAj+AAAAAAAAAAAAAAdA8AcAAAAAAAAAAAA4AII/AAAAAAAAAAAAwAEQ/AEAAAAAAAAAAAAOgOAPAAAAAAAAAAAAcAB2Df5Gjx6tmjVrytvbW/7+/urQoYMOHjxoM6Zx48ZycnKyuT377LM2Y06cOKE2bdrIy8tL/v7+evXVV3Xjxg2bMWvWrFG1atVksVhUqlQpzZw5M6s3DwAAAAAAAAAAAMg2dg3+1q5dq6ioKG3evFnLly9XQkKCWrRoocuXL9uMe/rpp3Xq1CnrbezYsdZ5iYmJatOmja5fv66NGzdq1qxZmjlzpoYOHWodc/ToUbVp00ZNmjTRzp07NXDgQD311FNaunRptm0rAAAAAAAAAAAAkJVc7fngS5Yssbk/c+ZM+fv7a9u2bWrYsKF1upeXlwIDA9Ncx7Jly/T7779rxYoVCggIUNWqVTVq1Ci99tprGj58uNzd3TV16lQFBwfrgw8+kCSVK1dO69ev1/jx4xUeHp51GwgAAAAAAAAAAABkkxx1jb/Y2FhJUv78+W2mz5kzRwULFlTFihU1ZMgQXblyxTpv06ZNqlSpkgICAqzTwsPDFRcXp3379lnHhIWF2awzPDxcmzZtSrOO+Ph4xcXF2dwAAAByI/oiAACAZPRFAADgQWDXI/5ulpSUpIEDB6pevXqqWLGidXr37t1VvHhxBQUFaffu3Xrttdd08OBBzZs3T5IUHR1tE/pJst6Pjo6+7Zi4uDhdvXpVnp6eNvNGjx6tESNGZPo23kmJ13/K9sfE3Tv2bpvseaDhvtnzOMiY4bHZ8jCVZlXKlsfBvdsTuSdbHmd/2XLZ8jjImHIH9tu7hGxjr74IAAAgp6EvAgAAD4Icc8RfVFSU9u7dq6+++spmer9+/RQeHq5KlSrpiSee0OzZszV//nwdOXIky2oZMmSIYmNjrbe//voryx4LAAAgJ6MvAgAASEZfBAAAHgQ54oi//v37a9GiRfrll19UpEiR246tXbu2JOnw4cMKCQlRYGCgfvvtN5sxp0+fliTrdQEDAwOt024e4+Pjk+poP0myWCyyWCwZ3h4AAABHQV8EAACQjL4IAAA8COx6xJ8xRv3799f8+fO1atUqBQcH33GZnTt3SpIKFy4sSQoNDdWePXt05swZ65jly5fLx8dH5cuXt45ZuXKlzXqWL1+u0NDQTNoSAAAAAAAAAAAAwL7sGvxFRUXpyy+/1Ny5c+Xt7a3o6GhFR0fr6tWrkqQjR45o1KhR2rZtm44dO6Yff/xRPXv2VMOGDVW5cmVJUosWLVS+fHk9+eST2rVrl5YuXao33nhDUVFR1l9hPfvss/rzzz81ePBgHThwQJMnT9Y333yjl156yW7bDgAAAAAAAAAAAGQmuwZ/U6ZMUWxsrBo3bqzChQtbb19//bUkyd3dXStWrFCLFi1UtmxZvfzyy4qIiNDChQut63BxcdGiRYvk4uKi0NBQ9ejRQz179tTIkSOtY4KDg/XTTz9p+fLlqlKlij744AN99tlnCg8Pz/ZtBgAAAAAAAAAAALKCXa/xZ4y57fyiRYtq7dq1d1xP8eLFtXjx4tuOady4sXbs2HFP9QEAAAAAAAAAAAAPCrse8QcAAAAAAAAAAAAgcxD8AQAAAAAAAAAAAA6A4A8AAAAAAAAAAABwAAR/AAAAAAAAAAAAgAMg+AMAAAAAAAAAAAAcAMEfAAAAAAAAAAAA4AAI/gAAAAAAAAAAAAAHQPAHAAAAAAAAAAAAOACCPwAAAAAAAAAAAMABEPwBAAAAAAAAAAAADoDgDwAAAAAAAAAAAHAABH8AAAAAAAAAAACAAyD4AwAAAAAAAAAAABwAwR8AAAAAAAAAAADgAAj+AAAAAAAAAAAAAAdA8AcAAAAAAAAAAAA4AII/AAAAAAAAAAAAwAEQ/AEAAAAAAAAAAAAOgOAPAAAAAAAAAAAAcAAEfwAAAAAAAAAAAIADIPgDAAAAAAAAAAAAHADBHwAAAAAAAAAAAOAACP4AAAAAAAAAAAAAB0DwBwAAAAAAAAAAADgAgj8AAAAAAAAAAADAARD8AQAAAAAAAAAAAA6A4A8AAAAAAAAAAABwAAR/AAAAAAAAAAAAgAMg+AMAAAAAAAAAAAAcAMEfAAAAAAAAAAAA4AAI/gAAAAAAAAAAAAAHQPAHAAAAAAAAAAAAOACCPwAAAAAAAAAAAMABEPwBAAAAAAAAAAAADoDgDwAAAAAAAAAAAHAABH8AAAAAAAAAAACAAyD4AwAAAAAAAAAAABwAwR8AAAAAAAAAAADgAAj+AAAAAAAAAAAAAAdA8AcAAAAAAAAAAAA4AII/AAAAAAAAAAAAwAEQ/AEAAAAAAAAAAAAOgOAPAAAAAAAAAAAAcAAEfwAAAAAAAAAAAIADIPgDAAAAAAAAAAAAHADBHwAAAAAAAAAAAOAACP4AAAAAAAAAAAAAB0DwBwAAAAAAAAAAADgAgj8AAAAAAAAAAADAARD8AQAAAAAAAAAAAA6A4A8AAAAAAAAAAABwAHYN/kaPHq2aNWvK29tb/v7+6tChgw4ePGgz5tq1a4qKilKBAgWUN29eRURE6PTp0zZjTpw4oTZt2sjLy0v+/v569dVXdePGDZsxa9asUbVq1WSxWFSqVCnNnDkzqzcPAAAAAAAAAAAAyDZ2Df7Wrl2rqKgobd68WcuXL1dCQoJatGihy5cvW8e89NJLWrhwob799lutXbtWJ0+eVKdOnazzExMT1aZNG12/fl0bN27UrFmzNHPmTA0dOtQ65ujRo2rTpo2aNGminTt3auDAgXrqqae0dOnSbN1eAAAAAAAAAAAAIKu42vPBlyxZYnN/5syZ8vf317Zt29SwYUPFxsbq888/19y5c9W0aVNJ0owZM1SuXDlt3rxZderU0bJly/T7779rxYoVCggIUNWqVTVq1Ci99tprGj58uNzd3TV16lQFBwfrgw8+kCSVK1dO69ev1/jx4xUeHp7t2w0AAAAAAAAAAABkthx1jb/Y2FhJUv78+SVJ27ZtU0JCgsLCwqxjypYtq2LFimnTpk2SpE2bNqlSpUoKCAiwjgkPD1dcXJz27dtnHXPzOlLGpKwDAAAAAAAAAAAAeNDZ9Yi/myUlJWngwIGqV6+eKlasKEmKjo6Wu7u7/Pz8bMYGBAQoOjraOubm0C9lfsq8242Ji4vT1atX5enpaTMvPj5e8fHx1vtxcXH3v4EAAAAPIPoiAACAZPRFAADgQZBjjviLiorS3r179dVXX9m7FI0ePVq+vr7WW9GiRe1dEgAAgF3QFwEAACSjLwIAAA+CHBH89e/fX4sWLdLq1atVpEgR6/TAwEBdv35dMTExNuNPnz6twMBA65jTp0+nmp8y73ZjfHx8Uh3tJ0lDhgxRbGys9fbXX3/d9zYCAAA8iOiLAAAAktEXAQCAB4Fdgz9jjPr376/58+dr1apVCg4OtplfvXp1ubm5aeXKldZpBw8e1IkTJxQaGipJCg0N1Z49e3TmzBnrmOXLl8vHx0fly5e3jrl5HSljUtZxK4vFIh8fH5sbAABAbkRfBAAAkIy+CAAAPAjseo2/qKgozZ07Vz/88IO8vb2t1+Tz9fWVp6enfH191bdvXw0aNEj58+eXj4+PBgwYoNDQUNWpU0eS1KJFC5UvX15PPvmkxo4dq+joaL3xxhuKioqSxWKRJD377LOaOHGiBg8erD59+mjVqlX65ptv9NNPP9lt2wEAAAAAAAAAAIDMZNcj/qZMmaLY2Fg1btxYhQsXtt6+/vpr65jx48fr0UcfVUREhBo2bKjAwEDNmzfPOt/FxUWLFi2Si4uLQkND1aNHD/Xs2VMjR460jgkODtZPP/2k5cuXq0qVKvrggw/02WefKTw8PFu3FwAAAAAAAAAAAMgqdj3izxhzxzEeHh6aNGmSJk2alO6Y4sWLa/HixbddT+PGjbVjx457rhEAAAAAAAAAAAB4ENj1iD8AAAAAAAAAAAAAmYPgDwAAAAAAAAAAAHAABH8AAAAAAAAAAACAAyD4AwAAAAAAAAAAABwAwR8AAAAAAAAAAADgAAj+AAAAAAAAAAAAAAdA8AcAAAAAAAAAAAA4AII/AAAAAAAAAAAAwAEQ/AEAAAAAAAAAAAAOgOAPAAAAAAAAAAAAcAAEfwAAAAAAAAAAAIADIPgDAAAAAAAAAAAAHADBHwAAAAAAAAAAAOAACP4AAAAAAAAAAAAAB0DwBwAAAAAAAAAAADgAgj8AAAAAAAAAAADAARD8AQAAAAAAAAAAAA6A4A8AAAAAAAAAAABwAAR/AAAAAAAAAAAAgAMg+AMAAAAAAAAAAAAcAMEfAAAAAAAAAAAA4AAI/gAAAAAAAAAAAAAHQPAHAAAAAAAAAAAAOACCPwAAAAAAAAAAAMABuNq7AAAAAOBWJV7/yd4l4DaOvdvG3iUAAAAAAIA0EPwBAAAAyHmG+9q7AtzO8Fh7V4BcZH/ZcvYuAbdR7sB+e5cAAACAmxD8AQAAAABypEqzKtm7BNzGnsg99i4BAAAAwC24xh8AAAAAAAAAAADgAAj+AAAAAAAAAAAAAAdA8AcAAAAAAAAAAAA4AII/AAAAAAAAAAAAwAEQ/AEAAAAAAAAAAAAOgOAPAAAAAAAAAAAAcAAEfwAAAAAAAAAAAIADIPgDAAAAAAAAAAAAHADBHwAAAAAAAAAAAOAACP4AAAAAAAAAAAAAB0DwBwAAAAAAAAAAADgAgj8AAAAAAAAAAADAARD8AQAAAAAAAAAAAA6A4A8AAAAAAAAAAABwAAR/AAAAAAAAAAAAgAMg+AMAAAAAAAAAAAAcAMEfAAAAAAAAAAAA4AAI/gAAAAAAAAAAAAAHQPAHAAAAAAAAAAAAOACCPwAAAAAAAAAAAMABZCj4+/PPPzO7DgAAAGQB+jYAAIBk9EUAACA3yFDwV6pUKTVp0kRffvmlrl27ltk1AQAAIJPQtwEAACSjLwIAALlBhoK/7du3q3Llyho0aJACAwP1zDPP6Lfffsvs2gAAAHCf6NsAAACS0RcBAIDcIEPBX9WqVTVhwgSdPHlS06dP16lTp1S/fn1VrFhR48aN09mzZzO7TgAAAGQAfRsAAEAy+iIAAJAbZCj4S+Hq6qpOnTrp22+/1ZgxY3T48GG98sorKlq0qHr27KlTp05lVp0AAAC4D/RtAAAAyeiLAACAI7uv4G/r1q16/vnnVbhwYY0bN06vvPKKjhw5ouXLl+vkyZNq3779bZf/5Zdf1LZtWwUFBcnJyUkLFiywmd+rVy85OTnZ3Fq2bGkz5vz583riiSfk4+MjPz8/9e3bV5cuXbIZs3v3bjVo0EAeHh4qWrSoxo4dez+bDQAA8MC5374NAADAUdAXAQAAR+aakYXGjRunGTNm6ODBg2rdurVmz56t1q1by9k5OUcMDg7WzJkzVaJEiduu5/Lly6pSpYr69OmjTp06pTmmZcuWmjFjhvW+xWKxmf/EE0/o1KlTWr58uRISEtS7d2/169dPc+fOlSTFxcWpRYsWCgsL09SpU7Vnzx716dNHfn5+6tevX0Y2HwAA4IGRWX0bAADAg46+CAAA5AYZCv6mTJmiPn36qFevXipcuHCaY/z9/fX555/fdj2tWrVSq1atbjvGYrEoMDAwzXn79+/XkiVLtGXLFtWoUUOS9PHHH6t169Z6//33FRQUpDlz5uj69euaPn263N3dVaFCBe3cuVPjxo0j+AMAAA4vs/o2AACABx19EQAAyA0yFPwdOnTojmPc3d0VGRmZkdXbWLNmjfz9/ZUvXz41bdpUb731lgoUKCBJ2rRpk/z8/KyhnySFhYXJ2dlZv/76qzp27KhNmzapYcOGcnd3t44JDw/XmDFjdOHCBeXLly/VY8bHxys+Pt56Py4u7r63AwAAwB7ut2+jLwIAAI6CvggAAOQGGbrG34wZM/Ttt9+mmv7tt99q1qxZ911UipYtW2r27NlauXKlxowZo7Vr16pVq1ZKTEyUJEVHR8vf399mGVdXV+XPn1/R0dHWMQEBATZjUu6njLnV6NGj5evra70VLVo007YJAAAgO91v30ZfBAAAHAV9EQAAyA0yFPyNHj1aBQsWTDXd399f77zzzn0XlaJr165q166dKlWqpA4dOmjRokXasmWL1qxZk2mPkZYhQ4YoNjbWevvrr7+y9PEAAACyyv32bfRFAADAUdAXAQCA3CBDp/o8ceKEgoODU00vXry4Tpw4cd9FpadkyZIqWLCgDh8+rGbNmikwMFBnzpyxGXPjxg2dP3/eel3AwMBAnT592mZMyv30rh1osVhksViyYAsAAACy1/32bfRFAADAUdAXAQCA3CBDR/z5+/tr9+7dqabv2rXLev29rPD333/r3Llz1gswh4aGKiYmRtu2bbOOWbVqlZKSklS7dm3rmF9++UUJCQnWMcuXL1eZMmXSvL4fAACAI7FX3wYAAJDT0BcBAIDcIEPBX7du3fTCCy9o9erVSkxMVGJiolatWqUXX3xRXbt2vev1XLp0STt37tTOnTslSUePHtXOnTt14sQJXbp0Sa+++qo2b96sY8eOaeXKlWrfvr1KlSql8PBwSVK5cuXUsmVLPf300/rtt9+0YcMG9e/fX127dlVQUJAkqXv37nJ3d1ffvn21b98+ff3115owYYIGDRqUkU0HAAB4oGRW3wYAAPCgoy8CAAC5QYZO9Tlq1CgdO3ZMzZo1k6tr8iqSkpLUs2fPe7rG39atW9WkSRPr/ZQwLjIyUlOmTNHu3bs1a9YsxcTEKCgoSC1atNCoUaNsTqswZ84c9e/fX82aNZOzs7MiIiL00UcfWef7+vpq2bJlioqKUvXq1VWwYEENHTpU/fr1y8imAwAAPFAyq28DAAB40NEXAQCA3CBDwZ+7u7u+/vprjRo1Srt27ZKnp6cqVaqk4sWL39N6GjduLGNMuvOXLl16x3Xkz59fc+fOve2YypUra926dfdUGwAAgCPIrL4NAADgQUdfBAAAcoMMBX8pSpcurdKlS2dWLQAAAMgi9G0AAADJ6IsAAIAjy1Dwl5iYqJkzZ2rlypU6c+aMkpKSbOavWrUqU4oDAADA/aFvAwAASEZfBAAAcoMMBX8vvviiZs6cqTZt2qhixYpycnLK7LoAAACQCejbAAAAktEXAQCA3CBDwd9XX32lb775Rq1bt87segAAAJCJ6NsAAACS0RcBAIDcwDkjC7m7u6tUqVKZXQsAAAAyGX0bAABAMvoiAACQG2Qo+Hv55Zc1YcIEGWMyux4AAABkIvo2AACAZPRFAAAgN8jQqT7Xr1+v1atX6+eff1aFChXk5uZmM3/evHmZUhwAAADuD30bAABAMvoiAACQG2Qo+PPz81PHjh0zuxYAAABkMvo2AACAZPRFAAAgN8hQ8DdjxozMrgMAAABZgL4NAAAgGX0RAADIDTJ0jT9JunHjhlasWKFPPvlEFy9elCSdPHlSly5dyrTiAAAAcP/o2wAAAJLRFwEAAEeXoSP+jh8/rpYtW+rEiROKj49X8+bN5e3trTFjxig+Pl5Tp07N7DoBAACQAfRtAAAAyeiLAABAbpChI/5efPFF1ahRQxcuXJCnp6d1eseOHbVy5cpMKw4AAAD3h74NAAAgGX0RAADIDTJ0xN+6deu0ceNGubu720wvUaKE/vnnn0wpDAAAAPePvg0AACAZfREAAMgNMnTEX1JSkhITE1NN//vvv+Xt7X3fRQEAACBz0LcBAAAkoy8CAAC5QYaCvxYtWujDDz+03ndyctKlS5c0bNgwtW7dOrNqAwAAwH2ibwMAAEhGXwQAAHKDDJ3q84MPPlB4eLjKly+va9euqXv37jp06JAKFiyo//u//8vsGgEAAJBB9G0AAADJ6IsAAEBukKHgr0iRItq1a5e++uor7d69W5cuXVLfvn31xBNP2FwcGQAAAPZF3wYAAJCMvggAAOQGGQr+JMnV1VU9evTIzFoAAACQBejbAAAAktEXAQAAR5eh4G/27Nm3nd+zZ88MFQMAAIDMRd8GAACQjL4IAADkBhkK/l588UWb+wkJCbpy5Yrc3d3l5eVFowQAAJBD0LcBAAAkoy8CAAC5gXNGFrpw4YLN7dKlSzp48KDq16/PxZABAAByEPo2AACAZPRFAAAgN8hQ8JeWhx9+WO+++26qX08BAAAgZ6FvAwAASEZfBAAAHE2mBX9S8gWST548mZmrBAAAQBagbwMAAEhGXwQAABxJhq7x9+OPP9rcN8bo1KlTmjhxourVq5cphQEAAOD+0bcBAAAkoy8CAAC5QYaCvw4dOtjcd3JyUqFChdS0aVN98MEHmVEXAAAAMgF9GwAAQDL6IgAAkBtkKPhLSkrK7DoAAACQBejbAAAAktEXAQCA3CBTr/EHAAAAAAAAAAAAwD4ydMTfoEGD7nrsuHHjMvIQAAAAyAT0bQAAAMnoiwAAQG6QoeBvx44d2rFjhxISElSmTBlJ0h9//CEXFxdVq1bNOs7JySlzqgQAAECG0LcBAAAkoy8CAAC5QYaCv7Zt28rb21uzZs1Svnz5JEkXLlxQ79691aBBA7388suZWiQAAAAyhr4NAAAgGX0RAADIDTJ0jb8PPvhAo0ePtjZJkpQvXz699dZb+uCDDzKtOAAAANwf+jYAAIBk9EUAACA3yFDwFxcXp7Nnz6aafvbsWV28ePG+iwIAAEDmoG8DAABIRl8EAABygwwFfx07dlTv3r01b948/f333/r777/1/fffq2/fvurUqVNm1wgAAIAMom8DAABIRl8EAABygwxd42/q1Kl65ZVX1L17dyUkJCSvyNVVffv21XvvvZepBQIAACDj6NsAAACS0RcBAIDcIEPBn5eXlyZPnqz33ntPR44ckSSFhIQoT548mVocAAAA7g99GwAAQDL6IgAAkBtk6FSfKU6dOqVTp07p4YcfVp48eWSMyay6AAAAkIno2wAAAJLRFwEAAEeWoeDv3LlzatasmUqXLq3WrVvr1KlTkqS+ffvq5ZdfztQCAQAAkHH0bQAAAMnoiwAAQG6QoeDvpZdekpubm06cOCEvLy/r9C5dumjJkiWZVhwAAADuD30bAABAMvoiAACQG2ToGn/Lli3T0qVLVaRIEZvpDz/8sI4fP54phQEAAOD+0bcBAAAkoy8CAAC5QYaO+Lt8+bLNL6NSnD9/XhaL5b6LAgAAQOagbwMAAEhGXwQAAHKDDAV/DRo00OzZs633nZyclJSUpLFjx6pJkyaZVhwAAADuD30bAABAMvoiAACQG2ToVJ9jx45Vs2bNtHXrVl2/fl2DBw/Wvn37dP78eW3YsCGzawQAAEAG0bcBAAAkoy8CAAC5QYaO+KtYsaL++OMP1a9fX+3bt9fly5fVqVMn7dixQyEhIZldIwAAADKIvg0AACAZfREAAMgN7vmIv4SEBLVs2VJTp07Vf//736yoCQAAAJmAvg0AACAZfREAAMgt7vmIPzc3N+3evTsragEAAEAmom8DAABIRl8EAAByiwyd6rNHjx76/PPPM7sWAAAAZDL6NgAAgGT0RQAAIDe451N9StKNGzc0ffp0rVixQtWrV1eePHls5o8bNy5TigMAAMD9oW8DAABIRl8EAAByg3sK/v7880+VKFFCe/fuVbVq1SRJf/zxh80YJyenzKsOAAAAGULfBgAAkIy+CAAA5Cb3FPw9/PDDOnXqlFavXi1J6tKliz766CMFBARkSXEAAADIGPo2AACAZPRFAAAgN7mna/wZY2zu//zzz7p8+XKmFgQAAID7R98GAACQjL4IAADkJvcU/N3q1sYJAAAAORN9GwAAQDL6IgAA4MjuKfhzcnJKdc5zzoEOAACQ89C3AQAAJKMvAgAAuck9XePPGKNevXrJYrFIkq5du6Znn31WefLksRk3b968u1rfL7/8ovfee0/btm3TqVOnNH/+fHXo0MHm8YYNG6Zp06YpJiZG9erV05QpU/Twww9bx5w/f14DBgzQwoUL5ezsrIiICE2YMEF58+a1jtm9e7eioqK0ZcsWFSpUSAMGDNDgwYPvZdMBAAAeKJndtwEAADyo6IsAAEBuck/BX2RkpM39Hj163NeDX758WVWqVFGfPn3UqVOnVPPHjh2rjz76SLNmzVJwcLDefPNNhYeH6/fff5eHh4ck6YknntCpU6e0fPlyJSQkqHfv3urXr5/mzp0rSYqLi1OLFi0UFhamqVOnas+ePerTp4/8/PzUr1+/+6ofAAAgp8rsvg0AAOBBRV8EAAByk3sK/mbMmJGpD96qVSu1atUqzXnGGH344Yd644031L59e0nS7NmzFRAQoAULFqhr167av3+/lixZoi1btqhGjRqSpI8//litW7fW+++/r6CgIM2ZM0fXr1/X9OnT5e7urgoVKmjnzp0aN24cwR8AAHBYmd23AQAAPKjoiwAAQG5yT9f4y05Hjx5VdHS0wsLCrNN8fX1Vu3Ztbdq0SZK0adMm+fn5WUM/SQoLC5Ozs7N+/fVX65iGDRvK3d3dOiY8PFwHDx7UhQsX0nzs+Ph4xcXF2dwAAAByI/oiAACAZPRFAADgQZBjg7/o6GhJUkBAgM30gIAA67zo6Gj5+/vbzHd1dVX+/PltxqS1jpsf41ajR4+Wr6+v9Va0aNH73yAAAIAHEH0RAABAMvoiAADwIMixwZ89DRkyRLGxsdbbX3/9Ze+SAAAA7IK+CAAAIBl9EQAAeBDc0zX+slNgYKAk6fTp0ypcuLB1+unTp1W1alXrmDNnztgsd+PGDZ0/f966fGBgoE6fPm0zJuV+yphbWSwWWSyWTNkOAACABxl9EQAAQDL6IgAA8CDIsUf8BQcHKzAwUCtXrrROi4uL06+//qrQ0FBJUmhoqGJiYrRt2zbrmFWrVikpKUm1a9e2jvnll1+UkJBgHbN8+XKVKVNG+fLly6atAQAAAAAAAAAAALKWXYO/S5cuaefOndq5c6ck6ejRo9q5c6dOnDghJycnDRw4UG+99ZZ+/PFH7dmzRz179lRQUJA6dOggSSpXrpxatmypp59+Wr/99ps2bNig/v37q2vXrgoKCpIkde/eXe7u7urbt6/27dunr7/+WhMmTNCgQYPstNUAAAAAAAAAAABA5rPrqT63bt2qJk2aWO+nhHGRkZGaOXOmBg8erMuXL6tfv36KiYlR/fr1tWTJEnl4eFiXmTNnjvr3769mzZrJ2dlZERER+uijj6zzfX19tWzZMkVFRal69eoqWLCghg4dqn79+mXfhgIAAAAAAAAAAABZzK7BX+PGjWWMSXe+k5OTRo4cqZEjR6Y7Jn/+/Jo7d+5tH6dy5cpat25dhusEAAAAAAAAAAAAcroce40/AAAAAAAAAAAAAHeP4A8AAAAAAAAAAABwAAR/AAAAAAAAAAAAgAMg+AMAAAAAAAAAAAAcAMEfAAAAAAAAAAAA4AAI/gAAAAAAAAAAAAAHQPAHAAAAAAAAAAAAOACCPwAAAAAAAAAAAMABEPwBAAAAAAAAAAAADoDgDwAAAAAAAAAAAHAABH8AAAAAAAAAAACAAyD4AwAAAAAAAAAAABwAwR8AAAAAAAAAAADgAAj+AAAAAAAAAAAAAAdA8AcAAAAAAAAAAAA4AII/AAAAAAAAAAAAwAEQ/AEAAAAAAAAAAAAOgOAPAAAAAAAAAAAAcAAEfwAAAAAAAAAAAIADIPgDAAAAAAAAAAAAHADBHwAAAAAAAAAAAOAACP4AAAAAAAAAAAAAB0DwBwAAAAAAAAAAADgAgj8AAAAAAAAAAADAAbjauwAAAAAAAAAAAJC+SrMq2bsE3MaeyD32LgGwIvgDAAAAAAAAcqASr/9k7xJwG8febZM9DzTcN3seBxkzPNbeFSAX2V+2nL1LQDrKHdhv7xKsONUnAAAAAAAAAAAA4AAI/gAAAAAAAAAAAAAHQPAHAAAAAAAAAAAAOACCPwAAAAAAAAAAAMABEPwBAAAAAAAAAAAADoDgDwAAAAAAAAAAAHAABH8AAAAAAAAAAACAAyD4AwAAAAAAAAAAABwAwR8AAAAAAAAAAADgAAj+AAAAAAAAAAAAAAdA8AcAAAAAAAAAAAA4AII/AAAAAAAAAAAAwAEQ/AEAAAAAAAAAAAAOgOAPAAAAAAAAAAAAcAAEfwAAAAAAAAAAAIADIPgDAAAAAAAAAAAAHADBHwAAAAAAAAAAAOAACP4AAAAAAAAAAAAAB0DwBwAAAAAAAAAAADgAgj8AAAAAAAAAAADAARD8AQAAAAAAAAAAAA6A4A8AAAAAAAAAAABwAAR/AAAAAAAAAAAAgAMg+AMAAAAAAAAAAAAcAMEfAAAAAAAAAAAA4ABydPA3fPhwOTk52dzKli1rnX/t2jVFRUWpQIECyps3ryIiInT69GmbdZw4cUJt2rSRl5eX/P399eqrr+rGjRvZvSkAAAAAAAAAAABAlnK1dwF3UqFCBa1YscJ639X1fyW/9NJL+umnn/Ttt9/K19dX/fv3V6dOnbRhwwZJUmJiotq0aaPAwEBt3LhRp06dUs+ePeXm5qZ33nkn27cFAAAAAAAAAAAAyCo5PvhzdXVVYGBgqumxsbH6/PPPNXfuXDVt2lSSNGPGDJUrV06bN29WnTp1tGzZMv3+++9asWKFAgICVLVqVY0aNUqvvfaahg8fLnd39+zeHAAAAAAAAAAAACBL5OhTfUrSoUOHFBQUpJIlS+qJJ57QiRMnJEnbtm1TQkKCwsLCrGPLli2rYsWKadOmTZKkTZs2qVKlSgoICLCOCQ8PV1xcnPbt25e9GwIAAAAAAAAAAABkoRx9xF/t2rU1c+ZMlSlTRqdOndKIESPUoEED7d27V9HR0XJ3d5efn5/NMgEBAYqOjpYkRUdH24R+KfNT5qUnPj5e8fHx1vtxcXGZtEUAAAAPFvoiAACAZPRFAADgQZCjj/hr1aqVOnfurMqVKys8PFyLFy9WTEyMvvnmmyx93NGjR8vX19d6K1q0aJY+HgAAQE5FXwQAAJCMvggAADwIcnTwdys/Pz+VLl1ahw8fVmBgoK5fv66YmBibMadPn7ZeEzAwMFCnT59ONT9lXnqGDBmi2NhY6+2vv/7K3A0BAAB4QNAXAQAAJKMvAgAAD4IHKvi7dOmSjhw5osKFC6t69epyc3PTypUrrfMPHjyoEydOKDQ0VJIUGhqqPXv26MyZM9Yxy5cvl4+Pj8qXL5/u41gsFvn4+NjcAAAAciP6IgAAgGT0RQAA4EGQo6/x98orr6ht27YqXry4Tp48qWHDhsnFxUXdunWTr6+v+vbtq0GDBil//vzy8fHRgAEDFBoaqjp16kiSWrRoofLly+vJJ5/U2LFjFR0drTfeeENRUVGyWCx23joAAAAAAAAAAAAg8+To4O/vv/9Wt27ddO7cORUqVEj169fX5s2bVahQIUnS+PHj5ezsrIiICMXHxys8PFyTJ0+2Lu/i4qJFixbpueeeU2hoqPLkyaPIyEiNHDnSXpsEAAAAAAAAAAAAZIkcHfx99dVXt53v4eGhSZMmadKkSemOKV68uBYvXpzZpQEAAAAAAAAAAAA5ygN1jT8AAAAAAAAAAAAAaSP4AwAAAAAAAAAAABwAwR8AAAAAAAAAAADgAAj+AAAAAAAAAAAAAAdA8AcAAAAAAAAAAAA4AII/AAAAAAAAAAAAwAEQ/AEAAAAAAAAAAAAOgOAPAAAAAAAAAAAAcAAEfwAAAAAAAAAAAIADIPgDAAAAAAAAAAAAHADBHwAAAAAAAAAAAOAACP4AAAAAAAAAAAAAB0DwBwAAAAAAAAAAADgAgj8AAAAAAAAAAADAARD8AQAAAAAAAAAAAA6A4A8AAAAAAAAAAABwAAR/AAAAAAAAAAAAgAMg+AMAAAAAAAAAAAAcAMEfAAAAAAAAAAAA4AAI/gAAAAAAAAAAAAAHQPAHAAAAAAAAAAAAOACCPwAAAAAAAAAAAMABEPwBAAAAAAAAAAAADoDgDwAAAAAAAAAAAHAABH8AAAAAAAAAAACAAyD4AwAAAAAAAAAAABwAwR8AAAAAAAAAAADgAAj+AAAAAAAAAAAAAAdA8AcAAAAAAAAAAAA4AII/AAAAAAAAAAAAwAEQ/AEAAAAAAAAAAAAOgOAPAAAAAAAAAAAAcAAEfwAAAAAAAAAAAIADIPgDAAAAAAAAAAAAHADBHwAAAAAAAAAAAOAACP4AAAAAAAAAAAAAB0DwBwAAAAAAAAAAADgAgj8AAAAAAAAAAADAARD8AQAAAAAAAAAAAA6A4A8AAAAAAAAAAABwAAR/AAAAAAAAAAAAgAMg+AMAAAAAAAAAAAAcAMEfAAAAAAAAAAAA4AAI/gAAAAAAAAAAAAAHQPAHAAAAAAAAAAAAOACCPwAAAAAAAAAAAMABEPwBAAAAAAAAAAAADoDgDwAAAAAAAAAAAHAABH8AAAAAAAAAAACAAyD4AwAAAAAAAAAAABwAwR8AAAAAAAAAAADgAAj+AAAAAAAAAAAAAAeQq4K/SZMmqUSJEvLw8FDt2rX122+/2bskAAAAAAAAAAAAIFPkmuDv66+/1qBBgzRs2DBt375dVapUUXh4uM6cOWPv0gAAAAAAAAAAAID7lmuCv3Hjxunpp59W7969Vb58eU2dOlVeXl6aPn26vUsDAAAAAAAAAAAA7luuCP6uX7+ubdu2KSwszDrN2dlZYWFh2rRpkx0rAwAAAAAAAAAAADKHq70LyA7//vuvEhMTFRAQYDM9ICBABw4cSDU+Pj5e8fHx1vuxsbGSpLi4uCytMyn+SpauH/cnq19/q3iTPY+DjMmm/SDxamK2PA7uXXZ9FlxKZB/IybJ6P0hZvzH2/5tAX4S0ZMtnIT1RzkZPBNEXIVlW7gc5qSeS7NMX0RPlbHxXBEn0RZBEX4Sc9V2Rk8kp3VMWOnnypB566CFt3LhRoaGh1umDBw/W2rVr9euvv9qMHz58uEaMGJHdZQIAANj466+/VKRIEbvWQF8EAADsLSf0RBJ9EQAAsL+76YtyRfB3/fp1eXl56bvvvlOHDh2s0yMjIxUTE6MffvjBZvytv+BKSkrS+fPnVaBAATk5OWVX2Q+0uLg4FS1aVH/99Zd8fHzsXQ7shP0A7AOQ2A8ywhijixcvKigoSM7O9j0zO33R/eM9APYBSOwHSMZ+cG9yUk8k0RfdL/Z/SOwHSMZ+APaBe3cvfVGuONWnu7u7qlevrpUrV1qDv6SkJK1cuVL9+/dPNd5ischisdhM8/Pzy4ZKHY+Pjw9vXLAfgH0AktgP7pWvr6+9S5BEX5SZeA+AfQAS+wGSsR/cvZzSE0n0RZmF/R8S+wGSsR+AfeDe3G1flCuCP0kaNGiQIiMjVaNGDdWqVUsffvihLl++rN69e9u7NAAAAAAAAAAAAOC+5Zrgr0uXLjp79qyGDh2q6OhoVa1aVUuWLFFAQIC9SwMAAAAAAAAAAADuW64J/iSpf//+aZ7aE5nPYrFo2LBhqU6BgdyF/QDsA5DYDwDeA2AfgMR+gGTsB8jN2P8hsR8gGfsB2AeylpMxxti7CAAAAAAAAAAAAAD3x9neBQAAAAAAAAAAAAC4fwR/AAAAAAAAAAAAgAMg+AMAAAAAAAAAAAAcAMEfMt2kSZNUokQJeXh4qHbt2vrtt9/sXRKy2S+//KK2bdsqKChITk5OWrBggb1LQjYbPXq0atasKW9vb/n7+6tDhw46ePCgvctCNpsyZYoqV64sHx8f+fj4KDQ0VD///LO9ywKyFX1R7kZPBIm+CPREQAr6otyNvgj0RJDoi7ILwR8y1ddff61BgwZp2LBh2r59u6pUqaLw8HCdOXPG3qUhG12+fFlVqlTRpEmT7F0K7GTt2rWKiorS5s2btXz5ciUkJKhFixa6fPmyvUtDNipSpIjeffddbdu2TVu3blXTpk3Vvn177du3z96lAdmCvgj0RJDoi0BPBEj0RaAvAj0RktEXZQ8nY4yxdxFwHLVr11bNmjU1ceJESVJSUpKKFi2qAQMG6PXXX7dzdbAHJycnzZ8/Xx06dLB3KbCjs2fPyt/fX2vXrlXDhg3tXQ7sKH/+/HrvvffUt29fe5cCZDn6ItyMnggp6Isg0RMh96Evws3oiyDRE+F/6IsyH0f8IdNcv35d27ZtU1hYmHWas7OzwsLCtGnTJjtWBsDeYmNjJSX/IUfulJiYqK+++kqXL19WaGiovcsBshx9EYD00BflbvREyI3oiwCkhZ4I9EVZx9XeBcBx/Pvvv0pMTFRAQIDN9ICAAB04cMBOVQGwt6SkJA0cOFD16tVTxYoV7V0OstmePXsUGhqqa9euKW/evJo/f77Kly9v77KALEdfBCAt9EW5Fz0RcjP6IgC3oifK3eiLsh7BHwAgS0VFRWnv3r1av369vUuBHZQpU0Y7d+5UbGysvvvuO0VGRmrt2rU0dACAXIm+KPeiJwIA4H/oiXI3+qKsR/CHTFOwYEG5uLjo9OnTNtNPnz6twMBAO1UFwJ769++vRYsW6ZdfflGRIkXsXQ7swN3dXaVKlZIkVa9eXVu2bNGECRP0ySef2LkyIGvRFwG4FX1R7kZPhNyMvgjAzeiJQF+U9bjGHzKNu7u7qlevrpUrV1qnJSUlaeXKlZyjF8hljDHq37+/5s+fr1WrVik4ONjeJSGHSEpKUnx8vL3LALIcfRGAFPRFSAs9EXIT+iIAEj0R0kdflPk44g+ZatCgQYqMjFSNGjVUq1Ytffjhh7p8+bJ69+5t79KQjS5duqTDhw9b7x89elQ7d+5U/vz5VaxYMTtWhuwSFRWluXPn6ocffpC3t7eio6MlSb6+vvL09LRzdcguQ4YMUatWrVSsWDFdvHhRc+fO1Zo1a7R06VJ7lwZkC/oi0BNBoi8CPREg0ReBvgj0REhGX5Q9nIwxxt5FwLFMnDhR7733nqKjo1W1alV99NFHql27tr3LQjZas2aNmjRpkmp6ZGSkZs6cmf0FIds5OTmlOX3GjBnq1atX9hYDu+nbt69WrlypU6dOydfXV5UrV9Zrr72m5s2b27s0INvQF+Vu9ESQ6ItATwSkoC/K3eiLQE8Eib4ouxD8AQAAAAAAAAAAAA6Aa/wBAAAAAAAAAAAADoDgDwAAAAAAAAAAAHAABH8AAAAAAAAAAACAAyD4AwAAAAAAAAAAABwAwR8AAAAAAAAAAADgAAj+AAAAAAAAAAAAAAdA8AcAAAAAAAAAAAA4AII/AAAAAAAAAAAAwAEQ/AHIVZycnLRgwQJ7l5Ehw4cPV9WqVe9rHceOHZOTk5N27tyZKTUBAIAHF30RfREAAEhGX0RfBDgSgj8ADiM6OloDBgxQyZIlZbFYVLRoUbVt21YrV660d2mSpMaNG2vgwIH2LgMAAOQC9EUAAADJ6IsA5Dau9i4AADLDsWPHVK9ePfn5+em9995TpUqVlJCQoKVLlyoqKkoHDhywd4kAAADZgr4IAAAgGX0RgNyII/4AOITnn39eTk5O+u233xQREaHSpUurQoUKGjRokDZv3pzucq+99ppKly4tLy8vlSxZUm+++aYSEhKs83ft2qUmTZrI29tbPj4+ql69urZu3SpJOn78uNq2bat8+fIpT548qlChghYvXpzhbbhTLSk++eQTFS1aVF5eXnr88ccVGxtrM/+zzz5TuXLl5OHhobJly2ry5MkZrgkAADx46Iv+h74IAIDcjb7of+iLgNyDI/4APPDOnz+vJUuW6O2331aePHlSzffz80t3WW9vb82cOVNBQUHas2ePnn76aXl7e2vw4MGSpCeeeEKPPPKI/l97dxMS1R7Gcfyn0iSoDSVRjajINIZBZmSBBLkR0oIWaS8Q4kKFTJnScCWo5bIgSM2Fi4KYyBa6qAgMElr0QsEM9EaghiK2KDLEEGXoaTHcAbPS5t7LvXPm+4GzOPP/n5nnzOoHz8x5+vr6lJKSolAopDVr1kiSGhsbtbi4qEePHiktLU1v3rxRenp6zPexUi2SNDo6qtu3b+vOnTuanZ1VbW2tTp8+rUAgIEkKBAJqb29XT0+Pdu3apWAwqPr6eqWlpammpibm2gAAQHwgF5GLAABABLmIXAQkLAOAOPfs2TOTZIODgyvulWRDQ0O/XL948aLt3r07ep6RkWHXr1//6d4dO3ZYZ2fnqussLS21M2fOrHr/j7V0dHRYSkqKTU1NRV+7f/++JScn24cPH8zMzOv12s2bN5e8T1dXl5WUlJiZ2fv3702SBYPBVdcBAADiB7mIXAQAACLIReQiIFHxjz8Acc/MYr52YGBAV65c0djYmObm5hQOh7Vu3broektLi+rq6nTjxg2VlZXp6NGj8nq9kiS/36+GhgYNDw+rrKxMlZWVKiws/NdqkaScnBxlZWVFz0tKSvTt2ze9e/dOGRkZGhsbU21trerr66N7wuGw3G53zHUBAID4QS4iFwEAgAhyEbkISFTM+AMQ93w+n5KSkv54IPOTJ0908uRJHTx4UHfv3lUwGFRbW5sWFxejezo7O/X69WsdOnRIDx8+1Pbt2zU0NCRJqqur0/j4uKqrq/Xy5UsVFxeru7s7pntYTS0rmZubkyT19/crFApFj1evXv32ufUAAMA5yEUR5CIAAEAuiiAXAYmHxh+AuLdhwwYdOHBAvb29+vr167L1L1++/PS6x48fKzc3V21tbSouLpbP59PExMSyffn5+Wpubtbw8LCOHDmia9euRdeys7N16tQpDQ4O6ty5c+rv74/pHlZby+TkpKanp6PnT58+VXJysrZt26ZNmzbJ4/FofHxcW7duXXLk5eXFVBcAAIgv5CJyEQAAiCAXkYuARMWjPgE4Qm9vr/bt26e9e/fqwoULKiwsVDgc1oMHD9TX16e3b98uu8bn82lyclK3bt3Snj17dO/eveivsyRpfn5era2tqqqqUl5enqampvT8+XNVVlZKks6ePauKigrl5+drZmZGIyMjKigo+G2dHz9+VCgUWvLali1bVqzlL6mpqaqpqdGlS5c0Ozsrv9+vY8eOafPmzZKk8+fPy+/3y+12q7y8XAsLC3rx4oVmZmbU0tLyp18rAACIQ+QichEAAIggF5GLgIT0H88YBIB/zPT0tDU2Nlpubq65XC7Lysqyw4cP28jISHSPfhjW3NraapmZmZaenm7Hjx+3y5cvm9vtNjOzhYUFO3HihGVnZ5vL5TKPx2NNTU02Pz9vZmZNTU3m9Xpt7dq1tnHjRquurrZPnz79sr7S0lKTtOzo6upasRazyLDmnTt32tWrV83j8VhqaqpVVVXZ58+fl3xOIBCwoqIic7lctn79etu/f390kDXDmgEASAzkoghyEQAAIBdFkIuAxJFk9jemnAIAAAAAAAAAAAD4X2DGHwAAAAAAAAAAAOAANP4AAAAAAAAAAAAAB6DxBwAAAAAAAAAAADgAjT8AAAAAAAAAAADAAWj8AQAAAAAAAAAAAA5A4w8AAAAAAAAAAABwABp/AAAAAAAAAAAAgAPQ+AMAAAAAAAAAAAAcgMYfAAAAAAAAAAAA4AA0/gAAAAAAAAAAAAAHoPEHAAAAAAAAAAAAOACNPwAAAAAAAAAAAMABvgMX8AbU68hhjQAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -1253,12 +609,16 @@ "\n", "==================== Running Test: IMBALANCED Dataset ====================\n", "\n", + "Checking if indices are reproducible with the same random state\n", + "SUCCESS: Train indices are reproducible.\n", + "SUCCESS: Test indices are reproducible.\n", + "\n", "Checking for group overlap...\n", "SUCCESS: No overlapping groups found between train and test sets.\n", "\n", "Dataset Sizes and Ratios:\n", - " - Train set size: 7003 (70.03%)\n", - " - Test set size: 2997 (29.97%)\n", + " - Train set size: 7035 (70.35%)\n", + " - Test set size: 2965 (29.65%)\n", "\n", "Class Distribution Ratios:\n", " - Full Dataset:\n", @@ -1267,22 +627,22 @@ " - Class 2: 3.00%\n", " - Class 3: 3.00%\n", " - Train Set:\n", - " - Class 0: 90.12%\n", - " - Class 1: 3.91%\n", - " - Class 2: 3.00%\n", - " - Class 3: 2.97%\n", + " - Class 0: 89.99%\n", + " - Class 1: 4.01%\n", + " - Class 2: 2.99%\n", + " - Class 3: 3.01%\n", " - Test Set:\n", - " - Class 0: 89.72%\n", - " - Class 1: 4.20%\n", - " - Class 2: 3.00%\n", - " - Class 3: 3.07%\n", + " - Class 0: 90.02%\n", + " - Class 1: 3.98%\n", + " - Class 2: 3.04%\n", + " - Class 3: 2.97%\n", "\n", "Generating class distribution histograms...\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1306,36 +666,36 @@ " - Class 3: 25.00%\n", "\n", "-- Testing with test_size = 0.1 --\n", - "Train size: 90054, Test size: 9946\n", + "Train size: 90022, Test size: 9978\n", " - Test Set:\n", - " - Class 0: 25.01%\n", - " - Class 1: 25.17%\n", - " - Class 2: 24.91%\n", - " - Class 3: 24.91%\n", + " - Class 0: 24.97%\n", + " - Class 1: 24.74%\n", + " - Class 2: 25.38%\n", + " - Class 3: 24.90%\n", "\n", "-- Testing with test_size = 0.2 --\n", - "Train size: 79969, Test size: 20031\n", + "Train size: 80044, Test size: 19956\n", " - Test Set:\n", - " - Class 0: 25.02%\n", - " - Class 1: 25.25%\n", - " - Class 2: 24.93%\n", - " - Class 3: 24.80%\n", + " - Class 0: 24.84%\n", + " - Class 1: 25.10%\n", + " - Class 2: 24.97%\n", + " - Class 3: 25.08%\n", "\n", "-- Testing with test_size = 0.3 --\n", - "Train size: 69810, Test size: 30190\n", + "Train size: 70070, Test size: 29930\n", " - Test Set:\n", - " - Class 0: 25.06%\n", - " - Class 1: 25.15%\n", - " - Class 2: 24.90%\n", - " - Class 3: 24.88%\n", + " - Class 0: 25.02%\n", + " - Class 1: 25.00%\n", + " - Class 2: 25.04%\n", + " - Class 3: 24.94%\n", "\n", "-- Testing with test_size = 0.4 --\n", - "Train size: 59851, Test size: 40149\n", + "Train size: 60005, Test size: 39995\n", " - Test Set:\n", - " - Class 0: 25.00%\n", - " - Class 1: 25.11%\n", - " - Class 2: 24.95%\n", - " - Class 3: 24.93%\n", + " - Class 0: 25.06%\n", + " - Class 1: 24.99%\n", + " - Class 2: 24.97%\n", + " - Class 3: 24.97%\n", "\n", "--- Scenario: IMBALANCED ---\n", "Full Dataset Distribution:\n", @@ -1346,36 +706,36 @@ " - Class 3: 3.00%\n", "\n", "-- Testing with test_size = 0.1 --\n", - "Train size: 90069, Test size: 9931\n", + "Train size: 90034, Test size: 9966\n", " - Test Set:\n", - " - Class 0: 90.01%\n", - " - Class 1: 4.02%\n", - " - Class 2: 3.03%\n", - " - Class 3: 2.94%\n", + " - Class 0: 90.03%\n", + " - Class 1: 3.97%\n", + " - Class 2: 2.97%\n", + " - Class 3: 3.03%\n", "\n", "-- Testing with test_size = 0.2 --\n", - "Train size: 80145, Test size: 19855\n", + "Train size: 80055, Test size: 19945\n", " - Test Set:\n", - " - Class 0: 89.97%\n", - " - Class 1: 4.00%\n", - " - Class 2: 3.00%\n", - " - Class 3: 3.04%\n", + " - Class 0: 90.00%\n", + " - Class 1: 3.96%\n", + " - Class 2: 3.03%\n", + " - Class 3: 3.01%\n", "\n", "-- Testing with test_size = 0.3 --\n", - "Train size: 70047, Test size: 29953\n", + "Train size: 70052, Test size: 29948\n", " - Test Set:\n", - " - Class 0: 90.00%\n", - " - Class 1: 3.97%\n", + " - Class 0: 89.99%\n", + " - Class 1: 4.02%\n", " - Class 2: 3.01%\n", - " - Class 3: 3.01%\n", + " - Class 3: 2.98%\n", "\n", "-- Testing with test_size = 0.4 --\n", - "Train size: 60008, Test size: 39992\n", + "Train size: 59965, Test size: 40035\n", " - Test Set:\n", - " - Class 0: 89.98%\n", - " - Class 1: 3.97%\n", - " - Class 2: 3.02%\n", - " - Class 3: 3.03%\n", + " - Class 0: 89.92%\n", + " - Class 1: 4.03%\n", + " - Class 2: 2.98%\n", + " - Class 3: 3.07%\n", "\n", "==================== Running Test: Varying Absolute Test Sizes (N=50,000) ====================\n", "\n", @@ -1388,44 +748,44 @@ " - Class 3: 25.00%\n", "\n", "-- Testing with test_size = 1000 --\n", - "Requested test size: 1000, Actual test size: 978\n", + "Requested test size: 1000, Actual test size: 985\n", " - Test Set:\n", - " - Class 0: 24.03%\n", - " - Class 1: 26.07%\n", - " - Class 2: 25.26%\n", - " - Class 3: 24.64%\n", + " - Class 0: 25.79%\n", + " - Class 1: 25.28%\n", + " - Class 2: 24.97%\n", + " - Class 3: 23.96%\n", "\n", "-- Testing with test_size = 3000 --\n", - "Requested test size: 3000, Actual test size: 2987\n", + "Requested test size: 3000, Actual test size: 2953\n", " - Test Set:\n", - " - Class 0: 24.74%\n", - " - Class 1: 25.04%\n", - " - Class 2: 24.87%\n", - " - Class 3: 25.34%\n", + " - Class 0: 24.86%\n", + " - Class 1: 24.79%\n", + " - Class 2: 25.19%\n", + " - Class 3: 25.16%\n", "\n", "-- Testing with test_size = 5000 --\n", - "Requested test size: 5000, Actual test size: 4985\n", + "Requested test size: 5000, Actual test size: 4983\n", " - Test Set:\n", - " - Class 0: 25.16%\n", - " - Class 1: 25.06%\n", - " - Class 2: 24.93%\n", - " - Class 3: 24.85%\n", + " - Class 0: 25.01%\n", + " - Class 1: 25.21%\n", + " - Class 2: 24.86%\n", + " - Class 3: 24.92%\n", "\n", "-- Testing with test_size = 7000 --\n", - "Requested test size: 7000, Actual test size: 6941\n", + "Requested test size: 7000, Actual test size: 6992\n", " - Test Set:\n", - " - Class 0: 24.88%\n", - " - Class 1: 25.13%\n", - " - Class 2: 25.05%\n", - " - Class 3: 24.94%\n", + " - Class 0: 24.94%\n", + " - Class 1: 25.04%\n", + " - Class 2: 25.14%\n", + " - Class 3: 24.87%\n", "\n", "-- Testing with test_size = 9000 --\n", - "Requested test size: 9000, Actual test size: 8918\n", + "Requested test size: 9000, Actual test size: 8947\n", " - Test Set:\n", - " - Class 0: 24.89%\n", - " - Class 1: 25.08%\n", - " - Class 2: 24.99%\n", - " - Class 3: 25.03%\n", + " - Class 0: 25.08%\n", + " - Class 1: 24.92%\n", + " - Class 2: 25.03%\n", + " - Class 3: 24.97%\n", "\n", "--- Scenario: IMBALANCED ---\n", "Full Dataset Distribution:\n", @@ -1436,59 +796,59 @@ " - Class 3: 3.00%\n", "\n", "-- Testing with test_size = 1000 --\n", - "Requested test size: 1000, Actual test size: 964\n", + "Requested test size: 1000, Actual test size: 957\n", " - Test Set:\n", - " - Class 0: 90.35%\n", - " - Class 1: 3.73%\n", - " - Class 2: 3.01%\n", - " - Class 3: 2.90%\n", + " - Class 0: 90.28%\n", + " - Class 1: 4.39%\n", + " - Class 2: 2.61%\n", + " - Class 3: 2.72%\n", "\n", "-- Testing with test_size = 3000 --\n", - "Requested test size: 3000, Actual test size: 2916\n", + "Requested test size: 3000, Actual test size: 2987\n", " - Test Set:\n", - " - Class 0: 90.05%\n", - " - Class 1: 3.98%\n", - " - Class 2: 3.09%\n", - " - Class 3: 2.88%\n", + " - Class 0: 90.02%\n", + " - Class 1: 4.02%\n", + " - Class 2: 2.85%\n", + " - Class 3: 3.11%\n", "\n", "-- Testing with test_size = 5000 --\n", - "Requested test size: 5000, Actual test size: 4913\n", + "Requested test size: 5000, Actual test size: 4927\n", " - Test Set:\n", - " - Class 0: 89.97%\n", - " - Class 1: 3.97%\n", - " - Class 2: 3.07%\n", - " - Class 3: 2.99%\n", + " - Class 0: 89.95%\n", + " - Class 1: 4.10%\n", + " - Class 2: 3.00%\n", + " - Class 3: 2.94%\n", "\n", "-- Testing with test_size = 7000 --\n", - "Requested test size: 7000, Actual test size: 6907\n", + "Requested test size: 7000, Actual test size: 6891\n", " - Test Set:\n", - " - Class 0: 90.04%\n", - " - Class 1: 3.97%\n", - " - Class 2: 2.97%\n", - " - Class 3: 3.03%\n", + " - Class 0: 89.99%\n", + " - Class 1: 4.08%\n", + " - Class 2: 2.96%\n", + " - Class 3: 2.97%\n", "\n", "-- Testing with test_size = 9000 --\n", - "Requested test size: 9000, Actual test size: 8991\n", + "Requested test size: 9000, Actual test size: 8949\n", " - Test Set:\n", - " - Class 0: 89.95%\n", - " - Class 1: 4.03%\n", - " - Class 2: 3.04%\n", - " - Class 3: 2.99%\n", + " - Class 0: 89.97%\n", + " - Class 1: 3.97%\n", + " - Class 2: 3.06%\n", + " - Class 3: 3.01%\n", "\n", "==================== Running Runtime Analysis ====================\n", "Testing with N = 1000...\n", - " -> Execution time: 0.0193 seconds\n", + " -> Execution time: 0.1363 seconds\n", "Testing with N = 10000...\n", - " -> Execution time: 0.0234 seconds\n", + " -> Execution time: 0.2156 seconds\n", "Testing with N = 100000...\n", - " -> Execution time: 0.0794 seconds\n", + " -> Execution time: 0.2427 seconds\n", "Testing with N = 1000000...\n", - " -> Execution time: 0.7114 seconds\n" + " -> Execution time: 1.7087 seconds\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAAIoCAYAAACbCCHjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAA6TxJREFUeJzsnXdcFNf6/z9bqIJYADuoqGDHAorRWGIBTO/NYEm9uUmupn9zE1NuejM3ITHFFmO66aJCFKNRFAuIFbugqLAivW2Z3x/+di/LFmZmZ3bmsM/79fKVcDjnOU85nxnOzu5ZDcdxHAiCIAiCIAiCIAhJ0CrtAEEQBEEQBEEQRFuCNlkEQRAEQRAEQRASQpssgiAIgiAIgiAICaFNFkEQBEEQBEEQhITQJosgCIIgCIIgCEJCaJNFEARBEARBEAQhIbTJIgiCIAiCIAiCkBDaZBEEQRAEQRAEQUgIbbIIgiAIgiAIgiAkhDZZBEH4FL1798bs2bPt2o4ePYrp06cjLCwMGo0Gv/zyC5YvXw6NRoNTp05JNvfs2bPRu3dvyeyxyKlTp6DRaPDOO+9Iarempgb33nsvunbtCo1Gg3/9618AgAsXLuDmm29G586dodFosGjRImzatAkajQabNm2S1AexOFtrkyZNwqRJkxTzSU40Gg1efPFFpd1QDXJeF+S4jhEEwQ/aZBEEISn79u3DzTffjOjoaAQGBqJHjx6YNm0aPvzwQ7t+r732Gn755RdZfNi2bRtefPFFVFRU8OqflpaGffv24dVXX8XKlSsxevRoWfxyRWNjIz788EOMHz8eHTt2hL+/P7p3745rr70W33zzDcxms1f9Ecvff/+NlJQU9OjRA4GBgYiKisI111yDr7/+Wva5X3vtNSxfvhwPPfQQVq5ciVmzZgEA5s+fj/Xr1+PZZ5/FypUrkZyc7PFcfNe4lJSUlODFF19Efn4+r/7WP66t//R6PXr06IHZs2fj7NmzsvlpJSMjg8mN1K233gqNRoOnn35aaVcIgmAcDcdxnNJOEATRNti2bRsmT56MqKgopKWloWvXriguLsb27dtx/PhxHDt2zNY3JCQEN998M5YvXy65H++88w6efPJJnDx50uEV4sbGRmi1Wvj5+QEA6uvrERwcjOeeew7/+c9/bP3MZjOMRiMCAgKg0Wgk8Wv27NnYtGmT3avKZWVlSElJwe7duzFjxgxMmzYNnTp1wvnz5/Hnn39i48aNePnll/H8889L4oNc/PDDD7jtttsQHx+P22+/HR07dsTJkyexefNm+Pn5ITs7G8DlJ1l9+vTB22+/jSeeeEKy+ceOHQu9Xo+///7brr1r166YOnUqvvrqK1vbpk2bMHnyZGRnZwt+WiRkjfNl+fLlmDNnjt16bWpqAgD4+/sDAHbt2oWEhAQsW7bM4UmsO5svv/wy+vTpg4aGBmzfvh3Lly9H7969sX//fgQGBgr2lS///Oc/kZ6eDmd/YjQ0NECv10Ov18s2vxiqqqrQpUsXdO3aFWazGadPn5ZM++5wdl2QCjmuYwRB8ENdVziCIJjm1VdfRVhYGHbu3IkOHTrY/a60tFS03draWrRr185D7y4TEBBg93NZWRkAOPir0+mg0+kkmdMds2bNQl5eHlavXo0bb7zR7nfPPvssdu3ahcLCQrc2Ghoa4O/vD61WuTcnvPjiixg0aBC2b99u2xhY8aT2fCktLcWgQYOctresrSfItcZb0jKHYklJSbE9mb333nsRHh6ON998E7/99htuvfVWSeYQipybO09YvXo1zGYzli5diilTpmDz5s2YOHGi0m55hLeuYwRBOEJvFyQIQjKOHz+OwYMHO/2jNjIy0vb/Go0GtbW1WLFihe3tTNZX51988UVoNBocPHgQd955Jzp27Ijx48cDAAoKCjB79mz07dsXgYGB6Nq1K+bOnYuLFy/abL/44ot48sknAQB9+vSx2be+Stz8M1kvvvgioqOjAQBPPvkkNBqN7UmCq88yrF27FhMmTEC7du0QGhqKmTNn4sCBAw7x/vLLLxgyZAgCAwMxZMgQ/Pzzzw59cnJysH79etx///0OGywro0ePxl133WX72fp5om+//Rb//ve/0aNHDwQHB6OqqgrA5SdKo0aNQlBQEMLDw3H33Xc7vD3M1ed9Wn42pPnnp95//31ER0cjKCgIEydOxP79++3GHj9+HAkJCU43B81r35zPPvsMMTExCAgIQEJCAnbu3CnYT2s+Tp48iTVr1tjqba0fx3FIT0+3tbtjx44dSE5ORlhYGIKDgzFx4kRs3brVIU4+axy4vM7/+c9/YtWqVYiNjUVgYCBGjRqFzZs3u/WjZeybNm1CQkICAGDOnDl2MQplwoQJtjiczdUcd+vBXe1mz56N9PR0ALB7y6KVlp/Jsmr+yJEjuPvuuxEWFoaIiAg8//zz4DgOxcXFuO6669C+fXt07doV7777roOvjY2NWLhwIfr164eAgAD06tULTz31FBobG3nnZtWqVZg2bRomT56MgQMHYtWqVQ59rOtq69atWLBgASIiItCuXTvccMMNthdsrPz666+YOXMmunfvjoCAAMTExOCVV15x+/ZfjuPQu3dvXHfddQ6/a2hoQFhYGB544AFb24cffojBgwcjODgYHTt2xOjRo+3enuvsOrZr1y7MmDED4eHhCAoKQp8+fTB37lzeeSIIgh/0JIsgCMmIjo5GTk4O9u/fjyFDhrjst3LlStx7771ITEzE/fffDwCIiYmx63PLLbegf//+eO2112xvOcrKysKJEycwZ84cdO3aFQcOHMBnn32GAwcOYPv27dBoNLjxxhtx5MgRfPPNN3j//fcRHh4OAIiIiHDw48Ybb0SHDh0wf/583HHHHUhNTUVISIhbv9PS0jBjxgy8+eabqKurwyeffILx48cjLy/P9gdpZmYmbrrpJgwaNAivv/46Ll68iDlz5qBnz5529n7//XcAwN13391KZh155ZVX4O/vjyeeeAKNjY3w9/e3vUUsISEBr7/+Oi5cuIAPPvgAW7duRV5enugnOl9++SWqq6vx8MMPo6GhAR988AGmTJmCffv2oUuXLgAu137Dhg04c+aMQ5zO+Prrr1FdXY0HHngAGo0Gb731Fm688UacOHHC9lZOPgwcOBArV67E/Pnz0bNnTzz++OMAgBEjRtg+mzVt2jTcc889bu1s3LgRKSkpGDVqFBYuXAitVotly5ZhypQp2LJlCxITE21x8lnjVv766y989913ePTRRxEQEICPP/4YycnJyM3N5TXeGuPLL7+MF154Affff79tozRu3Dhe45tj/WO7Y8eOgsdaaa12DzzwAEpKSpCVlYWVK1fytnvbbbdh4MCBeOONN7BmzRr85z//QadOnfDpp59iypQpePPNN7Fq1So88cQTSEhIwJVXXgkAsFgsuPbaa/H333/j/vvvx8CBA7Fv3z68//77OHLkCK/PfpaUlCA7OxsrVqwAANxxxx14//338dFHHzl94eCRRx5Bx44dsXDhQpw6dQqLFi3CP//5T3z33Xe2PsuXL0dISAgWLFiAkJAQbNy4ES+88AKqqqrw9ttvO/VDo9Hg7rvvxltvvYXy8nJ06tTJ9rvff/8dVVVVtuvF559/jkcffRQ333wzHnvsMTQ0NKCgoAA7duzAnXfe6dR+aWkppk+fjoiICDzzzDPo0KEDTp06hZ9++qnVHBEEIRCOIAhCIjIzMzmdTsfpdDouKSmJe+qpp7j169dzTU1NDn3btWvHpaWlObQvXLiQA8DdcccdDr+rq6tzaPvmm284ANzmzZttbW+//TYHgDt58qRD/+joaLt5T548yQHg3n77bbt+y5Yts7NRXV3NdejQgbvvvvvs+p0/f54LCwuza4+Pj+e6devGVVRU2NoyMzM5AFx0dLSt7YYbbuAA2PXjOI6rr6/nysrKbP8uXbpk+112djYHgOvbt69dPpqamrjIyEhuyJAhXH19va39jz/+4ABwL7zwgq1t4sSJ3MSJEx1yk5aWZuefNTdBQUHcmTNnbO07duzgAHDz58+3tS1ZsoQDwPn7+3OTJ0/mnn/+eW7Lli2c2Wy2m8Nqs3Pnzlx5ebmt/ddff+UAcL///rtgPznucl1nzpzp0BcA9/DDD9u1WXOYnZ3NcRzHWSwWrn///tyMGTM4i8Vi61dXV8f16dOHmzZtmq1NyBoHwAHgdu3aZWs7ffo0FxgYyN1www22tpZrzVnsO3fu5ABwy5Ytc5jHGVabf/75J1dWVsYVFxdzP/74IxcREcEFBARwxcXFLuey4mo98Kndww8/zLn6EwMAt3DhQtvPVs3ff//9tjaTycT17NmT02g03BtvvGFrv3TpEhcUFGSn4ZUrV3JarZbbsmWL3TyLFy/mAHBbt251mScr77zzDhcUFMRVVVVxHMdxR44c4QBwP//8s10/a16nTp1qt1bmz5/P6XQ6Oy07u1498MADXHBwMNfQ0GBra5nnwsJCDgD3ySef2I299tprud69e9vmve6667jBgwe7javl2vr55585ANzOnTvdjiMIwnPo7YIEQUjGtGnTkJOTg2uvvRZ79+7FW2+9hRkzZqBHjx747bffBNl68MEHHdqCgoJs/9/Q0ACDwYCxY8cCAPbs2eOZ862QlZWFiooK3HHHHTAYDLZ/Op0OY8aMsR3scO7cOeTn5yMtLQ1hYWG28dOmTXP4zJD1LX4tn54tXrwYERERtn/Wt0s2Jy0tzS4fu3btQmlpKf7xj3/YfeZl5syZiIuLw5o1a0THfv3116NHjx62nxMTEzFmzBhkZGTY2ubOnYt169Zh0qRJ+Pvvv/HKK69gwoQJ6N+/P7Zt2+Zg87bbbrN7mmJ9OnPixAnRfoolPz8fR48exZ133omLFy/aaltbW4urrroKmzdvhsViASB8jSclJWHUqFG2n6OionDddddh/fr1Xjk1curUqYiIiECvXr1w8803o127dvjtt994PW10hVy1u/fee23/r9PpMHr0aHAch3nz5tnaO3TogNjYWLu5fvjhBwwcOBBxcXF22pwyZQoA2LTpjlWrVmHmzJkIDQ0FAPTv3x+jRo1y+pZBALj//vvt3gI5YcIE22EZVprrs7q6GgaDARMmTEBdXR0OHz7s0pcBAwZgzJgxdnOXl5dj7dq1uOuuu2zzdujQAWfOnHF4m607rE+z//jjDxiNRt7jCIIQDm2yCIKQlISEBPz000+4dOkScnNz8eyzz6K6uho333wzDh48yNtOnz59HNrKy8vx2GOPoUuXLggKCkJERIStX2VlpWQxOOPo0aMAgClTpthtgCIiIpCZmWk79MD6R1b//v0dbMTGxtr9bP2Drqamxq79pptuQlZWFrKysjBs2DCn/rTMj3XelnMAQFxcnN0ff0JxFsuAAQMcPq82Y8YMrF+/HhUVFdi8eTMefvhhnD59GldffbXDoRBRUVF2P1v/aL906ZJoP8VirW1aWppDbb/44gs0NjbarS8ha9xV7urq6hw+wyMH6enpyMrKwo8//ojU1FQYDAaHw1+EIlftWtoNCwtDYGCg7S2/zdubz3X06FEcOHDAoXYDBgwA0PqBJIcOHUJeXh6uuOIKHDt2zPZv0qRJ+OOPP2wvhrjz1VkODhw4gBtuuAFhYWFo3749IiIibG/1a+16dc8992Dr1q023f7www8wGo22ryYAgKeffhohISFITExE//798fDDDzt8hrAlEydOxE033YSXXnoJ4eHhuO6667Bs2TJBn10jCIIf9JksgiBkwd/fHwkJCUhISMCAAQMwZ84c/PDDD1i4cCGv8c1fBbZy6623Ytu2bXjyyScRHx+PkJAQWCwWJCcn2540yIXV/sqVK9G1a1eH34s5jjouLg4AsH//flxxxRW29l69eqFXr14ALv/xZjAYHMY6yw9frAdCtESqJyvBwcGYMGECJkyYgPDwcLz00ktYu3Yt0tLSbH1cnXjW3C+5/bRire3bb7+N+Ph4p32cfVbP0zXuDRITE22nC15//fUYP3487rzzThQWFtpiEppnPrUTgzO7fOayWCwYOnQo3nvvPad9rVpyhfV4//nz52P+/PkOv1+9ejXmzJkjyK+KigpMnDgR7du3x8svv4yYmBgEBgZiz549ePrpp1u9Xt1+++2YP38+Vq1ahf/7v//DV199hdGjR9u9iDJw4EAUFhbijz/+wLp167B69Wp8/PHHeOGFF/DSSy85tavRaPDjjz9i+/bt+P3337F+/XrMnTsX7777LrZv3+72M6kEQQiDNlkEQciO9Y+8c+fO2dqEfmfLpUuXsGHDBrz00kt44YUXbO3WpxDNkeP7YKwHc0RGRmLq1Kku+1lPK3TmV8uj2K+++mq88cYbWLVqld0mSwzWeQsLC21vk2o+r/X3wOWNm7O3drl62uUsliNHjjh8B5kznNWeL0L9FIu1tu3bt3dbW3e4itNV7oKDg50exuIKKda0TqfD66+/jsmTJ+Ojjz7CM888A0CePHvzO5liYmKwd+9eXHXVVYLn5TgOX3/9NSZPnox//OMfDr9/5ZVXsGrVKodNVmts2rQJFy9exE8//WQ7oAMATp48yWt8p06dMHPmTKxatQp33XUXtm7dikWLFjn0a9euHW677TbcdtttaGpqwo033ohXX30Vzz77rNuj8seOHYuxY8fi1Vdfxddff4277roL3377rd1bNgmC8Ax6uyBBEJKRnZ3t9NVs62d3mr8K265dO1RUVPC2bX3luKV9V394ABBkvzVmzJiB9u3b47XXXnP6WQbrW7+6deuG+Ph4rFixwu4tQVlZWQ5vJbviiiswbdo0fPbZZ/j111+dzsv36cDo0aMRGRmJxYsX2731Z+3atTh06BBmzpxpa4uJicHhw4ft3q62d+9el281+uWXX+yOgc/NzcWOHTuQkpJia9uwYYPTsc5qzxehfopl1KhRiImJwTvvvOPw1k0AdvMLWePA5WP6m39esLi4GL/++iumT58u6PuLpFrTkyZNQmJiIhYtWoSGhgYA8uRZDg264tZbb8XZs2fx+eefO/yuvr4etbW1Lsdu3boVp06dwpw5c3DzzTc7/LvtttuQnZ2NkpISQT45u141NTXh448/5m1j1qxZOHjwIJ588knodDrcfvvtdr9v/tUVwOUnq4MGDQLHcS4/b3Xp0iWH9Wt9ektvGSQIaaEnWQRBSMYjjzyCuro63HDDDYiLi0NTUxO2bduG7777Dr1797Z7NXjUqFH4888/8d5776F79+7o06cPxowZ49J2+/btceWVV+Ktt96C0WhEjx49kJmZ6fSVYetBA8899xxuv/12+Pn54ZprrvHoC43bt2+PTz75BLNmzcLIkSNx++23IyIiAkVFRVizZg2uuOIKfPTRRwCA119/HTNnzsT48eMxd+5clJeX277PpuUf8V999RWSk5Nx/fXXIyUlBVOnTkXHjh1x/vx5/Pnnn9i8ebPdZsYVfn5+ePPNNzFnzhxMnDgRd9xxh+0I9969e9u9DWru3Ll47733MGPGDMybNw+lpaVYvHgxBg8e7PTzJ/369cP48ePx0EMPobGxEYsWLULnzp3x1FNP2fpcd9116NOnD6655hrExMSgtrYWf/75J37//XckJCTgmmuuEZxzoX6KRavV4osvvkBKSgoGDx6MOXPmoEePHjh79iyys7PRvn1723H7QtY4AAwZMgQzZsywO8IdgMu3c7kiJiYGHTp0wOLFixEaGop27dphzJgxTj+72BpPPvkkbrnlFixfvhwPPvigLHm2avDRRx/FjBkznG4SpGLWrFn4/vvv8eCDDyI7OxtXXHEFzGYzDh8+jO+//x7r16+3PWlsyapVq6DT6exehGjOtddei+eeew7ffvstFixYwNuncePGoWPHjkhLS8Ojjz4KjUaDlStXCnpL5cyZM9G5c2f88MMPSElJcfgetunTp6Nr16644oor0KVLFxw6dAgfffSR3QEeLVmxYgU+/vhj3HDDDYiJiUF1dTU+//xztG/fHqmpqbx9IwiCB14/z5AgiDbL2rVrublz53JxcXFcSEgI5+/vz/Xr14975JFHuAsXLtj1PXz4MHfllVdyQUFBHADbkczW45zLysoc7J85c4a74YYbuA4dOnBhYWHcLbfcwpWUlDgcCc1xHPfKK69wPXr04LRard0RxmKPcLeSnZ3NzZgxgwsLC+MCAwO5mJgYbvbs2XbHdHMcx61evZobOHAgFxAQwA0aNIj76aefnB49znGXj2xftGgRl5SUxLVv357T6/Vc165duauvvppbtWoVZzKZ7OYHwP3www9OKsBx3333HTdixAguICCA69SpE3fXXXfZHb9u5auvvuL69u3L+fv7c/Hx8dz69etdHtn99ttvc++++y7Xq1cvLiAggJswYQK3d+9eO3vffPMNd/vtt3MxMTFcUFAQFxgYyA0aNIh77rnnbMdiu8s3xzke7c3XT47z7Ah3K3l5edyNN97Ide7cmQsICOCio6O5W2+9lduwYYOtj5A1bp37q6++4vr3788FBARwI0aMcJiXzxHuHHf5qPRBgwZxer2+1ePcrTadHdVtNpu5mJgYLiYmxra2hK6HlrSsnclk4h555BEuIiKC02g0dse5t+zrSvNpaWlcu3btHOaaOHGiw9HlTU1N3JtvvskNHjyYCwgI4Dp27MiNGjWKe+mll7jKykqnOWpqauI6d+7MTZgwwenvrfTp04cbMWIEx3Gu8+psTW3dupUbO3YsFxQUxHXv3t123H/Lfq6uCxzHcf/4xz84ANzXX3/t8LtPP/2Uu/LKK23rNSYmhnvyySft4m25tvbs2cPdcccdXFRUFBcQEMBFRkZyV199tcP1iyAIz9FwnIefVCUIgiDaJKdOnUKfPn3w9ttv44knnlDaHebQaDR4+OGHbU84CUIo8+fPx5IlS3D+/HkEBwcr7Q5BEAKgz2QRBEEQBEGojIaGBnz11Ve46aabaINFEAxCn8kiCIIgCIJQCaWlpfjzzz/x448/4uLFi3jssceUdokgCBHQJosgCIIgCEIlHDx4EHfddRciIyPx3//+1+V3txEEoW7oM1kEQRAEQRAEQRASQp/JIgiCIAiCIAiCkBDaZBEEQRAEQRAEQUgIfSbLDRaLBSUlJQgNDYVGo1HaHYIgCIIgCIIgFILjOFRXV6N79+7Qat0/q6JNlhtKSkrQq1cvpd0gCIIgCIIgCEIlFBcXo2fPnm770CbLDaGhoQAuJ7J9+/a8xhiNRmRmZmL69Onw8/OTtL9Q274CK3lRwk8555TKtqd2xI4nrXofVvJCWpXHjtq0ysp6VAIWcqOUj6RVacawek+tqqpCr169bHsEd9Amyw3Wtwi2b99e0CYrODgY7du3573I+PYXattXYCUvSvgp55xS2fbUjtjxpFXvw0peSKvy2FGbVllZj0rAQm6U8pG0Ks0Y1u+pfD5GREe4u6GqqgphYWGorKzkvcmyvleT7+e4hPQXattXYCUvSvgp55xS2fbUjtjxpFXvw0peSKvy2FGbVllZj0rAQm6U8pG0Ks0YVu+pQvYGdLqgDAQFBcnWX6htX4GVvCjhp5xzSmXbUztix5NWvQ8reSGtymNHbVplZT0qAQu5UcpH0qo0Y9r6PZU2WRJjMpmQkZEBk8kkeX+htn0FVvKihJ9yzimVbU/tiB1PWvU+rOSFtCqPHbVplZX1qAQs5EYpH0mr0ozxhXsqfSaLB0ajEUajEQCg1Wqh0+lgNpthsVhsfazt1gVg7a/T6aDVamEymdD8nZnWdms/63/1+sslabmQ9Hq9bby1LwD4+fnBYrHAbDbb2jQaDfR6vct2V767i8mZ763F1Nx3VzE5axcak5Xm86o1puZ+eqNOznIjVUzObIuJyZkdIXVqPk5ITGL01Ly/nDE1b/e2nuS8RrTMoVpjsuJMN3LVydmcUsVkHdtyTqExOdOMu5ha1qn5ODmvEc76O4vJ+v8cx4mOqbnvbemea+1jsVicrkk1xOSufnLWSSo9yRmT1WbzNncxtayTdW5rHz4xCdVT8zlau+41/73Sa6/l791BmywnpKenIz093VbczMxMBAcHAwCioqIwYsQIFBQUoKioyDYmNjYWcXFx2LNnDwAgKysLABAfH4/o6Ghs3rwZ1dXVtv5JSUmIjIxEdna2Xf/JkycjKCgIGRkZdj6lpqaipqbGrq9er8fMmTNhMBiQk5Nj6xsaGoopU6aguLgY+fn5tvaIiAiMGzcOR48eRWFhoa29tZhyc3NRVlZma28tpszMTDshuYupvr7elgOxMSUkJNjlRa0xXbx40c5Pb9Spe/fuDrmRKqbp06c72BYT05AhQxzsCK2TFSExCdXT2bNn7frLHZNSepLzGmHVanZ2tqpjiomJAWBfP7nrJJWenMXUr18/AMCePXtgMBhExzRhwgQHH93F5KxOVuS8Rgi57gGX/3jyJKa2eM8NCQkBAJw9exb79u1TbUwAUFNTgy1btrQak9r0JGdM4eHhAIDjx4/j2LFjrcbkqk5nz55F3759eccECNMTAFy8eBE7d+5sNSYrSq+9uro6B59cQQdfuMH64TaDwWD7cFtrO+b6+npkZmZi2rRp8PPza3XHXFdXh6ysLFt/d69AGY1GrF271tYX8J1X1dzFxHEcMjIy7PKixpgaGxuxbt06m5/eqJPZbHbIjZSvvLe0LSYmi8Xisn58n2RlZWUhNTXVwT8p9eSqfnLE1Lxd7U99hD7Jap5DtcbkrH7eeJIlhZ5cvfK+fv16TJ8+3Ta/mJg4jnPQjLuYnD3JsmrV6iefmITqie91z+pPSkqKw4fpWdCT3E+yMjMzkZycbPc0UU0xuauf3E+ypNCTnDFZ6zdjxgy7p7tCnmRlZWUhOTkZAQEBvJ9kCdFT8zmcrTFX1w7rNUFoTC19F1unqqoqhIeH8zr4gjZZbhB7uqDJZIJer+d9ugrf/kJt+wqs5EUJP+WcUyrbntoRO5606n1YyQtpVR47atMqK+tRCVjIjVI+klalGcPqPZVOF1SY+vp62foLte0rsJIXJfyUc06pbHtqR+x40qr3YSUvpFV57KhNq6ysRyVgITdK+UhalWZMW7+n0iZLYkwmk8PnDaTqL9S2r8BKXpTwU845pbLtqR2x40mr3oeVvJBW5bGjNq2ysh6VgIXcKOUjaVWaMb5wT6VNFkEQBEEQBEEQhITQJosgCIIgCIIgCEJCaJMlA81Pm5G6v1DbvgIreVHCTznnlMq2p3bEjieteh9W8kJalceO2rTKynpUAhZyo5SPpFVpxrT1eyqdLugGMacLEgRBEARBEATR9qDTBRXEYrGgtLTU7qx+qfoLte0rsJIXJfyUc06pbHtqR+x40qr3YSUvpFV57KhNq6ysRyVgITdK+UhalWYM3/5mC4dtx8qwcvMhbDtWBrOFnWdDtMmSGLPZjJycHLsvhZOqv1DbvgIreVHCTznnlMq2p3bEjieteh9W8kJalceO2rTKynpUAhZyo5SPpFVpxvDpv27/OYx/cyPu/CIXz2ecwJ1f5GL8mxuxbv853n4pCW2yCIIgCIIgCIJQDev2n8NDX+3BucoGu/bzlQ146Ks9TGy0aJNFEARBEARBEIQqMFs4vPT7QTh7Y6C17aXfD6r+rYO0yZIYjUaD0NBQaDQayfsLte0rsJIXJfyUc06pbHtqR+x40qr3YSUvpFV57KhNq6ysRyVgITdK+UhalWaMu/65J8sdnmA1hwNwrrIBuSfLefunBHS6oBvodEGCIAiCIAiC8B6/5p/FY9/mt9rvg9vjcV18D/kdaoaQvQF7h84rgNFohNFoBABotVrodDqYzWa7E1Gs7U1NTThz5gx69Ohha9NqtTCZTGi+n7W2NzY24uzZs7b+1u8BMJlMdj7o9XpYLBacPn3a1hcA/Pz8YLFY7D44qNFobP2dtbvy3VW7K99dtVtz1dx3VzE5axcak1arxenTp9G9e3dbXtQYk8lkQlFRka1+3qgTAJw6dcpuzUgVk06nQ1FREbp162azLSYmjUbjsn586mSxWHDu3DlERUU5fIBWSj25qp8cMUlZJzVdIzQaDc6ePYuuXbva8qLGmDQajUvdyFUnqfTkLCYAKCkpQbdu3exeNRYak1arRXFxsZ2P7mJqWSeLxYKzZ8+id+/eACDbNQLgd92zXjt69erlkC8W9CTnNYLjOJw7dw49evRw0LBaYnJXPznrBEijJzljstave/fudjb41smq1aioKNv9r7WYhOrJYrHg/PnzTtdYZGgg+NA5+HLdvLn2Wv7eHbTJckJ6ejrS09NtCzYzMxPBwcEAgKioKIwYMQIFBQUoKiqyjYmNjUVcXBx27twJg8GAffv2AQDi4+MRHR2NzZs3o7q62tY/KSkJkZGR+PPPP2EymWz9J0+ejKCgIGRkZNj5lJqaiurqauzbt8/WV6/XY+bMmTAYDMjJybH1DQ0NxZQpU1BcXIz8/Hxbe0REBMaNG4ejR4+isLDQ1t5aTLm5uSgrK7O1txZTZmamnZDcxVRfX4/s7Gxbm5iYEhISUFBQgIKCAlXHVFpaalc/b9Spe/fudnNKGdP06dOxd+9e7N2719YuJqYhQ4Y41E9onQCgR48egmISqqeioiK7/nLHpJSe5LxGJCQkID8/33bTVmtMMTExDrqRu05S6clZTP369cOxY8dw5swZGAwG0TFNmDDBwUd3MTmrEwD06tULJSUlsl0jhFz3ACAyMhJZWVmiY2qL99yQkBDU1NTAbDbb5VFtMQFA+/btsWXLllZjUpue5IwpPDwcBoMBNTU1OHbsWKsxuaoTAPTt25d3TIAwPZlMJvj5+WHnzp12MU2cNBmhAVpUN7o63p1DB3+g7OB2FNR6d+3V1dW58MkRerugG6yPBA0Gg+2RYGuvAtTX1yMzMxPTpk2Dn59fqzvmuro6ZGVl2fq7ewXKaDRi7dq1tr6A77yq5i4mjuOQkZFhlxc1xtTY2Ih169bZ/PRGncxms0NupIoJgINtMTFZLBaX9eNTJ6PRiKysLKSmpjr4J6WeXNVPjpiat7elJ1kWi8Uuh2qNyVn95K4TII2enMVkNpuxfv16TJ8+3Ta/mJg4jnPQjLuYWtapuVatfvKJSaie+F73rP6kpKQ4fC6EBT3JeY0wmUzIzMxEcnKy3VNLNcXkrn5y1kkqPckZk7V+M2bMsD3ddRdTyzpZ/UhOTkZAQACvmITqqfkcLdfYxkIDHli52+nBF1bLH94+HDMGd/H62quqqkJ4eDi9XVAq/Pz87G4owOViNF+4VqzFaDmmuRBb2nbWv+V8AGyLtmVfrVZrt0Bba3fle2sx8W135rvQdiExWQUhpk5826WKyZmfctbJetF1lhtPY3KXdyExWS+KzuzIWScxenLWX00xuWpXyzXC3Zpx5burdjljElM/tejJXbter3fqD9+YxNRPijoJrYfQ655Go1HN2gPUd41w1l9NMbmqnzfq5Ime3LVLGZOQ+rX03WpTSExi9NS8ffuJi/jnN3ngACT17YyTF2txvtkhGF3DArHwmkFIHtJNVEyttbfmu6vfO52Dd0+CFxqNBhEREYJOV+HbX6htX4GVvCjhp5xzSmXbUztix5NWvQ8reSGtymNHbVplZT0qAQu5UcpH0qo0Y5z133+2Eveu2IUmkwXTBnXBJ3eNhEajQc6xMmzPP4ix8YOQ1C8COq1612Vz6O2CbqDTBQmCIAiCIAhCXk4aanHL4m0w1DQhsU8nfDk3EYF+jk+mlEbI3oC+J0tizGYzDh8+7HDKmRT9hdr2FVjJixJ+yjmnVLY9tSN2PGnV+7CSF9KqPHbUplVW1qMSsJAbpXwkrUozpnn/C1UNmLVkBww1TRjUrT2+SBttt8FiYT06gzZZEmOxWFBYWOhwfKUU/YXa9hVYyYsSfso5p1S2PbUjdjxp1fuwkhfSqjx21KZVVtajErCQG6V8JK1KM8ba/1JtI+5Zkoszl+rRu3MwVsxNRPtAP6d91bwenUGbLIIgCIIgCIIgvEqTGbj/qzwUXqhGZGgAVs4bg4jQAKXdkgw6+IIgCIIgCIIgCK9hNFuw9IgWhyoq0D5Qj5XzxqBXp2Cl3ZIUepIlMVqtFlFRUU6P0vS0v1DbvgIreVHCTznnlMq2p3bEjieteh9W8kJalceO2rTKynpUAhZyo5SPpFXPx1gsHJ75+QAOVWgR6KfFsjkJiO0aKqk/aoBOF3QDnS5IEARBEARBENLAcRxe+v0glm87Bb1Wg8/vGY3JcZFKu8UbOl1QQcxmM/Ly8gSdrsK3v1DbvgIreVHCTznnlMq2p3bEjieteh9W8kJalceO2rTKynpUAhZyo5SPpFXPxny48RiWbzsFAPhnQhiu7N9ZFn/UAG2yJMZisaCoqEjQ6Sp8+wu17Suwkhcl/JRzTqlse2pH7HjSqvdhJS+kVXnsqE2rrKxHJWAhN0r5SFoVP2bl9tN4L+sIAODfqbHoozW06XsqbbIIgiAIgiAIgpCNPwpK8MKv+wEAj07ph7SkaIU9kh/aZBEEQRAEQRAEIQubj5Rh/nf54DjgrjFRmD9tgNIueQXaZEmMVqtFbGysoFOQ+PYXattXYCUvSvgp55xS2fbUjtjxpFXvw0peSKvy2FGbVllZj0rAQm6U8pG0KmxMXtElPPjVbhjNHGYO64aXrxsCjUbjE/dUOl3QDXS6IEEQBEEQBEEI51hpNW5enIOKOiMm9A/HkrQE+OvZ2ii1RMjegL6MmAdGoxFGoxHA5d20TqeD2Wy2+wCetb2hoQG7du3CqFGjoNfrodPpoNVqYTKZ0Hw/a22vr6/H7t27bf31+sslMZlMdj7o9XqYTCbs2LHD1hcA/Pz8YLFY7E5c0Wg00Ov1Lttd+e6q3ZXvrtqtuWruu6uYnLULjQkAduzYgZEjR9psqjGmpqYm5Obm2urnjTpZLBaH3EgVk0ajcbAtJiaO41zWj0+dTCYT9uzZgzFjxqDla0ZS6slV/eSISco6qekawXEcdu3ahREjRtj8VWNMzuond52k0pOzmCwWC3bv3o2RI0dCp9M5+M43JgDIzc2189FdTC3r1FyrWq1WtmsE3+ue1Z/ExESHOFnQk5zXCLPZjD179mD06NG2+6zaYnJXPznrJJWe5IzJWr9Ro0bZPf3hWyeTyYTdu3cjMTER/v7+vGJq6XtJRT3u/iIXFXVGDO8Zhk/uGgkNZ4bR+L/rQV5enss15uraodFoFF17zq6LrqBNlhPS09ORnp5uK25mZiaCgy9/C3VUVBRGjBiBgoICFBUV2cbExsYiLi4Ou3fvxsWLF5GZmQkAiI+PR3R0NDZv3ozq6mpb/6SkJERGRmLjxo0wmUy2/pMnT0ZQUBAyMjLsfEpNTUV1dbWdbb1ej5kzZ8JgMCAnJ8fWNzQ0FFOmTEFxcTHy8/Nt7RERERg3bhyOHj2KwsJCW3trMeXm5qKsrMzW3lpMmZmZdhcNdzHV19cjOzvb1iYmpoSEBBgMBlte1BxT8/p5o07du3d3yI1UMU2fPt3BtpiYhgwZ4mBHaJ2Ay3/AC4lJqJ7OnDlj11/umJTSk5zXiISEBJSVldmue2qNKSYmxqF+ctdJKj05i6lfv34oKyvD7t27YTAYRMc0YcIEBx/dxeSsTsBlrcp5jRBy3QMu/9GUlZUlOqa2eM8NCQlBTU0Nzpw5g3379qk2JgCorq7Gli1bWo1JbXqSM6bw8HAYDAYcO3YMx44dazUmV3U6c+YM+vbtyzsm4LKefs7Iwgf7dSht0KBLEIfP7h4BS1M9MlqsPZPJBIPBgJ07d7YaE3D52nHs2DFF115dXR34Qm8XdIP1kaDBYLA9Emxtx1xfX4/MzExMmzYNfn5+re6Y6+rqkJWVZevv7hUoo9GItWvX2voCvvOqmruYOI5DRkaGXV7UGFNjYyPWrVtn89MbdTKbzQ65kSomAA62xcRksVhc1o9Pnax/IKWmpjr4J6WeXNVPjpiat7elJ1kWi8Uuh2qNyVn95K4TII2enMVkNpuxfv16TJ8+3e4JlNCYOI5z0Iy7mFrWqblWrX7yiUmonvhe96z+pKSk2L2SLiSm5r63pXuu9cXf5ORkuychaorJXf3krJNUepIzJmv9ZsyYYfe0jW+drH4kJycjICCAV0zWMROmTEPa8t3Yd7YK3cIC8d19iejVOcRlrK7WmKtrh/WaIDQmqepUVVWF8PBwerugVPj5+dndUIDLxWi+cK00f9uRs5uQM9vO+recD/jfW+Na9tVqtU4/DOiq3ZXvrcXEt92Z70LbhcRkFYSYOvFtlyomZ37KWSfrBcpZbjyNyV3ehcRkvSg6syNnncToyVl/NcXkql0t1wh3a8aV767a5YxJTP3Uoid37Xq93qk/fGMSUz8p6iS0HkKvexqNRjVrD1DfNcJZfzXF5Kp+3qiTJ3py1y5lTELq19J3q02+MZkswMPf7MW+s1Xo1M4fK+eNQVR4iMv+1jmExKr02nP1e2ew/ekzFaLT6RAfH++00J72F2rbV2AlL0r4KeecUtn21I7Y8aRV78NKXkir8thRm1ZZWY9KwEJulPKRtOoCjRa/lXVCzolytPPXYfmcBPSLDHHZ3RfuqfR2QTfQ6YIEQRAEQRAE4RqO4/B/P+/DN7nF8NdpsWxOAq7oF660W7IgZG9AT7IkxmQyOXyoW6r+Qm37CqzkRQk/5ZxTKtue2hE7nrTqfVjJC2lVHjtq0yor61EJWMiNUj6SVh15J7MQ3+QWQwPgvVuH8tpg+cI9lTZZEsNxHKqrqx2Okpaiv1DbvgIreVHCTznnlMq2p3bEjieteh9W8kJalceO2rTKynpUAhZyo5SPpFV7vthyAunZxwEAt/Y1Y8agLpLPwcJ6dAZtsgiCIAiCIAiCEMTq3WfwnzWHAAALpvbDuC5sbYLkhjZZBEEQBEEQBEHw5s+DF/DU6gIAwLzxffDglX0U9kh90MEXbhBz8IXFYoHBYEB4eLjToyc96S/Utq/ASl6U8FPOOaWy7akdseNJq96HlbyQVuWxozatsrIelYCF3CjlI2kVyD1ZjllLdqDRZMGNI3rgnVuGA+B84p4qZG9Amyw30OmCBEEQBEEQBHGZgyVVuO2zHFQ3mHBVXCQWzxoFP506N+JyQKcLKojRaMSaNWscvjFaiv5CbfsKrORFCT/lnFMq257aETuetOp9WMkLaVUeO2rTKivrUQlYyI1SPvqyVk9frEXaslxUN5iQ0Lsj0u8aadtg0T3VEdpkyYCY42nlsu0rsJIXJfyUc06pbEtxXK03xpFWPYeVvJBW5bGjNq2ysh6VgIXcKOWjL2q1tKoBs5bkoqy6EXFdQ/FFWgIC/XRux0jpIwvrsSW0ySIIgiAIgiAIwimV9UbcszQXReV1iOoUjC/nJiIsyE9pt1QPbbIIgiAIgiAIgnCgvsmMe1fsxOHz1QgPCcDKeYmIbB+otFtMQAdfuEHMwRfWL0wLDQ2FRqORtL9Q274CK3lRwk8555TKtqd2xI4nrXofVvJCWpXHjtq0ysp6VAIWcqOUj76k1cDgdnjoqz3YcLgUoYF6fHd/EgZ1d/73sK/cU+ngC4UJCgqSrb9Q274CK3lRwk8555TKtqd2xI4nrXofVvJCWpXHjtq0ysp6VAIWcqOUj76g1YCAQDy9eh82HC5FgF6LJWkJLjdYYuds6/dU2mRJjMlkQkZGhqAP3fLtL9S2r8BKXpTwU845pbLtqR2x40mr3oeVvJBW5bGjNq2ysh6VgIXcKOWjL2jVaDTigcXr8XPeWei0Gnx810gk9ukk6Zy+cE+lTRZBEARBEARBEACATzefxKZzl7cIb900DFcN7KKwR2xCmyyCIAiCIAiCIPD1jiK8++cxAMD/pcTiplE9FfaIXfRKO8ACRqPR9gVoWq0WOp0OZrMZFovF1sfabn2Uae2v0+mg1WphMpnQ/IwRa7u1n/W/ev3lkrR8JKrX623jm38Zm5+fHywWC8xms61No9FAr9e7bHflu7uYnPneWkzNfXcVk7N2oTFZaT6vWmNq7qc36uQsN1LF5My2mJic2RFSp+bjhMQkRk/N+8sZU/N2b+tJzmtEyxyqNSYrznQjV52czSlVTNaxLecUGpMzzbiLqWWdmo+T8xrhrL+zmKz/z3Gc6Jia+96W7rnWPhaLxemaVENM7uonZ52k0pOcMVltNm9zF5O1/Y+9Z/DvX/YBAKb2sCBtbC+bvdZiEqonax9Xa8zVtUPptSfkC5Fpk+WE9PR0pKen24qbmZmJ4OBgAEBUVBRGjBiBgoICFBUV2cbExsYiLi4OeXl5AICsrCwAQHx8PKKjo7F582ZUV1fb+iclJSEyMhLZ2dl2/SdPnoygoCBkZGTY+ZSamor6+nq7vnq9HjNnzoTBYEBOTo6tb2hoKKZMmYLi4mLk5+fb2iMiIjBu3DgcPXoUhYWFtvbWYsrNzUVZWZmtvbWYMjMz7YTUWkzWHIiNKSkpCf369bPlRa0xVVRUAPhf/bxRp6ioKISEhNjlRqqYUlNTkZCQYGdbTEzx8fHo2bOnnR2hdUpISIBer3d4z7aUejp37pxdf7ljUkpPcl4jxo4di9TUVNXHFBsbi/DwcLv6yV0nqfTkLKYBAwYgNTUVO3fu9GjtTZo0CdOmTbPz0V1MzuoUEhICvV6PoqIi2a4RQq57EyZMAADVrD01XSNSU1Nx9uxZ7N27V7UxTZs2DfX19di0aROvmNSkJ7ljSk1NxbFjx3DkyJFWY4qNjcVFfTj+9d1eWDggKdKCq3tZcO7cOfTu3Zt3TEL1lJqaivLycmzfvr3VmMLDw6HX61FYWKjo2qurqwNf6Ah3N1iPaTQYDLZjGlvbMRuNRlRXVyMkJAQajabVHXNTUxNqamps/Vt75b2iosLWF/CdV9XcxaTT6VBZWYng4GBbXtQYk9lsRmVlpa1+3qiTRqPBpUuX7NaMVDHp9XqHvIuJSavVoqKiAu3atXOoH586cRyHuro6hIWFCfJdqJ5c1U+OmKSsk5quEVqtFrW1tQgMDLR7Cq22mJzVT+46SaUnZzFpNBrU1dU5nM4lNCadTofq6moEBQXxql/LOnEch5qaGnTs2BEcx8l2jeB73eM4DvX19QgNDXV4xZ8FPcl5jQCA+vp6tGvXzmEtqSUmd/WTs05S6UnOmIDL9QsODna4BjuLaX9JNe5ekovaJjNmDIrEoluHob6uFmFhYW7r54meOI5DQ0ODyzXW8tpRW1uLDh06wGKxKLr2qqqqEB4ezu/rnTjCJZWVlRwArrKykveYpqYm7pdffuGampok7y/Utq/ASl6U8FPOOaWy7akdseNJq96HlbyQVuWxozatsrIelYCF3CjlY1vT6tEL1dyIlzO56Kf/4O78PIdrMJpE+eEr91QhewM6+IIgCIIgCIIgfIySinrcs2QHymubMKxnGD6dNRoBel3rAwle0CaLIAiCIAiCIHyIS7VNuGdpLkoqG9A3oh2WzU5ASAAd1SAltMmSAev7N+XoL9S2r8BKXpTwU845pbLtqR2x40mr3oeVvJBW5bGjNq2ysh6VgIXcKOUj61qtbTRh9vKdOFZag25hgVg5bww6hwR47AfdU+2hgy/cYD34gteH2wiCIAiCIAhCxTSazLh3xS5sOWpAh2A//PhgEvpFhirtFjMI2RvQkyyJsVgsKC0ttTvhRKr+Qm37CqzkRQk/5ZxTKtue2hE7nrTqfVjJC2lVHjtq0yor61EJWMiNUj6yrFWzhcOC7/diy1EDgv11WDY7wekGS4wfdE91hDZZEmM2m5GTk+NwfKUU/YXa9hVYyYsSfso5p1S2PbUjdjxp1fuwkhfSqjx21KZVVtajErCQG6V8ZFWrHMfhhV/3Y03BOfjpNFh89yiMiOoomR90T3WENlkEQRAEQRAE0YZ5P+sIVu0ogkYDvH9bPK4cEKG0S20e2mQRBEEQBEEQRBtl2daT+O/GYwCAl68bgquHdVfYI9+ANlkSo9FoEBoaavuWeSn7C7XtK7CSFyX8lHNOqWx7akfseNKq92ElL6RVeeyoTausrEclYCE3SvnImlZ/yTuLl34/CABYMG0AZo2NlsUPuqc6QqcLuoFOFyQIgiAIgiBYJLuwFPet2AWThcPscb2x8JpBzG1U1AadLqggFosFp0+fFnS6Ct/+Qm37CqzkRQk/5ZxTKtue2hE7nrTqfVjJC2lVHjtq0yor61EJWMiNUj6yotU1Ow7hoa92w2ThcF18d7xwNf8Nlhg/6J7qCG2yJMZsNiM/P1/Q6Sp8+wu17Suwkhcl/JRzTqlse2pH7HjSqvdhJS+kVXnsqE2rrKxHJWAhN0r5yIJWD56twBO/HUeD0YJJsRF455bh0Gr5P8ES4wfdUx2hTRZBEARBEARBtAGKy+sw98s9qDdrMKJXGD6+ayT8dPTnvhJQ1gmCIAiCIAiCccqqGzFryQ6UVjeiWxCHz+4eiWB/vdJu+SyUeYnRaDSIiIgQdLoK3/5CbfsKrORFCT/lnFMq257aETuetOp9WMkLaVUeO2rTKivrUQlYyI1SPqpVq1UNRqQtzcWpi3Xo2SEIzyb6o2M7f6/5QfdUR+h0QTfQ6YIEQRAEQRCEmmkwmnHP0lzknixHeIg/fnhwHPqEt1ParTYJnS6oIGazGYcPHxb0wT++/YXa9hVYyYsSfso5p1S2PbUjdjxp1fuwkhfSqjx21KZVVtajErCQG6V8VJtWTWYL/vl1HnJPliM0QI/lcxIR1THQ61qle6ojtMmSGIvFgsLCQkFHWPLtL9S2r8BKXpTwU845pbLtqR2x40mr3oeVvJBW5bGjNq2ysh6VgIXcKOWjmrTKcRye/Wkf/jx0Af56LT5PG40hPcIU0SrdUx2hTRZBEARBEARBMMYbaw/jh91noNUAH90xAmP7dlbaJaIZtMkiCIIgCIIgCIZY/NdxfLr5BADgjZuGYfrgrgp7RLSENlkSo9VqERUVBa2WX2qF9Bdq21dgJS9K+CnnnFLZ9tSO2PGkVe/DSl5Iq/LYUZtWWVmPSsBCbpTyUQ1a/X5nMd5YexgA8H+pcbh1dC9JfRQznu6pjtDpgm6g0wUJgiAIgiAItbD+wHk89NVuWDjggYl98WzKQKVd8imE7A3oe7J4YDQaYTQaAVzeTet0OpjNZrsP4FnbGxsbsX//fgwePBg6nQ46nQ5arRYmkwnN97PW9oaGBhw4cMDWX6+/XBKTyWTng16vh9lsxt69e219AcDPzw8Wi8XuxBWNRgO9Xu+y3ZXvrtpd+e6q3Zqr5r67islZu9CYNBoN9u7di0GDBtnyosaYjEYjCgoKbPXzRp04jkN+fr7dmpEqJq1W65B3MTEBcPBRSJ3MZjMOHjyI4cOHO3woVko9uaqfHDE1b/e2nuS8RgDA/v37MXDgQFte1BgT4Fg/uesklZ6cxcRxHA4cOIBBgwbZvRIsNCaNRoOCggI7H93F1LJOZrMZBw4cQHx8PDQajWzXCL7XPeu1Y9iwYQ7rlAU9yXmNsFgsOHjwIIYMGWLXV00xuaufnHWSSk9iYtp2rAyPfJMHCwfcPLIHnpjaDwBc1m/w4MF23y3Ft05WrQ4bNgx+fn68YhKqJ7PZjEOHDrlcY66uHdb4hMbU0nexdWr5e3fQJssJ6enpSE9PtxU3MzMTwcHBAICoqCiMGDECBQUFKCoqso2JjY1FXFwcdu3aBYPBgDNnzgAA4uPjER0djc2bN6O6utrWPykpCZGRkdiwYQNMJpOt/+TJkxEUFISMjAw7n1JTU1FdXY0zZ87Y+ur1esycORMGgwE5OTm2vqGhoZgyZQqKi4uRn59va4+IiMC4ceNw9OhRFBYW2tpbiyk3NxdlZWW29tZiyszMtBOSu5jq6+uRnZ1taxMTU0JCAoqLi1FcXKzqmMrKyuzq5406de/e3W5OKWOaPn26Q97FxDRkyBAHH4XWCQCGDh0qKCYxemreX+6YlNKTnNeIhIQEFBUVoaSkRNUxxcTEONRP7jpJpSdnMfXr1w9FRUWoq6uDwWAQHdOECRMcfHQXk7M6AcCwYcNQUlIi2zVCyHUPAOLi4pCVlSU6prZ4zw0JCUFNTQ3CwsKwb98+1cYEAL1798aWLVtajUltehIaU3T8eNz35S40mSwY2tGCcf6nsWVLudOYwsPDYTAY4O/vj2PHjrUak6s6dezYEX379uUdEyBMTyaTCV26dMHOnTtt7a7qBFy+dhw/flzRtVdXVwe+0NsF3WB9JGgwGGyPBFvbMdfX1yMzMxPTpk2Dn59fqzvmuro6ZGVl2fq7ewXKaDRi7dq1tr6A77yq5i4mjuOQkZFhlxc1xtTY2Ih169bZ/PRGncxms0NupIoJgINtMTFZLBaX9eNTJ6PRiKysLKSmpjr4J6WeXNVPjpiat7elJ1kWi8Uuh2qNyVn95K4TII2enMVkNpuxfv16TJ8+3Ta/mJg4jnPQjLuYWtapuVatfvKJSaie+F73rP6kpKTYvdovJKbmvrele67JZEJmZiaSk5PtntaoKSZ39ZOzTlLpSUhMJw21uOOLnbhY24QxfTpiyayRCPBz/Y4Ya/1mzJhh99SZb52sfiQnJyMgIIBXTEL11HwOZ2vM1bXDek0QGpNUdaqqqkJ4eDi9XVAq/Pz87G4oAGxvBWyJtRgtxzQXYkvbzvq3nA+AbdG27KvVap1+GNBVuyvfW4uJb7sz34W2C4nJKggxdeLbLlVMzvyUs07WC5Sz3Hgak7u8C4nJelF0ZkfOOonRk7P+aorJVbtarhHu1owr3121yxmTmPqpRU/u2vV6vVN/+MYkpn5S1EloPYRe9zQajWrWHqC+a4Sz/mqKyVX9vFEnT/Tkrr15TOcrGzBnxR5crG3C4O7t8UVaAkIC+V8jhNSvpe9Wm0JiEqMnIfVTeu25+r0z2DqmgwG0Wi1iY2OdLgxP+wu17Suwkhcl/JRzTqlse2pH7HjSqvdhJS+kVXnsqE2rrKxHJWAhN0r56E2tVtQ14Z6lO3C2oh59wtthxdxEhAa2/ke+Elqle6oj9HZBN9DpggRBEARBEIS3qWsy4a4vdiCvqAJd2gfgxwfHoVenYKXd8nmE7A3Y2hIygMlkwrZt25y+397T/kJt+wqs5EUJP+WcUyrbntoRO5606n1YyQtpVR47atMqK+tRCVjIjVI+ekOrdQ1NeOirPcgrqkBYkB++nDtG0AZLCa3SPdUR2mRJDMdxKCsrczi+Uor+Qm37CqzkRQk/5ZxTKtue2hE7nrTqfVjJC2lVHjtq0yor61EJWMiNUj7KrdULpWV4avU+/HWkDEF+OiydnYDYrqFe9VHMeLqnOkIHXxAEQRAEQRCEwnAch59OabHl/HnotRp8cvdIjIruqLRbhEjoSRZBEARBEARBKMxHm05gy3ktNBrg3VuHY1JspNIuER5AmyyJ0el0iI+Pd3qMpKf9hdr2FVjJixJ+yjmnVLY9tSN2PGnV+7CSF9KqPHbUplVW1qMSsJAbpXyUa96VOafw343HAQALrx6E6+J7iLalhFbpnuoInS7oBjpdkCAIgiAIgpCT3/aW4LFv88BxwGNX9cf8aQOUdolwAZ0uqCAmkwkbN24UdLoK3/5CbfsKrORFCT/lnFMq257aETuetOp9WMkLaVUeO2rTKivrUQlYyI1SPko9719HyvD49/ngOODuMb0wTFvMpFbpnuoIbbIkhuM4VFdXCzpdhW9/obZ9BVbyooSfcs4plW1P7YgdT1r1PqzkhbQqjx21aZWV9agELORGKR+lnHdP0SU8uHI3jGYOVw/rhudT41BTU8OkVume6ghtsgiCIAiCIAjCixy5UI25y3ei3mjGhP7heO/WeGi1GqXdIiSENlkEQRAEQRAE4SXOXKrDPUtyUVFnRHyvDvh01ij46+lP8rYGHXzhBjEHX1gsFhgMBoSHh0OrbV0wQvoLte0rsJIXJfyUc06pbHtqR+x40qr3YSUvpFV57KhNq6ysRyVgITdK+ejpvBdrGnHL4hycMNSiX2QIfnggCR3b+UtiWyofxYz3lXuqkL0BbbLcQKcLEgRBEARBEFJQ3WDEnZ/vwL6zlejRIQg/PpSEbmFBSrtFCIBOF1QQo9GINWvWwGg0St5fqG1fgZW8KOGnnHNKZdtTO2LHk1a9Dyt5Ia3KY0dtWmVlPSoBC7lRykex8zYYzbj/y93Yd7YSndr5Y+W8RIcNFstapXuqI7TJkgExx9PKZdtXYCUvSvgp55xS2ZbiuFpvjCOteg4reSGtymNHbVplZT0qAQu5UcpHofOaLRz+9W0+ck5cRDt/HVbMSUTfiBBJbLtCCa3SPdUe2mQRBEEQBEEQhAxwHIfnft6HdQfOw1+nxedpozG0Z5jSbhFegDZZBEEQBEEQBCEDb60vxLc7i6HVAP+9Ix7jYsKVdonwEnTwhRvEHHxh/cK00NBQaDStf9+BkP5CbfsKrORFCT/lnFMq257aETuetOp9WMkLaVUeO2rTKivrUQlYyI1SPgqZ9/PNJ/BqxiEAwBs3DsXtiVGS2ZbTjpjxvnJPpYMvFCYoSNhJMUL6C7XtK7CSFyX8lHNOqWx7akfseNKq92ElL6RVeeyoTausrEclYCE3SvnIZ94fd5+xbbCeSo5tdYMlxLY37IgZT/dUe2iTJTEmkwkZGRmCPnTLt79Q274CK3lRwk8555TKtqd2xI4nrXofVvJCWpXHjtq0ysp6VAIWcqOUj3zm/fPgBTy9ugAAcO/4PnhoYoxktr1hR8x4uqc6QpssgiAIgiAIgpCAHScu4uGv98Bs4XDTyJ74v9SBir/FjVAG2mQRBEEQBEEQhIccKKnEvSt2odFkwdSBkXjzpqHQammD5avQJosgCIIgCIIgPOD0xVqkLd2J6kYTEnt3wkd3joReR39m+zJ0uqAbxJ4uaDKZoNfreZ+uwre/UNu+Ait5UcJPOeeUyrandsSOJ616H1byQlqVx47atMrKelQCFnKjlI/O5i2tasBNi7ehuLweA7u1x3cPjEX7QD9JbEvlo9zjfeWeSqcLKkx9fb1s/YXa9hVYyYsSfso5p1S2PbUjdjxp1fuwkhfSqjx21KZVVtajErCQG6V8bD5vZZ0R9yzNRXF5PaI7B2PF3ARRGyxntj1BCa3SPdUe2mRJjMlkQnZ2tqDTVfj2F2rbV2AlL0r4KeecUtn21I7Y8aRV78NKXkir8thRm1ZZWY9KwEJulPKx+bz1TWbMW7ETh89XIyI0ACvnjkFkaKAktqXy0Vvj6Z7qiF5pBwiCIAiCIAiCJYxmCx7+Jg+7Tl9CaKAeX85NRFTnYKXdIlQEPckiCIIgCIIgCJ5YOODZnw8gu7AMgX5aLJ2dgIHd+H12n/Ad6EmWDOj1wtIqpL9Q274CK3lRwk8555TKtqd2xI4nrXofVvJCWpXHjtq0ysp6VAIWcqOEjxzH4bciPbJLzkGn1eDju0YioXcnyeyzrFW6p9pDpwu6wXqCiMFgsJ0gotVqodPpYDabYbFYbH2t7SaTCc1TqtPpoNVqXbYbjUa7Oa2LqOX7Tl21+/n5wWKxwGw229o0Gg30er3Ldle+U0wUE8VEMVFMFBPFRDFRTK5j+uSvk3jvz6MAgHduGoLr4rszH1NbrJNcMVVVVSE8PJzX6YLsbQu9QHp6OtLT023FzczMRHDw5ffZRkVFYcSIESgoKEBRUZFtTGxsLOLi4pCbm4uysjJbe3x8PKKjo7F582ZUV1fb2pOSkhAZGYnMzEy7RTd58mQEBQUhIyPDzqfU1FTU1dVh06ZNtja9Xo+ZM2fCYDAgJyfH1h4aGoopU6aguLgY+fn5tvaIiAiMGzcOR48eRWFhoa1dyZjq6+uRnZ3tUUxjx45Ffn4+zpw5o+qYSktLsWPHDl4xSVWnXr16YePGjXan8kgVU0pKCo4dO4ZDhw55FNPw4cORm5uL0tJSXjE5q9PAgQPRr18/WfV0+vRpFBQUeC0mpfQk5zVizJgx0Gq12Llzp6pjGjBgAP7++29UVla2GpPa9OQspgEDBqBz5844duyYR2tv0qRJqK2txc6dO3nF5KxOQUFBmDp1qqzXCCHXveHDh6Nbt25Yt26d6Jja4j03JCQEQ4cORW1tLe/rnhIxJSQkoF27dl7722jrBQ2+P6EDAMwaEgS/knxklOSrMqZ+/frh4sWLOHLkiNuYANd1GjZsGPr06cM7JqF6SkhIgMVi4fW3UVhYGK688krF115dXR34Qk+y3CDmSVZ9fT0yMzMxbdo0+Pn5tbpjrqurQ1ZWlq2/u1cBjEYj1q5da+sLsPkqQGvtQmPiOA4ZGRl2eVFjTI2NjVi3bp3NT2/UyWw2O+RGqpgAONgWE5PFYnFZPz51MhqNyMrKQmpqqoN/UurJVf3kiKl5e1t6pdBisdjlUK0xOauf3HUCpNGTs5jMZjPWr1+P6dOn273lRmhMHMc5aMZdTC3r1FyrVj/5xCRUT3yve1Z/UlJSHL57hwU9yXmNMJlMyMzMRHJyMrTa/318X00xuaufHHVau/88Hvu+ABwHTO9hwQf3TvVIT3LGZK3fjBkzoNPpXMbUst3qu9WP5ORkBAQE8IpJqJ6az+Fsjbm6dlivCUJjauk7PclSCX5+fnY3FOByMZovXCvWYrQc4+q9pM3/uGvev+V8AGyLtmVfrVZrt0Bba3fle2sx8W135rvQdiExWQUhpk5826WKyZmfctbJeoFylhtPY3KXdyExWS+KzuzIWScxenLWX00xuWpXyzXC3Zpx5burdjljElM/tejJXbter3fqD9+YxNRPijoJrYfQ655Go1HN2gPUd41w1l9NMbmqn5R1yjlxCY//uA8cB9ye0BNjdac81pO3YhJSv5a+W20KiUmMnoTEqvTac/V7Z9DpggRBEARBEAThhPziCty/cheMZg6pQ7vixasHosWDGoJwCj3JkhiNRoPQ0FCHR6VS9Bdq21dgJS9K+CnnnFLZ9tSO2PGkVe/DSl5Iq/LYUZtWWVmPSsBCbrzh47HSasxZlou6JjPG9wvH+7fFQweOtCrBGF+4p9Jnstxg/UwWn/ddEgRBEARBEG2Dkop63PTJNpyrbMDwnmFYdd9YhATQswlfR8jegN4uKDEWiwWnT5+2+/CdVP2F2vYVWMmLEn7KOadUtj21I3Y8adX7sJIX0qo8dtSmVVbWoxKwkBs5fSyvbcKsJTtwrrIBMRHtsGxOom2DRVqVZowv3FNpkyUxZrMZ+fn5dqe8SNVfqG1fgZW8KOGnnHNKZdtTO2LHk1a9Dyt5Ia3KY0dtWmVlPSoBC7mRy8eaRhPmLMvF8bJadAsLxJfzxqBTO3/Z55XSthJapXuqI7TJIgiCIAiCIHyeRpMZD67cjb1nKtEx2A8r5yWiR4cgpd0iGIU2WQRBEARBEIRPY7ZwmP9dPv4+ZkCwvw7L5iSiX2So0m4RDEObLInRaDSIiIgQdLoK3/5CbfsKrORFCT/lnFMq257aETuetOp9WMkLaVUeO2rTKivrUQlYyI2UPnIch+d/3Y+Mfefhp9Pgs1mjEd+rg+zzymVbCa3SPdUROl3QDXS6IEEQBEEQRNvm3cxCfLjxGDQaIP3OkUgd2k1plwiVQqcLKojZbMbhw4cFffCPb3+htn0FVvKihJ9yzimVbU/tiB1PWvU+rOSFtCqPHbVplZX1qAQs5EYqH5f+fRIfbjwGAPjP9UNa3WCRVqUZ4wv3VNpkSYzFYkFhYaGgIyz59hdq21dgJS9K+CnnnFLZ9tSO2PGkVe/DSl5Iq/LYUZtWWVmPSsBCbqTw8ee8M3j5j4MAgCemD8BdY6K9Mq/ctpXQKt1THaFNFkEQBEEQBOFTbDx8AU/+UAAAmHNFbzw8uZ/CHhFtDdpkEQRBEARBED7DrlPl+MeqPTBZONwwogeenzmIuUMVCPVDmyyJ0Wq1iIqKglbLL7VC+gu17Suwkhcl/JRzTqlse2pH7HjSqvdhJS+kVXnsqE2rrKxHJWAhN2J9PHSuCnOX70SD0YIpcZF46+Zh0Gr5b7BIq9KM8YV7Kp0u6AY6XZAgCIIgCKJtUHSxDjct3oay6kaMju6IlfPGIMhfp7RbBEPQ6YIKYjabkZeXJ+h0Fb79hdr2FVjJixJ+yjmnVLY9tSN2PGnV+7CSF9KqPHbUplVW1qMSsJAboT6WVjdg1tIdKKtuRFzXUCxJSxC1wSKtSjPGF+6ptMmSGIvFgqKiIkGnq/DtL9S2r8BKXpTwU845pbLtqR2x40mr3oeVvJBW5bGjNq2ysh6VgIXcCPGxst6ItKU7cfpiHXp1CsKXcxMRFuwn+7xK2VZCq3RPdYQ2WQRBEARBEESbpMFoxn0rduHQuSqEhwRg5dwxiGwfqLRbhA/g0SarsbFRKj8IgiAIgiAIQjJMZgv++fUe5J4qR2iAHivmJqB3eDul3SJ8BEGbrLVr1yItLQ19+/aFn58fgoOD0b59e0ycOBGvvvoqSkpK5PKTGbRaLWJjYwWdrsK3v1DbvgIreVHCTznnlMq2p3bEjieteh9W8kJalceO2rTKynpUAhZy05qPFguHp1fvw5+HShGg1+KLtNEY3D1M9nnVYFsJrdI91RFepwv+/PPPePrpp1FdXY3U1FQkJiaie/fuCAoKQnl5Ofbv348tW7YgJycHs2fPxiuvvIKIiAhv+C8rdLogQRAEQRAEW3Ach9cyDuHzLSeh02qw+O5RmDaoi9JuEW0AyU8XfOutt/D+++/j7NmzWLJkCR544AFcc801mDp1Km699Va8/PLLyM7OxvHjx9GhQwd89dVXkgTCIiaTCdu2bYPJZJK8v1DbvgIreVHCTznnlMq2p3bEjieteh9W8kJalceO2rTKynpUAhZy487HxX+dwOdbTgIA3rxpmKQbLNKqNGN84Z6q59MpJyeHl7EePXrgjTfe8Mgh1uE4DmVlZeD79WNC+gu17Suwkhcl/JRzTqlse2pH7HjSqvdhJS+kVXnsqE2rrKxHJWAhN658/Da3CG+uOwwAeC51IG4e1dMr86rJthJapXuqIx6/udFsNiM/Px+XLl2Swh+CIAiCIAiCEMy6/efwfz/vAwA8NCkG913ZV2GPCF9G8CbrX//6F5YsWQLg8gZr4sSJGDlyJHr16oVNmzZJ7R9BEARBEARBuGXbcQMe/SYfFg64PaEXnpoRq7RLhI8jeJP1448/Yvjw4QCA33//HSdPnsThw4cxf/58PPfcc5I7yBo6nQ7x8fHQ6fh9i7iQ/kJt+wqs5EUJP+WcUyrbntoRO5606n1YyQtpVR47atMqK+tRCVjITXMf952pxH0rdqHJbMGMwV3wn+uHQKPRyD6vWm0roVW6pzrC63TB5gQGBuLYsWPo2bMn7r//fgQHB2PRokU4efIkhg8fjqqqKrl89Tp0uiBBEARBEIR6OV5Wg1sW56C8tglJfTtj2ZwEBPqx9cc4wQ6Sny7YnC5duuDgwYMwm81Yt24dpk2bBgCoq6tjbocpByaTCRs3bhR0ugrf/kJt+wqs5EUJP+WcUyrbntoRO5606n1YyQtpVR47atMqK+tRCVjIjclkwo8ZGzDrix0or23CkB7t8dk9o2TfYJFWpRnjC/dUXqcLNmfOnDm49dZb0a1bN2g0GkydOhUAsGPHDsTFxUnuIGtwHIfq6mpBp6vw7S/Utq/ASl6U8FPOOaWy7akdseNJq96HlbyQVuWxozatsrIelYCF3JTXNuKdnfU4X69B3/B2WD4nEaGBfrLPS1qVZowv3FMFb7JefPFFDBkyBMXFxbjlllsQEBAA4PL7JZ955hnJHSQIgiAIgiAIK7WNJty3Mg/n6zXo0j4AX85LRHhIgNJuEYQdgjdZAHDzzTc7tKWlpXnsDEEQBEEQBEG4oslkwYNf7cbeM5UI1nFYds8o9OwYrLRbBOEAr4Mv/vvf//I2+Oijj3rkkJoQc/CFxWKBwWBAeHg4tNrWP/ImpL9Q274CK3lRwk8555TKtqd2xI4nrXofVvJCWpXHjtq0ysp6VAK15sZi4fDYd/n4fW8Jgvx0+OimAZg8rLdXfSStSjOG1XuqkL0Br01Wnz597H4uKytDXV0dOnToAACoqKhAcHAwIiMjceLECfGeqww6XZAgCIIgCEJ5OI7Dwt8O4Muc0/DTafBFWgImDohQ2i3Cx5D8dMGTJ0/a/r366quIj4/HoUOHUF5ejvLychw6dAgjR47EK6+8IkkALGM0GrFmzRoYjUbJ+wu17Suwkhcl/JRzTqlse2pH7HjSqvdhJS+kVXnsqE2rrKxHJVBjbhb9eRRf5pyGRgO8e2s8xvXpoIiPpFVpxvjCPVXwM7fnn38eH374IWJj//dN2rGxsXj//ffx73//W1LnWEXM8bRy2fYVWMmLEn7KOadUtqU4rtYb40irnsNKXkir8thRm1ZZWY9KoKbcrNh2Ch9sOAoAePnawbh2eHcAyvlIWpVmTFu/pwreZJ07d85poGazGRcuXJDEKYIgCIIgCIL4Nf8sFv52AADwr6n9MSupt7IOEQRPBG+yrrrqKjzwwAPYs2ePrW337t146KGHbN+ZRRAEQRAEQRCesKmwFI9/vxcAkJYUjceu6q+wRwTBH14HXzSnrKwMaWlpWLduHfz8Ln/pm8lkwowZM7B8+XJERkbK4qgSiDn4wvqFaaGhodBoNJL2F2rbV2AlL0r4KeecUtn21I7Y8aRV78NKXkir8thRm1ZZWY9KoIbc7D59CXd/sQP1RjOuHd4di26Lh1b7P1+U8pG0Ks0YVu+pQvYGgr8nKyIiAhkZGThy5AgOHz4MAIiLi8OAAQPEedsGCQoKkq2/UNu+Ait5UcJPOeeUyrandsSOJ616H1byQlqVx47atMrKelQCJXNz5EI15i7fiXqjGVcOiMA7twy322BZUcpH0qo0Y9r6PVX0YfMDBgzAtddei2uvvZY2WM0wmUzIyMgQ9KFbvv2F2vYVWMmLEn7KOadUtj21I3Y8adX7sJIX0qo8dtSmVVbWoxIomZvi8jrMWrIDlfVGjIjqgMV3j4S/3vHPVaV8JK1KM8YX7qmCn2SZzWYsX74cGzZsQGlpKSwWi93vN27cKJlzBEEQBEEQhG9gqGnErCU7cKGqEQO6hGDZ7AQE+wv+U5UgVIHglfvYY49h+fLlmDlzJoYMGaL4eyMJgiAIgiAItqluMCJtaS5OXaxDjw5B+HLuGHQI9lfaLYIQjeBN1rfffovvv/8eqampcvhDEARBEARB+BANRjPu+3IXDpRUoXM7f3x17xh0DQtU2i2C8AjBpwt2794dmzZt8onPYVlPEDEYDLYTRLRaLXQ6Hcxms91bJa3tRqMRRqMRer0eGo0GOp0OWq0WJpMJzVNtbW9qaoLJZLL11+sv73tbvu9Ur9eD4zg0NDTY+gKAn58fLBYLzGazra/Vjqt2V767anflu6v2lt/I7S4mZ+1CY9LpdGhsbIRWq7XlRY0xmc1mNDY22urnjTppNBo0NDTY/l/KmPR6PZqammyxNPddSExardZl/fjUieM4cBwHf39/Qb4L1ZOr+skRk5R1UtM1QqvVwmKxgOM4u3dBqC0mrVbrUjdy1UkqPTmLSaPRwNmtXmhM1lpbbbYWU8s6cRwHs9mMwMBA2//ziUmonvhe96zjrPM2hwU9yXmNaO5Ty7UkdUxGkxmPfleArEOlCAnQ4dv7kxAbGdyq7+7qJ2edpNKTnDG58pVvnTiOg8lkQkBAgNv6eaIn633A1Rpzde2wWCyK6qmqqgrh4eHynC74+OOP44MPPsBHH33UZt8qmJ6ejvT0dFtxMzMzERx8WfBRUVEYMWIECgoKUFRUZBsTGxuLuLg47Ny5E2VlZbb2+Ph4REdHY/Pmzaiurra1JyUlITIyEllZWXaLbvLkyQgKCkJGRoadT6mpqairq8OmTZtsbXq9HjNnzoTBYEBOTo6tPTQ0FFOmTEFxcTHy8/Nt7RERERg3bhyOHj2KwsJCW3trMeXm5gqKKTMzk3dM9fX1yM7O9iimpKQkFBYW4tSpU6qPafv27bxikqpOUVFR+Pvvv1FXVyd5TKmpqSgpKUFBQYFHMcXHx6OgoADnzp3jFZOzOg0bNgy9e/cWFJMYPe3du9drMSmlJzmvEWPHjkVQUBC2bNmi6phiY2Oxc+dOXLp0qdWY1KYnZzENGDAAPXr0wP79+z1ae5MmTYLZbMaWLVt4xeSsTsHBwZg6daqs1wgh173ExER07twZa9euFR1TW73njh49GuXl5byve2Ji+uuvv/D53jpsL9VCr+Hw9rX9MKRHGNasWcMrpgkTJkCn03n1byOp9CR3TEOGDMHZs2dx5MiRVmNyVafhw4ejd+/evGMSqqcJEyagvr6e199GHTt2xIQJExTXU/PrSmsIfpJ1ww03IDs7G506dcLgwYNt35Vl5aeffhJiTtWIeZJVX1+PzMxMTJs2DX5+fq3umOvq6pCVlWXr7+4VKKPRiLVr19r6Ar7zqpq7mDiOQ0ZGhl1e1BhTY2Mj1q1bZ/PTG3Uym80OuZEqJgAOtsXEZLFYXNaPT52MRiOysrKcvoVZSj25qp8cMTVvb0tPsiwWi10O1RqTs/rJXSdAGj05i8lsNmP9+vWYPn26bX4xMXEc56AZdzG1rFNzrVr95BOTUD3xve5Z/UlJSXF40ZgFPcl5jTCZTMjMzERycjK02v+d7Cd1TK+tOYjPtpyEVgN8dHs8kod24x2Tu/rJWSep9CRnTNb6zZgxAzqdrtWYWtbJ6kdycjICAgJ4xSRUT83ncLbGXF07Wj75alNPsjp06IAbbrhB6DCm8fPzc9hM6nQ6u4VrxVqMlmOaC7GlbWf9W84H/O/tGS37Wt9O0RJX7a58by0mvu3OfBfaLiQmqyDE1Ilvu1QxOfNTzjpZL1DOcuNpTO7yLiQm60XRmR056yRGT876qykmV+1quUa4WzOufHfVLmdMYuqnFj25a9fr9U794RuTmPpJUSeh9RB63dNoNKpZe4D6rhHO+ksR02ebj+OzLScBAK/fOBSpw3uI8t1V/bxRJ0/05K5dypiE1K+l71abQmISoychsSqtJ1e/dzoH757/n2XLlgkdQhAEQRAEQRAAgO93FeO1jMMAgGdS4nBbQpTCHhGE9Ij+8oGysjLbeyJjY2MREREhmVOs42p3LEV/obZ9BVbyooSfcs4plW1P7YgdT1r1PqzkhbQqjx21aZWV9agEcuUm88B5PLP68mcP77+yLx6cGCPallL1I61KM6at31MFfyartrYWjzzyCL788kvbI3ydTod77rkHH374oe2AiLaA9TNZfN53SRAEQRAEQbhm+4mLuGdpLppMFtwyqifeunlYmz1EjWibCNkbOL7ZsRUWLFiAv/76C7///jsqKipQUVGBX3/9FX/99Rcef/xx0U63FSwWC0pLS+0+fCdVf6G2fQVW8qKEn3LOKZVtT+2IHU9a9T6s5IW0Ko8dtWmVlfWoBHLkZv/ZSty3YheaTBZMG9QFr9841KMNllL1I61KM8YX7qmCN1mrV6/GkiVLkJKSgvbt26N9+/ZITU3F559/jh9//FEOH5nCbDYjJyfH6fcVeNpfqG1fgZW8KOGnnHNKZdtTO2LHk1a9Dyt5Ia3KY0dtWmVlPSqB1Lk5aajF7GW5qG40IbFPJ3x4xwjodYL/BJXVRzXMy7JW6Z7qiOAVXldXhy5duji0R0ZGCjo7niAIgiAIgmjbXKhqwKwlO2CoacKgbu3xRdpoBPo5ngJHEG0NwZuspKQkLFy4EA0NDba2+vp6vPTSS0hKSpLUOYIgCIIgCIJNKuuMuGdJLs5cqkfvzsFYMTcR7QP5H4FNECwj+KiODz74ADNmzEDPnj0xfPhwAMDevXsRGBiI9evXS+4ga2g0GoSGhvJ+n7GQ/kJt+wqs5EUJP+WcUyrbntoRO5606n1YyQtpVR47atMqK+tRCaTITX2TGXNX7EThhWpEhgZg5bwxiAgNUJWPapuXZa3SPdURwacLApffMrhq1SocPnz5Ow4GDhyIu+66C0FBQZI7qCR0uiBBEARBEIQwjGYL7vtyFzYVlqF9oB7fP5iEuK70dxTBPrKeLggAwcHBuO+++/Duu+/i3Xffxb333tvmNlhisVgsOH36tKDTVfj2F2rbV2AlL0r4KeecUtn21I7Y8aRV78NKXkir8thRm1ZZWY9K4EluLBYOT/ywF5sKyxDop8WyOQmybLCUqh9pVZoxvnBPFbzJev3117F06VKH9qVLl+LNN9+UxCmWMZvNyM/PF3S6Ct/+Qm37CqzkRQk/5ZxTKtue2hE7nrTqfVjJC2lVHjtq0yor61EJxOaG4zi8/MdB/JpfAr1Wg0/uGoVR0Z1U5aOa52VZq3RPdUTwJuvTTz9FXFycQ/vgwYOxePFiSZwiCIIgCIIg2OKjjcewfNspAMA7twzH5LhIZR0iCAURvMk6f/48unXr5tAeERGBc+fOSeIUQRAEQRAEwQ4rt5/Gu1lHAAALrxmE60f0UNgjglAWwZusXr16YevWrQ7tW7duRffu3SVximU0Gg0iIiIEna7Ct79Q274CK3lRwk8555TKtqd2xI4nrXofVvJCWpXHjtq0ysp6VAKhufmjoAQv/LofAPDolH6Yc0UfOd0DoFz9SKvSjPGFe6rg0wXfeustvPXWW3j77bcxZcoUAMCGDRvw1FNP4fHHH8ezzz4ri6NKQKcLEgRBEARBuGbzkTLMW7ETRjOHu8ZE4T/XD2Huj2GC4Iuspws++eSTmDdvHv7xj3+gb9++6Nu3Lx555BE8+uijbWqDJRaz2YzDhw8L+uAf3/5CbfsKrORFCT/lnFMq257aETuetOp9WMkLaVUeO2rTKivrUQn45iav6BIe/Go3jGYOM4d1w8vXeW+DpVT9SKvSjPGFe6rgTZZGo8Gbb76JsrIybN++HXv37kV5eTleeOEFOfxjDovFgsLCQkFHWPLtL9S2r8BKXpTwU845pbLtqR2x40mr3oeVvJBW5bGjNq2ysh6VgE9ujpVWY87ynahrMmNC/3C8f2s8dFrvPcFSqn6kVWnG+MI9VdT3ZAGXD8AoLy9HTEwMAgICIOI7jQmCIAiCIAjGOFtRj1lLclFRZ8TwXh2w+O5R8NeL/pOSINokghVx8eJFXHXVVRgwYABSU1NtJwrOmzcPjz/+uOQOEgRBEARBEOrgYk0jZi3ZgXOVDegXGYJlsxPQLkCvtFsEoToEb7Lmz58PPz8/FBUVITg42NZ+2223Yd26dZI6xyJarRZRUVHQavmlVkh/obZ9BVbyooSfcs4plW1P7YgdT1r1PqzkhbQqjx21aZWV9agErnJT02jCnOU7caKsFt3DAvHl3ER0auevKh9ZnpdlrdI91RHBpwt27doV69evx/DhwxEaGoq9e/eib9++OHHiBIYNG4aamhq5fPU6dLogQRAEQRAE0GgyY86yndh2/CI6BvvhhwfHoV9kiNJuEYRXkfV0wdraWrsnWFbKy8sREBAg1Fybw2w2Iy8vT9DpKnz7C7XtK7CSFyX8lHNOqWx7akfseNKq92ElL6RVeeyoTausrEclaJkbs4XDv77Nx7bjF9HOX4flcxIV32ApVT/SqjRjfOGeKniTNWHCBHz55Ze2nzUaDSwWC9566y1MnjxZUudYxGKxoKioSNDpKnz7C7XtK7CSFyX8lHNOqWx7akfseNKq92ElL6RVeeyoTausrEclaJ4bjuPw71/2Ye3+8/DXafHZPaMxvFcHpV1UrH6kVWnG+MI9VfAnFd966y1cddVV2LVrF5qamvDUU0/hwIEDKC8vx9atW+XwkSAIgiAIglCAdzIL8U1uMbQa4IPb43FFv3ClXSIIJhD8JGvIkCE4cuQIxo8fj+uuuw61tbW48cYbkZeXh5iYGDl8JAiCIAiCILzMsm2nkZ59HADw6g1DkTK0m8IeEQQ7iDpzMywsDM8995zUvrQJtFotYmNjBZ2uwre/UNu+Ait5UcJPOeeUyrandsSOJ616H1byQlqVx47atMrKelQCrVaLYl13vLO2EADw5IxY3JEYpbBX9ihVP9KqNGN84Z4q+HTBdevWISQkBOPHjwcApKen4/PPP8egQYOQnp6Ojh07yuKoEtDpggRBEARB+Bp/HryAB77aDbOFw7zxffDvmQOh0WiUdosgFEfW0wWffPJJVFVVAQD27duHBQsWIDU1FSdPnsSCBQvEedyGMJlM2LZtG0wmk+T9hdr2FVjJixJ+yjmnVLY9tSN2PGnV+7CSF9KqPHbUplVW1qO3yT1Zjoe/3gOzhcP18d3xXKo6N1hK1Y+0Ks0YX7inCn674MmTJzFo0CAAwOrVq3HNNdfgtddew549e5Camiq5g6zBcRzKysrA9wGhkP5CbfsKrORFCT/lnFMq257aETuetOp9WMkLaVUeO2rTKivr0ZscLKnCvBU70WiyYHBHC167fhC0WvVtsADl6kdalWaML9xTBT/J8vf3R11dHQDgzz//xPTp0wEAnTp1sj3hIgiCIAiCINjh9MVapC3LRXWDCaOjO2B2fwv8dGx9BoYg1IRg9YwfPx4LFizAK6+8gtzcXMycORMAcOTIEfTs2VNyBwmCIAiCIAj5KK1qwKwluSirbkRc11B8etcI+OuU9oog2EbwJuujjz6CXq/Hjz/+iE8++QQ9evQAAKxduxbJycmSO8gaOp0O8fHx0On4XZ2E9Bdq21dgJS9K+CnnnFLZ9tSO2PGkVe/DSl5Iq/LYUZtWWVmPclNZb8Q9S3NRVF6HqE7B+HJuIjqGBKo+N0rVj7QqzRhfuKcKPl3Ql6DTBQmCIAiCaKvUN5lxz9Id2HnqEsJDArD6oSREd26ntFsEoVokP12wtrZWkANC+7clTCYTNm7cKOh0Fb79hdr2FVjJixJ+yjmnVLY9tSN2PGnV+7CSF9KqPHbUplVW1qNcGM0W/PPrPdh56hJCA/X4cm6ibYPFQm6U8pG0Ks0YX7in8tpk9evXD2+88QbOnTvnsg/HccjKykJKSgr++9//SuYga3Ach+rqakGnq/DtL9S2r8BKXpTwU845pbLtqR2x40mr3oeVvJBW5bGjNq2ysh7lwGLh8PSPBdhwuBQBei2WpCVgUPf/vSrPQm6U8pG0Ks0YX7in8jrCfdOmTfi///s/vPjiixg+fDhGjx6N7t27IzAwEJcuXcLBgweRk5MDvV6PZ599Fg888IDcfhMEQRAEQRAC4TgOr2Ycwk95Z6HTavDxXSOR2KeT0m4RRJuD1yYrNjYWq1evRlFREX744Qds2bIF27ZtQ319PcLDwzFixAh8/vnnSElJYe5DaQRBEARBEL7Cx5uOY8nfJwEAb900DFcN7KKwRwTRNqGDL9wg5uALi8UCg8GA8PBwaLWtvxtTSH+htn0FVvKihJ9yzimVbU/tiB1PWvU+rOSFtCqPHbVplZX1KCXf5Bbh2Z/2AQD+PXMg7p3Q12k/FnKjlI+kVWnGsHpPFbI3oE2WG+h0QYIgCIIg2gJr953Dw1/vgYUD/jEpBk8lxyntEkEwh+SnCxL8MRqNWLNmDYxGo+T9hdr2FVjJixJ+yjmnVLY9tSN2PGnV+7CSF9KqPHbUplVW1qMUbDtmwGPf5sPCAXck9sKTM2Ld9mchN0r5SFqVZowv3FNpkyUDYo6nlcu2r8BKXpTwU845pbItxXG13hhHWvUcVvJCWpXHjtq0ysp69ISCMxW478tdaDJbkDKkK/5z/VBoNJpWx7GQG6V8JK1KM6at31Npk0UQBEEQBNEGOVZag9nLdqK2yYxxMZ2x6PZ46LStb7AIgvAc2mQRBEEQBEG0MUoq6nHPkh0or23CsJ5h+Oye0QjQ0wnQBOEtRB18sWXLFnz66ac4fvw4fvzxR/To0QMrV65Enz59MH78eDn8VAQxB19YvzAtNDSU1+N4If2F2vYVWMmLEn7KOadUtj21I3Y8adX7sJIX0qo8dtSmVVbWoxgu1Tbhlk9zcKy0Bn0j2uGHB5LQOSSA93gWcqOUj6RVacawek+V9eCL1atXY8aMGQgKCkJeXh4aGxsBAJWVlXjttdfEedzGCAoKkq2/UNu+Ait5UcJPOeeUyrandsSOJ616H1byQlqVx47atMrKehRCbaMJs5fvxLHSGnQLC8TKeWMEbbCssJAbpXwkrUozpq3fUwVvsv7zn/9g8eLF+Pzzz+Hn52drv+KKK7Bnzx5JnWMRk8mEjIwMQR+65dtfqG1fgZW8KOGnnHNKZdtTO2LHk1a9Dyt5Ia3KY0dtWmVlPQqh0WTGg1/txt7iCnQI9sPKeYno0UH4H6cs5EYpH0mr0ozxhXuq4E1WYWEhrrzySof2sLAwVFRUSOETQRAEQRAEIQCzhcOC7/diy1EDgv11WDY7Af0iQ5V2iyB8FsGbrK5du+LYsWMO7X///Tf69nX+zeEEQRAEQRCEPHAchxd+3Y81Befgp9Ng8d2jMCKqo9JuEYRPI3iTdd999+Gxxx7Djh07oNFoUFJSglWrVuGJJ57AQw89JIePBEEQBEEQhAvezzqCVTuKoNEA798WjysHRCjtEkH4PIJPF+Q4Dq+99hpef/111NXVAQACAgLwxBNP4JVXXpHFSaUQe7qgyWSCXq/nfboK3/5CbfsKrORFCT/lnFMq257aETuetOp9WMkLaVUeO2rTKivrsTWWbT2Jl34/CAB45fohmDU22mObLORGKR9Jq9KMYfWeKuvpghqNBs899xzKy8uxf/9+bN++HWVlZW1ug+UJ9fX1svUXattXYCUvSvgp55xS2fbUjtjxpFXvw0peSKvy2FGbVllZj674Je+sbYO1YNoASTZYVljIjVI+klalGdPW76miv4zY398fgwYNQmJiIkJCQqT0iWlMJhOys7MFna7Ct79Q274CK3lRwk8555TKtqd2xI4nrXofVvJCWpXHjtq0ysp6dEV2YSme+GEvAGD2uN54ZEo/yWyzkBulfCStSjPGF+6peqEDGhoa8OGHHyI7OxulpaWwWCx2v6dj3AmCIAiCIORj9+lyPPTVbpgsHK6L744Xrh6k+NuoCIKwR/Ama968ecjMzMTNN9+MxMREEjVBEARBEISXOHy+CnOW7USD0YJJsRF455bh0GrpbzGCUBuCN1l//PEHMjIycMUVV8jhT5tArxeWViH9hdr2FVjJixJ+yjmnVLY9tSN2PGnV+7CSF9KqPHbUplVW1qOV4vI63LMkF1UNJoyM6oCP7xoJP53oT364hYXcKOUjaVWaMW39nir4dMFBgwbh22+/xbBhw+TySTWIOV2QIAiCIAhCasqqG3HL4m04dbEOsV1C8d0DY9Eh2F9ptwjCp5D1dMF3330XTz/9NE6fPi3awbaMxWJx+lk1KfoLte0rsJIXJfyUc06pbHtqR+x40qr3YSUvpFV57KhNq6ysRwCoajAibWkuTl2sQ8+OQfhyXqKsGywWcqOUj6RVacb4wj1V8CZr9OjRaGhoQN++fREaGopOnTrZ/fN1zGYzcnJyYDabJe8v1LavwEpelPBTzjmlsu2pHbHjSaveh5W8kFblsaM2rbKyHhuMZty3YhcOnqtCeIg/Vs4bgy7tA2Wdk4XcKOUjaVWaMb5wTxX8Bsc77rgDZ8+exWuvvYYuXbrQwRcEQRAEQRAyYDJb8Mg3edhxshyhAXosn5OIPuHtlHaLIAgeCN5kbdu2DTk5ORg+fLgc/hAEQRAEQfg8HMfh2Z/2IevgBfjrtfg8bTSG9AhT2i2CIHgi+O2CcXFxTH7rsrfQaDQIDQ3l/YRPSH+htn0FVvKihJ9yzimVbU/tiB1PWvU+rOSFtCqPHbVpVe3r8Y21h/HD7jPQaoCP7hiBsX07e21utecGUM5H0qo0Y3zhnir4dMHMzEy89NJLePXVVzF06FD4+fnZ/b4tncJHpwsSBEEQBOFtFv91HG+sPQwAeOvmYbh1dC+FPSIIApD5dMHk5GTk5OTgqquuQmRkJDp27IiOHTuiQ4cO6Nixo2in2woWiwWnT58WdLoK3/5CbfsKrORFCT/lnFMq257aETuetOp9WMkLaVUeO2rTqlrX4/c7i20brP9LjVNkg6XW3DRHKR9Jq9KM8YV7quBNVnZ2NrKzs7Fx40a7f9Y2X8dsNiM/P1/Q6Sp8+wu17Suwkhcl/JRzTqlse2pH7HjSqvdhJS+kVXnsqE2ralyP6w+cxzM/FQAAHpjYF/dfGaOIH2rMTUuU8pG0Ks0YX7inCj74YuLEiXL4QRAEQRAE4bPkHL+IR77Jg4UDbh3dE88kxyntEkEQHsBrk1VQUIAhQ4ZAq9WioKDAbd9hw4ZJ4hhBEARBEIQvsP9sJe77cheaTBZMH9QFr90wlLkP+RMEYQ+vTVZ8fDzOnz+PyMhIxMfHQ6PRwNl5GRqNhrlHeVKj0WgQEREh6HQVvv2F2vYVWMmLEn7KOadUtj21I3Y8adX7sJIX0qo8dtSmVbWsxxNlNUhbmouaRhPG9u2E/94xAnqd4E9zSIpacuMOpXwkrUozxhfuqbxOFzx9+jSioqKg0Whw+vRpt32jo6Mlc05p6HRBgiAIgiDk4nxlA276ZBvOVtRjcPf2+Pb+sQgN9Gt9IEEQiiD56YLR0dHQ6/UoLS1FdHS023++jtlsxuHDhwV98I9vf6G2fQVW8qKEn3LOKZVtT+2IHU9a9T6s5IW0Ko8dtWlV6fVYUdeEe5buwNmKevQJb4cVcxNVs8FSOjd8UMpH0qo0Y3zhnsr7ebTAr9PyWSwWCwoLCwUdYcm3v1DbvgIreVHCTznnlMq2p3bEjieteh9W8kJalceO2rSq5HqsazJhzvKdOHKhBl3aB+DLuYkIDwnwuh+uYEGrSvlIWpVmjC/cU5V90y9BEARBEIQP0WSy4KGv9iCvqAJhQX74cu4Y9OoUrLRbBEFIjKAj3L/44guEhIS47fPoo4965BBBEARBEERbxGLh8MQPe/HXkTIE+emwdHYCYruGKu0WQRAyIGiTtXjxYuh0Ope/12g0qtxk3XDDDdi0aROuuuoq/Pjjj7LOpdVqERUVBa2W30NCIf2F2vYVWMmLEn7KOadUtj21I3Y8adX7sJIX0qo8dtSmVW/XmeM4vPT7Afy2twR6rQaf3D0So6I7emVuobCgVaV8JK1KM8YX7qm8ThcELgdoPcadNTZt2oTq6mqsWLFC0CaLThckCIIgCEIKPvjzKN7/8wg0GmDRbfG4Lr6H0i4RBCEQyU8XBMDc2fTNmTRpEkJDvfM43mw2Iy8vT9DpKnz7C7XtK7CSFyX8lHNOqWx7akfseNKq92ElL6RVeeyoTaverPPKnFN4/88jAIAXrxms+g0WC1pVykfSqjRjfOGeqvjpgps3b8Y111yD7t27Q6PR4JdffnHok56ejt69eyMwMBBjxoxBbm6uLL5IgcViQVFRkaDTVfj2F2rbV2AlL0r4KeecUtn21I7Y8aRV78NKXkir8thRm1a9Veff9pbghd8OAAAevao/0sb1lnU+KWBBq0r5SFqVZowv3FN5b7IWLlzY6qEXYqitrcXw4cORnp7u9PffffcdFixYgIULF2LPnj0YPnw4ZsyYgdLSUluf+Ph4DBkyxOFfSUmJ5P4SBEEQBEHw4a8jZXj8+3xwHDBrbDTmT+2vtEsEQXgJ3gdfLFy4UBYHUlJSkJKS4vL37733Hu677z7MmTMHwOXDN9asWYOlS5fimWeeAQDk5+dL4ktjYyMaGxttP1dVVQEAjEYjjEYjgMufTdPpdDCbzXY7amu7yWSyjQEAnU4HrVYLk8lk9zTQ2m7tZ/2vXn+5JFY7VvR6vW28tS8A+Pn5wWKx2D1C1Wg00Ov1Lttd+e4uJme+txZTc99dxeSsXWhMVprPq9aYmvvpjTo5y41UMTmzLSYmZ3aE1Kn5OCExidFT8/5yxtS83dt6kvMa0TKHao3JijPdyFUnZ3NKFZN1bMs5hcbkTDPuYmpZp+bj5LxGOOvvLCbr/3McJzqm5r63bM8/U4kHV+6G0cxh5pCu+HfKAJhMJtXen5r7bu1jsVicrkk1/B3hrn5yXiOk0pOcMVlttnx7Hd86Wee29uETk1A9NZ+jtete898rvfZa/t4dgk4X9DZNTU3YvXs3nn32WVubVqvF1KlTkZOTI/l8r7/+Ol566SWH9szMTAQHX/4Oi6ioKIwYMQIFBQUoKiqy9YmNjUVcXBzy8vIAAFlZWQAuP2WLjo7G5s2bUV1dbeuflJSEyMhIZGdn2/WfPHkygoKCkJGRYedDamoq6urq7Prq9XrMnDkTBoPBLh+hoaGYMmUKiouL7TagERERGDduHI4ePYrCwkJbe2sx5ebmoqyszNbeWkyZmZl2QnIXU319vS0HYmMaM2YMOnfubMuLWmMqLy8H8L/6eaNOPXv2hL+/v11upIopOTkZPXv2tLMtJqZhw4YhLCzMzo7QOvXs2RNarRbr1q3jHZNQPVmfjFv7yx2TUnqS8xqRmJiI2NhYZGdnqzqm/v37Izg42K5+ctdJKj05i6l///6IjY1FXl6eR2tv4sSJ6Nevn52P7mJyVid/f39otVpZrxFCrnu9e/eGxWLB+vXrRcfkrE7n64APD/qh3shhZPcgTGl3BuvWnXFbJzVdI0JCQhAbG4uSkhIUFBTwqpMSMfXr1w91dXX466+/RNVJTExS6UnumGJjY3HixAkcPXq01Zhc1amkpAR9+vThHZNQPcXGxqK8vNzuY0CuYgoODoZWq1V87Vn/duAD79MFvYFGo8HPP/+M66+/HsDl4vbo0QPbtm1DUlKSrd9TTz2Fv/76Czt27OBld+rUqdi7dy9qa2vRqVMn/PDDD3b2rDh7ktWrVy8YDAbbCSIsvALla0+yKCaKiWKimCgmikktMZ2tqMdtn+fiQlUj4nt1wMq5oxGo/98TORZjatneFupEMVFMYmKqqqpCeHg4v5PHORUBgPv5559tP589e5YDwG3bts2u35NPPsklJibK7k9lZSUHgKusrOQ9xmg0clu3buWMRqPk/YXa9hVYyYsSfso5p1S2PbUjdjxp1fuwkhfSqjx21KZVOXJuqG7gJr+dzUU//Qd31bubuPKaRslsexMWtKqUj6RVacawek8VsjdQ9bd6hYeHQ6fT4cKFC3btFy5cQNeuXRXyyj0cx6GsrIz3aYxC+gu17Suwkhcl/JRzTqlse2pH7HjSqvdhJS+kVXnsqE2rUue8ptGE2ct24oShFj06BGHlvER0bOcviW1vw4JWlfKRtCrNGF+4pwreZF24cAGzZs1C9+7dodfrodPp7P5Jib+/P0aNGoUNGzbY2iwWCzZs2OD07X4EQRAEQRDepsFoxv1f7sK+s5Xo1M4fK+cloltYkNJuEQShIIIPvpg9ezaKiorw/PPPo1u3bh5/SXFNTQ2OHTtm+/nkyZPIz89Hp06dEBUVhQULFiAtLQ2jR49GYmIiFi1ahNraWttpgwRBEARBEEphtnD417f52Hb8Itr567BiTiL6Rkj/lTcEQbCF4E3W33//jS1btiA+Pl4SB3bt2oXJkyfbfl6wYAEAIC0tDcuXL8dtt92GsrIyvPDCCzh//jzi4+Oxbt06dOnSRZL5pUan0yE+Pp73Uz0h/YXa9hVYyYsSfso5p1S2PbUjdjxp1fuwkhfSqjx21KZVKfLCcRye+3kf1h04D3+dFp+njcbQnmGi7akFFrSqlI+kVWnG+MI9VfDpgoMGDcKqVaswYsQIuXxSDVVVVQgLC+N3gghBEARBED7Fm+sO45NNx6HVAB/fNRLJQ7op7RJBEDIiZG8g+DNZixYtwjPPPINTp06J9a9NYzKZsHHjRpdfNOlJf6G2fQVW8qKEn3LOKZVtT+2IHU9a9T6s5IW0Ko8dtWnV03i+2HICn2w6DgB47YahbWqDxYJWlfKRtCrNGF+4pwp+u+Btt92Guro6xMTEIDg4GH5+fna/t37hqq/CcRyqq6sFna7Ct79Q274CK3lRwk8555TKtqd2xI4nrXofVvJCWpXHjtq06kk8P+4+g/+sOQQAeCo5FrcnRgm2oWZY0KpSPpJWpRnjC/dUwZusRYsWyeAGQRAEQRCE+vnz4AU8vboAAHDv+D54aGKMwh4RBKFGBG+y0tLS5PBD1RiNRts3QPP5ZmnrGID/N0tb/+vu27Kt45t/GzWL35bdWrvQmKw0n1etMTX30xt1cpYbqWJyZltMTM7sCKlT83FCYhKjp+b95Yypebu39STnNaJlDtUakxVnupGrTs7mlCom69iWcwqNyZlm3MXUsk7Nx8l5jXDW31lM1v/nOI53THuKq/Dw13tgtnC4YUR3PDmtH8xmc5u751r7WCwWp2tSDTG5q5+c1wip9CRnTFabzdvcxdSyTta5rX34xCRUT83naO261/z3Sq+9lr93h+BNFnA5wF9++QWHDl1+VD548GBce+21zJ364Yr09HSkp6fbipuZmYng4GAAQFRUFEaMGIGCggIUFRXZxsTGxiIuLg55eXkAgKysLABAfHw8oqOjsXnzZlRXV9v6JyUlITIyEtnZ2Xb9J0+ejKCgIGRkZNj5lJqaivr6eru+er0eM2fOhMFgQE5Ojq1vaGgopkyZguLiYuTn59vaIyIiMG7cOBw9ehSFhYW29tZiys3NRVlZma29tZgyMzPthNRaTNYciI1p7Nix6Nmzpy0vao3p0qVLAP5XP2/UqVevXggKCrLLjVQxpaSkYODAgXa2xcQ0fPhwREZG2tkRWqeBAwdCp9Nh7dq1gmJqXo/W1l5JSYldf7ljUkpPcl4jxowZg6SkJGRnZ6s6pgEDBiAsLMyufnLXSSo9OYtpwIABSEpKQl5enkdrb9KkSUhISLDz0V1MzuoUFBQEnU4n6zVCyHVv+PDh4DgOa9eubTWmcw16pB/Uo9FkwZCOFkwIKMK6dUVt8p4bEhKCpKQklJSUoKCgQLUxJSQkoL6+Hps2bWo1JrXpSe6YkpKScPLkSRw5cqTVmFzVqaSkBH369OEdkxA96fV6JCUl4dKlS9ixY0erMYWFhUGn0+HIkSOKrr26ujrwRfDpgseOHUNqairOnj2L2NhYAEBhYSF69eqFNWvWICam7Tw2t54gYjAYbCeIsPAKlK89yaKYKCaKiWKimCgmOWM6XV6H2z/PhaGmCQm9O2LpPSMR6KdjOiYrbalOFBPFJHdMVVVVCA8P53fyOCeQlJQULjk5mbt48aKtzWAwcMnJyVxqaqpQc6qmsrKSA8BVVlbyHtPU1MT98ccfXFNTk+T9hdr2FVjJixJ+yjmnVLY9tSN2PGnV+7CSF9KqPHbUplW+/S5U1nPj39zART/9B5e8aDNXWa/u9SsFLGhVKR9Jq9KMYfWeKmRvIPjtgn/99Re2b9+OTp062do6d+6MN954A1dccYVQc20SoUdMCunP2vGV3oKVvCjhp5xzSmXbUztix5NWvQ8reSGtymNHbVptrV9lnRH3LM1FcXk9ojsHY8XcBLQP9HM7pq3AglaV8pG0Ks2Ytn5PFfw9WQEBAXbvYbRSU1MDf39/SZwiCIIgCIJQkvomM+at2InD56sRERqAlXPHIDI0UGm3CIJgBMGbrKuvvhr3338/duzYAY7jwHEctm/fjgcffBDXXnutHD4SBEEQBEF4DaPZgoe/3oNdpy8hNFCPL+cmIqpzsNJuEQTBEIIPvqioqEBaWhp+//132xcRm0wmXHvttVi+fDnCwsJkcVQJrAdf8Ppw2/+H+/9fmBYaGmp3vLgU/YXa9hVYyYsSfso5p1S2PbUjdjxp1fuwkhfSqjx21KZVV/0sFg6P/7AXP+edRaCfFivnjUFC704u7bRFWNCqUj6SVqUZw+o9VcjeQPBnsjp06IBff/0VR48exeHDhwFcPj65X79+4rxtgwQFBcnWX6htX4GVvCjhp5xzSmXbUztix5NWvQ8reSGtymNHbVpt2Y/jOLyy5iB+zjsLnVaDj+8a6XMbLCssaFUpH0mr0oxp6/dUwW8XtNK/f39cc801uOaaa2iD1QyTyYSMjAxBH7rl21+obV+Blbwo4aecc0pl21M7YseTVr0PK3khrcpjR21addYvPfsYlm09BQB455ZhmBLXRZCvbQUWtKqUj6RVacb4wj2V15OsBQsW4JVXXkG7du2wYMECt33fe+89SRwjCIIgCILwFqt2nMY7mZe/uPWFqwfhhhE9FfaIIAiW4bXJysvLs305V15enqwOEQRBEARByInZwmHHyXLsNmjQ+WQ5KurN+Pcv+wEA/5zcD3PH91HYQ4IgWIfXJis7O9vp/xMEQRAEQbDEuv3n8NLvB3GusgGADl8e3WX73Z1jovD49AHKOUcQRJtB8OmCc+fOxQcffIDQ0FC79traWjzyyCNYunSppA4qidjTBU0mE/R6Pe/TVfj2F2rbV2AlL0r4KeecUtn21I7Y8aRV78NKXkir8thRg1bX7T+Hh77aA1d/+Hx850ikDuvG27e2CgtaVcpH0qo0Y1i9pwrZGwjeZOl0Opw7dw6RkZF27QaDAV27dmXuQ2nusCbSYDDYEqnVaqHT6WA2m2GxWGx9re1GoxHV1dUICQmBRqOBTqeDVquFyWRC81Rb25uamlBTU2Prr9dffrjYMo96vR4cx6GiosLWFwD8/PxgsVhgNpttfa12XLW78t1VuyvfXbVb31ra3HdXMTlrFxqTTqdDZWUlgoODbXlRY0xmsxmVlZW2+nmjThqNBpcuXbJbM1LFpNfrHfIuJiatVouKigq0a9fOoX586sRxHOrq6hAWFibId6F6clU/OWKSsk5qukZotVrU1tYiMDDQ7kaptpic1U/uOkmlJ2cxaTQa1NXVOZzOJTQmnU6H6upqBAUF8apfyzpxHIeamhp07NgRHMfJdo1wdd3joMEVb2zA+apGOEMDoGtYALIXXIkA//99RY27mJr73pbuuQBQX1+Pdu3aOawltcTEcRzq6+sRGhrq4LucdZJKT3LGBFyuX3BwsMM1mE+drFoNCwtzW7/mMbnz3VWsDQ0NLtdYy2tHbW0tOnToAIvFoujaq6qqQnh4uLRHuFdVVdkSX11djcDA/33rudlsRkZGhsPGi1XS09ORnp5uK25mZiaCgy9/CWFUVBRGjBiBgoICFBUV2cbExsYiLi4Oubm5MBgMtvb4+HhER0dj8+bNqK6utrUnJSUhMjISWVlZdotu8uTJCAoKQkZGhp1PqampqK6uxpYtW2xter0eM2fOhMFgQE5Ojq09NDQUU6ZMQXFxMfLz823tERERGDduHI4ePYrCwkJbO5+YysrKeMeUmZnJO6b6+nq7t6CKiSkhIQF//fWXnW01xnThwgXs3LmTV0xS1al79+52a0bKmKZPn+6QdzExDRkyBJs3b7azI7ROVj+FxCRUT6dPn8a+ffu8FpNSepLzGpGQkICdO3dCr9erOqaYmBiH+sldJ6n05Cymfv364dixYwgPDxd0f2oZ04QJExyuJ+5iclYna/+SkhLZrhGurnvHq3UuN1gAwAE4V9mIj75bh8fuSFG9nuS8RoSEhKCmpgZDhw7lfd1TIibAcV3KXSep9CRnTFbfrL62FpOrOg0dOhR9+/blHRMATJs2DVlZWXZtrtaeyWSy3Rdai8lq5/jx44quvbq6OvCF95MsrVbr9hGdRqPBSy+9hOeee4735GpHzJOs+vp6ZGZmYtq0afDz82t1x1xXV4esrCxbf3evQBmNRqxdu9bWF/CdV9XcxcRxHDIyMuzyosaYGhsbsW7dOpuf3qiT9QWQ5rmRKiYADrbFxGSxWFzWj0+djEYjsrKykJqa6uCflHpyVT85Ymre3paeZFksFrscqjUmZ/WTu06ANHpyFpPZbMb69esxffp02/xiYuI4zkEz7mJqWafmWrX6yScmoXpydd37fe85PPZdvkPeW/LeLUNxw8hevGJq7ntbuueaTCZkZmYiOTkZWu3/vu1HTTFZ11NKSorD36dy1kkqPckZk7V+M2bMgE6nazWmlnWy+pGcnIyAgABeMbnz3V2srtaYq2uH9ZogNKaWvqvqSVZ2djY4jsOUKVOwevVqdOr0vy/n8/f3R3R0NLp3787XHFP4+fnZ3VCAy8VovnCtWIvRckxzIba07ax/y/kA2L2lqfnvrW+naImrdle+txYT33ZnvgttFxKTVRBi6sS3XaqYnPkpZ52sFyhnufE0Jnd5FxKT9aLozI6cdRKjJ2f91RSTq3a1XCPcrRlXvrtqlzMmMfVTi57ctev1eqf+8I1JTP2kqJPQeji77p001GLJ1pMOfZ3RrUM7u+sDX9/b6j3XWX81xaTRaBSrkyd6ctcuZUxC6tfSd6tNITG58t1Vf1drTK16cvV7p3Pw7Thx4kQAwMmTJxEVFaX4B8/UjKvCSdFfqG1fgZW8KOGnnHNKZdtTO2LHk1a9Dyt5Ia3KY8fbWm0wmvFx9jEs/usEmswWt2MufyYrEIl9Ornt5yuwoFWlfCStSjOmrd9TBR980fJ90S258sorPXJITYg5XZAgCIIgCOXZcOgCXvz9AIrL6wEAE/qHY+rALnjxtwMAYHfCoPVl40/uHonkIXS6IEEQzhGyNxC8LZw0aZJDW/OnWi1PFPE1LBYLDAYDwsPDnT7m9KS/UNu+Ait5UcJPOeeUyrandsSOJ616H1byQlqVx463tFp8sRbP/ZSPzccrAABd2wfihWsGIWVIV2g0GnRpH9Dse7Iu0zUsEAuvGUQbrP8PC1pVykfSqjRjfOGeKtjTS5cu2f0rLS3FunXrkJCQgMzMTDl8ZAqz2YycnBzem00h/YXa9hVYyYsSfso5p1S2PbUjdjxp1fuwkhfSqjx25NZqo8mM9OxjmLZoMzYfr4Beq8EDV/bFhscnInVoN9sLwslDuuHvp6fgq7mjcU9/M76aOxp/Pz2FNljNYEGrSvlIWpVmjC/cUwU/yQoLC3NomzZtGvz9/bFgwQLs3r1bEscIgiAIgiD48PdRA174dT9OGGoBADGhHD5MG4dBPTs67a/TajCmTydcPMRhTJ9O0Gnpc+YEQUiLZJ8i69Kli9259QRBEARBEHJyvrIB/1lzEH8UnAMAhIcE4JkZ/aE/m4/+XUIU9o4gCF9G8CaroKDA7meO43Du3Dm88cYbiI+Pl8ovZtFoNAgNDeV9+qKQ/kJt+wqs5EUJP+WcUyrbntoRO5606n1YyQtpVR47UmrVaLZgxbZTeD/rCGqbzNBqgHuSemP+tAFo56fB5urjrc7DynpUAhZyo5SPpFVpxvjCPVXw6YJardb2BbDNGTt2LJYuXYq4uDhJHVQSOl2QIAiCINRF7slyvPDrfhw+Xw0AiO/VAf+5fgiG9HD8OANBEISUCNkbCD744uTJkzhx4gROnjyJkydP4vTp06irq8O2bdva1AZLLBaLBadPn7b71mmp+gu17Suwkhcl/JRzTqlse2pH7HjSqvdhJS+kVXnseKrV0qp6PP79Xtz6aQ4On69Gh2A/vHHjUPz00Di7DRbfeVhZj0rAQm6U8pG0Ks0YX7inCt5kRUdH2/3r1asXAgMD5fCNScxmM/Lz8wWdrsK3v1DbvgIreVHCTznnlMq2p3bEjieteh9W8kJalceO2PFNRhM+XLcXU9/bjNV7zgAAbk/ohY2PT8LtiVHQtji0gu88rKxHJWAhN0r5SFqVZowv3FMFfybr0UcfRb9+/fDoo4/atX/00Uc4duwYFi1aJJVvBEEQBEH4MHuLK/Dcz/uwv0QHwITB3dvjleuHYGSU81MDCYIg1ILgTdbq1avx22+/ObSPGzcOb7zxRpvcZBmNRhiNRgCXP5Om0+lgNpvtHlta200mk20MAOh0Omi1WphMJrvPsVnbrf2s/9XrL5fEaseKXq+3jbf2BQA/Pz9YLBa73b1Go4Fer3fZ7sp3dzE58721mJr77iomZ+1CY7LSfF61xtTcT2/UyVlupIrJmW0xMTmzI6ROzccJiUmMnpr3lzOm5u3e1pOc14iWOVRrTFac6UauOjmbU6qYrGNbzik0JmeacRdTyzo1H9daTBV1Rrz751F8t+sMOA4I0nFYMG0AZiX1hk6rgdls9vi6Z/1/juNEx9Tc97Z0z7X2sVgsTtekGmJyVz856ySVnuSMyWqz5ZMfvnWyzm3twycmoXpqPkdr173mv1d67bX8vTsEb7IuXrzo9Luy2rdvD4PBINScKklPT0d6erqtuJmZmQgODgYAREVFYcSIESgoKEBRUZFtTGxsLOLi4rBnzx4AQFZWFgAgPj4e0dHR2Lx5M6qrq239k5KSEBkZiezsbLv+kydPRlBQEDIyMux8Sk1NRW1trV1fvV6PmTNnwmAwICcnx9Y3NDQUU6ZMQXFxMfLz823tERERGDduHI4ePWp33H5rMeXm5qKsrMzW3lpMmZmZdkJyF1N9fb0tB2JjSkxMRHBwsC0vao2pvLwcwP/q54069ejRAzqdzi43UsU0Y8YMhIWF2dkWE9PQoUMRGBhoZ0doncLCwqDRaLB+/XreMQnV09mzZ+36yx2TUnqS8xqRmJiIiIgIZGdnqzqmfv36wc/Pz65+ctdJKj05i6l///6IiIjAnj177O7TQmO68sor0blzZzsf3cXkrE46nQ4ajcZlTIVHjmDl30fx22ktak2XX0S7Pr47rmh3Af6Vh7B+3SFbnaS47nXs2BFmsxmZmZmiY2qL99yQkBBERETg7Nmz2Ldvn2pj6ty5M2pra7F58+ZWY1KbnuSMKTw8HBEREThx4gSOHj3aakyu6nT27Fn07duXd0xC9RQREYHy8nLk5ua2GpOfnx80Go3ia6+urg58EXy64JAhQ/Dggw/in//8p137hx9+iE8++QQHDx4UYk7VWE8QMRgMthNEWHgFqi2+qkYxUUwUE8VEMbXtmI6U1uHfv+zDnqIKAEC/iHZ4+brBGNcvgtmY2mKdKCaKyZdjqqqqQnh4OL+TxzmBLFmyhAsKCuJeeOEFbtOmTdymTZu4559/ngsODuY+++wzoeZUTWVlJQeAq6ys5D3GZDJxhw4d4kwmk+T9hdr2FVjJixJ+yjmnVLY9tSN2PGnV+7CSF9KqPHZcja+qb+Je/G0/1+eZP7jop//gBj6/lvv0r2Nck8ksal6+/VlZj0rAQm6U8tGXtSrlGFbvqUL2BoJPF5w7dy7effddLFmyBJMnT8bkyZPx1Vdf4ZNPPsF9990n1Fybw2KxoLCwUNARlnz7C7XtK7CSFyX8lHNOqWx7akfseNKq92ElL6RVeey0HM9xHH7NP4sp7/6FZVtPwcIBM4d2w4bHJ+L+K2Pgp9OKmpdvf1bWoxKwkBulfPRFrcoxxhfuqYI/kwUADz30EB566CGUlZUhKCgIISEhUvtFEARBEEQb5VhpNZ7/5QByTlwEAPQJb4eXrh2MKwdEKOwZQRCENIjaZJlMJmzatAnHjx/HnXfeCQAoKSlB+/btacNFEARBEIRTGs3A25lHsHTraZgsHAL0Wvxzcj/cP7EvAvS61g0QBEEwguBN1unTp5GcnIyioiI0NjZi2rRpCA0NxZtvvonGxkYsXrxYDj+ZQavVIioqyu4YYKn6C7XtK7CSFyX8lHNOqWx7akfseNKq92ElL6RV6e1wHIesQ6V4a38ADHWnAABXxUXixWsHo1enYEnn5duflfWoBCzkRikf27pWxY6ne6ojgk8XvP766xEaGoolS5agc+fO2Lt3L/r27YtNmzbhvvvuszsqknWspwvyOkGEIAiCIAgHThlq8eLvB7Cp8PIxyj06BOHFawdj2qAuCntGEAQhDCF7A8Fbwi1btuDf//43/P397dp79+5t+x4ZX8ZsNiMvL8/hC+Ck6C/Utq/ASl6U8FPOOaWy7akdseNJq96HlbyQVqWx02A04/2sI5i+aDM2FZbBT6fBzYNCsP6x8YI2WHJplZX1qAQs5EYpH9uiVqUYT/dURwRvslqeW2/lzJkzCA0NlcQplrFYLCgqKhJ0ugrf/kJt+wqs5EUJP+WcUyrbntoRO5606n1YyQtp1XM72YdLMf39zfhgw1E0mSwY3y8cfzw8DhPCKhCg18g2r5D+rKxHJWAhN0r52Na0KtV4uqc6IniTNX36dCxatMj2s0ajQU1NDRYuXIjU1FQpfSMIgiAIgiHOVtTjgZW7MGf5ThSV16FL+wB8dOcIrJyXiL4R7ZR2jyAIwmsIPvji3XffxYwZMzBo0CA0NDTgzjvvxNGjRxEeHo5vvvlGDh8JgiAIglAxTSYLvvj7BD7ccAz1RjN0Wg3mXtEbj00dgJAAUQcZEwRBMI3gK1/Pnj2xd+9efPfdd9i7dy9qamowb9483HXXXQgKCpLDR6bQarWIjY0VdLoK3/5CbfsKrORFCT/lnFMq257aETuetOp9WMkLaVWYnW3HDHj+1/04XlYLAEjs3QkvXz8YcV3b8xovtf98+7OyHpWAhdwo5SPLWpVzPN1THRF8umBZWRkiIpx/WeC+ffswdOhQSRxTA3S6IEEQBEE4p7SqAf9Zcwi/7S0BAISH+OPZlIG4cWQPaDTCPndFEATBArKeLjh06FCsWbPGof2dd95BYmKiUHNtDpPJhG3btsFkMkneX6htX4GVvCjhp5xzSmXbUztix5NWvQ8reSGturfT0NiEJX+fxJR3/8Jve0ug1QD3JEVjw+OTcNOoni43WGrTKivrUQlYyI1SPrKkVW/eV+me6ojgtwsuWLAAN910E+bMmYP33nsP5eXluOeee7Bv3z58/fXXcvjIFBzHoaysDHwfEArpL9S2r8BKXpTwU845pbLtqR2x40mr3oeVvJBWXdvZcbwML+/IweELNQCA4b064NXrh2BIjzDZ/JBLq6ysRyVgITdK+ciKVr19X6V7qiOCN1lPPfUUpk2bhlmzZmHYsGEoLy/HmDFjUFBQgK5du8rhI0EQBEEQCnKxphGvrjmInw7oAdQgLMgPTyfH4faEXtBq6a2BBEEQLRF15E+/fv0wZMgQrF69GgBw2223tekNltFohNFoBHD5w3c6nQ5ms9nuvH5ru/VRprW/TqeDVquFyWSy24Fb2639rP/V6y+XpOUjUb1ebxtv7QsAfn5+Dt9dptFooNfrXba78t1dTM58by2m5r67islZu9CYrDSfV60xNffTG3VylhupYnJmW0xMzuwIqVPzcUJiEqOn5v3ljKl5u7f1JOc1omUO1RqTFWe6katOzuaUKibr2JZz8onJbOHw3a4zeO/Po6isvzz+phHd8NSMWHRq5w+z2QSNhl+dmscm5zXCWX9ndbL+P8dxvOunJj3JeY2w9rFYLE7XpBpiclc/OevkiZ68FZPVZsvvteVbJ+vc1j58YhKqp+ZztHbda/57pddey9+7Q/Ama+vWrbj77rvRqVMnFBQUYOvWrXjkkUeQkZGBxYsXo2PHjkJNqo709HSkp6fbipuZmYng4GAAQFRUFEaMGIGCggIUFRXZxsTGxiIuLg55eXkAgKysLABAfHw8oqOjsXnzZlRXV9v6JyUlITIyEtnZ2Xb9J0+ejKCgIGRkZNj5lJqaivr6eru+er0eM2fOhMFgQE5Ojq1vaGgopkyZguLiYuTn59vaIyIiMG7cOBw9ehSFhYW29tZiys3NRVlZma29tZgyMzPthNRaTNYciI1p7Nix6NKliy0vao3p0qVLAP5XP2/UqVevXggMDLTLjVQxpaSkoG/fvna2xcQ0fPhwdOrUyc6O0Dr17dsXOp0Oa9euFRRT83q0tvZKSkrs+ssdk1J6kvMaMWbMGMTHxyM7O1vVMQ0YMAChoaF29ZO7TlLpyVlMAwYMQHx8PPLy8gStvc9XZ+KboxyKay+/mBUb2Q4Pjw0HV3Yc2/8qFlWnwMBA6HQ6Wa8RQq57sbGx4DgOa9eu5VUnNelJzmtESEgI4uPjUVJSgoKCAtXGNHToUNTX12PTpk2txqS0nrwdU3x8PE6ePIkjR460GpOrOpWUlKBPnz68YxKqp/j4eFy6dAk7duxoNabQ0FDodDocOXJE0bVXV1cHvgg+XTAgIADz58/HK6+8Aj8/PwDA8ePHcffdd6O4uBhnzpwRYk7VWE8QMRgMthNEWHgFqi2+qkYxUUwUE8VEMXknppomC97NOoJVO4rAcUBIgB7/uioGaeP6QK/TMhlTW6wTxUQxUUzej6mqqgrh4eH8Th7nBLJp0yan7WazmXv55ZeFmlM1lZWVHACusrKS9xij0cht2LCBMxqNkvcXattXYCUvSvgp55xS2fbUjtjxpFXvw0pefFWrZrOF+35nETfy5Uwu+uk/uOin/+Ae+2YPd6GyXhIf1aZVVtajErCQG6V8VINW5bYjZryv3FOF7A0Ev11w4sSJTtu1Wi2ef/55oebaHBzHobq6WtDpKnz7C7XtK7CSFyX8lHNOqWx7akfseNKq92ElL76o1UPnqvD8L/ux6/TltzX3iwzBy9cNxriYcMl8VJtWWVmPSsBCbpTyUWmtesOOmPF0T3WE9/dkpaamorKy0vbzG2+8gYqKCtvPFy9exKBBgyR1jiAIgiAI+ahuMOKVPw7i6g//xq7TlxDkp8MzKXHIeHSC3QaLIAiCEAbvJ1nr169HY2Oj7efXXnsNt956Kzp06ADg8nsVm38QjSAIgiAIdcJxHH4vOIf//HEQpdWX7+0pQ7ri+asHoXuHIIW9IwiCYB/eB19otVqcP38ekZGRAC6f8rF371707dsXAHDhwgV0797d4bhIlrEefMHrw23/H4vFAoPBgPDwcLujZ6XoL9S2r8BKXpTwU845pbLtqR2x40mr3oeVvLR1rR4rrcELv+7HtuMXAQDRnYPx0rWDMSk2UlYf1aZVVtajErCQG6V8pPuqNGNYvacK2RvQJssNYjZZBEEQBKFG6ppM+GjjMXy+5QSMZg7+ei0entQPD0zsi0A/XesGCIIgfBwhewPe20GNRmP3xa/WNsIeo9GINWvW8P6yMiH9hdr2FVjJixJ+yjmnVLY9tSN2PGnV+7CSl7am1aamJry2Yg2mvvsXPt50HEYzhylxkfhz/kQ8NrU/7w1WW9MqK+tRCVjIjVI+0n1VmjG+cE/l/ZksjuMwe/ZsBAQEAAAaGhrw4IMPol27dgBg93ktX6fl9wBI2V+obV+Blbwo4aecc0pl21M7YseTVr0PK3lpK1otuliH53/dh7+OAEADenQIwsJrBmHaoC6iXihta1plZT0qAQu5UcpHuq9KM6at31N5b7LS0tLsfr777rsd+txzzz2ee0QQBEEQhEc0GM349K8TSN90DE0mC3QaDvdN6ItHpw5AsL/gb28hCIIgBML7Srts2TI5/SAIgiAIQgI2FZZi4W8HcPpiHQAgqW8nTG5fijnT+sPPjzZYBEEQ3oD3wRe+iJiDL6xfmBYaGsrrrRhC+gu17Suwkhcl/JRzTqlse2pH7HjSqvdhJS+sarWkoh4v/34Q6w6cBwBEhgbg31cPwtVDu6Kmpoa0KpE/vgALuVHKR7qvSjOG1XuqkL0BvaQlA0FBwr5jREh/obZ9BVbyooSfcs4plW1P7YgdT1r1PqzkhSWtNpksWLr1JP674SjqmszQaTWYPa43/jW1P0ID/cBxHGlVIru+BAu5UcpHuq9KM6at31PV+eUHDGMymZCRkSHoQ7d8+wu17Suwkhcl/JRzTqlse2pH7HjSqvdhJS8saTXn+EWk/ncL3lh7GHVNZoyO7og/HhmP568ehNBAP49sS+Wjp+Pl0ior61EJWMiNUj7SfVWaMb5wT6UnWQRBEATBGKVVDXg14xB+zS8BAHRu549nUuJw08ie0GrV+fYugiAIX4I2WQRBEATBCCazBSv/X3t3Hh9VdfcP/DNL9gXMAoghYQ9LkEVZlVVIWERcWlsf20esVatWa11arUVQXMBW6tLo06ftY62t1ao/EWvERAkmQBQFAgImhB3Dkg3InszMvb8/4oyZZGYyd+bcuXNzP+/Xi5dyOed7v+fc+53LYWZOPjuGdfkH0NBmh8kE3Dg1HQ9mj0Kf2Ait0yMiom9xkUVERKQDO46dxYr1e7H/VD0AYHxaH6y+OgsXp/XVNjEiIuqGuwv6EOjugna7HVar1e/dVfxtrzS2UehlXrTIU81zioodbJxA+7NWQ08v8xJutVrX1I41H36Nf3/5DQCgT0wEHszJxA1T0mHx46OBrFWx+RiBHuZGqxz5XBXTR6/PVCVrA258oYKWlhbV2iuNbRR6mRct8lTznKJiBxsn0P6s1dDTy7yEQ61KkozXPz+Oec9udi2wvn9JGjbdPxs/mpbh1wLLW2xROYaqv1q1qpf7UQt6mButcuRzVUyf3v5M5SLLDzabzfXL4XAAABwOh8fjra2tKCwsREtLC2w2GyRJAtCxM0rn9s7jLS0tbu1lWYYsy25tncdtNptbW5vNBgCQJMmtrXP3FW/HveXu7bi33L0d95S7tzF5Oq50THa7vdu8hOOY2tvb3fIMxXXyNDeixuQpdiBj8nX9/LlOzhrq2lZ0PXm7fmqMSct6UvM1ouschuuYfNWNWtep6zl3Ha3FNS9txW/e/Qrnmm0Y1T8eb/x0Mp66egz6RFsUjamtrQ2FhYVobW0N6t7zVDNKrlPnWlXzNcLf1z1nPp7GqYd6UvM1wvl3mfb29rAdk6/rp+Z1ElVPao7Jef3a2toCuk7OPNrb2/0ek9J66nyOnsbU+bUjHO49f/E7WR7k5uYiNzfXdYHy8/MRGxsLAEhPT8fEiROxZ88eHD9+3NUnMzMTo0aNws6dOwEABQUFAIAJEyYgIyMDRUVFaGhocLWfPn06+vXrh8LCQrf2c+fORUxMDPLy8txyWrx4MRobG93aWq1WLFmyBDU1NSgpKXG1TUhIwLx583DixAmUlpa6jqempmLGjBmoqKhAeXm563hPY9q+fTuqq6tdx3saU35+vts2m77G5Cwcp0DGNHnyZLd5Cdcx1dbWuuUZius0cODAbnMjakzZ2dndYgcypqysrG5xlF4nJyVjUlpPlZWVbu3VHpNW9aTma4SzVp0Py3Ad07BhwwC4Xz+1r5Oznt77sAAfHDdj6xkTZJgQH2XFzZemYIjjG5zZV4K8fcrHNHz4cADAzp07UVNTE/CYZs6c2W1efI3J03VyUvM1QsnrHtDxl61gxtQbn7nx8fEAgMrKSnz11VdhOyYAaGxsRHFxcY9jEnWdRNWTmmNKSUkBABw6dAgHDx7scUzerlNlZSWGDh3q95gAZfUEALW1tfjiiy96HJOT1vdec3Nzt5y84XeyfHB+7rKmpsb1uUuz2QyLxQKHw+Fa9XY+3tLSgvz8fCxYsAARERGwWCwwm82w2+3oPNXO483NzSgoKHC1d950XW9aq9UKm82GDz/80NUWACIiIiBJkmtBCAAmkwlWq9XrcW+5ezvuLXdvx7uu8n2NydNxpWOSZRl5eXlu8xKOY2pra8PGjRtdeYbiOjkcjm5zI2pMALrFDmRMkiR5vX7+XCebzYaCggIsXry4W34i68nb9VNjTJ2Ph7qe1HyNkCTJbQ7DdUyerp/a10mWZTz294348GQ06po7Yi29eAB+e+VYpMZHBjUmh8OBjz76CNnZ2a7zBzImWZa71YyvMXW9Tp1r1ZmnP2NSWk/+vu4581m0aFG373nooZ7UfI2w2+3Iz8/HwoULYTZ/96GncBqTr+un5nUSVU9qjsl5/XJycmCxWHocU9fr5Mxj4cKFiIqK8mtMSuup8zk83WPeXjucrwlKx9Q190CvU319PVJSUvz6ThbfyfJDRESE2wMF6LgYnW9cJ6vVCqvV2q1P50LsGttT+67nA7678bq2NZvNbjdoT8e95e5rTJ74GlOwx5WMyWazeZwXIPzGpOT6ibhODofD69wEOyZf865kTJIkeY3j73Vy/l7JmAKpJ0/t1RqTr9yVHg+X1whf94y33L0dV3NMgVy/YK5T+ekGPPLuHnx5zALAhmGpcVi9LAszhqe4jSuYMXV+NnXl75gCuX5dr4fzXGq+Rih53XN+kT5c7j1nTp6E+jXCarXCbDZ7bB8uY/J1/dS8TiLqydtxUWOyWq2wWCyKrl/n3J3Xv+vxQHP31t7bPebttUPre8/bn3vCd7J8CGR3QSIiIn80ttnx/McH8H9bj8IhyYiJsODuK4bjp5cPRaSVX5kmIgo33F1QQ5Ikoaqqyu0tS1HtlcY2Cr3MixZ5qnlOUbGDjRNof9Zq6OllXtTOU5Zl/GfPSVzx7Gb8ufgIHJKM7DH98eZNY/GzWeIXWKxVsfkYgR7mRqsc+VwV08cIz1QusgRzOBwoKSlx+2ysqPZKYxuFXuZFizzVPKeo2MHGCbQ/azX09DIvauZ5qLoRP/7rdvz89V04U9+G9KRYvLJ8MnJvGI8j+3ayVgX087e9Xu5HLehhbrTKkc9VMX2M8Ezld7KIiIhU1tLuQG7hQfyp6BBsDhmRVjPumD0Md8wZhugIi6JtgYmIKPxxkUVERKSigv1nsGrDPlSe6/hhmnMyU7Fq6VgMTonTODMiIlILF1mCmUwmJCQkdNu+UkR7pbGNQi/zokWeap5TVOxg4wTan7UaenqZF1F5nqhrxqoN+/BJWRUAYGCfaDy6dCxyxvbvFpu1Kq6fv+31cj9qQQ9zo1WOrFUxfYzwTOXugj5wd0EiIlKqze7Anz49jNzCg2izS7CaTfjpzKG454rhiI3kv20SEekVdxfUkCRJOHbsmKLdVfxtrzS2UehlXrTIU81zioodbJxA+7NWQ08v8xJMnkUHqrHwuWKsKziANruE6UOTsfHemXho0SifCyzWqrh+/rbXy/2oBT3MjVY5slbF9DHCM5WLLMEcDgdKS0sV7a7ib3ulsY1CL/OiRZ5qnlNU7GDjBNqftRp6epmXQPI8db4Fd/5zB/77/7bjSE0TUhOi8PwPJ+D1W6dieL8EVc7pL9aq2HyMQA9zo1WOrFUxfYzwTOXnFoiIiAJkc0j4vy1H8PwnFWhud8BsAm6aMRi/XDASidERWqdHREQa4SKLiIgoAJ8drsWj7+3FgTONAIBLMi7A6mVZGDOQ3+ElIjI6LrIEM5lMSE1NVbS7ir/tlcY2Cr3MixZ5qnlOUbGDjRNof9Zq6OllXnrKs6qhFU/nleHdXZUAgKS4SDy0cBS+d0kazObQ3sehjN3balUv96MW9DA3WuXIWhXTxwjPVO4u6AN3FyQiIieHJOMfnx3D7z8qR0ObHSYTcMOUdPwqJxN9YyO1To+IiFTG3QU15HA4UFZWpuiLf/62VxrbKPQyL1rkqeY5RcUONk6g/VmroaeXefGU587jZ3HVH7dg5YZ9aGizY9xFfbD+zsvw1DXjhCywWKvi+vnbXi/3oxb0MDda5chaFdPHCM9ULrIEkyQJ5eXliraw9Le90thGoZd50SJPNc8pKnawcQLtz1oNPb3MS+c8zza146F39uDal7Zh38l6JEZbsfrqLKy/6zKMH9RXlXOKxloVm48R6GFutMqRtSqmjxGeqfxOFhERUReSDPz7y2/wu4IKnGu2AQCum5SGhxePQkp8lMbZERFRuOMii4iIqJN9J+vx/F4Ljn62HwAwakACHl+WhSlDkjTOjIiI9IKLLMHMZjPS09NhNvv3SUwl7ZXGNgq9zIsWeap5TlGxg40TaH/WauiF+7ycb7FhXX45XvvsGCTZhLhIC365YCRumjEYERZ1c2atiuvnb/twvx+1pIe50SpH1qqYPkZ4pnJ3QR+4uyARUe8nyzLWl1biyQ/KUNPYBgC48uIL8dslYzCgT7TG2RERUbjg7oIacjgc2LVrl6LdVfxtrzS2UehlXrTIU81zioodbJxA+7NWQy8c5+XAmQb88H8/wy/f3I2axjYMTY3D32++FLeMNiE1PiJkebBWxfXzt3043o/hQg9zo1WOrFUxfYzwTOUiSzBJknD8+HFFu6v4215pbKPQy7xokaea5xQVO9g4gfZnrYZeOM1LU5sdT+V9jcXPF+PzI3WIjjDjwZxMfPiLmZg+NIm1qkKccKvVcLofw40e5karHFmrYvoY4ZnK72QREZFhyLKMD/eexur/7Mep860AgAVj+uPRK8dgUFIsAMBm09eDnIiIwg8XWX6w2Wyw2Tq28DWbzbBYLHA4HG4raudxu93u6gMAFosFZrMZdrsdnb/+5jzubOf8r9XacUmccZysVqurv7MtAERERECSJLe3UE0mE6xWq9fj3nL3NSZPufc0ps65exuTp+NKx+TU+bzhOqbOeYbiOnmaG1Fj8hQ7kDF5iqPkOnXup2RMgdRT5/Zqjqnz8VDXk5qvEV3nMNRjOlzdgMf+U4YtB2sBAIOSYrByyWjMHpniysvb9VP7Onk6p6jr5Ozb9ZxKx+SpZnyNqet16txPzdcIT+09jcn5/7IsBzymzrn3pmeus40kSR7vyXAYk6/rp+Z1ElVPao7JGbPrx+v8vU7Oczvb+DMmpfXU+Rw9ve51/nOt772uf+4LF1ke5ObmIjc313Vx8/PzERvb8S+c6enpmDhxIvbs2YPjx4+7+mRmZmLUqFHYtWsXAKCgoAAAMGHCBGRkZKCoqAgNDQ2u9tOnT0e/fv1QWFjo1n7u3LmIiYlBXl6eW06LFy9Gc3OzW1ur1YolS5agpqYGJSUlrrYJCQmYN28eTpw4gdLSUtfx1NRUzJgxAxUVFSgvL3cd72lM27dvR3V1tet4T2PKz893KyRfY2ppaXHNQaBjmjp1KpKTk13zEq5jqqurA/Dd9QvFdUpLS0NkZKTb3Iga08KFC5GWluYWO5AxXXzxxejTp49bHKXXKS0tDWazGRs3bvR7TErr6eTJk27t1R6TVvWk5mvElClTkJmZicLCwpCOadLkqXjsrc/x76/q4JBNsJhkXDs6AatvuBxf792DvLztbmMaMWIEYmNj3a6f2tdJVD15uk4jRoxAZmYmdu3aFdS9N3v2bAwfPtwtR19j8nSdIiMjYTabVX2NUPK6N3jwYEiShI8++ijgMfXGZ258fDwyMzNx8uRJ7NmzJ2zHNHz4cDQ3N+PTTz/tcUzhVk9qjykzMxOHDx9GRUVFj2Pydp1OnjyJIUOG+D0mpfWUmZmJuro6bN/+3WuwtzHFxsbCbDZrfu85/+7gD+4u6INzB5GamhrXDiJ6+Beo3vivahwTx8QxcUyBjKmwvBqr88pwoq4FADBzeDIevXIUhqYm6HZMvfE6cUwcE8fEMelhTPX19UhJSfFv53GZvDp//rwMQD5//rzffWw2m7x161bZZrMJb680tlHoZV60yFPNc4qKHWycQPuzVkMvlPNyvLZJvuVvX8gZv/6PnPHr/8jTnvpYzttzUpYkKazyDMU5Wati8zECPcyNVjmyVsX00eszVcnagB8XFEyWZVRXV7utjkW1VxrbKPQyL1rkqeY5RcUONk6g/VmroReKeWmzO/DnosP4Y+FBtNokWM0m3HL5ENxzxQjERfn3yGOtqhMn3GqVdeqdHuZGqxxZq2L6GOGZykUWERH1ClsqavDoe3txuKYJADB1SBJWX52Fkf0TNM6MiIiMhossIiLStdPnW7H6g/34YM8pAEBKfBR+u2Q0lk0Y6LYDKRERUahwkSWYxWLBhAkT3LaRFdVeaWyj0Mu8aJGnmucUFTvYOIH2Z62Gnuh5sTkk/G3rUTz38QE0tTtgNgH/PX0w7sseicToiLDJU+tzslbF5mMEepgbrXJkrYrpY4RnKncX9MG5u6BfO4gQEVHIbD9ShxXr96L8TMcWvBPT+2L1sixkXdRH48yIiKi3UrI2MPv8U1LMbrdj06ZNXn/QZDDtlcY2Cr3MixZ5qnlOUbGDjRNof9Zq6ImYl+qGNtz371Jc/6cSlJ9pwAWxEVh73Ti887MZwhZYrFV14oRbrbJOvdPD3GiVI2tVTB8jPFP5cUHBZFlGQ0ODot1V/G2vNLZR6GVetMhTzXOKih1snED7s1ZDL5h5cUgyXv/8GJ75qBwNrXaYTMAPJw/Cr3JG4YK4yLDJMxzPyVoVm48R6GFutMqRtSqmjxGeqVxkERFRWCs9cQ4r1u/FV5XnAQBjBybiiauzMDH9Ao0zIyIi8oyLLCIiCktnm9rxzEfleOOL45BlICHaigdzMnHj1AxYzNw1kIiIwhc3vvAhkI0vJElCTU0NUlJSYDb3/JU3Je2VxjYKvcyLFnmqeU5RsYONE2h/1mro+TsvkiTjrR0nsObDMpxttgEArp14ER5ePBqpCVFhk6dezslaFZuPEehhbrTKkbUqpo9en6lK1gZcZPnA3QWJiEJr38nzWLF+L3YePwcAGNk/HquXZWHq0GRtEyMiIsPj7oIastls+OCDD2Cz2YS3VxrbKPQyL1rkqeY5RcUONk6g/VmroedrXupbbVi1YR+WvrgFO4+fQ1ykBY8sHo0P7pkZ8gUWa1WdOOFWq6xT7/QwN1rlyFoV08cIz1R+J0sFgWxPq1Zso9DLvGiRp5rnFBVbxHa1oejHWg1e13mRZRnvlZ7Ek3lfo7qhDQCwZNyF+O2Vo3FhnxgtUgTAWlUrTrjVKuvUOz3MjVY5slbF9Ontz1QusoiISBMVZxqw4r29+OxwHQBgSEocHrtqLGaNTNU4MyIiouBwkUVERCHV1GbHyx8fxF+Lj8AuyYiymnH3vOG4ddZQRFktWqdHREQUNG584UMgG184f2BaQkICTKaetxhW0l5pbKPQy7xokaea5xQVO9g4gfZnrYaeJEl498ujePaTIzh5vhUAMH90P6xcOhaDkmI1zu47rFV14oRbrbJOvdPD3GiVI2tVTB+9PlOVrA34TpYKYmKUfY9ASXulsY1CL/OiRZ5qnlNU7GDjBNqftRo6R2uasHLDPnx6oBoAkHZBDFYtHYv5Y/prnJlnrFV14oRbrbJOvdPD3GiVI2tVTJ/e/kzl7oKC2e125OXlKfrSrb/tlcY2Cr3MixZ5qnlOUbGDjRNof9ZqaLTaHFhXcADZzxXh0wPVsJhk3Dl7KAp+OTtsF1isVXXihFutsk6908PcaJUja1VMHyM8U/lOFhERqaKwrAorN+zD8bpmAMBlw5IxJ+EMls8fjogIfveKiIh6Ly6yiIhIqG/ONuPx9/cjf/8ZAMCAxGisuHIMFoxKxocffqhxdkREROrjIouIiIRot0v4c/FhvLipAq02CRazCbdcPgT3XDEC8VFW3f0gSSIiokBxd0EfAt1d0G63w2q1+r27ir/tlcY2Cr3MixZ5qnlOUbGDjRNof9aqWFsP1mDFe3txuLoJADBlcBJWX52FzAEJrjZ6mRfWqjpxwq1W9XI/akEPc6NVjqxVMX30+kxVsjbgxhcqaGlpUa290thGoZd50SJPNc8pKnawcQLtz1oN3pn6Vtz9r1248S+f43B1E1LiI7Hu+vF48/ZpbgssJ73MC2tVnTjhVqt6uR+1oIe50SpH1qqYPr39mcpFlmB2ux2FhYWKdlfxt73S2Eahl3nRIk81zykqdrBxAu3PWg2O3SHhL8WHccWzn+L93SdhNgE3Tc/AJ/fPwbWT0jz+a6Ne5oW1qk6ccKtVvdyPWtDD3GiVI2tVTB8jPFP5nSwiIlLki6N1WLF+L8pONwAAxg/qiyevzkLWRX00zoyIiCg8cJFFRER+qWlsw5oPy/D2jm8AAH1jI/DrhaPwg0sHwWwOz+9tEBERaYGLLBVYrcqmVUl7pbGNQi/zokWeap5TVOxg4wTan7XqH4ck4/Xtx/G7jWWob+34uMYPLh2EXy8ahaS4SEWx9DIvrFV14oRbrerlftSCHuZGqxxZq2L69PZnKncX9CGQ3QWJiHqT3SfOYcV7e7Hnm/MAgDEXJmL11Vm4JOMCjTMjIiIKLe4uqCFJklBVVQVJkoS3VxrbKPQyL1rkqeY5RcUONk6g/Vmrvp1rbscj736Fq1/aij3fnEdClBWrlo7Bhp9fFvACSy/zwlpVJ0641ape7kct6GFutMqRtSqmjxGeqVxkCeZwOFBSUgKHwyG8vdLYRqGXedEiTzXPKSp2sHEC7c9a9UySZPz7yxOY9+yn+OfnxyHLwNUTBuKTB2Zj+WVDYLUE/tjQy7ywVtWJE261qpf7UQt6mButcmStiuljhGeq/j7gqAGbzQabzQYAMJvNsFgscDgcbitq53Hn9pLO9haLBWazGXa7HZ0/mek87mzn/K/zM6ddt6m0Wq2u/s62ABAREQFJktxuPJPJBKvV6vW4t9x9jclT7j2NqXPu3sbk6bjSMTl1Pm+4jqlznqG4Tp7mRtSYPMUOZEye4ii5Tp37KRlTIPXUub2aY+p8PJT1VH6mEave/xpfHjsLABieGodVS0dj+rAUIfXUdQ5DMaZA6snJU92odZ08nVPUmJx9u55T6Zg81YyvMXW9Tp37qfka4am9pzE5/1+W5YDH1Dn33vTMdbaRJMnjPRkOY/J1/dS8TqLqSc0xOWN2XZT4e52c53a28WdMSuup8zl6et3r/Oda33td/9wXLrI8yM3NRW5uruvi5ufnIzY2FgCQnp6OiRMnYs+ePTh+/LirT2ZmJkaNGoWdO3cCAAoKCgAAEyZMQEZGBoqKitDQ0OBqP336dPTr1w+FhYVu7efOnYuYmBjk5eW55bR48WI0Nja6tbVarViyZAlqampQUlLiapuQkIB58+bhxIkTKC0tdR1PTU3FjBkzUFFRgfLyctfxnsa0fft2VFdXu473NKb8/Hy3QvI1ppaWFtccBDqmyZMnu81LuI6ptrbWLc9QXKeBAwd2mxtRY8rOzu4WO5AxZWVldYuj9Do5KRmT0nqqrKx0a6/2mEJZT612IO8bM4pPmyHJQLTVhOyBdsy58Dxqv/4Me5rE1JOzVrv+vBO1XyOU1tOwYcMAuF8/ta+TqHryNKbhw4cDAHbu3ImampqAxzRz5sxuOfoak6fr5KTma4SS1z2g4y9PwYypNz5z4+PjAQCVlZX46quvwnZMANDY2Iji4uIexxRu9aTmmFJSUgAAhw4dwsGDB3sck7frVFlZiaFDh/o9JkBZPQFAbW0tvvjiix7H5KT1vdfc3NwtJ2+48YUPzi+31dTUuL7c1tOKubW1FVu3bsWMGTNgtVp7XDG3tLRg27Ztrva+/gXKbrejqKjI1RYwzr+q9fRO1qeffuo2L+E4pvb2dhQXF7vyDMV1kiSp29yIGpPJZOoWO5AxybLs9fr5c53sdju2bduG2bNno+vLmch68nb91BiTyOvka0wOhwPvlVZizcYDqGpoAwAsyhqA3yzKxIDEKLcxiagnWZaxZcsWTJ8+3W2nqHB7J8vT9VP7OomqJ09jkiTJ9Vzq/E6P0jEB6FYzvsbU9Tp1rlWz2azaa4S/r3vOfGbNmtVtnEZ/J8vhcGDbtm24/PLL3T4xEk5j8nX91LxOoupJzTE5r99ll13m9m6wv9fJmcfMmTMRGRnp15iU1pPdbkdJSYnXe8zba4fJZNL03quvr0dKSopfG19wkeUDdxckot7qYFUDHn1vH7Yd6niHdXByLB5bloXZI1M1zoyIiCg8cXdBDUmShGPHjinaXcXf9kpjG4Ve5kWLPNU8p6jYwcYJtL9Ra7W53Y61G8uw6PlibDtUiyirGfctGImN985SfYEVzvPSGWtVnTjhVqt6uR+1oIe50SpH1qqYPr3lmeoLF1mCORwOlJaWKtpdxd/2SmMbhV7mRYs81TynqNjBxgm0v9FqVZZlbNx7GgvWFeHlzYdgc8iYN6ofCn45G/dcMQLREZaegwQpHOfFE9aqOnHCrVb1cj9qQQ9zo1WOrFUxffT+TPUHN74gIurljtU2YeWGfdhc3vHl34v6xmDl0jFYMKa/22fhiYiISAwusoiIeqlWmwP/8+khvLT5ENrtEiIsJtw2ayh+PncEYiLVf+eKiIjIqLjIEsxkMiE1NdXvfx1W0l5pbKPQy7xokaea5xQVO9g4gfbv7bVaWF6FVRv24Vhtx3azlw1PxmNXZWF4v3jNcgqHefEHa1WdOOFWq3q5H7Wgh7nRKkfWqpg+enumBoK7C/rA3QWJSG8qz7Vg9fv7sXHfaQBA/8Qo/HbJGFx58YW6e0ARERGFE+4uqCGHw4GysjJFX/zzt73S2Eahl3nRIk81zykqdrBxAu3f22q13S7h5c2HMP/ZT7Fx32lYzCb89PIh+OT+OVg6fmBYLLBYq9qck7UqNh8j0MPcaJUja1VMn3B/porARZZgkiShvLxc0RaW/rZXGtso9DIvWuSp5jlFxQ42TqD9e1OtbjtUg8UvFGPtxjK02ByYPPgCfHDP5fjtlWMQHxU+nwpnrWpzTtaq2HyMQA9zo1WOrFUxfcL5mSpK+Dx9iYhIkar6VjyZ9zXeKz0JAEiOi8TDi0fjukkXhcU7V0REREbFRRYRkc7YHRL+XnIMfyg4gIY2O0wm4EdTM/BAdib6xEZonR4REZHhcZElmNlsRnp6Osxm/z6JqaS90thGoZd50SJPNc8pKnawcQLtr9da3XGsDr9dvw9fn6oHAIxP64PVV2fh4rS+ws8lGmtVm3OyVsXmYwR6mButcmStiukTLs9UNXF3QR+4uyARhYvaxjas3ViGf3/5DQCgT0wEfrUwEz+cnA6LmR8NJCIiUht3F9SQw+HArl27FO2u4m97pbGNQi/zokWeap5TVOxg4wTaXy+1Kkky/vn5Mcx79lPXAuv6S9Ow6f7ZuHFqhq4WWKxVbc7JWhWbjxHoYW60ypG1KqaPEf7+y0WWYJIk4fjx44p2V/G3vdLYRqGXedEiTzXPKSp2sHEC7a+HWv3qm/O45qWteOTdvTjfYsOoAQl4547peOZ745EcHxVUbC2wVrU5J2tVbD5GoIe50SpH1qqYPkb4+y+/k0VEFGbON9vw+/xy/OPzY5BlID7KivsWjMR/T8+A1cJ/GyMiIgp3XGQREYUJWZbxzs5KPJ33NWqb2gEAyyYMxCOLR6NfYrTG2REREZG/uMgSzGw2IzMzU9HuKv62VxrbKPQyL1rkqeY5RcUONk6g/cOtVstO12PF+r344uhZAMCw1DisXpaFGcNT/I4R7lir2pyTtSo2HyPQw9xolSNrVUwfI/z9l7sL+sDdBYlIbY1tdjxXcACvbDsKhyQjJsKCe64YgVsuH4JIq74eKERERL0ZdxfUkN1ux7Zt22C324W3VxrbKPQyL1rkqeY5RcUONk6g/bWuVVmW8f7uk7ji2c34y5YjcEgyFo4dgI/vn4075gzrlQss1qo252Stis3HCPQwN1rlyFoV08cIf//lxwUFk2UZ1dXV8PcNQiXtlcY2Cr3MixZ5qnlOUbGDjRNofy1r9VB1I1a+tw9bDtYAADKSY7HqqrGYm9nP/wHoEGtVm3OyVsXmYwR6mButcmStiuljhL//cpFFRBQiLe0O/LGwAv9bdBg2h4xIqxl3zhmGn80ehugIi9bpERERkSBcZBERCeSQZHx+pA47akxIPlKH6cP7wWwCCvafwWPv70fluRYAwNzMVKy6aiwykuM0zpiIiIhE4yJLMIvFggkTJsBi8e9fpZW0VxrbKPQyL1rkqeY5RcUONk6g/dWo1Y17T+Gx9/fj1PlWABb8veJLpMZHoX+fKOytrAcADOwTjUeXjkXO2P4wmUyKctY71qo252Stis3HCPQwN1rlyFoV08cIf//l7oI+cHdBIvLXxr2ncMc/dsLbC6rFDNw2axjunjccsZH89y0iIiK94e6CGrLb7di0aZOi3VX8ba80tlHoZV60yFPNc4qKHWycQPuLrFWHJOOx9/d7XWABQFJcFB7IzjT0Aou1qs05Wati8zECPcyNVjmyVsX0McLff437tFeJLMtoaGhQtLuKv+2VxjYKvcyLFnmqeU5RsYONE2h/Jf0kSUZNYxvKTzfAVFGDsy12VDW0ofrbXwerGr/9iKB31Q1t2H6kDtOHJSvKszdhrWpzTiPVqpL2erkftaCHudEqR9aqmD5G+PsvF1lEZFhtDuBYXTPOtTg6FkyNbaiqb3P9v3MRVdPYBrskA7ACe3YEfL6qBt8LMSIiIuoduMgiol7FIcmobWzreKep00LJ7VdjG6oaWtHUZgW2b/E7dpxVxsCkePRPjEFqQlTHr/gonGtpR27hoR7790uIDmZoREREpBPc+MKHQDa+kCQJNTU1SElJgdnc81felLRXGtso9DIvWuSp5jlFxfYnjizLaGxz/4jed+88taKytgHn22VUN7SjrqkNkoJXtSirGf0SOxZL/RKiv1s8fbuA6pfY8f8XxESg/lydxzwdkozL127C6fOtHr+XZQIwoE80tvx6HixmY+0o2BlrVZtzhrJW1eiv1nNVL/ejFvQwN1rlyFoV00evf/9VsjbgIssH7i5IpK52u4TaJs8f0atqaHU71mqT/I5rMgHJcR2Lo35dFk3O/3cej4+yCtlK3bm7IAC3hZYz8ss/moSFWRcGfR4iIiLShpK1AT8uKJjNZkN+fj6ys7MREREhtL3S2Eahl3nRIk81z+kttizLON9i+3ah5P6uk9viqaENZ5ttis4ZH2X9brH07btPybFWnDl2EHOmTcSFF8QhNSEKSbGRsFp8/2uX6FpdmHUhXv7RpE4/J6vDgD7RWLl0DBdYYK1qdU5RsYONE2h/tZ6rerkftaCHudEqR9aqmD5G+PsvF1kqCGR7WrViG4Ve5kWLPEWds9XmcFs4nT7fjJIjEore24/aJhuqO73zZHP4/wa51WxCnFXCoJQ+6JcY7fGdp34J0UhJiPS4/bnNZkNeXhlmj0xV/OIrulYXZl2IBWMGoORgFfKLP0f2zKmYPryfoT8i2BVrVZtziootYmvpUPRTso00eaaHudEqR9aqmD69/e+/XGQRGZgkyahrbu/+rlOn7zs534FqaPX0AmcGvvnGY+w+MRFdFkpR7t93+nbxFGcFNm78EIsXT9PVv1B5YzGbMHVIEmq/ljF1SBIXWERERAbERRZRL9TUZkd1QxtOnWvCrloTaj47jrpmW6fvO3X8t7apHQ4Fu0REWs2uRVNKXARazp7BJWNGoH/fmO8WU4nRSImPRJTV4ldMm03ZRwaJiIiIwh03vvAhkI0vnD8wLSEhwa8v0ytprzS2UehlXoLN0+6QUNvU3n1jCLfvO3X8t7ndoSh2clyk+0f0Ej1tEhGNxOjvNokQNe/Bxgm0P2s19PQyL1rkqeY5Wati8zECPcyNVjmyVsX00eszlRtfaCwmJka19kpjG4Ve5qVrnrIso77V7vUjep1/1TW3Q8k/icREWNAvIQop8ZFITYxG/64f14vv2K48OT4SET1sEuHveAIVbJxA+7NWQ08v86JFnmqek7UqJq6R6GFutMqRtSqmT29/pobnDz/QMbvdjry8PEVfuvW3vdLYRhGO89Jmd6DyXAtKT5xDwf4zeP3z4/hDfjmW/3Ejbvv7l7jmpa24fO0mjFqxEeMfy8f8dZ/ihj9/hnv+tQtPfPA1/vTpYfy/nZUorqhB2ekG1DZ1LLDMJqBfQhTGDkzEnMxUfP+SNNw1dxhWLR2D3P+ahH/fPh2FD8zBvsdy8PXqhfj4l5fjvy+qwYs/uBiPLcvCz+eNwA8mp2PeqP4Yl9YHA/pEB7zAEjXvwcYJtD9rNfT0Mi9a5KnmOVmrYvMxAj3MjVY5slbF9DHCM5XvZBH5SZJknGuxdXrXqePjelX17j/fqbqxDee8bk1uBs5UdTuaEG318HOcorvtspcUF8mNFIiIiIjCHBdZZHgt7Q63RVPXzSGcC6gahVuTR1hMboum5LgInDt1AtMnjcWAPrGu7zqlxEchJtK/TSKIiIiIKPxxkUW9kkOSUdvkaUvyToumb483tCl7+/mC2AiPP8fJ/ftOUegbG+H2Bc2On+d0DIunDOoVW5UTERERkWfcXdCHQHcXtNvtsFqtfu+u4m97pbF7G1mW0dTu6NgYosH9I3qnz7d8+wNxO47XNrZBwc7kiLKa0a/Ljnqp8dHdjiUr2JrcU/6hvn5qnlNU7GDjBNqftRp6epkX1qo6ccKtVvVyP2pBD3OjVY6sVTF99PpM5e6CGmtpaUFCQoIq7ZXG1gObQ0JtY7v7luQe3nmqbmhDi83/rclNJiA5LsrDu07dfyhuQlRoCleL66fmOUXFDjZOoP1Zq6Gnl3lhraoTJ9xqVS/3oxb0MDda5chaFdOntz9TubugYHa7HYWFhYp2V/G3vdLYWpJlGeebbThY1YBtB2vwXmkl/lJ8GE/nfY373izFj/7yOXL+UIRJqwsw4pEPMe3pT3DVH7fille/xEP/7ys8W3AAfy85ho37TmPHsbM4XtfsWmDFRVowJCUOUwYnYcm4C/HjaelYMsiBp68Zi1dunoz/3H05tv/mClQ8sQhf/nY+PvzFTPz9J1Pw7PXj8dCiUfjJ5UOwdPxATBuajGGp8UiMjgjJAkuL66fmOUXFDjZOoP1Zq6Gnl3lhraoTJ9xqVS/3oxb0MDda5chaFdPHCM9UvpPlB5vNBputY7c4s9kMi8UCh8MBSZJcbZzHnTeAs73FYoHZbIbdbkfnT2Y6jzvbOf9rtXZckq43kslswWeHa7GjxoQ+FVWYNiwVFrMJERERkCQJDsd37/CYTCZYrVavx73l7mtMztzbbA6cbXGgpqkdp881o+rbDSGqG9s73o1qbEf1tz/nSckmERazCSnf/kDcfonRSImPRHJchNu7TwP6xiIpNgLR1u8WRCaTCbIsIy/vMBaM6+f6rlNH7ma/xqTkOjl5u07ejjuvE/DdtVbzOjlzd+qcv6gxeYodyJg8xVFynTr3UzImT/17qqfO7dUcU+fjou69UL1G+BpT1zkM1zE5eaobta6Tp3OKGpOzb9dzKh2Tp5rxNaau16lzPzVfIzy19zQm5//LshzwmDrnHup6UvM1wtlGkiSP92Q4jMnX9VPzOomqJzXH5IzZ+ZivMXW9Ts5zO9v4Myal9dT5HD297nX+c63vva5/7gsXWR7k5uYiNzfXdXHz8/MRGxsLAEhPT8fEiROxZ88eHD9+3NUnMzMTo0aNws6dOwEABQUFAIAJEyYgIyMDRUVFaGhocLWfPn06+vXrh8LCQrf2c+fORUxMDPLy8lxtd9eakHc6Fqfr2wBY8PeKUvSNlPH9YSY8ctMS1NTUoKSkxNU+ISEB8+bNw4kTJ1BaWuo6npqaihkzZqCiogLl5eWu42mDBmHwyLEo/mI3yo+fRr0NaGgHLPFJcETE4WBlFWqbbKhvB1ocyt7xibHIuLBvLPolRqO9vhaJkUBihIyESGD+ZVOQECGjvHQ7Yq2A2WSD1dqGJUtmoqqqqmNMdYBUBzQlJCBj2DwcO3as25gmT57sNof+XKft27ejurradbyn65Sfn+/24uDpOgHA4sWL0dLS4rquQEeBLlmyBLW1tW55Kr1OgYxp4MCB3eZG1Jiys7O7xQ5kTFlZWd3iKL1OTkrG1NjY6HZe53XyVk+VlZVu7dUek8h7L9jXCFH15KzVrv8iGW5jGjZsGAD366f2dRJVT57GNHz4cADAzp07UVNTE/CYZs6c2S1HX2PydJ2c1HyNUPK6B3T85SmYMWlVT2q+RsTHxwMAKisr8dVXX4XtmACgsbERxcXFPY4p3OpJzTGlpKQAAA4dOoSDBw/2OCZv16myshJDhw71e0yAsnoCgNraWnzxxRc9jslJ63uvubm5W07ecOMLH5xfbqupqXF9ua2nFXNLSws++eQTzJs3DxERET2umJubm7Fp0yZX+64r5o/2ncHdb+xG14vkXOq8/KNJyB7T3+O/bDS2tuP0+ZaOXfQa21Hd2Ia6Jjuq6ltR1dCKmsb2jl32mtrhULBLRKTFhNSEjnebUuMjkZIQhdT4SPRLjEH/xGhcEGNBakIUUuIiERVhUf1fqWVZxkcffeSaw87XI5z+pbCtrQ0FBQWuPEPxr58Oh6Pb3Ij8l/eusQMZkyRJXq+fv+9kbdq0CTk5Od3y8zUmm82G/Px8t/P6uve8XT81xtT5eLi/66P0nayPP/4Yc+fOddthM9zG5On6heKdLBH15O1f3p3PJef5AxmTLMvdasbXmDy9k+WsVWee/oxJaT35+7rnzCc7O7vbR8b1UE9qv5O1adMmzJ8/3+3dxHAak6/rp/Y7WSLqSc0xOa/fFVdc4fburpJ3sjZt2oQFCxYgKirK73eylNSTzWZDYWGh13vM22uH8zVB6Zi65h7odaqvr0dKSopfG19wkeVDILsLiuSQZFy+dhNOnW/12qZPTAR+OnMIar9dMHX8fKeODSSa2v3fJAIAkuIikRof1X2XvYROG0bERyMxRvvdXYiIiIiIQom7C2pIkiTU1NQgJSXFbWUeSPvtR+p8LrAA4HyLDc/mH/D659ERZtfPcOrXZZe9zj/fKTk+EhEWfe6DonTOtaJFnmqeU1TsYOME2l9krYrKqbfTy7ywVtWJE261qpf7UQt6mButcmStiuljhGeqfjLVCYfDgZKSkm5fNgykfVWD7wWW09QhSbhzzjCsXDoGf/yvifj37dNR+MAc7H0sB18/vhBFv5qLd+6YgZd/dAkeX5aFu68YgR9OSccVo/tjXFofDOgTrdsFFqB8zrWiRZ5qnlNU7GDjBNpfZK2Kyqm308u8sFbViRNutaqX+1ELepgbrXJkrYrpY4RnKt/JCmP9EqL9anfv/JGYPixZ5WyIiIiIiMgf+n37wgCmDEnChX2i4e3bTyYAF/aJxpQhSaFMi4iIiIiIfOAiSzCTyYSEhAS/N4bw1d5iNmHl0jEd7br2+/a/K5eOgcVs7E0olM65VrTIU81zioodbJxA+4usVVE59XZ6mRfWqjpxwq1W9XI/akEPc6NVjqxVMX2M8Ezl7oI+aL27oNPGvafw2Pv73TbBuLBPNFYuHYOFWRdqlhcRERERkVEoWRvwnSzBJEnCsWPH3PbqD7b9wqwLseXX8/D6T6dgxfw0vP7TKdjy63lcYH1L6ZxrRYs81TynqNjBxgm0vxq1GmxOvZ1e5oW1qk6ccKtVvdyPWtDD3GiVI2tVTB8jPFO5yBLM4XCgtLRU0e4q/rS3mE2YnNEXKU1HMTmjr+E/ItiZ0jnXihZ5qnlOUbGDjRNof7VqNZiceju9zAtrVZ044VarerkftaCHudEqR9aqmD5GeKZykUVERERERCQQF1lEREREREQCcZElmMlkQmpqqqLdVfxtrzS2UehlXrTIU81zioodbJxA+7NWQ08v88JaVSdOuNWqXu5HLehhbrTKkbUqpo8RnqncXdCHcNldkIiIiIiItMXdBTXkcDhQVlam6It//rZXGtso9DIvWuSp5jlFxQ42TqD9Wauhp5d5Ya2qEyfcalUv96MW9DA3WuXIWhXTxwjPVC6yBJMkCeXl5Yq2sPS3vdLYRqGXedEiTzXPKSp2sHEC7c9aDT29zAtrVZ044VarerkftaCHudEqR9aqmD5GeKZykUVERERERCQQF1lEREREREQCcZElmNlsRnp6Osxm/6ZWSXulsY1CL/OiRZ5qnlNU7GDjBNqftRp6epkX1qo6ccKtVvVyP2pBD3OjVY6sVTF9jPBM5e6CPnB3QSIiIiIiAri7oKYcDgd27dqlaHcVf9srjW0UepkXLfJU85yiYgcbJ9D+rNXQ08u8sFbViRNutaqX+1ELepgbrXJkrYrpY4RnKhdZgkmShOPHjyvaXcXf9kpjG4Ve5kWLPNU8p6jYwcYJtD9rNfT0Mi+sVXXihFut6uV+1IIe5karHFmrYvoY4ZnKRRYREREREZFAVq0TCGfOr6vV19f73cdms6G5uRn19fWIiIgQ2l5pbKPQy7xokaea5xQVO9g4gfZnrYaeXuaFtapOnHCrVb3cj1rQw9xolSNrVUwfvT5TnWsCf7a04CLLh4aGBgDAoEGDNM6EiIiIiIjCQUNDA/r06eOzDXcX9EGSJJw8eRIJCQkwmUx+95s8eTK++OIL4e3r6+sxaNAgnDhxgrsddqF0zrWiRZ5qnlNU7GDjBNqftRp6rFVtzsla7Y516psealWrHFmrYvro8ZkqyzIaGhowcODAHreU5ztZPpjNZqSlpSnuZ7FYFN0EStsnJiZqfpOFG6VzqBUt8lTznKJiBxsn0P6s1dBjrWpzTtaqd6xTz/RQq1rlyFoV00evz9Se3sFy4sYXKrjrrrtUbU/d6WUOtchTzXOKih1snED7s1ZDTy9zyFpVJw5rVT/0MIda5chaFdNHD/dYMPhxQR3hD0cm0gfWKlH4Y50S6YNea5XvZOlIVFQUVq5ciaioKK1TISIfWKtE4Y91SqQPeq1VvpNFREREREQkEN/JIiIiIiIiEoiLLCIiIiIiIoG4yCIiIiIiIhKIiywiIiIiIiKBuMgiIiIiIiISiIusXuDcuXO49NJLMWHCBGRlZeHPf/6z1ikRkQ/Nzc3IyMjAAw88oHUqROTF4MGDcfHFF2PChAmYO3eu1ukQkRdHjhzB3LlzMWbMGIwbNw5NTU1apwQAsGqdAAUvISEBRUVFiI2NRVNTE7KysnDttdciOTlZ69SIyIMnn3wS06ZN0zoNIurBtm3bEB8fr3UaROTD8uXL8cQTT2DmzJmoq6sLm5+nxXeyegGLxYLY2FgAQFtbG2RZBn/8GVF4qqioQFlZGRYtWqR1KkRERLq2b98+REREYObMmQCApKQkWK3h8R4SF1lhoKioCEuXLsXAgQNhMpmwfv36bm1yc3MxePBgREdHY+rUqdi+fbvbn587dw7jx49HWloaHnzwQaSkpIQoeyLjEFGrDzzwAJ5++ukQZUxkTCJq1WQyYfbs2Zg8eTL++c9/hihzImMJtlYrKioQHx+PpUuXYtKkSXjqqadCmL1vXGSFgaamJowfPx65ubke//zNN9/Efffdh5UrV2Lnzp0YP348cnJyUFVV5WrTt29f7N69G0eOHMHrr7+OM2fOhCp9IsMItlbfe+89jBw5EiNHjgxl2kSGI+K5umXLFuzYsQMbNmzAU089hT179oQqfSLDCLZW7XY7iouL8dJLL6GkpAQFBQUoKCgI5RC8kymsAJDfffddt2NTpkyR77rrLtfvHQ6HPHDgQPnpp5/2GOOOO+6Q33rrLTXTJDK8QGr1oYcektPS0uSMjAw5OTlZTkxMlB977LFQpk1kOCKeqw888ID8yiuvqJglEQVSq9u2bZOzs7Ndf/7MM8/IzzzzTEjy7QnfyQpz7e3t2LFjB+bPn+86ZjabMX/+fJSUlAAAzpw5g4aGBgDA+fPnUVRUhMzMTE3yJTIqf2r16aefxokTJ3D06FH8/ve/x6233opHH31Uq5SJDMmfWm1qanI9VxsbG7Fp0yaMHTtWk3yJjMqfWp08eTKqqqpw9uxZSJKEoqIijB49WquU3YTHN8PIq5qaGjgcDvTv39/teP/+/VFWVgYAOHbsGG677TbXhhd33303xo0bp0W6RIblT60Skfb8qdUzZ87gmmuuAQA4HA7ceuutmDx5cshzJTIyf2rVarXiqaeewqxZsyDLMrKzs3HllVdqkW43XGT1AlOmTEFpaanWaRCRAsuXL9c6BSLyYujQodi9e7fWaRCRHxYtWhSWO/by44JhLiUlBRaLpdtGFmfOnMGAAQM0yoqIumKtEukDa5VIH/Req1xkhbnIyEhccskl+OSTT1zHJEnCJ598gunTp2uYGRF1xlol0gfWKpE+6L1W+XHBMNDY2IiDBw+6fn/kyBGUlpYiKSkJ6enpuO+++3DTTTfh0ksvxZQpU/Dcc8+hqakJN998s4ZZExkPa5VIH1irRPrQq2tV490NSZblwsJCGUC3XzfddJOrzYsvviinp6fLkZGR8pQpU+TPPvtMu4SJDIq1SqQPrFUifejNtWqSZVkO7bKOiIiIiIio9+J3soiIiIiIiATiIouIiIiIiEggLrKIiIiIiIgE4iKLiIiIiIhIIC6yiIiIiIiIBOIii4iIiIiISCAusoiIiIiIiATiIouIiIiIiEggLrKIiCgkjh49CpPJhNLSUq1TcSkrK8O0adMQHR2NCRMmaJ1OQEwmE9avX6/qOf76178iOztbcb/9+/cjLS0NTU1NKmRFRBS+uMgiIjKI5cuXw2QyYc2aNW7H169fD5PJpFFW2lq5ciXi4uJQXl6OTz75xGOb6upq3HHHHUhPT0dUVBQGDBiAnJwcbN26NcTZaqO1tRUrVqzAypUrXcdWrVoFk8mEn/3sZ25tS0tLYTKZcPToUQDAmDFjMG3aNKxbty6UKRMRaY6LLCIiA4mOjsbatWtx9uxZrVMRpr29PeC+hw4dwuWXX46MjAwkJyd7bHPddddh165dePXVV3HgwAFs2LABc+bMQW1tbcDn1ZO3334biYmJuOyyy9yOR0dH469//SsqKip89r/55pvx8ssvw263q5kmEVFY4SKLiMhA5s+fjwEDBuDpp5/22mbVqlXdPjr33HPPYfDgwa7fL1++HFdffTWeeuop9O/fH3379sXjjz8Ou92OBx98EElJSUhLS8Mrr7zSLX5ZWRlmzJiB6OhoZGVl4dNPP3X7871792LRokWIj49H//798eMf/xg1NTWuP58zZw5+/vOf495770VKSgpycnI8jkOSJDz++ONIS0tDVFQUJkyYgI0bN7r+3GQyYceOHXj88cdhMpmwatWqbjHOnTuH4uJirF27FnPnzkVGRgamTJmChx9+GFdddZWr3bp16zBu3DjExcVh0KBBuPPOO9HY2Oj687/97W/o27cv/vOf/yAzMxOxsbH43ve+h+bmZrz66qsYPHgwLrjgAtxzzz1wOByufoMHD8bq1atxww03IC4uDhdddBFyc3M9jtfpxIkTuP7669G3b18kJSVh2bJlrneWAGDz5s2YMmUK4uLi0LdvX1x22WU4duyY13hvvPEGli5d2u14ZmYm5s6di0ceecRnPgsWLEBdXV2360xE1JtxkUVEZCAWiwVPPfUUXnzxRXzzzTdBxdq0aRNOnjyJoqIirFu3DitXrsSVV16JCy64AJ9//jl+9rOf4fbbb+92ngcffBD3338/du3ahenTp2Pp0qWud4XOnTuHefPmYeLEifjyyy+xceNGnDlzBtdff71bjFdffRWRkZHYunUr/ud//sdjfs8//zyeffZZ/P73v8eePXuQk5ODq666yvXOy6lTpzB27Fjcf//9OHXqFB544IFuMeLj4xEfH4/169ejra3N61yYzWa88MIL2LdvH1599VVs2rQJv/rVr9zaNDc344UXXsAbb7yBjRs3YvPmzbjmmmuQl5eHvLw8vPbaa/jTn/6Et99+263f7373O4wfPx67du3CQw89hF/84hcoKCjwmIfNZkNOTg4SEhJQXFyMrVu3Ij4+HgsXLkR7ezvsdjuuvvpqzJ49G3v27EFJSQluu+02nx8X3bJlCy699FKPf7ZmzRq88847+PLLL732j4yMxIQJE1BcXOy1DRFRryMTEZEh3HTTTfKyZctkWZbladOmyT/5yU9kWZbld999V+78OFi5cqU8fvx4t75/+MMf5IyMDLdYGRkZssPhcB3LzMyUZ86c6fq93W6X4+Li5H/961+yLMvykSNHZADymjVrXG1sNpuclpYmr127VpZlWV69erWcnZ3tdu4TJ07IAOTy8nJZlmV59uzZ8sSJE3sc78CBA+Unn3zS7djkyZPlO++80/X78ePHyytXrvQZ5+2335YvuOACOTo6Wp4xY4b88MMPy7t37/bZ56233pKTk5Ndv3/llVdkAPLBgwddx26//XY5NjZWbmhocB3LycmRb7/9dtfvMzIy5IULF7rF/sEPfiAvWrTI9XsA8rvvvivLsiy/9tprcmZmpixJkuvP29ra5JiYGPmjjz6Sa2trZQDy5s2bfebvdPbsWRmAXFRU5Ha88z3ywx/+UJ43b54sy7K8a9cuGYB85MgRt/bXXHONvHz5cr/OSUTUG/CdLCIiA1q7di1effVVfP311wHHGDt2LMzm7x4j/fv3x7hx41y/t1gsSE5ORlVVlVu/6dOnu/7farXi0ksvdeWxe/duFBYWut5Bio+Px6hRowB0fH/K6ZJLLvGZW319PU6ePNnte0SXXXaZ4jFfd911OHnyJDZs2ICFCxdi8+bNmDRpEv72t7+52nz88ce44oorcNFFFyEhIQE//vGPUVtbi+bmZleb2NhYDBs2zPX7/v37Y/DgwYiPj3c75mu+nL/3Nobdu3fj4MGDSEhIcM1fUlISWltbcejQISQlJWH58uXIycnB0qVL8fzzz+PUqVNex97S0gKg4/tX3jzxxBMoLi5Gfn6+1zYxMTFuc0FE1NtxkUVEZECzZs1CTk4OHn744W5/ZjabIcuy2zGbzdatXUREhNvvTSaTx2OSJPmdV2NjI5YuXYrS0lK3XxUVFZg1a5arXVxcnN8xRYiOjsaCBQuwYsUKbNu2DcuXL3fttnf06FFceeWVuPjii/HOO+9gx44dru9Ndd6UQ4356qqxsRGXXHJJt/k7cOAA/uu//gsA8Morr6CkpAQzZszAm2++iZEjR+Kzzz7zGC85ORkmk8nnRinDhg3DrbfeioceeqjbfeNUV1eH1NTUgMdFRKQ3XGQRERnUmjVr8P7776OkpMTteGpqKk6fPu32F2aRP9uq81/o7XY7duzYgdGjRwMAJk2ahH379mHw4MEYPny42y8lC6vExEQMHDiw2zbrW7duxZgxY4Iew5gxY1w/+2nHjh2QJAnPPvsspk2bhpEjR+LkyZNBn8Op6wLos88+c81XV5MmTUJFRQX69evXbf769Onjajdx4kQ8/PDD2LZtG7KysvD66697jBcZGYkxY8Zg//79PnN89NFHceDAAbzxxhse/3zv3r2YOHGizxhERL0JF1lERAY1btw43HjjjXjhhRfcjs+ZMwfV1dV45plncOjQIeTm5uLDDz8Udt7c3Fy8++67KCsrw1133YWzZ8/iJz/5CQDgrrvuQl1dHW644QZ88cUXOHToED766CPcfPPNbrvu+ePBBx/E2rVr8eabb6K8vBwPPfQQSktL8Ytf/MLvGLW1tZg3bx7+8Y9/YM+ePThy5AjeeustPPPMM1i2bBkAYPjw4bDZbHjxxRdx+PBhvPbaa1434wjE1q1b8cwzz+DAgQPIzc3FW2+95XUMN954I1JSUrBs2TIUFxfjyJEj2Lx5M+655x588803OHLkCB5++GGUlJTg2LFjyM/PR0VFhddFGwDk5ORgy5YtPnPs378/7rvvvm73EtDxTl9lZSXmz5+vbOBERDrGRRYRkYE9/vjj3T6eNnr0aLz00kvIzc3F+PHjsX37do877wVqzZo1WLNmDcaPH48tW7Zgw4YNSElJAQDXu08OhwPZ2dkYN24c7r33XvTt29ft+1/+uOeee3Dffffh/vvvx7hx47Bx40Zs2LABI0aM8DtGfHw8pk6dij/84Q+YNWsWsrKysGLFCtx666344x//CAAYP3481q1bh7Vr1yIrKwv//Oc/fW6Rr9T999+PL7/8EhMnTsQTTzyBdevWed22PjY2FkVFRUhPT8e1116L0aNH45ZbbkFraysSExMRGxuLsrIyXHfddRg5ciRuu+023HXXXbj99tu9nv+WW25BXl4ezp8/7zPPBx54wO37ZU7/+te/kJ2djYyMDGUDJyLSMZPs7QPUREREpKnBgwfj3nvvxb333qtpHt///vcxadIkj9/h86W9vR0jRozA66+/3m0TEiKi3ozvZBEREZFPv/vd7zy+S9WT48eP4ze/+Q0XWERkOFatEyAiIqLwNnjwYNx9992K+zk33SAiMhp+XJCIiIiIiEggflyQiIiIiIhIIC6yiIiIiIiIBOIii4iIiIiISCAusoiIiIiIiATiIouIiIiIiEggLrKIiIiIiIgE4iKLiIiIiIhIIC6yiIiIiIiIBOIii4iIiIiISKD/Dzocat5Z/FmIAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -1540,6 +900,22 @@ " # 2. Perform a split\n", " sgss = StratifiedGroupShuffleSplit(n_splits=1, test_size=0.3, random_state=42)\n", " train_index, test_index = next(sgss.split(X, y, groups))\n", + " \n", + " # 2.1 Perform a second split and check if the indices are the same\n", + " \n", + " print(f\"\\nChecking if indices are reproducible with the same random state\")\n", + " sgss_2 = StratifiedGroupShuffleSplit(n_splits=1, test_size=0.3, random_state=42)\n", + " train_index_2, test_index_2 = next(sgss_2.split(X, y, groups))\n", + " \n", + " if np.all(np.equal(train_index, train_index_2)):\n", + " print(\"SUCCESS: Train indices are reproducible.\")\n", + " else:\n", + " print(\"FAILURE: Train indices are not reproducible.\")\n", + " \n", + " if np.all(np.equal(test_index, test_index_2)):\n", + " print(\"SUCCESS: Test indices are reproducible.\")\n", + " else:\n", + " print(\"FAILURE: Test indices are not reproducible.\")\n", "\n", " # 3. Check for group overlap\n", " train_groups = np.unique(groups[train_index])\n", @@ -1693,7 +1069,7 @@ ], "metadata": { "kernelspec": { - "display_name": "scikit_mol_cedenoruel", + "display_name": "scikit_mol", "language": "python", "name": "python3" }, @@ -1707,7 +1083,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.2" + "version": "3.13.4" } }, "nbformat": 4, From a036b9f81d30d54272090032db94731bb7da1168 Mon Sep 17 00:00:00 2001 From: batukav Date: Thu, 10 Jul 2025 17:27:40 +0200 Subject: [PATCH 06/17] Initial commit for the refactored MurckoScaffoldSplit transformer --- scikit_mol/conversions.py | 179 ++++++++++++++++++++++++++++---------- 1 file changed, 131 insertions(+), 48 deletions(-) diff --git a/scikit_mol/conversions.py b/scikit_mol/conversions.py index ee3cd32..b5eee73 100644 --- a/scikit_mol/conversions.py +++ b/scikit_mol/conversions.py @@ -1,6 +1,6 @@ from collections.abc import Sequence from typing import Optional, Union -from types import ModuleType +from abc import ABC, abstractmethod import rdkit import numpy as np @@ -132,69 +132,152 @@ def inverse_transform(self, X_mols_list, y=None): return np.array(X_out).reshape(-1, 1) +class BaseScaffoldGenerator(BaseEstimator, ABC): + """ + Abstract base class for scaffold generators. + Inherits from scikit-learn's BaseEstimator to allow for + integration into pipelines and hyperparameter tuning. + """ + + @abstractmethod + def get_scaffold(self, mol: Chem.Mol) -> Chem.Mol: + """ + Generates a scaffold for a given RDKit molecule. + Parameters + ---------- + mol : Chem.Mol + The input molecule. + Returns + ------- + Chem.Mol + The resulting scaffold molecule. Can be None if generation fails. + """ + raise NotImplementedError + + +class MurckoScaffoldGenerator(BaseScaffoldGenerator): + """ + Generates Murcko scaffolds for molecules. + This class encapsulates the logic for RDKit's Murcko scaffold + functionality and serves as a concrete implementation of the + BaseScaffoldGenerator. + Parameters + ---------- + include_chirality : bool, default=False + Whether to include chirality in the scaffold. This is passed to + `MurckoScaffold.MurckoScaffoldSmiles`. + make_generic : bool, default=False + Whether to convert the scaffold to a generic representation + (all atoms become carbons, all bonds become single). + """ + + def __init__(self, include_chirality: bool = False, make_generic: bool = False): + self.include_chirality = include_chirality + self.make_generic = make_generic + + def get_scaffold(self, mol: Chem.Mol) -> Chem.Mol: + """Generates a Murcko scaffold for the input molecule.""" + # We always use MurckoScaffoldSmiles to have explicit control over chirality. + scaffold_smiles = MurckoScaffold.MurckoScaffoldSmiles( + mol=mol, includeChirality=self.include_chirality + ) + + # An empty SMILES string is returned for acyclic molecules. + # Chem.MolFromSmiles("") returns None, which is the desired output for these cases. + scaffold_mol = Chem.MolFromSmiles(scaffold_smiles) if scaffold_smiles else None + + if self.make_generic and scaffold_mol: + scaffold_mol = MurckoScaffold.MakeScaffoldGeneric(scaffold_mol) + + return scaffold_mol + + class MolToScaffoldTransformer(SmilesToMolTransformer): """ - Transformer for converting SMILES strings to molecular scaffolds. - First converts SMILES to RDKit mol objects, then extracts the scaffold. + Transformer for converting RDKit Mol objects to molecular scaffolds. + This transformer assumes the input is already a sequence of Mol objects. """ def __init__( self, - n_jobs: Optional[None] = None, + scaffold_generator: Optional[BaseScaffoldGenerator] = None, + n_jobs: Optional[int] = None, safe_inference_mode: bool = False, - scaffold_transformer: ModuleType = MurckoScaffold, ): - super().__init__(n_jobs, safe_inference_mode) - self.scaffold_transformer = scaffold_transformer - - # Question: How generic should be the scaffold transformer? - # For now, just for demonstration I'm using the MurckoScaffold class + """ + Parameters + ---------- + scaffold_generator : object, optional + An object with a `get_scaffold(mol)` method that returns an RDKit Mol object. + If None, a default `MurckoScaffoldGenerator()` is used. + n_jobs : int, optional + The maximum number of concurrently running jobs. + `None` is a marker for 'unset' that will be interpreted as `n_jobs=1` + unless the call is performed under a `parallel_config()` context manager + that sets another value for `n_jobs`. + safe_inference_mode : bool, default=False + If `True`, enables safeguards for handling invalid data during inference. + This should only be set to `True` when deploying models to production. + """ + # Call the parent's __init__ to handle shared parameters like n_jobs + # and safe_inference_mode. + super().__init__( + n_jobs=n_jobs, safe_inference_mode=safe_inference_mode + ) + + if scaffold_generator is None: + self.scaffold_generator = MurckoScaffoldGenerator() + else: + if not isinstance(scaffold_generator, BaseScaffoldGenerator): + raise TypeError( + "scaffold_generator must be an instance of BaseScaffoldGenerator." + ) + self.scaffold_generator = scaffold_generator def transform( - self, X_smiles_list: Sequence[str] + self, X_mols_list: Sequence[Union[Chem.Mol, InvalidMol]], y=None ) -> NDArray[Union[Chem.Mol, InvalidMol]]: - # First step: convert SMILES to molecules using parent class - mols = super().transform(X_smiles_list, y=None).flatten() - - self.mols = mols # to be deleted - # Second step: convert molecules to scaffolds - scaffolds = ( - [] - ) # TODO: this will be very slow for large datasets, improve efficiency via initializing list + """ + Converts RDKit Mol objects into molecular scaffolds. + Parameters + ---------- + X_mols_list : Sequence[Union[Chem.Mol, InvalidMol]] + A sequence of RDKit Mol objects or InvalidMol objects. + Returns + ------- + NDArray[Union[Chem.Mol, InvalidMol]] + An array of scaffold molecules or InvalidMol objects. + """ + # The input is expected to be a list/array of Mol objects. + # We flatten the input in case it's a 2D array from a previous transformer. + mols = np.array(X_mols_list).flatten() + + # Parallelize the scaffold generation for efficiency + scaffold_arrays = parallelized_with_batches( + self._scaffold_transform, mols, self.n_jobs + ) + scaffolds = np.concatenate(scaffold_arrays) + + return scaffolds.reshape(-1, 1) + + def _scaffold_transform(self, mols: Sequence[Union[Chem.Mol, InvalidMol]]): + scaffolds = [] for mol in mols: if isinstance(mol, Chem.Mol): try: - scaffold = self.scaffold_transformer.GetScaffoldForMol(mol) - scaffolds.append(scaffold) + scaffold = self.scaffold_generator.get_scaffold(mol) + if scaffold is None: + # If scaffold generation results in None (e.g., for acyclic molecules), + # we create an InvalidMol object to signify this. + scaffolds.append( + InvalidMol(str(self), "Scaffold generation resulted in an empty molecule.") + ) + else: + scaffolds.append(scaffold) except Exception as e: scaffolds.append( InvalidMol(str(self), f"Error creating scaffold: {e}") ) else: - scaffolds.append(mol) # Keep InvalidMol objects as is - - self.scaffolds = np.array(scaffolds).reshape(-1, 1).flatten() - return np.array(scaffolds).reshape(-1, 1) - - def get_unique_scaffold_ids(self) -> NDArray[np.int_]: - - scaffold_smiles = self._create_smiles_from_mol() - # Get unique labels - _, labels = np.unique(scaffold_smiles, return_inverse=True) - - return labels - - def _create_smiles_from_mol(self): - - if type(self.scaffolds) == rdkit.Chem.rdchem.Mol: - return Chem.MolToSmiles(self.scaffolds) - elif type(self.scaffolds) == np.ndarray: - scaffold_smiles = [] - for scaffold in self.scaffolds: - scaffold_smiles.append(Chem.MolToSmiles(scaffold)) - - return scaffold_smiles - else: - raise RuntimeError("Unknown data type ") - # Keep scaffold_smiles ?? - # self.scaffold_smiles = scaffold_smiles + scaffolds.append(mol) # Pass through InvalidMol objects + return np.array(scaffolds) \ No newline at end of file From fc39e49e637999e6048b3ecb77d6a42d0e65ef16 Mon Sep 17 00:00:00 2001 From: batukav Date: Thu, 10 Jul 2025 17:29:21 +0200 Subject: [PATCH 07/17] Initial tests for the MolToScaffoldTransformer with Mucko scaffold as the default. These tests will need to be extended as more scaffolds transformations are implemented. --- tests/test_conversions.py | 181 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 181 insertions(+) create mode 100644 tests/test_conversions.py diff --git a/tests/test_conversions.py b/tests/test_conversions.py new file mode 100644 index 0000000..8bacedc --- /dev/null +++ b/tests/test_conversions.py @@ -0,0 +1,181 @@ +""" +Tests for the scaffold generator classes in scikit_mol.conversions. +""" + +import pytest +from rdkit import Chem +from sklearn.base import clone +from sklearn.pipeline import Pipeline + +from scikit_mol.conversions import ( + MurckoScaffoldGenerator, + MolToScaffoldTransformer, + SmilesToMolTransformer, +) + +# A selection of SMILES strings for testing +MURCKO_TEST_CASES = { + # Aspirin: simple case with a benzene ring and two side chains + "CC(=O)OC1=CC=CC=C1C(=O)O": "c1ccccc1", + # Ibuprofen: another common drug example + "CC(C)CC1=CC=C(C=C1)C(C)C(=O)O": "c1ccccc1", + # Atorvastatin (Lipitor): complex molecule with multiple rings. + # The expected scaffold is the result from RDKit's MurckoScaffold. + "CC(C)C1=C(C(=C(N1C2=CC=C(C=C2)F)C3=CC=CC=C3)C(=O)NC4=CC=C(C=C4)F)C(O)CC(O)CC(=O)O": "O=C(Nc1ccccc1)c1ccn(-c2ccccc2)c1-c1ccccc1", + # A molecule with no rings, should result in an empty scaffold + "CCO": "", + # A molecule with a chiral center but no rings, should also be empty + "C[C@H](O)C(=O)O": "", # Lactic acid +} + + +@pytest.fixture +def murcko_generator(): + """Provides a default MurckoScaffoldGenerator instance.""" + return MurckoScaffoldGenerator() + + +def test_murcko_generator_initialization(): + """ + Tests that the MurckoScaffoldGenerator initializes correctly and that + its parameters are stored as public attributes, which is a requirement + for scikit-learn compatibility. + """ + generator = MurckoScaffoldGenerator(include_chirality=True, make_generic=True) + assert generator.include_chirality + assert generator.make_generic + + +def test_murcko_scaffold_generation(murcko_generator): + """ + Tests the basic scaffold generation for a set of common molecules. + This test ensures that the core functionality of converting a molecule + to its Murcko scaffold is working as expected. + """ + for smiles, expected_scaffold_smiles in MURCKO_TEST_CASES.items(): + mol = Chem.MolFromSmiles(smiles) + scaffold = murcko_generator.get_scaffold(mol) + + # For molecules without rings, the scaffold should be '' + if not expected_scaffold_smiles: + assert scaffold is None, f"Scaffold should be empty for {smiles}" + continue + + assert scaffold is not None, f"Scaffold generation failed for {smiles}" + # Compare the SMILES representation of the generated scaffold to the expected one + scaffold_smiles = Chem.MolToSmiles(scaffold) + assert scaffold_smiles == expected_scaffold_smiles, f"Incorrect scaffold for {smiles}" + + +def test_murcko_chirality_option(): + """ + Tests the `include_chirality` parameter of the MurckoScaffoldGenerator. + When this option is enabled, the scaffold should preserve the stereochemistry + of the original molecule. This test uses a molecule with a chiral ring, + as Murcko scaffolds are only generated for cyclic systems. + """ + # A chiral molecule with a ring system + chiral_smiles = "C1CC[C@H]2CCCC[C@H]2C1" + mol = Chem.MolFromSmiles(chiral_smiles) + assert mol is not None, "Failed to create molecule from SMILES" + + # Test with chirality disabled (default) + generator_no_chirality = MurckoScaffoldGenerator(include_chirality=False) + scaffold_no_chirality = generator_no_chirality.get_scaffold(mol) + assert scaffold_no_chirality is not None, "Scaffold should not be None" + assert "@" not in Chem.MolToSmiles( + scaffold_no_chirality + ), "Scaffold should not have chiral centers" + + # Test with chirality enabled + generator_with_chirality = MurckoScaffoldGenerator(include_chirality=True) + scaffold_with_chirality = generator_with_chirality.get_scaffold(mol) + assert scaffold_with_chirality is not None, "Chiral scaffold should not be None" + assert "@" in Chem.MolToSmiles( + scaffold_with_chirality + ), "Scaffold should have chiral centers" + + +def test_murcko_generic_option(): + """ + Tests the `make_generic` parameter of the MurckoScaffoldGenerator. + When this option is enabled, all atoms in the scaffold are converted to + carbon and all bonds to single bonds, providing a generic framework. + """ + smiles = "CC1=CC=C(C=C1)C(C)C(=O)O" # Ibuprofen + mol = Chem.MolFromSmiles(smiles) + generator = MurckoScaffoldGenerator(make_generic=True) + scaffold = generator.get_scaffold(mol) + + assert scaffold is not None, "Scaffold generation failed" + # Check that all atoms in the generic scaffold are carbons (atomic number 6) + for atom in scaffold.GetAtoms(): + assert atom.GetAtomicNum() == 6, "All atoms should be carbon in a generic scaffold" + # Check that all bonds are single bonds + for bond in scaffold.GetBonds(): + assert ( + bond.GetBondType() == Chem.rdchem.BondType.SINGLE + ), "All bonds should be single in a generic scaffold" + + +def test_mol_to_scaffold_transformer_integration(): + """ + Tests the integration of MurckoScaffoldGenerator with MolToScaffoldTransformer + within a scikit-learn Pipeline. This ensures the transformers correctly chain + together, with the second transformer operating on the output of the first. + """ + smiles_list = list(MURCKO_TEST_CASES.keys()) + + # Define the pipeline + pipeline = Pipeline([ + ('smiles_to_mol', SmilesToMolTransformer()), + ('mol_to_scaffold', MolToScaffoldTransformer( + scaffold_generator=MurckoScaffoldGenerator() + )) + ]) + + # Transform the data through the pipeline + scaffolds = pipeline.transform(smiles_list) + + assert len(scaffolds) == len( + smiles_list + ), "Pipeline should output one scaffold per input SMILES" + + # Check the output for a known case (Aspirin) + aspirin_scaffold = scaffolds[0][0] + assert isinstance(aspirin_scaffold, Chem.Mol), "Output should be an RDKit Mol object" + assert Chem.MolToSmiles(aspirin_scaffold) == "c1ccccc1", "Incorrect scaffold for Aspirin" + + # Check the output for an acyclic case (Ethanol) + # The scaffold should be an InvalidMol object as per the transformer's logic + from scikit_mol.core import InvalidMol + ethanol_scaffold = scaffolds[3][0] + assert isinstance(ethanol_scaffold, InvalidMol), "Acyclic molecules should produce an InvalidMol object" + + +def test_scikit_learn_compatibility(): + """ + Verifies that the MurckoScaffoldGenerator is compatible with scikit-learn's + `clone` function and can be used in a Pipeline. This is essential for + hyperparameter tuning and other advanced scikit-learn workflows. + """ + generator = MurckoScaffoldGenerator(include_chirality=True) + # Test that the generator can be cloned + cloned_generator = clone(generator) + assert cloned_generator.include_chirality == generator.include_chirality + assert cloned_generator is not generator, "Cloned object should be a new instance" + + # Test that the generator can be used in a scikit-learn Pipeline + pipeline = Pipeline( + [ + ("smiles_to_mol", SmilesToMolTransformer()), + ( + "mol_to_scaffold", + MolToScaffoldTransformer(scaffold_generator=generator), + ), + ] + ) + # Cloning the pipeline should also work seamlessly + cloned_pipeline = clone(pipeline) + assert cloned_pipeline.steps[1][1].scaffold_generator.include_chirality + From 504a31aa786d58276146db388d2ecb193b1e9b8a Mon Sep 17 00:00:00 2001 From: batukav Date: Thu, 10 Jul 2025 17:29:49 +0200 Subject: [PATCH 08/17] Initial commit for the StratifiedGroupShuffleSplit --- scikit_mol/splitter.py | 210 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 210 insertions(+) create mode 100644 scikit_mol/splitter.py diff --git a/scikit_mol/splitter.py b/scikit_mol/splitter.py new file mode 100644 index 0000000..1836861 --- /dev/null +++ b/scikit_mol/splitter.py @@ -0,0 +1,210 @@ +import numpy as np +import matplotlib.pyplot as plt +import time +import warnings +import pandas as pd +from collections import defaultdict +from typing import Union, List +from sklearn.model_selection._split import BaseShuffleSplit +from sklearn.utils.validation import _num_samples +from sklearn.utils import check_random_state + + +class StratifiedGroupShuffleSplit(BaseShuffleSplit): + """Stratified ShuffleSplit cross-validator with non-overlapping groups.""" + + def __init__( + self, + n_splits: int = 5, + *, + test_size: float or int = 0.2, + train_size: float or int=None, + random_state: int = None, + sample_weighted: bool = False, + suppress_warnings: bool = False + ): + super().__init__( + n_splits=n_splits, + test_size=test_size, + train_size=train_size, + random_state=random_state, + ) + self.sample_weighted = sample_weighted + self.suppress_warnings = suppress_warnings + + if not suppress_warnings: + if self.sample_weighted: + warnings.warn( + f"sample_weighted = True. During the test split, groups with more samples will be prioritized", + UserWarning, + ) + + def _iter_indices(self, X: Union[List, np.ndarray, pd.Series], y: Union[List, np.ndarray, pd.Series], groups: Union[List, np.ndarray, pd.Series]): + + if y is None: + raise ValueError( + "StratifiedGroupShuffleSplit requires 'y' for stratification." + ) + + if groups is None: + raise ValueError( + "StratifiedGroupShuffleSplit requires 'groups' to be defined." + ) + n_samples = _num_samples(X) + + if isinstance(self.test_size, float): + n_test = int(self.test_size * n_samples) + else: + n_test = int(self.test_size) + + unique_groups, group_indices = np.unique(groups, return_inverse=True) + group_counts = np.bincount(groups) + self._check_split_viability(n_test, unique_groups, group_counts) + n_groups = len(unique_groups) + classes, y_indices = np.unique(y, return_inverse=True) + n_classes = len(classes) + overall_class_counts = np.bincount(y_indices, minlength=n_classes) + + group_info = defaultdict( + lambda: { + "class_counts": np.zeros(n_classes, dtype=int), + "indices": [], + "size": 0, + } + ) + for i, group_idx in enumerate(group_indices): + class_idx = y_indices[i] + group_info[group_idx]["class_counts"][class_idx] += 1 + group_info[group_idx]["indices"].append(i) + for i in range(n_groups): + group_info[i]["size"] = len(group_info[i]["indices"]) + + rng = check_random_state(self.random_state) + + for _ in range(self.n_splits): + available_groups = list(range(n_groups)) + test_groups = [] + + current_test_size = 0 + current_test_counts = np.zeros(n_classes, dtype=int) + + # Phase 1: Greedily add only "safe" groups that do not exceed n_test + while available_groups: + safe_candidates = [] + for group_idx in available_groups: + group_data = group_info[group_idx] + if current_test_size + group_data["size"] <= n_test: + prospective_counts = ( + current_test_counts + group_data["class_counts"] + ) + prospective_size = current_test_size + group_data["size"] + ideal_counts = overall_class_counts * ( + prospective_size / n_samples + ) + error = np.sum((prospective_counts - ideal_counts) ** 2) + safe_candidates.append({"error": error, "id": group_idx}) + + if not safe_candidates: + # No more groups can be added without overshooting + break + + safe_candidates.sort(key=lambda x: x["error"]) + pool_size = min(5, len(safe_candidates)) + candidate_pool = [cand["id"] for cand in safe_candidates[:pool_size]] + best_group = rng.choice(candidate_pool, self.sample_weighted) + + test_groups.append(best_group) + available_groups.remove(best_group) + group_data = group_info[best_group] + current_test_counts += group_data["class_counts"] + current_test_size += group_data["size"] + + # Phase 2: Decide if a single overshoot is better than the current undershoot + if available_groups and current_test_size < n_test: + overshoot_candidates = [] + for group_idx in available_groups: + group_data = group_info[group_idx] + prospective_size = current_test_size + group_data["size"] + # We only care about the size difference now + overshoot_candidates.append( + {"id": group_idx, "size": prospective_size} + ) + + if overshoot_candidates: + # Find the group that causes the smallest overshoot + overshoot_candidates.sort(key=lambda x: x["size"]) + best_overshoot_group = overshoot_candidates[0] + + undershoot_error = n_test - current_test_size + overshoot_error = best_overshoot_group["size"] - n_test + + if overshoot_error < undershoot_error: + # If overshooting is closer to the target, add the group + test_groups.append(best_overshoot_group["id"]) + + test_indices = ( + np.concatenate([group_info[g_idx]["indices"] for g_idx in test_groups]) + if test_groups + else [] + ) + all_indices = np.arange(n_samples) + train_indices = np.setdiff1d(all_indices, test_indices, assume_unique=True) + + if isinstance(self.test_size, float): + + requested_test_size_ratio = self.test_size + else: + requested_test_size_ratio = self.test_size / n_samples + + test_size_error = np.abs(len(test_indices)/n_samples - requested_test_size_ratio) + + if not self.suppress_warnings: + if test_size_error > 0.05: # 5% deviation + warnings.warn(f"Requested and calculated test sizes differ by {test_size_error*100:.2f}%") + + yield train_indices, test_indices + + def split(self, X, y, groups=None): + """Generates indices to split data into training and test set. + + Parameters + ---------- + X : array-like of shape (n_samples, n_features) + Training data, where `n_samples` is the number of samples + and `n_features` is the number of features. + + y : array-like of shape (n_samples,), optional + The target variable for supervised learning problems. + Stratification is done based on the y labels. + + groups : array-like of shape (n_samples,), optional + Group labels for the samples used while splitting the dataset into + train/test set. Each group will be kept together in either the + train set or the test set. + + Yields + ------ + train : ndarray + The training set indices for that split. + + test : ndarray + The testing set indices for that split. + """ + yield from self._iter_indices(X, y, groups) + + def get_n_splits(self): + return self.n_splits + + def _check_split_viability(self, n_test, unique_groups, group_counts): + too_large_groups = {} + for group_id, group_count in zip(unique_groups, group_counts): + if group_count >= n_test: + too_large_groups[group_id] = group_count + if len(too_large_groups) > 0 and not self.suppress_warnings: + warnings.warn( + f""" + Some groups are too large for the test set and will never be present in the test set: {too_large_groups}.\n + If you want a group to be able to be present in the test set, test_size >= group_size. + """, + UserWarning, + ) From 6f99382a2f731713dd74ca5f464daead60027a44 Mon Sep 17 00:00:00 2001 From: batukav Date: Tue, 15 Jul 2025 16:16:43 +0200 Subject: [PATCH 09/17] Correctly handle the case of sample_weighted. --- scikit_mol/splitter.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/scikit_mol/splitter.py b/scikit_mol/splitter.py index 1836861..1bbf356 100644 --- a/scikit_mol/splitter.py +++ b/scikit_mol/splitter.py @@ -111,7 +111,11 @@ def _iter_indices(self, X: Union[List, np.ndarray, pd.Series], y: Union[List, np safe_candidates.sort(key=lambda x: x["error"]) pool_size = min(5, len(safe_candidates)) candidate_pool = [cand["id"] for cand in safe_candidates[:pool_size]] - best_group = rng.choice(candidate_pool, self.sample_weighted) + if self.sample_weighted: + weights = [group_info[group_idx]["size"] for group_idx in candidate_pool] + best_group = rng.choice(candidate_pool, p=weights) + else: + best_group = rng.choice(candidate_pool) test_groups.append(best_group) available_groups.remove(best_group) From 63f0d0d127fe769232cbc30946fbc85940189b19 Mon Sep 17 00:00:00 2001 From: batukav Date: Tue, 15 Jul 2025 16:19:04 +0200 Subject: [PATCH 10/17] In case of an overshoot, choose randomly from the overshoot candidates. This can be changed later to include a weighted random choice. --- scikit_mol/splitter.py | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/scikit_mol/splitter.py b/scikit_mol/splitter.py index 1bbf356..0baa64e 100644 --- a/scikit_mol/splitter.py +++ b/scikit_mol/splitter.py @@ -142,9 +142,16 @@ def _iter_indices(self, X: Union[List, np.ndarray, pd.Series], y: Union[List, np undershoot_error = n_test - current_test_size overshoot_error = best_overshoot_group["size"] - n_test - if overshoot_error < undershoot_error: - # If overshooting is closer to the target, add the group - test_groups.append(best_overshoot_group["id"]) + valid_overshoot_candidates = [] + for cand in overshoot_candidates: + overshoot_error = cand["size"] - n_test + if overshoot_error < undershoot_error: + valid_overshoot_candidates.append(cand["id"]) + + if valid_overshoot_candidates: + # Randomly choose from the valid overshooting groups + best_overshoot_group_id = rng.choice(valid_overshoot_candidates) + test_groups.append(best_overshoot_group_id) test_indices = ( np.concatenate([group_info[g_idx]["indices"] for g_idx in test_groups]) From 046698b4361d8c759058d6ca59a1876602bf9219 Mon Sep 17 00:00:00 2001 From: batukav Date: Tue, 15 Jul 2025 16:19:21 +0200 Subject: [PATCH 11/17] if no train/test split is found, raise RuntimeError --- scikit_mol/splitter.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/scikit_mol/splitter.py b/scikit_mol/splitter.py index 0baa64e..57d1863 100644 --- a/scikit_mol/splitter.py +++ b/scikit_mol/splitter.py @@ -158,6 +158,8 @@ def _iter_indices(self, X: Union[List, np.ndarray, pd.Series], y: Union[List, np if test_groups else [] ) + if len(test_indices) == 0: + raise RuntimeError(f"Given the dataset, no train/test split could be found. Try increasing test_size") all_indices = np.arange(n_samples) train_indices = np.setdiff1d(all_indices, test_indices, assume_unique=True) From 0bcd1e227ed440f8fffffc0849391e89cd49e333 Mon Sep 17 00:00:00 2001 From: batukav Date: Tue, 15 Jul 2025 16:21:03 +0200 Subject: [PATCH 12/17] Improve warning handling of the _check_split_viability. --- scikit_mol/splitter.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/scikit_mol/splitter.py b/scikit_mol/splitter.py index 57d1863..620f188 100644 --- a/scikit_mol/splitter.py +++ b/scikit_mol/splitter.py @@ -210,10 +210,12 @@ def get_n_splits(self): def _check_split_viability(self, n_test, unique_groups, group_counts): too_large_groups = {} + n_groups = 0 for group_id, group_count in zip(unique_groups, group_counts): if group_count >= n_test: + n_groups += 1 too_large_groups[group_id] = group_count - if len(too_large_groups) > 0 and not self.suppress_warnings: + if len(too_large_groups) > 0 and not self.suppress_warnings and n_groups < len(unique_groups): warnings.warn( f""" Some groups are too large for the test set and will never be present in the test set: {too_large_groups}.\n @@ -221,3 +223,13 @@ def _check_split_viability(self, n_test, unique_groups, group_counts): """, UserWarning, ) + elif len(too_large_groups) > 0 and not self.suppress_warnings and n_groups == len(unique_groups): + warnings.warn( + """ + "Warning: All available groups are larger than the target test size. + The algorithm will still try to select a group that overshoots the target, + which may lead to a larger than requested test set, or an completely empty test set." + """, + UserWarning, + ) + From 1dba91a81b077c8ec442fe8869935203bacd838b Mon Sep 17 00:00:00 2001 From: batukav Date: Fri, 18 Jul 2025 15:06:38 +0200 Subject: [PATCH 13/17] format warning message f-string --- scikit_mol/splitter.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/scikit_mol/splitter.py b/scikit_mol/splitter.py index 620f188..92c0c53 100644 --- a/scikit_mol/splitter.py +++ b/scikit_mol/splitter.py @@ -217,19 +217,19 @@ def _check_split_viability(self, n_test, unique_groups, group_counts): too_large_groups[group_id] = group_count if len(too_large_groups) > 0 and not self.suppress_warnings and n_groups < len(unique_groups): warnings.warn( - f""" + f''' Some groups are too large for the test set and will never be present in the test set: {too_large_groups}.\n If you want a group to be able to be present in the test set, test_size >= group_size. - """, + ''', UserWarning, ) elif len(too_large_groups) > 0 and not self.suppress_warnings and n_groups == len(unique_groups): warnings.warn( - """ + ''' "Warning: All available groups are larger than the target test size. The algorithm will still try to select a group that overshoots the target, which may lead to a larger than requested test set, or an completely empty test set." - """, + ''', UserWarning, ) From da55256891077588740cb07f2730664bf4ebdf8a Mon Sep 17 00:00:00 2001 From: batukav Date: Fri, 18 Jul 2025 15:12:28 +0200 Subject: [PATCH 14/17] Add train_test_group_split function that splits the arrays or matrices into random train and test subset while respecting group ids. Intended to extend the scikit-learn train_test_split function to the groups. --- scikit_mol/splitter.py | 115 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 114 insertions(+), 1 deletion(-) diff --git a/scikit_mol/splitter.py b/scikit_mol/splitter.py index 92c0c53..9670321 100644 --- a/scikit_mol/splitter.py +++ b/scikit_mol/splitter.py @@ -5,9 +5,13 @@ import pandas as pd from collections import defaultdict from typing import Union, List -from sklearn.model_selection._split import BaseShuffleSplit +from sklearn.model_selection._split import BaseShuffleSplit, _validate_shuffle_split from sklearn.utils.validation import _num_samples from sklearn.utils import check_random_state +from sklearn.utils import indexable +from sklearn.utils._array_api import ensure_common_namespace_device +from itertools import chain +from sklearn.utils import _safe_indexing class StratifiedGroupShuffleSplit(BaseShuffleSplit): @@ -233,3 +237,112 @@ def _check_split_viability(self, n_test, unique_groups, group_counts): UserWarning, ) + +def train_test_group_split( + *arrays, + test_size=None, + train_size=None, + random_state=None, + shuffle=True, + stratify=None, +): + """Split arrays or matrices into random train and test subsets, while respecting group boundaries. + + Quick utility that wraps input validation and a Group-aware ShuffleSplit + into a single call for splitting (and optionally subsampling) data in a + one-liner. + + The last passed array is assumed to be the 'groups' array. + + Read more in the :ref:`User Guide `. + + Parameters + ---------- + *arrays : sequence of indexables with same length / shape[0] + Allowed inputs are lists, numpy arrays, scipy-sparse + matrices or pandas dataframes. The last array must be the `groups` + array. + + test_size : float or int, default=None + If float, should be between 0.0 and 1.0 and represent the proportion + of the dataset to include in the test split. If int, represents the + absolute number of test samples. If None, the value is set to the + complement of the train size. If ``train_size`` is also None, it will + be set to 0.25. + + train_size : float or int, default=None + If float, should be between 0.0 and 1.0 and represent the + proportion of the dataset to include in the train split. If + int, represents the absolute number of train samples. If None, + the value is automatically set to the complement of the test size. + + random_state : int, RandomState instance or None, default=None + Controls the shuffling applied to the data before applying the split. + Pass an int for reproducible output across multiple function calls. + See :term:`Glossary `. + + shuffle : bool, default=True + Whether or not to shuffle the data before splitting. For group-based + splitting, shuffling is always performed on the groups. If shuffle=False, + a ValueError will be raised. + + stratify : array-like or bool, default=None + If not None, data is split in a stratified fashion, using this as + the class labels. If True, it will use the second to last array as + stratification labels. + Read more in the :ref:`User Guide `. + + Returns + ------- + splitting : list, length=2 * len(arrays) + List containing train-test split of inputs. + """ + n_arrays = len(arrays) + if n_arrays < 2: + raise ValueError( + "At least two arrays are required as input (e.g., X, groups)." + ) + + arrays = indexable(*arrays) + groups = arrays[-1] + + n_samples = _num_samples(arrays[0]) + n_train, n_test = _validate_shuffle_split( + n_samples, test_size, train_size, default_test_size=0.25 + ) + + if not shuffle: + raise ValueError( + "shuffle=False is not supported for train_test_group_split. " + "Group-based splitting always shuffles the groups." + ) + + y_for_split = None + if stratify is not None: + if isinstance(stratify, bool): + if stratify: # stratify=True + if n_arrays < 3: + raise ValueError( + "When stratify=True, at least three arrays are required as input (e.g., X, y, groups)." + ) + y_for_split = arrays[-2] + CVClass = StratifiedGroupShuffleSplit + else: # stratify=False + CVClass = GroupShuffleSplit + else: # stratify is an array + y_for_split = stratify + CVClass = StratifiedGroupShuffleSplit + else: # stratify is None + CVClass = GroupShuffleSplit + + cv = CVClass(n_splits=1, test_size=n_test, train_size=n_train, random_state=random_state) + + train, test = next(cv.split(X=arrays[0], y=y_for_split, groups=groups)) + + train, test = ensure_common_namespace_device(arrays[0], train, test) + + return list( + chain.from_iterable( + (_safe_indexing(a, train), _safe_indexing(a, test)) for a in arrays + ) + ) From aabc5a68d0b9f369bc21de89d0305d6eb2ff54bc Mon Sep 17 00:00:00 2001 From: batukav Date: Fri, 18 Jul 2025 15:12:58 +0200 Subject: [PATCH 15/17] Add GroupSplitCV cross-validator that performs group-aware splits. --- scikit_mol/splitter.py | 89 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 89 insertions(+) diff --git a/scikit_mol/splitter.py b/scikit_mol/splitter.py index 9670321..8f5e10b 100644 --- a/scikit_mol/splitter.py +++ b/scikit_mol/splitter.py @@ -8,6 +8,7 @@ from sklearn.model_selection._split import BaseShuffleSplit, _validate_shuffle_split from sklearn.utils.validation import _num_samples from sklearn.utils import check_random_state +from sklearn.model_selection import GroupShuffleSplit from sklearn.utils import indexable from sklearn.utils._array_api import ensure_common_namespace_device from itertools import chain @@ -346,3 +347,91 @@ def train_test_group_split( (_safe_indexing(a, train), _safe_indexing(a, test)) for a in arrays ) ) + + +class GroupSplitCV: + """Cross-validator that performs group-aware splits. + + This cross-validator is a wrapper around StratifiedGroupShuffleSplit and + GroupShuffleSplit to be used in scikit-learn's GridSearchCV and other + similar utilities. + + Parameters + ---------- + n_splits : int, default=5 + Number of re-shuffling & splitting iterations. + + test_size : float or int, default=0.2 + If float, should be between 0.0 and 1.0 and represent the proportion + of the dataset to include in the test split. If int, represents the + absolute number of test samples. + + train_size : float or int, default=None + If float, should be between 0.0 and 1.0 and represent the + proportion of the dataset to include in the train split. If + int, represents the absolute number of train samples. If None, + the value is automatically set to the complement of the test size. + + random_state : int, RandomState instance or None, default=None + Controls the randomness of the training and testing indices produced. + Pass an int for reproducible output across multiple function calls. + + stratify : bool, default=False + Whether to perform stratified sampling. If True, the `y` parameter + in the `split` method is used for stratification. + """ + def __init__(self, n_splits=5, *, test_size=0.2, train_size=None, random_state=None, stratify=False): + self.n_splits = n_splits + self.test_size = test_size + self.train_size = train_size + self.random_state = random_state + self.stratify = stratify + + def split(self, X, y=None, groups=None): + """ + Generate indices to split data into training and test set. + + Parameters + ---------- + X : array-like of shape (n_samples, n_features) + Training data, where n_samples is the number of samples + and n_features is the number of features. + + y : array-like of shape (n_samples,), default=None + The target variable for supervised learning problems. + Stratification is done based on the y labels if `stratify=True`. + + groups : array-like of shape (n_samples,) + Group labels for the samples used while splitting the dataset into + train/test set. + + Yields + ------ + train : ndarray + The training set indices for that split. + + test : ndarray + The testing set indices for that split. + """ + if self.stratify: + if y is None: + raise ValueError("The 'y' parameter should not be None when stratify=True.") + cv = StratifiedGroupShuffleSplit( + n_splits=self.n_splits, + test_size=self.test_size, + train_size=self.train_size, + random_state=self.random_state, + ) + yield from cv.split(X, y, groups=groups) + else: + cv = GroupShuffleSplit( + n_splits=self.n_splits, + test_size=self.test_size, + train_size=self.train_size, + random_state=self.random_state, + ) + yield from cv.split(X, y=y, groups=groups) + + def get_n_splits(self, X=None, y=None, groups=None): + """Returns the number of splitting iterations in the cross-validator.""" + return self.n_splits \ No newline at end of file From 12ba1b92a92a1174b8fd6b9dfda1f05a06cb43cc Mon Sep 17 00:00:00 2001 From: batukav Date: Fri, 18 Jul 2025 15:43:08 +0200 Subject: [PATCH 16/17] update the notebook to showcase the recently added functionalities --- ...upShuffleSplit_and_MurckoTransformer.ipynb | 1880 +++++++++++++++++ 1 file changed, 1880 insertions(+) create mode 100644 scikit_mol/notebooks/StratifiedGroupShuffleSplit_and_MurckoTransformer.ipynb diff --git a/scikit_mol/notebooks/StratifiedGroupShuffleSplit_and_MurckoTransformer.ipynb b/scikit_mol/notebooks/StratifiedGroupShuffleSplit_and_MurckoTransformer.ipynb new file mode 100644 index 0000000..1e81cb3 --- /dev/null +++ b/scikit_mol/notebooks/StratifiedGroupShuffleSplit_and_MurckoTransformer.ipynb @@ -0,0 +1,1880 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# import the usual suspects\n", + "import os\n", + "import rdkit\n", + "from rdkit import Chem\n", + "import pandas as pd\n", + "from time import time\n", + "import numpy as np\n", + "import sys\n", + "sys.path.append('..')\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## import dataset ##" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "full_set = True\n", + "\n", + "if full_set:\n", + " csv_file = \"../../tests/data/SLC6A4_active_excape_export.csv\"\n", + " if not os.path.exists(csv_file):\n", + " import urllib.request\n", + "\n", + " url = \"https://ndownloader.figshare.com/files/25747817\"\n", + " urllib.request.urlretrieve(url, csv_file)\n", + "else:\n", + " csv_file = \"../../tests/data/SLC6A4_active_excapedb_subset.csv\"\n", + "\n", + "data = pd.read_csv(csv_file) " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "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", + "
Ambit_InchiKeyOriginal_Entry_IDEntrez_IDActivity_FlagpXC50DBOriginal_Assay_IDTax_IDGene_SymbolOrtholog_GroupSMILES
0AZMKBJHIXZCVNL-BXKDBHETNA-N445906436532A5.68382pubchem3932609606SLC6A44061FC1=CC([C@@H]2O[C@H](CC2)CN)=C(OC)C=C1
1AZMKBJHIXZCVNL-UHFFFAOYNA-N114923056532A5.16210pubchem3932589606SLC6A44061FC1=CC(C2OC(CC2)CN)=C(OC)C=C1
2AZOHUEDNMOIDOC-GETDIYNLNA-N444193406532A6.66354pubchem2760599606SLC6A44061FC1=CC=C(C[C@H]2C[C@@H](N(CC2)CC=C)CCCNC(=O)NC...
3AZSKJKSQZWHDOK-VJSLDGLSNA-NCHEMBL10807456532A6.96000chembl206170829606SLC6A44061C=1C=C(C=CC1)C2=CC(=C(N2CC(C)C)C)C(NCCCN3CCN(C...
4AZTPZTRJVCAAMX-UHFFFAOYNA-NCHEMBL5783466532A8.00000chembl205969349606SLC6A44061C1=CC=C2C(=C1)C=C(C(N(C3CCNCC3)C4CCC4)=O)C=C2
\n", + "
" + ], + "text/plain": [ + " Ambit_InchiKey Original_Entry_ID Entrez_ID Activity_Flag \\\n", + "0 AZMKBJHIXZCVNL-BXKDBHETNA-N 44590643 6532 A \n", + "1 AZMKBJHIXZCVNL-UHFFFAOYNA-N 11492305 6532 A \n", + "2 AZOHUEDNMOIDOC-GETDIYNLNA-N 44419340 6532 A \n", + "3 AZSKJKSQZWHDOK-VJSLDGLSNA-N CHEMBL1080745 6532 A \n", + "4 AZTPZTRJVCAAMX-UHFFFAOYNA-N CHEMBL578346 6532 A \n", + "\n", + " pXC50 DB Original_Assay_ID Tax_ID Gene_Symbol Ortholog_Group \\\n", + "0 5.68382 pubchem 393260 9606 SLC6A4 4061 \n", + "1 5.16210 pubchem 393258 9606 SLC6A4 4061 \n", + "2 6.66354 pubchem 276059 9606 SLC6A4 4061 \n", + "3 6.96000 chembl20 617082 9606 SLC6A4 4061 \n", + "4 8.00000 chembl20 596934 9606 SLC6A4 4061 \n", + "\n", + " SMILES \n", + "0 FC1=CC([C@@H]2O[C@H](CC2)CN)=C(OC)C=C1 \n", + "1 FC1=CC(C2OC(CC2)CN)=C(OC)C=C1 \n", + "2 FC1=CC=C(C[C@H]2C[C@@H](N(CC2)CC=C)CCCNC(=O)NC... \n", + "3 C=1C=C(C=CC1)C2=CC(=C(N2CC(C)C)C)C(NCCCN3CCN(C... \n", + "4 C1=CC=C2C(=C1)C=C(C(N(C3CCNCC3)C4CCC4)=O)C=C2 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7228\n" + ] + } + ], + "source": [ + "print(len(data))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Murcko Scaffold Transformation ###" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from rdkit.Chem.Scaffolds import MurckoScaffold # for comparison\n", + "from sklearn.pipeline import Pipeline\n", + "from conversions import SmilesToMolTransformer, MolToScaffoldTransformer, MurckoScaffoldGenerator" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With MolToScaffoldTransformer, we are implementing a generic transformer that reads RDKit mol objects and applies a user-defined scaffold. Currently, we are only supporting Murcko scaffolds, but designed scikit-mol such that it is rather straightforward to add your desired scaffold generator. \n", + "\n", + " The MurckoScaffoldGenerator has two important options:\n", + "\n", + "\n", + " * `include_chirality`: If set to True, stereocenters in the scaffold will be preserved. This is important if the 3D arrangement of your core structure is critical for its function. If False, all stereochemical information is removed.\n", + " * Example: A chiral scaffold might have a SMILES of C1C[C@H](C)CC1, while its non-chiral version would be C1CC(C)CC1.\n", + "\n", + "\n", + " * `make_generic`: If set to True, it converts all atoms in the scaffold to generic carbon atoms and all bonds to single bonds. This is useful for finding more abstract structural relationships, where you only care about the graph connectivity of the ring systems,\n", + " not the specific elements or bond types.\n", + "\n", + " What About Molecules Without Rings?\n", + "\n", + " A Murcko scaffold is only defined for molecules that contain at least one ring. What happens if you have an acyclic molecule like ethanol (CCO) in your dataset? The pipeline handles this automatically and will identify that no scaffold can be generated. It will produce an InvalidMol object for that entry. This ensures that your workflow doesn't crash and you can easily filter out these cases later if needed." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "pipeline = Pipeline([('mol_transformer', SmilesToMolTransformer(safe_inference_mode = True)), ('scaffold_transformer', \n", + " MolToScaffoldTransformer(safe_inference_mode=True, scaffold_generator=MurckoScaffoldGenerator(include_chirality=False, make_generic=False)))])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "InvalidMol('MolToScaffoldTransformer(safe_inference_mode=True,\n", + " scaffold_generator=MurckoScaffoldGenerator())', error='Scaffold generation resulted in an empty molecule.')\n" + ] + } + ], + "source": [ + "from scikit_mol.core import InvalidMol\n", + "murcko_example = pipeline.transform(['CCO'])\n", + "assert type(murcko_example[0][0]) == InvalidMol\n", + "assert murcko_example[0][0].error == 'Scaffold generation resulted in an empty molecule.'\n", + "print(murcko_example[0][0])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "murcko = pipeline.transform(data['SMILES'])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# The above transformation can be equivalently generated by\n", + "murcko_rdkit = [None] * len(data['SMILES'])\n", + "for i, smiles in enumerate(data['SMILES']):\n", + " murcko_rdkit[i] = MurckoScaffold.MurckoScaffoldSmiles(smiles = smiles, includeChirality = False)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "## Now more explicit comparison ##" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "pipeline = Pipeline([('mol_transformer', SmilesToMolTransformer(safe_inference_mode = True)), \n", + " ('scaffold_transformer', MolToScaffoldTransformer(safe_inference_mode=True, \n", + " scaffold_generator=MurckoScaffoldGenerator(include_chirality=False, \n", + " make_generic=False)))])\n", + "murcko = pipeline.transform(data['SMILES'])\n", + "for smiles, murcko_scaffold in zip(data['SMILES'], murcko):\n", + " assert MurckoScaffold.MurckoScaffoldSmiles(smiles = smiles, includeChirality = False) == Chem.MolToSmiles(murcko_scaffold[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "pipeline = Pipeline([('mol_transformer', SmilesToMolTransformer(safe_inference_mode = True)), \n", + " ('scaffold_transformer', MolToScaffoldTransformer(safe_inference_mode=True, \n", + " scaffold_generator=MurckoScaffoldGenerator(include_chirality=True, \n", + " make_generic=False)))])\n", + "murcko = pipeline.transform(data['SMILES'])\n", + "for smiles, murcko_scaffold in zip(data['SMILES'], murcko):\n", + " assert MurckoScaffold.MurckoScaffoldSmiles(smiles = smiles, includeChirality = True) == Chem.MolToSmiles(murcko_scaffold[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Both assertions passed, seems like we are handling the chirality correctly." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## StratifiedGroupShuffleSplit ##" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the StratifiedGroupShuffleSplit, we are providing a scikit-learn cross-validator that satisfies the following properties:\n", + " \n", + "1- Same group does not appear in both training and test sets,\n", + "2- train/test split is done such that the class labels (y) have the same distribution in both sets and the full dataset\n", + "3- For each new split, a fresh random sampling of the data is performed to form a single train and test set. The splits are independent of each other and can overlap.\n", + "\n", + "```python\n", + "StratifiedGroupShuffleSplit.__init__( \n", + " self,\n", + " n_splits: int = 5,\n", + " *,\n", + " test_size: float = 0.2,\n", + " train_size: float = None,\n", + " random_state: int = None,\n", + " sample_weighted: bool = False,\n", + " suppress_warnings: bool = False,\n", + ")\n", + "```\n", + "\n", + "You can define a test and train size in the same way as you do in scikit-learn: a float value will mean a fraction (test_size = 0.2 -> 20% of the data will be used for testing), while an int value will mean a number of samples (test_size = 10 -> 10 samples will be used for testing). \n", + "\n", + "Our implementation of the `StratifiedGroupShuffleSplit` uses a greedy search algorithm to find the best possible split that satisfies the above properties. One key point of the algorithm is that it will create a list of groups that can be properly fit into the test set, and then start placing these groups into the test set by randomly selecting them. `sample_weighted=True` will make the selection use the number of samples in each group as a weight, meaning that groups with more samples will be prioritized. \n", + "\n", + "Some important caveats are, \n", + "\n", + "1- Due to the nature of the optimization problem, we cannot guarantee that the returned `test_size` will be the same as the requested `test_size`. If the requested and returned test set sizes differ by larget than 5%, you will get a warning (provided `suppress_warnings=False`)\n", + "2- It is possible that the dataset contains groups that are too large to fit into your requested `test_size`. In this case, you will get a warning (provided `suppress_warnings=False`)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# helper script to make our lives a bit easier and cleaner\n", + "def print_report(splitter, x, y, groups):\n", + " \n", + " for i, (train_index, test_index) in enumerate(splitter.split(x, y, groups)):\n", + " \n", + " y_train_counts, y_test_counts, groups_train_counts, groups_test_counts = (\n", + " np.unique(y[train_index], return_counts=True),\n", + " np.unique(y[test_index], return_counts=True),\n", + " np.unique(groups[train_index], return_counts=True),\n", + " np.unique(groups[test_index], return_counts=True)\n", + " )\n", + " \n", + " print(f\"Split: {i}\")\n", + " print(f\"Train y and their counts: {y_train_counts}\")\n", + " print(f\"Test y and their counts: {y_test_counts}\")\n", + " print(f\"Train set class label distribution: {y_train_counts[1]/len(y[train_index])}\")\n", + " print(f\"Test set class label distribution: {y_test_counts[1]/len(y[test_index])}\")\n", + " print(f\"Train groups and their counts:: {groups_train_counts}\")\n", + " print(f\"Test groups and their counts: {groups_test_counts}\")\n", + " print(f\"Train size: {len(y[train_index])}\")\n", + " print(f\"Test size: {len(y[test_index])}\")\n", + " print(f\"Overlapping groups in train and test splits: {len(set(groups_balanced[train_index]).intersection(set(groups_balanced[test_index])))}\\n\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Let's create a dummy balanced dataset\n", + "x = np.random.rand(1000)\n", + "y_balanced = np.random.randint(0,3,1000)\n", + "groups_balanced = np.random.randint(0,10,1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Let's create a dummy imbalanced dataset\n", + "x = np.random.rand(1000)\n", + "y_imbalanced = np.random.randint(0,3,1000)\n", + "groups = np.random.randint(0,2,1000)\n", + "y_imbalanced[0:900] = 0\n", + "np.random.shuffle(y_imbalanced)\n", + "groups[0:850] = 1\n", + "groups_imbalanced = groups.copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unique y and their counts in the full dataset: (array([0, 1, 2]), array([318, 331, 351]))\n", + "Unique groups and their counts in the full dataset: (array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), array([ 80, 99, 122, 102, 114, 91, 105, 92, 99, 96]))\n", + "Split: 0\n", + "Train y and their counts: (array([0, 1, 2]), array([255, 268, 267]))\n", + "Test y and their counts: (array([0, 1, 2]), array([63, 63, 84]))\n", + "Train set class label distribution: [0.32278481 0.33924051 0.33797468]\n", + "Test set class label distribution: [0.3 0.3 0.4]\n", + "Train groups and their counts:: (array([0, 1, 2, 3, 5, 6, 7, 8]), array([ 80, 99, 122, 102, 91, 105, 92, 99]))\n", + "Test groups and their counts: (array([4, 9]), array([114, 96]))\n", + "Train size: 790\n", + "Test size: 210\n", + "Overlapping groups in train and test splits: 0\n", + "\n", + "Split: 1\n", + "Train y and their counts: (array([0, 1, 2]), array([260, 255, 287]))\n", + "Test y and their counts: (array([0, 1, 2]), array([58, 76, 64]))\n", + "Train set class label distribution: [0.32418953 0.31795511 0.35785536]\n", + "Test set class label distribution: [0.29292929 0.38383838 0.32323232]\n", + "Train groups and their counts:: (array([0, 2, 3, 4, 5, 6, 7, 9]), array([ 80, 122, 102, 114, 91, 105, 92, 96]))\n", + "Test groups and their counts: (array([1, 8]), array([99, 99]))\n", + "Train size: 802\n", + "Test size: 198\n", + "Overlapping groups in train and test splits: 0\n", + "\n" + ] + } + ], + "source": [ + "# Groups are splitted, i.e. the same group does not occur both in the test and train split\n", + "from sklearn.model_selection import GroupShuffleSplit\n", + "sss = GroupShuffleSplit(n_splits=2, test_size=0.2)\n", + "print(f\"Unique y and their counts in the full dataset: {np.unique(y_balanced, return_counts=True)}\")\n", + "print(f\"Unique groups and their counts in the full dataset: {np.unique(groups_balanced, return_counts=True)}\")\n", + "print_report(sss, x, y_balanced, groups_balanced)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unique y and their counts in the full dataset: (array([0, 1, 2]), array([932, 39, 29]))\n", + "Unique groups and their counts in the full dataset: (array([0, 1]), array([ 70, 930]))\n", + "Split: 0\n", + "Train y and their counts: (array([0, 1, 2]), array([64, 3, 3]))\n", + "Test y and their counts: (array([0, 1, 2]), array([868, 36, 26]))\n", + "Train set class label distribution: [0.91428571 0.04285714 0.04285714]\n", + "Test set class label distribution: [0.93333333 0.03870968 0.02795699]\n", + "Train groups and their counts:: (array([0]), array([70]))\n", + "Test groups and their counts: (array([1]), array([930]))\n", + "Train size: 70\n", + "Test size: 930\n", + "Overlapping groups in train and test splits: 10\n", + "\n", + "Split: 1\n", + "Train y and their counts: (array([0, 1, 2]), array([868, 36, 26]))\n", + "Test y and their counts: (array([0, 1, 2]), array([64, 3, 3]))\n", + "Train set class label distribution: [0.93333333 0.03870968 0.02795699]\n", + "Test set class label distribution: [0.91428571 0.04285714 0.04285714]\n", + "Train groups and their counts:: (array([1]), array([930]))\n", + "Test groups and their counts: (array([0]), array([70]))\n", + "Train size: 930\n", + "Test size: 70\n", + "Overlapping groups in train and test splits: 10\n", + "\n" + ] + } + ], + "source": [ + "# When we have a dataset with a strong class imbalance (NOTE: Group labels are still balanced)\n", + "# Groups are splitted, i.e. the same group does not occur both in the test and train split\n", + "# But the stratification is not guaranteed, i.e. class distributions (y-labels) in the test and train sets are not the same as in the full dataset\n", + "# In your dataset if one class label is occurring much more often than the other class labels (imbalanced dataset), without stratification \n", + "# you are risking of not having the under-represented cl\\asses in the test set\n", + "from sklearn.model_selection import GroupShuffleSplit\n", + "sss = GroupShuffleSplit(n_splits=2, test_size=0.2, random_state = 42)\n", + "print(f\"Unique y and their counts in the full dataset: {np.unique(y_imbalanced, return_counts=True)}\")\n", + "print(f\"Unique groups and their counts in the full dataset: {np.unique(groups, return_counts=True)}\")\n", + "\n", + "\n", + "print_report(sss, x, y_imbalanced, groups)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unique y and their counts in the full dataset: (array([0, 1, 2]), array([932, 39, 29]))\n", + "Unique groups and their counts in the full dataset: (array([0, 1]), array([ 70, 930]))\n", + "Split: 0\n", + "Train y and their counts: (array([0, 1, 2]), array([64, 3, 3]))\n", + "Test y and their counts: (array([0, 1, 2]), array([868, 36, 26]))\n", + "Train set class label distribution: [0.91428571 0.04285714 0.04285714]\n", + "Test set class label distribution: [0.93333333 0.03870968 0.02795699]\n", + "Train groups and their counts:: (array([0]), array([70]))\n", + "Test groups and their counts: (array([1]), array([930]))\n", + "Train size: 70\n", + "Test size: 930\n", + "Overlapping groups in train and test splits: 10\n", + "\n", + "Split: 1\n", + "Train y and their counts: (array([0, 1, 2]), array([868, 36, 26]))\n", + "Test y and their counts: (array([0, 1, 2]), array([64, 3, 3]))\n", + "Train set class label distribution: [0.93333333 0.03870968 0.02795699]\n", + "Test set class label distribution: [0.91428571 0.04285714 0.04285714]\n", + "Train groups and their counts:: (array([1]), array([930]))\n", + "Test groups and their counts: (array([0]), array([70]))\n", + "Train size: 930\n", + "Test size: 70\n", + "Overlapping groups in train and test splits: 10\n", + "\n" + ] + } + ], + "source": [ + "# When we have a dataset with a strong class imbalance and strong group imbalance:\n", + "# Groups are splitted, i.e. the same group does not occur both in the test and train split\n", + "# But the stratification is not guaranteed, i.e. class distributions (y-labels) in the test and train sets are not the same as in the full dataset\n", + "# In your dataset if one class label is occurring much more often than the other class labels (imbalanced dataset), without stratification \n", + "# you are risking of not having the under-represented classes in the test set\n", + "from sklearn.model_selection import GroupShuffleSplit\n", + "sss = GroupShuffleSplit(n_splits=2, test_size=0.2, random_state = 42)\n", + "print(f\"Unique y and their counts in the full dataset: {np.unique(y_imbalanced, return_counts=True)}\")\n", + "print(f\"Unique groups and their counts in the full dataset: {np.unique(groups_imbalanced, return_counts=True)}\")\n", + "\n", + "print_report(sss, x, y_imbalanced , groups_imbalanced)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([0, 1]), array([ 70, 930]))\n", + "Full dataset class label distribution: [0.932 0.039 0.029]\n", + "\n", + "Split: 0\n", + "Train y and their counts: (array([0, 1, 2]), array([583, 24, 20]))\n", + "Test y and their counts: (array([0, 1, 2]), array([349, 15, 9]))\n", + "Train set class label distribution: [0.92982456 0.03827751 0.03189793]\n", + "Test set class label distribution: [0.93565684 0.04021448 0.02412869]\n", + "Train groups and their counts:: (array([2, 4, 5, 6, 8, 9]), array([122, 114, 91, 105, 99, 96]))\n", + "Test groups and their counts: (array([0, 1, 3, 7]), array([ 80, 99, 102, 92]))\n", + "Train size: 627\n", + "Test size: 373\n", + "Overlapping groups in train and test splits: 0\n", + "\n", + "Split: 1\n", + "Train y and their counts: (array([0, 1, 2]), array([657, 26, 16]))\n", + "Test y and their counts: (array([0, 1, 2]), array([275, 13, 13]))\n", + "Train set class label distribution: [0.93991416 0.03719599 0.02288984]\n", + "Test set class label distribution: [0.91362126 0.04318937 0.04318937]\n", + "Train groups and their counts:: (array([0, 1, 2, 3, 6, 7, 8]), array([ 80, 99, 122, 102, 105, 92, 99]))\n", + "Test groups and their counts: (array([4, 5, 9]), array([114, 91, 96]))\n", + "Train size: 699\n", + "Test size: 301\n", + "Overlapping groups in train and test splits: 0\n", + "\n", + "Split: 2\n", + "Train y and their counts: (array([0, 1, 2]), array([624, 28, 22]))\n", + "Test y and their counts: (array([0, 1, 2]), array([308, 11, 7]))\n", + "Train set class label distribution: [0.92581602 0.04154303 0.03264095]\n", + "Test set class label distribution: [0.94478528 0.03374233 0.02147239]\n", + "Train groups and their counts:: (array([0, 1, 3, 4, 5, 7, 9]), array([ 80, 99, 102, 114, 91, 92, 96]))\n", + "Test groups and their counts: (array([2, 6, 8]), array([122, 105, 99]))\n", + "Train size: 674\n", + "Test size: 326\n", + "Overlapping groups in train and test splits: 0\n", + "\n" + ] + } + ], + "source": [ + "# If you use GroupKFold on an imbalanced dataset, you will be able to separate the groups but your splits won't be stratified\n", + "\n", + "from sklearn.model_selection import GroupKFold\n", + "sss = GroupKFold(n_splits=3, shuffle=True, random_state=None)\n", + "groups_counts = np.unique(groups, return_counts=True)\n", + "print(groups_counts)\n", + "print(f\"Full dataset class label distribution: {np.unique(y_imbalanced, return_counts=True)[1]/len(y_imbalanced)}\\n\")\n", + "\n", + "print_report(sss, x, y_imbalanced, groups_balanced)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([0, 1]), array([ 70, 930]))\n", + "Split: 0\n", + "Train y and their counts: (array([0, 1, 2]), array([223, 234, 238]))\n", + "Test y and their counts: (array([0, 1, 2]), array([ 95, 97, 113]))\n", + "Train set class label distribution: [0.32086331 0.33669065 0.34244604]\n", + "Test set class label distribution: [0.31147541 0.31803279 0.3704918 ]\n", + "Train groups and their counts:: (array([0, 1, 2, 3, 5, 6, 9]), array([ 80, 99, 122, 102, 91, 105, 96]))\n", + "Test groups and their counts: (array([4, 7, 8]), array([114, 92, 99]))\n", + "Train size: 695\n", + "Test size: 305\n", + "Overlapping groups in train and test splits: 0\n", + "\n", + "Split: 1\n", + "Train y and their counts: (array([0, 1, 2]), array([204, 207, 217]))\n", + "Test y and their counts: (array([0, 1, 2]), array([114, 124, 134]))\n", + "Train set class label distribution: [0.32484076 0.32961783 0.3455414 ]\n", + "Test set class label distribution: [0.30645161 0.33333333 0.36021505]\n", + "Train groups and their counts:: (array([2, 4, 6, 7, 8, 9]), array([122, 114, 105, 92, 99, 96]))\n", + "Test groups and their counts: (array([0, 1, 3, 5]), array([ 80, 99, 102, 91]))\n", + "Train size: 628\n", + "Test size: 372\n", + "Overlapping groups in train and test splits: 0\n", + "\n", + "Split: 2\n", + "Train y and their counts: (array([0, 1, 2]), array([209, 221, 247]))\n", + "Test y and their counts: (array([0, 1, 2]), array([109, 110, 104]))\n", + "Train set class label distribution: [0.30871492 0.32644018 0.3648449 ]\n", + "Test set class label distribution: [0.3374613 0.34055728 0.32198142]\n", + "Train groups and their counts:: (array([0, 1, 3, 4, 5, 7, 8]), array([ 80, 99, 102, 114, 91, 92, 99]))\n", + "Test groups and their counts: (array([2, 6, 9]), array([122, 105, 96]))\n", + "Train size: 677\n", + "Test size: 323\n", + "Overlapping groups in train and test splits: 0\n", + "\n" + ] + } + ], + "source": [ + "# To ensure both groups are separated and the class labels are stratified, you can use StratifiedGroupKFold. Note that you cannot define a test set size here\n", + "\n", + "from sklearn.model_selection import StratifiedGroupKFold\n", + "sss = StratifiedGroupKFold(n_splits=3)\n", + "groups_counts = np.unique(groups, return_counts=True)\n", + "print(groups_counts)\n", + "print_report(sss, x, y_balanced, groups_balanced)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([0, 1]), array([ 70, 930]))\n", + "\n", + "Full dataset class label distribution: [0.932 0.039 0.029]\n", + "\n", + "Split: 0\n", + "Train y and their counts: (array([0, 1, 2]), array([666, 27, 18]))\n", + "Test y and their counts: (array([0, 1, 2]), array([266, 12, 11]))\n", + "Train set class label distribution: [0.93670886 0.03797468 0.02531646]\n", + "Test set class label distribution: [0.92041522 0.04152249 0.03806228]\n", + "Train groups and their counts:: (array([0, 2, 3, 4, 6, 7, 9]), array([ 80, 122, 102, 114, 105, 92, 96]))\n", + "Test groups and their counts: (array([1, 5, 8]), array([99, 91, 99]))\n", + "Train size: 711\n", + "Test size: 289\n", + "Overlapping groups in train and test splits: 0\n", + "\n", + "Split: 1\n", + "Train y and their counts: (array([0, 1, 2]), array([625, 26, 17]))\n", + "Test y and their counts: (array([0, 1, 2]), array([307, 13, 12]))\n", + "Train set class label distribution: [0.93562874 0.03892216 0.0254491 ]\n", + "Test set class label distribution: [0.9246988 0.03915663 0.03614458]\n", + "Train groups and their counts:: (array([0, 1, 3, 5, 6, 7, 8]), array([ 80, 99, 102, 91, 105, 92, 99]))\n", + "Test groups and their counts: (array([2, 4, 9]), array([122, 114, 96]))\n", + "Train size: 668\n", + "Test size: 332\n", + "Overlapping groups in train and test splits: 0\n", + "\n", + "Split: 2\n", + "Train y and their counts: (array([0, 1, 2]), array([573, 25, 23]))\n", + "Test y and their counts: (array([0, 1, 2]), array([359, 14, 6]))\n", + "Train set class label distribution: [0.92270531 0.04025765 0.03703704]\n", + "Test set class label distribution: [0.94722955 0.03693931 0.01583113]\n", + "Train groups and their counts:: (array([1, 2, 4, 5, 8, 9]), array([ 99, 122, 114, 91, 99, 96]))\n", + "Test groups and their counts: (array([0, 3, 6, 7]), array([ 80, 102, 105, 92]))\n", + "Train size: 621\n", + "Test size: 379\n", + "Overlapping groups in train and test splits: 0\n", + "\n" + ] + } + ], + "source": [ + "# Stratification works pretty well for the imbalanced class labels. Note that you cannot define a test set size here.\n", + "\n", + "sss = StratifiedGroupKFold(n_splits=3, shuffle=True, random_state=65)\n", + "groups_counts = np.unique(groups, return_counts=True)\n", + "print(f\"{groups_counts}\\n\")\n", + "print(f\"Full dataset class label distribution: {np.unique(y_imbalanced, return_counts=True)[1]/len(y_imbalanced)}\\n\")\n", + "print_report(sss, x, y_imbalanced, groups_balanced)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([0, 1]), array([ 70, 930]))\n", + "\n", + "Split: 0\n", + "Train y and their counts: (array([0, 1, 2]), array([64, 3, 3]))\n", + "Test y and their counts: (array([0, 1, 2]), array([868, 36, 26]))\n", + "Train set class label distribution: [0.91428571 0.04285714 0.04285714]\n", + "Test set class label distribution: [0.93333333 0.03870968 0.02795699]\n", + "Train groups and their counts:: (array([0]), array([70]))\n", + "Test groups and their counts: (array([1]), array([930]))\n", + "Train size: 70\n", + "Test size: 930\n", + "Overlapping groups in train and test splits: 10\n", + "\n", + "Split: 1\n", + "Train y and their counts: (array([0, 1, 2]), array([932, 39, 29]))\n", + "Test y and their counts: (array([], dtype=int64), array([], dtype=int64))\n", + "Train set class label distribution: [0.932 0.039 0.029]\n", + "Test set class label distribution: []\n", + "Train groups and their counts:: (array([0, 1]), array([ 70, 930]))\n", + "Test groups and their counts: (array([], dtype=int64), array([], dtype=int64))\n", + "Train size: 1000\n", + "Test size: 0\n", + "Overlapping groups in train and test splits: 0\n", + "\n", + "Split: 2\n", + "Train y and their counts: (array([0, 1, 2]), array([868, 36, 26]))\n", + "Test y and their counts: (array([0, 1, 2]), array([64, 3, 3]))\n", + "Train set class label distribution: [0.93333333 0.03870968 0.02795699]\n", + "Test set class label distribution: [0.91428571 0.04285714 0.04285714]\n", + "Train groups and their counts:: (array([1]), array([930]))\n", + "Test groups and their counts: (array([0]), array([70]))\n", + "Train size: 930\n", + "Test size: 70\n", + "Overlapping groups in train and test splits: 10\n", + "\n" + ] + } + ], + "source": [ + "sss = StratifiedGroupKFold(n_splits=3, shuffle=True, random_state=65)\n", + "groups_counts = np.unique(groups, return_counts=True)\n", + "print(f\"{groups_counts}\\n\")\n", + "print_report(sss, x, y_imbalanced, groups_imbalanced)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Due to the strong group label imbalance, splits resulted in an unwanted train/test ratio and you don't get a warning about it" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Interlude ##\n", + "\n", + "Let's summarize:\n", + "\n", + "| Feature | GroupShuffleSplit | GroupKFold | StratifiedGroupKFold |\n", + "|:-------------------------|:-----------------:|:-----------------:|:--------------------------|\n", + "| Shuffles Data? | ✅ | ❌ | ❌¹ |\n", + "| Keeps Groups Intact? | ✅ | ✅ | ✅ |\n", + "| Is the Split Stratified? | ❌ | ❌ | ✅ |\n", + "\n", + "¹ StratifiedGroupKFold does not create new random splits on each iteration like GroupShuffleSplit. Instead, it has a shuffle parameter that, if set to True, will randomly shuffle the order of groups once before partitioning them into k consecutive folds.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's check how StratifiedGroupShuffleSplit works" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Groups and their counts: (array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), array([ 80, 99, 122, 102, 114, 91, 105, 92, 99, 96]))\n", + "Full dataset class label distribution: [0.932 0.039 0.029]\n", + "\n", + "Split: 0\n", + "Train y and their counts: (array([0, 1, 2]), array([768, 32, 24]))\n", + "Test y and their counts: (array([0, 1, 2]), array([164, 7, 5]))\n", + "Train set class label distribution: [0.93203883 0.03883495 0.02912621]\n", + "Test set class label distribution: [0.93181818 0.03977273 0.02840909]\n", + "Train groups and their counts:: (array([1, 2, 3, 4, 5, 6, 7, 8]), array([ 99, 122, 102, 114, 91, 105, 92, 99]))\n", + "Test groups and their counts: (array([0, 9]), array([80, 96]))\n", + "Train size: 824\n", + "Test size: 176\n", + "Overlapping groups in train and test splits: 0\n", + "\n", + "Split: 1\n", + "Train y and their counts: (array([0, 1, 2]), array([732, 29, 21]))\n", + "Test y and their counts: (array([0, 1, 2]), array([200, 10, 8]))\n", + "Train set class label distribution: [0.93606138 0.0370844 0.02685422]\n", + "Test set class label distribution: [0.91743119 0.04587156 0.03669725]\n", + "Train groups and their counts:: (array([0, 1, 3, 4, 5, 6, 7, 8]), array([ 80, 99, 102, 114, 91, 105, 92, 99]))\n", + "Test groups and their counts: (array([2, 9]), array([122, 96]))\n", + "Train size: 782\n", + "Test size: 218\n", + "Overlapping groups in train and test splits: 0\n", + "\n", + "Split: 2\n", + "Train y and their counts: (array([0, 1, 2]), array([733, 32, 22]))\n", + "Test y and their counts: (array([0, 1, 2]), array([199, 7, 7]))\n", + "Train set class label distribution: [0.93138501 0.04066074 0.02795426]\n", + "Test set class label distribution: [0.9342723 0.03286385 0.03286385]\n", + "Train groups and their counts:: (array([0, 1, 2, 3, 5, 6, 7, 9]), array([ 80, 99, 122, 102, 91, 105, 92, 96]))\n", + "Test groups and their counts: (array([4, 8]), array([114, 99]))\n", + "Train size: 787\n", + "Test size: 213\n", + "Overlapping groups in train and test splits: 0\n", + "\n" + ] + } + ], + "source": [ + "from splitter import StratifiedGroupShuffleSplit\n", + "\n", + "np.set_printoptions(legacy = '1.25')\n", + "sgss = StratifiedGroupShuffleSplit(n_splits=3, test_size = 0.22, random_state=43)\n", + "groups_counts = np.unique(groups_balanced, return_counts=True)\n", + "print(f\"Groups and their counts: {groups_counts}\")\n", + "print(f\"Full dataset class label distribution: {np.unique(y_imbalanced, return_counts=True)[1]/len(y_imbalanced)}\\n\")\n", + "print_report(sgss, x, y_imbalanced, groups_balanced)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that:\n", + "\n", + "1- For each split, we are getting different groups in the train and test sets,\n", + "2- Class labels are stratified with some small deviation (~<2%)\n", + "3- Groups are properly splitted\n", + "4- If the returned test size deviates more than 5% from the requested test size, we get a warning message.\n", + "\n", + "| Feature | GroupShuffleSplit | GroupKFold | StratifiedGroupKFold | StratifidGroupShuffleSplit\n", + "|:-------------------------|:-----------------:|:-----------------:|:--------------------------:|:--------------------------:|\n", + "| Shuffles Data? | ✅ | ❌ | ❌ | ✅ |\n", + "| Keeps Groups Intact? | ✅ | ✅ | ✅ | ✅ |\n", + "| Is the Split Stratified? | ❌ | ❌ | ✅ | ✅ |" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One last example: if no train/test split is found, the algorithm will raise an error. In the following example, there is no way that we can split two groups such that the test set contains around 220 samples." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Groups and their counts: (array([0, 1]), array([500, 500]))\n", + "Full dataset class label distribution: [0.932 0.039 0.029]\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/peptid/Local_Documents/personal/git_repos/scikit_mol_bkav/scikit_mol/notebooks/../splitter.py:232: UserWarning: \n", + " \"Warning: All available groups are larger than the target test size. \n", + " The algorithm will still try to select a group that overshoots the target, \n", + " which may lead to a larger than requested test set, or an completely empty test set.\"\n", + " \n", + " warnings.warn(\n" + ] + }, + { + "ename": "RuntimeError", + "evalue": "Given the dataset, no train/test split could be found. Try increasing test_size", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mRuntimeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[24]\u001b[39m\u001b[32m, line 13\u001b[39m\n\u001b[32m 11\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mGroups and their counts: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mgroups_counts\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m 12\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mFull dataset class label distribution: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnp.unique(y_imbalanced,\u001b[38;5;250m \u001b[39mreturn_counts=\u001b[38;5;28;01mTrue\u001b[39;00m)[\u001b[32m1\u001b[39m]/\u001b[38;5;28mlen\u001b[39m(y_imbalanced)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m13\u001b[39m \u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain_index\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest_index\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43msgss\u001b[49m\u001b[43m.\u001b[49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_imbalanced\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgroups_balanced\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\n\u001b[32m 14\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mcontinue\u001b[39;49;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Local_Documents/personal/git_repos/scikit_mol_bkav/scikit_mol/notebooks/../splitter.py:211\u001b[39m, in \u001b[36mStratifiedGroupShuffleSplit.split\u001b[39m\u001b[34m(self, X, y, groups)\u001b[39m\n\u001b[32m 185\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34msplit\u001b[39m(\u001b[38;5;28mself\u001b[39m, X, y, groups=\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[32m 186\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"Generates indices to split data into training and test set.\u001b[39;00m\n\u001b[32m 187\u001b[39m \n\u001b[32m 188\u001b[39m \u001b[33;03m Parameters\u001b[39;00m\n\u001b[32m (...)\u001b[39m\u001b[32m 209\u001b[39m \u001b[33;03m The testing set indices for that split.\u001b[39;00m\n\u001b[32m 210\u001b[39m \u001b[33;03m \"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m211\u001b[39m \u001b[38;5;28;01myield from\u001b[39;00m \u001b[38;5;28mself\u001b[39m._iter_indices(X, y, groups)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Local_Documents/personal/git_repos/scikit_mol_bkav/scikit_mol/notebooks/../splitter.py:167\u001b[39m, in \u001b[36mStratifiedGroupShuffleSplit._iter_indices\u001b[39m\u001b[34m(self, X, y, groups)\u001b[39m\n\u001b[32m 161\u001b[39m test_indices = (\n\u001b[32m 162\u001b[39m np.concatenate([group_info[g_idx][\u001b[33m\"\u001b[39m\u001b[33mindices\u001b[39m\u001b[33m\"\u001b[39m] \u001b[38;5;28;01mfor\u001b[39;00m g_idx \u001b[38;5;129;01min\u001b[39;00m test_groups])\n\u001b[32m 163\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m test_groups\n\u001b[32m 164\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m []\n\u001b[32m 165\u001b[39m )\n\u001b[32m 166\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(test_indices) == \u001b[32m0\u001b[39m:\n\u001b[32m--> \u001b[39m\u001b[32m167\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mGiven the dataset, no train/test split could be found. Try increasing test_size\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 168\u001b[39m all_indices = np.arange(n_samples)\n\u001b[32m 169\u001b[39m train_indices = np.setdiff1d(all_indices, test_indices, assume_unique=\u001b[38;5;28;01mTrue\u001b[39;00m)\n", + "\u001b[31mRuntimeError\u001b[39m: Given the dataset, no train/test split could be found. Try increasing test_size" + ] + } + ], + "source": [ + "# Let's create a dummy balanced dataset\n", + "x = np.random.rand(1000)\n", + "y_balanced = np.random.randint(0,3,1000)\n", + "groups_balanced = np.random.randint(0,2,1000)\n", + "\n", + "from splitter import StratifiedGroupShuffleSplit\n", + "\n", + "np.set_printoptions(legacy = '1.25')\n", + "sgss = StratifiedGroupShuffleSplit(n_splits=3, test_size = 0.22, random_state=43)\n", + "groups_counts = np.unique(groups_balanced, return_counts=True)\n", + "print(f\"Groups and their counts: {groups_counts}\")\n", + "print(f\"Full dataset class label distribution: {np.unique(y_imbalanced, return_counts=True)[1]/len(y_imbalanced)}\\n\")\n", + "for i, (train_index, test_index) in enumerate(sgss.split(x, y_imbalanced, groups_balanced)):\n", + " continue" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example Showcase ##\n", + "**Based heavily on the previous work of Ruel Cedeno, @cedenoruel**\n", + "\n", + "**!!! Seems to be working worse than the original notebook (https://github.com/cedenoruel/scikit-mol/blob/main/notebooks/12_scaffold_split_CV_and_hyperparameter_tuning.ipynb) when the full dataset is used. Maybe there's something wrong with my implementation.!!**" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# import the usual suspects\n", + "import os\n", + "import rdkit\n", + "from rdkit import Chem\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from time import time\n", + "import numpy as np\n", + "from sklearn.pipeline import Pipeline, make_pipeline\n", + "from sklearn.linear_model import Ridge\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "\n", + "#from scikit_mol package\n", + "\n", + "from scikit_mol.fingerprints import MorganFingerprintTransformer\n", + "\n", + "#to maintain reproducibility\n", + "random_state= 41 " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "full_set = True\n", + "\n", + "if full_set:\n", + " csv_file = \"../../tests/data/SLC6A4_active_excape_export.csv\"\n", + " if not os.path.exists(csv_file):\n", + " import urllib.request\n", + "\n", + " url = \"https://ndownloader.figshare.com/files/25747817\"\n", + " urllib.request.urlretrieve(url, csv_file)\n", + "else:\n", + " csv_file = \"../../tests/data/SLC6A4_active_excapedb_subset.csv\"\n", + "\n", + "data = pd.read_csv(csv_file) \n", + "#Add ROMol column to the dataframe\n", + "data[\"ROMol\"] = data.SMILES.apply(Chem.MolFromSmiles)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 2: Standardize molecules\n", + "\n", + "One key advantage of scikit-mol is it allows you to save/pickle models that **work directly on rdkit Mol object**.\n", + "\n", + "This solves the problem of having to generate features/descriptors externally with the risk of being incompatible with the saved model (that you may have built few months ago). " + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# Probably the recommended way would be to prestandardize the data if there's no changes to the transformer,\n", + "# and then add the standardizer in the inference pipeline.\n", + "\n", + "from scikit_mol.standardizer import Standardizer\n", + "\n", + "standardizer = Standardizer()\n", + "\n", + "data[\"ROMol\"] = standardizer.transform(data[\"ROMol\"]).flatten()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Ambit_InchiKeyOriginal_Entry_IDEntrez_IDActivity_FlagpXC50DBOriginal_Assay_IDTax_IDGene_SymbolOrtholog_GroupSMILESROMol
0AZMKBJHIXZCVNL-BXKDBHETNA-N445906436532A5.68382pubchem3932609606SLC6A44061FC1=CC([C@@H]2O[C@H](CC2)CN)=C(OC)C=C1<rdkit.Chem.rdchem.Mol object at 0x1333ecc80>
1AZMKBJHIXZCVNL-UHFFFAOYNA-N114923056532A5.16210pubchem3932589606SLC6A44061FC1=CC(C2OC(CC2)CN)=C(OC)C=C1<rdkit.Chem.rdchem.Mol object at 0x1333eccf0>
2AZOHUEDNMOIDOC-GETDIYNLNA-N444193406532A6.66354pubchem2760599606SLC6A44061FC1=CC=C(C[C@H]2C[C@@H](N(CC2)CC=C)CCCNC(=O)NC...<rdkit.Chem.rdchem.Mol object at 0x1333ecd60>
3AZSKJKSQZWHDOK-VJSLDGLSNA-NCHEMBL10807456532A6.96000chembl206170829606SLC6A44061C=1C=C(C=CC1)C2=CC(=C(N2CC(C)C)C)C(NCCCN3CCN(C...<rdkit.Chem.rdchem.Mol object at 0x1333ecdd0>
4AZTPZTRJVCAAMX-UHFFFAOYNA-NCHEMBL5783466532A8.00000chembl205969349606SLC6A44061C1=CC=C2C(=C1)C=C(C(N(C3CCNCC3)C4CCC4)=O)C=C2<rdkit.Chem.rdchem.Mol object at 0x1333ece40>
.......................................
7223ZZHKHRXDQLQSFW-HHHXNRCGNA-NCHEMBL2823806532A5.74000chembl205325809606SLC6A44061C=1C=CC(C(C=2C=CC=CC2)OCCN3CCN(CC3)C[C@@H](CC4...<rdkit.Chem.rdchem.Mol object at 0x1334c80b0>
7224ZZHKHRXDQLQSFW-MHZLTWQENA-NCHEMBL2814925553A5.67000chembl2019805010116SLC6A44061C=1C=CC(C(C=2C=CC=CC2)OCCN3CCN(CC3)C[C@H](CC4=...<rdkit.Chem.rdchem.Mol object at 0x1334c8120>
7225ZZHKHRXDQLQSFW-MHZLTWQENA-NCHEMBL281496532A5.66000chembl205325809606SLC6A44061C=1C=CC(C(C=2C=CC=CC2)OCCN3CCN(CC3)C[C@H](CC4=...<rdkit.Chem.rdchem.Mol object at 0x1334c8190>
7226ZZJGNQRWIXQQDJ-CPLJGATDNA-N444193066532A5.26241pubchem2760599606SLC6A44061FC1=CC=C(C[C@H]2C[C@@H](N(CC2)C(=O)C)CCCNC(=O)...<rdkit.Chem.rdchem.Mol object at 0x1334c8200>
7227ZZRHLICOWQQNJL-UHFFFAOYNA-NCHEMBL16838756532A6.81000chembl207269269606SLC6A44061C1CCCCC1(C2=CC=C(C(=C2)Cl)Cl)CN(CC)C<rdkit.Chem.rdchem.Mol object at 0x1334c8270>
\n", + "

7228 rows × 12 columns

\n", + "
" + ], + "text/plain": [ + " Ambit_InchiKey Original_Entry_ID Entrez_ID Activity_Flag \\\n", + "0 AZMKBJHIXZCVNL-BXKDBHETNA-N 44590643 6532 A \n", + "1 AZMKBJHIXZCVNL-UHFFFAOYNA-N 11492305 6532 A \n", + "2 AZOHUEDNMOIDOC-GETDIYNLNA-N 44419340 6532 A \n", + "3 AZSKJKSQZWHDOK-VJSLDGLSNA-N CHEMBL1080745 6532 A \n", + "4 AZTPZTRJVCAAMX-UHFFFAOYNA-N CHEMBL578346 6532 A \n", + "... ... ... ... ... \n", + "7223 ZZHKHRXDQLQSFW-HHHXNRCGNA-N CHEMBL282380 6532 A \n", + "7224 ZZHKHRXDQLQSFW-MHZLTWQENA-N CHEMBL28149 25553 A \n", + "7225 ZZHKHRXDQLQSFW-MHZLTWQENA-N CHEMBL28149 6532 A \n", + "7226 ZZJGNQRWIXQQDJ-CPLJGATDNA-N 44419306 6532 A \n", + "7227 ZZRHLICOWQQNJL-UHFFFAOYNA-N CHEMBL1683875 6532 A \n", + "\n", + " pXC50 DB Original_Assay_ID Tax_ID Gene_Symbol \\\n", + "0 5.68382 pubchem 393260 9606 SLC6A4 \n", + "1 5.16210 pubchem 393258 9606 SLC6A4 \n", + "2 6.66354 pubchem 276059 9606 SLC6A4 \n", + "3 6.96000 chembl20 617082 9606 SLC6A4 \n", + "4 8.00000 chembl20 596934 9606 SLC6A4 \n", + "... ... ... ... ... ... \n", + "7223 5.74000 chembl20 532580 9606 SLC6A4 \n", + "7224 5.67000 chembl20 198050 10116 SLC6A4 \n", + "7225 5.66000 chembl20 532580 9606 SLC6A4 \n", + "7226 5.26241 pubchem 276059 9606 SLC6A4 \n", + "7227 6.81000 chembl20 726926 9606 SLC6A4 \n", + "\n", + " Ortholog_Group SMILES \\\n", + "0 4061 FC1=CC([C@@H]2O[C@H](CC2)CN)=C(OC)C=C1 \n", + "1 4061 FC1=CC(C2OC(CC2)CN)=C(OC)C=C1 \n", + "2 4061 FC1=CC=C(C[C@H]2C[C@@H](N(CC2)CC=C)CCCNC(=O)NC... \n", + "3 4061 C=1C=C(C=CC1)C2=CC(=C(N2CC(C)C)C)C(NCCCN3CCN(C... \n", + "4 4061 C1=CC=C2C(=C1)C=C(C(N(C3CCNCC3)C4CCC4)=O)C=C2 \n", + "... ... ... \n", + "7223 4061 C=1C=CC(C(C=2C=CC=CC2)OCCN3CCN(CC3)C[C@@H](CC4... \n", + "7224 4061 C=1C=CC(C(C=2C=CC=CC2)OCCN3CCN(CC3)C[C@H](CC4=... \n", + "7225 4061 C=1C=CC(C(C=2C=CC=CC2)OCCN3CCN(CC3)C[C@H](CC4=... \n", + "7226 4061 FC1=CC=C(C[C@H]2C[C@@H](N(CC2)C(=O)C)CCCNC(=O)... \n", + "7227 4061 C1CCCCC1(C2=CC=C(C(=C2)Cl)Cl)CN(CC)C \n", + "\n", + " ROMol \n", + "0 \n", + "1 \n", + "2 \n", + "3 \n", + "4 \n", + "... ... \n", + "7223 \n", + "7224 \n", + "7225 \n", + "7226 \n", + "7227 \n", + "\n", + "[7228 rows x 12 columns]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 3: Use scaffold split to obtain train and test sets\n", + "\n", + "In a conventional random split, you would use the following \n", + "```python\n", + "X_train, X_test, y_train, y_test = train_test_split(X = data.ROMol, y = data.pXC50, test_size=0.2)\n", + "```\n", + "To perform a scaffold split, simply use ```data[\"scaffold_ID\"], _ = data['scaffold_smiles'].factorize()``` to add a column containing the **scaffold ID** then pass it to the parameter ```groups``` in the ```train_test_group_split``` " + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.pipeline import Pipeline\n", + "from conversions import SmilesToMolTransformer, MolToScaffoldTransformer, MurckoScaffoldGenerator" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "pipeline = Pipeline([('mol_transformer', SmilesToMolTransformer(safe_inference_mode = True)), ('scaffold_transformer', \n", + " MolToScaffoldTransformer(safe_inference_mode=True, scaffold_generator=MurckoScaffoldGenerator(include_chirality=False, make_generic=False)))])" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "scaffold = pipeline.transform(data['SMILES'])" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "scaffold_smiles = [Chem.MolToSmiles(i[0]) for i in scaffold]\n", + "data['scaffold_smiles'] = scaffold_smiles " + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "data[\"scaffold_ID\"], _ = data['scaffold_smiles'].factorize()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "from splitter import train_test_group_split\n", + "x_train, x_test, y_train, y_test, groups_train, groups_test = train_test_group_split(data.ROMol, data.pXC50, data.scaffold_ID, stratify=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 4: Build a pipeline and hyperparameter search space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For demonstration purposes, we will use a similar pipeline as the previous tutorial in hyperparameter tuning." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "moltransformer = MorganFingerprintTransformer()\n", + "regressor = Ridge(random_state=random_state)\n", + "optimization_pipe = make_pipeline(moltransformer, regressor)\n", + "\n", + "\n", + "#from scipy.stats import loguniform\n", + "\n", + "\n", + "param_grid = {\n", + " \"ridge__alpha\": [0.01,0.1,4,8],\n", + " \"morganfingerprinttransformer__fpSize\": [512,1024,2048,4096],\n", + "}\n", + "#\"morganfingerprinttransformer__radius\": [2, 3]\n", + "# \"morganfingerprinttransformer__useCounts\": [True, False]\n", + "# \"morganfingerprinttransformer__useFeatures\": [True, False]," + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 5: Use the GroupSplitCV in Hyperparameter Tuning\n", + "\n", + "Using ```GroupSplitCV``` allows you to perform hyperparameter tuning such that the validation set doesn't contain any **groups** present in the training set. In this particular example, our groups are **Bemis-Murcko scaffolds**. \n", + "\n", + "In principle, this would yield optimal hyperparameters that can better generalize to unseen molecular architectures. \n", + "\n", + "Using ```groups``` as a parameter for hyperparameter tuning is flexible as it gives you the freedom to create your own grouping algorithm. For instance, if you are working with a chemical series having the same scaffolds, then other grouping procedure is needed (k-nearest neighbor, Butina clustering, etc).\n", + "\n", + "```GroupSplitCV``` has the following arguments:\n", + "\n", + "n_splits <- number of splits/folds \n", + "\n", + "n_repeats <- number of reshuffling repetitions\n", + "\n", + "X,y <- as usual\n", + "\n", + "groups <- groupID such as scaffold_ID or cluster_ID, the validation set will not contain any group in common with the training set in each cycle\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "from splitter import GroupSplitCV\n", + "cv_scaffold = GroupSplitCV(n_splits=5, test_size=0.2, random_state=random_state)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pass the ```cv_scaffold``` to the ```cv``` parameter of any SearchCV of scikit-learn, in this case we use the ```GridSearchCV``` to minimize the effect of randomness " + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Runtime: 236.86\n" + ] + } + ], + "source": [ + "from sklearn.model_selection import GridSearchCV\n", + "search_scaffold = GridSearchCV(optimization_pipe, param_grid=param_grid, cv=cv_scaffold)\n", + "\n", + "t0 = time()\n", + "search_scaffold.fit(x_train, y_train, groups=groups_train)\n", + "t1 = time()\n", + "print(f\"Runtime: {t1-t0:0.2F}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.4337796417083567" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Test performance\n", + "from sklearn.metrics import r2_score\n", + "y_pred_scaffold = search_scaffold.best_estimator_.predict(x_test)\n", + "r2_scaffold = r2_score(y_test,y_pred_scaffold)\n", + "r2_scaffold" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analysis: Scaffold vs Random Split" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To understand the impact of scaffold splits, let's retrain the same model but this time, using random splits in cross validation." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Runtime: 639.33\n" + ] + } + ], + "source": [ + "from sklearn.base import clone\n", + "from sklearn.model_selection import RepeatedKFold\n", + "\n", + "cv_random = RepeatedKFold(n_splits=5, n_repeats=4, random_state=random_state)\n", + "#We use the same parameters n_splits and n_repeats so that it is comparable with the scaffold split\n", + "\n", + "optimization_pipe_random = clone(optimization_pipe)\n", + "\n", + "search_random = GridSearchCV(optimization_pipe_random, param_grid=param_grid, cv=cv_random)\n", + "\n", + "t0 = time()\n", + "search_random.fit(x_train,y_train)\n", + "t1 = time()\n", + "print(f\"Runtime: {t1-t0:0.2F}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'morganfingerprinttransformer__fpSize': 4096, 'ridge__alpha': 8}" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "search_random.best_params_" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'morganfingerprinttransformer__fpSize': 4096, 'ridge__alpha': 8}" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "search_scaffold.best_params_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Notice that the **optimal hyperparameters may be different** depending on the CV splitting approach.\n", + "\n", + "To determine whether this difference is statistically significant, we will perform further analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "df_cv_compare = pd.DataFrame()\n", + "\n", + "df_scaffold_cv_results = pd.DataFrame(search_scaffold.cv_results_)\n", + "df_random_cv_results = pd.DataFrame(search_random.cv_results_)\n", + "\n", + "\n", + "#get the row corresponding to the best hyperparameters\n", + "scaffold_best_idx = df_scaffold_cv_results[['mean_test_score']].idxmax().values[0]\n", + "random_best_idx = df_random_cv_results[['mean_test_score']].idxmax().values[0]\n", + "\n", + "#get the CV scores of the best hyperparameters\n", + "scaffold_split_cv_score = df_scaffold_cv_results.loc[scaffold_best_idx,df_scaffold_cv_results.columns.str.contains(\"split\")]\n", + "random_split_cv_score = df_random_cv_results.loc[random_best_idx,df_random_cv_results.columns.str.contains(\"split\")]\n", + "\n", + "#prepare dataframe for boxplot\n", + "df_cv_compare[\"score\"] = list(scaffold_split_cv_score) + list(random_split_cv_score)\n", + "df_cv_compare[\"split\"] = [\"scaffold\" for i in scaffold_split_cv_score ] + [\"random\" for i in random_split_cv_score ]\n", + "\n", + "sns.boxplot(data=df_cv_compare, x=\"split\", y=\"score\",hue=\"split\")\n", + "plt.ylabel(\"$R^2$ validation score\",fontsize=13)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "#!pip install statsmodels\n", + "from statsmodels.stats.multicomp import pairwise_tukeyhsd\n", + "thsd = pairwise_tukeyhsd(df_cv_compare.score, df_cv_compare.split)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Multiple Comparison of Means - Tukey HSD, FWER=0.05 \n", + "=====================================================\n", + "group1 group2 meandiff p-adj lower upper reject\n", + "-----------------------------------------------------\n", + "random scaffold -0.3827 0.0 -0.4249 -0.3404 True\n", + "-----------------------------------------------------\n" + ] + } + ], + "source": [ + "print(thsd)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In TukeyHSD test, if **p-adj < 0.05**, there is a **statistically significant difference**. \n", + "\n", + "In real world scenario, the new compounds to be evaluated will likely contain different scaffolds from that of the training set.\n", + "\n", + "Now, let's compare the model performance on unseen scaffolds, i.e. our **test set**." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y_pred_random = search_random.best_estimator_.predict(x_test)\n", + "r2_random = r2_score(y_test,y_pred_random)\n", + "\n", + "sns.scatterplot(x=y_test, y=y_pred_scaffold,color='b',label=f\"Scaffold split, Test $R^2$={r2_scaffold:.2f}\")\n", + "sns.scatterplot(x=y_test, y=y_pred_random,color='r',label=f\"Random split, Test $R^2$={r2_random:.2f}\")\n", + "plt.plot(y_test,y_test,color='g')\n", + "\n", + "plt.xlabel(\"Experimental\")\n", + "plt.ylabel(\"Predicted\")\n", + "plt.legend(fontsize=12)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "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", + "
split typevalidation scoretest score
0scaffold0.2932150.43378
1random0.6608200.43378
\n", + "
" + ], + "text/plain": [ + " split type validation score test score\n", + "0 scaffold 0.293215 0.43378\n", + "1 random 0.660820 0.43378" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_cv_test = pd.DataFrame()\n", + "df_cv_test[\"split type\"] = [\"scaffold\",\"random\"] \n", + "df_cv_test[\"validation score\"] = [scaffold_split_cv_score.median(),random_split_cv_score.median()] \n", + "df_cv_test[\"test score\"] = [r2_scaffold,r2_random]\n", + "df_cv_test" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Take aways\n", + "\n", + "In this example, the model trained via scaffold splits tends to have better generalizability on unseen scaffolds.\n", + "\n", + "Moreover, the discrepancy between the validation and test score is higher in random splits than in scaffold splits.\n", + "\n", + "Based on this result, scaffold splits can potentially:\n", + "- give **a more realistic estimation of model performance than the default random splits**\n", + "- **help mitigate overfitting** during hyperparameter optimization\n", + "\n", + "Although this outcome could highly depend on the data itself (as well as the arbitrary random states), this notebook shows the advantage of using scaffold splits, which has now a **convenient implementation in scikit-mol**. :)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "scikit_mol", + "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.13.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 1fe93aeb0ad8ae43cd8bcacc529ab7a3753c02b2 Mon Sep 17 00:00:00 2001 From: batukav Date: Fri, 18 Jul 2025 15:43:31 +0200 Subject: [PATCH 17/17] rename the notebook --- .../notebooks/scaffold_split_planning.ipynb | 1091 ----------------- 1 file changed, 1091 deletions(-) delete mode 100644 scikit_mol/notebooks/scaffold_split_planning.ipynb diff --git a/scikit_mol/notebooks/scaffold_split_planning.ipynb b/scikit_mol/notebooks/scaffold_split_planning.ipynb deleted file mode 100644 index 30d544d..0000000 --- a/scikit_mol/notebooks/scaffold_split_planning.ipynb +++ /dev/null @@ -1,1091 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# import the usual suspects\n", - "import os\n", - "import rdkit\n", - "from rdkit import Chem\n", - "import pandas as pd\n", - "from time import time\n", - "import numpy as np\n", - "import sys\n", - "sys.path.append('..')\n", - "from conversions import MolToScaffoldTransformer\n", - "import matplotlib.pyplot as plt\n", - "import time" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Scaffold split planning" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## personal notes/tests to understand the concepts ##" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### import dataset ###" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "csv_file = \"../../tests/data/SLC6A4_active_excapedb_subset.csv\"\n", - "data = pd.read_csv(csv_file)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "data.head()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "transformer = MolToScaffoldTransformer()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "mols = transformer.transform(data['SMILES'])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "data['scaffolds'] = mols.reshape(len(mols))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "data['scaffold_smiles'] = transformer._create_smiles_from_mol()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "data['scaffold_ids'] = transformer.get_unique_scaffold_ids()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "data['scaffold_ids'].head()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "len(data['scaffold_ids'].unique())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "data['scaffold_smiles']" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "## scaffold split ##" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.model_selection._split import GroupShuffleSplit\n", - "\n", - "# Question: \n", - "X = data['Ambit_InchiKey']\n", - "y = data['SMILES'] # some random label, does not matter\n", - "groups = data['scaffold_smiles']\n", - "gss = GroupShuffleSplit(n_splits=1, test_size=0.2, random_state=42)\n", - "train_idx, test_idx = next(gss.split(X, y, groups=groups))\n", - "\n", - "X_train, X_test = X[train_idx], X[test_idx]\n", - "y_train, y_test = y[train_idx], y[test_idx]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "set(groups[train_idx]).intersection(set(groups[test_idx]))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Do we need another train_test_split function? \n", - "# seems like there's a discussion here\n", - "# https://github.com/scikit-learn/scikit-learn/issues/9193" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.model_selection import StratifiedGroupKFold, BaseCrossValidator, GroupShuffleSplit,StratifiedShuffleSplit" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### train_test_split example ####" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "train_inds, test_inds = next(GroupShuffleSplit().split(X, y, groups))\n", - "X_train, X_test, y_train, y_test = X[train_inds], X[test_inds], y[train_inds], y[test_inds]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "X_train" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "y_train" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "set(groups[train_inds]).intersection(set(groups[test_inds]))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### stratifiedgroupkfold ####" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "X = data['Ambit_InchiKey']\n", - "y = data['pXC50'].astype(int) # some random label, does not matter\n", - "groups = data['scaffold_smiles']\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "sgkf = StratifiedGroupKFold(n_splits=3, shuffle=True, random_state=42)\n", - "for i, (train_index, test_index) in enumerate(sgkf.split(X, y, groups)):\n", - "\n", - " print(f\"Fold {i}:\")\n", - " print(f\"Train: index=\\n{train_index}\")\n", - " print(f\"group=\\n{groups[train_index]}\")\n", - " print(f\"Test: index=\\n{test_index}\")\n", - " print(f\"group=\\n{groups[test_index]}\")\n", - " assert(len(set(groups[train_index]).intersection(set(groups[test_index]))) == 0)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "sgkf = StratifiedGroupKFold(n_splits=3, shuffle=False)\n", - "for i, (train_index, test_index) in enumerate(sgkf.split(X, y, groups)):\n", - "\n", - " print(f\"Fold {i}:\")\n", - " print(f\"Train: index=\\n{train_index}\")\n", - " print(f\"group=\\n{groups[train_index]}\")\n", - " print(f\"Test: index=\\n{test_index}\")\n", - " print(f\"group=\\n{groups[test_index]}\")\n", - " assert(len(set(groups[train_index]).intersection(set(groups[test_index]))) == 0)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "groups[test_index].value_counts()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### showcase ###" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "x = np.random.rand(1000)\n", - "y = np.random.randint(0,3,1000)\n", - "groups = y[np.random.permutation(len(y))]\n", - "#groups[0:90] = 0\n", - "#y[0:90] = 1" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "sss = StratifiedShuffleSplit(n_splits=5, test_size=0.2)\n", - "print(np.unique(y,return_counts=True))\n", - "for i, (train_index, test_index) in enumerate(sss.split(x, y, groups)):\n", - " y_train_counts, y_test_counts = np.unique(y[train_index], return_counts=True),np.unique(y[test_index], return_counts=True)\n", - " print([i/sum(y_train_counts[1]) for i in y_train_counts[1]])\n", - " print([i/sum(y_test_counts[1]) for i in y_test_counts[1]])\n", - " print(y_test_counts)\n", - " print(len(y[train_index]), len(y[test_index]))\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# groups are splitted, stratification is not granted, exact test_size is not respected, fails quite miserably for imbalanced data\n", - "sss = GroupShuffleSplit(n_splits=5, test_size=0.2)\n", - "print(np.unique(y, return_counts=True))\n", - "print(np.unique(groups, return_counts=True))\n", - "for i, (train_index, test_index) in enumerate(sss.split(x, y, groups)):\n", - " y_train_counts, y_test_counts, groups_train_counts, groups_test_counts = np.unique(y[train_index], return_counts=True),np.unique(y[test_index], return_counts=True),np.unique(groups[train_index], return_counts=True),np.unique(groups[test_index], return_counts=True)\n", - " print(f\"Train: {y_train_counts}\")\n", - " print(f\"Test: {y_test_counts}\")\n", - " print(f\"Train groups: {groups_train_counts}\")\n", - " print(f\"Test groups: {groups_test_counts}\")\n", - " print(len(y[train_index]), len(y[test_index]))\n", - " print(len(set(groups[train_index]).intersection(set(groups[test_index]))))\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "sss = StratifiedGroupKFold(n_splits=5)\n", - "groups_counts = np.unique(groups, return_counts=True)\n", - "print(groups_counts)\n", - "for i, (train_index, test_index) in enumerate(sss.split(x, y, groups)):\n", - " y_train_counts, y_test_counts, groups_train_counts, groups_test_counts = np.unique(y[train_index], return_counts=True),np.unique(y[test_index], return_counts=True),np.unique(groups[train_index], return_counts=True),np.unique(groups[test_index], return_counts=True)\n", - " print(f\"Train counts: {y_train_counts}\")\n", - " print(f\"Test counts: {y_test_counts}\")\n", - " print(f\"Groups train counts: {groups_train_counts}\")\n", - " print(f\"Groups test counts: {groups_test_counts}\")\n", - " print(len(y[train_index]), len(y[test_index]))\n", - " print(len(set(groups[train_index]).intersection(set(groups[test_index]))))\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "sss = StratifiedGroupKFold(n_splits=5, shuffle=True, random_state=65)\n", - "groups_counts = np.unique(groups, return_counts=True)\n", - "print(groups_counts)\n", - "for i, (train_index, test_index) in enumerate(sss.split(x, y, groups)):\n", - " y_train_counts, y_test_counts, groups_train_counts, groups_test_counts = np.unique(y[train_index], return_counts=True),np.unique(y[test_index], return_counts=True),np.unique(groups[train_index], return_counts=True),np.unique(groups[test_index], return_counts=True)\n", - " print(f\"Train counts: {y_train_counts}\")\n", - " print(f\"Test counts: {y_test_counts}\")\n", - " print(f\"Groups train counts: {groups_train_counts}\")\n", - " print(f\"Groups test counts: {groups_test_counts}\")\n", - " print(len(y[train_index]), len(y[test_index]))\n", - " print(len(set(groups[train_index]).intersection(set(groups[test_index]))))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## StratifiedGroupShuffleSplit ##" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import time\n", - "from collections import defaultdict\n", - "from sklearn.model_selection._split import BaseShuffleSplit\n", - "from sklearn.utils.validation import _num_samples\n", - "from sklearn.utils import check_random_state\n", - "class StratifiedGroupShuffleSplit(BaseShuffleSplit):\n", - " \"\"\"Stratified ShuffleSplit cross-validator with non-overlapping groups.\"\"\"\n", - "\n", - " def __init__(self, n_splits=5, *, test_size=0.2, train_size=None, random_state=None):\n", - " super().__init__(\n", - " n_splits=n_splits,\n", - " test_size=test_size,\n", - " train_size=train_size,\n", - " random_state=random_state,\n", - " )\n", - "\n", - " def _iter_indices(self, X, y, groups):\n", - " if y is None:\n", - " raise ValueError(\"StratifiedGroupShuffleSplit requires 'y' for stratification.\")\n", - "\n", - " n_samples = _num_samples(X)\n", - " \n", - " if isinstance(self.test_size, float):\n", - " n_test = int(self.test_size * n_samples)\n", - " else:\n", - " n_test = int(self.test_size)\n", - "\n", - " unique_groups, group_indices = np.unique(groups, return_inverse=True)\n", - " n_groups = len(unique_groups)\n", - " classes, y_indices = np.unique(y, return_inverse=True)\n", - " n_classes = len(classes)\n", - " overall_class_counts = np.bincount(y_indices, minlength=n_classes)\n", - "\n", - " group_info = defaultdict(lambda: {\n", - " \"class_counts\": np.zeros(n_classes, dtype=int),\n", - " \"indices\": [],\n", - " \"size\": 0\n", - " })\n", - " for i, group_idx in enumerate(group_indices):\n", - " class_idx = y_indices[i]\n", - " group_info[group_idx][\"class_counts\"][class_idx] += 1\n", - " group_info[group_idx][\"indices\"].append(i)\n", - " for i in range(n_groups):\n", - " group_info[i][\"size\"] = len(group_info[i][\"indices\"])\n", - "\n", - "\n", - " rng = check_random_state(self.random_state)\n", - "\n", - " for _ in range(self.n_splits):\n", - " available_groups = list(range(n_groups))\n", - " test_groups = []\n", - " \n", - " current_test_size = 0\n", - " current_test_counts = np.zeros(n_classes, dtype=int)\n", - "\n", - " # Phase 1: Greedily add only \"safe\" groups that do not exceed n_test\n", - " while available_groups:\n", - " safe_candidates = []\n", - " for group_idx in available_groups:\n", - " group_data = group_info[group_idx]\n", - " if current_test_size + group_data[\"size\"] <= n_test:\n", - " prospective_counts = current_test_counts + group_data[\"class_counts\"]\n", - " prospective_size = current_test_size + group_data[\"size\"]\n", - " ideal_counts = overall_class_counts * (prospective_size / n_samples)\n", - " error = np.sum((prospective_counts - ideal_counts) ** 2)\n", - " safe_candidates.append({'error': error, 'id': group_idx})\n", - "\n", - " if not safe_candidates:\n", - " # No more groups can be added without overshooting\n", - " break\n", - " \n", - " safe_candidates.sort(key=lambda x: x['error'])\n", - " pool_size = min(5, len(safe_candidates))\n", - " candidate_pool = [cand['id'] for cand in safe_candidates[:pool_size]]\n", - " best_group = rng.choice(candidate_pool)\n", - "\n", - " test_groups.append(best_group)\n", - " available_groups.remove(best_group)\n", - " group_data = group_info[best_group]\n", - " current_test_counts += group_data[\"class_counts\"]\n", - " current_test_size += group_data[\"size\"]\n", - "\n", - " # Phase 2: Decide if a single overshoot is better than the current undershoot\n", - " if available_groups and current_test_size < n_test:\n", - " overshoot_candidates = []\n", - " for group_idx in available_groups:\n", - " group_data = group_info[group_idx]\n", - " prospective_size = current_test_size + group_data[\"size\"]\n", - " # We only care about the size difference now\n", - " overshoot_candidates.append({'id': group_idx, 'size': prospective_size})\n", - "\n", - " if overshoot_candidates:\n", - " # Find the group that causes the smallest overshoot\n", - " overshoot_candidates.sort(key=lambda x: x['size'])\n", - " best_overshoot_group = overshoot_candidates[0]\n", - " \n", - " undershoot_error = n_test - current_test_size\n", - " overshoot_error = best_overshoot_group['size'] - n_test\n", - "\n", - " if overshoot_error < undershoot_error:\n", - " # If overshooting is closer to the target, add the group\n", - " test_groups.append(best_overshoot_group['id'])\n", - "\n", - " test_indices = np.concatenate([group_info[g_idx][\"indices\"] for g_idx in test_groups]) if test_groups else []\n", - " all_indices = np.arange(n_samples)\n", - " train_indices = np.setdiff1d(all_indices, test_indices, assume_unique=True)\n", - " \n", - " yield train_indices, test_indices\n", - " \n", - " def split(self, X, y, groups=None):\n", - " \"\"\"Generates indices to split data into training and test set.\n", - "\n", - " Parameters\n", - " ----------\n", - " X : array-like of shape (n_samples, n_features)\n", - " Training data, where `n_samples` is the number of samples\n", - " and `n_features` is the number of features.\n", - "\n", - " y : array-like of shape (n_samples,), optional\n", - " The target variable for supervised learning problems.\n", - " Stratification is done based on the y labels.\n", - "\n", - " groups : array-like of shape (n_samples,), optional\n", - " Group labels for the samples used while splitting the dataset into\n", - " train/test set. Each group will be kept together in either the\n", - " train set or the test set.\n", - "\n", - " Yields\n", - " ------\n", - " train : ndarray\n", - " The training set indices for that split.\n", - "\n", - " test : ndarray\n", - " The testing set indices for that split.\n", - " \"\"\"\n", - " yield from self._iter_indices(X, y, groups)\n", - "\n", - " def get_n_splits(self, X=None, y=None, groups=None):\n", - " return self.n_splits\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "==================== Running Test: BALANCED Dataset ====================\n", - "\n", - "Checking if indices are reproducible with the same random state\n", - "SUCCESS: Train indices are reproducible.\n", - "SUCCESS: Test indices are reproducible.\n", - "\n", - "Checking for group overlap...\n", - "SUCCESS: No overlapping groups found between train and test sets.\n", - "\n", - "Dataset Sizes and Ratios:\n", - " - Train set size: 7031 (70.31%)\n", - " - Test set size: 2969 (29.69%)\n", - "\n", - "Class Distribution Ratios:\n", - " - Full Dataset:\n", - " - Class 0: 25.00%\n", - " - Class 1: 25.00%\n", - " - Class 2: 25.00%\n", - " - Class 3: 25.00%\n", - " - Train Set:\n", - " - Class 0: 25.03%\n", - " - Class 1: 25.05%\n", - " - Class 2: 24.90%\n", - " - Class 3: 25.02%\n", - " - Test Set:\n", - " - Class 0: 24.92%\n", - " - Class 1: 24.89%\n", - " - Class 2: 25.23%\n", - " - Class 3: 24.96%\n", - "\n", - "Generating class distribution histograms...\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "==================== Running Test: IMBALANCED Dataset ====================\n", - "\n", - "Checking if indices are reproducible with the same random state\n", - "SUCCESS: Train indices are reproducible.\n", - "SUCCESS: Test indices are reproducible.\n", - "\n", - "Checking for group overlap...\n", - "SUCCESS: No overlapping groups found between train and test sets.\n", - "\n", - "Dataset Sizes and Ratios:\n", - " - Train set size: 7035 (70.35%)\n", - " - Test set size: 2965 (29.65%)\n", - "\n", - "Class Distribution Ratios:\n", - " - Full Dataset:\n", - " - Class 0: 90.00%\n", - " - Class 1: 4.00%\n", - " - Class 2: 3.00%\n", - " - Class 3: 3.00%\n", - " - Train Set:\n", - " - Class 0: 89.99%\n", - " - Class 1: 4.01%\n", - " - Class 2: 2.99%\n", - " - Class 3: 3.01%\n", - " - Test Set:\n", - " - Class 0: 90.02%\n", - " - Class 1: 3.98%\n", - " - Class 2: 3.04%\n", - " - Class 3: 2.97%\n", - "\n", - "Generating class distribution histograms...\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABv4AAAHgCAYAAABtiBpNAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAdQJJREFUeJzs3XdcVvX///EnG5ThBDRREXNrKu6FJko5cpBpaaJZWjmzsvp8ytUwrTTNlZaj0m9TbZl77z0z03JUzlTACQjv3x/8uD5cAooIXHp43G83bsk573PO61zXuS5eXc/rnONkjDECAAAAAAAAAAAAcE9zdnQBAAAAAAAAAAAAAO4cwR8AAAAAAAAAAABgAQR/AAAAAAAAAAAAgAUQ/AEAAAAAAAAAAAAWQPAHAAAAAAAAAAAAWADBHwAAAAAAAAAAAGABBH8AAAAAAAAAAACABRD8AQAAAAAAAAAAABZA8AcAAAAAAAAAAABYAMEfAABALlq6dKl69uypcuXKydfXVx4eHipWrJhatGihcePG6ezZs3bjZ82aJScnJ/Xo0cMxBWeTo0ePysnJye7HxcVFBQoUUJkyZdS2bVu98847Onbs2E3Xk7Ls3SBln0qXLp1m3t1UZ4rSpUvLyclJR48edXQpmbJ582Y999xzqly5sgoUKCB3d3f5+/srLCxMb731lo4fP+7oEu85d+NxmV1eeOEFOTs7a9u2bXbTe/TokavvoSnbmzVrVq5sr2nTpnJyctKqVatyZXt3u6y8z6U8Z6l/vLy8FBAQoNq1a6t379764YcfdP369Zwr3KKefvppubq6au/evY4uBQAAIE8h+AMAAMgF//77r1q0aKGWLVtq1qxZSkhIULNmzRQZGamKFStqw4YNGjx4sMqUKaPNmzc7utwcFRkZqaioKD355JNq3ry5AgMDtWzZMv33v/9VcHCwnn32WV26dCnHtn+zwO5eldthQ066cuWKnnjiCdWrV09Tp07V+fPn1ahRI3Xq1Ek1atTQnj179MYbb+j+++/XggULHF0u7gIHDhzQxIkTFRkZqVq1ajm6HNyjQkJCFBUVpaioKNuxdObMGU2fPl3t2rVT2bJltXz58mzd5r32hYzUVq1aJScnJzVt2jTDMcOHD5ebm5sGDBiQe4UBAABAro4uAAAAwOpiYmLUqFEjHTx4UBUqVNC0adPUuHFjuzFxcXGaPXu2hg0bppMnTzqo0tzx/vvvpwndrl69qpkzZ+rVV1/Vxx9/rF9//VVLly6Vh4eH3bgDBw7kYqU3d9999+nAgQNyc3NzdCmZsnz5ciUkJOi+++5zdCkZSkhIUEREhNatW6dixYpp6tSpeuSRR+zGXL9+XfPnz9d//vOfe/LDcke6m14/2enll1/W9evXNXz4cEeXgntYo0aN0v3yxO7du/Xqq69q0aJFioiI0Pz589W2bdvcL/AeVKJECT399NOaOHGifvjhhzTv5wAAAMgZnPEHAACQw/r376+DBw+qdOnSWr9+fZrQT5I8PDzUu3dv7dq1SxUrVnRAlY7l5eWl559/XqtWrZKnp6fWrl2rMWPGpBlXoUIFVahQwQEVpuXm5qYKFSooJCTE0aVkSkhIiCpUqHBXB5Vvvvmm1q1bpwIFCmj9+vXpfkjs6uqqTp06aefOnQoLC3NAlfeuu+n1k11+//13LVy4UPXq1VPlypUdXQ4s6IEHHtDChQvVuXNnJSYmKioqSrGxsY4u657Rq1cvSdKHH37o2EIAAADyEII/AACAHPTnn39q7ty5kqSxY8eqUKFCNx0fEBCg8uXLZ2rd8+bN09NPP60qVaqoYMGC8vT0VHBwsJ566ikdPHgw3WXi4uL03nvvKTQ0VD4+PnJ3d1dgYKBq166tIUOG6Pz583bjDx06pKeeekrBwcHy8PCQt7e3SpUqpdatW2vmzJmZqvN21KxZU/3795ckjRs3Ls09lTK6R9nJkyc1cOBAlStXTp6ensqXL5+CgoLUvHlzvf/++7ZxPXr0UHBwsCTp2LFjae7rlGL48OFycnLS8OHDdfz4cfXq1UtBQUFyc3Oz3Ssss5cMnT59ukJDQ5U/f34VKFBArVq10qZNm9Ide6t7sN14P6+UGmbPni1J6tmzp93+pD4D6maXlLty5Yreffdd1axZUz4+PsqXL58qV66s119/XRcuXEgzPvW+G2M0bdo02z76+fmpZcuW2rhx400flxtdvHhR48ePlyQNHTrU9jxlxNvbWzVq1EgzffHixWrTpo38/f3l7u6u4sWLq3Pnzmnu/ZYi9WO6adMmtW7dWoULF5aPj4/CwsK0du1a29hFixapefPmKliwoLy9vdWiRQvt2LEjzTpTPz7Xr1/XmDFjVLlyZXl5ealIkSJ67LHH9Ntvv6Vbz5YtWzRkyBDVqVNHgYGBcnd3V0BAgNq2batly5alu0zqe4GeP39egwYNUkhIiDw8POwuw3enr58b63zsscdUvHhx2/0X27Ztq6VLl6Y7PvXlaI8cOaInn3xSgYGB8vDwUEhIiF5//XXFxcWlu+zNTJo0ScaY276HX+rLFMbFxWnEiBG2/S9ZsqReeeUVXbt2TVLyWdsvvfSSypQpI09PT5UuXVrDhw+/5T3fdu/erY4dO6po0aLy8vJStWrVNH78eCUmJqYZe/HiRU2fPl0dO3bU/fffr/z58yt//vyqWrWq/vvf/yo6Ovq29u/s2bOaMGGCWrVqpeDgYHl5ecnX11e1atXS6NGjbft2o9THyHfffadGjRrJ19dX+fPnV8OGDbVw4cIMt3n9+nXNmDFD4eHhKlKkiDw8PFSiRAmFh4fro48+SneZ5cuXq2PHjipWrJjtOOrQocNN3z9+/fVXderUSUWKFJGXl5eqVKmi999/P93HNbs4OTlp0qRJ8vLy0oULFzR9+nS7+bf7eKe8ZlPuaxscHGz33p36no258bdeSj7z/oMPPlC9evVUoEABeXp6qnz58hoyZIjOnTtnN7Zp06Zq1qyZJGn16tV2td/4N7F69ep64IEHtHLlSsuedQwAAHDXMQAAAMgx48ePN5JMgQIFzPXr1297+ZkzZxpJJioqKs08FxcXky9fPlOrVi3TsWNH88gjj5gyZcoYSSZ//vxm/fr1duMTExNN8+bNjSTj6+trHn74YfP444+b8PBwU6pUKSPJ7Ny50zZ+7969xtfX10gy5cuXNx07djSdOnUy9evXN97e3uaBBx7I9H4cOXLESDKSzJEjR246dvfu3baxGzdutJuXMj21kydPmuLFixtJpmTJkqZdu3amc+fOpnHjxqZQoULGz8/PNnb69OkmMjLS9hhFRUXZ/aQYNmyYkWSeeOIJU6hQIRMYGGgiIyNNx44dzYsvvmi3T6VKlUqzDyl1vvDCC8bJyck0atTIPP7446ZKlSpGknF1dTXz5s3LcLmMhIWFGUlm5cqVxhhjzp49a6KiokxISIiRZBo2bGi3P/Pnz7ctm/Ic3/j4nzt3zlSvXt12XDzyyCMmMjLSFClSxEgywcHBaZZJve9RUVHGzc3NPPjgg+axxx4z5cqVM5KMh4eH2bRpU4b7cqPvv//eSDJOTk7m33//zfRyqb3++uu2dTRs2NA8/vjjtn1zcXExn376aZplUh7Tl156ybi6upoaNWqYzp0725bz8PAw69evNxMnTjTOzs6mQYMGdvvp7e1tDh06lOHj07FjR+Pm5mbCw8NNly5dbK9Rb29vs2HDhjT1NG/e3Dg7O5uqVauaVq1amU6dOpmaNWvajo0PP/wwzTIp7xOtW7c2wcHBpmDBguaRRx4xnTp1Ml27drWNu9PXT4pp06YZZ2dnI8nUqFHDPP7446ZBgwa29Q8fPjzNMlFRUUaSGThwoPH19TWlSpUyjz32mAkPDzdeXl5Gkmnfvn2Gz21GSpYsaSSZw4cPpzs/Zbs3voeuXLnSSDL169c3YWFhtmO/TZs2xs/Pz0gybdq0MefOnTPly5c3RYsWNZGRkaZly5bG09PTSDLPPvtshtt77rnnjKenpyldurTp3LmzadmypXF3dzeSzKOPPmqSkpLsllu7dq2RZIoWLWoaNWpkW6Zw4cJGkilbtmy6r4sb3xNSfP7550aSue+++0xYWJjp0qWLad68ufH29rbt97Vr19KsL+U5HDp0qO111LlzZ/PAAw/YXlvpvXdFR0ebRo0aGUnGzc3NhIWFmccff9w0a9bMFC1aNN33tRdffNFIMs7OzqZOnTqmU6dOpm7dusbJycm4uLiYGTNmpFlm7dq1Jn/+/EaSKVOmjOnSpYsJDw83bm5uJjIyMsP3uZvJ6BhJT4cOHYwkExERYTf9dh/vtWvXmqioKNu+REZG2r13HzhwwDY2p//WG2PMP//8Y6pWrWokmUKFCpnw8HDToUMH2/jSpUubo0eP2saPGjXKREREGEkmICDArvaUv5GpvfTSS0aSeeedd275GAMAAODOEfwBAADkoCeffNJIMg8++GCWlr9Z8Pfll1+aS5cu2U1LSkoykyZNMpJM5cqV7T5cXr16te2D+tjY2DTr27p1q90Hyz179jSSzFtvvZVm7JUrV8zq1aszvR+3E/wlJibaPiD/5JNP7OalF1yMGDHCSDK9e/dO82F6fHy8WbZsWbq1pBfYpUgJ/iSZbt26pfsBeWaCPy8vL7N8+XK7eWPGjDGSjJ+fnzl9+vQt9y+1jD7kT/ngeubMmRkum9EH4p07dzaSTN26de2e/4sXL5qHH37YSDINGjRId99T9v/gwYO2edevXzdPPfWUkWRatmyZYT03euONN2wf5mfFL7/8YiQZT09Ps2TJErt5n3zyiS2Q2Ldvn928lMfUycnJfP7553bzBg8ebAu+vb297Y6l69ev20Lkp59+2m651I9PkSJFzO7du+2W69+/v+2xu/HYWrhwoTlx4kSa/duwYYPx9fU1bm5u5u+//7abl/I+Ick0b97cxMTEpPsYZcfrZ8+ePcbV1dU4OTmZzz77LE3tKa/dG5+DlGNUkvnvf/9r90WIvXv32gKQ9MLQjBw+fNgWlmXkVsGfJFOnTh27Y//o0aOmYMGCRpKpWrWqadu2rbl8+bJt/tatW42rq6txdnY2x44dy3A/n3/+eZOQkGCbt2/fPlsINnXqVLvl/vrrL7Ns2TKTmJhoN/3y5cume/futvXdKKP3hF9//TXNFyeMMeb8+fOmZcuWRpIZM2ZMmvkptRcoUCBNcJ/yvliuXLk0y3Xs2NH29+XG95iEhASzYMECu2nTpk2zBZqpXx/GJP+t8vHxMe7u7ub333+3Tb969aoJCgoyksygQYPsjqHdu3fbvqyQk8HfW2+9ZSSZEiVK2E3P6uOdmaAyp//WJyUlmYYNGxpJplevXnbLJCQk2ALaZs2a2a0n5TUUFhaWYe0p5s2bZ3t/AgAAQM4j+AMAAMhBDz30kJFkunTpkqXlbxb83Uz9+vWNJLN//37btK+//tpIMgMGDMjUOlq1amUkmR07dtzWttNzO8GfMcYEBgYaSWb06NF209MLLp5//nkjKd2zUG5WS2aCv0KFCpno6OjbXk9KnYMGDUp32Vq1ahlJ5u233053uYxkd/B37Ngx4+zsbJycnNJ8+G6MMX///bft7KbUZ5Wkfj5/+OGHNMudPHnSSMlny8XHx2dYU2rPPvuskWTq1auXqfE3SjnDZfDgwenOb9OmjZFknnnmGbvpKY9pp06d0ixz7tw5236+/PLLaeZv377dSMlnRaaW+vFJ7wy9a9eumfvuu89IMnPmzMn0Pr722mtGkpk0aZLd9JT3CTc3N/PHH39kuHx2vH569eplJJmOHTumO79fv35GkmnRooXd9JRjNDQ0NE3AaMz/nv+RI0dmqg5jjPnmm2+MJNOkSZMMx9wq+HNycjJ79+5Ns9yAAQOMlHxm5o0BvTHGtG3b1kgys2fPTnd7xYoVM1evXk2z3EcffWQkmfvvvz+Te5kc/rm6uqYbcGb0nnAzBw8eNJJM7dq108xLOUYmTJiQZt61a9dsZ0MeP37cNn3Xrl220P3GUDo9iYmJtrNMt23blu6YlC9IpD577IsvvjCSTFBQULrvK+PGjcvx4G/q1Km2L3Vk1s0e76ycoZhadvytT/nSRPXq1e2C6hSJiYm2s9VTv1ZuJ/hLeQwKFiyYqZoAAABwZ1wFAACAe9bhw4e1aNEiHT58WBcvXrTd4+j06dOSpIMHD6pSpUqSku+f5+LiohkzZqhcuXK2+yplpE6dOlq4cKGee+45jRgxQmFhYfL09Mz5nZKUlJQkSTe9312KOnXqaPLkyXr11VdljFHLli3l7e2dLXWEh4fLz88vy8tHRUWlO7179+7atm2bVq1apf/85z9ZXv+dWrNmjZKSklSzZk1Vq1Ytzfz77rtPERER+v7777Vy5Uo1aNDAbr6rq6seeuihNMsFBgaqYMGCunDhgs6dO6fAwMAc2wcp+d5i69evl6QM7/XWq1cv/fTTT1q5cmW681u1apVmWqFChVS4cGGdO3cu3fn333+/JOnEiRMZ1pbeMeDh4aHOnTtr7NixWrVqlZ544gm7+efOndPPP/+sffv26cKFC0pISJCUfM9NSRne16tGjRoqU6ZMhrWk53ZfPyn3HrvZ4zxx4kStXbtWiYmJcnFxsZvfpk2bdF/XFStWlCT9888/ma495X2ucOHCmV7mRiVLllSVKlXSTE95bkNDQ+Xv75/h/Iye+8ceeyzd98uoqCj1799fhw4d0okTJ1S8eHG7+Rs2bNDatWt1/PhxXblyRcYYSZK7u7vOnj2rCxcuqGDBgpnat8TERK1atUobNmzQyZMndfXqVZnkL/9Kyvg4kqS2bdummebh4aEyZcpo586d+ueffxQUFCQp+d6XktS6dWvdd999t6xr586dOnHihEJCQhQaGprumJR7U27YsME2LeXYe+yxx+Tm5pZmmaioKL3wwgu33P6duNnfpjt5vG8lJ//W//zzz5KkyMhIubqm/YjI2dlZTZo00b59+7Rhw4Z0Xy+3kvIavXDhguLj4+Xu7n7b6wAAAEDmEfwBAADkoKJFi0qSzpw5k63rTUxMVL9+/fTxxx/bPlRMT2xsrO3fISEhGjdunF5++WX169dP/fr1U6lSpVS/fn21adNGnTp1svsw7uWXX9a6deu0bNkyPfTQQ3Jzc9MDDzygJk2aqEuXLqpdu3a27lPqfYuOjpaUHLzcypNPPqmlS5dqzpw5ioyMlIuLiypVqqRGjRrp0Ucf1YMPPpjlWkqXLp3lZSUpODj4ptP//vvvO1r/nUoJWTKqU0o+blKPTa1YsWLpfgAvSb6+vrpw4YKuXbuWqVru5LVy7tw523Yy2peb7YeUHAClx9vbW+fOnUt3vo+PjyQpLi4u3WULFCigAgUKpDsvo2Ng+vTpeuGFF3T58uV0l5PsX9epZeV4vd3Xz62OmZTH+dq1azp37lya0Cyjx9nX19e2XGbFxMTYLZsVN3vebzY/5bnPqN6MHh8fHx9bmPz333/bgr8zZ84oMjJS69atu2m9sbGxmQr+Dh06pA4dOmj//v03XVdGbud5OnbsmCSpQoUKt6xLkv78809J0h9//HHLL3ecPXvW9u+U10pGj23BggXl5+dnOy5ywr///isp7d+mO328M5Ibf+tTno833nhDb7zxxk3rSf183I7Ur9Ho6Oh0w3QAAABkH2dHFwAAAGBlKWcz7Nixw/YN/ewwfvx4TZ06VQEBAZo7d66OHj1qd3bB448/LklpPijs37+/jh07pmnTpql79+5ycXHRl19+qW7duqlSpUo6efKkbWy+fPm0dOlSbdmyRSNHjlTz5s31+++/a+zYsapTp4769u2bbfuT2r59+xQfHy9Jqlq16i3HOzs764svvtD+/fs1ZswYtWnTRidPntSUKVPUvHlzPfLII1l+7L28vLK0XGbd7IPc9KScbXK3cHbOvv+dSHmtHDlyROfOncu29WbWrfYlO/c1tdTHwPbt29WnTx/FxcVp9OjR+vXXX3Xp0iUlJSXJGKOPP/44zTKpZeV4zcnXT0bbyy4poWpWApUUjnreJfvn8emnn9a6detUv359LVmyRKdPn1Z8fLztPT3ljK3Mvmc8+uij2r9/v9q0aaM1a9bo33//ta0vo6A6tZzc75T3scDAQEVFRd30p127djlWR1bs2LFDUtq/TXf6eGckN/7WpzwfjRo1uuXzUbly5SztR+owNrNnrAIAACDrOOMPAAAgB7Vp00aDBw9WdHS0fvjhB3Xo0CFb1vv1119Lkj7++GM98sgjaeanXBIwPQEBAXrmmWf0zDPPSJJ+++03PfXUU9q4caNeffVVzZ4922587dq1bWf3Xb9+XQsWLFD37t01efJkPfroo2rWrFm27FOKL774QlLypcEyugxceipVqqRKlSrp5ZdfljFGK1as0BNPPKEff/xRn332mXr27JmtdWbGkSNHVL169TTTjx49KkkqUaKE3XQ3NzclJCTo4sWLtjOKUks5sya7pFyWL+WMj/SkzMvMJfzuRLNmzeTj46OLFy/qs88+u61L9hUuXFgeHh6Ki4vTn3/+me5lS3NrP1KLjo5WdHR0umf9pXcMfPPNNzLGqH///hoyZEiaZW72ur5TmX393Hffffrjjz/0559/pnvJv5TH2dPTM1Nn7N6JlLOGHBEU38qRI0fSnX7x4kVbvSnP/eXLl7Vw4UI5Oztr4cKFaY6Xy5cv69SpU5ne9m+//aY9e/bI399f8+fPT3P5xuw+jlLODvztt98yNT7lEqGFCxfWrFmzMr2dlNduymvnRtHR0Tl+tt/ixYslSS1btrRNz8nHOzf+1qc8H+3atdNLL72U5VpvJuWYL1iwYIZniQMAACD7cMYfAABADgoJCbF9I//FF1/U+fPnbzr+zJkzmboPUMp6SpUqlWbe/v37tWvXrkzXWKFCBb3yyiuSdMvlXF1d9eijjyoiIiJT42/Xjh07NHHiREnS4MGD09wfLLOcnJzUvHlz273TUteZcomz69ev31mxmfD555/fdHrKfaxSpHywfeDAgTTL7NmzR3/99Ve668vqPjVp0kTOzs7atWuXdu/enWb+yZMnbffvyu6A90a+vr4aMGCAJGnkyJEZBicpLl26pJ07d0pKPi4bNWokSRkGCTNmzJCU8/txo/SOgfj4eH311VeS7I+Bm72ur127pu+++y5nirzBzV4/KfXe6nFu3LhxuvcLy041a9aUlP7rxdG++eabdM/0SjkeypYta3u9x8TEKDExUb6+vumGxF988cVtnR2cchwVL1483ecg5csV2SXlPp8LFy686f0uU9SuXVtFihTRr7/+etNLY94oLCxMUnIYlnLfy9Q+++yzTK/rdhlj1K9fP129elWFChVSr169bPPu5PG+1Xt3bvytf/jhhyX974sHmXU7f3f27dsnSbf1ZR4AAABkHcEfAABADvvoo49UtmxZHTlyRI0aNUr3Hk7x8fGaMWOGatSokakPsStWrChJmjRpkt3lH0+ePKnu3bun+0HcihUrtHDhwjQfmBpj9NNPP0my/3Bx8uTJ6YaQp06d0rZt29KMvxNXr17VlClT1LRpU127dk1NmzbN9JkHn332mbZv355m+sWLF7Vq1ao0dRYtWlTu7u46derULYPYOzVlyhRbDSnGjRunLVu2yMfHx+7DY0kKDw+XJI0YMcIuNDh69KiioqIy/FA25cyh2/kQXUo+U6dTp04yxqhPnz52Z05dvnxZvXv31rVr19SgQQM1aNDgttadFUOHDlWDBg0UHR2tRo0a6ccff0wzJjExUfPnz1doaKhWr15tm/7iiy9KSn7Mly9fbrfMrFmz9MMPP8jNzU0DBw7M2Z24wZtvvmn70FtKvqzeK6+8or///ltBQUGKjIy0zUt5Xc+ePVsXL160Tb927Zqef/75W4ahWXG7r5+BAwfK1dVVCxYsSBNoLFmyxHY50pw6cyi1MmXKqGTJkjp79qwOHz6c49u7HSdOnNBLL71kd5nUAwcOaOTIkZJkd0ZrQECAChYsqOjo6DRB8aZNm/Taa6/d1rbLlSsnFxcX7d27N837z48//qhx48bd5t7cXPXq1dWuXTtdvXpV7dq10/Hjx+3mX79+XT/88IPtdzc3Nw0bNkzGGHXo0CHdv4mJiYlasWKFNm3aZJv26KOP6r777tPx48f12muv2f3t27dvn956661s3a8Ue/bsUatWrfTVV1/JxcVFX3zxhd0Z2XfyeN/qvTs3/ta3a9dOtWvX1pYtW9SzZ8907+N34cIFTZ061W57KbUfOnQo3SA2tQ0bNkjSHd1zFwAAAJnHpT4BAAByWMGCBbV+/Xp17txZq1atUuPGjRUcHKxq1aopX758On36tLZs2aJLly7J19dXxYsXv+U6//Of/2jRokWaPn26Vq5cqZo1ayo2NlarV69WmTJl1KFDB82fP99umT179uiFF16Qr6+vatasqeLFi+vq1avasWOHjh07Jj8/P9uH0pI0bdo09e3bV8HBwapSpYp8fX119uxZrV27VlevXtWDDz6Y7qXHbuWll16St7e3pORw6cSJE9qxY4euXbsmZ2dnPfvss3r//fdtZxPcyrx58xQVFaXixYurevXqKliwoC5cuKD169crJiZGVapUsV3qTEr+0PmRRx7Rt99+q+rVq6tRo0bKly+fJOmTTz657f25mT59+ujBBx9U48aNdd9992nfvn3au3evXFxcNGPGDAUGBtqN/89//qNvv/1WCxcuVLly5VS7dm2dPXtWW7duVcOGDdWgQQPbB6iptW/fXiNGjNCECRO0b98+BQUFydnZWY888sgtn6NJkybpt99+0+bNmxUSEqJmzZrJ1dVVq1ev1tmzZxUcHKw5c+Zk6+OSEXd3dy1evFi9evXS119/rUceeUTFihVTaGiofH19de7cOW3dulXnz5+Xh4eHgoODbcs+/PDDev311/XWW2+pRYsWatiwoUqWLKnffvtNO3bskIuLi6ZOnZrle1RlRcmSJRUaGqqaNWuqadOmKly4sLZu3ao//vhD+fPn19y5c+Xp6Wkb37NnT40fP147d+5UcHCwGjduLBcXF9trbuDAgRo/fny21ni7r5+qVatq0qRJeu655/Tkk09q3LhxqlChgo4dO6YNGzbIGKPhw4fbXQoxJ7Vv314TJkzQ0qVLVbZs2VzZZmY8++yz+uSTT/Tzzz+rbt26unDhglauXKn4+Hh16NBBzz33nG2si4uLhg4dqhdeeEHdu3fXpEmTVKZMGR0/flwbNmxQt27dtGbNmkxf6rdIkSLq16+fxo8fr+bNm6tx48YqXry4Dh48qB07dtheJ9lp5syZatWqlTZt2qT7779fDRo0UPHixXXq1Cnt3btXZ8+etfviQr9+/XT8+HG99957aty4sSpXrqyyZcvKy8tLp06d0q5duxQdHa0pU6aoXr16kpLvYTlnzhy1atVKH3zwgRYsWKDatWvr3LlzWrVqldq2bavt27dn+ZLI69atU48ePSQlh5XR0dHat2+fbX3BwcH69NNP05w1fCePd2RkpFauXKlu3bqpZcuWtvvfvfzyyypfvnyu/K13dnbWggUL1Lp1a82ePVvffvutHnjgAZUsWVLx8fH6888/tXfvXiUmJqpHjx62sxpLliypWrVqadu2bapatapq1aolT09PFSlSRO+++65dTcuWLZOku+6ejQAAAJZlAAAAkGt++eUX0717d1O2bFnj7e1t3NzcTGBgoGnRooX58MMPzblz5+zGz5w500gyUVFRada1Z88e88gjj5hixYoZT09Pc//995shQ4aY2NhYExUVZSSZmTNn2sYfPnzYDB8+3DRv3tyULFnSeHp6moIFC5pq1aqZV1991fz111926//pp5/Mc889Z2rUqGGKFi1q3N3dTYkSJUzTpk3N7NmzTXx8fKb3+8iRI0aS3Y+zs7Px9fU1pUuXNm3atDFvv/22OXbs2E3Xk7JsamvWrDGDBg0yderUMYGBgcbd3d0EBgaa+vXrm48++shcunQpzXrOnTtn+vTpY0qWLGnc3NzSrHfYsGFGkhk2bNgt96lUqVI3rXPKlCmmevXqxsvLy/j6+pqHHnrIrF+/PsP1/vrrr6Zjx46mYMGCxsPDw5QvX9689dZbJj4+3oSFhRlJZuXKlWmWmz9/vmnYsKHx8fExTk5OaeovVaqUkWSOHDmSZtnLly+bUaNGmerVq5t8+fIZT09PU7FiRfOf//zHnD9//rb2PTPby4yNGzea3r17m4oVKxpfX1/j6upqihQpYpo0aWLefvtt8/fff6e73C+//GJatWplChcubFxdXU1gYKDp1KmT2bx5c7rjb/aYZmY/0jsmUz8+CQkJ5u233zYVKlQwHh4eplChQiYyMtLs378/3fWdPXvWPP/88yYkJMR4eHiY4sWLm27duplDhw5l+H5ws/eJW9WaldePMcZs2rTJPProoyYwMNC4urqawoULm9atW5slS5akOz6996Ss7MONDh48aJycnEydOnVuut0b17ty5UojyYSFhWWpnozeI1Lv544dO0zbtm1N4cKFjYeHh6lcubIZO3asSUhISHedCxYsMA0aNDAFChQw3t7eplatWmby5MkmKSkpw+Mwo+M3KSnJfPrppyY0NNR4e3sbPz8/06hRI/Pll18aY9I/Fm42/VbbM8aYuLg4M2XKFNO4cWNToEAB29+MFi1amEmTJqW7vvXr15uuXbuaUqVKGQ8PD+Pj42PKlStn2rdvbz755JN033/27t1rOnbsaAoVKmQ8PDxMxYoVzahRo0xCQkKW3ndSnrPUPx4eHsbf39+EhoaaZ555xnz//fcZPm/GZP3xTkxMNKNGjTKVK1c2np6etnGpH9+c/luf4tq1a2bq1KmmWbNmtvdPf39/U716ddO3b1+zePHiNMscO3bMPPHEE6ZYsWLG1dU13b8LO3bsMJJMs2bNbvIsAAAAIDs5GXMbF3EHAAAAANzU0aNHFRwcrFKlSuno0aOOLsfy2rRpo59//ll79uxR1apVHV0OgFT69++viRMn6vvvv8/SVQIAAABw+7jHHwAAAADgnjVmzBi5urpqxIgRji4FQCp//fWXPvnkEzVt2pTQDwAAIBcR/AEAAAAA7lmVKlVSv3799N1332nbtm2OLgfA/zdixAglJCRk+71JAQAAcHNc6hMAAAAAshGX+gQAAAAAOArBHwAAAAAAAAAAAGABXOoTAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgD0CesWrVKjk5OWnVqlW2aT169FDp0qUdVhMAAMDd5E56o+HDh8vJySl7CwIAAAAA3BaCPwB3tVmzZsnJySndn1dffTXX6mjatKltu87OzvL19VX58uX15JNPaunSpXe07smTJ2vWrFnZU+gdOnHihIYPH65du3Y5uhQAAJBKRv3QjT+pv+CU1/z4448KCwuTv7+/8uXLpzJlyuixxx7TokWLsrS+d955RwsWLMjeIgEAgMPlZl915coVDR8+/LbWdfToUfXs2VMhISHy9PRUYGCgmjRpomHDhmWphoULF2r48OFZWhbAvcnV0QUAQGaMHDlSwcHBdtOqVKmSqzWUKFFCo0aNkiRdvnxZhw8f1rx58/TFF1/oscce0xdffCE3N7fbXu/kyZNVpEgR9ejRI5srvn0nTpzQiBEjVLp0aVWvXt3R5QAAgP/v888/t/v9s88+09KlS9NMr1ix4h1tZ/r06UpKSsrSsq+//nqufjErtffff18vv/yywsLC9Nprrylfvnw6fPiwli1bpi+//FIPPfTQba/znXfe0aOPPqr27dtnf8EAAMBhcquvkpKDvxEjRkhK/lL5rRw+fFi1a9eWl5eXnnrqKZUuXVonT57Ujh07NHr0aNu6bsfChQs1adIkwj8gDyH4A3BPePjhh1WrVi2H1uDn56du3brZTXv33Xc1YMAATZ48WaVLl9bo0aMdVB0AALCyG3uQTZs2aenSpWmm3+jKlSvKly9fpreTlS8xpXB1dZWra+7/L+b169f15ptvqkWLFlqyZEma+WfOnMn1mgAAwN0rq31Vbhg3bpwuXbqkXbt2qVSpUnbz6GkAZBaX+gRwz3Nyckr3W0ulS5fO8bPoXFxcNGHCBFWqVEkTJ05UTEyMbd7MmTP14IMPyt/fXx4eHqpUqZKmTJmSpsb9+/dr9erVtktJpHwD7Pz583rppZdUtWpVeXt7y9fXVw8//LB2796dpo6PPvpIlStXVr58+VSwYEHVqlVLc+fOtRvzzz//6KmnnlJAQIA8PDxUuXJlzZgxwzZ/1apVql27tiSpZ8+etnrulsuQAgCAm2vatKmqVKmi7du3q0mTJsqXL5/+85//SJK+//57tW7dWsWLF5eHh4dCQkL05ptvKjEx0W4dN97j7+jRo3JyctL777+vadOmKSQkRB4eHqpdu7a2bt1qt2x69/hzcnJSv379tGDBAlWpUsXWg6R3+c1Vq1apVq1a8vT0VEhIiD7++ONM3Tfw33//VWxsrBo2bJjufH9/f7vf4+LiNGzYMJUtW1YeHh4KCgrSkCFDFBcXZ1f35cuXNXv2bFtPdDdcnQEAAOSOpKQkffjhh6pcubI8PT0VEBCgPn366MKFC3bjtm3bpoiICBUpUkReXl4KDg7WU089JSm5jypatKgkacSIEbae4mZn3v3xxx8qUaJEmtBPStvTSNIvv/yixo0bK3/+/PLx8VHr1q21f/9+2/wePXpo0qRJkuwvcQrA2jjjD8A9ISYmRv/++6/dtCJFijioGnsuLi56/PHH9cYbb2jdunVq3bq1JGnKlCmqXLmyHnnkEbm6uurHH3/U888/r6SkJPXt21eS9OGHH6p///7y9vbWf//7X0lSQECAJOnPP//UggUL1KlTJwUHB+v06dP6+OOPFRYWpl9//VXFixeXlHxJrgEDBujRRx/VwIEDde3aNe3Zs0ebN2/WE088IUk6ffq06tWrZ/vwrWjRovrll1/Uq1cvxcbGatCgQapYsaJGjhypoUOHqnfv3mrcuLEkqUGDBrn6eAIAgKw7d+6cHn74YXXp0kXdunWz9RWzZs2St7e3Bg8eLG9vb61YsUJDhw5VbGys3nvvvVuud+7cubp48aL69OkjJycnjRkzRh07dtSff/55y7ME161bp3nz5un555+Xj4+PJkyYoMjISB0/flyFCxeWJO3cuVMPPfSQihUrphEjRigxMVEjR460fVh2M/7+/vLy8tKPP/6o/v37q1ChQhmOTUpK0iOPPKJ169apd+/eqlixovbu3atx48bp999/t93T7/PPP9fTTz+tOnXqqHfv3pKkkJCQW9YCAACsoU+fPpo1a5Z69uypAQMG6MiRI5o4caJ27typ9evXy83NTWfOnFHLli1VtGhRvfrqqypQoICOHj2qefPmSZKKFi2qKVOm6LnnnlOHDh3UsWNHSVK1atUy3G6pUqW0bNkyrVixQg8++OBNa/z8888VFRWliIgIjR49WleuXNGUKVPUqFEj7dy5U6VLl1afPn104sSJdC9lCsDCDADcxWbOnGkkpfuTQpIZNmxYmmVLlSploqKibL+vXLnSSDIrV660TYuKijKlSpW6ZR1hYWGmcuXKGc6fP3++kWTGjx9vm3blypU04yIiIkyZMmXsplWuXNmEhYWlGXvt2jWTmJhoN+3IkSPGw8PDjBw50jatXbt2N63NGGN69eplihUrZv7991+76V26dDF+fn62Wrdu3WokmZkzZ950fQAAwLH69u1rbvzfubCwMCPJTJ06Nc349PqSPn36mHz58plr167Zpt3YGx05csRIMoULFzbnz5+3Tf/++++NJPPjjz/apg0bNixNTZKMu7u7OXz4sG3a7t27jSTz0Ucf2aa1bdvW5MuXz/zzzz+2aYcOHTKurq5p1pmeoUOHGkkmf/785uGHHzZvv/222b59e5pxn3/+uXF2djZr1661mz516lQjyaxfv942LX/+/Ha9JAAAsKYb+6q1a9caSWbOnDl24xYtWmQ3PeWzoK1bt2a47rNnz2b4uVV69u3bZ7y8vIwkU716dTNw4ECzYMECc/nyZbtxFy9eNAUKFDDPPPOM3fRTp04ZPz8/u+np9Y0ArI1LfQK4J0yaNElLly61+7mbeHt7S5IuXrxom+bl5WX7d8oZi2FhYfrzzz/tLgmaEQ8PDzk7J79NJyYm6ty5c/L29lb58uW1Y8cO27gCBQro77//TnO5rRTGGH333Xdq27atjDH6999/bT8RERGKiYmxWx8AALh3eXh4qGfPnmmmp+5LLl68qH///VeNGzfWlStX9Ntvv91yvZ07d1bBggVtv6dcGeDPP/+85bLh4eF2Z8tVq1ZNvr6+tmUTExO1bNkytW/f3nZFA0kqW7asHn744VuuX0q+fNbcuXNVo0YNLV68WP/9738VGhqqmjVr6sCBA7Zx33zzjSpWrKgKFSrY9UQp36hfuXJlprYHAACs65tvvpGfn59atGhh1y+EhobK29vb1i8UKFBAkvTTTz8pISEhW7ZduXJl7dq1S926ddPRo0c1fvx4tW/fXgEBAZo+fbpt3NKlSxUdHa3HH3/crkYXFxfVrVuXngbI47jUJ4B7Qp06dVSrVi1Hl5GhS5cuSZJ8fHxs09avX69hw4Zp48aNunLlit34mJgY+fn53XSdSUlJGj9+vCZPnqwjR47Y3YMn5bJYkvTKK69o2bJlqlOnjsqWLauWLVvqiSeesN3n5uzZs4qOjta0adM0bdq0dLfFDaIBALCG++67T+7u7mmm79+/X6+//rpWrFih2NhYu3mZ+UJSyZIl7X5PCQFvvM9NZpZNWT5l2TNnzujq1asqW7ZsmnHpTcvI448/rscff1yxsbHavHmzZs2apblz56pt27bat2+fPD09dejQIR04cCDDS4jSEwEAgEOHDikmJibde+pJ/+sXwsLCFBkZqREjRmjcuHFq2rSp2rdvryeeeEIeHh5Z3n65cuX0+eefKzExUb/++qt++uknjRkzRr1791ZwcLDCw8N16NAhScrwcqC+vr5Z3j6Aex/BHwDLSh2U5bR9+/ZJ+t+HU3/88YeaN2+uChUqaOzYsQoKCpK7u7sWLlyocePGKSkp6ZbrfOedd/TGG2/oqaee0ptvvqlChQrJ2dlZgwYNslu+YsWKOnjwoH766SctWrRI3333nSZPnqyhQ4dqxIgRtrHdunVTVFRUutu62fXlAQDAvSP1mX0poqOjFRYWJl9fX40cOVIhISHy9PTUjh079Morr2SqL3FxcUl3ujEmR5fNCl9fX7Vo0UItWrSQm5ubZs+erc2bNyssLExJSUmqWrWqxo4dm+6yQUFBOVITAAC4dyQlJcnf319z5sxJd37KF4icnJz07bffatOmTfrxxx+1ePFiPfXUU/rggw+0adMm29WhssrFxUVVq1ZV1apVVb9+fTVr1kxz5sxReHi4rX/7/PPPFRgYmGZZV1c+9gfyMt4BANzzChYsqOjoaLtp8fHxOnnyZK5sPzExUXPnzlW+fPnUqFEjSdKPP/6ouLg4/fDDD3bfck/vUgtOTk7prvfbb79Vs2bN9Omnn9pNj46OVpEiReym5c+fX507d1bnzp0VHx+vjh076u2339Zrr72mokWLysfHR4mJiQoPD7/pvmRUCwAAuHetWrVK586d07x589SkSRPb9CNHjjiwqv/x9/eXp6enDh8+nGZeetNuR61atTR79mxbXxgSEqLdu3erefPmt+x76IsAAMibQkJCtGzZMjVs2DDdL1XdqF69eqpXr57efvttzZ07V127dtWXX36pp59+Otv6iZSrYKXuaaTkPorPegDciHv8AbjnhYSEaM2aNXbTpk2blitn/CUmJmrAgAE6cOCABgwYYLuUQso321N/kz0mJkYzZ85Ms478+fOnCS5T1nHjN+G/+eYb/fPPP3bTzp07Z/e7u7u7KlWqJGOMEhIS5OLiosjISH333Xe2MxNTO3v2rF0tktKtBwAA3JvS60vi4+M1efJkR5Vkx8XFReHh4VqwYIFOnDhhm3748GH98ssvt1z+ypUr2rhxY7rzUpYvX768JOmxxx7TP//8Y3ePnBRXr17V5cuXbb9n1KMBAABre+yxx5SYmKg333wzzbzr16/b+oMLFy6k+dymevXqkqS4uDhJUr58+SRl/nOWtWvXpnu/wIULF0r6X08TEREhX19fvfPOO+mO57MeIG/jjD8A97ynn35azz77rCIjI9WiRQvt3r1bixcvTnNW3J2KiYnRF198ISn5A6bDhw9r3rx5+uOPP9SlSxe7hrBly5Zyd3dX27Zt1adPH126dEnTp0+Xv79/mjMRQ0NDNWXKFL311lsqW7as/P399eCDD6pNmzYaOXKkevbsqQYNGmjv3r2aM2eOypQpY7d8y5YtFRgYqIYNGyogIEAHDhzQxIkT1bp1a9s9B999912tXLlSdevW1TPPPKNKlSrp/Pnz2rFjh5YtW6bz589LSg5RCxQooKlTp8rHx0f58+dX3bp1FRwcnK2PJQAAyD0NGjRQwYIFFRUVpQEDBsjJyUmff/55jl1qMyuGDx+uJUuWqGHDhnruueeUmJioiRMnqkqVKtq1a9dNl71y5YoaNGigevXq6aGHHlJQUJCio6O1YMECrV27Vu3bt1eNGjUkSU8++aS+/vprPfvss1q5cqUaNmyoxMRE/fbbb/r666+1ePFi2zfqQ0NDtWzZMo0dO1bFixdXcHCw6tatm9MPBQAAcLCwsDD16dNHo0aN0q5du9SyZUu5ubnp0KFD+uabbzR+/Hg9+uijmj17tiZPnqwOHTooJCREFy9e1PTp0+Xr66tWrVpJSr4Me6VKlfTVV1+pXLlyKlSokKpUqaIqVaqku+3Ro0dr+/bt6tixo+22LDt27NBnn32mQoUKadCgQZKSL20+ZcoUPfnkk6pZs6a6dOmiokWL6vjx4/r555/VsGFDTZw4UVJyTyNJAwYMUEREhFxcXNSlS5ccfhQBOJQBgLvYzJkzjSSzdevWDMckJiaaV155xRQpUsTky5fPREREmMOHD5tSpUqZqKgo27iVK1caSWblypW2aVFRUaZUqVK3rCMsLMxIsv14e3ub+++/33Tr1s0sWbIk3WV++OEHU61aNePp6WlKly5tRo8ebWbMmGEkmSNHjtjGnTp1yrRu3dr4+PgYSSYsLMwYY8y1a9fMiy++aIoVK2a8vLxMw4YNzcaNG01YWJhtjDHGfPzxx6ZJkyamcOHCxsPDw4SEhJiXX37ZxMTE2NVz+vRp07dvXxMUFGTc3NxMYGCgad68uZk2bZrduO+//95UqlTJuLq6Gklm5syZt3x8AABA7urbt6+58X/nwsLCTOXKldMdv379elOvXj3j5eVlihcvboYMGWIWL158y97oyJEjRpJ577330qxTkhk2bJjt92HDhqWpSZLp27dvmmVv7NOMMWb58uWmRo0axt3d3YSEhJhPPvnEvPjii8bT0zODRyFZQkKCmT59umnfvr0pVaqU8fDwMPny5TM1atQw7733nomLi7MbHx8fb0aPHm0qV65sPDw8TMGCBU1oaKgZMWKEXf/022+/mSZNmhgvLy8jKU29AADAGtLrq4wxZtq0aSY0NNR4eXkZHx8fU7VqVTNkyBBz4sQJY4wxO3bsMI8//rgpWbKk8fDwMP7+/qZNmzZm27ZtduvZsGGDCQ0NNe7u7mn6pxutX7/e9O3b11SpUsX4+fkZNzc3U7JkSdOjRw/zxx9/pBm/cuVKExERYfz8/Iynp6cJCQkxPXr0sKvh+vXrpn///qZo0aLGyckp3X0FYC1OxtxFX/MEAAAAAOD/a9++vfbv369Dhw45uhQAAAAAuCdwjz8AAAAAgMNdvXrV7vdDhw5p4cKFatq0qWMKAgAAAIB7EGf8AQAAAAAcrlixYurRo4fKlCmjY8eOacqUKYqLi9POnTt1//33O7o8AAAAALgnuDq6AAAAAAAAHnroIf3f//2fTp06JQ8PD9WvX1/vvPMOoR8AAAAA3AbO+AMAAAAAAAAAAAAsgHv8AQAAAAAAAAAAABZA8AcAAAAAAAAAAABYAPf4y4SkpCSdOHFCPj4+cnJycnQ5AADA4owxunjxoooXLy5n57vre1r0RQAAILfczT2RRF8EAAByz+30RQR/mXDixAkFBQU5ugwAAJDH/PXXXypRooSjy7BDXwQAAHLb3dgTSfRFAAAg92WmLyL4ywQfHx9JyQ+or6+vg6sBAABWFxsbq6CgIFsPcjehLwIAALnlbu6JJPoiAACQe26nLyL4y4SUyzX4+vrSyAEAgFxzN14yir4IAADktruxJ5LoiwAAQO7LTF90910gHQAAAAAAAAAAAMBtI/gDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALcHV0Afif0q/+7OgScBNH323t6BIAAAAAAAAAAAAyxBl/AAAAAAAAAAAAgAUQ/AEAAAAAAAAAAAAWQPAHAAAAAAAAAAAAWADBHwAAAAAAAAAAAGABBH8AAAAAAAAAAACABRD8AQAAAAAAAAAAABZA8AcAAAAAAAAAAABYAMEfAAAAAAAAAAAAYAEEfwAAAAAAAAAAAIAFEPwBAAAAAAAAAAAAFkDwBwAAAAAAAAAAAFgAwR8AAAAAAAAAAABgAQR/AAAAAAAAAAAAgAUQ/AEAAAAAAAAAAAAWQPAHAAAAAAAAAAAAWADBHwAAAAAAAAAAAGABBH8AAAAAAAAAAACABRD8AQAAAAAAAAAAABZA8AcAAAAAAAAAAABYAMEfAAAAAAAAAAAAYAEEfwAAAAAAAAAAAIAFEPwBAAAAAAAAAAAAFkDwBwAAAAAAAAAAAFgAwR8AAAAAAAAAAABgAQR/AAAAAAAAAAAAgAUQ/AEAAAAAAAAAAAAWQPAHAAAAAAAAAAAAWADBHwAAAAAAAAAAAGABBH8AAAAAAAAAAACABTg0+EtMTNQbb7yh4OBgeXl5KSQkRG+++aaMMbYxxhgNHTpUxYoVk5eXl8LDw3Xo0CG79Zw/f15du3aVr6+vChQooF69eunSpUt2Y/bs2aPGjRvL09NTQUFBGjNmTK7sIwAAAAAAAAAAAJAbHBr8jR49WlOmTNHEiRN14MABjR49WmPGjNFHH31kGzNmzBhNmDBBU6dO1ebNm5U/f35FRETo2rVrtjFdu3bV/v37tXTpUv30009as2aNevfubZsfGxurli1bqlSpUtq+fbvee+89DR8+XNOmTcvV/QUAAAAAAAAAAAByiqsjN75hwwa1a9dOrVu3liSVLl1a//d//6ctW7ZISj7b78MPP9Trr7+udu3aSZI+++wzBQQEaMGCBerSpYsOHDigRYsWaevWrapVq5Yk6aOPPlKrVq30/vvvq3jx4pozZ47i4+M1Y8YMubu7q3Llytq1a5fGjh1rFxACAAAAAAAAAAAA9yqHnvHXoEEDLV++XL///rskaffu3Vq3bp0efvhhSdKRI0d06tQphYeH25bx8/NT3bp1tXHjRknSxo0bVaBAAVvoJ0nh4eFydnbW5s2bbWOaNGkid3d325iIiAgdPHhQFy5cyPH9BAAAAAAAAAAAAHKaQ8/4e/XVVxUbG6sKFSrIxcVFiYmJevvtt9W1a1dJ0qlTpyRJAQEBdssFBATY5p06dUr+/v52811dXVWoUCG7McHBwWnWkTKvYMGCdvPi4uIUFxdn+z02NvZOdxUAAOCeRF8EAACQjL4IAADcCxx6xt/XX3+tOXPmaO7cudqxY4dmz56t999/X7Nnz3ZkWRo1apT8/PxsP0FBQQ6tBwAAwFHoiwAAAJLRFwEAgHuBQ4O/l19+Wa+++qq6dOmiqlWr6sknn9QLL7ygUaNGSZICAwMlSadPn7Zb7vTp07Z5gYGBOnPmjN3869ev6/z583Zj0ltH6m2k9tprrykmJsb289dff2XD3gIAANx76IsAAACS0RcBAIB7gUODvytXrsjZ2b4EFxcXJSUlSZKCg4MVGBio5cuX2+bHxsZq8+bNql+/viSpfv36io6O1vbt221jVqxYoaSkJNWtW9c2Zs2aNUpISLCNWbp0qcqXL5/mMp+S5OHhIV9fX7sfAACAvIi+CAAAIBl9EQAAuBc4NPhr27at3n77bf388886evSo5s+fr7Fjx6pDhw6SJCcnJw0aNEhvvfWWfvjhB+3du1fdu3dX8eLF1b59e0lSxYoV9dBDD+mZZ57Rli1btH79evXr109dunRR8eLFJUlPPPGE3N3d1atXL+3fv19fffWVxo8fr8GDBztq1wEAAAAAAAAAAIBs5erIjX/00Ud644039Pzzz+vMmTMqXry4+vTpo6FDh9rGDBkyRJcvX1bv3r0VHR2tRo0aadGiRfL09LSNmTNnjvr166fmzZvL2dlZkZGRmjBhgm2+n5+flixZor59+yo0NFRFihTR0KFD1bt371zdXwAAAAAAAAAAACCnOBljjKOLuNvFxsbKz89PMTExOXoZh9Kv/pxj68adO/pua0eXAADII3Kr98iKu7k2AABgLXd733G31wcAAKzjdvoOh17qEwAAAAAAAAAAAED2IPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAlwdXQAAAABwo9Kv/uzoEnATR99t7egSAAAAAABAOjjjDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACHB78/fPPP+rWrZsKFy4sLy8vVa1aVdu2bbPNN8Zo6NChKlasmLy8vBQeHq5Dhw7ZreP8+fPq2rWrfH19VaBAAfXq1UuXLl2yG7Nnzx41btxYnp6eCgoK0pgxY3Jl/wAAAAAAAAAAAIDc4NDg78KFC2rYsKHc3Nz0yy+/6Ndff9UHH3ygggUL2saMGTNGEyZM0NSpU7V582blz59fERERunbtmm1M165dtX//fi1dulQ//fST1qxZo969e9vmx8bGqmXLlipVqpS2b9+u9957T8OHD9e0adNydX8BAAAAAAAAAACAnOLqyI2PHj1aQUFBmjlzpm1acHCw7d/GGH344Yd6/fXX1a5dO0nSZ599poCAAC1YsEBdunTRgQMHtGjRIm3dulW1atWSJH300Udq1aqV3n//fRUvXlxz5sxRfHy8ZsyYIXd3d1WuXFm7du3S2LFj7QJCAAAAAAAAAAAA4F7l0DP+fvjhB9WqVUudOnWSv7+/atSooenTp9vmHzlyRKdOnVJ4eLhtmp+fn+rWrauNGzdKkjZu3KgCBQrYQj9JCg8Pl7OzszZv3mwb06RJE7m7u9vGRERE6ODBg7pw4UJO7yYAAAAAAAAAAACQ4xwa/P3555+aMmWK7r//fi1evFjPPfecBgwYoNmzZ0uSTp06JUkKCAiwWy4gIMA279SpU/L397eb7+rqqkKFCtmNSW8dqbeRWlxcnGJjY+1+AAAA8iL6IgAAgGT0RQAA4F7g0OAvKSlJNWvW1DvvvKMaNWqod+/eeuaZZzR16lRHlqVRo0bJz8/P9hMUFOTQegAAAByFvggAACAZfREAALgXODT4K1asmCpVqmQ3rWLFijp+/LgkKTAwUJJ0+vRpuzGnT5+2zQsMDNSZM2fs5l+/fl3nz5+3G5PeOlJvI7XXXntNMTExtp+//vorq7sIAABwT6MvAgAASEZfBAAA7gUODf4aNmyogwcP2k37/fffVapUKUlScHCwAgMDtXz5ctv82NhYbd68WfXr15ck1a9fX9HR0dq+fbttzIoVK5SUlKS6devaxqxZs0YJCQm2MUuXLlX58uVVsGDBNHV5eHjI19fX7gcAACAvoi8CAABIRl8EAADuBQ4N/l544QVt2rRJ77zzjg4fPqy5c+dq2rRp6tu3ryTJyclJgwYN0ltvvaUffvhBe/fuVffu3VW8eHG1b99eUvIZgg899JCeeeYZbdmyRevXr1e/fv3UpUsXFS9eXJL0xBNPyN3dXb169dL+/fv11Vdfafz48Ro8eLCjdh0AAAAAAAAAAADIVq6O3Hjt2rU1f/58vfbaaxo5cqSCg4P14YcfqmvXrrYxQ4YM0eXLl9W7d29FR0erUaNGWrRokTw9PW1j5syZo379+ql58+ZydnZWZGSkJkyYYJvv5+enJUuWqG/fvgoNDVWRIkU0dOhQ9e7dO1f3FwAAAAAAAAAAAMgpDg3+JKlNmzZq06ZNhvOdnJw0cuRIjRw5MsMxhQoV0ty5c2+6nWrVqmnt2rVZrhMAAAAAAAAAAAC4mzn0Up8AAAAAAAAAAAAAsgfBHwAAAAAAAAAAAGABBH8AAAAAAAAAAACABRD8AQAAAAAAAAAAABZA8AcAAAAAAAAAAABYQJaCvz///DO76wAAAEAOoG8DAABIRl8EAADygiwFf2XLllWzZs30xRdf6Nq1a9ldEwAAALIJfRsAAEAy+iIAAJAXZCn427Fjh6pVq6bBgwcrMDBQffr00ZYtW7K7NgAAANwh+jYAAIBk9EUAACAvyFLwV716dY0fP14nTpzQjBkzdPLkSTVq1EhVqlTR2LFjdfbs2eyuEwAAAFlA3wYAAJCMvggAAOQFWQr+Uri6uqpjx4765ptvNHr0aB0+fFgvvfSSgoKC1L17d508eTK76gQAAMAdoG8DAABIRl8EAACs7I6Cv23btun5559XsWLFNHbsWL300kv6448/tHTpUp04cULt2rXLrjoBAABwB+jbAAAAktEXAQAAK3PNykJjx47VzJkzdfDgQbVq1UqfffaZWrVqJWfn5BwxODhYs2bNUunSpbOzVgAAANwm+jYAAIBk9EUAACAvyFLwN2XKFD311FPq0aOHihUrlu4Yf39/ffrpp3dUHAAAAO4MfRsAAEAy+iIAAJAXZCn4O3To0C3HuLu7KyoqKiurBwAAQDahbwMAAEhGXwQAAPKCLN3jb+bMmfrmm2/STP/mm280e/bsOy4KAAAA2YO+DQAAIBl9EQAAyAuyFPyNGjVKRYoUSTPd399f77zzzh0XBQAAgOxB3wYAAJCMvggAAOQFWQr+jh8/ruDg4DTTS5UqpePHj99xUQAAAMge9G0AAADJ6IsAAEBekKXgz9/fX3v27Ekzfffu3SpcuPAdFwUAAIDsQd8GAACQjL4IAADkBVkK/h5//HENGDBAK1euVGJiohITE7VixQoNHDhQXbp0ye4aAQAAkEX0bQAAAMnoiwAAQF7gmpWF3nzzTR09elTNmzeXq2vyKpKSktS9e3euiQ4AAHAXoW8DAABIRl8EAADygiwFf+7u7vrqq6/05ptvavfu3fLy8lLVqlVVqlSp7K4PAAAAd4C+DQAAIBl9EQAAyAuyFPylKFeunMqVK5ddtQAAACCH0LcBAAAkoy8CAABWlqXgLzExUbNmzdLy5ct15swZJSUl2c1fsWJFthQHAACAO0PfBgAAkIy+CAAA5AVZCv4GDhyoWbNmqXXr1qpSpYqcnJyyuy4AAABkA/o2AACAZPRFAAAgL8hS8Pfll1/q66+/VqtWrbK7HgAAAGQj+jYAAIBk9EUAACAvcM7KQu7u7ipbtmx21wIAAIBsRt8GAACQjL4IAADkBVkK/l588UWNHz9expjsrgcAAADZiL4NAAAgGX0RAADIC7J0qc9169Zp5cqV+uWXX1S5cmW5ubnZzZ83b162FAcAAIA7Q98GAACQjL4IAADkBVkK/goUKKAOHTpkdy0AAADIZvRtAAAAyeiLAABAXpCl4G/mzJnZXQcAAAByAH0bAABAMvoiAACQF2TpHn+SdP36dS1btkwff/yxLl68KEk6ceKELl26lG3FAQAA4M7RtwEAACSjLwIAAFaXpTP+jh07poceekjHjx9XXFycWrRoIR8fH40ePVpxcXGaOnVqdtcJAACALKBvAwAASEZfBAAA8oIsnfE3cOBA1apVSxcuXJCXl5dteocOHbR8+fJsKw4AAAB3hr4NAAAgGX0RAADIC7J0xt/atWu1YcMGubu7200vXbq0/vnnn2wpDAAAAHeOvg0AACAZfREAAMgLsnTGX1JSkhITE9NM//vvv+Xj43PHRQEAACB70LcBAAAkoy8CAAB5QZaCv5YtW+rDDz+0/e7k5KRLly5p2LBhatWqVXbVBgAAgDtE3wYAAJCMvggAAOQFWbrU5wcffKCIiAhVqlRJ165d0xNPPKFDhw6pSJEi+r//+7/srhEAAABZRN8GAACQjL4IAADkBVkK/kqUKKHdu3fryy+/1J49e3Tp0iX16tVLXbt2tbs5MgAAAByLvg0AACAZfREAAMgLshT8SZKrq6u6deuWnbUAAAAgB9C3AQAAJKMvAgAAVpel4O+zzz676fzu3btnqRgAAABkL/o2AACAZPRFAAAgL8hS8Ddw4EC73xMSEnTlyhW5u7srX758NEoAAAB3Cfo2AACAZPRFAAAgL3DOykIXLlyw+7l06ZIOHjyoRo0acTNkAACAuwh9GwAAQDL6IgAAkBdkKfhLz/3336933303zbenAAAAcHehbwMAAEhGXwQAAKwm24I/KfkGySdOnMjOVQIAACAH0LcBAAAkoy8CAABWkqV7/P3www92vxtjdPLkSU2cOFENGzbMlsIAAABw5+jbAAAAktEXAQCAvCBLwV/79u3tfndyclLRokX14IMP6oMPPsiOugAAAJAN6NsAAACS0RcBAIC8IEvBX1JSUnbXAQAAgBxA3wYAAJCMvggAAOQF2XqPPwAAAAAAAAAAAACOkaUz/gYPHpzpsWPHjs3KJgAAAJAN6NsAAACS0RcBAIC8IEvB386dO7Vz504lJCSofPnykqTff/9dLi4uqlmzpm2ck5NT9lQJAACALKFvAwAASEZfBAAA8oIsBX9t27aVj4+PZs+erYIFC0qSLly4oJ49e6px48Z68cUXs7VIAAAAZA19GwAAQDL6IgAAkBc4GWPM7S503333acmSJapcubLd9H379qlly5Y6ceJEthV4N4iNjZWfn59iYmLk6+ubY9sp/erPObZu3Lmj77Z2dAkAgDwiO3uP7O7b6Isg0RcBAHJHdvcd92pfBAAAcDt9h3NWN3D27Nk008+ePauLFy9mZZUAAADIAfRtAAAAyeiLAABAXpCl4K9Dhw7q2bOn5s2bp7///lt///23vvvuO/Xq1UsdO3bM7hoBAACQRfRtAAAAyeiLAABAXpCle/xNnTpVL730kp544gklJCQkr8jVVb169dJ7772XrQUCAAAg6+jbAAAAktEXAQCAvCBL9/hLcfnyZf3xxx+SpJCQEOXPnz/bCrubcC8bSNzLBgCQe3Ki98iuvo2+CBJ9EQAgd+RU33Gv9UUAAAA5fo+/FCdPntTJkyd1//33K3/+/LqDDBEAAAA5iL4NAAAgGX0RAACwsiwFf+fOnVPz5s1Vrlw5tWrVSidPnpQk9erVSy+++GK2FggAAICso28DAABIRl8EAADygiwFfy+88ILc3Nx0/Phx5cuXzza9c+fOWrRoUbYVBwAAgDtD3wYAAJCMvggAAOQFWQr+lixZotGjR6tEiRJ20++//34dO3YsS4W8++67cnJy0qBBg2zTrl27pr59+6pw4cLy9vZWZGSkTp8+bbfc8ePH1bp1a+XLl0/+/v56+eWXdf36dbsxq1atUs2aNeXh4aGyZctq1qxZWaoRAADgXpMTfRsAAMC9iL4IAADkBVkK/i5fvmz3zagU58+fl4eHx22vb+vWrfr4449VrVo1u+kvvPCCfvzxR33zzTdavXq1Tpw4oY4dO9rmJyYmqnXr1oqPj9eGDRs0e/ZszZo1S0OHDrWNOXLkiFq3bq1mzZpp165dGjRokJ5++mktXrz4tusEAAC412R33wYAAHCvoi8CAAB5QZaCv8aNG+uzzz6z/e7k5KSkpCSNGTNGzZo1u611Xbp0SV27dtX06dNVsGBB2/SYmBh9+umnGjt2rB588EGFhoZq5syZ2rBhgzZt2iQp+Ztav/76q7744gtVr15dDz/8sN58801NmjRJ8fHxkqSpU6cqODhYH3zwgSpWrKh+/frp0Ucf1bhx47Ky6wAAAPeU7OzbAAAA7mX0RQAAIC9wzcpCY8aMUfPmzbVt2zbFx8dryJAh2r9/v86fP6/169ff1rr69u2r1q1bKzw8XG+99ZZt+vbt25WQkKDw8HDbtAoVKqhkyZLauHGj6tWrp40bN6pq1aoKCAiwjYmIiNBzzz2n/fv3q0aNGtq4caPdOlLGpL6k6I3i4uIUFxdn+z02Nva29gkAAOBucad9G30RAACwCvoiAACQF2TpjL8qVaro999/V6NGjdSuXTtdvnxZHTt21M6dOxUSEpLp9Xz55ZfasWOHRo0alWbeqVOn5O7urgIFCthNDwgI0KlTp2xjUod+KfNT5t1sTGxsrK5evZpuXaNGjZKfn5/tJygoKNP7BAAAcDe5076NvggAAFgFfREAAMgLbvuMv4SEBD300EOaOnWq/vvf/2Z5w3/99ZcGDhyopUuXytPTM8vryQmvvfaaBg8ebPs9NjaWZg4AANxzsqNvoy8CAABWQF8EAADyitsO/tzc3LRnz5473vD27dt15swZ1axZ0zYtMTFRa9as0cSJE7V48WLFx8crOjra7qy/06dPKzAwUJIUGBioLVu22K339OnTtnkp/02ZlnqMr6+vvLy80q3Nw8ODmzoDAIB7Xnb0bfRFAADACuiLAABAXpGlS31269ZNn3766R1tuHnz5tq7d6927dpl+6lVq5a6du1q+7ebm5uWL19uW+bgwYM6fvy46tevL0mqX7++9u7dqzNnztjGLF26VL6+vqpUqZJtTOp1pIxJWQcAAICVZUffBgAAYAX0RQAAIC+47TP+JOn69euaMWOGli1bptDQUOXPn99u/tixY2+5Dh8fH1WpUsVuWv78+VW4cGHb9F69emnw4MEqVKiQfH191b9/f9WvX1/16tWTJLVs2VKVKlXSk08+qTFjxujUqVN6/fXX1bdvX9s3sJ599llNnDhRQ4YM0VNPPaUVK1bo66+/1s8//5yVXQcAALinZEffBgAAYAX0RQAAIC+4reDvzz//VOnSpbVv3z7bJTp///13uzFOTk7ZVty4cePk7OysyMhIxcXFKSIiQpMnT7bNd3Fx0U8//aTnnntO9evXV/78+RUVFaWRI0faxgQHB+vnn3/WCy+8oPHjx6tEiRL65JNPFBERkW11AgAA3G1yu28DAAC4W9EXAQCAvMTJGGMyO9jFxUUnT56Uv7+/JKlz586aMGGCAgICcqzAu0FsbKz8/PwUExMjX1/fHNtO6Vc5C/FudvTd1o4uAQCQR2RH75FTfRt9EST6IgBA7siuvuNe74sAAABup++4rXv83ZgR/vLLL7p8+fLtVwgAAIAcRd8GAACQjL4IAADkJbcV/N3oNk4WBAAAgAPRtwEAACSjLwIAAFZ2W8Gfk5NTmmuecw10AACAuw99GwAAQDL6IgAAkJe43s5gY4x69OghDw8PSdK1a9f07LPPKn/+/Hbj5s2bl30VAgAA4LbRtwEAACSjLwIAAHnJbQV/UVFRdr9369YtW4sBAABA9qBvAwAASEZfBAAA8pLbCv5mzpyZU3UAAAAgG9G3AQAAJKMvAgAAeclt3eMPAAAAAAAAAAAAwN2J4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsABXRxcAAAAAAAAAIK3Sr/7s6BJwE0ffbe3oEgAASIMz/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAswKHB36hRo1S7dm35+PjI399f7du318GDB+3GXLt2TX379lXhwoXl7e2tyMhInT592m7M8ePH1bp1a+XLl0/+/v56+eWXdf36dbsxq1atUs2aNeXh4aGyZctq1qxZOb17AAAAAAAAAAAAQK5xaPC3evVq9e3bV5s2bdLSpUuVkJCgli1b6vLly7YxL7zwgn788Ud98803Wr16tU6cOKGOHTva5icmJqp169aKj4/Xhg0bNHv2bM2aNUtDhw61jTly5Ihat26tZs2aadeuXRo0aJCefvppLV68OFf3FwAAAAAAAAAAAMgpro7c+KJFi+x+nzVrlvz9/bV9+3Y1adJEMTEx+vTTTzV37lw9+OCDkqSZM2eqYsWK2rRpk+rVq6clS5bo119/1bJlyxQQEKDq1avrzTff1CuvvKLhw4fL3d1dU6dOVXBwsD744ANJUsWKFbVu3TqNGzdOERERub7fAAAAAAAAAAAAQHa7q+7xFxMTI0kqVKiQJGn79u1KSEhQeHi4bUyFChVUsmRJbdy4UZK0ceNGVa1aVQEBAbYxERERio2N1f79+21jUq8jZUzKOm4UFxen2NhYux8AAIC8iL4IAAAgGX0RAAC4F9w1wV9SUpIGDRqkhg0bqkqVKpKkU6dOyd3dXQUKFLAbGxAQoFOnTtnGpA79UuanzLvZmNjYWF29ejVNLaNGjZKfn5/tJygoKFv2EQAA4F5DXwQAAJCMvggAANwL7prgr2/fvtq3b5++/PJLR5ei1157TTExMbafv/76y9ElAQAAOAR9EQAAQDL6IgAAcC9w6D3+UvTr108//fST1qxZoxIlStimBwYGKj4+XtHR0XZn/Z0+fVqBgYG2MVu2bLFb3+nTp23zUv6bMi31GF9fX3l5eaWpx8PDQx4eHtmybwAAAPcy+iIAAIBk9EUAAOBe4NAz/owx6tevn+bPn68VK1YoODjYbn5oaKjc3Ny0fPly27SDBw/q+PHjql+/viSpfv362rt3r86cOWMbs3TpUvn6+qpSpUq2ManXkTImZR0AAAAAAAAAAADAvc6hZ/z17dtXc+fO1ffffy8fHx/bPfn8/Pzk5eUlPz8/9erVS4MHD1ahQoXk6+ur/v37q379+qpXr54kqWXLlqpUqZKefPJJjRkzRqdOndLrr7+uvn372r6F9eyzz2rixIkaMmSInnrqKa1YsUJff/21fv75Z4ftOwAAAAAAAAAAAJCdHHrG35QpUxQTE6OmTZuqWLFitp+vvvrKNmbcuHFq06aNIiMj1aRJEwUGBmrevHm2+S4uLvrpp5/k4uKi+vXrq1u3burevbtGjhxpGxMcHKyff/5ZS5cu1QMPPKAPPvhAn3zyiSIiInJ1fwEAAAAAAAAAAICc4tAz/owxtxzj6empSZMmadKkSRmOKVWqlBYuXHjT9TRt2lQ7d+687RoBAAAAAAAAAACAe4FDz/gDAAAAAAAAAAAAkD0I/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAII/gAAAAAAAAAAAAALIPgDAAAAAAAAAAAALIDgDwAAAAAAAAAAALAAgj8AAAAAAAAAAADAAgj+AAAAAAAAAAAAAAsg+AMAAAAAAAAAAAAsgOAPAAAAAAAAAAAAsACCPwAAAAAAAAAAAMACCP4AAAAAAAAAAAAACyD4AwAAAAAAAAAAACyA4A8AAAAAAAAAAACwAII/AAAAAAAAAAAAwAJcHV0AgBsM93N0BbiZ4TGOrgAAAAAAAAAAgHRxxh8AAAAAAAAAAABgAQR/AAAAAAAAAAAAgAVwqU8AuAtVnV3V0SUgA3uj9ubKdg5UqJgr20HWVPztgKNLAAAAAAAAANIg+AMAAABw9+G+x3c37nsMAAAAAHclLvUJAAAAAAAAAAAAWABn/AEAAAAA7kpc/vzuxiXQIXEJdAAAgLsNZ/wBAAAAAAAAAAAAFkDwBwAAAAAAAAAAAFhAngr+Jk2apNKlS8vT01N169bVli1bHF0SAAAAAAAAAAAAkC3yzD3+vvrqKw0ePFhTp05V3bp19eGHHyoiIkIHDx6Uv7+/o8sDAAAAAAAAgLSG+zm6AtzM8BhHVwAAdvJM8Dd27Fg988wz6tmzpyRp6tSp+vnnnzVjxgy9+uqrDq4OAAAAAAAAAID0VZ1d1dEl4Cb2Ru3Nle0cqFAxV7aD21fxtwOOLsEmT1zqMz4+Xtu3b1d4eLhtmrOzs8LDw7Vx40YHVgYAAAAAAAAAAABkjzxxxt+///6rxMREBQQE2E0PCAjQb7/9lmZ8XFyc4uLibL/HxCSfrh0bG5ujdSbFXcnR9ePO5PTzbxNncmc7yJpcOg4SrybmynZw+3LrveBSIsfA3Synj4OU9Rvj+L8J9EVIT668F9IT3d3oiSD6IiTLyePgbuqJJMf0RfREdzc+K4Ik+iJIoi/C3fVZkZO5W7qnHHTixAndd9992rBhg+rXr2+bPmTIEK1evVqbN2+2Gz98+HCNGDEit8sEAACw89dff6lEiRIOrYG+CAAAONrd0BNJ9EUAAMDxMtMX5YngLz4+Xvny5dO3336r9u3b26ZHRUUpOjpa33//vd34G7/BlZSUpPPnz6tw4cJycnLKrbLvabGxsQoKCtJff/0lX19fR5cDB+E4AMcAJI6DrDDG6OLFiypevLicnR17ZXb6ojvHawAcA5A4DpCM4+D23E09kURfdKc4/iFxHCAZxwE4Bm7f7fRFeeJSn+7u7goNDdXy5cttwV9SUpKWL1+ufv36pRnv4eEhDw8Pu2kFChTIhUqtx9fXlxcuOA7AMQBJHAe3y8/Pz9ElSKIvyk68BsAxAInjAMk4DjLvbumJJPqi7MLxD4njAMk4DsAxcHsy2xflieBPkgYPHqyoqCjVqlVLderU0YcffqjLly+rZ8+eji4NAAAAAAAAAAAAuGN5Jvjr3Lmzzp49q6FDh+rUqVOqXr26Fi1apICAAEeXBgAAAAAAAAAAANyxPBP8SVK/fv3SvbQnsp+Hh4eGDRuW5hIYyFs4DsAxAInjAOA1AI4BSBwHSMZxgLyM4x8SxwGScRyAYyBnORljjKOLAAAAAAAAAAAAAHBnnB1dAAAAAAAAAAAAAIA7R/AHAAAAAAAAAAAAWADBHwAAAAAAAAAAAGABBH/IdpMmTVLp0qXl6empunXrasuWLY4uCblszZo1atu2rYoXLy4nJyctWLDA0SUhl40aNUq1a9eWj4+P/P391b59ex08eNDRZSGXTZkyRdWqVZOvr698fX1Vv359/fLLL44uC8hV9EV5Gz0RJPoi0BMBKeiL8jb6ItATQaIvyi0Ef8hWX331lQYPHqxhw4Zpx44deuCBBxQREaEzZ844ujTkosuXL+uBBx7QpEmTHF0KHGT16tXq27evNm3apKVLlyohIUEtW7bU5cuXHV0aclGJEiX07rvvavv27dq2bZsefPBBtWvXTvv373d0aUCuoC8CPREk+iLQEwESfRHoi0BPhGT0RbnDyRhjHF0ErKNu3bqqXbu2Jk6cKElKSkpSUFCQ+vfvr1dffdXB1cERnJycNH/+fLVv397RpcCBzp49K39/f61evVpNmjRxdDlwoEKFCum9995Tr169HF0KkOPoi5AaPRFS0BdBoidC3kNfhNToiyDRE+F/6IuyH2f8IdvEx8dr+/btCg8Pt01zdnZWeHi4Nm7c6MDKADhaTEyMpOQ/5MibEhMT9eWXX+ry5cuqX7++o8sBchx9EYCM0BflbfREyIvoiwCkh54I9EU5x9XRBcA6/v33XyUmJiogIMBuekBAgH777TcHVQXA0ZKSkjRo0CA1bNhQVapUcXQ5yGV79+5V/fr1de3aNXl7e2v+/PmqVKmSo8sCchx9EYD00BflXfREyMvoiwDciJ4ob6MvynkEfwCAHNW3b1/t27dP69atc3QpcIDy5ctr165diomJ0bfffquoqCitXr2ahg4AkCfRF+Vd9EQAAPwPPVHeRl+U8wj+kG2KFCkiFxcXnT592m766dOnFRgY6KCqADhSv3799NNPP2nNmjUqUaKEo8uBA7i7u6ts2bKSpNDQUG3dulXjx4/Xxx9/7ODKgJxFXwTgRvRFeRs9EfIy+iIAqdETgb4o53GPP2Qbd3d3hYaGavny5bZpSUlJWr58OdfoBfIYY4z69eun+fPna8WKFQoODnZ0SbhLJCUlKS4uztFlADmOvghACvoipIeeCHkJfREAiZ4IGaMvyn6c8YdsNXjwYEVFRalWrVqqU6eOPvzwQ12+fFk9e/Z0dGnIRZcuXdLhw4dtvx85ckS7du1SoUKFVLJkSQdWhtzSt29fzZ07V99//718fHx06tQpSZKfn5+8vLwcXB1yy2uvvaaHH35YJUuW1MWLFzV37lytWrVKixcvdnRpQK6gLwI9EST6ItATARJ9EeiLQE+EZPRFucPJGGMcXQSsZeLEiXrvvfd06tQpVa9eXRMmTFDdunUdXRZy0apVq9SsWbM006OiojRr1qzcLwi5zsnJKd3pM2fOVI8ePXK3GDhMr169tHz5cp08eVJ+fn6qVq2aXnnlFbVo0cLRpQG5hr4ob6MngkRfBHoiIAV9Ud5GXwR6Ikj0RbmF4A8AAAAAAAAAAACwAO7xBwAAAAAAAAAAAFgAwR8AAAAAAAAAAABgAQR/AAAAAAAAAAAAgAUQ/AEAAAAAAAAAAAAWQPAHAAAAAAAAAAAAWADBHwAAAAAAAAAAAGABBH8AAAAAAAAAAACABRD8AQAAAAAAAAAAABZA8AcgT3FyctKCBQscXUaWDB8+XNWrV7+jdRw9elROTk7atWtXttQEAADuXfRF9EUAACAZfRF9EWAlBH8ALOPUqVPq37+/ypQpIw8PDwUFBalt27Zavny5o0uTJDVt2lSDBg1ydBkAACAPoC8CAABIRl8EIK9xdXQBAJAdjh49qoYNG6pAgQJ67733VLVqVSUkJGjx4sXq27evfvvtN0eXCAAAkCvoiwAAAJLRFwHIizjjD4AlPP/883JyctKWLVsUGRmpcuXKqXLlyho8eLA2bdqU4XKvvPKKypUrp3z58qlMmTJ64403lJCQYJu/e/duNWvWTD4+PvL19VVoaKi2bdsmSTp27Jjatm2rggULKn/+/KpcubIWLlyY5X24VS0pPv74YwUFBSlfvnx67LHHFBMTYzf/k08+UcWKFeXp6akKFSpo8uTJWa4JAADce+iL/oe+CACAvI2+6H/oi4C8gzP+ANzzzp8/r0WLFuntt99W/vz508wvUKBAhsv6+Pho1qxZKl68uPbu3atnnnlGPj4+GjJkiCSpa9euqlGjhqZMmSIXFxft2rVLbm5ukqS+ffsqPj5ea9asUf78+fXrr7/K29s7y/txq1ok6fDhw/r666/1448/KjY2Vr169dLzzz+vOXPmSJLmzJmjoUOHauLEiapRo4Z27typZ555Rvnz51dUVFSWawMAAPcG+iL6IgAAkIy+iL4IyLMMANzjNm/ebCSZefPm3XKsJDN//vwM57/33nsmNDTU9ruPj4+ZNWtWumOrVq1qhg8fnuk6w8LCzMCBAzM9/sZahg0bZlxcXMzff/9tm/bLL78YZ2dnc/LkSWOMMSEhIWbu3Ll263nzzTdN/fr1jTHGHDlyxEgyO3fuzHQdAADg3kFfRF8EAACS0RfRFwF5FWf8AbjnGWOyvOxXX32lCRMm6I8//tClS5d0/fp1+fr62uYPHjxYTz/9tD7//HOFh4erU6dOCgkJkSQNGDBAzz33nJYsWaLw8HBFRkaqWrVqOVaLpP/X3t2DVpVuYQB+tTimUIKKqCfEEPREtFCLKIigpX9goUEFCRYqCIbgD6nS+NMKFhItUlgJVtpoo2A6FRQMqIiFAYOkUYyIEiLB7xZhDjjOjDPOhXtz8jzwFfvsb3PW3tULa7NXVqxYkZaWlvrx5s2b8+3bt7x69SoLFizI69evc+TIkRw7dqy+Z2pqKs3Nzb9cFwAwc8hFchEAME0ukotgtjLjD5jxarVa5syZ848HMj98+DCHDh3Krl27cvv27Tx9+jT9/f35+vVrfc/Zs2fz4sWL7N69O/fv38/atWtz69atJMnRo0czMjKS7u7uPHv2LJ2dnbl8+fIv3cPfqeVnPn/+nCQZHBzM8PBwfT1//vwvv1sPADQOuWiaXAQAyEXT5CKYfTT+gBlv0aJF2b59ewYGBvLly5cfzn/8+PEPr3vw4EHa2trS39+fzs7O1Gq1vHnz5od9HR0dOXXqVO7evZu9e/fm2rVr9XOtra05fvx4bt68mTNnzmRwcPCX7uHv1jI6OpqxsbH68aNHjzJ37tysXr06S5cuTbVazcjISFatWvXdam9v/6W6AICZRS6SiwCAaXKRXASzlU99Ag1hYGAgW7ZsyaZNm3L+/PmsW7cuU1NTuXfvXq5evZqXL1/+cE2tVsvo6Ghu3LiRjRs35s6dO/W3s5JkYmIifX196erqSnt7e96+fZvHjx9n3759SZKTJ09m586d6ejoyPj4eIaGhrJmzZq/rPPdu3cZHh7+7rfly5f/tJbfNDU15fDhw7l48WI+ffqU3t7e7N+/P8uWLUuSnDt3Lr29vWlubs6OHTsyOTmZJ0+eZHx8PKdPn/6njxUAmIHkIrkIAJgmF8lFMCv9j2cMAvzXjI2NlRMnTpS2trZSqVRKS0tL2bNnTxkaGqrvye+GNff19ZXFixeX+fPnlwMHDpRLly6V5ubmUkopk5OT5eDBg6W1tbVUKpVSrVZLT09PmZiYKKWU0tPTU1auXFnmzZtXlixZUrq7u8v79+//tL5t27aVJD+sCxcu/LSWUqaHNa9fv75cuXKlVKvV0tTUVLq6usqHDx+++5/r16+XDRs2lEqlUhYuXFi2bt1aH2RtWDMAzA5y0TS5CACQi6bJRTB7zCnlX0w5BQAAAAAAAP4vmPEHAAAAAAAADUDjDwAAAAAAABqAxh8AAAAAAAA0AI0/AAAAAAAAaAAafwAAAAAAANAANP4AAAAAAACgAWj8AQAAAAAAQAPQ+AMAAAAAAIAGoPEHAAAAAAAADUDjDwAAAAAAABqAxh8AAAAAAAA0AI0/AAAAAAAAaAD/AVY6XNXoP96OAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "==================== Running Test: Varying Test Ratios (N=100,000) ====================\n", - "\n", - "--- Scenario: BALANCED ---\n", - "Full Dataset Distribution:\n", - " - Full Dataset:\n", - " - Class 0: 25.00%\n", - " - Class 1: 25.00%\n", - " - Class 2: 25.00%\n", - " - Class 3: 25.00%\n", - "\n", - "-- Testing with test_size = 0.1 --\n", - "Train size: 90022, Test size: 9978\n", - " - Test Set:\n", - " - Class 0: 24.97%\n", - " - Class 1: 24.74%\n", - " - Class 2: 25.38%\n", - " - Class 3: 24.90%\n", - "\n", - "-- Testing with test_size = 0.2 --\n", - "Train size: 80044, Test size: 19956\n", - " - Test Set:\n", - " - Class 0: 24.84%\n", - " - Class 1: 25.10%\n", - " - Class 2: 24.97%\n", - " - Class 3: 25.08%\n", - "\n", - "-- Testing with test_size = 0.3 --\n", - "Train size: 70070, Test size: 29930\n", - " - Test Set:\n", - " - Class 0: 25.02%\n", - " - Class 1: 25.00%\n", - " - Class 2: 25.04%\n", - " - Class 3: 24.94%\n", - "\n", - "-- Testing with test_size = 0.4 --\n", - "Train size: 60005, Test size: 39995\n", - " - Test Set:\n", - " - Class 0: 25.06%\n", - " - Class 1: 24.99%\n", - " - Class 2: 24.97%\n", - " - Class 3: 24.97%\n", - "\n", - "--- Scenario: IMBALANCED ---\n", - "Full Dataset Distribution:\n", - " - Full Dataset:\n", - " - Class 0: 90.00%\n", - " - Class 1: 4.00%\n", - " - Class 2: 3.00%\n", - " - Class 3: 3.00%\n", - "\n", - "-- Testing with test_size = 0.1 --\n", - "Train size: 90034, Test size: 9966\n", - " - Test Set:\n", - " - Class 0: 90.03%\n", - " - Class 1: 3.97%\n", - " - Class 2: 2.97%\n", - " - Class 3: 3.03%\n", - "\n", - "-- Testing with test_size = 0.2 --\n", - "Train size: 80055, Test size: 19945\n", - " - Test Set:\n", - " - Class 0: 90.00%\n", - " - Class 1: 3.96%\n", - " - Class 2: 3.03%\n", - " - Class 3: 3.01%\n", - "\n", - "-- Testing with test_size = 0.3 --\n", - "Train size: 70052, Test size: 29948\n", - " - Test Set:\n", - " - Class 0: 89.99%\n", - " - Class 1: 4.02%\n", - " - Class 2: 3.01%\n", - " - Class 3: 2.98%\n", - "\n", - "-- Testing with test_size = 0.4 --\n", - "Train size: 59965, Test size: 40035\n", - " - Test Set:\n", - " - Class 0: 89.92%\n", - " - Class 1: 4.03%\n", - " - Class 2: 2.98%\n", - " - Class 3: 3.07%\n", - "\n", - "==================== Running Test: Varying Absolute Test Sizes (N=50,000) ====================\n", - "\n", - "--- Scenario: BALANCED ---\n", - "Full Dataset Distribution:\n", - " - Full Dataset:\n", - " - Class 0: 25.00%\n", - " - Class 1: 25.00%\n", - " - Class 2: 25.00%\n", - " - Class 3: 25.00%\n", - "\n", - "-- Testing with test_size = 1000 --\n", - "Requested test size: 1000, Actual test size: 985\n", - " - Test Set:\n", - " - Class 0: 25.79%\n", - " - Class 1: 25.28%\n", - " - Class 2: 24.97%\n", - " - Class 3: 23.96%\n", - "\n", - "-- Testing with test_size = 3000 --\n", - "Requested test size: 3000, Actual test size: 2953\n", - " - Test Set:\n", - " - Class 0: 24.86%\n", - " - Class 1: 24.79%\n", - " - Class 2: 25.19%\n", - " - Class 3: 25.16%\n", - "\n", - "-- Testing with test_size = 5000 --\n", - "Requested test size: 5000, Actual test size: 4983\n", - " - Test Set:\n", - " - Class 0: 25.01%\n", - " - Class 1: 25.21%\n", - " - Class 2: 24.86%\n", - " - Class 3: 24.92%\n", - "\n", - "-- Testing with test_size = 7000 --\n", - "Requested test size: 7000, Actual test size: 6992\n", - " - Test Set:\n", - " - Class 0: 24.94%\n", - " - Class 1: 25.04%\n", - " - Class 2: 25.14%\n", - " - Class 3: 24.87%\n", - "\n", - "-- Testing with test_size = 9000 --\n", - "Requested test size: 9000, Actual test size: 8947\n", - " - Test Set:\n", - " - Class 0: 25.08%\n", - " - Class 1: 24.92%\n", - " - Class 2: 25.03%\n", - " - Class 3: 24.97%\n", - "\n", - "--- Scenario: IMBALANCED ---\n", - "Full Dataset Distribution:\n", - " - Full Dataset:\n", - " - Class 0: 90.00%\n", - " - Class 1: 4.00%\n", - " - Class 2: 3.00%\n", - " - Class 3: 3.00%\n", - "\n", - "-- Testing with test_size = 1000 --\n", - "Requested test size: 1000, Actual test size: 957\n", - " - Test Set:\n", - " - Class 0: 90.28%\n", - " - Class 1: 4.39%\n", - " - Class 2: 2.61%\n", - " - Class 3: 2.72%\n", - "\n", - "-- Testing with test_size = 3000 --\n", - "Requested test size: 3000, Actual test size: 2987\n", - " - Test Set:\n", - " - Class 0: 90.02%\n", - " - Class 1: 4.02%\n", - " - Class 2: 2.85%\n", - " - Class 3: 3.11%\n", - "\n", - "-- Testing with test_size = 5000 --\n", - "Requested test size: 5000, Actual test size: 4927\n", - " - Test Set:\n", - " - Class 0: 89.95%\n", - " - Class 1: 4.10%\n", - " - Class 2: 3.00%\n", - " - Class 3: 2.94%\n", - "\n", - "-- Testing with test_size = 7000 --\n", - "Requested test size: 7000, Actual test size: 6891\n", - " - Test Set:\n", - " - Class 0: 89.99%\n", - " - Class 1: 4.08%\n", - " - Class 2: 2.96%\n", - " - Class 3: 2.97%\n", - "\n", - "-- Testing with test_size = 9000 --\n", - "Requested test size: 9000, Actual test size: 8949\n", - " - Test Set:\n", - " - Class 0: 89.97%\n", - " - Class 1: 3.97%\n", - " - Class 2: 3.06%\n", - " - Class 3: 3.01%\n", - "\n", - "==================== Running Runtime Analysis ====================\n", - "Testing with N = 1000...\n", - " -> Execution time: 0.1363 seconds\n", - "Testing with N = 10000...\n", - " -> Execution time: 0.2156 seconds\n", - "Testing with N = 100000...\n", - " -> Execution time: 0.2427 seconds\n", - "Testing with N = 1000000...\n", - " -> Execution time: 1.7087 seconds\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def plot_class_distribution(ax, y_data, title):\n", - " \"\"\"Helper function to plot class distribution histograms.\"\"\"\n", - " classes, counts = np.unique(y_data, return_counts=True)\n", - " ax.bar(classes, counts, color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'])\n", - " ax.set_title(title)\n", - " ax.set_xlabel('Class Label')\n", - " ax.set_ylabel('Frequency')\n", - " ax.set_xticks(classes)\n", - "\n", - "def print_dist_ratios(name, data, all_classes):\n", - " \"\"\"Helper function to print class distribution ratios.\"\"\"\n", - " classes, counts = np.unique(data, return_counts=True)\n", - " ratios = counts / len(data)\n", - " dist_map = dict(zip(classes, ratios))\n", - " print(f\" - {name}:\")\n", - " for cls in all_classes:\n", - " ratio_val = dist_map.get(cls, 0)\n", - " print(f\" - Class {cls}: {ratio_val:.2%}\")\n", - "\n", - "def run_test_scenario(scenario=\"balanced\", n_samples=10000):\n", - " \"\"\"Runs a full test scenario for either a balanced or imbalanced dataset.\"\"\"\n", - " print(f\"\\n{'='*20} Running Test: {scenario.upper()} Dataset {'='*20}\")\n", - " \n", - " # 1. Generate Data\n", - " if scenario == \"balanced\":\n", - " n_classes = 4\n", - " y = np.repeat(np.arange(n_classes), n_samples // n_classes)\n", - " else: # imbalanced\n", - " y = np.array([0]*int(n_samples*0.9) + [1]*int(n_samples*0.04) + \n", - " [2]*int(n_samples*0.03) + [3]*int(n_samples*0.03))\n", - " \n", - " all_classes = np.unique(y)\n", - " n_groups = 50\n", - " groups = np.random.randint(0, n_groups, size=n_samples)\n", - " X = np.random.rand(n_samples, 3)\n", - " \n", - " p = np.random.permutation(n_samples)\n", - " X, y, groups = X[p], y[p], groups[p]\n", - "\n", - " # 2. Perform a split\n", - " sgss = StratifiedGroupShuffleSplit(n_splits=1, test_size=0.3, random_state=42)\n", - " train_index, test_index = next(sgss.split(X, y, groups))\n", - " \n", - " # 2.1 Perform a second split and check if the indices are the same\n", - " \n", - " print(f\"\\nChecking if indices are reproducible with the same random state\")\n", - " sgss_2 = StratifiedGroupShuffleSplit(n_splits=1, test_size=0.3, random_state=42)\n", - " train_index_2, test_index_2 = next(sgss_2.split(X, y, groups))\n", - " \n", - " if np.all(np.equal(train_index, train_index_2)):\n", - " print(\"SUCCESS: Train indices are reproducible.\")\n", - " else:\n", - " print(\"FAILURE: Train indices are not reproducible.\")\n", - " \n", - " if np.all(np.equal(test_index, test_index_2)):\n", - " print(\"SUCCESS: Test indices are reproducible.\")\n", - " else:\n", - " print(\"FAILURE: Test indices are not reproducible.\")\n", - "\n", - " # 3. Check for group overlap\n", - " train_groups = np.unique(groups[train_index])\n", - " test_groups = np.unique(groups[test_index])\n", - " intersection = np.intersect1d(train_groups, test_groups)\n", - " print(f\"\\nChecking for group overlap...\")\n", - " if len(intersection) == 0:\n", - " print(\"SUCCESS: No overlapping groups found between train and test sets.\")\n", - " else:\n", - " print(f\"FAILURE: Found {len(intersection)} overlapping groups.\")\n", - "\n", - " # 4. Print size ratios\n", - " train_ratio = len(train_index) / n_samples\n", - " test_ratio = len(test_index) / n_samples\n", - " print(f\"\\nDataset Sizes and Ratios:\")\n", - " print(f\" - Train set size: {len(train_index)} ({train_ratio:.2%})\")\n", - " print(f\" - Test set size: {len(test_index)} ({test_ratio:.2%})\")\n", - "\n", - " # 5. Print class distribution ratios\n", - " print(\"\\nClass Distribution Ratios:\")\n", - " print_dist_ratios(\"Full Dataset\", y, all_classes)\n", - " print_dist_ratios(\"Train Set\", y[train_index], all_classes)\n", - " print_dist_ratios(\"Test Set\", y[test_index], all_classes)\n", - "\n", - " # 6. Create histograms\n", - " print(\"\\nGenerating class distribution histograms...\")\n", - " fig, axes = plt.subplots(1, 3, figsize=(18, 5), sharey=True)\n", - " fig.suptitle(f'Class Distribution Comparison ({scenario.capitalize()} Dataset)', fontsize=16)\n", - " \n", - " plot_class_distribution(axes[0], y, 'Full Dataset')\n", - " plot_class_distribution(axes[1], y[train_index], 'Training Set')\n", - " plot_class_distribution(axes[2], y[test_index], 'Test Set')\n", - " \n", - " plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n", - " plt.show()\n", - "\n", - "def run_runtime_analysis():\n", - " \"\"\"Measures and plots the execution time for different dataset sizes.\"\"\"\n", - " print(f\"\\n{'='*20} Running Runtime Analysis {'='*20}\")\n", - " sample_sizes = [1000, 10000, 100000, 1000000]\n", - " execution_times = []\n", - "\n", - " for n in sample_sizes:\n", - " print(f\"Testing with N = {n}...\")\n", - " y = np.repeat([0, 1], n // 2)\n", - " groups = np.random.randint(0, 100, size=n)\n", - " X = np.random.rand(n, 3)\n", - " \n", - " sgss = StratifiedGroupShuffleSplit(n_splits=1, test_size=0.3, random_state=42)\n", - " \n", - " start_time = time.time()\n", - " next(sgss.split(X, y, groups))\n", - " end_time = time.time()\n", - " \n", - " duration = end_time - start_time\n", - " execution_times.append(duration)\n", - " print(f\" -> Execution time: {duration:.4f} seconds\")\n", - "\n", - " plt.figure(figsize=(10, 6))\n", - " plt.plot(sample_sizes, execution_times, marker='o', linestyle='-')\n", - " plt.title('StratifiedGroupShuffleSplit Runtime Analysis')\n", - " plt.xlabel('Number of Samples (N)')\n", - " plt.ylabel('Execution Time (seconds)')\n", - " plt.xscale('log')\n", - " plt.yscale('log')\n", - " plt.grid(True, which=\"both\", ls=\"--\")\n", - " plt.show()\n", - "\n", - "def run_ratio_sweep_test():\n", - " \"\"\"Tests the splitter with various test ratios for a fixed N.\"\"\"\n", - " print(f\"\\n{'='*20} Running Test: Varying Test Ratios (N=100,000) {'='*20}\")\n", - " n_samples = 100000\n", - " test_ratios = [0.1, 0.2, 0.3, 0.4]\n", - "\n", - " for scenario in [\"balanced\", \"imbalanced\"]:\n", - " print(f\"\\n--- Scenario: {scenario.upper()} ---\")\n", - " if scenario == \"balanced\":\n", - " y = np.repeat(np.arange(4), n_samples // 4)\n", - " else:\n", - " y = np.array([0]*int(n_samples*0.9) + [1]*int(n_samples*0.04) + \n", - " [2]*int(n_samples*0.03) + [3]*int(n_samples*0.03))\n", - " \n", - " all_classes = np.unique(y)\n", - " groups = np.random.randint(0, 50, size=n_samples)\n", - " X = np.random.rand(n_samples, 3)\n", - " p = np.random.permutation(n_samples)\n", - " X, y, groups = X[p], y[p], groups[p]\n", - "\n", - " print(\"Full Dataset Distribution:\")\n", - " print_dist_ratios(\"Full Dataset\", y, all_classes)\n", - "\n", - " for ratio in test_ratios:\n", - " print(f\"\\n-- Testing with test_size = {ratio} --\")\n", - " sgss = StratifiedGroupShuffleSplit(n_splits=1, test_size=ratio, random_state=42)\n", - " train_index, test_index = next(sgss.split(X, y, groups))\n", - " \n", - " print(f\"Train size: {len(train_index)}, Test size: {len(test_index)}\")\n", - " print_dist_ratios(\"Test Set\", y[test_index], all_classes)\n", - "\n", - "def run_absolute_size_sweep_test():\n", - " \"\"\"Tests the splitter with various absolute test sizes for a fixed N.\"\"\"\n", - " print(f\"\\n{'='*20} Running Test: Varying Absolute Test Sizes (N=50,000) {'='*20}\")\n", - " n_samples = 50000\n", - " test_sizes = range(1000, 10000, 2000)\n", - "\n", - " for scenario in [\"balanced\", \"imbalanced\"]:\n", - " print(f\"\\n--- Scenario: {scenario.upper()} ---\")\n", - " if scenario == \"balanced\":\n", - " y = np.repeat(np.arange(4), n_samples // 4)\n", - " else:\n", - " y = np.array([0]*int(n_samples*0.9) + [1]*int(n_samples*0.04) + \n", - " [2]*int(n_samples*0.03) + [3]*int(n_samples*0.03))\n", - " \n", - " all_classes = np.unique(y)\n", - " groups = np.random.randint(0, 50, size=n_samples)\n", - " X = np.random.rand(n_samples, 3)\n", - " p = np.random.permutation(n_samples)\n", - " X, y, groups = X[p], y[p], groups[p]\n", - "\n", - " print(\"Full Dataset Distribution:\")\n", - " print_dist_ratios(\"Full Dataset\", y, all_classes)\n", - "\n", - " for size in test_sizes:\n", - " print(f\"\\n-- Testing with test_size = {size} --\")\n", - " sgss = StratifiedGroupShuffleSplit(n_splits=1, test_size=size, random_state=42)\n", - " train_index, test_index = next(sgss.split(X, y, groups))\n", - " \n", - " print(f\"Requested test size: {size}, Actual test size: {len(test_index)}\")\n", - " print_dist_ratios(\"Test Set\", y[test_index], all_classes)\n", - "\n", - "if __name__ == '__main__':\n", - " # Run the original detailed scenarios with plots\n", - " run_test_scenario(scenario=\"balanced\")\n", - " run_test_scenario(scenario=\"imbalanced\")\n", - " \n", - " # Run the new sweep tests\n", - " run_ratio_sweep_test()\n", - " run_absolute_size_sweep_test()\n", - "\n", - " # Run the performance benchmark\n", - " run_runtime_analysis()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "scikit_mol", - "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.13.4" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}