diff --git a/.gitignore b/.gitignore index a35edef..2c457cd 100644 --- a/.gitignore +++ b/.gitignore @@ -108,4 +108,5 @@ ENV/ .ruff_cache /.vs/LANDMark/v16 /.vs/LANDMark/config -/.vs \ No newline at end of file +/.vs +/notebooks/Untitled.ipynb diff --git a/LANDMark/LANDMark.py b/LANDMark/LANDMark.py index 119e7a1..bf0df4a 100644 --- a/LANDMark/LANDMark.py +++ b/LANDMark/LANDMark.py @@ -12,9 +12,10 @@ from typing import Optional, List +from scipy.sparse import csr_array, issparse -class LANDMarkClassifier(BaseEstimator, ClassifierMixin): +class LANDMarkClassifier(BaseEstimator, ClassifierMixin): def __init__( self, n_estimators: int = 64, @@ -27,14 +28,16 @@ def __init__( use_oracle: bool = True, use_lm_l2: bool = True, use_lm_l1: bool = True, + minority_sz_lm: int = 6, use_nnet: bool = True, nnet_min_samples: int = 32, + minority_sz_nnet: int = 6, use_etc: bool = True, etc_max_depth: int = 5, etc_max_trees: int = 128, - resampler = None, + resampler=None, use_cascade: bool = False, - n_jobs: int = 4 + n_jobs: int = 4, ): # Tree construction parameters self.n_estimators = n_estimators @@ -47,8 +50,10 @@ def __init__( self.use_oracle = use_oracle self.use_lm_l2 = use_lm_l2 self.use_lm_l1 = use_lm_l1 + self.minority_sz_lm = minority_sz_lm self.use_nnet = use_nnet self.nnet_min_samples = nnet_min_samples + self.minority_sz_nnet = minority_sz_nnet self.use_etc = use_etc self.etc_max_depth = etc_max_depth self.etc_max_trees = etc_max_trees @@ -85,12 +90,15 @@ def fit(self, X: np.ndarray, y: np.ndarray) -> LANDMarkClassifier: use_oracle=self.use_oracle, use_lm_l2=self.use_lm_l2, use_lm_l1=self.use_lm_l1, + minority_sz_lm=self.minority_sz_lm, use_nnet=self.use_nnet, nnet_min_samples=self.nnet_min_samples, + minority_sz_nnet=self.minority_sz_nnet, use_etc=self.use_etc, etc_max_depth=self.etc_max_depth, etc_max_trees=self.etc_max_trees, - resampler=self.resampler + resampler=self.resampler, + use_cascade=self.use_cascade, ), n_estimators=self.n_estimators, class_names=self.classes_, @@ -140,23 +148,78 @@ def score(self, X: np.ndarray, y: np.ndarray) -> float: return score - def proximity(self, X: np.ndarray) -> np.ndarray: + def proximity(self, X: np.ndarray, prox_type: str = "path") -> np.ndarray: check_is_fitted(self, attributes=["classes_", "estimators_"]) - tree_mats = [] + if prox_type == "terminal": + tree_mats = [] + + for estimator in self.estimators_.estimators_: + tree_mats.append(estimator.proximity(X, prox_type)) + + emb = np.hstack(tree_mats) + + return csr_array(emb.astype(np.uint8)) + + elif prox_type == "path": + if hasattr(self, "node_set"): + embs = [ + est.proximity(X, prox_type) for est in self.estimators_.estimators_ + ] + + if X.ndim == 1: + emb = np.zeros(shape=(1, len(self.node_set)), dtype=np.uint8) + else: + emb = np.zeros( + shape=(X.shape[0], len(self.node_set)), dtype=np.uint8 + ) + + for tree_emb in embs: + for sample, nodes in tree_emb.items(): + for node in nodes: + emb[sample, self.node_set[node]] = 1 + + return csr_array(emb) - for estimator in self.estimators_.estimators_: - tree_mats.append(estimator.proximity(X)) + else: + # Get the list of nodes associated with each sample in X + embs = [ + est.proximity(X, prox_type) for est in self.estimators_.estimators_ + ] - emb = np.hstack(tree_mats) + # Create a list of all nodes across all trees in the forest + node_set = set() + [node_set.update(est.all_nodes) for est in self.estimators_.estimators_] - return emb + node_set = list(node_set) - def _check_params(self, X: np.ndarray, y: np.ndarray) -> List[np.ndarray, np.ndarray]: + # Create the embedding matrix + emb = np.zeros(shape=(X.shape[0], len(node_set)), dtype=np.uint8) + + # Create a mapping between node id and index in the embedding matrix + self.node_set = {node: i for i, node in enumerate(node_set)} + + # Update the embedding matrix + for tree_emb in embs: + for sample, nodes in tree_emb.items(): + for node in nodes: + emb[sample, self.node_set[node]] = 1 + + return csr_array(emb) + + def _check_params( + self, X: np.ndarray, y: np.ndarray + ) -> List[np.ndarray, np.ndarray]: SUPPORTED_IMPURITY = {"gain", "gain-ratio", "tsallis", "tsallis-gain-ratio"} # Check that X and y meet the minimum requirements - X_conv, y_conv = check_X_y(X, y, accept_sparse=False) + X_conv, y_conv = check_X_y(X, y, accept_sparse=True) + + if not issparse(X_conv): + sparsity = 1.0 - (np.count_nonzero(X_conv) / X_conv.size) + + if sparsity >= 0.9: + X_conv = csr_array(X_conv) if not isinstance(self.n_estimators, int): raise TypeError("'n_estimators' must be an integer.") @@ -174,9 +237,11 @@ def _check_params(self, X: np.ndarray, y: np.ndarray) -> List[np.ndarray, np.nda if isinstance(self.max_depth, type(None)): pass + elif isinstance(self.max_depth, int): if self.max_depth <= 0: raise ValueError("'max_depth' must be an greater than zero.") + else: raise TypeError("'max_depth' must be an integer greater than zero or None.") @@ -192,6 +257,7 @@ def _check_params(self, X: np.ndarray, y: np.ndarray) -> List[np.ndarray, np.nda if isinstance(self.min_gain, float): if self.min_gain < 0: raise ValueError("'min_gain' must be greater than or equal to zero.") + else: raise TypeError("'min_gain' must be float.") @@ -233,7 +299,7 @@ def _check_params(self, X: np.ndarray, y: np.ndarray) -> List[np.ndarray, np.nda if not isinstance(self.use_etc, bool): raise TypeError("'use_etc' must be True or False.") - + if isinstance(self.etc_max_depth, int): if self.etc_max_depth <= 0: raise ValueError("'etc_max_depth' must be greater than zero.") @@ -259,7 +325,7 @@ def _check_params(self, X: np.ndarray, y: np.ndarray) -> List[np.ndarray, np.nda if isinstance(self.resampler, type(None)): pass - elif hasattr(self.resampler, "fit_transform") == False: + elif hasattr(self.resampler, "fit_transform") is False: raise ValueError("'resampler' must have a 'fit_transform(X, y)' function.") return X_conv, y_conv diff --git a/LANDMark/lm_dtree_clfs.py b/LANDMark/lm_dtree_clfs.py index 888e6e9..35b9d3e 100644 --- a/LANDMark/lm_dtree_clfs.py +++ b/LANDMark/lm_dtree_clfs.py @@ -6,6 +6,7 @@ import numpy as np + class ETClassifier(ClassifierMixin, BaseEstimator): def __init__(self, n_feat=0.8, max_depth=5, max_trees=128): self.n_feat = n_feat @@ -29,13 +30,13 @@ def fit(self, X, y): self.classes_, y_counts = np.unique(y_re, return_counts=True) - clf_1 = ExtraTreesClassifier( + clf = ExtraTreesClassifier( n_estimators=self.max_trees, max_depth=self.max_depth ) self.model_type = "nonlinear_etc" - self.clf_model = clf_1.fit(X_re, y_re) + self.clf_model = clf.fit(X_re, y_re) return self, self.decision_function(X) @@ -43,12 +44,9 @@ def predict(self, X): return self.clf_model.predict(X[:, self.features]) def predict_proba(self, X): - return self.clf_model.predict_proba(X[:, self.features]) def decision_function(self, X): D = self.clf_model.predict_proba(X[:, self.features]) return np.where(D > 0.5, 1, -1) - - diff --git a/LANDMark/lm_linear_clfs.py b/LANDMark/lm_linear_clfs.py index 5895aca..23566e6 100644 --- a/LANDMark/lm_linear_clfs.py +++ b/LANDMark/lm_linear_clfs.py @@ -1,6 +1,3 @@ -import logging -import os - import warnings from sklearn.exceptions import ConvergenceWarning @@ -12,24 +9,21 @@ from sklearn.linear_model import ( RidgeClassifierCV, LogisticRegressionCV, - LogisticRegression, SGDClassifier, - RidgeClassifier, ) from sklearn.svm import LinearSVC -from sklearn.ensemble import ExtraTreesClassifier from sklearn.model_selection import GridSearchCV from sklearn.utils import resample - -from random import choice +from sklearn.model_selection import StratifiedKFold from math import ceil class LMClassifier(ClassifierMixin, BaseEstimator): - def __init__(self, model_type, n_feat=0.8): + def __init__(self, model_type, n_feat=0.8, minority=6, use_etc_split=True): self.model_type = model_type self.n_feat = n_feat + self.minority = minority def fit(self, X, y): if X.shape[1] >= 4: @@ -48,11 +42,13 @@ def fit(self, X, y): self.classes_, y_counts = np.unique(y_re, return_counts=True) - self.y_min = min(y_counts) - - if self.y_min > 6: + self.y_min = min(y_counts) * 0.8 + + if self.y_min > self.minority: if self.model_type == "lr_l2": - self.clf = LogisticRegressionCV(max_iter=2000, cv=5).fit(X_re, y_re) + self.clf = LogisticRegressionCV( + max_iter=2000, cv=StratifiedKFold(5) + ).fit(X_re, y_re) elif self.model_type == "lr_l1": solver = "liblinear" @@ -60,7 +56,7 @@ def fit(self, X, y): solver = "saga" self.clf = LogisticRegressionCV( - max_iter=2000, cv=5, solver=solver, penalty="l1" + max_iter=2000, cv=StratifiedKFold(5), solver=solver, penalty="l1" ).fit(X_re, y_re) elif self.model_type == "sgd_l2": @@ -70,7 +66,7 @@ def fit(self, X, y): "alpha": [0.001, 0.01, 0.1, 1.0, 10, 100], "loss": ["hinge", "modified_huber"], }, - cv=5, + cv=StratifiedKFold(5), ).fit(X_re, y_re) self.clf = self.cv.best_estimator_ @@ -82,41 +78,34 @@ def fit(self, X, y): "alpha": [0.001, 0.01, 0.1, 1.0, 10, 100], "loss": ["hinge", "modified_huber"], }, - cv=5, + cv=StratifiedKFold(5), ).fit(X_re, y_re) self.clf = self.cv.best_estimator_ elif self.model_type == "ridge": self.clf = RidgeClassifierCV( - alphas=(0.001, 0.01, 0.1, 1.0, 10, 100, 1000), cv=5 + alphas=(0.001, 0.01, 0.1, 1.0, 10, 100, 1000), cv=StratifiedKFold(5) ).fit(X_re, y_re) elif self.model_type == "lsvc": self.cv = GridSearchCV( LinearSVC(max_iter=2000), param_grid={"C": [0.001, 0.01, 0.1, 1.0, 10, 100]}, - cv=5, + cv=StratifiedKFold(5), ).fit(X_re, y_re) self.clf = self.cv.best_estimator_ - else: - self.clf = ExtraTreesClassifier(n_estimators = 128, max_depth = 1) - - self.clf.fit(X_re, y_re) + return self, self.decision_function(X) - return self, self.decision_function(X) + # Otherwise use an Extra Trees Classifier or Nothing + else: + return self, None def predict(self, X): return self.clf.predict(X[:, self.features]) def decision_function(self, X): - - if self.y_min > 6: - return self.clf.decision_function(X[:, self.features]) - - else: - D = self.clf.predict_proba(X[:, self.features]) + return self.clf.decision_function(X[:, self.features]) - return np.where(D > 0.5, 1, -1) \ No newline at end of file diff --git a/LANDMark/lm_nnet_clfs.py b/LANDMark/lm_nnet_clfs.py index 253e6f0..bbd74ba 100644 --- a/LANDMark/lm_nnet_clfs.py +++ b/LANDMark/lm_nnet_clfs.py @@ -10,6 +10,9 @@ from skorch import NeuralNetClassifier +from scipy.sparse import issparse + + class LMNNet(pyt.nn.Module): def __init__(self, n_in, n_out): super(LMNNet, self).__init__() @@ -17,22 +20,28 @@ def __init__(self, n_in, n_out): self.n_in = n_in self.n_out = n_out - self.IN = pyt.nn.Linear(in_features = self.n_in, out_features = self.n_out * 32) - self.IN_Dr = pyt.nn.Dropout(0.5) - - self.D_1 = pyt.nn.Linear(in_features = self.n_out * 32, out_features = self.n_out * 16) + self.IN = pyt.nn.Linear(in_features=self.n_in, out_features=self.n_out * 32) + self.A_1 = pyt.nn.Mish() + self.IN_Dr = pyt.nn.Dropout(0.375) + + self.D_1 = pyt.nn.Linear( + in_features=self.n_out * 32, out_features=self.n_out * 16 + ) self.A_1 = pyt.nn.Mish() self.Dr_1 = pyt.nn.Dropout(0.375) - self.D_2 = pyt.nn.Linear(in_features = self.n_out * 16, out_features = self.n_out * 8) + self.D_2 = pyt.nn.Linear( + in_features=self.n_out * 16, out_features=self.n_out * 16 + ) # n_out * 8 self.A_2 = pyt.nn.Mish() self.Dr_2 = pyt.nn.Dropout(0.375) - self.D_3 = pyt.nn.Linear(in_features = self.n_out * 8, out_features = self.n_out) - self.O = pyt.nn.Softmax(dim = -1) + self.D_3 = pyt.nn.Linear( + in_features=self.n_out * 16, out_features=self.n_out + ) # in_features = *8 + self.O = pyt.nn.Softmax(dim=-1) def forward(self, x): - o = self.IN(x) o = self.IN_Dr(o) o = self.D_1(o) @@ -48,94 +57,115 @@ def forward(self, x): class ANNClassifier(ClassifierMixin, BaseEstimator): - def __init__(self, n_feat=0.8): + def __init__(self, n_feat=0.8, minority=6, use_etc_split=True): self.n_feat = n_feat + self.minority = minority def fit(self, X, y): self.model_type = "nonlinear_nnet" - self.classes_, _ = np.unique(y, return_counts=True) + if issparse(X): + X_not_sparse = X.toarray() + else: + X_not_sparse = X + + # Encode y self.y_transformer = LabelEncoder().fit(y) - if X.shape[1] >= 4: + # Select features + if X_not_sparse.shape[1] >= 4: self.features = np.random.choice( - [i for i in range(X.shape[1])], - size=ceil(X.shape[1] * self.n_feat), + [i for i in range(X_not_sparse.shape[1])], + size=ceil(X_not_sparse.shape[1] * self.n_feat), replace=False, ) else: - self.features = np.asarray([i for i in range(X.shape[1])]) - - X_trf, y_trf = resample(X[:, self.features], y, n_samples=X.shape[0], stratify=y) + self.features = np.asarray([i for i in range(X_not_sparse.shape[1])]) + + # Bootstrap resample + X_trf, y_trf = resample( + X_not_sparse[:, self.features], + y, + n_samples=X_not_sparse.shape[0], + stratify=y, + ) X_trf = X_trf.astype(np.float32) y_trf = self.y_transformer.transform(y_trf).astype(np.int64) - self.n_in = X_trf.shape[1] - self.n_out = self.classes_.shape[0] - - if pyt.cuda.is_available(): - device = "cuda" - else: - device = "cpu" + # Determine if minimum class count exists + self.classes_, y_counts = np.unique(y_trf, return_counts=True) + + self.y_min = min(y_counts) * 0.8 + + # Use neural network if more than 6 samples are present in the minority class + if self.y_min > self.minority: + self.n_in = X_trf.shape[1] + self.n_out = self.classes_.shape[0] + + if pyt.cuda.is_available(): + device = "cuda" + else: + device = "cpu" + + clf = NeuralNetClassifier( + LMNNet(n_in=X_trf.shape[1], n_out=self.classes_.shape[0]), + optimizer=pyt.optim.AdamW, + lr=0.001, + max_epochs=100, + batch_size=16, + device=device, + iterator_train__shuffle=True, + verbose=0, + ) - clf = NeuralNetClassifier(LMNNet(n_in = X_trf.shape[1], n_out = self.classes_.shape[0]), - optimizer = pyt.optim.AdamW, - lr = 0.001, - max_epochs = 100, - batch_size = 16, - device = device, - iterator_train__shuffle=True, - verbose = 0 - ) + clf.fit(X_trf, y_trf) - clf.fit(X_trf, y_trf) - - self.params = clf.module.state_dict() + self.params = clf.module.state_dict() - with pyt.inference_mode(): - D = clf.predict_proba(X[:, self.features].astype(np.float32)) + del clf - D = np.where(D > 0.5, 1, -1) + return self, self.decision_function(X) - return self, D + # Otherwise use an Extra Trees Classifier or Nothing + else: + return self, None def predict_proba(self, X): + if issparse(X): + X_not_sparse = X.toarray() - if pyt.cuda.is_available(): - device = "cuda" else: - device = "cpu" + X_not_sparse = X + + clf = LMNNet(n_in=self.n_in, n_out=self.n_out) + + clf.load_state_dict(self.params) - clf = NeuralNetClassifier(LMNNet(n_in = self.n_in, n_out = self.n_out), - optimizer = pyt.optim.AdamW, - optimizer__lr = 0.001, - max_epochs = 100, - batch_size = 16, - device = device - ) + n_batch = pyt.arange(0, len(X_not_sparse), 16) - clf.module.load_state_dict(self.params) + X_tensor = pyt.tensor(X_not_sparse[:, self.features].astype(np.float32)) - clf.initialize() + predictions = [] + for start in n_batch: + p = clf(X_tensor[start : start + 16]).detach().cpu().numpy() + predictions.extend(p) - with pyt.inference_mode(): - predictions = clf.predict_proba(X[:, self.features].astype(np.float32)) + predictions = np.asarray(predictions) + + del clf return predictions def decision_function(self, X): - D = self.predict_proba(X) return np.where(D > 0.5, 1, -1) def predict(self, X): - predictions = self.predict_proba(X) - predictions = np.argmax(predictions, axis = 1) + predictions = np.argmax(predictions, axis=1) return self.y_transformer.inverse_transform(predictions) - diff --git a/LANDMark/lm_oracle_clfs.py b/LANDMark/lm_oracle_clfs.py index 42a1f88..cd5bc97 100644 --- a/LANDMark/lm_oracle_clfs.py +++ b/LANDMark/lm_oracle_clfs.py @@ -4,6 +4,8 @@ from sklearn.base import ClassifierMixin, BaseEstimator +from scipy.sparse import issparse + class RandomOracle(ClassifierMixin, BaseEstimator): def __init__(self, oracle="Linear", n_feat=0.8): @@ -11,29 +13,35 @@ def __init__(self, oracle="Linear", n_feat=0.8): self.n_feat = n_feat def fit(self, X, y): - if X.shape[1] >= 4: + if issparse(X): + X_not_sparse = X.toarray() + + else: + X_not_sparse = X + + if X_not_sparse.shape[1] >= 4: self.features = np.random.choice( - [i for i in range(X.shape[1])], - size=ceil(X.shape[1] * self.n_feat), + [i for i in range(X_not_sparse.shape[1])], + size=ceil(X_not_sparse.shape[1] * self.n_feat), replace=False, ) else: - self.features = np.asarray([i for i in range(X.shape[1])]) + self.features = np.asarray([i for i in range(X_not_sparse.shape[1])]) if self.oracle == "Linear": # Select two points at random index = np.random.choice( - [i for i in range(X.shape[0])], size=2, replace=False + [i for i in range(X_not_sparse.shape[0])], size=2, replace=False ) - x = X[index] + x = X_not_sparse[index] # Make sure two unique instances are chosen while np.array_equal(x[0, self.features], x[1, self.features]): index = np.random.choice( - [i for i in range(X.shape[0])], size=2, replace=False + [i for i in range(X_not_sparse.shape[0])], size=2, replace=False ) - x = X[index] + x = X_not_sparse[index] # Find the midpoint midpoint = np.sum(x[:, self.features], axis=0) * 0.5 @@ -45,8 +53,16 @@ def fit(self, X, y): return self def decision_function(self, X): + if issparse(X): + X_not_sparse = X.toarray() + + else: + X_not_sparse = X + if self.oracle == "Linear": - predictions = np.dot(X[:, self.features], self.weights.T) + self.intercept + predictions = ( + np.dot(X_not_sparse[:, self.features], self.weights.T) + self.intercept + ) return predictions diff --git a/LANDMark/tree.py b/LANDMark/tree.py index 99ce177..8f0208e 100644 --- a/LANDMark/tree.py +++ b/LANDMark/tree.py @@ -120,14 +120,17 @@ def get_split( q, use_lm_l2, use_lm_l1, + minority_sz_lm, use_nnet, nnet_min_samples, + minority_sz_nnet, use_etc, etc_max_depth, etc_max_trees, N, current_depth, - use_oracle + use_oracle, + use_cascade, ): # Get the ID of the node self.node_id = id(self) @@ -168,14 +171,13 @@ def get_split( return self - if isinstance(max_depth, int): - if current_depth >= max_depth: - leaf_predictions = PredictData(outcomes[np.argmax(counts_prob)]) + if not isinstance(max_depth, type(None)) and current_depth >= max_depth: + leaf_predictions = PredictData(outcomes[np.argmax(counts_prob)]) - self.label = leaf_predictions.predict - self.terminal = True + self.label = leaf_predictions.predict + self.terminal = True - return self + return self # Otherwise split else: @@ -185,6 +187,10 @@ def get_split( D = self.splitter.decision_function(X) + # Extend X using the output of the decision function, D, if the cascade parameter is True + if use_cascade: + X = np.hstack((X, D.reshape(-1, 1))) + L = np.where(D > 0, True, False) R = np.where(D <= 0, True, False) @@ -204,14 +210,17 @@ def get_split( q=q, use_lm_l2=use_lm_l2, use_lm_l1=use_lm_l1, + minority_sz_lm=minority_sz_lm, use_nnet=use_nnet, nnet_min_samples=nnet_min_samples, + minority_sz_nnet=minority_sz_nnet, use_etc=use_etc, etc_max_depth=etc_max_depth, etc_max_trees=etc_max_trees, N=X.shape[0], current_depth=current_depth + 1, use_oracle=False, + use_cascade=use_cascade, ) self.right = Node().get_split( @@ -225,84 +234,88 @@ def get_split( q=q, use_lm_l2=use_lm_l2, use_lm_l1=use_lm_l1, + minority_sz_lm=minority_sz_lm, use_nnet=use_nnet, nnet_min_samples=nnet_min_samples, + minority_sz_nnet=minority_sz_nnet, use_etc=use_etc, etc_max_depth=etc_max_depth, etc_max_trees=etc_max_trees, N=X.shape[0], current_depth=current_depth + 1, use_oracle=False, + use_cascade=use_cascade, ) return self - # Split using a Linear or Neural Network Models + # Split using a Linear, Tree, or Neural Network Models else: self.c_choice = choice([i for i in range(outcomes.shape[0])]) # Train Linear Models - L2 if use_lm_l2: for clf in [ - LMClassifier(model_type="lr_l2", n_feat=max_features), - LMClassifier(model_type="sgd_l2", n_feat=max_features), - LMClassifier(model_type="ridge", n_feat=max_features), - LMClassifier(model_type="lsvc", n_feat=max_features), + LMClassifier( + model_type="lr_l2", + n_feat=max_features, + minority=minority_sz_lm, + ), + LMClassifier( + model_type="sgd_l2", + n_feat=max_features, + minority=minority_sz_lm, + ), + LMClassifier( + model_type="ridge", + n_feat=max_features, + minority=minority_sz_lm, + ), + LMClassifier( + model_type="lsvc", + n_feat=max_features, + minority=minority_sz_lm, + ), ]: model, D = clf.fit(X, y) - if D.ndim > 1: - D = D[:, self.c_choice] + if not isinstance(D, type(None)): + if D.ndim > 1: + D = D[:, self.c_choice] - L = np.where(D > 0, True, False) - R = np.where(D <= 0, True, False) + L = np.where(D > 0, True, False) + R = np.where(D <= 0, True, False) - X_L_n = X[L].shape[0] - X_R_n = X[R].shape[0] + X_L_n = X[L].shape[0] + X_R_n = X[R].shape[0] - # Calculate Information Gain - if X_L_n > 0 and X_R_n > 0: - IG = purity_function( - counts_sum, counts_prob, L, R, y, impurity, q - ) + # Calculate Information Gain + if X_L_n > 0 and X_R_n > 0: + IG = purity_function( + counts_sum, counts_prob, L, R, y, impurity, q + ) - gains.append(IG) - hyperplane_list.append((model, L, R)) - model_type.append(model.model_type) + gains.append(IG) + hyperplane_list.append((model, L, R)) + model_type.append(model.model_type) # Train Linear Models - L1 / ElasticNet if use_lm_l1: for clf in [ - LMClassifier(model_type="lr_l1", n_feat=max_features), - LMClassifier(model_type="sgd_l1", n_feat=max_features), + LMClassifier( + model_type="lr_l1", + n_feat=max_features, + minority=minority_sz_lm, + ), + LMClassifier( + model_type="sgd_l1", + n_feat=max_features, + minority=minority_sz_lm, + ), ]: model, D = clf.fit(X, y) - if D.ndim > 1: - D = D[:, self.c_choice] - - L = np.where(D > 0, True, False) - R = np.where(D <= 0, True, False) - - X_L_n = X[L].shape[0] - X_R_n = X[R].shape[0] - - # Calculate Information Gain - if X_L_n > 0 and X_R_n > 0: - IG = purity_function( - counts_sum, counts_prob, L, R, y, impurity, q - ) - - gains.append(IG) - hyperplane_list.append((model, L, R)) - model_type.append(model.model_type) - - # Train a Neural Network - if use_nnet: - if X.shape[0] >= nnet_min_samples: - for clf in [ANNClassifier(n_feat=max_features)]: - model, D = clf.fit(X, y) - + if not isinstance(D, type(None)): if D.ndim > 1: D = D[:, self.c_choice] @@ -322,6 +335,37 @@ def get_split( hyperplane_list.append((model, L, R)) model_type.append(model.model_type) + # Train a Neural Network + if use_nnet: + if X.shape[0] >= nnet_min_samples: + for clf in [ + ANNClassifier( + n_feat=max_features, + minority=minority_sz_nnet, + ) + ]: + model, D = clf.fit(X, y) + + if not isinstance(D, type(None)): + if D.ndim > 1: + D = D[:, self.c_choice] + + L = np.where(D > 0, True, False) + R = np.where(D <= 0, True, False) + + X_L_n = X[L].shape[0] + X_R_n = X[R].shape[0] + + # Calculate Information Gain + if X_L_n > 0 and X_R_n > 0: + IG = purity_function( + counts_sum, counts_prob, L, R, y, impurity, q + ) + + gains.append(IG) + hyperplane_list.append((model, L, R)) + model_type.append(model.model_type) + # Train Decision Tree Models if use_etc: for clf in [ @@ -333,24 +377,25 @@ def get_split( ]: model, D = clf.fit(X, y) - if D.ndim > 1: - D = D[:, self.c_choice] + if not isinstance(D, type(None)): + if D.ndim > 1: + D = D[:, self.c_choice] - L = np.where(D > 0, True, False) - R = np.where(D <= 0, True, False) + L = np.where(D > 0, True, False) + R = np.where(D <= 0, True, False) - X_L_n = X[L].shape[0] - X_R_n = X[R].shape[0] + X_L_n = X[L].shape[0] + X_R_n = X[R].shape[0] - # Calculate Information Gain - if X_L_n > 0 and X_R_n > 0: - IG = purity_function( - counts_sum, counts_prob, L, R, y, impurity, q - ) + # Calculate Information Gain + if X_L_n > 0 and X_R_n > 0: + IG = purity_function( + counts_sum, counts_prob, L, R, y, impurity, q + ) - gains.append(IG) - hyperplane_list.append((model, L, R)) - model_type.append(model.model_type) + gains.append(IG) + hyperplane_list.append((model, L, R)) + model_type.append(model.model_type) gains = np.asarray(gains) hyperplane_list = np.asarray(hyperplane_list, dtype="object") @@ -375,9 +420,25 @@ def get_split( self.gain = best_gain self.splitter = best_hyperplane[0] + # Append the output of the decision function to each dataframe + if use_cascade: + if isinstance(self.splitter, LMClassifier): + X_cascade = self.splitter.decision_function(X) + + if X_cascade.ndim == 1: + X_cascade = X_cascade.reshape(-1, 1) + + else: + X_cascade = self.splitter.predict_proba(X) + + X_new = np.hstack((X, X_cascade)) + + else: + X_new = X + # Recursivly split self.left = Node().get_split( - X[L], + X_new[L], y[L], min_samples_in_leaf=min_samples_in_leaf, max_depth=max_depth, @@ -387,18 +448,21 @@ def get_split( q=q, use_lm_l2=use_lm_l2, use_lm_l1=use_lm_l1, + minority_sz_lm=minority_sz_lm, use_nnet=use_nnet, nnet_min_samples=nnet_min_samples, + minority_sz_nnet=minority_sz_nnet, use_etc=use_etc, etc_max_depth=etc_max_depth, etc_max_trees=etc_max_trees, N=X.shape[0], current_depth=current_depth + 1, use_oracle=use_oracle, + use_cascade=use_cascade, ) self.right = Node().get_split( - X[R], + X_new[R], y[R], min_samples_in_leaf=min_samples_in_leaf, max_depth=max_depth, @@ -408,14 +472,17 @@ def get_split( q=q, use_lm_l2=use_lm_l2, use_lm_l1=use_lm_l1, + minority_sz_lm=minority_sz_lm, use_nnet=use_nnet, nnet_min_samples=nnet_min_samples, + minority_sz_nnet=minority_sz_nnet, use_etc=use_etc, etc_max_depth=etc_max_depth, etc_max_trees=etc_max_trees, N=X.shape[0], current_depth=current_depth + 1, use_oracle=use_oracle, + use_cascade=use_cascade, ) return self @@ -442,12 +509,15 @@ def __init__( use_oracle, use_lm_l2, use_lm_l1, + minority_sz_lm, use_nnet, nnet_min_samples, + minority_sz_nnet, use_etc, etc_max_depth, etc_max_trees, resampler, + use_cascade, ): self.min_samples_in_leaf = min_samples_in_leaf self.max_depth = max_depth @@ -458,12 +528,15 @@ def __init__( self.use_oracle = use_oracle self.use_lm_l2 = use_lm_l2 self.use_lm_l1 = use_lm_l1 + self.minority_sz_lm = minority_sz_lm self.use_nnet = use_nnet self.nnet_min_samples = nnet_min_samples + self.minority_sz_nnet = minority_sz_nnet self.use_etc = use_etc self.etc_max_depth = etc_max_depth self.etc_max_trees = etc_max_trees self.resampler = resampler + self.use_cascade = use_cascade def fit(self, X, y): self.classes_ = np.unique(y) @@ -493,34 +566,27 @@ def fit(self, X, y): q=self.q, use_lm_l2=self.use_lm_l2, use_lm_l1=self.use_lm_l1, + minority_sz_lm=self.minority_sz_lm, use_nnet=self.use_nnet, nnet_min_samples=self.nnet_min_samples, + minority_sz_nnet=self.minority_sz_nnet, use_etc=self.use_etc, etc_max_depth=self.etc_max_depth, etc_max_trees=self.etc_max_trees, N=X.shape[0], current_depth=1, use_oracle=self.use_oracle, + use_cascade=self.use_cascade, ) self.LMTree = tree - # Find all Node Ids - self.all_ids = list(set(self._get_node_ids(self.LMTree))) - - return self - - def _get_node_ids(self, node): - ids = [] - - if node.terminal is False: - ids.extend(self._get_node_ids(node.left)) - ids.extend(self._get_node_ids(node.right)) + self.all_nodes = self._get_all_nodes(self.LMTree) - else: - ids.append(node.node_id) + self.terminal_nodes = [x[0] for x in self.all_nodes if x[1] == 1] + self.all_nodes = [x[0] for x in self.all_nodes] - return ids + return self def _predict(self, X, current_node=None, samp_idx=None): final_predictions = [] @@ -532,7 +598,7 @@ def _predict(self, X, current_node=None, samp_idx=None): current_node = self.LMTree if current_node.terminal is False: - + # Determine where each sample goes D = current_node.splitter.decision_function(X) if D.ndim > 1: @@ -541,10 +607,28 @@ def _predict(self, X, current_node=None, samp_idx=None): L = np.where(D > 0, True, False) R = np.where(D <= 0, True, False) - X_L = X[L] + # Append decision function data + if self.use_cascade: + if isinstance(current_node.splitter, LMClassifier) or isinstance( + current_node.splitter, RandomOracle + ): + C = current_node.splitter.decision_function(X) + + if C.ndim == 1: + C = C.reshape(-1, 1) + + else: + C = current_node.splitter.predict_proba(X) + + X_new = np.hstack((X, C)) + + else: + X_new = X + + X_L = X_new[L] left = samp_idx[L] - X_R = X[R] + X_R = X_new[R] right = samp_idx[R] if left.shape[0] > 0: @@ -558,10 +642,7 @@ def _predict(self, X, current_node=None, samp_idx=None): elif current_node.terminal: predictions = current_node.label(X) predictions = np.asarray( - [ - (samp_idx[i], prediction) - for i, prediction in enumerate(predictions) - ] + [(samp_idx[i], prediction) for i, prediction in enumerate(predictions)] ) return predictions @@ -587,6 +668,22 @@ def score(self, X, y): return score + def _get_all_nodes(self, node): + node_list = set() + + if node.terminal is False: + node_list.update([(node.node_id, 0)]) + + node_list = node_list.union(self._get_all_nodes(node.left)) + node_list = node_list.union(self._get_all_nodes(node.right)) + + elif node.terminal: + node_list.update([(node.node_id, 1)]) + + return node_list + + return node_list + def _proximity(self, X, current_node=None, samp_idx=None): final_predictions = [] @@ -598,8 +695,7 @@ def _proximity(self, X, current_node=None, samp_idx=None): # Check if the node is a terminal node if current_node.terminal is False: - - # Determine splits + # Determine where each sample goes D = current_node.splitter.decision_function(X) if D.ndim > 1: @@ -608,10 +704,28 @@ def _proximity(self, X, current_node=None, samp_idx=None): L = np.where(D > 0, True, False) R = np.where(D <= 0, True, False) - X_L = X[L] + # Append decision function data + if self.use_cascade: + if isinstance(current_node.splitter, LMClassifier) or isinstance( + current_node.splitter, RandomOracle + ): + C = current_node.splitter.decision_function(X) + + if C.ndim == 1: + C = C.reshape(-1, 1) + + else: + C = current_node.splitter.predict_proba(X) + + X_new = np.hstack((X, C)) + + else: + X_new = X + + X_L = X_new[L] left = samp_idx[L] - X_R = X[R] + X_R = X_new[R] right = samp_idx[R] if left.shape[0] > 0: @@ -627,25 +741,103 @@ def _proximity(self, X, current_node=None, samp_idx=None): return final_predictions - def proximity(self, X): + def _proximity_path(self, X, current_node=None, samp_idx=None): + final_predictions = [] + + # Get a list of sample IDs if sample_index is not provided and set the node to the root of the tree + if isinstance(samp_idx, type(None)): + samp_idx = np.asarray([i for i in range(X.shape[0])]) + + current_node = self.LMTree + + # Check if the node is a terminal node + if current_node.terminal is False: + # Determine where each sample goes + D = current_node.splitter.decision_function(X) + + if D.ndim > 1: + D = D[:, current_node.c_choice] + + L = np.where(D > 0, True, False) + R = np.where(D <= 0, True, False) + + # Append decision function data + if self.use_cascade: + if isinstance(current_node.splitter, LMClassifier) or isinstance( + current_node.splitter, RandomOracle + ): + C = current_node.splitter.decision_function(X) + + if C.ndim == 1: + C = C.reshape(-1, 1) + + else: + C = current_node.splitter.predict_proba(X) + + X_new = np.hstack((X, C)) + + else: + X_new = X + + X_L = X_new[L] + left = samp_idx[L] + + X_R = X_new[R] + right = samp_idx[R] + + if left.shape[0] > 0: + final_predictions.extend( + [(entry, current_node.node_id) for entry in samp_idx[L]] + ) + predictions_left = self._proximity_path(X_L, current_node.left, left) + final_predictions.extend(predictions_left) + + if right.shape[0] > 0: + final_predictions.extend( + [(entry, current_node.node_id) for entry in samp_idx[R]] + ) + predictions_right = self._proximity_path(X_R, current_node.right, right) + final_predictions.extend(predictions_right) + + elif current_node.terminal: + return [(entry, current_node.node_id) for entry in samp_idx] + + return final_predictions + + def proximity(self, X, prox_type="path"): if hasattr(self.resampler, "transform"): X_trf = self.resampler.transform(X) else: X_trf = X - tree_predictions = self._proximity(X_trf) + if prox_type == "terminal": + tree_predictions = self._proximity(X_trf) - tree_predictions.sort() + tree_predictions.sort() + + col_dict = {col: i for i, col in enumerate(self.terminal_nodes)} + + emb_matrix = np.zeros( + shape=(X.shape[0], len(self.terminal_nodes)), dtype=np.ushort + ) + + for entry in tree_predictions: + row = entry[0] + col = col_dict[entry[1]] + + emb_matrix[row, col] = 1 - col_dict = {col: i for i, col in enumerate(self.all_ids)} + return emb_matrix - emb_matrix = np.zeros(shape=(X.shape[0], len(self.all_ids)), dtype=np.ushort) + elif prox_type == "path": + tree_predictions = self._proximity_path(X_trf) - for entry in tree_predictions: - row = entry[0] - col = col_dict[entry[1]] + emb_matrix = {} + for sample in tree_predictions: + if sample[0] not in emb_matrix: + emb_matrix[sample[0]] = set() - emb_matrix[row, col] = 1 + emb_matrix[sample[0]].add(sample[1]) - return emb_matrix + return emb_matrix diff --git a/LANDMark/utils.py b/LANDMark/utils.py index 27eafd0..3cd90a8 100644 --- a/LANDMark/utils.py +++ b/LANDMark/utils.py @@ -41,9 +41,9 @@ def predict_proba(self, X): class_map = {class_name: i for i, class_name in enumerate(self.classes_)} # Returns an array that of shape (n_estimators, n_samples) - prediction_results = Parallel(self.n_jobs)( - delayed(self.estimators_[i].predict)(X) for i in range(self.n_estimators) - ) + prediction_results = [ + self.estimators_[i].predict(X) for i in range(self.n_estimators) + ] prediction_results = np.asarray(prediction_results) @@ -74,4 +74,4 @@ def predict_proba(self, X): # Ensure all probabilities sum to one prediction_probs = softmax(prediction_probs, axis=1) - return prediction_probs \ No newline at end of file + return prediction_probs diff --git a/README.md b/README.md index af5ccfa..63e32fd 100644 --- a/README.md +++ b/README.md @@ -29,46 +29,12 @@ An overview of the API can be found [here](docs/API.md). ## Usage and Examples -Comming Soon +Examples of how to use `LANDMark` can be found [here](notebooks/README.md). ## Contributing To contribute to the development of `LANDMark` please read our [contributing guide](docs/CONTRIBUTING.md) -## Basic Usage - - from LANDMark import LANDMarkClassifier - - from sklearn.datasets import load_wine - from sklearn.preprocessing import StandardScaler - from sklearn.model_selection import train_test_split - - # Create the dataset - X, y = load_wine(return_X_y = True) - - # Split into train and test sets - X_train, X_test, y_train, y_test = train_test_split( - X, y, test_size=0.2, random_state=0, stratify=y - ) - - # Standardize - X_trf = StandardScaler() - X_trf.fit(X_train) - - X_train = X_trf.transform(X_train) - X_test = X_trf.transform(X_test) - - # Setup a LANDMark model and fit - clf = LANDMarkClassifier() - clf.fit(X_train, y_train) - - # Make a prediction - predictions = clf.predict(X_test) - -### Specal Notes - -Starting with TensorFlow 2.11, GPU support on Windows 10 and higher requires Windows WSL2. -See: https://www.tensorflow.org/install/pip ### References diff --git a/docs/API.md b/docs/API.md index 99ee2ca..9040721 100644 --- a/docs/API.md +++ b/docs/API.md @@ -5,8 +5,9 @@ of the `LANDMark` class and its methods. ## Class - class LANDMark.LANDMark(n_estimators, min_samples_in_leaf, max_depth, max_features, min_gain, impurity, use_oracle, use_lm_l2, use_lm_l1, - use_nnet, nnet_min_samples, use_etc, etc_max_depth = 5, etc_max_trees = 128, max_samples_tree, bootstrap, n_jobs = 4) + class LANDMark.LANDMark(n_estimators, min_samples_in_leaf, max_depth, max_features, min_gain, impurity, q, use_oracle, + use_lm_l2, use_lm_l1, use_nnet, nnet_min_samples, use_etc, etc_max_depth = 5, etc_max_trees = 128, resampler = None, + use_cascade = False, n_jobs = 4) ### Parameters @@ -17,8 +18,8 @@ of the `LANDMark` class and its methods. min_samples_in_leaf: int, default = 5 The minimum number of samples in each leaf to proceed to cutting. - max_depth: int, default = -1 - The maximum depth of the tree. '-1' implies that trees will fully + max_depth: Optional[int], default = None + The maximum depth of the tree. 'None' implies that trees will fully grow until a stopping criterion is met. max_features: float, default = 0.80 @@ -68,16 +69,17 @@ of the `LANDMark` class and its methods. etc_max_trees: int, default = 128 Specifies the maximum depth of trees used to train each ExtraTreesClassifier. Only used if 'use_etc' is set to True. - - max_samples_tree: int, default = -1 - Specifies the maximum number of samples used to construct each tree. - A stratified random sample is chosen to construct each tree. If '-1' - is selected, all samples are chosen. - + resampler: The resampling object. Cloning of the object must be possible and, at a minimum, the object must have a 'fit_resample(X, y)' method. The resampling object can also have a 'transform(X)' method if a user-defined transformation occurs during fitting. + + use_cascade: bool, default = False + This parameter extends 'X' using the information returned by the best decision + function within each node. By doing this, information about the split is + retained and has the potential to be used within deeper nodes of the tree. + The inspiration for this idea comes from: https://www.ijcai.org/proceedings/2017/0497.pdf n_jobs: int, default = 4 The number of processes used to create the LANDMark model. diff --git a/notebooks/ExampleUsage.ipynb b/notebooks/ExampleUsage.ipynb new file mode 100644 index 0000000..7e58d59 --- /dev/null +++ b/notebooks/ExampleUsage.ipynb @@ -0,0 +1,249 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "232ad2ee", + "metadata": {}, + "source": [ + "#### Import Required Files" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "42cd6666", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\miniconda3\\envs\\testLM\\Lib\\site-packages\\umap\\distances.py:1063: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @numba.jit()\n", + "d:\\miniconda3\\envs\\testLM\\Lib\\site-packages\\umap\\distances.py:1071: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @numba.jit()\n", + "d:\\miniconda3\\envs\\testLM\\Lib\\site-packages\\umap\\distances.py:1086: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @numba.jit()\n", + "d:\\miniconda3\\envs\\testLM\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "d:\\miniconda3\\envs\\testLM\\Lib\\site-packages\\umap\\umap_.py:660: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @numba.jit()\n" + ] + } + ], + "source": [ + "from sklearn.datasets import load_breast_cancer\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import balanced_accuracy_score\n", + "\n", + "from umap import UMAP\n", + "\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from LANDMark import LANDMarkClassifier" + ] + }, + { + "cell_type": "markdown", + "id": "a4ffcd8c", + "metadata": {}, + "source": [ + "#### Load data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4988ea4a", + "metadata": {}, + "outputs": [], + "source": [ + "X, y = load_breast_cancer(return_X_y = True)" + ] + }, + { + "cell_type": "markdown", + "id": "95bf8b65", + "metadata": {}, + "source": [ + "#### Split into training and testing sets" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "36e413dd", + "metadata": {}, + "outputs": [], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, \n", + " y, \n", + " test_size=0.2, \n", + " random_state=0, \n", + " stratify=y)" + ] + }, + { + "cell_type": "markdown", + "id": "d18cd1da", + "metadata": {}, + "source": [ + "#### Standardize data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8e9d8872", + "metadata": {}, + "outputs": [], + "source": [ + "trf = StandardScaler().fit(X_train)\n", + "\n", + "X_train = trf.transform(X_train)\n", + "X_test = trf.transform(X_test)" + ] + }, + { + "cell_type": "markdown", + "id": "10ca968a", + "metadata": {}, + "source": [ + "#### Setup model and train. Note, to obtain the best score cross-validation of relevant hyper-parameters should be performed. This is just a simple example." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "151d5379", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
LANDMarkClassifier(min_samples_in_leaf=2, minority_sz_nnet=24, n_estimators=16,\n",
+       "                   use_cascade=True)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "LANDMarkClassifier(min_samples_in_leaf=2, minority_sz_nnet=24, n_estimators=16,\n", + " use_cascade=True)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clf = LANDMarkClassifier(n_estimators = 16, n_jobs = 4, min_samples_in_leaf = 2, use_cascade = True, minority_sz_nnet = 24)\n", + "clf.fit(X_train, y_train)" + ] + }, + { + "cell_type": "markdown", + "id": "c39da47b", + "metadata": {}, + "source": [ + "#### Calculate balanced accuracy score" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "844c29ce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9692460317460317\n" + ] + } + ], + "source": [ + "BAcc = clf.score(X_test, y_test)\n", + "print(BAcc)" + ] + }, + { + "cell_type": "markdown", + "id": "7afac929", + "metadata": {}, + "source": [ + "#### We can visualize the output of each sample using LANDMark's proximities and UMAP. Note, this projection is constrained using the class labels. Another notebook will describe how to create an unsupervised projection of LANDMark proximities." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a8682a0e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\miniconda3\\envs\\testLM\\Lib\\site-packages\\umap\\umap_.py:1802: UserWarning: gradient function is not yet implemented for hamming distance metric; inverse_transform will be unavailable\n", + " warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prox = clf.proximity(X_test)\n", + "\n", + "X_test_umap = UMAP(metric = \"hamming\").fit_transform(prox)\n", + "\n", + "sns.scatterplot(x = X_test_umap[:, 0],\n", + " y = X_test_umap[:, 1],\n", + " hue = y_test)\n", + "\n", + "plt.show()\n", + "plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50e2f92f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/ParameterChoices.ipynb b/notebooks/ParameterChoices.ipynb new file mode 100644 index 0000000..9673a5c --- /dev/null +++ b/notebooks/ParameterChoices.ipynb @@ -0,0 +1,584 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4de8df46", + "metadata": {}, + "source": [ + "#### Import Required Files" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e4edf795", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.inspection import DecisionBoundaryDisplay\n", + "from sklearn.datasets import make_moons\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import balanced_accuracy_score\n", + "\n", + "from LANDMark import LANDMarkClassifier\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "d306e6fc", + "metadata": {}, + "source": [ + "#### Load data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "601edf31", + "metadata": {}, + "outputs": [], + "source": [ + "X, y = make_moons(noise=0.3, random_state=0)" + ] + }, + { + "cell_type": "markdown", + "id": "b9dd9c89", + "metadata": {}, + "source": [ + "#### Split into training and testing sets" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c070bdd6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, \n", + " y, \n", + " test_size=0.2, \n", + " random_state=0, \n", + " stratify=y)\n", + "\n", + "# Plot moons\n", + "sns.scatterplot(x = np.hstack((X_train[:, 0], X_test[:, 0])), \n", + " y = np.hstack((X_train[:, 1], X_test[:, 1])), \n", + " hue = np.hstack((y_train, y_test)), \n", + " style = np.hstack(([\"Train\" for _ in range(X_train.shape[0])],\n", + " [\"Test\" for _ in range(X_test.shape[0])])))\n", + "plt.show()\n", + "plt.close()" + ] + }, + { + "cell_type": "markdown", + "id": "1da16fc2", + "metadata": {}, + "source": [ + "#### Setup model and train. Predict class labels and score. Plot decision boundary. No L1, Neural Network, or Extra Trees" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9870b968", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.95\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_17960\\3307156328.py:13: UserWarning: You passed a edgecolor/edgecolors ('k') for an unfilled marker ('x'). Matplotlib is ignoring the edgecolor in favor of the facecolor. This behavior may change in the future.\n", + " DB.ax_.scatter(X_test[:, 0], X_test[:, 1],\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "clf = LANDMarkClassifier(n_estimators = 16, use_lm_l1 = False, use_etc = False, use_nnet = False)\n", + "clf.fit(X_train, y_train)\n", + "\n", + "score = clf.score(X_test, y_test)\n", + "probs = clf.predict_proba(X_test)\n", + "\n", + "print(score)\n", + "\n", + "DB = DecisionBoundaryDisplay.from_estimator(estimator = clf,\n", + " X = X,\n", + " response_method = \"predict_proba\")\n", + "\n", + "DB.ax_.scatter(X_test[:, 0], X_test[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_test], \n", + " edgecolor=\"k\", marker = \"x\")\n", + "DB.ax_.scatter(X_train[:, 0], X_train[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_train], \n", + " edgecolor=\"k\")\n", + "plt.show()\n", + "plt.close()" + ] + }, + { + "cell_type": "markdown", + "id": "1fb120b1", + "metadata": {}, + "source": [ + "#### Setup model and train. Predict class labels and score. Plot decision boundary. No L2, Neural Network, or Extra Trees" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3c0ef663", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_17960\\120678232.py:13: UserWarning: You passed a edgecolor/edgecolors ('k') for an unfilled marker ('x'). Matplotlib is ignoring the edgecolor in favor of the facecolor. This behavior may change in the future.\n", + " DB.ax_.scatter(X_test[:, 0], X_test[:, 1],\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "clf = LANDMarkClassifier(n_estimators = 16, use_lm_l2 = False, use_etc = False, use_nnet = False)\n", + "clf.fit(X_train, y_train)\n", + "\n", + "score = clf.score(X_test, y_test)\n", + "probs = clf.predict_proba(X_test)\n", + "\n", + "print(score)\n", + "\n", + "DB = DecisionBoundaryDisplay.from_estimator(estimator = clf,\n", + " X = X,\n", + " response_method = \"predict_proba\")\n", + "\n", + "DB.ax_.scatter(X_test[:, 0], X_test[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_test], \n", + " edgecolor=\"k\", marker = \"x\")\n", + "DB.ax_.scatter(X_train[:, 0], X_train[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_train], \n", + " edgecolor=\"k\")\n", + "plt.show()\n", + "plt.close()" + ] + }, + { + "cell_type": "markdown", + "id": "2bb75066", + "metadata": {}, + "source": [ + "#### Setup model and train. Predict class labels and score. Plot decision boundary. Only linear models and no Neural Network, or Extra Trees" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bad61aa7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.95\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_17960\\909056146.py:13: UserWarning: You passed a edgecolor/edgecolors ('k') for an unfilled marker ('x'). Matplotlib is ignoring the edgecolor in favor of the facecolor. This behavior may change in the future.\n", + " DB.ax_.scatter(X_test[:, 0], X_test[:, 1],\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGdCAYAAAAvwBgXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACDV0lEQVR4nO3dd3xb1f3/8de9Wpb3tuPsvckiCSSMJIQR9gpQoIQ9Cv1B6QAKZfVLQwttoewdVth77yRsQkISsveOneEta9/7+0OR4yHJsq3tz/Px8CNY90o6FrbuW+d8zjmKrus6QgghhBBxoMa7AUIIIYTouiSICCGEECJuJIgIIYQQIm4kiAghhBAibiSICCGEECJuJIgIIYQQIm4kiAghhBAibiSICCGEECJujPFuQCiaprFz506ysrJQFCXezRFCCCFEGHRdp66ujrKyMlQ1dJ9HQgeRnTt30rNnz3g3QwghhBAdsG3bNnr06BHynIQOIllZWQBMyT8fo2qOc2uEEE15+naLdxOESEh1fazxbkLc1ea7WPfYnY3X8VASOoj4h2OMqlmCiBCJxpgW7xYIkVDq+voCSEJfWKOsvrtvGMbg9P0bTlmFFKsKIYQQIm4kiAghhBAibiSICCGEECJuJIgIIYQQIm4kiAghhBCd5C9U7cr8hart1ZWLe4UQnWDcsAMAT//ucW6JEPEjAaTjAcRPekSEEJ3iDyRCdDUSQjofQkCCiBAiAiSMiK5GQkhkQghIEBFCRIiEESG6hvruasRCCEgQEUIIIUSYIhlA/CSICCGEEKJN0QghILNmhBBCiHbpavUh0QogftIjIoQQQoRJQkjkSY+IEEII0YauFkAgNiEEJIgIIYQQIXW1EBKrAOInQzNCCCFEEBJCok+CiBAiYmQtEZEq6vpaJYTEiAzNCCEiSvagEclOAkhsSY+IECIqpHdEJCMJIbEX/xYIIVKWhBEhElcihBCQoRkhhBCiS0mUAOKXWK0RQgghRNQkWggBCSJCCCEEkPr1IYkYQkCGZoQQQoiUDiGJGkD8Ert1QgghRJRJCIkv6RERQgjRJaVyAIHkCCEgPSJCCCFEykmWEAISRIQQUSZriQghQpEgIoSIOgkjQohgJIgIIWLCuGGHBBIhRCsSRIQQMSVhRCSCVC5UTab6EJBZM0IIIbqQVA4gkDghxN5dC/tcCSJCCCG6hFQOIYkSQAAaemjgCP/8xGm5EEIIESUSQmKjoUf4PSF+0iMihBBCJKFkDyB+ifNTCCGEECIsqRJCQIKIEEIIkVRSKYSADM0IIYRIcalSH5JqAcQvqj/V7NmzGT9+PFlZWRQXF3PqqaeyZs2aaD6lECIJyFoiIlYkhEReJEMIRDmIzJ8/n6uvvpoffviBzz77DLfbzTHHHIPNZovm0wohkoCEERFtEkIiL9IhBKI8NPPxxx83+37OnDkUFxezaNEijjjiiGg+tRAiCRg37MDTv3u8myFSjASQyItGAPGL6U9ZU1MDQH5+fiyfVgiRwGQPGhFJEkIiL5ohBGJYrKppGtdddx2TJ09mxIgRAc9xOp04nc7G72tra2PVPCGEECIhdKUQAjEMIldffTXLly/nm2++CXrO7NmzueOOO2LVJCGEECJhdLUA4heTn/qaa67h/fff56uvvqJHjx5Bz7vpppuoqalp/Nq2bVssmieEEELEVVcNIRDlHhFd1/n973/PW2+9xbx58+jbt2/I8y0WCxaLJZpNEkIIIRJKVw4hEOUgcvXVVzN37lzeeecdsrKyKC8vByAnJwerNTUKioQQQsRfMhapdvUA4hfVV+GRRx6hpqaGKVOm0K1bt8avV155JZpPK4QQoguRENI58QwhEIOhGSGEECJaJIR0TrxDCMheM0IIIZJUsoUQCSCBJc6rIoTo0mRhM5HKJIQElzivjBBCIHvQiNSTKCGkoYeWcCEEZGhGCJGA/GFE9qERySxRAggkXi9IU4nzKgkhhBBhSvT6EAkh4ZMeESGEEEkj0QMIJE4ISfQA4idBRAghRFJI9BCSKAEEkieEgAzNCCGESAKJHkISSTKFEJAeESGEECIlJFIAMZQ2hH2u9IgIIYQQSS6RQoixLPwQAtIjIoQQQiS1RAkh7Q0gjfeLcDuEEEKIiEqG+pB4FKomSgCBjocQkCAihEhgsrCZSPQQEosAkkiBI5DOhBCQGhEhRBKQZd+7JgkhiR1CjGUNnQ4hID0iQogkYdywQ3pGuohEDyAQ/RCSyAEEOt8L0pT0iAghkob0jKS+RA8h9d1VCSERDCEgPSJCCCESRDKEkGhL5BAS6QDS+LhReVQhhBAiTIkeQECGYqIVQkCCiBBCiDhK9BDS1XtBILohBCSICCGEEAF19RAS7QDS+DwxeRYhhBAiichQTGxCCEgQEUIIIRp19V4QiG0IAQkiQgghBCAhJNYBpPF54/KsQgjRQcEWNnM4a9i663v27V2Ky+MgPS2P0pIJlJWMw6Ca4tBSEUqiFanKUEx8QghIEBFCJKGWe9DU2XaxdMXTWLxOLkWnN/CtfQ9vb/6APXuXMWrYhRgM5ji2WDSVSCGkq/eCQHRCyOCSPWwM81xZWVUIkbSMG3ag6xor17zEYK+TjejcB/wBeB34BrDXb2fDti/i2k5xgISQxBGpvWJaGlpa0a7zJYgIIZJazaqfqHNW8TA6+S2OHQJci055xc94va54NE80kSghJFbLtCd6CImG9oYQkCAihEhyNZ7d5KFyaJDjpwAuzUWDY18smyUSVFfvBYHohJChpRUdCiEgNSJCiCSnoOJGx0vgNzT/W66iyOeurq6rh5BEGIYJRP4yhRBJrdDck3p03g1y/Dkgw5RFhrUols0SCUSGYiIfQjrTA9KS9IgIIZJatqmQwuw+XF67he7oTNx/uxd4DHgWGNT9cOkRibN41Yd09V4QiGwIiVT4aEqCiBAi6Q0bdA7LVs7hkIZyJqDQF51vUdmORo+SCfQsPSTeTezSJITERyQCSDSCR0sSRIQQSc9symDsyCvZU7WKzXuXscFjJy2tkPEl48jJ7BHv5nVZqRxAILVDSCwCiJ8EESFESlBVAyUFIygpGBHvpggSZ6putKRiCIll+GhKBk2FEEnPv9KqELGQqCGkMwuUxSuEgAQRIUSKkDAiYiGRQ0hHxTOEgAzNCCFSSMs9aISIlEQNIJB8QzEtSY+IECLlRLR3RNc7dkzERTQKVRM1hCTrUExLEkSEECIIVfdy4/rXObH8p1bH0rxO7l71LBOr1sShZYmrrq81LoWq0Vq0LJFDSEclUggBGZoRQoigjty7nKP2LuOovcsAeL90AuALIXetep6D6rbQr6GcC8Zcj8NgjmdTE0IqTddN1AACyT8U05IEESGECOKrwoMYYNvFWbu+5dpN7wHwedGoxhBSb0jjb4PPlxCChJBYSKVekKYkiAghRDCKwhO9jwVoDCP+QFJvSOPGobNYkyULpsVrKCYaEjGEtCeAJHLgCEaCiBBChLI/jFg1FydVLGy8WUJI/EgvSGvJGED8JIgIIdrk1pxsta9gt2MNTs1OmppBqXUoPaxDMSqmeDcv6tI0F70bdje7baBtpwSROOgqISTVe0GakiAihAjJ4a3n56q3cWs2zkJnKPCL18Wb9d9Rbl/N2LyTMatp8W5m1DQtTLUZLKzP6Mao2s2NQzT+AlYRXTIUE1iyhxCQICKEaMOK2i/J0Wx8jU7fJrf/ChzprWJ13TcclDM9Xs0LyrhhR6cXNmsaQhprQjK7c9mWT5oVsHblMBKL+pBU7QVJ1eLT9pJ1RIQQQdV7qtjj3sm9LUIIwEjgVnTKnRtweju/3Xg0dHZhs4Or1zcPIVk9GmtGXu02GYCzd35NmtcVieYmlVitFyIhpLVUCiEgPSJCiBCq3b43vFODHD8d+AM6NZ49FBt6x6pZ7dKZnpFvCobzn36nsDG9tHk9yP4wUmtKZ37BiC43fTdZAwhICElEEkSEEEEpKAC4gEBVIM7G8xK7c7Uze9B8VHJw4AOKwivdj+hMs5JSsoYQCSCJS4KIEEmgwVvLNvtK6twVgEKBpRfd04ZEvUg039wdBXgRuCrA8RcBEwZyTcVRbYfoOlIhhHQmcASSyiEEJIgIkfC221ezom4+2cBx6NiAT9w72WxbzJjcE8g1lUTtua2GTLpZ+nODcyPD0fF//teB94DZQLe0oexz7WCXYw1uzYZJzaS7dQhF5l4oSmL3lIjEkSpDMRJC2k+CiBAJrNpdwYq6eVwC3A+k77+9AjhNd7O4+gMOKzgPk2qJWhuGZR3JL956jvRUMB6FYegsQmE5OkWmHti8e9lau5zxKIxE5xf2sdi1mSJTd0bnzsCgyNuMCE16QVrrCgHET94hhEhgWxqW0g+FR9ExNLm9BHgTnZ66ix2ONfRJPyhqbTCqZsblncIe1xa22tewQbNhNmQxLm0IuxxrqXFu4CtgCvr+e+h8Apzq3snquu8Ynt316ig6TNdBUdp/LEaiUR8S6RASj1oQCSGdI0FEiARW6drGlS1CiF8pMB1Y5Nwa1SACoCoqJZa+lFgOTOJ1eG384tzAf9CZ0uL8Y/FN7b3VsZqBmRNSesGzSOlv28nvNn3E3wefTbUps9mxCVVrObn8R/4+6GyccZqhE+kQkgoBBKQANRJkAFeIBKbresDZKn7pgN7YExFbVe5daOicF+T4eYAHjWp3eSyblZQUXeOGdW9wUN1m/rXiGXLd9Y3HJlSt5bY1c5lYvZYzdn0Xl/ZJCGnNWNbQ4RAytLRCQkgTEkSESGA5pmLeIHB3fB3wCQo5USxWDUXH9+Yf7PO5ufG8+ASlZKIrKncM/g17TVn0te9uDCP+EGLWvSzIH8YrZYfHtF3RWLQsVUJIR0kAaU2CiBAJrGf6QfyEzv9a3O4BfgfYgR7WYbFvGJBr9AWgt4IcfxNQUcgxFsWsTW3p7Eqr0bTDWsifhl/cGEZe+/mf3LX6+cYQ8o+BZ+FVAw3SJYf67mpEQ0hDD01CSIqQICJEAisy96ZP+iiuBcahcBdwM9APhbkojMiehtWQ2cajREe6MYcSc0/+gsLaFsdWAH9DocTSh7Q4tS+YZAgjTS3L6pMSISSSoh1A/MMugb46QoZiQpNiVSESmKIoDM44hHxTGdsafuX/PBWoqOSae3NI+kFkmwrj2r5hWVNZVP02I7y1nAEMB5bi6yXJNOQyNOvIuLYvmEhsiBct3R2Vzb7PddeT5bVTrSZWoAtXpHtBok1mwMSeout6wg7g1tbWkpOTw/TCizGqXWsvB5G8NF1jj2sLFY6NePGQYcijh3UI6YbseDctKjyai22OVZTbV+HSGshUrRRYh9MjbShG1dR4Xo5mR9V1qgzpIR4t9hIpkDStCdmQXkK+q548j41N1mL+MvyiVrNpoqmztSHJFkAgsiGkqwcQt83FR8c9QU1NDdnZod/7ZGhGiAhyeG38VPkav9R8QqFzPaOcm9jT8Atf75vL5oZl8W5eVBhVM33TRzEl/wy+MxaxWndxuLlnqxByd9W73F39HnkJulNvvLUsTL165FX8YcSlrQpYYyGVQ0ikh10C6eohpL0kiAgRIbqus7TmI9K81fwALN2/sNcudP4ArK7/jgrnpji3MnpMupcs3UG+Zufu6nfp6akCDoSQPt4q0nUnabo7zi1NPIquccG2L1sVprYsYJ2+Z2lU29HeWTL+AtSWX5EQjWLUSA+7BCIhpP1kaEaICNnn2s7C6vf5ApjW4pgOTEFhubGQCflnxKF1sZGlOZhd/R79PfuoVK3cnX00v6v7mj7eKvaq6dyQezI7jbnxbmYziTI0k+O2MXPnNzzTc3qrwtTu9n0cue9X5nY/Mmqrq7Y3gERTNIZioh1CJIA0J0MzQsTBbudWeqAwNcAxBbgUnUrPHlyaI9ZNi5k6NY2bck9ig7GAfM3Ov6rfTegQkkhqTBk82fvYgLNjdlgLmNtjioSQDoj0sEsgEkI6R2bNCNGEV/ew27mZBm8NRsVCiaUvaYaMsO6r4yULBSXIAl65+//VdG9kGpug6tQ0/pk9nccrX2m87cGsIySEJKhwQ0iiB5BYDLs0JeEjciSICLFfuWMDq+vm49Bd5KFQh86a+m/paR3B4MxDUdvY0j7LWMhKNDYDfQIcfx9IV6xY1MhvHJZIcjQ7f635tNlt/69uPjcacthmzItTq0QgEkLaR8JHdMjQjBDAXuc2ltZ+xgm6izVAJTp7gLvQ2Wb/lTX1be/x0S1tAGbFxNWAs8WxBcAcFMrSh6O0EWiSWdPC1L1qOn/IO61xmKZpAauIv1QIIbEYdvGTEBI9qfuOKEQ7bLT9xCTgFWDQ/ttygRuBfwDb7CtweG0hH8OomBiRfTSfoDJk/yqoTwHn4CtezTaV0jd9dJR+gvjLbhFCbsg9mdWmkmY1I3dXv0t3T3W8m9rlhRNCIr0ke0udnRUTy6EYCSHRJUFEdHkN3loqPXu4Dgi0iPaVgBGdcufGNh+ryNKLiXmn47L053YMXAp8pGYzMHMSY3NPxKC0bzTU7q1nn2sHNe49RHuCm0dz0eCtxaO5OnR/u2JiryGzVWFq0wLWGsVKvWqJYKs7z7hhR0Iv+x4PidwLArEdipEQEn1SIyK6PLfmG0jpE+R4DpCLijvM2S6ZxjyKLH1IM2RjUIyUWvqR0c5CTZunmjX137LHta2x9DVLzaJv5njK0gaFvG9Tqq6hBRkK8h+r91SzwfYTFc5NaOioKBRb+jIgYzyZ7ajpcCtG7sw5ljytgd0tVpH1hxEVnZoErZFJ5GXfYymRQ4j0gqSmqP7GLViwgJNOOomysjIUReHtt9+O5tMJ0SFWQyYqCj8EOb4J2IMW1hLtu51bWLD3OZbWfo6tYQk7bAv5uvJlltV8hjfMhbwaPDUsrHqTDNd2ngTWAl8CR2l1LKv9ki0Ny8N6nEzNyb1V73CEY32rY8XeWh6sfJ0i+2oWVr2B2bmJe9H5DPgPOmnOTfxU+Qa17r1hPZefWzG2CiF+dWpa2CHEqdnZYFvMouoPWVz9EZsbljUGxmjqCj0jwYZlZCjmAAkhsRXVIGKz2Rg1ahQPPfRQNJ9GiE4xq1aKzX34FwotL7sacAtgUkyUpvUL+ThV7nKW1HzMNN3JKqAcjX3oPAlUOjfya80XYbVnne1HCnU3C9G5GBgITAXeBH4HrK//PqyL8gn2FQz1VPCX2i+ahZFiby3/qnqXvt5KltV9zQDdw9L9q79OB64FlqEzFC+r6r4Kq82RtNu5ha/3vsBW208c7NrKKNcW1tV/xzf7XqDKtSvqz5/KYSRUCImm9gSQaC+/HooMxcRHVIdmZsyYwYwZM6L5FEJExKDMQ1hYtZNxuosb0JkMbAHuB74CRmYdjkExhXyMTbZFDAXeBvxnpgGXAGnonO/aTK17b8gdc92akwrnJv6NTkGLYwrwN+AxvKyrX8iw7MNCtufV9DGUeWs4xrGGv9T6QtBqUzH/qnqXEq2ez9RMlmr1vI1v+KmpLOD/0DnJs48a9x5yTEUhnytS6j3VLK35hBPQeAbI33/7LuAs3c1PNR8yueA3WNTE2jgv0cUrgED4ISTW64C0JAEkPNMKV4d1niPNw0dhPmZC1Yg4nU6czgOf9Gpra+PYGtGVpBtzGJ93Omvqv+Ma15bGuoxcQz5jMidQbOkT8v4ezcUe1zbu5EAIaeps4FoUyp0bQgYRp2ZDQ2d8kOOlQDdgq2M5VmNmyFk4uqJwX9YUAI5xrOGm2s8bj2035HCH9SCo/5opQe7vv93mrY5ZENlq/5U8dF7BF+L8uuELeN11D9vtq+ifMS4m7UkFTUNILIKHX3t7QeJJQkjbwg0gHZFQQWT27Nnccccd8W6G6KLSjTmMyZ2BU2vA7q3DpFhIN+SghLGstkd3oQM9gxw3At1QqNFDD6mYFN/ldz0wOcDxOqAS31DNV/U/UGDqETLY+MNIsbee0e4DQw435J6Mw+MbiNpF6x4R/+3gm5YcK1XOzVyM3iyE+BUAJ6PzpXOLBJEwJXoIkQCSHKIZQiDBgshNN93E9ddf3/h9bW0tPXsGe2sXIjosanq7u/7NqhUzRr7Fw/EBju8F1qLRzxDokt/kuQ3pFJrKuN+9i3PRW/WuPAY48K1PcigK2+wrGW46IuRjFml1lHlrmt02wr2LPZY+WBQTD+tu/hfgfg8DZsVEgTl2M0k0XSMzxPEsfEvpi7a1Z/+YSAoUQuIdOAKRENJctMNGKAm1jojFYiE7O7vZl0h9uq5T7a5gp2Mde5xbk3IvFlUxUGodwkMotFxtRAduB7yoYU297Z8xnqXACcDi/bftBf6Ob4G1q4G+wIno2Nyh30z9hanFWj07DdksNPuC/V9qv2CqczO908fywP7H9g+E1uFbxO0+oHf66DZrYyIp01TM20F263ED76OQYSqJWXuSUV1fa6sQEqtaEAkhySmeIQQSrEdEdD1Vrl2srptPjbe68TarYqFvxnh6pY+IX8M6YEDGOBY6tzBeq+d6dKYD5cAjwCfAsMxJmMOYvppn7saYnOOZV/Mh49DJAOz4ak/+ANy9/7waQFECLcHm4w8hJVo92w053JB7MlVqOtfVzWssYNWzpvFU+hhub1jCbKAnCtvQcaDTN300/dLHduYlabee6SP52bWF/wB/bHK7DvwV2I3OZOvwmLYpmUgvSHASPgKLdwiBKAeR+vp61q8/MG1w06ZNLFmyhPz8fHr16hXNpxZJoNpdwaLq9zgYjTuASfjW7LhPd/J0/Td48dI3fVScWxk+s2rl4PzTWVv/A7c71nELvjfnXEMeozMOpjStf9iPVWTpSWnaMKocK/gbUAicvP9f8PWQvIdCrxBFtIc4tzQLIZX7dxFuWsB6gmMV3+SeRC/rcHY61uHUbPRUM+iWNhCrIdQgSXQUmnvQL30Mf2r4hddQOAsdD/ACCr+iMyRzElnGlvOJBAQOIfGalptIIaQrBZBECBUdoehRXDd63rx5TJ06tdXts2bNYs6cOW3ev7a2lpycHKYXXoxRNUehhSKefq56h+7ucn4IUJx4HfAwBo4ovABTgi0JHg6P5sKu1WFQTFjVrLAKXluyear5vvJVjkFjDuCft7IdOAuFxYqRSQXnhtzN94SGFXxv6dMYQvwUXef0hqV8aB2GPQH/tnY7N7OtYRlV7nIUFPLN3emVPiqm9SrJsspqPAIISC+IX7Je/KPNUe/hxvHzqampabPMIqpBpLMkiKQuu7eO+fte5AXgvADHdwE9gGFZR9LDOjS2jUsge5xbWVbzKeDhSMCDbydfs2JhdO7x5MayXkLXUfDNxGlJ0fWAt6eCRA4kiRBCEi18QOx6Qbp6CDk+c2XQY/V1GmOHVYQVRKRGRMSFU/O9eQWrAukG5KI0ntdVFVl6cXjh+exwrGGZaxeKojDE1J2ytEGxDee6zoW2n8jTGrgva0qz0KHqGn+p/YLNxnxeTsFptYm6B028h2ISMYCA9IJ0RKhAEQsSRERc+KfHLgcCVYHsBKrRKZMVNDGrafRNHxXXepm+nn2c2bAEw/75LP4w4g8hRzo3MMm5iQWW/o277qaSRAojibBMe6KFkFjWgaRSCIl3APGTICLiwmrIotDUjXvc5ZwRoEbkX4ABAyWW0Pu7iNjYZCrknuyj+HPtFxzjWAPAA1lH8KfaLznMuYE5KNxuyKK88nUMipHCtP70to5s967DIjQJIc11NoCkUqhor0QJISBBRMTRgMxD+LnqHaaicwdwKLAZ3/oVTwODMyckZaFqqpqfNgCgMYwc41iDBzgLeBOdo7y1/A6d3bqHZ+0r+cG+mjG5J5BvLotru1NFPEJIIgaQzoSPVA8eiRQu2kOCiIibXFMJ43JPYlXdfI5tsY7IsCRcR6QrmJ82ABWNv9R+CcADwDv49oE5pckyZHegcyIaP9R8wuGFv8WgyFtNR0kviPR8tCVZA4ifvDuIuMozd+OQ/LOp8ezG7q3DqFgoMJehhlioKxXZvfXUuHejKAp5pm6Y1UC7rcSfqmtMdG4BfIuMPQicA5zS4rwM4El0BupOdjnW08M6JLYNTXGRDiGh9oaJZQiRwNF+yR5CQIKISACKopBrKontVNQE4dLsrKxdQIVrU2N/ggGVsrTBDMmanFA9CU0LU92ofGHqxkb3Dv4V5Pz+wEGA27kVJIi0Wyx6QhIlgIAMuYSSCmEjlMR5lxOii/FoLhZVvYPRW8PDwOmAE3gBjTscq3F4axmbewKKEv8toVqGkLtyjuEbUzfY+wz2EPezoeAyRG/ZcV3XqfZUYPNUY1RMFJp7gqJQ596Ljk6WsSAp64wkhIQv1UJIqoeOQCSICBEn2xyrsHmrWQoMa3L7TcAYdGa4d7DHtY1iS+84tfCAHt5qJri2NIaQHy19MAF5xkKe8+zl/AD3+QlYj85Yc3R20K52V7Cq9qtm+xSpKBhQcO9fXt+EgW7WIQzKPARjDDfv64xY7BeTKEuzy1DMAV0xgPhJEBEiClyanSp3OQA5xmLSWiyxDlBhX83pNA8hfscBo1HYYV+VEEFkqzGfv+WcQKbu5Mcm+9v0Sh/NZ7Wfcye+AOW/1K8FfoNCtiGLInPk95Wq8+xjUdW7jEJjNnA4vjqVL9G5Hp3f4HtzewMv/7SvxObey7i8kztVexTttUTaCiDt7Q0J1eMRSKLWgqRS2AimK4cQkCAiRER5dDer675ll2Mt3v2fylUUSix9GZp1RLMiVKdmC7iYm99odLZqtii3OHwrzN1a3dYtbQA2TzW3NfzMo8AUYDfwJZChZjA2JzpDSxvqF9ILjXn7dyf+AN8Ox+/g2xzQbzgwHZ3DPBXsdKzrdNFsJMNINHs+2hNCErkXJFVCSFcPGm2RICJEhGi6xpLqD7G5y5nd5FP5m+jc4tzEYk81B+ef1jhEYFbTWe51BX28X1Ewqa17UhKKrvN3vAwDHgMWYyQfD08AGebePGsIvcdER7g1J7tdW7h/fwgBeAoYR/MQ4jcJOBZYaF8Zkdk7xg07gI7vQRPtoRcJIbEjASMyJIgIESG7nZvZ697FF8C0Jrf/DjgMnTHeSnba1zSuj1KaNoTXbT9wOzCoxWN9ASxCZ4x1cCya3jG6zizbT5zT8AsAIzInszF9JEfbV3FJ3XxwrCBNUXkscxJEcEM8t+5EQ6fpVohbgAkh7jMB+NpbF7E2QMd6RzoaQsIZlknEoZiO1IAkQwABCSGRJEFEiDa4NAc17t2ATo6pGLMa+GKyy7GaCShMo/WG1gfh+7Q+37GqMYj0sA5ll2Mlh3vruBu9cdbMi8AtKBSaSik2x78+JJgybw2nNywD4JHMybybPhKAT/bvlnxd3XxOtK/gE+sQNhsLQj6W/4Lu720IxaykoaKwFJ2j9t9WCKwPcZ91gCnOa7NEqyckkQJIqvV4BCIBJPIkiAgRhEdzs6b+W3Y2qfcwoNItbRBDMidjVJvPwnB56xkTIIT4jQI+9R6o+TCpFsblnsrKuq+42LWNi/ffbkCh1DKQodmHJ8TU3WB2GnO5I+c4untreK/FKrj+MFKrpoUdQpr+d6hAYlTNlFr681/nBi5CJw84F7gQWAKMbnH+ZuANoG9afHqXOhtAWvaGtDd4NJUIISTZAogEj+iTICK6vAZPDTud63BqDaSpGZSlDcKipvNL9QfYPRX8HzpnAwrwKhp3Otaw2FPJwXmnNJuFYTJk8Ku3CoKEkRUc2HXYz2JIZ0zuCTR4aqj27EZBId9UhsWQHLsOL7b0ZDGBp+f6w0gowYY2PP27hwwj/TPG85NrK4fqbu5AZyowBDgauB84E1CB94FrUTCrGfQIoz2Rkii9H011hRCi6zqLP6xgwfPb2L6yDoNRYfiUQqZe1JteI4PXK0nYiC9F1/XgH+HirLa2lpycHKYXXoxRNce7OSLF6LrGqrpv2epYQRYKvVHYhE4DOoXm3uxxbWEBvqmhTX0HTAZGZk2ju/VAdccux3qW1n7O18BhLe6zChgJDMycTJ/9QxhdXVv1FW0N09R7Klldu4C9nvLG20wouNEx4guObqDAWMKInOlYDVmdb3QTwdof6RDStEekI0EkWgGkvfUfsQghL/9tFT++sQtFBX3/S6UaFHRd5/x/DWfcCaXN7iMBJHrq6zTGDqugpqaG7OzQRevSIyKSTp2nkt3OzWi6lyxjPsWWPh1aH2Kd7We2O1bwH+BKdKzo1OP7RH2Lawv9aB1CwDcLYxoKyxwrmwWREktfCowlzPDs5h/onIt/LQu4EYVMQw494jQ8kGgiMQU205jPwfmnUu+pwuatxqiYyTOV0uCtpdK1Ax3IM5WSbSrsfIObCNX2aIaQjohGCEmU3o+WFr1fwY9v7AIOhBAAzev7rP3ijSsZMD6PnGLfSrsSQhKHBBGRNDyai+W1X1Du2kImChkobEAjXUljeM7RFJjDv7h5NBfbGpZyA/CHJrdnAjcDO4FnAQcQqMRxLDo/e+ub3aYqBsbknsDKugVc59zA/9s/RKMAxeaejM2e2tizp+s6Tq0BDS9pakaX2OQvWouBZRrzyDTmBf0+kmLVCwKJF0LCCSDxrP9Y8Pw2VBW0YJ1Gms6+d5fwm+si2zMmOk+CiEgKuq6ztOZjHO5dvADMRMeMznLgWt3JguoPmJB3etiffve6tuHGy5VBjl8JPAx8ja/uoKWVgEltXcdhVM0clDOdQd5DqXLvQkcn11RCepP1NHY51rPBtph6b6XvPoqFXtZh9M8YiyFJliFvj2iuRhpL8RiK6YiuFkDA17vxx5W1wUMIvoCybIk7do0SYUvcknwhmqhyl7PHvZMX0TkP8FcMjQA+QKcnOpv2r2cRDq/uAaA0yHH/7b8GOPYr8DFQGmJxrDRDBt3SBlCWNrBZCNlkW8LS2s8bQwiAR3eysWEJC6veb2xXKvD0754SIaStnyNrU6ht/wIrtVVy19fPkelqft/67irDyrfxjw/mYvQ2/10Ipz4k1iFkWuFqphWuRtPiV2roH2IxtPGxWlHAbI7cejYicqRHRCSFcud6eqFwQoAZKWn4ajxucm5E071hDXNkGHMB31LkxwU4/uX+f+8EcqDJrBn4MwrZhlzK0ga262do8NayxvZDkKO+XWS32pfTN310ux43ESViAPFoLty6E7OaFnbPU7g/R9Yme/g9I7rO3398npHl2yhxV3HZzCupS/Pdd1j5Np549VFynHZ2ZefywOHHh/eYxCaENO35aKhx8+H/tvL9qzup2+fCkmFgwmndmHZRb/LKYrNmS9M6jyOmWPjqcydeb+BzdR2OmJp8OzF3BRJERFJway76ErwLrxegoYcdRHKMxeQa8vmrt4rJ6DQdNa4EbkUh31iEWbVymWsLl+4/5q/3GJU9td3DKNvtq/Y/QvBPj1saoh9EdF2n1rMHp9aAWbWSYyxGidDKp4kYQOo8lWyoX0iFazM6OgZUSi0D6J95cLPeqpba+7OEE0b8wy63HXs2T776CCPKt/HEa49y2cwr6Vm9tzGE/FLWh6cmHlifN1RvSGcCSEcLT+v2ubj/3J/Zt93eWBjqtHn59qUdLHqvnN8/P45uAzM73K6mwi0qveSKTL741BnwmMEAuXkqJ54S30XtRGASRERSyDDmsNQJ9fgKSlv6BrAq4X/SVRSFYdnT+LnqbUbi5f/tXzJ8GfA/FCoVEwdnTyXTmEeDt5Yql6/eI9/UjXRjTod+Bpu3mlAhBMCh1aPpGmqQhcw03csOx1q22Vdg89ZgUsyUpQ2il3VEwB1+W9rj3Maq+m9o8NY03pZuyGZI5uRO7/KbiCGk2l3Boqp36YnGf9EZAvyCxv+c6/jJtYXxeac19o411dGfJVQYaVr7UZ6Vw6VnXcmTrz7KiPJtfPPgLRj2r6SwrLQXV8y8nAZz2xfNeIQQgDfuWkPlDkez2Sngm6HiqPfw3J+W85e3J3Yq4LZ3Vsu48WZm/zuHv/65BnRfTYii+HpCcvNU5szNJz1dqhESkQQRkRS6pw1mg+1n7gJmtzi2EngahW7WYe1648s2FTIh/ww22H7mz86NaE0+LU9o8mk53ZBNurXzm7cZFBMKCnqIMKJiQCHwz+DVPSyq/pBK984mt7nZ2LCEbfaVTMg7mawQq5jucW5lUc1HtAxDDd5aFtd8xNic4yi29GnXz+TX0Qu3rmvsq17Hrj1L8LjqMFlyKSseS1523w49XvPH1llV+xWj0fiqyQZ5xwKXonOI7mJ13QLG5Z3cqZ/BL5wAAlBSV80zLz/E132HculZV/Lms/9uDCHbcgroWb2X05f9yAsHHxny+eIVQur2Oln6ye5WIcRP88KutTY2L6ml75j2h/bOTKs9fWY6h0628MqLDSxb6sJsVphyVBonnZpGRoaEkEQlQUQkBashi4EZE7nb9iMrgMuBAnxbv9+HgtmQS9/0Ue1+3ExjHqNyjsaju/FoTkyqJWozV0ot/djpWBv0uIJCqaVf0DC13vYzle5dAY7ouHUXi6s/4YiC3wS8v67rrKz7hlA9MivrvqHI3LtdYa4zF2+P18mvq19kX+0mDkJhODqL6raxeO9SSvKGMsp4WKemNVe7y6nxVnM30LKvqBC4HZ3fundS291Kelp+h58Hwg8hAGN2bKJHdSXn/fIN+Q3Np4CX1VZi0HVmrP6Fl8cchsdgaDUsE68A4rdrnS1oCGmkwPaV4QeRSK7p0a3MwHV/lim6yUSCiEga/TLGkGbIYL5tEe/tH1owYaDUOphBGRMxqR0vRDMqJoyG6E6dLTL3IstYQL2nMmCviIJC34zRAe/r1T1sta8geJDQsWu17HNtp9DSesn1ak8Fdq02ZPscWj2V7p1hr8fS2R6ENRvfw167mU+Ao9H3V89ovA6cW7WKtVYzQ7IO7fDj13urAJgS5Li/AqPBvqdTQaQ9IQTg4yFjsLpd3PHxK8xYs8TXBpMZq9uFQddpMJn548kX4DG0DmEdCSGR3ojOaA6jZ0E/cJ4sHCbaIkFEJDSP5mKPaytu3Um6mk03ywC6WQbS4K1Fw4NVzW61+VyiUhSVg3NPZHH1x9R4KvYPwSjoaBgVC6Nzjg46tNLgrcGrh14DQUGh2lMRMIg4Wiy+FoxTs7V9Ep0PIQ5nLRV7l3EfOsc0uV0BZgJLgX/ZlzMgY1yHt3fw92xVAN0CHPcvDG/oxPYR7Q0hfmuKynAaTVg9vv+n6W4XAB5VJd3t4r53nuWymVdSMaDj4TpaK6D2GpmNNduIvTb4VHNFhauPq6Q0syboOUL4SRARCUnXdTY2/MIW22JceFABDchQMxiSdSRFll7xbmKHWFQrh+SdSrWngt3OLWi6l2xjIaVp/TAowf8cg9WNhHueWQ1vaqlZafu8SBSlVtX6anJ+G+T4BcBdeKlyV1AUIFiFo8jcCyMqj6BxZ4DjjwBWYzo5WW3/LkV00TJd55bP38DqcbM7I5ti24GeqgvPvpr/vf00I8q3ce6ar/jvgAOTy9vTGxLO+h8dZTSrTLu4Nx/ctyHgcUWFk09No7Rb6q8WLCJDqndEQtrQsIh1tp+4Bg9bAQ/wEzBJs/FLzUfsc4XeEC2RKYpCnqmUwZkTGZo1ie7WQSFDCECGIbfVzr0t6egUmHsEPJZv6oZFDT2rxqxYyW9jWCZSM2P0/UUGwS7v/p9Up+O7zZpUCz3TD+Iu4D7AfxmvAW4DngR69piCqoa+YEZ8+XZF4bpTLmRev2GYPc17uWas/oVLz7qSuZMO4YHjDqzpG24IGVpaETKE+Bcg64zjM1fy7z/YOOd83+viH0Hy/zv5cDN33p3bqecQXYv0iIiE49IcbLIt5ibgH01uHw98gG9n2/X1P1KQf3pc2hcPiqLSJ30Ua+q/D3wchWxjMbmmkqD3H5J5KEtrPw/6HEOyDg06bTjSU3OzM32P9y6+oZiW3gZUFLKNHd+wztO/O/3003BvMnN9xU/cikIPRWGzruMA+vY4kp6lh3T48Tsjz25j9M7N5DrtLOvWiw+HjOEvX73Leb98gydT55azzvDNPaV9ISSQSASPllRV4c7ZuZxzfgZvvNLAzh1e8gtUTjnNyvhDzBFblyZS/JvMJ1q7hI8EEZFwKpwbAY3rAhwzAX9C5yzPbhq8tSEXpEo1fawHYfNUs92xqsk0YF+JZ7ohhzE5x4S8f7e0AejorK77FpfuaLzdpKQxJPNQytIGBbxfNNYHyUwvoSCrN3+q28YhaDQdfFkN3IZCiaVvWGujBOJvs6KoDOl3Er3KJlO+Zyl1bhvdLdmUFo4mzdL2705He0Myd2hB60QG797BU688Qq6jgWXdenH5zCvY3d9CVamF2S+/xqyvvwXgjjNOxdi99fLxsdz9tq1C02HDTQy70zczxuXU+fhDB3/8fTUuFwwbbuTMc9IpLonPEI3Xq/PGq3aee9rGujUejEaYOt3CZVdlMmpMx+uCRORJEBEJx6XZyUahOMgMkcFNzutKQURRFIZnHUH3tEFss6/C5q3GpFooSxtIiSV0jYlfWdpASi392OfajkNrwKKmU2juEXSabDQXKRsy8EyWLH+Cwa46zm9cbAxeRSEtrYDRmYd36HH9bdZ0L3sr11C+dyleTwOWtALKiseSk9kzJp+Mg4WRvAYbaR4Xy7r14rfXXkad1VeQ+tohEwCY/fJrdHNWklZSj4fm/1+iWfvRUntmu2ze5OHC3+xj5w4NVfUtIvb5J/DgffXM/ncOp5weelgx0rxenT9cXc3HHzgaFzVzu+GLT518/omTe/+Xy4mnRH7HZNExiu7vs0pAtbW15OTkML3w4g5Xzovks8O+huV1X7EJCLTW5zPAxcCUgvNJM0RmGWnRXKxWSXW5bWwv/5Hduxfj9NiwmrIpLhlPj5KDSduyr12P1bTNbo+dZSufpcq2g3Eo9EfnB1S2otG9eCxD+p2CEmQYqqlI1IcECiNDXRtY262UOuuBx/cPwUxaup6Fw/rgNjUPlm3VfnREJKbWupw6x0zZQ8Uub8B9XhQF5r5RwLjxsXsPf/kFG7f9tZZgVzeTCeb/WExhkRTURkt9ncbYYRXU1NSQnR36A6P0iHRhXt3DLsd6Khxr8Wh2zIZsuluHUWTuFdex1BJLP9bUfc2deHgSms0DqQf+hUKRqbuEkCiJ5VLtZlMG/XpOo1/PaW2fHELLNq9a9xq6bSdfA4ft71nT0HgauHz3YqxpBfTpfkTIx4xUkWrLnpGGHhqLOLBybMsakO9GDWj1GG1tQNcRkVrf4+MPHezcHmSnOUBV4alH6xk3vnOLxrXHc0+HrqvxeuH1V+xceY28hyQCCSJdlEuzs7jqXaq9VUwDBgE/eKtZ7NpCibk3o3KO6dSqlp1hVE0MzJrE03ULqAb+APQBfgDuRGEDBsZnxqfIMNEk4v4ukdLRn83WsJvd1et4Hl9hs58KXAosAp7d+S29uk1CVQO/BUZypkzLENJUOIWoLUNILGo/2mPeFw4MBoLueuv1wldfONF1PSYfcDwenfXrgq9xAr6hmpXLQ6/LI2JHgkgXtbzmc4zean4BRjfeqvMOcKZrC+tsPzM4c2K8mkdP6zAMipFP63/iTe3AYlwFxmLGZx1OtqnjsylSQcuLtKZ5aXDsJTO99awZj8eBy9PQ6WXMk8W+mg1YUJgZpMboAuBRTwP1DRWNs3ciPkWX1kMy4YSQSNWAxHI1U5fLt8FcKF6v75wAi8VGnKoSMhj5zzHLaH/CkCDSBdV7Ktnt3sFcmoYQn1Pw9UD8z76cARljo7bvSjjK0gbRzTKQGs9u3JoDqyGbTGNe3NqTKAKFkOXrXmVf9XrGDL2A3OwDlTUej4NfVj2H3VnNuOEXk2FN/QCn6xoGINh1xl82WV9qRCmKbADRvB6c9fto6GbErBc01qG0FULCmQkTKoTEcxn1YcONfP4JQesxFAUGDDRiMMRmuFdVFQ6fYuHrec6QvTRTprW9u7GIDQkiXdA+106MwBlBjp8L3KO7qXXvJc8caHHs2FEUJejaGF1RoOEKXdfweJ14NRe/rHquMYz4Q0hN/TaMBitezRWHFsdedmZ31qHzJXBUgOPvAEbViDUncr9XmsfNpi2fUbvkO1xO39Roa3YeuROmYTnxkMYVb6PRCxLvvVzOPCedB++rD9oroutwwSUdm4bdUZddmcH8L50BjxkMUNLNwDEzJIgkCgkiXZKOSvBldY2NZ4lEEapewmAwMWrwuSxdM5fKmg38suo5Rg46m03b5zWGkLHDLiQ7o6xDzx3JYYusTa3XxYi03Kze5FiL+L19L/PQKW5ybDFwj6KQ3288RnP4P1eovWM0j4ftrz2Ba8cmrtF1TgbswLO1Vbz8+Rtke/ZQcvX0VveLxiyYePB64chpFr74tPmF3z9t9rgT0jjz7NhOlR1/iIXZ9+Zw819q0HXfsJCq+v4tKVWZMzcfs0UWN0sUEkS6oFxTKS7gfeDUAMdfx7erbXaQDdhEbIVTtGkwmJuFkSWrnwc4EEIywwsh0aiVCPb40QoliqIwdNA5LF3xFAM8dmah0w/4EXgDhfTcMnqOOSHsx2trA7vqX3/Etn0j84CmK58cB0wE/jBvATnHDSOt/4H/B9GYBRMP879ycM1lVbgD1H0Wl6hcfV0WM8+xxmxYpqnTz0pn0uEWXnu5gZXL3VgsClOnW5hxglVCSIKRdUS6qIWVb5Lu2cN89CYTCeFb4GgUiqzDGJbVsQWlRGR0ZNaI01XP14v+2fj9oD7H06vboWHdN9ohJJi2Aommedm1dwnl5T/RYN+L0WChsPAgenY7lDRLTtD7OZy1bCv/gT2VS3C57Fgz8sgbeCjFAw7BYAzv/aStEAKw+Zl/MX1vOW8HOOYBeqkqtqPGMuXW4MXf8VwHpKN27fRy9OG7cbsD14eoKrz5YSHDhifH7tgismQdEdGmETlHs6jqHYZo9ZwBDMT3ifFTIN9YwiCZHpt0PB4Hy9bMbXbbhq2fk51R1qyANZB4hRD/cwcKI3V9rWRsqOPX1S+wt2YDx6IwBZ0dmovndn1H+e6fGTXs4qC9Pe4hJZQOOYVSTmlXe8IJH34NPTScNXsJtiKJEThC0/hyz86gj5GMPSEAL7/QgMcTukj1uadt3P3v3Ji2SyQfCSJdlNWQxcT8mWy3r+Ijxxre1RykGbIYbh1GWdrAuK0hIjqmZWHq6CHnsXH7V401Iy1n0/jFM4A05Q8jLduzxvYd1TUb+RSYvr9q6QtgPTpfep388usjZPccRcnQI8gqDB22AmlP6GjJPxPGYEljm7s+6HlbVAVjpiXgsWQNIQDfLHCGnLbr9cI38wMXjArRVMf/CkXSM6kW+maM5pCCszm8aBbj80+nh3WIhJAk4/E6m4WQscMuJDe7N6MGn0t+Tv/G2TTVdVub3S9RQohfy/Zompd9a7/lCnT8pZ53AdOBHcDNwI1A9vZlrPz0AXav/6Fdz9fRENLQQ2s2Hddy8FjmqCrVAc5dBPyg6ZQdNbBDz5XINK3tUf221hcRAiSICJH0DKqJdGtRq8JUfwFrfk5/zKYM0swHxmmjEULcjjp2LP+clR/cy4q3/491856kavsKOlqG5qqvxOFqaCyoXgDcAtwBLAH+BtwJrNd1fgds/ukN7DW7G+9fYquiZ+2egI/d3bSLvIbgvRjBtFwPBCD7yMOwWUxMVxV+3n+bF18x+PEGhdw+eXQ7sl+r+yVzbwjA+ImWkAuUGQwwfqLU9om2SbGqEAmovYWquq5hd1YHXD3V63Xj9thJs2RHrRekoXoX6z5/BN1lZyY63YAvFJXFukZRn3H0PfTssDaZa8pRv4+l787mfeAEYCawElhO8/2HAJxAd0XFOHASfQ4+lWJbNY98/jAmzcPVR13FtuwiwNcLMrRiO0+++ggVmblccvZVVKUH3m8kUOhoyb8uiGPDTvbc8xKOfTWUGlQc6FR7dQqHlTD2HzNIK2i+jkakQkg8i1U3b/Jw3NQ9aCFWMH3pzdhudicShxSrCpGkXP1K0TQPhnbuy6EoatAl3A0GEwaDKWohRNe8bJj3FAPddj5Dp+TAAeYC529ehKFfTwrGNS/pzNwR+kJvycgjIyOP521VnICvmPq3tA4hABbgZF3jtepN1HdXMdtM2KxmBu2t5MF5j3Dx2b9jS35xYwjJcdjZUFpMTS+VhrTwxg9C7QuT1r+Mo984l4oftlC9ajc5BoWRE3qRO6yk1f/HZO8J8evT18jd/87hxutrUJQDS6r7l1e/4ZYsCSEiLBJEhEgAdZ59bFBWs/uHFWhoWI0ZlJaOp3e3yRiNnV8BsiMhpKGmnD0bfsJRtw+jOY2CXqPJKRvcqmejascqGhqqmQO0XKv0XOBD4M2F88gfe1iz+9Z3V0OGEUVRKRo2lVcWvslkwAA4QrTXAb45o0BlRhaXnnUVT776CIP2lvP0Kw9zz9RT+Ntnr5PjsLO4T28uvOoy6tPafm3b2pjuwJogKqWT+1I6uW/Qc1MlhPidekY6g4eaeO5pG1/P8xWvjp9oZtYlGYw9WEKICI8MzQgRZ/tcO/il5kN66DpXotET+AZ4BgWLtYgxIy7rcBjpSADRdZ3tSz9i58ovQVFB1xr/zSjoxZCpl2I0pzeev2Xxu1jWfMNmPXCoeA84GRh0xd8wZQfeKyhYINF1na2L3qF87TdkApnAVqDlyhQ1QDdFIfPQoymefFzj7fm2usYw4hduCOnIzrjBRCuAxHt5dyGCkaEZIZKEpntZXvMZR+gaH6DjvzSeC1yFzmT7HtZv+5whfU9s92N3dChmz4YffSEEfCGkyb+2yu2s++YFhk67vNl9Qn2aaYwYIYaagvWOKIpC74NPpaDPGHau/Ird25dzAfAEvlACUAmcrSi4DUbyRjVfvK0yI4t7p5zM468/3njb7Wee1u4Q0tlN6YQQwcmsGSHiqMK5Cbvu4IEmIcRvJPD/0Nm9ezFeb/gb1tX1tXY4hOi6xo4VX4Q4QaO2fC0N1bsab8ou7s9WXWNhkLu8DFhz8jFmhv5UVN9dDfrFqL6U/eZiyk6+gFdVlVJF4Sx8WxR0UxTmGYx0P/1STJnNV1odWrGde95/vtltjz/xNH13H5hNYyxraPXVeP/SCgkhQkSZBBEh4qjWs4cyFIYFOX4c4NLc2J3VYT1eZwtSHbV7cNmqQp+kKFTvWNX4rXH8cKw5+cxSVHY0OU0HnsEXRHIOntLuWTOB5AweTf/LbsY68Sg+7tGPL3v2J/ewGfS//BYyezdfq6NpYeriPr2Z8rcbWdOtlNKaWl588BEGsDXk8Eu8h12E6CpkaEag6zrVngp2Odbj0ZxYDdn0sA7BasiKd9NSlq7rbLEvZ0vDctLRcdO67gF8ww4Aqtr2n2okZsVooeZi7qeg4MjwNi4IpgDdz7iMjS8/RN8GG6egUwZ8rqis1DXyRk4kf8ykTrfNz5ydR8nhxwc93tBDY0B5OU+8/kirwtTzr76CFx57hMHbdvP87c9w1l2Xsasot9n9kyWASH2ISBUSRLo4j+5mWc2n7HZtozsKvYFfgY0NixiQMZ7+GePi3cSUtKlhCWttPwJQD7wBnNPiHB14HMhOK8RqCVzkGWlpWQWoBhOaN8B2qv526RrWkh7NbrMUlNDn4huo/vUnPl79C7rTgdKrlNLJk0gbPBC7Ak2qRQBI3x6ZDtlA631sz89neY8epLtcjSHEWNZADQZm3XYhz94xh01lhezJax62JYTEj67r/Pi9i3fftLNvr0ZpNwOnn2Vl1BiZqJDqJIh0cStqv6LetZ03gFPRUfFdGP8J/J9tIRY1gx7WIZ1+nhr3brY2LKfeXY6iKOSae9MrfQTphtB1A6nIrTlZbztQUaEClwPZwAx8PQz1wP8BHwAjekxp15oinWEwWijqP4GKdd8F3c3MmJFFZr+hzW7zhQEr6QOPJJ0jw3quhh5ayDDS1vEDz9uaw2zmd7eejcGr4UjXMHJgCGZfVjpnXn4yNoOK6vagGg1hBxCIbQhJxcARiMOu8/srqpj/lbNxHRKDAV56oYHTZlr5xz05GAyx+RsQsSdBpAuzearZ5dzIk8DpTW7PBP4OrAY+sS2ie9rgTl0INzUsZU399/REYRY6DuBV+69sty9nVM6xFFnav1lZMtuZXYm298AFVANs+FYP7bX/azFgBwb0OobSolFtPmYkFyvrMWoGdXs20VAVeMdYj9NOpXM91oEDOv1cLcNGy2DR9PtQ5zXVuNopzT9J67pO7ec/U/vmAhx7a3znmoz0OGEI7isOwRRkYzo/CSDRc8ffavh6/wZ5/oXR/P++/bqdsjID1/5JhopTlRSrdmG7XVuwoHBekOOXA3VaHfXeNooXmyj01vPH2i9J03xd+5Wunayp/54bgE3o3A88BuxA5zg0ltZ8isNr6+RPklyc7rpWhZv+y+pWfGuINAAjB59Ln+6Ht/l4kQghTWeoOPqkU3zcmcFP9nqpePwpvLV1nX5eOLCJXFtLqrd1XssZLy3te+kLdj/+HqfureFTfCu13uz2sO/dFfxwzVt4GsKfmRRNXS2E7K7w8tZr9qAb5Ok6zHnSht2esEteiU6SHpEuTNM9pEOraaN+BU3OC4uu87eaTxjk2UOJt45bc45nS8MyhqIwG73Z0tzpwPNANzS2O1YxIOPgjv4YScdiykYPsvhXU9kZZW2e05kQEmr32apl3x9YzKwlXUd3e6j9/kfyjp3e+ngMhbPoGIBrxx6q3lrAP4Cbmtw+AThd05mwsZKNry9j0AWtfw+lJyS6vv3a2eYuvTabzi+LXEw6zMLqVW5eebGBNavcZGSoHHN8GieeYsVqlaGbZCU9Il1YlrGAKnQWBzn+CWBEJd2QE+SMFhSFh7IOw6aYGenexZ01H1Lj3sE5LUKIXy4wA51qV+AhgFRVUjAcVQn1GUAhL7svaZbgr3t71grxup3s2biQHcs/p2Ld91Tn20OGEID6TasChxA/Xce+qv0X6EBrdXT0/u15jJovFpOvqlwf4NhBwHm6zo63l7c6FqsQcnzmyi4ZQgDcweuim3G5dB68r46Tj9nLyy808PNPbhbMc3Lzn2uYMXU3WzeH+YFJJBzpEenCCs29yFDT+YNm5yN00pscWwfcg0JJ2kBMauix86bWmkr4a+4J/KP6A0a6d5HRxvldsbPVaEyjf6+jWbflowBHFRRFZWDvY4Pevz29ILvX/8CWRe/4ZsH4ezgWvU3RIdMpmnRMY+1Py+EOXWm7x0YPY6ovBO+1aHq7Z2d6wHPaeoxwucsrOUzTCPabPBl4eo8NzaOhGn0hLZYhpCsbPiLQxPXmFAV2bPfyv3/XAwfqR/z11BXlGpdeUMlHXxVJUWsSkh6RLkxVVIZnT+d7VIaj8E/gFeA6YCwKXkMWgzMPaffj+sMIwBHAqwQOHNXAxyjkmtu35X0q6F02iSF9T8JkbH4BzrAWMW74xWRntn5N2rti6t5Ni9j00+sHpuL6ezg0L3u++4S9P3wOBC78TOvbp3EDuYBUlbR+/UI+f3t6LUL1cnQ2hAAYMtPYbFCCBt8tgDnNiGJQmFa4WkJIDA0faWLkKBMGQ+DjBgMcdYyFV+c2BN0lwOuFzZu8LPjKGb2GiqiRHpEuLt9cxoT809lk+4WbnRvxopGmmOlmHUbf9NGY1Y5ttubG965yLTAFuAGYDfjfa2zA+YAHlR5pgacH2711bLevot5bhUExUWLpS5G5N2oEVuhMBD1KJ1BWPJaq2s14vA6sljyyMsoCzlBqK4C0HGrRNY0t7wXqcTlgzw+fYz1pMmqAKqHsIw6nYXmIi6Sukz350KCHOxMeIhE8Whp2Yg9++OoXvgBaVrXUAU8YFMadVMxRRWvCfkwJEZHz7wdyOee0fdRUa429HeDLwmXdDfzxxixmTN0b8jGMRvh6vpOp0zu/W7WILQkigixjAQflTEfTvWi6F4Ni6tR03b7uvdxd/R4ARwL/Bf6Ab6nvU/BNS30dBRsKo3KOJc3QegBnc8My1tR/RwYKh6KzC4VfHGvJNeQxOvfEgPdJRqpqpCA39DTYYCEkVJ2HvXwrnrrqkI+re9w0rFxF5tgxrY5ZBw8k97hjqP74U9/VwF9NqKqg6xSeexamosKAj9tyr5ZQVpWXhDzeWf7n14t7UjSilDNXVvCwpnMmYAYWAteqUG1WmHpR+NPIJYREVp++Rt75uJA5T9p4/ZUGamt0CgpVzj4vnVkXZ6Bp4Q3ieqVMJClJEBGNVMWAqgTpHw2TP4Rk605WG4u5OfcEenir+brqPZ7Gw0cYqDJkkW/pzSjr8IALmlU4N7G6/jv+AJyMzgdAX3SmAS97q1ha8xET8s6I2SJf8RQohLRVaArgddjDenytIfh5eTOOIa1fH2rmf41z4yZQVKxDh5Az5XAsvXo2nheoByPcBcKanhfJUNLy+RVV4eB/nciSOz/lvB+2crkKVlVhr0ensNjCFf8dSXHf0HUqfhJCoqOk1MANt2Rzwy3Z6Lre7O9b03S6lans2hm8dsnjgVFj2q43EYlHgoiIHF3n+rp5zUJIg2phrVrCa3kn8UD1B2ToLl6w9OfFzPFBH2aL7RcmA6vw9aZ0B0qB5fhqTVyevVS6d1KQZLUlnv7htbcjPSAtmXML2j4JMBaGPs86eBDWwYMChI3ObxYX6H6RCCPBnt+UZeGGZwaya103Vs7fh8el0WNoFkOPKEANo8BRAkjstPyQoaoKsy7J4J//VxdwwV9VhcwsheNPitzCfiJ2JIiIyFEU7so5hovrf+C+rCNpaDLbxl/AepJ9Ba9kjA36EC7NQaVnNw349rx5A99wjgHYC9yMb/+VzQ2/JlUQaSuERCJ8NGXJL8Za1gf7ri2Bl2pXFAzZ2VgHDWx9rIn21mt0NIQ0vX9nwkiw529afNptYCbdBma263ElhMTfBRdn8PNPLj7/xNlstNBgAJMJHn4ijzRZSyQpKboeZEOJBFBbW0tOTg7TCy/GqMrGR12Bw2tj3r7nAXiJwBvBTQEWKmkcWXRhTNvWUaFCSEeHXsJhr9jBppf/h+72NA8j+z9tllxxCelDAxcKtyeAdDZ8BNOeQBJOAOkoCSGJw+vVefctOy/MaWD9Og/WNIUZJ6Ux65IM+vSVz9WJpL5OY+ywCmpqasjODr2nmPyfEwnFoloxYiQLD4EWGVeAq4AFugOH15bwRavxCiENPTTo0Y2y0t+z7933caxe23jM0rsXeScdj3VA/2b3SYTwEann6OoBpKpK49clLhRF4aDRJnJyE2umWcsakLZu9zMYFE47M53Tzgyvnkckh5gEkYceeoh77rmH8vJyRo0axQMPPMCECRNi8dQiySiKSqaxgBxPRdBfTv/n5LCXnk8wUQ8gTZi7l9HtqsvxVNfgralBzczAVOCrC+noNNnOhhB/SPhyb+d3dQ722J2VrCGkvl7jH7fX8vYbdjz7/zzMZjjjbCs3/i0nIZZBf/LRejZt9PD3u3NQ1eYFqXfcXEu37gauvKZ9Q2ft4fH4egeNxvi/FsIn6kHklVde4frrr+fRRx9l4sSJ3HfffRx77LGsWbOG4uLiaD+9SEJl1sGsqqtgM9AnwPHPATNGLAneGxJIpENIWxvF+aUNMwH+6bbxDSBNv49UGInkAmTJGkJcTp2Lzq3k12Vumi5663LBKy/a2bjeyzNz8+N6Ad6w3sO9s+sa6zv8YcQfQl56wbdo2bTpFgYNiewMmM8/cfDUY/UsWuhb4G/EQSYuviyDE05J6xIz8BJZ1GtEJk6cyPjx43nwwQcB0DSNnj178vvf/54bb7wx5H2lRqRr8upuFux9jhm6m9donpZXAYegkGcdztCsw+LUwvC0HJaJVAhpGT68tgbqvv+B+oWL0ewNmIqLyZ58KOmjRmLq4Wj34wcS6RDSUqhAIquchueNVxq46U81Ic+5/5FcZpx44PdQ13XWr/VQXaVR1sNA9x7R7yR/7y07f76uGk2Dmb+xcufsHO685UAI+ed/czj1jI4NvdhsGhkZrf+mHrqvjvv/Xd9qSRxNgwsuTufm27MljERYwtSIuFwuFi1axE03HdjvUlVVpk+fzvfff9/qfKfTidN5YIne2traaDZPJCiDYmJY9jTerfmUscDv0OkOzAMeR8FgyGFARvDpv/EUrCaksyEkWM+He/cedv3vYbz19Y0Fqd7aOhzr1pMxbjDd/nQOijHw2jAdDRfRCAaBHvPLvUNiuvNtsnv1Jd+FPNhHS1WFV+c2NAaRrz538N9/1LF63YEhzkmTzNx4ezZDhkZvPY6TTvM9/5+vq+a1l+y89pJvLZvOhpB1a9xceG4lf7k5i1NOP/AYvy51cf/+PWqa7vLr/+/nnm5gyrQ0Djsy/D21RGRFtYJp7969eL1eSkqaV7+XlJRQXl7e6vzZs2eTk5PT+NWzZ89W54iuocTSl/G5J1Nh7sHvgJOBhxQzRekHcXDeae3aiC/aPP27N361FGx/mHBDSEMPLWgIMXSzsfvZp/HabM2vPvv/27Z4LZVvzm92n6GlFY1f4WqoqCN9/pekffkFg/cuDPt+nSUhpH127vAGDSHgu/Du3OEbs/nwPTtXXlxF9/UePsDX0/gsUP2ji/NO3ceaVWFuidtBJ51m5V/35Ta7bfa/Ox5CAN5+w86e3Ro3/KGGd948MPx43711Ie9nMMDzc2wdfl7ReQk1a+amm27i+usPbNRdW1srYaQLyzN3I898Ah7NhVf3YFItnV75NZIitTZIuHUeLYtLG5ZvwrV9T/A76DrVH/3IpKuGoJrCe92aXvwdNg+v/G0VSz7e3ewC13tUNr+9ZwSFPVN38agN6z28/IKNpQvdGI1w2DQLZ52bTmFR4vz+tVRYqLK7QgvZI1JUbMDl1Pn7TTWcCbysH/g0OgQ4zQuHOHVm317LnFfCWxSvIzRNZ9FPrma3LVro4tQzrM0KWNvjjzdmUVOj8epcOzf8wTdEVVRs4Jv5rpD383ph+bLoBi8RWlSDSGFhIQaDgYqK5p++KioqKC0tbXW+xWLBYkmcT7oiMRhVM0YSp0aovVNyQwknhASb3WJftaX5PjABaPV26rdVk90v9EWlZe+D5tV5/PIlbFpS0+rCtm15Hf8772f+8vZEMvPN7aqt+LB+WLPvW9635fF4ePnFBm6/qYYCFWZ4fXsjPbbEzVMP23j02TzGH5KY71FnnJ3OyluDD2drGpx+lpUvP3ewr0bnTlp3iWcBN3hh1ncudmz3RKVmpGVh6mFHWvh2gbNxiKblbJpwqarCnbNzAHh1rp0/Xxu6XqYpi0XqQ+IpqkMzZrOZcePG8cUXXzTepmkaX3zxBYceGnznTiESRdNhl2DDL+Gq76429oaEGnLxM5Y1hJ5iqygoShi15iHeY4Nteb9ywV42Lq5BD9BEzatTu9fFzlcXt7vA03/+8ZkrA943XgWj/uf9ZZGL226q4Uodtnl9wxWvAts1GO/QuerCKiorw+vBirXTZlrp08+AIUCnjcEAQ4YaOeEkK8uXuclUfD0ggUzc/+/O7d4gZ3RcyxDyz//m8NTz+dxzXy6qCq+9ZOdvN9aEvcldS/4w0qu3ocXtwe9jMMAxM2TH3niK+io3119/PU888QTPPvssq1at4qqrrsJms3HRRRdF+6mF6LCOhI5QvSFNh2M6HUDYX+txRA66N/QbtjnXSmbP3Mbv/cEjWADxW/hOOUqodwcdnn2qY+PqbYWNio02FrywjXlztrLpl2qiObGvZSCa84SNgSo8ADTt98gHXtbAadd589WOTX+OtowMlRdfK2DSYc17bBQFjpxm4cEn8vjDNVU8/rANmw7BqoQ27P83Ny/yl4fNm7y8/Ya9VWHqSadZG8PIe2/Z2bi+42sE/fCdi/Ly5iHKbAkcRhQFjCY4b5YskBZPUa8ROfvss9mzZw+33nor5eXljB49mo8//rhVAasQ0abrOtXucqrcvkLpAnN3ckyt17LpTK9HS+2pBwl3gTF/oWn+yG5kDyykbuO+wIFEgX4zD2J66bqwHrfpBfmFqqqAvSFN2eph4Y8uxk+MzLBZdZXGn66tZsFXu3yr0Cuga9BtUAYX3jeSkr6RXTcmUCD6foGT67yBP6EVAcdo8N18J5deGb0FtzqjsMjAUy/ks2mjh0U/uVAUGH+ImbLuBs49Yx/LlvpqIRTgfuAfLe6vAf9RYOhAIwMGRf7y0K+/kSefy2PnTm+zmS3gCyOKAoXFKgMGdWzWznffOLnyokpcTl/4ystXeft1O04HWNMVGmx6YyDRdUjPUHjkqTx69kqocskuJyav/jXXXMM111wTi6cSIqAGby3Lqj+h2ruPTBR0YK1Np8BYzMicY0gz+C4sHQ0hbc2MiWQA8VMUhQl3zeDb//c29vIDMwMUVUHXdMqmDuDya9u+eAe6IHfvYeDnn9ou4Jv7nK1TQaS+TiMzS8Xt1rn4/EpWrfA9p67j21gIqNhg44HfLuIvb00ku6jz9RmhemQ0LyGrkcz7z0l0ffsZ6dvvwNv7px85WLL4wP9PDZiN7yW+Dt9qxauA2xT4Enj0pqyorasRqsbmxFM7XgDtDyEOB0w5ysKDj+VhNPlWln11rh17g86Z51hx2HV0HcaNN3PqGVYysxJr+fuuSGKgSHkuzcGiqrcp1uy8DByNjg58AFzl2cPi6ncZN+5aDIaOXVCbhpBwekDCGXYJV3q3bKY+ew7bPl7D9k/X4K5zktEzlz6nDOecE+1tXkyCXZTPPCedd95sezG0X5d2fLbB6lVuLjq3kj/flEV6hhJ05oLmBVuVm2/mbuf4a/sHPCdcbQ0LjRlv5s1vnNwUIGzUAZ+oMCtCPUCx9O5bDaiG1iHqX8A/gXTABhRkK/znHzlMnZ58NROrVribhRDz/gLUpgWsaWkK/7gnN46tFIFIEBEpb7t9FW6tgXlArya3nwwMRGeEt5Zde5fSo6R9i6QFCyAtw0e0N5Mzppvpe/pI+p4+EvDPgHEQrEo1nILQCYeYychUsNWHrs+wpHX8U/P779jZt1fjpj/VMHS4MeQEIF2Dn97e1akgEs7P/dtL0rl0vpN/An/hwCvoBq5QwKXC2ecmXz3B3j1awJ4c/8ttA0xmmL+opPECnmwuuSKTsu4Gjjo6rdnP4C9gPeRQCyecknwBqyuQICJS3m7HWs6geQjxGwocAyzc074g4g8hwQJIRzaUi9Zusx2ZiaIoCudfmM7jD9lCrkvRmdkGf7whi/panbnPN7ByedvFiQ01Het9ac/Pf8TUNK6+NpMb76/nBYNvXQ078JIBdgP/fjCX0m6Ju5ZIMD17GVj6ixtvkGElRYGePQ1JG0L8mi5f35SqKp0a9hHRJYNjIuV5VDf9QhzvB3g9bQcH/yqpLUNIy6m47Q0h7V3pNFbOuyADa7oScLaBqkKaVeGc8zreO6AoCrfdlc0554VxgVAgryw2n2av/VMWc17Kp/QoC48XqLxUrDL5bCtvflTIcSck58XszHPSg4YQv3POT75NJEVqkB4RkdI8/btjWV7At24bjdWPTejAtyiY0wIv+NWeItRgASTaISNaS6GXdjPw1PP5XH5hJXW1+2cbKL46g8wshcfn5FNS2vHeAV3XmfOkjc8/dbZ9MjDp7B4dfq72mnSYpdU02HjRNJ09u7WAr7XToWNr0MnPD/2ZcsIhZk44OY0P33O06uEyGGDAICNnnRt+yHI6dD7+0M43C1xoXp1RY3yFn9k58tlWtJ8EEZGSms5+KS0Zz7y6LXwGHN3ivDeApegMPmgydd1DvxG3J4AkSg9HZxcIGzfezIKfinnvLTsLf/QtlT3+EAsnnZoWcJfT9vj7rbW8MKft3iNFhR5Dszh0Zlmnni8ZaZrO7TfX8uWnDp5/raDZTBinQ+fqy6so3+nl2ZfzKSgMHgoVReGe+3Pp3aeeZ5+2Ndb+GE1w8qlW/npbNunp4f3/XLfGzUXnVbK7QsNg8M1wev8dB/++u44HHsvliKlShyHaR9GjuVpQJ9XW1pKTk8P0wosxqslXqS7io+UUXE338uuq56mp2cj/Q+dMwAu8DDwM5PYcSf/DfosSZAWvcANI0/CheTQUBRRD9D8hRro+JBZ+XerijBP3tXme0awy4bRunPznAaRldOxzU6K+BuGoq9X4zen7WLvGQ3Gx2hhG/CFkwVdO0tLgmbkFjBsf3nukw67z6zI3Xq/O4KEm8tqxcFl9ncbRR+yhukprNdSjKGA0wjufFDJgYPR27xXJob5OY+ywCmpqasjOzg55rvSIiKTQmUXGVMVAn+MuY/uvn/C/td9xr8c3FGAxWykdfDjdhx/VKoQE2h23rRCi6zrbPl7DxleXUrt+LyhQOLYHA34zhuKJgUplOy9Zd6h9/WV7W9vkAHDKjQM4/Dcd3/gymUMIQFa2ynOv5HPB2ZWsXePhtzP38eQL+dw7u64xhDzxXH7YIQR8tT0dXfvl7TfsVO4LvLGervv+fz7/dAN37J8yK0Q4JIiIhBapBcZUoNfoE+gx4hjstb6eC2tOKarBGDB0NNXWdFx/CFn6z6/Y+sGqA3M+ddj3yw72LtrOiP93GP1mjurQz9IZH9YPS8iL8eZNnjZDCMCeTR1bTj0Rf+aOyi8wNAsjJx+zF6AxhEw8NHa1LF98GnptGa8XPv7QIUFEtIsEEZGw2goh7d3pFkA1mtBH+nonwrnEhbsmyK55G3whBJrVxOr7N+9a/r9vKJrQi6zeee1uczDh9ob4d7RNpItzbp4acIGtpiwZBk67aVC7HzuRfs5IyS8w8OTz+RwxYXfjbX+9PSemIQTA4dCDTuf2c7kSdrRfJCgJIiJmIrWHS0cCSFu9Hk0FW449VFHqpjeWgapAkF1DFVVhyzvLGfH/Dg+7HaF0ZEgmkXpHTjjZykfvB/90rRoUDp3Zvd3LjCfKzxdpTofOLTc039b+wf/UMfFQc7MC1mgbPtLEksXB1yNRVRg2XC4ron1krpXoFP8uteF8dVbTNTzCVd9dDTuEtFwPpKm21gapWbc3aAgBX89I9Zo9YbUjmvy9I/E27WgLw0caA25Zr6hgSTdw5G87XhuSSloWpt7/SC6DBhvZvVvjtzP3sWljx3eqba9zzgu9HommwfkXynokon0kiIgOi+QutcG0XESsPSLVCxLO+iCqqe31NAyWyHxSTNYC1aaMRoWnXyzgkEm+oklVpTGU5He3cs1zY2O2gFkiaxlCnngunxknWnnulfy4hJEBg0zccEsWAGqTX3l/rffpM60cd0J0/7/V12vYbGEUGImkIX1ookPaG0I6EiQ6oz29IMG0Z4XUbkf0Y+uHq9C9wXtFSif3CfvxuoK8PJVn5hawZpWbb+Y7cbnhoNEmqkaNRlWTe6nxSNF18Hj0VoWpTQtY9+3T8HpiV5dxyRWZ9B9o5MlHbPz0g29tmYEDjVx4aQann2WNyq69uq7z1ut2nn7cxtrVvtA1eKiRS6/M4OTTovOcInZkHZEuLla9GrHSnl4QaF89SFMtFyyr3bSP+Re/iu7VWi3gqqgKpuw0jnrpPEyZnSsujERvSDzrKPbs9vLK3Aa++NSJy6UzeoyJ82ZlMGxE83UnOjKElKr1IQ67zrq1bkaOav0eWLnPS1WVTv8B8flM6Xbr6BpR3aNG13X+79Zanp/TgKL6NkAEGqd/X3hpBjfdmiVhJMG0Zx0RCSIpLBYhI5RoBpD2Bo5AOhJCQq2YWvHdZhbe+jGaywsovmm8mo4l38qh/zmF7P6Bl5EPV6SGZOJ1wV600MUlv63EYdcbp+4aDL4pn3+5OYtLr8xsdn57wkiqhhAB337t5KJzK0Oe8/yrsZ3GLNomC5qJmIaQRB12ibS2lm0vmdSHY968kG0frqZqVQWKQaFofC+6TxvQqfqQVKgJqavVuHxW8xACNBY+/uuuOoYMNXHYkQcuJv5w0VYgkRCS2l581tYYWAMxGODFZxskiCQxCSIpJloBJNZhI5BYBJDOblxnzk6j/zmjI9aeaISQeEzjfesNO/X1wdegMBjgqcfrmwURv+MzVwYMI8kQQLZu9tCrT+C32VDHxAGrVnhCztTxemHVCnfsGiQiTv4K4ijeQyfhiEcA6Uzg0DUNd20VKAqm7Nyg+8cEGpaJ1+65iUDXdX5Z5GbNKjeWNIUjplgoLOr4zrot/fBt6B12vV748TsXuq6nzFj/1/OcXHVpJVdcncnv/5DV7NirLzVw2001zP53DqeekR6nFiYHq7Xt34dwzhGJS4JInCRKCEmEno6mOhpCdE1j38/zqFm0AEd9LQDWrFxyxk8hf+xhzQJJe0JIqmraK7JqpZs//b6adWsPTAE1GGDmb6zccntORAoRdZ02V+TsaLWa06Gz9BcXTicMHGyktFvkAlRnrFvrxuWEB/5TD9AYRl59qYFb/uJbnGzlcg+nnhG3JiaFY09IY+P/6oNuCaCqRH3KsIguCSIxFu8AkmjBw69TvSC6xo73X6BuzRIuAM7CN3HlpbpqXvzybRy7d1J23NnYewa+0nW1EOL3Yf0wRuxdxnln7MNub/7aeL3w6lw7NdU69z/S+WXpx4038+VnzqBhQzXA2INN7eoN0TSdxx+28eQj9dTW+h5YUeCooy3c+n85cQ8kF1+eiab56l/8YaSk1NAYQmZdks5Nt2aFeggB/Ob8dJ57yobNprcKI6oBMjIUzjpXepWSmSxoFkPxDCEdXRQsFjpb+1G3fgU1a5bwMvAMMAM4Hnh+//fVy3+i0ram1f1CLVbWVdx8nxG7XQ84Bq9p8NH7Dn5d6ur085x+VjoWiy8oBKJ54aLLMgMfDOKu22r5zz/rGkMI+HpVvvrCydmn7qVyX4jCgg6ordEINsmwtibwx/VLr8zkLzf7wsYD/6lvFkL+elt2ygxDRVNxiYFn5uaTk+t7nzAYwLD/I3RensqzLxVEdBhRxJ70iIQp3j0ZHZUI4SPaRaY1S75jvKIwM8BF4gLgn6rKtm+/wzrkwAZqiR5AYjFTRvPqLHqvImQhoMEI775lD7iGRXvk56s89EQ+V11Sidd7YAaEfzbEFVdnMP3Y4N3rLWfQDNyxlOvmBP5/6PXC7gqNpx6z8ee/hp42GK49u7389ux9TD7cwi13NA8Q69e6ueAcXy3IrEtaL29+6ZWZvPZSA5s2HnihkzmELFro4uUXbaxf6yErS+X4k62cfFoa6enR+zs/aLSZ+T8U89EHdhb+4AIFJhxiZsYJVixpyfk6igMkiIQh0UJIIoSLUGI9vdazr4JpQT6pKsB0TeOp8gMFpxJCfFwOLx5X6KWydQ0q90VmOe3Dp1j44PMiXny2gc8+ceB26xw02sRvL8rg0MnhTb30B5K7X7WHnNLp9cIrcxv4002RWehq4Y8uNq73snG973fHH0bWr3Xz27Mr2bdX463XG/jN+emtampebRFCAB68r75VAWui03Wdv99aywtzGjAYwevx9XD98J2Lxx6s5/lX8+nRM3qXlDSrwmlnpnPamTIMk2okiLRBQkj7dDaEOCt3466rxmjNxFLULayLiGK2sCPE8e0AaWkJH0AgtmuGmK0GLBkGnLbgXSKKAqVlkev27t3XyF9vz+avt3eup2LdmuA7wPrV1uhUV+ukW+n0p+bjT7Jis+nc/Ocann/G93t0znnpXHCOL4QMHW7kmbkFAUNI0+GYklJDs5qRZAojL7/QwAv7e6G8++ua/fm/fJeXKy6s4v3PC5O2p0fEjwSRICSAtE9nA0jDri3s+eJt6ndtabwtPb+EwqknkdUv+IJWDT00TBPH8NpHn3CPrlPa4vhW4D1FIXfa8E61LxZivXCZqioccmYZX7+wDS1Ez8IZZyXeJ1D/fiNtmXiQryds3HgTl12VybSjOz67YuY5vtfBH0b8gWTocCNzXiogL6/530DLENJ0OMYfRhQFrrku8cOIpuk88YgNRQk8u8nrhXVrPXz/rYtJh8nCYqJ9UiKIJFpoiLREDSGRGoJp2LWFrS89xAjNy83AWGAdcE9lBV++8SQ9T7mQ7EEHtb7f/mm42ZMPoWH+1xxlb+BpTWfC/uPfARepKoacDLKnjIlIW1PN9Et7s+Tj3dTtdaEF2LDvwksz6Nc/8d4m7vxnDldcWBX2+b8scnPlxVUBl5Jvj5nnpLN+rYdnnrA13vbM3NYhBCArS8FggPMvbB5C/M//r7vqyM5JjvkCu3Z62b4tdBeU0QjffeOUICLaLfHeYdopWUNIooaLcES6BmTP528xUvPyna7jf1X6A8cApwGffPY6Wf2HoxgODBE0XQvEkJlJ0e+vYuMTT3PIvkrKVBUNKNc0rCV5lN50PoaM5H29oymr0MIfXj6Y1+5cw8p5exs/7aZnGznqsj6MuqQXsCqubQxkyjQLR0wxs2BeeDN6/NM+/3VXHVOmWRgwyBT6DkGsX+vm3bfszW576L66VgWsADNOtNK7j5Ghw42tjl16ZSaTDrO02uwvlOoqjU8+clC5T6NbmcoxM6JbINpUW8NgfsF61oQIJWk3vZMAEl2xKjh17qtg/dP/5HUg0LpOS4HRQK/TLyGr//CgG9WBb1Ez+8rVODZuRM30YB3Rl/SD+qOonftZYrWyarz3lKna5aB8gw2TWaXP6ByM5gOvWyIup+506Pz1L9W895Yj7PsYDHDerHRuuSOn3c/XtDB16HAjJ55i5Z5/1AHw24vSA4aRSNB1nYfvr+fh/9Xj8fgW8PJ6wZqu8Nfbsjk7BmtoeDw6h4/fzb69oQuXH3oij6OPk8XFRApueufp2w2Myf/LLSGkNXetr3t9fJDjo/D9krpqqkKGEABFVUkfMYzsY/pEsokxEe8QApDXLY28boH/zvzTZhMpkFjSFM44K71dQcTrhZXL278vScsQ4q8Jyc1TmxWwRiOMPP6wjfv/Xd/4vb93wt6g87cbaki3Kpx0WnTfW4xGhQsuzuC+e+oC1ogYDFBUrDJ1ugzLiPZLiiCSyJIlXIQjHrvaGqy+dRfWA70CHN8CeABvj7Y/9SXDrJhAEiGEhCseG+YF8903Tq68yLc9/IiRJmpqNLZtDT02oCgd25ekokKjrk5rVZjatIB1y2YvbjeYO7fkSjP19RoP318f8px7767lhFPSUNXozla59MoMli528eXnTlT1wHCXaoD0DIVHn87HaJQZM6L9JIh0UDIHkHgEjmDSSnqQnlvAvdX7mIpv3Y+m7gWMZjPpw4eGfJxkDCHJFECaSoQw4g8hDgccOc3CQ4/nUVOjMWPqnmYrrbak67QaOvB6db6e7+TreU7cbhg5ysQJJzevv5h8uIVnXshnwGBTq8LUmeekU1yicsihFszmyF6I53/pbLX8fku7dmosW+Jm9NgIJqAATCaFh57M44N3Hcx9zsbG9R4yMlVOPCWN82ZlxH1JfZG8JIh0gISQyFEUhYIjT+Kjd+ZwDnA7MBTYhi+EPAjkzzgG1RK8y1dCSOzFe6jmmSdszUKI2aJQVGzg0afzOHdmpW+zoRYMBsgvUJsNY+zY7uHS31ayYb0X4/53w5dfgLvvrOV/j+Ux+fADv3fjDwn+O3jk1OgMHQdbOr6l6urILDrXFoNB4eTTrJwc5aEg0bUk1lUpCSRrCKnvriZcCPHLHnQQPU48n7fTrAwD0hSFXsDDJhP5p5xI9tQjg9432iEkVoWqycofSGLt/kdyufrazMYQ4nfwRAv/eSAHk8k3DNN0X5LiEpVnX84nI8P3d+By6lxwdiWbN/mGczwe3xdAfb3OFRdWsn5t++tJIinclUp79pLPlCJ5dfnf3mQNFuFK1PABzafgmnqMpmzqCBpWrMJTVU12ZgbpI4ahpsWnSFkCSPjiMVSTnq5y7Z8CLwR24inpTJmWxjtv2lnyixujAQ470sLRx6U1Gzr56AN70JoSXfcVhT7zhI277smNxo8QlkmHmykpVdldoQUsElVVOGi0if4DuvxbuUhiSTF9d8r4mzFGYdZMKoeQRA4gQJszYMIVjR6RWISQZB+aCSbetSPtcc3llXz+ibPV1vJNZWYpLF7Zcr3e2Jr/lYMrLqoCnWZtVQ1gNsFLbxYyfGTH1kURIlraM303sa9WUZSqISSRh2D8IhVCokFCSOfEa6imI2w2PWQIAXA44v857cipacyZm8+IFmHjkEPNvPy2hBCR/Lpcf14qBJBEDxrBRDqARLo3REJIZCTCrJpwDBps4odvXUFXDVVUEmbI45BJFl5/38LWzR4qKzVKSg10i+BmhELEU2L8lbVDKgSJzpAQ4hPJENJVVk6NpXjPqgnH2eelN9szpiVdg/MvzAj78fbu8fL6K3ZWrXBjMiscdbSF6cemYTJFbkpvrz5GevWJ2MMF5XLp/PS9i5oajZ69DIwcZZJddUXUJFUQkRAiIUR6QZJLIveO9Otv5M9/zeKef9Q1W6ALfDNujpxq4YyzwnvPeefNBm76Yw2a5it0VVV49007PXsZmPNSflLNapn7nI3/3lNHTfWBYamBg4z8/Z85jD04umuViK4pKYpVx838P4ym5F/ivaMkgPgkYwiB1Agiuq6zfmE163+sQtd1+o/LZeCh+WGv5pmoYQTgk4/sPP6QjV+X+qbqlpSqzLokg1mXZITVm7FooYtzz9gXdOnzsu4GPp5XFNGekWh5+vF67v57XavbVdX3s8x9o4BRYySMiLal3F4zXU2yBo+mEjmEyNTc9tm33c6TVy9l11obqsF3Mf3Uu5miPulc+tBBlPRre/gikYdqjp1h5dgZVmprNNxunbx8tV3LpT/xcH3jRnQteb2wbauXzz9xMOPExO7RravV+M+/WocQONBbdO/sOp5/tSCGrRJdQfJf8VJIMsx4CUekh2IkhMSPw+bhwQsWUbHBV0uheXU0r++j/75tdh64YBH1Va5m96nYaKN2jzPg4z36fQ8aGhJz1lR2jkpBoaFdIUTTdOZ/5Qxa8Aq+noQvPw/8eiSSjz904ArRTE2DH793sWtn6P18hGiv5L/qpYBUCiBdvR4k1Sx8exdV5U60ANcezatjq3Lz/as7G28r32DjwVmLeeiixa3CyLqfqnhw1iLOON+ZsGGkvbzewD0hTWmabxXXRLen4sAy96HsrpAgIiIr+a9+SSxVAggk/lBMvEJIsteHLPog9Ouma/Dze7savzeaFAxGhYoNDc3CyLqfqnjiyiW47BqmNAOf2Ycm1ZojwZhMCn37GQg1oURRYMiwxF/ro7DY0GaoAigqTs5pw+W7vPzvP3VcdN4+Lr2gkjlP2qiJ0R49IrTUuAomAX/oaPqVjPy9Hi2/IiVVhmKmFa5O+hACYK9xB9xArtk5dZ7G/y7slc41z44lt9TSGEYWf1jRGEKGHF7AJQ+MxGRJzotZIBdcnBHyJVJVOPPsxK4PATju+DRMIfKSqsKEQ8yUdU++/3cff2Bn2uTdPHx/Pd8ucLHgKyez76xl2qTd/LLI1fYDiKhKzqthEknm0NFUpANHIKkyFJMKAcSvpF8GaojrjqJCcd/mxaotw8hzf1yesiEEfOuRTDvKAgrNekYMBt/3s/+dkxS9CNk5Kn/4c+D9e/yzZv7818DHE9nqVW6uu7oar6f5FG1d962ue8n5lVRWSs9IPCX/FTKBpUIAgdgsyS5DMYnp0LO7B6wP8dM1OOyc7q1uL+yVznHX9Gt221m3DU65EAJgNCo8+EQet/09mz59fT+fqvrWIXnx9QJOOT09zi0MruXqDRdfkcEtd2aTk9N8rKlPPwNzXkrOqbvPPmVDgYDTqzUNbA06b7wS3V28RWgyfTfCUiV8QPIFEJCC1EgbMjmfg08u5ed3y1sdUxQYPqWQg44ubnVs3U9VvHnXmma3PXbFEq5+ZizZRZaotTeaFi10MWyECau1dUHIwh9d/Oa36Zw3KwO3W8dgoF2zb2Kpvk7juadtvPxCA+XlGtnZCqfNtHLRZZmUdTdwwUUZnHNuOt9966SuRqdnbwOjxiTvyqpffR56VpOuwbwvnVx2VWbsGiWaSZ2rZhykSt1HIBJCBICiKJz7j2Gc/KcBZBcd+DSckWfiuGv6cdH9IxvXFvFrWpg65PACbnh3YrOakaazaZKlYHXelw4uOGcfV11Sid3e/KP1S8/bmHVOJTf/uQZN0zGZlIQNIVVVGmeevJf//aee8nLf33htrc4Lcxo4+dg9rF3tW9TNbFGYMi2Nk06zMnqsOWlDCIDH0/aMJbcr8Wc1pTLpEemgVAodLUktiGhKNShMu6Q3R87qyd5tdtChsKcVg6n138CmX2oCFqZe8+xYHpy1uDGMXPviwaTn+CojE3mxM7/MTBWzSeG7r11cdUkljzyVj9Wq8NLzNm77ay0AOblqyNkziWD2nTVs2eRtteuw1wu2ep1rr6riwy+Lkjp4tDRqtJnvvgneK2IwwOixyTfklEpS92oaRakaQqQgtXNSrT6kJYNRpaRvBiX9MgKGEIDiPukU9k5vVZjatIC139hc0rJafwZK5N6RgyeYeeK5fDIyDoSRZ56obwwhF1+ewQ23ZCX0BbyqSuP9tx1BL8heL2xY7+Xnn9yxbViUXXBJesihGU2D3/w2cet4ugLpEWmHVA0gkJxDMYkk1UNIuDLyTFz9zFjMVrVVYWphr3Suf3U8mQXmoEMXkdwkb+tmD6+81MDGdR6s6QrHHp/GtKM7vhuuP4xcdkEl333t4ruvfdM+kyGEAKxf48bjCX2OqsKKX92Mn5g6PQRHTk3j0iszePJRGwbDgQXoDAZfCLnz7hz69pNLYTzJqx9AKgeOQJKtFyTRSAhpLiM3+GIU4RSqRmKo5qlH6/nX/l11vV7fRef9dxwMGGjkmbn5lJR2bPbOwRPMHHVsGu++aW+87do/xT+EVFZqvDDHxusvN1BZqVFcbGDmb9I574J0snN872cmc9tt1HUwp04GafTnv2YxbryZZ5+y8csiFwaDwmFHmrn48kzZUTgByO67LXSlEJIKvSDxHJqRABJ9HQkjn3xo5/dXVAc8ZjDAoCFG3v6osEPhoWlNiN+kw82NNSPxsHOHl3NO28vuCq1Z7YeqQs9eBl56s4DCIgMul85hB1dQXRX8LV9R4PNviujZSz6jis5pz+67Xeeq24ZUm/XSllQIISL1fVg/rN21I48+4NsNNxCvF1at8PDj9+1fTbNpCLn48gzmvlHQrGak5WyaWPnLH6rZs1trVYCqabB9m5dbb6oBwGxWuPTK4FNUVRWOmZEmIUTEXNe58oaQygEk2kuyCxEL4YaRykqNFcs9rS7KTRmNvrUl2uPNVxtaFaa2LGD93SWVaFpsw8j6dW5++t4VsgD1i0+dlO/ynXDplRmce4GvMNOwP28Y9o9SHTzBzOx/50S7yUK00qWibyoHjpYkbIhUE04ha7jrQbjauW7EmIPNFJeonHiKtVlhamMB66xKph+bFvP1Q5Yva3uGi677zivtZkBVFW6/K4ezfpPO6680sGObl7x8lZNOs3Lo5OBFxEJEU5cIIl0pgICEEJG62ipkLSxSKShQ2bcv+N+AxwMjD2rfbrh9+xl55+NC8gvUVrUlB08w8/nXRRQUxn75eqMhvOBgbPHjDhth4tYR0vshEkPKX6ElhMRHLOpDpFC16wo2VGMwKJx/YXrQGhFVhawshRkntX833IJCQ9AC13iEEICJk8yNQyvBWCxw8HiZGSISV8pcpQMtt96VQkgi1X6kcgiZVrhaQkiCCBZGLrsqk/ETzSgBdsM1GOB/j+bFbYZLpBUVGzjlDGvQ4KUo8JvfZpCZ1XXeC0XySfrfzq4WOAJJlAACqR9CRGIJNKvGbFF46vl8br4jm959DCgKpKXBKadbefODQiYfkZyb7gVz2//lcMhkX4+Hv3fE/+9Rx1j4001ZcWqZEOFJ6nVEunoAgcQJIakcQEBCSDIIVjei63rcFxyLNk3T+XaBi7ffaKCiXKNbdwNnnGVl4qHJvWGdSF7tWUckKYtVJYAkTgABWS9EJIZgs2q6woVYVRUOn2Lh8Cmp1dsjuoakCCK2bioGi4QPPwkhQgSWDDv5CiGak6t7kkmUEGIsa5AQIhJWIu/kK4RoToJIkuhqs2ISidSHJCcJI0IkBwkiSSBRAgjEL4TITBnRER3Zq0YIEVtJUSPSVSRS4GipqwUQkBCSSsJZHl4IER9R6xG56667mDRpEunp6eTm5kbraVJCIg27BNLVQogsWpaapGdEiMQUtSDicrmYOXMmV111VbSeIiUkcgCBrhdCRGqToRohEk/UhmbuuOMOAObMmROtp0h6iRxCulpBquhaojlUo2k6879y8sbLDWzf7qWwyMCpZ1g5ZkYaZnPqr2kiRHslVI2I0+nE6XQ2fl9bWxvH1kRPIgcQkBAiuoZohBGXU+eay6uY96UTgwG8XlBVDwu+cjJylIlnXswnO0fmCAjRVEL9RcyePZucnJzGr549e8a7SREnIUSIxBHpoZp//7OOBfN8H6a8Xt9t2v4/+ZXL3dz0x+qIPZcQqaJdQeTGG29EUZSQX6tXd7zI76abbqKmpqbxa9u2bR1+rEQkISQ8MlNGxFokwkh9vcZLz9sag0dLXi98/qmTbVs9nX4uIVJJu4Zm/vjHP3LhhReGPKdfv34dbozFYsFiSb29EhI9gCQSWS9ExEtnh2qWLXHjcIQ+R9fhh+9c9OyVUKPiQsRVu/4aioqKKCoqilZbUpKEkPBIL4hIBJ3Zq0bzhneeN8zzhOgqolYjsnXrVpYsWcLWrVvxer0sWbKEJUuWUF9fH62nTDgSQsIjIUQkmo4M1QwbacIYxke7cQebOtAiIVJX1ILIrbfeypgxY7jtttuor69nzJgxjBkzhp9//jlaT5kwEn2BspZkAzshWmtvGMnPVznpNCsGQ+DjBgMcPNHEwMESRIRoKmoDlXPmzEn5NUSSKWwEIwFEiODaO1Rzy+3ZrFnlZtUKX0GqrvtuV1Qo7Wbg3//Li0o7hUhmCTV9N5lICBGi6wi3dyQrW+WlNwu59e/ZDB5qJCdHoW9/A3+8IYu3PyqkW1mQ7hIhujAp3W4nCSCpQ+pDRHuEO6vGalU4b1YG583KiEGrhEh+EkTaQUJIZEmRqkg2nZlVI4QITIZmwpBsxafBSAjxkRAiOks2zhMiciSItCFVAoiEECEiS8KIEJEhQSSEVAkhiSTeIUR6Q0QkRXqvGiG6IgkiAaTCUEyi9YIIkcokjAjRcRJEWkj2AAKJ1wsiRFcgYUSIjpEg0oSEECFEZ8hQjRDtJ0EEGYoRQkSWhBEhwtel1hFJ9rARjASQ8EihqoilcBdAE6Kr6zI9IhJChBCxJkM1QrQt5YNIKgy7BCJDMUIkDwkjQgSX0kMzqRJAUiVwxHsNESHiSZaHFyKwlO0RSYUQkiq9HkNLKySECLGf9I4I0VzKBZFUGYpJhQAC0gsiRCASRoQ4IKWCSCoEEJAQEg0yY0YkGilkFcInZYJIKoSQVBmKSTQSQkQikzAiurqkL1ZNhQACqdMLkkgkgIhkIWuOiK4sqXtEJISIYCSEiGQjQzWiq0raIJIKISSVh2ISqT5EiGQiYUR0NUkxNGPvrqGmJX/waCpVAwhICBGis2SoRnQlSdsjkswkhAgh2iJDNaKrkCASQ6k+FCMhRIjIkzAiUp0EkRhJ1QAihIg+CSMilUkQiQEJIUKIzpKhGpGqJIhEUSoPxQgh4kPCiEg1EkSiRAKIECJaJIyIVCJBJAq6WgiRIlUhYk+GakSqkCASQV1tKEZmyggRfxJGRLKTIBIhXSmAgPSCCJFIJIyIZCZBJAIkhAgh4k2GakSykiDSCV1tKEYIkfgkjIhkI0GkgySACCESlYQRkUwkiHSAhBAhRKKToRqRLCSItIMMxSRHfci0wtXxboIQCUPCiEh0EkTC1NUDCCR+CJlWuFpCiBABSBgRiUyCSBgkhCRHCBFCBCdDNSJRSRAJQYZikmPRMgkhQoRPwohINBJEgujqAUQIkbokjIhEIkEkAAkhQohUJ0M1IlFIEGlChmKEEF2NhBERbxJE9pMAIoToqiSMiHiSIIKEECGEkKEaES9dOojIUIwQQjQnYUTEWpcNIhJAhBAiMAkjIpaM8W5ArEkACV+irx8ihIgefxg5PnNlnFsiUl2X6hGREBI+CSFCCJDeERF9XSaISAgJn4QQIURTEkZENKX80IwEkPBJABFCBCNDNSJaUrpHREKIEEJElvSOiEhL2SAiIUQIIaJD1hwRkZRyQUTWBhFCiNiQMCIiIaWCiAQQIYSILQkjorNSJohICOkcKVQVQnSUDNWIzkj6ICJDMZ0ztLRCQogQIiIkjIiOSOogIgGkcySACCEiTcKIaK+kDSISQjonVULItMLV8W6CEKIFGaoR7ZF0QUSGYoSfhBAhEpuEERGOpAoiEkAE+AKIhBAhkoOEEdGWpAkiEkIESC+IEMlIhmpEKEkRRAylEkIiKVXqQ4QQyUXCiAgkKYKIiBwJIUKIeJIwIlqSINKFSAgRQiQCGaoRTUkQ6QJk0TIhRCKSMCJAgogQQog4kjAiJIgIIYSIKxmq6dokiAghhEgIEka6JgkiQgghEoaEka4nakFk8+bNXHLJJfTt2xer1Ur//v257bbbcLlc0XpKEYAUqQohko0M1XQtxmg98OrVq9E0jccee4wBAwawfPlyLrvsMmw2G/fee2+0nlbsJwFECJHsPqwfxvGZK+PdDBFlUQsixx13HMcdd1zj9/369WPNmjU88sgjEkSiTEKIECJVSBhJfVELIoHU1NSQn58f9LjT6cTpdDZ+X1tbG4tmpRQJIUKIVOMfppFAkppiVqy6fv16HnjgAa644oqg58yePZucnJzGr549e8aqeUIIIRKc1I2kpnYHkRtvvBFFUUJ+rV7dfIfUHTt2cNxxxzFz5kwuu+yyoI990003UVNT0/i1bdu29v9EQgghUpaEkdTT7qGZP/7xj1x44YUhz+nXr1/jf+/cuZOpU6cyadIkHn/88ZD3s1gsWCyWxu91XQdAszuD3UW04Lal9qwkR5on3k0QQsTZm/WDADgmY3UbZ4p4qa/XgAPX8VAUPZyzOmjHjh1MnTqVcePG8cILL2AwGNp1/+3bt8vwjBBCCJGktm3bRo8ePUKeE7UgsmPHDqZMmULv3r159tlnm4WQ0tLSsB5D0zR27txJVlYWiqJEo5mt1NbW0rNnT7Zt20Z2dnZMnrMrktc5NuR1jg15nWNHXuvY6OzrrOs6dXV1lJWVoaqhq0CiNmvms88+Y/369axfv75VGgo3+6iq2maSipbs7Gz5JY8BeZ1jQ17n2JDXOXbktY6NzrzOOTk5YZ0XtVkzF154IbquB/wSQgghhADZa0YIIYQQcSRBpAWLxcJtt93WbPaOiDx5nWNDXufYkNc5duS1jo1Yvs5RnTUjhBBCCBGK9IgIIYQQIm4kiAghhBAibiSICCGEECJuJIgIIYQQIm4kiASxefNmLrnkEvr27YvVaqV///7cdtttuFypvZdLPNx1111MmjSJ9PR0cnNz492clPLQQw/Rp08f0tLSmDhxIj/99FO8m5RyFixYwEknnURZWRmKovD222/Hu0kpZ/bs2YwfP56srCyKi4s59dRTWbNmTbyblZIeeeQRDjrooMaFzA499FA++uijqD6nBJEgVq9ejaZpPPbYY6xYsYL//ve/PProo/z1r3+Nd9NSjsvlYubMmVx11VXxbkpKeeWVV7j++uu57bbbWLx4MaNGjeLYY49l9+7d8W5aSrHZbIwaNYqHHnoo3k1JWfPnz+fqq6/mhx9+4LPPPsPtdnPMMcdgs9ni3bSU06NHD+6++24WLVrEzz//zLRp0zjllFNYsWJF1J5Tpu+2wz333MMjjzzCxo0b492UlDRnzhyuu+46qqur492UlDBx4kTGjx/Pgw8+CPj2burZsye///3vufHGG+PcutSkKApvvfUWp556arybktL27NlDcXEx8+fP54gjjoh3c1Jefn4+99xzD5dccklUHl96RNqhpqaG/Pz8eDdDiDa5XC4WLVrE9OnTG29TVZXp06fz/fffx7FlQnReTU0NgLwfR5nX6+Xll1/GZrNx6KGHRu15orbpXapZv349DzzwAPfee2+8myJEm/bu3YvX66WkpKTZ7SUlJaxevTpOrRKi8zRN47rrrmPy5MmMGDEi3s1JSb/++iuHHnooDoeDzMxM3nrrLYYNGxa15+tyPSI33ngjiqKE/Gr5Rr1jxw6OO+44Zs6cyWWXXRanlieXjrzOQgjRlquvvprly5fz8ssvx7spKWvw4MEsWbKEH3/8kauuuopZs2axcuXKqD1fl+sR+eMf/8iFF14Y8px+/fo1/vfOnTuZOnUqkyZN4vHHH49y61JHe19nEVmFhYUYDAYqKiqa3V5RUUFpaWmcWiVE51xzzTW8//77LFiwgB49esS7OSnLbDYzYMAAAMaNG8fChQu5//77eeyxx6LyfF0uiBQVFVFUVBTWuTt27GDq1KmMGzeOZ555BlXtch1IHdae11lEntlsZty4cXzxxReNhZOapvHFF19wzTXXxLdxQrSTruv8/ve/56233mLevHn07ds33k3qUjRNw+l0Ru3xu1wQCdeOHTuYMmUKvXv35t5772XPnj2Nx+QTZWRt3bqVyspKtm7ditfrZcmSJQAMGDCAzMzM+DYuiV1//fXMmjWLgw8+mAkTJnDfffdhs9m46KKL4t20lFJfX8/69esbv9+0aRNLliwhPz+fXr16xbFlqePqq69m7ty5vPPOO2RlZVFeXg5ATk4OVqs1zq1LLTfddBMzZsygV69e1NXVMXfuXObNm8cnn3wSvSfVRUDPPPOMDgT8EpE1a9asgK/zV199Fe+mJb0HHnhA79Wrl242m/UJEyboP/zwQ7yblHK++uqrgL+/s2bNinfTUkaw9+Jnnnkm3k1LORdffLHeu3dv3Ww260VFRfpRRx2lf/rpp1F9TllHRAghhBBxI0UPQgghhIgbCSJCCCGEiBsJIkIIIYSIGwkiQgghhIgbCSJCCCGEiBsJIkIIIYSIGwkiQgghhIgbCSJCCCGEiBsJIkIIIYSIGwkiQgghhIgbCSJCCCGEiBsJIkIIIYSIm/8PzbvLzqj6PIEAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "clf = LANDMarkClassifier(n_estimators = 16, use_etc = False, use_nnet = False)\n", + "clf.fit(X_train, y_train)\n", + "\n", + "score = clf.score(X_test, y_test)\n", + "probs = clf.predict_proba(X_test)\n", + "\n", + "print(score)\n", + "\n", + "DB = DecisionBoundaryDisplay.from_estimator(estimator = clf,\n", + " X = X,\n", + " response_method = \"predict_proba\")\n", + "\n", + "DB.ax_.scatter(X_test[:, 0], X_test[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_test], \n", + " edgecolor=\"k\", marker = \"x\")\n", + "DB.ax_.scatter(X_train[:, 0], X_train[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_train], \n", + " edgecolor=\"k\")\n", + "plt.show()\n", + "plt.close()" + ] + }, + { + "cell_type": "markdown", + "id": "0bd72be4", + "metadata": {}, + "source": [ + "#### Default Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b149f603", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\miniconda3\\envs\\testLM\\Lib\\site-packages\\joblib\\externals\\loky\\process_executor.py:752: UserWarning: A worker stopped while some jobs were given to the executor. This can be caused by a too short worker timeout or by a memory leak.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_17960\\4195489463.py:13: UserWarning: You passed a edgecolor/edgecolors ('k') for an unfilled marker ('x'). Matplotlib is ignoring the edgecolor in favor of the facecolor. This behavior may change in the future.\n", + " DB.ax_.scatter(X_test[:, 0], X_test[:, 1],\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "clf = LANDMarkClassifier()\n", + "clf.fit(X_train, y_train)\n", + "\n", + "score = clf.score(X_test, y_test)\n", + "probs = clf.predict_proba(X_test)\n", + "\n", + "print(score)\n", + "\n", + "DB = DecisionBoundaryDisplay.from_estimator(estimator = clf,\n", + " X = X,\n", + " response_method = \"predict_proba\")\n", + "\n", + "DB.ax_.scatter(X_test[:, 0], X_test[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_test], \n", + " edgecolor=\"k\", marker = \"x\")\n", + "DB.ax_.scatter(X_train[:, 0], X_train[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_train], \n", + " edgecolor=\"k\")\n", + "plt.show()\n", + "plt.close()" + ] + }, + { + "cell_type": "markdown", + "id": "bef95ec1", + "metadata": {}, + "source": [ + "#### Use Cascade Set to True. This parameter extends the data using the result of the previous node's decision function. These new features can then be used at subsequent nodes and this serves as a kind of internal feature engineering. In this dataset it results in the generation of more appropriate decision boundaries when using only linear models for the initial cuts (Extra Trees is used if the number of samples in the minority class is very small, but the initial cuts are made using linear models)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "36545bb2", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_17960\\4228608051.py:13: UserWarning: You passed a edgecolor/edgecolors ('k') for an unfilled marker ('x'). Matplotlib is ignoring the edgecolor in favor of the facecolor. This behavior may change in the future.\n", + " DB.ax_.scatter(X_test[:, 0], X_test[:, 1],\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_17960\\4228608051.py:35: UserWarning: You passed a edgecolor/edgecolors ('k') for an unfilled marker ('x'). Matplotlib is ignoring the edgecolor in favor of the facecolor. This behavior may change in the future.\n", + " DB.ax_.scatter(X_test[:, 0], X_test[:, 1],\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "clf = LANDMarkClassifier(n_estimators = 32, use_cascade = False, use_etc = True, etc_max_depth = 3, use_nnet = False)\n", + "clf.fit(X_train, y_train)\n", + "\n", + "score = clf.score(X_test, y_test)\n", + "probs = clf.predict_proba(X_test)\n", + "\n", + "print(score)\n", + "\n", + "DB = DecisionBoundaryDisplay.from_estimator(estimator = clf,\n", + " X = X,\n", + " response_method = \"predict_proba\")\n", + "\n", + "DB.ax_.scatter(X_test[:, 0], X_test[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_test], \n", + " edgecolor=\"k\", marker = \"x\")\n", + "DB.ax_.scatter(X_train[:, 0], X_train[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_train], \n", + " edgecolor=\"k\")\n", + "plt.title(\"Use Cascade is False\")\n", + "plt.show()\n", + "plt.close()\n", + "\n", + "clf = LANDMarkClassifier(n_estimators = 32, use_cascade = True, use_etc = True, etc_max_depth = 3, use_nnet = False)\n", + "clf.fit(X_train, y_train)\n", + "\n", + "score = clf.score(X_test, y_test)\n", + "probs = clf.predict_proba(X_test)\n", + "\n", + "print(score)\n", + "\n", + "DB = DecisionBoundaryDisplay.from_estimator(estimator = clf,\n", + " X = X,\n", + " response_method = \"predict_proba\")\n", + "\n", + "DB.ax_.scatter(X_test[:, 0], X_test[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_test], \n", + " edgecolor=\"k\", marker = \"x\")\n", + "DB.ax_.scatter(X_train[:, 0], X_train[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_train], \n", + " edgecolor=\"k\")\n", + "plt.title(\"Use Cascade is True\")\n", + "plt.show()\n", + "plt.close()" + ] + }, + { + "cell_type": "markdown", + "id": "df82eb5d", + "metadata": {}, + "source": [ + "#### Random Oracle. Using the random oracle results in random divisions of the data at the initial node. This creates more diverse trees which are better able to approximate the decision function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8a95da2e", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.95\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_17960\\2353877849.py:13: UserWarning: You passed a edgecolor/edgecolors ('k') for an unfilled marker ('x'). Matplotlib is ignoring the edgecolor in favor of the facecolor. This behavior may change in the future.\n", + " DB.ax_.scatter(X_test[:, 0], X_test[:, 1],\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "clf = LANDMarkClassifier(n_estimators = 16, use_oracle = True)\n", + "clf.fit(X_train, y_train)\n", + "\n", + "score = clf.score(X_test, y_test)\n", + "probs = clf.predict_proba(X_test)\n", + "\n", + "print(score)\n", + "\n", + "DB = DecisionBoundaryDisplay.from_estimator(estimator = clf,\n", + " X = X,\n", + " response_method = \"predict_proba\")\n", + "\n", + "DB.ax_.scatter(X_test[:, 0], X_test[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_test], \n", + " edgecolor=\"k\", marker = \"x\")\n", + "DB.ax_.scatter(X_train[:, 0], X_train[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_train], \n", + " edgecolor=\"k\")\n", + "plt.title(\"Using Random Oracle\")\n", + "plt.show()\n", + "plt.close()\n", + "\n", + "clf = LANDMarkClassifier(n_estimators = 16, use_oracle = False)\n", + "clf.fit(X_train, y_train)\n", + "\n", + "score = clf.score(X_test, y_test)\n", + "probs = clf.predict_proba(X_test)\n", + "\n", + "print(score)\n", + "\n", + "DB = DecisionBoundaryDisplay.from_estimator(estimator = clf,\n", + " X = X,\n", + " response_method = \"predict_proba\")\n", + "\n", + "DB.ax_.scatter(X_test[:, 0], X_test[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_test], \n", + " edgecolor=\"k\", marker = \"x\")\n", + "DB.ax_.scatter(X_train[:, 0], X_train[:, 1], \n", + " c=[\"black\" if entry == 1 else \"red\" for entry in y_train], \n", + " edgecolor=\"k\")\n", + "plt.title(\"Not Using Random Oracle\")\n", + "plt.show()\n", + "plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e87fda41", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/README.md b/notebooks/README.md index e69de29..45719ed 100644 --- a/notebooks/README.md +++ b/notebooks/README.md @@ -0,0 +1,4 @@ +This directory contains example notebooks for `LANDMark` models. The notebooks are organized as follows: + +- [Usage Example](ExampleUsage.ipynb) - A notebook that demonstrates how to use the `LANDMarkClassifier` with the Wisconsin Breast Cancer dataset. +- [Parameter Effects](ParameterChoices.ipynb) - A notebook that demonstrates how `LANDMarkClassifier` hyper-parameters influence the decision boundary in the Two Moons dataset. \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 1711bf1..b7a5e93 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ requires = ["hatchling"] [project] name = "LANDMarkClassifier" -version = "2.0.7" +version = "2.1.0" authors = [ {name = "Josip Rudar", email = "rudarj@uoguelph.ca"}, {name = "Teresita M. Porter"}, diff --git a/tests/test_landmark.py b/tests/test_landmark.py index 8c900c3..4d9ad36 100644 --- a/tests/test_landmark.py +++ b/tests/test_landmark.py @@ -4,7 +4,7 @@ from LANDMark.lm_oracle_clfs import RandomOracle from LANDMark.lm_dtree_clfs import ETClassifier -from sklearn.datasets import load_wine +from sklearn.datasets import load_wine, load_breast_cancer from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split from sklearn.metrics import balanced_accuracy_score @@ -17,7 +17,7 @@ def test_landmark(): # Create the dataset - X, y = load_wine(return_X_y = True) + X, y = load_breast_cancer(return_X_y = True) # Split into train and test sets X_train, X_test, y_train, y_test = train_test_split( @@ -31,19 +31,36 @@ def test_landmark(): X_train = X_trf.transform(X_train) X_test = X_trf.transform(X_test) - # Setup a LANDMark model and fit - clf = LANDMarkClassifier(n_estimators = 16, n_jobs = 2, min_samples_in_leaf = 2) + # Setup a LANDMark model and fit (With Cascade) + clf = LANDMarkClassifier(n_estimators = 16, n_jobs = 4, min_samples_in_leaf = 2, use_cascade = True) clf.fit(X_train, y_train) # Make a prediction predictions = clf.predict(X_test) + # Score + BAccC = clf.score(X_test, y_test) + assert BAccC >= 0.85 + + # Get proximity - Test Logic + clf.proximity(X_train, "terminal") + clf.proximity(X_train, "path") + + # Setup a LANDMark model and fit (Without Cascade) + clf = LANDMarkClassifier(n_estimators = 16, n_jobs = 4, min_samples_in_leaf = 2, use_cascade = False) + clf.fit(X_train, y_train) + + # Make a prediction + clf.predict(X_test) + # Score BAcc = clf.score(X_test, y_test) assert BAcc >= 0.85 # Get proximity - prox = clf.proximity(X_train) + clf.proximity(X_train, "terminal") + clf.proximity(X_train, "path") + def test_models():