From 5a19fc67657ce96aa58fb78fa84035100d7abcc4 Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Mon, 11 Sep 2023 15:08:51 -0400 Subject: [PATCH 01/70] ENH initialize with MIRF_AUC and MIRF_MV Co-Authored-By: Sambit Panda <36676569+sampan501@users.noreply.github.com> Co-Authored-By: Yuxin <99897042+YuxinB@users.noreply.github.com> Co-Authored-By: Adam Li <3460267+adam2392@users.noreply.github.com> --- sktree/stats/__init__.py | 1 + sktree/stats/_might.py | 288 +++++++++++++++++++++++++++++++++++++++ sktree/stats/meson.build | 10 ++ 3 files changed, 299 insertions(+) create mode 100644 sktree/stats/__init__.py create mode 100644 sktree/stats/_might.py create mode 100644 sktree/stats/meson.build diff --git a/sktree/stats/__init__.py b/sktree/stats/__init__.py new file mode 100644 index 000000000..d27397e5f --- /dev/null +++ b/sktree/stats/__init__.py @@ -0,0 +1 @@ +from ._might import MIRF_AUC, MIRF_MV diff --git a/sktree/stats/_might.py b/sktree/stats/_might.py new file mode 100644 index 000000000..860b210e1 --- /dev/null +++ b/sktree/stats/_might.py @@ -0,0 +1,288 @@ +import numpy as np +from joblib import Parallel, delayed +from sklearn.metrics import roc_auc_score +from sklearn.model_selection import train_test_split + +from ..ensemble import HonestForestClassifier + + +def auc_calibrator(tree, X, y, test_size=0.2, permute_y=False): + indices = np.arange(X.shape[0]) + X_train, X_test, y_train, y_test, indices_train, indices_test = train_test_split( + X, y, indices, test_size=test_size + ) + + # individual tree permutation of y labels + if permute_y: + y_train = np.random.permutation(y_train) + + tree.fit(X_train, y_train) + y_pred = tree.predict_proba(X_test)[:, 1] + + # Fill test set posteriors & set rest NaN + posterior = np.full(y.shape, np.nan) + posterior[indices_test] = y_pred + + return posterior + + +def perm_stat(clf, x, z, y, random_state=None): + permuted_Z = np.random.permutation(z) + X_permutedZ = np.hstack((x, permuted_Z)) + perm_stat = clf.statistic(X_permutedZ, y) + return perm_stat + + +def perm_half(clf, z, y, x_pos): + permuted_Z = np.random.permutation(z) + perm_stat, perm_pos = clf.statistic(permuted_Z, y, return_pos=True) + null_pos = forest_pos(x_pos + perm_pos, y) + null_stat = roc_auc_score(null_pos[:, 0], null_pos[:, 1], max_fpr=clf.limit) + + return null_stat + + +def pos_diff(observe_pos, perm_pos, limit): + total_pos = np.random.shuffle(np.concatenate((observe_pos, perm_pos))) + + half_ind = len(total_pos) * 0.5 + half_pos = total_pos[:half_ind] + end_pos = total_pos[half_ind:] + + half_pos_final = forest_pos(half_pos, y) + half_stat = roc_auc_score(half_pos_final[:, 0], half_pos_final[:, 1], max_fpr=limit) + + end_pos_final = forest_pos(end_pos, y) + end_stat = roc_auc_score(end_pos_final[:, 0], end_pos_final[:, 1], max_fpr=limit) + + return abs(half_stat - end_stat) + + +def forest_pos(posterior, y): + # Average all posteriors + posterior_final = np.nanmean(posterior, axis=0) + + # Ignore all NaN values (samples not tested) + true_final = y.ravel()[~np.isnan(posterior_final)].reshape(-1, 1) + posterior_final = posterior_final[~np.isnan(posterior_final)].reshape(-1, 1) + + return np.hstack((true_final, posterior_final)) + + +class MIRF_AUC: + def __init__( + self, + n_estimators=500, + criterion="gini", + splitter="best", + max_depth=None, + min_samples_split=2, + min_samples_leaf=1, + min_weight_fraction_leaf=0.0, + max_features="sqrt", + max_leaf_nodes=None, + min_impurity_decrease=0.0, + bootstrap=False, + oob_score=False, + n_jobs=None, + random_state=None, + verbose=0, + warm_start=False, + class_weight=None, + ccp_alpha=0.0, + max_samples=None, + honest_prior="empirical", + honest_fraction=0.5, + tree_estimator=None, + limit=0.05, + ): + self.clf = HonestForestClassifier( + n_estimators=n_estimators, + criterion=criterion, + splitter=splitter, + max_depth=max_depth, + min_samples_split=min_samples_split, + min_samples_leaf=min_samples_leaf, + min_weight_fraction_leaf=min_weight_fraction_leaf, + max_features=max_features, + max_leaf_nodes=max_leaf_nodes, + min_impurity_decrease=min_impurity_decrease, + bootstrap=bootstrap, + oob_score=oob_score, + n_jobs=n_jobs, + random_state=random_state, + verbose=verbose, + warm_start=warm_start, + class_weight=class_weight, + ccp_alpha=ccp_alpha, + max_samples=max_samples, + honest_prior=honest_prior, + honest_fraction=honest_fraction, + tree_estimator=tree_estimator, + ) + self.limit = limit + + def statistic( + self, + x, + y, + workers=1, + test_size=0.2, + initial=True, + return_pos=False, + permute_y=False, + ): + # Initialize trees + if initial: + self.clf.fit(x[0:2], y.ravel()[0:2]) + + # Compute posteriors with train test splits + posterior = Parallel(n_jobs=workers)( + delayed(auc_calibrator)(tree, x, y.ravel(), test_size, permute_y) + for tree in (self.clf.estimators_) + ) + + posterior_final = forest_pos(posterior, y) + self.stat = roc_auc_score(posterior_final[:, 0], posterior_final[:, 1], max_fpr=self.limit) + + if return_pos: + return self.stat, posterior + + return self.stat + + +class MIRF_MV: + def __init__( + self, + n_estimators=500, + criterion="gini", + splitter="best", + max_depth=None, + min_samples_split=2, + min_samples_leaf=1, + min_weight_fraction_leaf=0.0, + max_features="sqrt", + max_leaf_nodes=None, + min_impurity_decrease=0.0, + bootstrap=False, + oob_score=False, + n_jobs=None, + random_state=None, + verbose=0, + warm_start=False, + class_weight=None, + ccp_alpha=0.0, + max_samples=None, + honest_prior="empirical", + honest_fraction=0.5, + tree_estimator=None, + limit=0.05, + ): + self.clf = HonestForestClassifier( + n_estimators=n_estimators, + criterion=criterion, + splitter=splitter, + max_depth=max_depth, + min_samples_split=min_samples_split, + min_samples_leaf=min_samples_leaf, + min_weight_fraction_leaf=min_weight_fraction_leaf, + max_features=max_features, + max_leaf_nodes=max_leaf_nodes, + min_impurity_decrease=min_impurity_decrease, + bootstrap=bootstrap, + oob_score=oob_score, + n_jobs=n_jobs, + random_state=random_state, + verbose=verbose, + warm_start=warm_start, + class_weight=class_weight, + ccp_alpha=ccp_alpha, + max_samples=max_samples, + honest_prior=honest_prior, + honest_fraction=honest_fraction, + tree_estimator=tree_estimator, + ) + self.limit = limit + + def statistic( + self, + x, + y, + workers=1, + test_size=0.2, + initial=True, + return_pos=False, + permute_y=False, + ): + # Initialize trees + if initial: + self.clf.fit(x[0:2], y.ravel()[0:2]) + + # Compute posteriors with train test splits + posterior = Parallel(n_jobs=workers)( + delayed(auc_calibrator)(tree, x, y.ravel(), test_size, permute_y) + for tree in (self.clf.estimators_) + ) + + # Average all posteriors + posterior_final = np.nanmean(posterior, axis=0) + + # Ignore all NaN values (samples not tested) + true_final = y.ravel()[~np.isnan(posterior_final)] + posterior_final = posterior_final[~np.isnan(posterior_final)] + + self.stat = roc_auc_score(true_final, posterior_final, max_fpr=self.limit) + + if return_pos: + return self.stat, posterior + + return self.stat + + def test(self, x, z, y, reps=1000, workers=1, random_state=None): + XZ = np.hstack((x, z)) + observe_stat = self.statistic(XZ, y) + + null_dist = np.array( + Parallel(n_jobs=workers)([delayed(perm_stat)(self, x, z, y) for _ in range(reps)]) + ) + pval = (1 + (null_dist >= observe_stat).sum()) / (1 + reps) + + return observe_stat, null_dist, pval + + def test_twin(self, x, z, y, reps=1000, workers=1, random_state=None): + x_stat, x_pos = self.statistic(x, y, return_pos=True) + + # TODO: determine whether we need the forest + + z_stat, z_pos = self.statistic(z, y, return_pos=True) + + observe_pos = forest_pos(x_pos + z_pos, y) + observe_stat = roc_auc_score(observe_pos[:, 0], observe_pos[:, 1], max_fpr=self.limit) + + null_dist = np.array( + Parallel(n_jobs=workers)([delayed(perm_half)(self, z, y, x_pos) for _ in range(reps)]) + ) + pval = (1 + (null_dist >= observe_stat).sum()) / (1 + reps) + + return observe_stat, null_dist, pval + + def test_diff(self, x, z, y, reps=1000, workers=1): + XZ = np.hstack((x, z)) + observe_stat, observe_pos = self.statistic(XZ, y, return_pos=True) + + # Compute statistic for permuted sets + permuted_Z = np.random.permutation(z) + X_permutedZ = np.hstack((x, permuted_Z)) + perm_stat, perm_pos = self.statistic(X_permutedZ, y, return_pos=True) + + # Boostrap sample the posterior from the two forests + null_stats = np.array( + Parallel(n_jobs=workers)( + [delayed(pos_diff)(observe_pos, perm_pos, limit=self.limit) for _ in range(reps)] + ) + ) + + stat = observe_stat - perm_stat + + pval = (1 + (null_stats >= stat).sum()) / (1 + reps) + return stat, null_stats, pval diff --git a/sktree/stats/meson.build b/sktree/stats/meson.build new file mode 100644 index 000000000..c21857d68 --- /dev/null +++ b/sktree/stats/meson.build @@ -0,0 +1,10 @@ +python_sources = [ + '__init__.py', + '_might.py', +] + +py3.install_sources( + python_sources, + pure: false, + subdir: 'sktree/stats' +) From f1a8e49d319faaad3a8875522635c472d96acdd2 Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Mon, 11 Sep 2023 15:59:12 -0400 Subject: [PATCH 02/70] ENH add statistic alternatives --- sktree/stats/_might.py | 31 +++++++++++++++++++++++-------- 1 file changed, 23 insertions(+), 8 deletions(-) diff --git a/sktree/stats/_might.py b/sktree/stats/_might.py index 860b210e1..0fb8b66f2 100644 --- a/sktree/stats/_might.py +++ b/sktree/stats/_might.py @@ -1,5 +1,6 @@ import numpy as np from joblib import Parallel, delayed +from scipy.stats import entropy from sklearn.metrics import roc_auc_score from sklearn.model_selection import train_test_split @@ -126,6 +127,7 @@ def statistic( self, x, y, + stat="AUC", workers=1, test_size=0.2, initial=True, @@ -143,7 +145,16 @@ def statistic( ) posterior_final = forest_pos(posterior, y) - self.stat = roc_auc_score(posterior_final[:, 0], posterior_final[:, 1], max_fpr=self.limit) + + if stat == "AUC": + self.stat = roc_auc_score( + posterior_final[:, 0], posterior_final[:, 1], max_fpr=self.limit + ) + elif stat == "MI": + H_YX = np.mean(entropy(posterior_final[:, 1], base=np.exp(1), axis=1)) + _, counts = np.unique(posterior_final[:, 0], return_counts=True) + H_Y = entropy(counts, base=np.exp(1)) + self.stat = max(H_Y - H_YX, 0) if return_pos: return self.stat, posterior @@ -208,6 +219,7 @@ def statistic( self, x, y, + stat="AUC", workers=1, test_size=0.2, initial=True, @@ -224,14 +236,17 @@ def statistic( for tree in (self.clf.estimators_) ) - # Average all posteriors - posterior_final = np.nanmean(posterior, axis=0) - - # Ignore all NaN values (samples not tested) - true_final = y.ravel()[~np.isnan(posterior_final)] - posterior_final = posterior_final[~np.isnan(posterior_final)] + posterior_final = forest_pos(posterior, y) - self.stat = roc_auc_score(true_final, posterior_final, max_fpr=self.limit) + if stat == "AUC": + self.stat = roc_auc_score( + posterior_final[:, 0], posterior_final[:, 1], max_fpr=self.limit + ) + elif stat == "MI": + H_YX = np.mean(entropy(posterior_final[:, 1], base=np.exp(1), axis=1)) + _, counts = np.unique(posterior_final[:, 0], return_counts=True) + H_Y = entropy(counts, base=np.exp(1)) + self.stat = max(H_Y - H_YX, 0) if return_pos: return self.stat, posterior From fd0b937577f483b56fd6281a73621596975eff9d Mon Sep 17 00:00:00 2001 From: Sambit Panda <36676569+sampan501@users.noreply.github.com> Date: Tue, 12 Sep 2023 08:15:30 -0400 Subject: [PATCH 03/70] no axis=1 when taking posterior slice in MI --- sktree/stats/_might.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sktree/stats/_might.py b/sktree/stats/_might.py index 0fb8b66f2..3c9d79421 100644 --- a/sktree/stats/_might.py +++ b/sktree/stats/_might.py @@ -151,7 +151,7 @@ def statistic( posterior_final[:, 0], posterior_final[:, 1], max_fpr=self.limit ) elif stat == "MI": - H_YX = np.mean(entropy(posterior_final[:, 1], base=np.exp(1), axis=1)) + H_YX = np.mean(entropy(posterior_final[:, 1], base=np.exp(1))) _, counts = np.unique(posterior_final[:, 0], return_counts=True) H_Y = entropy(counts, base=np.exp(1)) self.stat = max(H_Y - H_YX, 0) From efc258758f42daa5da776ca96726e8d95b37a641 Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Tue, 12 Sep 2023 09:19:03 -0400 Subject: [PATCH 04/70] ENH add y-label permutation test to MIGHT --- sktree/stats/_might.py | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/sktree/stats/_might.py b/sktree/stats/_might.py index 3c9d79421..e27879aa3 100644 --- a/sktree/stats/_might.py +++ b/sktree/stats/_might.py @@ -28,8 +28,12 @@ def auc_calibrator(tree, X, y, test_size=0.2, permute_y=False): def perm_stat(clf, x, z, y, random_state=None): - permuted_Z = np.random.permutation(z) - X_permutedZ = np.hstack((x, permuted_Z)) + if z is not None: + permuted_Z = np.random.permutation(z) + X_permutedZ = np.hstack((x, permuted_Z)) + else: + X_permutedZ = np.random.permutation(x) + perm_stat = clf.statistic(X_permutedZ, y) return perm_stat @@ -70,7 +74,7 @@ def forest_pos(posterior, y): return np.hstack((true_final, posterior_final)) -class MIRF_AUC: +class MIGHT: def __init__( self, n_estimators=500, @@ -161,8 +165,18 @@ def statistic( return self.stat + def test(self, x, y, reps=1000, workers=1, random_state=None): + observe_stat = self.statistic(x, y) + + null_dist = np.array( + Parallel(n_jobs=workers)([delayed(perm_stat)(self, x, None, y) for _ in range(reps)]) + ) + pval = (1 + (null_dist >= observe_stat).sum()) / (1 + reps) + + return observe_stat, null_dist, pval + -class MIRF_MV: +class MIGHT_MV: def __init__( self, n_estimators=500, From d1f7748807ccf039aa429e3d708451217954faca Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Tue, 12 Sep 2023 09:19:36 -0400 Subject: [PATCH 05/70] FIX rename import --- sktree/stats/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sktree/stats/__init__.py b/sktree/stats/__init__.py index d27397e5f..f6933ba2c 100644 --- a/sktree/stats/__init__.py +++ b/sktree/stats/__init__.py @@ -1 +1 @@ -from ._might import MIRF_AUC, MIRF_MV +from ._might import MIGHT, MIGHT_MV From d4abb4aed585483bc190fd077ffe9d1472092fb0 Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Tue, 12 Sep 2023 10:16:26 -0400 Subject: [PATCH 06/70] FIX, correct function param --- sktree/stats/_might.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sktree/stats/_might.py b/sktree/stats/_might.py index e27879aa3..d76cdcbbf 100644 --- a/sktree/stats/_might.py +++ b/sktree/stats/_might.py @@ -47,7 +47,7 @@ def perm_half(clf, z, y, x_pos): return null_stat -def pos_diff(observe_pos, perm_pos, limit): +def pos_diff(observe_pos, perm_pos, y, limit): total_pos = np.random.shuffle(np.concatenate((observe_pos, perm_pos))) half_ind = len(total_pos) * 0.5 @@ -307,7 +307,7 @@ def test_diff(self, x, z, y, reps=1000, workers=1): # Boostrap sample the posterior from the two forests null_stats = np.array( Parallel(n_jobs=workers)( - [delayed(pos_diff)(observe_pos, perm_pos, limit=self.limit) for _ in range(reps)] + [delayed(pos_diff)(observe_pos, perm_pos, y, limit=self.limit) for _ in range(reps)] ) ) From a3424827840053b7643f50c4e284c87befa1e1df Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Tue, 12 Sep 2023 10:42:07 -0400 Subject: [PATCH 07/70] FIX remove axis param & TST initialize test file --- sktree/stats/_might.py | 2 +- sktree/stats/meson.build | 2 ++ sktree/stats/tests/test_might.py | 4 ++++ 3 files changed, 7 insertions(+), 1 deletion(-) create mode 100644 sktree/stats/tests/test_might.py diff --git a/sktree/stats/_might.py b/sktree/stats/_might.py index d76cdcbbf..ff3d9ac2b 100644 --- a/sktree/stats/_might.py +++ b/sktree/stats/_might.py @@ -257,7 +257,7 @@ def statistic( posterior_final[:, 0], posterior_final[:, 1], max_fpr=self.limit ) elif stat == "MI": - H_YX = np.mean(entropy(posterior_final[:, 1], base=np.exp(1), axis=1)) + H_YX = np.mean(entropy(posterior_final[:, 1], base=np.exp(1))) _, counts = np.unique(posterior_final[:, 0], return_counts=True) H_Y = entropy(counts, base=np.exp(1)) self.stat = max(H_Y - H_YX, 0) diff --git a/sktree/stats/meson.build b/sktree/stats/meson.build index c21857d68..d6cf64e5f 100644 --- a/sktree/stats/meson.build +++ b/sktree/stats/meson.build @@ -8,3 +8,5 @@ py3.install_sources( pure: false, subdir: 'sktree/stats' ) + +subdir('tests') diff --git a/sktree/stats/tests/test_might.py b/sktree/stats/tests/test_might.py new file mode 100644 index 000000000..fa8db2a34 --- /dev/null +++ b/sktree/stats/tests/test_might.py @@ -0,0 +1,4 @@ +import numpy as np +import pytest + +from sktree.stats import MIGHT, MIGHT_MV From 69c76a868d10e1c9b45ddaef810347ddafbec249 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 12 Sep 2023 11:11:44 -0400 Subject: [PATCH 08/70] Adding modularity Signed-off-by: Adam Li --- doc/references.bib | 11 ++++ sktree/stats/meson.build | 1 + sktree/stats/tests/test_might.py | 0 sktree/stats/utils.py | 90 ++++++++++++++++++++++++++++++++ 4 files changed, 102 insertions(+) create mode 100644 sktree/stats/tests/test_might.py create mode 100644 sktree/stats/utils.py diff --git a/doc/references.bib b/doc/references.bib index df44cfb26..58dad37dd 100644 --- a/doc/references.bib +++ b/doc/references.bib @@ -11,6 +11,17 @@ @article{breiman2001random publisher = {Springer} } +@article{coleman2022scalable, + title = {Scalable and efficient hypothesis testing with random forests}, + author = {Coleman, Tim and Peng, Wei and Mentch, Lucas}, + journal = {The Journal of Machine Learning Research}, + volume = {23}, + number = {1}, + pages = {7679--7713}, + year = {2022}, + publisher = {JMLRORG} +} + @article{Li2023manifold, author = {Li, Adam and Perry, Ronan and Huynh, Chester and Tomita, Tyler M. and Mehta, Ronak and Arroyo, Jesus and Patsolic, Jesse and Falk, Ben and Sarma, Sridevi and Vogelstein, Joshua}, title = {Manifold Oblique Random Forests: Towards Closing the Gap on Convolutional Deep Networks}, diff --git a/sktree/stats/meson.build b/sktree/stats/meson.build index c21857d68..b059cd516 100644 --- a/sktree/stats/meson.build +++ b/sktree/stats/meson.build @@ -1,6 +1,7 @@ python_sources = [ '__init__.py', '_might.py', + 'utils.py', ] py3.install_sources( diff --git a/sktree/stats/tests/test_might.py b/sktree/stats/tests/test_might.py new file mode 100644 index 000000000..e69de29bb diff --git a/sktree/stats/utils.py b/sktree/stats/utils.py new file mode 100644 index 000000000..7db2951de --- /dev/null +++ b/sktree/stats/utils.py @@ -0,0 +1,90 @@ +from numpy.typing import ArrayLike +import numpy as np + +from sklearn.metrics import mean_squared_error, roc_auc_score + +METRIC_FUNCTIONS = { + 'mse': mean_squared_error, + 'auc': roc_auc_score +} + +def pvalue(observe_stat: float, permuted_stat: ArrayLike) -> float: + """Compute pvalue with Coleman method. + + Implements the pvalue calculation from Algorithm 1. See + :footcite:`coleman2022scalable` for full details. + + Parameters + ---------- + observe_stat : float + The observed test statistic. + permuted_stat : ArrayLike of shape (n_repeats,) + The array of test statistics computed on permutations. + + Returns + ------- + pval : float + The pvalue. + """ + n_repeats = len(permuted_stat) + pval = (1 + (permuted_stat >= observe_stat).sum()) / (1 + n_repeats) + return pval + + +def compute_null_distribution(X_test, y_test, forest, perm_forest, metric: str='mse', n_repeats: int=1000, seed: int=None): + """Compute null distribution using Coleman method. + + The null distribution is comprised of two forests. + + Parameters + ---------- + X_test : _type_ + _description_ + y_test : _type_ + _description_ + forest : _type_ + _description_ + perm_forest : _type_ + _description_ + metric : str, optional + _description_, by default 'mse' + n_repeats : int, optional + _description_, by default 1000 + seed : int, optional + _description_, by default None + + Returns + ------- + _type_ + _description_ + """ + rng = np.random.default_rng(seed) + + metric_func = METRIC_FUNCTIONS[metric] + + # sample two sets of equal number of trees from the combined forest + y_pred_proba_normal = forest.predict_proba(X_test) + y_pred_proba_perm = perm_forest.predict_proba(X_test) + all_y_pred = np.concatenate((y_pred_proba_normal, y_pred_proba_perm), axis=0) + + n_samples = len(y_test) + + # pre-allocate memory for the index array + index_arr = np.arange(n_samples * 2, dtype=int) + + metric_star = [] + metric_star_pi = [] + for idx in range(n_repeats): + # two sets of random indices from 1 : 2N are sampled using Fisher-Yates + rng.shuffle(index_arr) + first_half_index = index_arr[:n_samples] + second_half_index = index_arr[n_samples:] + + # compute two instances of the metric from the sampled trees + first_half_metric = metric_func(y_true=y_test, y_pred=all_y_pred[first_half_index]) + second_half_metric = metric_func(y_true=y_test, y_pred=all_y_pred[second_half_index]) + + metric_star.append(first_half_metric) + metric_star_pi.append(second_half_metric) + + return metric_star, metric_star_pi \ No newline at end of file From b3ab11d4c7f0ed994ee5bf23050c342714b84cb9 Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Tue, 12 Sep 2023 11:29:34 -0400 Subject: [PATCH 09/70] TST experiment with unit test --- sktree/__init__.py | 3 +- sktree/meson.build | 5 ++-- sktree/stats/tests/__init__.py | 0 sktree/stats/tests/meson.build | 10 +++++++ sktree/stats/tests/test_might.py | 51 +++++++++++++++++++++++++++++++- 5 files changed, 65 insertions(+), 4 deletions(-) create mode 100644 sktree/stats/tests/__init__.py create mode 100644 sktree/stats/tests/meson.build diff --git a/sktree/__init__.py b/sktree/__init__.py index 451379644..ce1c4b2e2 100644 --- a/sktree/__init__.py +++ b/sktree/__init__.py @@ -36,7 +36,7 @@ # process, as it may not be compiled yet else: try: - from . import _lib, tree, ensemble, experimental + from . import _lib, tree, ensemble, experimental, stats from ._lib.sklearn.ensemble._forest import ( RandomForestClassifier, RandomForestRegressor, @@ -68,6 +68,7 @@ "tree", "experimental", "ensemble", + "stats", "ExtraObliqueRandomForestClassifier", "ExtraObliqueRandomForestRegressor", "NearestNeighborsMetaEstimator", diff --git a/sktree/meson.build b/sktree/meson.build index 0d5518a73..70b709920 100644 --- a/sktree/meson.build +++ b/sktree/meson.build @@ -80,7 +80,8 @@ cython_c_args += ['-Wno-cpp'] cython_cpp_args = cython_c_args subdir('_lib') -subdir('tree') subdir('ensemble') subdir('experimental') -subdir('tests') \ No newline at end of file +subdir('stats') +subdir('tests') +subdir('tree') diff --git a/sktree/stats/tests/__init__.py b/sktree/stats/tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/sktree/stats/tests/meson.build b/sktree/stats/tests/meson.build new file mode 100644 index 000000000..376ceb35a --- /dev/null +++ b/sktree/stats/tests/meson.build @@ -0,0 +1,10 @@ +python_sources = [ + '__init__.py', + 'test_might.py', +] + +py3.install_sources( + python_sources, + pure: false, + subdir: 'sktree/stats/tests' +) diff --git a/sktree/stats/tests/test_might.py b/sktree/stats/tests/test_might.py index fa8db2a34..7eea4c778 100644 --- a/sktree/stats/tests/test_might.py +++ b/sktree/stats/tests/test_might.py @@ -1,4 +1,53 @@ import numpy as np import pytest +from sklearn import datasets +from sklearn.utils.estimator_checks import parametrize_with_checks -from sktree.stats import MIGHT, MIGHT_MV +from sktree._lib.sklearn.tree import DecisionTreeClassifier +from sktree.stats import MIGHT +from sktree.tree import ObliqueDecisionTreeClassifier, PatchObliqueDecisionTreeClassifier + +# load the iris dataset +# and randomly permute it +iris = datasets.load_iris() +rng = np.random.RandomState(1) + +# remove third class +iris_X = iris.data[iris.target != 2] +iris_y = iris.target[iris.target != 2] + +p = rng.permutation(iris_X.shape[0]) +iris_X = iris_X[p] +iris_y = iris_y[p] + + +@pytest.mark.parametrize("criterion", ["gini", "entropy"]) +@pytest.mark.parametrize("max_features", [None, 2]) +@pytest.mark.parametrize("honest_prior", ["empirical", "uniform", "ignore", "error"]) +@pytest.mark.parametrize( + "estimator", + [ + None, + DecisionTreeClassifier(), + ObliqueDecisionTreeClassifier(), + PatchObliqueDecisionTreeClassifier(), + ], +) +@pytest.mark.parametrize("limit", [0.05, 0.1]) +def test_iris(criterion, max_features, honest_prior, estimator, limit): + # Check consistency on dataset iris. + clf = MIGHT( + criterion=criterion, + random_state=0, + max_features=max_features, + n_estimators=10, + honest_prior=honest_prior, + tree_estimator=estimator, + limit=limit, + ) + if honest_prior == "error": + with pytest.raises(ValueError, match="honest_prior error not a valid input."): + clf.statistic(iris_X, iris_y) + else: + score = clf.statistic(iris_X, iris_y, stat="AUC") + assert score == 1.0, "Failed with pAUC: {0} for max fpr: {1}".format(pAUC, limit) From 4ed31f8c4f1f65ac4cf19736b4b6e8c7b6526c31 Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Tue, 12 Sep 2023 11:35:22 -0400 Subject: [PATCH 10/70] FIX correct variable name --- sktree/stats/tests/test_might.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/sktree/stats/tests/test_might.py b/sktree/stats/tests/test_might.py index 7eea4c778..fb7949434 100644 --- a/sktree/stats/tests/test_might.py +++ b/sktree/stats/tests/test_might.py @@ -1,7 +1,6 @@ import numpy as np import pytest from sklearn import datasets -from sklearn.utils.estimator_checks import parametrize_with_checks from sktree._lib.sklearn.tree import DecisionTreeClassifier from sktree.stats import MIGHT @@ -50,4 +49,4 @@ def test_iris(criterion, max_features, honest_prior, estimator, limit): clf.statistic(iris_X, iris_y) else: score = clf.statistic(iris_X, iris_y, stat="AUC") - assert score == 1.0, "Failed with pAUC: {0} for max fpr: {1}".format(pAUC, limit) + assert score == 1.0, "Failed with pAUC: {0} for max fpr: {1}".format(score, limit) From 9114859cd2129e264f8094ad2bdba26f0dfa8f34 Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Tue, 12 Sep 2023 14:38:00 -0400 Subject: [PATCH 11/70] TST remove patch oblique tree tests --- sktree/stats/tests/test_might.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/sktree/stats/tests/test_might.py b/sktree/stats/tests/test_might.py index fb7949434..825137217 100644 --- a/sktree/stats/tests/test_might.py +++ b/sktree/stats/tests/test_might.py @@ -29,7 +29,6 @@ None, DecisionTreeClassifier(), ObliqueDecisionTreeClassifier(), - PatchObliqueDecisionTreeClassifier(), ], ) @pytest.mark.parametrize("limit", [0.05, 0.1]) @@ -49,4 +48,4 @@ def test_iris(criterion, max_features, honest_prior, estimator, limit): clf.statistic(iris_X, iris_y) else: score = clf.statistic(iris_X, iris_y, stat="AUC") - assert score == 1.0, "Failed with pAUC: {0} for max fpr: {1}".format(score, limit) + assert score >= 0.9, "Failed with pAUC: {0} for max fpr: {1}".format(score, limit) From 6b526081eb144ca90946f753baef01ffee0ef609 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 13 Sep 2023 17:29:32 -0400 Subject: [PATCH 12/70] WIP --- sktree/__init__.py | 2 + sktree/ensemble/_honest_forest.py | 2 + sktree/stats/__init__.py | 1 + sktree/stats/forestht.py | 255 ++++++++++++----- sktree/stats/permutationforest.py | 420 ++++++++++++++++++++++++++++ sktree/stats/tests/test_forestht.py | 130 ++++++++- sktree/stats/utils.py | 46 +-- 7 files changed, 764 insertions(+), 92 deletions(-) create mode 100644 sktree/stats/permutationforest.py diff --git a/sktree/__init__.py b/sktree/__init__.py index c6af80ea0..8a9e32eb5 100644 --- a/sktree/__init__.py +++ b/sktree/__init__.py @@ -58,6 +58,7 @@ PatchObliqueRandomForestRegressor, ) from .ensemble._honest_forest import HonestForestClassifier + from .stats import ForestHT except ImportError as e: msg = """Error importing scikit-tree: you cannot import scikit-tree while being in scikit-tree source directory; please exit the scikit-tree source @@ -85,4 +86,5 @@ "ExtraTreesClassifier", "ExtraTreesRegressor", "ExtendedIsolationForest", + "ForestHT", ] diff --git a/sktree/ensemble/_honest_forest.py b/sktree/ensemble/_honest_forest.py index 1c5edbefb..5ab5eca64 100644 --- a/sktree/ensemble/_honest_forest.py +++ b/sktree/ensemble/_honest_forest.py @@ -5,6 +5,7 @@ import numpy as np from joblib import Parallel, delayed +from sklearn.base import _fit_context from sklearn.ensemble._base import _partition_estimators from sklearn.utils.validation import check_is_fitted, check_X_y @@ -374,6 +375,7 @@ def __init__( self.honest_prior = honest_prior self.tree_estimator = tree_estimator + @_fit_context(prefer_skip_nested_validation=True) def fit(self, X, y, sample_weight=None, classes=None): """ Build a forest of trees from the training set (X, y). diff --git a/sktree/stats/__init__.py b/sktree/stats/__init__.py index f6933ba2c..77cdb9372 100644 --- a/sktree/stats/__init__.py +++ b/sktree/stats/__init__.py @@ -1 +1,2 @@ from ._might import MIGHT, MIGHT_MV +from .forestht import ForestHT diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index d8e6d9f54..8fdbddee4 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -1,13 +1,13 @@ import numpy as np -from joblib import Parallel, delayed from numpy.typing import ArrayLike from sklearn.base import MetaEstimatorMixin, clone from sklearn.model_selection import train_test_split +from sklearn.utils.validation import _is_fitted, check_X_y -from sktree import HonestForestClassifier from sktree._lib.sklearn.ensemble._forest import ForestClassifier from sktree._lib.sklearn.tree import DecisionTreeClassifier +from ..ensemble import HonestForestClassifier from .utils import METRIC_FUNCTIONS, _compute_null_distribution_coleman, _pvalue @@ -17,7 +17,7 @@ def tree_posterior( y: ArrayLike, covariate_index: ArrayLike = None, test_size: float = 0.2, - seed: int = None, + seed=None, ) -> ArrayLike: """Compute the posterior from each tree on the "OOB" samples. @@ -43,31 +43,32 @@ def tree_posterior( The predicted posterior probabilities for each OOB sample from the tree. For any in-bag samples, the posterior is NaN. """ - rng = np.random.default_rng(seed) + # seed the random number generator using each tree's random seed(?) + rng = np.random.default_rng(tree.random_state) indices = np.arange(X.shape[0]) if covariate_index is not None: # perform permutation of covariates - index_arr = rng.choice(indices, size=X.shape[0], replace=False, shuffle=False) + index_arr = rng.choice(indices, size=(X.shape[0], 1), replace=False, shuffle=False) perm_X_cov = X[index_arr, covariate_index] X[:, covariate_index] = perm_X_cov # XXX: we can replace this using Forest's generator for the in-bag/oob sample indices when # https://github.com/scikit-learn/scikit-learn/pull/26736 is merged - X_train, X_test, y_train, _, _, indices_test = train_test_split( - X, y, indices, test_size=test_size - ) + # X_train, X_test, y_train, _, _, indices_test = train_test_split( + # X, y, indices, test_size=test_size + # ) # individual tree permutation of y labels - tree.fit(X_train, y_train) - y_pred = tree.predict_proba(X_test)[:, 1] + tree.fit(X, y, check_input=False) + # y_pred = tree.predict_proba(X_test)[:, 1] # Fill test set posteriors & set rest NaN - posterior = np.full(y.shape, np.nan) - posterior[indices_test] = y_pred + # posterior = np.full((y.shape[0], tree.n_outputs_), np.nan) + # posterior[indices_test] = y_pred.reshape(-1, tree.n_outputs_) - return posterior + # return posterior class ForestHT(MetaEstimatorMixin): @@ -245,9 +246,6 @@ class ForestHT(MetaEstimatorMixin): Type of decision tree classifier to use. By default `None`, which defaults to :class:`sklearn.tree.DecisionTreeClassifier`. - alpha : float, optional - Rejection threshold, by default 0.05. - Attributes ---------- samples_ : ArrayLike of shape (n_samples,) @@ -287,7 +285,6 @@ def __init__( honest_prior="empirical", honest_fraction=0.5, tree_estimator=None, - alpha=0.05, ): self.estimator = HonestForestClassifier( n_estimators=n_estimators, @@ -313,7 +310,6 @@ def __init__( honest_fraction=honest_fraction, tree_estimator=tree_estimator, ) - self.alpha = alpha self.n_jobs = n_jobs self.n_estimators = n_estimators self.criterion = criterion @@ -345,27 +341,58 @@ def _statistic( covariate_index: ArrayLike = None, metric="auc", test_size=0.2, + return_posteriors: bool = False, **metric_kwargs, ): """Helper function to compute the test statistic.""" metric_func = METRIC_FUNCTIONS[metric] + rng = np.random.default_rng(self.random_state) # first run a dummy fit on just two samples to initialize the # internal data structure of the forest - estimator.fit(X[:2], y[:2]) + if not _is_fitted(estimator): + unique_y = np.unique(y) + X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) + estimator.fit(X_dummy, unique_y) # Fit each tree and ompute posteriors with train test splits - posterior = Parallel(n_jobs=self.n_jobs)( - delayed(tree_posterior)(tree, X, y, covariate_index, test_size) - for tree in (estimator.estimators_) - ) + n_samples = X.shape[0] + indices = np.arange(n_samples, dtype=int) + posterior_arr = np.zeros((self.n_estimators, n_samples, self.estimator.n_classes_)) + for idx in range(self.n_estimators): + seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32) + indices_train, indices_test = train_test_split( + indices, test_size=test_size, stratify=y, shuffle=True, + random_state=seed + ) + tree = estimator.estimators_[idx] + tree_posterior(tree, X[indices_train, :], y[indices_train, :], covariate_index, test_size, seed=seed) + + y_pred = tree.predict_proba(X[indices_test, :]) + + # Fill test set posteriors & set rest NaN + posterior = np.full((y.shape[0], tree.n_classes_), np.nan) + posterior[indices_test, :] = y_pred + posterior_arr[idx, ...] = posterior # Average all posteriors - posterior_final = np.nanmean(posterior, axis=0) - samples = np.argwhere(~np.isnan(posterior_final).any(axis=1))[0] + posterior_final = np.nanmean(posterior_arr, axis=0) + samples = np.argwhere(~np.isnan(posterior_final).any(axis=1)).squeeze() y_true_final = y[samples, :] posterior_final = posterior_final[samples, :] - stat = metric_func(y_true=y_true_final, y_pred=posterior_final, **metric_kwargs) + if metric == "auc": + if posterior_final.shape[1] != 2: + raise ValueError( + "AUC only supports binary classification. " + "Please use a different metric." + ) + print(posterior_final[:5, :]) + # get posteriors of the positive class + posterior_final = posterior_final[:, 1] + + print('Y true: ', y_true_final) + print('posterior: ', posterior_final) + stat = metric_func(y_true_final, posterior_final, **metric_kwargs) if covariate_index is None: # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) @@ -374,15 +401,20 @@ def _statistic( self.y_true_final_ = y_true_final self.posterior_final_ = posterior_final self.stat_ = stat - else: - if not np.array_equal(samples, self.samples_): - raise ValueError( - "The samples used in the final test are not the same as the " - "samples used in the initial test on the non-permuted samples." - ) + + if return_posteriors: + return stat, posterior_final, samples return stat + def reset(self): + class_attributes = dir(type(self)) + instance_attributes = dir(self) + + for attr_name in instance_attributes: + if attr_name.endswith("_") and attr_name not in class_attributes: + delattr(self, attr_name) + def statistic( self, X: ArrayLike, @@ -390,8 +422,44 @@ def statistic( covariate_index: ArrayLike = None, metric="auc", test_size=0.2, + return_posteriors: bool = False, **metric_kwargs, ): + """Compute the test statistic. + + Parameters + ---------- + X : ArrayLike of shape (n_samples, n_features) + The data matrix. + y : ArrayLike of shape (n_samples, n_outputs) + The target matrix. + covariate_index : ArrayLike, optional of shape (n_covariates,) + The index array of covariates to shuffle, by default None. + metric : str, optional + The metric to compute, by default "auc". + test_size : float, optional + Proportion of samples per tree to use for the test set, by default 0.2. + return_posteriors : bool, optional + Whether or not to return the posteriors, by default False. + + Returns + ------- + stat : float + The test statistic. + posterior_final : ArrayLike of shape (n_samples_final, n_outputs), optional + If ``return_posteriors`` is True, then the posterior probabilities of the + samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` + if all samples are encountered in the test set of at least one tree in the + posterior computation. + samples : ArrayLike of shape (n_samples_final,), optional + The indices of the samples used in the final test. ``n_samples_final`` is + equal to ``n_samples`` if all samples are encountered in the test set of at + least one tree in the posterior computation. + """ + X, y = check_X_y(X, y, ensure_2d=True, multi_output=True) + if y.ndim != 2: + y = y.reshape(-1, 1) + if covariate_index is None: estimator = self.estimator else: @@ -405,6 +473,7 @@ def statistic( covariate_index=covariate_index, metric=metric, test_size=test_size, + return_posteriors=return_posteriors, **metric_kwargs, ) @@ -416,51 +485,107 @@ def test( metric: str = "auc", test_size: float = 0.2, n_repeats: int = 1000, + return_posteriors: bool = False, **metric_kwargs, ): - # first compute the test statistic on the un-permuted data - observe_stat = self.statistic(X, y, metric=metric, test_size=test_size, **metric_kwargs) - - if self.method == "permutation": - # compute the null distribution by computing a second forest `n_repeats` times using - # permutations of the covariate - null_dist = np.array( - Parallel(n_jobs=self.n_jobs)( - [ - delayed(self.statistic)( - self, X, y, covariate_index, metric, test_size, **metric_kwargs - ) - for _ in range(n_repeats) - ] - ) - ) - elif self.method == "coleman": + """Perform hypothesis test using Coleman method. + + X is split into a training/testing split. Optionally, the covariate index + columns are shuffled. + + On the training dataset, two honest forests are trained and then the posterior + is estimated on the testing dataset. One honest forest is trained on the + permuted dataset and the other is trained on the original dataset. + + Finally, resample the posteriors of the two forests to compute the null + distribution of the statistics. + + Parameters + ---------- + X : ArrayLike of shape (n_samples, n_features) + The data matrix. + y : ArrayLike of shape (n_samples, n_outputs) + The target matrix. + covariate_index : ArrayLike, optional of shape (n_covariates,) + The index array of covariates to shuffle, by default None. + metric : str, optional + The metric to compute, by default "auc". + test_size : float, optional + Proportion of samples per tree to use for the test set, by default 0.2. + n_repeats : int, optional + Number of times to sample the null distribution, by default 1000. + return_posteriors : bool, optional + Whether or not to return the posteriors, by default False. + + Returns + ------- + stat : float + The test statistic. + pval : float + The p-value of the test statistic. + """ + X, y = check_X_y(X, y, ensure_2d=True, copy=True, multi_output=True) + if y.ndim != 2: + y = y.reshape(-1, 1) + + if not hasattr(self, "samples_"): # first compute the test statistic on the un-permuted data - permute_stat = self.statistic( + observe_stat, observe_posteriors, observe_samples = self.statistic( X, y, - covariate_index=covariate_index, + covariate_index=None, metric=metric, test_size=test_size, + return_posteriors=True, **metric_kwargs, ) + else: + observe_samples = self.samples_ + observe_posteriors = self.posterior_final_ + observe_stat = self.stat_ - # XXX: make sure train/test split before everything; rn there is prolly data leakage - metric_star, metric_star_pi = _compute_null_distribution_coleman( - X, - y, - self.estimator, - self.permuted_estimator_, - metric=metric, - n_repeats=n_repeats, - seed=self.random_state, - ) - # metric^\pi - metric - observe_stat = permute_stat - observe_stat + # next permute the data + permute_stat, permute_posteriors, permute_samples = self.statistic( + X, + y, + covariate_index=covariate_index, + metric=metric, + test_size=test_size, + return_posteriors=True, + **metric_kwargs, + ) + + # Note: at this point, both `estimator` and `permuted_estimator_` should + # have been fitted already, so we can now compute on the null by resampling + # the posteriors and computing the test statistic on the resampled posteriors + metric_star, metric_star_pi = _compute_null_distribution_coleman( + X_test=X, + y_test=y, + y_pred_proba_normal=observe_posteriors, + y_pred_proba_perm=permute_posteriors, + normal_samples=observe_samples, + perm_samples=permute_samples, + metric=metric, + n_repeats=n_repeats, + seed=self.random_state, + ) + print(observe_posteriors) + print(permute_posteriors) + # metric^\pi - metric + observe_stat = permute_stat - observe_stat - # metric^\pi_j - metric_j - null_dist = metric_star_pi - metric_star + # metric^\pi_j - metric_j + null_dist = metric_star_pi - metric_star pval = _pvalue(observe_stat=observe_stat, permuted_stat=null_dist, correction=True) + + if return_posteriors: + self.observe_posteriors_ = observe_posteriors + self.permute_posteriors_ = permute_posteriors + self.observe_samples_ = observe_samples + self.permute_samples_ = permute_samples + self.null_dist_ = null_dist return observe_stat, pval + + diff --git a/sktree/stats/permutationforest.py b/sktree/stats/permutationforest.py new file mode 100644 index 000000000..37af8eef2 --- /dev/null +++ b/sktree/stats/permutationforest.py @@ -0,0 +1,420 @@ +import numpy as np +from joblib import Parallel, delayed +from numpy.typing import ArrayLike +from sklearn.base import MetaEstimatorMixin +from sklearn.utils.validation import _is_fitted + +from ..ensemble import HonestForestClassifier +from .utils import METRIC_FUNCTIONS, _pvalue + + +class PermutationForest(MetaEstimatorMixin): + """Hypothesis testing with a permutation forest. + + This implements permutation testing of a null hypothesis using a random forest. + The null hypothesis is generated by permuting ``n_repeats`` times the covariate + indices and then a random forest is trained for each permuted instance. This + is compared to the original random forest that was computed on the regular + non-permuted data. + + Parameters + ---------- + n_estimators : int, default=100 + The number of trees in the forest. + + criterion : {"gini", "entropy"}, default="gini" + The function to measure the quality of a split. Supported criteria are + "gini" for the Gini impurity and "entropy" for the information gain. + Note: this parameter is tree-specific. + + splitter : {"best", "random"}, default="best" + The strategy used to choose the split at each node. Supported + strategies are "best" to choose the best split and "random" to choose + the best random split. + + max_depth : int, default=None + The maximum depth of the tree. If None, then nodes are expanded until + all leaves are pure or until all leaves contain less than + min_samples_split samples. + + min_samples_split : int or float, default=2 + The minimum number of samples required to split an internal node: + + - If int, then consider `min_samples_split` as the minimum number. + - If float, then `min_samples_split` is a fraction and + `ceil(min_samples_split * n_samples)` are the minimum + number of samples for each split. + + min_samples_leaf : int or float, default=1 + The minimum number of samples required to be at a leaf node. + A split point at any depth will only be considered if it leaves at + least ``min_samples_leaf`` training samples in each of the left and + right branches. This may have the effect of smoothing the model, + especially in regression. + + - If int, then consider `min_samples_leaf` as the minimum number. + - If float, then `min_samples_leaf` is a fraction and + `ceil(min_samples_leaf * n_samples)` are the minimum + number of samples for each node. + + min_weight_fraction_leaf : float, default=0.0 + The minimum weighted fraction of the sum total of weights (of all + the input samples) required to be at a leaf node. Samples have + equal weight when sample_weight is not provided. + + max_features : {"sqrt", "log2", None}, int or float, default="sqrt" + The number of features to consider when looking for the best split: + + - If int, then consider `max_features` features at each split. + - If float, then `max_features` is a fraction and + `round(max_features * n_features)` features are considered at each + split. + - If "auto", then `max_features=sqrt(n_features)`. + - If "sqrt", then `max_features=sqrt(n_features)`. + - If "log2", then `max_features=log2(n_features)`. + - If None, then `max_features=n_features`. + + Note: the search for a split does not stop until at least one + valid partition of the node samples is found, even if it requires to + effectively inspect more than ``max_features`` features. + + max_leaf_nodes : int, default=None + Grow trees with ``max_leaf_nodes`` in best-first fashion. + Best nodes are defined as relative reduction in impurity. + If None then unlimited number of leaf nodes. + + min_impurity_decrease : float, default=0.0 + A node will be split if this split induces a decrease of the impurity + greater than or equal to this value. + + The weighted impurity decrease equation is the following:: + + N_t / N * (impurity - N_t_R / N_t * right_impurity + - N_t_L / N_t * left_impurity) + + where ``N`` is the total number of samples, ``N_t`` is the number of + samples at the current node, ``N_t_L`` is the number of samples in the + left child, and ``N_t_R`` is the number of samples in the right child. + + ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, + if ``sample_weight`` is passed. + + bootstrap : bool, default=True + Whether bootstrap samples are used when building trees. If False, the + whole dataset is used to build each tree. + + oob_score : bool, default=False + Whether to use out-of-bag samples to estimate the generalization score. + Only available if bootstrap=True. + + n_jobs : int, default=None + The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`, + :meth:`decision_path` and :meth:`apply` are all parallelized over the + trees. ``None`` means 1 unless in a `joblib.parallel_backend` + context. ``-1`` means using all processors. See :term:`Glossary + ` for more details. + + random_state : int, RandomState instance or None, default=None + Controls both the randomness of the bootstrapping of the samples used + when building trees (if ``bootstrap=True``) and the sampling of the + features to consider when looking for the best split at each node + (if ``max_features < n_features``). + See :term:`Glossary ` for details. + + verbose : int, default=0 + Controls the verbosity when fitting and predicting. + + warm_start : bool, default=False + When set to ``True``, reuse the solution of the previous call to fit + and add more estimators to the ensemble, otherwise, just fit a whole + new forest. See :term:`the Glossary `. + + class_weight : {"balanced", "balanced_subsample"}, dict or list of dicts, \ + default=None + Weights associated with classes in the form ``{class_label: weight}``. + If not given, all classes are supposed to have weight one. For + multi-output problems, a list of dicts can be provided in the same + order as the columns of y. + + Note that for multioutput (including multilabel) weights should be + defined for each class of every column in its own dict. For example, + for four-class multilabel classification weights should be + [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of + [{1:1}, {2:5}, {3:1}, {4:1}]. + + The "balanced" mode uses the values of y to automatically adjust + weights inversely proportional to class frequencies in the input data + as ``n_samples / (n_classes * np.bincount(y))`` + + The "balanced_subsample" mode is the same as "balanced" except that + weights are computed based on the bootstrap sample for every tree + grown. + + For multi-output, the weights of each column of y will be multiplied. + + Note that these weights will be multiplied with sample_weight (passed + through the fit method) if sample_weight is specified. + + ccp_alpha : non-negative float, default=0.0 + Complexity parameter used for Minimal Cost-Complexity Pruning. The + subtree with the largest cost complexity that is smaller than + ``ccp_alpha`` will be chosen. By default, no pruning is performed. See + :ref:`minimal_cost_complexity_pruning` for details. + + max_samples : int or float, default=None + If bootstrap is True, the number of samples to draw from X + to train each base tree estimator. + + - If None (default), then draw `X.shape[0]` samples. + - If int, then draw `max_samples` samples. + - If float, then draw `max_samples * X.shape[0]` samples. Thus, + `max_samples` should be in the interval `(0.0, 1.0]`. + + honest_prior : {"ignore", "uniform", "empirical"}, default="empirical" + Method for dealing with empty leaves during evaluation of a test + sample. If "ignore", the tree is ignored. If "uniform", the prior tree + posterior is 1/(number of classes). If "empirical", the prior tree + posterior is the relative class frequency in the voting subsample. + If all trees are ignored, the empirical estimate is returned. + + honest_fraction : float, default=0.5 + Fraction of training samples used for estimates in the trees. The + remaining samples will be used to learn the tree structure. A larger + fraction creates shallower trees with lower variance estimates. + + tree_estimator : object, default=None + Type of decision tree classifier to use. By default `None`, which + defaults to :class:`sklearn.tree.DecisionTreeClassifier`. + + Attributes + ---------- + samples_ : ArrayLike of shape (n_samples,) + The indices of the samples used in the final test. + + y_true_ : ArrayLike of shape (n_samples_final,) + The true labels of the samples used in the final test. + + posterior_ : ArrayLike of shape (n_samples_final, n_outputs) + The predicted posterior probabilities of the samples used in the final test. + + null_dist_ : ArrayLike of shape (n_repeats,) + The null distribution of the test statistic. + + posterior_null_ : ArrayLike of shape (n_samples_final, n_outputs, n_repeats) + The posterior probabilities of the samples used in the final test for each + permutation for the null distribution. + """ + + def __init__( + self, + n_estimators=100, + criterion="gini", + splitter="best", + max_depth=None, + min_samples_split=2, + min_samples_leaf=1, + min_weight_fraction_leaf=0.0, + max_features="sqrt", + max_leaf_nodes=None, + min_impurity_decrease=0.0, + bootstrap=False, + oob_score=False, + n_jobs=None, + random_state=None, + verbose=0, + warm_start=False, + class_weight=None, + ccp_alpha=0.0, + max_samples=None, + honest_prior="empirical", + honest_fraction=0.5, + tree_estimator=None, + ): + self.estimator = HonestForestClassifier( + n_estimators=n_estimators, + criterion=criterion, + splitter=splitter, + max_depth=max_depth, + min_samples_split=min_samples_split, + min_samples_leaf=min_samples_leaf, + min_weight_fraction_leaf=min_weight_fraction_leaf, + max_features=max_features, + max_leaf_nodes=max_leaf_nodes, + min_impurity_decrease=min_impurity_decrease, + bootstrap=bootstrap, + oob_score=oob_score, + n_jobs=n_jobs, + random_state=random_state, + verbose=verbose, + warm_start=warm_start, + class_weight=class_weight, + ccp_alpha=ccp_alpha, + max_samples=max_samples, + honest_prior=honest_prior, + honest_fraction=honest_fraction, + tree_estimator=tree_estimator, + ) + self.n_jobs = n_jobs + self.n_estimators = n_estimators + self.criterion = criterion + self.splitter = splitter + self.max_depth = max_depth + self.min_samples_split = min_samples_split + self.min_samples_leaf = min_samples_leaf + self.min_weight_fraction_leaf = min_weight_fraction_leaf + self.max_features = max_features + self.max_leaf_nodes = max_leaf_nodes + self.min_impurity_decrease = min_impurity_decrease + self.bootstrap = bootstrap + self.oob_score = oob_score + self.random_state = random_state + self.verbose = verbose + self.warm_start = warm_start + self.class_weight = class_weight + self.ccp_alpha = ccp_alpha + self.max_samples = max_samples + self.honest_prior = honest_prior + self.honest_fraction = honest_fraction + self.tree_estimator = tree_estimator + + def statistic( + self, + X: ArrayLike, + y: ArrayLike, + covariate_index: ArrayLike = None, + metric="auc", + test_size=0.2, + return_posteriors: bool = False, + **metric_kwargs, + ): + """Compute the test statistic. + + Parameters + ---------- + X : ArrayLike of shape (n_samples, n_features) + The data matrix. + y : ArrayLike of shape (n_samples, n_outputs) + The target matrix. + covariate_index : ArrayLike, optional of shape (n_covariates,) + The index array of covariates to shuffle, by default None. + metric : str, optional + The metric to compute, by default "auc". + test_size : float, optional + Proportion of samples per tree to use for the test set, by default 0.2. + return_posteriors : bool, optional + Whether or not to return the posteriors, by default False. + + Returns + ------- + stat : float + The test statistic. + posterior_final : ArrayLike of shape (n_samples_final, n_outputs), optional + If ``return_posteriors`` is True, then the posterior probabilities of the + samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` + if all samples are encountered in the test set of at least one tree in the + posterior computation. + samples : ArrayLike of shape (n_samples_final,), optional + The indices of the samples used in the final test. ``n_samples_final`` is + equal to ``n_samples`` if all samples are encountered in the test set of at + least one tree in the posterior computation. + """ + rng = np.random.default_rng(self.random_state) + metric_func = METRIC_FUNCTIONS[metric] + + # first run a dummy fit on just two samples to initialize the + # internal data structure of the forest + if not _is_fitted(self.estimator): + self.estimator.fit(X[:2], y[:2]) + + # Fit each tree and ompute posteriors with train test splits + posterior = Parallel(n_jobs=self.n_jobs)( + delayed(tree_posterior)( + tree, X, y, covariate_index=covariate_index, test_size=test_size + ) + for tree in self.estimator.estimators_ + ) + + # Average all posteriors + posterior_final = np.nanmean(posterior, axis=0) + samples = np.argwhere(~np.isnan(posterior_final).any(axis=1))[0] + y_true_final = y[samples, :] + posterior_final = posterior_final[samples, :] + stat = metric_func(y_true=y_true_final, y_pred=posterior_final, **metric_kwargs) + + # Cache the original test statistic + if covariate_index is None: + self.samples_ = samples + self.y_true_ = y_true_final + self.stat_ = stat + self.posterior_ = posterior_final + + if return_posteriors: + return stat, posterior_final, samples + return stat + + def test( + self, + X: ArrayLike, + y: ArrayLike, + covariate_index: ArrayLike, + metric: str = "auc", + test_size: float = 0.2, + n_repeats: int = 1000, + return_posteriors: bool = False, + **metric_kwargs, + ): + """Perform hypothesis test using permutation testing. + + Parameters + ---------- + X : ArrayLike of shape (n_samples, n_features) + The data matrix. + y : ArrayLike of shape (n_samples, n_outputs) + The target matrix. + covariate_index : ArrayLike of shape (n_covariates,) + The covariate indices of ``X`` to shuffle. + metric : str, optional + Metric to compute, by default "auc". + test_size : float, optional + Size of the samples to leave out for each tree to compute posteriors on, + by default 0.2. + n_repeats : int, optional + Number of times to sample the null distribution, by default 1000. + + Returns + ------- + observe_stat : float + Observed test statistic. + pvalue : float + p-value of the test. + """ + # compute original test statistic + observe_stat = self.statistic(X, y, covariate_index, metric, test_size, **metric_kwargs) + + # compute null distribution of the test statistic + # WARNING: this could take a long time, since it fits a new forest + null_dist = np.array( + Parallel(n_jobs=self.n_jobs)( + [ + delayed(self.statistic)( + self, + X, + y, + covariate_index, + metric, + test_size, + return_posteriors, + **metric_kwargs, + ) + for _ in range(n_repeats) + ] + ) + ) + if not return_posteriors: + self.null_dist_ = null_dist + else: + self.null_dist_ = null_dist[0] + self.posterior_null_ = null_dist[1] + + pvalue = _pvalue(observe_stat=observe_stat, permuted_stat=null_dist, correction=True) + return observe_stat, pvalue diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 0cb36bc26..7a45cd19c 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -1,6 +1,26 @@ import numpy as np - +from scipy.special import expit +import pytest from sktree.stats.forestht import ForestHT +from sklearn import datasets + +from sktree._lib.sklearn.tree import DecisionTreeClassifier +from sktree.stats import MIGHT +from sktree.tree import ObliqueDecisionTreeClassifier, PatchObliqueDecisionTreeClassifier + +# load the iris dataset +# and randomly permute it +iris = datasets.load_iris() +rng = np.random.RandomState(1) + +# remove third class +iris_X = iris.data[iris.target != 2] +iris_y = iris.target[iris.target != 2] + +p = rng.permutation(iris_X.shape[0]) +iris_X = iris_X[p] +iris_y = iris_y[p] + seed = 12345 @@ -10,16 +30,18 @@ def test_iris(): def test_linear_model(): - """Test MIGHT using MSE from linear model simulation. + r"""Test MIGHT using MSE from linear model simulation. See https://arxiv.org/pdf/1904.07830.pdf Figure 1. - Y = Beta * X_1 + Beta * I(X_6 = 2) + epsilon + Y = Beta * X_1 + Beta * I(X_6 = 2) + \epsilon """ + # TODO: this requires us to implement the test using forestregressors + pass j = np.linspace(0.005, 2.25, 9)[0] beta = 10 sigma = 10 / j - n_samples = 2000 + n_samples = 20 n_estimators = 125 # subsample_size = np.power(n_samples, 0.6) @@ -27,7 +49,11 @@ def test_linear_model(): # sample covariates X_15 = rng.uniform(0, 1, size=(n_samples, 5)) - X_610 = rng.multinomial(1, [1.0 / 3, 1.0 / 3, 1.0 / 3], size=(n_samples, 5)) + X_610 = np.zeros((n_samples, 5)) + for idx in range(5): + X_610[:, idx] = np.argwhere( + rng.multinomial(1, [1.0 / 3, 1.0 / 3, 1.0 / 3], size=(n_samples,)) + )[:, 1] X = np.concatenate((X_15, X_610), axis=1) # sample noise @@ -53,11 +79,97 @@ def test_linear_model(): assert pvalue > 0.05 -def test_mars_model(): - """Test MIGHT using MSE from linear model simulation. +def test_correlated_logit_model(): + r"""Test MIGHT using MSE from linear model simulation. See https://arxiv.org/pdf/1904.07830.pdf Figure 1. - Y = Beta * X_1 + Beta * I(X_6 = 2) + epsilon + P(Y = 1 | X) = expit(beta * \\sum_{j=2}^5 X_j) """ - pass + beta = 15.0 + n_samples = 600 + n_estimators = 125 + n_jobs = -1 + + n = 100 # Number of time steps + ar_coefficient = 0.015 + rng = np.random.default_rng(seed) + test_size = 0.5 + + X = np.zeros((n_samples, n)) + for idx in range(n_samples): + # sample covariates + white_noise = rng.standard_normal(size=n) + + # Create an array to store the simulated AR(1) time series + ar1_series = np.zeros(n) + ar1_series[0] = white_noise[0] + + # Simulate the AR(1) process + for t in range(1, n): + ar1_series[t] = ar_coefficient * ar1_series[t - 1] + white_noise[t] + + X[idx, :] = ar1_series + + # now compute the output labels + y_proba = expit(beta * X[:, 1:5].sum(axis=1)) + assert y_proba.shape == (n_samples,) + y = rng.binomial(1, y_proba, size=n_samples) # .reshape(-1, 1) + + est = ForestHT(max_features=n, random_state=seed, n_estimators=n_estimators, n_jobs=n_jobs) + + # test for X_2 important + stat, pvalue = est.test(X, y, [1], test_size=test_size, metric="mse") + print(pvalue) + assert pvalue < 0.6, f"pvalue: {pvalue}" + + # test for X_1 + stat, pvalue = est.test(X, y, [0], metric="mse") + print(pvalue) + assert pvalue > 0.9, f"pvalue: {pvalue}" + + # test for X_500 + stat, pvalue = est.test(X, y, [n - 1], metric="mse") + print(pvalue) + assert pvalue > 0.9, f"pvalue: {pvalue}" + + +@pytest.mark.parametrize("criterion", ["gini", "entropy"]) +@pytest.mark.parametrize("max_features", [None, 'sqrt']) +@pytest.mark.parametrize("honest_prior", ["empirical", "uniform", "ignore"]) +@pytest.mark.parametrize( + "estimator", + [ + None, + DecisionTreeClassifier(), + ObliqueDecisionTreeClassifier(), + ], +) +@pytest.mark.parametrize("limit", [0.05, 0.1]) +def test_iris_pauc(criterion, max_features, honest_prior, estimator, limit): + # Check consistency on dataset iris. + clf = ForestHT( + criterion=criterion, + random_state=0, + max_features=max_features, + n_estimators=100, + honest_prior=honest_prior, + tree_estimator=estimator, + ) + score = clf.statistic(iris_X, iris_y, metric="auc", max_fpr=limit) + assert score >= 0.9, "Failed with pAUC: {0} for max fpr: {1}".format(score, limit) + + # now add completely uninformative feature + X = np.hstack((iris_X, rng.standard_normal(size=(iris_X.shape[0], 1)))) + + # test for unimportant feature + test_size = 0.2 + clf.reset() + stat, pvalue = clf.test(X, iris_y, [X.shape[1] - 1], test_size=test_size, metric="auc") + print(pvalue) + # assert pvalue > 0.05, f"pvalue: {pvalue}" + + stat, pvalue = clf.test(X, iris_y, [2, 3], test_size=test_size, metric="auc") + print(pvalue) + # assert pvalue < 0.05, f"pvalue: {pvalue}" + assert False \ No newline at end of file diff --git a/sktree/stats/utils.py b/sktree/stats/utils.py index 9bc196d36..baa3e1c42 100644 --- a/sktree/stats/utils.py +++ b/sktree/stats/utils.py @@ -4,7 +4,7 @@ from numpy.typing import ArrayLike from scipy.stats import entropy from sklearn.metrics import mean_squared_error, roc_auc_score -from sklearn.utils.validation import check_is_fitted, check_X_y +from sklearn.utils.validation import check_X_y from sktree._lib.sklearn.ensemble._forest import ForestClassifier @@ -107,8 +107,10 @@ def compute_null_distribution_perm( def _compute_null_distribution_coleman( X_test: ArrayLike, y_test: ArrayLike, - forest: ForestClassifier, - perm_forest: ForestClassifier, + y_pred_proba_normal: ArrayLike, + y_pred_proba_perm: ArrayLike, + normal_samples: ArrayLike, + perm_samples: ArrayLike, metric: str = "mse", n_repeats: int = 1000, seed: int = None, @@ -123,10 +125,14 @@ def _compute_null_distribution_coleman( The data matrix. y_test : ArrayLike of shape (n_samples, n_outputs) The output matrix. - forest : ForestClassifier - A trained forest on the original data. - perm_forest : ForestClassifier - A trained forest on the permuted data. + y_pred_proba_normal : ArrayLike of shape (n_samples_normal, n_outputs) + The predicted posteriors from the normal forest. + y_pred_proba_perm : ArrayLike of shape (n_samples_perm, n_outputs) + The predicted posteriors from the permuted forest. + normal_samples : ArrayLike of shape (n_samples_normal,) + The indices of the normal samples that we have a posterior for. + perm_samples : ArrayLike of shape (n_samples_perm,) + The indices of the permuted samples that we have a posterior for. metric : str, optional The metric, which to compute the null distribution of statistics, by default 'mse'. n_repeats : int, optional @@ -142,33 +148,37 @@ def _compute_null_distribution_coleman( An array of the metrics computed on the other half of the trees. """ rng = np.random.default_rng(seed) - check_is_fitted(forest) - check_is_fitted(perm_forest) - X_test, y_test = check_X_y(X_test, y_test, ensure_2d=True) + # X_test, y_test = check_X_y(X_test, y_test, copy=True, ensure_2d=True, multi_output=True) metric_func = METRIC_FUNCTIONS[metric] # sample two sets of equal number of trees from the combined forest - y_pred_proba_normal = forest.predict_proba(X_test) - y_pred_proba_perm = perm_forest.predict_proba(X_test) all_y_pred = np.concatenate((y_pred_proba_normal, y_pred_proba_perm), axis=0) - n_samples = len(y_test) + # get the indices of the samples that we have a posterior for, so each element + # is an index into `y_test` + all_samples_pred = np.concatenate((normal_samples, perm_samples), axis=0) + + n_samples_final = len(all_samples_pred) # pre-allocate memory for the index array - index_arr = np.arange(n_samples * 2, dtype=int) + index_arr = np.arange(n_samples_final, dtype=int) metric_star = np.zeros((n_repeats,)) metric_star_pi = np.zeros((n_repeats,)) for idx in range(n_repeats): # two sets of random indices from 1 : 2N are sampled using Fisher-Yates rng.shuffle(index_arr) - first_half_index = index_arr[:n_samples] - second_half_index = index_arr[n_samples:] + first_half_index = index_arr[: n_samples_final // 2] + second_half_index = index_arr[n_samples_final // 2 :] + + # now get the pointers to the actual samples used for the metric + y_test_first_half = y_test[all_samples_pred[first_half_index]] + y_test_second_half = y_test[all_samples_pred[second_half_index]] # compute two instances of the metric from the sampled trees - first_half_metric = metric_func(y_true=y_test, y_pred=all_y_pred[first_half_index]) - second_half_metric = metric_func(y_true=y_test, y_pred=all_y_pred[second_half_index]) + first_half_metric = metric_func(y_test_first_half, all_y_pred[first_half_index]) + second_half_metric = metric_func(y_test_second_half, all_y_pred[second_half_index]) metric_star[idx] = first_half_metric metric_star_pi[idx] = second_half_metric From 1a5ebe32ba3e8803540078957ad0ec9e18e5cd07 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 13 Sep 2023 22:32:56 -0400 Subject: [PATCH 13/70] Linear model not working? Signed-off-by: Adam Li --- benchmarks_nonasv/bench_forestht.py | 22 ++ sktree/stats/__init__.py | 2 +- sktree/stats/forestht.py | 583 +++++++++++++++++++++++++++- sktree/stats/tests/test_forestht.py | 65 ++-- sktree/stats/utils.py | 10 +- 5 files changed, 644 insertions(+), 38 deletions(-) create mode 100644 benchmarks_nonasv/bench_forestht.py diff --git a/benchmarks_nonasv/bench_forestht.py b/benchmarks_nonasv/bench_forestht.py new file mode 100644 index 000000000..88207b309 --- /dev/null +++ b/benchmarks_nonasv/bench_forestht.py @@ -0,0 +1,22 @@ +"""The following functions reproduce the results from the paper, :footcite:`coleman2022scalable`. + +Specifically, the simulations for model 1, 2, 3 and 4 are reproduced. + +.. note:: This script will take a long time to run, since a power curve is generated. +""" + +def linear_model_ancova(): + pass + +def linear_model_mars(): + pass + +def correlated_logit_model(): + pass + + +def random_forest_model(): + pass + +if __name__ == "__main__": + pass diff --git a/sktree/stats/__init__.py b/sktree/stats/__init__.py index 77cdb9372..da54ef020 100644 --- a/sktree/stats/__init__.py +++ b/sktree/stats/__init__.py @@ -1,2 +1,2 @@ from ._might import MIGHT, MIGHT_MV -from .forestht import ForestHT +from .forestht import ForestHT, HyppoForestRegressor diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 8fdbddee4..3b8317710 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -4,11 +4,50 @@ from sklearn.model_selection import train_test_split from sklearn.utils.validation import _is_fitted, check_X_y -from sktree._lib.sklearn.ensemble._forest import ForestClassifier -from sktree._lib.sklearn.tree import DecisionTreeClassifier +from sktree._lib.sklearn.ensemble._forest import ( + ForestClassifier, + ForestRegressor, + RandomForestRegressor, +) +from sktree._lib.sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor from ..ensemble import HonestForestClassifier -from .utils import METRIC_FUNCTIONS, _compute_null_distribution_coleman, _pvalue +from .utils import METRIC_FUNCTIONS, REGRESSOR_METRICS, _compute_null_distribution_coleman, _pvalue + + +def train_tree( + tree: DecisionTreeClassifier, + X: ArrayLike, + y: ArrayLike, + covariate_index: ArrayLike = None, +) -> ArrayLike: + """Compute the posterior from each tree on the "OOB" samples. + + Parameters + ---------- + tree : DecisionTreeClassifier + The tree to compute the posterior from. + X : ArrayLike of shape (n_samples, n_features) + The data matrix. + y : ArrayLike of shape (n_samples, n_outputs) + The output matrix. + covariate_index : ArrayLike of shape (n_covariates,), optional + The indices of the covariates to permute, by default None, which + does not permute any columns. + """ + # seed the random number generator using each tree's random seed(?) + rng = np.random.default_rng(tree.random_state) + + indices = np.arange(X.shape[0]) + + if covariate_index is not None: + # perform permutation of covariates + index_arr = rng.choice(indices, size=(X.shape[0], 1), replace=False, shuffle=False) + perm_X_cov = X[index_arr, covariate_index] + X[:, covariate_index] = perm_X_cov + + # individual tree permutation of y labels + tree.fit(X, y, check_input=False) def tree_posterior( @@ -362,11 +401,17 @@ def _statistic( for idx in range(self.n_estimators): seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32) indices_train, indices_test = train_test_split( - indices, test_size=test_size, stratify=y, shuffle=True, - random_state=seed + indices, test_size=test_size, stratify=y, shuffle=True, random_state=seed ) tree = estimator.estimators_[idx] - tree_posterior(tree, X[indices_train, :], y[indices_train, :], covariate_index, test_size, seed=seed) + tree_posterior( + tree, + X[indices_train, :], + y[indices_train, :], + covariate_index, + test_size, + seed=seed, + ) y_pred = tree.predict_proba(X[indices_test, :]) @@ -383,15 +428,14 @@ def _statistic( if metric == "auc": if posterior_final.shape[1] != 2: raise ValueError( - "AUC only supports binary classification. " - "Please use a different metric." + "AUC only supports binary classification. " "Please use a different metric." ) print(posterior_final[:5, :]) # get posteriors of the positive class posterior_final = posterior_final[:, 1] - - print('Y true: ', y_true_final) - print('posterior: ', posterior_final) + + print("Y true: ", y_true_final) + print("posterior: ", posterior_final) stat = metric_func(y_true_final, posterior_final, **metric_kwargs) if covariate_index is None: @@ -459,7 +503,7 @@ def statistic( X, y = check_X_y(X, y, ensure_2d=True, multi_output=True) if y.ndim != 2: y = y.reshape(-1, 1) - + if covariate_index is None: estimator = self.estimator else: @@ -589,3 +633,518 @@ def test( return observe_stat, pval +class HyppoForestRegressor(MetaEstimatorMixin): + """Forest hypothesis testing with continuous `y` variable. + + Parameters + ---------- + n_estimators : int, default=100 + The number of trees in the forest. + + criterion : {"gini", "entropy"}, default="gini" + The function to measure the quality of a split. Supported criteria are + "gini" for the Gini impurity and "entropy" for the information gain. + Note: this parameter is tree-specific. + + splitter : {"best", "random"}, default="best" + The strategy used to choose the split at each node. Supported + strategies are "best" to choose the best split and "random" to choose + the best random split. + + max_depth : int, default=None + The maximum depth of the tree. If None, then nodes are expanded until + all leaves are pure or until all leaves contain less than + min_samples_split samples. + + min_samples_split : int or float, default=2 + The minimum number of samples required to split an internal node: + + - If int, then consider `min_samples_split` as the minimum number. + - If float, then `min_samples_split` is a fraction and + `ceil(min_samples_split * n_samples)` are the minimum + number of samples for each split. + + min_samples_leaf : int or float, default=1 + The minimum number of samples required to be at a leaf node. + A split point at any depth will only be considered if it leaves at + least ``min_samples_leaf`` training samples in each of the left and + right branches. This may have the effect of smoothing the model, + especially in regression. + + - If int, then consider `min_samples_leaf` as the minimum number. + - If float, then `min_samples_leaf` is a fraction and + `ceil(min_samples_leaf * n_samples)` are the minimum + number of samples for each node. + + min_weight_fraction_leaf : float, default=0.0 + The minimum weighted fraction of the sum total of weights (of all + the input samples) required to be at a leaf node. Samples have + equal weight when sample_weight is not provided. + + max_features : {"sqrt", "log2", None}, int or float, default="sqrt" + The number of features to consider when looking for the best split: + + - If int, then consider `max_features` features at each split. + - If float, then `max_features` is a fraction and + `round(max_features * n_features)` features are considered at each + split. + - If "auto", then `max_features=sqrt(n_features)`. + - If "sqrt", then `max_features=sqrt(n_features)`. + - If "log2", then `max_features=log2(n_features)`. + - If None, then `max_features=n_features`. + + Note: the search for a split does not stop until at least one + valid partition of the node samples is found, even if it requires to + effectively inspect more than ``max_features`` features. + + max_leaf_nodes : int, default=None + Grow trees with ``max_leaf_nodes`` in best-first fashion. + Best nodes are defined as relative reduction in impurity. + If None then unlimited number of leaf nodes. + + min_impurity_decrease : float, default=0.0 + A node will be split if this split induces a decrease of the impurity + greater than or equal to this value. + + The weighted impurity decrease equation is the following:: + + N_t / N * (impurity - N_t_R / N_t * right_impurity + - N_t_L / N_t * left_impurity) + + where ``N`` is the total number of samples, ``N_t`` is the number of + samples at the current node, ``N_t_L`` is the number of samples in the + left child, and ``N_t_R`` is the number of samples in the right child. + + ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, + if ``sample_weight`` is passed. + + bootstrap : bool, default=True + Whether bootstrap samples are used when building trees. If False, the + whole dataset is used to build each tree. + + oob_score : bool, default=False + Whether to use out-of-bag samples to estimate the generalization score. + Only available if bootstrap=True. + + n_jobs : int, default=None + The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`, + :meth:`decision_path` and :meth:`apply` are all parallelized over the + trees. ``None`` means 1 unless in a `joblib.parallel_backend` + context. ``-1`` means using all processors. See :term:`Glossary + ` for more details. + + random_state : int, RandomState instance or None, default=None + Controls both the randomness of the bootstrapping of the samples used + when building trees (if ``bootstrap=True``) and the sampling of the + features to consider when looking for the best split at each node + (if ``max_features < n_features``). + See :term:`Glossary ` for details. + + verbose : int, default=0 + Controls the verbosity when fitting and predicting. + + warm_start : bool, default=False + When set to ``True``, reuse the solution of the previous call to fit + and add more estimators to the ensemble, otherwise, just fit a whole + new forest. See :term:`the Glossary `. + + class_weight : {"balanced", "balanced_subsample"}, dict or list of dicts, \ + default=None + Weights associated with classes in the form ``{class_label: weight}``. + If not given, all classes are supposed to have weight one. For + multi-output problems, a list of dicts can be provided in the same + order as the columns of y. + + Note that for multioutput (including multilabel) weights should be + defined for each class of every column in its own dict. For example, + for four-class multilabel classification weights should be + [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of + [{1:1}, {2:5}, {3:1}, {4:1}]. + + The "balanced" mode uses the values of y to automatically adjust + weights inversely proportional to class frequencies in the input data + as ``n_samples / (n_classes * np.bincount(y))`` + + The "balanced_subsample" mode is the same as "balanced" except that + weights are computed based on the bootstrap sample for every tree + grown. + + For multi-output, the weights of each column of y will be multiplied. + + Note that these weights will be multiplied with sample_weight (passed + through the fit method) if sample_weight is specified. + + ccp_alpha : non-negative float, default=0.0 + Complexity parameter used for Minimal Cost-Complexity Pruning. The + subtree with the largest cost complexity that is smaller than + ``ccp_alpha`` will be chosen. By default, no pruning is performed. See + :ref:`minimal_cost_complexity_pruning` for details. + + max_samples : int or float, default=None + If bootstrap is True, the number of samples to draw from X + to train each base tree estimator. + + - If None (default), then draw `X.shape[0]` samples. + - If int, then draw `max_samples` samples. + - If float, then draw `max_samples * X.shape[0]` samples. Thus, + `max_samples` should be in the interval `(0.0, 1.0]`. + + Attributes + ---------- + samples_ : ArrayLike of shape (n_samples,) + The indices of the samples used in the final test. + + y_true_final_ : ArrayLike of shape (n_samples_final,) + The true labels of the samples used in the final test. + + posterior_final_ : ArrayLike of shape (n_samples_final,) + The predicted posterior probabilities of the samples used in the final test. + + null_dist_ : ArrayLike of shape (n_repeats,) + The null distribution of the test statistic. + """ + + def __init__( + self, + estimator=None, + n_estimators=100, + criterion="squared_error", + max_depth=None, + min_samples_split=2, + min_samples_leaf=1, + min_weight_fraction_leaf=0.0, + max_features="sqrt", + max_leaf_nodes=None, + min_impurity_decrease=0.0, + bootstrap=False, + oob_score=False, + n_jobs=None, + random_state=None, + verbose=0, + warm_start=False, + ccp_alpha=0.0, + max_samples=None, + permute_per_tree=True, + ): + self.estimator = estimator + self.n_jobs = n_jobs + self.n_estimators = n_estimators + self.criterion = criterion + self.max_depth = max_depth + self.min_samples_split = min_samples_split + self.min_samples_leaf = min_samples_leaf + self.min_weight_fraction_leaf = min_weight_fraction_leaf + self.max_features = max_features + self.max_leaf_nodes = max_leaf_nodes + self.min_impurity_decrease = min_impurity_decrease + self.bootstrap = bootstrap + self.oob_score = oob_score + self.random_state = random_state + self.verbose = verbose + self.warm_start = warm_start + self.ccp_alpha = ccp_alpha + self.max_samples = max_samples + self.permute_per_tree = permute_per_tree + + def _statistic( + self, + estimator: ForestClassifier, + X: ArrayLike, + y: ArrayLike, + covariate_index: ArrayLike = None, + metric="mse", + test_size=0.2, + return_posteriors: bool = False, + **metric_kwargs, + ): + """Helper function to compute the test statistic.""" + metric_func = METRIC_FUNCTIONS[metric] + rng = np.random.default_rng(self.random_state) + n_samples = X.shape[0] + indices = np.arange(n_samples, dtype=int) + + if self.permute_per_tree: + # first run a dummy fit on the samples to initialize the + # internal data structure of the forest + if not _is_fitted(estimator): + unique_y = np.unique(y) + X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) + estimator.fit(X_dummy, unique_y) + + # Fit each tree and compute posteriors with train test splits + posterior_arr = np.zeros((self.n_estimators, n_samples, estimator.n_outputs_)) + for idx in range(self.n_estimators): + seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32) + indices_train, indices_test = train_test_split( + indices, test_size=test_size, stratify=y, shuffle=True, random_state=seed + ) + tree: DecisionTreeRegressor = estimator.estimators_[idx] + train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) + + y_pred = tree.predict(X[indices_test, :]) + + # Fill test set posteriors & set rest NaN + posterior = np.full((y.shape[0], tree.n_outputs_), np.nan) + posterior[indices_test, :] = y_pred + posterior_arr[idx, ...] = posterior + + # Average all posteriors + posterior_final = np.nanmean(posterior_arr, axis=0) + samples = np.argwhere(~np.isnan(posterior_final).any(axis=1)).squeeze() + y_true_final = y[samples, :] + posterior_final = posterior_final[samples, :] + else: + if covariate_index is not None: + print("Permuting the covariate...") + # perform permutation of covariates + index_arr = rng.choice(indices, size=(X.shape[0], 1), replace=False, shuffle=False) + X[:, covariate_index] = X[index_arr, covariate_index] + + X_train, X_test = X[self.indices_train_, :], X[self.indices_test_, :] + y_train, y_test = y[self.indices_train_, :], y[self.indices_test_, :] + + estimator.fit(X_train, y_train) + y_pred = estimator.predict(X_test) + + # set variables to compute metric + samples = self.indices_test_ + y_true_final = y_test + posterior_final = y_pred + + # print('Y true: ', y_true_final) + # print('posterior: ', posterior_final) + stat = metric_func(y_true_final, posterior_final, **metric_kwargs) + + if covariate_index is None: + # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) + # arrays of y and predicted posterior + self.samples_ = samples + self.y_true_final_ = y_true_final + self.posterior_final_ = posterior_final + self.stat_ = stat + + if return_posteriors: + return stat, posterior_final, samples + + return stat + + def reset(self): + class_attributes = dir(type(self)) + instance_attributes = dir(self) + + for attr_name in instance_attributes: + if attr_name.endswith("_") and attr_name not in class_attributes: + delattr(self, attr_name) + + def statistic( + self, + X: ArrayLike, + y: ArrayLike, + covariate_index: ArrayLike = None, + metric="mse", + test_size=0.2, + return_posteriors: bool = False, + check_input: bool = True, + **metric_kwargs, + ): + """Compute the test statistic. + + Parameters + ---------- + X : ArrayLike of shape (n_samples, n_features) + The data matrix. + y : ArrayLike of shape (n_samples, n_outputs) + The target matrix. + covariate_index : ArrayLike, optional of shape (n_covariates,) + The index array of covariates to shuffle, by default None. + metric : str, optional + The metric to compute, by default "auc". + test_size : float, optional + Proportion of samples per tree to use for the test set, by default 0.2. + return_posteriors : bool, optional + Whether or not to return the posteriors, by default False. + + Returns + ------- + stat : float + The test statistic. + posterior_final : ArrayLike of shape (n_samples_final, n_outputs), optional + If ``return_posteriors`` is True, then the posterior probabilities of the + samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` + if all samples are encountered in the test set of at least one tree in the + posterior computation. + samples : ArrayLike of shape (n_samples_final,), optional + The indices of the samples used in the final test. ``n_samples_final`` is + equal to ``n_samples`` if all samples are encountered in the test set of at + least one tree in the posterior computation. + """ + if check_input: + X, y = check_X_y(X, y, ensure_2d=True, multi_output=True) + if y.ndim != 2: + y = y.reshape(-1, 1) + + if metric not in REGRESSOR_METRICS: + raise RuntimeError(f'Metric must be either "mse" or "mae", got {metric}') + + if not hasattr(self, "estimator_") and self.estimator is None: + self.estimator_ = RandomForestRegressor( + n_estimators=self.n_estimators, + criterion=self.criterion, + max_depth=self.max_depth, + min_samples_split=self.min_samples_split, + min_samples_leaf=self.min_samples_leaf, + min_weight_fraction_leaf=self.min_weight_fraction_leaf, + max_features=self.max_features, + max_leaf_nodes=self.max_leaf_nodes, + min_impurity_decrease=self.min_impurity_decrease, + bootstrap=self.bootstrap, + oob_score=self.oob_score, + n_jobs=self.n_jobs, + random_state=self.random_state, + verbose=self.verbose, + warm_start=self.warm_start, + ccp_alpha=self.ccp_alpha, + max_samples=self.max_samples, + ) + elif not isinstance(self.estimator_, ForestRegressor): + raise RuntimeError(f"Estimator must be a ForestRegressor, got {type(self.estimator_)}") + + if covariate_index is None: + estimator = self.estimator_ + else: + self.permuted_estimator_ = clone(self.estimator_) + estimator = self.permuted_estimator_ + + return self._statistic( + estimator, + X, + y, + covariate_index=covariate_index, + metric=metric, + test_size=test_size, + return_posteriors=return_posteriors, + **metric_kwargs, + ) + + def test( + self, + X, + y, + covariate_index: ArrayLike, + metric: str = "mse", + test_size: float = 0.2, + n_repeats: int = 1000, + return_posteriors: bool = False, + **metric_kwargs, + ): + """Perform hypothesis test using Coleman method. + + X is split into a training/testing split. Optionally, the covariate index + columns are shuffled. + + On the training dataset, two honest forests are trained and then the posterior + is estimated on the testing dataset. One honest forest is trained on the + permuted dataset and the other is trained on the original dataset. + + Finally, resample the posteriors of the two forests to compute the null + distribution of the statistics. + + Parameters + ---------- + X : ArrayLike of shape (n_samples, n_features) + The data matrix. + y : ArrayLike of shape (n_samples, n_outputs) + The target matrix. + covariate_index : ArrayLike, optional of shape (n_covariates,) + The index array of covariates to shuffle, by default None. + metric : str, optional + The metric to compute, by default "mse". + test_size : float, optional + Proportion of samples per tree to use for the test set, by default 0.2. + n_repeats : int, optional + Number of times to sample the null distribution, by default 1000. + return_posteriors : bool, optional + Whether or not to return the posteriors, by default False. + + Returns + ------- + stat : float + The test statistic. + pval : float + The p-value of the test statistic. + """ + X, y = check_X_y(X, y, ensure_2d=True, copy=True, multi_output=True) + if y.ndim != 2: + y = y.reshape(-1, 1) + + indices = np.arange(X.shape[0]) + if not self.permute_per_tree: + # train/test split + # XXX: could add stratifying by y when y is classification + indices_train, indices_test = train_test_split( + indices, test_size=test_size, shuffle=True + ) + self.indices_train_ = indices_train + self.indices_test_ = indices_test + + if not hasattr(self, "samples_"): + # first compute the test statistic on the un-permuted data + observe_stat, observe_posteriors, observe_samples = self.statistic( + X, + y, + covariate_index=None, + metric=metric, + test_size=test_size, + return_posteriors=True, + check_input=False, + **metric_kwargs, + ) + else: + observe_samples = self.samples_ + observe_posteriors = self.posterior_final_ + observe_stat = self.stat_ + + # next permute the data + permute_stat, permute_posteriors, permute_samples = self.statistic( + X, + y, + covariate_index=covariate_index, + metric=metric, + test_size=test_size, + return_posteriors=True, + check_input=False, + **metric_kwargs, + ) + + # Note: at this point, both `estimator` and `permuted_estimator_` should + # have been fitted already, so we can now compute on the null by resampling + # the posteriors and computing the test statistic on the resampled posteriors + metric_star, metric_star_pi = _compute_null_distribution_coleman( + X_test=X, + y_test=y, + y_pred_proba_normal=observe_posteriors, + y_pred_proba_perm=permute_posteriors, + normal_samples=observe_samples, + perm_samples=permute_samples, + metric=metric, + n_repeats=n_repeats, + seed=self.random_state, + ) + # print(observe_posteriors) + # print(permute_posteriors) + # metric^\pi - metric + observe_stat = permute_stat - observe_stat + + # metric^\pi_j - metric_j + null_dist = metric_star_pi - metric_star + + pval = _pvalue(observe_stat=observe_stat, permuted_stat=null_dist, correction=True) + + if return_posteriors: + self.observe_posteriors_ = observe_posteriors + self.permute_posteriors_ = permute_posteriors + self.observe_samples_ = observe_samples + self.permute_samples_ = permute_samples + + self.null_dist_ = null_dist + return observe_stat, pval diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 7a45cd19c..3c4e644eb 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -1,11 +1,11 @@ import numpy as np -from scipy.special import expit import pytest -from sktree.stats.forestht import ForestHT +from scipy.special import expit from sklearn import datasets from sktree._lib.sklearn.tree import DecisionTreeClassifier from sktree.stats import MIGHT +from sktree.stats.forestht import ForestHT, HyppoForestRegressor from sktree.tree import ObliqueDecisionTreeClassifier, PatchObliqueDecisionTreeClassifier # load the iris dataset @@ -25,6 +25,14 @@ seed = 12345 +def test_forestht_proper_attributes(): + """Forest HTs should have n_classes_ and n_outputs_ properly set. + + This requires the first dummy fit to always get all classes. + """ + pass + + def test_iris(): pass @@ -36,14 +44,13 @@ def test_linear_model(): Y = Beta * X_1 + Beta * I(X_6 = 2) + \epsilon """ - # TODO: this requires us to implement the test using forestregressors - pass - j = np.linspace(0.005, 2.25, 9)[0] - beta = 10 - sigma = 10 / j - n_samples = 20 + # j = np.linspace(0.005, 2.25, 9)[] + beta = 10.0 + sigma = 0.05 # / j + n_samples = 2500 n_estimators = 125 - # subsample_size = np.power(n_samples, 0.6) + test_size = 0.1 + # subsample_size = 0.8 rng = np.random.default_rng(seed) @@ -54,29 +61,41 @@ def test_linear_model(): X_610[:, idx] = np.argwhere( rng.multinomial(1, [1.0 / 3, 1.0 / 3, 1.0 / 3], size=(n_samples,)) )[:, 1] - X = np.concatenate((X_15, X_610), axis=1) + X = np.concatenate((X_15, X_610), axis=1, dtype=np.float32) + assert X.shape == (n_samples, 10) # sample noise - epsilon = rng.normal(size=n_samples, scale=sigma) + epsilon = rng.normal(size=n_samples, loc=0.0, scale=sigma) # compute final y of (n_samples,) - y = beta * X[:, 0] + beta * (X[:, 5] == 2) + epsilon - - est = ForestHT(random_state=seed, n_estimators=n_estimators) + y = beta * X[:, 0] + (beta * (X[:, 5] == 2.0)) + epsilon + est = HyppoForestRegressor( + max_features=1.0, + random_state=seed, + n_estimators=n_estimators, + n_jobs=-1, + permute_per_tree=False, + # bootstrap=True, max_samples=subsample_size + ) # test for X_1 - stat, pvalue = est.test(X, y, [0]) - assert pvalue < 0.05 + stat, pvalue = est.test(X, y, [0], test_size=test_size) + print(pvalue) + # assert pvalue < 0.05, f"pvalue: {pvalue}" # test for X_6 - stat, pvalue = est.test(X, y, [5]) - assert pvalue < 0.05 + stat, pvalue = est.test(X, y, [5], test_size=test_size) + print(pvalue) + # assert pvalue < 0.05, f"pvalue: {pvalue}" # test for a few unimportant other X - for covariate_index in [1, 2, 3]: + for covariate_index in [1, 6]: # test for X_2, X_3, X_4 - stat, pvalue = est.test(X, y, [covariate_index]) - assert pvalue > 0.05 + stat, pvalue = est.test(X, y, [covariate_index], test_size=test_size) + print(pvalue) + # assert pvalue > 0.05, f"pvalue: {pvalue}" + + assert False def test_correlated_logit_model(): @@ -135,7 +154,7 @@ def test_correlated_logit_model(): @pytest.mark.parametrize("criterion", ["gini", "entropy"]) -@pytest.mark.parametrize("max_features", [None, 'sqrt']) +@pytest.mark.parametrize("max_features", [None, "sqrt"]) @pytest.mark.parametrize("honest_prior", ["empirical", "uniform", "ignore"]) @pytest.mark.parametrize( "estimator", @@ -172,4 +191,4 @@ def test_iris_pauc(criterion, max_features, honest_prior, estimator, limit): stat, pvalue = clf.test(X, iris_y, [2, 3], test_size=test_size, metric="auc") print(pvalue) # assert pvalue < 0.05, f"pvalue: {pvalue}" - assert False \ No newline at end of file + assert False diff --git a/sktree/stats/utils.py b/sktree/stats/utils.py index baa3e1c42..94754bfb0 100644 --- a/sktree/stats/utils.py +++ b/sktree/stats/utils.py @@ -3,7 +3,7 @@ import numpy as np from numpy.typing import ArrayLike from scipy.stats import entropy -from sklearn.metrics import mean_squared_error, roc_auc_score +from sklearn.metrics import mean_absolute_error, mean_squared_error, roc_auc_score from sklearn.utils.validation import check_X_y from sktree._lib.sklearn.ensemble._forest import ForestClassifier @@ -16,7 +16,13 @@ def _mutual_information(y_true, y_pred): return max(H_Y - H_YX, 0) -METRIC_FUNCTIONS = {"mse": mean_squared_error, "auc": roc_auc_score, "mi": _mutual_information} +METRIC_FUNCTIONS = { + "mse": mean_squared_error, + "mae": mean_absolute_error, + "auc": roc_auc_score, + "mi": _mutual_information, +} +REGRESSOR_METRICS = ("mse", "mae") def _pvalue(observe_stat: float, permuted_stat: ArrayLike, correction: bool = True) -> float: From d8da658b8395b9528b2640d6319abb72678926c8 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Fri, 15 Sep 2023 11:19:40 -0400 Subject: [PATCH 14/70] Adding permutation forest that seems to work Signed-off-by: Adam Li --- README.md | 12 +- benchmarks_nonasv/bench_forestht.py | 155 +++- .../test_permutation_forest.ipynb | 385 +++++++++ sktree/conftest.py | 2 + sktree/meson.build | 1 + sktree/stats/__init__.py | 3 +- sktree/stats/forestht.py | 52 +- sktree/stats/meson.build | 1 + sktree/stats/permutationforest.py | 763 ++++++++++++++---- sktree/stats/tests/test_forestht.py | 104 +-- sktree/stats/utils.py | 81 +- sktree/tree/_classes.py | 2 +- 12 files changed, 1275 insertions(+), 286 deletions(-) create mode 100644 benchmarks_nonasv/test_permutation_forest.ipynb create mode 100644 sktree/conftest.py diff --git a/README.md b/README.md index 470641ef1..36e39fd02 100644 --- a/README.md +++ b/README.md @@ -13,11 +13,6 @@ scikit-tree is a scikit-learn compatible API for building state-of-the-art decis Tree-models have withstood the test of time, and are consistently used for modern-day data science and machine learning applications. They especially perform well when there are limited samples for a problem and are flexible learners that can be applied to a wide variety of different settings, such as tabular, images, time-series, genomics, EEG data and more. -We welcome contributions for modern tree-based algorithms. We use Cython to achieve fast C/C++ speeds, while abiding by a scikit-learn compatible (tested) API. Moreover, our Cython internals are easily extensible because they follow the internal Cython API of scikit-learn as well. - -Due to the current state of scikit-learn's internal Cython code for trees, we have to instead leverage a fork of scikit-learn at https://github.com/neurodata/scikit-learn when -extending the decision tree model API of scikit-learn. Specifically, we extend the Python and Cython API of the tree submodule in scikit-learn in our submodule, so we can introduce the tree models housed in this package. Thus these extend the functionality of decision-tree based models in a way that is not possible yet in scikit-learn itself. As one example, we introduce an abstract API to allow users to implement their own oblique splits. Our plan in the future is to benchmark these functionalities and introduce them upstream to scikit-learn where applicable and inclusion criterion are met. - Documentation ============= @@ -105,6 +100,13 @@ Alternatively, you can use editable installs pip install --no-build-isolation --editable . +Development +=========== +We welcome contributions for modern tree-based algorithms. We use Cython to achieve fast C/C++ speeds, while abiding by a scikit-learn compatible (tested) API. Moreover, our Cython internals are easily extensible because they follow the internal Cython API of scikit-learn as well. + +Due to the current state of scikit-learn's internal Cython code for trees, we have to instead leverage a fork of scikit-learn at https://github.com/neurodata/scikit-learn when +extending the decision tree model API of scikit-learn. Specifically, we extend the Python and Cython API of the tree submodule in scikit-learn in our submodule, so we can introduce the tree models housed in this package. Thus these extend the functionality of decision-tree based models in a way that is not possible yet in scikit-learn itself. As one example, we introduce an abstract API to allow users to implement their own oblique splits. Our plan in the future is to benchmark these functionalities and introduce them upstream to scikit-learn where applicable and inclusion criterion are met. + References ========== [1]: [`Li, Adam, et al. "Manifold Oblique Random Forests: Towards Closing the Gap on Convolutional Deep Networks" SIAM Journal on Mathematics of Data Science, 5(1), 77-96, 2023`](https://doi.org/10.1137/21M1449117) diff --git a/benchmarks_nonasv/bench_forestht.py b/benchmarks_nonasv/bench_forestht.py index 88207b309..c18bb9e8b 100644 --- a/benchmarks_nonasv/bench_forestht.py +++ b/benchmarks_nonasv/bench_forestht.py @@ -4,19 +4,164 @@ .. note:: This script will take a long time to run, since a power curve is generated. """ +from collections import defaultdict + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import seaborn as sns +from scipy.special import expit + +from sktree.stats import PermutationForestClassifier, PermutationForestRegressor + +seed = 12345 + + +def linear_model_ancova(sigma_factor=2.0, seed=None): + r"""Test MIGHT using MSE from linear model simulation. + + See https://arxiv.org/pdf/1904.07830.pdf Figure 1. + + Y = Beta * X_1 + Beta * I(X_6 = 2) + \epsilon + """ + beta = 10.0 + sigma = 10.0 / sigma_factor + n_samples = 2200 + n_estimators = 125 + test_size = 0.1 + + rng = np.random.default_rng(seed) + + # sample covariates + X_15 = rng.uniform(0, 1, size=(n_samples, 5)) + X_610 = np.zeros((n_samples, 5)) + for idx in range(5): + buff = np.argwhere(rng.multinomial(1, [1.0 / 3, 1.0 / 3, 1.0 / 3], size=n_samples))[:, 1] + + X_610[:, idx] = buff + + X = np.concatenate((X_15, X_610), axis=1) + assert X_15.shape == (n_samples, 5) + assert X_610.shape == (n_samples, 5) + assert X.shape == (n_samples, 10) + + # sample noise + epsilon = rng.normal(size=n_samples, loc=0.0, scale=sigma) + + # compute final y of (n_samples,) + y = beta * X[:, 0] + (beta * (X[:, 5] - 2)) + epsilon + + # initialize hypothesis tester + est = PermutationForestRegressor( + max_features=1.0, + random_state=seed, + n_estimators=n_estimators, + n_jobs=-1, + # bootstrap=True, + # max_samples=subsample_size + ) + pvalue_dict = {} + + # test for X_1 + stat, pvalue = est.test(X.copy(), y.copy(), [0], n_repeats=100, test_size=test_size) + print("X1: ", pvalue) + pvalue_dict["X1"] = pvalue + # assert pvalue < 0.05, f"pvalue: {pvalue}" + + # test for X_6 + stat, pvalue = est.test(X.copy(), y.copy(), [5], n_repeats=100, test_size=test_size) + print("X6: ", pvalue) + pvalue_dict["X6"] = pvalue + # assert pvalue < 0.05, f"pvalue: {pvalue}" + + # test for a few unimportant other X + for name, covariate_index in zip(["X2", "X7"], [1, 6]): + # test for X_2, X_7 + stat, pvalue = est.test( + X.copy(), y.copy(), [covariate_index], n_repeats=100, test_size=test_size + ) + print("X2/7: ", pvalue) + pvalue_dict[name] = pvalue + # assert pvalue > 0.05, f"pvalue: {pvalue}" + + return pvalue_dict -def linear_model_ancova(): - pass def linear_model_mars(): pass -def correlated_logit_model(): - pass + +def correlated_logit_model(beta=5.0, seed=None): + n_samples = 600 + n_estimators = 125 + n_jobs = -1 + max_features = 1.0 + test_size = 1.0 / 6 + metric = "mse" + n_repeats = 100 + + n = 500 # Number of time steps + ar_coefficient = 0.15 + + rng = np.random.default_rng(seed) + + X = np.zeros((n_samples, n)) + for idx in range(n_samples): + # sample covariates + white_noise = rng.standard_normal(size=n) + + # Create an array to store the simulated AR(1) time series + ar1_series = np.zeros(n) + ar1_series[0] = white_noise[0] + + # Simulate the AR(1) process + for t in range(1, n): + ar1_series[t] = ar_coefficient * ar1_series[t - 1] + white_noise[t] + + X[idx, :] = ar1_series + + # now compute the output labels + y_proba = expit(beta * X[:, 1:5].sum(axis=1)) + assert y_proba.shape == (n_samples,) + y = rng.binomial(1, y_proba, size=n_samples) # .reshape(-1, 1) + + est = PermutationForestClassifier( + max_features=max_features, random_state=seed, n_estimators=n_estimators, n_jobs=n_jobs + ) + + # test for X_2 important + stat, pvalue = est.test(X, y, [1], test_size=test_size, n_repeats=n_repeats, metric=metric) + print("X2: ", pvalue) + assert pvalue < 0.05, f"pvalue: {pvalue}" + + # test for X_1 unimportant + stat, pvalue = est.test(X, y, [0], test_size=test_size, n_repeats=n_repeats, metric=metric) + print("X1: ", pvalue) + assert pvalue > 0.05, f"pvalue: {pvalue}" + + # test for X_500 unimportant + stat, pvalue = est.test(X, y, [n - 1], test_size=test_size, n_repeats=n_repeats, metric=metric) + print("X500: ", pvalue) + assert pvalue > 0.05, f"pvalue: {pvalue}" def random_forest_model(): pass + if __name__ == "__main__": - pass + pvalue_dict = defaultdict(list) + rng = np.random.default_rng(seed) + + j_space = np.linspace(0.005, 2.25, 9) + + for sigma_factor in j_space: + for idx in range(10): + new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32) + + elements_dict = linear_model_ancova(sigma_factor, new_seed) + for key, value in elements_dict.items(): + pvalue_dict[key].append(value) + pvalue_dict["sigma_factor"].append(sigma_factor) + + df = pd.DataFrame(pvalue_dict) diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/test_permutation_forest.ipynb new file mode 100644 index 000000000..6cd8626d7 --- /dev/null +++ b/benchmarks_nonasv/test_permutation_forest.ipynb @@ -0,0 +1,385 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b658bdd8-a3e6-4051-9d66-f2a153113234", + "metadata": {}, + "outputs": [], + "source": [ + "from collections import defaultdict\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "from sktree.stats import HyppoForestRegressor, PermutationForest\n", + "\n", + "seed = 12345" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "05b0b53e-0525-45ce-9f7e-0322a30221cf", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5e2d1279-fa4f-47ef-aa48-fac6d47159ad", + "metadata": {}, + "outputs": [], + "source": [ + "def linear_model_ancova(sigma_factor=2.0, seed=None):\n", + " r\"\"\"Test MIGHT using MSE from linear model simulation.\n", + "\n", + " See https://arxiv.org/pdf/1904.07830.pdf Figure 1.\n", + "\n", + " Y = Beta * X_1 + Beta * I(X_6 = 2) + \\epsilon\n", + " \"\"\"\n", + " beta = 10.0\n", + " sigma = 10.0 / sigma_factor\n", + " n_samples = 2200\n", + " n_estimators = 125\n", + " test_size = 0.1\n", + "\n", + " rng = np.random.default_rng(seed)\n", + "\n", + " # sample covariates\n", + " X_15 = rng.uniform(0, 1, size=(n_samples, 5))\n", + " X_610 = np.zeros((n_samples, 5))\n", + " for idx in range(5):\n", + " buff = np.argwhere(\n", + " rng.multinomial(1, [1.0 / 3, 1.0 / 3, 1.0 / 3], size=n_samples)\n", + " )[:, 1]\n", + "\n", + " X_610[:, idx] = buff\n", + "\n", + " X = np.concatenate((X_15, X_610), axis=1)\n", + " assert X_15.shape == (n_samples, 5)\n", + " assert X_610.shape == (n_samples, 5)\n", + " assert X.shape == (n_samples, 10)\n", + "\n", + " # sample noise\n", + " epsilon = rng.normal(size=n_samples, loc=0.0, scale=sigma)\n", + "\n", + " # compute final y of (n_samples,)\n", + " y = beta * X[:, 0] + (beta * (X[:, 5] - 2)) + epsilon\n", + "\n", + " # initialize hypothesis tester\n", + " est = PermutationForest(\n", + " max_features=1.0,\n", + " random_state=seed,\n", + " n_estimators=n_estimators,\n", + " n_jobs=-1,\n", + " # bootstrap=True,\n", + " # max_samples=subsample_size\n", + " )\n", + " pvalue_dict = {}\n", + "\n", + " # test for X_1\n", + " stat, pvalue = est.test(X.copy(), y.copy(), [0], n_repeats=100, test_size=test_size)\n", + " print(\"X1: \", pvalue)\n", + " pvalue_dict[\"X1\"] = pvalue\n", + " # assert pvalue < 0.05, f\"pvalue: {pvalue}\"\n", + "\n", + " # test for X_6\n", + " stat, pvalue = est.test(X.copy(), y.copy(), [5], n_repeats=100, test_size=test_size)\n", + " print(\"X6: \", pvalue)\n", + " pvalue_dict[\"X6\"] = pvalue\n", + " # assert pvalue < 0.05, f\"pvalue: {pvalue}\"\n", + "\n", + " # test for a few unimportant other X\n", + " for name, covariate_index in zip([\"X2\", \"X7\"], [1, 6]):\n", + " # test for X_2, X_7\n", + " stat, pvalue = est.test(\n", + " X.copy(), y.copy(), [covariate_index], n_repeats=100, test_size=test_size\n", + " )\n", + " print(\"X2/7: \", pvalue)\n", + " pvalue_dict[name] = pvalue\n", + " # assert pvalue > 0.05, f\"pvalue: {pvalue}\"\n", + "\n", + " return pvalue_dict\n", + "\n", + "\n", + "def linear_model_mars():\n", + " pass\n", + "\n", + "\n", + "def correlated_logit_model():\n", + " pass\n", + "\n", + "\n", + "def random_forest_model():\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "14806903-933b-4e31-a2db-a3a45e0a6f82", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 0.7623762376237624\n", + "X6: 0.0891089108910891\n", + "X2/7: 0.8316831683168316\n", + "X2/7: 0.8712871287128713\n", + "X1: 0.9504950495049505\n", + "X6: 1.0\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.693069306930693\n", + "X6: 0.6039603960396039\n", + "X2/7: 0.39603960396039606\n", + "X2/7: 0.594059405940594\n", + "X1: 0.9306930693069307\n", + "X6: 0.9900990099009901\n", + "X2/7: 0.9801980198019802\n", + "X2/7: 1.0\n", + "X1: 0.36633663366336633\n", + "X6: 0.039603960396039604\n", + "X2/7: 0.7623762376237624\n", + "X2/7: 0.9603960396039604\n", + "X1: 0.21782178217821782\n", + "X6: 0.43564356435643564\n", + "X2/7: 0.6237623762376238\n", + "X2/7: 0.24752475247524752\n", + "X1: 0.42574257425742573\n", + "X6: 0.7425742574257426\n", + "X2/7: 0.44554455445544555\n", + "X2/7: 0.1188118811881188\n", + "X1: 0.36633663366336633\n", + "X6: 0.0297029702970297\n", + "X2/7: 0.13861386138613863\n", + "X2/7: 0.1485148514851485\n", + "X1: 0.9405940594059405\n", + "X6: 1.0\n", + "X2/7: 0.9207920792079208\n", + "X2/7: 1.0\n", + "X1: 0.504950495049505\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.5742574257425742\n", + "X2/7: 1.0\n", + "X1: 0.7128712871287128\n", + "X6: 0.2079207920792079\n", + "X2/7: 0.9306930693069307\n", + "X2/7: 1.0\n", + "X1: 0.26732673267326734\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.5742574257425742\n", + "X2/7: 0.13861386138613863\n", + "X1: 0.7722772277227723\n", + "X6: 0.900990099009901\n", + "X2/7: 0.9900990099009901\n", + "X2/7: 1.0\n", + "X1: 0.297029702970297\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.6633663366336634\n", + "X2/7: 0.009900990099009901\n", + "X1: 0.9702970297029703\n", + "X6: 0.6336633663366337\n", + "X2/7: 0.9900990099009901\n", + "X2/7: 1.0\n", + "X1: 0.16831683168316833\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.26732673267326734\n", + "X2/7: 0.019801980198019802\n", + "X1: 0.27722772277227725\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.24752475247524752\n", + "X2/7: 0.12871287128712872\n", + "X1: 0.16831683168316833\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.5742574257425742\n", + "X2/7: 0.21782178217821782\n", + "X1: 0.019801980198019802\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.09900990099009901\n", + "X2/7: 0.0594059405940594\n", + "X1: 0.2871287128712871\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.40594059405940597\n", + "X2/7: 1.0\n", + "X1: 0.5346534653465347\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.504950495049505\n", + "X2/7: 0.0891089108910891\n", + "X1: 0.16831683168316833\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.900990099009901\n", + "X2/7: 1.0\n", + "X1: 0.009900990099009901\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.009900990099009901\n", + "X2/7: 0.009900990099009901\n", + "X1: 0.019801980198019802\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.40594059405940597\n", + "X2/7: 0.039603960396039604\n", + "X1: 0.22772277227722773\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.6534653465346535\n", + "X2/7: 0.9504950495049505\n", + "X1: 0.009900990099009901\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.009900990099009901\n", + "X2/7: 0.009900990099009901\n", + "X1: 0.009900990099009901\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.09900990099009901\n", + "X2/7: 0.009900990099009901\n", + "X1: 0.5544554455445545\n", + "X6: 0.009900990099009901\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.019801980198019802\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.38613861386138615\n", + "X2/7: 1.0\n", + "X1: 0.0594059405940594\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.2079207920792079\n", + "X2/7: 0.33663366336633666\n", + "X1: 0.039603960396039604\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.6732673267326733\n", + "X2/7: 0.504950495049505\n", + "X1: 0.2079207920792079\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.7227722772277227\n", + "X2/7: 0.7623762376237624\n", + "X1: 0.009900990099009901\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.9801980198019802\n", + "X2/7: 1.0\n", + "X1: 0.009900990099009901\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.039603960396039604\n", + "X2/7: 0.13861386138613863\n", + "X1: 0.009900990099009901\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.8811881188118812\n", + "X2/7: 0.9504950495049505\n", + "X1: 0.009900990099009901\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.9405940594059405\n", + "X2/7: 0.45544554455445546\n", + "X1: 0.009900990099009901\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.1485148514851485\n", + "X2/7: 0.9900990099009901\n", + "X1: 0.009900990099009901\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.7128712871287128\n", + "X2/7: 0.019801980198019802\n", + "X1: 0.019801980198019802\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.9504950495049505\n", + "X2/7: 1.0\n", + "X1: 0.009900990099009901\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.8613861386138614\n", + "X2/7: 0.46534653465346537\n", + "X1: 0.009900990099009901\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.7227722772277227\n", + "X2/7: 0.019801980198019802\n", + "X1: 0.009900990099009901\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.9504950495049505\n", + "X2/7: 0.8118811881188119\n", + "X1: 0.009900990099009901\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.297029702970297\n", + "X2/7: 1.0\n", + "X1: 0.009900990099009901\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.7821782178217822\n", + "X2/7: 0.8613861386138614\n", + "X1: 0.0297029702970297\n", + "X6: 0.009900990099009901\n", + "X2/7: 0.9108910891089109\n", + "X2/7: 1.0\n" + ] + } + ], + "source": [ + "pvalue_dict = defaultdict(list)\n", + "rng = np.random.default_rng(seed)\n", + "\n", + "j_space = np.linspace(0.005, 2.25, 9)\n", + "\n", + "for sigma_factor in j_space:\n", + " for idx in range(5):\n", + " new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32)\n", + "\n", + " elements_dict = linear_model_ancova(sigma_factor, new_seed)\n", + " for key, value in elements_dict.items():\n", + " pvalue_dict[key].append(value)\n", + " pvalue_dict[\"sigma_factor\"].append(sigma_factor)\n", + "\n", + "df = pd.DataFrame(pvalue_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d3e21945-92b3-4ccc-8f29-b44f67d9cf33", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "done\n" + ] + } + ], + "source": [ + "print(\"done\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2bced31-0367-48a8-88e1-0afd6a60173f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "sktree", + "language": "python", + "name": "sktree" + }, + "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.9.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/sktree/conftest.py b/sktree/conftest.py new file mode 100644 index 000000000..037cecae6 --- /dev/null +++ b/sktree/conftest.py @@ -0,0 +1,2 @@ +def pytest_configure(config): + config.addinivalue_line("markers", "slowtest: mark test as slow") diff --git a/sktree/meson.build b/sktree/meson.build index 70b709920..8608052b8 100644 --- a/sktree/meson.build +++ b/sktree/meson.build @@ -54,6 +54,7 @@ cython_c_args += numpy_nodepr_api python_sources = [ '__init__.py', 'neighbors.py', + 'conftest.py', ] py3.install_sources( diff --git a/sktree/stats/__init__.py b/sktree/stats/__init__.py index da54ef020..b7301579c 100644 --- a/sktree/stats/__init__.py +++ b/sktree/stats/__init__.py @@ -1,2 +1,3 @@ from ._might import MIGHT, MIGHT_MV -from .forestht import ForestHT, HyppoForestRegressor +from .forestht import ForestHT, FeatureImportanceForestRegressor +from .permutationforest import PermutationForestClassifier, PermutationForestRegressor diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 3b8317710..0d88f65df 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -8,46 +8,18 @@ ForestClassifier, ForestRegressor, RandomForestRegressor, + BaseForest ) from sktree._lib.sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor from ..ensemble import HonestForestClassifier -from .utils import METRIC_FUNCTIONS, REGRESSOR_METRICS, _compute_null_distribution_coleman, _pvalue - - -def train_tree( - tree: DecisionTreeClassifier, - X: ArrayLike, - y: ArrayLike, - covariate_index: ArrayLike = None, -) -> ArrayLike: - """Compute the posterior from each tree on the "OOB" samples. - - Parameters - ---------- - tree : DecisionTreeClassifier - The tree to compute the posterior from. - X : ArrayLike of shape (n_samples, n_features) - The data matrix. - y : ArrayLike of shape (n_samples, n_outputs) - The output matrix. - covariate_index : ArrayLike of shape (n_covariates,), optional - The indices of the covariates to permute, by default None, which - does not permute any columns. - """ - # seed the random number generator using each tree's random seed(?) - rng = np.random.default_rng(tree.random_state) - - indices = np.arange(X.shape[0]) - - if covariate_index is not None: - # perform permutation of covariates - index_arr = rng.choice(indices, size=(X.shape[0], 1), replace=False, shuffle=False) - perm_X_cov = X[index_arr, covariate_index] - X[:, covariate_index] = perm_X_cov - - # individual tree permutation of y labels - tree.fit(X, y, check_input=False) +from .utils import ( + METRIC_FUNCTIONS, + REGRESSOR_METRICS, + _compute_null_distribution_coleman, + _pvalue, + train_tree, +) def tree_posterior( @@ -633,11 +605,15 @@ def test( return observe_stat, pval -class HyppoForestRegressor(MetaEstimatorMixin): +class FeatureImportanceForestRegressor(MetaEstimatorMixin): """Forest hypothesis testing with continuous `y` variable. Parameters ---------- + estimator : object, default=None + Type of forest estimator to use. By default `None`, which defaults to + :class:`sklearn.ensemble.RandomForestRegressor`. + n_estimators : int, default=100 The number of trees in the forest. @@ -848,7 +824,7 @@ def __init__( def _statistic( self, - estimator: ForestClassifier, + estimator: BaseForest, X: ArrayLike, y: ArrayLike, covariate_index: ArrayLike = None, diff --git a/sktree/stats/meson.build b/sktree/stats/meson.build index 75947f98c..0b45a0ada 100644 --- a/sktree/stats/meson.build +++ b/sktree/stats/meson.build @@ -3,6 +3,7 @@ python_sources = [ '_might.py', 'forestht.py', 'utils.py', + 'permutationforest.py', ] py3.install_sources( diff --git a/sktree/stats/permutationforest.py b/sktree/stats/permutationforest.py index 37af8eef2..a4ce3cde6 100644 --- a/sktree/stats/permutationforest.py +++ b/sktree/stats/permutationforest.py @@ -1,15 +1,289 @@ import numpy as np -from joblib import Parallel, delayed from numpy.typing import ArrayLike -from sklearn.base import MetaEstimatorMixin -from sklearn.utils.validation import _is_fitted +from sklearn.base import MetaEstimatorMixin, clone, is_classifier +from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor +from sklearn.model_selection import train_test_split +from sklearn.utils.validation import check_X_y -from ..ensemble import HonestForestClassifier -from .utils import METRIC_FUNCTIONS, _pvalue +from sktree._lib.sklearn.ensemble._forest import BaseForest, ForestClassifier, ForestRegressor +from .utils import METRIC_FUNCTIONS, REGRESSOR_METRICS, compute_null_distribution_perm -class PermutationForest(MetaEstimatorMixin): - """Hypothesis testing with a permutation forest. + +class BasePermutationForest(MetaEstimatorMixin): + def __init__( + self, + estimator=None, + n_estimators=100, + criterion="squared_error", + max_depth=None, + min_samples_split=2, + min_samples_leaf=1, + min_weight_fraction_leaf=0.0, + max_features=1.0, + max_leaf_nodes=None, + min_impurity_decrease=0.0, + bootstrap=False, + oob_score=False, + n_jobs=None, + random_state=None, + verbose=0, + warm_start=False, + ccp_alpha=0.0, + max_samples=None, + **estimators_kwargs, + ): + self.estimator = estimator + self.n_jobs = n_jobs + self.n_estimators = n_estimators + self.criterion = criterion + self.max_depth = max_depth + self.min_samples_split = min_samples_split + self.min_samples_leaf = min_samples_leaf + self.min_weight_fraction_leaf = min_weight_fraction_leaf + self.max_features = max_features + self.max_leaf_nodes = max_leaf_nodes + self.min_impurity_decrease = min_impurity_decrease + self.bootstrap = bootstrap + self.oob_score = oob_score + self.random_state = random_state + self.verbose = verbose + self.warm_start = warm_start + self.ccp_alpha = ccp_alpha + self.max_samples = max_samples + self.estimator_kwargs = estimators_kwargs + + def reset(self): + class_attributes = dir(type(self)) + instance_attributes = dir(self) + + for attr_name in instance_attributes: + if attr_name.endswith("_") and attr_name not in class_attributes: + delattr(self, attr_name) + + def _get_estimator(self): + pass + + def _statistic( + self, + estimator: BaseForest, + X: ArrayLike, + y: ArrayLike, + covariate_index: ArrayLike = None, + metric="mse", + return_posteriors: bool = False, + seed=None, + **metric_kwargs, + ): + """Helper function to compute the test statistic.""" + metric_func = METRIC_FUNCTIONS[metric] + if seed is None: + rng = np.random.default_rng(self.random_state) + else: + rng = np.random.default_rng(seed) + n_samples = X.shape[0] + indices = np.arange(n_samples, dtype=int) + + if covariate_index is not None: + # perform permutation of covariates + index_arr = rng.choice(indices, size=(X.shape[0], 1), replace=False, shuffle=False) + X = X.copy() + X[:, covariate_index] = X[index_arr, covariate_index] + + X_train, X_test = X[self.indices_train_, :], X[self.indices_test_, :] + y_train, y_test = y[self.indices_train_, :], y[self.indices_test_, :] + + estimator.fit(X_train, y_train.ravel()) + + # Either get the predicted value, or the posterior probabilities + y_pred = estimator.predict(X_test) + + # set variables to compute metric + samples = self.indices_test_ + y_true_final = y_test + posterior_final = y_pred + + stat = metric_func(y_true_final, posterior_final, **metric_kwargs) + + if covariate_index is None: + # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) + # arrays of y and predicted posterior + self.samples_ = samples + self.y_true_final_ = y_true_final + self.posterior_final_ = posterior_final + self.stat_ = stat + + if return_posteriors: + return stat, posterior_final, samples + + return stat + + def statistic( + self, + X: ArrayLike, + y: ArrayLike, + covariate_index: ArrayLike = None, + metric="mse", + return_posteriors: bool = False, + check_input: bool = True, + seed=None, + **metric_kwargs, + ): + """Compute the test statistic. + + Parameters + ---------- + X : ArrayLike of shape (n_samples, n_features) + The data matrix. + y : ArrayLike of shape (n_samples, n_outputs) + The target matrix. + covariate_index : ArrayLike, optional of shape (n_covariates,) + The index array of covariates to shuffle, by default None. + metric : str, optional + The metric to compute, by default "mse". + test_size : float, optional + Proportion of samples per tree to use for the test set, by default 0.2. + return_posteriors : bool, optional + Whether or not to return the posteriors, by default False. + + Returns + ------- + stat : float + The test statistic. + posterior_final : ArrayLike of shape (n_samples_final, n_outputs), optional + If ``return_posteriors`` is True, then the posterior probabilities of the + samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` + if all samples are encountered in the test set of at least one tree in the + posterior computation. + samples : ArrayLike of shape (n_samples_final,), optional + The indices of the samples used in the final test. ``n_samples_final`` is + equal to ``n_samples`` if all samples are encountered in the test set of at + least one tree in the posterior computation. + """ + if check_input: + X, y = check_X_y(X, y, ensure_2d=True, multi_output=True) + if y.ndim != 2: + y = y.reshape(-1, 1) + + self.estimator_ = self._get_estimator() + + if is_classifier(self.estimator_): + if metric not in METRIC_FUNCTIONS: + raise RuntimeError( + f"Metric must be one of {list(METRIC_FUNCTIONS.keys())}, got {metric}" + ) + else: + if metric not in REGRESSOR_METRICS: + raise RuntimeError(f'Metric must be either "mse" or "mae", got {metric}') + + if covariate_index is None: + estimator = self.estimator_ + else: + self.permuted_estimator_ = clone(self.estimator_) + estimator = self.permuted_estimator_ + + return self._statistic( + estimator, + X, + y, + covariate_index=covariate_index, + metric=metric, + return_posteriors=return_posteriors, + seed=seed, + **metric_kwargs, + ) + + def test( + self, + X: ArrayLike, + y: ArrayLike, + covariate_index: ArrayLike, + metric: str = "mse", + test_size: float = 0.2, + n_repeats: int = 1000, + return_posteriors: bool = False, + **metric_kwargs, + ): + """Perform hypothesis test using permutation testing. + + Parameters + ---------- + X : ArrayLike of shape (n_samples, n_features) + The data matrix. + y : ArrayLike of shape (n_samples, n_outputs) + The target matrix. + covariate_index : ArrayLike of shape (n_covariates,) + The covariate indices of ``X`` to shuffle. + metric : str, optional + Metric to compute, by default "mse". + test_size : float, optional + Size of the samples to leave out for each tree to compute posteriors on, + by default 0.2. + n_repeats : int, optional + Number of times to sample the null distribution, by default 1000. + + Returns + ------- + observe_stat : float + Observed test statistic. + pvalue : float + p-value of the test. + """ + X, y = check_X_y(X, y, ensure_2d=True, copy=True, multi_output=True) + if y.ndim != 2: + y = y.reshape(-1, 1) + + indices = np.arange(X.shape[0]) + + # train/test split + # XXX: could add stratifying by y when y is classification + indices_train, indices_test = train_test_split(indices, test_size=test_size, shuffle=True) + self.indices_train_ = indices_train + self.indices_test_ = indices_test + + if not hasattr(self, "samples_"): + # first compute the test statistic on the un-permuted data + observe_stat, observe_posteriors, observe_samples = self.statistic( + X, + y, + covariate_index=None, + metric=metric, + return_posteriors=True, + check_input=False, + **metric_kwargs, + ) + else: + observe_samples = self.samples_ + observe_posteriors = self.posterior_final_ + observe_stat = self.stat_ + + # compute null distribution of the test statistic + # WARNING: this could take a long time, since it fits a new forest + null_dist = compute_null_distribution_perm( + X_train=X[self.indices_train_, :], + y_train=y[self.indices_train_, :], + X_test=X[self.indices_test_, :], + y_test=y[self.indices_test_, :], + covariate_index=covariate_index, + est=self.estimator_, + metric=metric, + n_repeats=n_repeats, + seed=self.random_state, + ) + + if not return_posteriors: + self.null_dist_ = np.array(null_dist) + else: + self.null_dist_ = np.array([x[0] for x in null_dist]) + self.posterior_null_ = np.array([x[1] for x in null_dist]) + + n_repeats = len(self.null_dist_) + pvalue = (1 + (self.null_dist_ < observe_stat).sum()) / (1 + n_repeats) + return observe_stat, pvalue + + +class PermutationForestRegressor(BasePermutationForest): + """Hypothesis testing of covariates with a permutation forest regressor. This implements permutation testing of a null hypothesis using a random forest. The null hypothesis is generated by permuting ``n_repeats`` times the covariate @@ -17,15 +291,27 @@ class PermutationForest(MetaEstimatorMixin): is compared to the original random forest that was computed on the regular non-permuted data. + .. note:: This does not allow testing on the posteriors. + Parameters ---------- + estimator : object, default=None + Type of forest estimator to use. By default `None`, which defaults to + :class:`sklearn.ensemble.RandomForestRegressor`. + n_estimators : int, default=100 The number of trees in the forest. - criterion : {"gini", "entropy"}, default="gini" - The function to measure the quality of a split. Supported criteria are - "gini" for the Gini impurity and "entropy" for the information gain. - Note: this parameter is tree-specific. + criterion : {"squared_error", "friedman_mse", "absolute_error", \ + "poisson"}, default="squared_error" + The function to measure the quality of a split. Supported criteria + are "squared_error" for the mean squared error, which is equal to + variance reduction as feature selection criterion and minimizes the L2 + loss using the mean of each terminal node, "friedman_mse", which uses + mean squared error with Friedman's improvement score for potential + splits, "absolute_error" for the mean absolute error, which minimizes + the L1 loss using the median of each terminal node, and "poisson" which + uses reduction in Poisson deviance to find splits. splitter : {"best", "random"}, default="best" The strategy used to choose the split at each node. Supported @@ -207,14 +493,14 @@ class PermutationForest(MetaEstimatorMixin): def __init__( self, + estimator=None, n_estimators=100, - criterion="gini", - splitter="best", + criterion="squared_error", max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, - max_features="sqrt", + max_features=1.0, max_leaf_nodes=None, min_impurity_decrease=0.0, bootstrap=False, @@ -223,17 +509,14 @@ def __init__( random_state=None, verbose=0, warm_start=False, - class_weight=None, ccp_alpha=0.0, max_samples=None, - honest_prior="empirical", - honest_fraction=0.5, - tree_estimator=None, + **estimators_kwargs, ): - self.estimator = HonestForestClassifier( + super().__init__( + estimator=estimator, n_estimators=n_estimators, criterion=criterion, - splitter=splitter, max_depth=max_depth, min_samples_split=min_samples_split, min_samples_leaf=min_samples_leaf, @@ -247,174 +530,306 @@ def __init__( random_state=random_state, verbose=verbose, warm_start=warm_start, - class_weight=class_weight, ccp_alpha=ccp_alpha, max_samples=max_samples, - honest_prior=honest_prior, - honest_fraction=honest_fraction, - tree_estimator=tree_estimator, + **estimators_kwargs, ) - self.n_jobs = n_jobs - self.n_estimators = n_estimators - self.criterion = criterion - self.splitter = splitter - self.max_depth = max_depth - self.min_samples_split = min_samples_split - self.min_samples_leaf = min_samples_leaf - self.min_weight_fraction_leaf = min_weight_fraction_leaf - self.max_features = max_features - self.max_leaf_nodes = max_leaf_nodes - self.min_impurity_decrease = min_impurity_decrease - self.bootstrap = bootstrap - self.oob_score = oob_score - self.random_state = random_state - self.verbose = verbose - self.warm_start = warm_start - self.class_weight = class_weight - self.ccp_alpha = ccp_alpha - self.max_samples = max_samples - self.honest_prior = honest_prior - self.honest_fraction = honest_fraction - self.tree_estimator = tree_estimator - def statistic( - self, - X: ArrayLike, - y: ArrayLike, - covariate_index: ArrayLike = None, - metric="auc", - test_size=0.2, - return_posteriors: bool = False, - **metric_kwargs, - ): - """Compute the test statistic. + def _get_estimator(self): + if not hasattr(self, "estimator_") and self.estimator is None: + estimator_ = RandomForestRegressor( + n_estimators=self.n_estimators, + criterion=self.criterion, + max_depth=self.max_depth, + min_samples_split=self.min_samples_split, + min_samples_leaf=self.min_samples_leaf, + min_weight_fraction_leaf=self.min_weight_fraction_leaf, + max_features=self.max_features, + max_leaf_nodes=self.max_leaf_nodes, + min_impurity_decrease=self.min_impurity_decrease, + bootstrap=self.bootstrap, + oob_score=self.oob_score, + n_jobs=self.n_jobs, + random_state=self.random_state, + verbose=self.verbose, + warm_start=self.warm_start, + ccp_alpha=self.ccp_alpha, + max_samples=self.max_samples, + **self.estimator_kwargs, + ) + elif not isinstance(self.estimator_, ForestRegressor): + raise RuntimeError(f"Estimator must be a ForestRegressor, got {type(self.estimator_)}") + return estimator_ - Parameters - ---------- - X : ArrayLike of shape (n_samples, n_features) - The data matrix. - y : ArrayLike of shape (n_samples, n_outputs) - The target matrix. - covariate_index : ArrayLike, optional of shape (n_covariates,) - The index array of covariates to shuffle, by default None. - metric : str, optional - The metric to compute, by default "auc". - test_size : float, optional - Proportion of samples per tree to use for the test set, by default 0.2. - return_posteriors : bool, optional - Whether or not to return the posteriors, by default False. - Returns - ------- - stat : float - The test statistic. - posterior_final : ArrayLike of shape (n_samples_final, n_outputs), optional - If ``return_posteriors`` is True, then the posterior probabilities of the - samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` - if all samples are encountered in the test set of at least one tree in the - posterior computation. - samples : ArrayLike of shape (n_samples_final,), optional - The indices of the samples used in the final test. ``n_samples_final`` is - equal to ``n_samples`` if all samples are encountered in the test set of at - least one tree in the posterior computation. - """ - rng = np.random.default_rng(self.random_state) - metric_func = METRIC_FUNCTIONS[metric] +class PermutationForestClassifier(BasePermutationForest): + """Hypothesis testing of covariates with a permutation forest classifier. - # first run a dummy fit on just two samples to initialize the - # internal data structure of the forest - if not _is_fitted(self.estimator): - self.estimator.fit(X[:2], y[:2]) + This implements permutation testing of a null hypothesis using a random forest. + The null hypothesis is generated by permuting ``n_repeats`` times the covariate + indices and then a random forest is trained for each permuted instance. This + is compared to the original random forest that was computed on the regular + non-permuted data. - # Fit each tree and ompute posteriors with train test splits - posterior = Parallel(n_jobs=self.n_jobs)( - delayed(tree_posterior)( - tree, X, y, covariate_index=covariate_index, test_size=test_size - ) - for tree in self.estimator.estimators_ - ) + .. note:: This does not allow testing on the posteriors. + + Parameters + ---------- + estimator : object, default=None + Type of forest estimator to use. By default `None`, which defaults to + :class:`sklearn.ensemble.RandomForestClassifier`. - # Average all posteriors - posterior_final = np.nanmean(posterior, axis=0) - samples = np.argwhere(~np.isnan(posterior_final).any(axis=1))[0] - y_true_final = y[samples, :] - posterior_final = posterior_final[samples, :] - stat = metric_func(y_true=y_true_final, y_pred=posterior_final, **metric_kwargs) + n_estimators : int, default=100 + The number of trees in the forest. - # Cache the original test statistic - if covariate_index is None: - self.samples_ = samples - self.y_true_ = y_true_final - self.stat_ = stat - self.posterior_ = posterior_final + criterion : {"gini", "entropy"}, default="gini" + The function to measure the quality of a split. Supported criteria are + "gini" for the Gini impurity and "entropy" for the information gain. - if return_posteriors: - return stat, posterior_final, samples - return stat + splitter : {"best", "random"}, default="best" + The strategy used to choose the split at each node. Supported + strategies are "best" to choose the best split and "random" to choose + the best random split. - def test( - self, - X: ArrayLike, - y: ArrayLike, - covariate_index: ArrayLike, - metric: str = "auc", - test_size: float = 0.2, - n_repeats: int = 1000, - return_posteriors: bool = False, - **metric_kwargs, - ): - """Perform hypothesis test using permutation testing. + max_depth : int, default=None + The maximum depth of the tree. If None, then nodes are expanded until + all leaves are pure or until all leaves contain less than + min_samples_split samples. - Parameters - ---------- - X : ArrayLike of shape (n_samples, n_features) - The data matrix. - y : ArrayLike of shape (n_samples, n_outputs) - The target matrix. - covariate_index : ArrayLike of shape (n_covariates,) - The covariate indices of ``X`` to shuffle. - metric : str, optional - Metric to compute, by default "auc". - test_size : float, optional - Size of the samples to leave out for each tree to compute posteriors on, - by default 0.2. - n_repeats : int, optional - Number of times to sample the null distribution, by default 1000. + min_samples_split : int or float, default=2 + The minimum number of samples required to split an internal node: - Returns - ------- - observe_stat : float - Observed test statistic. - pvalue : float - p-value of the test. - """ - # compute original test statistic - observe_stat = self.statistic(X, y, covariate_index, metric, test_size, **metric_kwargs) + - If int, then consider `min_samples_split` as the minimum number. + - If float, then `min_samples_split` is a fraction and + `ceil(min_samples_split * n_samples)` are the minimum + number of samples for each split. - # compute null distribution of the test statistic - # WARNING: this could take a long time, since it fits a new forest - null_dist = np.array( - Parallel(n_jobs=self.n_jobs)( - [ - delayed(self.statistic)( - self, - X, - y, - covariate_index, - metric, - test_size, - return_posteriors, - **metric_kwargs, - ) - for _ in range(n_repeats) - ] - ) + min_samples_leaf : int or float, default=1 + The minimum number of samples required to be at a leaf node. + A split point at any depth will only be considered if it leaves at + least ``min_samples_leaf`` training samples in each of the left and + right branches. This may have the effect of smoothing the model, + especially in regression. + + - If int, then consider `min_samples_leaf` as the minimum number. + - If float, then `min_samples_leaf` is a fraction and + `ceil(min_samples_leaf * n_samples)` are the minimum + number of samples for each node. + + min_weight_fraction_leaf : float, default=0.0 + The minimum weighted fraction of the sum total of weights (of all + the input samples) required to be at a leaf node. Samples have + equal weight when sample_weight is not provided. + + max_features : {"sqrt", "log2", None}, int or float, default="sqrt" + The number of features to consider when looking for the best split: + + - If int, then consider `max_features` features at each split. + - If float, then `max_features` is a fraction and + `round(max_features * n_features)` features are considered at each + split. + - If "auto", then `max_features=sqrt(n_features)`. + - If "sqrt", then `max_features=sqrt(n_features)`. + - If "log2", then `max_features=log2(n_features)`. + - If None, then `max_features=n_features`. + + Note: the search for a split does not stop until at least one + valid partition of the node samples is found, even if it requires to + effectively inspect more than ``max_features`` features. + + max_leaf_nodes : int, default=None + Grow trees with ``max_leaf_nodes`` in best-first fashion. + Best nodes are defined as relative reduction in impurity. + If None then unlimited number of leaf nodes. + + min_impurity_decrease : float, default=0.0 + A node will be split if this split induces a decrease of the impurity + greater than or equal to this value. + + The weighted impurity decrease equation is the following:: + + N_t / N * (impurity - N_t_R / N_t * right_impurity + - N_t_L / N_t * left_impurity) + + where ``N`` is the total number of samples, ``N_t`` is the number of + samples at the current node, ``N_t_L`` is the number of samples in the + left child, and ``N_t_R`` is the number of samples in the right child. + + ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, + if ``sample_weight`` is passed. + + bootstrap : bool, default=True + Whether bootstrap samples are used when building trees. If False, the + whole dataset is used to build each tree. + + oob_score : bool, default=False + Whether to use out-of-bag samples to estimate the generalization score. + Only available if bootstrap=True. + + n_jobs : int, default=None + The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`, + :meth:`decision_path` and :meth:`apply` are all parallelized over the + trees. ``None`` means 1 unless in a `joblib.parallel_backend` + context. ``-1`` means using all processors. See :term:`Glossary + ` for more details. + + random_state : int, RandomState instance or None, default=None + Controls both the randomness of the bootstrapping of the samples used + when building trees (if ``bootstrap=True``) and the sampling of the + features to consider when looking for the best split at each node + (if ``max_features < n_features``). + See :term:`Glossary ` for details. + + verbose : int, default=0 + Controls the verbosity when fitting and predicting. + + warm_start : bool, default=False + When set to ``True``, reuse the solution of the previous call to fit + and add more estimators to the ensemble, otherwise, just fit a whole + new forest. See :term:`the Glossary `. + + class_weight : {"balanced", "balanced_subsample"}, dict or list of dicts, \ + default=None + Weights associated with classes in the form ``{class_label: weight}``. + If not given, all classes are supposed to have weight one. For + multi-output problems, a list of dicts can be provided in the same + order as the columns of y. + + Note that for multioutput (including multilabel) weights should be + defined for each class of every column in its own dict. For example, + for four-class multilabel classification weights should be + [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of + [{1:1}, {2:5}, {3:1}, {4:1}]. + + The "balanced" mode uses the values of y to automatically adjust + weights inversely proportional to class frequencies in the input data + as ``n_samples / (n_classes * np.bincount(y))`` + + The "balanced_subsample" mode is the same as "balanced" except that + weights are computed based on the bootstrap sample for every tree + grown. + + For multi-output, the weights of each column of y will be multiplied. + + Note that these weights will be multiplied with sample_weight (passed + through the fit method) if sample_weight is specified. + + ccp_alpha : non-negative float, default=0.0 + Complexity parameter used for Minimal Cost-Complexity Pruning. The + subtree with the largest cost complexity that is smaller than + ``ccp_alpha`` will be chosen. By default, no pruning is performed. See + :ref:`minimal_cost_complexity_pruning` for details. + + max_samples : int or float, default=None + If bootstrap is True, the number of samples to draw from X + to train each base tree estimator. + + - If None (default), then draw `X.shape[0]` samples. + - If int, then draw `max_samples` samples. + - If float, then draw `max_samples * X.shape[0]` samples. Thus, + `max_samples` should be in the interval `(0.0, 1.0]`. + + honest_prior : {"ignore", "uniform", "empirical"}, default="empirical" + Method for dealing with empty leaves during evaluation of a test + sample. If "ignore", the tree is ignored. If "uniform", the prior tree + posterior is 1/(number of classes). If "empirical", the prior tree + posterior is the relative class frequency in the voting subsample. + If all trees are ignored, the empirical estimate is returned. + + honest_fraction : float, default=0.5 + Fraction of training samples used for estimates in the trees. The + remaining samples will be used to learn the tree structure. A larger + fraction creates shallower trees with lower variance estimates. + + tree_estimator : object, default=None + Type of decision tree classifier to use. By default `None`, which + defaults to :class:`sklearn.tree.DecisionTreeClassifier`. + + Attributes + ---------- + samples_ : ArrayLike of shape (n_samples,) + The indices of the samples used in the final test. + + y_true_ : ArrayLike of shape (n_samples_final,) + The true labels of the samples used in the final test. + + posterior_ : ArrayLike of shape (n_samples_final, n_outputs) + The predicted posterior probabilities of the samples used in the final test. + + null_dist_ : ArrayLike of shape (n_repeats,) + The null distribution of the test statistic. + + posterior_null_ : ArrayLike of shape (n_samples_final, n_outputs, n_repeats) + The posterior probabilities of the samples used in the final test for each + permutation for the null distribution. + """ + + def __init__( + self, + estimator=None, + n_estimators=100, + criterion="gini", + max_depth=None, + min_samples_split=2, + min_samples_leaf=1, + min_weight_fraction_leaf=0.0, + max_features="sqrt", + max_leaf_nodes=None, + min_impurity_decrease=0.0, + bootstrap=False, + oob_score=False, + n_jobs=None, + random_state=None, + verbose=0, + warm_start=False, + ccp_alpha=0.0, + max_samples=None, + **estimators_kwargs, + ): + super().__init__( + estimator=estimator, + n_estimators=n_estimators, + criterion=criterion, + max_depth=max_depth, + min_samples_split=min_samples_split, + min_samples_leaf=min_samples_leaf, + min_weight_fraction_leaf=min_weight_fraction_leaf, + max_features=max_features, + max_leaf_nodes=max_leaf_nodes, + min_impurity_decrease=min_impurity_decrease, + bootstrap=bootstrap, + oob_score=oob_score, + n_jobs=n_jobs, + random_state=random_state, + verbose=verbose, + warm_start=warm_start, + ccp_alpha=ccp_alpha, + max_samples=max_samples, + **estimators_kwargs, ) - if not return_posteriors: - self.null_dist_ = null_dist - else: - self.null_dist_ = null_dist[0] - self.posterior_null_ = null_dist[1] - pvalue = _pvalue(observe_stat=observe_stat, permuted_stat=null_dist, correction=True) - return observe_stat, pvalue + def _get_estimator(self): + if not hasattr(self, "estimator_") and self.estimator is None: + estimator_ = RandomForestClassifier( + n_estimators=self.n_estimators, + criterion=self.criterion, + max_depth=self.max_depth, + min_samples_split=self.min_samples_split, + min_samples_leaf=self.min_samples_leaf, + min_weight_fraction_leaf=self.min_weight_fraction_leaf, + max_features=self.max_features, + max_leaf_nodes=self.max_leaf_nodes, + min_impurity_decrease=self.min_impurity_decrease, + bootstrap=self.bootstrap, + oob_score=self.oob_score, + n_jobs=self.n_jobs, + random_state=self.random_state, + verbose=self.verbose, + warm_start=self.warm_start, + ccp_alpha=self.ccp_alpha, + max_samples=self.max_samples, + **self.estimator_kwargs, + ) + elif not isinstance(self.estimator_, ForestRegressor): + raise RuntimeError(f"Estimator must be a ForestRegressor, got {type(self.estimator_)}") + return estimator_ diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 3c4e644eb..c212eae33 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -4,8 +4,8 @@ from sklearn import datasets from sktree._lib.sklearn.tree import DecisionTreeClassifier -from sktree.stats import MIGHT -from sktree.stats.forestht import ForestHT, HyppoForestRegressor +from sktree.stats import MIGHT, PermutationForestClassifier, PermutationForestRegressor +from sktree.stats.forestht import ForestHT from sktree.tree import ObliqueDecisionTreeClassifier, PatchObliqueDecisionTreeClassifier # load the iris dataset @@ -33,24 +33,22 @@ def test_forestht_proper_attributes(): pass -def test_iris(): - pass - - -def test_linear_model(): - r"""Test MIGHT using MSE from linear model simulation. +@pytest.mark.slowtest +@pytest.mark.parametrize("hypotester", [PermutationForestRegressor]) +def test_linear_model(hypotester): + r"""Test hypothesis testing forests using MSE from linear model simulation. See https://arxiv.org/pdf/1904.07830.pdf Figure 1. Y = Beta * X_1 + Beta * I(X_6 = 2) + \epsilon """ - # j = np.linspace(0.005, 2.25, 9)[] beta = 10.0 - sigma = 0.05 # / j - n_samples = 2500 - n_estimators = 125 + sigma = 0.5 + n_samples = 550 + n_estimators = 50 test_size = 0.1 - # subsample_size = 0.8 + n_repeats = 50 + metric = "mse" rng = np.random.default_rng(seed) @@ -61,7 +59,7 @@ def test_linear_model(): X_610[:, idx] = np.argwhere( rng.multinomial(1, [1.0 / 3, 1.0 / 3, 1.0 / 3], size=(n_samples,)) )[:, 1] - X = np.concatenate((X_15, X_610), axis=1, dtype=np.float32) + X = np.concatenate((X_15, X_610), axis=1) assert X.shape == (n_samples, 10) # sample noise @@ -69,51 +67,55 @@ def test_linear_model(): # compute final y of (n_samples,) y = beta * X[:, 0] + (beta * (X[:, 5] == 2.0)) + epsilon - est = HyppoForestRegressor( + est = hypotester( max_features=1.0, random_state=seed, n_estimators=n_estimators, n_jobs=-1, - permute_per_tree=False, - # bootstrap=True, max_samples=subsample_size ) # test for X_1 - stat, pvalue = est.test(X, y, [0], test_size=test_size) - print(pvalue) - # assert pvalue < 0.05, f"pvalue: {pvalue}" + stat, pvalue = est.test(X, y, [0], metric=metric, test_size=test_size, n_repeats=n_repeats) + print("X1: ", pvalue) + assert pvalue < 0.05, f"pvalue: {pvalue}" # test for X_6 - stat, pvalue = est.test(X, y, [5], test_size=test_size) - print(pvalue) - # assert pvalue < 0.05, f"pvalue: {pvalue}" + stat, pvalue = est.test(X, y, [5], metric=metric, test_size=test_size, n_repeats=n_repeats) + print("X6: ", pvalue) + assert pvalue < 0.05, f"pvalue: {pvalue}" # test for a few unimportant other X for covariate_index in [1, 6]: - # test for X_2, X_3, X_4 - stat, pvalue = est.test(X, y, [covariate_index], test_size=test_size) - print(pvalue) - # assert pvalue > 0.05, f"pvalue: {pvalue}" - - assert False + # test for X_2, X_7 + stat, pvalue = est.test( + X, y, [covariate_index], metric=metric, test_size=test_size, n_repeats=n_repeats + ) + print("X2/7: ", pvalue) + assert pvalue > 0.05, f"pvalue: {pvalue}" -def test_correlated_logit_model(): +@pytest.mark.slowtest +@pytest.mark.parametrize("hypotester", [PermutationForestClassifier]) +def test_correlated_logit_model(hypotester): r"""Test MIGHT using MSE from linear model simulation. See https://arxiv.org/pdf/1904.07830.pdf Figure 1. P(Y = 1 | X) = expit(beta * \\sum_{j=2}^5 X_j) """ - beta = 15.0 + beta = 5.0 n_samples = 600 - n_estimators = 125 + n_estimators = 50 n_jobs = -1 + max_features = "sqrt" + test_size = 1.0 / 6 + metric = "mse" + n_repeats = 50 + + n = 200 # Number of time steps + ar_coefficient = 0.0015 - n = 100 # Number of time steps - ar_coefficient = 0.015 rng = np.random.default_rng(seed) - test_size = 0.5 X = np.zeros((n_samples, n)) for idx in range(n_samples): @@ -135,22 +137,30 @@ def test_correlated_logit_model(): assert y_proba.shape == (n_samples,) y = rng.binomial(1, y_proba, size=n_samples) # .reshape(-1, 1) - est = ForestHT(max_features=n, random_state=seed, n_estimators=n_estimators, n_jobs=n_jobs) + est = hypotester( + max_features=max_features, random_state=seed, n_estimators=n_estimators, n_jobs=n_jobs + ) # test for X_2 important - stat, pvalue = est.test(X, y, [1], test_size=test_size, metric="mse") - print(pvalue) - assert pvalue < 0.6, f"pvalue: {pvalue}" + stat, pvalue = est.test( + X.copy(), y.copy(), [1], test_size=test_size, n_repeats=n_repeats, metric=metric + ) + print("X2: ", pvalue) + assert pvalue < 0.05, f"pvalue: {pvalue}" - # test for X_1 - stat, pvalue = est.test(X, y, [0], metric="mse") - print(pvalue) - assert pvalue > 0.9, f"pvalue: {pvalue}" + # test for X_1 unimportant + stat, pvalue = est.test( + X.copy(), y.copy(), [0], test_size=test_size, n_repeats=n_repeats, metric=metric + ) + print("X1: ", pvalue) + assert pvalue > 0.05, f"pvalue: {pvalue}" - # test for X_500 - stat, pvalue = est.test(X, y, [n - 1], metric="mse") - print(pvalue) - assert pvalue > 0.9, f"pvalue: {pvalue}" + # test for X_500 unimportant + stat, pvalue = est.test( + X.copy(), y.copy(), [n - 1], test_size=test_size, n_repeats=n_repeats, metric=metric + ) + print("X500: ", pvalue) + assert pvalue > 0.05, f"pvalue: {pvalue}" @pytest.mark.parametrize("criterion", ["gini", "entropy"]) diff --git a/sktree/stats/utils.py b/sktree/stats/utils.py index 94754bfb0..3791a388f 100644 --- a/sktree/stats/utils.py +++ b/sktree/stats/utils.py @@ -3,10 +3,16 @@ import numpy as np from numpy.typing import ArrayLike from scipy.stats import entropy -from sklearn.metrics import mean_absolute_error, mean_squared_error, roc_auc_score +from sklearn.metrics import ( + balanced_accuracy_score, + mean_absolute_error, + mean_squared_error, + roc_auc_score, +) from sklearn.utils.validation import check_X_y from sktree._lib.sklearn.ensemble._forest import ForestClassifier +from sktree._lib.sklearn.tree import DecisionTreeClassifier def _mutual_information(y_true, y_pred): @@ -21,15 +27,50 @@ def _mutual_information(y_true, y_pred): "mae": mean_absolute_error, "auc": roc_auc_score, "mi": _mutual_information, + "balanced_accuracy": balanced_accuracy_score, } REGRESSOR_METRICS = ("mse", "mae") +def train_tree( + tree: DecisionTreeClassifier, + X: ArrayLike, + y: ArrayLike, + covariate_index: ArrayLike = None, +) -> ArrayLike: + """Compute the posterior from each tree on the "OOB" samples. + + Parameters + ---------- + tree : DecisionTreeClassifier + The tree to compute the posterior from. + X : ArrayLike of shape (n_samples, n_features) + The data matrix. + y : ArrayLike of shape (n_samples, n_outputs) + The output matrix. + covariate_index : ArrayLike of shape (n_covariates,), optional + The indices of the covariates to permute, by default None, which + does not permute any columns. + """ + # seed the random number generator using each tree's random seed(?) + rng = np.random.default_rng(tree.random_state) + + indices = np.arange(X.shape[0]) + + if covariate_index is not None: + # perform permutation of covariates + index_arr = rng.choice(indices, size=(X.shape[0], 1), replace=False, shuffle=False) + perm_X_cov = X[index_arr, covariate_index] + X[:, covariate_index] = perm_X_cov + + # individual tree permutation of y labels + tree.fit(X, y, check_input=False) + + def _pvalue(observe_stat: float, permuted_stat: ArrayLike, correction: bool = True) -> float: - """Compute pvalue with Coleman method. + """Compute pvalue. - Implements the pvalue calculation from Algorithm 1. See - :footcite:`coleman2022scalable` for full details. + Implements the pvalue calculation from optionally with a correction factor. Parameters ---------- @@ -47,13 +88,15 @@ def _pvalue(observe_stat: float, permuted_stat: ArrayLike, correction: bool = Tr """ n_repeats = len(permuted_stat) if correction: - pval = (1 + (permuted_stat >= observe_stat).sum()) / (1 + n_repeats) + pval = (1 + (permuted_stat < observe_stat).sum()) / (1 + n_repeats) else: - pval = (permuted_stat >= observe_stat).sum() / n_repeats + pval = (permuted_stat < observe_stat).sum() / n_repeats return pval def compute_null_distribution_perm( + X_train: ArrayLike, + y_train: ArrayLike, X_test: ArrayLike, y_test: ArrayLike, covariate_index: ArrayLike, @@ -82,29 +125,37 @@ def compute_null_distribution_perm( Random seed, by default None. """ rng = np.random.default_rng(seed) - X_test, y_test = check_X_y(X_test, y_test, ensure_2d=True) - n_samples = len(y_test) - + X_test, y_test = check_X_y(X_test, y_test, ensure_2d=True, multi_output=True) + n_samples_test = len(y_test) + n_samples_train = len(y_train) metric_func = METRIC_FUNCTIONS[metric] # pre-allocate memory for the index array - index_arr = np.arange(n_samples * 2, dtype=int) + train_index_arr = np.arange(n_samples_train, dtype=int).reshape(-1, 1) + test_index_arr = np.arange(n_samples_test, dtype=int).reshape(-1, 1) + + X = np.concatenate((X_train, X_test), axis=0) + index_arr = np.arange(X.shape[0], dtype=int) # .reshape(-1, 1) null_metrics = np.zeros((n_repeats,)) for idx in range(n_repeats): # permute the covariates inplace - rng.shuffle(index_arr) - perm_X_cov = X_test[index_arr, covariate_index] + rng.shuffle(test_index_arr) + perm_X_cov = X_test[test_index_arr, covariate_index] X_test[:, covariate_index] = perm_X_cov + rng.shuffle(train_index_arr) + perm_X_cov = X_train[train_index_arr, covariate_index] + X_train[:, covariate_index] = perm_X_cov + # train a new forest on the permuted data # XXX: should there be a train/test split here? even w/ honest forests? - est.fit(X_test, y_test) - y_pred_proba = est.predict_proba(X_test) + est.fit(X_train, y_train.ravel()) + y_pred = est.predict(X_test) # compute two instances of the metric from the sampled trees - metric_val = metric_func(y_true=y_test, y_pred=y_pred_proba) + metric_val = metric_func(y_test, y_pred) null_metrics[idx] = metric_val return null_metrics diff --git a/sktree/tree/_classes.py b/sktree/tree/_classes.py index 4e9bc279f..1fd839ab7 100644 --- a/sktree/tree/_classes.py +++ b/sktree/tree/_classes.py @@ -575,7 +575,7 @@ def _build_tree( class ObliqueDecisionTreeClassifier(SimMatrixMixin, DecisionTreeClassifier): - """A decision tree classifier. + """An oblique decision tree classifier. Read more in the :ref:`User Guide `. The implementation follows that of :footcite:`breiman2001random` and :footcite:`TomitaSPORF2020`. From 3d666af74011b47287809a2b65846d63aa03139c Mon Sep 17 00:00:00 2001 From: Adam Li Date: Sun, 17 Sep 2023 12:08:08 -0400 Subject: [PATCH 15/70] Upload notebook Signed-off-by: Adam Li --- .codespellignore | 3 +- .../test_permutation_forest.ipynb | 628 ++++++++++++------ sktree/meson.build | 2 +- sktree/stats/__init__.py | 2 +- sktree/stats/_might.py | 2 +- sktree/stats/forestht.py | 377 ++++++----- sktree/stats/permutationforest.py | 4 +- sktree/stats/tests/test_forestht.py | 85 ++- sktree/stats/tests/test_might.py | 2 +- sktree/stats/utils.py | 84 +-- 10 files changed, 777 insertions(+), 412 deletions(-) diff --git a/.codespellignore b/.codespellignore index 909bd6252..41359f0fb 100644 --- a/.codespellignore +++ b/.codespellignore @@ -1,4 +1,5 @@ raison nd parth -ot \ No newline at end of file +ot +fpr \ No newline at end of file diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/test_permutation_forest.ipynb index 6cd8626d7..d0e72e4d4 100644 --- a/benchmarks_nonasv/test_permutation_forest.ipynb +++ b/benchmarks_nonasv/test_permutation_forest.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 17, "id": "b658bdd8-a3e6-4051-9d66-f2a153113234", "metadata": {}, "outputs": [], @@ -14,17 +14,26 @@ "import pandas as pd\n", "import seaborn as sns\n", "\n", - "from sktree.stats import HyppoForestRegressor, PermutationForest\n", + "from sktree.stats import FeatureImportanceForestRegressor, PermutationForestRegressor\n", "\n", "seed = 12345" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 18, "id": "05b0b53e-0525-45ce-9f7e-0322a30221cf", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "%load_ext autoreload\n", "%autoreload 2" @@ -32,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 20, "id": "5e2d1279-fa4f-47ef-aa48-fac6d47159ad", "metadata": {}, "outputs": [], @@ -49,6 +58,10 @@ " n_samples = 2200\n", " n_estimators = 125\n", " test_size = 0.1\n", + " n_repeats = 500\n", + " metric = \"mse\"\n", + " permute_per_tree = True\n", + " sample_dataset_per_tree = True\n", "\n", " rng = np.random.default_rng(seed)\n", "\n", @@ -74,24 +87,30 @@ " y = beta * X[:, 0] + (beta * (X[:, 5] - 2)) + epsilon\n", "\n", " # initialize hypothesis tester\n", - " est = PermutationForest(\n", + " est = FeatureImportanceForestRegressor(\n", " max_features=1.0,\n", " random_state=seed,\n", " n_estimators=n_estimators,\n", " n_jobs=-1,\n", + " permute_per_tree=permute_per_tree,\n", + " sample_dataset_per_tree=sample_dataset_per_tree,\n", " # bootstrap=True,\n", " # max_samples=subsample_size\n", " )\n", " pvalue_dict = {}\n", "\n", " # test for X_1\n", - " stat, pvalue = est.test(X.copy(), y.copy(), [0], n_repeats=100, test_size=test_size)\n", + " stat, pvalue = est.test(\n", + " X.copy(), y.copy(), [0], metric=metric, n_repeats=n_repeats, test_size=test_size\n", + " )\n", " print(\"X1: \", pvalue)\n", " pvalue_dict[\"X1\"] = pvalue\n", " # assert pvalue < 0.05, f\"pvalue: {pvalue}\"\n", "\n", " # test for X_6\n", - " stat, pvalue = est.test(X.copy(), y.copy(), [5], n_repeats=100, test_size=test_size)\n", + " stat, pvalue = est.test(\n", + " X.copy(), y.copy(), [5], metric=metric, n_repeats=n_repeats, test_size=test_size\n", + " )\n", " print(\"X6: \", pvalue)\n", " pvalue_dict[\"X6\"] = pvalue\n", " # assert pvalue < 0.05, f\"pvalue: {pvalue}\"\n", @@ -100,7 +119,12 @@ " for name, covariate_index in zip([\"X2\", \"X7\"], [1, 6]):\n", " # test for X_2, X_7\n", " stat, pvalue = est.test(\n", - " X.copy(), y.copy(), [covariate_index], n_repeats=100, test_size=test_size\n", + " X.copy(),\n", + " y.copy(),\n", + " [covariate_index],\n", + " metric=metric,\n", + " n_repeats=n_repeats,\n", + " test_size=test_size,\n", " )\n", " print(\"X2/7: \", pvalue)\n", " pvalue_dict[name] = pvalue\n", @@ -123,7 +147,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 25, "id": "14806903-933b-4e31-a2db-a3a45e0a6f82", "metadata": { "scrolled": true @@ -133,185 +157,185 @@ "name": "stdout", "output_type": "stream", "text": [ - "X1: 0.7623762376237624\n", - "X6: 0.0891089108910891\n", - "X2/7: 0.8316831683168316\n", - "X2/7: 0.8712871287128713\n", - "X1: 0.9504950495049505\n", + "X1: 1.0\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.001996007984031936\n", + "X2/7: 0.001996007984031936\n", + "X1: 1.0\n", + "X6: 1.0\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 1.0\n", "X6: 1.0\n", "X2/7: 1.0\n", "X2/7: 1.0\n", - "X1: 0.693069306930693\n", - "X6: 0.6039603960396039\n", - "X2/7: 0.39603960396039606\n", - "X2/7: 0.594059405940594\n", - "X1: 0.9306930693069307\n", - "X6: 0.9900990099009901\n", - "X2/7: 0.9801980198019802\n", - "X2/7: 1.0\n", - "X1: 0.36633663366336633\n", - "X6: 0.039603960396039604\n", - "X2/7: 0.7623762376237624\n", - "X2/7: 0.9603960396039604\n", - "X1: 0.21782178217821782\n", - "X6: 0.43564356435643564\n", - "X2/7: 0.6237623762376238\n", - "X2/7: 0.24752475247524752\n", - "X1: 0.42574257425742573\n", - "X6: 0.7425742574257426\n", - "X2/7: 0.44554455445544555\n", - "X2/7: 0.1188118811881188\n", - "X1: 0.36633663366336633\n", - "X6: 0.0297029702970297\n", - "X2/7: 0.13861386138613863\n", - "X2/7: 0.1485148514851485\n", - "X1: 0.9405940594059405\n", + "X1: 1.0\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.001996007984031936\n", + "X1: 1.0\n", "X6: 1.0\n", - "X2/7: 0.9207920792079208\n", - "X2/7: 1.0\n", - "X1: 0.504950495049505\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.5742574257425742\n", - "X2/7: 1.0\n", - "X1: 0.7128712871287128\n", - "X6: 0.2079207920792079\n", - "X2/7: 0.9306930693069307\n", - "X2/7: 1.0\n", - "X1: 0.26732673267326734\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.5742574257425742\n", - "X2/7: 0.13861386138613863\n", - "X1: 0.7722772277227723\n", - "X6: 0.900990099009901\n", - "X2/7: 0.9900990099009901\n", - "X2/7: 1.0\n", - "X1: 0.297029702970297\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.6633663366336634\n", - "X2/7: 0.009900990099009901\n", - "X1: 0.9702970297029703\n", - "X6: 0.6336633663366337\n", - "X2/7: 0.9900990099009901\n", - "X2/7: 1.0\n", - "X1: 0.16831683168316833\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.26732673267326734\n", - "X2/7: 0.019801980198019802\n", - "X1: 0.27722772277227725\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.24752475247524752\n", - "X2/7: 0.12871287128712872\n", - "X1: 0.16831683168316833\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.5742574257425742\n", - "X2/7: 0.21782178217821782\n", - "X1: 0.019801980198019802\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.09900990099009901\n", - "X2/7: 0.0594059405940594\n", - "X1: 0.2871287128712871\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.40594059405940597\n", - "X2/7: 1.0\n", - "X1: 0.5346534653465347\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.504950495049505\n", - "X2/7: 0.0891089108910891\n", - "X1: 0.16831683168316833\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.900990099009901\n", - "X2/7: 1.0\n", - "X1: 0.009900990099009901\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.009900990099009901\n", - "X2/7: 0.009900990099009901\n", - "X1: 0.019801980198019802\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.40594059405940597\n", - "X2/7: 0.039603960396039604\n", - "X1: 0.22772277227722773\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.6534653465346535\n", - "X2/7: 0.9504950495049505\n", - "X1: 0.009900990099009901\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.009900990099009901\n", - "X2/7: 0.009900990099009901\n", - "X1: 0.009900990099009901\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.09900990099009901\n", - "X2/7: 0.009900990099009901\n", - "X1: 0.5544554455445545\n", - "X6: 0.009900990099009901\n", - "X2/7: 1.0\n", - "X2/7: 1.0\n", - "X1: 0.019801980198019802\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.38613861386138615\n", - "X2/7: 1.0\n", - "X1: 0.0594059405940594\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.2079207920792079\n", - "X2/7: 0.33663366336633666\n", - "X1: 0.039603960396039604\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.6732673267326733\n", - "X2/7: 0.504950495049505\n", - "X1: 0.2079207920792079\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.7227722772277227\n", - "X2/7: 0.7623762376237624\n", - "X1: 0.009900990099009901\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.9801980198019802\n", - "X2/7: 1.0\n", - "X1: 0.009900990099009901\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.039603960396039604\n", - "X2/7: 0.13861386138613863\n", - "X1: 0.009900990099009901\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.8811881188118812\n", - "X2/7: 0.9504950495049505\n", - "X1: 0.009900990099009901\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.9405940594059405\n", - "X2/7: 0.45544554455445546\n", - "X1: 0.009900990099009901\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.1485148514851485\n", - "X2/7: 0.9900990099009901\n", - "X1: 0.009900990099009901\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.7128712871287128\n", - "X2/7: 0.019801980198019802\n", - "X1: 0.019801980198019802\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.9504950495049505\n", - "X2/7: 1.0\n", - "X1: 0.009900990099009901\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.8613861386138614\n", - "X2/7: 0.46534653465346537\n", - "X1: 0.009900990099009901\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.7227722772277227\n", - "X2/7: 0.019801980198019802\n", - "X1: 0.009900990099009901\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.9504950495049505\n", - "X2/7: 0.8118811881188119\n", - "X1: 0.009900990099009901\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.297029702970297\n", - "X2/7: 1.0\n", - "X1: 0.009900990099009901\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.7821782178217822\n", - "X2/7: 0.8613861386138614\n", - "X1: 0.0297029702970297\n", - "X6: 0.009900990099009901\n", - "X2/7: 0.9108910891089109\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 1.0\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 1.0\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 1.0\n", + "X6: 1.0\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 1.0\n", + "X6: 1.0\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 1.0\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.001996007984031936\n", + "X1: 1.0\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 1.0\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 1.0\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 1.0\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 1.0\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 1.0\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 1.0\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.001996007984031936\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.001996007984031936\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.001996007984031936\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.001996007984031936\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.001996007984031936\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.001996007984031936\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.001996007984031936\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.001996007984031936\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 1.0\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", "X2/7: 1.0\n" ] } @@ -336,7 +360,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 26, "id": "d3e21945-92b3-4ccc-8f29-b44f67d9cf33", "metadata": {}, "outputs": [ @@ -354,9 +378,239 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "b2bced31-0367-48a8-88e1-0afd6a60173f", "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
X1X6X2X7sigma_factor
01.0000000.0019961.0000001.0000000.005
10.0019960.0019960.0019960.0019960.005
21.0000001.0000001.0000001.0000000.005
31.0000001.0000001.0000001.0000000.005
41.0000000.0019961.0000000.0019960.005
\n", + "
" + ], + "text/plain": [ + " X1 X6 X2 X7 sigma_factor\n", + "0 1.000000 0.001996 1.000000 1.000000 0.005\n", + "1 0.001996 0.001996 0.001996 0.001996 0.005\n", + "2 1.000000 1.000000 1.000000 1.000000 0.005\n", + "3 1.000000 1.000000 1.000000 1.000000 0.005\n", + "4 1.000000 0.001996 1.000000 0.001996 0.005" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "display(df.head())" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "9e60fac2-3b20-493e-886a-892d572a28c6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", + "\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", + "\n", + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\n", + " \"Linear ANCOVA model with Coleman Forest (Permutation per tree and sample dataset per tree)\"\n", + ")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "7c99ce8c-a32d-447b-9dd2-85c8d310239f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", + "\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", + "\n", + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\"Linear ANCOVA model with Coleman Forest (Permutation per tree)\")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "67846a66-1817-46c8-9ccc-5281773c4f92", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", + "\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", + "\n", + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\"Linear ANCOVA model with Coleman Forest\")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0f772759-751d-440c-abcb-13f3ee6f7705", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "7cf30622-ffff-4d00-b474-0ac49fcfde4b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", + "\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", + "\n", + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\"Linear ANCOVA model with Permutation Forest\")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34294429-04f3-4b12-baf3-fa6fdc11646f", + "metadata": {}, "outputs": [], "source": [] } diff --git a/sktree/meson.build b/sktree/meson.build index 8608052b8..b593f75aa 100644 --- a/sktree/meson.build +++ b/sktree/meson.build @@ -54,7 +54,7 @@ cython_c_args += numpy_nodepr_api python_sources = [ '__init__.py', 'neighbors.py', - 'conftest.py', + # 'conftest.py', ] py3.install_sources( diff --git a/sktree/stats/__init__.py b/sktree/stats/__init__.py index b7301579c..0061cd66a 100644 --- a/sktree/stats/__init__.py +++ b/sktree/stats/__init__.py @@ -1,3 +1,3 @@ from ._might import MIGHT, MIGHT_MV -from .forestht import ForestHT, FeatureImportanceForestRegressor +from .forestht import FeatureImportanceForestRegressor, ForestHT from .permutationforest import PermutationForestClassifier, PermutationForestRegressor diff --git a/sktree/stats/_might.py b/sktree/stats/_might.py index ff3d9ac2b..d88630215 100644 --- a/sktree/stats/_might.py +++ b/sktree/stats/_might.py @@ -304,7 +304,7 @@ def test_diff(self, x, z, y, reps=1000, workers=1): X_permutedZ = np.hstack((x, permuted_Z)) perm_stat, perm_pos = self.statistic(X_permutedZ, y, return_pos=True) - # Boostrap sample the posterior from the two forests + # Bootsrap sample the posterior from the two forests null_stats = np.array( Parallel(n_jobs=workers)( [delayed(pos_diff)(observe_pos, perm_pos, y, limit=self.limit) for _ in range(reps)] diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 0d88f65df..3ad77c8f8 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -5,83 +5,22 @@ from sklearn.utils.validation import _is_fitted, check_X_y from sktree._lib.sklearn.ensemble._forest import ( + BaseForest, ForestClassifier, ForestRegressor, RandomForestRegressor, - BaseForest ) -from sktree._lib.sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor +from sktree._lib.sklearn.tree import DecisionTreeRegressor from ..ensemble import HonestForestClassifier from .utils import ( METRIC_FUNCTIONS, REGRESSOR_METRICS, _compute_null_distribution_coleman, - _pvalue, train_tree, ) -def tree_posterior( - tree: DecisionTreeClassifier, - X: ArrayLike, - y: ArrayLike, - covariate_index: ArrayLike = None, - test_size: float = 0.2, - seed=None, -) -> ArrayLike: - """Compute the posterior from each tree on the "OOB" samples. - - Parameters - ---------- - tree : DecisionTreeClassifier - The tree to compute the posterior from. - X : ArrayLike of shape (n_samples, n_features) - The data matrix. - y : ArrayLike of shape (n_samples, n_outputs) - The output matrix. - covariate_index : ArrayLike of shape (n_covariates,), optional - The indices of the covariates to permute, by default None, which - does not permute any columns. - test_size : float, optional - The size of the OOB set of samples, by default 0.2. - seed : int, optional - Random seed, by default None. - - Returns - ------- - posterior : ArrayLike of shape (n_samples, n_outputs) - The predicted posterior probabilities for each OOB sample from the tree. - For any in-bag samples, the posterior is NaN. - """ - # seed the random number generator using each tree's random seed(?) - rng = np.random.default_rng(tree.random_state) - - indices = np.arange(X.shape[0]) - - if covariate_index is not None: - # perform permutation of covariates - index_arr = rng.choice(indices, size=(X.shape[0], 1), replace=False, shuffle=False) - perm_X_cov = X[index_arr, covariate_index] - X[:, covariate_index] = perm_X_cov - - # XXX: we can replace this using Forest's generator for the in-bag/oob sample indices when - # https://github.com/scikit-learn/scikit-learn/pull/26736 is merged - # X_train, X_test, y_train, _, _, indices_test = train_test_split( - # X, y, indices, test_size=test_size - # ) - - # individual tree permutation of y labels - tree.fit(X, y, check_input=False) - # y_pred = tree.predict_proba(X_test)[:, 1] - - # Fill test set posteriors & set rest NaN - # posterior = np.full((y.shape[0], tree.n_outputs_), np.nan) - # posterior[indices_test] = y_pred.reshape(-1, tree.n_outputs_) - - # return posterior - - class ForestHT(MetaEstimatorMixin): """Forest hypothesis testing. @@ -605,9 +544,73 @@ def test( return observe_stat, pval -class FeatureImportanceForestRegressor(MetaEstimatorMixin): +class BaseForestHT(MetaEstimatorMixin): + def __init__( + self, + estimator=None, + n_estimators=100, + criterion="squared_error", + max_depth=None, + min_samples_split=2, + min_samples_leaf=1, + min_weight_fraction_leaf=0.0, + max_features="sqrt", + max_leaf_nodes=None, + min_impurity_decrease=0.0, + bootstrap=False, + oob_score=False, + n_jobs=None, + random_state=None, + verbose=0, + warm_start=False, + ccp_alpha=0.0, + max_samples=None, + permute_per_tree=True, + **estimator_kwargs, + ): + self.estimator = estimator + self.n_jobs = n_jobs + self.n_estimators = n_estimators + self.criterion = criterion + self.max_depth = max_depth + self.min_samples_split = min_samples_split + self.min_samples_leaf = min_samples_leaf + self.min_weight_fraction_leaf = min_weight_fraction_leaf + self.max_features = max_features + self.max_leaf_nodes = max_leaf_nodes + self.min_impurity_decrease = min_impurity_decrease + self.bootstrap = bootstrap + self.oob_score = oob_score + self.random_state = random_state + self.verbose = verbose + self.warm_start = warm_start + self.ccp_alpha = ccp_alpha + self.max_samples = max_samples + self.estimator_kwargs = estimator_kwargs + self.permute_per_tree = permute_per_tree + + def reset(self): + class_attributes = dir(type(self)) + instance_attributes = dir(self) + + for attr_name in instance_attributes: + if attr_name.endswith("_") and attr_name not in class_attributes: + delattr(self, attr_name) + + +class FeatureImportanceForestRegressor(BaseForestHT): """Forest hypothesis testing with continuous `y` variable. + The dataset is split into a training and testing dataset initially. Then there + are two forests that are trained: one on the original dataset, and one on the + permuted dataset. The dataset is either permuted once, or independently for + each tree in the permuted forest. The original test statistic is computed by + comparing the metric on both forests ``(metric_forest - metric_perm_forest)``. + + Then the output predictions are randomly sampled to recompute the test statistic + ``n_repeats`` times. The p-value is computed as the proportion of times the + null test statistic is greater than the original test statistic. + Parameters ---------- estimator : object, default=None @@ -801,26 +804,60 @@ def __init__( ccp_alpha=0.0, max_samples=None, permute_per_tree=True, + sample_dataset_per_tree=False, + **estimator_kwargs, ): - self.estimator = estimator - self.n_jobs = n_jobs - self.n_estimators = n_estimators - self.criterion = criterion - self.max_depth = max_depth - self.min_samples_split = min_samples_split - self.min_samples_leaf = min_samples_leaf - self.min_weight_fraction_leaf = min_weight_fraction_leaf - self.max_features = max_features - self.max_leaf_nodes = max_leaf_nodes - self.min_impurity_decrease = min_impurity_decrease - self.bootstrap = bootstrap - self.oob_score = oob_score - self.random_state = random_state - self.verbose = verbose - self.warm_start = warm_start - self.ccp_alpha = ccp_alpha - self.max_samples = max_samples + super().__init__( + estimator=estimator, + n_estimators=n_estimators, + criterion=criterion, + max_depth=max_depth, + min_samples_split=min_samples_split, + min_samples_leaf=min_samples_leaf, + min_weight_fraction_leaf=min_weight_fraction_leaf, + max_features=max_features, + max_leaf_nodes=max_leaf_nodes, + min_impurity_decrease=min_impurity_decrease, + bootstrap=bootstrap, + oob_score=oob_score, + n_jobs=n_jobs, + random_state=random_state, + verbose=verbose, + warm_start=warm_start, + ccp_alpha=ccp_alpha, + max_samples=max_samples, + **estimator_kwargs, + ) self.permute_per_tree = permute_per_tree + self.sample_dataset_per_tree = sample_dataset_per_tree + + def _get_estimator(self): + if self.estimator is None: + estimator_ = RandomForestRegressor( + n_estimators=self.n_estimators, + criterion=self.criterion, + max_depth=self.max_depth, + min_samples_split=self.min_samples_split, + min_samples_leaf=self.min_samples_leaf, + min_weight_fraction_leaf=self.min_weight_fraction_leaf, + max_features=self.max_features, + max_leaf_nodes=self.max_leaf_nodes, + min_impurity_decrease=self.min_impurity_decrease, + bootstrap=self.bootstrap, + oob_score=self.oob_score, + n_jobs=self.n_jobs, + random_state=self.random_state, + verbose=self.verbose, + warm_start=self.warm_start, + ccp_alpha=self.ccp_alpha, + max_samples=self.max_samples, + **self.estimator_kwargs, + ) + elif isinstance(self.estimator, ForestRegressor): + raise RuntimeError(f"Estimator must be a ForestRegressor, got {type(self.estimator)}") + else: + estimator_ = self.estimator + return estimator_ def _statistic( self, @@ -829,7 +866,6 @@ def _statistic( y: ArrayLike, covariate_index: ArrayLike = None, metric="mse", - test_size=0.2, return_posteriors: bool = False, **metric_kwargs, ): @@ -837,9 +873,36 @@ def _statistic( metric_func = METRIC_FUNCTIONS[metric] rng = np.random.default_rng(self.random_state) n_samples = X.shape[0] - indices = np.arange(n_samples, dtype=int) - if self.permute_per_tree: + if self.permute_per_tree and not self.sample_dataset_per_tree: + # first run a dummy fit on the samples to initialize the + # internal data structure of the forest + if not _is_fitted(estimator): + unique_y = np.unique(y) + X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) + estimator.fit(X_dummy, unique_y) + + # Fit each tree and compute posteriors with train test splits + n_samples_test = len(self.indices_test_) + + # now initialize posterior array as (n_trees, n_samples_test, n_outputs) + posterior_arr = np.zeros((self.n_estimators, n_samples_test, estimator.n_outputs_)) + for idx in range(self.n_estimators): + tree: DecisionTreeRegressor = estimator.estimators_[idx] + train_tree( + tree, X[self.indices_train_, :], y[self.indices_train_, :], covariate_index + ) + + y_pred = tree.predict(X[self.indices_test_, :]).reshape(-1, tree.n_outputs_) + + # Fill test set posteriors & set rest NaN + posterior_arr[idx, ...] = y_pred # posterior + + y_true_final = y[self.indices_test_, :] + # Average all posteriors + posterior_final = np.nanmean(posterior_arr, axis=0) + samples = np.argwhere(~np.isnan(posterior_final).any(axis=1)).squeeze() + elif self.permute_per_tree and self.sample_dataset_per_tree: # first run a dummy fit on the samples to initialize the # internal data structure of the forest if not _is_fitted(estimator): @@ -847,38 +910,49 @@ def _statistic( X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) estimator.fit(X_dummy, unique_y) + # now initialize posterior array as (n_trees, n_samples, n_outputs) + posterior_arr = np.full((self.n_estimators, n_samples, estimator.n_outputs_), np.nan) # Fit each tree and compute posteriors with train test splits - posterior_arr = np.zeros((self.n_estimators, n_samples, estimator.n_outputs_)) for idx in range(self.n_estimators): - seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32) + # sample train/test dataset for each tree indices_train, indices_test = train_test_split( - indices, test_size=test_size, stratify=y, shuffle=True, random_state=seed + np.arange(n_samples, dtype=int), + test_size=self.test_size_, + shuffle=True, + random_state=rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32), ) tree: DecisionTreeRegressor = estimator.estimators_[idx] train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) - y_pred = tree.predict(X[indices_test, :]) + y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) - # Fill test set posteriors & set rest NaN - posterior = np.full((y.shape[0], tree.n_outputs_), np.nan) - posterior[indices_test, :] = y_pred - posterior_arr[idx, ...] = posterior + posterior_arr[idx, indices_test, :] = y_pred # posterior # Average all posteriors posterior_final = np.nanmean(posterior_arr, axis=0) - samples = np.argwhere(~np.isnan(posterior_final).any(axis=1)).squeeze() - y_true_final = y[samples, :] - posterior_final = posterior_final[samples, :] - else: - if covariate_index is not None: - print("Permuting the covariate...") - # perform permutation of covariates - index_arr = rng.choice(indices, size=(X.shape[0], 1), replace=False, shuffle=False) - X[:, covariate_index] = X[index_arr, covariate_index] + # Find the row indices with NaN values in any column + nonnan_indices = np.where(~np.isnan(posterior_final).any(axis=1))[0] + + # Ignore all NaN values (samples not tested) + y_true_final = y[nonnan_indices, :] + posterior_final = posterior_final[nonnan_indices, :] + samples = nonnan_indices + else: X_train, X_test = X[self.indices_train_, :], X[self.indices_test_, :] y_train, y_test = y[self.indices_train_, :], y[self.indices_test_, :] + if covariate_index is not None: + # perform permutation of covariates + n_samples_train = X_train.shape[0] + index_arr = rng.choice( + np.arange(n_samples_train, dtype=int), + size=(n_samples_train, 1), + replace=False, + shuffle=True, + ) + X_train[:, covariate_index] = X_train[index_arr, covariate_index] + estimator.fit(X_train, y_train) y_pred = estimator.predict(X_test) @@ -887,10 +961,7 @@ def _statistic( y_true_final = y_test posterior_final = y_pred - # print('Y true: ', y_true_final) - # print('posterior: ', posterior_final) stat = metric_func(y_true_final, posterior_final, **metric_kwargs) - if covariate_index is None: # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) # arrays of y and predicted posterior @@ -904,21 +975,12 @@ def _statistic( return stat - def reset(self): - class_attributes = dir(type(self)) - instance_attributes = dir(self) - - for attr_name in instance_attributes: - if attr_name.endswith("_") and attr_name not in class_attributes: - delattr(self, attr_name) - def statistic( self, X: ArrayLike, y: ArrayLike, covariate_index: ArrayLike = None, metric="mse", - test_size=0.2, return_posteriors: bool = False, check_input: bool = True, **metric_kwargs, @@ -962,30 +1024,8 @@ def statistic( if metric not in REGRESSOR_METRICS: raise RuntimeError(f'Metric must be either "mse" or "mae", got {metric}') - if not hasattr(self, "estimator_") and self.estimator is None: - self.estimator_ = RandomForestRegressor( - n_estimators=self.n_estimators, - criterion=self.criterion, - max_depth=self.max_depth, - min_samples_split=self.min_samples_split, - min_samples_leaf=self.min_samples_leaf, - min_weight_fraction_leaf=self.min_weight_fraction_leaf, - max_features=self.max_features, - max_leaf_nodes=self.max_leaf_nodes, - min_impurity_decrease=self.min_impurity_decrease, - bootstrap=self.bootstrap, - oob_score=self.oob_score, - n_jobs=self.n_jobs, - random_state=self.random_state, - verbose=self.verbose, - warm_start=self.warm_start, - ccp_alpha=self.ccp_alpha, - max_samples=self.max_samples, - ) - elif not isinstance(self.estimator_, ForestRegressor): - raise RuntimeError(f"Estimator must be a ForestRegressor, got {type(self.estimator_)}") - if covariate_index is None: + self.estimator_ = self._get_estimator() estimator = self.estimator_ else: self.permuted_estimator_ = clone(self.estimator_) @@ -997,7 +1037,6 @@ def statistic( y, covariate_index=covariate_index, metric=metric, - test_size=test_size, return_posteriors=return_posteriors, **metric_kwargs, ) @@ -1054,14 +1093,18 @@ def test( y = y.reshape(-1, 1) indices = np.arange(X.shape[0]) - if not self.permute_per_tree: - # train/test split - # XXX: could add stratifying by y when y is classification - indices_train, indices_test = train_test_split( - indices, test_size=test_size, shuffle=True - ) - self.indices_train_ = indices_train - self.indices_test_ = indices_test + self.test_size_ = int(test_size * X.shape[0]) + # if not self.permute_per_tree: + # # train/test split + # # XXX: could add stratifying by y when y is classification + # indices_train, indices_test = train_test_split( + # indices, test_size=test_size, shuffle=True + # ) + # self.indices_train_ = indices_train + # self.indices_test_ = indices_test + indices_train, indices_test = train_test_split(indices, test_size=test_size, shuffle=True) + self.indices_train_ = indices_train + self.indices_test_ = indices_test if not hasattr(self, "samples_"): # first compute the test statistic on the un-permuted data @@ -1070,7 +1113,6 @@ def test( y, covariate_index=None, metric=metric, - test_size=test_size, return_posteriors=True, check_input=False, **metric_kwargs, @@ -1086,7 +1128,6 @@ def test( y, covariate_index=covariate_index, metric=metric, - test_size=test_size, return_posteriors=True, check_input=False, **metric_kwargs, @@ -1095,26 +1136,32 @@ def test( # Note: at this point, both `estimator` and `permuted_estimator_` should # have been fitted already, so we can now compute on the null by resampling # the posteriors and computing the test statistic on the resampled posteriors - metric_star, metric_star_pi = _compute_null_distribution_coleman( - X_test=X, - y_test=y, - y_pred_proba_normal=observe_posteriors, - y_pred_proba_perm=permute_posteriors, - normal_samples=observe_samples, - perm_samples=permute_samples, - metric=metric, - n_repeats=n_repeats, - seed=self.random_state, - ) - # print(observe_posteriors) - # print(permute_posteriors) - # metric^\pi - metric + if self.sample_dataset_per_tree: + metric_star, metric_star_pi = _compute_null_distribution_coleman( + y_test=y[observe_samples, :], + y_pred_proba_normal=observe_posteriors, + y_pred_proba_perm=permute_posteriors, + metric=metric, + n_repeats=n_repeats, + seed=self.random_state, + ) + else: + metric_star, metric_star_pi = _compute_null_distribution_coleman( + y_test=y[self.indices_test_, :], + y_pred_proba_normal=observe_posteriors, + y_pred_proba_perm=permute_posteriors, + metric=metric, + n_repeats=n_repeats, + seed=self.random_state, + ) + # metric^\pi - metric = observed test statistic, which under the null is normally distributed around 0 observe_stat = permute_stat - observe_stat - # metric^\pi_j - metric_j + # metric^\pi_j - metric_j, which is centered at 0 null_dist = metric_star_pi - metric_star - pval = _pvalue(observe_stat=observe_stat, permuted_stat=null_dist, correction=True) + # compute pvalue + pvalue = (1 + (null_dist >= observe_stat).sum()) / (1 + n_repeats) if return_posteriors: self.observe_posteriors_ = observe_posteriors @@ -1123,4 +1170,4 @@ def test( self.permute_samples_ = permute_samples self.null_dist_ = null_dist - return observe_stat, pval + return observe_stat, pvalue diff --git a/sktree/stats/permutationforest.py b/sktree/stats/permutationforest.py index a4ce3cde6..fb9c6a98b 100644 --- a/sktree/stats/permutationforest.py +++ b/sktree/stats/permutationforest.py @@ -7,7 +7,7 @@ from sktree._lib.sklearn.ensemble._forest import BaseForest, ForestClassifier, ForestRegressor -from .utils import METRIC_FUNCTIONS, REGRESSOR_METRICS, compute_null_distribution_perm +from .utils import METRIC_FUNCTIONS, REGRESSOR_METRICS, _compute_null_distribution_perm class BasePermutationForest(MetaEstimatorMixin): @@ -259,7 +259,7 @@ def test( # compute null distribution of the test statistic # WARNING: this could take a long time, since it fits a new forest - null_dist = compute_null_distribution_perm( + null_dist = _compute_null_distribution_perm( X_train=X[self.indices_train_, :], y_train=y[self.indices_train_, :], X_test=X[self.indices_test_, :], diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index c212eae33..93e2138f8 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -4,9 +4,13 @@ from sklearn import datasets from sktree._lib.sklearn.tree import DecisionTreeClassifier -from sktree.stats import MIGHT, PermutationForestClassifier, PermutationForestRegressor +from sktree.stats import ( + FeatureImportanceForestRegressor, + PermutationForestClassifier, + PermutationForestRegressor, +) from sktree.stats.forestht import ForestHT -from sktree.tree import ObliqueDecisionTreeClassifier, PatchObliqueDecisionTreeClassifier +from sktree.tree import ObliqueDecisionTreeClassifier # load the iris dataset # and randomly permute it @@ -34,7 +38,13 @@ def test_forestht_proper_attributes(): @pytest.mark.slowtest -@pytest.mark.parametrize("hypotester", [PermutationForestRegressor]) +@pytest.mark.parametrize( + "hypotester", + [ + # PermutationForestRegressor, + FeatureImportanceForestRegressor + ], +) def test_linear_model(hypotester): r"""Test hypothesis testing forests using MSE from linear model simulation. @@ -94,6 +104,75 @@ def test_linear_model(hypotester): assert pvalue > 0.05, f"pvalue: {pvalue}" +@pytest.mark.slowtest +@pytest.mark.parametrize( + "hypotester", + [ + # PermutationForestRegressor, + FeatureImportanceForestRegressor + ], +) +def test_linear_model_withcoleman(hypotester): + r"""Test hypothesis testing forests using MSE from linear model simulation. + + See https://arxiv.org/pdf/1904.07830.pdf Figure 1. + + Y = Beta * X_1 + Beta * I(X_6 = 2) + \epsilon + """ + beta = 10.0 + sigma = 0.5 + n_samples = 600 + n_estimators = 125 + test_size = 0.1 + n_repeats = 200 + permute_per_tree = True + metric = "mse" + + rng = np.random.default_rng(seed) + + # sample covariates + X_15 = rng.uniform(0, 1, size=(n_samples, 5)) + X_610 = np.zeros((n_samples, 5)) + for idx in range(5): + X_610[:, idx] = np.argwhere( + rng.multinomial(1, [1.0 / 3, 1.0 / 3, 1.0 / 3], size=(n_samples,)) + )[:, 1] + X = np.concatenate((X_15, X_610), axis=1) + assert X.shape == (n_samples, 10) + + # sample noise + epsilon = rng.normal(size=n_samples, loc=0.0, scale=sigma) + + # compute final y of (n_samples,) + y = beta * X[:, 0] + (beta * (X[:, 5] == 2.0)) + epsilon + est = hypotester( + max_features=1.0, + random_state=seed, + n_estimators=n_estimators, + permute_per_tree=permute_per_tree, + n_jobs=-1, + ) + + # test for X_1 + stat, pvalue = est.test(X, y, [0], metric=metric, test_size=test_size, n_repeats=n_repeats) + print("X1: ", pvalue) + assert pvalue < 0.05, f"pvalue: {pvalue}" + + # test for X_6 + stat, pvalue = est.test(X, y, [5], metric=metric, test_size=test_size, n_repeats=n_repeats) + print("X6: ", pvalue) + assert pvalue < 0.05, f"pvalue: {pvalue}" + + # test for a few unimportant other X + for covariate_index in [1, 6]: + # test for X_2, X_7 + stat, pvalue = est.test( + X, y, [covariate_index], metric=metric, test_size=test_size, n_repeats=n_repeats + ) + print("X2/7: ", pvalue) + assert pvalue > 0.05, f"pvalue: {pvalue}" + + @pytest.mark.slowtest @pytest.mark.parametrize("hypotester", [PermutationForestClassifier]) def test_correlated_logit_model(hypotester): diff --git a/sktree/stats/tests/test_might.py b/sktree/stats/tests/test_might.py index 825137217..ff613c571 100644 --- a/sktree/stats/tests/test_might.py +++ b/sktree/stats/tests/test_might.py @@ -4,7 +4,7 @@ from sktree._lib.sklearn.tree import DecisionTreeClassifier from sktree.stats import MIGHT -from sktree.tree import ObliqueDecisionTreeClassifier, PatchObliqueDecisionTreeClassifier +from sktree.tree import ObliqueDecisionTreeClassifier # load the iris dataset # and randomly permute it diff --git a/sktree/stats/utils.py b/sktree/stats/utils.py index 3791a388f..c0a988520 100644 --- a/sktree/stats/utils.py +++ b/sktree/stats/utils.py @@ -15,8 +15,8 @@ from sktree._lib.sklearn.tree import DecisionTreeClassifier -def _mutual_information(y_true, y_pred): - H_YX = np.mean(entropy(y_pred, base=np.exp(1))) +def _mutual_information(y_true, y_pred_proba): + H_YX = np.mean(entropy(y_pred_proba, base=np.exp(1), axis=1)) _, counts = np.unique(y_true, return_counts=True) H_Y = entropy(counts, base=np.exp(1)) return max(H_Y - H_YX, 0) @@ -55,11 +55,11 @@ def train_tree( # seed the random number generator using each tree's random seed(?) rng = np.random.default_rng(tree.random_state) - indices = np.arange(X.shape[0]) + indices = np.arange(X.shape[0], dtype=int) if covariate_index is not None: # perform permutation of covariates - index_arr = rng.choice(indices, size=(X.shape[0], 1), replace=False, shuffle=False) + index_arr = rng.choice(indices, size=(X.shape[0], 1), replace=False, shuffle=True) perm_X_cov = X[index_arr, covariate_index] X[:, covariate_index] = perm_X_cov @@ -67,34 +67,7 @@ def train_tree( tree.fit(X, y, check_input=False) -def _pvalue(observe_stat: float, permuted_stat: ArrayLike, correction: bool = True) -> float: - """Compute pvalue. - - Implements the pvalue calculation from optionally with a correction factor. - - Parameters - ---------- - observe_stat : float - The observed test statistic. - permuted_stat : ArrayLike of shape (n_repeats,) - The array of test statistics computed on permutations. - correction : bool - Whether to use correction and add 1 to the numerator and denominator, by default True. - - Returns - ------- - pval : float - The pvalue. - """ - n_repeats = len(permuted_stat) - if correction: - pval = (1 + (permuted_stat < observe_stat).sum()) / (1 + n_repeats) - else: - pval = (permuted_stat < observe_stat).sum() / n_repeats - return pval - - -def compute_null_distribution_perm( +def _compute_null_distribution_perm( X_train: ArrayLike, y_train: ArrayLike, X_test: ArrayLike, @@ -135,8 +108,6 @@ def compute_null_distribution_perm( test_index_arr = np.arange(n_samples_test, dtype=int).reshape(-1, 1) X = np.concatenate((X_train, X_test), axis=0) - index_arr = np.arange(X.shape[0], dtype=int) # .reshape(-1, 1) - null_metrics = np.zeros((n_repeats,)) for idx in range(n_repeats): @@ -162,12 +133,9 @@ def compute_null_distribution_perm( def _compute_null_distribution_coleman( - X_test: ArrayLike, y_test: ArrayLike, y_pred_proba_normal: ArrayLike, y_pred_proba_perm: ArrayLike, - normal_samples: ArrayLike, - perm_samples: ArrayLike, metric: str = "mse", n_repeats: int = 1000, seed: int = None, @@ -209,33 +177,49 @@ def _compute_null_distribution_coleman( metric_func = METRIC_FUNCTIONS[metric] - # sample two sets of equal number of trees from the combined forest + # sample two sets of equal number of trees from the combined forest these are the posteriors all_y_pred = np.concatenate((y_pred_proba_normal, y_pred_proba_perm), axis=0) - # get the indices of the samples that we have a posterior for, so each element - # is an index into `y_test` - all_samples_pred = np.concatenate((normal_samples, perm_samples), axis=0) + n_samples_test = len(y_test) + assert len(all_y_pred) == 2 * n_samples_test + + # create two stacked index arrays of y_test resulting in [1, ..., N, 1, ..., N] + y_test_ind_arr = np.hstack( + (np.arange(n_samples_test, dtype=int), np.arange(n_samples_test, dtype=int)) + ) - n_samples_final = len(all_samples_pred) + # create index array of [1, ..., 2N] to slice into `all_y_pred` + y_pred_ind_arr = np.arange((2 * n_samples_test), dtype=int) + + # # get the indices of the samples that we have a posterior for, so each element + # # is an index into `y_test` + # all_samples_pred = np.concatenate((normal_samples, perm_samples), axis=0) + + # n_samples_final = len(all_samples_pred) # pre-allocate memory for the index array - index_arr = np.arange(n_samples_final, dtype=int) + # index_arr = np.arange(n_samples_final, dtype=int) metric_star = np.zeros((n_repeats,)) metric_star_pi = np.zeros((n_repeats,)) for idx in range(n_repeats): # two sets of random indices from 1 : 2N are sampled using Fisher-Yates - rng.shuffle(index_arr) - first_half_index = index_arr[: n_samples_final // 2] - second_half_index = index_arr[n_samples_final // 2 :] + rng.shuffle(y_pred_ind_arr) + + first_forest_inds = y_pred_ind_arr[:n_samples_test] + second_forest_inds = y_pred_ind_arr[:n_samples_test] + + # index into y_test for first half and second half + first_half_index_test = y_test_ind_arr[first_forest_inds] + second_half_index_test = y_test_ind_arr[second_forest_inds] # now get the pointers to the actual samples used for the metric - y_test_first_half = y_test[all_samples_pred[first_half_index]] - y_test_second_half = y_test[all_samples_pred[second_half_index]] + y_test_first_half = y_test[first_half_index_test] + y_test_second_half = y_test[second_half_index_test] # compute two instances of the metric from the sampled trees - first_half_metric = metric_func(y_test_first_half, all_y_pred[first_half_index]) - second_half_metric = metric_func(y_test_second_half, all_y_pred[second_half_index]) + first_half_metric = metric_func(y_test_first_half, all_y_pred[first_forest_inds]) + second_half_metric = metric_func(y_test_second_half, all_y_pred[second_forest_inds]) metric_star[idx] = first_half_metric metric_star_pi[idx] = second_half_metric From aab5df304790174dfc8f04100c437608218f6bb7 Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Mon, 18 Sep 2023 10:06:36 -0400 Subject: [PATCH 16/70] FIX correct MI calculation for MIGHT 2-class --- sktree/stats/_might.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/sktree/stats/_might.py b/sktree/stats/_might.py index d88630215..102dc1448 100644 --- a/sktree/stats/_might.py +++ b/sktree/stats/_might.py @@ -155,7 +155,9 @@ def statistic( posterior_final[:, 0], posterior_final[:, 1], max_fpr=self.limit ) elif stat == "MI": - H_YX = np.mean(entropy(posterior_final[:, 1], base=np.exp(1))) + class_zero = (1 - posterior_final[:, 1]).reshape(-1, 1) + full_class = np.hstack((class_zero, posterior_final[:, 1].reshape(-1, 1))) + H_YX = np.mean(entropy(full_class, base=np.exp(1), axis=1)) _, counts = np.unique(posterior_final[:, 0], return_counts=True) H_Y = entropy(counts, base=np.exp(1)) self.stat = max(H_Y - H_YX, 0) From 972fe95547f04083c0c9f8e597a6a1fb219264bf Mon Sep 17 00:00:00 2001 From: Adam Li Date: Mon, 18 Sep 2023 10:09:48 -0400 Subject: [PATCH 17/70] Correlated logit model Signed-off-by: Adam Li --- .../test_permutation_forest.ipynb | 585 ++++++++++++++---- sktree/stats/__init__.py | 2 +- sktree/stats/forestht.py | 578 ++++++++++++++++- 3 files changed, 1030 insertions(+), 135 deletions(-) diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/test_permutation_forest.ipynb index d0e72e4d4..12a0e6c0e 100644 --- a/benchmarks_nonasv/test_permutation_forest.ipynb +++ b/benchmarks_nonasv/test_permutation_forest.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "id": "b658bdd8-a3e6-4051-9d66-f2a153113234", "metadata": {}, "outputs": [], @@ -13,27 +13,23 @@ "import numpy as np\n", "import pandas as pd\n", "import seaborn as sns\n", + "from scipy.special import expit\n", "\n", - "from sktree.stats import FeatureImportanceForestRegressor, PermutationForestRegressor\n", + "from sktree.stats import (\n", + " FeatureImportanceForestClassifier,\n", + " FeatureImportanceForestRegressor,\n", + " PermutationForestRegressor,\n", + ")\n", "\n", "seed = 12345" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 2, "id": "05b0b53e-0525-45ce-9f7e-0322a30221cf", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "%load_ext autoreload\n", "%autoreload 2" @@ -41,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 5, "id": "5e2d1279-fa4f-47ef-aa48-fac6d47159ad", "metadata": {}, "outputs": [], @@ -137,14 +133,112 @@ " pass\n", "\n", "\n", - "def correlated_logit_model():\n", - " pass\n", - "\n", - "\n", "def random_forest_model():\n", " pass" ] }, + { + "cell_type": "code", + "execution_count": 17, + "id": "3db4f740-afd9-413e-8089-a8245f2a0747", + "metadata": {}, + "outputs": [], + "source": [ + "def correlated_logit_model(beta=5.0, seed=None):\n", + " r\"\"\"Test MIGHT using MSE from linear model simulation.\n", + "\n", + " See https://arxiv.org/pdf/1904.07830.pdf Figure 1.\n", + "\n", + " P(Y = 1 | X) = expit(beta * \\\\sum_{j=2}^5 X_j)\n", + " \"\"\"\n", + " n_samples = 600\n", + " n_estimators = 125\n", + " n_jobs = -1\n", + " max_features = \"sqrt\"\n", + " test_size = 1.0 / 6\n", + " metric = \"mse\"\n", + " n_repeats = 200\n", + " permute_per_tree = True\n", + " sample_dataset_per_tree = True\n", + "\n", + " n = 500 # Number of time steps\n", + " ar_coefficient = 0.15\n", + "\n", + " rng = np.random.default_rng(seed)\n", + "\n", + " X = np.zeros((n_samples, n))\n", + " for idx in range(n_samples):\n", + " # sample covariates\n", + " white_noise = rng.standard_normal(size=n)\n", + "\n", + " # Create an array to store the simulated AR(1) time series\n", + " ar1_series = np.zeros(n)\n", + " ar1_series[0] = white_noise[0]\n", + "\n", + " # Simulate the AR(1) process\n", + " for t in range(1, n):\n", + " ar1_series[t] = ar_coefficient * ar1_series[t - 1] + white_noise[t]\n", + "\n", + " X[idx, :] = ar1_series\n", + "\n", + " # now compute the output labels\n", + " y_proba = expit(beta * X[:, 1:5].sum(axis=1))\n", + " assert y_proba.shape == (n_samples,)\n", + " y = rng.binomial(1, y_proba, size=n_samples) # .reshape(-1, 1)\n", + "\n", + " pvalue_dict = {}\n", + "\n", + " # initialize hypothesis tester\n", + " est = FeatureImportanceForestClassifier(\n", + " max_features=1.0,\n", + " random_state=seed,\n", + " n_estimators=n_estimators,\n", + " n_jobs=-1,\n", + " permute_per_tree=permute_per_tree,\n", + " sample_dataset_per_tree=sample_dataset_per_tree,\n", + " # bootstrap=True,\n", + " # max_samples=subsample_size\n", + " )\n", + "\n", + " # test for X_2 important\n", + " stat, pvalue = est.test(\n", + " X.copy(), y.copy(), [1], test_size=test_size, n_repeats=n_repeats, metric=metric\n", + " )\n", + " pvalue_dict[\"X2\"] = pvalue\n", + " print(\"X2: \", pvalue)\n", + " # assert pvalue < 0.05, f\"pvalue: {pvalue}\"\n", + "\n", + " # test for X_1 unimportant\n", + " stat, pvalue = est.test(\n", + " X.copy(), y.copy(), [0], test_size=test_size, n_repeats=n_repeats, metric=metric\n", + " )\n", + " pvalue_dict[\"X1\"] = pvalue\n", + " print(\"X1: \", pvalue)\n", + " # assert pvalue > 0.05, f\"pvalue: {pvalue}\"\n", + "\n", + " # test for X_500 unimportant\n", + " stat, pvalue = est.test(\n", + " X.copy(),\n", + " y.copy(),\n", + " [n - 1],\n", + " test_size=test_size,\n", + " n_repeats=n_repeats,\n", + " metric=metric,\n", + " )\n", + " pvalue_dict[\"X500\"] = pvalue\n", + " print(\"X500: \", pvalue)\n", + " # assert pvalue > 0.05, f\"pvalue: {pvalue}\"\n", + " return pvalue_dict" + ] + }, + { + "cell_type": "markdown", + "id": "36acd19f-0e66-455e-b6e4-288e1c9d020c", + "metadata": {}, + "source": [ + "# Run Experiment on Linear ANCOVA Model" + ] + }, { "cell_type": "code", "execution_count": 25, @@ -350,7 +444,7 @@ " for idx in range(5):\n", " new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32)\n", "\n", - " elements_dict = linear_model_ancova(sigma_factor, new_seed)\n", + " elements_dict = correlated_logit_model(beta, new_seed)\n", " for key, value in elements_dict.items():\n", " pvalue_dict[key].append(value)\n", " pvalue_dict[\"sigma_factor\"].append(sigma_factor)\n", @@ -360,7 +454,310 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 28, + "id": "9e60fac2-3b20-493e-886a-892d572a28c6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", + "\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", + "\n", + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\n", + " \"Linear ANCOVA model with Coleman Forest (Permutation per tree and sample dataset per tree)\"\n", + ")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "7c99ce8c-a32d-447b-9dd2-85c8d310239f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", + "\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", + "\n", + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\"Linear ANCOVA model with Coleman Forest (Permutation per tree)\")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "67846a66-1817-46c8-9ccc-5281773c4f92", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", + "\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", + "\n", + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\"Linear ANCOVA model with Coleman Forest\")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "7cf30622-ffff-4d00-b474-0ac49fcfde4b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAJQCAYAAAATyPJiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hUVfoH8O8t02t6IwVI6AgISlEEFEVQ7G1FRda1uxbEXXvB3mVdsbv4U1TEui4qKs1CEWlKJ5CQQHqZ3u89vz8mGQlpk2QmMwnv53nyQGbuzJwpOXPfc877Ho4xxkAIIYQQQgghXcDHugGEEEIIIYSQno8CC0IIIYQQQkiXUWBBCCGEEEII6TIKLAghhBBCCCFdRoEFIYQQQgghpMsosCCEEEIIIYR0GQUWhBBCCCGEkC6jwIIQQgghhBDSZRRYEEIIIYQQQrqMAgtCIqS4uBgcx2HRokWxbgrp5bryWVu9ejU4jsPq1asj3i4AmDx5MiZPnhz2scOGDYtKO0hzV199NfLy8mLdDEJIL0aBBSFhWLRoETiOw2+//RbrpnSLf/zjH+A4DpdeemmL1zee2HIch08//bTZ9Q8//DA4jkNNTU2z61avXo0LLrgA6enpUCqVSE1NxcyZM/HZZ581O7a2thZ33XUXBg4cCLVajcTEREybNg3/+9//mhx3zjnnQKvVwm63t/qcZs2aBaVSidra2tBlFosFarUaHMdh165drd6WdF5ZWRkefvhhbN26NeL3nZeXF/occhyH1NRUTJw4EZ9//nnEH6u7LFy4sEuDE9F8vTvryP7i6J9x48bFunkt+uCDD/DSSy/FuhmE9DhirBtASG+Rm5sLt9sNhUIR66Z0CWMMH374IfLy8vDVV1/BbrfDYDC0evz8+fNxwQUXgOO4du/7oYcewvz581FQUIDrr78eubm5qK2txddff40LL7wQixcvxuWXXw4A2LNnD0477TRUV1djzpw5GDNmDCwWCxYvXoyZM2di3rx5ePbZZwEEg4avvvoKn3/+Oa666qpmj+tyufDll1/izDPPRFJSUujypUuXguM4pKenY/HixXjsscc6+nKRo3z33XdNfi8rK8MjjzyCvLw8jBw5MuKPN3LkSNx5552hx3r99ddxwQUX4NVXX8UNN9wQ8ceLtoULFyI5ORlXX311p27f1uv95ptvQpblrjeyk/7yl79gxowZTS5LSUmJUWva9sEHH2D79u24/fbbY90UQnoUCiwIiRCO46BWq2PdjDa5XC5otdo2j1m9ejUOHTqElStXYtq0afjss88we/bsFo8dOXIktm7dis8//xwXXHBBm/f7ySefYP78+bjooovwwQcfNAnA7rrrLixfvhx+vx8A4Pf7cdFFF6G+vh4//vgjxo4dGzr2jjvuwKxZs/Dcc89hzJgxuPTSS3HOOefAYDDggw8+aDGw+PLLL+F0OjFr1qwml7///vuYMWMGcnNz8cEHH1BgEQFKpbJbHy8rKwtXXHFF6PerrroK+fn5ePHFF7scWHg8HiiVSvB875jcj/Wgx/HHH9/kvYqU3vY+EdKT0V8hIRHS0rr3q6++Gnq9HocPH8Z5550HvV6PlJQUzJs3D5IkNbm9LMt46aWXMHToUKjVaqSlpeH6669HfX19k+O+/PJLnHXWWcjMzIRKpUL//v3x6KOPNru/xvXrmzZtwimnnAKtVot777233eexePFiDBkyBFOmTMHUqVOxePHiVo+97LLLMGDAAMyfPx+MsTbv94EHHkBiYiLeeeedFk9wpk2bhrPPPhsA8Omnn2L79u24++67mwQVACAIAl5//XWYzWY8/PDDAACNRoMLLrgAK1asQFVVVbP7/uCDD2AwGHDOOeeELispKcFPP/2Eyy67DJdddhmKioqwdu3aNp9Do8alXnv37sUVV1wBk8mElJQUPPDAA2CMobS0FOeeey6MRiPS09Px/PPPN7uPqqoqXHPNNUhLS4NarcaIESPw7rvvNjvOYrHg6quvhslkgtlsxuzZs2GxWFps1+7du3HRRRchMTERarUaY8aMwX//+9+wntORfv/9d3Ac1+S2mzZtAsdxOP7445scO3369Cbv0ZE5FqtXr8YJJ5wAAJgzZ05o+cvRS3127tyJKVOmQKvVIisrC88880yH29woPT0dgwcPRlFRUeiyw4cP469//SvS0tKgUqkwdOhQvPPOO01u15h78tFHH+H+++9HVlYWtFotbDZb6O+4pKQEZ599NvR6PbKysvDKK68AAP744w+ceuqp0Ol0oSD1SI2fl6M1LrEsLi4GEFzatWPHDqxZsyb0WjW+lnV1dZg3bx6GDx8OvV4Po9GI6dOnY9u2bU2eQ1uvd0s5Fk6nE3feeSeys7OhUqkwcOBAPPfcc83+njmOwy233IIvvvgCw4YNC72O3377bXhvTBgOHDiAiy++GImJidBqtRg3bhyWLVvW5Ji23icA2LBhA84880yYTCZotVpMmjQJv/zyS5P7sNvtuP3225GXlweVSoXU1FScfvrp2Lx5M4DgZ3jZsmU4ePBg6DWk3BRCwkOBBSFRJkkSpk2bhqSkJDz33HOYNGkSnn/+ebzxxhtNjrv++utx11134aSTTsKCBQswZ84cLF68GNOmTQuN5APBkxG9Xo+5c+diwYIFGD16NB588EHcfffdzR67trYW06dPx8iRI/HSSy9hypQpbbbV6/Xi008/xV/+8hcAwaULK1euREVFRYvHC4KA+++/H9u2bWtzXfu+ffuwe/dunHfeeW0uq2r01VdfAUCLsw8AYDKZcO6552L37t0oLCwEEFwOFQgE8PHHHzc5tq6uDsuXL8f5558PjUYTuvzDDz+ETqfD2WefjRNPPBH9+/dvM4hqyaWXXgpZlvHUU09h7NixeOyxx/DSSy/h9NNPR1ZWFp5++mnk5+dj3rx5+PHHH0O3c7vdmDx5Mt577z3MmjULzz77LEwmE66++mosWLAgdBxjDOeeey7ee+89XHHFFXjsscdw6NChFmeQduzYgXHjxmHXrl24++678fzzz0On0+G8887rcM7BsGHDYDabm7T5p59+As/z2LZtW+gkTpZlrF27FqecckqL9zN48GDMnz8fAHDdddfhvffew3vvvdfk+Pr6epx55pkYMWIEnn/+eQwaNAj//Oc/8c0333SozY38fj9KS0tDS94qKysxbtw4/PDDD7jllluwYMEC5Ofn45prrmlxDf2jjz6KZcuWYd68eXjiiSdCMzCSJGH69OnIzs7GM888g7y8PNxyyy1YtGgRzjzzTIwZMwZPP/00DAYDrrrqqiaBTbheeukl9OnTB4MGDQq9Vvfddx+A4En3F198gbPPPhsvvPAC7rrrLvzxxx+YNGkSysrKAIT3eh+JMYZzzjkHL774Is4880y88MILGDhwIO666y7MnTu32fE///wzbrrpJlx22WV45pln4PF4cOGFFzbJW2qLy+VCTU1Nk5/Gvq2yshITJkzA8uXLcdNNN+Hxxx+Hx+PBOeec0+Lnt6X3aeXKlTjllFNgs9nw0EMP4YknnoDFYsGpp56KX3/9NXTbG264Aa+++iouvPBCLFy4EPPmzYNGownlWd13330YOXIkkpOTQ68h5VsQEiZGCGnXf/7zHwaAbdy4sdVjioqKGAD2n//8J3TZ7NmzGQA2f/78JseOGjWKjR49OvT7Tz/9xACwxYsXNznu22+/bXa5y+Vq9tjXX38902q1zOPxhC6bNGkSA8Bee+21sJ/nJ598wgCwffv2McYYs9lsTK1WsxdffLHF5/rss8+yQCDACgoK2IgRI5gsy4wxxh566CEGgFVXVzPGGPvyyy8ZgGb305qRI0cyk8nU5jEvvPACA8D++9//MsYYCwQCLCMjg40fP77Jca+99hoDwJYvX97k8uHDh7NZs2aFfr/33ntZcnIy8/v97bav8fldd911ocsCgQDr06cP4ziOPfXUU6HL6+vrmUajYbNnzw5d9tJLLzEA7P333w9d5vP52Pjx45ler2c2m40xxtgXX3zBALBnnnmmyeNMnDix2WfttNNOY8OHD2/yGZBlmU2YMIEVFBSELlu1ahUDwFatWtXmczzrrLPYiSeeGPr9ggsuYBdccAETBIF98803jDHGNm/ezACwL7/8MnTcpEmT2KRJk0K/b9y4sVlbjzwWAPu///u/0GVer5elp6ezCy+8sM32McZYbm4uO+OMM1h1dTWrrq5m27ZtY5dddhkDwP7+978zxhi75pprWEZGBqupqWly28suu4yZTKbQ31Pj69KvX79mf2ONf8dPPPFE6LLG95XjOPbRRx+FLt+9ezcDwB566KHQZY2fl6M19itFRUWhy4YOHdrk9Wvk8XiYJElNLisqKmIqlapJ/9LW6z179myWm5sb+r3x8/XYY481Oe6iiy5iHMexwsLC0GUAmFKpbHLZtm3bGAD28ssvN3uso9sJoMWfxs/h7bffzgCwn376KXQ7u93O+vbty/Ly8kLPvbX3SZZlVlBQwKZNmxbqhxgL9pd9+/Zlp59+eugyk8nEbr755jbbfNZZZzV5rQgh4aEZC0K6wdFrvSdOnIgDBw6Efl+6dClMJhNOP/30JqN5o0ePhl6vx6pVq0LHHjnqbrfbUVNTg4kTJ8LlcmH37t1NHkelUmHOnDlht3Px4sUYM2YM8vPzAQAGgwFnnXVWmyP5R85afPHFFy0e0zjCHc5sBYB2E8aPvK/G+xYEAZdddhnWrVsXWloCBJdBpaWl4bTTTgtd9vvvv+OPP/4IzcwAwdmZmpoaLF++PKw2AsDf/va30P8FQcCYMWPAGMM111wTutxsNmPgwIFN3u+vv/4a6enpTR5foVDg1ltvhcPhwJo1a0LHiaKIG2+8scnj/P3vf2/Sjrq6OqxcuRKXXHJJ6DNRU1OD2tpaTJs2Dfv27cPhw4fDfl5A8DO6efNmOJ1OAMHR6hkzZmDkyJH46aefAARnMTiOw8knn9yh+z6SXq9vsu5eqVTixBNPbPJ6teW7775DSkoKUlJSMGLECCxduhRXXnklnn76aTDG8Omnn2LmzJlgjDX525o2bRqsVmto+Uuj2bNnN/kbO9KR73fj+6rT6XDJJZeELh84cCDMZnPY7Q+XSqUK5RBIkoTa2lro9XoMHDiw2XMI19dffw1BEHDrrbc2ufzOO+8EY6zZrNHUqVPRv3//0O/HHXccjEZj2M/1uuuuw/fff9/kZ8SIEaG2nHjiiU0+S3q9Htdddx2Ki4uxc+fOJvd19Pu0detW7Nu3D5dffjlqa2tD77PT6cRpp52GH3/8MZS4bjabsWHDhtBMDyEkcih5m5AoU6vVzSqfJCQkNMmd2LdvH6xWK1JTU1u8jyPzBnbs2IH7778fK1euDJ1UN7JarU1+z8rKCjuZ1mKx4Ouvv8Ytt9wSWl4EACeddBI+/fRT7N27FwMGDGjxtrNmzcKjjz6K+fPn47zzzmt2vdFoBIA2y8EeyWAwtFiq9kiN93VkADJr1iy8+OKL+OCDD3Dvvffi0KFD+Omnn3DrrbdCEITQce+//z50Oh369esXeq5qtRp5eXlYvHgxzjrrrLDamZOT0+R3k8kEtVqN5OTkZpcfuVzk4MGDKCgoaJZsOnjw4ND1jf9mZGRAr9c3OW7gwIFNfi8sLARjDA888AAeeOCBFttaVVWFrKyssJ4XEAwsAoEA1q1bh+zsbFRVVWHixInYsWNHk8BiyJAhSExMDPt+j9anT59m+QcJCQn4/fffw7p94xI0juOg1WoxePBgmM1mAMHnbLFY8MYbbzRbetjo6Jycvn37tnhcS3/HJpOpxfabTKZmuVFdJcsyFixYgIULF6KoqKhJTtWRlc464uDBg8jMzGwWxB/9OWx09OcdaN6XtaWgoABTp05ttS1H51Md3ZYj9zw5+n3at28fALRaaAII9o8JCQl45plnMHv2bGRnZ2P06NGYMWMGrrrqKvTr1y+s50EIaR0FFoRE2ZEntK2RZRmpqamtzgw0ntBYLBZMmjQJRqMR8+fPR//+/aFWq7F582b885//bFZKsrWR15YsXboUXq8Xzz//fIvJxosXL8YjjzzS4m0bZy2uvvpqfPnll82uHzRoEIBgkms4Bg8ejK1bt6KkpKTFkxkAoRPPIUOGhC4bPXo0Bg0ahA8//BD33nsvPvzwQzDGmlSDYg3ldJ1OZ5PbNqqqqoLD4Wh2Mt+Slt7b1t5v1k5ye1c0vu/z5s3DtGnTWjymcRYqXGPGjIFarcaPP/6InJwcpKamYsCAAZg4cSIWLlwIr9eLn376Ceeff36X2t7V1ys5ObnVk9XG1+WKK65o9YTzuOOOa/J7a38zrbUznPa3Vor56IILbXniiSfwwAMP4K9//SseffRRJCYmgud53H777d1WQjYWn+3WHP0+Nb4Gzz77bKtljRv/pi+55JLQfiffffcdnn32WTz99NP47LPPMH369Ki2m5DejgILQuJA//798cMPP+Ckk05qMxhYvXo1amtr8dlnnzVJyOxMoujRFi9ejGHDhuGhhx5qdt3rr7+ODz74oNXAAkAoufiRRx5pUn0JAAYMGICBAwfiyy+/xIIFC9o9aT/77LPx4Ycf4v/+7/9w//33N7veZrPhyy+/xKBBg5qdMM+aNQsPPPAAfv/9d3zwwQcoKCgIVcoBgDVr1uDQoUOYP39+aDS0UX19Pa677jp88cUXUSmL2Sg3Nxe///47ZFluMmvRuJQtNzc39O+KFSuaBTp79uxpcn+NI60KhaLVk+yOalyS9NNPPyEnJwcTJ04EEJzJ8Hq9WLx4MSorK1tNDG4Uzv4m0ZKSkgKDwQBJkiL2unRGQkICgODAQONsCtB8RgBo/fX65JNPMGXKFLz99ttNLrdYLE1myDryeufm5uKHH35otvTw6M9hd8jNzW32ue5IWxqXaBmNxrDe64yMDNx000246aabUFVVheOPPx6PP/54KLCI5eeWkJ6MciwIiQOXXHIJJEnCo48+2uy6QCAQKi/aOGJ45Aihz+fDwoULu/T4paWl+PHHH3HJJZfgoosuavYzZ84cFBYWYsOGDa3eR+OsxdatW1sscfrII4+gtrYWf/vb3xAIBJpd/91334V21L7oooswZMgQPPXUU812O5dlGTfeeCPq6+tbDIIaZycefPBBbN26tcW9K3Q6He66665mz/Paa69FQUFBh6tDddSMGTNQUVGBJUuWhC4LBAJ4+eWXodfrMWnSpNBxgUAAr776aug4SZLw8ssvN7m/1NRUTJ48Ga+//jrKy8ubPV51dXWn2jlx4kRs2LABq1atCgUWycnJGDx4MJ5++unQMW3R6XQA0GqJ3GgSBAEXXnhhqHzx0Tr7unRU40nvkVW2nE5ni+WFdTpdi6+VIAjNZgaWLl3aLHemI6/3jBkzIEkS/v3vfze5/MUXXwTHcd06ej9jxgz8+uuvWLduXegyp9OJN954A3l5eS3OLh5p9OjR6N+/P5577jk4HI5m1ze+15IkNVsympqaiszMTHi93tBlOp2u2XGEkPbRjAUhHfDOO++0WLf9tttu69L9Tpo0Cddffz2efPJJbN26FWeccQYUCgX27duHpUuXYsGCBbjoooswYcIEJCQkYPbs2bj11lvBcRzee++9Li9F+OCDD0KlJ1syY8YMiKKIxYsXt7gOulFjrsXWrVubXXfppZfijz/+wOOPP44tW7bgL3/5S2jn7W+//RYrVqwI1f9XKpX45JNPcNppp+Hkk09usvP2Bx98gM2bN+POO+/EZZdd1uxx+vbtiwkTJoSWZB0ZWDSW0z399NNb3czwnHPOwYIFC1BVVdVqzktXXXfddXj99ddx9dVXY9OmTcjLy8Mnn3yCX375BS+99FJo9HjmzJk46aSTcPfdd6O4uBhDhgzBZ5991uIJzyuvvIKTTz4Zw4cPx7XXXot+/fqhsrIS69atw6FDh5rsdxCuiRMn4vHHH0dpaWmTAOKUU07B66+/jry8PPTp06fN++jfvz/MZjNee+01GAwG6HQ6jB07ttVchkh76qmnsGrVKowdOxbXXnsthgwZgrq6OmzevBk//PAD6urqot6GM844Azk5Objmmmtw1113QRAEvPPOO0hJSUFJSUmTY0ePHo1XX30Vjz32GPLz85GamopTTz0VZ599NubPn485c+ZgwoQJ+OOPP7B48eJmeQEdeb1nzpyJKVOm4L777kNxcTFGjBiB7777Dl9++SVuv/32Jona0Xb33Xfjww8/xPTp03HrrbciMTER7777LoqKivDpp5+2u/kdz/N46623MH36dAwdOhRz5sxBVlYWDh8+jFWrVsFoNOKrr76C3W5Hnz59cNFFF2HEiBHQ6/X44YcfsHHjxiZLQEePHo0lS5Zg7ty5OOGEE6DX6zFz5sxovwyE9HwxqERFSI/TWBaytZ/S0tJWy83qdLpm99da+ck33niDjR49mmk0GmYwGNjw4cPZP/7xD1ZWVhY65pdffmHjxo1jGo2GZWZmsn/84x9s+fLlzUqITpo0iQ0dOjSs5zd8+HCWk5PT5jGTJ09mqampzO/3Nyk3e7QjX6vGcrNHWrFiBTv33HNZamoqE0WRpaSksJkzZzYpWdqoqqqKzZ07l+Xn5zOVSsXMZjObOnVqqMRsa1555RUGoEm5VMYY+/TTTxkA9vbbb7d629WrVzMAbMGCBa0ec3Q53Uatvd8tvReVlZVszpw5LDk5mSmVSjZ8+PAWS4TW1tayK6+8khmNRmYymdiVV17JtmzZ0mJJ0f3797OrrrqKpaenM4VCwbKystjZZ5/NPvnkk9Ax4ZabZSxYblgQBGYwGFggEAhd/v777zMA7Morr2zxuR5dLvXLL79kQ4YMYaIoNml3a5/Ro8uitiY3N5edddZZ7R5XWVnJbr75Zpadnc0UCgVLT09np512GnvjjTdCxzS+LkuXLm2xPeG+r621a9OmTWzs2LFMqVSynJwc9sILL7RYbraiooKdddZZzGAwMACh19Lj8bA777yTZWRkMI1Gw0466SS2bt26Dr3eLb2udrud3XHHHSwzM5MpFApWUFDAnn322SYlWxkLlpttqURrbm5uk1LKLWmrvzjS/v372UUXXcTMZjNTq9XsxBNPZP/73/+aHNPW+8QYY1u2bGEXXHABS0pKYiqViuXm5rJLLrmErVixgjEWLGd81113sREjRjCDwcB0Oh0bMWIEW7hwYZP7cTgc7PLLL2dms5kBoNKzhISJYywGWVeEEEIIIYSQXoVyLAghhBBCCCFdRoEFIYQQQgghpMsosCCEEEIIIYR0GQUWhBBCCCGEkC6jwIIQQgghhBDSZRRYEEIIIYQQQrqMAgtCCCGEEEJIl1FgQQghhBBCCOkyCiwIIYQQQgghXUaBBSGEEEIIIaTLKLAghBBCCCGEdBkFFoQQQgghhJAuo8CCEEIIIYQQ0mUUWBBCCCGEEEK6jAILQgghhBBCSJdRYEEIIYQQQgjpMgosCCGEEEIIIV1GgQUhhBBCCCGkyyiwIIQQQgghhHQZBRaEEEIIIYSQLqPAghBCCCGEENJlFFgQQgghhBBCuowCC0LiwBVXXAG1Wo29e/c2u+6pp54Cx3H43//+BwBYsmQJrrjiChQUFIDjOEyePLmbW0sIIeRo4fbjtbW1ePbZZ3HKKacgJSUFZrMZ48aNw5IlS2LQakIii2OMsVg3gpBjXVVVFQYNGoSRI0di5cqVocuLioowdOhQzJgxA5988gkAYPLkydi0aRNOOOEEbN26FccddxxWr14do5YTQggBwu/H//e//+GCCy7AjBkzMGXKFIiiiE8//RSrVq3Cgw8+iEceeSSGz4KQrqHAgpA48eabb+K6667DokWLMHv2bADA9OnTsXbtWuzcuRNZWVkAgNLSUmRlZYHneQwbNgzJyckUWBBCSBwIpx8vKioCz/PIzc0N3Y4xhqlTp+KXX35BbW0tdDpdrJ4CIV1CS6EIiRN/+9vfcNJJJ2HevHmora3FRx99hG+//RaPPfZYKKgAgOzsbPA8/ekSQki8Cacf79u3b5OgAgA4jsN5550Hr9eLAwcOxKLphESEGOsGEEKCOI7D66+/jlGjRuHGG2/ETz/9hDFjxuDmm2+OddMIIYSEoSv9eEVFBQAgOTk52s0kJGoosCAkjgwdOhTz5s3Dk08+CUEQsGzZMpqdIISQHqQz/XhdXR3eeustTJw4ERkZGd3UUkIij85YCIkzjaNVmZmZGDZsWIxbQwghpKM60o/LsoxZs2bBYrHg5Zdf7o7mERI1FFgQEkdKS0vx0EMPYdiwYSgtLcUzzzwT6yYRQgjpgI7243//+9/x7bff4q233sKIESO6qZWERAcFFoTEkVtuuQUA8M033+Diiy/G448/Tol8hBDSg3SkH3/kkUewcOFCPPXUU7jyyiu7s5mERAUFFoTEic8//xz//e9/8eijj6JPnz546aWXoFQqKXmbEEJ6iI7046+88goefvhh3H777fjnP/8Zg9YSEnm0jwUhccBut2PIkCFISUnBxo0bIQgCAOBf//oXbrvtNnz88ce4+OKLm92O9rEghJD40JF+fMmSJbj88svxl7/8Be+99x44jotl0wmJGAosCIkDt912G/79739j/fr1OOGEE0KXS5KEE088ERUVFdi9ezcMBgN+/PFH/PjjjwCAl19+GVqtFtdccw0A4JRTTsEpp5wSk+dACCHHsnD78V27dmHixIkwmUx4+umnoVAomtzPhAkT0K9fv+5uPiERQYEFITG2adMmjB07FjfeeGOLFUE2btyIcePG4ZZbbsGCBQvw8MMP45FHHmnxvh566CE8/PDDUW4xIYSQI3WkHx81ahTmzJnT6n395z//wdVXXx3F1hISPRRYEEIIIYQQQrqMkrcJIYQQQgghXUaBBSGEEEIIIaTLKLAghBBCCCGEdBkFFoQQQgghhJAuo8CCEEIIIYQQ0mVirBvQ3WRZRllZGQwGA21IQwgh3YAxBrvdjszMTPB818ezqB8nhJDu05E+/JgLLMrKypCdnR3rZhBCyDGntLQUffr06fL9UD9OCCHdL5w+/JgLLAwGA4Dgi2M0GmPcGkII6f1sNhuys7ND/W9XUT9OCCHdpyN9+DEXWDROmxuNRvpCIoSQbhSpZUvUjxNCSPcLpw+n5G1CCCGEEEJIl1FgQQghhBBCCOkyCiwIIYQQQgghXXbM5VgQQo5tkiTB7/fHuhm9ikKhgCAIsW4GIeQYQH145EWyD49pYPHjjz/i2WefxaZNm1BeXo7PP/8c5513Xpu3Wb16NebOnYsdO3YgOzsb999/P66++upuaS8hpOdijKGiogIWiyXWTemVzGYz0tPTaV8JQkhUUB8eXZHqw2MaWDidTowYMQJ//etfccEFF7R7fFFREc466yzccMMNWLx4MVasWIG//e1vyMjIwLRp07qhxYSQnqrxCyk1NRVarZZOgCOEMQaXy4WqqioAQEZGRoxbRAjpjagPj45I9+ExDSymT5+O6dOnh338a6+9hr59++L5558HAAwePBg///wzXnzxxVYDC6/XC6/XG/rdZrN1rdGEkB5HkqTQF1JSUlKsm9PraDQaAEBVVRVSU1MjviyK+nFCjm3Uh0dXJPvwHpW8vW7dOkydOrXJZdOmTcO6detavc2TTz4Jk8kU+qHdWgk59jSux9VqtTFuSe/V+NpGY+0z9eOEHNuoD4++SPXhPSqwqKioQFpaWpPL0tLSYLPZ4Ha7W7zNPffcA6vVGvopLS3tjqYSQuIQTZ1HTzRfW+rHCSEA9eHRFKnXttdXhVKpVFCpVLFuBiGEkE6ifpwQQnqGHjVjkZ6ejsrKyiaXVVZWwmg0htaHEUIIIYQQQrpfjwosxo8fjxUrVjS57Pvvv8f48eNj1CJCCImd4uJicByHrVu3hn2bRYsWwWw2R61NpHdzeAMoqXVBllmsm0JIr9Db+vGYBhYOhwNbt24NvZhFRUXYunUrSkpKAATX1V511VWh42+44QYcOHAA//jHP7B7924sXLgQH3/8Me64445YNJ8QQgg5Zrh9EnaX21BYbYfNQxuUEUKai2lg8dtvv2HUqFEYNWoUAGDu3LkYNWoUHnzwQQBAeXl5KMgAgL59+2LZsmX4/vvvMWLECDz//PN46623aA8LQgghJIq8AQl7K+2ocXjhC8iodfhi3SRCSByKaWAxefJkMMaa/SxatAhAcKpn9erVzW6zZcsWeL1e7N+/n3bdJoR0jdPZ+o/HE/6xR1ema+mYTvj2229x8sknw2w2IykpCWeffTb279/f4rGrV68Gx3FYtmwZjjvuOKjVaowbNw7bt29vduzy5csxePBg6PV6nHnmmSgvLw9dt3HjRpx++ulITk6GyWTCpEmTsHnz5k61n/R8fknGvkoHyq1upBs10KsUqLR54AvIsW4aId3bh1M/3q4elWNBCCERp9e3/nPhhU2PTU1t/dijN/vMy2t+TCc4nU7MnTsXv/32G1asWAGe53H++edDlls/qbvrrrvw/PPPY+PGjUhJScHMmTOb1CZ3uVx47rnn8N577+HHH39ESUkJ5s2bF7rebrdj9uzZ+Pnnn7F+/XoUFBRgxowZsNvtnXoO8abc6kZpnQuMUZ5AeySZYX+VA4fqXUg1qCHwHPQqEXaPHxYXzVqQONCdfTj14+3q9eVmCSGkJ7vwqC/Gd955BykpKdi5cyf0rXzJPfTQQzj99NMBAO+++y769OmDzz//HJdccgmA4AZIr732Gvr37w8AuOWWWzB//vzQ7U899dQm9/fGG2/AbDZjzZo1OPvssyP23GLF6Q2guCYYWGQnaqk2fitkmaGoxoHiWheS9SoohOBYpMBzEHgeVXYvUo3qGLeSkPh3LPXjFFgQQo5tDkfr1wlC09+rqlo/lj9qAri4uNNNOtK+ffvw4IMPYsOGDaipqQmNcJWUlGDIkCEt3ubISnmJiYkYOHAgdu3aFbpMq9WGvowAICMjA1VHPLfKykrcf//9WL16NaqqqiBJElwuV5Oct57O7ZOwtzL43lNw0RxjDKX1LhyodiJRq4RKbPq3YFQrUOPwwuENQK+iUwkSQ3HehwPHVj9OvQEh5Nim08X+2DbMnDkTubm5ePPNN5GZmQlZljFs2DD4fJ1fhqJQKJr8znFck2VBs2fPRm1tLRYsWIDc3FyoVCqMHz++S48Zb9RKATqlSMFFK8qsHuyrdMCgVkCjFJpdr1EKqHN5Ue/0UWBBYivO+3Dg2OrHqTcghJA4VVtbiz179uDNN9/ExIkTAQA///xzu7dbv349cnJyAAD19fXYu3cvBg8eHPbj/vLLL1i4cCFmzJgBACgtLUVNTU0nnkF806uDX4EUXDRVZfNgT4UNaoXQZtCgUYiosHmQadZA4Ol1I6Qlx1o/ToEFIYTEqYSEBCQlJeGNN95ARkYGSkpKcPfdd7d7u/nz5yMpKQlpaWm47777kJycjPPOOy/sxy0oKMB7772HMWPGwGaz4a677oJGo+nCM4lfFFw0VevwYleFDSLHw6RRtHmsQS2izumD1e1Hok7ZTS0kJD41zhYc3X8ca/04VYUihJA4xfM8PvroI2zatAnDhg3DHXfcgWeffbbd2z311FO47bbbMHr0aFRUVOCrr76CUhn+id/bb7+N+vp6HH/88bjyyitx6623IjU1tStPJa7p1WJoWdSh+mO3WpTV5cfuCjskCUgII1BQCDwkxlDr8HZD6wiJPcYYZJkhIMnwSzJ8AQkevwSXLwCnV4LTJ8HtC8AbkOCXZAQkGQCHDz/88Jjpxzl2jPWgNpsNJpMJVqsVRqMx1s0hhHQDj8eDoqIi9O3bF2p1761is3r1akyZMgX19fUwm83d+thtvcaR7ne7en+FVXYU1biQflRFI4cnAKcvgIHpevRJOLZmLhzeALYftsLhCSCtA5We7B4/ZABjchOgVjTPxSAkErqzD5cZA2No2FsNkMEgy42XMzAgeH3D8VzDDxq6iz+vY+DAgeMADhx4HuA5ruEnOLPBccHLjhSrfjxSfTgthSKEEEIQnLlgYNhT4QDAoU+C5pgILtw+CbvLbbC6/cjoYPlYnUpEudUDi8uPdBMFFiT+NQYMDAwyQyiIkFnw91BgccRtOODPAIEL/h/tdg0c0HA/jDFIEuA/4l4b75PnOAj8n8GG1FAxqqeO+1NgQQghhDQwqIN5BXsqgptI9fbgwhuQsLfSjmqHFxnGjj9XnuOgEDhU2jxIM6p69WtFeo7QbENohuHPoEGWg0FFm8ED3xA8dBXXeL/BOzsy9GYNQY3MGKQAC7XF4w8GFk6fBLUvAJ7nwDfOfBwx2xGvKLAghJBeYvLkyT12lCueHCvBhV+Ssa/SgXKrGxnGzld2MqoVqHf6YPcGYFS3nfBNSKQ0WbKEP4MHSW5/ydKfJ+ixan1DEHPkGqoGUyZPht3jB2MMfomBSQ1J4Y23QcOSKj64rCo469H4nGLfT1Fg0QlVNg+MGgWtJyWEkF6qtwcXksywvyqYrJ5qUHepXKxaIaDWGdzTggILEi0yY/AFJDBfIDT7EFpqhMaTb67JyXd4S5biDNdQWamF/qYxkJJkhoDMGp4312RZVXBp1RE5HEfMdnQHCiw6SJYZimqdUAo8BqUbW9w4iBASnxp3OyWR1xtf26ODi+xEbSybEzGMMRTVOFBc60KyXgWF0PUCkVplMNciy6yBGIH7I+RIHn+wCpPHFwAEZWjJEse3POrfWzUPEIL/b7KsSmbwSU0DDo7jIHCAShTAtzKIEKk+nAKLTpAloNTqgiQzDM4wQke7jhIS15RKJXieR1lZGVJSUqBUKnvV6HMsMcbg8/lQXV0Nnuc7VA6xJ+htwQVjDCV1LuyvdiJRq4RKjMzgmFGtQLXDA4vbj2S9KiL3SQgQzAMqqvPAHwBqqyuRlJwMhaJ39TPR1LhMjDFAUgoQ+aaBf6T7cDoj7qREnQq1Dh92lFkxOMMY+vIhhMQfnufRt29flJeXo6ysLNbN6ZW0Wi1ycnLA871vtLo3BRdlVg/2VTpgVCsiOuPeuJSqxu6lwIJETGMeUKXdizRzOjzuepSXlce6WT2SzBiUIt9qHkak+nAKLDqJ54B0kxqVNg92lNkwON0Ik5aCC0LilVKpRE5ODgKBACRJinVzehVBECCKYq+eBeoNwUWVzYO9FTaoFQL0UZhp16sUqHZ4keeXKAeRdJkkMxRW2UN5QKLAg4kpAJODS0dI2CSZod7lw/BMU4sD4ZHswymw6AKe45BuVKPK7g3NXISzWykhJDY4joNCoYBCQYMApOOODC44DuiT0HOCi1qHF7sqbBA4HiZNdD7/OqWAMqsPdU4fMs2aqDwGOTbIcjAP6GCtu0keEMdxACcAPAWuHcHJDDLPoFSpoY7yCpveN2fdzTiOQ6pBBbdPwo4yK2oc3lg3iRBCSJQY1ApolQJ2lwdHUnsCq9uP3RV2SBKiOvjFcRxUooBKm4fKHpNOY4yhtN6FAxHOAyLdgwKLCOA4DqlGNfwSw44yK6psnlg3iRBCSJQY1ApoFD0juHB4A9hVboPbJyHFEP3cB4NaRL3LB5s7EPXHIr1TYx6QIcJ5QKR7UGARQcl6FcA47CyzodzqjnVzCCGERIlRE//BhdsnYXe5DVa3H6ndEFQAwXKW/gBDnZNm70nHVdk82BPFPCASfRRYRFiiTgmB57Cr3IbDFgouCCGkt4rn4MIbkLC30o5qhxdpBnW3JtbrVCIqrF74pd63twmJnsY8IDGKeUAk+iiwiAKzVgmlIGBXmQ0ltU5aa0oIIb1UPAYXjSU6y61uZBg1XdpV+2gCz0El8m3ep14lwu71o97li9jjkt7N6uqePCASfTTPFCUmjQICx2FPpR0yY8hJ1LW62yEhhJCey9gwurq7oRRtLKtFSTLD/ipHqERnpIIKlcjDrFPArFHA6vbDpFHA4vLD4vLDG2g6MyHwHDiOQ43di1SDOiKPT3ovhzeAXRXBPKA0I31eejoKLKJIrxbBccDeSgcCMkO/ZP0xH1w4vMGEPlo7SQjpTYwaBeCObXDBWLBEZ3Gtq0mJzq5SiTz6JGrw2pr9WLS2GDZ3AEaNiDkT+uL6Sf1wqM7dLLgwqkVUO7xw+QLQKqm/Jy07Mg8og4KKXoH+2qNMpwoGF/urnZBloH+qPqLT0j1FQJJRbnWjqMYFo1rEiGxzr95MixBy7DkyuOA4DlnduJcDYwwlddEp0WnWKfDamv3414rC0GU2dwALVuwDAMwam4NKW9NkbY1CQL3LjzqnjwIL0qIj84AyjBo6J+glKMeiG2iVIhK1ShTVOrC30obAMZbQZnH5sP2wFTvK7JBlBovLH5q5IISQ3sSoUUAjCt1ewCNaJToFnoNZo8CitcUtXv+ftUUwaxXNBsw4joNa5FFh9UCWKc+QNBXNPCASWzSM0E3UCgFJOhUO1rrAGJCfaoBS7N1xnS8go7TOhdI6FwIyQ5pBBVHgcdjigtXtb3FbeUII6emMGgWYG9hVbgOAqM9cVNk82BulEp0iz8Hq9re6L4XNHYDVHYDIc5COCiCMGgXqXD7YPH6YtZSQS4KilQdE4kPvPrONMypRQKpBjZI6N3ZX2OANSLFuUlQwxlDj8GLbIQv2VTmgVghIM6ohNqz3VdPOrISQXs6kUUDdDTMXdU4fdlfYwUepRGdAZjBpFDBqWg5YjBoRJo2IQAuzEgqBhyQFvw8IAaKXB0TiR8zf0VdeeQV5eXlQq9UYO3Ysfv311zaPf+mllzBw4EBoNBpkZ2fjjjvugMfTc3a6Vgg8Ug0qlFnc2F1uh8ffu4ILj1/CvkoHtpZaYHcHkG5UQ3fUCJpBHawqYvPQcihCSPdTCjwUQvRHSaMdXFjdfuwqtyEgMSRGqUSnJDPsr3Zi9vi8Fq+fM6EvLC5/s9mKRnqViEqbt9cOpJHwHZkHlKBVRDQPiMSPmAYWS5Yswdy5c/HQQw9h8+bNGDFiBKZNm4aqqqoWj//ggw9w991346GHHsKuXbvw9ttvY8mSJbj33nu7ueVdoxB4pBs1KLd6sKvcBpev559gyzJDhdWDrSUWHKhxwKhSIMWganGKUyny8AVkWKjGOSGkG7l9AfgCMjRKEeP7JyHNqIIqyktSoxVcOLwB7CoPluhM1kdvmVGZxY07l27F1RPycOtp+aGZC6NGxK2n5eP6Sf1gcflbvb1eLcLu8bd5DDk2HJkHRAn9vVdM39kXXngB1157LebMmQMAeO2117Bs2TK88847uPvuu5sdv3btWpx00km4/PLLAQB5eXn4y1/+gg0bNrT6GF6vF17vn9OwNpstws+icwSeQ7pRjQqbG5LMMCjD2GNLsDq8ARysdaLM4oZSEJBpar+6g1YhotLmQXaC9pgvwUsIaVsk+nGvX8Jraw7gP2uLwiqXGkmmhmpRkcq58Pgl7KmwweryI8MUvV21JZnhhe/3Yk+lHfd/sR2PnDMUt0zJR73LD4NaxPr9tThY42pxGVQjnuOg4HlU2jy0R8ExLJp5QCS+xGzGwufzYdOmTZg6deqfjeF5TJ06FevWrWvxNhMmTMCmTZtCy6UOHDiAr7/+GjNmzGj1cZ588kmYTKbQT3Z2dmSfSBcIPIcMkwa1Dh92lllh8/SsER1JZjhU78LWknocqnchUatCok4Z1pecXi3C5gn0uOdMCOl+Xe3H3b4AFq7ejwUr9oWSkBvLpb6+5gDM2ugXkmicudhd0bWZC29Awp4KO6rtPqQZoxdUAMAnm0qxp9IOrVLARaP7oNLmRWGVE7UOL8586Uf89d3fsHZ/bbv3Y1ArUOf0UTXAY1S084BIfIlZYFFTUwNJkpCWltbk8rS0NFRUVLR4m8svvxzz58/HySefDIVCgf79+2Py5MltLoW65557YLVaQz+lpaURfR5dxXMc0k1qWN1+7CwLjkD1BFaXv6GErA0Ah0yTtkNVrhQCj4Ako95Jy6EIIW3raj8u8Dz+s7aoxetaK5caDSaNAiqh88FF4IgSnenG6FbT2Vdpx4cbg6/zDZP6h3bQlmQGSQaOz0kAAHy3s+Xv6yNplAI8AYn6+2NQYx6QX5KjlgdE4kvMk7c7YvXq1XjiiSewcOFCbN68GZ999hmWLVuGRx99tNXbqFQqGI3GJj/xhuc4pBnUcHgC2F5mRV0cd75+SUZxjQNbSutRZfcgVa/q9AiETimi0u495vb1IIR0TFf7cbsnvHKp3aGzwYUkMxR2U4lOj1/C89/vhSQznJyfjMkDUpodc8aQdADAxuI61IZR9Ukriii3ultN8ia9j/OIPKAUvSrWzSHdJGaBRXJyMgRBQGVlZZPLKysrkZ6e3uJtHnjgAVx55ZX429/+huHDh+P888/HE088gSeffBKy3LNPTjmOQ5pRDY9fwo4ya1yW56t1eLGt1ILdFXaoBAHpRk2ohGxn6FUi7O4AVYcihESVQd25cqnRcmRwURZGcNHdJToXrS3GYYsbiTolbprcv8XlVtmJWgzJMEJmwA+7Wy64ciSDWmwI4nrGrDzpGo9fwu6GPKBUg4p21T6GxCywUCqVGD16NFasWBG6TJZlrFixAuPHj2/xNi6XCzzftMmCECxX1lv2REg1qCFJDDvKrKiyxUcZ3WAJWTu2HrLA6vIj3aiBXt315CtR4CEzhjpn/AVRhJDeQ5JlzJnQt8XrZo/PQ5XN2+0j6Y3Bxa4wgovuLNG56WA9lv1RDgC4/bSCNjcynTY0uJT5+50VkNv5DhYFHhJjqLFTf9/bdWceEIk/MV0KNXfuXLz55pt49913sWvXLtx4441wOp2hKlFXXXUV7rnnntDxM2fOxKuvvoqPPvoIRUVF+P777/HAAw9g5syZoQCjN0jSq8AxDjvLbCi3Rm9jpfYwxlBl82BrqQX7qx3QK0WkRnhdr04losrmhZ+WQxFCokSjFHHT5P647bSCJuVS/35qPq6ekIcHvtwek30WwgkuyizubivRaXP78a8V+wAAZx+XgVENeRStmdA/GTqlgEpbcDa7PUaVAlV2T6/bv4n86cg8oLRWSs6T3i2mNb8uvfRSVFdX48EHH0RFRQVGjhyJb7/9NpTQXVJS0mSG4v777wfHcbj//vtx+PBhpKSkYObMmXj88cdj9RSiJkGnhMXlw85yGySZIcvcfgnXSHI2lJA9bPFA0VC9io/C4+tVIqrsHljdfiTTGkxCSJSoFAKun9QPN0/Jh83th0EjotrmxZxFG/H7ISs4cLh9akG3j66aNApY3cCuimAp2swjStFW2TzY000lOhljeGV1IepcPvRJ0ODqCXnt3katEDB5YCqW/VGO5Tsr2w1EdCoB5TY/6l0+ZJi6VnKXxJ/GzRQPN+QBdWWpNOm5ONZb1hCFyWazwWQywWq1diqRW5YZ/jhkhTcgQdMNG7zY3H64/RIK0vTISdRG/UtPkhkqbB4U1Tjh8ARP9qM99V5hcyM3UYcB6YaoPg4hJDa62u9G+v5Kap04UONEkk6FbYcsePDL7ZAZcP0p/XD2cZldbl9nWN1+eCUJg9ONyDRrUOf0YfthKxhDt1TTWbm7Ci/+sBcCz+G5i0YgP1Uf1u2Kahy49aOtEHkOi+ac2G4xj2q7F0l6JY7rY6IlMr0IYwwHqp0orHYgUauEWtF7VpH0BpLMUOPw4oS+iZ0quNORPpfCyQ5w+wIIyAwZZjVG5Ji7ZddWo0YBnVLE3ko7imuckKO4Dtjm8WN7mRXbD1nAZIZMkybqQQUQrA5V5fDGZCkCIeTY45Nk+KVgXzqijzk0Ov/Wz0XYUWaNSZuOXBZVXOPs1hKdVTYPXv9xPwDgLyfmhB1UAEDfZD0KUvUIyAwrdlW2e7xBLaLO6YWd9rToVUrrXNhf7YBZo6Cg4hhHgUWYGndtHfP49zjxiRU44fEfsHhDCfokaqIeXOjVIoxqBfZVOXCgxhHxJEO/JONgrRNbSupRafUgxaCGWRveRneRoFOJcHr8VC2EEBIT543MwikFyZBkhqe+2R1W+dRoaAwu9lTYu61EpyQzvPDDXrh8EganG3DR8X06fB/ThgYrOX63s7LdQipqhQCvX0ZdHFY+JJ1TZnFjb6UDBlX084BI5wg8B51KRHec1VFgEYZ42LVVqxRh1iixv9qJ/VWOiO39UOf04fdDFuwqt0HB88gwaaJeyvBoPMeB5/m4LLFLCOn9OI7D308tQF6SFha3H09+sztmBSVMGgWS9apuK9H55dbD2FFmg0Yh4I7TB3Qq2XZiQTLUCh6HLe6GTVPbplOJqLDRHka9QZXdg70V9mAeUASqRZLIUok80kwqDEzXo3+KDmqFAJcvurOFFFiEIV52bdUoBSRqlSiqdWBflb1LX3zegITCKju2ltbD0lBCtq2ygtFmUImodfioWgghJCbUCgH3zhgMvUrEnko7Xl+zP2ZtUYp8twQVRTUOvLf+IADgbxP7djqhWqsUcUpBcBO95WHsxG1QK2D3+GGhWeoerc7pw54KOwB0eqPc3kLgOahEPq6qYKlEHn0SNXh//UGMefwHnPjECox5/Hu8vuYAvFE816LAIgzxtGurWiEgWafGwVoX9lTY4Qt0LLhgjKHK7sG2UgsKqxzQKcWo7+IaDq1SgNMrweKiLxpCSGxkmDSYd8ZAcACW76zEt9vbP0nuqXwBGc9/txcBmWFs30ScPjitS/fXuBxqbWEtHO1setr4fVNlj4+9mkjHWd1+7C63wReQkXQMV3RsnBHIT9UhQadAfqquW/Jv2yLJDC5fADqViNfW7Me/VhQ2W22zcPX+qM1c0LxVGBp3bW0puGjctbW6Gzf9UYo8Ug1qlNa7IDOGAWmGsJKl3D4JxbUOHK73QIhiCdnO4DgOCp5DtcODdJM61s0hhByjRucm4Mpxufi/9Qfx+o/7kZekxaCMrleyijfvrT+Ig3UumDUK3DIlv8szJAWpeuQlaVFc68KqPVWYOaLt6loGlQI1dh/cSRI0Skr27Umc3gD2VNjg9AWQZjh2v68bZwReW7Mfi9YWw+YOwKgRMWdCX1w/qR8O1bnhDWPw1y/JcPskuP0SPH4p9P8jf3f5JXj8Mty+ADx+ueF3qcXbeQPBog8//3MKFq0tbvEx/7O2CDdPyY/wKxJEgUUYGndtXdCwcdCRrp6QB4vL3+27tioEHukGNcosbsgyw6AMY6vBhSwzVNo9OFDthN0TQJIuPkvB6dUi6pw+uHwBSgAjhMTMRaP7YF+VA+sO1OLJb3fjpUtGIqEbqjN1l98PWfDl1sMAgL+fWgCztuvPjeM4TBuajtd/PIDvdlbg7OMy2gxWtEoBVqsP9S4fNEra06Kn8Pgl7K6wod7pR7rp2N5V26xThGYEGjXOCDAwnDooFW/8WAS3L9Bw8i83DRoa/h+Iwvljil6FWoevzdU2do8/KrNNdPYWhsZdW4FglNcYlc4en4fZ4/Ow+WA90mOw2Y8o8Eg3alBh80BmNgzKMDQ7Ibd7/CiqcaLC6oFaFJAZxx2BRiHA4vLB4vJTYEEIiRmOC26Wd2ipC6X1bjz17W48dt6wbi9sEQ0ObwAv/rAPDMHlSyf2TYzYfU8ekIr//FKM4loX9lY6MLCNvYk4joNKFFBudSPdqAYfR2vTo8nq8oOBQaMUuqWceyT5AjL2VNhRbfMiPY5WPMSCwHMwaRStzggsWluMGyb1x/oDtahz+sK6T6XAQ6MUoFEIUCt4aJQiNAq+4XchdJ2m4f/qI/7feLm64f8GlYg0o6rN1TbRyquls7cwHblrq9Xth1EjYvPBelzy+npY3T68cMlIJERg1KejBJ5DulGNSrsbcllw5kKvEhGQZJRZ3CiudQXLFhpUcf+lyHEcFIKAarsXGXEcABFCej+tUsR9M4Zg7tKt2Fluw9s/F+GGSf1j3awue/3H/ahxBPvYa07qG9H71qtFnJSfhFV7qrF8Z0WbgQUQXGZscftg9wRg6obqirFm8/jxR5kVHp8EtYKHTiXCrFFApxKhUQrQKsWY5zu2JiDJKKyyo9zqRpox9nmZsSAzhsIqB9YfqEWlzYPHzx/eTv6tH1eOy4XN7T8iYGg9QIj0a2px+1tdbTNnQl8EZBnKKKRaU2DRAVqlCFlmKKt3o6haAgcOHr+EGocPT30TuxGtYHARnLnYftiKvCQdyq1uVNo8MKgUyDT3nGlmg1pEvcsHp0+CXkUfT0JI7GQlaHDn6QPw6LJdWPZHOfJT9ZjaxSTnWPppXzVW76kGzwFzpw6ISm7DtKHpWLWnGj/tq8bfTu7b5uyzUuThD8iocXh7fWDhl2Tsr3LA5Q0g1aCGxy/B6vKjqiE/UylwUIsijBoxuDGuSoRWKUDVTRXC2iLLwV21S+pcSDWoIcb5IGUkBSQZ28tsWHegFhsO1KK2YfYhUadEkl7Z5oxAkk6JaUPTu32pfCOL04/rJ/UD0HS1zZwJfXHT5P5QRWlJPJ25dYLLJ4GBwaBW4L6zBmPe0m3YWW7Dmz8dwE2To5MM0x6e45BhVKPSHgwuACCtB3YAaoWAOqcPFpePAgtCSMyd2DcJfzkhGx9uLMXC1YXITdSiIK3tkfh4VOvwYuHqYAndi8dkRy0hfUiGEX0SNDhU78aPe2tw5rD0No/XqxSotHmQk6SN+1n1zmKM4WCtE5U2D9KNmtBmZbojvuN8ARkev4QKmweHLG7wXDDw0ipFJGgV0KsUDbMaQre+TowxFNU4caDGgSRd/K98iAS3T8LmknqsL6rFxuI6OL1/lmbVKASMzk3AuH5JsLranhGIRf7tkbwBGYfq3Jg1Ngc3T+kPi9sPs0aJgCxHLagAKLDosuwELe48fSAeW7YT32yvQL9kfbsdabRwHIc0gxp+iUEZw1JnXaUSeVTaPMgya2I+UkMIIZedmIPCagc2FtfjiW9246VLR/aouv0yY3hpxT44vAHkp+px2ZjsqD0Wx3E4Y0ga3vmlGMt3VoQRWIiosntQ7/IhtZdWGKq2e1Fc40KCVtnqchelyEMp8jAi+LmSGYO3IdnX4vRDZjIEgYe6Yf18glYZCjQ0CiFqOSqldS4cqHEgQRufRV8ixer249eiWqw/UIetpRb4jtgnzKRRYGzfRIzvl4Tj+phD51d2T6DVGYHGqlCx5g3IqLR5UWnzwuENYGimAGOU+y4KLCLgxL6JmDUuF+83lCfMSdJiSIzKE3IcB6XYs0/G9WoRVrcfdm8Axhhu2kcIIUBwRvjO0wdi7sdbUWb14Olvd+PRc4f1mHXmy34vx9ZSC5QijztPHxD1mexTB6Xh/9YdRGGVAweqHeiXom/1WIHnwHEcqmzeXhlYOL0BFFY5IPJch4qS8BwXXIt/xHK1gCTDE5BR5/ShwuYGGKASgwm7Jo0CRo0C2iPW7XdVudWNvVUO6JWKXllQpdLmwfoDtVh3oBa7ym04cnIh3ajGuH5JGNcvEYPSjS3+rR89I2B1B2DSiLC4/GGXmu0ukszg9AbQHfMnve+TEiOXjO6DomoHftlfiye/2YUXLxmJ5GN405iuUIkCfAEvrC4/BRaEkLigU4m476whmLd0G/44bMWitUW45uR+sW5Wu0rqXKHKNX+dkIc+CdqoP6ZJo8C4fkn4ubAGy3dW4sZJrQcWAGBUi6h1eOH0BposD+rpApKM/dUO2L1+ZBi7nusoCjz0Ah9aJswYgzcgwxuQcbjejYN1TgjgoVLw0CoFJGiV0KsbEsMVQocCymq7F3sq7FAJPPTq3vGeMMZQXOvC+gO1WH+gFgdqnE2u75eiw7i+SRjfLwm5SdqwVkw0zgjUOHwQeQ7Vdm9Mlz/Fg97xaYkDHMfhttMG4LBlG4prXXji61146oLjevSSpFjSKERUNCyHOlbKEBJC4ltOoha3Ty3Ak9/sxhdby9A/RY/JA1Nj3axW+SUZL3y/Bz5JxvE5ZswYntFtjz1taDp+LqzBmj1VmDMhr80RdK1SRL3Lj3qXr1cFFofqXSizuJFqiE6VQ47joG6oNNS4NE+SGbwBCU6vhDqnAwwMosBDLQowqJsvoWqpXfVOH3ZX2AAGmHv4/i2SzLC7wtYQTNShwvbnbu88F8wJGt8/CWP7JiHN2PkZM0lmx3xA0aj3/AXHAY1SCJYn/Hgr9lU58MqqQtw+tYDyBDrBoBZR5zp2yhASQnqGCf2TcfHoPli66RBeXlWI3CQt+ia3PSIfKx/+WoL91U4YVCJuPbV7v4uO62NCmlGFSpsXvxTW4LR2qmmpRR7lVg8yTb1jMKnW4UVRjRMmjbJbE56FhiVXR1a/90vBxPAauw/lFg/ABXMZNQoBZq0CBrUiGGgoBXgb9qrw+WWkduFEOxoEnoPIcwi0cxLvC8jYdsiCdQdq8WtRHaxuf+g6pcBjVI4Z4/om4YS+iT0qV6qnoMAiwtJNavzjzEF46L/bsXJPFfqn6nDOiKxYN6vHUQg8JImh3tX7yxASQnqWWWNzsb/agc0lFjz+dXDpa7Q2m+qsneU2fLr5EADg5in5Udlhty08x+GMIel4b/1BLN9Z2W5gYdQoUOf0wer29/hdzj1+CfuqHJAZ4qK6oULgoRB4NKawNC6h8vgllNS5IcsuCDwHtSJY2tblCyAtjvJdVCIPs04Bs0YBq9sPk0YBi8sPi8sfymNwegPYWFyH9UV12HywHm7/n5WcdCoBJ+QFk6+Pz0no1Uno8SD2n/heaGS2GXNO6ou3fy7C2z8XITdRhxHZ5lg3q8fRKgVU2LzITtT1mCRJQkjvJ/Ac5p0xEHM/3oYKmwfPLt+Dh2YOjZt+yuUL4MXv90JmwKkDU3FSfnJM2jF1cBoWbziIXeU2lNS5kJPYen6HQuAhyQw1Dm+PDiyCez44YHH6kBGne0gduYSqkSQzePwSAjKL2tKtzlCJPPokavDamv1YtLa4SeWl607phw9/LcGy38vxx2ErAkfMYiTplA3J10kYlmnscaX3ezJ6paPk3BGZmDIwBTIDnv52d5N1fSQ8epUIhyfQZBqTEELigUGtwL0zBkMl8thSasH76w/Gukkhb/1chAqbB6kGFa47JXYJ5ok6JU7ISwQAfLejot3jDWoRlXYvvAGp3WPjVZnVjdI6F1IMavBxcnIejsa9NUwaRVy126xT4LU1+/GvFYWhjehs7gAWrNiH19bsR06iFltKLQjIDNkJGlw8ug+ev3gE3rn6BNwwqT9GZpspqOhm9GpHCcdxuHlKPvJT9bB7A3h82U54/D23s4wFsWEEq75hp0tCCIknfZN1uPXUAgDAJ5sP4ZfCmhi3CFh/oBbf76wEB+D2qQMingztDUiosnkgs/ASVacNDe5jsXJPFfxS2+U3dSoRTm8AFlfPHEyyuHzYX+WAXqWgwi0RIPAczBpFqKrZ0d5dV4yJBSm4cVJ/vDrreCycNRpXjc/DgDRDXAVHxxr65EeRShRw7/TBMGsUKK514aUV+8DC7IxJkE4losrmbfcLiRBCYuGUASk4b2Qwj+6lFXtxsNbZzi2ip97lw79XFQIAzh+VheFZpog/Ro3DC1Hk4PAEwjr++JwEJOuVsHsCWLe/ts1jeY6DyHGosHp63HelNyChsMoBv8SivgHZsULkOVjd/tBMxdFs7gAc3gDOH5XVLWWUSXgosIiyFIMKd08fBJHn8EthDT7ZdCjWTepR9CoRDp+flkMRQuLW1RPycFwfEzx+GU98vQsOb3gn3ZHEGMPLK/fB6vYjL0mLK8blRvwxbG4/dCoRqXo17GE+R4HnMLUhcXv5zvaXQxk1CtQ7fTF5DTuLMYaDNS7UOLy0f1UEBWTWsPFfy7NuRo0Ik0ZskltBYo8Ci24wNNMUWuf63vqD2FhcF+MW9RwCz4Ex0HIoQkjcEngO/5g2CCkGFcqsHjz/3Z6wlwpFyvIdldhYXA+RD+4SHukSp5LMYPf6kZuoRVaiBiqRC3t57+mD08AB+P2QFeVWd5vHqhUCPAGpR/X5FTYPDtY5kaRTxU0Cf28gyQy1Dh9mj89r8fo5E/rC4vLT/hFxhgKLbjJ9WAamDU0HA/Dcd3twqN4V6yb1GHqViCq7F74ALYcihMQnk0aBe6cPhkLg8NvBenz4a0m3PXaZxY23fj4AAJg9Pg95ybqIP0ad04ckvQoZZg0MKhEpBjUsYc4kpxrVGJWTAAD4bkdlu8drFSLKrJ4eccJo9/ixv8oBlShQGdMoeGVVIa6ekIe/n5ofmrkwakTcdloBrp/Ur8fm4/RmFFh0o+tP6YfBGUa4fBIeW7YLzh401RtLoYQ+d88ZwSKEHHvyU/W4ZUo+AOCjjaXYUNR2TkEkSDLDC9/vhTcg47gsE84ZmRnxx/AGJEiMITdJC4UQ3OsguEsxQyDM/LdpQ4PLoX7YXdnubQxqEXZPABZXfPf5fknG/ioHnD4JCdqeWyI3Xm07ZMH7G0pw6evrccHxffDbfVOx8b6p+O2+qZg1NgeH6tyhfSxI/KDAohspBB73nDkISTolDlvceP777p8u74l4jgPPcahxeGPdFEIIadOpg9Jw9vAMAMDz3+2N+uz00k2l2FNph04p4LapBVGphlPr8CHTrEbKEfkDiTolTBoFbGEmcZ+YlwizNrixWXvLgUWBB2Ms7vv8kloXKmyeuNpMrrfwBiS80lCIYEC6AQ5PAIVVTtQ7fSiscqLS5qWgIk5RYNHNEnRK3DcjOF2+sbgeH2zovunyeCDwHFQi3+F1qDqViFqHj0r2EkLi3jUn98XQTCPcfgmPf70LLl90Zqf3VtpDS65umNQfqVE4wXV4AlAreeQkaptsmibwHDLNGrj9gbAqOIkCj9MGNSZxt78cyqBWoMrujds+v8ruQVGtEwlaJeVVRMGSjaUot3qQqFPiqoZCBJIc3DG8JyyRO5ZRYBEDBWmG0HT5kt9K46L2ebSpRB5pJhXyU3VI0CmQn6pDmlEFVZi1vnVKAS6fRNWhCCFxTxR4/HPaICTqlDhU78ZLP+yL+Oy0xy/hhYbdtScWJGPSgJSI3j8AyIzB6gkmbBvUzUuoJutV0KtEOL3hnfyfMSQYWGw+WI8qe9ubxgb7/ADq43A5lMsXwIEqJ0SOg1YZ2X1CCHCw1onPthwGANxwSr+I78VCoivmgcUrr7yCvLw8qNVqjB07Fr/++mubx1ssFtx8883IyMiASqXCgAED8PXXX3dTayPn1EFpOGdEcC3sSyv2orgmdrXPo00l8uiTqMH76w9izOM/4ITHV2DM4z9g8YYS9EnUhBVccBwHgeNQbY/vqXFCCAGCs9P3NJQaX3egNuKlxhetLcZhixuJOiVunNS/yWxCpNQ7fTBrFcgwa1q8Xq0QkG5Sw+YN7+Q/06zBcVkmMAA/tDNrwXEcFLyAyjjb00KSGQqrHLC4fUjUUV5FpMmM4eWVhZBkhrF9EzG+f3Ksm0Q6KKaBxZIlSzB37lw89NBD2Lx5M0aMGIFp06ahqqqqxeN9Ph9OP/10FBcX45NPPsGePXvw5ptvIisrq5tbHhl/PakvRjTUPn/s652we3rnaLxZp8Bra/bjXysKQxvd2NwBLFixD6+vOQCzNrzNhAxqEbVOL9y++JwaJ4SQIw1KN+KGSf0BAO+vP4jfDkam1Pimg/VY9kc5AOD20wpanE3oKr8kwyfJ6Jusg0psvdpRil4NhcCHvWTpjIaduL/fVdXukhajRkSdyxd2Hkd3OFTvQpnFg1SDOirB3LHum+0V2FNph0YhhP52SM8S08DihRdewLXXXos5c+ZgyJAheO2116DVavHOO++0ePw777yDuro6fPHFFzjppJOQl5eHSZMmYcSIEd3c8shorH2eZlSh0ubFM8v39Lq1gwLPwaxRYNHa4hav/8/aIpi1irDWqGoUAtw+iapDEUJ6jGlD05uUGm9vH4f22Nx+LFixFwAw87iMUBnXSKtxeJFuapqw3RKjRkSSTgVbmMtUx/dLgkElosbhxZaS+jaPVYkCfAGGemd8zFTXOX0oqnbCpFZEfJ8QAtQ6vHi34VzhqvG5tNlgD9Wlvwyfz4c9e/YgEOj4aILP58OmTZswderUPxvD85g6dSrWrVvX4m3++9//Yvz48bj55puRlpaGYcOG4YknnoAktT5S4vV6YbPZmvzEE6NGgftmDIFK5LG11IJFa4ti3aSIEnigzukPzVQczeYOwOoOQAwjsOA4DgqBR5UtPr5kCCHdI9778fZcf0o/DEwzwOmV8MTXuzqdkMwYwyurC1Hv8iM7QYPZE/Ii29AGTm8ASpFHbqIOfDt9M8dxyDCpITEW1sCYUuQxZVAqgPB24tYpBVRYvfCHWdY2Wjx+CYVVdkiMQa+mNf/R8PqPB+D2SxiYZsD0YRmxbg7ppE4FFi6XC9dccw20Wi2GDh2KkpJgVYq///3veOqpp8K6j5qaGkiShLS0tCaXp6WloaKi5c7mwIED+OSTTyBJEr7++ms88MADeP755/HYY4+1+jhPPvkkTCZT6Cc7OzvMZ9l9+ibrcPvUAQCAL7aWYeXulpeC9TQ7yqy47/PtMGrE0MY2RzNqRJg0IgJhztQYVArUu3y0Bwghx5Ce0I+3RSHwuGf6IJi1ChTXuvCvlfs6lTewak8V1u6vhcBzmHv6wDaXKHUWYwwWtw99EjQwhblMNVGnhFGjgC3M5bzTGpZD/VpUh7p2dtg2qIP3G8uN0GSZ4UCNA3VOH42iR8m6A7VYdyD42b55Sj5V2urBOhVY3HPPPdi2bRtWr14NtfrP8nZTp07FkiVLIta4o8myjNTUVLzxxhsYPXo0Lr30Utx333147bXX2myr1WoN/ZSWlkatfV1xcn4yLh7dBwDw71X7sK/SHuMWdV651Y0nv9mFuz/7A78drMe6/bW4upWRtTkT+sLi8oe9BEyjFODxy2Hv+EoI6fl6Sj/eliS9CnefOQgCz+GnfTX4vKHqTbgqbR68tia4u/blJ+YgP1UfjWbC4vLDrFGiT4I27NuIAo8sswYunxRWwJSTqMXgdANkBqzY3XYSt8AH9zGqdrRdRSqaym0eHKpzI1mviso+Icc6ly+A19fsBwCcPzILfaOwczzpPp0KLL744gv8+9//xsknn9wkeWno0KHYv39/WPeRnJwMQRBQWdm0U6msrER6enqLt8nIyMCAAQMgCH+O0gwePBgVFRXw+Voe9VCpVDAajU1+4tUV43IxJjcBfonhiW92xWWZvbY4PAG8/fMB3LR4M9burwXPBUemjGoFbpjUH7edVhCauTBqRNx6Wj6un9SvwyNRapFHlS2+KoUQQqKnJ/XjbRmaacK1J/cFALy7rhhbSy1h3U6SGV78YS/cfgmD0w248Pg+UWmfX5Lh9geQm6yFWtGx2ZAkvRJapQBnmMU1QkncOyvbLcWrV4motnujth9IW6wuPwqr7NAqxajMEBHgvXUHUev0IcOkxmUn9qzZSNJcpwKL6upqpKamNrvc6XSGXSVBqVRi9OjRWLFiRegyWZaxYsUKjB8/vsXbnHTSSSgsLIQs/7nWcu/evcjIyIBS2fPLvvEch3lnDESWWYMahw9PfbM75utKw+GXZPx322Fc995v+GJrGQIyw/E5ZvzrslG4ZUo+1AoBh+rcmDU2B7/dNxXr7zkV6+85DaNzElBS6+rw7pk6lQiLywc7LYcihHSCVilClmX4YrBz74zhGThtUCpkBjyzfDcqbe2PxH+x9TB2lNmgUQiYe/rAqC0TqXP6kG7SdGqjPa1SRLpRHfZyqJPzk6FVCii3evDHYWs79x0s3FHfzcuhfAEZhdV2+AMMJk3kK28RYHeFLVTh7KbJ+RS89QKdCizGjBmDZcuWhX5vDCbeeuutVoOClsydOxdvvvkm3n33XezatQs33ngjnE4n5syZAwC46qqrcM8994SOv/HGG1FXV4fbbrsNe/fuxbJly/DEE0/g5ptv7szTiEs6lYj7zxoMrVLAznIb3vzpQKyb1CrGGNYdqMUtH2zGmz8Vwe4NICdRi4dnDsUj5wxDbtKf05negIxKmxeFVU5U2rw4/YU1mP2fjfhxX8c3B1QrBHglGdYYrrklhPRc6UY1shO1qHZ4Ir5xXXs4jsNNk/ORn6KH3RPAE9/sgjfQ+ih/UY0D768/CAC4dmJfpJsiv7s2EFyOwvPBZUqdDVxSjSoIPBdWwKZWCKFN/b7b0XYSN8dxUIsCKqxuyN1UOZExhuIaJ6rtlFcRLQFJxr9XFoIBOHVgKkZmm2PdJBIBnSpt8MQTT2D69OnYuXMnAoEAFixYgJ07d2Lt2rVYs2ZN2Pdz6aWXorq6Gg8++CAqKiowcuRIfPvtt6GE7pKSEvD8n7FPdnY2li9fjjvuuAPHHXccsrKycNttt+Gf//xnZ55G3OqToMWdpw/EY8t24pvtFeiXrMeZw1peHhYrhVUOvP3zAWwvC1ZnMWsUmDU2F6cPSWvzS0mSGXiOw4T+yVi66RA+/q0U4/omdrgeuEYUUWnzIMusabdqCSGEHInnOfRL0cPpk1Bt9yLNGJ2T9dYoRR73zBiEO5ZsxYFqJ15ZVYg7pg5o1g/6AjKe/24vAjLDuH6JmDo4rZV77BrGGOqdPvRL0SOhC5u+mTQKJOuUqHX6wpr1mDY0Hd9sr8Da/bWwuv1tzgoY1MHCHTaPH2Zt9FcoVNq8OFjnQpJOSYnEUfL51sM4WOeCQS3irw1LBEnP16kZi5NPPhlbt25FIBDA8OHD8d133yE1NRXr1q3D6NGjO3Rft9xyCw4ePAiv14sNGzZg7NixoetWr16NRYsWNTl+/PjxWL9+PTweD/bv34977723Sc5Fb3Fi30TMGpcLAHj9x/3YWR4f5RVrHF688P0e3PHxVmwvs0Ep8Lh4dB+8fuVonDksPewO+NyRWVCKPAqrHNgS5jrjIxnUIqweP+xxtHESIaTnUCsEFKTqoRA5WGNQDCLVoMY/zxwEngNW7anG/34vb3bMe+uLcbDOBbNGgVumFERtQzar2w+DRoHsxPATtlvCcRwyzBr4JTmsghz9U/TIT9EjIDOs2tN2NUSlyEOSZdQ6op97aPf4UVjtgErgO5xrQsJTZnHjo1+DRRj+dnI/WmrWi3R6H4v+/fvjzTffxK+//oqdO3fi/fffx/DhwyPZtmPeJaP74KT+SQjIDE9+sws1jtjt3+D2SXh//UFc//4mrNpTDQCYPCAFr15xPK4anwetsmOTXyaNAmc2JO99/FvHK7woBB7+AEO9i/a0IIR0jlmrRH6qAS5foNN7S3TFcX3MmHNScKT2rZ8PYPthKwSeg0rksbvChi+2lgEA/n5qQdROvCSZwemTkJukhUbZ9ZPoRJ0SZo0S9jBzLc4YGpyF+W5HRbsFOXRKBSptnqjmxgQkGQeqnXB6A12avSGtY4xh4epC+CQZI/qYMGVgSqybRCKoU0uhGvetaE1OTk6nGkOa4jgOt502AIct21Bc68ITX+/CUxccB6XYfTt+SjLDD7sqsXjDwVDi3JAMI645uS8GpBm6dN/nj8rC13+UY0eZDTvKrBiaaerQ7bVKARU2L7ITdTRVTQjplEyTGg5PAEU1DqQbNd3el5w7IhOFVQ4cqncj3aRG/1QdrG4/zjouAyaNAr8U1uLEvolRe/xahxepBhXSI7QcTCHwyDCrsavCBjPaPzGfNCAFb/9chNJ6N3ZV2DEko/WKX3qViEqbGxaXD6lRWr52sNaFcqsbaZ1IYCfhWbWnCtsOWaEUeNw0OT9qM3EkNjoVWOTl5bX5QWhrJ2zSMRqlgPtmDMHcj7diX5UDr6wqxO1TozclfqQtJfV455ciFNe6AAAZJjWunpCH8f2SIvL4yXoVThuUiuU7K/Hxb4fwyDkdCyz0KhF1Th9sbj+NLBFCOoXjOPRN1sHh9aPa4UG6UdPtjz/vjAHok6DFO78U4bYlW2BzB2DUiJg9Pg//nD4Qh+rcHa6eFw6PXwLjgNwkLUQhcgNWyXoVNKIAly/Q7my2VinilIIUfL+rEst3VLQZWAg8B4HnUWn3RCWwqLZ7UVznRIJWGdHXg/zJ6vbjrZ+LAACXnZiNTHP3/r2R6OvUX86WLVuwefPm0M+GDRvw2muvYcCAAVi6dGmk2xhXOA4QBA4ef/eVKUw3qfGPhrW4K/dU4b/byqL6eCV1Ljz81Q48+N8dKK51QacScM3JffHK5cdjQv/kiAY1F47uA54DNpfUo7DK0aHbKgQeEpPb3bmVEELaohR5FKQZoFEIMdk/KM2kxn/WFuHllYWwuYN5YzZ3AC+vLMTraw7AHOYO2B1V6/Qiy6xGYoQHZnQqEalGVdi5K2cMCS6H+rmwBo52yogb1CJqHb52j+soly+A/dUO8OA6vLSXhO/tnw/A7gkgL0mL80dmxbo5JAo6FViMGDGiyc+YMWNw7bXX4rnnnsO//vWvSLcxrjSObnEcg60bE/5GZv+5FvedX4qwrRMJz+2xuHxYuLoQf/9wMzYdrIfAczhnRCbeuGIMzhuZBUUURnAyTBqcUhBcX7l0U8dzLXRKBartXgR6wH4fhJD4ZVQrkJ9qgC8gwx3mJm+RIPAczBoFFq0tbvH6/6wtglmriPgSLavbD51KRE6iLioz4GlGDXiOC2svpoHpBuQkauELyFizt7rNY7VKER6/hPoIDihJMsOBaicsLh+SaPY7araWWrBqTzU4ALdMKaBZoV4qou/qwIEDsXHjxkjeZVxKMaiQn2qAs5sT/s4dkYkpA1MgM+Dpb3ejIoyNlcLhC8hYuqkU1723Cd9sr4DMgHH9EvHKX47HtRP7wRjlag0XjQ7uIrtufy1K61wduq1eJcLuDcSkqgshpHdJM6qQl6xFnav7BitEPliVqnGm4mg2dwBWdwBiBAMLSWZweP3ITdRCp4rO6LxZo0CCThFW38xxHKZ1IIlboxBRYfOEVXkqHIfrXThscSPVoKb1/lHi8Ut4ZVUhAOCs4RkYmN61HE0SvzoVWNhstiY/VqsVu3fvxv3334+CgoJItzEu9UnQoG+yDrVOb7ftjs1xHG6eko/8VD3s3gAeX7azS4ENYwxr9lbjhsWb8H/rDsLtl5CfoscT5w/HfTOGICuhe9Y+5ibpML5fEhg6Pmsh8Bxkxmg5FCGkyziOQ26SDhkmDars3nZPcCMhIAd3dTZqWj7BN2pEmDQiAhHcGK7OGdz0LSOK69t5nkOmWQNvQA5rE8IpA1OhEDgcqHG2uyzWoBZhdfkjMqBU7/ThQI0TBpUYlVl5ErRkYykqbB4k6ZS4cnxurJtDoqhTf0VmsxkJCQmhn8TERAwZMgTr1q3Dq6++Guk2xqXGJVFZZi2qbN23e6tKFHDv9MEwaxQornXhpRX7OvXlt7PchnmfbMNz3+1Btd2LZL0Sd0wdgOcvGYHhWR1Loo6EixtmLdbsrUaFtWMzMXqliCq7N6olCAkhxwaFwKN/qh4GtdgtAxaSzGBx+zFnQssbhM2Z0BcWlz9io/PegASZMeQm6aJ+Ip2oU8KoFsPab8igVmBC/2QAwPKdlW0eG8yvY6jtYgl2j19CYbUDksRgUNM+CtFSVOPEZ1sOAQBumNSfclh6uU69u6tWrWryO8/zSElJQX5+PkTx2PnAiAKPgjQ9vAEJVfbuqyaSYlDh7umDcP8X2/FLYQ2WJutwyZjssG5bbnXj3bXF+GV/LQBAreBx0fF9cO7IrJhuBFSQZsCobDO2lFrw6eZDuHlKfti31alEVNk9sLr9SDGoothKQsixQK8SkZ+mxx+HrXB6A1FbLtTI4vTj+kn9AARzKhqrQs2Z0BfXT+qHQ3XuiD1WrcOH7EQNkvXRzyVQiQIyTGrsqbCHtQ/HtCFpWLO3Gj/urcY1J/Vtc18Ng0pEpd2L7ERtp767ZJmhqMaBWocXGSaqTBQtkszw71X7IDNgfL8kjOuXFOsmkSjrVG85adKkSLejx1IrBAxIN+CPQ1bUOrxI0nfPie3QTBOuO6UfFq7ej/fXH0TfZB1OyEuEwHMQeQ4BmTUZ4XJ4AljyWwn+93s5AjIDzwGnD07DrLG5cVOq9ZIx2dhSasEPuypx2QnZYb+WAs+B5zjUOrwUWBBCIiLVoEa/pAD2VtmhFPmoju57AzIO1bkxa2wObp7SH1Z3ACaNCIvLH9FSs3aPH2olj+xEbbflEiQbVDhY54LbJ7W7Ad+wLBMyTWqUWT34qbAaZwxJb/VYnUpEudUDi8uPdFPHA4sKmweldW4k61Xgu+m1aO37uTf7Zns59lY6oFUKuP6UfrFuDukGYQcW//3vf8O+03POOadTjempjGoFBqQZsP2wBTa3P+rJzo2mD8vAgWonvt1Rgc82H8LpQ9KQ1lDiz6RRwOLyo8buxedby/DRryWwN5TnG5ltxjUn9UVesq5b2hmuYVkmDMkwYme5DZ9vOYy/TQy/E9IpRdQ4vPD4pZjOvBBCeo/sRC3s3gDKLG5kmjRRPRn3BmRU2ryocfgg8hyq7d6InnzKjMHm8WNQuqFbl/0Y1AqkGlQos3jaDSw4jsMZQ9OxaG0xvttR2WZgwXMcFAKHSpsHaUZVh94bq9uPwioHtEoRKjH63xcqkYdZp4BZo2jy/Wxx+aOyP0m8qLZ78X/rDgIAZo/P67aBVxJbYQcW5513XljHcRx3TG6Ql2JQoSDNgJ1lNigEvt0ONFKuO6UfZMbw5AXDsWhtMd5dVxyaRr96Qh6untAXK3dXwe4NIDtRi7+elIfROQlxW/nikjHZePirHfh2RwUuHpMd1vQ5AGhVAipsftjcfgosCCERIQo8ClINcPkk1Dh83TIjKkVpNLve6UOiThnVhO3WpBrVOGzxwC/J7c78nDooFe+tP4g9lXYU1zjbHAAzqhWoc3ph9wZgDDNY8gVk7K9ywBuQumX5skrk0SdRg9fW7MeitcUtLnPrjcEFYwyv/7gfbr+EQekGnDms9SCRRF93FRkCOpC8LctyWD/HYlDRKMusQb9kHepc3VcpSiHweHjmUCxaW9xsc6V/rSjEf34pwn0zBuGmyf3x8mWjMCY3MW6DCgA4PseM/BQ9vAG5QxsB8hwHgQuO8hFCSKRolAIKUvXgOAZHGEnI8cgvyfDLMnKTdN0yQn+0BK0SCVpFWHs/JWiVGNs3EQCwfGdFm8eqFQK8ATnsPS0YYzhY60SV3YsUfeR37m6JWafAa2v2418rmn4/L1ixL6qbH8baugO12FBUB4HncMuU/G5bbkb+xFiwzyqzuGHzBnNQVWL0K59RbbUI4jgOeck69EkIVorqjjWUAs8h2aDEu+uKW7z+3XXFOKkgGWcflxnxDZaigeM4XDwmWCFq2e9lcHZgd1WDWkSt09etm1sRQnq/JL0K/VP0sHp8PbL6XI3DizSjGikxWooiNJSe9QSksKoYTmtYArVqTxW8gbb7c60ymGsRzr4jVXYvDta6kKhVdsv3Yaw2P4w1pzeA19ccAABceHwf5CbF17Lr3s4vyah1eFFudUNiMvql6DA6JwHH9TF1y4qOTpe6cDqdWLNmDUpKSuDzNR0tuPXWW7vcsJ5KFHjkp+rh8UuodniQFuUNd8LZXMnWsLlST0kWG9cvCdmJWpTWufD1H+W4OMyKVxqFAIvbB4vbB42SqnwQQiKnT4IWDm8AJXUuZJg0PWYE1ukNQCnyyE3SgY/hCWyiTgm9WgG7J9BuHuLIHDNSDSpU2b1Yu78WUwamtnqsQSWixumFxe1HchuBk8MbQGGVo1uXKndk88Oe8v0cjv9bfxB1Lh8yTWpcGub3N+k6ly8Am8cPDhzMWgUKzAYk6ZTdvjy8U4HFli1bMGPGDLhcLjidTiQmJqKmpgZarRapqanHdGABNK0UVef0RTVh6cjNlVrqvBo3V+pJS4R4jsPFo/vghe/34sttZZg5IjOsPwyO4yDyPKpsVD6QEBJZPM+hX4oeTp+EGocXqYbuWUrTFTJjsLh9KEg1hJ2vFi1qhYAMoxr7quztBhY8x+H0IWlYvKEEy3dUtBlYiA05GzV2b6uBRUAK5lU4PAFkmLrvffNLMgzqtr+fDWqxw3s3xbNd5TZ880c5AODmKflQdsPSm2OZJAeLMrh8AWgUArISNEgzqGHuplm5lnTqHb/jjjswc+ZM1NfXQ6PRYP369Th48CBGjx6N5557LtJt7JEaK0UBCGtdaWd19+ZK3eWUgpRQhavv2llneySDSgGLy9ehJVSEEBIOtSKYb9E4Eh3vLC4/zBolshLiY6AlxRhc4+3xt79cdergNPAcsKPMhkP1rjaP1asUqG6oCtiS0joXKmxupBo6Vj2qK/ySjBe+34uf9lVj9vi8Fo+ZPT4PP+6txoNfbu8Rn6f2+CUZ/15VCAbgtEGpOK6POdZN6rU8fgmVNg+q7B4oRR5DMowYk5eIIRkmJOlVMV1e16nAYuvWrbjzzjvB8zwEQYDX60V2djaeeeYZ3HvvvZFuY4+VYlAhP00Plz8Q1XX/jZsr3XZaAYya4CSUUSPittMKcP2kfrC4el6HJfAcLjw+mGvx2ebDYSfDa5QCPAEZll7QSRNC4o9Zq0R+mgEuXyCsE+RY8UsyPP4AcpM7t4FcNBhUIpL0qrBOopP1KozOTQAAfNfOTtw6pQCnN9DiTuk1Di+Kap0wqZWh2Y1oc/kCmP+/nVixuwrPfLsH153S8vfzdaf0w4s/7MWWUgtuX7IFu8tt3dK+aPlsy2GU1LlgVIv460ktD3aSzpMZg9Xtx2GLGw6vH6lGFUbmmDEmNwE5Sbqob+QZrk61QqFQgOeDf6CpqakoKSnB4MGDYTKZUFpaGtEG9nRZZg08fgmFVQ6kCuqobLLUXZsrdbepg9Pw0cZS1Dp9WLm7CtOGhleuTinwqLJ5kGmKbn4LIeTYlGFUw+72o7jWiXSjJi6Tb+ucPqSbNHG1ZIvjOGSYNKiwBoubtPe6TRuajo3F9Vi5uwpXjstt9fuT4zioRAGVNg8yjuj33b7gdy8Y120nXTUOLx75ageKa11QK3j85cQclFs8LX4/l1s8uHlyPp78ZjcOW9y4+/M/8NeT8jDzuMwe9911uN6NJRtLAADXTuzXbft5HQt8ARlWtx8+SYZBLWJAmh7JBhUMKjEuPyedOssdNWoUNm7cCCC4C/eDDz6IxYsX4/bbb8ewYcMi2sCejuM45CVFv1JU4+ZKhVVO1Dt9KKxyotLm7bFBBRAspXv+qCwAwCebDoX92ulVIqwuPxy0HIoQEgU8z6Fvig4pBhWqHfG3Pt7lC0DggZxEbdwFPQlaBcxaRVizFmNyE5GoU8Lq9mNDUV2bxxrUIupcPtgaSgJLMsP+agcsLj+S9cqItL09RTUOzFu6DcW1LiRoFXjy/ONwQl5im9/PuUk6vHDJCJycnwxJZnjzpyI8/e1uuHw95/uLMYaFqwvhlxhGZZsxaUBKrJvU4zHG4PAGUGZ1o97tQ4JOgZHZZozJS0C/FD2MakVcBhVAJwOLJ554AhkZGQCAxx9/HAkJCbjxxhtRXV2NN954I6IN7A0aK0UlG1SosnvCKrfXWZLM4A3IPS6nojVnDk2HUS2iwubBT/uqw7qNWiHAE5B65BIwQkjPoBIF5KcaoFYIqHeFt49Cd2CMod7lQ58ELRJ03XNC3RGiwCPTrIHbH2j3u1DgOUwdnAYAWL6j7Vw7lSjAF5BR5wgWKimzuHCo3tVteRWbS+rxz0//QK3Th+wEDZ69aATyU/VNjmnt+1mrFPGPaQNx3cR+EHkOv+yvxdyPt6G4xhn1dkfCit1V+P2wFUqRx02T8+P2hLcnCEgy6pw+lFndCMgy+iXrMCY3ASOzzUg3qWOyD01HdSqwGDNmDKZMmQIguBTq22+/hc1mw6ZNmzBixIiINrC3aKwUpVMF91og4VErBJwzMjhr8fGmQ5DDDMrUDdPici8JsAgh8cekUaAg1QBvQI6b/XOsbj8MagX6JGhj3ZRWJetV0KlEOL3tv2anDwkGFltLLaiwtT07ZFApUGH1otruxf5qJ4xqRVSWHx/th52VmP+/nXD7JQzLNOKZC0cgzdixJWgcx2HmiEw8ecFwJOtVOGxx485PtmHl7rbzS2LN4vLhnZ+LAACzTsxBejdW3epNXL4AKm0e1Dh90KoEDO9jxgl5iShIM8CsVfaoYK1Tf3GPPfYYioqKIt2WXs+oVmBgugEcolspqrc5a3gGtEoBpXUubDhQG9ZtDGoFrB4/7LQcihASRWlGFfomaVHn8oa1SVs0BSQZTp+EvGRdt+3V0BlqhYB0oxo2b/uDbOlGNUZmmwEA37eTxK1XibB5/SiqcUCSGQzq6K7zZ4zhgw0HsWDlPkgyw6QBKZh/7jDo1Z3P5xiUbsRLl47EqGwzfAEZL/6wD/9euS9uN2Z8++ci2L0B9E3W4ZwRmbFuTo8iyQwWlw+HLS54/BIyzWqMyjHj+JwEZJk1cVN0oaM6FVgsXboU+fn5mDBhAhYuXIiamppIt6vXStZ3T6Wo3kSvEnHW8ODSu49/OxTWUjKlyMMfCP7REkJItHAch9xkHTJMGlTZvVFd6tqeWqcPaUYV0gyx2WG7I1INwWIm7e2sDSBUuOOHXZVtLvMVeA4ix6HO6Wtzs7xI8EsyXlqxDx9uDBasuXh0H8w9fUBEZkhMGgUemjkUl5+YAw7A8p2VuOvTbXG338Xmg/VYvbcaHIBbpuR3W9Wtns7jl1Bl86DS5oZC5DE4w4jReYkYkmlCcoxLxUZCpz4F27Ztw++//47JkyfjueeeQ2ZmJs466yx88MEHcLnarjdNgpWi+ibrUOfyhl1G9Vh37sgsqEQehdUObCm1hHUbrSK4HKq35JsQQuKTQuDRP1UPvVpsseRpd/D4JYALJmz3hBM8o0ZEkk4Faxi5cGP7JsKkUaDO6cNvB9tO4k4xqJAZ5Z3Rnd5gOdmVu6vAc8DNk/Nx1fi8iD6mwHP4y4k5eOScoTCqRRyoduL2JVuwoSi8Wfto8/glLFxTCACYOSIztG8XaZnMGGxuPw5bXLB7/Ug2qDAqJwGjcxOQm6SDPk5KxUZCp3ufoUOH4oknnsCBAwewatUq5OXl4fbbb0d6englQY9lTSpF2enENxwmjSI0avXxb+GVNNarg7ud2j207IwQEl16lYiCND0CjHX7Bp2MMdQ6fehj1iAxDhO2WxIsPauGxFi734EKgcepg4K7b7eXxM1xXFTXo9c4vLj7s9+xtdQCtYLHA2cNwZnDonfeMyonAS9dOgqD0g1w+iQ8tmwXFq0tivl5w0cbS1BpC+52PmtsTkzbEs/8kowahxcVNjcYBxSkGjA6NxHH9TEh1RidLQhiLSLPSKfTQaPRQKlUwu+nk7hwNFaKSumGSlG9xQWjsiDyHHaU2bCjzNru8QqBh8Rk1FOyPCGkG6Qa1OifrIPV4+vW2WibJwC9SkB2orZHJXkm6JQwahSwhTH4c0ZDEvemg/Woaaj81N2Kahy486hysmPyEqP+uCkGFZ44f3goh+HTzYdx3xd/xGx27EC1A59vOQwAuHFSP2iVvWe0PRKOLBVb5/TBqBFxXB8zTshLQP9UPUya+C0VGwmdDiyKiorw+OOPY+jQoRgzZgy2bNmCRx55BBUVbY8mkD+pFQIGpBmgp0pRYUnSq3Baw6jVx78dCus2WoWISnvskyoJIceG7ERtQ75F9wwYSTKD0+dHbpI2bnbeDZdC4JFl1sDtk9p9rfokaDE00wiZBXMtultjOdk6pw/ZiVo810I52WhSCDyundgPd585CBqFgB1lNty2ZAv+OGTptjYAwc/by6sKITPgpP5JOLFvUrc+fjwLSMGBzDKrB35JRl6SFqNzEzAqOwEZJk2PKBUbCZ0KLMaNG4f8/Hx88sknmDNnDg4ePIgVK1bgmmuugclkinQbezWDWoEBVCkqbBeO7gOeC3byhVWOdo/Xq0TY3YHQpkmEEBJNjbPRZq0SNY7oDxjVOr1I0qmQbtJE/bGiIUmvhEYpwBVGMZPG5bDf76wMu/R4JHy/swKPfLUDbr+E4VkmPHPBcUjtYDnZSDkpPxkvXjISeUlaWFx+3P/ldizdVNptr8eyP8pQWOWATingulP6d8tjxrPG2YkKmxs1Ti/USh7Dsow4IS8RA9ONSNApwffwZOyO6lRgcdppp+GPP/7Ali1bcOeddyIzs2slxl555RXk5eVBrVZj7Nix+PXXX8O63UcffQSO43Deeed16fFjjSpFhS/DpMEpBcFdPcPJtRAFHjIY6pyxmTonhBx7tEoRBal6cByDI4qDGt6ABMaA3CRdj12rrVWKSDOqYA1jOdSE/knQqQRU2b3YWmKJetsYY1i84SD+tTI4Qj9pQAoeOWdol8rJRkJWwwZ8pw5MhcyA/1t3EI8t2xnVzxoAVNk9eG/9QQDA7Al5PSafJxp8ARm1Di/KrW74JRnZCVocn5OA0bmJ6JOgjetyz9HWqZ7o8ccfx7p16zBs2DCo1Wqo1WoMGzYMb731Vofva8mSJZg7dy4eeughbN68GSNGjMC0adNQVVXV5u2Ki4sxb948TJw4sTNPIe40Voqqd1OlqPZcNLoPAGDdgVqU1LVfhUyvFFFlo9eVENJ9kvQq9E/Rw+rxRW0PglqnF5lmNZL1PfsEL9WghsBz7b5OKlHAlIENSdw7o7vs2i/JeOmHffiooZzsJWOycWeEyslGgloh4PapBbhlSj4UAoeNxfW4bckW7Ku0R+XxGGN4bc1+ePwyBmcYQ7NHxxJJZrC6/SizumDx+GDUiqGN7AZlGJHUC0rFRkKn/kIefPBB3HbbbZg5cyaWLl2KpUuXYubMmbjjjjvw4IMPdui+XnjhBVx77bWYM2cOhgwZgtdeew1arRbvvPNOq7eRJAmzZs3CI488gn79+rV5/16vFzabrclPPGqsFJVlpkpR7clN0mF8v+C6zqWb2p+10KlEOLwBWMIoa0gIiT89pR8/WlaCFjmJWlTbPRFfqmL3+KFRiD0uYbslZq0CyTolrGEsB542JHhCu6GoDvVR2qfI6Q3gka92YOWeYDnZW6bk48pxuXH3OnMch2lD0/HsRSOQblSjyu7FPz79Hd9sL494fs/a/bXYWFwPkedwy5T8qJbzjTdun4TKhn0neA7ITzFgTE4iRmUnINOsOaZnJ1rSqcDi1VdfxZtvvoknn3wS55xzDs455xw8+eSTeOONN7Bw4cKw78fn82HTpk2YOnXqnw3ieUydOhXr1q1r9Xbz589HamoqrrnmmnYf48knn4TJZAr9ZGdnh92+7kaVosJ3yZjg+/jj3up2Nw0SeA4cB1oORUgP1ZP68SMJPId+KXokGVSotkeu/5EZg83jR06iJuq7S3cHjuOQYdbAL8vtDqrlJeswMM0ASWZYubvtlQ2dUW334p+f/o5th6zBcrJnD4n70fn+KXq8eOlIjO2biIDMsHD1frzww97g3iYR4PAG8PqP+wEEVwzkJGojcr/xrDER+7DFBZc/gHSTGqNyEjAmLzFY2Unbuys7dUWnAgu/348xY8Y0u3z06NEIBMJf41dTUwNJkpCWltbk8rS0tFarS/388894++238eabb4b1GPfccw+sVmvop7Q0vD0QYoUqRYUnP1WP43PMkBnw6eb2K0TplQpUO3xh7fJKCIkvPa0fP5JaISA/RQ+FwIU1Ih+OeqcPiTolMs295wQvQauESa2AI4w9QM4YGjxn+G5HRUQH4A5UOzDvk204WHdEOdnc6JeTjQS9SsR9MwZjzoQ88Bywek817ly6DaX1Xd+0+N21xah3+ZFl1uDi0T0jqO8MxoI5UeVWN2ocPqiVPIZmmjAmLxHDsoL7TijF+FgKF8869QpdeeWVePXVV5td/sYbb2DWrFldblRr7HY7rrzySrz55ptITk4O6zYqlQpGo7HJT7w7slJUpL6IeqPGWYsfdlWitp265lqVAKfHH9Yur4SQ+NIT+/EjJeiUyE8zwOULdHkU2ReQ4Zdl5CXpetVJjlLkkWFWw+Ftv4+emJ8CjUJAmdWD7Yfb39MoHJsP1uPuz2JXTjYSOI7DBcf3wePnDUeCVoGSOhfu/HgbftpX3en73FFmxbcNmxLePCW/V33mGnkDEmocXpTb3Aiw4N/W6LxgInZ2orZX7YrdHTr9ar399tv47rvvMG7cOADAhg0bUFJSgquuugpz584NHffCCy+0eh/JyckQBAGVlU1rUldWVra4g/f+/ftRXFyMmTNnhi6T5WCylyiK2LNnD/r37x3lz5L1KhSkG7CzzAqlwNMavhYMzTRhaKYRO8ps+HzLYfxtYuv5NjzHged51Di8MSsTSAg5dmUY1bC7/SiudSLdqOl0kmeN04sMkxrJelWEWxh7SXoVNAoBLl+gzU3XNEoBpwxIwfIdFVi+sxLD+5i79Ljf7azAKw17MxyXZcI9Mwb36JPJYVkmLLh0FJ79bg/+OGzFM8v3YGe5DX89qW+Hks/9koxXVhUCAE4fkobhWb1nOwFJDpaJdXoDUIgcErRKpJsMSNAqoVbQ+VZXdOovZ/v27Tj++OMBBE/2gWCQkJycjO3bt4eOa2/9mVKpxOjRo7FixYpQyVhZlrFixQrccsstzY4fNGgQ/vjjjyaX3X///bDb7ViwYEGPWXcbrkyTGm5fAPurHRCF3rn1e1ddMjobD5XtwLc7KnDxmGyYNK2vNzaoRNQ4fPD4Jeo4CCHdiuc59E3RwekLoNrhQbqx4/tOOLwBqEQeuUm6XlkbX68SkWJU4XC9u93dnKcNScPyHRVYu78Gdk+/TuWaMMaw+NcSLGmo/DR5YApuPbWgV3zXJuiUePTcYVi84SCWbjqE//1ejn2VDvzjzIFINYQ3uPbp5kMorXfDrFFgzoS86Da4m7h8wX2tGGMwqBQYkKZHol4Fo1qknIkI6VRgsWrVqog1YO7cuZg9ezbGjBmDE088ES+99BKcTifmzJkDALjqqquQlZWFJ598MlTW9khmsxkAml3eGzRWivL4ZRyqd3VplKu3GpVjRn6KHoXVDvx3WxmuHJfb6rFapQCL1Q+Ly490EwUWhJDupRIF5Kca8PshC+pdPiRowy8TKzMGq9uHglRDmwMoPV26UYOy+uDOxW2d4Oen6tEvWYcDNU6s2lOFc0Zkdehx/JKMl1fuw6o9wWVCl4zJxhVjc3rVyaXAc7hqfB4GZxjxwvd7safSjts/2oo7zxiI0bkJbd72UL0rFHBdO7FzgVu88Esy7J5Aw6Aij0yTGilGFRK0yl4RRMabmL+il156KZ577jk8+OCDGDlyJLZu3Ypvv/02lNBdUlKC8vLyGLcydnpTpSiPX0Kd0xfRvBGO43DxmOC+Fst+L4OzjcQ/juOg4DlU2duuIhWvXL4ADlvcqLR5UO/0wekN0N4chPQwJo0C+al6eANyhzZEtbj8MGuVyEromTtsh8usUSBBp2j3e4LjOJzRUK1p+Y7KDn03Or0BPPzVDqzaUx3X5WQj5YS8RLx06Ujkp+phbyil+/6Gg61W4JIZw79XFSIgMxyfk4CJBeHltMYTuSERu8zqRp3TB61KwNAsI8bkJWJolgmpBloFEi0c68lnqp1gs9lgMplgtVp7VAKg3ePH9sNWePxyj1lbyxiD2y/B4Q0gIDOoBB56tQirxw+dQoQuQmtYZcZwy4dbUFrnwpXjckNJ3S1pTJ48oW9iu1Pt8cIbkFBh9aC0zgWHVwLPMXDgoRA4iCIPlchDpxSgU4lQijyUAh/8t+H/vfXLkvQcke53e2o/3ogxhsIqB/ZXO8KaifZLMmocXhzXx4x0U+/PESu3urGt1IoMk7rN/RKc3gCu+s+v8AVkPHvhcRiU0f5nodruxSNf7cDBOhc0CgH/PHNQu6P3vYVfkvHmTwfwzfZgMvaIPibMO2MgzA0zZwLPQeQ5/LCrEs8s3wOVyOPflx+P9B6Ul+jxS7B7AvBJMvQqAWlGNZL0Kpg0Clrx0QUd6XN7xpkVgUGtQEGaAdsPW2F1++N2KlySGZzeANx+CZIsQ6MUkWJQIVmvglGjgE4poLjGib1VdihFPiIjBjzH4eLRffDC93vx5dbDOGdEZqs5FBqFAIvLB4vLH/eBhV+SUWX3orTWBYvbD4NKRKZJDY7jIDMGvyTDLzG4fRJsbj8CDaNPHABR4KAQgq+vVilArxKhUgihoEPVEHT0xnXahMQ7juOQl6yD0xtApc2DjIa/69bUOX1IM6qRYugZg0pdlahTwqAWYfcE2vyu06lEnJyfjJW7q7B8Z0W7gcWBagce+d9O1Dl9SNQq8eDMIeif0rMqP3WFQuBx0+R8DMkw4t+rCrHtkBW3L9mKR88bhjF5CTBrFLC4/Lj6pDzkp+pRWGXvEUGFJDPYPX44fRJUIockvQppRjXMWgXlU8ZAfJ9ZkSaS9SoUpAUrRSkELm5OjH0BGU5fAG5/ADx46FQCshM1SNApYVQ3/8POTtTC7g2gzOJGpkkTkRH1UwpS8MGGElTYPFi+owLnjmx5vS3HcVAIAqrt3na/zGNFkhlqHF6U1LlQ6/BBqxCajdzxHAeVKKClSR/GGALyn4FHrcOHCqsHDAxggCAEZzuUvACNUoBOJUCtEILBxhEzHSJNExMSNQqBR36aAU5fcIloUisz0S5fAAIP5CZpj5kRV5UoINOkxp4Ke7uDaNOGpmPl7ir8tK8G107s1+r34uaD9Xjq291w+yXkJGrx0MwhYScx9zaTB6aiX4oeT36zCypRwNi+iXh3bTEWrSuGzR2AUSNi9vg83Di5Pw7VueENxN+S28YVEXZPADJjMGoUGJSoQaJeBYOKErFjKT7OTEnYjqwU1Tgi3d0YY/D4g8GEV5KgEHgYVCKyEwwwaYMjTW21qzFvxOWVUOv0RWRpl8BzuPD4PnhldSE+23IYM4ZntNoGg1oM5ij4pLgqKcgYQ63Th0N1LlTZvVAIPNKN6g6fTASDJ67V5x9oCDj8kgyLy4dqB4MsM4ADBI4LzXaoRB46lQidUvwz4DhiqRUhpGv0KhEFqXr8ftjaYolVxhjqXT70T9GHlqscK5INKhysdcHtk9ostz443YDsBA1K691Ys7ca04dlNDumt5WTjYScRC1euHgkOA5YtLYYL68sDF1ncwfw8spC8ByHWWNzUGmL3K7xXeWXZNjcfnglOZiIbVYjxaBGglZBg2Fx4tj+y+qBYlUpSmYMLp8EpzcAiclQiwLMWgVSDHoY1AoYVGKHltVolSL6p+rxx2ELnN5ARPItThucio82lqDW6cPK3VWYNrT5XihAcCfcOqcPFpcvbr5crC4/SutdqLAGE8uT9aqoBY2iwEMUAA2af1lLDTMdAYnB5ZVgdQWXWDUO/jQGLEoxuMRKp2xYYtUQdGgUAiXEEdIBqUY1+nkD2FdlbzZYZHH7YVArkJ3Ye3bYDpdBrUCKQYVyq6fNwKIxifvtn4uwfEcFzj4uEyLPISAzBCQZizeUYMlvwepGUwam4O+9pJxsJOjVIvJTdbjm/za2eP1/1hbh5in9UePwtZro3Z3qnT74JBlmrQL5JjUSdcq4WblB/kTvSA/UOOLvDUiotHuQYYzOkp6AJMPpk+DyBSstaZUCMhPUSNSqYNSIXf6DTjGo0C9Zh90VjojkWygEHuePysJbPxfhk02HMHVwWqtBl0rkUWnzIMscmaVYneXwBnCozoVyqxt+iSFRp4RKjN2aUIHnIPAC0MLqA5kxBBpmOrx+GQ6PhIDsQePXjShwMGsUGJxhpM6ekA7ISdTCcdTy0IAkw+2XMCzLdMyuE08zqVFm9SAgyW2ORk8ZmIqf91Vj3rSB6J+ig83jh1GjwO+lVvx2sB4AcOmYbMzqZeVku0rkOVjdftjcLVdTtLkDsLoDEHku5oGF0xuAT5YxNMuINIOa8gPjGH3791BqhYABaQb4AlbUOHwRS+rz+CW4fBLcfgkiz0GvFtEvRQdzwxKnSJ/0ZifqYPdIOGxxRSTfYtrQdHz8WykqbB78tK8akwemtnicXi0GO9R2kgOjxeOXcLjejUOW4FR/gjb+R154joNS5FpcBtWY11Ht8GBXuQ1DMky0WzwhYQotD/VJof681ulDqkGFtGMkYbslCVolzNpg6dnWclAAINWgwpLrx+Ptn4tw59JtTfIEPr5+HP67rQxjchO7seU9Q0BmMGkUMGrEFoMLo0aESSOi2h7bpVB+SYbF7cPANAMyTL273HJvQPOBPZhBrcCANAN4Hp3eG4IxBpcvgCq7B2VWNxxeP3QqAUMzjRiTl4AT8hKRn2pAsl4VlZF0gefQPzUYuNQ4fF2+P7VCwDkNidsfbzoEuZVqyipRgC8gw+rq+mN2hC8go6TWid8O1mNftR1KXkCWWRv3QUV7gnkdPNIMGlTbvdhVbutQjX5CjnVapYj8VD04jqHW4QXHA7lJumN63bjAc8g0a+AJSG3uU2HWKfDOL0V4eWVh6AS5MU/g3XXFOGt487wLElz6anH7MWdC3xavnzOhLywuf0xnK2TGUGX3ok+CFjlJupi1g4Tv2O2xeomkhkpRbv+fS5ba01iardLmQbnNA28guDfG8CwTTuibhNG5CchO1MKsVXZL/saRX6iONja4C9dZwzOgVQoorXNhw4Ha1h9XIaLS7g0mLkdZQJJRbnVjc0k9dpXbAAZkGjXQq3t2QHE0geeQbtSg0u7B7gobPH4KLggJV7JehX4pevgkGVkmDRK08VlWvDsl6ZTQqxWtfjcIfHAJ5qK1xS1ev2htMcxa2sOgNRanH9dP6ofbTiuAURP8PjJqRNx2WgGun9QPFlfkNrTtjBq7F4k6Bfqn6Ok97CF611nNMSrTpIbHJ6GwunnyXyO/JMPhDW4Ox3EctMqGkrBaJYya2Nd6bvxC3VVuh6qL+RZ6lYizhmdg6aZD+Pj/2bvz+DirevHjn2eZfc2+tGmbriyFtrRQymJBQBTFi4qiomCvO+hFqvcqiiAqi7soSC+ooPxAEK8oiqJYNqFl697SfUvS7Mvs+8zz+2PalNAkzTLJzCTfN6+8SmbOzJyZJOd5vs855/t9vYkzZ5b1u8TKadXpjiQIxJJjlnElkzHoDMdp7I7QGUpg1TWqPbZBiz4VO01VqHHbaA3EUAhwQo07779fQhSLqSV2VEWh3GmR/QBkZ6Fr3FZ2twdxWY8NtIppn0AhiqcyNHVHuXLpNK49fxb+aAqPTccXSeY91aw/mkTXFOZUumRpbRGRwGICOFJsKZ5K09CdzRSlKhBLZrKVpvukhLUNKSVsPkwtsROMpWjqifYWghup/1g4hSc2NbOnI8SGBh+n9VNZ1aSppA6nXM11YJFNE5mksTtCezCGpqhUuYafOrZYZWcurLT6oyiKwrxqlwQXQgyBpiqTMgvUYMpdFhq6w8SS6WPGkWLZJ1DI4qkMbYE4naEEuqrQEYznPQiLHV6FcVKtmxLH5Eq1XOwK68xSjJimKsyscFLhsnDIF6ElECWaTOGxm5hf62HJ9FKWTC+lvsJJqcNccEEFHN5vUeHEazeNer+Fx2bqTTf7+3WNA7ZzmHVaA7kdRP3RJNtbAqxv6KEjGKfMYaHCZZk0QcURmqpQ7bHR4o+yszVIPCXLooQQw+e26pQ5Lf3uJSyGfQLFIp0xiKcyef+s0odn+qeXOaiVzdpFR2YsJhCrSWNetRu3xYTr8BUcm0krqul0m1nLFoxq8hGKpUa1B+H9i6bwty0tbGsOsK3Zz8m1nmPaOC06XeEE/miS0lFeFQkfThd5qCdKPJ2h1G6e9FfpNVWhymWlxR9FUWBetSuv6XSFEMVHURSqPVZa/THSGeOYizRH9glAtvbCkaxQK86q57PLZ9LUHc1Ht8UItQdjVLut1Jc7JK1sEZLAYoJxWnTmVLvy3Y1RKTu832JHaxCLaeT7LcqcFi44sYp/bGvl9683cst7jw0sdE0lnTHoDsdHHFjEkmla/VEauqNEEmlK7CbKzJM3ReRb6Vp2GVizL3twP6HaLZW7hRDDUno49WwgmjxmaUwh7xMQw9MdTmC3ZBO6yHGiOMlPTRSkqSV2pnhttAfjA6aMHYrLT5uKqsD6Bh972kP9tnFYdNoDcZLp4R18Eqls9fP1B3vY0RpEVxWmeG1Fnzp2LOiaSqXLyiFflF1twWF/1kKIyU3XVGq9NqIDpJ49sk9gT3uYnnCCPe1h2gJxCSqKSCSRIpnJMLfS2e9GfVEcJLAQBenIfosSu4nO0Mg33VV7rLxtbgUAv3+9/70WTotOOJEaci2QdMag1R9jY2MP25r9pDMGtR6bDITHYTo8c9HUE2W3BBdCiGEqc1iwmzXC8YH3axXKPgExPEeK4M0sd1Dptua7O2IUJLAQBctm1phT5UJTFIKxkefS/uDiOgDW7uuioTtyzP2aqmAY0H2cDeOZjEFHMM6mRh+bGnuIxNNUuWx47eai2seSTyZNpdJloaE7IsGFEGJYbGaNareVwCiOB6LwHCmCV+uxM00yohU9CSxEQSt1mJlZ4SAQS5IY4ZT2tFI7y2aWAfDYABminBad9lC838xFhmHQE06wtdnPxkYfPZEElS4rZc7Jl+kpF0yaSoXTSkN3hD3tQVISXAghhqjSZUXXFckyN4F0BuN47SZmVzondaX5iUJ+gqLgTS3JXsXoCMZGvN/iQ0uysxYv7Oqg1R875n6HRSccSx6zHCoQS7KjNcCGxh7aA3FK7ebsgU0Gv1Ex69ng4mBXhD3tIQkuhBBD4rbplDss+PNcEVrkRiCaRNMU5lZJEbyJQs6ORMFTD9foKHWa6RxhkaPZlU5Om+YlY8Af1jcd+xqKgqqqvfs5IokUe9qDbDjYQ0N3BJfFRJXbKlkqcsisq5Q7LRzoCrOnPSRrooUQx6UoCjUeK6mM7KModrFkmnAixexK56jTvYvCIWdJoihYTRqzK11o2sj3WxyZtVi9vY2ufjaEOy06XaEE+zpCrD/Yw572EBZdo9Zjn/T1KMaKRdd6g4u9ElwIIYagxGHGYzfLXosils4YdIXjTCu1SxG8CUYCC1E0Sh1mZlU4CY5wv8XJtR5OrnWTyhj8ccOhY+53mDWCsRS72kIoKNR6bDgskjp2rFl0jTKHhX2dYfZ1hMhIcCGEGIRJU5nitRFJpPLdFTFC7cEYlS4r9RVSBG+ikcBCFJUpXht1pXY6QiPbb/GhwxmintrWesx+CkXJBhM1Hitum0kyPY0jq0mjzGGW4EIIMSRlTjM2s0Y4LsFFsektglflxKLLaoCJRgILUVSO7Lcoc1roGMF+i0XTvMyucJJIZXhiU/Mx92uqgioBRV5YTRolNjN7OkLs65TgQggxMLtZp8plxS/LoYpKJJEimc4wp9KJW2o/TUgSWIiiYzVpzK5wYtIUAkMsaneEoih8aMlUAJ7c3CxXuwqMzaxRarewtz3E/s6wBBdCiAFVua1oqjLiVORifB0pgldf7qDSZcl3d8QYkcBCFKUSh5lZlU7CidSw85kvnVnGtFI74USaJ7e0jFEPxUjZzBpeu5m9HSEOdoUxRphiWAgxsXlsJsoc5mOWtYrCYxgG7cEYNR4b08vsstR4ApPAQhStWo+NulIbnaH4sPZbqIrCBxdnZy3+vPEQsaQUWio0drOOx2Zid7sEF0KI/qmqQo3HRlJSzxa8jlAcr93MnEqX1IGa4OSnK4qWqirUlzspH8F+i3PnVFDtthKIpfjHttYx6qEYDbtZx23NBhcN3REJLoQQxyh1mHFbTIRkWWvBCkSTaKoUwZssJLAQRS1b38KJSVeGNR2uqQofOC07a/HHDYdISuXnguSw6DgtJna1hWiU4EII8RZmXaXGayEUl+VQhSieyhbBm1UhRfAmi4IILO6++25mzJiB1Wpl6dKlvPrqqwO2ve+++zj33HMpKSmhpKSECy+8cND2YuLz2rP1LSLD3G9xwYmVlDnMdIcTrN7ePoY9zA1NVbDoKtoky/nttOg4zTo720I09UhwIYToq9xlxWbSCqquRTpjEEumCUSTdIXitPpjNPujNPujtAVik2LpVjpj0BnKFsGb4pUieJNF3gOLRx99lJUrV3LzzTezfv16FixYwMUXX0x7e/8nes899xwf+chHePbZZ1m7di11dXW84x3v4NChYwueicmjd79FOD7kAdukqbxv0RQA/m99U8EO9BZdpcpjYXalgxKHidmVDqrcFix63v98x43Teji4aA3R1BPNd3eEEAXEadGpcFvGvRJ3xsgGD6FYiu5wgrZAjGZfNnjoDMWJJFKoioLXbqa+ws7JtW4W1nkpc5ppDUQJxQonEBoLHaEYFS6LFMGbZBQjz5f/li5dyumnn85dd90FQCaToa6uji9+8Yt87WtfO+7j0+k0JSUl3HXXXVx11VXHbR8IBPB4PPj9ftxu96j7LwpHPJVmS5MfXyRJlds6pMfEkmk++ZvXCMRSfOOSE1k+t4JUxiiYIMOiq0wttbHq+b08sOYAgWgKt01nxVn1fHb5TJq6o8QnUarFYCxJJJHmhBoXU0vs+e6OGKJcj7syjou36grF2dDgo9RhxpTDzcGGYZBMGyTTGRLpDMlUhlTGQFEMFFRMuoJJU7GZVRxmHbtZx6KrWHQNs65i0dVjTqqT6QzNvigHOsMk0hnKHZYJt6G5J5xAVeHUOq/Uq5gAhjPm6uPUp34lEgnWrVvHDTfc0HubqqpceOGFrF27dkjPEYlESCaTlJaW9nt/PB4nHj+6sTcQCIyu06JgWXSNOZUuNjb14I8m8diOP5hZTRqfOmcmJ9a6OHt2OeF4Co/NhC+SxBdJ5v2k3eswser5vfxs9Z7e2wLRFHeu3g3AlUun0RYYfqHAYuWymjAM2NEaRFEUmV6fJGQcF8dTYjdT4jARiCYpcw6/RkIynTn8ZZBIZUhlMhiAApg0BZOuYTNrVLgsOMw6FpOKWVN7/x1OYGDSVKaXOfDazOzvDNEaiOGymHAP4ZhVDCKJFIl0hlNqPBJUTEJ5DSw6OztJp9NUVVX1ub2qqoodO3YM6Tm++tWvUltby4UXXtjv/bfffju33HLLqPsqioPHbmJ2pYtth/xYdBWrafAMFBZd5VNvq+ee5/by5cc25XxGIGNkD1LxVIZ4Kp39N/mm/09liCff9P+pdO/9Jk3l2/8xnwfWHOj3ue9fs59rz59FZyhRMDMs48FtM2FEYUdrAAWoleBiwpNxXByPqirUem1sDvnIGAZqP3USUkcCh3SG1OEZCONw+KBrCmYtGyR47WacFh2LSesz85DLmRDIHq/mT/FQ6jCzvytMiz9KudOS89cZT8l0hp5IgjmVLimCN0nlNbAYrTvuuINHHnmE5557Dqu1/6UvN9xwAytXruz9PhAIUFdXN15dFHlQ67ESjCY50BWm2m0bdLPzkRmBnz9z7IyAgcElp9Twty0tAwcFvYHAscFCLJUZVUXYeVUuOkNxAtH+1+EGoim6w0n8kSROa1H/KQ+bx2bCfzi4UBWFas/Qlr6J4iTjuBiKUocZpyU742zSshW5kxmjt86RpiqYNAWzpuGymnFZjwQP2cDBrGcDi/Es3qZrKtPKHHjsZg50hmnxx3Ba9CHNuBeaI0Xwar1SBG8yy+vZSHl5OZqm0dbW1uf2trY2qqurB33sD3/4Q+644w7+9a9/ceqppw7YzmKxYLFI1DyZKIpCfYWDcCJFZyg+4H4LTVXw2kwDzgg8sOYAn1s+i0dfb6Q7nBh1v0yagkU/ehB78wHNomtYTEf/32pSKbWbqXBZcNv0foMLt03HbdO59nfrcVp0ltaXckZ9KXOrXP1erZtoskvWDLa3+FEUhryvRhQfGcfFUFh0jVqPlYbuCJDdNO2wZJcwmY+Ms4eDh0LbTOyxvWn2ojNMsz9KRZHNXhwpgje70jnh9oyIoctrYGE2m1m8eDGrV6/msssuA7Kbt1evXs0XvvCFAR/3/e9/n1tvvZV//OMfLFmyZJx6K4qJRdeYXeFiU9yHL5LAaz82f7auZmtfDDYj4IskufCEStpD8cGDAl09HBgcvd3a2yZ7UBtJmthALMmKs+p791S82SfOmsHGhuz76w4naOiO8Ni6Jrx2E6fPKGVpfSkLpnqPuxysmHntZnoiCbY3Z5dFVUpwIcSkNq3MQbXHNuIxN580VaGu1I7XbsoGF74oToupKGYvgrEkmqIwp9KJ3Ty5ZtBFX3n/6a9cuZKrr76aJUuWcMYZZ/DTn/6UcDjMihUrALjqqquYMmUKt99+OwDf+973uOmmm3j44YeZMWMGra3ZqslOpxOn05m39yEKT3a/hZNtzX5iyfQxJ9ipjIHHZhp0RqDcaeYTZ9fnbQ+DL5zks8tnAtk9Ff3tAXnok2fy+sFuXj3QzbqDPfgiSZ5+o42n32jDrKksrPNyRn0pZ8wopWQCFigqsZvpCSfY3hIABSpdElwIMVlpqlL01Z1dVhMn13ooc1rY3xGi2RelwlW4sxfxVJpQPMWJNe4RbZwXE0veA4srrriCjo4ObrrpJlpbW1m4cCFPPfVU74buhoYGVPXoH9M999xDIpHg8ssv7/M8N998M9/61rfGs+uiCNR4rIRiKfZ1ho7Zb5HOGPiiA88IrDirHl8kmdeN0fFUhqbuKFcunca158/CH03hsen4IsnejeVOq8558yo5b14lyXSGN5oDvLK/i1f2d9MejPPqgWzQAdl9G2fUZ2czppVOnDWwJYcLHW5vCaCgUCGbBoUQRUxTs1nvPDYT+zuyG7ttJg2PzVRQ4/aRInjTy6QInsjKex2L8Sb5zyefRCrDlkM+usMJqt19B74jdSL+9/l9A84I5Dvl7BGaqqCrypDrbBiGwYGuSDaw2N/FrrZQn/ur3BaW1pdxRn0pJ9e4J8Sa2K5QHFVVOKnWTblcOSsYUsdCiJHLZAxaAzH2dYYJx5OUO6yYC6RAamsgSqnDzPwpHix6cc8UiYENZ8yVwEJMCv5oks1NPjA4Zr+FRVfx2k147aY+MwKFUMcil7rDCV470M0r+7vY1OgnkT763hxmjcXTs5u/F08vwWnJ+2TmiHWG4uiawkkyLV8wJLAQYvTC8VTv3gurruG153f24kgRvFOmeotiH4gYOQksBiEHpMmrxR9l6yE/Xpu53w3Nw50RKGaxZJqNjT5e3Z9dJuWPJnvv01SFk2vdh7NMlVE9xA3RhfT5dQTjmHWFk2qzWVZEfklgIURuZDIGbcEY+zrCBGNJyp2WvMwURBIpgrEU86d4JN33JCCBxSDkgDR5GYbB7rYQ+zrDVLutRZcxZKykMwa724K8sr+bVw5009gd6XP/9FL74X0ZZcypch6Tytaiq3gdJrw2U2/F80KY8WkPxrCYNE6ucU/ITevFRAILIXIrkkhxoDPMIV8Us6ZRMo6zF8l0hvZgjNmVTmZVOAtqz4cYGxJYDEIOSJNbIpVhW7OfzlD8mP0WIqvZFz28L6Obbc1+3jz54LWbOONwKttTD09/Ty21ser5vTyw5kDB7VFpD8SwmjVOrnX3m3JYjA8JLITIPcMwaAvEOdAZxhdNUubofzY+16/Z7I9S67Vx0gTZmyeOTwKLQcgBSQRiSTY3+sgY2VSlYmDBWJJ1B3t4ZX82lW00me69z6yrPPifZ/DS3k5+tnrPMY+97oI5XLl0Gm2B+Hh2+RhtgRh2s8bJtR48dlkHnA8SWAgxdqKJNAe6QjT1xDCpCqUO85jNInQE49gtGqdO9Ui9iklkOGOu/FaIScdtNTG70sWWQ/3XtxBHuaymPqlstx7y8+rhJVPpjMEpUz18+sHX+33s/Wv2c+35s+gMJfK656LSZaE9GGd7S4C51S7ZcyGEmFBsZo0Tqt2UOSzsO1y1u8xhyfmxLRhLoipIETwxKPnNEJNSldtCMGZnb4fstxgqk6ayaFoJi6aV8Jm3zaQrHMcfGbxyuT+aQleVvAYWiqJQ6bLQGYqzsbGHqV47daX2oi+iJYQQRyiKQqXbittm4kBnmKaeKKF4ilKH+Zh9cSMRT6UJxpJSBE8clyyOE5OSoihML3NQ5bbQHozluztFR1EUqtw2ypxm3Lb+r0+4bToOi8avX9zPnvYQ+Vx1qSgKFS4rDrPOvs4Q6xt6aOqJkEpPnHTCQghhNWnMq3Zxap0Hm1mjxR8lmkgf/4GDSGcMOsNxppXZmVpiz1FPxUQlgYWYtMy6yuxKJ3azRk84ke/uFJ03Vy7vz9XLZvDi7k4eeb2R63+/kS/8bgN/XN9Edx4/a7tZp9ZjI5Mx2HoowKYmH12heF6DHiGEyKXsLK2VhXVeZpY7CcSTdATjZEY4znWEYlQ4LcyscKLK7L44DgksxKTmOrzfIpHOjPqqzmTkCyf57PKZXHfBnN6ZC7dN57oL5vD582YRiad525xyTJpCQ3eE+9ccYMUDr3LLX7bx4p5OEnnIGKUoCl67mWq3FV84yYZGHztaA4Tj/S/pEkKIYmQ1acypcrJgqhenNTt7EUkMb5zriSSwmTRmV7qksrYYEskKJSY9wzDY2xFiT3uIardN9lsM01Aql4fiKV7c3cnqHW3saA32PtZh0XjbnAouOKGKuVX5yYceS6bpCsdxWHSml9qp8dowSQrFnJKsUELkVzyVprErwsGeCBhQ5rAc91gnRfDEEZJudhByQBL9SaYzbDvkpy0Yp9Yj9S1GYqiVt5t6Ijyzo51nd7bTGTq6LGpqiY23n1DJ2+dV5mVzYCCaJBhPUua0ML3MToXTIoWfckQCCyEKQ2cozv7OMF2hBCV204DZnVKHi+DNkiJ4AgksBiUHJDGQYCzJliY/gWgSq0nDZtawmTQZUMdIOmOw5ZCf1dvbWLOvq3dZlKrAwjovbz+hijNnlo7r9Hs6Y9ATSZDKGNR4rEwrs+O2Su2L0ZLAQojCEU+laeyO0NAdwchAmbPv7IVhGLQEolR7bJwsRfAEElgMSg5IYjCBWBJ/JElnKE4gliSWSKMoCjaTht2sY9ZlgB0LkUSKF/d0snp7O2+0BHpvt5s1zp1dzgUnVnFCtWvcgrxEKkNnKI7VpDKt1E5tiU3WF4+CBBZCFJ7ucIJ9HSE6Q3G8NjMOS3b2QorgibeSwGIQckASQxVNpAnGkwSiSTpDCSKJFMm0ga4o2C06NpMm+zHGQLMvyjM723lmRzsdwaNVu2s9Vt5+YhXnz6ug0jU+631DsRT+WBKv3cSMMgeVLotkRRkBCSyEKEyJVIamnggNXRFSGQOrSSOVzjB/qodyqVchDpPAYhByQBIjkckYhBIpQrEUPeEEPdEk0XiatJHBZtKxmzUsuirLpnIoYxhsPeRn9fZ2Xtrb2bsRXAFOnerhghOrWDazbMwrp2cMg55wgng6Q7XbyvQyO167VO8eDgkshChsPeEE+zpD9ESSzK10Mq3Mke8uiQIigcUg5IAkciGRyhCKpwjGssumgrEUsWQGXVWwmjTsZk0yC+VQJJFizd4uVm9vY2vz0aVSNpPGObPLueDESk6qcQ8Y2A11Y/lgkukMXeE4JlVlaqmNqSX2MQ9qJgoJLIQofMl0Bl8kSZnDLDOzog8JLAYhBySRa4ZhEE2mCcVS+CJJukIJwskUqUwGs5oNMmxmDVVmM3KiNRDj2R3trN7RRlvg6FKparc1m1XqhEqq3NmlUhZdxesw4bWZ8EeTeGymY1LhDlckkaInksBtNTGj3EGV2ypL4o5DAgshhCheElgMQg5IYqylMwahWIpgPBtkBGJJook0hpG9wm4za3KlOwcyhsEbzQFW72jjpT1dRJNHCxyeMsXD5Yun8sElU1n1/F4eWHOAQDSF26az4qx6Prt8Jk3d0REHF4aRrToeSaSocluZXuagxG6SpXADkMBCCCGKlwQWg5ADkhhvsWQ6u2wqmqQznCAcSxFPp1EVFfvhZVOSzm90Ysk0a/Z28cyONjY3+TGA+65azOYmPz9/Zs8x7a+7YA5XLp3WZ8ZjJFLpDF3hBIoKUzw2ppXZJYtKPySwEEKI4jWcMXfyHgHDYdD6uWqsaWC19m03EFUFm21kbSMRGCimUxSw20fWNhqFzCBXYR2OkbWNxSCdzk1buz3bb4B4HFKp3LS12bKfM0AiAclkbtparUd/V4bTNpmERAIrYFWg3K4ww2YmnNAIx1L0pBW649kT03Q8jtVIYz88m/HWK9+G2QL64T/XVAolMfAJsWEyg8k0/LbpNEo8NvB7000YZvPw22YyKLFobtpqOoblcKYSw0CJRgCwARdMc3DBtJl0BGK8frCbs+tcfPmxTb1tbcmjn8Mjz23nmjOq6YpFsnsuVA3jTX/3SmSwv+WjbXVNpVpPE0ukaWwM092uMq3UQZXHmt1jI2NE1mDvezRkHJdxfJzG8QFZ3jQ2D6dtKpX9LAZi7juOD7ltOp392Q3EZMq2H27bTCb7u5aLtrqe/Swg+zcRieSm7XD+7mWM6L/tQH/3wxnDjUnG7/cbgOHP/viO/brkkr4PsNv7bweGsXx537bl5QO3XbKkb9vp0wdue9JJfduedNLAbadP79t2yZKB25aX9227fPnAbe32vm0vuWTgtm/9Nbr88sHbhkJH21599eBt29uPtr3mmsHb7t9/tO1XvjJ4261bj7a9+ebB27766tG23//+4G2fffZo27vuGrztX/9qJFNpoyccNzp/vmrQtgfuecDY3OgzNjf6jAP3PDBo24Yf3d3bdv8Djw7atuk7P+htu/f3fxm0bfM3vt3bdvdfnhm0bev1X+1tu/Nfawdt2/7ZL/a23b5m06BtO6/6VG/bbRv3DNo2+tGPGdO/+ldj+lf/apxw/R8Gbbv7be80/vVGq7GpocfY3OgbtK3/7e/o7cPmRp+Rtg08RmRkjMh+ZmAAht/vN3JBxvE3kXE8K4/jeK/77x+87e9/f7Tt738/eNv77z/a9q9/HbztXXcdbfvss4O3/f73j7Z99dXB295889G2W7cO3vYrXznadv/+wdtec83Rtu3tg7e9+uqjbUOhwdtefrnRx2BtZYzIfg1xjBjOGD55ZyyEKAC6pmZTlx4nX7g/miAUS8oym2EwaSpum04gOsjV0cN2tgW59jevU2I3MbfKxaM56kMkkSITS+KS6t1CCCEmgcm7x6K5uf91YjI91n9bmUIffttRTqFnMgbhRIpwPEV3WqEnbmQ3gSeTKIkEJk3BpKlYdBWTpvamB5yMS6H6U1nq4KENbdy5ejcYfZdCXXPeLN63aAp/3niI3e1hdnSE2R1I9aaitSWy701VoK7UxuxKF3MqncytclFb6kS1H/1bHmjZVCKVpjOSxOJ2Mr3UTq3Xjjk+yHubwGNEIBDAU1ub+z0WMo7LOF7g4/iAbWUpVPb/DUOWQo2k7TiPEcMZwydvYCGb/kSRSaYzhOPZehnRRIpgPEU4niaRSpNMG2QMAwMwa2qfgGOypkK16Nl6E//7/D7uX7P/uFmh4qk0ezvC7GwNsLMtxK62YJ/K30fYTBpzKp3Mq3Yxt8rFvCoXJY6BC+YFY0kCsSSlDjPTyxxUOCdf9W7ZvC2EEMVLskINQg5IYiLJZAziqQyxZJp46tiAI5EyyP6XDTjMmop5EgUcFl3FazfhtZvwR1N4bPqw6lh0hxPsbAuyqzXIzrYgu9uDxJLHPq7SZckGGdXZQGNmhQOLfnRT8ZHq3clMpjc9rcdWHMujookUmqoSPLykK5XJDHtJngQWQghRvCQrlBCThKoq2A4X4HuzAQOOWJpIItUbcEB2L8KRgMOsqxOqkF88laEtEKczlEBXFTqC8WFV3i51mFk2s4xlM8uAbI2Sxu4IO9uygcbO1iCN3RHag3Hag3Fe3NMJZCt915c7mFeVndU4odpFjcdKKmPQ6o/RHU5QV2JnaomNjGGM+sR9rMSTaVb1M+NzzXmzsEgtFiGEEG9RGEcvIUROjTTg8EUmZsCRzhjDCigGoqkKM8odzCh3cPHJ1UB2g/bu9hA7W4PsOhxw+CJJ9rSH2NMe4sktLQC4LDpzDgcZ00rtJFJparzWfpdqjceJu2EYGAa9S+gyh783DDDIfl6//Pf+7B6VwwLRVO/3n10+s2ACICGEEIVBjgpCTCLDCTgCsRSR+MQOOHLBbtZZMNXLgqleIHvC3h6MZ4OMw0uo9naECMZTrG/oYX1DD5At4HfPc3v7FPA7cuJuYPCB06ay/qCPVCZDxiD7bwbSb/6+z+3ZfTapjEEmY5DKZEgfbp82IJ02SBvZ2zJGNnAwDIO0kf35Z4zDXxlwWDR++MGF3L9mf7/v+f41+7n2/Nlj/tkKIYQoLgURWNx999384Ac/oLW1lQULFvDzn/+cM844Y8D2jz32GN/85jc5cOAAc+bM4Xvf+x6XXHLJOPZYiIllKAFHLJUtBPfWgCODgUJ2D8ebK4gfCTeOxB0KSp873nr/0ccp/d+uHOf+3nZ971De8nrjodJlodJl4ZzZ5UB24/2BrjA7W7ObwtsDMc6eXX60gN9bPLDmAJ9bPovvPPkG3eFBssyMkXlVLjpD8QFT9QaiKYKxJGXHSZMshBBicsl7YPHoo4+ycuVKVq1axdKlS/npT3/KxRdfzM6dO6msrDym/Zo1a/jIRz7C7bffznve8x4efvhhLrvsMtavX8/8+fPz8A6EmLgGCzhiqTTxZKZPwBFLprNVdI6sOjKO/HN0EzlG7829DY2+3/bOjrzlnz7P1+dxb3k8b1n1dMzz5oHLamLJjBKWzCjBadEJxlKDnrj3hJMsmublQGcYVVFQFPr8299tCvR/e3/t1KPtVSUbkB3512XVqXBZBqwD4rbpUptDCCHEMfKeFWrp0qWcfvrp3HXXXQBkMhnq6ur44he/yNe+9rVj2l9xxRWEw2H++te/9t525plnsnDhQlatWnVM+3g8TvxN+Z8DgQB1dXWSTUSIMXZkaDHeEhwYxwkm3joiDXT/8Z7vmCCkgPLfKYDdorPk1qcHPHF//RsXEYmn8hYKaarCr17su8fiiOsumDOsPRajzeIk47gQQuRP0WSFSiQSrFu3jhtuuKH3NlVVufDCC1m7dm2/j1m7di0rV67sc9vFF1/Mn/70p37b33777dxyyy0567MQYmiOLEk6dgvG5N6TcUQ0kWLFWfX9nrivOKueVCaDd5D6GOPhmvNmAeQ9K5SM40IIURzyGlh0dnaSTqepqqrqc3tVVRU7duzo9zGtra39tm9tbe23/Q033NAnEDlypUsIIfLJZtYL5sR9IBaTxmeXz+Ta82f3SYc73n2TcVwIIYpD3vdYjDWLxYLFIhsMhRCFp1BO3AdzZLnTkY3aZtTBmo8JGceFEKI45DWwKC8vR9M02tra+tze1tZGdXV1v4+prq4eVnshhChkhXDiLoQQQuRCXo9gZrOZxYsXs3r16t7bMpkMq1evZtmyZf0+ZtmyZX3aAzz99NMDthdCCCGEEEKMvbwvhVq5ciVXX301S5Ys4YwzzuCnP/0p4XCYFStWAHDVVVcxZcoUbr/9dgCuu+46li9fzo9+9CPe/e5388gjj/D6669z77335vNtCCGEEEIIManlPbC44oor6Ojo4KabbqK1tZWFCxfy1FNP9W7QbmhoQFWPTqycddZZPPzww9x44418/etfZ86cOfzpT3+SGhZCCCGEEELkUd7rWIw3v9+P1+ulsbFR8p8LIcQ4OJLFyefz4fF4Rv18Mo4LIcT4Gc4YnvcZi/EWDAYBJFWhEEKMs2AwmJPAQsZxIYQYf0MZwyfdjEUmk6G5uRmXy9VbwGuojkRscpXsWPLZDEw+m4HJZ9O/ifa5GIZBMBiktra2z9LWkZJxPPfkcxmYfDYDk89mYBPpsxnOGD7pZixUVWXq1Kmjeg632130vyRjRT6bgclnMzD5bPo3kT6XXMxUHCHj+NiRz2Vg8tkMTD6bgU2Uz2aoY7gkTBdCCCGEEEKMmgQWQgghhBBCiFGTwGIYLBYLN998MxaLJd9dKTjy2QxMPpuByWfTP/lcxo58tv2Tz2Vg8tkMTD6bgU3Wz2bSbd4WQgghhBBC5J7MWAghhBBCCCFGTQILIYQQQgghxKhJYCGEEEIIIYQYNQkshBBCCCGEEKMmgYUQQgghhBBi1CSwEEIIIYQQQoyaBBZCCCGEEEKIUZPAQgghhBBCCDFqElgIIYQQQgghRk0CCyGEEEIIIcSoSWAhhBBCCCGEGDUJLIQQQgghhBCjJoGFEEIIIYQQYtQksBBCCCGEEEKMmgQWQgghhBBCiFGTwEKIAvGxj30Mq9XKrl27jrnvjjvuQFEU/vrXv/beFgwG+Z//+R/q6+uxWCxMmTKFyy+/nEgkMp7dFkIIwdDH8Oeeew5FUQb8uvXWW/PQeyFyQzEMw8h3J4QQ0N7ezgknnMDChQt55plnem/fv38/J598Mpdccgl/+MMfAPD7/SxfvpympiY+85nPMHv2bDo6Ovj3v//Ngw8+SElJSb7ehhBCTEpDHcPb2tp4+umnj3n8gw8+yD//+U9effVVTj/99PHsuhA5I4GFEAXkvvvu4zOf+QwPPPAAV199NQDvete7WLNmDW+88QZTpkwB4JprruF3v/sd69evp76+Pp9dFkIIcdhQx/D+zJkzB0VR+p3xEKJYyFIoIQrIpz71Kc4++2y+8pWv0NXVxSOPPMJTTz3Fd7/73d4Dks/n4/777+czn/kM9fX1JBIJ4vF4nnsuhBBiKGN4f1599VX27NnDlVdeOY69FSL3JLAQooAoisL//u//4vf7+fznP8/111/PkiVLuPbaa3vbvPjii8RiMWbPns3ll1+O3W7HZrNx9tlns3Hjxvx1XgghJrmhjOH9eeihhwAksBBFT5ZCCVGAvv71r3P77bejaRqvvvoqp512Wu99P/nJT1i5ciVlZWXMmjWL6667Dr/fzy233EIikWDbtm3U1NTksfdCCDG5DTaGv1U6nWbKlClMnz6dV155ZRx7KUTu6fnugBDiWOXl5QDU1tYyf/78PveFQiEge2Vs9erVOJ1OABYtWsSyZcu4++67+e53vzu+HRZCCNFrsDH8rVavXk1bWxtf//rXx6NrQowpWQolRIFpbGzk5ptvZv78+TQ2NvL973+/z/02mw2ASy+9tDeoADjzzDOpr69nzZo149pfIYQQRx1vDH+rhx56CE3TuOKKK8aph0KMHQkshCgwX/jCFwD4+9//zgc/+EFuvfVW9u3b13t/bW0tAFVVVcc8trKykp6envHpqBBCiGMcbwx/s2g0yuOPP86FF17Y75guRLGRwEKIAvL444/zxBNP8J3vfIepU6fy05/+FLPZ3Gfj3+LFiwE4dOjQMY9vbm6moqJi3PorhBDiqKGM4W/2xBNPEAwGZdO2mDAksBCiQASDQf7rv/6LRYsW8cUvfhHIzk585zvf4amnnuKxxx4DYN68eSxYsIA///nPdHZ29j7+n//8J42NjVx00UV56b8QQkxmQx3D3+zhhx/Gbrfzvve9b7y7K8SYkKxQQhSI6667jrvuuouXX365T9XVdDrNGWecQWtrKzt27MDlcvHss89y0UUXMXv2bD772c/i9/v58Y9/TE1NDevWreuz90IIIcTYG84YDtDd3U11dTUf+MAH+N3vfpevbguRUzJjIUQBWLduHXfffTfXXHNNnwMSgKZprFq1itbWVm688UYAzj//fJ566ilKSkr4+te/zs9//nMuu+wynn/+eQkqhBBinA13DAd47LHHSCaTfPSjHx3v7goxZmTGQgghhBBCCDFqMmMhhBBCCCGEGDUJLIQQQgghhBCjJoGFEEIIIYQQYtQksBBCCCGEEEKMmgQWQgghhBBCiFHT892B8ZbJZGhubsblcqEoSr67I4QQE55hGASDQWpra1HV0V/PknFcCCHGz3DG8EkXWDQ3N1NXV5fvbgghxKTT2NjI1KlTR/08Mo4LIcT4G8oYPukCiyMVLxsbG3G73XnujRBCTHyBQIC6urre8Xe0ZBwXQojxM5wxfNIFFkemzd1utxyQhBBiHOVq2ZKM40IIMf6GMobL5m0hhBBCCCHEqElgIYQQQgghhBg1CSyEEEIIIYQQo5bXPRYvvPACP/jBD1i3bh0tLS08/vjjXHbZZYM+5rnnnmPlypVs27aNuro6brzxRj7xiU+MS3+FEMUvnU6TTCbz3Y0JxWQyoWlavrshhJgEZAzPvVyO4XkNLMLhMAsWLOA///M/ef/733/c9vv37+fd7343n/vc53jooYdYvXo1n/rUp6ipqeHiiy8ehx4LIYqVYRi0trbi8/ny3ZUJyev1Ul1dLXUlhBBjQsbwsZWrMTyvgcW73vUu3vWudw25/apVq6ivr+dHP/oRACeeeCIvvvgiP/nJTySwEEIM6sgBqbKyErvdLifAOWIYBpFIhPb2dgBqamry3CMhxEQkY/jYyPUYXlTpZteuXcuFF17Y57aLL76YL33pSwM+Jh6PE4/He78PBAJj1T0hRIFKp9O9B6SysrJ8d2fCsdlsALS3t1NZWZnzZVEyjhcOwzCIJTPYzLL0TYwfGcPHVi7H8KLavN3a2kpVVVWf26qqqggEAkSj0X4fc/vtt+PxeHq/pFqrEJPPkfW4drs9zz2ZuI58tmOx9lnG8cKQSmfY3RZiU5OPUDyV7+6ISUTG8LGXqzG8qAKLkbjhhhvw+/29X42NjfnukhAiT2TqfOyM5Web63G8MxSnPRjLUe8mh1gyzRstAfZ1hugJJ2jsDmMYRr67JSYZGcPHTq4+26JaClVdXU1bW1uf29ra2nC73b3TOG9lsViwWCzj0T0hhBBjINfjuC+S4EBnhFkVKaaVOdBUOVkZTCCWZFdrkM5gnEq3lXTG4JAvRqXLSplTjq9CiKOKasZi2bJlrF69us9tTz/9NMuWLctTj4QQQhSjWDLNzrYQO1sDxJLpfHenYHWG4mxp8tMdTlDtsWHSVKwmDcWAg10RUulMvrsohCggeQ0sQqEQGzduZOPGjUA2nezGjRtpaGgAstPfV111VW/7z33uc+zbt4//+Z//YceOHfziF7/g97//Pddff30+ui+EEHl14MABFEXpHUOH4oEHHsDr9Y5Zn4qFxaRR6bLQ0B1h6yE//qjkxX8zwzA45IuytclPIpWh2m3tM7NT5rTQEYrTFowP8ixCiOOZaON4XgOL119/nUWLFrFo0SIAVq5cyaJFi7jpppsAaGlp6Q0yAOrr63nyySd5+umnWbBgAT/60Y/45S9/KalmhRBCDJtJU6l22+iJJNjS5KM9IPsuANIZg30dYd5oDqBrKuVOyzHrrzVVwWbSONgZlhkfIQqYYRgk0xliyTSZcdgXldc9Fuedd96gm78eeOCBfh+zYcOGMeyVEEKIyUJTFardNrrDCTYf8jM7kaKudPLuu4in0uxtD9HQHaHEbsZuHvg0wWsz0eyP0tQdYXaVaxx7KYQ4nnTGIJ3JkEgbpDMGCqBrCuoYb4Avqj0WQgiRc+HwwF+x2NDbvjXldX9tRuCpp57inHPOwev1UlZWxnve8x727t3bb9vnnnsORVF48sknOfXUU7FarZx55pls3br1mLb/+Mc/OPHEE3E6nbzzne+kpaWl977XXnuNiy66iPLycjweD8uXL2f9+vUj6n+xKHWYcZp1drRO3n0XoXiKN5oDHOyKUOG0DhpUQDaLTIndTFNPFH9ElpKJPBnPMbzAx/Hm5mZS6QzRRJp/r3mZiy++mOlTqplWXc4l77hgXMZxCSyEEJOb0znw1wc+0LdtZeXAbd/1rr5tZ8w4ts0IhMNhVq5cyeuvv87q1atRVZX3ve99ZDIDb5r97//+b370ox/x2muvUVFRwaWXXtonN3kkEuGHP/whDz74IC+88AINDQ185Stf6b0/GAxy9dVX8+KLL/Lyyy8zZ84cLrnkEoLB4IjeQ7FwWHQqnNl9F9ua/QRik+dkuSecYOshP+2BODUeG2Z9aKcHdrNOMpPhYHeYTEbSz4o8GM8xvEDH8eeee56DDQ1cv/LLRBJpEukM4VCIj3384/zrmed49oUXmTlrNu99z3vGfBwvqnSzQggx2XzgLQfGX//611RUVPDGG2/gHOAgd/PNN3PRRRcB8Jvf/IapU6fy+OOP86EPfQjIFkBatWoVs2bNAuALX/gC3/72t3sf//a3v73P89177714vV6ef/553vOe9+TsvRUis57dd9EejBFN+plb6aTSbc13t8ZUqz/GzrYAqZRBjcc67Hz2ZQ4Lrf4YVW4rVRP8sxJiJMZqHL/r7l8wvX4myXSGT33mc3z/9tvQVAVFgfPffv7RJzPgZ3ffw7SaijEfxyWwEEJMbqHQwPdpWt/v29sHbqu+5QrvgQMj7tKb7d69m5tuuolXXnmFzs7O3itcDQ0NnHTSSf0+5s0puEtLS5k3bx7bt2/vvc1ut/cGFQA1NTW0v+m9tbW1ceONN/Lcc8/R3t5OOp0mEon0SaYxkWmqQo3HRlcozpZmP7OTaepK7KgTbN9FJmPQ0B1mT3sYs65S6R5ZTQqTpmLWVPZ3hvHaTVh07fgPEiJXCnwMh9yO4xkju3fCbrdTUzeDeCqNpihMmVJLR0c7R64LtLW18e1v3cS/n3+Bjo7xG8clsBBCTG4OR/7bDuLSSy9l+vTp3HfffdTW1pLJZJg/fz6JRGLEz2kymfp8ryhKn0QaV199NV1dXdx5551Mnz4di8XCsmXLRvWaxajMaSEUT7G9JUA4kWJWhXPCnDQnUhn2dYQ40BXGazPjsIzudKDEYabFH6XFF2VG+ciWiwgxIgU+hkPuxvFUOkMkniaeymAymQ7PTmQjCYW+4/hnPvmfdHd38f0f/Zhp06ahmcy84/y3jfk4LoGFEEIUqK6uLnbu3Ml9993HueeeC8CLL7543Me9/PLLTJs2DYCenh527drFiSeeOOTXfemll/jFL37BJZdcAkBjYyOdnZ0jeAfFz2nRMWsqDV0Rook0c6tcuKym4z+wgEUTaXa1BWnxxyh3WnISLKmKgttqoqE7SpnTUvSfkShMg2USLVSjGcfr6upIZQw6OrvYtWsXs+bOw8BAOxJMDDKJ+vLaNfzkZz/nne96FxhwoKFhXMZxCSyEEKJAlZSUUFZWxr333ktNTQ0NDQ187WtfO+7jvv3tb1NWVkZVVRXf+MY3KC8v57LLLhvy686ZM4cHH3yQJUuWEAgE+O///m9sNtso3klxe/O+i81JP3OqnFS6inMvgT+SZGdbgO5wgiqXFV3LXQ4Xl9VEsz9CY3eEE2vcw96rIUR/IokUncEYiVSGSDKNoqdRFQVVAVUd+/SpozXScfyWb38bu8tLeUUF3/nWTZSVZcdxTVVgCG951uzZ/O6hhzjttMUEAwG+fsPXxmUcl6xQQghRoFRV5ZFHHmHdunXMnz+f66+/nh/84AfHfdwdd9zBddddx+LFi2ltbeUvf/kLZrN5yK/7q1/9ip6eHk477TQ+/vGP81//9V9UVlaO5q0UvWy9CyvJVIath/wc7Cq+LEjtwRhbDvkIRFPUeGw5DSqOKLVbaPbF6ApPrmVzIncMwyAcT9Hsi7Kp0cdr+7vZ1RrIFnczDBKpDNFkmkgiTTieIhxPEU+mSaYzpDOZgpvVGOo4bhgGqXSGRCqb6vqmW77L/3zlepaffSbt7W089vjjwxrHf/G/9+Lz9XD2mWfwqf9cwWevuXZcxnHFKLSfwBgLBAJ4PB78fj9utzvf3RFCjINYLMb+/fupr6/Hai3OK81D8dxzz3H++efT09OD1+sd19ce7DPO9bg72ufb0x5kf2eE6hFmMArFUgRiCaaV2ZlZBPsuDMOgqSfC7vYQKgplzpFt0h6q9mAMr93EgqneMQlexMRjGAaheIpALEVnME5PJEEsmcasaTgsGlYlDaEOpk2fjuXI+GJAxsg+9kjSVgVQleyFAO3wbIaqZLMkFeoMWsYwSKWNw4GRwQsvPM+l77yIQ20duRvHDUhlDOwWDf2tm9QPy9UYLkuhhskwDPZ2hHBZTVS6LAX7iyqEEGJsOK06Jl3hYFeEWDLDnCoXzlFufh4rqXSG/Z1h9neGcVr0cdn7UOaw0BqI0RqIMbXEPuavJ4qTYRgE4yn8kSQdoRiBSIpYKoNFV3FadMocRwNgI5XhmKvgSjaIAAWt9zmzz5tMGyTS2UeoSnYP0NFAI/9LqAzDIH04oEilM6QNA4VsH/Uizz5XmCNhATMM6Agk2NcRZmqpjRlljuNWJxVCCDGxWHSNareNtmCMaCLNnCoXFa6xnQkYrlgyzZ72EE09EcocFqym8ZlZ0VQFh1njYFf2dW3mwp7REeMnk8kGE4FokrZAjEAsSSKdwappOCw6Zc7R/a4cmZl48zV5w8jOCqRTBgbZWQ3lyKyGovQGGeo4zGpkU8VmZydSaaN3I7ZpAs3syRnxCGWzhETpCSeZWeGgymWdcDnOhRDF5bzzziu49cWFyKypmLTRj9eaqlDjttIdTrD1kI9ZFU6mFki9i2Asyc7WIJ3BOJVu67ifuHhsJpr9UZp6Isypco3ra4vCks4YBGNJ/IeDiWA8RTKVwWbScVvHvu6JotCbRQnoXUKVThskMQADlWzaVk2lzxKqXP0tpzMGqUyGZDobWCjQJ1Xsm71t+XLC8eSxT1IkJLAYIbOuUuow44sk2dLkp6ckwfQyx6hzgQshxo6cdI+dYvhso4kUmqpiM+ssm1WGP5LEF0kST2WO/+ABKEp2z0IwlmR7S4BIIs3MCidmPX9XIDtDcXa1BgnFU1R7bNksMuNMURRK7GaaeiJUuCx47UPfdCqKXyqdIRhL4YskaAvGCcVSpDMGNpNGic084kDXOHZB1PAds4RK6Z3VSKYhkc6gkN2XcWQJlaYoKCq9AceQ+moYpDLZpU6pjEHGMFAVBdMQszqNt1yN4XIWPAqKolDiMJNIZWjojtAdSTKz3EG1W2YvhCgkRwrCRSKRSZ02dSxFIhHg2OJ7hSKeTLPq+X3cv2Y/gWgKt01nxVn1fHb5TJq6o6MKLiCbatWsq+zvChNLppmdh30XhmHQ7I+xuy2IYUC125rXfYB2s04wluJgVwSX1ZSXAEeMn2Q6QyCaDdY7QoeDCSOD3aRT6hh5MAGAqmMAsWgUqzX3Y3jfWQ0lO6vBm5dQZfdAHNmf0WdW4y1LqDJvmZ2A7GNMBf77n6sxXAKLHDDrKrUeG75okq2H/HSHE8wodxTsZj4hJhtN0/B6vbS3twNgt9sl8UKOGIZBJBKhvb0dr9eLphXeevpoIsWq5/dx5+rdvbcFoqne769cOo22QHzUr2PRNWrcNtoCMWLJDLOrnJSPcQamI9IZgwOdYfZ1hrGZNDy2wgjwSh1m2gIxqtxWqj0TNyPbZJVIZQjEkvSEE3QE44QTaTIZI7tfwmHOWVYwRVXBZKezowMAq82GMs6X/Q2Obg4/sltDPbxhQ1eyy5qysxSZ3tmJI7Mb6XHtaf/SGQPVODYrVK7HcDnzzZEj077JdIamngi+SIL6CifVbqtcpRGiAFRXVwP0Bhcit7xeb+9nXGg0VeX+Nfv7ve/+Nfu59vxZdIYSvVcXR/daCjUeK13hBFub/MyqdDLFaxvTWex4Ks3e9hAN3VFK7KaCSihi0lTMmsqBrjAljrFfTy/GXjyVJhBN0R2O0xlKEI6ngOwMVYXTMmbnPKqjhEwY2ts7CmYlUTbYMHr/H7IF4grxwlXGMDDr6oBLuXI1hhfO6DNBmDSVKV47/miSrU0+urw26ssd45LiTwgxMEVRqKmpobKykmSyeDfGFSKTyVSQMxVHBGNJAtFUv/cFoin80RS6quQksIDs71r5W/Zd1Jc7xmTfRTieYldbkLZAjAqnNa97OwZS4jDT4o/R3BOlvsKZ7+6IEYgl0wSiSbrDCTpDcSKJNIoCDrNOpWt8LqAqioLmLMXIeCHT/9/zeCu88KF/6YxBTyTBKbWefs9HczmGS2AxRjw2E3azRos/hj+apL7cQU2eNtEJIY7SNK2gT4JF7rmsJtw2vd/gwm3T8dh0OoKjXwrV3+uaNJX9nWGiiRRzqlw5TfDRE06wsy2IP5Kk2l24xxdVUfBYTTT0RCh3WeRCW5GIJtIEYkk6g3G6I9mZCU1VcZp1qtymvNWBUFQVVEkGMBxKxiCjGpgtVqxj/PdXeJc2JhCTlt17oaCwrTnA1kN+AjG5UiqEEOMpncmw4qz6fu/7xFkz8EWSOZuteCurSaPabaUtEGdLk5+uUG4CmFZ/jC2H/IRjKWo8hb/k1mnViSUyNHZHiiKD2GQVSaRo8UfZcsjHawe62dDgo8Ufw6Sq1HhsVLutOK16XovLicImMxbj4MjsRVsghi+aoL7MQa3XlrNNTUIIIQZmM+tcc94sgD5Zoa5eNoP/PLue9hxs3B7MkX0XnaEEW5r8zK7K7rsYyTrsTMagoTvMno4wZk2l0l08G6LLnGaafTEqXNaCKyY4mUUTafzRJO3BGD3hBLFUGl1RcVp1vDZTQe4XEIVLAotxYtKy0X4gmuSNliA9kSQzyh0Fk7lDCCEmMotJ47PLZ3Lt+bMJRJO4rDrP7+rgA/esZcVZM1hQ5x3T11cUhQqXJXsMaA4Qiaepr3AMKwVnMp1hb3uIg11h3DZz0WUetOgaqpLiYFcYr900oaoNF5tYMhtMdAbjdIUTRJMpdFXFadEpsZslmBAjVlyj0gTgPjx70R6M4Ytk09JOkdkLIYQYc0eyJUUSKbY2+3liUzN7O0L89uUD/HDqgnE5mXLbsvUu9naEiCbTzK50DmnfRTSRZldbkBZ/jDKHBaupOPcJlTrMtAWjtPpj1JXa892dSSWRyuCLJugKHd2ArSkKLquO1zayGTQh3koCizzQNZVqt41gLMmO1gDd4QT15Q6pTCqEEOMgkc4Wr/rQkjr+tb2NXW0hXt7XxbJZ5ePy+kf2XbQGokSTaeZWuSh1DDz++6NJdrUF6QrFqXJZi/pClKYqOMwmDnZHKHOaCyo17kSUTGfwR5N0hxK0h+KEY0k0VcVh0anO4wZsMXEV7+g0AbisJqpcNrpCCTY2+jjQGSKZHl31VyGEEENTYjfz3gVTAHjwlYYx28DdH11TqXHbCMdTbG7yccgX7XdTc3swxpYmH/5IkhrPxJjddlt1QtEkTd3RfHdlQkqlM3SF4uxpD/La/m7WH+zhYHcYFaj22KhyW3FaZAO2GBvFP0IVOU1VqHJbsegaO1uDbG7y0RNO5LtbQggxKbxv0RScFp3G7gjP7Rzf4omKolDpsqKrKtsO+dnTfvTikmEYNHZH2HrITyptUOW2TpgTQUVRKHVYaPJF5HiXI+mMQU84wd72EK8f6GF9g4+9HWEMAypdVqrdNlxWmaEQY0/mIAuE06JjM2l0heNsavQxrczO1BJ7QRY7EkKIicJp0bl88VQeWHOAh19t4G1zK8Z9U7HHZsJyeN9FJJHd1N3mj7G/M4zTok/Iug82s0YglqShO4LbZir4dLmFKJMxCMZS9ETitAbihGIp0kYGh9k0phWwhRiMBBYFRFOzV6+OVFLtDieYWeEcdO2tEEKI0Xn3KTU8sbGZ9mCcp7a2cumC2nHvg9WkUeWy0uKPEoynCMWSlNot2MzFuUl7KEodZlr9USrdFmo8tnx3pygYhkEglsIfSdAWjOOPJkmnDWxmjVKHWTJtibyT38AClN1UZcMfSbKxsYc97UHiqXS+uyWEEBOS1aTx4TPqAPj9641EE/kZb/XDRVWNjEGlyzqhgwrIpmG3mnQOdkaIJeUYNxDDMAjGkjR2R1h3sId1B7t5oyVANJ6m1G6m1mujxC5BhSgM8ltYoDRVodJtxWHW2dMeZnOTn84cVWwVQgjR10UnVlHjseKLJnlic3Pe+qEoCt5JdJLotZvwRRMc6pGN3G8Viqc45IuysdHH6we62dbsJxRL4bGameK1UyIzFKIA5f038u6772bGjBlYrVaWLl3Kq6++Omj7n/70p8ybNw+bzUZdXR3XX389sVhsnHo7/uxmnWq3lUA0yaYmH3vaZPZCCCFyTddUPnrGNAAeX99EMJbMc48mB1VR8NjMNPVECMhnTiSRotkXZdPhYGJLkx9/JInTYmKK106Z0yJ7L0VBy+tv56OPPsrKlSu5+eabWb9+PQsWLODiiy+mvb3/zBwPP/wwX/va17j55pvZvn07v/rVr3j00Uf5+te/Ps49H19H9l44zTp7OkJsavTREYz3m5pQCCHEyLxtbgUzyuyEE2n+b31TvrszaTgtOrFUhoauyKQ8rsWSaVr9MTY3+Xhtfzdbmnx0hRI4zDpTvDbKnMVbEFFMPnkNLH784x/z6U9/mhUrVnDSSSexatUq7HY7v/71r/ttv2bNGs4++2w++tGPMmPGDN7xjnfwkY98ZNBZjng8TiAQ6PNVrOxmnRqPjVAszaYmH7vbQrIuVQgx4Y3XOK4qCh8/cwYAf9nUQpcsPx035Q4LLf4YHZPkM48l07QHYmw75OfV/d1sauqhIxDHatKo8diocEkwIYpT3gKLRCLBunXruPDCC492RlW58MILWbt2bb+POeuss1i3bl1vILFv3z7+9re/cckllwz4Orfffjsej6f3q66uLrdvZJypikKFy4LbYmJfZ4iNjT7ag7FJeZVHCDE5jOc4fvqMEk6sdpFIZ3j09cYxex3Rl1lX0RSFg12RCVso1jAMOkNxdrQEeP1ANxsafbT4Y5gPF0usdFuxm3UUqTUhiljeAovOzk7S6TRVVVV9bq+qqqK1tbXfx3z0ox/l29/+Nueccw4mk4lZs2Zx3nnnDboU6oYbbsDv9/d+NTZOjAOFzZy9qhFLpNnc6Gdna1BmL4QQE9J4juOKonDVshkA/PONNlr8sql4vJQ6zHSF4rT4Jt5nnkhl2NOevRjY1BNFU1Wq3Vaq3FYcFgkmxMRRVDuAnnvuOW677TZ+8YtfsH79ev74xz/y5JNP8p3vfGfAx1gsFtxud5+viUJVFMqcFjw2Ewe6wtnZi4DMXgghJpbxHsfnT/Fw2rQS0hmDh15pGNPXEkdpqoLTYqKhO0I4nsp3d3LGF0mw5VC2ErbbYqLKbcVp0aUKtpiQ8hZYlJeXo2kabW1tfW5va2ujurq638d885vf5OMf/zif+tSnOOWUU3jf+97Hbbfdxu23304mMzGnTofCatKoPTx7sanJz47WAKEJNCgLIcR4u2rZdABe2NXB/s5wnnszeXhsJkLxNI3dxb+RO50xaDh80a8nnKTaPfFrkwiRt8DCbDazePFiVq9e3XtbJpNh9erVLFu2rN/HRCIRVLVvlzUt+0da7APQaCmHZy+8NhMHuyKsP9jDgc6QpKYVQogRmFXh5JzZ5RjAgy8fyHd3JpUyh5lD/ig9keJNPxuOp9jW7OeNliBmTaXKbUVTZYZCTHx5XQq1cuVK7rvvPn7zm9+wfft2Pv/5zxMOh1mxYgUAV111FTfccENv+0svvZR77rmHRx55hP379/P000/zzW9+k0svvbQ3wJjsrCaNKV47uqqwozXEhgYfrf4Y6czkDryEEGK4PrZ0OqoCrx3o4Y2W4s0oWGysJg0MaOgKF92xyzAMWv0xNjb6aPZFqXRZcFlN+e6WEONGz+eLX3HFFXR0dHDTTTfR2trKwoULeeqpp3o3dDc0NPSZobjxxhtRFIUbb7yRQ4cOUVFRwaWXXsqtt96ar7dQsFxWEw6Lji+SZHOTj0qXhWllDkrsJtkkJoQQQzClxMaFJ1bxzzfa+O3aA9z+vlNk/BwnpXYzrYEYlYEYtV5bvrszJLFkmgOdYRp7olg0lVqPTX5fxKSjGJNsDVEgEMDj8eD3+0e0ATCTMXhlXzcGRtFchUilM3RHEhjAFK+VulIHTkteY0ohxCQy2nE318+3pz3I/s4I1W7rcdt2huJ85sHXSaYNvnXpySyeXjKSLosR6AknMOkKi6aVFHxNh65QnH2dYbpCccocUoNCFJ5QPMXJtW7ctuGfuw5nzC2qrFBiZHRNpdJlxWPNZtuQ/RdCCDE05U4L7z6lBoDfvnyAzOS6FpdXXrsJfzRJU08k310ZUCqdYX9HiM1NPgLRJDUemwQVomBYdJUqj4V51U5mVTiwmjQiibFN7iOXrSeRbPYoO6FYih2tIVoDcaaX2al0yaYyIYQYyOWL6/jHtjb2dYR5aU8n586pyHeXJgVFUfDazDT1RKlwWfGM4ErrWArEkuzvCNPij+KxmWUlgCgoFl1laqmNVc/v5YE1BwhEU7htOivOquea82ZhGaMAWGYsJiGnVafGYyWezLC50ceWJh9dofikz6wlhBD98dhMvG/RFAAeeqWh6DYUFzOHRSeRynCwK0ymQD73TMag2RdlU6OP1kCMKpdVggpRcLwOE6ue38vPVu8hEM3OUgSiKe5cvZtfPLd3zGYuJLCYpFRFodRhptJlpTOUYEOjj+2tAYKx4k3vJ4QQY+U/Ftbituoc8kX51/a24z9A5EyZw0JbIEZnKJ7vrhBNpNnRGmDLIT8YUOuxoWtyKiUKi6YqeG0mHlhzoN/771+zH10dm99b+WuY5PTD+bU9VhON3RHWN/SwvyNELCn7L4QQ4gi7WeeDS+oAeOS1BhKpyVuUdbyZdRVdVTnQFc7r594RjLOpyUdDV4Qyhxmv3Zy3vggxGF1V8EeTvTMVbxWIpsbsQrIEFgI4uv/CrGrsbAuxscFHiz8qU/5CCHHYJfNrKHda6Awl+NuWlnx3Z1IpsZvpDido8UfH/bUTqQx72oNsavIRTaSp9dqw6LJBWxSuVMbAbTXhtvW/RM9t08css6kEFqKPI/svEqkMmxp9bJb9F0KICUZTlBFldzLrKh85Iztr8ft1jWOeXUUcpakKLks2s2EoPn6fuz+SZOshP3vaQ7gsOuVOi9SmEAXNMAwe39DEC7s7uHrZjH7brDirnlRmbGb/JLAQx1AVhRKHmSqXle5Qgg0NPra3yP4LIcTE4LaZUBVlRDOyF5xQxRSvjWAsxZ82HBqD3omBuG0mwvEUjd3hMb/Ylc4YNHZH2NjUQ3c4QbXbht0sG7RFYQvHU9z+9x3c9+/93PH3nXzynHquu2BO78yF26Zz3QVzuOa8WWP2+yx/JWJAuqZS6bYSS6Zp7I7SEYpTV2Kn1it5uoUQxctjM+Gy6oTiqWGnMNVUhY+dOZ3vPbWDP21s5t2n1hZcGtSJrMxh4ZAvRqXLSpnTMiavEUmk2NcRpqkngstiotQtP19R+Pa0h/jeUztoDcTQVYULT6ykzR/jyqXTuPb8WfiiSbw2M6lMZsxSzYLMWIghsJo0ar02zJrGrrYgGxt8NPuipNKyeVEIUXx0TaXKZSEUH9ks7FmzyphV4SCaTPPY64057p0YjNWkoRjQ0B3J+THIMAzaAjE2Nfpo6olQ6bKOqEqxEOPJMAz+vrWF//7DJloDMSpdFr73gVN5z6m1JNIGbYE4O1tD7G0PE0umx3zmTQILMWROi06tx0YilWHLIT+bm/x0yv4LIUQRKnGY0TWV5AhOTlVF4aozZwDwt60tdATznwZ1Mil1mGkPxmnL4eceT6XZ3RZiS5OfeDJDrceGSdLIigIXSaT44T938Yvn9pLKGCytL+XOKxYxt8rVp106YxCOpxiPszX5qxHDohzef1HptNATTrDx8P6LgOy/EEIUEbfVhMdmIhgb2UbgRdO8zK91k0wb/O61hhz3TgxG11RsJo2DneGcpEbvCSfY0uRnX2cIj81EmWzQFkXgQGeYlb/fxAu7O1AV+M+zZ/CNS07Eac3vLgcJLMSIHNl/4bWbaOyOsuFgD3vbpf6FEKI4qKpCtdtKNDmywEJRlN6MK6u3t9HUE8lh78TxeG0mArHkqD73VDpb0XtTow9fJEm1W/YPiuLwrzfa+PJjmzjki1LuNHPH+0/lfYumFkRALIGFGBWLfnj/ha6xuz3IhoYeDsn+CyFEEfDYTVh0dcQXRE6ocXPGjFIyBvy/V2TWYjwpikKJ3UxTdxR/ZPgz5qF4im3NAba3BLDoGlVuK5qa/5MyMTBNVbDo6qT+OcWSaX7yr13c+cxuEukMp00r4adXLOLEGne+u9ZLskKJnHBadBxmDV80yZYmP60uM9PLHJQ5zAURQQshxFu5LDpeuxlfJDniK9UfP3M6rx3o5qU9nexpDzG70pnjXoqB2M06gViSg91h5ls9qEM44TQMg9ZAjL0dYcKxFJUuq+ylKHAWXcXrMOG1mfBHk3hsJnyRJL5IkngeK7GPt8buCHc8tYOG7giqAlcunc7li6eiFtg5lgQWImeOXEFyWw26wnF6wj5qPFbqyuy4x6jCoxBCjJSiKFS6rbQFYhiGMaKLIDPKHSyfW8Fzuzp48OUD3PLe+WPQUzGQMoeFVn+MKreVKrd10LaxZJr9nSGaeqK9s+2isFl0lamlNlY9v5cH1hwgEE3htumsOKuezy6fSVN3dFIEF8/tbOfu5/YQS2YosZv473fM45Sp3nx3q18SWIic01SFSpeVeCpNk+9o/YspJbJ+VQhRWErsJmwmjego0jB+dOk0/r2nk/UNPrYc8nPKFE+OeykGYtJUzJrK/s4wXrsJi97/MaYzFGdfR4jucIJyp2XAdqKweB0mVj2/l5+t3tN7WyCa4s7VuwG4cuk02gITNytbIpXh3n/v4x/bWgE4daqHr7xjHiV2c557NjCZ/xNjxqJr1HpsWHWN3R1B1h+U/RdCiMJiN+uUOs2ERpgdCqDGY+MdJ1UB8Nu1ByQF9zgrcZjxRRK0+KLH3JdMZ9jXEWJzk49QLE2NxyZBRZHQVAWvzcQDaw70e//9a/bjtZsm7J6LZl+U//7DJv6xrRUF+PDpdXz7vfMLOqgACSzEOHBYdGrdNtIZgy1NfvZ3hvPdJSGE6FXpspLMGGRGERB8+PRpmHWVHa1BXjvQncPeieNRFQW31URDd5RQ/GiAGIgl2XbIz+62IHaTToXLUnDr0cXAdFXBH00SiPYf9AeiKbrDSeITMBvli3s6+dKjG9nXGcZjM3HLe0/myqXTiyKIksBCjAtFUfDazbitOu3B+IiKUgkhxFjw2Ew4LRqRxMhPUEodZi49tRaAB18+OKogRQyfy2oimkzR0B0mnTE45IuyscFHezBOlduGwyIrv4tNPJXBaTHhtvX/s3PbdNw2nc/9v/X87Jnd7O0IjXMPcy+ZzvC/L+zle0/tIJpMc1KNmzuvWMiiaSX57tqQSWAhxpXdrBNJpAhEpaCeEKIwWE0a5U4LofjoxqXLT5uKw6xxoCvCC7s6ctQ7MVSldgvNPTG2HvKz7ZAfVVGo8diK4iqv6CudMfjhP3fy4p6O3noxb/WJs2aw7kAPbcEYT7/Rxpce3cj//N9mXtjVUZQXL9sCMb76f5v56+YWAD5w2lRue98plDktee7Z8EgIL8aVpipkMhCIJovuj0UIMXGVOS00dEdIZ4wRn4g6rTrvP20qD758kIdeaeDs2eUTLpWppiroqkIqY5DOFNasjNWkEY6naA1EKXdYMesT67OfLNIZgx8/vYsXdnfQ4o/yf58/C1VRuH/N/mOyQjV2Rfj+B07lr5ubeWlvF9tbsrVJSuwm3nlyNRefXF0U5xqv7O/iJ//aRTiexmnRWXnRXE6fUZrvbo2IBBZi3NnMGm3BONPLHEPKOy6EEGPNazfhtOiE4ik8tpGnx37vglr+sqmZ1kD2Kuolp9TksJf5Uyy1BIrhJFIMLBtU7OSF3Z1oqsLli+to8cW4cuk0rj1/Fv5oCo9NxxdJ0tQdJZE2OLHGzYk1bj4ZTvCPba38fWsLPZEkv3utkd+va+LsWWW8+9RaTqx2FVxdrVQ6w29fPsjjGw4BMK/Kxf9cPI/K46ROLmQSWIhx57To9EQTBEd5ABdCiFwxaSqVbgt728OjGpesJo0PLanj3n/v49HXGnn7CZVFn2ZbagmI8XB0+VMnuqrw1XeewJkzy4inMrQF4nSGEuiqQkcw3u9sWanDzEfOmMbli6fy8r4u/rK5he0tAV7Y3ckLuzuZWe7g3afW8LY5FQXxN9kZivP9p3awvTUIZC9KfOKsGUU/yymBhRh3Jk0lmcoQOHzVSwghCkGpw8IBNUIqnUEfxcH9nfOr+dPGQ7QH4/x1cwuXL56aw16Ov8leS0CMvVQ6ww+f3sVLh4OKG951AmfUl/Vpkx7i8juTpnLunArOnVPB3o4QT25p4fmdHezrDPPzZ/bwwEsHuOikKt51Sg3VeZoZWHewhx89vZNgLIXDrHHdBXNYNqs8L33JteIOi0TRsuoanaG45HsXQhQMj82E06oTjI+8pgVkT2w+esY0AP5vfVOfFKjFZrLXEhBjL5XO8IN/7nxTUHHiMUHFSM2qcPJfb5/DAytOZ8VZM6h0WQjGU/xxwyE+89vX+c5f32B9Q8+4ZXFLZwwefPkg3/rLNoKxFLMqHPzkioUTJqgAmbEQeeKw6PijSSKJtKQBFEIUBE1VqHZb2NEaosQ+uuc6b14l/7fhEI3dEf64vomrBshsU+h0VaE7PHgtAX80ha4qBbeZWxS+ZDrDD/6xk7X7utBVhW9cciJLxmDTsstq4v2nTeU/Fk5h3cEe/rq5mQ2NPl490M2rB7qZ4rVxySk1XHhiJXbz2JyTdIcT/PCfO9lyyA/AJafU8Mmz6ydckoGJ9W5E0bCaNGLJNIGYpJ0VQhSOEocFk66QGOWeAU1V+PjS7KzFE5ua6QknctG9cdUTSXDn6t299QL647bpeGw6KQkqxDAl0xm+/48drN3XhUlTuPHdJ41JUPFmmqpwRn0p3/6P+dxz5WlcemoNNpPGIV+U+/69j0/c/xr3PL+Xhu5ITl93U5OP6x7dwJZDfmwmjf9+xzw+v3zWhAsqoAACi7vvvpsZM2ZgtVpZunQpr7766qDtfT4f1157LTU1NVgsFubOncvf/va3ceqtyCWTqtIdKr6DrRBi4nJZdDxWE8EcXPQ4c2YZc6ucxFMZfv96Yw56Nz4yhsE/trVyzUPreXJLCy/t6eQTA8y4rDirHl8kKbMVYliS6Qzfe2oHL+/rzgYVl5zE4unjWwRuaomdz7xtFg+sOJ3PLZ9FXYmNaDLN37a0cO3D6/nGn7awdm/nqH630xmD373awDf/tBVfJMmMMjs//tAC3ja3IofvpLDkdQ3Ko48+ysqVK1m1ahVLly7lpz/9KRdffDE7d+6ksrLymPaJRIKLLrqIyspK/vCHPzBlyhQOHjyI1+sd/86LUXNYdLojCWLJdEFkaBBCCFVVqPZY2RYKjPq5FEXhqjNncOOft/LUtlb+Y9GUvG0WHarG7gh3P7eHbc3Z9z+zwgEGfO68WShvqSVw9bIZfPptM2nuiea516KYJNMZ7vj7Dl490I1ZU/nGu0/ktDxWlrabdd59Sg2XzK9m8yE/T25u4ZX9XWxu8rO5yU+Fy8K75lfzjpOqB0w40199F18kwY+e3sXGRh8AF51UxWfOnTnhz3cUI4+7Z5cuXcrpp5/OXXfdBUAmk6Guro4vfvGLfO1rXzum/apVq/jBD37Ajh07MJlGlk0oEAjg8Xjw+/243e5hPz6TMXhlXzcGBi6rZDQajYxh0BaIsWhaCRUuyT0uxEQ12nF3rJ/vrULxFK/v78Zh0XNyEnDjn7awqcnP2+dVcv1Fc3PQw9xLpDI8tq6RP6xrIpUxsOgqH1s6nUsX1KKpSraOhd2E127CH03htOi8sLuDR19r5LoL5qAWWH0AUZiS6Qy3/W07rx/swaypfPM9J7Gwzpvvbh2jPRjjqa2t/GNbK4FYdn+RSVM4d04F7zmlhjlVLmDg+i6vH+jmxj9vozucwKKrXHPeLN5+QlXe3k86Y9AZinN6femIsnEOZ8wd1YxFIpFg//79zJo1C10f3lMlEgnWrVvHDTfc0HubqqpceOGFrF27tt/HPPHEEyxbtoxrr72WP//5z1RUVPDRj36Ur371q2ha/4N/PB4nHj+aBi8QGP1VKJEbqqKgKNmoXgILIcRAxnscd5g1ShxmukKJnAQWVy2bwZcf28SzO9t5/2lTmF7myEEvc2dLk4+7n9vLIV925mHJ9BI+t3wWVW+aXXlrLYE97UGuf3QjkUSa+bVuLjqpOl/dF0Uikcpw+98PBxW6yk3vPokFBRhUAFS6rFy1bAYfPn0a/97dwV83t7CnI8QzO9p5Zkc786pcfPzMabx/8dRj6rt84qwZXL1sBiV2Mw6zxlffeULB/c2PpRHtsYhEInzyk5/Ebrdz8skn09DQAMAXv/hF7rjjjiE9R2dnJ+l0mqqqvhFcVVUVra2t/T5m3759/OEPfyCdTvO3v/2Nb37zm/zoRz/iu9/97oCvc/vtt+PxeHq/6urqhvguxXiwmXQ6gnFSaSmuJITo33iP44qiUOm2kMykc5ISe26Vi2UzyzCA//fKwdF3MEcC0SR3rt7F1/+0lUO+KCV2E/9z8Txues9JfYKKN0tnDOKpDE6LiQ+fnv05/GbtwaJOqSvGXiKV4da/HQ0qbn5P4QYVb2bWVS44sYoff2gBP7x8AefNq0BXFXa2BanyWLnnuWx9lyNZ0wLRFD9bvYcH1hzgjvefwo8+uHBSBRUwwsDihhtuYNOmTTz33HNYrUcHnwsvvJBHH300Z517q0wmQ2VlJffeey+LFy/miiuu4Bvf+AarVq0atK9+v7/3q7GxeDbQTQYOs0YkkSYYk4OSEKJ/+RjHvTYzNpNOJJHOyfN97MzpqAq8vK+bnYcr7eaLYRg8u7Odax5ez7+2twPwzpOr+cWVizl3TgXKEJc1vefUWqZ4bfijSR55tWEsuyyKWDyV5rtPZutFWHSVb73nJE6d6s13t4ZFURTmVbv48kXz+PUnTucz59Zz9uxyfrP2QL/tf7P2AAvqPDitky+d/ogCiz/96U/cddddnHPOOX0GoJNPPpm9e/cO6TnKy8vRNI22trY+t7e1tVFd3f+Uak1NDXPnzu2z7OnEE0+ktbWVRKL/7EIWiwW3293nSxQOXVNJZTL4o5IdSgjRv3yM4zazRrnTPOpieUdMK7Vz3rxsUpLfvnwgJ885Ei3+KDc9sY0fP70LfzRJXamd733gVK49fzbOYdYUMmkqnz53JgB/3dJCY45TdIrilw0qtrOh0YfVpPKtS0/mlCILKt6qxG7m8sV1hOKpIdV3mWxGFFh0dHT0m7UpHA4P+UqH2Wxm8eLFrF69uve2TCbD6tWrWbZsWb+POfvss9mzZw+ZzNFlM7t27aKmpgaz2TzMdyEKhd2k0xFKkJF0hUKIAlLutJDJZHJWlfejZ0xDVxU2N/l7M8WMl1Q6uzn7Cw9vYGOjD5Om8LEzp3PnFQs5qWbkgdri6SUsrS8lnTG479/7crJ0TEwMsWQ2qNj4pqBi/hRPvruVE6mMgddmkvou/RhRYLFkyRKefPLJ3u+PBBO//OUvBwwK+rNy5Uruu+8+fvOb37B9+3Y+//nPEw6HWbFiBQBXXXVVn83dn//85+nu7ua6665j165dPPnkk9x2221ce+21I3kbokA4LDrBWJJQQpZDCSEKh8duwmE1Ec7RrEWV28o752dn5H+79sC4nYTvaA1w/e838tu1B0mkM5w61cNdHzmNK5bUYdJGX87qk+fUo6sKGxp9vLK/Owc9FsUulkzznSffYGOjD5tJ41uXnszJtRMjqIDsXiNfNMmKs+r7vX8y13cZ0eKv2267jXe961288cYbpFIp7rzzTt544w3WrFnD888/P+TnueKKK+jo6OCmm26itbWVhQsX8tRTT/Vu6G5oaEBVjw56dXV1/OMf/+D666/n1FNPZcqUKVx33XV89atfHcnbEAXCrKskUwaBaBK3pPAVQhQIi65R6bRwoCucs/TiH1pSx7+2t7G7PcTafV2cNas8J8/bn3A8xW9fPsjft7RgAC6rzqfOqef8eZVDXl0wFDUeG+9bNIXH1jXxyxf3cdq0kglZUVgMTSyZ5jt/fYPNh6tMf+u9J49qVqxQ+cJJPrs8uxTwzfVdVpxVz2eXz6Spe3LWdxlxHYu9e/dyxx13sGnTJkKhEKeddhpf/epXOeWUU3Ldx5zKRR2LLU1+4qk0NvPk25QzVjpDcUod5qLIEiGEGJ5iq2PxZp2hOBsaeqhwWtFytF76wZcP8vvXG6krsfHzj5yWs+c9wjAM1uzt4t4X9tEdye5fu+CESlacXT+iHPZDEU2k+dxD6+gOJ/jYmdO5YolkYJyMYsk0t/xlG1ubA9hMGre892ROnIBBxRFvre/isen4Ikl8kSTxVOFkuyyKOhazZs3ivvvuG+nDi1I0kUJTVWq8Vjx2E/4C/OUpVnazhi+SIJJIYZeATQhRILw2Ey6LiVA8lbOT8vctmsLftrTQ2BPl2Z3tXHhi7gpntQdjrHp+L68d6AGg1mPl2vNnj3kWHptZY8VZM/jR07t47PVGLjihknKn1CeaTKKJNLf8dRvbmgPYzdmg4oTqiRtUwLH1XTqC8Um5/OnNRnQGd6RuxUCmTZs2os4Usngyzarn9w043SXBxejYTBo9kSTBmAQWQojCoWsqlW4Lu9uDOQssnBadyxdP5YE1B3j41QaWz60Y9V6HdMbgL5ubeeiVg8SSGXRV4QOLp/KhxXXjtixp+dwK/ra1le0tAe5/6QD/ffG8cXldkX+RRIpb/vIGb7Rkg4pvv3c+86pd+e7WuElnjEkfUBwxojO4GTNmDLo+M53OTd7vQhFNpFj1/D7uXL2797ZANNX7/ZVLp9EWiA/0cDEEiqKgqQpd4fiAhZmEECIfSh1mNEUlmc7kZLMzwLtPqeGJjc10BOP8fWsr711QO+Ln2tMe4q5nd7O3IwzASTVurj1/NtNK7Tnp61ApisJnzp3Jyt9v5IXdHVxySvWE2rAr+hdJpPjWX95ge0sAh1nj2/8xn7lVkyeoEH2NaITcsGED69ev7/165ZVXWLVqFXPnzuWxxx7LdR/zTlNV7l+zv9/77l+zH6/dlPM1spOR06zTHU4ST02swFQIUdzcVhMeu4lQDgt5Wk0aHz4juw/h9683Eh1BIb5oIs0v/72PLz+2kb0dYRwWjS+cP5vb33/KuAcVR8yudPKOk7OZr/73hX1yFXeCiyRSfOuJbdmgwqLxHQkqJr0RzVgsWLDgmNuWLFlCbW0tP/jBD3j/+98/6o4VkmAsOWgRlO5wElUBOR0eHZtZoz0YIxhLYXFqx3+AEEKMA1VVqHZb2dbsp4Tc1Uy66MQqHt9wiBZ/jCc2HeKK04e+jPjV/d2semEvHcHsbPnb5pTzqXNmUuLIf02nj585nRd3d7C/M8w/32jlXfNr8t0lMQbC8RQ3P7GNnW1BnBad7/zHfGZXOvPdLZFnOV14OW/ePF577bVcPmVBcFkHL4Litulc/+hGntnRJldnRkFTFQzAF5Eq3EKIwuKxm7Doak5nVHVN5aNnZIOJP244RCCaPO5jusMJ7vj7dr7z5Bt0BONUuizcfOlJ/PfFJxREUAHgsZn46NLpQDYDVjB2/PcliosEFWIgIwosAoFAny+/38+OHTu48cYbmTNnTq77mHfpTGbAIiifOGsGa/d2sb01yE/+tZvPP7ROAoxRcJh1OkMJ+fyEEAXFZdHx2s0Ec7gcCuBtcyuYUWYnkkjzf+ubBmyXMQz+tqWFzz+0jpf2dqEq8P5FU7j7o6exZHppTvuUC5fMr2ZaqZ1gLMXDrwye8EUUl1A8xU1PbGVnWxCXRee7l0lQIY4aUWDh9XopKSnp/SotLeWkk05i7dq13HPPPbnuY97ZzDrXnDeL6y6Y0ztz4bbpXHfBHD63fBYVTgufOGsGbqtOiz/GT/61m2seWsczO9rlBHmY7GaNUCwlV7iEEAVFURQq3VYS6dxmAFQVhY+fOQOAv25uIRBNYNHVPvv2DnaF+er/beae5/cSSaSZU+nkJx9ayIqz67GaCnPZqK6pfObcbPGwv21t4UBnOM89ErkQiqX45p+3sqsthMuqc+v75jOrQoIKcdSICuS9tbq2qqpUVFQwe/ZsdL2wU4WOprBSJJFCV1X80SRum35MHYtoIs2TW1r444am3qtatR4rV5w+jeVzK2SD9xAd8kU5udZNXZ42HwohcquYC+S9WTie4vUD3VhNWk7TYhuGwV3P7OaDp9dxzpwKQrEkHpuJ7nCCB9ceZNXhTdA2k8bHz5zOJafUFM3x5La/bWftvi5OneLhu5fNz2nFbzG+jgQVezpCuK06373sFOrLHfnulhiC8SyQN+LK28VqPCpv9xdgTPHauOL0Ot42RwKM4+kOJ3BYNBZPL5GDkBATwEQJLAA2N/noCMSpzGFabIuuUuu18b8v7OU3aw/01kq6etkMPnHWDD70vy9T4TLz2bfNKrqic22BGNc8tJ5EOsPX3nkCZ88uz3eXxAgEY0m++eet7O0I47bq3HrZKcyQoKJoFGTl7SeeeGLIHXjve9875LbFKJJIYzBwPGYza1y+eCqXnFLNk1taeHzDIQ75ovz46V08+lqjBBjHYTdrBGNJQvEULmtuClIJIUQuVLqsNPtiGIaRswsfXoeJe/+9l58/s6f3tkA01fv9qo+dRixZnEVYq9xW3n/aFB55rZFfvbSfxdNLCnb5luhfMJbkxj9vZV9HGI/NxK2XzWd6mQQVon9DDiwuu+yyIbVTFGXCFcgbKbtZ54OL63j3KTXZAGN93wDjw6fXca4EGMewmjS6IwmCMQkshBCFxWs34bBohBNpnJbRL4fSVAWvzcQDaw70e/9v1h7gi2+fzZ72cNHu2fvAaVP51/Z2OoJxHt9wiI+cMfS0uiK/AtHsTMW+zjBem4nvSlAhjmPIm7czmcyQviSoONaRAOOXVy/hqjOn47LoHPJF+dHTu7j24fU8t1M2eb+Vriq9+dmFEKJQWE0a5U4z4XhuskPpqoI/OnitJH80hV7EF6CsJo3/PHsGAH9Y10R7IJbfDokh8UcPz1R0hvHaTdz6vlMkqBDHldM6FmJwdrPOB5dkA4yPS4AxKKdFxx9NEktKoCqEKCzlTitpw8jJeJ3KGHhsg9dK8th0UkV+bDhndjnza90k0hl+/dL+fHdH9ENTld6MZP5okhv/tIX9h4OK2y7LXzV3UVxGPI8bDod5/vnnaWhoIJHoW9Dsv/7rv0bdsYnMbtb50JI63nNqDX/dfHQPxo+e3sWjrzfy4dOncc7s8km9RMpm0vBFkwSiSVmPK4QoKB6bCadFJxxP4R7BRsg3S2cMfNEkK86q587Vu4+5f8VZ9fgiyaK/6KQoCp952yy+9OgGXtrbxeYmH6dO9ea7W4Js8gCvw4TXZjqc9dJE5744mqpScnimoq5EggoxNCMKLDZs2MAll1xCJBIhHA5TWlpKZ2cndrudyspKCSyG6M0Bxl82t/CnDYdo6onyw3/u5JHXGiZ1gKEoCpqi0B1O5DT7ihBCjJZZV6lyW7IZckYZWAD4wkk+uzxb8+H+Nft7s0KtOKuezy6fSVN3dNSvUQjqyx28c34Nf9vSwr0v7OPODy+alMe3QmLRVaaW2lj1/F4eWNM3I9ljn1vG1kN+SuyFUdFdFIcRLYW6/vrrufTSS+np6cFms/Hyyy9z8OBBFi9ezA9/+MNc93HCs5t1rlhSx6+uXsLHzpyO06L3Bhhf/N16XtjVUfRXq0bCbtboCidI5rgglRBCjFapw4KmKKRyMD7FUxmauqNcuXQar3/jQl77xoW8/o0LuXLpNJq6o721kiaCK8+Yhsuic7A7wt+3tuS7O5Oe12Fi1fN7+dnqPb37fI5kJHtgzX5OqHbluYei2IwosNi4cSNf/vKXUVUVTdOIx+PU1dXx/e9/n69//eu57uOkcSTA+OVVS/jY0mk4LBqNPVF+MEkDDLtZJ5JIEYhKFW4hRGHx2Ew4rTqhHG3ijqcytAXi7GkP0xNOsKc9TFsgPqGCCgC3zcTHzpwOwP975SB+Gd/zRlMVPINkJHtgzQG8dpPMKolhGVFgYTKZUNXsQysrK2loaADA4/HQ2NiYu95NUg6LzhWnT+NXV51+bIDxyAb+vXtyBBiaqpDJIIGFEKLgaKpCtdtCOJHbBBPpjEE8lZnQY/zFJ1dTX+4gHE/z0CsH892dSSWSSPHq/i7ufWEv33tqB+2B+ITOSCbG34j2WCxatIjXXnuNOXPmsHz5cm666SY6Ozt58MEHmT9/fq77OGkdCTDec2otf9nczJ82HqKxO8L3/7GTutJGPnJ6HWfPLkd9U5EmTVXQVYVUJjcZS/LNZtZoC8aZXuZAlcFNCFFASuwWTHqYRCqDWZcki0OlqQqfOXcmNzy+hae2tnLxydXMqnDmu1sTUjKdYVdbkI2NPjY1+tjZFuTIqUGpw0yZ04zbpvcbXBzJSCap38VwjCiwuO222wgGgwDceuutXHXVVXz+859nzpw5/PrXv85pB0U2wPjw6dO49NRantjUzJ/fFGBMO1xo7+0nVFLqNPdmdfDYTPgiSXyRZFFPpTstOj3RBMF4akRl6IUQYqy4rDoeq4lgLEmZ05Lv7hSV+VM8nDunnH/v7uTeF/Zxx/tPyVkl88nMMAwOdEXY1OhjU5OPrc3+Y6q213isLKzzsmCqF39k4mckE+NrRIHFkiVLev+/srKSp556KmcdEgNzWHQ+csY0Ll1Qy18OBxgN3RH+b322kun9a/b3yerw5owixRpcmDSVZCpD4HCwJIQQhUJVFarcVjpD/nx3pSitOKueV/Z380ZLgBd2d7J8bkW+u1SU2oMxNjX62NjoZ3OTD99blg97bCYWTPWysM7DgqnePpkWg7HUpMhIJsbPiAKL7373u1x55ZXU19fnuj9iCJxvCTAuOLGSX7+0n58/s6e3TSCa6r0CceXSabQFincq06prdIbiTC2xyRUtIURB8dpNWHWNWDItNXeGqcJl4UOLp/L/Xmng/pf2s7S+VD7DIQjFUmw+5Otd3tTs71vJ3KKrzJ/iYeFULwvqvEwvs/dZMv1mb85Idu35s/BHU3hsOr5IsqgvSor8GVFg8dhjj3HzzTezdOlSPvaxj/GhD32I8vLyXPdNHIfTovOxM6czq9LB9b/f2G+b+9fs59rzZ9EZShTtdKbjcBXuSCKNwzLimo5CCJFzTotOicNMVyghJ8UjcNmiKfzzjTbag3EeW9fExw9njBJHJVIZtrcGDs9K+NjbEeLNh3NVgblVLhbUeVk41cu8ahcmbeh7fo5kJOsMJdBVhY5gvGjPF0T+jegsbdOmTWzbto2HHnqIH/7wh3zpS1/ioosu4sorr+Syyy7DbpcKjeNFVxUC0eSgWR26wgnC8SRWU3GelFtNGt3hOIFYUgILIURBURSFSreFFn8UwzBkVnWYLLrGp86p57a/7+CP65u48MRKajy2fHdrTAw1uUo6Y7C/M5ydkWjy8UZzgMRb6qXUldpZONXDgjov82s9OTk2pidI0heRXyP+TTz55JO57bbbuO2223jppZd4+OGH+dKXvsTnPvc5AoFALvsoBpHKGHhspuNkdTDxHw9vYH6th8sWTaG+3JGHno6Orqp0hxIT9oAjhCheXpsZm1kjmkxjN8vFj+E6c2YZC+u8bGz08asX93Pju0/Kd5dyyqKreB2mAZOrGIZBayDWu7Rpc5Of4Fvqo5Q6zL1LmxZM9UiyAFGwcjICOhwObDYbZrO5N1uUGB/pjIEvOnBWh0+cNYMNDT7ag3Ge2dnOMzvbWVTn5bJFU1hU5y2aq2sOi053JCHrmIUQBcdm1ih3WGjxxySwGAFFUfj0uTP54u/W88r+btY39HDatJJ8dysnLLrK1FIbq57fe0xylU+dW88P/rGTp7a20v6WlK42k8apUz2HN117ZY+hKBojHgH379/Pww8/zMMPP8zOnTtZvnw5t9xyC5dffnku+yeGwBdOHjerw48+uIDHNxxizd5ONjT62NDoY0aZnfctmsK5cyqGtR4zH2xmDb8/QSCWlMBCCFFwKlwWGnsiZAxjwI2yYmDTSu2853BK9fv+vY+ff3gReoEfl4bC6zCx6vm9/Gz1sclVMobBObPL+e3ag+iqwrxqFwsP75OYU+WSiteiKCmGYQx7Qd2ZZ57Ja6+9xqmnnsqVV17JRz7yEaZMmTIW/cu5QCCAx+PB7/fjdruH/fhMxuCVfd0YGLishZP+1KKreO0mvHZTn6wOb61j0RqI8ZdNzfzzjdbe3NalDjOXnlrLO+dX4yzgPQytgSgzyhzMqXLluytCiGEY7bg71s+XC/FUmtcO9KCh4LQW7jhayELxFJ998HUCsRSfPKeeyxYWx3nFQDRVYXalgyW3/mvApcqvfv1CHl9/iNmVTrloJsZMOmPQGYpzen3piFL3D2fMHdHlgAsuuIAtW7awYcMGvvzlL1NbWzuSp+l19913M2PGDKxWK0uXLuXVV18d0uMeeeQRFEXhsssuG9XrTwRHsjrsaQ/TE06wpz1MWyB+TKq4areVT587k/uvPoOrlk2n1G6mO5zgN2sP8J8PvMZ9/95HWyA2wKvkl82UrQCaSkv6OyFEYbHoGpVOC8F48viNRb+cFp2rls0A4HevNuCLJPLboVHSVYWeyODJVYKxFIunl0hQISaMEQUWt956K2vXrmX+/PlYrVasVivz58/nl7/85bCf69FHH2XlypXcfPPNrF+/ngULFnDxxRfT3t4+6OMOHDjAV77yFc4999yRvIUJK50xiKcyx83s4LTqfHBxHb+8eglfumAO00vtRJNpntjUzGcefJ3v/2MHu9sKa7+Mw6wRSaQJxvofpIUQIp9KnWYUBcmsMwoXnljFrAoHkUSa3758MN/dGbFkOsMjrzXgsuq4bf3PYGWTq+ik5PdFTCAjCixuuukmrrvuOi699FIee+wxHnvsMS699FKuv/56brrppmE9149//GM+/elPs2LFCk466SRWrVqF3W7n17/+9YCPSafTXHnlldxyyy3MnDlz0OePx+MEAoE+X+Iok6ZywYlV/Pwji7jl0pNZWOclY8C/d3ey8rFNfO2Pm3l1fxeZ4a+YyzldU0llMvijxX0VSwgxPMUyjntsJlwWE6G4XPwYKU1V+MzbZgHwrzfa2FVgF7iGYldbkC89upFfv3SAl/Z08onDszBvteKsenyRpASiYkIZUWBxzz33cN9993H77bfz3ve+l/e+973cfvvt3HvvvfziF78Y8vMkEgnWrVvHhRdeeLRDqsqFF17I2rVrB3zct7/9bSorK/nkJz953Ne4/fbb8Xg8vV91dXVD7t9koigKp00v4Tv/MZ+ffXgh58+rQFMVtjUH+M6T27nmofX8Y1sriTxX4bSbdDpCCTIyEAsxaRTLOG7SVCpcFsIJWQ41GifVuDlvXgUGcO8L+wriwtZQxFNpHlizn//+wyYauiN4bCa6Qgk+d94srrtgTu/Mhdumc90Fc/js8pn4IvK7IiaWEe0wSyaTLFmy5JjbFy9eTCo19Cs1nZ2dpNNpqqqq+txeVVXFjh07+n3Miy++yK9+9Ss2btw4pNe44YYbWLlyZe/3gUCgYA9KhaK+3MnKi+Zx1bIZ/HVzM3/f2sohX5S7nt3Dgy8f5N2n1HDJKTUj2gA0Wg6Ljj+WIJRI4S6gzfNCiLFTTON4qcOM1qmSTGcKPtteIfvEshm8vK+LnW1BntvZwdtPqMx3lwa1vSXAnat3c8gXBWD53Ao+fe5MPDYTTd1Rrlw6jWvPn9UnuUpTd/SYfZBCFLsRBRYf//jHueeee/jxj3/c5/Z7772XK6+8Micd608wGOTjH/849913H+Xl5UN6jMViwWKRQjIjUe608Imz6vnQkjr++UYbT2xqpiMY5+FXbEEv1wAAOoxJREFUG/jD+iYuOKGS/1gwhSkl41e0zqyrJFMGgWhSAgshJoliGsfdhwuWhmIpShzmfHenaJU5LXxoSR2/XXuQB9bs58yZpQVZIySWTPPgywf5y6ZmDKDUbuaa82extL6st82R5CqdoQS6qtARjMvyJzFhjfiv9Fe/+hX//Oc/OfPMMwF45ZVXaGho4KqrrupzZemtwceblZeXo2kabW1tfW5va2ujurr6mPZ79+7lwIEDXHrppb23ZTLZaF/XdXbu3MmsWbNG+pbEAOxmncsWTuHSU2t5aU8nj284xJ6OEH/f2spTW1tZOrOU9y2ayonVrnEp4GPWVbpCCaaW2Mf8tYQQYjg0VaHKbWV7S4ASJLAYjcsWTuHpN9po8cf4/euNfOKs+nx3qY8tTT5+/uweWvzZTIoXnljJJ8+eOWC64XTGkIBCTHgjCiy2bt3KaaedBmRP9iEbJJSXl7N169bedsc7yTSbzSxevJjVq1f3pozNZDKsXr2aL3zhC8e0P+GEE9iyZUuf22688UaCwSB33nlnwU6NTxSaqvC2uRWcO6ecrc0BHt/QxGsHenh5Xzcv7+tmXpWL9y2awpkzywYs7KOpCrqqkBrFAOsw6/giCSKJVEFewRJCTG4lDjNmXSWeSmPRJY3oSJk0lU+dM5PvPPkGf97YzEUnVo/rDPlAIokUv1l7kL9taQGys/tfOH82i6dPjGrhQozGiM7Knn322Zx1YOXKlVx99dUsWbKEM844g5/+9KeEw2FWrFgBwFVXXcWUKVO4/fbbe9PavpnX6wU45nYxdhRF4ZQpHk6Z4qGxO8KfNh7i2Z3t7GwLcsdTO6h2W3nvglouPLEKmzl7ULXoKl6HCa/NhD+axGMz9VvAbyisJpWeaIZgTAILIUThcVl0vHYTgUgKi1MCi9E4fUYJi6eXsO5gD798cR83X3pyXvuzvqGHu57dQ0cwDsA7T65mxdkz5Fg0DrrDCSLJFDZdw2s3S2XyIUqmM/SEE+iawjgsKhn5UqhcueKKK+jo6OCmm26itbWVhQsX8tRTT/Vu6G5oaEBVZQNcoaortfPFt8/hY2dO58ktLfxtcwutgRj3/nsfD7/awLvmV/OhJXXMqnSw6vm9PLDmAIFoCrdNZ8VZ9Xx2+cxhb2BTFAVNUegKx6lyW8fw3QkhxPApikKV20Z7wJ/vrhQ9RVH41Dn1bGz08frBHl470M3pM0rHvR+heIpfv7Sfp9/ILt2uclv44tvnsGCqd9z7MhnFkmmS6Qxzq1x0hxO0BWPoioLXnp0dFMeKJtL4YwkUFMqdZmq9NpzjEAArhlEkedxyZDhlyfuTyRi8sq8bAwOXbB4+RiyZ5pkd7fxp46Hedaf3XbWYLU1+fvbMnmPaX3fBHK5cOo22QHxYrxOKpUhjcPqMEllqIESBG+24O9bPNxbC8RSvH+jGZtJ7Z27FyP36pf08vuEQtR4rd330tHHNuPXagW7ufnYPXeFsDaX3nFrDVWfOkJ/rOMkYBi3+KPXlTuZWOUlnDLojCVp8MTqCcQwMPFaz/DwAwzAIx7MBhVXXqHRbqPbY8NpMqKOY4RnOmJv3GQsxsVhNGpecUsPFJ1fz6v4untnRztmzy/nyY5v6bX//mv1ce/4sOkOJYe25sJk12oMxgjFZaiCEKDwOi06Jw0xHMC4nPDnw4dPreHZnO83+GH/Z1Mz7T5s65q8ZjCW599/7eG5nBwC1Hiv/dcEcTq71jPlri6O6wwm8djPTy+woioKuKVS6rFQ4LfREkrT6o7QH4nRH4nisZhwWbVwSyRSSjJHNlhlOpHBYdGZXOql0W/OSPVMCCzEmNFVh2axyzptXSTCWIhDtv75JIJrCH02hq8qwAgtNVTAAXyRBubM40lAKISaXSpeVFn8MwzAm3YlOrtnNOlcvm8Gdq3fzyGuNnDevktIxTOe7Zm8n9zy/F18kiarAfyycwkfPmIbVJEHieIom0qQzBjMrHMd89oqiUOowU+owM7U0SXsgRos/RrM/icOs4bKaJvw+jFQ6gz+aJJZK47GZOKnGTYXLmteLGRJYiDGVyhiU2LN53fsLLtw2HY9N790INxwOs05nKEF9uTHhBw8hRPHx2k3YzRrhRBqnRQ63o/X2Eyr5+9YWdrWF+M2aA1x/0dycv4Y/mmTV83t5cU8nAHUlNq67YC7zql05fy0xuIxh0B2JM7PcScVxLiC6rSbcVhNTvHY6gjGafTFaAzGsuorHZkKfYMUq46k0/kiStGFQ4jAz1+ui3GkpiP0m+e+BmNDSGQNfNMmKAfKPrzirHl8kOaLUs3azRiiWIhhLjrabQgiRc1aTRpnTTDje/4ytGB5VUfjs27K1qp7Z2c6O1kDOntswDF7Y1cE1D63jxT2dqAp8cPFU7vzwIgkq8qQrlKDUYWba4SVQQ2Eza0wrc3Da9BIW1HlwWnU6w3HaAjHiqfQY93jsRRIpWvxRfNEk5S4LC6d5OW1aCbVeW0EEFSAzFmIc+MJJPrt8JpDdU3EkK9Qnls3ozQo1EiZNJZUxCERTeO1SiEoIUXjKnRaauqOkMzKzmgtzq1xceGIl/9rezv++sI8ffXAB6iiXmXWHE9zz/B5e3tcNwIwyO9ddMJfZlc5cdFmMQCSRIoPBzArniJafmXWVGo+NSpeV7nCCFn+UjlCcVDqB12YqqvTAhmEQiqcIxFJYTSp1pTaq3Ta8dlNBLrEsnk9WFK14KkNTd5Qrl07j2vNn0RNJ4rLq/Ht3J6/s7abcNfI9EjZTdhN3XamtIP/AhBCTm9dmxmHRCcdTuG2SSTAXrjpzBi/t6WJPe4jV29u46KTqET2PYRg8u7Od+/69n1A8u9fvQ0vquHzx1HHNOiX6yhgGPZEEsyuco95DqakKFS4L5U4z/miSVn+MtkCMnnACl9WEy6oX7LlDOmMQiCWJJNI4LRpzKp1Uui0Fn5FUAgsxLuKpDG2BOJ2hBLqqcNOft/KPbW2cMsXDrZfNH/Eftt2sEYwlCcVTBf/HJoSYfMy6SqXLwr7OsAQWOVLiMPORM+r49UsH+M3agyybVT7sPSydoTh3P7uH1w/2ADC7wsl1F8xhRrljLLoshqEzFKfMaaGuzJ6z51QO17zw2s1MLbXTHojR7I/R7I9iN+m4bYWz0Tt5eEN2Ip3BYzNRX+6gwmUpmsQBEpKLcZXOGMRTGT64uA6zprLlkL93k9xIWE0aibRBMCZrmIUQhanMaUFFIZUeeiFQMbj3nFrLFK8NfzTJI682DPlxhmHwj22tXPvwel4/2IOuKly1bDo//OACCSoKQCSRQlFgZrljzGpUOS06MyucLJlewvwpHswmldZAlI5gnGQe/0ZjyTStgRhd4QRum86CqV4WTy+hrtReNEEFSGAh8qTKbeXyxdk85L9+aT+x5Mg3VemqMqKsUkIIMR7cVh2XTSckm7hzxqSpfPrc7N69v25pobE7ctzHtAVifPPPW7nr2T1EEmnmVbn42YcX8cHFdQVztXoyS2cMeiJJppXaKRuHNPJWk8bUEjuLp5ewsK4Ej12nK5ygLRAb1TnJcIXjKZp9UYLxJFVuC4umeVlYV0K1x1qUS/KKr8diwnj/aVOodFnoDCX4w7qmET+P06Jn8ziP40AghBBDpWsq1W4LkYSMUbm0eHoJZ8woJZ0xuO/f+zCM/rMLZgyDJzc384XfrWdTkx+zpvLJs+v53gdOpa40d8ttxOh0heKUO81MKx3fmSOTplLtsbKoroRF07xUe6wE40mafdExy+hmGAb+aJJDvgjxdJoZ5XYWTyvllCkeyp2Wog50JbAQeWPRNT55TjYN7R83NNHqj43oeWwmjWgyTSAqaWeFEIWpxG5B05S8LrWYiD55Tj26qrCh0ccr+7vRVAWLrvaemDX7onz98S2semEfsWSGk2vd/Pwji7hs0ZSiPnmbaMLxFKoKMyuceUubqqoK5U4LJ9e6WTytlPpyB/F0mkO+CP5okswAgetwpDMG3eEEzf4oKHBCtYsl00uZV+3GU6BZnoZLAguRV8tmlrFgqodk2uCXL+4b0XMoioKmKHSHEznunRBC5IbLquO1mWQ/WI7Vem28b9EUZlU4mVvlZFalgxKHidmVDhQFfrp6F9uaA1hNKp9720xue98p1Hpt+e62eJNsvasE00odY1pNfagURcFjNzH38En/CdUuFAVa/FG6w4kR1d1KpjN0BOO0BaJYTCrzp3hYMr2EGeVOHBOseObEejei6CiKwmfeNov/emQDr+zvZv3BHk6bXjLs57GbNbrCCRKpTMEUiRFCiCNUVaHKbWVbix/I/8nTRPLxM6dzwyUncv9L+/niIxt6ayVdvWwG/++TS7n5iW1ctnAKVW5rvrsq+tEVjlPhshTksjSHRcdhcVLz/9u78+go63t/4O9nmWfWzEwmIRtkAxTZV6HBtmCLUsV762m99dpepdQq16XqobVgD4IeTy9q3XqUK1Ur2FutaL0uVYtHEeoC/rQCCl5F2ddsJJl9fZ7v74+BQGRmkpBlJpn365wcT575PJNPHsbP5DPf5XFb0RyI4XBrCI3+CBRZQqFN63QNRCSuw3t8NkWRQ0OF24kiuzbo7gR+KjYWlHVVHhsuGV+Olz85gsfe3YOHh03u9oIlm6aiKRCBPxLvl0VfRETd5baZYFEUROL6gNrlJdeVuS1Ys2kvHn57V/sxXziBh9/eBUkCll0yBg0+bvCRiwLRBBRJwvDi7E2B6gqzqmCo24rSAnNyKlNbGM2BGAQEXBYNVu3k/89CCARjOnyRGLTj6zfKXRYU2jTIeTD9Lnf/FSmvXDG9Cm6rCYfbwvjbJ0e6fb4iSzAMcJ0FEeUsh1lFoV3jdKhepMgS3FYT1mzal/LxNZv2wW3LnXsU0Em6IeALx1BdZENhDkyB6gpVkVHitGDCMDemVBdiqNuKUCyBw20hBCIJeMNxHPGGEdcNDC92YEq1B+OGupJbTufJa5CNBeUEuzk5bA0Az3508IzWS9g0BQ3+6BnNfyQi6muSlLwLcFzX0+5gRN2jyhK84Th84dTNmi+cgDecvKs25ZbmQBRDCiwYloNToDojyxI8dg1jKlyYUlOIkSUOJIQBWQJGlzsxraYQZ5UWwJWHN8VkY0E54zujS3B2qQPhuI6n0nz6lIndrCIYSyDATwOJKEe5bSZYtOROdtRzCUPAZTXBaU09s9tpVeGyqkjwA6ecEogkoCoShg+xD8h7NZzKaTFhZEkBzq3xYFqNB9VFdti0/F1pMLD/NWlQkSUJC789AgDw9s5GfH7U163zTYqMeMKAL8LpUESUm2yaiiK7mdOheklyR6E4FsysTfn4gpm1aAvFOZKdQ3RDwBuJoabIBrdtYEyB6gqLScnpdSL9hVeAcsrZpQW4YHQpAOCxd/Z0+83AoipoCkQ4zYCIctaQAjN0IXplX3wC2oJxLJw1HDd/96z2kQunVcXN3z0LC2cNR1uIHzblkqZABGVOC4YVDrwpUNS5/B2roZx1ZV013t/djF1NAbz1eQPmji3r8rl2swpfOIFQTB90e0MT0eDgtplg1xSEojocFtapnoomDBxqCeMnM6pww/kj4A0n4LKqaAvFcagljGiCNyXMFf5IHJoio7bYMai3XM1n/FelnFNo0/Dj6VUAgD9t3tetNRMWk4JoXOd0KCLKWWZVwZACMwIx1qneEk0YaPBFsasxiNZgDLsag2jwRdlU5JCEnpyqXFNsh8uWf4ua8wUbC8pJ88aXo9Jjgy+SwNMf7u/Wuaos41iAd+EmotxV5DBDCHDufy/TDYFowuB1zUFNgSjKXVYM5Z3PBzU2FpSTVEXGwm8NBwC8vv0o9jUHu3yu3ayiNRRDhLuuEFGOcllNcJhVBKJcxE2Dny8ch9kko6bYzilQgxz/dSlnTax0Y+aIIhgCeOzdPV1ekG3VFISiCU6HIqKcZVJklDotCLKxoEEurhvwRxMYXmzPy/s65Bs2FpTTfnZeLTRFxvbDXry3q7lL58iSBFmW4OVOIESUwzx2DYosIa4PnHUAuiE4GkzdkpwCZUGFm7tA5QM2FpTTSp0WXDZ1GADgyff3dfkNzWpS0eSPIjGA3rCJKL84j9/YLdenQxlCwB+J46g3jKZABP5oHM2BaLbTogHAG47DalJQO8QOhXc/zwtsLCjn/WDKUJQUmNEciOKvHx/q0jkOs4pQTOdNqIgoZymyhFKnBaFY7tUpIQSC0QTqfRHUe8MwANQU2TG5qhDjh7qhqTIafBHei4PSiusGgrEEhg+xw2nhFKh8wcaCcp5ZVXD1N5N3Vf3frYdQ7410eo4iS9CFAW+Yu0MRUe5y2zRoqoxoIjemF4VjOhr9ERz1hRHTDQx1WzC5qhDn1hTi7LICFDvMGFJgxrihLrhsJhz1hrkDE6XU5E9OgSp3cReofJITjcXKlStRU1MDi8WCGTNm4MMPP0wb+/jjj+Nb3/oWCgsLUVhYiDlz5mSMp8GhbngRJlW6EdcFnnhvT5fOsaoqmgIxGHzTI6Ic5bSocFlN3bpfT2+LJQwcC0RxuC2MUDyBYocZE4a5cW6NB2MqXChxWmBWlQ7nuKwmjK1wosxpQb0vPKDWiVDf84bjsJkV1BZzClS+yXpjsXbtWixatAjLly/Hli1bMHHiRMydOxeNjY0p4zdu3IgrrrgCGzZswObNm1FZWYkLL7wQhw8f7ufMqT9JkoRrvjUciizh/+1twZb9rZ2eYzer8EfiCOTgNAMiIiBZ20qdFkT6+UZucd1AayiGw60heCMxFFhVjBvqxLQaDyYMc6HcZYVVUzI+h01TMbrCiSqPDY3+CBd1E4DjU6CicQwf4kABp0Dlnaw3Fg888ACuueYaLFiwAGPGjMGqVatgs9nw5JNPpox/+umncf3112PSpEk455xz8MQTT8AwDKxfv76fM6f+VuWx4ZLx5QCS28929gmZpsqIJQz4wtwdiohyV6FNg8UkIxzr2z/MdUPAG47jSFsYLcEYLCYZoyucmFrtwZSqQgwrtMFhViFJXf+E2awqOLu0ACOGONAaiuX8QnTqe02BCCrcNpQ7LdlOhbIgq41FLBbDxx9/jDlz5rQfk2UZc+bMwebNm7v0HKFQCPF4HB6PJ+Xj0WgUPp+vwxcNXFdMr4LbasLhtjD+9smRTuPNqsK7cBMNcIO9jtvNKgptGvzR3v8QxBACgUgC9b4wGv0RyBIwssSBqdWFmFrtQXVR8t4C3Wkmvk5VZIwY4sCosgIEYwm0hVhz81VbKAa7pqJ2iB0yp0Dlpaw2Fs3NzdB1HaWlpR2Ol5aWor6+vkvPsXjxYlRUVHRoTk61YsUKuFyu9q/Kysoe503ZYzermF9XAwB49qODaAlmfgOzayraQrGc3HWFiLomH+p4qdOChGF0+UagmQghEIol0OCLoN4XgS4MVHlsmFJdiHNrPRhR4kDh8Xto9BZZllBdZMe4ChcMIdDkj/bK70IDRyxhIBzXMXyIAw6zmu10KEuyPhWqJ+6++248++yzePHFF2GxpB5yu+222+D1etu/Dh482M9ZUm/7zugSnF3qQDiu46lN+zLGWkwyIgkDvjAbC6KBKh/quNtmgtWU3Cb7TEXiOpr8URz1hhFJ6ChzWTC50o1zaz0YVeZEscMMk9K3b/tlLgvGDXXBbJLR4Od2tPlCCHF8CpQVZZwCldey2lIWFxdDURQ0NDR0ON7Q0ICysrKM59533324++678dZbb2HChAlp48xmM8xmc6/kS7lBliQs/PYI/PL5T/D2zkZ8b1wZRpc7U8ZKkgRFktASiqLMxWJHNBDlQx23mBQUF2g43BqBvRuf9sYSBvyROCIJHRZVQZFDQ4nTDLdV63TxdV8pcpgxfpiMnfV+HPWGUea0cmegQa4tHEeBxYTaYk6ByndZHbHQNA1Tp07tsPD6xELsurq6tOfde++9uOuuu7Bu3TpMmzatP1KlHHN2aQEuGJ2cQvfYO3sy7qNu11S0BGI5s088EVEqxQ4zhBCdfsqfOLGjU1sYbZEYHBYVYytcmFbb9R2d+prTYsK4Che3o80DsYSBSFzH8CH2bjXFNDhl/RWwaNEizJ8/H9OmTcP06dPx0EMPIRgMYsGCBQCAq666CkOHDsWKFSsAAPfccw+WLVuGZ555BjU1Ne1rMRwOBxwOR9Z+D+p/V9ZV4/3dzdjVFMBbnzdg7tjUo1xWTUGjPw5/JAGzI7tvtkRE6bitGuxmFcFo4rRtOnVDIBBNIBhNQJElOCwqqjxWFNrMKLCoOfkpsVVTMLrCCU2VcbA1BI/NDIuJNXgwEUKgMRBBtceG0gLOCqAcaCwuv/xyNDU1YdmyZaivr8ekSZOwbt269gXdBw4cgCyfHFh59NFHEYvFcNlll3V4nuXLl+OOO+7o83wlCTCbZDQFogjFdDjMKmya0qMdNejMFNo0/Hh6FZ54by/+tHkfzhtRDIfl9Je0IksQSO5WUewY3NMpiGjg0lQZJQVm7GkOosBigiEEQjEdgWgcQgAOs4oRJXZ47Ga4rKYBMb3oxHa0JkXG3uYgCsymlHWaBqbWUBwuiwk1nAJFx0kiz7Zt8Pl8cLlc8Hq9cDpTz8vvTDShwxuKo8kfxbFgDOF4Aqokw2FRYTWxyehPCd3ATWu34WBLCJdMKMfCb49IGecNx6EqEs6t8QyIN2OiwaQ36m5fPl8uORaIYsuBNkgAdCFg1xQUO8wocpjhtpn6fPF1XzEMgUOtIXzZGIBZkeG2adlOiXoomtDRGoph/FA31zAOct2pufzY4AyYVQUlTgUlTgsicR1toTga/RG0BmNoC8VgUhQUWFQO+fYDVZGx8FvDsfTlHXh9+1HMHVOGmmL7aXE2TUFLMAZ/JM43NCLKWS6rCcUODaoioaTAApfVNCjeS2RZQlWRHZqqYGe9D03+KIodGj+IG6CEEGgOxFBdZEWpkzMB6KSB+dFHDrGYFJS5LJgwLLml3/hhbhQ5NARjCRxuC+NYIIpInIuG+9LESjdmjiiCIZJ35E41CGdSZCQMwW1niSinqYqMicPcGD/UjVKnZVA0FafidrSDQ0swBrfVhJoiB5tD6oCNRS+yaSoq3FZMGObCtBoPxg9zwWUzIRCN47A3hGOBKGIJ7ozRF352Xi00Rcb2w168t6s5ZYzVpKDRH+FNm4gopw32uerJ7WhdcNs0HPWGM+7qR7knEtcRNwRqh9izvvsY5R42Fn1AkiQ4zCqGuq2YVOnGtBoPxpa74LCo8EZiONwWQmswxu33elGp04LLpg4DADz5/r6Uo0Q2TYE/EkcgylELIqJsOrEdbbnLyu1oBxAhBI4Fo6gstKKkgFOg6HRsLPqYJEkosJhQ6bFhSlUhplZ7MKbcCatZQUsohiNtYbSGYkiwqPbYD6YMRUmBGc2BKP768aHTHreYFMR0AX+EjQURUbZZNQWjy52o8tjQFIgg3IO7jlP/aAnG4LZpqCm2cwoUpcTGoh/JsgSX1YSqIjumVhXi3GoPRpU5oKkyjgVjOOINwRuOc1j4DJlVBVd/sxYA8L9bD6HeGzktxiTLaPJH+zs1IiJKQVNljCpzYkSxA63hGAL84CdnReI6EobA8GL7oFv7Q72HjUWWyLIEl82EmmIHzq3xYGp1IUYOKYAqS2gKRHHEG4aPTUa31Q0vwqRKN+K6wBPv7TntcbtZgTcc5ydjREQ5QpEljChxYHRZAYLxBFpDsWynRF9jnJgC5bFhCKdAUQZsLHKAIksotGsYUeLAtJpCTKlyY8QQOyQJaPRHUO8Lwx+Jc/eMLpAkCdd8azgUWcL/29uCLftbOzxuNSkIx3X4I/EsZUhERF8nScntaMdVuCCEQJM/yo02csiJKVDVRTZOgaKM2FjkGFWRUeQwY2RJAc6t9WBKdSGqPXYYAOq9YTT4IghEE2wyMqjy2HDJ+HIAye1nT10UKEkSZEhoCfITMSKiXHNiO1oLt6PNGeGYDt0QGDHEwSlQ1Ck2FjnMpMgodphxdlkBzq0pxOTqQlQUWpAwDNT7ImjwRRCKJfipTgpXTK+C22rC4bYw/vbJkQ6P2c0KjgVj3PqXiCgHFTnMGMftaHOCIQRaQlFUeWwodvDmstQ5NhYDhFlVUFJgwZhyF86t8WBSpRvlLguiCQNHfWE0+tlknMpuVjG/rgYA8OxHBzuMUNg0FaFYgtOhiIhy1Ne3o+UHQdlxLBCDx66hilOgqIvYWAxAFpOCUqcFY4cmm4yJwwoxpMCMSFzHUW8YTf4ogpwuhe+MLsHZpQ6E4zqe2rSv/bgiSzAMoC3ExoKIKFeduh1tc5Db0fa3UCwBAwLDOQWKuoGNxQBn1RSUuSyYMMyNc2s9GD/MjSKHhrhhoNEfwRFvCC3BGMIxPe9GM2RJwsJvjwAAvL2zEV8c9bU/ZtMUNAWiHGInIsph7dvRDnGgjdvR9hvdEGgJxVDjsaHYwV2gqOvYWAwiNk1FhduKiZVuTK/1YEpVIUaVFsBhURCOJ3DEG8ZRbxhtoRiiifz45Ofs0gJcMLoUAPCHd/a0NxJ2s4pANME3KSKiHKfIEkYMceAcbkfbb44Foyh2mFFZZMt2KjTAqNlOgPqGWVVgdigocphRXSQQjusIRBPwheNoDsTgj8RxLBGFLMuwmRRYNQUmZXD2mVfWVeP93c3Y1RTAW583YO7YMpgUGQndgC8Sh8tmynaKRESUwYntaDVVwc56H5r8URQ7NM777wOhWAKSBAwvtsOscgoUdc/g/EuSOpAkCTZNRUmBBSNLCjC9xoNpNR5MrCxEZaEVkgS0hGI47A2hyR9FIJoYVFOECm0afjy9CgDwp8372kcpLKqCpkAk76aIERENVNyOtm/phkBrKI4qjw1FnAJFZ4CNRR6SZQkFFhPKXBacU+7E9FoPzq32YPxQN4Y4NeiGgSZ/FEfawjgWiA6K3abmjS9HpccGXySBpz/cDyA5HcoXTiDEBYFERAMGt6PtO8cCyZGgKo8926nQAMXGgqAqMlw2E4a6rRg/NLkIfGpNIUaXO+GymRBJJHebOuINozUUQyQ+8P4QVxUZC781HADw+vaj2NcchMWkIBrX4eO2s0REAwq3o+25hG4gGE3gWCB6/D0+BM0kY/gQBzSVfx7SmeEaCzqNWVVgVpX2vavDsZPrM44Fk1vZtoSikCHDqimwDZD1GRMr3Zg5ogibdh/DY+/uwW8vHQdVlnEsEEO5y5rt9IiIqBtObEdrUiQcbA2h0GqGVeOagFR0QyCa0BGNG4gc37xFliRYTDKcNhVuqwa7WYVNU1Bg4bpDOnNsLKhTVi25uHtIgRnDhR3BmI5gNAFvKI5jgRhawzEkEgKqnFzLYdUUKHJuLqj72Xm1+Oe+Vmw/7MX7u49hcqW7fRSG+3QTEQ0sJ7aj1VQZe5qC0A0THJb8/tPGEALRuIFoQkckYcAwBBRZgqbKsJkVVBRakk2EKfl+zdEJ6k35+39fMAgoKf6QVBTAYukYl44sA1brmcWGQkC6dQuSBNhsZxYbDgNGhiFhu/3MYiMRQNchAXAAcChAaYEM3W5GIKogqJrRGoyhNRxHyzEv9LgOsyrBqimwmJQOO3cIqy2ZNwApGgX09Fu+divWYk1eZwBSLAYkTp/iVKYCV4z14E+fNOKP7+3Fyh9PRjgQgu+YDEuB5bR4AMnXw4nXSiwGxDNMnTo1Nh5PxqdjNgOq2v3YRAKIRtPHahpgMnU/VteT/87pmEzJ+O7GGkbytdYbsaqavBZA8v+JUKh3Yrvz/z1rROrY4zUipUy/d0+wjvfev1F3Y20nazOi0WSt6Y1Y68k63mm9PR6ryBJGuDSYI2F81eRFpC3ZcKiKDFWWYFJkSFZr+2sl3fvDCcLcsY5L8fS1WWgd63iXYxMJSLH0tVmYOtbxdLFCCEQlFREpObU3Ho/DFI9BU6TkzXRtJhSYTbAc3/3RYrN8rY6HgXRpsI4nsUZ0r4aLPOP1egUA4U3+853+dfHFHU+w2VLHAULMmtUxtrg4fey0aR1jq6vTx44Z0zF2zJj0sdXVHWOnTUsfW1zcMXbWrPSxNlvH2IsvTh97yssoGtdF9NIfZIz99ItD4tODbeLTg22i5bIrMsZ+tm1Xe2zzVT/PGPv5pk/aYxsX/iJj7OW/eFxUL35V/Pr5T8Su63+Z+Xf78MOT1+HeezPHbthwMvaRRzLHvvrqydjVqzPHPvfcydjnnsscu3r1ydhXX80c+8gjJ2M3bMgce++9J2M//DBz7PLlJ2N37Mgc+6tfnYzduzdz7PXXn4xtbMwcO3/+ydhAIHPsZZd1fL1nimWNSH51o0Z4AQFAeL1e0RtYx0/RB3VcCJH8fyJTbCBwMnb+/MyxjY0nY6+/PnPs3r0nY3/1q8yxO3acjF2+PGPspr+8LtbtOCrW7Tgqvvzl7Rljdz/3t/b3kkN3/S5j7N41a9tjD9y/MmPsvkfXtMfue3RNxtgD969sj927Zm3G2J23rxCbdzeLz460icZX/p75mrGOJ79YI5JfXawR3anh+TtiQX1CU2Wgk2HVBm8EekKGSVZQomdnwd0PpgzFB18Y+N+th/DTOBf9ERENZueUOREe6kJcN2CxZl5D0BKIwR+IQpUl2LO4KDyuG4jGDYhw5g1GqotsGFnjgSxLQLqRd6J+IiWbuvzh8/ngcrngPXIETqfz9AAOj6WO7YUhdCEEQjEdIdWMSMKANxxDoC2EWDSKuC4gRPLyJxePy8kmxWbv1alQJxhmC5a9+jm2HWxDXWUBrpkxDJOqCuGxa6cHcypUEqdCdT+WNQLA8bpbUQGv15u67nYT6zinQnU7NkUdNwyBmG4grhuI6yL534SBiGpCSAfCMR2JaAx6JIKELpLb2kqADAmyDJhkGbLVAlXToCoSVD0BOdMUqwxToXTdQCRhIBrXEdMFDJMJikWDRVXgUACPImDW5OQ6RtPX1jGyjiexjp/UyzWiOzU8fxuLXnqDo57RDYFIXEc4riMc0+GPxOENJxBN6IglDAgAqiTBbDrZbMi9dKfVAy0h3PTsVuiGwE3fHYkfTB6KmmJHrzw3EZ3U23WXdZz6S/xE45E4tQkxkh+SxRKIxg3EDQMJQyCREJAkQEBAlmSYZKl9nYeqSFCPrwc5dYemqK4nF1crMiyqDLtZhdtqgt2swqIpsJkUqANg10Ua3LpTczkVirJKkSXYzSrs5pMvRcMQiCSSjUb4+H0mkjeyS6AtbEA3BFRZhlmVk6MbpjNrNqo8Nlwyvhwvf3IEz//zEL45oghVHntyOJmIiPKeSZGT26mnGMwGkHLUI5ZI7siUbD50JHQDkbhINh+GkXz/Mh3foclmgcNsgvX44mru0EQDHRsLyjny8W1rbVrHZiOaMBCKJRCO6whEEvCG4wjHk82GAQFFOtFsJBuOrmx5e8X0KhxoCeH680dgQmUhWkIxOC0mJAyjw8/PtnAsAUWW4Y/EUcD8uiWXcwOYH9FAJssSLLKSdrtyIZINxamjHqbjOzZxi3MajPjuQAOCLEvt99M4QQiBSNxITqOK6whE4sebDR2+cAKGEJAlKdlomFI3Gx67hj9dPR2PvbMHv3z+E/jCCTitKhbMrMX1s0fAnAOFPxrXseofe7B6017mN4hyY35Eg58kSTApUsZRD6LBJCcai5UrV+J3v/sd6uvrMXHiRDz88MOYPn162vjnn38et99+O/bt24ezzjoL99xzDy6++OJ+zJhygSR9vdmwQojkyMaJaVTBaAJt4fjx9RsJ6EJAxslmo9Rpx+Pv7sHDb+9qf15fOIHfr/8KAHD1N2uTC/ayRJEl/PG9ve35AMxvMOQGDPz8Fs4azpELIiLqIOvvCmvXrsWiRYuwatUqzJgxAw899BDmzp2LnTt3oqSk5LT4TZs24YorrsCKFStwySWX4JlnnsGll16KLVu2YNy4cVn4DSiXSNLJIebCU45H4nr7IvFgNIG2UBwJw4DLZsKaTftSPtfqTXuxcNZwzL5vI1qCGXZs6iMeu4b3Fp+P1Zv2pnyc+Q3M3IDBkd8N54/s56yIiCjXZX2V0AMPPIBrrrkGCxYswJgxY7Bq1SrYbDY8+eSTKeN///vf43vf+x5uvfVWjB49GnfddRemTJmCRx55pJ8zp4HEYlLgtmkod1kxsqQA02o8mFJVCH8kAV849daHvnACLcEYhjjM/Zxt0hCHGccCMeZ3BnI5N2Bw5OePZN5bn4iI8k9WRyxisRg+/vhj3Hbbbe3HZFnGnDlzsHnz5pTnbN68GYsWLepwbO7cuXjppZdSxkejUURP2cff5/P1PHEaFDRVgdMiwWlVU/4B5bSqKCmwYO2130A2JqRIAGxmlfkNstyAwZFfgSXzTcZ6E+s4EdHAkNXGorm5Gbquo7S0tMPx0tJSfPHFFynPqa+vTxlfX1+fMn7FihW48847eydhGnR0w8CCmbUd5pGfsGBmLRKGAXeqm+b1k3AswfzOUC7nBgyO/LR+GvRmHSciGhiyPhWqr912223wer3tXwcPHsx2SpRDrJqK62ePwM3fPQtOa7LPdlpV3Pzds3D97BFZX5zK/AZnbsyve1jHiYgGhqy+cxUXF0NRFDQ0NHQ43tDQgLKyspTnlJWVdSvebDbDbM7OPGUaGMwmBQtnDccN54/ssFd/rmynyfwGZ24A8+tyHqzjREQDQlZHLDRNw9SpU7F+/fr2Y4ZhYP369airq0t5Tl1dXYd4AHjzzTfTxhN1hU1ToakyihxmaKqc9U+Lv475nblczg1gfkRENHhk/R1i0aJFmD9/PqZNm4bp06fjoYceQjAYxIIFCwAAV111FYYOHYoVK1YAAG6++WbMmjUL999/P+bNm4dnn30W//znP/HYY49l89cgIiIiIsprWW8sLr/8cjQ1NWHZsmWor6/HpEmTsG7duvYF2gcOHIAsnxxYmTlzJp555hksXboUv/nNb3DWWWfhpZde4j0siIiIiIiySBJCZO/Wrlng8/ngcrng9XrhdDqznQ4R0aDX23WXdZyIqP90p+ZmfcSiv53oo7gPOhFR/zhRb3vrcyzWcSKi/tOdGp53jYXf7wcAVFZWZjkTIqL84vf74XK5euV5ANZxIqL+1JUanndToQzDwJEjR1BQUABJkrp1rs/nQ2VlJQ4ePMjh96/htUmP1yY9XpvUBtt1EULA7/ejoqKiw5q5M8U63vt4XdLjtUmP1ya9wXRtulPD827EQpZlDBs2rEfP4XQ6B/yLpK/w2qTHa5Mer01qg+m69MZIxQms432H1yU9Xpv0eG3SGyzXpqs1fNDfeZuIiIiIiPoeGwsiIiIiIuoxNhbdYDabsXz5cpjN5mynknN4bdLjtUmP1yY1Xpe+w2ubGq9Lerw26fHapJev1ybvFm8TEREREVHv44gFERERERH1GBsLIiIiIiLqMTYWRERERETUY2wsiIiIiIiox9hYfM3KlStRU1MDi8WCGTNm4MMPP8wY//zzz+Occ86BxWLB+PHj8frrr/dTpv2vO9dmzZo1kCSpw5fFYunHbPvPO++8g3/5l39BRUUFJEnCSy+91Ok5GzduxJQpU2A2mzFy5EisWbOmz/Psb929Lhs3bjztNSNJEurr6/sn4X60YsUKnHvuuSgoKEBJSQkuvfRS7Ny5s9Pz8qne9ATreGqs4amxhqfHOp4aa3h6bCxOsXbtWixatAjLly/Hli1bMHHiRMydOxeNjY0p4zdt2oQrrrgCV199NbZu3YpLL70Ul156KXbs2NHPmfe97l4bIHm3yaNHj7Z/7d+/vx8z7j/BYBATJ07EypUruxS/d+9ezJs3D+effz62bduGW265BT//+c/xxhtv9HGm/au71+WEnTt3dnjdlJSU9FGG2fOPf/wDN9xwAz744AO8+eabiMfjuPDCCxEMBtOek0/1pidYx1NjDU+PNTw91vHUWMMzENRu+vTp4oYbbmj/Xtd1UVFRIVasWJEy/kc/+pGYN29eh2MzZswQCxcu7NM8s6G712b16tXC5XL1U3a5A4B48cUXM8b8+te/FmPHju1w7PLLLxdz587tw8yyqyvXZcOGDQKAaG1t7ZecckljY6MAIP7xj3+kjcmnetMTrOOpsYZ3DWt4eqzj6bGGn8QRi+NisRg+/vhjzJkzp/2YLMuYM2cONm/enPKczZs3d4gHgLlz56aNH6jO5NoAQCAQQHV1NSorK/H9738fn332WX+km/Py5XVzpiZNmoTy8nJccMEFeP/997OdTr/wer0AAI/HkzaGr5vOsY6nxhreu/LhNdNT+VbHWcNPYmNxXHNzM3RdR2lpaYfjpaWlaecG1tfXdyt+oDqTazNq1Cg8+eSTePnll/HnP/8ZhmFg5syZOHToUH+knNPSvW58Ph/C4XCWssq+8vJyrFq1Ci+88AJeeOEFVFZWYvbs2diyZUu2U+tThmHglltuwXnnnYdx48aljcuXetMTrOOpsYb3Ltbw9PKxjrOGd6RmOwEanOrq6lBXV9f+/cyZMzF69Gj84Q9/wF133ZXFzChXjRo1CqNGjWr/fubMmdi9ezcefPBB/M///E8WM+tbN9xwA3bs2IH33nsv26kQtWMNpzORj3WcNbwjjlgcV1xcDEVR0NDQ0OF4Q0MDysrKUp5TVlbWrfiB6kyuzdeZTCZMnjwZu3bt6osUB5R0rxun0wmr1ZqlrHLT9OnTB/Vr5sYbb8Srr76KDRs2YNiwYRlj86Xe9ATreGqs4b2LNbx7BnMdZw0/HRuL4zRNw9SpU7F+/fr2Y4ZhYP369R0+tTlVXV1dh3gAePPNN9PGD1Rncm2+Ttd1bN++HeXl5X2V5oCRL6+b3rBt27ZB+ZoRQuDGG2/Eiy++iLfffhu1tbWdnsPXTedYx1NjDe9d+fCa6U2DsY6zhmeQ7dXjueTZZ58VZrNZrFmzRvzf//2fuPbaa4Xb7Rb19fVCCCGuvPJKsWTJkvb4999/X6iqKu677z7x+eefi+XLlwuTySS2b9+erV+hz3T32tx5553ijTfeELt37xYff/yx+Pd//3dhsVjEZ599lq1foc/4/X6xdetWsXXrVgFAPPDAA2Lr1q1i//79QgghlixZIq688sr2+D179gibzSZuvfVW8fnnn4uVK1cKRVHEunXrsvUr9InuXpcHH3xQvPTSS+Krr74S27dvFzfffLOQZVm89dZb2foV+sx1110nXC6X2Lhxozh69Gj7VygUao/J53rTE6zjqbGGp8canh7reGqs4emxsfiahx9+WFRVVQlN08T06dPFBx980P7YrFmzxPz58zvEP/fcc+Lss88WmqaJsWPHitdee62fM+4/3bk2t9xyS3tsaWmpuPjii8WWLVuykHXfO7G93te/TlyP+fPni1mzZp12zqRJk4SmaWL48OFi9erV/Z53X+vudbnnnnvEiBEjhMViER6PR8yePVu8/fbb2Um+j6W6LgA6vA7yvd70BOt4aqzhqbGGp8c6nhpreHqSEEL07ZgIERERERENdlxjQUREREREPcbGgoiIiIiIeoyNBRERERER9RgbCyIiIiIi6jE2FkRERERE1GNsLIiIiIiIqMfYWBARERERUY+xsSAiIiIioh5jY0GUY2KxGEaOHIlNmzZlO5Uu+cY3voEXXngh22kQEeUM1nHKV2wsiI5ramrCddddh6qqKpjNZpSVlWHu3Ll4//3322NqamogSRI++OCDDufecsstmD17dvv3d9xxByRJgiRJUBQFlZWVuPbaa9HS0tJpHqtWrUJtbS1mzpzZfuy3v/0tZs6cCZvNBrfbnfK8AwcOYN68ebDZbCgpKcGtt96KRCLR6c8Lh8Ow2+3YtWtXp7GpLF26FEuWLIFhGGd0PhFRb2EdZx2n7GJjQXTcD3/4Q2zduhVPPfUUvvzyS7zyyiuYPXs2jh071iHOYrFg8eLFnT7f2LFjcfToURw4cACrV6/GunXrcN1112U8RwiBRx55BFdffXWH47FYDP/2b/+W9nxd1zFv3jzEYjFs2rQJTz31FNasWYNly5Z1muebb76J6upqjBw5stPYVC666CL4/X78/e9/P6PziYh6C+s46zhlmSAi0draKgCIjRs3Zoyrrq4WN910k9A0Tbz22mvtx2+++WYxa9as9u+XL18uJk6c2OHcRYsWicLCwozP/9FHHwlZloXP50v5+OrVq4XL5Trt+Ouvvy5kWRb19fXtxx599FHhdDpFNBrN+DN/9rOficWLF6d87KmnnhJ2u118+eWX7ceuu+46MWrUKBEMBtuPLViwQPzHf/xHxp9DRNSXWMdZxyn7OGJBBMDhcMDhcOCll15CNBrNGFtbW4v//M//xG233dblYeN9+/bhjTfegKZpGePeffddnH322SgoKOhy7gCwefNmjB8/HqWlpe3H5s6dC5/Ph88++yzteYZh4NVXX8X3v//9lI9fddVVuPjii/GTn/wEiUQCr732Gp544gk8/fTTsNls7XHTp0/Hu+++262ciYh6E+s46zhlHxsLIgCqqmLNmjV46qmn4Ha7cd555+E3v/kNPv3005TxS5cuxd69e/H000+nfc7t27fD4XDAarWitrYWn332WadD7/v370dFRUW386+vr+/wZgSg/fv6+vq0552YYzxjxoy0MX/4wx9w9OhR3HTTTbj66qtxxx13YOrUqR1iKioqcPDgQc7PJaKsYR1nHafsY2NBdNwPf/hDHDlyBK+88gq+973vYePGjZgyZQrWrFlzWuyQIUPwq1/9CsuWLUMsFkv5fKNGjcK2bdvw0UcfYfHixZg7dy5+8YtfZMwhHA7DYrH0xq/TJS+//DIuueQSyHL6UlBYWIg//vGPePTRRzFixAgsWbLktBir1QrDMDr9lJCIqC+xjqfGOk79hY0F0SksFgsuuOAC3H777di0aRN++tOfYvny5SljFy1ahHA4jP/+7/9O+bimaRg5ciTGjRuHu+++G4qi4M4778z484uLi9Ha2trtvMvKytDQ0NDh2Invy8rK0p73yiuv4F//9V87ff533nkHiqLg6NGjCAaDpz3e0tICu90Oq9XazcyJiHoX63hqrOPUH9hYEGUwZsyYlAUYSM7nvf322/Hb3/4Wfr+/0+daunQp7rvvPhw5ciRtzOTJk/HFF19ACNGtPOvq6rB9+3Y0Nja2H3vzzTfhdDoxZsyYlOd89dVX2L9/Py644IKMz71p0ybcc889+Nvf/gaHw4Ebb7zxtJgdO3Zg8uTJ3cqZiKg/sI6zjlP/YWNBBODYsWP4zne+gz//+c/49NNPsXfvXjz//PO499570y6IA4Brr70WLpcLzzzzTKc/o66uDhMmTMB//dd/pY05//zzEQgETluod+DAAWzbtg0HDhyAruvYtm0btm3bhkAgAAC48MILMWbMGFx55ZX45JNP8MYbb2Dp0qW44YYbYDabU/6sl19+GXPmzOmweO/r/H4/rrzyStx000246KKL8PTTT2Pt2rX461//2iHu3XffxYUXXtjpNSAi6ius46mxjlO/yva2VES5IBKJiCVLlogpU6YIl8slbDabGDVqlFi6dKkIhULtcdXV1eLBBx/scO4zzzwjAHS6TaEQQvzlL38RZrNZHDhwIG0uP/rRj8SSJUs6HJs/f74AcNrXhg0b2mP27dsnLrroImG1WkVxcbH45S9/KeLxeNqf881vflM8/vjjaR8XIrn94Pjx40UkEmk/dv/99wuPxyMOHTokhBDi0KFDwmQyiYMHD2Z8LiKivsQ6nhrrOPUnSYhujtURUZ/69NNPccEFF2D37t1wOBx98jOam5tRXl6OQ4cOnbYLSXctXrwYra2teOyxx3opOyKigY11nPIVp0IR5ZgJEybgnnvuwd69e/vsZ7S0tOCBBx7o8ZsRAJSUlOCuu+7qhayIiAYH1nHKVxyxICIiIiKiHuOIBRERERER9RgbCyIiIiIi6jE2FkRERERE1GNsLIiIiIiIqMfYWBARERERUY+xsSAiIiIioh5jY0FERERERD3GxoKIiIiIiHqMjQUREREREfXY/wf+ROmj16eUCwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", + "\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", + "\n", + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\"Linear ANCOVA model with Permutation Forest\")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "74ab24c9-b9fe-4d67-9b04-7125aecb2816", + "metadata": {}, + "source": [ + "# Run Experiment on Correlated Logit Model" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "a2aed8f0-1230-4128-ad77-d84764c28d0d", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n" + ] + } + ], + "source": [ + "pvalue_dict = defaultdict(list)\n", + "rng = np.random.default_rng(seed)\n", + "\n", + "beta_space = np.hstack((np.linspace(0.01, 2.5, 8), np.linspace(5, 20, 7)))\n", + "for sigma_factor in j_space:\n", + " for idx in range(5):\n", + " new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32)\n", + "\n", + " elements_dict = correlated_logit_model(sigma_factor, new_seed)\n", + " for key, value in elements_dict.items():\n", + " pvalue_dict[key].append(value)\n", + " pvalue_dict[\"sigma_factor\"].append(sigma_factor)\n", + "\n", + "df = pd.DataFrame(pvalue_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, "id": "d3e21945-92b3-4ccc-8f29-b44f67d9cf33", "metadata": {}, "outputs": [ @@ -378,7 +775,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 20, "id": "b2bced31-0367-48a8-88e1-0afd6a60173f", "metadata": {}, "outputs": [ @@ -403,10 +800,9 @@ " \n", " \n", " \n", - " X1\n", - " X6\n", " X2\n", - " X7\n", + " X1\n", + " X500\n", " sigma_factor\n", " \n", " \n", @@ -414,41 +810,36 @@ " \n", " 0\n", " 1.000000\n", - " 0.001996\n", - " 1.000000\n", + " 0.004975\n", " 1.000000\n", " 0.005\n", " \n", " \n", " 1\n", - " 0.001996\n", - " 0.001996\n", - " 0.001996\n", - " 0.001996\n", + " 0.004975\n", + " 0.004975\n", + " 1.000000\n", " 0.005\n", " \n", " \n", " 2\n", " 1.000000\n", - " 1.000000\n", - " 1.000000\n", + " 0.004975\n", " 1.000000\n", " 0.005\n", " \n", " \n", " 3\n", + " 0.004975\n", " 1.000000\n", - " 1.000000\n", - " 1.000000\n", - " 1.000000\n", + " 0.004975\n", " 0.005\n", " \n", " \n", " 4\n", + " 0.004975\n", " 1.000000\n", - " 0.001996\n", - " 1.000000\n", - " 0.001996\n", + " 0.004975\n", " 0.005\n", " \n", " \n", @@ -456,12 +847,12 @@ "" ], "text/plain": [ - " X1 X6 X2 X7 sigma_factor\n", - "0 1.000000 0.001996 1.000000 1.000000 0.005\n", - "1 0.001996 0.001996 0.001996 0.001996 0.005\n", - "2 1.000000 1.000000 1.000000 1.000000 0.005\n", - "3 1.000000 1.000000 1.000000 1.000000 0.005\n", - "4 1.000000 0.001996 1.000000 0.001996 0.005" + " X2 X1 X500 sigma_factor\n", + "0 1.000000 0.004975 1.000000 0.005\n", + "1 0.004975 0.004975 1.000000 0.005\n", + "2 1.000000 0.004975 1.000000 0.005\n", + "3 0.004975 1.000000 0.004975 0.005\n", + "4 0.004975 1.000000 0.004975 0.005" ] }, "metadata": {}, @@ -474,79 +865,15 @@ }, { "cell_type": "code", - "execution_count": 28, - "id": "9e60fac2-3b20-493e-886a-892d572a28c6", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", - "axs = axs.flatten()\n", - "\n", - "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", - " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", - "\n", - " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", - " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", - " ax.legend()\n", - "fig.suptitle(\n", - " \"Linear ANCOVA model with Coleman Forest (Permutation per tree and sample dataset per tree)\"\n", - ")\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "7c99ce8c-a32d-447b-9dd2-85c8d310239f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", - "axs = axs.flatten()\n", - "\n", - "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", - " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", - "\n", - " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", - " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", - " ax.legend()\n", - "fig.suptitle(\"Linear ANCOVA model with Coleman Forest (Permutation per tree)\")\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "67846a66-1817-46c8-9ccc-5281773c4f92", + "execution_count": 25, + "id": "c4dbdaf1-9af7-4e6d-83b6-a9cabc18dc91", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAJQCAYAAAATyPJiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAADLsUlEQVR4nOzdd3hUZdoG8PtML8lMekIKSShKlRKkCQKKIijKqmtDBVbsYGF1V1xXQEXsoliw48eua10r1qWIAipd6S2QUNKT6X3e748hA0MKSWaSSbl/1zUXzJlnZt55c86Z88zbJCGEABERERERURhk0S4AERERERG1fUwsiIiIiIgobEwsiIiIiIgobEwsiIiIiIgobEwsiIiIiIgobEwsiIiIiIgobEwsiIiIiIgobEwsiIiIiIgobEwsiIiIiIgobEwsqF1YsmQJJEnCwYMHo12UEJIkYe7cudEuRq3mzp0LSZKiXYyw5OTkYOrUqU16bnP+bRpTt9WxZWVlzVKWpmrN+y41nN/vR58+fTB//vxoF4XaOI/Hg6ysLLzyyivRLgq1YkwsqE779+/Hrbfeii5dukCj0cBgMOCcc87BCy+8AIfDEe3iRcx7772HhQsXRu39Dx48CEmS8Mwzz0StDNUef/xxfPbZZ9EuRrvU3HW7atUqXH755UhLS4NKpUJKSgomTpyI//73v832nm2dJEm13tLS0qJdtFp9/fXXjU72/vOf/6CwsBAzZsxonkK1Ijt27MDcuXNb3Q9MkbB27VrMnTsXVVVVUSuDUqnErFmzMH/+fDidzqiVg1o3JhZUq2XLlqFv37748MMPMXHiRCxatAgLFixA586dcf/99+Puu++OdhEjJtqJRbQ89NBDNRJEJhaR0dJ1O2fOHIwZMwbbtm3DrbfeisWLF+P++++H1WrFFVdcgffee69Z3rc9uOCCC7B06dKQ28svvxztYtXq66+/xrx58xr1nKeffhrXXHMNjEZjM5Wq9dixYwfmzZvXbhOLefPmRTWxAIBp06ahrKyM5xSqkyLaBaDWJz8/H9dccw2ys7OxYsUKdOrUKfjYnXfeiX379mHZsmVhv48QAk6nE1qttsZjTqcTKpUKMhlz3+aiUCigUPAU0Bxasm4//vhjPPLII7jyyivx3nvvQalUBh+7//778d1338Hj8bRIWdqiM844A9dff33EX9fr9cLv90OlUkX8tRtq8+bN2Lp1K5599tmovL/dbodOp4vKe7dFNpsNer0+7Nfx+/1wu93QaDQRKFWouLg4XHjhhViyZAn+8pe/RPz1qe3jVRvV8NRTT8FqteKtt94KSSqqdevWLaTFwuv14tFHH0XXrl2hVquRk5ODBx98EC6XK+R5OTk5uOSSS/Ddd99h0KBB0Gq1eO2117Bq1SpIkoT3338fDz30EDIyMqDT6WA2mwEAv/76Ky666CIYjUbodDqMGjUKa9asOe3n+Pzzz3HxxRcjPT0darUaXbt2xaOPPgqfzxeMGT16NJYtW4ZDhw4Fu0Hk5OQEH3e5XJgzZw66desGtVqNrKws/O1vf6vx2VwuF+69914kJycjNjYWl156KQ4fPtyg+m6okpIS3HTTTUhNTYVGo0G/fv3w7rvv1ogrLy/HDTfcAIPBgLi4OEyZMgVbt26FJElYsmRJMO7UcQCSJMFms+Hdd98N1kV94xeq/24ffvgh5s2bh4yMDMTGxuLKK6+EyWSCy+XCPffcg5SUFMTExGDatGk16q2h+44QAo899hgyMzOh0+kwZswYbN++vdZyVVVV4Z577kFWVhbUajW6deuGJ598En6/vwG1HPqeSUlJmDVrVnCb3+9HXFwc5HJ5yC+HTz75JBQKBaxWK4Cm1W1VVRWmTp2KuLg4GI1GTJs2DXa7/bTl/Oc//4mEhAS8/fbbIUlFtXHjxuGSSy4J3m/oflSbI0eO4C9/+QtSU1OhVqvRu3dvvP322yExkdgv3nnnHZx33nlISUmBWq1Gr1698Oqrr9YoT/U55eeff8bgwYOh0WjQpUsX/N///V+DPk9DNKS+Tu7OuHDhwuD+vGPHDgDArl27cOWVVyIhIQEajQaDBg3CF198EfIaHo8H8+bNQ/fu3aHRaJCYmIgRI0bghx9+AABMnTo12JJycret+nz22WdQqVQ499xzQ7ZX75+7du3CVVddBYPBgMTERNx99921dnH517/+hby8PGi1WiQkJOCaa65BYWFhSMzo0aPRp08fbNy4Eeeeey50Oh0efPDBkLp5+eWX0aVLF+h0Olx44YUoLCyEEAKPPvooMjMzodVqcdlll6GioiLktesa73PyGKslS5bgz3/+MwBgzJgxwfpZtWpVMP6bb77ByJEjodfrERsbi4svvrjO88jJqsfwrV69GrfeeisSExNhMBhw4403orKyskZ8Q95n6tSpiImJwf79+zFhwgTExsZi8uTJtb7/3Llzcf/99wMAcnNzg5+tumVGkiTMmDED//73v9G7d2+o1Wp8++23ABp2zAIN/64DAq18P//8c42/ExHAFguqxZdffokuXbpg+PDhDYqfPn063n33XVx55ZX461//il9//RULFizAzp078emnn4bE7t69G9deey1uvfVW3HzzzTjzzDODjz366KNQqVS477774HK5oFKpsGLFCowfPx55eXmYM2cOZDJZ8KLjp59+wuDBg+ss15IlSxATE4NZs2YhJiYGK1aswMMPPwyz2Yynn34aAPCPf/wDJpMJhw8fxvPPPw8AiImJARC4iLz00kvx888/45ZbbkHPnj3xxx9/4Pnnn8eePXtCurVMnz4d//rXv3Dddddh+PDhWLFiBS6++OIG1V9DOBwOjB49Gvv27cOMGTOQm5uLjz76CFOnTkVVVVUw0fP7/Zg4cSJ+++033H777ejRowc+//xzTJky5bTvsXTpUkyfPh2DBw/GLbfcAgDo2rXraZ+3YMECaLVaPPDAA9i3bx8WLVoEpVIJmUyGyspKzJ07F7/88guWLFmC3NxcPPzww8HnNnTfefjhh/HYY49hwoQJmDBhAjZt2oQLL7wQbrc7pCx2ux2jRo3CkSNHcOutt6Jz585Yu3YtZs+ejWPHjjWqy5skSTjnnHOwevXq4Lbff/8dJpMJMpkMa9asCf6Nf/rpJwwYMCC47zSlbq+66irk5uZiwYIF2LRpE958802kpKTgySefrLOMe/fuxa5du/CXv/wFsbGxp/1MDd2PalNcXIyhQ4cGL2KSk5PxzTff4KabboLZbMY999wTEh/OfvHqq6+id+/euPTSS6FQKPDll1/ijjvugN/vx5133hnyPvv27cOVV16Jm266CVOmTMHbb7+NqVOnIi8vD7179z5tnTidzhoD52NjY6FWqxtdX++88w6cTiduueUWqNVqJCQkYPv27TjnnHOQkZGBBx54AHq9Hh9++CEmTZqETz75BH/6058ABC4eFyxYENxPzGYzNmzYgE2bNuGCCy7ArbfeiqNHj+KHH37A0qVLT/u5gED3mT59+tSacAKBfS4nJwcLFizAL7/8ghdffBGVlZUhidn8+fPxz3/+E1dddRWmT5+O0tJSLFq0COeeey42b96MuLi4YGx5eTnGjx+Pa665Btdffz1SU1ODj/373/+G2+3GzJkzUVFRgaeeegpXXXUVzjvvPKxatQp///vfg/vJfffdV+vFb33OPfdc3HXXXXjxxRfx4IMPomfPngAQ/Hfp0qWYMmUKxo0bhyeffBJ2ux2vvvoqRowYgc2bN4f8oFSXGTNmIC4uDnPnzsXu3bvx6quv4tChQ8FkurHv4/V6MW7cOIwYMQLPPPNMna07l19+Ofbs2YP//Oc/eP7555GUlAQASE5ODsasWLECH374IWbMmIGkpCTk5OQ0+JhtzHcdAOTl5UEIgbVr14b8aEEEABBEJzGZTAKAuOyyyxoUv2XLFgFATJ8+PWT7fffdJwCIFStWBLdlZ2cLAOLbb78NiV25cqUAILp06SLsdntwu9/vF927dxfjxo0Tfr8/uN1ut4vc3FxxwQUXBLe98847AoDIz88PiTvVrbfeKnQ6nXA6ncFtF198scjOzq4Ru3TpUiGTycRPP/0Usn3x4sUCgFizZk1IHdxxxx0hcdddd50AIObMmVPjtU+Wn58vAIinn366zpiFCxcKAOJf//pXcJvb7RbDhg0TMTExwmw2CyGE+OSTTwQAsXDhwmCcz+cT5513ngAg3nnnneD2OXPmiFNPAXq9XkyZMqXe8lar/rv16dNHuN3u4PZrr71WSJIkxo8fHxI/bNiwkHpu6L5TUlIiVCqVuPjii0P2gwcffFAACCnvo48+KvR6vdizZ0/Iaz7wwANCLpeLgoKC4LaG/G2efvppIZfLg/X74osviuzsbDF48GDx97//XQgRqN+4uDhx7733Bp/XmLqtjv3LX/4Ssv1Pf/qTSExMrLd8n3/+uQAgnn/++XrjqjV0PxKiZv3cdNNNolOnTqKsrCzkNa+55hphNBqDx1u4+4UQtR+748aNE126dAnZVn1OWb16dXBbSUmJUKvV4q9//etpaiPwGWu7VR8nDa2v6mPYYDCIkpKSkPc4//zzRd++fUPOOX6/XwwfPlx07949uK1fv37i4osvrre8d955Z439qj6ZmZniiiuuqLG9ep+79NJLQ7bfcccdAoDYunWrEEKIgwcPCrlcLubPnx8S98cffwiFQhGyfdSoUQKAWLx4cUhsdd0kJyeLqqqq4PbZs2cLAKJfv37C4/EEt1977bVCpVKF1Fddx2p2dnbIMfXRRx8JAGLlypUhcRaLRcTFxYmbb745ZHtRUZEwGo01tp+q+vslLy8vZJ9+6qmnBADx+eefN/p9pkyZIgCIBx54oN73rvb000/X+I6rBkDIZDKxffv2kO0NPWYb+l1X7ejRowKAePLJJxtUdupY2BWKQlR3P2rIr59AYDAhgJDuIgDw17/+FQBqjMXIzc3FuHHjan2tKVOmhIy32LJlC/bu3YvrrrsO5eXlKCsrQ1lZGWw2G84//3ysXr263u4tJ7+WxWJBWVkZRo4cCbvdjl27dp32s3300Ufo2bMnevToEXzvsrIynHfeeQCAlStXhtTBXXfdFfL8U3/BDcfXX3+NtLQ0XHvttcFtSqUSd911F6xWK3788UcAwLfffgulUombb745GCeTyWr8yhtJN954Y8gvokOGDIEQokb/2yFDhqCwsBBerzf4mYDT7zv/+9//gr90ntz1o7b6/eijjzBy5EjEx8eH/M3Gjh0Ln88X0vrQECNHjoTP58PatWsBBFomRo4ciZEjR+Knn34CAGzbtg1VVVUYOXJko177VLfddluN9y4vLw8ek7VpyvHakP3oVEIIfPLJJ5g4cSKEECF1O27cOJhMJmzatCnkOU3dL4DQY9dkMqGsrAyjRo3CgQMHYDKZQp7fq1evkLpPTk7GmWeeiQMHDjSoTi677DL88MMPIbfqc1Rj6+uKK64I+RW5oqICK1aswFVXXRU8B5WVlaG8vBzjxo3D3r17ceTIEQCBvuvbt2/H3r17G1TuhigvL0d8fHydj596Xpg5cyaAE8fmf//7X/j9flx11VUhf/O0tDR07949eA6splarMW3atFrf689//nPIAPIhQ4YAAK6//vqQ8UhDhgyB2+0O1ksk/PDDD6iqqsK1114b8jnkcjmGDBlS43PU5ZZbbgnZp2+//XYoFIpgfTXlfW6//faIfMZRo0ahV69ewfuNOWYb+l1XrXqfam1TZFPrwK5QFMJgMAAIXIg3xKFDhyCTydCtW7eQ7WlpaYiLi8OhQ4dCtufm5tb5Wqc+Vv0FW183HpPJVOcX5/bt2/HQQw9hxYoVNS7OTr04qc3evXuxc+fOkAuFk5WUlAA4UQendm05uZtXuA4dOoTu3bvXGMxe3cxfXc+HDh1Cp06dajSpn/r3iaTOnTuH3K++eMjKyqqx3e/3w2QyITExscH7TvW/3bt3D4lLTk6u8bffu3cvfv/999P+zRpq4MCB0Ol0+OmnnzBu3Dj89NNPmDdvHtLS0rBo0SI4nc5ggjFixIhGvfapTq3H6s9WWVkZPC5P1ZTjtSH70alKS0tRVVWF119/Ha+//nqtMafWbVP3CwBYs2YN5syZg3Xr1tUYZ2IymUIuUE99HyBQd7X1fa9NZmYmxo4dW+tjja2vU89h+/btgxAC//znP/HPf/6z1vcoKSlBRkYGHnnkEVx22WU444wz0KdPH1x00UW44YYbcNZZZzXoc9RFCFHnY6ceU127doVMJgv23d+7dy+EEDXiqp3axSojI6POweqN2R8ANPjv1xDV3yXVF8qnquv4OtWp9RATE4NOnTqF1Fdj3kehUCAzM7NB7306p+57jTlmG/pdV616n2rr6yBR82BiQSEMBgPS09Oxbdu2Rj2voSeY2maAquux6taIp59+Gv3796/1OXX1aa+qqsKoUaNgMBjwyCOPoGvXrtBoNNi0aRP+/ve/N2ggr9/vR9++ffHcc8/V+vipX4gdlVwub9T2Uy90Ivnl5Pf7ccEFF+Bvf/tbrY+fccYZjXo9pVKJIUOGYPXq1di3bx+KioowcuRIpKamwuPx4Ndff8VPP/2EHj161Pml3FANra+T9ejRAwDwxx9/hPXep1N9vFx//fV1JvqnXgA3db/Yv38/zj//fPTo0QPPPfccsrKyoFKp8PXXX+P555+vcew2pd6aS13nsPvuu6/OltrqxPrcc8/F/v378fnnn+P777/Hm2++ieeffx6LFy/G9OnTm1SexMTERl2gn3os+v1+SJKEb775ptZ6PvX8W9/5PdzzRG1OnoijPtV/h6VLl9a6RkmkZnBr7Puo1eqIzXxY177XkGO2sd911ftU9VgPopMxsaAaLrnkErz++utYt24dhg0bVm9sdnY2/H4/9u7dG/wVDwgM9KyqqkJ2dnaTy1HdAmAwGOr8RbEuq1atQnl5Of773/+GzIiSn59fI7auC9uuXbti69atOP/88+u9+K2ug/3794e0UuzevbtRZa5PdnY2fv/9d/j9/pAvououXdX1nJ2djZUrV9aY5nHfvn0Nep+W/AWqoftO9b979+5Fly5dgnGlpaU1Lpq6du0Kq9Xa6P2lPiNHjsSTTz6J//3vf0hKSkKPHj0gSRJ69+6Nn376CT/99FODBjA2R92eccYZOPPMM/H555/jhRdeqDPRrtbQ/ehU1bOd+Xy+iNZtbb788ku4XC588cUXIb9yN7S7SiQ1tb6qVe+vSqWyQfWWkJCAadOmYdq0abBarTj33HMxd+7cYGLR2H2oR48etZ7zqu3duzfkl+59+/bB7/cHBxh37doVQgjk5uY2OimPpPj4+BrrN7jdbhw7dixkW33ncgBISUkJa//du3cvxowZE7xvtVpx7NgxTJgwIaLvU5vG/u0bc8w29LuuWvU+dfJ5m6gax1hQDX/729+g1+sxffp0FBcX13h8//79eOGFFwAgeEI9dbad6l8+wpkZKS8vD127dsUzzzwTnMbzZKWlpXU+t/pXsJN/9XK73XjllVdqxOr1+lq7Rl111VU4cuQI3njjjRqPORwO2Gw2AMD48eMBAC+++GJITCQX3ZswYQKKiorwwQcfBLd5vV4sWrQIMTExGDVqFIDA1KIejyekzH6/v8ELfun1+hZbgKmh+87YsWOhVCqxaNGikL9nbfV71VVXYd26dfjuu+9qPFZVVRXSj7+hRo4cCZfLhYULF2LEiBHBL96RI0di6dKlOHr0aIPGVzRX3c6bNw/l5eWYPn16rZ/v+++/x1dffQWg4fvRqeRyOa644gp88skntbZm1ncsNlZtx67JZMI777wTsfdoqKbWV7WUlBSMHj0ar732Wo2LYCC03srLy0Mei4mJQbdu3UKm+6xe46Ch+9GwYcOwbdu2WqcMBVDjvLBo0SIAJ85pl19+OeRyOebNm1ejBUEIUaPMzaVr1641xke9/vrrNVos6qqfcePGwWAw4PHHH691TZeG7r+vv/56yPNfffVVeL3eYH1F6n1q09i/fWOO2YZ+11XbuHEjJEk67Q+P1DGxxYJq6Nq1K9577z1cffXV6NmzJ2688Ub06dMHbrcba9euDU63CAD9+vXDlClT8Prrrwe7H/3222949913MWnSpJBfdxpLJpPhzTffxPjx49G7d29MmzYNGRkZOHLkCFauXAmDwYAvv/yy1ucOHz4c8fHxmDJlCu666y5IkoSlS5fW2ryel5eHDz74ALNmzcLZZ5+NmJgYTJw4ETfccAM+/PBD3HbbbVi5ciXOOecc+Hw+7Nq1Cx9++GFwPY7+/fvj2muvxSuvvAKTyYThw4dj+fLlDW4lqLZ8+fJa55CfNGkSbrnlFrz22muYOnUqNm7ciJycHHz88cdYs2YNFi5cGBy8O2nSJAwePBh//etfsW/fPvTo0QNffPFFcL7x0/0alZeXh//973947rnnkJ6ejtzc3OAgy0hr6L6TnJyM++67DwsWLMAll1yCCRMmYPPmzfjmm29qNMXff//9+OKLL3DJJZcEpxy12Wz4448/8PHHH+PgwYONbr4fNmwYFAoFdu/eHZwqFgh0XaleW6EhiUVz1e3VV1+NP/74A/Pnz8fmzZtx7bXXIjs7G+Xl5fj222+xfPny4Cq5Dd2PavPEE09g5cqVGDJkCG6++Wb06tULFRUV2LRpE/73v/9FbE77Cy+8ECqVChMnTsStt94Kq9WKN954AykpKbVenDencOqr2ssvv4wRI0agb9++uPnmm9GlSxcUFxdj3bp1OHz4MLZu3QogMAh99OjRyMvLQ0JCAjZs2ICPP/4YM2bMCL5WXl4egMBEEePGjYNcLsc111xT53tfdtllePTRR/Hjjz/iwgsvrPF4fn4+Lr30Ulx00UVYt25dcMrsfv36AQh8Fzz22GOYPXs2Dh48iEmTJiE2Nhb5+fn49NNPccstt+C+++5rVJ02xfTp03HbbbfhiiuuwAUXXICtW7fiu+++q3Es9+/fH3K5HE8++SRMJhPUanVwPZRXX30VN9xwAwYOHIhrrrkGycnJKCgowLJly3DOOefgpZdeOm053G43zj//fFx11VXYvXs3XnnlFYwYMQKXXnopgEDreiTepzbVf/t//OMfuOaaa6BUKjFx4sR6F9Rr6DHb0O+6aj/88APOOeec4JgoohAtOQUVtS179uwRN998s8jJyREqlUrExsaKc845RyxatChkKkCPxyPmzZsncnNzhVKpFFlZWWL27NkhMUIEpgasbTrF6ukpP/roo1rLsXnzZnH55ZeLxMREoVarRXZ2trjqqqvE8uXLgzG1TTe7Zs0aMXToUKHVakV6err429/+Jr777rsa0xFarVZx3XXXibi4OAEgZOpLt9stnnzySdG7d2+hVqtFfHy8yMvLE/PmzRMmkykY53A4xF133SUSExOFXq8XEydOFIWFhY2abrau29KlS4UQQhQXF4tp06aJpKQkoVKpRN++fUOmj61WWloqrrvuOhEbGyuMRqOYOnWqWLNmjQAg3n///WBcbVOi7tq1S5x77rlCq9XWmMr1VHX93ar/FuvXrw/ZXv1+paWlwW0N3Xd8Pp+YN2+e6NSpk9BqtWL06NFi27ZtNaabFCIw5ePs2bNFt27dhEqlEklJSWL48OHimWeeCZkqsiF/m2pnn322ACB+/fXX4LbDhw8LACIrK6tGfGPqtrZ6EaL2fbo+y5cvF5dddplISUkRCoVCJCcni4kTJwanwqzW0P2otvopLi4Wd955p8jKyhJKpVKkpaWJ888/X7z++uvBmEjsF1988YU466yzhEajETk5OeLJJ58Ub7/9do36qOucMmrUKDFq1KjT1FjgM9555531xjSkvk43ZfT+/fvFjTfeKNLS0oRSqRQZGRnikksuER9//HEw5rHHHhODBw8WcXFxQqvVih49eoj58+eH7LNer1fMnDlTJCcnC0mSGjT17FlnnSVuuummkG3Vdb5jxw5x5ZVXitjYWBEfHy9mzJghHA5Hjdf45JNPxIgRI4Rerxd6vV706NFD3HnnnWL37t3BmFGjRonevXvXeG5dddOY/cTn84m///3vIikpSeh0OjFu3Dixb9++Wo//N954Q3Tp0kXI5fIa5/qVK1eKcePGCaPRKDQajejatauYOnWq2LBhQ711WF2mH3/8Udxyyy0iPj5exMTEiMmTJ4vy8vIa8Q15nylTpgi9Xl/v+57q0UcfFRkZGUImk4UcC/Xtxw05ZoVo+HddVVWVUKlU4s0332xU2anjkISIwgg3ImpRn332Gf70pz/h559/xjnnnBPt4hBRC1m6dCnuvPNOFBQUBBezmzt3LubNm4fS0lIOwG2AJUuWYNq0aVi/fn3IL/cd0cKFC/HUU09h//799Q7Wp46LYyyI2hmHwxFy3+fzYdGiRTAYDBg4cGCUSkVE0TB58mR07ty5weOsiOri8Xjw3HPP4aGHHmJSQXXiGAuidmbmzJlwOBwYNmwYXC4X/vvf/2Lt2rV4/PHH+WVA1MHIZLJGTx9OVBulUomCgoJoF4NaOSYWRO3Meeedh2effRZfffUVnE4nunXrhkWLFoUMAiUiIiKKNI6xICIiIiKisHGMBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERNbvrr78eGo0Ge/bsqfHYE088AUmS8NVXXwEAPvjgA1x//fXo3r07JEnC6NGjW7i0RETUFJIQQkS7EERE1L6VlJSgR48e6N+/P1asWBHcnp+fj969e2PChAn4+OOPAQCjR4/Gxo0bcfbZZ2PLli0466yzsGrVqiiVnIiIGootFkRE1OxSUlLw5JNPYuXKlXj33XeD2++44w4olUq88MILwW1Lly6FyWTCihUrkJ6eHo3iEhFREzCxICKiFjF9+nScc845uO+++1BeXo73338f3377LR577DFkZGQE47KysiCT8euJiKitYVcoIiJqMdu3b8eAAQMwadIk/PTTT8jMzMSvv/5aZyLRp08fJCUlsSsUEVEboIh2AYiIqOPo3bs37rvvPixYsAByuRzLli1j6wQRUTvBszkREbWopKQkAEB6ejr69OkT5dIQEVGkMLEgIqIWU1hYiDlz5qBPnz4oLCzEU089Fe0iERFRhDCxICKiFjNjxgwAwDfffIM///nPmD9/Pg4cOBDlUhERUSQwsSAiohbx6aef4osvvsCjjz6KzMxMLFy4ECqVCnfeeWe0i0ZERBHAxIKIiJqdxWLBXXfdhQEDBmDmzJkAAmMsHn30UXz77bf46KOPolxCIiIKF6ebJSKiZnf33XfjpZdewi+//IKzzz47uN3n82Hw4MEoKirCrl27EBsbi9WrV2P16tUAgEWLFkGn0+Gmm24CAJx77rk499xzo/IZiIiofkwsiIioWW3cuBFDhgzB7bffjkWLFtV4fP369Rg6dChmzJiBF154AXPnzsW8efNqfa05c+Zg7ty5zVxiIiJqCiYWREREREQUNo6xICIiIiKisDGxICIiIiKisDGxICIiIiKisDGxICIiIiKisDGxICIiIiKisCmiXYCW5vf7cfToUcTGxkKSpGgXh4iIiIio1RJCwGKxID09HTJZ/W0SHS6xOHr0KLKysqJdDCIiIiKiNqOwsBCZmZn1xnS4xCI2NhZAoHIMBkOUS0NERERE1HqZzWZkZWUFr6Hr0+ESi+ruTwaDgYkFEREREVEDNGQIQVQHb69evRoTJ05Eeno6JEnCZ599dtrnrFq1CgMHDoRarUa3bt2wZMmSZi8nERERERHVL6qJhc1mQ79+/fDyyy83KD4/Px8XX3wxxowZgy1btuCee+7B9OnT8d133zVzSYmIiIiIqD5R7Qo1fvx4jB8/vsHxixcvRm5uLp599lkAQM+ePfHzzz/j+eefx7hx42p9jsvlgsvlCt43m83hFZqIiIiIiGpoU2Ms1q1bh7Fjx4ZsGzduHO655546n7NgwQLMmzevmUtGLcXvF7C5vbA4vai0uWFxeSFEtEtFRJESq1EgK14Ho04Z7aIQUSvk8/ng8XiiXYxm5/X5YXd7YXP5YHJ4kGbUIE6napb3UiqVkMvlEXmtNpVYFBUVITU1NWRbamoqzGYzHA4HtFptjefMnj0bs2bNCt6vHtlObYfL64PV6YXZ4UGp1QWbywu3T0AhSVArI3MgEFHrcLTKgTKLC5kJWmTE6aBV8RgnosBaCkVFRaiqqop2UZqNXwgIEfjX7xcQQPDH0zK7DJWy5lt/LS4uDmlpaWGv8damEoumUKvVUKvV0S4GNYIQAlaXF1aXFxVWNyrtbjg8Pvj9gFYlR6xGCbWCFxtE7ZFRq4Td7cW+EiuKzS5kJ+qQZtBAIY/qkEAiirLqpCIlJQU6na5dLHIshIDPL+A/6V+/ACQAkgTIjn9Gr19Ao5BDqYj8eVAIAbvdjpKSEgBAp06dwnq9NpVYpKWlobi4OGRbcXExDAZDra0V1Ha4vX5YnB5YnB6UWt2wOj1wef1QymTQqRVIjlFC3oyZOhG1HjqVAlqlHCaHB9uOmFBkciI7UY+kGFW7uJggosbx+XzBpCIxMTHaxQmL3y/gO55I+HwCflmgZUIhB2QyCbWd4mQ+AY2yeRILAMFr6JKSEqSkpITVLapNJRbDhg3D119/HbLthx9+wLBhw6JUImoqIQRsbh8sTg8q7W5U2DxwuL3wCwGtQoFYjRJJbJUg6rAkSUKcToVYjRLlNhe2FlYhzahBVoIORi3HXxB1JNVjKnQ6XZRL0ngnt0p4fYGk4uRWCYVMCtyJsuq69Xg8bTexsFqt2LdvX/B+fn4+tmzZgoSEBHTu3BmzZ8/GkSNH8H//938AgNtuuw0vvfQS/va3v+Evf/kLVqxYgQ8//BDLli2L1kegRnB7/bC6vDA73CizumF1euHy+iCXyaBXKZAco2GrBBGFkMskpMRq4PL6cKTKgTKrC1nxOmTEa6HhGCuiDqWttFie3Crh9QWSCgEBGSRIMgnKVtizM1J1G9XEYsOGDRgzZkzwfvUg6ylTpmDJkiU4duwYCgoKgo/n5uZi2bJluPfee/HCCy8gMzMTb775Zp1TzVJ0CSFgd/tgcXpRYXcFWiVcPvjhh1ahgF6tQGIMx78Q0empFXKkG7WwubzYW2JBsdmJ7CQ9UmPVHH9BRFEV0irhP/F/CYGuTXKZ1GaSonBJQnSsyTrNZjOMRiNMJhMMBkO0i9PueHx+WJzewFgJiyvQKuHzQS4FWiW0KjlbJYgoLEIIVDk8sLt9SI5VITtRj0Q9x18QtVdOpxP5+fnIzc2FRqOJdnEAnNIq4a+exSmQTMhkEiJ5qePxCeiacYwFUH8dN+bamT/zUFiEELC5vCgyObHzmBm/5Vdg48FK7Dxmhs3lg16tQLpRh1SDBjEaBZMKIgqbJEmI16mQZtCgyubBloIq7DxmhtnZ/ue2J6LoEELA6/fD7fUF1pdwe2F3e+H2+iGEgFwmQSmXQSFvXFJx6OBB6NVKbN26pcHPWbJkCeLi4hr9GVpCmxq8Ta2Dx+eH1RlYpK7U6oTl+FgJmSSDXiVHcqyaCQQRNTu5TEKKITD+orDCgVKLC1kJOqTHcfwFEYXvdK0SSl7r1MDEgk5LCAGHxxdc7brc5obD7YPPL6BWyKBXK5CgYzcEIooOtUKO9DgtrC4v9hRbUGJ2oXNioKWUP3IQUUMJcXzWJj/g9fuDYyWAQCtERxor0VTsCkW18vr8qLS5UVhhx+bCSvyWX4EthVUorHRAApAUo0Z6nBaJMWpolHIeaEQUdTFqBToZtXB7/fj9cBV+P1yFcqsLHWwoIVHHYrPVfXM6Txvrt1jhMVvgNFthc/tgd/ng8HjhNVsh2e1QOh1QOu2QO+yQ7LYmFfH7777D2DGjkJ6ShKxOqbhi0mU4sH9/rbGrf/wRerUS3379NQbnDUCCIQZjR43Atm3basR+99136NmzJ2JiYnDRRRfh2LFjwcfWr1+PCy64AElJSTAajRg1ahQ2bdrUpPI3BhMLAlA9g5MXxWYndhcdHytxqBLbj5phtnuhVynQyaBBmkGDWA0XqyOi1kkmSYjXq5Aaq0G51Y3NhVXYWWSGheMviNqnmJi6b1dcERqbklIjRmaIhdJogOKSi0PGSsT27I6YxDjoEkJvTWG32zDz7nvw09pf8NW330Emk+Gaq66E3++v8zn/mP0AFjz5NFavXYfEpCRc/qfLgut5BF7TjmeeeQZLly7F6tWrUVBQgPvuuy/4uMViwZQpU/Dzzz/jl19+Qffu3TFhwgRYLJYmfYaGYleoDszrC6wrYXF6UWZ1wezwwOHxQy5J0KnkSNSrOI0jEbVJCrkMqQYNnB4fCivsKLW4kJ2gQ6c4LdRcfJOoQ6keK6FA3WvRVU8L2xwm/enykPuvvv4GsjM6YefOHYjRx9T6nNkPPYTzx44FACx+42306p6LTz/9FFdddRWAwEJ2ixcvRteuXQEAM2bMwCOPPBJ8/nnnnRfyeq+//jri4uLw448/4pJLLonYZzsVE4sOxnF8tesquwdlVhfsbh+8fgGNQgadSoF4nYzdmoio3dAo5Ug36mB1erGryIoiswvZiTqkxHL8BVG7YLXW2CREYGyET5LD6/YeHysB4NARyKRAy2aNSx1Z6A+pjj37ECn79u7Fo4/Mw4bffkN5eVmwpaKwoBA9e/as9TlDhgwN/j8+IQFnnHEmdu7cGdym0+mCSQUAdOrUCSUlJcH7xcXFeOihh7Bq1SqUlJTA5/PBbreHrA/XHJhYtHO1tUo4vYFWCa2SrRJE1DHEaBTQqeWosnvwe2EVUg0adE7UI16n5I8pRG2ZXg8AgUTi+MxN1YvUCQCST0AmSVDKARhqbx2o73Uj4c+X/wlZnTvjpVcXo1OnTvALP84e0B8et7vJr6lUKkPuS5IUMp5sypQpKC8vxwsvvIDs7Gyo1WoMGzYM7jDesyGYWLRD1a0SJocHZRY3bG4vvH4/NAo5WyWIqMOSSRIS9Cp4fAqUWd0ot7uRYdQiK0EHvZpfh0RtSbBVwg/4/P7AdLDHr6tPzOAU3TICQHl5Ofbs2Y2XXl2Mc0aMAACsXfPzaZ/322+/IqtzZwBAVWUl9u7dU2frRm3WrFmDV155BRMmTAAAFBYWoqysrAmfoHF4Jm0HfH4Bq9MLs9ODCpsbVQ43nB4/ZBKgVSqQoFdByVYJIiIAgPKk8RcHy20osQS6R3UyaqFqxpVtiSg8fiHg9fmD60oEWyUQ+OFAKUPdgyiiJD4+HomJiXj7rTeQlpaGwsJCPPzQg6d93oL585GQkIiU1BTM+ec/kZSUhEmTJjX4fbt3746lS5di0KBBMJvNuP/++6HVasP4JA3DM2gb5fT4UGJxYm+xBesPVmD9oQpsP2pChc0NjUJ+fAYnLYxaJZMKIqJaaJRyZMTpoJBJ2HnMjE0FlSgyOeH3c3paotZACAGL04MSixMerx8Otxd2tw9Orx/+4AxOUmC161aYVACATCbDkqX/xpZNm3H2wP74+/1/xfwFT572eY8+Nh/3/3UWRgwdgpLiYvz308+hUqka/L5vvfUWKisrMXDgQNxwww246667kJKSEs5HaRBJdLAJvs1mM4xGI0wmEwwGQ7SL02DVrRIWlwfl1uOtEm4fZDIJWqUCOpWcCQQRURP5hUClzQ23zx8Yf5GgQ7y+4V/iRBQZbq8fFqcHFqcHpVY3rE4PvG4XkmBG5+wcaDWaVplARMrqH3/E+AvH4khxKeLi4gAAHp+ATimHshlbVJ1OJ/Lz85GbmwuNRhPyWGOundkVqhVzenwwOz0wOzwos7phdQXGSqjlcuhUcsRrudo1EVEkyCQJiTFqeHx+lFpcKLe5kBmnQ0a8luMviJqREAK242NDK21uVNg9cLi98AsBrUKBWI0SKo0MwmKBTEK7TiraA54tWxGfXxyfwSnQKmFyBA4uSZKgUymQoONYCSKi5lQ9/sLh9uFAmQ0lFic6J+iQxvEXRBHj9gZmrDQ73Ci1umFzeuHy+iCXyaBXKZAcEzodtPD6olhaagwmFlHm9PhgcXphcrhRZg3M4OTx+aGSyaFXy2HUaiFjqwQRUYvSquTIUGlhcniw85gZRWYnshP1SI5RQ8b1L4gapbpVwur0osLuQoXNA4fLBz/80CoU0KsVSIxRR7uYrcK5o0bB5vKcPrCVYmIRBX6/QJHZiVKLC2anBw53IBPXKgPdm9gqQUTUOhi1SsSoFaiyu7G1sAppxsD4izgdx1+0V36/gNXthd3lQ2DOIQqH2xvoXmh1euHy+SCXjrdKxKq5SGU7xMQiCuweH/YUW+D1CcSoFTAYlGyVICJqpeSyE+Mvis1OlFtdyIwPjL/Qqfg12h64vMd7D9g9KLO6Ar0HvH6OY4wAAQFNdauEMrxWiQ4231CLql4NPFw8I0aJEILrSxARtSFKuQxpBi3sbi/2l1hRbHEhO0GHNKOG5/I2xu8XsLm9sDi9KLe5YLJ7YHf7IBDoPWDUqDimpjWRK+EHUFJ0DAlJSVAqO1aLodcvIPPJ4WuGfVIIAbfbjdLSUshkskZNaVsbJhZERESNoFMpoFXKYXZ6sf2o6fj4Cx2S9Bx/0Zq5vIE+/maHB6VWF2wuL9w+AYUsMEFKKnsPtFqSJEFuSIPDVoFjR49FuzgtzicEVHJZs3Yd0+l06Ny5M2Sy8JIXJhZERESNJElScPxF5fHxF6kGDbIT9DDqlNEuHiHwS2xgpkUvKm1uVNrdgVYJERicH6tRQq2QR7uY1ECSXAF5bDIg/IC/Y80SVWFx4swUA5Jjm2eAu1wuh0KhiEjXPyYWRERETSSXSUiKUcPt9aPI5ESF1Y3MeC0y4nXQqnjR2tKqF1czOzwoswUWV3N5/VDKZNCpFUiJVXLAcBsmSRIgyQFZxzq2fDIflCp1jYXrWiMmFkRERGFSKWToZAyMv9hXenz8RaIOqQaOv2hOJy+uVmF1o/L4+k9CABpFoFUiia0SRC2GiQUREVGEVI+/MDk82HbEhCJTYP2LpBgVZxiKkLoWV1PIZNDVsrgaEbUcJhZEREQRJEkS4nQqxGqUqLC5saWwCp2MGmQl6GDUcvxFY9W6uJrbC78QXFyNqJVhYkFERNQM5DIJybGB8RdHqhwos7qQGa9FZrwOGiW759TH4/PD4gy0SpRZ3YHF1bw+yGXHF1djqwRRq8TEgoiIqBmpFDKkG7WwubzYW2xFidmF7CQ9UmPVUHD8BYBAq4TdHVikrsLuQqXNA7vLB5/wQ6tkqwRRW8HEgoiIqAXo1QroVHJUOTz447AJRbEqZCfqkajvmOMvPD5/YF0JpwelFhesruOtEpIMOpUcybFqtkoQtTFMLIiIiFqIJEmI16lg0AiU21yotFUhPU6DzAQdDJr2Pf6iulXC6gqsK1Fuc8Ph9sHnF9Ao5dCrFEjUs1WCqC1jYkFERNTC5DIJKbEauLw+FFY4UGpxITNeh4x4bbsaf+E9PlbC4vSi1OqE5fhYCZkkg14lR1IMWyWI2hMmFkRERFGiVsiRHqeF1eXF3hILSi0udD6+/kVbvOAWQsDh8QVXu66wBVa79voFNAoZ9GoFEnQds+sXUUfAxIKIiCjKYtQK6FVyVNk9+P1wFVINGnRO0CGhDYy/8PoC60oEWyUcXjg8fshlEnRKORL1Kg5SJ+ogwkos3G438vPz0bVrVygUzFGIiIiaSpIkxOtViPUpUGENjEFIj9MgK16H2FY2/sLu9sLq9KLS7ka5NbRVQqdSIF4na/UJERFFXpOyAbvdjpkzZ+Ldd98FAOzZswddunTBzJkzkZGRgQceeCCihSQiIuooFHIZUgwaOD0+FFbYUWpxITtBh05xWqgV0Rl/cXKrRJnVBbPDA4fHD4VMgpatEkR0XJPOArNnz8bWrVuxatUqaDSa4PaxY8figw8+iFjhiIiIOiqNUo50ow4qmRy7iqzYXFCFYyYHfH7RIu/vcPtQYnZiT5EF6/MrseFgJbYfNcFk90CrVCDdqEGqQQODVsmkgogANLHF4rPPPsMHH3yAoUOHhjR19u7dG/v3749Y4YjqI5dJUMgkeP2ixb5o2xvWYWSwHiOD9Vi7GI0COvXx8ReFx8dfJOoRr1NGtLuRzy+C60qUW90wOd1wevyQSxI0bJUgigq5TEKMWoG20rOwSYlFaWkpUlJSamy32WzsU0nNTq2QIU6vRJxWCZPDA6NWiSq7B1V2D1xef7SL1yawDiOD9RgZrMfTk0kSEvQqeH0KlNvcKLe7kWHUIjNBhxh108c4Otw+WFwemOyBZMLq9sLr80OjkEOrkiNe2/oHjxO1RyefF6vsKsTpVLC7vdCpWveY5iaVbtCgQVi2bBlmzpwJAMGTzptvvolhw4ZFrnREp1ArZMhM0GLxj/uxZO1BmB1eGLQKTBuei1tHdcHhCgcvRE6DdRgZrMfIYD02jkIuQ0psYPzFwXIbSiwuZCfqkGbUNGj8RXWrhMUVSCSqHIFF6uQyCVplYCpYJVsliKKqvvPiHaO7Qt2K17ppUmLx+OOPY/z48dixYwe8Xi9eeOEF7NixA2vXrsWPP/4Y6TISBcXplVj84368uHxfcJvZ4cULy/cCACYP6YxisytaxWsTWIeRwXqMDNZj02iUcmTE6WBxerDzmBnHTE7kJOqRHFtzwTmnxwez0wOzw4MyqxtWlxdevx9quRw6tkoQtTqnOy/eOqpLq225aFKpRowYgS1btuCJJ55A37598f3332PgwIFYt24d+vbtG+kyEgEI9DM0apVYsvZgrY+/szYft47qgstfWYNKu6dlC9dGxOuU+H7WKNZhmFiPkdGQerxzTFeUWd0cc1GHWI0SerUClTZ3yPoXMpkES/VYCYcHDrcXkiRBp2KrBFFrJpdJiDvNtc6dY7q1bKEaocnpTteuXfHGG29EsixENfj8AnuLLdhwqBIVNjcentgLZoe31lizw4sKmxt6tRKHq5wtXNK2ITNeh3Krm3UYJtZjZDSkHk0OLxQyiYlFPWSShMQYNTw+P0otLpTZAi08Ht+JVok4rZatEkStmMPtw9bDgZnfpo3Irfe8aHF6kBijbuESNkyTEouCgoJ6H+/cuXOTCkMEACaHBxsPVWLjoUpsLqiExRU4uBL0KiTGqGDQKmo94AxaBZJj1fjbuDPh8fEipDZKuYQUg5p1GCbWY2Q0pB5jNQqUmJmcNYRSLkOqQQOX1weZJLFVgqgVE0LgcKUDGw9VYsOhCmw/aobXL5CgV+G+cWee5rzYuhbMPFmTEoucnJx6f/nw+XxNLhB1PH4hsK/Eig0HK7DhUCX2lVhx8qWYXi3HgKx4DMqOR5XNg2nDc4P9DE82bXguTHYPUgyaGo/RCSYH6zASWI+RUV89ThmWg9V7SvHKqv2YPiIX2Yn6KJSw7YnWInpEVD+nx4ffD5uw4VAFNh6qRIkldPxYmkGDvOx4HK1y1Pv94vX7oWraUnTNrkmJxebNm0PuezwebN68Gc899xzmz58fkYJR+2Z2eLCpoBIbCyqx6VAlzM7QrLxLkh552fHIy45HjzRDcDCi1eXFraO6AAj0M6xtBhmqX5XNwzqMANZjZNRXjzeNyMWfF6/F7mIr7np/My7q0wnXDe4Mo7b1/lpHRFRNCIGjVc5gIrHtqCmkFVshk9Anw4hBx693MuICXRb9ftR5Xmzts0JJQoiItdMvW7YMTz/9NFatWhWpl4w4s9kMo9EIk8kEg8EQlTJYXV6szy+HUdtxBtD5hcD+Eis2FgRWb91TbAlpldCp5BiQFYe87HgM7Bxfb99BtUKGOJ0ScTolTA4vjFoF57xvJNZhZLAeI6O+ejxUbsfba/Kx7kA5gEAL5nWDO2NCn05crI2IWh2X14c/jpiw8WAlNhyqRNEpXTlTYtXIyw70wjgrMw6aOpKEk8+LVQ4P4rQqeP3+qMwG1Zhr54gmFvv27UO/fv1gs9ki9ZIRx8Si5VidXmwuDCQSmwoqUeUInR0nJ1GHvOwEDMqOR4+02EZfJHCV3vCxDiOD9RgZ9dXj74er8MZPB3Cw3A4AyIzX4qYRuRiUnRCNohIRBR2tCoyV2FhQiT8Om+D2nfhhSSGT0DvdcDyZSEBmfOMmUpDLJFTa3eiWEoPUKHWvbcy1c5PSHrPZHHJfCIFjx45h7ty56N69e1NektoBIQQOlNmw4fjA691FZpx8baBVytH/eKtEXnY8ksKc0cDHi7iwsQ4jg/UYGfXV41mZcVh49QD8sKMY//r1EA5XOjDvyx3Iy47HTSNykRWva+HSElFH5fb6se2I6XgvjAocNYW2SiTFnNwqYQyrlcHnF7C6vIhcM0DzatInjYuLq5FtCSGQlZWF999/PyIFo7bB6vJiS2EVNh7vP3jqnP2dE3TBvoM9OxnadQsNETUvuUzCRX3SMLJ7Et5fX4ivfj+KjYcqsaWwChf37YRrz+6MGE3rXDSKiNq2IrMzMIPTwQr8fsQE90ndXeUyCb06GYLXO50TdB12eucmnYFXrlwZcl8mkyE5ORndunWDQsGTensmhMDB8hOtEjuPhbZKaJQy9Ms80SqREstZcYgosvRqBW4akYvxfdLw1s/5+O1gBb7YehQrd5dg8pBsXNQ7rcbq00REjeHx+bH9qBkbDlZgY0ElDleGTsiRoFcFE4n+WXGtdiXslhbRMRZN9fLLL+Ppp59GUVER+vXrh0WLFmHw4MG1xi5ZsgTTpk0L2aZWq+F0Nmyec46xaDy7O9AqseFQYAancps75PGseG2w72CvdLZKEFHL2lRQiTd/zkdhRWD8RXaCDtNHdkH/rLjoFoyI2pQSsxMbCwI/nG49XAWn50SrhEwCenYyBLs45STqW6xV4qjJgX6ZcUgztqMxFl988UWDC3DppZc2OPaDDz7ArFmzsHjxYgwZMgQLFy7EuHHjsHv3bqSkpNT6HIPBgN27dwfvd9TmpuYihEBBhf34oi2V2HHMHNLvWaWQoV+mEYOyE5CXHR+1wURERAAwsHM8Fl0Th2+3HcO/fy3AoQo7/vn5NgzJTcBfzslFepw22kUkolbI4/Nj5zFzsBdGwfEfJ6rF65TBH077ZcUhRs1WidNpcIuFTNawX6ElSWrUAnlDhgzB2WefjZdeegkA4Pf7kZWVhZkzZ+KBBx6oEb9kyRLcc889qKqqatDru1wuuFwnFiAxm83Iyspii8UpqpeSrz64yqyhi7ZkxGmD3Zv6pBuhUrSOchMRnczi9OA/vxVg2R/H4BeBGVkm9kvH1YOyoOdFAVGHV2Z1BWZwOj4+y+E5cc0qk4Az0060SuQm6SFrBT9et8sWC78/8nOyu91ubNy4EbNnzw5uk8lkGDt2LNatW1fn86xWK7Kzs+H3+zFw4EA8/vjj6N27d62xCxYswLx58yJe9rauein56kVbqpeSr6aSy9A388SiLZ2M/MWPiFq/WI0St5zbFRf16YS3fj6ATQVV+HTzEazcVYLrh2ZjbM9Ujr8g6kC8Pj92FlmOJxMVwSmrq8VplRjYOR6DcgJjJWI1XIAzHFH9+aasrAw+nw+pqakh21NTU7Fr165an3PmmWfi7bffxllnnQWTyYRnnnkGw4cPx/bt25GZmVkjfvbs2Zg1a1bwfnWLRUcUWEr+RKvEqUvJdzJqgq0SfTOMUCta78qORET16Zygw9yJvbHhUCXe+jkfR6oceGnlPnz9xzHcPLIL+mQYo11EImom5VYXNhUEunNvKayC3X2iVUICcEZqLAblxCOvczy6psS0ilaJ9qLJiYXNZsOPP/6IgoICuN2hg3nvuuuusAtWl2HDhmHYsGHB+8OHD0fPnj3x2muv4dFHH60Rr1aroVaHt15CWyWEwJHji7ZsOFSJbUdMIa0SSrmEvhnGYP9B9kMmovZEkiScnZOA/llx+PqPY/jPbwU4UGbD7E//wDldEzH1nFykcYwYUZvn8wvsKjIHuzgdKAtdqNmgUWBgdiCRGNA5HkYtWyWaS5MSi82bN2PChAmw2+2w2WxISEhAWVkZdDodUlJSGpxYJCUlQS6Xo7i4OGR7cXEx0tLSGvQaSqUSAwYMwL59+xr9Odojp8eHbUdMwVaJ2paSH5QTWO26b4axzqXkiYjaC6Vchsv6Z2D0mSn496+H8N32IqzZX47fDlZgUv8MXJmXyakiidqYSps7OIPT5sJK2FyhrRLdU2OQ1zkeg3IS0DU5hl0gW0iTzqT33nsvJk6ciMWLF8NoNOKXX36BUqnE9ddfj7vvvrvBr6NSqZCXl4fly5dj0qRJAAJjOZYvX44ZM2Y06DV8Ph/++OMPTJgwoSkfpV04WuUIJhLbjtRcSr7P8VaJvOx4ZMY1bil5IqL2wqhV4o7R3TC+Tye8+fMB/H7YhI82HsbynSW4cVg2xvRIYZcIolbK5xfYU2w53gujAvtLQ1slYtUKDDg+VmIgWyWipkmJxZYtW/Daa69BJpNBLpfD5XKhS5cueOqppzBlyhRcfvnlDX6tWbNmYcqUKRg0aBAGDx6MhQsXwmazBdequPHGG5GRkYEFCxYAAB555BEMHToU3bp1Q1VVFZ5++mkcOnQI06dPb8pHaZOql5LfcKgCGw5V4tgpS8knx6qDg67PyoiDVsVWCSKiarlJejx2WR/8kl+Bd9bk45jJiYXL92LZ8fEXPTtFZ8ZAIgpVZXdjU0EVNh6qwOaCKlhc3pDHuyXHIC8nHoM6x6N7aixbJVqBJiUWSqUyOP1sSkoKCgoK0LNnTxiNRhQWFjbqta6++mqUlpbi4YcfRlFREfr3749vv/02OKC7oKAgZKrbyspK3HzzzSgqKkJ8fDzy8vKwdu1a9OrVqykfpc0oMjmx8XgicepS8gqZhF7phmCTX1Y8WyWIiOojSRKGdUnEoOx4fLH1KD5YX4i9JVb87ZPfcW73ZEwdnoPk2I45Po8oWnx+gX0l1uD1zr4SK05eE0GvlmNAVmAq2IGd4xGvV0WtrFS7Jq28feGFF2Lq1Km47rrrcPPNN+P333/HXXfdhaVLl6KyshK//vprc5Q1IlrLyts7jpqgUcjrTAA8vkCrRPXA6yNVoUvJJ8WokNc5Hnk5CeiXaWT/YCKiMFTa3Vj6yyH8b0cxBAILgV4xIAOXD8zkWLQOSC6ToJBJ8PpFyAKx1DgNqUeTw4PNx8dKbCqohNkZ2irRJUkfmGQmJwFndtBWiba0jkWTEosNGzbAYrFgzJgxKCkpwY033oi1a9eie/fuePvtt9GvX78mF765RTuxcLi9kMtkqLK7YdQpYbJ7UGX3wOX1B5eS33CwEr8fCV1KXi6T0DMtFoNyEpDXOR7ZiTq2ShARRdi+Eive/PkAth81Awj8iDNlWA5GnZHMc24HoFbIEKdXIk6rhMnhgVGrRNVJ39PUMPXVo8Pjw/4Sa3Bs6J5iS0irhE4lx4CsOOQdb5VIjGHLYbtPLNqyaCYWLo8Pr6zaj3fW5sPs8MKgVWDq8BzcNKIL7vz3Jvy8rywkPkGnQt7xeZb7Z8Vx1VgiohYghMCa/eV4Z01+cL2fHmmxuHlkF5yRGhvl0lFzUStkyEzQYvGP+7Fk7cHg9/S04bm4dVQXHK5wMLlogLrqcerwHNx0Ti6mvrMemwurQp6Tk6hDXnZgxsoeabFQyGW1v3gH1e4Ti8ceewyTJ09Gbm5ukwsZLdFKLBxuLxb/eAAvLN9b47GZ53VD3wwjbvvXRvRIM2BQdmBWg5xEPX8hIyKKEpfXh8+2HMXHGwuDLcjnnZmCG4dl81fUdijVqMa/fjmEF5fXnL7+rvO74YKeqfhgw+EolKxtuXpQJn7YUYwXV9Ssx+rrnbvf34L+x1sl8rLjkcTjqV7tPrHo168ftm3bhiFDhuD666/HVVddhaSkpCYXuCVFK7Fwe/0YNP8HmB3eGo8ZtAr89uBY/FFogoYzOBERtSrlVhf+b90hrNhdAgDQKGW4Mi8Lk/qnQ63gObut8/kF8susGN+3EwY//r86v6d/mX0+Rjy5EhU2dy2vQgCQoFfh57+PwdAFy+usx/UPjsXuIgt/OG2EtpRYNKlvzdatW7F9+3b8+9//xjPPPIN77rkHF1xwASZPnoxJkyZBp9M1qeDtmcXpqfUgAwCzwwuL0wujTslmViKiViYxRo17LzgDF5/VCW/8dAC7iiz41y+H8P32Ikw7JxfndE3kRVIbU2FzY9OhSmwoqMSWgkpkxuswKCeh3u9pk92Dy/ql4+gpk6nQCelxWlTZ67/eMTu90CjlvN5pp5rcab937954/PHH8fjjj2PNmjV47733cM899+C2226D2WyOZBnbhViNEgatos4M3qhVoPR4X14iImp9zkiNxVNXnIUf95Ti3XUHUWJx4clvd6F3ugE3j+yCrskx0S4i1aF6cbUNxxdXO3DK4moOjxdJMep6v6cTY1T486AszhJVD7lMQlKMitc7HVhERgPr9XpotVqoVCpYLJZIvGS74/P7MW14bq1jLKYNz0WV3cOTFRFRKydJEkafmYKhXRLx302H8cnmI9h+1Ix7P9iCsb1SccPQbMTrOLd+axBYXC0wZfvmgipYT11cLSUmuJhs95RYWFwefk+HyecXqHKwHjuyJicW+fn5eO+99/Dee+9h9+7dGDVqFObNm4crr7wykuVrN7QqBe4Y3RUAQmaFOnm2CSIiahs0SjmuG5KNC3qlYcnag1i9txQ/7CjGz3vLcPXZWbi0XzqUnNmmRfn8AntLLMH1n/aVWEMej1ErMLBzYMDwgM7xNRLAKpsHt47qAoDf0+FgPXZsTRq8PXToUKxfvx5nnXUWJk+ejGuvvRYZGRnNUb6Ii/Y6Fna3FwqZDFUON4za0HUsiIiobdp5zIzXfzoQvJjtZNRg2jm5GJqbwPEXzah6cbUNxxdXs5yyuFrXZH1wGtMzGrC4mlohQ5xOiTidEiaHF0atgutYNAHrMbLa0uDtJiUW//jHPzB58mT06tUL1U9vKyfOaCcWQMNW3iYiorbFLwRW7irB/607hAp7YOagfplGTB/RBTlJ+iiXrn3wC4F9JVZsrGNxNb1Kjv6d4wNdnDrHI17ftG5pXHk7MliPkdHuEwsAeOutt/D8889j795AH7ru3bvjnnvuwfTp05vyci2mtSQW6/PLYdSq2FRORNTOONw+fLSxEJ9tOQKPT0AmAeN6p2HykGwYtcpoF6/NMTs82FxYhY2HKrCpoAomhyfk8dwkfXCsRI80w2lbJYjamraUWDRpjMXDDz+M5557DjNnzsSwYcMAAOvWrcO9996LgoICPPLII015WSIiojZPq5LjxmE5uLB3Gpasycea/eX4ZlsRVu8pxTWDO+Pivp34o1I9/ELgQKkNGw9VYMPxVomTf+zWKuUYcHysRF7neC5WSNSKNKnFIjk5GS+++CKuvfbakO3/+c9/MHPmTJSVlUWsgJHGFgsiImpJfxwx4Y2fDiC/LDDFaUacFtNH5GJQTkKUS9Z6WJ1ebC48MVaiyh7aKpGdoMOgnEAi0bOTAQp+d1IH0u5bLDweDwYNGlRje15eHrze2hdFISIi6oj6Zhjx/FX98b+dxfjXL4dwpMqBeV/twMDO8Zg+IhdZCR1vUVkhBPLLbNhwfKzEriJzjVaJfllG5HVOQF52PJJj2SpB1BY0KbG44YYb8Oqrr+K5554L2f76669j8uTJESkYERFReyGXSRjXOw0juiXhgw2F+HLrUWwqqMSM/1RiQt9OuG5wZ8Rq2vf4C5vLiy2FVcGB19UD3KtlJeiQ1zkeg3Li0auTgS36RG1Qk9exeOutt/D9999j6NChAIBff/0VBQUFuPHGGzFr1qxg3KnJBxERUUelVyvwl3NycVHvNLy9Jh+/5lfgq9+P4cfdpbhuSGeM79Op3Qw+FkLgYLn9+LoSFdhVZAmZGUitkKFfZlywi1OKITrdPIgocpo0xmLMmDENe3FJwooVKxpdqObEMRZERNRabCmswhs/HUBBhR1A4Ff7m0fkYkDn+CiXrGnsbi+2FlYFuziV20JbJTLitMEZnPpkGPkdSNQAbWmMRZOnm22rmFgQEVFr4vMLfLu9CP/+9VBwgbfBOQm4aUQu0uO0US5d/YQQKKiwB7s3bT9mDmmVUClkOCvDeDyZSIjahRFRW9aWEosmd4UiIiKi8MllEi7u2wmjuifjP+sLsOyPY/jtYAU2FVTikrPScfXZWYhRt56va4fbh62Hj4+VKKhEqcUV8ni6UYO87HgMyk5A7wwD1Ap5lEpKRC2t9ZypiIiIOrAYjQI3j+yCi/qk4a2f87HxUCU+23IEK3eXYPKQzriwV1pUxl8IIXC4yoGNBwOJxLYjJnhPbpWQy9An2CoR3+pbWYio+TCxICIiakWy4nWYO7E3NhyqwFs/5+NwpQOvrNqPb7YV4eYRueibGdfsZXB6fPj9sAkbCyqx4WAFSk5plUgzaELGSmiUbJUgIiYWRERErdKg7AT0z4zD19uO4b3fCpBfZsODn23DsC6J+Ms5uRHtby2EwNEqJzYWVGDDwUpsO2qCx3eiVUIhk9A3wxhY7To7HhlxWkhS+5i9iogih4kFERFRK6WQy3BpvwyMOiMF7/1WgG+3HcO6A+VYf7ACk/pn4M+DMqFTnfgql8skKGQSvH4RMoi6Ni6vD38cMQW7OB0zOUMeT4lVB8dKnJXJVgkiOj0mFkRERK2cUavE7aO6YkKfNLz5cz62FFbh402HsXxXMW4cmoPxfdOQEKNCnFYJk8MDo1aJKrsHVXYPXF5/8HWOmRzYcDyR+OOwCW7ficcUMgm90w3BZCIznq0SRNQ4TCyIiIjaiOxEPR65tDd+OxgYf3HM5MRXfxzD1HNy8M7afCxZexBmhxcGrQLThufi1lFd8P22YqzYXYINBytw9JRWiaSY6laJeJyVaQxp/SAiaiyeQYiIiNoQSZIwJDcRAzvH48utRzGiexLeXpOPRSv2BWPMDi9eWL4XfiHQN8OIL7YeBRDoKtWrkyE48Lpzgo6tEkQUMUwsqM3y+QW8fv/pA4mozZBLEhRcOLRBlHIZ/jwoC11T9Lj3wy21xry77iB+mX0+Lh+QgTPTYtE/K46tEkTUbHh2oTbF5fXB7vbB4fZBJgNXLidqZ7y+wA8GGoUcWpUcWqWcv6jXQyGTYHZ4YHZ4a33c7PDC5vLhtlFdQ8ZaEFHrJYSAwxO43nF5fdAo5IjCEjZNwsSCWjW/ELC7fbC7vPAKAZVcgl6tQFa8FgatEloVZykhak/cXj8sTi/KrC6YnR5UOTyQSxI0Sjn0KjlbM07h9QsYtUoYtIpakwuDVgGjVlFjdWwial08Pn/gh1OPF34BaJQyJOhVSNCrYNAoEatpG5fsbaOU1KG4vX7Y3F443D5IEqBTyZFq1CBBr0KsRgG9SgFZW0ndiahRdCogTqdCVoIODrcPFmdgZqNyqxvlNjd8QkAtl0GnUkCjlHX41gyfX6DK4cG04bl4YfneGo9PG56LKrvntFPPElHLEkLA6fHD7vbC6fVBIZNBr1IgJ1EPo1aJWE3b/PGUiQVFnV8IONw+2NxeeP0CSrmEmOOtErHaQJauVrS9g4uIwqNVBbpDpRg08Pr8sLq8J1ozHB5U2P2QSxJ0Kjl0Hbg1o8rmwa2jugAA3lmbX2NWqMMVjiiXkIgAwOvzw+b2wenxwScENAoZjDolusbEIFajQIxa0ebPY5IQokP9jGE2m2E0GmEymWAwGKJSBqvLi/X55TBqVR12jIDbG8jS7R4fJAQuIOJ0SiTq1YjRKBDDVgkiqkN1/2OL04squxvlVjfsbh+8/sAXdUdszVArZIjTKRGnU8Lk8MKoVdS6jgURtZzQVgk/FDIJepUCiTEqxOnaTqtEY66d2WJBLSKkVcInoFRI0KkU6BanhVGnRIxawVVdiahBJClw/tCpFEg93pphcXphdXlRanXC7PCi0uGHTJKgU8qhVysgb+c/VLi8fhSbXSizuqGQSSi1uNj9iSgKvMfHStjdgVYJrbK6VULdblol6sPEgpqNx+eHzRXaKpEcq0Zi9cHFVgkiigCFXIZ4vQrxehUy47XB1oxKmxsVNjfKrIGLbLVCBr1aAbWi/bZm+PyCCQVRCxJCwOUNXO9Ut0roVHJ0TtQiThcYG9qRZrdjYkER4xcCTo8PNpcPHp8fCkWgya9rnAZGbeDgYqsEETWnU1szPD4/rM7A2IxSqxMWpxcVdh9kkgx6lRw6VftvzSCiyPL5RfCHU78I/GgRq1Wga6wGMWoFYjXtu1WiPkwsKCyeYJNfYJpDjVKOxBgVkmLViFEHmvz4pU1E0aI8qTUjK0ELu/t4a4Y90JpRanHBJ/zQKhXQqeT88YOIaji5VcLl9UN+vFUiK16LeH3Ha5WoDxMLapSQRVt8PijlgenRuiTr2SpBRK2aJAXWwdGrFUgzBlozLE4vLE4PSi0uWJ1eVNhdkEuy4zNN8YcRoo7K5xewu72wuX3wCz/UCjlitQp0idEEunNrFB12Ap76MLGg0zq5VUIIAa1KgQS9CokxKsRqlGyVIKI2SSk/sQBV5wRdsDWjwu5CpS2QbPjhh0bB1gyijsB5/IdTh8cb+IFBLUdmvBbxx8dK6FRslTgdJhZUw6mtEgqZDDFqBXKT9DDqlDBolPyCJaJ25dTWDLc3sG6G2eFGmdUdaM2wuSA/voiVViXnDypEbVx1q0RgBic/1HI5YjQK5CTpEHt8tWu2SjQOEwsCcMpS8n4BjUp+olVCrUSMhq0SRNRxqBQyJCgCrRnZiQK246uAB8ZmeFBqdcIvBLQKBXRqORfxJGojqlslnF4vZAi0SqTHa5CgU7NVIgKYWHRQ1a0SDrcvsJS8XAa98vhS8jolYtVtY9EWIqLmJklScDKKTkYt3F4/LE5PYGyG1Q2L04NyrwsKWWBxPrZmELUePv+JdbR8/sBYiRiNAtmJWhi0KsSoFVAp2CoRKUwsOpDqpeQdHi/8AtAoZYjTBVolDBq2ShARNYRKIUNiTGBNnuxEAasrsDhfhdWNSsfx1gw/oFXK2ZpBFAUurw92lw8OrxcySYJWpUB6vOb4WAkl9GyVaDZMLNqx0KXkA2Ml9CoFshP0bWopeSKi1kqSpON9sZXoZNTC5fXB6vTC7PCgzHa8NcPnhkKSoFMHpqTkDzhEkVXdKmF3e+H1+6FSyBCjUaJzojZ4fLJVomV03MTCZgPktVxUy+WARhMaVxeZDNBqmxQrc9ghEx5ItQ0KkiQIre7EXYcdEHWspHpKrM9mg8PpgcPjg18AaoWEeK0SiUY1YjQKxCQYTyza4nAANn/dZdbrT/zf6QR8vsjE6nRA9S8FLhfg9UYmVqsN1DMAuN2AxxOZWI3mxL7SmFiPJxBfF7UaUCgaH+v1BuqiLioVoFQ2PtbnC/zt6qJUBuIbG+v3B/a1SMQqFIG6AALHhN0emdjGHPctdI6Avf7jHjpd02IdjkA91+XkY7kxsTxHAADUfh/UkheJOgnZGhVsbhmsx9fNqLI6UCIpIWRyaFVy6CUBtai7vEIVeo6QPHWfI0JivV5I7rqPe6EMPUc0ONbng+Sq57hXKCFOOkc0ONbvh+Ss77hvRKxcAXHScS856jvuGxErk0OcdNxL9vqO5UbESjKIk477RsU24tqgcbEOQNR93AudvmmxTifgr/u4b1SsVgeXzw+7ywenzQ653wetUoZOusC4KP3xrouSJAE6Vas6R7TJ64j6vrtOJToYk8kkAAhT4BCreZswIfQJOl3tcYAQo0aFxiYl1R07aFAwzOL0CHt6Zp2xjjN6iN8Lq4I3xxk96ox1ZWaJX/eXi5U7i8U3fxwTVb371V2GpKTQ8o4aVXesThcaO2FC3bGn7kZXXll/rNV6InbKlPpjS0pOxN5xR/2x+fknYu+7r/7YbdtOxM6ZU3/sb7+diH3qqfpjV648EfvSS/XHfvXVidh33qk/9sMPT8R++GH9se+8cyL2q6/qj33ppROxK1fWH/vUUydif/ut/tg5c07EbttWf+x9952Izc+vP/aOO07ElpTUHztlyolYq7X+2CuvFCHqi22Bc4QQQojs7Lpje/UKje3Vq+7Y7OzQ2EGD6o7lOeLErZnOEVVffycOlFjErwfKxK6HHq83Nn/JB8HvgYJnX6439uCrS4KxB19dUm9swbMvB2Pzl3xQb+zhR58Oxu7/8Mt6Y4/+45Fg7N4vV9QbW3Tv34Oxu/+3rt7YkltnBmN3rt1ab2zZjdODsdu37Ks3tuLKa4Oxf+w+Uv/f7eLLQr6X64s1nXdhSKxPW/c5wjL0nJBYT0JinbG2swaExLoys+qMbex1xMmxtrMG1BnrSUgMibUMPafOWJ9WFxJrOu/Ceuvt5Niqiy+rN/aH3/aLFTuLxG/55cJ89XX1xra1c0RrvI4wAQKAMJlM4nQ6botFO+HzCzg8Xhh0CnSN0UCv5p+UiKi1MmpVMCbHIDtRD1ei/vRPIKIaeqcbEJNohF6lgEyjjHZx6CSSEEJEuxAtyWw2w2g0wnT0KAwGQ82AFujmYHV5sXFHIYwa5YluSSc7pVkSdhvcHt/xpeQF5DJAp5IjXq9CnF6N2ATDiaXk2c0h8H82YTY+ll2hTtxnV6jGx/Ic0fjYk457lzewOJ/Z7kG5zQWb2wu3TAW5WhlYN0PyQ+6t+3XZFeo4doU6/mDb7ArlF4GxEg6LFT6PDwo5EKNWIEmvRow2sK6EWiHvkOeIWrXQdYS5tBTG9HSYTKbar51P0nETiwZUTnOxurxYn18Oo1ZV58IroUvJC6gVMsRqFEjmUvJERO2a3y9gdXthcXpRbnXB5PDA7g5ckOmUcujVPP9T++H2+mFze+Hw+CAB0KrkiNMpkag/PjZUpYCMEx5EVWOunVvFmenll19GTk4ONBoNhgwZgt9++63e+I8++gg9evSARqNB37598fXXX7dQSZuX0+NDhc2No1UOlFldEACy4rXonxWHs3MSMLBzPDon6hCvrzshISKitk0mk2DQKJERp8VZmSfO/92SY6BUyFDpCHxPlFpcsLu98Hes3wepjfMLAZvLixKLE0erHDA53VArZOiWHIOB2fEYnJuAvhlxSI/TwqBRMqloY6LeIf+DDz7ArFmzsHjxYgwZMgQLFy7EuHHjsHv3bqSkpNSIX7t2La699losWLAAl1xyCd577z1MmjQJmzZtQp8+faLwCZrO5xdwejwnlpJXyBGjDiwlX72uBBMIIqKOTaOUQ6OUIzlWjdwkPSzH180oswRaM0yOQLcKLVszqJXy+Pywubywe463vKkC+3NiTGC1a7ZKtB9R7wo1ZMgQnH322XjppZcAAH6/H1lZWZg5cyYeeOCBGvFXX301bDYbvvrqq+C2oUOHon///li8eHGNeJfLBddJ/cjMZjOysrKi3hVq48EKuL0COrUc8Xoll5InIqJGc3oCYzNMDjfKrG7Y3F54fH5I4PcItRICUCgk6FUKJMeoYTg+VkKj5DpabUVjukJFtcXC7XZj48aNmD17dnCbTCbD2LFjsW7dulqfs27dOsyaNStk27hx4/DZZ5/VGr9gwQLMmzcvYmWOBK1Sjm6psdAq5YhlqwQRETVRaGvGiVXAfT52j6LWQS6XEKNWIFbNVomOIKqJRVlZGXw+H1JTU0O2p6amYteuXbU+p6ioqNb4oqKiWuNnz54dkohUt1hEk1wmISNOe/pAIiKiBpLLJBi1Shi1nH6TiKIj6mMsmptarYa6ejo5IiIiIiJqFlHtg5OUlAS5XI7i4uKQ7cXFxUhLS6v1OWlpaY2KJyIiIiKi5hfVFguVSoW8vDwsX74ckyZNAhAYvL18+XLMmDGj1ucMGzYMy5cvxz333BPc9sMPP2DYsGENes/qsepmszmsshMRERERtXfV18wNmu9JRNn7778v1Gq1WLJkidixY4e45ZZbRFxcnCgqKhJCCHHDDTeIBx54IBi/Zs0aoVAoxDPPPCN27twp5syZI5RKpfjjjz8a9H6FhYUCAG+88cYbb7zxxhtvvPHWwFthYeFpr7OjPsbi6quvRmlpKR5++GEUFRWhf//++Pbbb4MDtAsKCiCTneixNXz4cLz33nt46KGH8OCDD6J79+747LPPGryGRXp6OgoLCxEbG9vi07pWDxwvLCyM2lS31PZxP6JI4H5E4eI+RJHA/aj1E0LAYrEgPT39tLFRX8eiI2nMPMBEdeF+RJHA/YjCxX2IIoH7UfvCBRSIiIiIiChsTCyIiIiIiChsTCxakFqtxpw5c7iuBoWF+xFFAvcjChf3IYoE7kftC8dYEBERERFR2NhiQUREREREYWNiQUREREREYWNiQUREREREYWNiQUREREREYWNiQUREREREYWNiQUREREREYWNiQUREREREYWNiQUREREREYWNiQUREREREYWNiQUREREREYWNiQUREREREYWNiQUREREREYWNiQUREREREYWNiQUREREREYWNiQUREREREYWNiQUREze7666+HRqPBnj17ajz2xBNPQJIkfPXVVygvL8fTTz+Nc889F8nJyYiLi8PQoUPxwQcfRKHURETUGJIQQkS7EERE1L6VlJSgR48e6N+/P1asWBHcnp+fj969e2PChAn4+OOP8dVXX+Hyyy/HhAkTMGbMGCgUCnzyySdYuXIlHn74YcybNy+Kn4KIiOrDxIKIiFrEG2+8gVtuuQVLlizBlClTAADjx4/H2rVrsWPHDmRkZCA/Px8ymQzZ2dnB5wkhMHbsWKxZswbl5eXQ6/XR+ghERFQPdoUiIqIWMX36dJxzzjm47777UF5ejvfffx/ffvstHnvsMWRkZAAAcnNzQ5IKAJAkCZMmTYLL5cKBAweiUXQiImoARbQLQEREHYMkSXjttdcwYMAA3H777fjpp58waNAg3Hnnnad9blFREQAgKSmpuYtJRERNxK5QRETUoh588EEsWLAAcrkcv/32GwYOHFhvfEVFBXr27IkzzzwTq1evbqFSEhFRY7ErFBERtajqVof09HT06dOn3li/34/JkyejqqoKixYtaoniERFREzGxICKiFlNYWIg5c+agT58+KCwsxFNPPVVv/MyZM/Htt9/izTffRL9+/VqolERE1BRMLIiIqMXMmDEDAPDNN9/gz3/+M+bPn1/ngOx58+bhlVdewRNPPIEbbrihJYtJRERNwMSCiIhaxKeffoovvvgCjz76KDIzM7Fw4UKoVKpaB2+//PLLmDt3Lu655x78/e9/j0JpiYiosTh4m4iImp3FYkGvXr2QnJyM9evXQy6XAwBefPFF3H333fjwww/x5z//GQDwwQcf4LrrrsO1116LpUuXQpKkaBadiIgaiIkFERE1u7vvvhsvvfQSfvnlF5x99tnB7T6fD4MHD0ZRURF27dqFnTt3YuTIkTAajXjyySehVCpDXmf48OHo0qVLSxefiIgagIkFERE1q40bN2LIkCG4/fbba53Zaf369Rg6dChmzJiBAQMGYNq0aXW+1jvvvIOpU6c2Y2mJiKipmFgQEREREVHYOHibiIiIiIjCxsSCiIiIiIjCxsSCiIiIiIjCxsSCiIiIiIjCxsSCiIiIiIjCxsSCiIiIiIjCpoh2AVqa3+/H0aNHERsby9VciYiIiIjqIYSAxWJBeno6ZLL62yQ6XGJx9OhRZGVlRbsYRERERERtRmFhITIzM+uN6XCJRWxsLIBA5RgMhiiXhoiIiIio9TKbzcjKygpeQ9cnqonF6tWr8fTTT2Pjxo04duwYPv30U0yaNKne56xatQqzZs3C9u3bkZWVhYceeghTp05t8HtWd38yGAxMLIiIiIiIGqAhQwiiOnjbZrOhX79+ePnllxsUn5+fj4svvhhjxozBli1bcM8992D69On47rvvmrmkRERERERUn6i2WIwfPx7jx49vcPzixYuRm5uLZ599FgDQs2dP/Pzzz3j++ecxbty4Wp/jcrngcrmC981mc3iFJiIiIiKiGtrUGIt169Zh7NixIdvGjRuHe+65p87nLFiwAPPmzWvmkhERERFRc/P5fPB4PNEuRruiVCohl8sj8lptKrEoKipCampqyLbU1FSYzWY4HA5otdoaz5k9ezZmzZoVvF89AIWIiIiI2gYhBIqKilBVVRXtorRLcXFxSEtLC3sphjaVWDSFWq2GWq2OdjGIiIiIqImqk4qUlBTodDquRRYhQgjY7XaUlJQAADp16hTW67WpxCItLQ3FxcUh24qLi2EwGGptrSAiIiKits3n8wWTisTExGgXp92pvoYuKSlBSkpKWN2iojorVGMNGzYMy5cvD9n2ww8/YNiwYVEqERERERE1p+oxFTqdLsolab+q6zbc8StRTSysViu2bNmCLVu2AAhMJ7tlyxYUFBQACIyPuPHGG4Pxt912Gw4cOIC//e1v2LVrF1555RV8+OGHuPfee6NRfCIiIiJqIez+1HwiVbdRTSw2bNiAAQMGYMCAAQCAWbNmYcCAAXj44YcBAMeOHQsmGQCQm5uLZcuW4YcffkC/fv3w7LPP4s0336xzqlkiIiIiImoZUR1jMXr0aAgh6nx8yZIltT5n8+bNzVgqIiIiIiJqrDY1xoKIiIiIqL04ePAgJEkKDgtoiCVLliAuLq7ZyhQOJhZERERERBQ2JhZERERERBQ2JhZERERE1DbZbHXfnM6GxzocDYttgm+//RYjRoxAXFwcEhMTcckll2D//v21xq5atQqSJGHZsmU466yzoNFoMHToUGzbtq1G7HfffYeePXsiJiYGF110EY4dOxZ8bP369bjggguQlJQEo9GIUaNGYdOmTU0qf2MwsSAiIiKitikmpu7bFVeExqak1B07fnxobE5O7XFNYLPZMGvWLGzYsAHLly+HTCbDn/70J/j9/jqfc//99+PZZ5/F+vXrkZycjIkTJ4asMWG32/HMM89g6dKlWL16NQoKCnDfffcFH7dYLJgyZQp+/vln/PLLL+jevTsmTJgAi8XSpM/QUG1q5W0iIiIiorbkilMSnLfffhvJycnYsWMHYupIVubMmYMLLrgAAPDuu+8iMzMTn376Ka666ioAgYXsFi9ejK5duwIAZsyYgUceeST4/PPOOy/k9V5//XXExcXhxx9/xCWXXBKxz3YqJhZERERE1DZZrXU/JpeH3i8pqTtWdkonnoMHm1ykU+3duxcPP/wwfv31V5SVlQVbKgoKCtCrV69anzNs2LDg/xMSEnDmmWdi586dwW06nS6YVABAp06dUHLS5ysuLsZDDz2EVatWoaSkBD6fD3a7PWR9uObAxIKIiIiI2ia9PvqxpzFx4kRkZ2fjjTfeQHp6Ovx+P/r06QO3293k11QqlSH3JUkKWRtuypQpKC8vxwsvvIDs7Gyo1WoMGzYsrPdsCCYWRERERETNoLy8HLt378Ybb7yBkSNHAgB+/vnn0z7vl19+QefOnQEAlZWV2LNnD3r27Nng912zZg1eeeUVTJgwAQBQWFiIsrKyJnyCxmFiQURERETUDOLj45GYmIjXX38dnTp1QkFBAR544IHTPu+RRx5BYmIiUlNT8Y9//ANJSUmYNGlSg9+3e/fuWLp0KQYNGgSz2Yz7778fWq02jE/SMJwVioiIiIioGchkMrz//vvYuHEj+vTpg3vvvRdPP/30aZ/3xBNP4O6770ZeXh6Kiorw5ZdfQqVSNfh933rrLVRWVmLgwIG44YYbcNdddyElJSWcj9Igkji5Q1YHYDabYTQaYTKZYDAYol0cIiIiIqqH0+lEfn4+cnNzodFool2cZrVq1SqMGTMGlZWViIuLa7H3ra+OG3PtzBYLIiIiIiIKGxMLIiIiIiIKGwdvExERERG1AqNHj0ZbHqXAFosoEELA5vJGuxhERERERBHDxCIKHB4fdh4zo9jsjHZRiIiIiNqEtvxLfmsXqbplYhEFfgFYnB7sLrKg0ta8KyASERERtWXVq0zb7fYol6T9qq7bU1f0biyOsYgih9uH3UUW9M4wIFYT3h+SiIiIqD2Sy+WIi4tDSUkJAECn00GSpCiXqn0QQsBut6OkpARxcXGQy+VhvR4TiyhKilGjzObCnmILeqcboVGG98ckIiIiao/S0tIAIJhcUGTFxcUF6zgcTCyiSJKA1FgNikwO7JFb0LOTAUo5e6cRERERnUySJHTq1AkpKSnweDzRLk67olQqw26pqMbEIsrkMgmpBg2OVjmhksvQPTUWchmb94iIiIhOJZfLI3YRTJHHn8dbAYVchqQYFQ5V2HGwzMZZD4iIiIiozWFi0UqoFXLEaZU4UGbDkSpHtItDRERERNQoTCxaEZ1KAa1Sjr3FFpRYuMYFEREREbUdTCxaGaNWCQkS9hRZUGXnGhdERERE1DYwsWiFEmPUcHr82FVkgc3ljXZxiIiIiIhOi4lFK5USq4bJHlid2+nxRbs4RERERET1YmLRSklSYBraEosT+0qs8Pr80S4SEREREVGdmFi0YnKZhJRYDY5U2nGg1Aa/n9PQEhEREVHrxMSilVPKZUjQq5FfZkVBBde4ICIiIqLWKazEwu12Y/fu3fB6OcC4OWmUchi1KuwrseGYidPQEhEREVHr06TEwm6346abboJOp0Pv3r1RUFAAAJg5cyaeeOKJiBaQAvRqBTRKOfYUW1BmdUW7OEREREREIZqUWMyePRtbt27FqlWroNFogtvHjh2LDz74IGKFo1BGrRJCALuLLDA5PNEuDhERERFRUJMSi88++wwvvfQSRowYAUmSgtt79+6N/fv3R6xwVFNSjBoOtw+7i8ywu9kFjYiIiIhahyYlFqWlpUhJSamx3WazhSQa1DySY9WosLmxp8gCl5drXBARERFR9DUpsRg0aBCWLVsWvF+dTLz55psYNmxYZEpGdZJJEtIMWhSZndjPNS6IiIiIqBVQNOVJjz/+OMaPH48dO3bA6/XihRdewI4dO7B27Vr8+OOPkS4j1aJ6jYvCSjtUchm6JMdAJmNrERERERFFR5NaLEaMGIEtW7bA6/Wib9+++P7775GSkoJ169YhLy8v0mWkOijlMsRr1ThQZsPhSnu0i0NEREREHViTWiwAoGvXrnjjjTciWRZqAq1KDp9fiT0lVqgUcqQZNad/EhERERFRhDUpsahet6IunTt3blJhqGliNAp4/H7sLjZDpZAhQa+KdpGIiIiIqINpUmKRk5NT7+xPPh9nKmpp8ToVSixO7C4yo3eGEQaNMtpFIiIiIqIOpEmJxebNm0PuezwebN68Gc899xzmz58fkYJR4yXHqFFkdmJPkQW9043QquTRLhIRERERdRBNSiz69etXY9ugQYOQnp6Op59+GpdffnnYBaPGkyQJqQYNjpmc2FNsQc9OBqgUTRqfT0RERETUKBG96jzzzDOxfv36SL4kNZJMkpAaq8YxkxP7Sy3w+UW0i0REREREHUCTWizMZnPIfSEEjh07hrlz56J79+4RKRg1nUIuQ3KMGofKHVDJ5eiSrOeK6ERERETUrJqUWMTFxdW4UBVCICsrC++//35ECkbhUSlkiNcpcaDMCpVChqwEXbSLRERERETtWJMSi5UrV4bcl8lkSE5ORrdu3aBQNHlpDIownUoBr09gb4kFaoUMKQaucUFEREREzaNJYyxGjRoVchs5ciR69OjR5KTi5ZdfRk5ODjQaDYYMGYLffvutztglS5ZAkqSQm0bDC+a6GLRKyCUZdhdbUGlzR7s4RERERNRONTgT+OKLLxr8opdeemmDYz/44APMmjULixcvxpAhQ7Bw4UKMGzcOu3fvRkpKSq3PMRgM2L17d/A+xw/UL0GvQonZid3FFvTJMCJGzVYlIiIiIoqsBl9hTpo0qUFxkiQ1aoG85557DjfffDOmTZsGAFi8eDGWLVuGt99+Gw888ECd75GWltag13e5XHC5XMH7pw487yiSY9U4Zj6+gF66ERol17ggIiIioshpcFcov9/foFtjkgq3242NGzdi7NixJwokk2Hs2LFYt25dnc+zWq3Izs5GVlYWLrvsMmzfvr3O2AULFsBoNAZvWVlZDS5feyJJElJjNSg1u7Cn2AKPzx/tIhERERFROxLV1dPKysrg8/mQmpoasj01NRVFRUW1PufMM8/E22+/jc8//xz/+te/4Pf7MXz4cBw+fLjW+NmzZ8NkMgVvhYWFEf8cbYVcJiHFoMHRKgf2l1jh5xoXRERERBQhTe5sb7PZ8OOPP6KgoABud+ig4LvuuivsgtVl2LBhGDZsWPD+8OHD0bNnT7z22mt49NFHa8Sr1Wqo1epmK09bo5TLkKhX42C5DWqFDDlJXOOCiIiIiMLXpMRi8+bNmDBhAux2O2w2GxISElBWVgadToeUlJQGJxZJSUmQy+UoLi4O2V5cXNzgMRRKpRIDBgzAvn37Gv05OiqNUo54nQr7S21QKeXIiNNGu0hERERE1MY1qSvUvffei4kTJ6KyshJarRa//PILDh06hLy8PDzzzDMNfh2VSoW8vDwsX748uM3v92P58uUhrRL18fl8+OOPP9CpU6dGf46OTKdSQKOUY2+RBaUW1+mfQERERERUjyYlFlu2bMFf//pXyGQyyOVyuFwuZGVl4amnnsKDDz7YqNeaNWsW3njjDbz77rvYuXMnbr/9dthstuAsUTfeeCNmz54djH/kkUfw/fff48CBA9i0aROuv/56HDp0CNOnT2/KR+nQjFolAGB3sQUmuyfKpSEiIiKitqxJXaGUSiVkskBOkpKSgoKCAvTs2RNGo7HRg6OvvvpqlJaW4uGHH0ZRURH69++Pb7/9Njigu6CgIPheAFBZWYmbb74ZRUVFiI+PR15eHtauXYtevXo15aN0eIkxahSbndhZZEbfDCP0XOOCiIiIiJpAEkI0emqgCy+8EFOnTsV1112Hm2++Gb///jvuuusuLF26FJWVlfj111+bo6wRYTabYTQaYTKZYDAYolIGq8uLHUdN0CjkrWLgtBACR00OpBo06JVugFrBNS6IiIiIqHHXzk3qCvX4448HxzTMnz8f8fHxuP3221FaWorXX3+9KS/ZYTjcXqjkMuQk6nFmp1ikGtRQK6I6629gwUGDFsVmJ/YWW+HlGhdERERE1EhNarFoy6LZYuHy+PDKqv14Z20+zA4vDFoFpg3Pxa2juuBwhQMub3Qv6D0+P0osTnRJikG3lBjIZNFvTSEiIiKi6Gn2FovHHnsM+fn5TSpcR+Vwe/HKqv14YflemB1eAIDZ4cULy/fitR8PIE6njHIJQ9e4KKy0R7s4RERERNSGNCmx+Oijj9CtWzcMHz4cr7zyCsrKyiJdrnZHLpPhnbW1J2PvrM1HnE4JeStoIdAo5YjVKLG32IpjJke0i0NEREREbUSTEoutW7fi999/x+jRo/HMM88gPT0dF198Md577z3Y7fyluzYWpyfYUnEqs8MLk8MLRStILAAgRq2AWiHDniILyq1c44KIiIiITq/Jo4Z79+6Nxx9/HAcOHMDKlSuRk5ODe+65p8ErZnc0sRolDNrap3I1aBWIUcuxtbCqZQtVjzidCj4/sKvIArOTa1wQERERUf0iMh2RXq+HVquFSqWCx8OL0Nr4/H5MG55b62NThuXgp71luP+T3zH/6x04WtU6uiAlxahgd3uxu8gCh9sX7eIQERERUSvW5MQiPz8f8+fPR+/evTFo0CBs3rwZ8+bNQ1FRUSTL125oVQrcMbor7j6/e7DlwqBV4O7zu+P2UV3x64EKyCTglwMVuPO9TXhnTT7s7tq7TrUUSZKQEqtBudWFPcUWuKM8axURERERtV5Nmm526NChWL9+Pc466yxMnjwZ1157LTIyMpqjfBEX7QXy7G4vFDIZqhxuGLVKmOweVNk9cHn9OFRuw1s/52Pz8S5RcVolrh+ajbE9U6M6sNvnFygyO9A5QYcz0wytYpA5ERERETW/xlw7Nymx+Mc//oHJkyejV69eqH56a1hBuiGinVgA9a+8LYTA+oOVeOvnAzhqcgIAuiTrcfOILuiTYYxGcQEAbq8fZTYnuibHoGtyTJv5exMRERFR0zX7Ohbz58/HunXr0KdPH2g0Gmg0GvTp0wdvvvlmkwrcEdlcXnj9NXM6SZIwODcBL103EDedkwu9So4DpTbM/vQPPPHtLhSbnVEoLaBSyBCvVeNAqQ2FFZz5i4iIiIhC1T5N0Wk8/PDDeO655zBz5kwMGzYMALBu3Trce++9KCgowCOPPBLRQnZESrkMkwZkYEyPFPzrl0P4fkcR1uwrw2/55fjTgExcOTATWpW8RcukVcnh8yuxt9QKtVKOVIOmRd+fiIiIiFqvJnWFSk5Oxosvvohrr702ZPt//vMfzJw5s1UvmNdaukKtzy+HUauCUt6wRqP8Mhve/OkAfj9iAgAk6FSYMjwbo89MgayFuyVV2tyABPTJMCJBr2rR9yYiIiKiltPsXaE8Hg8GDRpUY3teXh683ujOZNRe5Sbp8dikPnhwfA+kGTSosLvx/P/24v6Pt2LXMXOLliVer4LH58eeIgssXOOCiIiIiNDExOKGG27Aq6++WmP766+/jsmTJ4ddKKqdJEkY1jUJL183EFOG5UCrlGNPsRX3f/I7nvl+N0otLbdKdnKMGmanB7uLLHB6uMYFERERUUfXpK5QM2fOxP/93/8hKysLQ4cOBQD8+uuvKCgowI033gilUhmMfe655yJX2ghoq12halNpc2PpL4fwv53FEAgMsL5yYCb+NCADGmXzj7/wC4FjJic6xWnQM80AlSIi6y0SERERUSvR7NPNjhkzpkFxkiRhxYoVjX35ZtWeEotq+0qseOOnA9hxvEtUUowaU4fn4NzuSc0+LazX50exxYXsRC3OSOUaF0RERETtSbMnFm1Ze0wsgMD6Fz/vK8M7aw8Gu0T1TIvF9JFdcEZqbETeoy4urw9lVje6p8SgS7Kea1wQERERtRPNPnibWh9JkjCyezJenTwQk4d0hlohw84iC/760VY8/789KLc23/gLtUKOeJ0SB8psOFLlaLb3ISIiIqLWi4lFO6NWyHHN2Z3x2vV5GHNmMgBgxa4S3PbvjfhwQyHcXn+zvK9OpYBOKcfeYgtKLNFZxI+IiIiIooeJRTuVGKPGrAvOxDNX9sOZqbFwevxY+ssh3P7vjVizrwzN0QPOoFVCgoTdRRZU2d0Rf30iIiIiar2YWLRzZ6bF4qkrz8JfLzgDiXoVSiwuPPHtLjz46R84UGqN+Pslxqjh8vixq8gCq4trmhARERF1FEwsOgCZJGH0mSlYfH0erj47Cyq5DNuOmnHPB1uwaMVeVEa4dSElVg2T3YPdRWaucUFERETUQTCx6EA0SjmuH5KNVycPxMjuSRAAvt9RjFuXbsR/Nx2GxxeZ8ReSJCHVoEGpxYW9xdaIvS4RERERtV5MLDqgFIMGfxvXA09c3hfdkmPg8PjwztqDuPO9Tfg1vzwi4y/kMgkpsRocqbLjQKkNfn+HmtWYiIiIqMNhYtGB9U434tmr+uHu87ojXqfEMZMTjy3biYe/2I5D5bawX18plyFRr8bBMisKKmzNMmCciIiIiFoHJhYdnEySMLZXKhZfn4crB2ZCIZOwpbAKd72/Ga+s2geTwxPW62uUchi1KuwrseGYidPQEhEREbVXTCwIQGAdiinDc/Dq5DwM65IIvwC+2VaEW/+1AV9sPQJvGOMk9GoFNEo59hRbgquCExEREVH7wsSCQqQZNXhwQk88PqkPcpP0sLl8eOOnfMx8fzM2HKpo8usatUpAALuLLTDZw2sFISIiIqLWh4kF1apvZhyev6o/7hzdDUatEocrHZj35Q7M/XI7CivtTXrNxBg1nG4fdhebYXdzjQsiIiKi9oSJBdVJLpNwUZ80vHZ9Hib1z4BCJmHjoUrM/M9mvPHTAVidjU8OkmPVqLS7safIApeXa1wQERERtRdMLOi09GoFbhqRi5evG4jBOQnw+QW+2HoUt/xrA5b9cQy+RkwlK5MkpMZqUWR2Yl+JNayxG0RERETUejCxoAZLj9Pin5f0wiOX9kbnBB0sTi8W/7gfd7+/GVsKqxr8OtVrXBRW2JFfxjUuiIiIiNoDJhbUaAM6x+PFawbgtnO7IFatwKEKO/75+TY8tmwHjlY5GvQa1Wtc5JfZmjxmg4iIiIhaDyYW1CRymYSLz0rHazfkYeJZnSCTgF/zK3Dne5vw9pp82FynH3+hUcoRq1Fib4kVRVzjgoiIiKhNY2JBYYnVKHHLuV3x0rUDMbBzPLx+gU83H8Ft/9qI77YXnXb8RYxaAZVcht1FZpRbucYFERERUVvFxIIiIitBh3mX9sacS3ohI06LKocHL63ch1kfbsEfR0z1Pjdep4LPD+wussDs5BoXRERERG0REwuKqEE5CXjp2gGYPiIXepUcB8psePDTP7Dgm50oMtfd3SkpRgWb24vdRRY43JyGloiIiKitYWJBEaeQy3BZ/wy8dsMgjO+TBpkErN1fjjv+vRH/t+5grYvjSVJgpqhyqwt7ii1wezkNLREREVFbwsSCmo1Rq8Qdo7vhhasHoF+mER6fwEcbD+O2f23E/3YWwy9Cx18E1rjQ4JjJgX2llkatj0FERERE0cXEgppdTpIej17WB/+Y0BOdjBpU2j14Yfle/PWjrdhxzBwSq5DLkByjQUG5HfllVgjB5IKIiIioLWBiQS1CkiQM7ZKIl68biGnDc6BVyrGvxIq/f/I7nv5uF0osJ8ZfqBQyxOtUyC+z4XBlw9bFICIiIqLoYmJBLUopl+HygZl47YY8XNArFRKA1XvLcPu/N+Hfvx6C0xMYuK1TKaBXKbC3xILiegZ9ExEREVHrIIkO1tfEbDbDaDTCdPQoDAZDzQC5HNBoTty32ep+MZkM0GobHWt1ebFxRyGMGiUU8lpyO0mC0OpO3HXYgbr+TDViHYCoe+Cz0OmbFut0Av66Z2tqVKxWB0gSACD/SDmWrN6HnccsAIDEGCUmD87GiO5JkCQJFX4FIJPQN8OIeIUAvPUsvKfVBuoZANxuwFPP1LWNidVoAvtFY2M9nkB8XdRqQKFofKzXC7jqWfNDpQKUysbH+nyAs54kTqkMxDc21u8HHPW0PDUmVqEI1AUQOCbs9aza3pjYxhz3LXCOABAobz3HPXS6psU6HIF6rote37RYpzOwX0QiVnfiHAGXq/7jvjGxPEcE8BzR+FieI07gOaLxsW38HGEuLYUxPR0mk6n2a+eTiQ7GZDIJAMIUOMRq3iZMCH2CTld7HCDEqFGhsUlJdccOGhQMszg9wp6eWWes44we4vfCquDNcUaPOmNdmVkhsbazBtQZ60lIDIm1DD2nzlifVhcSazrvwro/GxASW3XxZfXG/rH7SDC24spr643dvmWf+N/2IrFuX5lw3XpbvbEiP//E3+K+++qP3bbtROycOfXH/vbbidinnqo/duXKE7EvvVR/7FdfnYh95536Yz/88ETshx/WH/vOOydiv/qq/tiXXjoRu3Jl/bFPPXUi9rff6o+dM+dE7LZt9cfed9+J2Pz8+mPvuONEbElJ/bFTppyItVrrj73yShGivtgWOEcIIYTIzq47tlev0NheveqOzc4OjR00qO7YpKTQ2FGj6o7V6UJjJ0yov95OduWV9cdarSdip0ypP7ak5ETsHXfUH8tzRODGc0TgxnNE4MZzxIkbzxGB2ynnCBMgAAiTySROh12hqFV7bdV+yGSAyelBlb2eTJyIiIiIoopdoU7FrlC1xzZTVyjJ5QJ8oc2SFVYX3vutED/uKYVDqYZGJccVAzIxLEOP7Hg1eqQZoKyt3tiEGcBuDo2PZTeHE9jNofGxPEcE8BzR+FieI5oWy3NEQCvsCtVxE4uG9BNrJlaXF+vzy2HUqmq/QCYAwJ5iC9746QB2FQXGXyTHqnFZv3RcOzgLnYxaKOQyWJwexGqU8Pr90KkUUS5x2+JweyGXsQ7DxXqMDNZj+FiHkcF6jAzWY/haSx025tq5VfyFX375ZTz99NMoKipCv379sGjRIgwePLjO+I8++gj//Oc/cfDgQXTv3h1PPvkkJkyY0IIlppZwRmosnrriLPy4pxTvrjuIUosLK3eX4s4x3bB49X4sWXsQZocXBq0C04bn4o7RXaFWyqNd7DbB5fFh8Y8H8M7afNZhGFiPkcF6DB/rMDJYj5HBegxfW63DqLdYfPDBB7jxxhuxePFiDBkyBAsXLsRHH32E3bt3IyUlpUb82rVrce6552LBggW45JJL8N577+HJJ5/Epk2b0KdPn9O+H1ss2ianx4f/bjqM83ulYmthFRat2Fcj5q7zu+FPAzKx/mBFFErYdpydk4BPNx/Gi8tZh+FgPUYG6zF8rMPIYD1GBusxfPXV4d3nd8eto7q0aMtFY66do55YDBkyBGeffTZeeuklAIDf70dWVhZmzpyJBx54oEb81VdfDZvNhq+++iq4bejQoejfvz8WL15cI97lcsF1Uj8ys9mMrKysVpFY+P2AXCZFpQxtkVIuYVBOAs5+/H8wO2r2kTRoFfhl9vkY8eRKVNg40Ls2CXoVfv77GAxdsJx1GAbWY2SwHsPHOowM1mNksB7D15A63PCPC6BStNwP022mK5Tb7cbGjRsxe/bs4DaZTIaxY8di3bp1tT5n3bp1mDVrVsi2cePG4bPPPqs1fsGCBZg3b17EyhwJKrkMqUYNvL4ONbwlbBqFDGanp9YDDQDMDi+q7B6MPiMZBRX1DMLrwDon6FBpYx2Gi/UYGazH8LEOI4P1GBmsx/A1pA4tTg8SY9QtXLKGiWpiUVZWBp/Ph9TU1JDtqamp2LVrV63PKSoqqjW+qKio1vjZs2eHJCLVLRbRpFLI0KuTMaplaKvcXj8MWkWdWXxSjBrPXd2/5QvWhrAOI4P1GBmsx/CxDiOD9RgZrMfwna4OYzXKKJSqYdp9B3+1Wg2DwRByo7bL5/dj2vDcWh+bNjwX3vqmvSMArMNIYT1GBusxfKzDyGA9RgbrMXxtuQ6j2mKRlJQEuVyO4uLikO3FxcVIS0ur9TlpaWmNiqf2RatS4I7RXQGgzc2U0FqwDiOD9RgZrMfwsQ4jg/UYGazH8LXlOmwVg7cHDx6MRYsWAQgM3u7cuTNmzJhR5+Btu92OL7/8Mrht+PDhOOuss2odvH2q1jArFIXP7vZC0Qrmdm7LWIeRwXqMDNZj+FiHkcF6jAzWY/haSx22mcHbADBr1ixMmTIFgwYNwuDBg7Fw4ULYbDZMmzYNAHDjjTciIyMDCxYsAADcfffdGDVqFJ599llcfPHFeP/997Fhwwa8/vrrDXq/6jzKbDY3zweiFuMFoATgtAdm/TLXs8gr1Y51GBmsx8hgPYaPdRgZrMfIYD2GrzXUYfU1c4PaIkQrsGjRItG5c2ehUqnE4MGDxS+//BJ8bNSoUWLKlCkh8R9++KE444wzhEqlEr179xbLli1r8HsVFhYKALzxxhtvvPHGG2+88cZbA2+FhYWnvc6Oeleolub3+3H06FHExsZCklp2DYnqGakKCwvZDYuajPsRRQL3IwoX9yGKBO5HrZ8QAhaLBenp6ZDJ6p/3KepdoVqaTCZDZmZmVMvA2akoErgfUSRwP6JwcR+iSOB+1LoZjcYGxbX76WaJiIiIiKj5MbEgIiIiIqKwMbFoQWq1GnPmzIFa3TqXYae2gfsRRQL3IwoX9yGKBO5H7UuHG7xNRERERESRxxYLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiJqsuuvvx4ajQZ79uyp8dgTTzwBSZLw1VdfAQBycnIgSVKN22233VbjuVVVVbjllluQnJwMvV6PMWPGYNOmTbWW4YsvvsDAgQOh0WjQuXNnzJkzB16vN7IflIiITksSQohoF4KIiNqmkpIS9OjRA/3798eKFSuC2/Pz89G7d29MmDABH3/8MYBAYhEfH4//b+/Ow6Mqz/6Bf88yayaZ7AmQAFEWWWQXCC6Ar0rRaqlalVpFqtK6oEixSqtStIJbVSpUXKr42nohvP1JrbRYi4BVQEnYQZAlIcEsZJ99Pef3xySTDNkzk0yW7+e65tLM3GfmmcOZc8597ud5zq9+9auQ9xg2bBgmT54c/FtRFFx++eU4cOAAHn30USQnJ+NPf/oTCgsLkZubi6FDhwZj//Wvf+G6667DjBkzMHfuXBw6dAhr1qzBggUL8Prrr3fytyciooaYWBARUVjeeustLFiwAOvWrcO8efMAALNnz8bOnTtx9OhRDBgwAEAgsRg9enSwgtGcDRs24NZbb8XGjRtx8803AwDKysowbNgwzJ49Gx988EEwdtSoUdBoNMjJyYEsywCAJ554AitWrMDRo0dx0UUXdcZXJiKiJrArFBERheWee+7BpZdeiiVLlqCiogLr16/Hli1b8Pvf/z6YVDTk8Xhgt9ubfb//+7//Q1paGm688cbgcykpKbjlllvw97//HW63GwBw9OhRHD16FAsWLAgmFQBw//33Q1XVYKWEiIi6BhMLIiIKiyAIeOONN1BTU4P77rsPjzzyCCZNmoQHHnigUeznn38Oo9EIk8mEwYMHY9WqVY1i9u3bhwkTJkAUQw9RkydPhsPhCI7n2LdvHwBg0qRJIXH9+/dHRkZG8HUiIuoacushRERELRs1ahSWLFmClStXQpIkbN68uVFiMGbMGFx22WUYPnw4KioqsG7dOixatAhFRUV4/vnng3HFxcW44oorGn1Gv379AABFRUW4+OKLUVxcHPL8+bFFRUWR/IpERNQKJhZERBQRycnJAAIVg9GjRzd6/eOPPw75e/78+Zg9ezZefvllLFy4EBkZGQAAp9MJnU7XaHm9Xh98veF/m4u1WCxhfBsiImovdoUiIqKwFRYWYtmyZRg9ejQKCwvxwgsvtLqMIAh45JFH4PP5sH379uDzBoMhOI6iIZfLFXy94X+bi617nYiIugYTCyIiCtuDDz4IIDD9609+8hM8++yzOH36dKvLZWZmAgAqKyuDz/Xr1y/Yzamhuuf69+8fjGv4/PmxdXFERNQ1mFgQEVFYPvroI3z88cd45plnkJGRgVdffRVarbbJwdvnq0s+UlJSgs+NGzcOe/fuhaIoIbFff/01jEYjhg0bFowDgJycnJC4oqIinD17Nvg6ERF1DSYWRETUYVarFQ899BDGjx+PhQsXAghUFJ555hls2bIFGzduBBCoSPj9/pBlvV4vnnvuOWi1WsycOTP4/M0334zS0lL8v//3/4LPlZeXY+PGjbj++uuDYypGjRqFiy66CG+++WbIe7/++usQBCF4DwwiIuoavEEeERF12MMPP4zVq1dj9+7duOSSS4LP+/1+TJ48GSUlJTh27Bj+9re/4fe//z1uvvlmZGVlobKyEh988AEOHz6MFStWYOnSpSHLXnbZZTh8+HDInbcLCgqwZ88eDB8+PBj7ySef4IYbbsDMmTNx22234fDhw1i9ejXuvvtuvPnmm126LoiI+jomFkRE1CG5ubmYMmUK7rvvPrz22muNXt+zZw+mTp2KBx98EHfeeSeWL1+OvXv3oqysDFqtFuPGjcNDDz2En/zkJ42WraqqwqOPPopNmzbB6XTikksuwUsvvdTonhUAsGnTJixfvhzffvstUlJScNddd+Gpp56CRqPplO9NRERNY2JBRERERERh4xgLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKmxztBnQ1RVFQVFSE2NhYCIIQ7eYQEREREXVbqqrCarWif//+EMWWaxJ9LrEoKipCZmZmtJtBRERERNRjFBYWIiMjo8WYPpdYxMbGAgisnLi4uCi3hoiIiIio+7JYLMjMzAyeQ7ckqonFF198gRdffBG5ubkoLi7GRx99hDlz5rS4zPbt27F48WIcOXIEmZmZeOKJJ3DXXXe1+TPruj/FxcUxsSAiIiIiaoO2DCGI6uBtu92OsWPHYs2aNW2Kz8vLw3XXXYeZM2di//79WLRoEe655x58+umnndxSIiIiIiJqSVQrFrNnz8bs2bPbHL927VpkZWXhD3/4AwBgxIgR+PLLL/HKK69g1qxZndVMIiIiIiJqRY8aY7Fr1y5cddVVIc/NmjULixYtanYZt9sNt9sd/NtisXRW89rMr6gotbigqGq0m9LjyaKIWL0Mo1biLF9E1Kepqgq7xw+rywu/wuNLuARBQIxWgkknQ5Y4Oz9RW/SoxKKkpARpaWkhz6WlpcFiscDpdMJgMDRaZuXKlVi+fHlXNbFNnF4/viu1wuXx82Q4XIIKnSTBpJeREqtDrF6DWL0MDQ8CRNQHeHwKrC4vrC4vymwe2FxeeHwKAB5bwqUKKmRBRIxWRpJJi3ijBrF6DQxaKdpN67NUVYXP54Pf7492U3oVSZIgy3JEzkl7VGLREUuXLsXixYuDf9eNbI82VVWRGqfnCXAEuLx+2N1+lNsskAQRRp2EpBgt4o1aVjOIqFdpWJWocnhQaffC6fFBUVUYZBmxeg10Mk98I8XnV2D3+HGm0o68CkCvEWHWa5Fk0iJOr4FJL0MSeXzpCh6PB8XFxXA4HNFuSq9kNBrRr18/aLXasN6nRyUW6enpKC0tDXmutLQUcXFxTVYrAECn00Gn03VF8yhK9BoJeo0EQAu/osLh8aGwyokzlXboZAmxehkpJj1i9TJMrGYQUQ/j9SuwunywOD0ot3lgc/ng9vkhiYGr6SkmPU9uO4ksiTAbRJgNGqiqCqfXj2qHByUWJ2RJhKm2mmE2ahCrYzWjsyiKgry8PEiShP79+0Or1fKCYYSoqgqPx4OysjLk5eVh6NChrd4EryU9KrHIzs7GP//5z5DnPvvsM2RnZ0epRdTdSKJQ2x0qcBBw+xRYnT6UWy2QRAFGrYTEGC0SYgLVDIOG1Qwi6l5UVYXD44fV5UOlw40quxcOtx8KFOhlGTE6GUkmXjDraoIgwKiVYdQGTp28fgUOjx/5FXYoZSr0WgnxhkA1I1bHakYkeTweKIqCzMxMGI3GaDen1zEYDNBoNDhz5gw8Hg/0en2H3yuqiYXNZsPJkyeDf+fl5WH//v1ITEzEwIEDsXTpUnz//ff43//9XwDAL3/5S6xevRq//vWv8fOf/xyff/45NmzYgM2bN0frK1A3JghCg2pGYNC83R2oZuRXOKDXiIgzNKhmcIAeEUVJXVXC6vKizOoOVCX8/kD3Tq2ElFgdT1K7GU0T1YxKuwfFFidkUYRJJyMpJlDNiNNrgsci6rhwrqRTyyK1bqOaWOTk5GDmzJnBv+vGQsybNw/r1q1DcXExCgoKgq9nZWVh8+bNeOSRR7Bq1SpkZGTg7bff5lSz1CaSKCDOoEGcob6aYXH4cM5igVxbzQgM0Ksbm9GjCnpE1IM0rEpUOzyosHvgcPvhVxUYNLVVCQ2rEj1Fc9WMvHI7VFWFQSvDbNAEqhl6DUw6VjOodxJUtW/NeWqxWGA2m1FTUxO1O2/b3D7syauA2aBlf/9uwld7EHB4/PCrKgwaEXEGDZJNOlYziCgivH4FNpcPVpcPZTYXrLVjJURBRIxWglHLk83eSFHV4CQjHsUPjRQYG5Ns0sJsCFzIYjWjZS6XC3l5ecjKygqrmw41r6V13J5zZ16SJUJggF6cQQxWM1xeBTUOL85Z3ZAEgdMNElG71XWPsbp8qLJ7UGn3BC5eKCp0sogYnYxEIweh9nZiM9WM02V2AHboNRLMBg2SY3Uw6WTE6mSITDD7jPz8fGRlZWHfvn0YN25cm5ZZt24dFi1ahOrq6k5tW0cwsSA6jyAIMGilYPJQN91gQaUDeRVqYGyGPlDN4HSDRNSQz6/A5q6vSlicPri8SmDyCI2EZBPHSvR1Dcdm1FUzKmwelNS4IMtC7UxfOsQZNKxmUI/DxIKoFU1NN1jj8KLU4oJcO91jciynGyTqqxweX/1YCVugKuFTVOhlEUatjESjyKoENampaobd7cPJMhsAwKiVAheyYmu75WpZzaDujZ3GidqhboBekkmHAfFGJMZo4VdV5FfYsfdMFb7Jr8CBwmoUVjpQ4/DCr/SpIUxEfYLPr6Da4UFhpQP7CqqwJ68S+wqqUVDhhKoCSTFaDIg3IMmkg4E36KR20Egi4o1a9DcbkB6nh0YUUW5z4/DZGuTkV+Kb/EqcOmdDuc0Nt493nwYA2O3NP1yutsc6nW2L7YAtW7bgsssuQ3x8PJKSkvDDH/4Qp06dajJ2+/btEAQBmzdvxpgxY6DX6zF16lQcPny4Ueynn36KESNGwGQy4Qc/+AGKi4uDr+3ZswdXX301kpOTYTabMX36dOzdu7dD7W8PJhZEYQiUtDVIjzOgv9kAvSyh0u7BkaIa7DlTiT35lThRasU5qwsuLw8CRD2V0+PHOYsL35VYsSevCjn5VThabEGNwwuDRkZ/sx7pZj3iDBpO9EARIQoCYnQyUmP16B9vgFmvhden4GSZLXAhK68Sh76vRlG1ExaXF0pfvZBlMjX/uOmm0NjU1OZjZ88OjR08uOm4DrDb7Vi8eDFycnKwdetWiKKIH//4x1AUpdllHn30UfzhD3/Anj17kJKSguuvvx5erzf4usPhwEsvvYT3338fX3zxBQoKCrBkyZLg61arFfPmzcOXX36J3bt3Y+jQobj22mthtVo79B3ail2hiCKktZsncbpBop7Dr6iwuXywuLwot7lhcXkDYyVq74+TFKNlAkFdSiuL0MpaxCMw01Qg2XWjqNoFjSTApAuMzYitHZuhk9ktt7u46bwE55133kFKSgqOHj0KUzPJyrJly3D11VcDAN577z1kZGTgo48+wi233AIA8Hq9WLt2LS688EIAwIMPPoinn346uPyVV14Z8n5vvvkm4uPjsWPHDvzwhz+M2Hc7HxMLok7SlpsncbpBou7D6fHD6vaixuFFudUDu8cHn6JALwcmc0gwcAYn6h7qqhkxusBpnMenwO7x4btSGwQhMDYjwahFQkzg+BLTm8dm2GzNvyadd1w9d6752PNvEJef3+Emne/EiRN46qmn8PXXX6O8vDxYqSgoKMDIkSObXCY7Ozv4/4mJiRg+fDi+/fbb4HNGozGYVABAv379cK7B9ystLcUTTzyB7du349y5c/D7/XA4HCH3h+sMTCyIukBz1YzTZXaoqq1RNYPTDRJ1voZViUq7B9VOD5wePyRRgEEjIzGG9xqinqGumpFgDGzXTq8fJTUunK12QisFkpC6maZMva2aERMT/dhWXH/99Rg0aBDeeust9O/fH4qiYPTo0fB4PB1+T41GE/K3IAhoeGu6efPmoaKiAqtWrcKgQYOg0+mQnZ0d1me2BRMLoihobrrB4honNDJvnkTUWVxePyyuQFWiwu6Bze2Dz69AJ0uBq7ysSlAPJ4mBblGm2mqG2xe4+et3pTaIImDQBKoZiSZtMI7bfOepqKjA8ePH8dZbb+Hyyy8HAHz55ZetLrd7924MHDgQAFBVVYXvvvsOI0aMaPPnfvXVV/jTn/6Ea6+9FgBQWFiI8vLyDnyD9mFiQRRlzU03WHfzJAOnGyTqML+i1t5XwosKmwc1Ti+cHh/EuqqEkVUJ6t10sgSdLDWuZlQ5oJVFmPQapNRVy/UaaGX+HiIpISEBSUlJePPNN9GvXz8UFBTg8ccfb3W5p59+GklJSUhLS8Nvf/tbJCcnY86cOW3+3KFDh+L999/HpEmTYLFY8Oijj8JgMITxTdqGiQVRN1M33WA86gfo1d08SSMHkpAUkw5mY2AAOKsZRKFctXe7rnF6UG6rrUooCnRSoCoRbzDwCi31SU1WM9x+HLdbIQoCDFoZiTEaJBgDiUYMp0sOmyiKWL9+PR566CGMHj0aw4cPxx//+EfMmDGjxeWee+45PPzwwzhx4gTGjRuHf/zjH9BqtW3+3D//+c9YsGABJkyYgMzMTKxYsSJk1qjOIqgNO2T1ARaLBWazGTU1NYiLi4tKG2xuH/bkVcBs4JUyah+PT4HD44Ojdupao1ZCvFGDpBgdTKxmUB+lKCqsbh9sbh/Kre5gVaJ+bJPEfS1RK/xK4EKW3eODXwl0DzTpA91y42q75Ubrd+RyuZCXl4esrCzo9fqotKGrbN++HTNnzkRVVRXi4+O77HNbWsftOXdmxYKoB2luusHvq1zQyoErUUkxgWoGpxuk3uz8qoTd44PXp0ArSYjRSTAbDBB5pZWozSRRCFyg0gdODV1eP+xuPyrsVogQYdBJSIzRINEY6JZrZDWDmsDEgqiHam66wZNlNggIVDPMtdWMXj/dIPV6iqLC5vHB6gpUJSwuL5yeQOXOoAkMumZVgihy9BqptqutNljNKKpyobDSAZ0UqGakxOpqx2ZEr5pB3QsTC6JeIjjdIALVDEeDmyf1+ukGqVdyef2wuX2ocXhRZnPD4fHB61OhkUQYtRLi4jSsShB1geaqGeU2CyRBhFEnITFGWzs2g9WMcMyYMQM9eZQCEwuiXkgUmp9usOHNk+qmG+SVJuouPH4FNpcPFXY3qh1eOGqrEkaNBLNeyxlriLqB86sZDo8PZ6ucKKi0QydLiNXLSDHpEauXYdCGfxHL7fVDVVUoSuDRFwkCekSyxsSCqA9obrrBwioHdLLILlLUbfgVFR6fCo0kIEYrI51VCaJuTRKF4FS1qqrC7VNgdfpQbrVAEgVo5PB/v4LiRaxPgcPjhV/sm6eueo0EjdR5+8JIVUn65r8OUR92/nSDHp8Cfx+9AkTdjyQKrEoQ9VCCIDSoZtRdKFDCf2NVBDyAx+WCwWAM//16GJ+iAJ18mHY4HAAa39G7vZhYEPVxPIkjIqLOIIlCRLpCARL83hiUl5cBAqA3GCCg71QyfYoK0e+DvxOO16qqwuFw4Ny5c4iPj4ckhffvxcSCiIiIiLo1MSYBih04d66sD6UUAX5VhVYSIXVit+X4+Hikp6eH/T5MLIiIiIioWxMEAZIpEaoSDyi+aDenS1VaXRieGoeUWF2nvL9Gowm7UlGHiQURERER9QiCKAKiNtrN6FJ+0Q+NVtcj7jrOztVERERERBQ2JhZERERERBQ2JhZERERERBQ2JhZERERERBQ2JhZERERERBQ2JhZERERERBQ2JhZERERERBQ2JhZERERERBQ2JhZERERERBQ2JhZERERERBS2sBILj8eD48ePw+fzRao9RERERETUA3UosXA4HLj77rthNBoxatQoFBQUAAAWLlyI5557LqINJCIiIiKi7q9DicXSpUtx4MABbN++HXq9Pvj8VVddhQ8//DBijevNYnQyZFGIdjN6NEkUoJNFSFyPREQAuF+MFK5Hoo6RO7LQpk2b8OGHH2Lq1KkQhPof3ahRo3Dq1KmINa43cnp80EoiBifFwGzUoMbhRbXDC7dPiXbTegydLCI+RoN4gwY1Ti/MBg2quR6JqA/jfjEyuB6JwtOhxKKsrAypqamNnrfb7SGJBoVye/1Yu+M03t2ZB4vThziDjPnTsvCL6RfgbKWTO6020MkiMhINWLvjFNbtzOd6JKI+j/vFyOB6JApfh7pCTZo0CZs3bw7+XZdMvP3228jOzo5My3oZp8eHP20/hVVbT8DiDAx2tzh9WLX1BN7YcRrxRk2UW9gzxMdosHbHKfxx60muRyIicL8YKVyPROHrUMVixYoVmD17No4ePQqfz4dVq1bh6NGj2LlzJ3bs2BHpNvYKkiji3Z15Tb727s483DfjQqzaegJ2t7+LW9ZzxOgkPPnDkVi3M7/J19/dmYcHZl6IcpsHfkXt2sYREUWBJAqIN2ha3C/y+NI6Hl+IIqNDicVll12G/fv347nnnsPFF1+Mf//735gwYQJ27dqFiy++ONJt7BWsLm/wCsj5LE4fym1u5ORX4XiptYtb1nMMT4tFmdXd4nqsdnghi4Cf1Woi6uUUVUVJlRMJRg2PL2Fqy/GlyuGFwqSCqEUdSiwA4MILL8Rbb70Vybb0arF6DeIMcpM7rTiDjGSTDlMuSMDoAXFRaF3PEKOTkBKra3E9mvQybntzNy5IicGkQYkYlxmPGF2HN3Miom7F4vRib0EVcguqsPdMFWRJxJePzeTxJUxtOb7E6mXc8NqX6B9vwKTBCZg4MBH94/UcW0rUQIfOuOruW9GcgQMHdqgxvZlfUTB/WhZWbT3R6LX507JgcXrxk4lcb62xuLzNrse7sgdj58lynC6343S5Hf/59hxEARjRLw4TByVg0qBEDE4y8iBARD2Goqo4dc6G3IIq5ORX4cQ5KxpeNDdqJRz+vgZ3TRuMP2492Wh5Hl/arrXjyzd5lSi1ulFqdWNfYTXeQh76mfWYODABEwcn4OIBZuhkKQotJ+o+BFVV213XE0WxxZMzv7/79uO0WCwwm82oqalBXFzXXr1xe/340/ZTnBUqDHWzdrzRzOxa+WV25BZUIye/ErkFVThb5QxZPilGi4mDEjBxUALGZcbDqGU1g4i6F5vLh32FgURib0EVqp3ekNcHJxkxcVAiJg5KwIj0WMTo5Bb3izy+tE1rx5fCCgdOldmRc6YSuWeqcKTIAl+DLE8ribg4w4yJAxMwaXAC+pkNUfw21JsU1TgxNiMe6WZ968GdoD3nzh1KLA4cOBDyt9frxb59+/Dyyy/j2WefxY033tjet+wy0UwsAMDh8UEWRVQ7PTAbeB+LjtDJIuKNGsQbNahx+mA2yM3OM15icSH3TBVy8itx8PsaeBq8LokCRvaLw6TaRGNgIqsZRNT1VFXF6XI7cs5UIfdMFY6XWEKqEgaNhHGZ8cGLIskmXaP3aM9+kZrXnvXo8Phw8GxN8N+t3OYOeb2/WY9JgxMxcWACRg8wQyt3aCJOot6fWDRn8+bNePHFF7F9+/ZIvWXERTuxAACb24ejRTXQyxJPZMMgiQJkUYBPUds0S4fHp+Dw9zW1XQoqUVTjCnk92aSr7TKVgLEZ8TBoWdImos5hc/uwv7AaubVXv6scoVWJgYnG4P5oRL84aKS2nZS2d79ITWvvelRVFQWVjsCFrDNVOFpsCVlOJ4u4eIA5kGgMSkB6XHROEKln6rOJxcmTJzF27FjY7fZIvWXEdZfEYk9eBcwGbZsPFhR5RdVO5J4JDII8dLYGngZTScmigFH968dmZCQYmAQSUYepqor8CkewG823xaFVCb1GxNiM+qpEaixPPHsyh6cucQwkGpV2T8jrGQmG2i5TiRjVv+2JI/VNvT6xsFgsIX+rqori4mL87ne/w7Fjx7B///72vmWXYWJBTXH7/Dj0fQ1y8wMHgRJLaDUjNba+mjEmIx56DasZRNSyhieXuWeqUNHEyWWgKyZPLnuzdiWVAxOQymoGnafXJxZNDd5WVRWZmZlYv359t777NhMLao2qqiiqdiG3oBI5+VU4XFQDr7/+ZyKLAi4eYA5WMzjdIBEBrXeH0coixmaYgwOv2R2mb7K5fThQWB1MNCLVDY56r16fWJx/d21RFJGSkoIhQ4ZAlts/y86aNWvw4osvoqSkBGPHjsVrr72GyZMnNxm7bt06zJ8/P+Q5nU4Hl8vVZPz5mFhQe7m8fhw8Wz8245w1dIBeepw+OAB89AAzqxlEfYjT48eBs9WtD+AdlIDR/TmAl0Ipqoq8cnswGe3IwH3q/Xp9YhFJH374Ie68806sXbsWU6ZMwauvvoqNGzfi+PHjSE1NbRS/bt06PPzwwzh+/HjwOUEQkJaW1qbPY2JB4VBVFWer6sdmHP6+ptF0g6MHmIOJRv94TjdI1JvU7QPaMuUo9wHUXlaXF/sLA4nq3jOtTzUs8xyiT+iVicXHH3/c5gbccMMNbY6dMmUKLrnkEqxevRoAoCgKMjMzsXDhQjz++OON4tetW4dFixahurq6zZ/REBMLiiSnx4+D31cjp3ZsRlNXK+u6THG6QaKeKVC1rK9KNFu15E3SKIIUVcXp2vtm5ORX4btSKxqesBm1gWrGpEEJmDAwAUmsZvRaPSmxaHO/pTlz5rQpThCENt8gz+PxIDc3F0uXLg0+J4oirrrqKuzatavZ5Ww2GwYNGgRFUTBhwgSsWLECo0aNajLW7XbD7a4/CJw/8JwoHAathClZSZiSlRTSvzr3TBWOFFtQVONC0cFi/ONgMbSyiDF11YzBiexfTdRNqaqK72tnjcs507gyqZEEjO5vxqTBCZg4kOOsqHOIgoAhqSYMSTXhtksGosbpxb6CQLV875kqWFw+7DxVgZ2nKgAAFyTHBLtMXZQeB0nkNkldr82JhaJE/gY75eXl8Pv9jboxpaWl4dixY00uM3z4cLzzzjsYM2YMampq8NJLL2HatGk4cuQIMjIyGsWvXLkSy5cvj3jbic4nCAIGJcVgUFIMbpyQAYenboBe/YwwObUnKvjiNAbEG0LGZrB6RRQ9Lq8fh7+vv9lZUzPD1d3sbEwGx1JR1zMbNJgxPBUzhqfCr6g4VWZDTn4lcguqcKLUhtPldpwut2Nj7lnE6CSMz0wIzjSVEKONdvOpj4jqGIuioiIMGDAAO3fuDJlJ6te//jV27NiBr7/+utX38Hq9GDFiBObOnYtnnnmm0etNVSwyMzPZFYq6VN10g4EroJVNTjc4ZkB87RVQTjdI1BWKqp3BROLw943vZTN6QO1YicEJyIjnvWyo+6pxerG3oAo5+VXYV1AFq9sX8vqFKTGYVDs2Y1haLKsZPUyv7Ap1Prvdjh07dqCgoAAeT+jc3A899FCb3iM5ORmSJKG0tDTk+dLSUqSnp7fpPTQaDcaPH4+TJ082+bpOp4NOx36HFF2CICArOQZZyTG4eWJGcLrBum5TlQ4PvsmvxDf5lQCAzERj7c2TEjCS0w0SRYTHp9RWJSqRc6YKxTWhVYmUWF3wdzdmQDwMWlYlqGcwGzSYOTwVM2urGSdKrcgpqEJufhVOltlwqsyOU2V2fJhTiFidjPED4zFxUCImDIxHvJHVDIqcDiUW+/btw7XXXguHwwG73Y7ExESUl5fDaDQiNTW1zYmFVqvFxIkTsXXr1uAYDkVRsHXrVjz44INteg+/349Dhw7h2muv7chXIYoKk07GpUOScemQZKi10w3WXTk9VmJBYaUDhZUObNr/PQwaCWMzzZg4MHC1KSWWiTJRW5VYXMjNDyQSB7+vgcdXX5WQRAGj+sUF+6UPTDSyKkE9niQKuKhfHC7qF4efTRmEKocHe2tnMtxbW8344kQ5vjhRDgHAkFRT8EaNQ1JNrGZQWDrUFWrGjBkYNmwY1q5dC7PZjAMHDkCj0eBnP/sZHn74Ydx4441tfq8PP/wQ8+bNwxtvvIHJkyfj1VdfxYYNG3Ds2DGkpaXhzjvvxIABA7By5UoAwNNPP42pU6diyJAhqK6uxosvvohNmzYhNzcXI0eObPXzOCsUdXc2lw/7CgNjMfYWVKH6vJsnDUo0BrtMjegXx+kGiRrw+gNVibqB199XO0NeT4rRBsc2jc2Mh1Hb4cI9UY/jV1QcL7UGx2acLrOHvB6nlzGhdqrk8QMTYDZootRSaqjXd4Xav38/3njjDYiiCEmS4Ha7ccEFF+CFF17AvHnz2pVY3HrrrSgrK8NTTz2FkpISjBs3Dlu2bAkO6C4oKIAo1p84VVVV4d5770VJSQkSEhIwceJE7Ny5s01JBVFPYNLLuHxoCi4fmhKcbjC3tuvG8RIrzlQ6cKbSgb/t/R5GrYSxGfVjMzjdIPVF5yyu2htYVuHg99VweeurEqIAjOgXh0mDEjFpUAIGJbEqQX2XJAoY2S8OI/vF4c7swai0B6oZOWcqsa+wGhaXD9u/K8P278ogABiWFhu8C/iFqSaI/O1QKzpUsUhJScHOnTsxdOhQDBs2DK+99hpmzZqFY8eOYeLEibDb7a2/SZSwYkE9mcXpxb7CauTW3pzL4godoJeVHBPsI96W6QYlUYAsCvApKvxKVO+V2aNxPUZGW9ej16/gaLEFOfmB7h2FlY6Q1xON2mD3prGZ8TDpWJUgao3Pr+BYibW2W24l8itCf1fxBk2DakY8YvWtVzO4bwyfJAqocngwJNWEtChN7NLpd96+5pprcNddd+GnP/0p7r33Xhw8eBAPPfQQ3n//fVRVVbVpNqdoYWJBvYWiqjh5zhacaepEqS3k5kkxWgnjBgauNJ0/3aBOFhEfo0G8QYMapxdmgwbVDi+qHV64fZGfWrq34nqMjLasxzKru/aO95U4UFgDp7f+fkmiAFyUHhe8spqVHMOqBFGYym3u4AQj+wurG/3mhqfFYmLtFMwXpMSEVDO4bwxfw3VY7fAi3qiFT1Gi0n2z0xOLnJwcWK1WzJw5E+fOncOdd94ZrGC88847GDt2bIcb39mYWFBvVTfdYO6ZwM2TmppucOKgRMwcnoLpw1OwdscprNuZD4vThziDjPnTsvCL6RfgbKWTO/420MkiMhINXI9hamk93nv5BViz7QT+eagEZ86rSsQbA1dPJw1KwPjMBJj0rEoQdRavX8G3xZbg2KWC836PCXW/x8GJyL4gCcPSTdw3hqGl/eL9My6Erovvo9PpiUVPxsSC+gK/ouLEOWtwpqmT52zB1966cyIOnq3Ba583nqL54f8ZilsnZYbEU9OGpJqwPqcAf9zK9RiOltbjwiuH4OIBZix4PxeiEOjvXTd7zflXSImo65yzuoLVjANnQ8c18RgTvtaOL7+YfkGXVi46PbH4/e9/j9tvvx1ZWVkdbmS0MLGgvqjK4cG+giocL7XipZ+MxdSVW2Fx+hrFxRlk7F76P7js+W2otHuaeCcCgMQYLb58bCbXY5jash6/XnoV/vr1GYxIj0McZ6gh6na8fgVHiyzIOVOJU+ds+PCX2dw3hqEt+8Wc314Nrdx154+dPivUxo0bsWzZMkyZMgU/+9nPcMsttyA5OblDjSWizpdg1OLKi9Iwe3Q/2N2+JndWAGBx+lBp9yDVpEMVd/rNSjXpUGHzcD2GqS3r0eb24YqhKew6QdRNaSQRYzPjMTYzHjpZhM3FY0w42rJftLq83XYWyA4lFgcOHMCRI0fw17/+FS+99BIWLVqEq6++GrfffjvmzJkDo9EY6XYSUQT4FBVmgwZxBrnZKyGpsTq8fOs4zuDRAkkUkBan43oMU1vWo9kgo8zqjkLriKi9fIqKeCOPMeFoy36xLTNyRUuH6yijRo3CihUrcPr0aWzbtg2DBw/GokWLkJ6eHsn2EVEE+RUV1U4v5k9ruhvj/GlZqHZ4ucNvBddjZHA9EvUu/E2Hry3r0Kd03wpuREZ+xMTEwGAwQKvVwmq1RuItiaiTVNu9+MX0CwAA7+7Ma3LGDmod12NkcD0S9S78TYevpXUYjVmh2qPDs0Ll5eXhgw8+wAcffIDjx49j+vTp+OlPf4qbb74ZZrM50u2MGA7eJqqdH9uoQbxRgxqnD2aDzDnGO4DrMTK4Hol6F/6mw9dwHVY7vYg39OL7WEydOhV79uzBmDFjcPvtt2Pu3LkYMGBAhxvclZhYENXjXVEjg+sxMrgeiXoX/qbD19PuvN2htOd//ud/8M4772DkyJHoY7fBIOpV/NzZRwTXY2RwPRL1LvxNh8+vqLC5fegpp9sdulz+7LPPYteuXRg9ejT0ej30ej1Gjx6Nt99+O9LtIyIiIiKiHqBDFYunnnoKL7/8MhYuXIjs7GwAwK5du/DII4+goKAATz/9dEQbSURERERE3VuHEovXX38db731FubOnRt87oYbbsCYMWOwcOFCJhZERERERH1Mh7pCeb1eTJo0qdHzEydOhM/X9J0CiYiIiIio9+pQYnHHHXfg9ddfb/T8m2++idtvvz3sRhERERERUc/S4clw//znP+Pf//43pk6dCgD4+uuvUVBQgDvvvBOLFy8Oxr388svht5KIiIiIiLq1DiUWhw8fxoQJEwAAp06dAgAkJycjOTkZhw8fDsYJghCBJhIRERERUXfXocRi27ZtkW4HERERERH1YLztMxERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERhY2JBRERERERha1DN8ij8AmCgHNWF0TenTxsBo2EGJ0MjcQ8mYj6Lo9Pgd3jg9PrB48s4VOhQidJMGpl6DUiBB6viVrFxCIKDBoJw9JioahqtJvS47m8fpTbPKhyeuD1K9CKEmJ0EvQaiUkbEfVqiqrC6fHD7vHB61ehlQWYdDIyEgzQyrzQEi5VBcptblicXlQ5FUiCAINGglErQeaFLKImMbGIAkkU0D/eEO1m9BpZySpsbh+sLi8qbB7UOL2ocXoBAEatDKNWYjWDiHoFr1+B3e2Do7YqYdBKSI3TISlGB5NehkkrQxR5USVSMhONcHr8sLq8qHYEjjEVdg98igq9LLKaQXQeJhbU40miALNBA7NBg4wEI1xeP6wuH2qcnpBqRqCkLcGgkXgQIKIeoa4q4fD44fUr0MgCjFoZQ+INMBs1MOlk6DVStJvZqxm0Um0Cp4fPr9ReyPIFqxmVjkA1w6hlNYOIiQX1OnpNoCtUSqyuyWpGtcMDURRg0LCaQUTdT11Vwun1Awic2CaZtEiO1SGWVYmokiUR8UYt4o1aZCQY4Ky9kFXt8DSqZsToZOhkVjOob2FiQb1aU9UMi8uLGocXFXYPKh0e+PwKdDKrGUQUHYqqwuX1w+72w6P4oZFExGhl9IvXw2zQIlbPqkR3JAhCbXdbGWm11Qyryweb24dzVhesLh8qHQpEQUCMNjAIXGJCSL0cEwvqU+qqGamxelygqLC5fLC4vKi0e1Dt9KDa6YUogNUMIupUXr8Ch8cPh8cHVVVh0MpIMmmRZNIiVh/o4sST0J5FlkQkxGiREBNazaiyByoZ5TY3/IoKfe0AcCaL1BsxsaA+SxIFmI0amI2a+gF67kA1o9xaX83Qy5xukIjCo6oqnN7AWAm3v74qcUFKDKsSvdD51QyvX4HNFRibUWarq2a4IQoiqxnUqzCxIKoVHKAXq0dWsgK7O9BtqtzmhsVVP92gXiMhhgP0iKgVdVUJp9cHRQlUJRJjWJXoizQNqhmZiQY4PLXVDIcHlXYPyqxu+FUlWC1nkkk9FRMLoibIkgizUQytZpw33aBfVaGTON0gEQWEVCV8fsiSCJNOxuC4GJiNGsTpNTxhJAiCgBidjBidjHRzoJphdQUmGSmzumGrrWZIQqCqZdBKTECpx2BiQdQGnG6QiJoSUpVQAb1GRGKMFokxWsTpNTDpWZWglmmk+m1mYKIRdo8/mFxU2gPJhgIFBjmQZDA5pe6MiQVRO3G6QaK+S1VVuLwKHB4fXD4/ZDFwVXlwUgzMBg1i9RoYtDzxo44RhMDd00211QyPL3Ahy1J7Xyaby4dKuxuSyGoGdU9MLIjC0NR0g3XVjDKbC1Zn/XSDRo2EGPapJupxfH4Fdo8fLq8fflWFXhPoJnmhyYQ4vQYxOlYpqXNoZRGJcqCaMShJhb22W26lzYMqpxdlNhcUVYVBlmHUSdDJTGopuphYEEVQc9WMKntggF7ddIM6VjOIuq2GVQm3P9DNMUYrY2CiEfFGViUoOhpWM/qZDfD4FFhd3sDYDJsncCNYnxuyKMKok2HQsJpBXY+JBVEnadt0g35ON0jUDfiC95UIVCUMtVWJZFPt3a51MqsS1K1oZRFJJh2STDoMSlJhcwduzldp86DK4UGZzQtFCYwRNGpZzaCuwcSCqItwukGi7kNVVbh9CuxuH1w+BbIYmHxhYJIB8cbAfSUMGokVReoRBEFArD5QTetnNsDtCwwAtzi9KLO5A9UMv6d2Ow8cY0Ru29QJmFgQRUF7phs0sppBFBF+RYXd7YPD64eiBiZYiDPKuNCkh0knI1bPqgT1DjpZgs4k1VYzYmD3BKrllXYPqh0elFq8UNVANSNGK0Mrc7unyOi7iYXdDkhNXBGWJECvD41rjigCBkPHYh0OQFWbjhUEwGjsWKzTCShK8+2IielYrMsF+P2RiTUaA+0GALcb8PkiE2swBNYzAHg8gNcbmVi9vn5baU+s1xuIb45OB8iBn6BG8SMRXiTqgYE6LRweKZBcON2otrtQbpfhl0XoZRlGUYVBbX49qBotoNEE/vD5IHjcbYv1+yG4Xc23V9ZA1WrbH6soEFzOyMRKMlSdrrbxKgSnIzKxogS1we9ecLT0W25HrCBCbfC7b1ess+XfvWowdjDWCajN/+5VY0zHYl0uQGn+d9+uWEP9715wuwF/C9t7C7GqqsJTW5Xw+FTAaIBRr0FmggEJGiBWUmurEioAL+Bq8NvuZvuIdsX6fIH9ZXO0ofuINsf6/YH9e3M0mkB8e2MVJXA8ikSsLAfWBRD4TTha+N23J7Y95wbd7DxCFAXEKl7EalT0j5fhNgmBC1lOLyrsTljtfrg0BmikwFgio+KB2Nz7onftIxrF6ut/94LHA/ia/y23K1ZX/7tvTyy8XgheDySHC4JdA8jnrZOu2ke0tF02+gJ9TE1NjQpArQn8HBs/rr02dAGjsek4QFWnTw+NTU5uPnbSpNDYQYOajx05MjR25MjmYwcNCo2dNKn52OTk0Njp05uPNRpDY6+9tvnY8zejm29uOdZmq4+dN6/l2HPn6mPvv7/l2Ly8+tglS1qOPXy4PnbZspZjv/mmPvaFF1qO3batPnb16pZjP/mkPvbdd1uMtfzvB2pemVXdk1ehHn7lrRZjC/6wRj1YWK0eLKxW89Z92GLs2WdeDMae2vCPFmOLfvt0MPbEPz5vMbbkkceCscf/s6vF2HO/WBiM/XbngRZjy++8Jxh7ZP/JFmMrb54bjD10/PsWY6uv+1Ew9mBhdYuxNVdeExLrNzS/j7BOvTQk1puY1Gysfcz4kFh3Rmazsc5hF4XEOodd1GysOyMzJNY+Znyzsd7EpJBY69RLm431G4whsTVXXtPiemsYW33dj1qMPXT8+2Bs5c1zW4w9sv9kMLb8znta/nc+clz1+Py9ch+hbthQH7thQ8ux775bH/vJJy3Hrl5dH7ttW8uxL7xQH/vNNy3HLltWH3v4cMuxS5bUx+bltRx7//31sefOtRw7b159rM3WcuzNN6shWortYecR/oGD1O+rHOrBs1XqF9+dU6tHjW02trfvI77deSAYe+4XC1uMPf6fXcHYkkceazH2xD8+D8YW/fbpFmNPbfhHMPbsMy+2vK110T6iBlABqDU1NWpr+m7FgqgHidXLiE02YVCSCleqKdrNIepWXLV3u45ze5HUQpzZqAXY1YkohCgA/eMN6B9vgMvrh6TjqSF1nBBIvPsOi8UCs9mMmqIixMXFNQ7oZiXMdseyK1Tg/3tYV6iOljDrphu0ubwot3tgc3nhFmRIOl1gukFBhexr/n3ZFaoWu0IF9YRuDoqiwunxw+7xwavXQyfLMOllpGiBWFlArF6GpqkEog/uI5rErlDtj+3BXaHaHVt7bqAoKmweH2wuHypsblhcXrg8CnxGY/C+TFqPu1vuIzoc2027QpXUuHDxADPSzPrQ4C7aR1jKymDu3x81NTVNnzs30C0SizVr1uDFF19ESUkJxo4di9deew2TJ09uNn7jxo148sknkZ+fj6FDh+L555/Htdde26bPCiYWbVg5RD2JqjaebtDp9QemG9RIvHkS9Wh1VQmXzwcRIow6CQkxGiQaA9PBGrWcwYmoM7lq78tUU3sXcLvHB69PgVaSEKMLzGTImaY6R1GNE2Mz4pF+fmLRRdpz7hz1eteHH36IxYsXY+3atZgyZQpeffVVzJo1C8ePH0dqamqj+J07d2Lu3LlYuXIlfvjDH+KDDz7AnDlzsHfvXowePToK34Coe2hpusFyu6d+ukFB4M2TqNvzN6hK+BUFOlmCSS9jUJIBcQYtTDrOZEPUlfSaQPKQEqtDVnLgQpbV5UWFzYMapxc1zsBV+LrpbJusGlKvF/WKxZQpU3DJJZdg9erVAABFUZCZmYmFCxfi8ccfbxR/6623wm6345NPPgk+N3XqVIwbNw5r165tFO92u+FuUO6xWCzIzMxkxYL6FEVRg9MNVtkD1QyHxw9VDUw3qBF5AKDuwetX4PT5IAoCDFoZiTEaJBi1iNVrEMOqBFG31GQ1w69AJ0nQySIE8HcbjmqXB+MzE1ixaI3H40Fubi6WLl0afE4URVx11VXYtWtXk8vs2rULixcvDnlu1qxZ2LRpU5PxK1euxPLlyyPWZqKeSBTrqxn94wPVjLrpBstsbvj8Ue8RSQQAMOgCN6mr215ZlSDq/lqqZtjdPqjgMSYcCUYtNFLPSM6imliUl5fD7/cjLS0t5Pm0tDQcO3asyWVKSkqajC8pKWkyfunSpSGJSF3Fgqgvq7t5UrJJh8HJMVC4z6duQhTAqgRRDyaJAswGDcwGDTISjPDzABMRPaXrctTHWHQ2nU4HXd2sD0TUiCAI6CEXQoiIqIfpKSfEFBlRrTEnJydDkiSUlpaGPF9aWor09PQml0lPT29XPBERERERdb6oJhZarRYTJ07E1q1bg88pioKtW7ciOzu7yWWys7ND4gHgs88+azaeiIiIiIg6X9S7Qi1evBjz5s3DpEmTMHnyZLz66quw2+2YP38+AODOO+/EgAEDsHLlSgDAww8/jOnTp+MPf/gDrrvuOqxfvx45OTl488032/R5dZNgWSyWzvlCRERERES9RN05c5smklW7gddee00dOHCgqtVq1cmTJ6u7d+8OvjZ9+nR13rx5IfEbNmxQhw0bpmq1WnXUqFHq5s2b2/xZhYWFKgA++OCDDz744IMPPvjgo42PwsLCVs+zo34fi66mKAqKiooQGxvb5TOP1M1IVVhYyHtoUIdxO6JI4HZE4eI2RJHA7aj7U1UVVqsV/fv3h9jKfa+i3hWqq4miiIyMjKi2IS4ujj8eChu3I4oEbkcULm5DFAncjro3s9ncpjjeeYiIiIiIiMLGxIKIiIiIiMLGxKIL6XQ6LFu2jDfso7BwO6JI4HZE4eI2RJHA7ah36XODt4mIiIiIKPJYsSAiIiIiorAxsSAiIiIiorAxsSAiIiIiorAxsSAiIiIiorAxsYiwNWvWYPDgwdDr9ZgyZQq++eabFuM3btyIiy66CHq9HhdffDH++c9/dlFLqTtrz3a0bt06CIIQ8tDr9V3YWupuvvjiC1x//fXo378/BEHApk2bWl1m+/btmDBhAnQ6HYYMGYJ169Z1ejupe2vvdrR9+/ZG+yJBEFBSUtI1DaZuZ+XKlbjkkksQGxuL1NRUzJkzB8ePH291OZ4b9VxMLCLoww8/xOLFi7Fs2TLs3bsXY8eOxaxZs3Du3Lkm43fu3Im5c+fi7rvvxr59+zBnzhzMmTMHhw8f7uKWU3fS3u0ICNyxtLi4OPg4c+ZMF7aYuhu73Y6xY8dizZo1bYrPy8vDddddh5kzZ2L//v1YtGgR7rnnHnz66aed3FLqztq7HdU5fvx4yP4oNTW1k1pI3d2OHTvwwAMPYPfu3fjss8/g9XpxzTXXwG63N7sMz416Nk43G0FTpkzBJZdcgtWrVwMAFEVBZmYmFi5ciMcff7xR/K233gq73Y5PPvkk+NzUqVMxbtw4rF27tsvaTd1Le7ejdevWYdGiRaiuru7illJPIAgCPvroI8yZM6fZmMceewybN28OOXDfdtttqK6uxpYtW7qgldTdtWU72r59O2bOnImqqirEx8d3Wduo5ygrK0Nqaip27NiBK664oskYnhv1bKxYRIjH40Fubi6uuuqq4HOiKOKqq67Crl27mlxm165dIfEAMGvWrGbjqffryHYEADabDYMGDUJmZiZ+9KMf4ciRI13RXOoluC+iSBo3bhz69euHq6++Gl999VW0m0PdSE1NDQAgMTGx2Rjuj3o2JhYRUl5eDr/fj7S0tJDn09LSmu1fWlJS0q546v06sh0NHz4c77zzDv7+97/jL3/5CxRFwbRp03D27NmuaDL1As3tiywWC5xOZ5RaRT1Nv379sHbtWvztb3/D3/72N2RmZmLGjBnYu3dvtJtG3YCiKFi0aBEuvfRSjB49utk4nhv1bHK0G0BE4cnOzkZ2dnbw72nTpmHEiBF444038Mwzz0SxZUTUlwwfPhzDhw8P/j1t2jScOnUKr7zyCt5///0otoy6gwceeACHDx/Gl19+Ge2mUCdixSJCkpOTIUkSSktLQ54vLS1Fenp6k8ukp6e3K556v45sR+fTaDQYP348Tp482RlNpF6ouX1RXFwcDAZDlFpFvcHkyZO5LyI8+OCD+OSTT7Bt2zZkZGS0GMtzo56NiUWEaLVaTJw4EVu3bg0+pygKtm7dGnI1uaHs7OyQeAD47LPPmo2n3q8j29H5/H4/Dh06hH79+nVWM6mX4b6IOsv+/fu5L+rDVFXFgw8+iI8++giff/45srKyWl2G+6MeTqWIWb9+varT6dR169apR48eVRcsWKDGx8erJSUlqqqq6h133KE+/vjjwfivvvpKlWVZfemll9Rvv/1WXbZsmarRaNRDhw5F6ytQN9De7Wj58uXqp59+qp46dUrNzc1Vb7vtNlWv16tHjhyJ1legKLNareq+ffvUffv2qQDUl19+Wd23b5965swZVVVV9fHHH1fvuOOOYPzp06dVo9GoPvroo+q3336rrlmzRpUkSd2yZUu0vgJ1A+3djl555RV106ZN6okTJ9RDhw6pDz/8sCqKovqf//wnWl+Bouy+++5TzWazun37drW4uDj4cDgcwRieG/UuTCwi7LXXXlMHDhyoarVadfLkyeru3buDr02fPl2dN29eSPyGDRvUYcOGqVqtVh01apS6efPmLm4xdUft2Y4WLVoUjE1LS1OvvfZade/evVFoNXUX27ZtUwE0etRtN/PmzVOnT5/eaJlx48apWq1WveCCC9R33323y9tN3Ut7t6Pnn39evfDCC1W9Xq8mJiaqM2bMUD///PPoNJ66haa2HwAh+xeeG/UuvI8FERERERGFjWMsiIiIiIgobEwsiIiIiIgobEwsiIiIiIgobEwsiIiIiIgobEwsiIiIiIgobEwsiIiIiIgobEwsiIiIiIgobEwsiIiIiIgobEwsiIgoqjweD4YMGYKdO3cCAPLz8yEIAvbv3x+V9jz++ONYuHBhVD6biKgnY2JBRNRHlZWV4b777sPAgQOh0+mQnp6OWbNm4auvvgrGDB48GIIgYPfu3SHLLlq0CDNmzAj+/bvf/Q6CIEAQBEiShMzMTCxYsACVlZWttmPt2rXIysrCtGnTIvbdAGDGjBlYtGhRu5dbsmQJ3nvvPZw+fTqi7SEi6u2YWBAR9VE33XQT9u3bh/feew/fffcdPv74Y8yYMQMVFRUhcXq9Ho899lir7zdq1CgUFxejoKAA7777LrZs2YL77ruvxWVUVcXq1atx9913h/VdIik5ORmzZs3C66+/Hu2mEBH1KEwsiIj6oOrqavz3v//F888/j5kzZ2LQoEGYPHkyli5dihtuuCEkdsGCBdi9ezf++c9/tviesiwjPT0dAwYMwFVXXYWf/OQn+Oyzz1pcJjc3F6dOncJ1113X6LVjx45h2rRp0Ov1GD16NHbs2BHy+uHDhzF79myYTCakpaXhjjvuQHl5OQDgrrvuwo4dO7Bq1apgJSU/Px9+vx933303srKyYDAYMHz4cKxatarRZ19//fVYv359i20nIqJQTCyIiPogk8kEk8mETZs2we12txiblZWFX/7yl1i6dCkURWnT++fn5+PTTz+FVqttMe6///0vhg0bhtjY2EavPfroo/jVr36Fffv2ITs7G9dff32wmlJdXY0rr7wS48ePR05ODrZs2YLS0lLccsstAIBVq1YhOzsb9957L4qLi1FcXIzMzEwoioKMjAxs3LgRR48exVNPPYXf/OY32LBhQ8hnT548GWfPnkV+fn6bvi8RETGxICLqk2RZxrp16/Dee+8hPj4el156KX7zm9/g4MGDTcY/8cQTyMvLw1//+tdm3/PQoUMwmUwwGAzIysrCkSNHWu1CdebMGfTv37/J1x588EHcdNNNGDFiBF5//XWYzWb8+c9/BgCsXr0a48ePx4oVK3DRRRdh/PjxeOedd7Bt2zZ89913MJvN0Gq1MBqNSE9PR3p6OiRJgkajwfLlyzFp0iRkZWXh9ttvx/z58xslFnVtOnPmTIvtJyKiekwsiIj6qJtuuglFRUX4+OOP8YMf/ADbt2/HhAkTsG7dukaxKSkpWLJkCZ566il4PJ4m32/48OHYv38/9uzZg8ceewyzZs1qdXYlp9MJvV7f5GvZ2dnB/5dlGZMmTcK3334LADhw4AC2bdsWrLyYTCZcdNFFAIBTp061+Jlr1qzBxIkTkZKSApPJhDfffBMFBQUhMQaDAQDgcDhafC8iIqrHxIKIqA/T6/W4+uqr8eSTT2Lnzp246667sGzZsiZjFy9eDKfTiT/96U9Nvq7VajFkyBCMHj0azz33HCRJwvLly1v8/OTkZFRVVbW73TabDddffz32798f8jhx4gSuuOKKZpdbv349lixZgrvvvhv//ve/sX//fsyfP79RslQ3m1VKSkq720ZE1FcxsSAioqCRI0fCbrc3+ZrJZMKTTz6JZ599FlartdX3euKJJ/DSSy+hqKio2Zjx48fj2LFjUFW10WsNp7j1+XzIzc3FiBEjAAATJkzAkSNHMHjwYAwZMiTkERMTAyCQ6Pj9/pD3/OqrrzBt2jTcf//9GD9+PIYMGdJkhePw4cPQaDQYNWpUq9+TiIgCmFgQEfVBFRUVuPLKK/GXv/wFBw8eRF5eHjZu3IgXXngBP/rRj5pdbsGCBTCbzfjggw9a/Yzs7GyMGTMGK1asaDZm5syZsNlsOHLkSKPX1qxZg48++gjHjh3DAw88gKqqKvz85z8HADzwwAOorKzE3LlzsWfPHpw6dQqffvop5s+fH0wmBg8ejK+//hr5+fkoLy+HoigYOnQocnJy8Omnn+K7777Dk08+iT179jT67P/+97+4/PLLg12iiIiodUwsiIj6IJPJhClTpuCVV17BFVdcgdGjR+PJJ5/Evffei9WrVze7nEajwTPPPAOXy9Wmz3nkkUfw9ttvo7CwsMnXk5KS8OMf/7jJQeHPPfccnnvuOYwdOxZffvklPv74YyQnJwMIDK7+6quv4Pf7cc011+Diiy/GokWLEB8fD1EMHNqWLFkCSZIwcuRIpKSkoKCgAL/4xS9w44034tZbb8WUKVNQUVGB+++/v9Fnr1+/Hvfee2+bviMREQUIalP1ZyIioi5y8OBBXH311Th16hRMJlO0m4N//etf+NWvfoWDBw9CluVoN4eIqMdgxYKIiKJqzJgxeP7555GXlxftpgAA7HY73n33XSYVRETtxIoFERERERGFjRULIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIKGxMLIiIiIiIK2/8HVEOMSDr/O/AAAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -554,38 +881,30 @@ } ], "source": [ - "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "fig, axs = plt.subplots(3, 1, figsize=(8, 6), sharey=True, sharex=True)\n", "axs = axs.flatten()\n", "\n", - "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X500\"]):\n", " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", "\n", " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", - " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (beta)\")\n", " ax.legend()\n", - "fig.suptitle(\"Linear ANCOVA model with Coleman Forest\")\n", + "fig.suptitle(\"Correlated Logit model with Coleman Forest (permute per tree)\")\n", "fig.tight_layout()" ] }, { "cell_type": "code", - "execution_count": null, - "id": "0f772759-751d-440c-abcb-13f3ee6f7705", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "7cf30622-ffff-4d00-b474-0ac49fcfde4b", + "execution_count": 23, + "id": "34294429-04f3-4b12-baf3-fa6fdc11646f", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -593,23 +912,23 @@ } ], "source": [ - "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "fig, axs = plt.subplots(3, 1, figsize=(8, 6), sharey=True, sharex=True)\n", "axs = axs.flatten()\n", "\n", - "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X500\"]):\n", " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", "\n", " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", - " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (beta)\")\n", " ax.legend()\n", - "fig.suptitle(\"Linear ANCOVA model with Permutation Forest\")\n", + "fig.suptitle(\"Correlated Logit model with Coleman Forest (permute per tree)\")\n", "fig.tight_layout()" ] }, { "cell_type": "code", "execution_count": null, - "id": "34294429-04f3-4b12-baf3-fa6fdc11646f", + "id": "0f1ea3aa-ebad-4ff5-ae7b-abe3aa8308b6", "metadata": {}, "outputs": [], "source": [] diff --git a/sktree/stats/__init__.py b/sktree/stats/__init__.py index 0061cd66a..95702f9e5 100644 --- a/sktree/stats/__init__.py +++ b/sktree/stats/__init__.py @@ -1,3 +1,3 @@ from ._might import MIGHT, MIGHT_MV -from .forestht import FeatureImportanceForestRegressor, ForestHT +from .forestht import FeatureImportanceForestClassifier, FeatureImportanceForestRegressor, ForestHT from .permutationforest import PermutationForestClassifier, PermutationForestRegressor diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 3ad77c8f8..a761c8660 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -8,9 +8,10 @@ BaseForest, ForestClassifier, ForestRegressor, + RandomForestClassifier, RandomForestRegressor, ) -from sktree._lib.sklearn.tree import DecisionTreeRegressor +from sktree._lib.sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor from ..ensemble import HonestForestClassifier from .utils import ( @@ -1171,3 +1172,578 @@ def test( self.null_dist_ = null_dist return observe_stat, pvalue + + +class FeatureImportanceForestClassifier(BaseForestHT): + """Forest hypothesis testing with categorical `y` variable. + + The dataset is split into a training and testing dataset initially. Then there + are two forests that are trained: one on the original dataset, and one on the + permuted dataset. The dataset is either permuted once, or independently for + each tree in the permuted forest. The original test statistic is computed by + comparing the metric on both forests ``(metric_forest - metric_perm_forest)``. + + Then the output predictions are randomly sampled to recompute the test statistic + ``n_repeats`` times. The p-value is computed as the proportion of times the + null test statistic is greater than the original test statistic. + + Parameters + ---------- + estimator : object, default=None + Type of forest estimator to use. By default `None`, which defaults to + :class:`sklearn.ensemble.RandomForestRegressor`. + + n_estimators : int, default=100 + The number of trees in the forest. + + criterion : {"gini", "entropy"}, default="gini" + The function to measure the quality of a split. Supported criteria are + "gini" for the Gini impurity and "entropy" for the information gain. + Note: this parameter is tree-specific. + + splitter : {"best", "random"}, default="best" + The strategy used to choose the split at each node. Supported + strategies are "best" to choose the best split and "random" to choose + the best random split. + + max_depth : int, default=None + The maximum depth of the tree. If None, then nodes are expanded until + all leaves are pure or until all leaves contain less than + min_samples_split samples. + + min_samples_split : int or float, default=2 + The minimum number of samples required to split an internal node: + + - If int, then consider `min_samples_split` as the minimum number. + - If float, then `min_samples_split` is a fraction and + `ceil(min_samples_split * n_samples)` are the minimum + number of samples for each split. + + min_samples_leaf : int or float, default=1 + The minimum number of samples required to be at a leaf node. + A split point at any depth will only be considered if it leaves at + least ``min_samples_leaf`` training samples in each of the left and + right branches. This may have the effect of smoothing the model, + especially in regression. + + - If int, then consider `min_samples_leaf` as the minimum number. + - If float, then `min_samples_leaf` is a fraction and + `ceil(min_samples_leaf * n_samples)` are the minimum + number of samples for each node. + + min_weight_fraction_leaf : float, default=0.0 + The minimum weighted fraction of the sum total of weights (of all + the input samples) required to be at a leaf node. Samples have + equal weight when sample_weight is not provided. + + max_features : {"sqrt", "log2", None}, int or float, default="sqrt" + The number of features to consider when looking for the best split: + + - If int, then consider `max_features` features at each split. + - If float, then `max_features` is a fraction and + `round(max_features * n_features)` features are considered at each + split. + - If "auto", then `max_features=sqrt(n_features)`. + - If "sqrt", then `max_features=sqrt(n_features)`. + - If "log2", then `max_features=log2(n_features)`. + - If None, then `max_features=n_features`. + + Note: the search for a split does not stop until at least one + valid partition of the node samples is found, even if it requires to + effectively inspect more than ``max_features`` features. + + max_leaf_nodes : int, default=None + Grow trees with ``max_leaf_nodes`` in best-first fashion. + Best nodes are defined as relative reduction in impurity. + If None then unlimited number of leaf nodes. + + min_impurity_decrease : float, default=0.0 + A node will be split if this split induces a decrease of the impurity + greater than or equal to this value. + + The weighted impurity decrease equation is the following:: + + N_t / N * (impurity - N_t_R / N_t * right_impurity + - N_t_L / N_t * left_impurity) + + where ``N`` is the total number of samples, ``N_t`` is the number of + samples at the current node, ``N_t_L`` is the number of samples in the + left child, and ``N_t_R`` is the number of samples in the right child. + + ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, + if ``sample_weight`` is passed. + + bootstrap : bool, default=True + Whether bootstrap samples are used when building trees. If False, the + whole dataset is used to build each tree. + + oob_score : bool, default=False + Whether to use out-of-bag samples to estimate the generalization score. + Only available if bootstrap=True. + + n_jobs : int, default=None + The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`, + :meth:`decision_path` and :meth:`apply` are all parallelized over the + trees. ``None`` means 1 unless in a `joblib.parallel_backend` + context. ``-1`` means using all processors. See :term:`Glossary + ` for more details. + + random_state : int, RandomState instance or None, default=None + Controls both the randomness of the bootstrapping of the samples used + when building trees (if ``bootstrap=True``) and the sampling of the + features to consider when looking for the best split at each node + (if ``max_features < n_features``). + See :term:`Glossary ` for details. + + verbose : int, default=0 + Controls the verbosity when fitting and predicting. + + warm_start : bool, default=False + When set to ``True``, reuse the solution of the previous call to fit + and add more estimators to the ensemble, otherwise, just fit a whole + new forest. See :term:`the Glossary `. + + class_weight : {"balanced", "balanced_subsample"}, dict or list of dicts, \ + default=None + Weights associated with classes in the form ``{class_label: weight}``. + If not given, all classes are supposed to have weight one. For + multi-output problems, a list of dicts can be provided in the same + order as the columns of y. + + Note that for multioutput (including multilabel) weights should be + defined for each class of every column in its own dict. For example, + for four-class multilabel classification weights should be + [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of + [{1:1}, {2:5}, {3:1}, {4:1}]. + + The "balanced" mode uses the values of y to automatically adjust + weights inversely proportional to class frequencies in the input data + as ``n_samples / (n_classes * np.bincount(y))`` + + The "balanced_subsample" mode is the same as "balanced" except that + weights are computed based on the bootstrap sample for every tree + grown. + + For multi-output, the weights of each column of y will be multiplied. + + Note that these weights will be multiplied with sample_weight (passed + through the fit method) if sample_weight is specified. + + ccp_alpha : non-negative float, default=0.0 + Complexity parameter used for Minimal Cost-Complexity Pruning. The + subtree with the largest cost complexity that is smaller than + ``ccp_alpha`` will be chosen. By default, no pruning is performed. See + :ref:`minimal_cost_complexity_pruning` for details. + + max_samples : int or float, default=None + If bootstrap is True, the number of samples to draw from X + to train each base tree estimator. + + - If None (default), then draw `X.shape[0]` samples. + - If int, then draw `max_samples` samples. + - If float, then draw `max_samples * X.shape[0]` samples. Thus, + `max_samples` should be in the interval `(0.0, 1.0]`. + + Attributes + ---------- + samples_ : ArrayLike of shape (n_samples,) + The indices of the samples used in the final test. + + y_true_final_ : ArrayLike of shape (n_samples_final,) + The true labels of the samples used in the final test. + + posterior_final_ : ArrayLike of shape (n_samples_final,) + The predicted posterior probabilities of the samples used in the final test. + + null_dist_ : ArrayLike of shape (n_repeats,) + The null distribution of the test statistic. + """ + + def __init__( + self, + estimator=None, + n_estimators=100, + criterion="gini", + max_depth=None, + min_samples_split=2, + min_samples_leaf=1, + min_weight_fraction_leaf=0.0, + max_features="sqrt", + max_leaf_nodes=None, + min_impurity_decrease=0.0, + bootstrap=False, + oob_score=False, + n_jobs=None, + random_state=None, + verbose=0, + warm_start=False, + ccp_alpha=0.0, + max_samples=None, + permute_per_tree=True, + sample_dataset_per_tree=False, + **estimator_kwargs, + ): + super().__init__( + estimator=estimator, + n_estimators=n_estimators, + criterion=criterion, + max_depth=max_depth, + min_samples_split=min_samples_split, + min_samples_leaf=min_samples_leaf, + min_weight_fraction_leaf=min_weight_fraction_leaf, + max_features=max_features, + max_leaf_nodes=max_leaf_nodes, + min_impurity_decrease=min_impurity_decrease, + bootstrap=bootstrap, + oob_score=oob_score, + n_jobs=n_jobs, + random_state=random_state, + verbose=verbose, + warm_start=warm_start, + ccp_alpha=ccp_alpha, + max_samples=max_samples, + **estimator_kwargs, + ) + self.permute_per_tree = permute_per_tree + self.sample_dataset_per_tree = sample_dataset_per_tree + + def _get_estimator(self): + if self.estimator is None: + estimator_ = RandomForestClassifier( + n_estimators=self.n_estimators, + criterion=self.criterion, + max_depth=self.max_depth, + min_samples_split=self.min_samples_split, + min_samples_leaf=self.min_samples_leaf, + min_weight_fraction_leaf=self.min_weight_fraction_leaf, + max_features=self.max_features, + max_leaf_nodes=self.max_leaf_nodes, + min_impurity_decrease=self.min_impurity_decrease, + bootstrap=self.bootstrap, + oob_score=self.oob_score, + n_jobs=self.n_jobs, + random_state=self.random_state, + verbose=self.verbose, + warm_start=self.warm_start, + ccp_alpha=self.ccp_alpha, + max_samples=self.max_samples, + **self.estimator_kwargs, + ) + elif isinstance(self.estimator, ForestClassifier): + raise RuntimeError(f"Estimator must be a ForestClassifier, got {type(self.estimator)}") + else: + estimator_ = self.estimator + return estimator_ + + def _statistic( + self, + estimator: BaseForest, + X: ArrayLike, + y: ArrayLike, + covariate_index: ArrayLike = None, + metric="mse", + return_posteriors: bool = False, + **metric_kwargs, + ): + """Helper function to compute the test statistic.""" + metric_func = METRIC_FUNCTIONS[metric] + rng = np.random.default_rng(self.random_state) + n_samples = X.shape[0] + + if self.permute_per_tree and not self.sample_dataset_per_tree: + # first run a dummy fit on the samples to initialize the + # internal data structure of the forest + if not _is_fitted(estimator): + unique_y = np.unique(y) + X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) + estimator.fit(X_dummy, unique_y) + + # Fit each tree and compute posteriors with train test splits + n_samples_test = len(self.indices_test_) + + # now initialize posterior array as (n_trees, n_samples_test, n_outputs) + posterior_arr = np.zeros((self.n_estimators, n_samples_test, estimator.n_outputs_)) + for idx in range(self.n_estimators): + tree: DecisionTreeClassifier = estimator.estimators_[idx] + train_tree( + tree, X[self.indices_train_, :], y[self.indices_train_, :], covariate_index + ) + + y_pred = tree.predict(X[self.indices_test_, :]).reshape(-1, tree.n_outputs_) + + # Fill test set posteriors & set rest NaN + posterior_arr[idx, ...] = y_pred # posterior + + y_true_final = y[self.indices_test_, :] + # Average all posteriors + posterior_final = np.nanmean(posterior_arr, axis=0) + samples = np.argwhere(~np.isnan(posterior_final).any(axis=1)).squeeze() + elif self.permute_per_tree and self.sample_dataset_per_tree: + # first run a dummy fit on the samples to initialize the + # internal data structure of the forest + if not _is_fitted(estimator): + unique_y = np.unique(y) + X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) + estimator.fit(X_dummy, unique_y) + + # now initialize posterior array as (n_trees, n_samples, n_outputs) + posterior_arr = np.full((self.n_estimators, n_samples, estimator.n_outputs_), np.nan) + # Fit each tree and compute posteriors with train test splits + for idx in range(self.n_estimators): + # sample train/test dataset for each tree + indices_train, indices_test = train_test_split( + np.arange(n_samples, dtype=int), + test_size=self.test_size_, + shuffle=True, + random_state=rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32), + ) + tree: DecisionTreeClassifier = estimator.estimators_[idx] + train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) + + y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) + + posterior_arr[idx, indices_test, :] = y_pred # posterior + + # Average all posteriors + posterior_final = np.nanmean(posterior_arr, axis=0) + + # Find the row indices with NaN values in any column + nonnan_indices = np.where(~np.isnan(posterior_final).any(axis=1))[0] + + # Ignore all NaN values (samples not tested) + y_true_final = y[nonnan_indices, :] + posterior_final = posterior_final[nonnan_indices, :] + samples = nonnan_indices + else: + X_train, X_test = X[self.indices_train_, :], X[self.indices_test_, :] + y_train, y_test = y[self.indices_train_, :], y[self.indices_test_, :] + + if covariate_index is not None: + # perform permutation of covariates + n_samples_train = X_train.shape[0] + index_arr = rng.choice( + np.arange(n_samples_train, dtype=int), + size=(n_samples_train, 1), + replace=False, + shuffle=True, + ) + X_train[:, covariate_index] = X_train[index_arr, covariate_index] + + estimator.fit(X_train, y_train) + y_pred = estimator.predict(X_test) + + # set variables to compute metric + samples = self.indices_test_ + y_true_final = y_test + posterior_final = y_pred + + stat = metric_func(y_true_final, posterior_final, **metric_kwargs) + if covariate_index is None: + # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) + # arrays of y and predicted posterior + self.samples_ = samples + self.y_true_final_ = y_true_final + self.posterior_final_ = posterior_final + self.stat_ = stat + + if return_posteriors: + return stat, posterior_final, samples + + return stat + + def statistic( + self, + X: ArrayLike, + y: ArrayLike, + covariate_index: ArrayLike = None, + metric="mse", + return_posteriors: bool = False, + check_input: bool = True, + **metric_kwargs, + ): + """Compute the test statistic. + + Parameters + ---------- + X : ArrayLike of shape (n_samples, n_features) + The data matrix. + y : ArrayLike of shape (n_samples, n_outputs) + The target matrix. + covariate_index : ArrayLike, optional of shape (n_covariates,) + The index array of covariates to shuffle, by default None. + metric : str, optional + The metric to compute, by default "auc". + test_size : float, optional + Proportion of samples per tree to use for the test set, by default 0.2. + return_posteriors : bool, optional + Whether or not to return the posteriors, by default False. + + Returns + ------- + stat : float + The test statistic. + posterior_final : ArrayLike of shape (n_samples_final, n_outputs), optional + If ``return_posteriors`` is True, then the posterior probabilities of the + samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` + if all samples are encountered in the test set of at least one tree in the + posterior computation. + samples : ArrayLike of shape (n_samples_final,), optional + The indices of the samples used in the final test. ``n_samples_final`` is + equal to ``n_samples`` if all samples are encountered in the test set of at + least one tree in the posterior computation. + """ + if check_input: + X, y = check_X_y(X, y, ensure_2d=True, multi_output=True) + if y.ndim != 2: + y = y.reshape(-1, 1) + + if metric not in REGRESSOR_METRICS: + raise RuntimeError(f'Metric must be either "mse" or "mae", got {metric}') + + if covariate_index is None: + self.estimator_ = self._get_estimator() + estimator = self.estimator_ + else: + self.permuted_estimator_ = clone(self.estimator_) + estimator = self.permuted_estimator_ + + return self._statistic( + estimator, + X, + y, + covariate_index=covariate_index, + metric=metric, + return_posteriors=return_posteriors, + **metric_kwargs, + ) + + def test( + self, + X, + y, + covariate_index: ArrayLike, + metric: str = "mse", + test_size: float = 0.2, + n_repeats: int = 1000, + return_posteriors: bool = False, + **metric_kwargs, + ): + """Perform hypothesis test using Coleman method. + + X is split into a training/testing split. Optionally, the covariate index + columns are shuffled. + + On the training dataset, two honest forests are trained and then the posterior + is estimated on the testing dataset. One honest forest is trained on the + permuted dataset and the other is trained on the original dataset. + + Finally, resample the posteriors of the two forests to compute the null + distribution of the statistics. + + Parameters + ---------- + X : ArrayLike of shape (n_samples, n_features) + The data matrix. + y : ArrayLike of shape (n_samples, n_outputs) + The target matrix. + covariate_index : ArrayLike, optional of shape (n_covariates,) + The index array of covariates to shuffle, by default None. + metric : str, optional + The metric to compute, by default "mse". + test_size : float, optional + Proportion of samples per tree to use for the test set, by default 0.2. + n_repeats : int, optional + Number of times to sample the null distribution, by default 1000. + return_posteriors : bool, optional + Whether or not to return the posteriors, by default False. + + Returns + ------- + stat : float + The test statistic. + pval : float + The p-value of the test statistic. + """ + X, y = check_X_y(X, y, ensure_2d=True, copy=True, multi_output=True) + if y.ndim != 2: + y = y.reshape(-1, 1) + + indices = np.arange(X.shape[0]) + self.test_size_ = int(test_size * X.shape[0]) + # if not self.permute_per_tree: + # # train/test split + # # XXX: could add stratifying by y when y is classification + # indices_train, indices_test = train_test_split( + # indices, test_size=test_size, shuffle=True + # ) + # self.indices_train_ = indices_train + # self.indices_test_ = indices_test + indices_train, indices_test = train_test_split(indices, test_size=test_size, shuffle=True) + self.indices_train_ = indices_train + self.indices_test_ = indices_test + + if not hasattr(self, "samples_"): + # first compute the test statistic on the un-permuted data + observe_stat, observe_posteriors, observe_samples = self.statistic( + X, + y, + covariate_index=None, + metric=metric, + return_posteriors=True, + check_input=False, + **metric_kwargs, + ) + else: + observe_samples = self.samples_ + observe_posteriors = self.posterior_final_ + observe_stat = self.stat_ + + # next permute the data + permute_stat, permute_posteriors, permute_samples = self.statistic( + X, + y, + covariate_index=covariate_index, + metric=metric, + return_posteriors=True, + check_input=False, + **metric_kwargs, + ) + + # Note: at this point, both `estimator` and `permuted_estimator_` should + # have been fitted already, so we can now compute on the null by resampling + # the posteriors and computing the test statistic on the resampled posteriors + if self.sample_dataset_per_tree: + metric_star, metric_star_pi = _compute_null_distribution_coleman( + y_test=y[observe_samples, :], + y_pred_proba_normal=observe_posteriors, + y_pred_proba_perm=permute_posteriors, + metric=metric, + n_repeats=n_repeats, + seed=self.random_state, + ) + else: + metric_star, metric_star_pi = _compute_null_distribution_coleman( + y_test=y[self.indices_test_, :], + y_pred_proba_normal=observe_posteriors, + y_pred_proba_perm=permute_posteriors, + metric=metric, + n_repeats=n_repeats, + seed=self.random_state, + ) + # metric^\pi - metric = observed test statistic, which under the null is normally distributed around 0 + observe_stat = permute_stat - observe_stat + + # metric^\pi_j - metric_j, which is centered at 0 + null_dist = metric_star_pi - metric_star + + # compute pvalue + pvalue = (1 + (null_dist >= observe_stat).sum()) / (1 + n_repeats) + + if return_posteriors: + self.observe_posteriors_ = observe_posteriors + self.permute_posteriors_ = permute_posteriors + self.observe_samples_ = observe_samples + self.permute_samples_ = permute_samples + + self.null_dist_ = null_dist + return observe_stat, pvalue From f26825da45b60bc49758fc9a401eafb0e86b0d51 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Mon, 18 Sep 2023 15:09:31 -0400 Subject: [PATCH 18/70] Patch up python code Signed-off-by: Adam Li --- benchmarks_nonasv/bench_forestht.py | 53 +- .../test_permutation_forest.ipynb | 2 +- sktree/__init__.py | 2 - sktree/conftest.py | 1 + sktree/meson.build | 2 +- sktree/stats/__init__.py | 2 +- sktree/stats/_might.py | 2 +- sktree/stats/forestht.py | 951 +++--------------- sktree/stats/permutationforest.py | 12 +- sktree/stats/tests/test_forestht.py | 151 ++- sktree/stats/utils.py | 6 +- 11 files changed, 236 insertions(+), 948 deletions(-) diff --git a/benchmarks_nonasv/bench_forestht.py b/benchmarks_nonasv/bench_forestht.py index c18bb9e8b..32bff3e94 100644 --- a/benchmarks_nonasv/bench_forestht.py +++ b/benchmarks_nonasv/bench_forestht.py @@ -87,10 +87,6 @@ def linear_model_ancova(sigma_factor=2.0, seed=None): return pvalue_dict -def linear_model_mars(): - pass - - def correlated_logit_model(beta=5.0, seed=None): n_samples = 600 n_estimators = 125 @@ -149,14 +145,43 @@ def random_forest_model(): pass -if __name__ == "__main__": +def evaluate_correlated_logit_model(): + pvalue_dict = defaultdict(list) + rng = np.random.default_rng(seed) + + beta_space = np.hstack((np.linspace(0.01, 2.5, 8), np.linspace(5, 20, 7))) + for beta in beta_space: + for idx in range(5): + new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32) + + elements_dict = correlated_logit_model(beta, new_seed) + for key, value in elements_dict.items(): + pvalue_dict[key].append(value) + pvalue_dict["sigma_factor"].append(beta) + + df = pd.DataFrame(pvalue_dict) + + fig, axs = plt.subplots(3, 1, figsize=(8, 6), sharey=True, sharex=True) + axs = axs.flatten() + + for ax, name in zip(axs, ["X1", "X2", "X500"]): + sns.lineplot(data=df, x="sigma_factor", y=name, ax=ax, marker="o") + + ax.axhline([0.05], ls="--", color="red", label="alpha") + ax.set(title=name, ylabel="pvalue", xlabel="SNR (beta)") + ax.legend() + fig.suptitle("Correlated Logit model") + fig.tight_layout() + + +def evaluate_linear_ancova_model(): pvalue_dict = defaultdict(list) rng = np.random.default_rng(seed) j_space = np.linspace(0.005, 2.25, 9) for sigma_factor in j_space: - for idx in range(10): + for idx in range(5): new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32) elements_dict = linear_model_ancova(sigma_factor, new_seed) @@ -165,3 +190,19 @@ def random_forest_model(): pvalue_dict["sigma_factor"].append(sigma_factor) df = pd.DataFrame(pvalue_dict) + + fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True) + axs = axs.flatten() + + for ax, name in zip(axs, ["X1", "X2", "X6", "X7"]): + sns.lineplot(data=df, x="sigma_factor", y=name, ax=ax, marker="o") + + ax.axhline([0.05], ls="--", color="red", label="alpha") + ax.set(title=name, ylabel="pvalue", xlabel="SNR (10 / x)") + ax.legend() + fig.suptitle("Linear ANCOVA model") + fig.tight_layout() + + +if __name__ == "__main__": + evaluate_linear_ancova_model() diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/test_permutation_forest.ipynb index 12a0e6c0e..bd7e6c43b 100644 --- a/benchmarks_nonasv/test_permutation_forest.ipynb +++ b/benchmarks_nonasv/test_permutation_forest.ipynb @@ -202,7 +202,7 @@ "\n", " # test for X_2 important\n", " stat, pvalue = est.test(\n", - " X.copy(), y.copy(), [1], test_size=test_size, n_repeats=n_repeats, metric=metric\n", + " X.copy(), y.copy(), covariate_index=[1], test_size=test_size, n_repeats=n_repeats, metric=metric\n", " )\n", " pvalue_dict[\"X2\"] = pvalue\n", " print(\"X2: \", pvalue)\n", diff --git a/sktree/__init__.py b/sktree/__init__.py index 8a9e32eb5..c6af80ea0 100644 --- a/sktree/__init__.py +++ b/sktree/__init__.py @@ -58,7 +58,6 @@ PatchObliqueRandomForestRegressor, ) from .ensemble._honest_forest import HonestForestClassifier - from .stats import ForestHT except ImportError as e: msg = """Error importing scikit-tree: you cannot import scikit-tree while being in scikit-tree source directory; please exit the scikit-tree source @@ -86,5 +85,4 @@ "ExtraTreesClassifier", "ExtraTreesRegressor", "ExtendedIsolationForest", - "ForestHT", ] diff --git a/sktree/conftest.py b/sktree/conftest.py index 037cecae6..c226c3c60 100644 --- a/sktree/conftest.py +++ b/sktree/conftest.py @@ -1,2 +1,3 @@ def pytest_configure(config): + """Set up pytest markers.""" config.addinivalue_line("markers", "slowtest: mark test as slow") diff --git a/sktree/meson.build b/sktree/meson.build index b593f75aa..8608052b8 100644 --- a/sktree/meson.build +++ b/sktree/meson.build @@ -54,7 +54,7 @@ cython_c_args += numpy_nodepr_api python_sources = [ '__init__.py', 'neighbors.py', - # 'conftest.py', + 'conftest.py', ] py3.install_sources( diff --git a/sktree/stats/__init__.py b/sktree/stats/__init__.py index 95702f9e5..6191b93dd 100644 --- a/sktree/stats/__init__.py +++ b/sktree/stats/__init__.py @@ -1,3 +1,3 @@ from ._might import MIGHT, MIGHT_MV -from .forestht import FeatureImportanceForestClassifier, FeatureImportanceForestRegressor, ForestHT +from .forestht import FeatureImportanceForestClassifier, FeatureImportanceForestRegressor from .permutationforest import PermutationForestClassifier, PermutationForestRegressor diff --git a/sktree/stats/_might.py b/sktree/stats/_might.py index 102dc1448..9e57ed921 100644 --- a/sktree/stats/_might.py +++ b/sktree/stats/_might.py @@ -306,7 +306,7 @@ def test_diff(self, x, z, y, reps=1000, workers=1): X_permutedZ = np.hstack((x, permuted_Z)) perm_stat, perm_pos = self.statistic(X_permutedZ, y, return_pos=True) - # Bootsrap sample the posterior from the two forests + # Bootstrap sample the posterior from the two forests null_stats = np.array( Parallel(n_jobs=workers)( [delayed(pos_diff)(observe_pos, perm_pos, y, limit=self.limit) for _ in range(reps)] diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index a761c8660..cbd31fe56 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -13,7 +13,6 @@ ) from sktree._lib.sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor -from ..ensemble import HonestForestClassifier from .utils import ( METRIC_FUNCTIONS, REGRESSOR_METRICS, @@ -22,201 +21,12 @@ ) -class ForestHT(MetaEstimatorMixin): - """Forest hypothesis testing. - - For example, this allows Mutual information for gigantic hypothesis testing (MIGHT) - via ``metric="mi"``. - - Parameters - ---------- - n_estimators : int, default=100 - The number of trees in the forest. - - criterion : {"gini", "entropy"}, default="gini" - The function to measure the quality of a split. Supported criteria are - "gini" for the Gini impurity and "entropy" for the information gain. - Note: this parameter is tree-specific. - - splitter : {"best", "random"}, default="best" - The strategy used to choose the split at each node. Supported - strategies are "best" to choose the best split and "random" to choose - the best random split. - - max_depth : int, default=None - The maximum depth of the tree. If None, then nodes are expanded until - all leaves are pure or until all leaves contain less than - min_samples_split samples. - - min_samples_split : int or float, default=2 - The minimum number of samples required to split an internal node: - - - If int, then consider `min_samples_split` as the minimum number. - - If float, then `min_samples_split` is a fraction and - `ceil(min_samples_split * n_samples)` are the minimum - number of samples for each split. - - min_samples_leaf : int or float, default=1 - The minimum number of samples required to be at a leaf node. - A split point at any depth will only be considered if it leaves at - least ``min_samples_leaf`` training samples in each of the left and - right branches. This may have the effect of smoothing the model, - especially in regression. - - - If int, then consider `min_samples_leaf` as the minimum number. - - If float, then `min_samples_leaf` is a fraction and - `ceil(min_samples_leaf * n_samples)` are the minimum - number of samples for each node. - - min_weight_fraction_leaf : float, default=0.0 - The minimum weighted fraction of the sum total of weights (of all - the input samples) required to be at a leaf node. Samples have - equal weight when sample_weight is not provided. - - max_features : {"sqrt", "log2", None}, int or float, default="sqrt" - The number of features to consider when looking for the best split: - - - If int, then consider `max_features` features at each split. - - If float, then `max_features` is a fraction and - `round(max_features * n_features)` features are considered at each - split. - - If "auto", then `max_features=sqrt(n_features)`. - - If "sqrt", then `max_features=sqrt(n_features)`. - - If "log2", then `max_features=log2(n_features)`. - - If None, then `max_features=n_features`. - - Note: the search for a split does not stop until at least one - valid partition of the node samples is found, even if it requires to - effectively inspect more than ``max_features`` features. - - max_leaf_nodes : int, default=None - Grow trees with ``max_leaf_nodes`` in best-first fashion. - Best nodes are defined as relative reduction in impurity. - If None then unlimited number of leaf nodes. - - min_impurity_decrease : float, default=0.0 - A node will be split if this split induces a decrease of the impurity - greater than or equal to this value. - - The weighted impurity decrease equation is the following:: - - N_t / N * (impurity - N_t_R / N_t * right_impurity - - N_t_L / N_t * left_impurity) - - where ``N`` is the total number of samples, ``N_t`` is the number of - samples at the current node, ``N_t_L`` is the number of samples in the - left child, and ``N_t_R`` is the number of samples in the right child. - - ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, - if ``sample_weight`` is passed. - - bootstrap : bool, default=True - Whether bootstrap samples are used when building trees. If False, the - whole dataset is used to build each tree. - - oob_score : bool, default=False - Whether to use out-of-bag samples to estimate the generalization score. - Only available if bootstrap=True. - - n_jobs : int, default=None - The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`, - :meth:`decision_path` and :meth:`apply` are all parallelized over the - trees. ``None`` means 1 unless in a `joblib.parallel_backend` - context. ``-1`` means using all processors. See :term:`Glossary - ` for more details. - - random_state : int, RandomState instance or None, default=None - Controls both the randomness of the bootstrapping of the samples used - when building trees (if ``bootstrap=True``) and the sampling of the - features to consider when looking for the best split at each node - (if ``max_features < n_features``). - See :term:`Glossary ` for details. - - verbose : int, default=0 - Controls the verbosity when fitting and predicting. - - warm_start : bool, default=False - When set to ``True``, reuse the solution of the previous call to fit - and add more estimators to the ensemble, otherwise, just fit a whole - new forest. See :term:`the Glossary `. - - class_weight : {"balanced", "balanced_subsample"}, dict or list of dicts, \ - default=None - Weights associated with classes in the form ``{class_label: weight}``. - If not given, all classes are supposed to have weight one. For - multi-output problems, a list of dicts can be provided in the same - order as the columns of y. - - Note that for multioutput (including multilabel) weights should be - defined for each class of every column in its own dict. For example, - for four-class multilabel classification weights should be - [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of - [{1:1}, {2:5}, {3:1}, {4:1}]. - - The "balanced" mode uses the values of y to automatically adjust - weights inversely proportional to class frequencies in the input data - as ``n_samples / (n_classes * np.bincount(y))`` - - The "balanced_subsample" mode is the same as "balanced" except that - weights are computed based on the bootstrap sample for every tree - grown. - - For multi-output, the weights of each column of y will be multiplied. - - Note that these weights will be multiplied with sample_weight (passed - through the fit method) if sample_weight is specified. - - ccp_alpha : non-negative float, default=0.0 - Complexity parameter used for Minimal Cost-Complexity Pruning. The - subtree with the largest cost complexity that is smaller than - ``ccp_alpha`` will be chosen. By default, no pruning is performed. See - :ref:`minimal_cost_complexity_pruning` for details. - - max_samples : int or float, default=None - If bootstrap is True, the number of samples to draw from X - to train each base tree estimator. - - - If None (default), then draw `X.shape[0]` samples. - - If int, then draw `max_samples` samples. - - If float, then draw `max_samples * X.shape[0]` samples. Thus, - `max_samples` should be in the interval `(0.0, 1.0]`. - - honest_prior : {"ignore", "uniform", "empirical"}, default="empirical" - Method for dealing with empty leaves during evaluation of a test - sample. If "ignore", the tree is ignored. If "uniform", the prior tree - posterior is 1/(number of classes). If "empirical", the prior tree - posterior is the relative class frequency in the voting subsample. - If all trees are ignored, the empirical estimate is returned. - - honest_fraction : float, default=0.5 - Fraction of training samples used for estimates in the trees. The - remaining samples will be used to learn the tree structure. A larger - fraction creates shallower trees with lower variance estimates. - - tree_estimator : object, default=None - Type of decision tree classifier to use. By default `None`, which - defaults to :class:`sklearn.tree.DecisionTreeClassifier`. - - Attributes - ---------- - samples_ : ArrayLike of shape (n_samples,) - The indices of the samples used in the final test. - - y_true_final_ : ArrayLike of shape (n_samples_final,) - The true labels of the samples used in the final test. - - posterior_final_ : ArrayLike of shape (n_samples_final,) - The predicted posterior probabilities of the samples used in the final test. - - null_dist_ : ArrayLike of shape (n_repeats,) - The null distribution of the test statistic. - """ - +class BaseForestHT(MetaEstimatorMixin): def __init__( self, + estimator=None, n_estimators=100, - criterion="gini", - splitter="best", + criterion="squared_error", max_depth=None, min_samples_split=2, min_samples_leaf=1, @@ -230,41 +40,15 @@ def __init__( random_state=None, verbose=0, warm_start=False, - class_weight=None, ccp_alpha=0.0, max_samples=None, - honest_prior="empirical", - honest_fraction=0.5, - tree_estimator=None, + permute_per_tree=True, + **estimator_kwargs, ): - self.estimator = HonestForestClassifier( - n_estimators=n_estimators, - criterion=criterion, - splitter=splitter, - max_depth=max_depth, - min_samples_split=min_samples_split, - min_samples_leaf=min_samples_leaf, - min_weight_fraction_leaf=min_weight_fraction_leaf, - max_features=max_features, - max_leaf_nodes=max_leaf_nodes, - min_impurity_decrease=min_impurity_decrease, - bootstrap=bootstrap, - oob_score=oob_score, - n_jobs=n_jobs, - random_state=random_state, - verbose=verbose, - warm_start=warm_start, - class_weight=class_weight, - ccp_alpha=ccp_alpha, - max_samples=max_samples, - honest_prior=honest_prior, - honest_fraction=honest_fraction, - tree_estimator=tree_estimator, - ) + self.estimator = estimator self.n_jobs = n_jobs self.n_estimators = n_estimators self.criterion = criterion - self.splitter = splitter self.max_depth = max_depth self.min_samples_split = min_samples_split self.min_samples_leaf = min_samples_leaf @@ -277,91 +61,10 @@ def __init__( self.random_state = random_state self.verbose = verbose self.warm_start = warm_start - self.class_weight = class_weight self.ccp_alpha = ccp_alpha self.max_samples = max_samples - self.honest_prior = honest_prior - self.honest_fraction = honest_fraction - self.tree_estimator = tree_estimator - - def _statistic( - self, - estimator: ForestClassifier, - X: ArrayLike, - y: ArrayLike, - covariate_index: ArrayLike = None, - metric="auc", - test_size=0.2, - return_posteriors: bool = False, - **metric_kwargs, - ): - """Helper function to compute the test statistic.""" - metric_func = METRIC_FUNCTIONS[metric] - rng = np.random.default_rng(self.random_state) - - # first run a dummy fit on just two samples to initialize the - # internal data structure of the forest - if not _is_fitted(estimator): - unique_y = np.unique(y) - X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) - estimator.fit(X_dummy, unique_y) - - # Fit each tree and ompute posteriors with train test splits - n_samples = X.shape[0] - indices = np.arange(n_samples, dtype=int) - posterior_arr = np.zeros((self.n_estimators, n_samples, self.estimator.n_classes_)) - for idx in range(self.n_estimators): - seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32) - indices_train, indices_test = train_test_split( - indices, test_size=test_size, stratify=y, shuffle=True, random_state=seed - ) - tree = estimator.estimators_[idx] - tree_posterior( - tree, - X[indices_train, :], - y[indices_train, :], - covariate_index, - test_size, - seed=seed, - ) - - y_pred = tree.predict_proba(X[indices_test, :]) - - # Fill test set posteriors & set rest NaN - posterior = np.full((y.shape[0], tree.n_classes_), np.nan) - posterior[indices_test, :] = y_pred - posterior_arr[idx, ...] = posterior - - # Average all posteriors - posterior_final = np.nanmean(posterior_arr, axis=0) - samples = np.argwhere(~np.isnan(posterior_final).any(axis=1)).squeeze() - y_true_final = y[samples, :] - posterior_final = posterior_final[samples, :] - if metric == "auc": - if posterior_final.shape[1] != 2: - raise ValueError( - "AUC only supports binary classification. " "Please use a different metric." - ) - print(posterior_final[:5, :]) - # get posteriors of the positive class - posterior_final = posterior_final[:, 1] - - print("Y true: ", y_true_final) - print("posterior: ", posterior_final) - stat = metric_func(y_true_final, posterior_final, **metric_kwargs) - - if covariate_index is None: - # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) - # arrays of y and predicted posterior - self.samples_ = samples - self.y_true_final_ = y_true_final - self.posterior_final_ = posterior_final - self.stat_ = stat - - if return_posteriors: - return stat, posterior_final, samples - - return stat + self.estimator_kwargs = estimator_kwargs + self.permute_per_tree = permute_per_tree def reset(self): class_attributes = dir(type(self)) @@ -376,9 +79,9 @@ def statistic( X: ArrayLike, y: ArrayLike, covariate_index: ArrayLike = None, - metric="auc", - test_size=0.2, + metric="mse", return_posteriors: bool = False, + check_input: bool = True, **metric_kwargs, ): """Compute the test statistic. @@ -412,14 +115,19 @@ def statistic( equal to ``n_samples`` if all samples are encountered in the test set of at least one tree in the posterior computation. """ - X, y = check_X_y(X, y, ensure_2d=True, multi_output=True) - if y.ndim != 2: - y = y.reshape(-1, 1) + if check_input: + X, y = check_X_y(X, y, ensure_2d=True, multi_output=True) + if y.ndim != 2: + y = y.reshape(-1, 1) + + if metric not in REGRESSOR_METRICS: + raise RuntimeError(f'Metric must be either "mse" or "mae", got {metric}') if covariate_index is None: - estimator = self.estimator + self.estimator_ = self._get_estimator() + estimator = self.estimator_ else: - self.permuted_estimator_ = clone(self.estimator) + self.permuted_estimator_ = clone(self.estimator_) estimator = self.permuted_estimator_ return self._statistic( @@ -428,7 +136,6 @@ def statistic( y, covariate_index=covariate_index, metric=metric, - test_size=test_size, return_posteriors=return_posteriors, **metric_kwargs, ) @@ -438,7 +145,7 @@ def test( X, y, covariate_index: ArrayLike, - metric: str = "auc", + metric: str = "mse", test_size: float = 0.2, n_repeats: int = 1000, return_posteriors: bool = False, @@ -465,7 +172,7 @@ def test( covariate_index : ArrayLike, optional of shape (n_covariates,) The index array of covariates to shuffle, by default None. metric : str, optional - The metric to compute, by default "auc". + The metric to compute, by default "mse". test_size : float, optional Proportion of samples per tree to use for the test set, by default 0.2. n_repeats : int, optional @@ -484,6 +191,20 @@ def test( if y.ndim != 2: y = y.reshape(-1, 1) + indices = np.arange(X.shape[0]) + self.test_size_ = int(test_size * X.shape[0]) + # if not self.permute_per_tree: + # # train/test split + # # XXX: could add stratifying by y when y is classification + # indices_train, indices_test = train_test_split( + # indices, test_size=test_size, shuffle=True + # ) + # self.indices_train_ = indices_train + # self.indices_test_ = indices_test + indices_train, indices_test = train_test_split(indices, test_size=test_size, shuffle=True) + self.indices_train_ = indices_train + self.indices_test_ = indices_test + if not hasattr(self, "samples_"): # first compute the test statistic on the un-permuted data observe_stat, observe_posteriors, observe_samples = self.statistic( @@ -491,8 +212,8 @@ def test( y, covariate_index=None, metric=metric, - test_size=test_size, return_posteriors=True, + check_input=False, **metric_kwargs, ) else: @@ -506,97 +227,50 @@ def test( y, covariate_index=covariate_index, metric=metric, - test_size=test_size, return_posteriors=True, + check_input=False, **metric_kwargs, ) # Note: at this point, both `estimator` and `permuted_estimator_` should # have been fitted already, so we can now compute on the null by resampling # the posteriors and computing the test statistic on the resampled posteriors - metric_star, metric_star_pi = _compute_null_distribution_coleman( - X_test=X, - y_test=y, - y_pred_proba_normal=observe_posteriors, - y_pred_proba_perm=permute_posteriors, - normal_samples=observe_samples, - perm_samples=permute_samples, - metric=metric, - n_repeats=n_repeats, - seed=self.random_state, - ) - print(observe_posteriors) - print(permute_posteriors) - # metric^\pi - metric - observe_stat = permute_stat - observe_stat - - # metric^\pi_j - metric_j - null_dist = metric_star_pi - metric_star - - pval = _pvalue(observe_stat=observe_stat, permuted_stat=null_dist, correction=True) - - if return_posteriors: - self.observe_posteriors_ = observe_posteriors - self.permute_posteriors_ = permute_posteriors - self.observe_samples_ = observe_samples - self.permute_samples_ = permute_samples - - self.null_dist_ = null_dist - return observe_stat, pval - - -class BaseForestHT(MetaEstimatorMixin): - def __init__( - self, - estimator=None, - n_estimators=100, - criterion="squared_error", - max_depth=None, - min_samples_split=2, - min_samples_leaf=1, - min_weight_fraction_leaf=0.0, - max_features="sqrt", - max_leaf_nodes=None, - min_impurity_decrease=0.0, - bootstrap=False, - oob_score=False, - n_jobs=None, - random_state=None, - verbose=0, - warm_start=False, - ccp_alpha=0.0, - max_samples=None, - permute_per_tree=True, - **estimator_kwargs, - ): - self.estimator = estimator - self.n_jobs = n_jobs - self.n_estimators = n_estimators - self.criterion = criterion - self.max_depth = max_depth - self.min_samples_split = min_samples_split - self.min_samples_leaf = min_samples_leaf - self.min_weight_fraction_leaf = min_weight_fraction_leaf - self.max_features = max_features - self.max_leaf_nodes = max_leaf_nodes - self.min_impurity_decrease = min_impurity_decrease - self.bootstrap = bootstrap - self.oob_score = oob_score - self.random_state = random_state - self.verbose = verbose - self.warm_start = warm_start - self.ccp_alpha = ccp_alpha - self.max_samples = max_samples - self.estimator_kwargs = estimator_kwargs - self.permute_per_tree = permute_per_tree + if self.sample_dataset_per_tree: + metric_star, metric_star_pi = _compute_null_distribution_coleman( + y_test=y[observe_samples, :], + y_pred_proba_normal=observe_posteriors, + y_pred_proba_perm=permute_posteriors, + metric=metric, + n_repeats=n_repeats, + seed=self.random_state, + ) + else: + metric_star, metric_star_pi = _compute_null_distribution_coleman( + y_test=y[self.indices_test_, :], + y_pred_proba_normal=observe_posteriors, + y_pred_proba_perm=permute_posteriors, + metric=metric, + n_repeats=n_repeats, + seed=self.random_state, + ) + # metric^\pi - metric = observed test statistic, which under the + # null is normally distributed around 0 + observe_stat = permute_stat - observe_stat - def reset(self): - class_attributes = dir(type(self)) - instance_attributes = dir(self) + # metric^\pi_j - metric_j, which is centered at 0 + null_dist = metric_star_pi - metric_star - for attr_name in instance_attributes: - if attr_name.endswith("_") and attr_name not in class_attributes: - delattr(self, attr_name) + # compute pvalue + pvalue = (1 + (null_dist >= observe_stat).sum()) / (1 + n_repeats) + + if return_posteriors: + self.observe_posteriors_ = observe_posteriors + self.permute_posteriors_ = permute_posteriors + self.observe_samples_ = observe_samples + self.permute_samples_ = permute_samples + + self.null_dist_ = null_dist + return observe_stat, pvalue class FeatureImportanceForestRegressor(BaseForestHT): @@ -607,7 +281,7 @@ class FeatureImportanceForestRegressor(BaseForestHT): permuted dataset. The dataset is either permuted once, or independently for each tree in the permuted forest. The original test statistic is computed by comparing the metric on both forests ``(metric_forest - metric_perm_forest)``. - + Then the output predictions are randomly sampled to recompute the test statistic ``n_repeats`` times. The p-value is computed as the proportion of times the null test statistic is greater than the original test statistic. @@ -922,256 +596,58 @@ def _statistic( shuffle=True, random_state=rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32), ) - tree: DecisionTreeRegressor = estimator.estimators_[idx] + tree = estimator.estimators_[idx] train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) - posterior_arr[idx, indices_test, :] = y_pred # posterior # Average all posteriors - posterior_final = np.nanmean(posterior_arr, axis=0) - - # Find the row indices with NaN values in any column - nonnan_indices = np.where(~np.isnan(posterior_final).any(axis=1))[0] - - # Ignore all NaN values (samples not tested) - y_true_final = y[nonnan_indices, :] - posterior_final = posterior_final[nonnan_indices, :] - samples = nonnan_indices - else: - X_train, X_test = X[self.indices_train_, :], X[self.indices_test_, :] - y_train, y_test = y[self.indices_train_, :], y[self.indices_test_, :] - - if covariate_index is not None: - # perform permutation of covariates - n_samples_train = X_train.shape[0] - index_arr = rng.choice( - np.arange(n_samples_train, dtype=int), - size=(n_samples_train, 1), - replace=False, - shuffle=True, - ) - X_train[:, covariate_index] = X_train[index_arr, covariate_index] - - estimator.fit(X_train, y_train) - y_pred = estimator.predict(X_test) - - # set variables to compute metric - samples = self.indices_test_ - y_true_final = y_test - posterior_final = y_pred - - stat = metric_func(y_true_final, posterior_final, **metric_kwargs) - if covariate_index is None: - # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) - # arrays of y and predicted posterior - self.samples_ = samples - self.y_true_final_ = y_true_final - self.posterior_final_ = posterior_final - self.stat_ = stat - - if return_posteriors: - return stat, posterior_final, samples - - return stat - - def statistic( - self, - X: ArrayLike, - y: ArrayLike, - covariate_index: ArrayLike = None, - metric="mse", - return_posteriors: bool = False, - check_input: bool = True, - **metric_kwargs, - ): - """Compute the test statistic. - - Parameters - ---------- - X : ArrayLike of shape (n_samples, n_features) - The data matrix. - y : ArrayLike of shape (n_samples, n_outputs) - The target matrix. - covariate_index : ArrayLike, optional of shape (n_covariates,) - The index array of covariates to shuffle, by default None. - metric : str, optional - The metric to compute, by default "auc". - test_size : float, optional - Proportion of samples per tree to use for the test set, by default 0.2. - return_posteriors : bool, optional - Whether or not to return the posteriors, by default False. - - Returns - ------- - stat : float - The test statistic. - posterior_final : ArrayLike of shape (n_samples_final, n_outputs), optional - If ``return_posteriors`` is True, then the posterior probabilities of the - samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` - if all samples are encountered in the test set of at least one tree in the - posterior computation. - samples : ArrayLike of shape (n_samples_final,), optional - The indices of the samples used in the final test. ``n_samples_final`` is - equal to ``n_samples`` if all samples are encountered in the test set of at - least one tree in the posterior computation. - """ - if check_input: - X, y = check_X_y(X, y, ensure_2d=True, multi_output=True) - if y.ndim != 2: - y = y.reshape(-1, 1) - - if metric not in REGRESSOR_METRICS: - raise RuntimeError(f'Metric must be either "mse" or "mae", got {metric}') - - if covariate_index is None: - self.estimator_ = self._get_estimator() - estimator = self.estimator_ - else: - self.permuted_estimator_ = clone(self.estimator_) - estimator = self.permuted_estimator_ - - return self._statistic( - estimator, - X, - y, - covariate_index=covariate_index, - metric=metric, - return_posteriors=return_posteriors, - **metric_kwargs, - ) - - def test( - self, - X, - y, - covariate_index: ArrayLike, - metric: str = "mse", - test_size: float = 0.2, - n_repeats: int = 1000, - return_posteriors: bool = False, - **metric_kwargs, - ): - """Perform hypothesis test using Coleman method. - - X is split into a training/testing split. Optionally, the covariate index - columns are shuffled. - - On the training dataset, two honest forests are trained and then the posterior - is estimated on the testing dataset. One honest forest is trained on the - permuted dataset and the other is trained on the original dataset. - - Finally, resample the posteriors of the two forests to compute the null - distribution of the statistics. - - Parameters - ---------- - X : ArrayLike of shape (n_samples, n_features) - The data matrix. - y : ArrayLike of shape (n_samples, n_outputs) - The target matrix. - covariate_index : ArrayLike, optional of shape (n_covariates,) - The index array of covariates to shuffle, by default None. - metric : str, optional - The metric to compute, by default "mse". - test_size : float, optional - Proportion of samples per tree to use for the test set, by default 0.2. - n_repeats : int, optional - Number of times to sample the null distribution, by default 1000. - return_posteriors : bool, optional - Whether or not to return the posteriors, by default False. - - Returns - ------- - stat : float - The test statistic. - pval : float - The p-value of the test statistic. - """ - X, y = check_X_y(X, y, ensure_2d=True, copy=True, multi_output=True) - if y.ndim != 2: - y = y.reshape(-1, 1) - - indices = np.arange(X.shape[0]) - self.test_size_ = int(test_size * X.shape[0]) - # if not self.permute_per_tree: - # # train/test split - # # XXX: could add stratifying by y when y is classification - # indices_train, indices_test = train_test_split( - # indices, test_size=test_size, shuffle=True - # ) - # self.indices_train_ = indices_train - # self.indices_test_ = indices_test - indices_train, indices_test = train_test_split(indices, test_size=test_size, shuffle=True) - self.indices_train_ = indices_train - self.indices_test_ = indices_test - - if not hasattr(self, "samples_"): - # first compute the test statistic on the un-permuted data - observe_stat, observe_posteriors, observe_samples = self.statistic( - X, - y, - covariate_index=None, - metric=metric, - return_posteriors=True, - check_input=False, - **metric_kwargs, - ) - else: - observe_samples = self.samples_ - observe_posteriors = self.posterior_final_ - observe_stat = self.stat_ - - # next permute the data - permute_stat, permute_posteriors, permute_samples = self.statistic( - X, - y, - covariate_index=covariate_index, - metric=metric, - return_posteriors=True, - check_input=False, - **metric_kwargs, - ) - - # Note: at this point, both `estimator` and `permuted_estimator_` should - # have been fitted already, so we can now compute on the null by resampling - # the posteriors and computing the test statistic on the resampled posteriors - if self.sample_dataset_per_tree: - metric_star, metric_star_pi = _compute_null_distribution_coleman( - y_test=y[observe_samples, :], - y_pred_proba_normal=observe_posteriors, - y_pred_proba_perm=permute_posteriors, - metric=metric, - n_repeats=n_repeats, - seed=self.random_state, - ) + posterior_final = np.nanmean(posterior_arr, axis=0) + + # Find the row indices with NaN values in any column + nonnan_indices = np.where(~np.isnan(posterior_final).any(axis=1))[0] + + # Ignore all NaN values (samples not tested) + y_true_final = y[nonnan_indices, :] + posterior_final = posterior_final[nonnan_indices, :] + samples = nonnan_indices else: - metric_star, metric_star_pi = _compute_null_distribution_coleman( - y_test=y[self.indices_test_, :], - y_pred_proba_normal=observe_posteriors, - y_pred_proba_perm=permute_posteriors, - metric=metric, - n_repeats=n_repeats, - seed=self.random_state, - ) - # metric^\pi - metric = observed test statistic, which under the null is normally distributed around 0 - observe_stat = permute_stat - observe_stat + X_train, X_test = X[self.indices_train_, :], X[self.indices_test_, :] + y_train, y_test = y[self.indices_train_, :], y[self.indices_test_, :] - # metric^\pi_j - metric_j, which is centered at 0 - null_dist = metric_star_pi - metric_star + if covariate_index is not None: + # perform permutation of covariates + n_samples_train = X_train.shape[0] + index_arr = rng.choice( + np.arange(n_samples_train, dtype=int), + size=(n_samples_train, 1), + replace=False, + shuffle=True, + ) + X_train[:, covariate_index] = X_train[index_arr, covariate_index] - # compute pvalue - pvalue = (1 + (null_dist >= observe_stat).sum()) / (1 + n_repeats) + estimator.fit(X_train, y_train) + y_pred = estimator.predict(X_test) + + # set variables to compute metric + samples = self.indices_test_ + y_true_final = y_test + posterior_final = y_pred + + stat = metric_func(y_true_final, posterior_final, **metric_kwargs) + if covariate_index is None: + # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) + # arrays of y and predicted posterior + self.samples_ = samples + self.y_true_final_ = y_true_final + self.posterior_final_ = posterior_final + self.stat_ = stat if return_posteriors: - self.observe_posteriors_ = observe_posteriors - self.permute_posteriors_ = permute_posteriors - self.observe_samples_ = observe_samples - self.permute_samples_ = permute_samples + return stat, posterior_final, samples - self.null_dist_ = null_dist - return observe_stat, pvalue + return stat class FeatureImportanceForestClassifier(BaseForestHT): @@ -1182,7 +658,7 @@ class FeatureImportanceForestClassifier(BaseForestHT): permuted dataset. The dataset is either permuted once, or independently for each tree in the permuted forest. The original test statistic is computed by comparing the metric on both forests ``(metric_forest - metric_perm_forest)``. - + Then the output predictions are randomly sampled to recompute the test statistic ``n_repeats`` times. The p-value is computed as the proportion of times the null test statistic is greater than the original test statistic. @@ -1497,7 +973,7 @@ def _statistic( shuffle=True, random_state=rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32), ) - tree: DecisionTreeClassifier = estimator.estimators_[idx] + tree = estimator.estimators_[idx] train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) @@ -1550,200 +1026,3 @@ def _statistic( return stat, posterior_final, samples return stat - - def statistic( - self, - X: ArrayLike, - y: ArrayLike, - covariate_index: ArrayLike = None, - metric="mse", - return_posteriors: bool = False, - check_input: bool = True, - **metric_kwargs, - ): - """Compute the test statistic. - - Parameters - ---------- - X : ArrayLike of shape (n_samples, n_features) - The data matrix. - y : ArrayLike of shape (n_samples, n_outputs) - The target matrix. - covariate_index : ArrayLike, optional of shape (n_covariates,) - The index array of covariates to shuffle, by default None. - metric : str, optional - The metric to compute, by default "auc". - test_size : float, optional - Proportion of samples per tree to use for the test set, by default 0.2. - return_posteriors : bool, optional - Whether or not to return the posteriors, by default False. - - Returns - ------- - stat : float - The test statistic. - posterior_final : ArrayLike of shape (n_samples_final, n_outputs), optional - If ``return_posteriors`` is True, then the posterior probabilities of the - samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` - if all samples are encountered in the test set of at least one tree in the - posterior computation. - samples : ArrayLike of shape (n_samples_final,), optional - The indices of the samples used in the final test. ``n_samples_final`` is - equal to ``n_samples`` if all samples are encountered in the test set of at - least one tree in the posterior computation. - """ - if check_input: - X, y = check_X_y(X, y, ensure_2d=True, multi_output=True) - if y.ndim != 2: - y = y.reshape(-1, 1) - - if metric not in REGRESSOR_METRICS: - raise RuntimeError(f'Metric must be either "mse" or "mae", got {metric}') - - if covariate_index is None: - self.estimator_ = self._get_estimator() - estimator = self.estimator_ - else: - self.permuted_estimator_ = clone(self.estimator_) - estimator = self.permuted_estimator_ - - return self._statistic( - estimator, - X, - y, - covariate_index=covariate_index, - metric=metric, - return_posteriors=return_posteriors, - **metric_kwargs, - ) - - def test( - self, - X, - y, - covariate_index: ArrayLike, - metric: str = "mse", - test_size: float = 0.2, - n_repeats: int = 1000, - return_posteriors: bool = False, - **metric_kwargs, - ): - """Perform hypothesis test using Coleman method. - - X is split into a training/testing split. Optionally, the covariate index - columns are shuffled. - - On the training dataset, two honest forests are trained and then the posterior - is estimated on the testing dataset. One honest forest is trained on the - permuted dataset and the other is trained on the original dataset. - - Finally, resample the posteriors of the two forests to compute the null - distribution of the statistics. - - Parameters - ---------- - X : ArrayLike of shape (n_samples, n_features) - The data matrix. - y : ArrayLike of shape (n_samples, n_outputs) - The target matrix. - covariate_index : ArrayLike, optional of shape (n_covariates,) - The index array of covariates to shuffle, by default None. - metric : str, optional - The metric to compute, by default "mse". - test_size : float, optional - Proportion of samples per tree to use for the test set, by default 0.2. - n_repeats : int, optional - Number of times to sample the null distribution, by default 1000. - return_posteriors : bool, optional - Whether or not to return the posteriors, by default False. - - Returns - ------- - stat : float - The test statistic. - pval : float - The p-value of the test statistic. - """ - X, y = check_X_y(X, y, ensure_2d=True, copy=True, multi_output=True) - if y.ndim != 2: - y = y.reshape(-1, 1) - - indices = np.arange(X.shape[0]) - self.test_size_ = int(test_size * X.shape[0]) - # if not self.permute_per_tree: - # # train/test split - # # XXX: could add stratifying by y when y is classification - # indices_train, indices_test = train_test_split( - # indices, test_size=test_size, shuffle=True - # ) - # self.indices_train_ = indices_train - # self.indices_test_ = indices_test - indices_train, indices_test = train_test_split(indices, test_size=test_size, shuffle=True) - self.indices_train_ = indices_train - self.indices_test_ = indices_test - - if not hasattr(self, "samples_"): - # first compute the test statistic on the un-permuted data - observe_stat, observe_posteriors, observe_samples = self.statistic( - X, - y, - covariate_index=None, - metric=metric, - return_posteriors=True, - check_input=False, - **metric_kwargs, - ) - else: - observe_samples = self.samples_ - observe_posteriors = self.posterior_final_ - observe_stat = self.stat_ - - # next permute the data - permute_stat, permute_posteriors, permute_samples = self.statistic( - X, - y, - covariate_index=covariate_index, - metric=metric, - return_posteriors=True, - check_input=False, - **metric_kwargs, - ) - - # Note: at this point, both `estimator` and `permuted_estimator_` should - # have been fitted already, so we can now compute on the null by resampling - # the posteriors and computing the test statistic on the resampled posteriors - if self.sample_dataset_per_tree: - metric_star, metric_star_pi = _compute_null_distribution_coleman( - y_test=y[observe_samples, :], - y_pred_proba_normal=observe_posteriors, - y_pred_proba_perm=permute_posteriors, - metric=metric, - n_repeats=n_repeats, - seed=self.random_state, - ) - else: - metric_star, metric_star_pi = _compute_null_distribution_coleman( - y_test=y[self.indices_test_, :], - y_pred_proba_normal=observe_posteriors, - y_pred_proba_perm=permute_posteriors, - metric=metric, - n_repeats=n_repeats, - seed=self.random_state, - ) - # metric^\pi - metric = observed test statistic, which under the null is normally distributed around 0 - observe_stat = permute_stat - observe_stat - - # metric^\pi_j - metric_j, which is centered at 0 - null_dist = metric_star_pi - metric_star - - # compute pvalue - pvalue = (1 + (null_dist >= observe_stat).sum()) / (1 + n_repeats) - - if return_posteriors: - self.observe_posteriors_ = observe_posteriors - self.permute_posteriors_ = permute_posteriors - self.observe_samples_ = observe_samples - self.permute_samples_ = permute_samples - - self.null_dist_ = null_dist - return observe_stat, pvalue diff --git a/sktree/stats/permutationforest.py b/sktree/stats/permutationforest.py index fb9c6a98b..55b79833b 100644 --- a/sktree/stats/permutationforest.py +++ b/sktree/stats/permutationforest.py @@ -243,7 +243,7 @@ def test( if not hasattr(self, "samples_"): # first compute the test statistic on the un-permuted data - observe_stat, observe_posteriors, observe_samples = self.statistic( + observe_stat, _, _ = self.statistic( X, y, covariate_index=None, @@ -253,8 +253,8 @@ def test( **metric_kwargs, ) else: - observe_samples = self.samples_ - observe_posteriors = self.posterior_final_ + # observe_samples = self.samples_ + # observe_posteriors = self.posterior_final_ observe_stat = self.stat_ # compute null distribution of the test statistic @@ -572,7 +572,7 @@ class PermutationForestClassifier(BasePermutationForest): non-permuted data. .. note:: This does not allow testing on the posteriors. - + Parameters ---------- estimator : object, default=None @@ -830,6 +830,6 @@ def _get_estimator(self): max_samples=self.max_samples, **self.estimator_kwargs, ) - elif not isinstance(self.estimator_, ForestRegressor): - raise RuntimeError(f"Estimator must be a ForestRegressor, got {type(self.estimator_)}") + elif not isinstance(self.estimator_, ForestClassifier): + raise RuntimeError(f"Estimator must be a ForestClassifier, got {type(self.estimator_)}") return estimator_ diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 93e2138f8..d02f09fa8 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -5,11 +5,11 @@ from sktree._lib.sklearn.tree import DecisionTreeClassifier from sktree.stats import ( + FeatureImportanceForestClassifier, FeatureImportanceForestRegressor, PermutationForestClassifier, PermutationForestRegressor, ) -from sktree.stats.forestht import ForestHT from sktree.tree import ObliqueDecisionTreeClassifier # load the iris dataset @@ -39,13 +39,36 @@ def test_forestht_proper_attributes(): @pytest.mark.slowtest @pytest.mark.parametrize( - "hypotester", + "hypotester, model_kwargs, n_samples, n_repeats, test_size", [ - # PermutationForestRegressor, - FeatureImportanceForestRegressor + [ + PermutationForestRegressor, + { + "max_features": 1.0, + "random_state": seed, + "n_estimators": 50, + "n_jobs": -1, + }, + 550, + 50, + 0.1, + ], + [ + FeatureImportanceForestRegressor, + { + "max_features": 1.0, + "random_state": seed, + "n_estimators": 125, + "permute_per_tree": True, + "n_jobs": -1, + }, + 600, + 200, + 0.1, + ], ], ) -def test_linear_model(hypotester): +def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size): r"""Test hypothesis testing forests using MSE from linear model simulation. See https://arxiv.org/pdf/1904.07830.pdf Figure 1. @@ -54,10 +77,6 @@ def test_linear_model(hypotester): """ beta = 10.0 sigma = 0.5 - n_samples = 550 - n_estimators = 50 - test_size = 0.1 - n_repeats = 50 metric = "mse" rng = np.random.default_rng(seed) @@ -77,12 +96,7 @@ def test_linear_model(hypotester): # compute final y of (n_samples,) y = beta * X[:, 0] + (beta * (X[:, 5] == 2.0)) + epsilon - est = hypotester( - max_features=1.0, - random_state=seed, - n_estimators=n_estimators, - n_jobs=-1, - ) + est = hypotester(**model_kwargs) # test for X_1 stat, pvalue = est.test(X, y, [0], metric=metric, test_size=test_size, n_repeats=n_repeats) @@ -106,76 +120,37 @@ def test_linear_model(hypotester): @pytest.mark.slowtest @pytest.mark.parametrize( - "hypotester", + "hypotester, model_kwargs, n_samples, n_repeats, test_size", [ - # PermutationForestRegressor, - FeatureImportanceForestRegressor + [ + PermutationForestClassifier, + { + "max_features": "sqrt", + "random_state": seed, + "n_estimators": 75, + "n_jobs": -1, + }, + 500, + 50, + 1.0 / 6, + ], + [ + FeatureImportanceForestClassifier, + { + "max_features": "sqrt", + "random_state": seed, + "n_estimators": 125, + "permute_per_tree": True, + "sample_dataset_per_tree": True, + "n_jobs": -1, + }, + 500, + 100, + 1.0 / 6, + ], ], ) -def test_linear_model_withcoleman(hypotester): - r"""Test hypothesis testing forests using MSE from linear model simulation. - - See https://arxiv.org/pdf/1904.07830.pdf Figure 1. - - Y = Beta * X_1 + Beta * I(X_6 = 2) + \epsilon - """ - beta = 10.0 - sigma = 0.5 - n_samples = 600 - n_estimators = 125 - test_size = 0.1 - n_repeats = 200 - permute_per_tree = True - metric = "mse" - - rng = np.random.default_rng(seed) - - # sample covariates - X_15 = rng.uniform(0, 1, size=(n_samples, 5)) - X_610 = np.zeros((n_samples, 5)) - for idx in range(5): - X_610[:, idx] = np.argwhere( - rng.multinomial(1, [1.0 / 3, 1.0 / 3, 1.0 / 3], size=(n_samples,)) - )[:, 1] - X = np.concatenate((X_15, X_610), axis=1) - assert X.shape == (n_samples, 10) - - # sample noise - epsilon = rng.normal(size=n_samples, loc=0.0, scale=sigma) - - # compute final y of (n_samples,) - y = beta * X[:, 0] + (beta * (X[:, 5] == 2.0)) + epsilon - est = hypotester( - max_features=1.0, - random_state=seed, - n_estimators=n_estimators, - permute_per_tree=permute_per_tree, - n_jobs=-1, - ) - - # test for X_1 - stat, pvalue = est.test(X, y, [0], metric=metric, test_size=test_size, n_repeats=n_repeats) - print("X1: ", pvalue) - assert pvalue < 0.05, f"pvalue: {pvalue}" - - # test for X_6 - stat, pvalue = est.test(X, y, [5], metric=metric, test_size=test_size, n_repeats=n_repeats) - print("X6: ", pvalue) - assert pvalue < 0.05, f"pvalue: {pvalue}" - - # test for a few unimportant other X - for covariate_index in [1, 6]: - # test for X_2, X_7 - stat, pvalue = est.test( - X, y, [covariate_index], metric=metric, test_size=test_size, n_repeats=n_repeats - ) - print("X2/7: ", pvalue) - assert pvalue > 0.05, f"pvalue: {pvalue}" - - -@pytest.mark.slowtest -@pytest.mark.parametrize("hypotester", [PermutationForestClassifier]) -def test_correlated_logit_model(hypotester): +def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, test_size): r"""Test MIGHT using MSE from linear model simulation. See https://arxiv.org/pdf/1904.07830.pdf Figure 1. @@ -183,13 +158,7 @@ def test_correlated_logit_model(hypotester): P(Y = 1 | X) = expit(beta * \\sum_{j=2}^5 X_j) """ beta = 5.0 - n_samples = 600 - n_estimators = 50 - n_jobs = -1 - max_features = "sqrt" - test_size = 1.0 / 6 metric = "mse" - n_repeats = 50 n = 200 # Number of time steps ar_coefficient = 0.0015 @@ -216,9 +185,7 @@ def test_correlated_logit_model(hypotester): assert y_proba.shape == (n_samples,) y = rng.binomial(1, y_proba, size=n_samples) # .reshape(-1, 1) - est = hypotester( - max_features=max_features, random_state=seed, n_estimators=n_estimators, n_jobs=n_jobs - ) + est = hypotester(**model_kwargs) # test for X_2 important stat, pvalue = est.test( @@ -256,7 +223,7 @@ def test_correlated_logit_model(hypotester): @pytest.mark.parametrize("limit", [0.05, 0.1]) def test_iris_pauc(criterion, max_features, honest_prior, estimator, limit): # Check consistency on dataset iris. - clf = ForestHT( + clf = FeatureImportanceForestClassifier( criterion=criterion, random_state=0, max_features=max_features, diff --git a/sktree/stats/utils.py b/sktree/stats/utils.py index c0a988520..cf725f2a2 100644 --- a/sktree/stats/utils.py +++ b/sktree/stats/utils.py @@ -107,7 +107,6 @@ def _compute_null_distribution_perm( train_index_arr = np.arange(n_samples_train, dtype=int).reshape(-1, 1) test_index_arr = np.arange(n_samples_test, dtype=int).reshape(-1, 1) - X = np.concatenate((X_train, X_test), axis=0) null_metrics = np.zeros((n_repeats,)) for idx in range(n_repeats): @@ -181,7 +180,10 @@ def _compute_null_distribution_coleman( all_y_pred = np.concatenate((y_pred_proba_normal, y_pred_proba_perm), axis=0) n_samples_test = len(y_test) - assert len(all_y_pred) == 2 * n_samples_test + if len(all_y_pred) != 2 * n_samples_test: + raise RuntimeError( + "The number of samples in `all_y_pred` is not equal to 2 * n_samples_test" + ) # create two stacked index arrays of y_test resulting in [1, ..., N, 1, ..., N] y_test_ind_arr = np.hstack( From 168935c995273581507a2dd536b12487b676655a Mon Sep 17 00:00:00 2001 From: Adam Li Date: Mon, 18 Sep 2023 15:12:34 -0400 Subject: [PATCH 19/70] Add documentation Signed-off-by: Adam Li --- doc/api.rst | 14 ++++++++++++++ doc/whats_new/v0.2.rst | 2 ++ 2 files changed, 16 insertions(+) diff --git a/doc/api.rst b/doc/api.rst index 59a58370f..cb722bdf0 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -125,6 +125,20 @@ an API-like interface similar to :class:`~sklearn.neighbors.NearestNeighbors`. NearestNeighborsMetaEstimator +Statistical Hypothesis Testing +------------------------------ +We provide an API for performing statistical hypothesis testing using Decision +tree models. + +.. currentmodule:: sktree.stats +.. autosummary:: + :toctree: generated/ + + FeatureImportanceForestRegressor + FeatureImportanceForestClassifier + PermutationImportanceForestRegressor + PermutationImportanceForestClassifier + Experimental Functionality -------------------------- diff --git a/doc/whats_new/v0.2.rst b/doc/whats_new/v0.2.rst index 37848d99f..97c5d501f 100644 --- a/doc/whats_new/v0.2.rst +++ b/doc/whats_new/v0.2.rst @@ -32,6 +32,7 @@ Changelog - |API| Allow ``sqrt`` and ``log2`` keywords to be used for ``min_samples_split`` parameter in unsupervised forests, by `Adam Li`_ (:pr:`114`) - |Feature| Implement extended isolation forest, by `Adam Li`_ (:pr:`101`) - |Feature| Implementation of StreamDecisionForest, by `Haoyin Xu`_ and `Adam Li`_ (:pr:`116`) +- |Feature| Implementation of Permutation forests and a feature importance testing forest, by `Haoyin Xu`_, `Adam Li`_, `Sambit Panda` (:pr:`125`) Code and Documentation Contributors ----------------------------------- @@ -42,3 +43,4 @@ the project since version inception, including: * `Adam Li`_ * `SUKI-O`_ * `Haoyin Xu`_ +* `Sambit Panda`_ From 01f20853ac8c3fa437d32cfed8f018543f3dcdb2 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 19 Sep 2023 10:53:16 -0400 Subject: [PATCH 20/70] Adding posterior Signed-off-by: Adam Li --- .../test_permutation_forest.ipynb | 30 +- sktree/stats/__init__.py | 1 - sktree/stats/_might.py | 319 ------------------ sktree/stats/forestht.py | 240 ++++++++----- sktree/stats/meson.build | 1 - sktree/stats/permutationforest.py | 12 + sktree/stats/tests/test_forestht.py | 103 +++--- sktree/stats/tests/test_might.py | 51 --- sktree/stats/utils.py | 24 +- test_requirements.txt | 3 +- 10 files changed, 258 insertions(+), 526 deletions(-) delete mode 100644 sktree/stats/_might.py delete mode 100644 sktree/stats/tests/test_might.py diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/test_permutation_forest.ipynb index bd7e6c43b..0fb5add90 100644 --- a/benchmarks_nonasv/test_permutation_forest.ipynb +++ b/benchmarks_nonasv/test_permutation_forest.ipynb @@ -2,10 +2,30 @@ "cells": [ { "cell_type": "code", - "execution_count": 15, + "execution_count": 1, "id": "b658bdd8-a3e6-4051-9d66-f2a153113234", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: '/Users/adam2392/Documents/scikit-tree/sktree/stats/_might.py'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 9\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mseaborn\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01msns\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mscipy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mspecial\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m expit\n\u001b[0;32m----> 9\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msktree\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mstats\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m (\n\u001b[1;32m 10\u001b[0m FeatureImportanceForestClassifier,\n\u001b[1;32m 11\u001b[0m FeatureImportanceForestRegressor,\n\u001b[1;32m 12\u001b[0m PermutationForestRegressor,\n\u001b[1;32m 13\u001b[0m )\n\u001b[1;32m 15\u001b[0m seed \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m12345\u001b[39m\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/__init__.py:39\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[38;5;66;03m# We are not importing the rest of scikit-tree during the build\u001b[39;00m\n\u001b[1;32m 36\u001b[0m \u001b[38;5;66;03m# process, as it may not be compiled yet\u001b[39;00m\n\u001b[1;32m 37\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 38\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 39\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m _lib, tree, ensemble, experimental, stats\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01m_lib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01msklearn\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mensemble\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01m_forest\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m (\n\u001b[1;32m 41\u001b[0m RandomForestClassifier,\n\u001b[1;32m 42\u001b[0m RandomForestRegressor,\n\u001b[1;32m 43\u001b[0m ExtraTreesClassifier,\n\u001b[1;32m 44\u001b[0m ExtraTreesRegressor,\n\u001b[1;32m 45\u001b[0m )\n\u001b[1;32m 46\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mneighbors\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m NearestNeighborsMetaEstimator\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/stats/__init__.py:1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01m_might\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m MIGHT, MIGHT_MV\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mforestht\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m FeatureImportanceForestClassifier, FeatureImportanceForestRegressor\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpermutationforest\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m PermutationForestClassifier, PermutationForestRegressor\n", + "File \u001b[0;32m:1007\u001b[0m, in \u001b[0;36m_find_and_load\u001b[0;34m(name, import_)\u001b[0m\n", + "File \u001b[0;32m:986\u001b[0m, in \u001b[0;36m_find_and_load_unlocked\u001b[0;34m(name, import_)\u001b[0m\n", + "File \u001b[0;32m:680\u001b[0m, in \u001b[0;36m_load_unlocked\u001b[0;34m(spec)\u001b[0m\n", + "File \u001b[0;32m:846\u001b[0m, in \u001b[0;36mexec_module\u001b[0;34m(self, module)\u001b[0m\n", + "File \u001b[0;32m:982\u001b[0m, in \u001b[0;36mget_code\u001b[0;34m(self, fullname)\u001b[0m\n", + "File \u001b[0;32m:1039\u001b[0m, in \u001b[0;36mget_data\u001b[0;34m(self, path)\u001b[0m\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/Users/adam2392/Documents/scikit-tree/sktree/stats/_might.py'" + ] + } + ], "source": [ "from collections import defaultdict\n", "\n", @@ -26,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "05b0b53e-0525-45ce-9f7e-0322a30221cf", "metadata": {}, "outputs": [], @@ -37,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "5e2d1279-fa4f-47ef-aa48-fac6d47159ad", "metadata": {}, "outputs": [], @@ -139,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "3db4f740-afd9-413e-8089-a8245f2a0747", "metadata": {}, "outputs": [], diff --git a/sktree/stats/__init__.py b/sktree/stats/__init__.py index 6191b93dd..b01038036 100644 --- a/sktree/stats/__init__.py +++ b/sktree/stats/__init__.py @@ -1,3 +1,2 @@ -from ._might import MIGHT, MIGHT_MV from .forestht import FeatureImportanceForestClassifier, FeatureImportanceForestRegressor from .permutationforest import PermutationForestClassifier, PermutationForestRegressor diff --git a/sktree/stats/_might.py b/sktree/stats/_might.py deleted file mode 100644 index 9e57ed921..000000000 --- a/sktree/stats/_might.py +++ /dev/null @@ -1,319 +0,0 @@ -import numpy as np -from joblib import Parallel, delayed -from scipy.stats import entropy -from sklearn.metrics import roc_auc_score -from sklearn.model_selection import train_test_split - -from ..ensemble import HonestForestClassifier - - -def auc_calibrator(tree, X, y, test_size=0.2, permute_y=False): - indices = np.arange(X.shape[0]) - X_train, X_test, y_train, y_test, indices_train, indices_test = train_test_split( - X, y, indices, test_size=test_size - ) - - # individual tree permutation of y labels - if permute_y: - y_train = np.random.permutation(y_train) - - tree.fit(X_train, y_train) - y_pred = tree.predict_proba(X_test)[:, 1] - - # Fill test set posteriors & set rest NaN - posterior = np.full(y.shape, np.nan) - posterior[indices_test] = y_pred - - return posterior - - -def perm_stat(clf, x, z, y, random_state=None): - if z is not None: - permuted_Z = np.random.permutation(z) - X_permutedZ = np.hstack((x, permuted_Z)) - else: - X_permutedZ = np.random.permutation(x) - - perm_stat = clf.statistic(X_permutedZ, y) - return perm_stat - - -def perm_half(clf, z, y, x_pos): - permuted_Z = np.random.permutation(z) - perm_stat, perm_pos = clf.statistic(permuted_Z, y, return_pos=True) - null_pos = forest_pos(x_pos + perm_pos, y) - null_stat = roc_auc_score(null_pos[:, 0], null_pos[:, 1], max_fpr=clf.limit) - - return null_stat - - -def pos_diff(observe_pos, perm_pos, y, limit): - total_pos = np.random.shuffle(np.concatenate((observe_pos, perm_pos))) - - half_ind = len(total_pos) * 0.5 - half_pos = total_pos[:half_ind] - end_pos = total_pos[half_ind:] - - half_pos_final = forest_pos(half_pos, y) - half_stat = roc_auc_score(half_pos_final[:, 0], half_pos_final[:, 1], max_fpr=limit) - - end_pos_final = forest_pos(end_pos, y) - end_stat = roc_auc_score(end_pos_final[:, 0], end_pos_final[:, 1], max_fpr=limit) - - return abs(half_stat - end_stat) - - -def forest_pos(posterior, y): - # Average all posteriors - posterior_final = np.nanmean(posterior, axis=0) - - # Ignore all NaN values (samples not tested) - true_final = y.ravel()[~np.isnan(posterior_final)].reshape(-1, 1) - posterior_final = posterior_final[~np.isnan(posterior_final)].reshape(-1, 1) - - return np.hstack((true_final, posterior_final)) - - -class MIGHT: - def __init__( - self, - n_estimators=500, - criterion="gini", - splitter="best", - max_depth=None, - min_samples_split=2, - min_samples_leaf=1, - min_weight_fraction_leaf=0.0, - max_features="sqrt", - max_leaf_nodes=None, - min_impurity_decrease=0.0, - bootstrap=False, - oob_score=False, - n_jobs=None, - random_state=None, - verbose=0, - warm_start=False, - class_weight=None, - ccp_alpha=0.0, - max_samples=None, - honest_prior="empirical", - honest_fraction=0.5, - tree_estimator=None, - limit=0.05, - ): - self.clf = HonestForestClassifier( - n_estimators=n_estimators, - criterion=criterion, - splitter=splitter, - max_depth=max_depth, - min_samples_split=min_samples_split, - min_samples_leaf=min_samples_leaf, - min_weight_fraction_leaf=min_weight_fraction_leaf, - max_features=max_features, - max_leaf_nodes=max_leaf_nodes, - min_impurity_decrease=min_impurity_decrease, - bootstrap=bootstrap, - oob_score=oob_score, - n_jobs=n_jobs, - random_state=random_state, - verbose=verbose, - warm_start=warm_start, - class_weight=class_weight, - ccp_alpha=ccp_alpha, - max_samples=max_samples, - honest_prior=honest_prior, - honest_fraction=honest_fraction, - tree_estimator=tree_estimator, - ) - self.limit = limit - - def statistic( - self, - x, - y, - stat="AUC", - workers=1, - test_size=0.2, - initial=True, - return_pos=False, - permute_y=False, - ): - # Initialize trees - if initial: - self.clf.fit(x[0:2], y.ravel()[0:2]) - - # Compute posteriors with train test splits - posterior = Parallel(n_jobs=workers)( - delayed(auc_calibrator)(tree, x, y.ravel(), test_size, permute_y) - for tree in (self.clf.estimators_) - ) - - posterior_final = forest_pos(posterior, y) - - if stat == "AUC": - self.stat = roc_auc_score( - posterior_final[:, 0], posterior_final[:, 1], max_fpr=self.limit - ) - elif stat == "MI": - class_zero = (1 - posterior_final[:, 1]).reshape(-1, 1) - full_class = np.hstack((class_zero, posterior_final[:, 1].reshape(-1, 1))) - H_YX = np.mean(entropy(full_class, base=np.exp(1), axis=1)) - _, counts = np.unique(posterior_final[:, 0], return_counts=True) - H_Y = entropy(counts, base=np.exp(1)) - self.stat = max(H_Y - H_YX, 0) - - if return_pos: - return self.stat, posterior - - return self.stat - - def test(self, x, y, reps=1000, workers=1, random_state=None): - observe_stat = self.statistic(x, y) - - null_dist = np.array( - Parallel(n_jobs=workers)([delayed(perm_stat)(self, x, None, y) for _ in range(reps)]) - ) - pval = (1 + (null_dist >= observe_stat).sum()) / (1 + reps) - - return observe_stat, null_dist, pval - - -class MIGHT_MV: - def __init__( - self, - n_estimators=500, - criterion="gini", - splitter="best", - max_depth=None, - min_samples_split=2, - min_samples_leaf=1, - min_weight_fraction_leaf=0.0, - max_features="sqrt", - max_leaf_nodes=None, - min_impurity_decrease=0.0, - bootstrap=False, - oob_score=False, - n_jobs=None, - random_state=None, - verbose=0, - warm_start=False, - class_weight=None, - ccp_alpha=0.0, - max_samples=None, - honest_prior="empirical", - honest_fraction=0.5, - tree_estimator=None, - limit=0.05, - ): - self.clf = HonestForestClassifier( - n_estimators=n_estimators, - criterion=criterion, - splitter=splitter, - max_depth=max_depth, - min_samples_split=min_samples_split, - min_samples_leaf=min_samples_leaf, - min_weight_fraction_leaf=min_weight_fraction_leaf, - max_features=max_features, - max_leaf_nodes=max_leaf_nodes, - min_impurity_decrease=min_impurity_decrease, - bootstrap=bootstrap, - oob_score=oob_score, - n_jobs=n_jobs, - random_state=random_state, - verbose=verbose, - warm_start=warm_start, - class_weight=class_weight, - ccp_alpha=ccp_alpha, - max_samples=max_samples, - honest_prior=honest_prior, - honest_fraction=honest_fraction, - tree_estimator=tree_estimator, - ) - self.limit = limit - - def statistic( - self, - x, - y, - stat="AUC", - workers=1, - test_size=0.2, - initial=True, - return_pos=False, - permute_y=False, - ): - # Initialize trees - if initial: - self.clf.fit(x[0:2], y.ravel()[0:2]) - - # Compute posteriors with train test splits - posterior = Parallel(n_jobs=workers)( - delayed(auc_calibrator)(tree, x, y.ravel(), test_size, permute_y) - for tree in (self.clf.estimators_) - ) - - posterior_final = forest_pos(posterior, y) - - if stat == "AUC": - self.stat = roc_auc_score( - posterior_final[:, 0], posterior_final[:, 1], max_fpr=self.limit - ) - elif stat == "MI": - H_YX = np.mean(entropy(posterior_final[:, 1], base=np.exp(1))) - _, counts = np.unique(posterior_final[:, 0], return_counts=True) - H_Y = entropy(counts, base=np.exp(1)) - self.stat = max(H_Y - H_YX, 0) - - if return_pos: - return self.stat, posterior - - return self.stat - - def test(self, x, z, y, reps=1000, workers=1, random_state=None): - XZ = np.hstack((x, z)) - observe_stat = self.statistic(XZ, y) - - null_dist = np.array( - Parallel(n_jobs=workers)([delayed(perm_stat)(self, x, z, y) for _ in range(reps)]) - ) - pval = (1 + (null_dist >= observe_stat).sum()) / (1 + reps) - - return observe_stat, null_dist, pval - - def test_twin(self, x, z, y, reps=1000, workers=1, random_state=None): - x_stat, x_pos = self.statistic(x, y, return_pos=True) - - # TODO: determine whether we need the forest - - z_stat, z_pos = self.statistic(z, y, return_pos=True) - - observe_pos = forest_pos(x_pos + z_pos, y) - observe_stat = roc_auc_score(observe_pos[:, 0], observe_pos[:, 1], max_fpr=self.limit) - - null_dist = np.array( - Parallel(n_jobs=workers)([delayed(perm_half)(self, z, y, x_pos) for _ in range(reps)]) - ) - pval = (1 + (null_dist >= observe_stat).sum()) / (1 + reps) - - return observe_stat, null_dist, pval - - def test_diff(self, x, z, y, reps=1000, workers=1): - XZ = np.hstack((x, z)) - observe_stat, observe_pos = self.statistic(XZ, y, return_pos=True) - - # Compute statistic for permuted sets - permuted_Z = np.random.permutation(z) - X_permutedZ = np.hstack((x, permuted_Z)) - perm_stat, perm_pos = self.statistic(X_permutedZ, y, return_pos=True) - - # Bootstrap sample the posterior from the two forests - null_stats = np.array( - Parallel(n_jobs=workers)( - [delayed(pos_diff)(observe_pos, perm_pos, y, limit=self.limit) for _ in range(reps)] - ) - ) - - stat = observe_stat - perm_stat - - pval = (1 + (null_stats >= stat).sum()) / (1 + reps) - return stat, null_stats, pval diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index cbd31fe56..8c329dbae 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -1,7 +1,10 @@ import numpy as np from numpy.typing import ArrayLike -from sklearn.base import MetaEstimatorMixin, clone +from sklearn.base import MetaEstimatorMixin, clone, is_classifier +from sklearn.ensemble._forest import ForestClassifier as sklearnForestClassifier +from sklearn.ensemble._forest import ForestRegressor as sklearnForestRegressor from sklearn.model_selection import train_test_split +from sklearn.utils.multiclass import type_of_target from sklearn.utils.validation import _is_fitted, check_X_y from sktree._lib.sklearn.ensemble._forest import ( @@ -15,6 +18,8 @@ from .utils import ( METRIC_FUNCTIONS, + POSITIVE_METRICS, + POSTERIOR_FUNCTIONS, REGRESSOR_METRICS, _compute_null_distribution_coleman, train_tree, @@ -43,7 +48,7 @@ def __init__( ccp_alpha=0.0, max_samples=None, permute_per_tree=True, - **estimator_kwargs, + sample_dataset_per_tree=True, ): self.estimator = estimator self.n_jobs = n_jobs @@ -63,8 +68,8 @@ def __init__( self.warm_start = warm_start self.ccp_alpha = ccp_alpha self.max_samples = max_samples - self.estimator_kwargs = estimator_kwargs self.permute_per_tree = permute_per_tree + self.sample_dataset_per_tree = sample_dataset_per_tree def reset(self): class_attributes = dir(type(self)) @@ -120,9 +125,6 @@ def statistic( if y.ndim != 2: y = y.reshape(-1, 1) - if metric not in REGRESSOR_METRICS: - raise RuntimeError(f'Metric must be either "mse" or "mae", got {metric}') - if covariate_index is None: self.estimator_ = self._get_estimator() estimator = self.estimator_ @@ -130,6 +132,9 @@ def statistic( self.permuted_estimator_ = clone(self.estimator_) estimator = self.permuted_estimator_ + if not is_classifier(self.estimator_) and metric not in REGRESSOR_METRICS: + raise RuntimeError(f'Metric must be either "mse" or "mae", got {metric}') + return self._statistic( estimator, X, @@ -193,14 +198,6 @@ def test( indices = np.arange(X.shape[0]) self.test_size_ = int(test_size * X.shape[0]) - # if not self.permute_per_tree: - # # train/test split - # # XXX: could add stratifying by y when y is classification - # indices_train, indices_test = train_test_split( - # indices, test_size=test_size, shuffle=True - # ) - # self.indices_train_ = indices_train - # self.indices_test_ = indices_test indices_train, indices_test = train_test_split(indices, test_size=test_size, shuffle=True) self.indices_train_ = indices_train self.indices_test_ = indices_test @@ -245,8 +242,13 @@ def test( seed=self.random_state, ) else: + if self.permute_per_tree: + y_test = y + else: + y_test = y[self.indices_test_, :] + print(y.shape, observe_posteriors.shape, permute_posteriors.shape) metric_star, metric_star_pi = _compute_null_distribution_coleman( - y_test=y[self.indices_test_, :], + y_test=y_test, y_pred_proba_normal=observe_posteriors, y_pred_proba_perm=permute_posteriors, metric=metric, @@ -261,7 +263,10 @@ def test( null_dist = metric_star_pi - metric_star # compute pvalue - pvalue = (1 + (null_dist >= observe_stat).sum()) / (1 + n_repeats) + if metric in POSITIVE_METRICS: + pvalue = (1 + (null_dist <= observe_stat).sum()) / (1 + n_repeats) + else: + pvalue = (1 + (null_dist >= observe_stat).sum()) / (1 + n_repeats) if return_posteriors: self.observe_posteriors_ = observe_posteriors @@ -276,6 +281,8 @@ def test( class FeatureImportanceForestRegressor(BaseForestHT): """Forest hypothesis testing with continuous `y` variable. + Implements the algorithm described in :footcite:`coleman2022scalable`. + The dataset is split into a training and testing dataset initially. Then there are two forests that are trained: one on the original dataset, and one on the permuted dataset. The dataset is either permuted once, or independently for @@ -443,6 +450,12 @@ class FeatureImportanceForestRegressor(BaseForestHT): - If float, then draw `max_samples * X.shape[0]` samples. Thus, `max_samples` should be in the interval `(0.0, 1.0]`. + permute_per_tree : bool, default=True + Whether to permute the covariate index per tree or per forest. + + sample_dataset_per_tree : bool, default=False + Whether to sample the dataset per tree or per forest. + Attributes ---------- samples_ : ArrayLike of shape (n_samples,) @@ -456,6 +469,10 @@ class FeatureImportanceForestRegressor(BaseForestHT): null_dist_ : ArrayLike of shape (n_repeats,) The null distribution of the test statistic. + + References + ---------- + .. footbibliography:: """ def __init__( @@ -479,8 +496,7 @@ def __init__( ccp_alpha=0.0, max_samples=None, permute_per_tree=True, - sample_dataset_per_tree=False, - **estimator_kwargs, + sample_dataset_per_tree=True, ): super().__init__( estimator=estimator, @@ -501,7 +517,6 @@ def __init__( warm_start=warm_start, ccp_alpha=ccp_alpha, max_samples=max_samples, - **estimator_kwargs, ) self.permute_per_tree = permute_per_tree self.sample_dataset_per_tree = sample_dataset_per_tree @@ -526,9 +541,8 @@ def _get_estimator(self): warm_start=self.warm_start, ccp_alpha=self.ccp_alpha, max_samples=self.max_samples, - **self.estimator_kwargs, ) - elif isinstance(self.estimator, ForestRegressor): + elif not isinstance(self.estimator, (ForestRegressor, sklearnForestRegressor)): raise RuntimeError(f"Estimator must be a ForestRegressor, got {type(self.estimator)}") else: estimator_ = self.estimator @@ -585,6 +599,11 @@ def _statistic( X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) estimator.fit(X_dummy, unique_y) + if hasattr(self, "test_size_"): + test_size = self.test_size_ + else: + test_size = 0.2 # type: ignore + # now initialize posterior array as (n_trees, n_samples, n_outputs) posterior_arr = np.full((self.n_estimators, n_samples, estimator.n_outputs_), np.nan) # Fit each tree and compute posteriors with train test splits @@ -592,7 +611,7 @@ def _statistic( # sample train/test dataset for each tree indices_train, indices_test = train_test_split( np.arange(n_samples, dtype=int), - test_size=self.test_size_, + test_size=test_size, shuffle=True, random_state=rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32), ) @@ -653,6 +672,8 @@ def _statistic( class FeatureImportanceForestClassifier(BaseForestHT): """Forest hypothesis testing with categorical `y` variable. + Implements the algorithm described in :footcite:`coleman2022scalable`. + The dataset is split into a training and testing dataset initially. Then there are two forests that are trained: one on the original dataset, and one on the permuted dataset. The dataset is either permuted once, or independently for @@ -820,6 +841,12 @@ class FeatureImportanceForestClassifier(BaseForestHT): - If float, then draw `max_samples * X.shape[0]` samples. Thus, `max_samples` should be in the interval `(0.0, 1.0]`. + permute_per_tree : bool, default=True + Whether to permute the covariate index per tree or per forest. + + sample_dataset_per_tree : bool, default=False + Whether to sample the dataset per tree or per forest. + Attributes ---------- samples_ : ArrayLike of shape (n_samples,) @@ -833,6 +860,10 @@ class FeatureImportanceForestClassifier(BaseForestHT): null_dist_ : ArrayLike of shape (n_repeats,) The null distribution of the test statistic. + + References + ---------- + .. footbibliography:: """ def __init__( @@ -856,8 +887,7 @@ def __init__( ccp_alpha=0.0, max_samples=None, permute_per_tree=True, - sample_dataset_per_tree=False, - **estimator_kwargs, + sample_dataset_per_tree=True, ): super().__init__( estimator=estimator, @@ -878,7 +908,6 @@ def __init__( warm_start=warm_start, ccp_alpha=ccp_alpha, max_samples=max_samples, - **estimator_kwargs, ) self.permute_per_tree = permute_per_tree self.sample_dataset_per_tree = sample_dataset_per_tree @@ -903,11 +932,14 @@ def _get_estimator(self): warm_start=self.warm_start, ccp_alpha=self.ccp_alpha, max_samples=self.max_samples, - **self.estimator_kwargs, ) - elif isinstance(self.estimator, ForestClassifier): + elif not isinstance(self.estimator, (ForestClassifier, sklearnForestClassifier)): raise RuntimeError(f"Estimator must be a ForestClassifier, got {type(self.estimator)}") else: + # self.estimator is an instance of a ForestEstimator, so we should verify that all + # the parameters are set correctly + # XXX: implement checks + estimator_ = self.estimator return estimator_ @@ -926,70 +958,89 @@ def _statistic( rng = np.random.default_rng(self.random_state) n_samples = X.shape[0] - if self.permute_per_tree and not self.sample_dataset_per_tree: - # first run a dummy fit on the samples to initialize the - # internal data structure of the forest - if not _is_fitted(estimator): - unique_y = np.unique(y) - X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) - estimator.fit(X_dummy, unique_y) - - # Fit each tree and compute posteriors with train test splits - n_samples_test = len(self.indices_test_) - - # now initialize posterior array as (n_trees, n_samples_test, n_outputs) - posterior_arr = np.zeros((self.n_estimators, n_samples_test, estimator.n_outputs_)) - for idx in range(self.n_estimators): - tree: DecisionTreeClassifier = estimator.estimators_[idx] - train_tree( - tree, X[self.indices_train_, :], y[self.indices_train_, :], covariate_index - ) + if metric in POSTERIOR_FUNCTIONS: + predict_posteriors = True + else: + predict_posteriors = False - y_pred = tree.predict(X[self.indices_test_, :]).reshape(-1, tree.n_outputs_) + if hasattr(self, "test_size_"): + test_size = self.test_size_ + else: + test_size = 0.2 # type: ignore - # Fill test set posteriors & set rest NaN - posterior_arr[idx, ...] = y_pred # posterior + if not _is_fitted(estimator): + unique_y = np.unique(y) + X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) + estimator.fit(X_dummy, unique_y) + if estimator.n_outputs_ > 1 and metric == "auc": + raise ValueError("AUC metric is not supported for multi-output classification") - y_true_final = y[self.indices_test_, :] - # Average all posteriors - posterior_final = np.nanmean(posterior_arr, axis=0) - samples = np.argwhere(~np.isnan(posterior_final).any(axis=1)).squeeze() - elif self.permute_per_tree and self.sample_dataset_per_tree: + if self.permute_per_tree: # first run a dummy fit on the samples to initialize the # internal data structure of the forest - if not _is_fitted(estimator): - unique_y = np.unique(y) - X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) - estimator.fit(X_dummy, unique_y) - - # now initialize posterior array as (n_trees, n_samples, n_outputs) - posterior_arr = np.full((self.n_estimators, n_samples, estimator.n_outputs_), np.nan) - # Fit each tree and compute posteriors with train test splits - for idx in range(self.n_estimators): - # sample train/test dataset for each tree - indices_train, indices_test = train_test_split( - np.arange(n_samples, dtype=int), - test_size=self.test_size_, - shuffle=True, - random_state=rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32), - ) - tree = estimator.estimators_[idx] - train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) - - y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) - - posterior_arr[idx, indices_test, :] = y_pred # posterior - - # Average all posteriors - posterior_final = np.nanmean(posterior_arr, axis=0) - - # Find the row indices with NaN values in any column - nonnan_indices = np.where(~np.isnan(posterior_final).any(axis=1))[0] - - # Ignore all NaN values (samples not tested) - y_true_final = y[nonnan_indices, :] - posterior_final = posterior_final[nonnan_indices, :] - samples = nonnan_indices + if self.sample_dataset_per_tree: + # Fit each tree and compute posteriors with train test splits + n_samples_test = len(self.indices_test_) + else: + n_samples_test = n_samples + + if predict_posteriors: + posterior_arr = np.zeros((self.n_estimators, n_samples_test, estimator.n_classes_)) + else: + # now initialize posterior array as (n_trees, n_samples_test, n_outputs) + posterior_arr = np.zeros((self.n_estimators, n_samples_test, estimator.n_outputs_)) + + if self.sample_dataset_per_tree: + for idx in range(self.n_estimators): + tree: DecisionTreeClassifier = estimator.estimators_[idx] + train_tree( + tree, X[self.indices_train_, :], y[self.indices_train_, :], covariate_index + ) + + if predict_posteriors: + # XXX: currently assumes n_outputs_ == 1 + y_pred = tree.predict_proba(X[self.indices_test_, :]) + else: + y_pred = tree.predict(X[self.indices_test_, :]).reshape(-1, tree.n_outputs_) + + # Fill test set posteriors & set rest NaN + posterior_arr[idx, ...] = y_pred # posterior + + y_true_final = y[self.indices_test_, :] + # Average all posteriors + posterior_final = np.nanmean(posterior_arr, axis=0) + samples = np.argwhere(~np.isnan(posterior_final).any(axis=1)).squeeze() + else: + # Fit each tree and compute posteriors with train test splits + for idx in range(self.n_estimators): + # sample train/test dataset for each tree + indices_train, indices_test = train_test_split( + np.arange(n_samples, dtype=int), + test_size=test_size, + shuffle=True, + random_state=rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32), + ) + tree = estimator.estimators_[idx] + train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) + + if predict_posteriors: + # XXX: currently assumes n_outputs_ == 1 + y_pred = tree.predict_proba(X[indices_test, :]) + else: + y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) + + posterior_arr[idx, indices_test, :] = y_pred # posterior + + # Average all posteriors (n_samples, n_outputs) + posterior_final = np.nanmean(posterior_arr, axis=0) + + # Find the row indices with NaN values in any column + nonnan_indices = np.where(~np.isnan(posterior_final).any(axis=1))[0] + + # Ignore all NaN values (samples not tested) + y_true_final = y[nonnan_indices, :] + posterior_final = posterior_final[nonnan_indices, :] + samples = nonnan_indices else: X_train, X_test = X[self.indices_train_, :], X[self.indices_test_, :] y_train, y_test = y[self.indices_train_, :], y[self.indices_test_, :] @@ -1006,13 +1057,28 @@ def _statistic( X_train[:, covariate_index] = X_train[index_arr, covariate_index] estimator.fit(X_train, y_train) - y_pred = estimator.predict(X_test) + + if predict_posteriors: + # XXX: currently assumes n_outputs_ == 1 + y_pred = estimator.predict_proba(X_test) + else: + y_pred = estimator.predict(X_test) # set variables to compute metric samples = self.indices_test_ y_true_final = y_test posterior_final = y_pred + if metric == "auc": + # at this point, posterior_final is the predicted posterior for only the positive class + # as more than one output is not supported. + if type_of_target(y_true_final) == "binary": + posterior_final = posterior_final[:, 1] + else: + raise RuntimeError( + f"AUC metric is not supported for {type_of_target(y_true_final)} targets." + ) + stat = metric_func(y_true_final, posterior_final, **metric_kwargs) if covariate_index is None: # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) diff --git a/sktree/stats/meson.build b/sktree/stats/meson.build index 0b45a0ada..fd81fea36 100644 --- a/sktree/stats/meson.build +++ b/sktree/stats/meson.build @@ -1,6 +1,5 @@ python_sources = [ '__init__.py', - '_might.py', 'forestht.py', 'utils.py', 'permutationforest.py', diff --git a/sktree/stats/permutationforest.py b/sktree/stats/permutationforest.py index 55b79833b..3808cf503 100644 --- a/sktree/stats/permutationforest.py +++ b/sktree/stats/permutationforest.py @@ -291,6 +291,12 @@ class PermutationForestRegressor(BasePermutationForest): is compared to the original random forest that was computed on the regular non-permuted data. + .. warning:: Permutation testing with forests is computationally expensive. + As a result, if you are testing for the importance of feature sets, consider + using :class:`sktree.stats.FeatureImportanceForestRegressor` or + :class:`sktree.stats.FeatureImportanceForestClassifier` instead, which is + much more computationally efficient. + .. note:: This does not allow testing on the posteriors. Parameters @@ -571,6 +577,12 @@ class PermutationForestClassifier(BasePermutationForest): is compared to the original random forest that was computed on the regular non-permuted data. + .. warning:: Permutation testing with forests is computationally expensive. + As a result, if you are testing for the importance of feature sets, consider + using :class:`sktree.stats.FeatureImportanceForestRegressor` or + :class:`sktree.stats.FeatureImportanceForestClassifier` instead, which is + much more computationally efficient. + .. note:: This does not allow testing on the posteriors. Parameters diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index d02f09fa8..1c161cbf2 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -1,8 +1,10 @@ import numpy as np import pytest +from flaky import flaky from scipy.special import expit from sklearn import datasets +from sktree import HonestForestClassifier from sktree._lib.sklearn.tree import DecisionTreeClassifier from sktree.stats import ( FeatureImportanceForestClassifier, @@ -12,10 +14,11 @@ ) from sktree.tree import ObliqueDecisionTreeClassifier -# load the iris dataset +# load the iris dataset (n_samples, 4) # and randomly permute it iris = datasets.load_iris() -rng = np.random.RandomState(1) +seed = 12345 +rng = np.random.default_rng(seed) # remove third class iris_X = iris.data[iris.target != 2] @@ -26,17 +29,7 @@ iris_y = iris_y[p] -seed = 12345 - - -def test_forestht_proper_attributes(): - """Forest HTs should have n_classes_ and n_outputs_ properly set. - - This requires the first dummy fit to always get all classes. - """ - pass - - +@flaky(max_runs=3) @pytest.mark.slowtest @pytest.mark.parametrize( "hypotester, model_kwargs, n_samples, n_repeats, test_size", @@ -44,26 +37,27 @@ def test_forestht_proper_attributes(): [ PermutationForestRegressor, { - "max_features": 1.0, + "max_features": "sqrt", "random_state": seed, - "n_estimators": 50, + "n_estimators": 75, "n_jobs": -1, }, - 550, + 300, 50, 0.1, ], [ FeatureImportanceForestRegressor, { - "max_features": 1.0, + "max_features": "sqrt", "random_state": seed, "n_estimators": 125, "permute_per_tree": True, + "sample_dataset_per_tree": True, "n_jobs": -1, }, - 600, - 200, + 300, + 500, 0.1, ], ], @@ -75,12 +69,10 @@ def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size) Y = Beta * X_1 + Beta * I(X_6 = 2) + \epsilon """ - beta = 10.0 - sigma = 0.5 + beta = 15.0 + sigma = 0.05 metric = "mse" - rng = np.random.default_rng(seed) - # sample covariates X_15 = rng.uniform(0, 1, size=(n_samples, 5)) X_610 = np.zeros((n_samples, 5)) @@ -118,6 +110,7 @@ def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size) assert pvalue > 0.05, f"pvalue: {pvalue}" +@flaky(max_runs=3) @pytest.mark.slowtest @pytest.mark.parametrize( "hypotester, model_kwargs, n_samples, n_repeats, test_size", @@ -127,10 +120,10 @@ def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size) { "max_features": "sqrt", "random_state": seed, - "n_estimators": 75, + "n_estimators": 50, "n_jobs": -1, }, - 500, + 600, 50, 1.0 / 6, ], @@ -144,8 +137,8 @@ def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size) "sample_dataset_per_tree": True, "n_jobs": -1, }, - 500, - 100, + 600, + 200, 1.0 / 6, ], ], @@ -157,13 +150,11 @@ def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, P(Y = 1 | X) = expit(beta * \\sum_{j=2}^5 X_j) """ - beta = 5.0 + beta = 10.0 metric = "mse" - n = 200 # Number of time steps - ar_coefficient = 0.0015 - - rng = np.random.default_rng(seed) + n = 100 # Number of time steps + ar_coefficient = 0.015 X = np.zeros((n_samples, n)) for idx in range(n_samples): @@ -210,7 +201,6 @@ def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, @pytest.mark.parametrize("criterion", ["gini", "entropy"]) -@pytest.mark.parametrize("max_features", [None, "sqrt"]) @pytest.mark.parametrize("honest_prior", ["empirical", "uniform", "ignore"]) @pytest.mark.parametrize( "estimator", @@ -221,30 +211,47 @@ def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, ], ) @pytest.mark.parametrize("limit", [0.05, 0.1]) -def test_iris_pauc(criterion, max_features, honest_prior, estimator, limit): +def test_iris_pauc_statistic(criterion, honest_prior, estimator, limit): + max_features = "sqrt" + n_repeats = 200 + n_estimators = 50 + # Check consistency on dataset iris. clf = FeatureImportanceForestClassifier( criterion=criterion, random_state=0, max_features=max_features, - n_estimators=100, - honest_prior=honest_prior, - tree_estimator=estimator, + n_estimators=n_estimators, + estimator=HonestForestClassifier( + n_estimators=n_estimators, tree_estimator=estimator, honest_prior=honest_prior + ), + n_jobs=-1, + sample_dataset_per_tree=True, + permute_per_tree=True, ) - score = clf.statistic(iris_X, iris_y, metric="auc", max_fpr=limit) - assert score >= 0.9, "Failed with pAUC: {0} for max fpr: {1}".format(score, limit) - # now add completely uninformative feature - X = np.hstack((iris_X, rng.standard_normal(size=(iris_X.shape[0], 1)))) + X = np.hstack((iris_X, rng.standard_normal(size=(iris_X.shape[0], 4)))) - # test for unimportant feature - test_size = 0.2 + # test for unimportant feature set + test_size = 0.1 clf.reset() - stat, pvalue = clf.test(X, iris_y, [X.shape[1] - 1], test_size=test_size, metric="auc") + stat, pvalue = clf.test( + X, + iris_y, + np.arange(iris_X.shape[0], X.shape[1], dtype=int).tolist(), + n_repeats=n_repeats, + test_size=test_size, + metric="auc", + ) print(pvalue) - # assert pvalue > 0.05, f"pvalue: {pvalue}" + assert pvalue > 0.05, f"pvalue: {pvalue}" - stat, pvalue = clf.test(X, iris_y, [2, 3], test_size=test_size, metric="auc") + # test for important features that are permuted + stat, pvalue = clf.test( + X, iris_y, [0, 1, 2, 3], n_repeats=n_repeats, test_size=test_size, metric="auc" + ) print(pvalue) - # assert pvalue < 0.05, f"pvalue: {pvalue}" - assert False + assert pvalue < 0.05, f"pvalue: {pvalue}" + + score = clf.statistic(iris_X, iris_y, metric="auc", max_fpr=limit) + assert score >= 0.8, "Failed with pAUC: {0} for max fpr: {1}".format(score, limit) diff --git a/sktree/stats/tests/test_might.py b/sktree/stats/tests/test_might.py deleted file mode 100644 index ff613c571..000000000 --- a/sktree/stats/tests/test_might.py +++ /dev/null @@ -1,51 +0,0 @@ -import numpy as np -import pytest -from sklearn import datasets - -from sktree._lib.sklearn.tree import DecisionTreeClassifier -from sktree.stats import MIGHT -from sktree.tree import ObliqueDecisionTreeClassifier - -# load the iris dataset -# and randomly permute it -iris = datasets.load_iris() -rng = np.random.RandomState(1) - -# remove third class -iris_X = iris.data[iris.target != 2] -iris_y = iris.target[iris.target != 2] - -p = rng.permutation(iris_X.shape[0]) -iris_X = iris_X[p] -iris_y = iris_y[p] - - -@pytest.mark.parametrize("criterion", ["gini", "entropy"]) -@pytest.mark.parametrize("max_features", [None, 2]) -@pytest.mark.parametrize("honest_prior", ["empirical", "uniform", "ignore", "error"]) -@pytest.mark.parametrize( - "estimator", - [ - None, - DecisionTreeClassifier(), - ObliqueDecisionTreeClassifier(), - ], -) -@pytest.mark.parametrize("limit", [0.05, 0.1]) -def test_iris(criterion, max_features, honest_prior, estimator, limit): - # Check consistency on dataset iris. - clf = MIGHT( - criterion=criterion, - random_state=0, - max_features=max_features, - n_estimators=10, - honest_prior=honest_prior, - tree_estimator=estimator, - limit=limit, - ) - if honest_prior == "error": - with pytest.raises(ValueError, match="honest_prior error not a valid input."): - clf.statistic(iris_X, iris_y) - else: - score = clf.statistic(iris_X, iris_y, stat="AUC") - assert score >= 0.9, "Failed with pAUC: {0} for max fpr: {1}".format(score, limit) diff --git a/sktree/stats/utils.py b/sktree/stats/utils.py index cf725f2a2..9b1c3debe 100644 --- a/sktree/stats/utils.py +++ b/sktree/stats/utils.py @@ -25,10 +25,15 @@ def _mutual_information(y_true, y_pred_proba): METRIC_FUNCTIONS = { "mse": mean_squared_error, "mae": mean_absolute_error, + "balanced_accuracy": balanced_accuracy_score, "auc": roc_auc_score, "mi": _mutual_information, - "balanced_accuracy": balanced_accuracy_score, } + +POSTERIOR_FUNCTIONS = ("mi", "auc") + +POSITIVE_METRICS = ("mi", "auc", "balanced_accuracy") + REGRESSOR_METRICS = ("mse", "mae") @@ -172,8 +177,6 @@ def _compute_null_distribution_coleman( An array of the metrics computed on the other half of the trees. """ rng = np.random.default_rng(seed) - # X_test, y_test = check_X_y(X_test, y_test, copy=True, ensure_2d=True, multi_output=True) - metric_func = METRIC_FUNCTIONS[metric] # sample two sets of equal number of trees from the combined forest these are the posteriors @@ -181,8 +184,12 @@ def _compute_null_distribution_coleman( n_samples_test = len(y_test) if len(all_y_pred) != 2 * n_samples_test: + print("y_pred_proba_perm: ", y_pred_proba_perm.shape) + print("y_pred_proba: ", y_pred_proba_normal.shape) + raise RuntimeError( - "The number of samples in `all_y_pred` is not equal to 2 * n_samples_test" + f"The number of samples in `all_y_pred` {len(all_y_pred)} " + f"is not equal to 2 * n_samples_test {2 * n_samples_test}" ) # create two stacked index arrays of y_test resulting in [1, ..., N, 1, ..., N] @@ -193,15 +200,6 @@ def _compute_null_distribution_coleman( # create index array of [1, ..., 2N] to slice into `all_y_pred` y_pred_ind_arr = np.arange((2 * n_samples_test), dtype=int) - # # get the indices of the samples that we have a posterior for, so each element - # # is an index into `y_test` - # all_samples_pred = np.concatenate((normal_samples, perm_samples), axis=0) - - # n_samples_final = len(all_samples_pred) - - # pre-allocate memory for the index array - # index_arr = np.arange(n_samples_final, dtype=int) - metric_star = np.zeros((n_repeats,)) metric_star_pi = np.zeros((n_repeats,)) for idx in range(n_repeats): diff --git a/test_requirements.txt b/test_requirements.txt index 0b025c336..abb85b9e2 100644 --- a/test_requirements.txt +++ b/test_requirements.txt @@ -2,4 +2,5 @@ pytest pytest-cov memory_profiler joblib -tqdm \ No newline at end of file +tqdm +flaky \ No newline at end of file From e9d07d869c696dd7a8a9e3153f8cba2d26526b7e Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 19 Sep 2023 10:57:07 -0400 Subject: [PATCH 21/70] Fix mesonb uild Signed-off-by: Adam Li --- sktree/stats/tests/meson.build | 1 - 1 file changed, 1 deletion(-) diff --git a/sktree/stats/tests/meson.build b/sktree/stats/tests/meson.build index 22cc87bcb..2f18f5a65 100644 --- a/sktree/stats/tests/meson.build +++ b/sktree/stats/tests/meson.build @@ -1,6 +1,5 @@ python_sources = [ '__init__.py', - 'test_might.py', 'test_forestht.py' ] From 1dcd4f6736b5267b17809d02a96564d795978f9b Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 19 Sep 2023 11:17:30 -0400 Subject: [PATCH 22/70] Fix unit-test Signed-off-by: Adam Li --- .../test_permutation_forest.ipynb | 214 +++--------------- sktree/stats/tests/test_forestht.py | 2 +- 2 files changed, 32 insertions(+), 184 deletions(-) diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/test_permutation_forest.ipynb index 0fb5add90..9f3e15e28 100644 --- a/benchmarks_nonasv/test_permutation_forest.ipynb +++ b/benchmarks_nonasv/test_permutation_forest.ipynb @@ -2,30 +2,10 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "b658bdd8-a3e6-4051-9d66-f2a153113234", "metadata": {}, - "outputs": [ - { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: '/Users/adam2392/Documents/scikit-tree/sktree/stats/_might.py'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[1], line 9\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mseaborn\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01msns\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mscipy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mspecial\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m expit\n\u001b[0;32m----> 9\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msktree\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mstats\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m (\n\u001b[1;32m 10\u001b[0m FeatureImportanceForestClassifier,\n\u001b[1;32m 11\u001b[0m FeatureImportanceForestRegressor,\n\u001b[1;32m 12\u001b[0m PermutationForestRegressor,\n\u001b[1;32m 13\u001b[0m )\n\u001b[1;32m 15\u001b[0m seed \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m12345\u001b[39m\n", - "File \u001b[0;32m~/Documents/scikit-tree/sktree/__init__.py:39\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[38;5;66;03m# We are not importing the rest of scikit-tree during the build\u001b[39;00m\n\u001b[1;32m 36\u001b[0m \u001b[38;5;66;03m# process, as it may not be compiled yet\u001b[39;00m\n\u001b[1;32m 37\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 38\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 39\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m _lib, tree, ensemble, experimental, stats\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01m_lib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01msklearn\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mensemble\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01m_forest\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m (\n\u001b[1;32m 41\u001b[0m RandomForestClassifier,\n\u001b[1;32m 42\u001b[0m RandomForestRegressor,\n\u001b[1;32m 43\u001b[0m ExtraTreesClassifier,\n\u001b[1;32m 44\u001b[0m ExtraTreesRegressor,\n\u001b[1;32m 45\u001b[0m )\n\u001b[1;32m 46\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mneighbors\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m NearestNeighborsMetaEstimator\n", - "File \u001b[0;32m~/Documents/scikit-tree/sktree/stats/__init__.py:1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01m_might\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m MIGHT, MIGHT_MV\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mforestht\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m FeatureImportanceForestClassifier, FeatureImportanceForestRegressor\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpermutationforest\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m PermutationForestClassifier, PermutationForestRegressor\n", - "File \u001b[0;32m:1007\u001b[0m, in \u001b[0;36m_find_and_load\u001b[0;34m(name, import_)\u001b[0m\n", - "File \u001b[0;32m:986\u001b[0m, in \u001b[0;36m_find_and_load_unlocked\u001b[0;34m(name, import_)\u001b[0m\n", - "File \u001b[0;32m:680\u001b[0m, in \u001b[0;36m_load_unlocked\u001b[0;34m(spec)\u001b[0m\n", - "File \u001b[0;32m:846\u001b[0m, in \u001b[0;36mexec_module\u001b[0;34m(self, module)\u001b[0m\n", - "File \u001b[0;32m:982\u001b[0m, in \u001b[0;36mget_code\u001b[0;34m(self, fullname)\u001b[0m\n", - "File \u001b[0;32m:1039\u001b[0m, in \u001b[0;36mget_data\u001b[0;34m(self, path)\u001b[0m\n", - "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/Users/adam2392/Documents/scikit-tree/sktree/stats/_might.py'" - ] - } - ], + "outputs": [], "source": [ "from collections import defaultdict\n", "\n", @@ -46,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "05b0b53e-0525-45ce-9f7e-0322a30221cf", "metadata": {}, "outputs": [], @@ -57,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "5e2d1279-fa4f-47ef-aa48-fac6d47159ad", "metadata": {}, "outputs": [], @@ -159,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "3db4f740-afd9-413e-8089-a8245f2a0747", "metadata": {}, "outputs": [], @@ -222,7 +202,12 @@ "\n", " # test for X_2 important\n", " stat, pvalue = est.test(\n", - " X.copy(), y.copy(), covariate_index=[1], test_size=test_size, n_repeats=n_repeats, metric=metric\n", + " X.copy(),\n", + " y.copy(),\n", + " covariate_index=[1],\n", + " test_size=test_size,\n", + " n_repeats=n_repeats,\n", + " metric=metric,\n", " )\n", " pvalue_dict[\"X2\"] = pvalue\n", " print(\"X2: \", pvalue)\n", @@ -261,7 +246,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 7, "id": "14806903-933b-4e31-a2db-a3a45e0a6f82", "metadata": { "scrolled": true @@ -464,7 +449,7 @@ " for idx in range(5):\n", " new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32)\n", "\n", - " elements_dict = correlated_logit_model(beta, new_seed)\n", + " elements_dict = linear_model_ancova(sigma_factor, new_seed)\n", " for key, value in elements_dict.items():\n", " pvalue_dict[key].append(value)\n", " pvalue_dict[\"sigma_factor\"].append(sigma_factor)\n", @@ -474,13 +459,13 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 9, "id": "9e60fac2-3b20-493e-886a-892d572a28c6", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -500,7 +485,7 @@ " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", " ax.legend()\n", "fig.suptitle(\n", - " \"Linear ANCOVA model with Coleman Forest (Permutation per tree and sample dataset per tree)\"\n", + " \"Linear ANCOVA model with FeatureImportanceRegressor (Permutation per tree and sample dataset per tree)\"\n", ")\n", "fig.tight_layout()" ] @@ -610,7 +595,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "id": "a2aed8f0-1230-4128-ad77-d84764c28d0d", "metadata": { "scrolled": true @@ -621,138 +606,18 @@ "output_type": "stream", "text": [ "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", "X1: 1.0\n", "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", + "X2: 1.0\n", "X1: 0.004975124378109453\n", "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", + "X2: 1.0\n", "X1: 1.0\n", "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", + "X2: 1.0\n", "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", + "X2: 1.0\n", "X1: 0.004975124378109453\n", "X500: 0.004975124378109453\n" ] @@ -763,32 +628,24 @@ "rng = np.random.default_rng(seed)\n", "\n", "beta_space = np.hstack((np.linspace(0.01, 2.5, 8), np.linspace(5, 20, 7)))\n", - "for sigma_factor in j_space:\n", + "for beta in beta_space:\n", " for idx in range(5):\n", " new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32)\n", "\n", - " elements_dict = correlated_logit_model(sigma_factor, new_seed)\n", + " elements_dict = correlated_logit_model(beta, new_seed)\n", " for key, value in elements_dict.items():\n", " pvalue_dict[key].append(value)\n", - " pvalue_dict[\"sigma_factor\"].append(sigma_factor)\n", + " pvalue_dict[\"sigma_factor\"].append(beta)\n", "\n", "df = pd.DataFrame(pvalue_dict)" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "d3e21945-92b3-4ccc-8f29-b44f67d9cf33", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "done\n" - ] - } - ], + "outputs": [], "source": [ "print(\"done\")" ] @@ -885,21 +742,10 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "id": "c4dbdaf1-9af7-4e6d-83b6-a9cabc18dc91", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axs = plt.subplots(3, 1, figsize=(8, 6), sharey=True, sharex=True)\n", "axs = axs.flatten()\n", @@ -910,7 +756,9 @@ " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (beta)\")\n", " ax.legend()\n", - "fig.suptitle(\"Correlated Logit model with Coleman Forest (permute per tree)\")\n", + "fig.suptitle(\n", + " \"Correlated Logit model with FeatureImportanceForestClassifier (permute per tree and sample dataset)\"\n", + ")\n", "fig.tight_layout()" ] }, diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 1c161cbf2..2e4f3d375 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -214,7 +214,7 @@ def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, def test_iris_pauc_statistic(criterion, honest_prior, estimator, limit): max_features = "sqrt" n_repeats = 200 - n_estimators = 50 + n_estimators = 100 # Check consistency on dataset iris. clf = FeatureImportanceForestClassifier( From 37b1648526e115fbacd270522283f85ced8ef45a Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 19 Sep 2023 11:41:49 -0400 Subject: [PATCH 23/70] Fix docs errors Signed-off-by: Adam Li --- .../test_permutation_forest.ipynb | 68 ++++++++- doc/api.rst | 4 +- doc/conf.py | 7 + sktree/stats/__init__.py | 7 + sktree/stats/forestht.py | 84 ++-------- sktree/stats/permutationforest.py | 144 +++--------------- 6 files changed, 113 insertions(+), 201 deletions(-) diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/test_permutation_forest.ipynb index 9f3e15e28..7c812d6d8 100644 --- a/benchmarks_nonasv/test_permutation_forest.ipynb +++ b/benchmarks_nonasv/test_permutation_forest.ipynb @@ -619,7 +619,73 @@ "X500: 1.0\n", "X2: 1.0\n", "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n" + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n" ] } ], diff --git a/doc/api.rst b/doc/api.rst index cb722bdf0..ecaa78ecb 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -136,8 +136,8 @@ tree models. FeatureImportanceForestRegressor FeatureImportanceForestClassifier - PermutationImportanceForestRegressor - PermutationImportanceForestClassifier + PermutationForestClassifier + PermutationForestRegressor Experimental Functionality diff --git a/doc/conf.py b/doc/conf.py index 689ee5c94..48bc28c6e 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -87,6 +87,7 @@ # TODO: figure out why these are raising an error? nitpick_ignore = [ ("py:mod", "sktree.tree"), + ("py:mod", "sktree.stats"), ] # The name of a reST role (builtin or Sphinx extension) to use as the default @@ -204,6 +205,7 @@ "matrix", "Ignored", "UnsupervisedSplitter", + "n_repeats", # from sklearn "such", "arrays", @@ -230,6 +232,11 @@ "joblib.parallel_backend", "length", "instances", + "decision_path", + "n_samples_final", + "predict", + "fit", + "apply", } # validation diff --git a/sktree/stats/__init__.py b/sktree/stats/__init__.py index b01038036..1e1538c46 100644 --- a/sktree/stats/__init__.py +++ b/sktree/stats/__init__.py @@ -1,2 +1,9 @@ from .forestht import FeatureImportanceForestClassifier, FeatureImportanceForestRegressor from .permutationforest import PermutationForestClassifier, PermutationForestRegressor + +__all__ = [ + "FeatureImportanceForestClassifier", + "FeatureImportanceForestRegressor", + "PermutationForestClassifier", + "PermutationForestRegressor", +] diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 8c329dbae..410a53974 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -100,11 +100,13 @@ def statistic( covariate_index : ArrayLike, optional of shape (n_covariates,) The index array of covariates to shuffle, by default None. metric : str, optional - The metric to compute, by default "auc". - test_size : float, optional - Proportion of samples per tree to use for the test set, by default 0.2. + The metric to compute, by default "mse". return_posteriors : bool, optional Whether or not to return the posteriors, by default False. + check_input : bool, optional + Whether or not to check the input, by default True. + **metric_kwargs : dict, optional + Additional keyword arguments to pass to the metric function. Returns ------- @@ -184,6 +186,8 @@ def test( Number of times to sample the null distribution, by default 1000. return_posteriors : bool, optional Whether or not to return the posteriors, by default False. + **metric_kwargs : dict, optional + Additional keyword arguments to pass to the metric function. Returns ------- @@ -307,11 +311,6 @@ class FeatureImportanceForestRegressor(BaseForestHT): "gini" for the Gini impurity and "entropy" for the information gain. Note: this parameter is tree-specific. - splitter : {"best", "random"}, default="best" - The strategy used to choose the split at each node. Supported - strategies are "best" to choose the best split and "random" to choose - the best random split. - max_depth : int, default=None The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than @@ -388,11 +387,7 @@ class FeatureImportanceForestRegressor(BaseForestHT): Only available if bootstrap=True. n_jobs : int, default=None - The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`, - :meth:`decision_path` and :meth:`apply` are all parallelized over the - trees. ``None`` means 1 unless in a `joblib.parallel_backend` - context. ``-1`` means using all processors. See :term:`Glossary - ` for more details. + The number of jobs to run in parallel. random_state : int, RandomState instance or None, default=None Controls both the randomness of the bootstrapping of the samples used @@ -409,32 +404,6 @@ class FeatureImportanceForestRegressor(BaseForestHT): and add more estimators to the ensemble, otherwise, just fit a whole new forest. See :term:`the Glossary `. - class_weight : {"balanced", "balanced_subsample"}, dict or list of dicts, \ - default=None - Weights associated with classes in the form ``{class_label: weight}``. - If not given, all classes are supposed to have weight one. For - multi-output problems, a list of dicts can be provided in the same - order as the columns of y. - - Note that for multioutput (including multilabel) weights should be - defined for each class of every column in its own dict. For example, - for four-class multilabel classification weights should be - [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of - [{1:1}, {2:5}, {3:1}, {4:1}]. - - The "balanced" mode uses the values of y to automatically adjust - weights inversely proportional to class frequencies in the input data - as ``n_samples / (n_classes * np.bincount(y))`` - - The "balanced_subsample" mode is the same as "balanced" except that - weights are computed based on the bootstrap sample for every tree - grown. - - For multi-output, the weights of each column of y will be multiplied. - - Note that these weights will be multiplied with sample_weight (passed - through the fit method) if sample_weight is specified. - ccp_alpha : non-negative float, default=0.0 Complexity parameter used for Minimal Cost-Complexity Pruning. The subtree with the largest cost complexity that is smaller than @@ -698,11 +667,6 @@ class FeatureImportanceForestClassifier(BaseForestHT): "gini" for the Gini impurity and "entropy" for the information gain. Note: this parameter is tree-specific. - splitter : {"best", "random"}, default="best" - The strategy used to choose the split at each node. Supported - strategies are "best" to choose the best split and "random" to choose - the best random split. - max_depth : int, default=None The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than @@ -779,11 +743,7 @@ class FeatureImportanceForestClassifier(BaseForestHT): Only available if bootstrap=True. n_jobs : int, default=None - The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`, - :meth:`decision_path` and :meth:`apply` are all parallelized over the - trees. ``None`` means 1 unless in a `joblib.parallel_backend` - context. ``-1`` means using all processors. See :term:`Glossary - ` for more details. + The number of jobs to run in parallel. random_state : int, RandomState instance or None, default=None Controls both the randomness of the bootstrapping of the samples used @@ -800,32 +760,6 @@ class FeatureImportanceForestClassifier(BaseForestHT): and add more estimators to the ensemble, otherwise, just fit a whole new forest. See :term:`the Glossary `. - class_weight : {"balanced", "balanced_subsample"}, dict or list of dicts, \ - default=None - Weights associated with classes in the form ``{class_label: weight}``. - If not given, all classes are supposed to have weight one. For - multi-output problems, a list of dicts can be provided in the same - order as the columns of y. - - Note that for multioutput (including multilabel) weights should be - defined for each class of every column in its own dict. For example, - for four-class multilabel classification weights should be - [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of - [{1:1}, {2:5}, {3:1}, {4:1}]. - - The "balanced" mode uses the values of y to automatically adjust - weights inversely proportional to class frequencies in the input data - as ``n_samples / (n_classes * np.bincount(y))`` - - The "balanced_subsample" mode is the same as "balanced" except that - weights are computed based on the bootstrap sample for every tree - grown. - - For multi-output, the weights of each column of y will be multiplied. - - Note that these weights will be multiplied with sample_weight (passed - through the fit method) if sample_weight is specified. - ccp_alpha : non-negative float, default=0.0 Complexity parameter used for Minimal Cost-Complexity Pruning. The subtree with the largest cost complexity that is smaller than diff --git a/sktree/stats/permutationforest.py b/sktree/stats/permutationforest.py index 3808cf503..2040f7003 100644 --- a/sktree/stats/permutationforest.py +++ b/sktree/stats/permutationforest.py @@ -31,7 +31,6 @@ def __init__( warm_start=False, ccp_alpha=0.0, max_samples=None, - **estimators_kwargs, ): self.estimator = estimator self.n_jobs = n_jobs @@ -51,7 +50,6 @@ def __init__( self.warm_start = warm_start self.ccp_alpha = ccp_alpha self.max_samples = max_samples - self.estimator_kwargs = estimators_kwargs def reset(self): class_attributes = dir(type(self)) @@ -141,10 +139,14 @@ def statistic( The index array of covariates to shuffle, by default None. metric : str, optional The metric to compute, by default "mse". - test_size : float, optional - Proportion of samples per tree to use for the test set, by default 0.2. return_posteriors : bool, optional Whether or not to return the posteriors, by default False. + check_input : bool, optional + Whether or not to check the input, by default True. + seed : int, optional + The random seed to use, by default None. + **metric_kwargs : dict, optional + Keyword arguments to pass to the metric function. Returns ------- @@ -221,13 +223,17 @@ def test( by default 0.2. n_repeats : int, optional Number of times to sample the null distribution, by default 1000. + return_posteriors : bool, optional + Whether or not to return the posteriors, by default False. + **metric_kwargs : dict, optional + Keyword arguments to pass to the metric function. Returns ------- observe_stat : float Observed test statistic. pvalue : float - p-value of the test. + Pvalue of the test. """ X, y = check_X_y(X, y, ensure_2d=True, copy=True, multi_output=True) if y.ndim != 2: @@ -292,10 +298,10 @@ class PermutationForestRegressor(BasePermutationForest): non-permuted data. .. warning:: Permutation testing with forests is computationally expensive. - As a result, if you are testing for the importance of feature sets, consider - using :class:`sktree.stats.FeatureImportanceForestRegressor` or - :class:`sktree.stats.FeatureImportanceForestClassifier` instead, which is - much more computationally efficient. + As a result, if you are testing for the importance of feature sets, consider + using `sktree.FeatureImportanceForestRegressor` or + `sktree.FeatureImportanceForestClassifier` instead, which is + much more computationally efficient. .. note:: This does not allow testing on the posteriors. @@ -319,11 +325,6 @@ class PermutationForestRegressor(BasePermutationForest): the L1 loss using the median of each terminal node, and "poisson" which uses reduction in Poisson deviance to find splits. - splitter : {"best", "random"}, default="best" - The strategy used to choose the split at each node. Supported - strategies are "best" to choose the best split and "random" to choose - the best random split. - max_depth : int, default=None The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than @@ -400,11 +401,7 @@ class PermutationForestRegressor(BasePermutationForest): Only available if bootstrap=True. n_jobs : int, default=None - The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`, - :meth:`decision_path` and :meth:`apply` are all parallelized over the - trees. ``None`` means 1 unless in a `joblib.parallel_backend` - context. ``-1`` means using all processors. See :term:`Glossary - ` for more details. + The number of jobs to run in parallel. random_state : int, RandomState instance or None, default=None Controls both the randomness of the bootstrapping of the samples used @@ -421,32 +418,6 @@ class PermutationForestRegressor(BasePermutationForest): and add more estimators to the ensemble, otherwise, just fit a whole new forest. See :term:`the Glossary `. - class_weight : {"balanced", "balanced_subsample"}, dict or list of dicts, \ - default=None - Weights associated with classes in the form ``{class_label: weight}``. - If not given, all classes are supposed to have weight one. For - multi-output problems, a list of dicts can be provided in the same - order as the columns of y. - - Note that for multioutput (including multilabel) weights should be - defined for each class of every column in its own dict. For example, - for four-class multilabel classification weights should be - [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of - [{1:1}, {2:5}, {3:1}, {4:1}]. - - The "balanced" mode uses the values of y to automatically adjust - weights inversely proportional to class frequencies in the input data - as ``n_samples / (n_classes * np.bincount(y))`` - - The "balanced_subsample" mode is the same as "balanced" except that - weights are computed based on the bootstrap sample for every tree - grown. - - For multi-output, the weights of each column of y will be multiplied. - - Note that these weights will be multiplied with sample_weight (passed - through the fit method) if sample_weight is specified. - ccp_alpha : non-negative float, default=0.0 Complexity parameter used for Minimal Cost-Complexity Pruning. The subtree with the largest cost complexity that is smaller than @@ -462,22 +433,6 @@ class PermutationForestRegressor(BasePermutationForest): - If float, then draw `max_samples * X.shape[0]` samples. Thus, `max_samples` should be in the interval `(0.0, 1.0]`. - honest_prior : {"ignore", "uniform", "empirical"}, default="empirical" - Method for dealing with empty leaves during evaluation of a test - sample. If "ignore", the tree is ignored. If "uniform", the prior tree - posterior is 1/(number of classes). If "empirical", the prior tree - posterior is the relative class frequency in the voting subsample. - If all trees are ignored, the empirical estimate is returned. - - honest_fraction : float, default=0.5 - Fraction of training samples used for estimates in the trees. The - remaining samples will be used to learn the tree structure. A larger - fraction creates shallower trees with lower variance estimates. - - tree_estimator : object, default=None - Type of decision tree classifier to use. By default `None`, which - defaults to :class:`sklearn.tree.DecisionTreeClassifier`. - Attributes ---------- samples_ : ArrayLike of shape (n_samples,) @@ -517,7 +472,6 @@ def __init__( warm_start=False, ccp_alpha=0.0, max_samples=None, - **estimators_kwargs, ): super().__init__( estimator=estimator, @@ -538,7 +492,6 @@ def __init__( warm_start=warm_start, ccp_alpha=ccp_alpha, max_samples=max_samples, - **estimators_kwargs, ) def _get_estimator(self): @@ -561,7 +514,6 @@ def _get_estimator(self): warm_start=self.warm_start, ccp_alpha=self.ccp_alpha, max_samples=self.max_samples, - **self.estimator_kwargs, ) elif not isinstance(self.estimator_, ForestRegressor): raise RuntimeError(f"Estimator must be a ForestRegressor, got {type(self.estimator_)}") @@ -578,10 +530,10 @@ class PermutationForestClassifier(BasePermutationForest): non-permuted data. .. warning:: Permutation testing with forests is computationally expensive. - As a result, if you are testing for the importance of feature sets, consider - using :class:`sktree.stats.FeatureImportanceForestRegressor` or - :class:`sktree.stats.FeatureImportanceForestClassifier` instead, which is - much more computationally efficient. + As a result, if you are testing for the importance of feature sets, consider + using `sktree.FeatureImportanceForestRegressor` or + `sktree.FeatureImportanceForestClassifier` instead, which is + much more computationally efficient. .. note:: This does not allow testing on the posteriors. @@ -598,11 +550,6 @@ class PermutationForestClassifier(BasePermutationForest): The function to measure the quality of a split. Supported criteria are "gini" for the Gini impurity and "entropy" for the information gain. - splitter : {"best", "random"}, default="best" - The strategy used to choose the split at each node. Supported - strategies are "best" to choose the best split and "random" to choose - the best random split. - max_depth : int, default=None The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than @@ -679,11 +626,7 @@ class PermutationForestClassifier(BasePermutationForest): Only available if bootstrap=True. n_jobs : int, default=None - The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`, - :meth:`decision_path` and :meth:`apply` are all parallelized over the - trees. ``None`` means 1 unless in a `joblib.parallel_backend` - context. ``-1`` means using all processors. See :term:`Glossary - ` for more details. + The number of jobs to run in parallel. random_state : int, RandomState instance or None, default=None Controls both the randomness of the bootstrapping of the samples used @@ -700,32 +643,6 @@ class PermutationForestClassifier(BasePermutationForest): and add more estimators to the ensemble, otherwise, just fit a whole new forest. See :term:`the Glossary `. - class_weight : {"balanced", "balanced_subsample"}, dict or list of dicts, \ - default=None - Weights associated with classes in the form ``{class_label: weight}``. - If not given, all classes are supposed to have weight one. For - multi-output problems, a list of dicts can be provided in the same - order as the columns of y. - - Note that for multioutput (including multilabel) weights should be - defined for each class of every column in its own dict. For example, - for four-class multilabel classification weights should be - [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of - [{1:1}, {2:5}, {3:1}, {4:1}]. - - The "balanced" mode uses the values of y to automatically adjust - weights inversely proportional to class frequencies in the input data - as ``n_samples / (n_classes * np.bincount(y))`` - - The "balanced_subsample" mode is the same as "balanced" except that - weights are computed based on the bootstrap sample for every tree - grown. - - For multi-output, the weights of each column of y will be multiplied. - - Note that these weights will be multiplied with sample_weight (passed - through the fit method) if sample_weight is specified. - ccp_alpha : non-negative float, default=0.0 Complexity parameter used for Minimal Cost-Complexity Pruning. The subtree with the largest cost complexity that is smaller than @@ -741,22 +658,6 @@ class PermutationForestClassifier(BasePermutationForest): - If float, then draw `max_samples * X.shape[0]` samples. Thus, `max_samples` should be in the interval `(0.0, 1.0]`. - honest_prior : {"ignore", "uniform", "empirical"}, default="empirical" - Method for dealing with empty leaves during evaluation of a test - sample. If "ignore", the tree is ignored. If "uniform", the prior tree - posterior is 1/(number of classes). If "empirical", the prior tree - posterior is the relative class frequency in the voting subsample. - If all trees are ignored, the empirical estimate is returned. - - honest_fraction : float, default=0.5 - Fraction of training samples used for estimates in the trees. The - remaining samples will be used to learn the tree structure. A larger - fraction creates shallower trees with lower variance estimates. - - tree_estimator : object, default=None - Type of decision tree classifier to use. By default `None`, which - defaults to :class:`sklearn.tree.DecisionTreeClassifier`. - Attributes ---------- samples_ : ArrayLike of shape (n_samples,) @@ -796,7 +697,6 @@ def __init__( warm_start=False, ccp_alpha=0.0, max_samples=None, - **estimators_kwargs, ): super().__init__( estimator=estimator, @@ -817,7 +717,6 @@ def __init__( warm_start=warm_start, ccp_alpha=ccp_alpha, max_samples=max_samples, - **estimators_kwargs, ) def _get_estimator(self): @@ -840,7 +739,6 @@ def _get_estimator(self): warm_start=self.warm_start, ccp_alpha=self.ccp_alpha, max_samples=self.max_samples, - **self.estimator_kwargs, ) elif not isinstance(self.estimator_, ForestClassifier): raise RuntimeError(f"Estimator must be a ForestClassifier, got {type(self.estimator_)}") From a28a8426f6006486d5915f008f3c0635b4e2c238 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 19 Sep 2023 11:51:22 -0400 Subject: [PATCH 24/70] Fix unit-test Signed-off-by: Adam Li --- .../test_permutation_forest.ipynb | 31 ++++++++++++++++++- sktree/stats/tests/test_forestht.py | 6 +++- 2 files changed, 35 insertions(+), 2 deletions(-) diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/test_permutation_forest.ipynb index 7c812d6d8..8a76cdb35 100644 --- a/benchmarks_nonasv/test_permutation_forest.ipynb +++ b/benchmarks_nonasv/test_permutation_forest.ipynb @@ -685,7 +685,36 @@ "X500: 1.0\n", "X2: 0.004975124378109453\n", "X1: 1.0\n", - "X500: 1.0\n" + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 1.0\n" ] } ], diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 2e4f3d375..2ef6958f9 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -200,6 +200,7 @@ def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, assert pvalue > 0.05, f"pvalue: {pvalue}" +@flaky(max_runs=3) @pytest.mark.parametrize("criterion", ["gini", "entropy"]) @pytest.mark.parametrize("honest_prior", ["empirical", "uniform", "ignore"]) @pytest.mark.parametrize( @@ -223,7 +224,10 @@ def test_iris_pauc_statistic(criterion, honest_prior, estimator, limit): max_features=max_features, n_estimators=n_estimators, estimator=HonestForestClassifier( - n_estimators=n_estimators, tree_estimator=estimator, honest_prior=honest_prior + n_estimators=n_estimators, + tree_estimator=estimator, + honest_prior=honest_prior, + random_state=0, ), n_jobs=-1, sample_dataset_per_tree=True, From b88e12e36de3eccf1749343886b2a3b2df7db260 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 19 Sep 2023 12:46:37 -0400 Subject: [PATCH 25/70] Clean up API Signed-off-by: Adam Li --- .../test_permutation_forest.ipynb | 216 +---------- sktree/stats/forestht.py | 360 +----------------- sktree/stats/permutationforest.py | 360 +----------------- sktree/stats/tests/test_forestht.py | 46 ++- 4 files changed, 73 insertions(+), 909 deletions(-) diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/test_permutation_forest.ipynb index 8a76cdb35..ce008e796 100644 --- a/benchmarks_nonasv/test_permutation_forest.ipynb +++ b/benchmarks_nonasv/test_permutation_forest.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 15, "id": "b658bdd8-a3e6-4051-9d66-f2a153113234", "metadata": {}, "outputs": [], @@ -15,6 +15,7 @@ "import seaborn as sns\n", "from scipy.special import expit\n", "\n", + "from sktree import RandomForestClassifier, RandomForestRegressor\n", "from sktree.stats import (\n", " FeatureImportanceForestClassifier,\n", " FeatureImportanceForestRegressor,\n", @@ -37,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 17, "id": "5e2d1279-fa4f-47ef-aa48-fac6d47159ad", "metadata": {}, "outputs": [], @@ -84,14 +85,12 @@ "\n", " # initialize hypothesis tester\n", " est = FeatureImportanceForestRegressor(\n", - " max_features=1.0,\n", + " RandomForestRegressor(\n", + " max_features=1.0, random_state=seed, n_estimators=n_estimators, n_jobs=-1\n", + " ),\n", " random_state=seed,\n", - " n_estimators=n_estimators,\n", - " n_jobs=-1,\n", " permute_per_tree=permute_per_tree,\n", " sample_dataset_per_tree=sample_dataset_per_tree,\n", - " # bootstrap=True,\n", - " # max_samples=subsample_size\n", " )\n", " pvalue_dict = {}\n", "\n", @@ -139,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 18, "id": "3db4f740-afd9-413e-8089-a8245f2a0747", "metadata": {}, "outputs": [], @@ -190,14 +189,15 @@ "\n", " # initialize hypothesis tester\n", " est = FeatureImportanceForestClassifier(\n", - " max_features=1.0,\n", + " RandomForestClassifier(\n", + " max_features=1.0,\n", + " random_state=seed,\n", + " n_estimators=n_estimators,\n", + " n_jobs=-1,\n", + " ),\n", " random_state=seed,\n", - " n_estimators=n_estimators,\n", - " n_jobs=-1,\n", " permute_per_tree=permute_per_tree,\n", " sample_dataset_per_tree=sample_dataset_per_tree,\n", - " # bootstrap=True,\n", - " # max_samples=subsample_size\n", " )\n", "\n", " # test for X_2 important\n", @@ -609,112 +609,8 @@ "X1: 1.0\n", "X500: 1.0\n", "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 1.0\n" + "X500: 1.0\n" ] } ], @@ -747,90 +643,10 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "b2bced31-0367-48a8-88e1-0afd6a60173f", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
X2X1X500sigma_factor
01.0000000.0049751.0000000.005
10.0049750.0049751.0000000.005
21.0000000.0049751.0000000.005
30.0049751.0000000.0049750.005
40.0049751.0000000.0049750.005
\n", - "
" - ], - "text/plain": [ - " X2 X1 X500 sigma_factor\n", - "0 1.000000 0.004975 1.000000 0.005\n", - "1 0.004975 0.004975 1.000000 0.005\n", - "2 1.000000 0.004975 1.000000 0.005\n", - "3 0.004975 1.000000 0.004975 0.005\n", - "4 0.004975 1.000000 0.004975 0.005" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "display(df.head())" ] diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 410a53974..49ec36c1c 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -30,47 +30,21 @@ class BaseForestHT(MetaEstimatorMixin): def __init__( self, estimator=None, - n_estimators=100, - criterion="squared_error", - max_depth=None, - min_samples_split=2, - min_samples_leaf=1, - min_weight_fraction_leaf=0.0, - max_features="sqrt", - max_leaf_nodes=None, - min_impurity_decrease=0.0, - bootstrap=False, - oob_score=False, - n_jobs=None, random_state=None, verbose=0, - warm_start=False, - ccp_alpha=0.0, - max_samples=None, permute_per_tree=True, sample_dataset_per_tree=True, ): self.estimator = estimator - self.n_jobs = n_jobs - self.n_estimators = n_estimators - self.criterion = criterion - self.max_depth = max_depth - self.min_samples_split = min_samples_split - self.min_samples_leaf = min_samples_leaf - self.min_weight_fraction_leaf = min_weight_fraction_leaf - self.max_features = max_features - self.max_leaf_nodes = max_leaf_nodes - self.min_impurity_decrease = min_impurity_decrease - self.bootstrap = bootstrap - self.oob_score = oob_score self.random_state = random_state self.verbose = verbose - self.warm_start = warm_start - self.ccp_alpha = ccp_alpha - self.max_samples = max_samples self.permute_per_tree = permute_per_tree self.sample_dataset_per_tree = sample_dataset_per_tree + @property + def n_estimators(self): + return self.estimator_.n_estimators + def reset(self): class_attributes = dir(type(self)) instance_attributes = dir(self) @@ -303,92 +277,6 @@ class FeatureImportanceForestRegressor(BaseForestHT): Type of forest estimator to use. By default `None`, which defaults to :class:`sklearn.ensemble.RandomForestRegressor`. - n_estimators : int, default=100 - The number of trees in the forest. - - criterion : {"gini", "entropy"}, default="gini" - The function to measure the quality of a split. Supported criteria are - "gini" for the Gini impurity and "entropy" for the information gain. - Note: this parameter is tree-specific. - - max_depth : int, default=None - The maximum depth of the tree. If None, then nodes are expanded until - all leaves are pure or until all leaves contain less than - min_samples_split samples. - - min_samples_split : int or float, default=2 - The minimum number of samples required to split an internal node: - - - If int, then consider `min_samples_split` as the minimum number. - - If float, then `min_samples_split` is a fraction and - `ceil(min_samples_split * n_samples)` are the minimum - number of samples for each split. - - min_samples_leaf : int or float, default=1 - The minimum number of samples required to be at a leaf node. - A split point at any depth will only be considered if it leaves at - least ``min_samples_leaf`` training samples in each of the left and - right branches. This may have the effect of smoothing the model, - especially in regression. - - - If int, then consider `min_samples_leaf` as the minimum number. - - If float, then `min_samples_leaf` is a fraction and - `ceil(min_samples_leaf * n_samples)` are the minimum - number of samples for each node. - - min_weight_fraction_leaf : float, default=0.0 - The minimum weighted fraction of the sum total of weights (of all - the input samples) required to be at a leaf node. Samples have - equal weight when sample_weight is not provided. - - max_features : {"sqrt", "log2", None}, int or float, default="sqrt" - The number of features to consider when looking for the best split: - - - If int, then consider `max_features` features at each split. - - If float, then `max_features` is a fraction and - `round(max_features * n_features)` features are considered at each - split. - - If "auto", then `max_features=sqrt(n_features)`. - - If "sqrt", then `max_features=sqrt(n_features)`. - - If "log2", then `max_features=log2(n_features)`. - - If None, then `max_features=n_features`. - - Note: the search for a split does not stop until at least one - valid partition of the node samples is found, even if it requires to - effectively inspect more than ``max_features`` features. - - max_leaf_nodes : int, default=None - Grow trees with ``max_leaf_nodes`` in best-first fashion. - Best nodes are defined as relative reduction in impurity. - If None then unlimited number of leaf nodes. - - min_impurity_decrease : float, default=0.0 - A node will be split if this split induces a decrease of the impurity - greater than or equal to this value. - - The weighted impurity decrease equation is the following:: - - N_t / N * (impurity - N_t_R / N_t * right_impurity - - N_t_L / N_t * left_impurity) - - where ``N`` is the total number of samples, ``N_t`` is the number of - samples at the current node, ``N_t_L`` is the number of samples in the - left child, and ``N_t_R`` is the number of samples in the right child. - - ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, - if ``sample_weight`` is passed. - - bootstrap : bool, default=True - Whether bootstrap samples are used when building trees. If False, the - whole dataset is used to build each tree. - - oob_score : bool, default=False - Whether to use out-of-bag samples to estimate the generalization score. - Only available if bootstrap=True. - - n_jobs : int, default=None - The number of jobs to run in parallel. - random_state : int, RandomState instance or None, default=None Controls both the randomness of the bootstrapping of the samples used when building trees (if ``bootstrap=True``) and the sampling of the @@ -399,26 +287,6 @@ class FeatureImportanceForestRegressor(BaseForestHT): verbose : int, default=0 Controls the verbosity when fitting and predicting. - warm_start : bool, default=False - When set to ``True``, reuse the solution of the previous call to fit - and add more estimators to the ensemble, otherwise, just fit a whole - new forest. See :term:`the Glossary `. - - ccp_alpha : non-negative float, default=0.0 - Complexity parameter used for Minimal Cost-Complexity Pruning. The - subtree with the largest cost complexity that is smaller than - ``ccp_alpha`` will be chosen. By default, no pruning is performed. See - :ref:`minimal_cost_complexity_pruning` for details. - - max_samples : int or float, default=None - If bootstrap is True, the number of samples to draw from X - to train each base tree estimator. - - - If None (default), then draw `X.shape[0]` samples. - - If int, then draw `max_samples` samples. - - If float, then draw `max_samples * X.shape[0]` samples. Thus, - `max_samples` should be in the interval `(0.0, 1.0]`. - permute_per_tree : bool, default=True Whether to permute the covariate index per tree or per forest. @@ -427,6 +295,9 @@ class FeatureImportanceForestRegressor(BaseForestHT): Attributes ---------- + estimator_ : BaseForest + The estimator used to compute the test statistic. + samples_ : ArrayLike of shape (n_samples,) The indices of the samples used in the final test. @@ -447,70 +318,22 @@ class FeatureImportanceForestRegressor(BaseForestHT): def __init__( self, estimator=None, - n_estimators=100, - criterion="squared_error", - max_depth=None, - min_samples_split=2, - min_samples_leaf=1, - min_weight_fraction_leaf=0.0, - max_features="sqrt", - max_leaf_nodes=None, - min_impurity_decrease=0.0, - bootstrap=False, - oob_score=False, - n_jobs=None, random_state=None, verbose=0, - warm_start=False, - ccp_alpha=0.0, - max_samples=None, permute_per_tree=True, sample_dataset_per_tree=True, ): super().__init__( estimator=estimator, - n_estimators=n_estimators, - criterion=criterion, - max_depth=max_depth, - min_samples_split=min_samples_split, - min_samples_leaf=min_samples_leaf, - min_weight_fraction_leaf=min_weight_fraction_leaf, - max_features=max_features, - max_leaf_nodes=max_leaf_nodes, - min_impurity_decrease=min_impurity_decrease, - bootstrap=bootstrap, - oob_score=oob_score, - n_jobs=n_jobs, random_state=random_state, verbose=verbose, - warm_start=warm_start, - ccp_alpha=ccp_alpha, - max_samples=max_samples, + permute_per_tree=permute_per_tree, + sample_dataset_per_tree=sample_dataset_per_tree, ) - self.permute_per_tree = permute_per_tree - self.sample_dataset_per_tree = sample_dataset_per_tree def _get_estimator(self): if self.estimator is None: - estimator_ = RandomForestRegressor( - n_estimators=self.n_estimators, - criterion=self.criterion, - max_depth=self.max_depth, - min_samples_split=self.min_samples_split, - min_samples_leaf=self.min_samples_leaf, - min_weight_fraction_leaf=self.min_weight_fraction_leaf, - max_features=self.max_features, - max_leaf_nodes=self.max_leaf_nodes, - min_impurity_decrease=self.min_impurity_decrease, - bootstrap=self.bootstrap, - oob_score=self.oob_score, - n_jobs=self.n_jobs, - random_state=self.random_state, - verbose=self.verbose, - warm_start=self.warm_start, - ccp_alpha=self.ccp_alpha, - max_samples=self.max_samples, - ) + estimator_ = RandomForestRegressor() elif not isinstance(self.estimator, (ForestRegressor, sklearnForestRegressor)): raise RuntimeError(f"Estimator must be a ForestRegressor, got {type(self.estimator)}") else: @@ -659,92 +482,6 @@ class FeatureImportanceForestClassifier(BaseForestHT): Type of forest estimator to use. By default `None`, which defaults to :class:`sklearn.ensemble.RandomForestRegressor`. - n_estimators : int, default=100 - The number of trees in the forest. - - criterion : {"gini", "entropy"}, default="gini" - The function to measure the quality of a split. Supported criteria are - "gini" for the Gini impurity and "entropy" for the information gain. - Note: this parameter is tree-specific. - - max_depth : int, default=None - The maximum depth of the tree. If None, then nodes are expanded until - all leaves are pure or until all leaves contain less than - min_samples_split samples. - - min_samples_split : int or float, default=2 - The minimum number of samples required to split an internal node: - - - If int, then consider `min_samples_split` as the minimum number. - - If float, then `min_samples_split` is a fraction and - `ceil(min_samples_split * n_samples)` are the minimum - number of samples for each split. - - min_samples_leaf : int or float, default=1 - The minimum number of samples required to be at a leaf node. - A split point at any depth will only be considered if it leaves at - least ``min_samples_leaf`` training samples in each of the left and - right branches. This may have the effect of smoothing the model, - especially in regression. - - - If int, then consider `min_samples_leaf` as the minimum number. - - If float, then `min_samples_leaf` is a fraction and - `ceil(min_samples_leaf * n_samples)` are the minimum - number of samples for each node. - - min_weight_fraction_leaf : float, default=0.0 - The minimum weighted fraction of the sum total of weights (of all - the input samples) required to be at a leaf node. Samples have - equal weight when sample_weight is not provided. - - max_features : {"sqrt", "log2", None}, int or float, default="sqrt" - The number of features to consider when looking for the best split: - - - If int, then consider `max_features` features at each split. - - If float, then `max_features` is a fraction and - `round(max_features * n_features)` features are considered at each - split. - - If "auto", then `max_features=sqrt(n_features)`. - - If "sqrt", then `max_features=sqrt(n_features)`. - - If "log2", then `max_features=log2(n_features)`. - - If None, then `max_features=n_features`. - - Note: the search for a split does not stop until at least one - valid partition of the node samples is found, even if it requires to - effectively inspect more than ``max_features`` features. - - max_leaf_nodes : int, default=None - Grow trees with ``max_leaf_nodes`` in best-first fashion. - Best nodes are defined as relative reduction in impurity. - If None then unlimited number of leaf nodes. - - min_impurity_decrease : float, default=0.0 - A node will be split if this split induces a decrease of the impurity - greater than or equal to this value. - - The weighted impurity decrease equation is the following:: - - N_t / N * (impurity - N_t_R / N_t * right_impurity - - N_t_L / N_t * left_impurity) - - where ``N`` is the total number of samples, ``N_t`` is the number of - samples at the current node, ``N_t_L`` is the number of samples in the - left child, and ``N_t_R`` is the number of samples in the right child. - - ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, - if ``sample_weight`` is passed. - - bootstrap : bool, default=True - Whether bootstrap samples are used when building trees. If False, the - whole dataset is used to build each tree. - - oob_score : bool, default=False - Whether to use out-of-bag samples to estimate the generalization score. - Only available if bootstrap=True. - - n_jobs : int, default=None - The number of jobs to run in parallel. - random_state : int, RandomState instance or None, default=None Controls both the randomness of the bootstrapping of the samples used when building trees (if ``bootstrap=True``) and the sampling of the @@ -755,26 +492,6 @@ class FeatureImportanceForestClassifier(BaseForestHT): verbose : int, default=0 Controls the verbosity when fitting and predicting. - warm_start : bool, default=False - When set to ``True``, reuse the solution of the previous call to fit - and add more estimators to the ensemble, otherwise, just fit a whole - new forest. See :term:`the Glossary `. - - ccp_alpha : non-negative float, default=0.0 - Complexity parameter used for Minimal Cost-Complexity Pruning. The - subtree with the largest cost complexity that is smaller than - ``ccp_alpha`` will be chosen. By default, no pruning is performed. See - :ref:`minimal_cost_complexity_pruning` for details. - - max_samples : int or float, default=None - If bootstrap is True, the number of samples to draw from X - to train each base tree estimator. - - - If None (default), then draw `X.shape[0]` samples. - - If int, then draw `max_samples` samples. - - If float, then draw `max_samples * X.shape[0]` samples. Thus, - `max_samples` should be in the interval `(0.0, 1.0]`. - permute_per_tree : bool, default=True Whether to permute the covariate index per tree or per forest. @@ -783,6 +500,9 @@ class FeatureImportanceForestClassifier(BaseForestHT): Attributes ---------- + estimator_ : BaseForest + The estimator used to compute the test statistic. + samples_ : ArrayLike of shape (n_samples,) The indices of the samples used in the final test. @@ -803,70 +523,22 @@ class FeatureImportanceForestClassifier(BaseForestHT): def __init__( self, estimator=None, - n_estimators=100, - criterion="gini", - max_depth=None, - min_samples_split=2, - min_samples_leaf=1, - min_weight_fraction_leaf=0.0, - max_features="sqrt", - max_leaf_nodes=None, - min_impurity_decrease=0.0, - bootstrap=False, - oob_score=False, - n_jobs=None, random_state=None, verbose=0, - warm_start=False, - ccp_alpha=0.0, - max_samples=None, permute_per_tree=True, sample_dataset_per_tree=True, ): super().__init__( estimator=estimator, - n_estimators=n_estimators, - criterion=criterion, - max_depth=max_depth, - min_samples_split=min_samples_split, - min_samples_leaf=min_samples_leaf, - min_weight_fraction_leaf=min_weight_fraction_leaf, - max_features=max_features, - max_leaf_nodes=max_leaf_nodes, - min_impurity_decrease=min_impurity_decrease, - bootstrap=bootstrap, - oob_score=oob_score, - n_jobs=n_jobs, random_state=random_state, verbose=verbose, - warm_start=warm_start, - ccp_alpha=ccp_alpha, - max_samples=max_samples, + permute_per_tree=permute_per_tree, + sample_dataset_per_tree=sample_dataset_per_tree, ) - self.permute_per_tree = permute_per_tree - self.sample_dataset_per_tree = sample_dataset_per_tree def _get_estimator(self): if self.estimator is None: - estimator_ = RandomForestClassifier( - n_estimators=self.n_estimators, - criterion=self.criterion, - max_depth=self.max_depth, - min_samples_split=self.min_samples_split, - min_samples_leaf=self.min_samples_leaf, - min_weight_fraction_leaf=self.min_weight_fraction_leaf, - max_features=self.max_features, - max_leaf_nodes=self.max_leaf_nodes, - min_impurity_decrease=self.min_impurity_decrease, - bootstrap=self.bootstrap, - oob_score=self.oob_score, - n_jobs=self.n_jobs, - random_state=self.random_state, - verbose=self.verbose, - warm_start=self.warm_start, - ccp_alpha=self.ccp_alpha, - max_samples=self.max_samples, - ) + estimator_ = RandomForestClassifier() elif not isinstance(self.estimator, (ForestClassifier, sklearnForestClassifier)): raise RuntimeError(f"Estimator must be a ForestClassifier, got {type(self.estimator)}") else: diff --git a/sktree/stats/permutationforest.py b/sktree/stats/permutationforest.py index 2040f7003..b51a182bb 100644 --- a/sktree/stats/permutationforest.py +++ b/sktree/stats/permutationforest.py @@ -2,6 +2,8 @@ from numpy.typing import ArrayLike from sklearn.base import MetaEstimatorMixin, clone, is_classifier from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor +from sklearn.ensemble._forest import ForestClassifier as sklearnForestClassifier +from sklearn.ensemble._forest import ForestRegressor as sklearnForestRegressor from sklearn.model_selection import train_test_split from sklearn.utils.validation import check_X_y @@ -14,42 +16,12 @@ class BasePermutationForest(MetaEstimatorMixin): def __init__( self, estimator=None, - n_estimators=100, - criterion="squared_error", - max_depth=None, - min_samples_split=2, - min_samples_leaf=1, - min_weight_fraction_leaf=0.0, - max_features=1.0, - max_leaf_nodes=None, - min_impurity_decrease=0.0, - bootstrap=False, - oob_score=False, - n_jobs=None, random_state=None, verbose=0, - warm_start=False, - ccp_alpha=0.0, - max_samples=None, ): self.estimator = estimator - self.n_jobs = n_jobs - self.n_estimators = n_estimators - self.criterion = criterion - self.max_depth = max_depth - self.min_samples_split = min_samples_split - self.min_samples_leaf = min_samples_leaf - self.min_weight_fraction_leaf = min_weight_fraction_leaf - self.max_features = max_features - self.max_leaf_nodes = max_leaf_nodes - self.min_impurity_decrease = min_impurity_decrease - self.bootstrap = bootstrap - self.oob_score = oob_score self.random_state = random_state self.verbose = verbose - self.warm_start = warm_start - self.ccp_alpha = ccp_alpha - self.max_samples = max_samples def reset(self): class_attributes = dir(type(self)) @@ -309,99 +281,7 @@ class PermutationForestRegressor(BasePermutationForest): ---------- estimator : object, default=None Type of forest estimator to use. By default `None`, which defaults to - :class:`sklearn.ensemble.RandomForestRegressor`. - - n_estimators : int, default=100 - The number of trees in the forest. - - criterion : {"squared_error", "friedman_mse", "absolute_error", \ - "poisson"}, default="squared_error" - The function to measure the quality of a split. Supported criteria - are "squared_error" for the mean squared error, which is equal to - variance reduction as feature selection criterion and minimizes the L2 - loss using the mean of each terminal node, "friedman_mse", which uses - mean squared error with Friedman's improvement score for potential - splits, "absolute_error" for the mean absolute error, which minimizes - the L1 loss using the median of each terminal node, and "poisson" which - uses reduction in Poisson deviance to find splits. - - max_depth : int, default=None - The maximum depth of the tree. If None, then nodes are expanded until - all leaves are pure or until all leaves contain less than - min_samples_split samples. - - min_samples_split : int or float, default=2 - The minimum number of samples required to split an internal node: - - - If int, then consider `min_samples_split` as the minimum number. - - If float, then `min_samples_split` is a fraction and - `ceil(min_samples_split * n_samples)` are the minimum - number of samples for each split. - - min_samples_leaf : int or float, default=1 - The minimum number of samples required to be at a leaf node. - A split point at any depth will only be considered if it leaves at - least ``min_samples_leaf`` training samples in each of the left and - right branches. This may have the effect of smoothing the model, - especially in regression. - - - If int, then consider `min_samples_leaf` as the minimum number. - - If float, then `min_samples_leaf` is a fraction and - `ceil(min_samples_leaf * n_samples)` are the minimum - number of samples for each node. - - min_weight_fraction_leaf : float, default=0.0 - The minimum weighted fraction of the sum total of weights (of all - the input samples) required to be at a leaf node. Samples have - equal weight when sample_weight is not provided. - - max_features : {"sqrt", "log2", None}, int or float, default="sqrt" - The number of features to consider when looking for the best split: - - - If int, then consider `max_features` features at each split. - - If float, then `max_features` is a fraction and - `round(max_features * n_features)` features are considered at each - split. - - If "auto", then `max_features=sqrt(n_features)`. - - If "sqrt", then `max_features=sqrt(n_features)`. - - If "log2", then `max_features=log2(n_features)`. - - If None, then `max_features=n_features`. - - Note: the search for a split does not stop until at least one - valid partition of the node samples is found, even if it requires to - effectively inspect more than ``max_features`` features. - - max_leaf_nodes : int, default=None - Grow trees with ``max_leaf_nodes`` in best-first fashion. - Best nodes are defined as relative reduction in impurity. - If None then unlimited number of leaf nodes. - - min_impurity_decrease : float, default=0.0 - A node will be split if this split induces a decrease of the impurity - greater than or equal to this value. - - The weighted impurity decrease equation is the following:: - - N_t / N * (impurity - N_t_R / N_t * right_impurity - - N_t_L / N_t * left_impurity) - - where ``N`` is the total number of samples, ``N_t`` is the number of - samples at the current node, ``N_t_L`` is the number of samples in the - left child, and ``N_t_R`` is the number of samples in the right child. - - ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, - if ``sample_weight`` is passed. - - bootstrap : bool, default=True - Whether bootstrap samples are used when building trees. If False, the - whole dataset is used to build each tree. - - oob_score : bool, default=False - Whether to use out-of-bag samples to estimate the generalization score. - Only available if bootstrap=True. - - n_jobs : int, default=None - The number of jobs to run in parallel. + :class:`sklearn.ensemble.RandomForestRegressor` with default parameters. random_state : int, RandomState instance or None, default=None Controls both the randomness of the bootstrapping of the samples used @@ -413,26 +293,6 @@ class PermutationForestRegressor(BasePermutationForest): verbose : int, default=0 Controls the verbosity when fitting and predicting. - warm_start : bool, default=False - When set to ``True``, reuse the solution of the previous call to fit - and add more estimators to the ensemble, otherwise, just fit a whole - new forest. See :term:`the Glossary `. - - ccp_alpha : non-negative float, default=0.0 - Complexity parameter used for Minimal Cost-Complexity Pruning. The - subtree with the largest cost complexity that is smaller than - ``ccp_alpha`` will be chosen. By default, no pruning is performed. See - :ref:`minimal_cost_complexity_pruning` for details. - - max_samples : int or float, default=None - If bootstrap is True, the number of samples to draw from X - to train each base tree estimator. - - - If None (default), then draw `X.shape[0]` samples. - - If int, then draw `max_samples` samples. - - If float, then draw `max_samples * X.shape[0]` samples. Thus, - `max_samples` should be in the interval `(0.0, 1.0]`. - Attributes ---------- samples_ : ArrayLike of shape (n_samples,) @@ -455,68 +315,22 @@ class PermutationForestRegressor(BasePermutationForest): def __init__( self, estimator=None, - n_estimators=100, - criterion="squared_error", - max_depth=None, - min_samples_split=2, - min_samples_leaf=1, - min_weight_fraction_leaf=0.0, - max_features=1.0, - max_leaf_nodes=None, - min_impurity_decrease=0.0, - bootstrap=False, - oob_score=False, - n_jobs=None, random_state=None, verbose=0, - warm_start=False, - ccp_alpha=0.0, - max_samples=None, ): super().__init__( estimator=estimator, - n_estimators=n_estimators, - criterion=criterion, - max_depth=max_depth, - min_samples_split=min_samples_split, - min_samples_leaf=min_samples_leaf, - min_weight_fraction_leaf=min_weight_fraction_leaf, - max_features=max_features, - max_leaf_nodes=max_leaf_nodes, - min_impurity_decrease=min_impurity_decrease, - bootstrap=bootstrap, - oob_score=oob_score, - n_jobs=n_jobs, random_state=random_state, verbose=verbose, - warm_start=warm_start, - ccp_alpha=ccp_alpha, - max_samples=max_samples, ) def _get_estimator(self): if not hasattr(self, "estimator_") and self.estimator is None: - estimator_ = RandomForestRegressor( - n_estimators=self.n_estimators, - criterion=self.criterion, - max_depth=self.max_depth, - min_samples_split=self.min_samples_split, - min_samples_leaf=self.min_samples_leaf, - min_weight_fraction_leaf=self.min_weight_fraction_leaf, - max_features=self.max_features, - max_leaf_nodes=self.max_leaf_nodes, - min_impurity_decrease=self.min_impurity_decrease, - bootstrap=self.bootstrap, - oob_score=self.oob_score, - n_jobs=self.n_jobs, - random_state=self.random_state, - verbose=self.verbose, - warm_start=self.warm_start, - ccp_alpha=self.ccp_alpha, - max_samples=self.max_samples, - ) - elif not isinstance(self.estimator_, ForestRegressor): - raise RuntimeError(f"Estimator must be a ForestRegressor, got {type(self.estimator_)}") + estimator_ = RandomForestRegressor() + elif not isinstance(self.estimator, (ForestRegressor, sklearnForestRegressor)): + raise RuntimeError(f"Estimator must be a ForestRegressor, got {type(self.estimator)}") + else: + estimator_ = self.estimator return estimator_ @@ -543,88 +357,6 @@ class PermutationForestClassifier(BasePermutationForest): Type of forest estimator to use. By default `None`, which defaults to :class:`sklearn.ensemble.RandomForestClassifier`. - n_estimators : int, default=100 - The number of trees in the forest. - - criterion : {"gini", "entropy"}, default="gini" - The function to measure the quality of a split. Supported criteria are - "gini" for the Gini impurity and "entropy" for the information gain. - - max_depth : int, default=None - The maximum depth of the tree. If None, then nodes are expanded until - all leaves are pure or until all leaves contain less than - min_samples_split samples. - - min_samples_split : int or float, default=2 - The minimum number of samples required to split an internal node: - - - If int, then consider `min_samples_split` as the minimum number. - - If float, then `min_samples_split` is a fraction and - `ceil(min_samples_split * n_samples)` are the minimum - number of samples for each split. - - min_samples_leaf : int or float, default=1 - The minimum number of samples required to be at a leaf node. - A split point at any depth will only be considered if it leaves at - least ``min_samples_leaf`` training samples in each of the left and - right branches. This may have the effect of smoothing the model, - especially in regression. - - - If int, then consider `min_samples_leaf` as the minimum number. - - If float, then `min_samples_leaf` is a fraction and - `ceil(min_samples_leaf * n_samples)` are the minimum - number of samples for each node. - - min_weight_fraction_leaf : float, default=0.0 - The minimum weighted fraction of the sum total of weights (of all - the input samples) required to be at a leaf node. Samples have - equal weight when sample_weight is not provided. - - max_features : {"sqrt", "log2", None}, int or float, default="sqrt" - The number of features to consider when looking for the best split: - - - If int, then consider `max_features` features at each split. - - If float, then `max_features` is a fraction and - `round(max_features * n_features)` features are considered at each - split. - - If "auto", then `max_features=sqrt(n_features)`. - - If "sqrt", then `max_features=sqrt(n_features)`. - - If "log2", then `max_features=log2(n_features)`. - - If None, then `max_features=n_features`. - - Note: the search for a split does not stop until at least one - valid partition of the node samples is found, even if it requires to - effectively inspect more than ``max_features`` features. - - max_leaf_nodes : int, default=None - Grow trees with ``max_leaf_nodes`` in best-first fashion. - Best nodes are defined as relative reduction in impurity. - If None then unlimited number of leaf nodes. - - min_impurity_decrease : float, default=0.0 - A node will be split if this split induces a decrease of the impurity - greater than or equal to this value. - - The weighted impurity decrease equation is the following:: - - N_t / N * (impurity - N_t_R / N_t * right_impurity - - N_t_L / N_t * left_impurity) - - where ``N`` is the total number of samples, ``N_t`` is the number of - samples at the current node, ``N_t_L`` is the number of samples in the - left child, and ``N_t_R`` is the number of samples in the right child. - - ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, - if ``sample_weight`` is passed. - - bootstrap : bool, default=True - Whether bootstrap samples are used when building trees. If False, the - whole dataset is used to build each tree. - - oob_score : bool, default=False - Whether to use out-of-bag samples to estimate the generalization score. - Only available if bootstrap=True. - n_jobs : int, default=None The number of jobs to run in parallel. @@ -638,26 +370,6 @@ class PermutationForestClassifier(BasePermutationForest): verbose : int, default=0 Controls the verbosity when fitting and predicting. - warm_start : bool, default=False - When set to ``True``, reuse the solution of the previous call to fit - and add more estimators to the ensemble, otherwise, just fit a whole - new forest. See :term:`the Glossary `. - - ccp_alpha : non-negative float, default=0.0 - Complexity parameter used for Minimal Cost-Complexity Pruning. The - subtree with the largest cost complexity that is smaller than - ``ccp_alpha`` will be chosen. By default, no pruning is performed. See - :ref:`minimal_cost_complexity_pruning` for details. - - max_samples : int or float, default=None - If bootstrap is True, the number of samples to draw from X - to train each base tree estimator. - - - If None (default), then draw `X.shape[0]` samples. - - If int, then draw `max_samples` samples. - - If float, then draw `max_samples * X.shape[0]` samples. Thus, - `max_samples` should be in the interval `(0.0, 1.0]`. - Attributes ---------- samples_ : ArrayLike of shape (n_samples,) @@ -680,66 +392,20 @@ class PermutationForestClassifier(BasePermutationForest): def __init__( self, estimator=None, - n_estimators=100, - criterion="gini", - max_depth=None, - min_samples_split=2, - min_samples_leaf=1, - min_weight_fraction_leaf=0.0, - max_features="sqrt", - max_leaf_nodes=None, - min_impurity_decrease=0.0, - bootstrap=False, - oob_score=False, - n_jobs=None, random_state=None, verbose=0, - warm_start=False, - ccp_alpha=0.0, - max_samples=None, ): super().__init__( estimator=estimator, - n_estimators=n_estimators, - criterion=criterion, - max_depth=max_depth, - min_samples_split=min_samples_split, - min_samples_leaf=min_samples_leaf, - min_weight_fraction_leaf=min_weight_fraction_leaf, - max_features=max_features, - max_leaf_nodes=max_leaf_nodes, - min_impurity_decrease=min_impurity_decrease, - bootstrap=bootstrap, - oob_score=oob_score, - n_jobs=n_jobs, random_state=random_state, verbose=verbose, - warm_start=warm_start, - ccp_alpha=ccp_alpha, - max_samples=max_samples, ) def _get_estimator(self): if not hasattr(self, "estimator_") and self.estimator is None: - estimator_ = RandomForestClassifier( - n_estimators=self.n_estimators, - criterion=self.criterion, - max_depth=self.max_depth, - min_samples_split=self.min_samples_split, - min_samples_leaf=self.min_samples_leaf, - min_weight_fraction_leaf=self.min_weight_fraction_leaf, - max_features=self.max_features, - max_leaf_nodes=self.max_leaf_nodes, - min_impurity_decrease=self.min_impurity_decrease, - bootstrap=self.bootstrap, - oob_score=self.oob_score, - n_jobs=self.n_jobs, - random_state=self.random_state, - verbose=self.verbose, - warm_start=self.warm_start, - ccp_alpha=self.ccp_alpha, - max_samples=self.max_samples, - ) - elif not isinstance(self.estimator_, ForestClassifier): - raise RuntimeError(f"Estimator must be a ForestClassifier, got {type(self.estimator_)}") + estimator_ = RandomForestClassifier() + elif not isinstance(self.estimator, (ForestClassifier, sklearnForestClassifier)): + raise RuntimeError(f"Estimator must be a ForestClassifier, got {type(self.estimator)}") + else: + estimator_ = self.estimator return estimator_ diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 2ef6958f9..3366dc1ea 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -4,7 +4,7 @@ from scipy.special import expit from sklearn import datasets -from sktree import HonestForestClassifier +from sktree import HonestForestClassifier, RandomForestClassifier, RandomForestRegressor from sktree._lib.sklearn.tree import DecisionTreeClassifier from sktree.stats import ( FeatureImportanceForestClassifier, @@ -37,10 +37,13 @@ [ PermutationForestRegressor, { - "max_features": "sqrt", + "estimator": RandomForestRegressor( + max_features="sqrt", + random_state=seed, + n_estimators=75, + n_jobs=-1, + ), "random_state": seed, - "n_estimators": 75, - "n_jobs": -1, }, 300, 50, @@ -49,12 +52,15 @@ [ FeatureImportanceForestRegressor, { - "max_features": "sqrt", + "estimator": RandomForestRegressor( + max_features="sqrt", + random_state=seed, + n_estimators=125, + n_jobs=-1, + ), "random_state": seed, - "n_estimators": 125, "permute_per_tree": True, "sample_dataset_per_tree": True, - "n_jobs": -1, }, 300, 500, @@ -118,10 +124,13 @@ def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size) [ PermutationForestClassifier, { - "max_features": "sqrt", + "estimator": RandomForestClassifier( + max_features="sqrt", + random_state=seed, + n_estimators=50, + n_jobs=-1, + ), "random_state": seed, - "n_estimators": 50, - "n_jobs": -1, }, 600, 50, @@ -130,12 +139,15 @@ def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size) [ FeatureImportanceForestClassifier, { - "max_features": "sqrt", + "estimator": RandomForestClassifier( + max_features="sqrt", + random_state=seed, + n_estimators=125, + n_jobs=-1, + ), "random_state": seed, - "n_estimators": 125, "permute_per_tree": True, "sample_dataset_per_tree": True, - "n_jobs": -1, }, 600, 200, @@ -219,17 +231,15 @@ def test_iris_pauc_statistic(criterion, honest_prior, estimator, limit): # Check consistency on dataset iris. clf = FeatureImportanceForestClassifier( - criterion=criterion, - random_state=0, - max_features=max_features, - n_estimators=n_estimators, estimator=HonestForestClassifier( + criterion=criterion, n_estimators=n_estimators, + max_features=max_features, tree_estimator=estimator, honest_prior=honest_prior, random_state=0, + n_jobs=-1, ), - n_jobs=-1, sample_dataset_per_tree=True, permute_per_tree=True, ) From 579003fd6b6610a1ac2f39e4ab3ed6c4b381e00b Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 19 Sep 2023 15:49:35 -0400 Subject: [PATCH 26/70] Working clean code Signed-off-by: Adam Li --- .spin/cmds.py | 7 +- README.md | 2 +- .../test_permutation_forest.ipynb | 353 +++++++++++++++++- doc/conf.py | 1 + sktree/conftest.py | 19 + sktree/stats/forestht.py | 352 +++++++++-------- sktree/stats/permutationforest.py | 72 +++- sktree/stats/tests/test_forestht.py | 38 +- 8 files changed, 628 insertions(+), 216 deletions(-) diff --git a/.spin/cmds.py b/.spin/cmds.py index 1a5fc67e4..30380208d 100644 --- a/.spin/cmds.py +++ b/.spin/cmds.py @@ -33,15 +33,10 @@ def docs(ctx, build_dir, clean=False, noplot=False): util.run(["pip", "install", "-q", "-r", "doc_requirements.txt"]) ctx.invoke(meson.docs) - # os.environ["SPHINXOPTS"] = "-W" - # os.environ["PYTHONPATH"] = f'{site_path}{os.sep}:{os.environ.get("PYTHONPATH", "")}' - # if noplot: - # util.run(["make", "-C", "docs", "clean", "html-noplot"], replace=True) - # else: - # util.run(["make", "-C", "docs", "clean", "html"], replace=True) @click.command() +@click.option("--runslow", help="Run slow tests.") @click.pass_context def coverage(ctx): """📊 Generate coverage report""" diff --git a/README.md b/README.md index 36e39fd02..4da75fef1 100644 --- a/README.md +++ b/README.md @@ -20,7 +20,7 @@ See here for the documentation for our dev version: https://docs.neurodata.io/sc Why oblique trees and why trees beyond those in scikit-learn? ============================================================= -In 2001, Leo Breiman proposed two types of Random Forests. One was known as ``Forest-RI``, which is the axis-aligned traditional random forest. One was known as ``Forest-RC``, which is the random oblique linear combinations random forest. This leveraged random combinations of features to perform splits. [MORF](1) builds upon ``Forest-RC`` by proposing additional functions to combine features. Other modern tree variants such as Canonical Correlation Forests (CCF), or unsupervised random forests are also important at solving real-world problems using robust decision tree models. +In 2001, Leo Breiman proposed two types of Random Forests. One was known as ``Forest-RI``, which is the axis-aligned traditional random forest. One was known as ``Forest-RC``, which is the random oblique linear combinations random forest. This leveraged random combinations of features to perform splits. [MORF](1) builds upon ``Forest-RC`` by proposing additional functions to combine features. Other modern tree variants such as Canonical Correlation Forests (CCF), Extended Isolation Forests, Quantile Forests, or unsupervised random forests are also important at solving real-world problems using robust decision tree models. Installation ============ diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/test_permutation_forest.ipynb index ce008e796..e8859626e 100644 --- a/benchmarks_nonasv/test_permutation_forest.ipynb +++ b/benchmarks_nonasv/test_permutation_forest.ipynb @@ -595,7 +595,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, + "id": "36c53ff3-984d-4428-87c1-3421098e0081", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.005 0.285625 0.56625 0.846875 1.1275 1.408125 1.68875 1.969375\n", + " 2.25 ]\n" + ] + } + ], + "source": [ + "print(j_space)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, "id": "a2aed8f0-1230-4128-ad77-d84764c28d0d", "metadata": { "scrolled": true @@ -610,7 +629,226 @@ "X500: 1.0\n", "X2: 1.0\n", "X1: 1.0\n", - "X500: 1.0\n" + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n" ] } ], @@ -633,30 +871,129 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "d3e21945-92b3-4ccc-8f29-b44f67d9cf33", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "done\n" + ] + } + ], "source": [ "print(\"done\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "b2bced31-0367-48a8-88e1-0afd6a60173f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
X2X1X500sigma_factor
01.01.0000001.0000000.01
11.01.0000001.0000000.01
21.00.0049750.0049750.01
31.01.0000001.0000000.01
41.00.0049750.0049750.01
\n", + "
" + ], + "text/plain": [ + " X2 X1 X500 sigma_factor\n", + "0 1.0 1.000000 1.000000 0.01\n", + "1 1.0 1.000000 1.000000 0.01\n", + "2 1.0 0.004975 0.004975 0.01\n", + "3 1.0 1.000000 1.000000 0.01\n", + "4 1.0 0.004975 0.004975 0.01" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "display(df.head())" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "c4dbdaf1-9af7-4e6d-83b6-a9cabc18dc91", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, axs = plt.subplots(3, 1, figsize=(8, 6), sharey=True, sharex=True)\n", "axs = axs.flatten()\n", diff --git a/doc/conf.py b/doc/conf.py index 48bc28c6e..fbab7cddd 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -206,6 +206,7 @@ "Ignored", "UnsupervisedSplitter", "n_repeats", + "n_samples_test_used", # from sklearn "such", "arrays", diff --git a/sktree/conftest.py b/sktree/conftest.py index c226c3c60..7b69b7098 100644 --- a/sktree/conftest.py +++ b/sktree/conftest.py @@ -1,3 +1,22 @@ +# import pytest + + +# def pytest_addoption(parser): +# parser.addoption( +# "--runslow", action="store_true", default=False, help="run slow tests" +# ) + + def pytest_configure(config): """Set up pytest markers.""" config.addinivalue_line("markers", "slowtest: mark test as slow") + + +# def pytest_collection_modifyitems(config, items): +# if config.getoption("--runslow"): +# # --runslow given in cli: do not skip slow tests +# return +# skip_slow = pytest.mark.skip(reason="need --runslow option to run") +# for item in items: +# if "slow" in item.keywords: +# item.add_marker(skip_slow) diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 49ec36c1c..9393ec91f 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -32,12 +32,14 @@ def __init__( estimator=None, random_state=None, verbose=0, + test_size=0.2, permute_per_tree=True, sample_dataset_per_tree=True, ): self.estimator = estimator self.random_state = random_state self.verbose = verbose + self.test_size = test_size self.permute_per_tree = permute_per_tree self.sample_dataset_per_tree = sample_dataset_per_tree @@ -53,6 +55,58 @@ def reset(self): if attr_name.endswith("_") and attr_name not in class_attributes: delattr(self, attr_name) + def _get_estimators_indices(self): + indices = np.arange(self._n_samples_, dtype=int) + + # Get drawn indices along both sample and feature axes + if self.permute_per_tree and self.sample_dataset_per_tree: + for tree in self.estimator_.estimators_: + seed = tree.random_state + + # Operations accessing random_state must be performed identically + # to those in `_parallel_build_trees()` + indices_train, indices_test = train_test_split( + indices, test_size=self.test_size, shuffle=True, random_state=seed + ) + + yield indices_train, indices_test + else: + indices_train, indices_test = train_test_split( + indices, test_size=self.test_size, shuffle=True, random_state=self.random_state + ) + for tree in self.estimator_.estimators_: + yield indices_train, indices_test + + @property + def train_test_samples_(self): + """ + The subset of drawn samples for each base estimator. + + Returns a dynamically generated list of indices identifying + the samples used for fitting each member of the ensemble, i.e., + the in-bag samples. + + Note: the list is re-created at each call to the property in order + to reduce the object memory footprint by not storing the sampling + data. Thus fetching the property may be slower than expected. + """ + return [ + (indices_train, indices_test) + for indices_train, indices_test in self._get_estimators_indices() + ] + + def _statistic( + self, + estimator: BaseForest, + X: ArrayLike, + y: ArrayLike, + covariate_index: ArrayLike = None, + metric="mse", + return_posteriors: bool = False, + **metric_kwargs, + ): + raise NotImplementedError("Subclasses should implement this!") + def statistic( self, X: ArrayLike, @@ -101,6 +155,9 @@ def statistic( if y.ndim != 2: y = y.reshape(-1, 1) + if self.sample_dataset_per_tree and not self.permute_per_tree: + raise ValueError("sample_dataset_per_tree is only valid when permute_per_tree=True") + if covariate_index is None: self.estimator_ = self._get_estimator() estimator = self.estimator_ @@ -108,8 +165,48 @@ def statistic( self.permuted_estimator_ = clone(self.estimator_) estimator = self.permuted_estimator_ + # Infer type of target y + if not hasattr(self, "_type_of_target"): + self._type_of_target = type_of_target(y) + + # XXX: this can be improved as an extra fit can be avoided, by just doing error-checking + # and then setting the internal meta data structures + # first run a dummy fit on the samples to initialize the + # internal data structure of the forest + if not _is_fitted(estimator) and is_classifier(estimator): + _unique_y = [] + for axis in range(y.shape[1]): + _unique_y.append(np.unique(y[:, axis])) + unique_y = np.hstack(_unique_y) + if unique_y.shape[1] == 1: + unique_y = unique_y.ravel() + X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) + estimator.fit(X_dummy, unique_y) + elif not _is_fitted(estimator): + if y.shape[1] == 1: + estimator.fit(X[:2], y[:2].ravel()) + else: + estimator.fit(X[:2], y[:2]) + + # permute per tree + n_samples = X.shape[0] + self._n_samples_ = n_samples + if self.sample_dataset_per_tree: + self.n_samples_test_ = n_samples + else: + # not permute per tree + test_size_ = int(self.test_size * n_samples) + + # Fit each tree and compute posteriors with train test splits + self.n_samples_test_ = test_size_ + if not is_classifier(self.estimator_) and metric not in REGRESSOR_METRICS: - raise RuntimeError(f'Metric must be either "mse" or "mae", got {metric}') + raise RuntimeError( + f'Metric must be either "mse" or "mae" if using Regression, got {metric}' + ) + + if estimator.n_outputs_ > 1 and metric == "auc": + raise ValueError("AUC metric is not supported for multi-output") return self._statistic( estimator, @@ -174,11 +271,11 @@ def test( if y.ndim != 2: y = y.reshape(-1, 1) - indices = np.arange(X.shape[0]) - self.test_size_ = int(test_size * X.shape[0]) - indices_train, indices_test = train_test_split(indices, test_size=test_size, shuffle=True) - self.indices_train_ = indices_train - self.indices_test_ = indices_test + # indices = np.arange(X.shape[0]) + # self.test_size_ = int(test_size * X.shape[0]) + # indices_train, indices_test = train_test_split(indices, test_size=test_size, shuffle=True) + # self.indices_train_ = indices_train + # self.indices_test_ = indices_test if not hasattr(self, "samples_"): # first compute the test statistic on the un-permuted data @@ -220,11 +317,11 @@ def test( seed=self.random_state, ) else: - if self.permute_per_tree: - y_test = y + if not self.sample_dataset_per_tree: + _, indices_test = self.train_test_samples_[0] + y_test = y[indices_test, :] else: - y_test = y[self.indices_test_, :] - print(y.shape, observe_posteriors.shape, permute_posteriors.shape) + y_test = y metric_star, metric_star_pi = _compute_null_distribution_coleman( y_test=y_test, y_pred_proba_normal=observe_posteriors, @@ -298,8 +395,18 @@ class FeatureImportanceForestRegressor(BaseForestHT): estimator_ : BaseForest The estimator used to compute the test statistic. - samples_ : ArrayLike of shape (n_samples,) - The indices of the samples used in the final test. + n_samples_test_ : int + The number of samples used in the final test set. + + indices_train_ : ArrayLike of shape (n_samples_train,) + The indices of the samples used in the training set. + + indices_test_ : ArrayLike of shape (n_samples_test,) + The indices of the samples used in the testing set. + + samples_ : ArrayLike of shape (n_samples_final,) + The indices of the samples used in the final test set that would slice + the original ``(X, y)`` input. y_true_final_ : ArrayLike of shape (n_samples_final,) The true labels of the samples used in the final test. @@ -320,6 +427,7 @@ def __init__( estimator=None, random_state=None, verbose=0, + test_size=0.2, permute_per_tree=True, sample_dataset_per_tree=True, ): @@ -327,6 +435,7 @@ def __init__( estimator=estimator, random_state=random_state, verbose=verbose, + test_size=test_size, permute_per_tree=permute_per_tree, sample_dataset_per_tree=sample_dataset_per_tree, ) @@ -342,7 +451,7 @@ def _get_estimator(self): def _statistic( self, - estimator: BaseForest, + estimator: ForestRegressor, X: ArrayLike, y: ArrayLike, covariate_index: ArrayLike = None, @@ -353,79 +462,40 @@ def _statistic( """Helper function to compute the test statistic.""" metric_func = METRIC_FUNCTIONS[metric] rng = np.random.default_rng(self.random_state) - n_samples = X.shape[0] - - if self.permute_per_tree and not self.sample_dataset_per_tree: - # first run a dummy fit on the samples to initialize the - # internal data structure of the forest - if not _is_fitted(estimator): - unique_y = np.unique(y) - X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) - estimator.fit(X_dummy, unique_y) - - # Fit each tree and compute posteriors with train test splits - n_samples_test = len(self.indices_test_) + if self.permute_per_tree: # now initialize posterior array as (n_trees, n_samples_test, n_outputs) - posterior_arr = np.zeros((self.n_estimators, n_samples_test, estimator.n_outputs_)) - for idx in range(self.n_estimators): + posterior_arr = np.zeros( + (self.n_estimators, self.n_samples_test_, estimator.n_outputs_) + ) + for idx, (indices_train, indices_test) in enumerate(self._get_estimators_indices()): tree: DecisionTreeRegressor = estimator.estimators_[idx] - train_tree( - tree, X[self.indices_train_, :], y[self.indices_train_, :], covariate_index - ) - - y_pred = tree.predict(X[self.indices_test_, :]).reshape(-1, tree.n_outputs_) - - # Fill test set posteriors & set rest NaN - posterior_arr[idx, ...] = y_pred # posterior - - y_true_final = y[self.indices_test_, :] - # Average all posteriors - posterior_final = np.nanmean(posterior_arr, axis=0) - samples = np.argwhere(~np.isnan(posterior_final).any(axis=1)).squeeze() - elif self.permute_per_tree and self.sample_dataset_per_tree: - # first run a dummy fit on the samples to initialize the - # internal data structure of the forest - if not _is_fitted(estimator): - unique_y = np.unique(y) - X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) - estimator.fit(X_dummy, unique_y) - - if hasattr(self, "test_size_"): - test_size = self.test_size_ - else: - test_size = 0.2 # type: ignore - - # now initialize posterior array as (n_trees, n_samples, n_outputs) - posterior_arr = np.full((self.n_estimators, n_samples, estimator.n_outputs_), np.nan) - # Fit each tree and compute posteriors with train test splits - for idx in range(self.n_estimators): - # sample train/test dataset for each tree - indices_train, indices_test = train_test_split( - np.arange(n_samples, dtype=int), - test_size=test_size, - shuffle=True, - random_state=rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32), - ) - tree = estimator.estimators_[idx] train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) + + # Fill test set posteriors & set rest NaN + print(posterior_arr.shape, y_pred.shape) posterior_arr[idx, indices_test, :] = y_pred # posterior - # Average all posteriors + y_true_final = y[indices_test, :] + + # Average all posteriors (n_samples_test, n_outputs) posterior_final = np.nanmean(posterior_arr, axis=0) # Find the row indices with NaN values in any column nonnan_indices = np.where(~np.isnan(posterior_final).any(axis=1))[0] + samples = nonnan_indices # Ignore all NaN values (samples not tested) y_true_final = y[nonnan_indices, :] posterior_final = posterior_final[nonnan_indices, :] - samples = nonnan_indices else: - X_train, X_test = X[self.indices_train_, :], X[self.indices_test_, :] - y_train, y_test = y[self.indices_train_, :], y[self.indices_test_, :] + # fitting a forest will only get one unique train/test split + indices_train, indices_test = self.train_test_samples_[0] + + X_train, X_test = X[indices_train, :], X[indices_test, :] + y_train, y_test = y[indices_train, :], y[indices_test, :] if covariate_index is not None: # perform permutation of covariates @@ -442,7 +512,7 @@ def _statistic( y_pred = estimator.predict(X_test) # set variables to compute metric - samples = self.indices_test_ + samples = indices_test y_true_final = y_test posterior_final = y_pred @@ -503,8 +573,18 @@ class FeatureImportanceForestClassifier(BaseForestHT): estimator_ : BaseForest The estimator used to compute the test statistic. - samples_ : ArrayLike of shape (n_samples,) - The indices of the samples used in the final test. + n_samples_test_ : int + The number of samples used in the final test set. + + indices_train_ : ArrayLike of shape (n_samples_train,) + The indices of the samples used in the training set. + + indices_test_ : ArrayLike of shape (n_samples_test,) + The indices of the samples used in the testing set. + + samples_ : ArrayLike of shape (n_samples_final,) + The indices of the samples used in the final test set that would slice + the original ``(X, y)`` input. y_true_final_ : ArrayLike of shape (n_samples_final,) The true labels of the samples used in the final test. @@ -525,6 +605,7 @@ def __init__( estimator=None, random_state=None, verbose=0, + test_size=0.2, permute_per_tree=True, sample_dataset_per_tree=True, ): @@ -532,6 +613,7 @@ def __init__( estimator=estimator, random_state=random_state, verbose=verbose, + test_size=test_size, permute_per_tree=permute_per_tree, sample_dataset_per_tree=sample_dataset_per_tree, ) @@ -542,16 +624,13 @@ def _get_estimator(self): elif not isinstance(self.estimator, (ForestClassifier, sklearnForestClassifier)): raise RuntimeError(f"Estimator must be a ForestClassifier, got {type(self.estimator)}") else: - # self.estimator is an instance of a ForestEstimator, so we should verify that all - # the parameters are set correctly - # XXX: implement checks - + # self.estimator is an instance of a ForestEstimator estimator_ = self.estimator return estimator_ def _statistic( self, - estimator: BaseForest, + estimator: ForestClassifier, X: ArrayLike, y: ArrayLike, covariate_index: ArrayLike = None, @@ -562,94 +641,53 @@ def _statistic( """Helper function to compute the test statistic.""" metric_func = METRIC_FUNCTIONS[metric] rng = np.random.default_rng(self.random_state) - n_samples = X.shape[0] if metric in POSTERIOR_FUNCTIONS: predict_posteriors = True else: predict_posteriors = False - if hasattr(self, "test_size_"): - test_size = self.test_size_ - else: - test_size = 0.2 # type: ignore - - if not _is_fitted(estimator): - unique_y = np.unique(y) - X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) - estimator.fit(X_dummy, unique_y) - if estimator.n_outputs_ > 1 and metric == "auc": - raise ValueError("AUC metric is not supported for multi-output classification") - if self.permute_per_tree: - # first run a dummy fit on the samples to initialize the - # internal data structure of the forest - if self.sample_dataset_per_tree: - # Fit each tree and compute posteriors with train test splits - n_samples_test = len(self.indices_test_) - else: - n_samples_test = n_samples - if predict_posteriors: - posterior_arr = np.zeros((self.n_estimators, n_samples_test, estimator.n_classes_)) + posterior_arr = np.zeros( + (self.n_estimators, self.n_samples_test_, estimator.n_classes_) + ) else: # now initialize posterior array as (n_trees, n_samples_test, n_outputs) - posterior_arr = np.zeros((self.n_estimators, n_samples_test, estimator.n_outputs_)) - - if self.sample_dataset_per_tree: - for idx in range(self.n_estimators): - tree: DecisionTreeClassifier = estimator.estimators_[idx] - train_tree( - tree, X[self.indices_train_, :], y[self.indices_train_, :], covariate_index - ) - - if predict_posteriors: - # XXX: currently assumes n_outputs_ == 1 - y_pred = tree.predict_proba(X[self.indices_test_, :]) - else: - y_pred = tree.predict(X[self.indices_test_, :]).reshape(-1, tree.n_outputs_) - - # Fill test set posteriors & set rest NaN - posterior_arr[idx, ...] = y_pred # posterior - - y_true_final = y[self.indices_test_, :] - # Average all posteriors - posterior_final = np.nanmean(posterior_arr, axis=0) - samples = np.argwhere(~np.isnan(posterior_final).any(axis=1)).squeeze() - else: - # Fit each tree and compute posteriors with train test splits - for idx in range(self.n_estimators): - # sample train/test dataset for each tree - indices_train, indices_test = train_test_split( - np.arange(n_samples, dtype=int), - test_size=test_size, - shuffle=True, - random_state=rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32), - ) - tree = estimator.estimators_[idx] - train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) - - if predict_posteriors: - # XXX: currently assumes n_outputs_ == 1 - y_pred = tree.predict_proba(X[indices_test, :]) - else: - y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) - - posterior_arr[idx, indices_test, :] = y_pred # posterior - - # Average all posteriors (n_samples, n_outputs) - posterior_final = np.nanmean(posterior_arr, axis=0) - - # Find the row indices with NaN values in any column - nonnan_indices = np.where(~np.isnan(posterior_final).any(axis=1))[0] - - # Ignore all NaN values (samples not tested) - y_true_final = y[nonnan_indices, :] - posterior_final = posterior_final[nonnan_indices, :] - samples = nonnan_indices + posterior_arr = np.zeros( + (self.n_estimators, self.n_samples_test_, estimator.n_outputs_) + ) + + for idx, (indices_train, indices_test) in enumerate(self._get_estimators_indices()): + tree: DecisionTreeClassifier = estimator.estimators_[idx] + train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) + + if predict_posteriors: + # XXX: currently assumes n_outputs_ == 1 + y_pred = tree.predict_proba(X[indices_test, :]) + else: + y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) + + # Fill test set posteriors & set rest NaN + print(posterior_arr.shape, y_pred.shape) + posterior_arr[idx, indices_test, :] = y_pred # posterior + + # Average all posteriors (n_samples_test, n_outputs) + posterior_final = np.nanmean(posterior_arr, axis=0) + + # Find the row indices with NaN values in any column + nonnan_indices = np.where(~np.isnan(posterior_final).any(axis=1))[0] + samples = nonnan_indices + + # Ignore all NaN values (samples not tested) + y_true_final = y[nonnan_indices, :] + posterior_final = posterior_final[nonnan_indices, :] else: - X_train, X_test = X[self.indices_train_, :], X[self.indices_test_, :] - y_train, y_test = y[self.indices_train_, :], y[self.indices_test_, :] + # fitting a forest will only get one unique train/test split + indices_train, indices_test = self.train_test_samples_[0] + + X_train, X_test = X[indices_train, :], X[indices_test, :] + y_train, y_test = y[indices_train, :], y[indices_test, :] if covariate_index is not None: # perform permutation of covariates @@ -671,18 +709,18 @@ def _statistic( y_pred = estimator.predict(X_test) # set variables to compute metric - samples = self.indices_test_ + samples = indices_test y_true_final = y_test posterior_final = y_pred if metric == "auc": # at this point, posterior_final is the predicted posterior for only the positive class # as more than one output is not supported. - if type_of_target(y_true_final) == "binary": + if self._type_of_target == "binary": posterior_final = posterior_final[:, 1] else: raise RuntimeError( - f"AUC metric is not supported for {type_of_target(y_true_final)} targets." + f"AUC metric is not supported for {self._type_of_target} targets." ) stat = metric_func(y_true_final, posterior_final, **metric_kwargs) diff --git a/sktree/stats/permutationforest.py b/sktree/stats/permutationforest.py index b51a182bb..026b89eca 100644 --- a/sktree/stats/permutationforest.py +++ b/sktree/stats/permutationforest.py @@ -16,10 +16,12 @@ class BasePermutationForest(MetaEstimatorMixin): def __init__( self, estimator=None, + test_size=0.2, random_state=None, verbose=0, ): self.estimator = estimator + self.test_size = test_size self.random_state = random_state self.verbose = verbose @@ -34,6 +36,27 @@ def reset(self): def _get_estimator(self): pass + @property + def train_test_samples_(self): + """ + The subset of drawn samples for each base estimator. + + Returns a dynamically generated list of indices identifying + the samples used for fitting each member of the ensemble, i.e., + the in-bag samples. + + Note: the list is re-created at each call to the property in order + to reduce the object memory footprint by not storing the sampling + data. Thus fetching the property may be slower than expected. + """ + indices = np.arange(self._n_samples_, dtype=int) + + # Get drawn indices along both sample and feature axes + indices_train, indices_test = train_test_split( + indices, test_size=self.test_size, shuffle=True, random_state=self.random_state + ) + return indices_train, indices_test + def _statistic( self, estimator: BaseForest, @@ -51,25 +74,27 @@ def _statistic( rng = np.random.default_rng(self.random_state) else: rng = np.random.default_rng(seed) - n_samples = X.shape[0] - indices = np.arange(n_samples, dtype=int) - + indices_train, indices_test = self.train_test_samples_ if covariate_index is not None: + n_samples = X.shape[0] + indices = np.arange(n_samples, dtype=int) # perform permutation of covariates - index_arr = rng.choice(indices, size=(X.shape[0], 1), replace=False, shuffle=False) + index_arr = rng.choice(indices, size=(n_samples, 1), replace=False, shuffle=False) X = X.copy() X[:, covariate_index] = X[index_arr, covariate_index] - X_train, X_test = X[self.indices_train_, :], X[self.indices_test_, :] - y_train, y_test = y[self.indices_train_, :], y[self.indices_test_, :] - - estimator.fit(X_train, y_train.ravel()) + X_train, X_test = X[indices_train, :], X[indices_test, :] + y_train, y_test = y[indices_train, :], y[indices_test, :] + if y_train.shape[1] == 1: + y_train = y_train.ravel() + y_test = y_test.ravel() + estimator.fit(X_train, y_train) # Either get the predicted value, or the posterior probabilities y_pred = estimator.predict(X_test) # set variables to compute metric - samples = self.indices_test_ + samples = indices_test y_true_final = y_test posterior_final = y_pred @@ -79,7 +104,7 @@ def _statistic( # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) # arrays of y and predicted posterior self.samples_ = samples - self.y_true_final_ = y_true_final + self.y_true_ = y_true_final self.posterior_final_ = posterior_final self.stat_ = stat @@ -139,6 +164,7 @@ def statistic( if y.ndim != 2: y = y.reshape(-1, 1) + self._n_samples_ = X.shape[0] self.estimator_ = self._get_estimator() if is_classifier(self.estimator_): @@ -173,7 +199,6 @@ def test( y: ArrayLike, covariate_index: ArrayLike, metric: str = "mse", - test_size: float = 0.2, n_repeats: int = 1000, return_posteriors: bool = False, **metric_kwargs, @@ -210,14 +235,11 @@ def test( X, y = check_X_y(X, y, ensure_2d=True, copy=True, multi_output=True) if y.ndim != 2: y = y.reshape(-1, 1) - - indices = np.arange(X.shape[0]) + self._n_samples_ = X.shape[0] # train/test split # XXX: could add stratifying by y when y is classification - indices_train, indices_test = train_test_split(indices, test_size=test_size, shuffle=True) - self.indices_train_ = indices_train - self.indices_test_ = indices_test + indices_train, indices_test = self.train_test_samples_ if not hasattr(self, "samples_"): # first compute the test statistic on the un-permuted data @@ -238,10 +260,10 @@ def test( # compute null distribution of the test statistic # WARNING: this could take a long time, since it fits a new forest null_dist = _compute_null_distribution_perm( - X_train=X[self.indices_train_, :], - y_train=y[self.indices_train_, :], - X_test=X[self.indices_test_, :], - y_test=y[self.indices_test_, :], + X_train=X[indices_train, :], + y_train=y[indices_train, :], + X_test=X[indices_test, :], + y_test=y[indices_test, :], covariate_index=covariate_index, est=self.estimator_, metric=metric, @@ -283,6 +305,9 @@ class PermutationForestRegressor(BasePermutationForest): Type of forest estimator to use. By default `None`, which defaults to :class:`sklearn.ensemble.RandomForestRegressor` with default parameters. + test_size : float, default=0.2 + The proportion of samples to leave out for each tree to compute metric on. + random_state : int, RandomState instance or None, default=None Controls both the randomness of the bootstrapping of the samples used when building trees (if ``bootstrap=True``) and the sampling of the @@ -315,11 +340,13 @@ class PermutationForestRegressor(BasePermutationForest): def __init__( self, estimator=None, + test_size=0.2, random_state=None, verbose=0, ): super().__init__( estimator=estimator, + test_size=test_size, random_state=random_state, verbose=verbose, ) @@ -357,6 +384,9 @@ class PermutationForestClassifier(BasePermutationForest): Type of forest estimator to use. By default `None`, which defaults to :class:`sklearn.ensemble.RandomForestClassifier`. + test_size : float, default=0.2 + The proportion of samples to leave out for each tree to compute metric on. + n_jobs : int, default=None The number of jobs to run in parallel. @@ -392,11 +422,13 @@ class PermutationForestClassifier(BasePermutationForest): def __init__( self, estimator=None, + test_size=0.2, random_state=None, verbose=0, ): super().__init__( estimator=estimator, + test_size=test_size, random_state=random_state, verbose=verbose, ) diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 3366dc1ea..9f5f0f384 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -62,9 +62,9 @@ "permute_per_tree": True, "sample_dataset_per_tree": True, }, - 300, - 500, - 0.1, + 300, # n_samples + 500, # n_repeats + 0.1, # test_size ], ], ) @@ -94,24 +94,22 @@ def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size) # compute final y of (n_samples,) y = beta * X[:, 0] + (beta * (X[:, 5] == 2.0)) + epsilon - est = hypotester(**model_kwargs) + est = hypotester(test_size=test_size, **model_kwargs) # test for X_1 - stat, pvalue = est.test(X, y, [0], metric=metric, test_size=test_size, n_repeats=n_repeats) + stat, pvalue = est.test(X, y, [0], metric=metric, n_repeats=n_repeats) print("X1: ", pvalue) assert pvalue < 0.05, f"pvalue: {pvalue}" # test for X_6 - stat, pvalue = est.test(X, y, [5], metric=metric, test_size=test_size, n_repeats=n_repeats) + stat, pvalue = est.test(X, y, [5], metric=metric, n_repeats=n_repeats) print("X6: ", pvalue) assert pvalue < 0.05, f"pvalue: {pvalue}" # test for a few unimportant other X for covariate_index in [1, 6]: # test for X_2, X_7 - stat, pvalue = est.test( - X, y, [covariate_index], metric=metric, test_size=test_size, n_repeats=n_repeats - ) + stat, pvalue = est.test(X, y, [covariate_index], metric=metric, n_repeats=n_repeats) print("X2/7: ", pvalue) assert pvalue > 0.05, f"pvalue: {pvalue}" @@ -188,26 +186,20 @@ def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, assert y_proba.shape == (n_samples,) y = rng.binomial(1, y_proba, size=n_samples) # .reshape(-1, 1) - est = hypotester(**model_kwargs) + est = hypotester(test_size=test_size, **model_kwargs) # test for X_2 important - stat, pvalue = est.test( - X.copy(), y.copy(), [1], test_size=test_size, n_repeats=n_repeats, metric=metric - ) + stat, pvalue = est.test(X.copy(), y.copy(), [1], n_repeats=n_repeats, metric=metric) print("X2: ", pvalue) assert pvalue < 0.05, f"pvalue: {pvalue}" # test for X_1 unimportant - stat, pvalue = est.test( - X.copy(), y.copy(), [0], test_size=test_size, n_repeats=n_repeats, metric=metric - ) + stat, pvalue = est.test(X.copy(), y.copy(), [0], n_repeats=n_repeats, metric=metric) print("X1: ", pvalue) assert pvalue > 0.05, f"pvalue: {pvalue}" # test for X_500 unimportant - stat, pvalue = est.test( - X.copy(), y.copy(), [n - 1], test_size=test_size, n_repeats=n_repeats, metric=metric - ) + stat, pvalue = est.test(X.copy(), y.copy(), [n - 1], n_repeats=n_repeats, metric=metric) print("X500: ", pvalue) assert pvalue > 0.05, f"pvalue: {pvalue}" @@ -228,6 +220,7 @@ def test_iris_pauc_statistic(criterion, honest_prior, estimator, limit): max_features = "sqrt" n_repeats = 200 n_estimators = 100 + test_size = 0.1 # Check consistency on dataset iris. clf = FeatureImportanceForestClassifier( @@ -240,6 +233,7 @@ def test_iris_pauc_statistic(criterion, honest_prior, estimator, limit): random_state=0, n_jobs=-1, ), + test_size=test_size, sample_dataset_per_tree=True, permute_per_tree=True, ) @@ -247,23 +241,19 @@ def test_iris_pauc_statistic(criterion, honest_prior, estimator, limit): X = np.hstack((iris_X, rng.standard_normal(size=(iris_X.shape[0], 4)))) # test for unimportant feature set - test_size = 0.1 clf.reset() stat, pvalue = clf.test( X, iris_y, np.arange(iris_X.shape[0], X.shape[1], dtype=int).tolist(), n_repeats=n_repeats, - test_size=test_size, metric="auc", ) print(pvalue) assert pvalue > 0.05, f"pvalue: {pvalue}" # test for important features that are permuted - stat, pvalue = clf.test( - X, iris_y, [0, 1, 2, 3], n_repeats=n_repeats, test_size=test_size, metric="auc" - ) + stat, pvalue = clf.test(X, iris_y, [0, 1, 2, 3], n_repeats=n_repeats, metric="auc") print(pvalue) assert pvalue < 0.05, f"pvalue: {pvalue}" From 2fa68cea2353ca72043aaff4bb30b223cb4a6762 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 19 Sep 2023 16:02:04 -0400 Subject: [PATCH 27/70] Working clean code Signed-off-by: Adam Li --- .spin/cmds.py | 1 - .../test_permutation_forest.ipynb | 258 +++--------------- sktree/stats/forestht.py | 6 +- 3 files changed, 33 insertions(+), 232 deletions(-) diff --git a/.spin/cmds.py b/.spin/cmds.py index 30380208d..5b8585dde 100644 --- a/.spin/cmds.py +++ b/.spin/cmds.py @@ -36,7 +36,6 @@ def docs(ctx, build_dir, clean=False, noplot=False): @click.command() -@click.option("--runslow", help="Run slow tests.") @click.pass_context def coverage(ctx): """📊 Generate coverage report""" diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/test_permutation_forest.ipynb index e8859626e..3ef50202d 100644 --- a/benchmarks_nonasv/test_permutation_forest.ipynb +++ b/benchmarks_nonasv/test_permutation_forest.ipynb @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "5e2d1279-fa4f-47ef-aa48-fac6d47159ad", "metadata": {}, "outputs": [], @@ -88,6 +88,7 @@ " RandomForestRegressor(\n", " max_features=1.0, random_state=seed, n_estimators=n_estimators, n_jobs=-1\n", " ),\n", + " test_size=test_size,\n", " random_state=seed,\n", " permute_per_tree=permute_per_tree,\n", " sample_dataset_per_tree=sample_dataset_per_tree,\n", @@ -96,7 +97,7 @@ "\n", " # test for X_1\n", " stat, pvalue = est.test(\n", - " X.copy(), y.copy(), [0], metric=metric, n_repeats=n_repeats, test_size=test_size\n", + " X.copy(), y.copy(), [0], metric=metric, n_repeats=n_repeats\n", " )\n", " print(\"X1: \", pvalue)\n", " pvalue_dict[\"X1\"] = pvalue\n", @@ -104,7 +105,7 @@ "\n", " # test for X_6\n", " stat, pvalue = est.test(\n", - " X.copy(), y.copy(), [5], metric=metric, n_repeats=n_repeats, test_size=test_size\n", + " X.copy(), y.copy(), [5], metric=metric, n_repeats=n_repeats\n", " )\n", " print(\"X6: \", pvalue)\n", " pvalue_dict[\"X6\"] = pvalue\n", @@ -119,7 +120,6 @@ " [covariate_index],\n", " metric=metric,\n", " n_repeats=n_repeats,\n", - " test_size=test_size,\n", " )\n", " print(\"X2/7: \", pvalue)\n", " pvalue_dict[name] = pvalue\n", @@ -138,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "3db4f740-afd9-413e-8089-a8245f2a0747", "metadata": {}, "outputs": [], @@ -196,6 +196,7 @@ " n_jobs=-1,\n", " ),\n", " random_state=seed,\n", + " test_size=test_size,\n", " permute_per_tree=permute_per_tree,\n", " sample_dataset_per_tree=sample_dataset_per_tree,\n", " )\n", @@ -205,7 +206,6 @@ " X.copy(),\n", " y.copy(),\n", " covariate_index=[1],\n", - " test_size=test_size,\n", " n_repeats=n_repeats,\n", " metric=metric,\n", " )\n", @@ -215,7 +215,7 @@ "\n", " # test for X_1 unimportant\n", " stat, pvalue = est.test(\n", - " X.copy(), y.copy(), [0], test_size=test_size, n_repeats=n_repeats, metric=metric\n", + " X.copy(), y.copy(), [0], n_repeats=n_repeats, metric=metric\n", " )\n", " pvalue_dict[\"X1\"] = pvalue\n", " print(\"X1: \", pvalue)\n", @@ -226,7 +226,6 @@ " X.copy(),\n", " y.copy(),\n", " [n - 1],\n", - " test_size=test_size,\n", " n_repeats=n_repeats,\n", " metric=metric,\n", " )\n", @@ -614,82 +613,14 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 29, "id": "a2aed8f0-1230-4128-ad77-d84764c28d0d", - "metadata": { - "scrolled": true - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", "X2: 0.004975124378109453\n", "X1: 0.004975124378109453\n", "X500: 0.004975124378109453\n", @@ -699,156 +630,28 @@ "X2: 0.004975124378109453\n", "X1: 1.0\n", "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n" + "X1: 1.0\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[29], line 10\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m5\u001b[39m):\n\u001b[1;32m 8\u001b[0m new_seed \u001b[38;5;241m=\u001b[39m rng\u001b[38;5;241m.\u001b[39mintegers(\u001b[38;5;241m0\u001b[39m, np\u001b[38;5;241m.\u001b[39miinfo(np\u001b[38;5;241m.\u001b[39muint32)\u001b[38;5;241m.\u001b[39mmax, dtype\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39muint32)\n\u001b[0;32m---> 10\u001b[0m elements_dict \u001b[38;5;241m=\u001b[39m \u001b[43mcorrelated_logit_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbeta\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnew_seed\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m key, value \u001b[38;5;129;01min\u001b[39;00m elements_dict\u001b[38;5;241m.\u001b[39mitems():\n\u001b[1;32m 12\u001b[0m pvalue_dict[key]\u001b[38;5;241m.\u001b[39mappend(value)\n", + "Cell \u001b[0;32mIn[18], line 80\u001b[0m, in \u001b[0;36mcorrelated_logit_model\u001b[0;34m(beta, seed)\u001b[0m\n\u001b[1;32m 76\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mX1: \u001b[39m\u001b[38;5;124m\"\u001b[39m, pvalue)\n\u001b[1;32m 77\u001b[0m \u001b[38;5;66;03m# assert pvalue > 0.05, f\"pvalue: {pvalue}\"\u001b[39;00m\n\u001b[1;32m 78\u001b[0m \n\u001b[1;32m 79\u001b[0m \u001b[38;5;66;03m# test for X_500 unimportant\u001b[39;00m\n\u001b[0;32m---> 80\u001b[0m stat, pvalue \u001b[38;5;241m=\u001b[39m \u001b[43mest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtest\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 81\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 82\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 83\u001b[0m \u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mn\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 84\u001b[0m \u001b[43m \u001b[49m\u001b[43mtest_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtest_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 85\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_repeats\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_repeats\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 86\u001b[0m \u001b[43m \u001b[49m\u001b[43mmetric\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmetric\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 87\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 88\u001b[0m pvalue_dict[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mX500\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m pvalue\n\u001b[1;32m 89\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mX500: \u001b[39m\u001b[38;5;124m\"\u001b[39m, pvalue)\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/stats/forestht.py:297\u001b[0m, in \u001b[0;36mBaseForestHT.test\u001b[0;34m(self, X, y, covariate_index, metric, test_size, n_repeats, return_posteriors, **metric_kwargs)\u001b[0m\n\u001b[1;32m 294\u001b[0m observe_stat \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstat_\n\u001b[1;32m 296\u001b[0m \u001b[38;5;66;03m# next permute the data\u001b[39;00m\n\u001b[0;32m--> 297\u001b[0m permute_stat, permute_posteriors, permute_samples \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstatistic\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 298\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 299\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 300\u001b[0m \u001b[43m \u001b[49m\u001b[43mcovariate_index\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcovariate_index\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 301\u001b[0m \u001b[43m \u001b[49m\u001b[43mmetric\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmetric\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 302\u001b[0m \u001b[43m \u001b[49m\u001b[43mreturn_posteriors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 303\u001b[0m \u001b[43m \u001b[49m\u001b[43mcheck_input\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 304\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmetric_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 305\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 307\u001b[0m \u001b[38;5;66;03m# Note: at this point, both `estimator` and `permuted_estimator_` should\u001b[39;00m\n\u001b[1;32m 308\u001b[0m \u001b[38;5;66;03m# have been fitted already, so we can now compute on the null by resampling\u001b[39;00m\n\u001b[1;32m 309\u001b[0m \u001b[38;5;66;03m# the posteriors and computing the test statistic on the resampled posteriors\u001b[39;00m\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msample_dataset_per_tree:\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/stats/forestht.py:211\u001b[0m, in \u001b[0;36mBaseForestHT.statistic\u001b[0;34m(self, X, y, covariate_index, metric, return_posteriors, check_input, **metric_kwargs)\u001b[0m\n\u001b[1;32m 208\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m estimator\u001b[38;5;241m.\u001b[39mn_outputs_ \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m metric \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mauc\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAUC metric is not supported for multi-output\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m--> 211\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_statistic\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 212\u001b[0m \u001b[43m \u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 213\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 214\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 215\u001b[0m \u001b[43m \u001b[49m\u001b[43mcovariate_index\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcovariate_index\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 216\u001b[0m \u001b[43m \u001b[49m\u001b[43mmetric\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmetric\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 217\u001b[0m \u001b[43m \u001b[49m\u001b[43mreturn_posteriors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreturn_posteriors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 218\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmetric_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 219\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/stats/forestht.py:662\u001b[0m, in \u001b[0;36mFeatureImportanceForestClassifier._statistic\u001b[0;34m(self, estimator, X, y, covariate_index, metric, return_posteriors, **metric_kwargs)\u001b[0m\n\u001b[1;32m 660\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx, (indices_train, indices_test) \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_estimators_indices()):\n\u001b[1;32m 661\u001b[0m tree: DecisionTreeClassifier \u001b[38;5;241m=\u001b[39m estimator\u001b[38;5;241m.\u001b[39mestimators_[idx]\n\u001b[0;32m--> 662\u001b[0m \u001b[43mtrain_tree\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtree\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindices_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindices_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcovariate_index\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 664\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m predict_posteriors:\n\u001b[1;32m 665\u001b[0m \u001b[38;5;66;03m# XXX: currently assumes n_outputs_ == 1\u001b[39;00m\n\u001b[1;32m 666\u001b[0m y_pred \u001b[38;5;241m=\u001b[39m tree\u001b[38;5;241m.\u001b[39mpredict_proba(X[indices_test, :])\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/stats/utils.py:72\u001b[0m, in \u001b[0;36mtrain_tree\u001b[0;34m(tree, X, y, covariate_index)\u001b[0m\n\u001b[1;32m 69\u001b[0m X[:, covariate_index] \u001b[38;5;241m=\u001b[39m perm_X_cov\n\u001b[1;32m 71\u001b[0m \u001b[38;5;66;03m# individual tree permutation of y labels\u001b[39;00m\n\u001b[0;32m---> 72\u001b[0m \u001b[43mtree\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcheck_input\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151\u001b[0m, in \u001b[0;36m_fit_context..decorator..wrapper\u001b[0;34m(estimator, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1144\u001b[0m estimator\u001b[38;5;241m.\u001b[39m_validate_params()\n\u001b[1;32m 1146\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m config_context(\n\u001b[1;32m 1147\u001b[0m skip_parameter_validation\u001b[38;5;241m=\u001b[39m(\n\u001b[1;32m 1148\u001b[0m prefer_skip_nested_validation \u001b[38;5;129;01mor\u001b[39;00m global_skip_validation\n\u001b[1;32m 1149\u001b[0m )\n\u001b[1;32m 1150\u001b[0m ):\n\u001b[0;32m-> 1151\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfit_method\u001b[49m\u001b[43m(\u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/_lib/./sklearn/tree/_classes.py:1270\u001b[0m, in \u001b[0;36mDecisionTreeClassifier.fit\u001b[0;34m(self, X, y, sample_weight, check_input, classes)\u001b[0m\n\u001b[1;32m 1230\u001b[0m \u001b[38;5;129m@_fit_context\u001b[39m(prefer_skip_nested_validation\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 1231\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfit\u001b[39m(\n\u001b[1;32m 1232\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1237\u001b[0m classes\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 1238\u001b[0m ):\n\u001b[1;32m 1239\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Build a decision tree classifier from the training set (X, y).\u001b[39;00m\n\u001b[1;32m 1240\u001b[0m \n\u001b[1;32m 1241\u001b[0m \u001b[38;5;124;03m Parameters\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1268\u001b[0m \u001b[38;5;124;03m Fitted estimator.\u001b[39;00m\n\u001b[1;32m 1269\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1270\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_fit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1271\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1272\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1273\u001b[0m \u001b[43m \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msample_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1274\u001b[0m \u001b[43m \u001b[49m\u001b[43mcheck_input\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcheck_input\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1275\u001b[0m \u001b[43m \u001b[49m\u001b[43mclasses\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mclasses\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1276\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1277\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/_lib/./sklearn/tree/_classes.py:421\u001b[0m, in \u001b[0;36mBaseDecisionTree._fit\u001b[0;34m(self, X, y, sample_weight, check_input, missing_values_in_feature_mask, classes)\u001b[0m\n\u001b[1;32m 418\u001b[0m min_weight_leaf \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmin_weight_fraction_leaf \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39msum(sample_weight)\n\u001b[1;32m 420\u001b[0m \u001b[38;5;66;03m# build the actual tree now with the parameters\u001b[39;00m\n\u001b[0;32m--> 421\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_build_tree\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 422\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 423\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 424\u001b[0m \u001b[43m \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msample_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 425\u001b[0m \u001b[43m \u001b[49m\u001b[43mmissing_values_in_feature_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmissing_values_in_feature_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 426\u001b[0m \u001b[43m \u001b[49m\u001b[43mmin_samples_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmin_samples_leaf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 427\u001b[0m \u001b[43m \u001b[49m\u001b[43mmin_weight_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmin_weight_leaf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 428\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_leaf_nodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_leaf_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 429\u001b[0m \u001b[43m \u001b[49m\u001b[43mmin_samples_split\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmin_samples_split\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 430\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_depth\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_depth\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 431\u001b[0m \u001b[43m \u001b[49m\u001b[43mrandom_state\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrandom_state\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 432\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 434\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/_lib/./sklearn/tree/_classes.py:572\u001b[0m, in \u001b[0;36mBaseDecisionTree._build_tree\u001b[0;34m(self, X, y, sample_weight, missing_values_in_feature_mask, min_samples_leaf, min_weight_leaf, max_leaf_nodes, min_samples_split, max_depth, random_state)\u001b[0m\n\u001b[1;32m 561\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 562\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbuilder_ \u001b[38;5;241m=\u001b[39m BestFirstTreeBuilder(\n\u001b[1;32m 563\u001b[0m splitter,\n\u001b[1;32m 564\u001b[0m min_samples_split,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 570\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstore_leaf_values,\n\u001b[1;32m 571\u001b[0m )\n\u001b[0;32m--> 572\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbuilder_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbuild\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 573\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtree_\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmissing_values_in_feature_mask\u001b[49m\n\u001b[1;32m 574\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 576\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_outputs_ \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m is_classifier(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 577\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_classes_ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_classes_[\u001b[38;5;241m0\u001b[39m]\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], @@ -857,6 +660,7 @@ "rng = np.random.default_rng(seed)\n", "\n", "beta_space = np.hstack((np.linspace(0.01, 2.5, 8), np.linspace(5, 20, 7)))\n", + "beta_space = j_space.copy()\n", "for beta in beta_space:\n", " for idx in range(5):\n", " new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32)\n", diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 9393ec91f..67c20a89e 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -178,12 +178,12 @@ def statistic( for axis in range(y.shape[1]): _unique_y.append(np.unique(y[:, axis])) unique_y = np.hstack(_unique_y) - if unique_y.shape[1] == 1: + if unique_y.ndim > 1 and unique_y.shape[1] == 1: unique_y = unique_y.ravel() X_dummy = np.zeros((unique_y.shape[0], X.shape[1])) estimator.fit(X_dummy, unique_y) elif not _is_fitted(estimator): - if y.shape[1] == 1: + if y.ndim > 1 and y.shape[1] == 1: estimator.fit(X[:2], y[:2].ravel()) else: estimator.fit(X[:2], y[:2]) @@ -475,7 +475,6 @@ def _statistic( y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) # Fill test set posteriors & set rest NaN - print(posterior_arr.shape, y_pred.shape) posterior_arr[idx, indices_test, :] = y_pred # posterior y_true_final = y[indices_test, :] @@ -669,7 +668,6 @@ def _statistic( y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) # Fill test set posteriors & set rest NaN - print(posterior_arr.shape, y_pred.shape) posterior_arr[idx, indices_test, :] = y_pred # posterior # Average all posteriors (n_samples_test, n_outputs) From 7fbdd3813945cafb65372545900ff84e2fcaed6f Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 19 Sep 2023 16:02:57 -0400 Subject: [PATCH 28/70] Working clean code Signed-off-by: Adam Li --- .../test_permutation_forest.ipynb | 31 ++++++++++--------- sktree/stats/forestht.py | 7 ----- 2 files changed, 17 insertions(+), 21 deletions(-) diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/test_permutation_forest.ipynb index 3ef50202d..ebf09d426 100644 --- a/benchmarks_nonasv/test_permutation_forest.ipynb +++ b/benchmarks_nonasv/test_permutation_forest.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 15, + "execution_count": 30, "id": "b658bdd8-a3e6-4051-9d66-f2a153113234", "metadata": {}, "outputs": [], @@ -27,10 +27,19 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 31, "id": "05b0b53e-0525-45ce-9f7e-0322a30221cf", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "%load_ext autoreload\n", "%autoreload 2" @@ -38,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "id": "5e2d1279-fa4f-47ef-aa48-fac6d47159ad", "metadata": {}, "outputs": [], @@ -96,17 +105,13 @@ " pvalue_dict = {}\n", "\n", " # test for X_1\n", - " stat, pvalue = est.test(\n", - " X.copy(), y.copy(), [0], metric=metric, n_repeats=n_repeats\n", - " )\n", + " stat, pvalue = est.test(X.copy(), y.copy(), [0], metric=metric, n_repeats=n_repeats)\n", " print(\"X1: \", pvalue)\n", " pvalue_dict[\"X1\"] = pvalue\n", " # assert pvalue < 0.05, f\"pvalue: {pvalue}\"\n", "\n", " # test for X_6\n", - " stat, pvalue = est.test(\n", - " X.copy(), y.copy(), [5], metric=metric, n_repeats=n_repeats\n", - " )\n", + " stat, pvalue = est.test(X.copy(), y.copy(), [5], metric=metric, n_repeats=n_repeats)\n", " print(\"X6: \", pvalue)\n", " pvalue_dict[\"X6\"] = pvalue\n", " # assert pvalue < 0.05, f\"pvalue: {pvalue}\"\n", @@ -138,7 +143,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "id": "3db4f740-afd9-413e-8089-a8245f2a0747", "metadata": {}, "outputs": [], @@ -214,9 +219,7 @@ " # assert pvalue < 0.05, f\"pvalue: {pvalue}\"\n", "\n", " # test for X_1 unimportant\n", - " stat, pvalue = est.test(\n", - " X.copy(), y.copy(), [0], n_repeats=n_repeats, metric=metric\n", - " )\n", + " stat, pvalue = est.test(X.copy(), y.copy(), [0], n_repeats=n_repeats, metric=metric)\n", " pvalue_dict[\"X1\"] = pvalue\n", " print(\"X1: \", pvalue)\n", " # assert pvalue > 0.05, f\"pvalue: {pvalue}\"\n", diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 67c20a89e..df37c7b62 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -224,7 +224,6 @@ def test( y, covariate_index: ArrayLike, metric: str = "mse", - test_size: float = 0.2, n_repeats: int = 1000, return_posteriors: bool = False, **metric_kwargs, @@ -271,12 +270,6 @@ def test( if y.ndim != 2: y = y.reshape(-1, 1) - # indices = np.arange(X.shape[0]) - # self.test_size_ = int(test_size * X.shape[0]) - # indices_train, indices_test = train_test_split(indices, test_size=test_size, shuffle=True) - # self.indices_train_ = indices_train - # self.indices_test_ = indices_test - if not hasattr(self, "samples_"): # first compute the test statistic on the un-permuted data observe_stat, observe_posteriors, observe_samples = self.statistic( From 918f9348da7b338b51d787be7a9855234d758c01 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 19 Sep 2023 16:15:11 -0400 Subject: [PATCH 29/70] Working clean code Signed-off-by: Adam Li --- .../test_permutation_forest.ipynb | 175 ++++-------------- sktree/stats/tests/test_forestht.py | 2 +- 2 files changed, 33 insertions(+), 144 deletions(-) diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/test_permutation_forest.ipynb index ebf09d426..779347c0d 100644 --- a/benchmarks_nonasv/test_permutation_forest.ipynb +++ b/benchmarks_nonasv/test_permutation_forest.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 30, + "execution_count": 1, "id": "b658bdd8-a3e6-4051-9d66-f2a153113234", "metadata": {}, "outputs": [], @@ -27,19 +27,10 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 2, "id": "05b0b53e-0525-45ce-9f7e-0322a30221cf", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "%load_ext autoreload\n", "%autoreload 2" @@ -47,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 3, "id": "5e2d1279-fa4f-47ef-aa48-fac6d47159ad", "metadata": {}, "outputs": [], @@ -143,7 +134,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 4, "id": "3db4f740-afd9-413e-8089-a8245f2a0747", "metadata": {}, "outputs": [], @@ -597,7 +588,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 6, "id": "36c53ff3-984d-4428-87c1-3421098e0081", "metadata": {}, "outputs": [ @@ -611,12 +602,13 @@ } ], "source": [ + "j_space = np.linspace(0.005, 2.25, 9)\n", "print(j_space)" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "id": "a2aed8f0-1230-4128-ad77-d84764c28d0d", "metadata": {}, "outputs": [ @@ -626,35 +618,31 @@ "text": [ "X2: 0.004975124378109453\n", "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", + "X500: 1.0\n", "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 1.0\n", "X1: 1.0\n", "X500: 1.0\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", "X2: 0.004975124378109453\n", "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", "X500: 0.004975124378109453\n", "X2: 1.0\n", - "X1: 1.0\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[29], line 10\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m5\u001b[39m):\n\u001b[1;32m 8\u001b[0m new_seed \u001b[38;5;241m=\u001b[39m rng\u001b[38;5;241m.\u001b[39mintegers(\u001b[38;5;241m0\u001b[39m, np\u001b[38;5;241m.\u001b[39miinfo(np\u001b[38;5;241m.\u001b[39muint32)\u001b[38;5;241m.\u001b[39mmax, dtype\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39muint32)\n\u001b[0;32m---> 10\u001b[0m elements_dict \u001b[38;5;241m=\u001b[39m \u001b[43mcorrelated_logit_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbeta\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnew_seed\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m key, value \u001b[38;5;129;01min\u001b[39;00m elements_dict\u001b[38;5;241m.\u001b[39mitems():\n\u001b[1;32m 12\u001b[0m pvalue_dict[key]\u001b[38;5;241m.\u001b[39mappend(value)\n", - "Cell \u001b[0;32mIn[18], line 80\u001b[0m, in \u001b[0;36mcorrelated_logit_model\u001b[0;34m(beta, seed)\u001b[0m\n\u001b[1;32m 76\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mX1: \u001b[39m\u001b[38;5;124m\"\u001b[39m, pvalue)\n\u001b[1;32m 77\u001b[0m \u001b[38;5;66;03m# assert pvalue > 0.05, f\"pvalue: {pvalue}\"\u001b[39;00m\n\u001b[1;32m 78\u001b[0m \n\u001b[1;32m 79\u001b[0m \u001b[38;5;66;03m# test for X_500 unimportant\u001b[39;00m\n\u001b[0;32m---> 80\u001b[0m stat, pvalue \u001b[38;5;241m=\u001b[39m \u001b[43mest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtest\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 81\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 82\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 83\u001b[0m \u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mn\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 84\u001b[0m \u001b[43m \u001b[49m\u001b[43mtest_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtest_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 85\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_repeats\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_repeats\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 86\u001b[0m \u001b[43m \u001b[49m\u001b[43mmetric\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmetric\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 87\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 88\u001b[0m pvalue_dict[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mX500\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m pvalue\n\u001b[1;32m 89\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mX500: \u001b[39m\u001b[38;5;124m\"\u001b[39m, pvalue)\n", - "File \u001b[0;32m~/Documents/scikit-tree/sktree/stats/forestht.py:297\u001b[0m, in \u001b[0;36mBaseForestHT.test\u001b[0;34m(self, X, y, covariate_index, metric, test_size, n_repeats, return_posteriors, **metric_kwargs)\u001b[0m\n\u001b[1;32m 294\u001b[0m observe_stat \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstat_\n\u001b[1;32m 296\u001b[0m \u001b[38;5;66;03m# next permute the data\u001b[39;00m\n\u001b[0;32m--> 297\u001b[0m permute_stat, permute_posteriors, permute_samples \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstatistic\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 298\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 299\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 300\u001b[0m \u001b[43m \u001b[49m\u001b[43mcovariate_index\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcovariate_index\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 301\u001b[0m \u001b[43m \u001b[49m\u001b[43mmetric\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmetric\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 302\u001b[0m \u001b[43m \u001b[49m\u001b[43mreturn_posteriors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 303\u001b[0m \u001b[43m \u001b[49m\u001b[43mcheck_input\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 304\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmetric_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 305\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 307\u001b[0m \u001b[38;5;66;03m# Note: at this point, both `estimator` and `permuted_estimator_` should\u001b[39;00m\n\u001b[1;32m 308\u001b[0m \u001b[38;5;66;03m# have been fitted already, so we can now compute on the null by resampling\u001b[39;00m\n\u001b[1;32m 309\u001b[0m \u001b[38;5;66;03m# the posteriors and computing the test statistic on the resampled posteriors\u001b[39;00m\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msample_dataset_per_tree:\n", - "File \u001b[0;32m~/Documents/scikit-tree/sktree/stats/forestht.py:211\u001b[0m, in \u001b[0;36mBaseForestHT.statistic\u001b[0;34m(self, X, y, covariate_index, metric, return_posteriors, check_input, **metric_kwargs)\u001b[0m\n\u001b[1;32m 208\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m estimator\u001b[38;5;241m.\u001b[39mn_outputs_ \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m metric \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mauc\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAUC metric is not supported for multi-output\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m--> 211\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_statistic\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 212\u001b[0m \u001b[43m \u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 213\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 214\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 215\u001b[0m \u001b[43m \u001b[49m\u001b[43mcovariate_index\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcovariate_index\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 216\u001b[0m \u001b[43m \u001b[49m\u001b[43mmetric\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmetric\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 217\u001b[0m \u001b[43m \u001b[49m\u001b[43mreturn_posteriors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreturn_posteriors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 218\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmetric_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 219\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/Documents/scikit-tree/sktree/stats/forestht.py:662\u001b[0m, in \u001b[0;36mFeatureImportanceForestClassifier._statistic\u001b[0;34m(self, estimator, X, y, covariate_index, metric, return_posteriors, **metric_kwargs)\u001b[0m\n\u001b[1;32m 660\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx, (indices_train, indices_test) \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_estimators_indices()):\n\u001b[1;32m 661\u001b[0m tree: DecisionTreeClassifier \u001b[38;5;241m=\u001b[39m estimator\u001b[38;5;241m.\u001b[39mestimators_[idx]\n\u001b[0;32m--> 662\u001b[0m \u001b[43mtrain_tree\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtree\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindices_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindices_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcovariate_index\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 664\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m predict_posteriors:\n\u001b[1;32m 665\u001b[0m \u001b[38;5;66;03m# XXX: currently assumes n_outputs_ == 1\u001b[39;00m\n\u001b[1;32m 666\u001b[0m y_pred \u001b[38;5;241m=\u001b[39m tree\u001b[38;5;241m.\u001b[39mpredict_proba(X[indices_test, :])\n", - "File \u001b[0;32m~/Documents/scikit-tree/sktree/stats/utils.py:72\u001b[0m, in \u001b[0;36mtrain_tree\u001b[0;34m(tree, X, y, covariate_index)\u001b[0m\n\u001b[1;32m 69\u001b[0m X[:, covariate_index] \u001b[38;5;241m=\u001b[39m perm_X_cov\n\u001b[1;32m 71\u001b[0m \u001b[38;5;66;03m# individual tree permutation of y labels\u001b[39;00m\n\u001b[0;32m---> 72\u001b[0m \u001b[43mtree\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcheck_input\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151\u001b[0m, in \u001b[0;36m_fit_context..decorator..wrapper\u001b[0;34m(estimator, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1144\u001b[0m estimator\u001b[38;5;241m.\u001b[39m_validate_params()\n\u001b[1;32m 1146\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m config_context(\n\u001b[1;32m 1147\u001b[0m skip_parameter_validation\u001b[38;5;241m=\u001b[39m(\n\u001b[1;32m 1148\u001b[0m prefer_skip_nested_validation \u001b[38;5;129;01mor\u001b[39;00m global_skip_validation\n\u001b[1;32m 1149\u001b[0m )\n\u001b[1;32m 1150\u001b[0m ):\n\u001b[0;32m-> 1151\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfit_method\u001b[49m\u001b[43m(\u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/Documents/scikit-tree/sktree/_lib/./sklearn/tree/_classes.py:1270\u001b[0m, in \u001b[0;36mDecisionTreeClassifier.fit\u001b[0;34m(self, X, y, sample_weight, check_input, classes)\u001b[0m\n\u001b[1;32m 1230\u001b[0m \u001b[38;5;129m@_fit_context\u001b[39m(prefer_skip_nested_validation\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 1231\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfit\u001b[39m(\n\u001b[1;32m 1232\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1237\u001b[0m classes\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 1238\u001b[0m ):\n\u001b[1;32m 1239\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Build a decision tree classifier from the training set (X, y).\u001b[39;00m\n\u001b[1;32m 1240\u001b[0m \n\u001b[1;32m 1241\u001b[0m \u001b[38;5;124;03m Parameters\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1268\u001b[0m \u001b[38;5;124;03m Fitted estimator.\u001b[39;00m\n\u001b[1;32m 1269\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1270\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_fit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1271\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1272\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1273\u001b[0m \u001b[43m \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msample_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1274\u001b[0m \u001b[43m \u001b[49m\u001b[43mcheck_input\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcheck_input\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1275\u001b[0m \u001b[43m \u001b[49m\u001b[43mclasses\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mclasses\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1276\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1277\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n", - "File \u001b[0;32m~/Documents/scikit-tree/sktree/_lib/./sklearn/tree/_classes.py:421\u001b[0m, in \u001b[0;36mBaseDecisionTree._fit\u001b[0;34m(self, X, y, sample_weight, check_input, missing_values_in_feature_mask, classes)\u001b[0m\n\u001b[1;32m 418\u001b[0m min_weight_leaf \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmin_weight_fraction_leaf \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39msum(sample_weight)\n\u001b[1;32m 420\u001b[0m \u001b[38;5;66;03m# build the actual tree now with the parameters\u001b[39;00m\n\u001b[0;32m--> 421\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_build_tree\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 422\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 423\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 424\u001b[0m \u001b[43m \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msample_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 425\u001b[0m \u001b[43m \u001b[49m\u001b[43mmissing_values_in_feature_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmissing_values_in_feature_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 426\u001b[0m \u001b[43m \u001b[49m\u001b[43mmin_samples_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmin_samples_leaf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 427\u001b[0m \u001b[43m \u001b[49m\u001b[43mmin_weight_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmin_weight_leaf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 428\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_leaf_nodes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_leaf_nodes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 429\u001b[0m \u001b[43m \u001b[49m\u001b[43mmin_samples_split\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmin_samples_split\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 430\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_depth\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_depth\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 431\u001b[0m \u001b[43m \u001b[49m\u001b[43mrandom_state\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrandom_state\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 432\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 434\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n", - "File \u001b[0;32m~/Documents/scikit-tree/sktree/_lib/./sklearn/tree/_classes.py:572\u001b[0m, in \u001b[0;36mBaseDecisionTree._build_tree\u001b[0;34m(self, X, y, sample_weight, missing_values_in_feature_mask, min_samples_leaf, min_weight_leaf, max_leaf_nodes, min_samples_split, max_depth, random_state)\u001b[0m\n\u001b[1;32m 561\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 562\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbuilder_ \u001b[38;5;241m=\u001b[39m BestFirstTreeBuilder(\n\u001b[1;32m 563\u001b[0m splitter,\n\u001b[1;32m 564\u001b[0m min_samples_split,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 570\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstore_leaf_values,\n\u001b[1;32m 571\u001b[0m )\n\u001b[0;32m--> 572\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbuilder_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbuild\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 573\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtree_\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmissing_values_in_feature_mask\u001b[49m\n\u001b[1;32m 574\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 576\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_outputs_ \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m is_classifier(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 577\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_classes_ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_classes_[\u001b[38;5;241m0\u001b[39m]\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n" ] } ], @@ -678,129 +666,30 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "id": "d3e21945-92b3-4ccc-8f29-b44f67d9cf33", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "done\n" - ] - } - ], + "outputs": [], "source": [ "print(\"done\")" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "id": "b2bced31-0367-48a8-88e1-0afd6a60173f", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
X2X1X500sigma_factor
01.01.0000001.0000000.01
11.01.0000001.0000000.01
21.00.0049750.0049750.01
31.01.0000001.0000000.01
41.00.0049750.0049750.01
\n", - "
" - ], - "text/plain": [ - " X2 X1 X500 sigma_factor\n", - "0 1.0 1.000000 1.000000 0.01\n", - "1 1.0 1.000000 1.000000 0.01\n", - "2 1.0 0.004975 0.004975 0.01\n", - "3 1.0 1.000000 1.000000 0.01\n", - "4 1.0 0.004975 0.004975 0.01" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "display(df.head())" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "id": "c4dbdaf1-9af7-4e6d-83b6-a9cabc18dc91", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axs = plt.subplots(3, 1, figsize=(8, 6), sharey=True, sharex=True)\n", "axs = axs.flatten()\n", diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 9f5f0f384..eca0b21c5 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -140,7 +140,7 @@ def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size) "estimator": RandomForestClassifier( max_features="sqrt", random_state=seed, - n_estimators=125, + n_estimators=150, n_jobs=-1, ), "random_state": seed, From bd02877c022faaa252b2a0fd1219e778b156f28f Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 19 Sep 2023 17:37:05 -0400 Subject: [PATCH 30/70] Fixed unit-tests Signed-off-by: Adam Li --- .../test_permutation_forest.ipynb | 227 +++++++++++++++++- sktree/stats/tests/test_forestht.py | 2 +- 2 files changed, 219 insertions(+), 10 deletions(-) diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/test_permutation_forest.ipynb index 779347c0d..e2dc525b7 100644 --- a/benchmarks_nonasv/test_permutation_forest.ipynb +++ b/benchmarks_nonasv/test_permutation_forest.ipynb @@ -608,9 +608,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "a2aed8f0-1230-4128-ad77-d84764c28d0d", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout", @@ -642,7 +644,115 @@ "X500: 1.0\n", "X2: 1.0\n", "X1: 0.004975124378109453\n", - "X500: 1.0\n" + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 1.0\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 1.0\n", + "X500: 1.0\n", + "X2: 0.004975124378109453\n", + "X1: 0.004975124378109453\n", + "X500: 0.004975124378109453\n" ] } ], @@ -666,30 +776,129 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "d3e21945-92b3-4ccc-8f29-b44f67d9cf33", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "done\n" + ] + } + ], "source": [ "print(\"done\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "b2bced31-0367-48a8-88e1-0afd6a60173f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
X2X1X500sigma_factor
00.0049750.0049751.0000000.005
10.0049750.0049751.0000000.005
21.0000001.0000001.0000000.005
31.0000000.0049751.0000000.005
41.0000001.0000000.0049750.005
\n", + "
" + ], + "text/plain": [ + " X2 X1 X500 sigma_factor\n", + "0 0.004975 0.004975 1.000000 0.005\n", + "1 0.004975 0.004975 1.000000 0.005\n", + "2 1.000000 1.000000 1.000000 0.005\n", + "3 1.000000 0.004975 1.000000 0.005\n", + "4 1.000000 1.000000 0.004975 0.005" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "display(df.head())" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "c4dbdaf1-9af7-4e6d-83b6-a9cabc18dc91", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2cAAAJQCAYAAAAKQxzEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXhTVf4/8HeSmz1N0pVCW0opKJuCFNkEcUERxBncUNQBdFzGBUHUURw3dBQdNxhccBnFQR3X0fHr+lMBF0DZUQTZLJSt+5I0+3J+f6QJTZuWdE2avl/Pw6NNTpKTm3vPvZ/7OYtMCCFAREREREREMSWPdQWIiIiIiIiIwRkREREREVFcYHBGREREREQUBxicERERERERxQEGZ0RERERERHGAwRkREREREVEcYHBGREREREQUBxicERERERERxQEGZ0RERERERHEg4YOz5cuXQyaTYf/+/bGuShiZTIYHH3ww1tWI6MEHH4RMJot1NdqkT58+mD17dqte25G/TUu2bbBseXl5h9SFiNrP6tWrIZPJsHr16pjVIVLbtWHDBowdOxZ6vR4ymQxbt26NSRt/00034ZxzzunUzyTqCG25voh3nXXNHK/X5u3p7rvvxqhRo1r12lYFZ/v27cMNN9yAvn37QqPRwGg04rTTTsOSJUvgcDhaVZF49NZbb2Hx4sUx+/z9+/dDJpPhySefjFkdgh599FF89NFHsa5GQuqobTt79mzIZLKI/7744ot2/zwg9sdMUJ8+fTB16tRYV6PVduzYgQcffLBLnrjOOOOMJve73377LdbVaySabf3hhx9i8uTJSEtLg0qlQq9evTB9+nSsXLmy8yraCh6PB5deeikqKyvxzDPPYMWKFcjNze30ehQWFuKVV17BPffc0+mf3dnsdjsefPDBmAbpHeXIkSN48MEHsXXr1lhXhbqxeLnOAJo/3ufNm4dt27bh448/bvH7Si19waeffopLL70UarUaM2fOxJAhQ+B2u/HDDz/gzjvvxK+//oqXXnqpxRWJR2+99Ra2b9+OefPmxboqneree+/F3XffHfbYo48+iksuuQTTpk2LTaUSRGdvW7VajVdeeaXR40OHDm33zwK67zHT3nbs2IGFCxfijDPOQJ8+fWJdnRbLzs7GokWLGj3eq1evGNSmec1tayEErrnmGixfvhynnHIK5s+fj8zMTBw9ehQffvghzj77bKxZswZjx46NTeUbcDgckKRjp/V9+/bhwIEDePnll3HttdeGHo/UDnWkJUuWIC8vD2eeeWanfWas2O12LFy4EEDgRkUiOXLkCBYuXIg+ffpg2LBhsa4OdVPxdJ3R3PGemZmJP/7xj3jyySfxhz/8oUXv26LgrLCwEJdffjlyc3OxcuVK9OzZM/TczTffjL179+LTTz9tUQUiEULA6XRCq9U2es7pdEKlUkEuT/gemTEjSVLYCZ7aT2dvW0mScNVVV3Xa53UUu90OnU4X62p0uGD71tWZTKYO2e+aOzd0hKeeegrLly/HvHnz8PTTT4d1Bfzb3/6GFStWxFVbqdFowv4uLS0FAJjN5rDH27sdau749Hg8ePPNN/GXv/yl3T6vJWw2G/R6fUw+uytqz+3VXdptoqZMnz4dl156KX7//Xf07ds3+heKFvjLX/4iAIg1a9ZEVd7j8YiHHnpI9O3bV6hUKpGbmysWLFggnE5nWLnc3Fxx/vnniy+++EIUFBQItVotnnnmGbFq1SoBQPznP/8Rf/vb30SvXr2ETCYTVVVVQgghfvzxRzFp0iRhNBqFVqsVp59+uvjhhx/C3vu1114TAERhYWHosY8++khMmTJF9OzZU6hUKtG3b1/x0EMPCa/XGyozYcIEASDsX25ubuh5p9Mp7r//fpGfny9UKpXIzs4Wd955Z6Pv5nQ6xbx580RaWpowGAziggsuEAcPHhQAxAMPPNDs9issLBQAxBNPPNFsuZKSEnHNNdeIjIwMoVarxcknnyyWL1/eqFx5ebm46qqrRFJSkjCZTGLmzJli69atAoB47bXXQuUeeOABUX/XaLgdAIhZs2Y1WZ/g7/bOO++IBx98UPTq1UsYDAZx8cUXi+rqauF0OsXcuXNFenq60Ov1Yvbs2Y22W7T7jt/vFw8//LDIysoSWq1WnHHGGWL79u0iNze3UR2rqqrE3LlzRXZ2tlCpVCI/P1889thjwufzhZU73m/j9/tFamqquO2220KP+Xw+YTKZhFwuD+2fQgjx2GOPCYVCIaxWa4u3bbDsnj17xKxZs4TJZBJGo1HMnj1b2Gy2JusXNGvWLKHX65st4/P5xDPPPCMGDRok1Gq1yMjIENdff72orKwMK9fWYybScSjEsX1l1apVYe8zePBgsXHjRjF+/Hih1WrF3LlzhRDRH3fBNiWo/rH07LPPiry8PKHVasU555wjioqKhN/vFw899JDIysoSGo1G/OEPfxAVFRUR3/PLL78UQ4cOFWq1WgwcOFB88MEHjbbrvn37xCWXXCKSk5OFVqsVo0aNEp988knE796wfXvmmWci7hfBbRTNb1F/O/7666/ijDPOEFqtVvTq1Us8/vjjjerrcDjEAw88IPr37y/UarXIzMwUF154odi7d2+oTLT7SvBzm9PWc4MQ0R/P//nPf8Tw4cOFwWAQSUlJYsiQIWLx4sVCiGP7ZaRtbbfbRUpKihgwYECjbRtJpH35u+++E5dcconIyckJ7a/z5s0Tdrs97LVHjx4Vs2fPFllZWUKlUonMzEzxhz/8Iex42bBhgzj33HNFamqq0Gg0ok+fPuLqq68Oe5/6bdesWbMafa8JEyYIIRq3Q0ErVqwQw4cPFxqNRiQnJ4vLLrtMFBUVhZVp7viMZOXKlQKAWL16dcTt9fbbb4sFCxaIHj16CJ1OJy644IJGnylEdOf74Pf69ddfxYwZM4TZbBbDhg0TQhzbl1atWiUKCgqERqMRQ4YMCf1eH3zwgRgyZIhQq9Vi+PDhYvPmzY2+d3D71Tdr1qxQOxdsZxr+q38+2blzp7j44otFcnKyUKvVoqCgQPzvf/9rcvsF1W/Dnn76adG7d2+h0WjE6aefLn755ZdG5aP5nOD+v3r1anHjjTeK9PR0YTabI35+8Pdq+C947dAe7bYQ0e2Dkezfv1/ceOON4oQTThAajUakpKSISy65pNE5J/idf/jhB3HbbbeJtLQ0odPpxLRp00RpaWlY2ZZcX0TSXNsjhBAVFRXi9ttvF0OGDBF6vV4kJSWJ8847T2zdujXitm/LNRUAcfPNN4s33nhDnHDCCaH9/Ntvv424fRput88++0yMGzdO6HQ6YTAYxJQpU8T27duPuw2EEGL79u3izDPPFBqNRmRlZYmHH35Y/Otf/2r3a3OXyyXuu+8+MXz4cGE0GoVOpxPjxo0TK1eubPFvI8TxzzHRHO/V1dVCJpOJp59+OqptFdSiW2f/93//h759+0bdhePaa6/F66+/jksuuQS33347fvrpJyxatAg7d+7Ehx9+GFZ2165dmDFjBm644QZcd911OPHEE0PPPfzww1CpVLjjjjvgcrmgUqmwcuVKTJ48GQUFBXjggQcgl8vx2muv4ayzzsL333+PkSNHNlmv5cuXw2AwYP78+TAYDFi5ciXuv/9+WCwWPPHEEwACd0Vrampw6NAhPPPMMwAAg8EAAPD7/fjDH/6AH374Addffz0GDhyIX375Bc888wx2794dNn7o2muvxRtvvIErrrgCY8eOxcqVK3H++edHtf2i4XA4cMYZZ2Dv3r245ZZbkJeXh/feew+zZ89GdXU15s6dG6rzBRdcgPXr1+PGG2/EgAED8L///Q+zZs067mesWLEC1157LUaOHInrr78eAJCfn3/c1y1atAharRZ333039u7di6VLl0KpVEIul6OqqgoPPvggfvzxRyxfvhx5eXm4//77Q6+Ndt+5//778fe//x1TpkzBlClTsHnzZpx77rlwu91hdbHb7ZgwYQIOHz6MG264Ab1798batWuxYMECHD16tEX9l2UyGU477TR89913ocd+/vln1NTUQC6XY82aNaHf+Pvvv8cpp5wS2ndas22nT5+OvLw8LFq0CJs3b8Yrr7yCjIwMPP7441HVt+GEIkqlEiaTCQBwww03YPny5bj66qtx6623orCwEM8++yy2bNmCNWvWQKlUAmj7MdNSFRUVmDx5Mi6//HJcddVV6NGjR4uOu6a8+eabcLvdmDNnDiorK/GPf/wD06dPx1lnnYXVq1fjrrvuCu2rd9xxB1599dWw1+/ZsweXXXYZ/vKXv2DWrFl47bXXcOmll+KLL74ITXZQUlKCsWPHwm6349Zbb0Vqaipef/11/OEPf8D777+PCy+8MOw9G7Zv5557Lm699Vb885//xD333IOBAwcCQOi/0fwWQVVVVTjvvPNw0UUXYfr06Xj//fdx11134aSTTsLkyZMBAD6fD1OnTsU333yDyy+/HHPnzoXVasVXX32F7du3h/bHaPeV4Hs23O80Gk1of2jruSHa4/mrr77CjBkzcPbZZ4eOl507d2LNmjWYO3cuTj/99Ca39Q8//IDKykrMmzcPCoXiuPtWJO+99x7sdjtuvPFGpKamYv369Vi6dCkOHTqE9957L1Tu4osvxq+//oo5c+agT58+KC0txVdffYWioqLQ3+eeey7S09Nx9913w2w2Y//+/fjvf//b5GffcMMNyMrKwqOPPopbb70Vp556Knr06NFk+UceeQT33Xcfpk+fjmuvvRZlZWVYunQpTj/9dGzZsiUs+xbp+GzK2rVrIZPJcMoppzT5uTKZDHfddRdKS0uxePFiTJw4EVu3bg1lSFt6vr/00kvRv39/PProoxBChB7fu3cvrrjiCtxwww246qqr8OSTT+KCCy7AsmXLcM899+Cmm24CEDh3TZ8+Hbt27WpRL5309HS88MILuPHGG3HhhRfioosuAgCcfPLJAIBff/0Vp512GrKysnD33XdDr9fj3XffxbRp0/DBBx80ahsi+fe//w2r1Yqbb74ZTqcTS5YswVlnnYVffvkl9Du09HNuuukmpKen4/7774fNZov4uQMHDsRDDz2E+++/H9dffz3Gjx8PAGHXg21tt1uyDza0YcMGrF27Fpdffjmys7Oxf/9+vPDCCzjjjDOwY8eORhm8OXPmIDk5GQ888AD279+PxYsX45ZbbsE777wTKhPt9UUkx2t7AOD333/HRx99hEsvvRR5eXkoKSnBiy++iAkTJmDHjh2NuoG35ZoKAL799lu88847uPXWW6FWq/H888/jvPPOw/r16zFkyJAmv8uKFSswa9YsTJo0CY8//jjsdjteeOEFjBs3Dlu2bGm2631xcTHOPPNMeL3e0L740ksvRez90NbrDIvFgldeeQUzZszAddddB6vVin/961+YNGkS1q9fH+qKG81vE8055njHOxDoRZKfn481a9bgtttua3I7NRJtFFdTUyMAiD/+8Y9RlQ9mZK699tqwx++44w4BICySzc3NFQDEF198EVY2eLegb9++YXca/X6/6N+/v5g0aZLw+/2hx+12u8jLyxPnnHNO6LFIdwEa3rUUQogbbrhB6HS6sLsN559/fli2LGjFihVCLpeL77//PuzxZcuWhWUWg9vgpptuCit3xRVXtFvmbPHixQKAeOONN0KPud1uMWbMGGEwGITFYhFCBO4KAgi7M+Dz+cRZZ5113MyZEELo9fqo7hQJcex3GzJkiHC73aHHZ8yYIWQymZg8eXJY+TFjxoRt52j3ndLSUqFSqcT5558fth/cc889jbJ7Dz/8sNDr9WL37t1h73n33XcLhUIRdmcumt/miSeeEAqFIrR9//nPf4rc3FwxcuRIcddddwkhAtvXbDaHZdhasm2DZa+55pqwxy+88EKRmprabP2EiHznHPXunn///fcCgHjzzTfDXvfFF180erytx0xLM2cAxLJly8LKRnvcCdF05iw9PV1UV1eHHl+wYIEAIIYOHSo8Hk/o8RkzZgiVShX23YLtVP1MWU1NjejZs6c45ZRTQo/NmzdPAAirp9VqFXl5eaJPnz6hu25NtW9CCPHee+812i5B0f4Wwe3473//O/SYy+USmZmZ4uKLLw499uqrrwoAEe/sBY+rluwrke5s1j8e2+PcEO3xPHfuXGE0GpvNfDW1rZcsWSIAiA8//LDJ19YXaV+O9FstWrRIyGQyceDAASFE4O7s8dr5Dz/8UAAQGzZsaLYODduuYJ3ee++9sHIN26H9+/cLhUIhHnnkkbByv/zyi5AkKezxpo7Pplx11VUR26tg3bKyskLtqBBCvPvuuwKAWLJkiRCiZef74PeaMWNGo88L7ktr164NPfbll18KAEKr1YZ+DyGEePHFFyO2S8fLnAkhRFlZWZPnkLPPPlucdNJJYcep3+8XY8eOFf37929Uvr5gG6bVasWhQ4dCj//0008CQNh5JtrPCbbL48aNiyo7vGHDhkbXC0Ftbbdbsg9GEulYW7duXaM2MPidJ06cGLY/3XbbbUKhUITODy25vogkmrbH6XQ2yvQXFhYKtVotHnroodBjbb2mEuJYL52NGzeGHjtw4IDQaDTiwgsvDD3W8FxttVqF2WwW1113Xdj7FRcXC5PJ1OjxhoLnw59++in0WGlpqTCZTO1+be71eoXL5Qp7rKqqSvTo0SPsOiqa3ybac0xzx3vQueeeKwYOHNjk85FEfUvIYrEAAJKSkqIq/9lnnwEA5s+fH/b47bffDgCNxqbl5eVh0qRJEd9r1qxZYVH21q1bsWfPHlxxxRWoqKhAeXk5ysvLYbPZcPbZZ+O7776D3+9vsm7138tqtaK8vBzjx4+H3W6Pajax9957DwMHDsSAAQNCn11eXo6zzjoLALBq1aqwbXDrrbeGvb49BzF+9tlnyMzMxIwZM0KPKZVK3HrrraitrcW3334LAPjiiy+gVCpx3XXXhcrJ5XLcfPPN7VaXhmbOnBl2N33UqFGhAfb1jRo1CgcPHoTX6w19J+D4+87XX38dyoLUHwsSafu+9957GD9+PJKTk8N+s4kTJ8Ln84VlwaIxfvx4+Hw+rF27FkAgQzZ+/HiMHz8e33//PQBg+/btqK6uDt1hbK2GYzXGjx+PioqK0DHZHI1Gg6+++irs31NPPQUgsE1MJhPOOeecsG1SUFAAg8EQ2o+Bth8zLaVWq3H11VeHPRbtcdecSy+9NJQ1BBCa5vaqq64KG4MzatQouN1uHD58OOz1vXr1CrvrbDQaMXPmTGzZsgXFxcUAAvvvyJEjMW7cuFA5g8GA66+/Hvv378eOHTvC3rNh+3Y8LfktDAZD2NgvlUqFkSNH4vfffw899sEHHyAtLQ1z5sxp9FnB46ol+woQmC2z4X7317/+NbR9gLadG6I9ns1mM2w2G7766qumNmeTWnrOi6T+b2Wz2VBeXo6xY8dCCIEtW7aEyqhUKqxevRpVVVUR3yeYMfjkk0/g8XhaXZ+m/Pe//4Xf78f06dPDtmdmZib69+/f6PeNdHw2paKiAsnJyU0+P3PmzLBtfMkll6Bnz56h/aQ15/umxrcNGjQIY8aMCf0dPP7POuss9O7du9Hj9Y+TtqqsrMTKlSsxffr00HFbXl6OiooKTJo0CXv27GnU3kQybdo0ZGVlhf4eOXIkRo0aFdperfmc6667rtXZ4fra0m63dB9sqP6x5vF4UFFRgX79+sFsNmPz5s2Nyl9//fVh1w3Bc/qBAwcAtOz6IpJo2h61Wh3KzPp8PlRUVMBgMODEE0+MWOfWXlMFjRkzBgUFBaG/e/fujT/+8Y/48ssv4fP5Itbxq6++QnV1NWbMmBH2uygUCowaNeq4v8tnn32G0aNHh2W309PTceWVVzYq29brDIVCERqz7ff7UVlZCa/XixEjRoRtz2h+m/a8Zgy+R0tE3a3RaDQCCGywaBw4cAByuRz9+vULezwzMxNmszl0AATl5eU1+V4Nn9uzZw8ANNslr6ampskTwq+//op7770XK1eubHSBW1NT0+R71v/8nTt3Ij09PeLzwUHYwW3QsJta/S6bbXXgwAH079+/UdeLYPec4HY+cOAAevbs2Si13/D3aU/1T3YAQhfFOTk5jR73+/2oqalBampq1PtO8L/9+/cPK5eent7ot9+zZw9+/vnn4/5m0Ro+fDh0Oh2+//57TJo0Cd9//z0WLlyIzMxMLF26FE6nMxSk1b9Ib42G2zH43aqqqkLHZVMUCgUmTpwY8bk9e/agpqYGGRkZEZ+vv03aesy0VFZWVqOJMaI97prTkn0SQKOL5X79+jVaH+qEE04AEFj6IjMzEwcOHIi4tkn9Y7J+F5Lm2r5IWvJbZGdnN6pvcnIyfv7559Df+/btw4knntjsBBEt2VcAQK/XN7nftce5Idrj+aabbsK7776LyZMnIysrC+eeey6mT5+O8847L/IXrael57xIioqKcP/99+Pjjz9utC8Ffyu1Wo3HH38ct99+O3r06IHRo0dj6tSpmDlzJjIzMwEAEyZMwMUXX4yFCxfimWeewRlnnIFp06bhiiuugFqtbnX9gvbs2QMhRKO2NKj+BSEQ+fhsjqjXtbChhp8pk8nQr1+/0NIGrTnfN3VMtfX4b4u9e/dCCIH77rsP9913X8QypaWlYYFXJJF+oxNOOAHvvvtuqz+npW1QU9rSbrd0H2zI4XBg0aJFeO2113D48OGwfS7SOaq58yrQsuuLSKJpe/x+P5YsWYLnn38ehYWFYQFSamrqcesc7TVVUFP7jt1uR1lZWai9qS94/AWD6YaOdw3S1Pkw0nVwe1xnvP7663jqqafw22+/hd3Iqr+PR/PbtOc1oxCixetKtig469WrF7Zv396iD4i2Qs3dOW74XPAu2RNPPNHkdK5NjXWprq7GhAkTYDQa8dBDDyE/Px8ajQabN2/GXXfd1WzGrf7nn3TSSXj66acjPt/wQOmumroT19TjDU/g7blIqt/vxznnnBO6e99Q8AI7WkqlEqNGjcJ3332HvXv3ori4GOPHj0ePHj3g8Xjw008/4fvvv8eAAQOaPLijFe32aim/34+MjAy8+eabEZ8P1rs9jpmmfsum7tZFag/a47hr6z7ZEVqSNWvpb9Fe3yvafaUl2nJuiPZ4zsjIwNatW/Hll1/i888/x+eff47XXnsNM2fOxOuvv97s5w4YMAAA8Msvv7RqmQufz4dzzjkHlZWVuOuuuzBgwADo9XocPnwYs2fPDvut5s2bhwsuuAAfffQRvvzyS9x3331YtGgRVq5ciVNOOQUymQzvv/8+fvzxR/zf//0fvvzyS1xzzTV46qmn8OOPP7Z6bGeQ3++HTCbD559/HnGfafj+LdlnU1NT2xTktOZ831T92nL8y2SyiMdNU21YQ8HvcccddzTZS6g9bpa25nPaa/bTtrTbLd0HG5ozZw5ee+01zJs3D2PGjIHJZIJMJsPll18e8RzV0W1+NG3Po48+ivvuuw/XXHMNHn74YaSkpEAul2PevHktqnNHfpdgPVasWBExeGuvWV/b4zrjjTfewOzZszFt2jTceeedyMjIgEKhwKJFi7Bv375QuWh+m/a8ZqyqqkJaWlrU5YEWTqU/depUvPTSS1i3bl1Y14BIcnNz4ff7sWfPntAdYyAwWL66urpNC2EGM1FGo7HJu7NNWb16NSoqKvDf//4Xp59+eujxwsLCRmWbunjIz8/Htm3bcPbZZzd7gRHcBsE700G7du1qUZ2bk5ubi59//hl+vz8sexZMAQe3c25uLlatWtVoatu9e/dG9TntGSgdT7T7TvC/e/bsCZuitKysrNHFQH5+Pmpra1u8vzRn/PjxePzxx/H1118jLS0NAwYMgEwmw+DBg/H999/j+++/j2oh5M7ctvXl5+fj66+/xmmnndbsybk9jpngncbq6uqwxxtmSY5X32iOu44UvCtd//N3794NAKFB0bm5uRGP8YbHZHOa+n4t+S2ilZ+fj59++gkej6fJu9PR7ivRaI9zQ0uOZ5VKhQsuuAAXXHAB/H4/brrpJrz44ou47777ImZCg8aNG4fk5GT85z//wT333NPibl+//PILdu/ejddffx0zZ84MPd5UV5r8/HzcfvvtuP3227Fnzx4MGzYMTz31FN54441QmdGjR2P06NF45JFH8NZbb+HKK6/E22+/HbaGWWvk5+dDCIG8vLwW36g6ngEDBuDNN99ETU1NWJfioOCd+SAhBPbu3RsaVN+W8317Sk5OjtjNsWEb1tT+FDxHKZXKNn2PhtsLCLRBwfanvT4nkta0u9G2223dB99//33MmjUr1G0fCCxN0vCcE62WXF805Xhtz/vvv48zzzwT//rXv8JeV11d3eKL+Wg0te/odLomb7AFj7+MjIxW7U+5ubkRP7fhObI9rjPef/999O3bF//973/DyjzwwAONyh7vt4n2HBPNMVFYWNjitWVbtFjYX//6V+j1elx77bUoKSlp9Py+ffuwZMkSAMCUKVMAoNEseMG7J22ZsbCgoAD5+fl48sknUVtb2+j5srKyJl8bPMHWv6Pgdrvx/PPPNyqr1+sjplKnT5+Ow4cP4+WXX270nMPhCM12FJwN7Z///GdYmfZc2XzKlCkoLi4Om2HI6/Vi6dKlMBgMmDBhAgBg0qRJ8Hg8YXX2+/147rnnovocvV7f6kaupaLddyZOnAilUomlS5eG/Z6Rtu/06dOxbt06fPnll42eq66ubtQ3Oxrjx4+Hy+XC4sWLMW7cuNBBOn78eKxYsQJHjhyJarxZZ27b+qZPnw6fz4eHH3640XNerzdUp/Y4ZoINfP1+2j6fr0UL1kd73HWkI0eOhM0maLFY8O9//xvDhg0L3VWcMmUK1q9fj3Xr1oXK2Ww2vPTSS+jTpw8GDRp03M8JrjPUcL9oyW8RrYsvvhjl5eV49tlnGz0X/Jxo95VotMe5IdrjuaKiIuw5uVweuuh3uVwAmt7WOp0Od911F3bu3Im77ror4l3oN954A+vXr49Yx0i/lRAidI4MstvtcDqdYY/l5+cjKSkpVMeqqqpGnx/MIgXLtMVFF10EhUKBhQsXNvocIUSj7dgSY8aMgRACmzZtivh8cPbBoPfffx9Hjx4NnT/bcr5vT/n5+fjtt9/CPm/btm1Ys2ZNWLngzc+G+1NGRgbOOOMMvPjiizh69Gij94/2e3z00UdhY8bWr1+Pn376KbS92utzImnqWGlOtO12W/dBhULR6HVLly6NOrPZUEuuLyKJpu2JVOf33nsvqrGHrbFu3bqwsVcHDx7E//73P5x77rlN3nyaNGkSjEYjHn300YjjXY+3P02ZMgU//vhjWDtZVlbWqBdGe1xnRHqPn376KexcDET320R7jmnqeA+qqanBvn37op7lPqhFmbP8/Hy89dZbuOyyyzBw4EDMnDkTQ4YMgdvtxtq1a0NTuAPA0KFDMWvWLLz00kuhdOX69evx+uuvY9q0aTjzzDNbVNH65HI5XnnlFUyePBmDBw/G1VdfjaysLBw+fBirVq2C0WjE//3f/0V87dixY5GcnIxZs2bh1ltvhUwmw4oVKyKeeAsKCvDOO+9g/vz5OPXUU2EwGHDBBRfgT3/6E95991385S9/wapVq3DaaafB5/Pht99+w7vvvosvv/wSI0aMwLBhwzBjxgw8//zzqKmpwdixY/HNN99Ena0K+uabbxqdvIHAwODrr78eL774ImbPno1NmzahT58+eP/997FmzRosXrw4NNB62rRpGDlyJG6//Xbs3bsXAwYMwMcff4zKykoAx4/+CwoK8PXXX+Ppp59Gr169kJeXF7EfcXuIdt9JT0/HHXfcgUWLFmHq1KmYMmUKtmzZgs8//7zRXac777wTH3/8MaZOnYrZs2ejoKAANpsNv/zyC95//33s37+/xXeqxowZA0mSsGvXrtA0+ABw+umn44UXXgCAqIKzzty29U2YMAE33HADFi1ahK1bt+Lcc8+FUqnEnj178N5772HJkiW45JJL2uWYGTx4MEaPHo0FCxagsrISKSkpePvtt1sUFEd73HWkE044AX/+85+xYcMG9OjRA6+++ipKSkrw2muvhcrcfffd+M9//oPJkyfj1ltvRUpKCl5//XUUFhbigw8+iGpq7mHDhkGhUODxxx9HTU0N1Go1zjrrrBb9FtGaOXMm/v3vf2P+/PlYv349xo8fD5vNhq+//ho33XQT/vjHP0a9r0SjPc4N0R7P1157LSorK3HWWWchOzsbBw4cwNKlSzFs2LBQ1q6pbZ2RkYE777wTv/76K5566imsWrUKl1xyCTIzM1FcXIyPPvoI69evD00K1NCAAQOQn5+PO+64A4cPH4bRaMQHH3zQ6K777t27cfbZZ2P69OkYNGgQJEnChx9+iJKSElx++eUAAuMonn/+eVx44YXIz8+H1WrFyy+/DKPRGAp22yI/Px9///vfsWDBAuzfvx/Tpk1DUlISCgsL8eGHH+L666/HHXfc0ar3HjduHFJTU/H1119HHLeSkpKCcePG4eqrr0ZJSQkWL16Mfv36hSavasv5vj1dc801ePrppzFp0iT8+c9/RmlpKZYtW4bBgweHjY/RarUYNGgQ3nnnHZxwwglISUnBkCFDMGTIEDz33HMYN24cTjrpJFx33XXo27cvSkpKsG7dOhw6dAjbtm07bj369euHcePG4cYbbwzdHExNTQ3rftUenxNJfn4+zGYzli1bhqSkJOj1eowaNarZMWvRtttt3QenTp2KFStWwGQyYdCgQVi3bh2+/vrriGO3otGS64tIoml7pk6dioceeghXX301xo4di19++QVvvvlmyxYrboEhQ4Zg0qRJYVPpA8DChQubfI3RaMQLL7yAP/3pTxg+fDguv/xypKeno6ioCJ9++ilOO+20iDf2gv76179ixYoVOO+88zB37tzQVPrBXl9B7XGdMXXqVPz3v//FhRdeiPPPPx+FhYVYtmwZBg0aFHZjJ5rfJtpzTHPHOxCYWEYIgT/+8Y8t+7FaNLdjnd27d4vrrrtO9OnTR6hUKpGUlCROO+00sXTp0rDpLj0ej1i4cKHIy8sTSqVS5OTkNLvQaENNTQMctGXLFnHRRReJ1NRUoVarRW5urpg+fbr45ptvQmUiTeG9Zs0aMXr06NCirH/9619DU+rWnzq3trZWXHHFFcJsNgsgfBFqt9stHn/8cTF48GChVqtFcnKyKCgoEAsXLhQ1NTWhcg6HQ9x6660iNTVV6PX6Vi1C3dS/FStWCCECi1BfffXVIi0tTahUKnHSSSdFnOq2rKxMXHHFFaFFqGfPni3WrFkjgMBCoEGRpnv/7bffxOmnny60Wu1xp5Ft6ncL/hYNp4MOfl5ZWVnosWj3HZ/PJxYuXCh69ux53EUirVarWLBggejXr59QqVQiLS1NjB07Vjz55JNh09NG89sEnXrqqY2miT106JAAIHJychqVb8m2jbRdhGh6WvqGolmEWgghXnrpJVFQUCC0Wq1ISkoSJ510kvjrX/8qjhw5EirTHsfMvn37xMSJE4VarRY9evQQ99xzj/jqq68iTlnd1CLG0R53zS1CXV9L9tX6i1CffPLJQq1WiwEDBkRsn4KLUJvNZqHRaMTIkSObXIS6qfbt5ZdfFn379hUKhSJsG0X7WzS1HRtO/S1EYArjv/3tb6HjLTMzU1xyySVi3759YeWi2VeiXYS6LecGIaI7nt9//31x7rnnioyMDKFSqUTv3r3FDTfcII4ePRrVtg4Kvk9KSoqQJEn07NlTXHbZZWELK0eaSn/Hjh1i4sSJwmAwiLS0NHHdddeJbdu2hU1HXl5eLm6++WYxYMAAodfrhclkEqNGjRLvvvtu6H02b94sZsyYIXr37h1aAHzq1Klh02IL0fqp9IM++OADMW7cOKHX64VerxcDBgwQN998s9i1a1eoTDS/b0O33nqr6NevX9hj9RdhX7BggcjIyBBarVacf/75YdPaB0Vzvm+qzRSi6X0JCCzOW19T7cUbb7wRWjh92LBh4ssvv4x4PK1du1YUFBQIlUrV6DfZt2+fmDlzpsjMzBRKpVJkZWWJqVOnivfff7/J7dewTk899ZTIyckRarVajB8/Xmzbtq1R+Wg+p6lzcnP+97//iUGDBglJksL24/Zot4WIbh+MpKqqKnQdZDAYxKRJk8Rvv/3W6Fqgqe8c6fhtyfVFQ9G0PU6nU9x+++2h9z/ttNPEunXrGi3b0B7XVMH9/I033hD9+/cXarVanHLKKY3auuaWvZk0aZIwmUxCo9GI/Px8MXv27EZtUCQ///yzmDBhwnEXoW7rdYbf7xePPvqoyM3NDX2/Tz75pNExGu15IdprxuaO98suu0yMGzfuuNuoIZkQnTDineLWRx99hAsvvBA//PADTjvttFhXhyhu9enTB0OGDMEnn3wS66oQdSm///47BgwYgM8//xxnn302gMAYkzPPPBPvvfde1FnX7mz//v3Iy8vDE0880eosJnVfMpkMN998c7NZLmpfxcXFyMvLw9tvv93izFmLxpxR1+ZwOML+9vl8WLp0KYxGI4YPHx6jWhERUSLr27cv/vznP+Oxxx6LdVWIiDrF4sWLcdJJJ7W8SyNaOOaMurY5c+bA4XBgzJgxcLlc+O9//4u1a9fi0UcfbbepdImIiBoKjsMlIuoO2nIzisFZN3LWWWfhqaeewieffAKn04l+/fph6dKluOWWW2JdNSIiIiKibo9jzoiIiIiIiOIAx5wRERERERHFAQZnREREREREcYDBGRERERERURxgcEZERERERBQHGJwRERERERHFAQZnREREREREcYDBGRERERERURxgcEZERERERBQHGJwRERERERHFAQZnREREREREcYDBGRERERERURxgcEZERERERBQHGJwRERERERHFAQZnREREREREcYDBGRERERERURxgcEZERERERBQHGJwRERERERHFAQZnREREREREcYDBGREREYCrrroKGo0Gu3fvbvTcY489BplMhk8++QQA8M477+Cqq65C//79IZPJcMYZZ3RybYmIKBHJhBAi1pUgIiKKtdLSUgwYMADDhg3DypUrQ48XFhZi8ODBmDJlCt5//30AwBlnnIFNmzbh1FNPxdatW3HyySdj9erVMao5ERElCmbOiIiIAGRkZODxxx/HqlWr8Prrr4cev+mmm6BUKrFkyZLQYytWrEBNTQ1WrlyJXr16xaK6RESUgBicERER1bn22mtx2mmn4Y477kBFRQXefvttfPHFF/j73/+OrKysULmcnBzI5TyFEhFR+2K3RiIionp+/fVXnHLKKZg2bRq+//57ZGdn46effmoyGBsyZAjS0tLYrZGIiNpMinUFiIiI4sngwYNxxx13YNGiRVAoFPj000+ZJSMiok7Bsw0REVEDaWlpAIBevXphyJAhMa4NERF1FwzOiIiI6jl48CAeeOABDBkyBAcPHsQ//vGPWFeJiIi6CQZnRERE9dxyyy0AgM8//xyXXnopHnnkEfz+++8xrhUREXUHDM6IiIjqfPjhh/j444/x8MMPIzs7G4sXL4ZKpcLNN98c66oREVE3wOCMiIgIgNVqxa233opTTjkFc+bMARAYc/bwww/jiy++wHvvvRfjGhIRUaLjVPpEREQA5s6di2effRY//vgjTj311NDjPp8PI0eORHFxMX777TckJSXhu+++w3fffQcAWLp0KXQ6Hf785z8DAE4//XScfvrpMfkORETUtTE4IyKibm/Tpk0YNWoUbrzxRixdurTR8xs2bMDo0aNxyy23YMmSJXjwwQexcOHCiO/1wAMP4MEHH+zgGhMRUSJicEZERERERBQHOOaMiIiIiIgoDjA4IyIiIiIiigMMzoiIiIiIiOIAgzMiIiIiIqI4wOCMiIiIiIgoDkixrgA15vf7ceTIESQlJUEmk8W6OkREREREcUsIAavVil69ekEu79q5JwZncejIkSPIycmJdTWIiIiIiLqMgwcPIjs7O9bVaBMGZ3EoKSkJQGAHMxqNMa4NEREREVH8slgsyMnJCV1Dd2UMzuJQsCuj0WhkcEZEREREFIVEGA7UtTtldoLvvvsOF1xwAXr16gWZTIaPPvrouK9ZvXo1hg8fDrVajX79+mH58uUdXk8iIiIiIuraGJwdh81mw9ChQ/Hcc89FVb6wsBDnn38+zjzzTGzduhXz5s3Dtddeiy+//LKDa0pERERERF0ZuzUex+TJkzF58uSoyy9btgx5eXl46qmnAAADBw7EDz/8gGeeeQaTJk2K+BqXywWXyxX622KxtK3SRERERETU5TA4a2fr1q3DxIkTwx6bNGkS5s2b1+RrFi1ahIULF3ZwzYi6FqfHB6vTixqHGxW1bvhFrGtEBMhkQJJaQopBhSSNEnqVIiHGOFDXIISAze2D1elBZa0bVpcXgm1j/BF+wO8D0H1+HJVCjv49kqCSOqZTnlKphEKh6JD3jjcMztpZcXExevToEfZYjx49YLFY4HA4oNVqG71mwYIFmD9/fujv4IwzRN2J3y9gdXlhdXpQUetGjcMDh9sLmUwGjVIBOS+AKU4U1zhxqMoOlSSHQaNEukEFo1YFg1rqsAsT6r7cXj9qXV5YHG6U1bpR6/TA7fVDksuhVnaPi9UuQwhIbgtUPge64ynrYFFFh56rzWYzMjMzE/6GGIOzOKBWq6FWq2NdDaJOVz87Vl7rhs3thcfnh0qugF6tgEmrZVBG8UerBAC4vD7YXT7sslkhl8mgVUlI0SuRolPDoJGYVaNWCWbHap1eVNpdqLQFblT5hYBWkpCkUUItMSiLR77aSsjhRFpmBjRaLWToHse/ACD8AhqVBIW8/b+zEAJ2ux2lpaUAgJ49e7b7Z8QTBmftLDMzEyUlJWGPlZSUwGg0RsyaEXUnfr9ArdsLq9OLcqsLNQ4PnB4fAECrVCBZq4JSwcwDdQ1qSQG1pEAyVPD5BRxuH45UOXGwwg61pIBBIyGtLquWpJG4b1OTPD4/rM5Adqy81o1apxcurw8KuRx6lYR0g6ZDLnqp/Qi/H/DYkZaRDnNySqyr06mECJzfNeqOCc4AhK6hS0tLkZGRkdBdHBmctbMxY8bgs88+C3vsq6++wpgxY2JUI6LYcnp8qHV5UWP3oKzWBZvbC69XQKmQQ6dSwKRVMjtGXZ5CLoNBI8GgCZxWnR4fbC4fKmxWyCGHTq1Acl1WLUkjQcesWrcmhIDdHeg5UGl3ocrmgd3lgx9+aCQJerWEVAN71HQpfi9kADS8Ed9hdDodAMDj8TA4685qa2uxd+/e0N+FhYXYunUrUlJS0Lt3byxYsACHDx/Gv//9bwDAX/7yFzz77LP461//imuuuQYrV67Eu+++i08//TRWX4GoU9XPjlXaXKi2e2B3B7JjOmbHqJvQKBXQKBVAXVbN7vYGsmqVdVk1tYT0JDWMGiUMzKp1Cx6fH7VOLyxOD8qsrkB2zOeDQha4UZWepGZ2LAF0l66MsdBdbmgxODuOjRs34swzzwz9HZy4Y9asWVi+fDmOHj2KoqKi0PN5eXn49NNPcdttt2HJkiXIzs7GK6+80uQ0+kSJwOWtGztm96DC5kKtywu3V0CpkEGvkpBpZHaMui+FXIYkjRJJmsBYtWBWrbzWErgwVyuQqlchWR+YVIRZtcQQzI7VuryosrlRYXPD7vLBJ/zQKuuyY0pmx4gonEwITsIabywWC0wmE2pqamA0GmNdHaJG/H4BW112rMLmQk1ddkwgMHZMr+KsdUTRCGbVbG4f/MIPtaRAkkZCRpIGBrWEJI0EiVm1LsNbN3bM6vSirNYJa93YMblMDr1KAV0HTZhAsSe8bghrKXrn5kKt0cS6Op0qOOZM14FjzgDA6XSisLAQeXl50DTYxol07czMGRFFxeUNzB5mcQTGjtW6vPD4BCS5DDqVhB7MjhG1WP2smhACLq8fVocXZVZL3bGlQEpdVi1JI0GrZFYtnggh4KibdbbK5kalzQ272wefX0AtyaFXS0jRqfibUZd1YP9+DDqxP9au34ChQ4dF9Zrly5dj3rx5qK6u7tC6JSoGZ0QUkRACtS5v6KKjyh646BAC0KoUMHI6Z6J2FVzTT1O3dpXX54fd7cPBKgf2V9ihVcqRpA3M3JekkWBQM6sWC16fP9Q2ltU6YXV44fD4oZDLoFMqkGbg2DEiaj0GZ0QU4vb6YXV6YHF4UG4LLHbq8vqhlMuhU0vISFLyooOok0gKOYxaOYzaQFbN6fHDYvei1HIsq5ZqUCFZp4JBI0Gn4im9o9jdXtQ6vaiyu1FRG7hR5fULaCQ5dCoJyTo5s2NE1C54y42oGwtmx47WOPDr4Rqs31+JzUVV2FNaC4fLhySNEllmHTKMgfEvDMyIYkMmk0GrUiDVoEaWWYtUvQpCAAcrHdhcVI0NhZXYUlSFg5V2VNvd8Pr8sa5yl+b1+VFtd+NgpR1biqqwobASm4uqcbDSASGAVL0q8DsY1NByAhc6Hput6X9OZ/RlHY7jl22F//fll5h45gT0ykhDTs8euHjaH/H7vn0Ry3737bfQq5X44rPPMLLgFKQYDTjz9NOw49ftjcp++eWXGDhwIAwGA8477zwcPXo09NyGDRtwzjnnIC0tDSaTCRMmTMDmzZtbVf9Ew9tsRN2M2xvokmNxuFFW64atbsC6JA/cAeZip0TxL1JWrcbuQYnFCalu4eJUgwpmXWA8m1bFLsjH43D7YHV6UG33oKLWHViT0e+HRlIwO0ZtoksxN/mc77zJcP3v49Df2uxekNntkcuefjpcX31zrOwJ/SArLw8rY3d5Wlw/u92GOXPnYciQk1Brq8XfFy7E5dMvwY8bNjX5mr8tuBv/eOpp9MjsgQfvuw+XXXIRftu1Cwq1qu497XjyySexYsUKyOVyXHXVVbjjjjvw5ptvAgCsVitmzZqFpUuXQgiBp556ClOmTMGePXuQlJTU4u+QSBicESU4IQRs7sBkHpV2FyptHjjcXviFgJaLnRJ1ecGsWjAA8/r8sLl9OFBpQ2EFoFHKYdKokGpQhdZV4w2YwEyZwXXHKmrdqHG64fT4oagb+5eqV3FMH3UL0y68KOzvF156GblZPbFz5w4Y9IaIr1lw7704e+JEAMCLr7yKE/P74KMPP8Tll18GILBQ9LJly5Cfnw8AuOWWW/DQQw+FXn/WWWeFvd9LL70Es9mMb7/9FlOnTm2379YVMTgjSkCeuumcLQ43ymvdgcVOvT4o6u6oMztGlLgkhRwmrRymuqyaw+NDtd2NYosDkkIOQ11WzaRTIkndvbJqDrcPVpcnsCZjrRu1bi+8vkB2TKtSIFnLmRWp/dkrq5t+UhF+/DkOHWm6rDz8ZoFj99421OqYvXv24OGHFmLj+vWoqCiH3x/oFn2w6CAGDhwY8TWjRo0O/X9KSgr69z8BO3/bGXpMp9OFAjMA6NmzJ0pLS0N/l5SU4N5778Xq1atRWloKn88Hu90etnZwd8XgjCgBBBc7tdZlx6psnsaLnTI7RtTtyGSBpS6Ck4V46maA3F9hg79MQKNSwKwNZNWS1ImXVQtmx6yuQDBW7XDD4fZBIZdBqwxMc69kdow6ml4f+7LNuPSiC5HTuzeefWEZevbsCb/w49RThsHjdrf6PZVKZdjfMpkM9ZdWnjVrFioqKrBkyRLk5uZCrVZjzJgxcLfhMxMFgzOiLsrj84e65JRZA+uOubw+KGRy6FQKpCdxOmciCqeMkFWrtLlx1OKAJJfDoJaQZlDBqFXCqFGGpvXvSpweHyzOuuyYzY1aV2DsmFqhgI7ZMaIwFRUV2L17F559YRlOGzcOALB2zQ/Hfd369T8hp3dvAEBVVRX27t2DgQMiZ9kiWbNmDZ5//nlMmTIFAHDw4EGUNxg/110xOCPqIoLZsVpXYN2xClvgDrDPL6BRKgITAOiZHSOi6DSVVfu9zAYhBLQqCSatMpBV0yjjdsZWnz+4JmPd2DFHYFxt8PsxO0bUtOTkZKSmpuLVf72MzMxMHDx4EPffe89xX7fokUeQkpKKjB4ZWHj//UhNTcMfp02L+nP79++PFStWYMSIEbBYLLjzzjuh1Wrb8E0SB4MzojjmrRs7FlrstG7smFwmh17FxU6JqP3Uz6r5hYCzXlZNqQiMV00zqGDSqpCkkWKaVXN6At24a+rG1drcXnh8x7JjZq2W2TGiKMjlcixf8SbunH8bTh0+DP1POAFPPr0Y551zdrOve/jvj+DO2+dj3949OHnoULzz/n+hUqmi/tx//etfuP766zF8+HDk5OTg0UcfxR133NHWr5MQZKJ+B1CKCxaLBSaTCTU1NTAajbGuDnWiYDcjqzOQHau0hS92qldLUEuczplaTiGXQZLL4PUL+Pxs9qllglk1u9sLANAoFTBplUhLUsOglpCkliDvwBtFfr+A1eVFrcuLcqsLNQ4PnB4fANRl/xTMjlGLtWe7KLxuCGspeufmQq3RtFMN4893336LyedOxOGSMpjNZgCAEIFjVNfB2XWn04nCwkLk5eVB02AbJ9K1MzNnRDHm9fnruuTUZcccXjjqpnPWqTidM7WNWpLDrFfCrFWixuGBSatEtT2wlpPLy4WKKTqRsmoVtW4U1zghSbK6WWDVMGqV7ZZVi5Qd83pFIIunDgSHct6oolZgu0jxjMEZUQzY3V7UOr2osrtRURueHeNip9Re1JIc2SlaLPt2H5av3Q+LwwujVsLVY/Nww4S+OFTp4IUItZg8wlg1m8uLvWW1AACdSlE3Vk2NJI0Egyq6rJrfL1DrDtyoKre6YHF64HD7IADolIGJPJgdo7Ziu0jxjsEZUSeonx0rr3XB4vDA6Q1kx7Rc7JQ6iFmvxLJv9+Gf3xxbC8fi8GLJN3sAAFeO6o0SiytW1aMEoVTIYdapYAbgFwIOtw9lVheOVjuhlAKBXLpBHVhXTSNBLR3Lqjk9gUmOauwelNW6YHd74anLjulUChiNzI5R+2K72DanT5gAm8sT62okNAZnFJHT40OVnWtNtJUQQK3Ti4pglxx/YLFTZseoI3l9fhSW29C/hwHL1+6PWOa1tYW46cx8lNe6OQaN2o1cJoNeHVhbEQDcXj/s7kBWTQZAq1LArFPCrFWh2uFGtT08O2bSqKCSeKOKOobT44NRo2y+XTwjHyU1ToDnZ4oRBmcUUZXdjW0Hq3nHso0EALkM0ColZseoQ1XUurC5qAobD1Rh68Fq5CTrcGpeCiwOb8TyFocXZVYXnl21B2kGNUbkJqNPqp43DKhdqSQ5VFJ4Vq3U4sLhKieUisBYNWbHqKMIIbC/woaN+6uwqagKfr/ASzNHNN8u1rpw7/+2w6CWUJCbjOG9k5FqiH6ZGs6z13H8/u7R3ZTBGUUkROAOaE8T15wgikc+v8BvxRZsOlCFTQeq8Hu5Lex5p8eLNIMaRq0U8ULEqJWQolfhx98rUWlz49/rDiBFr0JBbjJG5CZjWI45NKaIqD00zKoRdQSby4utB6uxqSjQNlbajvUCStGrkGpQHbddPFjlQKXNjTX7KgAAfdP0KMhNRkFuMgZkGiPPSKhQwg+gtPgoUtLSoFRGP618VycACL+AXHTMbI1CCLjdbpSVlUEul7doyv6uiC0kEVEXUWV3Y/OBQHZsy8Eq2Fy+0HMyAP17GFDQOxkj+qQgP90Aq8uDq8fmhcZS1Hf12DxU1LoxfUQONh2oxLZDNai0ufHVjhJ8taMECrkMg3oaQ8Fa7xQds2pEFHeEECiqtGPjgSps3F+JncXWsK7aakmOk7NNGJGbgoLcZNS6vM22i1anF/dMHohNByqx8UAV9pTW4vdyG34vt+G9TYegVytwSk6gXRyem4xkXSBQkMlkUBgz4bBV4uiRo532/eOBQOB3UEnyDs2C63Q69O7dG3J5YvdC4jpncSge1mo4Uu3A9sM1zJwRxZDPL7CnxIqNddmx4Gx4QUlqCaf0TsaIPoGuNyatMuz54KxkL377O15bW9jsrGRurx/bj9SEMnGHqx1h75VmUIfuHA/NNjGrRkQxY3d7se1QsL2qRHlt+Bj5LLM21F4N6WUKG8fYknYRAKrtbmwuqsamA5XYXFSNWld4xq1fuiF0E6t/jyTIZQCEH/D70F24fT7YXT6clG2CtoPODQqFApIkNXmTMB6undsLg7M4FA87GIMzotiocXhCAdKWoipYI10I9EnGiN6BC4HjdSFRS/LABAw6JWocXpi0UlTr+RytcWBTXZbul0M1cPuOlZXkMgzqZcSI3GQU5KYgJ1nLrBoRdRghBA5WOULZrB1HLPDWy46pFIHsWDAgO961S2vbxfo3zDYeqMS+svDu5MEbZsF6NLxhlqhcXh9qnV6M7JsSsxt38XDt3F4YnMWheNjBGJwRdQ6/ENhbWouN+wMXHXtLa1G/UQ7rQtM7Gcn61vW1V8hlkOQyeP2ixbMzurw+/HL4WFbtaI0z7PmMJHXozvHJ2eZ2WYCYiLo3p8eHnw9Vh3oOlFrDp7fvadLUtTspGJJlDFuiIVptaRcBoMrmDo1t21JUBZs7vKt5vwwDRuQGupr3yzAk7MQ3DM7aF4OzOBQPOxiDM6KOY3F4sLkoMHvY5gNVsDjDs2PBwecj+qTgxCiyY53tSLUDGw9UYtOBKvxyuAYe37HTiCSXYUiWqS6rlowsM7NqRHR8QggcrnaEgrHth2vCsmNKhQwnZZlQkJuCEbnJ6GWOr+uT403SZNRIGJ6bjILegRttxgTKqjE4a18MzuJQPOxgDM6I2o9fCOwrrcWmoips3F+F3SXWsOyYTqXAKTnmVk3bHGuBu9s1dd+tstHd7UyjJpRVG5JlYlaNiEKcnmNZ+Y0HKhst/pyRpMaIPoFg7KQu1n40XN7E3iCrdkKPJIzoEwjW8rt4Vo3BWfticBaH4mEHY3BG1Da1Ti+2HAwEY5uLqlDt8IQ93ydVF7oDPCAzKSHWwBNC4FC1A5vq1hRqeOdbpZBjSJYpFKzF251vIup4R+plx345XB0x8x4cs5WdIJl3r8+PncXW0AQm+yvsYc+btUoMr5vc6ZScZBg0XWvCJQZn7YvBWRyKhx2MwRlRywgh8Hu5LXTRsavYgvpDGLRKBYbVZccKcpOR1oWyY63lcPvw8+Hq0AKwZRHGjAQnFWntmBEiim8urw/bD1tCk3k0HLOanqQOdYM+OcsMrSrx24HyWleo++PWg9VweI5l1eQy4MTMY8uY9E3Tx32AyuCsfTE4i0PxsIMxOCM6vtrgYqd146+q7OHZsd4putBFx8CeRigTIDvWWsG1iIIXJL8etYQNwFdJcpwcGquWgkyTJoa1JaK2KK5xhoKxnw/XwO1tPNtrcE3G7j7bq8fnx46jltDsuAcrw7NqyTpl3U29FAzLMcMQh4u4MzhrXwzO4lA87GAMzogaE0Jgf8Wx7NjOo+HZMY1SjqHZx7JjGUkMMJpid3ux7WB16IKkwtZ4naJgYDsky9StA1uieOfx+bH9cE2obWy8TqIKBb2TUdAnheskHkepxRmaAXLrweqwqf3lMmBgz2NZtT6p8ZFVY3DWvhicxaF42MEYnBEF2N2B7NjGA4GZFRsGETnJ2tB0zoN6de/sWGsJIXCgwl53YVeJHRGC3pOzzKHB8xlGBr1EsVZicYYy4dsOhQcRCrkMAzOTMKJPCgp6JyM3VRcXQURX4/H58esRCzbur8SmoiocqgoPelP1KgyvC9SG5ZhjFhgxOGtfDM7iUDzsYAzOqLuq3/1u44Eq7IjQ/W5otgkjclNQkJuMHgwU2p0t1F00cOFXaW8QEKfo6rpEJWNQN+8uStRZPD4/dhyxhG6iHGwQKKToVCiou4EyLMcMfRx2v+vqiusC4o37Kxt1F1XIZRhUL6vWO6XzAmIGZ+2LwVkciocdjMEZdScOtw/b6i12Wl4bPnFFllkb6qo4pJcJKonBQGcRQqCw3BYKln+LMNHK0BwTCnoHguX0pMSfaIWos5RZ6yauKKrEtoM1jSauGJBprFtkOX662HUXbm+gK2lwGZMjDSZaSTOoQ4Ha0OyOnWiFwVn7SvjgzO12o7CwEPn5+ZCkrnEXJx52MAZnlMiEEDhUdWwh5V+PWBpN+X5S9rGFlHkcxI/gEgWBC8YqVDeYhCU3RRfq/jiwpzEhligg6ixenx87j1pCazIeaDA5hVmnDIwdy+2aU74nsiPVjlC7+MuhGrh94ZOwDO5lDE0s0t6TsDA4a18JG5zZ7XbMmTMHr7/+OgBg9+7d6Nu3L+bMmYOsrCzcfffdMa5h0+JhB2NwRokmsFjysexYw8WSe5o0oezYSVkmTuveBfiFwO9lttBsmbtKrGFZNZ1KgaHZx8aqdaXFvYk6S0WtKxSMbTsUvliyXAac2CMpdFHfN13fpRdL7i6cHl8gq1bX46DYEp5Vy0g6llU7Odvc5sW9GZy1r4QNzubOnYs1a9Zg8eLFOO+88/Dzzz+jb9+++N///ocHH3wQW7ZsiXUVmxQPOxiDM+rqhBA4XHcnceOBxgsiKxUynBRaEDmFCyInAIvDUzd5SyU2F1WjpsHC33lp+lA2dECmEQo5LzKp+/H5BX4rtoTWHywst4U9b9IqMby3GSNyU3BKbzOSNMoY1ZTagxACR6qd2FRUiY37q/BLg3NhcOHvYNuY1YqFvxmcta+EDc5yc3PxzjvvYPTo0UhKSsK2bdvQt29f7N27F8OHD4fFYol1FZsUDzsYgzOKFwq5DJJcBq9fhE3MEUnwbmEwOxbpbuGIPikYUZcda+vdQopffiGwt7Q2NKnI7hIr6u89erUCw3ICd44LeicjWa867nu2ZF8k6mgt2R+rbO5AduxAFbYWVcFWLzsmA3BCKDuWjH4ZBmbHEligF0lNqFt/w14kmUZNKKs2JMrzpM/vh8fnx+Cs2C2TEA/Xzu0lYTsLl5WVISMjo9HjNpuNA1aJugC1JIdZr4RZq0SNwwOTVolquwfVdk/YlM1Hqh2hYGz74cb97IfUZccKcpOR3Yo7gtQ1yWUynNAjCSf0SMKMkb1R4/BgS93F6eaiKlidXqzZW441e8sBAPnpehTkBgL3E3okhWXVot0XiTpDNPujzy+wu8QamllxX1l4dixJIx0bO9Y7GSYts2PdhUapwMi8FIzMSwmNvw70MKnEr0csKLY48ekvR/HpL0ehUshD59ARucmNepgE90WTVokauweSXA6728t17NooYTNnp59+Oi699FLMmTMHSUlJ+Pnnn5GXl4c5c+Zgz549+OKLL2JdxSbFQ/TPzBnFklqSIztFi2Xf7sPytfthcXhh1Eq4emwebpjQF/9vewm++a0EGw9U4WiDGarSk9Sh7hknZ3XsDFXUNfn8gazaxgOV2HigCntLa8OeN6glDO8dWEz8tH5pGNTL2OS+eKjSwQCNOk2zbePpffH+pkP4emcJNhdVo9blDXtt/wxDqBt3vwwDu/VSI3a3Fz8fOjZWreHMxT1NmrrzawpG9DGjb7oh4r540xn5UHdyz5R4uHZuLwkbnP3www+YPHkyrrrqKixfvhw33HADduzYgbVr1+Lbb79FQUFBrKvYpHjYwRicUSz1MKnxxo8H8M9v9jZ6bs5Z/XBSlgnXr9gEIJAdG9TLGLoL3Jlru1BiqLK7saUokH1teFH78swC/HyoBktXNt4X557dH1eO6o0Si6vRc0QdoSVt47GbDCkY3tsMs+74XXeJguqv+bnpQBV+bbDm5yuzRmDbweom28YbJvTt1AxaPFw7t5eEDc4AYN++fXjsscewbds21NbWYvjw4bjrrrtw0kknxbpqzYqHHYzBGcWKQi5DfoYepz7yNSwOb6PnjVoJPy44G/d9uB0n9jRiaHbs+rhT4qnfHWxvqRVvXDsKoxd90+S+uPFvE7G31MYxaNThomkbf1owEU988RsG9DQ26p5L1BZ2txfbDgZmPN5XVov/mzPuOG3jOZ26Jmg8XDu3l4S+osnPz8fLL78c62oQURRKLU5sKqpCicWFeRP7R2zwAcDi8MLm8uGGCfnsTkbtTiGXYWBPIwb2NEItyVHr9Da7L5bVuvHVjmJkJ+s4kQK1u/oT21TUunDv1EHN7o+1Li8uH9mbbSO1O51Kwpj8NIzJT4NaksF6nLbR6vRw+ZJWStjgrKioqNnne/fu3Uk1IaJIPD4/dhw9Np3zwbrFTlP0Kjw8bTCMWqnJO3ImrYQyK7uSUcfy+gXMOmWz+2KyTonX1x1Apc3NKcipXVgcHmw5WI1NDZaESNGrkGpQsW2kmPP6geTjtI1s/1ovYYOzPn36NDvuxOfzNfkcEXWMMqsr0H+9qBLbDtbA4Qlf7HRAphEjcpNRZnXh6rF5WPLNnkbvcfXYPFTbPexGRh3O5xeodnia3RcPVNgxIDMJW+ouolftKsOqXWVcvJeiVn8x9Y11yz7Ub960SgVOqZugpsrW/P7ItpE6QzRto9fvhwqd160xkSRscNZwkWmPx4MtW7bg6aefxiOPPBKjWhF1L16fHzuPWgLr6+yvwoG67FiQWac8Np1zTjIMmkCT5PL4ccOEvgCA19YWRpwhj6gzVNs8x90XF0weGHFf31lsxc5iK974qajJfZ26p1qnF1sOVtXdrKpCtT18wfQ+qbpQYD8wMwmSInCRa3N52TZSXGiubYzFbI2JJKEnBInk008/xRNPPIHVq1fHuipNiodBjZwQhFqrotYVukDddqgadnd4dizabIJaksOsU8KsU6LG4YVJK3FtKYqJ1uyL0WaJC3KTkZem5wyjCU4IgcJyW2iK8t+KLY2yY0NzTBiRm4LhvZORntT0WB22jRQvgvuiSaeExeGBSauC1++PySRd8XDt3F66XXC2d+9eDB06FDab7fiFYyQedjAGZxQtn1/gt2JL6KKjsDz82AqOwynITcEpOWYYW7jYqUIugySXwesX7K5DMdXafbGp8ZVBKXpVKKs2LMcMvZpZtURgc3mx9WB1KDtWaXOHPZ+TogsF6IN6GqFUtKwLGNtGihc+vx8enx+Ds2I3e3I8XDu3l4Q9A1gslrC/hRA4evQoHnzwQfTv3z9GtSJKDFU2dyA7dqAKWw9WweY6lhWQATghlB1LbvMMdj5eeFCcaO2+qFTIMTTbjKHZZvwZeaGZSYPZ5UqbG1/tLMFXO0sCs0VmJgUWec1NRm4q1+3rKoQQOFBhx8YDVdh0oBI7i61h+4takmNYTmDsWEHvZGQYNW36PLaNFC+8fhF2HUBtk7DBmdlsbnRCE0IgJycHb7/9doxqRdQ11V/7adOBSuwrC8+OJWkkDO+djBG5yTildzJMLcyOEXUnGUYNJg/piclDesLt9ePXIzWhzPPhage2H7Fg+xELXl+3H2mGY1m1oTlmrukXZ4JrPwWzY+W14dmx7GQtCnonY0SfFAzu1fLsGBF1Pwnbyq9atSrsb7lcjvT0dPTr1w+SlLBfm6jdVNvd2FwUGLC+uagata7w6XL7ZRhCXXL6Z3CxU6LWUElynNI7cFPj2vFAcY0zNGvfz4drUF7rxpc7SvDljhJIchkG9TKGLvZzkrXMqnUyIQSKKu2BYOxAFXYctcBbL3ulkuQ4OctU1zamINPUtuwYEXU/3W7MWWs899xzeOKJJ1BcXIyhQ4di6dKlGDlyZMSyy5cvx9VXXx32mFqthtPpjPrz4qHfLMecdT8+v8CeUmvoDv7e0tqw5w1qqW7sWOBCMlmnilFNiboHl9eH7YctoWDtaE34eSQ9SR26QXJylhlaFWdH6wgOtw8/H64OjRlsuI5YL5MGBbnJGJGbgsFZRqgl/g7Uvbi8PtQ6vRjZN4VjztpBQqWQPv7446jL/uEPf4iq3DvvvIP58+dj2bJlGDVqFBYvXoxJkyZh165dyMjIiPgao9GIXbt2hf7mnU2KVzUOD7bUjR3bXFQFqzM8O5afrg+NfTmhB7NjRJ1JLSlCYzevR+Cm2ca6jM0vh6tRZnXh8+3F+Hx7MSS5DEOyTKHy2WZm1VpLCIFD1Q5sqgvGth+uCc+OKeQYEsqOJaOXmTcxiaj9JFTmTC6Pri+3TCaLehHqUaNG4dRTT8Wzzz4LAPD7/cjJycGcOXNw9913Nyq/fPlyzJs3D9XV1VHX2+VyweU6difOYrEgJyeHmTNqd34hsLe0NtQlZ3eJFfUbAL1KgWF1Y8eG905Gip7ZMaJ45PT4sP1wDTYeqMLGA5UosYRnc3oY1aEbKydlmaDhmkPNcnp8+PlQTd1ELZUobZAdyzRqQsHYEG5PojDMnLWvhMqc+f3tu76H2+3Gpk2bsGDBgtBjcrkcEydOxLp165p8XW1tLXJzc+H3+zF8+HA8+uijGDx4cJPlFy1ahIULF7Zr3YmCLA4PthysxqYDldhcVI0aR/hip3lp+tBFx4BMI7NjRF2ARqnAiD4pGNEnBUL0xeFqR6hL8vbDNSixuPDZL0fx2S9HoVTIcFJdVm1EbgozPXUCmchKbNxfhe1HauDxHbtVJckbbjMNM5FE1CkSKjhrb+Xl5fD5fOjRo0fY4z169MBvv/0W8TUnnngiXn31VZx88smoqanBk08+ibFjx+LXX39FdnZ2xNcsWLAA8+fPD/0dzJwRtYZfCPxeZguNU9ldYm202OmwHDNG9AlM55xqaHqxUyKKfzKZDNnJOmQn6/DHYVlwuH345XB1qAtkqdWFzUXV2FxUjZe/L0TPujFSBXVZte4yRsrl9eGXwzWh7ooNx/BlJKlDwdjJ2cyOEVFsJHRwZrPZ8O2336KoqAhud/j0trfeemuHfOaYMWMwZsyY0N9jx47FwIED8eKLL+Lhhx+O+Bq1Wg21mhfI1Hq1Ti+2HKwKTedcbQ/PjuWm6ELB2IBWLHZKRF2HVqXAyLxUjMxLDYyfqgpkiDYdqMKvRyw4WuPEJz8fxSc/H4VKIcdJ2cfGTyVaV/ajNccyir8cqoHbd6yHjSSXYXAvYyggy+bsl0QUBxI2ONuyZQumTJkCu90Om82GlJQUlJeXQ6fTISMjI6rgLC0tDQqFAiUlJWGPl5SUIDMzM6p6KJVKnHLKKdi7d2+rvgdRJEIIFJbbQhcdvxVbGmXHhuaYUNA7BQW5yUhPYvBP1B3JZDLkpOiQk6LDhadkB9blOlRTN+60EuW17tAYVADIMmtDWbUhvUxQSV3rRo7b68f2w4GxY5vq1o2rL80QzI4l4+RsE9eNI6K4k7Ct0m233YYLLrgAy5Ytg8lkwo8//gilUomrrroKc+fOjeo9VCoVCgoK8M0332DatGkAAuPavvnmG9xyyy1RvYfP58Mvv/yCKVOmtParEAEAbC4vttZb7LTSFp4NzknR1a1/lIxBzI4RUQQ6lYQxfVMxpm9qaM2ujfXW7Dpc7cDhagc+3nYEakmOk7NNoYlFehjjc82uYoszFGz+fKgGLu+x7JhCLsOgnsZQZrB3io7ZMSKKawkbnG3duhUvvvgi5HI5FAoFXC4X+vbti3/84x+YNWsWLrrooqjeZ/78+Zg1axZGjBiBkSNHYvHixbDZbKG1zGbOnImsrCwsWrQIAPDQQw9h9OjR6NevH6qrq/HEE0/gwIEDuPbaazvsu1JiEkLgQEXwwqkSO4ut8NVLj6klOYZmm0N3ueP1womI4pNMJkNuqh65qXpcPDyQVdt68NhYtUqbGxv2V2HD/kBWLTtZG1pceXCv2N0A8vj8+PXIsfXfDlWFZ8dS9KpQMDYsx8zsGBF1KQnbYimVytDU+hkZGSgqKsLAgQNhMplw8ODBqN/nsssuQ1lZGe6//34UFxdj2LBh+OKLL0KThBQVFYVN4V9VVYXrrrsOxcXFSE5ORkFBAdauXYtBgwa17xekhGR3e7GtXnasvDY8OxbscjQiNxmDu2CXIyKKXzqVhLH5aRibnwYhBPZX2EKB2s6jFhyqcuBQlQMfbT0CjTL85lBGUsfeHCq1OkPdL7cdqobTcyw7JpcBA3seGzvWJ5XZMSLquhJqnbP6zj33XMyePRtXXHEFrrvuOvz888+49dZbsWLFClRVVeGnn36KdRWbFA9rNRTXOPB7mQ1mnSosW0PRU8hlkOQyeP2iyW0Y7Fa0qV63orDFTiU5Tg4tdpqCTBOzY0TU+WpD3aoDE4tUNZh0qHeKLnTjaOBxulVH0zZ6fH7sPGoJBYdFlfaw55N1ylAwNjTHDIM6Ye81E8U9rnPWvhI2ONu4cSOsVivOPPNMlJaWYubMmVi7di369++PV199FUOHDo11FZsU6x3M4fZCIZej2u6GWadEtd2DarsnrB8/NU0tyWHWK2HWKlHj8MCkDd+GDrcPPx+uxsa66ZzLGix22tOkCQVjQ7KM3WaaayLqGvx1ExJtPFCFTfsrsauJ5TqCwVpwuY7jtY3lta7QjaqtB6vh8PhC7ymXASdmHhs7lpemh5zZMaK4wOCsfSVscNaVxXIHc3l8eH71Pry2thAWhxdGrYSrx+bhhgl9cajSwQDtONSSHNkpWiz7dh+Wr90f2oazx/bBteP64p4Pf8EX24vDsmOBBWKPXchwgVgi6kqsTg+2FB3rjt1wofs+qTpMHtITN5/ZDy9937ht/PO4vpjz1mZ8t6c87HVmrRLD6yY5GpZjRpJG2Zlfi4iixOCsfSVsP4C///3vuPLKK5GXlxfrqnQZDrcXy779HUu+2RN6zOLwYsk3eyAgcM7AHnhn46EY1jD+XTYiG8tW78M/Vx5bOsHi8OKf3+yFEMAfhvbCJz8fRQ+jGiPqZkAbksXFTomo60rSKHH6Cek4/YR0+IXAvtLaUHfE3SVW7K+wY3iuGS9+tw9Lm2gbrxqdi+/3lOOEHkmhNRnzMwzMjhFRt5OwmbOhQ4di+/btGDVqFK666ipMnz4daWlpsa5WVGIV/bu9fox45CtYHN5Gzxm1En5ccDbGPb6q0RTuFJCiV+GHu87E6EXfNLkN198zEWv2lCM9Sc0B69RpnB4fHG4ffEJAp1JAo1Twopc6RY3Dg51HLbhqdC5GLfq62bZx68Fq6DmzInUSvxBwenywu31QyGTQ1rWN1HLMnLWvhG0Ft23bhl9//RVvvvkmnnzyScybNw/nnHMOrrzySkybNg06nS7WVYw7Vqcn4okTCNzhrLF78MehvXCkwaKeFNDLrEW1vfltaHV6kZOiY/dQ6lA+v4DD7YPd7YXX74daUkCvkaBSyFHj8KDa7oZMJoNOJUGnUnBNPOowJq0SE05IR63r+G1jik7FtpE6lMfnh72ubQQAjVKBFL0Kbp8fNqcXlTYXJLkcOpUErUoBhZw3sajzJWxwBgCDBw/Go48+ikcffRRr1qzBW2+9hXnz5uEvf/kLLBZLrKsXd5I0Shi1UpN3NlMNKlw6IoezNzZBIZchzaBqdhuatFKjCUCI2oPL64Pd5YPD64VcJoNWJaGnWYNkvQpJGiX0KgVkMhmcHh+sTi9qHG6U17pR5XDD4/NDrVBAp1JAq1Qwq0vtyusXMGmbP7+wbaSOIISAoy475vL5oFTIoVdJ6Juuh0mrQpJGgkapgBACNrcPVqcHlbVuVDk8KKt1wu8PTHCjUys4ORd1moQOzurT6/XQarVQqVSwWq2xrk5c8vn9uHpsXtiYs6Crx+ah2u5hYNYMn1+g2uHhNqRO4fPXXXS4vPD4/VBLchg0SvRO1SJJo0SSRhlxHTyNMtB1Jz1Jjbw0gVqXF1anBxW17lBWTS6XQatkVo3aB9tG6kz1s2NCCGhVElL0KqQaAjeqDGqpUUZMJpPBoJZgUEvoadLC7fXD6vTA6vSgrNYdaCN9bkgyGXRqCVols2rUcRI6OCssLMRbb72Ft956C7t27cKECROwcOFCXHLJJbGuWlzSqiTcdEY+ADQ5WyM1r9rmwQ0T+gLgNqT25/IG7gA73D7I5YE7upkmDVIMqtCFRUuyXgq5DCatEiatEtnJOjg9PlicHtTYPaiwuVFpd8PrC3SLZFaN2oJtI3WUsOyY1wdJIYdBHciOGbVKGDXKFo8lU0lypBrUSDWokZsauIlV6/IGsmp2N0qtHggBaFWBtpFZNWpPCTshyOjRo7FhwwacfPLJuPLKKzFjxgxkZWXFulpRifWgRrvbC0kuR7XDDbOW65y1lFqSw6xTwqxTosbhhUkrcRtSq/iFCN0B9voFVAoZ9GoJ6QY1jFolDBqpwy4KfH6BWqcXVlcgq1btcMPh9kHBrBq1EttGai/B7JjD44XPL6BVKWDW1mXH1IG2saMyW8HJLywOD8pqXbC5vHD7BCT5sXG83W3CJU4I0r4SNnN29tln49VXX8WgQYOQoPFnh9GpJBTXOPB7mQ1mnYpdTVrI5fWjxOJCea0bklyGMquL25Ci5vb6YXN74XD7IJMBOpUCGUY1UvVqJGkk6FUS5J3QnUYhl8GkU8KkC2TVHG4frK5AVq3c6kalzQ2v3w+NpICWWTWKAttGaq1gdszh9sEZzI6pJPRJ1cOkUyJJrYRW1TnZK7WkgNqgqMuq6WFzBya0qbC5UGP3oMTigUCgZ4NeJUXsXk7UnIQNzh555BH861//wvTp07FnT6CPe//+/TFv3jxce+21Ma5d/PMLoNbl5aKfbeDzC1540HH5RWBmRZvbC49PQCUFxj5kJ2th1CqR1IHZsZbQqgJBWEaSBn3TA1k1i9OD8loXLE4Pqh0eKGQyaJQK6FUKSMyqURPYNlI0vD4/bG4fnJ7AMiAapRxmXSA7ZtR0bHYsWnK5LDTGt5dZC5e3bsIluycQrDndcHsFlAoZ9HUzQHa3rBq1XMIGZ/fffz+efvppzJkzB2PGjAEArFu3DrfddhuKiorw0EMPxbiGRNRdub1+2N1e2D0+yBAIfILZMYNGgqGTsmOtVT+rlpNSl1VzBrqnVdS6UWFzwycE1IrAlNQapZxZNSJqlhACTk+gbXR6fZDkgZkVe6foYNYFAqDOyo61VjCrlmZQI8+vR63bi9q6rFq13YMaiwcAoFMqoFdL7BpOESXsmLP09HT885//xIwZM8Ie/89//oM5c+agvLw8RjU7vnjoN3uk2oHth2vQ06SNyecTJZJgdszu9sHj80MpBcYmpBvUMOkCs4clyuKnXp+/bgZIbyCr5vDA4fFDIZNBVzd4nlk1IgIC7YW9rm30CQGtUg6jVok0Q6Abt0EtJUx74fT4UOsKZNXKal2wub3wegWUCnlgwqUunFXjmLP2lbCZM4/HgxEjRjR6vKCgAF5v5IUwiYjai8fnh80Vnh1LNaiQllR30RHn2bHWkhSBrkdmnQo5KTrY6+4cV9ndoaya1y+gkZhVI+puwrNj/rpJNBTonapFsk4Fg0aK2cV9RwsuY5JmUCMvLZBVszq9KLcGuoZb6rJqWmbVur3EPAIA/OlPf8ILL7yAp59+Ouzxl156CVdeeWWMakVEicovBJweH2wuH9w+H5RSoEtOP/OxsWOJkh1ricDsZRIyjJqwrFpZrRNWhxdVDj/kMlmom0+sx5AQUfvy+UXoRpXPX5cd00nIN2gSLjsWLblcBqMmMM1/llkLp6durJrDjfJaN6ocbnh8fqjkCujVgaCuq2bVqOUSNjgDgH/961/4f//v/2H06NEAgJ9++glFRUWYOXMm5s+fHyrXMIAjIopGpMVOg9kxg1pCkjoxs2OtVT+rlp2shaPugqTKFpj9sbw2MHufWpJDr5aglphVI+pqhBBweQM9B+pnx3KStUjWq5CkkTi7awPBrFp6khp5aaLuJlZgDG+Nw4Nquxsy2bGp+plVS2wJG5xt374dw4cPBwDs27cPAJCWloa0tDRs3749VI6NAxFFK2yxU58PSkUgO9Y3XQ+TVtVts2OtcexCQ0IPowYenz+wrlowq+b0otLug1wmh16lgE7FrBpRvPL5BexuL2xuH/wisHB9klZC32B2TMNuetFSyGUwaZUwaQPLmDSVVVMrAmN4GegmnoQNzlatWhXrKhBRAqi/2KnfH8iOpejrFjvVBCbzYNDQdkqFHMl6FZL1KuSkaGF3By5Iqu2BcWplVhd8wh9aAJtBMFFsOetuVDk9dYvT18uOGdSB45RBQ9tFk1WTy2WhtpFBcNeXsMEZEVFrhGXHgoudqiX0MQYWOzVqlAwMOphMJoNeLUGvlpBpOpZVszg9KLO6UOvyotLugkImr5sBkgEyUUcLZscCMysGsmMGtYQ+abrQumMMDDpWpKyaxempW1fNjUq7G15f4LdhVq3rYnBGRN1e/eyYzy+gVSmOZcfU8bHYaXdWP6vWO0UXyqpV2l2osgUCNj/80EjMqhG1p1B2zOuFHHLo1Ar0StYgRReYdZbZsdgKZtUykjTo6xehm1iVNjeqHW5U2d2BrCazal0KgzMi6naC2TGH2xdY7FQhh14poU9qIDuWpI7/xU67q4ZZNbc3MAOkpW48Rq3Ti0qbC4q6BWy1KgUDa6Io+fyBNRltbi98/rrsmEZCbqoWxrpxtbzAj08KuQwmnRImnRI5KTo43D5YXYGsWrk1MOmS1++HRgqsqcasWvxicEZE3YLX54etbnyETwholHKYdErkGwyhLjm8iO96VJIcKZIKKXoVclMFbG4frE4PquxuVNo8KKt1wi8EtFIgUGNWjSics+5GlcPrhVwmg1YlhbJjBo0EPbNjXZK2bmHrjCQN8tL8sLkCXSDLawPrqlU7PFDIZNAoFdCrFN1uOYN4xuCMiBJS+GKnPkh1mZTeKTqYdUokaZgdSzQymQwGdWDdpJ4mLdxeP6xOD6xOD8pq3ah1elBpc0GSBxbAZlaNuqNgdszu9sJblx3TayT0rsuOGdQSVBIv1BOJpJDDpJOHZ9WcHlTbAxOLVNjc8AkBtSLQNmqUXMYklhicEVHC8IbWHQtkx7T1smPddbHT7kwlyZFqUCPVoA7LqlXWulHlqMuq+QGtUgGdWgG1xGCdEpPL64Pd5YPD44NcDmhVgW7BKXWzzjI71r2EsmpGDbw+f90MkN5AVs3hQaXdD4VMVjfhErNqnY3BGRF1WeHZsWOLnfZO1SJZp4JBE1hHi6iprJrF4UG5zR2YmtrnhiSTQacOLJLLrBp1VT5/3ayzLi+8QkClkMGgUSInRQujNtBzgNkxAgJZNbNOBbNOhexkLRyeesuY1GXVvH4BjcSsWmfhVQsRdSk+v4DN5YXd44NfBE4YRp2E/OBip8yOURQaZ9UCd46rbIEZzkqtHggRuMOsV7GbF8U/lzfQa8Dh9kEmA3QqBTJNGiTrAxN56FUS5LzhQM2QyWTQqQI3NXs0yKqV1TphdXhR5fBDLpNBp1RAz3U+OwSDMyKKa0IIuLx+2FxeuLx+KOqyY8HFTpM0EmedojaRy2VI0gSyCb3MWri8gTvHVocHZbUu1Djd8PhEXWY2MCW1nPsbxZhfiLpu3F54/YHsmF4tISc5kB0zaCR21aU2aSqrVmULzP5YXuuCzx9oGxmktR8GZ0QUd4KLndrcPvjrFjtN0kroG8yOcTpn6kBqSQG1QYE0gxq5qfpQVq3C5kKN3YMSiwcCgbFqzKpRZ3J7/bC5vXB4fJAhkB3LMKqRqlczO0YdqmFWzePzo9Z5LKvm8wvetGonDM6IKC4EFzt1eLxQyAKLneYka2HWqbjYKcVMw6ya0+NDrcsbWDsomFXzCkgKWWhdNV6gUHvxi2Prjnl8AiopsJ9lmbWBNRmZHaMYUSrkSNarkKxXISdFW7d/8kZVe2BwRkQxEcyOBWZWrFvsVC2hT5outO4Ys2MUbzTKwFppaQY18tL0qA1m1WpdqHF4UGPxAEBoPAb3YWopj88fGlcLHMuOpdRlxwzMjlGckclkUEncJ9sLgzMi6jTB7JjT64UcgexYcLFTZseoq5HLZTBqlDBqlMiqy6pZnV5Y6saqVTnc8HoFlAo5dHVTVzOrRg0Fs2N2tw8enx9SXXasnzk4s6LExdOJuhEGZ0TUYYKLndrcXvjqFjs1aCTkcrFTSkDBrFp6UiCrZnV5UevyotzqgsXpgaUuq6ZlVq3bC2bHHHXZMa1KgVSDCmlJzI4RdXcMzoioXTk9gamcHV4v5DIZtCoJvZI1SNZxsVPqPuRyGUxaJUza8KxajcON8lo3qhxueHx+qOQK6NWBoI5ZtcTlFwJOjw82lw9uvw9KhRx6lYSeZg1MWhWzY0QUwuCMiNokmB0LTOccyI7pNRJ6p2pDEykwO0bdXXhWTdStHeRBRa0bNQ4Pqu3uerOhKZhVSwAenz801b0QAlqVhFSDCqmGwI0qA9eIIqIIGJwRUYu5vD7YXT44PD7I5YBWJSHTpEGKgdkxouNR1MuqZSfr4PT4At0eHR6U17pRaXcHbnQoFIGxalzHr0sQQsBRN67W5fNBksthUEvom66HURsYm8jsGBEdD4MzIjoun7/uosPlhVcEFjs1aJTISQkOWGd2jKi1glm1jCRNIKvm9MLqCmTVqh1uVNvdkMtl0CqZVYs3weyYw+OF3x/IjqXomR0jotZjcEZEEYUWO3X7IJMFpnPONGmQrFdxsVOiDqKQy2DSKWHShWfVauweVNjqsmq+QPdhZtU6X1h2zOuDpAhkx/oY9TDpmB0jorZjcEZEAAID1u2hsWMCSoUMBrWEnGQtkrRc7JQoFupn1fr6A1k1i9ODSltdVs3hgVwGaJUS9CoFJGbV2p3X54ctmB0TgEYpR4pehRS9KrQmI7NjRNReGJwRdWOh7JjHBxmOLXaaWrfYKbNjRPGjflYtJ0UHh9sHq9ODGocH5VY3KmyBsWoaSQGdSoJGKWdWrRWEEHB6/LC7vXB6A2PH9CoJfVL1MNV149aqeKOKiDoGgzOibiS42KnN7YXXJ6CsW+w0y6yFScfsGFFXoq1b2DrDqEFemr9uBkgvymtdsDg8qHL4oZDJoFEqmFU7jmB2zOnxwScENJIcJp0S+QZDYN0xtcTtR0SdgsEZUYILLnZqr1vsNJgdS9FzsVOiRCEp5DDrVDDrVMhJ0cHu9qLW6UW1PTCxSCCrFgg6mFVrmB3zQ5IHblT1TtHBrGN2jIhih8EZUYIJZsfsbh88Pj+kuuxYP3NwZkUudkqU6ALrpUnIMGrg9TXOqlXaA1k1nSowsUh3yAp5Q+uOBbJjWmUwO6ZmdoyI4gaDM6IEEMyOOeqyY1qVAqkGFdKSmB0j6u7qZ9Wyk7VweHywOr2otrsbZdX0aglqKTGyakIIuLyBtjGYHdOpFOidqoVZF5h1lrNdElG8YXAWz2w2QBEhw6FQABpNeLmmyOWAVtuqsnKHHTKlP3JZmQxCqzv2p8MOCBFlWQcgmnhfAEKnb11ZpxPw+9qnrFYH1J2wZS4X4PO2T1mNNrCdAcjcbsDraVXZQJccH2wuHzx+P+Q6LfRaNXqaNTApgCSFqMuO+QGfG3C4j72xRnNsv/J4AHe95xpSqwFJanlZrxdwuZouq1IBSmXLy/p8gNPZdFmlMlC+pWX9fsDhaJ+ykhTYFkDgmLDb26dsS477TmojYG/+uIdO17qyDkdgOzdFr29dWaczsF+0R1ndseMeLldgP26Pstpjxz3c7sBx1x5l6457mUwGHfzQKXzokaSAV6eG1emFzeVFWa0T1mobKhUqyKXA7I86mYDka6adUoW3ETJP021EWFmvFzJ308e9UIa3EdGW9Xm8cFhqYff4IASgkmQwayWkmTTQqyUkJWkhaeuODZ+v+WOObUQA24jWle2ibUSLy8bLdURz+2VXIyju1NTUCACiJtBMNf43ZUr4C3S6yOUAISZMCC+bltZ02REjQsUOV9mFvVd2k2UdJwwQPx+sDv1znDCgybKu7JywsraTT2myrCclNaysdfRpTZb1aXVhZWvOOrfp7waEla0+/4/Nlv1l1+FQ2cpLZjRb9tete0Nly2de22zZnWu3hcqW3jCn2bK7vl4XKlt8213NlrV+t1Z4ff7Aj/ePfzRbVqxadWx/ePbZ5st+8smxsq+91nzZd989Vvbdd5sv+9prx8p+8knzZZ999ljZVauaL/uPfxwru35982UfeOBY2e3bmy97xx3HyhYWNl/2ppuOlS0tbb7srFnHytbWNl/2kkvCj+XmynZCGyGEECI3t+mygwaFlx00qOmyubnhZUeMaLpsWlp42QkTmi6r04WXnTKl+e1W3yWXNF+2tvZY2Vmzmi9bWnqs7E03NV+2sPBY2TvuaL7s9u3Hyj7wQPNl168/VvY4bUTFJ1+KnUdqxA97ysTOvz3abNnC5e+E2qmip55rtuz+F5aHyu5/YXmzZYueei5UtnD5O82/74OPi1U7S8QXvxwVG1/7oPntwDYi8I9tROAf24hj/1rQRsTjdUQNIACImpoa0dUxc0YUp4QQsLu9sLt90Do96NFMWYNGAthtkYjaQYpehZSeRnh8fnhSdMd/QYy5fH4kaSX0NWiQ3CMp1tUhImoTmRBCxLoSFM5iscBkMqHmyBEYjcbGBTqhO8KRagd27D2KTKMmcll2a2xd2eN0awwOWHd4fPCq1NBolDBrVUhVAUlyNL3YaVfvjsBujccvyy5Lx7DLUsvLtrGNCNws8qHW6UWVw40qmxt2lw9epRIarQY6lQIa+DusW6PbZoe9bqp7uUwGnVqBZL0KyVoVDEYddHpNYOwY24hjf7ONaHlZthEtLxsn1xGWsjKYevVCTU1N5GvnLoTBWRwKBWcx3MGOVDuw/XANepq0xy9MrSaEgMMTmD3M5fVBUshhUEtI1atg0ilh1Cg5syIRxR2Pzw+r0wur04Myqwu1Ti9cPh8UssCCzVqVIvKNpCj5/MfWZPQJP9QKBQwaCelJaiRpArPOKjmzIhHViYdr5/bCli0Kzz33HPr06QONRoNRo0Zh/fr1zZZ/7733MGDAAGg0Gpx00kn47LPPOqmm1BV4fX7UODwotjhw1OKE0+tDil6Fwb1MODU3Baf2SUH/HknISNIwMCOiuKRUyJGiVyE3VY+C3GSMyEvB0Oxk9ErWwAeBMqsLR2rsqLS54fQ0k12ox+nxodLmxpEaO8qsLvgg0CtZg6HZgfcvyE1GbqoeKXoVAzMiSlgcc3Yc77zzDubPn49ly5Zh1KhRWLx4MSZNmoRdu3YhIyOjUfm1a9dixowZWLRoEaZOnYq33noL06ZNw+bNmzFkyJAYfAOKNSHqL3bqgyQP3Fnuk6qHScvFTomoa5PJZDCoA+uEZZo0cHsD66pZHG6U17pR6/Si0uaCQh6eVQvLjvn9UEuB7FhuqhZGrQoGtQSVxCCMiLoXdms8jlGjRuHUU0/Fs88+CwDw+/3IycnBnDlzcPfddzcqf9lll8Fms+GTTz4JPTZ69GgMGzYMy5Yti/gZLpcLrnr9ai0WC3JycmLerXHrweo2dUshBOYOkgEaSQ6jVok0LnZKRN2IEAI2tw9WpwdVNjcq7R443F74/AIKuQxalYQUvRLJOhWSNEroVVx3jIhaLpG6NTJz1gy3241NmzZhwYIFocfkcjkmTpyIdevWRXzNunXrMH/+/LDHJk2ahI8++qjJz1m0aBEWLlzYLnVuLyatEkN6mWJdjYSgUcqZHSOibql+Vq2nSQu31w+r0wOHxwetUoEkjZLZMSKiehicNaO8vBw+nw89eoRPYt6jRw/89ttvEV9TXFwcsXxxcXGTn7NgwYKwgC6YOYslvVqCXs3dg4iI2o9KkiPVoI51NYiI4havvuOAWq2GWs2TFRERERFRd8a+BM1IS0uDQqFASUlJ2OMlJSXIzMyM+JrMzMwWlSciIiIiIgKYOWuWSqVCQUEBvvnmG0ybNg1AYEKQb775BrfcckvE14wZMwbffPMN5s2bF3rsq6++wpgxY6L+3OAcLRaLpdV1JyIiIiLqDoLXzIkwzyGDs+OYP38+Zs2ahREjRmDkyJFYvHgxbDYbrr76agDAzJkzkZWVhUWLFgEA5s6diwkTJuCpp57C+eefj7fffhsbN27ESy+9FPVnWq1WAIj5uDMiIiIioq7CarXCZOraE9oxODuOyy67DGVlZbj//vtRXFyMYcOG4YsvvghN+lFUVAS5/Fjv0LFjx+Ktt97Cvffei3vuuQf9+/fHRx991KI1znr16oWDBw8iKSmp06cUDk5GcvDgwS4/FSnFDvcjaivuQ9QeuB9RW3Ef6hqEELBarejVq1esq9JmXOeMwiTSOhEUO9yPqK24D1F74H5EbcV9iDobJwQhIiIiIiKKAwzOiIiIiIiI4gCDMwqjVqvxwAMPcN01ahPuR9RW3IeoPXA/orbiPkSdjWPOiIiIiIiI4gAzZ0RERERERHGAwRkREREREVEcYHBGREREREQUBxicERERERERxQEGZ0RERERERHGAwRkREREREVEcYHBGREREREQUBxicERERERERxQEGZ0RERERERHGAwRkREREREVEcYHBGREREREQUBxicERERERERxQEGZ0RERERERHGAwRkREREREVEcYHBGREREREQUBxicERERAbjqqqug0Wiwe/fuRs899thjkMlk+OSTT1BRUYEnnngCp59+OtLT02E2mzF69Gi88847Mag1ERElEpkQQsS6EkRERLFWWlqKAQMGYNiwYVi5cmXo8cLCQgwePBhTpkzB+++/j08++QQXXXQRpkyZgjPPPBOSJOGDDz7AqlWrcP/992PhwoUx/BZERNSVMTgjIiKq8/LLL+P666/H8uXLMWvWLADA5MmTsXbtWuzYsQNZWVkoLCyEXC5Hbm5u6HVCCEycOBFr1qxBRUUF9Hp9rL4CERF1YezWSEREVOfaa6/FaaedhjvuuAMVFRV4++238cUXX+Dvf/87srKyAAB5eXlhgRkAyGQyTJs2DS6XC7///nssqk5ERAlAinUFiIiI4oVMJsOLL76IU045BTfeeCO+//57jBgxAjfffPNxX1tcXAwASEtL6+hqEhFRgmK3RiIiogbuueceLFq0CAqFAuvXr8fw4cObLV9ZWYmBAwfixBNPxHfffddJtSQiokTDbo1EREQNBLNfvXr1wpAhQ5ot6/f7ceWVV6K6uhpLly7tjOoREVGCYnBGRERUz8GDB/HAAw9gyJAhOHjwIP7xj380W37OnDn44osv8Morr2Do0KGdVEsiIkpEDM6IiIjqueWWWwAAn3/+OS699FI88sgjTU7ysXDhQjz//PN47LHH8Kc//akzq0lERAmIwRkREVGdDz/8EB9//DEefvhhZGdnY/HixVCpVBEnBHnuuefw4IMPYt68ebjrrrtiUFsiIko0nBCEiIgIgNVqxaBBg5Ceno4NGzZAoVAAAP75z39i7ty5ePfdd3HppZcCAN555x1cccUVmDFjBlasWAGZTBbLqhMRUYJgcEZERARg7ty5ePbZZ/Hjjz/i1FNPDT3u8/kwcuRIFBcX47fffsPOnTsxfvx4mEwmPP7441AqlWHvM3bsWPTt27ezq09ERAmAwRkREXV7mzZtwqhRo3DjjTdGnHFxw4YNGD16NG655RaccsopuPrqq5t8r9deew2zZ8/uwNoSEVGiYnBGREREREQUBzghCBERERERURxgcEZERERERBQHGJwRERERERHFAQZnREREREREcYDBGRERERERURxgcEZERERERBQHpFhXgBrz+/04cuQIkpKSIJPJYl0dIiIiIqK4JYSA1WpFr169IJd37dwTg7M4dOTIEeTk5MS6GkREREREXcbBgweRnZ0d62q0CYOzOJSUlAQgsIMZjcYY14aIiIiIKH5ZLBbk5OSErqG7MgZnx/Hdd9/hiSeewKZNm3D06FF8+OGHmDZtWrOvWb16NebPn49ff/0VOTk5uPfeezF79uyoPzPYldFoNDI4IyIiIiKKQiIMB+ranTI7gc1mw9ChQ/Hcc89FVb6wsBDnn38+zjzzTGzduhXz5s3Dtddeiy+//LKDa0pERERERF0ZM2fHMXnyZEyePDnq8suWLUNeXh6eeuopAMDAgQPxww8/4JlnnsGkSZMivsblcsHlcoX+tlgsbas0ERERERF1OQzO2tm6deswceLEsMcmTZqEefPmNfmaRYsWYeHChR1cs5apcXhwpNoBIWJdk65NJgMMaglJGgkGtQRJwWQ1ERFRIvP5fPB4PLGuRkJRKpVQKBSxrkanYHDWzoqLi9GjR4+wx3r06AGLxQKHwwGtVtvoNQsWLMD8+fNDfwcHNcaSzeVFYZkNaiWDiTYRgMfvhySXQ6+SkGpQwaxTIkmjhFbVPRoZIiKi7kAIgeLiYlRXV8e6KgnJbDYjMzMzIcaVNYfBWRxQq9VQq9WxrkYjkkKGjCRNrKuRELw+P2xuH4oq7SisENAo5TBqlEgzqGHUKGHQSFDIE7uxISIiSmTBwCwjIwM6nS7hg4jOIoSA3W5HaWkpAKBnz54xrlHHYnDWzjIzM1FSUhL2WElJCYxGY8SsGXUPkkIOk1YOk1YJIQQcHh9q7B6UWJyQFHLolRLSklQw6ZRIUjOrRkRE1JX4fL5QYJaamhrr6iSc4DV0aWkpMjIyErqLI4OzdjZmzBh89tlnYY999dVXGDNmTIxqRPFGJpNBp5KgUwUOP4/PD7vbh/0VNvjLBDQqBcxaFVINKiSpmVUjIiKKd8ExZjqdLsY1SVzBbevxeBicdWe1tbXYu3dv6O/CwkJs3boVKSkp6N27NxYsWIDDhw/j3//+NwDgL3/5C5599ln89a9/xTXXXIOVK1fi3Xffxaeffhqrr0BxThkhq1Zpc+OoxQFJLodBLSFVH8iqGTVKaJSJ2yARERF1ZezK2HG6y7ZlcHYcGzduxJlnnhn6Ozhxx6xZs7B8+XIcPXoURUVFoefz8vLw6aef4rbbbsOSJUuQnZ2NV155pclp9InqayqrVlhugxACWpUEk1YZyKpplDComVUjIiIiShQMzo7jjDPOgGhmPvnly5dHfM2WLVs6sFbUXTSXVVMqAjNAphlUMGlVSNJIzKoRERERdWGcJ52oiwhm1dIMamSZdEjWquD1CfxeZsOWoiqsL6zEtoPVOFztQI3DA7+fi9QRERFR6+3fvx8ymQxbt26N+jXLly+H2WzusDolOmbOiLqo+lk1vxBwenyoqHWjuMYJSZJBr5KQblDDqFUyq0ZERETUBTA4I0oA8ghj1WwuL/aW1QIAdCpF3Vg1NZI0EgwqCXKOVSMiIiKKK+zWSJSAlAo5zDoVepm0yDRqoJTLUWZ1YfuhGmzcX4n1+yuxr7QW5bUuOD2+WFeXiIgocdlsTf9zOqMv63Acv2wrfPHFFxg3bhzMZjNSU1MxdepU7Nu3L2LZ1atXQyaT4dNPP8XJJ58MjUaD0aNHY/v27Y3Kfvnllxg4cCAMBgPOO+88HD16NPTchg0bcM455yAtLQ0mkwkTJkzA5s2bW1X/RMPgjCjByWUy6NUSMpI06GXWwqRRweP1Y29ZLTYfqMKG/ZX45XA1jlQ7YHFyrBoREVG7Mhia/nfxxeFlMzKaLjt5cnjZPn0al2kFm82G+fPnY+PGjfjmm28gl8tx4YUXwu/3N/maO++8E0899RQ2bNiA9PR0XHDBBaG13gDAbrfjySefxIoVK/Ddd9+hqKgId9xxR+h5q9WKWbNm4YcffsCPP/6I/v37Y8qUKbBara36DomE3RqJuhmVJIdKUsEMwC8EHG4fSi0uHKl2QqmQwaAOjFVLqhurppY4Vo2IiChRXdwgQHz11VeRnp6OHTt2wNBEwPfAAw/gnHPOAQC8/vrryM7Oxocffojp06cDCCwUvWzZMuTn5wMAbrnlFjz00EOh15911llh7/fSSy/BbDbj22+/xdSpU9vtu3VFDM6IurFgVk2vDjQFbq8fNrcXu0tqIZMFxqqZdSqk6ANT9es5Vo2IiKhlamubfk7R4AZoaWnTZeUNOrzt39/qKtW3Z88e3H///fjpp59QXl4eypgVFRVh0KBBEV8zZsyY0P+npKTgxBNPxM6dO0OP6XS6UGAGAD179kRpve9WUlKCe++9F6tXr0ZpaSl8Ph/sdnvY2sHdFYMzIgoJZtWSdYDPH1hXraTGicPVDqgUgUAuOAOkgVk1IiKi49PrY1+2GRdccAFyc3Px8ssvo1evXvD7/RgyZAjcbner31OpVIb9LZPJwtYNnjVrFioqKrBkyRLk5uZCrVZjzJgxbfrMRMHgjIgiUsgDXRwNdVk1l9cHu9uH3SW1kMsBrVKBZJ0KKQZVqJxMxqwaERFRV1FRUYFdu3bh5Zdfxvjx4wEAP/zww3Ff9+OPP6J3794AgKqqKuzevRsDBw6M+nPXrFmD559/HlOmTAEAHDx4EOXl5a34BomHwRkRRUUtKaCWFGFZteIaJw5V2aGS5DBolEg3qJCkUSJJo4RK4nxDRERE8Sw5ORmpqal46aWX0LNnTxQVFeHuu+8+7useeughpKamokePHvjb3/6GtLQ0TJs2LerP7d+/P1asWIERI0bAYrHgzjvvhFarbcM3SRy8eiKiFgtm1TKMGvQy65CkUcLh8mFXiRWbi6qwfn8ldhytwdEaB2pd3rCuDERERBQf5HI53n77bWzatAlDhgzBbbfdhieeeOK4r3vssccwd+5cFBQUoLi4GP/3f/8HlUoV9ef+61//QlVVFYYPH44//elPuPXWW5GRkdGWr5IwZIJXTXHHYrHAZDKhpqYGRqMxJnU4Uu3A9sM16GniXQxqGZ8/MAOkze2Fz++HWlLAoJGQZlDBqA10gWRWjYiIEonT6URhYSHy8vKg0WhiXZ0Os3r1apx55pmoqqqC2Wzu1M9ubhvHw7Vze2G3RiJqVwq5DAaNBIMm0Lw4PT7YXD5U2KyQQw6tWoEUvRIpOjWSNBJ0KgXHqhERERGBwRkRdTCNUgGNUgFAFcqqHaly4mClHWpFIKuWnqSuG6smQalgVo2IiIi6JwZnRNRpmsqqlddaoJDJoVMrkKpXwaxTMatGREQUZ8444wyOI+9gDM6IKGYaZtXsbi8OVjlwoNIGtaRAkkZCukEDo1aCWRf9QGMiIiKirojBGRHFBYVcFpqGXwgBl9cPq8OLcqsFakmOAT2NyDQl7iBrIiLq+phV6jjdZdsyOCOiuCOTyepl1YAquxu7ii1QKmRINahjXDsiIqJwSqUSAGC327leVwex2+0Ajm3rRMXgjIjiXrJOhTKrC7uKrRiSLYdRk9gNMxERdS0KhQJmsxmlpaUAAJ1OxzHT7UQIAbvdjtLSUpjNZigUilhXqUMxOCOiLiHNoEKJ1RkI0HqZoFUlduNMRERdS2ZmJgCEAjRqX2azObSNExmDMyLqEmQyGTKSNDha48DuEisG9jRyMWsiIoobMpkMPXv2REZGBjweT6yrk1CUSmXCZ8yCGJwRUZchl8nQI0mDIzUOKCUZTuxhhELObiNERBQ/FApFtwkkqP3xtjMRdSmSQo4MgwZFFXYUltd2m9mbiIiIKPExOCOiLkclyZGsU6Gw3IZDVY5YV4eIiIioXbBbIxF1STqVBJ9fYE+pFSpJjh5GroFGREREXRszZ0TUZSVplJBkcuwqtqLK5o51dYiIiIjahMEZEXVpyXoVPF4/dhVbUevyxro6RERERK3G4IyIurz0JDVqnB7sKrbA6fHFujpERERErcLgjIi6PFndFPtlFhd2l1jh8fljXSUiIiKiFmNwRkQJQSGXIcOoweEqB/aV1sLv5xT7RERE1LUwOCOihKFUyJGepMaBSjv2V9i4BhoRERF1KQkfnLndbuzatQteLycKIOoO1JICZq0S+8psOFLjjHV1iIiIiKKWsMGZ3W7Hn//8Z+h0OgwePBhFRUUAgDlz5uCxxx6Lce2IqCPpVBK0SgV2F1tQamWARkRERF1DwgZnCxYswLZt27B69WpoNMcWp504cSLeeeedGNaMiDqDSauEDDLsLraixu6JdXWIiIiIjithg7OPPvoIzz77LMaNGweZTBZ6fPDgwdi3b18Ma9Y1yGWAQS1BIZcdvzBFpJDLoJbk3IYxlGpQw+nxY2exBTaugUZERERxTop1BTpKWVkZMjIyGj1us9nCgjVqzOH2IkWvhlwmg1mnRLXdg2q7By4vpyePhlqSw6xXwqxVosbhgUnLbRhLGUlqHK1xYneJFQN7GqFRKmJdJSIiIqKIEjY4GzFiBD799FPMmTMHAEIB2SuvvIIxY8bEsmpxzeXxYdm3v+O1tYWwOLwwaiVcPTYPN0zoi0OVDgYXx6GW5MhO0WLZt/uwfO1+bsM4IJPJ0MOoQbHFAaVCjgGZSZAUCdtpgIiIiLqwhA3OHn30UUyePBk7duyA1+vFkiVLsGPHDqxduxbffvttrKsXlxxuL5Z9+zuWfLMn9JjF4Q39feWo3iixuGJVvS7BrFdi2bf78M9v9oYe4zaMPYVchowkDQ5X2aFSyNEvwwA5u5sSERFRnEnY4GzcuHHYunUrHnvsMZx00kn4f//v/2H48OFYt24dTjrppFhXLy4p5HK8trYw4nOvrS3EXybkY/47W2FxcuxOJEaNhJdnnYrla/dHfP61tYW4+cx8lNe64eMCyZ1OqZAjRa9GYXktVJIMual6dnEmIiKiuJKwwRkA5Ofn4+WXX451NboMq9MDiyNy4GVxeFFhc6Gs1o1dJdZOrlnXcGKPJJTXuprfhrVu7Cq2IDtZx7FPMaBRKmDSqrC31AaVpEAvszbWVSIiIiIKSdjgLLiuWVN69+7dSTXpOpI0Shi1UsTgwqiVkGZQY/qIbDg9HDMViUYpR3qSutltaNIp8fCnO2F1enBSlgkFuSkYkZvMIKET6dUSvH6B3SVWqCQ50gzqWFeJiIiICEACB2d9+vRptsuSz+frxNp0DT6/H1ePzQsbcxZ09dg8WBwejMxLjUHNug6L09PkNpw9tg92HrVAIZfB4xPYXFSNzUXVePl7oKdJg4LcZIzITcGQLCPUErNqHcmkVaK81oVdxVYos+QwaZWxrhIRERERZEKIhBz8sm3btrC/PR4PtmzZgqeffhqPPPIILrroohjV7PgsFgtMJhNqampgNBo79bNdHh+eX72PszW2UnC2xhebmfHS6fHhYJUDG/dXYlNRFXYcscBbbwyaSpLj5CxTKFjLNGma+URqixKLEyadEoN7GaFTJey9KiIiooQWy2vn9pawwVlTPv30UzzxxBNYvXp1rKvSpFjvYHa3F5JcjmqHG2au0dViakkOs04Js06JGocXJq3U7Da0u73YdqgGm+qCtfJad9jzWWYtCnKTUZCbjCG9TFBJnAa+vfiFwNEaBzKNGgzsxYwlERFRVxTra+f21O2Cs71792Lo0KGw2WyxrkqT4mEHK65x4PcyG8w6FWcWbCWFXAZJLoPXL6LehkIIHKiwY1NRFTbur8TOYmvYa9WSHCdnmzAiNwUFucnoYWRWra18foFiiwO9U3Q4oQfXQCMiIupq4uHaub0kbD8ei8US9rcQAkePHsWDDz6I/v37x6hWXYdfALUuL5I0HIvTWr4WBGVBMpkMfdL06JOmx8XDs2FzebH1YDU2FVVh0/4qVNrd2LC/Chv2VwEAcpK1oe6Pg3oZoWRg0WLBNdAO1q2Blp9h4BT7REREFBMJG5yZzeZGF1hCCOTk5ODtt9+OUa2IWkavlnBavzSc1i8NQgjsr7Bh4/4qbCqqws6jFhyscuBglQMfbT0CjVKOodnmUBfIjCRm1aKlVMiRrFXj93IbVJIcvVP1sa4SERERdUMJG5ytWrUq7G+5XI709HT069cPkpSwX5sSmEwmQ16aAXlpBlw6Ige1dVm1jfsrsbmoClV2D34qrMRPhZUAgN4pOoyoC9QG9mRW7Xi0KgV8fiV2l9ZCJSk4EQsRERF1um435qw1nnvuOTzxxBMoLi7G0KFDsXTpUowcOTJi2eXLl+Pqq68Oe0ytVsPpdEb9efHQb/ZItQPbD9egp4nrb3UFfiHwe5mtrvtjJXaVWFG/R6VWqcCwHHNdF8hkpHJtryZV2d0QEDgpy4wUvSrW1SEiIqLjiIdr5/aSUCmkjz/+OOqyf/jDH6Iq984772D+/PlYtmwZRo0ahcWLF2PSpEnYtWsXMjIyIr7GaDRi165dob85foU6mlwmQ78MA/plGHDZiBxYnR5sKarGpgOBLpA1Dg/W/V6Bdb9XAAD6pOpCC2APyOQkGPUl61QotTqxq9iCIVkmjrskIiKiTpNQmTP5/2/vzuPjqOv/gb9mdvbeZHMnbe7Su6VnegK2VRApoqgoInxbKocXlYKoVBEEhMohghQtiFCvyqE/kC8oyJejAi3QphcttKVtrh65j713do7fH5Nsu+Ro0m6ym83r+XjkAdl97+5npzOTec/7c4j9u8AUBKHfi1DPmzcPc+bMwdq1awEAmqahuLgYK1euxM0339wtfv369Vi1ahXa29v73e5wOIxwOBz93ePxoLi4mJUzigtN13Gw0YetNW2orGnD/gYvTjzoHRYTZhZ3jVXLYrUIxvjUek8IWU4Lpox2w27hFPtERETJipWzJKVp8V2HS5ZlVFZWYvXq1dHHRFHEueeei82bN/f6Op/Ph9LSUmiahlmzZuHuu+/GlClTeo1fs2YNbr/99ri2naiLKAgYl5+GcflpuGxuCTqCEWyvbYtW1bwhBe8cbME7B42q2pgcZ3RSkYkF6TCJI6/yKwgC8tNtONYRwv4GLyaNSuf6ckRERDToUqpyFm9Hjx5FYWEhNm3ahAULFkQf/9GPfoSNGzfivffe6/aazZs34+OPP8a0adPQ0dGB+++/H//973+xZ88eFBUV9fg5rJxRoqiajgONPmytaUVlTRs+bvTFPO+0mjCz2BinNqs0E5mOkVVVU1QNDd4wSrPtGJ8/MhNVIiKiZMfK2TDh9/uxceNG1NbWQpblmOe+//3vD8pnLliwICaRW7hwISZNmoRHH30Ud955Z4+vsVqtsFo5QQMNPZMoYEJBGiYUpOHyeaVoD8jYVtuOyppWbKtthy+s4O0DzXj7QDMAYGyuC7PLMlFRkolx+Wkpn6xIJhE5LgtqWoKwmEwYk+vkGFIiIiIaNCmbnG3fvh1Lly5FIBCA3+9HVlYWmpub4XA4kJeX16/kLCcnByaTCQ0NDTGPNzQ0oKCgoF/tMJvNmDlzJg4cOHBK34NoKGU4LPj0xDx8emIeVE3H/gYvKmvasLWmFQeb/DjQ5MOBJh+e3lKHNKuEmSWZqCjLxKySTLjtqTlxhlUyIdNhxqFmH6xmEUWZjkQ3iYiIiFJUyiZnN9xwAy666CKsW7cObrcb7777LsxmM6644gpcf/31/XoPi8WC2bNn47XXXsPFF18MwBjX9tprr+G6667r13uoqooPPvgAS5cuPdWvQpQQJlHApFHpmDQqHVfML0WbXzam6q9pw/baNnjDCv77cRP++3ETBADj8l2YXZKJirIsjM1zQUyhCpPDIkFRjWTVYhKRl8410IiIiCj+UnbMWUZGBt577z1MmDABGRkZ2Lx5MyZNmoT33nsPy5cvx969e/v1Pk8//TSWL1+ORx99FHPnzsWDDz6IZ555Bnv37kV+fj6WLVuGwsJCrFmzBgBwxx13YP78+Rg7diza29tx33334fnnn0dlZSUmT57cr89Mhn6zHHNGfVE1HXvrPcakIjVtONTsj3k+3SZhVmkmZpcYVbX0FKmqtfpliCJwZqEbGSNs/B0REVGySoZr53hJ2cqZ2WyOTq2fl5eH2tpaTJo0CW63G3V1df1+n0svvRRNTU249dZbUV9fjxkzZuDll19Gfn4+AKC2tjZmCv+2tjZcc801qK+vR2ZmJmbPno1Nmzb1OzEjGg5MooApo92YMtqNZQvK0OILY1ttG7bWtGFHXTs8IQVv7mvCm/uaIArAuLw0VJQZydoZw7iqluW0oMETwt56L6YWuuGypuwplIiIiBIgZStnn/3sZ3HllVfiG9/4Bq655hrs2rUL3//+9/HnP/8ZbW1tPc60mCySIftn5YxOlaJq+Kje21lVa0V1SyDm+Qy7GbM6x6rNLM6Ey9Z3gmMSBUiiAEXToWqJP13puo5jnhByXMYaaDYz10AjIiJKpGS4do6XlE3Otm7dCq/XiyVLlqCxsRHLli3Dpk2bMG7cODzxxBOYPn16opvYq2TYwZicUbw0+8LR7o876toRjBxfAF4UgAkF6ZhdakzXPybn+GyIVklEhtOMDLsZHcEI3HYz2gMRtAciCCvxXdNwoFRNR31HEKMz7Zg0Kh1mE9dAIyIiSpRkuHaOl5RNzoazZNjBmJzRYIioGj485umcAbINda2xVbVMhxmzSzPxmUn5+OKM0Vi38SDWb6qGJ6gg3S5hxcJyfGvRGBxuDSY8QYuoGhq9IZRlOzE+Pw1iii8rQERElKyS4do5XlI2OfvFL36Byy+/HOXl5YluyoAlww7G5IyGQqMnFJ0BckddezTh+v2y2dh1uAMPv959CYrrPzMOl88rQYMn3O25oRaKqGjxhzEhPw1lOVwDjYiIKBGS4do5XlK2L86zzz6LsWPHYuHChfjtb3+L5ubmRDeJiD4hL92GC6aOwi0XTsbfrpmPO784Fd+YW4Kzxubgj5ure3zNk5uqkOEwJ8UC2DazCZkOCw42+XG0I5To5hAREdEwl7LJ2c6dO7Fr1y4sXrwY999/P0aPHo0LL7wQGzZsQCAQOPkbENGQMptEzCjOwJULy+APK/AElR7jPEEFHUEFUhIkZ4CxBprNbMLH9V40eRNfzSMiIqLhK2WTMwCYMmUK7r77bhw6dAhvvPEGysrKsGrVKhQUFCS6aUTUC0XT4babkW7veRbHdLsEp9WEypq2IW5Z79yd67jta/CiIxBJcGuIiIhouErp5OxETqcTdrsdFosFkQgvnoiSlarpaA9GsGJhz+NFly8ow9sfN2P1cx/g9v/dg8NtyVEJz3ZZEZJV7K33wB/uuepHRERE1JeUTs6qqqpw1113YcqUKaioqMD27dtx++23o76+PtFNI6I+tPsj+NaiMbj+M+OiFbR0u4TrPzMO31l8BrZWt8IkCtha04br/rYdj791CL4kSIjy0qxoC8jY3+BFWFFP/gIiIiKiE6TsbI3z58/Hli1bMG3aNFx++eW47LLLUFhYmOhm9UsyzDjD2Rop0aySiAyHGRkOMzqCCtx2KWads8NtAfzh7Sps7ezemG6TcMX8Unx2ckFCJwtRNR31niCKMh2YWJAGiWugERERDapkuHaOl5RNzn7605/i8ssvx+TJk9H1FYfLNNfJsIMxOaNkYRIFSKIARdOhat1PV9tq2vD424dQ1xYEAJRlO3D1OWMwvShjiFt6XNcaaGNyXBib5+IaaERERIMoGa6d4yVlb+nedddd2Lx5M6ZOnQqbzQabzYapU6fi8ccfT3TTiGgAVE1HWNF6TMwAYFZpJn7z9Zm49pwxcFklVLcEcMvzu3HXvz7EsY7gELfWYDaJyHZaUd3iR12SjIkjIiKi5NfzdGgp4NZbb8UDDzyAlStXYsGCBQCAzZs344YbbkBtbS3uuOOOBLeQiOJFMom4aPpoLBqfi7+9X4t/7T6Gdw+1Ymt1G744YzS+VlEMh2VoT3c2swlpNjM+bvDBIomsQhMREdFJpWy3xtzcXPzmN7/BZZddFvP43/72N6xcuTKpF6VOhtIsuzXScFbT4scf3q7C9rp2AECGw4z/mV+Kz0zMH/LxaO0BGZquY2qhG9ku65B+NhER0UiQDNfO8ZKy3RojkQgqKiq6PT579mwoSuJndSOiwVOa7cTtX5iCn104GaPdNrQHInj49QO48dkd2HO0Y0jbkuGwQNWAvfVeeEJcxoOIiIh6l7LJ2f/8z//gd7/7XbfHH3vsMVx++eUJaBERDSVBEDC3PAtrvzELV51VDofFhENNftz8/z7AL1/eiwZPaMjakuOyICAr2FfvRVDmFPtERETUs5Tt1rhy5Ur86U9/QnFxMebPnw8AeO+991BbW4tly5bBbDZHYx944IFENbNHyVCaZbdGSjXtARl/ea8Wr35YD00HzCYBX5pZhEtmFcFuMQ3652u6jmMdQYxy2zFpVDosUsreGyMiIhpSyXDtHC8pm5wtWbKkX3GCIOD1118f5NYMTDLsYEzOKFVVNfvw+7eq8MERo3tjltOC5QtKsXhCHsRBXm6jaw20kiwHJhSkJ3Q9NiIiolSRDNfO8ZKyydlwlgw7GJMzSmW6ruPdQy144p1q1Hd2bxyf78I1Z4/BxFGDe8zJioZmfwhn5LpwRq5r2Ky/SERElKyS4do5XtivhohGHEEQsOCMHDzyjVlYtqAUdrMJ+xt8+OE/duH+/+xDsy88aJ9tkURk2q041OTHYa6BRkRERCdgckZEI5ZFEvHV2cVYd8VsnDspDwKAjfub8K2/VOJv79ciFBmcyTvsFhNcVgn7G31DOjEJERERJTcmZ0Q04mU5Lbj+M+PxwNdmYNKodMiKhg3v1+I7f92GjfubMBi9v9NsZpgFEfvqvWj1y3F/fyIiIhp+mJwREXUam+fCPV8+Ez86fwJy06xo9oVx/3/24cf/2IWPG7xx/7xMpwURRcP+ei+8XAONiIhoxGNyRkR0AkEQcM64XPzu8lm4fF4JrJKIj+q9uPHZnXjw//bHvcqVm2aFJxTBvnrvoHWjJCIiouGByRkRUQ+skglfn1OCdVfMxuIJuQCA1/Y24lt/2YpnttZBVrS4fI4gCMhLs6HZJ2NfgxcRNT7vS0RERMMPkzMioj7kuKz4wXkTcN8l0zAhPw2hiIY/v1uD7/y1Eu8caI7LeDSTKCA/zYpj7SEcaPRC1bjCCRER0UjE5IyIqB8mFqTj3kum4cbzxiPbaUGjN4xfvrwXP3nuAxxq8p32+0smETkuC2pagqhu9g/KJCRERESU3JicERH1kygIWDIhD+uumI1L5xTDYhKx+6gHq57egbWvf4z2wOmNR7NKJmQ6zDjU7MeR9mCcWk1ERETDhaDz9mzSSYZVzo91BLHnqAcau1edFh2AruuwSSY4LBJsZhGCICS6WRQnjZ4Q1m+uxlsfNwMAHBYTLq0oxkXTR8NsOvV7X55gBLKqYkqhG3lptng1l4iIKCUlw7VzvDA5S0LJsINFVA2eIKf2joeArKLZF4YnGEFI0WASBNjNJjgsJkincQFPyWPP0Q48/lYVDnR2bxzltuGqs8sxtyzrlJPxFl8YkknA1EI3MhyWeDaXiIgopSTDtXO8MDlLQqm0g9FxQVmFNxRBeyCCZl8YAVmFoumwSSKrailA03W8/lEj/vRuNdoCxo2NGcUZuPrscpRmO0/pPRu9ITitEs4sdMNpleLZXCIiopSRStfOTM6SUCrtYNQzRdXgCyvwhpRoVS0YMapqDgurasNZQFbw7NbDeH7HESiaDlEAPjd1FL4xtwRuu3lA76XrOo51hJCbZsXk0emwmU2D1GoiIqLhK5WunZmcJaFU2sHo5HRdRzCiwhtS0B6Q0eKTY6pqTqsEq8Sq2nBT3xHCE+9UYfOhFgCA02rCN+aWYOnUUQNKvFVNR70niMIMByaOSjutsWxERESpKJWunZmcJaFU2sFo4BRVgzekwBdW0OQLwRNUEFY0iIIAp8WYWMQkMlEbLnYdbsfv3zqE6pYAAKAo046rzi5HRWlWv98jompo9IYwJseFsXkuiPz3JyIiikqla2cmZ0kolXYwOj0nVtXa/DJa/DKCsgpV02HtrKqxq1vyUzUdr37YgL+8V4OOzol2Zpdm4qqzy1Gc6ejXe4QiKlr9YUwoSENptpOVVCIiok6pdO3M5CwJpdIORvEVUTX4Qgo8IWNSEW9IQVhRIQoiq2rDgD+s4KktdfjfXUehajpMooALzxyFy+aUwGU7+YQf/rBRUZ08Oh2jM+xD0GIiIqLkl0rXzkzOklAq7WA0eHRdR0DurKoFZLT6ZQTCKlRdg90swWExsaqWpI60BfHEO1V4v7oVAJBmk3D5vFJ8bkrBSZPrjmAEiqZhaqEbOS7rUDSXiIgoqaXStTOTsySUSjsYDZ1I51g1byiCJm8YvpCCsKrCJIhwWiTYLSZW1ZLMtto2PP52FepajfFopVkOXH3OGMwozujzdc2+MMySiDML3QOeAZKIiCjVpNK1M5OzJJRKOxglhq7r8MsqfCEFrYEwWv0RBMMqNGiwS0aixqpaclA1HS/vPoa/vlcLb1gBAMwrz8I3zyrvs+tigyeEdLuEqYVuOCxcA42IiEauVLp2ZnKWhFJpB6PkICvGumqeoIwmnwx/51g1k8iqWrLwhiLY8H4t/vXBMWg6IIkCvjB9NC6dU9xj8qXpxhT7+Wk2TBqdDqvEZJuIiEamVLp2ZnKWhFJpB6Pk01VV84YiaPPLaA1EEJQVaLoOuyTBYTXxQj+BalsD+MPbh7Ctth0AkGE344r5pTh3Un63BLprDbSSLAfG56dx4XIiIhqRUunamclZEkqlHYySn6xo8IYixlg1nwxfKAJZ0SCJIhxWCXYzq2pDTdd1bK1pwx/ersKR9iAAYEyOE9ecMwZTC90xsV1roJ2R68IZuVwDjYiIRp5UunZmcpaEUmkHo+FF13X4Oqdrb/XJaAvICEZUaBpgt5jgsLCqNpQiqoaXPjiGp96vhV9WAQBnnZGNK88qR0G6LRoXiqhoC8jRNdCIiIhGklS6dmZyloRSaQej4S2sGJOKeIIRNPnC8IcVyKoOSRDgsBrT9YtcDHnQdQQj+Ot7NXhlTz00HTCbBFw8oxBfnV0Mu8VIln0hBf6Igqmj3Shw207yjkRERKkjla6dmZwloegOdvRozzuYyQTYTrj48vt7fzNRBOz2U4sNBIDedg9BAByOU4sNBgFN670dTuepxYZCgKrGJ9bhMNoNAOEwoCjxibXbje0MALIMRCLxibXZjP1ioLGRiBHfG6sVkIzJKLSwDL8vAF9IQUsgDE8ggqCsQdcBm0WE3eWExWYxXqcoEORwr2+rmy2A2TzwWFWFEA713l7JDN1iGXispkEIBeMTa5KgWzvXH9N1CMFAfGJFEw75VDz+9iHsOtwBuxxCpsOMb8wtwaIJuRAEAe0BGTp0TC7KQnbOCd0feY4w8Bwx8NgBnCMGFKsoxrbojSX2HNHvWFU1/u16YzYb8QON1TRjX4tHrCQZ2wIwjolAH8f9QGIHcm3A64ieY3mOGHhskpwjPE1NcI8enRLJGXRKOh0dHToAvcM4TXX/Wbo09gUOR89xgK4vWhQbm5PTe2xFRWxsaWnvsZMnx8ZOntx7bGlpbGxFRe+xOTmxsYsW9R7rcMTGLl3ae+wnd/VLLuk71uc7Hrt8ed+xjY3HY7/73b5jq6qOx950U9+xu3cfj73ttr5j33//eOy99/Yd+8Ybx2PXru079sUXj8c++WSfsbt+/Zj+7w+O6f/3Yb2+7zd/6DO29leP6Lvq2vVdde161fqn+4w9fOd90diDz/xvn7FHf3pHNPbj/329z9j6G34cjd33f5v7jG381spo7EebdvYZ27zs6mjsnh0H+oxtveSyaOwH+470Gdt+4Rf1XXXt+s7aNv3RjQf7ft9F5+odQfn4vx3PEQaeIwwJOkfozzxzPPaZZ/qOffLJ47Evvth37Nq1x2PfeKPv2HvvPR77/vt9x9522/HY3bv7jr3ppuOxVVV9x373u8djGxv7jl2+/Hisz9d37CWX6DH6iuV1hPHDc8Txn2F+jugAdAB6R0eHPtxxai8iioszcl2YVuRGXroVqq4nujkpSxAELBiT3WeMouvYV+9FUO7jri4RERElHXZrTELs1sjuCAOOTbLuCKFgGD6PH55ABM3+MAKyAkUxPtZpkWB12iFaTqEL5Ajv1qifcNwLAeNYbvfL+NvWOrzxUSN0ABZJxEUzizBn0miUZTsxaVQ6LOE+2stzxKnF8hxhYLfGgceyW6OB54hTi+U5wpDC3RqZnCWhVBrUSKRpOnyyAm9IQbM3DE8ogqCsQgfgMJvgtEowc32u03ag0YfH3z6EPUc9AIBspwVfnFGIb8wrwmi3A5JJhDcUQZrNDEXTelzYmnoXlBWYRG7D08XtGB/cjqeP2zA+kmU7ptK1M5OzfnjkkUdw3333ob6+HtOnT8fDDz+MuXPn9hr/7LPP4mc/+xmqq6sxbtw43HPPPVi6dGm/Py+VdjCiTwpFVHhDCjqCMpp9MvyygoiiwWIywWk1wWbmDJCnStd1vHOwBU++U4VGbxhn5Lrw928vwJObqrB+UzU8QQXpdgkrFpbju4vPgNXMZRH6IxxR8ds3D+LJTVXchqeB2zE+uB1PH7dhfCTTdkyla2cmZyfx9NNPY9myZVi3bh3mzZuHBx98EM8++yz27duHvLy8bvGbNm3Cpz71KaxZswaf//znsWHDBtxzzz3Ytm0bpk6d2q/PTKUdjKgvqnZ8XbVmbxgdwQhCEaObiMNiTNXPqtrAhRUVz+84isUTcrGzrh0Pv36gW8z3PzMWX5pZhC3VrQlo4fAxpywLz20/jN+8xm14Orgd44Pb8fRxG8ZHX9vx+s+Mw7cWjRnSCloqXTszOTuJefPmYc6cOVi7di0AQNM0FBcXY+XKlbj55pu7xV966aXw+/148cUXo4/Nnz8fM2bMwLp163r8jHA4jPAJ/Wo9Hg+Ki4tTYgcjGogeq2qqBrMowsRq2oCYTQIqyrIw5+7/gyfYffxCul3Cu6s/g7PveQOt/j7GAIxgWU4L3v7xEsxf8xq34WngdowPbsfTx20YH/3Zjlt/eh4s0tDdXE2l5Iyda/sgyzIqKyuxevXq6GOiKOLcc8/F5s2be3zN5s2bceONN8Y8dv755+P555/v9XPWrFmD22+/PS5tJhrObGajW2NumhXlOUZVzRuKoD0gQ+NtpAGxSSI8oUiPfzgBwBNU0B6IYPH4XNS29jHJwAhWkuVAm5/b8HRxO8YHt+Pp4zaMj/5sR28ogmyXdYhblhqYnPWhubkZqqoiPz8/5vH8/Hzs3bu3x9fU19f3GF9fX9/r56xevTomoeuqnBGNZCZRgNtuhttuRlGm4+QvoG5kRUO6Xer1zmaOy4oHLp0x9A0bRrgN44PbMT64HU8ft2F8nGw7ptnMCWhVauBgjiRgtVqRnp4e80NEdLpUTcOKheU9PrdiYTmUvqaXJgDchvHC7Rgf3I6nj9swPrgdBw8rZ33IycmByWRCQ0NDzOMNDQ0oKCjo8TUFBQUDiiciGix2i4TvLj4DAJJiNq3hiNswPrgd44Pb8fRxG8YHt+Pg4YQgJzFv3jzMnTsXDz/8MABjQpCSkhJcd911vU4IEggE8L//+7/RxxYuXIhp06b1OiHIJ6XSoEYiSryArEBKgnVohjNuw/jgdowPbsfTx20YH8myHVPp2pl74UnceOONWL58OSoqKjB37lw8+OCD8Pv9WLFiBQBg2bJlKCwsxJo1awAA119/PRYtWoRf/epXuPDCC/HUU09h69ateOyxx/r9mV35ssfjif8XIqIRSQFgBhAKGDPDekIJbc6wxG0YH9yO8cHtePq4DeMjGbZj1zVzKtScmJydxKWXXoqmpibceuutqK+vx4wZM/Dyyy9HJ/2ora2FKB4furdw4UJs2LABt9xyC37yk59g3LhxeP755/u9xhkAeL1eAOCkIERERERE/eT1euF2uxPdjNPCbo1JSNM0HD16FGlpaRCGeG2nrpki6+rqhn1ZmBKH+xGdLu5DFA/cj+h0cR8aHnRdh9frxejRo2OKJsMRK2dJSBRFFBUVJbQNnDWS4oH7EZ0u7kMUD9yP6HRxH0p+w71i1mV4p5ZEREREREQpgskZERERERFREmByRjGsVituu+02WK3WRDeFhjHuR3S6uA9RPHA/otPFfYiGGicEISIiIiIiSgKsnBERERERESUBJmdERERERERJgMkZERERERFREmByRkRERERElASYnBERERERESUBJmdERERERERJgMkZERERERFREmByRkRERERElASYnBERERERESUBJmdERERERERJgMkZERERERFREmByRkRERERElASYnBERERERESUBJmdERERERERJgMkZERGlrCuuuAI2mw379+/v9twvf/lLCIKAF198EQBQVlYGQRC6/Xz729/u9tr29nZce+21yM3NhdPpxJIlS7Bt27Ye2/DCCy9g1qxZsNlsKCkpwW233QZFUeL7RYmIKCUIuq7riW4EERHRYGhsbMTEiRMxY8YMvP7669HHq6qqMGXKFCxduhR///vfARjJWWZmJn7wgx/EvMf48eMxd+7c6O+apuGcc87Bzp078cMf/hA5OTn47W9/i7q6OlRWVmLcuHHR2H//+9+48MILsXjxYlx22WX44IMP8Mgjj+Daa6/F7373u0H+9kRENNwwOSMiopT2+9//Htdeey3Wr1+P5cuXAwAuuOACbNq0CR9++CEKCwsBGMnZ1KlTo5W03jzzzDO49NJL8eyzz+KSSy4BADQ1NWH8+PG44IILsGHDhmjslClTYDabsXXrVkiSBAC45ZZbcPfdd+PDDz/ExIkTB+MrExHRMMVujURElNKuvvpqnHXWWbjpppvQ0tKCp556Ci+//DJ+8YtfRBOzE8myDL/f3+v7/f3vf0d+fj6+/OUvRx/Lzc3F1772Nfzzn/9EOBwGAHz44Yf48MMPce2110YTMwD47ne/C13XoxU7IiKiLkzOiIgopQmCgEcffRQdHR34zne+gxtuuAEVFRX43ve+1y329ddfh8PhgMvlQllZGR566KFuMdu3b8esWbMgirF/QufOnYtAIBAd37Z9+3YAQEVFRUzc6NGjUVRUFH2eiIioi3TyECIiouFtypQpuOmmm7BmzRqYTCa89NJL3ZKradOm4eyzz8aECRPQ0tKC9evXY9WqVTh69CjuueeeaNyxY8fwqU99qttnjBo1CgBw9OhRnHnmmTh27FjM45+MPXr0aDy/IhERpQAmZ0RENCLk5OQAMCpXU6dO7fb8Cy+8EPP7ihUrcMEFF+CBBx7AypUrUVRUBAAIBoOwWq3dXm+z2aLPn/jf3mI9Hs9pfBsiIkpF7NZIREQpr66uDrfddhumTp2Kuro63HvvvSd9jSAIuOGGG6AoCt58883o43a7PTqu7EShUCj6/In/7S2263kiIqIuTM6IiCjlXXfddQCMqe2/+tWv4q677sKhQ4dO+rri4mIAQGtra/SxUaNGRbssnqjrsdGjR0fjTnz8k7FdcURERF2YnBERUUp77rnn8MILL+DOO+9EUVERHnzwQVgslh4nBPmkrgQuNzc3+tiMGTOwbds2aJoWE/vee+/B4XBg/Pjx0TgA2Lp1a0zc0aNHcfjw4ejzREREXZicERFRyvJ6vfj+97+PmTNnYuXKlQCMytadd96Jl19+Gc8++ywAozKmqmrMayORCH75y1/CYrFgyZIl0ccvueQSNDQ04P/9v/8Xfay5uRnPPvssLrroougYsylTpmDixIl47LHHYt77d7/7HQRBiK6RRkRE1IWLUBMRUcq6/vrrsXbtWrz77ruYM2dO9HFVVTF37lzU19dj7969+Mc//oFf/OIXuOSSS1BeXo7W1lZs2LABu3fvxt13343Vq1fHvPbss8/G7t278cMf/hA5OTn47W9/i9raWmzZsgUTJkyIxr744ov4whe+gCVLluDrX/86du/ejbVr1+Kqq67CY489NqTbgoiIkh+TMyIiSkmVlZWYN28evvOd7+Dhhx/u9vyWLVswf/58XHfddVi2bBluv/12bNu2DU1NTbBYLJgxYwa+//3v46tf/Wq317a1teGHP/whnn/+eQSDQcyZMwf3339/tzXNAOD555/H7bffjo8++gi5ubm48sorceutt8JsNg/K9yYiouGLyRkREREREVES4JgzIiIiIiKiJMDkjIiIiIiIKAkwOSMiIiIiIkoCTM6IiIiIiIiSAJMzIiIiIiKiJMDkjIiIiIiIKAlIiW4AdadpGo4ePYq0tDQIgpDo5hARERERJS1d1+H1ejF69GiI4vCuPTE5S0JHjx5FcXFxoptBRERERDRs1NXVoaioKNHNOC1MzpJQWloaAGMHS09PT3BriIiIiIiSl8fjQXFxcfQaejhjcnYS//3vf3HfffehsrISx44dw3PPPYeLL764z9e8+eabuPHGG7Fnzx4UFxfjlltuwZVXXtnvz+zqypiens7kjIiIiIioH1JhONDw7pQ5BPx+P6ZPn45HHnmkX/FVVVW48MILsWTJEuzYsQOrVq3C1VdfjVdeeWWQW0pERERERMMZK2cnccEFF+CCCy7od/y6detQXl6OX/3qVwCASZMm4e2338avf/1rnH/++YPVTCIiIiIiGuaYnMXZ5s2bce6558Y8dv7552PVqlW9viYcDiMcDkd/93g8g9W8fgvIClr9cqKbQURxJIkiXDYJTospJbp+0PCjqBp8YQWhiIYMhxk2synRTSKi03DiMZ2XZoUo8m/L6WJyFmf19fXIz8+PeSw/Px8ejwfBYBB2u73ba9asWYPbb799qJrYL+2BCD440gERPMiIUoUg6LCYTHDZJOS4LEi3W5Bmk2A2sYc7DZ6grMIbiqA9EEGLT4ZfVqBoGjLsFpRkO5CXZoXEfZBShK7rUBQFqqomuimDJiSr8MsKPEEF7QEZwYgKiyTCKqTDbhmc1MJkMkGSpBFxY5HJWRJYvXo1brzxxujvXTPOJJpJEDDK3T2ZJKLhKxRR4Q+raPF7IUKEw2pCptOMLIcVaTYJDlbV6DR13Un3hhQ0+8LwBCMIKRpMggCb2YRspwUmUUB7IIJdh9uRn25DSZYDWU4L9z0a1mRZxrFjxxAIBBLdlLjSdSPp1KBD0wBN16F3PmcDYBcAXQaOHm6HOIjHsMPhwKhRo2CxWAbtM5IBk7M4KygoQENDQ8xjDQ0NSE9P77FqBgBWqxVWq3UomkdEI5zNbOrsSmaBqukIyAqOtoVQ1xqAVTLBZZWQm2ZFus0MF6tq1E9d1bGOYATN3uPVMZtkgt1iQqaje+KV6bQgTZXQ6pPR4pMxOtOG4kwH0mzmBH0LolOnaRqqqqpgMpkwevRoWCzD+2aDpulQdR2apkPRdOi6Dh260aNKFGJmFNQB6JoOm0WCaRC6Neq6DlmW0dTUhKqqKowbN27YLzTdFyZncbZgwQL861//inns1VdfxYIFCxLUIiKinplEAWk2c/RiuKuq1uzzwCQYVbVspwUZDgurahRD1XT4Qgo8oQha/TLagzKCsgqTKMBulpDltPQrsZdMIvLSbQhFVNS1BtDkDaMk04HRmXZYJY5Ho+FDlmVomobi4mI4HI5EN2fAdF2HqunQdCMZU2H8vyAKsAiAKAjo7fSv60YyZ7MOTnIGAHa7HWazGTU1NZBlGTabbVA+JxkwOTsJn8+HAwcORH+vqqrCjh07kJWVhZKSEqxevRpHjhzBn/70JwDAt7/9baxduxY/+tGP8M1vfhOvv/46nnnmGbz00kuJ+gpERP3SU1Wtri2ImlY/rJIJaTYJuS4b0mwSq2ojUCiiwhOKoCMQQYtfhi+sQFE1WCUTHBYTMu2nXimwmU0Y7XbAF1Kwr8GHBm8YpdkO5KXZBu1ij2gwDKeKTld1TO2sjmmaUR0TIEAUBZiT7NgbTtv2dDA5O4mtW7diyZIl0d+7xoYtX74c69evx7Fjx1BbWxt9vry8HC+99BJuuOEGPPTQQygqKsLjjz/OafSJaFg5saqm6zrCigZvUEGz1wOTKMBhMSHLaTG6ptkk2M2sqqWaruqYN2xM5NEelBGSVYhd1TFH/6pjA+GySXBYTcZ4tLrO8WjZTmQ6zNy/iE6Trsd2VeyqlAECRME47/M4SzwmZyexePFi6Lre6/Pr16/v8TXbt28fxFYREQ0doXMih65pz1VNhz9sVNWqWwKwm0Wk2U+oqlklzr43THVVxzzBCJp9ndUxTYPVdPrVsf4SBQFZTgsUVUKLX0ZLQMZotw3FWU64rLxsIRqI4VYdIyZnREQ0QCZRQLrdjHS7UVULRTR4AgoaPR5InVW1bNeJY9X4pyZZqZreObOiUR3rCEYQlBUIggCHZXCqY/0lmUTkpRnj0WpaAmjyyijJsmNUBsejEfXmeHUMUDStszpmPHcq1bGa6mpMnjAOm97fgunTZ/TrNevXr8eqVavQ3t4+8C9ATM6IiOjUCYIAu8WYkQ8wplEPyCrqWoOoajaqaul2M3JcVlbVkkQoosIbUtARlNHcue5YRNVgEU1wWk1w2+2DOh32QNnMJhRmOOANRbC33ot6Txhl2U7kplk5Ho0IvVXHAAHorI4luoU0EEzOiIgobiSTiHS7GFNV6whE0OAJQRJFOC1SZ1XNGM/WldTR4NE0HT65c90xbxieUARB2Vgg1242uioOh8ld0mxmOK0S2vxyzPpomc7UXvOI6JN03RgrpvZZHUtsG+nUJf/ZmIiIhqWuqlq2y4rCDAeynRaouo7a1gC217Xj/eoWbK9tQ11rAB2BCFSt9/G9NDChiIombxgHG314v7oVW6pbsftwB1p8MsyiiPx0G0a57chIYLfFUyEKArJdVuS4rGjyhrG9rg17j3ngDyuJbhpR7/z+3n9CoX7Fal4fIj6/seSJbCx7Emz3QPH4IPgDMIeMn1NJzP7zyis4d8kijM7LQfGofHzl4i/i0MGDPcb+d+NGOK1mvPyvf2Hu7JnISndhyafOwod7dneLfeWVVzBp0iS4XC587nOfw7Fjx6LPbdmyBeeddx5ycnLgdruxaNEibNu2bWANT1HD54xMRETDmmQS4babjcQg3QabZEJHIII9RzuwpboV7x9qxccNXjR6QtHKDvWPpunwhCI40h7EB0fasaW6Fdtq23CgyYeIoiHTbsHoDDty06xwWqWk6rZ4KswmI8F0WcyobglgW20balv8kBUt0U0j6s7l6v3nK1+Jjc3L6zFOTE+DsHQpwooGXdeNsb+TxiE9NxOunAw4soyfUxEI+LHy+lV4a9O7ePHlVyCKIr7+tUugab0fTz9dfTPW3HMf/rtpM3JycnHpJV9GJBI54T0DuP/++/HnP/8Z//3vf1FbW4ubbrop+rzX68Xy5cvx9ttv491338W4ceOwdOlSeL3eU/oOqYTdGomIaMh1TTjRNVlIpHOsWnWLH6qmw24xIcNuQZbTgnSbGS7b4C1uOlyFlc6xY4EImn1h+GUFsqLDbBLgtEgoSDcP+yTsZOwWEwotdniCEXx4zIN6Twil2U7kuqwQub/QMKPpOgQYY8V6IgiA2RT//friL3055vffPfZ7lBaOwkcffQiX09Xja1bfcgs+c+65AIBHH38CE84ow/PPPYevf/1SAEAkEsG6detwxhlnAACuu+463HHHHdHXf/rTn455v8ceewwZGRnYuHEjPv/5z8ftuw1HTM6IiCjhzCYRbrtRWdN1HcGIila/jGMdQUgmES6rhGynBW6HGek2c3Ra/5FE03T4O8eOtfjD6AhEEJBV6DDGjrltFlikkdkhJt1ujEdrD8jY2bk+Wmm2AxkOjkejJODz9fiwruvQRBGqokHVNGMyj5ojAIyxY6LwiS6Kn1iEObj/QFyad+Djj3HnHbdj6/vvo6WlOVoxq6utw6RJk3p8zbx586P/n5WVhXHjxuOjvR9FH3M4HNHEDABGjRqFxsbG6O8NDQ245ZZb8Oabb6KxsRGqqiIQCMSsHTxSMTkjIqKk0ldVTWvSYbdIcNvNyHZZkGYzw2VN3apaV3XMG4ygyReGL6wgouqdSxZIyB8B1bH+MonGeLSIqqHJG0arP4zCDAeKsuxczoESy+mM/q/WuQi0esJC0HpENWZWFASY01y9l876eN/T8dUvfwnFJSVY+7t1GDVqFDRdw5yZMxCR5VN+T7PZHPO7IAgx6wYvX74cLS0teOihh1BaWgqr1YoFCxZAPo3PTBU8WxERUVLrtarmCUISjapajstirL02zKtqJ1bH2vwy2gKyUR3TjS586TYz1/g6ia7xaAFZwaEmHxq9IZRmO1Dgtg+ryU8oNZw4s2JXdUzXAR3JMbNiS0sL9u/fh7W/W4ezzj4bALDpnbdP+rr3338PxSUlAIC2tjYcOPAxJk3sucrWk3feeQe//e1vsXTpUgBAXV0dmpubT+EbpB4mZ0RENGz0VlU71OSHrnevqqVZpaQfeyQrGryhCDzBCJr9MnyhCMKKBrMowmGVkJdmTtnK4GByWCTYzSZ4Qgr2HPWg3hNGaZYDORyPRoOsx+oYdAgQIAoCTCL6Xx0bZJmZmcjOzsYTf/g9CgoKUFdXh1tv+clJX7fmrruQlZWNvPw83H7rrcjOzsEXL7643587btw4/PnPf0ZFRQU8Hg9++MMfwm63n8Y3SR1MzoiIaNg6saqm6TpCERUtPmOsmlky1lXLcVngtluQZpOSoqqm6zr8sgpvKIJWn4y2YARBWYGmGWPH0mxm5LA6FheCIMBtN7q+tgVk7OxcH600ywm3w3zyNyDqB+OYVqBqOkKygghMndUxvTMZEyAkafdjURSx/s9/xQ9vvAFzZs3AuPHjcf8DD+Jz532mz9fd+Yu78MMf3IiDBz7GtOnT8fTf/x8slv6P8fzDH/6Aa6+9FrNmzUJxcTHuvvvumNkcRzJBP7EDKCUFj8cDt9uNjo4OpKenJ6QN9R1BHGryI8Nh4dpDp8gkCpBEIXrXjE4NtyOdqoiqwR9WEIx0Lrjc2S0wJ82KNJsEl2XoqmqyosEXVuAJymjyGdUxWdEgiaJR4bGYWB0bAhFVQ4s/DLMoojDTjqJMBxdCp1PyyWM6GAjCFWlDSWkpbDY7xL6mXRzG/rtxIy747Lk40tCEjIwMAICuG12yHYM8/jcUCqGqqgrl5eWw2WwxzyXDtXO8sHJG3QRlBVlOK0RBQIbDjPZABO0Bo5sNnZxVEpHhNCPDbkZHMAK3ndvwVHA70ukym0RkOCzIgNHNKCgbVbX6jhDMktE9MtdlhdthVFbiWVU7sTrWFpDR6u+sjuk67JIEl9UMm4tJwVAzm0QUpNsRkBUcbPKhwRtGWbYD+ek2jkejPnUd076QgtZA2Dimwyo0aLBLnTdYVKNKJnJXotPA5IxihCMq1m08hCc3VcETVJBul7BiYTm+tWgMDrcGeVF8ElZJRFGWHes2HsT6TdXchqeI25HiTRQEOK0SnFbjz56saAjICg40GVNcOywmZDjMyHKeelUtomrwhow76c0+Gb6QgrCiwiQa3StzXTZWx5JE7Hi0DtR3hFCS7UCuy5q03c9o6HUd095QBE3esHFMqypMQucxnWaNHtO6IoN9OygemJxRVFBWsG7jITz02sfRxzxBJfr75fNK0OAJJ6p5w0KG04x1Gw/iN68dX3uE23DguB1psFkkERYptqrW6AnjSFsIFknoXFfNqKql2aQeZ0jUdR0B2ZjqvjUQRps/gkDnnXSbZCSC2S7rkH836p8Tx6O1+mXsrOvAKLcNxVkOuO0cjzYS9XZMq7oGu7nzmDaP7GP6U4sWwR+OJLoZKY3JGUWZRBFPbqrq8bknN1XhW4vG4HMPvYVWP9eg6EmW04K3f7wE6zdV9/g8t2H/9Gc7fm/JGWj2yRyDRnHRU1XNLys40OiDIBhVNbfDjGynFS6bBFXV4em6kx7urI4JIhwWU8yddBoeTKKA3DQrZEXDkfYgmn1hFHWOR0uGCWRocEVUDb6QsXxFozcUPaZFQYSTxzQlAJMzijKmclZ6fM4TVNDql5HrsjKx6EWuy4oWn8xteJr6sx2bfDLe3NeI4kwHSrMd7IZEcdVVVct0AKpmrKvW6AnjaHsIZpMAVcXxO+kWo8JGw59FEjHabYc/bCTmDZ4wynKcyE+zQuJ4tJTRVR3zhY21BFv9xlqCqqbDZjbBaZGQ5bCc8t8VnZ0bB81ImcOQyRlFpdnMSLdLPV4Up9uNvtW3f3EKFHVkHBwDJZkE5KVbuQ1PU3+2Y6bDjMffrkKrX0aOy4LZJZmYXZaF6UXu6PpXRPFgEo0ujq4TqmomUeCd9BTmtEpwWEzoCEbwweEO1KdZUJLlRI7r1C/YKbGUzrFjvrBRHfOGFIQVzaiaW0zIccWhOiZK0AGEgkHYbFyvazAEAgEAgNmc2t2OeRVDUaqmYcXC8pgxZ11WLCxHRyACJy98+9QRjHAbxkFf2/HKhWWoavajPMcJX0hBs0/GKx824JUPGyCJAiaPTsfskkxUlGWhONPOiymKK4vECspIIAgCMhwWpNl0tPjDaPO3Y3SGDUVZDqTbUvvCMBXoulHx9oZiq2OKpsMmiXBaJWQ5xLj+fRBEETA70NzUBACw2e0QUnEu/R7oAHRNh6gPzlT6uq4jEAigsbERGRkZMJlSu7sx1zlLQolcqyEcUfHbNw9ytsZT1DXL4KOc8fK09Hc7hhUVHxzpQGVNGypr2nCsIxTzPrlpVlSUZqKiNBPTijI4foSITklYMZZhsJlFFGU6UJhp5/kkySiqse6YN6Sg2ReGJxhBMKLBJAhwWExwWEyD3j1V13Vo/jYgEhghaZlBh/HdLZIIcRBviGZkZKCgoKDHpDqV1jljcpaEEr2DBWQFkiiiPSgjg2tLDZhVEpHhMCPDYUZHUIHbLnEbnoJT2Y5H24PYWtOKypo2fHCkA5ETuo9KooCphW7MLs3E7NJMFGWwqkZEA+MLK+gIynDbzSjNdiKP49ESKiAr8IUUtAciaPaFY6pjDosEmzm+1bH+0jUN0HoeN52KZFVFIKzizCI37IPUO8hsNvdZMUv0tXM8MTlLQsmwg9V3BHGoyY8Mh4Uz4p0ikyhAEgUoms5teBpOdTuGIkZVbWtNG7ZWt6LRGzv1fn66FRWlWZhdmokzC928C05E/aLrOtqDEQQjKnJdVpRkO5Dt5Hi0odBTdSykGNUxu3loqmPUXVgxFueeOyYrYeO+k+HaOV6YnCWhZNjBjrYHsftIB0a5OaiVhj9d13G4PRjt/rj7SAeUExI9s0nAmYVuzC7NQkVpJkZncL8nor4pqoZWv7Hw8OgMY320NI5Hi7ugrMIbiqAjGEGzV4ZfVqBoGmySKaHVMTqOyVl8MTlLQsmwgzE5o1QWlFXsOtKOypo2bK1pQ9Mnqmqj3DbMLs1ERWkWpham97gAMRERYFTpW/xh2C0mlGQ6MCqD49FOh6rp8IUUeEIRtPpltAdlhCIaRAGwm42ZNM2sjiUVJmfxxeQsCSXDDsbkjEYKXddR1xbE1upWVNa24cOjnpiqmkUSMa1zrFpFaRYK3LYEtpaIkpUvpKAjFEGG3YzSHAfy0mxccqGfgrIKbziCjkAELX4ZvrACRdVglYyuinazidWxJMbkLL6YnCWhZNjBmJzRSBWQFew83IHKzmSt2Re7YHhhhj06qcjU0W5OrU5EUZquoyMQQTCiID/d6OqYxfFo3XRVx7zhCFp8ndUxWYUoCqyODUNMzuKLCy4REZ3AYZGwYEw2FozJhq7rqGkJoLLWmFTko3ovjrQHcaQ9iBd2HoVVEjGtyB2dWCQ/nVU1opFMFARkOi1IUyU0+2Q0+2UUZthQnOWMLmQ+UoUiKjyhCDzBCJp9ndUxTYPVZFTHMu1MYokAJmdERL0SBAFlOU6U5TjxlVlF8IcV7KhrR2VtGyqr29AakLGlug1bqtsAAMWZ9mj3x8mj03nnl2iEkkwi8tNtCEVU1LQE0OSVUZJlx6gM+4gZw6pqeufMikZ1rCMYQVBWIAgCHBYJWQ4Lz5FEPWByRkTUT06rhLPG5uCssTnQdR3VLX5srTYmFdlb70FdWxB1bUE8v+MobGYR04syolW13DRroptPREPMZjahMMMBbyiCvfU+1HvCKMt2IjfNmpLj0UIRFd6QsRZcs8+YWTGiarCIJjitJrjt9kFdpJgoFTA5IyI6BYIgoDzHhfIcF75aUQxfSMH2OmOq/sraNrQHInivqhXvVbUCAEqzHJ1VtUxMGpXOtXiIRpA0mxlOq4T2QAS7DrfHjEcbzjRNhzeswBdW0OwNwxOKICirAAC72eiqyOoY0cAwOSMiigOXTcI543JxzrhcaLqOQ01+VNa0orKmDfsavKhpDaCmNYD/t/0I7GYTZhRnRJO1bBerakSpThQEZDktiKgamrxhNPvDKHTbUZzlgHMYjUfrqo55ghE0+cLGumOKDrNJhMNiQnq6mdUxotMwfM4GRETDhCgIGJvnwtg8Fy6dUwJvKILtte3YWtOKbbXt6AhGsPlQCzYfagEAlGU7ot0fJxaksapGlMLMnePRgrKKqhY/mnxhlGQ5MMptT8rZXzVNh09W4A0paPWH0R6IINBZHXOwOkYUdyk/lb4sy6iqqsIZZ5wBSRoeuWgyTAfKqfSJBoem6zjQ6DO6P9a0YX+DFyeehJ0Wo6pWUZqFWaWZw77bExH1zROMwBuOIMtpQWm2E7kuK8QEj0cLK51jxwIRNHdWx2RFh9kkwGmRYLeYWB2jKE6lH1/DI1s5BYFAACtXrsQf//hHAMD+/fsxZswYrFy5EoWFhbj55psT3EIiGolEQcD4/DSMz0/DZXNL0BGMYHvt8bFq3pCCdw624J2DRlVtTK4Ts0syUVGWhQn5aSk5iQDRSJZuN8Nlk9Dml7GzzhiPVpLlQOYQ3pjRNB3+zupYiz+Mjs7qmA5j7JjbZknKqh5RKkrZ5Gz16tXYuXMn3nzzTXzuc5+LPn7uuefi5z//OZMzIkoKbrsZiyfkYfGEPKiaUVXb2jlW7eNGHw41+XGoyY9nKw/DaTVhVkkmZpdkYlZpJjId/b94M4kCJFGAoulQtZTuMEFJjvtid6IgINtljY5Ha/GHUZThQFGWfdAqEV3VMW/X2LGwAlnVIYnGVPf5HDtG/SSJApzWkbFExFBI2eTs+eefx9NPP4358+fHLGo4ZcoUHDx4MIEtIyLqmUkUMKEgDRMK0nD5vFK0B2Rsq21HZedYNV9YwVsfN+Otj5sBAGNzXZhdlomKkkyM66WqZpVEZDjNyLCb0RGMwG03oz0QQXsggrCiDfVXpBGM++LJdY1HC8gKDjX70egNoSTLgYI4jEc7sTrW5pfRFpCN6pgO2C0mpNnMI2YNNoqPrmPabTejIxCBJIoIyErCujamipTdek1NTcjLy+v2uN/v5wr0RDQsZDgs+PTEPHx6olFV29/gRWVNG7bWtOJgkx8Hmnw40OTD01vqkGaVMLMkExVlmZhVkgm33QyrJKIoy451Gw9i/aZqeIIK0u0SViwsx7cWjcHh1iAvimlIcF8cGIdFgt1sgiek4MNjHjR4wyjNciBngOPRZEWDNxSBJxhBs1+GL2QkwmZRhMMqIS/NzK7SdEr6Oqa/u/gMWM1M9E9VyiZnFRUVeOmll7By5UoAiCZkjz/+OBYsWJDIphERDZhJFDBpVDomjUrHFfNL0eaXUVlrLIC9o7YN3rCC/37chP9+3AQBwLh8F+7/6nSs23gQv3ntQPR9PEEFD732MQDg8nklaPCEE/SNaCTJcJq5Lw6QIAhw281wWSW0BWTsPHx8PFpGL12adV2HX1bhDUXQ6pPRFowgKCvQdcAmGdWxHFbHKA5Odkx/a9EYVtBOUcputbvvvhsXXHABPvzwQyiKgoceeggffvghNm3ahI0bNya6eUREpyXTacG5k/Jx7qR8qJqOvfWezqpaG6qa/Wj2yRib58IVf3ivx9c/uakK31tyBpp9Msf90KAyiQIy7Gas31Td4/PcF/tmEgXkdI5Ha/CE0OILoyjTgaJMB+wWE2RFgy+swBOU0eST4Q8pCCsqJFGEwyIh12VjdYziqn/H9NihbVQKSdnk7Oyzz8aOHTvwy1/+EmeeeSb+85//YNasWdi8eTPOPPPMRDePiChuTKKAKaPdmDLajWULytDiC6Om1Y+2QASeoNLjazxBBe2BCEwioLI3GQ2SUERFXasfGQ5zn/tiR1CBJApMzvpgNokoSLcjICs42ORDgzeMDLsZ7Z3VMU3XYZckOK0SF7anQROKqDjcFjjpMe0NRbgfnqKUTc4A4IwzzsDvf//7RDeDiGhIZbusyEu3IddlQbpd6vEPaLpdgssm4dJHN6M814WK0kzMLM6Ey5bSfxZokOm6jiPtQWztXMdv95EOpNvNePvHS/rcF9PtEpq87NbYHyeOR2voCLE6RoPuaHswOovwB0c6kGY7+TGdZjMnoKWpIWX/CtfW1vb5fElJyRC1hIho6KmajvZgBCsWlkfHAJzoygVl2HSgBVUtAVS1BPD63kaIAjChIB0VpZmYXZqJMTlOTqBEJxWKqPjgSEd0sppPjh2TRAF76724cmFZzPiULssXlGHjvib864NjuHROCVzWlL00iZuu8Wiw8wKY4i+sHD+mK2vacKwjFPO8JArYe6z3Y3rFwnIomgYLuDbeqRB0XU/JPgSiKPZ5UaGq6hC2ZmCSYZXzo+1B7D7SgVFue0I+n4hOX9dsWo9uPIQnN1V1myGvusmPbXXt0bFqda2BmNdnOSyYVZqBitIszCjOgJMXzdTp6AnVsQ+OtCOiHr+UkEQBUwvdmN2Z5Bdl2GEzm3rcF69cWIZvnlWOr/xuMw42+ZBuk3DF/FJ8dnIBK0FEQ+hYRzD6t+CDwx2QT+jvLokCpoxOx+zSTFSUZqEos/djOlGzNSbDtXO8pGxytnPnzpjfI5EItm/fjgceeAB33XUXvvzlLyeoZSeXDDsYkzOi1GCVRGQ4zMhwmNERVOC2S72uLdXoCaGy1rjg3lHXHvO8KACTRh3/41yW7WBVbQQJKyp2H/GgsqYVW3u4k56bZo1WXKcVZsBu6X5h1te+uOlgCx5/+xAOtwUBAGXZDlxzzhhMK8oYiq9HNOLIiobdR49Xx460B2Oez3FZO8/3mZhW5O5x5sWuY9rtMMMTjMBtt0DRtITM0pgM187xkrLJWW9eeukl3HfffXjzzTcT3ZReJcMOxuSMKLWYRAGSKEDR9H5NuhBRNew56sHW6lZU1rZFL5q7ZDst0T/c04szOGVyCqrvCEWTsV1HOiArsXfSJ49Ox+wSIyEryep/st7bvqioGv61ux4b3q+BP2z0blkwJhvfPKscBW5bfL8c0QjU4Al1VrxbsetwR8wNOJMoYPKo493aB3JMq5qGiKphSmHPSdxQSIZr53gZccnZgQMHMH36dPj9/kQ3pVfJsIMxOSOiE9V7QkaXl+rWbhfqJlHAlM6q2kD/qFPyiKgadh/piHZX/OSd9GynxbhwK8vC9F7upMeDJxjBhvdr8e/dx6DpRiL4xRmF+FpFEW8CEA1ARNXw4VFPdDKPuk/cZMvqOqZLMzHjNG6yhRUVvpCCuWOymJzFQcomZx6PJ+Z3Xddx7Ngx/PznP8fevXuxY8eOxDSsH5JhB2NyRkS9kRXjIr6y1kjWjn6ii1uO63gXt+lFPXdxo+TQ1ZV1a3Ubdh7u3pV18qh0zC7NQkVpJkqHuCtrTYsfj79dhR117QCADIcZy+aX4jOT8iEy+SfqUaM3FO2quPNwO0KRwe+ezuQsvlI2OetpQhBd11FcXIynnnoKCxYsSFDLTi4ZdjAmZ0TUX0fbjYHklbW9DySvKM0yJofItLOqlkARVcOHxzzYWm38e/U0CczsE+6kJ3oSGF3XsaW6FY+/XRUd53ZGrhPXnDMGU0a7E9o2omQQUTV8dMwTncyj9hPHdKbDHE3GphdnDMpsqEzO4itlk7ONGzfG/C6KInJzczF27FhI0sB2nEceeQT33Xcf6uvrMX36dDz88MOYO3duj7Hr16/HihUrYh6zWq0IhUI9xvckGXYwJmdEdCpCEdWoqnVeKNR7Ys99eWnW6IXCtCI3bEM8o9dI1OQNdybPrdhZ14Fg5PhsxaIATDxh+YTyJF0+IaJqeHHXUTy1pQ4B2Wj/2WNzsGJhGfLSOR6NRpYWXzja/XhHXXu3Y3rCJ47pwa40MzmLr5TtvL1o0aK4vM/TTz+NG2+8EevWrcO8efPw4IMP4vzzz8e+ffuQl5fX42vS09Oxb9++6O/J+IeOiGgw2MwmVJRloaIsC9fqOo62h1BZ24qt1cbipY3eMP69ux7/3l0Ps0nA1NHuaLI2OsPG82UcKF130ju7K9Z84k56hsMcnchjuCw8bjaJ+NLMIiyZkIe/vFeL/+ypx9sHmvF+VSu+NLMQl8wuYqJPKUtRNeyt90Yn86hu+cQxbTdjVkkmKsqMijcXgB7eUqpy9sILL/Q79gtf+EK/4ubNm4c5c+Zg7dq1AABN01BcXIyVK1fi5ptv7ha/fv16rFq1Cu3t7f1uyyclQ/bPyhkRxVsoomLX4Y7o4PRGb+xixQXpts4JJzJxZqEbVokX2/3V4gvHjB3rqi4BnXfS89M6uytmYUzu4N9JH2yHmnz4/VuHsPuoMb48y2nB8gVlWDwhd9h/NyIAaPXLqOw8V26viz2mBQDj89NQUZaJ2SWZOCPPldD9npWz+Er+22UDcPHFF/crThCEfi1CLcsyKisrsXr16uhjoiji3HPPxebNm3t9nc/nQ2lpKTRNw6xZs3D33XdjypQpvcaHw2GEw8cvUj45mQkRUSqwmU2YW56FueVZ0HUdh9u6Fj1txZ6jHtR7Qnjxg2N48YNjsJhEnFnkjlZ4RmfwRtGJVE3H3vrjY8eqmmNnIHbbzZhVYiwgPrMk9e6kj8l14e4vnYlNB1vwxDtVaPSG8ev/249/fXAMV59TjokFw/vijEaermO6azKPQ584ptNtEmaVGsnYzJJMuO2pdUzTcSmVnGmadvKgAWhuboaqqsjPz495PD8/H3v37u3xNRMmTMATTzyBadOmoaOjA/fffz8WLlyIPXv2oKioqMfXrFmzBrfffntc205ElMwEQUBxlgPFWQ5cPLMQAVnBrsPHx6o1+8LRixS8BYx221BRloXZJZmYWuiGRRIT/RWGXJtfNqpjNW3YUdsGfw930rsm8xib4DvpQ0EQBJw1NgdzyrLwzx1H8ExlHfY1ePHDv+/C4gm5uHJBGbJd1kQ3k6hXbQEZ2zrPedvr2qLr+wHGMT0u34XZJZmoKMvCGbkumMTUPqbJkFLdGuPt6NGjKCwsxKZNm2Jmd/zRj36EjRs34r333jvpe0QiEUyaNAmXXXYZ7rzzzh5jeqqcFRcXs1sjEY1Iuq6jtjUQTc72HPPELFZskURMK3QbyVppJgpSdEIIVdOxv+H4OJODTbF30tNs0vGxY7yTjla/jD9trsZrexsBAFZJxFdmFeFLMws5Ho2Sgqrp+LjBi621baisbsOBJl/M82lWCTM7x47NGkbHNLs1xldKVc4+ye/3Y+PGjaitrYUsyzHPff/73z/p63NycmAymdDQ0BDzeENDAwoKCvrVBrPZjJkzZ+LAgQO9xlitVlitvLtHRAQYFZHSbCdKs5348qwiBGQFO+vao7OTtfhlbO282wwARZn26N3lKaPTYTYN36pae0DGtlrje26rbYcvrMQ8PzbPhYrOCVTG5vFO+omynBasOnc8LjxzFH7/dhU+OubBhvdr8epHDVixsAxnj83hhDM05DqCEWzrHA+6vbYN3k8e07kuzC7LREVJJsblp/GYptStnG3fvh1Lly5FIBCA3+9HVlYWmpub4XA4kJeXh0OHDvXrfebNm4e5c+fi4YcfBmB0nSwpKcF1113X44Qgn6SqKqZMmYKlS5figQce6NdnJkP2z8oZESUjXddR3RKIjlX76JgHJxTVYDOLmF6UYXTvK8lM+mnWVU3Hx43eaHfOA42xd9JdVgmzSjKi1bFMhyVBLR1edF3HWx8348lN1Wj2GT1TJo9KxzXnjMHYPFeCW0epTNN1HGj0YWt1Kypr2/Bxgw8nXmg7rSbMKjHOT7NKU+OYZuUsvlI2OVu8eDHGjx+PdevWwe12Y+fOnTCbzbjiiitw/fXX48tf/nK/3ufpp5/G8uXL8eijj2Lu3Ll48MEH8cwzz2Dv3r3Iz8/HsmXLUFhYiDVr1gAA7rjjDsyfPx9jx45Fe3s77rvvPjz//POorKzE5MmT+/WZybCDMTkjouHAFzaqal3JWlsgEvN8SZajc6r+TEwalRxVtY5gBNs7q2OVtW3whmLvpJ+R68Ts0ixUlGZiPO+kn5ZQRMVz24/g79sOQ1Y0CAA+MykPy+aXIdM5/C+KKTl4OqtjlbVt2FbTBs8njukxuc5odX9CCh7TTM7iK2W7Ne7YsQOPPvooRFGEyWRCOBzGmDFjcO+992L58uX9Ts4uvfRSNDU14dZbb0V9fT1mzJiBl19+OTpJSG1tLUTx+B/7trY2XHPNNaivr0dmZiZmz56NTZs29TsxIyKi/nNZJZw1Ngdnjc2Brus41OyPjlXbW+9BbWsAta0BPLf9COxmE2YUZ0QnzcgZoskiuu6kd7Vrf4M39k66xYQZJUYCObskk0lDHNnMJlw2twTnTc7HHzdV4839Tfi/jxrxzoEWfLWiCF+cXjgiJ5eh06PpOg42+qLLV3zc6I2p4DssJswsNmZLnVWaiSwe0zQAKVs5y83NxaZNmzBu3DiMHz8eDz/8MM4//3zs3bsXs2fPht/vP/mbJEgyZP+snBHRcOcLKdheZ3QX3FbThvZgbFWtLNuB2aXGpCKTCtIgnaSqZhIFSKIARdNjJijpiTcUwfbadmytacW22nZ0fOKzy3OcRjJWmomJBekpdyc9We2t9+D3bx3C/gaj+2h+uhXfPKscC8ZkczzaCDSQYzp6Pqluw7ba3s8nFaWZmNiP80kqYeUsvlK2cjZz5kxs2bIF48aNw6JFi3DrrbeiubkZf/7znzF16tREN4+IiAaZyybhnHG5OGdcLjRdx6Emf3QB7H31XlS3BFDdEsA/th2Gw2JU1SpKjVnSTpyC3SqJyHCakWE3oyMYgdtuRnsggvZABGHFWMKl6/27Fo3d1xB7J91uNmFmyfGxcJziPTEmFqTjvkum4819Tfjj5mo0eMJY8++9OLPQjWvOKUd5DsejjQT9Oaa7KvFdExHtq/d0O6YTUYmn1JeylbOtW7fC6/ViyZIlaGxsxLJly6KVtCeeeALTp09PdBN7lQzZPytnRJTKPMEIttd1VrZ6GiOS48Ts0kwsmZCLxRPzsG7jQazfVA1PUEG6XcKKheX41qfG4J87juD/PmpEZW0b2gM93UnPxOzSrH5V5mhoBWUV/9h2GM9tPwJZ1SAKwHmTC3DFvBJkpMAkDdQzqySiKMve8zG9aAxe2HEU//dRA7bVtKM1EDvTd0mWI1rxTpYxrMmAlbP4StnkbDhLhh2MyRkRjRQnjgnbWtMaM7va75fNxq7DHXj49e7Loaz89FicWejGtX+uBGDcSZ9e7DbGmZRkIjeNd9KHg0ZPCE9uqsbbB5oBGOOFvj6nGJ+fNpoX3yko323FX96twW9eO/kxHTP7a2km8tKSe/bXRGFyFl8pm5z94he/wOWXX47y8vJEN2XAkmEHO9oexK7DHch0DI8FECm1iYIAqyRyTAgNia51ifY3eHHvJdMwf81r8ASVbnHpdgnvrv4M7v7XR5hYkI7JvJM+rO052oHH3jqEQ52LfY9223DV2eWYU5bFc0+KMIkCzshzYs5d/9fnMX3XSx9hUkE6Jg/zdROHCpOz+ErZ5Gz69OnYvXs35s2bhyuuuAJf+9rXkJOTk+hm9Usy7GCNnhD2N/qgnWSALNFQ0HUdoYgKQRDgsEhwWEz8g0mDziqJyHSaMeeu13qN2fLTc9Hml6PjVGh4UzUdr+1twJ8310QnfJhRnIGrzy5HabYzwa2jU6HrOmpbjbURm3xh/PhzE3HOvW/0Gs9jeuCYnMVXyk4IsnPnTuzZswd//etfcf/992PVqlU477zzcPnll+Piiy+Gw+FIdBOTWm6aFW5WzShJaBrgDUfgCUbQ7JPRGpChaBqsJhMcFhPsZhPvbFPcKZoOt92MdLvU6112t11CkzecgNbRYDCJAj47uQBnj83BM1vr8M8dR7Gjrh3ff2o7Lpg6Ct+YW4J0O/82JrugrGLn4fboZB5dC5FnOS3Idll4TFNSS9nK2Se988472LBhA5599lmEQiF4PJ5EN6lXqZT9E8WbqunwhRR4wxG0+GS0B2WEZBWiKMBuZlWN4ivfbcVf363FQ6993O256z8zDpfPK0GDhxdyqepYRxBPvFOFdw+1AjDW1fvG3BJcMLWAE7wkEV3XcbgtGJ2Ndc9RD5QTev5YTCLOLHKjojQT/zO/FM9WHuYxHUesnMVXylbOPsnpdMJut8NiscDr9Sa6OUR0ikyiALfDDLfDjKJMB4KyCm84go5ABM3ezqqaqsEmmWBnVY1OU7s/gm8tGgMAeHJTVbeZ3Q63BhPcQhpMo9x2/HTpZOw83I7H3zqE6pYAHnvrEP69+xiuOnsMZpdmJrqJI1YoomLXCdWxxk9Uu0a5bdGJPM4sdMMqmQAAAVnlMU1JLaUrZ1VVVdiwYQM2bNiAffv2YdGiRfjGN76BSy65BG63O9HN61UqZf9EQ6mrquYJGVW1jpCMUMSYIttuluC0mHi3mwbMKonIcJiR4TCjI6jAbZe6rYlEqU/VdPznw3r85d2a6NILFaWZuOrschRlcqjEYNN1HUfag52zqrZh95GOmOqY2STgzEI3ZpdmoqI0C6Mzep9tmsd0fLFyFl8pm5zNnz8fW7ZswbRp03D55ZfjsssuQ2FhYaKb1S+ptIMRJVJQVuENGX9wW3wy/LICRTOqag6LBJuZM0BS/5lEAZIoQNF0qJwsacTyhRU89X4tXvzgGFRNh0kU8PkzR+Hrc0vgso6YDklDIhRRsftIR7Q6Vu8JxTyfl2ZFRVkWKjqrYzazaUDvz2M6PpicxVfKJmc//elPcfnll2Py5Mno+orD5SIslXYwomShqBp8YQXekIJmXxieYAQhRYNJEGA3GxOLsKpGRP11uC2AP7xdha01bQCAdJuEK+aX4rOTC2ASh8f1RjI62h6MJmO7j3RAVo9XsiRRwNTO6tjs0kwUZdiHzbVdKmNyFl8pm5wBwB/+8Af8+te/xscfG4M+x40bh1WrVuHqq69OcMv6lko7GFGyCsgKfCEFbQEZLT4ZAVmFoumwSSKrakTUb9tq2vD424dQ12aMVSrLduDqc8ZgelFGYhs2TMiK1lkda8XWmjYc64itjuWmWVHRmYxNK8yA3TKw6hgNPiZn8ZWy9fdbb70VDzzwAFauXIkFCxYAADZv3owbbrgBtbW1uOOOOxLcQiJKJGO9NAl56baYqlqTLwRvUEFrQINJFOAwm+C0SrwTTkQ9mlWaid8UzcS/d9djw/u1qG4J4Jbnd2P+mCx886xyjHL3PvZppKrvCKGyMxnbdaQD8gnjvEyigCmj0qPVsZIsB2+U0YiSspWz3Nxc/OY3v8Fll10W8/jf/vY3rFy5Es3NzQlq2cmlUvZPNNzouo5gRIU3pKDNL6PVH1tVc1olWCVW1YioO08wgr+9X4t/7T4GTTe64X1xxmh8raI4YRWFZBBRjepY12QeR9pjZ0TMdlqi1bHpxRkjelsNR6ycxVfK7v2RSAQVFRXdHp89ezYUpfvCg0REgDE2tauqlp9uQ0TV4Asp8IUVNHpD8IaMqpooCHBajIlFWFUjIgBIt5vxrUVn4HNTC/CHt6uwva4d/9h2BK/tbcT/zC/FZybmj5jzRaMnhMraNmytbsOuI+0IRY5Xx0QBmDwqHbNLjck8SrNZHSPqkrKVs5UrV8JsNuOBBx6Iefymm25CMBjEI488kqCWnVwqZf9EqUTXdQRkFb6wUVVr8csIyipUTYetc1KRgc4WRkSpSdd1bKluwx/ePoSjneOoxuQ6ce05YzBldPIu53OqIqqGD495sLW6DZW1bahrDcQ8n+WwRLsqzijOgJMzW6YMVs7iK6WTsz/96U8oLi7G/PnzAQDvvfceamtrsWzZMpjN5mjsJxO4REulHYwolXVV1TyhCJq8YfjCCsKKCpMgwsGqGhHBOE+8tOsY/ralFgFZBQCcNTYHKxaWIT/dluDWnZ4mbxiVNW2orG3FzroOBCNq9DlRACYWpEe7K5bnOFkdS1FMzuIrZZOzJUuW9CtOEAS8/vrrg9yagUmlHYxopOiqqhndHsNo80cQCKtQdQ12s8SqGtEI1x6Q8Zf3avHqh/XQdGPR5C/NLMIls4qGzQyEiqrho2OeaHfFmk9UxzIcZswuMZKxmcWZcNlYHRsJmJzFV8omZ8NZKu1gRCNVRNXgDSnwBGU0+2T4Qp1VNVGE0yLBbjGxqkY0AlU1+/D7t6rwwZEOAECW04LlC8qweEIuxCSsLLX4wtFkbOfh9mj1DzCqY+Pz0zqrY1kYk+tMyu9Ag4vJWXwxOUtCqbSDEZFRVfPLxh+v1kAYrf4IgrIKTddgl4xEjVU1opFD13VsPtSCJ96pQoMnDAAYn+/CNeeMwcSCxP7dVzUde+uPjx2ravbHPO+2mzGrJAOzS7MwszgD6XZzL+9EIwWTs/hicpaEUmkHI6LuZMVYV80TlNHkk+HvrKpJorEANqtqRCODrGj4584jeHbr4eh4rUXjc3HlwjLkuKxD1o42v2xUx2rasKO2Df4TqmMCjOpY12QeY/NcrI5RDCZn8cXkLAml0g5GRH3rqqp5QxG0+mS0BSMIygp0HbBJJjisJlglVtWIUlmrX8af363Gax81QgdgkURcMqsIX5pZOChVdVXTsb/Bi601baisacXBptjqWJpNwqySTFSUZmJmSSbcrI5RH5icxReTsySUSjsYEQ2MrGjwhiLwBCNo9svwhSKQVR2SIMBhlWA3s6pGlKoONPrw2FuH8NExDwAgx2XFioVlOGdcTreZDk2iAEkUoGg6VO3kl3LtARnbattQWdOGbbXt8IVj13wdm+eKzqw4Li+N5xnqNyZn8cXkLAml0g5GRKdO13X4wsYC2K0+GW0BGcGICk0D7BYTnBYJFklMdDOJKI50XcfbB5rx5KZqNHmN8WiTRqXjmrPLMS4/DVZJRIbTjAy7GR3BCNx2M9oDEbQHIggrxxd6VjUdHzd6UVljdFc80OiL+RyXVcLMkoxodSzTYRnS70mpg8lZfDE5S0KptIMRUfx0/QH0BCNo8oXhDytGVU0U4LAY0/VzLAhRaggrKp7bfgR/rzwcTbqumFeC1Usn4dH/HsT6TdXwBBWk2yWsWFiOby0ag4+OerHpYDO21rRhW20bvKHY6tiYXCcqSrMwuzQTE/JZHaP4YHIWX1yAgohomLBKJlhdJmS7rCjNdsIvK/CGFLT4w+gIRNDgiUAHYDezqkY03FklE74+pwTnTsrHHzdX4819TVg0IRfrNh7Ew68fiMZ5ggoeeu1jaLqOMwvd+NWr+6PPOS0mzCjJREVJJmaVZiLLyeoYUbJjckZENAyJooA0mxlpNjNGZ9gRVowFsDsCESNZC8mIKDokkxBdV41VNaLhJ8dlxQ/Om4AvzSzE2WNz8YNnd/YY98fN1Xh39WcwozgDY3NdqCgzqmOSiTdpiIYTJmdERCmgq6qW47KiXHPCJyvwdVbV2gMReDqrag6zCU6rBDMv2GiI6bqOYERFUFYRVjRYJRF2iwl2s6nbZBfU3aSCdPjCEXiCSo/Pe4IK/GEF935lWszYM6LBous6QhEN3nCEXWTjiMkZEVGKEUUB6TYz0juraqGICl/YqKo1+cJoDxpVNbNJhMNiYlWNBo2iavDLKkIRFaquw2YWkeGwIMNhTGLREZLRHozAJAiwmU1wWkys9PRC0XS47Wak26UeE7R0uwS33Ywmr5yA1tFIoagaArKKYNcxLYnIclqQ47LCxmVf4oLJGRFRirOZTbCZO6tqOUZVzRtS0OwNwxMyqmpA51g1VtXoNHTdSQ/ICsKqBpNgdKstyXIgw2F0w7Vbjl/ABTvX+GsPRNDik9Hil6HqOqwmY0F2m1lkVa2TquloD0awYmE5Hnrt427Pr1hYjvZApF/T6hP114nHdEjRIIl9H9N0+picERGNICdW1Qo7q2rekIKOoIxmn4y2oIyIqsEimuC0Gkkdq2rUl57upLsdZuS4rEizSXBZpV6rYfbOym1eug2KqsEX7rxx4AvDE4ygNWAkeA6LCQ5W1dDuj+Bbi8YAAJ7cVNVttsbDrcEEt5BSQdcxHZCNY9puNo7pM/pxTNPp41T6SSiVpgMlouFD1fTOi2OjitERjCAoKxCE41P1s6pGPd1Jd1hMyHZZkOmwwGWT4jKddqBz3GRbQEaLT0ZAVqFoRvI3kqtqVklEhsOMDIcZHUEFbrvU4zpnRP2l6zrCigZ/uPsxneGwIM0mJf3Y0FS6dmZyloRSaQcjouHrk1U1v6wgomqwmowqRrL/sab4UTUd/rCCQESF1lkdS7NLyHXZhuRO+olVtSZfCN6gcREpCkJ0kpuRNiGBSRQgiQIUTWdXRhowVdMRkBX4ZeOYtkoi0mwS8tJscFklpNmGV3Usla6d2a2RiIh61DVWLTfNivKc7lW19oAMURRgN7OqlmpOvJMeVjSYOu+kF2fakekc+jvpkqlrIhELijLtCHbeOGjzy2j1y2j2haFqxgWm0yrBKqV+VU1lUkYDFIoYXRVDERUmUYA9gcc09Y7JGRERnZRJFOC2m+G2m1GU6UAoosITinSuqyajNSBDUTVYJVbVhqvYO+nGv2WaXcKYruqYLTkmiznezVZCfroNEVWDL3RCVS2koDWgQhREOC0mOCwjr6pGBPRyTNsklOc4k+qYplhMzoiIaMC6qmp5aTaM0XT4Qgo8oQha/TLag8b06KIA2M0Sp0dPYn3dSXdZjYposifZZpOITKcFmU4LirPsCMjG0hFtfmP2xyZvGKquRSu8NjNnlqPU1XVMByMKTIIIh9WEokw7MjvHjg2HY3qkY3JGRESnxSQKcDvMcDvMKM5yRKdH7whG0Ow1LpAVTYNNMo3oiRySQdeddGMWNuNOussqoSzHgXSbedjfSRcEAU6rBKc1tqrmCUXQ5A3DF1bQGggbF62sqlEKUDUdQVmFX1aMY9pkgstmHNNpNjPShvkxPRIxOSMiorg6cXr08hwN/rDRBbLZZ6yr1hbUuOjwEIpWxxQFIow76aMzbchyWFP+TvqJVbWSLAcCstrZ7TGMNr+RsGnQYJNYVaPhIxRREZRVBDuPafsJx7TLZvRWSNVjeiRgckZERINGMolwO8RuVTUuOjx4Yu6ka53VMZuE0mw70u2WEXsn/cSqWoHbBlkxZoD0dM5G6gspaPWHYRJFOC0S7BYTq2qUFHo7pks6j2mXVYJFGnnHdKpickZEREOGiw4PjrCiIhDuvJMuCLBbJIzOtHWOMzHzTnoPLJKILMmCLKcFpdk6/J03DtoCMlr9ETT5QtB0HXZJgsNqglViVY2GTo/HdIatc2ZFHtOpjMkZERElRG/To7d3LjpsjFUz1tQaKdOj91fXnfSArEDpvJPu5J30UyYIAlxWY722UW47ZEWDNxSBNxRBU2dVrUUJQxKNCi+rahRvqqYjGFERCBvHtEUS4bKZUZJt7xw7ZuYxPUIwOSMiooT75PToiqrBG1LgCxvTo3uCCloDI3vR4eid9IgKUQTsFqN7XpaLd9LjzSKJyHZZke2yxlTVWn0y2oKdVTUNsJtNrKrRKQsrnTMryp3HtNkUPaa7bhbwmB55mJwREVHSkU6YyKE/iw6n4kQOMXfSdR0WkwCXzYziLDvS7byTPlR6q6p5ghE0+2VjYXZVhiQIcFiNhXxH2o0D6h9N1xGQY49pp1VCcaZxTLtsEhN9YnJGRETJrX+LDodTYtFhWdHglxUEZRWCADgsxp10Y5yJBKdFgjhMv1uq6F5VU6I3DtoCMhq9Eei6Mb7SaWH30pGup2M6321DFo9p6gWTs2Tm9wOmHu6gmEyAzRYb1xtRBOz2U4sNBABd7zlWEACH49Rig0FA03pvh9N5arGhEKCq8Yl1OIx2A0A4DChKfGLtdmM7A4AsA5FIfGJttuP7ykBiIxEjvjdWKyBJA49VFGNb9MZiAczmgceqqvFv1xuz2YgfaKymGftaPGIlydgWgHFMBALxiR3IcZ/i5wiz03l80WE7EAhF4AspaAvKaPOH0NKmQtN1Y6HsjPRoVU0IhQCt9+Nedxw/R5w01n78uBfCYUDt/bjvK1bvupMuK1A1QHTa4bJbjDvpJh0uk955J10DVBkInnAM8hzRPXaIzxEigDQAaQ4zRme4EVZUeAMyfK0eNPuD8PoUKCpgEhGdAVKQzNBPOO6FYF/HvdT/WNEE/YTjXgj0dSwPIFYQoZ9w3A8oNtj3ca/bHacYGwT03s8RMcfyQGLjcI7QdWM8qNdkgaIDZpOANKgocZngshvrjnU7pnkd0T12oOeIvv52DTc6JZ2Ojg4dgN5hnKa6/yxdGvsCh6PnOEDXFy2Kjc3J6T22oiI2trS099jJk2NjJ0/uPba0NDa2oqL32Jyc2NhFi3qPdThiY5cu7T32k7v6JZf0HevzHY9dvrzv2MbG47Hf/W7fsVVVx2Nvuqnv2N27j8fedlvfse+/fzz23nv7jn3jjeOxa9f2Hfvii8djn3yy79hnnjke+8wzfcc++eTx2Bdf7Dt27drjsW+80Xfsvfcej33//b5jb7vteOzu3X3H3nTT8diqqr5jv/vd47GNjX3HLl9+PNbn6zv2kkv0GH3F8hyh64Cu2B36Gx816C/vPqq/uqdeb110bp/bbVdde/Sn/cIv9hn7wb4j0djWSy7rM3bPjgPR2OZlV/cZ6927X1dVzfhuPEcYUuwcUfP1K/WN+xr1rVWt+p4dB/qMbb3ksui+88G+I33Gtl/4xZh9uK/Yjk9/NiZWtfd+jvDOPysmNpKV3Wusf9rMmNhwUXGvscHxE2Nig+Mn9hobLiqOifVPm9lrbCQrOybWO/+sXmNVuyMmtuPTn+1zuw3oHLH/sH6kLaB3BGVdW7a87/2H1xHGz2mcIzoAHYDe0dGhD3esnBERUUoSBaCiPMtYvyoQhp6gdmi6Dn9YgV9W4A4ryO4j1mU1Gw2nlOW2m2GVRHSEZHR0BDE50Q2iAdN0HYra9xll6ugMwNlZReQhTQMg6LqeqL9X1AuPxwO3242Oo0eRnp7ePSDFuyyxW+MpxA737ghJ2mXplGLZrdGQhOcI2ReALxCGN2hM0+8LKZAVDaIowGmRYM1Ij45VO91ujYqqwR9WEIxoUO12OKwSMhxmZElAmgS4ehtnwnOEIcXPEZrZAp+swBuMoLWpDZ5gBEHZ2I/tZmOSG8kksltjr7FD361RUTV4TVYEIioEAA49ArdFRLbTCpdN6n5M8zrCMETnCE9TE9yjR6Ojo6Pna+dhhMlZPzzyyCO47777UF9fj+nTp+Phhx/G3Llze41/9tln8bOf/QzV1dUYN24c7rnnHixdurTfnxdNzlJgByMiSka63n3R4aCsnPKiw5quIxRR4Q+riKgaJMlI+HJd1s6ZFVNzRkmKj1DnbKSeYARNvjD8sgJF0WE2iXBaTbCZTRA5pfqQOvGYllUVZkmE0yIhx2WB227hMZ1kUunamd0aT+Lpp5/GjTfeiHXr1mHevHl48MEHcf7552Pfvn3Iy8vrFr9p0yZcdtllWLNmDT7/+c9jw4YNuPjii7Ft2zZMnTo1Ad+AiIg+6WSLDntDkeOLDvcyPXokWh0z7rTbLSZkuyzISbPCZZWQZuUsbNQ/NrORgOWmWVGe44Q3bKzx1+wNoyMYQUfQqGLYO9f4M5s4A+RgiKhadIIewPh3OfGYdo3A9RVp6LFydhLz5s3DnDlzsHbtWgCApmkoLi7GypUrcfPNN3eLv/TSS+H3+/Hiiy9GH5s/fz5mzJiBdevW9fgZ4XAY4RNKtx6PB8XFxSmR/RMRDTe6rsPXeXHc6jOmRw9G1Oiiw4qmQ9ZUo6rBO+k0yLqqah1BGc0+GX5ZQUTVYBFNsJlFCBzQdFp06AgrGsIqj+nhjJWzEUKWZVRWVmL16tXRx0RRxLnnnovNmzf3+JrNmzfjxhtvjHns/PPPx/PPP9/r56xZswa33357XNpMRESnRxAEpNmMRZ5Hue0IKyp8nV3Omv0yLCYR2S4L0mxm3kmnQRdbVTNuHHhDEbT4ZPjDCvSETXWTOrKcFh7TlDSYnPWhubkZqqoiPz8/5vH8/Hzs3bu3x9fU19f3GF9fX9/r56xevTomoeuqnBERUeJZJROsLhOyXVaU5egQOPaHEsQkCnDbzXDbzSjKdEDVmJjFA5MxSiZMzpKA1WqFtWs2JiIiSlpMzCiZMKkgSj0cUdqHnJwcmEwmNDQ0xDze0NCAgoKCHl9TUFAwoHgiIiIiIiKAyVmfLBYLZs+ejddeey36mKZpeO2117BgwYIeX7NgwYKYeAB49dVXe40nIiIiIiIC2K3xpG688UYsX74cFRUVmDt3Lh588EH4/X6sWLECALBs2TIUFhZizZo1AIDrr78eixYtwq9+9StceOGFeOqpp7B161Y89thj/f7Mrgk0PR5P/L8QEREREVEK6bpmToVJ6JmcncSll16KpqYm3Hrrraivr8eMGTPw8ssvRyf9qK2thSgeL0AuXLgQGzZswC233IKf/OQnGDduHJ5//vkBrXHm9XoBgJOCEBERERH1k9frhdvtTnQzTgvXOUtCmqbh6NGjSEtLG/LB510zRdbV1Q37dSIocbgf0eniPkTxwP2IThf3oeFB13V4vV6MHj06pmgyHLFyloREUURRUVFC25Cens6TEJ027kd0urgPUTxwP6LTxX0o+Q33ilmX4Z1aEhERERERpQgmZ0REREREREmAyRnFsFqtuO2227goNp0W7kd0urgPUTxwP6LTxX2IhhonBCEiIiIiIkoCrJwRERERERElASZnRERERERESYDJGRERERERURJgckZERERERJQEmJyNQI888gjKyspgs9kwb948vP/++33GP/vss5g4cSJsNhvOPPNM/Otf/xqillIyG8h+tH79egiCEPNjs9mGsLWUbP773//ioosuwujRoyEIAp5//vmTvubNN9/ErFmzYLVaMXbsWKxfv37Q20nJa6D70JtvvtntPCQIAurr64emwZR01qxZgzlz5iAtLQ15eXm4+OKLsW/fvpO+jtdFNJiYnI0wTz/9NG688Ubcdttt2LZtG6ZPn47zzz8fjY2NPcZv2rQJl112Ga666ips374dF198MS6++GLs3r17iFtOyWSg+xEApKen49ixY9GfmpqaIWwxJRu/34/p06fjkUce6Vd8VVUVLrzwQixZsgQ7duzAqlWrcPXVV+OVV14Z5JZSshroPtRl3759MeeivLy8QWohJbuNGzfie9/7Ht599128+uqriEQi+OxnPwu/39/ra3hdRIONU+mPMPPmzcOcOXOwdu1aAICmaSguLsbKlStx8803d4u/9NJL4ff78eKLL0Yfmz9/PmbMmIF169YNWbspuQx0P1q/fj1WrVqF9vb2IW4pDQeCIOC5557DxRdf3GvMj3/8Y7z00ksxF0Bf//rX0d7ejpdffnkIWknJrD/70JtvvoklS5agra0NGRkZQ9Y2Gj6ampqQl5eHjRs34lOf+lSPMbwuosHGytkIIssyKisrce6550YfE0UR5557LjZv3tzjazZv3hwTDwDnn39+r/GU+k5lPwIAn8+H0tJSFBcX44tf/CL27NkzFM2lFMFzEcXLjBkzMGrUKJx33nl45513Et0cSiIdHR0AgKysrF5jeC6iwcbkbARpbm6GqqrIz8+PeTw/P7/XPvf19fUDiqfUdyr70YQJE/DEE0/gn//8J/7yl79A0zQsXLgQhw8fHoomUwro7Vzk8XgQDAYT1CoaTkaNGoV169bhH//4B/7xj3+guLgYixcvxrZt2xLdNEoCmqZh1apVOOusszB16tRe43hdRINNSnQDiCj1LViwAAsWLIj+vnDhQkyaNAmPPvoo7rzzzgS2jIhGigkTJmDChAnR3xcuXIiDBw/i17/+Nf785z8nsGWUDL73ve9h9+7dePvttxPdFBrhWDkbQXJycmAymdDQ0BDzeENDAwoKCnp8TUFBwYDiKfWdyn70SWazGTNnzsSBAwcGo4mUgno7F6Wnp8NutyeoVTTczZ07l+chwnXXXYcXX3wRb7zxBoqKivqM5XURDTYmZyOIxWLB7Nmz8dprr0Uf0zQNr732WkxV40QLFiyIiQeAV199tdd4Sn2nsh99kqqq+OCDDzBq1KjBaialGJ6LaDDs2LGD56ERTNd1XHfddXjuuefw+uuvo7y8/KSv4bmIBhu7NY4wN954I5YvX46KigrMnTsXDz74IPx+P1asWAEAWLZsGQoLC7FmzRoAwPXXX49FixbhV7/6FS688EI89dRT2Lp1Kx577LFEfg1KsIHuR3fccQfmz5+PsWPHor29Hffddx9qampw9dVXJ/JrUAL5fL6YikVVVRV27NiBrKwslJSUYPXq1Thy5Aj+9Kc/AQC+/e1vY+3atfjRj36Eb37zm3j99dfxzDPP4KWXXkrUV6AEG+g+9OCDD6K8vBxTpkxBKBTC448/jtdffx3/+c9/EvUVKMG+973vYcOGDfjnP/+JtLS06Lgxt9sdrcjzuoiGnE4jzsMPP6yXlJToFotFnzt3rv7uu+9Gn1u0aJG+fPnymPhnnnlGHz9+vG6xWPQpU6boL7300hC3mJLRQPajVatWRWPz8/P1pUuX6tu2bUtAqylZvPHGGzqAbj9d+83y5cv1RYsWdXvNjBkzdIvFoo8ZM0Z/8sknh7zdlDwGug/dc889+hlnnKHbbDY9KytLX7x4sf76668npvGUFHrafwDEnFt4XURDjeucERERERERJQGOOSMiIiIiIkoCTM6IiIiIiIiSAJMzIiIiIiKiJMDkjIiIiIiIKAkwOSMiIiIiIkoCTM6IiIiIiIiSAJMzIiIiIiKiJMDkjIiIiIiIKAkwOSMiIjoJWZYxduxYbNq0CQBQXV0NQRCwY8eOhLTn5ptvxsqVKxPy2URENHiYnBERUdJqamrCd77zHZSUlMBqtaKgoADnn38+3nnnnWhMWVkZBEHAu+++G/PaVatWYfHixdHff/7zn0MQBAiCAJPJhOLiYlx77bVobW09aTvWrVuH8vJyLFy4MG7fDQAWL16MVatWDfh1N910E/74xz/i0KFDcW0PERElFpMzIiJKWl/5ylewfft2/PGPf8T+/fvxwgsvYPHixWhpaYmJs9ls+PGPf3zS95syZQqOHTuG2tpaPPnkk3j55Zfxne98p8/X6LqOtWvX4qqrrjqt7xJPOTk5OP/88/G73/0u0U0hIqI4YnJGRERJqb29HW+99RbuueceLFmyBKWlpZg7dy5Wr16NL3zhCzGx1157Ld59913861//6vM9JUlCQUEBCgsLce655+KrX/0qXn311T5fU1lZiYMHD+LCCy/s9tzevXuxcOFC2Gw2TJ06FRs3box5fvfu3bjgggvgcrmQn5+P//mf/0FzczMA4Morr8TGjRvx0EMPRSt61dXVUFUVV111FcrLy2G32zFhwgQ89NBD3T77oosuwlNPPdVn24mIaHhhckZEREnJ5XLB5XLh+eefRzgc7jO2vLwc3/72t7F69Wpomtav96+ursYrr7wCi8XSZ9xbb72F8ePHIy0trdtzP/zhD/GDH/wA27dvx4IFC3DRRRdFq3rt7e349Kc/jZkzZ2Lr1q14+eWX0dDQgK997WsAgIceeggLFizANddcg2PHjuHYsWMoLi6GpmkoKirCs88+iw8//BC33norfvKTn+CZZ56J+ey5c+fi8OHDqK6u7tf3JSKi5MfkjIiIkpIkSVi/fj3++Mc/IiMjA2eddRZ+ttDu6wAABKFJREFU8pOfYNeuXT3G33LLLaiqqsJf//rXXt/zgw8+gMvlgt1uR3l5Ofbs2XPS7pA1NTUYPXp0j89dd911+MpXvoJJkybhd7/7HdxuN/7whz8AANauXYuZM2fi7rvvxsSJEzFz5kw88cQTeOONN7B//3643W5YLBY4HA4UFBSgoKAAJpMJZrMZt99+OyoqKlBeXo7LL78cK1as6JacdbWppqamz/YTEdHwweSMiIiS1le+8hUcPXoUL7zwAj73uc/hzTffxKxZs7B+/fpusbm5ubjppptw6623QpblHt9vwoQJ2LFjB7Zs2YIf//jHOP/8808662EwGITNZuvxuQULFkT/X5IkVFRU4KOPPgIA7Ny5E2+88Ua0AuhyuTBx4kQAwMGDB/v8zEceeQSzZ89Gbm4uXC4XHnvsMdTW1sbE2O12AEAgEOjzvYiIaPhgckZEREnNZrPhvPPOw89+9jNs2rQJV155JW677bYeY2+88UYEg0H89re/7fF5i8WCsWPHYurUqfjlL38Jk8mE22+/vc/Pz8nJQVtb24Db7fP5cNFFF2HHjh0xPx9//DE+9alP9fq6p556CjfddBOuuuoq/Oc//8GOHTuwYsWKbgln1yyTubm5A24bERElJyZnREQ0rEyePBl+v7/H51wuF372s5/hrrvugtfrPel73XLLLbj//vtx9OjRXmNmzpyJvXv3Qtf1bs+dOH2/oiiorKzEpEmTAACzZs3Cnj17UFZWhrFjx8b8OJ1OAEayqKpqzHu+8847WLhwIb773e9i5syZGDt2bI+Vtt27d8NsNmPKlCkn/Z5ERDQ8MDkjIqKk1NLSgk9/+tP4y1/+gl27dqGqqgrPPvss7r33Xnzxi1/s9XXXXnst3G43NmzYcNLPWLBgAaZNm4a7776715glS5bA5/Nhz5493Z575JFH8Nxzz2Hv3r343ve+h7a2Nnzzm98EAHzve99Da2srLrvsMmzZsgUHDx7EK6+8ghUrVkQTsrKyMrz33nuorq5Gc3MzNE3DuHHjsHXrVrzyyivYv38/fvazn2HLli3dPvutt97COeecE+3eSEREwx+TMyIiSkoulwvz5s3Dr3/9a3zqU5/C1KlT8bOf/QzXXHMN1q5d2+vrzGYz7rzzToRCoX59zg033IDHH38cdXV1PT6fnZ2NL33pSz1ONPLLX/4Sv/zlLzF9+nS8/fbbeOGFF5CTkwPAmLDjnXfegaqq+OxnP4szzzwTq1atQkZGBkTR+PN70003wWQyYfLkycjNzUVtbS2+9a1v4ctf/jIuvfRSzJs3Dy0tLfjud7/b7bOfeuopXHPNNf36jkRENDwIek/9NIiIiChq165dOO+883Dw4EG4XK5ENwf//ve/8YMf/AC7du2CJEmJbg4REcUJK2dEREQnMW3aNNxzzz2oqqpKdFMAAH6/H08++SQTMyKiFMPKGRERERERURJg5YyIiIiIiCgJMDkjIiIiIiJKAkzOiIiIiIiIkgCTMyIiIiIioiTA5IyIiIiIiCgJMDkjIiIiIiJKAkzOiIiIiIiIkgCTMyIiIiIioiTA5IyIiIiIiCgJ/H9qs131YwTyrwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, axs = plt.subplots(3, 1, figsize=(8, 6), sharey=True, sharex=True)\n", "axs = axs.flatten()\n", diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index eca0b21c5..f015a0273 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -140,7 +140,7 @@ def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size) "estimator": RandomForestClassifier( max_features="sqrt", random_state=seed, - n_estimators=150, + n_estimators=100, n_jobs=-1, ), "random_state": seed, From 1eb8604f04c7f04dc83743bd936cf0b4e2ab25f6 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 19 Sep 2023 18:51:44 -0400 Subject: [PATCH 31/70] Adding coverage Signed-off-by: Adam Li --- ...t_MI_gigantic_hypothesis_testing_forest.py | 118 ++++++++++++++++++ sktree/stats/forestht.py | 6 + sktree/stats/permutationforest.py | 3 - sktree/stats/tests/test_forestht.py | 59 ++++++++- sktree/stats/utils.py | 23 +++- sktree/tree/__init__.py | 3 + sktree/tree/_honest_tree.py | 30 ++++- 7 files changed, 228 insertions(+), 14 deletions(-) create mode 100644 examples/plot_MI_gigantic_hypothesis_testing_forest.py diff --git a/examples/plot_MI_gigantic_hypothesis_testing_forest.py b/examples/plot_MI_gigantic_hypothesis_testing_forest.py new file mode 100644 index 000000000..2af3e4412 --- /dev/null +++ b/examples/plot_MI_gigantic_hypothesis_testing_forest.py @@ -0,0 +1,118 @@ +""" +=========================================================== +Mutual Information for Gigantic Hypothesis Testing (MIGHT) +=========================================================== + +An example using :class:`~sktree.FeatureImportanceForestClassifier` for nonparametric +multivariate hypothesis test, on simulated datasets. Here, we present a simulation +of how MIGHT is used to test the hypothesis that a "feature set is important for +predicting the target". + +We simulate a dataset with 1000 features, 500 samples, and a binary class target +variable. Within each feature set, there is 500 features associated with one feature +set, and another 500 features associated with another feature set. One could think of +these for example as different datasets collected on the same patient in a biomedical setting. +The first feature set (X) is strongly correlated with the target, and the second +feature set (W) is weakly correlated with the target (y). Here, we are testing the +null hypothesis: + +``H0: I(X; y) - I(X, W; y) = 0`` +``HA: I(X; y) - I(X, W; y) > 0`` + +where ``I`` is mutual information. + +We present causal settings where this would be true: + +- ``W X -> y``: here ``W`` is completely disconnected from X and y. +- ``W -> X -> y``: here ``W`` is d-separated from y given X. +- ``W -> y <- X``: here ``W`` is a weak predictor of y, and X is a strong predictor of y. +- ``X <- W -> y; X -> y``: here ``W`` is a weak confounder of the relationship between X and y. + +We then use MIGHT to test the hypothesis that the first feature set is important for +predicting the target, and the second feature set is not important for predicting the +target. We use :class:`~sktree.FeatureImportanceForestClassifier`. +""" + +import numpy as np +from scipy.special import expit + +from sktree import HonestForestClassifier +from sktree.stats import FeatureImportanceForestClassifier +from sktree.tree import DecisionTreeClassifier + +seed = 12345 +rng = np.random.default_rng(seed) + +# %% +# Simulate data +# ------------- +# We simulate the two feature sets, and the target variable. We then combine them +# into a single dataset to perform hypothesis testing. + +n_samples = 1000 +n_features_set = 500 +mean = 1.0 +sigma = 2.0 +beta = 5.0 + +unimportant_mean = 0.0 +unimportant_sigma = 4.5 + +# first sample the informative features, and then the uniformative features +X_important = rng.normal(loc=mean, scale=sigma, size=(n_samples, 10)) +X_important = np.hstack( + [ + X_important, + rng.normal( + loc=unimportant_mean, scale=unimportant_sigma, size=(n_samples, n_features_set - 10) + ), + ] +) + +X_unimportant = rng.normal( + loc=unimportant_mean, scale=unimportant_sigma, size=(n_samples, n_features_set) +) +X = np.hstack([X_important, X_unimportant]) + +# simulate the binary target variable +y = rng.binomial(n=1, p=expit(beta * X_important[:, :10].sum(axis=1)), size=n_samples) + +# %% +# Perform hypothesis testing using Mutual Information +# --------------------------------------------------- +n_estimators = 100 +max_features = 1.0 +test_size = 0.2 +n_repeats = 500 + +# TODO: This can be improved since HonestForestClassifier should be able to extract +# the relevant hyperparameters +est = FeatureImportanceForestClassifier( + estimator=HonestForestClassifier( + n_estimators=n_estimators, + max_features=max_features, + tree_estimator=DecisionTreeClassifier(), + random_state=seed, + honest_fraction=0.7, + ), + random_state=seed, + test_size=test_size, + permute_per_tree=True, + sample_dataset_per_tree=True, +) + +# we test for the first feature set, which is important and thus should return a pvalue < 0.05 +stat, pvalue = est.test( + X, y, covariate_index=np.arange(n_features_set, dtype=int), metric="mi", n_repeats=n_repeats +) +print(f"Estimated MI difference: {stat} with Pvalue: {pvalue}") + +# we test for the second feature set, which is important and thus should return a pvalue > 0.05 +stat, pvalue = est.test( + X, + y, + covariate_index=np.arange(n_features_set, dtype=int) + n_features_set, + metric="mi", + n_repeats=n_repeats, +) +print(f"Estimated MI difference: {stat} with Pvalue: {pvalue}") diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index df37c7b62..57ab24ea4 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -377,6 +377,9 @@ class FeatureImportanceForestRegressor(BaseForestHT): verbose : int, default=0 Controls the verbosity when fitting and predicting. + test_size : float, default=0.2 + Proportion of samples per tree to use for the test set. + permute_per_tree : bool, default=True Whether to permute the covariate index per tree or per forest. @@ -554,6 +557,9 @@ class FeatureImportanceForestClassifier(BaseForestHT): verbose : int, default=0 Controls the verbosity when fitting and predicting. + test_size : float, default=0.2 + Proportion of samples per tree to use for the test set. + permute_per_tree : bool, default=True Whether to permute the covariate index per tree or per forest. diff --git a/sktree/stats/permutationforest.py b/sktree/stats/permutationforest.py index 026b89eca..6512f28ae 100644 --- a/sktree/stats/permutationforest.py +++ b/sktree/stats/permutationforest.py @@ -387,9 +387,6 @@ class PermutationForestClassifier(BasePermutationForest): test_size : float, default=0.2 The proportion of samples to leave out for each tree to compute metric on. - n_jobs : int, default=None - The number of jobs to run in parallel. - random_state : int, RandomState instance or None, default=None Controls both the randomness of the bootstrapping of the samples used when building trees (if ``bootstrap=True``) and the sampling of the diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index f015a0273..ba020a403 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -29,6 +29,50 @@ iris_y = iris_y[p] +def test_featureimportance_forest_permute_pertree(): + est = FeatureImportanceForestClassifier( + estimator=RandomForestClassifier( + n_estimators=10, + ), + permute_per_tree=True, + sample_dataset_per_tree=True, + ) + est.statistic(iris_X[:10], iris_y[:10]) + + assert ( + len(est.train_test_samples_[0][1]) == 10 * est.test_size + ), f"{len(est.train_test_samples_[0][1])} {10 * est.test_size}" + assert len(est.train_test_samples_[0][0]) == est._n_samples_ - 10 * est.test_size + + est.test(iris_X[:10], iris_y[:10], [0, 1], n_repeats=10, metric="mse") + assert ( + len(est.train_test_samples_[0][1]) == 10 * est.test_size + ), f"{len(est.train_test_samples_[0][1])} {10 * est.test_size}" + assert len(est.train_test_samples_[0][0]) == est._n_samples_ - 10 * est.test_size + + +def test_featureimportance_forest_errors(): + permute_per_tree = False + sample_dataset_per_tree = True + est = FeatureImportanceForestClassifier( + estimator=RandomForestClassifier( + n_estimators=10, + ), + permute_per_tree=permute_per_tree, + sample_dataset_per_tree=sample_dataset_per_tree, + ) + with pytest.raises(ValueError, match="sample_dataset_per_tree"): + est.statistic(iris_X[:10], iris_y[:10]) + + est = FeatureImportanceForestClassifier(estimator=RandomForestRegressor) + with pytest.raises(RuntimeError, match="Estimator must be"): + est.statistic(iris_X[:10], iris_y[:10]) + + est = FeatureImportanceForestRegressor(estimator=RandomForestClassifier) + with pytest.raises(RuntimeError, match="Estimator must be"): + est.statistic(iris_X[:10], iris_y[:10]) + + @flaky(max_runs=3) @pytest.mark.slowtest @pytest.mark.parametrize( @@ -215,8 +259,12 @@ def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, ObliqueDecisionTreeClassifier(), ], ) -@pytest.mark.parametrize("limit", [0.05, 0.1]) -def test_iris_pauc_statistic(criterion, honest_prior, estimator, limit): +@pytest.mark.parametrize("permute_per_tree", [True, False]) +@pytest.mark.parametrize("sample_dataset_per_tree", [True, False]) +def test_iris_pauc_statistic( + criterion, honest_prior, estimator, permute_per_tree, sample_dataset_per_tree +): + limit = 0.1 max_features = "sqrt" n_repeats = 200 n_estimators = 100 @@ -234,14 +282,17 @@ def test_iris_pauc_statistic(criterion, honest_prior, estimator, limit): n_jobs=-1, ), test_size=test_size, - sample_dataset_per_tree=True, - permute_per_tree=True, + sample_dataset_per_tree=sample_dataset_per_tree, + permute_per_tree=permute_per_tree, ) # now add completely uninformative feature X = np.hstack((iris_X, rng.standard_normal(size=(iris_X.shape[0], 4)))) # test for unimportant feature set clf.reset() + if sample_dataset_per_tree and not permute_per_tree: + # test in another test + pytest.skip() stat, pvalue = clf.test( X, iris_y, diff --git a/sktree/stats/utils.py b/sktree/stats/utils.py index 9b1c3debe..9d06dc8fd 100644 --- a/sktree/stats/utils.py +++ b/sktree/stats/utils.py @@ -15,11 +15,30 @@ from sktree._lib.sklearn.tree import DecisionTreeClassifier -def _mutual_information(y_true, y_pred_proba): +def _mutual_information(y_true: ArrayLike, y_pred_proba: ArrayLike) -> float: + """Compute estimate of mutual information. + + Parameters + ---------- + y_true : ArrayLike of shape (n_samples,) + _description_ + y_pred_proba : ArrayLike of shape (n_samples, n_outputs) + Posterior probabilities. + + Returns + ------- + float : + The estimated MI. + """ + if y_true.squeeze().ndim != 1: + raise ValueError(f"y_true must be 1d, not {y_true.shape}") + + # entropy averaged over n_samples H_YX = np.mean(entropy(y_pred_proba, base=np.exp(1), axis=1)) + # empirical count of each class (n_classes) _, counts = np.unique(y_true, return_counts=True) H_Y = entropy(counts, base=np.exp(1)) - return max(H_Y - H_YX, 0) + return H_Y - H_YX METRIC_FUNCTIONS = { diff --git a/sktree/tree/__init__.py b/sktree/tree/__init__.py index c4a706c99..be8baf5db 100644 --- a/sktree/tree/__init__.py +++ b/sktree/tree/__init__.py @@ -1,3 +1,4 @@ +from .._lib.sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor from ._classes import ( ExtraObliqueDecisionTreeClassifier, ExtraObliqueDecisionTreeRegressor, @@ -22,4 +23,6 @@ "PatchObliqueDecisionTreeClassifier", "PatchObliqueDecisionTreeRegressor", "HonestTreeClassifier", + "DecisionTreeClassifier", + "DecisionTreeRegressor", ] diff --git a/sktree/tree/_honest_tree.py b/sktree/tree/_honest_tree.py index 4ffa72c0f..43abe93fe 100644 --- a/sktree/tree/_honest_tree.py +++ b/sktree/tree/_honest_tree.py @@ -1,10 +1,9 @@ # Authors: Ronan Perry, Sambit Panda, Haoyin Xu # Adopted from: https://github.com/neurodata/honest-forests -from copy import deepcopy - import numpy as np -from sklearn.base import ClassifierMixin, MetaEstimatorMixin, _fit_context +from sklearn.base import ClassifierMixin, MetaEstimatorMixin, _fit_context, clone +from sklearn.ensemble._base import _set_random_states from sklearn.utils.multiclass import _check_partial_fit_first_call, check_classification_targets from sklearn.utils.validation import check_is_fitted, check_X_y @@ -536,7 +535,7 @@ def _fit( _sample_weight[self.honest_indices_] = 0 - if not self.tree_estimator: + if self.tree_estimator is None: self.estimator_ = DecisionTreeClassifier( criterion=self.criterion, splitter=self.splitter, @@ -555,7 +554,28 @@ def _fit( ) else: # XXX: maybe error out if the tree_estimator is already fitted - self.estimator_ = deepcopy(self.tree_estimator) + self.estimator_ = clone(self.tree_estimator) + self.estimator_.set_params( + **dict( + criterion=self.criterion, + splitter=self.splitter, + max_depth=self.max_depth, + min_samples_split=self.min_samples_split, + min_samples_leaf=self.min_samples_leaf, + min_weight_fraction_leaf=self.min_weight_fraction_leaf, + max_features=self.max_features, + max_leaf_nodes=self.max_leaf_nodes, + class_weight=self.class_weight, + random_state=self.random_state, + min_impurity_decrease=self.min_impurity_decrease, + ccp_alpha=self.ccp_alpha, + monotonic_cst=self.monotonic_cst, + store_leaf_values=self.store_leaf_values, + ) + ) + + if self.random_state is not None: + _set_random_states(self.estimator_, self.random_state) # Learn structure on subsample self.estimator_._fit( From 8c1d15c034948e4c23db2647a38b597ca78bca91 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 19 Sep 2023 23:50:56 -0400 Subject: [PATCH 32/70] Updated example Signed-off-by: Adam Li --- ...t_MI_gigantic_hypothesis_testing_forest.py | 33 +++++++++++++------ sktree/stats/forestht.py | 20 +++++++---- sktree/stats/permutationforest.py | 3 -- sktree/stats/tests/test_forestht.py | 13 ++++++-- sktree/tree/_honest_tree.py | 18 ++++++++-- 5 files changed, 62 insertions(+), 25 deletions(-) diff --git a/examples/plot_MI_gigantic_hypothesis_testing_forest.py b/examples/plot_MI_gigantic_hypothesis_testing_forest.py index 2af3e4412..a8ed7fe1f 100644 --- a/examples/plot_MI_gigantic_hypothesis_testing_forest.py +++ b/examples/plot_MI_gigantic_hypothesis_testing_forest.py @@ -3,10 +3,11 @@ Mutual Information for Gigantic Hypothesis Testing (MIGHT) =========================================================== -An example using :class:`~sktree.FeatureImportanceForestClassifier` for nonparametric +An example using :class:`~sktree.stats.FeatureImportanceForestClassifier` for nonparametric multivariate hypothesis test, on simulated datasets. Here, we present a simulation of how MIGHT is used to test the hypothesis that a "feature set is important for -predicting the target". +predicting the target". This is a generalization of the framework presented in +:footcite:`coleman2022scalable`. We simulate a dataset with 1000 features, 500 samples, and a binary class target variable. Within each feature set, there is 500 features associated with one feature @@ -19,18 +20,16 @@ ``H0: I(X; y) - I(X, W; y) = 0`` ``HA: I(X; y) - I(X, W; y) > 0`` -where ``I`` is mutual information. - -We present causal settings where this would be true: +where ``I`` is mutual information. For example, this could be true in the following settings, +where X is our informative feature set and W is our uninformative feature set. - ``W X -> y``: here ``W`` is completely disconnected from X and y. - ``W -> X -> y``: here ``W`` is d-separated from y given X. -- ``W -> y <- X``: here ``W`` is a weak predictor of y, and X is a strong predictor of y. -- ``X <- W -> y; X -> y``: here ``W`` is a weak confounder of the relationship between X and y. +- ``W <- X -> y``: here ``W`` is d-separated from y given X. We then use MIGHT to test the hypothesis that the first feature set is important for predicting the target, and the second feature set is not important for predicting the -target. We use :class:`~sktree.FeatureImportanceForestClassifier`. +target. We use :class:`~sktree.stats.FeatureImportanceForestClassifier`. """ import numpy as np @@ -80,13 +79,22 @@ # %% # Perform hypothesis testing using Mutual Information # --------------------------------------------------- +# Here, we use :class:`~sktree.stats.FeatureImportanceForestClassifier` to perform the hypothesis +# test. The test statistic is computed by comparing the metric (i.e. mutual information) estimated +# between two forests. One forest is trained on the original dataset, and one forest is trained +# on a permuted dataset, where the rows of the ``covariate_index`` columns are shuffled randomly. +# +# The null distribution is then estimated in an efficient manner using the framework of +# :footcite:`coleman2022scalable`. The sample evaluations of each forest (i.e. the posteriors) +# are sampled randomly ``n_repeats`` times to generate a null distribution. The pvalue is then +# computed as the proportion of samples in the null distribution that are less than the +# observed test statistic. + n_estimators = 100 max_features = 1.0 test_size = 0.2 n_repeats = 500 -# TODO: This can be improved since HonestForestClassifier should be able to extract -# the relevant hyperparameters est = FeatureImportanceForestClassifier( estimator=HonestForestClassifier( n_estimators=n_estimators, @@ -116,3 +124,8 @@ n_repeats=n_repeats, ) print(f"Estimated MI difference: {stat} with Pvalue: {pvalue}") + +# %% +# References +# ---------- +# .. footbibliography:: diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 57ab24ea4..9f8016684 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -250,8 +250,6 @@ def test( The index array of covariates to shuffle, by default None. metric : str, optional The metric to compute, by default "mse". - test_size : float, optional - Proportion of samples per tree to use for the test set, by default 0.2. n_repeats : int, optional Number of times to sample the null distribution, by default 1000. return_posteriors : bool, optional @@ -315,6 +313,8 @@ def test( y_test = y[indices_test, :] else: y_test = y + print("y_test: ", y_test.shape) + print(observe_posteriors.shape, permute_posteriors.shape) metric_star, metric_star_pi = _compute_null_distribution_coleman( y_test=y_test, y_pred_proba_normal=observe_posteriors, @@ -647,13 +647,13 @@ def _statistic( if self.permute_per_tree: if predict_posteriors: - posterior_arr = np.zeros( - (self.n_estimators, self.n_samples_test_, estimator.n_classes_) + posterior_arr = np.full( + (self.n_estimators, self._n_samples_, estimator.n_classes_), np.nan ) else: # now initialize posterior array as (n_trees, n_samples_test, n_outputs) - posterior_arr = np.zeros( - (self.n_estimators, self.n_samples_test_, estimator.n_outputs_) + posterior_arr = np.full( + (self.n_estimators, self._n_samples_, estimator.n_outputs_), np.nan ) for idx, (indices_train, indices_test) in enumerate(self._get_estimators_indices()): @@ -667,6 +667,7 @@ def _statistic( y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) # Fill test set posteriors & set rest NaN + # TODO: refactor so posterior_arr is just a large NaN array posterior_arr[idx, indices_test, :] = y_pred # posterior # Average all posteriors (n_samples_test, n_outputs) @@ -679,6 +680,7 @@ def _statistic( # Ignore all NaN values (samples not tested) y_true_final = y[nonnan_indices, :] posterior_final = posterior_final[nonnan_indices, :] + print("Inside _statistic: ", y_true_final.shape, posterior_final.shape) else: # fitting a forest will only get one unique train/test split indices_train, indices_test = self.train_test_samples_[0] @@ -710,6 +712,9 @@ def _statistic( y_true_final = y_test posterior_final = y_pred + print("False false: ", posterior_final.shape, y_true_final.shape) + print(y_true_final) + print(posterior_final) if metric == "auc": # at this point, posterior_final is the predicted posterior for only the positive class # as more than one output is not supported. @@ -720,6 +725,9 @@ def _statistic( f"AUC metric is not supported for {self._type_of_target} targets." ) + if np.isnan(posterior_final).any(): + raise RuntimeError("NaN values encountered in posterior_final.") + stat = metric_func(y_true_final, posterior_final, **metric_kwargs) if covariate_index is None: # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) diff --git a/sktree/stats/permutationforest.py b/sktree/stats/permutationforest.py index 6512f28ae..4a27f539f 100644 --- a/sktree/stats/permutationforest.py +++ b/sktree/stats/permutationforest.py @@ -215,9 +215,6 @@ def test( The covariate indices of ``X`` to shuffle. metric : str, optional Metric to compute, by default "mse". - test_size : float, optional - Size of the samples to leave out for each tree to compute posteriors on, - by default 0.2. n_repeats : int, optional Number of times to sample the null distribution, by default 1000. return_posteriors : bool, optional diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index ba020a403..18cc507e3 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -250,7 +250,7 @@ def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, @flaky(max_runs=3) @pytest.mark.parametrize("criterion", ["gini", "entropy"]) -@pytest.mark.parametrize("honest_prior", ["empirical", "uniform", "ignore"]) +@pytest.mark.parametrize("honest_prior", ["empirical", "uniform"]) @pytest.mark.parametrize( "estimator", [ @@ -259,7 +259,13 @@ def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, ObliqueDecisionTreeClassifier(), ], ) -@pytest.mark.parametrize("permute_per_tree", [True, False]) +@pytest.mark.parametrize( + "permute_per_tree", + [ + True, + False, + ], +) @pytest.mark.parametrize("sample_dataset_per_tree", [True, False]) def test_iris_pauc_statistic( criterion, honest_prior, estimator, permute_per_tree, sample_dataset_per_tree @@ -268,7 +274,7 @@ def test_iris_pauc_statistic( max_features = "sqrt" n_repeats = 200 n_estimators = 100 - test_size = 0.1 + test_size = 0.2 # Check consistency on dataset iris. clf = FeatureImportanceForestClassifier( @@ -293,6 +299,7 @@ def test_iris_pauc_statistic( if sample_dataset_per_tree and not permute_per_tree: # test in another test pytest.skip() + stat, pvalue = clf.test( X, iris_y, diff --git a/sktree/tree/_honest_tree.py b/sktree/tree/_honest_tree.py index 43abe93fe..5b6c8f6a1 100644 --- a/sktree/tree/_honest_tree.py +++ b/sktree/tree/_honest_tree.py @@ -1,6 +1,8 @@ # Authors: Ronan Perry, Sambit Panda, Haoyin Xu # Adopted from: https://github.com/neurodata/honest-forests +import inspect + import numpy as np from sklearn.base import ClassifierMixin, MetaEstimatorMixin, _fit_context, clone from sklearn.ensemble._base import _set_random_states @@ -568,12 +570,22 @@ def _fit( class_weight=self.class_weight, random_state=self.random_state, min_impurity_decrease=self.min_impurity_decrease, - ccp_alpha=self.ccp_alpha, - monotonic_cst=self.monotonic_cst, - store_leaf_values=self.store_leaf_values, ) ) + # TODO: refactor oblique trees to have these parameters by default, but not used + init_signature = inspect.signature(self.estimator_.__init__) + if "ccp_alpha" in init_signature.parameters: + self.estimator_.set_params(**dict(ccp_alpha=self.ccp_alpha)) + if "store_leaf_values" in init_signature.parameters: + self.estimator_.set_params( + **dict( + store_leaf_values=self.store_leaf_values, + ) + ) + if "monotonic_cst" in init_signature.parameters: + self.self.estimator_.set_params(**dict(monotonic_cst=self.monotonic_cst)) + if self.random_state is not None: _set_random_states(self.estimator_, self.random_state) From c40e866363458e2e2fc8a5dde41669022edb78ae Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 19 Sep 2023 23:58:52 -0400 Subject: [PATCH 33/70] Fix bug Signed-off-by: Adam Li --- sktree/tree/_honest_tree.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sktree/tree/_honest_tree.py b/sktree/tree/_honest_tree.py index 5b6c8f6a1..8e0f2321d 100644 --- a/sktree/tree/_honest_tree.py +++ b/sktree/tree/_honest_tree.py @@ -584,7 +584,7 @@ def _fit( ) ) if "monotonic_cst" in init_signature.parameters: - self.self.estimator_.set_params(**dict(monotonic_cst=self.monotonic_cst)) + self.estimator_.set_params(**dict(monotonic_cst=self.monotonic_cst)) if self.random_state is not None: _set_random_states(self.estimator_, self.random_state) From a6b1a0c7c789c5ff95d0be8f3434322434cc5f48 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 20 Sep 2023 00:08:50 -0400 Subject: [PATCH 34/70] Fix example Signed-off-by: Adam Li --- examples/plot_MI_gigantic_hypothesis_testing_forest.py | 6 ++++-- pyproject.toml | 2 +- sktree/stats/forestht.py | 7 ------- 3 files changed, 5 insertions(+), 10 deletions(-) diff --git a/examples/plot_MI_gigantic_hypothesis_testing_forest.py b/examples/plot_MI_gigantic_hypothesis_testing_forest.py index a8ed7fe1f..75078a20f 100644 --- a/examples/plot_MI_gigantic_hypothesis_testing_forest.py +++ b/examples/plot_MI_gigantic_hypothesis_testing_forest.py @@ -90,10 +90,11 @@ # computed as the proportion of samples in the null distribution that are less than the # observed test statistic. -n_estimators = 100 -max_features = 1.0 +n_estimators = 125 +max_features = "sqrt" test_size = 0.2 n_repeats = 500 +n_jobs = -1 est = FeatureImportanceForestClassifier( estimator=HonestForestClassifier( @@ -102,6 +103,7 @@ tree_estimator=DecisionTreeClassifier(), random_state=seed, honest_fraction=0.7, + n_jobs=n_jobs, ), random_state=seed, test_size=test_size, diff --git a/pyproject.toml b/pyproject.toml index 7bb840d16..d032d2c5d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -166,7 +166,7 @@ _cythonlint = 'cython-lint sktree/ --exclude "sktree/_lib/*"' _black_check = 'black --check sktree examples' _isort_check = 'isort --check .' _pydocstyle = 'pydocstyle ./sktree' -_codespell = 'codespell sktree/ doc/ examples/ --ignore-words=.codespellignore --skip "**/_build/*,**/_lib/*,doc/_build/*,doc/auto_examples/*,doc/tutorials/*"' +_codespell = 'codespell sktree/ doc/ examples/ --ignore-words=.codespellignore --skip "**/_build/*,**/_lib/*,doc/_build/*,doc/auto_examples/*,doc/tutorials/*,doc/generated/*"' _changelog = 'semversioner changelog > CHANGELOG.md' _apply_version = 'semversioner release' diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 9f8016684..c8280ce41 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -313,8 +313,6 @@ def test( y_test = y[indices_test, :] else: y_test = y - print("y_test: ", y_test.shape) - print(observe_posteriors.shape, permute_posteriors.shape) metric_star, metric_star_pi = _compute_null_distribution_coleman( y_test=y_test, y_pred_proba_normal=observe_posteriors, @@ -680,7 +678,6 @@ def _statistic( # Ignore all NaN values (samples not tested) y_true_final = y[nonnan_indices, :] posterior_final = posterior_final[nonnan_indices, :] - print("Inside _statistic: ", y_true_final.shape, posterior_final.shape) else: # fitting a forest will only get one unique train/test split indices_train, indices_test = self.train_test_samples_[0] @@ -711,10 +708,6 @@ def _statistic( samples = indices_test y_true_final = y_test posterior_final = y_pred - - print("False false: ", posterior_final.shape, y_true_final.shape) - print(y_true_final) - print(posterior_final) if metric == "auc": # at this point, posterior_final is the predicted posterior for only the positive class # as more than one output is not supported. From 21f3b224652ca37e547cbb33f5d63aa6223c1bff Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 20 Sep 2023 00:30:18 -0400 Subject: [PATCH 35/70] Fix unit-test Signed-off-by: Adam Li --- sktree/tests/test_honest_forest.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/sktree/tests/test_honest_forest.py b/sktree/tests/test_honest_forest.py index 6f2e3daae..91fce420e 100644 --- a/sktree/tests/test_honest_forest.py +++ b/sktree/tests/test_honest_forest.py @@ -79,12 +79,14 @@ def test_iris(criterion, max_features, honest_prior, estimator): ], ) def test_iris_multi(criterion, max_features, honest_prior, estimator): + n_estimators = 10 + # Check consistency on dataset iris. clf = HonestForestClassifier( criterion=criterion, random_state=0, max_features=max_features, - n_estimators=10, + n_estimators=n_estimators, honest_prior=honest_prior, tree_estimator=estimator, ) @@ -101,7 +103,7 @@ def test_iris_multi(criterion, max_features, honest_prior, estimator): score = r2_score(clf.predict(X), y) if honest_prior == "ignore": assert ( - score > 0.6 and score < 1.0 + score > 0.4 and score < 1.0 ), "Failed with {0}, criterion = {1} and score = {2}".format( "HForest", criterion, score ) From c8af371ba75789703f96eb1d3e2c0025af8b0840 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 20 Sep 2023 09:44:19 -0400 Subject: [PATCH 36/70] Remove unnecessary doc string Signed-off-by: Adam Li --- sktree/ensemble/_eiforest.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/sktree/ensemble/_eiforest.py b/sktree/ensemble/_eiforest.py index ba755ec27..c56b65c69 100644 --- a/sktree/ensemble/_eiforest.py +++ b/sktree/ensemble/_eiforest.py @@ -40,10 +40,6 @@ class ExtendedIsolationForest(IsolationForest): original paper. - If float, the contamination should be in the range (0, 0.5]. - .. versionchanged:: 0.22 - The default value of ``contamination`` changed from 0.1 - to ``'auto'``. - max_features : int or float, default=1.0 The number of features to draw from X to train each base estimator. From fd5a63c6af80e0d94518b2a4129c8a10d25d8552 Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Wed, 20 Sep 2023 10:15:12 -0400 Subject: [PATCH 37/70] DOC correct result evaluation comment Co-authored-by: Adam Li --- examples/plot_MI_gigantic_hypothesis_testing_forest.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/plot_MI_gigantic_hypothesis_testing_forest.py b/examples/plot_MI_gigantic_hypothesis_testing_forest.py index 75078a20f..8408f4e03 100644 --- a/examples/plot_MI_gigantic_hypothesis_testing_forest.py +++ b/examples/plot_MI_gigantic_hypothesis_testing_forest.py @@ -117,7 +117,7 @@ ) print(f"Estimated MI difference: {stat} with Pvalue: {pvalue}") -# we test for the second feature set, which is important and thus should return a pvalue > 0.05 +# we test for the second feature set, which is unimportant and thus should return a pvalue > 0.05 stat, pvalue = est.test( X, y, From eee4cbc79b0cbf6cd94862737b1830210d7785be Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 20 Sep 2023 10:21:34 -0400 Subject: [PATCH 38/70] Try redirect Signed-off-by: Adam Li --- .github/workflows/circle_artifacts.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/circle_artifacts.yml b/.github/workflows/circle_artifacts.yml index 09a231ef8..971e00d15 100644 --- a/.github/workflows/circle_artifacts.yml +++ b/.github/workflows/circle_artifacts.yml @@ -17,7 +17,7 @@ jobs: uses: larsoner/circleci-artifacts-redirector-action@master with: repo-token: ${{ secrets.GITHUB_TOKEN }} - api-token: ${{ secrets.CIRCLE_TOKEN }} + api-token: ${{ secrets.CIRCLECI_TOKEN }} artifact-path: 0/dev/index.html circleci-jobs: build_docs job-title: Check the rendered docs here! From 527397d15ccc76af0c304321dd08c4198db06498 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 20 Sep 2023 11:05:37 -0400 Subject: [PATCH 39/70] Try again Signed-off-by: Adam Li --- .github/workflows/circle_artifacts.yml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/.github/workflows/circle_artifacts.yml b/.github/workflows/circle_artifacts.yml index 971e00d15..40ec84b30 100644 --- a/.github/workflows/circle_artifacts.yml +++ b/.github/workflows/circle_artifacts.yml @@ -4,13 +4,14 @@ on: [status] # Restrict the permissions granted to the use of secrets.GITHUB_TOKEN in this # github actions workflow: # https://docs.github.com/en/actions/security-guides/automatic-token-authentication -permissions: - statuses: write +permissions: read-all jobs: circleci_artifacts_redirector_job: runs-on: ubuntu-20.04 if: "github.repository == 'neurodata/scikit-tree' && github.event.context == 'ci/circleci: build_docs'" + permissions: + statuses: write name: Run CircleCI artifacts redirector steps: - name: GitHub Action step From fe848a4af4963af6223e5158e561ef96325f1457 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 20 Sep 2023 11:07:56 -0400 Subject: [PATCH 40/70] Try again Signed-off-by: Adam Li --- sktree/stats/tests/test_forestht.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 18cc507e3..62ffd0a09 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -248,7 +248,7 @@ def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, assert pvalue > 0.05, f"pvalue: {pvalue}" -@flaky(max_runs=3) +@flaky(max_runs=2) @pytest.mark.parametrize("criterion", ["gini", "entropy"]) @pytest.mark.parametrize("honest_prior", ["empirical", "uniform"]) @pytest.mark.parametrize( From 9a052359f34ac9cda43931b8a7b7f545e0051691 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Thu, 21 Sep 2023 12:02:25 -0400 Subject: [PATCH 41/70] Improve the checking inputs of feature importance forests Signed-off-by: Adam Li --- sktree/stats/forestht.py | 74 +++++++++++++++++++++++++---- sktree/stats/tests/test_forestht.py | 45 ++++++++++++++++++ 2 files changed, 109 insertions(+), 10 deletions(-) diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index c8280ce41..1cf054bd2 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -43,6 +43,12 @@ def __init__( self.permute_per_tree = permute_per_tree self.sample_dataset_per_tree = sample_dataset_per_tree + self.n_samples_test_ = None + self._n_samples_ = None + self._covariate_index_cache_ = None + self._type_of_target_ = None + self.n_features_in_ = None + @property def n_estimators(self): return self.estimator_.n_estimators @@ -107,6 +113,29 @@ def _statistic( ): raise NotImplementedError("Subclasses should implement this!") + def _check_input(self, X: ArrayLike, y: ArrayLike, covariate_index: ArrayLike = None): + X, y = check_X_y(X, y, ensure_2d=True, copy=True, multi_output=True) + if y.ndim != 2: + y = y.reshape(-1, 1) + + if self._n_samples_ is not None and X.shape[0] != self._n_samples_: + raise RuntimeError( + f"X must have {self._n_samples_} samples, got {X.shape[0]}. " + f"If running on a new dataset, call the 'reset' method." + ) + if self.n_features_in_ is not None and X.shape[1] != self.n_features_in_: + raise RuntimeError( + f"X must have {self.n_features_in_} features, got {X.shape[1]}. " + f"If running on a new dataset, call the 'reset' method." + ) + if self._type_of_target_ is not None and type_of_target(y) != self._type_of_target_: + raise RuntimeError( + f"y must have type {self._type_of_target_}, got {type_of_target(y)}. " + f"If running on a new dataset, call the 'reset' method." + ) + + return X, y, covariate_index + def statistic( self, X: ArrayLike, @@ -151,9 +180,12 @@ def statistic( least one tree in the posterior computation. """ if check_input: - X, y = check_X_y(X, y, ensure_2d=True, multi_output=True) - if y.ndim != 2: - y = y.reshape(-1, 1) + X, y, covariate_index = self._check_input(X, y, covariate_index) + + if self._n_samples_ is None: + self._n_samples_, self.n_features_in_ = X.shape + if self._type_of_target_ is None: + self._type_of_target_ = type_of_target(y) if self.sample_dataset_per_tree and not self.permute_per_tree: raise ValueError("sample_dataset_per_tree is only valid when permute_per_tree=True") @@ -167,7 +199,7 @@ def statistic( # Infer type of target y if not hasattr(self, "_type_of_target"): - self._type_of_target = type_of_target(y) + self._type_of_target_ = type_of_target(y) # XXX: this can be improved as an extra fit can be avoided, by just doing error-checking # and then setting the internal meta data structures @@ -264,9 +296,7 @@ def test( pval : float The p-value of the test statistic. """ - X, y = check_X_y(X, y, ensure_2d=True, copy=True, multi_output=True) - if y.ndim != 2: - y = y.reshape(-1, 1) + X, y, covariate_index = self._check_input(X, y, covariate_index) if not hasattr(self, "samples_"): # first compute the test statistic on the un-permuted data @@ -411,6 +441,17 @@ class FeatureImportanceForestRegressor(BaseForestHT): null_dist_ : ArrayLike of shape (n_repeats,) The null distribution of the test statistic. + Notes + ----- + This class trains two forests: one on the original dataset, and one on the + permuted dataset. The forest from the original dataset is cached and re-used to + compute the test-statistic each time the :meth:`test` method is called. However, + the forest from the permuted dataset is re-trained each time the :meth:`test` is called + if the ``covariate_index`` differs from the previous run. + + To fully start from a new dataset, call the :meth:`reset` method, which will then + re-train both forests upon calling the :meth:`test` and :meth:`statistic` methods. + References ---------- .. footbibliography:: @@ -591,6 +632,17 @@ class FeatureImportanceForestClassifier(BaseForestHT): null_dist_ : ArrayLike of shape (n_repeats,) The null distribution of the test statistic. + Notes + ----- + This class trains two forests: one on the original dataset, and one on the + permuted dataset. The forest from the original dataset is cached and re-used to + compute the test-statistic each time the :meth:`test` method is called. However, + the forest from the permuted dataset is re-trained each time the :meth:`test` is called + if the ``covariate_index`` differs from the previous run. + + To fully start from a new dataset, call the :meth:`reset` method, which will then + re-train both forests upon calling the :meth:`test` and :meth:`statistic` methods. + References ---------- .. footbibliography:: @@ -630,7 +682,7 @@ def _statistic( X: ArrayLike, y: ArrayLike, covariate_index: ArrayLike = None, - metric="mse", + metric="mi", return_posteriors: bool = False, **metric_kwargs, ): @@ -696,6 +748,8 @@ def _statistic( ) X_train[:, covariate_index] = X_train[index_arr, covariate_index] + if self._type_of_target_ == "binary": + y_train = y_train.ravel() estimator.fit(X_train, y_train) if predict_posteriors: @@ -711,11 +765,11 @@ def _statistic( if metric == "auc": # at this point, posterior_final is the predicted posterior for only the positive class # as more than one output is not supported. - if self._type_of_target == "binary": + if self._type_of_target_ == "binary": posterior_final = posterior_final[:, 1] else: raise RuntimeError( - f"AUC metric is not supported for {self._type_of_target} targets." + f"AUC metric is not supported for {self._type_of_target_} targets." ) if np.isnan(posterior_final).any(): diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 62ffd0a09..00b42832a 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -317,3 +317,48 @@ def test_iris_pauc_statistic( score = clf.statistic(iris_X, iris_y, metric="auc", max_fpr=limit) assert score >= 0.8, "Failed with pAUC: {0} for max fpr: {1}".format(score, limit) + + +@pytest.mark.parametrize( + "forest_hyppo", + [ + FeatureImportanceForestRegressor( + estimator=RandomForestRegressor( + n_estimators=10, + ), + random_state=seed, + ), + FeatureImportanceForestClassifier( + estimator=RandomForestClassifier( + n_estimators=10, + ), + random_state=seed, + permute_per_tree=False, + sample_dataset_per_tree=False, + ), + ], +) +def test_forestht_check_inputs(forest_hyppo): + n_samples = 100 + n_features = 5 + X = rng.uniform(size=(n_samples, n_features)) + y = rng.integers(0, 2, size=n_samples) # Binary classification + + # Test case 1: Valid input + forest_hyppo.statistic(X, y) + + # Test case 2: Invalid input with different number of samples + X_invalid = np.random.rand(n_samples + 1, X.shape[1]) + y_invalid = rng.integers(0, 2, size=n_samples + 1) + with pytest.raises(RuntimeError, match="X must have"): + forest_hyppo.statistic(X_invalid, y_invalid) + + # Test case 3: Invalid input with different number of features + X_invalid = np.random.rand(X.shape[0], n_features + 1) + with pytest.raises(RuntimeError, match="X must have"): + forest_hyppo.statistic(X_invalid, y) + + # Test case 4: Invalid input with incorrect y type target + y_invalid = np.random.rand(X.shape[0]) + with pytest.raises(RuntimeError, match="y must have type"): + forest_hyppo.statistic(X, y_invalid) From dddacb11279b5944c8a1b563f89a18d014e3dbba Mon Sep 17 00:00:00 2001 From: Adam Li Date: Thu, 21 Sep 2023 12:21:12 -0400 Subject: [PATCH 42/70] Fix unit test Signed-off-by: Adam Li --- .../compare_coleman_and_permutation_forest.ipynb} | 0 sktree/stats/forestht.py | 14 +++++++++----- sktree/stats/tests/test_forestht.py | 5 +++++ 3 files changed, 14 insertions(+), 5 deletions(-) rename benchmarks_nonasv/{test_permutation_forest.ipynb => notebooks/compare_coleman_and_permutation_forest.ipynb} (100%) diff --git a/benchmarks_nonasv/test_permutation_forest.ipynb b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb similarity index 100% rename from benchmarks_nonasv/test_permutation_forest.ipynb rename to benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 1cf054bd2..e4e4a9801 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -61,6 +61,12 @@ def reset(self): if attr_name.endswith("_") and attr_name not in class_attributes: delattr(self, attr_name) + self.n_samples_test_ = None + self._n_samples_ = None + self._covariate_index_cache_ = None + self._type_of_target_ = None + self.n_features_in_ = None + def _get_estimators_indices(self): indices = np.arange(self._n_samples_, dtype=int) @@ -221,13 +227,11 @@ def statistic( estimator.fit(X[:2], y[:2]) # permute per tree - n_samples = X.shape[0] - self._n_samples_ = n_samples if self.sample_dataset_per_tree: - self.n_samples_test_ = n_samples + self.n_samples_test_ = self._n_samples_ else: # not permute per tree - test_size_ = int(self.test_size * n_samples) + test_size_ = int(self.test_size * self._n_samples_) # Fit each tree and compute posteriors with train test splits self.n_samples_test_ = test_size_ @@ -298,7 +302,7 @@ def test( """ X, y, covariate_index = self._check_input(X, y, covariate_index) - if not hasattr(self, "samples_"): + if self._n_samples_ is None: # first compute the test statistic on the un-permuted data observe_stat, observe_posteriors, observe_samples = self.statistic( X, diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 00b42832a..54b3f3e2c 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -315,6 +315,11 @@ def test_iris_pauc_statistic( print(pvalue) assert pvalue < 0.05, f"pvalue: {pvalue}" + # one must call `reset()` to make sure the test is run on a "new" feature set properly + with pytest.raises(RuntimeError, match="X must have 8 features"): + clf.statistic(iris_X, iris_y, metric="auc", max_fpr=limit) + + clf.reset() score = clf.statistic(iris_X, iris_y, metric="auc", max_fpr=limit) assert score >= 0.8, "Failed with pAUC: {0} for max fpr: {1}".format(score, limit) From 33c9a74020446cf7253a869ac88c14913b7ce2c2 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Thu, 21 Sep 2023 12:51:53 -0400 Subject: [PATCH 43/70] Try again Signed-off-by: Adam Li --- doc/conf.py | 1 + sktree/stats/forestht.py | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/doc/conf.py b/doc/conf.py index fbab7cddd..da50fd4bd 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -216,6 +216,7 @@ "Tree", "_type_", "MetadataRequest", + "sklearn.utils.metadata_routing.MetadataRequest", "~utils.metadata_routing.MetadataRequest", "quantiles", "n_quantiles", diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index e4e4a9801..fd12873d3 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -453,7 +453,7 @@ class FeatureImportanceForestRegressor(BaseForestHT): the forest from the permuted dataset is re-trained each time the :meth:`test` is called if the ``covariate_index`` differs from the previous run. - To fully start from a new dataset, call the :meth:`reset` method, which will then + To fully start from a new dataset, call the ``reset`` method, which will then re-train both forests upon calling the :meth:`test` and :meth:`statistic` methods. References @@ -644,7 +644,7 @@ class FeatureImportanceForestClassifier(BaseForestHT): the forest from the permuted dataset is re-trained each time the :meth:`test` is called if the ``covariate_index`` differs from the previous run. - To fully start from a new dataset, call the :meth:`reset` method, which will then + To fully start from a new dataset, call the ``reset`` method, which will then re-train both forests upon calling the :meth:`test` and :meth:`statistic` methods. References From 64f20175f79e449794f61757317866c4c2cb3e93 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Thu, 21 Sep 2023 13:17:03 -0400 Subject: [PATCH 44/70] Fix docs Signed-off-by: Adam Li --- doc/conf.py | 1 + 1 file changed, 1 insertion(+) diff --git a/doc/conf.py b/doc/conf.py index da50fd4bd..fa949235e 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -88,6 +88,7 @@ nitpick_ignore = [ ("py:mod", "sktree.tree"), ("py:mod", "sktree.stats"), + ("py:class", "sklearn.utils.metadata_routing.MetadataRequest"), ] # The name of a reST role (builtin or Sphinx extension) to use as the default From b8dc3a22ca3b6f9285101ee20dce231a04b2434d Mon Sep 17 00:00:00 2001 From: Adam Li Date: Thu, 28 Sep 2023 11:07:06 -0400 Subject: [PATCH 45/70] Fix pvalue sampling Signed-off-by: Adam Li --- sktree/stats/forestht.py | 204 ++++++++++++++++++---------- sktree/stats/tests/test_forestht.py | 4 +- sktree/stats/utils.py | 45 +++--- 3 files changed, 162 insertions(+), 91 deletions(-) diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index fd12873d3..750d913f9 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -1,3 +1,5 @@ +from typing import Callable, Dict + import numpy as np from numpy.typing import ArrayLike from sklearn.base import MetaEstimatorMixin, clone, is_classifier @@ -8,7 +10,6 @@ from sklearn.utils.validation import _is_fitted, check_X_y from sktree._lib.sklearn.ensemble._forest import ( - BaseForest, ForestClassifier, ForestRegressor, RandomForestClassifier, @@ -109,12 +110,12 @@ def train_test_samples_(self): def _statistic( self, - estimator: BaseForest, + estimator: ForestClassifier, X: ArrayLike, y: ArrayLike, - covariate_index: ArrayLike = None, - metric="mse", - return_posteriors: bool = False, + covariate_index: ArrayLike, + metric: str, + return_posteriors: bool, **metric_kwargs, ): raise NotImplementedError("Subclasses should implement this!") @@ -175,7 +176,8 @@ def statistic( ------- stat : float The test statistic. - posterior_final : ArrayLike of shape (n_samples_final, n_outputs), optional + posterior_final : ArrayLike of shape (n_estimators, n_samples_final, n_outputs) or + (n_estimators, n_samples_final), optional If ``return_posteriors`` is True, then the posterior probabilities of the samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` if all samples are encountered in the test set of at least one tree in the @@ -332,6 +334,7 @@ def test( # Note: at this point, both `estimator` and `permuted_estimator_` should # have been fitted already, so we can now compute on the null by resampling # the posteriors and computing the test statistic on the resampled posteriors + print(observe_posteriors.shape, permute_posteriors.shape) if self.sample_dataset_per_tree: metric_star, metric_star_pi = _compute_null_distribution_coleman( y_test=y[observe_samples, :], @@ -342,11 +345,11 @@ def test( seed=self.random_state, ) else: - if not self.sample_dataset_per_tree: - _, indices_test = self.train_test_samples_[0] - y_test = y[indices_test, :] - else: - y_test = y + # If not sampling a new dataset per tree, then we may either be + # permuting the covariate index per tree or per forest. If not permuting + # there is only one train and test split, so we can just use that + _, indices_test = self.train_test_samples_[0] + y_test = y[indices_test, :] metric_star, metric_star_pi = _compute_null_distribution_coleman( y_test=y_test, y_pred_proba_normal=observe_posteriors, @@ -439,7 +442,7 @@ class FeatureImportanceForestRegressor(BaseForestHT): y_true_final_ : ArrayLike of shape (n_samples_final,) The true labels of the samples used in the final test. - posterior_final_ : ArrayLike of shape (n_samples_final,) + posterior_final_ : ArrayLike of shape (n_estimators, n_samples_final) The predicted posterior probabilities of the samples used in the final test. null_dist_ : ArrayLike of shape (n_repeats,) @@ -490,16 +493,16 @@ def _get_estimator(self): def _statistic( self, - estimator: ForestRegressor, + estimator: ForestClassifier, X: ArrayLike, y: ArrayLike, - covariate_index: ArrayLike = None, - metric="mse", - return_posteriors: bool = False, + covariate_index: ArrayLike, + metric: str, + return_posteriors: bool, **metric_kwargs, ): """Helper function to compute the test statistic.""" - metric_func = METRIC_FUNCTIONS[metric] + metric_func: Callable[[ArrayLike, ArrayLike, Dict], float] = METRIC_FUNCTIONS[metric] rng = np.random.default_rng(self.random_state) if self.permute_per_tree: @@ -516,18 +519,17 @@ def _statistic( # Fill test set posteriors & set rest NaN posterior_arr[idx, indices_test, :] = y_pred # posterior - y_true_final = y[indices_test, :] - + # determine if there are any nans in the final posterior array # Average all posteriors (n_samples_test, n_outputs) - posterior_final = np.nanmean(posterior_arr, axis=0) + posterior_forest = np.nanmean(posterior_arr, axis=0) - # Find the row indices with NaN values in any column - nonnan_indices = np.where(~np.isnan(posterior_final).any(axis=1))[0] + # # Find the row indices with NaN values in any column + nonnan_indices = np.where(~np.isnan(posterior_forest).any(axis=1))[0] samples = nonnan_indices - # Ignore all NaN values (samples not tested) + # # Ignore all NaN values (samples not tested) y_true_final = y[nonnan_indices, :] - posterior_final = posterior_final[nonnan_indices, :] + posterior_arr = posterior_arr[:, (nonnan_indices), :] else: # fitting a forest will only get one unique train/test split indices_train, indices_test = self.train_test_samples_[0] @@ -547,24 +549,31 @@ def _statistic( X_train[:, covariate_index] = X_train[index_arr, covariate_index] estimator.fit(X_train, y_train) - y_pred = estimator.predict(X_test) + + # construct posterior array for all trees (n_trees, n_samples_test, n_outputs) + posterior_arr = np.full( + (len(estimator.estimators_), self.n_samples_test_, estimator.n_outputs_), np.nan + ) + for itree, tree in enumerate(estimator.estimators_): + posterior_arr[itree, ...] = tree.predict(X_test) # set variables to compute metric samples = indices_test y_true_final = y_test - posterior_final = y_pred - stat = metric_func(y_true_final, posterior_final, **metric_kwargs) + # Average all posteriors (n_samples_test, n_outputs) to compute the statistic + posterior_forest = np.nanmean(posterior_arr, axis=0) + stat = metric_func(y_true_final, posterior_forest, **metric_kwargs) if covariate_index is None: # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) # arrays of y and predicted posterior self.samples_ = samples self.y_true_final_ = y_true_final - self.posterior_final_ = posterior_final + self.posterior_final_ = posterior_arr self.stat_ = stat if return_posteriors: - return stat, posterior_final, samples + return stat, posterior_arr, samples return stat @@ -625,12 +634,13 @@ class FeatureImportanceForestClassifier(BaseForestHT): samples_ : ArrayLike of shape (n_samples_final,) The indices of the samples used in the final test set that would slice - the original ``(X, y)`` input. + the original ``(X, y)`` input along the rows. y_true_final_ : ArrayLike of shape (n_samples_final,) The true labels of the samples used in the final test. - posterior_final_ : ArrayLike of shape (n_samples_final,) + posterior_final_ : ArrayLike of shape (n_estimators, n_samples_final, n_outputs) or + (n_estimators, n_samples_final) The predicted posterior probabilities of the samples used in the final test. null_dist_ : ArrayLike of shape (n_repeats,) @@ -659,7 +669,7 @@ def __init__( verbose=0, test_size=0.2, permute_per_tree=True, - sample_dataset_per_tree=True, + sample_dataset_per_tree=False, ): super().__init__( estimator=estimator, @@ -685,13 +695,13 @@ def _statistic( estimator: ForestClassifier, X: ArrayLike, y: ArrayLike, - covariate_index: ArrayLike = None, - metric="mi", - return_posteriors: bool = False, + covariate_index: ArrayLike, + metric: str, + return_posteriors: bool, **metric_kwargs, ): """Helper function to compute the test statistic.""" - metric_func = METRIC_FUNCTIONS[metric] + metric_func: Callable[[ArrayLike, ArrayLike, Dict], float] = METRIC_FUNCTIONS[metric] rng = np.random.default_rng(self.random_state) if metric in POSTERIOR_FUNCTIONS: @@ -699,41 +709,30 @@ def _statistic( else: predict_posteriors = False + if predict_posteriors: + # now initialize posterior array as (n_trees, n_samples_test, n_classes) + posterior_arr = np.full( + (self.n_estimators, self._n_samples_, estimator.n_classes_), np.nan + ) + else: + # now initialize posterior array as (n_trees, n_samples_test, n_outputs) + posterior_arr = np.full( + (self.n_estimators, self._n_samples_, estimator.n_outputs_), np.nan + ) if self.permute_per_tree: - if predict_posteriors: - posterior_arr = np.full( - (self.n_estimators, self._n_samples_, estimator.n_classes_), np.nan - ) - else: - # now initialize posterior array as (n_trees, n_samples_test, n_outputs) - posterior_arr = np.full( - (self.n_estimators, self._n_samples_, estimator.n_outputs_), np.nan - ) - for idx, (indices_train, indices_test) in enumerate(self._get_estimators_indices()): tree: DecisionTreeClassifier = estimator.estimators_[idx] train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) if predict_posteriors: # XXX: currently assumes n_outputs_ == 1 - y_pred = tree.predict_proba(X[indices_test, :]) + y_pred = tree.predict_proba(X[indices_test, :]).reshape(-1, tree.n_classes_) else: y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) # Fill test set posteriors & set rest NaN # TODO: refactor so posterior_arr is just a large NaN array posterior_arr[idx, indices_test, :] = y_pred # posterior - - # Average all posteriors (n_samples_test, n_outputs) - posterior_final = np.nanmean(posterior_arr, axis=0) - - # Find the row indices with NaN values in any column - nonnan_indices = np.where(~np.isnan(posterior_final).any(axis=1))[0] - samples = nonnan_indices - - # Ignore all NaN values (samples not tested) - y_true_final = y[nonnan_indices, :] - posterior_final = posterior_final[nonnan_indices, :] else: # fitting a forest will only get one unique train/test split indices_train, indices_test = self.train_test_samples_[0] @@ -756,39 +755,104 @@ def _statistic( y_train = y_train.ravel() estimator.fit(X_train, y_train) - if predict_posteriors: - # XXX: currently assumes n_outputs_ == 1 - y_pred = estimator.predict_proba(X_test) - else: - y_pred = estimator.predict(X_test) + # construct posterior array for all trees (n_trees, n_samples_test, n_outputs) + for itree, tree in enumerate(estimator.estimators_): + if predict_posteriors: + # XXX: currently assumes n_outputs_ == 1 + posterior_arr[itree, indices_test, ...] = tree.predict_proba(X_test).reshape( + -1, tree.n_classes_ + ) + else: + posterior_arr[itree, indices_test, ...] = tree.predict(X_test).reshape( + -1, tree.n_outputs_ + ) # set variables to compute metric samples = indices_test y_true_final = y_test - posterior_final = y_pred if metric == "auc": # at this point, posterior_final is the predicted posterior for only the positive class # as more than one output is not supported. if self._type_of_target_ == "binary": - posterior_final = posterior_final[:, 1] + posterior_arr = posterior_arr[..., (1,)] else: raise RuntimeError( f"AUC metric is not supported for {self._type_of_target_} targets." ) - if np.isnan(posterior_final).any(): - raise RuntimeError("NaN values encountered in posterior_final.") + # determine if there are any nans in the final posterior array + # Average all posteriors (n_samples_test, n_outputs) + posterior_forest = np.nanmean(posterior_arr, axis=0) + + # # Find the row indices with NaN values in any column + nonnan_indices = np.where(~np.isnan(posterior_forest).any(axis=1))[0] + samples = nonnan_indices + + # Ignore all NaN values (samples not tested) + y_true_final = y[(nonnan_indices), :] + posterior_arr = posterior_arr[:, (nonnan_indices), :] + + # Average all posteriors (n_samples_test, n_outputs) to compute the statistic + posterior_forest = np.nanmean(posterior_arr, axis=0) + stat = metric_func(y_true_final, posterior_forest, **metric_kwargs) - stat = metric_func(y_true_final, posterior_final, **metric_kwargs) if covariate_index is None: # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) # arrays of y and predicted posterior self.samples_ = samples self.y_true_final_ = y_true_final - self.posterior_final_ = posterior_final + self.posterior_final_ = posterior_arr self.stat_ = stat if return_posteriors: - return stat, posterior_final, samples + return stat, posterior_arr, samples return stat + + def statistic( + self, + X: ArrayLike, + y: ArrayLike, + covariate_index: ArrayLike = None, + metric="mi", + return_posteriors: bool = False, + check_input: bool = True, + **metric_kwargs, + ): + """Compute the test statistic. + + Parameters + ---------- + X : ArrayLike of shape (n_samples, n_features) + The data matrix. + y : ArrayLike of shape (n_samples, n_outputs) + The target matrix. + covariate_index : ArrayLike, optional of shape (n_covariates,) + The index array of covariates to shuffle, by default None. + metric : str, optional + The metric to compute, by default "mi", which computes Mutual Information. + return_posteriors : bool, optional + Whether or not to return the posteriors, by default False. + check_input : bool, optional + Whether or not to check the input, by default True. + **metric_kwargs : dict, optional + Additional keyword arguments to pass to the metric function. + + Returns + ------- + stat : float + The test statistic. + posterior_final : ArrayLike of shape (n_estimators, n_samples_final, n_outputs) or + (n_estimators, n_samples_final), optional + If ``return_posteriors`` is True, then the posterior probabilities of the + samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` + if all samples are encountered in the test set of at least one tree in the + posterior computation. + samples : ArrayLike of shape (n_samples_final,), optional + The indices of the samples used in the final test. ``n_samples_final`` is + equal to ``n_samples`` if all samples are encountered in the test set of at + least one tree in the posterior computation. + """ + return super().statistic( + X, y, covariate_index, metric, return_posteriors, check_input, **metric_kwargs + ) diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 54b3f3e2c..ba4050591 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -35,7 +35,7 @@ def test_featureimportance_forest_permute_pertree(): n_estimators=10, ), permute_per_tree=True, - sample_dataset_per_tree=True, + sample_dataset_per_tree=False, ) est.statistic(iris_X[:10], iris_y[:10]) @@ -323,6 +323,8 @@ def test_iris_pauc_statistic( score = clf.statistic(iris_X, iris_y, metric="auc", max_fpr=limit) assert score >= 0.8, "Failed with pAUC: {0} for max fpr: {1}".format(score, limit) + assert isinstance(clf.estimator_, HonestForestClassifier) + @pytest.mark.parametrize( "forest_hyppo", diff --git a/sktree/stats/utils.py b/sktree/stats/utils.py index 9d06dc8fd..766fd30d9 100644 --- a/sktree/stats/utils.py +++ b/sktree/stats/utils.py @@ -169,14 +169,16 @@ def _compute_null_distribution_coleman( Parameters ---------- - X_test : ArrayLike of shape (n_samples, n_features) - The data matrix. y_test : ArrayLike of shape (n_samples, n_outputs) The output matrix. - y_pred_proba_normal : ArrayLike of shape (n_samples_normal, n_outputs) - The predicted posteriors from the normal forest. - y_pred_proba_perm : ArrayLike of shape (n_samples_perm, n_outputs) - The predicted posteriors from the permuted forest. + y_pred_proba_normal : ArrayLike of shape (n_estimators, n_samples_normal, n_outputs) + The predicted posteriors from the normal forest. Some of the trees + may have nans predicted in them, which means the tree used these samples + for training and not for prediction. + y_pred_proba_perm : ArrayLike of shape (n_estimators, n_samples_perm, n_outputs) + The predicted posteriors from the permuted forest. Some of the trees + may have nans predicted in them, which means the tree used these samples + for training and not for prediction. normal_samples : ArrayLike of shape (n_samples_normal,) The indices of the normal samples that we have a posterior for. perm_samples : ArrayLike of shape (n_samples_perm,) @@ -199,10 +201,16 @@ def _compute_null_distribution_coleman( metric_func = METRIC_FUNCTIONS[metric] # sample two sets of equal number of trees from the combined forest these are the posteriors + # (n_estimators * 2, n_samples, n_outputs) all_y_pred = np.concatenate((y_pred_proba_normal, y_pred_proba_perm), axis=0) + print(y_pred_proba_normal.shape) + n_estimators, _, _ = y_pred_proba_normal.shape n_samples_test = len(y_test) - if len(all_y_pred) != 2 * n_samples_test: + if all_y_pred.shape[1] != n_samples_test: + print(all_y_pred.shape) + print(n_samples_test) + print(y_test.shape) print("y_pred_proba_perm: ", y_pred_proba_perm.shape) print("y_pred_proba: ", y_pred_proba_normal.shape) @@ -212,12 +220,13 @@ def _compute_null_distribution_coleman( ) # create two stacked index arrays of y_test resulting in [1, ..., N, 1, ..., N] - y_test_ind_arr = np.hstack( - (np.arange(n_samples_test, dtype=int), np.arange(n_samples_test, dtype=int)) - ) + # where N is `n_estimators` + # y_test_ind_arr = np.hstack( + # (np.arange(n_estimators, dtype=int), np.arange(n_estimators, dtype=int)) + # ) # create index array of [1, ..., 2N] to slice into `all_y_pred` - y_pred_ind_arr = np.arange((2 * n_samples_test), dtype=int) + y_pred_ind_arr = np.arange((2 * n_estimators), dtype=int) metric_star = np.zeros((n_repeats,)) metric_star_pi = np.zeros((n_repeats,)) @@ -228,17 +237,13 @@ def _compute_null_distribution_coleman( first_forest_inds = y_pred_ind_arr[:n_samples_test] second_forest_inds = y_pred_ind_arr[:n_samples_test] - # index into y_test for first half and second half - first_half_index_test = y_test_ind_arr[first_forest_inds] - second_half_index_test = y_test_ind_arr[second_forest_inds] - - # now get the pointers to the actual samples used for the metric - y_test_first_half = y_test[first_half_index_test] - y_test_second_half = y_test[second_half_index_test] + # get random half of the posteriors + y_pred_first_half = np.nanmean(all_y_pred[first_forest_inds], axis=0) + y_pred_second_half = np.nanmean(all_y_pred[second_forest_inds], axis=0) # compute two instances of the metric from the sampled trees - first_half_metric = metric_func(y_test_first_half, all_y_pred[first_forest_inds]) - second_half_metric = metric_func(y_test_second_half, all_y_pred[second_forest_inds]) + first_half_metric = metric_func(y_test, y_pred_first_half) + second_half_metric = metric_func(y_test, y_pred_second_half) metric_star[idx] = first_half_metric metric_star_pi[idx] = second_half_metric From 028f17d65f62d6dddcd3b99f073f44a72877b743 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Thu, 28 Sep 2023 14:50:23 -0400 Subject: [PATCH 46/70] Fixed pvalue issue Signed-off-by: Adam Li --- ...mpare_coleman_and_permutation_forest.ipynb | 772 +++++++++++++----- sktree/stats/forestht.py | 34 +- sktree/stats/tests/test_forestht.py | 28 +- sktree/stats/utils.py | 24 +- 4 files changed, 614 insertions(+), 244 deletions(-) diff --git a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb index e2dc525b7..7c2febb11 100644 --- a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb +++ b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb @@ -239,7 +239,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "id": "14806903-933b-4e31-a2db-a3a45e0a6f82", "metadata": { "scrolled": true @@ -249,186 +249,546 @@ "name": "stdout", "output_type": "stream", "text": [ - "X1: 1.0\n", - "X6: 0.001996007984031936\n", - "X2/7: 1.0\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 0.001996007984031936\n", - "X2/7: 0.001996007984031936\n", - "X1: 1.0\n", - "X6: 1.0\n", - "X2/7: 1.0\n", - "X2/7: 1.0\n", - "X1: 1.0\n", - "X6: 1.0\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X1: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X1: 1.0\n", - "X6: 0.001996007984031936\n", - "X2/7: 1.0\n", - "X2/7: 1.0\n", - "X1: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X1: 1.0\n", - "X6: 1.0\n", - "X2/7: 1.0\n", - "X2/7: 1.0\n", - "X1: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 0.001996007984031936\n", - "X1: 1.0\n", - "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X2/7: 1.0\n", - "X1: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", - "X2/7: 1.0\n", - "X2/7: 1.0\n", - "X1: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", - "X2/7: 1.0\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X1: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X2/7: 1.0\n", - "X1: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", - "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X1: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X6: 0.001996007984031936\n", + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", "X2/7: 1.0\n", - "X2/7: 1.0\n" + "(125, 2200, 1) (125, 2200, 1)\n", + "(125, 2200, 1)\n", + "X2/7: 0.001996007984031936\n" ] } ], @@ -452,13 +812,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "id": "9e60fac2-3b20-493e-886a-892d572a28c6", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA5sAAAJQCAYAAAAAM3DTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3xTVf8H8M/NbtKmg24oUErZm8pGUEAEhQdBQUQZDlDBxeNCEQRlKIrycyGo6IMgCIgDFFAE2bIVAdkb2tLS3TTz/P4oCQ1N27RN2rT9vF+vvpSbc2++ubn35H7vOfccSQghQERERERERORBssoOgIiIiIiIiKofJptERERERETkcUw2iYiIiIiIyOOYbBIREREREZHHMdkkIiIiIiIij2OySURERERERB7HZJOIiIiIiIg8jskmEREREREReRyTTSIiIiIiIvI4jyebZ8+ehSRJ+PLLLz29aSIn5TnWNm/eDEmSsHnzZo/HBQA9e/ZEz5493S7bokULr8RBRFVXdnY2wsPDsWTJksoOpcrydl1Pvm/06NGoX79+ZYfhFRV1zc1re7r//vsxdOjQMq1bqmTzyy+/hCRJ2Lt3b5nerKp58cUXIUkShg0b5vJ1+8knSRJWrVpV6PXXX38dkiQhJSWl0GubN2/G4MGDERkZCZVKhfDwcAwYMADfffddobKpqal44YUX0LhxY2g0GoSEhKBv375Ys2aNU7mBAwdCq9UiKyuryM80YsQIqFQqpKamOpalp6dDo9FAkiQcPXq0yHWp7C5fvozXX38dBw8e9Pi269ev7zgOb/7Ly8vz+PsBwMyZM/H99997Zdvusp9/77zzTqXGUR4///wzXn/99coOo0xuPtb0ej169OiBtWvXVnZo1ca8efMQEBCA+++/37HM/rti/9NqtWjWrBkmT56MzMzMSoy27Hbs2IHXX38d6enpZd7Gxx9/zAthF3yhrqaazRPntydVtbrCm9ePpfHSSy9h1apV+Ouvv0q9rsdbNuvVqweDwYCHHnrI05uuUEIIfPPNN6hfvz5++umnYhM4AJg+fTqEEG5te+rUqbjtttvwzz//YNy4cZg/fz5eeOEFZGdnY8iQIVi6dKmj7LFjx9C6dWv83//9H2677TZ8+OGHeOWVV5CcnIwBAwbghRdecJQdMWIEDAYDVq9e7fJ9c3Nz8cMPP+DOO+9ErVq1HMtXrFgBSZIQGRnJO+gesmHDBmzYsMHx78uXL2PatGleqyzatGmDxYsXF/pTqVReeT9ewHjGzz//jGnTplV2GGXWp08fLF68GP/73//w4osv4uTJkxgwYADWr19f2aFVeWazGfPmzcOjjz4KuVxe6PVPPvkEixcvxty5c9GkSRPMmDEDd955p9u/Q75kx44dmDZtmleSzVtvvRUGgwG33npr2QOswlhXU2XzxPntSVUx2fTm9aO72rZti4SEBLz77rulXlfh6WAkSYJGo/H0Zj0qNzcXWq222DKbN2/GxYsX8fvvv6Nv37747rvvMGrUKJdl27Rpg4MHD2L16tUYPHhwsdtduXIlpk+fjnvvvRdLly6FUql0vPbCCy9g/fr1MJvNAPIvNu69916kpaVhy5Yt6Nixo6Psc889hxEjRuCdd95BQkIChg0bhoEDByIgIABLly7FyJEjC733Dz/8gJycHIwYMcJp+ddff43+/fujXr16WLp0Kd58881iPwOVzFtJXlFq166NBx98sELf09NsNhtMJpPP1x+ekJOTA51OV9lhlFujRo2cjrshQ4agWbNmmDdvHvr27VuhsVS1fWqxWGCz2YqsK9asWYOrV68W2W3p3nvvRWhoKADg8ccfx5AhQ/Ddd99h165d6Ny5c5njEkIgLy8Pfn5+Zd6GL5HJZNW6TinpOCqNqnYOEVUXnjz33Mlxymro0KGYOnUqPv74Y/j7+7u/oiiFRYsWCQBiz549RZY5c+aMACAWLVrkWDZq1Cih0+nExYsXxX/+8x+h0+lEaGio+O9//yssFovT+larVbz33nuiWbNmQq1Wi/DwcDF27Fhx7do1p3Lff/+96N+/v4iKihIqlUo0aNBATJ8+vdD2evToIZo3by727t0runfvLvz8/MQzzzxT4md95JFHRLNmzYQQQvTr10/06dOnyM86e/Zs0ahRI9G6dWths9kcr0+dOlUAEFevXnUsa9KkiQgJCRGZmZklxvDNN98IAGL69OkuX09PTxdBQUGiSZMmjmWjRo0SCoVCJCUlFSp/9913i4CAAJGbm+tYdu7cOSFJkvj222/Fn3/+KQCI7du3lxhbwc937NgxMWLECKHX60VoaKiYPHmysNls4vz582LgwIEiICBAREREiHfeeafQNpKSksTDDz8swsPDhVqtFq1atRJffvlloXJpaWli1KhRQq/Xi8DAQDFy5Ehx4MCBQseaEEIcPXpUDBkyRAQHBwu1Wi3at28vfvjhB6cymzZtEgDEpk2bivx8f/31lwDgtO7evXsFANG2bVunsnfeeafo0KGD4989evQQPXr0cHqvm//scduP0cOHD4uePXsKPz8/ER0dLd56660iYyuoXr164q677iq2TFpamnjmmWdEnTp1hEqlEnFxcWL27NnCarU6lZszZ47o3LmzCAkJERqNRrRr106sWLHCqYyrzzJq1CghRP7xV69evULvbz9Wbt7O+PHjxddffy2aNWsmFAqFWL16tRBCiIsXL4oxY8aI8PBwoVKpRLNmzcTnn3/utL79/JszZ45jmb2O2rp1q3jqqadEaGioCAwMFGPHjhVGo1GkpaWJhx56SAQFBYmgoCDxwgsvOJ2zBbc5d+5cUbduXaHRaMStt94qDh06VOhzbdy4UXTr1k1otVoRGBgoBg4cKI4cOeLysx8+fFgMHz5cBAUFiTZt2ohRo0a53Jel+S4K7sfVq1eL5s2bO/bXL7/8UqjsxYsXxcMPP+yoN+vXry8ef/xxYTQaHWXcPVbs73uz0NBQ0ahRI6dleXl5YsqUKSIuLk6oVCpRp04d8cILL4i8vDyncrm5ueKpp54StWrVEv7+/mLAgAHi4sWLAoCYOnVqifvUbvHixaJdu3ZCo9GI4OBgMWzYMHH+/Hmn9zp+/LgYPHiwiIiIEGq1WtSuXVsMGzZMpKenO8ps2LBBdO3aVQQGBgqdTicaNWokJk2a5LQdd+qwgsfVe++9Jxo0aCBkMpk4cOBAof1nN3LkSFG/fv1Cy139rgghxIcffigAiCVLlggh3P8ttdcf69atE+3btxdqtVq89957jnpr+fLl4vXXXxfR0dHC399fDBkyRKSnp4u8vDzxzDPPiLCwMKHT6cTo0aOdvk9X1wJ2Bb9P++e5+e/MmTNCCCG++OILcdttt4mwsDChUqlE06ZNxccff1zoM9y8/s317811/bfffus4RmrVqiVGjBghLl686FSmNNcurtj37fr160Xr1q2FWq0WTZs2FatWrSpU1p3zrrTHUXF1tSfOISGE2LVrl+jbt6/Q6/XCz89P3HrrrWLbtm0l7huj0Shee+010a5dO6HX64VWqxXdunUTv//+u1O5gp/5008/FQ0aNBAqlUokJCSI3bt3F9quvR5Uq9WiefPm4rvvvivyd+lme/bsEXfccYeoVauW0Gg0on79+mLMmDFOZUpbL3/77beiadOmQqPRiE6dOom///5bCCHE/PnzRVxcnFCr1aJHjx6O492u4LVr586dHfF88sknLvdPWa6DiuLu9dZff/0lRo0aJWJjY4VarRYRERFizJgxIiUlxVHGE+e3EO59N+7UecXVFa6U9prAnf1uv07ZvHmzeOKJJ0RYWJgICgpy+f7uXj+6ynHc/d0Vwv3z3X5d/N133xW5z1zxeMtmUaxWK/r27YuOHTvinXfewW+//YZ3330XcXFxeOKJJxzlxo0bhy+//BJjxozB008/jTNnzuDDDz/EgQMHsH37dkdL4Jdffgl/f39MnDgR/v7++P333zFlyhRkZmZizpw5Tu+dmpqKfv364f7778eDDz6IiIiIYmM1Go1YtWoV/vvf/wIAhg8fjjFjxiAxMRGRkZGFysvlckyePBkjR44stnXzxIkT+Pfff/Hwww8jICCgxH32008/AYDLVkoACAwMxH/+8x989dVXOHnyJBo2bIgRI0bgq6++wrfffosJEyY4yl67dg3r16/H8OHDne5Yf/PNN9DpdLj77rvh5+eHuLg4LFmyBF26dCkxPrthw4ahadOmmD17NtauXYs333wTISEh+PTTT3H77bfjrbfewpIlS/D888/jlltucXRnMhgM6NmzJ06ePIkJEyYgNjYWK1aswOjRo5Geno5nnnkGQP6d9v/85z/Ytm0bHn/8cTRt2hSrV6922dJ8+PBhdO3aFbVr18bLL78MnU6Hb7/9FoMGDcKqVatwzz33uP25WrRogaCgIGzZsgUDBw4EAGzduhUymQx//fUXMjMzodfrYbPZsGPHDowdO9bldpo2bYrp06djypQpGDt2LLp37w4ATvs4LS0Nd955JwYPHoyhQ4di5cqVeOmll9CyZUv069evxFjNZnOhZ4O1Wi20Wi1yc3PRo0cPXLp0CePGjUPdunWxY8cOTJo0CVeuXMH777/vWGfevHkYOHAgRowYAZPJhGXLluG+++7DmjVrcNdddwEAFi9ejEcffRQdOnRwfOa4uDi392tBv//+u+NYDQ0NRf369ZGUlIROnTpBkiRMmDABYWFh+OWXX/DII48gMzMTzz77bInbfeqppxAZGYlp06Zh165dWLBgAYKCgrBjxw7UrVsXM2fOxM8//4w5c+agRYsWhc6x//3vf8jKysL48eORl5eHefPm4fbbb8ehQ4cc9cdvv/2Gfv36oUGDBnj99ddhMBjwwQcfoGvXrti/f3+hASnuu+8+xMfHY+bMmRBCoG3btrh8+TJ+/fVXLF68uNBncOe7sNu2bRu+++47PPnkkwgICMD//d//YciQITh//ryjy/zly5fRoUMHpKenY+zYsWjSpAkuXbqElStXIjc3FyqVqlTHiisZGRlIS0tzOh5sNhsGDhyIbdu2YezYsWjatCkOHTqE9957D8ePH3fq4jd69Gh8++23eOihh9CpUyf88ccfhT5rcfsUAGbMmIHXXnsNQ4cOxaOPPoqrV6/igw8+wK233ooDBw4gKCgIJpMJffv2hdFodBwrly5dwpo1a5Ceno7AwEAcPnwYd999N1q1aoXp06dDrVbj5MmT2L59u+P93a3D7BYtWoS8vDyMHTsWarUaISEhRX62HTt2oF27dsXu74JOnToFAI7v293fUiD/cY3hw4dj3LhxeOyxx9C4cWPHa7NmzYKfnx9efvllnDx5Eh988AGUSiVkMhnS0tLw+uuvY9euXfjyyy8RGxuLKVOmuB0zAAwePBjHjx/HN998g/fee8/RWhsWFgYgv7tw8+bNMXDgQCgUCvz000948sknYbPZMH78eADA+++/j6eeegr+/v549dVXAaDY33n7frnlllswa9YsJCUlYd68edi+fbvjGLFz99qlKCdOnMCwYcPw+OOPY9SoUVi0aBHuu+8+rFu3Dn369AGAUp937h5H7tTVZT2HgPz6u1+/fmjfvj2mTp0KmUyGRYsW4fbbb8fWrVvRoUOHIvdLZmYmPvvsMwwfPhyPPfYYsrKy8Pnnn6Nv377YvXs32rRp41R+6dKlyMrKwrhx4yBJEt5++20MHjwYp0+fdhzLGzZscPSumDVrFlJTUzFmzBjUqVOnxO8pOTkZd9xxB8LCwvDyyy8jKCgIZ8+eLTSORmnq5a1bt+LHH390HKezZs3C3XffjRdffBEff/wxnnzySaSlpeHtt9/Gww8/jN9//91p/bS0NPTv3x9Dhw7F8OHD8e233+KJJ56ASqXCww8/XORnKc91UGmut3799VecPn0aY8aMQWRkJA4fPowFCxbg8OHD2LVrFyRJ8sj57e53406dV9q6ws6da4LS7vcnn3wSYWFhmDJlCnJycly+rzvXj65ynNL87rp7vgNAs2bN4Ofnh+3bt5fqerrCWjbhooWubdu2on379o5/b9261enOrN26desKLS/YOmc3btw4odVqnbL2Hj16CABi/vz5bn/OlStXCgDixIkTQgghMjMzhUajEe+9957LzzpnzhxhsVhEfHy8U+vmzXegf/jhBwGg0HaK0qZNGxEYGFhsmblz5woA4scffxRCCGGxWERUVJTo3LmzU7n58+cLAGL9+vVOy1u2bClGjBjh+Pcrr7wiQkNDhdlsLjE+++cbO3asY5nFYhF16tQRkiSJ2bNnO5anpaUJPz8/x11VIYR4//33BQDx9ddfO5aZTCbRuXNn4e/v72j9/f777wUA8fbbbzu9T/fu3Qsda7169RItW7Z0OgZsNpvo0qWLiI+Pdyxzp2VTCCHuuusupxbLwYMHi8GDBwu5XO5oOdq/f3+hFtCCLZtC5N+VuznWgmUBiP/973+OZUajUURGRoohQ4YUG58Qru/UoUDLwRtvvCF0Op04fvy403ovv/yykMvlTnevbj6vTCaTaNGihbj99tudlut0Oqfv0q60LZsymUwcPnzYafkjjzwioqKinO6OCiHE/fffLwIDAx0xFtey2bdvX6cWy86dOwtJksTjjz/uWGY/Vgt+T/Zt+vn5ObVy2Fv9n3vuOceyNm3aiPDwcJGamupY9tdffwmZTCZGjhxZ6LMPHz680H4ZP358of1i5+53AUCoVCpx8uRJpzgAiA8++MCxbOTIkUImk7msv+37qjTHCgDxyCOPiKtXr4rk5GSxd+9eceeddxb6ThYvXixkMpnYunWr0zbtdZK9J8W+ffsEAPHss886lRs9enSRLZs379OzZ88KuVwuZsyY4bT80KFDQqFQOJbb79K7apGwe++991y2IBbkbh1mP670er1ITk4ucnt2ZrNZSJIk/vvf/xZ6rWCPkqtXr4ozZ86ITz/91NGykJOTU6rfUnv9sW7dOqey9jqyRYsWwmQyOZYPHz5cSJIk+vXr51S+c+fOTue+uy2bQuS3FqFAa0dBrn7r+/btKxo0aOC0rHnz5i5bKG6u600mkwgPDxctWrQQBoPBUW7NmjUCgJgyZYpjmbvXLkWx79uCLZkZGRkiKirKqXeMu+ddaY8jIYquq8t7DtlsNhEfH1+ors3NzRWxsbEue4MVZLFYnHpUCJF/nRARESEefvhhxzL7Z65Vq5ZTC5X9euqnn35yLGvTpo2Iiooq1DsBQIktm6tXry7x+tb++Qoqrl5Wq9VOx/Snn34qAIjIyEin3m2TJk0qdPzbrwveffddxzKj0ej43bGfk67OM3evg1wpzfWWq3PT3iNvy5YtjmXlPb/d+W5KU+cVVVe4UpprAnf3u/06pVu3bm71kHDn+vHmHMfd3113z/eCGjVqVKj+L0mFzrP5+OOPO/27e/fuOH36tOPfK1asQGBgIPr06YOUlBTHX/v27eHv749NmzY5yhZsncvKykJKSgq6d++O3Nxc/Pvvv07vo1arMWbMGLfjXLJkCRISEtCwYUMAQEBAAO66665iB8+xt27+9ddfRT6Mbx8p0J1WTSD/c5VU1v66fdtyuRz3338/du7cibNnzzrKLV26FBEREejVq5dj2d9//41Dhw5h+PDhjmXDhw9HSkpKqQb4ePTRRx3/L5fLkZCQACEEHnnkEcfyoKAgNG7c2On7/vnnnxEZGen0/kqlEk8//TSys7Pxxx9/OMopFAqnu8hyuRxPPfWUUxzXrl3D77//jqFDhzqOiZSUFKSmpqJv3744ceIELl265PbnAvKP0f379zvuOm3btg39+/dHmzZtsHXrVgD5dy8lSUK3bt1Kte2C/P39nZ59U6lU6NChg9P+Kk7Hjh3x66+/Ov3ZW+tWrFiB7t27Izg42Om86t27N6xWK7Zs2eLYTsHzKi0tDRkZGY594A09evRAs2bNHP8WQmDVqlUYMGAAhBBO8fbt2xcZGRluxfLII49AkiTHvzt27FjomLQfq6728aBBg1C7dm3Hvzt06ICOHTvi559/BgBcuXIFBw8exOjRo51aFVq1aoU+ffo4yhV0c/1XktJ8F71793ZqsWjVqhX0er3js9lsNnz//fcYMGAAEhISCq1v31elOVYA4PPPP0dYWBjCw8ORkJCAjRs34sUXX8TEiRMdZVasWIGmTZuiSZMmTtu8/fbbAcBRr69btw5A/t3egm4+zwu6eZ9+9913sNlsGDp0qNN7RUZGIj4+3vFegYGBAID169cjNzfX5bbtd3N/+OEH2Gw2l2XcrcPshgwZ4rijX5xr165BCIHg4OAiyzRu3BhhYWGIjY3FuHHj0LBhQ6xduxZarbZUv6UAEBsbW+QztiNHjnRqBbWfSze3rHTs2BEXLlyAxWIp8fOVRsHzICMjAykpKejRowdOnz6NjIyMUm9v7969SE5OxpNPPun0LOddd92FJk2auBxNuaRrl+JER0c7tQDo9XqMHDkSBw4cQGJiIoDSn3fuHkfuKOs5dPDgQZw4cQIPPPAAUlNTHeVycnLQq1cvbNmypcjzBsivf+3PmdpsNly7dg0WiwUJCQku67hhw4Y5nQ/2Fh7792Cvk0eNGuU4v4H8QcwK/sYUxX6+r1mzxjFuhiulqZd79erl1MPFPu7GkCFDnK7t7MtvPqYUCgXGjRvn+LdKpcK4ceOQnJyMffv2uYyvvNdB7l5v3bwv8vLykJKSgk6dOgGA29cM7pzf7nw3pa3zSquka4Ky7PfHHnvM5eBvpeUqx3H3d9fd870gez1VGhXWjVaj0RSqHIODg5GWlub494kTJ5CRkYHw8HCX20hOTnb8/+HDhzF58mT8/vvvhYZ7v/kHqHbt2m4/PJ+eno6ff/4ZEyZMwMmTJx3Lu3btilWrVuH48eNo1KiRy3VHjBiBN954A9OnT8egQYMKva7X6wGgxJFt7QICAkr8Qu3bKlhxjRgxAu+99x6WLl2KV155BRcvXsTWrVvx9NNPOx3YX3/9NXQ6HRo0aOD4rBqNBvXr18eSJUuK7b5WUN26dZ3+HRgYCI1G4+guUXB5wSlXzp07h/j4eMhkzvc8mjZt6njd/t+oqKhCDyMX7OoFACdPnoQQAq+99hpee+01l7EmJyc7VRgl6d69OywWC3bu3ImYmBgkJyeje/fuOHz4sFOy2axZs2K7xJWkTp06TskRkH9+/P33326tHxoait69e7t87cSJE/j777+LvDgpeF6tWbMGb775Jg4ePAij0ehYfnNsnhIbG+v076tXryI9PR0LFizAggULSoy3KK6OSQCIiYkptLxgHWQXHx9faFmjRo3w7bffArhxbN58DAL5x+/69esLPfB/82ctSWm+i5s/L+Bcv169ehWZmZklzudammMFAP7zn/9gwoQJMJlM2LNnD2bOnInc3Fync/rEiRM4evRoids8d+4cZDJZof1kv+nnys1lT5w4ASGEy+8PgCNpio2NxcSJEzF37lwsWbIE3bt3x8CBA/Hggw86jpVhw4bhs88+w6OPPoqXX34ZvXr1wuDBg3Hvvfc6Pp+7dVhR8ZZEFDOy7KpVq6DX66FUKlGnTh2nmw2l+S0tKa7SnEs2mw0ZGRlOo52X1/bt2zF16lTs3Lmz0I2BjIwMp8TCHcWdu02aNMG2bduclrlz7VKchg0bFjpn7dcQZ8+eRWRkZKnPu9IeR8Up6zl04sQJAChy4EQg//sp7obJV199hXfffRf//vuvUxLh6vPdfBzat2v/Huzfq6u4GzduXGLy06NHDwwZMgTTpk3De++9h549e2LQoEF44IEHoFarHeXKUy8Xd+4U/Cx20dHRhQaNKXjs2BO7gsp7HeTu9RaQn2BNmzYNy5YtK3SMunsjyJ3z253vprR1XmmVdE1Qlv3uqfPYVY7j7u+uu+d7QUKIUl8TVliy6U72brPZip3A2r7T0tPT0aNHD+j1ekyfPh1xcXHQaDTYv38/XnrppUJ300ozqt6KFStgNBrx7rvvuhzed8mSJUVOVWBv3Rw9ejR++OGHQq83adIEAHDo0CG3YmnatCkOHjyI8+fPu7yYBOBIRgreuWvfvj2aNGmCb775Bq+88gq++eYbCCGcRqEV16d2ycnJcXnXLzk5GdnZ2W6NNuXquy3q+y7u4qm87N/7888/X+Rd+uIuXF1JSEiARqPBli1bULduXYSHh6NRo0bo3r07Pv74YxiNRmzdurV0fddd8Ob+stls6NOnD1588UWXr9t/vLZu3YqBAwfi1ltvxccff4yoqCgolUosWrTIaTqe4hRVAVmtVpfLbz437d/hgw8+WORFTKtWrUqMo6j96Wq5N4/JgkpTD5X2u/DU8ePusWJXp04dx02O/v37IzQ0FBMmTMBtt93meHbdZrOhZcuWmDt3rstt3nzhVRqujh9JkvDLL7+43CcF67N3333XUVdv2LABTz/9NGbNmoVdu3ahTp068PPzw5YtW7Bp0yasXbsW69atw/Lly3H77bdjw4YNZboj7e4xEBISAkmSik1obr311kI39Ozc/S11J67SnEvAjWOutHWBK6dOnUKvXr3QpEkTzJ07FzExMVCpVPj555/x3nvvFdty5imeaHkoSWnPO0+OFFzWc8i+7+fMmVPo+cqby7ry9ddfY/To0Rg0aBBeeOEFhIeHQy6XY9asWY7njwvy9jWFJElYuXIldu3ahZ9++gnr16/Hww8/jHfffRe7du2Cv7+/x+plb//eA569DirK0KFDsWPHDrzwwgto06YN/P39YbPZcOedd7p1brp7frvz3ZS2zvO0sux3T53Hrrbj7u9uaX4z7dLS0opMTotSYcmmO+Li4vDbb7+ha9euxX4JmzdvRmpqKr777junubPOnDlT7hiWLFmCFi1aYOrUqYVe+/TTT7F06dJi58V78MEH8eabb2LatGmOQWXsGjVqhMaNG+OHH37AvHnzSkzk7r77bnzzzTf43//+h8mTJxd6PTMzEz/88AOaNGlS6CAeMWIEXnvtNfz9999YunQp4uPjccsttzhe/+OPP3Dx4kVMnz7dcRfeLi0tDWPHjsX333/v1ek06tWrh7///hs2m82pZcDeDbpevXqO/27cuLFQ8nvs2DGn7TVo0ABA/p2Yolr5SsvenXXr1q2oW7euo+tO9+7dYTQasWTJEiQlJZU4h5u3WgbdERcXh+zs7BL3yapVq6DRaLB+/XqnO7mLFi0qVLaozxMcHOxyLq2bW3iKEhYWhoCAAFitVo99h2Vhv2tf0PHjxx1douzH5s3HIJB//IaGhro1jHlR+7E034U7wsLCoNfr8c8//xRbzt1jpSjjxo3De++9h8mTJ+Oee+6BJEmIi4vDX3/9hV69ehV7HtSrVw82mw1nzpxx+iEr2MOkJHFxcRBCIDY2tsgeKAW1bNkSLVu2xOTJk7Fjxw507doV8+fPd0z/JJPJ0KtXL/Tq1Qtz587FzJkz8eqrr2LTpk3o3bu323VYaSkUCsTFxZX5N83d31Jvsrc83VwfuKoLijoufvrpJxiNRvz4449ON1xdde1yt44teO7au5TZHTt2rMzfWVHsLR4F4zt+/DgAOOqT8p53xSntb4+755C9JV2v15cp7pUrV6JBgwb47rvvnGJ0de3lDvv35qrudlVPF6VTp07o1KkTZsyYgaVLl2LEiBFYtmwZHn30UY/XyyW5fPlyoR4yNx87NyvvdZC711tpaWnYuHEjpk2b5jQomKv974nzGyj+uylNnVeW67GSrgm8cf1pV5Z43f3dLe1vpsViwYULFwrlNyWp0Gc2SzJ06FBYrVa88cYbhV6zWCyOHy179l3wLpDJZMLHH39crve/cOECtmzZgqFDh+Lee+8t9DdmzBicPHkSf/75Z5HbsLduHjx4ED/++GOh16dNm4bU1FQ8+uijLp9t2bBhA9asWQMgfx61Zs2aYfbs2di7d69TOZvNhieeeAJpaWkuK2d7K+aUKVNw8OBBl3Nr6nQ6vPDCC4U+52OPPYb4+Phin1H1hP79+yMxMRHLly93LLNYLPjggw/g7++PHj16OMpZLBZ88sknjnJWqxUffPCB0/bCw8PRs2dPfPrpp7hy5Uqh97t69WqZ4uzevTv+/PNPbNq0yZFshoaGomnTpnjrrbccZYpj/7GojEmNhw4dip07d7p8Djc9Pd1xHMrlckiS5NTycPbsWZfPIOt0OpefJS4uDhkZGU7df69cuYLVq1e7FatcLseQIUOwatUql4lRWb/D0vr++++dnq/YvXs3/vzzT8fIwFFRUWjTpg2++uorp/3wzz//YMOGDejfv79b71PUcVGa78IdMpkMgwYNwk8//VSoLgFu1KXuHitFUSgU+O9//4ujR486encMHToUly5dwsKFCwuVNxgMjueh7XeDb67Hbz7PizN48GDI5XJMmzatUCuBEMLRjT8zM7PQZ2nZsiVkMpmja9y1a9cKbd/egmMv424dVhadO3d2+V25w93fUm/S6/UIDQ0t9Lyhq9/p4s4DwPm3PiMjw+XFfVF10s0SEhIQHh6O+fPnO3WD/OWXX3D06FG3Hx9x1+XLl53qv8zMTPzvf/9DmzZtHKPbl/e8K467+8XO3XOoffv2iIuLwzvvvIPs7OxC2ymprnb13f7555/YuXOn27EWVLBOLtiF89dff8WRI0dKXD8tLa3Q5735fPd0vVwSi8WCTz/91PFvk8mETz/9FGFhYWjfvr3Ldcp7HeTu9Zar7w+AyxHLy3t+u/PdlKbOK+05AZR8TeCt6097vEDprh/d/d1193y3O3LkCPLy8ko1YwVQxpbNL774wjGYQ0E3D/NeWj169MC4ceMwa9YsHDx4EHfccQeUSiVOnDiBFStWYN68ebj33nvRpUsXBAcHY9SoUXj66achSRIWL15c7i4IS5cuhRCiyIy9f//+UCgUWLJkieOBblfsz24ePHiw0GvDhg3DoUOHMGPGDBw4cADDhw9HvXr1kJqainXr1mHjxo2O7hgqlQorV65Er1690K1bN4wZMwYJCQlIT0/H0qVLsX//fvz3v//F/fffX+h9YmNj0aVLF8cFX8Fk0z61S58+fYqc7HrgwIGYN28ekpOTi+wDX15jx47Fp59+itGjR2Pfvn2oX78+Vq5cie3bt+P99993PIc6YMAAdO3aFS+//DLOnj2LZs2a4bvvvnP5TMBHH32Ebt26oWXLlnjsscfQoEEDJCUlYefOnbh48SL++uuvUsfZvXt3zJgxAxcuXHBKKm+99VZ8+umnqF+/folDq8fFxSEoKAjz589HQEAAdDodOnbs6NFnb4rywgsv4Mcff8Tdd9+N0aNHo3379sjJycGhQ4ewcuVKnD17FqGhobjrrrswd+5c3HnnnXjggQeQnJyMjz76CA0bNiz07Gj79u3x22+/Ye7cuYiOjkZsbCw6duyI+++/Hy+99BLuuecePP3008jNzcUnn3yCRo0auT1gwOzZs7Fp0yZ07NgRjz32GJo1a4Zr165h//79+O2331wmAZ7WsGFDdOvWDU888QSMRiPef/991KpVy6mb25w5c9CvXz907twZjzzyiGPqk8DAQLz++utuvY/9guHpp59G3759HQN8lea7cNfMmTOxYcMG9OjRwzEU+pUrV7BixQps27YNQUFBbh8rxRk9ejSmTJmCt956C4MGDcJDDz2Eb7/9Fo8//jg2bdqErl27wmq14t9//8W3336L9evXIyEhAe3bt8eQIUPw/vvvIzU11TH1if1Ovjt3d+Pi4vDmm29i0qRJOHv2LAYNGoSAgACcOXMGq1evxtixY/H888/j999/x4QJE3DfffehUaNGsFgsWLx4seNmBwBMnz4dW7ZswV133YV69eohOTkZH3/8MerUqeMYDMzdOqws/vOf/2Dx4sXFjhNQFHd/S73t0UcfxezZs/Hoo48iISEBW7ZscXyfBdnPg1dffRX3338/lEolBgwYgDvuuAMqlQoDBgzAuHHjkJ2djYULFyI8PLzQBV379u3xySef4M0330TDhg0RHh5eqOUSyG95eOuttzBmzBj06NEDw4cPd0x9Ur9+fTz33HMe3QeNGjXCI488gj179iAiIgJffPEFkpKSnC6oPXHeFaWouroo7p5DMpkMn332Gfr164fmzZtjzJgxqF27Ni5duoRNmzZBr9c7pm9z5e6778Z3332He+65B3fddRfOnDmD+fPno1mzZi6TV3fMmjULd911F7p164aHH34Y165dwwcffIDmzZuXuM2vvvoKH3/8Me655x7ExcUhKysLCxcuhF6vd9w89Ea9XJzo6Gi89dZbOHv2LBo1aoTly5fj4MGDWLBggctn6ezKcx3k7vWWXq/Hrbfeirfffhtmsxm1a9fGhg0bXPbGKO/57c53U5o6z926oiB3rgm8cf0JlO360d3fXXfPd7tff/0VWq3WMW2T20ozdK19uN6i/i5cuFDk1Cc6na7Q9lxNhyCEEAsWLBDt27cXfn5+IiAgQLRs2VK8+OKL4vLly44y27dvF506dRJ+fn4iOjpavPjii2L9+vVOQ5wLcWPCU3e0bNlS1K1bt9gyPXv2FOHh4cJsNrucesGu4L5yNXT+xo0bxX/+8x8RHh4uFAqFCAsLEwMGDHA56W5ycrKYOHGiaNiwoVCr1SIoKEj07t3bMd1JUT766CMBwGnqDiGEWLVqlQAgPv/88yLX3bx5swAg5s2bV2SZoiYXL+r7dvVdJCUliTFjxojQ0FChUqlEy5YtXQ7vnJqaKh566CHHJMMPPfSQy0mGhRDi1KlTYuTIkSIyMlIolUpRu3Ztcffdd4uVK1c6yrg79YkQ+VPfyOVyERAQ4DRM9ddffy0AiIceesjlZ715aO0ffvhBNGvWTCgUCqe4izpG3Z2I2j5xeHGysrLEpEmTRMOGDYVKpRKhoaGiS5cu4p133nGa1uDzzz8X8fHxQq1WiyZNmohFixa5PE///fdfceuttwo/Pz8BwGlo/Q0bNogWLVoIlUolGjduLL7++usipz4ZP368y3iTkpLE+PHjRUxMjFAqlSIyMlL06tVLLFiwwFGmuKlPbh4i3d1jteA23333XRETEyPUarXo3r27+OuvvwrF+dtvv4muXbsKPz8/odfrxYABA8SRI0fcem8h8oeUf+qpp0RYWJiQJMlpH7n7XRS1H+vVq1doyoNz586JkSNHirCwMKFWq0WDBg3E+PHjnaYgcPdYKe77e/31153OL5PJJN566y3HZOvBwcGiffv2Ytq0aSIjI8OxXk5Ojhg/frwICQkR/v7+YtCgQeLYsWMCgNNUSsXtUyHy67hu3boJnU4ndDqdaNKkiRg/frw4duyYEEKI06dPi4cffljExcUJjUYjQkJCxG233SZ+++03xzbsdXR0dLRQqVQiOjpaDB8+vND0FO7UYcX9VhTFaDSK0NBQ8cYbbzgtL+mzF+TOb2lR9Ye9jrx5epjSnGO5ubnikUceEYGBgSIgIEAMHTpUJCcnC9w09YkQ+dN/1K5dW8hkMqdpEn788UfRqlUrx0Tub731lvjiiy8KTaWQmJgo7rrrLhEQECCAGxO1F1XXL1++XLRt21ao1WoREhIiRowY4TS1gRClv3a5mX3frl+/XrRq1cpxLruacsed864sx1FRdXV5zyG7AwcOiMGDB4tatWoJtVot6tWrJ4YOHSo2btxYbFw2m03MnDlT1KtXT6jVatG2bVuxZs2aQr97xX1mV8fRqlWrRNOmTYVarRbNmjUT3333nVu/pfv37xfDhw8XdevWFWq1WoSHh4u7775b7N2716lceerloj6Lq3PNfl2wd+9e0blzZ6HRaES9evXEhx9+6HKbZbkOKoq711sXL14U99xzjwgKChKBgYHivvvuE5cvX/b4+e3udyOEe3VeUXWFK6W9JnBnv7szjeTNSnv9KIT7v7tCuH++d+zYUTz44INux20nCVFBo2MQEfm4s2fPIjY2FnPmzHG6m0eV5+DBg2jbti2+/vrrQo8DVHdvvPEGFi1ahBMnTlTIQDXkWfXr10eLFi0cj8YQuatnz55ISUkp8Tl78i5eE9xw8OBBtGvXDvv37y9yULCi+NQzm0REVHMZDIZCy95//33IZLISB+Gqjp577jlkZ2dj2bJllR0KERHVYLNnz8a9995b6kQT8LHRaImIqOZ6++23sW/fPtx2221QKBT45Zdf8Msvv2Ds2LHlmiKlqvL39y/3/HBERETlVZ6bnkw2iYjIJ3Tp0gW//vor3njjDWRnZ6Nu3bp4/fXX8eqrr1Z2aERERFQGfGaTiIiIiIiIPI7PbBIREREREZHHMdkkIiIiIiIij2OySURERERERB7HZJOIiIiIiIg8jskmEREREREReRyTTSIiIiIiIvI4JptERERERETkcUw2iYiIiIiIyOOYbBIREREREZHHMdkkIiIiIiIij2OySURERERERB7HZJOIiIiIiIg8jskmEREREREReRyTTSIiIiIiIvI4JptERERERETkcUw2iYiIiIiIyOOYbBIREREREZHHMdkkIiIiIiIij2OySUQ+5cEHH4RGo8Hx48cLvTZ79mxIkoQ1a9YAAJYvX44HH3wQ8fHxkCQJPXv2rOBoiYioIHfr8NTUVMyZMwe33norwsLCEBQUhE6dOmH58uWVEDUReYskhBCVHQQRkV1ycjKaNGmCNm3a4Pfff3csP3PmDJo3b47+/ftj5cqVAICePXti3759uOWWW3Dw4EG0atUKmzdvrqTIiYjI3Tp8zZo1GDx4MPr374/bbrsNCoUCq1atwqZNmzBlyhRMmzatEj8FEXkKk00i8jkLFy7E2LFj8eWXX2LUqFEAgH79+mHHjh04cuQIateuDQC4cOECateuDZlMhhYtWiA0NJTJJhFRJXOnDj9z5gxkMhnq1avnWE8Igd69e2P79u1ITU2FTqerrI9ARB7CbrRE5HMeffRRdO3aFc8//zxSU1OxbNkyrFu3Dm+++aYj0QSAmJgYyGSsxoiIfIk7dXhsbKxTogkAkiRh0KBBMBqNOH36dGWETkQepqjsAIiIbiZJEj799FO0bdsWTzzxBLZu3YqEhASMHz++skMjIqISlKcOT0xMBACEhoZ6O0wiqgBMNonIJzVv3hzPP/88Zs2aBblcjrVr17IVk4ioiihLHX7t2jV89tln6N69O6KioiooUiLyJl65EZHPst/Zjo6ORosWLSo5GiIiKo3S1OE2mw0jRoxAeno6Pvjgg4oIj4gqAJNNIvJJFy5cwNSpU9GiRQtcuHABb7/9dmWHREREbiptHf7UU09h3bp1+Oyzz9C6desKipKIvI3JJhH5pAkTJgAAfvnlF9x3332YMWMGB4wgIqoiSlOHT5s2DR9//DFmz56Nhx56qCLDJCIvY7JJRD5n9erV+PHHH/HGG2+gTp06eP/996FSqThAEBFRFVCaOvyjjz7C66+/jmeffRYvvfRSJURLRN7EeTaJyKdkZWWhWbNmCAsLw549eyCXywEA//d//4dnnnkG3377Le67775C63GeTSKiyleaOnz58uV44IEHMHz4cCxevBiSJFVm6ETkBUw2icinPPPMM/jwww+xa9cu3HLLLY7lVqsVHTp0QGJiIv79918EBARgy5Yt2LJlCwDggw8+gFarxSOPPAIAuPXWW3HrrbdWymcgIqqp3K3Djx49iu7duyMwMBBvvfUWlEql03a6dOmCBg0aVHT4RORhTDaJyGfs27cPHTt2xBNPPOFyNMI9e/agU6dOmDBhAubNm4fXX38d06ZNc7mtqVOn4vXXX/dyxEREZFeaOrxt27YYM2ZMkdtatGgRRo8e7cVoiagiMNkkIiIiIiIij+MAQURERERERORxTDaJiIiIiIjI45hsEhERERERkccx2SQiIiIiIiKPY7JJREREREREHqeo7ACo8thsNly+fBkBAQGcSJmIyMuEEMjKykJ0dDRksvLf62UdTkRUsTxdj9cETDZrsMuXLyMmJqaywyAiqlEuXLiAOnXqlHs7rMOJiCqHp+rxmoDJZg0WEBAAIP+E0ev1lRwNEVH1lpmZiZiYGEfdW16sw4mIKpan6/GagMlmDWbvdqXX63mhQkRUQTzV5ZV1OBFR5eCjC+5jZ2MiIiIiIiLyOCabRERERERE5HFMNomIiIiIiMjj+MwmVTsGkwVymQxZeWYEaJSw2GzQqnznUPf1+KhmsNlsMJlMlR1GtaNSqTgcvgf4cj3py7EBjK+8fDk+X44NYHzkGvewj9iyZQvmzJmDffv24cqVK1i9ejUGDRpU7DqbN2/GxIkTcfjwYcTExGDy5MkYPXp0hcTrq4xmK+b/cRqLdpxBpsECvZ8CY7rE4smecVAr5ZUdns/HRzWDyWTCmTNnYLPZKjuUakcmkyE2NhYqlaqyQ6myfLme9OXYGF/1js+XY2N8VBwmmz4iJycHrVu3xsMPP4zBgweXWP7MmTO466678Pjjj2PJkiXYuHEjHn30UURFRaFv374VELHvMZgsmP/HaczbeMKxLNNgcfx7XI8GlXoHy9fjo5pBCIErV65ALpcjJiaGrXAeZLPZcPnyZVy5cgV169blaIVl4Mv1pC/HBjC+8vLl+Hw5NoDxUfG4Z31Ev3790K9fP7fLz58/H7GxsXj33XcBAE2bNsW2bdvw3nvvFZlsGo1GGI1Gx78zMzPLFzQAs9V3WkbkMhkW7Tjj8rVFO85gXI8G6DJ7I9JyzRUcGRCsVeK3iT2KjW/8bQ19an/KJAlyGS+WqxuLxYLc3FxER0dDq9VWdjjVTlhYGC5fvgyLxQKlUunRbXujDrfaBGxClHs7nuKr9bg7dbiv/8YwvqL5cny+HBtQPeIbf1vDCo6qZmGyWUXt3LkTvXv3dlrWt29fPPvss0WuM2vWLEybNs1jMWTkmnE0MRMWH0iQtCo56gRrkWmwuHw902DBtRwTAtRKXE7Pq+DogLrBWqRmm4qNL8NgwoVrucg1WSs4Otf8VHK0qhMEpZwtX9WJ1Zp/fLGbp3fY96vVavV4sunpOtxqEzh4IQ0GH6lzfLked6cO9/XfGMZXNF+Oz5djA6pHfFl5ZtTyV1dwZDUHk80qKjExEREREU7LIiIikJmZCYPBAD8/v0LrTJo0CRMnTnT8OzMzEzExMWWOwWKzIT3XjGCtZy+oykIIIFCrhN5P4bJC0fspEBagxltDWsJiq/i7+AqZhHC9utj49H5KCAGfSO6sNoF0gxkGs9Un4iHPYxdP7/DmfvV0HW61CeSarLDZAI2y8s9zIYBAP9+sx92pw339N4bxVc34fDm26hJfgKbyr2OrMyabNYharYZa7dk7N5IEn+nnfiIpG6M618cHv58s9NqYLrGw2gTa1A2uhMjyGUwWjOkS6/TMgN2YLrHIyDVDpZDDV9qbsjLMMJis0LMSJvIJ3qjDgfxE0xfq8X+vZCLdYPbZerykOtzXf2MYX/F8OT5fjg2o+vFZbDaoOBuk11T+rwuVSWRkJJKSkpyWJSUlQa/Xu2zVrO5W7L2A7adS8e24TpAk4MsdZ31utDE/lQJP9owDAKfR0EZ1ro+xtzbApTRDpcZ3MwkSco2uu50QEXnS4csZmPbTEUQH+WHlE50hk4BFPlaPF1WH+0JsjK96x+fLsTE+KokkhA+NDEAA8rthlTT1yUsvvYSff/4Zhw4dcix74IEHcO3aNaxbt86t98nMzERgYCAyMjKg1+tLHWdqthF7z6UhOrByk9tle85jyZ/nAQDP9IrHAx3rIkirRHaexSfnUco1WaC4Ps+TVqXAlhNXse1ECoYmlL07nDekZhsRqFWibSXejSTPy8vLw5kzZxAbGwuNRlPZ4XjM2bNnERsbiwMHDqBNmzZurfPll1/i2WefRXp6usfiKG7/lrfOvVl5t2ey2PDnmVSo5JXbsnnoUgamrzmMPLMNreoEYsagFgjSqhCh1/jkfHgF63Bfiw1gfOXly/H5cmxAzYjP0/V4TeA7R0ANl52djZMnb3QbOnPmDA4ePIiQkBDUrVsXkyZNwqVLl/C///0PAPD444/jww8/xIsvvoiHH34Yv//+O7799lusXbu2sj5ChRNCYOnu81i25wIAYGSneujdNAInkrKhUcrQJiYICrnM57pG2Cu2Wv5q/HLoCp5Ysh8yCejWMBTRQb7TKq1RypFjtMBksUGl8K19SETVw18X0zF9zRGYLDa0iQnCq/2bwmwVOJaUBb1G4Ri0w5fq8YJ1OOBbsQGMr7x8OT5fjg1gfOQa97KP2Lt3L9q2bYu2bdsCACZOnIi2bdtiypQpAIArV67g/PnzjvKxsbFYu3Ytfv31V7Ru3RrvvvsuPvvssxozx6YQAot3nXMkmmO61Md911sGc4wWBGtVUFSBgW3a1QtGi9p62ASw/Ppn8RVqhQx5FhsMZt8YqZKIqpcD59Mw/af8RLNd3WC8dlczaJRyZBst0GsU8Ofz4kREVZ7vX43XED179oQQotDfl19+CSC/u9fmzZsLrXPgwAEYjUacOnUKo0ePrvC4K4MQAl/uOIsV+y4CAB7pFovB7eoAACxWG+QyCcE6Xxlmp3g6tQKD29YGAGw+nowLabmVHNENCrkMVqvNZ6ZFIC/LySn6Ly/P/bIGg3tly2DdunXo1q0bgoKCUKtWLdx99904deqUy7KbN2+GJElYu3YtWrVqBY1Gg06dOuGff/4pVHb9+vVo2rQp/P39ceedd+LKlSuO1/bs2YM+ffogNDQUgYGB6NGjB/bv31+m+OmGfefS8MbaIzBZbbilfjAm39XU0YMi12RFeICa8/wSEVUDTDapShFC4PNtZ/DdgUsAgHG3NsCgNrUdr2cbLfDXKBDoVzXuiGuVcjSLDkS7ukGwCWDZbt9q3ZTJJORwkKCawd+/6L8hQ5zLhocXXbZfP+ey9eu7LlcGOTk5mDhxIvbu3YuNGzdCJpPhnnvugc1W9Fy/L7zwAt59913s2bMHYWFhGDBgAMzmGxOL5+bm4p133sHixYuxZcsWnD9/Hs8//7zj9aysLIwaNQrbtm3Drl27EB8fj/79+yMrK6tMn4GA3Weu4c21R2C2CnSMDcGkfk0dUyyZrTYo5BKCtZzzjoioOuAzm1RlCCGwYOtprPk7v9XhyZ5x6NciyqlMrtmCRsEBVeaOuEwmIdRfhbtaRWH/+XRsPXEVQxPqoF4tXWWHBgBQyeVIN5gqOwwiAMCQm5LeL774AmFhYThy5Aj8i0hgp06dij59+gAAvvrqK9SpUwerV6/G0KFDAQBmsxnz589HXFz+SIUTJkzA9OnTHevffvvtTttbsGABgoKC8Mcff+Duu+/22GerKXadTsVb6/6FxSbQJa4WXrijsdMjD9l5FgT6KRGg4eUJEVF1wJZNqhJsQuCTP05hzd9XIAGYcFvDQomm2WqDXJIhSFs1utDa6TVK1A7SoktcLQgA3/jQs5sapQy5JiuMFnalrfays4v+W7XKuWxyctFlf/nFuezZs67LlcGJEycwfPhwNGjQAHq9HvXr1wcAp+fZb9a5c2fH/4eEhKBx48Y4evSoY5lWq3UkmgAQFRWF5ORkx7+TkpLw2GOPIT4+HoGBgdDr9cjOzi72Pcm17SdTMPt6otk9PrRQognk3zAMD1BDVkVuGBIRUfF465B8nk0IfLTpJDYcSYIE4Ole8ejdNKJQOXsXWn0V6UJrp1MroFHIMKRdHew8lYrtJ1NwJiUbsaFl62roSWqFHFl5FuSZbFArOA9VtaYrRWu6t8qWYMCAAahXrx4WLlyI6Oho2Gw2tGjRAiZT2VvflUrn+kKSJBScEWzUqFFITU3FvHnzUK9ePajVanTu3Llc71kTbT1xFe9sOAabAHo0CsNzvRsV6oFistigVFS9G4ZERFQ0tmyST7PaBP5v4wlsOJIEmQQ816eRy0QTAAwmKyL1VW9QCa1KDq1ajrAANbrHhwIAlu72jVYTuUyCVQjkmvncJlWu1NRUHDt2DJMnT0avXr3QtGlTpKWllbjerl27HP+flpaG48ePo2nTpm6/7/bt2/H000+jf//+aN68OdRqNVJSUsr0GWqqzceSHYnm7Y3DXSaaQP4Nw0CNEgFq3gcnIqouWKOTz7LaBOZtPI5Nx65CJgET+zRGj0ZhLsuarTbI5VKVvCMuSRJq6dQ4dTUb93eoi20nU7Dr9DWcTM5Gw/DKb92UgYMEUeULDg5GrVq1sGDBAkRFReH8+fN4+eWXS1xv+vTpqFWrFiIiIvDqq68iNDQUgwYNcvt94+PjsXjxYiQkJCAzMxMvvPAC/Px8Zz5cX/f7v0mYt/EEbALo0zQC429rWOQNQYPZggZhOnahJSKqRtiyST7JahOY++uNRPOFvk2KTDSB/EEl9BoF9FV0XrYAPwUEgDpBfrj1+udcuvtc5QZ1nVohQ3quueSCRF4kk8mwbNky7Nu3Dy1atMBzzz2HOXPmlLje7Nmz8cwzz6B9+/ZITEzETz/9BJXK/ZtSn3/+OdLS0tCuXTs89NBDePrppxEeHl6ej1Jj/HokEe//lp9o9m0eiQm3F51oGi1WqBQyBGqrZh1ORESusWWTfI7FasM7vx7H9pMpkMskvNi3MbrEhRa7Tq7Zinqh2ip7R9xfrYBaIYPRYsPwW+piy/Gr2HM2DccSs9A4MqBSY1NfHyQoz2yFRsnnNqny9O7dG0eOHHFaVvD5yoL/b9etWzeXc2sCwOjRowvNTzxo0CCn7bRt2xZ79uxxKnPvvfeWNvQaZ90/ifho80kAQP+WURh3awPIpKLrZ8cotOxCS0RUrbBlk3yK2WrD2+uPYfvJFChkEib1a1Jiomm22qBUSAjyq3pdaO38lHLo1AoYTFZEB/nh9ib5LSe+0LqpVshhstiQZ+aItERUsrWHrjgSzYGto/F4CYkmAORZrQgP0EAqoRwREVUtTDbJZ5itNry17l/sPJ0KpVzCq/2bomNsrRLXy8qzQK+p2vOy5T+3qYLh+hQjwxLqQi6TsP98Oo5cyazU2OQyCVabQK6JySYRFe/Hvy5j/h+nAACD2tTGo91iS0wg88xWqOUyBLELLRFRtcNkk3yCyWLDzJ+P4s8z16CSyzC5fzMk1A9xa12D2YJIvabKdqG1C9AoASEghEBkoAa9r7duLvmz8ls3ZTIOEkRVS8+ePSGEQFBQUGWHUmN8f+ASFm49DQAY0q4OHu5a362WyhyjBUFaFfzZhZaIqNphskmVzmixYsbPR7D3XBpUChleu7sZ2tULdmtdk8UGlUJW5ebWdMVfrYBGKUee2QYAGHpLDBQyCX9fzMChi+mVGptaIUO6wezymTgiopX7LuLz7WcAAMMSYjCqcz23u8QaLTaEBajZhZaIqBpiskmVKs9sxZtrj2L/+XSoFTK8fncztIkJcnv9rDxzfhfaanBHXKOU5T+3ef3ZyPAADe5oHgkAWLL7fKUmemqFDLkmC4wWW6XFQJ7FGwfeURP36/K9F/DVzrMAgAc61MWDndxPNPPMVqgVMgRWgxuGRERUWNW/QqcqK89sxfQ1R3DoUgY0ShleH9AczaMDS7cNqxVxev8q34UWuPHcZmp2tmPZfe3r4NcjiTh8ORN/X8xA61Ik4p6kVsiRabDAYOKItFWdUqmEJEm4evUqwsLC2JrkQUIIXL16FZIkQams/smTEALL9lzA0t3nAQAPdqqHYQkxpdpGttGCIK2SXWiJiKop1u5UKXJNFkxfcwSHL2fCTynHtIHN0TRKX6ptGC35g0pUp3nZ/DVKSFL+RZwkSQj1V+PO5pH46e8r+PrPc2hVJ7BSkgO5TIINArlmK9zr4Ey+Si6Xo06dOrh48SLOnj1b2eFUO5IkoU6dOpDLq/dNGSEElvx5Hsv3XgAAjOpcH/e2r1Pq7ZisNoTrOQotEVF1xWSTKlyuyYLXfzyMo4lZ0KrkmD6wRZnmkszOs0BfzeZl81croFbKYDBboVXlf6772sdg/ZEk/JuYhf3n09HezedZPU0mScjOMwPwq5T3J8/x9/dHfHw8zGZzZYdS7SiVyhqRaH618xxW7b8IAHikaywGta1d6u2wCy0RUfVXfa7SqUrINuYnmseSsqBTy/HGwBaIjyh9ogkAeRYr4gL8q9UdcT+VHAEaBTJzLY5kM1inQv8WUfj+4CUs+fMc2tUNqpTPrFHIkJ5rdrS6UtUml8urfVJEnieEwBfbz+L7g5cAAI91b4CBraPLtK2sPAtq+augU/E4JCKqrjhAEFWY7DwLXvvhHxxLykKAWoE3/9Oy7Inm9Tvi1XFethCtCkar85yWQ9rVhkYpw4nkbOw5e61S4lIr5MgzWx2j5RJRzSKEwGfbzjgSzcd7xJU50QQAk9XKUWiJiKo5JptUITINZrz6wyGcTM6GXqPAjHtaoGG4f5m3V53nZfPXKCFBgq3AqJZBWhXubpl/Ubfkz8oZmVatlMFosTlGyyWimsMmBOZvOY0f/7oMABjfsyHuahlV5u0ZTFb4KeXsQktEVM0x2SSvyzCY8er3h3D6ag4C/ZSYeU9LxIaWPdEEgLxqPC/bjfk2nZO6e9rWhp9SjtMpOdh1OrXC45JJEgQEk02iGsYmBD7efAo/H7oCCcDTtzfEnS0iy7XNLKMZQVoVdNXwhiEREd3AZJO8Kj3XhFdXH8LZ1FwEafMTzXq1dOXaZp7ZCo1ChiCtykNR+haNMv+5TYPJOanT+ykdXdaW7j7v1PJZUeSSDJkGDipDVFPYhMCHv5/E+sOJkAA82zsefZqVL9EUQsBitSFcr/ZMkERE5LOYbJLXpOWY8MrqQzh3LRchOhVm3dMSdUO05d6ufV626jyoRC2dGnmWwi2Ig9rUhk4lx9nUXGw/mVLhcWmUcmQYzDVy4nqimsZqE5j32wn8ejQJMgmY2KcRbm8SUe7tGsxWaFTsQktEVBMw2SSvSM02YtLqQ7iQZkCof36iWSe4/IkmkD8vW1g1n5dNp5bnz215U1Lnr1HgP23ypxj4Zvd5WG0Vm/SpFTIYOUgQUbVntQm899tx/H4sGTIJeP6OxujZONwj287OsyBEp3KMuE1ERNUXk03yuJTriealdAPCAtSYdU8rRAd5Zm5Gg+n6KLTV/I64rojnNgFgYOto+KsVuJBmwNYTVys0LpUif5CgXJOlQt+XiCqOxWrDu78ewx/Hr0Iuk/Bi3yboHh/mkW0LIWARNoT5azyyPSIi8m1MNsmjkjPzMOm7Q7iSkYfwADVm3dMSkYGeu6jINloQXAMGldAo5dBrlMg1FU42dWoF7rk+gfqyPRcqtHUzf5AgcJAgomrKYrVhzoZj2HoiBQqZhJfvbIKuDUM9tn2D2Qo/pYJdaImIaggmm+QxiZl5mLT6EBIz8xAVqMGswS0RofdcoimEgPn6vGw1QYhOBaPFdXfVu1tFIUCjwKV0AzYfS67QuBSShMw8DhJEVN2YrTa8tf5f7DiVCoVMwqR+TdGpQS2PvkfW9S60ftX4mXsiIrqBySaVmYT8aTrkMglXMgyY9N0hJGcZER2owcx7WiI8wLPdpAxmKzRKOYK0NeOOuE6tgFySXLZcalUK3NuuDoD81k2LteKeoVQr5cg0WGCr4OdFicjztCo5FDIJZqsNs345il2nr0Epl/DqXU3RITbEo+8lhIDFJmrMDUMiImKySWVkMFngr1EiPtwfceE6KOUyBPopUSfYDzPvaYlQf89fTGQbLQiuQYNK6NRy+KlkLp/bBID+LaMQ5KdEYmYefq/A1k21Ij8mV6PlElHVYLj+3HVMsBYt6gTCaLHiWo4ZKrkMk+9qhoR6nk00ASDXZIVOzVFoiYhqEiabPuSjjz5C/fr1odFo0LFjR+zevbvY8u+//z4aN24MPz8/xMTE4LnnnkNeXp7X4zSarZj/x2kkzPgVHWZuxC0zfsP+82lY+XhnvDe0DWp5IdHMvyNuq1F3xNUKOQI0yiKfj9Qo5RjSPr91c/meCzBXUOum2jFIEJNNoqrIVR2+41Qqvn28E965rxXa1Q32yvtmGy2opVNBo2QXWiKimoLJpo9Yvnw5Jk6ciKlTp2L//v1o3bo1+vbti+Rk1y1WS5cuxcsvv4ypU6fi6NGj+Pzzz7F8+XK88sorXo3TYLLg482nMG/jCWQa8u+MZxos+OD3k/hyx1nUq+WZ6U0Kve/1LrQ17Y54iE4FUzFJZL8WkQjRqpCcZcRvR5MqJCZJkgCRPzIwEVUtxdXhX+046/FnNO1sQsAqhFd6vRARke9isukj5s6di8ceewxjxoxBs2bNMH/+fGi1WnzxxRcuy+/YsQNdu3bFAw88gPr16+OOO+7A8OHDi20NNRqNyMzMdPorLblMhkU7zrh8bdGOMwjSKiGXeX7+y5o6L5t/Mc9tAvmtn/cl5Ldufrv3AkxFDCjkaQq5hEwDBwkiqkjersO/3HHWa3V4rskKrUoOfQ27YUhEVNMx2fQBJpMJ+/btQ+/evR3LZDIZevfujZ07d7pcp0uXLti3b58juTx9+jR+/vln9O/fv8j3mTVrFgIDAx1/MTExpY41K8/suBt+s0yDBRkGCxQevlDJn5dN1Mh52XRqBTQqebFTjdzRLBKh/iqkZJuw4UhihcSlUXCQIKKKVlXrcOB6F1p/dqElIqppmGz6gJSUFFitVkRERDgtj4iIQGKi6+ThgQcewPTp09GtWzcolUrExcWhZ8+exXajnTRpEjIyMhx/Fy5cKHWsARol9H6uWxf1fgoE+ilg8XACkj8vW83rQgsAKoUMgX6KYrusqhQyDE3Iv+hcsfcijBUwcI9aKYPRYuV8m0QVqKrW4TYhYLPZEKpjF1oiopqGyWYVtXnzZsycORMff/wx9u/fj++++w5r167FG2+8UeQ6arUaer3e6a+0rDYbxnSJdfnamC6xSM81F9nls6yy8vIHlaip87IFa1Uw24pP6no3jUB4gBrXck345R/vt26q5PnJJgcJIqo4VbUOzzVaoVMrEFhDpq0iIqIbmGz6gNDQUMjlciQlOQ/wkpSUhMjISJfrvPbaa3jooYfw6KOPomXLlrjnnnswc+ZMzJo1Czab957b81Mp8GTPODzTK95xd1zvp8AzveIxrkcDpOd69jk+YR9UogaNQnuz/Oc2ZcVeACrlMgy7Jb91c9W+i0VOl+IpkiQBErz+PkTkWRVdhwNAjsmCUH811IqaecOQiKgmq1mjrfgolUqF9u3bY+PGjRg0aBAAwGazYePGjZgwYYLLdXJzcyGTOd8rkMvzf8iF8O5zdGqlHON6NMD42xoi3WBCkJ8S6blmXLxmgNHDA9TYB5WoiV1o7XRqBfxUchhMVvhrij5lb28cjhV7LyIxMw8/H7qCwe3qeDUupUyOdIMJMfDOCMRE5B0F6/AMgwl6PyUyvFSH24SATQiE+Ks8ul0iIqoa2LLpIyZOnIiFCxfiq6++wtGjR/HEE08gJycHY8aMAQCMHDkSkyZNcpQfMGAAPvnkEyxbtgxnzpzBr7/+itdeew0DBgxwJJ3epFUpkJ1nxomkbJxMzkFSptHjFykAkMV52aCUyxDkp0Su2fWgHnYKuQz3X2/dXLn/InJNxZcvL7VChiyDxeNd7ojI++wje5+/lot/LmZ4rQ7PMVqgVSsQ5Mdkk4ioJmLLpo8YNmwYrl69iilTpiAxMRFt2rTBunXrHIMGnT9/3qklc/LkyZAkCZMnT8alS5cQFhaGAQMGYMaMGRUWs0D+CIN6jXdaHW1CwGqzcV42AEE6FS6k55ZYrmfjcKzYdxGX0g1Y8/cVx8BB3qBRypGZZ4LBbIW/mlUJUVWUa7JCJZfBW6lgjsmCeiE6qBS8t01EVBNJwtt9LslnZWZmIjAwEBkZGWUaaCI124i959IQHejnhejyE1mrzYaE+iE1umUTADJyzdhz9hpq6VRQyIu/aNt8LBnv/noc/moFPhuZAJ0XE8FL6bloVy8Y4QE1b1oaotIqb53r6e2ZLDb8eSYVKrnMK3MYW20CyVl5aFs3GGE1+Ll7Iqo+PF2P1wS81Ug+K4fzsjno1PL85zbdGJCne3wYYkK0yDZa8ONfl70al0ySkGfy3oBURFR15Rgt+aPQ1uBn7omIajomm+ST7F1oa7ELLYD85zGDdcpi59u0k8skPNChLgDg+4OXkJ3nvWc3lXIZ0g0mr22fiKquHJMF4QFqdqElIqrB+AtAPinXaIVOo+Qd8QKC/FRuT7beJa4W6tfSItdkxfcHL3ktJrVChqw8CyxWtm4S0Q1Wm4AkAcE6DgxERFSTMdkkn5RtMiNUp+K8bAXo1ArI5RLMbiR2MulG6+aPf11GpsHzc+cB+YMEGS1Wt7r3ElHNkW20QKdiF1oiopqOySb5HKtNQAiwC+1NdCo5tEq5W11pAaBTg1poEKaDwWzFdwe807qplMtgtgq3YyKimiHHZEG4Xg1lCQOaERFR9cZfAfI5uSYOKuFK/nObKrdbESVJwogO9QAAa/6+jPRcLz1bKeD1OT2JqOqw2gRkkoRgLbvQEhHVdEw2yefkmCwI8+egEq4EaZWwlmK2olvqByM+3B9Giw2r9nundVOtkCHDwGSTiPJlGy3wZxdaIiICk03yMfYutCH+vCPuik6tgMLN5zaB662bHfNbN38+dAXXcjzfuqlWyJFltLgdExFVbznG/C60Jc0JTERE1R9/Ccin5Bgt8FcroNfwjrgrOpUCWoUCuaV4RrJd3SA0jQyAyWrDyn0XPB6TWinjIEFEBACwWG2QyySOQktERACYbJKPyTFZEMZ52Yokl0kI8VeWKrEr2Lq57nAiUrKNHo1JKZfBYhXI4yBBRDVejskKf40Ceo2iskMhIiIfwCt68hmcl809gX4q2Gyl67Laqk4gmkfrYbYKrNh30Stx5Rj53CZRTZdjMiM8gF1oiYgoH38NyGdwXjb36NRyKBUymCzuJ5wFWzc3HE5EcmaeR2NSyzlIEFFNZ7HaIJdkHIWWiIgcmGySz+C8bO7RqRTQqhSlfkayZe1AtK4TCItN4Nu9nn12U62UI9vEQYKIarJsoyW/Cy1vGBIR0XW8qiefwHnZ3CeTSQjRqmAowzOSD1xv3fzt32QkZniudVOjkCHPbC3VwEVEVL3kmCyICFBDLpMqOxQiIvIRTDbJJ2QbLQhQswutu/R+SthQ+lbEZlF6tKsbBKtNYPne8x6LRyGXwWazIY8j0hLVSGarDQqZjM/cExGREyab5BNyjPmj0HJQCffo1HKo5PlTjpSW/dnN3/9NxuV0gwejkjhIEFENlW20QO+nQACnrSIiogJ4ZU+VjvOylZ5OpYCfSlGmrrSNIgJwS/1g2ATwzR7PtW6qFXKkG0we2x4RVR25JivC2YWWiIhuwmSTKp1jUAnOy+Y2mUxCLZ0KeWVo2QSABzrkt25uOX4VF67leiQmtUKGXKO1VKPkElHVZ7baoJBLCNaqKzsUIiLyMUw2qdLlmvMHlWAX2tLR+ylhE2Vbt2G4Pzo1CIFNAMs81LqpVsiQZ7aVqbWViKqu7DwLAv2UCOANQyIiugmv7qlSma/PyxbEUWhLTadWQC2XlXlQHnvr5tYTKTiXmlPueBRyGWxClHpKFiKq2nLN+V1oZexCS0REN2GySZWK87KVnU4lh1YtL3NyFxuqQ9eGoRAAlu72TOumJAHZRrNHtkVEvs9ksUGpkHjDkIiIXGKySZXKYLIiUs9BJcpCkiSE6FTlmm5k+C0xkADsOJWK01ezyx2TWi5Hei6TTaKaIttoQaBGiQA1u9ASEVFhTDap0pitNsjlvCNeHnqNEgKAEGV7eLNeLR26x4cB8Ezrplopg8FsLdOULERU9RjMFkToNexCS0RELjHZpEqTnWeBXsN52cpDp1ZArZDBWI4RYId3iIFMAv48cw0nkrLKFY9aIYeRgwQR1QhGixUqhQyBWtbhRETkGpNNqjS5Zisi9Bp2oS0HrUoOnbps823a1QnWomejcADlb92UyyRYOUgQUY2Qf8OQXWiJiKhoTDapUpit1weV8GMX2vKQJAkhWhUM5ey2OuyW/NbNvefS8G9iZrm2JYOE7DxLubZBRL4vz5p/w1CSeMOQiIhcY7JJlcJxR5zzspVbgJ8CEKLMz20CQHSQH3o1iQAALPnzPOQyCWqFrEytzmqFDOkGc7niISLfZrRYoZazCy0RERWPySZVilyzBREBHFTCE/zVCmiU8nI9twnkt242ivDH+NviEBemQ7BOiYbhOkTo1VAr3K8q1EoZDCZrueMhIt+VnWdBoJZdaImIqHhMNn3IRx99hPr160Oj0aBjx47YvXt3seXT09Mxfvx4REVFQa1Wo1GjRvj5558rKNqyy5+XjXfEPcVPWf7nNgGgbogWKx7vgr8vZuCWmb/hlhkbkTDjNyz58zzqhPi5nXBykCCi6s9osSE8gF1oiYioeLwl6SOWL1+OiRMnYv78+ejYsSPef/999O3bF8eOHUN4eHih8iaTCX369EF4eDhWrlyJ2rVr49y5cwgKCqr44EuJ87J5liRJqKVTITUnG8Hl2E6QTonPt53GB7+fdCzLNFgwb+MJAMCIjnWRlGkscTtymQQb8gcJKk88ROSb8sxWqBUyBPrxhiERERWPV/s+Yu7cuXjssccwZswYAMD8+fOxdu1afPHFF3j55ZcLlf/iiy9w7do17NixA0pl/g9+/fr1i30Po9EIo/FGspCZWb6BYMrKYLagQZiOXWg9yF+jhIT8+TbL0tIgl0kI8lPiyx1nXb6+aMcZjL8tDinZJlhtJT+LKZMk5Bg5SBCRJ/lKHZ5ttCBIq4Q/bxgSEVEJ2I3WQ0wmE44dOwaLpfQX2CaTCfv27UPv3r0dy2QyGXr37o2dO3e6XOfHH39E586dMX78eERERKBFixaYOXMmrNaiuy7OmjULgYGBjr+YmJhSx1penJfNO/zVCqiVMuSZy/acpEImIcNgRqbB9fGbabAgw2CBws0bBGqFDGm5Jg4SRORBvlCHA9e70HIUWiIicgOTzXLKzc3FI488Aq1Wi+bNm+P8+fx5Cp966inMnj3brW2kpKTAarUiIiLCaXlERAQSExNdrnP69GmsXLkSVqsVP//8M1577TW8++67ePPNN4t8n0mTJiEjI8Pxd+HCBTc/pedk51kQ6McutJ6mUcrgr1aUeX5Li00g0E8JvZ/r70Xvp0CgnwIWN1o1AUCjkMNg5iBBRJ7kC3V4ntkKjZJdaImIyD1MNstp0qRJ+Ouvv7B582ZoNBrH8t69e2P58uVee1+bzYbw8HAsWLAA7du3x7Bhw/Dqq69i/vz5Ra6jVquh1+ud/ipansXKQSW8wP7cZl4Zk02rTSDdYMaYLrEuXx/TJRbpuWa3utAC+SPSmswCuRwkiMhjfKEOz8qzIFirgk4lr/D3JiKiqofNS+X0/fffY/ny5ejUqZNTAtW8eXOcOnXKrW2EhoZCLpcjKSnJaXlSUhIiIyNdrhMVFQWlUgm5/MYPftOmTZGYmAiTyQSVSlWGT+Nd9kElgtiF1iv8NUpIEmATArIyJPPpOWaM69EAQP4zmpkGC/R+CozuUh/jejTAxWsGt7clkyRYYStzSysR+SaT1YqwADVvGBIRkVvYsllOV69edTlabE5Ojts/xiqVCu3bt8fGjRsdy2w2GzZu3IjOnTu7XKdr1644efIkbLYb3RSPHz+OqKgon0w0ASDHaEGQVsVBJbzEPt9mWVs3jRYbLl4zYETHutj7am/sePl27JrUC72aRODiNUOpu8QqJBmy88xlioWIfI/BZIWfUs4utERE5DYmm+WUkJCAtWvXOv5tTzA/++yzIhNFVyZOnIiFCxfiq6++wtGjR/HEE08gJyfHMTrtyJEjMWnSJEf5J554AteuXcMzzzyD48ePY+3atZg5cybGjx/voU/meUaLjXfEvUijlCNAU775No0WG5IyjTiZnIPfjyah21ubMGHp/jIlsPmDBJk5SBBRNZF9/YahjjcMiYjITfzFKKeZM2eiX79+OHLkCCwWC+bNm4cjR45gx44d+OOPP9zezrBhw3D16lVMmTIFiYmJaNOmDdatW+cYNOj8+fOQyW7cG4iJicH69evx3HPPoVWrVqhduzaeeeYZvPTSSx7/jJ5wowutb7a6VhchOhWSs/LKvR2rTaBheAAyDWZcyzHhXGou6ofqSrUNjVKOXJMFeWYb/Ph8F1GVJoSA2WpFuF5d2aEQ0XVWqxVmM3sQedLNj6hR+THZLKdu3brh4MGDmD17Nlq2bIkNGzagXbt22LlzJ1q2bFmqbU2YMAETJkxw+drmzZsLLevcuTN27dpVlrArXLbRgmCtkoNKeJm/WgEJUpmf2yxIp1agfb1g/HnmGraeTCl1sqlSyJBuyH9uk8kmUdVmMFuhUbELLZEvEEIgMTER6enplR1KtRQUFITIyEj2xPMQJpseEBcXh4ULF1Z2GD7NZLUhjPOyeZ2uwHObWlX5T+9uDUPx55lr2HbiKh7sWLdU359MkmC1CeSaLAjRsUWbqCrLNloQFqD2SL1CROVjTzTDw8Oh1Wp5beUhQgjk5uYiOTkZQP5gnFR+/NUoJ/u8mkWpW7duBUXiuwym/C60vCPufZrrg3ek5Zg8clHYITYEKrkMlzPycDolB3Fh/qVaXymTISvPUu44iKjyCCFgsdkQHqApuTAReZXVanUkmrVq1arscKodPz8/AEBycjLCw8PZpdYDmGyWU/369Yu9o2S1cuqHbKMFtfw5L1tFCdGpkJhR/uc2AUCrUiChfjB2nErF1hMppU421Uo5Mgxm2GwCMhnvvBJVRQaz1XEji4gql/0ZTa1WW8mRVF/2fWs2m5lsegCTzXI6cOCA07/NZjMOHDiAuXPnYsaMGZUUle+wDyrBUWgrjk6tgEyWP8iP3AMJXvf4sOvJ5lWM6lyvVN+jWiFDjsmCPItnuvUSUcXLzrMgIlDDZ6+JfAivqbyH+9azePVXTq1bty60LCEhAdHR0ZgzZw4GDx5cCVH5jjyzjXfEK5hOLXc8t+mJKQoS6gVDo5QhOcuIE8nZaBQR4Pa6+dOf2GAwMdkkqoqEEDDbBMICOAotERGVHufZ9JLGjRtjz549lR1GpcsymjkvWwVTK+TQa5QwlGFuTFc0Sjk61A8BAGw9cbVU60qSBJsAcssx9ycRVZ5ckxVajkJLRERlxGSznDIzM53+MjIy8O+//2Ly5MmIj4+v7PAqlWNQCc7LVuFCdCoYLTaPba9bw1AAwLaTqbAJUap1lXIJWXmcB4yoKso2WlBLp4JGyS60ROQ9Z8+ehSRJOHjwoNvrfPnllwgKCvJaTOQZbG4qp6CgoEJ9u4UQiImJwbJlyyopKt/AQSUqj79aAfn1qUc88dxm+3oh8FPKkZJtxLHELDSN0ru9rlohR4bBwkGCiKoYmxCwCoFQdqElIqIyYrJZTps2bXL6t0wmQ1hYGBo2bAiFombv3uw8C8IDOS9bZdCpFfBTyWAwW+HvgS7MKoUMHRuEYPOxq9h64mopk00ZcowWGDz0DCkRVQx2oSUiovJiN9py6tGjh9Nf9+7d0aRJkxqfaAohYBE2hPlzXrbKoFLIoPdTwuDBZyW7NwwDAGw/mQqrzf2utGqFDCarzWPPkBJRxbBPW8UutERVQE5O0X95ee6XNRjcK1sG69atQ7du3RAUFIRatWrh7rvvxqlTp1yW3bx5MyRJwtq1a9GqVStoNBp06tQJ//zzT6Gy69evR9OmTeHv748777wTV65ccby2Z88e9OnTB6GhoQgMDESPHj2wf//+MsVPZVOzM6Iy+vHHH90uO3DgQC9G4rsMZiv8lAreEa9EIToVLqcbSi7oprZ1g6BTy3Et14QjVzLRsnagW+tJkgQh4NHEl4i8yyYEbDYbQnXsQktUJfgXMw92//7A2rU3/h0eDuTmui7bowewefONf9evD6SkFC5XyvEbACAnJwcTJ05Eq1atkJ2djSlTpuCee+4p9jnNF154AfPmzUNkZCReeeUVDBgwAMePH4dSmX99mZubi3feeQeLFy+GTCbDgw8+iOeffx5LliwBAGRlZWHUqFH44IMPIITAu+++i/79++PEiRMICHB/dH0qOyabZTBo0CC3ykmSBKu1Zl5gZ+VZEMl52SqVv1oBhUzmsec2lXIZOjeohd+OJmPriatuJ5v2dTMMJsSAk1ATVQW5xvxu74Fa3jAkIs8YMmSI07+/+OILhIWF4ciRI/AvIlmeOnUq+vTpAwD46quvUKdOHaxevRpDhw4FkD+//fz58xEXFwcAmDBhAqZPn+5Y//bbb3fa3oIFCxAUFIQ//vgDd999t8c+GxWNyWYZ2GyeG+WzOsofhZbzslU2nVoBjUoOg8kKf41nTvXuDcPw29Fk7DyVinG3xrmdxKoVMmQZrB5LfInIu3JMFtQJ9oNawRuGRFVCdnbRr8lvOo+Tk4suK7vpCbuzZ8sc0s1OnDiBKVOm4M8//0RKSorjevr8+fNo1qyZy3U6d+7s+P+QkBA0btwYR48edSzTarWORBMAoqKikFzg8yUlJWHy5MnYvHkzkpOTYbVakZubi/Pnz3vsc1HxmGySx+WarNCpOahEZVPKZQj0UyA50+ixZLNVnUAEaBRIN5jxz6UMtI4Jcms9tVKGrDyzxwYsIiLvsQkBmxAI8VdVdihE5C6drvLLlmDAgAGoV68eFi5ciOjoaNhsNrRo0QImk6nM27R3p7XLf3TnRhffUaNGITU1FfPmzUO9evWgVqvRuXPncr0nlQ6v+jwgJycHf/zxB86fP1/o4H366acrKarKk2W0oHaQhoNK+IBgrQqXPPjcpkIuQ5cGtbD+SBK2nrjqdrKpkstgstjyW1mZbBL5tByjBVo1n7knIs9JTU3FsWPHsHDhQnTv3h0AsG3bthLX27VrF+rWrQsASEtLw/Hjx9G0aVO333f79u34+OOP0b9/fwDAhQsXkOLqGVTyGl71ldOBAwfQv39/5ObmIicnByEhIUhJSYFWq0V4eHiNSzbtd8RD/dmF1hf4qxVQSDJYrDYo5J4ZfLp7fBjWH0nCjlOpeLxHnFvblSQJkDhIEFFVkGOyoG6Ill1oichjgoODUatWLSxYsABRUVE4f/48Xn755RLXmz59OmrVqoWIiAi8+uqrCA0NdXvsFACIj4/H4sWLkZCQgMzMTLzwwgvw8/Mrxyeh0uLUJ+X03HPPYcCAAUhLS4Ofnx927dqFc+fOoX379njnnXcqO7wKl2uyQqeSQ8874j4hf75NuUenHWlROxBBfkpkGS3462KG2+spZXKkG9hthciXWW0CQgAhHIWWiDxIJpNh2bJl2LdvH1q0aIHnnnsOc+bMKXG92bNn45lnnkH79u2RmJiIn376CSqV+138P//8c6SlpaFdu3Z46KGH8PTTTyM8PLw8H4VKiS2b5XTw4EF8+umnkMlkkMvlMBqNaNCgAd5++22MGjUKgwcPruwQK1SO0YLoYHah9RVKuQxBfkokZuQhQOOZGwBymYQuDUPx86Er2HriKtrXC3ZrPY1Shuw8CwcJIvJhuSZL/ii0vGFIRB7Wu3dvHDlyxGlZwecrhYvpVLp16+Zybk0AGD16NEaPHu20bNCgQU7badu2Lfbs2eNU5t577y1t6FQObNksJ6VSCdn1kbvCw8Mdo1sFBgbiwoULlRlahbMJAavNxi60PiZIp4LFVvr5sIrTvWEoAGDX6VSYre6NzqxWyJFnsSLXZPFoLETkOdlGC8ID1FApeHlARETlx5bNcrLfMYmPj0ePHj0wZcoUpKSkYPHixWjRokVlh1ehco1W6DRK3hH3Mf4qBeRyCWarDUoPPbfZNEqPEK0K13JNOHA+HR1iQ0pcR6WQwWwVMJitHmtlJSLPsdoEJAkI1nEUWiIi8gzeuiynmTNnIioqCgAwY8YMBAcH44knnsDVq1exYMGCSo6uYuWYLAjVqTiohI/RqeXQKuUeHZxHLpPQtWEtAMDWk1fdX1EAeSbOU0vki3KMFuhU7EJLRJWvZ8+eEEIgKCioskOhcmLLZjklJCQ4/j88PBzr1q2rxGgqj9XGedl8lUIuQ5BOictpeR4duKl7fBh++vsK/jx9DSaLza1udyqFDGm5JtStpfVYHETkGdkmC+LCdB7rAUFE3uPq+UbyDO5bz+IvSjm9+eabOHPmTGWHUelyTfnzsgX5Mdn0RUF+Klg9XHk2jgxAqL8aBrMV+85dc2sdjUKObKMFFjef8ySiimG1Ccik/Ll5ich3KZX5N41zc3MrOZLqy75v7fuayoctm+W0YsUKTJ06FR07dsSDDz6IoUOHIjQ0tLLDqnA5Jgvqheg4qISP0qkVUHj4uU2ZJKFbw1B8f/AStp5MQee4ko97tVKGdIMJuWYr9Gw9IfIZ2UYL/FV85p7I18nlcgQFBSE5ORkAoNVq8+eypnITQiA3NxfJyckICgqCXM7HwjyByWY5/fXXXzh8+DCWLFmCd955B88++yz69OmDESNGYNCgQdBqq393Qfu8bBxUwnf5qxXQKhTINVkR6Oe5JK97fH6yufvMNeSZrSVOeaOUy2CyCOSZrNBzkCAin5FjtKBhuD8UvAlE5PMiIyMBwJFwkmcFBQU59jGVH5NND2jevDlmzpyJmTNnYvv27Vi6dCmeffZZPP7448jMzKzs8Lwux8h52XydXCYhWKfEhTSDR7+n+HB/ROjVSMo0Yu+5NHRrWHLrpiSB058Q+RCLVUAmSbxhSFRFSJKEqKgohIeHw2w2V3Y41YpSqWSLpocx2fQwnU4HPz8/qFQqZGVlVXY4FSLHZEFsKLvQ+rpArRLnUnM8uk1JktCtYRhW7b+IrSeuupVsquUypOcy2STyFTkmC/R+Sug1vCQgqkrkcjkTI/J5zA484MyZM5gxYwaaN2+OhIQEHDhwANOmTUNiYmJlh+Z1QoDzslUROrUCSoUMZg8PztM9Pj/B3Hs2za0WS7VSjmyTxeNxEFHZGMxWhPmr2YWWiIg8jr8s5dSpUyc0bNgQK1euxJgxY3Du3Dls3LgRjzzyCAIDA0u1rY8++gj169eHRqNBx44dsXv3brfWW7ZsGSRJwqBBg8rwCcqP87JVDTqVAlpV/nObntQgVIfoQA1MVht2nyl5VFq1QgajxQqD2bNxEFHZ6FQKhPCGIREReQGTzXLq1asXDh06hAMHDuC///0voqOjy7Sd5cuXY+LEiZg6dSr279+P1q1bo2/fviU+/H327Fk8//zz6N69e5net7xkEhCuV3NetipALpMQrFV6PMmTJAnd48MAANtOppRYXimXwWK1weDhpJeIysZfo/DoHLxERER2zBDKacaMGdi5cydatGgBjUYDjUaDFi1a4LPPPivVdubOnYvHHnsMY8aMQbNmzTB//nxotVp88cUXRa5jtVoxYsQITJs2DQ0aNCjxPYxGIzIzM53+ykurVnBetiok0E8FITzffdXelXbfuTTkGEvuSitBQq4b5YjoBm/U4XJJQkSAGnIZp04gIiLPY7JZTlOmTMEzzzyDAQMGYMWKFVixYgUGDBiA5557DlOmTHFrGyaTCfv27UPv3r0dy2QyGXr37o2dO3cWud706dMRHh6ORx55xK33mTVrFgIDAx1/MTExbq1XFJkkIYCj0FYpOrX8+vQjnk0464ZoERPsB4tN4M8zqSWWV8llSDdwBD2i0vB0HS5J128YsgstERF5CZPNcvrkk0+wcOFCzJo1CwMHDsTAgQMxa9YsLFiwAB9//LFb20hJSYHVakVERITT8oiIiCIHGdq2bRs+//xzLFy40O1YJ02ahIyMDMffhQsX3F7XlUA/JRpHBnBQiSpEp1LAT6XwalfarSdK7kqrUcqRY7R4POklqs48XYcr5TI0ivBHEHunEBGRlzBLKCez2YyEhIRCy9u3bw+LxTvdBLOysvDQQw9h4cKFCA0teaoJO7VaDb1e7/RXHjKZBI2SQ25XJTKZhFo6FfK8MDhPt+tdaQ9cSEdWXvGtlmqFDHkWGwcJIioFT9fhAKBVcboTIiLyHiab5fTQQw/hk08+KbR8wYIFGDFihFvbCA0NhVwuR1JSktPypKQkREZGFip/6tQpnD17FgMGDIBCoYBCocD//vc//Pjjj1AoFDh16lTZPgzVCHo/JaxCeHy7McFa1K+lhdUmsPN08V1pFXIZrBwkiIiIiKha4y1ND/j888+xYcMGdOrUCQDw559/4vz58xg5ciQmTpzoKDd37lyX66tUKrRv3x4bN250TF9is9mwceNGTJgwoVD5Jk2a4NChQ07LJk+ejKysLMybN6/cz/FQ9aZTK6CW508/olZ4tmW6e3wYzqaew9YTKbijWeEbJQXJZJJbgwkRERERUdXEZLOc/vnnH7Rr1w4AHC2KoaGhCA0NxT///OMoJ0nFj/Q3ceJEjBo1CgkJCejQoQPef/995OTkYMyYMQCAkSNHonbt2pg1a5ZjxNuCgoKCAKDQcqKbaZVy+KnkMJi8kWyGYvGuc/j7YjoyDOZiB49SyeVIN5g8+v5ERERE5DuYbJbTpk2bPLKdYcOG4erVq5gyZQoSExPRpk0brFu3zjFo0Pnz5yGTsdczlZ9MJqGWvwpnUnI8vu2oQD80DPPHyavZ2HEqBf1aRBVZVq2QIddk9UoLKxERERFVPiabPmTChAkuu80CwObNm4td98svv/R8QFRt6TVKWG2AEKLEVvfS6hYfipNXs7HtRPHJpkYpR3a2BXkmG5NNIiIiomqITWVENZBOrYBGIYPRC1OPdGuYPyrtP5czkJZTdDdZuUyCVQjkmvncJhEREVF1xGSTqAbSquTQaTw/3yYAROg1aBwRAJsAtp8qfs5NGThIEBEREVF1xWSTqAaSJAkhWu/MtwncmHNz64nik021Qob03OLn5CQiIiKiqonJJlENFeCngED+c5ueZu9Ke+RKJlKyjUWWUyvzBwnyVtJLRERERJWHySZRDeWvVkDtpec2Q/3VaBalBwBsP1l066ZaIYfJYmOySURERFQNMdkkqqH8lHLo1AoYTF7qStuw5K60cpkEq00g10sxEBEREVHlYbJJVENJkoRQnQoGi3cSva4NQyEBOJaUheTMvCLLySQOEkRERERUHTHZJKrB/DVKQAivPLcZolOhRe1AAMC24rrSKmVIN5i9EgMRERERVR4mm0Q1mL9aAY1Sjjyz55/bBIDuboxKq1bIkGuyeOXZUSIiIiKqPEw2iWowjVKW/9ymlwbo6RIXCpkEnLyajcvpBpdl1Ao5TGbhtWdHiYiIiKhyMNkkqsEkSUKov/fm2wz0U6JVnSAARY9KK5dJsEF4LeElIiIiosrBZJOohvPXKAEJsHnpmUnHqLTFPLcpkyRk5Zm98v5EREREVDmYbBLVcPnPbcq81rrZJa4W5DIJZ1JycDEt12UZjUKGDA4SRERERFStMNkkquE0SjkCNN6bbzNAo0SbmCAARQ8UpFbIYTBbvTZQERERERFVPCabRIQQrQpGq/eemexeQldatVIGo9nG5zaJiIiIqhEmm0SEAI0SEiSvPbfZqUEtKGQSLlzLxbnUnEKvyyQJgoMEEREREVUrTDaJCDrHfJveSfZ0agXa1wsGUHTrplySIdPAQYKIiIiIqgsmm0QEjVIOvUbp1bku7aPSbjuR4nIgII1SzkGCiIiIiKoRJptEBAAI0amQZ/FestkhNgQquQyX0g04k1K4K61aIYORgwQRERERVRtMNokIAKBTyyGXSbDavNOyqFUV6ErrYlRalUIGo8WGXJPFK+9PRERERBWLySYRAfD+c5sA0D3ePirt1ULdZfMHCQIHCSIiIiKqJphsEhGAAs9tejHZu6V+CNQKGZIyjTiRnF3odYUkITOPgwQRERERVQdMNonIIUSngtHivWcmNUo5OsSGAAC2uRiVVq2UI9Nggc1LXXmJiIiIqOIw2SQiB51aAbnkvec2AaC7fVTak4VHpVUrZMgzW706UBERERERVQwmm0TkoFPL4aeSebUrbbt6wfBTynE1y4hjiVlOr6kdgwQx2SQiIiKq6phsEpGDWiFHgJfn21Qr5Oh4vSvt1pu60kqSBAh49f2JiIiIqGIw2SQiJyE6FUxW7yZ79lFpt51Mge2mrrQKuYRMAwcJIiIiIqrqmGwSkRN/tQIKmcyrz222rRsMnUqOazkmHLmc6fSaRsFBgoiIiIiqAyabPuSjjz5C/fr1odFo0LFjR+zevbvIsgsXLkT37t0RHByM4OBg9O7du9jyRO7SqRXQqORe7cqqlMvQqUEtAIVHpVUrZTBarJxvk4iIiKiKY7LpI5YvX46JEydi6tSp2L9/P1q3bo2+ffsiOTnZZfnNmzdj+PDh2LRpE3bu3ImYmBjccccduHTpUgVHTtWNSiFDoJ8CuWaLV9+ne3wYAGD7qRSnVlSVPD/Z5CBBRERERFUbk00fMXfuXDz22GMYM2YMmjVrhvnz50Or1eKLL75wWX7JkiV48skn0aZNGzRp0gSfffYZbDYbNm7cWOR7GI1GZGZmOv0RuRKsVcFs8958mwDQuk4gAtQKpOea8c/lDMdySZIACchjyyaRE9bhRERU1TDZ9AEmkwn79u1D7969HctkMhl69+6NnTt3urWN3NxcmM1mhISEFFlm1qxZCAwMdPzFxMSUO3aqnvzVCijlMuSavNe6qZDL0Dkuvyvt1hPOXWmVMjnSDSavvTdRVcQ6nIiIqhommz4gJSUFVqsVERERTssjIiKQmJjo1jZeeuklREdHOyWsN5s0aRIyMjIcfxcuXChX3FR9Bfop0aCWDhkGM3KM3ks47V1pd5xKgcV6oyVVrZAhy2Dx6iBFRFUN63AiIqpqFJUdAJXf7NmzsWzZMmzevBkajabIcmq1Gmq1ugIjo6pKkiTUD9VBkoATydkA8gcO8rSWtQMR6KdEhsGMvy9moF29YACARilHZp4JBrMV/l54X6KqiHU4ERFVNWzZ9AGhoaGQy+VISkpyWp6UlITIyMhi133nnXcwe/ZsbNiwAa1atfJmmFTDSJKEerV0aBQRgCyjGdleaOGUyyR0iSs8Kq1SLsFosXm1Gy8REREReReTTR+gUqnQvn17p8F97IP9dO7cucj13n77bbzxxhtYt24dEhISKiJUqmEkSULdEC0aRQQg22hBdp7nkz9HV9rTKTBf70orSRIkCcgzeXeQIiIiIiLyHiabPmLixIlYuHAhvvrqKxw9ehRPPPEEcnJyMGbMGADAyJEjMWnSJEf5t956C6+99hq++OIL1K9fH4mJiUhMTER2dnZlfQSqpuwJZ+MIf+SYLMjKM3t0+82i9AjWKpFjtOLghXTHcpWcgwQRERERVWVMNn3EsGHD8M4772DKlClo06YNDh48iHXr1jkGDTp//jyuXLniKP/JJ5/AZDLh3nvvRVRUlOPvnXfeqayPQNWYJEmICdGicaQ/ck1WjyaccpmErg1DAQBbT1x1LFcrZMjKszgNHEREREREVQdH3vAhEyZMwIQJE1y+tnnzZqd/nz171vsBERUgSRLqBGshSRL+vZIFIQC9n9Ij2+4eH4Y1f1/BrtPXYLLYoFLIoFHmt2wazFYEyHlfjIiIiKiq4RUcEbnNnnA2iQqAwWJFhsEzLZxNIgMQ6q+CwWzFvvNpAAClXAazVcBgtnrkPYiIiIioYjHZJKJSqxOsRdMoPYxWzyScMklCt+tdabcV6EoLAeR6cZ5PIiIiIvIeJptEVCa1g/zQNFIPk9WK9NzyD+RjH5V299lryLvemqlWyJBhYLJJREREVBUx2SSiMosO8kPTKD0sNlu5E874cH+EB6iRZ7Zh37n8rrRqhRzZRotjShQiIiIiqjqYbBJRuUQF+qFpVCAsNhvSypFwSpKE7vHOo9KqlTLkWax8bpOIiIioCmKySUTlFhmoQbPoQNhsAmk5ZU84uzXM70q751waDCYrlHIZLFaBPBOTTSIiIqKqhskmEXlEhF6DZtF62CBwrYwJZ1yYDlGBGpgsNuw+e82xPIeDBBERERFVOUw2ichjwvUaNIvSAxBIzTaWev38rrT5rZuOrrRyDhJEREREVBUx2SQijwrXa9A0Wg9JhjIlnN2vT4Gy71wack0WqJVyZJs4SBARERFRVcNkk4g8LjxAg2ZRgZDJJKSUMuGsV0uLmGA/WGwCu05fg0YhQ57Zilw+t0lERERUpTDZJCKvCAtQo1m0Hgq5hKtZ7ieckiShW8Mbo9Iq5DLYbDbH3JtEREREVDUw2SQirwn1V6NZlB4qRekSTvtzmwcvpCM7zwJA4iBBRERERFUMk00i8qpa/mo0iw6ESiEhOSvPrXViQrSoX0sLi01g5+kUqBVypBvKPqUKEREREVU8JptE5HUhOhWaRQdCrZQjOdO9hLObY1TaFKgVMuQarTBZOEgQERERUVXBZJOIKkSIToXmUXpoVHIkZeZBCFFsefuotH9dTIfRbEWe2QYDBwkiIiIiqjKYbBJRhQnWqdA8Wg+tSo7kLGOxCWd0kB/iwnSwCWD32TTYhICBgwQRERERVRlMNomoQgVpVWgeHQiduuSEs1vD611pT16FJAHZRnNFhUlERERE5cRkk4gqXKBWiWZRgfBXK4pNOLvF53el/edSBvJMNqTnMtkkIiIiqiqYbBJRpQjUKtE0Wg9/jQJJWa6f4YzUa9Aowh82ARy4kAaD2QqjhV1piYiIiKoCJptEVGkC/ZRoFq1HgEaJxCIGDep+vSvtrtPXYOQgQURERERVhqKyAyAfkJMDyOWFl8vlgEbjXK4oMhng51e2srm5QFHP7UkSoNWWrazBANiKmSpDpytb2bw8wFpMwlOaslptftwAYDQCFotnyvr55e9nADCZAHMx3U9LU1ajuXGslKas2Zxf3gU9gObhWhxOzkViZh4i/OSQW25st3u0H5aa8nD2XB7SUsJgiNAiSKvKf9Fiyd8XRVGpAKWy9GWt1vzvrihKZX750pa12fKPNU+UVSgAtTr//4XIPzc8UbY05z3rCNdlizrvi/vM5cE6nHV4JdbhAPLrF4Wi9GVZh+f/P+vwspWtjDrCW/V4dSaoxsrIyBAAREb+aV34r39/5xW0WtflACF69HAuGxpadNmEBOey9eoVXbZZM+eyzZoVXbZePeeyCQlFlw0NdS7bo0fRZbVa57L9+xdd9uZT6t57iy+bnX2j7KhRxZdNTr5R9skniy975syNss8/X3zZf/65UXbq1OLL7t59o+zbbxdfdtOmG2U//LD4smvWiEyDSfx5OkX8/eb7xZa9vOCrG9v99tvit7to0Y2ya9YUX/bDD2+U3bSp+LJvv32j7O7dxZedOvVG2X/+Kb7s88/fKHvmTPFln3zyRtnk5OLLjhp1o2x2dvFl771XOCmuLOuI/D8364gMQAAQGRkZwhNYhxfAOjxfJdbhDosWFV/2229vlGUdno91+A0+Xkd4uh6vCdiNloh8QoBGiWbXR6ktTo7JCiFEBUVFRERERGUlCV611ViZmZkIDAxExuXL0Ov1hQuwe4XrsuyCVfqypehWlZ1twLHzKUjLNiMiUA1JknAt24jHv94PAWDm/e3Rr20MNEo5u2CxC1aVqiMyMzMRGB2NjIwM13VuKbEOZx1e6rLsRpuPdXjpy7KOAOD5erwmYLJZgzkuVHjCkI/JMVpw9EomUrKNiNT7QS6TMOm7v/HP5Uzc264OXr2rKYJ1qsoOk6hUPF3nsg4nIqpYrHdLj91oicjn6NQKNIvWIyxAjaQsA6w2ge7x+aPS7jl7DQYzR6QlIiIi8nVMNonIJ2lVCjSN0iPUX43ETAM6xoZAJgHnruXiXEp2ZYdHRERERCXg1CdE5LO0KgWaRQXiKDKRlJWHfi0iMahtbbStF4LUbCMCNEpYbDZoVb5RlRlMFshlMmTlmX0uNoDxlYcvx0ZEROSr+EvpQz766CPMmTMHiYmJaN26NT744AN06NChyPIrVqzAa6+9hrNnzyI+Ph5vvfUW+vfvX4ERE3mfn0qOplF6aJQyzBrcCgu3nsZ/V/yFTIMFej8FxnSJxZM946BWFj+KrbcZzVbM/+M0Fu0443OxMb7qGxsREZEvYzdaH7F8+XJMnDgRU6dOxf79+9G6dWv07dsXycnJLsvv2LEDw4cPxyOPPIIDBw5g0KBBGDRoEP75558KjpzI+/xUctStpcVn207jg99PItOQP4pjpsGCeRtP4OPNp5BrKmZkRy8zmCz4ePMpzNt4wudiY3zVNzYiIiJfx9FofUTHjh1xyy234MMPPwQA2Gw2xMTE4KmnnsLLL79cqPywYcOQk5ODNWvWOJZ16tQJbdq0wfz58916T46oRVWJyWJDwoxfHRf8Ben9FNg1qReGzd+JdEMxQ/l7QZCfEssf74xOszb6XGyMz/ux7X21D1QK9+7bcjRaIqKqjfVu6bEbrQ8wmUzYt28fJk2a5Fgmk8nQu3dv7Ny50+U6O3fuxMSJE52W9e3bF99//32R72M0GmEsMEdVZmZm+QInqkBZeWaXF/xAfkvTtRwTTFaBC2nFzGvmBVqVAqnZJp+MDWB83o4tK8+MWv7qComHdTgREVU1TDZ9QEpKCqxWKyIiIpyWR0RE4N9//3W5TmJiosvyiYmJRb7PrFmzMG3atPIHTFQJAjRK6P0URbYwhfmr8d8+jWCyFjNpsxeo5DKEB6h9MjbG5/3YAjTKCouHdTgREVU1TDZrkEmTJjm1hmZmZiImJqYSIyJyn9Vmw5gusZi38USh18Z0iYVVCNzRIrISIst/rs9XYwMYX3mUFJvFZoOqgoY/YB1ORERVDZNNHxAaGgq5XI6kpCSn5UlJSYiMdH2BFRkZWaryAKBWq6FWV0x3LyJP81Mp8GTPOADwuVFBfTk2xld9YmMdTkREVQ0HCPIRHTt2RIcOHfDBBx8AyB8gqG7dupgwYUKRAwTl5ubip59+cizr0qULWrVqxQGCqFrLNVmg8NH5Dn05NoDxlYcnYuMAQUREVRvr3dLzjV9xwsSJEzFq1CgkJCSgQ4cOeP/995GTk4MxY8YAAEaOHInatWtj1qxZAIBnnnkGPXr0wLvvvou77roLy5Ytw969e7FgwYLK/BhEXme/wLcPylJRXRjd4cuxAYyvPHw5NiIiIl/FZNNHDBs2DFevXsWUKVOQmJiINm3aYN26dY5BgM6fPw+Z7MbFTZcuXbB06VJMnjwZr7zyCuLj4/H999+jRYsWlfURiIiIiIiIHNiNtgZjVwAioorDbrRERFUb693SYz8gIiIiIiIi8jh2o63B7I3anBiciMj77HWtpzoUsQ4nIqpYnq7HawImmzVYVlYWAHCeNiKiCpSVlYXAwECPbAdgHU5EVNE8VY/XBHxmswaz2Wy4fPkyAgICIElSqda1TyZ+4cIF9lm/CfdN0bhvXON+KVp12jdCCGRlZSE6OtppwLeyYh3uHdw3ReO+KRr3jWvVbb94uh6vCdiyWYPJZDLUqVOnXNvQ6/XVovLwBu6bonHfuMb9UrTqsm88eSecdbh3cd8UjfumaNw3rlWn/cIWzdJhSk5EREREREQex2STiIiIiIiIPI7JJpWJWq3G1KlToVarKzsUn8N9UzTuG9e4X4rGfeMd3K9F474pGvdN0bhvXON+IQ4QRERERERERB7Hlk0iIiIiIiLyOCabRERERERE5HFMNomIiIiIiMjjmGwSERERERGRxzHZJCIiIiIiIo9jsklEREREREQex2STiIiIiIiIPI7JJhEREREREXkck00iIiIiIiLyOCabRERERERE5HFMNomIiIiIiMjjmGwSERERERGRxzHZJCIiIiIiIo9jsklEREREREQex2STiIiIiIiIPI7JJhH5lAcffBAajQbHjx8v9Nrs2bMhSRLWrFnjWJaVlYUXX3wRsbGxUKvVqF27Nu69917k5uZWZNhERAT36/DNmzdDkqQi/2bMmFEJ0RORp0lCCFHZQRAR2SUnJ6NJkyZo06YNfv/9d8fyM2fOoHnz5ujfvz9WrlwJAMjIyECPHj1w8eJFjB07Fg0bNsTVq1exdetWLF68GMHBwZX1MYiIaiR36/CkpCT8+uuvhdZfvHgxNmzYgN27d+OWW26pyNCJyAuYbBKRz1m4cCHGjh2LL7/8EqNGjQIA9OvXDzt27MCRI0dQu3ZtAMCTTz6Jb775Bvv370dsbGxlhkxERNe5W4e7Eh8fD0mSXLaMElHVw260RORzHn30UXTt2hXPP/88UlNTsWzZMqxbtw5vvvmm4yIlPT0dixYtwtixYxEbGwuTyQSj0VjJkRMRkTt1uCu7d+/GyZMnMWLEiAqMloi8ickmEfkcSZLw6aefIiMjA0888QSee+45JCQkYPz48Y4y27ZtQ15eHho2bIh7770XWq0Wfn5+6Nq1Kw4ePFh5wRMR1XDu1OGuLFmyBACYbBJVI+xGS0Q+65VXXsGsWbMgl8uxe/dutGvXzvHae++9h4kTJ6JWrVqIi4vDM888g4yMDEybNg0mkwmHDx9GVFRUJUZPRFSzFVeH38xqtaJ27dqoV68e/vzzzwqMkoi8SVHZARARFSU0NBQAEB0djRYtWji9lp2dDSD/DvrGjRvh7+8PAGjbti06d+6Mjz76CG+++WbFBkxERA7F1eE327hxI5KSkvDKK69URGhEVEHYjZaIfNKFCxcwdepUtGjRAhcuXMDbb7/t9Lqfnx8AYMCAAY5EEwA6deqE2NhY7Nixo0LjJSKiG0qqw2+2ZMkSyOVyDBs2rIIiJKKKwGSTiHzShAkTAAC//PIL7rvvPsyYMQOnT592vB4dHQ0AiIiIKLRueHg40tLSKiZQIiIqpKQ6vCCDwYDVq1ejd+/eLut0Iqq6mGwSkc9ZvXo1fvzxR7zxxhuoU6cO3n//fahUKqfBJdq3bw8AuHTpUqH1L1++jLCwsAqLl4iIbnCnDi/oxx9/RFZWFgcGIqqGmGwSkU/JysrC008/jbZt2+Kpp54CkN+K+cYbb2DdunVYsWIFAKBx48Zo3bo1fvjhB6SkpDjW37BhAy5cuIA+ffpUSvxERDWZu3V4QUuXLoVWq8U999xT0eESkZdxNFoi8inPPPMMPvzwQ+zatQu33HKLY7nVakWHDh2QmJiIf//9FwEBAdi0aRP69OmDhg0bYty4ccjIyMDcuXMRFRWFffv2OT3LSURE3leaOhwArl27hsjISAwZMgTffPNNZYVNRF7Clk0i8hn79u3DRx99hCeffNLpIgUA5HI55s+fj8TEREyePBkAcNttt2HdunUIDg7GK6+8gg8++ACDBg3CH3/8wUSTiKiClbYOB4AVK1bAbDbjgQceqOhwiagCsGWTiIiIiIiIPI4tm0RERERERORxTDaJiIiIiIjI45hsEhERERERkccx2SQiIiIiIiKPY7JJREREREREHqeo7ACo8thsNly+fBkBAQGQJKmywyEiqtaEEMjKykJ0dDRksvLf62UdTkRUsTxdj9cETDZrsMuXLyMmJqaywyAiqlEuXLiAOnXqlHs7rMOJiCqHp+rxmoDJZg0WEBAAIP+E0ev1lRwNEVH1lpmZiZiYGEfdW16sw4mIKpan6/GagMlmDWbvdqXX63mhQkRUQTzV5ZV1OBFR5eCjC+5jZ2MiIiIiIiLyOCabRERERERE5HFMNomIiIiIiMjj+Mymj9iyZQvmzJmDffv24cqVK1i9ejUGDRpU7DqbN2/GxIkTcfj/2bvzOKfKe3/gn7Of7Jl9gYEBBpFNUJBNLVqx1B272dafC7eLtdpqaXsVi1ptla7W3lal2ireXr1ar3WpWq1FUZBVcGGTHYZlZpg9k/XkLL8/MgkzTDKTZLLn+3695vVikifJM4fkyfme5/t8nx07UFdXh2XLluGGG27ISH8JIflN13UoipLtbhQcURSpHH4K+BQVHMuixx+ETRag6jrMIp2yxIOO3fDk0/HTNA3BYDDb3SgogiCA47hsd6Og5Oanpwh5PB5MmzYN//Ef/4EvfOELQ7Y/ePAgLr30UnznO9/B008/jVWrVuGb3/wmampqsHDhwgz0mBCSrxRFwcGDB6Hrera7UnBYlsWYMWMgimK2u5K3AkENK949gCfXHYTLp8Ju4rF43hh89/xxkAQ6CRwMHbvhyZfjZxgGmpub0dXVle2uFCSn04nq6moqApQiFGzmiIsvvhgXX3xx3O1XrFiBMWPG4Le//S0AYOLEiVi7di1+97vfUbBJCInJMAw0NTWB4zjU1dXRLFwK6bqO48ePo6mpCaNGjaITlST4FBUr3j2A36/aG7nN5VMjv984f2zOzjJlGx274cmn4xcONCsrK2E2m2msSRHDMOD1enHixAkAQE1NTZZ7VBhy41NDErZ+/XosWLCg320LFy7EbbfdFvMxgUAAgUAg8rvL5UpX93JCUAvN2ggcnUwTEqaqKrxeL2pra2E2m7PdnYJTUVGB48ePQ1VVCIKQ0udOxxjuCahQdWPYz5MKDABZ4PDkuoNR739y3UHcfEEDXL4gcqPHuSPeY0di41g2L957uqaho6MTFZUVcJSUZLk3+YkFA5aNHqCbTCYAwIkTJ1BZWUkptSlAwWaeam5uRlVVVb/bqqqq4HK54PP5Ih+WvpYvX4577703U13MKp+iYVeTC06zgLEV1mx3h5CcoWkaAFCaZ5qEj6umaSkPNlM9hgc1HduPd6PHp6bsOYfDIvEYV2GBK0Z/XD4VXT4F+0944AnkRp9zRTzHrscfRJlVynDP8kePP5gX7z1WD8Kp62B4Cd6AltW+5CueZWCWYodA4QuxwWCQgs0UoGCziCxduhRLliyJ/O5yuVBXV5fFHqWHV1Gxq8mFo50+GBgYdBNCaEPqdEnncU31GG4YgKLqsIg8TGL2T6g4loHTLMBu4qOe9NtNPJwmAVaJhymH1s/lAo5l4Bji2Nnk1F78KDQ2OT/ee4bKgPUw4DkWfIzZORKbZhhDzk7T92NqUbCZp6qrq9HS0tLvtpaWFtjt9qizmgAgSRIkqbCvaoYDzTZ3AJVWGV5FQ0DVIPF0YkIIyW/pGsNZNhSs5IIuXxDXz63HH97eN+C+6+fWo7UnVEE5V/qbK9rdAWw4EIh57BbPGwNV0yHytKwkFkXTcMO8evzXqujHr8sbqvqa7feewTIngyX6GCQu23nQRYiCzTw1d+5cvP766/1ue+uttzB37tws9Sj7PIFQoNnuCaDKFgq429wq/IpOwSYhhOSBDw524IZ59QCAp9YfilQEvX5uPW6YV49bntmKGz8zjtJB+zjR48eyl7bDLPJ4/jtzwTDAynUnj90Nc+vx7c+MRbPLj1GlZvBUx2AAf1DD0Q4fFp8zBobR/713w9x63Dh/LI52+LLdTULyEo04OcLtduOjjz7CRx99BCC0tclHH32ExsZGAKH0qeuuuy7S/jvf+Q4OHDiA//zP/8Snn36KRx55BH/729/wgx/8IBvdzzp3QMXOJhfa3Qqq7SZwLAOOZaAbBrxBWttDSKE7dOgQGIaJjKHxWLlyJZxOZ9r6RBK34r0D+MqfNuAz4yuw+ScLsGXZAmz+yQJ88awRuOl/tmD9gQ4sfXEbTvT4s93VnNDi8mPp37ehqdsPdyCI3U0ufPXsUdj8kwXYdOeF2LD0Qpw5qgQHWt3Y09KDvSd6oGq05VFf/qCG3c092H68G1f/aT2mjnBg850LsOknoeM3eYQDHxzqRECl45ZOhw8dgkUS8PHHH8X9mL/+91OorSxPX6dISlCwmSM++OADnHnmmTjzzDMBAEuWLMGZZ56Ju+++GwDQ1NQUCTwBYMyYMXjttdfw1ltvYdq0afjtb3+LP//5z0W57Ym7d0azw62g2iGD7ZNrzzJM1hfzE0IIGdq2o1345Gg3Drd7sLelB81dPpRZJRzv9GF3Sw9u/Mw4VNtlNHWHAqwWV3EHnM3d/t7AO4Aah4zlV50Bqyzgk6NdaO7ywSbz+Oxv3sXilZuxp8WNcquEw+1eCjj78Ac1fNrkQlOXDwdbPdjT4sbPXt2JIx1emEUON/71A9z41y34y9roVWoJIUOjYDNHnH/++TAMY8DPypUrAYSuwK9evXrAYz788EMEAgHs378fN9xwQ8b7nW09/iB2Hu9Gh2dgoAkAIsdG1lkQQgjJTYZh4OlNoQuqF02qQrlNglkKFbRxmkVwDItSi4jlX5iKGoeMEz0BLH1xG5q7izPgPN7lw9IXP0FrTwAjnCYsv2oqKmwSgpoOnmXhMIswiTxOr7EBANbsbYPEc6iwyjjc7sWelp7I9mDFKly1vtkVQLXDhPf3twMAZtSXwCTxMAk8Lp5cCwB4b08rDrd7stldQvIWBZskb/X4g9hx3IUubxDV9oGBJgBIAguvosEfpPLghAzK44n94/fH39bni69tEt544w2ce+65cDqdKCsrw2WXXYb9+/dHbbt69WowDIPXXnsNZ5xxBmRZxpw5c7B9+/YBbd98801MnDgRVqsVn//859HU1BS5b/PmzbjoootQXl4Oh8OB+fPnY+vWrUn1n8T28dFu7DjugsAxuPyMGkgCC2vv1gR2kwCrzMMdUFFulbD8qqkY4TShtSeApS9+guNdxbWW7minF0tf3IY2t4K6EhMeuGpqZA2rO6DCKp+sPLtwUjUAYO2+NuiGAZFnUWGV0djhxd4iDjhPBpp+VNtl9PiD+ORoFwBg1ugymAUOHMvgrNFOnDXKCQPA/24+ktU+DykPxvB/vfkmFlwwH7WV5airqcIXF12JAzHG8PfefRcWScAbr7+OWTPORKndivPPOwc7dgwcw9/6179w1hlTUVnqxJWXXdpvDN/ywWZcdvHnMaq2GjUVZbj4ogvx0Yc0hmcSBZskL7l6A02XL3agCQASz0FRdQo2CRmK1Rr754tf7N+2sjJ224sv7t+2vj56uyR4PB4sWbIEH3zwAVatWgWWZXHVVVdB12OfMP/4xz/Gb3/7W2zevBkVFRW4/PLLEQyezHbwer34zW9+g7/+9a9477330NjYiB/96EeR+3t6enD99ddj7dq12LBhA8aPH49LLrkEPT09Sf0NZCDDMPD0xsMAgM9ProZZ5GGTT27HwrEMqmwSPEpoSURZb8BZV2JCm1vB0he34WinN2v9z6QjHV7c+eI2dHgUjCo14/6rpqLUcnLPXK+iodouRSqmfnZiBWSBRZs7gN3NofesyLOotMlo7PBhd3MPlCJbi+hVVOxs6saJHj9qems8rNvfDt0AxlZYMKJUjrz3HGYBl02tAQC8v68NB9tyd3bTXOqM+SNd/ZV+bU0ja2O3veKy/m1Pa4jaLhlerwffu/U2rFm3Aa++8SZYlsVXv/KlQcfwnyy9A8t/+Wu8t249yssr8OWrrhowhv/+dw/iz08+iTdXvY2jR47gzjv+M3J/T48b11x7Ld56ezXeeW8txjU04AuLrqAxPIOoGi3JO92+IHY1udDjDwWag+2HxLEMNMOAV9HgNGewk4SQlPviKUHvE088gYqKCuzcuRPWGAHsPffcg4suuggA8NRTT2HkyJF48cUX8ZWvhE6+gsEgVqxYgXHjxgEAbrnlFtx3332Rx3/2s5/t93yPPfYYnE4n3n33XVx2Wf+TMpKcrY1d+LS5ByLH4ksz6uBXVZSa+w/YJRYRPMsiqOkQOBYlFhEPXDUVy17ajsO9AdjPF03FqNLCHegPt3uw7KXt6PIFUV9mxs8XTYXDdHLvzKCmg+cYlJhPVup1mEScNaoE6/a3Y83eVkyssQMABI5FpU3C0c7QLNZpVbai2Bal7/Zo4WKCALBmbysAYFZ9KcwiD6n3WFgkHvUVFswbV4Z1+9vxv5saceclE7PW/3y36Kov9Pv90ccex+gRNdi1ayesluhj+NJly3DhggUAgMf+8gROG1uPV15+CV/80pcBhMbw//rjwxjbO4bfeNNNWP7A/ZHHn3/BBf2e778efhR11RU0hmcQBZskr3R7Q4GmO6CiyjZ4oBnGgooEETIktzv2fdwpWwedOBG7LXvKCeuhQ0l36VR79+7F3XffjY0bN6KtrS1yNbyxsRGTJk2K+pi+20GVlpZiwoQJ2LVrV+Q2s9kcCTQBoKamBif6/H0tLS1YtmwZVq9ejRMnTkDTNHi93n4F20jyDMPA//TOal4ytRpOs4AWlwarLPRrZ5MF2HpTaUvMoZk8p1nE/VdNxbKXtuFQuxc/eXEbfr5oCkaXWTL+d6TbwTYPlr20DS6/irHlFvzsyimwm/ofI7dfhV0OzQqHyQKHz5xWgXX72/H+vnZ887yxkUygkwGnF4YBTKgu7IDz1O3RwoFmh0fBjuMuAMD0OiecJiFybmEReZhFHldOq8X6/e1Yf6Ad+0640VCZXHZGOnk7umLfecoY7jt6PHbbU8Zw356B+44ma9/evfjZfffig02b0N5+cgw/0ngEEydGD+Jnz54T+XdpaSnGn3Yadn/6aeQ2s9kcCTQBoLqmBq2njOH3/fRurHn3PbS20hieDRRskrzRN9CstElxBZpAaN1mly8IwzDifgwhRceSwAl6utoO4fLLL8fo0aPx+OOPo7a2FrquY8qUKVAUJennFIT+J+wMw8AwTu76ff3116O9vR2///3vMXr0aEiShLlz5w7rNclJmw91YN8JNySexRfPGgl/UIMscJH1mmEcy6DKLmF3sxslfSYvHSYB9y+airte2Y4DrZ7eGc4pGFOee8FAsva3unHXS9vRE1DRUGHFfVdOjqzJ7Msb1DC63AyW7f89N/+0cvzXKg4dXgU7j7swZYQjcl8o4JRxrMsLAwYmVNsKcl/q/lXrTf2W3ry/rw0GgNOrbSgxi7D0ee9xLINSs4gei4r5p1Vg9Z5WPLPpMO6+bHIW/ooh5MEY/uUvXIW6UaPwx0dXoKamBrqh4+wzpyOYyjEc/cfwb3/jP9DR0Y5f/fZBjBo9CrwgYsH5n6ExPIMK9xIWKShdXgU7jncnHGgCgMSz8Cka7ZFFSB5rb2/H7t27sWzZMlx44YWYOHEiOjs7h3zchg0bIv/u7OzEnj17Yl5Bj+b999/H97//fVxyySWYPHkyJElCW1tbUn8D6S+0VjM0u3DZGbVwmkX4FA02mYcsDAx4SswSOI4ZUNTGbhJw/5VT0VBphcuv4icvbsf+1kFm6vPI3pYe/OSlbegJqDityoqfLZoSNdBUVB0Cz8BpEgfc5zSLmF7nBACs2TfwvStwLKpsMo53hdZwBtTCqnEw2PZowMljcs64cnAsA7PY/71nNwnQoeOrZ48CywCbD3ViTwut90tUe3s79uzZjduX3okLPvtZnD5xIrriGMM3bdoY+XdnZyf27d2LCaefHvfrbli/DjfdfAs+f/HFmDRpMiRRQjuN4RlFwSbJeZ29KS5eRUs40ARCRYICQR0+pbC+QAkpJiUlJSgrK8Njjz2Gffv24e2338aSJUuGfNx9992HVatWYfv27bjhhhtQXl6ORYsWxf2648ePx1//+lfs2rULGzduxDXXXAOTyTSMv4SEbTjQjgNtHpgEDledOQIA4Fc1lFmkqO1tMg+7zMPtH7gswirz+NmVUzChyoaegIqfvLQNe/M8INjd3IO7Xt4OT0DD6dU23HfFlAEzvmHugAp7b6rxqcwCj1n1pQCAdfvaoOnGgDZ8n4Dz06aegimqN9T2aK09AexqcoEBMLO+BCLPDrjQYZE4iByLcpuI8ydUAkDkIgmJX3gMf+Ivj2P/vn1Y/c47uOM/fzzk45bffz/eeftt7NixHTd+8xsoKy/H5VdcGffrjmtowP8+/TQ+3bULmzdtxDcXX09jeIZRsElyWodHwY4mF/yKhqohigHFwrEMdBjwFciXJyHFiGVZPPvss9iyZQumTJmCH/zgB/j1r3895ON+8Ytf4NZbb8WMGTPQ3NyMf/zjHxDFgbM/sfzlL39BZ2cnzjrrLFx77bX4/ve/j8rKyuH8KQSA3mdW8/JptXCYBOiGAY5lYJGip3GyLIMquwxvjLHcKvG478rJmFhtgyeg4a6Xt0cqsOabXU2uUKCpaJhca8e9V0zul955Kl9QDVVmZwd+R8oii2mjHLBJPLp8QWw/1h31OcIBZ1N3aIYz3wPOeLZHe793VnNSrb13fSY3MNgUeZhEHj5Fw9d6Zze3NnZiV5MrI39HoWBZFiv/+jQ+2vohzj5rOm7/8Q9x//JfDvm4n/38fvz4h0tw7pzZaGlpxvN/fzGhMfyRPz2Grq5OnDNnFr65eDG+892bUVFBY3gmMUbfxGZSVFwuFxwOB7q7u2G327PdnQE6PAp2Hu9GQNVRaZOH9VzNLj9GlZowoTr3/k5CMsnv9+PgwYMYM2YMZHl4n6tctnr1alxwwQXo7OyE0+nM2OsOdnxTPeYO9/kUVcfGg+0QORZmMbMlHNbsbcWv3twNs8jhL9edDavMw6uoUDQdZ9eXRk2jBUJr9z9o7IBTFmMWs/EqKu57dSd2HHfBJHC494rJkSqs+WDH8W7c+4+d8AU1TB3hwN2XTYp5PAAgoGpw+YOYMbq0X3XavrYc7sB/rdqHd/e0YuGkKtzy2fExn0/TDTR3+1DtkHF6jX3Q185VLn8QO4+HqtYPVkzwh89/hD0tbnznM2MxY3QpxlSY0VBpG9Bub0sPDrV7UG034Q9v78W/drZg2kgHfr5oarr/lAEMVYHRcwKjRo+GVMBj+HvvvouLP7cAx1paUzqGa7oBlmEGvXiTyXG8GNDMJslJ7e4Adh7vhqIaww40AUDmWXR5g6BrK4QQkl2abuB/N4VmNRdNHwFrb+qnT9Fgl4VBg5tQKq0A9yAVxs0ij59ePhlTRzjgC2q455Ud2HE8+mxertl2tAv3vLIDvqCGaSOHDjSBcBVaAfYoKbRhTpOIGaOdAIB1+9uharFrGHAsg2qHCc2uAD5tcuXdDGe3L75As9nlx54WN1gGmNdQDh1GzADEbhIQzj7+ysw68CyDj492Y1uMWWJCyEkUbJKc0+YOYGeTC4pqoMIWfe1OoiSeg1/V4A9SkSBCCMmmNXtbcaTTB6vE44pptZHbA6qOUsvg6XEsy6DaLsMXHHw7K1ngcPdlkzC9zhkJOLcd7UpF99Pm4yNd+OmrOxFQdZxZ58RdcQSaAODXhl5mYpF4NFRY4TQJ6Amo+OTo4EES13ucm12hNY35UvOg2xvEruMuuP1Db48WTqGdMsIBuyyAYxiYhejBpkXiIXEs/MHQsb5oUhUA4OmNh+kiNiFDoGCT5JTWngB2HndB1VIXaAKh7U8CQZ3WbRJSJM4//3wYhpHRFFoytL6zmledOSIykxRPaluY3SRA5FkoQ1QYlwUOyy6diLNGORFQdfz01Z34+EjXsP+GdNh6uBP3vboTiqpj5ugSLLt0UlxbkARUDRLHwmGOnj4bZhI5iAKHOWPLAABr9rUO+dzhgLPF5cfOpu6cDzgT3R5tzd7QMTivoSJ0HAUWshj9tNgscDBLXOQcIjy7ueO4a8jAnSTnM/PnwxMI0hheACjYJDnjRE/oC03XDZRbUxdoAgDLMDCoSBAhEXQ1Pj3ouA5u9e4TON7th03mcdkZNZHb/UENJpGNWRyoL3tvKm2PPzhkW4nn8JNLJmHm6BIoqo77Xt2JrYeH3m4hkz441IGfv74TiqZjVn0p7rxkYsz1qKdy+1XYTQJsQwTpJoGDzLOYNSZUlXb9gfYBW8hEEwo4TaELwU3d8CqDzyhnS6Lbox3v8mF/qwcsA8wdVwZ/UIdZ5GIG+CzLoNQiRlKKy60SPj+lGkD2ZjcN0FiTLjSOpxYFmyQnnHD5seu4C4YOlKU40AzjGBY9vqFPTggpZBwXOpmiDa3TI3xcw8eZnKRqOp7dfAQA8MWzRvYrSuQLarDJQlyzeQwTqkrr1+K7eCjyLO68ZCJmjymFoun4+es78cGhjuT+iBTbdLAd97++C0HNwNyxZbjj4tMhcPGfmvnV+Cq1izwLi8SjvtSMUrMIT0DDh41dcb1GOOBsc4cyjzyDrJfNhmS2RwvvrTm9zgmHSYCiaVH3KO3LLgswcDIQ+dJZIyFyLHY198R9LFOC5WEA8Pt8mXvNIuP1egEAgjB4xgCJT2bLzxESxQmXHzubXGDAoMwafznrRMkChy5fqEhQMluoEFIIeJ6H2WxGa2srBEEAy9I1x1TRdR2tra0wm83gefp6PdWqT0+g2eWH0yTg0qk1/e5TtKHXa/blMAuQODaU/hhHgCpwLG7//On49Zu7sf5AKMBbevHpmDWmLOG/I1XW72/Dr97cDVU3cM64MvzocxPAJxJoBjXIPBezAu2pnCYBrT0BnNNQhn980oQ1+1ojM51DCQecTd0+7GpyYWKNPa6U53Tr8CjY2eRCoHd7tHit7U2hPbehHACg67GLA4VZJB4SzyKg6pAFDmVWCRdPqcbLHx/H/2w8jDNHOTNybsGwLCCY0dYa+htkkwkM6JwmXnrvOSBnDPz/NgwDXq8XJ06cgNPppIuGKZL9kYIUtZbeGU2WYVCSwIlGMiSehVdR4Q/qMIk0gJDixDAMampqcPDgQRw+fDjb3Sk4LMti1KhRdEHrFEFNx3Mf9M5qzhjZr/CNphvgGAbWBIIXm8TDbhLQ41MhWeMbzwWOxX8unIDfvLUH7+9rw/J/for/XDgBc8eVJ/bHpMD7+9rw63/thqYb+Mz4ciy5aAK4KHtkDsYdUOE0C3EfN7PEw4CB88ZX4B+fNGHjgQ4oqh53yi7LMKhxmNDcHbpAPLHGntD/War12x4tgUDzSIcXh9q94FkGc8eWQ9V0cBw75HmBWeRgkXj4Alrk/fvFGSPxxo5m7D3hxuZDnXEH78PFWkqge4ATJ1opzExQONiUBnnfO51OVFdXZ7BXhY2CTZI1zd1+fNrkAssyKDGnN9AEQmlEnV4dXkWlYJMUNVEUMX78eEqlTQNRFGm2OIp/72pBa08AJWYBF0/pfxLnC2qQe0/k4xVOpW3rcSXUD55j8ePPTQDHAO/tbcMv39yNH38OOKchcwHne3ta8du3dkM3gPMnVOC2C09LONAEEAmy4r2wYRI58ByLsRUWlFsltLkD2NLYiblj45/dZRkG1Q4ZzS4/dh7vxsQaO2xy5lMN292hKrnJbI+2tk8KrVXm4QmokHkWpiEq/zIMg1KziH0eN0p6bysxi7jsjBq8sPUYnt50GGfXl2RmdpNhwFlLYehOQM+ttOZc5/YFYRJZnD7CGfV+QRBoRjPFKNgkWdHU7cOnTS5wLJuRQBMIFwkCFQkiBKEZuFM3qyYkHRRVx996ZzW/PKNuQNqrT9FQYRfjnmELc5gESHxoO4p4tggJ41gGSy6aAJZlsHp3K3715qf4oT4BnzmtIqHXT8Y7u0/goX/vgW4AF55eie99dnxSgWbob2bjTqEFQkWCJJ5DUDNwbkM5XvroGNbubU0o2AR6A057KOAMp9RmMuBs6w00k6labxjGySq040P/3/6gBruZj+v9ZzPxgGH0W45z1Zkj8fq2Zhxo9WDDwY6Ej+dwMCwLsJk5hyoUBgeA4+j7L4Po8ivJuONdoTUffAYDzTCeYeCKo4IhIYSQ1HhzRzPa3ArKrSIWTh6YmqZoWlLfBVaJh8MswJ1EwRqOZXDbhafhwtMroRvAb9/ajXd2n0j4eRLx710t+N1boUDzc5Oq8P0Lkws0AaDHr6LELMKSQJaOwLGwijwCQQ3njQ/N5G461BGpsJoIlmFQY5fR5Q1ix3FXxr5X+26PlkzV+sPtXhzp9EHgGMwZG0p5VTQdJUMUBwqzSjxkgUOgz7Y7DpOAy3v3i31m42HoVMmUkH4o2CQZdazLh13NLogcB2eGA00AkAQOLp8KXacvA0IISbeAquH5LaFZza/MrBswe6TpBniWTWrtH8MwqLTL/U78E8GxDL5/4Xh8blIVdAP43Vt7sGpXS1LPNZQ3dzTjv1bthQHg4inVuPmCBrDDSLdUNA0VcVZe7ctp5hHQdIyvtKLKLsEf1PFBklvBML0znD3+IHYed6E7zdXeU7E9WrgK7YzRJZFqyAYMmON8/5mEULq395Q9RxdNr4VZ5HCo3Yt1+9uT6hshhYqCTZIxx3pnNCUu/up5qRZOufKrlEpLCCHp9s/tzej0BlFhk7BgYtWA+31K4us1+3KYBMgCm9TsHBCaobv5ggZcPKUaBoDfr9qLf+1sTuq5Yvnn9ib88Z19MABcNrUGN80fN6xA06eE0oaT+R41izwMIxQontsQSiMNp5Umg2EYVNlkuP0qdjWlL+BMxfZofVNow397UNPBc2zcadgMw6Csz36bYTZZwJXh2c1NjdDogjYhERRskow42unFruMumBIo054O4bLlp16VJIQQklr+oIYXthwFAFw9sy7q/pHeoAqniU9ob8m+LCKHErOYVCptGMswuGn+OFw2tQYGgD+8vQ//3N6U9PP19eonx/HI6v0AgCum1eLbnxk77AIy7kBvCm0SAboschB5BkFNj6TSfnCoE14l+ePHMAwqbVIo4DzuQrc3tQFneHs0gBnWPtz7Wz1o6vZD5FnMqg+l0AZUHRLPwZxAOrJVFsAwJ/fbDLti+ghYJA5HOryRIkSEEAo2SZoZhoEjHV582tQDs8jBnsVAEwh9KcIIXRkmhBCSPq9ta0KXL4hqu4wLT6+M2iao6yixJB9AMAyDCpuEwDCzVRiGwbc/MxZX9M5OPbJ6P1775PiwnvPlj47hT+8dAAB84cwR+Oa5Y4YdaBqGgWBvCm0yzL1FggJBHWPLLah1yFA0HZsPJZdKGxYJOAMqdjZ1o8ubmkrXLb2BJgsmoX1YowkHgGePLolUpA8ENVjFxC52WCUeksDCH9QH3H7VmSMBAP9Ls5uERFCwSdImHGjubg4Fmtkojx4NzzFwpXltCSGEFDOvouKFraFZza+eXQc+ysm8qungmVDRmuFwmASYBG7YFxEZhsE3zx2DL5w5AgCw4r0DePmjY0k919+3HsWf1x4EAHx5xkjcMK8+JVti+Hor7zrNyX2f8lxofaxf1cAwTKQi63BSacPCAadX0bDjuGvYAWdzd+r24Y5WhRYAApoOpzmx958shI5htMr2l59RA5vE41iXD+/uSW/BKULyBQWbJC0Mw0Bjhxe7W9ywiHzOBJoAIPNUJIgQQtLp1U+a0ONXUeuQcf6E6LOavqAGk8jBIg1vTzuLxMM5zFTaMIZhcMO8enx5RmiG6s9rD+LvvUFzvJ7/4AieXHcIQCjQvnbO6JTtvegOqCixiJHiNskoMYtQeosqndu7v+iWw53wpOj4VVgl+HsDzk5PcgFnU7cPu5q6waVoH+69J9w40ROALLCYMbqk332JHstY6zbDz/WFs0LvnWc3H4GqJVe8ipBCQsEmSblwoLmnpQdWiYdVzq3tXCWBRUDVaL9NQghJA09AxYsfhmYEvzZrVMztPXyKhhKzEHXWM1GVdglBTRuwji4ZDMPg2jmj8dWz6wAAT647FKmoO5RnNzfivzccBgB8fdYoXDM7dYGmYRhQdT3pFNowWWSB3i6NLjOjrsQEVTew8WBqqqiGqwT7FQ07mlzoSDDgDG+PJqSwan14VnNWfVmkGFCoOBADOYH1mmHhdZvRtjm5dGoNHCYBTd3+tG+nQ0g+oGCTpJRhGDjc7ukNNIWkytmnm8ixUDQqEkQIIenwysfH4Q6oqCsx9UtZPJWqGykLJkJVabmUXURkGAbXzB6Nr88aBQD47/WH8ezmxpjtDcPA0xsP4+mNoTbXzRmNr/U+NlUiKbRx7gkZi0ngIHAMFFU/JZU2tUVtKu0yAkENO493o90diOsxfbdHS1UxQd0wIus1w0WRACAQ1CHzHMxxVqLtK7zfZrTZTZPI4Ut9ZjeDNLtJihwFmyRlDMPAoTYP9rS4YcvRQBMInUQYMJIulU8IISQ6t1/FSx8NPasZ1HRwHJP0lienMos8SiypSaXt62uzRuG6OaMBAE9vbMTTGw/DMAxwLAOJZ8GxDAzDwF83HMazm0Ozn4vn1ePLM+tS2g8gdGxLLWKkuE2yzCIPmeciRZXO7Q3APjzShR5/ausZVNpkKKqBnU0utA0RcB7t9KZle7RPm3vQ5lZgFjmcNepkCq1f1WCV+KRm1mWBg03mY64T/vyUapSYBZzoCeDfadq7lSRH4BiYkrjAQJJHwWYOefjhh1FfXw9ZljF79mxs2rRp0PYPPfQQJkyYAJPJhLq6OvzgBz+A3+/PUG/703UDB9s82HvCDYdJSNkJRLoILIcuX2qq5RFCCAl56aNj8CoaRpeacU5Decx2PkWDWeBgGWbg1FeFTYKq6ylJpe3ryzPrsHhePQBg86FOGAAaKi0osQhoqLRANwxsbewCAHzj3DGRNXupZBgGgrqBCqs87OfiWAZWmY9UU60rMaO+zAxNN7D+QGpSafuqsElQNQM7j7vQ2jMw4DQMA0c7Q1Xr07E9WjiFdvaYUoj8ydNeRdXhMCV/rlJqERHQogebssDhSzNCFxz+9gHNbuYCiWdR5ZBw1ugSVNglKKo+rC1/SPxyOyIoIs899xyWLFmCFStWYPbs2XjooYewcOFC7N69G5WVA4srPPPMM7jjjjvwxBNPYN68edizZw9uuOEGMAyDBx98MKN9Dwea+1tDgeZwChdkisSz6PGp0HQj5pV3Qggh8XP5gnjl49B2IV+fPQrsIGsVfUENI0pMKVmvGeY0iZFU2lR/D33hrJGotEv4ysw6rFx3CNc+sREunwq7icf1c+vxtxvn4IUtRzF3XOwAezi8igazmHwV2lM5TSKaun2R388bX4FD7Yexdm8bPjepOiWv0Ve5VUK7O4CdTd2YBEdk3Wko0PSlrWq9phtYty8UQA9I6WYA8zAujFslHizDQDeMqO/1z0+uxt+3HkWbW8G/djTj0jNqk34tMjwSz2JkqQkr3t2PlesORT67i+eNwXfPHweJZjrTimY2c8SDDz6Ib33rW1i8eDEmTZqEFStWwGw244knnojaft26dTjnnHPw9a9/HfX19fjc5z6Hr33ta0POhqaarhs40ObGvhM9eRNoAqGrjlQkiBBCUufvHx6DL6hhbLkFc8aWDdpWM4yUBU5hJpFDmUWC25+e2YovzhiJp9Ydwh/e3geXL/QaLp+KP7y9D0+tP4RFvVumpIM7oKLMIkaK2wyXSeQAA5FZ4HBV2o+PdqE7TVuDlVklGDqws6kbJ3r8GdkebWeTCx1eBVaJx/Q6Z+R2RdWHnU5pGWTdJgCIPIuvzAzPbh4d9l6wJHlOi4AV7+7Hf63q/9n9/aq9eGT1fprhTDMKNnOAoijYsmULFixYELmNZVksWLAA69evj/qYefPmYcuWLZHg8sCBA3j99ddxySWXxHydQCAAl8vV72c4TgaabpSYpbwJNAFEiiPQAEMIyRepHsNTqcur4NVPQrOa1wwxqxmuApqO5RblVglB3Uh5Ki3HMnCaBKxcfyjq/SvXHYLTLKQlU0Y3DGiGgfJhVqHtyyRyEPlQsTwAqHWaMK7CAt0A1u1PbaGgvsqsEmAw2HXchb0tPWnfHi2cQjt3bBmEPrPoAVULFQcaxnmLLHCwy8Kg+7teNKkKFTYJHV4Fb2xvTvq1SPIin93e7YhO9eS6g+BZCofSiY5uDmhra4Omaaiqqup3e1VVFZqbow9OX//613Hffffh3HPPhSAIGDduHM4//3zceeedMV9n+fLlcDgckZ+6uuEVMOj2BXGozYtSszTsggWZxjAMwAB+hdZREELyQ6rH8FR6YesxBFQdDZVWnF1fOmhbr6LBzPOwpOECpdMswCxyKa82zrMMun3ByKzIqVw+Fd0+FXwags1wCm0q1zKaBA4yzyMQPPkdGE4zXZviqrSnKrWIYMBgX6snrdujabqBdftDKbTnju+f3hxQdVhlftgXB0otIgJq7PMIgWNxde/s5v9tOUqFCbMgns9uqgtjkf4o2MxTq1evxgMPPIBHHnkEW7duxd///ne89tpr+NnPfhbzMUuXLkV3d3fk58iR+PYNiyV8tTXfAs0wkaMiQYSQ/JHqMTxVOjwKXt/WBCA0qznUvpK+oIYSS3pmAWWBQ1kaqtKqugGHSYA9RkEZu4mHw8RD1VM7owr0ptBaU5dCC4Rme2wmrl+gFE6l3X68G50J7o2ZqBKLiJFOU1qr1m871o1uXxA2mccZIxz97lM0bdhbyAChVFqGCQW2sVx4eiWq7BK6fMHI54RkjqobsMmDf3bTNbNOQijYzAHl5eXgOA4tLf3LY7e0tKC6OvpC/bvuugvXXnstvvnNb2Lq1Km46qqr8MADD2D58uXQ9ehX2SRJgt1u7/dTzCSehduvQqUqcYSQPJCrY/j/bTkCRdMxocqGGX22lohF13U4Urxes69ymwTNSG0qraYb6PIFsXjemKj3L543Bl3e4KBBRzJ0w4Cu6yi3pC6FNsxhEvtVSa2yy5hQZYNuAO+nMZU2bKiLEsMVTqGdN668XyEqwzAAAym5UG6ROJjE2Os2AYDnWHz17NCeqy9sPUrLdzLs1U+OY83eVlw/tz7q/YvnjYEa47yZpAYFmzlAFEXMmDEDq1atitym6zpWrVqFuXPnRn2M1+sFe0qOOceFBs5Ur1UpVLLAwU9FggghJGlt7gDe2BFa7vH/5oweMoBQVB0Cz6Z1e6xQsToOnhSn0nZ5grhx/ljceuH4yCyJ3cTj1gvH48b5Y9HlTX0qnjegwSLxsKd4OxAgFGwxTP9zhnC66dp96Q8200nVdKzfH65C2z+FNqgZEHk2JcGmxPeu2xziPOKCCZWodchw+VW89gnNbmbKa58cxyOr9+MX/9yNb54X/bP73fPH5VXNkXxERzdHLFmyBNdffz1mzpyJWbNm4aGHHoLH48HixYsBANdddx1GjBiB5cuXAwAuv/xyPPjggzjzzDMxe/Zs7Nu3D3fddRcuv/zySNBJBidwLIKaAV9QoxQKQghJwvNbjiKoGZhca8e0kY4h24e3JUnHes0wWeBQZhVxrNOf0jTNgKrjaIcP18wehZsvGIdunwqHiUeXN4ijHb5B1+4ly6OoGFliSmkKbZhJ4CByLAKqHnn+c8aV4y9rD2LncRfa3YFQQZ889PHRbvQEVDjNAqbU9n9f+oMaZJ4fViXavkotIpq6B9/jnGMZfG3WKPz2rT34+4fHcOkZNRTgpNnLHx3Dn9ceBABMG+lAc1fos/vdC8bB5VPhMAlQdZ22PckAeqfniKuvvhqtra24++670dzcjOnTp+ONN96IFA1qbGzsN5O5bNkyMAyDZcuW4dixY6ioqMDll1+O+++/P1t/Qn4yAG9ABWzZ7gghhOSXEy4//tU7q3nNrKHXagKAT9Ewusyc9v2Nyy0SjrR7Y+6BmKyAqqPFFUCbWwHPMmjtCaQ8dTZMNwzohoFS6/DXFkZjEjhIAtcv2KywSZhYY8euJhfW7mvDldPTt51LOoVTaM8ZVz7gvRZQdVTaxZS9B60SD45hhty3+7zxFXjugyM42unDKx8fj6TWktT7+9ajeLK3+uyXZ4zEtXNGQ9EMtLgC2N/qhl0WUGGTIFKCZ0bQUc4ht9xyCw4fPoxAIICNGzdi9uzZkftWr16NlStXRn7neR733HMP9u3bB5/Ph8bGRjz88MNwOp2Z73gek3gW3TEqlBFCCIntbx8cgaobOGOEA1NHOuN6jA49LSmhp7KbBFgkHt5AepZJaLqBgKqnLdAEAE9AhVniU1qFti+WZeAw8QP2fzyvt1DQmjRXpU2XoKZjw4HoKbTh+x0pKA4UZpF4mER2yFRajmXw9VmhAPOlD4+lbT/YYvf8liORQPOrZ9fh2lPS+8MZbSRzKNgkRU3iObgDar8iCYQQQgbX3O3Hvz89AQD4+uz4ZmgCqgaRY2GR0p+2Jgscyq0SPHlcjMWjqKiwipD49B0vmywMqKB7TkM5GAC7W3pwwjV4emgu+rCxEx5FQ6lFxMSa/kW0DMMAw6SmOFCYyLOwDbHfZtg5DeUYXWqGR9Hw0sfHUtYHEvLs5kb89/rDAICvzxqFa2YPvY6cpB8Fm6SoSQJLRYIIISRBz33QCE03cGadE5Nrh16rCYRSaE1pXq/ZV6lVjKSi5htNN6AbQGkaqtD2ZRY5MOhfJKjUImJK71Yh+VgoKDwje25D+YAUakXTIXJsytZrhpVZRSja0OcRLMNELs688tFxuHy0v2MqGIaBpzcextMbGwEA180Zja/NojTlXEHBJilqAsdC1Qz4U1y1kBBCCtXxLh/e7p3VvGb26Lgf51c1lFlEsGlerxnmMAkwpzGVNp28igprGlNow0wiB5FnBxQ3Cqef5lsqbUDVsPFgB4CT6cB9+YOhgjCpDjatEg+eZeNKq54ztgxjyy3wBTW8+CHNbg6XYRj464bDeHZzaN/hxfPq8eWZdVnuFemLgk1CEFobQwghZGj/u7kRugHMHF2CCdXxV1fTDWRkvWaYxHOosIpwK/k3e+QOqKiwShD59J6myTwHubdIUF/zxpWDZYB9rW40dfvS2odU2nq4E76ghgqbFPW9GVA1OEx8yi94WCQessjFlUrbd3bz1W3H0eVVUtqXYmIYBp5afwjPbzkKAPjGuWPwhbNGZrlX5FQUbJKiJ3FUJIgQQuJxpMOL9/aEKn0mNKsZ1CBx6d1fM5pSiwTdQFoL+aRauK/pqkLbV6hIkIDAKUtJHCYBZ/QWfVqbR7Oba/adTKGNtlYvqBlp2epM4Fg4TDy8wfjOJWbVl6Kh0gp/UMffaXYzKYZh4C9rD+KFraHjd+NnxmJRnlZPLnQUbJKiJwkc3AoVCSKEkKE82zurOXtM6GQ5Xr6gBrPEwZzhPe0cJgFWiYc3jwoFeQKZSaENs8k8gvrA779zw1Vp82Tdpj+oYdMgKbSGYYBlQutU06HELEY9jtEwDINremc3X9vWhE4PzW4mwjAMPLbmAF7++DgA4Lvnj8NlZ9RmuVckFgo2SdGTeRb+oAYvrdskhJCYDrd7Imv4romzAm2YPxiqDpqp9ZphIs+i0ibBnUdLJdyKigqbBIHLzCmaWeTBscyAQkrzxpWBYxkcbPPgaKc3I30Zjs2HOhBQdVTb5agXQgKqDpFnU1qJti+rxINnWKhxXrieMaoEE6psUFQd/7f1aFr6VIh0w8Cj7+7Hq580gQFwywUNuHhKTba7RQZBwSYpejzHQtd1+KkiLSGExPTMpkYYAM4ZV4Yx5fHPahqGAQOAPQ3pi/EosYTSUfMhlVbTQ7NvpZb0p9CGmQQOIsdCOWXdpk0WML3OCSA/CgX1rUIbLYU2oOqQBQ5ymraSCe23ycVd3b7v7OY/tzeh3R1IS78KiW4YeOSdffjn9mYwAL5/4XgsnFyd7W6RIVCwSQgAgKEiQYQQEsOBVjfW7W8HAyS8pUBA1SHxmV+vGRZOpc2HMd4dUGEVhYwWUpIFFpLARb3gel6epNJ6FRVbDncCOFlJ91SBoAaHSUjb7LrAsXCa4ttvM2x6nROTa+0IakakyA2JTtMN/OHtvXhzZwtYBvjBRadhwcSqbHeLxIGCTUIQqlrY5aM1E4QQEs0zm0L71503vhyjyywJPdYX1GCR+LStlRuKwLGosElw58G6TU9ARYVdzFgKLRCaYSsxCwMq0gLA7LFl4FkGRzq8ONzuyVifErXpYAcUTccIpwljyqO/P4O6Dpuc3gseTosINYEZdIZhcE3vxZs3dzTjRI8/XV3La5pu4Per9uDfu06AZYAlF03ABRMqs90tEicKNgkBIPEsvAFtQBoRIYQUu70tPdh4sAMsA3w1iY3S/UENpWYxampjppRaRLBMbqfSqpoOlmFQapEy/tpWWYBqDPz+s0o8zhpVAiC3ZzfXhqvQjo+eQqsbBjiWSfn+mqeyijw4jkmo4ODUkU6cMcIBVTfwtw9odvNUmm7gwbf24J3drWAZ4McLT8f80yqy3S2SAAo2CUEo2PQH9YTSXwghpBiEZzXnn1aBuhJzQo81DAOGYcBmyk4KbZjdJMAqCjldKMijaLCZeNjTPPsWjUngwIEdUCQIOJmWunZvG4wo92ebO9AnhTZKFVoAUFQdIsfCLKb32Fp6Ky4nei4R3nfz37ta0Oyi2c0wVdPx63/txnt7W8GxDG7//OmRKskkf1CwSQh6iwQZRtwL+wkhpBh82uzCB4c7Q7OaZyc+qxkuymLN0nrNMIFjUWEXc3rdpkcJosIqgc9gCm2YWeQgCgwCwYEzcrPGlELkWBzr8uFgW+6l0m480A5VNzCq1Bwzxdsf1CAJHGQhvceW51g4LULC5xKTax04s84JTTfwt81H0tS7/BLUdPzqzd14f18beJbB0otPx7xxFGjmIwo2CenFMIA7EMx2NwghJGc8szE0q/nZ0ytR6zQl/HifElqvme70xXiUWiSwDBP31hSZpGo6OIbNaBXaviSehUng4FcHBklmkceM0b2ptDlYlTac3jvYjFdA1VFiFjKSyu00idCSmAEOz26u+rQFx7t8qe5WXglqOn75xqdYf6AdPMvgzksmYvaYsmx3iySJgk1Cekkchy4vBZuEEAIAO45348MjXeBYBlcnMasJAD5VQ5klu+s1w+wyD5uJhycHl0u4AyqsMp/RKrR9hYoEiVGLBAEnU2nX7GvNqVRaly+Ij450AYhdhRYANEOHNUNb71gkHnyC6zYB4PRqO2aOLoFuAM9ubkxT73Kfoup44PVd2HiwAyLH4q5LJ+Hs+tJsd4sMAwWbhPSSBBa+oIZAlCu7hBBSbMKzmgsmVqHaLif8eMMwwAAZO8kfCs+xqLBK8OZgVVpvUEWVTQKXpm054mGR+KhrNgHg7PpSSDyLFlcA+064M9yz2DYcbIemGxhTbsHIGOuJdcMAg/QXBwqzSjzMPA9vEhc1vt5bgOvdPa040ulNdddyXkDVcP/ru/DB4U6IPIu7LpuEs3pn1Un+omCTkF4SzyFARYIIIQSfHO3CJ8e6wbMMvjJzZFLP4Q/qkAQ26+s1+wpVpc2tVNpgbwqt05ydFNowk8CBBRO1Yq8scJHZpVyqShtO641VGAgAAr3vw0xtvcOxDEqSWLcJAOOrbJg9pjQ0u7mpuNZu+oMafv7aLmxt7ITEs/jpZZMwvc6Z7W6RFKBgk5BeHMtAoyJBhJAiZxgGnu6d1fzc5GpU2hKf1QRC+2taJT7tRVkSYTcJsMp8TlWlzXYKbZhJ5CAJbMzsnkhV2n25UZW22xfEJ0e7AADnjY+9FYZf1WASOEh85t6HDrMAXU/ugkZ4dnPN3tac3ts0lfxBDT97dSc+OtIFWWBx7xWTMXWkM9vdIimSO98AhOQAFgzc/tw5CSGEkEz76EgXdja5IHAMvjIjuVlNIHQCmSvrNcM4lkGVTYI3mDvjvE/RUG3Pbgot0FskSOSiVqQFgBmjS2ASOLT2BLC7uSfDvRto3f426AbQUGlFtSP2BZGAqsNpyuz70CLxEHg2qb27x1ZYMW9cGQwA/7up8NduehUVP/3HDnxyrBsmgcN9V0zB5FpHtrtFUoiCTUL6kHgWXb5gTly1JYSQTOs7q3nxlBqUWaWknkc3DIDJnfWafZVYRHAMm3ABl3QIajo4jsl6Ci0QKhLkNAkxiwRJPIfZY3InlTaeFFog9F60ZnjvUovIwyzySWdKfX3WKDAA3t/fjoNtubNGNtVCgeZO7Djuglnk8LMrp2BijT3b3SIpRsEmIX1IAgufosX8siWEkEK2pbETu1t6IPIsvnTW8GY15Rxbrxlmk3MnldbtV2GXedhzJCi3yjx0xL7Y2jeVNlYxoUzo8CjYfqwbwOBbnmi6ATaDxYHCOJZBiVlIugbE6DJL5Fg/U6Czm56Airtf3oFdTS5YJA4/v3IKJlTbst0tkgYUbBLSh8RzUFQqEkQIKT59ZzUvmVKDkmHs+ehTNNhlAXIO7K95Ko5lUG2XcmKc9wY1VNllsFlOoQ0zCRw4JnqRIAA4c1QJLCKHDo+CncddGe7dSe/va4MBYEKVDZWDVEoOqBokIZQenGkOkwgDyV+4/uqsUWAZYMOBjpyqAJwKbr+Ku17ejt0tPbBJPH5+5VSMr6JAs1BRsElIHxwb+pKlIkGEkGKz6VDopFYWWHzxrBHDeq6ApqF0GMFqujnNIrgk9kJMpaCmQ+AZOE25c5yGKhIkcCxmjy0DEJrdzJbwaw+2tyYQWq9pEjNbHCjMInEQuOTWbQJAXYkZnzktVPjo6Y2HU9m1rHL5glj28jbsPeGGXeZx/1VT0FBpzXa3SBpRsEnIKViWgScH0qsIISRT9D6zmpdNrR3WGsLwvoa5mEIbZpcF2GU+qwXhevwq7LIAW4bXEw5G4jmYhNhFgoCTAd77+9tizoCmU5s7gJ1NLjAYPIUWCG174jQJWSlSZRF5mER+WPu6fu3s0OzmB4c7c6Io03B1+4JY9vJ27G/1wGES8MBVUzGmnALNQkfBJiGnoCJBhJBis+FAOw62eWASOFx15vBmNUPrNTlYcjjYZFkGVXYZ3ixmsfiCKqpzKIU2zGkWENBiH5fpI52wSTy6vEFsP96dwZ6FhGc1J9XahyxgpSPzxYHCWJZBmUWEP8YscTxqnSZ89vRKAMAzm/J7drPLq2DZS9twsM0DpzkUaI4us2S7WyQDKNgk5BQyz8GrqFQkiBBSFHTDwDO9s5pXTKsd9n6Pubxesy+nSYTAZyeVVlF1iDyb9b01o7FKAga71spzLOaOC6XShivCZtLaOKvQaroBjsl8caC+7CYBw538vXrmKHAsg62NoS2J8lGnR8GdL23HoXYvSs0ill81FaNKzdnuFskQCjYJOYUksFCCBrw5UDyCEELSbcOBdhzu8MIiclg0fXizmkBonVyZNXfWIcZi660C25OFVNoefzCUQpuDs78mgQPLMFAHCcLPGx9aS7huf9ug7VKtxeXH7pYesAwwb9xQ6zWzVxwozCLxkLjYa2DjUe2QsaB3djMf1262uwNY+uI2HOnwotwqYvkXpmJkCQWaxYSCTVKQOJaBxLNJbZLNMgw06FQkiBBS8Ew8i7d2tgAArpw+Ytgph5pugGWR0ym0YSzLoNouwxfMfLDp13KrCm1fJpGDLLCDZvdMHeGAwxQK1D85mrlU2nAK7ZRax5DVkgNBHSaBg8RnL9g0CxxMIjfsysdfObsOPMvgk6Pd2NPsSvr8JhP6nn+1uQO488VtONblQ4VNwvKrzkCt05TtLpIMy/1vA0ISIPEsnBYBTpOAbl8QDpOALm8QXd5gQmmxPMPC7Q8CoEGREFJ4fIoKjmUxotSM/7tpHtbvb0eZZfD1b/E4uV4zt1Now+wmASLPRtJaMyGgapA4Fg5z7qXQAoDIszBLHHp8GmK9JTiWwbxxZfjn9mas3deGs0aXZKRv4RTac4eoQguEKiLXmmNvi5IJLMugzCriYJtnWM9TaZNx3dx6zB1XinMbKuAOJH9+ky6nnn/ZTQJO9PhhEnlU2iQ8cNVUVA2yTQ0pXDSzmUMefvhh1NfXQ5ZlzJ49G5s2bRq0fVdXF26++WbU1NRAkiScdtppeP311zPU29wj8SxGlprwPxsOY+b9/8bZ96/CzPv/jac3NmJkqSmh0ucSz6LLS0WCCCGFJxDUsOLdA5h5/1uYu/xtzFm+Ch8f7cJp1dZhbxHhC4bWa2ZzNikR9kgqbTBjr+n2q7CbcjOFNsxpEodM/QyvmVx3oC0j616Pd/mwr9UdVwotABhGaP1pttnl0LrN4ZxPSDyLH37uNHxytBuzlw/v/CYdop1/nX3/v7HlcCee/85c/P6r0ynQLGK5O9IVmeeeew5LlizBihUrMHv2bDz00ENYuHAhdu/ejcrKygHtFUXBRRddhMrKSvzf//0fRowYgcOHD8PpdGa+8znCaRGw4t39+K9V+yK3uXwqfr9qLwDgmtmj0OIKxPVcshAqEuQP6lld70EIIankU1SsePdAZFwEQuPkf63aBwZMQuNkNAFVz+n9NU/FMKGqtG2ezKWC+lUNDXZrVrbjiFcoDXrw4GhSrQMlZgGd3iA+OtKFs+tL09qncArttJFOOIYorKRqOtgsFwcKs0g8JD6Ulpxs0SynRcCf3tuPP7wd/fzmyzNGorHDm5L+JuP0GlvU868/vL0PLDP8cYXkNwo2c8SDDz6Ib33rW1i8eDEAYMWKFXjttdfwxBNP4I477hjQ/oknnkBHRwfWrVsHQQgNuvX19YO+RiAQQCBw8sPucuVnVbNoOJaB0yRg5bpDUe9/ct1B3HzBOLS5lbj2BRN5Fl2+0LpNCjYJIbkgFWM4x7J4ct3BqPclOk6eKlz9M5f314zGYRYiRVzSPSPrD2qQeW7IYCnbZIEDy7JQNR08F33WjGMZnNNQjlc/acKava1pDzbX7G0FcHKfz8GEArvsFgcKM4uhbYB8ipZUsBnP+c2N88fiP1/4BB0eZZi9TVypRcTa2y9I2fkXKTyURpsiiqJg9+7dUNXECw0oioItW7ZgwYIFkdtYlsWCBQuwfv36qI955ZVXMHfuXNx8882oqqrClClT8MADD0AbZG+s5cuXw+FwRH7q6uoS7muu4lkG3b4gXL7ox9/lU9HtU8HHuaCeZRhoujGszZgJISSVUjGG9/hTN06eKnRxjs2L4kB92SQedpMAdwaq0roDKhxmIecDcrPIQRY4+IdYCxiuSrvhQAeUNK4bPNLpxaF2L3iWwdyx8QWbZonL2DrcwTAMg1KzCH+SRQfjOb/p8CgY4ZQh8WzGf0Y4ZbS7lbSNKyT/5fZolwe8Xi++973v4amnngIA7NmzB2PHjsX3vvc9jBgxIuqs5Kna2tqgaRqqqqr63V5VVYVPP/006mMOHDiAt99+G9dccw1ef/117Nu3D9/97ncRDAZxzz33RH3M0qVLsWTJksjvLperYAJOVTfgMAmwm/ioA57dxMNh4tHaE38ah8CyWSmJTwgh0aRiDLfJqR0n+/IpGsqsYk6c4CcinErb2pP+VNqAqqPCJuV0Ci0ACBwLq8ijy6sMGhifXm1DuVVEm1vBlsZOzB1blpb+hAsDTa9zxlUxOaBqGCnnToE/m4mHbhgwDCPh//t4zm8qbRJ++cVpWZk55FgGVXYpbeMKyX/59Y2Qg5YuXYqPP/4Yq1evhiyfXPy8YMECPPfcc2l7XV3XUVlZicceewwzZszA1VdfjZ/85CdYsWJFzMdIkgS73d7vp1Aoqo5tR7tx/dz6qPcvnjcGXd5gQgOxJHDo9gWhU9oHISQHpGIM13Qdi+eNiXpfMuNkX4qm5dV6zb4cJgEyzyU9+xSPUAotC6c5P46Rw8QjMEThH5ZhcE5vsZ5wQJgOa3rXa8aTQhtiDHsbn1SySjxkgUuqaqymG+jyBdP2uR2uXO8fyb7c+STmqZdeegnPPfcc5syZ0+9q1eTJk7F///64nqO8vBwcx6GlpaXf7S0tLaiuro76mJqaGgiCAI47mf8/ceJENDc3Q1EUiGJ+fJmlgqYb+P2qPWjs8OFvN84BwwAr1x2Cy6fCbuJx/dx63Dh/LI52+BJ6Xoln4VFU+FUNZpE+KoSQ/GcSeXz3/HEAQmupwuPk4nljkhonwzTdAM+yOZ8eGotV4uEwC+j2BpMu4jIUd0BFqUWEJQfWEcYj3nTo88ZX4OWPj2PTofbI1jepdLjdgyMdoRTa2WOGnjlVNR0sy6bt/zEZJqF33WYguePT5QnixvljAaT2c5squd4/kl35+a2QQ1pbW6NWi/V4PHGnSoiiiBkzZmDVqlVYtGgRgNDM5apVq3DLLbdEfcw555yDZ555BroeGlSBUApvTU1N0QWaD761B+/tbQXHMvjXzhb8v9mjccsFDej2qbBIHNbsbcOWQ50JX02WeBadXh0+hYJNQkjhkAQON84fi5svaEC3T4HdFAqyjnb4kt6vz6dokHsLoeQjhmFQaZfTWjEzoGooz4MU2jBZ5MBzDIKaDiFGkSAAOK3KikqbhBM9AWw53IlzGuKdfYzPmt4Z0xmjS+J6f/lVHTLP5kQl2jCGYVBuEbHH40YyO5IGVB1HO3y4ZvYo3HzBOHT7VDhMPLqG+blNlVzvH8kuSqMdppkzZ+K1116L/B7+Evnzn/+MuXPnxv08S5YsweOPP46nnnoKu3btwk033QSPxxOpTnvddddh6dKlkfY33XQTOjo6cOutt2LPnj147bXX8MADD+Dmm29O0V+W+1RNx6//tTsSaN6+cAKm1DrQ4gpg3wkPOj0Kvvs/W3HjX7fgjR3NCT8/wzAwAHiV9KVVEUJINoQvoDV2eLH9aDdaXIFhnRB6g6GTy3xbr9lXKJWWTUsqbbgSqTPHq9D2ZRI4yDyHQHDw9wXDMJH01nDF2FQxDKNPFdqKuB4TCGqwSkLOvRetsgD0rttMRkDV+53f7DvhGfbnNpVyvX8ke/LzEmQOeeCBB3DxxRdj586dUFUVv//977Fz506sW7cO7777btzPc/XVV6O1tRV33303mpubMX36dLzxxhuRokGNjY2RGUwAqKurw5tvvokf/OAHOOOMMzBixAjceuutuP3221P+N+aioKbj12/uxvoD7eBZBndcfHq/9BpNN6DpBqaNdGL1nlas2duGr549KuHX4Vkmo5t9E0JIJnkVDSLHYrj5MEFdR0merEWMxSJyKLGI6PAoKU/BdAdUlFnFvJr5FbhQWnSnR4F1iNPFcxsq8MLWY9h8uBM+JXVbhh1o8+B4tx8ix2JWnFurBDQdDlPuHefwus3h7t8dPr/JVbneP5J5uXXZJw+de+65+Oijj6CqKqZOnYp//etfqKysxPr16zFjxoyEnuuWW27B4cOHEQgEsHHjRsyePTty3+rVq7Fy5cp+7efOnYsNGzbA7/dj//79uPPOO/ut4SxUQU3HL9/4FOsPtEPgGPzkkokx13HMGVsGnmXQ2OHF4XZPwq8l8Ry6fSoVCSKEkBhUTQfP5O96zTCGYVBukxBQUzuzaRgGgpqGCpuU0ufNBIeJj2tmalyFBTUOGYqqY9OhjpS9fjiFdmZ9SUIBmjkH34uyENoWyJfGIlSE5KLc+zTmoXHjxuHxxx/PdjeKgqLqWP7PXfjgcCdEjsVPLpmIs0bHXgFhlXmcOcqJzYc6sXZfG0aXWRJ6PYln4Qmo8AW1vLoiTQghmRLaXzN/12v25TQJkAUupbNzvt6iOU5z/qTQhplFHohjiSnDMDi3oRzPbzmKNXtbMf+0+FJeB5NMCm1Q08FzTMr+71KJYRiUW0W0u93Z7gohGUUzm8PU2Ng46A9JnYCq4f7Xd4YCTZ7FXZdNGjTQDAt/Sa3Z25bwWgmJZ6FoOl2JJISQGHyKBqdJGLSITL6wSDxKzCLcgdTtsewOqCixiHlZaM4kchB6iwQNJfxdu+VwJ7zK8I/f3hNunOgJQBZYzIzjux4AAkEdEs/lVHGgvqyyADCAnuS6TULyUf6NfDmmvr5+0MpymkZBSir4gxruf30XPjrSBYlncc9lkzB1pDOux84eUwqBY3Csy4dD7R6MKbfG/boMw8AwQidThBBCBlJ1A8483V8zmgqbhOZuHwzDGHblWMMwoOp6XqbQAqEiQVLv/qNDXUyoLzNjZIkJRzt92HCgA589fWCl/kSEU2hn1ZfGvYY2oGoosYg5e+EjtG4zVIQqHy8+EJKM3Pw05pEPP/wQW7dujfxs3LgRK1aswGmnnYbnn38+290rCP6ghp+9uhMfHemCLLC494rJcQeaQCgNaOboUGGBNUlsOi1wLLp9SsKPI4SQQhfUdHAcA2sBnTg7zb2ptCnIaImk0JryMxjnORY2Ob51mwzD4LyG1FSl1Q0Da/eFvq/PjTOFFsjd4kBhssDBJvN0AZsUldz9ROaJadOmDbht5syZqK2txa9//Wt84QtfyEKvCodXUXHfqzux47gLJoHDvVdMxsQae8LPc974cqw/0I41e9tw7ZzRCV2tlngWPT4Nmm6AY/NjfzRCCMkEn6LBLHCwSLmZtpgMs8ijxCKitScw7Nknt19FpUPKyTWE8XKaRDR1++Jqe974Cvzv5iP46EgX3H4VVjm547e7uQdt7gBMAocZo+LfmdIwkPMzhqXm0HuLkGJBM5tpMmHCBGzevDnb3chrXkXFT1/ZgR3HXTCLHH525ZSkAk0AmDm6FCLPotnlx74TiS3OlwQWflWldZuEEHIKX1CD0yKAz9G0xWRV2CSoup70nohAbxVa3UCFVU5hzzJPFlkYBuI6FnWlZtSXmaHqBtYfSDyTKCw8Mzp7bGnc+2UGNR0in5vFgfqyygIYMLRukxSNwvp2yAKXy9Xvp7u7G59++imWLVuG8ePHZ7t7ecsdUHH3yzuwq7kHFonDz6+cggnVtqSfzyRyOLt3j65wak68RI6FouqU9kIIIafQDCNvU0QH4zSJw06l9SoazCIHhyn/qtD2ZRZ5SDyLoBZfcHRun6J8ydB0A+/vawcAnNcQfwqtP6jldHGgsJP7bdI5BSkOFGwOk9PpRElJSeSntLQUkyZNwvr16/Hoo49mu3t5ye1XcdfL27G7pQc2icfPr5yK8VXJB5ph4bUka/clVpWWYRiAoSJBhBDSV3ibiULY8uRUJpFDqUWE2598VVV3QEWZRcz5mbah9C0SFI/wd+3HR7vQ7Qsm/Hq7mlzo8CqwSBzOHOWM+3EBVYdV4nN+ll0WONhlgc4pSNEovG+IDHvnnXf6/c6yLCoqKtDQ0ACep8ObKJcviLte2Y4DrR7YZR4/XzQloeqxg5lZXwKTwOFETwC7W3pwenX8KbkCy6HLp2AUzCnpCyGE5DufosHM87AWYLAJABVWGce7/ElVpTUMA5phoDxPq9D2xbEMbCYera74CuXVOk0YW2HBgVYP1u9vx+enVCf0emt6s4/mji1LqKpsUNNRYs6PWfZSi4hmV3zrYAnJd4X5DZFB8+fPz3YXCka3L4hlL23DoXYvHCYB9y+agtFllpQ9v8RzmDWmFO/uacWavW0JBZuywMLtV6lIECGE9PIGNdSVmAp2THSaBZgEDl5FS3j21lMgKbRhTpOI413xB0fnNVTgQKsHa/a1JhRsarqBdb3BZiIptECogq0s5vasZphF4sCxDJ1TkKJAwWYSXnnllbjbXnHFFWnsSeHo8ipY9tJ2HO7wwmkWcP+iqRhVmvpZxPPGl+PdPa14f18bvnHuGLBxXq2WeA4uvwKvosImF8bJAyGEDIeu63CYC3c8lAUOZRYRTd3+hINNd0DFiBI57v0hc50scEBvkaB4ZnnPHV+Op9YfwvZj3ej0KnHPOG4/1o0uXxA2mccZIx1x909RdUg8m/OVaMMsfdZtFmIaOiF90Ts8CYsWLYqrHcMw0DTKyR9Kp0fBT17ahiOdPpSaRdx/1RSMLElPuupZo0pgFjm0exTsanJhcm18X2Yiz0LRDPiCGgWbhJCiF9R0CDxb8CfK5TYJR7t8CaXS6oYBXddRbsn/FNowsxhat6loOiR+6AC62i7jtCor9rS4sW5fGy49ozau1wlXoZ03rjyhtZcBNT+KA4WF1212eJSC/wwRkh/5BjlG1/W4fijQHFq7O4ClL4YCzXKriOVfmJq2QBMABI7FnDFlAJKolGcAfmXoja0JIaTQhSqt8rDkyUxSshwmAWaRgyeBYi7eQGi2yl4gKbTAySJBgWD834HhNNg1cVaAVzUd6/aHq9CWJ9Q/f1CHzcTnVUpqqUVEQKVzClL4KNgkWdPWG2ge6/KhwiZh+VVnoNZpSvvrnjc+9CX2/v42aHr8VWlFnkWnN74CCYQQUsh8QQ0lZiGvTu6TIQscyqwi3IH4q9J6FBVlVrFgUmgBgGUZ2E08/Gr8Qfc5vQHjzuMutLsDQ7b/5Gg3egIqnCYBU0bEn0ILAEFdy7steCwSD45hEjoPISQfFfYlyQzxeDx499130djYCEXpH4x8//vfz1KvctsJlx8/eWk7ml1+VNokPHDVVFTZM7Px9bQ6J6wSjy5vEDuOd+OMkc64HifzHNwBFaqm53xpdUIISSfD0OHIs5P7ZJVbJDS2e6EbxpDr/HXDgKbrKLMWTgptmN0k4Ghn/EWCKmwSJlbbsKu5B+/vb8MV00YM2n7Nvt4U2obyhC5iGIYBGMi74N4icTCJLHxBrWArOhMCULA5bB9++CEuueQSeL1eeDwelJaWoq2tDWazGZWVlRRsRtHs8uMnL27DiZ4Aahwyfr5oCiptmQk0gVAq7dxxZXhrZwvW7G2LO9iUBBZdPgXeoAY7BZuEkCKlqDoEjoVFyq+T+2TZTQKsEg+vMnRQ4A1osMhCwVSh7cskcgATf5EgADh3fAV2Nfdgzd7Bg82gpmP9geRSaMPrSM15tp+pxHOwyQLa3QoFm6Sg0RnzMP3gBz/A5Zdfjs7OTphMJmzYsAGHDx/GjBkz8Jvf/Cbb3cs5Td0+LP17KNCsdch44KqpGQ00w8JfZusSSKUVOBaKasBPGzETQoqYL6jBVATrNcNkgUO5VYInjlRatxJEuUWMq4hOvgkVCWITWmd4zrgyMAA+be7BiR5/zHYfNnbBE9BQahExqTb+bckAIBAMBZv5NrMJhNZtKlTfgxQ4CjaH6aOPPsIPf/hDsCwLjuMQCARQV1eHX/3qV7jzzjuz3b2ccqwzFGi2uQMYWWLCA1dNRXmWUo3OGOmEXebh8qv4+GhX3I9jGMCrxL92hxBCCo0/qKHMIoIt8PWafZVaRWi6Dt2IfXFS0w3oBgoyhRYILSWRBS6hYLPMKmFyb/C4dpCifOEU2nMbyuPekizMr2qw51lxoDCrxINnWVq3SQoaBZvDJAgCWDZ0GCsrK9HY2AgAcDgcOHLkSDa7llOOdHpx54vb0O5RUFdqxgOLpmb1C5ljGcwbF5rdHOwL8FQSx6LbR8EmIaR4aYZeUJVW4+EwCbDIAryB2LNQXkWFVeILMoUWOFkkKBBMbCbuvPGDV6VVVB0bD3QACAWbiVI1I2/fjxaJhyxy8FHGFClgFGwO05lnnonNmzcDAObPn4+7774bTz/9NG677TZMmTIly73LDYfbPbjzxW3o8CqoLzPjgUVTUGLJfmGJcFXa9QfaEdTiu1IrCRx6Amrc7QkhpJAEVA0SxxXd3oASz6HcIsKtBGO2cQdUVFgliHzhnlrZZQHqILO70cwdVwaWAfadcKOpe2CBoS2HO+ALaii3SphQbUvouQ3DAJje9aR5SORZOEw8vEG6iE0KV+GOiBnywAMPoKamBgBw//33o6SkBDfddBNaW1vx2GOPZbl32XeozYOfvLQdXd4gxpRb8PNFU+E0Zz/QBIDJtQ6UmAW4Ayo+PtIV12NC61U0+BK8sksIIYXAp2gwiRzMebg+brjKrBIMA1FTHsO3lVpz4/stXUwCBwYYNJ34VCVmEVN7tzJZG2V2M3xbMim0AVWHxLN5VxyorxKziKBOF7BJ4aJgc5hmzpyJCy64AEAojfaNN96Ay+XCli1bMG3atCz3LrsOtLpx50vb0O0LYlyFBfcvmpJT6UUcy+Cc3lTaNXGm0gocC1XTKeWFEFKU/KqGMmtxrdcMc5gEWCQ+6rp9T6CwU2jDzCIPiWehJLBuEziZSnvqshV/UMOmQx29bRJPoQ2oOmSBg5zHBZmsEg+eCZ1bEFKIKNgcpp///Oc4ePBgtruRc/adcOMnL21Hj1/F+Eorfn7lVNjk3PsSPrf3y23Dwfa4vzwZMPAmsME3IYQUAsMwoOmhVMpiJPIsKqwS3FHGf7eiosImQSjwbbFkgYWUYJEgAJg7tgwcy+BAmwfH+uzV+cHhTviDOqrtMsZXWhPuTyCowS7zeX3xwyLxMIkcZUyRglXYo2IGPP/882hoaMC8efPwyCOPoK0t/mIzhWpPSw+WvbwN7oCKCVU2/OzKKbDKubm+Z2KNHWUWEV5Fw9bGzrgeI3Isunyx1+0QQkghCqg6ZJ4tuvWafYXTZPum0mq6AZYJbWNR6BiGgcMkwJ9gYGQ3CZjWu6d1uPIsAKzZe7IKbbx7d/alGvlbHChM4Fg4TQJlTJGCRcHmMH388cf45JNPcP755+M3v/kNamtrcemll+KZZ56B1+vNdvcy7tMmF+56eTs8AQ0Ta+y478rJOX1iwjIMzmlILJVWFjh4AmrCaUSEEJLPfEENZonL6/Vxw+UwCbBKfL89N90BFVZRyPugJ152kwDNSPz7L5wmG/6u9SoqPjjU2e++ROiGAQahdaT5zmkRodL2J6RAUbCZApMnT8YDDzyAAwcO4J133kF9fT1uu+02VFdXZ7trGbXjeDfufmUHvIqGybV23Hv5ZJjzYNPv8JfcpkPtcV2tlXgWflWnlBdCSFEJ7a8pJTUDVSgEjkWFTYK7z7pNT0BFhV0s+BTasFCRICahIkEAMGdMGXiWQWOHF4fbPdh0sAOKpqPWIWNMuSXhfiiqDpFn87YSbV9WkQfHMbRukxSk4hgZM8hiscBkMkEURQSDhZ1qySC0sJ1jGWw71o2f/mMHfEENZ4xw4KeXT86bL4AJVTZU2iT4gzq2HB46lZbnWGhUJIgQUkQMw4ABwGbK/QuI6VZqEcEyofTZUAotg5IcqbKeCSaBgySwCAQTC4ysMo8zRzkBAB82duJwhxelFhHnja9I6gJGuDhQIcxsWqRQhWe6iE0KEX1rpMDBgwfxzDPP4JlnnsHu3bsxf/583HvvvfjSl76U7a6ljU9RYZUFjK+0wmEScKzLixFOM2wyj59cMhFyHg3+DMPg3IZy/P3DY1izry2SVjsYlmX6pVERQkghC28xYc3hZRGZYjcJsIh8pFCQTS78KrR9yQILmecQULWELypfMa0W3/7MWJzTUI52t4L7rpyMtp4A/EE94aJD/qCGEVZTQcy08xwLp0XA8U5/ThZTJGQ4aGZzmObMmYOGhgb83//9HxYvXozDhw9j1apV+MY3vgGHw5HQcz388MOor6+HLMuYPXs2Nm3aFNfjnn32WTAMg0WLFiXxFyQuENSw4t0DmHn/W5j1wCqc/cC/8cnRbrxw01z8fNHkvAo0w8Jl2Tcf6ohrxlLkOHT5lHR3ixBCcoJP0UJVM/NwfE81gWNRaZfgUdRQCq1NAl8kKbRA6AKt0yzAn2BwKPEsvjhjJD452o05y1fhvF+9gznLV+GFrccwstQEiU/sGGqGDluOFh9MhtMkQkswNZmQfFA8o2OaXHjhhdi2bRs+/PBD/PCHP0RtbW1Sz/Pcc89hyZIluOeee7B161ZMmzYNCxcuxIkTJwZ93KFDh/CjH/0I5513XlKvmyifouKR1fvx+1V74fKFruq6fCr+8PY+PPn+IVTa5Iz0I9XGVVhQ45ChqDo29+75NRiJZ+FVNARUSnkhhBQ+n6qh3CIWxCxSKpRaJLBgwLEMSoqgCu2pbLKQ8JpNp0XAinf34w9v7+t3/vD7VXvxp3cPwGmOf0YvVByIyYu6EPGySDx4jkGQ1m2SAkPB5jDdf//9WL9+PaZMmQJZliHLMqZMmYI///nPCT3Pgw8+iG9961tYvHgxJk2ahBUrVsBsNuOJJ56I+RhN03DNNdfg3nvvxdixY4d8jUAgAJfL1e8nURzL4sl10fcVfXLdQTjNArg83O8qnEoL9C/LHosscAgEdfgV+lIghGRGKsbwZBiGARgGrJTeF2GXedhkHtYiS6ENMwkcWDD9toAZDMcycJoErFx3KOr9iZ4/BIKhtO5Cmmm3SjzMPE/1IEjBoWBzmO6++27ceuutuPzyy/H888/j+eefx+WXX44f/OAHuPvuu+N6DkVRsGXLFixYsCByG8uyWLBgAdavXx/zcffddx8qKyvxjW98I67XWb58ORwOR+Snrq4ursf11eMPRq5InsrlU9HtU8HnYbAJnKxKu+VwJ7zK4OsxOZaBZhjwBmndJiEkM1IxhifDHwwVYqH1mifxHIsqu4Qah5yXF1iHyyRyEAUm7uwenmXQ7Uvd+UNA1SALHGShcE5jOZaB0yJQkaA00nQDXkWFmGDKNhkeOtrD9Oijj+Lxxx/H8uXLccUVV+CKK67A8uXL8dhjj+GRRx6J6zna2tqgaRqqqqr63V5VVYXm5uaoj1m7di3+8pe/4PHHH4+7r0uXLkV3d3fk58iRI3E/NswmC7DHqEZoN/FwmPi83SuqvsyCEU4TgpqBjQeHTqVlQUWCCCGZk4oxPBm+YGi9ZiGd2KdCfbkFo0rN2e5GVkg8C7PIx13UR9UNOEypO3/wqzqcZqHg0rqdZoHWbaaJphtodvlQYZPQUGnNdneKCn1zDFMwGMTMmTMH3D5jxgyoanoCkZ6eHlx77bV4/PHHUV4e/0bIkiTBbrf3+0mUputYPG9M1PsWzxuDLm8w7rSaXMMwTJ9Np4dOpZV4Fl3ewt7ehhCSO1IxhicjtL8mrdc8FcMwRXtMGCaUFhvv9ieabqDLF0zZ+YNm6AWZ1k3rNtND0w00uXyotMmYVOMoqLW++YCCzWG69tpr8eijjw64/bHHHsM111wT13OUl5eD4zi0tLT0u72lpQXV1dUD2u/fvx+HDh3C5ZdfDp7nwfM8/vu//xuvvPIKeJ7H/v37k/tj4mASeXz3/HG49cLxkSuUdhOPWy8cjxvnj8374CtclfbDxi64/YNfLJCEUJEgP6W8EEIKlG4YAAPYinBdIhmcReITKhLU5Qnixvljh33+oOkGOLAwF9B6zTCLyMMs8PDSus2UCc1o+lFtlzGxxp43e8AXEgrtU+Avf/kL/vWvf2HOnDkAgI0bN6KxsRHXXXcdlixZEmn34IMPRn28KIqYMWMGVq1aFdm+RNd1rFq1CrfccsuA9qeffjq2bdvW77Zly5ahp6cHv//979O+jkcSONw4fyxuvqABXT4FTpOALm8QRzt8Ce+TlWtGlZoxutSMwx1ebDjQjgWTqmK2lXgOPX4V/qCWl9u9EELIUELjG+2vSQYyi1yofoFuxLVuNaDqONrhwzWzR+HmC8ah26fCYeITPn8IqBpEgSnIoIFjGZRaBDR2+Iqy8FSqabqB5m4fqh0yTq+x07laltC3xzBt374dZ511FgBEZhTLy8tRXl6O7du3R9oNlWqzZMkSXH/99Zg5cyZmzZqFhx56CB6PB4sXLwYAXHfddRgxYgSWL18eqXjbl9PpBIABt6eLWeTR4Q5gb4sbJWYxb1NnozlvfDkOb2zEmn2tgwabkSJBigZncS7bIYQUOJ+iwW7m6SSNDCALHESeRUDV4k5LDKg6WlwBtLkV8CyD1p5AwucPAVWHWeQT3pczXzhMInTdk+1u5D1V09Hi8qPGacKEahuNYVlEweYwvfPOOyl5nquvvhqtra24++670dzcjOnTp+ONN96IFA1qbGwEy+bWwGoAcAdU2Ats3cS5DRX4n42N+OhIF7p9wUGvLlKRIEJIIQtoGkrNdDWNDCQLHMwiB29AgznBrUY13Uj6InVA1VHjkAt2vaxF4iDwLBRVp6qpSVI1HS09FGjmCgo2c8gtt9wSNW0WAFavXj3oY1euXJn6DhWpESUmjC234ECbB+v3t+PzUwaumw2TBBZdviAMwyjYLz5CSHHSDQMMmIIsxEJSw2kW0OnJbK0GXTdgKeC0bovIwyzy8AU1CjaTEAk0HRRo5gp6FxMSxbm9VWnX7hu8Kq3Es/ApWt6vVSWEkFOF16PTek0Si0XioSNzy2jC60PNBbheM4xlGZRZRPioSFDCgr2BZq3ThNNrKNDMFRRsEhLFeQ2hqrTbjnWj06vEbCfxHAJBnb4UCCEFx6dosMm0XpPEZhZ4cAyTsboNATU021fo70m7SYAOuoidiKCm40RvoDmh2gaJL+z3SD6hYJOQKKodMsZXWqEbwLr97THbcSwDHQZ8tP0JIaTA+FUNZRYp290gOUwWWUgCm7EtwAJBHWaRK/hg0yLxELlQ8SUytFCgGcDIEjNOr7ZToJljKNgkJIbzelNp1+wdPJWWZRj0+PN7f1FCCOkrnK5okeikjcQm8aEiQZlaShJQdTjNhb+G2CxwMIk8ZU3F4WSgacJpVTZa55qD6H+EkBjOaQgFmzuPu9DuDsRsJ/MsunuLBBFCSCEIr9cs5EIsJDWcJhGKlpmgSEdhFwcKY1kG5VYRfprZHJSihlJnR5WGUmcp0MxN9L9CSAyVNhmnV9tgAHh/f1vMdhLPwRfU4A/S+gpCSGHwBTXYZaHg0xXJ8FkkHnoG1mxqugGOYWAWCj/YBAC7LEDTQReyY1BUHa1uP0aVmjG+ygaBo5AmV9H/DCGDCKfSrt07SLApsKEiQbRukxBSIAKqjlJLgpsnkqJkEjlwHAtVS+8F14CqQRJYyGJxnLpaJB4yz1K1+ygCqoY2tx+jyijQzAf0v0PIIM4ZVw4GwK7mHrT2RE+lZRkGBhUJIoQUiPAMUjGkK5LhMwlcRoIif29xoGIp/mIWOZgljs4tThEKNAMYVWbGaZUUaOYD+h8iZBBlVgmTau0ABt9zk2NY9PioSBAhJP/5gxpMIkvFgUhcRJ6FReLTXpFW0TQ4TcUz284wDEotYsYq/eYDf1BDuyeA+jILxlfawFOgmRfof4mQIZw3PrTn5ppBUmllgUMXFQkihBQAr6LBJgtFM4NEhs9pEqCkOY1W14ujOFBfdlmAAVq3CfQNNK1oqLRSoJlH6H+KkCHMG1cGlgH2nnCjudsftY3EswhQkSBCSAFQNI3Wa5KEmCUeBtIXEKmaDo5jYRKL6wKIReJD5xdFvm4zFGgqGFtOgWY+ov8tQoZQYhYxZYQDALAmRiqt2Ptl4FXUTHaNEEJSStMN8CwLa5HNIJHhMYkceI5FME2zmwFVh8yzMBVZdWSzGNp+qJj32zwZaFowrtIKjmWy3SWSIAo2CYnDeQ2hVNpYVWlDRYJAC/kJIXnNF9Qgi7S/JkmMSQgV7knXDJw/qMEscUW3jyLDMCiziPAV6X6bPiWUOjuuggLNfFZcn1pCkjS3N5X2QJsHxzp9UdvwDAOXn4oEEULyl0/R4DDxRXdST4ZH4FhYRR6BNF1wVTQdJUVUHKgvq8wDhlF06za9iopObwANlVaMq6BAM5/RtwkhcXCYBEyvcwKIXZVWEji4fGpGNrcmhJB0COoaSszFeVJPhsdp5hFIUxqtAQPmIp1tt0o8ZIErqpoQXkVFl1fBuEorxpZbwVKgmdco2CQkTuFU2lhVaSWehT+owV+k6S6EkPymajo4htZrkuSYRR7pmHwLajo4loVcZOs1w0xC77rNIlmm41VUdPuCaKi0UaBZICjYJCROc8aWgWcZHO7worHDO+B+KVIkqDi+EAghhcUf1GGi9ZokSbLIQeSZlBcJCqg6ZIGDucgq0YaF120Ww36bJwNNK8aUWyjQLBAUbBISJ6vM48xRTgDAmr0DU2kZhgEMFHXVOEJI/vIGVThNAgTaVoAkwRwuEpTidM9AUINV5Iv6fWmVBYAB9AJet+kJhALN8RRoFpzi/eQSkoRz+6TSRlusz3MMXD4qEkQIyT+qbsBJ+2uSJPFcKAU71UtJApoOp7m4Z9tD6zbZgp3ddAdU9ASCOK3KivpyS+jiPSkYFGwSkoA5Y0shcAyOdflwqH1gKq3MU5EgQkj+UTUdHMvAKhb3ST0ZnhKzCCUN25+Yi/x9aRI5WAt0v023X4U7oOK0KhtGl1GgWYgo2CQkAWaRx4zRJQCip9JKAouAqhXNQn5CSGHwBTWYBQ4WqTjXxZHUkEUWSGGsENR08BwDuUjXa/ZVZhER0Arr3MLtV+FWVEyosmJUqZkCzQJFwSYhCQpXpV27b2AqrciFgk0qEkQIySc+RYPTIoAv4nVxZPhMAgeBY1I2uxkI6pB5DuYirUTbl1UWwIApmHWbPf4gPL2BZh0FmgWNvlUISdDZ9aUQeRZN3X7sb/X0u49hGIBBwa6rIIQUJlU34DTRek0yPGaRh8xzCKRo3aZf1WCVeLoIgr77beb/+YXLF4RX0TCh2kaBZhGgTy8hCTKJHM6uLwUQPZVWYDl0+5RMd4sQQpIS1AxwHENbnpBh41gGVpmHP0UVaRVVh8NE70sAkAUONjn/1212+4LwqRpOr6FAs1hQsElIEs5rKAcQPZVW4lm4fCo0KhJECMkDkfWatC6OpIDTJCKopyggYgAzXQSJKLNIKa/2m0ndviD8qoaJNXaMLDFnuzskQyjYJCQJM0aXQBZYnOgJYHdLT7/7ZIGjIkGEkLzhUzSUWERKVSQpYRI5wEDU7cESoag6BI6BidZrRlgkDhzL5OXF7G5fEAFNw6QaO0Y4TdnuDskg+mYhJAmywGFWfRkAYO3etn73hYsjeBU1G10jhJCEsCzgNAvZ7gYpECaRg8izULThpdIGVA0yz1Gw2YclT9dtdnkVKJqGidV21FKgWXQo2CQkSeeNP5lK27c6XKRIkJL6vcYIISTVTCJH6zVJypgEDjLPIzDMdZsBVYdVpuJAfckCB7ss5FXmVKdXgarrmFhDgWaxok9wDnn44YdRX18PWZYxe/ZsbNq0KWbbxx9/HOeddx5KSkpQUlKCBQsWDNqepN6M0SUwixzaPQp2Nbn63SdyHLqoSBAhJA+YeR4WkYJNkhocy8Bm4hAY5vYniqZRheQoSi3isI9tpnR6FOi6gYk1DtQ4KNAsVhRs5ojnnnsOS5YswT333IOtW7di2rRpWLhwIU6cOBG1/erVq/G1r30N77zzDtavX4+6ujp87nOfw7FjxzLc8+IlcCzmjImeSivxLHr8KtRhphERQkg6MQBKrQI4lipCktRxmEQEh/H9ZxgGYPSu/yT9WCQeHJP76zY7PAp0GJhYa0e1Q852d0gW0aXMHPHggw/iW9/6FhYvXgwAWLFiBV577TU88cQTuOOOOwa0f/rpp/v9/uc//xkvvPACVq1aheuuuy7qawQCAQQCgcjvLpcrartCER6I03kSdd74cry9+wTe39+Gb543NvJashCa2fQFNdgoBYgQkgLpGMNFnoWDZo9IiplEDgwTChqT2doiqBkQeZaCzSgsEgeTyMLlD0Lic/P8wqdoYBhgUo0dlXYKNItdbr5Li4yiKNiyZQsWLFgQuY1lWSxYsADr16+P6zm8Xi+CwSBKS0tjtlm+fDkcDkfkp66ubth9z1WKqqPZ5UOzywcljekm0+qcsEo8Or1B7DjeHbld4FgENSOv1lUQQnJbqsdwjg1V+rTJdN2ZpJZJ4CBybNLpnv6gBpnnqThQFBLPocQSukAUUPWc/JF4DhNrKdAkIfQNkwPa2tqgaRqqqqr63V5VVYVPP/00rue4/fbbUVtb2y9gPdXSpUuxZMmSyO8ul6sgA86AqqHdHcCoMjNgAI0dXlRYZYhpuAIocCzmji3DW7tasHZfG84Y6Tx5pwF4AypgS/nLEkKKUKrHcI5lMLnWAZZSaEmKmQQOkhBatyknETAGVB2VdpHSu2M4vdoOVc/dZTosw0CgrC7Si4LNAvCLX/wCzz77LFavXg1Zjn0VSZIkSJKUwZ5lXkDV0OYOYHSZGeMrbTAAgAGOtHtRZpUg8am/Snru+HK8tasF6/a348bPjIt8OUo8i24fbX9CCEmNdIzhFGiSdGBZBg4Tj6ZuP4DEt9VRNI3SuwfBsQw4lmZ9SX6gyw45oLy8HBzHoaWlpd/tLS0tqK6uHvSxv/nNb/CLX/wC//rXv3DGGWeks5s5zx/U0O4JoL7MgvGVNvAcC4FjcVqlDaPKzGhzBxBQU5/WOm2kE3aZR7cviE+OdkVul3gO7oA6rCIJhBBCSD6yyQKCWuJFbAzDAMswtF6TkAJBwWYOEEURM2bMwKpVqyK36bqOVatWYe7cuTEf96tf/Qo/+9nP8MYbb2DmzJmZ6GrOOhloWjG+ytZvXy6eYzG+0ob6MgvaPYGUb4bMsQzmjQvtublm38mqtJLAwq9qtG6TEEJI0TGLHNjeIkGJUDQdIsfSek1CCgQFmzliyZIlePzxx/HUU09h165duOmmm+DxeCLVaa+77josXbo00v6Xv/wl7rrrLjzxxBOor69Hc3Mzmpub4Xa7s/UnZE0o0FQwttyKhkpr1DUePMdifJUN9WXWtASc540PBZvr97dHZjIFjoWqGfArFGwSQggpLiaRg8gnXiTIH9QhCRwFm4QUCFqzmSOuvvpqtLa24u6770ZzczOmT5+ON954I1I0qLGxESx78trAo48+CkVR8KUvfanf89xzzz346U9/msmuZ1U40BxXYcHYiuiBZhjHMmiotIIBcKDNgzKLmFThgmgm1zrgNAvo8gbx8ZEuzKw/WRXYE6B1m4QQQoqLzHOQkygSFFA11DhkWk9MSIGgYDOH3HLLLbjlllui3rd69ep+vx86dCj9HcpxPkVDpy++QDOMYxmMq7SCYYD9rakLODmWwTnjyvHatias2dsWCTYljooEEUIIKT6hIkECjnf6AFP8RYKCmgGbnHhRIUJIbqI0WpKXfIqGTm8A4yosGBdnoBnGsQzGVlgxriK0htOXojTXcCrthoMnU2klgYNboSJBhBBCio9N5hFMYIuOUHGg0HpPQkhhoGCT5B2voqLTG0BDpQ1jy61JpdpwLINxFaE1np3eALzK8GcfJ9bYUWYR4VU0bG3sBADIPAt/UIOX1m0SQggpMmaRB8cy0OMsEhRQdYg8S5VoCSkgFGySvOJVVHT7gmiotGFMuWVYazpYlsHYcivGVVrR5VWGHXCyDINzGnqr0u4NVaXlORa6rqe8IBEhhBCS60wCB5FjocRZJCi8vlNOw57YhJDsoGCT5I1woDm+0jrsQDMsHHA2VNrQ7QsOO+AMp9JuOtjRZ09PhooEEUIIKTqywEISuLgvuAaCGhwmgYoDEVJAKNgkecETOBlo1qco0AxjWQZjyi1oqLQOO+CcUGVDhU2CL6jhg0OhVFqJ59DlU1LVXUIIISQvMAyDErMQ9/YnQV2HTabalYQUEgo2Sc5zB1T0BII4rSoUaDJM6q94hgPO8b0BZ7IzkQzD4NxwKu2+UCqtxLPwBrS404gIIYSQQmGVBajG0N9/umGAZRjaX5OQAkPBJslp7oAKd0DFaVU2jC5LT6AZxjAM6sstOK3Kip5AEO4kA87zeoPNzYc64A9qkHgW/qCesqq3hBBCSL4wCRw4sEMWCVJUHRLPwizSzCYhhYSCTZKz3P5QoDmhyopRpea0BpphDMNgdJkFp1XZQoGuP/GAs6HSimq7DEXVsflQR6hIkGHAR0WCCCGEFBmzyEEUGASCg89u+oMaJIGDLNCpKSGFhD7RJCf1+IPwKKFAsy5DgWYYwzAYVWrGhCor3EriASfDMJFCQeGqtAwDuAPBlPeVEEIIyWUSz8IkcPCrg19wDag6SsxCRr/vCSHpR8EmyTkuXxBeRcOEalvGA80whmFQ1xtwehQVPf7EAsVwsPnB4Q54FRUSx6HLS8EmIYSQ4hIqEiQOWSRIM3RYZSFDvSKEZAoFmySndPuC8KkaTq/JXqAZFgk4q23wKhpcvviDxfoyC0Y4TQhqBjYe7IAksPAFtT7boRBCCCHFwSLx0PXYazZ1wwADKg5ESCGiYJPkjG5fEAFNw8QaO0aWmLPdHQAnA87Ta2zwqRq64ww4GYbBuZFU2lZIPIcAFQkihBBShEwCB5ZhoMUIOANBHZLAwixSsElIoaFgk+SESKBZbccIpynb3RlgZIkZE2vsCGjxB5zhqrQfNnbBp2jQqEgQIYSQImQSOUgCGzO7x69qMAkcJJ5OSwkpNPSpJlnX5VWg9AaatTkYaIaNcJowsTr+T+7HoQAAGdRJREFUgHN0mQWjSs1QdQMbDraDBZNUdVtCCCEkn0k8C5PIxaxIG1B1OE0iFQcipABRsEmyqtOrQNV1TKzJ7UAzrLY34FQ0DV1eZcj2favSSjyLLl8QxhB7jRFCCCGFhGEYOE1CzCJBumHAKtP+moQUIgo2SdZ0ehTouoGJNQ7UOHI/0AyrdZowscYOVdfROUTAeV5DBQDg46NdUDQNPkUbsiIfIYQQUmisMg8dAy+2aroBlooDEVKwKNgkWdHhUaDDwMRaO6odcra7k7AahwkTaxzQdQOdntgB54gSE8aWW6DpBrY2dkFRqUgQIYSQ4mMSOHBRigQFVA2SEEqzJYQUHgo2ScZ1eBQABibV2FFlz79AM6zaIWNirR06jN6/KbpwVdr397VB06lIECGEkOITq0hQQNVD91FxIEIKEn2ySUa1uwNA74xmZR4HmmFVdhmTauzAIAFnOJV227FuuAMqPAEqEkQIIaS4SDwHkzCwSFAgqMNpEqg4ECEFioJNkjHt7gAYFphU60ClLf8DzbBKe2iGEzB6g+n+qh0yGiqt0A3gk6Nd6PQqVCSIEEJI0XGaBQS0/jObOqg4ECGFjD7dBPB4AC7KWgmOA2S5f7t+jwuA83rBCDrAsDBMJ4v8MN7+bdvdAfAsgwnVdlTwpxTI8XqBWMEXwwBmc3JtfT5AH6QYj8WSXFu/Hzjly7KSBRgHj0+bu9EOoMwqhbrk9wO6hs+ONOPY0TZ8svs4Foy2INAtQBa4UH/DV3MDAUAdZNYzkbYmE8D2XktSFCA4yFYtibSV5ZPvlUTaBoOh9rFIEsDzibdV1dCxiEUUAUFIvK2mhf6fYxGEUPtE2+p66L2WirY8HzoWQOgz4fWmpu1Qn/tk27Js6L2WTNsCGCMADP43D0eyY3hf9P+TXFsaw0PiHMNtqgIET/7dmhKE4PPCpEiAJ8r/H43hibelMfykdIwR6RrHC5lBilZ3d7cBwOgOfawH/lxySf8HmM3R2wFGz5xzjE+OdEV+gqVlMdsaM2f2f97Ro2O3nTSpf9tJk2K3HT26f9uZM2O3LS/v33b+/Nhtzeb+bS+5JHZbwHh39wnj7V0txidHuoyuS68ctK3hdp983uuvH7ztiRMn2373u4O3PXjwZNsf/Wjwttu3n2x7zz2Dt9206WTbX/1q8LbvvHOy7R//OHjbV1892fbJJwdv+7e/nWz7t78N3vbJJ0+2ffXVwdv+8Y8n277zzuBtf/Wrk203bRq87T33nGy7ffvgbX/0o5NtDx4cvO13v3uy7YkTg7e9/vqTbd3uwdt+6UtGP4O1TWCMMObP79+2vDx22wIdI7oBA4DR3d1tpEIqx3D6/+nz09eXvjR4WxrDQz8JjOEfP/iYsfVQh/HJkS5jzx/+Mvjz0hge+qExPPSTA2NEqsfxYkBptISk2KRaO3iOQWvPIFdgCSGEkCIkcGxkC7CgZmS5N4SQdGMMw6BPepFyuVxwOBzoPn4cdrt9YIMh0iva3QF82NgV2rokShpta48fksDh9Go7Si3iyQcWcnpFb9t2dwC7mlwIeryoMIfSel7fdhxPvn8YY8vN+N1Xp+O0KjulYIVRGm3ibSkFKySPxgiXywVHbS26u7ujj7kJGu4Y3g/9/yTXlsbwkATG8K0tHvQEGZRaRLR09GCMjce4Slv0xjSGJ96WxvCT0jBGpHocLwYUbBaxyIlKkh+YdncAHxzuRK3DNOC+Ey4/ZJHDpBo7SvoGmkWkw6NgZ5MLgaCGSpuMdncAi1duhgHg4a+fiUum1lD1PUKKyHDH3HQ/HyGZsP+EG/tb3ahxmNDU7cMZI515ud82KU407iaO0mhJShmGgRYKNAEApRYRk2vskAUOJ1x+lFklTKoNDUxr9rbBHxzkChshhBBSgEKVZw2omg6WYWASohS3IoQUDAo2ScoYhoETPQGYRQ6Ta4s70AwrsYiYXGuHLHJocflxbkM5AODTZhcUlYJNQgghxUUWOLAsC4+iQRZYyCKdihJSyGjrE5IS4UDTKvGYWGOHo3edIgGc5lDAuavJhRmjS/D4dTNwTkM53AEVispB1XWYxdz5KPoUFRzLoscfhE0WqH8JyOW+AdS/4cjlvhGST8wiB1ng4PIGUe2UIPE0s0lIIaNvyhzy8MMP49e//jWam5sxbdo0/OEPf8CsWbNitn/++edx11134dChQxg/fjx++ctf4pJLLslgj0MigabcG2iaKNA8ldMsYkqtAxzH4NHV+/HD5z+Gy6fCbuKxeN4YfPf8cZByIJUoENSw4t0DeHLdQepfAfWN+le4fSMk3wgcC6vIo60nAIdMGVCEFDoKNnPEc889hyVLlmDFihWYPXs2HnroISxcuBC7d+9GZWXlgPbr1q3D1772NSxfvhyXXXYZnnnmGSxatAhbt27FlClTMtr3lh4/bLJAgeYQeI7BincP4A9v74vc5vKp+P2qvQCAb5w7BpqevXpdHMvgL2sPRvoDUP8KoW8A9S+dfbtx/lia4SQkQQ4TD5Fne9dvEkIKGVWjzRGzZ8/G2WefjT/+8Y8AAF3XUVdXh+9973u44447BrS/+uqr4fF48Oqrr0ZumzNnDqZPn44VK1ZEfY1AIIBAn7LhLpcLdXV1w6pGu+VwJ+wmAZNq7bDLFGgORlF1zLz/Lbh8A8vd2008Niy9EOf+8h10eAYpL58mpRYRa2+/AHOWr6L+FVDfqH/p79sHP7kIIh/fmrPhVjFM9RhOSLaccPmx54QbU0c46CI1yStUjTZxtCo7ByiKgi1btmDBggWR21iWxYIFC7B+/fqoj1m/fn2/9gCwcOHCmO0BYPny5XA4HJGfurq6YfWbYxlU2iRMpkAzLj3+YNQTViA0U9LhUVBhlTLcq5AKq4R2t0L9S0Iu9w2g/g1HPH3r8Q+yT2GKpXoMJyRbzBIPu8TDLFIaOiGFjvIXckBbWxs0TUNVVVW/26uqqvDpp59GfUxzc3PU9s3NzTFfZ+nSpViyZEnk9/BV8WQ5zSKmjhTAsbRXZDxssgC7iY85Q1Jpk/Hct+cgG6kGDHq//Kl/BdU3gPqX7r7ZMnihLdVjOCHZYpV4TB7hoPMHQooABZtFRJIkSFJqZwfoiyJ+mq5j8bwx/dZ+hS2eNwaqrsOZxe1ifIpK/UtSLvcNoP4NRzx9EzOUJJSOMZyQbKHzB0KKAwWbOaC8vBwcx6GlpaXf7S0tLaiuro76mOrq6oTak+wziTy+e/44AMjJqpbUv8LsG/WvcPtGCCGE5DoqEJQjZs+ejVmzZuEPf/gDgFCBoFGjRuGWW26JWSDI6/XiH//4R+S2efPm4YwzzohZIOhUtMg5O7yKCj6H9+uj/iUvl/sGUP+GIxV9S/WYS2M4IYRkFo27icuNb3GCJUuW4Prrr8fMmTMxa9YsPPTQQ/B4PFi8eDEA4LrrrsOIESOwfPlyAMCtt96K+fPn47e//S0uvfRSPPvss/jggw/w2GOPZfPPIHEIn6CW9RY8yVQKXryof8nL5b4B1L/hyOW+EUIIIbmKgs0ccfXVV6O1tRV33303mpubMX36dLzxxhuRIkCNjY1g2ZMnN/PmzcMzzzyDZcuW4c4778T48ePx0ksvZXyPTUIIIYQQQgiJhtJoixilAhBCSOZQGi0hhOQ3GncTR3lAhBBCCCGEEEJSjtJoi1h4UtvlcmW5J4QQUvjCY22qEopoDCeEkMxK9TheDCjYLGI9PT0AQJuCE0JIBvX09MDhcKTkeQAawwkhJNNSNY4XA1qzWcR0Xcfx48dhs9nAMIltruxyuVBXV4cjR45Qzvop6NjERscmOjousRXSsTEMAz09Paitre1X8C1ZNIanBx2b2OjYxEbHJrpCOy6pHseLAc1sFjGWZTFy5MhhPYfdbi+IwSMd6NjERscmOjousRXKsUnllXAaw9OLjk1sdGxio2MTXSEdF5rRTAyF5IQQQgghhBBCUo6CTUIIIYQQQgghKUfBJkmKJEm45557IElStruSc+jYxEbHJjo6LrHRsUkPOq6x0bGJjY5NbHRsoqPjQqhAECGEEEIIIYSQlKOZTUIIIYQQQgghKUfBJiGEEEIIIYSQlKNgkxBCCCGEEEJIylGwSQghhBBCCCEk5SjYJDE9/PDDqK+vhyzLmD17NjZt2jRo++effx6nn346ZFnG1KlT8frrr2eop5mXyLFZuXIlGIbp9yPLcgZ7mxnvvfceLr/8ctTW1oJhGLz00ktDPmb16tU466yzIEkSGhoasHLlyrT3MxsSPTarV68e8J5hGAbNzc2Z6XCGLF++HGeffTZsNhsqKyuxaNEi7N69e8jHFdNYMxw0hsdGY/hANIbHRmN4dDSGk3hQsEmieu6557BkyRLcc8892Lp1K6ZNm4aFCxfixIkTUduvW7cOX/va1/CNb3wDH374IRYtWoRFixZh+/btGe55+iV6bADAbrejqakp8nP48OEM9jgzPB4Ppk2bhocffjiu9gcPHsSll16KCy64AB999BFuu+02fPOb38Sbb76Z5p5mXqLHJmz37t393jeVlZVp6mF2vPvuu7j55puxYcMGvPXWWwgGg/jc5z4Hj8cT8zHFNNYMB43hsdEYHh2N4bHRGB4djeEkLgYhUcyaNcu4+eabI79rmmbU1tYay5cvj9r+K1/5inHppZf2u2327NnGjTfemNZ+ZkOix+bJJ580HA5HhnqXGwAYL7744qBt/vM//9OYPHlyv9uuvvpqY+HChWnsWfbFc2zeeecdA4DR2dmZkT7lihMnThgAjHfffTdmm2Iaa4aDxvDYaAwfGo3hsdEYHhuN4SQamtkkAyiKgi1btmDBggWR21iWxYIFC7B+/fqoj1m/fn2/9gCwcOHCmO3zVTLHBgDcbjdGjx6Nuro6XHnlldixY0cmupvTiuU9MxzTp09HTU0NLrroIrz//vvZ7k7adXd3AwBKS0tjtqH3zdBoDI+NxvDUKZb3zHDQGD4QvW+KDwWbZIC2tjZomoaqqqp+t1dVVcVcb9Dc3JxQ+3yVzLGZMGECnnjiCbz88sv4n//5H+i6jnnz5uHo0aOZ6HLOivWecblc8Pl8WepVbqipqcGKFSvwwgsv4IUXXkBdXR3OP/98bN26NdtdSxtd13HbbbfhnHPOwZQpU2K2K5axZjhoDI+NxvDUoTE8NhrDaQwnJ/HZ7gAhhW7u3LmYO3du5Pd58+Zh4sSJ+NOf/oSf/exnWewZyVUTJkzAhAkTIr/PmzcP+/fvx+9+9zv89a9/zWLP0ufmm2/G9u3bsXbt2mx3hZB+aAwniaIxnJCTaGaTDFBeXg6O49DS0tLv9paWFlRXV0d9THV1dULt81Uyx+ZUgiDgzDPPxL59+9LRxbwR6z1jt9thMpmy1KvcNWvWrIJ9z9xyyy149dVX8c4772DkyJGDti2WsWY4aAyPjcbw1KExPDE0hocUy1hDTqJgkwwgiiJmzJiBVatWRW7TdR2rVq3qd3W3r7lz5/ZrDwBvvfVWzPb5KpljcypN07Bt2zbU1NSkq5t5oVjeM6ny0UcfFdx7xjAM3HLLLXjxxRfx9ttvY8yYMUM+ht43Q6MxPDYaw1OnWN4zqUJjeAi9b4pQtisUkdz07LPPGpIkGStXrjR27txpfPvb3zacTqfR3NxsGIZhXHvttcYdd9wRaf/+++8bPM8bv/nNb4xdu3YZ99xzjyEIgrFt27Zs/Qlpk+ixuffee40333zT2L9/v7Flyxbjq1/9qiHLsrFjx45s/Qlp0dPTY3z44YfGhx9+aAAwHnzwQePDDz80Dh8+bBiGYdxxxx3GtddeG2l/4MABw2w2Gz/+8Y+NXbt2GQ8//LDBcZzxxhtvZOtPSJtEj83vfvc746WXXjL27t1rbNu2zbj11lsNlmWNf//739n6E9LipptuMhwOh7F69Wqjqakp8uP1eiNtinmsGQ4aw2OjMTw6GsNjozE8OhrDSTwo2CQx/eEPfzBGjRpliKJozJo1y9iwYUPkvvnz5xvXX399v/Z/+9vfjNNOO80QRdGYPHmy8dprr2W4x5mTyLG57bbbIm2rqqqMSy65xNi6dWsWep1e4VLvp/6Ej8X1119vzJ8/f8Bjpk+fboiiaIwdO9Z48sknM97vTEj02Pzyl780xo0bZ8iybJSWlhrnn3++8fbbb2en82kU7ZgA6Pc+KPaxZjhoDI+NxvCBaAyPjcbw6GgMJ/FgDMMw0jt3SgghhBBCCCGk2NCaTUIIIYQQQgghKUfBJiGEEEIIIYSQlKNgkxBCCCGEEEJIylGwSQghhBBCCCEk5SjYJIQQQgghhBCSchRsEkIIIYQQQghJOQo2CSGEEEIIIYSkHAWbhBBCCCGEEEJSjoJNQkjOUhQFDQ0NWLduXba7Epc5c+bghRdeyHY3CCEkJ9AYTgihYJMQMkBraytuuukmjBo1CpIkobq6GgsXLsT7778faVNfXw+GYbBhw4Z+j73ttttw/vnnR37/6U9/CoZhwDAMOI5DXV0dvv3tb6Ojo2PIfqxYsQJjxozBvHnzIrfdf//9mDdvHsxmM5xOZ9THNTY24tJLL4XZbEZlZSV+/OMfQ1XVIV/P5/PBYrFg3759Q7aNZtmyZbjjjjug63pSjyeEkFSgMZzGcEJyBQWbhJABvvjFL+LDDz/EU089hT179uCVV17B+eefj/b29n7tZFnG7bffPuTzTZ48GU1NTWhsbMSTTz6JN954AzfddNOgjzEMA3/84x/xjW98o9/tiqLgy1/+cszHa5qGSy+9FIqiYN26dXjqqaewcuVK3H333UP286233sLo0aPR0NAwZNtoLr74YvT09OCf//xnUo8nhJBUoDGcxnBCcoZBCCF9dHZ2GgCM1atXD9pu9OjRxve//31DFEXjtddei9x+6623GvPnz4/8fs899xjTpk3r99glS5YYJSUlgz7/5s2bDZZlDZfLFfX+J5980nA4HANuf/311w2WZY3m5ubIbY8++qhht9uNQCAw6Gv+x3/8h3H77bdHve+pp54yLBaLsWfPnshtN910kzFhwgTD4/FEblu8eLHx//7f/xv0dQghJF1oDKcxnJBcQjObhJB+rFYrrFYrXnrpJQQCgUHbjhkzBt/5znewdOnSuNOODh06hDfffBOiKA7abs2aNTjttNNgs9ni7jsArF+/HlOnTkVVVVXktoULF8LlcmHHjh0xH6frOl599VVceeWVUe+/7rrrcMkll+Caa66Bqqp47bXX8Oc//xlPP/00zGZzpN2sWbOwZs2ahPpMCCGpQmM4jeGE5BIKNgkh/fA8j5UrV+Kpp56C0+nEOeecgzvvvBOffPJJ1PbLli3DwYMH8fTTT8d8zm3btsFqtcJkMmHMmDHYsWPHkKlbhw8fRm1tbcL9b25u7neSAiDye3Nzc8zHhdctzZ49O2abP/3pT2hqasL3v/99fOMb38BPf/pTzJgxo1+b2tpaHDlyhNb8EEKygsZwGsMJySUUbBJCBvjiF7+I48eP45VXXsHnP/95rF69GmeddRZWrlw5oG1FRQV+9KMf4e6774aiKFGfb8KECfjoo4+wefNm3H777Vi4cCG+973vDdoHn88HWZZT8efE5eWXX8Zll10Glo09LJaUlOAvf/kLHn30UYwbNw533HHHgDYmkwm6rg85o0AIIelCY3h0NIYTknkUbBJCopJlGRdddBHuuusurFu3DjfccAPuueeeqG2XLFkCn8+HRx55JOr9oiiioaEBU6ZMwS9+8QtwHId777130NcvLy9HZ2dnwv2urq5GS0tLv9vCv1dXV8d83CuvvIIrrrhiyOd/7733wHEcmpqa4PF4Btzf0dEBi8UCk8mUYM8JISR1aAyPjsZwQjKLgk1CSFwmTZoU9YsZCK0Ruuuuu3D//fejp6dnyOdatmwZfvOb3+D48eMx25x55pn49P+3c/8uycVRHMc/zxCSSEJE4NQYCAq1CS1FCv4DbdLWUrQ05OAWBAbVXmsZUUs0RUND0Hy1hiDEut0p+jEkIUScZ3hA8FELea6PBe8XuHw9956Dw8HDvZzra5lZR3UmEgldXl7q4eGhfnZ6eqqBgQFFo9GW19zc3Oju7k7JZPLTe19cXCifz+v4+FihUEgLCwtNMVdXVxobG+uoZgDoNno4PRzoBYZNAA2enp40NTWlnZ0dlUolVSoVHRwcaG1tre3iBUmam5tTOBxWoVD4MkcikVA8Htfq6mrbmMnJSVWr1aaFEK7rynEcua6rj48POY4jx3FUrVYlSalUStFoVJlMRsViUScnJ8rlcpqfn1cgEGiZ6+joSNPT0w1LIv72+vqqTCajxcVFpdNp7e7uan9/X4eHhw1x5+fnSqVSX/4GANAN9PDW6OFAj/R6HS6A76VWq1k2m7Xx8XELh8MWDAZtdHTUcrmcvb291eNGRkZsc3Oz4dpCoWCSvlybb2a2t7dngUDAXNdtW8vMzIxls9mGs9nZWZPU9Dk7O6vH3N7eWjqdtv7+fhsaGrKlpSV7f39vm2diYsK2t7fbfm/2Zx1+LBazWq1WP1tfX7fBwUHzPM/MzDzPs76+Pru/v//0XgDQLfTw1ujhQG/8Muvw/QYA+E9KpZKSyaTK5bJCoVBXcjw+PioSicjzvKYNiJ1aXl7Wy8uLtra2fKoOAH4uejgAXqMF8G3F43Hl83lVKpWu5Xh+ftbGxsY//0mRpOHhYa2srPhQFQD8fPRwADzZBAAAAAD4jiebAAAAAADfMWwCAAAAAHzHsAkAAAAA8B3DJgAAAADAdwybAAAAAADfMWwCAAAAAHzHsAkAAAAA8B3DJgAAAADAdwybAAAAAADf/QZEj1rN4QTl9AAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -588,7 +948,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "36c53ff3-984d-4428-87c1-3421098e0081", "metadata": {}, "outputs": [ @@ -608,7 +968,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "a2aed8f0-1230-4128-ad77-d84764c28d0d", "metadata": { "scrolled": true @@ -618,140 +978,251 @@ "name": "stdout", "output_type": "stream", "text": [ + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 1.0\n", - "X1: 1.0\n", - "X500: 1.0\n", - "X2: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", - "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", - "X500: 1.0\n", - "X2: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", - "X500: 1.0\n", - "X2: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", - "X2: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", - "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", - "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", - "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", - "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", - "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 0.004975124378109453\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", - "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", - "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", - "X500: 1.0\n", - "X2: 0.004975124378109453\n", - "X1: 1.0\n", - "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 0.004975124378109453\n" ] } @@ -761,7 +1232,7 @@ "rng = np.random.default_rng(seed)\n", "\n", "beta_space = np.hstack((np.linspace(0.01, 2.5, 8), np.linspace(5, 20, 7)))\n", - "beta_space = j_space.copy()\n", + "# beta_space = j_space.copy()\n", "for beta in beta_space:\n", " for idx in range(5):\n", " new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32)\n", @@ -776,129 +1247,30 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "d3e21945-92b3-4ccc-8f29-b44f67d9cf33", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "done\n" - ] - } - ], + "outputs": [], "source": [ "print(\"done\")" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "b2bced31-0367-48a8-88e1-0afd6a60173f", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
X2X1X500sigma_factor
00.0049750.0049751.0000000.005
10.0049750.0049751.0000000.005
21.0000001.0000001.0000000.005
31.0000000.0049751.0000000.005
41.0000001.0000000.0049750.005
\n", - "
" - ], - "text/plain": [ - " X2 X1 X500 sigma_factor\n", - "0 0.004975 0.004975 1.000000 0.005\n", - "1 0.004975 0.004975 1.000000 0.005\n", - "2 1.000000 1.000000 1.000000 0.005\n", - "3 1.000000 0.004975 1.000000 0.005\n", - "4 1.000000 1.000000 0.004975 0.005" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "display(df.head())" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "c4dbdaf1-9af7-4e6d-83b6-a9cabc18dc91", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axs = plt.subplots(3, 1, figsize=(8, 6), sharey=True, sharex=True)\n", "axs = axs.flatten()\n", diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 750d913f9..97d9793a6 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -1,4 +1,4 @@ -from typing import Callable, Dict +from typing import Callable import numpy as np from numpy.typing import ArrayLike @@ -46,6 +46,7 @@ def __init__( self.n_samples_test_ = None self._n_samples_ = None + self._metric = None self._covariate_index_cache_ = None self._type_of_target_ = None self.n_features_in_ = None @@ -66,6 +67,7 @@ def reset(self): self._n_samples_ = None self._covariate_index_cache_ = None self._type_of_target_ = None + self._metric = None self.n_features_in_ = None def _get_estimators_indices(self): @@ -238,6 +240,13 @@ def statistic( # Fit each tree and compute posteriors with train test splits self.n_samples_test_ = test_size_ + if self._metric is not None and self._metric != metric: + raise RuntimeError( + f"Metric must be {self._metric}, got {metric}. " + f"If running on a new dataset, call the 'reset' method." + ) + self._metric = metric + if not is_classifier(self.estimator_) and metric not in REGRESSOR_METRICS: raise RuntimeError( f'Metric must be either "mse" or "mae" if using Regression, got {metric}' @@ -334,7 +343,6 @@ def test( # Note: at this point, both `estimator` and `permuted_estimator_` should # have been fitted already, so we can now compute on the null by resampling # the posteriors and computing the test statistic on the resampled posteriors - print(observe_posteriors.shape, permute_posteriors.shape) if self.sample_dataset_per_tree: metric_star, metric_star_pi = _compute_null_distribution_coleman( y_test=y[observe_samples, :], @@ -502,14 +510,14 @@ def _statistic( **metric_kwargs, ): """Helper function to compute the test statistic.""" - metric_func: Callable[[ArrayLike, ArrayLike, Dict], float] = METRIC_FUNCTIONS[metric] + metric_func: Callable[[ArrayLike, ArrayLike], float] = METRIC_FUNCTIONS[metric] rng = np.random.default_rng(self.random_state) + posterior_arr = np.full( + (self.n_estimators, self.n_samples_test_, estimator.n_outputs_), np.nan + ) if self.permute_per_tree: # now initialize posterior array as (n_trees, n_samples_test, n_outputs) - posterior_arr = np.zeros( - (self.n_estimators, self.n_samples_test_, estimator.n_outputs_) - ) for idx, (indices_train, indices_test) in enumerate(self._get_estimators_indices()): tree: DecisionTreeRegressor = estimator.estimators_[idx] train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) @@ -551,9 +559,6 @@ def _statistic( estimator.fit(X_train, y_train) # construct posterior array for all trees (n_trees, n_samples_test, n_outputs) - posterior_arr = np.full( - (len(estimator.estimators_), self.n_samples_test_, estimator.n_outputs_), np.nan - ) for itree, tree in enumerate(estimator.estimators_): posterior_arr[itree, ...] = tree.predict(X_test) @@ -669,7 +674,7 @@ def __init__( verbose=0, test_size=0.2, permute_per_tree=True, - sample_dataset_per_tree=False, + sample_dataset_per_tree=True, ): super().__init__( estimator=estimator, @@ -701,7 +706,7 @@ def _statistic( **metric_kwargs, ): """Helper function to compute the test statistic.""" - metric_func: Callable[[ArrayLike, ArrayLike, Dict], float] = METRIC_FUNCTIONS[metric] + metric_func: Callable[[ArrayLike, ArrayLike], float] = METRIC_FUNCTIONS[metric] rng = np.random.default_rng(self.random_state) if metric in POSTERIOR_FUNCTIONS: @@ -731,7 +736,6 @@ def _statistic( y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) # Fill test set posteriors & set rest NaN - # TODO: refactor so posterior_arr is just a large NaN array posterior_arr[idx, indices_test, :] = y_pred # posterior else: # fitting a forest will only get one unique train/test split @@ -782,11 +786,13 @@ def _statistic( # determine if there are any nans in the final posterior array # Average all posteriors (n_samples_test, n_outputs) - posterior_forest = np.nanmean(posterior_arr, axis=0) + # posterior_forest = np.nanmean(posterior_arr, axis=0) # # Find the row indices with NaN values in any column - nonnan_indices = np.where(~np.isnan(posterior_forest).any(axis=1))[0] + # nonnan_indices = np.where(~np.isnan(posterior_forest).any(axis=1))[0] + nonnan_indices = np.all(~np.isnan(posterior_arr), axis=(0, 2)) samples = nonnan_indices + print(nonnan_indices) # Ignore all NaN values (samples not tested) y_true_final = y[(nonnan_indices), :] diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index ba4050591..05aaae129 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -29,26 +29,34 @@ iris_y = iris_y[p] -def test_featureimportance_forest_permute_pertree(): +@pytest.mark.parametrize("sample_dataset_per_tree", [True, False]) +def test_featureimportance_forest_permute_pertree(sample_dataset_per_tree): est = FeatureImportanceForestClassifier( estimator=RandomForestClassifier( n_estimators=10, + random_state=seed, ), permute_per_tree=True, - sample_dataset_per_tree=False, + test_size=0.7, + random_state=seed, + sample_dataset_per_tree=sample_dataset_per_tree, ) - est.statistic(iris_X[:10], iris_y[:10]) + n_samples = 50 + est.statistic(iris_X[:n_samples], iris_y[:n_samples], metric="mse") assert ( - len(est.train_test_samples_[0][1]) == 10 * est.test_size - ), f"{len(est.train_test_samples_[0][1])} {10 * est.test_size}" - assert len(est.train_test_samples_[0][0]) == est._n_samples_ - 10 * est.test_size + len(est.train_test_samples_[0][1]) == n_samples * est.test_size + ), f"{len(est.train_test_samples_[0][1])} {n_samples * est.test_size}" + assert len(est.train_test_samples_[0][0]) == est._n_samples_ - n_samples * est.test_size - est.test(iris_X[:10], iris_y[:10], [0, 1], n_repeats=10, metric="mse") + est.test(iris_X[:n_samples], iris_y[:n_samples], [0, 1], n_repeats=10, metric="mse") assert ( - len(est.train_test_samples_[0][1]) == 10 * est.test_size - ), f"{len(est.train_test_samples_[0][1])} {10 * est.test_size}" - assert len(est.train_test_samples_[0][0]) == est._n_samples_ - 10 * est.test_size + len(est.train_test_samples_[0][1]) == n_samples * est.test_size + ), f"{len(est.train_test_samples_[0][1])} {n_samples * est.test_size}" + assert len(est.train_test_samples_[0][0]) == est._n_samples_ - n_samples * est.test_size + + with pytest.raises(RuntimeError, match="Metric must be"): + est.statistic(iris_X[:n_samples], iris_y[:n_samples], metric="mi") def test_featureimportance_forest_errors(): diff --git a/sktree/stats/utils.py b/sktree/stats/utils.py index 766fd30d9..30ce83ff8 100644 --- a/sktree/stats/utils.py +++ b/sktree/stats/utils.py @@ -171,18 +171,14 @@ def _compute_null_distribution_coleman( ---------- y_test : ArrayLike of shape (n_samples, n_outputs) The output matrix. - y_pred_proba_normal : ArrayLike of shape (n_estimators, n_samples_normal, n_outputs) + y_pred_proba_normal : ArrayLike of shape (n_estimators_normal, n_samples, n_outputs) The predicted posteriors from the normal forest. Some of the trees may have nans predicted in them, which means the tree used these samples for training and not for prediction. - y_pred_proba_perm : ArrayLike of shape (n_estimators, n_samples_perm, n_outputs) + y_pred_proba_perm : ArrayLike of shape (n_estimators_perm, n_samples, n_outputs) The predicted posteriors from the permuted forest. Some of the trees may have nans predicted in them, which means the tree used these samples for training and not for prediction. - normal_samples : ArrayLike of shape (n_samples_normal,) - The indices of the normal samples that we have a posterior for. - perm_samples : ArrayLike of shape (n_samples_perm,) - The indices of the permuted samples that we have a posterior for. metric : str, optional The metric, which to compute the null distribution of statistics, by default 'mse'. n_repeats : int, optional @@ -204,28 +200,15 @@ def _compute_null_distribution_coleman( # (n_estimators * 2, n_samples, n_outputs) all_y_pred = np.concatenate((y_pred_proba_normal, y_pred_proba_perm), axis=0) - print(y_pred_proba_normal.shape) n_estimators, _, _ = y_pred_proba_normal.shape n_samples_test = len(y_test) if all_y_pred.shape[1] != n_samples_test: - print(all_y_pred.shape) - print(n_samples_test) - print(y_test.shape) - print("y_pred_proba_perm: ", y_pred_proba_perm.shape) - print("y_pred_proba: ", y_pred_proba_normal.shape) - raise RuntimeError( f"The number of samples in `all_y_pred` {len(all_y_pred)} " f"is not equal to 2 * n_samples_test {2 * n_samples_test}" ) - # create two stacked index arrays of y_test resulting in [1, ..., N, 1, ..., N] - # where N is `n_estimators` - # y_test_ind_arr = np.hstack( - # (np.arange(n_estimators, dtype=int), np.arange(n_estimators, dtype=int)) - # ) - - # create index array of [1, ..., 2N] to slice into `all_y_pred` + # create index array of [1, ..., 2N] to slice into `all_y_pred` the stacks of trees y_pred_ind_arr = np.arange((2 * n_estimators), dtype=int) metric_star = np.zeros((n_repeats,)) @@ -234,6 +217,7 @@ def _compute_null_distribution_coleman( # two sets of random indices from 1 : 2N are sampled using Fisher-Yates rng.shuffle(y_pred_ind_arr) + # get random half of the posteriors from two sets of trees first_forest_inds = y_pred_ind_arr[:n_samples_test] second_forest_inds = y_pred_ind_arr[:n_samples_test] From 2f06e76b5181314bf99cbf83f42138812576e395 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Thu, 28 Sep 2023 14:51:41 -0400 Subject: [PATCH 47/70] Cleanup Signed-off-by: Adam Li --- .../compare_coleman_and_permutation_forest.ipynb | 12 ++++++++++++ sktree/stats/forestht.py | 7 +------ 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb index 7c2febb11..482f63bc6 100644 --- a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb +++ b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb @@ -1223,6 +1223,18 @@ "(125, 600, 1) (125, 600, 1)\n", "X1: 0.004975124378109453\n", "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", "X500: 0.004975124378109453\n" ] } diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 97d9793a6..c4217201f 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -785,14 +785,9 @@ def _statistic( ) # determine if there are any nans in the final posterior array - # Average all posteriors (n_samples_test, n_outputs) - # posterior_forest = np.nanmean(posterior_arr, axis=0) - - # # Find the row indices with NaN values in any column - # nonnan_indices = np.where(~np.isnan(posterior_forest).any(axis=1))[0] + # Find the row indices with NaN values in any column nonnan_indices = np.all(~np.isnan(posterior_arr), axis=(0, 2)) samples = nonnan_indices - print(nonnan_indices) # Ignore all NaN values (samples not tested) y_true_final = y[(nonnan_indices), :] From dc6dd29956d957f8a1a7304f1c8587b7ae96d7ba Mon Sep 17 00:00:00 2001 From: Adam Li Date: Thu, 28 Sep 2023 15:09:01 -0400 Subject: [PATCH 48/70] Fix docs biuld Signed-off-by: Adam Li --- ...mpare_coleman_and_permutation_forest.ipynb | 112 +++++++++++++++++- sktree/stats/forestht.py | 6 +- 2 files changed, 114 insertions(+), 4 deletions(-) diff --git a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb index 482f63bc6..e44fefd69 100644 --- a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb +++ b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb @@ -1235,7 +1235,117 @@ "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", "(125, 600, 1) (125, 600, 1)\n", - "X500: 0.004975124378109453\n" + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n" ] } ], diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index c4217201f..83b041c9a 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -179,7 +179,7 @@ def statistic( stat : float The test statistic. posterior_final : ArrayLike of shape (n_estimators, n_samples_final, n_outputs) or - (n_estimators, n_samples_final), optional + (n_estimators, n_samples_final), optional If ``return_posteriors`` is True, then the posterior probabilities of the samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` if all samples are encountered in the test set of at least one tree in the @@ -645,7 +645,7 @@ class FeatureImportanceForestClassifier(BaseForestHT): The true labels of the samples used in the final test. posterior_final_ : ArrayLike of shape (n_estimators, n_samples_final, n_outputs) or - (n_estimators, n_samples_final) + (n_estimators, n_samples_final) The predicted posterior probabilities of the samples used in the final test. null_dist_ : ArrayLike of shape (n_repeats,) @@ -844,7 +844,7 @@ def statistic( stat : float The test statistic. posterior_final : ArrayLike of shape (n_estimators, n_samples_final, n_outputs) or - (n_estimators, n_samples_final), optional + (n_estimators, n_samples_final), optional If ``return_posteriors`` is True, then the posterior probabilities of the samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` if all samples are encountered in the test set of at least one tree in the From dbf079e0cfea0b6eb3cc735992e9d89b15e91ea7 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Thu, 28 Sep 2023 15:16:06 -0400 Subject: [PATCH 49/70] Fix unit-test Signed-off-by: Adam Li --- ...mpare_coleman_and_permutation_forest.ipynb | 36 ++++++++++++++++++- sktree/stats/forestht.py | 4 ++- 2 files changed, 38 insertions(+), 2 deletions(-) diff --git a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb index e44fefd69..24475912c 100644 --- a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb +++ b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb @@ -1345,7 +1345,41 @@ "(125, 600, 1) (125, 600, 1)\n", "X500: 1.0\n", "(125, 600, 1) (125, 600, 1)\n", - "X2: 0.004975124378109453\n" + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n" ] } ], diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 83b041c9a..f0f41dc9a 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -785,8 +785,10 @@ def _statistic( ) # determine if there are any nans in the final posterior array + temp_posterior_forest = np.nanmean(posterior_arr, axis=0) + nonnan_indices = np.where(~np.isnan(temp_posterior_forest).any(axis=1))[0] + # Find the row indices with NaN values in any column - nonnan_indices = np.all(~np.isnan(posterior_arr), axis=(0, 2)) samples = nonnan_indices # Ignore all NaN values (samples not tested) From 1c0f66bbe2326e05ee3948d90ea6930f53199354 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Fri, 29 Sep 2023 11:35:46 -0400 Subject: [PATCH 50/70] Add update reshapes Signed-off-by: Adam Li --- ...mpare_coleman_and_permutation_forest.ipynb | 3520 ++++++++++++++--- sktree/stats/forestht.py | 33 +- 2 files changed, 2977 insertions(+), 576 deletions(-) diff --git a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb index 24475912c..8b5c34f46 100644 --- a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb +++ b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb @@ -38,12 +38,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "id": "5e2d1279-fa4f-47ef-aa48-fac6d47159ad", "metadata": {}, "outputs": [], "source": [ - "def linear_model_ancova(sigma_factor=2.0, seed=None):\n", + "def linear_model_ancova(\n", + " sigma_factor=2.0, seed=None, permute_per_tree=True, sample_dataset_per_tree=True\n", + "):\n", " r\"\"\"Test MIGHT using MSE from linear model simulation.\n", "\n", " See https://arxiv.org/pdf/1904.07830.pdf Figure 1.\n", @@ -57,8 +59,6 @@ " test_size = 0.1\n", " n_repeats = 500\n", " metric = \"mse\"\n", - " permute_per_tree = True\n", - " sample_dataset_per_tree = True\n", "\n", " rng = np.random.default_rng(seed)\n", "\n", @@ -239,556 +239,2800 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 12, "id": "14806903-933b-4e31-a2db-a3a45e0a6f82", "metadata": { "scrolled": true }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X1: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X6: 0.001996007984031936\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 1.0\n", - "(125, 2200, 1) (125, 2200, 1)\n", - "(125, 2200, 1)\n", - "X2/7: 0.001996007984031936\n" + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n", + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X6: 0.001996007984031936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", + " y_train = y_train.ravel()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X2/7: 1.0\n" ] } ], @@ -802,7 +3046,12 @@ " for idx in range(5):\n", " new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32)\n", "\n", - " elements_dict = linear_model_ancova(sigma_factor, new_seed)\n", + " elements_dict = linear_model_ancova(\n", + " sigma_factor,\n", + " new_seed,\n", + " permute_per_tree=True,\n", + " sample_dataset_per_tree=False,\n", + " )\n", " for key, value in elements_dict.items():\n", " pvalue_dict[key].append(value)\n", " pvalue_dict[\"sigma_factor\"].append(sigma_factor)\n", @@ -845,13 +3094,13 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 8, "id": "7c99ce8c-a32d-447b-9dd2-85c8d310239f", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -870,19 +3119,21 @@ " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", " ax.legend()\n", - "fig.suptitle(\"Linear ANCOVA model with Coleman Forest (Permutation per tree)\")\n", + "fig.suptitle(\n", + " \"Linear ANCOVA model with FeatureImportanceRegressor (Original Coleman method)\"\n", + ")\n", "fig.tight_layout()" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "id": "67846a66-1817-46c8-9ccc-5281773c4f92", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -901,7 +3152,9 @@ " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", " ax.legend()\n", - "fig.suptitle(\"Linear ANCOVA model with Coleman Forest\")\n", + "fig.suptitle(\n", + " \"Linear ANCOVA model with Coleman Forest (Permute per tree, but not sample separate dataset)\"\n", + ")\n", "fig.tight_layout()" ] }, @@ -968,7 +3221,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "a2aed8f0-1230-4128-ad77-d84764c28d0d", "metadata": { "scrolled": true @@ -1379,7 +3632,55 @@ "(125, 600, 1) (125, 600, 1)\n", "X1: 1.0\n", "(125, 600, 1) (125, 600, 1)\n", - "X500: 1.0\n" + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X2: 0.004975124378109453\n", + "(125, 600, 1) (125, 600, 1)\n", + "X1: 1.0\n", + "(125, 600, 1) (125, 600, 1)\n", + "X500: 0.004975124378109453\n" ] } ], @@ -1403,30 +3704,129 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "d3e21945-92b3-4ccc-8f29-b44f67d9cf33", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "done\n" + ] + } + ], "source": [ "print(\"done\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "b2bced31-0367-48a8-88e1-0afd6a60173f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
X2X1X500sigma_factor
00.0049750.0049751.0000000.01
10.0049750.0049750.0049750.01
20.0049750.0049750.0049750.01
30.0049750.0049751.0000000.01
41.0000001.0000000.0049750.01
\n", + "
" + ], + "text/plain": [ + " X2 X1 X500 sigma_factor\n", + "0 0.004975 0.004975 1.000000 0.01\n", + "1 0.004975 0.004975 0.004975 0.01\n", + "2 0.004975 0.004975 0.004975 0.01\n", + "3 0.004975 0.004975 1.000000 0.01\n", + "4 1.000000 1.000000 0.004975 0.01" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "display(df.head())" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "c4dbdaf1-9af7-4e6d-83b6-a9cabc18dc91", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, axs = plt.subplots(3, 1, figsize=(8, 6), sharey=True, sharex=True)\n", "axs = axs.flatten()\n", diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index f0f41dc9a..d2c4ca4d4 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -513,9 +513,7 @@ def _statistic( metric_func: Callable[[ArrayLike, ArrayLike], float] = METRIC_FUNCTIONS[metric] rng = np.random.default_rng(self.random_state) - posterior_arr = np.full( - (self.n_estimators, self.n_samples_test_, estimator.n_outputs_), np.nan - ) + posterior_arr = np.full((self.n_estimators, self._n_samples_, estimator.n_outputs_), np.nan) if self.permute_per_tree: # now initialize posterior array as (n_trees, n_samples_test, n_outputs) for idx, (indices_train, indices_test) in enumerate(self._get_estimators_indices()): @@ -526,18 +524,6 @@ def _statistic( # Fill test set posteriors & set rest NaN posterior_arr[idx, indices_test, :] = y_pred # posterior - - # determine if there are any nans in the final posterior array - # Average all posteriors (n_samples_test, n_outputs) - posterior_forest = np.nanmean(posterior_arr, axis=0) - - # # Find the row indices with NaN values in any column - nonnan_indices = np.where(~np.isnan(posterior_forest).any(axis=1))[0] - samples = nonnan_indices - - # # Ignore all NaN values (samples not tested) - y_true_final = y[nonnan_indices, :] - posterior_arr = posterior_arr[:, (nonnan_indices), :] else: # fitting a forest will only get one unique train/test split indices_train, indices_test = self.train_test_samples_[0] @@ -556,16 +542,31 @@ def _statistic( ) X_train[:, covariate_index] = X_train[index_arr, covariate_index] + if self._type_of_target_ == "binary": + y_train = y_train.ravel() estimator.fit(X_train, y_train) # construct posterior array for all trees (n_trees, n_samples_test, n_outputs) for itree, tree in enumerate(estimator.estimators_): - posterior_arr[itree, ...] = tree.predict(X_test) + posterior_arr[itree, indices_test, ...] = tree.predict(X_test).reshape( + -1, tree.n_outputs_ + ) # set variables to compute metric samples = indices_test y_true_final = y_test + # determine if there are any nans in the final posterior array + temp_posterior_forest = np.nanmean(posterior_arr, axis=0) + nonnan_indices = np.where(~np.isnan(temp_posterior_forest).any(axis=1))[0] + + # Find the row indices with NaN values in any column + samples = nonnan_indices + + # Ignore all NaN values (samples not tested) + y_true_final = y[(nonnan_indices), :] + posterior_arr = posterior_arr[:, (nonnan_indices), :] + # Average all posteriors (n_samples_test, n_outputs) to compute the statistic posterior_forest = np.nanmean(posterior_arr, axis=0) stat = metric_func(y_true_final, posterior_forest, **metric_kwargs) From 39aef2ab816e85746291c6c478a96028701a3481 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Mon, 2 Oct 2023 13:49:45 -0400 Subject: [PATCH 51/70] Add some todos and fixes from quick call w/ sambit/hao Signed-off-by: Adam Li --- sktree/__init__.py | 10 ++++++++++ sktree/ensemble/_honest_forest.py | 13 ++++++++----- sktree/stats/forestht.py | 12 ++++++++++-- 3 files changed, 28 insertions(+), 7 deletions(-) diff --git a/sktree/__init__.py b/sktree/__init__.py index c6af80ea0..87de95f28 100644 --- a/sktree/__init__.py +++ b/sktree/__init__.py @@ -43,6 +43,12 @@ ExtraTreesClassifier, ExtraTreesRegressor, ) + from ._lib.sklearn.tree import ( + DecisionTreeClassifier, + DecisionTreeRegressor, + ExtraTreeClassifier, + ExtraTreeRegressor, + ) from .neighbors import NearestNeighborsMetaEstimator from .ensemble import ExtendedIsolationForest from .ensemble._unsupervised_forest import ( @@ -85,4 +91,8 @@ "ExtraTreesClassifier", "ExtraTreesRegressor", "ExtendedIsolationForest", + "DecisionTreeClassifier", + "DecisionTreeRegressor", + "ExtraTreeClassifier", + "ExtraTreeRegressor", ] diff --git a/sktree/ensemble/_honest_forest.py b/sktree/ensemble/_honest_forest.py index 5ab5eca64..63249f179 100644 --- a/sktree/ensemble/_honest_forest.py +++ b/sktree/ensemble/_honest_forest.py @@ -15,6 +15,9 @@ DTYPE = _sklearn_tree.DTYPE +# TODO: throw error and check if sklearn.tree.BaseDecisionTree, +# or sktree.tree.BaseDecisionTree (i.e. fork of sklearn.tree.BaseDecisionTree) + class HonestForestClassifier(ForestClassifier): """ @@ -449,12 +452,12 @@ def _predict_proba(self, X, indices=None, impute_missing=None): posteriors = [ np.zeros((X.shape[0], j), dtype=np.float64) for j in np.atleast_1d(self.n_classes_) ] - lock = threading.Lock() - if indices is None: indices = [None] * self.n_estimators + + lock = threading.Lock() Parallel(n_jobs=n_jobs, verbose=self.verbose, require="sharedmem")( - delayed(_accumulate_prediction)(tree, X, posteriors, lock, idx) + delayed(_accumulate_prediction)(tree.predict_proba, X, posteriors, lock, idx) for tree, idx in zip(self.estimators_, indices) ) @@ -579,7 +582,7 @@ def get_leaf_node_samples(self, X): return self.estimator_.get_leaf_node_samples(X) -def _accumulate_prediction(tree, X, out, lock, indices=None): +def _accumulate_prediction(predict, X, out, lock, indices=None): """ See https://github.com/scikit-learn/scikit-learn/blob/ 95119c13af77c76e150b753485c662b7c52a41a2/sklearn/ensemble/_forest.py#L460 @@ -590,7 +593,7 @@ def _accumulate_prediction(tree, X, out, lock, indices=None): if indices is None: indices = np.arange(X.shape[0]) - proba = tree.predict_proba(X[indices], check_input=False) + proba = predict(X[indices], check_input=False) with lock: if len(out) == 1: diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index d2c4ca4d4..7b8ad4f48 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -55,6 +55,12 @@ def __init__( def n_estimators(self): return self.estimator_.n_estimators + @property + def n_classes_(self): + return self.estimator_.n_classes_ + + # tODO: replace all instances of estimator.n_classes_ with self.n_classes_ + def reset(self): class_attributes = dir(type(self)) instance_attributes = dir(self) @@ -204,7 +210,7 @@ def statistic( self.estimator_ = self._get_estimator() estimator = self.estimator_ else: - self.permuted_estimator_ = clone(self.estimator_) + self.permuted_estimator_ = self._get_estimator() estimator = self.permuted_estimator_ # Infer type of target y @@ -313,6 +319,8 @@ def test( """ X, y, covariate_index = self._check_input(X, y, covariate_index) + # TODO: need to add a more robust check to ensure that the estimator is correct when + # refitting if self._n_samples_ is None: # first compute the test statistic on the un-permuted data observe_stat, observe_posteriors, observe_samples = self.statistic( @@ -497,7 +505,7 @@ def _get_estimator(self): raise RuntimeError(f"Estimator must be a ForestRegressor, got {type(self.estimator)}") else: estimator_ = self.estimator - return estimator_ + return clone(estimator_) def _statistic( self, From 48d889b4536d6cdb7c18f6822decacae683a2c34 Mon Sep 17 00:00:00 2001 From: Sambit Panda Date: Mon, 2 Oct 2023 21:11:57 -0400 Subject: [PATCH 52/70] set covariate_index to None by default and change self.n_classes --- sktree/stats/forestht.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 7b8ad4f48..682313e2e 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -275,7 +275,7 @@ def test( self, X, y, - covariate_index: ArrayLike, + covariate_index: ArrayLike = None, metric: str = "mse", n_repeats: int = 1000, return_posteriors: bool = False, @@ -725,9 +725,7 @@ def _statistic( if predict_posteriors: # now initialize posterior array as (n_trees, n_samples_test, n_classes) - posterior_arr = np.full( - (self.n_estimators, self._n_samples_, estimator.n_classes_), np.nan - ) + posterior_arr = np.full((self.n_estimators, self._n_samples_, self.n_classes_), np.nan) else: # now initialize posterior array as (n_trees, n_samples_test, n_outputs) posterior_arr = np.full( From bbb5c7c0f9d470b0114c0eb3c25673cfd72de1b8 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Mon, 2 Oct 2023 21:14:15 -0400 Subject: [PATCH 53/70] Fix a few issues and consolidate todos Signed-off-by: Adam Li --- doc/api.rst | 9 ++ sktree/__init__.py | 10 --- sktree/ensemble/_honest_forest.py | 7 +- sktree/stats/forestht.py | 14 ++- sktree/tree/__init__.py | 9 +- sktree/tree/_classes.py | 120 ++++++++++++++++++++++++++ sktree/tree/_honest_tree.py | 28 +++--- sktree/tree/tests/test_honest_tree.py | 11 +++ 8 files changed, 167 insertions(+), 41 deletions(-) diff --git a/doc/api.rst b/doc/api.rst index ecaa78ecb..2a74a7a01 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -34,6 +34,15 @@ to the scikit-learn estimators. ExtraTreesClassifier ExtraTreesRegressor +.. currentmodule:: sktree.tree +.. autosummary:: + :toctree: generated/ + + DecisionTreeClassifier + DecisionTreeRegressor + ExtraTreeClassifier + ExtraTreeRegressor + Supervised ---------- Decision-tree models are traditionally implemented with axis-aligned splits and diff --git a/sktree/__init__.py b/sktree/__init__.py index 87de95f28..c6af80ea0 100644 --- a/sktree/__init__.py +++ b/sktree/__init__.py @@ -43,12 +43,6 @@ ExtraTreesClassifier, ExtraTreesRegressor, ) - from ._lib.sklearn.tree import ( - DecisionTreeClassifier, - DecisionTreeRegressor, - ExtraTreeClassifier, - ExtraTreeRegressor, - ) from .neighbors import NearestNeighborsMetaEstimator from .ensemble import ExtendedIsolationForest from .ensemble._unsupervised_forest import ( @@ -91,8 +85,4 @@ "ExtraTreesClassifier", "ExtraTreesRegressor", "ExtendedIsolationForest", - "DecisionTreeClassifier", - "DecisionTreeRegressor", - "ExtraTreeClassifier", - "ExtraTreeRegressor", ] diff --git a/sktree/ensemble/_honest_forest.py b/sktree/ensemble/_honest_forest.py index 63249f179..e40773594 100644 --- a/sktree/ensemble/_honest_forest.py +++ b/sktree/ensemble/_honest_forest.py @@ -15,9 +15,6 @@ DTYPE = _sklearn_tree.DTYPE -# TODO: throw error and check if sklearn.tree.BaseDecisionTree, -# or sktree.tree.BaseDecisionTree (i.e. fork of sklearn.tree.BaseDecisionTree) - class HonestForestClassifier(ForestClassifier): """ @@ -190,7 +187,9 @@ class HonestForestClassifier(ForestClassifier): tree_estimator : object, default=None Type of decision tree classifier to use. By default `None`, which - defaults to :class:`sklearn.tree.DecisionTreeClassifier`. + defaults to `sktree.tree.DecisionTreeClassifier`. Note + that one MUST use trees imported from the `sktree.tree` + API namespace rather than from `sklearn.tree`. Attributes ---------- diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 7b8ad4f48..8874ccaf5 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -50,17 +50,12 @@ def __init__( self._covariate_index_cache_ = None self._type_of_target_ = None self.n_features_in_ = None + self._is_fitted = False @property def n_estimators(self): return self.estimator_.n_estimators - @property - def n_classes_(self): - return self.estimator_.n_classes_ - - # tODO: replace all instances of estimator.n_classes_ with self.n_classes_ - def reset(self): class_attributes = dir(type(self)) instance_attributes = dir(self) @@ -75,6 +70,7 @@ def reset(self): self._type_of_target_ = None self._metric = None self.n_features_in_ = None + self._is_fitted = False def _get_estimators_indices(self): indices = np.arange(self._n_samples_, dtype=int) @@ -319,9 +315,7 @@ def test( """ X, y, covariate_index = self._check_input(X, y, covariate_index) - # TODO: need to add a more robust check to ensure that the estimator is correct when - # refitting - if self._n_samples_ is None: + if self._is_fitted: # first compute the test statistic on the un-permuted data observe_stat, observe_posteriors, observe_samples = self.statistic( X, @@ -585,6 +579,7 @@ def _statistic( self.y_true_final_ = y_true_final self.posterior_final_ = posterior_arr self.stat_ = stat + self._is_fitted = True if return_posteriors: return stat, posterior_arr, samples @@ -815,6 +810,7 @@ def _statistic( self.y_true_final_ = y_true_final self.posterior_final_ = posterior_arr self.stat_ = stat + self._is_fitted = True if return_posteriors: return stat, posterior_arr, samples diff --git a/sktree/tree/__init__.py b/sktree/tree/__init__.py index be8baf5db..1ed18f3f0 100644 --- a/sktree/tree/__init__.py +++ b/sktree/tree/__init__.py @@ -1,4 +1,9 @@ -from .._lib.sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor +from .._lib.sklearn.tree import ( + DecisionTreeClassifier, + DecisionTreeRegressor, + ExtraTreeClassifier, + ExtraTreeRegressor, +) from ._classes import ( ExtraObliqueDecisionTreeClassifier, ExtraObliqueDecisionTreeRegressor, @@ -25,4 +30,6 @@ "HonestTreeClassifier", "DecisionTreeClassifier", "DecisionTreeRegressor", + "ExtraTreeClassifier", + "ExtraTreeRegressor", ] diff --git a/sktree/tree/_classes.py b/sktree/tree/_classes.py index 1fd839ab7..24c25afcf 100644 --- a/sktree/tree/_classes.py +++ b/sktree/tree/_classes.py @@ -704,6 +704,20 @@ class ObliqueDecisionTreeClassifier(SimMatrixMixin, DecisionTreeClassifier): ``(max_features, n_features)``. Thus this value must always be less than ``n_features`` in order to be valid. + ccp_alpha : non-negative float, default=0.0 + Not used. + + store_leaf_values : bool, default=False + Whether to store the leaf values. + + monotonic_cst : array-like of int of shape (n_features), default=None + Indicates the monotonicity constraint to enforce on each feature. + - 1: monotonic increase + - 0: no constraint + - -1: monotonic decrease + + Not used. + Attributes ---------- classes_ : ndarray of shape (n_classes,) or list of ndarray @@ -825,6 +839,9 @@ def __init__( min_impurity_decrease=0.0, class_weight=None, feature_combinations=None, + ccp_alpha=None, + store_leaf_values=False, + monotonic_cst=None, ): super().__init__( criterion=criterion, @@ -838,6 +855,9 @@ def __init__( class_weight=class_weight, random_state=random_state, min_impurity_decrease=min_impurity_decrease, + ccp_alpha=ccp_alpha, + store_leaf_values=store_leaf_values, + monotonic_cst=monotonic_cst, ) self.feature_combinations = feature_combinations @@ -1080,6 +1100,20 @@ class ObliqueDecisionTreeRegressor(SimMatrixMixin, DecisionTreeRegressor): ``(max_features, n_features)``. Thus this value must always be less than ``n_features`` in order to be valid. + ccp_alpha : non-negative float, default=0.0 + Not used. + + store_leaf_values : bool, default=False + Whether to store the leaf values. + + monotonic_cst : array-like of int of shape (n_features), default=None + Indicates the monotonicity constraint to enforce on each feature. + - 1: monotonic increase + - 0: no constraint + - -1: monotonic decrease + + Not used. + Attributes ---------- feature_importances_ : ndarray of shape (n_features,) @@ -1186,6 +1220,9 @@ def __init__( max_leaf_nodes=None, min_impurity_decrease=0.0, feature_combinations=None, + ccp_alpha=None, + store_leaf_values=False, + monotonic_cst=None, ): super().__init__( criterion=criterion, @@ -1198,6 +1235,9 @@ def __init__( max_leaf_nodes=max_leaf_nodes, random_state=random_state, min_impurity_decrease=min_impurity_decrease, + ccp_alpha=ccp_alpha, + store_leaf_values=store_leaf_values, + monotonic_cst=monotonic_cst, ) self.feature_combinations = feature_combinations @@ -1472,6 +1512,20 @@ class PatchObliqueDecisionTreeClassifier(SimMatrixMixin, DecisionTreeClassifier) as follows: for every patch that is sampled, the feature weights over the entire patch is summed and normalizes the patch. + ccp_alpha : non-negative float, default=0.0 + Not used. + + store_leaf_values : bool, default=False + Whether to store the leaf values. + + monotonic_cst : array-like of int of shape (n_features), default=None + Indicates the monotonicity constraint to enforce on each feature. + - 1: monotonic increase + - 0: no constraint + - -1: monotonic decrease + + Not used. + Attributes ---------- classes_ : ndarray of shape (n_classes,) or list of ndarray @@ -1574,6 +1628,9 @@ def __init__( data_dims=None, boundary=None, feature_weight=None, + ccp_alpha=None, + store_leaf_values=False, + monotonic_cst=None, ): super().__init__( criterion=criterion, @@ -1587,6 +1644,9 @@ def __init__( class_weight=class_weight, random_state=random_state, min_impurity_decrease=min_impurity_decrease, + ccp_alpha=ccp_alpha, + store_leaf_values=store_leaf_values, + monotonic_cst=monotonic_cst, ) self.min_patch_dims = min_patch_dims @@ -1913,6 +1973,20 @@ class PatchObliqueDecisionTreeRegressor(SimMatrixMixin, DecisionTreeRegressor): as follows: for every patch that is sampled, the feature weights over the entire patch is summed and normalizes the patch. + ccp_alpha : non-negative float, default=0.0 + Not used. + + store_leaf_values : bool, default=False + Whether to store the leaf values. + + monotonic_cst : array-like of int of shape (n_features), default=None + Indicates the monotonicity constraint to enforce on each feature. + - 1: monotonic increase + - 0: no constraint + - -1: monotonic decrease + + Not used. + Attributes ---------- feature_importances_ : ndarray of shape (n_features,) @@ -2018,6 +2092,9 @@ def __init__( data_dims=None, boundary=None, feature_weight=None, + ccp_alpha=None, + store_leaf_values=False, + monotonic_cst=None, ): super().__init__( criterion=criterion, @@ -2030,6 +2107,9 @@ def __init__( max_leaf_nodes=max_leaf_nodes, random_state=random_state, min_impurity_decrease=min_impurity_decrease, + ccp_alpha=ccp_alpha, + store_leaf_values=store_leaf_values, + monotonic_cst=monotonic_cst, ) self.min_patch_dims = min_patch_dims @@ -2363,6 +2443,20 @@ class ExtraObliqueDecisionTreeClassifier(SimMatrixMixin, DecisionTreeClassifier) ``(max_features, n_features)``. Thus this value must always be less than ``n_features`` in order to be valid. + ccp_alpha : non-negative float, default=0.0 + Not used. + + store_leaf_values : bool, default=False + Whether to store the leaf values. + + monotonic_cst : array-like of int of shape (n_features), default=None + Indicates the monotonicity constraint to enforce on each feature. + - 1: monotonic increase + - 0: no constraint + - -1: monotonic decrease + + Not used. + Attributes ---------- classes_ : ndarray of shape (n_classes,) or list of ndarray @@ -2488,6 +2582,9 @@ def __init__( min_impurity_decrease=0.0, class_weight=None, feature_combinations=None, + ccp_alpha=None, + store_leaf_values=False, + monotonic_cst=None, ): super().__init__( criterion=criterion, @@ -2501,6 +2598,9 @@ def __init__( class_weight=class_weight, random_state=random_state, min_impurity_decrease=min_impurity_decrease, + ccp_alpha=ccp_alpha, + store_leaf_values=store_leaf_values, + monotonic_cst=monotonic_cst, ) self.feature_combinations = feature_combinations @@ -2752,6 +2852,20 @@ class ExtraObliqueDecisionTreeRegressor(SimMatrixMixin, DecisionTreeRegressor): ``(max_features, n_features)``. Thus this value must always be less than ``n_features`` in order to be valid. + ccp_alpha : non-negative float, default=0.0 + Not used. + + store_leaf_values : bool, default=False + Whether to store the leaf values. + + monotonic_cst : array-like of int of shape (n_features), default=None + Indicates the monotonicity constraint to enforce on each feature. + - 1: monotonic increase + - 0: no constraint + - -1: monotonic decrease + + Not used. + Attributes ---------- feature_importances_ : ndarray of shape (n_features,) @@ -2859,6 +2973,9 @@ def __init__( max_leaf_nodes=None, min_impurity_decrease=0.0, feature_combinations=None, + ccp_alpha=None, + store_leaf_values=False, + monotonic_cst=None, ): super().__init__( criterion=criterion, @@ -2871,6 +2988,9 @@ def __init__( max_leaf_nodes=max_leaf_nodes, random_state=random_state, min_impurity_decrease=min_impurity_decrease, + ccp_alpha=ccp_alpha, + store_leaf_values=store_leaf_values, + monotonic_cst=monotonic_cst, ) self.feature_combinations = feature_combinations diff --git a/sktree/tree/_honest_tree.py b/sktree/tree/_honest_tree.py index 8e0f2321d..7d534ddb9 100644 --- a/sktree/tree/_honest_tree.py +++ b/sktree/tree/_honest_tree.py @@ -1,11 +1,10 @@ # Authors: Ronan Perry, Sambit Panda, Haoyin Xu # Adopted from: https://github.com/neurodata/honest-forests -import inspect - import numpy as np from sklearn.base import ClassifierMixin, MetaEstimatorMixin, _fit_context, clone from sklearn.ensemble._base import _set_random_states +from sklearn.tree._classes import BaseDecisionTree as skBaseDecisionTree from sklearn.utils.multiclass import _check_partial_fit_first_call, check_classification_targets from sklearn.utils.validation import check_is_fitted, check_X_y @@ -152,9 +151,10 @@ class HonestTreeClassifier(MetaEstimatorMixin, ClassifierMixin, BaseDecisionTree Read more in the :ref:`User Guide `. tree_estimator : object, default=None - Instatiated tree of type BaseDecisionTree. + Instatiated tree of type BaseDecisionTree from sktree. If None, then DecisionTreeClassifier with default parameters will - be used. + be used. Note that one MUST use trees imported from the `sktree.tree` + API namespace rather than from `sklearn.tree`. honest_fraction : float, default=0.5 Fraction of training samples used for estimates in the leaves. The @@ -555,6 +555,10 @@ def _fit( store_leaf_values=self.store_leaf_values, ) else: + # we throw an error if the user is using trees from sklearn:main + if isinstance(self.tree_estimator, skBaseDecisionTree): + raise RuntimeError("Instead of using sklearn.tree, use trees import from sktree.") + # XXX: maybe error out if the tree_estimator is already fitted self.estimator_ = clone(self.tree_estimator) self.estimator_.set_params( @@ -570,22 +574,12 @@ def _fit( class_weight=self.class_weight, random_state=self.random_state, min_impurity_decrease=self.min_impurity_decrease, + ccp_alpha=self.ccp_alpha, + monotonic_cst=self.monotonic_cst, + store_leaf_values=self.store_leaf_values, ) ) - # TODO: refactor oblique trees to have these parameters by default, but not used - init_signature = inspect.signature(self.estimator_.__init__) - if "ccp_alpha" in init_signature.parameters: - self.estimator_.set_params(**dict(ccp_alpha=self.ccp_alpha)) - if "store_leaf_values" in init_signature.parameters: - self.estimator_.set_params( - **dict( - store_leaf_values=self.store_leaf_values, - ) - ) - if "monotonic_cst" in init_signature.parameters: - self.estimator_.set_params(**dict(monotonic_cst=self.monotonic_cst)) - if self.random_state is not None: _set_random_states(self.estimator_, self.random_state) diff --git a/sktree/tree/tests/test_honest_tree.py b/sktree/tree/tests/test_honest_tree.py index cc130a14a..92dc99845 100644 --- a/sktree/tree/tests/test_honest_tree.py +++ b/sktree/tree/tests/test_honest_tree.py @@ -2,6 +2,7 @@ import pytest from sklearn import datasets from sklearn.metrics import accuracy_score +from sklearn.tree import DecisionTreeClassifier as skDecisionTreeClassifier from sklearn.utils.estimator_checks import parametrize_with_checks from sktree._lib.sklearn.tree import DecisionTreeClassifier @@ -117,3 +118,13 @@ def test_sklearn_compatible_estimator(estimator, check): if check.func.__name__ in ["check_class_weight_classifiers", "check_classifier_multioutput"]: pytest.skip() check(estimator) + + +def test_error_with_sklearn_trees(): + X = np.ones((20, 4)) + X[10:] *= -1 + y = [0] * 10 + [1] * 10 + + with pytest.raises(RuntimeError, match="Instead of using sklearn.tree"): + clf = HonestTreeClassifier(tree_estimator=skDecisionTreeClassifier()) + clf.fit(X, y) From 5ad1b4482f2f650dc6af4f860a8c7a174c39d554 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Mon, 2 Oct 2023 21:32:01 -0400 Subject: [PATCH 54/70] Fix Signed-off-by: Adam Li --- sktree/stats/forestht.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 499db6e25..cd19e2571 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -315,7 +315,7 @@ def test( """ X, y, covariate_index = self._check_input(X, y, covariate_index) - if self._is_fitted: + if not self._is_fitted: # first compute the test statistic on the un-permuted data observe_stat, observe_posteriors, observe_samples = self.statistic( X, @@ -720,7 +720,9 @@ def _statistic( if predict_posteriors: # now initialize posterior array as (n_trees, n_samples_test, n_classes) - posterior_arr = np.full((self.n_estimators, self._n_samples_, self.n_classes_), np.nan) + posterior_arr = np.full( + (self.n_estimators, self._n_samples_, estimator.n_classes_), np.nan + ) else: # now initialize posterior array as (n_trees, n_samples_test, n_outputs) posterior_arr = np.full( From 80ada6891bab655af0829d66ecef08fe7ab5ee95 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Mon, 2 Oct 2023 21:40:04 -0400 Subject: [PATCH 55/70] Add clone to get estimators Signed-off-by: Adam Li --- sktree/stats/forestht.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index cd19e2571..f198cec19 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -697,7 +697,7 @@ def _get_estimator(self): else: # self.estimator is an instance of a ForestEstimator estimator_ = self.estimator - return estimator_ + return clone(estimator_) def _statistic( self, From ff377403686b38f9d1e065d06e37b5ffbf916338 Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Tue, 3 Oct 2023 10:04:19 -0400 Subject: [PATCH 56/70] ENH mark all default tests as MI and correct posterior return parameter --- sktree/stats/forestht.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index f198cec19..f41b67157 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -152,7 +152,7 @@ def statistic( X: ArrayLike, y: ArrayLike, covariate_index: ArrayLike = None, - metric="mse", + metric="mi", return_posteriors: bool = False, check_input: bool = True, **metric_kwargs, @@ -272,9 +272,9 @@ def test( X, y, covariate_index: ArrayLike = None, - metric: str = "mse", + metric: str = "mi", n_repeats: int = 1000, - return_posteriors: bool = False, + return_posteriors: bool = True, **metric_kwargs, ): """Perform hypothesis test using Coleman method. @@ -302,7 +302,7 @@ def test( n_repeats : int, optional Number of times to sample the null distribution, by default 1000. return_posteriors : bool, optional - Whether or not to return the posteriors, by default False. + Whether or not to return the posteriors, by default True. **metric_kwargs : dict, optional Additional keyword arguments to pass to the metric function. @@ -322,7 +322,7 @@ def test( y, covariate_index=None, metric=metric, - return_posteriors=True, + return_posteriors=return_posteriors, check_input=False, **metric_kwargs, ) @@ -337,7 +337,7 @@ def test( y, covariate_index=covariate_index, metric=metric, - return_posteriors=True, + return_posteriors=return_posteriors, check_input=False, **metric_kwargs, ) From aed91798acaefac0773a4dc12d430977d79bc023 Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Tue, 3 Oct 2023 10:29:24 -0400 Subject: [PATCH 57/70] FIX unify all variable names so posteriors are not saved twice Add permute_stat to class variable --- sktree/stats/forestht.py | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index f41b67157..74a4350d3 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -327,9 +327,9 @@ def test( **metric_kwargs, ) else: - observe_samples = self.samples_ - observe_posteriors = self.posterior_final_ - observe_stat = self.stat_ + observe_samples = self.observe_samples_ + observe_posteriors = self.observe_posteriors_ + observe_stat = self.observe_stat_ # next permute the data permute_stat, permute_posteriors, permute_samples = self.statistic( @@ -341,6 +341,7 @@ def test( check_input=False, **metric_kwargs, ) + self.permute_stat_ = permute_stat # Note: at this point, both `estimator` and `permuted_estimator_` should # have been fitted already, so we can now compute on the null by resampling @@ -452,7 +453,8 @@ class FeatureImportanceForestRegressor(BaseForestHT): y_true_final_ : ArrayLike of shape (n_samples_final,) The true labels of the samples used in the final test. - posterior_final_ : ArrayLike of shape (n_estimators, n_samples_final) + observe_posteriors_ : ArrayLike of shape (n_estimators, n_samples_final, n_outputs) or + (n_estimators, n_samples_final, n_classes) The predicted posterior probabilities of the samples used in the final test. null_dist_ : ArrayLike of shape (n_repeats,) @@ -575,10 +577,10 @@ def _statistic( if covariate_index is None: # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) # arrays of y and predicted posterior - self.samples_ = samples + self.observe_samples_ = samples self.y_true_final_ = y_true_final - self.posterior_final_ = posterior_arr - self.stat_ = stat + self.observe_posteriors_ = posterior_arr + self.observe_stat_ = stat self._is_fitted = True if return_posteriors: @@ -648,8 +650,8 @@ class FeatureImportanceForestClassifier(BaseForestHT): y_true_final_ : ArrayLike of shape (n_samples_final,) The true labels of the samples used in the final test. - posterior_final_ : ArrayLike of shape (n_estimators, n_samples_final, n_outputs) or - (n_estimators, n_samples_final) + observe_posteriors_ : ArrayLike of shape (n_estimators, n_samples_final, n_outputs) or + (n_estimators, n_samples_final, n_classes) The predicted posterior probabilities of the samples used in the final test. null_dist_ : ArrayLike of shape (n_repeats,) @@ -806,10 +808,10 @@ def _statistic( if covariate_index is None: # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) # arrays of y and predicted posterior - self.samples_ = samples + self.observe_samples_ = samples self.y_true_final_ = y_true_final - self.posterior_final_ = posterior_arr - self.stat_ = stat + self.observe_posteriors_ = posterior_arr + self.observe_stat_ = stat self._is_fitted = True if return_posteriors: From c7164403f5c715241dad8461538babaad25e1748 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 3 Oct 2023 13:22:21 -0400 Subject: [PATCH 58/70] Add additional testing Signed-off-by: Adam Li --- .github/workflows/main.yml | 114 +++++++++++++++++++++++++++- .spin/cmds.py | 45 +++++------ doc/conf.py | 1 + pyproject.toml | 6 +- sktree/stats/forestht.py | 32 +++++++- sktree/stats/tests/test_forestht.py | 35 +++++++++ sktree/tree/_classes.py | 12 +-- 7 files changed, 206 insertions(+), 39 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index a329c4362..12182c95f 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -116,7 +116,116 @@ jobs: ./spin --help ./spin coverage --help ./spin test --help - ./spin coverage + ./spin test + cp $PWD/build-install/usr/lib/python${{matrix.python-version}}/site-packages/coverage.xml ./coverage.xml + + - name: debug + run: | + ls $PWD/build-install/usr/lib/python${{matrix.python-version}}/site-packages/ + echo "Okay..." + ls $PWD/build + ls ./ + + - name: Save build + uses: actions/upload-artifact@v3 + with: + name: sktree-build + path: $PWD/build + + build_and_test_slow: + name: Meson build ${{ matrix.os }} - py${{ matrix.python-version }} + timeout-minutes: 20 + needs: [build_and_test] + strategy: + fail-fast: false + matrix: + os: [ubuntu-22.04] + python-version: ["3.11"] + poetry-version: [1.5.0] + runs-on: ${{ matrix.os }} + defaults: + run: + shell: bash + env: + # to make sure coverage/test command builds cleanly + FORCE_SUBMODULE: True + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Setup Python ${{ matrix.python-version }} + uses: actions/setup-python@v4.6.1 + with: + python-version: ${{ matrix.python-version }} + architecture: "x64" + cache: "pip" + cache-dependency-path: "requirements.txt" + + - name: show-gcc + run: | + gcc --version + + - name: Install Ccache for MacOSX + if: ${{ matrix.os == 'macos-latest'}} + run: | + brew install ccache + + - name: Install packages for Ubuntu + if: ${{ matrix.os == 'ubuntu-22.04'}} + run: | + sudo apt-get update + sudo apt-get install -y libopenblas-dev libatlas-base-dev liblapack-dev gfortran libgmp-dev libmpfr-dev libsuitesparse-dev ccache libmpc-dev + + - name: Install Python packages + run: | + python -m pip install -r build_requirements.txt + python -m pip install spin + python -m pip install -r test_requirements.txt + + - name: Prepare compiler cache + id: prep-ccache + shell: bash + run: | + mkdir -p "${CCACHE_DIR}" + echo "dir=$CCACHE_DIR" >> $GITHUB_OUTPUT + NOW=$(date -u +"%F-%T") + echo "timestamp=${NOW}" >> $GITHUB_OUTPUT + + - name: Setup compiler cache + uses: actions/cache@v3 + id: cache-ccachev1 + # Reference: https://docs.github.com/en/actions/guides/caching-dependencies-to-speed-up-workflows#matching-a-cache-key + # NOTE: The caching strategy is modeled in a way that it will always have a unique cache key for each workflow run + # (even if the same workflow is run multiple times). The restore keys are not unique and for a partial match, they will + # return the most recently created cache entry, according to the GitHub Action Docs. + with: + path: ${{ steps.prep-ccache.outputs.dir }} + # Restores ccache from either a previous build on this branch or on main + key: ${{ github.workflow }}-${{ matrix.python-version }}-ccache-linux-${{ steps.prep-ccache.outputs.timestamp }} + # This evaluates to `Linux Tests-3.9-ccache-linux-` which is not unique. As the CI matrix is expanded, this will + # need to be updated to be unique so that the cache is not restored from a different job altogether. + restore-keys: | + ${{ github.workflow }}-${{ matrix.python-version }}-ccache-linux- + + - name: Setup build and install scikit-tree + run: | + ./spin build -j 2 --forcesubmodule + + - name: Ccache performance + shell: bash -l {0} + run: ccache -s + + - name: build-path + run: | + echo "$PWD/build-install/" + export INSTALLED_PATH=$PWD/build-install/usr/lib/python${{matrix.python-version}}/site-packages + + - name: Run unit tests and coverage + run: | + ./spin --help + ./spin coverage --help + ./spin test --help + ./spin coverage -k "slowtest" cp $PWD/build-install/usr/lib/python${{matrix.python-version}}/site-packages/coverage.xml ./coverage.xml - name: debug @@ -127,7 +236,6 @@ jobs: ls ./ - name: Upload coverage stats to codecov - if: ${{ matrix.os == 'ubuntu-22.04' && matrix.python-version == '3.10'}} uses: codecov/codecov-action@v3 with: # python spin goes into the INSTALLED path in order to run pytest @@ -146,7 +254,7 @@ jobs: release: name: Release runs-on: ubuntu-latest - needs: [build_and_test] + needs: [build_and_test_slow] if: startsWith(github.ref, 'refs/tags/') steps: - name: Checkout repository diff --git a/.spin/cmds.py b/.spin/cmds.py index 5b8585dde..b7f2cd863 100644 --- a/.spin/cmds.py +++ b/.spin/cmds.py @@ -1,5 +1,4 @@ import os -import shutil import subprocess import sys @@ -13,33 +12,27 @@ def get_git_revision_hash(submodule) -> str: @click.command() -@click.option("--build-dir", default="build", help="Build directory; default is `$PWD/build`") -@click.option("--clean", is_flag=True, help="Clean previously built docs before building") -@click.option("--noplot", is_flag=True, help="Build docs without plots") +@click.argument("slowtest", default=True) @click.pass_context -def docs(ctx, build_dir, clean=False, noplot=False): - """📖 Build documentation""" - if clean: - doc_dir = "./docs/_build" - if os.path.isdir(doc_dir): - print(f"Removing `{doc_dir}`") - shutil.rmtree(doc_dir) - - site_path = meson._get_site_packages() - if site_path is None: - print("No built scikit-tree found; run `./spin build` first.") - sys.exit(1) - - util.run(["pip", "install", "-q", "-r", "doc_requirements.txt"]) - - ctx.invoke(meson.docs) - - -@click.command() -@click.pass_context -def coverage(ctx): +def coverage(ctx, slowtest): """📊 Generate coverage report""" - pytest_args = ("-o", "python_functions=test_*", "sktree", "--cov=sktree", "--cov-report=xml") + if slowtest: + pytest_args = ( + "-o", + "python_functions=test_*", + "sktree", + "--cov=sktree", + "--cov-report=xml", + "-k slowtest", + ) + else: + pytest_args = ( + "-o", + "python_functions=test_*", + "sktree", + "--cov=sktree", + "--cov-report=xml", + ) ctx.invoke(meson.test, pytest_args=pytest_args) diff --git a/doc/conf.py b/doc/conf.py index fa949235e..33b43e88b 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -240,6 +240,7 @@ "predict", "fit", "apply", + "TreeBuilder", } # validation diff --git a/pyproject.toml b/pyproject.toml index d032d2c5d..544710691 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -235,7 +235,7 @@ exclude = [ [tool.pytest.ini_options] minversion = '6.0' -addopts = '--durations 20 --junit-xml=junit-results.xml --verbose --ignore=sktree/_lib/' +addopts = '--durations 20 --junit-xml=junit-results.xml --verbose --ignore=sktree/_lib/ -k "not slowtest"' filterwarnings = [] [tool.coverage.run] @@ -267,7 +267,9 @@ Environments = [ 'spin.cmds.meson.ipython', 'spin.cmds.meson.python', ] -Documentation = ['.spin/cmds.py:docs'] +Documentation = [ + 'spin.cmds.meson.docs' + ] Metrics = [ '.spin/cmds.py:coverage', '.spin/cmds.py:asv', diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 74a4350d3..5ce124174 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -1,4 +1,4 @@ -from typing import Callable +from typing import Callable, Tuple import numpy as np from numpy.typing import ArrayLike @@ -28,6 +28,13 @@ class BaseForestHT(MetaEstimatorMixin): + observe_samples_: ArrayLike + observe_posteriors_: ArrayLike + observe_stat_: float + permute_samples_: ArrayLike + permute_posteriors_: ArrayLike + permute_stat_: float + def __init__( self, estimator=None, @@ -129,6 +136,13 @@ def _check_input(self, X: ArrayLike, y: ArrayLike, covariate_index: ArrayLike = if y.ndim != 2: y = y.reshape(-1, 1) + if covariate_index is not None: + if not isinstance(covariate_index, (list, tuple, np.ndarray)): + raise RuntimeError("covariate_index must be an iterable of integer indices") + else: + if not all(isinstance(idx, int) for idx in covariate_index): + raise RuntimeError("Not all covariate_index are integer indices") + if self._n_samples_ is not None and X.shape[0] != self._n_samples_: raise RuntimeError( f"X must have {self._n_samples_} samples, got {X.shape[0]}. " @@ -156,7 +170,7 @@ def statistic( return_posteriors: bool = False, check_input: bool = True, **metric_kwargs, - ): + ) -> Tuple[float, ArrayLike, ArrayLike]: """Compute the test statistic. Parameters @@ -503,6 +517,20 @@ def _get_estimator(self): estimator_ = self.estimator return clone(estimator_) + def statistic( + self, + X: ArrayLike, + y: ArrayLike, + covariate_index: ArrayLike = None, + metric="mse", + return_posteriors: bool = False, + check_input: bool = True, + **metric_kwargs, + ): + return super().statistic( + X, y, covariate_index, metric, return_posteriors, check_input, **metric_kwargs + ) + def _statistic( self, estimator: ForestClassifier, diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 05aaae129..925c62f1f 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -1,6 +1,7 @@ import numpy as np import pytest from flaky import flaky +from joblib import Parallel, delayed from scipy.special import expit from sklearn import datasets @@ -58,6 +59,14 @@ def test_featureimportance_forest_permute_pertree(sample_dataset_per_tree): with pytest.raises(RuntimeError, match="Metric must be"): est.statistic(iris_X[:n_samples], iris_y[:n_samples], metric="mi") + # covariate index must be an iterable + with pytest.raises(RuntimeError, match="covariate_index must be an iterable"): + est.statistic(iris_X[:n_samples], iris_y[:n_samples], 0, metric="mi") + + # covariate index must be an iterable of ints + with pytest.raises(RuntimeError, match="Not all covariate_index"): + est.statistic(iris_X[:n_samples], iris_y[:n_samples], [0, 1.0], metric="mi") + def test_featureimportance_forest_errors(): permute_per_tree = False @@ -257,6 +266,7 @@ def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, @flaky(max_runs=2) +@pytest.mark.slowtest @pytest.mark.parametrize("criterion", ["gini", "entropy"]) @pytest.mark.parametrize("honest_prior", ["empirical", "uniform"]) @pytest.mark.parametrize( @@ -377,3 +387,28 @@ def test_forestht_check_inputs(forest_hyppo): y_invalid = np.random.rand(X.shape[0]) with pytest.raises(RuntimeError, match="y must have type"): forest_hyppo.statistic(X, y_invalid) + + +def test_parallelization(): + """Test parallelization of training forests.""" + n_samples = 100 + n_features = 5 + X = rng.uniform(size=(n_samples, n_features)) + y = rng.integers(0, 2, size=n_samples) # Binary classification + + def run_forest(covariate_index=None): + clf = FeatureImportanceForestClassifier( + estimator=HonestForestClassifier( + n_estimators=10, + random_state=seed, + n_jobs=1, + ), + ) + obs_stat = clf.statistic(X, y, metric="mi") + perm_stat = clf.statistic(X, y, covariate_index=[covariate_index], metric="mi") + return obs_stat, perm_stat + + out = Parallel(n_jobs=1)( + delayed(run_forest)(covariate_index) for covariate_index in range(n_features) + ) + assert len(out) == n_features diff --git a/sktree/tree/_classes.py b/sktree/tree/_classes.py index 24c25afcf..a9e00c6d0 100644 --- a/sktree/tree/_classes.py +++ b/sktree/tree/_classes.py @@ -839,7 +839,7 @@ def __init__( min_impurity_decrease=0.0, class_weight=None, feature_combinations=None, - ccp_alpha=None, + ccp_alpha=0.0, store_leaf_values=False, monotonic_cst=None, ): @@ -1220,7 +1220,7 @@ def __init__( max_leaf_nodes=None, min_impurity_decrease=0.0, feature_combinations=None, - ccp_alpha=None, + ccp_alpha=0.0, store_leaf_values=False, monotonic_cst=None, ): @@ -1628,7 +1628,7 @@ def __init__( data_dims=None, boundary=None, feature_weight=None, - ccp_alpha=None, + ccp_alpha=0.0, store_leaf_values=False, monotonic_cst=None, ): @@ -2092,7 +2092,7 @@ def __init__( data_dims=None, boundary=None, feature_weight=None, - ccp_alpha=None, + ccp_alpha=0.0, store_leaf_values=False, monotonic_cst=None, ): @@ -2582,7 +2582,7 @@ def __init__( min_impurity_decrease=0.0, class_weight=None, feature_combinations=None, - ccp_alpha=None, + ccp_alpha=0.0, store_leaf_values=False, monotonic_cst=None, ): @@ -2973,7 +2973,7 @@ def __init__( max_leaf_nodes=None, min_impurity_decrease=0.0, feature_combinations=None, - ccp_alpha=None, + ccp_alpha=0.0, store_leaf_values=False, monotonic_cst=None, ): From f6cb04b380eedc219df81dd6d02f5e5a58231a85 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 3 Oct 2023 13:44:22 -0400 Subject: [PATCH 59/70] Fix CI Signed-off-by: Adam Li --- .github/workflows/main.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 12182c95f..ea1f78ee8 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -117,7 +117,6 @@ jobs: ./spin coverage --help ./spin test --help ./spin test - cp $PWD/build-install/usr/lib/python${{matrix.python-version}}/site-packages/coverage.xml ./coverage.xml - name: debug run: | @@ -133,7 +132,7 @@ jobs: path: $PWD/build build_and_test_slow: - name: Meson build ${{ matrix.os }} - py${{ matrix.python-version }} + name: Slow Meson build ${{ matrix.os }} - py${{ matrix.python-version }} timeout-minutes: 20 needs: [build_and_test] strategy: From 8df008d786e0d4ae5e5e6981d2551a12d256c8b0 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Tue, 3 Oct 2023 13:52:10 -0400 Subject: [PATCH 60/70] Adding parallelization test Signed-off-by: Adam Li --- sktree/stats/forestht.py | 3 +++ sktree/stats/tests/test_forestht.py | 16 ++++++++-------- 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 5ce124174..66bee9c15 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -819,6 +819,9 @@ def _statistic( ) # determine if there are any nans in the final posterior array + print(posterior_arr.shape) + print(posterior_arr) + print(np.nanmean(posterior_arr, axis=0).shape) temp_posterior_forest = np.nanmean(posterior_arr, axis=0) nonnan_indices = np.where(~np.isnan(temp_posterior_forest).any(axis=1))[0] diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 925c62f1f..9b849ed22 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -389,7 +389,9 @@ def test_forestht_check_inputs(forest_hyppo): forest_hyppo.statistic(X, y_invalid) -def test_parallelization(): +@pytest.mark.parametrize("backend", ["loky", "threading"]) +@pytest.mark.parametrize("n_jobs", [1, -1]) +def test_parallelization(backend, n_jobs): """Test parallelization of training forests.""" n_samples = 100 n_features = 5 @@ -399,16 +401,14 @@ def test_parallelization(): def run_forest(covariate_index=None): clf = FeatureImportanceForestClassifier( estimator=HonestForestClassifier( - n_estimators=10, - random_state=seed, - n_jobs=1, + n_estimators=10, random_state=seed, n_jobs=n_jobs, honest_fraction=0.2 ), + test_size=0.5, ) - obs_stat = clf.statistic(X, y, metric="mi") - perm_stat = clf.statistic(X, y, covariate_index=[covariate_index], metric="mi") - return obs_stat, perm_stat + pvalue = clf.test(X, y, covariate_index=[covariate_index], metric="mi") + return pvalue - out = Parallel(n_jobs=1)( + out = Parallel(n_jobs=1, backend=backend)( delayed(run_forest)(covariate_index) for covariate_index in range(n_features) ) assert len(out) == n_features From 7964d9941952868e055fc77371634c436259340f Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Tue, 3 Oct 2023 20:07:48 -0400 Subject: [PATCH 61/70] FIX remove extra print statememts --- sktree/stats/forestht.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 66bee9c15..5ce124174 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -819,9 +819,6 @@ def _statistic( ) # determine if there are any nans in the final posterior array - print(posterior_arr.shape) - print(posterior_arr) - print(np.nanmean(posterior_arr, axis=0).shape) temp_posterior_forest = np.nanmean(posterior_arr, axis=0) nonnan_indices = np.where(~np.isnan(temp_posterior_forest).any(axis=1))[0] From 8b5a7d164585a06cb0e6bc98be8d05d094673d65 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 4 Oct 2023 08:54:45 -0400 Subject: [PATCH 62/70] Remove numpy nanmean warnings and also bug fix of some code (#133) * Update Signed-off-by: Adam Li * Fix submodule Signed-off-by: Adam Li * Possible change to might code Signed-off-by: Adam Li * Add fixes Signed-off-by: Adam Li * Fix style Signed-off-by: Adam Li --------- Signed-off-by: Adam Li --- .github/workflows/main.yml | 2 +- ...mpare_coleman_and_permutation_forest.ipynb | 2855 +---------------- ...t_MI_gigantic_hypothesis_testing_forest.py | 8 +- sktree/_lib/sklearn_fork | 2 +- sktree/stats/forestht.py | 89 +- sktree/stats/tests/test_forestht.py | 68 +- sktree/stats/utils.py | 82 +- 7 files changed, 283 insertions(+), 2823 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index ea1f78ee8..a943e3d13 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -224,7 +224,7 @@ jobs: ./spin --help ./spin coverage --help ./spin test --help - ./spin coverage -k "slowtest" + ./spin coverage cp $PWD/build-install/usr/lib/python${{matrix.python-version}}/site-packages/coverage.xml ./coverage.xml - name: debug diff --git a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb index 8b5c34f46..3990764bf 100644 --- a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb +++ b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "id": "5e2d1279-fa4f-47ef-aa48-fac6d47159ad", "metadata": {}, "outputs": [], @@ -55,9 +55,9 @@ " beta = 10.0\n", " sigma = 10.0 / sigma_factor\n", " n_samples = 2200\n", - " n_estimators = 125\n", + " n_estimators = 500\n", " test_size = 0.1\n", - " n_repeats = 500\n", + " n_repeats = 1000\n", " metric = \"mse\"\n", "\n", " rng = np.random.default_rng(seed)\n", @@ -134,7 +134,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 17, "id": "3db4f740-afd9-413e-8089-a8245f2a0747", "metadata": {}, "outputs": [], @@ -152,7 +152,7 @@ " max_features = \"sqrt\"\n", " test_size = 1.0 / 6\n", " metric = \"mse\"\n", - " n_repeats = 200\n", + " n_repeats = 500\n", " permute_per_tree = True\n", " sample_dataset_per_tree = True\n", "\n", @@ -239,7 +239,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "14806903-933b-4e31-a2db-a3a45e0a6f82", "metadata": { "scrolled": true @@ -249,2814 +249,213 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n", + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "X2/7: 1.0\n" + "X1: 0.9940119760479041\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "X1: 1.0\n" + "X6: 0.36726546906187624\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "X6: 1.0\n" + "X2/7: 0.23952095808383234\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "X2/7: 1.0\n" + "X2/7: 0.49101796407185627\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n", + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "X2/7: 1.0\n" + "X1: 0.00998003992015968\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "X1: 1.0\n" + "X6: 0.3532934131736527\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n" ] - }, + } + ], + "source": [ + "pvalue_dict = defaultdict(list)\n", + "rng = np.random.default_rng(seed)\n", + "\n", + "j_space = np.linspace(0.005, 2.25, 9)\n", + "\n", + "for sigma_factor in j_space:\n", + " for idx in range(5):\n", + " new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32)\n", + "\n", + " elements_dict = linear_model_ancova(\n", + " sigma_factor,\n", + " new_seed,\n", + " permute_per_tree=False,\n", + " sample_dataset_per_tree=False,\n", + " )\n", + " for key, value in elements_dict.items():\n", + " pvalue_dict[key].append(value)\n", + " pvalue_dict[\"sigma_factor\"].append(sigma_factor)\n", + "\n", + "df = pd.DataFrame(pvalue_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "5f4eb53c-c82d-4770-836a-552b910dd736", + "metadata": {}, + "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" + "[autoreload of sktree.stats.forestht failed: Traceback (most recent call last):\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 276, in check\n", + " superreload(m, reload, self.old_objects)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 500, in superreload\n", + " update_generic(old_obj, new_obj)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 397, in update_generic\n", + " update(a, b)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 349, in update_class\n", + " if update_generic(old_obj, new_obj):\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 397, in update_generic\n", + " update(a, b)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 309, in update_function\n", + " setattr(old, name, getattr(new, name))\n", + "ValueError: statistic() requires a code object with 1 free vars, not 0\n", + "]\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", + "\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", + "\n", + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\n", + " \"Linear ANCOVA model with FeatureImportanceRegressor (Permutation per tree and sample dataset per tree)\"\n", + ")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "b470b569-4391-40e2-b7c4-a8439cc026c0", + "metadata": {}, + "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "pvalue_dict = defaultdict(list)\n", - "rng = np.random.default_rng(seed)\n", - "\n", - "j_space = np.linspace(0.005, 2.25, 9)\n", - "\n", - "for sigma_factor in j_space:\n", - " for idx in range(5):\n", - " new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32)\n", + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", "\n", - " elements_dict = linear_model_ancova(\n", - " sigma_factor,\n", - " new_seed,\n", - " permute_per_tree=True,\n", - " sample_dataset_per_tree=False,\n", - " )\n", - " for key, value in elements_dict.items():\n", - " pvalue_dict[key].append(value)\n", - " pvalue_dict[\"sigma_factor\"].append(sigma_factor)\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", "\n", - "df = pd.DataFrame(pvalue_dict)" + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\n", + " \"Linear ANCOVA model with FeatureImportanceRegressor (Permutation per tree and sample dataset per tree)\"\n", + ")\n", + "fig.tight_layout()" ] }, { diff --git a/examples/plot_MI_gigantic_hypothesis_testing_forest.py b/examples/plot_MI_gigantic_hypothesis_testing_forest.py index 8408f4e03..fd4f84765 100644 --- a/examples/plot_MI_gigantic_hypothesis_testing_forest.py +++ b/examples/plot_MI_gigantic_hypothesis_testing_forest.py @@ -90,10 +90,10 @@ # computed as the proportion of samples in the null distribution that are less than the # observed test statistic. -n_estimators = 125 +n_estimators = 200 max_features = "sqrt" test_size = 0.2 -n_repeats = 500 +n_repeats = 1000 n_jobs = -1 est = FeatureImportanceForestClassifier( @@ -107,8 +107,8 @@ ), random_state=seed, test_size=test_size, - permute_per_tree=True, - sample_dataset_per_tree=True, + permute_per_tree=False, + sample_dataset_per_tree=False, ) # we test for the first feature set, which is important and thus should return a pvalue < 0.05 diff --git a/sktree/_lib/sklearn_fork b/sktree/_lib/sklearn_fork index e2fee00aa..d9d1ea68f 160000 --- a/sktree/_lib/sklearn_fork +++ b/sktree/_lib/sklearn_fork @@ -1 +1 @@ -Subproject commit e2fee00aa461c21b8cfa59eb907d27972415c99b +Subproject commit d9d1ea68fde4f0bf90caff21dc26044ace3114ae diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 5ce124174..427de8251 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -23,6 +23,7 @@ POSTERIOR_FUNCTIONS, REGRESSOR_METRICS, _compute_null_distribution_coleman, + _non_nan_samples, train_tree, ) @@ -140,7 +141,7 @@ def _check_input(self, X: ArrayLike, y: ArrayLike, covariate_index: ArrayLike = if not isinstance(covariate_index, (list, tuple, np.ndarray)): raise RuntimeError("covariate_index must be an iterable of integer indices") else: - if not all(isinstance(idx, int) for idx in covariate_index): + if not all(isinstance(idx, (np.integer, int)) for idx in covariate_index): raise RuntimeError("Not all covariate_index are integer indices") if self._n_samples_ is not None and X.shape[0] != self._n_samples_: @@ -362,7 +363,7 @@ def test( # the posteriors and computing the test statistic on the resampled posteriors if self.sample_dataset_per_tree: metric_star, metric_star_pi = _compute_null_distribution_coleman( - y_test=y[observe_samples, :], + y_test=y, y_pred_proba_normal=observe_posteriors, y_pred_proba_perm=permute_posteriors, metric=metric, @@ -375,10 +376,13 @@ def test( # there is only one train and test split, so we can just use that _, indices_test = self.train_test_samples_[0] y_test = y[indices_test, :] + y_pred_proba_normal = observe_posteriors[:, indices_test, :] + y_pred_proba_perm = permute_posteriors[:, indices_test, :] + metric_star, metric_star_pi = _compute_null_distribution_coleman( y_test=y_test, - y_pred_proba_normal=observe_posteriors, - y_pred_proba_perm=permute_posteriors, + y_pred_proba_normal=y_pred_proba_normal, + y_pred_proba_perm=y_pred_proba_perm, metric=metric, n_repeats=n_repeats, seed=self.random_state, @@ -588,19 +592,15 @@ def _statistic( samples = indices_test y_true_final = y_test - # determine if there are any nans in the final posterior array - temp_posterior_forest = np.nanmean(posterior_arr, axis=0) - nonnan_indices = np.where(~np.isnan(temp_posterior_forest).any(axis=1))[0] - - # Find the row indices with NaN values in any column - samples = nonnan_indices + # determine if there are any nans in the final posterior array, when + # averaged over the trees + samples = _non_nan_samples(posterior_arr) # Ignore all NaN values (samples not tested) - y_true_final = y[(nonnan_indices), :] - posterior_arr = posterior_arr[:, (nonnan_indices), :] + y_true_final = y[(samples), :] # Average all posteriors (n_samples_test, n_outputs) to compute the statistic - posterior_forest = np.nanmean(posterior_arr, axis=0) + posterior_forest = np.nanmean(posterior_arr[:, (samples), :], axis=0) stat = metric_func(y_true_final, posterior_forest, **metric_kwargs) if covariate_index is None: # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) @@ -750,6 +750,7 @@ def _statistic( if predict_posteriors: # now initialize posterior array as (n_trees, n_samples_test, n_classes) + # XXX: currently assumes n_outputs_ == 1 posterior_arr = np.full( (self.n_estimators, self._n_samples_, estimator.n_classes_), np.nan ) @@ -818,19 +819,15 @@ def _statistic( f"AUC metric is not supported for {self._type_of_target_} targets." ) - # determine if there are any nans in the final posterior array - temp_posterior_forest = np.nanmean(posterior_arr, axis=0) - nonnan_indices = np.where(~np.isnan(temp_posterior_forest).any(axis=1))[0] - - # Find the row indices with NaN values in any column - samples = nonnan_indices + # determine if there are any nans in the final posterior array, when + # averaged over the trees + samples = _non_nan_samples(posterior_arr) # Ignore all NaN values (samples not tested) - y_true_final = y[(nonnan_indices), :] - posterior_arr = posterior_arr[:, (nonnan_indices), :] + y_true_final = y[(samples), :] # Average all posteriors (n_samples_test, n_outputs) to compute the statistic - posterior_forest = np.nanmean(posterior_arr, axis=0) + posterior_forest = np.nanmean(posterior_arr[:, (samples), :], axis=0) stat = metric_func(y_true_final, posterior_forest, **metric_kwargs) if covariate_index is None: @@ -846,51 +843,3 @@ def _statistic( return stat, posterior_arr, samples return stat - - def statistic( - self, - X: ArrayLike, - y: ArrayLike, - covariate_index: ArrayLike = None, - metric="mi", - return_posteriors: bool = False, - check_input: bool = True, - **metric_kwargs, - ): - """Compute the test statistic. - - Parameters - ---------- - X : ArrayLike of shape (n_samples, n_features) - The data matrix. - y : ArrayLike of shape (n_samples, n_outputs) - The target matrix. - covariate_index : ArrayLike, optional of shape (n_covariates,) - The index array of covariates to shuffle, by default None. - metric : str, optional - The metric to compute, by default "mi", which computes Mutual Information. - return_posteriors : bool, optional - Whether or not to return the posteriors, by default False. - check_input : bool, optional - Whether or not to check the input, by default True. - **metric_kwargs : dict, optional - Additional keyword arguments to pass to the metric function. - - Returns - ------- - stat : float - The test statistic. - posterior_final : ArrayLike of shape (n_estimators, n_samples_final, n_outputs) or - (n_estimators, n_samples_final), optional - If ``return_posteriors`` is True, then the posterior probabilities of the - samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` - if all samples are encountered in the test set of at least one tree in the - posterior computation. - samples : ArrayLike of shape (n_samples_final,), optional - The indices of the samples used in the final test. ``n_samples_final`` is - equal to ``n_samples`` if all samples are encountered in the test set of at - least one tree in the posterior computation. - """ - return super().statistic( - X, y, covariate_index, metric, return_posteriors, check_input, **metric_kwargs - ) diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 9b849ed22..20fc68e52 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -1,7 +1,11 @@ +import pickle +from pathlib import Path + import numpy as np import pytest from flaky import flaky from joblib import Parallel, delayed +from numpy.testing import assert_array_equal from scipy.special import expit from sklearn import datasets @@ -124,8 +128,8 @@ def test_featureimportance_forest_errors(): "sample_dataset_per_tree": True, }, 300, # n_samples - 500, # n_repeats - 0.1, # test_size + 1000, # n_repeats + 0.2, # test_size ], ], ) @@ -205,12 +209,12 @@ def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size) n_jobs=-1, ), "random_state": seed, - "permute_per_tree": True, - "sample_dataset_per_tree": True, + "permute_per_tree": False, + "sample_dataset_per_tree": False, }, - 600, - 200, - 1.0 / 6, + 600, # n_samples + 1000, # n_repeats + 1.0 / 6, # test_size ], ], ) @@ -266,7 +270,6 @@ def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, @flaky(max_runs=2) -@pytest.mark.slowtest @pytest.mark.parametrize("criterion", ["gini", "entropy"]) @pytest.mark.parametrize("honest_prior", ["empirical", "uniform"]) @pytest.mark.parametrize( @@ -408,7 +411,54 @@ def run_forest(covariate_index=None): pvalue = clf.test(X, y, covariate_index=[covariate_index], metric="mi") return pvalue - out = Parallel(n_jobs=1, backend=backend)( + out = Parallel(n_jobs=-1, backend=backend)( delayed(run_forest)(covariate_index) for covariate_index in range(n_features) ) assert len(out) == n_features + + +def test_pickle(tmpdir): + """Test that pickling works and preserves fitted attributes.""" + n_samples = 100 + n_features = 5 + X = rng.uniform(size=(n_samples, n_features)) + y = rng.integers(0, 2, size=n_samples) # Binary classification + n_repeats = 1000 + + clf = FeatureImportanceForestClassifier( + estimator=HonestForestClassifier( + n_estimators=10, random_state=seed, n_jobs=1, honest_fraction=0.2 + ), + test_size=0.5, + ) + stat, pvalue = clf.test(X, y, covariate_index=[1], metric="mi", n_repeats=n_repeats) + + with open(Path(tmpdir) / "clf.pkl", "wb") as fpath: + pickle.dump(clf, fpath) + + with open(Path(tmpdir) / "clf.pkl", "rb") as fpath: + clf_pickle = pickle.load(fpath) + + # recompute pvalue manually and compare + pickle_pvalue = ( + 1.0 + (clf_pickle.null_dist_ <= (clf_pickle.permute_stat_ - clf_pickle.observe_stat_)).sum() + ) / (1.0 + n_repeats) + assert pvalue == pickle_pvalue + assert clf_pickle.permute_stat_ - clf_pickle.observe_stat_ == stat + + attr_list = [ + "test_size", + "observe_samples_", + "y_true_final_", + "observe_posteriors_", + "observe_stat_", + "_is_fitted", + "permute_samples_", + "permute_posteriors_", + "permute_stat_", + "n_samples_test_", + "_n_samples_", + "_metric", + ] + for attr in attr_list: + assert_array_equal(getattr(clf, attr), getattr(clf_pickle, attr)) diff --git a/sktree/stats/utils.py b/sktree/stats/utils.py index 30ce83ff8..d2f36c1e4 100644 --- a/sktree/stats/utils.py +++ b/sktree/stats/utils.py @@ -16,12 +16,12 @@ def _mutual_information(y_true: ArrayLike, y_pred_proba: ArrayLike) -> float: - """Compute estimate of mutual information. + """Compute estimate of mutual information for supervised classification setting. Parameters ---------- y_true : ArrayLike of shape (n_samples,) - _description_ + The true labels. y_pred_proba : ArrayLike of shape (n_samples, n_outputs) Posterior probabilities. @@ -41,21 +41,69 @@ def _mutual_information(y_true: ArrayLike, y_pred_proba: ArrayLike) -> float: return H_Y - H_YX +def _cond_entropy(y_true: ArrayLike, y_pred_proba: ArrayLike) -> float: + """Compute estimate of entropy for supervised classification setting. + + H(Y | X) + + Parameters + ---------- + y_true : ArrayLike of shape (n_samples,) + The true labels. Not used in computation of the entropy. + y_pred_proba : ArrayLike of shape (n_samples, n_outputs) + Posterior probabilities. + + Returns + ------- + float : + The estimated MI. + """ + if y_true.squeeze().ndim != 1: + raise ValueError(f"y_true must be 1d, not {y_true.shape}") + + # entropy averaged over n_samples + H_YX = np.mean(entropy(y_pred_proba, base=np.exp(1), axis=1)) + return H_YX + + METRIC_FUNCTIONS = { "mse": mean_squared_error, "mae": mean_absolute_error, "balanced_accuracy": balanced_accuracy_score, "auc": roc_auc_score, "mi": _mutual_information, + "cond_entropy": _cond_entropy, } -POSTERIOR_FUNCTIONS = ("mi", "auc") +POSTERIOR_FUNCTIONS = ("mi", "auc", "cond_entropy") POSITIVE_METRICS = ("mi", "auc", "balanced_accuracy") REGRESSOR_METRICS = ("mse", "mae") +def _non_nan_samples(posterior_arr: ArrayLike) -> ArrayLike: + """Determine which samples are not nan in the posterior tree array. + + Parameters + ---------- + posterior_arr : ArrayLike of shape (n_trees, n_samples, n_outputs) + The 3D posterior array from the forest. + + Returns + ------- + nonnan_indices : ArrayLike of shape (n_nonnan_samples,) + The indices of the samples that are not nan in the posterior array + along axis=1. + """ + # Find the row indices with NaN values along the specified axis + nan_indices = np.isnan(posterior_arr).any(axis=2).all(axis=0) + + # Invert the boolean mask to get indices without NaN values + nonnan_indices = np.where(~nan_indices)[0] + return nonnan_indices + + def train_tree( tree: DecisionTreeClassifier, X: ArrayLike, @@ -218,16 +266,30 @@ def _compute_null_distribution_coleman( rng.shuffle(y_pred_ind_arr) # get random half of the posteriors from two sets of trees - first_forest_inds = y_pred_ind_arr[:n_samples_test] - second_forest_inds = y_pred_ind_arr[:n_samples_test] + first_forest_inds = y_pred_ind_arr[: n_estimators // 2] + second_forest_inds = y_pred_ind_arr[n_estimators // 2 :] + + # get random half of the posteriors as one forest + first_forest_pred = all_y_pred[first_forest_inds, ...] + second_forest_pred = all_y_pred[second_forest_inds, ...] + + # determine if there are any nans in the final posterior array, when + # averaged over the trees + first_forest_samples = _non_nan_samples(first_forest_pred) + second_forest_samples = _non_nan_samples(second_forest_pred) + + # todo: is this step necessary? + non_nan_samples = np.intersect1d( + first_forest_samples, second_forest_samples, assume_unique=True + ) - # get random half of the posteriors - y_pred_first_half = np.nanmean(all_y_pred[first_forest_inds], axis=0) - y_pred_second_half = np.nanmean(all_y_pred[second_forest_inds], axis=0) + # now average the posteriors over the trees for the non-nan samples + y_pred_first_half = np.nanmean(first_forest_pred[:, non_nan_samples, :], axis=0) + y_pred_second_half = np.nanmean(second_forest_pred[:, non_nan_samples, :], axis=0) # compute two instances of the metric from the sampled trees - first_half_metric = metric_func(y_test, y_pred_first_half) - second_half_metric = metric_func(y_test, y_pred_second_half) + first_half_metric = metric_func(y_test[non_nan_samples, :], y_pred_first_half) + second_half_metric = metric_func(y_test[non_nan_samples, :], y_pred_second_half) metric_star[idx] = first_half_metric metric_star_pi[idx] = second_half_metric From 3a2279adb5370c192768cf5d50059a1757641c1b Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 4 Oct 2023 09:04:23 -0400 Subject: [PATCH 63/70] Add fixes Signed-off-by: Adam Li --- .github/workflows/main.yml | 2 +- ...mpare_coleman_and_permutation_forest.ipynb | 2855 +---------------- ...t_MI_gigantic_hypothesis_testing_forest.py | 8 +- sktree/_lib/sklearn_fork | 2 +- sktree/stats/forestht.py | 92 +- sktree/stats/tests/test_forestht.py | 68 +- sktree/stats/utils.py | 82 +- 7 files changed, 283 insertions(+), 2826 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index ea1f78ee8..a943e3d13 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -224,7 +224,7 @@ jobs: ./spin --help ./spin coverage --help ./spin test --help - ./spin coverage -k "slowtest" + ./spin coverage cp $PWD/build-install/usr/lib/python${{matrix.python-version}}/site-packages/coverage.xml ./coverage.xml - name: debug diff --git a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb index 8b5c34f46..3990764bf 100644 --- a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb +++ b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "id": "5e2d1279-fa4f-47ef-aa48-fac6d47159ad", "metadata": {}, "outputs": [], @@ -55,9 +55,9 @@ " beta = 10.0\n", " sigma = 10.0 / sigma_factor\n", " n_samples = 2200\n", - " n_estimators = 125\n", + " n_estimators = 500\n", " test_size = 0.1\n", - " n_repeats = 500\n", + " n_repeats = 1000\n", " metric = \"mse\"\n", "\n", " rng = np.random.default_rng(seed)\n", @@ -134,7 +134,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 17, "id": "3db4f740-afd9-413e-8089-a8245f2a0747", "metadata": {}, "outputs": [], @@ -152,7 +152,7 @@ " max_features = \"sqrt\"\n", " test_size = 1.0 / 6\n", " metric = \"mse\"\n", - " n_repeats = 200\n", + " n_repeats = 500\n", " permute_per_tree = True\n", " sample_dataset_per_tree = True\n", "\n", @@ -239,7 +239,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "14806903-933b-4e31-a2db-a3a45e0a6f82", "metadata": { "scrolled": true @@ -249,2814 +249,213 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n", + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "X2/7: 1.0\n" + "X1: 0.9940119760479041\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "X1: 1.0\n" + "X6: 0.36726546906187624\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "X6: 1.0\n" + "X2/7: 0.23952095808383234\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "X2/7: 1.0\n" + "X2/7: 0.49101796407185627\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n", + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "X2/7: 1.0\n" + "X1: 0.00998003992015968\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "X1: 1.0\n" + "X6: 0.3532934131736527\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", + " return fit_method(estimator, *args, **kwargs)\n" ] - }, + } + ], + "source": [ + "pvalue_dict = defaultdict(list)\n", + "rng = np.random.default_rng(seed)\n", + "\n", + "j_space = np.linspace(0.005, 2.25, 9)\n", + "\n", + "for sigma_factor in j_space:\n", + " for idx in range(5):\n", + " new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32)\n", + "\n", + " elements_dict = linear_model_ancova(\n", + " sigma_factor,\n", + " new_seed,\n", + " permute_per_tree=False,\n", + " sample_dataset_per_tree=False,\n", + " )\n", + " for key, value in elements_dict.items():\n", + " pvalue_dict[key].append(value)\n", + " pvalue_dict[\"sigma_factor\"].append(sigma_factor)\n", + "\n", + "df = pd.DataFrame(pvalue_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "5f4eb53c-c82d-4770-836a-552b910dd736", + "metadata": {}, + "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" + "[autoreload of sktree.stats.forestht failed: Traceback (most recent call last):\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 276, in check\n", + " superreload(m, reload, self.old_objects)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 500, in superreload\n", + " update_generic(old_obj, new_obj)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 397, in update_generic\n", + " update(a, b)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 349, in update_class\n", + " if update_generic(old_obj, new_obj):\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 397, in update_generic\n", + " update(a, b)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 309, in update_function\n", + " setattr(old, name, getattr(new, name))\n", + "ValueError: statistic() requires a code object with 1 free vars, not 0\n", + "]\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", + "\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", + "\n", + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\n", + " \"Linear ANCOVA model with FeatureImportanceRegressor (Permutation per tree and sample dataset per tree)\"\n", + ")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "b470b569-4391-40e2-b7c4-a8439cc026c0", + "metadata": {}, + "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n", - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.001996007984031936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n", - " y_train = y_train.ravel()\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 1.0\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "pvalue_dict = defaultdict(list)\n", - "rng = np.random.default_rng(seed)\n", - "\n", - "j_space = np.linspace(0.005, 2.25, 9)\n", - "\n", - "for sigma_factor in j_space:\n", - " for idx in range(5):\n", - " new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32)\n", + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", "\n", - " elements_dict = linear_model_ancova(\n", - " sigma_factor,\n", - " new_seed,\n", - " permute_per_tree=True,\n", - " sample_dataset_per_tree=False,\n", - " )\n", - " for key, value in elements_dict.items():\n", - " pvalue_dict[key].append(value)\n", - " pvalue_dict[\"sigma_factor\"].append(sigma_factor)\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", "\n", - "df = pd.DataFrame(pvalue_dict)" + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\n", + " \"Linear ANCOVA model with FeatureImportanceRegressor (Permutation per tree and sample dataset per tree)\"\n", + ")\n", + "fig.tight_layout()" ] }, { diff --git a/examples/plot_MI_gigantic_hypothesis_testing_forest.py b/examples/plot_MI_gigantic_hypothesis_testing_forest.py index 8408f4e03..fd4f84765 100644 --- a/examples/plot_MI_gigantic_hypothesis_testing_forest.py +++ b/examples/plot_MI_gigantic_hypothesis_testing_forest.py @@ -90,10 +90,10 @@ # computed as the proportion of samples in the null distribution that are less than the # observed test statistic. -n_estimators = 125 +n_estimators = 200 max_features = "sqrt" test_size = 0.2 -n_repeats = 500 +n_repeats = 1000 n_jobs = -1 est = FeatureImportanceForestClassifier( @@ -107,8 +107,8 @@ ), random_state=seed, test_size=test_size, - permute_per_tree=True, - sample_dataset_per_tree=True, + permute_per_tree=False, + sample_dataset_per_tree=False, ) # we test for the first feature set, which is important and thus should return a pvalue < 0.05 diff --git a/sktree/_lib/sklearn_fork b/sktree/_lib/sklearn_fork index e2fee00aa..d9d1ea68f 160000 --- a/sktree/_lib/sklearn_fork +++ b/sktree/_lib/sklearn_fork @@ -1 +1 @@ -Subproject commit e2fee00aa461c21b8cfa59eb907d27972415c99b +Subproject commit d9d1ea68fde4f0bf90caff21dc26044ace3114ae diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 66bee9c15..427de8251 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -23,6 +23,7 @@ POSTERIOR_FUNCTIONS, REGRESSOR_METRICS, _compute_null_distribution_coleman, + _non_nan_samples, train_tree, ) @@ -140,7 +141,7 @@ def _check_input(self, X: ArrayLike, y: ArrayLike, covariate_index: ArrayLike = if not isinstance(covariate_index, (list, tuple, np.ndarray)): raise RuntimeError("covariate_index must be an iterable of integer indices") else: - if not all(isinstance(idx, int) for idx in covariate_index): + if not all(isinstance(idx, (np.integer, int)) for idx in covariate_index): raise RuntimeError("Not all covariate_index are integer indices") if self._n_samples_ is not None and X.shape[0] != self._n_samples_: @@ -362,7 +363,7 @@ def test( # the posteriors and computing the test statistic on the resampled posteriors if self.sample_dataset_per_tree: metric_star, metric_star_pi = _compute_null_distribution_coleman( - y_test=y[observe_samples, :], + y_test=y, y_pred_proba_normal=observe_posteriors, y_pred_proba_perm=permute_posteriors, metric=metric, @@ -375,10 +376,13 @@ def test( # there is only one train and test split, so we can just use that _, indices_test = self.train_test_samples_[0] y_test = y[indices_test, :] + y_pred_proba_normal = observe_posteriors[:, indices_test, :] + y_pred_proba_perm = permute_posteriors[:, indices_test, :] + metric_star, metric_star_pi = _compute_null_distribution_coleman( y_test=y_test, - y_pred_proba_normal=observe_posteriors, - y_pred_proba_perm=permute_posteriors, + y_pred_proba_normal=y_pred_proba_normal, + y_pred_proba_perm=y_pred_proba_perm, metric=metric, n_repeats=n_repeats, seed=self.random_state, @@ -588,19 +592,15 @@ def _statistic( samples = indices_test y_true_final = y_test - # determine if there are any nans in the final posterior array - temp_posterior_forest = np.nanmean(posterior_arr, axis=0) - nonnan_indices = np.where(~np.isnan(temp_posterior_forest).any(axis=1))[0] - - # Find the row indices with NaN values in any column - samples = nonnan_indices + # determine if there are any nans in the final posterior array, when + # averaged over the trees + samples = _non_nan_samples(posterior_arr) # Ignore all NaN values (samples not tested) - y_true_final = y[(nonnan_indices), :] - posterior_arr = posterior_arr[:, (nonnan_indices), :] + y_true_final = y[(samples), :] # Average all posteriors (n_samples_test, n_outputs) to compute the statistic - posterior_forest = np.nanmean(posterior_arr, axis=0) + posterior_forest = np.nanmean(posterior_arr[:, (samples), :], axis=0) stat = metric_func(y_true_final, posterior_forest, **metric_kwargs) if covariate_index is None: # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs) @@ -750,6 +750,7 @@ def _statistic( if predict_posteriors: # now initialize posterior array as (n_trees, n_samples_test, n_classes) + # XXX: currently assumes n_outputs_ == 1 posterior_arr = np.full( (self.n_estimators, self._n_samples_, estimator.n_classes_), np.nan ) @@ -818,22 +819,15 @@ def _statistic( f"AUC metric is not supported for {self._type_of_target_} targets." ) - # determine if there are any nans in the final posterior array - print(posterior_arr.shape) - print(posterior_arr) - print(np.nanmean(posterior_arr, axis=0).shape) - temp_posterior_forest = np.nanmean(posterior_arr, axis=0) - nonnan_indices = np.where(~np.isnan(temp_posterior_forest).any(axis=1))[0] - - # Find the row indices with NaN values in any column - samples = nonnan_indices + # determine if there are any nans in the final posterior array, when + # averaged over the trees + samples = _non_nan_samples(posterior_arr) # Ignore all NaN values (samples not tested) - y_true_final = y[(nonnan_indices), :] - posterior_arr = posterior_arr[:, (nonnan_indices), :] + y_true_final = y[(samples), :] # Average all posteriors (n_samples_test, n_outputs) to compute the statistic - posterior_forest = np.nanmean(posterior_arr, axis=0) + posterior_forest = np.nanmean(posterior_arr[:, (samples), :], axis=0) stat = metric_func(y_true_final, posterior_forest, **metric_kwargs) if covariate_index is None: @@ -849,51 +843,3 @@ def _statistic( return stat, posterior_arr, samples return stat - - def statistic( - self, - X: ArrayLike, - y: ArrayLike, - covariate_index: ArrayLike = None, - metric="mi", - return_posteriors: bool = False, - check_input: bool = True, - **metric_kwargs, - ): - """Compute the test statistic. - - Parameters - ---------- - X : ArrayLike of shape (n_samples, n_features) - The data matrix. - y : ArrayLike of shape (n_samples, n_outputs) - The target matrix. - covariate_index : ArrayLike, optional of shape (n_covariates,) - The index array of covariates to shuffle, by default None. - metric : str, optional - The metric to compute, by default "mi", which computes Mutual Information. - return_posteriors : bool, optional - Whether or not to return the posteriors, by default False. - check_input : bool, optional - Whether or not to check the input, by default True. - **metric_kwargs : dict, optional - Additional keyword arguments to pass to the metric function. - - Returns - ------- - stat : float - The test statistic. - posterior_final : ArrayLike of shape (n_estimators, n_samples_final, n_outputs) or - (n_estimators, n_samples_final), optional - If ``return_posteriors`` is True, then the posterior probabilities of the - samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` - if all samples are encountered in the test set of at least one tree in the - posterior computation. - samples : ArrayLike of shape (n_samples_final,), optional - The indices of the samples used in the final test. ``n_samples_final`` is - equal to ``n_samples`` if all samples are encountered in the test set of at - least one tree in the posterior computation. - """ - return super().statistic( - X, y, covariate_index, metric, return_posteriors, check_input, **metric_kwargs - ) diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 9b849ed22..20fc68e52 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -1,7 +1,11 @@ +import pickle +from pathlib import Path + import numpy as np import pytest from flaky import flaky from joblib import Parallel, delayed +from numpy.testing import assert_array_equal from scipy.special import expit from sklearn import datasets @@ -124,8 +128,8 @@ def test_featureimportance_forest_errors(): "sample_dataset_per_tree": True, }, 300, # n_samples - 500, # n_repeats - 0.1, # test_size + 1000, # n_repeats + 0.2, # test_size ], ], ) @@ -205,12 +209,12 @@ def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size) n_jobs=-1, ), "random_state": seed, - "permute_per_tree": True, - "sample_dataset_per_tree": True, + "permute_per_tree": False, + "sample_dataset_per_tree": False, }, - 600, - 200, - 1.0 / 6, + 600, # n_samples + 1000, # n_repeats + 1.0 / 6, # test_size ], ], ) @@ -266,7 +270,6 @@ def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, @flaky(max_runs=2) -@pytest.mark.slowtest @pytest.mark.parametrize("criterion", ["gini", "entropy"]) @pytest.mark.parametrize("honest_prior", ["empirical", "uniform"]) @pytest.mark.parametrize( @@ -408,7 +411,54 @@ def run_forest(covariate_index=None): pvalue = clf.test(X, y, covariate_index=[covariate_index], metric="mi") return pvalue - out = Parallel(n_jobs=1, backend=backend)( + out = Parallel(n_jobs=-1, backend=backend)( delayed(run_forest)(covariate_index) for covariate_index in range(n_features) ) assert len(out) == n_features + + +def test_pickle(tmpdir): + """Test that pickling works and preserves fitted attributes.""" + n_samples = 100 + n_features = 5 + X = rng.uniform(size=(n_samples, n_features)) + y = rng.integers(0, 2, size=n_samples) # Binary classification + n_repeats = 1000 + + clf = FeatureImportanceForestClassifier( + estimator=HonestForestClassifier( + n_estimators=10, random_state=seed, n_jobs=1, honest_fraction=0.2 + ), + test_size=0.5, + ) + stat, pvalue = clf.test(X, y, covariate_index=[1], metric="mi", n_repeats=n_repeats) + + with open(Path(tmpdir) / "clf.pkl", "wb") as fpath: + pickle.dump(clf, fpath) + + with open(Path(tmpdir) / "clf.pkl", "rb") as fpath: + clf_pickle = pickle.load(fpath) + + # recompute pvalue manually and compare + pickle_pvalue = ( + 1.0 + (clf_pickle.null_dist_ <= (clf_pickle.permute_stat_ - clf_pickle.observe_stat_)).sum() + ) / (1.0 + n_repeats) + assert pvalue == pickle_pvalue + assert clf_pickle.permute_stat_ - clf_pickle.observe_stat_ == stat + + attr_list = [ + "test_size", + "observe_samples_", + "y_true_final_", + "observe_posteriors_", + "observe_stat_", + "_is_fitted", + "permute_samples_", + "permute_posteriors_", + "permute_stat_", + "n_samples_test_", + "_n_samples_", + "_metric", + ] + for attr in attr_list: + assert_array_equal(getattr(clf, attr), getattr(clf_pickle, attr)) diff --git a/sktree/stats/utils.py b/sktree/stats/utils.py index 30ce83ff8..d2f36c1e4 100644 --- a/sktree/stats/utils.py +++ b/sktree/stats/utils.py @@ -16,12 +16,12 @@ def _mutual_information(y_true: ArrayLike, y_pred_proba: ArrayLike) -> float: - """Compute estimate of mutual information. + """Compute estimate of mutual information for supervised classification setting. Parameters ---------- y_true : ArrayLike of shape (n_samples,) - _description_ + The true labels. y_pred_proba : ArrayLike of shape (n_samples, n_outputs) Posterior probabilities. @@ -41,21 +41,69 @@ def _mutual_information(y_true: ArrayLike, y_pred_proba: ArrayLike) -> float: return H_Y - H_YX +def _cond_entropy(y_true: ArrayLike, y_pred_proba: ArrayLike) -> float: + """Compute estimate of entropy for supervised classification setting. + + H(Y | X) + + Parameters + ---------- + y_true : ArrayLike of shape (n_samples,) + The true labels. Not used in computation of the entropy. + y_pred_proba : ArrayLike of shape (n_samples, n_outputs) + Posterior probabilities. + + Returns + ------- + float : + The estimated MI. + """ + if y_true.squeeze().ndim != 1: + raise ValueError(f"y_true must be 1d, not {y_true.shape}") + + # entropy averaged over n_samples + H_YX = np.mean(entropy(y_pred_proba, base=np.exp(1), axis=1)) + return H_YX + + METRIC_FUNCTIONS = { "mse": mean_squared_error, "mae": mean_absolute_error, "balanced_accuracy": balanced_accuracy_score, "auc": roc_auc_score, "mi": _mutual_information, + "cond_entropy": _cond_entropy, } -POSTERIOR_FUNCTIONS = ("mi", "auc") +POSTERIOR_FUNCTIONS = ("mi", "auc", "cond_entropy") POSITIVE_METRICS = ("mi", "auc", "balanced_accuracy") REGRESSOR_METRICS = ("mse", "mae") +def _non_nan_samples(posterior_arr: ArrayLike) -> ArrayLike: + """Determine which samples are not nan in the posterior tree array. + + Parameters + ---------- + posterior_arr : ArrayLike of shape (n_trees, n_samples, n_outputs) + The 3D posterior array from the forest. + + Returns + ------- + nonnan_indices : ArrayLike of shape (n_nonnan_samples,) + The indices of the samples that are not nan in the posterior array + along axis=1. + """ + # Find the row indices with NaN values along the specified axis + nan_indices = np.isnan(posterior_arr).any(axis=2).all(axis=0) + + # Invert the boolean mask to get indices without NaN values + nonnan_indices = np.where(~nan_indices)[0] + return nonnan_indices + + def train_tree( tree: DecisionTreeClassifier, X: ArrayLike, @@ -218,16 +266,30 @@ def _compute_null_distribution_coleman( rng.shuffle(y_pred_ind_arr) # get random half of the posteriors from two sets of trees - first_forest_inds = y_pred_ind_arr[:n_samples_test] - second_forest_inds = y_pred_ind_arr[:n_samples_test] + first_forest_inds = y_pred_ind_arr[: n_estimators // 2] + second_forest_inds = y_pred_ind_arr[n_estimators // 2 :] + + # get random half of the posteriors as one forest + first_forest_pred = all_y_pred[first_forest_inds, ...] + second_forest_pred = all_y_pred[second_forest_inds, ...] + + # determine if there are any nans in the final posterior array, when + # averaged over the trees + first_forest_samples = _non_nan_samples(first_forest_pred) + second_forest_samples = _non_nan_samples(second_forest_pred) + + # todo: is this step necessary? + non_nan_samples = np.intersect1d( + first_forest_samples, second_forest_samples, assume_unique=True + ) - # get random half of the posteriors - y_pred_first_half = np.nanmean(all_y_pred[first_forest_inds], axis=0) - y_pred_second_half = np.nanmean(all_y_pred[second_forest_inds], axis=0) + # now average the posteriors over the trees for the non-nan samples + y_pred_first_half = np.nanmean(first_forest_pred[:, non_nan_samples, :], axis=0) + y_pred_second_half = np.nanmean(second_forest_pred[:, non_nan_samples, :], axis=0) # compute two instances of the metric from the sampled trees - first_half_metric = metric_func(y_test, y_pred_first_half) - second_half_metric = metric_func(y_test, y_pred_second_half) + first_half_metric = metric_func(y_test[non_nan_samples, :], y_pred_first_half) + second_half_metric = metric_func(y_test[non_nan_samples, :], y_pred_second_half) metric_star[idx] = first_half_metric metric_star_pi[idx] = second_half_metric From 3a4a4b4fe0524e8021839b3a7d2636c35868179d Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 4 Oct 2023 11:33:19 -0400 Subject: [PATCH 64/70] Add parallelization to the tree building and predicting posteriors Signed-off-by: Adam Li --- ...mpare_coleman_and_permutation_forest.ipynb | 412 +++++++++++++----- ...t_MI_gigantic_hypothesis_testing_forest.py | 5 +- sktree/stats/forestht.py | 89 ++-- sktree/stats/tests/test_forestht.py | 2 +- 4 files changed, 381 insertions(+), 127 deletions(-) diff --git a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb index 3990764bf..f084e213b 100644 --- a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb +++ b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb @@ -239,112 +239,196 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "14806903-933b-4e31-a2db-a3a45e0a6f82", "metadata": { "scrolled": true }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", - " return fit_method(estimator, *args, **kwargs)\n", - "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", - " return fit_method(estimator, *args, **kwargs)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X1: 0.9940119760479041\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", - " return fit_method(estimator, *args, **kwargs)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.36726546906187624\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", - " return fit_method(estimator, *args, **kwargs)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 0.23952095808383234\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", - " return fit_method(estimator, *args, **kwargs)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X2/7: 0.49101796407185627\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", - " return fit_method(estimator, *args, **kwargs)\n", - "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", - " return fit_method(estimator, *args, **kwargs)\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "X1: 0.00998003992015968\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", - " return fit_method(estimator, *args, **kwargs)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "X6: 0.3532934131736527\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", - " return fit_method(estimator, *args, **kwargs)\n" + "X1: 0.16167664670658682\n", + "X6: 0.017964071856287425\n", + "X2/7: 0.313373253493014\n", + "X2/7: 0.043912175648702596\n", + "X1: 0.24550898203592814\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.8962075848303394\n", + "X2/7: 0.001996007984031936\n", + "X1: 0.9700598802395209\n", + "X6: 0.13572854291417166\n", + "X2/7: 0.9181636726546906\n", + "X2/7: 0.07584830339321358\n", + "X1: 0.9640718562874252\n", + "X6: 0.00998003992015968\n", + "X2/7: 0.9940119760479041\n", + "X2/7: 0.03792415169660679\n", + "X1: 1.0\n", + "X6: 0.11776447105788423\n", + "X2/7: 0.6347305389221557\n", + "X2/7: 0.0718562874251497\n", + "X1: 1.0\n", + "X6: 0.007984031936127744\n", + "X2/7: 0.9960079840319361\n", + "X2/7: 0.14770459081836326\n", + "X1: 0.9161676646706587\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.9001996007984032\n", + "X2/7: 0.011976047904191617\n", + "X1: 0.9940119760479041\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.11976047904191617\n", + "X1: 0.874251497005988\n", + "X6: 0.11976047904191617\n", + "X2/7: 1.0\n", + "X2/7: 0.003992015968063872\n", + "X1: 1.0\n", + "X6: 0.005988023952095809\n", + "X2/7: 0.998003992015968\n", + "X2/7: 0.29740518962075846\n", + "X1: 0.936127744510978\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.9001996007984032\n", + "X2/7: 0.00998003992015968\n", + "X1: 0.7265469061876247\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.9940119760479041\n", + "X2/7: 0.07584830339321358\n", + "X1: 0.9441117764471058\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.998003992015968\n", + "X2/7: 0.19560878243512975\n", + "X1: 0.9660678642714571\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.07584830339321358\n", + "X1: 0.3912175648702595\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.7724550898203593\n", + "X2/7: 0.015968063872255488\n", + "X1: 0.013972055888223553\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.998003992015968\n", + "X2/7: 0.059880239520958084\n", + "X1: 0.3073852295409182\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.18962075848303392\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.281437125748503\n", + "X2/7: 0.03592814371257485\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.9880239520958084\n", + "X2/7: 0.05788423153692615\n", + "X1: 0.6347305389221557\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.9940119760479041\n", + "X2/7: 0.06187624750499002\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.02594810379241517\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.17165668662674652\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.9880239520958084\n", + "X2/7: 0.01996007984031936\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.8842315369261478\n", + "X2/7: 0.033932135728542916\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.9900199600798403\n", + "X2/7: 0.10578842315369262\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.5209580838323353\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.8982035928143712\n", + "X2/7: 0.03992015968063872\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.9960079840319361\n", + "X2/7: 0.005988023952095809\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.4091816367265469\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.9960079840319361\n", + "X2/7: 0.4311377245508982\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.998003992015968\n", + "X2/7: 0.0998003992015968\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.9181636726546906\n", + "X2/7: 0.06986027944111776\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.14570858283433133\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.09780439121756487\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.9660678642714571\n", + "X2/7: 0.059880239520958084\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.9900199600798403\n", + "X2/7: 0.05588822355289421\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.09381237524950099\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.45708582834331335\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.9900199600798403\n", + "X2/7: 0.20159680638722555\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.810379241516966\n", + "X2/7: 0.1656686626746507\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.20958083832335328\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.9960079840319361\n", + "X2/7: 0.033932135728542916\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.998003992015968\n", + "X2/7: 0.12375249500998003\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 0.998003992015968\n", + "X2/7: 0.19560878243512975\n", + "X1: 0.001996007984031936\n", + "X6: 0.001996007984031936\n", + "X2/7: 1.0\n", + "X2/7: 0.05588822355289421\n" ] } ], @@ -361,8 +445,8 @@ " elements_dict = linear_model_ancova(\n", " sigma_factor,\n", " new_seed,\n", - " permute_per_tree=False,\n", - " sample_dataset_per_tree=False,\n", + " permute_per_tree=True,\n", + " sample_dataset_per_tree=True,\n", " )\n", " for key, value in elements_dict.items():\n", " pvalue_dict[key].append(value)\n", @@ -371,6 +455,60 @@ "df = pd.DataFrame(pvalue_dict)" ] }, + { + "cell_type": "code", + "execution_count": 24, + "id": "48b832dd-aa16-4f11-94aa-8e4bdff5c957", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[autoreload of sktree.stats.forestht failed: Traceback (most recent call last):\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 276, in check\n", + " superreload(m, reload, self.old_objects)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 500, in superreload\n", + " update_generic(old_obj, new_obj)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 397, in update_generic\n", + " update(a, b)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 349, in update_class\n", + " if update_generic(old_obj, new_obj):\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 397, in update_generic\n", + " update(a, b)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 309, in update_function\n", + " setattr(old, name, getattr(new, name))\n", + "ValueError: statistic() requires a code object with 1 free vars, not 0\n", + "]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", + "\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", + "\n", + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\n", + " \"Linear ANCOVA model with FeatureImportanceRegressor (Permutation per tree and sample dataset per tree)\"\n", + ")\n", + "fig.tight_layout()" + ] + }, { "cell_type": "code", "execution_count": 19, @@ -425,6 +563,82 @@ "fig.tight_layout()" ] }, + { + "cell_type": "code", + "execution_count": 21, + "id": "631649cc-f99f-4ce2-9b42-a4a7d75bd5b1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[autoreload of sktree.stats.forestht failed: Traceback (most recent call last):\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 276, in check\n", + " superreload(m, reload, self.old_objects)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 500, in superreload\n", + " update_generic(old_obj, new_obj)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 397, in update_generic\n", + " update(a, b)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 349, in update_class\n", + " if update_generic(old_obj, new_obj):\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 397, in update_generic\n", + " update(a, b)\n", + " File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 309, in update_function\n", + " setattr(old, name, getattr(new, name))\n", + "ValueError: statistic() requires a code object with 1 free vars, not 0\n", + "]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", + "\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", + "\n", + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\n", + " \"Linear ANCOVA model with FeatureImportanceRegressor (Original Coleman method)\"\n", + ")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "633dda38-68e6-4101-8657-86b75721f92a", + "metadata": {}, + "outputs": [], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n", + "axs = axs.flatten()\n", + "\n", + "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n", + " sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n", + "\n", + " ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n", + " ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n", + " ax.legend()\n", + "fig.suptitle(\n", + " \"Linear ANCOVA model with Coleman Forest (Permute per tree, but not sample separate dataset)\"\n", + ")\n", + "fig.tight_layout()" + ] + }, { "cell_type": "code", "execution_count": 15, diff --git a/examples/plot_MI_gigantic_hypothesis_testing_forest.py b/examples/plot_MI_gigantic_hypothesis_testing_forest.py index fd4f84765..034e5ebec 100644 --- a/examples/plot_MI_gigantic_hypothesis_testing_forest.py +++ b/examples/plot_MI_gigantic_hypothesis_testing_forest.py @@ -17,8 +17,9 @@ feature set (W) is weakly correlated with the target (y). Here, we are testing the null hypothesis: -``H0: I(X; y) - I(X, W; y) = 0`` -``HA: I(X; y) - I(X, W; y) > 0`` +- ``H0: I(X; y) - I(X, W; y) = 0`` +- ``HA: I(X; y) - I(X, W; y) < 0`` indicating that there is more mutual information with + respect to ``y`` where ``I`` is mutual information. For example, this could be true in the following settings, where X is our informative feature set and W is our uninformative feature set. diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index 427de8251..b63cbd894 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -1,6 +1,7 @@ -from typing import Callable, Tuple +from typing import Callable, Tuple, Union import numpy as np +from joblib import Parallel, delayed from numpy.typing import ArrayLike from sklearn.base import MetaEstimatorMixin, clone, is_classifier from sklearn.ensemble._forest import ForestClassifier as sklearnForestClassifier @@ -15,7 +16,7 @@ RandomForestClassifier, RandomForestRegressor, ) -from sktree._lib.sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor +from sktree.tree import DecisionTreeClassifier, DecisionTreeRegressor from .utils import ( METRIC_FUNCTIONS, @@ -28,6 +29,35 @@ ) +def _parallel_build_trees_and_compute_posteriors( + trees, + idx: int, + indices_train: ArrayLike, + indices_test: ArrayLike, + X: ArrayLike, + y: ArrayLike, + covariate_index, + posterior_arr: ArrayLike, + predict_posteriors: bool, +): + """Parallel function to build trees and compute posteriors. + + This inherently assumes that the caller function defines the indices + for the training and testing data for each tree. + """ + tree: Union[DecisionTreeClassifier, DecisionTreeRegressor] = trees[idx] + train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) + + if predict_posteriors: + # XXX: currently assumes n_outputs_ == 1 + y_pred = tree.predict_proba(X[indices_test, :]).reshape(-1, tree.n_classes_) + else: + y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) + + # Fill test set posteriors & set rest NaN + posterior_arr[idx, indices_test, :] = y_pred # posterior + + class BaseForestHT(MetaEstimatorMixin): observe_samples_: ArrayLike observe_posteriors_: ArrayLike @@ -471,9 +501,11 @@ class FeatureImportanceForestRegressor(BaseForestHT): y_true_final_ : ArrayLike of shape (n_samples_final,) The true labels of the samples used in the final test. - observe_posteriors_ : ArrayLike of shape (n_estimators, n_samples_final, n_outputs) or - (n_estimators, n_samples_final, n_classes) + observe_posteriors_ : ArrayLike of shape (n_estimators, n_samples, n_outputs) or + (n_estimators, n_samples, n_classes) The predicted posterior probabilities of the samples used in the final test. + For samples that are NaNs for all estimators, means the sample was not used + in the test set at all across all trees. null_dist_ : ArrayLike of shape (n_repeats,) The null distribution of the test statistic. @@ -551,15 +583,20 @@ def _statistic( posterior_arr = np.full((self.n_estimators, self._n_samples_, estimator.n_outputs_), np.nan) if self.permute_per_tree: - # now initialize posterior array as (n_trees, n_samples_test, n_outputs) - for idx, (indices_train, indices_test) in enumerate(self._get_estimators_indices()): - tree: DecisionTreeRegressor = estimator.estimators_[idx] - train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) - - y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) - - # Fill test set posteriors & set rest NaN - posterior_arr[idx, indices_test, :] = y_pred # posterior + Parallel(n_jobs=estimator.n_jobs, verbose=self.verbose, prefer="threads")( + delayed(_parallel_build_trees_and_compute_posteriors)( + estimator.estimators_, + idx, + indices_train, + indices_test, + X, + y, + covariate_index, + posterior_arr, + False, + ) + for idx, (indices_train, indices_test) in enumerate(self._get_estimators_indices()) + ) else: # fitting a forest will only get one unique train/test split indices_train, indices_test = self.train_test_samples_[0] @@ -760,18 +797,20 @@ def _statistic( (self.n_estimators, self._n_samples_, estimator.n_outputs_), np.nan ) if self.permute_per_tree: - for idx, (indices_train, indices_test) in enumerate(self._get_estimators_indices()): - tree: DecisionTreeClassifier = estimator.estimators_[idx] - train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) - - if predict_posteriors: - # XXX: currently assumes n_outputs_ == 1 - y_pred = tree.predict_proba(X[indices_test, :]).reshape(-1, tree.n_classes_) - else: - y_pred = tree.predict(X[indices_test, :]).reshape(-1, tree.n_outputs_) - - # Fill test set posteriors & set rest NaN - posterior_arr[idx, indices_test, :] = y_pred # posterior + Parallel(n_jobs=estimator.n_jobs, verbose=self.verbose, prefer="threads")( + delayed(_parallel_build_trees_and_compute_posteriors)( + estimator.estimators_, + idx, + indices_train, + indices_test, + X, + y, + covariate_index, + posterior_arr, + predict_posteriors, + ) + for idx, (indices_train, indices_test) in enumerate(self._get_estimators_indices()) + ) else: # fitting a forest will only get one unique train/test split indices_train, indices_test = self.train_test_samples_[0] diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 20fc68e52..628644223 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -319,7 +319,7 @@ def test_iris_pauc_statistic( clf.reset() if sample_dataset_per_tree and not permute_per_tree: # test in another test - pytest.skip() + return stat, pvalue = clf.test( X, From e91060f4042c1bbe7d8c0582bf282eb713efb695 Mon Sep 17 00:00:00 2001 From: Haoyin Xu Date: Wed, 4 Oct 2023 14:43:21 -0400 Subject: [PATCH 65/70] ENH add MIGHT example notebook on AUC --- .../notebooks/might_example_auc.ipynb | 252 ++++++++++++++++++ 1 file changed, 252 insertions(+) create mode 100644 benchmarks_nonasv/notebooks/might_example_auc.ipynb diff --git a/benchmarks_nonasv/notebooks/might_example_auc.ipynb b/benchmarks_nonasv/notebooks/might_example_auc.ipynb new file mode 100644 index 000000000..f844e5185 --- /dev/null +++ b/benchmarks_nonasv/notebooks/might_example_auc.ipynb @@ -0,0 +1,252 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "711de268", + "metadata": {}, + "source": [ + "## Mutual Information for Genuine Hypothesis Testing (MIGHT)" + ] + }, + { + "cell_type": "markdown", + "id": "f7bc7387", + "metadata": {}, + "source": [ + "An example using `sktree.stats.FeatureImportanceForestClassifier` for nonparametric multivariate hypothesis test, on simulated datasets. Here, we present a simulation of how MIGHT is used to evaluate how a \"feature set is important for predicting the target\".\n", + "\n", + "We simulate a dataset with 1000 features, 500 samples, and a binary class target variable. Within each feature set, there is 500 features associated with one feature set, and another 500 features associated with another feature set. One could think of these for example as different datasets collected on the same patient in a biomedical setting.\n", + "The first feature set (X) is strongly correlated with the target, and the second feature set (W) is weakly correlated with the target (y).\n", + "\n", + "We then use MIGHT to calculate the partial AUC of these sets." + ] + }, + { + "cell_type": "markdown", + "id": "55286132", + "metadata": {}, + "source": [ + "### Installation (WIP)\n", + "\n", + "```\n", + "cd scikit-tree/\n", + "git checkout might\n", + "git pull\n", + "pip install -e .\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "07959f0d", + "metadata": {}, + "source": [ + "### Import dependencies & set random seed" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "916af34d", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from scipy.special import expit\n", + "\n", + "from sktree import HonestForestClassifier\n", + "from sktree.stats import FeatureImportanceForestClassifier\n", + "from sktree.tree import DecisionTreeClassifier\n", + "\n", + "seed = 12345\n", + "rng = np.random.default_rng(seed)" + ] + }, + { + "cell_type": "markdown", + "id": "9ccfa9ac", + "metadata": {}, + "source": [ + "### Simulate data\n", + "\n", + "We simulate the two feature sets and the target variable. We then combine them into a single dataset to perform hypothesis testing." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c479d14e", + "metadata": {}, + "outputs": [], + "source": [ + "n_samples = 1000\n", + "n_features_set = 500\n", + "mean = 1.0\n", + "sigma = 2.0\n", + "beta = 5.0\n", + "\n", + "unimportant_mean = 0.0\n", + "unimportant_sigma = 4.5\n", + "\n", + "# first sample the informative features, and then the uniformative features\n", + "X_important = rng.normal(loc=mean, scale=sigma, size=(n_samples, 10))\n", + "X_important = np.hstack(\n", + " [\n", + " X_important,\n", + " rng.normal(\n", + " loc=unimportant_mean,\n", + " scale=unimportant_sigma,\n", + " size=(n_samples, n_features_set - 10),\n", + " ),\n", + " ]\n", + ")\n", + "\n", + "X_unimportant = rng.normal(\n", + " loc=unimportant_mean, scale=unimportant_sigma, size=(n_samples, n_features_set)\n", + ")\n", + "X = np.hstack([X_important, X_unimportant])\n", + "\n", + "# simulate the binary target variable\n", + "y = rng.binomial(n=1, p=expit(beta * X_important[:, :10].sum(axis=1)), size=n_samples)" + ] + }, + { + "cell_type": "markdown", + "id": "7afbe135", + "metadata": {}, + "source": [ + "### Use partial AUC as test statistic\n", + "\n", + "You can specify the max FPR in `statistic`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a3b78a92", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ASH-90 / Partial AUC: 0.6049643724062328\n", + "Shape of Observed Samples: (1000,)\n", + "Shape of Tree Posteriors for the positive class: (125, 1000, 1)\n" + ] + } + ], + "source": [ + "# parameters that could be changed\n", + "n_estimators = 125\n", + "max_features = \"sqrt\"\n", + "metric = \"auc\"\n", + "test_size = 0.2\n", + "n_jobs = -1\n", + "honest_fraction = 0.7\n", + "max_fpr = 0.1\n", + "\n", + "est = FeatureImportanceForestClassifier(\n", + " estimator=HonestForestClassifier(\n", + " n_estimators=n_estimators,\n", + " max_features=max_features,\n", + " tree_estimator=DecisionTreeClassifier(),\n", + " random_state=seed,\n", + " honest_fraction=honest_fraction,\n", + " n_jobs=n_jobs,\n", + " ),\n", + " random_state=seed,\n", + " test_size=test_size,\n", + " permute_per_tree=True,\n", + " sample_dataset_per_tree=True,\n", + ")\n", + "\n", + "# we test for the first feature set, which is important and thus should return a higher AUC\n", + "stat, posterior_arr, samples = est.statistic(\n", + " X_important,\n", + " y,\n", + " metric=metric,\n", + " return_posteriors=True,\n", + ")\n", + "\n", + "print(\"ASH-90 / Partial AUC:\", stat)\n", + "print(\"Shape of Observed Samples:\", samples.shape)\n", + "print(\"Shape of Tree Posteriors for the positive class:\", posterior_arr.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b41d2a8e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ASH-90 / Partial AUC: 0.4944796805261922\n", + "Shape of Observed Samples: (1000,)\n", + "Shape of Tree Posteriors for the positive class: (125, 1000, 1)\n" + ] + } + ], + "source": [ + "# Repeat for the second feature set\n", + "stat, posterior_arr, samples = est.statistic(\n", + " X_unimportant,\n", + " y,\n", + " metric=metric,\n", + " return_posteriors=True,\n", + ")\n", + "\n", + "print(\"ASH-90 / Partial AUC:\", stat)\n", + "print(\"Shape of Observed Samples:\", samples.shape)\n", + "print(\"Shape of Tree Posteriors for the positive class:\", posterior_arr.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "02e69f1c", + "metadata": {}, + "source": [ + "### All posteriors are saved within the model\n", + "\n", + "Extract the results from the model variables anytime. You can save the model with `pickle`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4e8d8f2f", + "metadata": {}, + "outputs": [], + "source": [ + "print(\"ASH-90 / Partial AUC:\", est.observe_stat_)\n", + "print(\"Observed Samples:\", est.observe_samples_)\n", + "print(\"Tree Posteriors for the positive class:\", est.observe_posteriors_) # (n_trees, n_samples_test, 1)\n", + "print(\"True Labels:\", est.y_true_final_)" + ] + } + ], + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From efbd440ef77c676367102a25d15d483d191d872c Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 4 Oct 2023 15:33:14 -0400 Subject: [PATCH 66/70] Consolidate parallleization Signed-off-by: Adam Li --- README.md | 9 +- ...mpare_coleman_and_permutation_forest.ipynb | 6 +- .../forest_ht_independent_data.ipynb | 143 ++++++++++++++++++ ...t_MI_gigantic_hypothesis_testing_forest.py | 6 +- sktree/stats/forestht.py | 96 ++++++++++-- sktree/stats/tests/test_forestht.py | 73 ++++++++- sktree/stats/utils.py | 57 ++----- 7 files changed, 318 insertions(+), 72 deletions(-) create mode 100644 benchmarks_nonasv/notebooks/forest_ht_independent_data.ipynb diff --git a/README.md b/README.md index 4da75fef1..12076150c 100644 --- a/README.md +++ b/README.md @@ -26,8 +26,6 @@ Installation ============ Our installation will try to follow scikit-learn installation as close as possible, as we contain Cython code subclassed, or inspired by the scikit-learn tree submodule. -AS OF NOW, scikit-tree is in development stage and the installation is still finicky due to the upstream scikit-learn's stalled refactoring PRs of the tree submodule. Once those are merged, the installation will be simpler. The current recommended installation is done locally with meson. - Dependencies ------------ @@ -40,11 +38,12 @@ We minimally require: Installation with Pip (https://pypi.org/project/scikit-tree/) ------------------------------------------------------------- +Installing with pip on a conda environment is the recommended route. pip install scikit-tree -Building locally with Meson (RECOMMENDED) ------------------------------------------ +Building locally with Meson (For developers) +-------------------------------------------- Make sure you have the necessary packages installed # install build dependencies @@ -96,7 +95,7 @@ You can also do the same thing using Meson/Ninja itself. Run the following to bu python -c "from sktree import tree" python -c "import sklearn; print(sklearn.__version__);" -Alternatively, you can use editable installs +After building locally, you can use editable installs (warning: this only registers Python changes locally) pip install --no-build-isolation --editable . diff --git a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb index f084e213b..cd38e171f 100644 --- a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb +++ b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb @@ -1488,11 +1488,9 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "0f1ea3aa-ebad-4ff5-ae7b-abe3aa8308b6", + "cell_type": "markdown", + "id": "1c50ea7c-fd59-46c1-9408-ac119592f855", "metadata": {}, - "outputs": [], "source": [] } ], diff --git a/benchmarks_nonasv/notebooks/forest_ht_independent_data.ipynb b/benchmarks_nonasv/notebooks/forest_ht_independent_data.ipynb new file mode 100644 index 000000000..b31e72003 --- /dev/null +++ b/benchmarks_nonasv/notebooks/forest_ht_independent_data.ipynb @@ -0,0 +1,143 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a8602dd6-12b9-4ebf-a217-4cddca954cea", + "metadata": {}, + "source": [ + "# Test on Independent High-dimensional Data\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ad09a023-04db-4748-bfe8-1ec34bc83061", + "metadata": {}, + "outputs": [], + "source": [ + "from collections import defaultdict\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "from scipy.special import expit\n", + "\n", + "from sktree import RandomForestClassifier, RandomForestRegressor\n", + "from sktree.stats import (\n", + " FeatureImportanceForestClassifier,\n", + " FeatureImportanceForestRegressor,\n", + " PermutationForestRegressor,\n", + ")\n", + "\n", + "seed = 12345" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "91b2f4e9-b4df-4ff0-9e99-dc9a68ebc62c", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fa105af9-f0b6-4fbe-9d91-8b2a5493593a", + "metadata": {}, + "outputs": [], + "source": [ + "n_samples = 600\n", + "n_features = 500\n", + "\n", + "n_estimators = 125\n", + "n_jobs = -1\n", + "max_features = \"sqrt\"\n", + "test_size = 1.0 / 6\n", + "metric = \"mse\"\n", + "n_repeats = 500\n", + "permute_per_tree = True\n", + "sample_dataset_per_tree = True\n", + "\n", + "rng = np.random.default_rng(seed)\n", + "\n", + "# initialize hypothesis tester\n", + "est = FeatureImportanceForestClassifier(\n", + " RandomForestClassifier(\n", + " max_features=1.0,\n", + " random_state=seed,\n", + " n_estimators=n_estimators,\n", + " n_jobs=-1,\n", + " ),\n", + " random_state=seed,\n", + " test_size=test_size,\n", + " permute_per_tree=permute_per_tree,\n", + " sample_dataset_per_tree=sample_dataset_per_tree,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "be324da0-524f-4eaa-9fa1-dbad27058dbc", + "metadata": {}, + "source": [ + "# Run Pvalue Computation Over Many Instances" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3b53a9ec-befb-471a-9a44-681bbd86b31b", + "metadata": {}, + "outputs": [], + "source": [ + "stats = []\n", + "pvalues = []\n", + "\n", + "for idx in range(500):\n", + " X = rng.standard_normal(size=(n_samples, n_features))\n", + " y = rng.binomial(1, 0.5, size=n_samples) # .reshape(-1, 1)\n", + " stat, pvalue = est.test(X, y, covariate_index=[0], metric=\"mi\")\n", + " est.reset()\n", + " \n", + " stats.append(stat)\n", + " pvalues.append(pvalue)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ff616595-bad5-4845-94b9-713c11dc5745", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "sktree", + "language": "python", + "name": "sktree" + }, + "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.9.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/plot_MI_gigantic_hypothesis_testing_forest.py b/examples/plot_MI_gigantic_hypothesis_testing_forest.py index 034e5ebec..423bc63dc 100644 --- a/examples/plot_MI_gigantic_hypothesis_testing_forest.py +++ b/examples/plot_MI_gigantic_hypothesis_testing_forest.py @@ -108,10 +108,14 @@ ), random_state=seed, test_size=test_size, - permute_per_tree=False, + permute_per_tree=True, sample_dataset_per_tree=False, ) +print( + f"Permutation per tree: {est.permute_per_tree} and sampling dataset per tree: " + f"{est.sample_dataset_per_tree}" +) # we test for the first feature set, which is important and thus should return a pvalue < 0.05 stat, pvalue = est.test( X, y, covariate_index=np.arange(n_features_set, dtype=int), metric="mi", n_repeats=n_repeats diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index b63cbd894..c49f28275 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -11,10 +11,13 @@ from sklearn.utils.validation import _is_fitted, check_X_y from sktree._lib.sklearn.ensemble._forest import ( + BaseForest, ForestClassifier, ForestRegressor, RandomForestClassifier, RandomForestRegressor, + _get_n_samples_bootstrap, + _parallel_build_trees, ) from sktree.tree import DecisionTreeClassifier, DecisionTreeRegressor @@ -25,12 +28,11 @@ REGRESSOR_METRICS, _compute_null_distribution_coleman, _non_nan_samples, - train_tree, ) def _parallel_build_trees_and_compute_posteriors( - trees, + forest: BaseForest, idx: int, indices_train: ArrayLike, indices_test: ArrayLike, @@ -39,14 +41,56 @@ def _parallel_build_trees_and_compute_posteriors( covariate_index, posterior_arr: ArrayLike, predict_posteriors: bool, + permute_per_tree: bool, + sample_weight: ArrayLike = None, + class_weight=None, + missing_values_in_feature_mask=None, + classes=None, ): """Parallel function to build trees and compute posteriors. This inherently assumes that the caller function defines the indices for the training and testing data for each tree. """ - tree: Union[DecisionTreeClassifier, DecisionTreeRegressor] = trees[idx] - train_tree(tree, X[indices_train, :], y[indices_train, :], covariate_index) + tree: Union[DecisionTreeClassifier, DecisionTreeRegressor] = forest.estimators_[idx] + if permute_per_tree and covariate_index is not None: + random_state = tree.random_state + else: + random_state = forest.random_state + + X_train = X[indices_train, :] + y_train = y[indices_train, ...] + rng = np.random.default_rng(random_state) + + if forest.bootstrap: + n_samples_bootstrap = _get_n_samples_bootstrap( + n_samples=X_train.shape[0], max_samples=forest.max_samples + ) + else: + n_samples_bootstrap = None + + # individual tree permutation of y labels + if covariate_index is not None: + indices = np.arange(X_train.shape[0], dtype=int) + # perform permutation of covariates + index_arr = rng.choice(indices, size=(X_train.shape[0], 1), replace=False, shuffle=True) + perm_X_cov = X_train[index_arr, covariate_index] + X_train[:, covariate_index] = perm_X_cov + + tree = _parallel_build_trees( + tree, + forest.bootstrap, + X_train, + y_train, + sample_weight, + idx, + len(forest.estimators_), + verbose=0, + class_weight=class_weight, + n_samples_bootstrap=n_samples_bootstrap, + missing_values_in_feature_mask=missing_values_in_feature_mask, + classes=classes, + ) if predict_posteriors: # XXX: currently assumes n_outputs_ == 1 @@ -114,7 +158,7 @@ def _get_estimators_indices(self): indices = np.arange(self._n_samples_, dtype=int) # Get drawn indices along both sample and feature axes - if self.permute_per_tree and self.sample_dataset_per_tree: + if self.sample_dataset_per_tree: for tree in self.estimator_.estimators_: seed = tree.random_state @@ -127,7 +171,10 @@ def _get_estimators_indices(self): yield indices_train, indices_test else: indices_train, indices_test = train_test_split( - indices, test_size=self.test_size, shuffle=True, random_state=self.random_state + indices, + test_size=self.test_size, + shuffle=True, + random_state=self.estimator_.random_state, ) for tree in self.estimator_.estimators_: yield indices_train, indices_test @@ -145,6 +192,9 @@ def train_test_samples_(self): to reduce the object memory footprint by not storing the sampling data. Thus fetching the property may be slower than expected. """ + if self._n_samples_ is None: + raise RuntimeError("The estimator must be fitted before accessing this attribute.") + return [ (indices_train, indices_test) for indices_train, indices_test in self._get_estimators_indices() @@ -174,6 +224,12 @@ def _check_input(self, X: ArrayLike, y: ArrayLike, covariate_index: ArrayLike = if not all(isinstance(idx, (np.integer, int)) for idx in covariate_index): raise RuntimeError("Not all covariate_index are integer indices") + if self.test_size * X.shape[0] < 2: + raise RuntimeError( + f"There are less than 2 testing samples used with " + f"test_size={self.test_size} for X ({X.shape})." + ) + if self._n_samples_ is not None and X.shape[0] != self._n_samples_: raise RuntimeError( f"X must have {self._n_samples_} samples, got {X.shape[0]}. " @@ -244,8 +300,8 @@ def statistic( if self._type_of_target_ is None: self._type_of_target_ = type_of_target(y) - if self.sample_dataset_per_tree and not self.permute_per_tree: - raise ValueError("sample_dataset_per_tree is only valid when permute_per_tree=True") + # if self.sample_dataset_per_tree and not self.permute_per_tree: + # raise ValueError("sample_dataset_per_tree is only valid when permute_per_tree=True") if covariate_index is None: self.estimator_ = self._get_estimator() @@ -277,11 +333,11 @@ def statistic( else: estimator.fit(X[:2], y[:2]) - # permute per tree + # sampling a separate train/test per tree if self.sample_dataset_per_tree: self.n_samples_test_ = self._n_samples_ else: - # not permute per tree + # here we fix a training/testing dataset test_size_ = int(self.test_size * self._n_samples_) # Fit each tree and compute posteriors with train test splits @@ -316,7 +372,7 @@ def test( self, X, y, - covariate_index: ArrayLike = None, + covariate_index: ArrayLike, metric: str = "mi", n_repeats: int = 1000, return_posteriors: bool = True, @@ -582,10 +638,13 @@ def _statistic( rng = np.random.default_rng(self.random_state) posterior_arr = np.full((self.n_estimators, self._n_samples_, estimator.n_outputs_), np.nan) - if self.permute_per_tree: + + # both sampling dataset per tree or permuting per tree requires us to bypass the + # sklearn API to fit each tree individually + if self.sample_dataset_per_tree or self.permute_per_tree: Parallel(n_jobs=estimator.n_jobs, verbose=self.verbose, prefer="threads")( delayed(_parallel_build_trees_and_compute_posteriors)( - estimator.estimators_, + estimator, idx, indices_train, indices_test, @@ -594,6 +653,7 @@ def _statistic( covariate_index, posterior_arr, False, + self.permute_per_tree, ) for idx, (indices_train, indices_test) in enumerate(self._get_estimators_indices()) ) @@ -778,7 +838,7 @@ def _statistic( ): """Helper function to compute the test statistic.""" metric_func: Callable[[ArrayLike, ArrayLike], float] = METRIC_FUNCTIONS[metric] - rng = np.random.default_rng(self.random_state) + rng = np.random.default_rng(estimator.random_state) if metric in POSTERIOR_FUNCTIONS: predict_posteriors = True @@ -796,10 +856,13 @@ def _statistic( posterior_arr = np.full( (self.n_estimators, self._n_samples_, estimator.n_outputs_), np.nan ) - if self.permute_per_tree: + + # both sampling dataset per tree or permuting per tree requires us to bypass the + # sklearn API to fit each tree individually + if self.sample_dataset_per_tree or self.permute_per_tree: Parallel(n_jobs=estimator.n_jobs, verbose=self.verbose, prefer="threads")( delayed(_parallel_build_trees_and_compute_posteriors)( - estimator.estimators_, + estimator, idx, indices_train, indices_test, @@ -808,6 +871,7 @@ def _statistic( covariate_index, posterior_arr, predict_posteriors, + self.permute_per_tree, ) for idx, (indices_train, indices_test) in enumerate(self._get_estimators_indices()) ) diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 628644223..37a46173a 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -17,6 +17,7 @@ PermutationForestClassifier, PermutationForestRegressor, ) +from sktree.stats.utils import _non_nan_samples from sktree.tree import ObliqueDecisionTreeClassifier # load the iris dataset (n_samples, 4) @@ -82,8 +83,11 @@ def test_featureimportance_forest_errors(): permute_per_tree=permute_per_tree, sample_dataset_per_tree=sample_dataset_per_tree, ) - with pytest.raises(ValueError, match="sample_dataset_per_tree"): - est.statistic(iris_X[:10], iris_y[:10]) + with pytest.raises(RuntimeError, match="The estimator must be fitted"): + est.train_test_samples_ + + with pytest.raises(RuntimeError, match="There are less than 2 testing samples"): + est.statistic(iris_X[:5], iris_y[:5]) est = FeatureImportanceForestClassifier(estimator=RandomForestRegressor) with pytest.raises(RuntimeError, match="Estimator must be"): @@ -200,6 +204,7 @@ def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size) 1.0 / 6, ], [ + # XXX: Currently does not work with permute and sample dataset per tree FeatureImportanceForestClassifier, { "estimator": RandomForestClassifier( @@ -306,7 +311,7 @@ def test_iris_pauc_statistic( tree_estimator=estimator, honest_prior=honest_prior, random_state=0, - n_jobs=-1, + n_jobs=1, ), test_size=test_size, sample_dataset_per_tree=sample_dataset_per_tree, @@ -462,3 +467,65 @@ def test_pickle(tmpdir): ] for attr in attr_list: assert_array_equal(getattr(clf, attr), getattr(clf_pickle, attr)) + + +@pytest.mark.parametrize("permute_per_tree", [True, False]) +@pytest.mark.parametrize("sample_dataset_per_tree", [True, False]) +def test_sample_size_consistency_of_estimator_indices_(permute_per_tree, sample_dataset_per_tree): + """Test that the test-sample indices are what is expected.""" + clf = FeatureImportanceForestClassifier( + estimator=HonestForestClassifier( + n_estimators=10, random_state=seed, n_jobs=1, honest_fraction=0.2 + ), + test_size=0.5, + permute_per_tree=permute_per_tree, + sample_dataset_per_tree=sample_dataset_per_tree, + ) + + n_samples = 100 + n_features = 5 + X = rng.uniform(size=(n_samples, n_features)) + y = rng.integers(0, 2, size=n_samples) # Binary classification + + _, posteriors, samples = clf.statistic( + X, y, covariate_index=None, return_posteriors=True, metric="mi" + ) + if sample_dataset_per_tree: + assert_array_equal( + samples, + sorted(np.unique(np.concatenate([x[1] for x in clf.train_test_samples_]).flatten())), + ) + else: + assert_array_equal(samples, sorted(clf.train_test_samples_[0][1])) + assert len(_non_nan_samples(posteriors)) == len(samples) + + +def test_permute_per_tree_samples_consistency_with_sklearnforest(): + n_samples = 100 + n_features = 5 + X = rng.uniform(size=(n_samples, n_features)) + y = rng.integers(0, 2, size=n_samples) # Binary classification + + clf = FeatureImportanceForestClassifier( + estimator=HonestForestClassifier( + n_estimators=10, random_state=seed, n_jobs=1, honest_fraction=0.2 + ), + test_size=0.5, + permute_per_tree=True, + sample_dataset_per_tree=False, + ) + + other_clf = FeatureImportanceForestClassifier( + estimator=HonestForestClassifier( + n_estimators=10, random_state=seed, n_jobs=1, honest_fraction=0.2 + ), + test_size=0.5, + permute_per_tree=False, + sample_dataset_per_tree=False, + ) + + clf.statistic(X, y, covariate_index=None, metric="mi") + other_clf.statistic(X, y, covariate_index=None, metric="mi") + + assert_array_equal(clf.train_test_samples_[0][0], other_clf.train_test_samples_[0][0]) + assert_array_equal(clf.train_test_samples_[0][1], other_clf.train_test_samples_[0][1]) diff --git a/sktree/stats/utils.py b/sktree/stats/utils.py index d2f36c1e4..2d36c1e22 100644 --- a/sktree/stats/utils.py +++ b/sktree/stats/utils.py @@ -12,7 +12,6 @@ from sklearn.utils.validation import check_X_y from sktree._lib.sklearn.ensemble._forest import ForestClassifier -from sktree._lib.sklearn.tree import DecisionTreeClassifier def _mutual_information(y_true: ArrayLike, y_pred_proba: ArrayLike) -> float: @@ -104,41 +103,6 @@ def _non_nan_samples(posterior_arr: ArrayLike) -> ArrayLike: return nonnan_indices -def train_tree( - tree: DecisionTreeClassifier, - X: ArrayLike, - y: ArrayLike, - covariate_index: ArrayLike = None, -) -> ArrayLike: - """Compute the posterior from each tree on the "OOB" samples. - - Parameters - ---------- - tree : DecisionTreeClassifier - The tree to compute the posterior from. - X : ArrayLike of shape (n_samples, n_features) - The data matrix. - y : ArrayLike of shape (n_samples, n_outputs) - The output matrix. - covariate_index : ArrayLike of shape (n_covariates,), optional - The indices of the covariates to permute, by default None, which - does not permute any columns. - """ - # seed the random number generator using each tree's random seed(?) - rng = np.random.default_rng(tree.random_state) - - indices = np.arange(X.shape[0], dtype=int) - - if covariate_index is not None: - # perform permutation of covariates - index_arr = rng.choice(indices, size=(X.shape[0], 1), replace=False, shuffle=True) - perm_X_cov = X[index_arr, covariate_index] - X[:, covariate_index] = perm_X_cov - - # individual tree permutation of y labels - tree.fit(X, y, check_input=False) - - def _compute_null_distribution_perm( X_train: ArrayLike, y_train: ArrayLike, @@ -279,17 +243,24 @@ def _compute_null_distribution_coleman( second_forest_samples = _non_nan_samples(second_forest_pred) # todo: is this step necessary? - non_nan_samples = np.intersect1d( - first_forest_samples, second_forest_samples, assume_unique=True - ) + # non_nan_samples = np.intersect1d( + # first_forest_samples, second_forest_samples, assume_unique=True + # ) # now average the posteriors over the trees for the non-nan samples - y_pred_first_half = np.nanmean(first_forest_pred[:, non_nan_samples, :], axis=0) - y_pred_second_half = np.nanmean(second_forest_pred[:, non_nan_samples, :], axis=0) + # y_pred_first_half = np.nanmean(first_forest_pred[:, non_nan_samples, :], axis=0) + # y_pred_second_half = np.nanmean(second_forest_pred[:, non_nan_samples, :], axis=0) + + # # compute two instances of the metric from the sampled trees + # first_half_metric = metric_func(y_test[non_nan_samples, :], y_pred_first_half) + # second_half_metric = metric_func(y_test[non_nan_samples, :], y_pred_second_half) + + y_pred_first_half = np.nanmean(first_forest_pred[:, first_forest_samples, :], axis=0) + y_pred_second_half = np.nanmean(second_forest_pred[:, second_forest_samples, :], axis=0) # compute two instances of the metric from the sampled trees - first_half_metric = metric_func(y_test[non_nan_samples, :], y_pred_first_half) - second_half_metric = metric_func(y_test[non_nan_samples, :], y_pred_second_half) + first_half_metric = metric_func(y_test[first_forest_samples, :], y_pred_first_half) + second_half_metric = metric_func(y_test[second_forest_samples, :], y_pred_second_half) metric_star[idx] = first_half_metric metric_star_pi[idx] = second_half_metric From be16e5a8dccb9d786580efb28df93526cd2a408e Mon Sep 17 00:00:00 2001 From: Sambit Panda Date: Wed, 4 Oct 2023 23:25:00 -0400 Subject: [PATCH 67/70] set default for covariate_index in ForestHT test --- sktree/stats/forestht.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index c49f28275..fa1d6950a 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -372,7 +372,7 @@ def test( self, X, y, - covariate_index: ArrayLike, + covariate_index: ArrayLike = None, metric: str = "mi", n_repeats: int = 1000, return_posteriors: bool = True, From 26b5b5feb7f1b19c81b7fb26d20bef1fb12049b3 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Thu, 5 Oct 2023 00:10:45 -0400 Subject: [PATCH 68/70] Add unit-test for small sample sizes Signed-off-by: Adam Li --- .../forest_ht_independent_data.ipynb | 66 +++++- sktree/stats/forestht.py | 38 ++- sktree/stats/tests/test_coleman.py | 191 +++++++++++++++ sktree/stats/tests/test_forestht.py | 223 +++--------------- 4 files changed, 317 insertions(+), 201 deletions(-) create mode 100644 sktree/stats/tests/test_coleman.py diff --git a/benchmarks_nonasv/notebooks/forest_ht_independent_data.ipynb b/benchmarks_nonasv/notebooks/forest_ht_independent_data.ipynb index b31e72003..fe8e153ce 100644 --- a/benchmarks_nonasv/notebooks/forest_ht_independent_data.ipynb +++ b/benchmarks_nonasv/notebooks/forest_ht_independent_data.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 15, "id": "ad09a023-04db-4748-bfe8-1ec34bc83061", "metadata": {}, "outputs": [], @@ -36,10 +36,19 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 16, "id": "91b2f4e9-b4df-4ff0-9e99-dc9a68ebc62c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "%load_ext autoreload\n", "%autoreload 2" @@ -47,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 17, "id": "fa105af9-f0b6-4fbe-9d91-8b2a5493593a", "metadata": {}, "outputs": [], @@ -61,8 +70,8 @@ "test_size = 1.0 / 6\n", "metric = \"mse\"\n", "n_repeats = 500\n", - "permute_per_tree = True\n", - "sample_dataset_per_tree = True\n", + "permute_per_tree = False\n", + "sample_dataset_per_tree = False\n", "\n", "rng = np.random.default_rng(seed)\n", "\n", @@ -104,10 +113,9 @@ " y = rng.binomial(1, 0.5, size=n_samples) # .reshape(-1, 1)\n", " stat, pvalue = est.test(X, y, covariate_index=[0], metric=\"mi\")\n", " est.reset()\n", - " \n", + "\n", " stats.append(stat)\n", - " pvalues.append(pvalue)\n", - " " + " pvalues.append(pvalue)" ] }, { @@ -116,6 +124,46 @@ "id": "ff616595-bad5-4845-94b9-713c11dc5745", "metadata": {}, "outputs": [], + "source": [ + "plt.plot(pvalues)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c4569a24-4b12-4266-8d6c-7e740737c59f", + "metadata": {}, + "outputs": [], + "source": [ + "stats = []\n", + "pvalues = []\n", + "\n", + "for idx in range(500):\n", + " X = rng.standard_normal(size=(n_samples, n_features))\n", + " y = rng.binomial(1, 0.5, size=n_samples) # .reshape(-1, 1)\n", + " stat, pvalue = est.test(X, y, covariate_index=[0], metric=\"mi\")\n", + " est.reset()\n", + "\n", + " stats.append(stat)\n", + " pvalues.append(pvalue)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2da6a320-605a-40d6-9f8f-1aa1ff03110e", + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(pvalues, \"x\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "42ecee87-31b9-4c52-b867-348569050142", + "metadata": {}, + "outputs": [], "source": [] } ], diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py index fa1d6950a..122b5f377 100644 --- a/sktree/stats/forestht.py +++ b/sktree/stats/forestht.py @@ -224,9 +224,9 @@ def _check_input(self, X: ArrayLike, y: ArrayLike, covariate_index: ArrayLike = if not all(isinstance(idx, (np.integer, int)) for idx in covariate_index): raise RuntimeError("Not all covariate_index are integer indices") - if self.test_size * X.shape[0] < 2: + if self.test_size * X.shape[0] < 5: raise RuntimeError( - f"There are less than 2 testing samples used with " + f"There are less than 5 testing samples used with " f"test_size={self.test_size} for X ({X.shape})." ) @@ -619,6 +619,40 @@ def statistic( check_input: bool = True, **metric_kwargs, ): + """Compute the test statistic. + + Parameters + ---------- + X : ArrayLike of shape (n_samples, n_features) + The data matrix. + y : ArrayLike of shape (n_samples, n_outputs) + The target matrix. + covariate_index : ArrayLike, optional of shape (n_covariates,) + The index array of covariates to shuffle, by default None. + metric : str, optional + The metric to compute, by default "mse". + return_posteriors : bool, optional + Whether or not to return the posteriors, by default False. + check_input : bool, optional + Whether or not to check the input, by default True. + **metric_kwargs : dict, optional + Additional keyword arguments to pass to the metric function. + + Returns + ------- + stat : float + The test statistic. + posterior_final : ArrayLike of shape (n_estimators, n_samples_final, n_outputs) or + (n_estimators, n_samples_final), optional + If ``return_posteriors`` is True, then the posterior probabilities of the + samples used in the final test. ``n_samples_final`` is equal to ``n_samples`` + if all samples are encountered in the test set of at least one tree in the + posterior computation. + samples : ArrayLike of shape (n_samples_final,), optional + The indices of the samples used in the final test. ``n_samples_final`` is + equal to ``n_samples`` if all samples are encountered in the test set of at + least one tree in the posterior computation. + """ return super().statistic( X, y, covariate_index, metric, return_posteriors, check_input, **metric_kwargs ) diff --git a/sktree/stats/tests/test_coleman.py b/sktree/stats/tests/test_coleman.py new file mode 100644 index 000000000..58c6d6f73 --- /dev/null +++ b/sktree/stats/tests/test_coleman.py @@ -0,0 +1,191 @@ +import numpy as np +import pytest +from flaky import flaky +from scipy.special import expit + +from sktree import RandomForestClassifier, RandomForestRegressor +from sktree.stats import ( + FeatureImportanceForestClassifier, + FeatureImportanceForestRegressor, + PermutationForestClassifier, + PermutationForestRegressor, +) + +seed = 12345 +rng = np.random.default_rng(seed) + + +@flaky(max_runs=3) +@pytest.mark.slowtest +@pytest.mark.parametrize( + "hypotester, model_kwargs, n_samples, n_repeats, test_size", + [ + [ + PermutationForestRegressor, + { + "estimator": RandomForestRegressor( + max_features="sqrt", + random_state=seed, + n_estimators=75, + n_jobs=-1, + ), + "random_state": seed, + }, + 300, + 50, + 0.1, + ], + [ + FeatureImportanceForestRegressor, + { + "estimator": RandomForestRegressor( + max_features="sqrt", + random_state=seed, + n_estimators=125, + n_jobs=-1, + ), + "random_state": seed, + "permute_per_tree": True, + "sample_dataset_per_tree": True, + }, + 300, # n_samples + 1000, # n_repeats + 0.2, # test_size + ], + ], +) +def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size): + r"""Test hypothesis testing forests using MSE from linear model simulation. + + See https://arxiv.org/pdf/1904.07830.pdf Figure 1. + + Y = Beta * X_1 + Beta * I(X_6 = 2) + \epsilon + """ + beta = 15.0 + sigma = 0.05 + metric = "mse" + + # sample covariates + X_15 = rng.uniform(0, 1, size=(n_samples, 5)) + X_610 = np.zeros((n_samples, 5)) + for idx in range(5): + X_610[:, idx] = np.argwhere( + rng.multinomial(1, [1.0 / 3, 1.0 / 3, 1.0 / 3], size=(n_samples,)) + )[:, 1] + X = np.concatenate((X_15, X_610), axis=1) + assert X.shape == (n_samples, 10) + + # sample noise + epsilon = rng.normal(size=n_samples, loc=0.0, scale=sigma) + + # compute final y of (n_samples,) + y = beta * X[:, 0] + (beta * (X[:, 5] == 2.0)) + epsilon + est = hypotester(test_size=test_size, **model_kwargs) + + # test for X_1 + stat, pvalue = est.test(X, y, [0], metric=metric, n_repeats=n_repeats) + print("X1: ", pvalue) + assert pvalue < 0.05, f"pvalue: {pvalue}" + + # test for X_6 + stat, pvalue = est.test(X, y, [5], metric=metric, n_repeats=n_repeats) + print("X6: ", pvalue) + assert pvalue < 0.05, f"pvalue: {pvalue}" + + # test for a few unimportant other X + for covariate_index in [1, 6]: + # test for X_2, X_7 + stat, pvalue = est.test(X, y, [covariate_index], metric=metric, n_repeats=n_repeats) + print("X2/7: ", pvalue) + assert pvalue > 0.05, f"pvalue: {pvalue}" + + +@flaky(max_runs=3) +@pytest.mark.slowtest +@pytest.mark.parametrize( + "hypotester, model_kwargs, n_samples, n_repeats, test_size", + [ + [ + PermutationForestClassifier, + { + "estimator": RandomForestClassifier( + max_features="sqrt", + random_state=seed, + n_estimators=50, + n_jobs=-1, + ), + "random_state": seed, + }, + 600, + 50, + 1.0 / 6, + ], + [ + # XXX: Currently does not work with permute and sample dataset per tree + FeatureImportanceForestClassifier, + { + "estimator": RandomForestClassifier( + max_features="sqrt", + random_state=seed, + n_estimators=100, + n_jobs=-1, + ), + "random_state": seed, + "permute_per_tree": False, + "sample_dataset_per_tree": False, + }, + 600, # n_samples + 1000, # n_repeats + 1.0 / 6, # test_size + ], + ], +) +def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, test_size): + r"""Test MIGHT using MSE from linear model simulation. + + See https://arxiv.org/pdf/1904.07830.pdf Figure 1. + + P(Y = 1 | X) = expit(beta * \\sum_{j=2}^5 X_j) + """ + beta = 10.0 + metric = "mse" + + n = 100 # Number of time steps + ar_coefficient = 0.015 + + X = np.zeros((n_samples, n)) + for idx in range(n_samples): + # sample covariates + white_noise = rng.standard_normal(size=n) + + # Create an array to store the simulated AR(1) time series + ar1_series = np.zeros(n) + ar1_series[0] = white_noise[0] + + # Simulate the AR(1) process + for t in range(1, n): + ar1_series[t] = ar_coefficient * ar1_series[t - 1] + white_noise[t] + + X[idx, :] = ar1_series + + # now compute the output labels + y_proba = expit(beta * X[:, 1:5].sum(axis=1)) + assert y_proba.shape == (n_samples,) + y = rng.binomial(1, y_proba, size=n_samples) # .reshape(-1, 1) + + est = hypotester(test_size=test_size, **model_kwargs) + + # test for X_2 important + stat, pvalue = est.test(X.copy(), y.copy(), [1], n_repeats=n_repeats, metric=metric) + print("X2: ", pvalue) + assert pvalue < 0.05, f"pvalue: {pvalue}" + + # test for X_1 unimportant + stat, pvalue = est.test(X.copy(), y.copy(), [0], n_repeats=n_repeats, metric=metric) + print("X1: ", pvalue) + assert pvalue > 0.05, f"pvalue: {pvalue}" + + # test for X_500 unimportant + stat, pvalue = est.test(X.copy(), y.copy(), [n - 1], n_repeats=n_repeats, metric=metric) + print("X500: ", pvalue) + assert pvalue > 0.05, f"pvalue: {pvalue}" diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index 37a46173a..de7a4eb5e 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -6,17 +6,11 @@ from flaky import flaky from joblib import Parallel, delayed from numpy.testing import assert_array_equal -from scipy.special import expit from sklearn import datasets from sktree import HonestForestClassifier, RandomForestClassifier, RandomForestRegressor from sktree._lib.sklearn.tree import DecisionTreeClassifier -from sktree.stats import ( - FeatureImportanceForestClassifier, - FeatureImportanceForestRegressor, - PermutationForestClassifier, - PermutationForestRegressor, -) +from sktree.stats import FeatureImportanceForestClassifier, FeatureImportanceForestRegressor from sktree.stats.utils import _non_nan_samples from sktree.tree import ObliqueDecisionTreeClassifier @@ -80,198 +74,23 @@ def test_featureimportance_forest_errors(): estimator=RandomForestClassifier( n_estimators=10, ), + test_size=0.5, permute_per_tree=permute_per_tree, sample_dataset_per_tree=sample_dataset_per_tree, ) with pytest.raises(RuntimeError, match="The estimator must be fitted"): est.train_test_samples_ - with pytest.raises(RuntimeError, match="There are less than 2 testing samples"): + with pytest.raises(RuntimeError, match="There are less than 5 testing samples"): est.statistic(iris_X[:5], iris_y[:5]) - est = FeatureImportanceForestClassifier(estimator=RandomForestRegressor) + est = FeatureImportanceForestClassifier(estimator=RandomForestRegressor, test_size=0.5) with pytest.raises(RuntimeError, match="Estimator must be"): - est.statistic(iris_X[:10], iris_y[:10]) + est.statistic(iris_X[:20], iris_y[:20]) - est = FeatureImportanceForestRegressor(estimator=RandomForestClassifier) + est = FeatureImportanceForestRegressor(estimator=RandomForestClassifier, test_size=0.5) with pytest.raises(RuntimeError, match="Estimator must be"): - est.statistic(iris_X[:10], iris_y[:10]) - - -@flaky(max_runs=3) -@pytest.mark.slowtest -@pytest.mark.parametrize( - "hypotester, model_kwargs, n_samples, n_repeats, test_size", - [ - [ - PermutationForestRegressor, - { - "estimator": RandomForestRegressor( - max_features="sqrt", - random_state=seed, - n_estimators=75, - n_jobs=-1, - ), - "random_state": seed, - }, - 300, - 50, - 0.1, - ], - [ - FeatureImportanceForestRegressor, - { - "estimator": RandomForestRegressor( - max_features="sqrt", - random_state=seed, - n_estimators=125, - n_jobs=-1, - ), - "random_state": seed, - "permute_per_tree": True, - "sample_dataset_per_tree": True, - }, - 300, # n_samples - 1000, # n_repeats - 0.2, # test_size - ], - ], -) -def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size): - r"""Test hypothesis testing forests using MSE from linear model simulation. - - See https://arxiv.org/pdf/1904.07830.pdf Figure 1. - - Y = Beta * X_1 + Beta * I(X_6 = 2) + \epsilon - """ - beta = 15.0 - sigma = 0.05 - metric = "mse" - - # sample covariates - X_15 = rng.uniform(0, 1, size=(n_samples, 5)) - X_610 = np.zeros((n_samples, 5)) - for idx in range(5): - X_610[:, idx] = np.argwhere( - rng.multinomial(1, [1.0 / 3, 1.0 / 3, 1.0 / 3], size=(n_samples,)) - )[:, 1] - X = np.concatenate((X_15, X_610), axis=1) - assert X.shape == (n_samples, 10) - - # sample noise - epsilon = rng.normal(size=n_samples, loc=0.0, scale=sigma) - - # compute final y of (n_samples,) - y = beta * X[:, 0] + (beta * (X[:, 5] == 2.0)) + epsilon - est = hypotester(test_size=test_size, **model_kwargs) - - # test for X_1 - stat, pvalue = est.test(X, y, [0], metric=metric, n_repeats=n_repeats) - print("X1: ", pvalue) - assert pvalue < 0.05, f"pvalue: {pvalue}" - - # test for X_6 - stat, pvalue = est.test(X, y, [5], metric=metric, n_repeats=n_repeats) - print("X6: ", pvalue) - assert pvalue < 0.05, f"pvalue: {pvalue}" - - # test for a few unimportant other X - for covariate_index in [1, 6]: - # test for X_2, X_7 - stat, pvalue = est.test(X, y, [covariate_index], metric=metric, n_repeats=n_repeats) - print("X2/7: ", pvalue) - assert pvalue > 0.05, f"pvalue: {pvalue}" - - -@flaky(max_runs=3) -@pytest.mark.slowtest -@pytest.mark.parametrize( - "hypotester, model_kwargs, n_samples, n_repeats, test_size", - [ - [ - PermutationForestClassifier, - { - "estimator": RandomForestClassifier( - max_features="sqrt", - random_state=seed, - n_estimators=50, - n_jobs=-1, - ), - "random_state": seed, - }, - 600, - 50, - 1.0 / 6, - ], - [ - # XXX: Currently does not work with permute and sample dataset per tree - FeatureImportanceForestClassifier, - { - "estimator": RandomForestClassifier( - max_features="sqrt", - random_state=seed, - n_estimators=100, - n_jobs=-1, - ), - "random_state": seed, - "permute_per_tree": False, - "sample_dataset_per_tree": False, - }, - 600, # n_samples - 1000, # n_repeats - 1.0 / 6, # test_size - ], - ], -) -def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats, test_size): - r"""Test MIGHT using MSE from linear model simulation. - - See https://arxiv.org/pdf/1904.07830.pdf Figure 1. - - P(Y = 1 | X) = expit(beta * \\sum_{j=2}^5 X_j) - """ - beta = 10.0 - metric = "mse" - - n = 100 # Number of time steps - ar_coefficient = 0.015 - - X = np.zeros((n_samples, n)) - for idx in range(n_samples): - # sample covariates - white_noise = rng.standard_normal(size=n) - - # Create an array to store the simulated AR(1) time series - ar1_series = np.zeros(n) - ar1_series[0] = white_noise[0] - - # Simulate the AR(1) process - for t in range(1, n): - ar1_series[t] = ar_coefficient * ar1_series[t - 1] + white_noise[t] - - X[idx, :] = ar1_series - - # now compute the output labels - y_proba = expit(beta * X[:, 1:5].sum(axis=1)) - assert y_proba.shape == (n_samples,) - y = rng.binomial(1, y_proba, size=n_samples) # .reshape(-1, 1) - - est = hypotester(test_size=test_size, **model_kwargs) - - # test for X_2 important - stat, pvalue = est.test(X.copy(), y.copy(), [1], n_repeats=n_repeats, metric=metric) - print("X2: ", pvalue) - assert pvalue < 0.05, f"pvalue: {pvalue}" - - # test for X_1 unimportant - stat, pvalue = est.test(X.copy(), y.copy(), [0], n_repeats=n_repeats, metric=metric) - print("X1: ", pvalue) - assert pvalue > 0.05, f"pvalue: {pvalue}" - - # test for X_500 unimportant - stat, pvalue = est.test(X.copy(), y.copy(), [n - 1], n_repeats=n_repeats, metric=metric) - print("X500: ", pvalue) - assert pvalue > 0.05, f"pvalue: {pvalue}" + est.statistic(iris_X[:20], iris_y[:20]) @flaky(max_runs=2) @@ -398,10 +217,10 @@ def test_forestht_check_inputs(forest_hyppo): @pytest.mark.parametrize("backend", ["loky", "threading"]) -@pytest.mark.parametrize("n_jobs", [1, -1]) +@pytest.mark.parametrize("n_jobs", [1, 2]) def test_parallelization(backend, n_jobs): """Test parallelization of training forests.""" - n_samples = 100 + n_samples = 20 n_features = 5 X = rng.uniform(size=(n_samples, n_features)) y = rng.integers(0, 2, size=n_samples) # Binary classification @@ -529,3 +348,27 @@ def test_permute_per_tree_samples_consistency_with_sklearnforest(): assert_array_equal(clf.train_test_samples_[0][0], other_clf.train_test_samples_[0][0]) assert_array_equal(clf.train_test_samples_[0][1], other_clf.train_test_samples_[0][1]) + + +def test_small_dataset(): + n_samples = 32 + n_features = 5 + X = rng.uniform(size=(n_samples, n_features)) + y = rng.integers(0, 2, size=n_samples) # Binary classification + + clf = FeatureImportanceForestClassifier( + estimator=HonestForestClassifier( + n_estimators=10, random_state=seed, n_jobs=1, honest_fraction=0.5 + ), + test_size=0.2, + permute_per_tree=False, + sample_dataset_per_tree=False, + ) + stat, pvalue = clf.test(X, y, covariate_index=[1, 2], metric="mi") + assert ~np.isnan(pvalue) + assert ~np.isnan(stat) + assert pvalue > 0.05 + + stat, pvalue = clf.test(X, y, metric="mi") + assert stat == 0.0 + assert pvalue > 0.05 From 80a4304c5fc556e34d878b8f3188e72be2bee318 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Thu, 5 Oct 2023 10:29:06 -0400 Subject: [PATCH 69/70] Final commit Signed-off-by: Adam Li --- .../forest_ht_independent_data.ipynb | 264 +++++++++++++++++- sktree/conftest.py | 20 +- sktree/stats/tests/meson.build | 3 +- sktree/stats/tests/test_forestht.py | 19 ++ 4 files changed, 283 insertions(+), 23 deletions(-) diff --git a/benchmarks_nonasv/notebooks/forest_ht_independent_data.ipynb b/benchmarks_nonasv/notebooks/forest_ht_independent_data.ipynb index fe8e153ce..38e3088b6 100644 --- a/benchmarks_nonasv/notebooks/forest_ht_independent_data.ipynb +++ b/benchmarks_nonasv/notebooks/forest_ht_independent_data.ipynb @@ -100,7 +100,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, + "id": "560b27ff-26a1-45af-98d8-f2b4ac3c0c70", + "metadata": {}, + "outputs": [], + "source": [ + "permute_per_tree = True\n", + "sample_dataset_per_tree = True\n", + "\n", + "rng = np.random.default_rng(seed)\n", + "\n", + "# initialize hypothesis tester\n", + "est = FeatureImportanceForestClassifier(\n", + " RandomForestClassifier(\n", + " max_features=1.0,\n", + " random_state=seed,\n", + " n_estimators=n_estimators,\n", + " n_jobs=-1,\n", + " ),\n", + " random_state=seed,\n", + " test_size=test_size,\n", + " permute_per_tree=permute_per_tree,\n", + " sample_dataset_per_tree=sample_dataset_per_tree,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, "id": "3b53a9ec-befb-471a-9a44-681bbd86b31b", "metadata": {}, "outputs": [], @@ -120,17 +147,65 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "ff616595-bad5-4845-94b9-713c11dc5745", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.plot(pvalues)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, + "id": "cdf6ee7b-8ab5-4abd-af46-63e5889a7baf", + "metadata": {}, + "outputs": [], + "source": [ + "permute_per_tree = False\n", + "sample_dataset_per_tree = False\n", + "\n", + "rng = np.random.default_rng(seed)\n", + "\n", + "# initialize hypothesis tester\n", + "est = FeatureImportanceForestClassifier(\n", + " RandomForestClassifier(\n", + " max_features=1.0,\n", + " random_state=seed,\n", + " n_estimators=n_estimators,\n", + " n_jobs=-1,\n", + " ),\n", + " random_state=seed,\n", + " test_size=test_size,\n", + " permute_per_tree=permute_per_tree,\n", + " sample_dataset_per_tree=sample_dataset_per_tree,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, "id": "c4569a24-4b12-4266-8d6c-7e740737c59f", "metadata": {}, "outputs": [], @@ -150,10 +225,187 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "2da6a320-605a-40d6-9f8f-1aa1ff03110e", "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(pvalues, \"x\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "42ecee87-31b9-4c52-b867-348569050142", + "metadata": {}, + "outputs": [], + "source": [ + "permute_per_tree = True\n", + "sample_dataset_per_tree = False\n", + "\n", + "rng = np.random.default_rng(seed)\n", + "\n", + "# initialize hypothesis tester\n", + "est = FeatureImportanceForestClassifier(\n", + " RandomForestClassifier(\n", + " max_features=1.0,\n", + " random_state=seed,\n", + " n_estimators=n_estimators,\n", + " n_jobs=-1,\n", + " ),\n", + " random_state=seed,\n", + " test_size=test_size,\n", + " permute_per_tree=permute_per_tree,\n", + " sample_dataset_per_tree=sample_dataset_per_tree,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "d2193297-b494-4cc4-8cf9-ea2f209e907b", + "metadata": {}, + "outputs": [], + "source": [ + "stats = []\n", + "pvalues = []\n", + "\n", + "for idx in range(500):\n", + " X = rng.standard_normal(size=(n_samples, n_features))\n", + " y = rng.binomial(1, 0.5, size=n_samples) # .reshape(-1, 1)\n", + " stat, pvalue = est.test(X, y, covariate_index=[0], metric=\"mi\")\n", + " est.reset()\n", + "\n", + " stats.append(stat)\n", + " pvalues.append(pvalue)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "65cfa941-9009-430f-a709-02a781db18f0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(pvalues, \"x\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "2c4c4933-9735-4660-917f-641be99bf48a", + "metadata": {}, + "outputs": [], + "source": [ + "permute_per_tree = False\n", + "sample_dataset_per_tree = True\n", + "\n", + "rng = np.random.default_rng(seed)\n", + "\n", + "# initialize hypothesis tester\n", + "est = FeatureImportanceForestClassifier(\n", + " RandomForestClassifier(\n", + " max_features=1.0,\n", + " random_state=seed,\n", + " n_estimators=n_estimators,\n", + " n_jobs=-1,\n", + " ),\n", + " random_state=seed,\n", + " test_size=test_size,\n", + " permute_per_tree=permute_per_tree,\n", + " sample_dataset_per_tree=sample_dataset_per_tree,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "2beb63bf-77e3-43bc-8259-f6e8a149825d", + "metadata": {}, "outputs": [], + "source": [ + "stats = []\n", + "pvalues = []\n", + "\n", + "for idx in range(500):\n", + " X = rng.standard_normal(size=(n_samples, n_features))\n", + " y = rng.binomial(1, 0.5, size=n_samples) # .reshape(-1, 1)\n", + " stat, pvalue = est.test(X, y, covariate_index=[0], metric=\"mi\")\n", + " est.reset()\n", + "\n", + " stats.append(stat)\n", + " pvalues.append(pvalue)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "54654a10-40ff-44b0-9015-c97d34e00dd9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.plot(pvalues, \"x\")" ] @@ -161,7 +413,7 @@ { "cell_type": "code", "execution_count": null, - "id": "42ecee87-31b9-4c52-b867-348569050142", + "id": "37269289-a50d-4a7d-ae32-cde44e38ae97", "metadata": {}, "outputs": [], "source": [] diff --git a/sktree/conftest.py b/sktree/conftest.py index 7b69b7098..ba40aa1fb 100644 --- a/sktree/conftest.py +++ b/sktree/conftest.py @@ -1,22 +1,10 @@ -# import pytest +import pytest - -# def pytest_addoption(parser): -# parser.addoption( -# "--runslow", action="store_true", default=False, help="run slow tests" -# ) +# With the following global module marker, +# monitoring is disabled by default: +pytestmark = [pytest.mark.monitor_skip_test] def pytest_configure(config): """Set up pytest markers.""" config.addinivalue_line("markers", "slowtest: mark test as slow") - - -# def pytest_collection_modifyitems(config, items): -# if config.getoption("--runslow"): -# # --runslow given in cli: do not skip slow tests -# return -# skip_slow = pytest.mark.skip(reason="need --runslow option to run") -# for item in items: -# if "slow" in item.keywords: -# item.add_marker(skip_slow) diff --git a/sktree/stats/tests/meson.build b/sktree/stats/tests/meson.build index 2f18f5a65..c0b2305ff 100644 --- a/sktree/stats/tests/meson.build +++ b/sktree/stats/tests/meson.build @@ -1,6 +1,7 @@ python_sources = [ '__init__.py', - 'test_forestht.py' + 'test_forestht.py', + 'test_coleman.py' ] py3.install_sources( diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py index de7a4eb5e..2ad605229 100644 --- a/sktree/stats/tests/test_forestht.py +++ b/sktree/stats/tests/test_forestht.py @@ -372,3 +372,22 @@ def test_small_dataset(): stat, pvalue = clf.test(X, y, metric="mi") assert stat == 0.0 assert pvalue > 0.05 + + +# @pytest.mark.monitor_test +# def test_memory_usage(): +# n_samples = 1000 +# n_features = 5000 +# X = rng.uniform(size=(n_samples, n_features)) +# y = rng.integers(0, 2, size=n_samples) # Binary classification + +# clf = FeatureImportanceForestClassifier( +# estimator=HonestForestClassifier( +# n_estimators=10, random_state=seed, n_jobs=-1, honest_fraction=0.5 +# ), +# test_size=0.2, +# permute_per_tree=False, +# sample_dataset_per_tree=False, +# ) + +# stat, pvalue = clf.test(X, y, covariate_index=[1, 2], metric="mi") From 60d9c856bf4fe65ae42f154c9fda12415696b519 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Thu, 5 Oct 2023 10:30:05 -0400 Subject: [PATCH 70/70] Release v0.2 Signed-off-by: Adam Li --- pyproject.toml | 2 +- sktree/__init__.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 544710691..2c0d0c2af 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ name = "scikit-tree" # 0.0.0 is standard placeholder for poetry-dynamic-versioning # any changes to this should not be checked in # -version = "0.2.0dev0" +version = "0.2.0" description = "Modern decision trees in Python" maintainers = [ {name="Neurodata", email="adam.li@columbia.edu"} diff --git a/sktree/__init__.py b/sktree/__init__.py index c6af80ea0..e0fe9e741 100644 --- a/sktree/__init__.py +++ b/sktree/__init__.py @@ -3,7 +3,7 @@ import os import sys -__version__ = "0.2.0dev0" +__version__ = "0.2.0" logger = logging.getLogger(__name__)