From 220b4e2e071eb91a77a67733d7e73bba4afa62c6 Mon Sep 17 00:00:00 2001 From: jrudar Date: Tue, 6 Jun 2023 01:55:51 -0400 Subject: [PATCH 01/14] - 'use_cascade' parameter is now active. This parameter extends X using the results of the decision function at each node. These new features are then used alongside the original features during the training (and prediction) steps within each node in the tree. --- LANDMark/LANDMark.py | 3 +- LANDMark/tree.py | 83 +++++++++++++++++++++++++++++++++++++----- tests/test_landmark.py | 22 +++++++++-- 3 files changed, 94 insertions(+), 14 deletions(-) diff --git a/LANDMark/LANDMark.py b/LANDMark/LANDMark.py index 119e7a1..cd06dc3 100644 --- a/LANDMark/LANDMark.py +++ b/LANDMark/LANDMark.py @@ -90,7 +90,8 @@ def fit(self, X: np.ndarray, y: np.ndarray) -> LANDMarkClassifier: 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_, diff --git a/LANDMark/tree.py b/LANDMark/tree.py index 99ce177..c98abf7 100644 --- a/LANDMark/tree.py +++ b/LANDMark/tree.py @@ -127,7 +127,8 @@ def get_split( etc_max_trees, N, current_depth, - use_oracle + use_oracle, + use_cascade ): # Get the ID of the node self.node_id = id(self) @@ -185,6 +186,12 @@ def get_split( D = self.splitter.decision_function(X) + if use_cascade: + X_new = np.hstack((X, D.reshape(-1,1))) + + else: + X_new = X + L = np.where(D > 0, True, False) R = np.where(D <= 0, True, False) @@ -194,7 +201,7 @@ def get_split( # 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, @@ -212,10 +219,11 @@ def get_split( N=X.shape[0], current_depth=current_depth + 1, use_oracle=False, + 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, @@ -233,6 +241,7 @@ def get_split( N=X.shape[0], current_depth=current_depth + 1, use_oracle=False, + use_cascade = use_cascade ) return self @@ -375,9 +384,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, @@ -395,10 +420,11 @@ def get_split( 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, @@ -416,6 +442,7 @@ def get_split( N=X.shape[0], current_depth=current_depth + 1, use_oracle=use_oracle, + use_cascade = use_cascade ) return self @@ -448,6 +475,7 @@ def __init__( etc_max_depth, etc_max_trees, resampler, + use_cascade, ): self.min_samples_in_leaf = min_samples_in_leaf self.max_depth = max_depth @@ -464,6 +492,7 @@ def __init__( 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) @@ -501,6 +530,7 @@ def fit(self, X, y): N=X.shape[0], current_depth=1, use_oracle=self.use_oracle, + use_cascade = self.use_cascade ) self.LMTree = tree @@ -533,6 +563,7 @@ def _predict(self, X, current_node=None, samp_idx=None): if current_node.terminal is False: + # Determine where each sample goes D = current_node.splitter.decision_function(X) if D.ndim > 1: @@ -541,10 +572,26 @@ 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: @@ -599,7 +646,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 +655,26 @@ 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: diff --git a/tests/test_landmark.py b/tests/test_landmark.py index 8c900c3..5969b96 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 @@ -31,8 +31,22 @@ 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 + prox = clf.proximity(X_train) + + # 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 @@ -45,6 +59,8 @@ def test_landmark(): # Get proximity prox = clf.proximity(X_train) + dfdfd = 5 + def test_models(): # Create the dataset From 8fe1cae9b7bc03f7e4149cc7239d4f91a38135a3 Mon Sep 17 00:00:00 2001 From: jrudar Date: Tue, 6 Jun 2023 02:17:43 -0400 Subject: [PATCH 02/14] - Updated API - Updated tests - Updated version (2.1.0) due to new non-breaking feature --- LANDMark/LANDMark.py | 5 ++++- LANDMark/lm_linear_clfs.py | 5 ----- docs/API.md | 22 ++++++++++++---------- pyproject.toml | 2 +- tests/test_landmark.py | 3 +-- 5 files changed, 18 insertions(+), 19 deletions(-) diff --git a/LANDMark/LANDMark.py b/LANDMark/LANDMark.py index cd06dc3..912723e 100644 --- a/LANDMark/LANDMark.py +++ b/LANDMark/LANDMark.py @@ -175,9 +175,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.") @@ -193,6 +195,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.") @@ -260,7 +263,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_linear_clfs.py b/LANDMark/lm_linear_clfs.py index 5895aca..096e1a6 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,9 +9,7 @@ from sklearn.linear_model import ( RidgeClassifierCV, LogisticRegressionCV, - LogisticRegression, SGDClassifier, - RidgeClassifier, ) from sklearn.svm import LinearSVC from sklearn.ensemble import ExtraTreesClassifier 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/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 5969b96..60202c1 100644 --- a/tests/test_landmark.py +++ b/tests/test_landmark.py @@ -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( @@ -59,7 +59,6 @@ def test_landmark(): # Get proximity prox = clf.proximity(X_train) - dfdfd = 5 def test_models(): From ddff827743f40f5db2a0cccebf86952afba903c9 Mon Sep 17 00:00:00 2001 From: jrudar Date: Fri, 9 Jun 2023 00:04:42 -0400 Subject: [PATCH 03/14] - Updated README - Added notebooks on simple and advanced usage - Added notebooks demonstrating the effects of some important parameters - Changed code in linear models so that 'y_min' is equal to 80% of minimum count of the bootstrapped resampled data - 5-Fold Stratified Cross-Validation is now explicitly stated to be used for linear models - Use of a neural network model to split a node now requires that at greater than 'minority_sz_nnet' samples of the minority class is present in the bootstrapped resampled data. If not, an Extra Trees Classifier with a 'max_depth' of 3 is used - 'minority_sz_lm' controls how many samples must be present to split using a linear model --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) 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 From 4e3d0c984a7c3a59bf8e2783024fd8e186b1c7c0 Mon Sep 17 00:00:00 2001 From: jrudar Date: Fri, 9 Jun 2023 00:05:57 -0400 Subject: [PATCH 04/14] - See latest on Cascade branch --- LANDMark/LANDMark.py | 6 + LANDMark/lm_linear_clfs.py | 25 ++-- LANDMark/lm_nnet_clfs.py | 102 ++++++++------ LANDMark/tree.py | 31 ++++- README.md | 5 - notebooks/ExampleUsage.ipynb | 249 +++++++++++++++++++++++++++++++++++ notebooks/README.md | 3 + 7 files changed, 360 insertions(+), 61 deletions(-) create mode 100644 notebooks/ExampleUsage.ipynb diff --git a/LANDMark/LANDMark.py b/LANDMark/LANDMark.py index 912723e..87b02a5 100644 --- a/LANDMark/LANDMark.py +++ b/LANDMark/LANDMark.py @@ -27,8 +27,10 @@ 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, @@ -47,8 +49,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,8 +89,10 @@ 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, diff --git a/LANDMark/lm_linear_clfs.py b/LANDMark/lm_linear_clfs.py index 096e1a6..6726f49 100644 --- a/LANDMark/lm_linear_clfs.py +++ b/LANDMark/lm_linear_clfs.py @@ -15,6 +15,7 @@ from sklearn.ensemble import ExtraTreesClassifier from sklearn.model_selection import GridSearchCV from sklearn.utils import resample +from sklearn.model_selection import StratifiedKFold from random import choice @@ -22,9 +23,10 @@ class LMClassifier(ClassifierMixin, BaseEstimator): - def __init__(self, model_type, n_feat=0.8): + def __init__(self, model_type, n_feat=0.8, minority = 6): self.model_type = model_type self.n_feat = n_feat + self.minority = minority def fit(self, X, y): if X.shape[1] >= 4: @@ -43,11 +45,13 @@ def fit(self, X, y): self.classes_, y_counts = np.unique(y_re, return_counts=True) - self.y_min = min(y_counts) + self.y_min = min(y_counts) * 0.8 - if self.y_min > 6: + 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" @@ -55,7 +59,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": @@ -65,7 +69,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_ @@ -77,21 +81,22 @@ 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_ @@ -108,7 +113,7 @@ def predict(self, X): def decision_function(self, X): - if self.y_min > 6: + if self.y_min > self.minority: return self.clf.decision_function(X[:, self.features]) else: diff --git a/LANDMark/lm_nnet_clfs.py b/LANDMark/lm_nnet_clfs.py index 253e6f0..567945b 100644 --- a/LANDMark/lm_nnet_clfs.py +++ b/LANDMark/lm_nnet_clfs.py @@ -1,6 +1,7 @@ from sklearn.utils import resample from sklearn.base import ClassifierMixin, BaseEstimator from sklearn.preprocessing import LabelEncoder +from sklearn.ensemble import ExtraTreesClassifier from math import ceil @@ -48,16 +49,17 @@ def forward(self, x): class ANNClassifier(ClassifierMixin, BaseEstimator): - def __init__(self, n_feat=0.8): + def __init__(self, n_feat=0.8, minority = 6): 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) - + # Encode y self.y_transformer = LabelEncoder().fit(y) + # Select features if X.shape[1] >= 4: self.features = np.random.choice( [i for i in range(X.shape[1])], @@ -68,34 +70,51 @@ def fit(self, X, y): else: self.features = np.asarray([i for i in range(X.shape[1])]) + # Bootstrap resample X_trf, y_trf = resample(X[:, self.features], y, n_samples=X.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] + # Determine if minimum class count exists + self.classes_, y_counts = np.unique(y_trf, return_counts=True) - 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.fit(X_trf, y_trf) + 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.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)) - with pyt.inference_mode(): - D = clf.predict_proba(X[:, self.features].astype(np.float32)) + D = np.where(D > 0.5, 1, -1) + + # Otherwise use an Extra Trees Classifier + else: + self.etc_clf = ExtraTreesClassifier(128, max_depth = 3).fit(X_trf, y_trf) + + D = self.etc_clf.predict_proba(X[:, self.features].astype(np.float32)) D = np.where(D > 0.5, 1, -1) @@ -103,25 +122,30 @@ def fit(self, X, y): def predict_proba(self, X): - if pyt.cuda.is_available(): - device = "cuda" - else: - device = "cpu" + if self.y_min > self.minority: - 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 - ) + if pyt.cuda.is_available(): + device = "cuda" + else: + device = "cpu" - clf.module.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 + ) - clf.initialize() + clf.module.load_state_dict(self.params) - with pyt.inference_mode(): - predictions = clf.predict_proba(X[:, self.features].astype(np.float32)) + clf.initialize() + + with pyt.inference_mode(): + predictions = clf.predict_proba(X[:, self.features].astype(np.float32)) + + else: + predictions = self.etc_clf.predict_proba(X[:, self.features].astype(np.float32)) return predictions diff --git a/LANDMark/tree.py b/LANDMark/tree.py index c98abf7..3bc8ff3 100644 --- a/LANDMark/tree.py +++ b/LANDMark/tree.py @@ -120,8 +120,10 @@ 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, @@ -186,6 +188,7 @@ 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_new = np.hstack((X, D.reshape(-1,1))) @@ -211,8 +214,10 @@ 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, @@ -233,8 +238,10 @@ 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, @@ -253,10 +260,10 @@ def get_split( # 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) @@ -282,8 +289,8 @@ def get_split( # 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) @@ -309,7 +316,7 @@ def get_split( # Train a Neural Network if use_nnet: if X.shape[0] >= nnet_min_samples: - for clf in [ANNClassifier(n_feat=max_features)]: + for clf in [ANNClassifier(n_feat=max_features, minority = minority_sz_nnet)]: model, D = clf.fit(X, y) if D.ndim > 1: @@ -412,8 +419,10 @@ 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, @@ -434,8 +443,10 @@ 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, @@ -469,8 +480,10 @@ 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, @@ -486,8 +499,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 @@ -522,8 +537,10 @@ 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, diff --git a/README.md b/README.md index af5ccfa..370b3c2 100644 --- a/README.md +++ b/README.md @@ -65,11 +65,6 @@ To contribute to the development of `LANDMark` please read our [contributing gui # 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 Rudar, J., Porter, T.M., Wright, M., Golding G.B., Hajibabaei, M. LANDMark: an ensemble 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/README.md b/notebooks/README.md index e69de29..070985f 100644 --- a/notebooks/README.md +++ b/notebooks/README.md @@ -0,0 +1,3 @@ +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. \ No newline at end of file From 1b3b0629b2d35cb8d3e369cbc2af7031a074e551 Mon Sep 17 00:00:00 2001 From: jrudar Date: Fri, 9 Jun 2023 00:58:02 -0400 Subject: [PATCH 05/14] - Hyper-parameter notebook --- notebooks/ParameterChoices.ipynb | 617 +++++++++++++++++++++++++++++++ notebooks/README.md | 3 +- 2 files changed, 619 insertions(+), 1 deletion(-) create mode 100644 notebooks/ParameterChoices.ipynb diff --git a/notebooks/ParameterChoices.ipynb b/notebooks/ParameterChoices.ipynb new file mode 100644 index 0000000..e6028ea --- /dev/null +++ b/notebooks/ParameterChoices.ipynb @@ -0,0 +1,617 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4de8df46", + "metadata": {}, + "source": [ + "#### Import Required Files" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "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": 18, + "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": 22, + "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": 34, + "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_31764\\2125759794.py:14: 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": "096834d7", + "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": 35, + "id": "3c0ef663", + "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_31764\\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": "a0c8dfd5", + "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": 36, + "id": "abd841d0", + "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_31764\\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": "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", + "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": "fb5a1cfe", + "metadata": {}, + "source": [ + "#### Default Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "20ca83b8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\miniconda3\\envs\\testLM\\Lib\\site-packages\\joblib\\externals\\loky\\process_executor.py:700: 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_31764\\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": "ce959851", + "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": 55, + "id": "8a3b5241", + "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_31764\\1653589715.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_31764\\1653589715.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 = 1, use_cascade = 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.title(\"Use Cascade is False\")\n", + "plt.show()\n", + "plt.close()\n", + "\n", + "clf = LANDMarkClassifier(n_estimators = 1, use_cascade = 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(\"Use Cascade is True\")\n", + "plt.show()\n", + "plt.close()" + ] + }, + { + "cell_type": "markdown", + "id": "db2f4af0", + "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": 54, + "id": "1f82e803", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_31764\\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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.95\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_31764\\2353877849.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 = 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": "bbc7e6c7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f43d3eba", + "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 070985f..45719ed 100644 --- a/notebooks/README.md +++ b/notebooks/README.md @@ -1,3 +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. \ No newline at end of file +- [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 From a5c704088d2c858bf68efd1c475ccdb40067cdef Mon Sep 17 00:00:00 2001 From: jrudar Date: Fri, 9 Jun 2023 01:16:58 -0400 Subject: [PATCH 06/14] - Notebook update and update to README --- README.md | 31 +------------------- notebooks/ParameterChoices.ipynb | 50 +++++++++++--------------------- 2 files changed, 18 insertions(+), 63 deletions(-) diff --git a/README.md b/README.md index 370b3c2..63e32fd 100644 --- a/README.md +++ b/README.md @@ -29,41 +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) ### References diff --git a/notebooks/ParameterChoices.ipynb b/notebooks/ParameterChoices.ipynb index e6028ea..45a551a 100644 --- a/notebooks/ParameterChoices.ipynb +++ b/notebooks/ParameterChoices.ipynb @@ -155,7 +155,7 @@ }, { "cell_type": "markdown", - "id": "096834d7", + "id": "1fb120b1", "metadata": {}, "source": [ "#### Setup model and train. Predict class labels and score. Plot decision boundary. No L2, Neural Network, or Extra Trees" @@ -218,7 +218,7 @@ }, { "cell_type": "markdown", - "id": "a0c8dfd5", + "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" @@ -227,7 +227,7 @@ { "cell_type": "code", "execution_count": 36, - "id": "abd841d0", + "id": "bad61aa7", "metadata": {}, "outputs": [ { @@ -281,7 +281,7 @@ }, { "cell_type": "markdown", - "id": "fb5a1cfe", + "id": "0bd72be4", "metadata": {}, "source": [ "#### Default Parameters" @@ -290,7 +290,7 @@ { "cell_type": "code", "execution_count": 37, - "id": "20ca83b8", + "id": "b149f603", "metadata": {}, "outputs": [ { @@ -352,7 +352,7 @@ }, { "cell_type": "markdown", - "id": "ce959851", + "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)." @@ -360,10 +360,10 @@ }, { "cell_type": "code", - "execution_count": 55, - "id": "8a3b5241", + "execution_count": 64, + "id": "36545bb2", "metadata": { - "scrolled": true + "scrolled": false }, "outputs": [ { @@ -377,13 +377,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_31764\\1653589715.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", + "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_31764\\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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", + "image/png": "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", "text/plain": [ "
" ] @@ -402,13 +402,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_31764\\1653589715.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", + "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_31764\\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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", + "image/png": "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", "text/plain": [ "
" ] @@ -418,7 +418,7 @@ } ], "source": [ - "clf = LANDMarkClassifier(n_estimators = 1, use_cascade = False, use_etc = False, use_nnet = False)\n", + "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", @@ -440,7 +440,7 @@ "plt.show()\n", "plt.close()\n", "\n", - "clf = LANDMarkClassifier(n_estimators = 1, use_cascade = True)\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", @@ -465,7 +465,7 @@ }, { "cell_type": "markdown", - "id": "db2f4af0", + "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." @@ -474,7 +474,7 @@ { "cell_type": "code", "execution_count": 54, - "id": "1f82e803", + "id": "8a95da2e", "metadata": { "scrolled": true }, @@ -575,22 +575,6 @@ "plt.show()\n", "plt.close()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bbc7e6c7", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f43d3eba", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 95dc9fe1d9a840d5e154ffd0f70bbab89a7272fe Mon Sep 17 00:00:00 2001 From: jrudar Date: Mon, 10 Jul 2023 14:45:08 -0400 Subject: [PATCH 07/14] - Autodetection of sparse matrix and conversion to CSR format if sparsity >= 90% sparsity - New way to create high-dimensional embedding for calculation of dissimilarities using the proximity() function: "path". By using this parameter a binary matrix containing all nodes visited by sample is created rather than just the terminal nodes. - New hyper-parameter 'use_etc_split' will control if a shallow ExtraTreesClassifier() is constructed at nodes where 'minority_sz_lm' and 'minority_sz_nnet' are not met - Initial layer of neural network model uses 'mish' activation function and other small changes to the architecture of the network - Replaced the _get_node_ids() function in tree.py with _get_all_nodes(). This is done so that the new embedding approach can be implimented --- LANDMark/LANDMark.py | 83 +++++++-- LANDMark/lm_dtree_clfs.py | 8 +- LANDMark/lm_linear_clfs.py | 28 +-- LANDMark/lm_nnet_clfs.py | 126 +++++++------ LANDMark/lm_oracle_clfs.py | 35 +++- LANDMark/tree.py | 352 +++++++++++++++++++++++++------------ LANDMark/utils.py | 8 +- 7 files changed, 426 insertions(+), 214 deletions(-) diff --git a/LANDMark/LANDMark.py b/LANDMark/LANDMark.py index 87b02a5..4b6f68e 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, @@ -34,9 +35,10 @@ def __init__( use_etc: bool = True, etc_max_depth: int = 5, etc_max_trees: int = 128, - resampler = None, + use_etc_split: bool = False, + resampler=None, use_cascade: bool = False, - n_jobs: int = 4 + n_jobs: int = 4, ): # Tree construction parameters self.n_estimators = n_estimators @@ -56,6 +58,7 @@ def __init__( self.use_etc = use_etc self.etc_max_depth = etc_max_depth self.etc_max_trees = etc_max_trees + self.use_etc_split = use_etc_split self.resampler = resampler self.use_cascade = use_cascade @@ -89,15 +92,16 @@ 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, + 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, + 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, + use_etc_split=self.use_etc_split, resampler=self.resampler, - use_cascade = self.use_cascade + use_cascade=self.use_cascade, ), n_estimators=self.n_estimators, class_names=self.classes_, @@ -147,23 +151,72 @@ 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)) + + emb = np.hstack(tree_mats) + + return csr_array(emb.astype(np.uint8)) + + else: + 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 estimator in self.estimators_.estimators_: - tree_mats.append(estimator.proximity(X)) + for tree_emb in embs: + for sample, nodes in tree_emb.items(): + for node in nodes: + emb[sample, self.node_set[node]] = 1 - emb = np.hstack(tree_mats) + return csr_array(emb) - return emb + else: + embs = [ + est.proximity(X, prox_type) for est in self.estimators_.estimators_ + ] - def _check_params(self, X: np.ndarray, y: np.ndarray) -> List[np.ndarray, np.ndarray]: + node_set = set() + [node_set.update(est.all_nodes) for est in self.estimators_.estimators_] + + node_set = list(node_set) + emb = np.zeros(shape=(X.shape[0], len(node_set)), dtype=np.uint8) + + self.node_set = {node: i for i, node in enumerate(node_set)} + + 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.") @@ -243,7 +296,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.") 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 6726f49..36941b8 100644 --- a/LANDMark/lm_linear_clfs.py +++ b/LANDMark/lm_linear_clfs.py @@ -23,10 +23,11 @@ class LMClassifier(ClassifierMixin, BaseEstimator): - def __init__(self, model_type, n_feat=0.8, minority = 6): + 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 + self.use_etc_split = use_etc_split def fit(self, X, y): if X.shape[1] >= 4: @@ -46,11 +47,11 @@ def fit(self, X, y): self.classes_, y_counts = np.unique(y_re, return_counts=True) 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=StratifiedKFold(5) + self.clf = LogisticRegressionCV( + max_iter=2000, cv=StratifiedKFold(5) ).fit(X_re, y_re) elif self.model_type == "lr_l1": @@ -88,8 +89,7 @@ def fit(self, X, y): elif self.model_type == "ridge": self.clf = RidgeClassifierCV( - alphas=(0.001, 0.01, 0.1, 1.0, 10, 100, 1000), - cv=StratifiedKFold(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": @@ -101,22 +101,26 @@ def fit(self, X, y): self.clf = self.cv.best_estimator_ + return self, self.decision_function(X) + + # Otherwise use an Extra Trees Classifier or Nothing else: - self.clf = ExtraTreesClassifier(n_estimators = 128, max_depth = 1) - - self.clf.fit(X_re, y_re) + if self.use_etc_split: + self.clf = ExtraTreesClassifier(128, max_depth=3).fit(X_trf, y_trf) + + return self, self.decision_function(X) - return self, self.decision_function(X) + else: + return self, None def predict(self, X): return self.clf.predict(X[:, self.features]) def decision_function(self, X): - if self.y_min > self.minority: return self.clf.decision_function(X[:, self.features]) else: D = self.clf.predict_proba(X[:, self.features]) - return np.where(D > 0.5, 1, -1) \ No newline at end of file + return np.where(D > 0.5, 1, -1) diff --git a/LANDMark/lm_nnet_clfs.py b/LANDMark/lm_nnet_clfs.py index 567945b..55579af 100644 --- a/LANDMark/lm_nnet_clfs.py +++ b/LANDMark/lm_nnet_clfs.py @@ -11,6 +11,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__() @@ -18,22 +21,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) @@ -49,29 +58,41 @@ def forward(self, x): class ANNClassifier(ClassifierMixin, BaseEstimator): - def __init__(self, n_feat=0.8, minority = 6): + def __init__(self, n_feat=0.8, minority=6, use_etc_split=True): self.n_feat = n_feat self.minority = minority + self.use_etc_split = use_etc_split def fit(self, X, y): self.model_type = "nonlinear_nnet" + if issparse(X): + X_not_sparse = X.toarray() + + else: + X_not_sparse = X + # Encode y self.y_transformer = LabelEncoder().fit(y) # Select features - if X.shape[1] >= 4: + 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])]) # Bootstrap resample - X_trf, y_trf = resample(X[:, self.features], y, n_samples=X.shape[0], stratify=y) + 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) @@ -82,7 +103,6 @@ def fit(self, X, y): # 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] @@ -91,75 +111,73 @@ def fit(self, X, y): 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) - + 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) - # Otherwise use an Extra Trees Classifier + # Otherwise use an Extra Trees Classifier or Nothing else: - self.etc_clf = ExtraTreesClassifier(128, max_depth = 3).fit(X_trf, y_trf) - - D = self.etc_clf.predict_proba(X[:, self.features].astype(np.float32)) + if self.use_etc_split: + self.clf = ExtraTreesClassifier(128, max_depth=3).fit(X_trf, y_trf) - D = np.where(D > 0.5, 1, -1) + return self, self.decision_function(X) - return self, D + else: + return self, None def predict_proba(self, X): + if issparse(X): + X_not_sparse = X.toarray() + + else: + X_not_sparse = X if self.y_min > self.minority: + clf = LMNNet(n_in=self.n_in, n_out=self.n_out) - if pyt.cuda.is_available(): - device = "cuda" - else: - device = "cpu" + clf.load_state_dict(self.params) + + n_batch = pyt.arange(0, len(X_not_sparse), 16) - 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 - ) + X_tensor = pyt.tensor(X_not_sparse[:, self.features].astype(np.float32)) - clf.module.load_state_dict(self.params) + predictions = [] + for start in n_batch: + p = clf(X_tensor[start : start + 16]).detach().cpu().numpy() + predictions.extend(p) - clf.initialize() + predictions = np.asarray(predictions) - with pyt.inference_mode(): - predictions = clf.predict_proba(X[:, self.features].astype(np.float32)) + del clf else: - predictions = self.etc_clf.predict_proba(X[:, self.features].astype(np.float32)) + predictions = self.clf.predict_proba(X_not_sparse[:, self.features]) 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..eb1f44d 100644 --- a/LANDMark/lm_oracle_clfs.py +++ b/LANDMark/lm_oracle_clfs.py @@ -3,6 +3,9 @@ from math import ceil from sklearn.base import ClassifierMixin, BaseEstimator +from sklearn.utils.extmath import safe_sparse_dot + +from scipy.sparse import issparse class RandomOracle(ClassifierMixin, BaseEstimator): @@ -11,29 +14,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 +54,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 3bc8ff3..268ea54 100644 --- a/LANDMark/tree.py +++ b/LANDMark/tree.py @@ -127,10 +127,11 @@ def get_split( use_etc, etc_max_depth, etc_max_trees, + use_etc_split, N, current_depth, use_oracle, - use_cascade + use_cascade, ): # Get the ID of the node self.node_id = id(self) @@ -171,14 +172,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: @@ -190,10 +190,7 @@ def get_split( # Extend X using the output of the decision function, D, if the cascade parameter is True if use_cascade: - X_new = np.hstack((X, D.reshape(-1,1))) - - else: - X_new = X + X = np.hstack((X, D.reshape(-1, 1))) L = np.where(D > 0, True, False) R = np.where(D <= 0, True, False) @@ -204,7 +201,7 @@ def get_split( # Recursivly split self.left = Node().get_split( - X_new[L], + X[L], y[L], min_samples_in_leaf=min_samples_in_leaf, max_depth=max_depth, @@ -221,14 +218,15 @@ def get_split( use_etc=use_etc, etc_max_depth=etc_max_depth, etc_max_trees=etc_max_trees, + use_etc_split=use_etc_split, N=X.shape[0], current_depth=current_depth + 1, use_oracle=False, - use_cascade = use_cascade + use_cascade=use_cascade, ) self.right = Node().get_split( - X_new[R], + X[R], y[R], min_samples_in_leaf=min_samples_in_leaf, max_depth=max_depth, @@ -245,80 +243,88 @@ def get_split( use_etc=use_etc, etc_max_depth=etc_max_depth, etc_max_trees=etc_max_trees, + use_etc_split=use_etc_split, N=X.shape[0], current_depth=current_depth + 1, use_oracle=False, - use_cascade = use_cascade + 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, 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), + LMClassifier( + model_type="lr_l2", + n_feat=max_features, + minority=minority_sz_lm, + use_etc_split=use_etc_split, + ), + LMClassifier( + model_type="sgd_l2", + n_feat=max_features, + minority=minority_sz_lm, + use_etc_split=use_etc_split, + ), + LMClassifier( + model_type="ridge", + n_feat=max_features, + minority=minority_sz_lm, + use_etc_split=use_etc_split, + ), + LMClassifier( + model_type="lsvc", + n_feat=max_features, + minority=minority_sz_lm, + use_etc_split=use_etc_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) # Train Linear Models - L1 / ElasticNet if use_lm_l1: for clf in [ - 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), + LMClassifier( + model_type="lr_l1", + n_feat=max_features, + minority=minority_sz_lm, + use_etc_split=use_etc_split, + ), + LMClassifier( + model_type="sgd_l1", + n_feat=max_features, + minority=minority_sz_lm, + use_etc_split=use_etc_split, + ), ]: 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, 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] @@ -338,6 +344,38 @@ 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, + use_etc_split=use_etc_split, + ) + ]: + 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 [ @@ -349,24 +387,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") @@ -397,7 +436,7 @@ def get_split( X_cascade = self.splitter.decision_function(X) if X_cascade.ndim == 1: - X_cascade = X_cascade.reshape(-1,1) + X_cascade = X_cascade.reshape(-1, 1) else: X_cascade = self.splitter.predict_proba(X) @@ -426,10 +465,11 @@ def get_split( use_etc=use_etc, etc_max_depth=etc_max_depth, etc_max_trees=etc_max_trees, + use_etc_split=use_etc_split, N=X.shape[0], current_depth=current_depth + 1, use_oracle=use_oracle, - use_cascade = use_cascade + use_cascade=use_cascade, ) self.right = Node().get_split( @@ -450,10 +490,11 @@ def get_split( use_etc=use_etc, etc_max_depth=etc_max_depth, etc_max_trees=etc_max_trees, + use_etc_split=use_etc_split, N=X.shape[0], current_depth=current_depth + 1, use_oracle=use_oracle, - use_cascade = use_cascade + use_cascade=use_cascade, ) return self @@ -487,6 +528,7 @@ def __init__( use_etc, etc_max_depth, etc_max_trees, + use_etc_split, resampler, use_cascade, ): @@ -506,6 +548,7 @@ def __init__( self.use_etc = use_etc self.etc_max_depth = etc_max_depth self.etc_max_trees = etc_max_trees + self.use_etc_split = use_etc_split self.resampler = resampler self.use_cascade = use_cascade @@ -537,38 +580,26 @@ 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, + 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, + 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, + use_etc_split=self.use_etc_split, N=X.shape[0], current_depth=1, use_oracle=self.use_oracle, - use_cascade = self.use_cascade + use_cascade=self.use_cascade, ) self.LMTree = tree - # Find all Node Ids - self.all_ids = list(set(self._get_node_ids(self.LMTree))) + self.all_nodes = self._get_all_nodes(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)) - - else: - ids.append(node.node_id) - - return ids - def _predict(self, X, current_node=None, samp_idx=None): final_predictions = [] @@ -579,7 +610,6 @@ 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) @@ -591,12 +621,14 @@ def _predict(self, X, current_node=None, samp_idx=None): # Append decision function data if self.use_cascade: - if isinstance(current_node.splitter, LMClassifier) or isinstance(current_node.splitter, RandomOracle): + 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) @@ -622,10 +654,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 @@ -651,6 +680,20 @@ def score(self, X, y): return score + def _get_all_nodes(self, node): + node_list = set() + + node_list.update([node.node_id]) + + if node.terminal == False: + 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: + return node_list + + return node_list + def _proximity(self, X, current_node=None, samp_idx=None): final_predictions = [] @@ -662,7 +705,6 @@ 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 where each sample goes D = current_node.splitter.decision_function(X) @@ -674,12 +716,14 @@ def _proximity(self, X, current_node=None, samp_idx=None): # Append decision function data if self.use_cascade: - if isinstance(current_node.splitter, LMClassifier) or isinstance(current_node.splitter, RandomOracle): + 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) @@ -707,25 +751,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.all_ids)} + + emb_matrix = np.zeros( + shape=(X.shape[0], len(self.all_ids)), 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 From e9e301b1013c55267df4b6394cfd05ed03b3808d Mon Sep 17 00:00:00 2001 From: jrudar Date: Mon, 10 Jul 2023 14:52:50 -0400 Subject: [PATCH 08/14] - Corrected typo on Line 109 in lm_linear_clfs.py --- LANDMark/lm_linear_clfs.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LANDMark/lm_linear_clfs.py b/LANDMark/lm_linear_clfs.py index 36941b8..10e0cb4 100644 --- a/LANDMark/lm_linear_clfs.py +++ b/LANDMark/lm_linear_clfs.py @@ -106,7 +106,7 @@ def fit(self, X, y): # Otherwise use an Extra Trees Classifier or Nothing else: if self.use_etc_split: - self.clf = ExtraTreesClassifier(128, max_depth=3).fit(X_trf, y_trf) + self.clf = ExtraTreesClassifier(128, max_depth=3).fit(X_re, y_re) return self, self.decision_function(X) From 447f9ae1fe89301970dd3f50f37abb3351c8ae83 Mon Sep 17 00:00:00 2001 From: jrudar Date: Mon, 10 Jul 2023 15:09:16 -0400 Subject: [PATCH 09/14] - Removed unused imports and variables - Added additional tests --- LANDMark/lm_linear_clfs.py | 2 -- LANDMark/lm_oracle_clfs.py | 1 - LANDMark/tree.py | 2 +- tests/test_landmark.py | 18 +++++++++++++++--- 4 files changed, 16 insertions(+), 7 deletions(-) diff --git a/LANDMark/lm_linear_clfs.py b/LANDMark/lm_linear_clfs.py index 10e0cb4..55813a9 100644 --- a/LANDMark/lm_linear_clfs.py +++ b/LANDMark/lm_linear_clfs.py @@ -17,8 +17,6 @@ from sklearn.utils import resample from sklearn.model_selection import StratifiedKFold -from random import choice - from math import ceil diff --git a/LANDMark/lm_oracle_clfs.py b/LANDMark/lm_oracle_clfs.py index eb1f44d..cd5bc97 100644 --- a/LANDMark/lm_oracle_clfs.py +++ b/LANDMark/lm_oracle_clfs.py @@ -3,7 +3,6 @@ from math import ceil from sklearn.base import ClassifierMixin, BaseEstimator -from sklearn.utils.extmath import safe_sparse_dot from scipy.sparse import issparse diff --git a/LANDMark/tree.py b/LANDMark/tree.py index 268ea54..41f5fba 100644 --- a/LANDMark/tree.py +++ b/LANDMark/tree.py @@ -685,7 +685,7 @@ def _get_all_nodes(self, node): node_list.update([node.node_id]) - if node.terminal == False: + if node.terminal is False: node_list = node_list.union(self._get_all_nodes(node.left)) node_list = node_list.union(self._get_all_nodes(node.right)) diff --git a/tests/test_landmark.py b/tests/test_landmark.py index 60202c1..e63eaa3 100644 --- a/tests/test_landmark.py +++ b/tests/test_landmark.py @@ -43,21 +43,23 @@ def test_landmark(): assert BAccC >= 0.85 # Get proximity - prox = clf.proximity(X_train) + 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 - predictions = clf.predict(X_test) + 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(): @@ -82,6 +84,11 @@ def test_models(): BAcc = balanced_accuracy_score(y_test, p) assert BAcc > 0.7 + # Tests the ANN for min samples + clf, _ = ANNClassifier().fit(X_train[0:4], y_train[0:4]) + p = clf.predict(X_test) + D = clf.decision_function(X_test) + clf, _ = ETClassifier().fit(X_train, y_train) p = clf.predict(X_test) BAcc = balanced_accuracy_score(y_test, p) @@ -98,6 +105,11 @@ def test_models(): assert BAcc > 0.7 D = clf.decision_function(X_test) + # Tests the ETC model for min samples + clf, _ = LMClassifier(model_type="lr_l2").fit(X_train[0:4], y_train[0:4]) + p = clf.predict(X_test) + D = clf.decision_function(X_test) + clf, _ = LMClassifier(model_type="sgd_l2").fit(X_train, y_train) p = clf.predict(X_test) BAcc = balanced_accuracy_score(y_test, p) From 11596922615e1e5be451e629e34beba00ff3a7e2 Mon Sep 17 00:00:00 2001 From: jrudar Date: Mon, 10 Jul 2023 19:04:09 -0400 Subject: [PATCH 10/14] Fixed bug in "terminal" path related to new changes in the "path" option. --- LANDMark/LANDMark.py | 2 +- LANDMark/tree.py | 13 +++++++++---- tests/test_landmark.py | 2 +- 3 files changed, 11 insertions(+), 6 deletions(-) diff --git a/LANDMark/LANDMark.py b/LANDMark/LANDMark.py index 4b6f68e..80a1548 100644 --- a/LANDMark/LANDMark.py +++ b/LANDMark/LANDMark.py @@ -158,7 +158,7 @@ def proximity(self, X: np.ndarray, prox_type: str = "path") -> np.ndarray: tree_mats = [] for estimator in self.estimators_.estimators_: - tree_mats.append(estimator.proximity(X)) + tree_mats.append(estimator.proximity(X, prox_type)) emb = np.hstack(tree_mats) diff --git a/LANDMark/tree.py b/LANDMark/tree.py index 41f5fba..d2e7c14 100644 --- a/LANDMark/tree.py +++ b/LANDMark/tree.py @@ -598,6 +598,9 @@ def fit(self, X, y): self.all_nodes = self._get_all_nodes(self.LMTree) + 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 self def _predict(self, X, current_node=None, samp_idx=None): @@ -683,13 +686,15 @@ def score(self, X, y): def _get_all_nodes(self, node): node_list = set() - node_list.update([node.node_id]) - 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 @@ -826,10 +831,10 @@ def proximity(self, X, prox_type="path"): tree_predictions.sort() - col_dict = {col: i for i, col in enumerate(self.all_ids)} + col_dict = {col: i for i, col in enumerate(self.terminal_nodes)} emb_matrix = np.zeros( - shape=(X.shape[0], len(self.all_ids)), dtype=np.ushort + shape=(X.shape[0], len(self.terminal_nodes)), dtype=np.ushort ) for entry in tree_predictions: diff --git a/tests/test_landmark.py b/tests/test_landmark.py index e63eaa3..805a098 100644 --- a/tests/test_landmark.py +++ b/tests/test_landmark.py @@ -42,7 +42,7 @@ def test_landmark(): BAccC = clf.score(X_test, y_test) assert BAccC >= 0.85 - # Get proximity + # Get proximity - Test Logic clf.proximity(X_train, "terminal") clf.proximity(X_train, "path") From f8a2dbadd491b2fd8bb1c2e18650481200f06bdc Mon Sep 17 00:00:00 2001 From: jrudar Date: Tue, 11 Jul 2023 20:50:17 -0400 Subject: [PATCH 11/14] - Removed ability of models to use ExtraTreesClassifier at each node. - Updated tests to reflect above --- LANDMark/LANDMark.py | 13 ++++++++----- LANDMark/lm_linear_clfs.py | 16 ++-------------- LANDMark/lm_nnet_clfs.py | 33 +++++++++++---------------------- LANDMark/tree.py | 14 -------------- tests/test_landmark.py | 10 ---------- 5 files changed, 21 insertions(+), 65 deletions(-) diff --git a/LANDMark/LANDMark.py b/LANDMark/LANDMark.py index 80a1548..bf0df4a 100644 --- a/LANDMark/LANDMark.py +++ b/LANDMark/LANDMark.py @@ -35,7 +35,6 @@ def __init__( use_etc: bool = True, etc_max_depth: int = 5, etc_max_trees: int = 128, - use_etc_split: bool = False, resampler=None, use_cascade: bool = False, n_jobs: int = 4, @@ -58,7 +57,6 @@ def __init__( self.use_etc = use_etc self.etc_max_depth = etc_max_depth self.etc_max_trees = etc_max_trees - self.use_etc_split = use_etc_split self.resampler = resampler self.use_cascade = use_cascade @@ -99,7 +97,6 @@ def fit(self, X: np.ndarray, y: np.ndarray) -> LANDMarkClassifier: use_etc=self.use_etc, etc_max_depth=self.etc_max_depth, etc_max_trees=self.etc_max_trees, - use_etc_split=self.use_etc_split, resampler=self.resampler, use_cascade=self.use_cascade, ), @@ -164,7 +161,7 @@ def proximity(self, X: np.ndarray, prox_type: str = "path") -> np.ndarray: return csr_array(emb.astype(np.uint8)) - else: + elif prox_type == "path": if hasattr(self, "node_set"): embs = [ est.proximity(X, prox_type) for est in self.estimators_.estimators_ @@ -185,18 +182,24 @@ def proximity(self, X: np.ndarray, prox_type: str = "path") -> np.ndarray: return csr_array(emb) else: + # Get the list of nodes associated with each sample in X embs = [ est.proximity(X, prox_type) for est in self.estimators_.estimators_ ] + # 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_] node_set = list(node_set) + + # 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: diff --git a/LANDMark/lm_linear_clfs.py b/LANDMark/lm_linear_clfs.py index 55813a9..d0a1078 100644 --- a/LANDMark/lm_linear_clfs.py +++ b/LANDMark/lm_linear_clfs.py @@ -25,7 +25,6 @@ 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 - self.use_etc_split = use_etc_split def fit(self, X, y): if X.shape[1] >= 4: @@ -103,22 +102,11 @@ def fit(self, X, y): # Otherwise use an Extra Trees Classifier or Nothing else: - if self.use_etc_split: - self.clf = ExtraTreesClassifier(128, max_depth=3).fit(X_re, y_re) - - return self, self.decision_function(X) - - else: - return self, None + return self, None def predict(self, X): return self.clf.predict(X[:, self.features]) def decision_function(self, X): - if self.y_min > self.minority: - 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) diff --git a/LANDMark/lm_nnet_clfs.py b/LANDMark/lm_nnet_clfs.py index 55579af..777d3bb 100644 --- a/LANDMark/lm_nnet_clfs.py +++ b/LANDMark/lm_nnet_clfs.py @@ -61,7 +61,6 @@ class ANNClassifier(ClassifierMixin, BaseEstimator): def __init__(self, n_feat=0.8, minority=6, use_etc_split=True): self.n_feat = n_feat self.minority = minority - self.use_etc_split = use_etc_split def fit(self, X, y): self.model_type = "nonlinear_nnet" @@ -132,13 +131,7 @@ def fit(self, X, y): # Otherwise use an Extra Trees Classifier or Nothing else: - if self.use_etc_split: - self.clf = ExtraTreesClassifier(128, max_depth=3).fit(X_trf, y_trf) - - return self, self.decision_function(X) - - else: - return self, None + return self, None def predict_proba(self, X): if issparse(X): @@ -147,26 +140,22 @@ def predict_proba(self, X): else: X_not_sparse = X - if self.y_min > self.minority: - clf = LMNNet(n_in=self.n_in, n_out=self.n_out) + clf = LMNNet(n_in=self.n_in, n_out=self.n_out) - clf.load_state_dict(self.params) + clf.load_state_dict(self.params) - n_batch = pyt.arange(0, len(X_not_sparse), 16) + n_batch = pyt.arange(0, len(X_not_sparse), 16) - X_tensor = pyt.tensor(X_not_sparse[:, self.features].astype(np.float32)) + X_tensor = pyt.tensor(X_not_sparse[:, self.features].astype(np.float32)) - predictions = [] - for start in n_batch: - p = clf(X_tensor[start : start + 16]).detach().cpu().numpy() - predictions.extend(p) + predictions = [] + for start in n_batch: + p = clf(X_tensor[start : start + 16]).detach().cpu().numpy() + predictions.extend(p) - predictions = np.asarray(predictions) + predictions = np.asarray(predictions) - del clf - - else: - predictions = self.clf.predict_proba(X_not_sparse[:, self.features]) + del clf return predictions diff --git a/LANDMark/tree.py b/LANDMark/tree.py index d2e7c14..adbc652 100644 --- a/LANDMark/tree.py +++ b/LANDMark/tree.py @@ -127,7 +127,6 @@ def get_split( use_etc, etc_max_depth, etc_max_trees, - use_etc_split, N, current_depth, use_oracle, @@ -218,7 +217,6 @@ def get_split( use_etc=use_etc, etc_max_depth=etc_max_depth, etc_max_trees=etc_max_trees, - use_etc_split=use_etc_split, N=X.shape[0], current_depth=current_depth + 1, use_oracle=False, @@ -243,7 +241,6 @@ def get_split( use_etc=use_etc, etc_max_depth=etc_max_depth, etc_max_trees=etc_max_trees, - use_etc_split=use_etc_split, N=X.shape[0], current_depth=current_depth + 1, use_oracle=False, @@ -263,25 +260,21 @@ def get_split( model_type="lr_l2", n_feat=max_features, minority=minority_sz_lm, - use_etc_split=use_etc_split, ), LMClassifier( model_type="sgd_l2", n_feat=max_features, minority=minority_sz_lm, - use_etc_split=use_etc_split, ), LMClassifier( model_type="ridge", n_feat=max_features, minority=minority_sz_lm, - use_etc_split=use_etc_split, ), LMClassifier( model_type="lsvc", n_feat=max_features, minority=minority_sz_lm, - use_etc_split=use_etc_split, ), ]: model, D = clf.fit(X, y) @@ -313,13 +306,11 @@ def get_split( model_type="lr_l1", n_feat=max_features, minority=minority_sz_lm, - use_etc_split=use_etc_split, ), LMClassifier( model_type="sgd_l1", n_feat=max_features, minority=minority_sz_lm, - use_etc_split=use_etc_split, ), ]: model, D = clf.fit(X, y) @@ -351,7 +342,6 @@ def get_split( ANNClassifier( n_feat=max_features, minority=minority_sz_nnet, - use_etc_split=use_etc_split, ) ]: model, D = clf.fit(X, y) @@ -465,7 +455,6 @@ def get_split( use_etc=use_etc, etc_max_depth=etc_max_depth, etc_max_trees=etc_max_trees, - use_etc_split=use_etc_split, N=X.shape[0], current_depth=current_depth + 1, use_oracle=use_oracle, @@ -490,7 +479,6 @@ def get_split( use_etc=use_etc, etc_max_depth=etc_max_depth, etc_max_trees=etc_max_trees, - use_etc_split=use_etc_split, N=X.shape[0], current_depth=current_depth + 1, use_oracle=use_oracle, @@ -548,7 +536,6 @@ def __init__( self.use_etc = use_etc self.etc_max_depth = etc_max_depth self.etc_max_trees = etc_max_trees - self.use_etc_split = use_etc_split self.resampler = resampler self.use_cascade = use_cascade @@ -587,7 +574,6 @@ def fit(self, X, y): use_etc=self.use_etc, etc_max_depth=self.etc_max_depth, etc_max_trees=self.etc_max_trees, - use_etc_split=self.use_etc_split, N=X.shape[0], current_depth=1, use_oracle=self.use_oracle, diff --git a/tests/test_landmark.py b/tests/test_landmark.py index 805a098..4d9ad36 100644 --- a/tests/test_landmark.py +++ b/tests/test_landmark.py @@ -84,11 +84,6 @@ def test_models(): BAcc = balanced_accuracy_score(y_test, p) assert BAcc > 0.7 - # Tests the ANN for min samples - clf, _ = ANNClassifier().fit(X_train[0:4], y_train[0:4]) - p = clf.predict(X_test) - D = clf.decision_function(X_test) - clf, _ = ETClassifier().fit(X_train, y_train) p = clf.predict(X_test) BAcc = balanced_accuracy_score(y_test, p) @@ -105,11 +100,6 @@ def test_models(): assert BAcc > 0.7 D = clf.decision_function(X_test) - # Tests the ETC model for min samples - clf, _ = LMClassifier(model_type="lr_l2").fit(X_train[0:4], y_train[0:4]) - p = clf.predict(X_test) - D = clf.decision_function(X_test) - clf, _ = LMClassifier(model_type="sgd_l2").fit(X_train, y_train) p = clf.predict(X_test) BAcc = balanced_accuracy_score(y_test, p) From f7ce93a14c0512194a6f00b0b0770bc738ad843b Mon Sep 17 00:00:00 2001 From: jrudar Date: Tue, 11 Jul 2023 20:57:52 -0400 Subject: [PATCH 12/14] Typo fix --- LANDMark/tree.py | 1 - 1 file changed, 1 deletion(-) diff --git a/LANDMark/tree.py b/LANDMark/tree.py index adbc652..8f0208e 100644 --- a/LANDMark/tree.py +++ b/LANDMark/tree.py @@ -516,7 +516,6 @@ def __init__( use_etc, etc_max_depth, etc_max_trees, - use_etc_split, resampler, use_cascade, ): From d91e05701f64364f40027aa3fd689128f9acc053 Mon Sep 17 00:00:00 2001 From: jrudar Date: Tue, 11 Jul 2023 21:05:23 -0400 Subject: [PATCH 13/14] - Removed unused imports --- LANDMark/lm_linear_clfs.py | 1 - LANDMark/lm_nnet_clfs.py | 1 - 2 files changed, 2 deletions(-) diff --git a/LANDMark/lm_linear_clfs.py b/LANDMark/lm_linear_clfs.py index d0a1078..23566e6 100644 --- a/LANDMark/lm_linear_clfs.py +++ b/LANDMark/lm_linear_clfs.py @@ -12,7 +12,6 @@ SGDClassifier, ) from sklearn.svm import LinearSVC -from sklearn.ensemble import ExtraTreesClassifier from sklearn.model_selection import GridSearchCV from sklearn.utils import resample from sklearn.model_selection import StratifiedKFold diff --git a/LANDMark/lm_nnet_clfs.py b/LANDMark/lm_nnet_clfs.py index 777d3bb..bbd74ba 100644 --- a/LANDMark/lm_nnet_clfs.py +++ b/LANDMark/lm_nnet_clfs.py @@ -1,7 +1,6 @@ from sklearn.utils import resample from sklearn.base import ClassifierMixin, BaseEstimator from sklearn.preprocessing import LabelEncoder -from sklearn.ensemble import ExtraTreesClassifier from math import ceil From f00efbb0b81c536f7764128031c7a7081a994d3d Mon Sep 17 00:00:00 2001 From: jrudar Date: Tue, 11 Jul 2023 21:26:47 -0400 Subject: [PATCH 14/14] - Updated ParameterChoice notebook to reflect changes --- notebooks/ParameterChoices.ipynb | 85 +++++++++++++------------------- 1 file changed, 34 insertions(+), 51 deletions(-) diff --git a/notebooks/ParameterChoices.ipynb b/notebooks/ParameterChoices.ipynb index 45a551a..9673a5c 100644 --- a/notebooks/ParameterChoices.ipynb +++ b/notebooks/ParameterChoices.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 1, "id": "e4edf795", "metadata": {}, "outputs": [], @@ -39,7 +39,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 2, "id": "601edf31", "metadata": {}, "outputs": [], @@ -57,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 3, "id": "c070bdd6", "metadata": {}, "outputs": [ @@ -100,7 +100,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 4, "id": "9870b968", "metadata": {}, "outputs": [ @@ -115,13 +115,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_31764\\2125759794.py:14: 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", + "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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", + "image/png": "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", "text/plain": [ "
" ] @@ -163,7 +163,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 5, "id": "3c0ef663", "metadata": {}, "outputs": [ @@ -171,20 +171,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.95\n" + "0.9\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_31764\\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", + "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": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGdCAYAAAAvwBgXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB+5ElEQVR4nO3dd3iUVdrH8e/zTMtMeiGE0HsXEAHFBlaw967Yd131XXWLdW27Lruru+uuvWPDXteuKGDDAoLSe4cQSJ1enuf9Y5iQMjOZJFOT+3NduZSph0nI/Oac+9xH0XVdRwghhBAiBdRUD0AIIYQQXZcEESGEEEKkjAQRIYQQQqSMBBEhhBBCpIwEESGEEEKkjAQRIYQQQqSMBBEhhBBCpIwEESGEEEKkjDHVA4hG0zS2b99Obm4uiqKkejhCCCGEiIGu69TX11NeXo6qRp/zSOsgsn37dnr37p3qYQghhBCiHbZs2UKvXr2i3iatg0hubi4AU4ouwKiaUzwaIYRID/7+PVI9hKSo72dN9RA6zNGja1ZABDxu1jx2d8P7eDRpHURCyzFG1SxBRAghQoxZqR5BwtX3t6b3G1SMDJauGURCYimr6NqvkBBCiLRT3z/zZ0IA7D3lLTYW8ioJIYQQcSYhJHadYeZLCCGESAsSQNpOXjEhhBAiDiSEtI+8akIIIYRIGQkiQgghhEgZCSJCCCGESBkJIkIIIYRIGdk1I4QQIm1kYg8RKVLtGHn1hBBCpAUJIV2TzIgIIYRIqUwMICAhJF7kVRRCCJEyEkKEvJJCCCGESBkJIkIIIYRIGQkiQgghhEgZCSJCCCFEG0h9SHzJqymEEELESEJI/Mn2XSGEEKIVEkASR15ZIYQQIgoJIYklr64QQoiUyNQeIiK+JIgIIYRIOgkhIkSCiBBCiKSSECIak2JVIYQQSZGJAUTqQxJPXmEhhBAiDAkhySGvshBCCNGMhJDkkaUZIYQQYi8JIMknr7gQQgghUkaCiBBCiITLxEJVkRyyNCOEECJhJICI1siMiBBCiISQECJiIUFECCFE3GViCJFC1dSQpRkhhBBdmgSQ1JJXXwghRJclIST15DsghBCiS5IQkh5kaUYIIUSXIgEkvch3QwghRJchISQ5XD21mG8r3xEhhBBdgoSQ5HD2ij2EgCzNCCGE6AIkhCReWwNISEK/MzNnzmTChAnk5uZSWlrKKaecwqpVqxL5lEIIIVIsE3uIiI5pbwiBBAeRefPmcfXVV7NgwQI+/fRTfD4fxxxzDA6HI5FPK4QQIgXq+1slhHRBHQkhkOClmY8++qjJn2fNmkVpaSkLFy7ksMMOS+RTCyGESCIJIF1PRwNISFIXzWprawEoKipK5tMKIYRIoHQPIVIfEn/xCiGQxGJVTdO47rrrOPjggxk1alTY23g8HjweT8Of6+rqkjU8IYQQnZCEkPiLZwiBJAaRq6++mqVLl/LVV19FvM3MmTO56667kjUkIYQQnZQEkPiLdwAJScp36pprruG9997jiy++oFevXhFvd/PNN1NbW9vwtWXLlmQMTwghRCciIST+EhVCIMEzIrquc+211/LWW28xd+5c+vfvH/X2FosFi8WSyCEJIYQQog0SGUIgwUHk6quvZvbs2bzzzjvk5uayc+dOAPLz87Fa07u4SQghhOjKEh1AQhI6f/XII49QW1vLlClT6NGjR8PXK6+8ksinFUIIIUQHJCuEQBKWZoQQQgiROZIZQkDOmhFCCNEB6dRDRIpUOybZASREvmtCCCHaRUJI55GqEAIyIyKEEKKN0imAgISQjkhlAAmR754QQoiYSQjpPNIhhIAEESGEEKLLSZcQArI0I4QQQnQZ6RRAQmRGRAghhOgC0jGEgAQRIYQQGUrqQ2KXriEEZGlGCCFEBpIQEpt0DiAhEkSEEEJkDAkgscuEEAKyNCOEECJDSAiJXaaEEJAZESGEEDFKtx4ioqVMCiAhEi+FEEK0SkJI+svEEAISRIQQQrRCQkj6y9QQArI0I4QQIgIJIOkvkwNIiAQRIYQQaU2KVMPrDCEEJIgIIYRIYxJCMi9wGMudBJzu2G+fwLEIIYQQ7SIBJPMCCARDSFvJd1oIIYRIM10lhIDMiAghhBBpJdNCSHsDSMP94zQOIYQQQnRApgUQ6HgIAVmaEUIIIVKuq4YQkBkRIYQQaaarFapmWgiJVwBpeLy4PpoQQqSIK2Bnk/MXKj2r8Wpesg159LCOpJd1GAZFftW1RaoamUkASS/xDhwRnycpzyKEEAlU59vNopp3ydJ9XI5OX+DrQDVv279il3sN4wpPwKiYUj3MjCAhJDkkhDR6rqQ9kxBCJICu6/xS+zFDdR+fo1O09/LrgQXAEf5drLH/wPDcySkcZWaQEJIc6RxCkhlAQrrWd18I0ens8W6lXqvn4UYhJORA4Lfo7HAvJ6D7UjG8jCHnyiSes5cmISTc86bkWYUQIk5q/bsoROEg9LDXnwz8Tffj8NeSZypJ7uCE2CudAkiqAkckEkSEEBlNQcUHBAj/Cy30K1dRZAJYpEa6hJB0CyAh8i9TCJHRSsy9saPzboTrnwOyVRs5hoIkjkrEqjPXh6TTUky6hhCQICKEyHB5phK6mXpwJQrfNbo8ADwMPAv0to3tNDMi/oE9Uz2EuOnsISRdpHMIAVmaEUJ0AqPzj2FR9XscGNjDRBT6o/M1ClvR6ZM1kr7W0akeYlxICMkM6RJC0j2AhEgQEUJkPLNqZWLRaezybGSTey3rdTdZhgIOsg4n31Sa6uF1mASQzJAuAQQyJ4SABBEhRCehKgbKsgZSljUw1UOJKwkhmUFCSPtJEBFCiC4uGT1EJITEV6aFjWgkiAghRBeW6BAiAST+OlMIAdk1I4QQXZaEkPaTEBI/MiMihBDR6DooStuvE52SBJD467xxVQghOkjVNf5YN4fjnctaXJel+bin5j0mejalYGQiFSSEJIbMiAghRASHedYx1bOWqZ61ALxvGwkEQ8jdtR8w2reD/nVVXFJyHh7FlMqhigSTgtTEkSAihBARzLUMYqBtN2c4l3CN/UsA5mQNaQghdsXMnQXTJIR0YjILkngSRIQQIhJF4ansAwEawkgokNgVM7cWHM9qU/dUjjAtdZYiVQkhySFBRAghotkbRqy6j+NdyxsulhASnoSQtutqwaM5CSJCiFb5NA+bXcvY5V6FR3ORpWZTZh1OL+twjF1gWSJL99PHX93kssG+3RJEmukMISRZAaSrh4/GJIgIIaJyB+z8WP02Ps3BWegMB34KeHnT/g07XSvZv/AkzGpWqoeZMI0LUx2KmXXGYvbz7WhYogkVsHZ1EkJiIwGkJQkiQoioltV9Tr7m4Et0+je6/Bfg8EA1K+u/Yr/8o1I1vIRqHEIaakKMpVzmWNCkgDVRYSSR58wko617Jkl0CJEAElnmR1ghRMLY/dVU+rZzX7MQAjAauB2dnZ51eAKd85fs/t4tTUOIqXtDzcjrtjEAnOn8CYvui/tzd6bD7tKZs5cmISTFZEZECBFRja8CgFMiXH8acD06tf5KSg19kzWspPkmawD364ezwVjUtB5kbxipU7L4MmtgXLfvSgBJHlmKSQ8SRIQQESkE25d7gXBVIJ6G23XeydWPrcPDX6EovJY9Lq7PlawQEu9lmUysD5FZkPQhQUSIDOAM1LHFtZx6XwWgUGzpQ8+sYQkvEi0y90QBXgSuCnP9i4AJAwWm0oSOoyvI1JmQTAshEkDSjwQRIdLcVtdKltXPIw+Yho4D+Ni3nY2ORYwrOJ6CBG4htRpy6GEZyI2e9YxE57C9l+vA/4CZQI+s4ezxbmOHexU+zYFJzaGndRjdzH1QlMx6k0qVTAwhmRZAIDEhRIJHx0kQESKN1fgqWFY/l8uA/wC2vZdXAKfqPhbVvM8hxedjUi0JG8OI3MP5KWDncH8FE1AYgc5CFJai083UC0dgN5vrljIBhdHo/MQeFnk30s3Uk7EF0zEo8msmncRjWUZCiASQeJLfEEKksU3OJQxA4VF0DI0u7w68iU5v3cs29yr62fZL2BiMqpnxhSdT6d3EZtcq1mkOzIZcxmcNY4d7NbWedXwBTEHfew+dj4FTfNtZWf8NI/MOi/LooslsiK6DooS/YbTrREQSQNJf5sVaIbqQKu8WLmoWQkLKgKOAPZ7NCR+Hqqh0t/RnXME0Jhadztj8Y8g1FrPTs4570JnS7PbHEtzau8O9Eq/mTvj4MlXjEDLQsZ1/LnuaAp+9xe0mVq/mLytfwBLwJnN4GU9CSGaQICJEGtN1PexulRAboDfMRCRXtW8HGjrnR7j+fMCPRo1vZzKHlZEUXePGNW+wX/1G/rHsmSZhZGL1au5YNZtJNas5fcc3KRxlZolnCDGWOyWEJJAEESHSWL6plDcIPx1fD3yMQn6KzjvRCf6iN0e43txwu9QEpXTXeDZEV1TuGnouu0259HftaggjoRBi1gPMLxrBK+WHpnDEmSHeDcokgCSeBBEh0lhv2358j85/m13uB34DuIBe1hHJHxhQYAwGoLciXP8moKKQb+yWtDFlsm3WEn4/8tKGMPLaj3/nnpXPN4SQvw4+i4AabpEueew91bQuVJWlmMyUvj9RQgi6mfvSzzaG3wLjUbgHuBUYgMJsFEblHYHVkJOSsdmM+XQ39+aPKKxudt0y4E8odLf0IytF48tEoTDS2M+5/eIWQjqyYyadAwjEJ4SElmBkKaZjhpdVMLR7Zcy3l10zQqQxRVEYmn0gRaZytjh/4S/+ClRUCsx9OdC2H3mmkpSOb0TuVBbWvM2oQB2nAyOBJQRnSXIMBQzPPTyl48tEPd1VTf5c4LOTG3BRo7Y/0HV0y246h5COBhAJHPE1vKyizfeRICJEnGm6RqV3ExXu9QTwk20opJd1GDZDXrseT1EUSi19KbWk31kuFoONiYVnsMW9gg9dK3hHc5KjWhlsHUmvrOEY1X1nsORrLlRdp9pgi/KIXVuoJgRgna07RV47fdy7+ceyZ/jjyEuoMbU9jMgsSHgSQOKrPQEkRIKIEHHkDjhYXPMeNYFq9kOhDJ1v2cgG5yKG5kxOaL+PVDGqZvrbxjDMOoI7az6iT6CKm8y92dIshPyt+l1U4KaCEyWMhNG8MPWvg8+izFPNfcuebihgbW8Y6YzaG0IkgHRMRwJHJOkdd4XIILqus6T2Q7ICNSwAluxt7LUDneuBlfZvqPBsSPEoE8ekB8jV3RRpLv5W8y69/dXAvhDSL1CNTfeQpftSPNL0o+gaF235vEVhavMC1qMql6R6qCnX1l0xUvcRH8PLKhISQkCCiBBxU+XbRrV/Ny+iM6nR5dnAfcBhKGxyLErR6BLPrmZxc8GJrDMWN4SR0d7tDSFkt2rjxoKT2GHMT/VQ046uqNw6/EJeKT+kRWFqMIxcxjO9j+T1HpNTOMrUa08AER2XqAASIkszQsTJLs9meqEwNUzfDAW4HJ2L/JV4NXfCT81Nlfq9YWRmzf8Y6N/DP2reBWgIIduNBakdYBqrNWXzZN9jw163zVrM7F5TkjqedKsPaWsIEW2X6MARiQQRIRoJ6H52eTbiDNRiVCx0t/Qny5Ad0311AuSioERo4FWw97+aHojPYNNUvZrF3/OO4vGqVxouezD3MAkhSdbeItVMDiAgIaQ9UhVAQiSICLHXTvc6VtbPw617KUShHp1V9q/pbR3F0JyDUFs50j7XWMJyNDYC/cJc/x5gU6xY1I6ffprO8jUXt9R+0uSy/6ufx02GfLYYC1M0qq6lK4YQCSDtk+oQAlIjIgQAuz1bWFL3KcfrXlYBVehUAvegs8X1C6vsrZ/x0SNrEGbFxNWAp9l184FZKJTbRqK0EmgyWePC1N2qjesLT21SMxIqYBWJIyFExCodQgjIjIgQAKx3fM9k4BVoOOm2ALiJYH3HLa5l9LeNi7pMY1RMjMo7mo9rP2IYOpejUwZ8CrwOFJrK6G8bm8i/RkrlNQshoZqQxjUjf6t5lz8WnMw2WaaJu87SL0SWYuIrXcJGNBJERJfnDNRR5a/kOvaFkMZ+TfBI+52e9fSzjY76WN0sfZhUeBobnYu507MBPwHy1DwG20bRxzoSVWlbm25XwL63XsVMnrEERQl/AF48+DUvXt2NWcnCqEY6yi4yl2JityGHHN3TpDC1cQGrquvYVUucRy66YgiRANK6RISQI0pWxnQ7d5afD2N8TAkiosvzacGFlH4Rrs8HClDxae6YHi/HWEg3Sz+yDHkYFCNllgFkt3EGwOGvYZX9ayq9WxpKX3PVXPrnTKA8a0jMj6PqGlqEpaDQdXZ/Desc31Ph2YCGjopCqaU/g7InkNOGmg6fYuTu/GMp1JzsatZFNhRGVHRqO3mNjGifSCFEAkf7pDKEtFVCo/D8+fM58cQTKS8vR1EU3n777UQ+nRDtYjXkoKKwIML1G4BKtJhatO/ybGL+7udYUvcZDuditjl+4Muql/m59lMCMTbycvpr+aH6TbK9W3kSWA18Dhyp1fNz3edsci6N6XFyNA/3Vb/DYe61La4rDdTxYNXrdHOt5IfqNzB7NnAfOp8C/0Iny7OB76veoM63O6bnCvEpxhYhJKRezYo5hHg0F+sci1hY8wGLaj5ko/PnhsAomsr02ZBoDcokhLRdIhqPHVGyMmEhBBI8I+JwOBgzZgyXXnopp512WiKfSoh2M6tWSs39+Id3I+eg0/gYOQ24DTApJsqyBkR9nGrfThbXfsQ0dP4JDEPDDbwIXONZzy+1AcYWTGt1PGsc31Gi+/gBneK9lw0GpgDXAE/Yv6U8azCmVpY4jnctY7i/giF1uwCYnzUICIaQf1S/S3fNzs/1XzIIja/RCbUZOwq4FJ1DCbCi/gsmFZ3Z6pjjaZdnEz/XfoKBAEcAfuBz7yY2OH5gbP5xFJp7JHU8nVW6hJBwJIA0lco6j0QGkJCEBpHp06czffr0RD6FEHExJOdAfqjeznjdy43oHAxsAv4DfAGMzj0Ug2KK+hgbHAsZDrwNhG6ZBVwGZKFzgXcjdb7dUU/M9WkeKjwb+GejEBKiAH8CHiPAGvsPjMg7JOp4XrWNozxQyzHuVfyxbg4AK02lDSHkUzWHJZqdt4HmvU5zgb+gc6J/D7W+SvJN3aI+V7zY/TUsqf2Y49F4Bijae/kO4Czdx/e1H3Bw8blYVDmrJtNJCIlNImY30k1a1Yh4PB48nn3Tr3V1dSkcjehKbMZ8JhSexir7N1zj3dRQl1FgKGJczkRKLf2i3t+vean0buFu9oWQxs4GfovCTs+6qEHEoznQ0JkQ4foyoAew2b0UqzEn6i4cXVG4P3cKAMe4V3Fz3WcN12015HOXdT+wf8mUCPcPXe4I1CQtiGx2/UIhOq8QDHEhPQgGvJ66n62uFQzMHp+U8XRWqZwNiVaQKiFkn0yq8eiotAoiM2fO5K677kr1MEQXZTPmM65gOh7NiStQj0mxYDPkx7RTxa970YHeEa43Aj1QqNWj1zmYlODb71rg4DDX1wNVwFTgC/sCik29ogabUBgpDdgZ69vWcPmNBSfh9gfrP3bQckYkdDkEtyUnS7VnI5eiE64BfjFwEjqfezZJENmrPfUhqQohEkBi15VCCKRZELn55pu54YYbGv5cV1dH796RfrULkRgW1dbmqX+zasWMka/xc1yY63cDq9EYYIh+4JvFYKPEVM5/fDs4D73F7MpjgBt4CjgIhS2u5Yw0HRb1Mbtp9ZQHaptcNsq3g0pLPyyKiYd1H/8Nc7+HAbNiotjcM+rjx5Oma0Q75D6XYCt90bEi1WRqbUtuVw0hXS1sRJP6aqVGLBYLeXl5Tb5E56frOjW+Cra711Dp2ZyRZ7GoioEy6zAeQmF9s+t04E4ggBrT1tuB2RNYAhwPhM7q3Q38mWCDtauB/sAJ6Dh80X+ZhQpTSzU72w15/GAOBvs/1s1hqmcjfW3788Dexw4thNYDfwXuB/raxrZaGxNPOaZS3o5wWo8PeA+FbFP3pI0nXbV3JiTZsyESQsKTENJUWs2IiK6n2ruDlfXzqA3UNFxmVSz0z55AH9uo1A2sHQZlj+cHzyYmaHZuQOcoYCfwCPAxMCJnMuYYtq8WmnswLv845tZ+wHh0sgEXwdqT64G/7b1dLaBEaZDWeHfMVkM+NxacRLVq47r6uQ0FrHruETxlG8edzsXMBHqjsAUdNzr9bWMZYNu/Iy9Jm/W2jeZH7yb+Bfyu0eU6cAuwC52DrSOTOqZ0kknt2xuHkK4aOMKRENJSQoOI3W5n7dp9PQw2bNjA4sWLKSoqok+fPol8apEBanwVLKz5HwegcRcwmWDPjvt1D0/bvyJAgP62MSkeZezMqpUDik5jtX0Bd7rXcBvBX8QFhkLGZh9AWdbAmB+rm6U3ZVkjqHYv409ACXDS3v9CcIbkfyj0iVJEe6BnU5MQUrW3PX3jAtbj3Sv4quBE+lhHst29Bo/moLeaTY+swVgN0RZJEqPE3IsBtnH83vkTr6FwFjp+4AUUfkFnWM5kco3N9xOJaFI5C9IVA0gyt9pmegAJUXRdD39meRzMnTuXqVOntrh8xowZzJo1q9X719XVkZ+fz1Ell7ar5bRIbz9Wv0NP304WhClOvA54GAOHlVzUar+MdOTXvLi0egyKCaua267W7A5/Dd9WvcoxaMwCQvtWtgJnobBIMTK5+Lyop/ke71zGt5Z+DSEkRNF1TnMu4QPrCFxp+G9rl2cjW5w/U+3biYJCkbknfWxjklqvkmj+gW37u2TCbEhXDCFdYXtte7jtfm6aMI/a2tpWyywSOiMyZcoUEphzRAZzBerZ7dvB/RB2h8SNwAMEqPCsp5d1eHIHFwdG1Uyu2rFP7tnGAsbkT+PT2k/oiZ/DCTb3mg+YFTPjCo6LGkIA3reFX8bQFYU3sse2bUC6jrL3vs0puh728vYqtfRrdcu0SC9dLYTIEkv8SI2ISAmPFvxFFakKpAdQgNJwu66qm6UPh5ZcwDb3Kn727kBRFIaZelKeNSS5s4S6zsWO7ynUnNyfO6VJ6FB1jT/WzWGjsYiXZVttQqTzDpmuFkBAZkHiTYKISInQ9tilQLgqkO1ADTrl0kETs5pFf9uYlNbL9Pfv4QznYgx797OEwkgohBzuWcdkzwbmWwY2nLorUi9RyzLhdsN0xhCSjHqPrh5CQIKISBGrIZcSUw/u9e3k9DA1Iv8ADBjobol+votIjg2mEu7NO5I/1M3hGPcqAB7IPYzf133OIZ51zELhTkMuO6tex6AYKckaSF/r6DafOiziJ94hpCs1JJNll+SSICJSZlDOgfxY/Q5T0bkLOAjYSLB/xdPA0JyJGVmo2lnN23toXiiMHONehR84C3gTnSMDdfwGnV26n2ddy1ngWsm4guMpMpendNxdUTxDSFcKICDLLu1xXM7yFpfZdY2bYry/BBGRMgWm7owvOJEV9fM4tlkfkREZ2EekK5iXNQgVjT/WfQ7AA8A7BM+BOblRG7K70DkBjQW1H3NoyYUYFPlV015tqQ+RWZD2k1mQtgsXQNpDfjuIlCo09+DAorOp9e/CFajHqFgoNpejRmnU1Rm5AnZqfbtQFIVCUw/Mari9RKmn6hqTPJuAYJOxB4FzgJOb3S4beBKdwbqHHe619LIOS+5AO4lUFal2lgAi4SJx4hVCQIKISAOKolBg6k5BF2zd7dVcLK+bT4V3Q8N8ggGV8qyhDMs9OK1mEhoXpvpQmWPqwXrfNv4R4fYDgf0An2czSBBpk3QMINC1Q0hnCyDxDBIdlT6/5YToYvyal4XV72AM1PIwcBrgAV5A4y73StyBOvYvOB5FSf2RUM1DyD35x/CVqQfsfgZXlPs5UPAaEvemqus6Nf4KHP4ajIqJEnNvUBTqfbvR0ck1FmdcnVG6hZBMCh8hEkIiS6cAEiJBRIgU2eJegSNQwxJgRKPLbwbGoTPdt41K7xZKLX1TNMJ9egVqmOjd1BBCvrP0wwQUGkt4zr+bC8Lc53tgLTr7mxNzgnaNr4IVdV80OadIRcGAgm9ve30TBnpYhzEk50CMSTy8r73SKYRIAOlcAQTSM4SABBEhEsKruaj27QQg31hKVrMW6wAVrpWcRtMQEjINGIvCNteKtAgim41F/Cn/eHJ0D9816njaxzaWT+s+426CASr0Vr8aOBeFPEMu3czxP1eq3r+HhdXvMgaNmcChBOtUPkfnBnTOJfjL7Q0C/N21HIdvN+MLT0rr2qOOhpD2FKpmagCRwNF26RpCQIKIEHHl132srP+aHe7VBPZ+KldR6G7pz/Dcw5oUoXo0R9hmbiFj0dmsORI84tgtM/docVmPrEE4/DXc4fyRR4EpwC7gcyBbzWb//MQsLa2z/0AfNObuPZ34fYInHL9D8HDAkJHAUegc4q9gu3tNpyyabe9OmUztiCohJCidg0VbpX7xWYhOQtM1Ftd8wB73KmaisQXYATyAjtuzgUXV7+LXfQ23N6s2lkZ5vF9QMKktZ1LSiq7zZwIsAU4FNmDEAjwBPGHui80Q/bCr9vBpHnZ5N3Hd3hAC8BQwnqYhJGQycCyww5W+v7iTeaCds5eWkSFkeFmFhJC9OlMIAZkRESJudnk2stu3gznAEY0u/w1wCDrjAlVsd61q6I9SljWM1x0LuBMY0uyx5gAL0RlnHZqMobePrjPD8T3nOH8CYFTOway3jeZo1wouq58H7mVkKSqP5UyGOB6I59M9aOg0PgpxEzAxyn0mAl8G6uM2hvZo62m7rYnHUkwmhZD2yNSgEU1nCyEgQUSIVnk1N7W+XYBOvqkUc4QTb3e4VzIRhSNoeeL0fgQ/rc9zr2gIIr2sw9nhXs6hgXr+ht6wa+ZF4DYUSkxllJpTXx8SSXmgltOcPwPwSM7BvGsbDcDHe09Lvq5+Hie4lvGxdRgbjR07ibgxs5KFisISdI7ce1kJsDbKfdYAphT0ZoklfCSjQDVTakHiNeMhASSzSBARIgK/5mOV/Wu2N6r3MKDSI2sIw3IOxqg23YXhDdgZFyaEhIwBPgnsq/kwqRbGF5zC8vovuNS7hUv3Xm5AocwymOF5h6bF1t1IthsLuCt/Gj0DtfyvWRfcUBipU7PiGkIAjKqZMstA/u1ZxyXoFALnARcDi4GxzW6/EXgD6J+V3NmleM+AtFUmNSWLRwBJ9/DRmYNER0kQEV2e01/Lds8aPJqTLDWb8qwhWFQbP9W8j8tfwV/QORtQgFfRuNu9ikX+Kg4oPLnJLgyTIZtfAtUQIYwsY9+pwyEWg41xBcfj9NdS49+FgkKRqRyLITNOHV5k6c0iwm/PDYWRRBiYPYHvvZs5SPdxFzpTgWHA0cB/gDMIFsC9B/wWBbOaTa8Ejqe5WENIvGtDWmtIBp0rhDQPH7qus+iDCuY/v4Wty+sxGBVGTilh6iV96TM6/vVKsZIQEp2i63rkj3ApVldXR35+PkeVXIpRNad6OKKT0XWNFfVfs9m9jFwU+qKwAR0nOiXmvlR6NzGf4NbQxr4BDgZG5x5BT+u+6o4d7rUsqfuML4FDmt1nBTAaGJxzMP32LmGIjrH7q1hZN5/d/p0Nl5lQ8KFjJBgcfUCxsTuj8o/CashN+JjaOgvSniDSkRACiQ8iiWir3likmQ9d13n5Tyv47o0dKCroe18O1aCg6zoX/GMk448vS+jYmuvKAcRer7H/iApqa2vJy4seAmVGRGScen8Vuzwb0fQAucYiSi392tUfYo3jR7a6l/Ev4NfoWNGxE/xEfZt3EwNoGUIguAvjCBR+di9vEkS6W/pTbOzOdP8u/orOeYR6WcBNKOQY8umV5OWBzizHWMQBRadg91fjCNRgVMwUmspwBuqo8m5DBwpNZeSZSlI91LhpTwhJ5gxIKs92WfheBd+9sQPYF0IAtEDws/aLNy1n0IRC8kuT02m3K4eQtpIgIjKGX/OytG4OO72byEEhG4V1aNiULEbmH02xOfZPo37NyxbnEm4Erm90eQ5wK7AdeBZwA+FKHPdH58eAvcllqmJgXMHxLK+fz3Wedfzf3iUaBSg192b/vKkNM3u6ruPRnGgEyFKz07rRVrrLMRaSYyyM+OdkSXRNSLgQki4BBFLf32P+81uazIQ0p2s63762jWlXD2jXeCRYJI4EEZERdF1nSe1HuH07eAE4Ex0zOkuB3+oe5te8z8TC02L+9LvbuwUfAX4d4fpfAw8DXxKsO2huOWBSW9ZxGFUz++UfxZDAQVT7dqCjU2Dq3qSfxg73WtY5FmEPVAXvo1joYx3BwOz9MWRAG3LRUntCSKzLMm2dBelqASRk67K6iCEEggFl8y917XpsCSGJJUFEZIRq304qfdt5Fzix0eWjgPfRGQFscP7EmPxwsaGlgO4HINKKcejyX2gZRH4BPgKGR+nSmWXIpodhUIvLNzgWs8qxoMllft3DeudiqrzbmVB4YlqduCtiY1y3rU1hpNRTw01fvsbMSWdiNzcNJEOrtnL2yi/566Qz8Rta/iykahYkWuDQNR1Fja1XTKJ2t6hGFc0b+bVRFDCa274LTUJI4slvPJERdnrW0geF48PsSMkiWONxs2c9mh6IaZkj21gABFuRTwtz/ed7/3s3kA+Nds3AH1DIMxRQnjW4TX8HZ6CuRQjZJ3iK7GbXUvrbxrbpcUVs/JoXn+7BrGaldOapvl8W93/8KiOrttDDUcX/HfEr7GYr9p4qI3Zu4b9fPEa+x8WWskIeOPS4JvdNpxDirXez/pUlbHp3GZ5qF0abid7ThzHw3HHYuucmfTvt8EOLWTZ3d0NNSHO6Dmcd7ZVgkYbSt0mBEI34NC+9iPwD2wfQ0NH0QEyPl28spcBQxC0oNO+3WQXcjkKRsRSruS9XALkE60cuA4zm3uxfeFKb38y2ulYQjDORbXJGa/oeH7quU+vbxS7PRmp8FaTxxrm4qPdXsbjmY+bsfoZ5e17k88pn+KX2c5yB9k3TR2Jct631sfS3gqIwc9KZVFuyGVG1lf9+/hhKsYcRO7fwxKuPku9x8VN5P56adEST+0ZqShb6SoRIbdU91U7mX/Eaa55fiKfaBYDf6WPj20v55rLZDK/+MSHjiWbqpX3QtfA/ywYDFJeonHBy8pvaidbJjIjICNnGfJZ4wE4wEDT3FWBVYv+kqygKI/KO4MfqtxlNgP/b2zL8Z+C/KFQpJg7Im0qOsRBnoI5qb7Deo8jUA5sxv11/B0eghkg9RkLcmh1N11AjNDLT9ADb3KvZ4lqGI1CLSTFTnjWEPtZRYU/4ba7Ss4UV9q9wBmobLrMZ8hiWc3BanPIbbzW+ChZWv0tvNP6NzjDgJzT+61nD995NTCg8tWF2LB6iLdE0rgnZZSvg2qlX8sAXjzOiaitfPXgbhr2B8OeyPvzqzCtxmve9aaaiNXu0pZhf7v8S1876Fm/8ekDHbffz3O+X8se3J6HEsbV/awbsX8C5fx3BS7cuRwE0Lbgco+tQUKgya3YRNpt89k5HEkRERuiZNZR1jh+5B5jZ7LrlwNMo9LCOaNMvvjxTCROLTmed40f+4FmPho4BlTLLICbmHNBQYGoz5GGzdrwZkkExoaCgRwkjKgaUCLMmAd3PwpoPqPJtb3SZj/XOxWxxLWdi4UlYh+4X8bF3V69h8coPaB6GnIE6FtV+yP750yi19GvT36mjdF2j0ruFHe7V+DQnZjWHntZhFJnKO/wmpus6K+q+YCwaXzQ6IO9Y4HJ0DtS9rKyfz/jCcEfltV2sNSLdnDU8/NkjLCgfxrVTr+SFj/7dEEK25BfTu2Y3p/38HS8ccDiQfiHEXeVkx9x1EWcftADsWO1g4+I6+o9rX2hvrzsvqOZXR5TyyotOfl7ixWxWmHJkFieekkV2toSQdCVBRGQEqyGXwdmT+JvjO5YBVwLFBI9+vx8Fs6GA/rYxbX7cHGMhY/KPxq/78GseTKolYfUDZZYBbHevjni9gkKZZUDEN+C1jh+p8u0Ic42OT/eyyDGHyfqosG3hdV1n1Yb3iDYjs7z+K7qZ+ybtU6xf87G49kN2+7azHwoj0VmIwg+eNZSZ+7Nf/lEd2tZc49tJbaCGvwHN54pKgDvRudC3Hae/tt2zXCFtKVQdU7mRnvYqzlz9NTmKo8l15XVVGHSdY9f/xNMnTsZvaPr3T2UzslDNx+o1VXwSIYQ0UGDr8vgEkbbWdPQoN3DdHxLfvE7EjwQRkTEGZI8jy5DNPMdC/rd3acGEgTLrUIZkT8Kktr9RkVExYTQktoCxm7kPucZi7P6qsLMiCgr9s8eGvW9A97PZtYzIQULH5amiqnY9xQUtd+vU2rfg8lRFHZ9bs1Pl296mfiwdsaJ+Pk7fDj4GjkZHAXR0XgfO825gtf17huUe1O7HtweqAZgS4fojGm5X06Eg0taD7T7rO5Ysv5dbvnuV6asWA+A0mbH6vBh0HafZxLUXX9AkhKR6FqRx4WlMO0/09u1QaU4KS7sGCSIirfk1L5Xezfh0DzY1jx6WQfSwDMYZqEPDj1XNa3H4XLpSFJUDCk5gUc1H1Por9i7BKOhoGBULY/OPJjfCAXHOQC0B3Rf98VGprd8cNoh4PLVh7tGSR3O0fqM4cAfs7PCs5X50jml0uQKcCSwB/uFayqDs8e0+3iE0s1UB9AhzfagxvLEDM2DtbWL285CeeBaasPqD31Obzxt8PFXF5vXx8NPPceFvfkW9zZqQENKW3h/Nd7/0GZ2HNc+Iq84f8T6KGtzF0l4SQLoWCSIiLem6znrnT2xyLMKLHxXQgGw1m2G5h9PN0ifVQ2wXi2rlwMJTqPFXsMuzCU0PkGcsoSxrQNT+IZHqRhrT0SOe1msyhSvxbcmsJP5IeoA93u1o6FwY4fqLgHsIUO2roJsl/KF6relm7oMRlUfQuDvM9Y8QLHAuMHVv1+PHqnnjMnu5wm0vvoHV76MiL5fudfv2bZ1zzVU89tQs9tuylcu/mMcDVxwWlzG0p+lYpO23RrPKEZf25f3714W9XlFh/AllFJS1b4eKhJCuR4KISEvrnAtZ6/iRG4DrgF7Aj8CtmoM5tR8yvuCEpC0hxJuiKBSayig0xX4AV7ahAItqw6NF+3SsU5TfcjYEoDCvLxZzHh5v5C2rZsVKUZJeU51gAWak2GNrdrv2MKkWetv24x7nYooI1hXZgFrgX8CTwLDs8Qltr98ihOztknrdyRdz65evsf/6jU2uP/GnxVx49ZVc8NW3PHLJwTE/Tzy6m7al78eRV/Sleoebb17ZhmpQ0AJ6w3+HHlTEWXdGbvYXjYSQrkmCiEg7Xs3NBscibgb+2ujyCcD7BE+2XWv/juKi01IyvlRQFJV+tjGssn8b/npU8nJ6kp/bK+L9h/Sdxi9rXo34HIMHHodal5ydBfmmUgDeJbgU09zbgIpCnrFjB9YNyZ5IQPNyg3s5t6PQC4WN6HiAgbb96Wsd1aHHjyRc+/bGrdqz8uzsv2EThS4Xi/v25n/7j+PWt//HjC+/BuC2s07HaHTF9FwdCSHtbTqmqgpn3TmMyWf35Ls3t1O9w01OoZkDTixj4ISCNhc8JzqAhHrlJHM7sYidBBGRdio86wGN68JcZwJ+j85Z/l04A3VNznDp7PpZ98Phr2Gre0WjbcDBEk+rtYj9hp4b9f7dS0ajo7Nqwwf4/PtqQUxGG4P7TaNHt7H4u4W/byzNutoi11hEiamM3/sqOBCdxosvK4E7Uehu6R9Tb5RoFEVlRN5h9LONYbtnDQ7NRW81h/KswWQZYluuiiRcfUgs58f0Ubby4oOPUuh0srhvb2ZcdSX1Viv2rCxmvvwaM778GjXbz58vPS7YCCOCVASQ5noNz6XXrcETpf1ejcUf7+L5PyzD79XoNTyXSaeXt3rabaJCSCCg88arLp572sGaVX6MRph6lIUrrsphzLj21R2JxJAgItKOV3ORh0JphB0iQxvdrisFEUVRGJl7GD2zhrDFtQK7yYnJaKWsZD9Ki0diiKFot6xkP0qLRlJVuw6Ptw6LOZei/IGoavRfBaE33XgGkpF5R7Kw+m2Gak4uaGg2FmyjbzXkMyb30A49vqZrVHo3scO1Br/uIsuQT0/rMAqM3Tv0yTiWhmXRFNvtWH3eJiEE4K3TRqEWeLnn0XfoXlWHMaDhN4ZfNkqHENJY5UYnD1/6E9U73METcHX4ZU4lHz28gfPuGc4BJ4UrF05sCLn+6ho+et/d0NTM54M5n3j47GMP9/23gBNOTk49lGidoqdxf+e6ujry8/M5quTSdlfOi8yzzbWKpfVfsAEI1+vzGeBSYErxBR3+VJuJEn3cfGviGUa8movNrmVUuFbi1lxYDdn0yBpBb+uIDv2b92kefqp5jyp/JeNRGIjOAhQ2o9Mraxgjcw9vVxhp7yxI42UZZy+N8es3sLpHWUMIabwzZvKStfwwoh+Deu9p8/hCknnOi9+rcc/0b6mt8IQ950VRYPYbxYyfkLzf4S+/4OCOW+qI9O5mMsG870op6Za4+qCuzl6vsf+ICmpra8nLi/6BUWZEurCA7meHey0V7tX4NRdmQx49rSPoZu6T0rXU7pYBrKr/krvx8yRNT2exA/9AoZupp4SQFI4hXmHErFoZlH0Ag7IPiMvjhSyt+wzNv5svgUP2zqxp6DwNXOleic2Qz4DscTE/XkdnQZpbOKA/0LI/yPCyCqrLchlE20NIsg+ZC1n88S6qt7sjXq+q8NSjdsZPKEramJ57OvqW50AAXn/Fxa+v6Xq/Q9KRBJEuyqu5WFT9LjWBao4AhgALAjUs8m6iu7kvY/KPSehugmiMqonBuZN5un4+NcD1QD9gAXA3CuswMCHnwJSMTQRFC0TxridpK7u/mgrvFp4nWNgcogKXAwuBZ51L6GfbL+zPeFsblIUdQ8/wRb+N27WHCyHtkaoAErJ83m4MhuCbeziBAHwxx4Ou60n5gOP366xdE7nHCQSXapYvjd6XRySPBJEuamntZxgDNfwEjG24VOcd4AzvJtY4fmRozqRUDY/e1hEYFCOf2L/nTc3ecHmxsZQJuYeSZ+rYborORtMCON27ybG17Inh97vx+p3YspLziTSeMybtsdu7BQvhd+NAsEfJo7qbev+eht070PEAEil8hMQzhKQifESq5/hAq0VrZZd1IBA8hM6QhM82qkrUYBS6jVlW+9OGBJEuyO6vYpdvG7NpHEKCTiY4A/Ff11IGZe+fsHNXYlGeNYQelsHU+nfh09xYDXnkGAtTNp50pWkBlq55lT01axk3/CIK8vZV1vj9bn5a8RwuTw3jR15KtjU5AS6VYURHx4CCOUKxc6hHidaoR0lrISTWGRDN78dXuwdUFXNBcUODuUghpCMdTpMpWlHpiJFGPvuYiPUYigKDBhsxGJKz3KuqCodOsfDlXE/UWZopR7Sv4ZqIPwkiXdAe73aMwOkRrj8PuFf3UefbTaE5fLV7siiKkvDOl5lO1zX8AQ8BzctPK55rCCOhEFJr34LRYCWgeZM6rkTstIlFvrEbq9D5HDgyzPXvAEbFiHXQSPzG6G9GMQcQn5fKbz+hbvE3eD3BeglrXiEFE4/AcsKBDZ1xQyEkUwIItL6z5YxzbDx4vz3irIiuw0WXdWwbdltd8ets5n3uCXudwQDdexg4ZroEkXQhQaRL0lEJrpmHY2y4lcgEBoOJMUPPY8mq2VTVruOnFc8xesjZbNg6tyGE7D/iYvKyy1MyvmQHkkJTD/INhVwbqGEuOqWNrlsE3ItC99JxGNsZQpovwWh+P1tffxzvtg1co+ucBLiAZ+uqefmzN8jzV1J86kkxhZBUh47GYt1aGwjA4UdYmPNJ0zf+0LbZacdnccbZyd0qO+FACzPvy+fWP9ai68FlIVUN/rd7mcqs2UWYLdLcLF1IEOmCCkxleIH3gFPCXP86wVNt8yIcwCbSj8FgbhJGFq98HmBfCMlJTQhpLFnLNYqiMDr/aBZWv8sg3cMMdAYA3wFvoJCb3YPBfY6JeP9YA0hIzS/f4di6nrlA484n04BJwPVz55M/bQRGyluEkGQHj3j37Zj3hZtrrqjGF6bus7S7ytXX5XLmOdakLcs0dtpZNiYfauG1l50sX+rDYlGYepSF6cdbJYSkGQkiXVC+qRvFxlL+z1/JGHT6N7rua4LbY3tYh0nvlgxjMJgZOegMvlz494bLBvSemhYhJKQ9YUTTA2x3r2G7aymOQC0mxURJ1mD6WkdjjbCFO8dYxKSiM9hg2cQzlT/h8buxWQro330CvbofgMHQ8me7rQEkpG7x15xI0xAScg3wD1Wlds6PjDt4X/F3OhWbtteO7QGuvjwYQsLVh1Tu0thvrCklISSkrIeBa6/PTdnzi9hIEOmiRuUfzcLqdxim2TkdGEzwE+MnQJGxO0Nke2zG8fvd/LxqdpPL1m3+jLzs8iYFrKnWljCi6QEW13xIpW8rxwJTgG26j+ecP7PDtYL9C04k39S0L33DUhAwmKEM7tv22Q+IfReMp3Y3kc7INQKHaRqfV25vuCzTZ0FCXn7Bid8fvUj1uacd/O2fBQl5ftF5SBDpoqyGXCYVnclW1wo+dK/iXc1NliGXkdYRlGcNTlkPEdE+zQtTxw47n/Vbv2ioGWm+mybVmu9SiRRM1jkWUe3byifAUXsvmwOsRedz3cuP1W9QYh5AryFHkZ/bO+xjNNfeHiCNNd4FY7BkscVnj3jbTaqCMSd43kpnCSEAX833RN22GwjAV/PCF4wK0ZgEkS7MpFronz2W/tljUz0U0QH+gKdJCAnVhDQvYB03YgYFuX1SPdywwhW0anqA7a6l/Ip9IeQe4DZgP+BWwAe86N3Aj0sfZ9iAk+nZPXKH1vYuvTTWOICEWA7Yn1nzv+IOTaOg2XULgQWazvgjB8f8HG2V6JNrI9G01svZW+svIgRE3jghhMgQBtWEzdqtRWFqqIC1KH8gZlM2WebEHhDo9dlZv3UuPy5+gO8X3seSFc9RWbWSthxn1XimxBWox6V7Ggqq5xMMIXcBi4E/AXcDa9C5Cli5/l0crsqG+3fz1FBQbKe+v7VFCBlUvR1TobPDIcRY7qTorANwWEwcpSr8uPfyAMFi8OMMCgX9Culx+ICEzIakKoQATJhkidqgzGCACZOkzky0Tg69EyJBknkujK5ruDw1YbunBgI+fH4XWZbEBRG7YydLlj+D5ndxJjo9gDkoLEKnR8kYRgw6raG5V6y8q1cwf89s3gOOJ9gpdTmwlKbnDwF4gJ6oGIdMpt8Bp1DqqOGRzx7GpPm5+sir2JK3r46kt3E7T776CBU5BVx29lVU24IFr+GCRiTNO6O6122n8t6XcO+ppcyg4kanJqBTMqI7+/91OlnF2XEPIqkMIQAbN/iZNrUSLUoH05feTO5hdyJ9yKF3QqRQRwKIpgfQND8G1dzquRwtlxqyqW/0p9wNLiDYZ8RgaFuH3LYc5qZrAZa++yKDAi4+RWdf+zmd2cCFu5dg7tOPsmGHNowpFqbBQ8mxF/C8p4bjCRZTX0jLEAJgAU5C483K9QD4DAZcRjM9a6t4aM4jXHLeb9hUVMrwiq08+eoj5LtdbCgspbaPijOr/QEkJGtgOb0euh7HT6vJ3bmafIPC6Il9KBjRvU3nq6Q6XLRFv/5G/vbPfG66oRZF2ddSPdRe/cbbciWEiJhIEBEijtobQuodO9m0bT679ixDQ8NqzKasbAJ9exwctvFWLEGhvr+1TW/8zR/TWbuTynXf467fg9GcRXGfseSXD20xs1G9bQVOZw2zgOY9cM8DPgDeWjmP7kMPjmncoTErikqv8kN5ZcP/OBgwAJHPeN173d4i6y0D87m07CqefPURhuzeydOvPMy9U0/mT5++Tr7bxaJ+fbn4qiuwZ7XeXTNS+GhOMajkHDCMYWXtO4Ygk0JIyCmn2xg63MRzTzv4cm6weHXCJDMzLstm/wMkhIjYyNKMEHHS3hBSVbuen1c8Ry9d59do9Aa+Ap5BwWLtxrhRVzQJI+05ej5SIAn3WLqus3XJh2xf/jkoKuhaw3+zi/swbOrlGM22httvWvQullVfsVEPP7PwP+AkYOzJt2HJLmjTuHVdZ/PCd9i5+itygBxgM9B8fqcW6KEo5Bx0NKUHT2u4vMhR3xBGQmIJIbGGj3DCdU5tbVkmE0OIENG0ZWlGilWFSCFN87Ni9SscpmusQONGgrMIDwPfo6O5Klm75bMOP0+oYLP5VziV674LhhAIhpBG/3VUbWXNVy+0uE+0TzMN8aQdfa0URaHvAacw8phrMfUaxS6Cp+c23ixbBZyhKPgMRgrHHNTk/luHZnPPGSc2uezOM05tCCHGcmfYr/YYXlbRrhAC8IF9RLueU4jOQIKIEClUWbUCl9/JA+g0/3w+Gvg/dHbtWkQgkJwD63RdY9uyOVFuoFG3czXOmh0NF+WVDmSzrvFDhLu8DGRnF2G2tq1Y1t5TbfhiTH/Kz72U8pMu4lVVpUxROIvgEQU9FIW5JiMlv7oU37BcnL20hq+RW7byn+eaBqfHn3ia/rsqOzTr0Vyk82PS6ewYIdKVBBEhUqjOsZ1yFCJ9Hp4GeDUfLk9NXJ+38Zt84y2s7rpKvI7q6HdWFGq2rWj4Y0H5cLKzi5ihqDRuS6YDzxAMIiXDD49510zzMYU4e2mYjtyPnn+6GePRR/D+gP58OmgA2cdNo/z2W7AOadqrY+SWrTz/8GMUOIM1IVP+dBOrepRRVlvH7Icfpt/23TGNpzWRZkHaGkJkVkR0VVKsKtB1nRp/BTvca/FrHqyGPHpZh2E1yBkNiaLrOlt2LmDLjgXY0PHRsu4BgssOAKoa/KfanvqQxiL1zQhdrlRH2Yu5l4KCpvn3/VlVGTjlMlZ/9gj9PQ5ORqcc+ExRWa5rlA6cSPfBB0V+wAhji7Sd1lhUSNHx0yM+jrHcycAtu3j+kacaQkioJmTGny/i2btmMXTLLp6/8xnOuucKdnQraHVskbR3KSaSUBiRmhHRlUgQ6eL8uo+faz9hl3cLPVHoC/wCrHcuZFD2BAZmj0/1EDulTdu/Yu3mT4BgvcMbwDnNbqMDjwN5WSVYLYUdDiGxCAzphvKpCd0f5jjV0Lh0jezCpoW51vzujDzhj1Su/55PNy1G87kx5ZcxbPBk8soGt9jCGq2RWKz9PKItrWwrLWDZgB7Y3F4uu+183DYNI06qyGHGHRfz7F2z2FBeQmVh+8K2LMXEn67rfPetl3ffdLFnt0ZZDwOnnWVlzDjZqNDZSRDp4pbVfYHdu5U3gFPQUQm+Mf4d+IvjByxqNr2swzr8PLW+XWx2LsXu24miKBSY+9LHNgqbIbHdPtORz+9i3ZZ9dRgqcCWQB0wnWNNpB/4CvA+M6jUF+wBbmEeKP9VsoXD0JKoWfx3xNDNTVi4F5cNbXG602OgxfAo9hk+J+PgdDSCx1nW4LWauuvE8DAENh61p9c2eXBtnXHkSDoOK6vOjGtt2rpKEkPhzu3Su/VU1877wNPQhMRjgpRecnHqmlb/em5/SU3xFYkkQ6cIc/hp2eNbzJHBao8tzgD8DK4GPHQvpmTW0TU2ZmtvgXMIq+7f0RmEGOm7gVdcvbHUtZUz+sXSzpM9hbMmwa88ydH3fEogGOAh2D+2z92sR4AIG9TmGsm5jmjQqa69Y25mXHnoczm0bcO8KfxCd3+eivnI9ed0Hdfi54xk+mnNbmn6S1nWdus9+pO7N+bh31wYf22Qke+o4is87GkN26z1FIoUQ0TF3/amWL/cekBdqjBb679uvuygvN/Db38tScWclxapd2C7vJiwonB/h+iuBeq0ee6CV4sVGSgJ2flf3OVlacGq/yrudVfZvuRHYgM5/gMeAbehMQ2NJ7Se4A44O/k0yi8dX36JwM/R2vJlgDxEnMHroefTreWhclmTacqaKwZJF2ZGnR7xe1wKsmvsUPte+eNS8+DVcMWzj3Syhr9bEc2fLnpfmsOvx/3HK7lo+Idip9Vafn8BnP7Lz9qfQXPtOig1txW3+FU57ClPFPrsqArz1miviAXm6DrOedOBypW3LK9FBMiPShWm6Hxu02DYaUtzodjHRdf5U+zFD/JV0D9Rze/5xbHL+zHAUZqI3aSNhA54HeqCx1b2CQdmRT03tbCymPPQIzb8ay8suj8vztSWEhFT//O2+ZmbN6Tqa5mdr5fd0O+joqI/TlvNbGotnAAHwbquk+q35/BW4udHlE4HTNJ2JW3Zh+vIzhlzUtp9DCSAd9/WXnlZP6XU4dH5a6GXyIRZWrvDxyotOVq3wkZ2tcsxxWZxwshWrVZZuMpXMiHRhucZiqtFZFOH6jwEjKjZDfmwPqCg8lHsIDsXMaN8O7q79gFrfNs5pFkJCCoDp6NR4t7dr/Jmqe/FIVCXaZwCFwrz+ZFlifN0jCM1GBLweapb+QOW3n1K1+Bv8rtZnoOwbVoQPISG6Tv2GFRGvbj7j0ZbGYfEOIQC1cxZRpKrcEOa6/YDzdZ1tby9t02NKCIkPX+S66Ca8Xp0H76/npGN28/ILTn783sf8uR5u/UMt06fuYvPGGD8wibQjMyJdWIm5D9mqjes1Fx+i07gccg1wLwrdswZjUi0xP+ZqU3duKTiev9a8z2jfDrJbuX1XnGw1GrMY2Odo1mz6MMy1CoqiMrjvsUD7t+uGZkGqlnzLzs/fDu6CUVXQNHbMeYtuBx5Ft8nHRK79iWHGJtzH2ObhozWJCB3h+HZWcYimEekn+WDg6UoHml9DNbb++UxCSPyMHNX6gYyKAtu2BvjvP4M9dUP1I6F66oqdGpdfVMWHX3STotYMJDMiXZiqqIzMO4pvURmJwt+BV4DrgP1RCBhyGZpzYJsfNxRGAA4DXiV84KgBPkKhwNz+02ozVd/yyQzrfyImY9PdMNnWbowfeSl5OT07HEJqlv3Ijk9e27cVNxQctACV33zM7gXB1vHhajcsA/sFg0skioppWP+INR/RAkYyCj6b13YUddPZaFAiBt9NgDnLiJImb2JdqbnZyNEmRo8xYYiweclggCOPsfDqbCeRcnMgABs3BJj/hSf8DURakxmRLq7IXM7EotPY4PiJWz3rCaCRpZjpYR1Bf9tYzGrrOwnC8RH8rfJbYApwIzATCP2ucQAXAH5UemWF3x7sCtSz1bUCe6Aag2Kiu6U/3cx9UWPs0JnuepVNpLx0f6rrNuIPuLFaCsnNLm/3DqXGtSC6plHx5QdRb1/53WdYTzwYNUyVUN5hh+JcGq2plk7ewS2blLU2wxEKIaH/rtjZ/LzejgsXdHoeOZgFH6xkDnBUs+vqgccNCj2OHtKh3WHx9oF9RJdpbPbPBwo459Q91NZoDbMdEMzC5T0N/O6mXKZPjd4J12iEL+d5mHpU+35nidSRICLINRazX/5RaHoATQ9gUEwd+oXc37ebv9X8D4DDgX8D1xNs9X0ywW2pr6PgQGFM/rFkGVou4Gx0/swq+zdko3AQOjtQ+Mm9mgJDIWMLTgh7n0ykqkaKC5pug23PTEjzglTXzs3462ui3kf3+XAuX0HO/uNaXGcdOpiCacdQ89EnDUs6ewcMuk7335yCdYyN4P6e1kWaBRleVhG3MBJtpqXbAb3pNqqMM5ZX8LCmcwZgBn4AfqsqVJkMHHJOy9ch1bpKGOnX38g7H5Uw60kHr7/ipK5Wp7hE5ezzbcy4NBtNi20RNyBlIhlJgohooCoGVKVtzZ2aC4WQPN3DSmMptxYcT69ADV9W/4+n8fMhBqoNuRRZ+jLGOjJsQ7MKzwZW2r/heuAkdN4H+qNzBPByoJoltR8ysfD0tPr0Gg8dXYppzJkT25ZozemKeF3h9GPIGtCP2nlf4tmwAVSF7HGDKTj+ILIGxracFssyTDzCSGvPo6gKB/zjBBbf/QnnL9jMFaqCVYE9AZ2cYhsT/zyNnD4FMT1XsutDukrb9+5lBm68LY8bb8tD1/Um/741TadHucqO7ZFrl/x+GDOu9XoTkX4kiIj40XVuqJ/bJIQ4VQur1e68VngiD9S8T7bu5QXLQF7MmRDxYTY5fuJgYAXB2ZSeQBmwlGCtide/myrfdorTrLbEuG4b/hjfoNsrlq24zl4axoriVm8HYCyJfjvr0CHkTu0V02M1Fo86kHjXkphyLUy490TqNuyh4ptNaL4AAwd3o/uBfVAMUqCaTpp/yFBVhRmXZfP3v9SHbfirqpCTq3DciYk/BkHEnwQRET+Kwj35x3CpfQH35x6Os9Fum1AB64muZbySvX/Eh/Bqbqr8u3ASPPPmDYLLOQZgN3ArwfNXNjp/SbsgAu0PI63NhsTaCyRUMGruXoqlf188GzeHb9WuKBjy8lqcWNtYW3e0xCs4JLqYNa9/MXn9YwtqIAEkXVx0aTY/fu/ls489TVYLDQYwmeDhJwrJkl4iGUmCiIirnYY8/pp/TNjrVpu6809T9Cl4bW/r85+Al2jaer4EeJRg6/kffDvjMNrEMK4LtkaP1+xIrLMgzRWfcRo7/vMgus/fNIzs/bRZcu6ZKBF2xsQaQuIdGtKphboEkPRiNCo88Fgh777l4oVZTtau8WPNUph+YhYzLsumX395O8tU8p0TacWiWjFiJBc/Z4S5XgGuAubrbtwBR6cpWo2kvSEEwNKrJ+XXXcued9/DvXL1vsv79qHwxOOwDhoY9n6xhJDOHEAg80NIdbXGL4u9KIrCfmNN5Bek106z5jUgrV0eYjAonHqGjVPPSM4hkCI5khJEHnroIe6991527tzJmDFjeOCBB5g4cWIynlpkGEVRyTEWk++viPjDGZpTibn1fBx1dJYjHufGhMTSPt3cs5weV12Jv6aWQG0tak42puLivWEjNUsviZTpAaKj7HaNv95Zx9tvuPDv/edhNsPpZ1u56U/5adEG/clH7WxY7+fPf8tHVZsWpN51ax09ehr49TU5CXt+vz84O2g0pv61EEEJDyKvvPIKN9xwA48++iiTJk3i/vvv59hjj2XVqlWUlpYm+ulFBiq3DmVFfQUbgX5hrv8MMGPEkuTZkGSHkOazIe09twXAWJCPsSDYMj5RtR+hEPD57vB9Ydp6u1h19fAR4vXoXHJeFb/87ENr1IvD64VXXnSxfm2AZ2YXpfQNeN1aP/fNrG+o7wiFkVAIeemFYNOyI46yMGRYfHfAfPaxm6ces7Pwh2CDv1H7mbj0imyOPzmr0+3AyzSKroerZIufSZMmMWHCBB588EEANE2jd+/eXHvttdx0001R71tXV0d+fj5HlVyKUTVHva3oPAK6j/m7n2O67uM1mqblFcCBKBRaRzI895CkjCdetR4dCSLRQkjA4aT+2wXYf1iE5nJiKi0l7+CDsI0Z3aIGpC0hJJYAEi0ENA4asd4uVl0xfLS2ffeNV5zc/PvaqLf5zyMFTD9h38+hruusXe2nplqjvJeBnr0SP0n+v7dc/OG6GjQNzjzXyt0z87n7tn0h5O//zueU09u39OJwaGRnt1yGeuj+ev7zT3uLljiaBhddauPWO/MkjMSZvV5j/xEV1NbWkpfXsk1DYwkNIl6vF5vNxuuvv84pp5zScPmMGTOoqanhnXfeaXJ7j8eDx7OvRW9dXR29e/eWINIFVXg2sKT2E0YCv0GnJzAXeBwFgyGfAwpPbdMZOI0leottSLTg0d7aj+ZBwrtjD1tvf4pArWNfQaqqgKaTPX4oPX5/DoqxZW+Y9iyzdMU3/3QRSw+Rs0/ZzeJFvrCbpCD4xnvQwWaemR3cMfTFZ27+/dd6Vq7Zt8Q5ebKZm+7MY9jwxPbjaBxGQjoaQtas8nHxeVX88dZcTj5t32P8ssTL6SfsiXrfp18o4pDD2/f7RITXliCS0Pi7e/duAoEA3bs33SnRvXt3Vq5s+Utt5syZ3HXXXYkcksgQ3S39mVBwEhuci/iNdws6YFHMlFuHM8C2f5tDSEfCR0frOuIVOprTdZ0d/5iNVudouitmbxdKx6JVqJ98wLBL21aP1TxwVG93s+rbKr4J6PTdL4+ew3Lb9HiiY2JtZLZ9WyBiCIHgp//t24JrNh/8z8X1V9dwBPBPYADwPfD377ycf8oeZr9dzNAEhpETT7WiA7//v5qGy2b+s/0hBODtN1xU7tK48frgrFAojNx/X33U+xkM8PwshwSRFEqrXTM333wzN9yw76Du0IyIv38PMMr5AV1NLj3ZjwPwBzwEAl5MRhuqGvx0H88y1XgWkEYLHa3VeIQLHtFmLnYv2srarZWRH1CHrW/+xJXX5WA0t33XhNvh55U/rWDxR7uavMH1HZPHhfeOoqR309ct9IbZ2oFtx+Usj+uhbonoOLpurZ+XX3Cw5AcfRiMccoSFs86zUdKtY52HE6mkRGVXhRZ1RqRbqQGvR+fPN9dyBvCyvu/k02HAqQE40KMz8846Zr0Se6+VttI0nYXfe5tctvAHL6ecbm1SwNoWv7spl9pajVdnuxrCSLdSA1/N80a9XyAAS3/2tes5RXwkNIiUlJRgMBioqGj6y7SiooKysrIWt7dYLFgskkpFU0aDBaMh/j8XbQkgsTYUa66tMx1tqcv4aM16VIOCFoj8MdhZ66dyo5MeQ/btQojljTsQ0Lngoj0sCTPVv3VpHY9dsID/fVJCUXHLN+ZYHj/W0NKWx4yXl190cufNtRSrMD0QPBvpscU+nnrYwaPPFjLhwPT8HXX62TaW314X8XpNg9POsvL5Z2721OrcTcvj13OBGwMw4xsv27b6E1Iz0rww9ZDDLXw938NrLwWPG2i+myZWqqpw98xgQfars1384bfR62Uas1ikPiSVErq53Gw2M378eObMmdNwmaZpzJkzh4MOanlypxDJUN/fmpQQ0lZtLQ6Nubhu782Oy1ke8xv6vM89LPyh6e6LkEAAdldqPPdMbOfZdERbxhwPPy30csfNtfxahy0BeBZ4FdiqwQS3zlUXV1NV1f7dS4l06plW+g0wYAgzaWMwwLDhRo4/0crSn33kKMEZkHAm7f3v9q1hvvkd1DyE/P3f+Tz1fBH33l+AqsJrL7n40021MR9y11wojPTpa2h2eeT7GAxwzHSZcU+lhP+GveGGG3jiiSd49tlnWbFiBVdddRUOh4NLLrkk0U8tRINQ+GhrAElGCBleVtGu4tHBkwqjzoYAFBWrXDRqU5vfzN9+wxX2DS1E1+HZpxITRCrWO5j/whYqXvqeRT96SfDGviZmPeFgsAoPAI3nPYqAlzXwuHTefLVt25+TJTtb5cXXipl8SNMZG0WBw4+w8OAThVx/TTWPP+zAoUOkn7h1e/9bUBj/n/2NGwK8/YarRWHqiadaG8LI/95ysX5t+xdfF3zjZefOpiHKbAkfRhQFjCY4f4Y0SEulhNeInH322VRWVnL77bezc+dOxo4dy0cffdSigFWIWLW3pkPXdeyVG6nfvQFQyOs+kJziPmFvm06zIJH03z+fnsNy2LHGETaQKArMuCwbk6nt0867KwMEWvlA7LDDD995mTApPjvaHDU+XrhxGSvm70FRguPXNBgyzMh/Hy1kwMDEl7R9O9/DdYHwn9C6Acdo8M08D5f/OnENtzqipJuBp14oYsN6Pwu/96IoMOFAM+U9DZx3+h5+XhKshVCA/wB/bXZ/DfiXAsMHGxk0JP6v94CBRp58rpDt2wNNdrZAMIwoCpSUqgwa0r5C2W++8vDrS6rweoLhq7BI5e3XXXjcYLUpOB16QyDRdbBlKzzyVCG9+6RVuWSXk5RX/5prruGaa65JxlOJTqwjRaVu+x7Wz59Ffc0OchQFHdii6+QX92HAoTMw2/IbbpvIENLWZmKNNd/NoigKlz64Hw9etIiaHW4g+MvVYAgunxx3YhZX/qZ9Td969jLw4/etF/DNfs7RoSBymL6U+cooAj6NRy//ie0rgzscdH3fRqB1a/ycf8Ye3v24hG6liS0W1QIQ7W9j3nubdNd/gJH+A/b9ev/kQzeLF+37fmrATIKnWV9HsFvxCuAOBT4HHr05N2F9NaLV2JxwSvv/jYdCiNsNU4608OBjhRhNwc6yr8524XLqnHGOFbdLR9dh/AQzp5xuJSc3vdrfd0USA0XaiecuFgC/x8nqTx+izG3nNeBoXUcH3geuqtrK6s8eYfhx1+Pqmz5HiMfas6O4p5U5c/J5+3Uz777loq5Wo98AI+dcYOPwqZZ2v5mccY6Nd950t3q7X5a0f7fByhU+Ljmvij/c/CMrDb3Zsiz8NstAAKqrNF581sl1f0js1uFxE8y8+ZWHm8OEjXrgYxVmxGkGKJnefcuJamgZov4B/B2wAQ6gOE/hX3/NZ+pRmVczsWKZr0kIMe8tQG1cwJqVpfDXewtSOEoRjgQRkVLxDh3h7Fq3gICrnrnoNF6IOQkYrGuMsu9mW81iivomtoA63GzIip3d27U807TmQ+WCi7O54OL4tbyfeKCZ7BwFhz16fYYlq/2fmt97x8We3Ro3/76W4SMdTbpeNqdp8OZriQ8iF15m4/J5Hv4O/JGGOl98wK8U8Kpw9nmZV0+wu1ILO5MTerkdgMkM8xZ2b3gDzzSX/SqH8p4Gjjw6q8nfIVTAeuBBFo4/OfMCVlcgc1IiJdpaONoRNRsWcnqzEBIyHDgGsC9fmJSxxCLSbEhoB0kydpEoisIFF9uINqGiqh3bbfC7G3M570Ibug7Ll/ojhpCQ2prEF60eNjWLq3+bw03Afga4HfgD0N8Ar6tw34MFlPVI314ikfTuE343TYiiQO/ehowNISHTT7CG/TuoqsIJp1iljXuakiAikiqZASQk4HEyIMr1AwDdaY/78zbuIRKpNiTW2ZBkbmENOf+ibKw2JexuA1WFLKvCOee3f3ZAURTuuCePc85v/edBUaC8V3ICwG9/n8usl4ooO9LC48UqL5WqHHy2lTc/LGHa8emzfNcWZ5xja7X4+JwLknuIpBAhsjQjkibZASTEnFvCVx474VpO6sDXiopa2C2pY4oUQNLpPJeyHgaeer6IKy+uor5u724DJVhnkJOr8PisIrqXtT8c6LrOrCcdfPaJp/UbA+dekLwlkcmHWFpsg00VTdOp3KWFfa09bh2HU6eoKPpnyokHmjn+pCw++J+7xT8DgwEGDTFy1nmx//v0uHU++sDFV/O9aAGdMeOChZ95+fLZVrSdBBGRcKkKICHFgw5iXuUGPgWObnbdG8ASXaPP2PjVhzTvptp4NiTaDEg6hZCQ8RPMzP++lP+95eKH74KtsiccaOHEU7LCnnLaFn++vY4XZrW+i0g1wIiRJs46N/NqMzpK03TuvLWOzz9x8/xrxU12wnjcOldfWc3O7QGefbmI4pLIoVBRFO79TwF9+9l59mlHQ+2P0QQnnWLlljvysNli+36uWeXjkvOr2FWhYTAE8/1777j559/qeeCxAg6bKnUYom0SevpuR9XV1ZGfn8+UCbdilLNmMlKqQwiArgVYM/cpHDvX8H/onAEEgJeBh4GcIfvR86SLUJSOf5oLhRA9EABFQVHVhiDS2jJMtCCSiqWZRIrlRFQINqI6/Uwbf7g1l5ycrvdpu75O49zT9rB6lZ/SUrUhjIRCyPwvPGRlwTOzixk/IbbdPG6Xzi8/+wgEdIYON1HYhsZl9nqNow+rpKZaa7HUoyhgNMI7H5cwaHBiT+8V6S9tTt8VXVs6hBAARTUw6PBL2frLx/x39Tfc5w8uBVjMVoomHEa3A4/qcAhx9tKCDdO+/5G6uV/i3bYdFAXrqP4UnnQw2WMHx+Ov0mm8/rIr6i6ZkFv+lMd5M7pu7UJunspzrxRx0dlVrF7l58Iz9/DkC0XcN7O+IYQ88VxRzCEEgrU97e398vYbLqr2hD9YT9eD38/nn3Zy18z8ljcQIgIJIiLu0iWANKYajPQZezy9Rh2Dqy44M2HNL0M1GGEH2Hu2/7FDIWT3y69hX/A9DVtNdB3Xsg24fllPycXT4bJoJbNdy8YNre+SAVi/Pp7nLGemomJDkzBy0jG7ARpCyKSDklfLMueT6L1lAgH46AO3BBHRJl1vrlMkVDqGkMZUo4nsol5kF/UKhpC9cra17yCz0FKMe/OPwRACTYti9x7etXvWh9Rvqm7foDuhgkIVtZU615wchVvvjD6l21UUFRt48vmiJpfdcmd+UkMIgNuth50NaczrTdvVfpGmJIiIuEn3ENKatoaRUAgxljup+XABRDm6XFEVNr2ztEPj60yOP8katVW6wQBnnmuTvg97edw6t93Y9Fj7B/9Vz4YkzxiNHG2K2o9EVWHESJloF20jQUR0WCp6gyRKrGGk+c4Yz8YdDbMf4eiaTs2qyojXp+OOmUQ64mgLI0cbIx5Zb8tWmHFZ160Naax5Yep/HilgyFAju3ZpXHjmnqSGkXPOj96PRNOIa4df0TVIEBEd0lkCSKycvbQWIcS/3YZibP1ToMHSvk+KnW3HDIDRqPD0i8UcODlYNKmqNISSnr0MvPBaMeU9M6+Dabw1DyFPPFfE9BOsPPdKUUrCyKAhJm68Ldhmv/HSWqjW+7QzrUw7PrE7HO12DYejfUupIj3JHJpot84YQiKdvNs8fDSXM3E4dV/8FHUbSNnB/ToytE6nsFDlmdnFrFrh46t5Hrw+2G+siYMONqNGWebqSnQd/H69RWFq4wLWPXs0Av7k1WVc9qscBg428uQjDr5fEOwtM3iwkYsvz+a0sxLTRl3Xdd563cXTjztYvTIYuoYON3L5r7M56VRp3Z7ppI+IaLPOGEAgfAhpLYCEeHfsZNu9/4JAy9srqoIpL4sjXzofU0744sJo58t0JpW7Arwy28mcTzx4vTpjx5k4f0Y2I0ZJ34lI3C6dNat9jB7Tcstt1Z4A1dU6Awel5jOlz6ejayT0jBpd1/nL7XU8P8uJooK+959YaPv3xZdnc/PtuRJG0kxb+ohIEBFt0llCSKSZj8ZiDSENt1+2nF2znkP3+QEleHSrpmMpsnLQv04mb2BxxPuGCyKdLYQs/MHLZRdW4XbpDRNHBkNwy+cfb83l8l/npHaAIi19/aWHS86rinqb519N7jZm0TppaCYSQkJIdLaRI+h95+3Yv/8Bb8UGFIOKbcxAcg4aRV7f6L9Im+tsIaS+TuPKGU1DCNBQ+PiPe+oZNtzEIYfLm4lo6sVnHQ2BNRyDAV581ilBJINJEBGtkgASO0O2jfyphwOHRzxxtyt66w0XdnvkHhQGAzz1uL3TBZHNG/306Rf+12y068Q+K5b5o+7UCQRgxTJf8gYk4k52zYhORdc03PY9eOxV6Pq+UJGMENJezZdlUjEbous6i3708tLzDt58zcnuylbOjG+jBV9HP2E3EIDvvvGSxivFbfblXA/HHVXJA/+ub3Hdqy85OXZKJW+/IWG1NVZr67UfsdxGpC+J46JVuRtcQHrPjOiaxo6V89iz6kucrjoAbLYCug07nOwjDqW1X1PxDiGxzoakQ/+QFct9/P7aGtas3rcFNNhQzMptd+bHpRBR12m1I2d7M4jHrbPkJy8eDwweaqSsR3ps+12z2ofXAw/8yw7AtdcHt72++pKT2/4YbE62fKmfU05P2RAzwrHHZ7H+v/aIG9JUlYRvGRaJJUFExCwUSJIplvCj6xrrv3mRqs1LuAg4C9CBl5w1vLjoHfK9OyifdnbEqvpEh5Bwp+6myy6ZzRv9nH/6HlyupikgEIBXZ7uordH5zyOFHX6e8RPMfP6pJ2LYUA2w/wGmNu180DSdxx928OQjdurqgg+sKHDk0RZu/0t+ygPJpVfmoGnB+pdQGOleZmgIITMus3Hz7bmpHGJGOPcCG8895cDh0FuEEdUA2dkKZ51nS83gRFzI0oxIa7kbXFG/AKq3Lmf35iW8DDwDTAeOA57f++eapd/j2LQ67OPHM4QYy50xzYSkwyxIyKMP2XG59LBr8JoGH77n5pcl3g4/z2ln2bBY9p0H2OK5AnDJFW3bNXPPHXX86+/1DSEEgrMqX8zxcPYpu6naE9/lpbpaLeLSUV1t+J+jy3+dwx9vDYaNB/5lbxJCbrkjT7acxqC0u4FnZheRXxB8uzIYIHRMVGGhyrMvFVPSLT1mwUT7ZMT23aNKLsWotu/YatGSf2AHjppNQws3PM+gijV8H+ZHWQdGKSrbBo2k1ymXNFyezKWYxjMi0UJIsmdDAgGdsUN34olSvmEwwgUzbNx6Z8dPU/1yroerLqsiENi3AyK0G+JXV2fzu5tiP+BuzSofxx+1O+L1BgNcemU2f7glPofmVe4KcOHZezj4UAu33dU0QKxd7eOic6r41dU5EdvSH3v4Ljas3xeMVm0uy9gQsvAHLy+/6GDtaj+5uSrHnWTlpFOzsNkS+7nW7dL58H0XPyzwggITDzQz/XgrlqzMfB07O9m+K8LqbAEEgks33iUVHBEhTyvAkbrG07t3JmwMHd0dk6qtui6XHjWEQLB5VNWe+IS2Q6dYeP+zbrz4rJNPP3bj8+nsN9bEhZdkc9DBbdst88arrqhbOgMBeGW2k9/fHJ9GVz9852X92gDr1wa/16Ewsna1jwvPrmLPbo23Xndy7gW2FjU1r77kbBJCAB68395QM5IpdF3nz7fX8cIsJwYjBPzBGa4F33h57EE7z79aRK/eiXtLybIqnHqGjVPPkGWYzkaCSBeRKSHE4dqNx1uLyZhNjq17TG8iqimLbdRGvH4roFj21ZrEazYkHttzU9kvxGZTyMlRsNsjT4oqCpSVx2/au29/I7fcmcctd3ZspmLNKl/ULZ0AdbU6NTU6Nisd/tR83IlWHA6dW/9Qy/PPBL/v55xv46JzgiFk+Egjz8wuDhtCGi/HdC8zNKkZyaQw8vILTl6YFfy7B/bWNYfy/84dAX51cTXvfVaSsTM9InUkiHRymRJAauu3sm7j+1TZtzZclm/tRv++0ygpHBL2PqFC1vy+43jt54+5F52yZrfZDPwPhZLh44DUhpB0qg0BUFWFM86x8fwzjqgzC6eflX6fQEPnjbRm0n7BZbHxE0xccVUORxzd/t0VZ54TfB1CYSQUSIaPNDLrpWIKC5suTTQPIY1rQkJhRFHgmuvSP4xoms4TjzhQlPC7mwIBWLPaz7dfe5l8SOfqBSMSLyOCiL9/D5AW751Wbf1Wflr2JKN0jUeB/YE1wL2uSr5Y+Tyjh5xDafHIiDtoSgcdyO5VX3Kk18nTus7EvZd/A1yiqBhtORSMmhj2vq3p6KxHuB0z6eTK32Tz4XsudldqYcPIxZdnM2Bg+v2auPvv+fzq4uqYb//TQh+/vrS6w63kzzzHxtrVfp55wtFw2TOzW4YQgNxcBYMBLri4aQgJPf8/7qknLz8z9gvs2B5g65boU1BGI3zzlUeCiGizzPhXIDq1tRveY7Su8Q06ZwIDgWnAp8BJwJpN71HbN3KxsmdgHj3Pu5oNeYUcCPRSVcpVlUOAbQXF9Dr3agxZ1jbPhnSFzqgl3Qy89m4Jh0+1NNnRkp+v8IdbctN2e+mUIywcNiX2AvbQts9/3FPP2tXt78K5drWPd99quo39ofvrw+6mmX6ClTfeKwm7O+byX+fw9oclXHRJ+OLWcGqqNV6Z7eSRB+y8/YYTpzN5DfhaWwYL0eK7UUl0Een3UUd0KQ5XJdWObTwBNJ/vUIG7gHc8dmp3rKKw54iG65p3Ss0qKaP/5bdg37ACx9b1KCj07TOI7H5DUBTJ29GU9TDw6DNF7NgeYO1qPxYLjN3fnNATVTtKURQeeqKIW/5Yw//ecsd8P4MBXn7RyW13tX0XUOPC1OEjjZxwspV7/1rfsETTfDcNEPVU4VhPHNZ1nYf/Y+fh/9rx+4MNvAIBuOOWOm65I4+zk9BDo7yngeISlT27I4cfvx/GjZfdjaLtJIiIlHJ7agCYEOH6MQR/SD2O4DR8tFbtiqqSO3AkuQNHdnhc8ZgNSfdlmeZ6lBvoEcfC1ESzZCmcfpatTUEkEIDlS9s+I9I8hIRqQgoK1SYFrOHCSEc9/rCD//zT3vDn0OyEy6nzpxtrsVkVTjw1sV2PjUaFiy7N5v5768PWiBgM0K1UZepRsiwj2k6CiEiIWNvB+6qKYAWsBfqEuX4T4AdMltinsCOxbVWTdp5M8xCSboWqncE3X3n49SXBU41HjTZRW6uxZXP0tQFFad+5JBUVGvX1WovC1MYFrJs2BvD5wBzHSQG7XePh/9ij3ua+v9Vx/MlZqGpiZ7Au/3U2SxZ5+fwzD6q6b7lLNYAtW+HRp4swGtN3Fk2kLwkiIq7aeh6NrbAn2TnF3Gffw1RocSbMfYDJaKag5/C4jC+WMJKsAtVUbt3NdKEQ4nbD4UdYeOjxQmprNaZPrWzSabU5XYejpzUtfA8EdL6c5+HLuR58Phg9xsTxJzVt0HXwoRaeeaGIQUNNLQpTzzzHRml3lQMPsmA2x/eNeN7nnhbt95vbsV3j58U+xu6f2GURk0nhoScLef9dN7Ofc7B+rZ/sHJUTTs7i/BnZKW+pLzKXBBERN+05FE9RFMrHncCHXz7LOcCdwHBgC8EQ8iDQZ/QxGIzxm/JN5MxIW86VEe33zBOOJiHEbFHoVmrg0acLOe/MqmBL3WYMBigqVpssY2zb6ufyC6tYtzaAce9vw5dfgL/dXcd/Hyvk4EP3/dxNODDyz+DhUxOzqy9S6/jmamqSM9NnMCicdKqVkxK8FCS6FqniE3HRkZN5i3qPZuDk83nHbGUEkIVCH+ARg4k+406gbNjhQPT6kFg5e2kRQ0isZ8VEkmk1IZnsP48UcPVvcxpCSMgBkyz864F8TKbgMkzjc0lKu6s8+3IR2dnBnyOvR+eis6vYuCG4nOP3B78A7HadX11c1aEdNvEQa6fS3n3kM6XIXPLTK8LqSLBoj5J+4yjqPZqa7SvwOmowZmVT2HMEBlPwk2YsIaQjsxxdYatuZ2Kzqfz29+G3Fp9wso0pR2TxzpsuFv/kw2iAQw63cPS0rCZLJx++74pYU6LrwaLQZ55wcM+9BYn4K8Rk8qFmupep7KrQwhaJqirsN9bEwEHyq1xkLvnpFS0kO4SEqAYjRb1HN7ks1lkQCSGisZxclfNnZHP+jMi3+fQjd5Oiy+YCAfjwfTf33JuYMcbCYFD4yz/y+dUl1Sh607GqBjCb4I6/dPxAQiFSSZZmRBOpCiHhJDqEdHQpRmQ2h0OPGEJC3O7UH05++NQsZs0uYtTopn1HDjzIzMtvlzBydGz9SIRIVzIjIoD0CiCQ+KUYIYYMNbHga2/ErqGKStoseRw42cLr71nYvNFPVZVG97LM6vkiRDTp8a9MtJBuwaCj4lFoChI+RPycfb6tyZkxzekaXHBx7P1rdlcGeP0VFyuW+TCZFY482sJRx2ZhMsVvS2+ffkb69Ivbw0Xk9ep8/62X2lqN3n0MjB5jklN1RcJIEEkTnS14NNbRECLhQyTCgIFG/nBLLvf+tb5FrYiiwOFTLZx+Vmz/Lt9508nNv6tF04KFrqoK777poncfA7NeKsqoXS2zn3Pw73vrqa3Ztyw1eIiRP/89n/0PkBbuIv4y519HJ9WZAwhICIkk05qZ6brO9wu8LPjGCzocMNHMQYeYE97NM9GuuCqHPv0MPP6Qg1+WBLfqdi9TmXFZNjMuy46pU+jCH7z88braJrtaQss927cFuPjcKj6a2y2uMyOJ8vTjdv725/oWl69b6+fCs/Yw+41ixoyTMCLiS4JICnXmEBKvpZhESWWRaqaFkC2b/Vx1WTWrV/oxGIPdbx/6D/QbYOCRp4rSpo6ivY6dbuXY6VbqajV8Pp3CIrVNAeuJh+0NB9E1FwjAls0BPvvYzfQT0vvfe32dxr/+0TKEwL7Zovtm1vP8q8VJHJXoCtL73aITy+QQYu+ptvoVD4mYDUn2TpnmXVUzLYTY7RoXnrWHdWuCnb4CjZp+bdkU4IIz91BV1fT7tG6tn8pd4StAf17sTerx9W2Rl69SXGJoUwjRNJ15X3giFrxCsKna55954jDCxProAzfeKMPUNPjuWy87tkc/z0eItpIgkmT1/a1pH0KSETJSQbbqtt1br7vYsV2L+Gm/ukrjlRf3va5r1/i48Kw9XHROVYsw8t23Hi48q4orZ1SnbRhpq0Ag/ExIY5oW7OKa7ior9rW5j2ZXhQQREV+Z+66SYdI9gKRT0IjWhr29Eh1CYmnvnmmzIQDvve2Ker2mwbtv7buN2aRgNMK6Nf4mYeS7bz1cOaMal0vHkqVgyPDakhCTSaH/AAPRNpQoCgwbkf69PkpKDa2GKoBupZm5bXjnjgD//Vc9l5y/h8svqmLWkw5qk3RGj4guIxZ36/tZMZoSc6hUV5QOYaO5TC5K7cxnzNTV6mFbizdWX7fve9enn5EXXi3mgr3LORedU8U11+Vwy+9rcbl0Dp1i4eEnCrFkdY4gAnDRpdnc9ae6iNerKpxxdvp+CAmZdlwWd99Wi9cb/npVDRYpl/fMvCDy0fsubri2Bi2wr97ly7keHvhXPU8+X8S48VKAm0rp944kYhJLnUYmLK0kYvYjmTpzCAEYMMiAIcr7jmqA/gObfp4JhZGyHirr1vi5/uqaThtCINiP5IgjLaDQZGbEYAj+eeY/8zNiFiEvX+X6P4Q/v0dVg3+fP9wS/vp0tnKFj+uuriHgb7pFW9eD3XUvu6CqRZ2TSK70elcSUaVrmGirUPjI9ADS2UMIwDnnZ0edrtcCcN6FthaX9+ln5P9uaPqmdffMvE4XQgCMRoUHnyjkjj/n0a9/MHCoarAPyYuvF3PyaS1fn3ShN5vuuvRX2dx2dx75+U2/T/0GGJj1UmZu3X32KQcKhJ3Z0zRwOHXeeEXqx1IpI5ZmRHoup7RHJoePruiQw82cfFoW77zlhma/yBUFph5l4ZjpLZdNv/vWw59vb7pccflF1Tz3clFGzA6Es/AHLyNGmbBaW4apH77zcu6FNs6fkY3Pp2MwkLY9Vuz1Gs897eDlF5zs3KmRl6dw6plWLrkih/KeBi66JJtzzrPxzdce6mt1evc1MGZc5nZW/eKz6LuadA3mfu7hiqtykjco0YQEkQTrLAGioySAZCZFUfjbvwoYOtzBM084qNwV/D4WFilcdEk2V16dg8HQ9A2qcWHqoVMs3HRbLpddWNVQM5KJYWTu526uvqKaCZPMPPJUUZMw8tLzDu64pY7Tz7Jyz735ad24rLpa49zTdrNxfaBhmaKuTueFWU7eet3F7NeLGTLMhNmiMOWIzlGX5/e3vmPJ503/XU2dmbxLxlk612OkioSQzGYwKFz+6xzmfVfKR3O78eEX3fjqx+5cfV1uizfdnxZ6m4SQh58oZPBQU5OakYvOqcq43Qo5OSpmk8I3X3q56rIqXK7gG1cohADkF6hRd8+kg5l317JpQ6DFqcOBADjsOr+9qrrFck2mGzPWHLXOyWCAsftn3pJTZyLvlHEkwaOpTK8DEU0ZjQoDBhoZOMgY8VN/vwFG+vY3tChMbVzAOn6Cidy8NH/HbuaAiWaeeK6I7Ox9YeSZJ+wNIeTSK7O58bbctF6+qK7WeO9td8RlikAA1q0N8OP3vuQOLMEuuswWvc5Jg3PD1DmJ5JGlmTiRENKUBJCWPrCPyMheIm1RWKjy3MvFWK1Ki8LUPv2MvPFeCcUlbWuh3l6bN/p55SUn69f4sdoUjj0uiyOObv9puKEwcsVFVXzzpZdvvgzuc82EEAKwdpWvoStuJKoKy37xMWFS55khOHxqFpf/OpsnH3VgMOxrQGcwBEPI3X/Lp/8AeStMJXn1O0gCSEsSQiLrCmGkoDDyv4lk1YY89aidf+w9VTcQCL7pvPeOm0GDjTwzu4juZe0bxwETzRx5bBbvvrmvidtvf5/6EFJVpfHCLAevv+ykqkqjtNTAmefaOP8iG3n5we+Hydz6GHUdzJ0ngzT4wy25jJ9g5tmnHPy00IvBoHDI4WYuvTJHThROA4qexguCdXV15OfnM/7Mv6S0oZmEjdikcwCJd2fVWLfuNj9rJqSzh5FU+vgDF9f+qibsdQYDDBlm5O0PS9oVHhrXhIRMPrRlAWsybd8W4JxTd7OrQmtS+6Gq0LuPgZfeLKakmwGvV+eQAyqoqY78K19R4LOvutG7j3xGFR1jr9fYf0QFtbW15OXlRb2tvMNGIQWnsZFakMg+3z0s7OUf2EckeSRdx6MPBE/DDScQgBXL/Hz3bYT2oVE0DiGXXpnN7DeKm9SMhApYk+2P19dQuUtrUYCqabB1S4Dbb64FwGwOFh1HoqpwzPQsCSEi6eRdNgIJILGRANJ+Ekbir6pKY9lSf4s35caMxmBvibZ481Vni8LU5gWsv7msCk1LbhhZu8bH9996oxagzvnEw84dwRtc/utszrsoWJhp2Js3QjtKDphoZuY/8xM9ZCFakOgbhoSQ2EgIEekm1n4Q3jb2jRh3gJnS7ionnGxtUpjaUMA6o4qjjs1KehOzpT+3vsNF14O3K+thQFUV7rwnn7POtfH6K062bQlQWKRy4qlWDjrYnLZN2ETnJkGkEQkgsZEAItJVSTeV4mKVPXsi/4z6/TB6v7adhtt/gJF3PiqhqFhtUVtywEQzn33ZjeKS5DdpMxpiCw7GZn/dEaNM3D5KZj9EepB33r0khMRGQkjnP+gukxkMChdcbItYI6KqkJurMP3Etp+GW1xiiFjgmooQAjBpcvRmXQAWCxwwQXaGiPQl775ICImVhBCRCa64KocJk8woYU7DNRjgv48WpmyHS7x1KzVw8unWiMFLUeDcC7PJyZXfcSJ9demfTtkVExvZFbOPzIakP7NF4anni7j1rjz69jOgKJCVBSefZuXN90s4+DBLqocYV3f8JZ8DDw7OeIRmR0L/PfIYC7+/OTfCPYVID122RkQCSGwkgOwjISRzmC3BQ/kuuiQbXddT3nAskaxWhadfKOLr+V7efsNJxU6NHj0NnH6WlUkHmTv13110Dl0yiEgIiUyCR/xEamYmkqsrvBGrqsKhUywcOqVzzfaIrqFLBREJIOFJ+Ig/CSFCCBGbLvPOLCEkPAkh8SchRAghYtclZkQkhLQkASQxJIQIIUTbdOogIgEkPAkhQggh0kWnfaeWEBKehBAhhBDpJGHv1vfccw+TJ0/GZrNRUFCQqKdpQXqDhCe9QIQQQqSjhL1je71ezjzzTK666qpEPUULEkDCkwAihBAiXSWsRuSuu+4CYNasWXF/bAkcsZMQEh/SzEzEStN05n3h4Y2XnWzdGqCkm4FTTrdyzPQszObO39NEiLZKq2JVj8eDx+Np+HNdXV2T6yWAxE4CiBDJ5/XoXHNlNXM/92AwQCAAqupn/hceRo8x8cyLReTly+8xIRpLq38RM2fOJD8/v+Grd+/eDddJCImdhJD4astsyOe7hyVwJCLd/fPv9cyfG/wwFQgEL9P2/nNcvtTHzb+rSc3AhEhjbXp3v+mmm1AUJerXypXt76Nw8803U1tb2/C1ZcsWABw9JITESkJIfMmSjIiV3a7x0vOOhuDRXCAAn33iYctmf3IHJkSaa9PSzO9+9zsuvvjiqLcZMGBAuwdjsViwWOSshNZI2EgOCSGiLX5e7MPtjn4bXYcF33jp3SetVsWFSKk2/Wvo1q0b3bp1S9RYRAwkhAiRnrRAbLcLxHg7IbqKhMXyzZs3U1VVxebNmwkEAixevBiAQYMGkZOTk6in7dQkhCSPzIaIthox2oTRCP5WVl7GH2BKzoCEyBAJCyK33347zz77bMOfx40bB8AXX3zBlClTEvW0nZIEECHSX1GRyomnWnn3TVfYWQ+DAcYdYGLwUAkiQjSWsCrQWbNmoet6iy8JIW0jIUSIzHHbnXkMHW5EUUBp1DJEUaGsh4F//rcwdYMTIk1JxVQakxAiRGbJzVN56c0S3nzVySuznezYFqCoROX0s2ycfZ6N/ALZAShEcxJE0pAEECEyl9WqcP6MbM6fkZ3qoQiRESSIpJAEjs7p893DOKKk/f10hBCiK5F5whSREJK+ZMeMEEIkjwSRJHP20iSEdAHS6l0IIWIjQSSJJICkv3jOhkgYEUKI1kkQSQKZBem6JIwIIUR0EkQSTAKIEEIIEZkEkQSSECKEEEJEJ9t3E0ACSGaS3TJCCJF8EkQ6QAJH5yEhRAghUkOCSDtJCOkcJIAIIURqSRBpIwkgnYeEECGESD0pVm0DCSFCCCFEfEkQiZGEENFe0ktECCEik6WZVkgAEfEQCiNyGJ4QQjQlMyJRSAgRQgghEkuCSAQSQkQiyDKNEEI0JUszzUgAEUIIIZJHZkQakRAihBBCJJcEkb0khHRexnJnqocghBAigi61NCNho+uRECKEEOmty8yISAjpeiSECCFE+usSQURCSNcjIUQIITJDp16akQDSNUkIEUKIzNFpZ0QkhIhM8IF9RKqHIIQQKdUpg4iEEJFJJIwIIbqyThVEnL00CSEiI0kYEUJ0VZ0miEgAEW0xvKwi1UNoQcKIEKIryrhiVQkcoqPSMYQIIURXlTFBRAKIEEII0flkxNKMq6eEEBEfMhsihBDpJWNmRIRojfQPEUKIzJMRMyJCtEZCiBBCZCYJIiLjSQgRQojMJUFEZDQJIUIIkdkkiAiRRqSXiBCiq5EgIkSakTAihOhKJIgIkYY+sI+QQCKE6BIkiIiM1RXqQySMCCE6OwkiIiN1hRAihBBdgTQ0ExlFAogQQnQuMiMiMoaEECGE6HwkiAghhBAiZSSIiC4jXQ68+3z3MD7fPSzm28sOGiFEZyZBRIgUaUsYAdlBI4TonCSIiC4hXWZDmpMwIoTo6iSICJFiEkaEEF2ZBBEhhBBCpIwEESGEEEKkjAQRkRGkh4gQQnROEkRE2pMQIoQQnZcEEZHWJIQIIUTnJmfNiLQkAUQIIboGmRERQgghRMpIEBEiA0nbdyFEZyFBRIgMJmFECJHpJIgIkeEkjAghMpkEESE6AQkjQohMJUFECCGEECkjQUQIIYQQKSNBRAghhBApIw3NRFqRRmZCCNG1yIyISBsSQoQQouuRICLSgoQQIYTomiSIiJSTECKEEF2XBBEhOgnpJSKEyEQSRIToROQMGiFEppEgIkQnJGFECJEpEhZENm7cyGWXXUb//v2xWq0MHDiQO+64A6/Xm6inFBlI6kMSR8KIECITJKyPyMqVK9E0jccee4xBgwaxdOlSrrjiChwOB/fdd1+inlZkEAkhQgghEhZEpk2bxrRp0xr+PGDAAFatWsUjjzwiQaSLkwAihBAiJKmdVWtraykqKop4vcfjwePxNPy5rq4uGcMSSSQhRAghRGNJK1Zdu3YtDzzwAL/61a8i3mbmzJnk5+c3fPXu3TtZwxNCCCFECrQ5iNx0000oihL1a+XKlU3us23bNqZNm8aZZ57JFVdcEfGxb775Zmpraxu+tmzZ0va/kRBCCCEyRpuXZn73u99x8cUXR73NgAEDGv5/+/btTJ06lcmTJ/P4449HvZ/FYsFisTT8Wdd1ADS3u63DFGkq4EzN99LnSO/dWu4sf0Ie165rCXlcIYSIxm4P/u4JvY9Ho+ix3Kqdtm3bxtSpUxk/fjwvvPACBoOhTfffunWrLM8IIYQQGWrLli306tUr6m0SFkS2bdvGlClT6Nu3L88++2yTEFJWVhbTY2iaxvbt28nNzUVRlEQMs4W6ujp69+7Nli1byMvLS8pzdkXyOieHvM7JIa9z8shrnRwdfZ11Xae+vp7y8nJUNXoVSMJ2zXz66aesXbuWtWvXtkhDsWYfVVVbTVKJkpeXJz/kSSCvc3LI65wc8jonj7zWydGR1zk/Pz+m2yVs18zFF1+Mruthv4QQQgghQM6aEUIIIUQKSRBpxmKxcMcddzTZvSPiT17n5JDXOTnkdU4eea2TI5mvc0J3zQghhBBCRCMzIkIIIYRIGQkiQgghhEgZCSJCCCGESBkJIkIIIYRIGQkiEWzcuJHLLruM/v37Y7VaGThwIHfccQdeb3qfWZKJ7rnnHiZPnozNZqOgoCDVw+lUHnroIfr160dWVhaTJk3i+++/T/WQOp358+dz4oknUl5ejqIovP3226keUqczc+ZMJkyYQG5uLqWlpZxyyimsWrUq1cPqlB555BH222+/hkZmBx10EB9++GFCn1OCSAQrV65E0zQee+wxli1bxr///W8effRRbrnlllQPrdPxer2ceeaZXHXVVakeSqfyyiuvcMMNN3DHHXewaNEixowZw7HHHsuuXbtSPbROxeFwMGbMGB566KFUD6XTmjdvHldffTULFizg008/xefzccwxx+BwOFI9tE6nV69e/O1vf2PhwoX8+OOPHHHEEZx88sksW7YsYc8p23fb4N577+WRRx5h/fr1qR5KpzRr1iyuu+46ampqUj2UTmHSpElMmDCBBx98EAie3dS7d2+uvfZabrrpphSPrnNSFIW33nqLU045JdVD6dQqKyspLS1l3rx5HHbYYakeTqdXVFTEvffey2WXXZaQx5cZkTaora2lqKgo1cMQolVer5eFCxdy1FFHNVymqipHHXUU3377bQpHJkTH1dbWAsjv4wQLBAK8/PLLOBwODjrooIQ9T8IOvets1q5dywMPPMB9992X6qEI0ardu3cTCATo3r17k8u7d+/OypUrUzQqITpO0zSuu+46Dj74YEaNGpXq4XRKv/zyCwcddBBut5ucnBzeeustRowYkbDn63IzIjfddBOKokT9av6Letu2bUybNo0zzzyTK664IkUjzyzteZ2FEKI1V199NUuXLuXll19O9VA6raFDh7J48WK+++47rrrqKmbMmMHy5csT9nxdbkbkd7/7HRdffHHU2wwYMKDh/7dv387UqVOZPHkyjz/+eIJH13m09XUW8VVSUoLBYKCioqLJ5RUVFZSVlaVoVEJ0zDXXXMN7773H/Pnz6dWrV6qH02mZzWYGDRoEwPjx4/nhhx/4z3/+w2OPPZaQ5+tyQaRbt25069Ytpttu27aNqVOnMn78eJ555hlUtctNILVbW15nEX9ms5nx48czZ86chsJJTdOYM2cO11xzTWoHJ0Qb6brOtddey1tvvcXcuXPp379/qofUpWiahsfjSdjjd7kgEqtt27YxZcoU+vbty3333UdlZWXDdfKJMr42b95MVVUVmzdvJhAIsHjxYgAGDRpETk5OageXwW644QZmzJjBAQccwMSJE7n//vtxOBxccsklqR5ap2K321m7dm3Dnzds2MDixYspKiqiT58+KRxZ53H11Vcze/Zs3nnnHXJzc9m5cycA+fn5WK3WFI+uc7n55puZPn06ffr0ob6+ntmzZzN37lw+/vjjxD2pLsJ65plndCDsl4ivGTNmhH2dv/jii1QPLeM98MADep8+fXSz2axPnDhRX7BgQaqH1Ol88cUXYX9+Z8yYkeqhdRqRfhc/88wzqR5ap3PppZfqffv21c1ms96tWzf9yCOP1D/55JOEPqf0ERFCCCFEykjRgxBCCCFSRoKIEEIIIVJGgogQQgghUkaCiBBCCCFSRoKIEEIIIVJGgogQQgghUkaCiBBCCCFSRoKIEEIIIVJGgogQQgghUkaCiBBCCCFSRoKIEEIIIVJGgogQQgghUub/AXchahEMJE7CAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -226,7 +226,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 6, "id": "bad61aa7", "metadata": {}, "outputs": [ @@ -241,13 +241,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_31764\\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", + "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": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -289,7 +289,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 7, "id": "b149f603", "metadata": {}, "outputs": [ @@ -297,7 +297,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "d:\\miniconda3\\envs\\testLM\\Lib\\site-packages\\joblib\\externals\\loky\\process_executor.py:700: 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", + "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" ] }, @@ -312,13 +312,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_31764\\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", + "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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", + "image/png": "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", "text/plain": [ "
" ] @@ -360,7 +360,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 8, "id": "36545bb2", "metadata": { "scrolled": false @@ -370,20 +370,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.95\n" + "0.9\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_31764\\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", + "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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", + "image/png": "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", "text/plain": [ "
" ] @@ -402,13 +402,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_31764\\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", + "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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", + "image/png": "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", "text/plain": [ "
" ] @@ -473,37 +473,12 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": null, "id": "8a95da2e", "metadata": { "scrolled": true }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_31764\\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" - }, { "name": "stdout", "output_type": "stream", @@ -515,13 +490,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\Josip Rudar - Home\\AppData\\Local\\Temp\\ipykernel_31764\\2353877849.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", + "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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", + "image/png": "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", "text/plain": [ "
" ] @@ -575,6 +550,14 @@ "plt.show()\n", "plt.close()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e87fda41", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": {