From 0a1896401c137f5d2fb3105de94705fd5fb0f7e5 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 16 Aug 2023 10:23:14 -0400 Subject: [PATCH 01/13] Try to bring up cmi stuff Signed-off-by: Adam Li --- sktree/experimental/__init__.py | 3 +- sktree/experimental/forest.py | 271 +++++++++ sktree/experimental/ksg.py | 532 ++++++++++++++++++ sktree/experimental/meson.build | 3 + sktree/experimental/monte_carlo.py | 238 ++++++++ sktree/experimental/mutual_info.py | 377 ++----------- sktree/experimental/simulate.py | 224 ++++++++ sktree/experimental/tests/meson.build | 2 + sktree/experimental/tests/test_ksg.py | 51 ++ sktree/experimental/tests/test_monte_carlo.py | 51 ++ sktree/meson.build | 1 + sktree/neighbors.py | 135 ++++- sktree/utils.py | 27 + 13 files changed, 1550 insertions(+), 365 deletions(-) create mode 100644 sktree/experimental/forest.py create mode 100644 sktree/experimental/ksg.py create mode 100644 sktree/experimental/monte_carlo.py create mode 100644 sktree/experimental/tests/test_ksg.py create mode 100644 sktree/experimental/tests/test_monte_carlo.py create mode 100644 sktree/utils.py diff --git a/sktree/experimental/__init__.py b/sktree/experimental/__init__.py index bf88ce488..317305dac 100644 --- a/sktree/experimental/__init__.py +++ b/sktree/experimental/__init__.py @@ -1,4 +1,6 @@ from . import mutual_info, simulate +from .forest import SupervisedInfoForest +from .ksg import entropy_continuous, mutual_info_ksg from .mutual_info import ( cmi_from_entropy, cmi_gaussian, @@ -7,5 +9,4 @@ mi_from_entropy, mi_gamma, mi_gaussian, - mutual_info_ksg, ) diff --git a/sktree/experimental/forest.py b/sktree/experimental/forest.py new file mode 100644 index 000000000..3decab37e --- /dev/null +++ b/sktree/experimental/forest.py @@ -0,0 +1,271 @@ +from copy import deepcopy + +import numpy as np +from numpy.typing import ArrayLike +from scipy.stats import entropy +from sklearn.base import BaseEstimator, MetaEstimatorMixin +from sklearn.ensemble._forest import BaseForest + +from sktree.utils import check_is_forest + +from .ksg import entropy_continuous + + +class SupervisedInfoForest(BaseEstimator, MetaEstimatorMixin): + def __init__(self, estimator, y_categorical: bool = False, n_jobs=None, random_state=None): + """Meta estimator for mutual information. + + This supervised forest estimator uses two supervised forests to estimate + the (conditional) mutual information between X and Y given Z. + + Parameters + ---------- + estimator : _type_ + _description_ + y_categorical : bool, optional + _description_, by default False + n_jobs : _type_, optional + _description_, by default None + random_state : _type_, optional + _description_, by default None + """ + self.estimator = estimator + self.y_categorical = y_categorical + self.n_jobs = n_jobs + self.random_state = random_state + + def fit(self, X, y, Z=None): + X, y = self._validate_data(X, y, accept_sparse="csc") + check_is_forest(self.estimator, allow_tree=False, ensure_fitted=False) + + self.estimator_yxz_ = deepcopy(self.estimator) + self.estimator_yz_ = deepcopy(self.estimator) + # self.estimator_yxz_ = CalibratedClassifierCV( + # copy(self.estimator), method='isotonic', cv=5, + # ) + # self.estimator_yz_ = CalibratedClassifierCV( + # copy(self.estimator), method='isotonic', cv=5, + # ) + + if Z is not None: + XZ = np.hstack((X, Z)) + else: + XZ = X + + # compute the entropy of H(Y | X, Z) + self.estimator_yxz_.fit(XZ, y) + + # compute the entropy of H(Y | Z) + if Z is None: + # compute entropy using empirical distribution + if self.y_categorical: + _, self.counts_ = np.unique(y, return_counts=True) + else: + self.H_yz_ = entropy_continuous(y, k=5, n_jobs=self.n_jobs) + else: + self.estimator_yz_.fit(Z, y) + + return self + + def predict_cmi(self, X, y, Z=None): + if Z is not None: + X, y = self._validate_data(X, y, accept_sparse="csc") + Z = self._validate_data(Z, accept_sparse="csc") + else: + X = self._validate_data(X, accept_sparse="csc") + + if Z is not None: + XZ = np.hstack((X, Z)) + else: + XZ = X + + # if not fitted yet + if not hasattr(self, "estimator_yz_"): + self.fit(X, y, Z) + + sample_indices = np.arange(0, X.shape[0]) + + # compute the entropy of H(Y | X, Z) + H_yxz = cond_entropy( + self.estimator_yxz_, XZ, y, sample_indices, kappa=3, seed=self.random_state + ) + + # compute the entropy of H(Y | Z) + if Z is None: + if self.y_categorical: + # compute entropy using empirical distribution + H_yz = entropy(self.counts_, base=np.exp(1)) + else: + H_yz = self.H_yz_ + else: + H_yz = cond_entropy( + self.estimator_yz_, Z, y, sample_indices, kappa=3, seed=self.random_state + ) + + return H_yxz - H_yz + + +def approx_marginal(est: BaseForest, X: ArrayLike, weighted: bool = False): + """Compute the approximate marginal distribution. + + A fitted tree/forest can be used to compute the approximate marginal + by counting the number of training (weighted) training samples + that fall into each leaf node for samples in X. + + Parameters + ---------- + est : Forest + Fitted forest or tree estimator. + X : ArrayLike of shape (n_samples, n_features_in_) + Samples to compute the approximate marginal distribution for. + weighted : bool, default=False + Whether to use the weighted number of samples in each leaf node. + """ + check_is_forest(est) + n_samples = X.shape[0] + p_leaves = np.zeros(n_samples, est.n_estimators) + + # leaf indices (n_samples, n_estimators) + X_leaves = est.apply(X) + + for idx, tree_ in enumerate(est.estimators_.tree_): + # compute the empirical distribution of the leaf nodes + # (n_nodes,) array + if weighted: + n_node_samples = tree_.weighted_n_node_samples + else: + n_node_samples = tree_.n_node_samples + + # compute the total number of samples used in this tree + total_samples_in_tree = n_node_samples.sum() + + # compute the empirical distribution of the leaf nodes for each sample in X + tree_leaves = X_leaves[:, idx] + p_leaves[:, idx] = n_node_samples[tree_leaves] / total_samples_in_tree + + # return the average over all trees + return p_leaves.mean(axis=1) + + +def cond_entropy( + est: BaseForest, X: ArrayLike, y: ArrayLike, estimators_samples_: ArrayLike, kappa=3, seed=None +): + rng = np.random.default_rng(seed) + + check_is_forest(est) + # if "multioutput" in est._get_tags(): + # raise ValueError("Multioutput is not supported.") + + # get leaves of each tree for each sample (n_samples, n_estimators) + X_leaves = est.apply(X) + n_classes = est.n_classes_ + n_samples = X.shape[0] + + cond_entropy = 0.0 + for tree_idx, tree in enumerate(est.estimators_): + # (n_nodes,) array of number of samples + node_counts = tree.tree_.n_node_samples + n_nodes = len(node_counts) + + # (n_nodes, n_classes_) + class_counts = np.zeros((n_nodes, n_classes)) + + # Find the indices of the training set used for partition. + sampled_indices = estimators_samples_[tree_idx] + unsampled_indices = np.delete(np.arange(0, n_samples), sampled_indices) + + # Randomly split the rest into voting and evaluation. + total_unsampled = len(unsampled_indices) + rng.shuffle(unsampled_indices) + vote_indices = unsampled_indices[: total_unsampled // 2] + eval_indices = unsampled_indices[total_unsampled // 2 :] + + # true classes of evaluation points + true_classes = y[vote_indices] + + # estimated nodes + tree_vote_leaves = X_leaves[vote_indices, tree_idx] + n_vote_samples = len(tree_vote_leaves) + for i in range(n_vote_samples): + class_counts[tree_vote_leaves[i], true_classes[i]] += 1 + + # compute total number of samples in each leaf node + # then compute probabilies per class for each node + # (n_nodes, n_classes_) + n_node_leaves = class_counts.sum(axis=1) + class_probs = _finite_sample_correction(class_counts, n_node_leaves, n_classes, kappa=kappa) + + # Place evaluation points in their corresponding leaf node. + # Store evaluation posterior in a num_eval-by-num_class matrix. + tree_eval_leaves = tree.apply(X[eval_indices, :]) + eval_class_probs = class_probs[tree_eval_leaves, :] + + # compute the entropy per sample + eval_entropies = [entropy(posterior) for posterior in eval_class_probs] + cond_entropy += np.mean(eval_entropies) + return cond_entropy / est.n_estimators + + +def _finite_sample_correction(class_counts, n_samples_per_node, n_classes, kappa=3): + """Perform finite sample correction on class probabilities. + + This applies the following procedure: + + - if a leaf (i.e. node) is pure for a certain class, meaning there is 0 samples + for that class in the node, then the probability of that class is replaced + with ``1 / (kappa * n_classes)``, where `kappa` is a hyperparameter and + + + Parameters + ---------- + class_counts : array-like of shape (n_nodes, n_classes) + Class counts in each node. + n_samples_per_node : array-like of shape (n_nodes,) + Total number of samples in each node. + n_classes : int + Number of classes. + kappa : float, default=3 + Corrective factor hyperparameter. + """ + # Avoid divide by zero. + n_samples_per_node[n_samples_per_node == 0] = 1 + + class_probs = np.divide(class_counts, n_samples_per_node[:, np.newaxis]) + + # Make the nodes that have no estimation indices uniform. + # This includes non-leaf nodes, but that will not affect the estimate. + class_probs[np.argwhere(class_probs.sum(axis=1) == 0)] = 1.0 / n_classes + + # Apply finite sample correction and renormalize. + where_0 = np.argwhere(class_probs == 0) + for row, col in where_0: + class_probs[row, col] = 1.0 / (kappa * class_counts[row].sum()) + row_sums = class_probs.sum(axis=1) + class_probs = class_probs / row_sums[:, None] + + return class_probs + + +def approx_joint(est: BaseForest, X: ArrayLike, P_Y: ArrayLike): + """Compute the approximate joint distribution. + + A fitted tree/forest can be used to compute the approximate joint + by counting the number of training (weighted) training samples + that fall into each leaf node for samples in X. Then the conditional + distribution is computed as the number of Y samples in each for a + fitted tree or forest for P(Y | X). + + Parameters + ---------- + est : Forest + The fitted supervised forest. + X : ArrayLike of shape (n_samples, n_features_in_) + Input data. + P_Y : ArrayLike of shape (n_samples,) + The approximate marginal distribution of X. + """ + check_is_forest(est) + if est._get_tags().get("multioutput", False): + raise ValueError("Multioutput is not supported.") + + est.apply(X) diff --git a/sktree/experimental/ksg.py b/sktree/experimental/ksg.py new file mode 100644 index 000000000..435320672 --- /dev/null +++ b/sktree/experimental/ksg.py @@ -0,0 +1,532 @@ +from typing import Optional + +import numpy as np +import scipy.linalg +import scipy.special +import scipy.stats +from numpy.typing import ArrayLike +from sklearn.base import BaseEstimator +from sklearn.neighbors import NearestNeighbors +from sklearn.preprocessing import StandardScaler + + +def entropy_continuous(X, k=1, norm="max", min_dist=0.0, n_jobs=-1): + """Estimates the entropy H of a continuous random variable. + + The approach uses the kth-nearest neighbour distances between sample points + from :footcite:`kozachenko1987sample`. See: + https://github.com/paulbrodersen/entropy_estimators/blob/master/ + + Parameters + ---------- + X : ArrayLike of shape (n_samples, n_features) + N samples from a d-dimensional multivariate distribution + + k : int (default 1) + kth nearest neighbour to use in density estimate; + imposes smoothness on the underlying probability distribution + + norm : 'euclidean' or 'max' + p-norm used when computing k-nearest neighbour distances + + min_dist : float (default 0.) + minimum distance between data points; + smaller distances will be capped using this value + + n_jobs : int (default 1) + number of workers to use for parallel processing in query; + -1 uses all CPU threads + + Returns + ------- + h: float + entropy H(X) + + References + ---------- + .. footbibliography:: + """ + if X.ndim == 1: + X = X[:, np.newaxis] + n, d = X.shape + + if norm == "max": # max norm: + p = np.inf + log_c_d = 0 # volume of the d-dimensional unit ball + elif norm == "euclidean": # euclidean norm + p = 2 + log_c_d = (d / 2.0) * np.log(np.pi) - np.log(scipy.special.gamma(d / 2.0 + 1)) + else: + raise NotImplementedError("Variable 'norm' either 'max' or 'euclidean'") + + kdtree = scipy.spatial.KDTree(X) + + # query all points -- k+1 as query point also in initial set + # distances, _ = kdtree.query(x, k + 1, eps=0, p=norm) + distances, _ = kdtree.query(X, k + 1, eps=0, p=p, workers=n_jobs) + distances = distances[:, -1] + + # enforce non-zero distances + distances[distances < min_dist] = min_dist + + sum_log_dist = np.sum(np.log(2.0 * distances)) # where did the 2 come from? radius -> diameter + h = ( + -scipy.special.digamma(k) + + scipy.special.digamma(n) + + log_c_d + + (d / float(n)) * sum_log_dist + ) + + return h + + +def mutual_info_ksg_nn( + X, + Y, + Z=None, + k: float = 0.2, + norm="max", + n_jobs: int = -1, + transform: str = "rank", + random_seed: int = None, + verbose: bool = False, +): + rng = np.random.default_rng(random_seed) + + data = np.hstack((X, Y)) + x_idx = np.arange(X.shape[1]) + y_idx = np.arange(Y.shape[1]) + X.shape[1] + z_idx = np.array([]) + if Z is not None: + z_idx = np.arange(Z.shape[1]) + data.shape[1] + data = np.hstack((data, Z)) + + data = _preprocess_data(data, transform, rng) + if verbose: + print(f"Data shape: {data.shape}") + print(f"X shape: {X.shape}, Y shape: {Y.shape}") + if Z is not None: + print(f"Z shape: {Z.shape}") + print("Preprocessing complete.") + n_samples = data.shape[0] + + # get the number of neighbors to use in estimating the CMI + if k < 1: + knn_here = max(1, int(k * n_samples)) + else: + knn_here = max(1, int(k)) + + if verbose: + print(f"Using {knn_here} neighbors to define D-dimensional volume.") + + if Z is not None: + val = _cmi_ksg_scipy(data, x_idx, y_idx, z_idx, knn_here, n_jobs=n_jobs) + else: + val = _mi_ksg_scipy(data, x_idx, y_idx, knn_here, n_jobs=n_jobs) + + if norm == "max": + norm_constant = np.log(1) + else: + norm_constant = np.log( + np.pi ** (data.shape[1] / 2) + / scipy.special.gamma(data.shape[1] / 2 + 1) + / 2 ** data.shape[1] + ) + + return val + norm_constant + + +def mutual_info_ksg( + X, + Y, + Z=None, + k: float = 0.2, + norm="max", + nn_estimator=None, + n_jobs: int = -1, + transform: str = "rank", + random_seed: int = None, + verbose: bool = False, +): + """Compute the generalized (conditional) mutual information KSG estimate. + + Parameters + ---------- + X : ArrayLike of shape (n_samples, n_features_x) + The X covariate space. + Y : ArrayLike of shape (n_samples, n_features_y) + The Y covariate space. + Z : ArrayLike of shape (n_samples, n_features_z), optional + The Z covariate space, by default None. If None, then the MI is computed. + If Z is defined, then the CMI is computed. + k : float, optional + The number of neighbors to use in defining the radius, by default 0.2. + If a number less than 1, then the number of neighbors is computed as + ``k * n_samples``. + norm : str, optional, {'max', 'euclidean'} + The norm to use in computing the distance, by default 'max'. This is the norm + used for computing the distance between points in the covariate space and + affects the constant term in the KSG estimator. For 'max' norm, the constant + term is :math:`\\log(1) = 0`, and for 'euclidean' norm, the constant term is + :math:`\\pi^{d/2} / \\Gamma(d/2 + 1) / 2^d)`, where :math:`d` is the dimension. + nn_estimator : str, optional + The nearest neighbor estimator to use, by default None. If None will default + to using :class:`sklearn.neighbors.NearestNeighbors` with default parameters. + n_jobs : int, optional + Number of parallel jobs, by default -1. + transform : one of {'rank', 'standardize', 'uniform'} + Preprocessing, by default "rank". + random_seed : int, optional + Random seed, by default None. + verbose : bool, optional + Whether to print verbose output, by default False. + + Returns + ------- + val : float + The estimated MI, or CMI value. + + Notes + ----- + Given a dataset with ``n`` samples, the KSG estimator proceeds by: + + 1. For fixed k, get the distance to the kth nearest-nbr in XYZ subspace, call it 'r' + 2. Get the number of NN in XZ subspace within radius 'r' + 3. Get the number of NN in YZ subspace within radius 'r' + 4. Get the number of NN in Z subspace within radius 'r' + 5. Apply analytic solution for KSG estimate + + For MI, the analytical solution is: + + .. math:: + + \\psi(k) - E[(\\psi(n_x) + \\psi(n_y))] + \\psi(n) + + For CMI, the analytical solution is: + + .. math:: + + \\psi(k) - E[(\\psi(n_{xz}) + \\psi(n_{yz}) - \\psi(n_{z}))] + + where :math:`\\psi` is the DiGamma function, and each expectation term + is estimated by taking the sample average. + + Note that the :math:`n_i` terms denote the number of neighbors within + radius 'r' in the subspace of 'i', where 'i' could be for example the + X, Y, XZ, etc. subspaces. This term does not include the sample itself. + + The hyperparamter ``k`` defines the number of points in the D-dimensional + ball with a specified radius. The larger the k, the higher the bias in + the estimate, but the lower the variance. The smaller the k, the lower + the bias, but the higher the variance. The default value of 0.2 is set + to allow scaling with the number of samples. + """ + rng = np.random.default_rng(random_seed) + + if nn_estimator is None: + nn_estimator = NearestNeighbors(n_jobs=n_jobs) + + data = np.hstack((X, Y)) + x_idx = np.arange(X.shape[1]) + y_idx = np.arange(Y.shape[1]) + X.shape[1] + z_idx = np.array([]) + if Z is not None: + z_idx = np.arange(Z.shape[1]) + data.shape[1] + data = np.hstack((data, Z)) + + data = _preprocess_data(data, transform, rng) + if verbose: + print(f"Data shape: {data.shape}") + print(f"X shape: {X.shape}, Y shape: {Y.shape}") + if Z is not None: + print(f"Z shape: {Z.shape}") + print("Preprocessing complete.") + n_samples = data.shape[0] + + # get the number of neighbors to use in estimating the CMI + if k < 1: + knn_here = max(1, int(k * n_samples)) + else: + knn_here = max(1, int(k)) + + if verbose: + print(f"Using {knn_here} neighbors to define D-dimensional volume.") + + if Z is not None: + val = _cmi_ksg(data, x_idx, y_idx, z_idx, nn_estimator, knn_here) + else: + val = _mi_ksg(data, x_idx, y_idx, nn_estimator, knn_here) + + if norm == "max": + norm_constant = np.log(1) + else: + norm_constant = np.log( + np.pi ** (data.shape[1] / 2) + / scipy.special.gamma(data.shape[1] / 2 + 1) + / 2 ** data.shape[1] + ) + + return val + norm_constant + + +def _preprocess_data(data, transform, rng): + n_samples, n_features = data.shape + + # add minor noise to make sure there are no ties + random_noise = rng.random((n_samples, n_features)) + data += 1e-5 * random_noise @ np.std(data, axis=0).reshape(n_features, 1) + + if transform == "standardize": + # standardize with standard scaling + data = data.astype(np.float64) + scaler = StandardScaler() + data = scaler.fit_transform(data) + elif transform == "uniform": + data = _trafo2uniform(data) + elif transform == "rank": + # rank transform each column + data = scipy.stats.rankdata(data, axis=0) + return data + + +def _cmi_ksg_scipy(data, x_idx, y_idx, z_idx, knn_here: int, n_jobs: int = -1) -> float: + tree_xyz = scipy.spatial.KDTree(data) + radius_per_sample = tree_xyz.query(data, k=[knn_here + 1], p=np.inf, eps=0.0, workers=n_jobs)[ + 0 + ][:, 0].astype(np.float64) + + # To search neighbors < eps + radius_per_sample = np.multiply(radius_per_sample, 0.99999) + + # compute on the subspace of X, Z + xz_idx = np.concatenate((x_idx, z_idx)).squeeze() + tree_xz = scipy.spatial.KDTree(data[:, xz_idx]) + num_nn_xz = tree_xz.query_ball_point( + data[:, xz_idx], r=radius_per_sample, eps=0.0, p=np.inf, workers=n_jobs, return_length=True + ) + + # compute on the subspace of Y, Z + yz_idx = np.concatenate((y_idx, z_idx)).squeeze() + tree_yz = scipy.spatial.KDTree(data[:, yz_idx]) + num_nn_yz = tree_yz.query_ball_point( + data[:, yz_idx], r=radius_per_sample, eps=0.0, p=np.inf, workers=n_jobs, return_length=True + ) + + tree_z = scipy.spatial.KDTree(data[:, z_idx]) + num_nn_z = tree_z.query_ball_point( + data[:, z_idx], r=radius_per_sample, eps=0.0, p=np.inf, workers=n_jobs, return_length=True + ) + + # compute the final CMI value + hxyz = scipy.special.digamma(knn_here) + hxz = scipy.special.digamma(num_nn_xz) + hyz = scipy.special.digamma(num_nn_yz) + hz = scipy.special.digamma(num_nn_z) + val = hxyz - (hxz + hyz - hz).mean() + return val + + +def _mi_ksg_scipy(data, x_idx, y_idx, knn_here: int, n_jobs: int = -1) -> float: + n_samples = data.shape[0] + + tree_xyz = scipy.spatial.KDTree(data) + radius_per_sample = tree_xyz.query(data, k=[knn_here + 1], p=np.inf, eps=0.0, workers=n_jobs)[ + 0 + ][:, 0].astype(np.float64) + + # To search neighbors < eps + radius_per_sample = np.multiply(radius_per_sample, 0.99999) + + # compute on the subspace of X + tree_x = scipy.spatial.KDTree(data[:, x_idx]) + num_nn_x = tree_x.query_ball_point( + data[:, x_idx], r=radius_per_sample, eps=0.0, p=np.inf, workers=n_jobs, return_length=True + ) + + # compute on the subspace of Y + tree_y = scipy.spatial.KDTree(data[:, y_idx]) + num_nn_y = tree_y.query_ball_point( + data[:, x_idx], r=radius_per_sample, eps=0.0, p=np.inf, workers=n_jobs, return_length=True + ) + + # compute the final MI value + # \\psi(k) - E[(\\psi(n_x) + \\psi(n_y))] + \\psi(n) + hxy = scipy.special.digamma(knn_here) + hx = scipy.special.digamma(num_nn_x) + hy = scipy.special.digamma(num_nn_y) + hn = scipy.special.digamma(n_samples) + val = hxy - (hx + hy).mean() + hn + return val + + +def _mi_ksg(data, x_idx, y_idx, nn_estimator: BaseEstimator, knn_here: int) -> float: + """Compute KSG estimate of MI. + + Parameters + ---------- + data : ArrayLike + Stacked data of X and Y. + x_idx : ArrayLike + Indices for the X data stored as a 1D array. + y_idx : ArrayLike + Indices for the Y data stored as a 1D array. + nn_estimator : BaseEstimator + Nearest neighbor estimator. + knn_here : int + Number of nearest neighbors used in nn_estimator to estimate the volume + of the joint distribution. + + Returns + ------- + val : float + Estimated MI value. + """ + n_samples = data.shape[0] + + # estimate distance to the kth NN in XYZ subspace for each sample + neigh = nn_estimator.fit(data) + dists, _ = neigh.kneighbors(n_neighbors=knn_here) + + # - get the radius we want to use per sample as the distance to the kth neighbor + # in the joint distribution space + radius_per_sample = dists[:, -1] + + # compute on the subspace of X + num_nn_x = _compute_radius_nbrs(data, radius_per_sample, nn_estimator, col_idx=x_idx) + + # compute on the subspace of Y + num_nn_y = _compute_radius_nbrs(data, radius_per_sample, nn_estimator, col_idx=y_idx) + + # compute the final MI value + # \\psi(k) - E[(\\psi(n_x) + \\psi(n_y))] + \\psi(n) + hxy = scipy.special.digamma(knn_here) + hx = scipy.special.digamma(num_nn_x) + hy = scipy.special.digamma(num_nn_y) + hn = scipy.special.digamma(n_samples) + val = hxy - (hx + hy).mean() + hn + return val + + +def _cmi_ksg( + data: ArrayLike, x_idx, y_idx, z_idx, nn_estimator: BaseEstimator, knn_here: int +) -> float: + """Compute KSG estimate of CMI. + + Parameters + ---------- + data : ArrayLike + Stacked data of X, Y and Z. + x_idx : ArrayLike + Indices for the X data stored as a 1D array. + y_idx : ArrayLike + Indices for the Y data stored as a 1D array. + z_idx : ArrayLike + Indices for the Z data stored as a 1D array. + nn_estimator : BaseEstimator + Nearest neighbor estimator. + knn_here : int + Number of nearest neighbors used in nn_estimator to estimate the volume + of the joint distribution. + + Returns + ------- + val : float + Estimated CMI value. + """ + # estimate distance to the kth NN in XYZ subspace for each sample + nn_estimator = nn_estimator.fit(data) + dists, _ = nn_estimator.kneighbors(n_neighbors=knn_here) + + # get the radius we want to use per sample as the distance to the kth neighbor + # in the joint distribution space + radius_per_sample = dists[:, -1] + + # compute on the subspace of XZ + xz_idx = np.concatenate((x_idx, z_idx)).squeeze() + num_nn_xz = _compute_radius_nbrs( + data, + radius_per_sample, + nn_estimator, + col_idx=xz_idx, + ) + + # compute on the subspace of YZ + yz_idx = np.concatenate((y_idx, z_idx)).squeeze() + num_nn_yz = _compute_radius_nbrs( + data, + radius_per_sample, + nn_estimator, + col_idx=yz_idx, + ) + + # compute on the subspace of XZ + num_nn_z = _compute_radius_nbrs( + data, + radius_per_sample, + nn_estimator, + col_idx=z_idx, + ) + + # compute the final CMI value + hxyz = scipy.special.digamma(knn_here) + hxz = scipy.special.digamma(num_nn_xz) + hyz = scipy.special.digamma(num_nn_yz) + hz = scipy.special.digamma(num_nn_z) + val = hxyz - (hxz + hyz - hz).mean() + return val + + +def _compute_radius_nbrs( + data: ArrayLike, + radius_per_sample: ArrayLike, + nn_estimator: BaseEstimator, + col_idx: Optional[ArrayLike] = None, +): + # compute distances in the subspace defined by data + nn_estimator.fit(data[:, col_idx]) + + # compute the radius neighbors for each sample + if getattr(nn_estimator, "_supports_multi_radii", False): + nn = nn_estimator.radius_neighbors( + X=data[:, col_idx], radius=radius_per_sample, return_distance=False + ) + else: + nn = [] + for idx, radius in enumerate(radius_per_sample): + nn_ = nn_estimator.radius_neighbors( + X=np.atleast_2d(data[:, col_idx]), radius=radius, return_distance=False + ) + nn.append(nn_[idx]) + + num_nn_data = np.array([len(nn_) for nn_ in nn]) + return num_nn_data + + +def _trafo2uniform(X): + """Transforms input array to uniform marginals. + + Assumes x.shape = (dim, T) + + Parameters + ---------- + X : arraylike + The input data with (n_samples,) rows and (n_features,) columns. + + Returns + ------- + u : array-like + array with uniform marginals. + """ + + def trafo(xi): + xisorted = np.sort(xi) + yi = np.linspace(1.0 / len(xi), 1, len(xi)) + return np.interp(xi, xisorted, yi) + + _, n_features = X.shape + + # apply a uniform transformation for each feature + for idx in range(n_features): + marginalized_feature = trafo(X[:, idx].to_numpy().squeeze()) + X[:, idx] = marginalized_feature + return X diff --git a/sktree/experimental/meson.build b/sktree/experimental/meson.build index e92935a50..a1f0a9029 100644 --- a/sktree/experimental/meson.build +++ b/sktree/experimental/meson.build @@ -2,6 +2,9 @@ python_sources = [ '__init__.py', 'mutual_info.py', 'simulate.py', + 'ksg.py', + 'forest.py', + 'monte_carlo.py', ] py3.install_sources( diff --git a/sktree/experimental/monte_carlo.py b/sktree/experimental/monte_carlo.py new file mode 100644 index 000000000..0c412a782 --- /dev/null +++ b/sktree/experimental/monte_carlo.py @@ -0,0 +1,238 @@ +from typing import Optional + +import numpy as np +from numpy.typing import ArrayLike +from scipy.sparse import issparse +from sklearn.neighbors import NearestNeighbors +from sklearn.utils import _approximate_mode, _safe_indexing, check_array, check_consistent_length + + +def _conditional_shuffle(nbrs: ArrayLike, replace: bool = False, rng=None) -> ArrayLike: + """Compute a permutation of neighbors with restrictions. + + Parameters + ---------- + nbrs : ArrayLike of shape (n_samples, k) + The k-nearest-neighbors for each sample index. Each row corresponds to the + original sample. Each element corresponds to another sample index that is deemed + as the k-nearest neighbors with respect to the original sample. + replace : bool, optional + Whether or not to allow replacement of samples, by default False. + random_seed : int, optional + Random seed, by default None. + + Returns + ------- + restricted_perm : ArrayLike of shape (n_samples) + The final permutation order of the sample indices. There may be + repeating samples. See Notes for details. + + Notes + ----- + Restricted permutation goes through random samples and looks at the k-nearest + neighbors (columns of ``nbrs``) and shuffles the closest neighbor index only + if it has not been used to permute another sample. If it has been, then the + algorithm looks at the next nearest-neighbor and so on. If all k-nearest + neighbors of a sample has been checked, then a random neighbor is chosen. In this + manner, the algorithm tries to perform permutation without replacement, but + if necessary, will choose a repeating neighbor sample. + """ + n_samples, k_dims = nbrs.shape + rng = np.random.default_rng(seed=rng) + + # initialize the final permutation order + restricted_perm = np.zeros((n_samples,), dtype=np.intp) + + # generate a random order of samples to go through + random_order = rng.permutation(n_samples) + + # keep track of values we have already used + used = set() + + # go through the random order + for idx in random_order: + if replace: + restricted_perm[idx] = rng.choice(nbrs[idx, :], size=1) + else: + m = 0 + use_idx = nbrs[idx, m] + + # if the current nbr is already used, continue incrementing + # until we have either found a new sample to use, or if + # we have reach the maximum number of shuffles to consider + while (use_idx in used) and (m < k_dims - 1): + m += 1 + use_idx = nbrs[idx, m] + + # check whether or not we have exhaustively checked all kNN + if use_idx in used and m == k_dims: + # XXX: Note this step is not in the original paper + # choose a random neighbor to permute + restricted_perm[idx] = rng.choice(nbrs[idx, :], size=1) + else: + # permute with the existing neighbor + restricted_perm[idx] = use_idx + used.add(use_idx) + return restricted_perm + + +def conditional_resample( + conditional_array, + *arrays, + nn_estimator=None, + replace=True, + replace_nbrs=True, + n_samples=None, + random_state=None, + stratify=None, +): + """Conditionally resample arrays or sparse matrices in a consistent way. + + The default strategy implements one step of the bootstrapping + procedure. Conditional resampling is a modification of the bootstrap + technique that preserves the conditional distribution of the data. This + is done by fitting a nearest neighbors estimator on the conditional array + and then resampling the nearest neighbors of each sample. + + Parameters + ---------- + conditional_array : array-like of shape (n_samples, n_features) + The array, which we preserve the conditional distribution of. + + *arrays : sequence of array-like of shape (n_samples,) or \ + (n_samples, n_outputs) + Indexable data-structures can be arrays, lists, dataframes or scipy + sparse matrices with consistent first dimension. + + nn_estimator : estimator object, default=None + The nearest neighbors estimator to use. If None, then a + :class:`sklearn.neighbors.NearestNeighbors` instance is used. + + replace : bool, default=True + Implements resampling with replacement. If False, this will implement + (sliced) random permutations. The replacement will take place at the level + of the sample index. + + replace_nbrs : bool, default=True + Implements resampling with replacement at the level of the nearest neighbors. + + n_samples : int, default=None + Number of samples to generate. If left to None this is + automatically set to the first dimension of the arrays. + If replace is False it should not be larger than the length of + arrays. + + random_state : int, RandomState instance or None, default=None + Determines random number generation for shuffling + the data. + Pass an int for reproducible results across multiple function calls. + See :term:`Glossary `. + + stratify : array-like of shape (n_samples,) or (n_samples, n_outputs), \ + default=None + If not None, data is split in a stratified fashion, using this as + the class labels. + + Returns + ------- + resampled_arrays : sequence of array-like of shape (n_samples,) or \ + (n_samples, n_outputs) + Sequence of resampled copies of the collections. The original arrays + are not impacted. + """ + max_n_samples = n_samples + rng = np.random.default_rng(random_state) + + if len(arrays) == 0: + return None + + first = arrays[0] + n_samples = first.shape[0] if hasattr(first, "shape") else len(first) + + if max_n_samples is None: + max_n_samples = n_samples + elif (max_n_samples > n_samples) and (not replace): + raise ValueError( + "Cannot sample %d out of arrays with dim %d when replace is False" + % (max_n_samples, n_samples) + ) + + check_consistent_length(conditional_array, *arrays) + + # fit nearest neighbors onto the conditional array + if nn_estimator is None: + nn_estimator = NearestNeighbors() + nn_estimator.fit(conditional_array) + + if stratify is None: + if replace: + indices = rng.integers(0, n_samples, size=(max_n_samples,)) + else: + indices = np.arange(n_samples) + rng.shuffle(indices) + indices = indices[:max_n_samples] + else: + # Code adapted from StratifiedShuffleSplit() + y = check_array(stratify, ensure_2d=False, dtype=None) + if y.ndim == 2: + # for multi-label y, map each distinct row to a string repr + # using join because str(row) uses an ellipsis if len(row) > 1000 + y = np.array([" ".join(row.astype("str")) for row in y]) + + classes, y_indices = np.unique(y, return_inverse=True) + n_classes = classes.shape[0] + + class_counts = np.bincount(y_indices) + + # Find the sorted list of instances for each class: + # (np.unique above performs a sort, so code is O(n logn) already) + class_indices = np.split( + np.argsort(y_indices, kind="mergesort"), np.cumsum(class_counts)[:-1] + ) + + n_i = _approximate_mode(class_counts, max_n_samples, random_state) + + indices = [] + + for i in range(n_classes): + indices_i = rng.choice(class_indices[i], n_i[i], replace=replace) + indices.extend(indices_i) + + indices = rng.permutation(indices) + + # now get the kNN indices for each sample (n_samples, n_neighbors) + sample_nbrs = nn_estimator.kneighbors(X=conditional_array[indices, :], return_distance=False) + + # actually sample the indices using a conditional permutation + indices = _conditional_shuffle(sample_nbrs, replace=replace_nbrs, rng=rng) + + # convert sparse matrices to CSR for row-based indexing + arrays = [a.tocsr() if issparse(a) else a for a in arrays] + resampled_arrays = [_safe_indexing(a, indices) for a in arrays] + if len(resampled_arrays) == 1: + # syntactic sugar for the unit argument case + return resampled_arrays[0] + else: + return resampled_arrays + + +def conditional_shuffle( + conditional_array, *arrays, random_state: Optional[int] = None, n_samples: Optional[int] = None +): + """_summary_ + + Parameters + ---------- + conditional_array : ArrayLike of shape (n_samples, k) + The array, which we preserve the conditional distribution of. + *arrays : sequence of ArrayLike + Indexable data-structures can be arrays, lists, dataframes or scipy sparse matrices + with consistent first dimension. + random_state : int, optional + Random seed, by default None. + n_samples : int, optional + Number of samples to generate, by default None. If left to None this is + automatically set to the first dimension of the arrays. It should not be larger + than the length of arrays. + """ + pass diff --git a/sktree/experimental/mutual_info.py b/sktree/experimental/mutual_info.py index a1820e715..ac5384329 100644 --- a/sktree/experimental/mutual_info.py +++ b/sktree/experimental/mutual_info.py @@ -1,15 +1,5 @@ -from typing import Optional - import numpy as np -import scipy.linalg import scipy.special -import scipy.stats -from numpy.typing import ArrayLike -from sklearn.neighbors import NearestNeighbors -from sklearn.preprocessing import StandardScaler - -from sktree.ensemble import UnsupervisedObliqueRandomForest -from sktree.tree import compute_forest_similarity_matrix def entropy_gaussian(cov): @@ -24,14 +14,8 @@ def entropy_gaussian(cov): Returns ------- - true_mi : float - The true analytical mutual information of the generated multivariate Gaussian distribution. - - Notes - ----- - The analytical solution for the true mutual information, ``I(X; Y)`` is given by:: - - I(X; Y) = H(X) + H(Y) - H(X, Y) = -\\frac{1}{2} log(det(C)) + true_entropy : float + The true entropy of the generated multivariate Gaussian distribution. References ---------- @@ -43,13 +27,17 @@ def entropy_gaussian(cov): return true_entropy -def mi_gaussian(cov): +def mi_gaussian(cov, x_index, y_index): """Compute mutual information of a multivariate Gaussian. Parameters ---------- cov : array-like of shape (d,d) The covariance matrix of the distribution. + x_index : list or int + List of indices in ``cov`` that are for the X variable. + y_index : list or int + List of indices in ``cov`` that are for the Y variable. Returns ------- @@ -62,12 +50,20 @@ def mi_gaussian(cov): H(X) = \\frac{d}{2} (1 + log(2\\pi)) + \\frac{1}{2} log(det(C)) """ + x_index = np.atleast_1d(x_index) + y_index = np.atleast_1d(y_index) + # computes the true MI - true_mi = -0.5 * np.log(np.linalg.det(cov)) + det_x = np.linalg.det(cov[np.ix_(x_index, x_index)]) + det_y = np.linalg.det(cov[np.ix_(y_index, y_index)]) + det_xy = np.linalg.det( + cov[np.ix_(np.concatenate((x_index, y_index)), np.concatenate((x_index, y_index)))] + ) + true_mi = 0.5 * np.log((det_x * det_y) / det_xy) return true_mi -def cmi_gaussian(cov, x_index, y_index, z_index): +def cmi_gaussian(cov, x_index, y_index, z_index=None): """Compute the analytical CMI for a multivariate Gaussian distribution. Parameters @@ -95,22 +91,28 @@ def cmi_gaussian(cov, x_index, y_index, z_index): where we plug in the analytical solutions for entropy as shown in :func:`entropy_gaussian`. """ - x_index = np.atleast_1d(x_index) - y_index = np.atleast_1d(y_index) - z_index = np.atleast_1d(z_index) - - xz_index = np.concatenate((x_index, z_index)).squeeze() - yz_index = np.concatenate((y_index, z_index)).squeeze() - - cov_xz = cov[xz_index, xz_index] - cov_yz = cov[yz_index, yz_index] - cov_z = cov[z_index, z_index] - + x_index = np.atleast_1d(x_index).astype(int) + y_index = np.atleast_1d(y_index).astype(int) + if z_index is None: + z_index = [] + z_index = np.atleast_1d(z_index).astype(int) + + xz_index = np.concatenate((x_index, z_index)) + yz_index = np.concatenate((y_index, z_index)) + + cov_xz = cov[np.ix_(xz_index, xz_index)] + cov_yz = cov[np.ix_(yz_index, yz_index)] + cov_z = cov[np.ix_(z_index, z_index)] + cov_xyz = cov[ + np.ix_( + np.concatenate((x_index, y_index, z_index)), np.concatenate((x_index, y_index, z_index)) + ) + ] cmi = ( entropy_gaussian(cov_xz) + entropy_gaussian(cov_yz) - entropy_gaussian(cov_z) - - entropy_gaussian(cov) + - entropy_gaussian(cov_xyz) ) return cmi @@ -136,312 +138,3 @@ def mi_from_entropy(hx, hy, hxy): def cmi_from_entropy(hxz, hyz, hz, hxyz): """Analytic formula for CMI given plug-in estimates of entropies.""" return hxz + hyz - hz - hxyz - - -def mutual_info_ksg( - X, - Y, - Z=None, - k: float = 0.2, - metric="forest", - algorithm="kd_tree", - n_jobs: int = -1, - transform: str = "rank", - random_seed: int = None, -): - """Compute the generalized (conditional) mutual information KSG estimate. - - Parameters - ---------- - X : ArrayLike of shape (n_samples, n_features_x) - The X covariate space. - Y : ArrayLike of shape (n_samples, n_features_y) - The Y covariate space. - Z : ArrayLike of shape (n_samples, n_features_z), optional - The Z covariate space, by default None. If None, then the MI is computed. - If Z is defined, then the CMI is computed. - k : float, optional - The number of neighbors to use in defining the radius, by default 0.2. - metric : str - Any distance metric accepted by :class:`sklearn.neighbors.NearestNeighbors`. - If 'forest' (default), then uses an - :class:`sktree.UnsupervisedObliqueRandomForest` to compute geodesic distances. - algorithm : str, optional - Method to use, by default 'knn'. Can be ('ball_tree', 'kd_tree', 'brute'). - n_jobs : int, optional - Number of parallel jobs, by default -1. - transform : one of {'rank', 'standardize', 'uniform'} - Preprocessing, by default "rank". - random_seed : int, optional - Random seed, by default None. - - Returns - ------- - val : float - The estimated MI, or CMI value. - - Notes - ----- - Given a dataset with ``n`` samples, the KSG estimator proceeds by: - - 1. For fixed k, get the distance to the kth nearest-nbr in XYZ subspace, call it 'r' - 2. Get the number of NN in XZ subspace within radius 'r' - 3. Get the number of NN in YZ subspace within radius 'r' - 4. Get the number of NN in Z subspace within radius 'r' - 5. Apply analytic solution for KSG estimate - - For MI, the analytical solution is: - - .. math:: - - \\psi(k) - E[(\\psi(n_x) + \\psi(n_y))] + \\psi(n) - - For CMI, the analytical solution is: - - .. math:: - - \\psi(k) - E[(\\psi(n_{xz}) + \\psi(n_{yz}) - \\psi(n_{z}))] - - where :math:`\\psi` is the DiGamma function, and each expectation term - is estimated by taking the sample average. - - Note that the :math:`n_i` terms denote the number of neighbors within - radius 'r' in the subspace of 'i', where 'i' could be for example the - X, Y, XZ, etc. subspaces. This term does not include the sample itself. - """ - rng = np.random.default_rng(random_seed) - - data = np.hstack((X, Y)) - if Z is not None: - data = np.hstack((data, Z)) - - data = _preprocess_data(data, transform, rng) - n_samples = data.shape[0] - - if k < 1: - knn_here = max(1, int(k * n_samples)) - else: - knn_here = max(1, int(k)) - - if Z is not None: - val = _cmi_ksg(data, X, Y, Z, metric, algorithm, knn_here, n_jobs) - else: - val = _mi_ksg(data, X, Y, metric, algorithm, knn_here, n_jobs) - return val - - -def _preprocess_data(data, transform, rng): - n_samples, n_features = data.shape - - # add minor noise to make sure there are no ties - random_noise = rng.random((n_samples, n_features)) - data += 1e-5 * random_noise @ np.std(data, axis=0).reshape(n_features, 1) - - if transform == "standardize": - # standardize with standard scaling - data = data.astype(np.float64) - scaler = StandardScaler() - data = scaler.fit_transform(data) - elif transform == "uniform": - data = _trafo2uniform(data) - elif transform == "rank": - # rank transform each column - data = scipy.stats.rankdata(data, axis=0) - return data - - -def _mi_ksg(data, X, Y, metric, algorithm, knn_here, n_jobs): - """Compute KSG estimate of MI.""" - n_samples = X.shape[0] - - # estimate distance to the kth NN in XYZ subspace for each sample - # - get the radius we want to use per sample as the distance to the kth neighbor - # in the joint distribution space - neigh = _compute_nn(data, algorithm=algorithm, metric=metric, k=knn_here, n_jobs=n_jobs) - dists, _ = neigh.kneighbors() - radius_per_sample = dists[:, -1] - - # compute on the subspace of X - num_nn_x = _compute_radius_nbrs( - X, - radius_per_sample, - knn_here, - algorithm=algorithm, - metric=metric, - n_jobs=n_jobs, - ) - - # compute on the subspace of Y - num_nn_y = _compute_radius_nbrs( - Y, - radius_per_sample, - knn_here, - algorithm=algorithm, - metric=metric, - n_jobs=n_jobs, - ) - - # compute the final MI value - # \\psi(k) - E[(\\psi(n_x) + \\psi(n_y))] + \\psi(n) - hxy = scipy.special.digamma(knn_here) - hx = scipy.special.digamma(num_nn_x) - hy = scipy.special.digamma(num_nn_y) - hn = scipy.special.digamma(n_samples) - val = hxy - (hx + hy).mean() + hn - return val - - -def _cmi_ksg(data, X, Y, Z, metric, algorithm, knn_here, n_jobs): - """Compute KSG estimate of CMI.""" - # estimate distance to the kth NN in XYZ subspace for each sample - neigh = _compute_nn(data, algorithm=algorithm, metric=metric, k=knn_here, n_jobs=n_jobs) - - # get the radius we want to use per sample as the distance to the kth neighbor - # in the joint distribution space - dists, _ = neigh.kneighbors() - radius_per_sample = dists[:, -1] - - # compute on the subspace of XZ - xz_data = np.hstack((X, Z)) - num_nn_xz = _compute_radius_nbrs( - xz_data, - radius_per_sample, - knn_here, - algorithm=algorithm, - metric=metric, - n_jobs=n_jobs, - ) - - # compute on the subspace of YZ - yz_data = np.hstack((Y, Z)) - num_nn_yz = _compute_radius_nbrs( - yz_data, - radius_per_sample, - knn_here, - algorithm=algorithm, - metric=metric, - n_jobs=n_jobs, - ) - - # compute on the subspace of XZ - num_nn_z = _compute_radius_nbrs( - Z, - radius_per_sample, - knn_here, - algorithm=algorithm, - metric=metric, - n_jobs=n_jobs, - ) - - # compute the final CMI value - hxyz = scipy.special.digamma(knn_here) - hxz = scipy.special.digamma(num_nn_xz) - hyz = scipy.special.digamma(num_nn_yz) - hz = scipy.special.digamma(num_nn_z) - val = hxyz - (hxz + hyz - hz).mean() - return val - - -def _compute_radius_nbrs( - data, - radius_per_sample, - k, - algorithm: str = "kd_tree", - metric="l2", - n_jobs: Optional[int] = None, -): - neigh = _compute_nn(data, algorithm=algorithm, metric=metric, k=k, n_jobs=n_jobs) - - n_samples = radius_per_sample.shape[0] - - num_nn_data = np.zeros((n_samples,)) - for idx in range(n_samples): - nn = neigh.radius_neighbors(radius=radius_per_sample[idx], return_distance=False) - num_nn_data[idx] = len(nn) - return num_nn_data - - -def _compute_nn( - X: ArrayLike, algorithm: str = "kd_tree", metric="l2", k: int = 1, n_jobs: Optional[int] = None -) -> NearestNeighbors: - """Compute kNN in subspace. - - Parameters - ---------- - X : ArrayLike of shape (n_samples, n_features) - The covariate space. - algorithm : str, optional - Method to use, by default 'knn'. Can be ('ball_tree', 'kd_tree', 'brute'). - metric : str - Any distance metric accepted by :class:`sklearn.neighbors.NearestNeighbors`. - If 'forest', then uses an :class:`sktree.UnsupervisedObliqueRandomForest` - to compute geodesic distances. - k : int, optional - The number of k-nearest neighbors to query, by default 1. - n_jobs : int, - The number of CPUs to use for joblib. By default, None. - - Returns - ------- - neigh : instance of sklearn.neighbors.NearestNeighbor - A fitted instance of the nearest-neighbor algorithm on ``X`` input. - - Notes - ----- - Can query for the following, using the ``neigh.kneighbors(X)`` function, which would - return: - - dists : ArrayLike of shape (n_samples, k) - The distance array of every sample with its k-nearest neighbors. The columns - are ordered from closest to furthest neighbors. - indices : ArrayLike of shape (n_samples, k) - The sample indices of the k-nearest-neighbors for each sample. These - contain the row indices of ``X`` for each sample. The columns - are ordered from closest to furthest neighbors. - """ - if metric == "forest": - est = UnsupervisedObliqueRandomForest() - dists = compute_forest_similarity_matrix(est, X) - - # we have a precomputed distance matrix, so we can use the NearestNeighbor - # implementation of sklearn - metric = "precomputed" - else: - dists = X - - # compute the nearest neighbors in the space using specified NN algorithm - # then get the K nearest nbrs and their distances - neigh = NearestNeighbors(n_neighbors=k, algorithm=algorithm, metric=metric, n_jobs=n_jobs).fit( - dists - ) - return neigh - - -def _trafo2uniform(X): - """Transforms input array to uniform marginals. - - Assumes x.shape = (dim, T) - - Parameters - ---------- - X : arraylike - The input data with (n_samples,) rows and (n_features,) columns. - - Returns - ------- - u : array-like - array with uniform marginals. - """ - - def trafo(xi): - xisorted = np.sort(xi) - yi = np.linspace(1.0 / len(xi), 1, len(xi)) - return np.interp(xi, xisorted, yi) - - _, n_features = X.shape - - # apply a uniform transformation for each feature - for idx in range(n_features): - marginalized_feature = trafo(X[:, idx].to_numpy().squeeze()) - X[:, idx] = marginalized_feature - return X diff --git a/sktree/experimental/simulate.py b/sktree/experimental/simulate.py index 17b56145f..dbe9fd7a3 100644 --- a/sktree/experimental/simulate.py +++ b/sktree/experimental/simulate.py @@ -2,6 +2,8 @@ import scipy.linalg import scipy.special import scipy.stats +from scipy.integrate import nquad +from scipy.stats import multivariate_normal def simulate_helix( @@ -221,3 +223,225 @@ def simulate_multivariate_gaussian(mean=None, cov=None, d=2, n_samples=1000, see data = rng.multivariate_normal(mean=mean, cov=cov, size=(n_samples)) return data, mean, cov + + +def embed_high_dims(data, n_dims=50, random_state=None): + rng = np.random.default_rng(random_state) + + new_data = np.zeros((data.shape[0], n_dims + data.shape[1])) + new_data[:, : data.shape[1]] = data + + for idim in range(n_dims): + new_col = rng.standard_normal(size=(data.shape[0],)) + new_data[:, data.shape[1] + idim] = new_col + + return new_data + + +def simulate_separate_gaussians(n_dims=2, n_samples=1000, n_classes=2, pi=None, seed=None): + """Simulate data from separate multivariate Gaussians. + + Parameters + ---------- + n_dims : int + The dimensionality of the data. The default is 2. + n_samples : int + The number of samples to generate. The default is 1000. + n_classes : int + The number of classes to generate. The default is 2. + pi : array-like of shape (n_classes,) + The class probabilities. If None (default), then uniform class probabilities are used. + seed : int + The random seed to feed to :func:`numpy.random.default_rng`. The default is None. + + Returns + ------- + data : array-like of shape (n_samples, n_dims) + The generated data. + y : array-like of shape (n_samples,) + The class labels. + means : list of array-like of shape (n_dims,) + The means of the Gaussians from each class. + sigmas : list of array-like of shape (n_dims, n_dims) + The covariance matrices of the Gaussians from each class. + pi : array-like of shape (n_classes,) + The class probabilities. + + Notes + ----- + This simulates data from separate multivariate Gaussians, where each class has its own + multivariate Gaussian distribution. The class labels are sampled from a multinomial distribution + with probabilities `pi`. + + The ground-truth computation of the MI depends on + """ + rng = np.random.default_rng(seed) + + if pi is None: + pi = np.ones((n_classes,)) / n_classes + else: + if len(pi) != n_classes: + raise RuntimeError(f"pi should be of length {n_classes}") + + # first sample the class labels according to class probabilities + counts = rng.multinomial(n_samples, pi, size=1)[0] + + # now sample the multivariate Gaussian for each class + means = [np.zeros((n_dims,))] + sigmas = [np.eye(n_dims)] + for _ in range(1, n_classes): + mean = rng.standard_normal(size=(n_dims,)) + sigma = np.eye(n_dims) + + means.append(mean) + sigmas.append(sigma) + + # now sample the data + X_data = [] + y_data = [] + for k in range(n_classes): + X_data.append(rng.multivariate_normal(means[k], sigmas[k], counts[k])) + y_data.append(np.repeat(k, counts[k])) + X = np.concatenate(tuple(X_data)) + y = np.concatenate(tuple(y_data)) + + return X, y, means, sigmas, pi + + +def mi_separated_gaussians(means, sigmas, pi, seed=None): + """Compute the ground-truth mutual information between the class labels and the data. + + Parameters + ---------- + means : list of array-like of shape (n_dims,) + The means of the Gaussians from each class. The list has length ``n_classes``. + sigmas : list of array-like of shape (n_dims, n_dims) + The covariance matrices of the Gaussians from each class. + The list has length ``n_classes``. + pi : array-like of shape (n_classes,) + The class probabilities. + seed : int + The random seed to feed to :func:`numpy.random.default_rng`. The default is None. + + Returns + ------- + I_XY : float + The ground-truth mutual information between the class labels and the data. + """ + n_dims = means[0].shape[0] + n_classes = len(sigmas) + + # compute ground-truth MI + base = np.exp(1) + # H_Y = entropy(pi, base=base) + + def func(*args): + # points at which to evaluate the multivariate-Gaussian + x_points = np.array(args) + + # compute the probability of the multivariate-Gaussian at various points in the + # d-dimensional space + p = 0.0 + for k in range(n_classes): + p += pi[k] * multivariate_normal.pdf(x_points, mean=means[k], cov=sigmas[k]) + + # compute the log-probability + return -p * np.log(p) / np.log(base) + + # limits over each dimension of the multivariate-Gaussian + lims = [[-10, 10]] * n_dims + H_X, _ = nquad(func, ranges=lims) + + # now compute H(X|Y) + H_XY = _conditional_entropy_separated_gaussians(sigmas, pi, base) + + I_XY = H_X - H_XY + return I_XY + + +def _conditional_entropy_separated_gaussians(sigmas, pi, base): + """Conditional entropy. + + Computes H(X | Y), where X can be multivariate and is assumed to be multivariate-Gaussian. + The determinant of the covariance matrix of X is used to compute the entropy. + + Y is assumed to be discrete. + X is some multivariate-Gaussian, where the covariance matrix is given by `sigmas` + and provides the entropy of X for each class. + """ + n_classes = len(sigmas) + n_dims = sigmas[0].shape[0] + + # now compute H(Y|X) = H(X, Y) - H(X) + H_XY = 0.0 + for k in range(n_classes): + # [d * log(2 * pi) + log(det(sigma)) + d] / (2 * log(base)) + H_XY += ( + pi[k] + * (n_dims * np.log(2 * np.pi) + np.log(np.linalg.det(sigmas[k])) + n_dims) + / (2.0 * np.log(base)) + ) + return H_XY + + +def cmi_separated_gaussians(means, sigmas, pi, condition_idx, seed=None): + """Compute the ground-truth conditional mutual information. + + This computes the CMI between the class labels and the data. + """ + n_classes = len(means) + + x_idx = np.ones((means[0].shape[0],), dtype=np.bool_) + x_idx[condition_idx] = False + # Z_sigmas = [sigma[condition_idx, condition_idx] for sigma in sigmas] + # X_sigmas = [sigma[x_idx, x_idx] for sigma in sigmas] + base = np.exp(1) + + def func(*args): + # points at which to evaluate the multivariate-Gaussian + x_points = np.array(args) + + # compute the probability of the multivariate-Gaussian at various points in the + # d-dimensional space + p = 0.0 + for k in range(n_classes): + p += pi[k] * multivariate_normal.pdf(x_points, mean=means[k], cov=sigmas[k]) + + # compute the log-probability + return -p * np.log(p) / np.log(base) + + # integrate to get approximate H(X, Z) + n_dims = means[0].shape[0] + lims = [[-10, 10]] * n_dims + H_XZ, _ = nquad(func, ranges=lims) + + def func(*args): + # points at which to evaluate the multivariate-Gaussian + x_points = np.array(args) + + # compute the probability of the multivariate-Gaussian at various points in the + # d-dimensional space + p = 0.0 + for k in range(n_classes): + p += pi[k] * multivariate_normal.pdf(x_points, mean=z_means[k], cov=z_sigmas[k]) + + # compute the log-probability + return -p * np.log(p) / np.log(base) + + # get approximate H(Z) + z_means = [mean[condition_idx] for mean in means] + z_sigmas = [sigma[np.ix_(condition_idx, condition_idx)] for sigma in sigmas] + n_dims = z_means[0].shape[0] + lims = [[-10, 10]] * n_dims + H_Z, _ = nquad(func, ranges=lims) + + # now compute H(X, Z|Y) + H_XZY = _conditional_entropy_separated_gaussians(sigmas, pi, base) + + # lastly compute H(Z |Y) + H_ZY = _conditional_entropy_separated_gaussians(z_sigmas, pi, base) + + # now compute H(X|Y,Z) + print(H_XZ, H_Z, H_XZY, H_ZY) + I_XYZ = H_XZ - H_Z - H_XZY + H_ZY + return I_XYZ diff --git a/sktree/experimental/tests/meson.build b/sktree/experimental/tests/meson.build index ac5c5d40f..55ef7e965 100644 --- a/sktree/experimental/tests/meson.build +++ b/sktree/experimental/tests/meson.build @@ -2,6 +2,8 @@ python_sources = [ '__init__.py', 'test_mutual_info.py', 'test_simulate.py', + 'test_ksg.py', + 'test_monte_carlo.py' ] py3.install_sources( diff --git a/sktree/experimental/tests/test_ksg.py b/sktree/experimental/tests/test_ksg.py new file mode 100644 index 000000000..c2be62114 --- /dev/null +++ b/sktree/experimental/tests/test_ksg.py @@ -0,0 +1,51 @@ +import itertools + +import numpy as np + +from sktree.experimental.ksg import entropy_continuous +from sktree.experimental.mutual_info import entropy_gaussian + +seed = 12345 + +rng = np.random.default_rng(seed) + + +def get_mvn_data(total_rvs, dimensionality=2, scale_sigma_offdiagonal_by=1.0, total_samples=1000): + data_space_size = total_rvs * dimensionality + + # initialise distribution + mu = rng.standard_normal(data_space_size) + sigma = rng.rand(data_space_size, data_space_size) + + # ensures that sigma is positive semi-definite + sigma = np.dot(sigma.transpose(), sigma) + + # scale off-diagonal entries -- might want to change that to block diagonal entries + # diag = np.diag(sigma).copy() + # sigma *= scale_sigma_offdiagonal_by + # sigma[np.diag_indices(len(diag))] = diag + + # scale off-block diagonal entries + d = dimensionality + for ii, jj in itertools.product(list(range(total_rvs)), repeat=2): + if ii != jj: + sigma[d * ii : d * (ii + 1), d * jj : d * (jj + 1)] *= scale_sigma_offdiagonal_by + + # get samples + samples = rng.multivariate_normal(mu, sigma, size=total_samples) + + return [samples[:, ii * d : (ii + 1) * d] for ii in range(total_rvs)] + + +def test_get_h_1d(k=5, norm="max"): + X = rng.standard_normal(size=(1000, 1)) + cov_X = np.atleast_2d(np.cov(X.T)) + + analytic = entropy_gaussian(cov_X) + kozachenko = entropy_continuous(X, k=k, norm=norm) + + print("analytic result: {:.5f}".format(analytic)) + print("K-L estimator: {:.5f}".format(kozachenko)) + assert np.isclose( + analytic, kozachenko, rtol=0.1, atol=0.1 + ), "K-L estimate strongly differs from analytic expectation!" diff --git a/sktree/experimental/tests/test_monte_carlo.py b/sktree/experimental/tests/test_monte_carlo.py new file mode 100644 index 000000000..9a24868d1 --- /dev/null +++ b/sktree/experimental/tests/test_monte_carlo.py @@ -0,0 +1,51 @@ +import numpy as np +from scipy.sparse import csr_matrix +from sklearn.datasets import make_classification +from sklearn.neighbors import NearestNeighbors + +from sktree.experimental.monte_carlo import conditional_resample + + +def test_conditional_resample(): + # Generate synthetic data + X, y = make_classification(n_samples=100, n_features=5, random_state=42) + + # Convert X to sparse matrix + X_sparse = csr_matrix(X) + + # Create conditional array + nn = NearestNeighbors(n_neighbors=5) + nn.fit(X) + conditional_array = nn.kneighbors_graph(X).toarray() + + # Perform conditional resampling + resampled_X = conditional_resample(conditional_array, X, replace=False, replace_nbrs=False) + resampled_X_sparse = conditional_resample( + conditional_array, X_sparse, replace=False, replace_nbrs=False + ) + + # Check that the resampled arrays have the correct shape + assert resampled_X.shape == X.shape + assert resampled_X_sparse.shape == X_sparse.shape + + # Check that the resampled arrays have the correct number of unique samples + assert len(np.unique(resampled_X, axis=0)) == X.shape[0] + assert len(np.unique(resampled_X_sparse.toarray(), axis=0)) == X_sparse.shape[0] + + # Check that the conditional distribution is preserved + for i in range(X.shape[1]): + unique_values, counts = np.unique(resampled_X[:, i], return_counts=True) + original_values, original_counts = np.unique(X[:, i], return_counts=True) + + assert np.all(unique_values == original_values) + assert np.all(counts == original_counts) + + unique_values_sparse, counts_sparse = np.unique( + resampled_X_sparse[:, i].toarray(), return_counts=True + ) + original_values_sparse, original_counts_sparse = np.unique( + X_sparse[:, i].toarray(), return_counts=True + ) + + assert np.all(unique_values_sparse == original_values_sparse) + assert np.all(counts_sparse == original_counts_sparse) diff --git a/sktree/meson.build b/sktree/meson.build index 0d5518a73..da3cae04f 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', + 'utils.py' ] py3.install_sources( diff --git a/sktree/neighbors.py b/sktree/neighbors.py index 1d6e1ed84..424a56977 100644 --- a/sktree/neighbors.py +++ b/sktree/neighbors.py @@ -2,6 +2,7 @@ from copy import copy import numpy as np +from joblib import Parallel, delayed from sklearn.base import BaseEstimator, MetaEstimatorMixin from sklearn.exceptions import NotFittedError from sklearn.neighbors import NearestNeighbors @@ -10,6 +11,21 @@ from sktree.tree._neighbors import _compute_distance_matrix, compute_forest_similarity_matrix +def forest_distance(clf, X, Y) -> float: + """Compute a valid distance metric between two samples using a decision-tree or forest model.""" + X = np.atleast_2d(X) + Y = np.atleast_2d(Y) + XY = np.concatenate((X, Y), axis=0) + aff_matrix = compute_forest_similarity_matrix(clf, XY) + + # dists should be (2, 2) + dists = _compute_distance_matrix(aff_matrix) + if dists.shape != (2, 2): + raise RuntimeError("This shouldn't happen") + + return dists[0, 1] + + class NearestNeighborsMetaEstimator(BaseEstimator, MetaEstimatorMixin): """Meta-estimator for nearest neighbors. @@ -29,14 +45,31 @@ class NearestNeighborsMetaEstimator(BaseEstimator, MetaEstimatorMixin): See :class:`sklearn.neighbors.NearestNeighbors` for details. n_jobs : int, optional The number of parallel jobs to run for neighbors, by default None. + force_fit : bool, optional + If True, the estimator will be fit even if it is already fitted, by default False. + verbose : bool, optional + If True, print out additional information, by default False. """ - def __init__(self, estimator, n_neighbors=5, radius=1.0, algorithm="auto", n_jobs=None): + _supports_multi_radii: bool = True + + def __init__( + self, + estimator, + n_neighbors=5, + radius=1.0, + algorithm="auto", + n_jobs=None, + force_fit=False, + verbose: bool = False, + ): self.estimator = estimator self.n_neighbors = n_neighbors self.algorithm = algorithm self.radius = radius self.n_jobs = n_jobs + self.force_fit = force_fit + self.verbose = verbose def fit(self, X, y=None): """Fit the nearest neighbors estimator from the training dataset. @@ -56,15 +89,31 @@ def fit(self, X, y=None): self : object Fitted estimator. """ - X, y = self._validate_data(X, y, accept_sparse="csc") + if y is not None: + X, y = self._validate_data(X, y, accept_sparse="csc") + else: + X = self._validate_data(X, accept_sparse="csc") self.estimator_ = copy(self.estimator) - try: - check_is_fitted(self.estimator_) - except NotFittedError: + if self.force_fit: self.estimator_.fit(X, y) + else: + try: + check_is_fitted(self.estimator_) + except NotFittedError: + self.estimator_.fit(X, y) + + if self.verbose: + print(f"Finished fitting estimator: {self.estimator_}") + + # get the number of neighbors to use in estimating the CMI + n_samples = X.shape[0] + if self.n_neighbors < 1: + knn_here = max(1, int(self.n_neighbors * n_samples)) + else: + knn_here = max(1, int(self.n_neighbors)) - self._fit(X, self.n_neighbors) + self._fit(X, knn_here) return self def _fit(self, X, n_neighbors): @@ -76,12 +125,20 @@ def _fit(self, X, n_neighbors): ) # compute the distance matrix - aff_matrix = compute_forest_similarity_matrix(self.estimator_, X) - dists = _compute_distance_matrix(aff_matrix) + dists = self._compute_distance_matrix(X) + + if self.verbose: + print(f"Finished computing distance matrix: {dists.shape}") # fit the nearest-neighbors estimator self.neigh_est_.fit(dists) + def _compute_distance_matrix(self, X): + # compute the distance matrix + aff_matrix = compute_forest_similarity_matrix(self.estimator_, X) + dists = _compute_distance_matrix(aff_matrix) + return dists + def kneighbors(self, X=None, n_neighbors=None, return_distance=True): """Find the K-neighbors of a point. @@ -182,26 +239,60 @@ def radius_neighbors(self, X=None, radius=None, return_distance=True, sort_resul if X is not None: n_samples = X.shape[0] + X = self._compute_distance_matrix(X) + + if self.verbose: + print(f"Finished computing distance matrix: {X.shape}") else: n_samples = self.neigh_est_.n_samples_fit_ - if isinstance(radius, numbers.Number): - radius = [radius] * n_samples - # now construct nearest neighbor indices and distances within radius - nn_ind_data = np.zeros((n_samples,), dtype=object) - nn_dist_data = np.zeros((n_samples,), dtype=object) - for idx in range(n_samples): - nn = self.neigh_est_.radius_neighbors( - X=X, radius=radius[idx], return_distance=return_distance, sort_results=sort_results + if self.verbose: + print(f"Computing radius neighbors for {n_samples} samples") + + if isinstance(radius, numbers.Number): + # return only neighbors within one fixed radius across all samples + return self.neigh_est_.radius_neighbors( + X=X, radius=radius, return_distance=return_distance, sort_results=sort_results + ) + else: + # forest-based nearest neighbors needs to support all samples to get pairwise + # distances before querying the radius neighbors API + if X is None: + raise RuntimeError("Must provide X if radius is an array of numbers") + + if len(radius) != n_samples: + raise RuntimeError(f"Expected {n_samples} radius values, got {len(radius)}") + + nn_inds_arr = np.zeros((n_samples,), dtype=object) + nn_dist_arr = np.zeros((n_samples,), dtype=object) + + # compute radius neighbors for each sample in parallel + if self.verbose: + print("Computing radius neighbors in parallel...") + + result = Parallel(n_jobs=self.n_jobs)( + delayed(_parallel_radius_nbrs)( + self.neigh_est_.radius_neighbors, + np.atleast_2d(X[idx, :]), + radius[idx], + return_distance, + ) + for idx in range(n_samples) ) + for idx, nn in enumerate(result): + if return_distance: + nn_inds_arr[idx] = nn[0][0] + nn_dist_arr[idx] = nn[1][0] + else: + nn_inds_arr[idx] = nn[0] + if return_distance: - nn_ind_data[idx] = nn[0][idx] - nn_dist_data[idx] = nn[1][idx] + return nn_dist_arr, nn_inds_arr else: - nn_ind_data[idx] = nn + return nn_inds_arr + - if return_distance: - return nn_dist_data, nn_ind_data - return nn_ind_data +def _parallel_radius_nbrs(radius_nbr_func, X, radius, return_distance): + return radius_nbr_func(X, radius, return_distance) diff --git a/sktree/utils.py b/sktree/utils.py new file mode 100644 index 000000000..1c3378f77 --- /dev/null +++ b/sktree/utils.py @@ -0,0 +1,27 @@ +from sklearn.utils.validation import check_is_fitted + + +def check_is_forest( + est, + allow_tree=False, + ensure_fitted: bool = True, +): + """Check if an estimator is a tree or forest. + + Parameters + ---------- + est : Estimator + Given estimator. + allow_tree : bool, optional + Whether to allow the estimator to be tree, by default False. + ensure_fitted : bool, optional + Whether to check if the estimator is fitted or not, by default True. + """ + if ensure_fitted: + check_is_fitted(est) + + if not hasattr(est, "apply"): + raise ValueError(f"estimator {est} must be a tree or forest") + + if not allow_tree and not hasattr(est, "estimator"): + raise ValueError("estimator must be a forest, not a tree") From 64ddf971c76843f9404274ae03dee6b588f03859 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 16 Aug 2023 12:03:11 -0400 Subject: [PATCH 02/13] Remove png Signed-off-by: Adam Li --- README.md | 3 ++- doc/api.rst | 7 +++++++ doc/whats_new/v0.2.rst | 1 + examples/overlapping_gaussians.png | Bin 110920 -> 0 bytes 4 files changed, 10 insertions(+), 1 deletion(-) delete mode 100644 examples/overlapping_gaussians.png diff --git a/README.md b/README.md index dc128d971..79a14169c 100644 --- a/README.md +++ b/README.md @@ -3,9 +3,10 @@ [![Main](https://github.com/neurodata/scikit-tree/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/neurodata/scikit-tree/actions/workflows/main.yml) [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/) [![codecov](https://codecov.io/gh/neurodata/scikit-tree/branch/main/graph/badge.svg?token=H1reh7Qwf4)](https://codecov.io/gh/neurodata/scikit-tree) -[![PyPI Download count](https://pepy.tech/badge/scikit-tree)](https://pepy.tech/project/scikit-tree) +[![PyPI Download count](https://img.shields.io/pypi/dm/scikit-tree.svg)](https://pypistats.org/packages/scikit-tree) [![Latest PyPI release](https://img.shields.io/pypi/v/scikit-tree.svg)](https://pypi.org/project/scikit-tree/) + scikit-tree =========== diff --git a/doc/api.rst b/doc/api.rst index e3db11d56..357255941 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -145,3 +145,10 @@ for the entropy, MI and CMI of the Gaussian distributions. mi_gaussian cmi_gaussian entropy_gaussian + + +.. currentmodule:: sktree.experimental.monte_carlo +.. autosummary:: + :toctree: generated/ + + conditional_resample diff --git a/doc/whats_new/v0.2.rst b/doc/whats_new/v0.2.rst index c92efce42..b3ea96c99 100644 --- a/doc/whats_new/v0.2.rst +++ b/doc/whats_new/v0.2.rst @@ -27,6 +27,7 @@ Changelog --------- - |Efficiency| Upgraded build process to rely on Cython 3.0+, by `Adam Li`_ (:pr:`109`) - |Feature| Allow decision trees to take advantage of ``partial_fit`` and ``monotonic_cst`` when available, by `Adam Li`_ (:pr:`109`) +- |Feature| Add a variety of different mutual information estimators based on decision trees, by `Adam Li`_ (:pr:`110`) Code and Documentation Contributors diff --git a/examples/overlapping_gaussians.png b/examples/overlapping_gaussians.png deleted file mode 100644 index 9ce697415524808796533a3c9bad0ba2b1a4d992..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 110920 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%0D!IdG!lEG6O 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 From 027b41dd68514954ffbd04a6cbeb2c5d71146491 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 16 Aug 2023 14:59:11 -0400 Subject: [PATCH 03/13] Add comments Signed-off-by: Adam Li --- sktree/tree/_oblique_splitter.pyx | 2 ++ 1 file changed, 2 insertions(+) diff --git a/sktree/tree/_oblique_splitter.pyx b/sktree/tree/_oblique_splitter.pyx index d549b0c45..d9dace4d8 100644 --- a/sktree/tree/_oblique_splitter.pyx +++ b/sktree/tree/_oblique_splitter.pyx @@ -156,6 +156,8 @@ cdef class BaseObliqueSplitter(Splitter): """ cdef SIZE_t idx, jdx + # XXX: this should be able to be improved, if we can flip the order of the for-loops + # XXX: we can add a hashmap here to keep track of the min/max of each feature # Compute linear combination of features and then # sort samples according to the feature values. for idx in range(start, end): From e0ef001bb108d43f7f7993ebf3a514be37164d22 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Thu, 17 Aug 2023 10:27:27 -0400 Subject: [PATCH 04/13] Try again Signed-off-by: Adam Li --- .../plotting_cmi_analysis_unsupervised.ipynb | 1146 +++++++++++++++++ experiments/plotting_cmi_supervised.ipynb | 618 +++++++++ 2 files changed, 1764 insertions(+) create mode 100644 experiments/plotting_cmi_analysis_unsupervised.ipynb create mode 100644 experiments/plotting_cmi_supervised.ipynb diff --git a/experiments/plotting_cmi_analysis_unsupervised.ipynb b/experiments/plotting_cmi_analysis_unsupervised.ipynb new file mode 100644 index 000000000..af651d18c --- /dev/null +++ b/experiments/plotting_cmi_analysis_unsupervised.ipynb @@ -0,0 +1,1146 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b0125b7c-d6d3-46a7-9e86-c3f7e2f6cda3", + "metadata": {}, + "source": [ + "# Analysis of (Conditional) Mutual Information Estimators Using Forests - Sample Efficiency\n", + "\n", + "In this simulation notebook, we will evaluate the sample efficiency of using forests to estimate\n", + "(conditional) mutual information. We will replicate the findings of https://arxiv.org/pdf/2110.13883.pdf. \n", + "\n", + "The data we will simulate comes from the following distributions for mutual information:\n", + "\n", + "- Helix: X is dependent on Y on a helix\n", + "- Sphere: X is dependent on Y\n", + "- Uniform: X is dependent on Y\n", + "- Gaussian: X is dependent on Y\n", + "- independent: X is completely independent of Y\n", + "\n", + "The data we will simulate comes from the following distributions for conditional mutual information:\n", + "\n", + "- Uniform: X is conditionally (in)dependent on Y given Z\n", + "- Gaussian: X is conditionally (in)dependent on Y given Z\n", + "\n", + "For each distribution, we will add a varying number of independent dimensions to the data (i.e. sampled from Gaussian distribution).\n", + "\n", + "## Graphical models of the simulation\n", + "\n", + "For our purposes, we are motivated by the feature selection problem in cancer research, where cancer status (1-4 severity) is the outcome variable of interest and certain feature sets (X and W) are possibly high-dimensional sets that may have causal impact on each other. With prior knowledge, we know that cancer status cannot cause any of the features in the feature sets. We are also typically concerned with comparing sets of features conditioned on at most one other feature set. This allows us to enumerate all possible causal DAG settings that match this. We have the following 8 possible DAGs:\n", + "\n", + "1. W is completely independent: $(X \\rightarrow Y, W)$\n", + "2. W is an observed covariate: $(X \\rightarrow Y, X \\leftarrow W \\rightarrow Y)$\n", + "3. W is an observed confounder that explains the correlation between X and Y: $(X, X \\leftarrow W \\rightarrow Y)$\n", + "4. W affects the outcome only: $(X \\rightarrow Y, W \\rightarrow Y)$\n", + "5. W affects the treatment only: $(X \\rightarrow Y, W \\rightarrow X)$\n", + "6. W affects the outcome only but X is independent: $(X, W \\rightarrow Y)$\n", + "7. W affects the treatment only but X is independent: $(Y, W \\rightarrow X)$\n", + "8. All are d-separated: $(Y, W, X)$\n", + "\n", + "With these, we assume that there are no other relevant latent confounders that are not controlled for in our experimental design.\n", + "\n", + "# Estimation Methods for Y discrete\n", + "\n", + "1. Direct estimation of entropy using supervised forests:\n", + "\n", + "$$I(X; Y) = H(X) - H(X | Y) = H(Y) - H(Y | X)$$\n", + "\n", + "-> H(Y| X) = clf.predict_proba(X) after fitting forest to (X, Y) pairs\n", + "-> H(Y) = empirical entropy calculuation\n", + "\n", + "$$I(X; Y|Z) = H(Y | Z) - H(Y | X, Z)$$\n", + "\n", + "-> Train two forests and directly estimate using pairs of (Y, Z) and (Y, X \\cup Z)\n", + "\n", + "2. Indirect estimation of entropy using KSG with unsupervised forests\n", + "\n", + "The (conditional) mutual information KSG estimator just requires training a forest.%load_ext lab_black" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "705fb134-54c2-42fd-bbc3-1d4541ae8769", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext lab_black" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2e7b6950-44a0-40a9-bf2a-b6eca06725c1", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# from dodiscover.ci import CMITest\n", + "import pandas as pd\n", + "import scipy\n", + "import scipy.spatial\n", + "import seaborn as sns\n", + "from sklearn.neighbors import NearestNeighbors\n", + "from tqdm import tqdm\n", + "\n", + "import sktree\n", + "from sktree import (\n", + " NearestNeighborsMetaEstimator,\n", + " ObliqueRandomForestClassifier,\n", + " ObliqueRandomForestRegressor,\n", + " UnsupervisedObliqueRandomForest,\n", + " UnsupervisedRandomForest,\n", + ")\n", + "from sktree.experimental import SupervisedInfoForest, mutual_info_ksg\n", + "from sktree.experimental.ksg import _compute_radius_nbrs, mutual_info_ksg_nn\n", + "from sktree.experimental.mutual_info import (\n", + " cmi_from_entropy,\n", + " cmi_gaussian,\n", + " entropy_gaussian,\n", + " entropy_weibull,\n", + " mi_from_entropy,\n", + " mi_gamma,\n", + " mi_gaussian,\n", + ")\n", + "from sktree.experimental.simulate import (\n", + " embed_high_dims,\n", + " simulate_helix,\n", + " simulate_multivariate_gaussian,\n", + " simulate_sphere,\n", + ")\n", + "from sktree.neighbors import forest_distance\n", + "from sktree.tree import compute_forest_similarity_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "bf387bc2-f1d1-4b7a-9dab-e9c8fb992b2a", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "8ca87428-e8c8-46df-829f-116261c54f86", + "metadata": {}, + "source": [ + "## Define Hyperparameters of the Simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e5089afb-c359-423d-92b1-641fca6315b2", + "metadata": {}, + "outputs": [], + "source": [ + "seed = 12345\n", + "rng = np.random.default_rng(seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4fcde0a4-7413-4f09-bbd8-fe62fcd62c2d", + "metadata": {}, + "outputs": [], + "source": [ + "n_jobs = -1\n", + "n_estimators = 100\n", + "feature_combinations = 2.0\n", + "n_nbrs = 5\n", + "\n", + "# hyperparameters of the simulation\n", + "n_samples = 1000\n", + "n_noise_dims = 20\n", + "alpha = 0.001\n", + "\n", + "# dimensionality of mvg\n", + "d = 3\n", + "\n", + "# for sphere\n", + "radius = 1.0\n", + "\n", + "# for helix\n", + "radius_a = 0.0\n", + "radius_b = 2.0\n", + "\n", + "# manifold parameters\n", + "radii_func = lambda: rng.uniform(0, 1)" + ] + }, + { + "cell_type": "markdown", + "id": "dc222a29-5a31-486e-b2e3-6e276a61f81f", + "metadata": {}, + "source": [ + "## Setup a single simulation\n", + "\n", + "Now, to demonstrate what the data would look like fromm a single parameterized simulation, we want to show the entire workflow from data generation to analysis and output value." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3cc73c4e-78b6-48b3-83b3-091d365d8ada", + "metadata": {}, + "outputs": [], + "source": [ + "# generate helix data\n", + "helix_data = simulate_helix(\n", + " radius_a=radius_a,\n", + " radius_b=radius_b,\n", + " alpha=alpha / 2,\n", + " n_samples=n_samples,\n", + " return_mi_lb=True,\n", + " random_seed=seed,\n", + ")\n", + "P, X, Y, Z, helix_lb = helix_data\n", + "\n", + "# generate sphere data\n", + "sphere_data = simulate_sphere(\n", + " radius=radius, alpha=alpha, n_samples=n_samples, return_mi_lb=True, random_seed=seed\n", + ")\n", + "lat, lon, Y1, Y2, Y3, lb = sphere_data\n", + "\n", + "# simulate multivariate Gaussian\n", + "mvg_data = simulate_multivariate_gaussian(d=d, n_samples=n_samples, seed=seed)\n", + "data, mean, cov = mvg_data" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "aa1a67bb-55fa-4983-b2d1-a23102945b7c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# helix data\n", + "fig = plt.figure()\n", + "ax1 = fig.add_subplot(111, projection=\"3d\")\n", + "\n", + "ax1.plot(X, Y, Z, \"*\", c=\"b\", label=\"Helix\")\n", + "ax1.legend(loc=\"upper left\")\n", + "ax1.axis(\"equal\")\n", + "# ax1.set(\n", + "# xlim=[-1, 1],\n", + "# ylim=[-1, 1],\n", + "# zlim=[0.25, 1],\n", + "# )\n", + "fig.tight_layout()\n", + "elev = 20\n", + "azim = 50\n", + "roll = 0\n", + "ax1.view_init(elev, azim, roll)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a841ffc8-e821-4c0a-8df0-9b55b1be3aba", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ8AAAGJCAYAAABVbT4SAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOx9d3wUdf7+M7MtvVdCSIEQelUhEcWCiqf31bN76p0Ne/dnRz0R6+mpWEA4bCeIguXu9PRUEAFBPCG9EUJISC+btrvZOp/fH8NndmZ3tmZTwHleL14hm92Z2dnZzzPv9jwMIYRAgQIFChQoGEGwo30AChQoUKDgtweFfBQoUKBAwYhDIR8FChQoUDDiUMhHgQIFChSMOBTyUaBAgQIFIw6FfBQoUKBAwYhDIR8FChQoUDDiUMhHgQIFChSMOBTyUaBAgQIFIw6FfBQoUKBAwYhDIR8FChQoUDDiUMhHgQIFChSMOBTyUaBAgQIFIw6FfBQoUKBAwYhDIR8FChQoUDDiUIdqQ4QQ2O12OByOUG1SQQBQqVRQq9VgGGa0D0WBAgUKfCIk5GO1WtHa2gqTyRSKzSkIEhEREUhPT4dWqx3tQ1GgQIECr2CG6mTKcRxqa2uhUqmQnJwMrVar3H2PMAghsFqt6OzshMPhQF5eHlhWyagqUKBg7GLIkY/VagXHccjMzEREREQojklBEAgPD4dGo0FDQwOsVivCwsJG+5AUKFCgwCNCdnus3GmPPpTPQIECBccKlNVKgQIFChSMOBTyUaBAgQIFIw6FfIaAw4cPg2EYFBcXj/ahKFCgQMExhTFFPr/+CpxxBv9zJNDZ2Ylbb70VEyZMgE6nQ1paGs455xz89NNPI3MAChQoUPAbRciGTEOBDz4AfvgB+Mc/gBNOGP79XXzxxbBarXj//feRm5uL9vZ2bN26Fd3d3cO/cy+wWq3KrI4CBQqOa4x65NPQAOzbB+zfD3z8Mf/Ypk387/v28X8fDvT29mLnzp144YUXcPrppyMrKwsnnXQSHnnkEfzf//0fAIBhGKxevRrnnnsuwsPDkZubiy1btrht69ChQzj99NMRERGB2bNnY8+ePZK/79q1C6eccgrCw8ORmZmJu+66C0ajUfh7dnY2nn76afzpT39CTEwMbrrpJr9ep0CBAgXHLMgQMTg4SCorK8ng4GBQrwec/xhG+pP+Gw7YbDYSFRVF7rnnHmI2mz0cG0hiYiJZt24dqampIcuXLycqlYpUVlYSQgipr68nAMiUKVPIl19+SWpqasgll1xCsrKyiM1mI4QQcvDgQRIZGUleeeUVcuDAAfLTTz+RuXPnkmuvvVbYT1ZWFomJiSEvvfQSOXjwoPDP1+tcMdTPQoECBQpGCqNOPh9+SIhaLSUb+k+t5v8+XNiyZQuJj48nYWFhpLCwkDzyyCOkpKRE+DsAcsstt0hes2DBAnLrrbcSQpzk8/e//134e0VFBQFAqqqqCCGE3HDDDeSmm26SbGPnzp2EZVnhnGVlZZELL7xQ8hx/XucKhXwUKFBwrGDU025XXQXs3Sv/t717+b8PFy6++GK0tLTgX//6F5YuXYrt27dj3rx5eO+994TnFBQUSF5TUFCAqqoqyWOzZs0S/p+eng4A6OjoAACUlJTgvffeQ1RUlPDvnHPOAcdxqK+vF153gkuRy9/XKVCgQMGxiDHVcMCyAMc5f44EwsLCcNZZZ+Gss87C448/jhtvvBFPPvkkrr32Wr+3odFohP9TXTvu6BswGAy4+eabcdddd7m9bsKECcL/IyMjJX/z93UKFChQcCxiTJBPSgqQlgZkZgI33ACsXw8cOcI/PtKYNm0avvjiC+H3n3/+GX/6058kv8+dO9fv7c2bNw+VlZWYNGlSQMcR7OsUKFCg4FjAmCCf8eOBw4cBrRZgGOCmmwCrFdDphm+f3d3duPTSS3H99ddj1qxZiI6Oxq+//ooXX3wRF1xwgfC8zZs344QTTsCiRYuwYcMG/PLLL1i/fr3f+3nooYewcOFC3HHHHbjxxhsRGRmJyspKfPfdd3jjjTdC/joFChQoOBYwJsgHkBINwwwv8QBAVFQUFixYgFdeeQV1dXWw2WzIzMzEsmXL8OijjwrPe+qpp7Bp0ybcdtttSE9Px0cffYRp06b5vZ9Zs2bhxx9/xGOPPYZTTjkFhBBMnDgRl19++bC8ToECBQqOBQzZz8dsNqO+vh45OTnHnYw/wzD4/PPPceGFF472ofiF4/mzUKBAwfGFUe92U6BAgQIFvz0o5KNAgQIFCkYcY6bmMxYxxIykAg8ghMDhcIBlWTAMo9iuK1DwG4RCPgpGFA6HAzabDSaTCSzLQqVSQa1WQ61WQ6VSKWSkQMFvBCEjHyVKGH2M5c+AEAK73Q673Q5CiBD12O122Gw2gXRUKhU0Gg1UKhVUKpViDa5AwXGKIZMPne43mUwIDw8f8gEpCB4mkwmAVHFhLIDjONjtdjgcDgAQiIZlWYFcCK8zKJARALAsK4mKFDJSoOD4wZDJR6VSIS4uTtAyi4iIUNImIwxCCEwmEzo6OhAXFweVSjXahwSAPy6O42Cz2UAIEUiH4zgwDCM8BkgJib6WEAKbzQar1QpAISMFCo4nDHnOB+AXira2NvT29obgkBQEi7i4OKSlpY0J8hen2QBIajkcx8FqtQZU36FERkmJvlYhIwUKjk2EhHwoaDFZwciD1knGAmi0I+5oc/17oOTjCjEZUbiSkVqtHhNErECBAneElHwU/LZBW6jtdjs4jpMlHiA05CO3b9fIyFM3nQIFCkYfCvkoCAlofca1qUAOw0E+csdDyai0tBQTJ05EdHS0WzedQkYKFIwOlDkfBUMGJRNv0c5Ig7ZtA4DRaAQASQMDjYxca0Zj4dgVKPgtQCEfBUGDptloN5u/xDPSC7x4hghwzkNR0rRYLAoZKVAwwlDIR0FQcE2zBRrxjPSi7tqYAECWjCwWi9fWboWMFCgIDRTyURAQPM3uHMsQk5FKpRKaFgghbmRE60VqtXrMpBgVKDgWoZCPAr9BZ3cqKiqQnJyMxMTE43LxFROqKxmZzWbhOZSMaGSkkJECBf5DIR8FfoFGOxzHob+/H7GxscfMQjvU41TISIGC0EMhHwVeIU6z0W42lmXBcdxoH1pACOVEgb9k5DpjpJCRAgVOKOSjwCM8NRVQXTYFPDyREcdxAhlR0lbISIECHgr5KJCFN4kchXy8wxMZORwOWK1WVFZWYvr06UKKTiEjBb9FKOSjQAJ/ZneONfIZ7eMVK3YTQtDT0wOA10J0OBzCnBFN04l16RQyUnC8QiEfBQL8nd0Z7cX8eABt6wbcvYzEQ7GKy6uC4xUK+SgA4FQk90ciRyGf4CF33jx5GSkurwqOZyjk8xuHq++OP3UHhXyGDl/k7g8ZKV5GCo5lKOTzG4a4hRrwrkQtBnUjDRZtbW04cOAAIiIikJCQgPj4eERGRg5bSmkskWUwx6G4vCo4HqGQz28QcrM7gSz8tHAeKBwOB2pqatDS0oJJkybBZrNBr9fj0KFDYFkW8fHxwr/w8HClvuEBvshIiYwUHAtQyOc3hqEKggLBRRJGoxElJSVgGAYFBQXQaDQghCArKwscx2FgYAB6vR7t7e04cOAAtFqthIzCwsIC2t9YRyiJVY6M6M0FdRZWXF4VjDUo5PMbgi97a38RKPm0traioqICGRkZyM/PB8MwErt1lmURGxuL2NhY5OTkwOFwoK+vDz09PWhubkZ1dTXCw8MFIoqLi4NWqw3oeMcKRiL9J7aPoPukn73Yy0hxeVUwmlDI5zcAf+2t/YW/5ONwOFBdXY22tjbMnDkTqampwvF4g0qlQkJCAhISEgAAdrsdvb296OnpweHDh2EwGBAVFSUhI7Xa+6U8Vmo+FCO50Psio97eXrAsi6SkJMXlVcGIQSGf4xyhSLO5wh/yMRgMKCkpAcuyKCwsRHh4eND7U6vVSEpKQlJSEgDAarWip6cHPT09qK2thdlsRnR0tEBGsbGxksV2LGEskKArGen1ejAMg9jYWMXlVcGIQSGf4xiBzO4EAl/dbi0tLaioqMCECROQl5cX8kK3VqtFamqqEEmZzWaBjKqqqmCz2RATE4P4+HgkJCSMiQVfjLG4iNMUnOLyqmCkoJDPcQg6E1JTU4Po6GikpqaGdKFgWVZSs6FwOByorKxER0cHZs+ejZSUlJDt0xvCwsKQnp6O9PR0EEIwODgokFFTUxNsNhsOHToEo9GI+Ph4REVFjdrCOdaIEOCJhp4Pby6vChkpCCUU8jnOwHEc7HY7HA4HBgYGoNFoQr4oyKXdDAYDiouLodFocPLJJ49adxrDMIiIiEBERAQyMjJACMHPP/+MqKgo9PT0oL6+HgzDSDrpIiIiftMLJ3WklYMcGXlyeVXISEEgUMjnOIGcvXWw8zi+4Eo+TU1NqKqqQlZWFiZNmuR3ms3bohcq0POQnJyMpKQkoa27p6cHnZ2dOHjwINRqtZCiG4m27rG2KAfyOXjzMrJYLJLISDHWU+ANCvkcB3CVyBHPfQyH6RslH7vdjsrKSnR1dWHOnDlITk4O+b5CDXFbd3Z2NhwOB/r7+9HT04OWlhZUV1cjLCxMEhkF0tbtC2Mx7TaUmwDF5VVBsFDI5xiHL9+d4SIfq9WKPXv2QKfTobCwcEwPgXpb5FQqlUAygLStu6GhARUVFYiMjJS0dWs0mpE69BFBKCNQxeVVgb9QyOcYhT+zO8ORdiOEoK+vD3q9Hrm5uZg0adIxsWj4ex5c27ptNpvQvFBXVweTyYTo6GghRRdMW/dYO1/Dmf5UXF4VeIJCPscg/J3dCXXazW63o7y8HJ2dnYiJiUFeXl7Itj1WodFokJKSInTuWSwWSVu31WpFbGysEBnFxMR4rXkdb2m3QOGNjCwWC8xms3D+1Go1tFqtQkbHKRTyOcZAW15H2nenv78fxcXFCA8Px6RJk9Dd3R2S7R5r0Ol0SEtLQ1pammxbt8PhQFxcnEBG0dHRsk6wYwkjST6ucFVSp2TU3NyMrq4uzJw5U1IzUlxejx8o5HOMwB97a1d4mscJdL9HjhxBTU0NcnNzkZubi+bm5jF5B+8Jw5lScm3rNhqNAhk1NDQAAOLi4oQ03XDU4IaK0SQfV7hGRjQ6oilmsbGe4vJ6bEMhn2MAwUrkDDXysdlsKC8vR29vL+bPny9orY0lfxx/MVKCnlFRUYiKikJmZiYIIUJbd1dXFw4ePAiWZeFwONDS0iJYR4w2xhL5UIhvsPwx1lNcXo89KOQzxiGOdgK9uxtKzaevrw/FxcWIjIzEySefLGk3Hir5/FbuUhmGQUxMDGJiYgTrCGqk19raipqaGuh0Oklbt06nG/HjHIvkI1ZdEEMho+MHCvmMUXia3QkEwZAPIQQNDQ2ora3FxIkTkZOTI9tFN5T0kcViQVVVFViWRWJi4rC3L4+VhZVlWURFRUGlUmH+/PlwOBxCW/eRI0dQWVkpcXcdqbZuGmWMJdCapi/4IiNAcXkdq1DIZwzC1d462C9KoBGKzWZDWVkZ+vv7ccIJJwizL0Pdrhh6vR4lJSWIiYmBSqUKWfvysQRxTSMxMRGJiYkA+PNPyYhq0bmqdfuyjggGYzXyCea690RGisvr2INCPmMIQ7W3dkUgEUpvby+Ki4sRHR2NwsJCr1P9wZAPIQT19fWoq6tDfn4+0tLShPdosVig1+slqtS0fTkhIUG2YyxQjJUalbfj0Gg0SE5OFpQixG3dNTU1sFgsglo3JaNQLJpjkXxCFY3JkZHi8jo2oJDPGMFw+e74Ih9CCA4fPoyDBw9i0qRJyM7O9rnfQMnHarWirKwMBoMBJ510EmJjYyVdeDqdTqJKbTKZhEW3sbERgLRj7LciBCpu6wYgaetuaWmB3W6XkHRUVFRQC/ZYJB+O44Yl+qX1IAo5l1cxGSkur8MHhXzGAEJlb+0KXwoHlBQGBgZw4oknIi4uzq/tBkI+NKKKiYlBYWGhUMPwpqIcGRmJyMhIjB8/XugY0+v1ghCoRqMR7v4TEhJ8FunH2sIR7PGEh4cjPDwc48aNkyVpQoikeSEyMtKvfY1V8hmJepc/ZEQtxxWX19BCIZ9RBNW7MplMCA8PD/kUt7e0W09Pj1B7OfnkkwP6ovtDPuLGBbmIyl/yEneMUSHQvr4+YaizqqrKryL9sZB2CwRyJG0wGNDT04Pu7m4cOnQILMtKyCg8PFz2+vLUWTaaCLbmM1T4IqO+vj4wDIPk5GTFPmKIUMhnlEDTbO3t7aivr0dBQUHIL2A5khDXXvLy8pCVlRXwfn2l88TzQd4aF4KBSqVCQkICEhISMHHiRKFIr9frUVdXh8HBQbci/VjDcCxUDMMgOjoa0dHRmDBhAjiOE9S629vbceDAAWi1WtmIcSxGPmOlA09MRoQQ6PV6EEIQGxurGOsNEQr5jAJc7a2H68vvGvlYrVaUlpbCaDQKtZdg4C3yoTI8ERERbvNBwwG5Ij1tXqisrITdbgfLsujq6kJERERImheGgpGKwFiWRVxcHOLi4pCTkyOJGJubm4WIMT4+Hg6HQ6g1jhWMVuTjDfSmi1pDKC6vQ4NCPiMI19kdmkseri++mCRoi3NcXJyk9hIM5GpJhBA0NTWhurpakOEZjS+cXPNCaWkpTCYTiouLAUBy9+8pFXW8QRwxAk7rCL1eD7vdjpKSEkRFRUmsI4ajrdtfjMVUICBthBC3zAOKy2ugUMhnhOA6uyNuAR0uvS8q5VJXV4dDhw4hPz8fmZmZIemiE5OP2FRu3rx5wtzKaIPWRSghpaamwmAwyDYv0JrRSCgMjIWFR2wd0dbWhhkzZgj2EbW1tTCbzW7py5GcvRqLkQ8AoSlIDp4Uuz25vNK27t+qYrdCPsMMX7M79CIdDjgcDlgsFjQ3N2PBggWIiYkJyXbF5GMwGFBUVAStVjvmTeVYlvXYvEAVBsTGcfHx8SG/+x8rjQ9iEEKg1WqRkJCA1NRUAIDZbBY66Wj6UmwdER0dPazkMFZqPq4IpAXcGxkpLq8K+Qwr/JndodFJqNHd3Y2ysjIAQGFhYUgXUUo+LS0tqKioQFZWFiZNmjQmFwtvkGteEBvHiZsXEhISQjbUOdYWFrmaY1hYmCR9SWeM9Ho9jhw5Ao7jJNYRUVFRIX1fx2Lk4wv+ktFvxeVVIZ9hgr+zO/4MggYCQggOHjyIw4cPIzs7Gw0NDSG/e+c4Dg6HA1VVVZgzZ45Q7A8EI/ll8ncuydU4jt796/V6VFRUCHf/NEUXTPPCWI18vL0PhnG3jqBt3T09PaivrxcaHEJVSzsWaj5DhScyknN5/fzzzzF37lzMmjUrJPseC1DIJ8Twx95aDJVKBY7jQtLxZjabUVpaCovFgoULFwIADh8+PKRtusJoNKKkpAQAH1GNBUuA4YLr3b/JZBI66Q4fPgyGYY755gW64AVyNy/X1k2tI+QGgePj4wNOxx6PkY8veCOjN998E3fddZdCPgrkEYxEjlhzaigLV1dXF0pLS5GUlIR58+ZBrVbDaDSG9E67ra0N5eXlSEtLg9FoHNP1nVBDPNSZmZkpWXA7OjpQW1sr1E182SOMRYIaqoZgbGwsYmNjhVpaf38/9Ho9mpubUV1djbCwMAkZ+WrBH6vkM1yyP3IQk5HRaERUVNSI7HekoJBPiOA6u+Pvl5l+wYL9snEch4MHD6KhoQFTp07F+PHjJdsORUqP4zjU1NSgubkZM2fORFxcHJqamoZEmGNxAQ4EcgtuX1+fUBMRNy8kJCQIrctjLe1GjyeUn4dKpRJIBnC2dVN314qKCp+NHWO14WA4Ix9PoA650dHRI7rf4YZCPkOEeHbHX3trMcTkEyjMZjNKSkpgs9lQUFDgdmdEj2MoJDE4OIji4mIQQlBYWIiIiAhhfmGsLaSeMBQLCH/hOkcjbl4Qty6HhYWB47gxc2c/HOTjCnFbN8APO1My8qRK8Vuo+QQCk8mEyMjIEd/vcEIhnyGA4zjY7fYhKVEHSz6dnZ0oLS1FSkoKpk2bJvuFEG87mC9MR0cHysrKkJaWhilTprgN1x0r5DMakGte0Ov1aGtrg9lsxo4dOyQF+lB3i/mLkSAfV2i1Wsm5cbXUsFqtQjdlamoqYmJixgRRA6OXDlTSbgoASGd3grG3FoO+1l/y4TgOtbW1aGxsxPTp0zFu3DiPzxXXkwKBr30MlXwcDgdqampgNpuFaOF4rx+FhYVh3Lhx0Gg0sNlsmD59uhAZHT58WOgWozWjkWpeGA3ycYWrKsXg4CB+/vlnmM1mlJWVgeM4N+uI0SLq0Yh8OI6DyWRSyOe3jlDYW7vC39oMTYFxHCebZnMFPa5AoipfqTx6vEBw5COWuYmLi0NLSwtqamoQHh4uKdaHei5pLIHaaUdFRUmaF/R6vSACqtPpJJ10w6WRNxbIRwyGYYQOyilTpkCr1cJoNEqIWtxlOJL+TkN1Fg4WRqMRAJSaz28Zw+m744sg2tvbhU4zcQrM13bpcfsDccfc/PnzPRJAMKQGOFOF6enpmDRpEhwOB1QqlawyNXXsTEhICEnaZaykCOWOQ9y8QEVAaU1E3Lwgto0IFTmL5Z7GCsSLPMMwbkTtKpGkVqvdrCOGA+L0+kiCko9S8/kNItDZnUDhjXzEnWbTp09Henq639v1lyQIIairq0N9fb1bx5yv1/n7PDr4StN44lqZqzI1rY/QVl06TU9TdMe6k6mvY1epVEhMTBQ08mjzgl6vF5oXQmWnPdYiH8A7IbpKJHEcJ0gktba2oqamRhI1hlKvbzQjH61WO+wK8SMNhXx8gE5zE0Kg0WiGRerCk8SOyWRCSUkJCCEoKCgI6s7Hl5upxWJBaWkpBgcHsXDhQr9Ce5pq9Id8rFYrSkpKYDab/d4+rY9Qx056p9vd3Y26urpREQMNFYKJwFybF8R22s3NzXA4HJJ6USA1kbHq5QP4t8iLDfMAvq3bm16fJ7NBfxDqjIe/MBgMfrvSHktQyMcLqE9HaWkpkpOTkZWVNSz7kYt86EDnuHHjkJ+fH3SR01tURW0W4uPjMXfu3IBSOf6QD7XQjo2NRUFBQVCpIvE0fVZWlkcxUBoVxcXFuZ0rb1/a/ftZPPGEDitWWDBvHif8/sc/2rBxowZ//KMNb7+tgckEREQAN9/MP06fL7eN4YarnTatiej1ekHqxlV5wRPGIvkMJRWoVqvdokaawjx06JAwLyMmI3+/W6PVZm00GhERETHi+x1uKOQjA5pmo91sarV62GwPAKfEDuDsBGtpacGMGTOQlpY2pG37cjOdPHkyJkyYEJSbqSfyIYSgsbERBw4cCNot1RM8iYHq9XrU1NTAYrFI9NeokrenY/3oIw127FBj0yYO8+ZZhN/1egbl5SrhJ8XKlSyamljh+QCwapUWO3aosWoVwV13Wb0SUagXe7maiKfmBXpOxOmbsUo+oYow5MwGadRIrxd/U5ijMWAKONusx9rnNFQo5OMCOYmc4VKepqCt1lQ3jWEYYaBzqJBzMy0rK4PBYBiSm6mndJ7dbkd5eTl6enq8WmiH6ovkmpIymUwCGTU2NqK2NhbvvjsVd93VhMREE8LDw3HkCIvubgYMA3z2Gf8V2LRJjexsBzZs4H8vL2clPymamvjj/vBDNbKzOSQmEnz5Jf8a+nPHDjXWreOwbJlNEkWtWGFBd7cOK1fOxiuvsMMSJXlrXqDqAmLTOLVaPeYWteEcMNXpdEhLSxNu6sQpzJaWFq/isaMZ+RxvzQaAQj4SiKMdV5G/4Yx8WJYVlJMzMjKQn58fsjsscYRC02DR0dFDdjOVm02i3j46nQ6FhYUjUovZv5/Fvffy++FTYolYsSIK8+bx6suffsqitDQKX35pQHLyXuh0Oixdeo7ofdBzw+Lhh8XpKcblp/Rxg4HFww9LZ5OsVuCzz/hzumGDFq2tLHbsUKO9nUFNjQqbNnEwGmNQVBSHTZusQuQ0nHBtXrBarW7KCwBw6NChkHUWDhUjKa3jmsKkNy+UrAEIw8DA6DRmHI8DpoBCPgB8z+4MZ+TjcDgwODiI/v5+zJo1SzDzChXosTc0NODAgQOYNGkSsrOzQ+5m2traivLyckyYMAF5eXkjtnh89JEGRUX8ZfzGG3yKbN06Dqee6sCaNRrU1/PHsWNHBu65JwH9/QOYO3cARUV84wMhoVxMpNvato0/rpoa/m55wwYNCOEXkU8+UeOPf7SBEKC1lcFbb2lHpGak1WqRmpoqXGcdHR2orq6GyWSSdBYOl0+PPxgtFQGxeOz48eNBCBHEY7u7u9HT0wMAKC8vl7R1D/f5UWo+xylc7a3lLno6ixJqGAwGlJSUwG63IycnJ+TEA/BfqLq6OphMJq9psGC2Sye+aSv47NmzhfSXP68PFo2NDCoqWPT3M/joI2f0RlNkGzZosWEDfZQnSL1ehdNOiwYweoN6AwMM6FdOr2dx6qnSVMqqVQT19fx5eeWVkWle0Gq1UKvVmDFjhtC8QKVuxM0LYuWF4cZY0XVjGEZo687KykJzczNaWloQGRkp1NP8VTIfCpTI5ziDL3trMVQqlZCeCBWoC+iECRNgMpmGJZfc398Pk8kElmVx8sknh3ROgGEYWCwW/PLLL3A4HCGrUfmDGTM8fRHlPj+59Bnx8Fzx37w9J5QgiIgATCYGX3yhBsfx+1y3jsPq1cOflhM3HIibF6hPT39/v9sMjXixHY7Zk7EiuuoKQgh0Oh1ycnKEeppr52VERIRkxmgoqW0Kg8GgkM/xgkB9d0KZdnM4HKisrERHR4cQKZSWlobczbSpqQnV1dXQarXIzc0N+SLBcRzKy8uRmprqUdjUF4K5u92/n0V+vgO1taywUAcOVytzgqQkgo4OBlFRBAYDA5YFOI7IPj+0YGAy8fsRv58NG7TIzuYwaxYHQjBsaTlv3W5Uby4uLg45OTnCDI1er3drXqA246FQXhir5ON6XHKdl7S5o76+HuXl5ZLmjmCVKUwmk5J2Ox4QjEROqBoODAYDiouLodFocPLJJwtimqHy3QH4brPKykp0dXVh3rx5qK2tDam0DCEEhw4dgsViQVZWFqZOnRqybbti40Y1HnpIhxdesGDKFA733qtDQwMLvZ7FGWfYsG3b0O8qAWDTpkFs2qTBZ59pQO8xpMQ21ChI7vXix+S3/cwz0oaGP/6RxcaNgyEloEBarV1naMTNC+K2ZXGbezAkcqx6+bi2dcs1d4jbumNiYvy6aTMajcOSkh9t/GbIZygSOaGIfJqamlBVVYWsrCxMmjRJchGHinzE5FZYWIiwsDDU1dWFjHxsNhtKS0thMBgQHh4uLEJDgXhAE4BkRuaNN7To62Nx771hWLjQITQWAAgR8fAEcNllzrvKwUHp33j4vk4YhiA62ob+fi1cU3daLaDRcDCbGTgc/m/T9ThbWlhceGE4XnjBgpNPdmDChKF/rkOZ83FtXhgcHBTqRU1NTZLmhYSEBL+n9MdKzccVgbZay50fGhlVVFQIbd2UjKKjo2XJ7Xit+Yy924thAE2z0TbqQAfYhhL52O12lJaW4sCBA5g7dy4mT57sdoGFgnxaWlqwZ88epKSk4MQTTwx5VNXf34/du3cDgNCmHQpSo0Odf/xjuDCseeaZEbj7bq3QQDA4yOCHH/y5Twr0eFyjG/FjgS1+X3/dhTPO4AUgY2MtuPXWCsTF8U0qF11kweHDRnz9tQmZmRawbPDH2dvL4uabwzFjRhRef33oBBzKhT48PBwZGRmYMWMGFi1ahHnz5iE+Ph49PT3Yt28fdu3ahYqKCrS0tGDQyfKyx3QsRj6+EB4ejvT0dEybNg0nn3wyTjzxRCQnJ2NgYAAlJSXYuXMnSkpK0NjYiIGBAeH7NRTyefPNN5GdnY2wsDAsWLAAv/zyi8fnnnbaaUKnr/jfeeedJzzn2muvdfv70qVLgzq24z7yCdbeWgyVShVU5DMwMIDi4mJh7sWTZw3LskF30zkcDlRVVaG9vR1z5swRQn6KULh40qgtNzcXubm5AWm7yaGhAejsZGC3s9i8mb8EW1pYfPUVc/Q9MXj33cC7hh580IIXX/THF4iPJCIiOFgsNBoJdgHmt3XkSBR++ok/ZobRIj8/RYhyvv6awSefVOCLLybjyJHQDQs+9lgYLrjAPqQIaLgUDsSySOLmBb1eLzQvhIWFSWzGaV1yLJNPqLrZ5Nq6DQaDkKarr6/HDz/8gKKiItjtdkFfMpDP6uOPP8Z9992HNWvWYMGCBXj11VdxzjnnoKamRrYr9bPPPhNcigGgu7sbs2fPxqWXXip53tKlS/Huu+8Kvwd7To5b8nGd3RmKXEeg0YO44J+dnY1JkyYNS0OD0WhEcXExWJZFYWGhbBvsUCIf2hzR2dmJefPmSdJsQyGf/Hx6sUqJwmIZ2iLoH/E4YTIFSzqUvMjRbQDLloVLBlbvucd5E9DXp8Xtty90e30oMGNGFHJz7bj3XhtmzuQC1pgbKXkdcfMCwGcEaArq8OHDQkdXQkIC7Hb7mE27DRcpypF1ZGQkrFYr/vWvf+Hpp5/G22+/jTPOOAPnn38+LrvsMp/b/Nvf/oZly5bhuuuuAwCsWbMGX331Fd555x08/PDDbs+nFvAUmzZtQkREhBv5UJWIoWLs3V6EAFQQNFSGb4FEPna7HSUlJaitrcW8efOQl5fnc9/BEERbWxv27NmDhIQELFiwwOP8RbAkYTKZ8PPPP8NoNKKwsNCtvjMU8lm/fnhbiLVa+eNyprs8tV+Lf3oD/zpKPMIWPA6s0se9bzs1NbjzcuiQGnfeGS5JYe7f799Xe7S03dRqNZKSkpCXl4eTTjoJixYtQlZWFmw2Gzo6OtDV1YX9+/ejvr4efX19w6ow4i9GUl6HZVmccMIJePbZZxEREYENGzbggw8+wIQJE1BUVOTz9VarFfv27cOSJUsk21yyZAn27Nnj1zGsX78eV1xxhZu0z/bt25GSkoL8/Hzceuut6O7uDuzNHcVxFfkEMrsTCPwlh/7+fhQXFyM8PBwnn3yy3+GoL9sDMcRDnf4IjwZDbB0dHSgtLfUq9ROI9bcYJpMJ2dlFuP76HLzzTk7Ar/cHVqv8Z+6pNVurJbBaGSxaZMeRIywaGsRzPr6jFJWKiBoJvMGV9KT7aG8Pvh2eYYigS9fSwmLFCh16eoCHHrLid7/zfOM0VoRFxcV5nU4Hg8GAxMREt+YF2kk3GhYDoyEsSiV/kpKScPrpp+OMM87w63VdXV1wOBxuXXKpqamorq72+fpffvkF5eXlWL9+veTxpUuX4qKLLkJOTg7q6urw6KOP4txzz8WePXsCJubjhnwCnd0JBL4iH0IIjhw5gpqaGkldxF/4m3ajNtqEEL+HOgMhH47jcPDgQTQ0NGDGjBlejeuCiXy+/74Xjz6qwoMPjsP116fhnXcCeTW/QKemcujqYvxc7P0DJauaGhbz5zvQ0MAiIYHgiScsWL1aI8jjeMKaNWYsWxYOliXgOAYMQ0CI86cnAsvO5nD4sAqeScl/EMLAYHC+hkr7XHGFGps2mTwS0FghHzEIIdBqtcjIyEBGRoakHkI9ncTupQkJCR7rqaHEb0lYdP369Zg5cyZOOukkyeNXXHGF8P+ZM2di1qxZmDhxIrZv344zzzwzoH0cF2k3cZqNYZgRdRq12WwoLi5GXV0d5s+fj4kTJwa8b38IoqOjA7t370ZMTAwWLFjg99CZvyRhsVjw66+/or29HQUFBT4dUwOJ1qiT6Zo1JpSWJmHjxkm45RYtIiP9I8U//KEWubn9SEiw4pNPGoIiHu8dZvzfOjsZfPMN30Gm17OYN8+B+++3enw9fSw+niAlhcOcORxefdWM6dM5MAzB9On8756IhCceOThJSKUaekfhFVdEYPHicPznP+77G4szNa7HROshEyZMwJw5c3Dqqadi+vTpCA8PR2trK/bs2YM9e/agpqYGHR0dwyKFBYy+pUIgSEpKgkqlQnt7u+Tx9vZ2n9kSo9GITZs24YYbbvC5n9zcXCQlJeHgwYMBHR9wjEc+dHanrq4OiYmJwyaCqFKphJSe+OLr6+tDcXExIiMjhyRf48tGu7a2Fo2NjYIFdai2TdHT04Pi4mLEx8dj3rx5fk1h+0tqdXV2/PzzQQwOmvDzz/xA6n/+I96+t/QW/9jdd6chK0uP9vZ6GAzduPdePVatmguHw5+FgN/Gbbe14Y03PBGqfA1IrL02Zw6H//s/G1au5FOpy5db8K9/adDUxGD6dA4VFUZotQDDANddZ8PAABAdzf9usRA89FCYzPvzBQbOgHhosj9FRWpccYUa5eUGSXfcWIx8fBX25dxLXZUFgjWM83VcIx35OBwOmM3mgMlHq9Vi/vz52Lp1Ky688EIA/PFv3boVd9xxh9fXbt68GRaLBVdffbXP/TQ1NaG7u9vnzaocjlnyEafZmpqaEBER4ZdFczCgXwT6pSCEoKGhAbW1tZg4cSJycnKG3NAgRxBmsxklJSWw2WwoKCgIqtffW21G/D4CNZWTI58PP2Rx//1qvPyyHVdfzZuaTZ+eBGA23aPop+uC77zbz87mTdneekuDhgYWHR0qzJuXgMTEBAATMWeOFePGteOBB/y54PntUuKhqTH609fr1GqCVavMuOoqOxgGuO02/q46LAy4914brFbAtbTHMMBRDzsAwK232jF/vglLlrinTrwfh/Q8vfSSGe+/r0FrK4Mrr7Th9dcDb3GdMSMKb789KAypjlXyCWSRp80LSUlJAKSGcdXV1bBarcIwZ0JCgsdhTl8YjcjHYDAAQFDf/fvuuw9//vOfccIJJ+Ckk07Cq6++CqPRKHS//elPf0JGRgaee+45yevWr1+PCy+80K3JyGAw4KmnnsLFF1+MtLQ01NXV4cEHH8SkSZNwzjnnIFAck+TjOrsz3H479IvgcDhACEFZWRn6+/tDphItF510d3ejpKQESUlJmD9/ftCaWZ7qSdT0rbe3FyeeeKLQAusvxOSzbx+DRx9Vo7kZ6OtjsGqVCmec0YTXX+9FWFg8rFaqw+Z7gHP1ajMWLXKgu5uB0aiFzcZg2zY1li51vgetVos9e2I8bkMOKhVBZCTBpEkEf/qTDR98oEF9PYOeHtYrAWzbZsKcOc7PRlxaYBh34vEEGhTTOhDd59tv8/UieUgjsZ4e4I47rMjI4DBxIsGHH2rQ0xPIYsiT2c038/vr7x8Ys+QzlEVebBhHCBEM4/R6PY4cOQJCiET8MxDlhZGOfIxGfnA5GPK5/PLL0dnZiSeeeAJtbW2YM2cOvvnmG6EJobGx0e0819TUYNeuXfj222/dtqdSqVBaWor3338fvb29GDduHM4++2w8/fTTQc36HFPkI57dESsVqFQqoa16OEAvTHonRc3YQiXWKSYfQgjq6upQX1+PqVOnIiMjY0iLgxyx0eHXsLCwoN8HJZ9332XwyCNq9PayoJFNWRmDxYuTMDiYCbNZhbw8DrW1vt4DvzDeeiu/MM6fb0drK//F+PRT3vumtZXfRno6wfbtgS0Cb775K04/PQXJybFQq1W47jobDh9mcNZZERg/nuD00+14+WWdcBy+I6PAkJzM14WSk80477xWfP99NpqaGMTH+1vTYSRab/39A9i8efBoNOVvKk76nP37GZjNasTFHV/kIwbDMIiIiEBERISkeUGv17s1L9BOOk/NC6MR+RiNRoSFhQV983nHHXd4TLNt377d7bH8/HyP6fTw8HD897//Deo45HDMkA/HcbDb7bLdbMEqEAQChmFQWlqKvLy8kJixiUEJwmq1oqSkBIODg1iwYAFiYgK7u5eDa3qMWjn4M/zqDW1tOjQ06HDrre7ERQhw5IgzBXrwoD9dXNLH9+1zXpqdnYyb9w0d6PS18NJI429/mwyLpQJ2ewM+/HAWHnqoG6eeGoHycg46HYOWFgYffKBBRgbBtdfykVFTE4PkZCLRnwtW1DMjg6CiwoiWlsPYtw/Ys4dgwwYzxo8nCAsjMJv9FTIlOOssO37+mfczio/nMDDAILB7L377p50WBWAKfvhhO8xm84h0jPmD4WyCEA9zZmVlgeM4wRahubkZ1dXVCAsLk9hGUFuE0VBeoJ1uYy06DQXGPPmIZ3dc7a0phpN8rFYrysrKQAjB9OnTMX78+JDvg2VZ2O12/PTTT4iPj8fcuXNDIk1Pt81xHDiOQ3V1NVpbWwMyfZNDQwNwwQWzZf4i3zLs5L5gW4mdz6URiXOg0/N2wsIIsrM5HDoEHDgQi6qq+bDZ7CgqisSWLSZERPwKtVotyOIXFycgKkorNA3Qes6rr/Kac5s2cUOyvtbp+FTd118nYedONdasIbj7biuioij50PPivRb13XcafPedU9fNScT+ghFed+21h2EymbBnzx6Eh4dLIoBQXYOBYiSFRcXNC7m5uULzgl6vlzQvxMXFhVQd3l8YDIbj0k4BGOPk48vemmK4yKenpwclJSWIiYmBTqcbll57QghaWlpgt9uRl5cXUNHfHzAMA7vdjr1794IQgoKCgiFdzPv2MTj5ZH/TdO4EoVIRjB9P0NSEoFqm16wx46ab/HPTNJuB6mpnem7TJg0AftHeti0Nd9xxGgwGA7q79TAaj2BgoFKQeDGZklFeHo+339YJVtw0/UcIkJhIAtJUa2xk0N3NoLU1DN9/n3R0exp8+qkGgQqiMgzB9dfb8P77GtjtYiIODIQw+OqrDJx22iB+//t0oUhfV1eHwcFBREdHC8QcrD1CMBhNbTdPzQt0in/v3r2IjY0VCDrY5gV/QduslchnBBGI706oyYcQgvr6etTV1SEvLw9ZWVnYtWtXyAmOWhT09/eDYRhkZWWFdPsAryjQ3d2NjIwMTJ06dcgF0w0b+C+ac4AyMISH87YFlHj4SAbwNxL673/Votc5BznT0jh0dDAudRrpNvm6FA+9nhXZaqejv3+C4L+i1+uxaJE4wuXJoatLmv7r7x/wOyXndF/Ng3vXX2BDptHRBH/+sw0LFzq8NCv4h44OLTZsSIXZHIb16yfgxRdTsXAhB7PZLNgjlJWVjajCwFgSFqXNCwkJCWhvb8eJJ54otHU3NjZKmhcSEhIQERER0vMyGgOmI4UxRz7B+O6EsuHAarWitLQURqMRJ510EmJjYwGE1vANcM4IRUVFYf78+di9e3dIO49o4wJtQ58xY0bQ22poAHbtYvHiiyrU1fHHFx3tQH9/4JePwSCdxPefePgF+YcfVEhI4JCcTHD55TZ8+SVfm1m1yoznntNKPH/8gVpNsHo1b5Gu1WphsaTBbE7H8uWDWLmSzubwx0fJVqUieOMNvgWW6qn5SsmtWzeIW28Ng93uT9ef9/PR38+61cCGgm+/TQRtbqL23WFhYRg3bhzGjRsHQgiMRqNbkZ4SUUJCQsjUnoGxOfjqcDgEJeqoqChBiXpgYAA9PT3o6upyOy/emhf8hUI+I4RgJXLUajUslqGLVer1epSUlCAuLk7wrKEIVXRFCEFjYyMOHDiASZMmITs7W5AxDxX5UAI1mUzIzc2FXq8f0vacKtRO9Pe7RlDBKjUH9pqeHj7NpNcDK1ao0Nc3AKsVWL5cJxCPa1TkDa6t1M4IBfCUDnvqqRIYjb3YsCECn3wyFwCwZYv3lNzll9uRn2+SJQ13OZ5AEDqFbIC371682IHVqzWCLhzDMIiKikJUVJSguEzttKndRmRkpLDoBmsXTTGWIh8KuRthhmEQExODmJgYZGVlweFwCLYRtHlBXEeLi4uTrCn+QCGfEQDt9gpGEHSoxECtoQ8dOoT8/HxkZma67T8UbqZ0tqanp0cyI+Q6xDoU9PX1oaioCDExMSgoKEBXVxe6urqC2lZDA1BezuCmm+xYu1asQQaIU0RpaQRxcUBzMzAwMJSFkCApiaC7m29S0OnIUZsF9+hDrSZYudKC4mIWDAN89hl/KTMMweTJHM47z44vvlCjrk4FuQXaUyu1fITiPD6AwfLlc1wec0/J/fCDAU8+GSak4/bvZ3HvvdTvR0o2+fkcbrnFhnvuCeYuOdSpLyLU1K64Qo3+/gG3Z4iL9BMnToTNZhPSlWK7aFovCrQuMhadTP1ps1apVBLlBZvNJqTo6urqYDKZhDpafHw8YmNjfabBj1cXU2AMkA9NswXrMgoMjXwsFgtKS0t9tjcPdZBVrHhdWFgoSVOIySdYiMVNxaoLwapPA/IRjzsYtLUxuOgiO557zoElSzT43/+CJ9CuLudrm5oMqKxksXix+53ftm3SKIJ2fBHCNxnQRoPkZA7JyYM444xerFnDSxOJpXGSk/2PUKZM4aDXM/h//8+KRx/VyabQVCoO99xTgldeiceOHdl4550BTJ/uwEcfxaCoSI2wMAdycgZx881qfPCBBkeOMPjss0GMH08QEUFwyy1hPueLvM0g3XSTBe+8oz16bMFA2hyyaZMa+fmc1wYLjUaDlJQUoYNSbKd95MgRABDqRQkJCQgPD/f6HR+rkU+g9VKNRoPk5GTB4JE2L+j1elRVVcFms7kpL7ieF4V8hgmhUqIOlnyoikBiYqLP9uZgIx9CCJqbm1FVVYWcnBxZ4VH6RQuWQB0OByoqKtDV1eVm+haIAKgr3n3XhhtuUPs1bPnRRyqcdBJBdXUgn59rROKMalavNkOn45WmAXGDg/M14ijFtfWabuPCC+2or6+BWq3C738fhxUrdDjtNIdHaZzGRkbYp+vxXXSRDZdcYsekSQQLFzpkCWrNGgvy8ibh4ov5jsLPPotCYmIJNm7kW9PDwjg89NBh5OTk4Mwz7UhLI8IxXHGFHQkJg7jkEvduRJWKgGGcxOmqzkDPz5IlDlx6qQlbt6rw/PM6DCUycjgYSWehXBQkB2qnTYc6BwYGoNfr0dnZidraWmi1WoGI4uPj3Yacx2rNZ6jH5Kq8YDKZhA7DxsZGAE6Sjo2NRWRkJIxGY9DdqW+++Sb++te/oq2tDbNnz8brr7/uplJN8d577wmyO+LjNZvNwu+EEDz55JNYt24dent7cfLJJ2P16tXIy8sL6vhGjXzE0c5Imr0BTpXlw4cPY8qUKRg/frxfTQ2BRhB2ux2VlZWypCDGUCIUo9GIoqIiaDQaWavuoTRKFBZyeOmlTtx3n7eZIH6B7ulhcO21geWzPS2M4jrMjh383WZSEsGUKQ7s3KmGTkfwwAM6vPCCxS0CktsG/Wg/+0yDn35yNgfodHDrVpPWfKR49tkwPPssUF5uEB5z1Yqj3Wc0EjMYNHjllROE5/f2qnHttc7mj5aWVmi1zs6xlBQivF5Mtt98Y8Ls2ZygKSdWZ6ByQU1NDC67TLxQ+VLy9u87xzAEjz1mQWMjE7Blt7gukp2dDYfDIaSiGhoaUFFRIbS303rR8RL5eIOcjbaYpD/44AOsW7cOubm5SE1NRUtLS0CiwoFaaANATEwMampqJMcoxosvvohVq1bh/fffR05ODh5//HGcc845qKysDKqxYlTIh87vhIJ4gMDIx2w2o7S0FBaLBQsXLvRbjDTQyMdgMKC4uNgjKchtP1CSaG9vR1lZGcaPH4/Jkyd7NH0LNPLhtdpU+PFHFQBfw6ihyM3zCyFdcNvaGBQV8bUcqoBtswFlZc73t3evGq+/zne8Ae4kUF3NYvlyHW67zQqbLRIsywh1IfG8ztq1fLfa668TdHYyuO46C959l4ZD8u9txowofP+9ESkpnGTxr6lhwUtxeZu9cXbMPfroAezbVyvUCvg73iTEx4fDZmNw000WbN+uRlMTc1QJ4egWGCAnh7gpaVutQHJytNu+hgpCGKxcGYaVK+Gmih0oVCoVEhMThRsxcXt7dXW1oNnY2toKQohsKmo0MNzSOq4knZeXh5kzZ+LNN99EUVERMjMzMXnyZJx77rl4+eWXfZ6TQC206TF4slsghODVV1/F8uXLccEFFwAAPvjgA6SmpuKLL76Q+Pz4i1EhH+q5Eyr4Sz6dnZ0oKytDUlKS39YBge4DcErYTJgwAXl5eX6910AiK47jcODAATQ1Nfl0Mw2G1N5/n+DHH1U44YRu/PqrfLQWCNxTZlKymTjRgsLCLmzZkgq1mnO5e+chntHhmxCcQ5oxMQSZmRyWLXNGAD/+qMKOHWrs2KEGMPXoK52+Pa7R0n/+o8bgIIPmZv8WuiVLItHZOSBZ/O+/X4e//92/AdwffjBhzpxx4Lg0SefYwEAVFi2ah3//OxN6vQXffz8Ih0MlK2AqfoyKnK5bN4hbbgnzMMArthGX/p1hCFjW9+DvjBlRfqff/IHYwZSKgO7du1eI6BmGkbR0e7KLH26MdDQWFRWF3//+9/jHP/6BBx98EH/605+wfft21NXV+SQeaqH9yCOPCI/5Y6FtMBgEyaF58+bh2WefxfTp0wEA9fX1aGtrk9hyx8bGYsGCBdizZ8+xQz6Ae0g3FPgiBrFD59SpU4OSyKESON7gcDhQXV0t5FgDkbDxlyRcbRZ8tWH6W/NpaAC6uxn09/fh449jjj6WcLTTbWiXiacogD7+73/b8dprKRgc1ODPfx5Afn47Hn98vB9+PTyJ9fczqKhQYcmSQcyZ40BFBSt0jkVHczAa6fCp3HwNv43BQf43vjvOO8Q1KapcwDDAP//pPE+uhOupnZp2jg0MJECtZhATY8fu3fxn+vnnOsyevReRkVHIyorEjBnRPqfdL7/cDkBeKXvtWjNyczlZa4cffzQhMZFg/vwImM2ez3tkJIePPlILlgyhBMMwCA8PByEEU6dOhVarFVJRbW1tOHDgAMLCwiQSQIG2LgcLh8MxKi6mVF4nLi5O8OXxhWAstPPz8/HOO+9g1qxZ6Ovrw0svvYTCwkJUVFRg/PjxaGtrE7bhuk36t0Ax6t1uoYA38gmFJw7dh7dZIpPJhOLiYjAMg8LCwoDv0PwhHzqHlJiY6LfNgr+1JGdnWzKcEQJ8EA+/sD74oB0vvujPpSRd/FmW4MEHzejqcqbE/vOfSNxwA4s1ayx+TO87272XL7fI1mv41m9vNzqBqQsA0nqSeJ9isVNxAwR1Nb3xRhvWrnWgvV3r1mUnt53+fi3uvfdU4fF///tLSYrO03CnUylbGmkmJBDB2kFuFiozk3glHgAwGlnBkmGoKTg50BsllmXBsixiY2MRGxuLnJwcj6Zx9FzExsYOW3QyWhbatD17uFFQUICCggLh98LCQkydOhVvv/02nn766WHZ53ET+XAc5zak2dnZidLSUqSkpGDatGlDuni8pcXa2tpQXl6OjIwM5OfnB/UF8EY+hBAcPnwYBw8e9DiHFMx2Kex2O556qgkrVuQcjTY8LcjSn1lZgxgcDMd55zkQFsYPfcot3J6GJzmOwfPPh+P5550Lruu8jL+FcV6NQA6BXmee0lXSTjsKfzruzj3XLriaLlpUC6sVyMjI87kd8UzT6tVmnHLKKZIhRvFwJx1iVKlUmD6dQ3IyX4/68595DTjquApAUqtas8aGrq5wtLczOP/8cNx5pwWvv67167zNmBEVcgKi16rc9S2nu0ZbuisqKmC32yUt3aGUABotC22DwRDwkOlQLLQpNBoN5s6dK9hj09e1t7dLXEvb29sxZ86cgI6P4riJfAD+AlGr1UO2npaDXMMBx3GoqalBc3Ozz9qLP9uXIwmbzYby8nL09fVJ5H78ha/Ih+bW09LiMWsWh6Ii9y9YTAy/AKakEFxyiR1ffqnC4cMcIiNteO89NRYv9j4PRBdR16aA5cvNeP55neyCq1IRqFSA1cpgwQI79u1TgRBak5Bv0Q4M0nSYJ8THc8jJIbjmGn4Rb2mRzgZ5mwtyVU8AnLUZV/i3HRZxcXGIi4tDbm6uZLiTFutjY2PR2joOEydm4rnnbJg/n0gUugFIGhVmz96PpKRxeO65LOzYoUZyMkF0NPF7WDjUNSB6rfqz0Ot0OqSnpyM9PV2QAKLno76+HizLSupFQ5G6GY3Ih7Zjj6SFNoXD4UBZWRl+97vfAQBycnKQlpaGrVu3CmTT39+PvXv34tZbbw3o+CiOK/Kx2+2w2WwoLi4Gx3FDSrPJ7UO8iA8ODkr2M1QJDE+mb0VFRYiIiAja9I3WfOSkezo6OlBaWoqDB6fimWey0dnp+oWnNRUAYKDXM1i5ksXgoAU33mjGhg2x2LLFjnffteG663zn3ufOJbj2Wjvee0+Fpibgj3+04ayz7Fi82P0zWrPGjEce0aGri8GhQyy+/tqEzk4Gd94ZhqQkgpoa94VApSJ+K2V/9NEg7r47DOHhQEOD52aIzZsHceKJHBgGuP56+dkgCn8suv2RUPLX6ls83EmL9Xq9Hq+/HoGff9bhlVda8Mgj7UhISEBjYwqefjpKIoDKzzRFordXh40b+WtLqrLtPeoU6+KFCuK0WyAQSwBlZmaC4zghSmxpaUFNTQ3Cw8MlumuBNByNVvt3sPI6gVpor1ixAgsXLsSkSZPQ29uLv/71r2hoaMCNN94IgD+/99xzD1auXIm8vDyh1XrcuHF+16JccVyk3ehwakdHB2pra5GWloYpU6aE9E5FHPnQdF5qampIlKLp9sXk09zcjMrKSo+Dqf6Cvk686NE5p19+aUdy8lzcc484MhQvOK7T+wTLlztQXMzgm294wvjkExWuvtrmtTFBpSJYvdqOa67hF/Ebb+RgsRAcOQKPA518vceZijvrLOcX8LPPjFi8OFIgCLpIr1njzZJaun1q7nbPPTo0NGgRH09gs/FCpyoVh6wsgo4OBhkZRJgT8hS1UJdS15kb17oOhdxnuX8/i4ce0gmRlj/bEePIERbd3VFgmCj8+CN/Dn76aQIOH7ahpKQPn3yiw44dcVizRo/nnjMhLi4OM2bEAaAzSJ4/d0+Qi+yGCiqtM9T1gWWlUaLdbheiImoZERMTI0RFviwjaFZlpGE0GoOq+QRqod3T04Nly5ahra0N8fHxgtjxtGnThOc8+OCDMBqNuOmmm9Db24tFixbhm2++CTqiZMhoOCTBaZkQqm199913YFkWM2bMkOQkQ4X29nYcPHgQycnJaGhoCFk6j+LXX39Famoqxo0bJ3TMzZo1S5DmCBZWqxXbtm3DWWedBZVKJYiO1tdzuOaaU4LebiBimHv2WDF3rvQyI4QgPFx80Xquq1DQO+1FixxYvNh9wPKtt8xH1QG8O4GGh9vw5JM1yMkJx+2356CrS4XkZA4ffTQIlQqIjSWYOJF4jXJcYbFASGURAo+vPXDgAFiWxaRJkySPP/CADm+/rcWyZVa89JLF53ZcERPjXKDk1CAooqPtSEsz4Lzz6mC3x2L16lw/ugoppJ/Rjh3GkJOP0WjE//73P5x22mkh3a4rqGUErRmJLSPkrBHoMOxw2J54gtVqRVJSEpqampCRkTFi+x0pHPNpN5PJhJKSEgAYNuIB+Dsfo9EY8nQeBcuywoxDsB1znrYL8ARN6zvR0dG45pqTA97Wk0/a8Mwzao81GoCDwyEW8vSetlm3zoRbbw3302ZAeqctN2DZ1cUIEcjpp9vx8svuq/b27UacdloUHn545tFHnLM/4hbk/v4Bv4kHkJ+5kYP4Xk/cpv3xx/xXcfNmNa65JnDDOm+ND2IMDKgwMBCHV1+dDwC47779+Nvf5vm1jylTONx8s7T2FQqLcTFGKr3lahlhMBgklhEajUbS0j0aDQcGA6+kcbyqWo8tDYsA0dbWht27dyM2NhZhYWHD1vPf3d2NyspKMAwzLMQD8I0Fhw8fRlxcHBYsWBCyYTr6hWlpacHevXsxfvx4JCTMxYUX2uG/gyZBZCTBNddw2LlTPlq9++4i0OyASgVkZvKpq6Qk4jFtdNlldmzdavS6X0+gltSAc7GnqbQffjDhgguo+y2R/GRZBuvWDUKtFg9cOn+qVBweeaQCdXV1wh1xqEHvqGfMiMLixZE49dRI9Pbyj/X28t1+ixdHyraO79/P4vzzw7F/v/Sre/nldmzbZvJn70d/8u//xx8zjx4TkTwu/T//8+23zbjhBhteecWMyZM5tLczWLWKtxhftSrweqQcRkPXjWEYREdHIysrC3PmzMEpp5yCqVOnQqfT4ciRI/jpp58Ez57u7u5hcU2Wg5GXyzhuyeeYrPk4HA7U1NSgpaVF6DLbvXt3yC8KashWX1+PrKwsHDlyJOR5X1p/6e3tFVrCQ719AKitrcWcOXNgMiX7qVYtBoNrrrFj/Hh+9gdwb5/+29/mCQuYw8HXICj8memVS+OpVIBWy2FwkAXD8DWYoiLWa0RAIw5ah4mPJzCbbbDZgM5OHdrbGa+dZd9+24/MTC26uwdQXl4OjuOEO+DExMQh3xSII5/nnzfjscd0R5sk3OtrzzzjPlfmj3mdr0YF8X727ePTuhMmEPz5z7xo6ZEjfIdkaqoZZ5zRiG+/TYdeHwmr9QgGBmKwbl0Sdu3iJYm+/pr/PnzxhdovBWxfGAu6biqVSki/UcuIffv2gRCCmpoaWCwWiZV2TEzMsEgAUVHR0ZgvGgkcc2k3o9GIkpISITVFFV9DbaUtNmRbsGABGIZBQ0NDyLZP91FSUoLBwUGkpKSE/A7HbDajuLgYADBv3jxUVyfgjDP8IR73dNmnn6rw5z9zaG/nRT7T0y1YtKgGX3wxGa2tvOOne7qHIDubYMMGFosWcZBLl1OS6OjgFxwxoTkcDAYHnek9sdqzp/ZecRqoosKIxx7TYe3aMEyaZILNxuCLL9RISSE4cEC6wFHS6+7W4sQTncrDNB1Dm1nCwsIkisxDuRl5+GHPhVqHg8HDD4fhtttskvScnD5dayuDt97S4s47rULacdo0Bz78UAPfbej8Z93QwGLFijDBnA/A0YHU8Xj88UEUFXWjocGM8vIObNw47ugxODvjOC44BWxXjAXycYVGo4FKpUJmZiaSk5MFNWq9Xi+oUYuttH1ZRvgLSj5jQdtuOHBMkU9rayvKy8sxfvx4t2HOUJJPT08PiouLERcXh4KCAmg0GphMppCmYHp7e1FcXIzY2FgUFhbiwIEDId2+Xq9HcXExkpOT0dfXB51OFyTx8L93dgIFBc7USnq6AZMnD+DgQeDXX21YvFg+7XL4MIsbbuA/J7PZclS0VI1nnrFh5kxnquzzz9W47bYwnz40DEOwdq3n9l4aGVDR0U8+4S/xujp+YdywQYsNG+ixOmtTlPQuuyxCWDhpOoamZOiEvV6vx8GDB2E2m4U74MTERJ/SN4C069CbDptKRbBmDf8+5dQP3IdxgWnTOEktbNkym6wXkhRSlYjiYtfIkkFkZAR+97tUH6+XIhgFbGBsGskB0iHTiIgIREREuFlG0BsUnU4nqRcFMyIBHN8upsAo1nwCucCoX01lZSVmz56NqVOnut0dhYJ8CCGor6/Hr7/+itzcXMyZM0eoI9F5maESBLXR/t///ifkmNVq9ZCsD1y3f/jwYezbtw+TJk3CjBkz0N0dhW++8Td0l9YE5NJBc+Z0oKwsCT/+mAmVioXn75b0M96/n8GaNSx+/JHFxo3O49HpeC8bf2oWcXEE+fn8MGxjI4P9+1ksWRKOjz5So7iYFUUGGlx2WYQgSCrf0+n+3tatG/S4bzphP3nyZBQUFGDhwoVITU1Ff38/Pv64DqecYsWWLYfR2trql6375Zfb8fHH8vv7+OPBozptkNSo5Bo9oqPJ0fesRlUVi+Ji/tw4a2L+kcDKlWEea03SOplvzJgRhYGBgYAV1ceilw/geciUqlFnZ2dj3rx5OPXUU5Gfnw+1Wo2Ghgbs2rUL//vf/3Dw4EHo9fqAlfFDqdIw1jCqkY8/cv8GgwElJSVgWdZrB9hQycdms6GsrAz9/f048cQTERcX57Z9YGhpAbvdjoqKCuj1esyfPx8JCQmS7fsSLvVn+9SmW/werr/+DL9er9Px7cX8wiZ/wV911UH8+98TAQA//JCGoiIG7e04OhUPD6/jI4zCQidLbd6swhVXqMBxBElJkNwly9csnL5B4jv+m2+24pdf1PjlF6eNtvj5Tvj+AvNK0/7fAIhN0z74QIvSUh2++44gK6sMVVVVgk8Nlb6h1414MXH176E/6eMAT1KEmCVpLQqHg4HBIB8NVVUZhDTc//2fDU8/rQMhOHpu5c+PSkUwaRJv+y3uXisocGD1am9zVE6wLMHy5bXYv/9AwCoDYzHtBvgvryNnGUHbucXupfS68BYtB6NucCxhTKfdArEmGAr59PX1obi4GFFRUR6VBFwlfAIF9ffRarVuNtrA0EzfAKdMjtz2H3igBC+/PMtrEVqtJlixwo5nnlEfVTSQxwcfODXJ+vq0KChwbtOz0oH7fru6IFko+/sHJMOa//d/NqxYoQN/SuQL8o88YsHbb0tTaN7ajF3hr5KAJ4hrMZ9/zr/v779PxK23LkBUlA1qdS+s1nZUVlbCbrcjPj4eVqtViKIZhvF7QPW//6XXnLsskCctOJrSpGm4v/zF9zDg3LkO/PqrGk89pcM//+mMyqTRkPcW+j/8wY7/9//SwXGpGBgYQHd3t6AyEBERIVEZcI0mxmraLVh5Ha1WK+teqtfrcfjwYUHVnJ4T8c11MLpuxxLGJPk4HA5UVlaio6PDb2uCYMiHpsAOHDiAiRMnIicnx+OFTx8PhiDa2tpQVlbmlUSHQj5UJseTqdyZZ7YhM3MC7ror3uM27HYGDz0kJg5/BD2dRPD883bo9f6/Vpw2euGFdlitGmRkaCWL5W232VBSwkrUDSgcDt7gzHdKSV42x5uSgL+zK75rMXHo708UdMdogbqlpQXd3d3C3W9JSQIiItSSmSVXu4YffuAXPrUauPtuC776So3WVgZ9fe7XkngeSnyPI54F8vT57N/P72fHDhWKi1lh3khan5KPSunPTz9VIy1Ng8sucyAxMQ65ubESLbqenh4cOHBA0jWWkJCA6OjoMRn50HT7UI/L1b2U4zihXtTa2oqamhqEhYUhIiICZWVl0Ov1QZNPIBba69atwwcffIDy8nIAwPz58/Hss89Knn/ttdfi/fffl7zunHPOwTfffBPU8QFjkHzEDqAnn3yy39INviwPXCFOUbmmwOTAMEzABCcWHp01a5abF4YYwZAPIQS1tbVoaGjAzJkzPQqbsiyLLVsCbRH2/+7z4os5PPCAXMTjm4QcDgZz51Zi164BQR4/MTERMTExCAtjhcXTNUqhOm6+Ix3n36OjnbI5331nQnY2cVvwAf/amQH/lKgBqe7YwMAAwsPDERsbC71ej0OHDmFwsAIxMTHCe+flVBiZaAOw2+E2POtvBJeXx2HmTAeKijx/7enrHQ7GLTL11J7ufu4ZvPlmGN580/laQKpFB0ASBTQ0NIBlWYSFhYEQArPZPCQh0FCCaiOGuuXZk2VEUVERnn/+eTQ1NSEhIQHLly/HWWedhYKCAr+aFwK10N6+fTuuvPJKwXH5hRdewNlnn42KigqJssLSpUvx7rvvCr/L2XkEglGT1wEgWOZSNDU1oaqqCllZWZg0aVJAdxqHDh3CwMAAZs+e7fO5VLAzPDwcs2bN8vskbt26FSeeeCJiYmJ8Ppe2OTscDsyZM8fnHcyRI0fQ3t6OE044wevzKMSt4PPmzZPNDVODuJKSYtxzzwmwWFgAvFq0vwKc3tUK+MfUaoLrrnPgnXdUXhw05fd3/fVmHDyoxuOPG5CV1Ynu7m7o9XoQQhAfHw+bLRWXXZaN8ePhQUrHN1iW4PHHD+GOO1Kg1cpL1oijjIsvDkdnJ4vkZA6ffjroVW2guJiVXZA9Sc9UVFQgMjIS2dnZwmNU6uWnnyx47bVxuO66aixYoMJPP2XhkUfSZTsA1WqCZ54x4+WXdW4pux9/NCEjw/1YqYQP4D6n5Qv9/QPCe3WSnPebC5YluO46Ky6/3I6FC73fWNEooL6+HgMDA7Db7YIQKE1Jjda8i91ux44dO3DqqaeOqL7bI488grKyMmRmZuL777+HyWRCW1ubMF7iCQsWLMCJJ56IN954AwB/bjMzM3HnnXd6tNAWw+FwID4+Hm+88Qb+9Kc/AeAjn97eXnzxxRdDfl8UYyLysdvtqKysRFdXF+bOnSv4dQQCf6MSSnDBCHb6u4/u7m6UlJQgOTnZbx+hQCIfWqOKiYlBYWGhxy+Ec5j0JIi719zfgmdi8S57wz9mtzNYt87zpfTuu3bZWpBaTdDSwttdf/ppBF58MQ0tLePw/PM6PPywHlFRbdDrj+Ctt6oQExOGpKREXHBBAiIi4lBT42ww8KUxt3HjQWRn66HT8Xd9cvcaclGGawHf2+xKIPUj12uOSr388osOpaValJXNxhln1CMj4zDuvLMVr7wy320bq1ebUVDgwPXX82nKoiIWn36qxoYNZgnxyM0IMQzfMXjCCQ58+KGvO2mC9HReRic11Tm463AANhvQ0OD52uY4BuvX67B+vc7n3A+NAuLi4qDRaDB58mShrb22tlbS1k5TdCNVG6Lf+ZFOB9psNsydOxevvvqqMIzui3iCtdAWw2QywWazuWWDtm/fjpSUFMTHx+OMM87AypUrhcaKYDDq5DMwMIDi4mLodDoh7AsGvoiB1pE6OzuDJjhfBEFbtevq6jBlyhSMHz8+pKZvgJM8fdWo3OHteZ6JxRXTpnGoqWFkIxxXd0z6++CgCUAsXOsudjuDH3+UDk2uWqXFzp1qTJ8ehyuuiMSTT07DE08YkZ3NS5tUV/MdQzZbKpKS5gFg0NWlQlISgcNBoNezQTUSyNVD5FJorghU0do10UDJoaaGxTvv8AT9j39EYeHCPJfuNmkESrvO+vr6wTAMPvpIg5071fj0Uw4LFjhThXJ1KUKA6moVqqtVLtt2x4knOvC//6mxaZMGL74oHtzV4qKLbF7JJxjQ2opGo0FycrIgrOs62MkwjMTRdThTdA6HAwzDjDj5GI1GYZ1iGAZ5eXk+XhGchbYrHnroIYwbNw5LliwRHlu6dCkuuugi5OTkoK6uDo8++ijOPfdc7NmzJ+iIdFTJp6mpCRUVFcjOzsakSZOGdCfjrVVZXEcaLoKjrdoDAwNBmb75Ih+O41BVVYW2tja/yfPdd2248UZ1ACk2b+AXqMpKz19AutATwuD112147z0VGhsdGBwsRVJSAdLSWJx7rh1//aszCho82lDV2SmNMj79VI3OTgY7dqjx7rvhWL3a6VtTU2NGff0AVqwow8MPTwOggs3mwAsvdOHhh1MxbhzBsmVOIkhI8N7C3tjIYPJkzmMr8caNg1i61CHbiODaUUbrRxUVLG6+OUy2aUF8ncvN1NhsjExbtbt6xAUX1GH+/CRcfXU3tmzJEs4bVT6gjQKeBEdVKgKNxgGGYaHTcejtFYvC8qiq4heWTz5RY/58/trfsoVfNrZvVyEykoCXIPN0jfHDq/4OnXoq7IsHO+UK9eIUXVxcXEjTY6Pp5TPSrdbPP/88Nm3ahO3bt0vWySuuuEL4/8yZMzFr1ixMnDgR27dvx5lnnhnUvkZ9zmfevHlDCt0oPBFDIO3aviDnZgrwjn5FRUWIioryuygot21P5GM2m1FUVARCSEBq11deyaGoyI5Vq0IpuOo9z88Patpx5ZUOnHJKFerrm3HCCTNx440OxMaqUV7u6t/jvqjyigrMUfkWXpXg5pudC+pJJ6UA4FNo9G6+t1eNm2/mFc17eoAlS6px6aUJ0Ggi0dpqE0hODnIEIAZVPfDUiCBO4xUV8QSVlERkn+uqan399Ra88468bTVfM7Fh/Xr360mnA/75T96W4S9/iYNYndvfRoGtWw14/vlOfPNN7tHzQ6DT8fYQFEeFlaHXs27E3NPD+FE34rsSV670T3LHnyFTuUI9jYqGI0U3Gi6mQHBzPkOx0H7ppZfw/PPP4/vvv8esWbO8Pjc3NxdJSUk4ePDgsUk+48ePD5kkjiv5OBwOwRfH33Ztf/bhShA0DZabm4vc3NygL3JP5EPrRykpKUEZ1w2dePyp/Thx8cUcLr3Ugn37eM26U09dIDRbvPuuDcuWqb22+srvh0gWz7Q0Dm1t/DZc7+b5QnwL9uyxYdUqDW68sRwzZpjBsixsNpus8rk05eb+/u+6y+KiniCNLiZM4GsiDz6oQ2QksGOHGuHhRPa5YvgiPb5mIn8j497Y6RrVcLjnnhKUlQ2ioyMdQI5bWvTbb1XYtWu8ZBv8duWM5WTOjKhd3lt0LZYK8gWO4wKOWtRqtSRFRx1dxdprlIiCSdGNhp0CEJy8TrAW2i+++CKeeeYZ/Pe///Wr6ampqQnd3d1DsrAZ9cgnVBCTj8lkQnFxsWCB4KtI5y/EkY/D4UBVVRXa29uDriF52jbglMk5ePAgpkyZgszMTL+3Rbvcqqv9rTcRcByfQiIEaGlhoFYDTzxhx0cfqVBV5a2DTfrz228ZfPBBOcLCorBw4RxERjovsSuv5DBlik2iEUfhvfuKkTynrc3zQsDPuMTggQeSUVamRVGRFrNm7YfBYMCuXbvQ2pqB9evz8Ze/mLBoURgYxrvKNcBg1aowrFrlWVetvNyAVau0gsoC4Dmd+NNPQGurFt3dLJYvN2PlSh28LfCe61beP9tt20yYODEFer0ezc1tiItLR0qKBRdf3IvnnuNTdM8+6+l7Edj38uOP+Rmg7m75SOjCC+2CVJAvhGLIVKw8EYoU3WhFPgaDISgX00AttF944QU88cQT2LhxI7Kzs9HW1gYAwniAwWDAU089hYsvvhhpaWmoq6vDgw8+iEmTJuGcc84J+v2NesNBqEDJp729HWVlZRg3bhymTJkS0jsWGvmIyS2QWSRvEEc+dAapt7dXVurHF/y3TCB4+WU7briBg8UC0A7y/n4+rRMWBixZQlBYqHW7a544kUNdnQquC1VvL4Pbb18o/G42y8/JuLptZmURHD7svX1XpyMwm+W78uj2qC03jVK++ioKS5dmYHDQjFmzxmHzZgb/+18U1qzpBPCrMFtjs/F3za7NCsuXm/H88zqPBnqPPGLxMP3vHpGtXm0GIQRnnZXn8nzPCFR5wXkeVHj88VSsWBGHpUs5VFUNwmjsQU+PHnZ7H/7615kIhGTEJOh6jlJSCKqqjCgpYSWGfPRcfPGFGuec45/dQqjrK6FI0Y1G5EPVEIIZMg3UQnv16tWwWq245JJLJNt58skn8Ze//AUqlQqlpaV4//330dvbi3HjxuHss8/G008/PaRZn1Gd83E4HEPWM6Ogd7ZqtVrw+Ak1SktLQQhBZ2dnyMltYGAAP//8MwoKClBUVASdToc5c+YEXD9qaAA2blTh6adVPheudetsuOYa7x12TU3AySdrMX48wbXXOvDeeyocPsxg7VoLNm8+jE2b8iG3iKnVfO1n8mSCRx9V49ln7Zg/n0i2d+WVVnz4oRotLSw2bRrEGWeETkrEUwt2cjInzPC8914Henv7wDDdMJkG8MADp2HcOAeuusqMzZtj0NzM4s03zXj2Wa3XwUwe3mthdO6ntLQUP/2UjcceG+cxzSeOJNPSHOjsZP1qGomIIJgwgTd5O/VUO/75Ty1uucWKF1+U3gAQQhAb63tWjR7D3LkOMAxfoyIEyMriO/tWr9bg0CEWTzxhQWoqQU8P8NBDch16Unir/ZSXlyMmJgYTJkzw4/iGDnGKrqenB4B7iq6trQ0tLS2YN88/x9dQgBCCqVOn4qOPPsKpp546YvsdSYwq+XAcB5tN3hkzEAwODqKoqAj9/f0oLCz0awg0UBBCsHv3bhgMBsyaNSvkdt1GoxE7d+6EWq1GZmZm0M0RYWH+34l88YUVS5f6/vgtFgjdXIQA4eHifcgvMPPmcXj9dTs2bGDx1ltqZGRw+OQTnoAsFkCjIbDbbXA4ONjtvJLBhg1q3Hmnb1sFV7Aswdtvm2G3w+frPZFSV1c3Wlv1GBjoRk+PHhxH0NSUib/8ZSra26myueeoyNf+xOSTkJCArq4Jsmm+sDACjYY/P3o9//lffLFNaL6Qh+dBYE+Dsi++qMHKlZ4idoLERAu6u/m/JyRw+PzzQVit/DYmTuSVIcRDq+7H4g4aKV5xhd1j9EPPz3h/HAhDDHGKTq/Xo7+/H+Hh4dBqtbDb7Zg3b96IDZkSQjBhwgRs3boV8+e7z3kdDzjmyaezsxOlpaVISUlBc3MzzjjjjKD9MzzBYrGgpKQE/f39SElJ8dkJEigIIaiqqkJjYyNmz54dNLHxUQ+LFSvUHusnWi2B1covvp9/bkNKCr+gyBm9uYJ68SxezOHZZ1U+7tyByy5z4IcfWHR2On+/5x6HsAhShQsxyXpSDPAGsZqAp9d7qp3QdJi4JtHQABw5MojXXtPgv/+NB8CTSHa2Geeea8GPP0ahs5PFjz+a3Go6rudhyhQH9Hqn6kBJSQkSExMF8nEltGefHUR8PPDIIzrBDiIqioPBwLpt23u05S5ACjijjuZmBgsXRshqw3naFsWPPxolShBhYQRmM7wcizs8RT/Ug0os6zJaoCm6xsZGGAwGcByH2NhYxMfHCzJIwzXoSghBYmIiKioqMHny5GHZx2jjmK35cByHgwcPoqGhAdOmTcO4cePQ3NwccittaiwXHx8vmEeFEmI3UwBBd+U1NPhX66EulQBw4YVOkvZUmxFjwwbei2fGDA5fftmFpUuT3Z4zbhzQ0sL//5NP6NyI83f+MWDLFgtWrQrHU0+ZMX8+EWZorr6avxkZquK06+sff/wgnnrKfUhPLMIJ8KmlmTOjAEgLvYQA9fXheOstPq20detPICQBZnMKgEi3GlZ+PoeeHgaffTaI5GQiaceuqAjHSy/pkJDAITvbOZy6f78Kjz7q3kYvJR7Av85D74OyGRkEGzb04Pzz/RlzkO7HaVDHf7Z8h1xoFuGxJCxKu+iMRiPCwsKQm5srREVHjhwBAIldxFAt1sWwWq2w2+2KpcJwIdi7BrPZjNLSUlgsFixcuFDoCAmlmykhBA0NDaitrcXkyZMxYcIE1NXVCSQRCvT19aGoqAixsbE46aSTsH379qA7a/xvMpAuSgCwZInnc0Y75xiG9+ABgE2bAJ3uCIBkuN4Vt7S43pHLf8aXXKI7ui0N5s+3CjM0EyZwEsUAWlfQavlmA46jxnD8fmJjeaFQOsQopzjQ2MghJsY/UvPc/ux87htv9CAlJRadnZ04cuQI4uMXIz3djssuG8Q//xmH5mYWn3/uTjoAf139858x2LtXjWXLrHjpJYswnLpxoxq33x7mkWwD1WMT48EHLW4dZ+npDkREWGEy+WO3zePtt424/fYIWSUIHr7EZAluuMFztmMsmslRQhR30RFC0N/fD71ej7a2Nhw4cCCkg66GowNWCvmMIdC5l8TERLccbKjIR6x4fcIJJyA+nk+9eBoyDQauMjk0ogrWVmEoagYlJSw2bmTxxhsqPPqoHeef74xWxKRGW427u1X4299o8ZXBgw/a8NJLatGi6f0YVCqCiAhgYIDBxx9rcMIJHDZs4D/HL79UY8uWQajVQFISQWUli5oaFWw25zb5RZj/f18fKwiM9vcPHL2jH8SKFTrMmePAddfZUFd3BA0NJr9kcLzP/ACnnmrDww/H4pFHwnHnnTbMnGlHYWELBga6odd3Y84cCyIj48FxCfj111Q8+2wcnn7agqQkgu5uBgcOROI//+Frkl98ocY11zhngK66yo7p0z21fANr1/IKDN5JiF/8XcU/P/5Yg4cfli766ekObNiwFQkJp/phtw0sX27GlVdymDrV8zH6wp13WvHMM1aPfx9LkQ+Fw+FwuyFkGEa2i66npwcHDx7E4OCgoFSekJCAmJiYgG62DQYDGIYJ2ZjIWMQxQz6EEBw6dAiHDh3yqJsWCvIxGAxCt5mrKZvckGmg4DgOlZWVaG9vl1V3CHb7hYVc0DI6XV3A9dfzBe1LLtFKUnDiwVBP9gUvvqiBr5ZhMcTum7290sn53l5G0q6bnMyfj+hoDiYTI2uj4JpS2rKF1zmj6gJaLUFKilVWBsc1MvE+8wPs2MGfp8ceC8Odd9qgVquRkZEEIAmEEAwODgrK3G++GY6dO5Pw1ltd+OQT2n05TzhXgQiXAsBrr2mEVN3pp9vdrBUA4KOPePKMiyNYtMiBDz/kj/fQIRYff6wGIUB2NoeFCzkQQqDVEondtidSY1leYLSoiMWBA67k4N9QKgC8/roOl1xi99hyPRbN5PzJRngadO3p6RFSdGItOl8pOtpmPdaIOJQ4JshHbB+wYMECj91sQyUfKsWTlZWFvLw8ty/BUCOfwcFBFBcXA4CbTA4VLgyWfPxPu7kX38ULTnQ0wTPPsHjlFTUef9yOu+/mkJGhx9lnu9cG8vN7UFMTT9+BH3t2LlK+Bkopurr43w0Gz1Iu27aZkJDAL4xi9WaqLtDaGga12oyZM0V7YeTVrT0dr9tRMsRtMWcYBl1dkejujgLDZOHnn/nP97vvEnHttQfxwQe54DjW7RyIyTM5mSApiUNvL4P0dH5xbm3lh37Ly52pupISFi+/rHMTcc3IIOjtZdHbCxw+7Ky5EQIJyff3D0jcVMXHIweOY3D77Z6FTgMBjbKoKKp0P2Mz8gm0ick1RUcdXdvb23HgwAGEhYVJ7CJcU3QGgwERERFjjohDiVH9lP05sT09Pdi9ezdUKhUKCgq8tlEHSz40GqmqqsLs2bMxefJk2WMbSuTT3d2NPXv2IDo6GieddJLsnU+w5GOz2fDEEwfAsr5fO348h7//3fNslcEAPP20BgYD72xKxV/54+MXKZp+a2z0Jx9NkJ7O4fXXbZg7lyAhIbCGDdfBTvH+6fEAfK1m8eJInHpqpEBYNLK4/PKJuPhi/9tVk5MJ4uM5eJsdpov5TTeF4+yzndGL+Di6u/nj6O1V4733Jh0lHnds3nwEf/iDCQDfCFBVZURLiwH/+Y8J//jHIL7+2oSoKP69fvGFGiUlLNrbGSQlcZg7l8Orr5oxZw5fK0tOJrjhBivEFhrSn/TvEMgnI4PgrbcGoVJ5+mz4xzUaInqOf5GOHFQqDvfdtx979uxBdXU1Ojo6hHm/sUg+Qz0mhmEQExODnJwczJs3D6eccopwc1tXV4edO3di3759qK+vR19fHziOC0pah+LNN99EdnY2wsLCsGDBAvzyyy9en79582ZMmTIFYWFhmDlzJv7zn/9I/k4IwRNPPIH09HSEh4djyZIlqK2tDerYxBj1yIdhGNkOMiovQwv+WVlZPskqGPKh0QghxKcUTzCRj1gmZ+rUqV7nF4IhH2qMd845kcjMzJRVZabQ6Qiamlh8842TRFzvdl2Lx2vW9CM6eibi4wlycwn27XNGIIOD/ujGMWhtZbBsmQ033shh+/ZBnHtunFt3mCs8NQS4dog1NTFob2eQleVAQwMfVcgpETz2WC0A/1rYMzIILr7Yjr//nd7tyh2jeDF31lK8uZu6tj875YLasGtXK6Kjo5GYmCi08c6c6VRG9yTtU1c34JZGfOUVCxYudMheC+vWOdvKxSmuq6+2Y8YM77UcfirCe63JH/zwwyBmzsxFb2+C4OZaUcG7udrtdphMJsTGxo6Zu/5Qy+uo1WokJSUJklyDg4OC6kJdXR1uvPFGTJ48GVqtFocPH0ZOTo7f2w7UxXT37t248sor8dxzz+H888/Hxo0bceGFF2L//v2YMWMGAF73bdWqVXj//feRk5ODxx9/HOeccw4qKyuHpO4ytm4xjsJms6GoqAgNDQ046aSTkJ2d7deFGCj5dHV1Yffu3YiOjsaCBQt8FvcCjXzsdjuKi4uF9+FrcC5Q8mlra8PPP/+M9PR0JCbOw+uveyIDfuGiaaatW1kkJBDk5xPcfLP3OauXXpqLJ5+MR08Pg127bHj3XZuwEPoDlYrg3Xf5fXR2dqC9fR8SE22YN4/gtdcsmDhR/vN68EG+X5vui/7ctMmIH34w4frrbfjhBxMqKoz4/nv1UV8Z+Wtk06Z6nH12p89jbWxkUFTEoriYxT//6TRemzKFw7nnyp+ndevMeOUVZ43s8svt2LbN5GEPDHQ6O2bMsODVV82YO5ePVk47bRoiIxfj0UcXYv9+FqWlpdi1axeefLJWiDTkbLrXrRsU6jVFRSwuvjgc+/fL1WPEP0V/ORr5uEIcUdLjlv6U277/+PZbFb79VgujMQl5eXlYuHAhCgoKkJ6eDo7jUFtbi507d6K8vBwtLS0wm/0TJR0uDLe8Tnh4OMaNG4cZM2bg9NNPx/vvv4/MzEy0t7dj8uTJyMvLw+23347W1laf2/rb3/6GZcuW4brrrsO0adOwZs0aRERE4J133pF9/muvvYalS5figQcewNSpU/H0009j3rx5ggsqIQSvvvoqli9fjgsuuACzZs3CBx98gJaWliG7mo565OMK6tIZFRWFwsLCgHKt/pKPuHnBVzQiRiCRD21cCAsL8/t9+Es+hBAcOHAAR44cQWLiPBw4kISLL/a2fX7R6O/nf+r1/CKm1zOorna1OHB/HUBw0028xIo3cVA5fPaZDWefzeHQId5kb/HiGTh0iINWy8Fut2H2bCtOOy3arQX6hBPikZLCISODw0UX9WDjxnC0tWnQ3LwXZWXhGBxMQVtbEszmMHz8setlLD9gKQexR89ppznv+n0br7mfr40b1XjoIR1uv93q8bnh4RyeeqoDiYmJOPNMO9LS+HbsV1+NwN69Wsydm48XXsjCwMAAMjO7MW7cPtx8s7vKsOt8kqvdw6RJHBiGIDwcOO88G776So3BQYJJk5yvcSUfcZv6tGm0WcFXpOOe1vMVAYmVFWiTBXVzPXDgAObPnw+HwwG9Xo+WlhbU1NQgIiJC0sY8kkKfIyksqlKpsHjxYtTV1aG7uxtffPEFfvzxR3z77bc+mxSCcTHds2cP7rvvPslj55xzjkAs9fX1aGtrkxjLxcbGYsGCBdizZ4/E5ydQjDr50LQbIQRHjhxBTU1NEC6dPLwZylFYrVaUlZXBYDB4bV7wtH1/yKGtrQ1lZWWYMGGCx/qRHPwhN9p8MTg4iIULFyIpKXAvJPHd8wsv2PHii2qMH08QH2/C99+7p13ee8+OK67wNyKTLriJiQ6UlZVDr9cLJntUKWHFCgeSk+2yLdDTp3Oi7rQw3HUXgcVigd0+Hd3d3Vi0yJurozNKSEnhkJjo+ZyKF21vxmssS45KC3lezN94Q4u+PhbvvqtBdDSHgQFWtA3+fPT2anDRRU7dMqoWIG2SUIGQOCQmxmLqVH7/rqm62tpaWCyRICQRYWE6gYA3beKbLFgW2LPHiClTCFgW4Di+nhcT4yTc++7TIDKSkRCwuCNw+nQHHnlEfsGLiiIwGNyv68mTOSxbZsMrr2iPznx5bthYu9Y9oiGEQKVSISoqSmhjttlsQlqquroaNpsNcXFxAhlFRkYOa4puNIRFqZFcdHQ0zj//fJx//vk+XxOMi2lbW5vs86myNf3p7TnBYtTJB5DO1cyfP9/NO9xf+Ip8aFQVHR2NwsJCWW+XoWyfpgyOHDmCWbNmuX1gvuAr8hkYGMD+/fsRHR2NgoKCIetM7dzJNwHccIMFjY0H8ec/89P6vjqZ+I4sgp4egrQ0fgaipYWBwwHMmEGQkMDhxx9VCA8naGkpRnKyBQUFBULbOlVK2LRJjeees/nVAs0wQFgYg/37Y/DEE8l47DEznntO53Egk+q9XXihHZ2ddnR3S03c6OCsa2ecJzfT7dtNyM3lEBUFyWJeWcm/D4bh3UsBoLVVzp7avT3cbmeEzi9PNZ2qKoOEnN9/X42mJgYTJoTJqmP39sq3bxcXOwmGEm5OThSuuYaREDAVId2/n/VIPICc6gL/XtetMyMxkeCBB7zXAgjh3WPFDqf0JtR1oddoNEhJcTrZmkwmQWng0KFD0Gg0EjHQQL/XvjAalgqj4WI60hh18unv78f+/fsRHh7uNlcTKDxFPoQQNDU1obq6OuioCvAemVitVhQXFwuqC8FcON7Ip7W1FeXl5cjJycHEiRODvNNzJ5VDhxz4+eeDaGqyo7ZWzpOIwG4naGiAoP82fjxQV2fF7t17MHVqLlJTU1FbC7S3M4iMBC64gP/ya7VWmM0x0GhysW8fi/p6Fm++qUJ9Pb/vLVvUuPxyFgzDCnMfvlqg6UI5bRqH7ds9F8hfemkHsrKsaGxMBMdxkqYWsYqBp0VfTglBHCSzLP+7uNPNvf7h+TPats2EmhrWS3MCcMYZdo823TpdBp5/3ozHHtMdne9yj9T+8pf+o9ESg7Vr+fP2+usEO3bwC+kXX0QhIyNNiJrExndr19IF3LdiAcC3gsfEcOjoYPwaWAWcLdeUIOm17y3KYBgGkZGRiIzkG2wcDgf6+vqg1+vR0NCAyspKREdHS4Y7hxq1jFbkE2i3WzAupmlpaV6fT3+2t7dLNCfb29sxZ86cgI7PFaNOPgcPHkR6ejomTZo05NBZpVLB4mLx6HA4UFFRga6uriFbdqtUKuHuTHysVCYnLi5uSMq3cuQjjqaG6shK79j5hYKgocGMK66IAeBJKJV/jzfeyNd3xMOn1O8H4Alj1ixXpWugr0+LP/1pusx2nQv+aac5NdQ8DVl6ilTmz/cchc6dOxeZmZ3o7u5GZ2cn7Ha7oIzx5pvjcPfdMR49eiIjgUmTOK9KCBQ33GDF+vW0NhLYrJOvgdayMr75QaxILSbnhx/2HF1wHIMnnohFXNxuxMXFYuNG/nPg1bHp56PCs886Px85kdTYWIK+Pt/vy27nrbYvvZRv2vHlbip/zPy1H8g6oFKpBKIBeBFgGhWVlZWBEBLQcKen4xqNyCdQI7lgXEwLCgqwdetW3HPPPcJj3333HQoKCgAAOTk5SEtLw9atWwWy6e/vx969e3HrrbcG/L7EGHXymTdv3pBVAyhc02JGoxHFxcVQqVQoLCwcsukbvftxOBwCwRw5cgTV1dWYNGmS31153o5ffC6o6KjZbEZBQYHbnVBDA/Dkk3Y89ZTnTi8x6B08v1AwR4lHbqGQbot687hC3CYvb5HtXNAvuIDDZ5/RAUv3Bd+bzbKnSEWcHsvM5M9bayuD2FiCtDRWSNVER0ejvb0dcXFx6OjowPjxtXjttRSJ6R3FDz+YMHUq5zMNSPHKKxaPVtfy4N+zJzITw5cCwrp1vIOo3CJPP9O77io8+og/KgTSNnuAkSEe1+hZPp3oD/GwLMGzzzpvaOi1NJQoQ6fTIT09Henp6cJwpyf9tfj4eL9IZbQin2DU7QN1Mb377ruxePFivPzyyzjvvPOwadMm/Prrr1i7di0A/jt+zz33YOXKlcjLyxNarceNGycQXLAYdfIZLitt6miakZGB/Pz8kFw89ELlOE6w0e7o6BhyREUhjnz6+/tRVFSEmJgYj/WdQFQNpBC369rxn/8w2LzZ86Wwdq0d772nwuTJBPPnOxdNMflceqkVQBWuu849inI4GHz2mVThWgxPNsu0EP7YY2a88IJnN9FVq8y4+mr+9RaLu3oBwzBQqVRHZ8WywXEczGZpOzQt5Dc2WjFnjlr0uG8lhBtusGD9ev8+C5WKw2239eDmm2OxYgVvwpaSwiEigo/w5JQnXOWDKC6/3I74+EFB206Mjz8eRE8PI9KpC/R75qmLzTuBbdw4iL4+xiMpisFxDB5+OAy33WY7+nvgkY830OHOmJgYZGdnS1xMDxw4AIvFImlciIqKcts3IWRUBl9HysW0sLAQGzduxPLly/Hoo48iLy8PX3zxhTDjAwAPPvggjEYjbrrpJvT29mLRokX45ptvhnwzP+rkE0qo1WrY7XbU1NTgyJEjIXc0pR+a0WhEVVUVGIYJSURFwTAMOI4TZH5yc3ORm5vr8cv417/a8PDDwYmJAsC6dXZMmUJw7730MpDe1dIF+euvGfz4Iy8+Kk51UfIxmUzYv38/HA4+9eFaL3FGVvJ30Vu3qtzSS4C0vrNtm3x66ocfpC3Hvj4KZxQVI3m/dKG/+up4fPvtd8KwZ1xcnM+F5+qr7X6Tzxtv/Io9e/IlBX5a0ykpkfcimjnTgbw8+exASopT7cHV2vrssx1e03qug77eWtMjIwmMRt/X2WWXRaC/f8AjKYpBm0Io6CI/XJ1rrvpr4saFw4cPS1J4CQkJ0Gq1AiGORtotWIWDO+64w2Oabfv27W6PXXrppbj00ks9bo9hGKxYsQIrVqwI6ng8YdTJJ5QXGnUitNvtQRf9vYFh+OLtvn37kJ6ejqlTp4bcb76jowMGgwFz5swRviSe8MADwXb18IvNddeJi8pi8J/JxIkEej2wdSv/xVu7VoX58wmmTCFITOTrXgMDA6iurkZ6ejomTJiC1FRy1HLbjrVrVWhuBpYvt+O++zwfq2uHllz7MSU9Vy2zQCFVrXZPD771lgm5ubno7u5GVVUVbDabYB6WmJgoWzOYP5/DAw+Y8de/emM+/pw3Nkbgq68ihfdFC/yJic7PwFWRuqjIOb/jCjkLCbkales277/fgi+/JDhwQIfp0zlce+0g3n9fjcZGFfr6NG5E5CQe7wZ2d97JH6Mze+z5+Z98Moizz3bezIy0qGhERAQiIiIwfvx4cBwnNC40NjYKjQtxcXEAQrtO+YPfQrfbqDqZAnw+1ddsjj/Q6/UoKioCx3E4/fTTQ253SwhBfX09Dhw4gIkTJyIvz9ucSeCwWq346aefwHEcFi5c6Nddz0cfsX7aKEj1uFQqAq0WMJvlxSRdFx5Pd8Tff78VRqMR06ZNQ2ZmJgCp5XYglt6As17gul/X/b/6qllYZKlDqDe0tLSgvb0dc+fOBeDZ7VTsiArwn7nRaER3dze6u7vR19eH8PBw2aiouZlBYWEEenrcb0buv9/iokAtH2ls3mzCTTeFwWJhkJnJoaZGJTzXkx024G5zLq5RNTczWLw4QiCn997ToLmZwY4dJnDcERw50ouCghnCaw8fZnDWWRFIT7cjNnYQO3bEIJCU3VVXWbFsmU0ysOuJgD75xISlS53kMzAwgOLiYpxyyil+72+4YLVaodfr0dnZic7OTqhUKknjwnBbHSxatAiPP/44LrnkkmHdz2hi1COfoUKsnZaZmYnW1taQE4/dbkdZWRn6+vqg0WgETaZQgbabq1QqpKam+h1uFxZyePFFO+6/31cEJP3iOxwMvHniXXoph3PP5QRicyUelYrgpptaUV/P4YQTJgjEA0jrI9ImBN/w1X4strz21QjgD3wZyzEMg6ioKERFRSErK0uoGXR1dclGRZs383YQdHuUXC64wI4pUzi3iIu+L/q89es1UKkAk4k5SjxOuHaiiZsPpPUt6e+eW7WBI0cIoqPFlgpATo7z+Q8+GI4dO3y3WYvJZcMGLcxm19fIb4Om6CjGkqioVqtFWloaYmJihE5ZvV6Pjo4O1NbW+lSlHgpoKjvYtNuxglEnn6GEs2JSOPHEE8GyLJqbm0N4dO4yOT///HPIuvMAp43DxIkTYbVaA9q2tOEgcGl798iC38Z337G4916Hx4jK4WCwevU4AONQXV0DAIJqwbPP2oWmhMmTCWbNIti/X347cpGNt/ZjsaSMf5YI8vA3VeUKcc1AHBXRBclgiENiYgEyMjhcdx2Hf/xDK2x3zhzP7ys6mqC/n8E334hvIjx3k8k1H1CI1QrmzePPlSdyktN2k2tr518nJwQr13xAjrZze4dch+NY9vKJjo5GdHS0cBPS29srCIEODg4iNjZWIKPo6Oghvw+DwRBwq/WxhlEnn2BB1ZzpcKpWq4XRaAyZ0yjglMkR+/uEys2U4zjU1NSgublZqO/U1tYGlIKUb2/2H59/bsOFF2rdIpueHvjUblOrCZYvrxO63ahqgbgpYcMGVkbokoJIIhtqB7B/P4t77+VXR1+RSbDwFg34C09R0RdfFGNgoBt2uw2vvhqPmJikozMoYu8mabqtv1/uHMm/X1dNN1e4arx5g9xiL9fWLv6sAAbx8ZxsetH9uD3fED3zjMVN4WAsRT4Ucm3WcqrUtHGhoaEBLMtKGheCGZz/LdR8jknyodFCdna2ZDiVzsl4Uuv1F95kckLhZkrVEKxWKwoLC4X8caCq1oGKfLoiNRU44wwHtm2jKR73AnxYGGS7nNautSMhwYDy8lj09jLYvJnfxkcfqZCYCHzyCXtU2wtw95aR7mPNGl4GhxfY1KKoSA2djkCjAW66yYLt29VukYncHb4nyNl2eEtVBQNPUVF3dzsaGvj5Ers9DfHxkzF+PMHs2awP4U7X9+C5E00uWtm0SY29e1nccosNJ5/skHUNdf2e7N/PIj/fgYMHWVnHWAA480w7HnnEIkkvejlqj38RD8iKFQ7GGvn4M2AqNo7jOA79/f3Q6/Vobm5GVVUVoqKiJKKovt4jTbsp5DPMCIQkOI5DVVWV0L/u2g1GLxLxEGigsFgsKCkpgdVqlR3sHGrk400NYSjbdu1mkgPDEKSmEnR08DI47e38FL0nnH66A8uXO3DaaTq3tMs337D45JM5km0D/PDqihWu597zZ+xwMCgocKCyUupCyjC8e2lDA4v33x8U1J8pArnDDwaBkJsrPEVF3d3dWLfuO2g0BAkJ8bjgggxcemmOj63x5zs/n4NeL58alItWenv5Lrmbb+bPp5x6BCUf+l6TkghqalS4+GKbx9RZaSmLfftYqFT8zcHFF1uxYYMWwaR9AYJ165ypNzldt9FGoAOmLMsiLi4OcXFxyM3Nhc1mE6KiyspK2O12t8YF1zXQbDbD4XAc9+Qztj5pLxgcHMTevXvR19eHwsJC2TZkMfkEg97eXuzZswdardZjx9lQIp/m5mb88ssvmDBhAmbPnu1GkMGYySUn84SSnW1BRoYBUVGeX08I0NbGguMYDAwwuPBCLbq6PG97504ViooOIzLSKmyXfk+2bmVx663NgveLL+sCT7j+erPE/bOzk98OtXD59FMNZs6MQmUli59/ZgW/HXEbdnEx/3hjo/wxlJXpcO+9s4QU4P79LM4/X877xgknuQ1dpJJGRVOmTEF0tBaTJ+chLi4OPT16AOL0ljvy83nPn88+G0RFhVG2s2/dukGo1a6fgzPqXL7cLHt+CCFoa9Nh1SotduxQ4+uv+XNKW+vl0NXF4KGHwuFwMDCb+WgrOZnDnDkc7r+f3gT420DLQKM5iO+/70Fdnf2YjXy8QaPRIDU1FVOnTsXJJ5+ME044AfHx8ejq6sL//vc/iZurjXfrg9FoBIAhk49er8dVV12FmJgYxMXF4YYbboDBYPD6/DvvvBP5+fkIDw/HhAkTcNddd6Gvr0/yPDpyIv63adOmgI9v1CMff9DZ2YnS0lKkpaV5na2hA2rBuI1SOwdfMjnBuKXS+k5LSwvmzp3rsVsuGPJJTbXhlVfK8fbb4/Djj+nQ6cTmYfJdR5QwOM69k038WosFuPfefOlfjm6+uxtYvTojoGOV288777jOxrgvnoC7WKUnQVB6hy+OXP75zxgUFcVj0yYr5s2zSKImwCY8LymJeFS7lmtxloM/EROVeFGr+VqXVutAUxPVXHNGl/HxHD7/fBDJycRrWtCXRtzKlWFYuVJ6fhobGVRUhOHqq6cIz6MdkL29nm8kXK+Xr75S45lnLEhI4JXO//EPDeLiCDiO305XlzcyIbj22pnCb998w9s99/X1ITo6ekwQUSildcQR8YQJE+BwOITGhfr6elRUVOC9995DXFwckpOTA/Iyk8NVV12F1tZWfPfdd7DZbLjuuutw0003YePGjbLPb2lpQUtLC1566SVMmzYNDQ0NuOWWW9DS0oItW7ZInvvuu+9i6dKlwu90HioQjDr5eEu7EUJw8OBBHD58GNOmTUNGhu/FLlBycDgcqKysRGdnp192DoEShMViQXFxMex2u1823YFsu6rKhJ9+qsEddzg1yix+ZKDWr7dj82YG//mPp49frotJ/m9UvcC7cZsniwZnB9cDD5jw3HNyi6fzOX/+sw3vv6/x2oZNQVWcL7mEhc3GE9ymTfywqljFubOTwY4daqxbxx1NHx3d61Fy89biLAd/0oFlZTr89a/hgn/OPffosGEDT2733tuPjz7SoKVFheee24Ft22Lw3nvT8PjjAzj11AioVCofBOf5HIvPD5+qm+LyGvfP9pFHLBLzN1f09LC47TZnM0Vn5wDuukuHjz7SYulSG775xlszjPPYXn/dgLi4OOj1epSUlACAkJpKTEwcktr9UDCcoqIqlUpo0wf4dFtVVRW++uor9PT0ID09HUuWLMHZZ5+NCy64IKARj6qqKnzzzTf43//+hxNO4M0IX3/9dfzud7/DSy+9hHHjxrm9ZsaMGfj000+F3ydOnIhnnnkGV199Nex2uyRTExcXN2T1mNG/tfAA6srX2tqKhQsX+kU8gH+GchQmkwl79+6FwWBAYWGhXz5CgZBbX18f9uzZA51O55dNdyDk09HRgblz40XE41rUd+06cv687jqNiHiIy8/A8Npr9UhNJZg3j+DBB+WtpsePJ2AY3tRMDmvWmJGbK3ZUdce2bSa88orFo0X1tm0mFBQ4hLTcxo08kXR1sejr47fd28ti2bJw9Pbyv3d2MkJtY8MGLZYvN7vZVosXyHXr5IejqP32pk1qvPMOvz1P6UBCCD79NPKovYEWVVUsvv2W/yxYFjj1VDXefJNg61YbLrvsBPzyyxT8+ms03nnHip07d6KkpATr1lncUoK0fXzKFPnrZ9s2k0Q/b926QeG9eiKHH34wCQoEvqzTWZZP71VVsfjoI/7cu7eOy2PbNhOuugqIjo5GbGwsTjnlFMyZMweRkZFoaWnB7t278csvv+DgwYPo6ekJ6aiDL4ykqGhYWBhuu+02PPHEE0hMTMSXX36J6dOn45133kF5eXlA29qzZw/i4uIE4gGAJUuWgGVZ7N271+/t9PX1ISYmxq1EcPvttyMpKQknnXQS3nnnHbeGHn8w6pEP4N6N1Nvbi+LiYsTGxqKgoCAgcyh/yaGrqwslJSVIT0/HlClT/L7A/G0KaGpqQlVVVUBq1/7Uk8QW4K+8EoYHHkjyo9XaEyG53yH7CxrpJCTYcOCAFVotUFzM4MUX3Vukm5rYo8cuv60bb3TeOWdnczh8WHynyR9nU5MDMTEcqqpcbb/5nzU1rIsJXOAqzt7u8FevNru1BlOIC/4UrunA8nIDursZ1NZG49//5m9CPv1UI7E4cH3Njh1GfP01/5527pyAJUtiUVFhwL//zc9/bNpEsGhRE2JiYpGVFYmKCiMqK1ksXhzp9hm44vLL7QgLq8I110xzPyuiKFY8E3X66XYXpQYnOI4Rpfd8zwLJKTyItd2oICh1MqVF+4qKCjgcDqFo70nyKFQYTSO5hQsXoqCgAE888UTA22hra3OzX1Gr1UhISPDbgbSrqwtPP/00brrpJsnjK1aswBlnnIGIiAh8++23uO2222AwGHDXXXcFdIxjgnwoAqm9eIIv8hEv3v6m8gLZPsdxqK6uRmtrq9f6jhyosKgnUMfX3t5eLFiwAGedFYOFC+Vbrb2nwQDXRYFhOACeakCA62I/ZQpBR4cd8fE2oR5Bmx+ottubb6pQW8uTjr9zOjzxuC9ef/yjd7tzd/fRQBsgvD9fvH1x6q2xkcHy5byrqngo19UuwklQhZL5GXG6y/Xcn3pqpKiLkMWdd8YDiBf+3turxdVXTxV+37lzFxyOVKSk5GL8ePgcoKU3fK6djOLOOvFM1H//63kRvuEGC957T+tBQNYJPk3L/z82lkCrJcKxeRoypUX71NRU2eFeWkOjkkehJIvRNJKTOxcPP/wwXnjhBa+vr6qqGvIx9Pf347zzzsO0adPwl7/8RfK3xx9/XPj/3LlzYTQa8de//vXYJR+73Y6Kigro9fphs9K22WwoKyvDwMAAFixYgJgY7wuaHFiWhdVqlf1bIPUdT8fuiXxMJhOKioqgVqtRWFiI1lYtDh5kcOCA/Bc90O6z/Hwjrr1WI2tQFhdHMHEiwVVX2fHhh7xY6L/+ZUNfXy0AZ11j/HgIURDDAJWVDKqr1Zg40YG6Ou8LwhNPWLFiBSVRX4uXe31CrSZ4800TGhtZPPOMpzth3+rNd91lxqpVOtljkFMXkIt6xHA4mKPprkE32SBP7zMry4GmJtdZGzk4G0gmTrSjuTkNaWnNeOutGkRH65CUlIj/+78ERETEISLC/fzHxVmRmGhDVhaL8HCCn35SIzyc4LPPpE0O9Odll4mvZ+nNiG9Vb/55/OXNH/fgIIMtW0zo6OAt2P3pdvPUxq7X61FTUwOr1SrYJCQmJsq2MgeC0Yp8PEnr3H///bj22mu9vj43NxdpaWno6OiQPG6326HX633WagYGBrB06VJER0fj888/95l5WrBgAZ5++mlYLJaAanNjgnyMRiP2798PjUYTEittOfKhiggREREoKCgIupPEE0H09vaiqKgICQkJmDFjRlAXrKeaT3d3N4qLiyUpQnlpneBmLQAG1dXR2L/fcfQ4pCmbf/7ThpNO4jXAbr2VE9QAzGZg//5w3H+/RpDVaWsDursZtLUBmzbx5+DQIddUmfg98/vgawtiApKCEsYf/uDAli3ul+233/Zj1iw7SkpUHsln4kQOhw6xmD6dQ0GBHevW6dyOaeZMgrfeMkuK6BRy6gJSlWx3LF/Ok5W3jjRXpe6GBu+zNq7IyeFQW6vB9u0T8OKLqZK5opqaao/K3A4H8OqrDZgwIR2XXMI/FhlJ0NXFoLOTcevu86YIrlYTPPww35wgn+pzj+4sFl4Lj2L//sDnfFyHe6lNQnd3Nw4dOgSNRiO872A02DiOC7lWpC8YDAaPbdZiSwhvKCgoQG9vL/bt24f58+cDALZt2waO47BgwQKPr+vv78c555wDnU6Hf/3rX37ZxRQXFyM+Pj7gdXvUyYcQgtLSUiQnJyMvL2/IIa5arXYjn9bWVpSXl7spIgQDuZoPre/k5eUdNSwLbvuu5EMIQWNjIw4cOIApU6ZIBDy9OYcGQkJRUQ4YjSoQwmDrVhYJCQQpKQRXXmnHv/6lQlMTL0cjFp+k1xjLsvjqq0SJrI6cwZ2z1iM9pqeesuKf/1ShuZlBSgpw9tkOeLIMiYvjZX/oDIrrgq3RaKDVskhN5ZCQwEGvZ+FKyn//uwl5eUB0NBAbS3WzGMnzxOk1f2R9Lr/cDkLMuOkmd7KKj+dw1VVyDrBSTbvcXA4XXmjHV1+pUVPDghBGpDohfQ0P6fuqq+O/M5s2qXHGGXakprJITEzBlCnyGnRUmfsPf5gn2T7A3zh46u7zpbuXnEywdi0vk7R0qR0bNmjQ1uarHunEUOd8GIZBZGQkIiMjkZmZKWlldtVgS0xMlDWPc4XD4Rhyy3OgGIqXD8XUqVOxdOlSLFu2DGvWrIHNZsMdd9yBK664Quh0a25uxplnnokPPvgAJ510Evr7+3H22WfDZDLhww8/RH9/P/r7+wHwpKdSqfDvf/8b7e3tWLhwIcLCwvDdd9/h2Wefxf/7f/8v4GMcdfJhGAYLFiwImaCgOPLhOA4HDhxAU1MTZs+e7VaAC3b7lCDEiguhcDMVkw/HcaioqEBnZ6cwmCbGlVdyiI214aKLhvbFMBicl0B3NwAw0OsZPPkki8FBi6zmWUMDv0i1tITju+/49Ognn6hw9dUcnnzSjpUrVV5tuVUqgjfftOKaaxy4/347rFagooLFAw9oEBPDob+fdUuN9fRIf9K/zZnDobmZQWoq71aak6PCjh0WnHGGDhkZHP74RzPWrSPo6tIhMdGO8HA+bbd2rQm33houm8JjWYLwcN6au6mJhcHAE0VHB9/VRiMC2vLs7BrjyYCS1ubNg5Kh0ORkgvh4MyZMYHHddRw++ECDI0cY1NWp8PLLKtE2gJ4e6TmTpt/ki/m9vawkNdbfP+BVbeG++/bjtdfmwOFgfbauu0KuoYHWh5KTo1FRIX0/vrBu3WDIU1ziVua8vDxBg627uxsNDQ2y5nGuGI20W6gUrTds2IA77rgDZ555JliWxcUXX4xVq1YJf7fZbKipqYHJxHeQ7t+/X+iEmzRpkmRb9fX1yM7OhkajwZtvvol7770XhBBMmjQJf/vb37Bs2bKAj2/U/XwAPhcZKkHQiooKaDQaZGVlobi4GDabDXPnzg2ZPHlLSwuOHDmCOXPmCP5Bc+fODUnHjclkws6dO7F48WIUFRUB4At6nkLfQP1y/IVKRZCXR7B+vV1imy2/X991FFfs2jWIuXOl2/1//0+D1as1uOoqO77/nkVGBsH06QT/+IcKnuovb79txeWXO2QJkp93sqKkpBiEAPn5MxER4dT+A4CSEhXOPDPO67F68hQqLzfgiSd0+OwzDcLCCMxmBmo1wd13W/Hll2p0dzPYudPda+iHH3Zj3rwZiI2NASHAL7+wuOOOMEFPTR6BpVPF1hPeUFpaioaGRFx11RS3v/373y1YtCjCbeF19QeS81V64QUNnn1W5/f1cNllVvz97xZUVlYiPDwcOTk5fr7T4CE2j+vu7obBYEBMTIwQFcXExIBhGJSUlCAxMRHjx48f9mOieOyxx2C1WrFmzZoR2+doYNQjn1BDpVLBZDJh9+7dSEhIwPz580Oas6UNB7t370ZiYiKmT58esjsjlmVBCMGePXv82vbLL9tw//1qBF7n8Y6LLuKwebPKzTabQi7l5+pNI/2/lKCqq1k8+qgad95pQ3o6v2DROs6336rwySdmqNVAUhJw8802LFrkTuzbt5sFApNLNdvtRhQVFSEmJsbtPHIcd7SLSXqc9Odjjw3ihRfkPYXo4KW40YBKAdntkLQiy0nhqNUOSQpzyxYNampUOP10G374wVONx7lvfyzTfSlfi0Hz9K4eRIcPHwYh3W61ovZ2BpMnc3j6aQvmz+dkFcG7uli/iQcAPvlEi7//3TKi2m4syyI+Ph7x8fGYOHEiLBaLQERNTU0A+CFXk8nklnUYbhiNxhHf52jguCIfQggMBgO6u7uRn58/pPqLJ+j1ehiNRkyZMiXk229vbwcAZGVlIScnx+e2b7+dwwkn2LB4cahy0jxJfP89vwDQVBqVlsnK4p/lTU2b1mYAIDKSX+j5mgxBVhaHzk4GP/7IYscOFXbscBKCUy4HOP10J9ns2sUPdroujtXVLObOlY+W6ZR8ZmYmJk6c6HYeWZYFy7LIyGCQmsohI4Pg6qst+Mc/tGhuZnH55WaccYZFNipyOBjRPFBwnjvNzWrU1UmFVHfvFg/9yn/ua9aYsWxZuIy3TuDRJ8B/NomJDllvozPPnIm4OIOkVnTkSCpWrJiLjg41Nm1yYP58KxiGT5k++KAON9xgw9SpnMQHyHczDMGLL1qE4xktSR2dTof09HSkp6eDECIoU3d3d+PgwYNoa2sToqLY2NhhPU6TySSp7x6vOG7Ix+FwoKKiAj09PYiPj0d2dnZIt89xHCorK9HW1gadThfS7Yu9fQBg/PjxfpOaM00dTKeb6+v4n5Q8urqkvj5mM79INDQA1dXyzQ30tQCvSk3/9tlnZkRHE9hswOWX84t3dDSByQRJS7G45vD221akpEAgiGuvdeDpp9UCgV15pTv5tLS0oKqqClOmTPE5w5WRQVBVZRZaw2+80QyrFVCrWXR3+46KPJ3vbdtM4Djg/PN5CR0AghwOIQQLFqSKns2TrlMWiXH5m3Phjo/nBz5TUggaGhjYbAwsFt72Qq3mkJXF16VcZ3o8yfEQQtDVpfYSyUQdLcpno6oKePLJMHR3U8sG4MQTDyI2Ng6bN6fhl1/U+OUXqkgupy/o6dpkcMstvDLGWDGTYxgGsbGxiI2NRWdnJyZMmACGYdDd3T0iQ65Go3HYbbrHAsYE+Qz1gjOZTCguLgbLssjJyRE6NEIFs9mM4uJicByHmTNnorKyMmTbtlqtKCkpgcViwcKFC7Fr166A5EPoYGdcHIHVStDYyAtj/v73dnz+uaeUHL8oZGU50NDgribgmkrjpWXsglvpjz96u+uT/yx/9ztn3YouTgaD53kkcVrt228t6O/nCYIQPjX15ZdqLFrE4vbb7Tj5ZA6ZmRzq6uqEelxiYiL272fx2GMaPPOMzaPIpzhdpFKx4NcRZ1Q0bhyHa66x+hUViSMPscYbIRD+f/75wBtv9OCee+L86FRkMG4ch5YW3sJg+nROGPi0WgGNhj+HUVGAzQbhcdc0pCe9OUII/vWvWOzapcbHH3OYP9/i5m3U2MjIzjL19Wlx441zXR7lj11OWdvTdUFb0YGx6edDu90SEhKEIVeDwSCx1A71kOtvwUgOGCPkMxRQxWs6A9PS0oIe8e33ENHT04Pi4mKhBhNKt9SBgQHs378f0dHRWLhwoXDRBkI+dLDz4YdVWL1ajZtvtuOpp4yoqirCOedE4ZZbTpB5Fb8QSInH+bgrdu60Ye5cgvvuU+HHH1ksWeLA9u1swA6qajWRraPwkC5QNTX8/xMTgdmzXWVz+Airp0eFG2/k38PPP+9Fb28vTjzxROGLu3Ejn9rbuJEL2JNHLiqyWAg0GveoiB57To4DnZ0sbrtNh8ZG/rg+/lgttJp/8okaU6bEYMoUOzZuHHQZ2qRwdtxdd50V77zDR54OB/Dhh2pkZRFkZ3NYuJB/P3RO2nUgVM5gjip0t7bS7rhI/Oc/0ZK/idW7PRGP+Dh5+Iq65f+WkCBtRR+L5OPa7cYwjJuldqiHXBXyGeMQy+RMnz5d6F0PRFjU1/ap1M/kyZOF0DsUTqaA06I7JydHUpcIRFyUtjzzhWv+C/LppyxmzKhATEwykpImHt2mb6M5KaQtwzTFRt1KS0pYrFljlmiyeYNKRbB2rRX5+Zxs8wAPaQ3jhhuckdL69RbceCO1+3a/q77hhsMoLmZRULAQer0WtbX8X2gTw5YtamGRS0yET1sECp0OMtGTShIVXXmlFR99xEdFhw7x+ysvdy6gYrtpvZ7FPfecIn3XHuo0HEdVA5zin8884zwn27cbvRKqnMGcq3YccIKwfde/bdpkwhVX+Jv68RTpuF5v0sc/+UTain4smskNx5Drb8HFFBgj5BPonYHNZkNpaSkMBoObTE4oyIHWdzo6Otykfig5BGvVLbaJcLXoFm/fH4gHOsULzJ13FgqPJyXxPiuAAdXVdLDSOwllZxPcf78d772nwr59DK67TuOyD7gRj7di94MPVuDEEwlaWtIAhLvNiDjJUbqIqVQEjz5qQ34+h9hYoLdX/njXr8/B+vXu7bni4xWTntEor4wtB7noyTUq+t3vLGhrA374gT1KEL6uC4I777Ti4481SEggqK4W69m5/nTdFv/4unUarF7t2T9DrEbgGmmK/ZzkUqwPPWQJgHjk4KnOI308MXEQgPMaPhYiH28IxZArHQr+LZDP2Pqk/cDAwAD27NkDACgsLHTTZwvG7E0Ms9mMvXv3YmBgQNZmIZjUGIXdbkdRURFaWlqwcOFCN+Kh2/d32+++a/PqYHn33XZ0dfGdYU7i8Y1x4zhs2aLCa6/ZsXat+z7Ek/bZ2RxWrbJi7lwOsbHiQrPz58SJCTAajWhrK0V8vBn5+UasXNmF2bMdSE3lsGWLfGeYw8Hg6ae1WLQoXEQ8rlGLc9Fcv96C9estHo+XPscXeIsE/p84eqKPNTYy0OkgtEzPmBGJJUsivWjKuYJvFvjmGxNWrLAgIYEDvSFWq/l0lLcCPcBbQBQXs/joIzWWLHF3Zb38crtH+4nt203Yvl3+b6tXm1FVFVzNgpL99ddbBIKTA8sSPPRQNRobd+Pnn3/GgQMH0N3dDYfDMSYaDigIIUMiRDrkmpeXh4ULFwrf+f7+fuzfvx8//fST0MQk1osMFfkE6mQKAKeddpqbS+ktt9wieU5jYyPOO+88REREICUlBQ888EBQ2aYxEfn4C39kcoZCPj09PSgqKkJycjKmTZsme8dDL0SHwxFQYdFo5OdOdDqdV205X8rWYlx5JYe8PLOHVBaD117zZRYnD9r2+9prKqxcaceOHVYUFroP02zbZoZazWD5cg0efpivF9xyixYDAwzsdn4hjY7mkJCQgLi4eFx8sQOLFnWhv78L3d1dmDHDhKioBPT2ZgDIcYuEnnjCimef1XgozEshblDIz5c/J+LneMPUqc7X+hM9rV9vwc03a/2ogTkjzi1b1FizRuvyN35WiJcG8gUiSZOtWkXw3nvyJO7NXsG1m89dHdz3cWRnE9xzjxXPPKNFZycDq5XB9u2enVW3bzdhzpwM2O2pgtpCdXU1LBYL6uvrMTg4OOxWCf6Afg9DNccXHh6OjIwMZGRkSIZcGxsbUVlZie+//x5WqxXh4eEhee+BOplSLFu2DCtEOlfizjuHw4HzzjsPaWlp2L17N1pbW/GnP/0JGo0Gzz77bEDHNybIx9fdjrgV2ZdMTjA1H3F9Jz8/H5mZmV5ttOkx+QvqHZSRkYHJkyd7vZMKJPIxmUwoK6sFcBLk8uz85D3gOw3kCn4bmzersHmzCn//O7+ouS5iWi2wYYPKbWaHLqQOB1/zuOgivlaxc6cZjz2WjmeeSUJhIQeTyYSuri709XUiLi4dKSkWXHJJH776Kg1tbWpcfbUDZ5/t8ECuvmdbfHnaeIKYTDy1gItxxRUOj4QnHQx1fj60acEJKbnyxyx+3BXS+srXX/PmdeKGAbEXj5y9Qny8BZmZwPXXE9xzj28BSTls2MDXbVjWqeH33/+qsXix7xtA13rJrl27EB0dPSJWCf6A3sQORypQbsi1tbUVn376KVpaWnD66afjnHPOwdKlS/G73/1ONkviDcE4mVJERER4VL7+9ttvBaJMTU3FnDlz8PTTT+Ohhx7CX/7yl4B08MYE+XiD2KagsLDQZ/87jXz8rcmIbbTlNNRcQUNRf6IrQggOHz6MgwcP+u0d5G/NR6/Xo6ioCNnZE+iRufwEzOZgUxjShe3GG/mFac4cDtde68DatWq0tAAdHc6ifnQ0EbVOuy/Yjzxiw+WXa9HSwgr1k4iICEyYMAETJvAdewZDD7q6OnHyyRWwWoHu7nh0dWUAyHQbMo2LI+jtZZCURMCyBOL7EdfZoPfec4qX+gNvZLJ9uxmEMDj3XJ1sC7frcX77rRk7drRj5coJcDhYt3PjSbVg69YBGI0Mzj8/2i/yHByEmyCo2IuHYeCmRvDBBzswc2Y+EhLiERFBcMstYR73M2+eDfv3U+M753Ouusr5fRTXHV0jqKgoDmYz/7nJeQvR7+q4ceMQHR0t0aCrrvaszD2coN/DkahD6XQ6XHXVVbjgggswbtw4fPHFF/jll1+wdu1aDA4O4rbbbgtoe76cTP/whz94fO2GDRvw4YcfIi0tDb///e/x+OOPC+vunj17MHPmTAkZnnPOObj11ltRUVGBuXNd2+89Y0yTD21zDsSmQByZ+Hq+2WwWNNQKCwv9kg+n+/BFEHTotbu7GyeddBJiY2P92rY/5NPY2IiamhpB6XrdOhtuvlntY4Hy1HnkDU7yePNNK666ipeGuesu/u7moovCQaOcgQHn813x9tsWfP21Ci0t/JdYrvssMlKNyMgUpKamgBCCgYEBdHZ2wmI5gri4ZCQnm1FQ0I49e3LQ1aUR3Vgw2LTJjI4OvkY0YQJxawi4/nq77PyLP5CLnuSaEOQI7/BhBvfcY8PNN7fjv/+NxZIl7jc2a9dacMMNYW6kxZ8DQKMhyM11oKbGVwpV/tyL3zNVI6ADpxoNh88+i8BTT0XiwQetWLzY7lHihyceuh/5bja5xoaICH7YWK0Gpk93YNkyGzzdt4mHTF2jopE0kKOgnW4jWYcyGo0AgMWLF+Pcc8/Fk08+GdR2gnUy/eMf/4isrCyMGzcOpaWleOihh1BTU4PPPvtM2K5rFEZ/99chVTiegJ49TJDr+KBWAuI2Z39AL0JfNRm9Xo/i4mKkpKRg2rRpAd3d+KorDQ4OoqioCCzLBuxP5I18xC6p4i68a67hsGyZf0QCEERHA3/9qw233OJfiOxaK5GvcXgmNnHbNAB0dnrvPhPbKKenm/CPf+xEWBiLs84602Uf7nI8dFuui26gxONKJnLRniuJignvmmsGce21BvzznxkoK5sjaK25koxez8hGaePGqfHxx2rYbAwWL7bjz38249FHI+HrhoE6p3qCeOD0ggsI3norFn19LB57TPwZyZOLM8Xp3pUoF71xHAOjkf+censZ9Paqcccd/LkTWzUIe/XQau1NmXs4o6LR6L4zGo1Qq9Ue14zhdjIVW2bPnDkT6enpOPPMM1FXV4eJEycGvV05jAnyEUMcMfiTBnOFmHzkICY2X/UdT5Dz9KGgTQvBkBrdthz5WK1WFBcXw2q1BuWSSrF7t+3/t3fe4VFU6x//bk3vHQIkEEhCAqQHUCnipUOComKjXLBwLRfsVwUVC1dBftgBRRG9CBKKFEWlF5GSTkISCAkhhPTGZrN1zu+PcSbbs5vsbjYwn+fhiW5mZ89uZs93znnf9/siJoagsNBUTYZpPy5T21I05gohTGafNTc3IycnB337hmDIkCEGRU/zLvvzzyUArHMHrLt60lztmUpCqKjgoapKgeLiIhw/Tm9B7NwpxqRJMvj6EvTpQ/DEE0rWJigvj6/1Ovfco0Z1NW3OuXMn/Zq7domxY4can30mxTPPmHZnX7dO383aUMHpDz8IIZWG4/JlzZWOYa86Ho/g9dfl+OwzMZqb9f+2jOecrrAChrMw33hDrtWagj7O/MwyQ6uixsZG1NXVWXVV1FNdTF1dXY1+DvboZKoJ03ju8uXLGDRoEIKDg3H27FmtYxhPSkvOCziQ+PB4PDYjTCgUYtSoUWZvg+mex9jKpLvCxmBs2+3atWsoKiqyeLWmiSHxkUgkyMrKgru7OxISEgwWqtEO1513vmRWAYwtT02NfjBc42gAMBkrMRWP6N+fQmUlz+jvly9XYM4cwyJeU1ODgoICREREoH9/Oq5lSvTGj69Dnz5/4c8/XREQEAB/f/9uG0Bq3nyam4RAZ8q5AEhlRaqujtmiBBobeUhIULM2QQcOCFFY2LF6GjpUP9Ourk67ANTwZ07/7Tw9VXqTuKGCU4mEj82bI3XOYfjvRAhjpmrIsw2s55yPD50kwecDtbU8rQJbTd591xnvvkv/N7MCYtpcWPr30lwV9e/f3+SqyNfX16Kbts4KTG2BqS6mgO07meqSk5MDAAgJCWHP+95776G2tpbd1vvjjz/g6emJoUOHmn1ewIHqfGpra9k2CMnJyV0SHgZD4tPe3o4zZ85AKpVi1KhR3bIs1135MI3fSkpKkJCQYNVuprW1tfjrr78QEhKC+Ph4oxXSTz9NYeFCU1l+BO7uKjbYy9jyPP64CppV9No/CRYsUBpsDcBsS8XFUXjpJSV7PP0e6J8VFXzce6/xMdGts3VGSQjKyspQUFCAYcOGscKji7Z5JZCVFQAvr/GQSqNRXk6Qm5uLY8eOIT8/Hzdu3IBSqTR4HoasLD6mTHHSq5dhmDNHjaNHDW9nHT0qw5w5ajQ2NuKFF7LZ5nL6d/00d97p8nfjvo7V0513uiA62sVgnZJmBpynJ/2Zv/22AkIhgVBI8NZbMsTHqxEQQCE6WgWVSgWFQsH2ydqwQWrgnObT0SxP//rw9OzwnBs3To1LlwQYP16N7dvb2WO06RDsr75qZx9lrvnuxleYVVFUVBRGjx7N3mTW1dXhzJkzenVFpuiplY81eo9pdjI9e/YsTp06ZbCTaVRUFLuSKS0txTvvvIPMzEyUl5djz549mDt3LsaMGYPhw4cDACZOnIihQ4fiscceQ25uLn777Te88cYbePrpp3tfG22A/iMzGWGmUgDNRVd8GhoakJubi6CgIERHR3f7bkZz5aObjdfd/WZG2JhJuLS0FLGxseydhylmzKCwcaPh323fXo7g4HqEhtIX0dWr9MQ3b54SW7cK/k4Y0GbjRjnmzNFf4TGWM1u2KJCaSqGqiofNmwXw9wemTFFi+3Yhrl4FAB4OHtRtFUD/pNt1a5+XiWnV19cjKSlJr4AY6FiF6U6iTU3AuHEeADwA9IVEMhgtLS2or6/H1atXUVBQAC8vL/j7+yMgIABubm5aE50lPnCGkhCqq6tRUFCAJ5+MwqxZhldnrq506jtFGV89zZmjhpeXHLNn6998jR+vxuuvKxEcDAwYQPDMM7SwFxbycfgwD1u3KhAeLoJarWZdOCiKwr33tiMiQom77zYv6aUDAk9P4Jtv2jF7tv6K4dgxKTw8aCftujoeu6X3009ChIer4elJYMzjV7fnkC0yy7q7KuqJlY9UKu2SH5whLO1kKhaLcfDgQaxduxZtbW3o168f7rvvPrzxxhvscwQCAfbt24fFixdj1KhRcHNzw7x587TqgszFIcSHCcxbq6mqZrr11atXcenSJTYzzBowAsFUKnt7e1utaR2fz4dKpUJ+fr5FmXL0ZI+/v/D6wf/6eiFCQzsEWdOax9h2Snk5H4D+RMxM1BkZtMElEx/x9XVFQYF2EkOHMwF93oAAAh6P4PBhudaKirFMUigUSElJMbry7duXYP16OZ5+2njCw4QJKvB4PHh7e8Pb2xsRERGQyWSor69HXV0drly5ArFYDJWqLwC6a6U5PnDGUrgVikoUFhZj+PDhCAgIQF6e4YmD/o4b/p1mUoch4QGAQ4eEOHSIHuf27TJMnUr/bXT/HsyEyQiQ5o2YsV5AhvD0BHbulKKsjD6frujyeEBCgv6WXmMjH6+8oiu+prMru7rtZgmdxYqcnZ3ZpAVvb+8eWfl0tu1mCb6+viYLSsPCwrTm3H79+uHYsWOdnnfAgAH45Zdfuj0+hxAfgL5Lsab4KJVKdgLvTnzH2PmbmppQVFSEgQMHYuDAgVZLxySEoKqqCs7OzhbFvfTFRHtSXry4HwYM8MOWLTwkJFDYuFGGJ590MmnrX1DQ8Z7ooDVQVMTH11/Tl83XXwuRmEghKoqu4UhOVuPcOWNO2R3B7G3bZGhups/Zvz9Be3s7tm69jI0bh2HNGiGcnU1PQI8+qkZMjPGEh7w8AbKz6ddlBMTZ2RmhoaGore2P1auFeOmlesyYoRkg7dzJQDcJYcECJQoLL6O+/joSExPZmwRj4mEoI9BQkeyqVXK89JLpLYz773dmG+0ZF076cxQIBAgN7TBDdXMjOHmSrtlxdiYYNkyFc+f0Ew9aW4F77unYAnJ1BZ54Qo79+4W4coWP6mqeQQ+5zt879Gp9mDRre6U1m7MqcnFxYc1C7dVfx1rbbr0BhxEfa1NSUmLxBG4OzB1Te3s74uLiTLotWEpLSwtqamrg7OyMlJQUi+66vv1WiUWLhH+nvBoORl+96or/+z8Vamv5+Ne/FFi3Ts4WkGri5ga0tQEnTgiRnU1PZoYmeqWSh0WLzN3npcekmxpdVXUDOTk5OHEiEdnZ3vjpJyVSUkzHZzrDkIAwW4UBAQTHjwsRE+OHZcsUeOcdETQzvDSLP9eubQYhYq0JkdnWpigKFy5cQGtrK1JSUrQmp40b5XjiCbFZLa+Z12Muo6wsPvbuFWLBAiW+/dZ0AknHe+xcONVq4Mcf5RCJgPR0enXq5aXGrl3t+OADscZ59G9GhEKCO+9U4+hRIaRSHsaOVaO4WIDDh4X48EM5IiONW+kYeMd44QW5Xhyxp01FDa2KSktL0draijNnzuitimy1IrLmysfRcRjxsdYdT0NDA1pbW+Ht7Y3k5GSrXtBKpZJt/Na3b1+rCg/jW+fl5QVXV1eLL+6HHqKwYIGxz7Dj8d27BVCpeDh+3FCrY5q2tg6h0JzMOq+077xwVdv1oBHbtl1Gv35ROHzYHwDw449CnDnDx7/+pcQddxCj7Q+YLTAXF3oFpTku3ThKRQXtc3f8uAAuLvT5MjIYCxjD49248QL8/Stw7BgP/v7+uHGjLz76KAjvv6/CsGFy5ObmQq1WIyUlRc9SpPNUdLCvKxDQBbzMZMxsoQUGdrYLoL+6NWUBpOlXx4hVS4sAd9/dYTjLuEbo8sUXUrz6Kv183f5EDz+sxKlTzHfMvMLljz5yxptvat9gOEoXU6BjVeTp6QmRSIQhQ4ZYLYOuM6RSKbfy6W1oWtl4eHggMDDQqsLDpDu7ubkhODjYKvEdgB73pUuXUFFRgbi4ODQ3N0MmM14kaIq33lLhrbdMj4veZtPFeIqtJp37o5k/eWzdWo7Zs8MBMP1tmGJEICuro0mc5t27bm8dZgssJ4dncKLfulWO4GCiNfG2/51gVVfXsV0FdMRCmJ8REREYMSKcTVrYtEmNEyeE+L//q8aiRflwdXVFQkICRKLO0ttNx1aOHZPBzw/sNiEzpiNHBPD0pNDayjfyXOOftSEDVe3VmOFtVkPCAwBPPNExGer2J9Je8XRdPByxlw8T87E0VtSdVdHt0k4BcKBU6+6gVquRl5eH8vJyJCcns95Q1oJJdw4ODmbrbKzRzZRpsVBdXY2RI0ciICDAon4+ujz6qBq+vtaJm2ni6tq1c3akQ3ekXzM/q6qq8NlnTWwKsKEJcflyBdvCICuLjwcfFP+dkUZ/uTXbGhh6jdmznfW2pow5MmhmnwUFUQgMBCorBSgv94VEMgSnTtHJKocOBaC01AtZWTzs2ZOL4uJiNDQ06P3NAgMBX18Cd3fghReUiIrSTg1nPpuiIj6io13YdOv6evqoxkb8LTz0WF98UXslo4nu+9aFEILk5BL8+985Rs6g/9lPnaqCszNBx+dmHXg87RRrhp7edjOEoWw3ZlXUv39/xMfH46677kJERASbqXnixAnk5uaisrKSzSKzBIlEctusfBzmr93VJbdUKsVff/0FmUyG0aNHs3ce1ug2SghBaWkpcnNzERMTgyFDhlitmykzbrVajZEjR7J3O905d2go8OWX3YuXGKIL3yEAwIABFLy9CXx86NqU//u/dgwZIoGPjxxDhsQgLs4Z69cbdzhYsULM1r98/LG2N5xmbx3NmqNPPlEgLo5CUBCF1asVBsTNEB3bVRs3ynHxogx9+xKDotDSIsazz47G88+Pwdy5Y9jC5aNHjyI3NxfXr1//e1uWYPZsFSQSHqRS4Oef5QgMpNO4P/lE8XeDP+DYMb5ZPYjS0+mbHUa0GKHx9SV671tzN5gQguLiYlRWVqK0NIp5VOenNidOyDBgAIFMxsP48ebeZJknUq+/LtdzYAAcU3zMGVNndUWnT582u64IoOcFDw/ze2/1Znr1thvTqiAkJARRUVHshdLdhnIAvSq5cOECmpub9bqlmrLXMQfGkVp33My5uyNsDz5ovqW5YQh4POik4xqauI3t73dsM5WXM9sPPPz0UwteekmNpUuvIj19IIKCvDsZh/a5MzI6trcMecNpZqHFxVF4/XURUlMpHD3aWeylA1MedroFn0xcZejQoSCEQCKRoK6uDpmZ9aiqqoKbmysyMuL/HrsAjzyiwscfKyAUAiEhBAoF/X727hXiySdlWL9erueBpzmm69cNe8AdOiRHWBgxaKBKURQOHryE69fliI4ehZMn6fPTf1/Aw4M2hNVNv/79dz67/ffnn8zfUP/vrZ2pZ97NY79+hkXKkWI+DGq12qJkJWu4Ldgzs66n6ZXioxnfiY6ORmhoqNbvBQIB5PLOO1YaQyqVsjY/o0eP1gsod2d1wljwGKs76q74fPONAgsXirpUyU7DTELGcXWlQFG8v3sF6cY0tCcjgYBg4EAV3nlHipycEOTkuOPRR1U6Pm1dGSMN4w2nWVz9448CnDhBF4wyqcf69S0dYzeWSEEXfDKxKW00hYrH48HDwwMeHh4YNkxz4uiwx9EXwI4Yl/bvDI/JHKduTQNVZit61qw79F6TSRi4eZM+f2QkhTlz1HjrLfo6f+cdJ/bYjq+R9jalWAx4eVFob+dBIjGv+Z27O8GYMcY9Fx1x5dOd+E1XYkXWynZrbGzEs88+i71797IFph9//LHRc5eXlyM8XP86B4CffvoJ999/PwDDO1Q//vgj5syZY/EYHeavbe5dj0qlQm5uLq5evYqUlBQ94QG6t/JpaGjA6dOn4ePjg+TkZIPNkbqy8qEoCoWFhSgpKUFiYqLRgtfuiA8hBA88oMTx4/p76mY8W+M8hgLSHVs+X399FX/+2chuI61Zo0BUlOExjx4tw6VLIpw5Q9uuZ2SIkJ3NQ2QkhU8/NR7HYF6rw9pFn7AwCkOGMFY+hltf19Xx4OtLYehQepwJCRT8/Sn4+xPEx5verrp06RKuX78OoPO4CoPmFprhwD5l8Hd8PoFIRAtPfLwazs70e+/w3tOOcZly6lYqlcjKyoJKpdKy1jE8HqCoSIC33hLDw0PzvZla0dDdSuvqBBrCY3or7+DBFhQXNyEgQA6VSqV3jffWbTdz6SxW9NZbb2HixImQy+VsW4Xu8Mgjj6CgoAB//PEH9u3bh+PHj2s5VuvSr18/3LhxQ+vf22+/DXd3d0yZMkXr2G+//VbruPT09C6NsVetfDRXJKNGjTLqJdQV8dF0u+7MDcHS81viSN1V8WEq2ennduVujWfUGt/JCQgMpODqSqGhAXByqkNl5QVs3OiMPn38ERgYgKQkX4wZ46rnbHziBH1XL5fT59XdMjP+fujjt2+XsaacupSX87FliwAJCZTR1tezZtHbJo2NwJNPyvHEE/SKAYDRVQRzo9Dc3IyxYxMtakxnOs3a2BYmnUnI/NmLivhob6eP27VLgMmTTV8PmlmAMTHtyMrKgrOzM4YPH47kZGDoUFPj6UAiMfkyBtAUNcMZdMz14OQkhpubknVdYBKCeDweezPniNtuthJE3VWRr68vRCIRtm7dildffRXr16/HlClT8MADD+COO+7o/IQadKWLqUAg0HOl3rVrFx544AG91ZK3t7fFDtaGcKxbDRPU19fj9OnTrPGoKRM7S8WBMQYtLS1FUlJSpzY8lmy7SSQS/PXXXxAKhRg5cmSn+7ldER9N4eHz+QgK4sHfn9K44zXrLHrCw9zly+U8XLvGx/jxBCUlCkyeHItx48YhNnYw1GraCujKldPw9VUgJkb+95i0764NFS4+9JASxu6U6b40co1J3nC2GJN8sGyZQs/QUzdoTz+PFhljqwgmA1EikSA5ORmDB7vg4kUZjh+XY+FCFY4f70hIMEZ+vu57Nxf6+HaNhesPP4jw4498/PorHxUVhidnpjZo82aCc+fOwcPDAyNGjNDbMtLMPtRE3wjVXIyLKfN4dDS9qgwK4kEkEsHJyQlisRgikUir/YlcLgePxzO4Kuop7GWvw+PxEB0djWXLlkEoFGLHjh1YtWoV5HI5Tp48afH5Outiag6ZmZnIycnBwoUL9X739NNPw9/fHykpKfjmm2+67Ezj8CsfTYNNc1tRWyI+MpkMOTk5oCjK7G6m5m671dbWIi8vD/3798fgwYPNurOzVHx0hYfH46FvX4KSEhkqKnhYu1aATZuYKn5TdEyY/v50Rfv58wJUVnb8bts2IZKT1fDyAmJieOjfPxCBgXTn0dbWVvz2WzGam2vxyy/e+PjjeFAUH8Zed906BTZvFuLLLxVYvFj/RuLYMe1Ae0gIQU6OgD0fc73rFsIawlDdiyHkcjmys7MhFouRlJTE1nIZi6vo1h0xLF7MXEPacRLz/wbax2m6UDB1T4zdEdBRG/TTT3yMG9cfrq4DUFnZ4UvHZAP6+BAUFQnYsTCrU6abqi0oKBCgsVGq9Rny+Xwt/znG/HXIkCEGV0XMT3vTE8aibW1tCAwMxMiRI5GWltalc3S1i6kmGzduRHR0NEaPHq31+IoVK3D33XfD1dUVv//+O/71r39BIpHgueees3icDiM+hiZmzYwzS1pRmys+zc3NyM7Ohp+fH2JiYsy+y+ls5aOZEGGuIzWDucJGCNEyjdRt9+vkBMTFdcVhm4f6eh5279b/0jU18bQmKWYi5PF48PLygrOzM7Kz6zBjRitGjy7H/fcP1D/73xPegQP8vyv5tTt8mgq0b9smMNpMTigkeO01JVasEBs9lyna2tqQlZUFHx8fs5sAGnLCzsriIySEwo0buquC7m4pEaxYUYa6OgF8fX0RHe2h9TuATgN/5JEo9lHm78N8hnRfICf07Uvw6KNq/PADvYXo49MRz6I/r85NRy3BlNN+fX098vPzERMTg+DgYFAUxZoCM//NwIiWvQShJ4xFpVKp0aQAW3cxZWhvb8eWLVuwbNkyvd9pPhYfH4+2tjasWrWqS+LjsNtuTB2MQqHA6NGjzRYeAGYVgV6/fh3nzp1DWFgYhg0bZtFFZkog1Go18vPzUV5ejpSUFIuEhzl3Z8tY3S+mMUPGjRvlnQbIuwKfTxAZSWn1vrl58ybOnj0Ld3d3JCcns+9bt++OUKiGm5sKBw/S4z18WAhfX4IhQwjeestw8J/ZIuusp86jj6q16n2GDKGD+JpBe0M0Nzfj3LlzCAkJQUxMjMnJzVhiA/PY+vUC3LjBx4QJ5m/7enpqbyUawsuLwsCBcuzbV4WffjqD5ctLNI7XXzFNmKBdS+PkBISGEnYLMTmZgpsbsGWLArGxHXVSdDYaDy4uBD/9ZCxj1HRygeZxjz9uvO7sxo0byM/Px7Bhw9gYAp/Ph0gkglgsZv8JBAJ2R0C3V5Ett+jsvfKhKMqksegLL7yAixcvmvxnjS6mGRkZkEqlmDt3bqfHpqamorKyskvZxQ6z8tGkrq4OeXl56NOnDyIjIy2+AEytfCiKQnFxMaqqqhAfHw9/f3+Lx2ds5SOTyZCdnQ0AXTY07Wzlo7nN1tl2hHkeY5Zz770qZGSI2GA/c/c6YMAAhIeHg8fjabUfYO6ys7IEUCqFoPu60RNXYyMA8NDYyMNbb4khkUj1UogNYWh1o5uOXFjIQ1GRCAcPGg/a19bW4sKFCxg8eLBZLTcMJTYYSqI4e9Z4fUwHBB4eBDt3yjFnjjPc3QnKyw0f29LCx6OPRrP/HxPTDmdnFdrbDdv7GHL2Bjo+1y1b6HT0jAwKzz2nwo8/yiEWdyRouLmB7fGkaz0kFAIeHpTRTqUd8LB2rWHxuX79OoqLixEXFwc/Pz+Dx2jW7QFgb7g0exXR47PN9py9Vz5MlpuxIlN7dTHduHEjZs6cadZr5eTkwMfHx+JGcoADiQ/TUuHKlSu4cuUKYmJiutxYzpj4KBQK1hh05MiRXbaxMCQQLS0tyMrKsngLz9C5jd3NGYrv9ARMg7iMDCH+8Y8qlJdfRWJiLAYO7LhYGSGoruahsRFITlZjyhRnSCS6d+lMPRCFRx+9gvHjg/D22zKMGWO4oZaxnjrMSqmmpiMWsmOH6R49165dw6VLlxAbG2u2SaypwlMaWmw6mvMZ/xudPCnD0KEETk5AfT293al5Dm20/7+gwAWmVh6GCnENxYkyMoT48ssOAWMEtaEB7BYrITx88okCmzYJcO0aD3V1fDQ1mRorzcyZhlPpKyoqcPnyZcTHx1vU6kQ3VqT5fTC0Pcf8d1ex98qHEZ/u2utodjFdt24dlEqlwS6mEyZMwObNm5GSksI+9/Llyzh+/LjBfj179+5FTU0NRo4cCWdnZ/zxxx94//338eKLL3ZpnA4jPiqVCjk5OWhpadFzFLAUZmVCCGEnsJs3byIrKwseHh4YOXJkt4xBdc/POFJHREQgLCysW6LAiI/m2IGuC09gIODvT9DUBKMW/y4uBGo1/k5BNnSM9gTDNIirqwPuvXcAgAEAOmIMmoH4u+5y1jmPYQ4dasOHHwbj3Dl3/Pe/rSDkHNt11M/Pj/17dVZsaSzlWnMilkhou/zKykokJCTA29vb6Lh06Xw1qZ/V9/LLSrz/vthg7x5m3Bs3yrFwoZPOOfR5/HEFvvpKuw2EqXEIBBQWL67HxIneOHVKs2at47PRRDdTUCCgnRzuuINCfLwaSiWQlubMFqiaGsOePWIA2tt/ZWVlKC8v1+p/1BU6WxV1N2mBianac+UjlUrZjMDuYmkXU4ZvvvkGoaGhmDhxot45RSIRPv/8cyxduhSEEERERGDNmjV4/PHHuzRGhxEfPp8PNzc3xMTEGCzstATNFE6hUIjq6mrk5+cjLCwMERER3V4xaJ7/ypUrrCO1OcvUzmC+IIz4MF8CiqK6tOKhM9/ace4cH7NnO/09aWgHlNeskWPMGILaWu1eOwwnTsjw5psiHD7MXC66qxaCDRs67nI1A/HaTgbGha20VIQjR+gv3blzfcDni3D5chNKSirh6ZkPX19fBAQEwN/fX6tVuW6xpaGViWZSwrp1chQUFKCpqQlJSUndqiY3J7Hh6FEZlEpg3TqCwECCykpAIqG3sGpraTdrPz9a1K5eVWDFCtPX/ldfiWFJCnd0tByFhTycOiVGYmI9srL8/v489EXG0M0Jk3Xo5tZRImAqNsXA5xOsXNlxTTA+iZWVlUhKSrK6f5nuqkjzX1eSFjQTeewFYypqjR0NS7uYMrz//vt4//33DT5n8uTJmDx5crfHxuBQ4hMZGWmVbqaMOKhUKvZOSzOo2V2YCzInJwdSqVTLGNRa52ZiOswXiPldVy5MJydg0iTj8ScmNZjpjKlbKFpSwkN+vvE7wHHj1Fi/nu7zEhVFaW3pTJggx6uvKvDuu/p3c489psT339NbPvQWT0edy5QpgQACAUSitrYO9fX1qKmpQXFxMdzc3Nj9b09PT63PxNTK5NChNvD5Obh5U47k5OQuNxnsSF0GVCoCoRCorQUaGw0LESPojY08duImBFrFs21tUkycqMaKFYZfUzuDTvca6FiZ6v7tLlxwgZMT/T4vX/aBq6sabW36X/vXXlPgnXec2Ofpvg/Nlgzm1ANRFA+vvOKEZ56RghCCkpISVFdXd1vwzUFXiABYvCpinmfPlc/t5GgNOHC2W3dgLqT8/HxUVVVh5MiRVhMeAGxmh0qlsqrwANqrKs1snu7GeEzZvjBFmLru0Mwks3Chs972jCYnTwpw9qwAixY5aTlA19fTbQ06hEc7S4oRng4Mb+W4ublhwIABSEpKwtixYxEWFob2drqS//jx4ygoKEBtba1eHK4j04/+WVhY+Hd7ga4LD9Cx9TdunBqXL/MxbpwaP/4oY7P23N07stdqa2GwAFb3swdoUXNy0s0ko3++804ePvnknMHxdMyPBOHhFB59VKklEIy7REuLwKDwAMDBg60AAD8/Ch9/LNfLOpwzR42JEy1zDdm4UQ5CCIqKilBbW4vk5GS796phhMhUgatmBp2mWAHm235ZAybN2tGcHmyFw6x8gI6kg+7CBO5UKhVGjRrV7W08TRhHagBW2SLUhRFOpVKpdWfWXUytCDSLMDXjKW5uxEBwXRP6jls3y1J3u8uU6eg//6nCN98IDW756G7nAfS+c0hICEJCQkBRFJqbm1FXV4eSkhLI5XL4+vpCpQpGYGA4QkPpfjrHjwvg5KRC374ixMebV8NjDM2gPZPQsGOHEOvW0UJqanVjiKNHtZvJubrSZp5CIbBkiQJ79ghQU6OGp2c7IiJiAeh3lNXU3NJSAUpLzcm0A3uMmxtBUZEvAECpVIHHO4/nnvNGaKgn5HJvZGfT7/PXX82fLpYsUeCBB5QoKKBtipKSkrS2S3sKY0kLzPY2sypSKBRs2YO9xKCtre22cbQGHEx8rAHTZkEgECAyMtKq4qDpSF1cXGy18+rC4/Fw5coVBAcHw8fHx+oXv26soqiIj9deE7KV+poJA6ZbEuiuVAxPdqGhFCor9bcvmHjCyJFqgxX2GzbIMWdOR+afrqMAn8+Hr68vfH19MWTIEEilUtTV1SE/vw4vvFAFT08nvPZaPAABXF0JfH2jkJurnfFmKcYSGjTRXd0IBAQBAQTV1XyD21qGzqlSAatXM9euAJMnx6K6Wshm+sXEUPj+eyFM+aqZVyDKQ1sbD21t9Ou2torx3HPGvMTMLzq97z66QJyxKbJGEN3aGEtaIISgvr4eYrGYFSN7FLhay9G6t3DLbLsxNjzZ2dmIioqCk5OTVVZRgGFH6u729NFFs3B0xIgR4PF4uHDhAo4dO4b8/HzU1NR0uzursaZrx47xtTqEdiQMCFBJ++voNTEzjObk10FlpbbzsW7A2tcXWr/XfDwri48pU5yQlcXXGpfeK/N4cHNzQ1hYGObMGYlXXrkLixenoKmJvr9qahKyjeE0J3tLMdX4zZgD96xZKlRX05+Bvz/Rc9I2dE5N4fr6axkEAgG73Xf8uBzr1ilx4oThglvzYvm623va74XHI0hO1m5g15nwMMf5+FCoqyuAVCpFUlKSQwqPIZjtuevXr6OqqootPmdir7YucDVVYHor4lArn67e4TPdJBsaGpCcnAxvb2+Ul5dbRRyMOVJbq1sq0CE8zPmYFGPGM622thalpaXIz+/I+goICLA4bqGZpnztGo9NnX3wQfo8P/4oRFKSGlu30pfF1q1Anz6t8PFRo08f4Mkn6bqaggL+33EEY3fCxmpUtCc4Jp7g7U0XW6rV9GfR3s4EzAnef1+E48cF+PhjCseOma7bYdAMjhuqJ/r3v3OQnd3Ofo6WTI6mti8ZjzRdm5oDBzq+ZioVD25uFP7zH7odRN++xOQ5jx2TgRAepkxxYld8zNZfSYnhxIOOGiNDGN4C1TuK8HDhAi2Y7u4wcU76fEuXtuPYMTEqK3n4+OPz8PGRIj4+ESKR4SJYR4XJXk1MTNTKyLNHgWtbW9tttfJxKPHpCjKZDFlZWeDz+VquAgKBoNsrBYlEgqysLLi7uyMhIUGrNshaKx/NPWfmvAyMZ5qXlxcGDx7MbitVV1ejuLgY7u7uCAwMREBAgNmBSlP1MM3N2t5tTU1CLFuW+Pd/AwkJCsTHqzFzpvPfcZ6ubgfSsR7GGVo7vdtwvITuZGrYUYCpL6KfR5CcXIKPPmrGkiV36b3yunUKbNoUi5SUa1Aq6W1UDw8PVog0P0fdbT5m0i8u1n7fzFaaStVRAJuV1WGC2lFYa9wfT/dcmjVBuh5y2is3zRuAzmtvLPmbMe7aHTU9hs/n4SFHbOwJTJsmhFSqgpub8JYSHsA+Ba7cyqcX0dTUhOzsbAQGBuqZQXa3lXZdXR1yc3ONOlJbY+Vjaf2Oq6srBgwYgAEDBkChUKC+vh51dXUoLy+HSCRCQEAAAgMD4e3t3emFb7hSX5eOjCyVqqMbp7Zfm+UCtHEjHcthJvPlyxVYsUK3cNJQHEk/U2z9+o6EBIqicPHiRTQ2NiImJhmAfnzrt98EOHVKhOHD+2P16hC9z7GszA+bN8fgzTel2LfP14xJv0MknnzSGYcPt0MkAqZOdTY5afP5BF991TH2wEAgIEAFb28JHnlEhu3bA3DjBg91ddoeco88osLy5Qq8955IZ2Wnj6GiVvOwJGYE3LzphBkz4pGVlQWhkIJUqsDp06fh7+8Pf39/+Pr6dquo2x6YEh5dbFXgeruJD49YKzBiBZi0R3Nggv9DhgxB//799SburKws+Pr6IiwszKIxmOtI/ddff6F///5dtgCyplWOWq1m2/PW1dWBoih2687f39/oFz8721B7Z31OnmxHcTG/G22vGehJbeNGGebMobQKF7siZCdPtrNZekzbaJlMhvj4eDQ0uOCuu2gH55kz6a3E2lr6/I2NPAQEEOzaRcdM/Pxoe5vXXxdCKFTg8GFXjB1bhZwcP7S0OMHPT4WMDCmOHHHWmPS1YQSaobOJX3PsAG2ymZtbhBEjohESEmzwszFXTCxx8+4uAgHBF19IMWjQX3B1dcWwYcMA0DeG9fX1qK+vR3t7O3x9fdlr0hGy3jQpLS3FtWvXrFKDpFvgqjm9dpa08OyzzyIoKKhT5+pbBce+HTEA03b2xo0bSEhIMGpK2JWVj2bsqLMWDt1Z+WhenNZIpRYIBFpdEZk40ZUrV3DhwgUL4kTGrfQtNyk17E/G4xF89pkIQ4YozXA/MA+FQoHs7GwIBAIkJSVBJBJpxbfc3fWr83Utd2bPVuH4cSGYr8SxY33AbPM1NAgwfrxpu6ejR2UoLuZbVIjJwHidJSUNZ41uDX02ptpHMJ/3Sy8pcegQHxcvdnRDtSVqNQ/h4X/C3d1TyxHcz88Pfn5+iIyMRFtbG7u6LCkpgaurKytEXl5ePdKrh8GawgMY3p7TFCJTqyIu5uPAMJMMU79jKifeUvGx1JG6q626TfXgsQaWxIkCAjzg6UmhtVW3cr5jy4vPB/78kw8/P02htaQxGg1tbaPA6dN8bNwowpYtFFavVpoQNMOvweMRDBhA0N5Ob1VJpVJkZWXB09MTsbGxWhOZpm+aMcsdxlaG2doytc1H1yVV4KuvBhiMzcyZo8bChZ3/Pf39CQIDwRrpVlRUaHnMVVTwEBlJYf16w03etm6VY/hwgvXrOwxWv/1WgGvX+Bg1SoUhQ/hYvFjMfl5d23ozj3nzLsHHxwfR0dFGr2U3Nze2UFipVKKxsZEtiSCEwM/Pj/Xws3bdnCk07X5sMembSuU2FCvitt16EIqioFQatmBvbW1FVlYWvL29ERsb2+keMtNUKTo62uRxQNccqXNycuDl5YXw8PBOjwVMJxbYC834RkNDA0QiEVQqAS5fdsaSJXcaeIa2AJSUtOOuu5xQU2P52DdulCEykmDWLGfU1XVsexUXawfgmTv5VatkeOkl/Yl35852TJxIoFAAZ85I8corwMsvNyA9PdSkkHe+xdi5oJ482Y7AQODOO50QHKzEtGnVyMjwQl2dMzZtKkBMjBc2beqL994z/jrjx6uwY4cCYjHBrl3XsGpVAFat4uHOOzveq/aWm2Ha2qSQy8EWBBOivcKz5H11FQ8PBbZtK8aYMQO7dBPFrNLr6mj7JIlEAi8vLzZWZKtqf0b0KysrkZiY2COrDd0CV5lMhtjYWDz44IP44osv7D6enqBXrHwY1+iBAwdi4EDzLnShUGhWg6OuOlJbsvLpjjGoNRGLxejTpw/69OnDZgmq1Qrw+cxkqTtRdayAHnxQhc2b+fD3J2huJqxliz6Gt+4YgTHVA8fdnSA0lLakYUzNdVcYgYH0ZNvaWofPP6eQlxeOU6e8MGtWx00Lk6X22GMqfP89XTzLZKjpFnl2GGqaTg7Q7BlUVMS4QATgtdcIGhqa0doqRkVFBQYOvAJPz3FobTV8B5+TI0BBAVBaegX/+58P8vL8sHu3Enfe2TF+7S03/c931So6UUEzQ/zaNZ5OIgKDocQNQ1giUvSxn39+tcvCA2iv0iMiIiCTydg40ZUrVyAWi7WSFqzhs8YYnF6/fr3HhAfQXhXJ5XIsXLgQgYGBWLx4cY+MpydwaPFhDAmvXbuGESNGmN1zBehcHAghuHTpEioqKiw+N2BZu2tH6MGjiVQqRXZ2Ntzc3JCamoqICAECAtTw8FDiyhVD2408bNummTZrfLHcrx9BQwNAUYBc3iEcPB5tNmmqB05bG1BURH8pn3zSGSIRwcCBFJ5+uqNvj1IJ/PZbPa5evYrTp+n+8rp1P0xqclMTkJ9PZ6tJJPQr+fsTLFumZM+3bp2CbaCmDT0mFxeCAQMo1NbyoFTSoqo56fP5PAQEeCIgwBPFxYPx6acCPPZYMz7/3LDDeVMTcNddrgCGsY9pjv/GDR6++06IdevkWLRIf1yHD8uQmqr/+XdeOMuDvz+FpiYe+vQh7Gt5eNDecP7+BEVF5l6b9HEjR4aa5XBtLs7OzggNDUVoaCjUajWbtFBUVASFQqGVtNAVbz5HER5NFAoF5s2bh6qqKpw8edJoDPtWxKG23QghUNBNZaBUKpGXl4e2tjYkJCRYfKFcvXoVDQ0NSEhI0PudSqVCXl4eJBJJl84NAEVFRSCEmNzWs3ZigTVobm5GTk4OQkJCMGTIEHZMcjlQUMDDXXd1NRNJ/87ZUFzEHIRCgrFj1Th0SIjFi5VYvVoJQmgx8/Pr2BM3dn5vb4Lm5o7HPTzI36slHnx8CPbulYEQenV18ya9AtMfo+EVnG5djiaGs/dMrSiMZ7HNnq36Ow6lfR7NLDnNOqSSEp7JbMTlyxVYskQFQjpWTHI5vYoEgK1b+fjXv5xMjLUDHo+O3z36qPUcPkxBCNFKWmhpaWGdzf39/eHl5dXpd0tTeJKSkhwitqJSqfDPf/4TRUVFOHLkiFVasvQmHNJeRyKR4PTp0yCEYNSoUV0SB2MrH6lUir/++qvbjtSmVj6aAUVCiMMIT3V1NTIzMzFo0CBERkZqjcnJCQgKAjw9Lc/ge+kluggzKIjC6tUKo/YzgHk2PevXy5GXR2+xZGQIkZ3NQ1YWcOpUKV56Kdfk+QG6WFbz8Zs3eX8nVdBFnnfe6YK77nLBiBEurOVQfDyFhx9WQtduRrOmiHGf1qSigofsbPqfh4fmezK/4FMz+YE5xx9/CODpSbGO1UIh4OtLr8AqKujjNe2G5sxR4+hRw3Y7vr50K3MnJ8DZmRYcus04H+npTigo4ONf/3LuZKwdnDghs5vwAPT2nLu7O8LCwpCcnIyxY8ciPDwc7e3tyMnJwbFjx3DhwgVUV1cbjBkTQnD58mWHEh61Wo2nnnoKBQUFOHjw4G0nPIADbrvV1tYiLy8P/fr107oztxRD4sM4UoeEhCAqKqpbQX9jqda6iQU8Hq/HhYepXSorK8Pw4cONXuh9+xKUl8vw8ssifP21OdXp9N14UFAjDh92AUUJ4eQEeHtTBreMfH0phIV1tL8uL+cb7IGj2dtHOyV6OBoaGpGWZjhDzlhDNEMwBaq6nVEXL1YZXP1pOn9rYsgpoquo1TxIJPQ5Wlq041BqNdDYyMe999Kf69dfy/H119rFp8y2mW5cKyNDxrpJaLJ+vRDHjwvw/PPE5llx1kQkEiE4OBjBwcEghKClpQV1dXUoKyvDhQsX4O3tzcaKXF1dUVpaiqqqKocSnmeffRbnzp3D0aNHrdrupTfhUOIjlUqRl5eHoUOHdrl4k0FXfDQdqfv169fdoRpc+ThifIep+md87zqr3nZyAqZNU5slPt7eFJqbBdi0SYQ333TGkiVleOwxYP/+sL+PoMWJmQR37JAjOZmw7a/Ly3mYMMGJTRdes0aI8nLttG9mQuTzCQYPprBzpxu+/FLIPqbpXsB4q5mDpphoxnCYP5k5XUoBulfPO+/Q7gym2k4YQrfxm+b71TuLzuOLFnUMWrdmKT6eYgX++nUeQkM7nqfZEuKHH+jP8dy5zqYBwhbR+vp2ePI5AjweD97e3vD29sbgwYPR3t7OJi2UlpaybREiIyMdoriVoigsXboUx48fx5EjR9C3b9+eHlKP4VDi4+bmhjFjxlgl158RH82i1MTERPh2WCh3+/yaKx9HFB4mbqZUKpGSkmJ2kDYmhu7x0tbWWUYbvXK8eNEHajUPGzeGw929GAcP0kcJBMDTT0vw++8uqK/noW/fjsmdxwPCw+lVR3U1D42NwA8/qDF9ujOam/VfMT1dhZ07RfjkEzqJwMWFIDqa0lhF8fB//yf6+9zMZK4/8XcmJsw2HCOIzARuaMLNyuJj40amrUFnaI9FfxXIQ2Nj5yvxxx9X6vU/0ty2++ILBR55RM0K/JkzfCxaJGb96Yz7whkf844d1Zg40Qs3b9Lbdo5sUu3i4oJ+/fohNDQUxcXFuHHjBvz9/VFaWori4mKtduz2dtumKAovv/wyfv/9dxw9ehQDBgyw6+s7Gg6VcADQ2R/WGFJzczOysrLg4eEBuVyOhIQEqzZqqqysRFVVFVJSUhwysaC9vR3Z2dlwcXHBsGHDLPbWKivj4a67nNDUZGpCNBZUN/x4RcU1+Pj4ICdHqGXYaU6g3t2dQCLpWCV4exN8/bUcwcEEvr7A2rVCbNgggosLwaBBFK5e5UOtpoVIJuOBxwOWLVPi559pMTlxQq61FaUZvI+JobTqZxQK7QmXWT2sXSvSKE41LXqa78/VFfjmG7pQdMAAAkKA778XYPHijjbWxn52hm5CxIsvivDllyI2cWPrVoHZNkn9+rVCJnPDqVMKg9t2jgqTycq07XZ1dQUhBBKJhE1aaG1thbu7OytEuu3YrQ1FUXjjjTewfft2HD16FIMHD7bZa/UWblnxqampYU1Hhw8fbnVjwxs3bqC8vBypqalaLXcdQXhaWlqQk5ODoKAgDBkypMuxrbNneRg/3kVve8j46sH4pJua2oI33/wTFEXhu+8SsX17MJ56So6PPlJbNCEae42AAIK6Oh78/Ql275ZBoaATKEJC6MkdoO/aCQHOnOHj7bc7xA/Qn6SNUVHBM5LW3LViTkYsnnpKhO+/FyEggMKyZSps2CBAYSEfMTEEjz+uwqZNAly+TDd+MxbXWrRIiZISPp59VomQEPpN6xb1AkB1NQ+zZ3e+Cv711zqkpro59EpHF0PCYwim4Lq+vh4NDQ3g8/lsnMjPz8+q8wUhBCtWrMB3332HI0eOmFX4fjtwS4pPXV0dcnJyoFarMXHiRJu4CdTU1ODSpUtITU0F4DjCU1NTg4KCAkRERKBfv37dGtP16zzWnFNzC+rLL+WdtofWxdeX4MMP5SguVmDNGneo1Xx4ecnx0UeF8Pb2QVGRP954Qz/z0FyTTGMrBEOp0YzQPPaYCk8+SQuNoUma6RWkuSq6667OJ+3Ro6vw118hJsctFBK8/74So0ertV6fEU9CaLGMjiZaK7DCQsNODR4ectx5ZyN+/VXbCLcr6e58PgUfH4LTp3vfiqekpAQ1NTUmhUcXph07I0ZSqRQ+Pj7sqqg7OyaEEPz3v//FunXrcPjwYdZ4lcMBxUepVHbZsFPTkToyMhKFhYU2ER8mw+bMmTPw8PBAYGAgAgMDezSThhCCq1ev4sqVK4iNjbW4aNYYuhYuCgVw+DD/7zvn7lm3GJ4Qtbfdli2T4513LL/1ZrLZ5syhJ3fNQDsz0Rt6XUPipbkqSkqiOl2lLVwowbRpApMCffJku5aImCuejE2Q7vGffNKKt95yRWOjEC4uSsjlwk5E2/jfbt++Bowe7dLrVjwlJSWora1FYmJitwRDKpWyQtTY2AgXFxe2uNWcdiWaY1qzZg3Wrl2LQ4cOIS4urstjuhW5ZcRH05E6ISEBbm5uOHjwIO6++26rmhVqJhaoVCq2jUFDQwNcXV1Z005b7yFrwiRV1NXVIS4uzqQbtzUwx3us6xiO+ViaCqzbskBzzObEZgQC2jl60iR1p350ugQEEPz3v3KNlPGO12Jeu7M2FbriyaC7Gn3uuY5ru6tFvZoEBqpx8mTvXPFYQ3h0UalUbLuS+vp6UBQFPz8/dovO2NxCCMGnn36KDz74AL///juSk5OtNqZbhVtCfDQdqePj4+Hs7AxCCH777TeMHTvWaimWpjLaVCoVGhoaUFtbi/r6eggEAlaIfHx8bGYkyrg1yOVyxMXF2SWdtPMYTVdWRIafw+dTEInU4PPp9GuVig+6jtDw+TUnd03xsSyuZPicxl0QtP9f9zimRbhAQBAWBtTWgk14MGZ4qjt+TTRXozNmiHH4sDnxCdOOC3w+hc8+a8OcOYJet+IpLi5GXV0dkpKSbHr9E0Jw8+ZNVohu3rwJT09PdlXEGKESQrB+/XqsWLECv/76K0aNGmWzMfVmHCrVuisYc6Rm+mRYq9U141pgzLFAKBQiKCgIQUFBoCgKTU1NqK2txYULF0BRFNtPx9/f3yoGiUCH6Do5OSE5Odlu3SI77+1jWTKC8ecAx4/L8dVXFL77zg0zZ17DXXddwVdfJaCkRL9e6cUXFTh82HBq9Jw5anh5yU0E2rUnZ02TTt0aHD6fwN0dCA6mUF+vQmOjGIZqk5jVy6xZaohEgFJJi4ZCAdTU0K4IxlpyV1czY9GnpqZjCzE/39S1pP+ZOzvT2X+6rFnTgLlzXeEAYUuzsafwAPSc4unpCU9PTwwaNAhyuZzdnisvL8fu3bvR0NCAPn36YPPmzdi/fz8nPCZwOPGxZKuKcaQeNGgQwsPDDba67q74aDpSM+PrbIx8Pp9tphUVFcVWYF++fBkXLlxg+5cEBAR0eUuwtbUV2dnZCAgI6LZbQ3ewXddMeuIsLubhl1/obZTTp0PB5wegpKTDIVtz+yw9XY233lLppUYDdMzHdIZXhx2OszNtR1NYyENGhn6x7b33qvD551I8+eRN7N4dinvvVWDnTv2/o64rAjMmJyddI9AO4WOEa/ZsZ4PJEllZfK2kB9OuCjy9/5bJdK8T+rWbm8tw/HgDe4Pk5+dntZskW2Bv4TGEk5MT+vbti759+7Lb8OvXr8fmzZshl8uxcuVK5OfnIy0tDaGalb4cABxQfMzBXEfq7oqPNXrw6FZgSyQS1NXVobKyEhcvXoS3tzcCAgIQGBho9heIWVENHDgQAwYM6JEsO81izAkTKKxaJYLprR1Lx0gfr2m1U1cH7N7dMfEOGUJBJFLiwgVniMUqlJWdQVlZML78MgwrV1JISuo4W+euzx3IZDycOMHDgQO6DebonwcOCLB27TUcOhQJADh8WLu41RxBNtzFtaNYdMMGhcHnbdnCCAI9FuMJG51BMHnyDdTUBOL6dT7mzImBm1sT221ULpdrFWR2xUXaVjiC8OjC4/HQ1NSEEydOICMjA+Hh4di/fz927NgBtVqN5557rqeH6HA4XMxHpVKZFAxLHKlPnjyJyMjILpn2aQqPrdKoZTIZ6urqUFtbi6amJrboLTAw0GgjLablckxMDIKCgqw+JktgYg9VVXQQ3N+foKCg63fLTJfSmhqeGS2gtSdZf38KmzbV4OOPxfjjDz/MmFGGe+9tw/r1g7BypRpXroi6HPPpHP2CWLEY+Osvw55qDJ3Fe5gUb0N1O91l/fpMzJkzGAKBUG+laMhFmrk2AwIC4OHh0WNlBYQQFBUVoaGhAYmJiQ4hPACwc+dOPPnkk9i2bRumT5/e08PpFTic+KjVarbPuS5My2SxWIy4uLhOt6xOnz6N8PBwi4377CE8uiiVStTX17MJC05OTqwQMe2Vi4uLUVNTY5eMNkthhOiHHwR4+mmx2QafmsybJ4dQyMPWrSIT1j66GF5tiUQESUkSnD7tgQkTKvDmm1dRWxuK2bPDLR6XuQgEBOPG0a0gnnhCif/7P+PFqkCH+Oj6yDHiM3euGDt26G5OdC+9nXn+8eNtSEw07zyaBZn19fUQCoVskN1aTd7MwVGFZ9++fViwYAF++OEHzJo1q6eH02voNeLTFUfqs2fPsnuy5qCZWNCTVjlqtRqNjY2ora1FXV0dgI4tv8TERIdw5jVF5y2rbYnhyTkjoww5OTK8+2600WO6y8aNMrz6qpPRYlVdDBXxVlTwsGGDAoGBBP/4hzPa23kQicjfjey6A/2ew8LaIJW64ORJeZfSqZlkGqbEQKFQsKnHAQEBNvNLI4Tg4sWLaGxsdCjhOXDgAB577DF8++23eOCBB3p6OL2KXiE+jCN1ZGQk+vfvb/a5MjMzERAQYNZzupJYYA/a29uRmZkJiqLA4/GgVCrh5+eHwMBA+Pv7QyQyp/WBfdEthLQOxvzjLH9ubKwMd95Zg6++ot3NZ82qR0ZGIHtc53VAxpvAWeK0AOgX8bq7W9qQzjz69ZOgrU2MU6eUCAriWSWdmtmeY4SotbUVHh4e7Pacsa3jrrwOIzxJSUkOE386dOgQHnroIaxbtw6PPPKIQ8wXvQmHEx+KotiGUJqO1PHx8RY7Uufk5MDLywvh4aa3WqyRWGALbt68iezsbPj5+SE6Oho8Hg8SiQS1tbWora1FW1sbGxTuamthW6B5Ry8UtuLsWR8rnbl7k7FQSPD55x2uz1IphcbGRly+3IxHH42En1877r23EXv29EVxsRhiMSCXG69liowkePpplU4rCH2Sk1VwceFpeckZw7oFvAR9+lBob1dh06ZC3HHHYLi42O7aZrbnmKJrkUiktT3Xle+VowrP8ePHcf/99+OTTz7B/PnzOeHpAg4rPgqFArm5ud1ypM7Pz4eLiwsiIiKMHuOIrRAAoL6+Hnl5eQgPD0dYWJjBcUmlUjZhoaWlBZ6enmycqKe35iQSJQoLc1BXJ8YTT6SiudnYxGOtu/vOn68byNcUA5mMQCZrRX19HWpr67Bq1UD8/nvn8aGTJ9vh6wtUVwN33214K8jFhaC9nYfZs1V45x2lwS04hq1bBXjiia7FzHT55Zcm8Hhn4eUVgOHDI+16bavVanZ7rr6+nl2xM9lz5pQYOKrwnDp1Cvfddx9WrVqFJ554wmHmjN6GQ6ZaSyQSZGVlwd3dHSNHjuxy8WRnqdaOKjzXrl1DSUkJYmJiTCZLuLq6YsCAARgwYAAUCgUrRFeuXIGLiwsrRPa0+gHorcK8vGy4urpi8uRY7Nol13LHNgeRiMDdnaCpSTsN2TjGf6+7BdbRfppixcfZmYfaWm/cvOkNF5fBGg3WTG+9MbGtr7823MIaANrb6Z8ZGUJkZAgRGamGUAisW6e/EqLtdMxvimcI5nO+fLkQd90VhMGDB9v92hYIBKwFDdPOoK6uDteuXUNhYSF7oxQQEAA3Nze98RFCUFhYiObmZocSnrNnz2L27Nl47733OOHpJg638mlubsapU6fQv3//bn9piouLoVarMXToUL3fOWIPHsaj6saNG4iLi2Oz3CzFkNUPI0S2tPoBOrYKmeJXHo+nF1g3tU0lFBL83/8pMH8+vTUmkwGZmTxMmmRJEzTt48LCKLS08LBxowyBgcYdrI0Vfpp6Lf3W3eav4Jj2DZorMQCYN0+EK1fMzyB74QUFPv6Yjv0tW6bErl08XL2qxrZtZRg9ur9DXNuayOVydkXU0NAAsVjMCpGPjw94PB4rPImJiQ4jPFlZWZgxYwbeeOMNPP/88w73ufY2HE58VCoVqquru1Sbo8vly5chlUoxfPhw9jFHTSxQq9XIz89HW1sb4uPjrWaOqGn1U1dXB7VaDX9/fwQGBlq9b0ljYyNyc3MRFhamt1WoG1g/e5ZncJtK09OMcaKurQXuu88ZhPDg5EQglwMdE7zpxm2GfmcsKeDrr2V48kkx1GrLxPmtty7h3XcjLK4h8vIiWLNGjowMIX79VYjHHlOhvR1aDer03682//mPAm+8oYLs74WXXN6CzMwshIYOxJAhjt8pk8nsZMRIpVJBJBKBoigkJCR02vbdXuTl5WHq1Kl46aWX8OqrrzrEnNHbcTjxIYRAoTBc3W0pZWVlaG5uRnx8PHtuR0wskMvlyMnJAZ/Px4gRI6zqwq0JIQStra2sELW3t8PX15c1QO3O61ZXV6OgoADR0dHo06dPp8d3VuMCWC/4LhQSLFigwrffCo06SH/5pQze3heQleWKlStjzD73K6+04uGHy/HnnzIsXpxilfFqY1xcfX2JViFrY2MjcnJyEBERYVFWqKNAURRyc3PR0tICJycntLW1wcvLi40TGdqesweFhYWYMmUKnnnmGSxfvpwTHivhcDEfa/5hNWM+jlC/YwiJRILs7Gx4e3sjJibGpoLI4/Hg5eUFLy8vDB48GG1tbaitrcX169dx8eJFeHl5sb2JLKmjuHr1KkpLSzFixAj4+/ub9RxNex7NRnWaTknaFjSmML3V9eqrCjzyCIV581QG648OHpSgqKgE99+vaXvf+babry9BSooYzz4bg7lz6fIA81ppW4L+lh4j1BkZHcLDJKhERkaaXdfmSDAxHqlUilGjRsHJyQkymYzNnistLWULry3tq9MdiouLMX36dDz++OOc8FgZh1v5APRKwBpcv34dlZWVSElJccjEgoaGBuTl5aF///4YOHBgj45L1+rHzc2NFSJj9RpMjKq6uhrx8fHw9PS06DUNNarTrT+xZsHq11/LsGiRfo+dL788i0OH+iEjI6ST2iTtyf/w4XZs3y7El1+KMGWKCgcPCtC3L8E//qHCxo2iv5MrrCNCbm4EkZGUllAzbRkYr7/o6GiEhIR0fjIHgxCCgoICtLa2IjEx0WChqlqtRkNDAytGTF8dZlVki3q3y5cvY8qUKZgzZw5WrVrlMDsltwoOKT7WaKUN0FtBV65cQUpKisMJT2VlJYqLi83eprInmlY/mgFhxuqHx+OBoihcuHABN2/etGqMSpcO8enOJE7w3HMqZGbycOqU9mKfz6fbHfB4fMhkPLi5EYPWPp6edM3MnDlqfP+9EFev8vD++3KsWkU7GjDp1Lbi8OF2pKQQPaFmtjuHDRtmte619sQc4TH0nNbWVra4ta2tDd7e3mxNkTXKDMrLyzF58mSkpaXh448/5oTHBtyy4kMIQUNDA7KzszFgwACTd/D2hBCCy5cvo7KyEiNGjLC4cNbeGLL68fPzw82bN8Hn85GQkGCzGBXQUbDq4wMUFXV1ArCNnY72ubv+Gp05Qfj6UvjrL307nOvXr6O4uBjDhw83e7vTkSCEsDcw5gqPIdrb29kVEdP2mtme8/Lyslg4rl27hkmTJmHy5Mn44osvOOGxEbek+GjW79TU1LB38M7OzuxWkr1rX4COVt+tra2Ij4/v8UJQSyGE3uK5ePEi1Go1eDyeXax+5HKgoICHu+7qWAHZro9Q53h4ENy8aVmGnTF8fCj07SvH6NE38PXXYaAoHgIDlRCL+aiuFsDbGzhyRIaBA7W/D9euXcOlS5cQFxfn8DcwhqAoCgUFBd0WHl00215r3iwFBATAz8+v02v0xo0bmDRpEsaMGYOvvvrKoXsa9XYcUny60kqbgUksUKvVWttsarVayzVaKBSyQsRsJdkShUKBnJwcADDLkdsRYYp//f39ERkZCalUyq6IJBIJfHx82Mw5a9dmGDLhLC/nobHR/nel5nnWdZ4C7utL4fhxOcLC6O20mzeVqKqqh0xGpx0TIkZgYAD69vXXqs8qLy9HWVkZ4uPju1wL1pNoCk9SUpJNszuZRo719fVoa2uDj48PGyfS3SquqanBlClTkJSUhO+++44THhtzS4mPuY4FFEWxW0m1tbUAwApRVz2oTNHW1obs7Gx4enpqtfruTTA1PMaSI9rb29nPs6WlBR4eHuxnaq0Vnm6CQlkZD+PHO6Oxkf5/kYiOhdhqi82S1dagQWrcuMGHVKq5JUf/jIqi0NQEHDwo11vRMDDXKHMHr1ar4efnB0II6+xsaYKHI8DECtva2pCYmGjXm7D29nb282xqaoKrqyu7IxIbG4u0tDTExMTgf//7n91a0t/O3DLi01XHAkIIW4RZW1sLtVrNBtet0UqYmbRDQ0MRERHR4zGnrlBTU4MLFy4gKirKrDReTaufxsZGm253yuW08AC0MJ07xxSvGneeNh9t0Vi1SoaXXjK2otN+vZMn2+HtDYwfT6/WHn1Uje+/F6C6mofjx+UICCBmO0szAfbi4mK0trYCAHsHHxAQ4DDtBTqjJ4VHF8YFZP369fjiiy9AURR8fX3x4YcfYtq0aTYtbj1+/DhWrVqFzMxM3LhxA7t27UJ6errJ5xw9ehTPP/88CgoK0K9fP7zxxhuYP3++zcZoDxxSfDrrZqoJ04OHOb47jgWaRZg1NTWQy+WsG0BXYhpVVVW4ePGi2ZO2I8J0Th02bFiXXCeYLzlzx2lrqx9mey4khGDBAjW++06A0lIKajWBTCZCQADdKZW+t9FflTA/fXwIwsIoLFigxrff0qnN69crMGuWM7sCYoTG15dCWBgtMD/8oJ0GbU46eWcwTdTq6+uRmJgIHo+ndQfPpMX3dJdRUziS8GjS3NyMGTNmwMvLCwkJCfjll19QWlqKV155BStWrLDJa/766684deoUEhMTce+993YqPmVlZYiNjcVTTz2FRYsW4dChQ1iyZAn279+PSZMm2WSM9qBXi4+uY4E1rXKYXiVMwgLTvoC5gzf15SGEoLS0FNeuXcPw4cPh5+dnlTHZE0IILl26hKqqKsTHx1ulc6pmIzJmlWkLqx9mwgcILl4sQlVV/d8JHu5wcqJ/T/vFOcPZGaAoAoWCvm6GDKHQ3MzDoUMdsRhGNOrr9eNO16/zcPCgHOHh+mnQ1oCiKC2fM91VDpMWz8Q1hEKh3Xz8zMVRhae1tRVpaWnw9vbGzz//zMYpDdly2Qoej9ep+LzyyivYv38/Lly4wD42Z84cNDc348CBAzYfo63oteKjGd/h8Xg2/5IxwfXa2lq0trbC29ubFSLN4DoTTGVsfdzd3W06LlvAvIeWlpYut7PoDFta/QDQqkNKSEgwuDXV2gq4uwNKJSAUAm1tgIeHafGwxkrG0vcgkUjMyggzFieyZSFmZ1AUhfz8fEilUocSHolEgnvvvRdisRj79u2zWZ1aZ5gjPmPGjEFCQgLWrl3LPvbtt99iyZIlaGlpsf0gbUSvjKr1RCsEV1dX1jBT0w2gpKSEDa77+Pjg0qVLoCgKKSkpNmspbEuUSiXy8vKgUqmQkpJis8nCXKufgIAAiycGtVqN3NxcKBQKJCcnG30PTLye+TPp/r8hNH/H49lOeNRqNfLy8iCXy83OCOPz+Wwbg6ioKNy8eRO1tbUoLy9HQUGB3eNEjio8UqkUDzzwAPh8Pvbs2dNjwmMu1dXVCAoK0nosKCgIra2taG9v7zUxP10cUnxMiYkj9OBxdnZGv3790K9fPza4fuPGDVy+fBkCgYB9XCwWO+T+uzFkMhmys7Ph5OSExMREu2b8uLm5ITw8HOHh4ay419XV4dKlS2ZZ/TAolUpkZ2eDz+cjKSmpV2YtqdVq5OTkQK1WIzExsUsrFh6PB09PT3h6eiIiIkIr06ukpMTmcSJGeNrb2x1KeGQyGR566CHI5XL89ttvvXJn4lah13wzdRMLHMUqRywWw9XVFRKJBP369YOXlxdqa2tx9uxZODk5ISgoqMeKWi2BMTj19fVFdHR0j8YKNMVdM6Zx7tw5iEQidtLUNZdkxNPFxQXDhg3rlSntKpUK2dnZ4PF4SEhIsJp4uri4oH///ujfv7/WZ3r16lWrx4l0hacntvsMIZfL8eijj6K5uRm///57r0lVDw4ORk1NjdZjNTU18PT07LWrHqCXiI+j9uAB6IrowsJCDBkyBP369QMAhISEsEaItbW1yMrKgkAg0CpqdYRAMENTUxNycnLQr18/DBo0yGE+WwAQiUQICQlhP1MmppGXlwcAWttIOTk5DiGeXUWpVCIrKwsikQgjRoywmXhqfqaacaKCggKoVCrWI60rcSKKopCXlweZTOZQwqNQKDBv3jxUVVXh0KFD8PHx6ekhmc2oUaPwyy+/aD32xx9/YNSoUT00IuvgkAkHFEVBqaS7Oto7scBcCCEoKyvD1atXMWzYMJPeWkyWV01NDerq6kAI0aol6sn3VFNTg4KCAgwZMgShoaE9Ng5LIYSgubkZdXV1qK6uhlwuh6urK8LDwxEQEOAwk565KBQKZGZmwtXVFcOGDeuRa4IQwsaJGMNOS+JEjio8SqUSCxcuRFFREY4cOWKVRpXdQSKR4PLlywCA+Ph4rFmzBuPHj4evry/69++P//znP7h+/To2b94MoCPV+umnn8Y///lPHD58GM899xyXam0LGPFxhPiOIZj018bGRsTHx1tUkMZMmkzmnFKp1BIie8YomBqe2NjYXumIDNCrtuzsbPTp0wcikcguVj/WRiaTITMzk3XAcJQbLF1HADc3N/Za1Y0TOarwqFQqPPnkk8jNzcXhw4cRHBzc00PC0aNHMX78eL3H582bh02bNmH+/PkoLy/H0aNHtZ6zdOlSFBYWIjQ0FMuWLeOKTG0BRVFQKBQOKTxKpRK5ublQqVSIi4vr1sSmeadZU1MDmUzGGnXa8u6dcda+fv064uLieqU/GADU1dUhPz9fb9XGTJq1tbVobm5msxEZu31HuZYAeqyZmZnw8fHB0KFDHWpsmhirJ2Jib/n5+VAoFEhISHAY4VGr1XjmmWdw+vRpHDlypNcWet+qOKT47N27FyqVCmPGjIGzs7PDfCGlUilycnLYgLa1VykSiYRdEUkkEq26F2ulbWsWLfZGZ20Gxj0iNjZWLw1VE4VCodWbiLH6Yez2e/LaamtrQ2ZmJgIDAxEZGekw13lnMNvIzPacQqGAQCDA4MGDERQU5BDiQ1EUlixZgsOHD+Po0aO9sq34rY5Dis/q1auxdu1aSCQSTJs2DWlpabjnnnt6dPukubkZOTk5CA4OtstEoWvU2dUW15qoVCrk5uZCqVQiPj6+V9YhAR3bhSNGjLDIPUIzCaSurg58Pp8VIlsYyppCIpEgMzMTffr06bWefxRFIScnBzKZDP7+/mhoaLA4TmSrcb388svYv38/jhw5goEDB9p9DByd45DiA9ATxenTp7Fjxw7s2rULjY2NmDx5MtLT0/GPf/zDrnfsTFA+IiKiR+6g5HI5K0RNTU1wd3dnU7jN/Rzkcjmys7MhFosxfPjwXln/wtgWVVZWdtvyx5jVD5PlZcvPp7W1FVlZWejfvz/Cw8N7pfAwRbDMjQyz2rEkTmQLKIrC66+/jh07duDIkSMYPHiwTV+Po+s4rPhoQlEUzp8/j4yMDOzatQtVVVWYOHEi0tLSMGXKFJs50BJC2N4pXTXWtDZKpZKdMBsaGuDi4sKuiIx9udva2pCVlcXGFRwloG0JjLlmXV0dEhISrFocqNmWuba2FlKplLWlseaWJ0CvoLOzszFw4EAMGDDAaue1J4yDhEql0hIeXUzFiWyx0iSE4O2338b333+PI0eOICoqyqrn57AuvUJ8NKEoCrm5uawQlZWV4Z577sHMmTMxbdo0q+3jUxTFTnbx8fEOWZCmUqm0GuSJxWJWiJjPgdkuDA0NdbgaHnMxx6fNmrS1tbFC1NraCi8vL/buvTtWLI2NjcjJycHgwYPZmrDehqbwWFIEqxsn6m49kS6EEKxcuRIbNmzA4cOHERsb263zcdieXic+mhBCUFBQwApRUVERxo0bh/T0dEyfPh2+vr5dmmwZfzOFQoH4+HiHT9UFwBZgMl9uHo8HDw8PNDU1YfDgwb024Krp05aQkGB3mxa5XK7Vm6ir20hMZl5UVBT69Olj41Hbhq4Kjy5MlifzuXY3TkQIwZo1a7B27VocOnQIcXFxXRoXh33p1eKjCSEEJSUl2LFjB3bu3Inc3FzcddddSE9Px4wZMxAYGGjWRNHe3o7s7Gw4Ozv32tgIRVEoKSlBZWUlBAIBeDweO2H6+vr2GtsZTZ+2uLi4Hv9bKJVKNmGhvr4eIpGI/VxNuVYwzfg6y8xzZKwlPIYwFicKCAjo1JaKEIJPP/0UH374IX777TckJydbbVwctuWWER9NGPcBRojOnz+PUaNGIS0tDTNnzkSfPn0MXtAtLS3IyclhU197a2yECcrHxcXBy8sLLS0tbMKCQqHQapDX0xO6MWQyGbKystiKf0cTTM1W7JquFQEBAVodcG/cuIGLFy86TMywKzBGpxRFIT4+3qbXjGacqKGhgW0+aChORAjB+vXrsWLFCvz666+93m7mduOWFB9NCCG4du0adu7ciZ07d+L06dNISkpCWloa0tLS0L9/f/B4POzZswdOTk6IiopiH+ttUBSFixcvss4LukF5QggkEgnbII/poRMUFAR/f3+HcR5mEiR6i08bIURL4JkOuAKBADU1NYiLi+uVDQUB+wqPLobiRH5+fjh//jxmzJiBffv24bXXXsO+ffswZswYu42Lwzrc8uKjCSGE7Zm+Y8cOnDhxAsOHD8eAAQPw66+/4scff8TEiRN7ephdQqVSsf1fzI1TMT10amtrcfPmTdaSJjAwsMdqgFpbW5GdnY2QkBAMHjy4190EMB1wS0pK0NDQAB6Px8YzdBsPOjo9KTy6MHGikpIS/POf/0R5eTmcnZ0xf/58vPDCCwgPD7fLOD7//HOsWrUK1dXVGDFiBD799FOkpKQYPHbTpk1YsGCB1mNOTk6QyWT2GKrDc1uJjyaEEFRXV+Phhx/G6dOnERISAk9PT6SlpSE9Pb1XVZwzNTyMG3JXJglm372mpgYtLS3w9PREYGAggoKC7FYoyLhrh4eHIywszC6vaQuuXLmCiooKxMfHQywW61n9MELkaFY/mjiS8GhCCMG2bduwfPlyzJgxA5cvX8bRo0cRHR2NvXv32jR9fdu2bZg7dy7WrVuH1NRUrF27Ftu3b0dxcbFBb8RNmzbh3//+N4qLi9nHeDxer437WZvbVnza2trw4IMPoqysDPv27YOXlxd+/vln7Ny5E3/88QcGDhyItLQ0zJo1y6FrY9ra2pCdnQ0vLy+rmVLqZni5u7uzKyJbTZjGfNp6E0y87fr160hISNCrPzNk9cMIUU9b/WjiqMIDADt37sSTTz6Jn376CdOmTQNA104dOHAAs2fPtulYU1NTkZycjM8++wwAvS3Yr18/PPvss3j11Vf1jt+0aROWLFmC5uZmm42pN3Pbio9SqcTbb7+NF198Uc9Ys6WlBXv37sXOnTvx22+/oU+fPuyKKC4uzmGEqKWlBdnZ2ejbt6/NLFqYAHBNTY2WN1pQUJDVKtbN9WlzZJhsy5qaGiQmJnbqPGHI6kczI7GnrjG1Wo3s7GwAtN2/IyV67N27F//85z/xv//9D+np6XZ9bYVCAVdXV2RkZGi99rx589Dc3Iyff/5Z7zmbNm3CokWL0LdvX1AUhYSEBLz//vuIiYmx48gdl9tWfMxFIpHgl19+wY4dO/DLL7/A398fM2fORHp6OpKTk3tskmBWCva0/FGr1VpFrUKhUKtBXleE6OrVqygtLbXYp82RIITg4sWLaGhoQFJSksXblBRFsW02NAPr9s5IdGTh+fXXXzF37lxs2rQJ999/v91fv6qqCn379sWff/6plVX38ssv49ixYzhz5ozec06fPo1Lly5h+PDhaGlpwerVq3H8+HEUFBT02tW9NeHExwKkUil+++037NixA/v374e7uztmzJiB9PR0jBo1ym5f1srKSpSUlCAmJqbHVgpMqjHTII+pJQoKCjKrFbM1fdp6EoqiUFBQgNbWViQmJnY7ocBQQzdbuJvr4sjCc+jQITz00ENYv349Hn744R7ZnuyK+OiiVCoRHR2Nhx56CO+8844th9srcJzN3F6Aq6srZs2ahVmzZkEmk+HgwYPYsWMHHnroIYjFYkyfPh2zZs3CHXfcYRNbeUKIVjC7J1sB8/l8+Pv7w9/fX+vOvaCgAGq1WqtBnu5ExqwU6uvrkZyc3GvbOlAUhfz8fEilUiQlJVlFGHg8Hjw9PeHp6YmIiAjW6qeqqgpFRUVsIkh3rX40UalUWsW8jiQ8x48fx8MPP4zPPvusx4QHgFbqvCY1NTVmN6gTiUSIj49nu5je7nArHyugVCpx5MgRZGRk4OeffwZFUZg2bRpmzZqFsWPHWqV+prMaHkeBMelkGuQxNS/MnTufz7erT5utYCr+GVdne9RIWcvqRxNHFp5Tp07hvvvuw+rVq/H444/3eEJGamoqUlJS8OmnnwKgv5P9+/fHM888YzDhQBe1Wo2YmBhMnToVa9assfVwHR5OfKyMSqXCiRMnkJGRgd27d0MqlbI9iSZMmNClbRnGvl4mk/Uarzmgo6iVqSVqa2uDUCiEQCBAQkJCr13xqFQq5OTkgBCCuLi4Hmmepmsqa67Vj+45HFV4zp49i7S0NLz33nt4+umne1x4ADrVet68eVi/fj1SUlKwdu1a/PTTTygqKkJQUBDmzp2Lvn37YuXKlQCAFStWYOTIkYiIiEBzczNWrVqF3bt3IzMzE0OHDu3hd9PzcOJjQ9RqNf7880+2J1FzczMmT56MtLQ0TJw40axtE4VCgezsbAgEAowYMcIhukR2BYVCgczMTKjVaohEIty8eRPe3t7sFlJvEVTGb04gEDjMhG3I6odZbRra9gQcW3iysrIwY8YMLFu2DEuXLnUI4WH47LPP2CLTuLg4fPLJJ0hNTQUAjBs3DmFhYdi0aRMAYOnSpdi5cyeqq6vh4+ODxMREvPvuu4iPj+/Bd+A4cOJjJyiKwrlz51gH7urqavzjH/9Aeno6Jk+ebLAnkVQqRVZWFjw9PREbG+swKd6Wwvi0ubm5ITY2FgKBADKZjF0RNTc32ySWYW0UCgWysrLg5OSE4cOHO9SEzWDI6kczc04sFrPCw9zQONL7yMvLw9SpU/Hyyy/jlVdecSjh4bAunPj0AEz7YUaIysvLcc899yAtLQ1Tp06Fl5cXjh8/jvz8fEycOLFX2swwmOPTplAotBrkubm5sULk7u7uEO9dLpcjMzMT7u7uveZGgLH6YYRIIpHAy8sLMpkMzs7OSEhIcCjhKSwsxOTJk/Hss89i+fLlDvF357AdnPj0MIQQXLhwgRWi4uJipKam4ty5c3juued69ZeQaRdtSREsU9TKxDKcnJzYluGd2evbCplMhszMTHh5eTm020VnSCQSZGdnQ6VSQa1W28W5wlyKioowZcoULFq0CO+++26vveY5zIcTHweCEIL3338fb7/9NoYNG4b8/HytnkQBAQG95kvZ2NiI3Nzcbvm06boACAQCraJWe4iAVCpFZmYm/P39ERUV1Ws+f12YWJVQKMSIESNAURTbQ4cRed0uuPbi8uXLmDx5Mh5++GF8+OGHvVbcOSyDEx8H4oMPPsDKlSuxe/dujB07FleuXGF7EmVmZmLUqFFIT0/HzJkzERIS4rATYW1tLS5cuIDIyEj07dvXKuc0FFRnJktb2dG0tbUhMzMTQUFBGDJkiMN+3p3BCI9IJDIYq2JEnhEj3eaDthSDsrIyTJkyBenp6Vi7di0nPLcRnPg4EAcOHEDfvn0xbNgwrccJIaioqGB7Ev31119ITk5mbX769evnMBMjUwwZGxtr0OnXGhBC2KLW2tpaqFQqrQZ51ohj3Lx5E5mZmQgNDcWgQYMc5vO1FKVSiaysLIjFYowYMaLTyV3X6kepVGplzlkz27KiogKTJ0/G5MmT8cUXX3DCc5vBiU8vgxCCqqoq7Nq1Czt37sSJEycwYsQIpKenIy0tDQMHDuyxiZLxaYuLi4Ovr69dXlOzqLW2thYymUxLiLoyWba0tCArKwthYWF26xNjCywVHl1safVz48YNTJo0CWPHjsWGDRscKvGBwz5w4tOLIYSgtrYWu3fvxs6dO3HkyBFER0cjPT0d6enpdtsqchSfNkPZXcxkGRgYaJYLAdNTaNCgQXYzbLUF3RUeQ0ilUlaINHs+BQQEWFQwXF1djSlTpiAlJQWbNm3ihOc2hROfWwRCCBobG9meRAcPHsSgQYPYnkS2aket6ejsaK4FzGRZW1uL1tZWeHl5ISgoCAEBAQZtfRoaGpCbm2vVWFVPYAvh0YWx+qmrq0NDQwNcXV1ZITKVlVhXV4epU6ciNjYW//vf/xyqVxCHfeHE5xalublZqydRaGgo25PIWhMSRVG4cOECJBIJEhISHNqlQCaTsbVETU1N8PDw0EozZpIkoqOjERIS0tPD7TJKpRKZmZlwdnbG8OHD7RJHUalUbFZifX290azEhoYGTJs2DYMGDcJPP/3Ua906OKwDJz63ATdv3mR7Ev36669sT6JZs2YhKSmpSxOUSqVCbm4uVCqV3Yw1rQXTUZRpkCcWiyGXyzFkyBD079+/VycX2Ft4dGGyEhmhv3btGnbv3o2JEyfiu+++Q9++fbFz5067XS+ff/45a4czYsQIfPrpp0hJSTF6/Pbt27Fs2TKUl5dj8ODB+OCDDzB16lS7jPV2gxOf2wypVIoDBw6wPYk8PT3ZnkQjR440a/+d8ZtjakZ689bJtWvXUFxcDC8vL9y8eRNisbjH6l26AyM8Li4uGDZsmENkjhFCUFhYiE8//RS//fYbpcY1SQAAGbtJREFU6uvrMXXqVNx3332YPn06/P39bfr627Ztw9y5c7Fu3TqkpqZi7dq12L59O4qLiw1mYv75558YM2YMVq5cienTp2PLli344IMPkJWVhdjYWJuO9XaEE5/bGJlMhj/++AM7duzAnj174OTkhBkzZrA9iQyJiqZPm6NMcl3l2rVruHTpEpudZ6i1NdMy3F5FrV3BEYWHQSKRYNasWRCLxfjoo49w4MAB7N69GxcuXEBdXZ1NY4SpqalITk7GZ599BoBelfXr1w/PPvuswRYIDz74INra2rBv3z72sZEjRyIuLg7r1q2z2ThvVzjx4QBAr2Y0exIRQtjmeGPGjIFYLEZeXh7Onz+P1NRUDB06tNesCgxRXl6OsrIyxMfHw9vbW+/3FEWhqamJTVgghGgVXjpKhhZjduqIwiOVSnHfffcBANv5l6G+vt6mKx+FQgFXV1dkZGQgPT2dfXzevHlobm7Gzz//rPec/v374/nnn8eSJUvYx958803s3r0bubm5Nhvr7YrjXKlW4L333sPo0aPh6upqcEIxBCEEy5cvR0hICFxcXHDPPffg0qVLth2oAyIWizFp0iR89dVXqKqqwrZt2+Di4oKnnnoKAwcOxGOPPYZJkyahoKCgVwsPkxZeXl6OxMREo9cJn8+Hn58foqOjMWbMGMTFxUEoFKKoqAjHjh1DXl4eampqoFKp7PsGNGDaVDii8LS3t2POnDlQKpXYu3evXvNDW2+51dfXQ61W67WZDwoKQnV1tcHnVFdXW3Q8R/dwnKvVCigUCtx///1YvHix2c/58MMP8cknn2DdunU4c+YM3NzcMGnSJMhkMhuO1LERCoW4++678cUXX+DatWt46623sG/fPoSEhGDLli1YuHAhfv75Z0il0p4eqkUQQnDp0iVUVlYiKSkJnp6eZj2Px+PB29sbkZGRuPPOO5GUlARXV1eUlpbi2LFjyMnJQVVVFZRKpY3fQQeM8Dji9qdcLsejjz6K1tZW/PLLL2Z/zhy3F45zxVqBt99+G0uXLtWzpzEGIQRr167FG2+8gbS0NAwfPhybN29GVVUVdu/ebdvB9hL279+P1157DV9++SUKCwvZtO033ngDYWFhePTRR5GRkQGJRNLTQzUJIQTFxcWoqalBUlJSl9uQ83g8eHp6IiIiAqNHj0Zqaiq8vLxQUVGBY8eOITMzE9euXYNcLrfyO+hAU3gcrb2DQqHA3LlzUV1djQMHDpi9A2FtGJulmpoarcdramoQHBxs8DnBwcEWHc/RPRznqu0BysrKUF1djXvuuYd9zMvLC6mpqTh9+nQPjsxxkMlk+P777/HPf/4TfD4fI0eOxOrVq3Hp0iUcO3YMkZGReO+99xAWFoYHH3wQP/74I1paWuBIoUQm66q+vh5JSUlWDXK7u7sjPDwcI0eOxB133AF/f39UV1fjxIkTOHfuHK5evYr29narvZ4jC49SqcTChQtRXl6O33//3W4WS4YQi8VITEzEoUOH2McoisKhQ4cwatQog88ZNWqU1vEA8Mcffxg9nqN79N4cWSvA7OVy+7zGeeCBBww+zufzkZiYiMTERLz//vu4cOECtm/fjrVr1+Jf//oX7r77bqSlpWH69Onw8fHpsRiRZiFsUlKSTQthXVxcMGDAAAwYMIB1AKitrcWlS5e0eud0ddXlyMKjUqnw1FNP4eLFizhy5AgCAgJ6ekh4/vnnMW/ePCQlJSElJQVr165FW1sbFixYAACYO3cu+vbti5UrVwIA/v3vf2Ps2LH46KOPMG3aNGzduhXnz5/Hhg0bevJt3LI4ztVrhFdffRU8Hs/kv6Kiop4e5m0Nj8fDsGHDsGLFCuTl5SEnJwejR4/Ghg0bMHDgQKSlpeGbb75hs8bsBUVRyMvLg1Qqtbnw6OLk5ITQ0FAkJCRg7Nix6N+/P1pbW3HmzBn8+eefuHz5MlpbW83+PBQKBc6fP++QnVTVajWeeeYZZGZm4uDBg3o3cz3Fgw8+iNWrV2P58uWIi4tDTk4ODhw4wI6voqICN27cYI8fPXo0tmzZgg0bNmDEiBHIyMjA7t27uRofG+HwqdaMd5QpBg4cqFUxvWnTJixZsgTNzc0mn3flyhUMGjQI2dnZiIuLYx8fO3Ys4uLi8PHHH3dn6Lc9TGYZ05MoKysLo0ePRlpams17EqnVai0HBkexctG0oqmrq4NIJNKyojH0eTDC4+HhgZiYGIcSHoqi8O9//xtHjx7FkSNHerUZK4d9cXjx6Qrmig8hBH369MGLL76IF154AQDd+jkwMBCbNm3CnDlz7DDa2wOmJxEjRGfOnEFKSgpmzpyJtLQ0q/YkUqlUyM7OBo/HY1OkHRG1Wq3VII9p4hYUFAQfHx/w+XzI5XJkZmY6rPC89NJL+OWXX3D06NFe3X6Cw/7cUuJTUVGBxsZG7NmzB6tWrcKJEycAABEREew+e1RUFFauXIlZs2YBoLuH/ve//8V3332H8PBwLFu2DHl5eSgsLHRoo8zeDNOTiGmOd/LkScTFxbE9icLDw7ssRIyjs0gkwogRIxymGLQzNJu41dbWQq1Ww9fXFy0tLfDx8UFsbKxD1VZRFIXXXnuNbeUxePDgnh4SRy/jlhKf+fPn47vvvtN7/MiRIxg3bhwAOj7x7bffYv78+QDoifDNN9/Ehg0b0NzcjDvvvBNffPEFhgwZYseR374QQlBTU8P2JDp69CiGDh3KCpElPYk0iy57yljTGhBCUF9fj4KCAlAUBQBaDfJ6eiVHCMFbb72FH374AUeOHEFUVFSPjoejd3JLiQ9H74bpScQI0cGDBzF48GC2FYSpnkSM55wjBuQthdlq8/T0xNChQ7Ua5LW1tcHPz4/tnWNvN3FCCFauXIkNGzbg8OHDXDCeo8tw4sPhkBBC0NLSgj179mDnzp34/fff0a9fP1aINFc2lZWVKCsrg6+vb6+2/gFo4Tl//jy8vLwQExOj9140hejmzZvw8fFhhcjW28SEEHz00Uf4+OOPcfjwYYwYMcKmr8dxa8OJD0ev4ObNm9i/fz/bkygwMBAzZ85EfHw8XnzxRbz22mt44oknerXwyGQyZGZmwtvb2ywRlclkrBA1Nzezba0DAwPh6upq1bERQvDJJ59g1apV+P3335GUlGTV83PcfvTevYleQGNjIx555BF4enrC29sbCxcu7NSGZty4cXp1TE899ZSdRuy4eHh4YM6cOdi+fTtqamqwatUqlJSUYNGiRQgNDcXly5dx+vRpqNXqnh5ql7BUeADA2dkZ/fv3R1JSEsaMGYM+ffqgsbERf/75J06fPo3S0lJIJJJu11YRQrBu3Tp88MEH+OWXXzjh4bAK3MrHhkyZMgU3btzA+vXroVQqsWDBAiQnJ2PLli1GnzNu3DgMGTIEK1asYB9zdXXlzBl1yMrKwsSJE7F48WIkJSVh165d2LNnD5ydndmeRKNHj+7x4Lw5dEV4TKFUKlFfX8+2tXZ2dmZXRJ6enhadnxCCb775Bq+//jr279+Pu+66q1tj4+Bg4MTHRly8eBFDhw7FuXPn2DvFAwcOYOrUqaisrESfPn0MPm/cuHGIi4vD2rVr7Tja3gUhBOPGjcPMmTPZ+iyAznY7fPgwduzYgd27d4PH42H69OlIT09nexI5GtYWHl3UarWWEAmFQrYvUWe2R4QQfP/993jppZewd+9eNmOUg8MacOJjI7755hu88MILaGpqYh9TqVRwdnbG9u3b2TojXcaNG4eCggIQQhAcHIwZM2Zg2bJlVt/D7+3IZDKTAXaVSoVjx46xFilyuRzTp09HWloa7r77bjg5OdlxtIaRyWQ4f/48fH19ER0dbfN4FUVRbFFrbW0tALArIl9fX60MQUIItm3bhueeew47d+7ExIkTbTo2jtsPLuZjI6qrq/X6xAuFQvj6+po0LX344YfZ+on//Oc/+P777/Hoo4/aeri9js4yu4RCISZMmIAvv/wSlZWV2L17N7y9vbFkyRKEh4dj4cKF2LNnT4/1JLK38AC0Gay/vz+GDh2KsWPHshmDhYWFbIO8LVu24ObNm9i5cyeeffZZbNu2rUeFh4ub3rpwKx8LefXVV/HBBx+YPObixYvYuXMnvvvuOxQXF2v9LjAwEG+//bbZDe8OHz6MCRMm4PLlyxg0aFCXx81BQ1EUzpw5g4yMDOzatQt1dXWYOHEi0tPTMWnSpC47TltCTwiPKQghaG1tRUFBAebPn4+6ujo4OTlh4cKFePPNN3usJw/AxU1vZTjxsRBzjU5/+OGHLm276dLW1gZ3d3ccOHAAkyZN6tbYObShKApZWVnIyMjAzp07UVlZiXvuuQfp6emYMmWKxcF5c2hvb0dmZib8/PwQFRXV48Kjy/79+/HSSy8hNTUVxcXFKCwsxIQJE7B27VpERkbadSxc3PTWhtt2s5CAgABERUWZ/CcWizFq1Cg0NzcjMzOTfe7hw4dBURRSU1PNfr2cnBwAQEhIiLXfym0Pn89HUlIS/vvf/6KoqAh//fUXRowYgTVr1iA8PBz3338/vv/+ezQ2NlqlFYSjC8/Bgwcxf/58vP/++9i2bRtycnJw8eJFTJgwoUcaw50+fRre3t5aqd333HMP+Hw+zpw5Y/K5//vf/+Dv74/Y2Fj85z//6XUt328HuJWPDZkyZQpqamqwbt06dssgKSmJ3TK4fv06JkyYgM2bNyMlJQWlpaXYsmULpk6dCj8/P+Tl5WHp0qUIDQ3FsWPHevjd3D4QQnDx4kV2a66goABjx45FWloaZsyYAX9/f4uFo729HefPn4e/v79DCs+xY8dw//3347PPPsO8efMcYnzvv/9+l7auN2zYgAEDBqBPnz7Iy8vDK6+8gpSUFOzcudMew+YwE27lY0P+97//ISoqChMmTMDUqVNx5513anVFVCqVKC4uZu/KxGIxDh48iIkTJyIqKgovvPAC7rvvPuzdu7en3sJtCY/Hw9ChQ7F8+XJkZWWhoKCAvUmIiIjAtGnTsH79ety4ccOsFREjPMyq2REmdk1OnTqFBx54AGvWrLGL8Ni6QeQTTzyBSZMmYdiwYXjkkUewefNm7Nq1C6WlpVZ8FxzdhVv5cHCYCSEEV69e1epJlJqairS0NKSlpSE0NFRv4tYUnsjISIcTnjNnziA9PR3vvfcenn76abuMj4ubcgCc+HBwdAlCCK5fv872JDp16hTi4+PZVhBhYWEoLi7Gpk2bMH/+fIcUnszMTMycORPLly/HkiVLHG58TMLB+fPnkZiYCAD4/fffMXnyZJMJB7qcOnUKd955J3JzczF8+HBbDpnDArhtt9uAzz//HGFhYXB2dkZqairOnj1r8vjt27cjKioKzs7OGDZsGH755Rc7jbT3wOPxEBoaiueeew5HjhzBtWvXsGDBAhw5cgTx8fEYOXIkJk2ahOvXr2Pw4MEON7Hn5uYiLS0Nr776qkMKDwBER0dj8uTJePzxx3H27FmcOnUKzzzzDObMmcMKz/Xr1xEVFcVe06WlpXjnnXeQmZmJ8vJy7NmzB3PnzsWYMWM44XE0CMctzdatW4lYLCbffPMNKSgoII8//jjx9vYmNTU1Bo8/deoUEQgE5MMPPySFhYXkjTfeICKRiOTn59t55L0TiqLI2bNnia+vL4mKiiIikYjExsaS119/nZw7d45IJBLS1tbWo//Onj1L/Pz8yNtvv00oiurpj8wkDQ0N5KGHHiLu7u7E09OTLFiwgNy8eZP9fVlZGQFAjhw5QgghpKKigowZM4b4+voSJycnEhERQV566SXS0tLSQ++AwxjcttstTmpqKpKTk/HZZ58BoGtb+vXrh2effRavvvqq3vEPPvgg2trasG/fPvaxkSNHIi4uDuvWrbPbuHsrpaWlGDduHO6//36sXr0aLS0t2Lt3L3bs2IHff/8dAwYMwMyZMzFr1iwMGzbM7k3vioqKMGXKFCxatAjvvvuuQ654OG4PuG23WximrfQ999zDPsbn83HPPffg9OnTBp9z+vRpreMBYNKkSUaP59BGIBBg8eLF+Oijj8Dn8+Hj44O5c+fi559/Rk1NDd58801cuXIF//jHPzBixAi8/vrrOH/+PNsu25ZcunQJ06dPx9y5c/HOO+9wwsPRo3DicwtTX18PtVqNoKAgrceDgoKM+stVV1dbdDyHNmFhYXjttdcMTuyenp546KGHkJGRgZqaGnzwwQeorq7GjBkzEBMTg1deecVmPYnKysowffp0zJ49Gx988EGvbjPOcWvAXYEcHD2Am5sbZs+ejR9//BHV1dX45JNP0Nraivvvvx9RUVF4/vnncfz4cahUqm6/VkVFBaZNm4Zp06Zh7dq1nPBwOATcVXgL4+/vD4FAgJqaGq3Ha2pqEBwcbPA5wcHBFh3P0X1cXFyQlpaG7777DtXV1fjqq6+gUqnw2GOPISIiAs8++ywOHToEpVJp8bmrqqowbdo0TJgwAZ9//jknPBwOA3cl3sKIxWIkJibi0KFD7GMUReHQoUMYNWqUweeMGjVK63gA+OOPP4wez2FdxGIxpk6diq+//hpVVVXYsmULRCIRHn/8cQwcOBCLFy/GgQMHIJfLOz1XdXU1pk2bhjvuuAMbNmyAQCCwwzvg4DCTnk6347AtW7duJU5OTmTTpk2ksLCQPPHEE8Tb25tUV1cTQgh57LHHyKuvvsoef+rUKSIUCsnq1avJxYsXyZtvvsmlWjsAKpWKHD16lDzzzDMkNDSUeHl5kTlz5pCtW7eS+vp6vXTq8vJyMnToUPLggw8SpVLZ08Pn4NCDE5/bgE8//ZT079+fiMVikpKSQv766y/2d2PHjiXz5s3TOv6nn34iQ4YMIWKxmMTExJD9+/fbecQcplCr1eTUqVNk6dKlJDw8nLi7u5P77ruPfP/996SmpoZUVFSQYcOGkVmzZhGFQtHTw+XgMAhX58PB0YuhKAqZmZmsA/e1a9fg7OyMlJQU7N27F2KxuKeHyMFhEE58ODhuERghWrZsGXbs2AE3N7eeHhIHh1E48eHg4ODgsDtcthtHj2CJ2emmTZv0+r04OzvbcbQcHBzWhhMfDruzbds2PP/883jzzTeRlZWFESNGYNKkSaitrTX6HE9PT9y4cYP9d/XqVTuOmMNc3nvvPYwePRqurq7w9vY26zmEECxfvhwhISFwcXHBPffcg0uXLtl2oBw9Dic+HHZnzZo1ePzxx7FgwQIMHToU69atg6urK7755hujz+HxeAgODmb/6VoAcTgGCoUC999/v9EW14b48MMP8cknn2DdunU4c+YM3NzcMGnSJMhkMhuOlKOn4cSHw650xewUACQSCQYMGIB+/fohLS0NBQUF9hguh4W8/fbbWLp0KYYNG2bW8YQQrF27Fm+88QbS0tIwfPhwbN68GVVVVdi9e7dtB8vRo3Diw2FXumJ2GhkZiW+++QY///wzfvjhB1AUhdGjR6OystIeQ+awIWVlZaiurta6GfHy8kJqairnpH6LI+zpAXBwdMaoUaO07H1Gjx6N6OhorF+/Hu+8804PjoyjuzA3HJyT+u0Ht/LhsCtdMTvVRSQSIT4+HpcvX7bFEDl0ePXVV/WyDXX/FRUV9fQwOXoZ3MqHw65omp2mp6cD6DA7feaZZ8w6h1qtRn5+PqZOnWrDkXIwvPDCC5g/f77JYwYOHNilczM3HDU1NQgJCWEfr6mpQVxcXJfOydE74MSHw+48//zzmDdvHpKSkpCSkoK1a9eira0NCxYsAADMnTsXffv2xcqVKwEAK1aswMiRIxEREYHm5masWrUKV69exaJFi3rybdw2BAQEICAgwCbnDg8PR3BwMA4dOsSKTWtrK86cOWNRxhxH74MTHw678+CDD6Kurg7Lly9HdXU14uLicODAAXbfv6KiQqvvTFNTEx5//HFUV1fDx8cHiYmJ+PPPPzF06NCeegscRqioqEBjYyMqKiqgVquRk5MDAIiIiIC7uzsAICoqCitXrsSsWbPA4/GwZMkSvPvuuxg8eDDCw8OxbNky9OnTh10Zc9yacPY6HBwcVmP+/Pn47rvv9B4/cuQIxo0bB4Cu2fr222/ZrTxCCN58801s2LABzc3NuPPOO/HFF19gyJAhdhw5h73hxIeDg4ODw+5w2W4cHBocP34cM2bMQJ8+fcDj8cwqdDx69CgSEhLg5OSEiIgIbNq0yebj5ODo7XDiw8GhQVtbG0aMGIHPP//crOPLysowbdo0jB8/Hjk5OViyZAkWLVqE3377zcYj5eDo3XDbbhwcRuDxeNi1a5fJwPcrr7yC/fv348KFC+xjc+bMQXNzMw4cOGCHUXJw9E64lQ8HRzc4ffq0ljUMAEyaNImzhuHg6AROfDg4ukF1dbVBa5jW1la0t7f30Kg4OBwfTnw4ODg4OOwOJz4cHN0gODjYoE+dp6cnXFxcemhUHByODyc+HBzdYNSoUTh06JDWY3/88YeWCzcHB4c+nPhwcGggkUiQk5PD2sKUlZUhJycHFRUVAID//Oc/mDt3Lnv8U089hStXruDll19GUVERvvjiC/z0009YunRpTwyfg6PXwKVac3BocPToUYwfP17v8Xnz5mHTpk2YP38+ysvLcfToUa3nLF26FIWFhQgNDcWyZcs6dYHm4Ljd4cSHg4ODg8PucNtuHBwcHBx2hxMfDg4ODg67w4kPBwcHB4fd4cSHg4ODg8PucOLDwcHBwWF3OPHh4ODg4LA7nPhwcHBwcNgdTnw4ODg4OOwOJz4cHBwcHHaHEx8ODg4ODrvDiQ8HBwcHh93hxIeDg4ODw+78P6WraKVsEAEhAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# sphere data\n", + "fig = plt.figure()\n", + "ax1 = fig.add_subplot(111, projection=\"3d\")\n", + "\n", + "ax1.plot(Y1, Y2, Y3, \"*\", c=\"b\", label=\"Sphere\")\n", + "ax1.legend(loc=\"upper left\")\n", + "ax1.axis(\"equal\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "383a17a7-6c4f-49fc-aa4d-322f820ac18e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0.31087872 0.01905156 -0.19413813]\n", + " [ 0.01905156 1.21114085 2.27200637]\n", + " [-0.19413813 2.27200637 5.13099624]]\n", + "[6.17646933 0.35752001 0.11902648]\n" + ] + } + ], + "source": [ + "print(cov)\n", + "print(np.linalg.eigvals(cov))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "570cf521-f62f-4e62-98e4-0aea8e4f72db", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# mvg data\n", + "fig = plt.figure()\n", + "ax1 = fig.add_subplot(111, projection=\"3d\")\n", + "\n", + "ax1.plot(data[:, 0], data[:, 1], data[:, 2], \"*\", c=\"b\", label=\"MVG\")\n", + "ax1.legend(loc=\"upper left\")\n", + "ax1.axis(\"equal\")\n", + "elev = 20\n", + "azim = 50\n", + "roll = 0\n", + "ax1.view_init(elev, azim, roll)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "438211c0-228c-453d-aaec-02813988177f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1000, 3)\n" + ] + } + ], + "source": [ + "# now we will embed in high-dimensions\n", + "data, mean, cov = mvg_data\n", + "print(data.shape)\n", + "X = embed_high_dims(data, n_dims=50, random_state=seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ff5c92e5-65e6-4990-9287-708e4af32450", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1000, 21) (1000, 3)\n" + ] + } + ], + "source": [ + "X = embed_high_dims(data[:, [0]], n_dims=n_noise_dims, random_state=seed)\n", + "Y = embed_high_dims(data[:, [1]], n_dims=n_noise_dims, random_state=seed)\n", + "Z = embed_high_dims(data[:, [2]], n_dims=n_noise_dims, random_state=seed)\n", + "highdim_data = np.hstack((X, Y, Z))\n", + "\n", + "print(X.shape, data.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "2e7eb0d5-75f9-4934-af65-1985bb395b38", + "metadata": {}, + "source": [ + "### Unsupervised KSG approach" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "cc2209c6-3562-44e2-95d9-8343e24b5e28", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1000, 21) (1000, 21) (1000, 42)\n" + ] + } + ], + "source": [ + "# define the forest-based estimator to determine distances\n", + "clf = UnsupervisedObliqueRandomForest(\n", + " n_estimators=n_estimators,\n", + " feature_combinations=feature_combinations,\n", + " min_samples_split=int(np.sqrt(2 * n_samples)),\n", + " n_jobs=n_jobs,\n", + " random_state=seed,\n", + ")\n", + "\n", + "# meta-estimator for nearest-neighbor lookup\n", + "est = NearestNeighborsMetaEstimator(\n", + " estimator=clf,\n", + " n_neighbors=n_nbrs,\n", + " algorithm=\"auto\",\n", + " n_jobs=n_jobs,\n", + " force_fit=True,\n", + " verbose=True,\n", + ")\n", + "\n", + "data = np.hstack((X, Y))\n", + "print(X.shape, Y.shape, data.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "aadc7bb0-40e5-4e5c-9e99-f810d570b19f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0.31087872 0.01905156 -0.19413813]\n", + " [ 0.01905156 1.21114085 2.27200637]\n", + " [-0.19413813 2.27200637 5.13099624]]\n" + ] + } + ], + "source": [ + "print(cov)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "d49a1ad6-55f3-42aa-b68c-26b009970ad7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1000, 21) (1000, 21) (1000, 42)\n" + ] + } + ], + "source": [ + "print(X.shape, Y.shape, data.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "3bded813-31ea-44ba-bf77-973b3338f0fc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8879202209746868\n", + "0.09749224201325823\n" + ] + } + ], + "source": [ + "# true MI and CMI\n", + "true_mi = mi_gaussian(cov, 1, 2)\n", + "true_cmi = cmi_gaussian(cov, 0, 1, 2)\n", + "print(true_mi)\n", + "print(true_cmi)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "c051b1e1-4262-49c0-8383-74565b192a6b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finished fitting estimator: UnsupervisedObliqueRandomForest(feature_combinations=2.0, min_samples_split=44,\n", + " n_jobs=-1, random_state=12345)\n", + "Finished computing distance matrix: (1000, 1000)\n", + "Finished fitting estimator: UnsupervisedObliqueRandomForest(feature_combinations=2.0, min_samples_split=44,\n", + " n_jobs=-1, random_state=12345)\n", + "Finished computing distance matrix: (1000, 1000)\n", + "Finished computing distance matrix: (1000, 1000)\n", + "Computing radius neighbors for 1000 samples\n", + "Computing radius neighbors in parallel...\n", + "Finished fitting estimator: UnsupervisedObliqueRandomForest(feature_combinations=2.0, min_samples_split=44,\n", + " n_jobs=-1, random_state=12345)\n", + "Finished computing distance matrix: (1000, 1000)\n", + "Finished computing distance matrix: (1000, 1000)\n", + "Computing radius neighbors for 1000 samples\n", + "Computing radius neighbors in parallel...\n", + "0.4266301582681855\n" + ] + } + ], + "source": [ + "geo_ksg_mi = mutual_info_ksg(\n", + " X, Y, nn_estimator=est, n_jobs=n_jobs, k=0.2, verbose=False\n", + ")\n", + "print(geo_ksg_mi)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "162653a5-d2f9-4e17-91fa-04be2c8515d7", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4266301582681855\n" + ] + } + ], + "source": [ + "print(geo_ksg_mi)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "5a56b255-4f29-4ce7-a0ee-616063c10ad5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.478563245379208\n" + ] + } + ], + "source": [ + "ksg_mi = mutual_info_ksg_nn(X, Y, n_jobs=n_jobs, k=0.2, verbose=False)\n", + "print(ksg_mi)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "21a59855-6d48-490e-b746-231871281d9e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0795154036298156\n" + ] + } + ], + "source": [ + "nn_estimator = NearestNeighbors(\n", + " n_neighbors=5, algorithm=\"kd_tree\", p=np.inf, n_jobs=n_jobs\n", + ")\n", + "ksg_mi = mutual_info_ksg(\n", + " X, Y, nn_estimator=nn_estimator, n_jobs=n_jobs, k=0.3, verbose=False\n", + ")\n", + "print(ksg_mi)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "5bbc83e4-a7d1-4639-82b8-f4efe621c7ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0795154036298156\n" + ] + } + ], + "source": [ + "print(ksg_mi)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "5f2aea06-d2d1-4320-a3fd-3aecca36fb14", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'col_idx' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[27], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m nn_estimator\u001b[38;5;241m.\u001b[39mfit(data[:, \u001b[43mcol_idx\u001b[49m])\n\u001b[1;32m 3\u001b[0m nn \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx, radius \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(radius_per_sample):\n", + "\u001b[0;31mNameError\u001b[0m: name 'col_idx' is not defined" + ] + } + ], + "source": [ + "nn_estimator.fit(data[:, col_idx])\n", + "\n", + "nn = []\n", + "for idx, radius in enumerate(radius_per_sample):\n", + " nn_ = nn_estimator.radius_neighbors(\n", + " X=np.atleast_2d(data[:, col_idx]), radius=radius, return_distance=False\n", + " )\n", + " nn.append(nn_[idx])\n", + "print(np.array([len(nn_) for nn_ in nn]))" + ] + }, + { + "cell_type": "markdown", + "id": "9dae4346-5af2-4435-ad9d-a7dab1681d22", + "metadata": {}, + "source": [ + "### Supervised entropy estimate approach\n", + "\n", + "This is tabled until we get \"proba\" estimates for regression trees." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "77cc2540-819a-4fdd-b426-29c377490195", + "metadata": {}, + "outputs": [], + "source": [ + "estimator = ObliqueRandomForestRegressor(n_estimators=n_estimators, n_jobs=n_jobs)\n", + "sup_cmi_est = SupervisedInfoForest(estimator=estimator, y_categorical=False, n_jobs=-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "836b2183-9d0e-4454-ae8b-733b3419a659", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/utils/validation.py:1189: 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", + " y = column_or_1d(y, warn=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1000, 2) (1000,)\n" + ] + }, + { + "data": { + "text/html": [ + "
SupervisedInfoForest(estimator=ObliqueRandomForestRegressor(n_jobs=-1),\n",
+       "                     n_jobs=-1)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "SupervisedInfoForest(estimator=ObliqueRandomForestRegressor(n_jobs=-1),\n", + " n_jobs=-1)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y = Y[:, [0]]\n", + "\n", + "sup_cmi_est.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "ea70bc36-0bb5-4f96-bcd4-23763c88bb86", + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'ObliqueRandomForestRegressor' object has no attribute 'predict_proba'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/var/folders/6_/sl83qtkd68x3_mvfys07_6qm0000gn/T/ipykernel_32459/3154728669.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msup_cmi_est\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict_cmi\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Documents/scikit-tree/sktree/experimental/forest.py\u001b[0m in \u001b[0;36mpredict_cmi\u001b[0;34m(self, X, Z)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0;31m# compute the entropy of H(Y | X, Z)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 54\u001b[0;31m \u001b[0mH_yxz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator_yxz_\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict_proba\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mXZ\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 55\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 56\u001b[0m \u001b[0;31m# compute the entropy of H(Y | Z)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'ObliqueRandomForestRegressor' object has no attribute 'predict_proba'" + ] + } + ], + "source": [ + "print(sup_cmi_est.predict_cmi(X))" + ] + }, + { + "cell_type": "markdown", + "id": "67330326-469a-48de-9107-7d5cfdcfd4b7", + "metadata": {}, + "source": [ + "# Final Analysis Across All Possible Parametrizations\n", + "\n", + "Now, we want to analyze Unsup-Forest-KSG, Sup-Forest-KSG, Uncertainty-Forest, and KSG-estimator for MI. Moreover, we can implement all traditional RF and oblique RF." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "0a875b34-9a97-4bdf-ab45-14a1be6e60a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[10. 20. 30. 40. 50.]\n" + ] + } + ], + "source": [ + "# fix the number of samples, but increase the number of noise dimensions\n", + "n_samples = 10000\n", + "\n", + "n_jobs = -1\n", + "n_estimators = 300\n", + "feature_combinations = 1.5\n", + "k_ratio = 0.2\n", + "\n", + "# semi-parametric\n", + "n_nbrs = 0.2\n", + "\n", + "# hyperparameters of the simulation\n", + "alpha = 0.01\n", + "\n", + "# dimensionality of mvg\n", + "d = 3\n", + "\n", + "n_repeats = 10\n", + "\n", + "noise_dims_grid = np.linspace(10, 50, 5)\n", + "print(noise_dims_grid)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "a21a0542-2557-4863-935a-697892700973", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8879202209746868\n", + "0.9849302324167128\n" + ] + } + ], + "source": [ + "X = embed_high_dims(data[:, [0]], n_dims=n_noise_dims, random_state=seed)\n", + "Y = embed_high_dims(data[:, [1]], n_dims=n_noise_dims, random_state=seed)\n", + "Z = embed_high_dims(data[:, [2]], n_dims=n_noise_dims, random_state=seed)\n", + "highdim_data = np.hstack((X, Y, Z))\n", + "\n", + "# true MI and CMI\n", + "x_cov_idx = 0\n", + "y_cov_idx = 1\n", + "z_cov_idx = 2\n", + "true_mi = mi_gaussian(cov, y_cov_idx, z_cov_idx)\n", + "true_cmi = cmi_gaussian(cov, y_cov_idx, z_cov_idx, x_cov_idx)\n", + "print(true_mi)\n", + "print(true_cmi)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "e95a90ef-2a18-4de3-a0ad-af45a842cad1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/5 [28:33 55\u001b[0m geo_ksg_mi \u001b[38;5;241m=\u001b[39m \u001b[43mmutual_info_ksg\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 56\u001b[0m \u001b[43m \u001b[49m\u001b[43mY\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mZ\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnn_estimator\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mest\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnorm\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmax\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mk_ratio\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\n\u001b[1;32m 57\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 59\u001b[0m \u001b[38;5;66;03m# regular KSG estimator using KD-Tree\u001b[39;00m\n\u001b[1;32m 60\u001b[0m ksg_mi \u001b[38;5;241m=\u001b[39m mutual_info_ksg_nn(\n\u001b[1;32m 61\u001b[0m Y, Z, norm\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmax\u001b[39m\u001b[38;5;124m\"\u001b[39m, n_jobs\u001b[38;5;241m=\u001b[39mn_jobs, k\u001b[38;5;241m=\u001b[39mk_ratio, verbose\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m 62\u001b[0m )\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/experimental/ksg.py:258\u001b[0m, in \u001b[0;36mmutual_info_ksg\u001b[0;34m(X, Y, Z, k, norm, nn_estimator, n_jobs, transform, random_seed, verbose)\u001b[0m\n\u001b[1;32m 256\u001b[0m val \u001b[38;5;241m=\u001b[39m _cmi_ksg(data, x_idx, y_idx, z_idx, nn_estimator, knn_here)\n\u001b[1;32m 257\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 258\u001b[0m val \u001b[38;5;241m=\u001b[39m \u001b[43m_mi_ksg\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnn_estimator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mknn_here\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 260\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m norm \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmax\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 261\u001b[0m norm_constant \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mlog(\u001b[38;5;241m1\u001b[39m)\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/experimental/ksg.py:387\u001b[0m, in \u001b[0;36m_mi_ksg\u001b[0;34m(data, x_idx, y_idx, nn_estimator, knn_here)\u001b[0m\n\u001b[1;32m 384\u001b[0m n_samples \u001b[38;5;241m=\u001b[39m data\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 386\u001b[0m \u001b[38;5;66;03m# estimate distance to the kth NN in XYZ subspace for each sample\u001b[39;00m\n\u001b[0;32m--> 387\u001b[0m neigh \u001b[38;5;241m=\u001b[39m \u001b[43mnn_estimator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 388\u001b[0m dists, _ \u001b[38;5;241m=\u001b[39m neigh\u001b[38;5;241m.\u001b[39mkneighbors(n_neighbors\u001b[38;5;241m=\u001b[39mknn_here)\n\u001b[1;32m 390\u001b[0m \u001b[38;5;66;03m# - get the radius we want to use per sample as the distance to the kth neighbor\u001b[39;00m\n\u001b[1;32m 391\u001b[0m \u001b[38;5;66;03m# in the joint distribution space\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/neighbors.py:99\u001b[0m, in \u001b[0;36mNearestNeighborsMetaEstimator.fit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimator_ \u001b[38;5;241m=\u001b[39m copy(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimator)\n\u001b[1;32m 98\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mforce_fit:\n\u001b[0;32m---> 99\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mestimator_\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\n\u001b[1;32m 100\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 101\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/ensemble/_unsupervised_forest.py:156\u001b[0m, in \u001b[0;36mForestCluster.fit\u001b[0;34m(self, X, y, sample_weight)\u001b[0m\n\u001b[1;32m 145\u001b[0m trees \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m 146\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_make_estimator(append\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, random_state\u001b[38;5;241m=\u001b[39mrandom_state)\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(n_more_estimators)\n\u001b[1;32m 148\u001b[0m ]\n\u001b[1;32m 150\u001b[0m \u001b[38;5;66;03m# Parallel loop: we prefer the threading backend as the Cython code\u001b[39;00m\n\u001b[1;32m 151\u001b[0m \u001b[38;5;66;03m# for fitting the trees is internally releasing the Python GIL\u001b[39;00m\n\u001b[1;32m 152\u001b[0m \u001b[38;5;66;03m# making threading more efficient than multiprocessing in\u001b[39;00m\n\u001b[1;32m 153\u001b[0m \u001b[38;5;66;03m# that case. However, for joblib 0.12+ we respect any\u001b[39;00m\n\u001b[1;32m 154\u001b[0m \u001b[38;5;66;03m# parallel_backend contexts set at a higher level,\u001b[39;00m\n\u001b[1;32m 155\u001b[0m \u001b[38;5;66;03m# since correctness does not rely on using threads.\u001b[39;00m\n\u001b[0;32m--> 156\u001b[0m trees \u001b[38;5;241m=\u001b[39m \u001b[43mParallel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprefer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mthreads\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 157\u001b[0m \u001b[43m \u001b[49m\u001b[43mdelayed\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_parallel_build_trees\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 158\u001b[0m \u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 159\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbootstrap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 160\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 161\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 162\u001b[0m \u001b[43m \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 163\u001b[0m \u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 164\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtrees\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 165\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 166\u001b[0m \u001b[43m \u001b[49m\u001b[43mclass_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclass_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 167\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_samples_bootstrap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_samples_bootstrap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 168\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 169\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtrees\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 170\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 172\u001b[0m \u001b[38;5;66;03m# Collect newly grown trees\u001b[39;00m\n\u001b[1;32m 173\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimators_\u001b[38;5;241m.\u001b[39mextend(trees)\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/utils/parallel.py:65\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 60\u001b[0m config \u001b[38;5;241m=\u001b[39m get_config()\n\u001b[1;32m 61\u001b[0m iterable_with_config \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 62\u001b[0m (_with_config(delayed_func, config), args, kwargs)\n\u001b[1;32m 63\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m delayed_func, args, kwargs \u001b[38;5;129;01min\u001b[39;00m iterable\n\u001b[1;32m 64\u001b[0m )\n\u001b[0;32m---> 65\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \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[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43miterable_with_config\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/joblib/parallel.py:1952\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1946\u001b[0m \u001b[38;5;66;03m# The first item from the output is blank, but it makes the interpreter\u001b[39;00m\n\u001b[1;32m 1947\u001b[0m \u001b[38;5;66;03m# progress until it enters the Try/Except block of the generator and\u001b[39;00m\n\u001b[1;32m 1948\u001b[0m \u001b[38;5;66;03m# reach the first `yield` statement. This starts the aynchronous\u001b[39;00m\n\u001b[1;32m 1949\u001b[0m \u001b[38;5;66;03m# dispatch of the tasks to the workers.\u001b[39;00m\n\u001b[1;32m 1950\u001b[0m \u001b[38;5;28mnext\u001b[39m(output)\n\u001b[0;32m-> 1952\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m output \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturn_generator \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43moutput\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/joblib/parallel.py:1595\u001b[0m, in \u001b[0;36mParallel._get_outputs\u001b[0;34m(self, iterator, pre_dispatch)\u001b[0m\n\u001b[1;32m 1592\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m\n\u001b[1;32m 1594\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backend\u001b[38;5;241m.\u001b[39mretrieval_context():\n\u001b[0;32m-> 1595\u001b[0m \u001b[38;5;28;01myield from\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_retrieve()\n\u001b[1;32m 1597\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mGeneratorExit\u001b[39;00m:\n\u001b[1;32m 1598\u001b[0m \u001b[38;5;66;03m# The generator has been garbage collected before being fully\u001b[39;00m\n\u001b[1;32m 1599\u001b[0m \u001b[38;5;66;03m# consumed. This aborts the remaining tasks if possible and warn\u001b[39;00m\n\u001b[1;32m 1600\u001b[0m \u001b[38;5;66;03m# the user if necessary.\u001b[39;00m\n\u001b[1;32m 1601\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_exception \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/joblib/parallel.py:1707\u001b[0m, in \u001b[0;36mParallel._retrieve\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1702\u001b[0m \u001b[38;5;66;03m# If the next job is not ready for retrieval yet, we just wait for\u001b[39;00m\n\u001b[1;32m 1703\u001b[0m \u001b[38;5;66;03m# async callbacks to progress.\u001b[39;00m\n\u001b[1;32m 1704\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ((\u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jobs) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m\n\u001b[1;32m 1705\u001b[0m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jobs[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mget_status(\n\u001b[1;32m 1706\u001b[0m timeout\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtimeout) \u001b[38;5;241m==\u001b[39m TASK_PENDING)):\n\u001b[0;32m-> 1707\u001b[0m \u001b[43mtime\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msleep\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0.01\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1708\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[1;32m 1710\u001b[0m \u001b[38;5;66;03m# We need to be careful: the job list can be filling up as\u001b[39;00m\n\u001b[1;32m 1711\u001b[0m \u001b[38;5;66;03m# we empty it and Python list are not thread-safe by\u001b[39;00m\n\u001b[1;32m 1712\u001b[0m \u001b[38;5;66;03m# default hence the use of the lock\u001b[39;00m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "true_mis = []\n", + "ksg_mis = []\n", + "uf_ksg_mis = []\n", + "exp_idx = []\n", + "noise_list = []\n", + "\n", + "\n", + "# we are just comparing I(X; Y)\n", + "for idx in tqdm(range(len(noise_dims_grid))):\n", + " for jdx in range(n_repeats):\n", + " this_seed = seed + jdx + idx\n", + " noise_dims = noise_dims_grid[idx].astype(int)\n", + " # simulate multivariate Gaussian\n", + " mvg_data = simulate_multivariate_gaussian(d=d, n_samples=n_samples, seed=seed)\n", + " data, mean, cov = mvg_data\n", + "\n", + " X = embed_high_dims(data[:, [0]], n_dims=noise_dims, random_state=this_seed)\n", + " Y = embed_high_dims(data[:, [1]], n_dims=noise_dims, random_state=this_seed)\n", + " Z = embed_high_dims(data[:, [2]], n_dims=noise_dims, random_state=this_seed)\n", + " highdim_data = np.hstack((X, Y, Z))\n", + "\n", + " # true MI and CMI\n", + " x_cov_idx = 0\n", + " y_cov_idx = 1\n", + " z_cov_idx = 2\n", + " true_mi = mi_gaussian(cov, y_cov_idx, z_cov_idx)\n", + " true_cmi = cmi_gaussian(cov, y_cov_idx, z_cov_idx, x_cov_idx)\n", + " # print(true_mi)\n", + " # print(true_cmi)\n", + " # print(X.shape, data.shape)\n", + "\n", + " #\n", + " data = np.hstack((Y, Z))\n", + " # print(X.shape, Y.shape, data.shape)\n", + "\n", + " # now estimate both MIs\n", + " # define the forest-based estimator to determine distances\n", + " clf = UnsupervisedObliqueRandomForest(\n", + " n_estimators=n_estimators,\n", + " feature_combinations=feature_combinations,\n", + " min_samples_split=int(np.sqrt(2 * n_samples)),\n", + " n_jobs=n_jobs,\n", + " random_state=seed,\n", + " )\n", + "\n", + " # meta-estimator for nearest-neighbor lookup\n", + " est = NearestNeighborsMetaEstimator(\n", + " estimator=clf,\n", + " n_neighbors=n_nbrs,\n", + " algorithm=\"auto\",\n", + " n_jobs=n_jobs,\n", + " force_fit=True,\n", + " verbose=False,\n", + " )\n", + " geo_ksg_mi = mutual_info_ksg(\n", + " Y, Z, nn_estimator=est, norm=\"max\", n_jobs=n_jobs, k=k_ratio, verbose=False\n", + " )\n", + "\n", + " # regular KSG estimator using KD-Tree\n", + " ksg_mi = mutual_info_ksg_nn(\n", + " Y, Z, norm=\"max\", n_jobs=n_jobs, k=k_ratio, verbose=False\n", + " )\n", + "\n", + " true_mis.append(true_mi)\n", + " uf_ksg_mis.append(geo_ksg_mi)\n", + " ksg_mis.append(ksg_mi)\n", + " exp_idx.append(jdx)\n", + " noise_list.append(noise_dims)\n", + "\n", + " print(noise_dims, true_mi, geo_ksg_mi, ksg_mi)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "37c7459e-8bd4-4ecd-8864-e5e0a3709cbd", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "true_mis = []\n", + "ksg_mis = []\n", + "uf_ksg_mis = []\n", + "exp_idx = []\n", + "noise_list = []\n", + "\n", + "# we are just comparing I(X; Y)\n", + "for idx in tqdm(range(len(noise_dims_grid))):\n", + " for jdx in range(n_repeats):\n", + " noise_dims = noise_dims_grid[idx].astype(int)\n", + " # simulate multivariate Gaussian\n", + " mvg_data = simulate_multivariate_gaussian(d=d, n_samples=n_samples, seed=seed)\n", + " data, mean, cov = mvg_data\n", + "\n", + " X = embed_high_dims(data[:, [0]], n_dims=noise_dims, random_state=seed)\n", + " Y = embed_high_dims(data[:, [1]], n_dims=noise_dims, random_state=seed)\n", + " Z = embed_high_dims(data[:, [2]], n_dims=noise_dims, random_state=seed)\n", + "\n", + " # true MI and CMI\n", + " x_cov_idx = 0\n", + " y_cov_idx = 1\n", + " z_cov_idx = 2\n", + " true_mi = mi_gaussian(cov, y_cov_idx, z_cov_idx)\n", + " true_cmi = cmi_gaussian(cov, y_cov_idx, z_cov_idx, x_cov_idx)\n", + "\n", + " # now estimate both MIs\n", + " # define the forest-based estimator to determine distances\n", + " clf = UnsupervisedObliqueRandomForest(\n", + " n_estimators=n_estimators,\n", + " feature_combinations=feature_combinations,\n", + " n_jobs=n_jobs,\n", + " random_state=seed,\n", + " )\n", + "\n", + " # meta-estimator for nearest-neighbor lookup\n", + " est = NearestNeighborsMetaEstimator(\n", + " estimator=clf,\n", + " n_neighbors=n_nbrs,\n", + " algorithm=\"auto\",\n", + " n_jobs=n_jobs,\n", + " force_fit=True,\n", + " verbose=False,\n", + " )\n", + " geo_ksg_cmi = mutual_info_ksg(\n", + " Y,\n", + " Z,\n", + " X,\n", + " nn_estimator=est,\n", + " norm=\"max\",\n", + " n_jobs=n_jobs,\n", + " k=k_ratio,\n", + " verbose=False,\n", + " )\n", + "\n", + " # regular KSG estimator using KD-Tree\n", + " ksg_cmi = mutual_info_ksg_nn(\n", + " Y, Z, X, norm=\"max\", n_jobs=n_jobs, k=k_ratio, verbose=False\n", + " )\n", + "\n", + " true_mis.append(true_cmi)\n", + " uf_ksg_mis.append(geo_ksg_cmi)\n", + " ksg_mis.append(ksg_cmi)\n", + " exp_idx.append(jdx)\n", + " noise_list.append(noise_dims)\n", + "\n", + " print(noise_dims, true_cmi, geo_ksg_cmi, ksg_cmi)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f9a70357-5a71-4dda-8784-62fcb011ff05", + "metadata": {}, + "outputs": [], + "source": [ + "geo_ksg_cmi = mutual_info_ksg(\n", + " Y, Z, X, nn_estimator=est, norm=\"max\", n_jobs=n_jobs, k=k_ratio, verbose=False\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51cc4a64-0f59-4cab-84d6-df1ac5449ecc", + "metadata": {}, + "outputs": [], + "source": [ + "result_df = pd.DataFrame(\n", + " np.vstack((true_mis, uf_ksg_mis, ksg_mis, noise_list, exp_idx)).T,\n", + " columns=[\"true\", \"uf\", \"ksg\", \"noise_dim\", \"exp_idx\"],\n", + ")\n", + "\n", + "print(result_df.head())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "263cea70-d755-431e-8052-b8bbb48d30d1", + "metadata": {}, + "outputs": [], + "source": [ + "# exp 1 is MI = uf min_samples_split=2, twomeans\n", + "# exp 2 is CMI = uf min_samples_split=2, twomeans\n", + "# exp 3 is MI = uf min_samples_split=np.sqrt(2*n), twomeans\n", + "result_df.to_csv(\"/Users/adam2392/Downloads/cmi_exp3.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "bcb9e192-bd3e-4342-b365-41dc770cd931", + "metadata": {}, + "outputs": [], + "source": [ + "result_df = pd.read_csv(\"/Users/adam2392/Downloads/cmi_exp3.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "39d9c074-790b-4390-818d-b43535238084", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.melt(\n", + " result_df,\n", + " id_vars=\"noise_dim\",\n", + " var_name=\"estimator\",\n", + " value_vars=[\"true\", \"uf\", \"ksg\"],\n", + " value_name=\"estimate\",\n", + ")\n", + "\n", + "display(df.head())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "148cb19c-b6f7-4d4d-910f-dd5b8c5944d1", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_context(\"talk\", font_scale=1.0)\n", + "fig, ax = plt.subplots(figsize=(7, 5))\n", + "sns.lineplot(data=df, x=\"noise_dim\", y=\"estimate\", hue=\"estimator\", ax=ax)\n", + "ax.set(\n", + " title=\"MI of I(Y; Z)\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "607e5a3e-f467-4f24-81e6-45dafa1115a0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Text(0.5, 1.0, 'CMI of I(Y; Z | X)')]" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set_context(\"talk\", font_scale=1.0)\n", + "fig, ax = plt.subplots(figsize=(7, 5))\n", + "sns.lineplot(data=df, x=\"noise_dim\", y=\"estimate\", hue=\"estimator\", ax=ax)\n", + "ax.set(\n", + " title=\"CMI of I(Y; Z | X)\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "02d99c21-6874-48e8-8a51-ed923646f63a", + "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/experiments/plotting_cmi_supervised.ipynb b/experiments/plotting_cmi_supervised.ipynb new file mode 100644 index 000000000..f2f4690c6 --- /dev/null +++ b/experiments/plotting_cmi_supervised.ipynb @@ -0,0 +1,618 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "355a421f-926e-4ce6-ba03-b03893f47fed", + "metadata": {}, + "source": [ + "# Analysis of (Conditional) Mutual Information with Supervised Forests\n", + "\n", + "Compared to unsupervised forests, supervised forests are useful for computing direct estimates of entropy based on their abilities to predict probabilities. Moreover, supervised forests lend themselves well to computing (C)MI between discrete and continuous variables (i.e. when Y is categorical but X is continuous for (X, Y) input data).\n", + "\n", + "- MI: I(X;Y) = H(Y) - H(Y|X)\n", + "- CMI: I(X;Y | Z) = H(Y|Z) - H(Y | X, Z)\n", + "\n", + "Specifically, we will extend the separated Gaussian simulations of the uncertainty forest paper.\n", + "\n", + "$\n", + "\\begin{align}\n", + " I(X; Y | Z) = H(X | Z) - H(X | Y, Z) \\quad \\text{(Entropy identity)}\\\\\n", + " = (H(X, Z) - H(Z)) - (H(X, Z | Y) - H(Z | Y)) \\quad \\text{(By chain rule)} \\\\\n", + " = H(X, Z) - H(Z) - H(X, Z | Y) + H(Z | Y) \\quad \\text{(Simplify)}\n", + "\\end{align}\n", + "$\n", + "\n", + "Now each quantity is directly computable from $(X \\cup Z) \\sim$ multivariate Gaussian with Y being categorical.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "daa90182-c238-42dc-882b-0f1849461125", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The lab_black extension is already loaded. To reload it, use:\n", + " %reload_ext lab_black\n" + ] + } + ], + "source": [ + "%load_ext lab_black\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "c482e3c5-b7f6-4b7a-a81e-e76a1c718206", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import scipy\n", + "import scipy.spatial\n", + "import seaborn as sns\n", + "from sklearn.neighbors import NearestNeighbors\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "from sklearn.utils.validation import check_is_fitted\n", + "from tqdm import tqdm\n", + "\n", + "import sktree\n", + "from sktree import (\n", + " HonestForestClassifier,\n", + " NearestNeighborsMetaEstimator,\n", + " ObliqueRandomForestClassifier,\n", + " ObliqueRandomForestRegressor,\n", + " UnsupervisedObliqueRandomForest,\n", + " UnsupervisedRandomForest,\n", + ")\n", + "from sktree.experimental import SupervisedInfoForest, mutual_info_ksg\n", + "from sktree.experimental.ksg import _compute_radius_nbrs, mutual_info_ksg_nn\n", + "from sktree.experimental.mutual_info import (\n", + " cmi_from_entropy,\n", + " cmi_gaussian,\n", + " entropy_gaussian,\n", + " entropy_weibull,\n", + " mi_from_entropy,\n", + " mi_gamma,\n", + " mi_gaussian,\n", + ")\n", + "from sktree.experimental.simulate import (\n", + " cmi_separated_gaussians,\n", + " embed_high_dims,\n", + " mi_separated_gaussians,\n", + " simulate_helix,\n", + " simulate_multivariate_gaussian,\n", + " simulate_separate_gaussians,\n", + " simulate_sphere,\n", + ")\n", + "from sktree.neighbors import forest_distance\n", + "from sktree.tree import ObliqueDecisionTreeClassifier, compute_forest_similarity_matrix" + ] + }, + { + "cell_type": "markdown", + "id": "9ed18c2d-7c0f-44a2-a240-fa7aa7fd9df5", + "metadata": {}, + "source": [ + "## Define Hyperparameters of the Simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "037d0d4d-5c0d-4f0d-8318-bcf7af194cdf", + "metadata": {}, + "outputs": [], + "source": [ + "seed = 12345\n", + "rng = np.random.default_rng(seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "efddcb34-6007-4312-b7f4-e17a48f3614d", + "metadata": {}, + "outputs": [], + "source": [ + "n_jobs = -1\n", + "n_estimators = 100\n", + "feature_combinations = 2.0\n", + "n_nbrs = 5\n", + "\n", + "# hyperparameters of the simulation\n", + "n_samples = 1000\n", + "n_noise_dims = 20\n", + "alpha = 0.001\n", + "n_classes = 2\n", + "\n", + "# dimensionality of mvg\n", + "n_dims = 3\n", + "\n", + "# for sphere\n", + "radius = 1.0\n", + "\n", + "# for helix\n", + "radius_a = 0.0\n", + "radius_b = 2.0\n", + "\n", + "# manifold parameters\n", + "radii_func = lambda: rng.uniform(0, 1)" + ] + }, + { + "cell_type": "markdown", + "id": "e20f862e-4a93-4fba-8066-0606fe71b667", + "metadata": {}, + "source": [ + "## Setup a single simulation\n", + "\n", + "Now, to demonstrate what the data would look like fromm a single parameterized simulation, we want to show the entire workflow from data generation to analysis and output value." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "602422ed-7735-4396-8c28-f32a9fdf62a3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1000, 3) (1000,)\n" + ] + } + ], + "source": [ + "# simulate separated Gaussians\n", + "# simulate multivariate Gaussian\n", + "X, y, means, sigmas, pi = simulate_separate_gaussians(\n", + " n_dims=n_dims, n_samples=n_samples, n_classes=n_classes, seed=seed\n", + ")\n", + "\n", + "print(X.shape, y.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3de9593a-de44-4512-bfe8-f3c489eefd96", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2 2\n", + "(3,) [0.5 0.5]\n" + ] + } + ], + "source": [ + "print(len(means), len(sigmas))\n", + "print(means[0].shape, pi)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6d4b5d32-fce7-4198-95d1-ceb01400456b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[array([[1., 0., 0.],\n", + " [0., 1., 0.],\n", + " [0., 0., 1.]]), array([[1., 0., 0.],\n", + " [0., 1., 0.],\n", + " [0., 0., 1.]])]\n" + ] + } + ], + "source": [ + "print(sigmas)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "84c17ab8-6e7d-478c-8e9c-757bf1a2c527", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# compute ground-truth MI/CMI\n", + "# I(X;Y)\n", + "# I(X;Y |Z)\n", + "\n", + "# true MI and CMI\n", + "true_mi = mi_separated_gaussians(means, sigmas, pi, seed=seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ee0fa67d-aac1-4e20-b153-0fb51d8b16b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.351104834412363 2.8469010556693393 4.2568155996140185 2.8378770664093453\n" + ] + } + ], + "source": [ + "true_cmi = cmi_separated_gaussians(means, sigmas, pi, condition_idx=[1, 2], seed=seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "dee49368-27f5-4f33-a9ce-525483e2abba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(2, 2), (2, 2)]\n" + ] + } + ], + "source": [ + "condition_idx = [1, 2]\n", + "z_sigmas = [sigma[np.ix_(condition_idx, condition_idx)] for sigma in sigmas]\n", + "print([sigma.shape for sigma in z_sigmas])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "fb21dfe6-4cec-4aa2-ba1b-4e1d760a1f93", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.09428923479834417\n", + "0.08526524553835024\n" + ] + } + ], + "source": [ + "print(true_mi)\n", + "print(true_cmi)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "bf304453-a772-4148-a41a-f3e9de322b0a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1000, 3) (1000,) (1000, 21) (1000, 21)\n" + ] + } + ], + "source": [ + "_X = embed_high_dims(X[:, [1]], n_dims=n_noise_dims, random_state=seed)\n", + "_Z = embed_high_dims(X[:, [2]], n_dims=n_noise_dims, random_state=seed)\n", + "highdim_X = np.hstack((_X, _Z))\n", + "\n", + "print(X.shape, y.shape, _X.shape, _Z.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "b9a79406-10cb-4a72-a016-109a2a752eac", + "metadata": {}, + "source": [ + "# Setup SupervisedInfoForest\n", + "\n", + "The info forest object is just a meta-estimator that I wrote to expose the sklearn API for computing MI/CMI. It proceeds by fitting multiple forests." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c6e3014d-ace3-41c2-9f30-cf2015737e4a", + "metadata": {}, + "outputs": [], + "source": [ + "tree_estimator = ObliqueDecisionTreeClassifier(\n", + " feature_combinations=feature_combinations,\n", + " random_state=seed,\n", + ")\n", + "tree_estimator = DecisionTreeClassifier(\n", + " # feature_combinations=feature_combinations,\n", + " random_state=seed,\n", + ")\n", + "\n", + "estimator = HonestForestClassifier(\n", + " n_estimators=n_estimators,\n", + " n_jobs=n_jobs,\n", + " random_state=seed,\n", + " tree_estimator=tree_estimator,\n", + ")\n", + "est = SupervisedInfoForest(\n", + " estimator=estimator, y_categorical=True, n_jobs=n_jobs, random_state=seed\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "ebee771a-c4cc-4fda-9e36-1987c1bdee25", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
SupervisedInfoForest(estimator=HonestForestClassifier(n_jobs=-1,\n",
+       "                                                      random_state=12345,\n",
+       "                                                      tree_estimator=DecisionTreeClassifier(random_state=12345)),\n",
+       "                     n_jobs=-1, random_state=12345, y_categorical=True)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "SupervisedInfoForest(estimator=HonestForestClassifier(n_jobs=-1,\n", + " random_state=12345,\n", + " tree_estimator=DecisionTreeClassifier(random_state=12345)),\n", + " n_jobs=-1, random_state=12345, y_categorical=True)" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est.fit(_X, y, _Z)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "4ca327d7-b1f6-49a1-ad2e-3d7346904c6e", + "metadata": {}, + "outputs": [], + "source": [ + "check_is_fitted(est)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "b0781b14-051e-4476-9bd4-44c6af841f8e", + "metadata": {}, + "outputs": [ + { + "ename": "NotFittedError", + "evalue": "This HonestTreeClassifier instance is not fitted yet. Call 'fit' with appropriate arguments before using this estimator.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNotFittedError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[38], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mestimator_yxz_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m)\u001b[49m)\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/ensemble/_honest_forest.py:512\u001b[0m, in \u001b[0;36mHonestForestClassifier.apply\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m 495\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mapply\u001b[39m(\u001b[38;5;28mself\u001b[39m, X):\n\u001b[1;32m 496\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 497\u001b[0m \u001b[38;5;124;03m Apply trees in the forest to X, return leaf indices.\u001b[39;00m\n\u001b[1;32m 498\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 510\u001b[0m \u001b[38;5;124;03m return the index of the leaf x ends up in.\u001b[39;00m\n\u001b[1;32m 511\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 512\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[43mestimator_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/_lib/./sklearn/tree/_classes.py:792\u001b[0m, in \u001b[0;36mBaseDecisionTree.apply\u001b[0;34m(self, X, check_input)\u001b[0m\n\u001b[1;32m 768\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mapply\u001b[39m(\u001b[38;5;28mself\u001b[39m, X, check_input\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[1;32m 769\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Return the index of the leaf that each sample is predicted as.\u001b[39;00m\n\u001b[1;32m 770\u001b[0m \n\u001b[1;32m 771\u001b[0m \u001b[38;5;124;03m .. versionadded:: 0.17\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 790\u001b[0m \u001b[38;5;124;03m numbering.\u001b[39;00m\n\u001b[1;32m 791\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 792\u001b[0m \u001b[43mcheck_is_fitted\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 793\u001b[0m X \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_validate_X_predict(X, check_input)\n\u001b[1;32m 794\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtree_\u001b[38;5;241m.\u001b[39mapply(X)\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/utils/validation.py:1462\u001b[0m, in \u001b[0;36mcheck_is_fitted\u001b[0;34m(estimator, attributes, msg, all_or_any)\u001b[0m\n\u001b[1;32m 1459\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m is not an estimator instance.\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m (estimator))\n\u001b[1;32m 1461\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m _is_fitted(estimator, attributes, all_or_any):\n\u001b[0;32m-> 1462\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m NotFittedError(msg \u001b[38;5;241m%\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;28mtype\u001b[39m(estimator)\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m})\n", + "\u001b[0;31mNotFittedError\u001b[0m: This HonestTreeClassifier instance is not fitted yet. Call 'fit' with appropriate arguments before using this estimator." + ] + } + ], + "source": [ + "print(est.estimator_yxz_.apply(X))" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "fd03e849-854e-423c-93d7-214eb52558b3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HonestForestClassifier(n_jobs=-1, random_state=12345,\n", + " tree_estimator=DecisionTreeClassifier(random_state=424562602))\n", + "None\n", + "None\n", + "None\n" + ] + } + ], + "source": [ + "print(est.estimator_yxz_)\n", + "print(check_is_fitted(est))\n", + "print(check_is_fitted(est.estimator_yxz_))\n", + "print(check_is_fitted(est.estimator_yz_))" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "ba9a8f70-555b-4f9e-9d79-0ad8f64f9ecc", + "metadata": {}, + "outputs": [ + { + "ename": "NotFittedError", + "evalue": "This HonestTreeClassifier instance is not fitted yet. Call 'fit' with appropriate arguments before using this estimator.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNotFittedError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[27], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mestimator_yxz_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/ensemble/_honest_forest.py:512\u001b[0m, in \u001b[0;36mHonestForestClassifier.apply\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m 495\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mapply\u001b[39m(\u001b[38;5;28mself\u001b[39m, X):\n\u001b[1;32m 496\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 497\u001b[0m \u001b[38;5;124;03m Apply trees in the forest to X, return leaf indices.\u001b[39;00m\n\u001b[1;32m 498\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 510\u001b[0m \u001b[38;5;124;03m return the index of the leaf x ends up in.\u001b[39;00m\n\u001b[1;32m 511\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 512\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[43mestimator_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/_lib/./sklearn/tree/_classes.py:792\u001b[0m, in \u001b[0;36mBaseDecisionTree.apply\u001b[0;34m(self, X, check_input)\u001b[0m\n\u001b[1;32m 768\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mapply\u001b[39m(\u001b[38;5;28mself\u001b[39m, X, check_input\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[1;32m 769\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Return the index of the leaf that each sample is predicted as.\u001b[39;00m\n\u001b[1;32m 770\u001b[0m \n\u001b[1;32m 771\u001b[0m \u001b[38;5;124;03m .. versionadded:: 0.17\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 790\u001b[0m \u001b[38;5;124;03m numbering.\u001b[39;00m\n\u001b[1;32m 791\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 792\u001b[0m \u001b[43mcheck_is_fitted\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 793\u001b[0m X \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_validate_X_predict(X, check_input)\n\u001b[1;32m 794\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtree_\u001b[38;5;241m.\u001b[39mapply(X)\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/utils/validation.py:1462\u001b[0m, in \u001b[0;36mcheck_is_fitted\u001b[0;34m(estimator, attributes, msg, all_or_any)\u001b[0m\n\u001b[1;32m 1459\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m is not an estimator instance.\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m (estimator))\n\u001b[1;32m 1461\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m _is_fitted(estimator, attributes, all_or_any):\n\u001b[0;32m-> 1462\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m NotFittedError(msg \u001b[38;5;241m%\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;28mtype\u001b[39m(estimator)\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m})\n", + "\u001b[0;31mNotFittedError\u001b[0m: This HonestTreeClassifier instance is not fitted yet. Call 'fit' with appropriate arguments before using this estimator." + ] + } + ], + "source": [ + "est.estimator_yxz_.apply(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "e5e5d360-6007-4997-83dc-ff4bb425ab8e", + "metadata": {}, + "outputs": [ + { + "ename": "NotFittedError", + "evalue": "This HonestTreeClassifier instance is not fitted yet. Call 'fit' with appropriate arguments before using this estimator.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNotFittedError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[20], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m pred_cmi \u001b[38;5;241m=\u001b[39m \u001b[43mest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpredict_cmi\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_X\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_Z\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/experimental/forest.py:89\u001b[0m, in \u001b[0;36mSupervisedInfoForest.predict_cmi\u001b[0;34m(self, X, y, Z)\u001b[0m\n\u001b[1;32m 86\u001b[0m sample_indices \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;241m0\u001b[39m, X\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m])\n\u001b[1;32m 88\u001b[0m \u001b[38;5;66;03m# compute the entropy of H(Y | X, Z)\u001b[39;00m\n\u001b[0;32m---> 89\u001b[0m H_yxz \u001b[38;5;241m=\u001b[39m \u001b[43mcond_entropy\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 90\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mestimator_yxz_\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mXZ\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msample_indices\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkappa\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mseed\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrandom_state\u001b[49m\n\u001b[1;32m 91\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 93\u001b[0m \u001b[38;5;66;03m# compute the entropy of H(Y | Z)\u001b[39;00m\n\u001b[1;32m 94\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m Z \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/experimental/forest.py:160\u001b[0m, in \u001b[0;36mcond_entropy\u001b[0;34m(est, X, y, estimators_samples_, kappa, seed)\u001b[0m\n\u001b[1;32m 155\u001b[0m check_is_forest(est)\n\u001b[1;32m 156\u001b[0m \u001b[38;5;66;03m# if \"multioutput\" in est._get_tags():\u001b[39;00m\n\u001b[1;32m 157\u001b[0m \u001b[38;5;66;03m# raise ValueError(\"Multioutput is not supported.\")\u001b[39;00m\n\u001b[1;32m 158\u001b[0m \n\u001b[1;32m 159\u001b[0m \u001b[38;5;66;03m# get leaves of each tree for each sample (n_samples, n_estimators)\u001b[39;00m\n\u001b[0;32m--> 160\u001b[0m X_leaves \u001b[38;5;241m=\u001b[39m \u001b[43mest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 161\u001b[0m n_classes \u001b[38;5;241m=\u001b[39m est\u001b[38;5;241m.\u001b[39mn_classes_\n\u001b[1;32m 162\u001b[0m n_samples \u001b[38;5;241m=\u001b[39m X\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m]\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/ensemble/_honest_forest.py:512\u001b[0m, in \u001b[0;36mHonestForestClassifier.apply\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m 495\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mapply\u001b[39m(\u001b[38;5;28mself\u001b[39m, X):\n\u001b[1;32m 496\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 497\u001b[0m \u001b[38;5;124;03m Apply trees in the forest to X, return leaf indices.\u001b[39;00m\n\u001b[1;32m 498\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 510\u001b[0m \u001b[38;5;124;03m return the index of the leaf x ends up in.\u001b[39;00m\n\u001b[1;32m 511\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 512\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[43mestimator_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/_lib/./sklearn/tree/_classes.py:792\u001b[0m, in \u001b[0;36mBaseDecisionTree.apply\u001b[0;34m(self, X, check_input)\u001b[0m\n\u001b[1;32m 768\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mapply\u001b[39m(\u001b[38;5;28mself\u001b[39m, X, check_input\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[1;32m 769\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Return the index of the leaf that each sample is predicted as.\u001b[39;00m\n\u001b[1;32m 770\u001b[0m \n\u001b[1;32m 771\u001b[0m \u001b[38;5;124;03m .. versionadded:: 0.17\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 790\u001b[0m \u001b[38;5;124;03m numbering.\u001b[39;00m\n\u001b[1;32m 791\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 792\u001b[0m \u001b[43mcheck_is_fitted\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 793\u001b[0m X \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_validate_X_predict(X, check_input)\n\u001b[1;32m 794\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtree_\u001b[38;5;241m.\u001b[39mapply(X)\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/utils/validation.py:1462\u001b[0m, in \u001b[0;36mcheck_is_fitted\u001b[0;34m(estimator, attributes, msg, all_or_any)\u001b[0m\n\u001b[1;32m 1459\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m is not an estimator instance.\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m (estimator))\n\u001b[1;32m 1461\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m _is_fitted(estimator, attributes, all_or_any):\n\u001b[0;32m-> 1462\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m NotFittedError(msg \u001b[38;5;241m%\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;28mtype\u001b[39m(estimator)\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m})\n", + "\u001b[0;31mNotFittedError\u001b[0m: This HonestTreeClassifier instance is not fitted yet. Call 'fit' with appropriate arguments before using this estimator." + ] + } + ], + "source": [ + "pred_cmi = est.predict_cmi(_X, y, _Z)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "726a83f2-5084-4958-9d01-71e2c3e86ebb", + "metadata": {}, + "outputs": [], + "source": [ + "pred_mi = est.predict_cmi(_X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "18b82f0f-5842-4f2d-8239-1a0e4067c282", + "metadata": {}, + "outputs": [], + "source": [ + "print(pred_cmi, pred_mi)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "c299a578-1984-4030-a34d-eb3219edd4be", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.009832259764467277 -0.19976608189849127\n" + ] + } + ], + "source": [ + "print(pred_cmi, pred_mi)" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "7ab5065a-f606-4281-9631-15b1c460e048", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.006589316434129411 -0.19854781628986418\n" + ] + } + ], + "source": [ + "print(pred_cmi, pred_mi)" + ] + }, + { + "cell_type": "markdown", + "id": "63a9f1b5-fee5-416b-823b-c3781fa7a2d4", + "metadata": {}, + "source": [ + "# Analysis of dimensionality " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "842ccb8a-c25a-4d2d-93e4-ea70687a3bba", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5e50fca6-a6ac-42ee-9b27-78e3b0552350", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d03d7125-9378-4058-957c-f79f59c38fc4", + "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 +} From 370fc98638777333c4f326ce4796dd7156dc8fdc Mon Sep 17 00:00:00 2001 From: Adam Li Date: Fri, 18 Aug 2023 16:27:10 -0400 Subject: [PATCH 05/13] WIP Signed-off-by: Adam Li --- doc/references.bib | 18 + .../plotting_cmi_analysis_unsupervised.ipynb | 164 +++-- sktree/experimental/ksg.py | 18 +- sktree/neighbors.py | 7 +- sktree/tests/test_unsupervised_forest.py | 6 +- sktree/tree/_classes.py | 18 +- sktree/tree/tests/meson.build | 1 + sktree/tree/tests/test_criterion.py | 125 ++++ sktree/tree/tests/test_unsupervised_tree.py | 35 +- sktree/tree/unsupervised/_unsup_criterion.pxd | 25 +- sktree/tree/unsupervised/_unsup_criterion.pyx | 671 ++++++++++++++++-- .../unsupervised/_unsup_oblique_splitter.pyx | 4 +- .../tree/unsupervised/_unsup_oblique_tree.pyx | 1 - sktree/tree/unsupervised/_unsup_splitter.pyx | 22 +- 14 files changed, 988 insertions(+), 127 deletions(-) create mode 100644 sktree/tree/tests/test_criterion.py diff --git a/doc/references.bib b/doc/references.bib index 3e21f09a4..decacba98 100644 --- a/doc/references.bib +++ b/doc/references.bib @@ -11,6 +11,15 @@ @article{breiman2001random publisher = {Springer} } +@inproceedings{marx2022estimating, + title = {Estimating Mutual Information via Geodesic k NN}, + author = {Marx, Alexander and Fischer, Jonas}, + booktitle = {Proceedings of the 2022 SIAM International Conference on Data Mining (SDM)}, + pages = {415--423}, + year = {2022}, + organization = {SIAM} +} + @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}, @@ -84,3 +93,12 @@ @article{Kraskov_2004 pages = {066138}, file = {APS Snapshot:/Users/adam2392/Zotero/storage/GRW23BYU/PhysRevE.69.html:text/html;Full Text PDF:/Users/adam2392/Zotero/storage/NJT9QCVA/Kraskov et al. - 2004 - Estimating mutual information.pdf:application/pdf} } + +@inproceedings{terzi2006efficient, + title = {Efficient algorithms for sequence segmentation}, + author = {Terzi, Evimaria and Tsaparas, Panayiotis}, + booktitle = {Proceedings of the 2006 SIAM International Conference on Data Mining}, + pages = {316--327}, + year = {2006}, + organization = {SIAM} +} \ No newline at end of file diff --git a/experiments/plotting_cmi_analysis_unsupervised.ipynb b/experiments/plotting_cmi_analysis_unsupervised.ipynb index af651d18c..fa1c35648 100644 --- a/experiments/plotting_cmi_analysis_unsupervised.ipynb +++ b/experiments/plotting_cmi_analysis_unsupervised.ipynb @@ -147,7 +147,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 39, "id": "4fcde0a4-7413-4f09-bbd8-fe62fcd62c2d", "metadata": {}, "outputs": [], @@ -158,7 +158,7 @@ "n_nbrs = 5\n", "\n", "# hyperparameters of the simulation\n", - "n_samples = 1000\n", + "n_samples = 5000\n", "n_noise_dims = 20\n", "alpha = 0.001\n", "\n", @@ -188,7 +188,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 40, "id": "3cc73c4e-78b6-48b3-83b3-091d365d8ada", "metadata": {}, "outputs": [], @@ -217,13 +217,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 41, "id": "aa1a67bb-55fa-4983-b2d1-a23102945b7c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -256,13 +256,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 42, "id": "a841ffc8-e821-4c0a-8df0-9b55b1be3aba", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -285,7 +285,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 43, "id": "383a17a7-6c4f-49fc-aa4d-322f820ac18e", "metadata": {}, "outputs": [ @@ -307,13 +307,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 44, "id": "570cf521-f62f-4e62-98e4-0aea8e4f72db", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -340,7 +340,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 45, "id": "438211c0-228c-453d-aaec-02813988177f", "metadata": {}, "outputs": [ @@ -348,7 +348,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "(1000, 3)\n" + "(5000, 3)\n" ] } ], @@ -361,7 +361,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 46, "id": "ff5c92e5-65e6-4990-9287-708e4af32450", "metadata": {}, "outputs": [ @@ -369,7 +369,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "(1000, 21) (1000, 3)\n" + "(5000, 21) (5000, 3)\n" ] } ], @@ -392,7 +392,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 47, "id": "cc2209c6-3562-44e2-95d9-8343e24b5e28", "metadata": {}, "outputs": [ @@ -400,7 +400,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "(1000, 21) (1000, 21) (1000, 42)\n" + "(5000, 21) (5000, 21) (5000, 42)\n" ] } ], @@ -408,6 +408,7 @@ "# define the forest-based estimator to determine distances\n", "clf = UnsupervisedObliqueRandomForest(\n", " n_estimators=n_estimators,\n", + " criterion='fasterbic',\n", " feature_combinations=feature_combinations,\n", " min_samples_split=int(np.sqrt(2 * n_samples)),\n", " n_jobs=n_jobs,\n", @@ -428,6 +429,41 @@ "print(X.shape, Y.shape, data.shape)" ] }, + { + "cell_type": "code", + "execution_count": 48, + "id": "ff401a6b-bd8b-479c-a36c-e198e1dd450e", + "metadata": {}, + "outputs": [ + { + "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[48], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mclf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/ensemble/_unsupervised_forest.py:156\u001b[0m, in \u001b[0;36mForestCluster.fit\u001b[0;34m(self, X, y, sample_weight)\u001b[0m\n\u001b[1;32m 145\u001b[0m trees \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m 146\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_make_estimator(append\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, random_state\u001b[38;5;241m=\u001b[39mrandom_state)\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(n_more_estimators)\n\u001b[1;32m 148\u001b[0m ]\n\u001b[1;32m 150\u001b[0m \u001b[38;5;66;03m# Parallel loop: we prefer the threading backend as the Cython code\u001b[39;00m\n\u001b[1;32m 151\u001b[0m \u001b[38;5;66;03m# for fitting the trees is internally releasing the Python GIL\u001b[39;00m\n\u001b[1;32m 152\u001b[0m \u001b[38;5;66;03m# making threading more efficient than multiprocessing in\u001b[39;00m\n\u001b[1;32m 153\u001b[0m \u001b[38;5;66;03m# that case. However, for joblib 0.12+ we respect any\u001b[39;00m\n\u001b[1;32m 154\u001b[0m \u001b[38;5;66;03m# parallel_backend contexts set at a higher level,\u001b[39;00m\n\u001b[1;32m 155\u001b[0m \u001b[38;5;66;03m# since correctness does not rely on using threads.\u001b[39;00m\n\u001b[0;32m--> 156\u001b[0m trees \u001b[38;5;241m=\u001b[39m \u001b[43mParallel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprefer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mthreads\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 157\u001b[0m \u001b[43m \u001b[49m\u001b[43mdelayed\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_parallel_build_trees\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 158\u001b[0m \u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 159\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbootstrap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 160\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 161\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 162\u001b[0m \u001b[43m \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 163\u001b[0m \u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 164\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtrees\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 165\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 166\u001b[0m \u001b[43m \u001b[49m\u001b[43mclass_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclass_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 167\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_samples_bootstrap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_samples_bootstrap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 168\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 169\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtrees\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 170\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 172\u001b[0m \u001b[38;5;66;03m# Collect newly grown trees\u001b[39;00m\n\u001b[1;32m 173\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimators_\u001b[38;5;241m.\u001b[39mextend(trees)\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/utils/parallel.py:65\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 60\u001b[0m config \u001b[38;5;241m=\u001b[39m get_config()\n\u001b[1;32m 61\u001b[0m iterable_with_config \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 62\u001b[0m (_with_config(delayed_func, config), args, kwargs)\n\u001b[1;32m 63\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m delayed_func, args, kwargs \u001b[38;5;129;01min\u001b[39;00m iterable\n\u001b[1;32m 64\u001b[0m )\n\u001b[0;32m---> 65\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \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[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43miterable_with_config\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/joblib/parallel.py:1952\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1946\u001b[0m \u001b[38;5;66;03m# The first item from the output is blank, but it makes the interpreter\u001b[39;00m\n\u001b[1;32m 1947\u001b[0m \u001b[38;5;66;03m# progress until it enters the Try/Except block of the generator and\u001b[39;00m\n\u001b[1;32m 1948\u001b[0m \u001b[38;5;66;03m# reach the first `yield` statement. This starts the aynchronous\u001b[39;00m\n\u001b[1;32m 1949\u001b[0m \u001b[38;5;66;03m# dispatch of the tasks to the workers.\u001b[39;00m\n\u001b[1;32m 1950\u001b[0m \u001b[38;5;28mnext\u001b[39m(output)\n\u001b[0;32m-> 1952\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m output \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturn_generator \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43moutput\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/joblib/parallel.py:1595\u001b[0m, in \u001b[0;36mParallel._get_outputs\u001b[0;34m(self, iterator, pre_dispatch)\u001b[0m\n\u001b[1;32m 1592\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m\n\u001b[1;32m 1594\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backend\u001b[38;5;241m.\u001b[39mretrieval_context():\n\u001b[0;32m-> 1595\u001b[0m \u001b[38;5;28;01myield from\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_retrieve()\n\u001b[1;32m 1597\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mGeneratorExit\u001b[39;00m:\n\u001b[1;32m 1598\u001b[0m \u001b[38;5;66;03m# The generator has been garbage collected before being fully\u001b[39;00m\n\u001b[1;32m 1599\u001b[0m \u001b[38;5;66;03m# consumed. This aborts the remaining tasks if possible and warn\u001b[39;00m\n\u001b[1;32m 1600\u001b[0m \u001b[38;5;66;03m# the user if necessary.\u001b[39;00m\n\u001b[1;32m 1601\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_exception \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/joblib/parallel.py:1707\u001b[0m, in \u001b[0;36mParallel._retrieve\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1702\u001b[0m \u001b[38;5;66;03m# If the next job is not ready for retrieval yet, we just wait for\u001b[39;00m\n\u001b[1;32m 1703\u001b[0m \u001b[38;5;66;03m# async callbacks to progress.\u001b[39;00m\n\u001b[1;32m 1704\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ((\u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jobs) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m\n\u001b[1;32m 1705\u001b[0m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jobs[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mget_status(\n\u001b[1;32m 1706\u001b[0m timeout\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtimeout) \u001b[38;5;241m==\u001b[39m TASK_PENDING)):\n\u001b[0;32m-> 1707\u001b[0m \u001b[43mtime\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msleep\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0.01\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1708\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[1;32m 1710\u001b[0m \u001b[38;5;66;03m# We need to be careful: the job list can be filling up as\u001b[39;00m\n\u001b[1;32m 1711\u001b[0m \u001b[38;5;66;03m# we empty it and Python list are not thread-safe by\u001b[39;00m\n\u001b[1;32m 1712\u001b[0m \u001b[38;5;66;03m# default hence the use of the lock\u001b[39;00m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "clf.fit(data)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7f17e6c-ed4a-4581-a76a-58a5a0972a73", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": 19, @@ -491,7 +527,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 36, "id": "c051b1e1-4262-49c0-8383-74565b192a6b", "metadata": { "tags": [] @@ -501,55 +537,43 @@ "name": "stdout", "output_type": "stream", "text": [ - "Finished fitting estimator: UnsupervisedObliqueRandomForest(feature_combinations=2.0, min_samples_split=44,\n", - " n_jobs=-1, random_state=12345)\n", - "Finished computing distance matrix: (1000, 1000)\n", - "Finished fitting estimator: UnsupervisedObliqueRandomForest(feature_combinations=2.0, min_samples_split=44,\n", - " n_jobs=-1, random_state=12345)\n", - "Finished computing distance matrix: (1000, 1000)\n", - "Finished computing distance matrix: (1000, 1000)\n", - "Computing radius neighbors for 1000 samples\n", - "Computing radius neighbors in parallel...\n", - "Finished fitting estimator: UnsupervisedObliqueRandomForest(feature_combinations=2.0, min_samples_split=44,\n", - " n_jobs=-1, random_state=12345)\n", - "Finished computing distance matrix: (1000, 1000)\n", - "Finished computing distance matrix: (1000, 1000)\n", - "Computing radius neighbors for 1000 samples\n", - "Computing radius neighbors in parallel...\n", - "0.4266301582681855\n" + "Data shape: (10000, 22)\n", + "X shape: (10000, 11), Y shape: (10000, 11)\n", + "Preprocessing complete.\n", + "Using 2000 neighbors to define D-dimensional volume.\n", + "(10000, 22) [ 0 1 2 3 4 5 6 7 8 9 10] [11 12 13 14 15 16 17 18 19 20 21] []\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "KeyboardInterrupt\n", + "\n" ] } ], "source": [ - "geo_ksg_mi = mutual_info_ksg(\n", - " X, Y, nn_estimator=est, n_jobs=n_jobs, k=0.2, verbose=False\n", - ")\n", + "geo_ksg_mi = mutual_info_ksg(X, Y, nn_estimator=est, n_jobs=n_jobs, k=0.2, verbose=True)\n", "print(geo_ksg_mi)" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "id": "162653a5-d2f9-4e17-91fa-04be2c8515d7", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.4266301582681855\n" - ] - } - ], + "outputs": [], "source": [ "print(geo_ksg_mi)" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 33, "id": "5a56b255-4f29-4ce7-a0ee-616063c10ad5", "metadata": {}, "outputs": [ @@ -557,7 +581,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "1.478563245379208\n" + "1.3430269602006017\n" ] } ], @@ -568,9 +592,10 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 32, "id": "21a59855-6d48-490e-b746-231871281d9e", "metadata": { + "scrolled": true, "tags": [] }, "outputs": [ @@ -578,7 +603,30 @@ "name": "stdout", "output_type": "stream", "text": [ - "1.0795154036298156\n" + "Data shape: (10000, 22)\n", + "X shape: (10000, 11), Y shape: (10000, 11)\n", + "Preprocessing complete.\n", + "Using 2000 neighbors to define D-dimensional volume.\n", + "(10000, 22) [ 0 1 2 3 4 5 6 7 8 9 10] [11 12 13 14 15 16 17 18 19 20 21] []\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[32], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m nn_estimator \u001b[38;5;241m=\u001b[39m NearestNeighbors(\n\u001b[1;32m 2\u001b[0m n_neighbors\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m, algorithm\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mkd_tree\u001b[39m\u001b[38;5;124m\"\u001b[39m, p\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39minf, n_jobs\u001b[38;5;241m=\u001b[39mn_jobs\n\u001b[1;32m 3\u001b[0m )\n\u001b[0;32m----> 4\u001b[0m ksg_mi \u001b[38;5;241m=\u001b[39m \u001b[43mmutual_info_ksg\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 5\u001b[0m \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[43mnn_estimator\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnn_estimator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\n\u001b[1;32m 6\u001b[0m \u001b[43m)\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28mprint\u001b[39m(ksg_mi)\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/experimental/ksg.py:259\u001b[0m, in \u001b[0;36mmutual_info_ksg\u001b[0;34m(X, Y, Z, k, norm, nn_estimator, n_jobs, transform, random_seed, verbose)\u001b[0m\n\u001b[1;32m 257\u001b[0m val \u001b[38;5;241m=\u001b[39m _cmi_ksg(data, x_idx, y_idx, z_idx, nn_estimator, knn_here)\n\u001b[1;32m 258\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 259\u001b[0m val \u001b[38;5;241m=\u001b[39m \u001b[43m_mi_ksg\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnn_estimator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mknn_here\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 261\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m norm \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmax\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 262\u001b[0m norm_constant \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mlog(\u001b[38;5;241m1\u001b[39m)\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/experimental/ksg.py:396\u001b[0m, in \u001b[0;36m_mi_ksg\u001b[0;34m(data, x_idx, y_idx, nn_estimator, knn_here)\u001b[0m\n\u001b[1;32m 393\u001b[0m radius_per_sample \u001b[38;5;241m=\u001b[39m dists[:, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n\u001b[1;32m 395\u001b[0m \u001b[38;5;66;03m# compute on the subspace of X\u001b[39;00m\n\u001b[0;32m--> 396\u001b[0m num_nn_x \u001b[38;5;241m=\u001b[39m \u001b[43m_compute_radius_nbrs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mradius_per_sample\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnn_estimator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcol_idx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mx_idx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 398\u001b[0m \u001b[38;5;66;03m# compute on the subspace of Y\u001b[39;00m\n\u001b[1;32m 399\u001b[0m num_nn_y \u001b[38;5;241m=\u001b[39m _compute_radius_nbrs(data, radius_per_sample, nn_estimator, col_idx\u001b[38;5;241m=\u001b[39my_idx)\n", + "File \u001b[0;32m~/Documents/scikit-tree/sktree/experimental/ksg.py:497\u001b[0m, in \u001b[0;36m_compute_radius_nbrs\u001b[0;34m(data, radius_per_sample, nn_estimator, col_idx)\u001b[0m\n\u001b[1;32m 495\u001b[0m nn \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 496\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx, radius \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(radius_per_sample):\n\u001b[0;32m--> 497\u001b[0m nn_ \u001b[38;5;241m=\u001b[39m \u001b[43mnn_estimator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mradius_neighbors\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 498\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43matleast_2d\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcol_idx\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mradius\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mradius\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreturn_distance\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\n\u001b[1;32m 499\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 500\u001b[0m nn\u001b[38;5;241m.\u001b[39mappend(nn_[idx])\n\u001b[1;32m 502\u001b[0m num_nn_data \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray([\u001b[38;5;28mlen\u001b[39m(nn_) \u001b[38;5;28;01mfor\u001b[39;00m nn_ \u001b[38;5;129;01min\u001b[39;00m nn])\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/neighbors/_base.py:1235\u001b[0m, in \u001b[0;36mRadiusNeighborsMixin.radius_neighbors\u001b[0;34m(self, X, radius, return_distance, sort_results)\u001b[0m\n\u001b[1;32m 1233\u001b[0m n_jobs \u001b[38;5;241m=\u001b[39m effective_n_jobs(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_jobs)\n\u001b[1;32m 1234\u001b[0m delayed_query \u001b[38;5;241m=\u001b[39m delayed(_tree_query_radius_parallel_helper)\n\u001b[0;32m-> 1235\u001b[0m chunked_results \u001b[38;5;241m=\u001b[39m \u001b[43mParallel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprefer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mthreads\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1236\u001b[0m \u001b[43m \u001b[49m\u001b[43mdelayed_query\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1237\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_tree\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m[\u001b[49m\u001b[43ms\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mradius\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreturn_distance\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msort_results\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msort_results\u001b[49m\n\u001b[1;32m 1238\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1239\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43ms\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mgen_even_slices\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1240\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1241\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m return_distance:\n\u001b[1;32m 1242\u001b[0m neigh_ind, neigh_dist \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtuple\u001b[39m(\u001b[38;5;28mzip\u001b[39m(\u001b[38;5;241m*\u001b[39mchunked_results))\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/utils/parallel.py:65\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 60\u001b[0m config \u001b[38;5;241m=\u001b[39m get_config()\n\u001b[1;32m 61\u001b[0m iterable_with_config \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 62\u001b[0m (_with_config(delayed_func, config), args, kwargs)\n\u001b[1;32m 63\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m delayed_func, args, kwargs \u001b[38;5;129;01min\u001b[39;00m iterable\n\u001b[1;32m 64\u001b[0m )\n\u001b[0;32m---> 65\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \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[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43miterable_with_config\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/joblib/parallel.py:1952\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1946\u001b[0m \u001b[38;5;66;03m# The first item from the output is blank, but it makes the interpreter\u001b[39;00m\n\u001b[1;32m 1947\u001b[0m \u001b[38;5;66;03m# progress until it enters the Try/Except block of the generator and\u001b[39;00m\n\u001b[1;32m 1948\u001b[0m \u001b[38;5;66;03m# reach the first `yield` statement. This starts the aynchronous\u001b[39;00m\n\u001b[1;32m 1949\u001b[0m \u001b[38;5;66;03m# dispatch of the tasks to the workers.\u001b[39;00m\n\u001b[1;32m 1950\u001b[0m \u001b[38;5;28mnext\u001b[39m(output)\n\u001b[0;32m-> 1952\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m output \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturn_generator \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43moutput\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/joblib/parallel.py:1595\u001b[0m, in \u001b[0;36mParallel._get_outputs\u001b[0;34m(self, iterator, pre_dispatch)\u001b[0m\n\u001b[1;32m 1592\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m\n\u001b[1;32m 1594\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backend\u001b[38;5;241m.\u001b[39mretrieval_context():\n\u001b[0;32m-> 1595\u001b[0m \u001b[38;5;28;01myield from\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_retrieve()\n\u001b[1;32m 1597\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mGeneratorExit\u001b[39;00m:\n\u001b[1;32m 1598\u001b[0m \u001b[38;5;66;03m# The generator has been garbage collected before being fully\u001b[39;00m\n\u001b[1;32m 1599\u001b[0m \u001b[38;5;66;03m# consumed. This aborts the remaining tasks if possible and warn\u001b[39;00m\n\u001b[1;32m 1600\u001b[0m \u001b[38;5;66;03m# the user if necessary.\u001b[39;00m\n\u001b[1;32m 1601\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_exception \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/envs/sktree/lib/python3.9/site-packages/joblib/parallel.py:1707\u001b[0m, in \u001b[0;36mParallel._retrieve\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1702\u001b[0m \u001b[38;5;66;03m# If the next job is not ready for retrieval yet, we just wait for\u001b[39;00m\n\u001b[1;32m 1703\u001b[0m \u001b[38;5;66;03m# async callbacks to progress.\u001b[39;00m\n\u001b[1;32m 1704\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ((\u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jobs) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m\n\u001b[1;32m 1705\u001b[0m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jobs[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mget_status(\n\u001b[1;32m 1706\u001b[0m timeout\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtimeout) \u001b[38;5;241m==\u001b[39m TASK_PENDING)):\n\u001b[0;32m-> 1707\u001b[0m \u001b[43mtime\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msleep\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0.01\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1708\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[1;32m 1710\u001b[0m \u001b[38;5;66;03m# We need to be careful: the job list can be filling up as\u001b[39;00m\n\u001b[1;32m 1711\u001b[0m \u001b[38;5;66;03m# we empty it and Python list are not thread-safe by\u001b[39;00m\n\u001b[1;32m 1712\u001b[0m \u001b[38;5;66;03m# default hence the use of the lock\u001b[39;00m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], @@ -587,7 +635,7 @@ " n_neighbors=5, algorithm=\"kd_tree\", p=np.inf, n_jobs=n_jobs\n", ")\n", "ksg_mi = mutual_info_ksg(\n", - " X, Y, nn_estimator=nn_estimator, n_jobs=n_jobs, k=0.3, verbose=False\n", + " X, Y, nn_estimator=nn_estimator, n_jobs=n_jobs, k=0.2, verbose=True\n", ")\n", "print(ksg_mi)" ] @@ -602,12 +650,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "1.0795154036298156\n" + "(10000, 22)\n" ] } ], "source": [ - "print(ksg_mi)" + "print(data.shape)" ] }, { @@ -620,23 +668,23 @@ "outputs": [ { "ename": "NameError", - "evalue": "name 'col_idx' is not defined", + "evalue": "name 'nn_estimator' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[27], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m nn_estimator\u001b[38;5;241m.\u001b[39mfit(data[:, \u001b[43mcol_idx\u001b[49m])\n\u001b[1;32m 3\u001b[0m nn \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx, radius \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(radius_per_sample):\n", - "\u001b[0;31mNameError\u001b[0m: name 'col_idx' is not defined" + "Cell \u001b[0;32mIn[27], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mnn_estimator\u001b[49m\u001b[38;5;241m.\u001b[39mfit(data)\n\u001b[1;32m 3\u001b[0m nn \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx, radius \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(radius_per_sample):\n", + "\u001b[0;31mNameError\u001b[0m: name 'nn_estimator' is not defined" ] } ], "source": [ - "nn_estimator.fit(data[:, col_idx])\n", + "nn_estimator.fit(data)\n", "\n", "nn = []\n", "for idx, radius in enumerate(radius_per_sample):\n", " nn_ = nn_estimator.radius_neighbors(\n", - " X=np.atleast_2d(data[:, col_idx]), radius=radius, return_distance=False\n", + " X=np.atleast_2d(data), radius=radius, return_distance=False\n", " )\n", " nn.append(nn_[idx])\n", "print(np.array([len(nn_) for nn_ in nn]))" diff --git a/sktree/experimental/ksg.py b/sktree/experimental/ksg.py index 435320672..8d363d761 100644 --- a/sktree/experimental/ksg.py +++ b/sktree/experimental/ksg.py @@ -251,6 +251,7 @@ def mutual_info_ksg( if verbose: print(f"Using {knn_here} neighbors to define D-dimensional volume.") + print(data.shape, x_idx, y_idx, z_idx) if Z is not None: val = _cmi_ksg(data, x_idx, y_idx, z_idx, nn_estimator, knn_here) @@ -270,12 +271,17 @@ def mutual_info_ksg( def _preprocess_data(data, transform, rng): + if transform not in ("rank", "standardize", "uniform", None): + raise ValueError(f"Unknown transform {transform}. Must " + f"be one of 'rank', 'standardize', 'uniform', or None.") + n_samples, n_features = data.shape # add minor noise to make sure there are no ties random_noise = rng.random((n_samples, n_features)) data += 1e-5 * random_noise @ np.std(data, axis=0).reshape(n_features, 1) + # optionally transform the data if transform == "standardize": # standardize with standard scaling data = data.astype(np.float64) @@ -359,7 +365,7 @@ def _mi_ksg_scipy(data, x_idx, y_idx, knn_here: int, n_jobs: int = -1) -> float: return val -def _mi_ksg(data, x_idx, y_idx, nn_estimator: BaseEstimator, knn_here: int) -> float: +def _mi_ksg(data, x_idx, y_idx, nn_estimator: BaseEstimator, knn_here: int, verbose: bool=False) -> float: """Compute KSG estimate of MI. Parameters @@ -383,18 +389,28 @@ def _mi_ksg(data, x_idx, y_idx, nn_estimator: BaseEstimator, knn_here: int) -> f """ n_samples = data.shape[0] + if verbose: + print(f'Fitting nearest neighbors estimator with {data.shape} data.') + # estimate distance to the kth NN in XYZ subspace for each sample neigh = nn_estimator.fit(data) dists, _ = neigh.kneighbors(n_neighbors=knn_here) + if verbose: + print(f'Computing radii for {knn_here} nn and got dists {dists.shape}.') + # - get the radius we want to use per sample as the distance to the kth neighbor # in the joint distribution space radius_per_sample = dists[:, -1] # compute on the subspace of X + if verbose: + print(f'Computing radius neighbors for X with {x_idx.shape} indices.') num_nn_x = _compute_radius_nbrs(data, radius_per_sample, nn_estimator, col_idx=x_idx) # compute on the subspace of Y + if verbose: + print(f'Computing radius neighbors for Y with {y_idx.shape} indices.') num_nn_y = _compute_radius_nbrs(data, radius_per_sample, nn_estimator, col_idx=y_idx) # compute the final MI value diff --git a/sktree/neighbors.py b/sktree/neighbors.py index 424a56977..1591c06a3 100644 --- a/sktree/neighbors.py +++ b/sktree/neighbors.py @@ -30,7 +30,12 @@ class NearestNeighborsMetaEstimator(BaseEstimator, MetaEstimatorMixin): """Meta-estimator for nearest neighbors. Uses a decision-tree, or forest model to compute distances between samples - and then uses the sklearn's nearest-neighbors API to compute neighbors. + and then uses the sklearn's nearest-neighbors API to compute neighbors. Thus, + this meta-estimator is a two-stage process: + + 1. Fit a forest on X (n_samples, n_features) to compute a distance matrix (n_samples, n_samples). + 2. Fit an instance of `sklearn.neighbors.NearestNeighbors` on the distance matrix to compute + nearest neighbors. Parameters ---------- diff --git a/sktree/tests/test_unsupervised_forest.py b/sktree/tests/test_unsupervised_forest.py index 7bd1e0116..737f8ceaf 100644 --- a/sktree/tests/test_unsupervised_forest.py +++ b/sktree/tests/test_unsupervised_forest.py @@ -8,7 +8,7 @@ from sktree.ensemble import UnsupervisedObliqueRandomForest, UnsupervisedRandomForest -CLUSTER_CRITERIONS = ("twomeans", "fastbic") +CLUSTER_CRITERIONS = ("twomeans", "fastbic", "fasterbic") FOREST_CLUSTERS = { "UnsupervisedRandomForest": UnsupervisedRandomForest, @@ -53,7 +53,7 @@ def test_check_simulation(name, forest, criterion): n_features = 5 if criterion == "twomeans": expected_score = 0.05 - elif criterion == "fastbic": + elif criterion in ("fastbic", "fasterbic"): expected_score = 0.35 else: n_features = 20 @@ -96,7 +96,7 @@ def test_check_iris(name, forest, criterion): expected_score = 0.21 else: expected_score = 0.2 - elif criterion == "fastbic": + elif criterion in ("fastbic", "fasterbic"): if "oblique" in name.lower(): expected_score = 0.55 else: diff --git a/sktree/tree/_classes.py b/sktree/tree/_classes.py index 9bcbefb24..28a782726 100644 --- a/sktree/tree/_classes.py +++ b/sktree/tree/_classes.py @@ -57,7 +57,11 @@ "best": _morf_splitter.BestPatchSplitter, } -UNSUPERVISED_CRITERIA = {"twomeans": _unsup_criterion.TwoMeans, "fastbic": _unsup_criterion.FastBIC} +UNSUPERVISED_CRITERIA = { + "twomeans": _unsup_criterion.TwoMeans, + "fastbic": _unsup_criterion.FastBIC, + "fasterbic": _unsup_criterion.FasterBIC +} UNSUPERVISED_SPLITTERS = { "best": _unsup_splitter.BestUnsupervisedSplitter, } @@ -70,7 +74,7 @@ class UnsupervisedDecisionTree(SimMatrixMixin, TransformerMixin, ClusterMixin, B Parameters ---------- - criterion : {"twomeans", "fastbic"}, default="twomeans" + criterion : {"twomeans", "fastbic", "fasterbic"}, default="twomeans" The function to measure the quality of a split. Supported criteria are "twomeans" for the variance impurity and "fastbic" for the BIC criterion. If ``UnsupervisedCriterion`` instance is passed in, then @@ -163,6 +167,16 @@ class UnsupervisedDecisionTree(SimMatrixMixin, TransformerMixin, ClusterMixin, B clustering_func_args : dict Clustering function class keyword arguments. Passed to `clustering_func`. + + Notes + ----- + The "faster" BIC criterion is computed by enabling computation of the split point evaluations + in O(n log(n)) time. This implements the algorithm described in :footcite:`marx2022estimating` and + :footcite:`terzi2006efficient`. + + References + ---------- + .. footbibliography:: """ def __init__( diff --git a/sktree/tree/tests/meson.build b/sktree/tree/tests/meson.build index e3d54ab85..5ce6459ce 100644 --- a/sktree/tree/tests/meson.build +++ b/sktree/tree/tests/meson.build @@ -6,6 +6,7 @@ python_sources = [ 'test_marginal.py', 'test_all_trees.py', 'test_unsupervised_tree.py', + 'test_criterion.py' ] py3.install_sources( diff --git a/sktree/tree/tests/test_criterion.py b/sktree/tree/tests/test_criterion.py new file mode 100644 index 000000000..20172e120 --- /dev/null +++ b/sktree/tree/tests/test_criterion.py @@ -0,0 +1,125 @@ +import pytest +import numpy as np +from sktree.tree.unsupervised._unsup_criterion import CriterionTester + + +def test_node_impurity_equality(): + # Create instances of FastBIC and FasterBIC with test data + n_outputs = 1 + n_classes = np.array([2]) + + X = np.array([0, 1, 2, 3, 5, 10, 20, 200]).reshape(-1).astype(np.float32) + n_samples = X.shape[0] + + # Create a new array which will be used to store nonzero + # samples from the feature of interest + samples = np.arange(n_samples, dtype=np.intp) + sample_weight = np.ones(n_samples, dtype=np.float64) + weighted_n_samples = np.sum(sample_weight) + + crit_tester = CriterionTester() + crit_tester.init(sample_weight, weighted_n_samples, samples, X) + crit_tester.reset() + for pos in range(1, n_samples): + print("Doing pos: ", pos) + crit_tester.update(pos) + fast_bic_imp, faster_bic_imp = crit_tester.node_impurity() + print(fast_bic_imp, faster_bic_imp) + assert fast_bic_imp == faster_bic_imp + + (fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right) = crit_tester.children_impurity() + print((fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right)) + assert fast_bic_left == faster_bic_left + assert fast_bic_right == faster_bic_right + + fast_bic_imp, faster_bic_imp = crit_tester.proxy_impurity() + print(fast_bic_imp, faster_bic_imp) + assert fast_bic_imp == faster_bic_imp + + (fast_bic_weights, faster_bic_weights) = crit_tester.weighted_n_samples() + assert all(weight == other_weight for weight, other_weight in zip(fast_bic_weights, faster_bic_weights)) + print(crit_tester.weighted_n_samples()) + + fast_sum_right, faster_sum_right = crit_tester.sum_right() + assert fast_sum_right == faster_sum_right + + crit_tester.reset() + crit_tester.update(1) + + crit_tester.set_sample_pointers(3, 6) + crit_tester.init_feature_vec() + crit_tester.update(5) + n_samples = 3 + + X[0] = 100 + print("Doing pos: ", 5) + fast_bic_imp, faster_bic_imp = crit_tester.node_impurity() + print(fast_bic_imp, faster_bic_imp) + assert fast_bic_imp == faster_bic_imp + + (fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right) = crit_tester.children_impurity() + print((fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right)) + assert fast_bic_left == faster_bic_left + assert fast_bic_right == faster_bic_right + + print(crit_tester.weighted_n_samples()) + (fast_bic_weights,faster_bic_weights) = crit_tester.weighted_n_samples() + assert all(weight == other_weight for weight, other_weight in zip(fast_bic_weights, faster_bic_weights)) + + fast_bic_imp, faster_bic_imp = crit_tester.proxy_impurity() + print(fast_bic_imp, faster_bic_imp) + assert fast_bic_imp == faster_bic_imp + + crit_tester.init_feature_vec() + for pos in range(4, 6): + print("Doing pos: ", pos) + crit_tester.update(pos) + fast_bic_imp, faster_bic_imp = crit_tester.node_impurity() + print(fast_bic_imp, faster_bic_imp) + assert fast_bic_imp == faster_bic_imp + + (fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right) = crit_tester.children_impurity() + print((fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right)) + assert fast_bic_left == faster_bic_left + assert fast_bic_right == faster_bic_right + + print(crit_tester.weighted_n_samples()) + (fast_bic_weights,faster_bic_weights) = crit_tester.weighted_n_samples() + assert all(weight == other_weight for weight, other_weight in zip(fast_bic_weights, faster_bic_weights)) + + fast_bic_imp, faster_bic_imp = crit_tester.proxy_impurity() + print(fast_bic_imp, faster_bic_imp) + assert fast_bic_imp == faster_bic_imp + + fast_sum_right, faster_sum_right = crit_tester.sum_right() + assert fast_sum_right == faster_sum_right + # assert False + # fast_bic = FastBIC(n_outputs, n_classes) + # faster_bic = FasterBIC(n_outputs, n_classes) + + # fast_bic.init( + # sample_weight, + # weighted_n_samples, + # samples, + # feature_values, + # ) + # # Call the cpdef node_impurity function for both instances + # impurity_fast = fast_bic.node_impurity() + # impurity_faster = faster_bic.node_impurity() + + # # Compare the results using pytest's built-in assert statement + # assert pytest.approx(impurity_fast, rel=1e-5) == impurity_faster + + +# def test_children_impurity_equality(): +# # Create instances of FastBIC and FasterBIC with test data +# fast_bic = FastBIC(...) +# faster_bic = FasterBIC(...) + +# # Call the cpdef children_impurity function for both instances +# left_impurity_fast, right_impurity_fast = fast_bic.children_impurity() +# left_impurity_faster, right_impurity_faster = faster_bic.children_impurity() + +# # Compare the results using pytest's built-in assert statement +# assert pytest.approx(left_impurity_fast, rel=1e-5) == left_impurity_faster +# assert pytest.approx(right_impurity_fast, rel=1e-5) == right_impurity_faster diff --git a/sktree/tree/tests/test_unsupervised_tree.py b/sktree/tree/tests/test_unsupervised_tree.py index 42066c473..f2e23e196 100644 --- a/sktree/tree/tests/test_unsupervised_tree.py +++ b/sktree/tree/tests/test_unsupervised_tree.py @@ -1,5 +1,6 @@ import numpy as np import pytest +from numpy.testing import assert_array_equal from sklearn import datasets from sklearn.cluster import AgglomerativeClustering from sklearn.datasets import make_blobs @@ -8,7 +9,7 @@ from sktree.tree import UnsupervisedDecisionTree, UnsupervisedObliqueDecisionTree -CLUSTER_CRITERIONS = ("twomeans", "fastbic") +CLUSTER_CRITERIONS = ("twomeans", "fastbic", "fasterbic") REG_CRITERIONS = ("squared_error", "absolute_error", "friedman_mse", "poisson") TREE_CLUSTERS = { @@ -133,7 +134,7 @@ def test_check_simulation(name, Tree, criterion): expected_score = 0.02 else: expected_score = 0.3 - elif criterion == "fastbic": + elif criterion in ("fastbic", 'fasterbic'): if "oblique" in name.lower(): expected_score = 0.01 else: @@ -172,7 +173,7 @@ def test_check_rotated_blobs(name, Tree, criterion): expected_score = 0.02 else: expected_score = 0.3 - elif criterion == "fastbic": + elif criterion in ("fastbic", 'fasterbic'): if "oblique" in name.lower(): expected_score = 0.01 else: @@ -196,7 +197,8 @@ def test_check_rotated_blobs(name, Tree, criterion): def test_check_iris(name, Tree, criterion): # Check consistency on dataset iris. n_classes = len(np.unique(iris.target)) - est = Tree(criterion=criterion, random_state=12345) + + est = Tree(criterion=criterion, min_samples_split=np.sqrt(len(iris)).astype(int), random_state=12345) est.fit(iris.data, iris.target) sim_mat = est.compute_similarity_matrix(iris.data) @@ -206,7 +208,7 @@ def test_check_iris(name, Tree, criterion): expected_score = 0.2 else: expected_score = 0.01 - elif criterion == "fastbic": + elif criterion in ("fastbic", 'fasterbic'): if "oblique" in name.lower(): expected_score = 0.001 else: @@ -220,3 +222,26 @@ def test_check_iris(name, Tree, criterion): assert score > expected_score, "Iris failed with {0}, criterion = {1} and score = {2}".format( name, criterion, score ) + + +def test_fasterbic_vs_fastbic_on_iris(): + fastbic_tree = UnsupervisedDecisionTree(criterion="fastbic", random_state=1) + fasterbic_tree = UnsupervisedDecisionTree(criterion="fasterbic", random_state=0) + + n_classes = len(np.unique(iris.target)) + fastbic_tree.fit(iris.data, iris.target) + fasterbic_tree.fit(iris.data, iris.target) + + sim_mat = fastbic_tree.compute_similarity_matrix(iris.data) + cluster = AgglomerativeClustering(n_clusters=n_classes).fit(sim_mat) + predict_labels = cluster.fit_predict(sim_mat) + fastbic_score = adjusted_rand_score(iris.target, predict_labels) + + sim_mat = fasterbic_tree.compute_similarity_matrix(iris.data) + cluster = AgglomerativeClustering(n_clusters=n_classes).fit(sim_mat) + predict_labels = cluster.fit_predict(sim_mat) + fasterbic_score = adjusted_rand_score(iris.target, predict_labels) + + print(fastbic_score, fasterbic_score) + assert False + # assert_array_equal(fastbic_tree.compute_similarity_matrix(iris.data), fasterbic_tree.compute_similarity_matrix(iris.data)) diff --git a/sktree/tree/unsupervised/_unsup_criterion.pxd b/sktree/tree/unsupervised/_unsup_criterion.pxd index 8c6b4bb5d..a80cc2bf3 100644 --- a/sktree/tree/unsupervised/_unsup_criterion.pxd +++ b/sktree/tree/unsupervised/_unsup_criterion.pxd @@ -51,11 +51,11 @@ cdef class UnsupervisedCriterion(BaseCriterion): const DOUBLE_t[:] sample_weight, double weighted_n_samples, const SIZE_t[:] samples, + const DTYPE_t[:] Xf, ) except -1 nogil cdef void init_feature_vec( self, - const DTYPE_t[:] Xf, ) noexcept nogil cdef void set_sample_pointers( @@ -63,3 +63,26 @@ cdef class UnsupervisedCriterion(BaseCriterion): SIZE_t start, SIZE_t end ) noexcept nogil + + +cdef class CriterionTester: + cdef public object fast_bic + cdef public object faster_bic + + cpdef init(self, + const DOUBLE_t[:] sample_weight, + double weighted_n_samples, + const SIZE_t[:] samples, + const DTYPE_t[:] Xf) + cpdef init_feature_vec(self) + cpdef update(self, int pos) + cpdef reset(self) + cpdef node_impurity(self) + cpdef children_impurity(self) + cpdef proxy_impurity(self) + cpdef weighted_n_samples(self) + + cpdef sum_right(self) + cpdef sum_left(self) + cpdef sum_total(self) + cpdef set_sample_pointers(self, int start, int end) \ No newline at end of file diff --git a/sktree/tree/unsupervised/_unsup_criterion.pyx b/sktree/tree/unsupervised/_unsup_criterion.pyx index 5a0f36b8a..2fc415223 100644 --- a/sktree/tree/unsupervised/_unsup_criterion.pyx +++ b/sktree/tree/unsupervised/_unsup_criterion.pyx @@ -5,11 +5,147 @@ cimport numpy as cnp import numpy as np from libc.math cimport log +from libcpp.unordered_map cimport unordered_map cnp.import_array() cdef DTYPE_t PI = np.pi + +cdef class CriterionTester: + cpdef init(self, + const DOUBLE_t[:] sample_weight, + double weighted_n_samples, + const SIZE_t[:] samples, + const DTYPE_t[:] Xf + ): + n_classes = np.array([2]) + n_samples = Xf.shape[0] + + # Create instances of FastBIC and FasterBIC with test data + cdef int n_outputs = 1 + cdef int start = 0 + cdef int end = len(Xf) + + # Create a new array which will be used to store nonzero + # samples from the feature of interest + weighted_n_samples = np.sum(sample_weight) + feature_values_fast = np.empty(n_samples, dtype=np.float32) + feature_values_faster = np.empty(n_samples, dtype=np.float32) + + # initialize the two criterion + fast_bic = FastBIC(n_outputs, n_classes) + faster_bic = FasterBIC(n_outputs, n_classes) + fast_bic.init( + sample_weight, + weighted_n_samples, + samples, + feature_values_fast, + ) + faster_bic.init( + sample_weight, + weighted_n_samples, + samples, + feature_values_faster, + ) + fast_bic.set_sample_pointers( + start, + end + ) + faster_bic.set_sample_pointers( + start, + end + ) + fast_bic.init_feature_vec() + faster_bic.init_feature_vec() + + self.fast_bic = fast_bic + self.faster_bic = faster_bic + + cpdef init_feature_vec(self): + cdef FastBIC fast_bic = self.fast_bic + cdef FasterBIC faster_bic = self.faster_bic + fast_bic.init_feature_vec() + faster_bic.init_feature_vec() + + cpdef update(self, int pos): + cdef FastBIC fast_bic = self.fast_bic + cdef FasterBIC faster_bic = self.faster_bic + fast_bic.update(pos) + faster_bic.update(pos) + + cpdef node_impurity(self): + cdef FastBIC fast_bic = self.fast_bic + cdef FasterBIC faster_bic = self.faster_bic + + fast_bic_imp = fast_bic.node_impurity() + faster_bic_imp = faster_bic.node_impurity() + + return fast_bic_imp, faster_bic_imp + + cpdef children_impurity(self): + cdef FastBIC fast_bic = self.fast_bic + cdef FasterBIC faster_bic = self.faster_bic + + cdef double fast_bic_left + cdef double fast_bic_right + cdef double faster_bic_left + cdef double faster_bic_right + fast_bic.children_impurity(&fast_bic_left, &fast_bic_right) + faster_bic.children_impurity(&faster_bic_left, &faster_bic_right) + + return (fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right) + + cpdef sum_total(self): + cdef FastBIC fast_bic = self.fast_bic + cdef FasterBIC faster_bic = self.faster_bic + return fast_bic.sum_total, faster_bic.sum_total + + cpdef sum_left(self): + cdef FastBIC fast_bic = self.fast_bic + cdef FasterBIC faster_bic = self.faster_bic + return fast_bic.sum_left, faster_bic.sum_left + + cpdef sum_right(self): + cdef FastBIC fast_bic = self.fast_bic + cdef FasterBIC faster_bic = self.faster_bic + return fast_bic.sum_right, faster_bic.sum_right + + cpdef proxy_impurity(self): + cdef FastBIC fast_bic = self.fast_bic + cdef FasterBIC faster_bic = self.faster_bic + + fast_bic_imp = fast_bic.proxy_impurity_improvement() + faster_bic_imp = faster_bic.proxy_impurity_improvement() + + return fast_bic_imp, faster_bic_imp + + cpdef reset(self): + cdef FastBIC fast_bic = self.fast_bic + cdef FasterBIC faster_bic = self.faster_bic + fast_bic.reset() + faster_bic.reset() + + cpdef set_sample_pointers(self, int start, int end): + cdef FastBIC fast_bic = self.fast_bic + cdef FasterBIC faster_bic = self.faster_bic + fast_bic.set_sample_pointers(start, end) + faster_bic.set_sample_pointers(start, end) + + cpdef weighted_n_samples(self): + cdef FastBIC fast_bic = self.fast_bic + cdef FasterBIC faster_bic = self.faster_bic + + # for idx in range(len(np.array([0, 1, 2, 3, 5, 10, 20, 200]).reshape(-1, 1))): + # print('idx: ', idx) + # print(faster_bic.sample_indices[idx]) + # print(faster_bic.cumsum_weights_map[faster_bic.sample_indices[idx]]) + # print(faster_bic.cumsum_map[faster_bic.sample_indices[idx]]) + + + return ((fast_bic.weighted_n_node_samples, fast_bic.weighted_n_left, fast_bic.weighted_n_right), + (faster_bic.weighted_n_node_samples, faster_bic.weighted_n_left, faster_bic.weighted_n_right)) + cdef class UnsupervisedCriterion(BaseCriterion): """Abstract criterion for unsupervised learning. @@ -22,6 +158,7 @@ cdef class UnsupervisedCriterion(BaseCriterion): This object stores methods on how to calculate how good a split is using different metrics for unsupervised splitting. """ + def __cinit__(self): """Initialize attributes for unsupervised criterion. """ @@ -42,51 +179,12 @@ cdef class UnsupervisedCriterion(BaseCriterion): def __reduce__(self): return (type(self), (), self.__getstate__()) - cdef void init_feature_vec( - self, - const DTYPE_t[:] Xf, - ) noexcept nogil: - """Initialize the 1D feature vector, which is used for computing criteria. - - This function is used to set a read-only memoryview of a feature - vector. The feature vector must be set in order for criteria to be - computed. It then keeps a running total of the feature vector from - samples[start:end] so that way it is efficient to compute the right and - left sums and corresponding metrics. - - Parameters - ---------- - Xf : array-like, dtype=DTYPE_t - The read-only memoryview 1D feature vector with (n_samples,) shape. - """ - self.Xf = Xf - - # also compute the sum total - self.sum_total = 0.0 - self.weighted_n_node_samples = 0.0 - cdef SIZE_t s_idx - cdef SIZE_t p_idx - - cdef DOUBLE_t w = 1.0 - for p_idx in range(self.start, self.end): - s_idx = self.sample_indices[p_idx] - - # w is originally set to be 1.0, meaning that if no sample weights - # are given, the default weight of each sample is 1.0. - if self.sample_weight is not None: - w = self.sample_weight[s_idx] - - self.sum_total += self.Xf[s_idx] * w - self.weighted_n_node_samples += w - - # Reset to pos=start - self.reset() - cdef int init( self, const DOUBLE_t[:] sample_weight, double weighted_n_samples, const SIZE_t[:] sample_indices, + const DTYPE_t[:] Xf, ) except -1 nogil: """Initialize the unsuperivsed criterion. @@ -101,10 +199,13 @@ cdef class UnsupervisedCriterion(BaseCriterion): The total weight of all sample_indices. sample_indices : array-like, dtype=SIZE_t A mask on the sample_indices, showing which ones we want to use + Xf : array-like, dtype=DTYPE_t + The memoryview 1D feature vector with (n_samples,) shape. """ self.sample_weight = sample_weight self.weighted_n_samples = weighted_n_samples self.sample_indices = sample_indices + self.Xf = Xf return 0 @@ -136,6 +237,43 @@ cdef class UnsupervisedCriterion(BaseCriterion): self.sum_left = self.sum_total return 0 + cdef void init_feature_vec( + self, + ) noexcept nogil: + """Initialize the 1D feature vector, which is used for computing criteria. + + This function is used to set a read-only memoryview of a feature + vector. The feature vector must be set in order for criteria to be + computed. It then keeps a running total of the feature vector from + samples[start:end] so that way it is efficient to compute the right and + left sums and corresponding metrics. + + Parameters + ---------- + Xf : array-like, dtype=DTYPE_t + The read-only memoryview 1D feature vector with (n_samples,) shape. + """ + # also compute the sum total + self.sum_total = 0.0 + self.weighted_n_node_samples = 0.0 + cdef SIZE_t s_idx + cdef SIZE_t p_idx + + cdef DOUBLE_t w = 1.0 + for p_idx in range(self.start, self.end): + s_idx = self.sample_indices[p_idx] + + # w is originally set to be 1.0, meaning that if no sample weights + # are given, the default weight of each sample is 1.0. + if self.sample_weight is not None: + w = self.sample_weight[s_idx] + + self.sum_total += self.Xf[s_idx] * w + self.weighted_n_node_samples += w + + # Reset to pos=start + self.reset() + cdef int update( self, SIZE_t new_pos @@ -167,7 +305,7 @@ cdef class UnsupervisedCriterion(BaseCriterion): # sum_left[x] + sum_right[x] = sum_total[x] # and that sum_total is known, we are going to update # sum_left from the direction that require the least amount - # of computations, i.e. from pos to new_pos or from end to new_po. + # of computations, i.e. from pos to new_pos or from end to new_pos. if (new_pos - pos) <= (end - new_pos): for p in range(pos, new_pos): i = sample_indices[p] @@ -402,6 +540,7 @@ cdef class TwoMeans(UnsupervisedCriterion): ss += w * (self.Xf[s_idx] - mean) * (self.Xf[s_idx] - mean) return ss + cdef class FastBIC(TwoMeans): r"""Fast-BIC split criterion @@ -432,7 +571,6 @@ cdef class FastBIC(TwoMeans): Additionally, Fast-BIC is substantially faster than the traditional BIC method. Reference: https://arxiv.org/abs/1907.02844 - """ cdef double bic_cluster(self, SIZE_t n_samples, double variance) noexcept nogil: """Help compute the BIC from assigning to a specific cluster. @@ -578,3 +716,452 @@ cdef class FastBIC(TwoMeans): else: impurity_left[0] = -BIC_same_var_left impurity_right[0] = -BIC_same_var_right + + +cdef class FasterBIC(UnsupervisedCriterion): + r"""Faster-BIC split criterion + + This utilizes a trick from [2]_ to improve the computation for the variance. + Since we have an arbitrary segment $X_i, ..., X_j$ with $1 \le i \le j \le n_samples$, + we can compute the + + Reference: + [1] https://arxiv.org/pdf/2110.13883.pdf + [2] E. Terzi, Problems and algorithms for sequence segmen- tations. Helsingin yliopisto, 2006. + """ + cdef unordered_map[SIZE_t, DTYPE_t] cumsum_of_squares_map + cdef unordered_map[SIZE_t, DTYPE_t] cumsum_map + cdef unordered_map[SIZE_t, DTYPE_t] cumsum_weights_map + + cdef double bic_cluster(self, SIZE_t n_samples, double variance) noexcept nogil: + """Help compute the BIC from assigning to a specific cluster. + + Parameters + ---------- + n_samples : SIZE_t + The number of samples assigned cluster. + variance : double + The plug-in variance for assigning to specific cluster. + + Notes + ----- + Computes the following: + + :math:`-2 * (n_i log(w_i) - n_i/2 log(2 \\pi \\sigma_i^2)) + + where :math:`n_i` is the number of samples assigned to cluster i, + :math:`w_i` is the probability of choosing cluster i at random (or also known + as the prior) and :math:`\\sigma_i^2` is the variance estimate for cluster i. + + Note that :math:`\\sigma_i^2` in the Fast-BIC derivation may be the + variance of the cluster itself, or the estimated combined variance + from both clusters. + """ + cdef SIZE_t n_node_samples = self.n_node_samples + + # chances of choosing the cluster based on how many samples are hard-assigned to cluster + # i.e. the prior + # cast to double, so we do not round to integers + cdef double w_cluster = (n_samples + 0.0) / n_node_samples + + # add to prevent taking log of 0 when there is a degenerate cluster (i.e. single sample, or no variance) + return -2. * (n_samples * log(w_cluster) + 0.5 * n_samples * log(2. * PI * variance + 1.e-7)) + + cdef double node_impurity( + self + ) noexcept nogil: + """Evaluate the impurity of the current node. + + Evaluate the FastBIC criterion impurity as estimated maximum log likelihood. + This is the maximum likelihood given prior, mean, and variance at s number of samples + Namely, this is the maximum likelihood of Xf[sample_indices[start:end]]. + The smaller the impurity the better. + """ + cdef double variance + cdef double impurity + cdef SIZE_t n_node_samples = self.n_node_samples + + # then compute the variance of the cluster + # see Section 5.2 in reference. + variance = self.fast_total_variance(self.weighted_n_node_samples, self.end) + + # Compute the BIC of the current set of samples + # Note: we do not compute the BIC_diff_var and BIC_same_var because + # they are equivalent in the single cluster setting + impurity = self.bic_cluster(n_node_samples, variance) + return impurity + + cdef inline DTYPE_t fast_total_variance(self, double weighted_n_node_samples, SIZE_t j) noexcept nogil: + """Computes variance in O(1). + + Computes: + + \sigma_{i,j}^2 = \frac{1}{j-i+1} ((css_j - css_{i-1}) - \frac{1}{j-i+1} (cs_j - cs_{i-1})^2) + """ + cdef double normalizer = 1. / weighted_n_node_samples + cdef SIZE_t s_idx = self.sample_indices[j] + return normalizer * \ + ( + (self.cumsum_of_squares_map[s_idx]) - \ + (normalizer * (self.cumsum_map[s_idx]) * (self.cumsum_map[s_idx])) + ) + + cdef inline DTYPE_t fast_variance(self, double weighted_n_node_samples, SIZE_t j, SIZE_t i) noexcept nogil: + """Computes variance in O(1). + + Computes: + + \sigma_{i,j}^2 = \frac{1}{j-i+1} ((css_j - css_{i-1}) - \frac{1}{j-i+1} (cs_j - cs_{i-1})^2) + """ + cdef double normalizer = 1. / weighted_n_node_samples + cdef SIZE_t sj_idx = self.sample_indices[j] + cdef SIZE_t si_idx = self.sample_indices[i - 1] + + return normalizer * \ + ( + (self.cumsum_of_squares_map[sj_idx] - self.cumsum_of_squares_map[si_idx]) - \ + (normalizer * (self.cumsum_map[sj_idx] - self.cumsum_map[si_idx]) * (self.cumsum_map[sj_idx] - self.cumsum_map[si_idx])) + ) + + cdef void children_impurity( + self, + double* impurity_left, + double* impurity_right + ) noexcept nogil: + cdef SIZE_t pos = self.pos + cdef SIZE_t start = self.start + cdef SIZE_t end = self.end + cdef SIZE_t n_samples_left, n_samples_right + + cdef double variance_left, variance_right, variance_comb + cdef double BIC_diff_var_left, BIC_diff_var_right + cdef double BIC_same_var_left, BIC_same_var_right + cdef double BIC_same_var, BIC_diff_var + + # number of samples of left and right + n_samples_left = pos - start + n_samples_right = end - pos + + # compute the variance of the node, left, and right child + variance_left = self.fast_total_variance(self.weighted_n_left, pos) + variance_right = self.fast_variance(self.weighted_n_right, end, pos) + variance_comb = self.fast_total_variance(self.weighted_n_node_samples, end) + + # Compute the BIC using different variances for left and right + BIC_diff_var_left = self.bic_cluster(n_samples_left, variance_left) + BIC_diff_var_right = self.bic_cluster(n_samples_right, variance_right) + + # Compute the BIC using different variances for left and right + BIC_same_var_left = self.bic_cluster(n_samples_left, variance_comb) + BIC_same_var_right = self.bic_cluster(n_samples_right, variance_comb) + BIC_same_var = BIC_same_var_left - BIC_same_var_right + BIC_diff_var = BIC_diff_var_left - BIC_diff_var_right + + # choose the BIC formulation that gives us the smallest values + # (i.e. min of (BIC_diff, BIC_same) in the paper) and then + # assign the left and right child BIC values by reference + if BIC_diff_var < BIC_same_var: + impurity_left[0] = -BIC_diff_var_left + impurity_right[0] = -BIC_diff_var_right + else: + impurity_left[0] = -BIC_same_var_left + impurity_right[0] = -BIC_same_var_right + + + cdef void init_feature_vec( + self, + ) noexcept nogil: + """Compute sufficient statistics from the feature vector at this node. + + This function iterates over the set of samples at this node and computes + the cumulative sum and cumulative sum-of-suqares, which enables O(1) computation + of the variance. + + When calling `update` to compute the sum_left and sum_right. It will be fairly straightforward. + """ + # also compute the sum total + self.sum_total = 0.0 + self.weighted_n_node_samples = 0.0 + cdef SIZE_t s_idx + cdef SIZE_t p_idx + + cdef DOUBLE_t w = 1.0 + + cdef SIZE_t prev_s_idx + # = self.sample_indices[self.start] - 1 + # self.cumsum_of_squares_map[self.sample_indices[self.start] - 1] = 0.0 + # self.cumsum_map[self.sample_indices[self.start] - 1] = 0.0 + # self.cumsum_weights_map[self.sample_indices[self.start] - 1] = 0.0 + + cdef unordered_map[SIZE_t, DTYPE_t] cumsum_map + cdef unordered_map[SIZE_t, DTYPE_t] cumsum_of_squares_map + cdef unordered_map[SIZE_t, DTYPE_t] cumsum_weights_map + self.cumsum_map = cumsum_map + self.cumsum_of_squares_map = cumsum_of_squares_map + self.cumsum_weights_map = cumsum_weights_map + + for p_idx in range(self.start, self.end): + s_idx = self.sample_indices[p_idx] + + # w is originally set to be 1.0, meaning that if no sample weights + # are given, the default weight of each sample is 1.0. + if self.sample_weight is not None: + w = self.sample_weight[s_idx] + + self.sum_total += self.Xf[s_idx] * w + self.weighted_n_node_samples += w + + if p_idx != self.start: + self.cumsum_of_squares_map[s_idx] = self.cumsum_of_squares_map[prev_s_idx] + (self.Xf[s_idx] * self.Xf[s_idx] * w * w) + self.cumsum_map[s_idx] = self.cumsum_map[prev_s_idx] + (self.Xf[s_idx] * w) + self.cumsum_weights_map[s_idx] = self.cumsum_weights_map[prev_s_idx] + w + else: + self.cumsum_of_squares_map[s_idx] = 0.0 + self.cumsum_map[s_idx] = 0.0 + self.cumsum_weights_map[s_idx] = 0.0 + prev_s_idx = s_idx + + # Reset to pos=start + self.reset() + + cdef int update( + self, + SIZE_t new_pos + ) except -1 nogil: + """Updated statistics by moving sample_indices[pos:new_pos] to the left child. + + Update the split point. + + Parameters + ---------- + new_pos : SIZE_t + The new ending position for which to move sample_indices from the right + child to the left child. + """ + cdef SIZE_t pos = self.pos + + # infer left-child statistics + self.weighted_n_left = self.cumsum_weights_map[self.sample_indices[new_pos]] + self.sum_left = self.cumsum_map[self.sample_indices[new_pos]] + + # Update right part statistics as a result + self.weighted_n_right = (self.weighted_n_node_samples - + self.weighted_n_left) + self.sum_right = self.sum_total - self.sum_left + + self.pos = new_pos + return 0 + + +# cdef FasterBICv2(UnsupervisedCriterion): +# cdef double sumsq_total # The sum of the weighted count of each feature. +# cdef double sumsq_left # Same as above, but for the left side of the split +# cdef double sumsq_right # Same as above, but for the right side of the split + + +# cdef void init_feature_vec( +# self, +# ) noexcept nogil: +# """Initialize the 1D feature vector, which is used for computing criteria. + +# This function is used to set a read-only memoryview of a feature +# vector. The feature vector must be set in order for criteria to be +# computed. It then keeps a running total of the feature vector from +# samples[start:end] so that way it is efficient to compute the right and +# left sums and corresponding metrics. + +# Parameters +# ---------- +# Xf : array-like, dtype=DTYPE_t +# The read-only memoryview 1D feature vector with (n_samples,) shape. +# """ +# # also compute the sum total +# self.sum_total = 0.0 +# self.weighted_n_node_samples = 0.0 +# cdef SIZE_t s_idx +# cdef SIZE_t p_idx + +# cdef DOUBLE_t w = 1.0 +# for p_idx in range(self.start, self.end): +# s_idx = self.sample_indices[p_idx] + +# # w is originally set to be 1.0, meaning that if no sample weights +# # are given, the default weight of each sample is 1.0. +# if self.sample_weight is not None: +# w = self.sample_weight[s_idx] + +# self.sum_total += self.Xf[s_idx] * w +# self.weighted_n_node_samples += w + +# # Reset to pos=start +# self.reset() + +# cdef int update( +# self, +# SIZE_t new_pos +# ) except -1 nogil: +# """Updated statistics by moving sample_indices[pos:new_pos] to the left child. + +# Returns -1 in case of failure to allocate memory (and raise MemoryError) +# or 0 otherwise. + +# Parameters +# ---------- +# new_pos : SIZE_t +# The new ending position for which to move sample_indices from the right +# child to the left child. +# """ +# cdef SIZE_t pos = self.pos +# cdef SIZE_t end = self.end + +# cdef const SIZE_t[:] sample_indices = self.sample_indices +# cdef const DOUBLE_t[:] sample_weight = self.sample_weight + +# cdef SIZE_t i +# cdef SIZE_t p +# cdef DOUBLE_t w = 1.0 + +# # Update statistics up to new_pos +# # +# # Given that +# # sum_left[x] + sum_right[x] = sum_total[x] +# # and that sum_total is known, we are going to update +# # sum_left from the direction that require the least amount +# # of computations, i.e. from pos to new_pos or from end to new_pos. +# if (new_pos - pos) <= (end - new_pos): +# for p in range(pos, new_pos): +# i = sample_indices[p] + +# if sample_weight is not None: +# w = sample_weight[i] + +# # accumulate the values of the feature vectors weighted +# # by the sample weight +# self.sum_left += self.Xf[i] * w + +# # keep track of the weighted count of each sample +# self.weighted_n_left += w +# else: +# self.reverse_reset() + +# for p in range(end - 1, new_pos - 1, -1): +# i = sample_indices[p] + +# if sample_weight is not None: +# w = sample_weight[i] + +# self.sum_left -= self.Xf[i] * w + +# self.weighted_n_left -= w + +# # Update right part statistics +# self.weighted_n_right = (self.weighted_n_node_samples - +# self.weighted_n_left) +# self.sum_right = self.sum_total - self.sum_left + +# self.pos = new_pos +# return 0 + +# cdef double bic_cluster(self, SIZE_t n_samples, double variance) noexcept nogil: +# """Help compute the BIC from assigning to a specific cluster. + +# Parameters +# ---------- +# n_samples : SIZE_t +# The number of samples assigned cluster. +# variance : double +# The plug-in variance for assigning to specific cluster. + +# Notes +# ----- +# Computes the following: + +# :math:`-2 * (n_i log(w_i) - n_i/2 log(2 \\pi \\sigma_i^2)) + +# where :math:`n_i` is the number of samples assigned to cluster i, +# :math:`w_i` is the probability of choosing cluster i at random (or also known +# as the prior) and :math:`\\sigma_i^2` is the variance estimate for cluster i. + +# Note that :math:`\\sigma_i^2` in the Fast-BIC derivation may be the +# variance of the cluster itself, or the estimated combined variance +# from both clusters. +# """ +# cdef SIZE_t n_node_samples = self.n_node_samples + +# # chances of choosing the cluster based on how many samples are hard-assigned to cluster +# # i.e. the prior +# # cast to double, so we do not round to integers +# cdef double w_cluster = (n_samples + 0.0) / n_node_samples + +# # add to prevent taking log of 0 when there is a degenerate cluster (i.e. single sample, or no variance) +# return -2. * (n_samples * log(w_cluster) + 0.5 * n_samples * log(2. * PI * variance + 1.e-7)) + +# cdef double node_impurity( +# self +# ) noexcept nogil: +# """Evaluate the impurity of the current node. + +# Evaluate the FastBIC criterion impurity as estimated maximum log likelihood. +# This is the maximum likelihood given prior, mean, and variance at s number of samples +# Namely, this is the maximum likelihood of Xf[sample_indices[start:end]]. +# The smaller the impurity the better. +# """ +# cdef double mean +# cdef double variance +# cdef double impurity +# cdef SIZE_t n_node_samples = self.n_node_samples + +# # then compute the variance of the cluster +# # see Section 5.2 in reference. +# variance = self.fast_total_variance(self.weighted_n_node_samples, self.end) + +# # Compute the BIC of the current set of samples +# # Note: we do not compute the BIC_diff_var and BIC_same_var because +# # they are equivalent in the single cluster setting +# impurity = self.bic_cluster(n_node_samples, variance) +# return impurity + + +# cdef void children_impurity( +# self, +# double* impurity_left, +# double* impurity_right +# ) noexcept nogil: +# cdef SIZE_t pos = self.pos +# cdef SIZE_t start = self.start +# cdef SIZE_t end = self.end +# cdef SIZE_t n_samples_left, n_samples_right + +# cdef double variance_left, variance_right, variance_comb +# cdef double BIC_diff_var_left, BIC_diff_var_right +# cdef double BIC_same_var_left, BIC_same_var_right +# cdef double BIC_same_var, BIC_diff_var + +# # number of samples of left and right +# n_samples_left = pos - start +# n_samples_right = end - pos + +# # compute the variance of the node, left, and right child +# variance_left = self.fast_total_variance(self.weighted_n_left, pos) +# variance_right = self.fast_variance(self.weighted_n_right, end, pos) +# variance_comb = self.fast_total_variance(self.weighted_n_node_samples, end) + +# # Compute the BIC using different variances for left and right +# BIC_diff_var_left = self.bic_cluster(n_samples_left, variance_left) +# BIC_diff_var_right = self.bic_cluster(n_samples_right, variance_right) + +# # Compute the BIC using different variances for left and right +# BIC_same_var_left = self.bic_cluster(n_samples_left, variance_comb) +# BIC_same_var_right = self.bic_cluster(n_samples_right, variance_comb) +# BIC_same_var = BIC_same_var_left - BIC_same_var_right +# BIC_diff_var = BIC_diff_var_left - BIC_diff_var_right + +# # choose the BIC formulation that gives us the smallest values +# # (i.e. min of (BIC_diff, BIC_same) in the paper) and then +# # assign the left and right child BIC values by reference +# if BIC_diff_var < BIC_same_var: +# impurity_left[0] = -BIC_diff_var_left +# impurity_right[0] = -BIC_diff_var_right +# else: +# impurity_left[0] = -BIC_same_var_left +# impurity_right[0] = -BIC_same_var_right diff --git a/sktree/tree/unsupervised/_unsup_oblique_splitter.pyx b/sktree/tree/unsupervised/_unsup_oblique_splitter.pyx index 7a6f91060..898238ef4 100644 --- a/sktree/tree/unsupervised/_unsup_oblique_splitter.pyx +++ b/sktree/tree/unsupervised/_unsup_oblique_splitter.pyx @@ -280,8 +280,8 @@ cdef class BestObliqueUnsupervisedSplitter(UnsupervisedObliqueSplitter): # initialize feature vector for criterion to evaluate # GIL is needed since we are changing the criterion's internal memory - with gil: - self.criterion.init_feature_vec(feature_values) + # with gil: + self.criterion.init_feature_vec() # Evaluate all splits self.criterion.reset() diff --git a/sktree/tree/unsupervised/_unsup_oblique_tree.pyx b/sktree/tree/unsupervised/_unsup_oblique_tree.pyx index 0ea70a6b6..2c9c21900 100644 --- a/sktree/tree/unsupervised/_unsup_oblique_tree.pyx +++ b/sktree/tree/unsupervised/_unsup_oblique_tree.pyx @@ -216,7 +216,6 @@ cdef class UnsupervisedObliqueTree(UnsupervisedTree): # For reference, see: # https://www.codementor.io/@arpitbhayani/powering-inheritance-in-c-using-structure-composition-176sygr724 cdef ObliqueSplitRecord* oblique_split_node = (split_node) - node_id = self.node_count node.feature = deref(oblique_split_node).feature node.threshold = deref(oblique_split_node).threshold diff --git a/sktree/tree/unsupervised/_unsup_splitter.pyx b/sktree/tree/unsupervised/_unsup_splitter.pyx index 18ba8ab2f..a771e07dc 100644 --- a/sktree/tree/unsupervised/_unsup_splitter.pyx +++ b/sktree/tree/unsupervised/_unsup_splitter.pyx @@ -122,7 +122,8 @@ cdef class UnsupervisedSplitter(BaseSplitter): self.criterion.init( self.sample_weight, self.weighted_n_samples, - self.samples + self.samples, + self.feature_values, ) # set sample pointers in criterion @@ -199,7 +200,7 @@ cdef class BestUnsupervisedSplitter(UnsupervisedSplitter): cdef SIZE_t[::1] constant_features = self.constant_features cdef SIZE_t n_features = self.n_features - cdef DTYPE_t[::1] Xf = self.feature_values + cdef DTYPE_t[::1] feature_values = self.feature_values cdef SIZE_t max_features = self.max_features cdef SIZE_t min_samples_leaf = self.min_samples_leaf cdef UINT32_t* random_state = &self.rand_r_state @@ -278,12 +279,12 @@ cdef class BestUnsupervisedSplitter(UnsupervisedSplitter): # sorting the array in a manner which utilizes the cache more # effectively. for i in range(start, end): - Xf[i] = self.X[samples[i], current_split.feature] + feature_values[i] = self.X[samples[i], current_split.feature] - sort(&Xf[start], &samples[start], end - start) + sort(&feature_values[start], &samples[start], end - start) # check if we have found a "constant" feature - if Xf[end - 1] <= Xf[start] + FEATURE_THRESHOLD: + if feature_values[end - 1] <= feature_values[start] + FEATURE_THRESHOLD: features[f_j], features[n_total_constants] = \ features[n_total_constants], features[f_j] @@ -296,14 +297,13 @@ cdef class BestUnsupervisedSplitter(UnsupervisedSplitter): # initialize feature vector for criterion to evaluate # GIL is needed since we are changing the criterion's internal memory - with gil: - self.criterion.init_feature_vec(Xf) + self.criterion.init_feature_vec() # Evaluate all splits along the feature vector p = start while p < end: - while p + 1 < end and Xf[p + 1] <= Xf[p] + FEATURE_THRESHOLD: + while p + 1 < end and feature_values[p + 1] <= feature_values[p] + FEATURE_THRESHOLD: p += 1 # (p + 1 >= end) or (X[samples[p + 1], current_split.feature] > @@ -334,14 +334,14 @@ cdef class BestUnsupervisedSplitter(UnsupervisedSplitter): if current_proxy_improvement > best_proxy_improvement: best_proxy_improvement = current_proxy_improvement # sum of halves is used to avoid infinite value - current_split.threshold = Xf[p - 1] / 2.0 + Xf[p] / 2.0 + current_split.threshold = feature_values[p - 1] / 2.0 + feature_values[p] / 2.0 if ( - current_split.threshold == Xf[p] or + current_split.threshold == feature_values[p] or current_split.threshold == INFINITY or current_split.threshold == -INFINITY ): - current_split.threshold = Xf[p - 1] + current_split.threshold = feature_values[p - 1] best_split = current_split # copy From 407746c4dea4333993bdc3cfa45d9ce738aa7543 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 23 Aug 2023 17:08:20 -0400 Subject: [PATCH 06/13] Merge in changes for unsup Signed-off-by: Adam Li --- sktree/tree/_oblique_splitter.pyx | 147 ------------------ sktree/tree/unsupervised/_unsup_criterion.pxd | 1 - sktree/tree/unsupervised/_unsup_criterion.pyx | 25 +-- sktree/tree/unsupervised/_unsup_splitter.pxd | 2 - sktree/tree/unsupervised/_unsup_splitter.pyx | 1 - 5 files changed, 16 insertions(+), 160 deletions(-) diff --git a/sktree/tree/_oblique_splitter.pyx b/sktree/tree/_oblique_splitter.pyx index d9dace4d8..7b3ff7dab 100644 --- a/sktree/tree/_oblique_splitter.pyx +++ b/sktree/tree/_oblique_splitter.pyx @@ -458,150 +458,3 @@ cdef class BestObliqueSplitter(ObliqueSplitter): self.monotonic_cst.base if self.monotonic_cst is not None else None, self.feature_combinations, ), self.__getstate__()) - - cdef int node_split( - self, - double impurity, - SplitRecord* split, - SIZE_t* n_constant_features, - double lower_bound, - double upper_bound, - ) except -1 nogil: - """Find the best_split split on node samples[start:end] - - Returns -1 in case of failure to allocate memory (and raise MemoryError) - or 0 otherwise. - """ - # typecast the pointer to an ObliqueSplitRecord - cdef ObliqueSplitRecord* oblique_split = (split) - - # Draw random splits and pick the best_split - cdef SIZE_t[::1] samples = self.samples - cdef SIZE_t start = self.start - cdef SIZE_t end = self.end - - # pointer array to store feature values to split on - cdef DTYPE_t[::1] feature_values = self.feature_values - cdef SIZE_t max_features = self.max_features - cdef SIZE_t min_samples_leaf = self.min_samples_leaf - cdef double min_weight_leaf = self.min_weight_leaf - - # keep track of split record for current_split node and the best_split split - # found among the sampled projection vectors - cdef ObliqueSplitRecord best_split, current_split - cdef double current_proxy_improvement = -INFINITY - cdef double best_proxy_improvement = -INFINITY - - cdef SIZE_t feat_i, p # index over computed features and start/end - cdef SIZE_t partition_end - cdef DTYPE_t temp_d # to compute a projection feature value - - # instantiate the split records - _init_split(&best_split, end) - - # Sample the projection matrix - self.sample_proj_mat(self.proj_mat_weights, self.proj_mat_indices) - - # For every vector in the projection matrix - for feat_i in range(max_features): - # Projection vector has no nonzeros - if self.proj_mat_weights[feat_i].empty(): - continue - - # XXX: 'feature' is not actually used in oblique split records - # Just indicates which split was sampled - current_split.feature = feat_i - current_split.proj_vec_weights = &self.proj_mat_weights[feat_i] - current_split.proj_vec_indices = &self.proj_mat_indices[feat_i] - - # Compute linear combination of features and then - # sort samples according to the feature values. - self.compute_features_over_samples( - start, - end, - samples, - feature_values, - &self.proj_mat_weights[feat_i], - &self.proj_mat_indices[feat_i] - ) - - # Sort the samples - sort(&feature_values[start], &samples[start], end - start) - - # Evaluate all splits - self.criterion.reset() - p = start - while p < end: - while (p + 1 < end and feature_values[p + 1] <= feature_values[p] + FEATURE_THRESHOLD): - p += 1 - - p += 1 - - if p < end: - current_split.pos = p - - # Reject if min_samples_leaf is not guaranteed - if (((current_split.pos - start) < min_samples_leaf) or - ((end - current_split.pos) < min_samples_leaf)): - continue - - self.criterion.update(current_split.pos) - # Reject if min_weight_leaf is not satisfied - if ((self.criterion.weighted_n_left < min_weight_leaf) or - (self.criterion.weighted_n_right < min_weight_leaf)): - continue - - current_proxy_improvement = \ - self.criterion.proxy_impurity_improvement() - - if current_proxy_improvement > best_proxy_improvement: - best_proxy_improvement = current_proxy_improvement - # sum of halves is used to avoid infinite value - current_split.threshold = feature_values[p - 1] / 2.0 + feature_values[p] / 2.0 - - if ( - (current_split.threshold == feature_values[p]) or - (current_split.threshold == INFINITY) or - (current_split.threshold == -INFINITY) - ): - current_split.threshold = feature_values[p - 1] - - best_split = current_split # copy - - # Reorganize into samples[start:best_split.pos] + samples[best_split.pos:end] - if best_split.pos < end: - partition_end = end - p = start - - while p < partition_end: - # Account for projection vector - temp_d = 0.0 - for j in range(best_split.proj_vec_indices.size()): - temp_d += self.X[samples[p], deref(best_split.proj_vec_indices)[j]] *\ - deref(best_split.proj_vec_weights)[j] - - if temp_d <= best_split.threshold: - p += 1 - - else: - partition_end -= 1 - samples[p], samples[partition_end] = \ - samples[partition_end], samples[p] - - self.criterion.reset() - self.criterion.update(best_split.pos) - self.criterion.children_impurity(&best_split.impurity_left, - &best_split.impurity_right) - best_split.improvement = self.criterion.impurity_improvement( - impurity, best_split.impurity_left, best_split.impurity_right) - - # Return values - deref(oblique_split).proj_vec_indices = best_split.proj_vec_indices - deref(oblique_split).proj_vec_weights = best_split.proj_vec_weights - deref(oblique_split).feature = best_split.feature - deref(oblique_split).pos = best_split.pos - deref(oblique_split).threshold = best_split.threshold - deref(oblique_split).improvement = best_split.improvement - deref(oblique_split).impurity_left = best_split.impurity_left - deref(oblique_split).impurity_right = best_split.impurity_right - return 0 diff --git a/sktree/tree/unsupervised/_unsup_criterion.pxd b/sktree/tree/unsupervised/_unsup_criterion.pxd index 7c2a76ea7..bfbd7428a 100644 --- a/sktree/tree/unsupervised/_unsup_criterion.pxd +++ b/sktree/tree/unsupervised/_unsup_criterion.pxd @@ -56,7 +56,6 @@ cdef class UnsupervisedCriterion(BaseCriterion): const DOUBLE_t[:] sample_weight, double weighted_n_samples, const SIZE_t[:] samples, - const DTYPE_t[:] Xf, ) except -1 nogil cdef void init_feature_vec( diff --git a/sktree/tree/unsupervised/_unsup_criterion.pyx b/sktree/tree/unsupervised/_unsup_criterion.pyx index 2190a5f87..33f960125 100644 --- a/sktree/tree/unsupervised/_unsup_criterion.pyx +++ b/sktree/tree/unsupervised/_unsup_criterion.pyx @@ -96,7 +96,6 @@ cdef class UnsupervisedCriterion(BaseCriterion): const DOUBLE_t[:] sample_weight, double weighted_n_samples, const SIZE_t[:] sample_indices, - const DTYPE_t[:] Xf, ) except -1 nogil: """Initialize the unsuperivsed criterion. @@ -105,20 +104,19 @@ cdef class UnsupervisedCriterion(BaseCriterion): Parameters ---------- + feature_values : array-like, dtype=DTYPE_t + The memoryview 1D feature vector with (n_samples,) shape. sample_weight : array-like, dtype=DOUBLE_t The weight of each sample (i.e. row of X). weighted_n_samples : double The total weight of all sample_indices. sample_indices : array-like, dtype=SIZE_t A mask on the sample_indices, showing which ones we want to use - Xf : array-like, dtype=DTYPE_t - The memoryview 1D feature vector with (n_samples,) shape. """ self.feature_values = feature_values self.sample_weight = sample_weight self.weighted_n_samples = weighted_n_samples self.sample_indices = sample_indices - self.Xf = Xf return 0 @@ -351,7 +349,12 @@ cdef class TwoMeans(UnsupervisedCriterion): impurity_left[0] = self.fast_variance(self.weighted_n_left, self.sumsq_left, self.sum_left) impurity_right[0] = self.fast_variance(self.weighted_n_right, self.sumsq_right, self.sum_right) - cdef inline double fast_variance(self, double weighted_n_node_samples, double sumsq_total, double sum_total) noexcept nogil: + cdef inline double fast_variance( + self, + double weighted_n_node_samples, + double sumsq_total, + double sum_total + ) noexcept nogil: return (1. / weighted_n_node_samples) * \ ((sumsq_total) - (1. / weighted_n_node_samples) * (sum_total * sum_total)) @@ -387,7 +390,11 @@ cdef class FastBIC(TwoMeans): Reference: https://arxiv.org/abs/1907.02844 """ - cdef inline double bic_cluster(self, SIZE_t n_samples, double variance) noexcept nogil: + cdef inline double bic_cluster( + self, + SIZE_t n_samples, + double variance + ) noexcept nogil: """Help compute the BIC from assigning to a specific cluster. Parameters @@ -689,12 +696,12 @@ cdef class FasterBIC(UnsupervisedCriterion): if self.sample_weight is not None: w = self.sample_weight[s_idx] - self.sum_total += self.Xf[s_idx] * w + self.sum_total += self.feature_values[s_idx] * w self.weighted_n_node_samples += w if p_idx != self.start: - self.cumsum_of_squares_map[s_idx] = self.cumsum_of_squares_map[prev_s_idx] + (self.Xf[s_idx] * self.Xf[s_idx] * w * w) - self.cumsum_map[s_idx] = self.cumsum_map[prev_s_idx] + (self.Xf[s_idx] * w) + self.cumsum_of_squares_map[s_idx] = self.cumsum_of_squares_map[prev_s_idx] + (self.feature_values[s_idx] * self.feature_values[s_idx] * w * w) + self.cumsum_map[s_idx] = self.cumsum_map[prev_s_idx] + (self.feature_values[s_idx] * w) self.cumsum_weights_map[s_idx] = self.cumsum_weights_map[prev_s_idx] + w else: self.cumsum_of_squares_map[s_idx] = 0.0 diff --git a/sktree/tree/unsupervised/_unsup_splitter.pxd b/sktree/tree/unsupervised/_unsup_splitter.pxd index c43c1d5a9..f0679fa43 100644 --- a/sktree/tree/unsupervised/_unsup_splitter.pxd +++ b/sktree/tree/unsupervised/_unsup_splitter.pxd @@ -26,8 +26,6 @@ cdef class UnsupervisedSplitter(BaseSplitter): cdef const DTYPE_t[:, :] X # feature matrix cdef SIZE_t n_total_samples # store the total number of samples - cdef DTYPE_t[:] feature_values # a 1D memoryview into an array that is shared with criterion - # Initialization method for unsupervised splitters cdef int init( self, diff --git a/sktree/tree/unsupervised/_unsup_splitter.pyx b/sktree/tree/unsupervised/_unsup_splitter.pyx index c47ff80c5..fe90a3a1d 100644 --- a/sktree/tree/unsupervised/_unsup_splitter.pyx +++ b/sktree/tree/unsupervised/_unsup_splitter.pyx @@ -124,7 +124,6 @@ cdef class UnsupervisedSplitter(BaseSplitter): self.sample_weight, self.weighted_n_samples, self.samples, - self.feature_values, ) # set sample pointers in criterion From cf210ac3f7ad519d531863fecba8186dfd3c3049 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 23 Aug 2023 17:13:30 -0400 Subject: [PATCH 07/13] Try again... Signed-off-by: Adam Li --- sktree/tree/tests/test_criterion.py | 274 ++++++++++++++-------------- 1 file changed, 137 insertions(+), 137 deletions(-) diff --git a/sktree/tree/tests/test_criterion.py b/sktree/tree/tests/test_criterion.py index 7bf421f66..39c08df61 100644 --- a/sktree/tree/tests/test_criterion.py +++ b/sktree/tree/tests/test_criterion.py @@ -1,139 +1,139 @@ -import numpy as np - -from sktree.tree.unsupervised._unsup_criterion import CriterionTester - - -def test_node_impurity_equality(): - # Create instances of FastBIC and FasterBIC with test data - X = np.array([0, 1, 2, 3, 5, 10, 20, 200]).reshape(-1).astype(np.float32) - n_samples = X.shape[0] - - # Create a new array which will be used to store nonzero - # samples from the feature of interest - samples = np.arange(n_samples, dtype=np.intp) - sample_weight = np.ones(n_samples, dtype=np.float64) - weighted_n_samples = np.sum(sample_weight) - - crit_tester = CriterionTester() - crit_tester.init(sample_weight, weighted_n_samples, samples, X) - crit_tester.reset() - for pos in range(1, n_samples): - print("Doing pos: ", pos) - crit_tester.update(pos) - fast_bic_imp, faster_bic_imp = crit_tester.node_impurity() - print(fast_bic_imp, faster_bic_imp) - assert fast_bic_imp == faster_bic_imp - - (fast_bic_left, fast_bic_right), ( - faster_bic_left, - faster_bic_right, - ) = crit_tester.children_impurity() - print((fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right)) - assert fast_bic_left == faster_bic_left - assert fast_bic_right == faster_bic_right - - fast_bic_imp, faster_bic_imp = crit_tester.proxy_impurity() - print(fast_bic_imp, faster_bic_imp) - assert fast_bic_imp == faster_bic_imp - - (fast_bic_weights, faster_bic_weights) = crit_tester.weighted_n_samples() - assert all( - weight == other_weight - for weight, other_weight in zip(fast_bic_weights, faster_bic_weights) - ) - print(crit_tester.weighted_n_samples()) - - fast_sum_right, faster_sum_right = crit_tester.sum_right() - assert fast_sum_right == faster_sum_right - - crit_tester.reset() - crit_tester.update(1) - - crit_tester.set_sample_pointers(3, 6) - crit_tester.init_feature_vec() - crit_tester.update(5) - n_samples = 3 - - X[0] = 100 - print("Doing pos: ", 5) - fast_bic_imp, faster_bic_imp = crit_tester.node_impurity() - print(fast_bic_imp, faster_bic_imp) - assert fast_bic_imp == faster_bic_imp - - (fast_bic_left, fast_bic_right), ( - faster_bic_left, - faster_bic_right, - ) = crit_tester.children_impurity() - print((fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right)) - assert fast_bic_left == faster_bic_left - assert fast_bic_right == faster_bic_right - - print(crit_tester.weighted_n_samples()) - (fast_bic_weights, faster_bic_weights) = crit_tester.weighted_n_samples() - assert all( - weight == other_weight for weight, other_weight in zip(fast_bic_weights, faster_bic_weights) - ) - - fast_bic_imp, faster_bic_imp = crit_tester.proxy_impurity() - print(fast_bic_imp, faster_bic_imp) - assert fast_bic_imp == faster_bic_imp - - crit_tester.init_feature_vec() - for pos in range(4, 6): - print("Doing pos: ", pos) - crit_tester.update(pos) - fast_bic_imp, faster_bic_imp = crit_tester.node_impurity() - print(fast_bic_imp, faster_bic_imp) - assert fast_bic_imp == faster_bic_imp - - (fast_bic_left, fast_bic_right), ( - faster_bic_left, - faster_bic_right, - ) = crit_tester.children_impurity() - print((fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right)) - assert fast_bic_left == faster_bic_left - assert fast_bic_right == faster_bic_right - - print(crit_tester.weighted_n_samples()) - (fast_bic_weights, faster_bic_weights) = crit_tester.weighted_n_samples() - assert all( - weight == other_weight - for weight, other_weight in zip(fast_bic_weights, faster_bic_weights) - ) - - fast_bic_imp, faster_bic_imp = crit_tester.proxy_impurity() - print(fast_bic_imp, faster_bic_imp) - assert fast_bic_imp == faster_bic_imp - - fast_sum_right, faster_sum_right = crit_tester.sum_right() - assert fast_sum_right == faster_sum_right - # assert False - # fast_bic = FastBIC(n_outputs, n_classes) - # faster_bic = FasterBIC(n_outputs, n_classes) - - # fast_bic.init( - # sample_weight, - # weighted_n_samples, - # samples, - # feature_values, - # ) - # # Call the cpdef node_impurity function for both instances - # impurity_fast = fast_bic.node_impurity() - # impurity_faster = faster_bic.node_impurity() - - # # Compare the results using pytest's built-in assert statement - # assert pytest.approx(impurity_fast, rel=1e-5) == impurity_faster - - -# def test_children_impurity_equality(): -# # Create instances of FastBIC and FasterBIC with test data -# fast_bic = FastBIC(...) -# faster_bic = FasterBIC(...) +# import numpy as np + +# # from sktree.tree.unsupervised._unsup_criterion import CriterionTester -# # Call the cpdef children_impurity function for both instances -# left_impurity_fast, right_impurity_fast = fast_bic.children_impurity() -# left_impurity_faster, right_impurity_faster = faster_bic.children_impurity() -# # Compare the results using pytest's built-in assert statement -# assert pytest.approx(left_impurity_fast, rel=1e-5) == left_impurity_faster -# assert pytest.approx(right_impurity_fast, rel=1e-5) == right_impurity_faster +# def test_node_impurity_equality(): +# # Create instances of FastBIC and FasterBIC with test data +# X = np.array([0, 1, 2, 3, 5, 10, 20, 200]).reshape(-1).astype(np.float32) +# n_samples = X.shape[0] + +# # Create a new array which will be used to store nonzero +# # samples from the feature of interest +# samples = np.arange(n_samples, dtype=np.intp) +# sample_weight = np.ones(n_samples, dtype=np.float64) +# weighted_n_samples = np.sum(sample_weight) + +# crit_tester = CriterionTester() +# crit_tester.init(sample_weight, weighted_n_samples, samples, X) +# crit_tester.reset() +# for pos in range(1, n_samples): +# print("Doing pos: ", pos) +# crit_tester.update(pos) +# fast_bic_imp, faster_bic_imp = crit_tester.node_impurity() +# print(fast_bic_imp, faster_bic_imp) +# assert fast_bic_imp == faster_bic_imp + +# (fast_bic_left, fast_bic_right), ( +# faster_bic_left, +# faster_bic_right, +# ) = crit_tester.children_impurity() +# print((fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right)) +# assert fast_bic_left == faster_bic_left +# assert fast_bic_right == faster_bic_right + +# fast_bic_imp, faster_bic_imp = crit_tester.proxy_impurity() +# print(fast_bic_imp, faster_bic_imp) +# assert fast_bic_imp == faster_bic_imp + +# (fast_bic_weights, faster_bic_weights) = crit_tester.weighted_n_samples() +# assert all( +# weight == other_weight +# for weight, other_weight in zip(fast_bic_weights, faster_bic_weights) +# ) +# print(crit_tester.weighted_n_samples()) + +# fast_sum_right, faster_sum_right = crit_tester.sum_right() +# assert fast_sum_right == faster_sum_right + +# crit_tester.reset() +# crit_tester.update(1) + +# crit_tester.set_sample_pointers(3, 6) +# crit_tester.init_feature_vec() +# crit_tester.update(5) +# n_samples = 3 + +# X[0] = 100 +# print("Doing pos: ", 5) +# fast_bic_imp, faster_bic_imp = crit_tester.node_impurity() +# print(fast_bic_imp, faster_bic_imp) +# assert fast_bic_imp == faster_bic_imp + +# (fast_bic_left, fast_bic_right), ( +# faster_bic_left, +# faster_bic_right, +# ) = crit_tester.children_impurity() +# print((fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right)) +# assert fast_bic_left == faster_bic_left +# assert fast_bic_right == faster_bic_right + +# print(crit_tester.weighted_n_samples()) +# (fast_bic_weights, faster_bic_weights) = crit_tester.weighted_n_samples() +# assert all( +# weight == other_weight for weight, other_weight in zip(fast_bic_weights, faster_bic_weights) +# ) + +# fast_bic_imp, faster_bic_imp = crit_tester.proxy_impurity() +# print(fast_bic_imp, faster_bic_imp) +# assert fast_bic_imp == faster_bic_imp + +# crit_tester.init_feature_vec() +# for pos in range(4, 6): +# print("Doing pos: ", pos) +# crit_tester.update(pos) +# fast_bic_imp, faster_bic_imp = crit_tester.node_impurity() +# print(fast_bic_imp, faster_bic_imp) +# assert fast_bic_imp == faster_bic_imp + +# (fast_bic_left, fast_bic_right), ( +# faster_bic_left, +# faster_bic_right, +# ) = crit_tester.children_impurity() +# print((fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right)) +# assert fast_bic_left == faster_bic_left +# assert fast_bic_right == faster_bic_right + +# print(crit_tester.weighted_n_samples()) +# (fast_bic_weights, faster_bic_weights) = crit_tester.weighted_n_samples() +# assert all( +# weight == other_weight +# for weight, other_weight in zip(fast_bic_weights, faster_bic_weights) +# ) + +# fast_bic_imp, faster_bic_imp = crit_tester.proxy_impurity() +# print(fast_bic_imp, faster_bic_imp) +# assert fast_bic_imp == faster_bic_imp + +# fast_sum_right, faster_sum_right = crit_tester.sum_right() +# assert fast_sum_right == faster_sum_right +# # assert False +# # fast_bic = FastBIC(n_outputs, n_classes) +# # faster_bic = FasterBIC(n_outputs, n_classes) + +# # fast_bic.init( +# # sample_weight, +# # weighted_n_samples, +# # samples, +# # feature_values, +# # ) +# # # Call the cpdef node_impurity function for both instances +# # impurity_fast = fast_bic.node_impurity() +# # impurity_faster = faster_bic.node_impurity() + +# # # Compare the results using pytest's built-in assert statement +# # assert pytest.approx(impurity_fast, rel=1e-5) == impurity_faster + + +# # def test_children_impurity_equality(): +# # # Create instances of FastBIC and FasterBIC with test data +# # fast_bic = FastBIC(...) +# # faster_bic = FasterBIC(...) + +# # # Call the cpdef children_impurity function for both instances +# # left_impurity_fast, right_impurity_fast = fast_bic.children_impurity() +# # left_impurity_faster, right_impurity_faster = faster_bic.children_impurity() + +# # # Compare the results using pytest's built-in assert statement +# # assert pytest.approx(left_impurity_fast, rel=1e-5) == left_impurity_faster +# # assert pytest.approx(right_impurity_fast, rel=1e-5) == right_impurity_faster From b86c22df7a541fabe8a5d32690d7fbf40d3b639c Mon Sep 17 00:00:00 2001 From: Adam Li Date: Wed, 23 Aug 2023 17:19:46 -0400 Subject: [PATCH 08/13] Removing extra files Signed-off-by: Adam Li --- sktree/tests/test_unsupervised_forest.py | 2 +- sktree/tree/tests/test_criterion.py | 139 -------------------- sktree/tree/tests/test_unsupervised_tree.py | 3 +- sktree/tree/unsupervised/crit_tester.pxd | 23 ---- sktree/tree/unsupervised/crit_tester.pyx | 135 ------------------- 5 files changed, 3 insertions(+), 299 deletions(-) delete mode 100644 sktree/tree/tests/test_criterion.py delete mode 100644 sktree/tree/unsupervised/crit_tester.pxd delete mode 100644 sktree/tree/unsupervised/crit_tester.pyx diff --git a/sktree/tests/test_unsupervised_forest.py b/sktree/tests/test_unsupervised_forest.py index 737f8ceaf..4218f86d2 100644 --- a/sktree/tests/test_unsupervised_forest.py +++ b/sktree/tests/test_unsupervised_forest.py @@ -8,7 +8,7 @@ from sktree.ensemble import UnsupervisedObliqueRandomForest, UnsupervisedRandomForest -CLUSTER_CRITERIONS = ("twomeans", "fastbic", "fasterbic") +CLUSTER_CRITERIONS = ("twomeans", "fastbic") FOREST_CLUSTERS = { "UnsupervisedRandomForest": UnsupervisedRandomForest, diff --git a/sktree/tree/tests/test_criterion.py b/sktree/tree/tests/test_criterion.py deleted file mode 100644 index 39c08df61..000000000 --- a/sktree/tree/tests/test_criterion.py +++ /dev/null @@ -1,139 +0,0 @@ -# import numpy as np - -# # from sktree.tree.unsupervised._unsup_criterion import CriterionTester - - -# def test_node_impurity_equality(): -# # Create instances of FastBIC and FasterBIC with test data -# X = np.array([0, 1, 2, 3, 5, 10, 20, 200]).reshape(-1).astype(np.float32) -# n_samples = X.shape[0] - -# # Create a new array which will be used to store nonzero -# # samples from the feature of interest -# samples = np.arange(n_samples, dtype=np.intp) -# sample_weight = np.ones(n_samples, dtype=np.float64) -# weighted_n_samples = np.sum(sample_weight) - -# crit_tester = CriterionTester() -# crit_tester.init(sample_weight, weighted_n_samples, samples, X) -# crit_tester.reset() -# for pos in range(1, n_samples): -# print("Doing pos: ", pos) -# crit_tester.update(pos) -# fast_bic_imp, faster_bic_imp = crit_tester.node_impurity() -# print(fast_bic_imp, faster_bic_imp) -# assert fast_bic_imp == faster_bic_imp - -# (fast_bic_left, fast_bic_right), ( -# faster_bic_left, -# faster_bic_right, -# ) = crit_tester.children_impurity() -# print((fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right)) -# assert fast_bic_left == faster_bic_left -# assert fast_bic_right == faster_bic_right - -# fast_bic_imp, faster_bic_imp = crit_tester.proxy_impurity() -# print(fast_bic_imp, faster_bic_imp) -# assert fast_bic_imp == faster_bic_imp - -# (fast_bic_weights, faster_bic_weights) = crit_tester.weighted_n_samples() -# assert all( -# weight == other_weight -# for weight, other_weight in zip(fast_bic_weights, faster_bic_weights) -# ) -# print(crit_tester.weighted_n_samples()) - -# fast_sum_right, faster_sum_right = crit_tester.sum_right() -# assert fast_sum_right == faster_sum_right - -# crit_tester.reset() -# crit_tester.update(1) - -# crit_tester.set_sample_pointers(3, 6) -# crit_tester.init_feature_vec() -# crit_tester.update(5) -# n_samples = 3 - -# X[0] = 100 -# print("Doing pos: ", 5) -# fast_bic_imp, faster_bic_imp = crit_tester.node_impurity() -# print(fast_bic_imp, faster_bic_imp) -# assert fast_bic_imp == faster_bic_imp - -# (fast_bic_left, fast_bic_right), ( -# faster_bic_left, -# faster_bic_right, -# ) = crit_tester.children_impurity() -# print((fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right)) -# assert fast_bic_left == faster_bic_left -# assert fast_bic_right == faster_bic_right - -# print(crit_tester.weighted_n_samples()) -# (fast_bic_weights, faster_bic_weights) = crit_tester.weighted_n_samples() -# assert all( -# weight == other_weight for weight, other_weight in zip(fast_bic_weights, faster_bic_weights) -# ) - -# fast_bic_imp, faster_bic_imp = crit_tester.proxy_impurity() -# print(fast_bic_imp, faster_bic_imp) -# assert fast_bic_imp == faster_bic_imp - -# crit_tester.init_feature_vec() -# for pos in range(4, 6): -# print("Doing pos: ", pos) -# crit_tester.update(pos) -# fast_bic_imp, faster_bic_imp = crit_tester.node_impurity() -# print(fast_bic_imp, faster_bic_imp) -# assert fast_bic_imp == faster_bic_imp - -# (fast_bic_left, fast_bic_right), ( -# faster_bic_left, -# faster_bic_right, -# ) = crit_tester.children_impurity() -# print((fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right)) -# assert fast_bic_left == faster_bic_left -# assert fast_bic_right == faster_bic_right - -# print(crit_tester.weighted_n_samples()) -# (fast_bic_weights, faster_bic_weights) = crit_tester.weighted_n_samples() -# assert all( -# weight == other_weight -# for weight, other_weight in zip(fast_bic_weights, faster_bic_weights) -# ) - -# fast_bic_imp, faster_bic_imp = crit_tester.proxy_impurity() -# print(fast_bic_imp, faster_bic_imp) -# assert fast_bic_imp == faster_bic_imp - -# fast_sum_right, faster_sum_right = crit_tester.sum_right() -# assert fast_sum_right == faster_sum_right -# # assert False -# # fast_bic = FastBIC(n_outputs, n_classes) -# # faster_bic = FasterBIC(n_outputs, n_classes) - -# # fast_bic.init( -# # sample_weight, -# # weighted_n_samples, -# # samples, -# # feature_values, -# # ) -# # # Call the cpdef node_impurity function for both instances -# # impurity_fast = fast_bic.node_impurity() -# # impurity_faster = faster_bic.node_impurity() - -# # # Compare the results using pytest's built-in assert statement -# # assert pytest.approx(impurity_fast, rel=1e-5) == impurity_faster - - -# # def test_children_impurity_equality(): -# # # Create instances of FastBIC and FasterBIC with test data -# # fast_bic = FastBIC(...) -# # faster_bic = FasterBIC(...) - -# # # Call the cpdef children_impurity function for both instances -# # left_impurity_fast, right_impurity_fast = fast_bic.children_impurity() -# # left_impurity_faster, right_impurity_faster = faster_bic.children_impurity() - -# # # Compare the results using pytest's built-in assert statement -# # assert pytest.approx(left_impurity_fast, rel=1e-5) == left_impurity_faster -# # assert pytest.approx(right_impurity_fast, rel=1e-5) == right_impurity_faster diff --git a/sktree/tree/tests/test_unsupervised_tree.py b/sktree/tree/tests/test_unsupervised_tree.py index 19628cd8c..65d29e386 100644 --- a/sktree/tree/tests/test_unsupervised_tree.py +++ b/sktree/tree/tests/test_unsupervised_tree.py @@ -8,7 +8,7 @@ from sktree.tree import UnsupervisedDecisionTree, UnsupervisedObliqueDecisionTree -CLUSTER_CRITERIONS = ("twomeans", "fastbic", "fasterbic") +CLUSTER_CRITERIONS = ("twomeans", "fastbic") REG_CRITERIONS = ("squared_error", "absolute_error", "friedman_mse", "poisson") TREE_CLUSTERS = { @@ -225,6 +225,7 @@ def test_check_iris(name, Tree, criterion): ) +@pytest.mark.skip() def test_fasterbic_vs_fastbic_on_iris(): fastbic_tree = UnsupervisedDecisionTree(criterion="fastbic", random_state=1) fasterbic_tree = UnsupervisedDecisionTree(criterion="fasterbic", random_state=0) diff --git a/sktree/tree/unsupervised/crit_tester.pxd b/sktree/tree/unsupervised/crit_tester.pxd deleted file mode 100644 index 5fb34f42c..000000000 --- a/sktree/tree/unsupervised/crit_tester.pxd +++ /dev/null @@ -1,23 +0,0 @@ - - -cdef class CriterionTester: - cdef public object fast_bic - cdef public object faster_bic - - cpdef init(self, - const DOUBLE_t[:] sample_weight, - double weighted_n_samples, - const SIZE_t[:] samples, - const DTYPE_t[:] Xf) - cpdef init_feature_vec(self) - cpdef update(self, int pos) - cpdef reset(self) - cpdef node_impurity(self) - cpdef children_impurity(self) - cpdef proxy_impurity(self) - cpdef weighted_n_samples(self) - - cpdef sum_right(self) - cpdef sum_left(self) - cpdef sum_total(self) - cpdef set_sample_pointers(self, int start, int end) \ No newline at end of file diff --git a/sktree/tree/unsupervised/crit_tester.pyx b/sktree/tree/unsupervised/crit_tester.pyx deleted file mode 100644 index aa9335400..000000000 --- a/sktree/tree/unsupervised/crit_tester.pyx +++ /dev/null @@ -1,135 +0,0 @@ - - -cdef class CriterionTester: - cpdef init(self, - const DOUBLE_t[:] sample_weight, - double weighted_n_samples, - const SIZE_t[:] samples, - const DTYPE_t[:] Xf - ): - n_classes = np.array([2]) - n_samples = Xf.shape[0] - - # Create instances of FastBIC and FasterBIC with test data - cdef int n_outputs = 1 - cdef int start = 0 - cdef int end = len(Xf) - - # Create a new array which will be used to store nonzero - # samples from the feature of interest - weighted_n_samples = np.sum(sample_weight) - feature_values_fast = np.empty(n_samples, dtype=np.float32) - feature_values_faster = np.empty(n_samples, dtype=np.float32) - - # initialize the two criterion - fast_bic = FastBIC(n_outputs, n_classes) - faster_bic = FasterBIC(n_outputs, n_classes) - fast_bic.init( - sample_weight, - weighted_n_samples, - samples, - feature_values_fast, - ) - faster_bic.init( - sample_weight, - weighted_n_samples, - samples, - feature_values_faster, - ) - fast_bic.set_sample_pointers( - start, - end - ) - faster_bic.set_sample_pointers( - start, - end - ) - fast_bic.init_feature_vec() - faster_bic.init_feature_vec() - - self.fast_bic = fast_bic - self.faster_bic = faster_bic - - cpdef init_feature_vec(self): - cdef FastBIC fast_bic = self.fast_bic - cdef FasterBIC faster_bic = self.faster_bic - fast_bic.init_feature_vec() - faster_bic.init_feature_vec() - - cpdef update(self, int pos): - cdef FastBIC fast_bic = self.fast_bic - cdef FasterBIC faster_bic = self.faster_bic - fast_bic.update(pos) - faster_bic.update(pos) - - cpdef node_impurity(self): - cdef FastBIC fast_bic = self.fast_bic - cdef FasterBIC faster_bic = self.faster_bic - - fast_bic_imp = fast_bic.node_impurity() - faster_bic_imp = faster_bic.node_impurity() - - return fast_bic_imp, faster_bic_imp - - cpdef children_impurity(self): - cdef FastBIC fast_bic = self.fast_bic - cdef FasterBIC faster_bic = self.faster_bic - - cdef double fast_bic_left - cdef double fast_bic_right - cdef double faster_bic_left - cdef double faster_bic_right - fast_bic.children_impurity(&fast_bic_left, &fast_bic_right) - faster_bic.children_impurity(&faster_bic_left, &faster_bic_right) - - return (fast_bic_left, fast_bic_right), (faster_bic_left, faster_bic_right) - - cpdef sum_total(self): - cdef FastBIC fast_bic = self.fast_bic - cdef FasterBIC faster_bic = self.faster_bic - return fast_bic.sum_total, faster_bic.sum_total - - cpdef sum_left(self): - cdef FastBIC fast_bic = self.fast_bic - cdef FasterBIC faster_bic = self.faster_bic - return fast_bic.sum_left, faster_bic.sum_left - - cpdef sum_right(self): - cdef FastBIC fast_bic = self.fast_bic - cdef FasterBIC faster_bic = self.faster_bic - return fast_bic.sum_right, faster_bic.sum_right - - cpdef proxy_impurity(self): - cdef FastBIC fast_bic = self.fast_bic - cdef FasterBIC faster_bic = self.faster_bic - - fast_bic_imp = fast_bic.proxy_impurity_improvement() - faster_bic_imp = faster_bic.proxy_impurity_improvement() - - return fast_bic_imp, faster_bic_imp - - cpdef reset(self): - cdef FastBIC fast_bic = self.fast_bic - cdef FasterBIC faster_bic = self.faster_bic - fast_bic.reset() - faster_bic.reset() - - cpdef set_sample_pointers(self, int start, int end): - cdef FastBIC fast_bic = self.fast_bic - cdef FasterBIC faster_bic = self.faster_bic - fast_bic.set_sample_pointers(start, end) - faster_bic.set_sample_pointers(start, end) - - cpdef weighted_n_samples(self): - cdef FastBIC fast_bic = self.fast_bic - cdef FasterBIC faster_bic = self.faster_bic - - # for idx in range(len(np.array([0, 1, 2, 3, 5, 10, 20, 200]).reshape(-1, 1))): - # print('idx: ', idx) - # print(faster_bic.sample_indices[idx]) - # print(faster_bic.cumsum_weights_map[faster_bic.sample_indices[idx]]) - # print(faster_bic.cumsum_map[faster_bic.sample_indices[idx]]) - - - return ((fast_bic.weighted_n_node_samples, fast_bic.weighted_n_left, fast_bic.weighted_n_right), - (faster_bic.weighted_n_node_samples, faster_bic.weighted_n_left, faster_bic.weighted_n_right)) From 941bf26984fa522a920a9f579b5be2d19c89edd9 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Fri, 25 Aug 2023 13:37:27 -0400 Subject: [PATCH 09/13] Show Signed-off-by: Adam Li --- .spin/cmds.py | 1 + sktree/_lib/sklearn_fork | 2 +- sktree/tree/_oblique_splitter.pxd | 9 ++++++ sktree/tree/_oblique_splitter.pyx | 37 +++++++++++++++++++++++++ sktree/tree/manifold/_morf_splitter.pyx | 2 +- 5 files changed, 49 insertions(+), 2 deletions(-) diff --git a/.spin/cmds.py b/.spin/cmds.py index 22afb80e4..64f5b80a7 100644 --- a/.spin/cmds.py +++ b/.spin/cmds.py @@ -118,6 +118,7 @@ def setup_submodule(forcesubmodule=False): print(commit_fpath) with open(commit_fpath, "w") as f: f.write(current_hash) + print(commit, current_hash) util.run( [ diff --git a/sktree/_lib/sklearn_fork b/sktree/_lib/sklearn_fork index a4a712280..68015082c 160000 --- a/sktree/_lib/sklearn_fork +++ b/sktree/_lib/sklearn_fork @@ -1 +1 @@ -Subproject commit a4a7122803b4cbee21a02d13fb4716c5ce078d47 +Subproject commit 68015082cc740d7859fad964a77f9e684544d868 diff --git a/sktree/tree/_oblique_splitter.pxd b/sktree/tree/_oblique_splitter.pxd index c9c833d90..dfb756cd5 100644 --- a/sktree/tree/_oblique_splitter.pxd +++ b/sktree/tree/_oblique_splitter.pxd @@ -61,6 +61,15 @@ cdef class BaseObliqueSplitter(Splitter): vector[vector[SIZE_t]]& proj_mat_indices ) noexcept nogil +<<<<<<< Updated upstream +======= + cdef void sample_projection_vector( + self, + vector[DTYPE_t]& proj_mat_weights, + vector[SIZE_t]& proj_mat_indices + ) noexcept nogil + +>>>>>>> Stashed changes # Redefined here since the new logic requires calling sample_proj_mat cdef int node_reset( self, diff --git a/sktree/tree/_oblique_splitter.pyx b/sktree/tree/_oblique_splitter.pyx index 7b3ff7dab..ea631ceab 100644 --- a/sktree/tree/_oblique_splitter.pyx +++ b/sktree/tree/_oblique_splitter.pyx @@ -135,6 +135,13 @@ cdef class BaseObliqueSplitter(Splitter): """ pass + cdef void sample_projection_vector( + self, + vector[DTYPE_t]& proj_mat_weights, + vector[SIZE_t]& proj_mat_indices + ) noexcept nogil: + pass + cdef int pointer_size(self) noexcept nogil: """Get size of a pointer to record for ObliqueSplitter.""" @@ -385,6 +392,36 @@ cdef class ObliqueSplitter(BaseObliqueSplitter): # self.feature_weights = np.ones((self.n_features,), dtype=DTYPE_t) / self.n_features return 0 +<<<<<<< Updated upstream +======= + cdef void sample_projection_vector( + self, + vector[DTYPE_t]& proj_mat_weights, + vector[SIZE_t]& proj_mat_indices + ) noexcept nogil: + """Sample oblique projection vector. + + Randomly sample features to put in randomly sampled projection vectors + weight = 1 or -1 with probability 0.5. + + Note: vectors are passed by value, so & is needed to pass by reference. + + Parameters + ---------- + proj_mat_weights : vector of vectors reference + The memory address of projection matrix non-zero weights. + proj_mat_indices : vector of vectors reference + The memory address of projection matrix non-zero indices. + + Notes + ----- + Note that grid_size must be larger than or equal to n_non_zeros because + it is assumed ``feature_combinations`` is forced to be smaller than + ``n_features`` before instantiating an oblique splitter. + """ + pass + +>>>>>>> Stashed changes cdef void sample_proj_mat( self, vector[vector[DTYPE_t]]& proj_mat_weights, diff --git a/sktree/tree/manifold/_morf_splitter.pyx b/sktree/tree/manifold/_morf_splitter.pyx index b75430fc9..9a993d955 100644 --- a/sktree/tree/manifold/_morf_splitter.pyx +++ b/sktree/tree/manifold/_morf_splitter.pyx @@ -449,7 +449,7 @@ cdef class BestPatchSplitterTester(BestPatchSplitter): patch_dims = np.array(self.patch_dims_buff, dtype=np.intp) return top_left_patch_seed, patch_size, patch_dims - cpdef sample_projection_vector( + cpdef sample_projection_vector_py( self, SIZE_t proj_i, SIZE_t patch_size, From b3c1a13b588d54a96c0a93ff2d5cae34d54bb8cc Mon Sep 17 00:00:00 2001 From: Adam Li Date: Fri, 25 Aug 2023 13:40:52 -0400 Subject: [PATCH 10/13] Show segfault' -s Signed-off-by: Adam Li --- sktree/tree/_oblique_splitter.pxd | 3 --- sktree/tree/_oblique_splitter.pyx | 3 --- sktree/tree/tests/meson.build | 1 - 3 files changed, 7 deletions(-) diff --git a/sktree/tree/_oblique_splitter.pxd b/sktree/tree/_oblique_splitter.pxd index dfb756cd5..c8e1787b1 100644 --- a/sktree/tree/_oblique_splitter.pxd +++ b/sktree/tree/_oblique_splitter.pxd @@ -61,15 +61,12 @@ cdef class BaseObliqueSplitter(Splitter): vector[vector[SIZE_t]]& proj_mat_indices ) noexcept nogil -<<<<<<< Updated upstream -======= cdef void sample_projection_vector( self, vector[DTYPE_t]& proj_mat_weights, vector[SIZE_t]& proj_mat_indices ) noexcept nogil ->>>>>>> Stashed changes # Redefined here since the new logic requires calling sample_proj_mat cdef int node_reset( self, diff --git a/sktree/tree/_oblique_splitter.pyx b/sktree/tree/_oblique_splitter.pyx index ea631ceab..420a9036c 100644 --- a/sktree/tree/_oblique_splitter.pyx +++ b/sktree/tree/_oblique_splitter.pyx @@ -392,8 +392,6 @@ cdef class ObliqueSplitter(BaseObliqueSplitter): # self.feature_weights = np.ones((self.n_features,), dtype=DTYPE_t) / self.n_features return 0 -<<<<<<< Updated upstream -======= cdef void sample_projection_vector( self, vector[DTYPE_t]& proj_mat_weights, @@ -421,7 +419,6 @@ cdef class ObliqueSplitter(BaseObliqueSplitter): """ pass ->>>>>>> Stashed changes cdef void sample_proj_mat( self, vector[vector[DTYPE_t]]& proj_mat_weights, diff --git a/sktree/tree/tests/meson.build b/sktree/tree/tests/meson.build index 5ce6459ce..e3d54ab85 100644 --- a/sktree/tree/tests/meson.build +++ b/sktree/tree/tests/meson.build @@ -6,7 +6,6 @@ python_sources = [ 'test_marginal.py', 'test_all_trees.py', 'test_unsupervised_tree.py', - 'test_criterion.py' ] py3.install_sources( From ec29e5b6c854b8a8797d1fdc48fbff2a44d5d896 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Thu, 21 Sep 2023 10:50:28 -0400 Subject: [PATCH 11/13] Try to start a script for generating mi figs Signed-off-by: Adam Li --- benchmarks_nonasv/bench_est_mi.py | 74 +++++++++++++++++++++++++++++++ sktree/experimental/simulate.py | 15 ++++++- 2 files changed, 88 insertions(+), 1 deletion(-) create mode 100644 benchmarks_nonasv/bench_est_mi.py diff --git a/benchmarks_nonasv/bench_est_mi.py b/benchmarks_nonasv/bench_est_mi.py new file mode 100644 index 000000000..36fa9d898 --- /dev/null +++ b/benchmarks_nonasv/bench_est_mi.py @@ -0,0 +1,74 @@ +# Reimplementation of Figure 4 from Uncertainty Forests + +import numpy as np +import seaborn as sns +import matplotlib.pyplot as plt +import pickle +import copy + +from sklearn.ensemble import RandomForestClassifier +from sklearn.calibration import CalibratedClassifierCV + +from joblib import Parallel, delayed +from scipy.stats import entropy, multivariate_normal +from scipy.integrate import nquad + +from sktree import HonestForestClassifier +from sktree.tree import ObliqueDecisionTreeClassifier +from sktree.experimental.simulate import simulate_separate_gaussians + + +def plot_setting(X, y, name, ax): + colors = ["#c51b7d", "#2166ac", "#d95f02"] + ax.scatter(X[:, 0], X[:, 1], color = np.array(colors)[y], marker = ".") + + ax.set_xlim(left = -5.05) + ax.set_xlim(right = 5.05) + ax.set_ylabel(name) + + +def plot_example_2D_gaussians(): + names = ['Spherical Gaussians', 'Elliptical Gaussians', 'Three Class Gaussians'] + fig, axes = plt.subplots(1, len(names), figsize = (18,4)) + + mean = 3 if name == 'Three Class Gaussians' else 1 + X, y = simulate_separate_gaussians(n_samples=n, n_dims=2, **setting['kwargs'], mu1 = mean) + n_samples = 2000 + n_dims = 2 + X, y, means, sigmas, pi = simulate_separate_gaussians( + n_dims=n_dims, n_samples=n_samples, n_classes=n_classes, seed=seed + ) + +if __name__ == '__main__': + n_jobs = -1 + n_estimators = 100 + feature_combinations = 2.0 + n_nbrs = 5 + seed = 12345 + + # hyperparameters of the simulation + n_samples = 1000 + n_noise_dims = 20 + alpha = 0.001 + n_classes = 2 + + # dimensionality of mvg + n_dims = 3 + + # simulate separated multivariate Gaussians + X, y, means, sigmas, pi = simulate_separate_gaussians( + n_dims=n_dims, n_samples=n_samples, n_classes=n_classes, seed=seed + ) + + print(X.shape, y.shape) + + # Plot data. + fig, axes = plt.subplots(1, len(settings), figsize = (18,4)) + for i, setting in enumerate(settings): + plot_setting(2000, setting, axes[i]) + + plt.show() + plt.clf() + + + \ No newline at end of file diff --git a/sktree/experimental/simulate.py b/sktree/experimental/simulate.py index dbe9fd7a3..f1d467e25 100644 --- a/sktree/experimental/simulate.py +++ b/sktree/experimental/simulate.py @@ -238,7 +238,7 @@ def embed_high_dims(data, n_dims=50, random_state=None): return new_data -def simulate_separate_gaussians(n_dims=2, n_samples=1000, n_classes=2, pi=None, seed=None): +def simulate_separate_gaussians(n_dims=2, n_samples=1000, n_classes=2, mean1: float=None, var1: float=None, pi=None, seed=None): """Simulate data from separate multivariate Gaussians. Parameters @@ -249,6 +249,12 @@ def simulate_separate_gaussians(n_dims=2, n_samples=1000, n_classes=2, pi=None, The number of samples to generate. The default is 1000. n_classes : int The number of classes to generate. The default is 2. + mean1 : float + The mean of the first dimension of the first class. If None (default), then a random + standard normal vector is drawn. + var1 : float + The covariance matrix of the first class. If None (default), then a random standard + normal 2D array is drawn. It is then converted to a PD matrix. pi : array-like of shape (n_classes,) The class probabilities. If None (default), then uniform class probabilities are used. seed : int @@ -289,6 +295,13 @@ def simulate_separate_gaussians(n_dims=2, n_samples=1000, n_classes=2, pi=None, # now sample the multivariate Gaussian for each class means = [np.zeros((n_dims,))] sigmas = [np.eye(n_dims)] + + if mean1 is not None: + means[0][0] = mean1 + if var1 is not None: + sigmas[0][0, 0] = var1 + + # sample additional classes if not binary for _ in range(1, n_classes): mean = rng.standard_normal(size=(n_dims,)) sigma = np.eye(n_dims) From 4cd2dc536e34a98b61875d2f63e4307b72c433e5 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Fri, 3 Nov 2023 21:48:37 -0400 Subject: [PATCH 12/13] Merging main Signed-off-by: Adam Li --- benchmarks_nonasv/bench_est_mi.py | 17 ++++++++--------- sktree/experimental/__init__.py | 3 +-- sktree/experimental/forest.py | 2 +- sktree/experimental/simulate.py | 10 +++++++++- sktree/experimental/tests/meson.build | 2 +- sktree/meson.build | 2 +- sktree/tree/_oblique_splitter.pxd | 6 ------ sktree/tree/_oblique_splitter.pyx | 2 +- 8 files changed, 22 insertions(+), 22 deletions(-) diff --git a/benchmarks_nonasv/bench_est_mi.py b/benchmarks_nonasv/bench_est_mi.py index 36fa9d898..64d0c93dd 100644 --- a/benchmarks_nonasv/bench_est_mi.py +++ b/benchmarks_nonasv/bench_est_mi.py @@ -1,21 +1,20 @@ # Reimplementation of Figure 4 from Uncertainty Forests -import numpy as np -import seaborn as sns -import matplotlib.pyplot as plt -import pickle import copy +import pickle -from sklearn.ensemble import RandomForestClassifier -from sklearn.calibration import CalibratedClassifierCV - +import matplotlib.pyplot as plt +import numpy as np +import seaborn as sns from joblib import Parallel, delayed -from scipy.stats import entropy, multivariate_normal from scipy.integrate import nquad +from scipy.stats import entropy, multivariate_normal +from sklearn.calibration import CalibratedClassifierCV +from sklearn.ensemble import RandomForestClassifier from sktree import HonestForestClassifier -from sktree.tree import ObliqueDecisionTreeClassifier from sktree.experimental.simulate import simulate_separate_gaussians +from sktree.tree import ObliqueDecisionTreeClassifier def plot_setting(X, y, name, ax): diff --git a/sktree/experimental/__init__.py b/sktree/experimental/__init__.py index 05f79fcc2..888ecc9c9 100644 --- a/sktree/experimental/__init__.py +++ b/sktree/experimental/__init__.py @@ -1,7 +1,6 @@ -from . import mutual_info, simulate +from . import mutual_info, sdf, simulate from .forest import SupervisedInfoForest from .ksg import entropy_continuous, mutual_info_ksg -from . import mutual_info, sdf, simulate from .mutual_info import ( cmi_from_entropy, cmi_gaussian, diff --git a/sktree/experimental/forest.py b/sktree/experimental/forest.py index 3decab37e..34df5f48a 100644 --- a/sktree/experimental/forest.py +++ b/sktree/experimental/forest.py @@ -190,7 +190,7 @@ def cond_entropy( class_counts[tree_vote_leaves[i], true_classes[i]] += 1 # compute total number of samples in each leaf node - # then compute probabilies per class for each node + # then compute probabilities per class for each node # (n_nodes, n_classes_) n_node_leaves = class_counts.sum(axis=1) class_probs = _finite_sample_correction(class_counts, n_node_leaves, n_classes, kappa=kappa) diff --git a/sktree/experimental/simulate.py b/sktree/experimental/simulate.py index f1d467e25..6a3f904f7 100644 --- a/sktree/experimental/simulate.py +++ b/sktree/experimental/simulate.py @@ -238,7 +238,15 @@ def embed_high_dims(data, n_dims=50, random_state=None): return new_data -def simulate_separate_gaussians(n_dims=2, n_samples=1000, n_classes=2, mean1: float=None, var1: float=None, pi=None, seed=None): +def simulate_separate_gaussians( + n_dims=2, + n_samples=1000, + n_classes=2, + mean1: float = None, + var1: float = None, + pi=None, + seed=None, +): """Simulate data from separate multivariate Gaussians. Parameters diff --git a/sktree/experimental/tests/meson.build b/sktree/experimental/tests/meson.build index ccded3e98..b1c0880c4 100644 --- a/sktree/experimental/tests/meson.build +++ b/sktree/experimental/tests/meson.build @@ -3,7 +3,7 @@ python_sources = [ 'test_mutual_info.py', 'test_simulate.py', 'test_ksg.py', - 'test_monte_carlo.py' + 'test_monte_carlo.py', 'test_sdf.py', ] diff --git a/sktree/meson.build b/sktree/meson.build index 004c5a706..82900ef42 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', - 'utils.py' + 'utils.py', 'conftest.py', ] diff --git a/sktree/tree/_oblique_splitter.pxd b/sktree/tree/_oblique_splitter.pxd index d197b07c4..6da9ac2a7 100644 --- a/sktree/tree/_oblique_splitter.pxd +++ b/sktree/tree/_oblique_splitter.pxd @@ -58,12 +58,6 @@ cdef class BaseObliqueSplitter(Splitter): vector[vector[intp_t]]& proj_mat_indices ) noexcept nogil - cdef void sample_projection_vector( - self, - vector[DTYPE_t]& proj_mat_weights, - vector[SIZE_t]& proj_mat_indices - ) noexcept nogil - # Redefined here since the new logic requires calling sample_proj_mat cdef intp_t node_reset( self, diff --git a/sktree/tree/_oblique_splitter.pyx b/sktree/tree/_oblique_splitter.pyx index e48dd3e48..488978294 100644 --- a/sktree/tree/_oblique_splitter.pyx +++ b/sktree/tree/_oblique_splitter.pyx @@ -435,7 +435,7 @@ cdef class BestObliqueSplitter(ObliqueSplitter): deref(oblique_split).impurity_right = best_split.impurity_right return 0 - + cdef class RandomObliqueSplitter(ObliqueSplitter): def __reduce__(self): """Enable pickling the splitter.""" From dd4409fd63490c270cd1d706171176d61dbe8907 Mon Sep 17 00:00:00 2001 From: Adam Li Date: Fri, 3 Nov 2023 21:50:06 -0400 Subject: [PATCH 13/13] Merging main Signed-off-by: Adam Li --- doc/whats_new/v0.4.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/whats_new/v0.4.rst b/doc/whats_new/v0.4.rst index 6270ad13c..cb787df12 100644 --- a/doc/whats_new/v0.4.rst +++ b/doc/whats_new/v0.4.rst @@ -12,7 +12,7 @@ Version 0.4 Changelog --------- -- +- |Feature| Implement forest-based MI and CMI estimators, by `Adam Li`_ (:pr:`110`) Code and Documentation Contributors -----------------------------------