diff --git a/bartpy/covariates.py b/bartpy/covariates.py new file mode 100644 index 0000000..06a705a --- /dev/null +++ b/bartpy/covariates.py @@ -0,0 +1,212 @@ +from abc import ABCMeta +from operator import gt, le +from typing import List, Any, Union, Optional + +import numpy as np +import pandas as pd + +from bartpy.errors import NoSplittableVariableException +from bartpy.splitcondition import SplitCondition +from bartpy.samplers.scalar import VariableWidthDiscreteSampler + + +DataFrame = Union[np.ndarray, pd.DataFrame] + + +def is_not_constant(series: np.ndarray) -> bool: + """ + Quickly identify whether a series contains more than 1 distinct value + Parameters + ---------- + series: np.ndarray + The series to assess + + Returns + ------- + bool + True if more than one distinct value found + """ + if len(series) <= 1: + return False + first_value = None + for i in range(1, len(series)): + if series[i] != first_value: + if first_value is None: + first_value = series.data[i] + else: + return True + return False + + +def is_unique(series: np.ndarray) -> bool: + vals = set() + for i in range(0, len(series)): + if series[i] in vals: + return False + else: + vals.add(series[i]) + else: + return True + + +class CovariateMatrix(object, metaclass=ABCMeta): + + def __init__(self, + X: DataFrame, + mask: np.ndarray, + n_obsv: int, + unique_columns: List[Optional[bool]], + splittable_variables: List[Optional[bool]], + choice_sampler: VariableWidthDiscreteSampler=VariableWidthDiscreteSampler()): + + self._X = X + self._n_obsv = n_obsv + self._n_features = X.shape[1] + self._mask = mask + self.choice_sampler = choice_sampler + + # Cache initialization + if unique_columns is not None: + self._unique_columns = [x if x else None for x in unique_columns] + else: + self._unique_columns = [None for _ in range(self._n_features)] + + if splittable_variables is not None: + self._splittable_variables = [x if x is False else None for x in splittable_variables] + else: + self._splittable_variables = [None for _ in range(self._n_features)] + + self._max_value_cache = [None] * self._n_features + self._X_cache = None + + def get_column(self, i: int) -> np.ndarray: + if self._X_cache is None: + self._X_cache = self.values[self.mask, :] + return self._X_cache[:, i] + + def is_variable_splittable(self, i: int) -> bool: + if self.is_column_unique(i) and self.n_obsv > 1: + return True + else: + return is_not_constant(self.get_column(i)) + + def splittable_variables(self) -> List[int]: + """ + List of columns that can be split on, i.e. that have more than one unique value + + Returns + ------- + List[int] + List of column numbers that can be split on + """ + for i in range(0, self._n_features): + if self._splittable_variables[i] is None: + self._splittable_variables[i] = self.is_variable_splittable(i) + + return [i for (i, x) in enumerate(self._splittable_variables) if x] + + def is_at_least_one_splittable_variable(self) -> bool: + if any(self.splittable_variables_cache): + return True + else: + return len(self.splittable_variables()) > 0 + + def random_splittable_value(self, variable: int) -> Any: + """ + Return a random value of a variable + Useful for choosing a variable to split on + + Parameters + ---------- + variable - str + Name of the variable to split on + + Returns + ------- + Any + + Notes + ----- + - Won't create degenerate splits, all splits will have at least one row on both sides of the split + """ + if not self.is_variable_splittable(variable): + raise NoSplittableVariableException() + max_value = self.max_value_of_column(variable) + candidate = self.choice_sampler.sample(self.get_column(variable)) + while candidate == max_value: + candidate = self.choice_sampler.sample(self.get_column(variable)) + return candidate + + def is_column_unique(self, i: int) -> bool: + """ + Identify whether feature contains only unique values, i.e. it has no duplicated values + Useful to provide a faster way to calculate the probability of a value being selected in a variable + + Returns + ------- + List[int] + """ + if self._unique_columns[i] is None: + self._unique_columns[i] = is_unique(self.get_column(i)) + return self._unique_columns[i] + + def max_value_of_column(self, i: int): + if self._max_value_cache[i] is None: + self._max_value_cache[i] = self.get_column(i).max() + return float(self._max_value_cache[i]) + + def random_splittable_variable(self) -> int: + """ + Choose a variable at random from the set of splittable variables + Returns + ------- + str - a variable name that can be split on + """ + if self.is_at_least_one_splittable_variable(): + return self.choice_sampler.sample(self.splittable_variables()) + else: + raise NoSplittableVariableException() + + def proportion_of_value_in_variable(self, variable: int, value: float) -> float: + if self.is_column_unique(variable): + return 1. / self.n_obsv + else: + return float((self.get_column(variable) == value).mean()) + + def update_mask(self, other: SplitCondition) -> np.ndarray: + if other.operator == gt: + column_mask = self.values[:, other.splitting_variable] > other.splitting_value + elif other.operator == le: + column_mask = self.values[:, other.splitting_variable] <= other.splitting_value + else: + raise TypeError("Operator type not matched, only {} and {} supported".format(gt, le)) + + return self.mask & column_mask + + @property + def variables(self) -> List[int]: + return list(range(self._n_features)) + + @property + def n_obsv(self) -> int: + return self._n_obsv + + @property + def n_splittable_variables(self) -> int: + return len(self.splittable_variables()) + + @property + def values(self) -> np.ndarray: + return self._X + + @property + def mask(self) -> np.ndarray: + return self._mask + + @property + def splittable_variables_cache(self) -> List[Optional[bool]]: + return self._splittable_variables + + @property + def unique_variables_cache(self) -> List[Optional[bool]]: + return self._unique_columns \ No newline at end of file diff --git a/bartpy/data.py b/bartpy/data.py index baf8e7b..e28cc31 100644 --- a/bartpy/data.py +++ b/bartpy/data.py @@ -1,37 +1,12 @@ -from operator import gt, le -from typing import Any, List, Optional, Union +from typing import List, Optional, Union import numpy as np import pandas as pd -from bartpy.errors import NoSplittableVariableException +from bartpy.covariates import CovariateMatrix, DataFrame from bartpy.splitcondition import SplitCondition - - -def is_not_constant(series: np.ndarray) -> bool: - """ - Quickly identify whether a series contains more than 1 distinct value - Parameters - ---------- - series: np.ndarray - The series to assess - - Returns - ------- - bool - True if more than one distinct value found - """ - if len(series) <= 1: - return False - first_value = None - for i in range(1, len(series)): - # if not series.mask[i] and series.data[i] != first_value: - if series[i] != first_value: - if first_value is None: - first_value = series.data[i] - else: - return True - return False +from bartpy.target import Target +from bartpy.samplers.scalar import VariableWidthDiscreteSampler def ensure_numpy_array(X: Union[np.ndarray, pd.DataFrame]) -> np.ndarray: @@ -45,12 +20,12 @@ def ensure_float_array(X: np.ndarray) -> np.ndarray: return X.astype(float) -def format_covariate_matrix(X: Union[np.ndarray, pd.DataFrame]) -> np.ndarray: +def format_covariate_matrix(X: DataFrame) -> np.ndarray: X = ensure_numpy_array(X) return ensure_float_array(X) -def make_bartpy_data(X: Union[np.ndarray, pd.DataFrame], +def make_bartpy_data(X: DataFrame, y: np.ndarray, normalize: bool=True) -> 'Data': X = format_covariate_matrix(X) @@ -58,229 +33,6 @@ def make_bartpy_data(X: Union[np.ndarray, pd.DataFrame], return Data(X, y, normalize=normalize) -class CovariateMatrix(object): - - def __init__(self, - X: np.ndarray, - mask: np.ndarray, - n_obsv: int, - unique_columns: List[int], - splittable_variables: List[int]): - - if type(X) == pd.DataFrame: - X: pd.DataFrame = X - X = X.values - - self._X = X - self._n_obsv = n_obsv - self._n_features = X.shape[1] - self._mask = mask - - # Cache iniialization - if unique_columns is not None: - self._unique_columns = [x if x is True else None for x in unique_columns] - else: - self._unique_columns = [None for _ in range(self._n_features)] - if splittable_variables is not None: - self._splittable_variables = [x if x is False else None for x in splittable_variables] - else: - self._splittable_variables = [None for _ in range(self._n_features)] - self._max_values = [None] * self._n_features - self._X_column_cache = [None] * self._n_features - self._max_value_cache = [None] * self._n_features - self._X_cache = None - - @property - def mask(self) -> np.ndarray: - return self._mask - - @property - def values(self) -> np.ndarray: - return self._X - - def get_column(self, i: int) -> np.ndarray: - if self._X_cache is None: - self._X_cache = self.values[~self.mask, :] - return self._X_cache[:, i] - - def splittable_variables(self) -> List[int]: - """ - List of columns that can be split on, i.e. that have more than one unique value - - Returns - ------- - List[int] - List of column numbers that can be split on - """ - for i in range(0, self._n_features): - if self._splittable_variables[i] is None: - self._splittable_variables[i] = is_not_constant(self.get_column(i)) - - return [i for (i, x) in enumerate(self._splittable_variables) if x is True] - - @property - def n_splittable_variables(self) -> int: - return len(self.splittable_variables()) - - def is_at_least_one_splittable_variable(self) -> bool: - if any(self._splittable_variables): - return True - else: - return len(self.splittable_variables()) > 0 - - def random_splittable_variable(self) -> str: - """ - Choose a variable at random from the set of splittable variables - Returns - ------- - str - a variable name that can be split on - """ - if self.is_at_least_one_splittable_variable(): - return np.random.choice(np.array(self.splittable_variables()), 1)[0] - else: - raise NoSplittableVariableException() - - def is_column_unique(self, i: int) -> bool: - """ - Identify whether feature contains only unique values, i.e. it has no duplicated values - Useful to provide a faster way to calculate the probability of a value being selected in a variable - - Returns - ------- - List[int] - """ - if self._unique_columns[i] is None: - self._unique_columns[i] = len(np.unique(self.get_column(i))) == self._n_obsv - return self._unique_columns[i] - - def max_value_of_column(self, i: int): - if self._max_value_cache[i] is None: - self._max_value_cache[i] = self.get_column(i).max() - return self._max_value_cache[i] - - def random_splittable_value(self, variable: int) -> Any: - """ - Return a random value of a variable - Useful for choosing a variable to split on - - Parameters - ---------- - variable - str - Name of the variable to split on - - Returns - ------- - Any - - Notes - ----- - - Won't create degenerate splits, all splits will have at least one row on both sides of the split - """ - if variable not in self.splittable_variables(): - raise NoSplittableVariableException() - max_value = self.max_value_of_column(variable) - candidate = np.random.choice(self.get_column(variable)) - while candidate == max_value: - candidate = np.random.choice(self.get_column(variable)) - return candidate - - def proportion_of_value_in_variable(self, variable: int, value: float) -> float: - if self.is_column_unique(variable): - return 1. / self.n_obsv - else: - return float(np.mean(self.get_column(variable) == value)) - - def update_mask(self, other: SplitCondition) -> np.ndarray: - if other.operator == gt: - column_mask = self.values[:, other.splitting_variable] <= other.splitting_value - elif other.operator == le: - column_mask = self.values[:, other.splitting_variable] > other.splitting_value - else: - raise TypeError("Operator type not matched, only {} and {} supported".format(gt, le)) - - return self.mask | column_mask - - @property - def variables(self) -> List[int]: - return list(range(self._n_features)) - - @property - def n_obsv(self) -> int: - return self._n_obsv - - -class Target(object): - - def __init__(self, y, mask, n_obsv, normalize, y_sum=None): - - if normalize: - self.original_y_min, self.original_y_max = y.min(), y.max() - self._y = self.normalize_y(y) - else: - self._y = y - - self._mask = mask - self._inverse_mask_int = (~self._mask).astype(int) - self._n_obsv = n_obsv - - if y_sum is None: - self.y_sum_cache_up_to_date = False - self._summed_y = None - else: - self.y_sum_cache_up_to_date = True - self._summed_y = y_sum - - @staticmethod - def normalize_y(y: np.ndarray) -> np.ndarray: - """ - Normalize y into the range (-0.5, 0.5) - Useful for allowing the leaf parameter prior to be 0, and to standardize the sigma prior - - Parameters - ---------- - y - np.ndarray - - Returns - ------- - np.ndarray - - Examples - -------- - >>> Data.normalize_y([1, 2, 3]) - array([-0.5, 0. , 0.5]) - """ - y_min, y_max = np.min(y), np.max(y) - return -0.5 + ((y - y_min) / (y_max - y_min)) - - def unnormalize_y(self, y: np.ndarray) -> np.ndarray: - distance_from_min = y - (-0.5) - total_distance = (self.original_y_max - self.original_y_min) - return self.original_y_min + (distance_from_min * total_distance) - - @property - def unnormalized_y(self) -> np.ndarray: - return self.unnormalize_y(self.values) - - @property - def normalizing_scale(self) -> float: - return self.original_y_max - self.original_y_min - - def summed_y(self) -> float: - if self.y_sum_cache_up_to_date: - return self._summed_y - else: - self._summed_y = np.sum(self._y * self._inverse_mask_int) - self.y_sum_cache_up_to_date = True - return self._summed_y - - def update_y(self, y) -> None: - self._y = y - self.y_sum_cache_up_to_date = False - - @property - def values(self): - return self._y - class Data(object): """ Encapsulates the data within a split of feature space. @@ -304,22 +56,25 @@ def __init__(self, y: np.ndarray, mask: Optional[np.ndarray]=None, normalize: bool=False, - unique_columns: List[int]=None, + unique_columns: List[Optional[bool]]=None, splittable_variables: Optional[List[Optional[bool]]]=None, - y_sum: float=None, - n_obsv: int=None): + choice_sampler: VariableWidthDiscreteSampler=None): if mask is None: - mask = np.zeros_like(y).astype(bool) - self._mask: np.ndarray = mask + mask = np.ones_like(y).astype(bool) + + if choice_sampler is None: + choice_sampler = VariableWidthDiscreteSampler() + self.choice_sampler = choice_sampler + + self._mask: DataFrame = mask - if n_obsv is None: - n_obsv = (~self.mask).astype(int).sum() + n_obsv = (self.mask).astype(int).sum() self._n_obsv = n_obsv - self._X = CovariateMatrix(X, mask, n_obsv, unique_columns, splittable_variables) - self._y = Target(y, mask, n_obsv, normalize, y_sum) + self._X = CovariateMatrix(X, mask, n_obsv, unique_columns=unique_columns, splittable_variables=splittable_variables, choice_sampler=choice_sampler) + self._y = Target(y, mask, n_obsv, normalize) @property def y(self) -> Target: @@ -343,7 +98,6 @@ def __add__(self, other: SplitCondition) -> 'Data': self.y.values, updated_mask, normalize=False, - unique_columns=self._X._unique_columns, - splittable_variables=self._X._splittable_variables, - y_sum=other.carry_y_sum, - n_obsv=other.carry_n_obsv) + unique_columns=self._X.unique_variables_cache, + splittable_variables=self._X.splittable_variables_cache, + choice_sampler=self.choice_sampler) diff --git a/bartpy/initializers/sklearntreeinitializer.py b/bartpy/initializers/sklearntreeinitializer.py index 3455065..03d455a 100644 --- a/bartpy/initializers/sklearntreeinitializer.py +++ b/bartpy/initializers/sklearntreeinitializer.py @@ -36,7 +36,7 @@ def initialize_tree(self, } clf = GradientBoostingRegressor(**params) - fit = clf.fit(tree.nodes[0].data.X.data, tree.nodes[0].data.y.data) + fit = clf.fit(tree.nodes[0].data.X.values, tree.nodes[0].data.y.values) sklearn_tree = fit.estimators_[0][0].tree_ map_sklearn_tree_into_bartpy(tree, sklearn_tree) diff --git a/bartpy/model.py b/bartpy/model.py index b1f1742..ffa1f26 100644 --- a/bartpy/model.py +++ b/bartpy/model.py @@ -15,14 +15,14 @@ class Model: def __init__(self, - data: Optional[Data], + data: Data, sigma: Sigma, trees: Optional[List[Tree]]=None, n_trees: int=50, alpha: float=0.95, beta: float=2., k: int=2., - initializer: Initializer=SklearnTreeInitializer()): + initializer: Optional[Initializer]=None): self.data = deepcopy(data) self.alpha = float(alpha) @@ -41,10 +41,12 @@ def __init__(self, self.n_trees = len(trees) self._trees = trees + self._sigma_m = 0.5 / (self.k * np.power(self.n_trees, 0.5)) + def initialize_trees(self) -> List[Tree]: trees = [Tree([LeafNode(Split(deepcopy(self.data)))]) for _ in range(self.n_trees)] for tree in trees: - tree.update_y(tree.update_y(self.data.y.values / self.n_trees)) + tree.update_y(self.data.y.values / self.n_trees) return trees def residuals(self) -> np.ndarray: @@ -79,7 +81,7 @@ def refreshed_trees(self) -> Generator[Tree, None, None]: @property def sigma_m(self) -> float: - return 0.5 / (self.k * np.power(self.n_trees, 0.5)) + return self._sigma_m @property def sigma(self) -> Sigma: diff --git a/bartpy/plotting.py b/bartpy/plotting.py deleted file mode 100644 index e8dc2ee..0000000 --- a/bartpy/plotting.py +++ /dev/null @@ -1,14 +0,0 @@ -from matplotlib import pyplot as plt - -from bartpy.sklearnmodel import SklearnModel - - -def plot_residuals(model: SklearnModel): - plt.plot(model.data.unnormalized_y - model.predict()) - plt.show() - - -def plot_modelled_against_actual(model: SklearnModel): - plt.plot(model.data.unnormalized_y) - plt.plot(model.predict()) - plt.show() diff --git a/bartpy/samplers/oblivioustrees/proposer.py b/bartpy/samplers/oblivioustrees/proposer.py index 4ceeb05..1a6a9ff 100644 --- a/bartpy/samplers/oblivioustrees/proposer.py +++ b/bartpy/samplers/oblivioustrees/proposer.py @@ -61,11 +61,5 @@ def sample_split_node(node: LeafNode) -> DecisionNode: Split a leaf node into a decision node with two leaf children The variable and value to split on is determined by sampling from their respective distributions """ - if node.is_splittable(): - conditions = sample_split_condition(node) - return split_node(node, conditions) - else: - return DecisionNode(node.split, - LeafNode(node.split, depth=node.depth + 1), - LeafNode(node.split, depth=node.depth + 1), - depth=node.depth) \ No newline at end of file + conditions = sample_split_condition(node) + return split_node(node, conditions) \ No newline at end of file diff --git a/bartpy/samplers/oblivioustrees/treemutation.py b/bartpy/samplers/oblivioustrees/treemutation.py index 292bfc0..82db689 100644 --- a/bartpy/samplers/oblivioustrees/treemutation.py +++ b/bartpy/samplers/oblivioustrees/treemutation.py @@ -53,8 +53,8 @@ def step(self, model: Model, tree: Tree) -> Optional[List[TreeMutation]]: return mutations -def get_tree_sampler(p_grow: float, - p_prune: float): +def get_tree_sampler(p_grow: float=0.5, + p_prune: float=0.5): proposer = UniformMutationProposer(p_grow, p_prune) likihood = UniformTreeMutationLikihoodRatio([p_grow, p_prune]) return UnconstrainedTreeMutationSampler(proposer, likihood) diff --git a/bartpy/samplers/scalar.py b/bartpy/samplers/scalar.py index 4694e31..1b5c485 100644 --- a/bartpy/samplers/scalar.py +++ b/bartpy/samplers/scalar.py @@ -3,7 +3,7 @@ import numpy as np -class NormalScalarSampler(): +class NormalScalarSampler: def __init__(self, cache_size: int=1000): @@ -19,7 +19,7 @@ def refresh_cache(self): self._cache = list(np.random.normal(size=self._cache_size)) -class UniformScalarSampler(): +class UniformScalarSampler: def __init__(self, cache_size: int=1000): @@ -35,7 +35,7 @@ def refresh_cache(self): self._cache = list(np.random.uniform(size=self._cache_size)) -class DiscreteSampler(): +class DiscreteSampler: def __init__(self, values: List[Any], @@ -55,3 +55,25 @@ def sample(self): def refresh_cache(self): self._cache = list(np.random.choice(self._values, p=self._probas, size=self._cache_size)) + + +class VariableWidthDiscreteSampler: + """ + A sampler for when you want to sample choices from a set whose width you don't know in advance. + e.g. choosing a random splittable column + """ + + def __init__(self, + cache_size: int=10000): + self._cache_size = cache_size + self._cache = [] + + def sample(self, options): + if len(self._cache) == 0: + self.refresh_cache() + value = self._cache.pop() + index = int(value * len(options)) + return options[index] + + def refresh_cache(self): + self._cache = list(np.random.uniform(size=self._cache_size)) diff --git a/bartpy/samplers/sigma.py b/bartpy/samplers/sigma.py index 13c67e7..9f3a451 100644 --- a/bartpy/samplers/sigma.py +++ b/bartpy/samplers/sigma.py @@ -15,6 +15,6 @@ def step(self, model: Model, sigma: Sigma) -> float: @staticmethod def sample(model: Model, sigma: Sigma) -> float: posterior_alpha = sigma.alpha + (model.data.X.n_obsv / 2.) - posterior_beta = sigma.beta + (0.5 * (np.sum(np.square(model.residuals())))) + posterior_beta = sigma.beta + (0.5 * np.square(model.residuals()).sum()) draw = np.power(np.random.gamma(posterior_alpha, 1./posterior_beta), -0.5) return draw diff --git a/bartpy/samplers/unconstrainedtree/proposer.py b/bartpy/samplers/unconstrainedtree/proposer.py index c84e826..958bb67 100644 --- a/bartpy/samplers/unconstrainedtree/proposer.py +++ b/bartpy/samplers/unconstrainedtree/proposer.py @@ -1,17 +1,18 @@ from operator import le, gt from typing import Callable, List, Mapping, Optional, Tuple -import numpy as np - from bartpy.errors import NoSplittableVariableException, NoPrunableNodeException from bartpy.mutation import TreeMutation, GrowMutation, PruneMutation from bartpy.node import LeafNode, DecisionNode, split_node -from bartpy.samplers.scalar import DiscreteSampler +from bartpy.samplers.scalar import DiscreteSampler, VariableWidthDiscreteSampler from bartpy.samplers.treemutation import TreeMutationProposer from bartpy.split import SplitCondition from bartpy.tree import Tree +CHOICE_SAMPLER = VariableWidthDiscreteSampler() + + def uniformly_sample_grow_mutation(tree: Tree) -> TreeMutation: node = random_splittable_leaf_node(tree) updated_node = sample_split_node(node) @@ -38,7 +39,7 @@ def __init__(self, self.methods = list(self.prob_method_lookup.keys()) self.method_sampler = DiscreteSampler(list(self.prob_method_lookup.keys()), list(self.prob_method_lookup.values()), - cache_size=1000) + cache_size=100000) def propose(self, tree: Tree) -> TreeMutation: method = self.method_sampler.sample() @@ -59,7 +60,7 @@ def random_splittable_leaf_node(tree: Tree) -> LeafNode: if len(splittable_nodes) == 0: raise NoSplittableVariableException() else: - return np.random.choice(splittable_nodes) + return CHOICE_SAMPLER.sample(splittable_nodes) def random_prunable_decision_node(tree: Tree) -> DecisionNode: @@ -70,7 +71,7 @@ def random_prunable_decision_node(tree: Tree) -> DecisionNode: leaf_parents = tree.prunable_decision_nodes if len(leaf_parents) == 0: raise NoPrunableNodeException() - return np.random.choice(leaf_parents) + return CHOICE_SAMPLER.sample(leaf_parents) def sample_split_condition(node: LeafNode) -> Optional[Tuple[SplitCondition, SplitCondition]]: @@ -83,7 +84,7 @@ def sample_split_condition(node: LeafNode) -> Optional[Tuple[SplitCondition, Spl Returns None if there isn't a possible non-degenerate split """ - split_variable = np.random.choice(list(node.split.data.X.splittable_variables())) + split_variable = node.split.data.X.random_splittable_variable() split_value = node.data.X.random_splittable_value(split_variable) if split_value is None: return None diff --git a/bartpy/sklearnmodel.py b/bartpy/sklearnmodel.py index 7e92b1a..91f5639 100644 --- a/bartpy/sklearnmodel.py +++ b/bartpy/sklearnmodel.py @@ -6,9 +6,8 @@ from joblib import Parallel, delayed from sklearn.base import RegressorMixin, BaseEstimator -from bartpy.data import Data +from bartpy.data import Data, DataFrame from bartpy.initializers.initializer import Initializer -from bartpy.initializers.sklearntreeinitializer import SklearnTreeInitializer from bartpy.model import Model from bartpy.samplers.leafnode import LeafNodeSampler from bartpy.samplers.modelsampler import ModelSampler, Chain @@ -158,7 +157,12 @@ def _convert_covariates_to_data(X: np.ndarray, y: np.ndarray) -> Data: if type(X) == pd.DataFrame: X: pd.DataFrame = X X = X.values - return Data(deepcopy(X), deepcopy(y), normalize=True) + + unique_columns = [ + len(np.unique(X[:, i])) == X.shape[0] for i in range(X.shape[1]) + ] + + return Data(deepcopy(X), deepcopy(y), unique_columns=unique_columns, normalize=True) def _construct_model(self, X: np.ndarray, y: np.ndarray) -> Model: if len(X) == 0 or X.shape[1] == 0: @@ -205,7 +209,7 @@ def f_chains(self) -> List[Callable[[], Chain]]: """ return [delayed_run_chain() for _ in range(self.n_chains)] - def predict(self, X: np.ndarray=None) -> np.ndarray: + def predict(self, X: Optional[DataFrame]=None) -> np.ndarray: """ Predict the target corresponding to the provided covariate matrix If X is None, will predict based on training covariates @@ -214,7 +218,7 @@ def predict(self, X: np.ndarray=None) -> np.ndarray: Parameters ---------- - X: pd.DataFrame + X: DataFrame covariates to predict from Returns diff --git a/bartpy/split.py b/bartpy/split.py index bc46c2e..c6d1c4d 100644 --- a/bartpy/split.py +++ b/bartpy/split.py @@ -32,7 +32,7 @@ def combined_condition(self): def condition(self, X: np.ndarray=None) -> np.array: if X is None: - return ~self._data.mask + return self._data.mask else: return self.out_of_sample_condition(X) diff --git a/bartpy/splitcondition.py b/bartpy/splitcondition.py index 6936c6c..bcdc002 100644 --- a/bartpy/splitcondition.py +++ b/bartpy/splitcondition.py @@ -1,5 +1,5 @@ from operator import le, gt -from typing import Callable, List, Optional, Union +from typing import Callable, List import numpy as np @@ -19,17 +19,12 @@ def __init__(self, splitting_variable: int, splitting_value: float, operator: Callable[[float, float], bool], - condition=None, - carry_y_sum=None, - carry_n_obsv=None): + condition=None): self.splitting_variable = splitting_variable self.splitting_value = splitting_value self._condition = condition self.operator = operator - self.carry_y_sum = carry_y_sum - self.carry_n_obsv = carry_n_obsv - def __str__(self): return str(self.splitting_variable) + ": " + str(self.splitting_value) @@ -57,10 +52,9 @@ def add_condition(self, split_condition: SplitCondition) -> 'CombinedVariableCon class CombinedCondition(object): def __init__(self, variables: List[int], conditions: List[SplitCondition]): - self.variables = {v: CombinedVariableCondition(v, -np.inf, np.inf) for v in variables} + self.variables = variables + self._variable_conditions = None self.conditions = conditions - for condition in conditions: - self.variables[condition.splitting_variable] = self.variables[condition.splitting_variable].add_condition(condition) if len(conditions) > 0: self.splitting_variable = conditions[-1].splitting_variable else: @@ -68,15 +62,24 @@ def __init__(self, variables: List[int], conditions: List[SplitCondition]): def condition(self, X: np.ndarray) -> np.ndarray: c = np.array([True] * len(X)) - for variable in self.variables.keys(): - c = c & (X[:, variable] > self.variables[variable].min_value) & (X[:, variable] <= self.variables[variable].max_value) + for variable in self.variables: + c = c & (X[:, variable] > self.variable_conditions[variable].min_value) & (X[:, variable] <= self.variable_conditions[variable].max_value) return c def __add__(self, other: SplitCondition): - return CombinedCondition(list(self.variables.keys()), self.conditions + [other]) + return CombinedCondition(list(self.variables), self.conditions + [other]) def most_recent_split_condition(self): if len(self.conditions) == 0: return None else: return self.conditions[-1] + + @property + def variable_conditions(self): + if self._variable_conditions is None: + self._variable_conditions = {v: CombinedVariableCondition(v, -np.inf, np.inf) for v in self.variables} + for condition in self.conditions: + self._variable_conditions[condition.splitting_variable] = self._variable_conditions[condition.splitting_variable].add_condition( + condition) + return self._variable_conditions \ No newline at end of file diff --git a/bartpy/target.py b/bartpy/target.py new file mode 100644 index 0000000..f091262 --- /dev/null +++ b/bartpy/target.py @@ -0,0 +1,77 @@ +import numpy as np + + +class Target(object): + + def __init__(self, y, mask, n_obsv, normalize): + + if normalize: + self.original_y_min, self.original_y_max = y.min(), y.max() + self._y = self.normalize_y(y) + else: + self._y = y + + self._mask = mask + self._mask_int = None + + self._n_obsv = n_obsv + + self.y_sum_cache_up_to_date = False + self._summed_y = None + + @staticmethod + def normalize_y(y: np.ndarray) -> np.ndarray: + """ + Normalize y into the range (-0.5, 0.5) + Useful for allowing the leaf parameter prior to be 0, and to standardize the sigma prior + + Parameters + ---------- + y - np.ndarray + + Returns + ------- + np.ndarray + + Examples + -------- + >>> Data.normalize_y([1, 2, 3]) + array([-0.5, 0. , 0.5]) + """ + y_min, y_max = y.min(), y.max() + return -0.5 + ((y - y_min) / (y_max - y_min)) + + def unnormalize_y(self, y: np.ndarray) -> np.ndarray: + distance_from_min = y - (-0.5) + total_distance = (self.original_y_max - self.original_y_min) + return self.original_y_min + (distance_from_min * total_distance) + + @property + def unnormalized_y(self) -> np.ndarray: + return self.unnormalize_y(self.values) + + @property + def normalizing_scale(self) -> float: + return self.original_y_max - self.original_y_min + + def summed_y(self) -> float: + if self.y_sum_cache_up_to_date: + return self._summed_y + else: + self._summed_y = float((self._y * self.mask_int).sum()) + self.y_sum_cache_up_to_date = True + return self._summed_y + + def update_y(self, y) -> None: + self._y = y + self.y_sum_cache_up_to_date = False + + @property + def values(self): + return self._y + + @property + def mask_int(self): + if self._mask_int is None: + self._mask_int = self._mask.astype(int) + return self._mask_int \ No newline at end of file diff --git a/bartpy/tree.py b/bartpy/tree.py index fb6b58f..b592bb0 100644 --- a/bartpy/tree.py +++ b/bartpy/tree.py @@ -21,10 +21,12 @@ class Tree: All nodes contained in the tree, i.e. decision and leaf nodes """ - def __init__(self, nodes: List[TreeNode]): + def __init__(self, nodes: List[TreeNode], n_obsv=None): self._nodes = nodes self.cache_up_to_date = False self._prediction = None + if n_obsv is None: + self.n_obsv = nodes[0].data.X.n_obsv @property def nodes(self) -> List[TreeNode]: @@ -83,10 +85,10 @@ def predict(self, X: np.ndarray=None) -> np.ndarray: if self.cache_up_to_date: return self._prediction + + self._prediction = np.zeros(self.n_obsv) for leaf in self.leaf_nodes: - if self._prediction is None: - self._prediction = np.zeros(self.nodes[0].data.X.n_obsv) - self._prediction[leaf.split.condition()] = leaf.predict() + self._prediction += leaf.data.y.mask_int * leaf.predict() self.cache_up_to_date = True return self._prediction @@ -171,4 +173,4 @@ def deep_copy_tree(tree: Tree): Tree Version of the tree optimized to be low memory """ - return Tree([deep_copy_node(x) for x in tree.nodes]) + return Tree([deep_copy_node(x) for x in tree.nodes], n_obsv=tree.n_obsv) diff --git a/diagnostics/performance/Comparison of model with sin waves.ipynb b/diagnostics/performance/Comparison of model with sin waves.ipynb new file mode 100644 index 0000000..6b4c473 --- /dev/null +++ b/diagnostics/performance/Comparison of model with sin waves.ipynb @@ -0,0 +1,1047 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model comparisons\n", + "\n", + "In this notebook, we'll take BartPy through its paces using increasingly complex sin wave models. We'll compare how it performs to two similar models: OLS and catboost.\n", + "\n", + "For the purposes of this exercise, I'm testing out of the box performance. This makes sense, as part of the value prop of BartPy is it's ability to work well without parameter tuning, but it's possible that the scores of all of the models could be improved with parameter tuning" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "import catboost \n", + "from catboost import Pool\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.metrics import r2_score\n", + "from sklearn.model_selection import KFold\n", + "from copy import deepcopy\n", + "\n", + "from bartpy.sklearnmodel import SklearnModel\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set up models" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def fit_catboost(X_train, y_train, X_test, y_test):\n", + " eval_cutoff = len(X_train) // 3\n", + " eval_X, eval_y, train_X, train_y = X_train[:eval_cutoff, :], y_train[:eval_cutoff], X_train[eval_cutoff:, :], y_train[eval_cutoff:]\n", + " catboost_model = catboost.CatBoostRegressor()\n", + " catboost_model.fit(Pool(train_X, train_y), eval_set = Pool(eval_X, eval_y), use_best_model=True, verbose=300)\n", + " pred = catboost_model.predict(X_test)\n", + " score = r2_score(y_test, pred)\n", + " return catboost_model, pred, score\n", + "\n", + "def fit_bartpy(X_train, y_train, X_test, y_test):\n", + " model = SklearnModel(n_samples=1000, \n", + " n_burn=200, \n", + " n_trees=200, \n", + " n_chains=4,\n", + " n_jobs=-1,\n", + " store_in_sample_predictions=False)\n", + " model.fit(X_train, y_train)\n", + " pred = model.predict(X_test)\n", + " score = model.score(X_test, y_test)\n", + " return model, pred, score\n", + "\n", + "def fit_linear_model(X_train, y_train, X_test, y_test):\n", + " rebased_x = np.sin(X_train[:, 0]).reshape(-1, 1)\n", + " linear_model = LinearRegression()\n", + " linear_model.fit(rebased_x, y_train)\n", + " pred = linear_model.predict(np.sin(X_test[:, 0]).reshape(-1, 1))\n", + " score = linear_model.score(np.sin(X_test[:, 0]).reshape(-1, 1), y_test)\n", + " return linear_model, pred, score\n", + "\n", + "kf = KFold(2)\n", + "\n", + "def compare_models(X, y, models_funcs = [fit_bartpy, fit_catboost, fit_linear_model]):\n", + " scores, predictions, trained_models, train_splits, test_splits = [], [], [], [], []\n", + "\n", + " for train_index, test_index in kf.split(X):\n", + " trained_models.append([]) \n", + " scores.append([])\n", + " predictions.append([])\n", + " train_splits.append(train_index)\n", + " test_splits.append(test_index)\n", + "\n", + " for f in models_funcs:\n", + " model, pred, score = f(X[train_index, :], y[train_index], X[test_index, :], y[test_index])\n", + " trained_models[-1].append(deepcopy(model))\n", + " predictions[-1].append(pred)\n", + " scores[-1].append(score)\n", + " return scores, predictions, trained_models, train_splits, test_splits" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_prediction_against_actual(y, predictions, test_splits):\n", + " for p, test_index in zip(predictions, test_splits):\n", + " for m in p:\n", + " plt.scatter(y[test_index], m)\n", + " plt.title(\"Preicted V Actual Per Model\")\n", + " plt.xlabel(\"True Target\")\n", + " plt.ylabel(\"Predicted Target\")\n", + "\n", + "def plot_covariate_against_prediction(X, predictions, test_splits, split_index, feature_index):\n", + " test_index = test_splits[split_index]\n", + " plt.scatter(X[test_index, feature_index],predictions[split_index][1], label=\"catboost\")\n", + " plt.scatter(X[test_index, feature_index],predictions[split_index][2], label=\"OLS\")\n", + " plt.scatter(X[test_index, feature_index],predictions[split_index][0], label=\"bartpy\")\n", + " plt.ylabel(\"Prediction\")\n", + " plt.xlabel(\"Covariate\")\n", + " plt.title(\"Prediction by model by value of X\")\n", + " plt.legend(loc=\"best\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## One dimensional, single wave" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'X v y')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(0, 5, 3000)\n", + "X = pd.DataFrame(x).sample(frac=1.0).values\n", + "y = np.random.normal(0, 0.1, size=3000) + np.sin(X[:, 0])\n", + "plt.scatter(X[:, 0], y)\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.title(\"X v y\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate set to 0.046077\n", + "0:\tlearn: 0.6904949\ttest: 0.6880123\tbest: 0.6880123 (0)\ttotal: 54.2ms\tremaining: 54.1s\n", + "300:\tlearn: 0.0966597\ttest: 0.0981311\tbest: 0.0974514 (176)\ttotal: 251ms\tremaining: 583ms\n", + "600:\tlearn: 0.0931206\ttest: 0.1002908\tbest: 0.0974514 (176)\ttotal: 445ms\tremaining: 295ms\n", + "900:\tlearn: 0.0911902\ttest: 0.1023228\tbest: 0.0974514 (176)\ttotal: 648ms\tremaining: 71.2ms\n", + "999:\tlearn: 0.0907995\ttest: 0.1028430\tbest: 0.0974514 (176)\ttotal: 712ms\tremaining: 0us\n", + "\n", + "bestTest = 0.09745144836\n", + "bestIteration = 176\n", + "\n", + "Shrink model to first 177 iterations.\n", + "Learning rate set to 0.046077\n", + "0:\tlearn: 0.6885020\ttest: 0.6942689\tbest: 0.6942689 (0)\ttotal: 1.35ms\tremaining: 1.35s\n", + "300:\tlearn: 0.0950076\ttest: 0.0987536\tbest: 0.0979791 (166)\ttotal: 194ms\tremaining: 451ms\n", + "600:\tlearn: 0.0913979\ttest: 0.1007699\tbest: 0.0979791 (166)\ttotal: 377ms\tremaining: 250ms\n", + "900:\tlearn: 0.0893979\ttest: 0.1023758\tbest: 0.0979791 (166)\ttotal: 561ms\tremaining: 61.6ms\n", + "999:\tlearn: 0.0888951\ttest: 0.1028475\tbest: 0.0979791 (166)\ttotal: 621ms\tremaining: 0us\n", + "\n", + "bestTest = 0.097979115\n", + "bestIteration = 166\n", + "\n", + "Shrink model to first 167 iterations.\n" + ] + } + ], + "source": [ + "scores, predictions, models, train_splits, test_splits = compare_models(X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**As we might expect, all three models are capable of capturing such a simple function. There's very little difference between the scores or predictions of the models.**" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0.9806128889621087, 0.9808769882368441, 0.9812104330040549],\n", + " [0.9804238592192183, 0.9802956276780866, 0.9809006163120686]]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_prediction_against_actual(y, predictions, test_splits)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_covariate_against_prediction(X, predictions, test_splits, 1, 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Single dimension - multiple waves\n", + "\n", + "** To extend our original model, let's add a high frequency cosine wave in our single dimension. This will make the predicted function change faster and at varying rates across x **" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'X v y')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(0, 5, 3000)\n", + "X = pd.DataFrame(x).sample(frac=1.0).values\n", + "y = np.random.normal(0, 0.1, size=3000) + np.sin(X[:, 0]) + np.cos(5 * X[:, 0])\n", + "plt.scatter(X[:, 0], y)\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.title(\"X v y\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate set to 0.046077\n", + "0:\tlearn: 0.9934074\ttest: 0.9947985\tbest: 0.9947985 (0)\ttotal: 1.62ms\tremaining: 1.62s\n", + "300:\tlearn: 0.1006679\ttest: 0.1150237\tbest: 0.1150237 (300)\ttotal: 203ms\tremaining: 471ms\n", + "600:\tlearn: 0.0945074\ttest: 0.1140979\tbest: 0.1139724 (492)\ttotal: 393ms\tremaining: 261ms\n", + "900:\tlearn: 0.0922886\ttest: 0.1149004\tbest: 0.1139724 (492)\ttotal: 588ms\tremaining: 64.6ms\n", + "999:\tlearn: 0.0919235\ttest: 0.1150951\tbest: 0.1139724 (492)\ttotal: 655ms\tremaining: 0us\n", + "\n", + "bestTest = 0.1139724327\n", + "bestIteration = 492\n", + "\n", + "Shrink model to first 493 iterations.\n", + "Learning rate set to 0.046077\n", + "0:\tlearn: 0.9647855\ttest: 0.9523732\tbest: 0.9523732 (0)\ttotal: 1.35ms\tremaining: 1.35s\n", + "300:\tlearn: 0.1045856\ttest: 0.1114030\tbest: 0.1114030 (300)\ttotal: 202ms\tremaining: 469ms\n", + "600:\tlearn: 0.0982732\ttest: 0.1090977\tbest: 0.1089771 (539)\ttotal: 398ms\tremaining: 264ms\n", + "900:\tlearn: 0.0959376\ttest: 0.1090624\tbest: 0.1088563 (806)\ttotal: 582ms\tremaining: 64ms\n", + "999:\tlearn: 0.0954672\ttest: 0.1091444\tbest: 0.1088563 (806)\ttotal: 648ms\tremaining: 0us\n", + "\n", + "bestTest = 0.1088563316\n", + "bestIteration = 806\n", + "\n", + "Shrink model to first 807 iterations.\n" + ] + } + ], + "source": [ + "scores, predictions, models, train_splits, test_splits = compare_models(X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "** Catboost and BartPy capture this faster moving sin wave pretty nicely, and come up with very similar predictions. The linear model pretty much treats the cos wave as noise, and fits a curve close to the original one **" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_prediction_against_actual(y, predictions, test_splits)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOydeXhV1dW433WTkECYZRYUiAgOQbBRotRKnahiNVoBrVocGn/Wz4r10xYLFqygtLRaW7XWqBUV24CtEU0/qULROgQbBUEqoAFlCqOEIYSM6/fHOTfcJPecOw9J9vs850myz75775x771lnr1FUFYPBYDAYnPAkegEGg8FgSG6MoDAYDAaDK0ZQGAwGg8EVIygMBoPB4IoRFAaDwWBwxQgKg8FgMLhiBIUhbERksIioiKTaf/+fiEwJY5zjROSQiKTEYI0qIidEe9xo0vw6Buh7g4i8G+k4sUREvhSRCxIw72wR2SMiO+I9d1vHCIo2jv2lrbJvxDtF5DkR6RyLuVT1YlWdH+SaGm8kqrpZVTuran0s1mVo+4jIccD/Aieraj8/578rIjtEpKdP2+Uisk1EusVzra0RIyjaB99V1c7A6UAOMKN5B7EwnwdDa+U4YK+q7vJ3UlVfA5YBjwCISHfgj8CPVHV/3FbZSjE3hnaEqm4D/g84FUBElovIHBF5DzgMDBWRbiLyjIiU209bs70qIRFJEZHf2Nv7jcAE3/Ht8X7o83e+iHwmIgdF5L8icrqIvID1pX7N3uX81I8Ka4CILBaRr0XkCxHJ9xlzlogsFJHn7XHXikhOgH/9EhHZaK97noh4RKSDPX62z9h9ROSwiPRuPoCt8nlPRB4RkQp7vLPt9i0isstX7WZfx+dFZLeIfCUiM7yCOIjr6PgeBMlNIrLdfv3d9pj97P/tGJ95TrfXl9Zs/gH2LtT36Xu0vd40EckSkWUistduW2DfeFtg72Bn+/w9TkS2Npvrb/Y6NonIHU7/lNM1tXenbwID7M/Ucw5D3AFcLCLjsQTG26q62OU6GmyMoGhHiMgg4BJgpU/z9cAtQBfgK+A5oA44ARgNXAR4b/75wKV2ew5wlctcE4FZwA+ArsBlWE981wObsXc5qvprPy//K7AVGGDP8aCInOdz/jK7T3dgMfBYgH/9Cnu9pwOXAzepao09xnU+/a4BlqrqbodxxgCrgWOAl+zXn4F1ra4DHpOjar0/AN2AocC59nW40T4X6Do+h/N7EAzfBobZr/uZiFygqjuA5cAkn37XA39V1VrfF6vqduAD4Hs+zd8HXrb7CvAQ1vtzEjAI670OCVtwvgZ8AhwLnA/cad/I/eH3mqrqW8DFwHb7M3WDvxer6h5gKrAA6/o7CiVDM1TVHG34AL4EDgEVWILgCaCjfW458Eufvn2Bau95u+0a4F/278uAW33OXQQokOoz3g/t35cAU13WdIHP34O942DddOqBLj7nHwKes3+fBbzlc+5koMrl/1fgOz5/34YlDMC68W8GxP67FJjkMM4NwOc+f2fbY/f1adsLjAJSgBosfbn33P8Dlge6jkG8BzcA7zqs0XsdR/i0/Rp4xv59MvCe/XsKsAM402GsHwLL7N8F2AJ8y6FvHrDS3/uLJfRm+5wbB2z1vf7NxroX+LOfOQJd08ZxA3wfhgC1wIJEfzdb05FQ7whD3MhT66nLH1t8fj8eSAPKRcTb5vHpM6BZ/69c5hwElIW+VAYAX6vqwWbz+KqXfL1aDgMZIpKqqnUOYzZf8wAAVV0hIoeBcSJSjvUE76aK2Onze5U9RvO2zkAvrOvoe32+wnpqBvfrGOg9CIbmY3vVa68CT4rIEGA4sF9VP3QY42/AH0SkP3Ai0AD8G0BE+gKPAudg7UQ9wL4Q1ufleCx1UYVPW4p3nmYEuqbB8hTwPHCliJylqh+E+Pp2iREUBt/0wVuwnmZ7Odx0y7EEgJfjXMbdAmQFMWdztgM9RaSLj7A4Dtjm8ppADALW+oy13efcfCy10Q4s1cqRCObxsgfrqfV44L8+83r/B7frGOg9CIZBwDqfsbcDqOoREVmI9f+OAF5wGkBV94nIP7F2ISdhqai879uDWO9htqp+LSJ5OKv/KoFOPn/7eiRtATap6rAg/qdA1zQgInIz1rW5FGv3+LSIjFZLDWlwwdgoDI2oajnwT+C3ItLVNhRmici5dpeFwB0iMlBEegDTXIZ7GrhbRL4hFieIyPH2uZ1YemZ/a9gCvA88JCIZIjISuBl4MYJ/7R4R6WHbaKYChT7nXsSyYVyH9aQZMWq5+S4E5ohIF/v/vouj/4PjdQziPQiG+0Skk4icgmUX8f1/n8dSX12Gi6CweQnLDnCV/buXLljqzP0icixwj8sYq7CcCXqKSD/gTp9zHwIHReRnItLRNvKfKiJnNB8kiGvqiogMAOYB+apaDTyJpSqcHszr2ztGUBia8wOgA9ZT2z7gZaC/fa4Ay/bwCfAx8HenQVR1ETAH6wZzECgCvF40DwEzbO+hu/28/Bosfft24BVgpovqLBheBT7CumkVA8/4rHOL/b8o/lUe4fJjrKfpjcC7WNfhWftcoOvo9h4Ew9vAF8BS4Deq+k/vCVV9D0uN9LGquqkOwVLDDQN2qOonPu33YzkG7Me6no6fAyxh9AmW3eKf+Agt++Z/KZZdZxPWruFpLIO1P9yuaSCewNoV/dueW7GcCu60BarBBTm6mzQY2ici8iyWx0yL+JK2iIgsA15S1acTvRZD68AICkO7RkQGY+00RqvqpsSuJvbYap03gUHNHAYMBkeM6snQbhGRB4BPgXntREjMB94C7jRCwhAKZkdhMBgMBlfMjsJgMBgMrrTJOIpevXrp4MGDE70Mg8FgaDV89NFHe1S1RZ4zaKOCYvDgwZSWliZ6GQaDwdBqEBFHd2mjejIYDAaDK0ZQGAwGg8EVIygMBoPB4EqbtFEYDIb2QW1tLVu3buXIkWjkcmwfZGRkMHDgQNLS0gJ3tjGCwmAwtFq2bt1Kly5dGDx4MD5p2Q0OqCp79+5l69atDBkyJOjXGdWTwWBotRw5coRjjjnGCIkgERGOOeaYkHdgRlAYDIZWjRESoRHO9UqYoBCRQSLyLxH5r4isFZGpfvqIiPxeRL4QkdUicnoi1mowGAztmUTaKOqA/1XVj0WkC/CRiLypqv/16XMxVj78YVj1df9o/zQkEdl/vALt+EWTtsEdLuD17z+SoBUZDMnH8uXL6dChA2effTYAN9xwA5deeilXXXVV1OeqqKjgpZde4rbbbovKeAnbUahquap+bP9+EPiMlvVvLweeV4sSoLtdw9eQJHiFhAhNji9r3uLSl36S6OUZDEnD8uXLef/99+MyV0VFBU888UTUxksKG4VdE2A0sKLZqWNpWih+Kw7F1EXkFhEpFZHS3bt3x2KZBpvijcWcNv80sudnNwqJ5niFxYyiNfFfoMHgQNHKbYydu4wh04oZO3cZRSsjKcVu8fzzzzNy5EhOO+00rr/+el577TXGjBnD6NGjueCCC9i5cydffvklTz75JI888gijRo3i3/+2iim+9dZb5OTkcOKJJ/L6668DloH+xhtvJDs7m9GjR/Ovf/3LtX3t2rWceeaZjBo1ipEjR/L5558zbdo0ysrKGDVqFPfc41apNjgS7h4rIp2Bv2HlyD8Q7jiq+hTwFEBOTo7JnR4jcp7PoVqrG/8OZBd7Zff/g6I/MTsvO8YrMxjcKVq5jXv/voaq2noAtlVUce/frQeZvNF+nz8DsnbtWmbPns37779Pr169+PrrrxERSkpKEBGefvppfv3rX/Pb3/6WW2+9lc6dO3P33Vb132eeeYYvv/ySDz/8kLKyMr797W/zxRdf8PjjjyMirFmzhnXr1nHRRRexYcMGx/Ynn3ySqVOncu2111JTU0N9fT1z587l008/ZdWqVVG5dgndUYhIGpaQWKCq/urubgMG+fw90G4zJICRfz6TIw3VgTvaiICkHeRv2+6L4aoMhuCYt2R9o5DwUlVbz7wl68Mec9myZUycOJFevXoB0LNnT7Zu3cr48ePJzs5m3rx5rF271vH1kyZNwuPxMGzYMIYOHcq6det49913ue666wAYMWIExx9/PBs2bHBsP+uss3jwwQf51a9+xVdffUXHjh3D/n+cSKTXk2AVuf9MVR926LYY+IHt/ZQL7FfV8rgt0tDItQUf0CBVAXcQzRGBlMyy2CzKYAiB7RVVIbWHy49//GNuv/121qxZw5/+9CfXmIXmrqrhuK5+//vfZ/HixXTs2JFLLrmEZcuWhTxGIBK5oxgLXA+cJyKr7OMSEblVRG61+/wD2Ah8ARQA0THhG0Lm45pfRfT6aws+iNJKDIbwGNDd/5O2U3swnHfeeSxatIi9e/cC8PXXX7N//36OPdZSZc2fP7+xb5cuXTh4sGkF2kWLFtHQ0EBZWRkbN25k+PDhnHPOOSxYsACADRs2sHnzZtf2jRs3MnToUO644w4uv/xyVq9e7XeuSEiYjUJV3wVcxadadVr/Jz4rMriRklkW8m7Cl/fKvo7eYgyGMLhn/PAmNgqAjmkp3DN+eNhjnnLKKUyfPp1zzz2XlJQURo8ezaxZs5g4cSI9evTgvPPOY9Mmqxz7d7/7Xa666ipeffVV/vCHPwBw3HHHceaZZ3LgwAGefPJJMjIyuO222/jRj35EdnY2qampPPfcc6Snpzu2L1y4kBdeeIG0tDT69evHz3/+c3r27MnYsWM59dRTufjii5k3b15E165N1szOyclRU7goemQ/fTaaejBsQaEKWtuFzrvuZ8X0C6O7OEO75rPPPuOkk04Kun/Rym3MW7Ke7RVVDOjekXvGDw/bkN2a8XfdROQjVc3x1z/hXk+G5Cb797egXZ2FRPPnDCdXWdIOcqjPTIpWntwuv5iG5CBv9LHm8xcGSRFHYUhetGtJwJ3E4fVzmX3aGwzucEELweHF6wF1Z+GqqPiuGwyG+GEEhSEAzqpJVajdl8vGhyaQN/rYoFN2ROKOaDAY4o8RFIYAuG8n6nZdEUJvSO9bxLYouyMaDIbYYgSFwRXRlnYIOLqbuGbMoCbtKZLiuAkRgbQeJXQa8rBxlzUYWhFGUBgcmV0yGzzqaKOYOOSOFqk5Vk1ZRYqkuNoqPOm7KD30bJRXazAYYoURFAZHFm1Y5HhOBMf8TaumrHI1gHt3FgZDW2Dr1q1cfvnlDBs2jKysLKZOnUpNTQ3Lly/n0ksvbdH/9ddfZ/To0Zx22mmcfPLJ/OlPf0rAqkPDCAqDIw3aENPxR/35mzEd32CINarKlVdeSV5eHp9//jkbNmzg0KFDTJ8+3W//2tpabrnlFl577TU++eQTVq5cybhx4+K76DAwgsIQFllds1zPp5Diel4E6mS/ERaG+LJ6ITxyKszqbv1cvTCi4ZYtW0ZGRgY33ngjACkpKTzyyCM8++yzHD58uEX/gwcPUldXxzHHHANAeno6w4eHHxkeL4ygMDgiLj5MRVcUub521ZRVrq+Ho8KirZG/JJ/s+dmNxzde+AbFG4sTvSzD6oXw2h2wfwug1s/X7ohIWKxdu5ZvfOMbTdq6du3KcccdxxdffNGif8+ePbnssss4/vjjueaaa1iwYAENDbHduUcDIygMjjimdwky68vqKauZPHyyo2G7LZK/JJ+S8qb2l5qGGn72zjSynzsqPM5ecHaCVtiOWfpLqG3mml1bZbXHkaeffpqlS5dy5pln8pvf/IabbroprvOHgxEUBkfUYUfg1O6PGbkzAvZpS5HaH5SX+A0mEaFJ+4Hag5zy7CgGTys2VQDjxf6tobUHwcknn8xHH33UpO3AgQNs3ryZE044wfF12dnZ/OQnP+HNN9/kb3/7W9jzxwsjKAyOaIP/VGBO7U546vu57iraSqT2yJlvBN1XBMRTT2rXlbxYspkxc96M4coMAHQbGFp7EJx//vkcPnyY559/HoD6+nr+93//lxtuuIFOnTq16H/o0CGWL1/e+PeqVas4/vjjw54/XhhBYfDLmDlvIp5av+ec2p1YfbP7TfDrLr8Pabxk5UB1feBOPohAxoBCUruuZOfBGhOEGGvO/wWkNas9kdbRag8TEeGVV15h0aJFDBs2jBNPPJGMjAwefPBBAJYuXcrAgQMbj5UrV/LrX/+a4cOHM2rUKGbOnMlzzz0XwT8VHxKaPVZEngUuBXap6ql+zo8DXgU22U1/V9X4KhTbKTsP1pBZ2x3pUNHinNZ2D3m82n25pPVomWDQWwFv3AtXs/z6v4a73IRTtHIb6X3dDfz+8AqL+m6lvFeWH4OVGRoZOcn6ufSXlrqp20BLSHjbw2TQoEG89tprLdrHjRtHVVXLdDXnnHNORPMlgkSnGX8OeAx43qXPv1W1ZdSKIWYc1ZnXo9o0dbg2pFGze3zIYx6n11KO/yA7EdhT71xXONkZOfMNDlTX03lE4Ey7/vAKS0vQTIj6+gw+jJwUsWBojyRU9aSq7wCm9FkSMaNoDS+WbCYzaw6S1rQOhSpoXQZ9PKF77Lx517joLTKJGDPnTQ5U15N5ov8Aq2CxotVXRGlVBkN0aQ02irNE5BMR+T8ROcWpk4jcIiKlIlK6e/fueK6vTeEkJOBoTYlISke6ccK9rS/WYOfBGlK7rkQ89a7FndQhuaIvEqzfscEQZ5JdUHwMHK+qpwF/AByVwKr6lKrmqGpO796947bAtsSFDy8nc/g0v0LCiwhhVwiThgzXm2VdK71PpvcvDJjb6tMb1nBCN/dodgXO+4tRPRmSj6QWFKp6QFUP2b//A0gTkV4JXlabZXu3u61dQ5i1sQOx5qb/xGbgBNJpyMNBX6+iK4pIl3TXNOy7qzeTv8QYtQ3JRVILChHpJ2J9DUXkTKz17k3sqtouklId8KYXKIdTIOorsxx3FZnD741o7Hhz9oKzSUnfFfCa+ebFKv1BqbuCSaBkRwkj54+MyhoNhmiQUEEhIn8BPgCGi8hWEblZRG4VkVvtLlcBn4rIJ8DvgavVMa+EIRKCzUU055w5Ec0zsPpOv+3WTqb1vLVnLzibg3UHA5b0y+qa1SIvlgTxtWtQNcKiFfDll19y6qktPPuDpqioiP/+979RXFFsSLTX0zWq2l9V01R1oKo+o6pPquqT9vnHVPUUVT1NVXNV9f1ErretUryxmGnvTHN/MlboktqFCUMj06G/edc413tra0lncbDuYMA+HvH4TZ545jGXBDZsiyUsDG2Xuro6IygMrYdHP37U9clYFbqkdeH9a6Mkp13menlT24jSBph44kS/7c989yG0Pr1dJUtMFoo3FnPRyxcxcv5ILnr5oqhk9a2rq+Paa6/lpJNO4qqrruLw4cP88pe/5IwzzuDUU0/llltuaUywOW7cOO68805ycnL41a9+xeLFi7nnnnsYNWoUZWVljBs3jqlTpzJq1ChOPfVUPvzwQxoaGhg2bBheb86GhgZOOOEE4undaQSFgR2VOxzPqcKR7ZOjJySw7Bz+bpIikJrksQQzitYweFpxUDd5t4SIlZ/fj9Z2McIijhRvLGbW+7MoryxHUcory5n1/qyIhcX69eu57bbb+Oyzz+jatStPPPEEt99+O//5z3/49NNPqaqq4vXXX2/sX1NTQ2lpKdOnT+eyyy5j3rx5rFq1iqwsy5Z1+PBhVq1axRNPPMFNN92Ex+PhuuuuY8GCBQC89dZbnHbaacTTu9MICgP9Mvu5nteDp0d1vlVTVrnNZtXqTkK8wYipXVe69lOF1ENjXfsM65NJZdl0VMWvsPDGXbSlzLqJ5tGPH+VI/ZEmbUfqj1g76ggYNGgQY8da7/d1113Hu+++y7/+9S/GjBlDdnY2y5YtY+3ao5kHJk+e7DreNddcA8C3vvUtDhw4QEVFBTfddFNj4sFnn322sVBSvDCCwsDU06f6ddlUBa3twjVjBkV9Trc4jcL1hUkpLP6yYgsA6X1f87t+7829dl8uFVu+6zrWm3eNs4TF+ofQhpQmQXmNgqOuC3cWrjLCIko47ZzddtTBIM0+DCLCbbfdxssvv8yaNWvIz8/nyJGjAiozMzPk8QYNGkTfvn1ZtmwZH374IRdffHFEaw4VIygMfLD6OGr25ba4WWltFwYcfJDZedlRnzNQ9btFGxZFfc5Iqbfv4JLSssSll0Pr5lK9M48B3Ts69vHy5l3j+HLuBCo3zEFru1hji8+RdpDMrDnc/1rrzYOVTDjtnAPtqAOxefNmPvjAyvz70ksv8c1vWuV9e/XqxaFDh3j55ZcdX9ulSxcOHmzqGFFYWAjAu+++S7du3ejWrRsAP/zhD7nuuuuYOHEiKSmRuamHihEUBhb+91XSun/U5CaFplG9+xI27na+KUaCBkhX0aDJVx4yJYRIxFDTnLilTNl3OLS07gb/TD19KhkpGU3aMlIyrB11BAwfPpzHH3+ck046iX379vGjH/2I/Px8Tj31VMaPH88ZZ5zh+Nqrr76aefPmMXr0aMrKyqw1ZWQwevRobr31Vp555pnGvpdddhmHDh2Ku9oJEp891pAEpPVd3KLGhHhqSe+9hMoDo2Myp+BBcRYGHkm+Z5hrxgzixZLNaH1HJLVl+mitt3YRv5s8KqQ0J4EEkGUTMak9IsXr2v3ox4+yo3IH/TL7MfX0qRG5fA8ePJh169a1aJ89ezazZ7dUn/oWLQIYO3ZsC/fY6667jt/97nctXvvJJ59w2mmnMWLEiLDXGy5GULRzijcWIyktb3oAklYR0lN0KNR8fSapfupTgKX2yul5SUzmjQSvCu7vO7ugKVXN0q9D9c7LgNBzYV0zZhBFLct+AHa9in6vAIFLyhoCM2HohIhjgRLB3Llz+eMf/9jo+RRvku+xzRBXHv34UZdAO4mJIRvgyM48av3ZRWxj8NL3vpmURtydHX+Px1/aDoGUjl+FNebsvGz3YEePqX7XXli+fDk5OTkt2qdNm8ZXX33VaP+IN0ZQtHPcPD5ENCaGbLDULdU78zi0bi71lU2zqno6WIFEyVhLu2SH/12Qt57EsD7uHi1O9M/s73r+vTJTtsUJk9UnNMK5XkZQtHM8pDueC3TzigTvTqXjoAJSMsuaGNJTMsvoOKiA7RX+VWLJiqBhF2iaevpUE3wXBhkZGezdu9cIiyBRVfbu3UtGRkbgzj4YG0U75tKXfkKdHvFvJ2iAsT2vj9nc3p1KUUWZYx3tYFxMkwmPJ/znrglDJ3Dvm8/QkP55i6qCtftyo7C6tsnAgQPZunVrXNNZtHYyMjIYOHBgSK8xgqId82XNUmfduMA/PzyWmefFbv7Zedm8+pzz+YvOTC4bRd4reVZgosM1c8rtFCy/PPMP/Gz5LNJ6NK0t7umwm7FZPSMau62SlpbGkCFDEr2MNo8RFH7IX5JPSXlJo6d/fWUWA6vvbIN1n92363FR/bhEaBdv/wMzid2uJlTK9pe5JjR0y+0UDHmjj+XPZUcoO9Q0cj01s4xO/Z8FzopofIMhXIyNohleIUEznXl5zx+T/Vw22fOzkzK9RHi4u77GQ/WT289ZrVJVV5VU1zoeWvCNlav8elSVlJf47W8wxINEFy56VkR2icinDudFRH4vIl+IyGoRiW52Oj+U7Chpcf9sjFa22wvXFZI9PzsqKYoTiTgYAL3pO0KNLg6HgvEFzndggcJ1yZHKY3TB91zPxzpAUIFzn709pnMYDE4kWvX0HPAY8LzD+YuBYfYxBvij/TN2uOigG7HPT/v3NIBWGcAzZeEfUXH+V+fkLAo5cCwgr98Fpc+0bB88COeV1MOsbs3aUuDKJ2HkpOiuz4HZJbOpTdvgaM9RhYnDI7NPBEIE9nrejukcBoMTCRUUqvqOiAx26XI58Lxd/rRERLqLSH9VLY/ZmggsJ3y57937Wp2gKN5YzEeHn3AN8gpbSKxeCH/PD++1QVNvzeE0T87NcOnDUZtt0YZFrtdKiNw+4SW3Xy4flPuP1QBLNVowviAqcxkMwZLoHUUgjgW2+Py91W6LmaCor8xq9OsPhpqGWsa9cDXLr/9rrJYUddyjsSEkUTn/MtgU2ZNun7o6dqWmOuceD5XSZ5ruXCIUHAETFEYxy0nB+AJOfc5/kKOIrRo1GOJMmzFmi8gtIlIqIqWR+FRXbcl3LCbjf17YU7+WcS9cHfac8SZQRbvafS7avdfvslRB3iNCIQGwdKuz3I/KPbj0maZrnn9ZSC93tT+ou0E+HFxLl5tiRoYEkOyCYhvgm2xooN3WAlV9SlVzVDUnkhKBY7N6WsVk7DKVTQrJOOAVFq2FQPn3czrf1LThsTFHb7L+bAxRoKPDRc6IRcTtprdDEhoNFWMcq9ClSIcYqILcv5Zz3k5MYjhD+yXZBcVi4Ae291MusD+W9gmABflnWcKibDqH1s3l0Lq5NFT3aVPpFZzy76tCqnZjQf5ZTXcOe1qmUY42RxzUTk7tUcMrNBwExrUFH3Bw++V+Exg2VPchs3xe1JdUs+9Mx8+bCBzOfC3qcxoMbiTURiEifwHGAb1EZCswE0gDUNUngX8AlwBfAIeBuFTsWJBvBTYVrdzGvCXr2bbpLjqPuJf4eNLHnglDJ7By10oK1xc2ae/bsQ9LN37ux8so9vSrq6c8reXHsV9dfcgOBmHhFRhgzXblUzByEu+VfU1q15WkdvvIp7NQu28M1TvzqCL6QYm9qq9hP862CE+aQ05ygyFGJNrr6ZoA5xX4nzgtpwV5o49t9P457bHF1Hd+391T6JU8iq4oitPqwqd4YzEL173S5O6b0dDATzb/F6pjU9HOL537w93WbmXqxmKm//sX1FPTeFoVyutOQmZ9Br8ZAYdiupn0QRu9qr7Z71RWdT/Q7H3XxjQbvapdP8Jhcc/44cz4xPl8tw59oj6nweCGtMWsizk5OVpaWhr1cWeXzOav6wpdhcXcc+Ymvbts9nPZfh/R+9fW8c+t26M72ZBzYcrioLqOLvhei3gFVeh45Jv859Y/Or/wsTExUY8VZ3ZiWu9jHL2xVIXZp/1f9ONNgMtfvp6yQ36itIE+GX1YOnlp1Oc0tG9E5CNVbVkMAyMoQuaily+ivNL5ybZ/Zn/+edU/YzJ3NMh5PofqhiP+b36qrMgNgH0AACAASURBVPlyS8v2oDmqsgmHU5/zX8BHFT69YU3wA61eCK/8PysFbgRcNHCAX3WYL2umhLCuEDn9+dOpVf/1snP75Zp4CkNUcRMUyR5HkXRMPX0qP3tnmuOuojxu6pHQmf34iVRndnB8Qg7Ls6HXCLh9RUTrCobijcXB79RGTmoqrMLccZSnpriej3Xajjqtczxn4ikM8STZvZ6SjkA3K8Wq85BU2O6ti1yEBEDQz985N8Os/dYRByEhYgUJhs3tK46uN+fm6CxKlYkVFfDQcdEZzw9d08J38zYYookRFGHgdZX0hwh8WfMWlzzzu/guyh/zL2vi3hpIEPSvq3c+2WvE0ZttFNNj+OLm2eQWJBgSlz589P/oNSK8MVRJb2hgxtcVUL0/rCC+YKjeNd7ZLbvtaYwNSYxRPYVB9c68FsVlfBGBzZ5nmLIwnfmTfhTHldk4pNXw4CIsVJm6r5nbpY9XUjzolNaJw3X+va5SxF0NFBa+u6EQvapKNzeL+/S610bxmu3ZcQqZ3f2fM3LCEE/MjiIMrssNrG4QD5Tufym+6Ra8OwiHtBoTDxz0H2auSm5VFRMq7Zv0kHOtJ+44CgmAX5z1C8dzdQ11VoW5WHH3Out/HnJuY1NuVVXL62VfK0cOlVvvwet3RbykAd07+t29mvKohnhjBEUYzM7LDipaW9IqmLdkfXwWdX+vgHmXZnxdweQDB606FD7HpAMH+dOOPUdtD0G6s0abCUMnOF9TgS/2l8V+EVMWN9oyntq5hzFeYWEfuVVVFOzcE3gcb36p1QvDXso944dTvTOvRVS4wRBvjKAIkyv7BmeDiHk5UW+qDQc3yuaMrq6hX109gmWTeHDXXo7blcPQ6pdiZnuIJhc+vDw+E136MEOOvMRbX/2etzfuYfWmLazetCU4IeHL3/MttVYY5I0+lq7pR1Vu3gJaItChR0lSVf8ztG2MoAiT2XnZpEv3gE94vfrFMFngA/1CStJXnNmJWb16Up6WiopQnpbKvb3780Cn0WSkxDxJRlTYdOTdmM9RtHIbg6cVk9p1JZlZc/nW0N6cOnAkCzMDv99+8aqjwjB4r77/O3To8aHf8qiLNiRH9T9D28cIigj4aMq/6duxj6NlUQQ8vV6N/sT397JuPPWh7VYe7dGdI56mb7l4asnos4R1cy6J5grDRuvTXT3K0nsvien8RSu3cWfhKjKHTyNjQCGeDhXW+9ihggd6d2VyxmU0hBvHt+ltmNUj9NeJ/wkD1skwGKKEERQRsnTyUle/zsP1B6I3mddYHaSaqSniGGXsSdsf2bqiSP3GX7qelxgnxJu3ZD2Zw6cdrZPuO7cH1vZdy/WD3oArw42KbrDew8eCr+jrGNin5utriA/mkxYF+mf2dzwXtUIzDx0XZpEggSsLOHvYyY49AtWniCfWzsZZ8sZaQVbR+6d+hUTj/J5aK7vwyEktvKRCYs+6oG0X3evO8ev5VLPvzPjZbAztGiMoosDU06c6qku0vmNknk/eXUR1GE/9OTfDrApmH97AwbqDjt2c6lMkiqtHOOeKUmBGUWzyK51feD6SUh1aRVavl1Q4O4wgXWm/2nCx7fkktueTULsvl+qdeXy+qzL0eQ2GEDGCIgpMGDrBv797g4fqnZeF7/k0q0d4u4jO/ZtEUAcyeiZbttsZuTNcz79YsjkmwmLXkV0BhYQ47Wm8O4zOzrtLR0qfCZgKpL7qeI4m8LTSnHcakvxeaoa2gREUUaJ6Zx5Htk+mocbyjGmo6c6R8onUHRhNh9QQL/PqhXYRnVCNlR6/gXJuRs9krcEsR4b5Vbdog+Uu+pcVkWS59U9AjyaFyS67HeBo4J6khTa5SyqQ1K4ryehfiMfT1EXWk77LCAtDXEiooBCR74jIehH5QkSm+Tl/g4jsFpFV9vHDRKwzGMZm9SSl41eNxlZJqyBjQCHpfYuorgvhhv9AP8v3PlR6jYBZ+/yeCpTlNG5BgSFQtff0Ft5kIiCeejoNeZj6OEeeqcLkEZMD7nYambknPPtFk0p7Fl0HvIm/t1AEUtJ3hT6HwRAiCRMUIpICPA5cDJwMXCMi/iyuhao6yj6ejusiQ+Ck7KWk9Shp8sQnAmk9SsgcNjOw0dFriwjR5RVJC5jFdeKJE50yd1BfmRX7oMAw6Nj3n443R0/6LlKiXEu7eGOx4zlV6FhxffBCwovXfpHSMfQF+ewu6sT/AwAQhxqxBkNidxRnAl+o6kZVrQH+ClyewPVExKINi/zqt0VAUqrZ3u1uZ2ERrkfTlQXWk2sYqILWdqFqSz4DuodxI4sxmuruBnvNmEFRne/n//65Y9GkmvLJTD/32vAHv29HeOnNN70Nvxnh6pWmClMWulT/MxiiQCIFxbGAr6J5q93WnO+JyGoReVlEHO8OInKLiJSKSOnu3bujvdaAuNkBvMJisyxoefKBfqF7NHmN1UFWkvMnxERA0g4BVk6hZKO/y81RBF7d/32y52dHLY1Fg4s96NffuTHycqfe9Obp3QL39eVQOVM3fep4WsRKPtlWKFq5jbFzlzFkWjFj5y5LSvtZeyTZjdmvAYNVdSTwJjDfqaOqPqWqOaqa07t3/Au+BLIDeNVQjdjFhEJWNV1ZEFJW1wsfXk69Yyixcl3ucTGp+RwpwbrsFq4vjI6wcDF5LCrdHPn4Xu7dHPLuYkJlJXN37XG0tktaRcxchuPJ5S9fz4xPvsP+flPJHDGN/f2m8vMPf2CERRIQtKAQkWNF5GwR+Zb3iHDubYDvDmGg3daIqu5V1Wr7z6eBb0Q4Z8yYeOLEoPrlL8m3dhFhlOYMZRcBlpDY3uXnLj2Ef62L/+4rGEJx2Y1GziM30/h7ZV9HPH4TwthdTKg87PJllZh4gcWL8wvPJ3t+NmWHVrWw8XnSd/HzD3/A4GnFjYcJMow/QQkKEfkV8B4wA7jHPu6OcO7/AMNEZIiIdACuBprktxYRX6f0y4DPIpwzZszInUFW1yxXF0sRKCn/IPRdRHo368YSIp/vqkTSDjrq3mv3jUlKQ3aoRJrzKH+Jfy8zrx0nZty7OaRAPRcn57h7gUWL8wvPZ9cRy3PLycbnaebZ9fmuSiMs4kywFe7ygOE+T/cRo6p1InI7sARIAZ5V1bUi8kugVFUXA3eIyGVAHfA1cEO05o8FRVcUcfKfzseTHjhwK2iuLAhpFxEK1TvzODYJDdmhEkjtF4iSHSWO71dl2fSIxg7IyEl2sF6ItotmRNsLLB7MKFrDzqrgviudR0xDa7s0vh8mIj2+BPsN2wiEGEEUGFX9h6qeqKpZqjrHbvuFLSRQ1XtV9RRVPU1Vv62q8S25Fgap2++JzkAhGqzDQUhOQ7aXQDs0sJ76B6WeF9lEAeYYm9UzsvGDIZIa3kTfCyzWzChaw4slwdl+GlVRaQfpPGKaCTJMAMEKisPAKhH5k4j83nvEcmGtldX3fwd1qn6nSlZNTeBBcm6OShnSYX0y0YYU/xHOtV14ZPKopDRkeym6oojOcmyT6m7Nj9p9uXy25sKw5yjeWByw/vSC/LPCHj8kbl8RVs4oQcn5dE4MFhQ7Xt70ezqPaBFj64qJSE8cwaqeFtPMfmBwpvu+6XTt+WO2drD31HL057a0NIozOx2tT+1LSkfL5z5KnHv2uxSuq28SlKUKoql8mv9+1OaJJSVT3mDwNOdgOIvw9fMPlTwcPTVhNPCqoh46roXbdFZNDWUdOjRV5tsPH5fX/h+HZ/Wm06zkdE7wJX9JPqk9nNV9gTAR6fEnqB2Fqs4H/gJ8ZB8v2W0GPyw5PIl/bNtK/7r6Fha6Ix4Pj/bo3vJFQ86NqpAA2xvIT/yEJ6VtFbwJVz9ftHIbFTXuN5yE6f7v3dwiBUjR9p3WjtRnS5UK5O+3HBY6ao1V1CqJuX/ZC3xQHr6QaEScnRAM0SeoHYWIjMOKYfgS69YzSESmqOo7sVtaK+X+XmR6ahFgR2qK3y4t2mNksG5oaPCb4qE1V0brOKiAlMyyxr/rK7M4vcPPwhprztsLwI/M9iWhuv8p9ib+/l6Nxary9x/k3l49UbtSYR0wrfcxrEzvwIyvK6x+s7rDlU/F1L4VDkUrt7Gw7Ck8Hdz7qTrXA/GlZEdJ4E6GqBCsjeK3wEWqeq6qfgsYDzwSu2W1Ql6/q7H6nPcznupgiVVVS1nidXuNwRd67GPzIlDIJBd9u1h3Fq+Q8PWzT8ks4+OaX4UVcFbV7UXHG5Iq9Eo5hdl52ZEsPTr4JBi8/5ijQqIREQq7dqE4s5PdoFZiydUL47vOANxXOiX4CoXBfHjbyge8FRCsoEhT1cYUo6q6gRh4QbVaHhtj1RRoRq1jmTRhTP+TLPVCjKhIX+z8VNbKvmArpl9I3y4dGoWEL15h8WLJ5pAieEc+cyGI+4VYfv1fw1lubJiyGK4soMrj/JlqodL8e77ftOWJIO+VPDRtZ1A7hatHTGbNDWtYM8Vd+CsweFqxidyOA8EKilIReVpExtlHAVAay4W1Gu7vFXqUtQiH0ytdM5ZGituTWyuTE4AlLNzIzJoTUrr0hpQdrjetZLJvNzJykqtOxq+qc9PbViaABFO2v6WQb46q5RLtm6U3Y9/1+NOUejfr6X2LuLNwlREWMSZYQfEj4L/AHfbxX7ut/eItLmTrjkNFBB79+NEoL8oikABKyptgBHh97KMVZa4KWd2yojJWtHGssIezqpP6KqtaYgIJWBNK4ZiGcym6oqhJ+54dp1B/uGU8jW8a/46DCpKypkpbIlivp2pVfVhVr7SPR6IZpd3qeP2uoIoL5VZVuZZNKz9UHs1VAZaQmPbvaa6696GdR0V93njQWUe4BuAFmy49UBJBUWlxw0oWJg13tmfVivjYKZrTYD3YJMBuEYx3kgBv3/RYi/YB3TuSkrnR8fPsVT3uamgd7t6tFVdBISIL7Z9r7FTfTY74LDHJmH+ZX3uEPwp2Omf8BGioDeByEwYPlbgHIonAq1e9EPV540HJje7J/3Y2vB+UUXvhev+1Q8B6u646PkrR9THAtXiSCNN6H+MiLLAecB4bE/2FueCWIqURh/NW5gD3/YiIVejKEDsC7Si8uZ4vBb7r52hfPNAvtAJD6d04Un6Nfx1rQwrVu8dHb202+wPEBXQMp9paEuH2ZJneewkvlmx2FBaj5o8ie362o3uwKkw87qfMPO/6aC03NrjdN0V4qGcANdOedVZAX7wIohZ5l1T/yRfzRh8bVC6vhpR9bSLVerLi+g6oqlc3cpuqfuV7ALfFfnlJgtceEUrW114j4N7N9PGczZHyyTQ0eJqknqg/PJi6A6OjvtRA38kj9UeiPmc86Z/Z3/GcpFWQ2nWl3xxCo+aPop56q5/L023SCwkCv8f7U4LQKFfvj5sqymm93u9Cl7QuvH+ts+po0vDgUvi7PSQYIiNYY7Y/l5OLo7mQpOWxMUHZI5ow5NzGGtb3jB9OSsevEGlo4f9/zPDoG7MD7fDdymq2BqaePtVRmycCGf0LSe26skUaaq+QaAt46qNomI6xKsrrWOEv31h9ZRaV6+a6Cgmw1G2Th0+2X+g+X2uuy5HMBLJR/EhE1gAjmtknNgFtX3T/ZkTorq9XFhyNqMXaOqf3/NCv/3+1lHPGk9FzHitauc39e6RpQVeOS1YCFTQSD6T3X9QkDfX5hecHNbbGwGYUC743JN+vOrMREUIqXrlnXUxSf/g6VvjbxdXuzwnaAWFG7gzWTFkTcDfVWutyJDuBPk0vYdkiXqWpbeIbqhpBtflWwAP9IBSvpJSOjlHW6lByRgSqMt6LWhGW6Sudb6KqMPdbD4RUOS5ZCWgXlQZSu64ELA+nXVWBE8ipQqfK1mF2m3ne9Uw8/qfuKdhn7bM+k8GitRHXxGiOm2OF16YU7TT3rbEuR2sgkI1iv6p+CTwKfO1jn6gTkYj3qyLyHRFZLyJfiEiLnMMiki4ihfb5FSIyONI5g+L+XqHZI9K7uSb0czfGKZ/vqow4YOgb889BPPXO3jy13duEkAACSgoRyBhQSPazZ1C4rjBgf2/a9enntp5nn5nnXU93h1Kq3TrY7fftsOqahEIU7RaBEi560ipCTnNfuy/XrxoLrBQvra0uR2sh2P3pH4FDPn8fstvCRkRSgMexbB0nA9eIyMnNut0M7FPVE7ByS/0qkjmDYv5loQXR2UZrNyaeONH16a/joAJ+EmF0abVWuLp8xsLDKlFkdQ0cDCcC6jniKiS8xtSG6j50KJ+V1LU5/HHvmHtBm0Zja4OHrBQfgXf3uhZZaAMShTxR1xZ8EFCVF457ePfDkxqFhfc75Wv3W1P363CW2yooWrmNU37xRmPt8CHTiuNmvA9WUIjq0VudqjYQfC0LJ84EvlDVjapaA/wVuLxZn8uxstYCvAycLxLjvWUo7q9XFjQard1w8333fsAzYhxdOqZ3cHr61kDRFUVBCwsnvLuIQ+vmcnjTXcz87ilRXGF8eGlpT6q2X0VDTXdL4NV050j5RN7++LimNxA7T1RIMfkR5olasXsppFY4PiCFq+pbMf1Cuh+21Lv+7H5lh9pmOo+ildv46Rt/RobcQ+cR0+g8YhqZI6ZRVPF9Tn0um1Ofy7byl8WIoEuhisgdIpJmH1OxyqNGwrGAr4vCVrvNbx9VrQP2A8f4G0xEbhGRUhEp3b07xsVbJC3krK9uX1GvsIhWCgp/xK1KW5wouqKIuefMDVgq1Q1v/WWBVrebAHiv7GvqDoymsmwah9bNpbJsWqPLdQvvn5GTYFaFVT0xWMLME1W8sZiM/oV4PC1v5qqgDXBk++SwVX2B8n61xXQec95eQIf+hYiHJt6TvkdDyo6YCYtgBcWtwNnANqwb+hjglpisKExU9SlVzVHVnN69e8duoiHnWmmfQyWIh7lgPUCac+6ztzue8+bQaYtMGDoBj6SFLCysm9VRlc21uXEMPosTjt4/lz4cWrnV+qqQPaKmvf1znMxyIqB13fnNxTfGTDjvbIPpPA5nvhYwut0rLGJBsLmedqnq1araR1X7qur3VTXSWoTbAF/L00C7zW8fEUkFugF7I5zXHSd9rncXMSW8irC5/XID+oAfrAqinrYf9nre8fsh8taU9pdDp62wesrHiI++OlgqN1g1pq/LPS45ak5EGVfvn5GTQhMWXo+o1+8K2LV4YzEq7oWxPB32x0xIeL2p2pr6yRNsHY9Yze92UkR+av/8g4j8vvkR4dz/AYaJyBAR6QBcTcu63IuBKfbvVwHLfG0lMWHK4pbCItxdhA8F4wusXYXL6g+nlzJmzpthjO48aPXOvDDGa12suXFN0Np3b6AXwJdzJ7RqITE2q6fjuYDePyMnWQ8+oVD6jBVb5MJ97/w64JNv/ygEfbqqctMq2qT6KZEE2lF8Zv8s5Wi9bN8jbGybw+3AEnuehaq6VkR+KSJeK9ozwDEi8gVwF9DChTYmTFlsfYm8R5i7iOasmbLG8RPudenceTC0XUUsa1q0JiaPmBx0oY2qLfkM65MZ2wXFgQX5Z/kVFiHtkmbtDy3e4lC5q7Co4WvXl6sSlaDPbg6uwV4qjnFJntjKGPfC1cEV/FPw1Mcm84LE+gE9EeTk5GhpaXLWVSreWMzP3vGfBtzribM2Pzgda/HGYqa9M81R+KjCabVPtTlDthOzS2bz13WFgH+PJ68q7ji9ljfvGhffxcWQ2SWzKVy3yA7sFGr3jSGn802hve8PHWflfwoajxXU14xTCs7B08G/mkQVjqu/mX/cfGcI8/jH7XvknSuv+0utesfo5dTnsoMq+iQqrLkx/KTeIvKRqub4OxdI9fSaiCx2OsJeUTvGLejNW4AnWB79+NGARvL2IiTAckM+rfYp6iuzmiRgVAXUKrG5/icFbVBIFEJjLjElrUcJq/jf0MqE3rs5xHgLu75FMxfahppj/NqLVKGhMisqQgKs71EgdePLmyLVjicetzgJ31iSE7plRSQkAhEoFuI39s8rgX7Ai/bf1wA7Y7Wotk6gD3j+knzLphGAHZWx8XBozSzIP4trC37Ge+uOqkDGZvVsswJz0YZFLT5QIkDaQTuQ00poGZTxeMpiK9AulCSYXhfa+3Ywo2iNa5GhB89+PPhxgyC3fy4flPuvdSECqT0CxzglO3/bdh8pLlrSbjse5b1p58V8Ha6CQlXfBhCR3zbbkrwmIsmp22kNuNVqFqvQSzBkyDFUqYuRvSEtxIW1DdqqUPCHU20Nb2yOYsUVBO1lNHKSbegOIe+TXWr15W5XkdrDvypbJPqxKgXjCzjlzyMBdRBOrVutnr8kn5RM/7XGVUHr06OeK8uJYOMoMkVkqPcPERkCtH5rYILI7Zfrel4VLn3pJwHHqazb5xr5+o3OIaZHN7Q6ginqE1YgZ4hG7tk9u5LW4wPH3UQw6wyHAfuc1UsSSgbdJOPagg8cd0tgq6lTquMWKBrslfwJsFxElovI28C/gOgoG9shBeMLyO3XMrmZFxH4smapq37y/MLzHZMAqsI3Ot3G/EnRS2FuSE4C5RGD8AM5uW+HlcssCBZ27eKYM0XVWmcsePOucTRU+E8UWLPvzFYZT3FtwQeUHno2YL945skNNuDuDWAYVmnUO4Dhqroklgtr6wS2QajfSm1edlXtcvWEMEKifTAjd4br50AgMvXE7SuCCs4LUJ3VvdZ3hGia/5Q9ng67W2U8xXtlX5PWI/w647EgKEEhIp2Ae4DbVfUT4DgRuTSmK2sHRFIox+2L2ckT/SI0htZJ96xnI1dPeIPzJDltXv70+PHIn5ZIVAOrsKNJsKqnPwM1gNdKuA2YHZMVtSNqd493VRt0GuJc+MUJVZj5zbsjWJWhteGk/xeB2rQNXFvwQXQmmrknaFVUI6pkkRK4X4zofOyrCZs7FnhdYusrs4LyjIwWwQqKLFX9NVALoKqHia+KrE0y6eTmWdWPIgKe9F2c9HgeI2e+0eK81nbxq5fV+vS2U6DIEBSB9P8rdi+N3mR+VFGze7rvjIs2bQorC22wON2IREC7lLQ6O4VbahaAQ+vm8r1jH4jTaiyCFRQ1ItIRW+MhIllAdcxW1U6YnececendPjcMvocTHpzNtQUfcPaCs8l+LrsxMK9JYFltFzrveChOqzckC4HqnWQMKIxuqpdmqqhFLobsNO/TTH1VVKvn+ZLb39kxBLTV2SkW5J/FMQ3n+n0QrN2Xm5BElsEKipnAG8AgEVkALAV+GrNVtSMCuQ2KgHisL/snabdwoPYg+MlFD6ANHQPm6je0TQJ50T368aPRn3TmHkjp6FAR3qKuuQCJsCCSPwKpYHa1wrTjb9/0GFePmNx4f/CIpzGzQCLSkgQUFHZFuXVY0dk3AH8BclR1eUxX1k4I1m2wuVDwd96THmnmd0NrpWB8gasuOGZR/PftwE0L3a+uvmXjprcDZqGNFiLQse8/4zJXNCneWMw7W99BVemf2Z8Hv/lgTD3HAhFQUNhpvf+hqntVtVhVX1d1Cwc2hMKM3Bn0yegTUaU2gwFwrw/e0CEmU15b8IGzB54qU/c51FE4VB5VVZSbkNTUxNZyCJXijcXMen8W5ZXlKEp5ZTmz3p+V0EzRwaqePhaRM2K6knbM0slL0YaUiIWF8S5o33RJ6ekcqS/VYdY6cWdlg/tT7oTKw+4D/D3fylwbIR6P863MUx++G3oiePTjRzlSf6RJ25H6I7FRHwZJsIJiDFAiImUislpE1ohI7FIVtkM6l89rkg0yVFQhq1tWdBdlaFXI1pmu50OtdRKIopXb8KQ7B34GnUCjen9ouaX84KTC1Qao3HERFz68PKLx44mTmjCRSUCDfS/HA0OB84DvApfaPw1RYsX0C+m8/eFGt9dQBIYqaHUfiq4oit0CDUlPPIPLilZu4973/8e1j3tBVD9EoIqakTuDukNZfr43VgzH57sqwxo3ETgVZeoXhcqA4RKoHkWGiNyJFZX9HWCbqn7lPcKdVER6isibIvK5/bOHQ796EVllH22+/sWK6ReyNv99Pr1hDVqfHpSwUIXa7ZNZ+/+i6CtvaJUEyumUmTUnanPNW7LeMbOpl/6dB0Dn/qENHIEqytNhb8sIbU896f3+HtZ4ieC8v0xg3xE/NhWFQ9WH4r8gm0A7ivlADrAGuBj4bZTmnQYsVdVhWK62TiVOq1R1lH1E16cuyRnV8AeObJ+MQxbpRrS+I+t/3nbKPhrC557xwx3TwniLYrklmgyFQLsXbbBLnt69LnRh4VVFvX5XSC+TNP9Ga/HUkt43+Xfbl798PbuqN/sXvgIHa4MvahZtAgmKk1X1OlX9E3AVcE6U5r0cSwhh/8yL0rhthgX5ZzGm9/kcKZ/smkq8dme7kp8GF/JGH8ukrFtcd6J/WbElKnP16rfW8ZwqdNx//dEMAXevCyqxYAtKnwlpd+GWyiStR0n0UpnEiI2HVrnu0BLpGBlIUNR6f1HVuijO21dVy+3fdwB9HfpliEipiJSIiKswEZFb7L6lu3f7zybZ2liQfxZf/HwGWZ1H+Y3SbKju45oGxND+mHne9a43m4wTfhHxHMUbiznS4wXXeaafe23TBm80dwg1LoCju4sggvQ0gFXkvbKvXc8nktkls5O6zFIgQXGaiBywj4PASO/vInLA7YUi8paIfOrnaHJns+M0nK7R8XZlve8Dv7NTh/hFVZ9S1RxVzendu3eAf6t18epVLzQKC9+kYFf2/V2bKB5viC5OcTmNxW5eiWwDH8hN07Wa3X07IOfm0Cfd9Dbc754VuX9miCquJGLh+kXuuwk7RU+iCFQKNey0j6p6gdM5EdkpIv1VtVxE+gN+Q4pVdZv9c6OILAdGA2Xhrqk18+pVLyR6CYZWwtLJS8l+zv8DhAiUHYjsK1ReWR64kxuXPmwdj42BPeuCf53WWruLXiOs5ITNmHr6VH72zjTHG27HQQVAcibMbNAGx3V7Hw5HRc1EHDqJqhW4273legAAFZ1JREFUGJhi/z4FaJELWER6iEi6/XsvYCzw37it0GBoxbiqMSLVcbi8XhUmD58c3Di3r4Ah54Y+/551fo3dE4ZOwKMdHXdTqZnJ+Yx5xpPORca8O4lRdU8ltBZ8ogTFXOBCEfkcuMD+GxHJEZGn7T4nAaUi8glW6dW5qmoEhcEQIQqcveDsiF7vt92+qYWUk2jK4vAM3eDX2L36xg9bXYaCqoz3XNVO3ffOTqiQgAQJCjtv1PmqOkxVL1DVr+32UlX9of37+6qaraqn2T+fScRaDYbWSN0+92yyB+sOxiR30JGNYbhqew3d4dgu/EV1O6lwgHOfvT30OWKO+xYvolK2USJROwqDwRBDrhpyB7UuwgJikHpcU7hmzKDwX3/pw+F5RoElLGZ1tyK7a/o6qp/2et5mdklrKs4pkZeyjQJGUBgMbZDZedl0PzzJtU84RunzC893Pin10fHCu29HeLYLFP6eT1/Z7pqOf9GGRREtL9o4aZ1UYXAHl+sdR4ygMBjaKDsP1vgtmRsJu444JwF0igoPiymLw95d7Ep1v601BEp3EGecMt+KwOvffyTOq/GPERQGQxumsmx61MbKeyXPUZ2uCt2rY5Al4L4dIRu7/RZLSmIaKsb4FeZBe4/FASMoDIZ2TLD6+rxX8qz4CxfvnPduvydKq2pGsxrdgZi6r8I9/XIShUCPnPkGB7dfbtuTxI6ZENh/VkIr2jXHCAqDoY0yNqsnYEXxO903g9XXuwXpxS1qeOYeS2A4pOH2MqHyMHN373URFskjKQ5U19NpyMOk9SjBu66G6t4c3J5cqXmMoDAY2igL8s9ibFZPqrbkO/YJWl8f4N4aTRVXQO7dHHCHMaHyMLlVVS2FhSpjqqpsL6nQM9RGm05DHm4s/uQ9POm76DTk4YSuqzlGUBgM7YLIwtACPYP37RKbmtyuzNzj6h1VsHPPUWFhH7lVVTy9c8/RTqXPJFRg+KsQ6BUWyYRrrieDwdC68WZM1drOkHawpceSQv6SfArGOxuMR80f5XhOFbQ+nRXTL4zGckNnil3P7Dcj4FBLd98CX6HgRukz1pHezdqxxIGildviMk80MILCYGgHiD8hASBQUl7i+LrijcXUa71rionKz++PfIGRcredXHD+ZVam2XDxjfR2SD4YLeYtWQ8O1U2TLQ2JERQGQzvHTa1037v3ud61tLY7XdPDTjIdffzsMPL79qKk49F4jNyqquB2Gt7kgxATobG9oorMvvi9vtGMfYkGxkZhMLRhvJ5Pgcj988QWbWcvOJtarfXT20IVqnePZ/X93wl7fTHDrqp3s1dI+FiLSzp2JL+ve22LFniFhm+qkAgZ0L2joxB228ElArOjMBjaMAvyz+Lagg/4uDKLlMwyvzcgETiEpbqZUbSGF0s22944DuoqaPT37+sJPwttzBk5iRUfP9Dyf7CFRfhYqUL4u483Wef+R9VfQTCjaA3bKqro7KB6Cqh7ev0uy6biSwxVZUZQGAxtnAX5ZzFmzv9wgMcdhQVA9rNncHDDLMC/N05zKtc/xJzJic9smhQcKm+ZxRasqPKRTXNueYWxheBP+SdeSeFPIDixZ51VDCoGwsIICoOhHbBi+oWMmQOVmf7dQEVAPUdI71tkB3+5o/XWE3kyZDZ1w1nYCXkD+vLKtp0gMTQeN995AA8oPJBu/T77QHcWdu3SdKGqTDpwwL/gCUQoFQNDICE2ChGZKCJrRaRBRHJc+n1HRNaLyBciMi2eazQY2horpl9IZx3haihN61HSqM53QhWqd14WtP0jKRH4okM6Q6pfYl3DsXGN1fZe3znH2EICmsR6TD5wkBlfV8RxRYFJlDH7U+BK4B2nDiKSAjwOXAycDFwjIifHZ3kGQ9uk5Eb3lB2B1E3edB1yaHTCq65Fi4tr5nFC9V/s5IPxsSLP7tmdQu9OwvcASjPS47KGUEhUhbvPVHV9gG5nAl+o6kZVrQH+CiRXAhSDoRWi9emOhX2CobJsOvMmOgfhJRO5/dyLN3mpV7WTD1ZY6UHCLc8aBMWZnY4KieaIUNYhgij3XiPCf60LyeweeyywxefvrXabX0TkFhEpFZHS3bt3x3xxBkNrJWVzeBXeVKF2Xy6/mzwq6W0TXgrGF6ANKf5SPtFQ3afx75TmN21vxlrvEaUbcHFmJ6b16hkb/1dJi5nXU8wEhYi8JSKf+jlisitQ1adUNUdVc3r37h2LKQyGNkG4cQ9d07qw/icFrUZIeLmi5ws0VPfxNQPQUN2Hw5uOGvYDlnC9fUVTwRGmmurRHt3BoVBRRPQaYeW+ihEx83pS1QsiHGIb4PvuDbTbDAZDnEmXdN6/9v1ELyMsZudls2XhVXxU+UTjvd2TvovOI6ZRuy+XiUPuCL2E68hJLdxeAcs91cXzqDw1QBS7Klk1NQ4nU+DKJ/3PG2OS2T32P8AwERmCJSCuBr6f2CUZDG2DdOlOtVYEpQHJ7ZfrmjQw2SneWMzHVU8gfh7kO/QsIaPf8UAUan2Dq+on75U82O9c1wMAEYpu2RCdtUSRRLnHXiEiW4GzgGIRWWK3DxCRfwCoah1wO7AE+AxYqKprE7Feg6Gt8dGUf+ORNP+GXrstt18ua6asadVCAuDRjx91PV+4vjAu6whUIVAV+mT0ce6QQBLl9fSKqg5U1XRV7auq4+327ap6iU+/f6jqiaqapapzErFWg6GtsnrKx1w9omVd5qxuWW1CQHjZUbkjYJ+8V/LisBJnvG7HSycvTeg6nEhm1ZPBYIgxM3JnJFVt5ljQL7Mf5ZUta1X44lbqNRoUbywO2CeuVQJDJJndYw0GgyFipp4+NWCfWKf1dlN/eXcTyRzpbgSFwWBo00wYOoG558xN6BoCqb9G8dukjnQ3gsJgMLR5JgydQFbXLL87h+bBd7GgX6ZTPnEr9i6ZhQQYQWEwGNoJRVcU0VmObRJ45xUSV/b9XUzn7khfRyFVdygr6etnG2O2wWBoN5RMeYMZRWv4y4ot1KuSIsI1YwaFHnAXArNLZrPx0KoWMSuqoA0pVG3JZ96S9Ukd8W52FAaDoV0xOy+bob07AVYywBdLNnPhw8tjNl/h+kK/8RMiIJ56wKqfncyYHYXBYGhXXPjwcram/47OI466xG6tzOLCh+HNu8ZFda7TH56LBpEDcED3SEqzxh6zozAYDO2Krem/aywJ6z1SMsvYmh5dO8WYOW9S3X1hUGlS7hmf3CVljaAwGAztCn91w73CIprsPFiDeGodz3sN6a0hbbsRFAaDwWATb++jw5vuSnohAUZQGAyGdoabJmjO2wuiNk9q15WO57zR2MP6ZEZtvlhiBIXBYGhXpHnS/LaLwOHM16I2T6e+/3S1T3TedX/UjeexwggKg8HQrnjgmw80plJvjietImrzaOo+x3MisGL6hVGbK9YYQWEwGNoVE4ZOwCMOleYE8pfkRzzH7BL3uuQef1WUkphEFS6aKCJrRaRBRHJc+n0pImtEZJWIlMZzjQaDoe3SQL3juZIdJRGPv2jDItfzE0+cGPEc8SRRAXefAlcCfwqi77dVNXZVww0GQ/tDcbZqRyHleIM2uJ5vbTVAEiIoVPUzAAkmEsVgMBiiTIzlBB7xOAqLZC136kayK8oU+KeIfCQit7h1FJFbRKRUREp3794dp+UZDIbWSH2l/5Tj0cKvakkhhQ5JW+7UjZgJChF5S0Q+9XNcHsIw31TV04GLgf8RkW85dVTVp1Q1R1VzevfuHfH6DQZD26VqS+QGazfqDx+PatPbq+KhavsVSZ9S3B8xUz2p6gVRGGOb/XOXiLwCnAm8E+m4BoOhfTM2qyefxGjsKQv/yEeHn/CTJqSB1F5LmLfk7FYRje1L0qqeRCRTRLp4fwcuwjKCGwwGQ0QsyD+LzjqihfrJWyMi3LTjUxb+kY8qWwoJL5JWkfQpxf2RKPfYK0RkK3AWUCwiS+z2ASLyD7tbX+BdEfkE+BAoVtU3ErFeg8HQ9ii5cRHakNJEWHhrRGzvdndYY5YeeAm3EAmt7Z70KcX9kRBBoaqvqOpAVU1X1b6qOt5u366ql9i/b1TV0+zjFFWdk4i1GgyGtot46v1mkpWU6oBBc37HS3WO7FaF6t3jkz6luD+SVvVkMBgMiUIECtcVRn3cMb3Pb3X2CTCCwmAwtGPcIrkUuPzl66Myntf2sSD/rJDGSxaMoDAYDO2WrG7O8RQiUHZoVdDurDOK1rgG6629aVXoC0wSjKAwGAztlqIrigL2ue/jSUGN9ZcVW9D6dL+eVPWVWeEsL2kwgsJgMLRrOtDT8ZwIaMqB4MYZ+BSSUu3XNbZ2v2Pu01aBERQGg6Fd88C3fuqaziPYjHT+anGDJWzSey8Ja23JghEUBoOhXTNh6ARE/Ve9A8uonf1cdkB3Wbccp9EsiJQIjKAwGAztnrnnPoBTZnARQKBwfaGjsMj+c7brrqR/5/6RLzKBGEFhMBjaPROGTuBI+eSAGWX9FST6/+3df6xXdR3H8ecr8EcDghk/UiApopYDRbqZhhlqEIoLbC6yqBUNW+WGsqk4/nLrB5vN2WbNzFyWDHIzlykGpOSPlOSi/BYM0hQ1oB+G95bIj3d/nM9lX+793nOv43u+h/v9vh7b2b3nfD/3e96fMb7v7+dzzvm8J9w1kVD3I4oImD9pfg2iLI8ThZkZcHDf2T22qawxMW/FPCbcPYGo8nR3ZzM+OONYwyuVE4WZGTBu+IBet523Yt6Rkqk911/r+wXanCjMzIBVC6ZweP/w3OmnCLho6Yxe19WOgPce7raMTp/hRGFmlmz95iO5yUKCPftf7rFeakS2Hfj3uTw297baB1pnThRmZhX+++KC3Nel3tXVbtu2mO3X/qw2QZXMicLM7B3Kuy4RAXFgELfOnli/gArmRGFmVmHy2FM41N79YoF5OpJE+85FfXI58e6UVeHuZknbJG2UdL+kId20my5pu6QdkhbWO04zaz5L5p3HpBNvqLrAX54IeOu12bTvXMTksd2vH9UXlTWiWAWMj4gzgReAGzs3kNQP+DFwCXAGcKWkM+oapZk1pSXzzuO0//zwHSeLg/vOZvLYU/ps3YnulFUKdWVEHEy7a4BRVZqdA+xIJVHfBpYBM+sVo5k1t1ULptD+l5u61NWupuMOp35SwyUJOD6uUcwFHq5yfCTwSsX+rnSsKklXSWqV1Lp3794ah2hmzaifRPsL3ztyu2tnlbfB7t89iys/Mbr+QdZBYYlC0h8kba6yzaxoswg4CCw51vNFxB0R0RIRLcOGDTvWtzMzO/LB3759MXFg0JHE0LEd3j+ctm2L2b97FnPOfT/fnTWh5IiL0b+oN46Iz+S9LulrwGXAxRFVB3avApXpeVQ6ZmZWFx0f/PeseZn2nYu6vD5i0IlsXTy13mHVnap/Rhd8Umk6cAvw6YioOk8kqT/Zhe6LyRLEWuBLEbGlp/dvaWmJ1tbWGkZsZtbYJK2LiKql+Mq6RnEbMAhYJWm9pNsBJJ0maTlAuth9NbACeB64tzdJwszMaquwqac8EfGhbo6/Blxasb8cWF6vuMzMrKvj4a4nMzM7jjlRmJlZLicKMzPL5URhZma5nCjMzCxXKc9RFE3SXuBvNXirocA/avA+fUEz9RXc30bWTH2F2vX39IiouqxFQyaKWpHU2t0DKI2mmfoK7m8ja6a+Qn3666knMzPL5URhZma5nCjy3VF2AHXUTH0F97eRNVNfoQ799TUKMzPL5RGFmZnlcqIwM7NcThRVSJouabukHZIWlh1PkSTdJWmPpM1lx1IPkkZLWi1pq6QtkuaXHVNRJJ0s6RlJG1Jfbyo7pnqQ1E/Sc5IeLDuWokl6SdKmVK6hsCI8vkbRiaR+ZAWTppLV6V4LXBkRW0sNrCCSLgDagF9GxPiy4ymapFOBUyPiWUmDgHXArEb895UkYEBEtEk6AXgSmB8Ra0oOrVCSFgAtwHsi4rKy4ymSpJeAlogo9AFDjyi6OgfYERF/jYi3gWXAzB7+ps+KiMeBf5UdR71ExOsR8Wz6/U2yolgjy42qGJFpS7snpK2hvxlKGgXMAO4sO5ZG4kTR1UjglYr9XTToB0mzkzQGOBv4c7mRFCdNw6wH9gCrIqJh+5rcClwPHC47kDoJYKWkdZKuKuokThTWlCQNBO4DromIfWXHU5SIOBQRE4FRwDmSGnZ6UdJlwJ6IWFd2LHV0fkRMAi4BvpOmkmvOiaKrV4HRFfuj0jFrEGm+/j5gSUT8pux46iEi3gBWA9PLjqVAk4HPpXn7ZcBFku4pN6RiRcSr6ece4H6yqfOac6Loai0wTtIHJJ0IfBF4oOSYrEbSBd6fA89HxC1lx1MkScMkDUm/v5vsBo1t5UZVnIi4MSJGRcQYsv+3j0bEnJLDKoykAemGDCQNAKYBhdy96ETRSUQcBK4GVpBd6Lw3IraUG1VxJC0FngY+ImmXpG+UHVPBJgNfIfu2uT5tl5YdVEFOBVZL2kj2BWhVRDT8LaNNZATwpKQNwDPAQxHx+yJO5Ntjzcwsl0cUZmaWy4nCzMxyOVGYmVkuJwozM8vlRGFmZrmcKMw6kfQ+Scsk7UxLIyyX9OECz/dUD68PkfTtos5v1hPfHmtWIT2Q9xRwd0Tcno6dRbYS6RM1Plf/9NxOT+3GAA82w+q+dnzyiMLsaBcCBzqSBEBEbCB7sOlmSZvT+v+zAdLIY0ZHW0m/kHSFpDGSnpD0bNo+mV6fko4/AGxNx9rSz4GSHkntN0nqWLV4MTA2PRx4c2p7naS1kjY2S50JK0//sgMwO86MJ6tR0dnngYnAWcBQYK2kx4FfA18AHkpLvlwMfAsQMDUi3pI0DlhKViMBYBIwPiJe7HSOt4DLI2KfpKHAmpRQFqb2EwEkTQPGka3rI+ABSRekJePNas6Jwqx3zgeWRsQhYLekx4CPAw8DP5J0EtmCe49HxP8kDQZukzQROARUXuN4pkqSgOxD//tpBdDDZMvbj6jSblrankv7A8kShxOFFcKJwuxoW4Arets4jRj+CHwWmE22ainAtcBushHIu8hGCx3au3m7LwPDgI9FxIG0CurJVdoJ+EFE/LS3cZodC1+jMDvao8BJlUVgJJ0JvAHMToWAhgEXkC3EBtn009eBTwEdi7INBl6PiMNkixD268W5B5PVUzgg6ULg9HT8TWBQRbsVwNxUUwNJIyUNf+ddNesdjyjMKkRESLocuFXSDWQjgZeAa8imeDaQVRW7PiL+nv5sJfAr4LepfC7AT4D7JH2VLHl0N4qotAT4naRNQCtpSfCI+KekP0naDDwcEddJ+ijwdHaTFm3AHLIqdmY159tjzcwsl6eezMwslxOFmZnlcqIwM7NcThRmZpbLicLMzHI5UZiZWS4nCjMzy/V/w1utExgflvcAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_covariate_against_prediction(X, predictions, test_splits, 1, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "p = pd.DataFrame(np.array(predictions[1]).T, columns = [\"bartpy\", \"catboost\", \"OLS\"])\n", + "sns.pairplot(p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Single dimension - discrete break points\n", + "\n", + "** To make the model more complex, let's add some discrete dumps to make the curve less smooth. This will test the ability of the models to handle very isolated effects in feature space **" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'X v y')" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(0, 5, 3000)\n", + "X = pd.DataFrame(x).sample(frac=1.0).values\n", + "y = np.random.normal(0, 0.1, size=3000) + np.sin(X[:, 0]) + np.cos(5 * X[:, 0])\n", + "y[(X[:,0] < 1.5) & (X[:,0] > 1.)] += 3\n", + "y[(X[:,0] < 3.5) & (X[:,0] > 3.)] -= 3\n", + "plt.scatter(X[:, 0], y)\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.title(\"X v y\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate set to 0.046077\n", + "0:\tlearn: 2.0249057\ttest: 1.9762890\tbest: 1.9762890 (0)\ttotal: 1.05ms\tremaining: 1.05s\n", + "300:\tlearn: 0.1730722\ttest: 0.2784624\tbest: 0.2774811 (223)\ttotal: 194ms\tremaining: 450ms\n", + "600:\tlearn: 0.1581279\ttest: 0.2822762\tbest: 0.2774811 (223)\ttotal: 376ms\tremaining: 249ms\n", + "900:\tlearn: 0.1547546\ttest: 0.2853854\tbest: 0.2774811 (223)\ttotal: 568ms\tremaining: 62.4ms\n", + "999:\tlearn: 0.1542514\ttest: 0.2860638\tbest: 0.2774811 (223)\ttotal: 630ms\tremaining: 0us\n", + "\n", + "bestTest = 0.2774811298\n", + "bestIteration = 223\n", + "\n", + "Shrink model to first 224 iterations.\n", + "Learning rate set to 0.046077\n", + "0:\tlearn: 1.9675861\ttest: 1.9980471\tbest: 1.9980471 (0)\ttotal: 987us\tremaining: 986ms\n", + "300:\tlearn: 0.1880747\ttest: 0.2268492\tbest: 0.2268492 (300)\ttotal: 192ms\tremaining: 446ms\n", + "600:\tlearn: 0.1728099\ttest: 0.2186123\tbest: 0.2185730 (586)\ttotal: 378ms\tremaining: 251ms\n", + "900:\tlearn: 0.1703407\ttest: 0.2187935\tbest: 0.2184685 (770)\ttotal: 562ms\tremaining: 61.7ms\n", + "999:\tlearn: 0.1698324\ttest: 0.2190395\tbest: 0.2184685 (770)\ttotal: 623ms\tremaining: 0us\n", + "\n", + "bestTest = 0.2184684559\n", + "bestIteration = 770\n", + "\n", + "Shrink model to first 771 iterations.\n" + ] + } + ], + "source": [ + "scores, predictions, models, train_splits, test_splits = compare_models(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0.9922216264577248, 0.9870015668310034, 0.2951019225894349],\n", + " [0.9940161555583875, 0.9889802037929508, 0.31764061177535946]]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_prediction_against_actual(y, predictions, test_splits)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_covariate_against_prediction(X, predictions, test_splits, 1, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "p = pd.DataFrame(np.array(predictions[1]).T, columns = [\"bartpy\", \"catboost\", \"OLS\"])\n", + "sns.pairplot(p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Single meaningful dimension - additional noise dimensions\n", + "\n", + "** It's important for the models to be able to correctly identify features that aren't important. In this case, we just add normally distributed noise features. This shouldn't be too difficult a problem to solve **" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'X v y')" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(0, 5, 3000)\n", + "X = np.random.normal(0, 3, size = 3000 * 8).reshape(3000, 8)\n", + "X[:, 0] = x\n", + "X = pd.DataFrame(X).sample(frac=1.0).values\n", + "y = np.random.normal(0, 0.1, size=3000) + np.sin(X[:, 0])\n", + "plt.scatter(X[:, 0], y)\n", + "plt.scatter(X[:, 1], y)\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.title(\"X v y\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate set to 0.046077\n", + "0:\tlearn: 0.7014599\ttest: 0.6909322\tbest: 0.6909322 (0)\ttotal: 1.82ms\tremaining: 1.82s\n", + "300:\tlearn: 0.0708725\ttest: 0.1092401\tbest: 0.1089265 (203)\ttotal: 246ms\tremaining: 572ms\n", + "600:\tlearn: 0.0496617\ttest: 0.1106342\tbest: 0.1089265 (203)\ttotal: 485ms\tremaining: 322ms\n", + "900:\tlearn: 0.0363843\ttest: 0.1111062\tbest: 0.1089265 (203)\ttotal: 827ms\tremaining: 90.8ms\n", + "999:\tlearn: 0.0331902\ttest: 0.1114189\tbest: 0.1089265 (203)\ttotal: 933ms\tremaining: 0us\n", + "\n", + "bestTest = 0.1089264923\n", + "bestIteration = 203\n", + "\n", + "Shrink model to first 204 iterations.\n", + "Learning rate set to 0.046077\n", + "0:\tlearn: 0.7022567\ttest: 0.6695192\tbest: 0.6695192 (0)\ttotal: 1.93ms\tremaining: 1.93s\n", + "300:\tlearn: 0.0702167\ttest: 0.1054306\tbest: 0.1038735 (165)\ttotal: 246ms\tremaining: 572ms\n", + "600:\tlearn: 0.0488468\ttest: 0.1082234\tbest: 0.1038735 (165)\ttotal: 491ms\tremaining: 326ms\n", + "900:\tlearn: 0.0349572\ttest: 0.1091821\tbest: 0.1038735 (165)\ttotal: 757ms\tremaining: 83.2ms\n", + "999:\tlearn: 0.0317149\ttest: 0.1094885\tbest: 0.1038735 (165)\ttotal: 838ms\tremaining: 0us\n", + "\n", + "bestTest = 0.1038735284\n", + "bestIteration = 165\n", + "\n", + "Shrink model to first 166 iterations.\n" + ] + } + ], + "source": [ + "scores, predictions, models, train_splits, test_splits = compare_models(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0.9776670938368426, 0.9804054928680594, 0.9819510603353212],\n", + " [0.9769423624072204, 0.9793968811773819, 0.9811971722649624]]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_prediction_against_actual(y, predictions, test_splits)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_covariate_against_prediction(X, predictions, test_splits, 1, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "p = pd.DataFrame(np.array(predictions[1]).T, columns = [\"bartpy\", \"catboost\", \"OLS\"])\n", + "sns.pairplot(p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mixture of multiple meaningful dimensions and noise dimensions\n", + "\n", + "** Both catboost and BartPy have performed well with noise dimensions and rapidly moving targets, let's combine them to make a relatively difficult test for tree models **\n", + "\n", + "BartPy does significantly worse than catboost in this test. It can't match the very rapidly moving cos wave, while catboost does an excellent job." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'X v y')" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "X = np.random.normal(0, 3, size = 3000 * 8).reshape(3000, 8)\n", + "X = pd.DataFrame(X).sample(frac=1.0).values\n", + "y = np.random.normal(0, 0.1, size=3000) + np.sin(X[:, 0]) + np.sin(5 * X[:, 1]) + np.cos(-6 * X[:, 3])\n", + "plt.scatter(X[:, 0], y)\n", + "plt.scatter(X[:, 1], y)\n", + "plt.scatter(X[:, 3], y)\n", + "\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.title(\"X v y\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate set to 0.046077\n", + "0:\tlearn: 1.2071709\ttest: 1.2274656\tbest: 1.2274656 (0)\ttotal: 1.26ms\tremaining: 1.25s\n", + "300:\tlearn: 0.5214435\ttest: 0.8112397\tbest: 0.8112397 (300)\ttotal: 249ms\tremaining: 579ms\n", + "600:\tlearn: 0.2805957\ttest: 0.6565300\tbest: 0.6565300 (600)\ttotal: 495ms\tremaining: 329ms\n", + "900:\tlearn: 0.1768165\ttest: 0.6120706\tbest: 0.6120706 (900)\ttotal: 744ms\tremaining: 81.7ms\n", + "999:\tlearn: 0.1542937\ttest: 0.6026805\tbest: 0.6026437 (998)\ttotal: 825ms\tremaining: 0us\n", + "\n", + "bestTest = 0.602643672\n", + "bestIteration = 998\n", + "\n", + "Shrink model to first 999 iterations.\n", + "Learning rate set to 0.046077\n", + "0:\tlearn: 1.2175917\ttest: 1.2833024\tbest: 1.2833024 (0)\ttotal: 2.05ms\tremaining: 2.04s\n", + "300:\tlearn: 0.5196479\ttest: 0.8241700\tbest: 0.8241700 (300)\ttotal: 252ms\tremaining: 585ms\n", + "600:\tlearn: 0.2896781\ttest: 0.6666183\tbest: 0.6666183 (600)\ttotal: 494ms\tremaining: 328ms\n", + "900:\tlearn: 0.1809154\ttest: 0.6023277\tbest: 0.6023277 (900)\ttotal: 767ms\tremaining: 84.3ms\n", + "999:\tlearn: 0.1575576\ttest: 0.5926307\tbest: 0.5926307 (999)\ttotal: 846ms\tremaining: 0us\n", + "\n", + "bestTest = 0.5926306827\n", + "bestIteration = 999\n", + "\n" + ] + } + ], + "source": [ + "scores, predictions, models, train_splits, test_splits = compare_models(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0.4474648128069827, 0.776096900193399, 0.32349435338659893],\n", + " [0.4729599336660458, 0.7971621384928165, 0.3404468586098318]]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_prediction_against_actual(y, predictions, test_splits)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_covariate_against_prediction(X, predictions, test_splits, 1, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_covariate_against_prediction(X, predictions, test_splits, 1, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_covariate_against_prediction(X, predictions, test_splits, 1, 3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/diagnostics/performance/Diagnostics on OLS.ipynb b/diagnostics/performance/Diagnostics on OLS.ipynb new file mode 100644 index 0000000..42e45d8 --- /dev/null +++ b/diagnostics/performance/Diagnostics on OLS.ipynb @@ -0,0 +1,367 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "# Evaluate BartPy on sample regression data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn.datasets import make_regression\n", + "\n", + "from matplotlib import pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from bartpy.sklearnmodel import SklearnModel" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "regression = make_regression(n_samples=2000, n_features=20, n_informative=10)\n", + "X, y = regression" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def get_clean_model():\n", + " return SklearnModel(n_chains=4, \n", + " n_jobs=-1, \n", + " n_burn=200,\n", + " n_samples=1000, \n", + " n_trees=200, \n", + " initializer=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SklearnModel(alpha=0.95, beta=2.0, initializer=None, n_burn=200, n_chains=4,\n", + " n_jobs=-1, n_samples=1000, n_trees=200, sigma_a=0.001,\n", + " sigma_b=0.001, store_acceptance_trace=False,\n", + " store_in_sample_predictions=False, thin=0.1,\n", + " tree_sampler=)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = get_clean_model()\n", + "model.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(model.predict(X), y)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(X[:, 0], model.predict(X))\n", + "plt.scatter(X[:, 0], y)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2020-04-15 06:42:19.360759\n", + "2020-04-15 06:44:25.237537\n", + "Learning rate set to 0.043074\n", + "0:\tlearn: 147.5860308\ttest: 139.5846629\tbest: 139.5846629 (0)\ttotal: 68.2ms\tremaining: 1m 8s\n", + "300:\tlearn: 10.6295816\ttest: 26.4414621\tbest: 26.4414621 (300)\ttotal: 570ms\tremaining: 1.32s\n", + "600:\tlearn: 4.6150550\ttest: 23.0637667\tbest: 23.0637667 (600)\ttotal: 1.03s\tremaining: 686ms\n", + "900:\tlearn: 2.4713029\ttest: 22.6120298\tbest: 22.6120298 (900)\ttotal: 1.43s\tremaining: 157ms\n", + "999:\tlearn: 2.0047184\ttest: 22.5633313\tbest: 22.5633313 (999)\ttotal: 1.56s\tremaining: 0us\n", + "\n", + "bestTest = 22.56333129\n", + "bestIteration = 999\n", + "\n", + "2020-04-15 06:44:27.010944\n", + "2020-04-15 06:44:27.011257\n", + "2020-04-15 06:46:37.413548\n", + "Learning rate set to 0.043074\n", + "0:\tlearn: 137.5676637\ttest: 149.2084231\tbest: 149.2084231 (0)\ttotal: 3.07ms\tremaining: 3.07s\n", + "300:\tlearn: 11.2687535\ttest: 39.2827762\tbest: 39.2827762 (300)\ttotal: 327ms\tremaining: 759ms\n", + "600:\tlearn: 4.7385856\ttest: 34.7193126\tbest: 34.7193126 (600)\ttotal: 665ms\tremaining: 441ms\n", + "900:\tlearn: 2.3271836\ttest: 33.9917921\tbest: 33.9917921 (900)\ttotal: 988ms\tremaining: 109ms\n", + "999:\tlearn: 1.8667008\ttest: 33.9240697\tbest: 33.9223245 (997)\ttotal: 1.09s\tremaining: 0us\n", + "\n", + "bestTest = 33.92232455\n", + "bestIteration = 997\n", + "\n", + "Shrink model to first 998 iterations.\n", + "2020-04-15 06:46:38.660304\n" + ] + } + ], + "source": [ + "from sklearn.model_selection import KFold\n", + "from datetime import datetime\n", + "from catboost import CatBoostRegressor, Pool\n", + "kf = KFold(n_splits=2, shuffle=True)\n", + "b_scores, c_scores = [], []\n", + "for train_index, test_index in kf.split(X):\n", + " print(datetime.now())\n", + " model = get_clean_model()\n", + " model.fit(X[train_index], y[train_index])\n", + " b_scores.append(np.sum(np.square(y[test_index] - model.predict(X[test_index]))))\n", + " print(datetime.now())\n", + " eval_pool = Pool(X[train_index][:300,:], y[train_index][:300])\n", + " train_pool = Pool(X[train_index][300:,:], y[train_index][300:])\n", + " c_model = CatBoostRegressor()\n", + " c_model.fit(train_pool, eval_set=eval_pool, verbose=300)\n", + " c_scores.append(np.sum(np.square(y[test_index] - c_model.predict(X[test_index]))))\n", + " print(datetime.now())" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[728849.355589103, 805988.7792926353]\n", + "[688369.736772838, 932436.9130089999]\n" + ] + } + ], + "source": [ + "print(b_scores)\n", + "print(c_scores)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.4268633726349401, 0.41484025141397446)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt(b_scores[0]) / X.shape[0], np.sqrt(c_scores[0]) / X.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(model.predict(X[test_index]), y[test_index])\n", + "plt.scatter(c_model.predict(X[test_index]), y[test_index])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting yellowbrick\n", + " Downloading yellowbrick-1.1-py3-none-any.whl (263 kB)\n", + "\u001b[K |████████████████████████████████| 263 kB 1.1 MB/s eta 0:00:01\n", + "\u001b[?25hRequirement already satisfied: matplotlib!=3.0.0,>=2.0.2 in /Users/jacoltman/opt/anaconda3/envs/bartpy/lib/python3.7/site-packages (from yellowbrick) (3.1.3)\n", + "Requirement already satisfied: cycler>=0.10.0 in /Users/jacoltman/opt/anaconda3/envs/bartpy/lib/python3.7/site-packages (from yellowbrick) (0.10.0)\n", + "Requirement already satisfied: scikit-learn>=0.20 in /Users/jacoltman/opt/anaconda3/envs/bartpy/lib/python3.7/site-packages (from yellowbrick) (0.22.1)\n", + "Requirement already satisfied: scipy>=1.0.0 in /Users/jacoltman/opt/anaconda3/envs/bartpy/lib/python3.7/site-packages (from yellowbrick) (1.4.1)\n", + "Requirement already satisfied: numpy>=1.13.0 in /Users/jacoltman/opt/anaconda3/envs/bartpy/lib/python3.7/site-packages (from yellowbrick) (1.18.1)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /Users/jacoltman/opt/anaconda3/envs/bartpy/lib/python3.7/site-packages (from matplotlib!=3.0.0,>=2.0.2->yellowbrick) (2.4.6)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /Users/jacoltman/opt/anaconda3/envs/bartpy/lib/python3.7/site-packages (from matplotlib!=3.0.0,>=2.0.2->yellowbrick) (2.8.1)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/jacoltman/opt/anaconda3/envs/bartpy/lib/python3.7/site-packages (from matplotlib!=3.0.0,>=2.0.2->yellowbrick) (1.1.0)\n", + "Requirement already satisfied: six in /Users/jacoltman/opt/anaconda3/envs/bartpy/lib/python3.7/site-packages (from cycler>=0.10.0->yellowbrick) (1.14.0)\n", + "Requirement already satisfied: joblib>=0.11 in /Users/jacoltman/opt/anaconda3/envs/bartpy/lib/python3.7/site-packages (from scikit-learn>=0.20->yellowbrick) (0.14.1)\n", + "Requirement already satisfied: setuptools in /Users/jacoltman/opt/anaconda3/envs/bartpy/lib/python3.7/site-packages (from kiwisolver>=1.0.1->matplotlib!=3.0.0,>=2.0.2->yellowbrick) (45.2.0.post20200210)\n", + "Installing collected packages: yellowbrick\n", + "Successfully installed yellowbrick-1.1\n" + ] + } + ], + "source": [ + "!pip install yellowbrick" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jacoltman/opt/anaconda3/envs/bartpy/lib/python3.7/site-packages/sklearn/utils/deprecation.py:144: FutureWarning: The sklearn.metrics.classification module is deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.metrics. Anything that cannot be imported from sklearn.metrics is now part of the private API.\n", + " warnings.warn(message, FutureWarning)\n" + ] + } + ], + "source": [ + "from yellowbrick.regressor import ResidualsPlot\n", + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "model = get_clean_model()\n", + "visualizer = ResidualsPlot(model)\n", + "visualizer.fit(X_train, y_train) \n", + "visualizer.score(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from yellowbrick.regressor import PredictionError\n", + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "model = get_clean_model()\n", + "visualizer = PredictionError(model)\n", + "visualizer.fit(X_train, y_train) \n", + "visualizer.score(X, y)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/diagnostics/profiling/ols.py b/diagnostics/profiling/ols.py new file mode 100644 index 0000000..5afbe34 --- /dev/null +++ b/diagnostics/profiling/ols.py @@ -0,0 +1,27 @@ +import pandas as pd +import numpy as np + +from bartpy.sklearnmodel import SklearnModel + + +def run(alpha, beta, n_trees, n_regressors, n_burn=50, n_samples=200, n_obsv=1000): + b_true = np.random.uniform(-2, 2, size = n_regressors) + x = np.random.normal(0, 1, size=n_obsv * n_regressors).reshape(n_obsv, n_regressors) + X = pd.DataFrame(x) + y = np.random.normal(0, 0.1, size=n_obsv) + np.array(X.multiply(b_true, axis = 1).sum(axis=1)) + model = SklearnModel(n_samples=n_samples, + n_burn=n_burn, + n_trees=n_trees, + alpha=alpha, + beta=beta, + n_jobs=1, + n_chains=1, + initializer=None, + store_acceptance_trace=False, + store_in_sample_predictions=False) + model.fit(X, y) + model.predict(X) + + +if __name__ == "__main__": + model, x, y = run(0.95, 2., 200, 50, n_obsv=10000) diff --git a/diagnostics/profiling/sin.py b/diagnostics/profiling/sin.py new file mode 100644 index 0000000..7411b4c --- /dev/null +++ b/diagnostics/profiling/sin.py @@ -0,0 +1,22 @@ +import pandas as pd +import numpy as np +from bartpy.sklearnmodel import SklearnModel + +def run(alpha, beta, n_trees, size=100): + x = np.linspace(0, 5, size) + y = np.random.normal(0, 1.0, size=size) + np.sin(x) + X = pd.DataFrame(x) + + model = SklearnModel( + n_samples=50, + n_burn=50, + n_trees=n_trees, + alpha=alpha, + beta=beta, + n_jobs=1, + n_chains=1) + model.fit(X, y) + model.predict(X) + +if __name__ == "__main__": + run(0.95, 2., 200, size=1000) diff --git a/diagnostics/speed/simple.py b/diagnostics/speed/simple.py new file mode 100644 index 0000000..18ddbe7 --- /dev/null +++ b/diagnostics/speed/simple.py @@ -0,0 +1,106 @@ +import pandas as pd +import numpy as np + +from bartpy.sklearnmodel import SklearnModel + + +def ols_with_all_unique_columns(alpha, beta, n_trees, n_regressors, n_burn=50, n_samples=200, n_obsv=1000): + b_true = np.random.uniform(-2, 2, size = n_regressors) + x = np.random.normal(0, 1, size=n_obsv * n_regressors).reshape(n_obsv, n_regressors) + X = pd.DataFrame(x) + y = np.random.normal(0, 0.1, size=n_obsv) + np.array(X.multiply(b_true, axis = 1).sum(axis=1)) + model = SklearnModel(n_samples=n_samples, + n_burn=n_burn, + n_trees=n_trees, + alpha=alpha, + beta=beta, + n_jobs=1, + n_chains=1, + initializer=None, + store_acceptance_trace=False, + store_in_sample_predictions=False) + model.fit(X, y) + return model, x, y + + +def ols_with_all_small_amount_of_duplication(alpha, beta, n_trees, n_regressors, n_burn=50, n_samples=200, n_obsv=1000): + b_true = np.random.uniform(-2, 2, size = n_regressors) + x = np.random.normal(0, 1, size=n_obsv * n_regressors).reshape(n_obsv, n_regressors) + + x[:, :5] = 4 + + X = pd.DataFrame(x) + + y = np.random.normal(0, 0.1, size=n_obsv) + np.array(X.multiply(b_true, axis = 1).sum(axis=1)) + model = SklearnModel(n_samples=n_samples, + n_burn=n_burn, + n_trees=n_trees, + alpha=alpha, + beta=beta, + n_jobs=1, + n_chains=1, + initializer=None, + store_acceptance_trace=False, + store_in_sample_predictions=False) + model.fit(X, y) + return model, x, y + + +def ols_with_significant_categorical_variables(alpha, beta, n_trees, n_regressors, n_burn=50, n_samples=200, n_obsv=1000): + b_true = np.random.uniform(-2, 2, size = n_regressors) + x = np.random.normal(0, 1, size=n_obsv * n_regressors).reshape(n_obsv, n_regressors) + + for i in range(n_regressors //2): + x[:, i] = np.random.binomial(3, 0.5, size=x.shape[0]) + + X = pd.DataFrame(x) + + y = np.random.normal(0, 0.1, size=n_obsv) + np.array(X.multiply(b_true, axis = 1).sum(axis=1)) + model = SklearnModel(n_samples=n_samples, + n_burn=n_burn, + n_trees=n_trees, + alpha=alpha, + beta=beta, + n_jobs=1, + n_chains=1, + initializer=None, + store_acceptance_trace=False, + store_in_sample_predictions=False) + model.fit(X, y) + return model, x, y + + + + +if __name__ == "__main__": + from timeit import default_timer as timer + + all_unique_small_n, all_unique_big_n, some_duplication_small_n, significant_categorical_variables = [None] * 4 + + + start = timer() + all_unique_small_n = ols_with_all_unique_columns(0.95, 2., 200, 50, n_obsv=100) + end = timer() + all_unique_small_n = end - start + + start = timer() + all_unique_big_n = ols_with_all_unique_columns(0.95, 2., 200, 50, n_obsv=100000) + end = timer() + all_unique_big_n = end - start + + start = timer() + some_duplication_small_n = ols_with_all_small_amount_of_duplication(0.95, 2., 200, 50, n_obsv=100) + end = timer() + some_duplication_small_n = end - start + + start = timer() + significant_categorical_variables = ols_with_significant_categorical_variables(0.95, 2., 200, 50, n_obsv=10000) + end = timer() + significant_categorical_variables = end - start + + print({ + "all_unique_small_n": all_unique_small_n, + "all_unique_big_n": all_unique_big_n, + "some_duplication_small_n": some_duplication_small_n, + "significant_categorical_variables": significant_categorical_variables, + }) \ No newline at end of file diff --git a/examples/Comparison of model with sin waves.ipynb b/examples/Comparison of model with sin waves.ipynb deleted file mode 100644 index 49d5b8e..0000000 --- a/examples/Comparison of model with sin waves.ipynb +++ /dev/null @@ -1,905 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Model comparisons\n", - "\n", - "In this notebook, we'll take BartPy through its paces using increasingly complex sin wave models. We'll compare how it performs to two similar models: OLS and catboost.\n", - "\n", - "For the purposes of this exercise, I'm testing out of the box performance. This makes sense, as part of the value prop of BartPy is it's ability to work well without parameter tuning, but it's possible that the scores of all of the models could be improved with parameter tuning" - ], - "execution_count": null, - "outputs": [] - }, - { - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "from matplotlib import pyplot as plt\n", - "import catboost \n", - "from catboost import Pool\n", - "from sklearn.model_selection import cross_val_score\n", - "from sklearn.linear_model import LinearRegression\n", - "from sklearn.metrics import r2_score\n", - "from sklearn.model_selection import KFold\n", - "from copy import deepcopy\n", - "\n", - "from bartpy.sklearnmodel import SklearnModel\n", - "\n", - "%matplotlib inline" - ], - "cell_type": "code", - "outputs": [], - "metadata": {}, - "execution_count": 1 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Set up models" - ], - "execution_count": null, - "outputs": [] - }, - { - "source": [ - "def fit_catboost(X_train, y_train, X_test, y_test):\n", - " eval_cutoff = len(X_train) // 3\n", - " eval_X, eval_y, train_X, train_y = X_train[:eval_cutoff, :], y_train[:eval_cutoff], X_train[eval_cutoff:, :], y_train[eval_cutoff:]\n", - " catboost_model = catboost.CatBoostRegressor()\n", - " catboost_model.fit(Pool(train_X, train_y), eval_set = Pool(eval_X, eval_y), use_best_model=True, verbose=300)\n", - " pred = catboost_model.predict(X_test)\n", - " score = r2_score(y_test, pred)\n", - " return catboost_model, pred, score\n", - "\n", - "def fit_bartpy(X_train, y_train, X_test, y_test):\n", - " model = SklearnModel(n_samples=1000, \n", - " n_burn=200, \n", - " n_trees=200, \n", - " n_chains=4,\n", - " n_jobs=-1,\n", - " store_in_sample_predictions=False)\n", - " model.fit(X_train, y_train)\n", - " pred = model.predict(X_test)\n", - " score = model.score(X_test, y_test)\n", - " return model, pred, score\n", - "\n", - "def fit_linear_model(X_train, y_train, X_test, y_test):\n", - " rebased_x = np.sin(X_train[:, 0]).reshape(-1, 1)\n", - " linear_model = LinearRegression()\n", - " linear_model.fit(rebased_x, y_train)\n", - " pred = linear_model.predict(np.sin(X_test[:, 0]).reshape(-1, 1))\n", - " score = linear_model.score(np.sin(X_test[:, 0]).reshape(-1, 1), y_test)\n", - " return linear_model, pred, score\n", - "\n", - "kf = KFold(2)\n", - "\n", - "def compare_models(X, y, models_funcs = [fit_bartpy, fit_catboost, fit_linear_model]):\n", - " scores, predictions, trained_models, train_splits, test_splits = [], [], [], [], []\n", - "\n", - " for train_index, test_index in kf.split(X):\n", - " trained_models.append([]) \n", - " scores.append([])\n", - " predictions.append([])\n", - " train_splits.append(train_index)\n", - " test_splits.append(test_index)\n", - "\n", - " for f in models_funcs:\n", - " model, pred, score = f(X[train_index, :], y[train_index], X[test_index, :], y[test_index])\n", - " trained_models[-1].append(deepcopy(model))\n", - " predictions[-1].append(pred)\n", - " scores[-1].append(score)\n", - " return scores, predictions, trained_models, train_splits, test_splits" - ], - "cell_type": "code", - "outputs": [], - "metadata": {}, - "execution_count": 2 - }, - { - "source": [ - "def plot_prediction_against_actual(y, predictions, test_splits):\n", - " for p, test_index in zip(predictions, test_splits):\n", - " for m in p:\n", - " plt.scatter(y[test_index], m)\n", - " plt.title(\"Preicted V Actual Per Model\")\n", - " plt.xlabel(\"True Target\")\n", - " plt.ylabel(\"Predicted Target\")\n", - "\n", - "def plot_covariate_against_prediction(X, predictions, test_splits, split_index, feature_index):\n", - " test_index = test_splits[split_index]\n", - " plt.scatter(X[test_index, feature_index],predictions[split_index][1], label=\"catboost\")\n", - " plt.scatter(X[test_index, feature_index],predictions[split_index][2], label=\"OLS\")\n", - " plt.scatter(X[test_index, feature_index],predictions[split_index][0], label=\"bartpy\")\n", - " plt.ylabel(\"Prediction\")\n", - " plt.xlabel(\"Covariate\")\n", - " plt.title(\"Prediction by model by value of X\")\n", - " plt.legend(loc=\"best\")" - ], - "cell_type": "code", - "outputs": [], - "metadata": {}, - "execution_count": 3 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## One dimensional, single wave" - ], - "execution_count": null, - "outputs": [] - }, - { - "source": [ - "x = np.linspace(0, 5, 3000)\n", - "X = pd.DataFrame(x).sample(frac=1.0).values\n", - "y = np.random.normal(0, 0.1, size=3000) + np.sin(X[:, 0])\n", - "plt.scatter(X[:, 0], y)\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.title(\"X v y\")" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": "Text(0.5, 1.0, 'X v y')" - }, - "metadata": {}, - "execution_count": 4 - }, - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 4 - }, - { - "source": [ - "scores, predictions, models, train_splits, test_splits = compare_models(X, y)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": "Learning rate set to 0.046077\n0:\tlearn: 0.7025332\ttest: 0.6984980\tbest: 0.6984980 (0)\ttotal: 56.4ms\tremaining: 56.3s\n300:\tlearn: 0.0923884\ttest: 0.0970714\tbest: 0.0967830 (158)\ttotal: 257ms\tremaining: 597ms\n600:\tlearn: 0.0883887\ttest: 0.0982320\tbest: 0.0967830 (158)\ttotal: 483ms\tremaining: 321ms\n900:\tlearn: 0.0863563\ttest: 0.0991067\tbest: 0.0967830 (158)\ttotal: 726ms\tremaining: 79.8ms\n999:\tlearn: 0.0859201\ttest: 0.0994788\tbest: 0.0967830 (158)\ttotal: 809ms\tremaining: 0us\n\nbestTest = 0.09678304152\nbestIteration = 158\n\nShrink model to first 159 iterations.\nLearning rate set to 0.046077\n0:\tlearn: 0.6880031\ttest: 0.6723999\tbest: 0.6723999 (0)\ttotal: 1.74ms\tremaining: 1.74s\n300:\tlearn: 0.0979395\ttest: 0.1020531\tbest: 0.1007809 (150)\ttotal: 286ms\tremaining: 663ms\n600:\tlearn: 0.0942788\ttest: 0.1041898\tbest: 0.1007809 (150)\ttotal: 539ms\tremaining: 358ms\n900:\tlearn: 0.0925689\ttest: 0.1056040\tbest: 0.1007809 (150)\ttotal: 784ms\tremaining: 86.1ms\n999:\tlearn: 0.0921997\ttest: 0.1059786\tbest: 0.1007809 (150)\ttotal: 866ms\tremaining: 0us\n\nbestTest = 0.100780855\nbestIteration = 150\n\nShrink model to first 151 iterations.\n" - } - ], - "metadata": {}, - "execution_count": 5 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**As we might expect, all three models are capable of capturing such a simple function. There's very little difference between the scores or predictions of the models.**" - ], - "execution_count": null, - "outputs": [] - }, - { - "source": [ - "scores" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": "[[0.979240152760104, 0.9789337911646875, 0.9798112313922381],\n [0.9818140178185625, 0.981869261398282, 0.9823333307052863]]" - }, - "metadata": {}, - "execution_count": 6 - } - ], - "metadata": {}, - "execution_count": 6 - }, - { - "source": [ - "plot_prediction_against_actual(y, predictions, test_splits)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 7 - }, - { - "source": [ - "plot_covariate_against_prediction(X, predictions, test_splits, 1, 0)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 8 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Single dimension - multiple waves\n", - "\n", - "** To extend our original model, let's add a high frequency cosine wave in our single dimension. This will make the predicted function change faster and at varying rates across x **" - ], - "execution_count": null, - "outputs": [] - }, - { - "source": [ - "x = np.linspace(0, 5, 3000)\n", - "X = pd.DataFrame(x).sample(frac=1.0).values\n", - "y = np.random.normal(0, 0.1, size=3000) + np.sin(X[:, 0]) + np.cos(5 * X[:, 0])\n", - "plt.scatter(X[:, 0], y)\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.title(\"X v y\")" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": "Text(0.5, 1.0, 'X v y')" - }, - "metadata": {}, - "execution_count": 9 - }, - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 9 - }, - { - "source": [ - "scores, predictions, models, train_splits, test_splits = compare_models(X, y)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": "Learning rate set to 0.046077\n0:\tlearn: 0.9485227\ttest: 0.9899281\tbest: 0.9899281 (0)\ttotal: 1.59ms\tremaining: 1.59s\n300:\tlearn: 0.1013880\ttest: 0.1072979\tbest: 0.1072979 (300)\ttotal: 246ms\tremaining: 571ms\n600:\tlearn: 0.0954432\ttest: 0.1069481\tbest: 0.1064541 (397)\ttotal: 511ms\tremaining: 339ms\n900:\tlearn: 0.0933128\ttest: 0.1081105\tbest: 0.1064541 (397)\ttotal: 782ms\tremaining: 85.9ms\n999:\tlearn: 0.0927988\ttest: 0.1083851\tbest: 0.1064541 (397)\ttotal: 866ms\tremaining: 0us\n\nbestTest = 0.1064541285\nbestIteration = 397\n\nShrink model to first 398 iterations.\nLearning rate set to 0.046077\n0:\tlearn: 0.9818705\ttest: 0.9822582\tbest: 0.9822582 (0)\ttotal: 962us\tremaining: 962ms\n300:\tlearn: 0.1024520\ttest: 0.1180349\tbest: 0.1180329 (298)\ttotal: 256ms\tremaining: 596ms\n600:\tlearn: 0.0955009\ttest: 0.1175944\tbest: 0.1173868 (504)\ttotal: 522ms\tremaining: 347ms\n900:\tlearn: 0.0928601\ttest: 0.1180401\tbest: 0.1173868 (504)\ttotal: 787ms\tremaining: 86.4ms\n999:\tlearn: 0.0922364\ttest: 0.1182714\tbest: 0.1173868 (504)\ttotal: 876ms\tremaining: 0us\n\nbestTest = 0.1173868018\nbestIteration = 504\n\nShrink model to first 505 iterations.\n" - } - ], - "metadata": {}, - "execution_count": 10 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "** Catboost and BartPy capture this faster moving sin wave pretty nicely, and come up with very similar predictions. The linear model pretty much treats the cos wave as noise, and fits a curve close to the original one **" - ], - "execution_count": null, - "outputs": [] - }, - { - "source": [ - "plot_prediction_against_actual(y, predictions, test_splits)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 11 - }, - { - "source": [ - "plot_covariate_against_prediction(X, predictions, test_splits, 1, 0)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 12 - }, - { - "source": [ - "import seaborn as sns\n", - "p = pd.DataFrame(np.array(predictions[1]).T, columns = [\"bartpy\", \"catboost\", \"OLS\"])\n", - "sns.pairplot(p)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": "" - }, - "metadata": {}, - "execution_count": 13 - }, - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 13 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Single dimension - discrete break points\n", - "\n", - "** To make the model more complex, let's add some discrete dumps to make the curve less smooth. This will test the ability of the models to handle very isolated effects in feature space **" - ], - "execution_count": null, - "outputs": [] - }, - { - "source": [ - "x = np.linspace(0, 5, 3000)\n", - "X = pd.DataFrame(x).sample(frac=1.0).values\n", - "y = np.random.normal(0, 0.1, size=3000) + np.sin(X[:, 0]) + np.cos(5 * X[:, 0])\n", - "y[(X[:,0] < 1.5) & (X[:,0] > 1.)] += 3\n", - "y[(X[:,0] < 3.5) & (X[:,0] > 3.)] -= 3\n", - "plt.scatter(X[:, 0], y)\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.title(\"X v y\")" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": "Text(0.5, 1.0, 'X v y')" - }, - "metadata": {}, - "execution_count": 14 - }, - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 14 - }, - { - "source": [ - "scores, predictions, models, train_splits, test_splits = compare_models(X, y)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": "Learning rate set to 0.046077\n0:\tlearn: 1.9630556\ttest: 1.9187768\tbest: 1.9187768 (0)\ttotal: 1.42ms\tremaining: 1.42s\n300:\tlearn: 0.1828203\ttest: 0.1931937\tbest: 0.1931937 (300)\ttotal: 245ms\tremaining: 568ms\n600:\tlearn: 0.1700359\ttest: 0.1810160\tbest: 0.1810160 (600)\ttotal: 466ms\tremaining: 310ms\n900:\tlearn: 0.1674174\ttest: 0.1794306\tbest: 0.1794167 (882)\ttotal: 685ms\tremaining: 75.3ms\n999:\tlearn: 0.1669206\ttest: 0.1790912\tbest: 0.1790887 (996)\ttotal: 764ms\tremaining: 0us\n\nbestTest = 0.1790886711\nbestIteration = 996\n\nShrink model to first 997 iterations.\nLearning rate set to 0.046077\n0:\tlearn: 2.0548603\ttest: 2.0016480\tbest: 2.0016480 (0)\ttotal: 1.27ms\tremaining: 1.27s\n300:\tlearn: 0.2146599\ttest: 0.2410188\tbest: 0.2409787 (299)\ttotal: 210ms\tremaining: 488ms\n600:\tlearn: 0.2029724\ttest: 0.2323946\tbest: 0.2323858 (597)\ttotal: 444ms\tremaining: 295ms\n900:\tlearn: 0.2005487\ttest: 0.2311126\tbest: 0.2311094 (896)\ttotal: 686ms\tremaining: 75.4ms\n999:\tlearn: 0.2001254\ttest: 0.2308372\tbest: 0.2308372 (999)\ttotal: 757ms\tremaining: 0us\n\nbestTest = 0.2308371709\nbestIteration = 999\n\n" - } - ], - "metadata": {}, - "execution_count": 15 - }, - { - "source": [ - "scores" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": "[[0.9891212322011914, 0.9918080856331236, 0.29495395350129483],\n [0.9925583798088817, 0.9864558649069506, 0.31426717560135164]]" - }, - "metadata": {}, - "execution_count": 16 - } - ], - "metadata": {}, - "execution_count": 16 - }, - { - "source": [ - "plot_prediction_against_actual(y, predictions, test_splits)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 17 - }, - { - "source": [ - "plot_covariate_against_prediction(X, predictions, test_splits, 1, 0)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 18 - }, - { - "source": [ - "import seaborn as sns\n", - "p = pd.DataFrame(np.array(predictions[1]).T, columns = [\"bartpy\", \"catboost\", \"OLS\"])\n", - "sns.pairplot(p)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": "" - }, - "metadata": {}, - "execution_count": 19 - }, - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 19 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Single meaningful dimension - additional noise dimensions\n", - "\n", - "** It's important for the models to be able to correctly identify features that aren't important. In this case, we just add normally distributed noise features. This shouldn't be too difficult a problem to solve **" - ], - "execution_count": null, - "outputs": [] - }, - { - "source": [ - "x = np.linspace(0, 5, 3000)\n", - "X = np.random.normal(0, 3, size = 3000 * 8).reshape(3000, 8)\n", - "X[:, 0] = x\n", - "X = pd.DataFrame(X).sample(frac=1.0).values\n", - "y = np.random.normal(0, 0.1, size=3000) + np.sin(X[:, 0])\n", - "plt.scatter(X[:, 0], y)\n", - "plt.scatter(X[:, 1], y)\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.title(\"X v y\")" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": "Text(0.5, 1.0, 'X v y')" - }, - "metadata": {}, - "execution_count": 20 - }, - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 20 - }, - { - "source": [ - "scores, predictions, models, train_splits, test_splits = compare_models(X, y)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": "Learning rate set to 0.046077\n0:\tlearn: 0.6902375\ttest: 0.6749551\tbest: 0.6749551 (0)\ttotal: 2.99ms\tremaining: 2.99s\n300:\tlearn: 0.0692805\ttest: 0.1067056\tbest: 0.1053449 (157)\ttotal: 394ms\tremaining: 916ms\n600:\tlearn: 0.0493094\ttest: 0.1085172\tbest: 0.1053449 (157)\ttotal: 711ms\tremaining: 472ms\n900:\tlearn: 0.0360980\ttest: 0.1099309\tbest: 0.1053449 (157)\ttotal: 1.01s\tremaining: 111ms\n999:\tlearn: 0.0326738\ttest: 0.1102993\tbest: 0.1053449 (157)\ttotal: 1.08s\tremaining: 0us\n\nbestTest = 0.1053449052\nbestIteration = 157\n\nShrink model to first 158 iterations.\nLearning rate set to 0.046077\n0:\tlearn: 0.6952048\ttest: 0.6885760\tbest: 0.6885760 (0)\ttotal: 1.83ms\tremaining: 1.83s\n300:\tlearn: 0.0733799\ttest: 0.1068581\tbest: 0.1067496 (191)\ttotal: 301ms\tremaining: 699ms\n600:\tlearn: 0.0511122\ttest: 0.1084341\tbest: 0.1067496 (191)\ttotal: 616ms\tremaining: 409ms\n900:\tlearn: 0.0368398\ttest: 0.1093515\tbest: 0.1067496 (191)\ttotal: 914ms\tremaining: 100ms\n999:\tlearn: 0.0333289\ttest: 0.1096700\tbest: 0.1067496 (191)\ttotal: 994ms\tremaining: 0us\n\nbestTest = 0.1067496021\nbestIteration = 191\n\nShrink model to first 192 iterations.\n" - } - ], - "metadata": {}, - "execution_count": 21 - }, - { - "source": [ - "scores" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": "[[0.9770079447936509, 0.9778809433148894, 0.9803351575876399],\n [0.9766251937157352, 0.9786380763434477, 0.9805387346487965]]" - }, - "metadata": {}, - "execution_count": 22 - } - ], - "metadata": {}, - "execution_count": 22 - }, - { - "source": [ - "plot_prediction_against_actual(y, predictions, test_splits)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 23 - }, - { - "source": [ - "plot_covariate_against_prediction(X, predictions, test_splits, 1, 0)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 24 - }, - { - "source": [ - "import seaborn as sns\n", - "p = pd.DataFrame(np.array(predictions[1]).T, columns = [\"bartpy\", \"catboost\", \"OLS\"])\n", - "sns.pairplot(p)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": "" - }, - "metadata": {}, - "execution_count": 25 - }, - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 25 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Mixture of multiple meaningful dimensions and noise dimensions\n", - "\n", - "** Both catboost and BartPy have performed well with noise dimensions and rapidly moving targets, let's combine them to make a relatively difficult test for tree models **\n", - "\n", - "BartPy does significantly worse than catboost in this test. It can't match the very rapidly moving cos wave, while catboost does an excellent job." - ], - "execution_count": null, - "outputs": [] - }, - { - "source": [ - "X = np.random.normal(0, 3, size = 3000 * 8).reshape(3000, 8)\n", - "X = pd.DataFrame(X).sample(frac=1.0).values\n", - "y = np.random.normal(0, 0.1, size=3000) + np.sin(X[:, 0]) + np.sin(5 * X[:, 1]) + np.cos(-6 * X[:, 3])\n", - "plt.scatter(X[:, 0], y)\n", - "plt.scatter(X[:, 1], y)\n", - "plt.scatter(X[:, 3], y)\n", - "\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.title(\"X v y\")\n", - "" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": "Text(0.5, 1.0, 'X v y')" - }, - "metadata": {}, - "execution_count": 26 - }, - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 26 - }, - { - "source": [ - "scores, predictions, models, train_splits, test_splits = compare_models(X, y)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": "Learning rate set to 0.046077\n0:\tlearn: 1.2061165\ttest: 1.2020891\tbest: 1.2020891 (0)\ttotal: 2.64ms\tremaining: 2.64s\n300:\tlearn: 0.5199855\ttest: 0.7841135\tbest: 0.7841135 (300)\ttotal: 313ms\tremaining: 726ms\n600:\tlearn: 0.2746953\ttest: 0.6326910\tbest: 0.6326910 (600)\ttotal: 618ms\tremaining: 410ms\n900:\tlearn: 0.1761277\ttest: 0.5875634\tbest: 0.5875634 (900)\ttotal: 937ms\tremaining: 103ms\n999:\tlearn: 0.1554583\ttest: 0.5778688\tbest: 0.5778688 (999)\ttotal: 1.01s\tremaining: 0us\n\nbestTest = 0.5778688273\nbestIteration = 999\n\nLearning rate set to 0.046077\n0:\tlearn: 1.2538038\ttest: 1.2056868\tbest: 1.2056868 (0)\ttotal: 1.94ms\tremaining: 1.93s\n300:\tlearn: 0.5172745\ttest: 0.7356682\tbest: 0.7356682 (300)\ttotal: 334ms\tremaining: 775ms\n600:\tlearn: 0.2888642\ttest: 0.6001392\tbest: 0.6001392 (600)\ttotal: 666ms\tremaining: 442ms\n900:\tlearn: 0.1873105\ttest: 0.5505221\tbest: 0.5505221 (900)\ttotal: 1s\tremaining: 110ms\n999:\tlearn: 0.1630441\ttest: 0.5428900\tbest: 0.5428900 (999)\ttotal: 1.09s\tremaining: 0us\n\nbestTest = 0.5428899564\nbestIteration = 999\n\n" - } - ], - "metadata": {}, - "execution_count": 27 - }, - { - "source": [ - "scores" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": "[[0.4640142748387709, 0.7813636989737592, 0.3647061306501107],\n [0.44852802164754024, 0.7887514128067696, 0.3478875822169615]]" - }, - "metadata": {}, - "execution_count": 28 - } - ], - "metadata": {}, - "execution_count": 28 - }, - { - "source": [ - "plot_prediction_against_actual(y, predictions, test_splits)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 29 - }, - { - "source": [ - "plot_covariate_against_prediction(X, predictions, test_splits, 1, 0)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 30 - }, - { - "source": [ - "plot_covariate_against_prediction(X, predictions, test_splits, 1, 1)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 31 - }, - { - "source": [ - "plot_covariate_against_prediction(X, predictions, test_splits, 1, 3)" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 32 - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4-final" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} \ No newline at end of file diff --git a/examples/Cross Validation.ipynb b/examples/Cross Validation.ipynb index 6435179..078d87c 100644 --- a/examples/Cross Validation.ipynb +++ b/examples/Cross Validation.ipynb @@ -12,6 +12,10 @@ ] }, { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", @@ -20,147 +24,159 @@ "%matplotlib inline\n", "\n", "from bartpy.sklearnmodel import SklearnModel" - ], - "cell_type": "code", - "outputs": [], - "metadata": {}, - "execution_count": 1 + ] }, { - "source": [ - "# Start by creating some synthetic data to play with\n", - "\n", - "x = np.random.normal(0, 0.5, size=1000)\n", - "X = pd.DataFrame({\"x\": x})\n", - "y = 2 * x + 4 * np.power(x, 3)\n", - "plt.scatter(x, y)" - ], "cell_type": "code", + "execution_count": 2, + "metadata": {}, "outputs": [ { - "output_type": "execute_result", "data": { - "text/plain": "" + "text/plain": [ + "" + ] }, + "execution_count": 2, "metadata": {}, - "execution_count": 2 + "output_type": "execute_result" }, { - "output_type": "display_data", "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" + "image/png": "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\n", + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } ], - "metadata": {}, - "execution_count": 2 + "source": [ + "# Start by creating some synthetic data to play with\n", + "\n", + "x = np.random.normal(0, 0.5, size=1000)\n", + "X = pd.DataFrame({\"x\": x})\n", + "y = 2 * x + 4 * np.power(x, 3)\n", + "plt.scatter(x, y)" + ] }, { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], "source": [ "# Create an instance of the Sklearn class\n", "# Set parameters to make the model very small and fast for exposition purposes\n", "model = SklearnModel(n_burn=50, n_chains=1, n_jobs=1, n_samples=50, n_trees=10)" - ], - "cell_type": "code", - "outputs": [], - "metadata": {}, - "execution_count": 3 + ] }, { - "source": [ - "# Quickly train and visually inspect that the results look good\n", - "model.fit(X, y)\n", - "plt.scatter(x, model.predict(X))\n", - "plt.scatter(x, y)" - ], "cell_type": "code", + "execution_count": 5, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stderr", - "text": "100%|██████████| 50/50 [00:00<00:00, 253.52it/s]\n 0%| | 0/50 [00:00" + "text/plain": [ + "" + ] }, + "execution_count": 5, "metadata": {}, - "execution_count": 5 + "output_type": "execute_result" }, { - "output_type": "display_data", "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" + "image/png": "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\n", + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } ], - "metadata": {}, - "execution_count": 5 + "source": [ + "# Quickly train and visually inspect that the results look good\n", + "model.fit(X, y)\n", + "plt.scatter(x, model.predict(X))\n", + "plt.scatter(x, y)" + ] }, { - "source": [ - "# Score the model using cross validation\n", - "from sklearn.model_selection import cross_val_score\n", - "scores = cross_val_score(model, X, y)\n", - "scores" - ], "cell_type": "code", + "execution_count": 6, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stderr", - "text": "/opt/anaconda3/lib/python3.7/site-packages/sklearn/model_selection/_split.py:1978: FutureWarning: The default value of cv will change from 3 to 5 in version 0.22. Specify it explicitly to silence this warning.\n warnings.warn(CV_WARNING, FutureWarning)\n 46%|████▌ | 23/50 [00:00<00:00, 228.78it/s]Starting burn\n100%|██████████| 50/50 [00:00<00:00, 238.75it/s]\n100%|██████████| 50/50 [00:00<00:00, 265.64it/s]\n 0%| | 0/50 [00:00)" - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model = get_clean_model()\n", - "model.fit(X, y)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": "" - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "text/plain": "
" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(model.predict(X), y)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": "" - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "text/plain": "
" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(X[:, 0], model.predict(X))\n", - "plt.scatter(X[:, 0], y)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": "2020-02-05 08:45:31.178163\n2020-02-05 08:47:50.598099\nLearning rate set to 0.043074\n0:\tlearn: 153.8237301\ttest: 170.9859251\tbest: 170.9859251 (0)\ttotal: 55.7ms\tremaining: 55.6s\n300:\tlearn: 11.7652868\ttest: 41.8285107\tbest: 41.8285107 (300)\ttotal: 869ms\tremaining: 2.02s\n600:\tlearn: 4.9212923\ttest: 37.3946619\tbest: 37.3946619 (600)\ttotal: 1.68s\tremaining: 1.11s\n900:\tlearn: 2.6105102\ttest: 36.5869786\tbest: 36.5869786 (900)\ttotal: 2.46s\tremaining: 271ms\n999:\tlearn: 2.1047594\ttest: 36.4953980\tbest: 36.4953980 (999)\ttotal: 2.73s\tremaining: 0us\n\nbestTest = 36.49539798\nbestIteration = 999\n\n2020-02-05 08:47:53.511703\n2020-02-05 08:47:53.512103\n2020-02-05 08:49:55.523054\nLearning rate set to 0.043074\n0:\tlearn: 165.3079260\ttest: 160.2259262\tbest: 160.2259262 (0)\ttotal: 2.28ms\tremaining: 2.28s\n300:\tlearn: 11.5576619\ttest: 33.1391005\tbest: 33.1391005 (300)\ttotal: 537ms\tremaining: 1.25s\n600:\tlearn: 4.8629551\ttest: 29.1160878\tbest: 29.1160878 (600)\ttotal: 906ms\tremaining: 601ms\n900:\tlearn: 2.5112892\ttest: 28.5680536\tbest: 28.5663171 (899)\ttotal: 1.29s\tremaining: 142ms\n999:\tlearn: 2.0676432\ttest: 28.4768475\tbest: 28.4768475 (999)\ttotal: 1.48s\tremaining: 0us\n\nbestTest = 28.4768475\nbestIteration = 999\n\n2020-02-05 08:49:57.176635\n" - } - ], - "source": [ - "from sklearn.model_selection import KFold\n", - "from datetime import datetime\n", - "from catboost import CatBoostRegressor, Pool\n", - "kf = KFold(n_splits=2, shuffle=True)\n", - "b_scores, c_scores = [], []\n", - "for train_index, test_index in kf.split(X):\n", - " print(datetime.now())\n", - " model = get_clean_model()\n", - " model.fit(X[train_index], y[train_index])\n", - " b_scores.append(np.sum(np.square(y[test_index] - model.predict(X[test_index]))))\n", - " print(datetime.now())\n", - " eval_pool = Pool(X[train_index][:300,:], y[train_index][:300])\n", - " train_pool = Pool(X[train_index][300:,:], y[train_index][300:])\n", - " c_model = CatBoostRegressor()\n", - " c_model.fit(train_pool, eval_set=eval_pool, verbose=300)\n", - " c_scores.append(np.sum(np.square(y[test_index] - c_model.predict(X[test_index]))))\n", - " print(datetime.now())" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": "[964705.2906824035, 1016191.4718016029]\n[1179905.8774384584, 880745.2650863533]\n" - } - ], - "source": [ - "print(b_scores)\n", - "print(c_scores)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": "(0.491097060335939, 0.5431173624177509)" - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.sqrt(b_scores[0]) / X.shape[0], np.sqrt(c_scores[0]) / X.shape[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": "" - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "text/plain": "
" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(model.predict(X[test_index]), y[test_index])\n", - "plt.scatter(c_model.predict(X[test_index]), y[test_index])" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": "0.9755208151788579" - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "text/plain": "
" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from yellowbrick.regressor import ResidualsPlot\n", - "from sklearn.model_selection import train_test_split\n", - "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", - "model = get_clean_model()\n", - "visualizer = ResidualsPlot(model)\n", - "visualizer.fit(X_train, y_train) \n", - "visualizer.score(X, y)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": "0.9700097741424252" - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeoAAAFJCAYAAABU5W56AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdebzdVX3v/9f6Dns8Y06SkxlCCAQSQEhkDCFMaq2iVhQccLy3XrEg9j7UVq3a1taB+6O91Gq1v9oqYFGkIrUOlEg4jAEiAU4ImQmZzjzt8Tuu+8f37J0zD/ucJCfk83w8eEjOPvu7v3s/Iu+91vqsz1Jaa40QQgghZiTjeN+AEEIIIUYnQS2EEELMYBLUQgghxAwmQS2EEELMYBLUQgghxAxmHe8bGCoMQ3K5HLZto5Q63rcjhBBCHFVaazzPI51OYxjDx88zLqhzuRw7duw43rchhBBCHFNnnHEG1dXVw34+44Latm0guuFYLHac7+boam5uZtWqVcf7NmYU+UyGk89kOPlMBpPPY7jJfCZuENCdd6lPxYiZ5qRfyw0CPnnfJrYc6iLIZ+Gpn8PB7QCoZRdw3js+yPc/cMWo13Zdlx07dpTzb6gZF9Sl6e5YLEY8Hj/Od3P0nQzvcbLkMxlOPpPh5DMZTD6P4cb7TIIw5M6mbWzc3UpnzqEhHWf9skZuXXcW5ghT0KPp7M3zam8RVxt0vPYq/L4JYkm44v2Eyy7gvYvnUZ1KjXud0ZZ7Z1xQCyGEEMfCnU3beHDrAQyliFsmWcfnwa0HAPjM+pWjPs/xg3Kwxy2T+qRNQzpOzDLhzHPpynyAYNFZ2LUNNFYl+NxVU5vtkKAWQghx0nH8gI27WzGGjGINpdi4u5Wb164gbg2eqg7CkDse2crDO1vIOB5zqhKcbed54l9u5/zr/wcvGnNZXJdm4dVvwws0pgHvXLWYVGzkKe2JkqAWQghx0unMOXTmnGFhDNCVjx5bUHtkujoIQ979rxt54tV2vEBjGbD/sV/zeNNP0b5Hbc1Pue5/f4ONu1vpyg+eRp8qCWohhBAnnYZ0nIZ0nKzjD3tsVip6bKBv/a6Zx/a0oQGjkCHceBe5fc0ANL7xSn541w+YVVfLzWtXDJoWnw4S1EIIIU46cctk/bLG8hp1Sag165c1lkO2NN3994++QsbxsQ6+TLzpHlQhA7EkxpUfYNYl6ykqu3zdgSPxiXCDYMzHJaiFEEKclErT0qXp6lmp4dPVdzZt4+fN+3H8AOU7xPpDOpy/HOOaD+OnZ1EVs4eNwCeiVHX+/P42Pn12zai/J0EthBDipGQaBp9Zv3LU6epSwVncMrEtAy+exLn8A5hdB/HOuZp0IoZtKK5ZPq+iae5S1XlDfOznSlALIYQ4YQzdGjUdRpuu7sgW2fm7/0R5RerPexN+UMQ9ZRXe4rPRGhRw2alz+NMrR9/KNZrRqs5HIkEthBBixpuu5iQjGSn829rauO1P/oSWhx8GpThr1cWQrqG76OIFirhpctsVK/jcVavKrz+ZLxFjVZ0PJUEthBBixqu0OclQA8PUMtSI4X+Wc4BP33or7e3tJKqqaXzbx0nMns9iYKFO4fgB71q1mM9efQ5Q2ZeIsarOh5KgFkIIMaNV0pxkqJHCVAE9BRfTMIhbJn3ZPN/91tfoePq3AKxbt45/+Pa3+dmu3kEFZ2uXLuTG85fi+AFxy6zoS8TAqvPxSFALIYSY0SbbnGQkQ8O0r+jRfLib+mScxfVpAA7++i46nvlvlGHyxS9+kds+fSuGYfCZRYu4ee0K2jIF7v39Xh7f28YvmvfTkI6z9tQ5PLa3vaIvEaXq8uf3t41571Oa2O/s7OSKK65g9+7d7Nu3j/e97328//3v5ytf+QphGALw7W9/m+uvv54bb7yRF198cSovJ4QQ4iRUmiYeyUjNSYYaaUTuBRo/hO6iS6g1APPWv4v0kjNY+j//khs/9seDzoaOWyY/e2Efv3rlEFnHL4+cf968n+aWnhFft/QlYjSlqvN/fPdFY95/xUHteR5f/vKXSSQSAHz961/ntttu48c//jFaazZs2MDWrVt55plnuO+++7jjjjv4y7/8y0pfTgghxEnG8QMO9eYBWL+ssRyoJUObk4ymNCIfyDYVlpPBf/IBXC9aJ7ZrZrH8f/4lC09fMSz8R5t+j1smBc8fdm8wsS8RwLhHa1Y89f3Nb36TG2+8ke9///sAbN26lQsvvBCI5vWfeOIJli5dytq1a1FKsWDBAoIgoKuri1mzZlX6skIIIV7nRlpPXreskbedvZCmPW2jNicZzcDCrVBrvEBT2PU84f3/hCpk6JnbwLzLrwNAw4jhP9r0u6EUKdvE8UOS9pHHJvolYiIqCur/+I//YNasWVx++eXloNZal8/STKfTZDIZstksdXV15eeVfj6RoG5ubq7k1k44mzdvPt63MOPIZzKcfCbDyWcy2Ovp87hnWydNB/rKo9fDhTz/3t7FukU1/Nk59fQ6KWrjJjGzyJbnn8cNQnqdoP9nRyaKB34mp8U87t/XRbbgED71c4yXHwMgfeoKas+4gK7ePmpiJqsb01yWLgz7PN0gxPSKZArhsPtdmFCcX6/Y0p6jzw3GvE4lKgrq+++/H6UUTz31FNu2bePzn/88XV1d5cdzuRw1NTVUVVWRy+UG/by6unpCr7Fq1arX/UHomzdvZvXq1cf7NmYU+UyGk89kOPlMBns9fR6OH7B7y6PU1gxvqbnbsbjgggsG9eEebVvUluefH/SZbOxrxtj8Cvzy+xhdh8EwSa59F5++5U+45YqVw/Y/j7Qn+p351Ii9wa9buYjPrF9ZcTMWx3HGHJxWFNT33HNP+d9vuukmvvrVr3L77bezadMmLrroIpqamrj44otZsmQJt99+Ox//+MdpaWkhDEOZ9hZCCDGqyVR4j7Utat2AMaHjB/zXo0+SuedvIPCJNcznlPfeQtXC03js1Q5uuYLyNccK//F6g1dyIMdETNv2rM9//vP8xV/8BXfccQennXYab37zmzFNkzVr1nDDDTcQhiFf/vKXp+vlhBBCvA5N9PjJ8fZWX3zOkaTuzDk4dQtJL15OfPYCFr71JsxYVAg9mfD/zPqVY/YGP1qmHNR33XVX+d/vvvvuYY/fcsst3HLLLVN9GSGEECeBiR4/Od7Iu9dJ8dBDD3HOOefQMGcus6uTxD7yBQzLHvS7kwn/0p7oozVyHs3UGqQKIYQQ0+zWdWdx3cpFVMUt3CCgKm5x3cpFgyq8SyPvUGscPxy0ParWhnv++bvceOON3HzzzdiGYv2yRjAHj01HC/+RjLcn+miSzmRCCCFmlPGOnwSwDIUCmg9344fRvui6ZIz6fDv7H/wuHQf2Yds2V199NTCxs6cnOu1+rElQCyGEmJHGmmK+s2kbPQWX+mSc7qKL6wd0PvVrOp9+AB34LF68mLvvvptzzjmn/Jzxwn+i0+7HmgS1EEKIE0ppLdk0DBbXp1kQJNhz17fI7noBgA99+CO85/p3DwrpkvHWlweOvDtyRapiNtcsnz+hxipHi6xRCyGEOCGUWooe6s0PWi82TZOqxadjpqpZ/L7P8Lmvfq3c3nqyTMPg1nVnsXbpXKpiMTKOz+OvtnNn0zaCcHizk2NBRtRCCCGOi4k2CMm7Ht/6XTPP7e+ip+BSl4zRlclQW+ghteBUAOat/yNmX3gt9bNn05COc3gK93Vn0zZ+te0ghlIk7crPvp4uEtRCCCGOqbGaipgDTqwq/d4PNu1if08e2zKoT8Tw216j/d47aS1mWXnr/8GuqkWZJmZV7ZTXkqfj7OvpJkEthBBiWkx0hDxeU5GBv/dA835as0VMQxEEAR1P/pKOTQ9CGGA1LMDyCrhB1aQO6RjLdJx9Pd0kqIUQQkzJREfIMHjEGp1kFWKbxrARa+n3vDDaJ20WeuF3P4IDrwDQcOG1zL32ffzLR68mbprlLweOH9CayeMGla0nz8QtWhLUQgghpmSiI2QgKgbrydNTcOlxPLxAY5uK+kSMudXx8oi1LVPgpcM9ZBwPb+9LGI/ehXJykKgiXP9BGi++nIZ0nAU1KeKWSRCG/N3GreUvC6ZX5J351IhfFsYyE7doSVALIYSo2EhruqUznzfsbCmPkEuj7g07W3i5vRfPD7ENg7hlEIbQkSsSs43yiPXuZ3fTW3DRWmPYMXDy+AtXEKy/iVTdLMz+bmOl4Bz6ZSFTCCsuAJtIc5RjSYJaCCFExQau6WrgQE+OnoKLF2hMQ/HXD23hE5ecyb3Pv8qvth0EwEABCjcMwYeEbYJSKB1No9/+u23834eeoWCk8MMQe/5y3Ld9Gn/uqWgUc9MJ3rlqcTk4Ky0AG21NfSKd0Y4lCWohhBATNjTcBq7pHujJ0ZFz+mNYU/QDvvfkLu7Z/CoFLyAVs9Ba4wYhQX9vbicIScZMGlJxapMxvvnwS9z7b/+C88h9JN56M868M3D9ALNxKWnbIh23+P57L2bNktnlKe3JFoBNdE39WB++MRoJaiGEEOMaK9zWL2vkgeb99BRcSmNaxw/QgBeEtGULeIGmo79JiR5wXQ1oDYtqU5iFXn70la/Tu7s5us6hXdC4HAAvhF7HJ+P6fODuxzh3wSyuPD16/ckWgE1mTX0mkKAWQggxrrHC7ROXnsGB3jzNh3sINJhK42sNKLKuPyiYR5JxPHY+8xjBI3dRzGaw0jWk3vQR2huW4wTh4GDX0J51eKWtl4zjAVG4TrQAbCbukx6PBLUQQogxjRZuSil+sGkXG3a20JV3sU1FrW0Rak1f0Qelxw1pPIfYMz8nt+MpAOrPfAML3/m/MKpq6Xytc/DrAYah8HVId95hYW2qHK5DC8CSljHsaEyYmfukxyNBLYQQYkyjhduBnhxt2SLVCRtDKarjNu3ZIn4QxXM4bkqDCjys/c1gWnz+i1/CPvdKfvHyQfKOh2EoDKXQaLQG01BoIAzBDUK8QA8K14EFYPu2b+WSC4dPY8/EfdLjkUM5hBBCjKkUbgOFWtNdcAkCzY72PppbeukpepiGohiEjNluRIcQBtG/Jqoorv8I1nv+jD/+4z9GGwZdOYddHVmKvo9GEzMNTCNqkBKGmhAo+gGtmQL1ycH3VioAi5kjx1tpn3SoB3+LON5HWY5FgloIIcSYRgo3L9BkHY9Qh2gNhgLXCyj2F5GpUa6lcj2kf/sd4lt+E01lKwjmnU6ycQn/t2kbv9x6gLnVSc5ZUE9jVRLbGLjmfKQQzVQGHbkihmLS4XrrurO4buUiquIWbhBQFbdGnCafKWTqWwghxIgGbsUqhdiGnS20ZoqkYya2EY10866PO2See6RZb+vVF0g+cS+Gm8foacU792qMWIKYZbByfi3P7e9CKcX+/r3Yrh9iGArXDwmGXDDQGstQBGGI4weTCuuZtk96PBLUQgghBhlpK9alp86hO++wo62X9pyD1ppiEIDPsBAdxnNIbvoPYjufjv648Cysqz9EVaoKgNnpOBcumcPDOw7Tli2W92KbhsLzFaE+MkIvFbRFIa15ubW34gKwmbJPejwS1EIIIQYZuBUrZpm83NrLb145iN+/8GwoojVgPX5Imx2vkXz0R5h97WjTorjmHVSvvrp/DVsxvzrBRy46nU9eegbP7e9kR3tfOZSjVqT9a9mAqRSlwnM/1MQtRd6Lpq5fz17f704IIcSkDN2KdaAnx6HefDmkIVordvwQ01DRxuYxxLf8BrOvnaBuPvn1H8JsWMiLn3s7BS8ERflQDYA1ixt4fE8bhoqu74XRlPeRVepo9Vv3/2uoNSnbIuv41CRi0/xJzBwS1EIIIcoGbsUKtaY77456ZOTQyumRFC69geDlJpw3vAXDtrEMRcEPWdpQPex3P3fVSn724j5e7criBtH6tEFUQaaJ9m2HWpenwoNQk7RN6pL2FN/1zCZV30IIcRJz/IBDvXkcP8DxA/ocl4Rt4oeanOuTdf0R90NrGLR2XGK9uoXUw/98ZPtVqhZnzdtRlk3MNKLR85Drle7BNAw+vPo0kpZFVdwmHbOImSZKKUwVrUkroinwuGVgG6q/n/iOo/HRzBgyohZCiJPQwIKxjmyR3qJHR87B8UNyrkeoo3Xo0UbTJZaKwtp1HZKb7ie2cxMA9t7n8ZatKf9eqe93VezICDjvenzrd1t5bn8nPQWXhnScNyyopypukXN9vFCTipkoTMJQ01P0UCoqMkvFLOoTMRbVpWZs68/pIkEthBAnoVLBGMChvgIHe/PDCsPGC2kAT4PZvo/qR3+EkelAmxbhRe9ELV/D0K4noYbegsfl//BbTp9dzY62Pg705onbJvXJGDHLZOPuVtJxi1NnVeEFGtuMupMV/IBtLT2sml+H1mCbRnkdfaa2/pwuEtRCCHGScfyAR3a1crA3T3feobvgjbjvedwV6DAk3ryB+O9/hdIhQf183Cs/QrJxMUnAK3oojuR13DSIWwb7unPs7ujDD6N1ZycIyfcf3rGkLo3qLxSLW0dWZ21DsbAuRcwcPmqeqa0/p4sEtRBCnGQO9eXZcqiLrOMThuH4gTwKe89mEpt/CYBz9hUUV7+dZCJBQypGd8HDUFAVM3F8Tcwy+vt2Q9H3o6ptoBS7XqBp6SuwqDZFbTLGlac38vzBbrryDrNS8XJntF++fHDcE7JebySohRDidWJgJ7GRgqu0Lv3Q9sO0ZgqAmlJFsXfaatwDL+OdfiH+oqhzmWkoGquTzKtJ0Z4tMCsV5+XWPkqdQEMd7ehSikFDdqWiqXbHD5lTFefPrzkXYND7CcKwfBzlwACfqa0/p4sEtRBCnOCCUPN3G7cO6iRWCjDTOBLFpXVpLwgxlIEfhASTeSGvSGLzL3HOuQadrgPDoLD+w4N+RaGpS8a4evk8Qq15cOsBbFMRlkvHNUpFHca01mitUQNHyAweIQ9cd55s68/xvricKCSohRDiBHfv9i6e79UYShG3TLKOXy4U+8z66KjHvqLLb145BETtNw01rNZrTGb7vqjDWKYDI9NJ/tpPjPh7q+bX8w9/dCEN6Ti9BZcw1HTmHQ705ImZBrMScYKwQNEPiBkKpaLzpUMNKdvk3ecsGXeEPF7rzyAMuWdbJ7u3PDrmF5cThQS1EEKcwBw/YHNrDiuZHvTz0hTxJy49g+89uYNfvXyIp19rjwq0+juLTUgYEn/pYeLP/7q/YGwBxTXXjfirhoJd7Rmu+sffUgxCkrbFqnl13LT6NPKuz+YDXfQWXeKW0T/1Dr6GlDKpilv8r0vP5LNXrZrS5wHRzEHTgT5qa2pG/eJyIpGgFkKIE1hnzqHX9WlIHvlZ1CNbU/QdvrGhmR//fi+9RQ/HDyh4wYSLx1S2i1TT3VituwFwVq6nuPrtYA6PDoNo33Wf41H0FaZh4Pgur7T1knE8rlu5iPs/up7OnENd0uZ7T+5gw84W2rNF5lQluHr5vGlZax7aArV8f/1fXE7E/dYS1EIIcQJrSMepjUX/KddEvbl7Ci5eoImZsKOtFzcIMQ0D1b8uPCFukaoH/w+GkyNM1lC4/AP4C1cM+zUFJGwTRbS3Oef6GMooP9ZTcFlYe6QpSWnK+mgdM1lqgTqSE3W/tQS1EEKcwOKWyerGNM/3ag705GjPOSitKfohWUeX16ENFZWNDSm2Hl0sgXv2OsyO/RTWvg+dqBr0sAlUxS3ObKxFKcW2ll7CMFonH1gc5oXR6H6kkDwax0w2pKM91YcL+WGPnaj7rSWohRDiBFDqhz30xCmA9yyvZ+dLUZcvL9AjBvFI/bqHMttfBc8hWHBm9JrnvinaNzUgeA1g7WlzeMuKhVimQdPuVjpyDgnbIB2z6Cm4gw7Usg2FbSpqErFjEpJxy2T9skbuae8a9PMTeb+1BLUQQsxgQRjy94++zL8+u5vDvdHe53nVCa4/bwmfv3oVqZjNfTu76cwF/QdeBLgTSeWBwpD4i/9NfMtv0PEU2Xd8Hp2qgREqpC87tYHffOLacuD9Sf/09T3P7eZXrxzCQNGRK0bT7EBdMjp+8liG5K3rzmL/gYPsdqzXxX5rCWohhJjB7mzaxnef3EFXzgGlKPo+uzozfOuRrdz/0mt84PylPHagFzORwkRPOqSjgrG7sFr3AOAueyM6PvJ0tALefNaiQYFbmr7+0ytXYpkGj+xqYWtLSN4LSNkWK+bWcuXpxzYkTcPgA2c1sOq8N8g+aiGEEEeP4wds2NkSVWwHGjfwy0dLhgr2dmT52n+/SDHQGBQnfX17z+9JPvVTlFsYs2CsxDIUj+9tw/GDYcE3tBlJVdwi6/jHNSSPxhr48SBBLYQQM1RnzqE1U6C34A462UoTteEsDjjdajLNSwASzz5IvHkDAN6ScyhcduOwgrGhvFDz5N4Ovv7wi/zFm84bsXnIwHCsScQmeVdiJCdeixYhhDhJ1CVt9nVlhx0/OR28xWejrTiFS95L/qqPjxvSpXIyQ8Eju1q5s2nb9N+UGJEEtRBCzEBBGHLDD5voLnjTc8EwwDr4ypHrzzudzHu/grviskFV3YqoUntgu5DSli4FVCfscvMQx59Up3BRIZn6FkKIGeiOjS/zxN62SWx8Hp3KdEYFY217yb3pk+V1aB1PD/vdhlSMVMyiPVPEDUMCfeTlLaXoyjlkih61CYu2TJHF9cOvMV1eL4dqTFVFQe15Hl/4whc4ePAgruvyyU9+ktNPP50/+7M/QynF8uXL+cpXvoJhGHz7299m48aNWJbFF77wBc4999zpfg9CCPG6knc9/mXTLnJeMKH9z2Oxdz9H8qn7UF6RMFmDNkYPvJqYxZOf/gNipsG9v9/Lxj2tPLmnHTcMCAKNaSicIKDoB2Rdj5vvf5oHPnbliGvVUwnZ0nGc450GdrKoKKgffPBB6urquP322+nu7uZd73oXK1as4LbbbuOiiy7iy1/+Mhs2bGDBggU888wz3HfffRw+fJhbbrmF+++/f7rfgxBCnJCGhlnpz999YjstfYWpXdwtkHz6Z8R2PweUCsbeh06MPAKOGXDpaXNYVJcmbpl89upzuPWKs/nrh7bwvSd3kdc+XhhGXccUWIbB06+2c8fGlwcdpDEdIVs6jnOs08BOJhUF9Vve8hbe/OY3l/9smiZbt27lwgsvBGDdunU88cQTLF26lLVr16KUYsGCBQRBQFdXF7NmzZqeuxdCiBPQ0DCblYpHx05qTUumwJ6OLH6osQyFX8GQ2ug6RHrDP2Nku9BWjMKF78I745JBa9FD1afiXLN8/rA90p+45Ezu2fwqGccrP982DOKWga/h4R0t3LrurPLzphqyr8dDNaaqoqBOp6NvZNlslltvvZXbbruNb37zm+X+rul0mkwmQzabpa6ubtDzMpnMhIK6ubm5kls74WzevPl438KMI5/JcPKZDHcifyb3bOuk6UBfOYxe6Oylq+ARaPDCyW+1GkqnaiDwCRoWkb/iQ4S1jeM+5+1LqrgsXRj2ubpBSGMcOgxQqlRkpgmCAFMpWrq7eeSpZ5mTsnGDkAc2H6AwwhGaD2zewcWp6EzqsbTnPfa1dRIbYfTd1avLrzURJ/LfkYEqLiY7fPgwn/rUp3j/+9/P29/+dm6//fbyY7lcjpqaGqqqqsjlcoN+Xl1dPaHrr1q1inj8xGuePhmbN29m9erVx/s2ZhT5TIaTz2S4E/EzKU1r26Zi67NPUF1djaGiEXMu04OrKxs9l6hsFzpVC4aJTlSRe8ufEFY3jHgk5VBp22DFslNYvXrk6el3ZxLs3vgy4YD708DsdJxT59Zy5SVvJG6ZHOrNEzzdQXVy+IjXDQJOOXPluA1IHD/glB15so4/7LGquFV+rfGcSH9HHMcZc3Ba0ap8R0cHH/vYx/jsZz/L9ddfD8DZZ5/Npk2bAGhqamLNmjVccMEFPP7444RhyKFDhwjDUKa9hRAnlSAM+buNW3nPv21k7Z2/ZuU3H6RpTwvNLT28dLib5pYeeovulELa3v0s1Q98g/jzvyr/LKxrnFBIG8AbFs7iwa0HRt0b/adXruSyU+dE0/OAaShmp+MsqE0N6uFdOrlqJBM9uap0qEY45DjOE/lQjamqaET9T//0T/T19fGd73yH73znOwB88Ytf5Gtf+xp33HEHp512Gm9+85sxTZM1a9Zwww03EIYhX/7yl6f15oUQYqYrrdke7MnTU3ABCLSmr+ihNdimQlW6B8stkHzqPmJ7oiles68DdAhqYmMwBVTFbUKtsMdYAzYNg/s/up47Nr7MwztayLoes9PDD7oohWxpjbpksiFbuubG3a2vi0M1pqqioP7Sl77El770pWE/v/vuu4f97JZbbuGWW26p5GWEEOK4mcr2otJzq+IWG3e3AtBddFFKEWqNgcILNQpw/JGPpRyP2bqHVNNdRwrGLvojvOUXj1kwNpQiKtKyzeg5I50ZXX49w+CzV63i1nVnjfm5TEfIDu0bLvuohRBClE1le9HQ56ZjFjs7MsyvSeL6IQUvINCD13knLQyJv/Ab4i88hNIav2ExhSs+RFg7d/KXIlo7PtibZ1FdekLT0+MddGEaBjevXcE7z10CGhbUpioO2dfLoRpTJUEthBADTGV70dDnukFIxvEwM1Bwfaal4aZSmO2vgYbiOVfjnP/WCa1Fj8QyFLZp0JFz0Fpz82VnTmnkKo1Kjg4JaiGE6DfZPbwDp8eBYc81lKI2brOvKze1kNYafBfsOChF4fL3Y/S0EsxfPuFLKCBuG+ggJGFbmIYCpfACjW0q4rbJJy49Yyp3KY1KjhIJaiGE6NeZi9ZoRxpVDly/HThybM86pG2LlQtqacsUSNhWOfwMpegtulMLaSdP8un7MDJd5N56a7T9KllDkKyZ8CVMBfNqEjRWJ2nNFFnWEG0NC7XGC0Js08APQ3oKHqnYxPYoD7tNaVRy1EhQCyFEv9L2opH28A5cv72zaRu/2HqAgz05DvflcXzNxt0tKCBmG1jKIGYZVMesKZ1+ZbbuJtV0d7lgzOg6RDh78aSuoYjqyzJFn7jp4g04w7o08h36/iox0S85YvJk0UAIIfpNZA9vaeR4sCfHvu4cBV8TEhVmBUDBC/GCgCDUHOjNV1gwFhD//X+R/vU/YLj2sFQAACAASURBVGS78GcvIXvdZycd0iWWMvpH9x4Jy8QZ0jlsOvYoT8ceajEyGVELIcQA420v6sw5tGcdDvcVCEZJ4WKgcQKvopA2+jpINv0Iq30fGkXx3GuigrExTr2CaNRlG4oQ8IY0T4n1b7/yQs3y2TVce+Z8Ht/bVn5/a0+dw/XnnYLjB1Oq0J6OPdRiOAlqIYQYYLw9vA3pOCnbpDhCP+uBKu0zZr32Elb7PsJUHfkrbiKYd/q4zzGAlG1iGAZKQdbxMA2FH+hoW3V/cFoKrj1zfrQf2g9oyxS59/m9PL63jV9sPTDlKm1pVHJ0SFALIcQIRtvDG7dMlKo8iEekdTlM3ZVXoAIPZ8VaiE9sTVcDThAS+iFKRWvPCcvEVRo/DAk1WKbislPn8Kfrzy6/j5+98Cq/2nZw2qq0pVHJ0SFr1EIIMQmOHxAzjWn7j6fZsouqB29HZbujHygD57w3TTikIQrqUhW3H0b/FPwAhWZ+TZKLT5nN59afzf0fXV8eKY9Xpe34ldeql77kSEhPDxlRCyHEBDl+wNaWHjpyztQvFgbEn/8N8Zf+G6U18eYNFC++vvLLhdFUfOkLhNbQWJPgA6uX8sVrzxsWmlKlfeKQoBZCiHHkXY9v/W4rz77WwdaWHg72FqZ0ZrTR107y0buwOkoFY2/COf8tk78O/adZAam4HaUz0Qg71DC/JsULh3pGfO5Et6KJ40+CWgghRhEFdDM/fWEfh3oK+GFI0Q8rX5/WGnvXMySfvh/lO4TpOvLrJlYwNuLl+v83Yan+ZW5VXu6OmVF70NFGx1KlfeKQoBZCiCFKncd+sGkX+3vyFPwAE3CmcGY09I+kn7gXpUPcU8+ncOl7J7UWPZQmGlUroOD7aF0aVGtqEzaKsUfHUqV9YpCgFkKIIe7Y+DL3v/QahzPF/mlkPeqe6ckIa+dSXPN2dLwK7/Q3TupIyhLLUBgqCuRkzGJ2KkZHpoDfv13MNKIGJ34Q8lpPjk+NcdCGVGmfGCSohRCiXxCG3PHIVv6/R7fRW/Rwg6msRNNfMPZrgjmn4C85BwB31VVTuqTu/9JQm7CpT8VZUJuiM1ukOm7hBiFJyyBAYRuKpDWxgzbkOMmZTYJaCCH63dm0jZ8376ev6A06N7oSRm8byaa7sDpeI0xWk1lwJlixyq4F2KYiZVssm1PNjrY+zp5Xh2UYOH6IrzW2YWCbJmfMrcFQBrappnzQhpgZJKiFEIIj+4pt0yDUGl1pUGuNvXMTyU33o3yXMF1Pft1NFYe0AgxDEWioT8VJ2RamYRCEGsuIAtzqn0K3zahxSak4bOj69MBjOWWK+8QhQS2EEBzZVwwKpSCsZNbbyZN88ifEXt0CgLv0AgqXvGdKBWOlVWzLUMytTmAoxfzqRHSeNFGDkuqYQZ+naUjEyyEdas3aU+fQmXOoS9p878kdbNzdWg7qqbQKFceWBLUQQhDtK65LxujKuyRMAzeYfGeu9IZ/xmrdg7bjFC5+D96yNeMWjCnGbkeqVBTSqZhFrH+0/8E1p1HwfJ7b30Vv0eWU6hiz6usItaa74FKfjGEoxWN72/nF1gP0FF0cL2BxfdW0tAoVx5YEtRDipOL4AYf68qApF1C1ZQrc/dwedrb38WpXFr/CWe/iBW8jsfk/ya/7ILp69ri/HzMUlgEFX0f9uW2DohcQ6CMBbhoKLwjRGqrjNoaCJ/a20ZV3qUvGuHr5fK6pc1l78YXlqe17Nu8p9/C2TYPWTJEg1CiVY3FdGjjSKvTmtStkGnyGk6AWQpwUgjDk75u28W+bdnGor0CoNXHLZFYyxqFMgbzrT3oLltHbhnVwG+7ZV0SvMW8Zubd+ekLbruKmImFb0Xq47wMaUylQUfFYaYk8ZdvMStksnVXNJUsaeGhnS/kQjYIX8OjuVvpqFWsvjqq3G9JxHt/bVp4C94IQL9CYCnoKLgtrU+XHpFXoiUGCWghxUrizaRvfefwVDvePLoNQ0+f4tFfSt1tr7J1Pk9z0H1HBWG0j/sIV0WPjhLQBoKJQdfwQv38xPNDg+NHI2VAKDcQsg1Xz67AMRc7z2binbcRDNDa35spnSQ/t4W2bUQV4GGq8UOMFmrg1crGZmJkkqIUQJxTHD2jPe+Vgmoi86/H/P72L13ryTLG5GMrJkXziJ9j7XgDAPe0C/NlLxn1eVczENKIWn5apKHohXhD2r0GDSf8UN4CKKrjn1ySx+ovGqmI2GcclaQ//z3afG5RHxkN7eBtKUZ+I0ZErlkMbpFXoiUSCWghxQii19dy4u5V9bZ2csiM/auXy0G1I3/hdM3s6M1MOafPQDlKP3Y2R740Kxi55D96yN07ouW4QYoQqauuZTBCGHqaKKsxnpxMoBd15h7zrk7AtGtJxFvWvJ4dac80Z83h8b9uIh2jUxMzyyHikHt6L6lKEaJKWiR+G0ir0BCNBLYQ4IdzZtK0cPjHDGLFyeWCYl4J67alz+Onzr+JPMaXt3c+RbLobhcafcyr5Kz6Erm6Y8PPPnV9HwjJ5ubWXA315/DCq5q6JWyyoSRBomF+TpOD6vPmshbx4qHtY/23LUCMeorG6MT1oZDxSD+9PXXYmn7j0DHoKnuyjPsFIUAshZrxSM5KR1mcHVi4PDPO4ZZIpevzjE9s52Fuo/MSrfv7Cs9DpOpzlF+Gc9yYwJh50tXGLqniM/d05glCTjtnkXJ9UzCLnBmw+2IVlmNimorE6wZ9fvQrTMIY1JxntEI3L0oVBrzdWD2/pUnbikaAWQsx4AwukQq1xQ02ooy1NpcrlhnR8WJgf6MnTXfAI6a+knsyLao316paoR7dpoRNpMn/0hYo6jCml2NeZodf1Uf33ZxkKxw/wQ43SmphhEITgeAHfe3IHn1m/clg19mgBvHnz5hFfV3p4vz5ISxohxIzk+AGHevM4fkBDOs6sVJz9PTmaW3rY1V2kuaWH/T056pNR8VQpzEOtcfwANwjoyBdx/ahxyWQajalijtTvfkB6478Rf/5XRx6osA1ob9HjtZ48vQW33Jo0ZVvlNeqwv9J7djrO4voqNu5uxfFHb7hSCmCZvj45yIhaCDGjDF1nrkvGWLN4FkEQ8GpXllBHI+Ni3qW34LJibg1xyyRpG3TkinTmXLKujx+EkwrnEvPQdlKP3dNfMJYgrF8wpfdj9AdxdFxmtAUrbptUJ2z8vMY2DRSKlfNrsfqL4mR/sxhIgloIMaOU1pkV0JYpsr29j8f3tJFz/UHBWwq+Tfvauf13zfzwud3s687hBbqy9ejAJ/H7/yLW/EhUMDZ3Kfl1N02qYGyocj9uNLq/25ivQxakkiysS5N1PPwgpCEdL4c0yP5mMZgEtRDiuCttp6qKW+V15v3dOTpyxWhNVw2eui5FmlLQkff4yZZX2deVww8rC2nl5Ej/5juYXQfQSlE87y2TLhgbdk2OHKih+huYVMUtahI2pzVUk/d8GqsSFPyARXVHRs6yv1kMJUEthDhuhk5zp2M2O9t7WVKfprvolgNu6NnQ5dDu//H2tl7yXiUT3f2XiaUIUzUot4H8upsIGpdO+hqN6RhzqxO0ZByCMKTX8QY9rhQ0pOKcPa+Wuz6wlqzjDzrVauhWLCFKJKiFEMfN0O1UbhCQcTxe65/C9oIQNwjGbVRSSUirYhZ8F101C5SicPkH0YYJscSkr2Uq+O3/upaGdIJ7Nu/hv7YdZGtLN70FD1TU5KQ2YbOwLsX6ZY3UJGLUJKLCtNG2UQlRIkEthDguRtobbShFfSpOZ66I54cUg8pHyWMxD20n1XQ3YdUscm+9FQwTnUhXfL26pM0Zc2uJWyZ/uv7sciOTlw73kHcD0jGTVfPrufL0kUfLso1KjEWCWghxXAw9PAJA66joqjjBkDYVkzvxKvBJbP4l8a2PABBWN6DcAjpRNdnbL1PAZ644u/w+hu51ropbZB1fRsuiYhLUQoijbmjvbWDY4REQNSjpLBWQjUMxuZA2elpJPfpDzK6DaGXgvOEtOOdeM+WCsT9YsYDPXbVq2GMDR8mlaW4hKiFBLYQ4akbqvV0qlhp6eESoNd1FlxAoeKM3+yiZzEDa3vEUyafvRwUeQXUDhXUfIph7aqVvq2zd0jk88PErhx0KIsR0kr9dQoijplQslnV84pZZPkjjzqZtQNS7+rqVi/qnhz38QOP5078urdwiKvBwl72R7HWfm5aQBlCGwZ1N2wjCo7OWLgTIiFoIcZQMLRYLtcYLNLY5+CCNW9edhR+EPLT9MDB9BWSqmC2vPbsrryCYtYBgwZnTcm2ApGkQaj3sBC8hppuMqIUQR0WpWCzQmr1dGZoPd7O1pYetLT00H+6hLROd+HRn0zZ+9cohQqA6Pg0nOwU+iWd+TtX9f4PKdkU/U0ZFIa1G+XdTwfzaJIZS5RO8xurNLcRUSFALIY6KuqRNT9Fl8/5O9vfk6XU8HD/AC0L6HI97f7+3POqGaAQ+sENXJYyeFqp+eQfxrRtRXhGrdU/F14qbiotPmc2SuhTpmElV3MJUkLQNTqlLs7juyHauUm9uIY4GmfoWQkyrUoX3PZv3UHQD3P6p7DAEhxA3CKlP2jy2t413nXcKLx3qJuP6ZB0Pb1J7rQbQmtj2J0g880B/wdhsClfcRDDn1Irfh6EMbNPgtIZqFtQm+fofXsBf//ZF/P7jNQeS3tziaJKgFkJMi4EV3u3ZInu7siRtC631oM5iGsgUPZoP9/DDZ3aTcTzyXljxYRqqmCX5+L9j728GwD39QgoXvxvsyXcYKzEVWKbCC0LilsnsdIKLTpnDW89eWF6TLpHe3OJok6AWQkyLge1ADaUoeCG9xcKIe50DDe25Is/u7yQds+ku5Cs78Qowsl1YB15Gx5IULr0Bb+n5U3ofpoKquI1pKOz+grFSEJe6im3Y2UJ7tsCcqiRXL58nvbnFUXVMgjoMQ7761a+yfft2YrEYX/va1zjllFOOxUsLIY6BoRXelmlQ9Hy8UZp0a6DghTy6u6WykXQYlBuVBLOXUFj3Qfy5S6O+3RUwiA7NMA2DedUJso5HTf9JV6MdkqH1+E1ZhJgOxySoH374YVzX5Sc/+QlbtmzhG9/4Bt/97nePxUsLIY6Boe1AD/bk8cc4SaP0iFvBmrTRfZjUoz+ieP5b8E85DwDvtNWTvk5JlaWYVZUk43iAYuW8Oq5Y1siN5y9lbnVi0JT2wFmD6oRNwQtke5Y46o5JUG/evJnLL78cgDe84Q00Nzcfi5cVQhwjDek4dckYPQUP01B0F9zydqZKp7SH0ZrYK4+TePYXqMAj/tIG/CXnRkPhKQhVNMW9cl4dV57eyJ9fc+6I680jHSIClLdnlfaFCzHdjklQZ7NZqqqONL03TRPf97Gs0V/+ZAnzzZs3H+9bmHHkMxluJn0mbhDS6wTUxk1ipkEQau7d3sW2Q1205X1MpSgGYZSf/Sk91bBWhQzJx3+MfeDl6B6WX0ThondPOaQBdBjSnS3wB4uSvLUhoPmFLSP+XnveY19bJ7ER2oV29WoeeepZ5qSmYR94hWbS35GZ4vXymRyToK6qqiKXy5X/HIbhmCENsGrVKuLx1/d2h82bN7N6deVTdq9H8pkMN1M+k9H6doda83yv5pTZ9Zg9eboKDoEXBXXMVFiGIueFFYe1dWAbycfvwShk0LEk+UtvwJ9iwVhJfcJmRWMtGs3n37FuzKMmHT/glB35QYeIlFTFLa685I3HbUQ9U/6OzCQn0mfiOM6Yg9Nj0vDkggsuoKmpCYAtW7ZwxhlnHIuXFUJMo5H6dj/QvJ9/fXb3oOlgpRSWGf1ZoSj4R0I6bhlYxiRGwYFP4un7MAoZ/Hmnk3nH56ctpOsSFucsqC9vvxpvH3TpEJFQD/7KIduzxNF2TEbU1157LU888QQ33ngjWmv+9m//9li8rBBimoy2PhuEcLi3wJx0goM9eTr6j6hM2tEhG05pCrx8nUn28TYtCpffhNW6C2fV1TDFU6qStompFDHTYNX8uvKpXRMN2lL198bdrXTlHWal4qNWhQsxXY5JUBuGwV/91V8di5cSQhwFQ6u6S2xToZTC8QO6iy4oRbG/TWigwVAQ6qhP9oSmvrUmtu0xjFw3xTe+A4CgcSlB49IpvwdTwbnz62nPFojbJn4YTjpo/VBzw/lL+fjFy8k6/qDztYU4WqThiRBiXA3pqEXm0PVZQynmVyeik7H8kIIfDNqWNcYOrWGGFYwtW0M4a+G03D8AGupTNu85bwmfuPQMegrehIN2rHO1hTjaJKiFEOMqrc+W9hBDtDbr+CHvX72UJ/e283uva8QuZBNhHXiZ5GP3YBSzhLEUhctumN6QBuZWJ/j2H13E0oZqAFKxiVdoD9w/PfBcbZD90+Lok6AWQkxIafT4yK5Wtrb0kPd8kpbJ3Zv34HghtmEQTPYsad8j8dyDxLdFxab+vOXk130Qna6b1ntPWgbnLawfs6p7NLJ/WhxvEtRCiAkxDYOb166gK+fQli1gm0lyrs/ezgxeqPHCSYY0kHj+V8S3NaGVQfGCP8RdddWUC8aGStsGjdVJrlk+v6JAHW19Ho4cb1nJFwAhJkqCWggxrtIa7YadLTyxp5WcGxBMw3WL516L2XmAwprrCGcvnoYrDmYpWFxXxccuPr3i9eTR1udBjrcUx4YEtRBiXHc2beMXzft5rTtPn1t5RKtCH/EXH6a45jowLYinyL3lU9N2nwbRgDxlWyjgE5eewVff8oYpTU2PtD4Psn9aHDsS1EKcRBw/KFctDw2YoY+V/lwVt9i4u5VDvQW6Ck7Fr23t30ry8R9jFLNoK46z+g8rvpZBtN3LUNGRmaaKGq0AhKHGUIrLT5vL1956PuY0TKXL/mlxPElQC3ESGG970cDHZqXi/fufNV15l4Rlsr29l6IXTr5hCYDvknj2QeKvPBb9cf5y3BWXVfQ+TAU1iRhJQ1PUiiDUKKA+GaPP8fCCkJhpctvlZ/K5a86ZlpCGaH3+M+tXcvPaFaN+0RHiaJGgFuIEMdZoeDxjbS8CBj22rbWHtmyROak4Sik68w59jo8GJnsEhtF1kNSjP8LsaUEbZn/B2JWgJh+gcVOxorGW2kSMXDZLT2DQni0yO51gcX26vF3sXecs5rNXrZr09Sd0D5YphWPimJOgFmKGC0LN323cOuJoeCIjxrG2F23Y2VL+c9HzackUONhbIAg1e938sGtNZpu00X2Iql/egQp8gtq55Nd9qOKCsRiwftk8rlw+j8f3ttHTp1kxt5azG2sJtaa74Mp0tHjdkqAWYoa7d3sXz/fqipttjLW9qC1TpCWTp+CH5BwfPwwn1U1sLGHdfPyFZxEmqile+E6wp1AdbUDMMvjsVau41Q945Klny6dVTWWmQYgTwTE5PUsIURnHD9jcmhu12Ybjj1+BXdpeNJKc65N3fYJQE2gNSqGp/Pxoa38zRm9b9AelyF/5UYqX3TClkDaAhTWp/qntgLhlMidll0O5NB0tIS1erySohZjBOnMOve7w/btwpNnGQI4fcKg3PyjARzue0Q9DlAGz0lGv7tLDarIL0RAVjD11H+mH/5lk010Q9r++UXl4GkDMUJxSn+aUhmq6C+6w9yvEyUCmvoWYwRrScWpjI//fdGCzjbzr8a3fNfPc/i56Cu6wdeyRthedv3AWD20/RLvvEIQ6CvJoUD25teiug6Q2/hCztxVtmHhLz68w7SOq/x/DiLZfla4kzUXEyUqCWogZLG6ZrG5Ml9eoS0rNNixD8Xcbt/KDTbvY35PHtgyqYxaWoQatY4+0vQjg/hf20ZlziJkGoda4foieaErrkNjLj5J47j9RYUBQ20j+ig8RNiyq6L0qwDQUi2qSdBZcDKK90T2Ox4IwlOYi4qQlQS3EDHfjmbNYnEuyYWcL7dkic6oSXL18HreuO4s7m7bxQPN+WrJFvDCkUAzoybu05YosqE7xyK6WMQ+N0ArQGl1qFjLRm9Ka1IZ/wd7fDIBz5qUUL3wXWLGK3mPMVHiBxlSKebUpTNOgp+DihRql4crTpZpbnLwkqIU4gegBw93Stis/1PQVvfI50ApwvJC2bIFAh3TmHBqrE8Manpy/sJ6auI2bTnA4U6A4mWYmSuHPX47ZtpfCZTfin3Juxe9JAZYyMG1N0jKJmQaL69IsrE3hBZq6pM2fX3PutDUvEeJEI0EtxAw3cHtWdSJGwQt4cOsBeotRcVVrX6HcoaskBNxAk/cCbFPx1w+9wIadLWgNtmmQdXwe2dVKpugxvzZJe644/o34Lmb3IYI5pwLgnn0F3rI16ERVxe+tyjYwDAPLUNQkYhiK8hS/oRS2CVcvnydT3uKkJkEtxAxW2p5lJdODfm4oxXP7u6hN2rzS1gcwrHOYH4a4fsiNP2ri6Vc78HU0tZyKmdTEbRbXpejIOxzszdM3wslQg16v8wCpR3+Eke8l847Poasboq1cFYa0DTTWJsl7AV6g0cAHVi+lNhmjSfppCzGIBLUQM1hpe1ZDcvhjvUWXC5fM5vE9bZiGKm+xKgW2UgqNZkdbH24QohS4ocYrhPQWPA71FlBqnHVpHRLbupHE5l+WC8aU71a8z7rEskz6ij6WAbNSNmfNreOL155L3DL5kzH6aZeam7hBBT3HhThBSVALMYONtz3rS9eew2+3H2JfZ458/95pRbStyQ81RS8g29+ne2DHMaXAK6X6KFS+l+Rj92Af2g6As+Iyim98Z8UFYwOFOkQpg1BDd97FNtWwBiYDDT1UxPSKvDOfmnAbVSFOZPI3XIgZrLQ9a6RmJecvnEUqZvPh1adRn7KJGf3HPRId/QjgBJpgSB4PDe2RWAdfoeqBb2If2k4YT5O7+n9QvOS90xLSAF6oKfoBhqGY099wZawua6VDRbKOT9wyKfghD249wJ1N26blfoSYyWRELcQMd+OZs5jfF+fhnS1kHI9M0UMreOiVg/zsxX2EoaYz76KVwlJRZbg7xZnhMJ5GeUW8BSsoXP5+dKp2yu+jtH5uKEjbJqZhcHZjLZZhlLuOjXQy1ViHimzc3Trm9jMhXg8kqIWYwYIw5N7tXex2LDKOT1fewQs0p9SnOdCTpyNXJAS0hqRl4odjj0zHorJd6KpZAISzF5P7w9sIGhZVdCTlUIaCqrhNzvGwjajSOwCCkP516tG7jo11qEipjaocPSlez2TqW4gZ7M6mbTQd6Ouf8jXoyrt05x1e68nRXXRRSqG0xgtCcp5PwQvK094TpkNiL/2O6vu/hvXqlvKPg9lLpiWkTcDu34JVm7CxjaizmqXANlW5y9poo+KxDhWRtqLiZCBBLcQM5PgBezszbNjZUp7y9QKNG2g0iu68i9vfoMQNdFS5rSffX1vle0k99F2Sz/0CFQaYnfun8V1AwjJYPrea8xbUsbKxlrpkjEArcq5PwQtpzxV529kLx9yCNdqhIuMFvBCvFzL1LcRRUOkZyQOrmw/35tndmaPK0qSrNK2ZAkXfJ4xSGds0MJSBF4aYKppCdiYx623te5HkE/+O4eQJE1UU1r4Pf/GqSb/XkZgK5lUnOK2hmppEjMuXzuGHm/fQnnNIxkzmJZLMrU5gGQpDqXErt4ceKpK0DK5buUj2WIuTggS1ENNo6DaioadYjadU3WwoRTpuYxjQ4wRsbenBDzWmMgiJ9kSHQUjWDwnpbxs60Tlv3yWx6efEdzwJgLfwLApr349O1VT+xgcwFdQmYyybXYOhFN0Fh+vfcCqP7mmjLhHHNtWgwrCJFIQNPVRk3/atXHLhymm5XyFmOpn6FmIaDd1GlHX8CW8jGlrdbChFfSKG1lEvb4C4Fa31WsrA1UealUxqWVqHWIe3ow2TwoXvIn/tH09bSJfUJuzy+5iVioOCnoJL3DKGVW+PdK72aEp7rGOm/KdLnDzkb7sQU+T4AYd68/QV3TG3EQ2txi49r/TzUnVziQY0Gi+M/sk6Hp4fkrJNnMl25tIhBP1tQu0E+fUfJfv2/427cv20FIwNeikNjVUJ4Mg68oKalBSECVEhmfoWokJDp7nTMYudHRlOnVXF0LKugduIRpse/8SlZ9CQjpPt77t9oCdHZ97tPys6JGEZ5L2Agh9MagStcj2kHruboLaR4iXvAaLtV9NNEX25MA0I0VTFrUHT/uuXNZan9UukIEyI8UlQC1GhgevJccvEDUIyjseBnhyL6wYfojFw1Dj0eaXpcYC1p87h5837MQ1FV86JzorWmuqERa7oT/y86H7WvhdIPnEvhpPH6D6Mc/5b0Yn0+E+cIIOopzhEbUm11syrTvKP776YlfPqBgXw0IIwOXRDiImRoBaiAiN1yyqtKXfnHRbWpsqPDRw1jtZlSynFDzbtYnFdmu1tfWQdD19HQWgbYGuFO5lhtOeQfObnxHY8Ff1x4VlRh7FpDOnqmIkXRu1MtY5CujZhc+6C+mEhDcMLwiZbES/EyUqCWogKjNYta1FdikCHxEyTvOcNGzWO9rwDPTnaskWyjkfR86Mt0f3FYk4Ibn8x2USYHa+RfPQuzL42tGlRXPMO3LMuj4a8FYoO+oien45bxE2DCxbN4tn9nXiBwlSK+lSMRbUprjx97POjRzp0QwgxOglqISpQ6paVHXKOs1KKVfPruesDa8k6/rBR40jPC7Wmp+BimwZt2SJuoFHqyJovTK6qO7Z1I2ZfG0HdfPJXfIhw1oLK3+hApS8PYcjFp83l/o+u545HtvLwzhayrsfsdEKmsoU4CiSohahAqVvWaMVRNYkYNYnhJ02N9Dwv0BRdP+rTXTrWatJtQHV5xFy4+HrC6tk4514zbaddaUCHGstUrDutkZ9+eB2mYfDZq8/h1ivOlqlsIY4iCWohKlRpcdTQ59UlY6AUbljZkVfWq1uIb3uc3LWfAMuGeArngrdWdK2hjP6RfVXM4tSGat5z7hL+/NpzB/2OTGULcXRJUAtRoUqLo4Y+/WrMqwAAIABJREFUzzYVp//Nz/urpidxA55DctP9xHZuAsDe/SzemZdW+G6GK61La62ZX5PkptVLZVpbiONAglqICRird/dUR5S7OzPRzPUknmO27yP56I8wMx1o06b4xnfgnXFJxfcwktJIes2SWfz8o1eSitnTen0hxMRIUAsxhqn07h4t3P9fe3ceX1V9Jn78c5a7JDdkYQsgYEWJ7KBYaiUsBa1Lqz+HIZCqTF2qMkilUtGxHUQUUWcGbC2VoozWoY4r49jaaQtYFoPYaiQqEVECQlgCgRCSe3O3c87398fNvSQkJBCW3CTP+/Xy9UrO3b7na8KT7/Y8x79nJ7dJ0LJxTmY07Th4tryL5+P/Q1MOdlZPasb9ECer52neaX1uXSPFZTAj92IeuXr4SeUpF0KcHRKohWhCU8lJ7hvfeFGI5oL78e+5/VD1yQVpwCzdgrfwHQDCg8YRGnl9bF36DNGBzBQXOd3SyUr18K9XDZMgLUQrk0AtxAkcn5zEUYqo7eAy9CYrPp0ouFu2w+QR30jUmHaUio26gydXkALA6juU8MVXYPUdhtX7zK4XGxr0yUzl/M6dUEoxsX/T56GFEOeGBGohTiCenMRt6OyprOFIKELUVrgMjXSPycHqEH2y6mf6aizzmFKKvZU1LN6wldeKdrHjsB/DANCIWA7+SP2z2PVEw3g/fJvI4PE4Gd1B0whdMfWM3mev9BRMXaM6HEuq0qlOjm4hROuTQC3ECcSTk2wtO8qhQAhN0zA0cJxY2clXN+9kzoQh9V7TWOaxPZU1HAqEUJqG2zSIODbhsIPb1Ik2UUO67oYxo3I/gWvvPa3sYsfzmDo+t8lFXTslRvhuw2DFzbmNngEXQrSOFi0+VVdXM336dG655RamTp3K5s2bASgqKiIvL4/8/HyWLFkCxLIYPfzww0ydOpVp06axa9euM9d6Ic4ij2mQ+41uHAlFEoUnIJb8IyvVQ8HOgw1KV8aDe5yjVOL1pq5xoKqGUNTBAUKWg93YeSzHwfPJKnx//AVG9SHsrF4Evz2lxUG6sVe5DQ2vaZCV4q5X/7omGm2QbU0I0bpaFKhffPFFLr/8cn73u9/xxBNP8OijjwIwb948Fi1axCuvvMInn3xCcXExa9asIRKJ8Nprr/HTn/6UJ5988ozegBBnU/6lF9DJ48LQNRzA0DW6+jz0zvQlSlfWFQ/uwaiVWNOO2gpHKWoiFqVHa5pMOqb5K/D9eQnej/+IphzCg8fj//7sFu/q1jXITHHTyeMixTTwmgY+l066x524j7qkNrQQyadFU9+33norbndsasy2bTweD36/n0gkQt++fQHIzc1l06ZNlJeXM2bMGABGjBjBli1bzlDThTj7undKYWjPTKpC0cT6dHwEGg9q8WNYmSkufl2wjdVflrG/KkjIsvGYOrZjE7EcrOZ2dlsR0t55Gj1YhZOSTnDMTVjntWydWAd0HfpmpdE7IzXRdgC3YTD+ou6s2ra/3mhbakMLkZyaDdRvvPEGL730Ur1rCxcuZNiwYZSXlzNnzhx+9rOf4ff7SUtLSzzH5/NRWlra4LphGFiWhWk2/dEdJaAXFha2dhOSTmv2ScR2OBq2yfAYuI3YhNOFHosN5dXomkak9nmOUgw9rxMP/Pdq/l4WIGA57PdHCURtDF3DpeukuXQiYQtdnUSQBjDdhIddhblvG8HcH6C8ac2/phEGkOqKTbWnaRYBvz92b7XtHts7nYkZEcozNAoPBKiK2KS7DUZm+xjtC7aZn8m20s5zRfqjofbSJ80G6ry8PPLy8hpc37ZtG7Nnz+aBBx5g1KhR+P1+AoFA4vFAIEB6ejqhUKjedcdxmg3SAEOGDMHjad9TcIWFhYwcObK1m5FUWqtPmjr7POKS2JGrd78qo9wfolual+9clM2GHQd5f+dBrNqazCHLBhWroKXpOn4boja4TBPNshqd8jbKv0arqcI6P5Y/OzJwzGmXpExxG3RLSyG7k4crc3qxeW9Fg1zkhq4z6ptNZ1xLZvK7U5/0R0NtqU/C4XCTg9MWTX1v376dWbNm8Ytf/IIBAwYAkJaWhsvlYvfu3fTp04eCggJmzpxJWVkZa9eu5brrrqOoqIicnJyW3YkQZ1FTiU3qHlNStZu/1m0/wAe7D+HUFq2K2A6Oik05Rx0Ht6OBphOxHUBD12Kb0BKJTRwHz6er8RT9GUwX1Z0fRHXqctq7ut26hqnrHA1FuLh7Og9dORTgrKU/FUKcfS0K1IsWLSISifD4448DsSC9dOlS5s+fz/33349t2+Tm5jJ8+HCGDh3Kxo0byc/PRynFwoULz+gNCHG6Gjv7DLFd0OtKDmDZDu9s3YvtKHweF9XhKJ/uO0LIskl1mSh1rJiGA6AgELVx6QqlFC7dRJkQisaqY2n+ClI3/A7zQEns83O+jUrNOO370ACvKxaII7bDZX26JAKzBGMh2q4WBeqlS5c2en3EiBG8/vrr9a7pup7YFS5EMmrs7HNcuT/Ef/59O4drIkQsB1s5KAVhy0EBumbjMQ1UIxPbUcdBA7JS3ZRVx3Z7u3Z8TMqm19EiwdoNYzdjnTfgtNrvMzUsR2HoBgoNXdfo2SmFByY0nuJUCNG2SMIT0eHFzz43dn64oibC/qogpq5j2Q7R2prRmgYoYru5HdUgV7cDGJpGVoobA0XIUng2/x/eor8AEO0z5LQ2jMUZGjjonJfp5byM1NqArXHjkD5S7UqIdkKy7YsOz2MajL8wG+e45COW42DUrlkrpbCUE9solkgQEts4ZjVWUUNBJ48Lt6Gx80gNANG+w1DuFILfnkLNxB+1OEibGqSaBimmjtc0UCqWhtRyHLr4PNw4pI+k/xSiHZERtRAc2zC2ruRAYof0JedlsfrLMqKOw0F/KFYzunYZWyMWiAMRi8aygCrgSCBIdennOOfHNnQ5XXpTlfcIuL0tbme/zqlYCiprIuha7O9sl6Fj2YrxF/Vg7neHt6nd20KI5kmgFgIwdJ37xg9mRu6AxA5pgM17jyRG1KVRm9ge7tgoPKd7Op+XHcWJWhhAVJFYqdaqD5O6YQXmwZ3UjL+V6AWXxB44jSBtaNA51cvOCn+DjW9RR/Hh7sMtfm8hRPKSqW8h6ogfV/KYRmJKXClF36w0zstIxWvqpLpNeqan4DUNXIaGy9BRHAvSrpKP6PT2v2Ee3ImTko7jOTM7rk1dx2MajRbycBka/ki0QUpTIUTbJyNqIZpw79iBRGyHF/9ewpGaMLatgFhyk1S3QXZaCtvKq2JBOhIk5YM3cZd8BEC071CCo/NPe8MYgKlrpLhMRn+jG1sPVNbbvKaUIsvroavPK3m6hWiHJFALcQLxbGUrCnew/2gNug4uU8PQdI4Ewqz7aj/RWDIy9MoyfKuXofsrUIaL4LcmEc359hkpS2kCPrdJr3Qvc68extaDR9n4dXkif3eW10OvjBTJ0y1EOyWBWogTeGbDVv53SyllVUGC9UpS2g2e6/gyUZqO3bk3NeP+CScz+7Q+2yD2B4DP40JXDl1S3dz6rYtIdbtYedt4Fq8tZs1XZfgjUbr6vInUoEKI9kcCtRCNiGcrsx1FVSja6M5urfowKqUTmG5weQlcPSOWYcw4tV+r2iPZQGzDmMcwsJSDy9DJ8Jj0SdX4x29enAjEhq4zZ+JQ7h03qE3m6RZCnBoJ1KJdakmxibqviWcrU6hGg7Sr5CNSNr1BpN+lhK6YChDL1d0Chh5LQerU/udx6fRMTaFXRioRy2FklsZ94xtmGZM83UJ0DBKoRbvSVBUsQ69/yKFuHell73/JupIDlPtDdPK4GNuvO0eCYfYdDdb/gEiQlE1v4N4RK5+nh/zg2KC3bESrAb3TU8lOT+WrQ1VELYecbumkuGK/mikug6LyAGHLllGzEB2UBGqRtFoyKm6qClZ8VHp8MD8ajBCM2mhAZThK1Fa8v7McRzmxIhu1jAM7SN2wIrZhzHTHNoz1v7zFG8Y0wGPoVEcssjWwbIXL1Bvca1Uk1g8yehaiY5JALZLOqYyK64qvK8e/dhk6uqYlqmDNyB2AxzTqBXOXoXPAH8IfttBQeF0mugZBx8F2akttKAdP0V/wfPIXNKWwuvQhOO6fcDK6t/geDS2WCtRj6kSdWKYUU4csr7tBMpN0tyHHroTowCRQi6RzMqPixhysDvHZviNUR6w6R5fc9M5MpaImnAj6dUtaRm1FxI7v6I6VpVRoOE6deliajl5VDgrCQyYSuvS6Fm8Yc2uQ4jYZ0jOTsqoQR0IRlILOqW5GX9CdymCk3uscpRiZ7ZNpbyE6MAnUIqlEbKfJ2tDxUXFjXt28k+pwFEfVVpVyFIcCIQAG9siot0ks/h4uQ8PUdZSKHblSxGayNQ0IB8GdAkDw23lELr4Cu8dFLbovXY+9ucvU6erz4jIM+mT56Omk8J2LsnnoymGYupaYSYjnGx9/YTajfcFm318I0X5JoBZJ5WjYPmFt6PiouLG12rBlU7DzIFmpHg4FwsTDvKZpVATDDOuRCTQsaanXlqKsDkdjzwcI1eBZ/wp6xT781/8UTBe4U045SGvE/hCwHUWKaZDiMvlmny5oGhwJRhKBuO6U/vH5xj2mQWFh4Sl9rhCifZFALZJKhsc4YW3ozqmeE67VxkfKvTN9KKU4UhMh6jg4SqGUxp+37efTskrGX5jN2Auzead2at1Riu6dvBwJhglFbVRZCaz5La7aDWPG4T3Y2Re06F50DbymgWnoXNi1E/84tC9zJgxpdpOcHLsSQtQlRTlEUnEbeqO1oR2lmkyR2cXnoXOqmz1HAlSGoliOwrJVbDTrNkjzmMfWupXi+4N7c7A6yGf7K/niwFGyfW76laxDe/tpNH8FdD8fc+rPoUfLgnSszRCIWLg0jbxhfZk9fhBQv/CHEEI0R0bUIuk0Vhu6uRSZHtNA1zTKA6Hand5gKQelNDRIrHnrmsaGHQfJ/UY3Ovs8ZKS4cY6Ws/vVp6kp/Qo0jawrrqfPd6egGSZb9h+hIhg95XvQNcjwukn3uuidmYquaU3uWBdCiBORQC2STmO1oZsbfVaFItREbLr6PBwNRQnbCqVIlKB0lEoE60OBMKu27SdqOygFe4qLqCn9CuXLxHXVbXhzhqEbJnuO1lATtdE16lWrak6a20TTqE1cEmt3cxvhhBDiRCRQi6R1Mmu1tuPwb+9u4ffFpRSXVeJxmWR4XXTzedl+uBrHUViOImorPKaGUopD/hB7Kv1EndoA3GsEqZdPwhz4baJeHzVRi11HAhz0hwhbDqcQowEwdA1T1/CYx0bQTW2EE0KIpkigFm1WxLIYufiPfFleheOAA4SsKFErdtSqk9ukoiaMqesYtTFzd2WAIyWf41r3MtaEO1AZ2aBpBAeOw23qpGga52X62HagMra57BTao0NixJyZUj9xSVMb4YQQoikSqEVSidgO+47WnNR09z++uJ5tB6tA02Jnn1HYSuGP2AQrA1Bb5ELXbbbsr6S7zyTy/h9QH7yDrhSuz97Fyr0JiAX5sOVgOVE+2n0Iq3auWyN2plopGg3aWu1/mV436SkmKS6TsGXTO9OXeE5zG+GEEKIpEqhFUoinDf3fwj3YHxxqNm1oVSjC33YfxlGgjtshrgDLiY1w3aaB29RJC1dy9Pf/SWhvCQqNyPDvEhpxTYPXxQOyIvZ6p/ba8XRA1zUUikyPm4/v/x66ptcr8HGyG+GEEKIpEqhFUoinDQ1aDp1Smk8buv1QNdXhSLNT08pxYOsHVG18Ay0axvFlUjN22gmTlyhUIjA7jT4jPsrWat8fUtw6uqYn1p9PdSOcEEI0Rc6LiFYXL6ZxorSh4do15/hz9x2toUuqC7uxQtF1OECkqgLeey0WpPtdiv//PdhkhjHnuCnueIv02q9NXcPQj7XTaxoM6ZHVYP1ZzkoLIc4UGVGLVnd8/u264rulszt561XUOhQIYzfyXsdTaVkEL/9H0HTI+RZabRRuKsRrdR5Xtd+7TR3LcUh1m7HHY2W16OLzcGVOTwnIQoizRgK1aHXH59+uK75b+vjSlIdrwhgaNBhUOzaezX/CSe9OtP8oAKI534491kh0NrTYka2609zxp+nEprhdhsbI3p3ZU1mD2zQ4FAiDpuiRnspt37xQ1p+FEGeVBGrR6jymwfgLsxNr0hDbKR22bK65uCdAg9KUlq1wGQbKshOjXo4eJGXDCsxDu1HuFKzzh6Jqq19R+xyXBpHjAnb89cdPeet6rLKWy9BwFAztlcWKm3M5XBMGhUxtCyHOCQnUIinER6VvfbSNryuqqYnapLhM3ttZTiD6KYcCYbx1SlO6DA1N01EoNKVg2we4N72JZkVQaVloE28jrVMnghELakfNmgYeQycaPZbExK7dOWZooKOR4jaI2LHHvaaRCNiGrjH+wmzSvW7Sve5z30FCiA5LArVodfFqUjNyB/D17lKsIyqR1auiJsK7X5VRFYzg7XRsdJzmcVEZjJDqhEn74HWqiv8OQNfhozG/cxP7QsQSnRg6XtMgFLXRNAjZqjb3N/jcJoFIbLo93esiy+vmcE1srTxqOxi6RtR26NkphRuH9JEpbiFEq5BALU5LcyUbmxI/Ox3fIJaZ4mbrvqP07ZrJ3qM1VAYjRG2Fy9AwNY3MVDcHqkO11x2itoN39QtU7f4cw5PC9++ezfNzf0LEdvi3vxbzYekh/rbrMJoGPreBoxTVYQtd13AbOjndM/jiwFEMLbYWfV5mKpqmcSQUwXE0hvfKIveC7jwwYTCpbtdZ6kEhhGiaBGrRIscH2eYSlDSm7gYxj2lQURPmQCBKlVWJ7Rwb+dqOIuzYHPKHOJII3jrdfF4yvncLwbWvsvTXv2bU0AGYhoFpGDxyzQjCls0Taz5lxUc7OFITqbeT21GKikAYj6lj1+YCtxxFnywf56lU3IbOG7eOk2luIUSrk3PUokXiQdYftvCYxxKUPLNh60m9vu7ZaQWUVgb4qryKsK04UhMhbNXPs+02DY4EI1xo1pD95VqG9Mikd2YqR1OzOXTlP/Pght1MeWk9T68rxnacxEh/1tiBpLpMzNoqWrqm4dJ1PKbB0VCEDK8bRXzd+9ivwzUDekmQFkIkBRlRi1PWXIKSkynnWPfs9J7KAIcCYTRim7qiKrazGxy8po5SijSXiyOb1/HV+2+iomF83c/Df95QDgVCKE1D1zT8YYu3i/ewvuQAqvYzfG6TQNRmUI9MLFtRVl1DRe1nRR1F905eQOFxGViOIyk/hRBJRwK1OGUnk6CkuXKOaR4Tn9tFyLKpDEYSGcDchoZlxbJtW7aN7jbIUFHsVS+hf/53FJA17ArS+g2h9GgETYuVlHQZsXfYd7SG4rIIQ3pk4jFjO7irw1H2Ha2hT6aPvpk+dGLr0JqCrBQ3k4f15e4rcqgMRiXlpxAi6UigFqfsZBKUnEjdte2vyo9yNBQlaNmJo1AAWSkuLNvB0TR6VZdS9r+/IVpVgeFJ4bzv30aXS8YStmyidgRdO1ZS0lEqsQEtajt4TANd08jyujlSE+a8jFR0TaNPlo+eTgrfuSibh64clgjMsmFMCJGMZI1anLJ4ghLnuLJSJ1POse7a9jc6p5GV6sZ2HEJRG13XyPSYDOmRSbe0FDy7PqX0v54gWlVB74uH8H7BBn548w9I85goFCkuna4+T6KkZCxAqwbrzb0zU0n3unAbBhHbJs1jcuOQPsz97nAZPQshkp6MqEWLxNdw15Uc4FAgTJrbxZU5PZpc2z1+bVvTNM7PSkMjdl56UHYGwUAAXdc5LzOVH/7gRv7ny3eZ9A//wIMPzME0TWacb3Pj0L6gwZtFu/i/rXsTI3GXoWHqkOV111s/1zSNIT1jWcX8YUumt4UQbYoEatEihq5z79iBWLbDmq/KqA5HKNh5EFPXTnhE60Rr232y0nCUH5emUfrpB3S5YjzfHfwN7h07kPuveg+Px4PtODy9rrjecbCx/brz/cG92VCn9vPoC7pTGYzUe//4SF+yigkh2iIJ1KJFYmeUP2Pt9jJMXSfFZTZbQ/qEa9tK4bGDfP3ac1Ru+Ts7D30Ngx8BwOOJrXcff+baH7Z45/O93DC4N6//cFwieJu6llgDjwdv2cUthGjLJFCLUxLfDPbuV2Vs+rocQ9fITHHTO9NXm6DkxEe06hbfqDs1XfLJR/j//J8ofyWa20vK+QPrBfyTOQ5Wd5f5feMHMyN3QIszpgkhRDKRQC1OSXxkG7WdWIlJR8XKPgJ9ajd1HX9Eq26a0fjI9t2vyjh41E+g4C2qN/wBUPj69KfrdbfRuU8/gEQQPn7KPF5ZCyBkWY0eB/OYRrNHxIQQoi2QQC1OWt2RrcuoLf9Ym+qzMhhJHH+KH9FqLM3o2AuzQSnscJDSF+YTLvsaNI0e35lMj3H/gL+mJvF58YAfnzKvDkUprQxQVhUibMcCtdc0WPFRCfd/Z/BJpy4VQoi2RAK1OGl1R7a6ppHhdXHIH0bXNaJO/GgUiSNaT68rbrCu/JuN21DA+VlppGb3xgkHiI7/J6L9BqEZ9aeo4wE/PmX+643b2Hc0iOUotNrUo5ajeP6Dr3AbeqPr4kII0dad1hCkpKSEkSNHEg7Hpj6LiorIy8sjPz+fJUuWAOA4Dg8//DBTp05l2rRp7Nq16/RbLVpFfGSrlKL0SIDKYISw7RCIWERsm4wUkxsG9+besQMbXVeOBKqoLNvL0VAUWym0sfk4kx8i1OUb7K70s/tIIJHf+/gz2XdfkYPHMHBQxM9juXQdr8vgaCjKu1+VJabDhRCiPWlxoPb7/Tz11FO43ceOu8ybN49Fixbxyiuv8Mknn1BcXMyaNWuIRCK89tpr/PSnP+XJJ588Iw0X5158ZLu7MhDLsa0g1WWQ6jLo7vMwvl82942PTUHHR99xVds/Y9uSB7H+7zdEw2F2H/FTYek4phevqaNrOhU1Yfb7o6R5jgX8uMpgFJ/bxGua+FwmPreJx9RRCqK2Q7k/WO/zhBCivWhRoFZKMXfuXGbPnk1KSgoQC9yRSIS+ffuiaRq5ubls2rSJwsJCxowZA8CIESPYsmXLmWu9OOfuviKHFNPANHQcwNA1uqV5uaBLOgVflydGtfHRt2NZ7P3z7yj57eNY1UfQvKmYVojqUDSRqETTNNI8JkN6ZtK7k4sVN+cmAn5cF5+H7p28uA0NTYOwFRvJByIWoaiNP2yRmSIpQIUQ7U+za9RvvPEGL730Ur1rvXr14rrrrmPAgAGJa36/n7S0tMT3Pp+P0tLSBtcNw8CyLEyz6Y/uKAG9sLCwtZtwSsprohhOhL5pJpaj0DVwHIuqqioOO4o3/7qJfpke3IZOl8pd/O35XxA5WAqaTufR1xMeNhFb0/FH7USgVkqR6TEJBgJEHcX7H35Mt9SGQTcnxeZTzaE8YmPXpi+NZzGtqgnyr6+v5eaBXc5RT5xbbe3n5FyQPqlP+qOh9tInzQbqvLw88vLy6l276qqrWLlyJStXrqS8vJzbb7+dZcuWEQgEEs8JBAKkp6cTCoXqXXccp9kgDTBkyJBEsov2qrCwkJEjR7Z2M05J2LI5/8saqkNR9lTWcCQUIWo52I5C0+CZ4qNkprjpvudj/vriM0SCQbydu9Nz0gx6XzyEsRdmY9kOv9iwlWDUwWXEimb0zkxF0zSsYIDvfPubjZ59HnGJQ/baYh5f8xl2NDZy97h0eqal0CfLR0nYZMjwEe3u3HRb/Dk526RP6pP+aKgt9Uk4HG5ycNqiXd+rV69OfD1hwgReeOEFPB4PLpeL3bt306dPHwoKCpg5cyZlZWWsXbuW6667jqKiInJyclrykSJJ1N2BXREIo2nxHd+xwFl8oBJTNzC+3I8KBpkydSoLFj5BRHfXSz6iA29tKU3sIIfYBrKR2b4TBlpD15l22YW8vaW0Xnvirz/ZEptCCNGWnNHjWfPnz+f+++/Htm1yc3MZPnw4Q4cOZePGjeTn56OUYuHChWfyI0UruPuKHF7423ZMQ69NfOKgaRoEqoj6OuHWdVTOt9DTu3Jh3o10zcps8B6zvzMY09AbpPoc7Qs2+dldfB66pXlbVGJTCCHaotMO1H/9618TX48YMYLXX3+93uO6rvPoo4+e7seIJFIZjJKR4qZrmpdAxOLLssPYH7yN+cVGaq7/KSq7N7qmYfe8iDVflnHv2IENRsmGrjea6rO5NaUTpSE9mRKbQgjRFkkqJ3HK4ju6dU3DqDyA/tZ/4NqyFmwL89DXiU1ipq5RURNmX1XNCd8rnurzVALsvWMHcsPg3qR5zER96eOPcwkhRHshmcnEKfOYBuP6defF3/6WfX9aAVYUp1NXQuOmYfToB5pGyLLRNY0dh6v58cq/M7F/jxOWvzxVJxqNCyFEeySB+hyrW6CirTp06BAfPb+QvX/+MwAZI8YS/NYkLMdIrFtDbETdJdVDMGo3Wf6ypaTwhhCiI5BAfY40VqDiQo/FiEucNldMoqKigvXr15Oens6//cd/kHvVdWSmuPh1wTb+sm0fm/dUoOvHjl1B0+UvhRBCnJgE6nMkXh6yboGKDeVVPLNha5soJhGJRHC5XGiaRk5ODsuXL2fo0KH07t078Zw5E4Ywefj5TH1pPT6Pq0H9aDk+JYQQp65tDeXaqMYKVMCxUWayF5PYunUrEydO5OWXX05cu/baa+sF6bheGan0rC13eTw5PiWEEKdOAvU5cHyBirrio8xkpJRi+fLlTJw4keLiYp5//nkcx2nyNfHjU048t2ctOT4lhBAtI4H6HIgfZ2pMso4yy8vLuemmm3jggQcIhULcfPPNvPPOO+gnsZ4ux6eEEOLMkTXqc6CtJelYs2YNM2fO5ODBg2RkZPD0009z4403nvTr5fiUEEKcORKoz5H4aLJuyszhvdOTbpRp2zaPPPIIBw8eZPTo0SxdurTRteiTIcenhBDi9EkzJBj/AAAO3ElEQVSgPkcaG2Vu+aQoaY5mKaXQNA3DMHjuuedYtWoVP/7xjzEMGQkLIURrkkB9jiXbKDO+Yeyzzz7jmWeeAWDQoEEMGjSolVsmhBACJFB3aOXl5cycOTNRtvSWW25h+KUjZV1ZCCGSiATqDmr16tXMnDmT8vJyMjMzWfz002ys8fH4S+sTgXr8hdlnLD+3EEKIlpF/gTuYUCjEv/zLvzB16lTKy8vJzc3lvffeY2fGRfy+eA/+sJXInPb74j08s2FrazdZCCE6NAnUHcwzzzzDc889h2mazJs3j7feeouu2T3adOY0IYRoz2Tqu4O55557KCoqYs6cOVxyySUAHDhaw+FAuNE1acnPLYQQrUtG1O3cwYMHmT17Nn6/HwCfz8d///d/J4I0tM3MaUII0VFIoG7HVq1aRW5uLr/97W957LHHTvg8yc8thBDJS6a+26FgMMgjjzzC888/D8DYsWOZNWtWk69pLHNafNe3EEKI1iOBup0pLi7mzjvv5IsvvsDlcvHzn/+cmTNnNltMQ/JzCyFEcpJA3Y7s3LmTK6+8knA4zEUXXcRzzz3HiBEjTuk9ki1zmhBCdHQSqNuRCy64gEmTJuFyuXj88cfx+Xyt3SQhhBCnSQJ1G7dq1Sp69uzJ0KFDAfj3xU9TGbIwPbJTWwgh2gMJ1G1UMBhk3rx5LF++nP79+7Pm3XdZ/tEu1pUckBSgQgjRjkigboOKi4v50Y9+xLZt23C5XEybNo3n/76TP2zdh65p9VKAAtw3fnArt1gIIURLyVCrDXEch6VLlzJx4kS2bdtG//79Wb16NXdO/2fW7yyXFKBCCNEOyYi6Dbnjjjt4++23Abj11ltZsGABqamp7JMUoEII0W7JiLoNueaaa+jcuTMrVqxg8eLFpKbGgq+kABVCiPZLAnUSq6mpoaCgIPH9lClT+PDDD/ne975X73mSAlQIIdovCdRJ6rPPPmPChAnk5eXx+eefA6BpGllZWY0+/96xA7lhcG/SPCYR2ybNY3LD4N6SAlQIIdo4WaNOMvENY4899hiRSIT+/fuf1OskBagQQrRPEqiTSFlZGTNmzGDdunUA3H777Tz66KOJteiTISlAhRCifZFAnSTee+89brvtNioqKujcuTO/+tWvuPbaa1u7WUIIIVqZBOok0aNHD0KhEOPHj+fZZ5+lR48erd0kIYQQSUACdSvat28fl156KZqm0b9/f1atWsWAAQOaLUkphBCi45CI0Aocx2HJkiXccccd/Nd//Vfi+qBBgyRICyGEqEdG1OfY/v37mTFjBuvXrwdgx44drdwiIYQQyUwC9Tn0xz/+kVmzZlFRUUGXLl34yU9+wj333NPazRJCCJHEZJ71HAgGg9x3331MmzaNiooKJkyYQEFBAZdffnlrN00IIUSSk0B9DmiaxkcffYTb7ebxxx/n9ddfJzs7u7WbJYQQog2Qqe+zxHEcQqEQqampeL1eli9fTjQaZciQIa3dNCGEEG2IBOqzYO/evdxzzz106dKF5cuXo2kaF198cWs3SwghRBskgfoM+8Mf/sCsWbOorKykW7du7N+/n169erV2s4QQQrRRLVqjtm2bBQsWkJ+fz6RJk1i7di0ARUVF5OXlkZ+fz5IlS4DYFPDDDz/M1KlTmTZtGrt27TpzrU8igUCAWbNm8cMf/pDKykquvPJK3nvvPQnSQgghTkuLRtRvv/02lmXx6quvcuDAAf70pz8BMG/ePH71q1/Rp08f7rrrLoqLi9m7dy+RSITXXnuNoqIinnzySZYuXXpGb6K1FRUVcdddd7F9+3Y8Hg+PPPIId911F5qmtXbThBBCtHEtCtQFBQXk5ORw1113oZRi7ty5+P1+IpEIffv2BSA3N5dNmzZRXl7OmDFjABgxYgRbtmw5c61PEq+88grbt29nwIABLF++nEGDBrV2k4QQQrQTzQbqN954g5deeqnetaysLDweD8uWLePDDz/koYceYtGiRaSlpSWe4/P5KC0txe/317tuGAaWZWGaTX90sgd0pVRixHzDDTcQjUaZPHkywWCQwsLCk36fU3luRyF90pD0SUPSJ/VJfzTUXvqk2UCdl5dHXl5evWv33Xcf48ePR9M0Ro0axddff01aWhqBQCDxnEAgQHp6OqFQqN51x3GaDdIAQ4YMwePxnMq9nDO///3v+eUvf8lbb71Feno6AKNHjz7l9yksLGTkyJFnunltmvRJQ9InDUmf1Cf90VBb6pNwONzk4LRFm8lGjhyZyFX9xRdf0LNnT9LS0nC5XOzevRulFAUFBVx22WVceumlbNiwAYit5ebk5LTkI5OC3+/nxz/+MbfeeiubN2/m5Zdfbu0mCSGEaOdatEY9ZcoU5s2bx5QpU1BKMX/+fADmz5/P/fffj23b5ObmMnz4cIYOHcrGjRvJz89HKcXChQvP6A2cKx9//DF33303JSUleL1eHn30Ue64447WbpYQQoh2rkWB2u1288QTTzS4PmLECF5//fV613Rd59FHH21Z65KAbds888wzPPHEE1iWxaBBg3j++ecZOHBgazdNCCFEByC5vptRUFDAY489hmVZTJ8+nTVr1kiQFkIIcc5IZrITiO/qHjduHLNmzWL06NFceeWVrd0sIYQQHYyMqI/j9/uZNWsWRUVFiWvz5s2TIC2EEKJVyIi6jsLCQu6++2527NjB5s2bWb9+vWQXE0II0apkRE1sw9jixYu59tpr2bFjB4MHD2bZsmUSpIUQQrS6Dj+i3rNnD9OnT+f9998HYPr06Tz88MN4vd5WbpkQQgjRwQN1NBrle9/7HqWlpWRnZ7NkyRImTpzY2s0SQgghEjr01LfL5WLu3Llcc801vPfeexKkhRBCJJ0OF6g/+ugjXn311cT3kydP5uWXX6Zr166t2CohhBCicR1m6tu2bZ5++mmeeuopDMNg+PDhicQlsmlMCCFEskraQB2xbc5U7azS0lKmT5/Opk2bALj77rvp16/fGXp3IYQQ4uxJ2qnve1b+jafXFWM7zmm9z8qVKxkzZgybNm0iOzubN998kwULFiRtCU0hhBCirqQN1DVhm98X7+GZDVtb/B6LFy/mzjvvpKqqimuvvZaCggImTJhwBlsphBBCnF1JN/WtlAIgwx37G2Jz6UGqay7AbRin/F7XX389b775JjNmzGDy5MlomkY4HD6j7T1dydaeZCB90pD0SUPSJ/VJfzTUVvokEokAx+Lf8TR1okdaSXV1NV9++WVrN0MIIYQ4p3JycujUqVOD60kXqB3HIRAI4HK5ZDe2EEKIdk8pRTQaxefzoesNV6STLlALIYQQ4pik3UwmhBBCCAnUQgghRFKTQC2EEEIkMQnUQgghRBKTQH2O2LbNggULyM/PZ9KkSaxduxaAoqIi8vLyyM/PZ8mSJUBs5/vDDz/M1KlTmTZtGrt27WrNpp9VJSUljBw5MnHesSP3R3V1NdOnT+eWW25h6tSpbN68GejYfVJXR7znuGg0ypw5c7jpppuYPHky7777Lrt27eIHP/gBN910E/PmzcOpzeK4ZMkSJk+eTH5+Pp9++mkrt/zsO3z4MOPGjaOkpKT99okS58TKlSvVvHnzlFJKlZWVqRdffFEppdQNN9ygdu3apRzHUT/60Y/Uli1b1F/+8hf14IMPKqWU2rx5s5o+fXortfrsqq6uVnfeeae6/PLLVSgUUkp17P745S9/mfi5KCkpUTfeeKNSqmP3SV0d8Z7j3nzzTbVgwQKllFIVFRVq3Lhx6u6771YffPCBUkqpuXPnqlWrVqktW7aoadOmKcdx1N69e9WkSZNas9lnXSQSUTNmzFDf/e531fbt29ttnyRdZrL2qqCggJycHO666y6UUsydOxe/308kEqFv374A5ObmsmnTJsrLyxkzZgwAI0aMYMuWLa3Z9LMi3gezZ89mxowZAB26PwBuvfVW3G43EJuB8Xg8Hb5P6iosLOxw9xx3zTXXcPXVVye+NwyD4uJiRo0aBcDYsWPZuHEjF1xwAbm5uWiaRq9evbBtm4qKCjp37txaTT+rnnrqKfLz83nuuecA2m2fSKA+C9544w1eeumleteysrLweDwsW7aMDz/8kIceeohFixaRlpaWeI7P56O0tBS/31/vumEYWJaFabbN/12N9UevXr247rrrGDBgQOLa8ffdXvsDGu+ThQsXMmzYMMrLy5kzZw4/+9nPOlSfNKcj3nOcz+cDYn1w77338pOf/ISnnnoqkRTK5/NRXV2N3+8nMzOz3uuqq6vbVFA6Wf/zP/9D586dGTNmTCJQK6XaZZ+0/5/wVpCXl0deXl69a/fddx/jx49H0zRGjRrF119/TVpaGoFAIPGcQCBAeno6oVCo3nXHcdr0P0aN9cdVV13FypUrWblyJeXl5dx+++0sW7asQ/QHNN4nANu2bWP27Nk88MADjBo1Cr/f32H6pDnH/750hHuua//+/dxzzz3cdNNNXH/99fz7v/974rH4z0Vj/6Y0lpKyPVi5ciWaprFp0ya2bt3Kgw8+SEVFReLx9tQnspnsHBk5ciTr168H4IsvvqBnz56kpaXhcrnYvXs3SikKCgq47LLLuPTSS9mwYQMQ20iUk5PTmk0/K1avXs2KFStYsWIF3bp144UXXujQ/QGwfft2Zs2axaJFixg3bhxAh++TujriPccdOnSI22+/nTlz5jB58mQABg0axN/+9jcANmzYkPi5KCgowHEc9u3bh+M4bWrkeCpefvllfve737FixQoGDhzIU089xdixY9tln3ScP0db2ZQpU5g3bx5TpkxBKcX8+fMBmD9/Pvfffz+2bZObm8vw4cMZOnQoGzduJD8/H6UUCxcubOXWnzsduT8WLVpEJBLh8ccfB2JBeunSpR26T+q66qqrOtw9x/3mN7+hqqqKZ599lmeffRaAn//85yxYsIDFixfTr18/rr76agzD4LLLLmPq1KmJXfIdyYMPPsjcuXPbXZ9Irm8hhBAiicnUtxBCCJHEJFALIYQQSUwCtRBCCJHEJFALIYQQSUwCtRBCCJHEJFALIYQQSUwCtRBCCJHEJFALIYQQSez/AyTV1hQ68MmLAAAAAElFTkSuQmCC\n", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "text/plain": "
" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from yellowbrick.regressor import PredictionError\n", - "from sklearn.model_selection import train_test_split\n", - "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", - "model = get_clean_model()\n", - "visualizer = PredictionError(model)\n", - "visualizer.fit(X_train, y_train) \n", - "visualizer.score(X, y)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4-final" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} \ No newline at end of file diff --git a/examples/Feature Selection.ipynb b/examples/Feature Selection.ipynb deleted file mode 100644 index 435f37d..0000000 --- a/examples/Feature Selection.ipynb +++ /dev/null @@ -1,466 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Feature Selection\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "from matplotlib import pyplot as plt\n", - "import catboost \n", - "from catboost import Pool\n", - "from sklearn.model_selection import cross_val_score\n", - "from sklearn.linear_model import LinearRegression\n", - "from sklearn.metrics import r2_score\n", - "from sklearn.model_selection import KFold\n", - "from sklearn.pipeline import make_pipeline\n", - "from copy import deepcopy\n", - "\n", - "from bartpy.sklearnmodel import SklearnModel\n", - "from bartpy.features.featureselection import SelectNullDistributionThreshold, SelectSplitProportionThreshold\n", - "from bartpy.diagnostics.features import *\n", - "\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": "Text(0.5, 1.0, 'X v y')" - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "text/plain": "
" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "x = np.linspace(0, 5, 1000)\n", - "X = np.random.normal(0, 3, size = 1000 * 2).reshape(-1, 2)\n", - "X[:, 0] = x\n", - "X = pd.DataFrame(X).sample(frac=1.0).values\n", - "y = np.random.normal(0, 0.1, size=1000) + np.sin(X[:, 0])\n", - "plt.scatter(X[:, 0], y)\n", - "plt.scatter(X[:, 1], y)\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.title(\"X v y\")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": "100%|██████████| 50/50 [00:00<00:00, 254.49it/s]\n 0%| | 0/200 [00:00)" - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model = SklearnModel(n_samples=200, n_burn=50, n_trees=10, store_in_sample_predictions=False, n_jobs=1)\n", - "model.fit(X, y)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmoAAAKUCAYAAAC0ShQWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeZhU1bXw4d+qqp5paEZlFA3GqzgQxSnmGhK9TnGK1yQaHFARB3Jjol5jNBfFiFETh0RERXFup09jNEaNQ0IMGgdMlEFUCDKjINBA01MN6/tjn6o+XV3dNN3VXae61/s8/VB1zqlTu4oaVu21196iqhhjjDHGmOAJ5boBxhhjjDEmMwvUjDHGGGMCygI1Y4wxxpiAskDNGGOMMSagLFAzxhhjjAkoC9SMMcYYYwLKAjVjTKCJyN0i8n+5bkdbicgIEakWkXCu22KMyX9i86gZY3JJRJYBOwExIA58BDwMzFTVRA6b1iZe+yeq6mu5bosxpvuxHjVjTBCcoKrlwC7AjcDPgFm5bZIxxuSeBWrGmMBQ1c2q+jzwA+BsEdlbRB4UkesBRKSviLwgIutFZJN3eVjy9iKyq4i8ISJbReQ1EblTRB719o0UERWRs0VkhYh8KSJX+25bJCK3i8ga7+92ESny9g3w7qtKRDaKyN9FJCQijwAjgD966c4rfPcT8W7bT0Qe8M65SUT+0No5u+q5NsbkB/tQMMYEjqq+C6wC/jNtVwh4ANfzNgKoBab79j8GvAv0B64Fzsxw+m8AewBHAFNEZE9v+9XAIcAYYD/gIOAX3r7LvPYMxKVpr3LN1DOBFbgewV6qenOG+3sEKAVGA4OA21o7ZwtPiTGmh7JAzRgTVGuAfv4NqrpBVZ9R1RpV3QpMA74JbhA/cCAwRVUbVHUO8HyG805V1VpV/RD4EBeUAYwHrlPVdaq6HphKY6AXBQYDu6hqVFX/rm0Y4Csig4FjgQtVdZN327915JzGmJ7FAjVjTFANBTb6N4hIqYjcIyLLRWQL8AZQ4VVYDgE2qmqN7yYrM5z3c9/lGqCXd3kIsNy3b7m3DeDXwBLgFRFZKiJXtvExDPfatCnDvvae0xjTg1igZowJHBE5EBeozUnbdRkubXmwqvYGDk/eBFgL9BORUt/xw3fgbtfgUqpJI7xtqOpWVb1MVXcDTgAuFZEjvONa6wVb6bWpIn3Hds5pjDGABWrGmAARkd4icjzwBPCoqs5PO6QcNy6tSkT6Adckd6jqcmAucK2IFIrIobgAqK0eB34hIgNFZAAwBUgWIhwvIqNERIAtuGlE4t7tvgB2y3RCVV0LvATM8AohCkTk8Dac0xhjAAvUjDHB8EcR2YrrgboauBU4J8NxtwMlwJfA28DLafvHA4cCG4DrgSeB+ja24XpcoDcPmA/809sGsDvwGlAN/AOYoaqzvX2/wgV4VSJyeYbznokbj/YxsA74SRvOaYwxgE14a4zpxkTkSeBjVb1muwcbY0wAWY+aMabbEJEDReQr3hxnxwAnAX/IdbuMMaa9IrlugDHGZNHOwO9x86itAi5S1X/ltknGGNN+lvo0xhhjjAkoS30aY4wxxgSUBWrGGGOMMQFlgZoxxhhjTEBZoGaMMcYYE1AWqBljjDHGBJQFasYYY4wxAWWBmjHGGGNMQFmgZowxxhgTUBaoGWOMMcYElAVqxhhjjDEBZYGaMcYYY0xAWaBmjDHGGBNQFqgZY4wxxgSUBWrGGGOMMQFlgZoxxhhjTEBZoGaMMcYYE1AWqBljjDHGBJQFasYYY4wxAWWBmjHGGGNMQFmgZowxxhgTUBaoGWOMMcYElAVqxhhjjDEBZYGaMcYYY0xAWaBmjDHGGBNQFqgZY4wxxgSUBWrGGGOMMQFlgZoxxhhjTEBZoGaMMcYYE1AWqBljjDHGBJQFasYYY4wxAWWBmjHGGGNMQFmgZowxxhgTUBaoGWOMMcYElAVqxhhjjDEBZYGaMcYYY0xAWaBmjDHGGBNQFqgZY4wxxgSUBWrGGGOMMQFlgZoxxhhjTEBZoGaMMcYYE1AWqBljjDHGBJQFasYYY4wxAWWBmmk3EXlQRK7PdTuM6SgRWSUi49p47EQRmd25Leo6IvKJiPxnrtvRE4jIeBF5JdftMPnFArVuQkQmiMh8EakRkc9FZIaI9Ek7Zi8ReV5ENovIVhH5i4gc0kXtUxEZ1RX3ZTpGRKp9fwkRqfVdH98F97/Kd59VIvKmiEwSEcnS+R8VkWuzca6OEpE5IjLBu3ykiCzr5Ptr9thVdQ9V/Xtn3m9PIiLfEJG3vM/Zjd7r90AAVa1U1aNy3UYAEektIreLyArvvbbEuz4g120zTVmg1g2IyGXATcD/An2AQ4CRwCsiUuAd8xXgTWA+sCswBPgD8KqIHJSDZpuAUtVeyT9gBXCCb1tl+vEiEumEZhzr3f9I4NfAVcDMTrifbqOT/h/MDhCR3sALwB1AP2AoMBWoz2W70olIIfA6MBo4BugNfB3YAATm+8Be0x5Vtb88/sO9waqB76dt7wWsA872rj8CvJjh9ncBf23h3OOAVbgvyS+BZcB43/4Hget9188HlgAbgeeBId72NwAFtnlt/UGunzf7a/PraxlwZNq264EngceBrcAE3I++q4B/e6+VJ4C+vtscBrwNVAEfAIe3cp+rgHFp2w4FEsB/eNeLgVuBlcAXwAyg2Nt3pNfuKbgvns+A07x9FwNRoMF7LT7ru89LcT9kNnuPraiF9k30XtMzvGMXAd/y9p0OvJN2/M+Ap1s41xzv+esD1HqPsdr7G9Ta8wqM8t5X5+AC6r94xz8NfO4917OBPdvw2Mf5ntffAWuB1d5zXJj2vF4BrAfWAGfl+jUapD9gLFDVyv4JwBzf9aOAT7zX0Qzgb8BE37FvArd5/5dLccHUBO91n/p8947/DvAvYIu3/9pW2jHRe9/0auWYPb3XTxWwEDjRt+9B4E7gT7jPgHeAr3j77gZ+k3au54BLvctDgGe819BnwI99x13rvX4f9R7HRKAEeAjYhHuvXQGs8t1me+d7CnjYa+dCYKxv/3Dg995tNwDTffvO9e5vE/BnYJecva5y/cK2vw7+B7pfQzEgkmHfQ0Cld/lz4JwMx3zLu31xhn3jvH23AkXAN3HB1h7e/gfxAjXg27gvkv29Y+8A3vCdS4FRuX6+7G+HX1/LyByoNQAn4AKDEuBy3JfKUNyX/SzgEe/44d6H4NHe8cd4r5X+Ldxns0DN274GON+7PB14FuiL+7HyIvBLb9+R3uv2195r8dtATfL1530JXJvhPt8Gdgb6A5/ifWFmaMdE7/w/BgqAH+K+zCq856IK2N13/HzgpBbONQeY4Gv3srT9rT2vyUDtAaDUu+8Q7ou83Dt+OjDXd76WHvs47/INwFvAQFyg+A5wTdrzeo33uE/EfR70zvXrNCh/3mtxA+6z91h8P1a8/RPwAjVgAC4YOQWIAJfgAml/oBbDBeJh3PtuBS5AKsIFeVvxgi3c5/U+3mtgX1wgdnIL7XwCeKiVx1GA+9F9FVDovYe20vSzfyOu9y0CVAJPePsOxwWK4l3vi/sRMsRr2/u4H1GFwG64APRo79hrvefgZBo/W27EBbB9gWHAPLxArY3nqwOO857DXwFve/vCwIe4QLgM9375hrfvZO/x7+k9vl8Ab+XsdZXrF7b9dfA/EM4APm9h343AK97lGHBMhmP+A/dhPyTDvnHe7cp8254C/s+7/CCNgdos4Gbfcb28N9xI77oFann4R8uB2l/Sti0Gvum7PhyX7gkBVwMPpB3/Or7e2bR9LQVqc3G9UyHvw3cX377/BBZ7l4/EBZKlvv2/B37uXW4pWDnNd/1WfL+u046diO+LyNv2T+B07/K9wFTv8hhcUFrQwrm2F6i19rwmA7URrfz/DfCOKdvOYx/nXV4OHOXb9x1gia991UDYt38jvh4K+0v1RD3oPa8xXHZhJ2/fBBoDtbOAf/huJ97ryh+oLfbt38f7v9zJt20DMKaFdtwO3NbCvleBG1t5DP+J+3Ef8m17PPna8R7ffb59xwEf+x7HCrxec1ym5S/e5YOBFWn39XO8zwdcYPVG2v5U4OVdn0hjoNaW873m27cXUOtdPhTXk5apk+Ml4Dzf9RDux94uuXhN2Ri1/PclMKCFXP5g3AsxedzgFo5Rb38mm1R1m+/6ctwvo3RDvH0AqGo17kNkaKutN/lqZdr1EcAfvcH/VbheJMX1yuwCnJ7c5+0/hMyvo9YMxQUGO+N6FD70ne8F776SNqhqje96S69bv899l2twPzZaskq9T/AM538ISBZdnAE8qarR7dx3S1p7XpNS/xciEhaRm0VkqYhswfUKgAvY2mIwvvexd9n/Hv5SVeO+69t7nnocVV2kqhNUdRiwN+51cXuGQ4fg+7/zXk+r0o75wne51jsufVsvABE5WET+KiLrRWQzcCEt/79vIPP3QZO2qWrCty39tZDx/eI9jidwwwDA9Tgnx7buAgxJ+yy4CtjJd670z5Yhadv8l9tyvvR2Fnvfl8OB5aoaa/bo3Xl/6zvnRlwAmpPvMwvU8t8/cL+wT/FvFJEyXNf737xNrwHfy3D77+O6ghtaOH9f71xJI3ApqHRrcC9u//33x41zMd2Ppl1fBfyXqlb4/opV9XPcB+sDafvKVPXXbb0zrzp5J1wP1Be4HrM9fOfro6r+Kuf+IlLiu+5/3aa3vT2GpV1PnV9V53htPgz3ZfVIG8+ZqV2tPa949+e/3Vm43o1v48a9JSutkxWz23vsa/G9j3GPy97D7aSqH+N6n/bOsHstvteRV9Wc/rraEY/heu+Ge++Fu2n8f0/3GnB02me73xpguIj4Y4QdeS08DpwqIrvger2e8bavBD5Lez2Xq+pxvtumv0abPE+4ACupLedryUpgRAudHCuBC9LOW6Kqb7XhvFlngVqeU9XNuKqiO0TkGBEpEJGRwP/D9ZIlf8lMBb4uItNEpJ+IlIvI/+DGP1yznbuZKiKF3lxLx3vnTvcYcI6IjBGRItxYl3dUdZm3/wvc+AHTPd0N3CAiIwBEZJCInOjtewT4roj8l9fjUywi3xKR7faoiUgf7zyPAQ96vRVx4D7gdhEZKM4wEfFPexACrvVet+NwP1qe9vZl47U4WER+JCIRETkN+Arwsm//I7hCnW2q+nYbz/kFrne83Lettec1k3LcD7cNuHFr0zLcR2uP/XFgiogMEJGBwP/h0qWmDUTkP0TkMhEZ5l0fjgvWM70G/gTsIyIne8HCZFxvcXuVAxtVtc6r5P9hK8c+ggtGnvHaHBKR/iJylYgchxubuA24wvtOGYcbk/pEWxqiqv/CZXPuA/6sqlXerneBLSLyMxEp8T4P9k5OX9KCp4Cfi0hfERkK/Mi3rz3n8992LXCjiJR5n0uHefvu9u5zNKQ+hzJ1dHQJC9S6AVW9Gdfd+xvcgM/PcB/SRybTlqq6GPgGsB9u3FEV8Evgu6r6aiun/xxX9bIGF/Rd6P1KTG/D67gP9WdwL/6vAKf5DrkWeMjrSv5+ex+rCaxbcYHK6yKyFTcgPTl31DLgu7jXx3rc+JXLaP3z5yURqfaOvRJXGDDRt/8yXCrmXVzF3CvA7r79q3BfNGtxqciJ3nsA3JfHfiKySUSepn3ewk1tsBH32v5vVd3k2/8wrhelrb1pqOoC3Ptnmfc+GUQrz2sLHsC9V9fgKtzSewC299in4gZYz8cN2n4HNwDbtM1WXA/SOyKyDRegLcC9XptQ1S9xWY6bcYH1XrhxmO2dyuNi4DrvdTIFF+BkpKr1uDGHH+PGq23BvZcG4H5gN+CKRY7F/eCfgavwbfbZ34rHvft4zHe/cVzANwb3PfUl7jXZJ9MJPNfh3s+f4XoCn8Z7jtp5vvS2jMJ9zqwCfuDtexY35dUT3hCCBbjnIieSVRmmGxGRc3EfuIep6ooWjhmG+xC5RlVntXDMOOBRb6yFMXlBRI7EDXQemcM2lOGmT9hbVT/LVTtM/vDSjKtwRTZ/zXV7gkpELsIV/nwz123pKtaj1g2p6v24Hravt3LMKtwvhMEiYoOBjcmuycCbFqSZ1ojI0SJS4Q0XuQo3pqytqfIeQUQGi8hhXnp2D1zv5LO5bldXsll/uylV3W7KRVXn41IcxpgsEZFVuKlpTsp1W0zgHYpLDRYCH+HmPavNbZMCpxC4B7eiThVunNyMnLaoi1nq0xhjjDEmoCz1aYwxxhgTUN0u9TlgwAAdOXJkrpthDKxaBV98wftuktCBuWqGvSdM0Lz//vv2njDGs733Q7cL1EaOHMncuXNz3QzT073zDnz96zBxInLffcu3f4POY+8JEzQiYu8JYzzbez9Y6tOYbKurg3POgSFD4De/yXVrjDHG5LFu16NmTM5NnQqLFsHLL0Of7c67aIwxxrTIetSMyab33oObb4bzzoOjj851a4wxxuQ5C9SMyZb6epgwwaU8b7kl160xxhjTDVjq05hsue46+OgjePFFS3kaY4zJCutRMyYb5s6Fm25yRQTH5mztXmOMMd1M4AM1ESkWkXdF5EMRWSgiU3PdJtNzVFbCyJEQCrl/KyszHFRf7wK0nXaCW2/d7jlFZLiI/FVEFnmv6UsyHCMi8jsRWSIi80Rkf9++s0Vksfd3dkcenzHGmGDLh9RnPfBtVa0WkQJgjoi8pKq2cK3pVJWVMGkS1NS468uXu+sA48f7Drz+eliwAF54ASoq2nLqGHCZqv5TRMqB90XkVVX9yHfMscDu3t/BwF3AwSLSD7gGGAuod9vnVXVTBx6qMcaYgAp8oKZuMdJq72qB92cLlJpOd/XVjUFaUk2N254K1P75T/jVr+Dss+E732nTeVV1LbDWu7xVRBYBQ3GLMiedBDzsvf7fFpEKERkMjANeVdWNACLyKnAM8Hh7HuMbq96gId7Qnpt2ipCEOGTwIZQWlOa6KSkJTfD22repidZs/2ADQHlhOQcPPjjXzTBmh1XXx1i3pY7dBvbKdVNSAh+oAYhIGHgfGAXcqarvpO2fBEwCGDFiRNc30HRLK1ZsZ3tDg6vyHDQIbrutXfchIiOBrwHvpO0aCqz0XV/lbWtpe/p52/SeuPata1lfu37HG96JLh97OWePDk5Gd8GXC7jg1Qty3Yy8sme/PXnqhKdy3Qxjdtjds//No+8s54MpR+W6KSl5EaipahwYIyIVwLMisreqLvDtnwnMBBg7dqz1tpmsGDHCpTszbQdg2jSYPx+efx769t3h84tIL+AZ4CequiV9d4abaCvbm25o43vi3qPuJZaItbnNne3UP57Ktui2XDejiWR7fnnYL9mz3545bk1+KI4U57oJxrTL0i+rqaqJEo0nKAgHYxh/XgRqSapaJSKzcameBds53JgOmTat6Rg1gNJSt51//QtuuAHOPBNOOGGHz+2Nt3wGqFTV32c4ZBUw3Hd9GLDG2z4ubfvsHW6A5ysVX2nvTTtFWMKBChyBVHt27bMre/TbI8etMcZ0ptWbagHYVh+jorSw2f5TZrzJWYeO5OSvNUtkdJpghIutEJGBXk8aIlICHAl8nNtWmZ5g/HiYORN22QVE3L8zZ8L47zW4Ks8BA+D223f4vCIiwCxgkaq2VCb6PHCWV/15CLDZG9v2Z+AoEekrIn2Bo7xt3UJYwsQ0WIFaXOMARCSvftcG1ssvvwywt1fRfGX6fhEpEpEnvf3veMMDEJFCEXlAROZ7swCM893mAG/7Eq9aOlPPszHbtbqqDnBj1dKpKv9cUcVHa9MTIJ0rHz55BgMPeePUQsBTqvpCjttkeojx49MqPAGm/go+/BCeew769WvPaQ8DzgTmi8gH3rargBEAqno38CJwHLAEqAHO8fZtFJFfAu95t7suWVjQHURCEeKJeK6b0USyPZFQPnxcBls8Hmfy5MkAn+Iql9/zqpb9hTTnAZtUdZSInAbcBPwAOB9AVfcRkUHASyJyoKomcFXRk4C3ce+dY4CXuupxme6hLhrny+p6ALbVN/8cisbdKJKGWKJL2xX4Tx5VnYcbbG1M7n34oZuOY/x4OPHEdp1CVeeQeayZ/xgFJrew737g/nbdecCFQ8FLfUY1CrjePtMx7777LqNGjWLp0qUNqtogIk/gKpzTK56v9S4/DUz3esj2Al4HUNV1IlIFjBWRlUBvVf0HgIg8DJyMBWpmB63dXJe6nKlHLZZwAVp9rGt/TAY+9WlMYESjrsqzf3/47W9z3ZpuKSKRVKoxKJI9auGQBWodtXr1aoYP9w+9zFi1nKpsVtUYsBnoD3wInCQiERHZFTgAN45zqHee1s6JiEwSkbkiMnf9+mBVOptgSI5PAzdGLV005nrU6qNd26NmgZrp8dq0+gDAjTfCBx/A3Xe7YM1kXSQUCVyPWmqMmqU+O8x1FDffnHa9pcrm+3FB2FzgduAt3OTRba6EVtWxqjp24MCBO9Js00OsrmqsHMsUqDXEkz1qFqgZ02WSqw8sXw6qjasPNAvW5s2DX/4STj8dTj45J23tCcKhcGB71KyYoOOGDRvGypUrm2zCVTP7pSqeRSQC9AE2qmpMVX+qqmNU9SSgAljsHT9sO+c0ponNtVEmPPAua6oae9GShQSQOfUZjVvq05guk+xFO+OMllcfSIlGXZVn377wu991ZTN7nCBOzxFNeGPULPXZYQceeCCLFy8GKBSRQuA0XIWz3/NAcsbjU4G/qKqKSKmIlAGIyH8BMVX9yKuG3ioih3hj2c4CnuuKx2Pyw+xP1rEorVLz47VbmP3Jet5b1liLtXpTLcUFLizK1KMW84oJrEfNmE7m70VrSZNVCW6+2S0VddddbkoO02kCWfXp9fBZMUHHRSIRpk+fDvBVYBGuin+hiFwnIsnqnFlAfxFZAlwKJKfwGAT801ty7We4yumki4D7cFXS/8YKCYzP1c8u4JZXPm2ybXOt+wG2cVvjEnprqmr56k7lAGxraP45lKvUp/Xlmx4n0xqe6VKrDyxYAFOnwg9+AKec0ult6+kiEgnePGo2PUdWHXfccQALVHVscpuqTvFdrgO+l347VV0GZJxxWFXnAntnu62me9hcG2Xxuq3NtgFs8gVqq6tqGTO8gkVrt2wn9Wk9asZ0qpbW8ExKrT4Qi7kqz4oKuOOOrmhajxfE6TmS7bFAzZj8E08o1fUxVmysoS7a2Eu2pc69rzd4gVoioazdXMuQihLKiiKtpz6jNkbNmE7VyhrljasPjAd+/Wt4/32YMQOsSqxLhCV4xQTJHj5LfRqTf6q9gEwVlqyrTm1PT32ur64nGleG9i2hrDCSsUctmfrs6glvLVAzPUaygGD5crcklF9pKTz6KCxb5gVpCxfCtdfC974Hp57a9Y3toQpCBcEbo2apT2PyytxlG3nug9UAbKmLprb7A7UtaYHaaq/6c2hFMWVF4czzqFnq05jOk15AoNoYrDXpRQOX8jznHOjdG9zAZ9NFApn6tB41Y/LKw/9Yzo0vuSXB/YHap180jlNrFqhtSgZqpV7qM9MSUhaoGdNpMhUQqLogLdWLlnTLLfDee3DnnTBoUFc2s8cL5KLsiThhCWPrfBuTH+IJparGBWJb6xo/Txb7e9S8AG5TjQvUkvOpDakopldR5tRn4/QcmXv93/r3l5w0fU7WU6MWqJkeoaUCgmbbP/oIpkyB//5vl/Y0XSqI03PENGZpT2PySDyh1Ebj1EXjqUBteL8SFvt61FJVnzVREgllTVUtvYsjlBcXUFaYuZhge9NzvL9sEx+u2txkyo9ssEDN9AgtFRA02Z5MeZaXu94060HpckFdmcDSnsbkj7i3VNmW2mgqxXnAiL5NKj+TgVo8oWypi7K6qo4hFSUALVZ9Rn3FBJmWQ9vo9c5ta8huVsACNdMjTJvmCgb8UtNwJN16K7z7rgvSdtqpS9tnnIgEb63PWCJmqxIYk0cSCRdEVdVG2eqlOA8Y2Y+Ewr/Xu/TnltoYRREXAm3Y1sCaqtpUoNarKNxq6hMy96ol52SryTC+rSMsUDM9wvjxrmBgl11cR1mzAoJFi1zK85RT4Pvfz2lbe7JAjlHTuK3zaUweSXi9XVU10VTqc/8RFUBj5efm2igj+5cBrqBgzeZahlQUA16PWkO8Wa9ZMvUJmQO1jd64uJos96jZp4/pMcaPTysaSIrHXcqzrMzNmWYpz5wJ5Bi1hI1RMyafJDu+NtU0sKUuSklBmN0HlRMOCUvWVdMQS1AbjTNyQCmffLGV1ZtqqaqJNkl9xhNKfSxBcUFjb3rUF6hlKhhI9ahlWH6qI+zTx5jbboN33oHHHrOUZ44FcnoOS30ak1eSqc/NXo9aeXGEwkiInXsXs3pTbaric+QA16O2YPVmAIamUp8uNNpWH2sSqDVNfTYPxpJFBDZGzZhs+vhj+MUv4OST4bTTct2aHi8ikeAVE6gVExiTT+KpMWoNqUANYHCfYtZsrk0VGOzqpT4XrHGBmr9HDWg2l1p0O6nP5FQfNkbNmGyJx+Hcc11VwV13WcozACKh4BUTxBNxCkIFuW6GMaaN4r4xalvqopQXu/fvkIoS1m6uS1V87tS7mNLCMAtXb0ntB1dMADQrKGgyRi3aNFCri8ZTKc9sj1GzQM30XL/9LfzjH27B9Z13znVrDAFNfWrMetSMySP+qs8tdTF6l7hAbXBFMWur6qjyArXeJRH6lhaytT5GSGCn8iLA16OWFnBFYy2nPpO9ae521qNmTMd9+qlbruDEE+GHP+zSuxaR+0VknYgsaGH//4rIB97fAhGJi0g/b98yEZnv7ZvbpQ3vAoFclN3GqBmTV5I9am6MWjSV+hzSp4SGeILP1m8DoE9JAf17FQKwc+9iImEXEiUDtfQetVii5WKCDdWNgZr1qBnTUcmUZ3Ex3H13LlKeDwLHtLRTVX+tqmNUdQzwc+BvqrrRd8i3vP1jO7mdXS6Qi7Jr3Ko+jckjyR61TTUNbKmN0TsZqHmpzY8/d6nO3sUF9C0tbLIPmhYT+LU2PYe/R82qPo3pqDvugDffhIcfhsGDu/zuVfUNERnZxsNPBx7vvNYESyDnUUvYPGrG5BMvTvPmUYvS2xujNriPmyft48/dUlK9SwroX+YCtStO/nEAACAASURBVMG+QK2shUCtaeqzaaDmXzbKigmM2QGVlTByJIRC7t/nb1kMV10Fxx8PZ5yR6+a1SkRKcT1vz/g2K/CKiLwvIpNaue0kEZkrInPXr1/f2U3NmkCOUbPUpzF5JVn1uW5rPfWxRGPq0wvGPv1iK4WREMUFYfqVJXvUilO371WYTH02Dbj8qc9mY9S8QK2itMCm5zCmrSorYdIkWL4cVGHF8gT9rziXeimCe+7JhyrPE4A309Keh6nq/sCxwGQROTzTDVV1pqqOVdWxAwcO7Iq2ZkUgx6hZMYExeSW5MsGX1fUAqarPvqUFFBeEqIsm6OMVGPT1ArWhTXrU3Pu9WY9aK1WfG2uiiMDgPiVZT31aoGa6rauvhpqaxus/YjqHJeZwVcntMGRI7hrWdqeRlvZU1TXev+uAZ4GDctCuTlMQKiChCRLafI6iXIknbIyaMfkk2aOW1LvEvX9FhCF9XECWDNSSqc/kdoBIOERRJNR8jFpMiYTcD/xmY9S2NVBRUkB5ccSKCYxpqxUrGi9/hSXcyJX8ieO4bcNZuWtUG4lIH+CbwHO+bWUiUp68DBwFZKwczVfJFGOQCgos9WlMfomnrdFZXtQ4D+JgL8WZLDDYbWAvwiFh9516NblNr6JIs6rPaDyRGr/WkJb63FjTQN+yQsoKw1ZMYExbjRjh0p5CglmcRwOFTGImI3bJbcpTRB4HxgEDRGQVcA1QAKCqd3uHfRd4RVW3+W66E/CsuJRtBHhMVV/uqnZ3hWSKMaYxCgjGJLO2KLsx+SWRUELSWFSQHKMGLjUJjT1qB+3aj/d/cSQVXvVnUmlRuFmPWiyRoFdRhM210Yw9av1KCyktjLBiYw3ZZJ8+ptuaNs2NUTunZgbf5A3O4X6qSocyc1pu26Wqp7fhmAdx03j4ty0F9uucVgVDMsUYqB41tUXZjckncVX6lhaywRvgn5zwFhoLCvzb0oM0gLLCSLNigoaYpqbuyFT1ObxfKaWFYWptjJox21dZ6cao7VSzlJv4GS9xDH8dMYGZM2H8+Fy3zrQkGRAFqfIzlrBiAmPySSJBaiJbaNqjNsSboqNPSes99r2KIhmLCYoLQkRCknFlgn6lhZQVRbK+MoH9TDTdTrLas7YmweucR4wIlxTPZNoNYkFawPlTn0ERT8RtjJoxeSShmpp2AxqrPqFxvrTexa0HamVFkSaT2IJLfRZ4hQb+qk9VZdO2KH3LChHpgSsTiMhwEfmriCwSkYUickmu22SCKTln2hlnuGrPC7mbbzGbS7mVxXXDufrqXLfQbE8QU59xtUXZjckn8YTSv6wodT2ZrgQYWtHGHrXiCNV1zSe8LQiHKIyEmqxSsK0hTkM8Qb+yAsoKw0Tj2myJqY4IfKAGxIDLVHVP4BDc3FF75bhNJmD8c6YBjOQzbuYK/sxR3M+5QNMqUBNMyR61IM2lZqlPY/JLQpXeJQWEQ0J5UYRwqLGAbES/Mo7bZ2e+Pqp/q+cYVF7E51vqUF8FaUM8QSQsFEXCTXrUkpPd9isrotSbLDeb49QCn/pU1bXAWu/yVhFZBAwFPsppw0ygXHJJ45xpySrPBCHO517AvUlHjMhd+0zbBHaMmqU+jckb8YSb76xPSQHFkab9UYWREDPGH7DdcwytcBPXVtVEU5PixhIJCsMhigpCTcaobUwFagXEvdULtjXE6FOanZ74fOhRS/HWR/wa8E7a9rxcLsdkR2UlbNjQeH0SM/k2f+UybmEljdHZtBxXe5rtSwVqQRqjZtNzGJNX4t70HG4C2vYFS8P6urFsq6tqU9uSqc+iSKhJ1efGmuTyUYWUeD1q2RynljeBmoj0wq15+BNV3eLfl6/L5ZjsuMQ3anEXlvFr/pdXOZL7mJja3r+/VXvmg1TqM0hj1GxlAmPySkIhFBL6lRW2u1draEUpkBaoxRMUREIu9ekL1JLVoeVFEcoK3WdYNie9zYtPHxEpwAVplar6+1y3xwRH0940TQVnE7mPZMqztBR++9ucNM/soGSKMVCpT1vr05i8Ek8oYRGmnLAXQvsmOE8u0r56U2Og1hBPUBASr0etMRBLjlcrioRTY9S21fegQE3cNOyzgEWqemuu22OCobLS9aT5U57ncy9H8joXcDcr2AWAXXZxKU/rTcsPyRRj4IoJbIyaMXkjoUo4JOw7rKLd5+hXVkhxQahJj1os7qv69PWoJXvXigpCqQXds5n6DHygBhwGnAnMF5EPvG1XqeqLOWyTyaHKSjjnHIhGG7eNYDm3cBmv821mMgmARx+1AC3fBLGYIK6W+jQmnyRUCYU6tlSgiDC0oqRJj5pLfboeNf86oMnetaJIiFIv9ZnNSW8D/+mjqnOgnX2XptuprISzznIzTzdS7uV8AM5jFiA2Ji1PBS31mdAECU1YMYExeSSZ+uyooX1Lm/SoNcQTREKhZtNzpHrUfKnP2p5YTGBMZSWcfXZ6kObGox3Fq/wvv2Y5I21MWh4L2jxqyaIGS30akx9UNVVM0FFDK0qapT4LI82n50gGbYWREGWdMEbNAjWTNy65BOJpr/3hrGiS8gyHsfU881hyBYCgVH0mpwmx1Kcx+SHhzU+bjR61YX1L2LitITXeLBpPUBCWZtNz1MfiFISFcEgoKcz+GDUL1Eze8BcOOC7lGSLBRO6joDDEQw9ZkJbPgrbWZ6pHzao+s+bll18G2FtElojIlen7RaRIRJ709r/jzZ+JiBSIyEMiMt9bUvDnvtss87Z/ICJzu+qxmOCJe5FaFjrUGOqtC7qmqo5EQoklkvOohZsVExRF3GdEYSREQViyOj2HBWomb53L/RzNK1zBzawI7cr991uQlu+CNkYt2Q7rUcuOeDzO5MmTAT4F9gJOz7Ak4HnAJlUdBdwG3ORt/x5QpKr7AAcAFySDOM+3VHWMqo7txIdgAi7hLfmUjdTnkIrGSW+j3pibZNWnv0etIZagyLcCQmlhxAI10zP19y3NNoyV3Mql/JVx3M2FPPywBWndQWpR9oCMUUulPq2YICveffddRo0aBdCgqg3AE8BJaYedBDzkXX4aOMKbpkmBMhGJACVAA7AFY3ySPWrhbIxRS65OsKmWWNydtzH16RujFos3CdTKCsOpSXCzwQI1kze+//3kJWUmk4gQ4zxmceFFIQvSuonUPGoBGaNmxQTZtXr1aoYPH+7ftAq3drPfUGAlgKrGgM1Af1zQtg239vMK4DequtG7jQKviMj7IjIp033bUoM9Q7JHLRtj1HYqLyIcElZX1RCNN/aoFUXCROOaCgrrYwmKCho/I0oKw9RErUfN9DAXXwx33+0uT+BBjuVlruQmjrloN2bMyG3bTPYkA6JoIrqdI7tGskfNxqhlh3pfoumb065n+oZV4CAgDgwBdgUuE5HdvP2Hqer+wLHAZBE5PMN921KDPUByVoBspD4j4RA79y5m9aZaGrxALeItyg6kxqnVR5umPsuKItRYj5rpSSorXZCmCkNZxW38lL9xOHdyMS/atMfdSlCn57AxatkxbNgwVq5c2WQTsCbtsFXAcAAvzdkH2Aj8EHhZVaOqug54ExgLoKprvH/XAc/igjrTA8VTPWrZOd+QimLWbq5LpT4LvdQnNE50m576LC0MZ3XCWwvUTOBdfbUL0kC5hwsopIFzuR8lxIoVuW7djhOR+0VknYgsaGH/OBHZ7FWwfSAiU3z7jhGRT1qqmMt3qTFqAUl92vQc2XXggQeyePFigEIRKQROA55PO+x54Gzv8qnAX9R1xa0Avi1OGXAI8LGIlIlIOYC3/Sgg43vLdH/ZHKMG0Lu4gOr6WLPUJ/h61HxVnwBlhRGbnsP0LMlg7Cwe5ju8yJXcyFK+AsCIETlsWPs9CByznWP+7lWwjVHV6wBEJAzciUvvtFQxl9eCtoRUsh2W+syOSCTC9OnTAb4KLAKeUtWFInKdiJzoHTYL6C8iS4BLgeQPkjuBXrgg7D3gAVWdB+wEzBGRD4F3gT+p6std9qBMoGSz6hOgV3GkSaAW8ao+oXFFAjdGrTGcKikMZ7Xq034mmkCrrAQRGKyr+S2X8Ab/yXR+BLjt06bluIHtoKpvpE0r0FYHAUtUdSmAiCQr5j7KXutyK7DzqFkxQdYcd9xxAAv802io6hTf5TrcVBxNqGp1C9uXAvt1SmNN3mmcRy1LgVpRhK11MaK+1KfQPPXZt7QgdZuywgg1tjKB6e4qK6FXLzjjDEgkGlOe5zEL9V62F17YrafkOFREPhSRl0RktLctVQ3nyVQxB+RvhVvQUp/JsXLJFROMMcGWSn1mKVArLy6gui499em+g+qi/mKCxh9zpUU2PYfp5ior4ZxzYNs2d/0MHuV4/sRV3MASdgfcnGrduNrzn8AuqrofcAfwB297S9VwzTfmaYVb0HrULPVpTH7JduqzvDhCQzxBtRd4FYRDqak4mqQ+fcUEw/qWsrU+xhrfOqEdYYGaCZyrr4aoNzvDzqzld/yYORzGHfxP6piNG1u4cTegqlu8NA+q+iJQICID8FXDeTJVzOW1oPWopQI1S30akxdSa31mKbrpVeQ+kzZtc19KEV/VZ2MxQbzJGLXDRrnZ2d9c8mVW2mCBmgmc5cuTl1zKs5g6zuV+EjR+WeZpEUGbiMjO3kzsiMhBuPfpBtwA6t1FZNdWKubyWqqYICA9asnUp61MYEx+6IwxagCbahoAKPSlPhvHqDVNfe6xUzkDehVmLVCzTx8TGJWVcMEFjdd/yGOcyB+5lFtYzFebHJuPRQRJIvI4MA4YICKrgGuAAgBVvRs3JcFFIhIDaoHTvOkJYiLyI+DPQBi4X1UX5uAhdJqQhBAkMD1qNo+aMfkltTJBFlOfABu3uUCtIBwi4k3SVt/ChLciwmGjBjBnyQZUFelg0GifPiYQkuPSkinPnficO/gf3uJQfsslTY696KL8LiJQ1dO3s386ML2FfS8C3Xqa33AoHJzpOWxlAmPySraLCXqlBWou9dk4Rk1VqY/FU1N2JB02agDPfbCGT7+oZo+dyzvUBkt9mkDwj0sD5W4upJQazuGBVMozFIJHH+3WRQQGl2YMysoENkbNmPySSn1mq0etyFV8V2VKfUbjxBJKQmnSowYuUAOYk4X0pwVqJucqK/3j0uA0nuBknuMXXM+n7JHa/vDD+d2TZtomEooEpkctNUbNUp/G5IVU1We2e9RqXE9CgW+tz7pYIpX+9I9RAxhaUcJuA8qYs7jj0yNZoGZyqrISzjqr8fogvmA6P+IfHMJt/DS1vazMgrSeIlCpT68dVkxgTH5oXEIqO+drHKNWD0BBJERZodtWUx+jPup+zPmrPpMO2rUf/1pZhWrGWZTazAI1k1MXXgiJRPKachcXUca2JlWe4TDcc0/Ommi6WFjClvo0xrRL1nvU0qbnKAgJpYVhRGBbfczXo9Y8nPqPncupqomybmt9h9pggZrJmYsvhurqxuvf5ylO4VmmcB0fsyfgxqU99JD1pvUkkVBwxqhZ6tOY/NI4j1p2ArWiSIiCsKSm5ygIhxARygojVNfHW0x9Auyxc28APv58a4faYIGayRl/L9lA1nEnk3mHg7iVS1PbbVxazxOR4IxRs5UJjMkv2a76FBF6FUVSi6wXeD1nvYoiXo+al/psoUcN4JPPt3SoDRaomZxpTHnCnUymnK2cwwPEvVljjjjCgrSeKEhj1GweNWPySyLLVZ/g1vtMinjnLSsKU10fo95b7zPTGLW+ZYUMKi/qcI+affqYnDjyyMbLp/L/+B5PcyW/YhF7Aa544LXXctQ4k1NBSn0m51GzYgJj8kM8yxPeQuM4NXCpz+S26iZj1DL3uu+xczmfBCX1KSJfEZEi7/I4EfmxiFRk6/ym+6ishNdfd5cHsJ4ZXMx7jOU3XJ46xooHeq6whAO3MoEVExiTH7K9hBQ0TtERDkkqACxrQ+oTXPpz8bpqYvFExv1tkc3U5zNAXERGAbOAXYHHsnh+001ceGHj5en8iN5saZLyzPeVB0zHBGkeNVuZwJj80lj1mb1zlns9ahHfScuSPWrR7fWo9aYhlmDZhpp23382A7WEqsaA7wK3q+pPgcFZPL/pBiorGys9/5un+QFPMZVrWMjeAIjYygM9XVjCwVmU3caoGZNXkh1XWU19ej1qhb7J2XoVRdjW4Et9ZhijBv6CgvanP7MZqEVF5HTgbOAFb1tBK8ebHugSb9nOZMpzLgdwM1ek9vt720zPFAlFApP6TI1Rs0DNmLyQ7XnUoHHS2wJferOsKMy2+vh2U5+jBvUiJB2r/Mzmp885wIXANFX9TER2BR7N4vlNnhs9GjZscJfv4H+ooIpv85dUyrOw0HrTTLB61GKJGIIQEiuQNyYfJBKdUUzg+pwKwhlSn9spJiguCDNyQFmHKj+zFqip6kci8jNghHf9M+DGbJ3f5LfRo+Gjj9zlU3iG03iSq7k+lfIEuP/+HDXOBEqQxqjFE3ErJDAmj3RG1WeyRy0S8qU+CyM0xBJU17nPqpZ61ABOHjO0Q+3JZtXnCcAHwMve9TEi8nwWznu/iKwTkQUdPZfJjcrKxiCtP18yg4t5n/2bpDzBCgiMEwlFAtOjFtc4BSEbwWFMvuiUqk+vmKCwSerTbduwza1Y0NIYNYAfH7E7k781qt33n83+/GuBg4AqAFX9AFf52VEPAsdk4TwmByor4YwzGq//jh/Tl02cwwPEfEMYw9ZpYTxhCc6Et7FEzCo+jckjiU7sUfOnPpPBW3Kx9sJsrQKfQTbPHFPVzWnbOrZkPKCqbwAbO3oe0/UuvrhpkHYyz/JDHueX/B/z2bfJsZMmdXHjTGCFQ8GZRy2WiFnq05g8kqr67IQeNX/qsywVqDUQCQmRPAnUFojID4GwiOwuIncAb2Xx/C0SkUkiMldE5q5fv74r7tJsR2Ul3HVX4/V+bOAuLuJfjOFGrmxy7BFHWBGBaVQQKgjMygRxjduqBMbkkWQxQRbjtNT0HOlVn+BSn62NT8uGbJ79f4DRQD3wOLAF+EkWz98iVZ2pqmNVdezAgQO74i7NdkyY0PT6b7mE/mxgAg82SXk++qgtFWWaClLqM65WTGBMPumUYgKv6rMwY+qzgaKCzv2MyGbVZw1wtfdnerDRoyHm+549kec4g0qu4VrmsV9qe09dgUBE7geOB9ap6t4Z9o8HfuZdrQYuUtUPvX3LgK1AHDfcYGyXNLoLBWlR9lgiZj1qxuSRzh2j5qv69LZtrG5IXe4sHT67iPyRVsaiqeqJHb0Pkz8uvrixwhOgLxu5mwv5gP34FT9PbR8ypEenOx8EpgMPt7D/M+CbqrpJRI4FZgIH+/Z/S1W/7Nwm5k5YwoFJfdoYNWPyS6IT1/r0j0MrK3TbttbH6N+rMGv3lUk2wsDfZOEcLRKRx4FxwAARWQVco6qzOvM+Tfv5x6UB3M5PGMCXHMtLRHEv5iFDYPXqHDQuIFT1DREZ2cp+/9jOt4Fhnd2mICkIFQSmmCCucVuVwJg8Eu+UCW+TS0g1T31Cy5PdZkuHP4FU9W/ZaEgr5z+9M89vsqdv36bXj+ePnMUjTGUKHzIGgL32goULc9C4/HUe8JLvugKviIgC96jqzEw3EpFJwCSAESNGdHojsyloKxPY9BzG5I+4l9/LZtVnUSREQViapD7L/IFaK3OoZUM2Up9Pqer3RWQ+GVKgqrpvhpuZbqZvX6iqarxewSbu4QLmsQ/TvGGL4bAFaTtCRL6FC9S+4dt8mKquEZFBwKsi8rE3hU0TXgA3E2Ds2LEdnianKwVpjFo8YT1qxuSTVOozi7GTiFBeXNAk9VkYCVEYDtEQT3R61Wc2PoG8ZbY5PgvnMnnoyCObBmkAt/FTBrGO43khlfJ86KEcNC5Pici+wH3Asaq6IbldVdd4/64TkWdxk0w3C9TyWSQUCc4YNbViAmPySWdUfQJ8ZWAZI/qVNNlWVhSmoSbR6anPDoeBqrrWu3ixqi73/wEXd/T8Jvhef73p9eP4ExN4iF/xc/7F/kDPrfBsDxEZAfweOFNVP/VtLxOR8uRl4Cig2y2tFpHgrPVpxQTG5JfOWEIK4IlJh3L5UXs02ZZMf+ZDj1rSf9E4pUDSsRm2mW5k9Oim1/tQxUwmMZ+9uZ5fAC7l2YMrPJvJVCADbnI5Vb0bmAL0B2aI+7BJTsOxE/Csty0CPKaqL3f5A+hk2VyZIBqNsmrVKurq6tp1+7MHnI2iLFq0KCvt6WmKi4sZNmwYBQW2XqrpGp1R9QmZe+iSBQX5MEbtIlzP2W4iMs+3qxx4s6PnN8HlX2w96VYuZSe+4CSeo4EiwFKe6bZXIKOqE4GJGbYvBd9EdN1UclF2VUU6+GG7atUqysvLGTlyZLvO9dnmzxCEkX1GdqgdPZGqsmHDBlatWsWuu2Zj2ef8sXZzLRUlhZQUdk5v7MI1m5n+lyXc9oMxFHfyZKv5JpEsJshy6jOTxh61gKc+gceAE4DnvX+Tfweo6hmt3dDkt0suaXr9GF7iXB7gJn7G+7h5WB991FKeZsckqywTmujwuerq6ujfv3+7Az6l48FiTyUi9O/fv929mfnshDvmMGvO0k47/ztLN/LSgs95b5ktg50uOUatC+K0Lkt9ZmOM2mZVXeb1EqwCorjqz17eWBvTTW3Y0Hi5N5u5l/NZyF5cxxTAgjTTPskqy2xN0dGRQEs1rwpmA6cnBrkNsQRfVjfwZXVDp91HbdQNDXhzyYbtHNnzJBJKSLrmtdfLW+8zb8aoiciPgGuBL4DkT2EFbHqOHuAWLmMwa/kuz9JAEeGwBWmmfZJVlvFEHAKQ1RF6XrBh2m9bvfuB0RDveI9wS+pTgVq3XaCk3eKqXZL2hMbVCTp7rc9shoE/AfZQ1dGquo/3Z0FaN3XkkY2Xj+LPTGQWN3MFczkQsHFppv2SVZZBmPQ2G6lPEeHMM89MXY/FYgwcOJDjj3czGj3//PPceOONO3TOcDjMmDFjGD16NPvttx+33noriUT7A4MbbrghdXnZsmXsvXezJWiz5uWXXwbYW0SWiMiV6ftFpEhEnvT2v5NcxUNECkTkIRGZLyKLROTnvtscIyKftHTOrlSdDNRinReoJXvUFqzZzKZtnddzl49cj1oXBWr5kvr0WQlszuL5TIAlp+TozWbuYyIfsSdTuQaAsjLrTTPtlxyjFoQpOrKR+iwrK2PBggXU1tYC8OqrrzJ06NDU/hNPPJErr9yx2KKkpIQPPviAhQsX8uqrr/Liiy8yderUdrfRH6h1png8zuTJkwE+BfYCTheRvdIOOw/YpKqjgNuAm7zt3wOKVHUf4ADgAhEZKSJh4E7cLAMtnbPLbK1zr9toJ/ao1UXduVXhH0st/ekXT3Rdj1pysfa8SX0CS4HZIvInoD65UVVvzeJ9mID5Nf/LENbwdd6inmIA7rknx40yeS05Ri3b631O/eNCPlqzZYduUxurJSQhisKrMu7fa0hvrjlhdMZ9fsceeyx/+tOfOPXUU3n88cc5/fTT+fvf/w7Agw8+yNy5c5k+fToTJkygd+/ezJ07l88//5ybb76ZU089tdVzDxo0iJkzZ3LggQdy7bXXkkgkuPLKK5k9ezb19fVMnjyZCy64gNmzZzNlyhT69+/PJ598wuGHH86MGTO46qqrqK2tTfXQTZs2jXg8zvnnn89bb73F0KFDee655ygpKWm1HW3x7rvvMmrUKJYuXdqgqg0i8gRwEuCvHz8JN4wG4GlgurhuTQXKRCQClAANwBbcpM9LvKpoWjhnl+mqHrWB5UXUNcSZs+RLjttncKfdV76Jay561PIn9bkCeBUoxE3Nkfwz3Uxlpfv3v3iFSdzLb7icdzk4td9600xHpAK1gKxOkI2P/NNOO40nnniCuro65s2bx8EHH9zisWvXrmXOnDm88MILbe5p22233UgkEqxbt45Zs2bRp08f3nvvPd577z3uvfdePvvsM8AFSrfccgvz58/n3//+N7///e+58cYbUz10ld6be/HixUyePJmFCxdSUVHBM8880/EnAVi9ejXDhw/3b1oFDE07bCguQ4OqxnCZmv64oG0bsBb3ffMbVd3oP76VcyIik0RkrojMXb9+fVYeTybV9VGgcwO1umic8qIIB+/W38appUkWE3SFsnyZRy1JVdvf727yyplnQjlbuJfzWcR/cA32X2+yJ5n6jCaiWT1vW3q+0n2y8RPKC8sZ0mtIh+573333ZdmyZTz++OMcd9xxrR578sknEwqF2Guvvfjiiy/afB/JNO0rr7zCvHnzePrppwHYvHkzixcvprCwkIMOOojddtsNgNNPP505c+Zk7LHbddddGTNmDAAHHHAAy5Yta3M72tLG9M1p1zN9zSqu5ywODAH6An8XkddaOT79vrtk/dtk6rMziwnqonGKCsLsNaQ3ry36wgUnXRWdBFxCu2YONcjPqs+BwBXAaPByYICqfjtb92Fy78gj3biIm7mCYaziMN5MpTwBdtklh40z3UKymCDbqc/20Obf9+124okncvnllzN79mw2bGh5XFFRUVHj/bdxjNzSpUsJh8MMGjQIVeWOO+7g6KOPbnLM7NmzmxVGtFQo4W9DOBxOja/rqGHDhrFy5comm4A1aYetAoYDq7w0Zx9gI/BD4GVVjQLrRORNYCyuN83fTZfpnF2mK1KfddEEJQUhSr0JdWuj8VTvTk+Xk6rPPEp9VgIfA7sCU4FlwHtZPL8JgNdfhyN4jQu5h1u5lHc4pMn+adNy1DDTbQQq9anZm57j3HPPZcqUKeyzzz5ZOV/S+vXrufDCC/nRj36EiHD00Udz1113EY26HslPP/2Ubdu2AS71+dlnn5FIJHjyySf5xje+AUBBQUHq+LZasGABTz31FA8//HDqb3sOPPBAFi9eDFAoIoXAabjJ0v2eB872Lp8K/EVdxLoC+LY4ZcAhuO+c94DdRWTXVs7ZZbpi4zr6WwAAIABJREFUeo66aJzigjBlXqBW0xCA90pAdGXVZ688XOuzv6rOEpFLVPVvwN9E5G9ZPL/JsYsvhl5s5T4m8jF7MIXrmh3T08an1dfX88wzz7Bs2TJiscYqxSlTpuSwVfktOY9aIKo+s7gywbBhw7gkfTmPdkoO/o9Go0QiEc4880wuvfRSACZOnMiyZcvYf//9UVUGDhzIH/7wBwAOPfRQrrzySubPn8/hhx/Od7/7XQAmTZrEvvvuy/7778+0Nvzamjp1KrNnz+ajjz7iuOOO46WXXuIb3/gGZ511Vqu3i0QiTJ8+ne985ztfBRYB96vqQhG5Dpirqs8Ds4BHRGQJriftNO/mdwIPAAtw6c4HVHUepObx/DNu5r37VXVh25/N7Kqu65pigj4lBZR4PTq1FqildGXV5+CKEkRgUO/i7R/cAdkM1JI/x9aKyHdwXc/Dsnh+k0NHHul602ZwBSNYwWG8SR1Nq8COOCJHjcuhk046iT59+nDAAQc0SReZ9ktNzxGQedQ6qrq6utm2cePGMW7cOAAmTJjAhAkTAFcBur3bgpvmoiWhUIgbbrgh45QbpaWlPPnkk82233TTTdx0002p6wsWLEhdvvzyy5sd//TTT/Phhx/yta99jQceeIAvvviCiRObLU+bkTdGb4Gqjk1uU9Upvst1uKk4mlDV6kzbvX0vAi+2qQGdbGuXpD5dj1oy9bmtIffvlc7ywcoq+pcVMrxfaZuO78qqz10HlPH2z49gpzwK1K4XkT7AZcAdQG/gp1k8v8mR0aPd4uvf5nUu4m5+w2W8zaHNjnvttRw0LsdWrVqVnMDTZElnTc/RLllMfXYnJSUlhEIhIpEIW7ZsYdCgQSxd2nlrW+aT6i4pJkg0CdS6c+rz0ic/4IBd+vLr7+3XpuMTXdijBnR6kAbZrfp8wbu4GfhWts5rcquy0gVpvdjKLM7jE77K//HLZsc9+mgOGhcAX//615k/f37Wxx31ZKlighyPUVPVbrUou78Xr6PGjh1LVVUV559/PgcccAC9evXioIMOysq5812ymCDa6T1qIUp7QOqzNhqnJtr2xxfXrlmQvStls+rzATKXRJ+brfswXc/LyHAjVzKCFfwnf2+W8oSeNzZtn332QUSIxWI88MAD7LbbbhQVFaHqvtjnzZuX6ybmrSCNUTOZzZgxA4ALL7yQY445hi1btrDvvrZiIPiqPjuxR622B6U+YwklHm/7EISEdr+pSrKZ+nzBd7kY+C45LJE2HVdZCbEYjOOvTGYGt/JT3uKwZsdddFEOGpdjL7zwwvYPMu2SWuszx4FacnyapT4zmzdvXpMimiVLlnDKKafkuFW5l5xHrb6TetRUlbponBJfoJbeo5ZIuFdvV6YAO0s8ocR2YB3bREIJd5Ne8KRspj6bTF0tIo8DPXDUUvcxcSKUUc0szmMxo/gF1zc7pqICvB/XPcou3oRxZ555Jo888kiTfZm2mbYLyvQcyTnMukvqM5vOPfdc5s2bx+jRowmF3NQEImKBGp0/j1pDPEFCaZL6TB+jdvq9b7Pn4N5ce+KOT/IcNNF4gugO9Kh1ZdVnV+nMGfJ2B0Z04vlNJ6qshLo6+B0/ZyTL+CZ/o5amVTcVFbBpU44aGBAL/z97Zx4fVXX3//eZfbKShKBAWEQFREVQXKlWBTdqwVZ9lMcFXEoV3OtuVeputWoRq9IKVk3R1pVHrRUV1PpTcQEFRQWVLYBAQvbMfn5/3GXubMkkmWSG5Lxfr7wyc++5d85EST7z+W5fxXYBCIfDfPbZZ1naTc8gV0KfylFLzUcffcTXX2dllGbOYy0mMFIhALY1+Lj79W+4/ZT9zP5bHcEYyO5x2vGaxQSx/1bWVzfz444mbv3lqDY/aLy0fBPPfLSBFy4+osN76kra7ah1Y9Vnd5GxLm1CiAYhRL3xHfg/4LpM3V/RfVRWwtlnw1G8y6XMZQ6X8V+OjFkzYEDvFml33303hYWFfPnllxQVFVFYWEhhYSH9+vVjypQp2d7eLk0uTSbIBEIIzjnnHPN5KBSivLyck08+uUtfd/r06eyxxx4ccMABDB8+nHPPPZeqqqoO3+/ll182xdnhhx/OwQcfzKeffpqp7fYYDEdNSk1kGLz/3Q5eWl7FFxtrO3V/n55Y31rVpy8UZluDn+9+St7excryDbV8tn5n2lMwuptQRBLq5Y5axoSalLJQSllk+T48PhyqyH0MkZZHE/M5n7XsyU0kNsDsxO/7HsENN9xAQ0MD11xzDfX19TQ0NNDQ0EB1dTV33313q9cKIeYLIbYJIValOC+EEHOEEGuFEF8KIQ60nJsmhFijf01Ldv2ujumoZbmPWqZCn/n5+axatcocw7R48WIGDkyYGd4l3HfffXzxxRd8++23jB07lmOOOYZAINChe1mF2rRp01i+fDmnnnoqo0ePZv/991fFBGj5UU2BkNmp3lpQUFWr/fff1uDr1GsYQs3rtOO023DZbQlCzchZe39NdPh8XUuQGU99ync/NcSsrW8JJuw1l9ActXYINYkqJkiGEMILnAWM0g99CjwvpezYbwRF1jAap9/FjezJDxzFuzSTH7MmPz/Jhb2Uu+66ixdffJH//ve/CCE48sgjOeWUU9q67ElgLpBq5s5JaKkDewOHAo8ChwohSoFb0eYbSuAzIcQiKWWP8jYNRy0YCWbkU755jzeuh60r098HkqHBFlx2F9icyRftvj+cdE+b9zrppJN47bXXOO2001i4cCFTp07l/fffB6CpqYlLL72UlStXEgqFmD17NlOmTGHdunWcc8455vinuXPncsQRR7B06VJmz55N3759WbVqFQcddBDPPPNMq4JSCMGVV17JSy+9xL///W+mTJnCm2++ya233orf72fPPfdkwYIFFBQUMHToUM444wyWLFkCwD/+8Q+2bdvGokWLePfdd7njjjvYuXMnI0eOZPz48Xz00Uc0NDTwxz/+Me2fbU+lORhGSijLd7G5zkcgFCHPpZ3btLMZgG31/k69hjX0CeB12WmxhD6llGYhw/trdnDhkcMA+PD7Hbz59U9U1bbw8qzxOO2amKy3TFLo6pmV7UVKqQm1dohIrZigCzeVBTot1IQQ+6OFOd8FPkMb7XECcKUQ4jjgainl7zv7OoruoboajuQ9LmcOc7iU9zkqYc3jj2dhYznKrFmzWLt2LVOnTgXgscceY/HixTzyyCMpr5FSvieEGNrKbacAT+nzDT8SQvQRQvQHjgYWSylrAIQQi4ETgYWZeC+5gsuu/WW74f0buOH9Gzp1r4dGPUSkWvslv7uvBk+wud33yESO2plnnsltt93GySefzJdffsn5559vCrU777yTY489lvnz51NbW8shhxzCxIkT6devH4sXL8bj8bBmzRqmTp1qhhqXL1/OV199xYABAxg/fjwffPCBObezNQ488EC++eYbxo8fzx133MFbb71Ffn4+9957Lw888IA5+qyoqIhly5bx1FNPccUVV/Dqq68yefJkTj75ZE477TSOPfZYIpEIBQUFfPHFF7z++us88MADnH560sEBvQYjP620ICrUDDbtNBy1zgm1FsNRc2lCK89lp8niqBkizWETfPxjtTnFYMXGOoSArzbX8+jS77lswt5A1FHzhyIUdmpnmcdw0tpbTNDTctQy4ajNAX4jpVxsPSiEmIg2ky1rM9cU7WPmTPDSzHzO53uGcQOJIbwBA3pfz7TWePfdd1m1apXpZkybNi0TzW8HAhstzzfpx1IdT0AIMQOYATB48K5V0zMgfwC/P/T31PhqOn2vQlFIeV45AOET7qSpndcLBB5PKdg65zSMHj2adevWsXDhQmOEksmbb77JokWLuP/++wHw+Xxs2LCBAQMGcMkll7BixQrsdjvfffedec0hhxxCRYU2oW/MmDGsW7cuLaFmuItGMcD48Vq7nUAgwOGHR6eNGB88pk6dypVXJg6YGTlyJC+88AJHH300L774IrW1tTFjp3orjX5N9JTma+PkrC06oqHPzjpqeo6a7n7luewx7TmM84cNK+O/a3fw2fqdjN+rL19srGX0wGKGlOXz8DtrOH1cBf2LvdT79NBnFzbo7ShGjl+4HaFP1UctOf3jRRqAlPItIUQQrZ+aIscxZnk+wE3sxfcczZKEkKfTqXLT4hkxYgQbNmww23Vs3LgxE7k6yX7LyFaOJx6Uch4wD2DcuHG5mSWcAiEEZ4w8IyP3Wr16Nf3y+mXkXp1l8uTJXH311SxdupTq6mrzuJSSF154gREjRsSsnz17NrvtthtffPEFkUgEjyc6qsY6V9Zut5u9zNpi+fLlTJgwASklxx13HAsXJjdjrWHUZCHVlpYWhBB89tlnrF+/Hp/Pl3IuaW/C6KFWmqeFyoN6yC4SkWw2hFp953LUDEfN4zKEmiOm6tM4f/SIcj7+sZol32zjsGFlrKyq49cHDuSk/fqz6IvN/Li9if7FXuosjlquYTpq7az6dNgyln6fE2Ti3diEEAnTqIUQHiAopWx/rEHRrVRWaiJtPP/lcv7MXGbxLkcnrOtgDnKPprq6mn322ccczzNq1Ci2b9/O5MmTmTx5ckdvuwkYZHlegdY8OtVxxS7A+eefzy233JLguJ5wwgk8/PDDptu1fPlyAOrq6ujfvz82m42nn3661UHsbSGlZM6cOWzZsoUTTzyRww47jA8++IC1a9cC0NzcHOPYGYPbn3vuOdNpKywspKFBS0RfsGABI0eO5NZbb2XBggU8/PDD9O3bt8P76ykYFZ+Go2Yk6G9r8Jvhu846av44R80bF/o0ctjKClwctXc5r365hTXbGmj0hzigog+l+Vpqwc5mTaDVt3T9EPmOYuSm9faqz0w4ak8BLwghLpFSrgPQ82/mAKrr5y7ARRdFQ57rGcL1JCZHqwKC5Nx2221dcdtFwCVCiGfRignqpJRbhBD/Ae4SQpTo644HOpfEpeg2KioquNyo1rFw8803c8UVVzB69GiklAwdOpRXX32VmTNncuqpp/Kvf/2LY445hvwO/CO85ppruP3222lubuawww5jyZIluFwuysvLefLJJ5k6dSp+vyYc7rjjDoYPHw6A3+/n0EMPJRKJmK7bmWeeyW9+8xvmzJnD6NGjWbt2Lffffz/9+vWjpaWF2tpaXnnllV7dnsbIUSsr0MSQIX6MQoJh5fn8VJcZR83ooZbvsrOjMfop2hoanTJ2IG9/s4157/0AwAGD+lDk0f7s1zQHCIQi5v38odxrh2M4au0pJlBVn0mQUt4hhLgEeE8IYXREbQLul1I+3Nn7AwghTgT+DNiBv0kp2y6zUqRFZSU0NsL93Mxw1nAsb9NEQcI6VUCQnJ///OesX7+eNWvWMHHiRFpaWgiFQhQWpk7L1ad2HA30FUJsQqvkdAJIKR8DXgcmAWuBZuA8/VyNEOJ24BP9VrcZhQWK3CVZSNA6IN3r9fJ4kn9ge++9d8zMWKPtS/xw9blz5yZ93SeffLLVfR177LF88sknSc/NmjWLW2+9NebY+PHjzfYcM2bMYNiwYWaO2wsvvMBZZ53FE088wZIlS3jooYdafe2eSoPuqJXkxQs1Lex54OASnv9sE03+EPkdbHobrfo0igkcNAeaLeejfdaOHlZGvsvOi59XUeh2MKxvvil+apsCNOj5ada95hJGblp72nOoqs8USCnnAnOFEIX684Y2LkkbIYQdeAQ4Di3084nekkC1xc4A55wDh/P/uJIH+QsXs4RjE9aoAoLU/PWvf2XevHnU1NTw/fffs2nTJi666CLefvvtlNdIKae2dk+92nNWinPzgfmd2rRC0UnWrl3LO++8g8Oh/Qm5+OKLOf7441m8eHEmiml2WcyqTz28aIQ+jUKCsYP78Pxnm9jW4GePDgo1o3DAG9OeI+qGtViEmtdl54R9d+fF5VWMHlSMzSZw2QQFbgc1zQEzPw1yO0etXX3UemDoM6MZd1LKhkyKNJ1DgLVSyh/0vmzPorUvUHQSlwvcsoUFnMcGBnMd9yas8XpVAUFrPPLII3zwwQcUFRUBmguybdu2LO9Koeg469atazPfrKqqyuzvBlovuM2bN2O322MKHXob0Ry1xNBn3wIXg0u1oFNnCgp8oagQAy30GdOeI85xmzJWKww/oKKPuaYk30ltc9DsoWbday5hhDyD7emj1gNHSHXlrM9MkawlwaHWBbtyK4JsMXAgBINwJ7cwgu+YwFs0Jumi06xKQVrF7XbjcrnM56FQSA3xVvR4rr32WsaMGcPRRx+NlJL33nuPG2+8kaamJiZOnJjt7WWNJn9IH5auiShr6HNgSR79CrXK3c4UFBihT2P6gdflSNqewxBy4/csY+bRe/I/46J1SCV5LmqaAmYPNcj1HDXVRy3XabMlwa7ciiAbVFbC5s1wGB9yFQ/wGL/lHSYkrLv44ixsbhfj5z//OXfddRctLS0sXryYv/zlL/zyl7/M9rYUii7lggsuYNKkSSxbtgwpJXfddRcDBgwAtLFVvZUGf4gCtxNX3Aipqp0t7NO/iH6Fmtv4U2cctWAYj9NmfiDMc9kJhCMEwxGcdltM6BPAYbdx7YkjY+5Rkueitjlg9lCD3Ax9drSPmgp9pkAIkSeEuFkI8Vf9+d5CiExMHVYtCTLMhReCBy3kuYkKriVx9IsQ8Je/ZGFzuxj33HMP5eXl7L///jz++ONMmjSJO+64I9vbUii6hG+++QaAzz//nC1btjBo0CAGDx7M1q1b+fzzz7O8u+zT6AtR6HHg0sczBUIRIhHJptoWKkq89Mlz4rLb2J6moxaJSO7+92p+3BENMxuTBgziB7MbjpvXmbpJc0mek5rmgNmaA3JTqBkhz/b1UVNVn62xAG2ElNHeehPwL+DVTt73E2BvIcQeQBVwJvC/nbxnr6WyEnw+uIfZjORbjuNNGihKWPe0aqySFjabjVNOOYVTTjmF8vLybG9HoehSHnjgAebNm8fvfvc7ILEZ7jvvvJONbeUMjf4QBW6H6agFwxF2NPkJhCJUlHgRQlBe6E479LlpZwuPv/sD+S6HOfKpJRCOEWF5Lod5vNjrtIQ+U/swJfkudjYFY4oJcjFHzXDSpEy/SCDcA6s+M1lMsKeU8o9AEEBK2ULysGW7kFKGgEuA/wCrgX9KKdVYqg4yfTocwsdczf3M4ze8xXEJa555RlV5toWU0hyMPXLkSEaMGEF5eXlX9VVT7MIIITjnnHPM56FQiPLyck4+ufMBh6VLl1JcXMzYsWMZMWIERx11FK++2vHPxuvWreMf//iH+fzJJ5/kkksuMZ9feOGFbN26lSVLlrBkyRKmTZtGQUEB++23H88//3yn3ktPoNGnCTWnxVEzhrDvVqTlp/UrcrOtIb3Q55Y6rVp0Y42l/UYoksJRC+nnY0OfySjNc9HoD1HdGBWMuSjUrNWe6RYUhCM9b4RUJoVaQAjhRc8fE0LsCXSuBbOOlPJ1KeVwKeWeUso7M3HP3sjEiWAP+VjAeVQxkKu5P2GNEmnp8dBDD/HBBx/wySefUF1dTU1NDR9//DEffPABDz74YLa3p8gh8vPzWbVqFS0t2h/dxYsXM3Bg0hGtHeLII49k+fLlfPvtt8yZM4dLLrmk1fYwrREv1OK56KKLzOKZ9957jxtuuIFp06ZRXFzMjBkzOvSaPYkGf4gCT9RR84ciZiVogd5otl+h2xRvbbFVz2XbuDMq1FoCsaFPb3zoU/9uFBsko49elbq+ptkUerkY+rTmpqWbpxaRErsqJkjJrcAbwCAhRCUwHpiewfsrOoExJuou/sAoVnMCbySEPF0uJdLS5amnnmLx4sUxbQyGDRvGM888w/HHH590kLUiu9y77F6+qfkmo/ccWTqS6w65rs11J510Eq+99hqnnXYaCxcuZOrUqbz//vsALFu2jCuuuIKWlha8Xi8LFixgxIgRPPDAA6xatYr58+ezcuVKpk6dyrJly8jLy0v5OmPGjOGWW25h7ty5TJgwge3bt3PRRRexYcMGQPuAMX78eGbPns33339PVVUVGzdu5Nprr+U3v/kN119/PatXr2bMmDFMmzaNkpISNm/ezIknnsj3339PXV0dpaWlgDZeasaMGZx66qmceuqpjBkzJgM/0V2b5kCIfJfdFEmBcIQmXajluwyh5uHD76tT3sPKFn2KwcaaFvOYPxSOCWsa9zWFWigSU2yQjFK9Ie+G6mbKC92sr27OSUfN6qKlW/mp+qi1gj6Y/ddo4mwhME5KuTRT91d0junTYRyfcC1/5G9cwJuckLBmvmqjmjbBYDBpr6ny8nKCwWCSKxS9mTPPPJNnn30Wn8/Hl19+yaGHRjsMjRw5kvfee4/ly5dz2223ceONNwJwxRVXsHbtWl566SXOO+88Hn/88VZFmsGBBx5oJv1ffvnlXHnllXzyySe88MILXHjhhea6L7/8ktdee40PP/yQ2267jc2bN3PPPfdw5JFHsmLFCvPDxooVK3juuedYuXIltbW1/PjjjwC8/fbbHHtstEF2uoPhezJGor+1mMDocWZMIuhX6KbeFzJzyVpjqy7UttS1mKIlPkfNGx/6jCs2SEaJPjR+fU0TffJcOGwiJ9tzWF20dAsKIrLnhT477agJIQ6MO7RF/z5YCDFYSqlKgbLMvvuCLeTnSaazmQH8jj8lXafctPSx9k5rzzlF9kjH+eoqRo8ezbp161i4cCGTJk2KOVdXV8e0adNYs2YNQghT6NtsNp588klGjx7Nb3/7W3NcU1sYw90B3nrrLXPsE0B9fb05WH3KlCl4vV68Xi/HHHMMy5Yto0+fPgn3mzBhAsXFxQAMHTqUyZMnM2zYMLxeL0ceeSSgTSow1vRm/KEIbocNm03gsAmCFketQBdqZQVai46dzQH6F3tbvd9mfaJBRGqPh5Tl4wuFKfI6zTVG6LLFrPoMmwPbU1Gihz59wQhFHgduhy0nHTVrjlp7HLUeptMyEvpM/ldfQ0KSmUSKbqOkBGpr4Q5uY1++5kT+TT2Jv1BVz7T28cUXX5jTCKxIKfH5Ojd0WdEzmTx5MldffTVLly6lujoa+rr55ps55phjeOmll1i3bl3MHM81a9ZQUFDA5s3pdyRavnw5++yzDwCRSIQPP/wQrzdREMSHxlKFyqyTBoYPH86kSZPo378/xx9/vHlNJBLh4YczMtp5l8bqZjntmvgxhFqeWzse306jNbbW+8zJAxtqmjWhFozEOGpG6NNw7lqCkVYrPiE6ixSgyKv1fcvJHDWLOAul7ajR43LUOh36lFIe08qXEmlZZOJETaQdxKdcx708wfn8hxMT1o0apXqmtZdwOEx9fX3CV0NDgwp9KpJy/vnnc8sttyTMwqyrqzOLC6yD1Ovq6rj88st57733qK6uTquq8ssvv+T2229n1ixtVOzxxx8fM7R9xYoV5uNXXnkFn89HdXU1S5cu5eCDD6awsNB03FIxatQofvWrX5Gfn28eGz58OAceGB9c6V1IKU1HDcDlMISaHvrUBZU3zgFrjS11Pg4cUgJE89RaAmHcFiEWvV/6oc8+eVFHrsjjxO2w56ij1v4ctYiq+kyNEMIjhLhKCPGiEOIFIcQVQghPpu6vaD9vvw0utJDnVnZPGvIUAr5SzU4Uii6noqKCyy+/POH4tddeyw033MD48eMJh6N/vK+88kpmzpzJ8OHDeeKJJ7j++uuTzpF9//33zfYcs2bNYs6cOUyYoE0amTNnDp9++imjR49m1KhRPPbYY+Z1hxxyCL/4xS847LDDuPnmmxkwYACjR4/G4XBwwAEHqOrldhIIR5AS3LpIcjlsWjFBQBsrZSS4xyf/p7xfKMKORj9jB/XBaRdm5ac/FN9HLb7hbdtCzeO0m9cVm45a7uWoxYQ+03TUwqrqs1WeAhoAw/+eCjwNnJ7B11C0k5u5nf34ikm8Rh2J+Seqsa1C0bU0NjYmHDv66KPNEOfhhx/Od999Z567/fbbAZhvqe4ZNGgQa9euTXqfurq6lK/dt29fnnvuuaTnhg8fzrx582KOOZ3OhNYe06dPNx93pkdbT8cIHZqOml0LJ9r0JrgGhgPWFGi9+OKneh9SwsASLwP7eM1eagntOZzG/axCrW0PpiTPRXOghSKvwxSVuUZMMUEvrvrMpFAbIaU8wPJ8iRDiiwzeX9EOXC44kM+4nntYwHT+zaSENaNGqQIChUKhyATxw9DdDhvBsCQSCZkVn5CY/J8Ko4fa7sVeBpXmsbGmWcuBDcXmqNlsAq/Tbgl9RigraLugqSTfSVVtix76tOEP5p5Qs4Y729NHraeFPjMp1JYLIQ6TUn4EIIQ4FPggg/dXpMm++wLBAE8ynZ/Yjat4IGHNqFEq5KlQ9FZmz56d7S30OAyhYzhqWjFBmHAkOuYJ0i8mMHqo9S/2UFGSx382byUYloQjMsExy3PZY0Kfrc35NDAKCoxiglx01KzhzvZMJlChz9QcCpwrhNigPx8MrBZCrASklHJ0Bl9L0Qpffw1/4A72ZxW/4FVqKYk5P2ECvPVWljanUHQzUspWm38qug5rq5Cejj9udJNRTOAPRShwJ/Y9a2kj9LlVHx+1e7GHwaV51DQFqGkKxLyGQZ7bItRCbeeoQVSoFXuTO2pVtS3ku+z0ycteu6HYHLW2/1+SUqqh7G2QWE6o6HYmToSxfM6N3MXfOZfX+UXCGiXSFL0Fj8dDdXU1ZWVlSqx1M1JKqqur8Xh6R02ZL85RM4sJ/KEYsZNuMcHmWh8FbgdFHieDSrX2Kt/9pFXkJgg1p8NseNsSaLs9B0Cp3kutyOPA5bDHDGgHOH/BJ4wZ1Id7T8uexxJuZx81Y3kP02mZE2pSyvVCiBJgkPW+quFt9zFzJrz3doBPOI9t9OMKHkpYM2pUFjamUGSJiooKNm3axPbt27O9lV6Jx+OhoqIi29voFhIcNaOPWiBMRYmUwLXkAAAgAElEQVSlmCAu+T8VW+t87F6sidwhpVorlM/W74x5DfOeltCnPxjG3UbDW4gNfSZreLtpZ3NauW5dSaidfdQiuoOrQp8pEELcjjY+6nv0weyohrfdyrx58Hvu4gC+5JcsSgh5Op0qLy1XEEKcCPwZsAN/k1LeE3f+QeAY/Wke0E9K2Uc/FwZW6uc2SCknd8+udz2cTid77LFHtreh6AXE56i5HDaaW8I0+UNmXhpoYTmP09Zm6HNLvY/+ulDbd0ARQ8ryqPx4PUBCDlq+2x6dTBAKm+HV1hhU6sVlt9E3353QnsMXDNMUCFPdGGjzPl1Je/uoGQ5cTwt9ZqyPGvA/wJ5SyqNVw9vssF94BTdxJ09zNq/yy4Tzgez+m1PoCCHswCPAScAoYKoQIsbrlFJeKaUcI6Ucg9by5kXL6RbjnBJpil2JN954gxEjRgDsJ4S4Pv68EMIthHhOCLFWCPGxEGKofvwsIcQKy1dECDFGP7dUCPGt5Vy/7nxPBr44R82YTNDoj636BK24oK3Q59a6FlOo2WyCcw8fyo5GI0ct9k+31+mgKRAmFI4QDMs2R0gBTD5gAG//7ucU5yU6ajubtdfZ0ehv8z5dSSimPUc7HLUeJtQymaO2CugDJHZkVHQ5Jxwb5EmmU00Zl/PnbG9H0TqHAGullD8ACCGeBaYAX6dYPxW4tUt28sih0PhTl9y6Qwg7nPwgjMoh/VnzIzx5MgSbsr2TXYfd9oPpsT3XwuEws2bNYvHixey5555foX1AWSSltP5/fwGwU0q5lxDiTOBe4AwpZSVQCSCE2B94RUq5wnLdWVLKT7v0PbWB6ajpIkoTP2GaA+GYPmqA3k4jtVBr8AXZ1uBnUEmeeez0cRX86c1vaQ4kVnVqVZ8hfLrYSidHzWG3Mag0z9yrdYSUUbRQ0xzIal+ycDvbcxhrVOgzNXejtehYBZgyXH3i73omToQjltzNGL5gCi+zk9KENXqjckVuMBDYaHm+Ca1qOgEhxBBgD+Ady2GPEOJTIATcI6V8Ocl1M4AZAIMHD069k5G/AH/rI4O6lS+fg29eyy2h9sNSqN8EY88BZ+tDtBU6RQMTDi1btoy99tqLYcOGgZYWk+wDyhRgtv74eWCuEELI2PLRqcDCLth1pzAdNUe06rPBFyIckeacT4N8S5VmMr7aXI+UsN/A6FzmIo+TUw+s4OmP1pvTDwxK813UNAYSermlS/wIKUOoSak9Li90p7q0SwlaHbU0hJoRKe1poc9MCrW/o336WQnkXkOWHsjMmfDoozCaL7iZ26nkf1nElKRrVaVnTpHst0iq30JnAs9LKa2/1QdLKTcLIYYB7wghVkopv4+5mZTzgHkA48aNS/0bbsIt7dp4l1O7ETYvz/YuYtm8HDx9YPLD2sw1RYeoqqpi0KBB1kPJPqCYH2KklCEhRB1QBuywrDkDEn7RLdBzN18A7ogTdkA7Prx0kHhHzWW3mSHEBEfN5aA5mFqorarSpk1YhRrARUfvSaM/xMjdC2OO9yty0+APsVMXWOn0UbMSn6NmCDWA6iZ/1oRaOCZHrW1ZETaLCbpsS1khkzlqO6SUc6SUS6SU7xpfGby/wsLEiZpIcxBkAedRQymXMSfpWsvsZEVusAmtOtqgAticYu2ZxLkHUsrN+vcfgKXA2MxvMUsMGAs7vsstl2/LChgwRom0TpKip1r8wVY/xOiN1JullKss58+SUu4PHKl/nZPi9edJKcdJKceVl5e3a+/pYLpZFkfNGHtkbXgLkOe00+xPXUywsqqO/sWeBIE0sI+XB88Yk5Dz1q9Qy2XboI+ZcqcR+rRi5KgZ/42sQm1HQ/aSm0NJ2nN8tbku5QB5M/TZwxy1TAq1z4QQdwshDhdCHGh8ZfD+Cp3KSm3gOsB13MuBLOciHqOGsqTrH3+8GzenSIdPgL2FEHsIIVxoYmxR/CIhxAigBPjQcqxECOHWH/cFxpM6t23XY8AYQMLWlW0u7RaCPvjpa01AKjpFRUUFGzdujDlE4gcU80OMEMIBFAM1lvPJPrhU6d8bgH+g5YB2O+asT2d0MoFBgTtZTllqR21lVV2Cm9YauxVpgs4Qau0NfbrsNiIyKox2WoVaFgsKwjHtOSR1zUEmz/2Al1dUJV1vCM2e1jMxk6FP4zfZYZZjqj1HFzBtmvZ9P1ZyC7exkDN5mV8lXTthgprnmWvoIZ1LgP+gteeYL6X8SghxG/CplNIQbVOBZ+PCOPsAjwshImgftO6JS8betek/Rvu+eTkMOSK7ewHY9hVEgtF9KTrMwQcfzJo1a/jxxx9Bc87OBP43btkiYBrah5PTgHeM//+FEDbgdOAoY7Eu5vpIKXcIIZzAyUBWEj2iDW+jjppBvKPmddlpSRH6bPSH+HFHE6eMSczzS4XhqK2v7qBQ0/caCEVw2m1UNwW0PnDhSFaFWuxkgggN/iDhiEy5p7Cq+mwdKeUxba9SdJaJEyEc1kKeTzKdWvpwKQ8nXTtggMpNy1WklK8Dr8cduyXu+ewk1/0/YP8u3Vw2KdxNS0TPlTy1zXphoXLUOo3D4WDu3LmccMIJAPsCtyf5gPIE8LQQYi2ak3am5RZHAZuMamkdN/AfXaTZ0UTaX7vh7STgD4Vx2oUpEqxCLT5Ume+KThKI56uqOqSE/TvhqLU3R83o/eYPRch3a6HPQaVeNtQ0my1BskEoEsFhE4QikmBYmq5lU4qwsar6TAMhxC/Q/gGaM0OklLdl8jV6M9aQ5zXcx0F8zqk8TzV9E9aqoeuKXZb+Y3JIqC0Hbyn0yXzyeW9k0qRJTJo0CSHEKinlnRD7AUVK6UNzzRKQUi4lNmKDlLIJOKjrdpw+vmAkpn+Z22ENfSY6aqlCnytTFBK0RrE+WD0a+mxfVpNL37eR+1XTFKCswE2TP0x1NkOfEYnHaafRHyIUjpgFG03+5D+7nlr1mbEcNSHEY2jVOJei2dqnA0MydX8FXHih9n1fVjGb2TzH//Aip8asEQKeeUaJNMUuzICxUL0WfPXZ3onmqA0YqwoJFG3iD4VjkvidltLDPFfyHLVkBRarqurYvSixkKA1hBD0K3R3OEct6qhpAqimKUBpnouyAld2Q59haYrOUESa+0vpqJmhz+7ZX3eRSUftCCnlaCHEl1LKPwgh/kRsN3VFJ6isBJ8P7IRYwHnUUcwlzI1ZM2AAVCXPsVQodh0G6Plgr14B+ZmvzmsX21fD8OOzuwfFLoEvGImZsemyp3bU8lx2whFJIBxJmMu5eksD+w0savfr9yt0s2lnC0BakwmsWHPUQJtMUFrgoiUYpropu1Wfxs8nZAl9pnIjzRFSPeyDVSaFWov+vVkIMQCoRmvUqcgAN92kfb+a+zmYTzmdf7KD6B8xIZRIU/QQKg6G0j1hbQ4kWHpLYO8Tsr0LRY6xdlsDH/9Yw1mHRoNG8Y6ayyKW4hveevXigpZA4gD12pYAY/L7tHtPRkEBgMfV/vYcoOWoRSKSnc1BSvNc+IMR1vyUvVY5mlCzIYSWr2YItcYUjpoaIdU2rwoh+gD3AZ+jVXxmJamzJ7J+PezD1/yBW/kXp/F8XBrH009naWMKRabx9oHLPs/2LhSKlMx77wf++ekmzjx4sCkKEhw1h9GmQySIsXw9FNocCNMnL+aUNiIqjaHq8RgFBdDxqk9/KEK9T6usLM13EQxH2NEUQEqJEIKdTQHOmf8xD089kD36dn2DznAkgt0mcNq0nnT+YBuhT1VM0DpSytv1hy8IIV4FPFLKukzdvzczc2Y05NlAIbN4JOa8asGhUCgU3cfnG2oBaA6EKPQ4Ac1R88Q4atrj+IpPwBRi8SE8KSUtgXBCTls69CuyOGrtDH26LcUERqizNN+lhWdDERr8IYo8TtZsa2RVVT2rt9R3i1ALhbU5ow67IGxx1JpShD4jqo9acoQQBwMbpZRb9efnAqcC64UQs6WUNa3eQNEq++4LX38N1/AAh7KMM3iW7fSLWaNacCgUCkX3UNcSZO22RkALwZlCLRiJqfR06cUE+a7EP7NGX7X4Fh2BcIRQRHZMqOnFBzYRW8iQDi5LMcFOi1AzhE91Y4Aij5MGXxCAYBrjnDJBKCJx2m3YbSKt9hxG1WdPC31mojbicSAAIIQ4CrgHeAqoQ581qOgYEydqIm0kq7mNW3iBX/NP/ifb21IoFIpey4qNteZjq2DQHLXE0Ge+O1F05aVw1Fr0594k4q4tDEfN67S321FyW4oJrI5a3wJN/BmVn/W6UPOnGOGULmt+akg1UiyGUERz1Jx2m56j1jurPjPxduwW1+wMYJ6U8gUp5c3AXhm4f6/E6JlmI8wCzqORAmbyF+JH4ak5ngqFQpF5VlUlnym5fMNO83GjpZ+XL8FR08RY/FQCiIY+W+KEmiHc8juRo9be/DSILSbYmUSoGb3UGnyaQEo1azMdftjeyHEPvseH31e3uTasN7x12IRW9Wn0UUvRLLinVn1mRKjpYzwAJgDvWM51KrQqhDhdCPGVECIihBjXmXvtakyfrn2/kgc5jI+5hLlsY7eEdWqOp0KhUGSWBl+QKY98wKNLv0849/mGWrOtXjqOWnxrDoiGQ+MdtWbTUetI6FNz1Dom1JLnqPUtcAGwXZ9OUN/S+dCncf+fGnxtrg2FJQ674ahFQ5++YIRQkj301KrPTAi1hcC7QohX0Fp0vA8ghNgLLfzZGVYBvwbe6+R9dikmToRQCEbwDXfwe17kVzzHGQnrRo1SRQQKhUKRaWqbtcrHF5dvignRRSKSFRt2MlqfGmBtE5HgqOmPk+WbRUOfsc6Q4bAlc+HaoiTPqVWYtnMqAcRWfdY0Bchz2fE47ZTmuxACdjRkzlEzXLHGFNMFrIQiEodNy1ELhaOhT0heUNBTqz47LdT0MSC/A54EfmYZIG1Dm1LQmXuvllJ+27kd7lpYQ57zOZ8m8pOGPNWIKIVCoegajNDa+urmmJy0H3Y0Uu8L8bO9tbF9rTlqRkJ/MkfNDH0G4x017X4dKSbQphN42j3nE6wNb7VigpI8zUlz2G0Ue53sbNYdNT1HrTNCzddGiw0rRo6awy4IWhw1SBS5oAlpUCOkkiKl/EhK+ZI+d8049p2UsluaIQkhZgghPhVCfLp9+/bueMkuwxgTdQUPcQQfcikP8xO7x6y5+GIl0hQKhaKrsIqIV1ZsZlu9j1teWcV5T34CwFF7a83GW3PU3K205zCEWPzMys6EPgH6Fbk7JPKsOWrVTQHK9JAnQEmei53NmkCr1x21zoQ+fW0UBFgxctScNlvMrM9U14d7aOgzo0PZO4IQ4i2IUyIaN0kpX0nnHlLKeegVpuPGjWu7lCRHMcZEDedb7uD3vMwUFjI1Zs2ECfCXv2RpgwqFQtELMMJyA4o9vLyiin+v2kJtc5Dxe/Xlop/vyQGD+ujrNLEgpUzMUTOKCZJUfXocdoSAljhXKFpM0LE/zTectI+Zp9UerCOkttS1MLg0WqXWJ89JbXNsjpq/E0ItGvpMw1HTc9S0PmoyNvSZJHSqG2r0MJ2WfaEmpZyY7T3kChdeGA15tuDlYh7FGvK021XPNIVCoehqDLdm6iGD+dPi7xhU6uXlWePZp782g1NKLSRnrAuGJRFJ0hy1giSiy2YTeJ32JMUEHQ99AhyyR2mHrnPYBDahuV3rq5tNxxA0R22bnvifiRy19jhqRo6aI66PWqrrIz206jPrQk2hse++mpt2BXMYz//jbJ5mK/1j1vz971nanEKhUPQiDLdnypiBDC7L46i9yynJj4YDhRDku+ymq2M4PVZHzevSXLPiPGfS18hz2WmOy1EzctY6GvrsKEIIXA4bm3a24A9FGNI31lH7dqs277M+Aw1vzRYbaRQThM0cNVvMrE9I7siZxQQ9zFLL6bZwQohfCSE2AYcDrwkh/pPtPXUFM2dqjW33Yg13cSOL+CWVxJZzqjFRCoVC0T0Ybk2hx8GUMQNjRJpBgdthigWfLj6sjlqx18nfzzuEX40dmPQ1vC57yj5qHXXUOoPbYee7n7SJC0NKowNIS/NcZjFBJh21tEKflj5qxqxPw6mMdyMhmqOmHLVuREr5EvBStvfRlVRWwqOPRhvb+vBwEY9hDXm6XCrkqVAoFN2FIdSSFQIY5Lsd5jrDUXPHVVweNbw84TqDPKcjIXzXrD9v76zOTOBy2PheH401tCzqqJXku2gOhPGHwuYIqUy050hWtRmPtY9aSzCMPxShLN/FljpfUqEXUY6aItPMnAlnn609voS5/IwPuJw/s4UBMevmz8/C5hQKhaKX0ugP47LbTPcmGfltOGptkee2J2nPoQ1kz0Z7CbfDRiCsOVgD+kQHvPfRQ7fb6v3m+wxkoOoz3T5qdksftUAoQqnubvamqk8l1LLEzJmakwawJ2u5mxt4lV/wNOfErHO5VMizJyKEOFEI8a0QYq0Q4vok56cLIbYLIVboXxdazk0TQqzRv6Z1784Vip5PcyCUdEanlUJPVKgly1FrizxXkmKCYDgrYU+IFj9UlHhxWIZlGj3VNtQ0m8cCoY43V4jmqKXTnkNq7TnsRjFB2BSOrTW8VaFPRacxwp0AggjzOZ8ALn7L48Q3tlVuWs9DCGEHHgGOAzYBnwghFkkpv45b+pyU8pK4a0uBW4FxgAQ+06/diUKhyAiN/lCrYU/QWmj8VK9VQ3bEUfM6HdQ0tcQcawmEu72QwMAYIzW4LHaAtCGMYoRaZ4oJ2lP1GY5oxQQ2o5hAG22lFXIkCX0qR02RKS66KPp4Fo9wFO9zBQ+xmdik02eeUW5aD+UQYK2U8gcpZQB4FpiS5rUnAIullDW6OFsMnNhF+1QoeiVN/lCbvcy0HLXUVZ9tkeeyJ+mjFiLPmR3/xHDUhpblxRw3Qo3rq62OWtthy1T42tNHLSJx6n3UjFmfboedfLcjxWQC7XsP02lKqHU3M2dCo5avyTC+5x6u53VO4u/ERrAuvliJtB7MQGCj5fkm/Vg8pwohvhRCPC+EGNSea3vStA6Fortp8ofbDH0WuO3R0GdHctRc9oTwXXNWHTVt74NLY4VaNPSpDR5yOWwEw50IfYYMcZt8sLoVI0fNYROE9NCn22HT8wN7T9WnEmrdSHzI8wkuIISDGczDGvJU0wd6PMl+i8T/5vs/YKiUcjTwFmB00UvnWqSU86SU46SU48rLU1eeKRSKRNIKferFBMZUAmivo+ZI2p4jWzlqbtNRSx76NBy1vvkus+pzS10Lf1m6NmZwfVv4YsZAte7MGTlqDnt0hJTbaSPfnSL0qao+FZ3lwgujjy/mUY7mXa7kQaqoMI9PmKBacfQCNgGDLM8rgM3WBVLKaimlX3/6V+CgdK9VKBSdo8kfSjpM3Uq+26GPNYp0KEetyOugKRAyh5SDIdSyFPrUCwiGxIU+3Q47eS47G3ShVlbgNoXaG6u28sc3vmVbg590sY6BamylRYeU0mx467QMZdf2k9jaBFTVp6KTGJMHAPbgB+7lOt7gBBZwnrlGibRewyfA3kKIPYQQLuBMYJF1gRDCOpZiMrBaf/wf4HghRIkQogQ4Xj+mUCgyRFMajlqhRzvf6A91yFHbu18hUsJavXcZaLM/s+aoOW0IAYPiQp+ghT8bdGFUVuAyJxMY7UWSNZ9Nha+NweoGId0dc9q1YgJj1qfbYaPArYnceHrqCCkl1LqYykpwu7XJAxANeUaw8Rv+ihHJuvhiJdJ6C1LKEHAJmsBaDfxTSvmVEOI2IcRkfdllQoivhBBfAJcB0/Vra4Db0cTeJ8Bt+jGFQpEhGtNx1HTnq8kf6pCjtk//QgBWb6k3j2Uz9FnsdTG4NC+p2CzJ18KfQmiizRjl5GtH81oDfyhsOl6tFRREx0FpfdSC4YjuqNliCjmSX9OzhJpqz9GFVFbCeedBMBg99lse5xiWciF/ZZMewcrPVzlpvQ0p5evA63HHbrE8vgG4IcW18wHVuEWh6AKklDQF2i4mMBy3jjpqQ8ry8ThtrN7SYB7LZnuO3x0/nBm+YUnPGQUFBW4HHqfNbM/h1x21+Fy71vAFtaa12xv8aTlqRh+1lkAYKbXpD6nacxg1DvYe5qgpodZFVFbCuedGy4UBhrCO+7iGNzmOJ7jAPP7441nYoEKhUCgS8IcihCOyzVwxw3Fr8oc75KjZbYIRuxeZjpomELMX+uxb4KZvgTvpuT66UCvyOHHZbWbo09eB0Kc/FKYsDaEWDkfdMW0ou/Y86qhFr62qbeHl5VU47ZpAs/WwWGEPezu5geGkRWIqj6UZ8ryQv2GEPNWwdYVCocgdjHBc28UEdn19EH8obFYntod9di/km631euVohIgka8UErVGiV34Wehw47TazmCAa+myfo1ZWoAm/1sZIBfU/oE67wGkJZbodNs1RC4TNnLSFH2/gvv98y5eb6gCVo6ZIg8svjw13AsxgHhN4h6u5n40MBmDUKJWXplAoFLlEsy4e2iomKDBDn5qj1h43zWCf/kXsbA7yU73fDB9my1FrjRhHzREVakYxQUsw/Rw1XzBMab7m3LXqqMXkqEV/tkbDW+vrr6zSBNp/1+7Qr1FCTdEKM2dCdXXsscGs536uZjET+Su/ATQn7auvsrBBhUKhUKQk6qill6PWpOeotSc/zWCf/kUArN5aT3Mwd4Vaqe6oFXkduBxaGDISkR0MfUYoyzcctfRy1Bx2i6PmtMX87KWUrNKFWm2z5pAoR02REmtD2yiSv6E1UDOqPMvKlJOmUCgUuYjR9qFNR80TW/XZEUdtxO7Ryk9jnJQ3F0OfurAq9Dhx6uHdQDiCz3DW0hRqkYgkEIpQ7HVit4nWiwn0PDijj5qBy24zw85NgTCb63xUNwUo9jrNNcpRU6Tk8ssTj13I3ziOt7iG+1jPUFwu+POfu39vCoVCoWgbw+VJZyi7sd4finTIUSv2OhnYx8vqLQ1mu4m8Dtynq4mGPh2mIA2EI+121IxqUU8rlZsGpqOm91EzcDttMa1RVup5aecePsRc08N0mhJqmaKyMjHkOYgN/Inf8TbHMo8ZlJXB/PmqeEChUChylaY0iwnsNoHXaafRp00XcHXAUQOtn9rqLfWm2MlrI+SaDaLFBE7zfQZCEbM9R7pCzRB2RtPa1ooJwmbo0xYb+nTYLfmBIVZW1eKwCaYdMRS7TWATIFToUxHPzJlw9tnxRyV/5TfYiHABT/D0MzZ27FAiTaFQKHKZpjQdNWNNU0Bz1NwddMJG7F7Iuh1N1LVo+VW5WfWpO2pehxn6DIajo7Na0mx4azTK9TjtCS024glZ23PEFBPYzLDz+uomVlbVs/duhfQtcHNARXGPC3uCEmqdprISHnss8fj5zOcE3uQa7mNH/lAl0BQKhWIXwHB58tNI6i9w29nZFOSrqjoq+ng79HrDdyskFJF8vVkL4eViMUH/Yg+njBnAz/YqN2eCBkIRfKGOO2r5KcZAGYQs7TniHbVR/YvYb2ARf3zjW77YWMvogcUA/PKAAQzrW9D+N5jjKKHWCSorYdo00OfAmlSwkQe4inc4hsf5rWpoq1AoFLsI7XXUlny7jeqmAKePq+jQ6w3fTSsoWL6xFgBvDuaoOew2HjpzLKMGFMWEPs0ctWC6Qi3qqBW05ahZxkE546o+HXYb959+APW+IHUtQfar0ITa9COG8sYVR7b/DeY4Sqh1kMpKmDEDwgn/f0rmMQM7YS7gCUrLbMpNUygUCp033ngDYD8hxFohxPXx54UQbiHEc/r5j4UQQ/XjZwkhVli+IkKIMfq5g4QQK/Vr5ohOJCk1+UO4HDYzxNcaBW4H/lCEihIvR+1d3qHXG1aej90m+EIXarnoqFmxVn0a1Z7pVn0ao7Y0R82edF6nQUyOWlzoE2Dk7kVcMXE4AAcO7gNouWk9LT8NlFDrMDfdBM3NicfPYwEn8QbXcS+bXXuoCk+FQqHQCYfDzJo1C+A7YBQwVQgxKm7ZBcBOKeVewIPAvQBSykop5Rgp5RjgHGCdlHKFfs2jwAxgb/3rxI7uMZ2B7AbGuqmHDMbWwdwot8PO0LI86n2au5SLOWpW3FZHLdS+oexWRy3f7Wi9j1pMjlps6NNg5tF78uaVR7HvgOL2vYldDCXUOsiGDYnHBrKJB7mSpfycp/MvVhWeCoVCYWHZsmXstddeAAEpZQB4FpgSt2wK8Hf98fPAhCQO2VRgIYAQoj9QJKX8UEopgaeAUzq6x+Y0BrIbFHgcOGyiw2FPA6OfmhDgceb2n2Uj9OkPRaITCtrrqDm1qs/0c9QSHTXQHDQjdNyTyW3pnsMMHgzr11uPaCFPByHq/vQE9Vfl9j82hUKh6G6qqqoYNGiQ9dAm4NC4ZQOBjQBSypAQog4oA3ZY1pxBVOAN1O9jvefA+NcWQsxAc90YPHhwyj02+kNmn662mH7EUI4eUU6/Qk9a61Oxd79CYCt5TnvOh+6M0GeDLyqy0i8m0B01RxpVnxHrUPbYHLXeRu97xxli0iTt04/BNP7OJP7N1+few5Sr9szexhQKhSJHkfGVV/rhuOfJlIq5RghxKNAspVyVznrLa8+TUo6TUo4rL0+dT9bUjtDn2MEl/Gps59w0iDpquTiVIB7DUWvwRQdapyvUDEfNoztqwbA0j8UTDkdz1JyWHDVXOwff9wR63zvOAJWV8Pe/R6s9B1DFQ1zBmv5HcvCCWdndnEKhUOQoFRUVbNy4MeYQsDlu2SZgEIAQwgEUAzWW82eihz0t661qKdk906bJHyIvTaGWKYbvprWUyPVCAogKpXq975vDJszh6G1hOGpuh91sf5KqoMDqqBm90bS5n71PtvS+d5wBYgsJJI/zW1wEuFDMB5v6kSoUCkUyDj74YNasWQPgEkK40ETXorhli4Bp+uPTgHf03DOEEDbgdLTcNgCklFuABiHEYXou27nAKx3do1ZM0L2CaUhZPi67bdcQarqjVsoEc0QAACAASURBVNeihS1L8l0pc9RWVdVRVdtiPrc6atbB6smw5qgZ7Tk6Mk+1J9A733UnsRYSnMPTnMxr3MDdvL9lr+xtSqFQKHIch8PB3LlzAYYDq4F/Sim/EkLcJoSYrC97AigTQqwFrgKsLTyOAjZJKX+Iu/XFwN+AtcD3wL87uscmfzjtHLVM4bTbGFaev2sINcNR00OfZfkuWoJhIpHEsPalC5fzp/98az63OmqF+nSBtdsbk75OOCZHTXvNjk5/2NXJ/YB4DmIUEvRnM3/mct7nZzzMpbSSn6pQKBQKYNKkSQCrpJTjjGNSylssj31orlkCUsqlwGFJjn8K7JeJ/TX5Q2k1u8001500MklmXe4Rn6NmjJfyhcK4HXYiUpoFB9WNfrY3+s1rzckEThuH79mXoWV5XPXcCl6cOZ49+uYD8PrKLfy4o4ndi7QCDa2PmnLUFO1k0iQQesjTg4/zmY83z8add2Z7Z4pdBSHEiUKIb1tp+nmVEOJrIcSXQoi3hRBDLOfClqaf8WEjhULRCQ7fs4xR/Yu6/XWPGdGPY0b26/bXbS+GUKvXQ5+l+ZpQaw6EufeNb/jfv34EaIUjjf4Qtc3RogNj1qfbYaPY6+TJ8w5BCMF5C5YRDGvnXllRxYIP1kUdNcsIKSXUFG1SWQl9+8Kjj8L/UskveZUbuYvvxd5Mm6Z6pinSQwhhBx4BTiJ108/lwDgp5Wi0XlJ/tJxrMRp/Sikno1AoMsa8c8fxPwcPanthL8XIFzNCnyX5TkDrpbZ6Sz0/bG8CNOEWkbCzOWBe6w+GcTtsZguSoX3zufK44ayrbuanep9235YQO5sDBHTh5rQMZbc2u+1N5LRQE0LcJ4T4RncVXhJC9MnWXoyRUdXVsDtbmMNlfMARzOEypITXX8/WzhS7IIcAa6WUP6Rq+imlXCKlNEpWPiK2qk2hUCiyQjT0qTtqeVFHbUdjgHpfECmleb4uzlGLd8XKC7TrDYeu3hckHJFUN2oCzzrrszf2UIMcF2rAYmA/3VX4DrihuzdQWQlDh8LZZxuVnpLHuAgvLZzPfCJoCj/ZpAKFIgVmQ0+dpA06LVxAbHK0RwjxqRDiIyFE0g7sQogZ+ppPt2/f3vkdKxQKBYnFBCVm6DPE9gY/wbDEF4yYOWwN/pAZ1vQFw3jiCgKKPJojV6e3+zAE3rYGzWFz2GzRYoJeGvrM6WICKeWblqcfoZVqdxuGi2ad6TmVhUxhEb/jfr5jhHlcFRIo2kFaDToBhBBnA+OAn1sOD5ZSbhZCDAPeEUKslFJ+H3MzKecB8wDGjRu3C6QoKxSKXQEhNIfL6KNm5Kg1+kPUNGmFA/W+oDm7FKC2OUh5oRt/KJIo1LxO8xrr95/qtXvZ7cJSTKBCn7nO+aQouc60e5DoomnsxlYe5lI+5DAe4grzeF4eqpBA0R7Mhp46SRt0CiEmAjcBk6WUZumUlHKz/v0HYCkwtis3q1AoFFZcdpspxAyhtrm2BaNDR31LMGZyQV2LFsb06TlqVoq9UUdNSmkKwKijJlTVZ7Y3IIR4SwixKsnXFMuam4AQUJnsHumOBmkNQ5wJAeecEz/HE0DyKBeTTxPnscAMeZaVwbx5qpBA0S4+AfYWQuyRqumnEGIs8DiaSNtmOV4ihHDrj/sC44Gvu23nCoWi1+Ny2MyqTKM9x/rqqKtR7wvSaGlku1PPU2vVUWsJ0qQXIABmcYEjpo9a1iVLVsh66FNKObG180KIacDJwASjO3WmiQ9xJnuVM3iOX/Ey1/BHvmUkoIm0HTsS1yoUraEPmr4E+A9gB+YbTT+BT6WUi4D7gALgX3qF1Aa9wnMf4HEhRATtg9Y9Ukol1BQKRbfhtIxx6pOnCa0NNRah1hKKGdq+sym1o1bodiCEJtQMNw1gR7Jigl4a+sy6UGsNIcSJwHXAzy0VcBkndiRUIv34iblcwkccygNcBWjhzj//uat2pOjpSClfB16PO2Zt+pn0A4yU8v8B+3ft7hQKhSI1RuWn22EzpzjECDVfbOizVhdgvmCYvLipDzaboNDtoN4XMvPTQJtMYLcJhIjO+lShz9xkLlAILNabez7WFS/SesWm5C/MpIBGLrRpIc8hQ1S4U6FQKBS9E0OoeZx2vPrYq1ihFuuo1eq91JK15wAt/FnXEjRbdBgYuWlOm6r6zFmklN0yPNMYCZWM0/kXp/Iiy8+4h1XP7tMd21EoFAqFImcxWnR4nDbcDhs2oVV2Ou2CYFjqxQQhCt0OWoJhczpBsvYcoBUUWEOfbocNfyhiCjWbTWATvXfWZ++Up3HceacWyrQiBJSzjUdts9gx7GDGPvO77GxOoVAoFIocwnDUvE47QggznLl7sQe3w6aHPkMUehz0yXPFFBMkddQ8uqOmhz6NuZ9GyBPghH13Z9yQki59X7mKEmpoIcx582DIEE2gDRkCTz8N206/hDJHPX0XLQBHTpuPCoVCoVB0C1FHTXO4jPBn3wI3RV6nXkwQpNDjpE+e0wx9+oKRpK5Ysdep9V7THbWhZZpQc1iKFh49+yCO33f3rntTOYwSajpnnQXr1kEkon0/y/Uv+Ne/YPZs2HffLO9OoVAoFIrcwCwm0EVXnkWoFXocMY5aSZ7TDH36Q2E8SVpsFHkduqOm5agN1R01hy1Zb/DehxJqydi+HWbNgnHj4Jprsr0bhUKhUChyBqM9h8cSAgUoL3RT5NHyzRr8QQo9Doq9LnMwuz8YSdpio1h34epbguS57OxW5AaUUDNQQi0Zl14KdXWwQIU8FQqFQqGwYq36hFhHrcjrpN4XotEXosDjpCRPyz+LRCSBcCS5o+Zx0hIMU9MUoMjjNKcd2O1KqIESaom88AI89xzceivst1+2d6NQKBQKRU4RFWq6o+ayOmoOGlqsxQROdjYH8Ie0wexJHTW9ae6mnS0UeR2U5WuOmtGWo7ejfgpWduyAmTPhoIPg2muzvRuFQqFQKHKOhGICpxZ5Ki9wmY6aterTF4yY4c9UjhrAxp3NFHmclBXojpoKfQI53ket27nsMti5E956S4U8FQqFQqFIginUHElCnx7NQQtHJEUepzkLdMm32sjivfoVJNzPGMy+td7HPv2LKMtXQs2KUiMGL70ECxfC7bfD/mpCj0KhUCgUyTD7qLlihVp5oZsir8Mc2G6EPgFe+ryKPJedQ/YoTbhfkVeTIlJCkcdBiS7UHCpHDVChT43qarj4Yhg7Fq67Ltu7USgUCoUiZzGqPt1xOWqGo2ZQ4I4KtU/X7+Rne/VNWfVpUOR14rTbKPY6cagcNUA5ahqXXaaJtTffBKez7fUKhUKhUPRSzGICXXSNrijmoCEl5LsdFFlEV6HHSR+vy3x+7Mh+Se9nFXfG47J8l2rPoaOE2ssvwz/+AX/4A4wene3dKBQKhUKR08S35/jV2Ap+NbYC0EKXBoUeByX5URF29IgUQi3GUdOuryjNw6mEGtDbhVpNDVx0EYwZAzfckO3dKBQKhUKR87j03LFkFZyFHquj5jAdtVH9i9i92JP0fh6nHZfDRiAUMR21P51+QKa3vcvSawPAlZXw4uDLCf5UzaSfFlD5TxXyVCgUCoWiLeIdNSvFXouj5nbiddmpKPEyZcyAVu9p5KkZ7lp5oZvyQnemtrxL0ysdtcpKePn8Rfwr8AyzuZV/bxnDuzO0c2edld29KRQKhUKRy0T7qKXuiQaaowbw7jXH0FYUs8jjYHuDP+Z6hUavdNT+eH0NcwK/5QtGcxc3AtDcDDfdlOWNKRQKhUKR4zjjZnxaseabFehCzW4TCNG6Uos6ar3SP2qVXvkTuWrTlZSznUm8TpBoRcqGDVnclEKhUCgUuwAusz1HolBzO2y47DbsNmG28UgHQ+ApRy2RHu+oVVbC0KFgs2nfl179KtN4iru4kRWMjVk7eHBWtqjohQghThRCfCuEWCuEuD7JebcQ4jn9/MdCiKGWczfox78VQpzQnftWKBSK+PYcVoQQFHkdZtgzXeJz1BRRerSjVlkJM2ZoYU2AuvU7Gf7Ab6kq3Z8HWn4PLdG1eXlw553Z2aeidyGEsAOPAMcBm4BPhBCLpJRfW5ZdAOyUUu4lhDgTuBc4QwgxCjgT2BcYALwlhBgupQx377tQKBS9FbcjdY4a6K5YOztrGE5aewVeb6BH/0Ruuikq0gAe4Cr6yZ84xbWIR+a4uOkmLdw5eLAm0lQhgaKbOARYK6X8AUAI8SwwBbAKtSnAbP3x88BcoSV5TAGelVL6gR+FEGv1+33YkY384f++4uvN9R16EwpFKkYNKOLWX+6b7W0ouogDh5QwZcwARuxemPR8YQdcsbGD+/DN1vp2hUt7Cz1aqFlzzk7idc7jSe7gJl7/6SBePUsJM0XWGAhstDzfBByaao2UMiSEqAPK9OMfxV07MP4FhBAzgBkAg1VMX6FQZJB+hR7+fObYlOdPPTDhV1Kb/PrACn59YEVnttVj6dFCbfBgWL8eiqllHjNYxb7czs0qF02RbZIFBWSaa9K5FinlPGAewLhx4xLOGyjXQ6FQZJpzDx+a7S30KHq0x3jnnVru2Z/4Hbuzlek8iSPPrXLRFNlmEzDI8rwC2JxqjRDCARQDNWleq1AoFIoeQo8WamedBf836w0uYD73cS07hoxj3jwV8lRknU+AvYUQewghXGjFAYvi1iwCpumPTwPekVL+f/buPT6uqlz4+O+ZyeTatE0vKS0ptIVApYpwLBw4Yom0FVAsKHgUEYpaqb548AIoeqRCOR7L0RcVRWxFpaAiCgioQLnGHl4oUK5SWhtogSS0TS9pmubSZGae94+1Jp1MZpJJO8lMkuf7+cxnZtbs2XvtvWfPPLOu6tM/5XuFTgcqgWcHKd/GGGMG2bCu+qSpidPu+AIccwzfeuG7fMtmozA5wLc5+zKwCggCv1bVdSKyFFirqvcDvwJu950FduGCOfxyf8R1PAgDl1qPT2OMGb6Gd6B2xRXwzjtw991QYFGayR2q+gDwQELakrjH7cAnUrz3e4BV4BtjzAgwfKs+H34YbrkFrrwSTjwx27kxxpgR76GHHuLoo48GePcBDPR8rIg8LSLrROQfIlLo06v94M8v+Vv5YO2PMYNheAZqe/bAokUwcyZcc022c2OMMSNeJBLh0ksv5cEHHwRYB5zvB3CO1zXQM/Aj3EDPsQ41vwW+qKqzgCqgM+59F6jqcf7WMMC7YsygGp6B2pVXQn09/OY3UFiY7dwYY8yI9+yzz3LkkUcyY8YMcEPKxAZ6jnc2sNI/vguY6wd6/hDwiqq+DKCqO61tphkphl+gtmcPrFgBl18OJ52U7dwYY4wB6uvrmTo1fmSZpIM1dxvoGYgN9HwUoCKySkReEJFvJLzvN77a82of2PUgIpeIyFoRWbt9+/ZM7JIxg2L4BWpvvQVHHw3XXpvtnBhjjPHc6DI9kxOepxrQOQ84BbjA339MROb61y9Q1fcAH/C3C1Nsf4WqzlbV2RMnTjyAPTAmOyTFxTNkich24K0B3swEYMcAb2Ow2T4NnMNVNWu/DGlcE7lynBLlYr5yMU8wNPJVAkwBaoDDgRsAVPX7sYVFZBVwjao+7dulbQUmAp8EzlDVi/1yVwPtqvqD+I2JyMXAbFX9cm+Zsmsio3IxTzC08tXrb8SwG55jMH4QRWStqs4e6O0MJtun4auvayJXj1Mu5isX8wRDI18+8NqIG3amHjfw86cT3hIb6Plp4gZ69gHcN0SkGOgATgV+5Nc5VlV3iEgIOAt4tK982TWRObmYJxhe+Rp2gZoxxpjcc5ADPTeKyA244E6BB1T1byJSAqzyQVoQF6T9ctB3zpgBZIGaMcaYQXGQAz3/FjdER3xaC/C+zOfUmNwx/DoTDI4V2c7AALB9Grly9TjlYr5yMU9g+cq0XM13LuYrF/MEwyhfw64zgTHGGGPMcGElasYYY4wxOcoCNWOMMcaYHGWB2gESkR+IyAYReUVE/iwiY7OdpwMhImf4CY1fTzZJ8lAjIlNF5AkRWe8nb/5KtvOUq3Ll3Kc6ZyIyTkQeEZEaf1+WpfwFReRFEfmrfz7dTxhe4ycQz89CnsaKyF3+O2i9iJyc7eMlIl/z5+9VEblDRApz4Vj1h10TaefPron08pSRa8ICtQP3CPBuVT0WNzbQt7Kcn34TkSBwE3AmcAzJJ0keasLA5ar6LuAk4NJhsE8Zl2PnPtU5uwp4TFUrgcf882z4CrA+7vn1wI98vhpxE4kPtp8AD6nqTOC9Pn9ZO14icihwGW6w2Xfjhsr4FLlxrNJi10S/2DXRh0xeExaoHSBVfdjPRQewBqjIZn4O0InA66q6SVU7SD5J8pCiqltU9QX/uBl3sSbOJ2hy6Nz3cs7iJ+heCZwz2HkTkQrgI8At/rkAp+EmDM9KvkRkNDAHN+YYqtqhqrvJ/vHKA4rEDUJbDGwhy8eqn+yaSINdE/2SkWvCArXM+BzwYLYzcQC6JkD2kk2SPGSJyDTgeOCZ7OYkJ+XkuU84Z5NUdQu4Hy6gPAtZ+jHwDSDqn48Hdsf9ScvGcZsBbMdNRP6iiNwibuDXrB0vVa0Hfgi8jfsxagKeJ/vHqj/smkiPXRNpyOQ1YYFaL0TkUV+3nHg7O26Z/8QVU/8uezk9YKkmQB7yRGQUcDfwVVXdk+385KCcO/e5ds5E5CygQVWfj09OsuhgH7c84F+Am1X1eKCF7FWBAeDb/pwNTMfN51mCq0JMlMvfL7lwbruxayJtw/qasJkJeqGq83p7XUQW4uaWm6tDc0C6OmBq3PMK4J0s5SVjxE0nczfwO1W9J9v5yVE5de5TnLNtIjJZVbeIyGSgYZCz9X5ggYh8GCgERuNKE8aKSJ7/V5yN41YH1KlqrKT4LtyPUjaP1zxgs6puBxCRe4B/I/vHqj/smuibXRPpy9g1YSVqB0hEzgC+CSxQ1dZs5+cAPQdU+l4o+biGjvdnOU8HxbeX+BWwXlVvyHZ+cljOnPtezllsgm78/X2DmS9V/ZaqVqjqNNzxeVxVLwCewE0Ynq18bQVqReRonzQXeI3sHq+3gZNEpNifz1iesnqs+smuiT7YNdEvmbsmVNVuB3ADXse1Z3jJ336R7Twd4H58GNdr9Q3gP7Odnwzszym4ouRX4s7Nh7Odr1y85cq5T3XOcG1fHgNq/P24LOaxCvirfzwDeNZ/B/wJKMhCfo4D1vpjdi9Qlu3jBVwLbABeBW4HCnLhWPVzH+yaSD+Pdk30naeMXBM2hZQxxhhjTI6yqk9jjDHGmBxlgZoxxhhjTI6yQM0YY4wxJkdZoGaMMcYYk6MsUDPGGGOMyVEWqGWAiIwXkZf8bauI1PvHu0XktUHOy3F+MMLY8wUickAjNIvImyIyIUn6GBG5TUTe8Lff+VGYM6q3fRGRa0Tkikxv0wwfIrLX308TkU9neN3fTnj+VCbXb8xAsGtiaLJALQNUdaeqHqeqxwG/AH7kHx/H/vnQMsZP8JrKcbjxdmJ5u19Vl2U4C78CNqnqEap6BG48mFszvA0YnH0xw980oF8/SiIS7GORbj9Kqvpv/cyTMdk0DbsmhgwL1AZeUER+KSLrRORhESkCEJEjROQhEXleRP5XRGb69MNF5DERecXfH+bTbxWRG0TkCeB6ESkRkV+LyHN+Etqz/WjaS4FP+hK9T4rIxSLyM7+OSSLyZxF52d/+zaff6/OxTkQu6W1nRORI4H3AdXHJS4H3isjRIlIlIn+NW/5nInKxf7zE5/dVEVnhR2tGRKpF5HoReVZENorIB/ral4Q8pTqWn/DbellEVvf/1JlhYhnwAf85+pqIBEXkB/6z+IqILAbwn90nROT3wD98Wo9rQ0SWAUV+fb/zabGSCvHrflVE/iEin4xbd7WI3CUiG3wpdLI5Eo0ZDHZNDCXZGtV4uN6Aa4Ar/ONpuAnbj/PP/wh8xj9+DKj0j/8VNxUHwF+Ahf7x54B7/eNbgb8CQf/8v+PWNRY3mnYJcDHws7j8dD0H7sRN7gsQBMb4x+P8fRFuBOXx/vmbwISE/VsA/DnJfv8ZOIe40ap9+s+Ai+O34x/fDnzUP64G/q9//GHg0cS8J9mX+OOc6lj+Azg0doyy/dmw2+DegL3+PvEzeQnwHf+4ADea+XS/XAswPW7ZVNfG3hTbOhd4xF9fk3DTyEz2627Cze0XAJ4GTsn2MbLbyLrZNTE0bzYp+8DbrKov+cfPA9NEZBRuctY/xf2BKPD3JwMf949vB/4nbl1/UtWIf/wh3OS4sXZahcBhfeTlNOAiAL+eJp9+mYh8zD+eClQCO1OsQ3BTmyRL78sHReQbQDEwDliHC0wBYpMOP48LcNPSx7H8f8CtIvLHuPUb8yHgWBGJzbc3BveZ7wCeVdXNccv259oAN/XPHf762iYifwdOAPb4ddcBiMhLuM/5k5nZJWMOil0TOcwCtYG3L+5xBPcvJADsVteOrS/xQVFL3GMBzlXVf8YvLCL/2p/MiUgVMA84WVVbRaQaF/Slsg44XkQCqhr16wgAxwIv4ILF+Cr1Qr9MIfBzYLaq1orINQnbiR2nCP37XKY8lqr6RX88PgK8JCLHqWpvXyhmZBDgP1R1VbdEdy20JDzvz7URW3cqid8F9v1rcoVdEznM2qhlgaruATaLyCegqw7/vf7lp4BP+ccXkPrfxSrgP+LaeR3v05uB0hTveQz4kl8+KCKjcf+cGv1FNxM4qY+8vw68CHwnLvk7wGOq+jbwFnCMiBSIyBhgrl8mdjHv8KVg59G33vYllp+Ux1JEjlDVZ1R1CbAD9+/PjDyJn6NVwJdEJAQgIkeJSEmS9/V2bXTG3p9gNa5dZVBEJgJzcBMwG5NL7JoYQixQy54LgM+LyMu4UqqzffplwGdF5BXgQuArKd5/HRACXhGRV9nfuP8JXKD0UqzRZpyv4Kof/4GrYpwFPATk+e1dB6xJI++fAypF5HUR2Y67WL8IoKq1uLZ4rwC/wwV1qOpu4Je4dmP3As+lsZ3e9iVeqmP5A9949VXcl8XLaWzTDD+vAGFxnUq+BtwCvAa84D8by0n+T763a2MF7tr7XcJ7/uy39zLwOPANVd2a0b0x5uDZNTGEiG/sZ8wBEZGjgQdwxeYPZDs/xhhjzHBigZoxxhhjTI6yqk9jjDHGmBxlgZoxxhhjTI6yQM0YY4wxJkdZoAaIyGEislf6nsvsYLZxq4j811Bbd67z05hUpXitSkTqMrSdahFZlIl1mczw3f33ip9mzRhjhqMRFaiJyJsi0ua/3GO3Kar6tqqOio36n+xHWURU3DyXmc7TySLSIiI9xgsTN4fnlzO9zYMlbl62zyVJ/4qIrE3xnvhjv9UHl6MONi+qOktVqw92PUNJwuc3mvCZvmAQtl8nIu0iUpaQ/g9/nVSksY48v+y0fmz3SfHzxoKbXcNft2/3I/v94re5Q9zcs1kjIr8VN0h0zog7hy3+s1cnbk7HtH5XRGSeiLw5wNk0ZsgbUYGa91H/5R67vZPNzKjq00Adbj60LiLybuAY4I5s5KsPK/FTUSW40L+WykdVdRRwHHA88K0ByNuwF//5xc2bF/+ZThzDCBEZiNG+32L/wMyIyL8AWQ1mMk1EjsBN6RbEzW5hkpvlP4un4b4DFmY5P8YMKyMxUOtBRKb5f4Z5IvI94APAz/y/xJ+JyGq/6Ms+7ZP+fWf5wVh3i8hTInJs3DqPF5EXRKRZRO6k92k2kgU+FwF/i015JCJ/8iVRTSKyWkRmpdiXi0XkyYS0rtJAcTMG/FBE3haRbSLyCxEp8q9NEJG/+v3ZJSL/m+Lf8e3AKSJyeNw23oWbRqrPwNIPdrgKF7DF3n9A+fIldfP84yJfUtcoIq/h5pNLehz8864qYxEp89vY7t//11QlQyJypIj83Z+LHf785gwR+S8RuVNE7hCRZuAzIhIQkW+LyBs+z3+ILxETkfeLyBp/jF8SkTl9bOZ2un9mLwJuS8hHtxIwEVkkbsoZcAMQA6zz19S5IjJeRB6IOwd/EZFD/XuvxwVNv/DL/zixVE5ExvqSp+3+c/Etka6ZOxb5c/Yjv4+bRORDfezjQtzMILeTEHyISLFf19tx12SBf22OP5ZNIlIrIhf69EIRucGnbRORn4ubWq2rdElElojIThHZLCKf8q/9H+CTwLf9vv/Zp3/H70ezuCYACxKOdcr99cf6VhHZ4o/13XGvLRA3EOpufw7f3cdxAkBVN+JmVom/rheJyHqfxzfE11SIm7XkL0Cs2cleESnv63NqzEhkgVoCVf1P4H+BL/sSii+rauxH670+7U5xJQi/BhYD43EjOd8vLuDIx42+fztu8vE/kVBiluB24APi29qIC0I+Tfcfvgdxk9+W4+bU7FFykqbrgaNwX6ZHAocCS/xrl+NK9yYCk4Bvk2QCdj+J7hO4f88xFwEPqOqOvjLgA6AzgdczmS/gu8AR/nY6/ftnHwB+AxyOm6+0DfhZimWvAx4GyoAK4Kf92M5g+Rjwe9yUL3cCX8eVCs3B5bkFuBFARKYC9+OO3zjgKuAeERnfy/qfBCaKSKW4ErtP0L/PZOyamuWvqbtx5+CXuON/ONAJ/ARAVb8JPA180S//1STr/DlQDMzAle58nu7B5L/hZsYYD/wI+FWqzPkA70K/T78DPiwiE+IW+RHuj8m/4o7Zt4GoiEwH/gbc4LdzvN8mwA+B6f59lbgJqP8zbp0VuGl9pvi8/1pEjlTVn+PO4X/7fY9NiL0ReD/uHH8P+L2ITEpzf3+PKwE9BndN/cTv9wm4c7DIv+/XwH2SRtWvuD9r76f7db0N97kbDXwB+KmIHKuqTcBHgbfjSoMb6OVzasyIpaoj5ga8CewFdvvbvT59Gu6HP88/rwYWJbxXgSPjnt8MXJewzD+BU3FfMu/gBxT2rz0F/FcveXsU+LZ/PB83N2UoxbJjfX7G+Oe3xtYNXAw8R4st+gAAIABJREFUmSzvuMlxW4Aj4l47GdjsHy8F7ovfz17y+xngn/5xAFcF97E0jn2zz89jwFj/2gHny693nn+8CTgj7rVLgLpezmHXcUuy3uNwc9rFnnd9JnAB9AqgIkc+0/MS0v4LeDwhrQY4Ne75VNyEyAFcsPCbhOUfAy5Isc06oAq4Bhe0noX7I1Hoj3GFX+5J4OK49y0Cqv3jPL/stF72bTawPe554vq61oGbTi0MHBX3+qXAo3Hb3hD32mj/3gkptl0FdADj/PPXcbNvgKsK3YcLMhPfdzXwpyTpAaAdODwu7QNAjX88z2+vOO71e4Bv+ce/Ba7p47PwKvCRvvbXn/sw/vsjYR2/BL6bkPYG8P4ky8aO/x7c9as+n/m95PGvwKVx+/xmup/TbF9rdrNbtm4jsUTtHFUd62/nHMR6Dgcu99UDu0VkN+5LZYq/1atqfKnPW32sL77680Lg96raCV2925b56oA9uB9ncF+6/TERV+LwfFyeH/LpAD/A/SA97KtKruplXfcAk0XkJNyPWjGuJKE356hqqV9+Zlz+M5WvKUBt3PO+jnkXX5W1XETe8sd4NTBWkvcE/gYuuHzWVzn16FiRA2oTnh8G/CXu+P4D98Najvssn5/wWT4Jdzx7cxtuntWFJFR7HggRKRGRW3x14h7cvIDpfsbLcQFU/Dl/C1cyGxM/v2Crv0/VoWUh8KCq7vLPf8/+EtpJuNKoN5K8b2qK9EOAAlzzidgx/qvPd8xOVW2Ne/4WvZwDcc0c4tcXf01B6v2dCuxQV6qV6HDgmwmfhcl0P46JjsWVBH4a9werOC6PZ4nIM+KaLOwGPkTv57S3z6kxI9JIDNTSkc68WrXA9+KCvrGqWqyqdwBbgEN99UlMX0MI3OPf80Hg43T/4fs0bqLxebhqjmk+PX79MS10/6I8JO61HbgqvVlxeR6jriEwqtqsqper6gxctcTXRWRussz6H5S7cMHlhcAfVLWjj32MvffvuNKsH2Y4X1twP0Ixice8lbhjg/vxjLkcOBr4V1Udzf6quR7HWFW3quoXVHUKrur75zIAPYIPUuJnuA6Yn/B5LVTXXrAWV6IW/1qJqv6g1w2obsKVHM/HVfUn6vZZpPvxTnaNfQNXNXiiPwen9bFP8RqACC7QiDkMqO/lPUmJSAlwHjBXXLvQrcB/AO8T1zZ0G67064gkb69NkR57z9EJn/ExccuMF98uMy7/sc5O3fZdRGbgSvW/BIxX1bHABpJ/JyTL4wQRGZ3itWuTfK/9sbcVqmrUf/etBb7j81iE+474PjDJ5/HhuDwmO5+9fU6NGZEsUEtuG66dS29pvwS+KCL/Kk6JiHxE3DAbT+OqFi4T1+D548CJvW1QVVtwX2q/Ad5S1fhhLkpxxf87cT98/93Lql4GZonIceIaKl8Tt42oz/ePRKQcQEQOFZHT/eOzxDWUF1x1RsTfUlmJa+R8Lr339kzmx8B8ETkug/n6I/AtcR0DKnA/rvFeAj7tSyjPwFVTx5TigsXdIjIO114rKRH5hOzvaNCI+8Hp7Tjlgl8A/x3XDrJc9jc+vx34mIjM98emUEQ+KCJ9laiBq2qfq6ptSV57CThXXCePo4Cukkd1Q+HspPs1VYoLpht9+7gldJfsuoytrxN3/fy3iIzybcW+hquK66+P4663mbgq8OOAd+Gu64t83m8Ffiwih/hj9n4RCfntnSGuc0SeuI4w7/XvucW/Z6L/zqiQ7h0aAsA1IpIvbmzAM/0+Jdv3UbjP3XZck7pFPr99UtVaXFOLm8R1wAjJ/s4jK4BLReQEn8dRIvJRH7ym4/u478WJuBLEfJ/HiIicBcT/wdqGCxjjhybq7XNqzIhkgVpyPwHOE9cbKtaQ9RpgpS+S/3cfSH0B1+C8EVc1dzGAL1n6uH/eiAtm7kljuytxJQKJ1Ui34apB6oHXgDWpVqCu59VS3BdxDa5dT7xv+ryu8dVLj+JKksA1cH4U15bsaeDn2vsYZauBJlw173N97FtiPrf7/bo6g/m6FnecNuP+ud+e8PpXcCVyu3FVdvGlQD8GinCle2twVa+pnAA8IyJ7cY3wv6Kqm3vf46y7AbdPj4nrCfoUvlesqr6J63xwNe5H9W1cCWOf3w+q+rqqPp/i5R/igokGXKP0xKDpu7gG8Lv9n5kbcCXGO33+HkxY/sfsr6K9Icn2/g+u1Goz8Hfc9XQgVbILgV+pap0vPd3qS3R+hutBG8QFgeuB54FduD9P4j8HH8V9nnfhOv68x6/3ctzn81ncdfMw7rMdU4crhdzi875IVWv8a7cA7/XfSXep6iu4RvbP+uVnAs/0Yx8/4+834gKm/wBQ1WdwpXQ34767NsYt2ydVfQl3jV6hqrtxx+nPuGNxHq66N7bsq8DdwJv+nJbTy+fUmJFKujejMsYYM9jEDTFzi6pOy3ZejDG5xUrUjDHGGGNylAVqxhhjjDE5yqo+jTHGGGNylJWoGWOMMcbkqIGYrDmrJkyYoNOmTct2Nozp8vzzz+9Q1Yl9Lzkw7JowucauCWP26+t6GHaB2rRp01i7dm3fCxozSEQk7RkSBoJdEybX2DVhzH59XQ9W9WmMMcYYk6MsUDPGGGOMyVEWqBljjDHG5CgL1IwxxhhjcpQFasYYY4wxOcoCNWOMMcaYHGWBmjHGGGNMjrJAzRhjjDEmR1mgZowxxhiTo4bdzATGDJTqDQ0sX72J2sZWppYVs3jODKpmlmc7W8YYY4YxK1EzJg3VGxpYcv86GprbGVsUoqG5nSX3r6N6Q0O2s2aMMWYYs0DNmDQsX72JUFAozs9DxN2HgsLy1ZuynTVjjDHDmAVqxqShtrGVolCwW1pRKEhdY2uWcmSMMWYksEDNmDRMLSumrTPSLa2tM0JFWXGWcmSMMWYksEDNmDQsnjODzojS2hFG1d13RpTFc2ZkO2vGGGOGMQvUjElD1cxyli6YRXlpIU1tnZSXFrJ0wSzr9WmMMWZA2fAcxqSpama5BWbGGGMGlZWoGZNDROTXItIgIq+meF1E5EYReV1EXhGRfxnsPBpjjBk8FqgZk1tuBc7o5fUzgUp/uwS4eRDyZIwxJkuyGqiJyBki8k9fOnBVL8udJyIqIrMHM3/GxFRvaOD8FWs45frHOX/FmgEb6FZVVwO7elnkbOA2ddYAY0Vk8oBkxhhjTNZlLVATkSBwE66E4BjgfBE5JslypcBlwDODm0NjnOoNDVxx18u8WNvItj3tvFjbyBV3vZytWQkOBWrjntf5tG5E5BIRWSsia7dv3z5omTPGGJNZ2SxROxF4XVU3qWoH8AdcaUGi64D/AdoHM3PGxCx7cD27WzvRKARF0Cjsbu1k2YPrs5EdSZKmPRJUV6jqbFWdPXHixEHIljHGmIGQzUCtz5IBETkemKqqf+1tRVZ6YAbS5p2tBAQCAUFECASEgLj0LKgDpsY9rwDeyUZGjDHGDLxsBmq9lgyISAD4EXB5Xyuy0gMzgtwPXOR7f54ENKnqlmxnyhhjzMDI5jhqfZUMlALvBqpFBOAQ4H4RWaCqawctl2bEmzGhhJqGvYgqIqAKUYXKiSUZ35aI3AFUARNEpA74LhACUNVfAA8AHwZeB1qBz2Y8E8YYY3JGNgO154BKEZkO1AOfAj4de1FVm4AJseciUg1cYUGaGWzfPGMmV971Ms3tYcKRKHmBAGXFIb55xsyMb0tVz+/jdQUuzfiGjTHG5KSsVX2qahj4MrAKWA/8UVXXichSEVmQrXwZk6hqZjk/OO+9TJ9QQjAQQIHxJfnZzpYxxpgRIKtTSKnqA7iqnPi0JSmWrRqMPBmTSktHhIqyIopCQdo6Iyy5fx1LwaaVMsYYM2BsZgJj0rB89SZCQaE4Pw8Rdx8KCstXb8p21owxxgxjFqgZk4baxlaKQsFuaUWhIHWNWRmiwxhjzAhhgZoxaZhaVkxbZ6RbWltnhIqy4izlyBhjzEhggZoxaVg8ZwadEaW1I4yqu++MKIvnzMh21owxxgxjFqgZk4aqmeUsXTCL8tJCmto6KS8tZOmCWdaRwBhjzIDKaq9PY4aSqpnlFpgZY4wZVFaiZowxxhiToyxQM8YYY4zJURaoGWOMMcbkKAvUjDHGGGNylAVqxhhjjDE5ygI1Y4wxxpgcZcNzGJOG6g0NLF+9idrGVqaWFbN4zgwbqsMYY8yAsxI1Y/pQvaGBJfevo6G5nbFFIRqa21ly/zqqNzRkO2vGGGOGOQvUjOnD8tWbCAWF4vw8RNx9KCgsX70p21kzZkDt2rWL+fPnU1lZyfz582lsbEy63MqVK6msrKSyspKVK1d2pT///PO85z3v4cgjj+Syyy5DVWMvBUXkERGp8fdlACJygYi84m9Pich7ffpUEXlCRNaLyDoR+UpsRSIyLtm6jBkuLFAzpg+1ja0UhYLd0opCQeoaW7OUI2MGx7Jly5g7dy41NTXMnTuXZcuW9Vhm165dXHvttTzzzDM8++yzXHvttV0B3Ze+9CVWrFhBTU0NNTU1PPTQQ7G3TQYeU9VK4DHgKp++GThVVY8FrgNW+PQwcLmqvgs4CbhURI7xr12VYl3GDAsWqBnTh6llxbR1RrqltXVGqCgrzlKOjBkc9913HwsXLgRg4cKF3HvvvT2WWbVqFfPnz2fcuHGUlZUxf/58HnroIbZs2cKePXs4+eSTEREuuuii+PePBWJFbyuBcwBU9SlVjRXbrQEqfPoWVX3BP24G1gOH+uXOTrYuY4YLC9SM6cPiOTPojCitHWFU3X1nRFk8Z0a2s2bMgNq2bRuTJ08GYPLkyTQ09GyXWV9fz9SpU7ueV1RUUF9fT319PRUVFT3SvTxV3QIuCAOS9cz5PPBgYqKITAOOB57xSZPSWBcicomIrBWRtdu3b+9lr43JLdbr05g+VM0s57y63dzy5GZaOiKU5AdZdMp06/VphoV58+axdevWHunf+9730np/XLuzLiKSMj0dIvJBXKB2SkL6KOBu4Kuquietle3P5wp8Vers2bN7Zs6YHGWBmjF9qN7QwF0v1FNSECQcidLSEeam6jcAuGzeUVnOnTEH59FHH0352qRJk9iyZQuTJ09my5YtlJf3/HNSUVFBdXV11/O6ujqqqqqoqKigrq6uW/qUKVNiT8MiMllVt4jIZKCrqE5EjgVuAc5U1Z1x6SFckPY7Vb0nLgvbUq3LmOHAqj6N6cPy1ZvY297J1qZ9tHZGUYVwNMpN1W/YEB1mWFuwYEFXL86VK1dy9tln91jm9NNP5+GHH6axsZHGxkYefvhhTj/9dCZPnkxpaSlr1qxBVbntttvi378bWOgfLwTuAxCRw4B7gAtVdWNsYXFFcb8C1qvqDQlZuD/ZuowZLixQM6YPNQ3N7GrtBECAqEIkCvvCUZY9uD67mTNmAF111VU88sgjVFZW8sgjj3DVVa5D5dq1a1m0aBEA48aN4+qrr+aEE07ghBNOYMmSJYwbNw6Am2++mUWLFnHkkUdyxBFHcOaZZ8ZWvQWYLyI1wHwg1p10CTAe+LmIvCQia336+4ELgdN8+ksi8mH/2rIU6zJmWJBk7QiGstmzZ+vatWv7XtCYNB17zSr2tIcRIPFqCQbgVxed0Gt7NRF5XlVnD2gme2HXhMk1dk0Ys19f14OVqBnTh1BQkgZpANEoXP/QhsHOkjHGmBHCAjVj+nDUpNGMKUre7yYgsLFhr7VVM8YYMyAsUBtGqjc0cP6KNZxy/eOcv2KNBQ8ZsnjODEYX5ZMf7D60QF5AyAsEbDopY4wxA8YCtWHCJg4fOFUzyznvXw4lGNgfqAUFgiJEUSaVFth0UsYYYwaEjaM2TMRPHA5QnJ9Ha0eY5as35eTArNUbGli+ehO1ja1MLStm8ZwZOZlP2D+O2pSxRdTtaqUjokQUQgJTRheRFxTKSwuznU1jjDHDkAVqw0RtYytji0Ld0nJ14vBY6V8oKN1K/5ZCRoO1TAWDy1dvoiMcYefeMGHfoyAg7pYXFJtOyhhjzICxqs9hYihNHB5f+ifi7jPdziuTVcEbt+1hZ0sH4YgSCgjBgKAKbZ1RyksLWbpgVs6WBhpjjBnaLFAbJobSxOG1ja0UhYLd0jJd+pfJYLAz4orRAgFBRAgFA+QFhdLCPO645CQL0owxxgwYC9SGiaqZ5SxdMIvy0kKa2jpzuqRnMEr/MhkM5ucFQCGqiqJEVUF9ujHGGDOArI3aMFI1szwnA7NEi+fMYMn962jtCFMUCtLWGcl46d/UsmIamtu7OlfAgQeDleWlvLlzL3vawnREouQHA4wuCTFt/KiM5dcYY4xJxooEzKAbjNK/TFYFL54zg1AwyCFjCjl6UimlhXnsaumkpqHZxqszxhgzoKxEzWTFQJf+Vc0sZymurVpdYysVB9HrM7au6x/awIatewhHIT8olOQHM95jVUTOAH4CBIFbVHVZwuuHASuBsX6Zq1T1gYPesDHGmJxkgZoZtjIdDLZ0RMgLBgiIIiJsadrHlLGFXZ0UDnZbIhIEbgLmA3XAcyJyv6q+FrfYd4A/qurNInIM8AAw7aA2bIwxJmdZ1acxaYj1Io1ElYAIARFEYHvzvkz2WD0ReF1VN6lqB/AH4OyEZRQY7R+PAd7JxIaNMcbkJgvUjElDrBdpfjCA+kFvRaAjEs1kj9VDgdq453U+Ld41wGdEpA5XmvYfyVYkIpeIyFoRWbt9+/ZM5M0YY0wWWKB2EGwS9JEjNqRIcX6wKzhr74wikMkeq5IkTROenw/cqqoVwIeB20Wkx3WsqitUdbaqzp44cWIm8maMMSYLLFA7QDYJ+siyeM4Mtu9pZ/vejm6RU0dEOXRMQabawtUBU+OeV9CzavPzwB8BVPVpoBCYkImNG2OMyT0WqB2gwZgGyeSWtnA0afrTmxu58dGNmdjEc0CliEwXkXzgU8D9Ccu8DcwFEJF34QI1q9s0xphhygK1AzQY0yANR0O1unj56k1dbdOSueXJzQe9DVUNA18GVgHrcb0714nIUhFZ4Be7HPiCiLwM3AFcrNpbzowxxgxlI254juoNDSxfvYnaxlamHsTYWpkc+X6kiFUXh4LSrbo4U2OQpdpmJs53bWMrBXkBwh2RHq8JbuiOTPBjoj2QkLYk7vFrwPszsjFjjDE5b0SVqGWyXdlQmgQ9Vwx2dXFG2xFGo7SmCMYCAiX5waSvGWOMMQcjq4GaiJwhIv8UkddF5Kokr39dRF4TkVdE5DEROfxgtpfJQGEoTYKeKwa7uri3892fKtgbH93IO3v29eh+CS5IQ4RFp0wfkH0wxhgzsmWt6jPNUdhfBGaraquIfAn4H+CTB7rN2sZWxhaFuqUdTKAwVCZBzxWDXV2c6nzXNDT3qwr2lic3EwwIeQjhaJRoXMQ2qiCPRadM57J5Rw3IPhhjjBnZslmi1uco7Kr6hKrGoqg1uOEKDlhsLKx41q5s8Ax2dXGq890RjvarZLWlI4KqEo5GUe0+2Nm+cJQHX906ZDpFGGOMGVqyGailMwp7vM8DDyZ7Id1R2K1dWXYNdnVxqvMdCkq/qmDzg0I4ClF1o8/GV4GqKjUNe7nyrpctWDPGGJNx2ez1mc4o7G5Bkc8As4FTk72uqiuAFQCzZ89OOVRB1cxyluLaLtU1tlJxEL0A+yNTPQ+Hg8GsLk51vpev3sTmHXtpbg/TEYmSHwxQWpjH9Amjkq6npCCPts6OFFsRggFobg9nZGJ2Y4wxJl42A7V0RmFHROYB/wmcqqr7Dnajg92uLBtDUpj9kp3vV+p28+ybuwiI6wzQEYmyfW8Hnz5xXI/3V29ooLG1kwCQbLjbzoirRo2o2hh6xhhjMi6bVZ99jsIuIscDy4EFqjok65VsBoPc8/SmXZSX5pMfDBBVyA8GKC/N5+lNu3osGzt/oWDA9fBMoEBnVMkLBKytozHGmIzLWomaqoZFJDYKexD4dWwUdmCtqt4P/AAYBfxJRADeVtUFKVeag+J7Hja3d7K9eR/7whHqGtuo3tBgpWpZUNvYyviSAiaMKuxK0xQlYrWNrUwqLeCdpvZuvT3jqUJpYZ61dTTGGJNxWZ2ZII1R2OcNeqYyqHpDA3vaOtnS1EYoECAcVYIBISCCCFYFmiX9GSYktuyUMUW8tSt51WZA4AfnvdfOozHGmIwbUTMTwODNNRlrm1acHyQgQns4SjiqRKKKApNKC60KNEv60/s3tmxeULpVfYYCUBAMEAoK44pDPYK0bdu28fnPf54zzzwTABE5RkQ+P6A7ZowxZtgZUYFasimFrrjrZc788eqMB26xtk0TSwuZMqaoq4trVJUpY4oYXRSySdyzpD/DhMQvGwoGyA8KBUEBEfKCwviSfConje7xvosvvpjTTz+dd97p6h+zEfjqgO6YMcaYYWdETcoe37AfIBxRdrd2src9zJHlozLaIzO+bdroohDF+UE6I1HUPwcbbDeb+tP7N7bsjY9u5KdPvE5HxDVWE6JEoslL4nbs2MG///u/8/3vfx/oapOZmZnbjTHGjBgjKlBLnFJox959gLIvrPxzWzP5wQCji/IyMh7W1LLibmN1BYDOiCICG7buIRgQRhXkcfVHjjm4nTKDonpDA7eveYtIRBF8b8+I0t6ZPPYqKSlh586d+E4wiMhJQNOgZdgYY8ywMKICtcRG5O3hKJGoG3k3GBDCUWVHcwedkeaD3tbJM8Z1G6urM+LapgXE9TBEJemIvyYz0hlkuD8DES97cD07WzqI4s5hnrhOIZ1RTRrY33DDDSxYsIA33ngDYCZwG/CJgdhXY4wxw9eIaqOW2Ihc1VVhhYIBBPfDi0BHONnQpv2TOFYXQDAAhXlB3jV5DJWTShldFLLOBAMgWVvEJfev69b+sHpDA1fc9TIv1jaybU87L9Y2ckWKaaCqNzRQs31v13mMqhs7Laqu6jNZO8NZs2bx97//naeeegrgTWAWsGEg9tcYY8zwNaICtcRG5AFxwZPgSrmi/pc4P3jwZV21ja3kB/cf3thk3h2R/UHgUOpMMFi9ZTORl/i2iM3tYbY2tfPO7jYu+8OLXcsue3A9u1s70SgERdAo7G7tZNmD63tsb/nqTYQCAQR3Dn1tJuGoK4lN1s7w5JNPJi8vj1mzZgG0q2on8HRGD4Qxxphhb0RVfUL3RuTnr1iTZM7HUMo5H/tjVH6Q17e3EBQhKEIYJRyFgri5wIdKZ4JYCVVnJEJTqxsX7oW3G7m06ggum3dU1zKDMZ9pOlNyxdoi7mnr5J2mNgJ+Ps6WjnDXspt3trpq6UCsDRloVNm8M/mgt6ML89i+t8NNRutL1hQYVdB9oNutW7dSX19PW1sbL774YqzUtlhEqoDcP9nGGGNyyogK1BKDiZNnjKN+dxuHjMmjKBSkrTOScjyt/oo1Io8Vw8TawHVElPVbmsgLuInAh0JnguWrN9EZibBzbycirqo4ElVuqn6DYyvGAgzafKaJPXeL8/No7eg+IXqsLeKOvfsIIAQCQlShMC9wQGPXlRbkUdPUTl5QCPu2hgAFQeGHCQPdrlq1iltvvZW6ujq+/vWvx5IrgK8D3z6onTfGGDPijJhALVlJzF0v1HPevxzK05t2UdfYSkUGS4K2791HMK69W15QunoLim8Ll2JGopxT29hKU6sL0gI+AA0KhH1DeqDP4CmTeYmVlu3Yu6+rJLSptaNrmcVzZrDk/nXsC0cJBlybMlWYWFrQVd08Y0IJNQ17EXU9cVXdcpUTS3psM9aWMYBQkCeoQkSV6RNKeuzfwoULWbhwIXfffTfnnnsuACKycahNfWaMMSY3jJhALVVJzNObdnHHJSdldFvVGxpobg8TBQpCAVRdwBYQKAwFmTHRVa1mOpgZqOrHqWXFbhqshDZ3BXkB6hpbUeg27AkMXPu72LAn2/d2EPWzPHRGInREol1zp1bNLGcpcNkfXqSlI0xhXoCJpQWUFoZo7Qh3BeRX3vUyze1hwpEoeYEAZcUhvnnGzB7b3NsR4dCxhezY20F7ONoVuG3e2ZpyvtZzzz2Xv/3tb6xbtw5gsogsAVDVpRk/KMYYY4atEdOZoLaxlaJQsFtaJoKJZA3bl6/eRFmxC1zUD/+huBKbCaMKMrr9+Hz01dPxQC2eM4O8gKvujHW6iKKUFuZRUVbM1LJi2hLGExuo9neL58xge/O+rqm4YqJR5fqH9neqrJpZzo2fOp5DxxZzyJhCRhXkdZsqqmpmOT84770cf1gZk8cUcfxhZSnn65xaVkxeMMCEUQUEBEKBAHkBV0Ka6hh/8Ytf5M477+SnP/1pLOkTwOGZPBbGDLRdu3Yxf/58KisrmT9/Po2NjUmXW7lyJZWVlVRWVrJy5cqu9Oeff573vOc9HHnkkVx22WVdf3KAoIg8IiI1/r4MQEQuEJFX/O0pEXmvT58qIk+IyHoRWSciX4mtSESuEZF6EXnJ3z48UMfDmGwYMYHaQAQTqYKjmoZmJowqYMqYIvKCQkSVgKvt7JqVIBPbjxdfYiji7jM1l2jVzHIurTqCgLh2drGpk/LzgiyeM6Nfc2dmQiRJnbEIbNrR0iPfvU0VVTWznDsuOYn//eZp3HHJSSlLH2P7t625HQE6I1E6Ikp7OEpdYyvf+fMrPd7z1FNPcdttt1FWVgawBTgZmHpQO27MIFu2bBlz586lpqaGuXPnsmzZsh7L7Nq1i2uvvZZnnnmGZ599lmuvvbYroPvSl77EihUrqKmpoaamhoceeij2tsnAY6paCTwGXOXTNwOnquqxwHXACp8eBi5X1XcBJwGXikh8A98fqepx/vZAZo+CMdk1YgK1+GBiT1sHNQ3NvLmzld2tHQdc6rR89SY6whG2NrXzz23NbG1qpyMcoSMcpa0zwuiiEDMmjmLmIaOZNLqAUF5gwIKZgSoxjLls3lEs/8z7OGHaOMaV5DN9wqiuoKc/c2cerFSBZyTF0HfpBmO9ie0Pm6pGAAAgAElEQVRf2Ado8ZuKKtQ17ePGRzd2e09RUREAxcXFACGgE5je740bk0X33XcfCxcuBFz7y3vvvbfHMqtWrWL+/PmMGzeOsrIy5s+fz0MPPcSWLVvYs2cPJ598MiLCRRddFP/+sUCs6G0lcA6Aqj6lqrFiuzW4jjio6hZVfcE/bgbWA4cOyE4bk2NGTBu1WLulZQ+u582dbYQCASrGFtIRiR5wD8WN2/awpz3shn8Q1yNwZ0sHhXnSFRTGepOGgkEurTpsQDouQM9ZFyDz1Y+9zY/Zn7kzD8bGbXuSpiswfXzPfc1Eu73qDQ0se3A9vY2DfMuTm7uGKgE466yz2L17N1deeSXnnXfeMbhBb2/p14aNybJt27YxefJkACZPnkxDQ88/tfX19Uydur+wuKKigvr6eurr66moqOiR7uWp6hZwQZiIJLsoPw88mJgoItOA44Fn4pK/LCIXAWtxJW896mhF5BLgEoDDDjss9U4bk2NGTKAGLphYvnoT06LaLaA50Eb9nb4OLjYWV1SVzogSjiqHjg0gIjS1dXYLyi7L3O50E+vpGB8cDmT1Y7Z0Rlw1cjRJ9edVZ76r2/N0xlzrS2wd7+xuS7lMKAAtHd2r1a+++mqAWM/PV4DTVNXm+jQ5Z968eWzdurVH+ve+97203h/X7qyLiKRMT4eIfBAXqJ2SkD4KuBv4qqrG/rXdjKsmVX//f4HPJcnnCnxV6uzZs4dKp3tjRlagBj0nZgcIR6K88HYjp1z/eL9LXTojSmck0tVhAOiaA7IzEuW6s989KCVNsRLD5as3DUiJXa7IzwsQ7BACokT9kBoCjCoI9tjXdMZc60tsDLlwssgwRoSShGrnBAqcKCLfUNX5aW3YmEHy6KOPpnxt0qRJbNmyhcmTJ7NlyxbKy3teNxUVFVRXV3c9r6uro6qqioqKCurq6rqlT5kyJfY0LCKTfWnaZKCrqE5EjsWVPp+pqjvj0kO4IO13qnpPLF1Vt8Ut80vgr2nvvDFDwIhpoxaT2Kmgub2T+t3tiNCv3pLVGxq6xukKxI2JFhQ3sGomG/OnKxPtsXJdZXkpE0rzKcgLEgwIJflBDhlTwLsPHdtj2drGVsKRKJu272XD1j1s2r6XcCTar3Z7sTHkehOJKotOcc3PHn/8cY466ihGjRrFZz7zGV577TWAdwHLcP/8jRkyFixY0NWLc+XKlZx99tk9ljn99NN5+OGHaWxspLGxkYcffpjTTz+dyZMnU1paypo1a1BVbrvttvj37wYW+scLgfsAROQw4B7gQlXtavgprijuV8B6Vb0hfvs+0Iv5GPBqBnbdmJwxogK16g0NNLbs482dLdRsa2ZPWwdbm9oBmFRa2K/ekrEhOAIihAL7D2P8EBxDaS7PoWLxnBmEgkEOGVPI0ZNKOWRMIaFgMGkV76j8IPW72wlHtKsNYf3udkryey396sYF9r00TgNK8oNdMzRcfvnlrFixgp07d3Leeedx0kknAexU1ffFlwIYMxRcddVVPPLII1RWVvLII49w1VWuc+batWtZtGgRAOPGjePqq6/mhBNO4IQTTmDJkiWMGzcOgJtvvplFixZx5JFHcsQRR3DmmWfGVr0FmC8iNcB83B8ZgCXAeODnfqiNtT79/cCFwGlJhuH4HxH5h4i8AnwQ+NoAHhJjBt2IqfqMb69UMbaIbc37qNvthls4dGxht2Ez0gmwahtbmTCqgIK8oB8h36WL7B+CI1lj/sGaE3O46k8Vb+I0XgBo+u1kwAWGazbvTDmNxLTxxQQD0lWdKiJUVVUBcM455zBx4kSam5uzN4O9MQdh/PjxPPbYYz3SZ8+ezS237O8b87nPfY7Pfa5HszBmz57Nq68mLeCKqOrcxERVXQQsSpL+JPuv4sTXLuxlF4wZ8kZMoJbYXml0UT6tHWG2N+8jL9i9YDGd3pKxXpaji0KMLgrR3N5JXWMbeUHXiDZZY/5MNG436fcwbd4X7ppRIDbV1CGjC9i7L9yvbZUW5LGnved7AgKlhSFUtSuw3717N/fcs7/gzDeoHisiH/fPrVTNGGNM2kZMoJasE0FRKEh+XqDHUBrp9JZM7GUZDAhlxSHGl+T36OkZs+zB9TQ0txOJKvl+pPtYNWsmAjUrreuutCCPzTtaiKg73hNLCwgGhPLSwn6tZ9aUMby5cy972sK0+qLTvKCQ7wP8+MD+1FNP5S9/+UvXe0899VQ2b948FvgorlzOAjVjjDFpGzGBWqpxxirLS1k8Z0a/e0smq4K7+iPHpHxf9YYGarbvJSj7x1x7p6mNKWMKM9KOzUrruqve0MD2vfsIR91wHp2RKHWNbZQVh7j6I8f0vYI4saD8kDF5hCNR6ne3owoTRuX3GLj4N7/5TY/333rrrW+q6mczsmPGGGNGlF4DNRFpJnnrHAFUVUcPSK4GQG/jjB3oYK39ed/y1ZsIBQIoro2UCBCFbc37OH5qWb+3nXT9BzkURV+GUond8tWbGFMUoiQ/z7chjHZNfdXfPCcG5UdOLEFE2LsvTHlpYU4fB2OMMUNbr4GaqpYOVkYGWrbHGattbGXS6AK2NO0jiiICihKOkJFBaVNV7WZ60vehUmIXOx6SL12dO1SVprbeh9pIJRaUD6Vg1RhjzNDXr6pPP81HVwMfVX074zkaQIM1zVEysarXKWML2d7sSniCIhwxsSQjeRroKaQOpn1dNoKbgTge1Rsa+MqdL7KnLYwC9Y1tvLaliZ988ngL1owxxgyItMZRE5EFfrybzcDfcfMW9piDzaQWmxQ+GBCmTyjhsHHFlI8u5JtnzMzo+gdi0vdY+7poVLu1r0tn8NhYSVxDc3u/BhQ+WANxPK7400s0+SANXJuAprYwV9/Xc/iB1tZWrrvuOr7whS8AICKVInJWX9sQkTNE5J8i8rqIXJVimX8XkddEZJ2I/P6Ad8gYY0zOS3fA2+uAk4CNqjodmAv8vwHL1TBUNbOcpQtmUV5aSFNbJ+WlhSxdMCtjJTEDuf5Y+zrXtk4IBIQAwrbmfX2WUMW3nevPgMIHK9PHo3pDAztakleb1jb2nAf0s5/9LAUFBTz99NOxpDrgv3rbhogEgZuAM4FjgPNF5JiEZSqBbwHvV9VZwFf7tyfGGGOGknSrPjtVdaeIBEQkoKpPiMj1A5qzYWigq14Hav0H074u03Or9kcmj0dfgWX1hoZu23rjjTe48847ueOOOwBQ1Tbpe6TdE4HXVXUTgIj8ATgbeC1umS8AN6lqo1+vDaZrjDHDWLolartFZBSwGvidiPwESH/U0BxXvaGB81es4ZTrH+f8FWsGvFpuqJlaVkxeMMCUsYXkBYRIVAmIcFT5qD4DoVRzq6oqjS0dPPfmLhb/9nlufHRjL2vJvpqG5l5fTwzk8vPzaWtr65oFQUSOAPb1sZlDgdq453U+Ld5RwFEi8v9EZI2InJFsRSJyiYisFZG127dv72OzxhhjclW6JWpnA+24OdQuAMYASwcqU4Ppxkc3clP1G0SiSkFegHAkelC9GbPZK/DGRzdyy5ObaemIUJIfZNEp07ls3lEHvd7Y0CahoGtfFxvaJJ32dYnDomxtckFaWEFQF/ipclP1GxxbMXZQOyb0Z10d4d7n+6zZtgdwE7S3d0a44lvf4bT5H+Lt2lqA6cBjwMV9ZClZiVvi8Dh5QCVQBVQA/ysi71bV3d3epLoCWAEwe/bsFBNgGWOMyXVpBWqq2hL3dOUA5WXQVW9o4KbqN4iqCxjCEWVnSwfjS/IPaPyxbA5hceOjG/nJ468TEMgLuB6OP3n8dYCDDtbSHdokVeAT/14F8gJu8s1AwMUlQT8gbV/HPHZ8O8IRmtvDbG1q54W3G7m06oiU+5gqT/09V1FNHagFBNrDUWp3tdIZccsdd9IcfvarWfzzHy9ywSc+tgs4WVV39HKYwZWgTY17XgG8k2SZNaraCWwWkX/iArfn+li3McaYISitQC1h4Nt8IAS0DKUBb2Pif7j3tHXSGYmSnxdA2D8IbXN7OO3xxxLXV5wfZEyRG8FkIAadTeWWJzf7IM3VZgcEwtEotzy5OSOlan219+or8Im99/wVa3juzV3kxVW6q0JBMNDnMV++ehMd4Qg7WzoIIH2WxvWWp/4OECyIG+U5Sb4CQCgY6ArSAFb97X7+7QOn8qEzzgRoAsIico6q3tvLLj4HVIrIdKAe+BTw6YRl7gXOB24VkQm4qtCB7ZlhjDEma9Jqo6aqpao62t8KgXOBnw1s1jIvcaiI1o4IUYVwZP/PrwjsC0fTGm/rxkc3svi3z/Pcm7tobOmguT3MzpYO9vhBVfe0dbK1qZ1n39w14G3fWjoiBBIqzgLi0gdDur07F8+ZQdAHWIoSVUUVxhSH+jzmtY2tNLeHCfjSOBEhGBDC0WjSxv695am2sZWiULDb8rEBgsORKC37wuxq6WBLUxtv7WwhLxggmKIrQFlJiMPHlXRL++kPl1E6ekzXc181+d3e9k9Vw8CXgVXAeuCPqrpORJaKyAK/2Cpgp4i8BjwBXKmqO3tbrzHGmKHrgOb6VNV7U43xlMsSS1EK8gJoOEIkqgQDrjdjRN1YZ331ZkxWbQqujdKOva7N+DtNbtiGgqAMeDVoSb6bFis+WIuqSx8M6c6MUDWznEurjuCm6jfojEQpCAYYUxIiFAz2ecynlhWztandV506vZXG1TQ007ovTGd0/6TsowryqPPVoA3N7RSGgqjSNdbahFEFvL2r57oOH1dC/e4Wdrd20plQCxqOwqdOmNotLRpNWlXa5/Wmqg8ADySkLYl7rMDX/c0YY8wwl+6Atx+Pu50nIstIXguU0xJLUSaMKiAgQkD2t5MKiHBp1RF9BlPLV28iHI0iQEckSkckiuKCo33haFewJgjlowsHfPywRadMd6WD0ShRjfp7lz4YEnt3QuqZAC6bdxTLP/M+Tpw2nvGjCpg2flRaY5z1pzSuekMDze0uSHOlbkp9Yxvb97YzaXQhn3hfBa0dEV/9HWHvvjAdEeWTs6cm3fanTphKOOrOb6KOzp6llsccexxXXnE5v334WYB8EfkR8HyvO2iMMcYkSLdE7aNxj8O4mQnOznhuBljitEKji0LsC0do7YgwpijUr/k/axtbyRNhX0RdV724Bkz5wQDt4SgFQReklRa6kqZMzr2ZKNYOLd1en5nundrbpPe96U+0XzWznA+/exL3vryFzogSEBhTlJe0NO7mv7/BmKI8drV0EI0Afuy3XS2dfG1uBccdNpavnFbJH56rZeueNg4ZXcSnTpjKiTPGpdx+ZyRKJEmGWzuj/GDVBk6pnEhdYyu1jW1snfIxmp76A3+99HMARwB/Ay7tx+4aY4wxaff6/OxAZ2QwJAsm8vOCLPv4sf0OUqaWFdOwp31/gv8BF+CwcUWICJt3tFC/u4384D4mlhYQDAgl+UHOX7FmQIbvuGzeUWl1HBiI3qn9mfT+QLdfvaGB599u4pDRBTS1drIvEqVlX4QLT5rM+6aVsXOvm0N1X2eUN3e2MKYoRDiiNLZ2orhzUxySrmDsxBnjeg3MYva0dXLj4zXs3Ze8vZ8CO1s7ue/l/R00A/mFlFVdTElBkNeWnrleVb/V54aMMcaYBL0GaiLyU3op9FDVyzKeowHUn2CiL4vnzODzt+0kLwCRKF2BwIRRIXa0dAAQjrpSn85IlLrGNopDAQpCwf/P3pvHt1Vfef/vcyVZ3hM7iRODHZKAaaDsDRSmlAaSDEvnB+2UFlo6pC0pKVNKZ+Zph3Q68BRafhOmPEOXaYEMXUKZB2hpKZlOG7aSUgYChH0LBJy0ibM4ie14kW1t5/njXimyLFmSbXmJzzsvvaR79b33nnt1ZZ2c7zmfQySuYy7fkUqhFY/5km8ngOEe//Y/vIvPgYpgCdPKSlCFUDjKE2/v5yMnNwwYW19dRktHD119Ufw+t6I3HlfCceXZ5rZBDlo4GmfngV62t/WyvS3EjvZetreH2N4WorMvP23nMxbMoLG2jIaacnxdu3j0vh/RvqcFXIHa3wOo6jl57cwwDMMwyB1R2+Q9fwC39+B93vLHmaT5NqPVVmjxwjqaZlWyrS2EiJusPrMyiN8n7O1yI2gVJX72eVEev0+IxmFWWWDUHaRCyTfxf7yOH48r/dE44aib+xfxHlv391Bd6qezN0JbT5hILI7fEbr7BztSl57ayHXrXkNRHASNe4UHfuEb//U6Ab9Dqd9HbUWAzr4oezr7Muaf5cuCmRXc9NHjkssfXvzXfGr5Fbz/tM/zh8cf2wF8dfh7NwzDMKYqQzpqqroWQEQ+A5ztiWwiIrcDDxfdujFgJLlaFxxfzw82vIt6P/D90RiKj4BPKAv4kBKh2nNIVJU3d3dllYQYTbtykZ6rB9kT/4tB6vHVKwjoCUepqyodIBqbTiJK1hGKgoDjFQl090cHRMlC4SjTygMEHKEvokRTgsI9YXfffdE4XUTZ2z2wq1PQ79BYU05DTVkyOnbrI2/TN0Rngsqgjys/ODBHzuf3c9lnVyQ+/5CqTsr/2BiGYRjjS77FBIcBVUCbt1zprZvUDJUrBQzpKG3Y3Mr9L7RQWxHgQChCXzRGNKR8cfFcnm5uy+gIJSQ0cjlIxe5wMNzE/5Ggql50TLnstLlcv+41treHiMcVxxEqSvx84awjszppMDBKJgrxOMSBMr/w7YfforG2jO1tvez3pp6Hwu8IJX4HR2B6WQl/t7SJhpoyZla5lcAJfvbUtiGdtAUzK7jygwsGTaUu+cvzufvH/8Fff+yjAD4RqfWuQ1uG3RiGYRhGRvJ11FYDL4rI497yh4BvFMWiMSRbrtTN6zfTE44N6Sgltp1WVsrMSrcTQSgc5enmtqyO0Ioz53P/Cy05HaRi5ZAlGM1cvXRUvWnLWJxoTInE3CnMVAesu9+Lcak7HZktC1JV6eiNsL0txPa2XrcFlR7MCUzQE47TEw4PctAcceU0RNzXCRMCDsyf6QrUKkpXX5RTjqgZdPxnm9u4a+Ofhjzf6tJAxvW/+vn/BeBHt30X3LSB570zLZ43bBiGYRxy5Fv1+RMR+R3wfm/VKlXdXTyzxoZsuVJbWrtpqCkb0lEaKs9qKEfohIbpOR2kscghG2muXtSLjkXicSJR73UsPmRELMG9z22nMuhnVmUQgLi6ztLtf3iXt1q73ET+thDb20P0ZKm0TCDgVdP6ueCEOTTUlNNYU8bezn5WP7QZ4u7UalzdsY4MdPL6InHmVJdltTOTHEcqb+w+wM0P9XDtuQsHRNX+sOk1wJWAmVVV+qqqLsp1XQzDMAwjnVxVnwtVdbOInOKt2u49HyYih6nqCyM5uIicB3wX8AF3qurqtPeDwF3A+4D9wCWqum0kx0wlkSsViyt7u9ykf58IsbjmzCXLleeVzRHKx0Ea7xyyBKpKJOZNWXpRsUSkLK6FZd7HVWnt7Gd7e4h393XjCOzvDrv7S8ni/8n/bMu4/czKEhpqygn6Hd7c1UmJ36Ey6CMaU2IKXz6nKeko/eypbdz97J+JeF6WT9yoWnVpgAO9ERxHUJS+iHvs9K4CCXZ19g55Tn4BjbvyHWueeHfQ9Oe7b73Jjq1bAGaIyOUAqnpXPtfLMAzDMCB3RO0fgCuB/5PhPQWGLTUgIj7gB8AyYAfwnIisU9U3UoZdAbSr6lEicilwM3DJcI+ZzsqzFvDV+192dbZUiStEvHjLjvYQjSn9G9MdpcS2Le29RONx/I5DVamf6z587KjYNZY5ZLG4Gw2LxpWo54yFvSiZ5umQ/eypbfz8+R2EwjGCfodFR9RwxMwKLzLWS0tHL+Ehcr3AjXY11VUNSORvrHGfy1JaYT3b3JZVqPbZ5jbufvbPqCoBByJx3KiYQnsoQkXQR11lkK6+aE6R2/rqMvZ09md8D0j2GiWu7OjoZXZ1KT7HbRb/rW/eyB/+8AfeeOMNcPM7/xV4Evc/HoZhGIaRF7mqPq/0ns8uwrFPA95R1WYAEbkXt9tBqqN2EQdz4e4H/l1ERPP1HnKweGEdMypKaA9FBkxxCdDRG6W0q4+ZlcGsjpJ6g0XEU76HV3Z0jLhacyQ5ZNmqRdOdsUhMicZdhyyWpy5FwkHaeSBEbXmQU+fVUFbi4/HNrWzZ25Mc1xeN8+S7+3ny3cG9wh2BmvISuvujBHwO5SUOqu41/PslTbz/yBk57RhKqPbe57YT99pGaSIRzkOBgM/hyrOO5IyjZrjtwxzBl2gj5gh+x8Hnc52tq885khV3ZS/WjMYVEUk+KoIHv06//OUvefnllzn55JNpbW3dBnwYuDPnyRmGYRhGCnnlqInIx4H1qtolIv8MnAJ8U1VfHMGxD+fgVCq4UbX3ZxujqlEROQDMAPal2XclbuSPuXPnFmTE3u7+QY5KQrw2FI5xoDeS0VG644lmppUFqJ92ML9pX3cfP9jwLg01ZSOu1sw3hywRCYzFlQ2bW7nxv9/A7wiVJT52doT4pwde5ctLmjh1fm4F/vT97u8JJyNim7a28dyf2onFlWhcae0Ks3lP15D7cATOe+8cGmrdyFhjTTn100sJ+JyBUbFpuds35YPPEXZ39lLid4jFdMCUKkB5wKGmPMCDL+/k0vfnvk+WHjuHyqBDd3/mSKCCN10OR8+uHPBeWVkZjuPg9/vB7anbihUSGIZhGAWSb9Xndar6CxE5EzgXuAW4ncGOVSFIhnXpoZ18xqCqa4A1AIsWLSoo2haJadIxSxxNvUrBaWUB/nht5tndTAn/B0IRYnFN5pZFY0prVx8r736eU+bWFBRdcx0iN9oVVzzHI05MlWhMvdysgVOTP9zwLoLbazSuEPT7iGuMe57dntVR6w3HPAV+V4k/kci/o713UJP1dAQIBhz6InEcAUfcDgBu21MlFoevnPuejNvm277J8aYXfY6405rP/ImdHb001JRzxZnzWLywDp83RkSYP7OSrfu62d8THnCjCDCrqpTyEn9BRRnHH17D1n3d7Onsz9qiI65w/nFzBqxbtGgRHR0dfP7zn+eqq646FngBeDbvAxuGYRgG+TtqiV/sDwO3qeqDIvKNER57B5Caxd0A7MwyZoeI+IFpHNRyGxbpU4ODSOnZOVTyfqaE//5YnFK/m0vV2Rth54FeBC+RPiW69sGjZyWdsMTDnZJ0pydd56zw2d1dnb1Ulw78SEsDDrsOhGhJtERq72WHFyXb3h5if/fQmmMC1FUHae8JU1bio8TnUOJ3KPE5+Bzo7o/RJVH6ozE3X8sjnqEgIx2/4+A4biTMJ4Lf5+D3ph2T05DePjdsbuXfHn2bgE+orShhf08/N/12M0G/b4Dzm8jvm1FRQmtXf7Lac2ZlCdVlAULhaEFFGYn9BXxCOEsJqN+Bp5vbSO2n9sMf/hCAL3zhC1x11VVvA8tV9ZW8D2wYhmEY5O+otYjIHcBS4GavGtMZ4bGfA5pEZD7QAlwKfCptzDpgOfA0cDHw+5Hkp2USku2PxqkM+ujpj6GKFxlynYihkvfTE/5D4Sg+ESqDPq+KtA/xQnUBn4PfcYjEonznsS3MnTH61ZuqyqyKIK3dfQiSLAjo93LQ/ubHQwdzqkr9ycR9N5nfna48fHoZwYCPf7jvZfb39A9wvnojMeZUl3H+e6exduOfIB5HhKQcxqdOa6Sy1J+MePkc8a6F65QVQr7acqn5fdG4K/tRUx5gZmWQUDhacFHG4oV1XLyjg+8//k7G9wOOG0JMj9ItWbKExx57LLEYVtVXROQxVV1SyHkbhmEYU5t8HbVPAOcBt6hqh4jUM8LehV7O2dXAQ7jyHD9W1ddF5EZgk6quA34E/ExE3sGNpF06kmNm+rGvKQ/QHoowZ1qQA6EI/TG3gvOC42Zz+x/e5eu/fpWG6eV89gPzOOOomUS9iNd76qu45pyj+OHj7/CWl6s1o6KE/micrr4I4VjcnUlVNwKkqgT9DrsPDC35kItwNM6O9tSm4a4Q7Pb2XrpyNA/3O8Lh08sGOGINNeU01pYxrSzgFkVk4dJTG/nu77fQG4lRGnDoj8aJK1xx5jw+tLCOylI/P31qGz3hGJVBPyvOnM81S48e0bmmkphq7uqLJKVUAo5woDcyaGxqfl8igjoSYd+nm9uYW1tOS3vvoC4FkbjidyQZpevr6yMUCrFv3z7a29sTU9M+EZnHIdDNwzAMwxhb8hW8DYlIK3AmsAWIes8jQlV/C/w2bd31Ka/7cBvAjwqJH/tEUE4Vd0orGmfXAVeGodTv8KGjZ7Bxazt+Rygv8bHzQC83/OaNAVpd4Oag9UbjzKkupTTg0N4TpqsvQldvhKi6Oluzp7nN2WFocdVU3KnS/uQUZaoAbOsQuVIJAo6bK1ZVGuD0+bV8oGkmjTXlzJlWOmB6Mhci7jRk0O9w3vFzmF4e4CdPbUvmiKU6Pf/r3IX8r3MX5r3vQmmsKWfb/m72d0cQr0Iz4kXMNmxuzep8jVTYFw7eN7OrS/lzW2jQ9Y/GlTnVJQDccccdfOc732Hnzp2cckpCfpBjgQdx5WgMwzAMI2/yrfr838Ai4D3AT4AAcDfwgeKZNjxU3RZFMS/ZPpkHpsqsyiD7e/qTeWTd/VF2H+hzZRu8mbhILM5jm/dSUx7AER872nuJxOI4Iqz5Y/MAR+3e57bjd9wG7N39UTq86I7fJ9SU+tnfE6E/EqO8xJdRXLW7P5qsqtyRktDf0t5Lfw7NsbKAj4aa1OhYuac9VjYgby4fklOSPknmoPkdh4BPBkTZzju+nvOOry9o36PFyrMWsPLu51EUB0G9y1NTHsjaWmu0Gts31pSzdV+3q7eXZcxjm/cC8OUvf5kvf/nLfP/73+dLX/oSACJinQkMwzCMYZHvL/pHgZNxK9dQ1Z0iUlU0q0ZATJXWzr6M712yyJ2+U3Wn7/b19BPHTQZ3HM9TiyuRuNIRigBREFwl+7iybX8Pzza3JZ211FpYdgEAACAASURBVOT99lAYQRDHjbDUlLvtkdwWSGGqSks47rAqntiyl/989s/saA/RHho8bZeKIzBnWmlS+DUxXdlYW86MipIhpyoz789tRJ58+BwCPqegKNtQFOIYFepELV5YR2XQdXjDsTglPoeZlaVUlWau4hzNxvZnLKjl2W1tWfXmRKAnPLBCdsWKFfzbv/0bTz75JMCRIvJ3wO1elNgwDMMw8iJfRy2sqioirsarSEWuDSYipy2o5cs0seaPzWzbH0q2GEp1UxK+TyQOAZ/r3IBbDOr3uVG0hKNWX13mRegcwlE3kT4ec/fR0tHrtl6KKaFInH09Ebbu7yET08oCSQeswdMba6wt47DpZQQKTLpPEPA5BFOcsoDnlI2EoZyrbI7RxTs6eLq5bcA2wLCcqKNnV/PmrgP0RpSeWIze9hDVpX6OqZ82aOxoNrZ/urmN6lIf7aHMOYCqUBEcWOG6fPlyqqqq+NKXvsQDDzzQijv9+TNGcSrfMAzDOPTJ11H7uVf1OV1EPg98jkmqsv7W7k62t4eIx9XT+/KcMtSNnHm5ZVEF1NVYU3V1wWaUl7C9vYffb271ojjKzgN9ByMtiYCLQjQtwhLwCY1pFZWJRP6q0oF6bIWQmLZMjZIF/U7B0bZc5IpQZXKM9nZlFgAuDzjDcqLmVJfwdPNBZymubgeJRH5YKrka2xcS0Xt7Tyfd/bHk/ZKJFWfOH7D81ltv8fLLLycWu1T1ShF5edCGhmEYhjEE+RYT3CIiy4BO3Dy161X1kaJaVgSebW7jZ8/8iUzpX5G4EvBEWitL/TgoXeEY8Zgmo2y7O13NsW/995tDHqfE7+Z6OSJcfEoDS4+dTV11MBmdGy4+x526DPp9yWjZSKNk+ZIrQpXJMerqixKNxwdts3V/iKa6NCX/tKb3mXhs8158juc4e6LEIgfzw1IZqrF9odOiicirI5BJSu2M+TWDKlxPPvlkNm7cyOmnnw6AiLwf+J8hT9AwDMMw0sg769xzzB4Bt6G6iFymqv9ZNMuKwJo/Nmd00hJEvPc602Qu0pXbKoI+GmvK2dPpRtMqSvyU+IT+WJy2UBhVOGpW1YjaIokknDL3URrwjZlTlolcEaqMAsDROME0mxM6bL2RWEYnaih6wjH8juDIwX3GNT4oPwyGbmxf6LRoid+hNxwjU4qaT9yoXjrPPPMMd911V6Kl2fG4WoBvisirgKrqCUOerGEYhmGQw1ETkWrgi7g9N9fhOmpfxNVQewmY0I5aOBqnpcNrjdTWy9Z9mXPEMuFzhNryEvqjMWJxpbaihAuOq+cvj5vNdE9z7JP/sZHqUj/iZbkFAz6qSv109UX5t0tOLOhY6VGyEv/4OWWZGCpCBZkdI58jTCsf6Nz1RmIsmFlBTziW0YkaiooSd2xq7UNc3fXpJIRqb/9DM6FIDBE4fFopkNvpTGdmRQmdvYMrPhON3Jsz3Ffr169Pvp43b95bwP835MkZhmEYRgZyRdR+BrTjRgNW4DpoJcBFqvpSkW0bFnsO9HHtL19hR3tvUnojH0r8DjMrSlh2zGyWHFtH/bSynNWQiWKCVLX+XFpp6U5Z0O8UrNI/Hqw8awFfvf9lWtp7icZdUeCqUj/XffhYYGBHgIS47EUnHsb9L7QMcsiu+7Crt1aoEO2KM+fz3d+/QzTu9haNex0Q0vPDNmxu5eb1m3lrT1cyCqYKOzr6uOaeFzhselneEb0Nm1vZ3xPOGE3zOw7ZstaOOOIInnzySbZs2QIQBnqAKlXdOuRJGsYEoq2tjUsuuYRt27Yxb948fv7zn1NTUzNo3Nq1a/nWt74FwD//8z+zfPlyAJ5//nk+85nP0NvbywUXXMB3v/vdRP6sT0QeAeYB24BPqGq7iFwGXOvtthu4SlVfFpFS4AkgiPu7db+q/m8Ar7vNvUAtrjLB36jq0L3xDGMSkctRW6CqxwOIyJ3APmCuqnYV3bJh0hYK89y29gHrSv0ODbXlvNvanb2xdjzOvp5+1r2yk2Pqq/PqB5mu1p+ulZaYvizxOQQDDqV+34SLlBWCW/Lrnhcy2EXJJC57QsP0rA5ZodWXiTywO5/cSk84RkWJb1AHhET+WWtnX0bnqqs/Rk84hojkFdG744lmqssCVAT9bNs/MOImuDlrR80cfK/ccMMNbNq0ibfeeiuxqoQJqj1oGNlYvXo1S5YsYdWqVaxevZrVq1dz8803DxjT1taWvN9FhPe9731ceOGF1NTUcNVVV7FmzRpOP/10LrjgAtavX8/5558PUA/cp6qrRWQVsArXQdsKfMhz2s4H1gDvB/qBc1S1W0QCwJMi8jtV3QjcDNyqqveKyO3AFcBtY3SJDKPo5HLUkkJfqhoTka0T2UkDqAz6+etTDnflLmrKaawtZ2alqzm2Yu2mjNNU4MpwaNxtpr7miXfzyi1LyH3c+9x2dnf2ctj0MpafMY+zj6lzI2a+0a++HC/ueKKZaWUB6qcdjBbmU6k5Gp0BUrlm6dFJ5297e4inm9s4IaUzQSL/LJalJawCrV393PHp9+UV0UtMk4oI82aUs70tRFzd/YgD04MBVp1/zKDtHnjgAV588cVkd4KJrD1oGNl48MEH2bBhA+BKzixevHiQo/bQQw+xbNkyamvdv5nLli1j/fr1LF68mM7OTs444wwALr/8cn79618nHLXpwFpvF2uBDcC1qvpUyq43Ag3gJnXiRtjAFVwPACruH9hzONgnei3wDcxRMw4hcjlqJ4pIp/dagDJvWXC/O9VFtW4YNNaWc/XZR2V870NNM9m6r2dQJEhwo0QiQFzZ3pG7H2fAi5Kdf0I9Hznl8KJIYkwkCs3rSiWTFAYwrK4BuSo2E3aW+BwiscFFBolPKF8HMjU3z2055tDnaebNqy1n1fnHZC5AKCnx7in3iJNVe9CY2uzZs4f6ercbSX19Pa2trYPGtLS00Nh4sONKQ0MDLS0ttLS00NDQMGi9h19VdwGo6i4RyfRlvAL4XWJBRHzA88BRwA9U9RkRmQl0qGqiomcHbk71IETkSuBKIFHkYxiTgiEdNVUdnKU9iXlx+wFmVAToCceIxOJDVoCm4ndcpyyYIo3hjJKa/2QhVzFBNjI5Vl+5/2UEqC4LFNw1IFfFZsLOWVVBQvsH9+UUYP6M3NPaCRJFEnu7+tjf46a9BBxhZlUJoUj2G+gTn/gEK1eupKOjA2Am8CjwH3kf2DDGiKVLl7J79+5B62+66aa8ttcM0WsRybo+H0TkbFxH7cyU48SAk0RkOvCAiBwH7MlkUhY71+BOpbJo0aJ805cNY9yZvAlTw2BXZy81FSU01pSzYGYlJb6DXQf6o3H6o3FicTiitpxpZQHe2t3F1371Kp+6cyN/d+9LvPTnDspKfFPOSQPXYYnElFA4iqr7nE+lZqpjJeI+d/dH6eqLJl/vPtBHS0eIa+59kQ2bB/+PPZXt7aEBxRswMLKXsNPnCLMqBwrhBhyorSzJOFWZjcUL67jxwvcSCseIq1Liczi8poyZlaUEfMIdTzRn3O4rX/kKF198MR/72McASnG1B7+f94ENY4x49NFHee211wY9LrroImbPns2uXbsA2LVrF3V1g/8j1dDQwPbt25PLO3bs4LDDDqOhoYEdO3YMWu8RFZF6AO85+cUXkRNwBdUvUtX96cdT1Q7cqdLzcPOmp4tI4n+QDcDO4V4Lw5iITClHrb66jL6UKEhV6eCAYhw4/vBqXt1xgH/53Wb+tL+H9p4wz21rY+Xdz/O9R98eQ4snDgmHpa6qlAO9EeqqSrnxwvcOaCH1yTUbOfPm3/PJNRuTDlcmxyoWV6LxOF19EXZ29BGNK35HCIVjXL/u9SGdtcaacnojA6c0UyN7qXYGAz6OmVPFwtmVNNaUsWjeDG65+MSCc+YWL6yjuizAMXOqWTCrMtlJYqip361bt/LBD36Qb3/72+BOxzwpIvMKOrBhjDMXXngha9e6qWRr167loosuGjTm3HPP5eGHH6a9vZ329nYefvhhzj33XOrr66mqqmLjxo2oKnfddVfq9h3Acu/1cuBBABGZC/wKt3Iz+cdWRGZ5kTREpAxYCmz2ctceBy5O35dhHCrkLXh7KHDpaY1877EthGNxygI+uvuiA9oCCa421m9f28Obu7oIR2Ps7wnjIPgdN0H9Bxve5YSG6aOaID9ZyJbXNVTeWKYpU58joMLern5E3EKOeByCfklGqbJd31wyIel2JvLjusMHHapCG8KTdh5dfRH2dvXTF41RUeJnQ0oxQ4KPf/zjPPVUal40MeAXwKlDHsgwJhCrVq3iE5/4BD/60Y+YO3cuv/jFLwDYtGkTt99+O3feeSe1tbVcd911nHqqe2tff/31ycKC2267LSnPcf755ycKCQB2ActE5ArgzxzsgXs9MAP4oTdNGlXVRbhVomu9PDUH+Lmq/sbb5lrgXhH5FvAi8KMiXhLDGHMOaUctkfAf9PsoDThcMrOROdWl3Lx+M837euiPuf0+HXDlJrxqvnA0ztb9IVcFH0lOdfoEIrF40pEYzg/+ZCbb+Q6VN5ZJCLcy6EdwpVT8juukxVFmVpbmVaCQSyYk1d50B/Kr97+MAtMKyI/73qNv89L2dnq9aKwD+HyCI0J5iS/j9tFolJKSg1OvqhoWkcFNSQ1jAjNjxgwee+yxQesXLVrEnXcebPf8uc99js997nMZx7322muZdh1T1SXpK1V1Ba5mZ/r6V4CTM+1IVZuB07KfhWFMbg65qU9HhNnVpcytdaU56qpKmVYWIOj3JRNZe8IxGmrKqCjxobjTnQnJhcRzLO7mrKXmvqpC0Oewoz10UK+rq2/AD36uHKvJylDnm5je7OyN0Ly3m827O9l9oI8tezozTpnecvGJfPviE6ko8ROLg98nHDatjOqyQM4ChYRMSFNdFQvnVNNUV8W0skDGXLHVv3uT1q4+/twWYuu+HqIxpasvSnd/dEDO3FC5Zt979G1PZFdJSOAlJs8Pm1bGrKrMuWqzZs1i3bp1yWURuQg3n8YwDMMw8uaQi6g5AhXB7KeVGv2ZWRmkpy1z9EbVdSBiqvgS0TaFaRUBGmrKC+4XOREpJCI41Pk21pSzdV93cprYJ0I45or/JqYFM+33e5eenIx4lQV8eRUo5CsTsmFzK1v2duMT155oTNl5oJdYTPH5JOf2Ce58ciuOJLoQQCweQ3Ebtf/Zu3dKfMKB3siA7W6//XYuu+wyrr76anB7fV4LXJ71xAzDMAwjA4dcRC0Xqcnt1Wk/+KnEFL64+EgcESKxOD6BGZUBAj4fK89akLP6cDzIltCfbWwhEcGhznflWQtoD7mOijieGCxCbUXmSFeCXAUKmchVTJDgjieaCThOUsvM8aax8fpz5to+QU/Y7S0ajcXpj8YyTrP2x5QDvZEB1+7II49k48aNvPHGGwCvq+pfqOo7WU/MQ0TOE5G3ROQdT7E927iLRURFZFGufRqGYRiTlynnqGX6oc/GNUuP5o5Pv4/T5s1gRmWQeTMqk45Evg7DWFGo45VJNmOoKcChznfxwjqqSv0EHCHmVXAeNr2UGRXBnI7r4oV13HPl6fzx2nO458rTc0YjV561gAO9Eba0drF5dydbWrs40BsZFIXb3h6iutRPOBqnNxKjPxojpu6kZWXQn7fMSEWJj0hMicR1UEsqJSU/TnXAtfunf/onOjo6qKysBIiLSI2X7JwVL1H6B8D5wLHAJ0Xk2AzjqoBrgGeG2p9hGIYx+ZlSjtqGza10hMJs2x9iS2sXnb3Z+/amKthnciSGqytWLAp1vIbKK8tErvNtqquifnoZC1MkLIrluAqAekKbevCzSqUq6KctFMHnSLKBezQOh08v45aLT8w7irfizPkZe4amEvCiiKlO6e9+9zumT5+eXFbVduCCHKd2GvCOqjZ7TaXvBQbrIcA3gX8F+nLszzAMw5jkTBlHLRFxCsfiNEwvBYU/t/Vm/JEH+MhJ9UPubzjTdsWk0KnYxppy9nX3s/NAL9GYJvPKuvpjGaNwuc53rBzXRJP0ptlVHFM/jabZVVRnKCZIqKL7RCjxOQR9Dn5HqCjxFRTFu2bp0VRn0NtL4Ag4joPfcQY4pbFYjP7+/uSyp/0UzHF6hwPbU5YHtcMRkZOBxhRpgoyIyJUisklENu3duzfHYQ3DMIyJyiFXTJCN9GT46rIStrR2gUJpwEdHSjL4zMoSbr30lJz7HO2G4yOh0BZPK89awMq7nwe8vDIdmFeW6byGOt/FC+u4EQY0Oj9jQS13PNHMPz/42qjJl+RbTNAdjnH49FL2dYcJx+KU+BzmVAbpCec37Z3Kew+bxnPb2lwpEYVw7KBoclxdAd+a8sAAp/TTn/40S5Ys4bOf/Sy4ulCPAHflOFSm/zck43ki4gC3Ap/JZbO1yzEMwzg0mDKOWuIHvrM3wr7ufrcqMeZFXRxXaLXE5zCzsiTnVNdEJJNe2VARrUReWag/SiTutkaaVRWkMugfdkFEutDsUM3Th0u+Dmli3IJZlcl1oXCUuqrSgo+58qwFvPDndrcC2BECuFWkCohAU10l1563cMB5/eM//iMnnHACjz76KEAZ8E1VfSjHoXYAjSnL6e1wqoDjgA2e1MwcYJ2IXKiqmwo+McMwDGPCM2WmPjNN9SWSwfujcXyOEI0rLR19VA4h7zFRGc5UbDHzygrNmcuXfKdYR3MqdvHCugEVwAFHqCkPEPQ71JYHmF6eWcf2vPPO45ZbbgHXAesWkR/kONRzQJOIzPfEcS8FkmJsqnpAVWeq6jxVnQdsBMxJMwzDOISZfB7JMMk01ZcgUamYmGRSnYQhNQqfii00ClcIuaYoh9vVIdMUa6Zt8xlXiA3XLD2aExqmc8cTzWxp7aKrL0pNeYCZlcGs0cKXXnqJe+65B1wdtW/h9jDMiqpGReRq4CHAB/xYVV8XkRuBTaq6bqjtDcMwjEOPKeOopU71hWNKPMUZUyCmOqI8pslIvk4PuE7N6t+9ydb9rqO1YGbFoOm+VIaaohzptGi+DulQ44ZjQ2J/n1yzccC5pYr/HuZ0cO+993LPPfcwY8YMLrnkEgBU9eycBrvjfgv8Nm3d9VnGLs5nn4ZhGMbkZco4auBO9W3b383+ble2IRKLE/fkHRItjBJ5TFOlj2c+Ts+Gza185f6X6QhFSGjFbmnt5qv3v8y3Lz4x4/bp0br9Pf209UToCIW55t4XqQj6mFbm5osNp6vDSD+f4XSW2LC5lZvXb+bN3V0IbkeCOd59k4gWLlz4F3zwgx/kv/7rvzjqqKMAuOaaa/K2yzAMwzBSmTI5auA6D61dbiFBfzSeLBoQgX3d/ck8pjMW1E6pPp65uOOJZrr7o247JsfxHkJXXzRrzllqztzuzj7aeiLUlAeon1ZGKBxjX1eYrr6DlbaFdHUYjT6rhcqZbNjcylfvf5ktrd2Al9sYU7a3h+jsjSSjhb/85S+ZM2cOZ599Np///OczNrQ2DMMwjHyZUo7aKzs6SFFWSOII9EXjyQT8p5vbipIIP1nZ3h4iFtcBDepFIBqPD+lcJfTKmuqqaKhxG5iLCEG/AwJ7uw7qjBVSxDAahQr5dpZItOVaeffz7O8JA14+o0dcYWdHKJnb99GPfpT77ruPzZs3s3jxYm699VYAv4jcJiJ/mbeBhmEYhsEUc9TufHJrUqgq1emIxt1WQYnps4nYx3M8aawpx+fIgAIMVQaJvGYj/XrOrHR1X/uisWFVZI7G55NPVWhq5C4Wjye7G0TT9Fsicbj4lMMHTJlWVFRw2WWX8Zvf/AbgFeAlIGvvTsMwDMPIxJRy1HrCMXzeGacXdlYEfcnps4nWx3O8WXnWAiqDfmKqxOJx76FUlfrzcq4qS3y847Wpat7rTh1WBn2A8ObuLvZ29Q9ydIZiND6ffORMUiN3Qb9vgBptwtEXgVK/w9PNbUMdLqaqd6jqOXkbaBiGYRhMsWKCihJXgiLgQCQtKrKvO4xPhJvXb+ba8xYWTbZiMrJ4YR23XHzigKrPpllDV30m2LC5lf09YaIxxRGIxNzp0rjC7OogMyuD9EZi3P9CCyc0TM/LWRstWZFchRTb20P4BJr3dtMXHThnnnD0HdzzmKrRVsMwDKO4TClHbcWZ87n10S2D1vscwecI8bjytpcsfuOF781LtmKqMNx2WYnenBVBP3u9Qo64QsAnzKoaXtVnIbIiI6Eq6GdLa3eyc0WUg9OeiarP+ull+BwZVscDwzAMw8jFlHLUTmiYTnWZn87e6ID1PhHcfxDwuQ5ArmbdxtAk5DOe3dZG0CfUVZcm2zm9uesACgPaeZX4HA6Ewnnvfyz6rCaFj70nnwgqblHFETMqLNpqGIZhFJ0p5ajd8UQzMyuDzK2toLM3wp/a3OmqSCyO4BBHOayq1KaxRkiqmKzfEUKRONv2hyj1O8yZVorfcYirsvNALw6CT8TtvRpXNmxuzWs6dSw07jI2dp9WRltPP3u7+ukJx6go8bHizPnm1BuGYRhFYUoVE6RWC1aXBQj63CiaAn6fcNi0Mvy+/CoZjewkkvBjcSWaoofSF42zo72XYMBJdoYQx73+glBbEcgpsTEaGmr50lhTjt/nsGBWZbIfan80TjgGs6qCHDOnillVQe5/oWXKauwZhmEYxWVKRdTS2xrVTy9jR3svfp8wf2bFoGmsqdKdIBeFXodEn8+t+3rw+xycuBJTJa6uQ1xfXcq+njCh/iiRuNu6a1ZVkMqgP2c0s9COAtlsz+ecMhUttIci1FYECupoYBiGYRjDZUo5auk/vD5HqCkPMKOihAO9kQFJ6SPtR3moMJzrkHCIw7E4PkeSzlrCIT7QG6GprmpQL9BQODpkNHPD5lZe+HM70bgm88fKAj5mVpZkdPCy2X7xjg7uf6El5zllKlo40BthRkVwwHGmssaeYRiGUVymlKOW6Yf3ug8fm9HhGG4vyPGOwI22DcO5DgmH2CduJW08HiemEFXhnb3dzKstL1hiI+F0qSqxFGmV/miMlo4+muoq87b9zie3MqsqmNc5pRctpDdkh6mtsWcYhmEUlymVowYH2xr98dpzhqzsHE4vyPHuD1oMG4bTBSAhJjt/ZgWRmBJV8DngE4jG1GvFRE7B2VQSTpfjKc0mxGcTKXCarmA8hO094diwOxvk09HAMAzDMEaLKRVRK4T0fDYYOnIynMjTaFMMGwq9DgkSkajzv/MEW/f1EFMl4OWi+RwpWAIlkfcWiWuyAATv+fDppfSEY4O2yWZ7Qvh4OFGxsdJwMwzDMAyYghG1fCk0cjIR+oMWw4aRRpC6+qMcVXewarKqNDAsmxprytnf0088RXA28dwfjWd0srLZvuLM+cM+p9SpZXPSDMMwjGJjjloW8ukFmcpE6A9aDBsKvQ4JNmxu5ZNrNrK3q5939nbT2RsZkU0rz1pAW08Ex5PzSETURKA9FMnoZGWz/ZqlRw/7nMZ7etswDMOYWozL1KeI1AL3AfOAbcAnVLU9bcxJwG1ANRADblLV+8bSzkLU70er/+RIKLYNg7PAMpNabTmt1E9rd5g/tYUI+oSaihJK/L5h9eWsDProiwh90XgyJ63U71Ae9Gf9nLJ9hsPpbJCqD7d1X49b1er1h7WommEYhlEMxiuitgp4TFWbgMe85XRCwOWq+l7gPOA7IjJ9DG0siOFGnia6DcOJIqU6NB29UQKesHB/TGkPRbj4lMOHZdPRs6uZM62UY+uree9h03jvYdOon15GU13VsM+vELa3h4jGXNHeUNh1gvuicd7a02VRNcMwDKMojFcxwUXAYu/1WmADcG3qAFV9O+X1ThFpBWYBHWNjYuGMRf/JsbZhOAUKqYK3cVXiql73AagpD/B0cxvXDMOW4UQMR1OupLGmnOf/1EbUK2gQAVX3YVE1wzAMoxiMl6M2W1V3AajqLhEZ8hdORE4DSoB3s7x/JXAlwNy5c0fFwHx+4CeCblqxSThdqeQqBkhUW/ZF48nk/wT7e8JEY53DsqXQisvRFi1eedYCPvPT/YA3DeydmiPQvK9nWOdkGIZhGENRNEdNRB4F5mR46+sF7qce+BmwXFXjmcao6hpgDcCiRYvyTaVKku5wnbGgNqdy/VTpXDAceY5E5Cse1wF5bX7HrdUMxwr+iJIUEjEcbbmSxQvr8DsHtdtEwCeCyNDbGYZhGMZwKVqOmqouVdXjMjweBPZ4DljCEcuY4CMi1cB/A/+sqhuLYWemHKwfbHiXSMzV2RJxf+gDPhnQMDzVCcg25lBgOPIciVw5v88TpxUIOOA4Agol/rFJjXx7Tye7D/SxeXcnzV7l6UjlSo6aVYnPEUp8DiU+B0eEuML8GdaZwDAMwxh9xquYYB2w3Hu9HHgwfYCIlAAPAHep6i+KZUgmhysWVw6EIgPGpf/ATwTdtLFguAUKixfWseiIWuqnBSkP+EAEvyPMrCoZk+T/DZtb6e6PJSszozFl54Fe9nX3j0iuZNX5xzC9PIA4EFNFHJheHmDV+ceMovWGYRiG4TJejtpqYJmIbAGWecuIyCIRudMb8wngLOAzIvKS9zhptA3J5HAF/Q79sYGzrOnTfRNBN22sWLywjpVnLaChppzt7SHueKI5ryrHlWctIODzMWdaKe+ZXcWcaaUEfIVLcwyHO55oprYigCBuIYN3p2fTXMuXxQvruOXiEzm5sYY51aWc3FjDLRefeEhNdxuGYRgTh3EpJlDV/cCSDOs3ASu813cDdxfblkw5WFWlfvq7Y2xp7SIWV3yOUBn0c92Hj02OmQi6aWPFcPPxxrPd0vb2EDMqggT9PvZ29ROOxQk4MqTmWr5MhOpewzAMY2ow5Xt9ZnK4onGlIuinP+IJq6qQni8+lXo+jiQpf7ycmoQDXlUaoKrUrVoNhaPUVZWOuS2GYRiGMVymvKOWyeEq8TmEY/EBUbZMjslEi6wUSy5kOBIdVbyN3AAAGItJREFUxbIn331OpYinYRiGcegy5R01GOxwnXnz74flmIwnxZQLGY5ERzHsKWSfUyniaRiGYRy6WFP2DEzGQoFiyoUMR6KjGPYUus/FC+u458rT+eO153DPlaebk2YYBdLW1sayZctoampi2bJltLe3Zxy3du1ampqaaGpqYu3atcn1zz//PMcffzxHHXUU11xzTbJHL+ATkUdEZIv3XAMgIpeJyCve4ykROdFbXyoiz4rIyyLyuojckNiRiPxURLYWs+jMMMYTc9QyMBzHZLwpplzI4oV1XHzK4ezt6ufN3V3s7erP2a+zGPZMFUkUw5gorF69miVLlrBlyxaWLFnC6tWrB41pa2vjhhtu4JlnnuHZZ5/lhhtuSDp0V111FWvWrGHLli1s2bKF9evXJzarJ3O/563Ah1T1BOCbeELmQD9wjqqeCJwEnCcip6eY8VVVPcl7vDS6V8Ewxhdz1DIwERqsF0oxo4AbNrdy/wstzKoKcsycKmZVBbn/hZYhJTqKYc9kjHQaxmTmwQcfZPlyV/Jy+fLl/PrXvx405qGHHmLZsmXU1tZSU1PDsmXLWL9+Pbt27aKzs5MzzjgDEeHyyy9P3X46bp9nvOePAKjqU6qaCNttBBq89aqq3d76gPcYfosTw5hEmKOWhck2bVbMKOBwpjGLYc9kjHQaxmRmz5491NfXA1BfX09r6+D/nLW0tNDY2JhcbmhooKWlhZaWFhoaGgat9/Cn9nsGMv2BvQL4XWJBRHwi8hJuJ5tHVPWZlLE3edOlt4pIMNO5iMiVIrJJRDbt3bs3n9M3jAmBFRMcIhQzeX44VZ/FsMcKBAxj9Fm6dCm7d+8etP6mm27Ka/uUvLMkIpJ1fT6IyNm4jtqZKceJASeJyHTgARE5TlVfA74G7AZKcKdKrwVuzGDniHpCG8Z4YY4axZO1GGuKJRcynKrPYtkz0SRRDGOy8+ijj2Z9b/bs2ezatYv6+np27dpFXd3g715DQwMbNmxILu/YsYPFixfT0NDAjh07Bqw/7LDDEotREalX1V3p/Z5F5ATgTuB8Txx9AKraISIbgPOA1xKROaBfRH4CfCXPUzeMScGUn/rM1JT9+nWv59UiaapgU46GMTW58MILk1Wca9eu5aKLLho05txzz+Xhhx+mvb2d9vZ2Hn74Yc4991zq6+upqqpi48aNqCp33XVX6vYdZOj3LCJzgV8Bf6OqbycGi8gsL5KGiJQBS4HN3nK99yy4uW6vjfJlMIxxZco7asWUtThUmIzFFZMVETlPRN4SkXdEZFWG9/9BRN7w8nEeE5EjxsNOY2qwatUqHnnkEZqamnjkkUdYtcq9JTdt2sSKFSsAqK2t5brrruPUU0/l1FNP5frrr6e2thaA2267jRUrVnDUUUdx5JFHcv755yd2vYsM/Z6B64EZwA89qY1N3vp64HEReQV4DjdH7Tfee/8pIq8CrwIzgW8V7YIYxjggmfIIJjOLFi3STZs25R7okRC3Tc2dUFUO9Eb447XnFMNEY4ohIs+r6qI8xvmAt3F/uHbg/iB9UlXfSBlzNvCMqoZE5CpgsapeMtR+C/1OGEaxyfc7USzsO2FMJHJ9H6Z8RM0kH4wJxGnAO6rarKph4F5gwFyTqj6uqokqjqR8gWEYhnFoMuUdNcu/mjxs2NzKJ9ds5Mybf88n12w8FPMIDwe2pyzv8NZlY4B8QSomRWAYhnFoMOWrPk3yoXiMZjVtMXuZTiAyaRdkzE0QkU8Di4APZXrfpAgMwzAODaa8owYm+VAMRtuxSi36ACgv8RMKR7njieZD6bPbATSmLDcAO9MHichS4Ou4rXb6x8g2wzAMYxwwR83Im0IiZKPtWA1HdHcS6uM9BzSJyHygBbgU+FTqABE5GbgDOE9VD7m5X8MwDGMgUz5HzciPQvXmRruBeqFFH5NRH09Vo8DVwEPAm8DPVfV1EblRRC70hn0bqAR+4ckXrBsncw3DMIwxwCJqI2ASRmyGTaERsuF2M8jGyrMWcP261wmFo5QFfPRGYkMWfUzWqVJV/S3w27R116e8XjrmRhmGYRjjhkXUhslkjNikU0gVZaERstGupi1UdHe0I3qGYRiGMR5YRG2YTNaITYJCk/0LjZAVqyl7vtuPdkTPMAzDMMYDc9SGyXCS2ycShTqahU49wvhW0w7HXsMwDMOYaNjU5zCZ7B0NCp0anGz9PiebvYZhGIaRCYuoDZPJHrEZztTgZNObm2z2GoZhGEY6FlEbJpM9YmOtswzDMAxj4mMRtREwmSM21jrLMAzDMCY+5qhNYSazo2kYhmEYUwGb+jQMwzAMw5igmKNmGIZhGIYxQTFHzTAMwzAMY4JijpphGIZhGMYExRw1wzAMwzCMCYo5aoZhGIZhGBMUc9QMwzAMwzAmKOaoGYZhGIZhTFDMUTMMwzAMw5igmKNmGIZhGIYxQbEWUsakYsPmVu54opnt7SEarT+pYRiGcYhjETVj0rBhcyvXr3ud1q4+ppcFaO3q4/p1r7Nhc+t4m2YYhmEYRcEcNWPScMcTzQR8QnmJHxH3OeAT7niiebxNMwzDMIyiMOWnPm0qbfKwvT3E9LLAgHVlAR872kPjZJFhGIZhFJcpHVGzqbTJRWNNOb2R2IB1vZEYDTXl42SRYRiGYRSXKe2o2VTa5GLlWQuIxJRQOIqq+xyJKSvPWjDephmGYRhGUZjSjtr29hBlAd+AdTaVNnFZvLCOGy98L3VVpRzojVBXVcqNF77XpqoNwzCMQ5ZxyVETkVrgPmAesA34hKq2ZxlbDbwJPKCqV4+mHY015bR29VFecvAy2FTaxGbxwjpzzAzDMIwpw3hF1FYBj6lqE/CYt5yNbwJ/KIYRNpVmGIZhGMZEZrwctYuAtd7rtcBHMg0SkfcBs4GHi2GETaUZhmEYhjGRGS95jtmqugtAVXeJyCDPSEQc4P8AfwMsGWpnInIlcCXA3LlzCzLEptIMwzAMw5ioFM1RE5FHgTkZ3vp6nrv4W+C3qrpdRIYcqKprgDUAixYt0kLsNAzDMAzDmKgUzVFT1aXZ3hORPSJS70XT6oFMwmVnAB8Ukb8FKoESEelW1aHy2QzDMAzDMA4Zxmvqcx2wHFjtPT+YPkBVL0u8FpHPAIvMSTMMwzAMYyoxXsUEq4FlIrIFWOYtIyKLROTOcbLJMAzDMAxjQjEuETVV3U+GAgFV3QSsyLD+p8BPi26YYRiGYRjGBGJKdyYwDMMwstPW1sayZctoampi2bJltLdn1CVn7dq1NDU10dTUxNq1a5Prn3/+eY4//niOOuoorrnmGlSTtV4+EXlERLZ4zzUAInKZiLziPZ4SkRNTjyMiPhF5UUR+k7Juvog84+3rPhEpGe3rYBjjiTlqhmEYRkZWr17NkiVL2LJlC0uWLGH16tWDxrS1tXHDDTfwzDPP8Oyzz3LDDTckHbqrrrqKNWvWsGXLFrZs2cL69esTm9WTWfR8K/AhVT0BV+x8TdrhvozbqSaVm4FbvX21A1eM+MQNYwJhjpphTCBE5DwReUtE3hGRQcUzIhL0ogbveFGEeWNvpTFVePDBB1m+fDkAy5cv59e//vWgMQ899BDLli2jtraWmpoali1bxvr169m1axednZ2cccYZiAiXX3556vbTySB6rqpPpbQT3Ag0JDYQkQbgw8CdKesEOAe4P31fhnGoYI6aYUwQRMQH/AA4HzgW+KSIHJs27AqgXVWPAm7FjSYYRlHYs2cP9fX1ANTX19PaOlhJqaWlhcbGxuRyQ0MDLS0ttLS00NDQMGi9hz9V9BzIpDp+BfC7lOXvAP8IxFPWzQA6VDXqLe8ADs90LiJypYhsEpFNe/fuzX7ShjHBGC95DsMwBnMa8I6qNgOIyL247dbeSBlzEfAN7/X9wL+LiGhK8o9hFMLSpUvZvXv3oPU33XRTXttnuvVEJOv6fBCRs3EdtTO95b8CWlX1eRFZnDo0k0lZ7DRhdGNSIofa33cR2Qv8KcvbM4F9Y2hOIZhtw2My2HaEqs7KNVhELgbOU9UV3vLfAO9X1atTxrzmjdnhLb/rjdmXtq9kWzXgPcBbedg5kTCb8qeYdh2He+9EgADuvfRa2phaoIqDf3eP8J53AkcDr2cYdxLQmCJ6vkFV3wMgIicADwDnq+rb3rp/wW0nGAVKgWrgV966vcAcVY2KyBnAN1T13KFOyvud6GFifp75MFHvxXww2wcz5G/EIRdRG+pkRWSTqi4aS3vyxWwbHoeYbflEB/KKIKRGD3IedAJeQ7Mpf4ppl4h8G9ivqqu9nMlaVf3HtDG1wPO4mpgAL+BOR54sIs8BXwKeAX4LfF9Vf+vtd5DouYjMxXPAEk4agKp+DfiaN2Yx8BVV/bS3/DhwMXAvWQTU01HVWRP188wHs318GC/bLUfNMCYOO4DGlOUG3KhExjEi4gemAW1jYp0xFckpTq6qbbgVms95jxuBmLf9VbjJ/+8A73Iw5yzjfoHrcfPOfigiL4nIpjxsvBb4BxF5x9v2R8M/XcOYeBxyETXDmMQ8BzSJyHygBbgU+FTamET7tadxowi/t/w0o1jkK06uqj8GfpxYFpEvpow7roD9riCD6HnamA3AhpTlZtz8TsM4JJlqjlpeU0HjhNk2PA4Z27wcm6uBhwAf8GNVfV1EbgQ2qeo63GjBz7zoQRuuMzemdo4RZlP+TES7JqJN6UwGG7Nhto8P42L7IVdMYBiGYRiGcahgOWqGYRiGYRgTFHPUDMMwDMMwJiiHtKMmIh8XkddFJC4iWUtqc7XtKZJttZmaEmcYF/Oqn14SkXVFtmnCti/Kw7bPiMjelGs1ZELyKNv2YxFp9TTOMr0vIvI9z/ZXROSUMbJr2J+niHzNW/+WiAypSVUEu/5BRN7wrtVjInJEyntF+T6M5P4SkeXe93iLiCwfQ5tuTbHnbRHpSHmvWNdp2Pd6sa6Tt+9c1+osEXlBRKLi6hWmvpfxWskYNXsvku0/FZGtKe+dNAFtnysiD4vIm973fZ63fjJc92y2F+e6q+oh+wCOwRVo3AAsyjLGh1s2vgAoAV4Gjh0D2/4VWOW9XgXcnGVc9xhdq5zXAfhb4Hbv9aXAfRPIts8A/z5O99lZwCnAa1nevwBXlkCA04FnJsg1y/h54ravehkIAvO9/fjG0K6zgXLv9VWp91kxvg8jub9wRVybveca73XNWNiUNv5LuMUnRbtO3n6Hda8X6zoV8PnNA04A7gIuTnsv47UCfg5c6r2+HbhqnO694dj+0/SxE9D2DcAy73Vlynd+Mlz3bLYX5bof0hE1VX1TVYdSZIeUtj2qGsYVTbyo+NZxERmaEo8j+VyHVJvvB5aI5NkTpvi2jRuq+gRDa5ldBNylLhuB6eKqsReTkXyeFwH3qmq/qm7F1cAaLfmDnHap6uOqGvIWBzTmLhIjub/OBR5R1TZ1m4k/Apw3DjZ9ErhnFI47JCO414t1nSC/e2qbqr7CwD6hWfG+B2PR7H3UbR9Dhm27uD2M/ar6iDeuW1VDk+G6Z7O9CDYmOaQdtTw5HNiespy1qe8oM1tzNyUGKBW3kfBGESmmM5fPdUiOUbcJ8gFcgclik+9n9DFvuuV+EWnM8P54MR732Eg+z2LaW+i+0xtzF+P7MJL7q1jXKu/9ijs1PB/4fcrqsfq7kU42uyfSPZVOpmuVd7P3EVIM2xPc5N2vt4pIcMSWDmYkth8NdIjIr0TkRRH5toj4mBzXPZvtCUb9uk96HTUReRSYk+Gtr6tqzlYiFNDUt1CGsq2A3cxV1Z0isgD4vYi8qqrvjoZ9aYxa+6IikM9x/wu4R1X7ReQLuP8TO6foluXHeFy3kXyexbQ3732LyKeBRcCHUlYX4/swkvurWNeqkP1eCtyvqrGUdWP1dyOdCX1PZWHQtQI6R7jPfBl1273P+WvAbtxpvTW43RtuHLG1AxmJ7X7gg8DJwJ+B+3DTCzLlU060657N9h9RpOs+6SNqqrpUVY/L8MjHSYP82vYUw7Y9iekv77k1yz52es/NuPPiJ4+GbRmYyO2LctqmqvtVtd9b/A/gfWNgV74U7R4b4TGzfZ7FtDevfYvIUtz/0FyY8rkW6/swkvurWNeqkP1eStq05xj+3Ugnm93jfk9lI8u12oc7bZsIZhTrO1sM21HVXd70cz/wE4rTuWEktu8AXvSmHqPAr3FzHyfDdc9me9Gu+6R31EaBZNser7rkUjJ79aNNohUQZGkkLCI1idCpiMwEPgC8USR78rkOqTaPZfuinLal5XxdCLw5BnblyzrgcnE5HTiQmPYuIiP5PNcBl4pbFTofaAKeHSu7RORk4A5cJ601ZX2xvg8jub8eAv7Ss60G+EtvXdFt8ux6D25y/tMp68by70Y62e71Yl0nGMHf8GzXyvseJJq9Q57N3ofBqNvuLSeCAIKb45WxSne8bPe2rRGRWd7yOUyS604W26GI112LWBUy3g/go7jebz+wB3jIW38Y8NuUcRcAb+NWgXx9jGybATwGbPGea731i4A7vdd/AbyKW5HyKnBFkW0adB1ww7YXeq9LgV/gJpc/CywYw88yl23/ArzuXavHgYVjaNs9wC4g4t1vVwBfAL7gvS/ADzzbXyVLBfJE+jxxo1nvAm8B54+xXY9639eXvMc6b33Rvg8jub+Az3nX8B3gs2Nlk7f8DWB12nbFvE7DvteLdZ3y/PxO9eztAfYDr+e6VrgVgc969v4CCI6mzUW2/ffeuteAu4HKiWS7994y4BXPzp8CJZPhuuewvSjX3VpIGYZhGIZhTFBs6tMwDMMwDGOCYo6aYRiGYRjGBMUcNcMwDMMwjAmKOWqGYRiGYRgTFHPUDMMwDMMwJijmqE0CRCQmIi+lPOaJyCIR+Z73/mIR+YuU8R8Rtx9ZocfpzrBug4icm7bu70Tkh4XuyzDGksQ96H1fPjXK+/6ntOWnRnP/hmEYCcxRmxz0qupJKY9tqrpJVa/x3l+Mq6mT4CNAwY5aFu7BFQNMZZASumFMYOYBBTlqab37MjHAUVPVv8g20DAMYySYozZJ8aJovxGRebiCk3/vRds+hKuc/m1v+UjvsV5EnheRP4rIQm8f80XkaRF5TkS+meVQ9wN/laKAPQ9XMPhJEakUkcdE5AUReVVELspmZ8ryv4vIZ7zX7xORP3h2PZSm/m4Yo8Vq4IPe9+HvRcQnbiPl58RtnrwSkvfq4yLyf3FFKxGRX3v35+sicqW3bjVQ5u3vP711ieidePt+zftOXJKy7w3iNnTfLCL/6amXG4ZhDMmkb8o+RSgTkZe811tV9aOJN1R1m4jcDnSr6i0AIrIO+I2q3u8tP4arHL5FRN4P/BC37cV3gdtU9S4R+WKmA6vqfhF5FjgPt5XHpcB9qqoi0gd8VFU7vRYmG0VkneahoiwiAeD7wEWqutf7QbsJV73cMEaTVcBXVPWvADyH64Cqnur9B+R/RORhb+xpwHGqutVb/pyqtolIGfCciPxSVVeJyNWqelKGY/01cBJwIjDT2+YJ772Tgffi9hT8H9yWP0+O/ukahnEoYY7a5KA3y49CTkSkEnda9Bcp/4EPes8fAD7mvf4ZcHOW3SSmPxOOWsKZEuD/F5GzgDhwODAb2J2Hae8BjgMe8ezy8f/au58Xm8I4juPvj0iS7uouRSmJorBwCxHZK5rFLK0kZDH+ASsbe5KdZrKhbMxGQymhmbk3xAqxoUQzUuZHX4vzHM69zlyHRk63z2t1z3PO8zzn1v3xPed8n75ZaRqzf+0IsF1SXk+wQVbPdA54VAjSAM5Iyi+M1qfjPvYZey8wGhGLwHtJ98hK0cyksd8BpAuvjThQM7PfcKA2+FYAn/sEelVqiN0CLknaCayJiMnUPgw0gV0RMS/pNVn9yKIFuh+x5/tFVjutVWF+s+Uk4HREdBUFl3SArK5fcfsw0IqIr5Im+PXzXTb2Ur4VXi/i318zq8A5aoNhFlhXth0RM8ArScfhRw7NjnTcA34uFBheavCI+AJMANfoXkTQAD6kIO0gsKGk+xtgq6TVkhrAodT+EmhKaqXzWiVpW8X3a/Yner8f48DJ9PgdSZslrS3p1wA+pSBtC7CnsG8+79/jPjCU8uCawH6yAtNmZn/FgdpguA0cTcnN+4AxYETSlKRNZEHYCUlt4BmQJ/2fBU5Jekz2p9TPKFnezVih7TqwW9KTNMeL3k4R8Ra4AXTS8VOpfQ44BlxM5zVN98pVs+XSARYktSWdA64Cz4FJSU+By5Tf3boDrJTUAS4ADwv7rgCdfDFBwc00Xxu4C5yPiCqpAGZmpVQh79vMzMzM/gPfUTMzMzOrKQdqZmZmZjXlQM3MzMysphyomZmZmdWUAzUzMzOzmnKgZmZmZlZTDtTMzMzMauo7e2lx1FMBe3MAAAAASUVORK5CYII=\n", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "text/plain": "
" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from matplotlib import pyplot as plt\n", - "\n", - "from bartpy.diagnostics.residuals import plot_qq, plot_homoskedasity_diagnostics\n", - "from bartpy.diagnostics.sampling import plot_tree_mutation_acceptance_rate\n", - "from bartpy.diagnostics.sigma import plot_sigma_convergence\n", - "from bartpy.diagnostics.trees import plot_tree_depth\n", - "from bartpy.sklearnmodel import SklearnModel\n", - "\n", - "\n", - "def plot_diagnostics(model: SklearnModel):\n", - " fig, ((ax1, ax2, ax3), (ax4, ax5, ax6)) = plt.subplots(2, 3, figsize=(10, 10))\n", - " fig.suptitle(\"Diagnostics\")\n", - " plot_qq(model, ax1)\n", - " plot_tree_depth(model, ax2)\n", - " plot_sigma_convergence(model, ax3)\n", - " plot_homoskedasity_diagnostics(model, ax4)\n", - " plot_tree_mutation_acceptance_rate(model, ax5)\n", - " plt.show()\n", - "\n", - "plot_diagnostics(model)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Sklearn API\n", - "\n", - "Feature selection can be done in BartPy using the Sklearn selector API. This allows for deep integration with the Sklearn pipelines" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Proportion Threshold\n", - "\n", - "The simplest way to select features is to set a threshold on how often a variable is used in splits in the model trees. The more times a tree appears in the model, the more likely it is that the feature is important and captures a meaningful pattern.\n", - "\n", - "While this method is simple, the downside is that it is hard to set the threshold appropriately. Cross validation is recommended" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "model = SklearnModel(n_samples=200, n_burn=50, n_trees=20, store_in_sample_predictions=False)\n", - "pipeline = make_pipeline(SelectSplitProportionThreshold(model, 0.3), model)\n", - "pipeline_model = pipeline.fit(X, y)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": "Feature Proportions {0: 0.3870967741935484, 1: 0.2903225806451613}\nIs Kept [ True False]\n" - } - ], - "source": [ - "print(\"Feature Proportions\", pipeline_model.named_steps[\"selectsplitproportionthreshold\"].feature_proportions)\n", - "print(\"Is Kept\", pipeline_model.named_steps[\"selectsplitproportionthreshold\"]._get_support_mask())" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": "" - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "text/plain": "
" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(pipeline.predict(X), y)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "text/plain": "
" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "pipeline_model.named_steps[\"selectsplitproportionthreshold\"].plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Null Distribution Threshold\n", - "\n", - "For a more principled analysis, BartPy implements the method described in https://repository.upenn.edu/cgi/viewcontent.cgi?article=1555&context=statistics_papers.\n", - "\n", - "This is significantly more computationally expensive, but offers a principled way to set proportions" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": "[0, 1]\n" - } - ], - "source": [ - "model = SklearnModel(n_samples=200, n_burn=200, n_trees=5, store_in_sample_predictions=False, n_jobs=-1)\n", - "pipeline = make_pipeline(SelectNullDistributionThreshold(model, 0.75, \"local\"), model)\n", - "pipeline_model = pipeline.fit(X, y)" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": "Thresholds {0: 0.2355833333333333, 1: 0.20002080123266563}\nFeature Proportions {0: 0.36666666666666664, 1: 0.3}\n[0, 1]\nIs Kept [ True True]\n" - } - ], - "source": [ - "print(\"Thresholds\", pipeline_model.named_steps[\"selectnulldistributionthreshold\"].thresholds)\n", - "print(\"Feature Proportions\", pipeline_model.named_steps[\"selectnulldistributionthreshold\"].feature_proportions)\n", - "print(\"Is Kept\", pipeline_model.named_steps[\"selectnulldistributionthreshold\"]._get_support_mask())" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": "" - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "text/plain": "
" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(model.predict(X), y)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": "" - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "text/plain": "
" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(X[:,0], model.predict(X))\n", - "plt.scatter(X[:,1], model.predict(X))" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": "[0, 1]\n" - }, - { - "data": { - "image/png": "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\n", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "text/plain": "
" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "pipeline_model.named_steps[\"selectnulldistributionthreshold\"].plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Feature Selection\n", - "\n", - "The approach so far is useful - but it doesn't give a complete picture of the importance of a single variable. There are at least two big limitations:\n", - "1. % of splits doesn't give up an idea of how much a variable is improving accuracy\n", - "2. In cases of high correlation, the model might be able to as easily split on different variables\n", - "\n", - "To get a more direct account of a single variable, we can instead permute that variable, and see how the out of sample RMSE changes. The bigger the increase in RMSE that scrambling a variable, the more important the variable is." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": " sampling\n100%|██████████| 500/500 [00:03<00:00, 150.15it/s]\n 6%|▌ | 11/200 [00:00<00:01, 108.69it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 134.82it/s]\n 3%|▎ | 13/500 [00:00<00:03, 129.28it/s]Starting sampling\n100%|██████████| 500/500 [00:03<00:00, 153.04it/s]\n 8%|▊ | 17/200 [00:00<00:01, 160.23it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 166.83it/s]\n 3%|▎ | 17/500 [00:00<00:02, 168.59it/s]Starting sampling\n100%|██████████| 500/500 [00:02<00:00, 176.90it/s]\n 10%|▉ | 19/200 [00:00<00:01, 180.85it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 186.67it/s]\n 8%|▊ | 38/500 [00:00<00:02, 187.68it/s]Starting sampling\n100%|██████████| 500/500 [00:02<00:00, 187.61it/s]\n 8%|▊ | 17/200 [00:00<00:01, 166.14it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 189.05it/s]\n 4%|▍ | 19/500 [00:00<00:02, 184.14it/s]Starting sampling\n100%|██████████| 500/500 [00:02<00:00, 189.95it/s]\n 10%|▉ | 19/200 [00:00<00:00, 185.51it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 190.00it/s]\n 4%|▎ | 18/500 [00:00<00:02, 172.04it/s]Starting sampling\n100%|██████████| 500/500 [00:02<00:00, 189.14it/s]\n 10%|█ | 20/200 [00:00<00:00, 191.06it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 196.06it/s]\n 4%|▍ | 20/500 [00:00<00:02, 193.30it/s]Starting sampling\n100%|██████████| 500/500 [00:02<00:00, 192.01it/s]\n 19%|█▉ | 38/200 [00:00<00:00, 181.98it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 163.02it/s]\n 3%|▎ | 15/500 [00:00<00:03, 145.17it/s]Starting sampling\n100%|██████████| 500/500 [00:02<00:00, 172.72it/s]\n 10%|▉ | 19/200 [00:00<00:00, 186.14it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 180.94it/s]\n 2%|▏ | 12/500 [00:00<00:04, 118.13it/s]Starting sampling\n100%|██████████| 500/500 [00:03<00:00, 152.25it/s]\n 6%|▋ | 13/200 [00:00<00:01, 127.42it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 167.98it/s]\n 4%|▍ | 19/500 [00:00<00:02, 181.46it/s]Starting sampling\n100%|██████████| 500/500 [00:03<00:00, 159.40it/s]\n 0%| | 0/200 [00:00\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "text/plain": "
" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from bartpy.features.featureimportance import feature_importance\n", - "feature_importance(model, X, y, 0)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmwAAAKUCAYAAAC5VGRRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeXgUVdbA4d/phCWsKosCYVMURUBAQBBlEFARER3HBVQEIyKCDjpuiCMCivugIiKiAooRdUQHBpdPcETBDXHYF4XRABEUjLIGCEnO90dVdzpNEkLSSVUn532eflJdy63bnaru03cVVcUYY4wxxvhXwOsMGGOMMcaYglnAZowxxhjjcxawGWOMMcb4nAVsxhhjjDE+ZwGbMcYYY4zPWcBmjDHGGONzFrAZY3xNRKaIyANe56OwRKSRiOwVkTiv82KMKTvExmEzxnhJRFKA44FMIAtYC7wGTFXVbA+zVihu/ger6gKv82KMKbushM0Y4weXqGp1oDHwGHAv8Iq3WTLGGP+wgM0Y4xuquktV5wJXAwNFpKWIzBCRhwFE5FgRmSciO0TkD3c5MXi8iDQVkc9FZI+ILBCR50XkdXdbExFRERkoIptF5DcRuT/s2Eoi8oyIbHUfz4hIJXdbbfdcO0XkdxFZJCIBEZkJNAL+7VaD3hN2nnj32ONEZLqb5h8i8q+C0iyt99oYE1vsw8EY4zuqugRIBc6N2BQApuOUxDUC9gOTwra/ASwBagFjgAF5JH8O0BzoAYwWkdPc9fcDnYA2wBlAR+Dv7rY73fzUwam+HeVkUwcAm3FKCKup6hN5nG8mUAU4HagLPF1Qmvm8JcaYcs4CNmOMX20FjgtfoappqjpbVdNVdQ8wHvgTOI39gQ7AaFXNUNXFwNw80h2rqvtVdQWwAic4A7gWGKeq21V1BzCWnIDvEFAPaKyqh1R1kRaiAbCI1AMuAoaq6h/usZ8VJ01jTPlkAZsxxq8aAL+HrxCRKiLyoohsEpHdwOfAMW6PzPrA76qaHnbIljzS/SVsOR2o5i7XBzaFbdvkrgN4EtgIfCwiP4rIyEK+hoZunv7IY1tR0zTGlEMWsBljfEdEOuAEbIsjNt2JU515lqrWALoGDwG2AceJSJWw/RsexWm34lS1BjVy16Gqe1T1TlU9EbgE+JuI9HD3K6hUbIubp2MiNxwhTWOMycUCNmOMb4hIDRHpA7wJvK6qqyJ2qY7Tbm2niBwHPBjcoKqbgKXAGBGpKCKdcQKhwpoF/F1E6ohIbWA0EOyw0EdEmomIALtxhh/Jco/7FTgxrwRVdRvwITDZ7TBRQUS6FiJNY4zJxQI2Y4wf/FtE9uCUSN0PTABuyGO/Z4AE4Dfga+CjiO3XAp2BNOBh4C3gYCHz8DBOwLcSWAX8110HcDKwANgLfAVMVtWF7rZHcQK9nSJyVx7pDsBpr7Ye2A7cXog0jTEmFxs41xhTZonIW8B6VX3wiDsbY4yPWQmbMabMEJEOInKSO0ZaL+BS4F9e58sYY4or3usMGGNMFJ0AvIszDlsqcIuqLvM2S8YYU3xWJWqMMcYY43NWJWqMMcYY43MWsBljjDHG+JwFbMYYY4wxPmcBmzHGGGOMz1nAZowxxhjjcxawGWOMMcb4nAVsxhhjjDE+ZwGbMcYYY4zPWcBmjDHGGONzFrAZY4wxxvicBWzGGGOMMT5nAZsxxhhjjM9ZwGaMMcYY43MWsBljjDHG+JwFbMYYY4wxPmcBmzHGGGOMz1nAZowxxhjjcxawGWOMMcb4nAVsxhhjjDE+ZwGbMcYYY4zPWcBmjDHGGONzFrAZY4wxxvicBWzGGGOMMT5nAZsxxhhjjM9ZwGaMMcYY43MWsBljjDHG+JwFbMYYY4wxPmcBmzHGGGOMz1nAZowxxhjjcxawGWOMMcb4nAVsxhhjjDE+ZwGbMcYYY4zPWcBmjDHGGONzFrAZY4wxxvicBWzGGGOMMT5nAZsxxhhjjM9ZwGaMMcYY43MWsBljjDHG+JwFbMYYY4wxPmcBmzHGGGOMz1nAZowxxhjjcxawGWOMMcb4nAVspshEZIaIPOx1PowpLhFJFZFuhdx3sIgsLNkclR4R+V5EzvU6H+WBiFwrIh97nQ8TmyxgKyNEZJCIrBKRdBH5RUQmi0jNiH1aiMhcEdklIntE5D8i0qmU8qci0qw0zmWKR0T2hj2yRWR/2PNrS+H8qWHn3CkiX4jIEBGRKKX/uoiMiUZaxSUii0VkkLvcU0RSSvh8h712VW2uqotK8rzliYicIyJfup+zv7vXbwcAVU1W1Qu8ziOAiNQQkWdEZLN7r210n9f2Om8mbxawlQEicifwOHA3UBPoBDQBPhaRCu4+JwFfAKuApkB94F/AfBHp6EG2jU+parXgA9gMXBK2LjlyfxGJL4FsXOSevwnwJDAKmFoC5ykzSuj/YI6CiNQA5gHPAccBDYCxwEEv8xVJRCoCnwCnA72AGsDZQBrgm+8Du6YjqKo9YviBc6PtBa6KWF8N2A4MdJ/PBD7I4/gXgE/zSbsbkIrzZfkbkAJcG7Z9BvBw2PObgI3A78BcoL67/nNAgX1uXq/2+n2zR6GvrxSgZ8S6h4G3gFnAHmAQzo+/UcD/3GvlTeDYsGO6AF8DO4HlQNcCzpkKdItY1xnIBk51n1cGJgBbgF+ByUBld1tPN9+jcb6AfgL6uduGAYeADPdafC/snH/D+UGzy31tlfLJ32D3mp7s7rsOOM/d1h/4JmL/e4F38klrsfv+1QT2u69xr/uoW9D7CjRz76sbcALr/7j7vwP84r7XC4HTCvHau4W9rxOBbcDP7ntcMeJ9vQfYAWwFrvf6GvXTA2gP7Cxg+yBgcdjzC4Dv3etoMvAZMDhs3y+Ap93/5Y84QdUg97oPfb67+18MLAN2u9vHFJCPwe59U62AfU5zr5+dwBqgb9i2GcDzwPs4nwHfACe526YAT0WkNQf4m7tcH5jtXkM/AX8N22+Me/2+7r6OwUAC8CrwB869dg+QGnbMkdJ7G3jNzecaoH3Y9obAu+6xacCksG1J7vn+AP4PaOz59eV1BuxRzH+g8+soE4jPY9urQLK7/AtwQx77nOceXzmPbd3cbROASsCfcIKu5u72GbgBG9Ad5wulnbvvc8DnYWkp0Mzr98seR319pZB3wJYBXIITICQAd+F8uTTA+dJ/BZjp7t/Q/TC80N2/l3ut1MrnnIcFbO76rcBN7vIk4D3gWJwfLR8AD7nberrX7ZPutdgdSA9ef+6XwZg8zvk1cAJQC/gB94szj3wMdtP/K1ABuAbnS+0Y973YCZwctv8q4NJ80loMDArLd0rE9oLe12DANh2o4p47gPOFXt3dfxKwNCy9/F57N3f5EeBLoA5OwPgN8GDE+/qg+7r74nwe1PD6OvXLw70W03A+ey8i7EeLu30QbsAG1MYJSi4H4oEROAF1eMCWiROQx+Hcd5txAqVKOMHeHtygC+fzupV7DbTGCcguyyefbwKvFvA6KuD8+B4FVHTvoT3k/uz/Hac0Lh5IBt50t3XFCRjFfX4szo+R+m7evsP5MVUROBEnEL3Q3XeM+x5cRs5ny2M4geyxQCKwEjdgK2R6B4De7nv4KPC1uy0OWIETEFfFuV/Ocbdd5r7+09zX93fgS8+vL68zYI9i/gPhOuCXfLY9BnzsLmcCvfLY51ScD/36eWzr5h5XNWzd28AD7vIMcgK2V4Anwvar5t54TdznFrDF4IP8A7b/RKzbAPwp7HlDnGqgAHA/MD1i/08IK62N2JZfwLYUp7Qq4H4INw7bdi6wwV3uiRNQVgnb/i5wn7ucX9DSL+z5BMJ+bUfsO5iwLyR33X+B/u7yS8BYd7kNTnBaIZ+0jhSwFfS+BgO2RgX8/2q7+1Q9wmvv5i5vAi4I23YxsDEsf3uBuLDtvxNWYmGPUMnUDPd9zcSpbTje3TaInIDteuCrsOPEva7CA7YNYdtbuf/L48PWpQFt8snHM8DT+WybDzxWwGs4F+dHfiBs3azgteO+vpfDtvUG1oe9js24peg4NS//cZfPAjZHnOs+3M8HnADr84jtoQDMfT6YnICtMOktCNvWAtjvLnfGKVnLq7DjQ+DGsOcBnB99jb28tqwNW+z7DaidT11/PZwLMrhfvXz2UXd7Xv5Q1X1hzzfh/FKKVN/dBoCq7sX5MGlQYO5NrNoS8bwR8G+3k8BOnFIlxSmlaQz0D25zt3ci7+uoIA1wAoQTcEoYVoSlN889V1CaqqaHPc/vug33S9hyOs6PjvykqvtJnkf6rwLBzhnXAW+p6qEjnDs/Bb2vQaH/hYjEicgTIvKjiOzGKSUAJ3ArjHqE3cfucvg9/JuqZoU9P9L7VO6o6jpVHaSqiUBLnOvimTx2rU/Y/869nlIj9vk1bHm/u1/kumoAInKWiHwqIjtEZBcwlPz/72nk/X2QK2+qmh22LvJayPN+cV/HmzjNA8ApgQ62fW0M1I/4LBgFHB+WVuRnS/2IdeHLhUkvMp+V3e/LhsAmVc087NU76T4blubvOIGop99nFrDFvq9wfnFfHr5SRKriFMl/5q5aAFyZx/FX4RQRZ+ST/rFuWkGNcKqmIm3FucjDz18Lpx2MKXs04nkqcL6qHhP2qKyqv+B8wE6P2FZVVZ8s7Mnc3szH45RI/YpTgtY8LL2aqhreK7qWiCSEPQ+/biPzXhSJEc9D6avqYjfPXXC+tGYWMs288lXQ+4p7vvDjrscp7eiO0y4u2DM72MP2SK99G2H3Mc7rsnu4iFR1PU5pVMs8Nm8j7Dpye0FHXldH4w2c0ryG7r0whZz/e6QFwIURn+3htgINRSQ8Rjiaa2EWcIWINMYpBZvtrt8C/BRxPVdX1d5hx0Zeo7neJ5xAK6gw6eVnC9Aon8KOLcDNEekmqOqXhUi3xFjAFuNUdRdOL6TnRKSXiFQQkSbAP3FKzYK/bMYCZ4vIeBE5TkSqi8htOO0jHjzCacaKSEV3rKY+btqR3gBuEJE2IlIJpy3MN6qa4m7/Fad9gSmbpgCPiEgjABGpKyJ93W0zgT+LyPluCVBlETlPRI5YwiYiNd103gBmuKUXWcDLwDMiUkcciSISPlxCABjjXrfdcH68vONui8a1WE9EbhWReBHpB5wEfBS2fSZOh559qvp1IdP8Fae0vHrYuoLe17xUx/kBl4bTrm18Huco6LXPAkaLSG0RqQM8gFONagpBRE4VkTtFJNF93hAnaM/rGngfaCUil7lBw3Cc0uOiqg78rqoH3J7/1xSw70ycoGS2m+eAiNQSkVEi0hun7eI+4B73O6UbTpvVNwuTEVVdhlO78zLwf6q60920BNgtIveKSIL7edAyOOxJPt4G7hORY0WkAXBr2LaipBd+7DbgMRGp6n4udXG3TXHPeTqEPofyKvAoVRawlQGq+gROMfBTOA1Df8L5sO4ZrM5U1Q3AOcAZOO2SdgIPAX9W1fkFJP8LTi+ZrTjB31D3V2NkHj7B+XCfjXMTnAT0C9tlDPCqW8R8VVFfq/GtCTgByycisgen4Xpw7KkU4M8418cOnPYtd1Lw58+HIrLX3XckTgeCwWHb78SpolmC08PuY+DksO2pOF8423CqKAe79wA4XyJniMgfIvIORfMlzpAIv+Nc239R1T/Ctr+GU6pS2NI1VHU1zv2T4t4ndSngfc3HdJx7dStOj7jIEoEjvfaxOA2xV+E07v4Gp6G2KZw9OCVK34jIPpxAbTXO9ZqLqv6GU+vxBE6A3QKnnWZRhwAZBoxzr5PROIFOnlT1IE6bxPU47dl249xLtXF+aGfgdCq5COeH/2ScHsGHffYXYJZ7jjfCzpuFE/i1wfme+g3nmqyZVwKucTj38084JYPv4L5HRUwvMi/NcD5nUoGr3W3v4QyV9abbtGA1znvhqWAvDlOGiEgSzgdvF1XdnM8+iTgfJg+q6iv57NMNeN1ti2FMTBCRnjgNopt4mIeqOMMutFTVn7zKh4kdbvVjKk5nnE+9zo9ficgtOB2E/uR1XkqblbCVQao6DafE7ewC9knF+cVQT0Ss0bAx0TUc+MKCNVMQEblQRI5xm5GMwmlzVtgq9HJBROqJSBe32rY5Tmnle17nyws2inAZpapHrIpR1VU4VR/GmCgRkVScIW0u9Tovxvc641QZVgTW4oybtt/bLPlOReBFnBl6duK0o5vsaY48YlWixhhjjDE+Z1WixhhjjDE+V+aqRGvXrq1NmjTxOhvGQGoq/Por3zmDjdbxKht2Txi/+e677+yeMMZV2PuhzAVsTZo0YenSpV5nw5R333wDZ58NgwcjL7+86cgHlBy7J4zfiIjdE8a4Cns/WJWoMdF24ADccAPUrw9PPeV1bowxxpQBZa6EzRjPjR0L69bBRx9BzSOO32iMMcYckZWwGRNN334LTzwBN94IF17odW6MMcaUEVbCZky0HDwIgwY5VaH/+IfXuSnQoUOHSE1N5cCBA15npVyqXLkyiYmJVKhQweusGGNihAVsxkTLuHGwdi188IHvq0JTU1OpXr06TZo0QUS8zk65oqqkpaWRmppK06ZNvc6OMSZGWJWoMdGwdCk8/rjT2eAiz+cIPqIDBw5Qq1YtC9Y8ICLUqlXLSjeNMUfFAjZjiiE5GU5pfJBVHW7gF47n7U4TipyWiFQWkSUiskJE1ojI2Dz2qSQib4nIRhH5RkSaFON8Rc6rKR57740xR8uqRI0pouRkGDIERqY/TCtWc3HWPBbecQyHqsK11xYpyYNAd1XdKyIVgMUi8qGqhk8GfSPwh6o2E5F+wOPA1cV+McYYY3zNAjZjiuj++6F5+n+5j0eZwUA+4GJId9YXJWBTZ2Lfve7TCu4jcrLfS4Ex7vI7wCQREY3BSYFFhOuuu46ZM2cCkJmZSb169TjrrLOYN28ec+fOZe3atYwcObLQacbFxdGqVSsOHTpEfHw8AwcO5PbbbycQKFplwiOPPMKoUaMASElJoU+fPqxevbpIaZWEA5kH+Hrb12RmZ3qdlVyqV6zOWfXO8jobRy0zK5sv/5dGneqVOK1eDa+zY0wuFrAZU0TbNmUwl0Fspy538HRo/ebNRU9TROKA74BmwPOq+k3ELg2ALQCqmikiu4BawG8R6QwBhgA0atSo6BkqQVWrVmX16tXs37+fhIQE5s+fT4MGDULb+/btS9++fY8qzYSEBJYvXw7A9u3bueaaa9i1axdjxx5Wu1wo4QGbH83931we+vohr7NxmNOOO423L3nb62wUydDXv+OKMxMZd2lLr7NiTC4WsBlTRE/UHE/rXau4hLns5NjQ+uLER6qaBbQRkWOA90SkpaqGF+nk1fjpsNI1VZ0KTAVo3769b0vfLrroIt5//32uuOIKZs2aRf/+/Vm0aBEAM2bMYOnSpUyaNIlBgwZRo0YNli5dyi+//MITTzzBFVdcUWDadevWZerUqXTo0IExY8aQnZ3NyJEjWbhwIQcPHmT48OHcfPPNLFy4kNGjR1OrVi2+//57unbtyuTJkxk1ahT79++nTZs2nH766YwfP56srCxuuukmvvzySxo0aMCcOXNISEgojbcqT+mH0gGYedFMEuK9y0ekyvGVvc5CkcTHBTgj8RiWbd7pdVaMOYwFbMYUxbJl3Lb3Ed6IG8C8rEtCq6tUgfHji5+8qu4UkYVALyA8YEsFGgKpIhIP1AR+L865xv57DWu37i5OEodpUb8GD15y+hH369evH+PGjaNPnz6sXLmSpKSkUMAWadu2bSxevJj169fTt2/fIwZsACeeeCLZ2dls376dOXPmULNmTb799lsOHjxIly5duOCCCwBYsmQJa9eupXHjxvTq1Yt3332Xxx57jEmTJoVK7FJSUtiwYQOzZs3ipZde4qqrrmL27Nlcd911R/HORFc22QA0P665rwK2WNau8TG8+NmP7M/IIqFinNfZMSbEeokac7QyMuCGGwjUqU2F55+hcWMQgcaNYerUInc4QETquCVriEgC0BNYH7HbXGCgu3wF8J9YbL8W1Lp1a1JSUpg1axa9e/cucN/LLruMQCBAixYt+PXXXwt9juDb8/HHH/Paa6/Rpk0bzjrrLNLS0tiwYQMAHTt25MQTTyQuLo7+/fuzePHiPNNq2rQpbdq0AeDMM88kJSWl0PkoCdnqBGwBsY/yaGnX6Fgys5XVW3d5nRVjcrESNmOO1qOPwooVMGcOV/Y9jitvjlrK9YBX3XZsAeBtVZ0nIuOApao6F3gFmCkiG3FK1voV96SFKQkrSX379uWuu+5i4cKFpKWl5btfpUqVQsuFjVF//PFH4uLiqFu3LqrKc889x4URU4YtXLjwsGE28ht2IzwPcXFx7N+/v1D5KCkWsEVf3epOde7O9EMe58SY3CxgM+ZorFgBDz/sFKMdZYP4I1HVlUDbPNaPDls+AFwZ1RN7LCkpiZo1a9KqVSsWLlwYtXR37NjB0KFDufXWWxERLrzwQl544QW6d+9OhQoV+OGHH0KdHJYsWcJPP/1E48aNeeuttxgyZAgAFSpU4NChQ76dQipLswAIWGVJ1MQFnGA9Kzvb45wYk5vd5cYU1qFDzlyhtWrBs896nZsyIzExkREjRkQlrfBOAj179uSCCy7gwQcfBGDw4MG0aNGCdu3a0bJlS26++WYyM53hMDp37szIkSNp2bIlTZs25c9//jMAQ4YMoXXr1lxb1HruEhYsaYylEraPPvoIoKU7+PNhY7bkNzi0iFQQkVdFZJWIrBOR+8KOSXHXLxeRpcXJX3ycE7BlZsdsSwNTRlkJmzGF9dhjsHw5vPeeE7SZYtm7d+9h67p160a3bt0AGDRoEIMGDQKcHqNHOhYgKysr3/MFAgEeeeQRHnnkkcO2ValShbfeeuuw9Y8//jiPP/546Hn4GGx33XVXvucqLVmahSAxM3NCVlYWw4cPB/gBaA98KyJzVXVt2G75DQ59JVBJVVuJSBVgrYjMUtUU97jzVDXX8DZFER8qYbOAzfhL7PwsM8ZLK1fCQw9B//5w2WVe58YYwClhi5PY6cm4ZMkSmjVrBpChqhnAmziDQYe7FHjVXX4H6CFORKpAVbd3dAKQAUS3ezMQ7w6ynJllAZvxFwvYjDmSQ4ecSd2PPRYmTvQ6NybKunXrxrx587zORpFkaVZMVYf+/PPPNGzYMHxVKs5g0OFyDQ4NBAeHfgfYB2wDNgNPqWpwSBsFPhaR79xBow8jIkNEZKmILN2xY0e+eYwLVYlaGzbjL1YlasyRPPEE/Pe/MHs21K7tdW6MCcnW7JgK2PLp3Ru5Mr/BoTsCWUB94FhgkYgsUNUfgS6qulVE6gLzRWS9qn4ece5CDSYdrBK1NmzGb2LnTjfGC6tXw9ixcPXVcPnlXufGmFxiLWBLTExky5YtuVYBWyN2Cw4OTcTg0NcAH6nqIVXdDnyB0w4OVd3q/t0OvIcT3BVJnLVhMz4VO3e6MaUtMxMGDeJAwjG0++I5AgFo0gSSk73OmDGOWAvYOnToEBysuKKIVMQZR3BuxG75DQ69GegujqpAJ2C9iFQVkeoA7voLyD07yFGpYG3YjE/Fzp1uTGl78kn47jtuPDCZZal1UIVNm2DIEAvajD/EWsAWHx/PpEmTAE4B1uEMDr1GRMaJSHBgw1eAWu7g0H8DgkN/PA9UwwnGvgWmu2MXHg8sFpEVwBLgfVX9qKh5DLZhsxI24zexc6cbU5rWrIExY5hX5UreyMg9Z2V6Otx/v0f5KkNEhAEDBoSeZ2ZmUqdOHfr06VOi5x00aBBNmzbljDPO4JRTTuH666/n559/LnJ6//rXv1i7NmdUim7durF0abGGAiu0WOt0AASnIFutqiep6nhwBod2Z/JAVQ+o6pWq2kxVO7pt1FDVve7601W1hao+6a7/UVXPcB+nB9MsqmAbtkPW6cD4TGzd6caUhsxMp1dojRrcmD4pz102by7lPJVBVatWZfXq1aHpnebPnx+aeaCkPfnkk6xYsYLvv/+etm3bct5555GRkVGktCIDttKkqjEXsPldqA2bVYkan7E73ZhI//gHfPstPP88CY3r5rlLo0alnKcy6qKLLuL9998HYNasWfTv3z+0bd++fSQlJdGhQwfatm3LnDlzAEhJSeHcc8+lXbt2tGvXji+//BJw5gTt1q0bV1xxBaeeeirXXnvtEeccFRHuuOMOTjjhBD788EPAmSS+c+fOtGvXjiuvvDI0SG+TJk2499576dixIx07dmTjxo18+eWXzJ07l7vvvps2bdrwv//9D4B//vOfdOzYkVNOOYVFixZF900LE4slbH5nvUSNX9mwHsaEW7sWRo+Gv/wFrryS8YecNmvp6Tm7VKkC44tV6eIzH46EX1ZFN80TWsFFjx1xt379+jFu3Dj69OnDypUrSUpKCgU448ePp3v37kybNo2dO3fSsWNHevbsSd26dZk/fz6VK1dmw4YN9O/fP1QFuWzZMtasWUP9+vXp0qULX3zxBeecc84R89GuXTvWr19Ply5dePjhh1mwYAFVq1bl8ccfZ8KECYwe7UznWqNGDZYsWcJrr73G7bffzrx58+jbty99+vThiityqs4zMzNZsmQJH3zwAWPHjmXBggVFeRePKNbasMUCESEuINaGzfiOBWzGBLlVoQcqVuecb57nv3FCo0YwcCB88IFTDdqokROs+XRqyZjTunVrUlJSmDVrVrBtU8jHH3/M3LlzeeqppwA4cOAAmzdvpn79+tx6660sX76cuLg4fvjhh9AxHTt2JDExEYA2bdqQkpJSqIAtWBL39ddfs3btWrp06QJARkYGnTt3Du0XLAHs378/d9xxR77pXe4OAXPmmWeSkpJyxPMXVbZmx9RMB7EiLiBWwmZ8xwI2Y4ImTIAlSxhS8U2+Sz0ecHqFvvoqTJ1ahoO0QpSElaS+ffty1113sXDhQtLS0kLrVZXZs2fTvHnzXPuPGTOG448/nhUrVpCdnU3lypVD2ypVqhRajouLC03ufiTLli2jR48eqCrnn38+s2bNynO/8Dk7C5q/M5iPo8lDUVgJW8mIDwiZWdbpwPiL3enGAKxbB6NH82GVy5mZcVWuTdYrtGQlJSUxevRoWrVqlWv9hRdeyHPPPcgTvcYAACAASURBVBcq/Vq2bBkAu3btol69egQCAWbOnFnghO9HoqpMnDiRbdu20atXLzp16sQXX3zBxo0bAUhPT89VghecIP6tt94KlbxVr16dPXv2FDkPxZGNBWwlwUrYjB/ZnW5MVha/XXIDfxyqyqD0yeQ1M471Ci05iYmJjBgx4rD1DzzwAIcOHaJ169a0bNmSBx54AIBhw4bx6quv0qlTJ3744QeqVq161Oe8++67Q8N6fPvtt3z66adUrFiROnXqMGPGDPr370/r1q3p1KkT69evDx138OBBzjrrLJ599lmefvppwGmH9+STT9K2bdtQp4PSkp1tAVtJiLc2bMaH5Ei9qGJN+/bttbTGQDJlw3+veYp2s+6mP2/wJv3z3KdxYyhqUyQR+U5V2xc9h8WT1z2xbt06TjvtNI9yFJuaNGnC0qVLqR2l+WSj8T+467O7+OGPH5h7WeRkAf7mx3siXIfxC+h52vE8enmrfPcxJloKez/YTzNTvq1fz+mz/s57XMab9MtzlzLXK9SUGdmaTcA+xqPOKWGzNmzGX6zTgSm/srIgKYl9VOEWXiCvqtDGja1XqHGUZG/PosrWbAIBC9iiLS4gNpeo8R270025k5zsTOL+t/hn4auvuI3n+JUTDtsvWA1qwZrxqyzNsmE9SkC8dTowPuT7gE1EGorIpyKyTkTWiMjhrZONKaTkZGcg3IqbfmA89zOHvrzBNYftZ9WgJhZkazaSR8mwKR4bONf4ke8DNiATuFNVTwM6AcNFpIXHeTIx6v774UB6FtNI4gCVGcoUIqtCGzcu4+OumTLDBs4tGRXiAmRaGzbjM75vw6aq24Bt7vIeEVkHNAC8mW3ZxLRNm2AEz3EOXzCA1/iFerm2ixS9N6gxpc0Gzi0ZVsJm/Cim7nQRaQK0Bb6JWD9ERJaKyNIdO3Z4kTXjc8nJULs2NGMDjzCKf9OH17nusP1sUvfSIyIMGDAg9DwzM5M6derQp0+fYqe9cOFCatasSdu2bWnevDldu3Zl3rx5RU4vJSWFN954I/R8xowZ3HrrrcXOZ3FZwFYy4gPCIet0YHwmZu50EakGzAZuV9Xd4dtUdaqqtlfV9nXq1PEmg8Z3gkGaCFx3Hfyels00kjhIJW7mRSKrQq3dWumqWrUqq1evZv/+/QDMnz+fBg0aRC39c889l2XLlvH9998zceJEbr31Vj755JMipRUZsPmFBWwlw0rYjB/FxJ0uIhVwgrVkVX3X6/wY/0tOhhtugLCpKbmVSZzLYm7nGbZRP9f+1m7NGxdddBHvv/8+ALNmzQpNrg6wZMkSzj77bNq2bcvZZ5/N999/D8CECRNISkoCYNWqVbRs2ZL09PQCz9OmTRtGjx7NpEmTANixYwd/+ctf6NChAx06dOCLL74AnHlKBwwYQPfu3Tn55JN56aWXABg5ciSLFi2iTZs2oRkOtm7dSq9evTj55JO55557oviuFJ4FbCUj3tqwGR/yfRs2cWZYfgVYp6oTvM6PiQ0jRsChQznPT2IjjzGS9+nNa1yfa9/izGJQFjy+5HHW/77+yDsehVOPO5V7O957xP369evHuHHj6NOnDytXriQpKYlFixY5aZx6Kp9//jnx8fEsWLCAUaNGMXv2bG6//Xa6devGe++9x/jx43nxxRepUqXKEc/Vrl07nnzySQBGjBjBHXfcwTnnnMPmzZu58MILWbduHQArV67k66+/Zt++fbRt25aLL76Yxx57jKeeeipUrTpjxgyWL1/OsmXLqFSpEs2bN+e2226jYcOGRX3LiiRbs4kP+P5jPOY4VaIWsBl/iYU7vQswAFglIsvddaNU9QMP82R8LDk5d8makM0r3EgGFRnCVMKrQq0a1FutW7cmJSWFWbNm0bt371zbdu3axcCBA9mwYQMiwiE3Ag8EAsyYMYPWrVtz880306VLl0KdK3wavgULFrB2bU6/pd27d4cmcL/00ktJSEggISGB8847jyVLlnDMMcccll6PHj2oWbMmAC1atGDTpk2lHrBlaRYVpWKpnrM8iAsI+w9ZlajxF98HbKq6mLyGoDcmH5HziA9jMn/ic25gGlvJaSNVqxY8+6xVgxamJKwk9e3bl7vuuouFCxeSFhZpP/DAA5x33nm89957pKSk0K1bt9C2DRs2UK1aNbZu3Vro8yxbtiw0d2d2djZfffUVCQkJh+3nFOrn/zyoUqVKoeW4uDgyMzMLnZdoUVUb1qMExNtMB8aHrPGDKVMiS9ea8iOPcy8f0osZDAKcQO311+G33/wVrBVmkGgR6SYiu0RkufsY7UVeoykpKYnRo0fTqlXuibZ37doV6oQwY8aMXOtHjBjB559/TlpaGu+8884Rz7Fy5Uoeeughhg8fDsAFF1wQas8GsHz58tDynDlzOHDgAGlpaSxcuJAOHTpQvXr1UAmcn2RpVr4BpSm6uEDAZjowvuP7EjZjCis5Ga4Pa54WrArNJJ4hTCUQEF57zV9BWoTgINH/FZHqwHciMl9VI8ccXKSqxR/7wicSExMZEVksCtxzzz0MHDiQCRMm0L1799D6O+64g2HDhnHKKafwyiuvcN5559G1a1fq1q2b6/hFixbRtm1b0tPTqVu3LhMnTqRHjx4ATJw4keHDh9O6dWsyMzPp2rUrU6ZMAaBjx45cfPHFbN68mQceeID69etTp04d4uPjOeOMMxg0aBDHHntsCb4jhWcD55aMCnE2+bvxHwvYTJkQ7BUa/hk7lCmcx0Ju5GVSacjr/g7Wyt0g0Xv37j1sXbdu3UJVn507d+aHH34IbXvooYcAmDZtWmhdw4YN2bhxY57p7Nq1K99z165dm7feeivPbaeccgpTp07Nta5ChQqHDQkyaNCg0HJxxngrjmzNthK2EhBnc4kaH7IqUVMm3H9/7l6hTfiJJ7iH/+MCppFErVr+DtYi5TdItKuziKwQkQ9F5PR8jrfBpMuBbKyErSTE2zhsxoeshM2UCZs25SwHq0KzCXATLwHCs896lrWjVtAg0cB/gcaquldEegP/Ak6OTENVpwJTAdq3b2/fPIU0ZswYr7NwVLKzbRy2khAXCFinA+M7dqebmJec7MxmEDSEqXTnU+7kH2yhUUyVrh1pkGhV3a2qe93lD4AKIlK7KOcKH+bClK5ovffZWMBWEuIDYgPnGt+xO93EvPvvh+D3X2NSeJK7mU9PXmYwFSsSM6VrhRkkWkROcPdDRDri3MNpee1bkMqVK5OWlmZBmwdUlbS0NCpXrlzstGymg5IRH2dVosZ/rErUxLyc6lDlZQYDMJiXAWHatNgpXSOfQaKBRgCqOgW4ArhFRDKB/UA/LULUlZiYSGpqKta+zRuVK1cmMTGx2OlkZWfFXMD20UcfAbQUkY3Ay6r6WPh2EakEvAacifNj5GpVTXFLn18G2uF8d72mqo+6x/QCngXi8krzaMVbpwPjQxawmZg2bFjO8k28RE8+4WamsJnGNG4cU8FaoQaJVtVJwKSC9imMChUq0LRp0+ImYzymxNbAuVlZWcGx8H4A2gPfisjciKFrbgT+UNVmItIPeBy4GrgSqKSqrUSkCrBWRGYBW4DngfOB1HzSPCpxgQBZ1obN+Exs/TQzJkxyMrhDZ9GITfyDO/mE7kxlCCI25ZQp+7I0C4mhiWCWLFlCs2bNADJUNQN4E7g0YrdLgVfd5XeAHm4zAAWqikg8kABkALuBjsBGVf2xgDSPSnyccMjasBmfsYDNxKwRI4Jt15SXuAmAG3kFEFRjq3TNmKLI1mziArFTwvbzzz9HzreaCmHzxTka4JSaoaqZwC6gFk7wtg9nrMLNwFOq+nv4/gWkeVRD3cTZsB7GhyxgMzEpfAqqwbzMBcznbp5kE00AaNzYu7wZU1qyNTumStjyaW4ZuTKvF6Q4JWlZQH2gKXCniJxYwP6R556qqu1VtX2dOnUKzGcFtw2bqrJoww4L3owvWMBmYlJwJqOGbM5VFQpYdagpN2JtaqrExES2bNmSaxWwNWK3VKAhgFv9WRP4HbgG+EhVD6nqduALnHZwof0LSPOoxAUCqMI736Uy4JUlvPvf1OIkZ0xUWMBmYk5O6ZpTFRogm8G8jLqX89ChVh1qyodYm5qqQ4cObNiwAaCiiFQE+gFzI3abCwx0l68A/uP2hN4MdBdHVaATsB74FjhZRJoWkOZRiY9z3tNP1m0H4JB1QDA+YAGbiTlDhzp/k5jGhXzMPTxBCk6Px1q1YPJkDzNnTCnK0qyYKmGLj49n0qRJAKcA64C3VXWNiIwTkb7ubq8AtdxhP/4GjHTXPw9UA1bjBGnTVXWl287tVuD/wtMsVj4DTsC2MnUnAHH2TWl8wIb1MDElORn27oVEtjCBv/Ep3ZjC0ND2WBkk15hoUNWYG4etd+/eAKtVtX1wnaqODls+gDOERy7uDB+HrXe3fQB8EK08JlR0guCtuw4AsO9gVrSSNqbIYutON+WeU7qmTGUI8WRyI6+EqkLBqkJN+ZKlsTdwbixIqJC71DI9I9OjnBiTw0rYTMzo2dMpXRvEDC7iI27lOX7ixND2WrU8zJwxHlCNrYFzY0WVirm/GtMzrITNeM9+mpmYMGwYfPIJNCCVp7mDz+jKZIbl2seqQ015k6VZMdXpIFZUqRhZwmYBm/GeBWzG93JmNFBe5GYqkkES03JVhd5yi1WHmvLHSthKRkJEwLbvoFWJGu9ZlajxveCMBtfzGhfzAX/lWX7kpNB2EesZasonK2ErGVbCZvzIStiMrwXHXKvPzzzLCD7nXCZxa659hg7N52BjyjBVjbnJ32PF4QGblbAZ71nAZnzNmdEgpyo0sldojx5WumbKp2x1Jie3XqLRlxDW6aBiXIB9VsJmfMDudONLyclQrZpTunYdr9OH9xnFI2zk5Fz7LVjgUQaN8ZgFbCWnStiwHnWqV7ISNuML1obN+E5yMgwY4LRbO4FtTOSvLKYLz3Fbrv1sgndTnmVjAVtJCe90ULtaRfZYpwPjA3anG19JTobrrnOCtWBVaGUOkMQ0ssndrsQmeDflWVa2U01nAVv0VYrPeU9rV6tEus10YHzA7nTjG8OGOcFa0DW8QV/+zf2MZwOn5NrXhvEw5Z3iTEhunQ6iL7znbZ3qldhnVaLGByxgM76QnAwvvJDz/Hh+4Tlu40s68ywjcu1rE7wb4wzpASDYsB4l6biqFUnPyEKdYn9jPGMBm/GFEbliMmUKQ6lCOjcwPVdVaHy8zWhgDBAKIOICVsJWkqpWiicrWzmYme11Vkw5ZwGb8YW0tJzlfrzJZczh7zzMDzQPra9cGWbMsKpQY8BK2ErL8TUqA7B1536Pc2LKOwvYjK/U5VcmcStf0YmnuSO0vkcP2L/fgjVjgoLDelgbtpLVuFYVADb/nu5xTkx5ZwGb8dSwYc7UUg7lBW6hKvty9Qrt0cPGWzMmUmgctoB9jJekRsc5AdsWC9iMx2wcNuOZYcNydzS4ire5nPe4h8dZz2mh9RasGXO4UMBmv7tLxKtJHdmfkUmdapWoFB9gU5oFbMZbFrAZT0QGa3XYzvMM5xs6MoG/hdbb4LjG5M1mOihZfzqlTmi50XFVrErUeM73d7qITBOR7SKy2uu8mOiIDNYAnmc41dnDDUwnK+x3hA2Oa0zegp0OLGAreSfUrMyvew56nQ1TzsXCnT4D6OV1Jkz0TJmS+/kV/JMreYcHGcs6WoTWV61qnQyMyU9wWA8L2EpefEDIzrZx2Iy3onani8hJIlLJXe4mIn8VkWOKm66qfg78XuwMGl9ITg5OO+WozQ4mM4xvac9T3BVaLwIvvuhBBo2JEVbCVnoCImTbwLnGY9G802cDWSLSDHgFaAq8EcX08yUiQ0RkqYgs3bFjR2mc0hRBcJ7QcJO4lRrszlUVWrkyzJxZ/krXRKShiHwqIutEZI2IjMhjHxGRiSKyUURWikg7L/JqvGfDepQeEcHiNeO1aAZs2aqaCfwZeEZV7wDqRTH9fKnqVFVtr6rt69Spc+QDTKmLnCcU4C+8w9W8zVgeZA0tgXI/3lomcKeqngZ0AoaLSIuIfS4CTnYfQ4CI1oCmvLBOB6UnIFgJm/FcNHuJHhKR/sBA4BJ3XYUopm9iVOQ8oZBTFbqUM3mCewAbb01VtwHb3OU9IrIOaACsDdvtUuA1dRowfS0ix4hIPffYo/bPH/7J/kP+GsG9UlwlLjnpEqpUqOJ1VnL5autXbPhjg9fZCNmx36lNsICt5AWshM34QDQDthuAocB4Vf1JRJoCr0cxfROjRhxWsQfPcRvHsJPu/CdUFVqeg7VIItIEaAt8E7GpAbAl7Hmquy5XwCYiQ3BK4GjUqFG+53lh+QuhL34/OS7hOM5vfL7X2chl5KKR/H7AX81p4ySOE6qe4HU2yrxAwErYjPeiFrCp6loRuRdo5D7/CXisuOmKyCygG1BbRFKBB1X1leKma0rHsGG55wkFuJzZ9OMt7ufhUFVorVoeZM6nRKQaTpvQ21V1d+TmPA457JtEVacCUwHat2+f7zfN3Mvmoocf7pnNezbTb14/MrIyvM7KYTKyMrjqlKu4/czbvc5KSHwgnoT4BK+zUeaJdTowPhC1gE1ELgGeAioCTUWkDTBOVfsWJ11V7R+N/JnSl1dVaC1+YzLD+I52oapQgGefLeXM+ZSIVMAJ1pJV9d08dkkFGoY9TwS2FvV81SpWK+qhJaJ6hepATvssP8nWbCrHV6Z6xepeZ8WUMgGrEjWei2bjhzFAR2AngKoux+kpasqpvKpCJ/JXjuUPbmA6mVQgLg5ef73cdjLIRUQEp4f1OlWdkM9uc4Hr3d6inYBdRW2/5kfiTizr14DN2osVz0cffUTz5s0BWorIyMjtIlJJRN5ye0F/4zYNQESuFZHlYY9st1AAEVkoIt+Hbasb7XwHRDwth96cls70L37yMAfGD6LZhi1TVXeJ5Kqxsd8k5VhkVehlvMc1zOIBxrGK1gBkZnqQMf/qAgwAVonIcnfdKHKaGUwBPgB6AxuBdJy2o2VGcIgKPwZsWZplAVsxZGVlMXz4cObPn89JJ520BugvInNVNbxTzY3AH6raTET6AY8DV6tqMpAMICKtgDluoUDQtaq6tKTy7nUv0aunfsW2XQe4sn1DqlWyGSXLq2j+51eLyDVAnIicDPwV+DKK6ZsYkpyc+/lxpPECt7CMNjyG88P6lls8yJiPqepi8m6jFr6PAsNLJ0elLxgQ+TFgU1Ub86wYlixZQrNmzTjxxBPB+TH/Jk6v58he0GPc5XeASSIiqrmipf7ArJLPcQ6vB87dc8D5ZatWL1uuRfPn4m3A6cBBnJtpN+Cf1rmmVA0enPv5s4ygFmkMYgaZVKBFC5g82Zu8Gf8KBmzBUfz9JEuziKhBMEfh559/pmHD8OaXoR7O4UK9oN1xPXcBkV2SrubwgG26Wx36gOTzTyrOAOsiQraHvyGCL8jCtfItagGbqqar6v2q2sEdxPZ+VT0QrfRN7Bg2DA6E/ef7MofrSOZh/s5KzqBiRVizxrv8Gf8KBmx+K0lQVRQrYSuOfP6nkSsL7AUtImcB6aq6Omz7taraCjjXfQzI5/xFHmA9IP67Jk35U+wqURH5NwUE/sXtJWpiT3jP0GP5nSkMZTln8Cj3ATBtmkcZM77n1xK2YBWtlbAVXWJiIlu2bMm1isN7OAd7QaeKSDxQk9xzSfcjonRNVX92/+4RkTdwOr+9Fs28i4Af5n73YUsBU4qi0YbtqSikYcqI00/P/fwZbqc2v3ERH3KIioD1CDX5C5Zg+WlsOIBsbN7O4urQoQMbNmzgp59+AqckrR9wTcRuc3Fmy/kKuAL4T7D9mogEgCuBrsGd3aDuGFX9zR0Spw8Q9SG4vW7DFix3tLHgyrdiB2yq+lk0MmJiX3IyrA1rPtyHf3M9MxnLaFbQBrABck3BgiVYWdn+LGGzXqJFFx8fz6RJk7jwwgvBae/8kKquEZFxwFJVnYszrM1MEdmIU7LWLyyJrkCqqv4Ytq4S8H9usBaHE6y9FO28i8fDegTLdS1gK9+iUSX6tqpeJSKryHvE9dbFPYeJDQPCWo4cwx+8yM2spBXjuT+03gbINQXxbQmbBWxR0bt3b3r37o2IrFbV8QCqOjq43W33fGVex6rqQqBTxLp9wJkll2OH123YcsYn9CwLxgeiUSUaHB61TxTSMjGqZ8/cI4E/zR3UZTt9mBeqCu3Rw6pDTcH83obNqkTLJ6dK1OtcWAlbeVfsn4tho6wPU9VN4Q9gWHHTN7Hhk09ylnvzPoN4lUe5j2W0A6B+fZvc3RyZX8dhCwaQUvAweaaM8nrgXLE2bIbojsN2fh7rLopi+sanwgfJrclOpjKEVbTkYf4eWv/zzx5kzMQcvwZsweqwuICVsJVHzjhsHgZs7l8/lPIZ7xQ7YBORW9z2a81FZGXY4ydgZfGzaPwuvO3aBP7G8fzKDUwng0qAUxVqTGEE8GeVqJWwlW8i/pj8vaCgcfXPuxj377U2XlwZFo02bG8AHwKPAuGT+e5R1d/zPsSUFQ0a5HyQ9eJDkpjOeEbxHe0BOOYYqwo1hefXgXOtDVv55vXk7zmdDvLPxdUvfsW+jCzuOP9kqleuUFpZM6UoGsN67MKZPqS/iMQBx7vpVhORaqq6ubjnMP7UoAFsdYe9rMEuXuIm1tCCcYQ6ffHHHx5lzsQkEUEQ35Ww2cC55Zvnbdjcv1YlWr5FbfJ3EbkVZ9LeX4FgAxQFbFiPMig8WAP4B3dSj238mfdCVaHGFEWcxFkJm/EVrwfOPZpOBxbUlV1RC9hwJnpvrqppUUzT+FDPnrmDtQv4PwbzCo8ykqV0CK23tmumKET8W8Jm47CVT+KTYT0K80Mmyw8ZNSUimp8+W3CqRk0ZlpycewiPGuziZQazltMYy4O59rW2a6Yo4iTOd71EgwGkBWzlk9cD5wYrRbMKcVtkZufstHH7XpqMfJ9VqfbVXBZEs4TtR2ChiLwPHAyuVNUJUTyH8digQbmfP8nd1GcrZ/MlB6kcWv/666WbL1N2BCTgu4At+GVtAVv55JfJ3wtTJRpewvaf9b8CMGf5z7RKrFli+TKlI5qfPpuB+UBFoHrYw5QRw4ZBZmbO8/P5mCG8xFPcxRLOCq2/5Rab0cAUnR8DNithK98CIh5PTeX8LUzAlpmVs09wGJqjyfnyLTt54F+rfdeO1ESxhE1Vx0YrLeNPL7yQs1yd3bzETazjVB4k519/yy0webIHmTNlhh8DttDAudbpoFzyug1bsJdoYWKo8BK2YKAXedzG7XvpOeEz5t12Di0b5C55G/zqt/y2N4Pbe55MrWrWgcxPotlLtA5wD3A65NSNqWr3aJ3DeKdKldzPn+AeEkmlC1+EqkJ79LBgzRRfQAK+63QQGjjXhvUolwKhwEc9uQaCpyyoQ0EwX5l57KMRZWyfrMupKo0M2GpUrsBvezNI25dhAZvPRLMNWzLwFs4k8EOBgcCOKKZvPHLssbB/f87zHixgKC/yJHfxDZ0AiIuzTgYmOgIS8F11jA3rcbjVq1ezdu1aDhw4EFp3/fXXe5ijkhMIDVwLcR7E7MGqzaNtwxYM4o7mdjquakV+/G0f23cf5JTjrVWTn0QzYKulqq+IyAhV/Qz4TEQ+i2L6xgM9e8LOnTnPq7GHlxnMepozmnGh9a++6kHmfOzgwYPMnj2blJQUgHoiMhpAVccVeKDxZQmbDZyb29ixY1m4cCFr166ld+/efPjhh5xzzjllOGBz/marEufh9GQFVcsGf+SEB2zhJYPh8qsqBSdgA9i+58DhG42notmC9pD7d5uIXCwibYHEKKZvPBA+hAc4VaGN2MwNTOcACQBUrWqdDCJdeumlzJkzh/j4eHAGkt7nPswRBCRwWBWO17KxErZw77zzDp988gknnHAC06dPZ8WKFRw8ePDIB8aowkwNVbLnd/4e7ThsobZvkekV0BmhVjUnYNuxp+z+P2NVNEvYHhaRmsCdwHNADeCOKKZvStmwYbmfd+cTbmEKT3EnX9M5tP7FF0s5YzEgNTWVjz76CIB77733V1X9h8dZihlxEkdWts9K2LJt4NxwCQkJBAIB4uPj2b17N3Xr1uXHH3/0OlslpqASqdJUmEFxw8dhy69KtKCC4krxzo+S7Raw+U40e4nOcxd3AedFK13jnfBeodXYwyvcyPecwgM8FFr/+utWupaXs88+m1WrVtGqVSuvsxJz/NhL1Ib1yK19+/bs3LmTm266iTPPPJNq1arRsWNHr7NVYgJFaAsWTUczl2ievUTzKbHO6/UEj7eAzX+i2Ut0OnmUsKpqUrTOYUpPcnLu548xkkZs5lwWhapCLVg7XKtWrRARMjMzmT59OieeeCJACxFZBaiq2ty6RxCQQKgK0i+CX3gWsDkmu93Bhw4dSq9evdi9ezetW5fdSzu8DZsXckrKClPClkeVaD6H5RXIBY/fYW3YfCeaVaLzwpYrA38Gtuazr/G5AQNylrvxKcOZzATu4Eu6ADY4bn7mzZt32LomTZpsBC4p/dzEpoAEQlWQfhGsorWALcfKlStJSUkh0x1Ne+PGjVx++eUe56pkBDxuwxZUUAlbMKjLq5do5HEF9R7Ncu+99Ax/NUsw0a0SnR3+XERmATbQQwzq2TPnRq7KXl7hRjbQjL/zcGgfG28tb40bNwZgwIABzJw5M7g6Q1U3ichMYEB+xxqHn0vYrNOBIykpiZUrV3L66acTCDhBrIiU2YAtv8CntGUdZQlbcOmwXqKFOD4j01/3oIluCVukk4FGJZi+KSHhPUMf5T6akMKf+Iz9OKPn3nKLRxmLIWvWrMn1XETigDO9yU1sCeDfNmzi4ZAOfvL111+zdu1ar7NRanKqFr3tJVq4cdhy7p1sN/g6mmxnWcDmW1Er3xeRPSKyO/gX+Ddwb7TSN6Xj2GNzlrvyGbcxiYn8tkDg2AAAIABJREFUlcWcG1pvpWv5e/TRR6levTorV66kRo0aVK9eHaAtsB2Y423uYkMg4L+ALTRwbsBK2AA6d+5crgK2nDZs3pz/aIb1CJ9LNFhaFtlWraD0gscctIDNd6IWsKlqdVWtEfb3lMhqUuNvw4blDJJbhX1MI4mNnMT9jA/t06KFR5mLEffddx979uzh7rvvZvfu3ezZswdgmarWUtX7jnS8iEwTke0isjqf7d1EZJeILHcfo6P9GrwWwMcD51oJGwADBw6kc+fONG/enNatW9OqVauy3ekgUPhG/yWpME07w0vhgqVtwVU//LrHmV7L3f7qV5vo9uSnuY7PcgO+jCwL2PwmKlWiIpIAXAsEv86XAu+oakY00jelI3wYj0cYxUn8SFc+I52qofURNX0mH4888gjvvvsuixcvBkgUkctU9V+FOHQGMAl4rYB9Fqlqnyhk05f8OKyHTU2VW1JSEjNnzqRVq1ahNmxlmddt2II/FApqwxYMJsPbsOWUsMF/1v9K0oylPHN1m1zlbSlp6bnSsTZs/lXsO01EWgHrgHOBFGATcCHwhYgcIyIPF3B4Yc/RS0S+F5GNIjKyuOmZw4UP43EunzOCiUzkNhbRNbT+9dc9yFiMGj58OFOmTAmOw7YfGCoizx/pOFX9HPi9pPPnZ3ES59uArTwEJ4XRqFEj+vbtS9OmTWncuHHoUVblN8VTaSnqTAfB0jJVWLdtDwDrftld4AC8wVK5g5n+KuU20SlhmwjcpKrzw1eKSE9gNVCsMhm3sfbzwPlAKvCtiMxV1fLTgKIUBIfxSCCdaSTxP07kPh4Nba9f34bxOBqfffYZq1evRkRISkpKA3oDq6KUfGcRWYEzbM5dqnrYPSYiQ4Ah4Hy5xhI/lrCFBs6N6mx+sevUU0/lmmuu4ZJLLqFSpUqh9WW1l2jAJ71ECzOsR55t2FRDHRDiRDiUlX9CVsLmX9EI2OpFBmsAqrpARA7hjMdWHB2Bjar6I/D/7J15nBP1/f+f7ySb7MF9itxyKmhRQbTehXpgK1r151XFq8hhxar1Qq3VYrW2XsULq3itVqvVUmtVRKt+rYqIoIBaULkVYbn3zPH5/TEz2clkspvdnc1kdz/PxyOPTWYmM++ZJJtX3ici8ldgIqAFm0d07lyb4zCLmQzmK47irZRQ6IYNPhnXQhk2bBhr1661ex36Ap96sOvFQH+l1G4RmQC8hFGRnYJSag4wB2D06NH5NZizHvJRsFmeDd2HzaCyspJIJMLrr7+eXJZtWw9zZNtIEVkF/EUpdZt9vYhEMFICDgTKgNOVUqtF5Gzg17ZN9wMOUEotEZEDMdIJioBXgBnKQ3dY7aQBnzxsDTh+iofNvB9NqGQ4NRiQlErSTM9PKIjFE4SC+j2fL3gh2AIiElFKpcyxEJFCIKqUqsjwvGzpDayzPV4PjHUcq8V6E/zGXmhwKP/HDO5hNtN5m6OS2+g2Hg2nrKyMvffe2xrXMwzjB8b7IjIPQCl1YmP2q5Taabv/iojcLyLdlFJbvLA7H8hHwaZHU6Uyd+7cRj0vHo8zffp0gP8Bo3GPmFwIbFNKDRaRM4DbMURbKVAKyVScfyillpjPeQDjO+ADDMF2HPDvRhnpgt+Nc92a4mbCLYctFk8kPWwBkZRt6np+TR2C7b9fbSGRgMOGdKv/BDSe4IVgewJ4QUQuUUqtBhCRARih0iczPy1r3MqyUt5tLdmb4DfW4HYrFLqG/lxDyg9e3cajEdx8883J+0cdddQG4GIv9isiewCblFJKRA7CyEMt82Lf+UI+CjbLWaOLDgwuvfTStGUdO3Zk9OjRTJw4MePzFi5cyODBg/n6669rlFI1GSImE4GbzPvPA7NFRBweszOBZwBEpBfQQSn1vvn4CeAkPBRsfg9/r2/ElB2798y6H43XethCAamzAtQuCmtiCYrD7tud9fCHAKy+7YT6jdJ4QpN/Liqlfge8CrwjIltEZAvwNjBfKXVL3c/OivUY4SSLPuiRV55hfbZv4QaGspILeYRy2iXXjxvnk2EtnCOPPJIBAwYQjUYBdgMLgcVKqbeVUm9nep45IeR9YJiIrBeRC0VkiohMMTc5FVhm5rDdC5zhZegnH8hHwZZsnCu6rQdAVVUVS5YsYciQIQwZMoRPP/2UrVu38sgjj3DZZZdlfN6GDRvo29f+75z1GFEUO8moilIqBuwAujq2OR1TsJnbr69nn4jIZBFZJCKLNm/eXP9J2vB7+LtFNh4+Vw9bIpG8Hwike9jiLs8B3Yst3/CkrYdSajbGr6D25uNdXuzX5CNgiIgMBDYAZwBnebj/NsuIEcbfQ/gvv+Iu7mcqb/GjlG3e0MPFGsXDDz/MnDlz2Lo1WfDZB3gQqFMCK6XOrGf9bIy2H62WfBRsuq1HKqtWreLNN98kFDK+QqZOncoxxxzD/PnzrcpoVzL8tnAurDOqIiJjgQql1LJstrcdu9GRGKs4OJ9niVqsKatgyMxX+NelhyfDoLG4reggIGmh1epYnOKw8VraPXS68CC/8DQhQym1y2OxZv3CugR4DaN9yHNuVXGahlFaCitWQCGVzOV81tKPq7k9ZRvdxqPx3Hfffbz33nt06NABAKXUSqCHv1a1DPK6rYfOYQMMT1l5eXnycXl5ORs3biQYDKZUjTrp06cP69atS1lEesQkGVURkRDQkdRWN2dQ612ztu9Tzz6bhN85bJYkTWSh2P65dCPRuOKFj9cnvWXReAIrCqpUaiUpQFW09vNmX6c9bPlFc84S9Qyl1CsYiaQaj5hiBthu5kaG8T/G8Qa7aZ9cX1Ki23g0hUgkQjhcm/xhfvG0qtBlcyEieTvpQAs2g6uuuopRo0Zx1FFHoZTinXfe4brrrqO8vJzx48dnfN6YMWNYuXIlQFhEwrhHTOYBkzBSA04F3rTC/iISAE6D2gaRSqlvzZGIBwMfAucCf/bsZMmHxrmYx89sgLVNMj9NbFWi8UTyubF4Iq1KdMXGnXy2YQdTjxpEPKEQMYRdTSzB3xevJxpPcPTwHvRoX+jlaWkaSIsQbBrv2b0bDuZ9LudOHuRi3nRE6qxiBE3jOPLII7n11luprKwE6AD8DWO+rqYetIct/7nwwguZMGECCxcuRCnFrbfeyp577gnAHXfckfF5oVCI2bNnc8IJJwzFiJg8qpRaLiI3A4uUUvOAR4AnzbYfWzFEncURwHqrzZONqdS29fg3HhYcQD4Mf69fMFqronHrvSq2HDZFLFmAkEjLYfv5I0YBwfmHDiCuFMUFQcpr4tTEE1z+3NLkdg+cfQDH79vLi1PSNAIvh78Xi8gNIvKw+XiIiLTa8Tktmd69a0Oh6+nDVfwhZX0wqL1rTeW2226je/fuVj5PNwwP8fX+WtUyEJG8E2y6rYfBF198AcDixYv59ttv6du3L/369eO7775j8eLFWe1jwoQJAMuUUoOUUrMAlFI3mmINpVSVUuo0pdRgpdRBdnGmlPqPUupg5z6VUouUUiPNfV7idSFOsujAy502gro8bLUetNoGubUeNpUMe9bEVcb2IDXxBPGEosjMZ3PmsC344nvA/5mqbRUvPWxzgY+BQ8zH6zG8Ci97eAxNExk/HjZuhNu4ieF8yY95nV10SNnm8cd9Mq4VEQgEOOmkkzjppJN4/vnnv1ZKPey3TS2FoARJkF+CTTfONbjzzjuZM2cOV1xxBZBeNfvmm2/6YVazY42myufGuXGbNw0Mm+192Kqixo8ONw+bRU0sQSyuKA4bxTXO8VTPf7yeTTureGTSmEafi6bxePnfZ5BS6g9AFEApVYl79Y7GRxYsgIP4kCv5I3P4BW/w47RttHet8SiluOmmm+jWrRvDhw9n2LBhAD8QkRv9tq2lEJAAiTo6sfuB9rAZXHTRRXz33Xe89dZbvPXWW0yaNIl27doxcuRInn/+eb/NazaSIUmf3paSRdFBmtdMaicaxBIqKdhiphfNjZqYsc4SbG5Vou+u3EJlNL9yTNsKXv73qRGRIkyvsYgMAqrrfooml4wYARGqmMv5bKA3V/LHtG1a8fzmnHD33Xfz3nvv8dFHH1FWVma19fgcOFREfuWzeS2CgATyz8OGbpwLMGXKlGQxzTvvvMO1117LpEmT6NixI5MnT/bZuubDbw+bRSa9ppRK85oFpDY8Go0nUkKidXrYEoqiOgQbkBR/mtziZUj0NxgNdPuKSClwKHCeh/vXNAGrjcet/JZ9+JxjeTUtFAowa5YPxrUinnjiCebPn0+3binjWmqAnwOvA3f5YlgLIkD+9WGLJ3TjXDBGS3Xp0gWAZ599lsmTJ3PKKadwyimnMGrUKJ+taz78bpwr1N1WxE1/BWw5bLG4SgmJZpolWmOuK7Fy2DJMRKis0YLNDzwTbEqp+SKyGDgYIxQ6ozXNN2zpzJgBo/mIq/gDf+FCXufYtG3GjdPh0KYSjUadYg0ApdRmESnwwaQWRyAQSAqkfEE3zjWIx+PEYjFCoRALFixgzpw5yXWxWMxHy5oX8TuHrZ7ju4U4BVL6sFXFbDls8ew8bG592MLBgA6J+kSTBZuIHOBY9K35t5+I9FNKZVc6pGlWdpVV8xjnsZE9uYI/pa0Ph/VUAy+w915zoSZXdrRkghJMhiDzBStE29Zz2M4880yOPPJIunXrRlFREYcffjhgTD7o2LGjz9Y1H743zjXJFBJ1E2xxpVL6sFkh0bqKDqpj8Xpz2Hp1KtSCzSe88LClf/vXosAx60iTc6ZNgxu5mRGs4Dj+zU7S/7E++qgPhrVCli5dmpxuYGN/EdkF6K6TWSDoxrn5ysyZMxk3bhzffvstxxxzjC0ZP8Gf/+xpr9q8Ijn83V8zMgrGmEuIM2orLrAXHWwrj6ZVf1pUmx624gwetnHDe7Dy+91U6ZCoLzRZsCmljvbCEE3zMG0aLHxgER9wO49wAa9xXNo2U6fqUKhXxOPp/8hE5BOl1GgfzGmRBAO6cW4+c/DBaW3QGDp0qA+W5I7aHDZ/G+dmOrybhy1q67cWs/Vhe//rsozHsapEiwrc+7AVR0LE4gntYfMJz3LYRKQQmAYchvFD5F3gQaVUlVfH0DSM0lJ45IFqPuY8vmMP11AowP3359gwjaYOhDxunOvt+GVNCyHg82gqCzdhppTiyr8tTVtu5KOZYdBEguosRJazrUdFTWpeYlFBgFhCacHmE17+93kCGIExw202sA/wpIf71zSA8ePh5z+HG7iFkSxnMnPYQae07YJtO4dak4fk42gq3Ti3bRPIog9ac1JX49w1ZRW88fn3actjidqQqFJQXpO5KOT4kXsAJIVYJBSgICjsqIymbBcOmYJNh0R9wcu2HsOUUj+wPX5LRNJlv6bZmTbNaJB7AB9zDbcxl/P4NxNct23FrZM0LZR8HU0lSJtv69FmSVZp+muG2/E/yBDijMZS+61lsv21y44gEgrw72XfUWEKsWBQ6FISZuP21ABZKBBga3kNv37+08adQJYs+HwTj773DU9dOFZ/5mx4Kdg+EZGDlVIfAIjIWOA9D/evyZKHHoICaniM89hETy7nTtftOnXS4VBN/hGUYF4WHbT1lh5tGb9z2CzPmtvx3/wi3bsGqUUHdREOBQiHDM+xJdhCAaF7+wgbtlembBsKpIqnSKh5PM4XPbEIpYxiiYKgFmwWXgq2scC5IrLWfNwP+FxEPgOUUmo/D4+lyUBpqTE+5Tf8jn1Zxgm8zHY6p23XqRNs2+aDgRpNPQQkkHfDpRMqocOhbZh8Gf7uFGDv/G8zr6/Y5Lrt2//bTFl5/Z2ECoKSFGyVZtg0GAjQvV2ExWu3p2wbCqZ+BsLNJNisj38srijQv5OSeCnY0ssPNTlnxgzYn8Vcx608zrm8wglp22ixpslnAhLISw+bFmxtF79HU1nHdTrMFq0x/pHv368TnzjEVTZiDVI9bM8tWg/UeticOWx2D9sP+nbim827sz+JRhBNJChCKzYLLycdrBGRzkBf+35149zcUVoKO8tqmMv5fE8PLuPutG20WNPkO0EJag+bJq8Qn6tErY+D83NRXh2jJByke7tIxucGA1JnaDQSDBI2PWdrt1YAEDAFm5OQLTxZEg42+6iuTBMZ2ipetvW4BWN26FfUeo5149wcMmkSXM+t/IBP+SnzXEOhWqxp8h2R/GycqwVb2yV/PGzpgq04EqJjUeapd0UFQXZXZ64QDQYlKdgsQgFxFYF2D1s4FCDezNfDrSFwW8bLkOj/AwYppfT4HR8YPx5Gxpcwk1k8yc95mZ+mbTN1qg+GaTQNRHvYNPmG30UH1mGds9h3V8doFwnRqTizYItmGOAO0KN9hKKCIAFHMUEwIHRvnz6YJRio/QxEQoFmF7Daw5aKl4JtGdAJcC9Z0TQbpaXw9oIoH3EeZXRlBve4bqcrQjUtgXz0sMVVXAu2Nkxy+LpPDh9Ltrh52EoiQfp2Kc74XLcB7gD9uhTzzlXug4pCGUKi9orNwoJgs4eItWBLxUvB9nuM1h7LgGproVLqRA+PoXFQWmo1yP09o1jKRF5iG13Sths3zgfjNJpGYA1/V0rlTQ8mpZQWbG0Yv6tEM7X1KK+OUxIOcfbY/gDsqopxx2tfZrXPqjqmFQQzCLagzRMXCTV/NXdUh0RT8FKwPQ7cDnwG6KucAyyxth9LuYFbKOUs5jExbbtOneCNN3wwUKNpBJYwyqfeZ3EVzxtbNLlHfM5hsw7r9Gjtro7Rq2MhwYBw7iED+HjN1qz3mcnzBkaDXPeiA3tIVHvYco2Xgm2LUupeD/enqYeLLoIQUeZyPlvpwqWkX34RXWigaVmkCLY8KelPqETeePs0ucfvHDZLKMaV4rsdVXzwdRkn7d+b8poYJZHar/ERe3ascz+diwvYVmG06qjLwxZXipJwkKKCYMrc0JDDw9bcArau/Lu2iJc+/o9F5PcicoiIHGDdPNy/xsb48VBVBVdzOwfwCVN4kK10TdvuST3NVdPCSAq2PHLU55O3T5N7/B7+bm/rce6jH3LZs0vYXR0zQqI2wVZYEOS/1/yIfXp1cN3PnHNH89fJBwN1e9h2VkYRSQ+LOqtElWpeERvzexZYnuGlYNsfOBi4FfiTefujh/vXmFizQkfyGTdyM89wBi9xctp2++wDZ5/tg4EaTROwBFs8kT+FB7pKtG3jd1sPSxQlEvDtDmO+ZzSWoLw6RrtI6g+JPTsVJUO4Rw7tzmPnj0mu61wcZsyA9BxnJzurDC9cmmALpgo2aF4RG28FOWx/X7ye4+5+x5N9edk4173cROM5DzxghEIf4zy204lf8ue0bTp1guXLfTBOo2kilidL+T4IqJYEWrC1ZcTn4e+JZA6bSib+V0bjVEZTPWwWVihx8hF7MbRn++TySChAMCD8avxQjhrWPePx9uhgtPRw9mIL2dp6WN62hFIEaZ50gWgryGG7/LmlACQSKq19SkPxMocNETkBGAEkG7gopW728hhtmdJSOOcc4/6vuYMDWcwpPE8Z3VK203lrLRcReRT4CfC9Umqky3oB7gEmABXAea1tmoiY//zzqbVHIqEFW1tG/O7DRm0OmxWe3WqOnioJp3+N15jhzuJwMGXepzWsfcb4IRmP9cLUQzign9F0va6QaO30h2YMibYCwWYRTSSIBJqWVuHZfyAReRA4HfglIMBpQH+v9t/WsSpClYIRLOMmbuJZ/h9/55S0bXXeWovmMeqey3s8MMS8TQYeyIFNOSVo/lPLp+a52sPWtqktOvDn+IlkDlutLdasUDcPmyXY2kVCSZEGdQ9rP3ZETw7ZqysH9u+SFGP9uxaniDR7W49cXBMv2noopTj+nnf5x5INHljUeGrqyBnMFi89bD9USu0nIp8qpX4rIn8C/u7h/ts0M2YYf4PEmMv57KAjlzA7bbtx43TeWktGKfWOiAyoY5OJwBPKUDMfiEgnEemllPo2JwbmAMvDdtfHd1EYSu+27gefl31OQSBzN3lN68b/HLba41u2lO022p2WRNK9NjWmZ6okEkoZO1WXYHvonNFpy35+cH/G7d2To//4HwAKbPvKxTXxwsMWjSs+/3Ynq75v3kH12djRVLwUbJXm3woR2RMoAwZ6uP82TVmZ8fdK/sgYFnEaz7GF1ByEceN0v7U2QG9gne3xenNZimATkckYHjj69euXM+O8YEjnIXQp7MLra17325QUjul/jN8maHzC/ypRa5ZorZdriynY2rl62Ix0guJw6tgp58zQ+igsCDKwWwnF4SC/Gj/U1cPWnNck5kFbjxpzH35XnHrRosRLwfayiHQC7gAWYzSFftjD/bdZSkuNv3uzgt/yG/7GqTzPaSnbhMNarLUR3LJW0/4TKaXmAHMARo8enT+xxSwYs8cY3j79bb/N0DQDr776KjOMcMFIEblGKXWbfb2IRIAngAMxfvSfrpRaba7bD3gI6IDRnH2MUqpKRP4D9KLWaXCMUsrTEYm+N841/36ydhs7K40KziXrtgOwV/d2adtffOQg7njty7RwaaiBgs1ixc1GlsZ/v9qSXJaLaxL1QGRZoch4hn2t2LiTt778nulHD27ysbKxoyl4WSV6i3n3BRF5GShUSu3wav9tmRkzakOhu2jPdO5L2+bRR30wTOMH64G+tsd9gI0+2aLRZE08Hmf69OnMnz+fQYMGLQfOFJF5SqkVts0uBLYppQaLyBkY03NOF5EQ8BRwjlJqqYh0BaK2552tlFrUXLb7XXRgiaL12yqTy95duYVu7SIM6Jo+R3T60YObRYDYq0STHrZm9Fx50dbDEkqZwqs/nf1/xBOKKUcOSvEgeoWIEdKu8cDD1uQsWhEZIyJ72B6fCzwH3CIi9Td80dRLWRlczp2MZSHTuY/N9EhZ/9RTOm+tDTEPOFcMDgZ2tKb8NU3rZeHChQwePJi99toLDKfRXyFtlt5EjDGHAM8D48zK6GOAT5VSSwGUUmVK5a6MuDZfK1dHTMVNFO2qijFmQOecTuCw92ELBpo/JOpF3ldSsGUQf5bnrbmmKlhXzAsPmxdlTw8BNQAicgRwG4ZLewdmSEbTeEpLYTifczM38gI/4zn+X8r6/v21WGtNiMgzwPvAMBFZLyIXisgUEZlibvIK8DWwCiPlYJpPpmo0DWLDhg307Wt3DifzL+0kczSVUjGM75GuwFBAichrIrJYRK5yPG+uiCwRkRskg4IRkckiskhEFm3evLlBtjdXReTOqigXP7komY+WiUyHHWLrsZYLQik5bMbffC86sDxbm3ZW8e7KzK+7Nfnh4zVb+XiNd32xrLdjvuSwBZVS1sTZ04E5SqkXMEKjS5qyYxE5DbgJ2Bs4qDld3vnKBZPivM357KYd07gfZwrTrFn+2KVpHpRSZ9azXgHTc2SORuMZGcKJzoWZcjRDwGHAGIz+gwtE5GOl1AKMcOgGEWkPvACcg+E0cB6/0XmdzZWv9ezCdby2fBN9Ohdzw0/2ybhdpsN2KPS0lWq92EOiOenD5mFI9LXlm3ht+Sa+vnWCawNbS1Cd8sD7AKy+7YQmHxsMYRvHG8HmhYctaOYXAIwD3rSta+q7aRnwM8CbuQ4tjGnT4JfxuziYD7mE2XxPz5T1JSXau6bRaFoGffr0Yd26dSmLSM+/TOZomt8rHYGt5vK3lVJblFIVGJ7mAwCUUhvMv7uAp4GDvLa9uYa/W5WLoXpypzIdt0NhblvN2EOizeV1tJ+rJyFRh1CKZzDYi5ClG1aborpmt2aLF4LtGeBtEfkHRpXOuwAiMhjDnd1olFKfK6W+bLqJLZP/PPgFv+N6/s7JPMvpaesfesgHozQajaYRjBkzhpUrV/LNN9+A4Uk7AyMn0848YJJ5/1TgTdOr/Bqwn4gUm0LuSGCFiIREpBuAiBRgTAlZ5rXtzdXCwvJO1TeyKNNx2+fcw9b8IVG7SPOkrYdDKGUKs2brAauKxtmwvbL+DS3E2n/Tr1OTBZtSahZwBUaH9sNUrTwOYEw9aHaakpuQt8Tj/EVdQDklrqFQ0N41jUbTcgiFQsyePZtjjz0WjBGGzymllovIzSJyornZI0BXEVkFXA5cA6CU2gbcCXwELAEWK6X+BUSA10TkU3P5BpqhnZSX4uSrzbvZZQ5Xt8RDvR62DFls7XPtYXOrEvVYxNqFU1N6p3353S52V8fSBZstzGr35mXrYfvlM59w6G1vZu1t9bLowBN5rpT6wGXZ/7J5roi8AezhsmqmUuofWR6/xfacysTNXe7mRt7nLErZ5HJ5pk71wSiNRqNpAhMmTGDChAmIyDLzxz5KqRut9UqpKnA0maxd9xRGaw/7snKMnm3NihXW8kKcjPvT2/ygT0f+cclhyfBcoJ5Kz0zH7VCU3Vf4Q+cc6IlgCNpCosm8Po8VW4pga6RXSinFsXe/w9iBXbj4yL1S1tn3WRmtLTTOtu3G/BWbACPEWVhQ/2xQSXrY8kSwNQWl1Hi/bcg3Thj8Jc/vvJ6XmMgzpOegB4Nw//0+GKbRaDRtEGuMrFc5bEvXG9lCltipr/9XpuNm62E7doSbT6ThFLjMFfU6JFqT4mFrnMixwo8ffrOV8w9NHbhk99ptq6ht5ddQQVtRE89KsAU8rBLV04zzjOlT4lz31QVUUsRUHsAtFPr44+nP02g0Gk3z4FWCvdMbZXnY6hds7stzncOW7Wiq6lg87VyVUkwvXVxnaw1IzfVqbN6XXeg5PWf2ddsrahp8LOsS2L1zdWFdsXwpOmg2RORkEVkPHAL8S0Re89um5qS0FMIP3cuh/JdLuZfv6JW2jYjOXdNoNJpc4lUOm7NCMVsPW6bj5rzoIGhv62H8ddqmlGLY9a9y/T9Saz+2V0T512ffcv7cj+o8RiwlJNpID1ssc26aPSS6o7LhHjZLqFbWxLLa3ss+bHkt2JRSLyql+iilIkqpnkqpY/22qTm555KV3Mp1zOOnlOKuyqZMcV2I2npzAAAgAElEQVSs0Wg0mmbC6U2KxRPc/59VVNY0bNiCMyfLCs8F68hhUypTyQFEQvWH5Lwk5OJhc4ZrLU/V0x+uTVm+dmsFAJ1Lwq77fmPFJs56+IMU4dTYooOo3cOWVnRgy2GzvX7ZCirrvCuyfO2tKxZt7R62NkU8zp3bz6eKQqbwIG6h0D331LlrGo1Gk2uc3qQXP9nAH179knsWrGzQfpw5WdZYJGdbj8qaONe9+Bk7KqMMvPYVz3udNRa3PmxOTVUVcxcylmDrUuwu2Jas285/vyqjPIOIOvCW+Tz5/uqs7LQ/r8Zhj30+qT2s+f7XZQy45l/17tt6LzjF+uK12/j9vz93eYJpR2soOtAY3Lf3bKbzHufyON+yZ9r6YBA2bPDBMI1Gk78kErD5C0hkF57JGQVF0G2I31Z4hlUlanmTrC9few5UNjg9bJZgc3qp/vrRWp7+cC1hWwjylz8azLaKGp76INVzlUtS23oYf50h0SpTyDhblViCrVOxe6GEJbLKq2vfy9b1SiQUZeU13PCP5ZxzyIB67UwJiTqEkj1XzS66rOrP+kh62Bw5bD+7/78AXHPc8JT5rkkPmwd92LRgywPO/eEqHlx5LS9zAk9yjus2utBAo9GksfhxePkyv61Ip9cP4OLWM6DG0h6WNikwhUtDQ3bO7a2cNqfosTbbbRMvoUCAkrC/X9lWrl1xOJgUJXHHOVleK7s3DmCdKdgyeQutpHz7OVvXq6HX2R4SdQolu71VNtFVHU33mL227DuunbB3yvJABg+b/XjhUHqEzIuiAy3YfKS0FM47N8GCxAXUEOZiHsJ9lJ4uNNBoNC5sWg7h9nDyg35bkkphB78t8BRn+K/A/EJuaFK8U9wk6hEkFbbE9oDUiqCfHdCbqUcOatCxveL3P9uXgwZ24evN5UC6AEsKtkBqxpU1HWBXtbs32PKw2c/ZCiE3tL2HPSTqFEr2dfaQqHM7y2N29XHDU0LWtUUH7oItlkgQtmWbWa95q+jD1lYpLYVzzoHp6j6O4F3OYy4b6e26bf/+OTZOo3lpGqz70J9jByNw6iPQY+/6t23rbP0aug6CvX/ityWtGmcOmyVGGhrmcn5pW0ItnmE/u6trRUEgIEmxMKBrCUN6tm/Qsb3izIP6AbB6iyHY0kKiUeMcnZWvVpL+7uoobljFAfZkfisk2mBPpu16OosOLAF1w0vLePKDNRm3S26vFAGbI8V6LzhDohbRmAJbmp71HvGi6EALNp+46CIYqL7iNq7hFY7n8eT4vFRCIZg1K8fGado25VtgSSnseQB0GVj/9l4Sr4HP/wmr/08LtmzY+jXsub/fVrR6RASR2lwzKz+roV6TbD1sljyocHijJOnp878KIVPRQWWGHLZqM/l/d5W7h83KNauoTi86yCRoM1GTUnTgnsP2wddlDvvcX8tYXGHvj2t52254aRm9OhQyfp+eqft3eAOtx7rooIUybRpUVyV4hAuJEWIyc8gUCn3sMR0O1eSYNe8Zf4+/HfoelNtjJxIwqyfsWJfb47ZE4lHjOo08xW9L2gQBkaQ4seSDm+fn4zXbOKBfp5TEc5Lbp35pV1uCxCnYzKfa87kCIrZE/0acgMfYvY5PfbCGmliCCw4bmMwLc+awVUfTc9Ts1IZEbR42K5zYwJBoioct7qwSNdZ9v6sagMKCAFXRREZBZbxmtYrNflaX/vUTVtx8XGoY13bseEIlQ8Y6JNrCKC2FGTOgrAym8QBH8TYX8Agb6JO2rQg8+aQWa5pm5rGfGB41OxVboKDYH89NIAAdesP2PBRsL06FjZ/4bUUtiZhx67JX/dtqmoxQ69myvnydX8ILPt/EhY8v4ncnjeTnB6fnsjgFnuX9iSUU17zwKSfs14vDh3Sv9bDZxItI5t5nfmC35fqXjCa5Fxw2MGMOm+XBisYV1bF4Wg+5ZEg0aoifcDBQ62FraNGB7XWxV4yCIf6qovFk09wOhQVURasz7stZ2WsPg3cwR4Nt3lVtW59wvV8Ta/prpgVbjigthUmTIB6HgXzN7VzNqxzLXM5P2zYU0p41TY7oMhCKOjsWDoEBh0EwuzmFntOpb/552HZvhqVPG9WPnfIoqbT3ATBYj2POBXYPWzK3yvFl/o2Z12Ul5Dtxbm+JlOpYnL9+tI6/frSO1bedkFzvLDrwauKCF2Tsw5bJw2brh7a7KkakXdCxPjUkGgkFkkKtoUPgU4SSQ1TH4ypFYJVEQgTLazKKQqfItp+HNWkik2CzP1eHRFsQM2YYYk0wQqEJAvyCh3GGQseNgzfe8MdGTRvkxD/7bUE6HfvBVwv8tiKVdR8Yf4+/A/qN9dcWjS/Yc9iSQsIRqrOEVKZJU/Yv8D++9mXyy39buXs/N3v4UBBbDlsjTsBjrHPM1NbDWXRQHUvQLhJid3WM3dUxuraLpKx3hkQjBcFGFR1Ux+LJFiLgNukgwfe7qpKPRQxvXmXCvYjAfn7xhErxsFmCrSKl2a9tFmos4Xq/sWjBliPKzPzGi3mIo/kPF/Ew6+mbso0WaxoNhodt13fwj+lkyu3MOd99ZlSv7jnKb0s0PhEOBZJeEiunyvpyfmbhWq79+2dc8eOhQPrkAjDEnt37MvutVQzt2Q6AMlOwFZheKUuYWRWXxjK7V8t/xWado92WeEJlLjqIJujePsLu6hi7XAoPLGFVaYZECwsCyescb0AO26XPfMJry2ub4DqLCWIJxfc7az1isbgiHApkHOZuf82qHNuEQwHTPuW6fbSOIfSNQQu2HNKf1dzBr3mdH/MIF6at12JNowEGHmFUqa56029LUhl1FoQi9W+naZVEQsHkl3+t58d4fM8bxoiqTabnJuBScHDX/P9x75urUpaVm+G/st2GYCs087rcRosGRBCxJiM06VQ8oTaHrXbZrqpoUtQE03LY4nRtF2bt1oq0woMtu6uTXirrmhTaPGx2r9WKjTtRKEbs2dHVLrtYg3ShFIsrtlTYBVuCgmDmKZ12MeYUf5atmcKg9lCuLjpoIZSWAqhkKPQi/oLTczB1qh+WaTR5SP8fwmWf+W2FRpNCJBRg1fe7mfveN2m5bCURQ2hZniOng+1OF7FmbG8kvpeVGwIiYvaPcPMri8C+vQ2R8oM+nZp0Ll5gnaNdiOyojKZ5qr7fVcX5cz8ioWrniNpz85RSjP5drbfC8tAVFrgXHUy4912AlFy/unDOEo0lVLJCFCCaUERCmQWbPezt9LBZY7Qyedis90fn4gL26dX0ZtJasOWAmTNhMnMYx5tM5iHW0S+5TgSmTNFD3TUajSafiRQEWPjNVhZ+s5VfHG70J7S+nNuZ1YLbKwwBFgwIm3ZW0bGogMKCIPdmGBJvdf3faoZE6xIOAREOHdyN/17zI/bsVOTNSTUBK2xrz9/aXhFNhnGtKRDPfLiO5Rt3AtDJFGyVNZlDhVaVaGEoyPaocT0b2jjXjrO5cSyeSBFssXiCknDQ+bQk9yxYxfSjB1EdTbC6zCgmuemn+7Bw9VY+Wr0tzT63kOhNJ45g4ij3xvgNQQu2HKDWrOGPXMl8xvMwv0hZ18D2MhqNRqPxAfsg9i1mCNP6om4fMb5KLeEVEGHsrQs4fEg3Hjs/cy/D2h5dxp3CAuMYbvrECpPmg1iDWg+bvRGu3cNmCRd7jltnc/C73cNWVeMQbMmigwCx3aniz86KjTt5fcV3XDZ+aJ12pjXOTSg27ayiqCBIZTSezGHLxD+XbuTfn32bIsp6diikT+di3vpis2Ffhtml1jWoK+TaELzZi8aV0lKIhBV/4SKAtKpQPXJKo9FoWgYRW7v773YYuWrOkKgl2KwQ2bsrt2QceeRG2Mxhc2sx4daI10+sHLadVbWjpnZURqmqsQRb+mD7TqZgs4dNnSFUKyQaCQXrHP7+09n/x91vrEwRc2796dJGU8UTbN5VzV7dSww7E3XnsLkdP1IQoF0kZAq+REquWswlJOoswGgsWrA1E9Omwc9/DudG/8KPeYNfcwdrGJCyjR45pdFoNC0De7hy005DsFltOdpFClKWW01ZAfa+8dWsjxFzydmyyC+5VivYdtXjYbOfS6dkDltmwVZhy2GzBI/b9Yi7iLmdbtWnLvNbv99VzeAeRoVufR42NwpDQUpMr2p5TdyRw2bc/2TtNj5eY4RMvfKw6ZBoMzBtGjzwAPRlLX/iChbwI+YwOW073RhXo9FoWgZ2wfadKcwsb1CxmQNliYftle4Dzuuj2jb5wIlb5amfWEWg9orP619axoCuxYBtsH0i3cP2+vLvGL5He44a1iN5DS2SRQehYDLUWFeFZTSeoND0ftob2FpUu3jwtpbXMLCb4WG76PC9+HT99nrONpWicDAZBt9dHSPqksN28v3/TS7TIdE8xRJroHiYXxAgwYU8gnJc6mDmHEeNRqPR5Bn2UUqWF6gqlkAphSJVYO1opGCzqhDd+o55FFXzDEtAWjlse3YsBGB1mdG0NhpL8On67bz3Ve3ou8JQkMKCAIvXbue8uR8BUOWo4rQ8YpGCYNJbVddoKns4csvudMFW7hCEzy9eDxh5aN/8fgLXHD+coT3b13e6KbSLhGhnNs3dXRUjntLWI/21c059aCxasHlIaSk8+KBx/wIe5Vhedw2FAkxOd7hpNBqNJk+JFKR/XcYTipp4Ik1Q7Khwn1xQH5Zgc/Ow5ZmDrTYkWm2I08cvOIgfDuoKwAH9OhFNJDhx9nss27Az+ZxIQYDicGpgr6rGvWGtERJNbVDsxoIvvk9OLrAXM1iUO3q+rTEFZY/2kWReoNUuJVtKIiHaJT1sUUeVaLqtBR4JNh0S9QD7UHeAPqzjTi7nTY7mIS5O237cON3GQ6PRaFoSkQxhrV1VsbRZl432sJkh0USLKDow/lo5bMWREHefMYpP1m7ns/U7WLp+R9pzIqEgRQWp4SW3CQMixhSBqEtY1cmVf1vKwG4llF40llXf705b7yZ+gwHhEFNcAuzXp+GCzQrDVkUTGdt6WIQCOiSaF5SWwvnn14o1UMxhMkHirqHQqVP1RANNZkTkOBH5UkRWicg1LuvPE5HNIrLEvF3kh50aTVvDzcMGxhxQp6BobA5bTSxBIqHcPWyN2mPzYQlIK4etJBykR/tCjh2xB6GguIqsSChAUbh+wRYKCAWBWg+bW5jRzjdbyvnhbW9y6ytfZGX7rJNGpnj69urejq4l4ayeC8a5Wl6zmliqh9VtUL0OieYJM2ZA1PbZPJ+5HM+rXM3trGZgcnm7dvDUU9qzpsmMiASB+4DjgX2AM0VkH5dNn1VKjTJvf8mpkRpNG8Wew2ZnW0U0JekcahvoNobqWHqIFfKw6MA0Z4d5rnYBlCnJPlIQIOg4D/u8VItgQAgGhIQyvI1uIqghhB32WBWe9uN9fMOPs95fKBhIVpZWxxL1jqDSRQd5wLRpds8a9GY9d/Er/sORPEDtrKmpU2HXLl0VqqmXg4BVSqmvlVI1wF+BiT7bpNF4yquvvgowsg4vckREnjXXfygiA2zr9hOR90VkuYh8JiKF5vIDzcerROReaYb4YaYpBFvLaxo0nNxJMOAUMPEmdfbPFZaAXF1Wzh4dClNaY2TK2YqEgikD0SGThy2Q3MdLSzY0eXC6s22HVTDQFKz3w98WrePvn6xPLnfPYdOCzTdKS6FbN6sa1MIIhYaIpYRCu3bVXjVN1vQG1tkerzeXOTlFRD4VkedFpK/bjkRksogsEpFFmzdvbg5bNZoGE4/HmT59OsD/yOxFvhDYppQaDNwF3A4gIiHgKWCKUmoEcBRgubIeACYDQ8zbcV7b7hRs1lSC7RU1TfIAdTDFg9VctSoWd+87lg8T321YQjOhSLbIsMjoYQsF0jxQbkUHATG8WACXP7eUu9/4X9Z2uUl1p4BsF3EXbM7zqIuw2ephwRffs6asInlct6kMunGuT0ybBueck+pZA5jE40zg31zDbXzNIADCYbjnHh+M1LRU3D7Vzv/S/wQGKKX2A94AHnfbkVJqjlJqtFJqdPfu3T02U6NpHAsXLmTw4MEANXV4kSdS+75+HhhnesyOAT5VSi0FUEqVKaXiItIL6KCUel8Zre6fAE7y2vaII1m+e/sIAFsr0nPYLA7oV/+Q9vbmHFKrR1lV1D0k6laI4Cd2YTTAIXRCdQm2WOp5uHrYgoEUkbNpZ3q7jkwUF6SHrp32lITdBduzkw9m7nlj6pzpauH02lnPicYTaRMXtIfNB6y2Hc4fOnuygbu5jHc4nPuYDhietUcf1WFQTYNYD9g9Zn2AjfYNzC8p67/Xw8CBObJNo2kyGzZsoG/fFKewmxc56WlWSsWAHUBXYCigROQ1EVksIlfZtl9ve76rZ7qpXmdnHlT7SAGRUIDtFUZbh45FBWnPuXniSNd9/f5n+ybvW94e6/mZQqL5Fia159Tt5RBsYZtH67wfDkjeN3qr1Xqg4gmVbGViJxiQRoscN7HofO0yedh6dCjk6OE96FxcfwGC02tXYIZxowmVFhbVRQc+MHNmulgDxUNcTJgaLuBRkABPPQVbtmixpmkwHwFDRGSgiISBM4B59g1Mb4LFicDnObRPo2kSbrMeSfciZ/I0h4DDgLPNvyeLyLg6tnceu0leZ2eVqAh0KQmbOWyKvl2K0ta7iTiAMw/ql7xvVU1aY5uqonHXnLi6Wlv4gV2w9TenG1jY21hEQgH6dDauTTgYSMlHq4klMlaJNlbkuL3H0kKi9eSwWd7OunB62IJBQ2TG4om0nLsC3dYj96xdm77sHJ7kJ/yLa/k9X8tgpkzRQk3TOExvwiXAaxhC7Dml1HIRuVlETjQ3u9RMuF4KXAqc54+1Gk3D6dOnD+vWrUtZhMOLjM3TbOatdQS2msvfVkptUUpVAK8AB5jL+9SzzybjLA6IJxSdi8NsK68hlkhQHA5x+Y+H0q+LIV6KCoLJXl11YXl/OhXVhkRbhoet9n7XdpGUdQU2MRMOBXj24kO4+/RRRm81h2DL6GGrQ+Qc2L8zPxrew3Wd228Cp7gqidT9ujRGsIUCRhg3GldpA+cLQtrDlnP69Ut93IuN3MMM3uUwnu7yS558UhcYaJqGUuoVpdRQpdQgpdQsc9mNSql55v1rlVIjlFI/UEodrZTKrvGQRpMHjBkzhpUrVwKEM3mRzceTzPunAm+auWmvAfuJSLEp5I4EViilvgV2icjBZq7bucA/vLbdKQSi8QSdSwrYZuawhQLCpeOGcNDALoAxXzRT7zY7lhDsaOWwOYoOLEdWUypRmwN7IW57h8eqwKbmwsEAvTsVcdL+RpT60EHdkuuqY3Eqa+L06VzEHafuxwn7GQGEkNnWIxNXHzecS8cNcV3nVpyRnm9Wt2DrkkVPNmeYNWSGcaPxRJpg041zc0xpKexOaaJshEILqeKNMx9lc1lAe9Y0Go2mDkKhELNnzwYjHy2TF/kRoKuIrAIuB64BUEptA+7ESB1YAixWSv3LfM5U4C/AKuAr4N9e227JACu8FksoigpCVJoeMUtgWOKgsCCYVfK65XGyGrdW1qQKNiuJvomdLTzHLqicOWH2/DOnWPrzWftz8ZF7AUYPs8ponJJwiNNG902ea7CekGg4FMhYeZlQirPH9kvxwPXvmn31J9SGp+tCRFJEWyhYK9iqHfNR9WiqHFJaasz+rKioXXY2pfyUl/n47Dv57VPuSl+j0Wg0qUyYMAFgmVJqtLVMKXWj7X4VcJrbc5VST2G09nAuXwS4Z/h7hem5KQ6H2FEZJRpLECkIUB2LUxCUpICwvsSLw8E0L4wbVqizS4kRVtxdHUsRbEXhEOU17nltfmLXS85GtHax5RRsxeEQ+/TqABiCrSqaoNDM47O2NfqwZb52kVAgowcukYBZJ+/Lrqoo+970OgBnj+3HKQf05oLHFmV1bmMHduHpD2tzoEovGsuKjTuZ9crnHDa41kNYEBSsriTW6x9zhESDAfFsrJgWbFkwc2aqWNuDb7mXS1kU+SGjH7/UP8M0Go1GkxMsDVUcDrKj0qgMjYQCVEcTFIYUQTPsZXnV2hcWZPVFbfXt6lJihEQrqmMp+WpFYWN/+eZhs5+b08NmF6puwssKSdbEEny/q5oeZosUa3kwIHX2LqvLc5kwhbW9dUckFOSHtlBsfUwc1ZuhPdtz/D3vAjBizw4cOrgbRwztniygcGIJs2hCUW0TbF71YAMdEs2K1GIDxYNMoYhKfl79KATrTyrVaDQaTcvGqj60qjoNwRakJp5I5rAByS9rK5etPqwWEJaHrTwtJGoIj3z2sDm9Xc6iAyeW4NpZFWXlpl2M2LNDyrZWeDET4VBmD5wl2AKOPLqGsrfpBYRa0Tlsj/Yp3kR7tlxB0GzrEUutEvWqBxvkuWATkTtE5Auzq/uLIlJ/F0KPKS0Fe77gmTzDROZxPb+jqv+wXJuj0Wg0Gh84ft9e9GgfYcoRRmP0aCxhetjiRBMJgmYYcMW3OwE4cmjdrUPuPXN/bvvZvsnB5h2LCggGhIoap4etViDmE3XNNk31bmUWbJ+t30Esodi3d0egVrDVl8MWCQUzrne7TNZ+n7pwLE9dODbjfjORSXQ56xtCgQCxRGrRgVf5a5Dngg2YD4w0u7r/D7g2lwe3ctfiZoy6J9/xZ37J+xzMnKLLmDUrl9ZoNBqNxi96dihk4czxjOhteF6iCVOwxVI9bNceP5xTD+zDmAF1e9hO/MGenHFQv6SHrbAgQHE4SHl1PGWqQVGy6KDlCDZ71aibd8sSUIvWbAVgpCnYIskcNqmzsjJSEMi4fr8+HTMe77Ah3ThsSPahUYtMokvZfGwJpSgIBYjGHSFRDz1seZ3DppR63fbwA4wS75yRmrumeICplFDORYG5PPhwUFeFajQaTRvDElCxuEoKtlhcJQXE/v06s3+/zlnvz/KwFRYEKQmHTA9b7Rd+r06FQG3bj3yhrvS8FMHm6mEzruHHa7bTqbggmRdmCbaA1FMlGgy4jur6w6n78eO9e6Zvn0W1bl1kykW0e9gSymhnUhNzeNjaaA7bBWQo1W6uQdf23LXTeZaTeYkbuIXP1XAt1jQajaYNYjXDjSVUcr5oVTTe6ORya3B8YShIScTwsNm9aWce1I/bT9mXXxy+VxMt95a6+qTZ87zcxJK1bMvuavbt3TEpiOw5bG7X86yxRjPUcDDg6rk6Ykh3Orv0UGtMDls2pAo2RXHEENw1zeRh812wicgbIrLM5TbRts1MIAaUuu2juQZdW41ye7CJ2VzCB4zlTi5Pa6Cr0Wg0mrZBkW16geURKq+JJXPYGoo9JFoSCVHuyGGLhAKcPqafp8nrXlBXSDSlD5trlWjtMiscat82mKGtxy0TR7Li5mMJBMQ1TGnl+zlpqoctE/aQqFKGZ3FXVYyaeG0fNq/miEIehESVUuPrWi8ik4CfAONUhkF0zcWsWTD5F4r7K6fRjt2cz1wKi4M6d02j0WjaKHZRYAmPqmgiKw/bgK7F/PrY4SnLrPBnKGjksFU4ctiaS2w0lWwdinV52ABG7lkr2KzJEJlmiQYDQrFZ0OA2uqoowyiwbBoYNwa7IoknFB0KQ+yqTvWweendy893gomIHAdcDZxozo7LKWefDa9e+DdO4e/cxG+p7L83c+boWaEajUbTVolkaFmRKUR45kF9k/ePHt4jOX7J4mRzZFNx2Mhhc3rYmiuc11SybQZbV1sPIFkhChAO2vuw1X3e9rYdz04+mIuP2CvN69bRnM/aXN5JuwcpoRTtIiF2VUUdRQetyMNWD7OBCDDffHN8oJSakosDl5bCndd8z6vrp7MkPIb9Hr6C287NxZE1Go1Gk69YQuXMg/qlzKTM5GH7/c/2Y3CP9tzy8grX9defsA9XHDOMwoKgmQMVzygK85Hhe7Svc71rWw/TE9axqIC+XWob0YZtVaINaYcxekAXxu7VNW35S9MP5b1VW+rMt2sKCeUMiRZQFU1QXm0LiXo0RxTyXLAppQb7cVyrncfcikvowE6OqpnL6qkhVFB71zQajaat883vJwDw6rLvksuCWXwxuyX1BAOSnBRQEg5SXh0jGKitCM1nwTbvkkPp36XuOZ1hl+byltdwZO8OKZ661D5s2Z93JkE2sFsJA7s1bI5oQ3CGRK3q2K3l1cnlbakPmy/MnAkTKv7G/+Nv3MRNrGAEFRXGco1Go9G0bUSMMURWzhV4M4KoJBKi3DFL1C1XK1/Yr0+netuNFITSr0tB0BCpBzjan6T2YWser1hzYYVEAcrKa5LL24yHzQ9KS6F8zWbuYzofMZo7+HVyXeqIKo1Go9G0Zewh0brCbtlKj5JwkIponGi8eXKg/MAtB09EmHfJofTqmDqXs9bDFmiBgs0IiQJs2FaZXN6WcthyihUKfYRf0pEdnM9c4rZLpNt5aDQajcbCHq6sS2BYrSvqmy9aHAmhFJRXxzhscDdO3r93UgS0VDKFdPfq3i5926C9SrT2efN/dYTryKl8IqGMKlGA1WXlyeVeFo1owWZj5kw4ruIFzuBZrmMWyxmZXFdcjG7nodFoNJok9oT6uvqwHTSwC4uuH0+3dpE691ditgzZWRWjT+ciTjmwjzeG+oCIkePVkBy8QjPEHAymFh0M6Vl3YUM+kFCKdqZg27SzmnAoQE0s4amHLX+D4zmktBQGDIDda7ZwP9NYxIH8gatSttHtPDQajUZjJ5sqUYv6xBqQ7DEWT6iUthUtkecuPoQzD+rbIA9Tsq2H1N/WIxe8dtkRvP6rIzKut9qGACQSKsUbukcHY6RYm5klmgusMGhFBZRyKZ3ZxnjeSAmF9u+vxZpGo9FoUomkhESb/sVcEsleAOY7YwZ0YcyAukPATuxVopaHLct2b83CsHpalrw0/VBe+Hg9s99alZx0YNGzQ4S1Wyva7CzRZsEa8H4SL3IWz3AzN7KMfZPrdShUo9FoNG6kVIl6EPqyPGxQd8eNowYAACAASURBVBFDa8Xeh01EuPzHQ/nnJYf5bFVmBnYr4ZxD+gOpVaIAPbSHzXvWroUulPEAU1nM/tzO1cl1/fsbYk171zQajUbjJNsq0WyxD01v6R62xmB5LK18wEvHDfHTnKywQr5xpSgsCNK5uIBtFVF6tjcEm5d92Nq8YOvXD2atuZSulHEMrxPDiEH37w+rV/trm0aj0Wjyl2yrRLPFHhLNphFva8PuYWspWDZbVayDe7Tjo9Xb6NnByFn0cixW23tHOHj85Jc4m6e5hRv4jP0AHQbVaDQaTf2kVIl6kcNmC4l2KGp7/pRQQOjftbje6QkWXUrCKYn/fmAJsoj5d1TfTkCtx1U3zm0CpaVG3tratbBv7618sGsKW/uP4ml1LbLO9LjpMKhGo9Fo6sHuCfLCK1QcrvWwdSkON3l/LQ0R4e1fH5319guvG9eM1mRHOBTg18cOY/zePQH41Y+HUhIJMXFUb373r891SLSx2CtCAa5cP4MQZXxw1ausuq5lNyfUaDQaTW6xz8H0OoetS0nbE2wNxcuE/qYw/ejasefF4RCXjR9KZY0xAF73YWskVkUowE+Zxzk8xSxmMm3OKH8N02g0Gk2LpEd7I1fJCw+bPcSqBVvLxvKsWb3lvKBNCTZrFmhntvIQF7OU/biV6/SMUI1Go9E0in3NsVPVsUQ9W9aP3WOnBVvLJhQM8KfTfsApB/b2bJ+tVrBZ0wsCAeNvaWntLNC7+BXd2cx5PEaUsJ4RqtFoNJpGccigrgDsro55ut+uJfVPRtDkN6cc2Ic+nYs921+rFGxWrtqaNcYsszVrjMcTJsDPIi8ziSe4letYwv66IlSTV4jIcSLypYisEpFrXNZHRORZc/2HIjIg91ZqNBqL8w8dyG0/25fTRns799PeNV+jgVYq2Oy5ahYVFfB//9zGk8UX83nBvszievr31zNCNfmDiASB+4DjgX2AM0VkH8dmFwLblFKDgbuA23NrpUbTeF599VWGDRsGMLIhP0hEZICIVIrIEvP2oO05/zF/5FjreuTqfMAoNjjjoH4pTXS9oKXPEtV4T6uU8Jly0n61/nKKg5vY+8N5VB+o8wM0ecdBwCql1NcAIvJXYCKwwrbNROAm8/7zwGwREaWUaswBf/vP5azYuLPxFms0LuyzZwd+89MRKcvi8TjTp09n/vz5DBo0aDnGD5J5Sin7+zv5g0REzsD4QXK6ue4rpVSmCrGzlVKLvD4PjSafaJUeNrectON5hfN5DK65Bg48MOc2aTRZ0BtYZ3u83lzmuo1SKgbsALo6dyQik0VkkYgs2rx5czOZq9Fkz8KFCxk8eDB77bUXgAKsHyR2JgKPm/efB8aJ+Dn+O/fcevK+XHv8cL/N0OQhrdLDNmtWar+1jmznYZnM9t4j6HTDDf4ap9Fkxu2Lyek5y2YblFJzgDkAo0ePzuh9c3pBNJrmYsOGDfTt29e+aD0w1rFZyg8SEbH/IBkoIp8AO4HrlVLv2p43V0TiwAvA79w8ziIyGZgM0C+PK83OGpu/tmn8pVV62M4+28hN698fROChkivoJd/R6cXHIKIrbzR5y3rA/o3WB9iYaRsRCQEdga05sU6jaQIZovbZ/iD5FuinlNofuBx4WkQ6mOvPVkrtCxxu3s7JcPw5SqnRSqnR3bt3b8wpaDS+0ioFGxiibfVqSLzyKqeXP0rg6qtg9Gi/zdJo6uIjYIiIDBSRMHAGMM+xzTxgknn/VODNxuavaTS5pE+fPqxbty5lEVn+IFFKVSulygCUUh8DXwFDzccbzL+7gKcxckE1mlZHqxVsAOzYAb/4BeyzD/zmN35bo9HUiZmTdgnwGvA58JxSarmI3CwiJ5qbPQJ0FZFVGJ6GtEo7jSYfGTNmDCtXruSbb74Bw5OW9Q8SEeluVlEjInsBQ4CvRSQkIt3M5QXAT4BlzX82Gk3uaZU5bEmuvBI2boQXXtChUE2LQCn1CvCKY9mNtvtVwGm5tkujaSqhUIjZs2dz7LHHAowAbrF+kACLlFLzMH6QPGn+INmKIeoAjgBuFpEYEAemKKW2ikgJ8Jop1oLAG8DDuT0zjSY3tF7B9vrr8Je/wNVXw0HaQ67RaDR+M2HCBCZMmICILFNKzYLsfpAopV7AKChwLi8HdNm/pk3QOkOiO3fCRRfB8OFw001+W6PRaDQajUbTJFqnh+3Xv4YNG+C996Cw0G9rNBqNRqPRaJpE6/Ow7dxp9PS44go4+GC/rdFoNBqNRqNpMq1PsK1ZA8OGwW9/67clGo1Go9FoNJ4gra2Fk4hsBtY04yG6AVuacf/5gD5Hb+mvlPKtU2cWn4l8fL3z0SbIT7vy0Sao2y79mWg4+WgT5Kdd+WgTZLYrq89DqxNszY2ILFJKteoOvPoc2xb5eC3y0SbIT7vy0SbIX7uyIR9tz0ebID/tykeboOl2tb6QqEaj0Wg0Gk0rQws2jUaj0Wg0mjxHC7aGM8dvA3KAPse2RT5ei3y0CfLTrny0CfLXrmzIR9vz0SbIT7vy0SZool06h02j0Wg0Go0mz9EeNo1Go9FoNJo8Rws2jUaj0Wg0mjxHC7ZGICJ3iMgXIvKpiLwoIp38tskLROQ4EflSRFaJyDV+2+M1ItJXRN4Skc9FZLmIzPDbJj/Jp9dbRFaLyGciskREFpnLuojIfBFZaf7tnAM7HhWR70VkmW2Zqx1icK95/T4VkQNyaNNNIrLBvF5LRGSCbd21pk1fisixzWST62fJ72vVVPRnIs2GvPs81GFX6/9MKKX0rYE34BggZN6/Hbjdb5s8OKcg8BWwFxAGlgL7+G2Xx+fYCzjAvN8e+F9rO8eW+noDq4FujmV/AK4x71+Ti88ZcARwALCsPjuACcC/AQEOBj7MoU03AVe6bLuP+VpGgIHmaxxsBptcP0t+X6smnpP+TGT33vP9NW6rnwntYWsESqnXlVIx8+EHQB8/7fGIg4BVSqmvlVI1wF+BiT7b5ClKqW+VUovN+7uAz4He/lrlGy3h9Z4IPG7efxw4qbkPqJR6B9iapR0TgSeUwQdAJxHplSObMjER+KtSqlop9Q2wCuO19tqmTJ8lX69VE9GfCQf5+Hmow65MtJrPhBZsTecCDJXc0ukNrLM9Xk8rFjMiMgDYH/jQX0t8I99ebwW8LiIfi8hkc1lPpdS3YPwzBHr4ZFsmO/y+hpeYoZRHbaGxnNvk+Czl67XKhnyzMV8/E/n8Grfqz4QWbBkQkTdEZJnLbaJtm5lADCj1z1LPEJdlrbLni4i0A14ALlNK7fTbHp/It9f7UKXUAcDxwHQROcJHW7LFz2v4ADAIGAV8C/zJD5sa8FnKt/ebG/lmY0v7TPh9/Vr9ZyLUFMNaM0qp8XWtF5FJwE+AccoMSLdw1gN9bY/7ABt9sqXZEJECjA9TqVLq737b4yN59XorpTaaf78XkRcxQhabRKSXUupbM1TwvU/mZbLDt2uolNpk3ReRh4GXc21Ths9S3l2rBpBXNubxZyIvX+O28JnQHrZGICLHAVcDJyqlKvy2xyM+AoaIyEARCQNnAPN8tslTRESAR4DPlVJ3+m2Pz+TN6y0iJSLS3rqPUdSzzLRnkrnZJOAffthXhx3zgHPNaq+DgR1W6KO5ceS6nIxxvSybzhCRiIgMBIYAC5vh+Jk+S3l3rRqA/kxkR16+xm3iM+F1pURbuGEkLa4Dlpi3B/22yaPzmoBR2fIVMNNve5rh/A7DcDl/anvtJvhtV1t/vTGq8paat+WWLUBXYAGw0vzbJQe2PIMRToli/AK+MJMdGCGN+8zr9xkwOoc2PWke81PzH38v2/YzTZu+BI5vJptcP0t+XysPzkt/Jup/7/n+GrfVz4QeTaXRaDQajUaT5+iQqEaj0Wg0Gk2eowWbRqPRaDQaTZ6jBZtGo9FoNBpNnqMFm0aj0Wg0Gk2eowWbRqPRaDQaTZ6jBZsHiEhXEVli3r4TkQ3m/e0isiLHtowSkQm2xyeKyDWN3NdqEenmsryjiDwhIl+Zt1LbGBDPqOtcROQmEbnS62NqWg8istv8O0BEzvJ439c5Hv/Xy/1rNM2B/ky0bLRg8wClVJlSapRSahTwIHCXeX8UkPD6eCJS14SKURi9Xyzb5imlbvPYhEeAr5VSg5RSgzD60j3m8TEgN+eiaf0MABr05SQiwXo2SflyUkr9sIE2aTR+MgD9mWhxaMHW/ARF5GERWS4ir4tIEYCIDBKRV8UY7PuuiAw3l/cXkQViDLBdICL9zOWPicidIvIWcLvZCftREflIRD4RkYlmd+6bgdNND9/pInKeiMw299FTRF4UkaXm7Yfm8pdMO5ZL7ZBhV0RkMHAgcItt8c3AD0RkmIgcJSIv27afLSLnmfdvNO1dJiJzzM7QiMh/ROR2EVkoIv8TkcPrOxeHTZmu5WnmsZaKyDsNf+k0rYTbgMPN99GvRCQoIneY78VPReRiAPO9+5aIPI3RyNL1syEitwFF5v5KzWWW50LMfS8Tkc9E5HTbvv8jIs+LyBemV9ptlqBGkwv0Z6Il4lcn59Z6A24CrjTvD8AYDj/KfPwc8HPz/gJgiHl/LPCmef+fwCTz/gXAS+b9xzBmowXNx7fa9tUJozt3CXAeMNtmT/Ix8CzGQFqAINDRvG91Xi7CGOfR1Xy8GujmOL8TgRddzvtF4CTgKOBl2/LZwHn245j3nwR+at7/D/An8/4E4A2n7S7nYr/Oma7lZ0Bv6xr5/d7Qt9zegN3mX+d7cjJwvXk/AiwCBprblQMDbdtm+mzsznCsU4D55uerJ7AW6GXuewfGvMAA8D5wmN/XSN/a1k1/Jlr2TQ9/b36+UUotMe9/DAwQkXbAD4G/2X5QRMy/hwA/M+8/CfzBtq+/KaXi5v1jgBOlNo+rEOhXjy0/As4FMPezw1x+qYicbN7vizFrrSzDPgRj/Ibb8vo4WkSuAoqBLhgjV/5prrMG5X6MIXSzop5r+R7wmIg8Z9u/RnMMsJ+InGo+7ojxnq8BFiqlvrFt25DPBhjjaZ4xP1+bRORtYAyw09z3egARWcL/Z+/d4+Mq68T/92cuuTVJk7RNW0gLFIMVWBEtCF+1Rku3sCp4QQQvFBeWuovihXWtrlRB0er604VdlCIqxVVQWZbWVaByKdWVW7mIXAqFUtqEtGmbpLlMkrmcz++P58x0Mpkkk3SSyeXz7muaOc+5PeeZ85z5zOfq7vM/5eeSDOOwsDkxCTCBbezpS3ufwP0qCQDt6vzchiNdOOpOey/Ah1T1hfSNReStI+mciDQAZwCnq2pERDbjhL/BeBY4WUQCqur5xwgAbwSewAmN6ab2En+bEuCHuHppu0Xk6xnnSY5TgpHdl4OOpap+yh+P9wBPicibVHWoB4sxPRDgM6p6T79GNxe6M5ZHMjeSxx6MzGeBPX+NiYLNiUmA+bAVAFXtAF4RkQ9DysZ/kr/6z8D5/vuPMfivjXuAz6T5gZ3st3cCFYPscx/wj/72QRGpxP2SavMn32LgtGH6/hLwJPDVtOavAvep6i7gVeB4ESkWkZnAMn+b5KTe72vFzmV4hrqWZH8GHUsROVZVH1HVNcB+3K9BY/qReR/dA/yjiIQBROQ4EZmRZb+h5kYsuX8GW3B+l0ERmQMsBR7Ny1UYRv6wOTEJMYGtcHwMuFhE/oLTWp3jt18OfFJEngY+AXx2kP2/AYSBp0XkGQ4FATyAE5ieSjp3pvFZnFnyrzjT4wnA3UDIP983gIdz6PvfA/Ui8pKI7MNN2k8BqOpunK/e08AvcMIdqtoO/BjnV3Yn8FgO5xnqWtIZbCz/zXdyfQb30PhLDuc0ph5PA3FxwSefB24CngOe8O+NdWT/ZT/U3LgRN/d+kbHP//jn+wtwP/Avqronr1djGIePzYlJiPhOgYYxKkTk9cDvcer03xe6P4ZhGIYxFTGBzTAMwzAMY4JjJlHDMAzDMIwJjglshmEYhmEYExwT2AzDMAzDMCY4JrABIrJQRLpk+Fpph3OOm0Xkm5Pt2BMdvzxKwyDrGkSkMU/n2Swil+TjWEZ+8NMEdIlfvs0wDGMqM60ENhHZKSI9/kM++TpCVXepanmyikC2L2cRUXF1NPPdp9NFpFtEBuQbE1cj9NP5PufhIq7u299naf+siGwdZJ/0sd/jC5nlh9sXVT1BVTcf7nEmExn3r5dxT39sHM7fKCK9IlKd0f5Xf57U5XCMkL/t0SM475/Er0sLrlqHP293jaD7I8I/535xtW0Lhoj8l7hk0xOGtM+w27/3GsXVjMzpe0VEzhCRnWPcTcOYMkwrgc3nff5DPvl6rZCdUdWHgEZcvbUUInIicDxwayH6NQzr8UtcZfAJf91gvE9Vy4E3AScDXx6Dvk150u9fXF2+9Hs6MwcSIjIW2cNf5VCCZ0TkzUBBhZp8IyLH4krFBXHVMozsnODfi+/GPQNWFrg/hjElmY4C2wBE5Gj/l2JIRK4B3gH8p/+r8T9FZIu/6V/8to/4+73XT+raLiJ/FpE3ph3zZBF5QkQ6ReRXDF2+I5sAdCHwu2QpJRH5ja+ZOigiW0TkhEGu5SIR+VNGW0o7KK4CwfdEZJeI7BWRG0Sk1F83W0T+17+eVhH54yC/ln8OvF1Ejko7xxtw5amGFTD9pIn34AS35P6j6pevuTvDf1/qa+7aROQ5XL26rOPgL6dMySJS7Z9jn7///w6mKRKR14nIg/5nsd//fCcMIvJNEfmViNwqIp3Ax0UkICJfEZGX/T7flq4hE5G3icjD/hg/JSJLhznNz+l/z14I3JLRj34aMRG5RFwpG3CJjAGe9efUh0Rkloj8Pu0z+K2IHOnv+x2c8HSDv/2/Z2rpRKTK10Tt8++LL4ukKoFc4n9mP/CvcYeI/O0w17gSV2nk52QIISJS5h9rV9qcLPbXLfXH8qCI7BaRT/jtJSLyfb9tr4j8UFzJtpS2SUTWiMgBEXlFRM731/0T8BHgK/61/4/f/lX/OjrFuQacnTHWg16vP9Y3i0izP9b/nbbubHEJVdv9z/DEYcYJAFV9EVepJX1eXyIiz/t9fFl8y4W4Kii/BZLuKF0iUjvcfWoY0xkT2DJQ1X8F/gh82tdYfFpVk19eJ/ltvxKnUfgpsAqYhcsMvVGc4FGEy+b/c1yR89+QoUHL4OfAO8T3xREnjHyU/l+Ad+GK7NbianYO0KTkyHeA43AP1dcBRwJr/HVX4LR9c4C5wFfIUujdL9b7AO7XdJILgd+r6v7hOuALQmcBL+WzX8DXgGP91wpG9ks/APwMOApXD7UH+M9Btv0GsAmoBuqA/xjBecaLDwC/xJWS+RXwBZyWaCmuz93AdQAisgDYiBu/GmA1cIeIzBri+H8C5ohIvTgN3ocZ2T2ZnFMn+HPqv3GfwY9x438UEAOuBVDVLwEPAZ/yt/9clmP+ECgDFuG0PRfTX6j8f7hKG7OAHwA/GaxzvqD3Cf+afgH8nYjMTtvkB7gfKG/FjdlXAE9EjgF+B3zfP8/J/jkBvgcc4+9Xjyt0/a9px6zDlQs6wu/7T0Xkdar6Q9xn+C3/2pOFt18E3ob7jK8Bfikic3O83l/iNKLH4+bUtf51n4L7DC7x9/spsEFyMAmL+9H2NvrP6724+64S+AfgP0Tkjap6EHgfsCtNO9zCEPepYUx7VHXavICdQBfQ7r/u9NuPxgkAIX95M3BJxr4KvC5t+UfANzK2eQF4J+5h8xp+YmJ/3Z+Bbw7Rt3uBr/jvl+NqX4YH2bbK789Mf/nm5LGBi4A/Zes7rghvN3Bs2rrTgVf891cDG9Kvc4j+fhx4wX8fwJnmPpDD2Hf6/bkPqPLXjbpf/nHP8N/vAM5MW3cp0DjEZ5gatyzHfROuZl5yOXVP4ATpG4G6CXJPn5HR9k3g/oy27cA705YX4AovB3BCw88ytr8P+Ngg52wEGoCv44TX9+J+UJT4Y1znb/cn4KK0/S4BNvvvQ/62Rw9xbUuAfWnLmcdLHQNXpi0OHJe2/jLg3rRzb0tbV+nvO3uQczcAUaDGX34JV80DnIm0DydsZu53JfCbLO0BoBc4Kq3tHcB2//0Z/vnK0tbfAXzZf/9fwNeHuReeAd4z3PX6n30c//mRcYwfA1/LaHsZeFuWbZPj34Gbv+r3s2iIPv4vcFnaNe/M9T4t9Fyzl70K/ZqOGrb3q2qV/3r/YRznKOAK32zQLiLtuIfLEf6rSVXTtUCvDnO8dLPoJ4BfqmoMUtFwa30zQQfuSxrcw3ckzMFpIB5P6/PdfjvAv+G+mDb5JpTVQxzrDmC+iJyG+3Irw2kWhuL9qlrhb784rf/56tcRwO605eHGPIVv4lonIq/6Y7wFqJLskcP/ghMyH/VNUQMCMCYAuzOWFwK/TRvfv+K+YGtx9/IFGffyabjxHIpbcHVcV5JhDh0NIjJDRG7yzYwduLqDud7jtThBKv0zfxWnqU2SXr8w4v8dLPBlJXCXqrb6y7/kkMZ2Lk479XKW/RYM0j4PKMa5VSTH+H/9fic5oKqRtOVXGeIzEOf+kH689DkFg1/vAmC/Oi1XJkcBX8q4F+bTfxwzeSNOM/hR3A+tsrQ+vldEHhHnytAO/C1Df6ZD3aeGMa2ZjgJbLuRSr2s3cE2a8FelqmWqeivQDBzpm1WSDJd64A5/n3cBH6T/F+BHcQXNz8CZP47229OPn6Sb/g/MeWnr9uNMfSek9XmmOodhVLVTVa9Q1UU4c8UXRGRZts76Xyy344TMTwC3qWp0mGtM7vsgTrv1vTz3qxn3ZZQkc8wjpI0N7ks0yRXA64G3qmolh0x2A8ZYVfeo6j+o6hE4k/gPZQwiiA+TzHu4EViecb+WqPMn3I3TsKWvm6Gq/zbkCVR34DTJy3EuAJn0uxfpP97Z5ti/4EyGp/qfwbuHuaZ0WoAETuBIshBoGmKfrIjIDOBcYJk4v9E9wGeAt4jzHd2L04Ydm2X33YO0J/d5fcY9PjNtm1ni+22m9T8ZFNXv2kVkEU7L/4/ALFWtAraR/ZmQrY+zRaRykHVXZXmu/XqoA6qq5z/7tgJf9ftYintGfBuY6/dxU1ofs32eQ92nhjGtMYEtO3txfjBDtf0Y+JSIvFUcM0TkPeLSczyEMzlcLs4x+oPAqUOdUFW7cQ+3nwGvqmp6eowKnFngAO4L8FtDHOovwAki8iZxDs1fTzuH5/f7ByJSCyAiR4rICv/9e8U51AvOzJHwX4OxHucM/SGGjg7Nxr8Dy0XkTXns16+BL4sLIKjDfcmm8xTwUV9jeSbOfJ2kAic0totIDc6fKysi8mE5FJDQhvviGWqcJgI3AN9K85OslUNO6j8HPiAiy/2xKRGRd4nIcBo2cCb4Zarak2XdU8CHxAWDHAekNJHqUugcoP+cqsAJ1W2+/9wa+pNtXiaPF8PNn2+JSLnvS/Z5nIlupHwQN98W40zjbwLegJvXF/p9vxn4dxGZ54/Z20Qk7J/vTHFBFCFxATMn+fvc5O8zx39m1En/wIcA8HURKRKXW/As/5qyXXs57r7bh3O5u8Tv77Co6m6cC8b14gI1wnIoyORG4DIROcXvY7mIvM8XYnPh27jn4hycRrHI72NCRN4LpP/Q2osTHNNTGg11nxrGtMYEtuxcC5wrLnoq6fD6dWC9r6o/zxeo/gHnmN6GM9ldBOBrmj7oL7fhhJo7cjjvepyGINO8dAvOPNIEPAc8PNgB1EVqXY17IG/H+f2k8yW/rw/7Zqd7cZolcI7Q9+J8zR4CfqhD5zjbAhzEmX8fG+baMvu5z7+uK/PYr6tw4/QK7pf8zzPWfxanoWvHmfLStUL/DpTitH0P40yyg3EK8IiIdOGc9T+rqq8MfcUF5/u4a7pPXOTon/GjaFV1Jy5I4Urcl+sunMZx2OeDqr6kqo8Psvp7OKGiBee8nik8fQ3nKN/u/6j5Pk6DfMDv310Z2/87h0y3389yvn/CabFeAR7EzafRmGpXAj9R1UZfm7rH1/D8Jy7iNogTBp8HHgdacT+ixL8P3oe7n1txAUJ/4x/3Ctz9+Shu3mzC3dtJGnFayWa/75eo6nZ/3U3ASf4z6XZVfRrnjP+ov/1i4JERXOPH/b8v4gSnzwCo6iM4rd2PcM+uF9O2HRZVfQo3R/9ZVdtx4/Q/uLE4F2cGTm77DPDfwE7/M61liPvUMKY70t/NyjAMwxhvxKWmuUlVjy50XwzDmJiYhs0wDMMwDGOCYwKbYRiGYRjGBMdMooZhGIZhGBMc07AZhmEYhmFMcMaiKHRBmT17th599NGF7oZhpHj88cf3q+qc4bccG2xOGBMNmxOGcYhc58OUE9iOPvpotm7dOvyGhjFOiEjOFRfGApsTxkTD5oRhHCLX+WAmUcMwDMMwjAmOCWyGYRiGYRgTHBPYDMMwDMMwJjgmsBmGYRiGYUxwTGAzDMMwDMOY4JjAZhiGYRiGMcExgc0wDMMwDGOCYwKbYRiGYRjGBMcENsMwDMMwjAmOCWyGYRiGYRgTnClXmsqYvmze1sK6LTvY3RZhQXUZq5YuomFxbaG7ZRiGYRiHjWnYjCnB5m0trNn4LC2dvVSVhmnp7GXNxmfZvK2l0F0zDMMwjMPGBDZjSrBuyw7CQaGsKISI+xsOCuu27Ch01wzDMAzjsDGBzZgS7G6LUBoO9msrDQdpbIsUqEeGYRiGkT9MYDOmBAuqy+iJJfq19cQS1FWXFahHhmEYhpE/TGAzpgSrli4illAi0Tiq7m8soaxauqjQXTMMwzCMw8YENmNK0LC4lqvPPoHaihIO9sSorSjh6rNPsChRwzAMY0pgApsxZWhYXMutl57GH7/0bm699LRJKayJyE9FpEVEnhlkvYjIdSLykog8LSJvHu8+GkZrayvLly+nvr6e5cuX09bWlnW79evXU19fT319PevXr09fVSYif/Xv4+tERABEpEZE/iAi2/2/1ckdRKRBRJ4SkWdF5MG09jNFnBCEUgAAIABJREFU5AX/WKvH6JINo+CYwGYYE4ubgTOHWH8WUO+/LgV+NA59Mox+rF27lmXLlrF9+3aWLVvG2rVrB2zT2trKVVddxSOPPMKjjz7KVVddlS7YHYW7f5P3cvKeXw3cp6r1wH3+MiJSBfwQOFtVTwA+7LcHgetx8+J44AIROX5srtowCosJbIYxgVDVLUDrEJucA9yijoeBKhGZPz69MwzHhg0bWLlyJQArV67kzjvvHLDNPffcw/Lly6mpqaG6uprly5dz991309zcDBBQ1YdUVYFbgPf7u50DJFVx69PaPwrcoaq7AFQ1mWDxVOAlVd2hqlHgNv8YhjHlMIHNMCYXRwK705Yb/bZ+iMilIrJVRLbu27dv3DpnTA/27t3L/Pnud8L8+fNpaRmYoLqpqYkFCxakluvq6mhqaqKpqQkglrZp+j08V1WbAfy/Sb+G44BqEdksIo+LyIV+e07zAWxOGJMfK01lGJMLydKmAxpUbwRuBFiyZMmA9YYxHGeccQZ79uwZ0H7NNdfktL9TnvVHRLK2k+UeziAEvAVYBpQCD4nIw+Q4H/z+2JwwJjUmsBnG5KIRWJC2XAe8VqC+GFOYe++9d9B1c+fOpbm5mfnz59Pc3Ext7cAAn7q6OjZv3pxabmxspKGhgbq6OoBw+qYcuof3ish8VW32Tf1J1V0jsF9Vu4FuEdkCnITNB2MaYSZRw5hcbAQu9KNFTwMOJk1IhjFenH322amoz/Xr13POOQPdxlasWMGmTZtoa2ujra2NTZs2sWLFiqQp1ROR0/zo0AuBDf5uG4GV/vuVae0bgHeISEhEyoC3As8DjwH1InKMiBQB5/vHMIwph2nYDGMEbN7WwrotO9jdFmFBdRmrli7Ka/oQEbkVaABmi0gj8DV8bYSq3gD8Hvg74CUgAnwybyc3jBxZvXo15513Hj/5yU9YuHAhv/nNbwDYunUrN9xwAzfddBM1NTVceeWVnHLKKQCsWbOGmpqa5CFeBW7CmTfv8l8Aa4Ffi8jFwC78aFBVfV5E7gaeBjzgJlV9BkBEPg3cAwSBn6rqs2N9/YZRCGQQf4LxObnImcC1uIl2k6quzVj/KeAyIAF0AZeq6nNDHXPJkiW6devWMeqxMZ3ZvK2FNRufJRwUSsNBemIJYgkdNkGviDyuqkvGsav9sDlhTDRsThjGIXKdDwUzieaYP+eXqvo3qvom4LvA98e5m4aRYt2WHYSDQllRCBH3NxwU1m3ZUeiuGYZhGFOcQvqwDZs/R1U70hZnMHwkkWGMGbvbIpSGg/3aSsNBGtsiBeqRYRiGMV0opMCWaz6py0TkZZyG7fJsB7L8OsZ4sKC6jJ5Yol9bTyxBXXVZgXpkGIZhTBcKKbDlmk/qelU9FvgS8NVsB1LVG1V1iaoumTNnTp67aRiOVUsXEUsokWgcVfc3llBWLV1U6K4ZhmEYU5xCRomONH/ObVjdxEnFWEdUjjcNi2u5GufL1tgWoW4KXJNhGIYxOSikwJbKnwM04fLnfDR9AxGpV9Xt/uJ7gO0Yk4L0iMqq0jAtnb2s2fgsV8OkFnAaFtdO6v4bhmEYk5OCCWyqGs+WP0dErga2qupG4NMicgau7lwbhxIqGhOc9IhKgLKiEJFonHVbdoypwDPVtHqGYRiGAQVOnKuqv8clAk1vW5P2/rPj3ikjL+xui1BVGu7XNtYRlVNVq2cYhmEYVprKGBMKEVFpedIMwzCMqYoJbMaYUIiISsuTZhiGYUxVTGAzxoSGxbVcffYJ1FaUcLAnRm1FybAlnA4Xy5NmGIZhTFWs+PsUYSI62493ROWqpYtYs/FZItF4v1qf+dDqTcTxNQzDMKYPpmGbAiSd7Vs6e/s522/e1lLoro0rY6XVs/E1DMMwCo1p2KYAhUqhkQvjrZkaC63eRB5fwzAMY3pgGrYpwER1tp8qmqn08e3sjbFjXxevHujmiV1tk+5aDMMwjMmJCWxTgInqbD9V0mwkx7elo5dXD0TojiZIeKCqk1IANQzDMCYfJrBNASZqUfKJqvnLZPO2Fi648WHe/p37ueDGhwcIYKuWLqKjJ8bezj7Ub1Mg7inReGLSCaCGYRjG5MN82KYAE7Uo+YLqMlo6e1O+XzD2mr+R+szlUh2hYXEts2YUsa8rCkBAIChCQITO3viEE0ANwzCMqYcJbFOEiViUfCzTbGRjNKWpcg0o6IomKAsHSCgERABnEu2LewU3PRuGYRhTHzOJGmPGeCfPHY3PXK5m2wXVZcwsC6MKniqKklAlGJCCm54NwzCMqY8JbMa4oMNvctiMxmcu14CNVUsXEQ4GmVUeJigQS3gERLis4dgJp9k0DMMwph4msBljxnin9RhNtGyuARtJbeHRs8qZVV7MqUfPYt3H38LlZxw3JtdiGIZhGOmYD5sxZuTiH5bPxLqrli7in2//C03tPSQ8Z64sLw5x5XuOH3SfkQRsTEQ/QcMwDGN6YAKbMWbsbotQVRru15ZuohxNkMBwCIC6gABU3PIwmCBmGIZhTHTMJGqMGcOZKPOdWPc7d2+jszdOQpXiUJB5M0uoLA1bnjTDMAxj0mMCmzFmDOcfls/Eupu3tfBiSxeeH7kZ95TX2nuJJzzLk2YYhmFMekxgM8aM4dJ65LOkVlJbl/wXEEEE9nb0WZ40wzAMY9IzrQW24UoSGYdPw+Jabr30NP74pXdz66Wn9fMVy2dJrd1tEeZWFOOheJ6i6l4xz7M8aYaRZ1pbW1m+fDn19fUsX76ctra2rNutX7+e+vp66uvrWb9+ffqqMhH5q4i8JCLXibhs1CJSIyJ/EJHt/t/q5A4i0iAiT4nIsyLyYFr7T0WkRUSeGaPLNYwJwbQV2MY75YQxkHwm1l1QXUYoGOCImaWEgkJClUBAqJ9TnvPxTIA3jNxYu3Yty5YtY/v27Sxbtoy1a9cO2Ka1tZWrrrqKRx55hEcffZSrrroqXbA7CrgUqPdfZ/rtq4H7VLUeuM9fRkSqgB8CZ6vqCcCH0051c9r+hjFlmbYCW74d3o3RMZQGbiQktXWhoHDM7BksrCmjtqKE1We9Iaf9TYA3jNzZsGEDK1euBGDlypXceeedA7a55557WL58OTU1NVRXV7N8+XLuvvtumpubAQKq+pCqKnAL8H5/t3OApCpufVr7R4E7VHUXgKqmJqaqbgFa836RhjHBmLYCWz4d3o3BGS+t1eFq60yAN4zc2bt3L/Pnzwdg/vz5tLQMnNdNTU0sWLAgtVxXV0dTUxNNTU0AsbRNG4Ej/fdzVbUZwP+bnMDHAdUisllEHheRC0faZxG5VES2isjWffv2jXR3wyg4Bc3DJiJnAtcCQeAmVV2bsf4LwCVAHNgH/L2qvpqPcy+oLqOlszeV1BVG7/BuZGcs8qwNxeHkUxsuZ5xhTDfOOOMM9uzZM6D9mmuuyWl/pzzrj4hkbWf46nUh4C3AMqAUeEhEHlbVF3PqjOvPjcCNAEuWLBmPanmGkVcKJrCJSBC4HliO+4X1mIhsVNXn0jZ7EliiqhER+Ufgu8BH8nH+VUsXsWbjs0SicUrDQXpiiVE7vBvZyaXSwVgx0goKJsAbRn/uvffeQdfNnTuX5uZm5s+fT3NzM7W1A+dWXV0dmzdvTi03NjbS0NBAXV0dQPqvozrgNf/9XhGZr6rNIjIfSKruGoH9qtoNdIvIFuAkIGeBzTAmO4U0iZ4KvKSqO1Q1CtyG819IoaoPqGpSxfEwbmLnhXw6vBvZKZTZeTT+aOkRqx09Uba3dLLzQIT2SNT82Awjg7PPPjsV9bl+/XrOOeecAdusWLGCTZs20dbWRltbG5s2bWLFihVJU6onIqf50aEXAhv83TYCK/33K9PaNwDvEJGQiJQBbwWeH6vrM4yJSCEFtiOB3WnL6X4M2bgYuCvbitH6JiQd3r9xzokAfHXDMxYdmEfymWdtJIzGHy0pwIcDQmN7DyjUVZUQTXgWfGAYGaxevZo//OEP1NfX84c//IHVq1cDsHXrVi655BIAampquPLKKznllFM45ZRTWLNmDTU1NclDvArcBLwEvMyhZ/taYLmIbMdZX9YCqOrzwN3A08CjOBeaZwBE5FbgIeD1ItIoIheP9fUbRiGQQfwJxv7EIh8GVqjqJf7yJ4BTVfUzWbb9OPBp4J2q2jfUcZcsWaJbt27NuR/pflbpplHTth0+hRrbt3/nfqpKw/ipnQDnT3OwJ8Yfv/TuIfe94MaHB5hGI9E4tRUl3HrpaaPqj4g8rqpLRrVzHhjpnDCMscbmhGEcItf5UEgNWyOwIG053Y8hhYicAfwrLv/OkMLaaFi3ZQexRII9B3t5YW8new72EkskLDowD4y32TkZkbqvs4+XWrro7D0UiJarZq/Q0cMicqaIvOAnFF2dZf1CEXlARJ4UkadF5O/GpWOGYRhGQSlklOhjQL2IHAM0Aefjcu2kEJGTgXXAmel5d/LJ9pZODkZiBAKSqkG5vzNKLNE5FqebdhxO5OZIuO7eF7l+88vEPY8gEFdobOvhyColFAzkHFBSyOCDHANxvgr8WlV/JCLHA78Hjh7zzhmGYRgFpWAaNlWN48yc9+CcR3+tqs+KyNUicra/2b8B5cBv/JIkG/Pdj2jcA8HVnvRrUCJ++wixTPmFYfO2Fq7f/DKeKuFgAAm42zogsKejb0SavXyWyxoFwwbi4NIfVPrvZ5JFK20YhmFMPQqah01Vf4/TEKS3rUl7f8ZY9yEcFHpi4HmKCCRd+oqCMvSOGYx3zrGJxEhTaOSbdVt2kPCUUMAv/S4QCgYICswqLx6R71nD4lqu9o/Z2BahbnyvJ1sgzlsztvk6sElEPgPMALLOERG5FFf6h4ULF+a9o4ZhGMb4UlCBbSJw3NxKXtnfRWdvnGjCoygYoKIkzDGzy0d0nELmHCskE0FQ3d0WoTgUIJ5wQje4IINIXEl09nHBjQ+PSOgaLzNuFrL9SsiMCroAuFlV/z8ROR34uYicqKr9VMKWJNQwDGNqMW1LUyVZtXQRRaEg82aW8Pq5FcybWUJRKDhiE1ihndULxUQo6bSguoyKkhAeiucp8YRHNOFklHmVxXmtCzrGZu9cAnEuBn4NoKoPASXA7Hx2wjAMw5h4THuBLV+RjIXKOVZoJoKgmhS6Z80oIhQUYp4iwJzyIipLi/ImRI5DgfhUII6IFOECcTL9NnfhyvMgIm/ACWxWGNEwDGOKM61Nopm+V98458RRm8Kma6mriVDSKdPvLO71Ma+ymMrSotQ2oxUi0++R1q4offEEXpqfY/WMoryZvVU1LiLJQJwg8NNkIA6wVVU3AlcAPxaRz+PMpRdpoZIpGoZhGOPGtBXY8u17lc1Z/fRFNazbsoOvbnimIM7448FEEVTT/c6SyW/TGY0QmX6PBAUiGRrUvoTS0tlHPDHyiOLByCEQ5zngbXk7oWEYhjEpmLYm0bHwvUqWuvrjl97NqqWLuP2JJlo6ewkKPLmrjYtveYwzf/DglEr3MRFrsuYrNUf6PbLnYG/WbTwl5S9nGIZhGGPFtNWw7W6LUFUa7teWT9+r5Jd9wlOaD/YhAkERdrZGply6jwJGVWYlXdu5fW8H0YRSFAqkhPFc+7q7LUJQ4MU9HfQNIZSZRdIwDMMYa6athm2sgwSSzvj7Op2wFhCXlDfh6bhHUU5HGhbXsmrpIsqKw8ypKGZeZcmIgwTKi4I0tfcOq0FLr1lqGIZhGGPBtBXYxjqjfVIgjCa8tNxgUBQMTIt0HxOBwzV7JwWx4fRnpmEzDMMwxpppK7ABzCgK0tjWw/aWLsIByavv1aqlizjYEyPhKb0xj95YgpjnMbu8eFqk+5gIHG7Kkc6+OEdWlRAYQoEWDJiGzTAMwxh7pqUPW3r0X31tOT2xBJFY/iL9kggQCgjRhKK42pZ98QTKyBPzTmYKVbrqcFOOJPdfUF1GU3sPca+/Ji0UAEEoCk3r3z2GYRjGODAtBbbxKCO1bssOKkvDzJtZSmdvjH2dffTGE0SiCdZ+8I15FVgKXctzKApZuiqZcmR/Vy8HIzH6Eh6hQIBzTjpiyDFLrntxbwddfQlmFAXxvIFmz6AINeVFHD1rZGXMDMMwDGOkTEuBLTNCtLM3RktHLzsPREZcdzKXc1SUhKkoCaOqHOyJ5V1YK3Qtz6EoZI3VhsW1nNvYzvWbXybhKSWhIBUlIW55+FUi0R30RBMo0NTWw3PNB7n2IycDpMZz/sxS9nf1sbezj4BASTBALOERCgZQVSQghIPTS1tqGIZhFIZpKbClm8o6e2O81t6LopSEAnkTeHIxx+VDMzbRi86PdfqU4XhoRyt11aX9PofnmzuI++Wrkt5nB3viXLnhGeqqy/qN55yKEvZ3RSkKCsfWVqS0pX1xD9H8+j0ahmEYxmBMS+eb9AjRlg4nrAHMLi/OW93J4aJQ81WXciLU8hyKfKRPOZyC69nGJ+WLJmkvoLGtJ+v2xaEAfX41g4qSMIvmlHPUrBm8eWG1CWuGYRjGuDAtBbaGxbWc++Yj2dfZRyTmkfCU6tIwlb4mKB8Cz3AVANbe9Twtnb3sao3wyv5u4onR5Web6EXnDzd9yuEKttnGZzB0kO0rSkKEAoERXcPevXu5+OKLOeusswAQkeNF5OKcOmIYhmEYGUxLgW3zthZuf6KJORXFzCgKEgwI7T1xOntjQP4EnvRSVbdeelo/p/bt+7rwPCUoQjyhvHawh3jCG7GgONb55A6Xwy1dNdJcapnauNMX1QwYnySqh14ApeHAgPHc19lLWyRGUVDY19nHno7enK7hoosuYsWKFbz22mvJpheBz+V00YZhGIaRwbT0YUtqtxKepqoPBAPQ0tFLMCBjLvCs27KDABDznLQg4iTnvZ19nLygekTHylZ0fryjRIfzxTuc0lUj8YFLauOi8QSdvXH2HOzlsZ0HqCororPXCWrHzCrjA2+az51PNQNOq5b0Y/vHdx47oKxVZ1+CmhlhZs0o7lfYfrjr2b9/P+eddx7f/va33XlU4yKSm6rPMAzDMDKYdgJbUrsVFCEogqpLfBoA+hJKbUXJmAs8L+7twOOQZkcVPCAR80YlKBayludYR6mOJJfaui07iMYTHOiOEkAQlJgH+7uiHFVTSigYIBLzOOdNdRwzu5yb/vQK3VGXtuOStx/D5WccBxwazwtufLjfuZMBHd+5e9uwwSIzZszgwIEDqaS6InIacPCwB8QwDMOYlkw7k+i6LTsIBwKIiBPUAkJIBAkIpx5d0890OVbEEk6zVxQMEJBDGp7SouCkc2I/3PJPwzESk+/utgidvXECuM81vQTo/q5ov75dfsZxPP31FfzkwiWccMRMfv14YyqgIWlWfXRnK83tPSlTOUA84fFiS9ewPnXf//73Ofvss3n55ZcBFgO3AJfnZVAMwzCMace007Dtboswt7KY5oN9eCie5xH3QBPQHomyeVvLmAtNRaEAPdEEEnDvVcHzlLKi4PA7TzDGMm1H0tQaicaJxj2KgkL93MpBNaALqsvYc7CXkF9LKr3EZySaYNueDoqCAQ5GoqnjZ2oHv3j7X1BgZmmYklCAaMLjtfZejqhyEaJ7O/pySqNywgkn8OCDD/LCCy9w4okn7gROZhr+QDIMwzDyw7T7AllQXUYoGOCIqhJQZzJToDgoRBPeqFJrjJT62gpmVxQRCjj/uVBAmF1RRH1txZiedywoLwry0r4utu3pYMe+Ljp6YnkJ2kgKUzsPdBHpi9MdjdPZl+D0RTWDCtSrli4iGBASqi5VS0aJz6C4z7izL5ESBjO1g529cbr64pQVhZhdXgyAorR09Drtnucxt6K433GzCainn346oVCIE044AaBXVWPAQ4c1KIZhGMa0ZdoJbEkTWzAghIIBwkFnmpxfVZp3c95QfQgHg8ybWcLr51Ywb2bJpMyYv3lbCwe6o8QTiucpkWiCV1sj7GqNcPqimsM69rotO4glEhzoipFQCAcDeKpcv/nlQQXqhsW1XNZwLAERYgmPcJrAFg6KH2Ag1MwIp3zQBuZoc2leACpLwxwxs5SiYCDl31g/p5xQsP+0SRdQ9+zZw+OPP05PTw9PPvkkTzzxBECZiDQAEyPXimEYhjHpKKjAJiJnisgLIvKSiKzOsn6piDwhInEROTcf50xPM9Eb9wgHhCOqSqgoyV8OtpH0YTSpLiYKyXqpNWVhPIWkBVKA259oOixN5e62CAcjMRdBK4LggkQSng4pUL+xropjZpURCgSQQICgOO2pAiH/s541o5hGP2AgM+daKBAgGDgk6bl6sCUp/8bVZ71hSJ+6e+65h3/+53+msbGRL3zhC1xxxRUAdcAXgK+MekAMYwLR2trK8uXLqa+vZ/ny5bS1tWXdbv369dTX11NfX8/69evTV5WJyF/9Z/914kfniEiNiPxBRLb7f1Nh8yLSICJPicizIvKg37ZARB4Qkef99s+O4WUbRkEpmMAmIkHgeuAs4HjgAhE5PmOzXcBFwC/zee5kfrRTj65hflVpSliD8Us6O1iOtslEUkPVHU1QFAxQGg5SEg6gcNiaygXVZfQlPCRNS6bqqg4MJlAnzagxT6mvLaeu2kWGzigOURR0/mj7Ovs40N2XSn+SKXxVlIQoLw4NKpANJ2yvXLmSBx54gJtvvpkHHniABx54AOBFVT1bVe8Y9YAYxgRi7dq1LFu2jO3bt7Ns2TLWrl07YJvW1lauuuoqHnnkER599FGuuuqqdMHuKOBSoN5/nem3rwbuU9V64D5/GRGpAn4InK2qJwAf9rePA1eo6huA04DLsnyPGMaUoJAatlOBl1R1h6pGgduAc9I3UNWdqvo0LutF3pnoSWcnOkkNVTRNsFIlJbwdjqZy1dJFhAIBEp6i6kyuHkpFSWiAQJ2M6lz1X4/T0tlLPKEpn7TScIDWSIxowiMgEE14tHRGU75wmcLXv517Et879yRqK0rY09HLvs4+uvtirNuyI6UxbFhcy6qli6irLmN3W6TfuiQf+tCH+N3vfsd3v/tdgPkiskZE1ox6QAxjArFhwwZWrlwJuB8pd95554Bt7rnnHpYvX05NTQ3V1dUsX76cu+++m+bmZoCAqj6kqoqLoH6/v9s5QFIVtz6t/aPAHaq6C0BVW/y/zar6hP++E3geODL/V2wYhaeQUaJHArvTlhuBt47mQCJyKe7XGgsXLsx5v4mQdHYys2rpItZsfJZgQPD8YuqqMKei+LA1lUl/tOs3v0w07qUCCNoiMT6a5h+XHukZT3h4Cq+2RigOCvOrSoklXL+SGraiYICKkhAP7WjlcrLnsNu8rYX2SJS2SIxwUKguK+6XXw4YNvfcpz71KSKRSFLDBk4j8OioB8QwJhB79+5l/vz5AMyfP5+WloHuD01NTSxYsCC1XFdXR1NTE01NTQCxtE0bOSRkzVXVZnDCmIgkJ+dxQFhENgMVwLWqekv6+UTkaFw09iPZ+jza7wnDmCgUUmCTLG2apW1YVPVG4EaAJUuWjOgYhU46O1wC1olMUuBde9fzbN/XRViEeTOL81YtIpnI9vrNLxP3PIqDAWaWhbn9iSbeWFdFw+LaVKRnwlO8tE8+6imvtfeS8DxKwwEWzSlPrVPVYc2qLR29BAXUg91tPYSDTtt3+W1PcsTMkmFTe/z5z3/m6aef5o1vfCONjY3NQANgJlFj0nDGGWewZ8+eAe3XXHNNTvurDnwUi0jWdoZ/9oeAtwDLgFLgIRF5WFVf9I9bDvw38DlV7RikP6P+njCMiUAhBbZGYEHach3w2iDbTjnGukLAeJEUeJPCZ2NbJGu1iNEKpw/taKWuurRfpYN04SiZB+6V/d0upYcvtam6dBweMLOsf564obR/KQFQXSRxIuEEwWjcoygkdEfjbN/XRV1Vab/9Mk3ApaVufVlZGUAYp1E4ZtgLNowJwr333jvourlz59Lc3Mz8+fNpbm6mtnbgXK6rq2Pz5s2p5cbGRhoaGqirqwM3J1KbcujZv1dE5vvatflAUnXXCOxX1W6gW0S2ACcBL4pIGCes/cL8RI2pTCF92B4D6kXkGBEpAs4HNhawP+NKvisEZBY9H+tccplkBlEAqf6c+YMH+eLtfxm2OkA2sqXeSBeO0v3oAhk62wBQXhQgHAzm7KeYPF9R0CU0TvTTBgjhQADPg1dbe9ixrytVBSFTCHzve99Le3s7X/ziF8EF1ezE+WkaxqTn7LPPTkV9rl+/nnPOOWfANitWrGDTpk20tbXR1tbGpk2bWLFiRdKU6onIaX506IXABn+3jcBK//3KtPYNwDtEJCQiZTj3mef9/X8CPK+q3x+bqzWMiUHBNGx+MexPA/cAQeCnqvqsiFwNbFXVjSJyCvA/QDXwPhG5yo8QOmzSNT4VxSFUla5oYtxMk/msEDDRtHWZ/XlpXxfxhDKj+JBwmq06QDaGqyWa9KMTIJpWiyokkFA4sqqM1We9IWc/xeT55lQU81p77yEzq5DS3gX8Y0cTHk1tPcyuSAzIo3fllVcCLvgAeBp4t6paLVFjSrB69WrOO+88fvKTn7Bw4UJ+85vfALB161ZuuOEGbrrpJmpqarjyyis55ZRTAFizZg01NSn/01eBm3Dmzbv8F8Ba4NcicjEuS8CHAVT1eRG5GzeXPOAmVX1GRN4OfAL4q4g85R/jK6r6+7EdAcMYf2QQf4JJy5IlS3Tr1q1DbpPpqN7U3gvAkVUlhIIBYgk9rLxouZj/MguLgzP11VaUpDRUuZLPY+WDzP5s29OB4JLfJn3JVJWDPTH++KV3D3ms9M+qNBykJ5YY8Pls3tbCP/3yCSLRBCJOWAv4Eab1teXc9bmlOfc9897Y3daDp1AScspoTf4nLq9bX9yjrCjIdeefPOj9IiKPA18G/kVVl+fcmTyRy5wwjPFERB5X1SWFOr/NCWMiket8mHaVDqC/OXJ/V5RgwCVlzSwQPhpSTuudxFrSAAAgAElEQVTDmP/ymVJkOLPheJPZnyK/MkA0cSg7S65RpLkkGW5YXEvNjCKOqimlLBwEEUIB4ciqErr64iPqe/r5PIXjasuZU17EkdWlxD3PpRhBmVdZwqI55SyeV8HM0nCqP/fffz/HHXcc5eXlfPzjH+e5554DeANOc/CjEXXGMAzDMHymXfF3OGSO7OiJEYkmUJyZK+ZBZ2+Mlo5edh6IuNxeIzSPrtuyg2g8wYGueL80Epnmv3ymFBnObDjepPenoydGPOER9dNrdPREU1rMXIXTXCJ5k+dMjwZNahlHSub5DgVU9CACcytKqPTN2ZnjfMUVV3DjjTdy+umnc9ddd3HaaacBHFDVt4y4I4ZhGIbhMy0FtgXVZWzbc5D2SDwVS570VdrdGiEQEEpCgVH5gr24t4OO3jgBv5RSPKF+vc2Bkeb5SimS9OOKROP9zIaFSgCc7M++zl4OdEcBp8oNBYXG9l6Oqy3nyvcszqt/3WjHIBfzdXok7JqNzxIKutQE2c4hIjQ0NADw/ve/nzlz5tDZ2Tm+ESCGYRjGlGNaCmynL6rhoR0HAJcMLt2Lz1MnXMwuLx6Rc3ySmO/4HvBDFkXA87SfQzzkNwfbREsA3LC4lnMb27n2/pdIeEpAXDLd2soSItE4VWVFY9K3snCAVw44M/Ci2TOGFQpTpawSCQ5GYjQf7OGJXW1c1nBsKgdc5nUlx3n73g6iCaUoFEiZzxsW19Le3s4ddxzKLOD7iFaJyAf9ZUs7YBiGYYyYaSmwPbSjlYC4XF1wKINvUqQ6YmZpyuQ1Ul8wVSWeUGKJBAFxplZBKAodchfMd1TnREvAu3lbC7c/0YQAxSEBhLZIjNKiIOXFobz71qWPZ31tOT2xBN3RxLD7rduyg1giwYEuV2Q+mRz3+s0vpxLzZpJsW7PxWWb6gRDpn9873/lOfvvb36a2f+c738krr7xSBbwPd4uZwGYYhmGMmGkpsCWd4uMJTWnCFKU35lEcDqSENRiZL9jmbS1EE0ogAJ7ntHWqUFUWpL62IrVdetADZM+UnysTIaVHpsDY1t1HOCgUhwKpMfZQ9nX2EQxI3n3rhhvPwQTa3W0RDkacsBbwi6EGBeKesvau5wcVgoc6360/+9mA/t188807VfWTeb1owzAMY1oxZJSoiHSKSEeWV6eIZC3/MRlYUF1GRUkID1dUXFVJeEo4KJQXh0Ydubluyw5qZoQJSoCiUICScICAQHtPnO0tnamEtvmM6kxqifYc7OWFvZ3sOdhLLJEYdZTrSMkWFbt9XxfxhMfs8uLUGIPSGx8b37ps4xlPeDyxq40l3/wDq/7rcV7Z3zUgandBdRl9fuH6hKf0xRP0xj3inrJtbxdP7m4jKAyI9J1oUbmGYRjG1GdIgU1VK1S1MsurQlUrx6uT+WbV0kUUhYLMmlFEKCjEPSUgwmfe9Tq+d+5JQ6aQGIrdbRFmzSjmiKoSQgEXcJDwfeLmVZakvvgrikP0xPqb7EYb1bm9pZP9nVHiniulFPeU/Z1Rtrd0jvhYoyFrxYZAgL2dfVSWhjliZimhoJDwYEZRaMT57XKp4JCsdpCkoydGU3svAkT64njqAj86e+P90rasWrqIUCBALO4R9QvHpxNPKK8d7CWe0H6pXjLPB4WNyjUMwzCmPiMyiYpILZDKk6Cqu/Leo3FgOCf90ZoSk6klKkrCVJSE2bGvC/FTe6Rn+FfVVA62w43qjMY9SDPpiYAn6trHgWwVG+ZWFtPY3kskGqeiJEQoKKNKRpyruTczQnRvp0uEPG9mCU3tPQQDgnqwv8sJkaXhINtbOll71/PEEx6JQXJHx30JzplFS1MatIkWlWsYhmFMfXJKnCsiZ4vIduAV4EFcXcS7htxpApPu05TPiMrMZLi9caeFmV1enNqmNBykO5oYNhlsroSDTlBLmnY9X8goCspQu+WNbNqmUDDAcbXlh319udZbzUyuq+qqVlSUhFM1QUUOJe490N1HeyTKS/tcwfhMMls8hab2XsqLQ6l7p7svxr7OPvZ09Ga9vraOTr76ta/zyYsvdscUqReR9w53zSJypoi8ICIvicjqQbY5T0SeE5FnReSXwx3TMAzDmPzkWungG8BpwIuqegywDPi/MevVGLF5Wwtn/uBBLr7lMZ7cld0/6XDIFByKggEEeO2gKxTe0RMbYDo73MJgx82tTJl2E6qEgsKsGUXUzx0fi/VgFRu+dOZibr30NL5xzokAfHXDMyMuSj8SX7H04vNvXlhNyK+uMKeiOFXEvSgYIBKN09odIyAuT14wEPAjeR3ZxNxkW2dPlDUbn2XngS56ogm6o3E6e+O89ZhqTl1UQ3skyp6Dvezc383HL7yImAZ5+KGHk4dpBL451PWKSBC4HjgLVzD+AhE5PmObelyZq7f5dXU/N9QxDcMwjKlBrgJbTFUPAAERCajqA8CbxrBfeSdpXtvZGiEoggLNB/tIeC4Fx+W3PTmkn1SuJAWHb5xzIuXFITx1X/ixhEdTew8He2Kcvqgmp/JVuZD0x5s3s4TXz61g3swSikLBcTPPDVU66rp7X2TVfz3OYztbaeuO8sr+rhFdZ66+Ypl+bqcvqkkJkeXFIWaVhwmIUBoOUFtRQnlx0JUD9SWxUODQNFAGCtGKix7d2xklGo+nfAZDASHheVy/+WU2Pvkard1RIlHnM7dr5yus+sznCYWduVhVe8guD6ZzKvCSqu5Q1ShwG3BOxjb/AFyvqm3+cS0pr2EYxjQgVx+2dhEpB7YAvxCRFmBkRRoLTNK8lvCUoAgiLtXEnoO9JDxFgYU1ZXlLi7Fuyw4qS8PMKA6xr7OPaMIjFBDmlBfz0I7WvKX1mAhJc7NVbNi8rYXrN7+Mp5oKwDjQHWXWjKKcrzPdVyye8Njb0UfM8wgHhM3bWvpVH0j3c7v9iSbOffORPLSjlca2CEfPKufbHzg0Jhfc+DBP7m5DPSe0BQOCp+7eCAUED/BUUYUgrkJDNOHukT0drnJDOODuoYAfYXrbY7s5dVFNqu/hcJjenh4k5VsoxwJ9w1zykcDutOVG4K0Z2xznH+//cN37uqrenXkgEbkUuBRg4cKFw461YRiGMbHJVWA7B+gFPg98DJgJXD1WnRoLks7xRUGXG0zEJbntS1YmEOjsjVNZGh618JTtfCJCRUlKy8LBnhidfXGCAjv2daXqjc4uLxp1Woh8lbjKJ+u27CDueYSDAQRx2izPjXGu15kURr9z9zZ2HogQDgp1VaXEPE0J1YPlRHtoRyu3Xnpa1uOuWrqIf779L7RHYqjv+6cKNTPCfO29JxD3lNV3PI2nLodc3BfW0ol5SjLUoigUYE9HT7/1n/uXf+WT53+A1xobAY4B7gMuGuaSs2ngMk8dAuqBBqAO+KOInKiq7f12Ur0RuBFgyZIlh2t5NwzDMApMTiZRVe1W1YSqxlV1vape55tIJw1J81oyN1jML0ieJIDzNevoieUlp9ZQ5rzyoiBN7S5dRLLeaFN7LzOKgoMcbfKxuy1Cse/wn0QE+uLeiNJfNCyupaqsiKNnlVFfW0FlaVG/4IOR5kTzPOW0Y2dx3lvqCAUgmlBinvN1++LfLubEupm8aWEVM4pDTtvm6aBRpDFPUZQZRUHmVZb2W/f2hnfzw5/9gutu+DFAK7BEVTcPc7mNwIK05TrgtSzbbFDVmKq+AryAE+AMwzCMKUyuUaLpCXR7RSQx2RLnJp3jQ0HhiJkleL4kIUAoAOFQkADC/q6+vOTUGswZf9XSRSkzGZL2gkPtk4Dh8qMtqC5jZlkYVd+8iJJQlytupP51QwllQwnG8YRHT9TVCd3X2UdjW4SdB7q584km/uep15hTUUJ97QwWVJcOGPujamYwp6KE2ooShqKqNEw4FOT8Uxb0a7/ndxsJhUL87ZlnARwE4iLy/mEu9TGgXkSOEZEi4HxgY8Y2dwLvAhCR2TgT6fhkSTYMwzAKRk4mUVWtSF/2v3hOHZMejRGZvl7hYIB5lcWICK+19zoBTpS+uOYlp9ZQvmVf3fAMR1aVsL8rmjKJzqsspqtvcrgF5pIf7fRFNTyxq42456HqTM6hYIDLGo7NyXybnnqloydGPOExJ014Sgplq5Yu4soNz6AaozjkcqJFEx4fOPkIdrVGeHRHKzdueZnd7c5kuaC6DHy/uqQQmMyllu6Hdv4pC7j2/u0c6O7vdhb2tW4ezretrnoG55+yoJ//WsJTvv/dbzHvpKX8paUZAFVtF5Gv4QSurKhqXEQ+DdyD80/7qao+KyJXA1tVdaO/7m9F5DkgAXxxsmm7DcMwjJEzqlqiqnrnYDmiJjLpvl4X3PgwLZ29lBWFOKIKmtt76EsoAnkzTQ7mW5ZMsLtoTnmqLRKND6vNmSjkUrvz9ieaqC4L09kbpy/uEQwIlzUcy+VnHDfs8TMFwoTn0dIZRVWZVV5MTzRBNKF8ZEkdr5tbzmXveh23PbqbPR09zKss5fxTFrDk6Boe3dHKd+7ZRkdPjGS6tVcPdOMpzJ9ZjJOJHCXhgX5opeEg0fghe2goABIA8UNJP/7Wo6gqC/N0Uzv3btvL3o5e9nb0sb+rj8b93Xz+V3/JvLRh55uq/h74fUbbmrT3CnzBfxmGYRjThJwENhH5YNpiAFjC4acQKyjpEYiqzk8pFBCOrCohmvDyEik6WNHx4TLlD7bfRCFbdYN0v7GkQDeztIQ5vm42GQhweQ7Hv+HBlwkFoDgUJOEpM0uLiCeUrr4EItGUUPbGBVVE4x6nHlPDqcfUDDjObY/tpjsaJyBCICmxqZJIKPu7o5QXH7qG3pjHvMpSVJUHtu3jRw++DOCn7nBBBwnvUPUDgJ/9eeeg11A073W03vdjFr79AwBFIvID4PEcLt8wDMMwBpCrhu19ae/juEoHmfmhJhXpJssndrURCgjzZpakIjoPN1J0OLPhYObSXMsxFZKkhjCpYYP++dGGE+iSeJ4S8zz64h5R/xVPKK8c6KayJEQ84dHVF6ctEiWW8BARPrfsuH7mx6Fo7ujB8+vEHsJpUWNxZX9XHyJOWIt5Sm/M48xr/0hskCiDzNZgQKitKGZuZTG1FSXMrSxmbmUJcytLqPjIjfz3T67jsQevAzgW+B1wWU4dNwzDMIwMcvVh++RYd6QQJE2Wb//O/akUHEkON1I0Pe/bK/u7iSY8giJ85+5tqfNmE8CGMzdOBIbTECYFutKwS1CLQnc0ztzKElo6eokmnGDmaXbBaH5lKQe6XVLjls5elxYEF5tx7f3b+Sz1gwptPbEELb5pMhwI4KnzKYOBqTlaI7F+y/u6hkuTBsVBoSgUYEHNDD7+1oWcduysQbf98te+QWVpmDkVJc+r6peHPbhhGIZhDMKQApuI/AdDmD5VNRcL14RhMFPjcBqj0Zzj0Z2tfsJYj1Aw4JKzesqLLV2ppK/ZyFU7NVbkYo5N1xDubu3miKoyPvn/juakBVW0dPRy7puP5Ht/eJFo3KMkHKA35hH3lHPfXJdTYEW6w7+Ak9RUmF1eBMBP/+8VehMJ9nb0+X5jTkBr6eilozf3wI3qsjBzK0uorSxmbkUJf37pAH3xBPu7o/22SwqLHlBbWUJJOEBnb4z/eOAlAiJZhcdXXt7Oj394HXubdgMcJyL3A6jqu3PuoGEYhmH4DKdh2+r/fRuutuGv/OUPM8n8cdJNjUGBJ3e3cfEtWzmutpyzTpzH7U80DaoxGs05ioNCJOaKjQc8JeTXFQ0HGVJblk/hcaQMZo5d43m87XVziHlOMxZLeBxbW863Pvg3aJqWrC3iBJ2Tj6rms++u57bH+gcCDGfKTHjKvq4+iosCvON1s7n9iUa/cLszazYf7Ev9evj6xueGPFbQrypRWhRkX2cvkWgCAeZUlPCxUxdyxvG1FGekCtmyfR/VM8K0RaL9cq8ly1UFYMjI0nQ+ffGFfHTlxfz931/M5vvvawS+OGSHDcMwDGMIhhTYVHU9gIhcBLxLVWP+8g3ApsM9uYicCVyLC9e7SVXXZqwvBm4B3gIcAD6iqjtHc66kqTGeUHa39aDqvoRf2NvJvq4+LjztqFQpo9GWd0o3Z9ZWlrDzgNOKJVQJeIqHckRFyZDasuHMjfkk4Slxz8PzXB+vf+AlAgLhYMCvlRkgGo/zn/e/3C+iNRdOXVQzQJBJN1fu7eilpbO/hmx/Vx9eFn1uMpdbOqXhYD+fsbmVxXT1xtm6s422nihHzizlglMX5uzvBodMsUWhALGER8Jz90hSw1Yc7p+2MFtkaZJgKMTHPnkJlU5bGlHVSfUDxzAMw5hY5Bp0cARQgcvYDvD/s/fu8XHU58Hv95nd1c2SbMlYRiCDMZiYJIUAckJaIEps1SQ9tZNTAuTSuG8gkDQJ6cmbE9wU/JY0nNoNaRJaUqAmrUh6uIQmtU9PMLahDskpBmTuF4PBGFuysCxL1l2rvTznj5ldr1a70q60K62k5/v57Gd3Zn7zm2dmdzSPnmu5t27CiIgPuBNoxK3e/oyIbFPVRNPJtUCXqp4jItcAm4GrJ3K8mKtxf2fvCKUgqtDRN8xDzYf53YZVEz2dEccAqCgJUOJ3GApHiapbs+uU8hL8PhmzfMdkeoOqajxmKxJ1C9VGvFixiCrhyEkFLRyNjtr/UNcAlSV+ogkXaCyl5OkDnTzwzGHaegY5taKEP77gNE6vKnUVsN7JuyvnFfvp6A0S8DmUBLyuCQJ//pFz+Mh7ThkRc/j0gU5+/Ph+/I5QVRbgSPcAt2x7mXlFPpYuLB/Twhc7j4PH++gfjlAW8BEKR/F5+tmC0gDdQ2HmFflGJEE4jlA3vzTlnKv+8OP8/Kf/zP/+J58C8IlINYCqdqbcwTAMwzDGIFOFbRPwnIj8l7f8EeCvJ3nsDwJvquoBABF5ADfzNFFhW5dwnIeBfxQRUU0TrT4GMVfjcJoMwJYTQ2PGlo3H7n3t9AyGaOsepMTvY1FFMafOL6GlaxC/TzjrlHkZW8uSExIiUSUYjhCNupamsKeQJSpfMSVtMsQsTIldBWLlLmLuypgC9uw7Xfx2f4dXEkVp7wnyQmt3RsfxO8KiFNmVbsal+x5zV8aUqfFcqw88czheDLd/OMyJgTCKEgxHOd4fTJuskKjoLaooxt8/TPdQGHEkni3aORDi/NMreadzkKM9QzjiWtwiEeXEYIjnDnXxB+cscteL4HOE//jF/Qjw07vuADecYC+uwS73plLDMAxj1pNplui/iMgjwIe8VRtU9d1JHvt04HDCckvC/KPGeFXgu4GFQEfiIBG5Hrge4Iwzzkh5sJirMVmlEU5mVUw0EzMW+1VWdLLSfmvXIKdUFFFVFmDhvCK6B0Nxa9nl5y7yXG6u9Suq7sM/ojrKOhZRJRP9NNHaVZthzFgig6EIH33PIv71yYPxxIBgOEooEqVnKMyaHz2R0l2ZirIiX1z5SlTEYopZ9bwifI6MPxGpXaupaOsZpLLE/Tl39g+DgIMQikRHxZuJeFmnAg82HybgE0oDfkTglIoSwtFBTgyG8Ttuh4aowoutPVSVBdz+okCRz2FRRTE+R3h4byt/cvHI1lTvHHw7/llEXlLV+syunmEYhmGMZrws0RWquk9ELvJWxRSs00TkNFV9dhLHTvXETqVPjTcGVb0HuAegvr4+pVoRczX++b89y4DXezJx8mK/k3UmpnoK1j/95i18DlTPK8bvOHT2BwmGo/QOhfnrP34fH1q20O2n6cViHTzen9VxxiPRSlRZ4h9lUVJVugdDbuxY71DW2ZXdgyPLX8Q6GJQEHAKOg98nBHwOfgeGwlHu/9Ilee+L6niWrNirbkEZHf1DlAX8hCJuZwWNuopVwO/K2NE3NCoW71hfcFRJl+5B91oEfK6Vz4drxezsD/G+0yrpC4Y51huk9cQgAUdGXZ8YL7/8Mq+++irAQhH5AoCq3pf7q2EYU0tnZydXX301Bw8eZOnSpTz00ENUVVWNGtfU1MT3vvc9AG6++WbWr18f21QmIi8BpbidPb6hquqFDjwILMWt93mVqnYBiEgD8CMgAHSo6kdEpAR4AijGfZ49rKr/K0+nbRjTyngWtm/iWq5+kGKbApMpUdACJJol6oAjaca0iIgfmM/JOLqMicV2Xbr8FO645gN8+d/2Eo6O1PwiniWmeyDkNSs/uV/M7ReJnlS6YusBDiYUei0r8lFWVIai9A6FuejMKkKR0fFiMHmrWIz7nz4EqqgKvYNhrwhshNt+/RoLygK097oKZCYkFoNdXFnC4gq37EWyu/KbD74wyn06GIpw2vyyrJU1EcGfoHzFlLGYi9ERV0GLrQ/4ZNQxvv6xc9i47ZV4b9ZQVEHcrFBHhIFQhCXV80YdO1VWruJa32JEom78nwJvHHVjIGOyhqLu95zsTr/11lvZvXt3TGGrAP4O+B1uEo1hzGg2bdrEqlWr2LBhA5s2bWLTpk1s3rx5xJjOzk5uvfVWmpubEREuvvhi1q5dG1PszgRWA3twFbYrgEeADcBjqrrJa3+4AbhJRBYAPwGuUNVDIhK72YLAx1S1T0QCwO9E5BFV3TMFl8EwppTxskSv994/modjPwMsF5GzgFbgGuCzSWO2AeuBJ4ErgcfHi1+LqNLWPei6G73sx8RdltWU86cfOpOmPe+MSj441hfkkZfaslaaxor9Ssd4VrFEkrMrjyZlWrb3pi/42ptU9yw5u3Ki7spYrbTBUGRErbVrVi4ZNdbnCH6fQ8BTcvw+xy2v4gh+x8nYPToWicka3YMheofCVJUFqChxCw+nix2Muco7+oboHggRjCnX3m8jEnXLmMR+KrEYSIF4B4WqssAod/rDDz/MCy+8wIUXXkh7e/tB4I+ALZM+UcMoALZu3cru3bsBWL9+PQ0NDaMUtkcffZTGxkaqq92/Z42NjWzfvp2GhgYAR1WfBBCR+4BP4ips64AGb4omYDdwE+6z4ZeqeghAVdu9dwX6vPEB7zWj2yYaRjoy7SX6aWC7qvaKyM3ARcDfqOpzEz2wF5P2NeBRXK/TT1X1FRH5LtCsqtuAe4GficibuJa1a8afFwaHI2OOec+plaN8rVEgEo2mras1FsnKS5cXuN4XDPPNB19IaTmLBcmX+B0iUVcBGA5HuePx/VzyzkJXGfOUsmyyK10lyLVKlRcHuHpl3YjSF+XF/py4Kz+4rJpvsJwHm92EgNPml/GFD5/JZecuwu9zZfA7TkprWL5ITNaIFQAeL9O2YUUNV7ac4M7dbxGJKiV+H6D0D0cZDkdcS6o3tqa8iI7+YVTdnqJlRQ6nlJdQUeIf5U4vLS3FcRz8fj+4JdzasYQDY5Zw9OhRamtrAaitraW9vX3UmNbWVpYsOfkPXF1dHa2trbS2tgIkxhG04MYrAyxW1TYAVW1LsKSdCwREZDeuxfrHsfACr+LAXuAc4E5VfSqVzJnEOhtGIZNplugtqvoLEbkUWAPcDtzF6CSBrFDVX+OawxPXbUz4PIRbpDenPPDM4ZQB9D1DEd453jd6wzjElJcHnjnMO8f76BuOsKDUz4KyIjr6hvjBrjf41AdOZ2F5Udw69mpbNwpxV1siv3y2NeVx0rkru/pDbHuhlWK/Q2mRL27t+sbH0rdwyoaAz/GUMFcBiy1ftXIJ13yoMP/wpWv9lYonD3RSV+VlwvYGGY4oPkkomCtwyrwiFs8vpX84Ere4xeLhBobDowob19fXc+LECb70pS/xla985b3As8DTuTxHw8gnq1ev5t13R+eW3XbbbRntn8oZIiLpkqjGs4r5cetxrsKNe3tSRPao6huqGgE+4LlNfyUi71fVl1PIM26ss2EUMpkqbDGT1R8B/6SqW0Xkr/MjUv45eLwv7V+HdGU/0jEYinC0ZwgEPrpiEf/21CCBiNIXjNA1MEDY0wzv+e2BcecS3OSHC5YsyNpdubymPOvOAvHjisQVsYDXRivgS20hy6R11XQxUdkOdw3gE2jrdpvB+xw3izSicN7icoYj0XiM26KK4nipFlVNW6rlJz/5CQBf/vKX+cpXvvIGsF5VX8z1ORtGvti1a1fabYsXL6atrY3a2lra2tqoqRl9n9XV1cXdpgAtLS00NDRQV1cHrusyPpST8ctHRaTWs67V4lqmwbXCdahqP9AvIk8AFwBvxCZR1ROeBe4KYJTCZhgznUwVtlYRuRs3SHSz14HAGWefguTpA530j+EyLfKfPK0R2ZUJxWDbE2LJsi0GW+MpYBqFF1pOUORzKCty3aIRVf5i1bkTsoplUv4ippAFfCfjyLJxW6ZrXXVlywmePNCZVlGaCiVvVOuxQ11ce98zLF9UzoaPnzfm8ZZUlfHcoS7ES25w49ZOJpSUF7u3SWnAh88rzJtcqiV5/lWrVvHYY4/FFodV9UUReUxVJ1ed2TAKgLVr19LU1MSGDRtoampi3bp1o8asWbOG73znO3R1dQGwY8cO/vZv/zYW0xYVkUuAp4AvAP/g7RaLW97kvW/11m/FrcPpB4pwvTs/FJFFQMhT1krxnlH5OWvDmF4yVdiuwv2v5XbvxqhlhvZGfOCZwywo9XOsb3QphmK/gyPCtx9+0Q3m7xliKMPsSnAtM+qV7xCgstTPvGI/kahSU1HCj675wIjxmRaFzYaAz6HY78TdljGLmd+ZfCxZYustgLIiPx19Q9y5+y3qqkpHKHHfxXVLplPyYttTMREF7+4nDhCKRGjvCTEUjiKAz4GDnQPjHu+Gy5dx7X3P4BMhHFU3wxTwOzDsuT+LfE5cQbvlj96bdq6hoSEGBgbo6Oigq6sr5v7xichSJtkdxDAKhQ0bNnDVVVdx7733csYZZ/CLX/wCgObmZu666y62bNlCdXU1t9xyCytXrgRg48aN8QQE4B3cJJxS3GSDR7z1m4CHRORa4BBeSIyqviYi24EXcUOOt6jqyyJyPtDkxbE5wEOq+p/5vwKGMfVIpk0DvPi15dC0SiQAACAASURBVF4R3UVAuaq+Pd5+U80HLrpYf/nob4CT7spEi9gvn20FcQP8s2kMkKp3ZaxK/12/OUDP4DBlRX76gmHae4eAWEX/kpzGkzkiBPxuxqU/ppQ5TtpyF7nk0s2Pj6pZ9lZ7L8MR5bzayvi6geEwNRUl3HD5Mm584DkGhiMU+x1OKS+msjQQ337/9ZeMOkaigpfYS/W7a983ptJW/72ddA+E4spWDAGWLZqX9ngxrvjhbzjYOUAw5CrofkdwPEX31Pkl4+4f48c//jE/+tGPOHLkCKed5upnBw8eHAb2Af+sqv847iQ5pr6+Xpubm6f6sIaRFhHZO53FpO2eMAqJTO+HTLNE/xdQD7wH+Bfc+IOfA38wGSHzQUvnADf8bG/W7kqAuqpSzl5UPjKwP4PsyuP9wXiVfdd9VkLXwDDBcJSF84onZDmLxZUV+RyK/N7L5+D3TZ8nOlXNsmAk6mVWnqQ04GP/0R42bnuF/uEwfkcIR5Qj3W5P0lRZlTFiVrxwRHm7u59hrwjupkdeG1NhGw5HiaT458NN7IiOWxR5w8fPY+O2VzhyYtDrISqoujFrpQFfxkWVv/GNb/CNb3yDf/iHf+DrX/86YJ0ODMMwjMmTqUv0U8CFuJluqOoREanIm1SToDcYZn/7yEzPxOxKB+HVth6C4Wi8J2RUYX5ZgK81nJORYpVc8HZewM3MjNVhKy/243OEhfOK+furLxhzLkeEIv/J2LKYK7PI50xZOYxMidUsGxgOx61ffsehomTkz8htz6XM9wklfh/hqOI4AlHo6Avi98morMoYsQSAI91DOAg+EaJRZf+xvjF7vQZ8roKViqO9QS5cMroKeyKxOm43PvAc/cNhSvxu66mKkkDKLNDxuO666/j7v/97fve73wGcLSJ/AdzlZT4bhmEYRlZkqrANe21DFEBERpeMLxCqygJcd+lZY2ZXXtfUTEvXAFFVAj6H6nlFOCIZ1WBLVfC2LxhmOBQhpErUU07mFfn5asM58f2SLWaxBIDEJIdCJ7E4bay+2boLTuPhZ1tHKHGhiFLkdygN+FhUUcyRE0NEURAlGNa0RWzBSwA43IWD65IEV6kOiIzZ6/XcxZXseft4yuIAYx0v+fzuuObCES7ZsYrujsX69eupqKjg61//Or/61a/acRvA/4w8lKkxDMMwZj+ZKmwPeVmiC0TkS8AXKdCq7afOL+Wz49QG6x8Oc+bCMgaGI3T2D3O0Zwi/I/Gm52MRK3gbs6aVBnwMDocJRqI44ll5vKSDsiJXYYm5MwvNYjYRUtU3O79uwagitXc/cYD23iEqSgKctgCO9QYZCkeZV+QfMx7NTQBoPlkHTd3XqfOLx3RLfnhZNU8eOA641z6mt/kcOLemPOOs1Fgh3S2/e5v+4Qjzinxcd+lZWWe1vv7667zwwguxxV5VvV5EXhhrH8MwDMNIR0YKm6reLiKNQA9uHNtGVd2ZV8nySG1lKW939NGdEOMWjipD4RA/+++D/OnvL027b1vPYDxeDQCB/mG3Iv65iysQz806GIrwT795i/ufOVyQNctySboitTH3acxFnEnyQMOKGs6tKeftjn4iUaXI57omXbd2Sdr9njzQSVWZnxMDYbcXKOA44HccbrpiRcbnsntfOw8/20pZkY9IVBkYjnDn7rcAuHH1uRnPc+GFF7Jnzx4uucRNVBCRDwH/X8YTGIZhGEYCmVrY8BS0neC2AhGRz6nqv+VNsjzx9IFO2roHRihrifzLk+9wuGuA7/zRe0dtC/gc6haUcbw/SFmRL66chSJKiX9kT8xwJMrB4wPUVBTRPRCirXuQZw918dWGs7N68E8n45XXGGt7KvdppgrrTVesSJkpOpZb8nDXAKcvKKOyJExHXzDeBL404GSlJN/9xAGGwxGO9w/j4GaJRlS5c/dbnF+3IOO5nnrqKe67775YC5zfw+2H+5qIvITbAvH8jIUyDMMw5jxjKmwiUgl8FbfP2zZche2ruDXYngdmlMIWiz/rGhhdgy2RXfuOsaT6IF+6/GxKAj5KAg7Ffrdo6tc/dg4bt71CMByJKxM+R5hfFhgxx9GeID6B430hRFxlLxLN/sE/XYxXPy2T+mqx95hSd/cTB0asT8dE3JKxDNbK0gCVpe53ESsfkk1dt8NdA/QOhUfE0PkEQpHomDF0yWzfvj3+eenSpa8Df5zRjoZhGIaRgvEi3n+G6wJ9CbgO2IEbNL1OVUeXti5wYvFnUdVRzd+TeXhvC6ctKKV6XhFlRf649axhRQ3fXfs+aipK6B4MUVNRwlcbzibgcwPUVdUNVI9GQTVePV+8jMdIVOOKSyGxe187n7lnD5dufpzP3LOHzdv3xYvkirjvAZ/EZU8soptqe2zOjdteob13aIRSt3vf6EbRybI8/GwriyqKOe/UChZVFPPws61j7nfD5csIRXTkdxBRPrysOisZllSVEQxHiaoSDEcYCkUIhqP4RTIu7QFw5plncvjwYR5//HGAYaAfcFT1HVV9J+OJDMMwDIPxXaLLVPX3AERkC9ABnKGqvXmXLA+09QwyvyRAwOegGiVd21ABBrwCqumsM+MF3gcc4fWjfYhG3c4H4mrHxVnU9JoqUlnLDh4foG7ByJixxHpkh7sGWFAaSLsdUndGGBgOj2upmsh+6Vyw2c51w+XLaH6nk1DkpFKv6sY4xlpUZcKtt95Kc3Mzr7/+emxVEQVau9AwDMMofMZ7AsV9h6oaEZG3Z4qyFi+j4Xco9vko8juctXAex/qCLK4s4ciJITQSJbnxlACOwLwiX1ZtlZKVuDt2vcG+o/vjtcFU3X4q5WPUIJsuUik1AZ9wtCdIZWlRfNxgKBKXPVUR3cTtkJlSl4qJ7pdKkb5568tZzdWwoobKYj/HB0InM03F/T1l2hUE4Fe/+hXPPfccF110EVDYtQsNwzCMwmc8l+gFItLjvXqB82OfRaRnKgTMFp8Ip1eVsnRhGXVVZdRUlDC/LEBpkY8vf+RsQhHF5wi184tH1UCLKWuIcN2lZ2Xk9kvHkwc6qS4LxK00jrgP/sFQNOuaXvnmcNdAvExJjMUVxYSi0VEuxpjs6VyQiee2pKqMwVBkxLzJSl0qkvfrHQrxZnsf7b1BPnPPnnFdqmPNNZ4Mu/e1c2IohE+83wJuYeWqMj/9w5GU+6SiqKgIkZOtwgq5dqFhGIZR+IypsKmqT1UrvVeFqvoTPleOte90IQLFfl/KmmeJ8WdRhaULyzjv1Aoqit2EAhGYV+znGx87hxtXn5tSkQlHojx7qCse65WoPCTGgT17qIuKEj9nLixjXpE7f7Hf7QqQy4SD5NizbJSZGDGlpmcwxIFjfex7t4ejvUFqK4pHxOolluRIFcuXXLIjE6UuFYn79QwO09I1SDiqnFpZnHEc3ERluPuJAwQctwVYsd9HacBHkc+hNzi+opnIVVddxQ033MCJEycATgF2Af+c8QSGYRiGkUDmQTmzhJjbLNHdeebCeSmbjCe7/XqHQrSeGMKfwkUKjHCfdvQFaT0xRF1VKcsWlQMnsxZzRTYu27G44fJlfOvhFzgxEIq36wpHlKCn2IwVNwbps0AnWtojcb9nD3Xh9wmLK0pGZH+mikFLF2+YjQyHuwZYXFlMW3eQKG7SiKKEI2RlGf3Wt77Fzp07qays5Pbbby9hhtcuNAzDMKaXOaewxUgXjL55+774Q7+8yEfPoBvGVxrw8W632wZycUVJ3EUaUx6AEfMtriih9cQg73YPUV7sz6iWWK7OIZvyE+AqSIvKi+kbChPRkcVqx5prLIUxJl9Mefqbde/PWqaGFTVcuvlxFpQGRlhMU8Wgjae8ZqrcxZT00xaUcKzXrefmE+HsRfOykv/tt9/msssuo7Gxkdtvv70F+J2ILFXVgxlPYhiGYRgeM6eRZQ7Zva+dZw91cahzgAPH+uJKWTgS5Y32vngJiFBUUaDI59A96Aahn77gpKUHTioPye7TytIApy8oQSGty3CypHLZZhKcn4reYJhzaspZcWolyxaVU1ESGHeudDF+mx55LV5Kwyfw3OEurr2vmY//6ImsXbaZxqBlE284VrmRGy5fRvdgiHd7hlxlzRHKS/xZdUsA+PSnP43jjLi9IsAvsprEMAzDMDzmnMIWe1gLrusvGI5yqHOAV450c6hzEJ8w4qE/vzTAgrIifnvTx7jojCr8vpGXLKY8pFIs/D6Hi86o4rc3fYz7r78k58VyJxrUn6u50imMbx8fIOATegdDHOocZCgUJRJV3jrWl1X8GWQeg5aN8jqWcvdiywm6B0MMhaKEI0okEh23Zl8qwuEwRUUnM2xVdRi3tIdhGIZhZM2cU9hiD+tT57uJB2HPiqbqNgwPR5TeoZOdEBIf+mMpDxMNsJ8MuTzmROZaUlVGR18wnqhw4FgfHX1BwLVWHusbdvt6enFxwxElFIlkVTg4k+SGZFleOdLNK0e6ebWth+7B0CgFMZ1yt/9oT7xvaInfocjngEjcNZwNixYtYtu2bfFlEVmHW8fQMAzDMLJmzsWwxWp8iQh+Z4iIarxWWrFPiALHeoNUlLhuz0Qr03gB7BPtnTlRJhLUP1Yh4Gzm2r2vncPH+3i3x1XQAg4Me0pabWUxR3uCJFctE4HugRAtTnYu23TN5RP58LJqnj7YiaoSTTiw35FRiRjpasgNR5RwNErA5yC4WcNEoXconLWb+a677uJzn/scX/va18DtJXoT8IWsJjEMwzAMjzmnsCU+rCOqFPsdNAp+n3BKeTFHugcZCkdQ1RGJAsmKTqog+kwUCxi/qXo2ZHrM2HHHC8zPVP6N216hYyCE34GIQigKJX7hlPIAFSUB2nqGEFyrZUxzCzhCMBLN2mWbyfV68kAnNRVFHPUUSEfA5wjBcJQq38jkiRsuX8bGba8wMBwe0Vy+yO8QjjhEvM4U4L4Hw9nLfPbZZ7Nnzx76+vqoqKh4RVV/P5P9ROQK4MeAD9iiqpvSjLsSNyZupao2ZyWcYRiGMeOYFpeoiFSLyE4R2e+9V6UZt11ETojIf+bq2Imuv4Dj9vaMopxSXkxlaYCF84qYV+Qf4X4DJtQTMxUT7a+ZuP9E665NphBw8jzD4QjBUJRw1HV3+h3XdbhwXjF9wTDLF5WTWJfY7wgK+B0nK5dtptfrcNcAC+e5ma0lfreGms8RhiPRUbFs6dysy2sqmF8WcLtSqKIoEXULLWfrZv7Od77DiRMnKC8vB4iKSJWIfG+sfUTEB9wJfBx4L/AZEXlvinEVwI3AU1kJZRiGYcxYpiuGbQPwmKouBx7zllPxfeBPc3ngxId1WbEfR4SF84qoKHFLYhT5fdxxzYUjEgWSFZ1wRGnvHeKGn++dUqVpssperrJK3zjaw/H+4fiyKkSiSjAcjbuQN3z8PGoXlHFqZTFlRT4UcET4asPZWVkTM71esaSJIp8zoh1Ykc9JmTzRsKKG+6+/hL9Z937AbWHV1R8kHFEWlgfwCYQi0QnJDPDII4+wYMGChGukXcAnxtntg8CbqnrAS1J4AFiXYtzfAH8HDGUllGEYhjFjmS6FbR3Q5H1uAj6ZapCqPgbkvHdp7GHdfHMjd3/+Ys46pXzMgPZERadnMMSR7kGiUSUSjU6p0jRZC1muskpDEVcj8nu9m9R7RaIadyHHFOOqsiLCUddKddbCMs6vW5B+4hRker1iltOKEj/DEVdxDIajDAxHONYzlNJClqwAh6LKUChC92CYYMStR1dTUcxDe1uyVswjkQjBYDC+LCKlQPE4u50OHE5YbvHWJc5zIbBEVce0OovI9SLSLCLNx44dy1huwzAMozCZLoVtsaq2AXjvk4rMz/bhlOhWvPuJA9xw+bIxS28kKjodfUEc3B6RxX7flCpNk7WQ5SqrtMjvgILjCAHnZLyX3yejFN7+4Qh1VaUsryknFNWsXcmZXq+YghhzvcZQoG84wostJ0bNncpyOhiKEo0qdQtKCEWUtm63lly2ivnnP/95Vq1axb333guwENgJ3DfObqkqiMRPR0Qc4IfA/xzv+Kp6j6rWq2r9okWLMpLZMAzDKFzyprCJyC4ReTnFK5WLZ1Jk83CaiFsxUdEZjkRR3MzSRRWuwWSqlKbJWsgyLZExHstrKjilosi1sIlQFvBRO7+Y+jOrR8yVi5i5bK5Xw4oaeobCBHxCacAXf/kcYcvv3h41PlkB7ugL4ghEVOnoG8bnlfTo6BvOWvZvf/vb3Hzzzbz22msApcDfqOrmcXZrAZYkLNcBRxKWK4D3A7tF5CBwCbBNROozEsowDMOYseQtS1RVV6fbJiJHRaRWVdtEpBbIPnp/gsQC5o/3hUcoPzc+8Bx3XHNhSuVlZMmLQQQ4dX5JytIf4zHR/pqQPrsxGwtZNlml48lx6nz/mHLESqgkkm3MXLbXq384MiLZAdyM0f7hyKixyeU9hr0iuUU+J96SCnHXT0T2K664giuuuIIf/OAHLUCfiNypql8dY5dngOUichbQClwDfDa2UVW7cRvJAyAiu4FvWZaoYRjG7Ge6ynpsA9YDm7z3rVN14DeO9tAzFEajI+t19QfDYzZOT24a73NkVOmPTJmo0jQZZS+XZCrHkqoy3u7oo3fItUwW+RwqSvycdUp51sfL9BznFbkKpJPgXIyquz6ZZAXY57hu0UUVxRzrdRMQwFXgIPt4v+eff577778f3Dps3wN+OdZ4VQ2LyNeAR3HLevxUVV8Rke8Czaq6baz9DcMwjNnLdClsm4CHRORa4BDwaQDPtfNlVb3OW/4tsAIoF5EW4FpVfXQyB44FzEeT1kcUhsORcRunT7fSlAsL2VTJEStm64hr5YoV1v3sB6vzJtd1l57Fjx9/k3A0iiOushZVd30yyd/l0uoyjvcP43OEU8qLaD0xBAqnVhZn7Lp+4403eOCBB7j//vtZuHAhV199NQCq+tFM5FfVXwO/Tlq3Mc3YhkzmNIxc09nZydVXX83BgwdZunQpDz30EFVVo6szNTU18b3vudVsbr75ZtavXx/bVCYiL+GGC/wa+IaqqohUAw8CS4GDwFVehjUi0gD8CAgAHar6kdhkXkmcZqBVVf+3PJyyYUw7oqrjj5pB1NfXa3Nzeg9R/fd20j0QIhQdfd4+B6pKAzTf8of5FHHO8Jl79nDweB89gyctbJWlfpYuLOf+6y/J23Hv2PUGW373Nv3DEeYV+bju0rO4cfW5Ge0bK9Lb0jXAvCIfIkJfMJyxYu44Dpdddhn33nsv55xzDgAiMqyq42WI5o3x7gnDyJZvf/vbVFdXs2HDBjZt2kRXVxebN48M0ezs7KS+vp7m5mZEhIsvvpi9e/dSVVWFiAwAq4E9uArbHar6iIj8HdCpqptEZANQpao3icgC4L+BK1T1kIjUqGo8lEZEvgnUA5WZKGx2TxiFhIjsVdVxY5HnXKeD5TUVHDzeR1t3cNS2SBQGhpNtb8ZE2d/ey0AwTCjqlshYVFFMebE/67pv2XLj6nMzVtASyUUHin//93/ngQce4KMf/ShXXHEF11xzTdZyGEahs3XrVnbv3g3A+vXraWhoGKWwPfroozQ2NlJd7VrUGxsb2b59Ow0NDQCOqj4JICL34ZZ2egS35FODN0UTsBu3rdtngV+q6iGAJGWtDvgj4Dbgmzk/WcMoEOZc8/dY1mEysZCnUMQUtlywe1873YMhBkJRL8szQkvXIMf7g1nXfZsKJluUOManPvUpHnzwQfbt20dDQwM//OEPAfwi8k8iYqZbY1Zw9OhRamtrAaitraW9ffR90traypIlJ5Oe6+rqaG1tpbW1FSCUMDSx3mC6kk/nAlUisltE9opIYl/eHwHfZnSkywisNqEx05lzFjZIXewKwO+4tcWMybN5+z4iCYqxAuGoWy7jbz+VXd23qSCxBAlAWZGfY71D3PjAc1SWBrK2uM2bN4/Pfe5zfO5zn0NEXgSex+3osSNvJ2EYOWT16tW8++67o9bfdtttGe2fKtxGRFKuB8aLzfEDFwOrcOPenhSRPbiKXLuq7vVi3MaS5x7gHnBdouPJbxiFxpxT2O5+4gCVpQF6BkMER1na3Gr8xuQ50NGP3ydu2yrVhHZRWhBJE8kklyDpGQxxvH+YqCpnVJfFLW7psojHIaKqdwN351Bkw8gru3btSrtt8eLFtLW1UVtbS1tbGzU1o++Jurq6uNsUoKWlhYaGBurq6sBNHIgP5WS9wXQln1pwEw36gX4ReQK4ALgIWCsinwBKgEoR+bmqfn5iZ20Yhcucc4nGiqWeOr8UR05a2xRYUBZgw8fPm07xppVMG8tn04De73MbsZcEfAR8gs/J708uG9kSSS5K3NHnxjiW+H0TLvprGLOVtWvX0tTkdhdsampi3brR9dDXrFnDjh076Orqoqurix07drBmzZqYKzUqIpeIiABf4GRpp1jJJxhZ8mkrcJmI+EWkDPgQ8Jqq/qWq1qnqUty6hY+bsmbMVuacwpb4YA549bUEKA043H7lBQVp/ZkKMo3hynTconkBQhH1enpGCIUjRJW8WjAnE4eW3FEhGI5CQjcLyL5wrmHMVjZs2MDOnTtZvnw5O3fuZMOGDQA0Nzdz3XXXAVBdXc0tt9zCypUrWblyJRs3bownIADvAFuAN4G3cBMOwC351Cgi+4FGbxlVfQ3YDrwIPA1sUdWXp+JcDaNQmHMu0RsuX8a3Hn6BEwMhHIGAT4gqlBfPuUsxglQxXAPD4VF16ZLHRaJKe88QN/x8LxedURWvUxaMqNfmyauFBjiqfOL3avN+DpGo8nZHf7xbwebt+8ZVxJNrspUV+ZhX7It3s4DsC+caxmxl4cKFPPbYY6PW19fXs2XLlvjyF7/4Rb74xS+mmmIgVRkDVT2OG6c2ClX9PvD9dDKp6m7crFLDmJXMOS2lYUUNi8qL6RsKE9GT5SZ8joxbNHc2k2kbqcRxvUMhjpwYAhTlZIP0eUU+KksDOCK09wZRXCum3yc8/Gwr59ctyMt1Ptw1gE+grTuICPgcIRpV3mjvY/e+9oyUttiYmLVuMm3ADMMwDCNXzDmXKEBvMMw5NeWsOLWSZYvKqSgJzHl3V6aN5RPHHet1FSNBKPI58TivAx39lAZ89AXDFPkdSgM+iv0OCnmNA1tSVcbRniCKEopECXolRXxC1sdsWFHDd9e+j5qKEroHQ9RUlPDdte+bswq9YRiGMb3MSYUtU+VkLpEcw5WuFVPiuGA4gqoSRTml3I31Kg24PTsHQxG3mbqX1aHq9uTMp2J8w+XLGI64SlpU3UQSBcIRZX97b9bzNayo4f7rL+G3N32M+6+/xJQ1wzAMY9qYkwrbWMrJRLMMZzrZWJTKAg4tXYPEagyfNr+USs9NOhiKcNbCMs+yJYTCUYZCEYKRKOFIlI6+/BXObVhRQ7HfQXBdsI5AwBF8PmE4bAWRDcMwjJnLnIthg/QN3AE2bnuFgE9GZBlOsPbWjGO8hu6xuK7hcAS/I4QFhiNKS9cATrfgc4TyYj+3X3kBALdsfZnDXYNu/JrjJh7ku/l7WZGPcFRxEERcy14UpchnBZENwzCMmcucVNggtXLymXv2ZJQpOVe5+4kDDIcjHO8fxkFwRIioElHQiCJA92CI//mL5zl3cSXlxX6qywKcGAwRjoIjyoLSAE8e6OTGPMl47uJK3u7oo3foZMP5ipIAZ51SnvVcuegtahiGYRi5YE66RNMRK6qbSKqYq7nqNj3cNUDvUNhV1hxXWYvbrTxrWyii9AUjtPcO8frRXroHQwR8DiUBh4DPoXcoPKF4sky54fJlhKNKxGutEFElHM0+uzNXvUUNwzAMIxeYwpZAJskIc/lBvqSqjGB4ZCJBrLlXVE92jQiGo4QjMYUJHBHEs8gh5D2eTADU62Wo6XvHjkVivTnrdGAYhmFMN6awJXDD5cvoHgyxv72Xfe/2sL/dtRAlWmfm8oP8hsuX4fMsa5pKE5KTbx19wbg2F42qm00adVfkM54s1it2+eIKzqudz/LFFVSWBrL+ft442sO73UPse7eHA8f66BkMzfnSL4ZhGMb0MWdj2NIx0jojo3SSTAvMzkYaVtTw1YazuXP3W4QiUYocIRjR+PZYg3e/gxs/5neIRKP4fTLpeLKxSIw1O9Yb5NTK4hHbM/l+EucoL/LRMxQGwCdCOKIc6R5kYbgo57IbhmEYRiaYwpZAzDpz6vzS+LrkpIMlVWW09w7FExNgdtRwyzTA/sbV53J+3YJ4hu3xvmFCkQhR3K4CPgdE3Bi3imI/CswvDWTVLSCbYP+YizqW2dvRF6Sla5BATzDeyaKy1M/ShekVreQ53jzWRzSqiAgqIA4Qha6BEJus04FhGIYxDZhLNIFMkg4yLTA7k8g2Li+xoOxPPncRtQvKWLqwjDOqS/E7DhFVllaX8f0rL+D2Ky/IqltAtrIku6griv1EFIbCURxxLX3tvcN8eFn6UiLJc0Siis8R/N4rElUCjlBR4rcsUcMwDGNaMAtbAplYz9LVcJvJD/JMG7+nIvl6XOg1gE/cL5trk60syS7qgeEIPvEaznvdFSpK/GOWEkmeo8jnEIpEiaiyfFGFN2+YmoqSjM/DMAzDMHKJKWwJ3HD5sowafo9XYHamMdm4vFxej2xlSVayhyNRfI5Q4nNYtsh1g6rqmOcSmyMcUTr6ggyFo0Sjit9x97XG74ZhGMZ0Yy7RBOZqw+9C6q2arSzJLmqfI0QVFlUUZ7R/bI7uwRCtJwYJRaL4xG1rhQjvdg/Omd+BYRiGUbiYhS2J2WY9y4RMLYuFKEuyS3ZpdRnH+4fxOZKxdaxhRQ2LyovpGwrHExVOW1CMzxFqKkq4//pL8nS2hmEYhpEZ06KwiUg18CCwFDgIXKWqXUljPgD8E1AJRIDbVPXBXMphrYdcCikubyKyJCvZse81m3PpDYY5p6YckZOFXFSV/Ud7+Mw9e+b8b8QwThKJZAAAGqRJREFUDMOYXqbLwrYBeExVN4nIBm/5pqQxA8AXVHW/iJwG7BWRR1X1RC4ESC7lMNcavSdTSJbFVApYNkrTRM4lVcJJ64kBTgyE6Tp4nGKfW1NuLv9GDMMwjOljumLY1gFN3ucm4JPJA1T1DVXd730+ArQDi3IlwEQ6FszVHqITJRfXa6pagSXHwnX0DdE1EMYRCPgcIgrH+0KEIpE50dXCMAzDKCymS2FbrKptAN77mOYKEfkgUAS8lWb79SLSLCLNx44dy0iATBu9x5hLPUQLSdGaqlZgyQkn/cFIXFmL9UEVge6B0JzoamEYhmEUFnlT2ERkl4i8nOK1Lst5aoGfAf9DVVN2DVfVe1S1XlXrFy3KzAiXbTbiXOkhWmiKVraK9WRoWFHDDZcvo66qjP5h97cRjp5svSUCwUh0xne1MAzDMGYeeVPYVHW1qr4/xWsrcNRTxGIKWUptQEQqgf8XuFlV9+RSvmw7Fkyl4jCdFJqiNZUlRxKV1RK/e2uEo0ooEkVViUQVv+NYPTbDMAxjypmupINtwHpgk/e+NXmAiBQBvwLuU9Vf5FqAbLMRC7WHaK4zXTMpXLt7Xzubt+/jQEc/AGctLGPDx88bcdxcXa+pLDmSqKyeUl7Mke5BiCpRVcJR8DnCVxvOtoQDwzAMY8qZrhi2TUCjiOwHGr1lRKReRLZ4Y64CLgf+TESe914fyKUQiT0x77/+kjEfxIXYQzQfcXXjWbR272vn/3z4Bfa396GqqCpvHuvnWw+/MOK4ubpeU1nMONEqWFka4LT5pZQGfIgIK5dWc/fnL+bG1efm/LiGYRiGMR7TYmFT1ePAqhTrm4HrvM8/B34+xaKlpZBqlcWYTA/QdMQsWh19Q3QPhAhGovgdh3UXnBY/Zu9QGJ/jBuIDSFTpC448bi6v11SVHEm2ClaWBvD7rHiuYRiGMf1Yp4MsyFZxyHdh3sn2AE1Fw4oarmw5wZ273yISVUr8PipK/Dz8bCvn1y3gcNcA4WgUv++kcVYEItHR/ToLqbZbJhRSxwfDMAzDSMQUtjwxFYV5cxlXl6hc9gyGqCoLsKiiJL49ZrlbUlVGR28QVVdRA1B147umO55vshSiFdUwDMMwwJq/542pKAOSqzix5Fi4/uEwx/uH6RkMxcfELHc3XL6MihI/kagSiUbdlyrlxf6Ux51pxYaziWs0jLlKZ2cnjY2NLF++nMbGRrq6ulKOa2pqYvny5SxfvpympqbETWUi8pKIvCkid4jXE05EqkVkp4js996rYjuISIMXy/yKiPwmYf1Bb67nRaQ5T6dsGNOOKWx5YirKgOQqID9ZuSzxu3J39AXjY2KWu4YVNXz/ygtY7vXdFBHOWTSP26+8YNRx51Kx4VwhIleIyOveg2xDiu3fFJFXReRFEXlMRM6cDjmNuc2mTZtYtWoV+/fvZ9WqVWzatGnUmM7OTm699Vaeeuopnn76aW699dZExe5M4Hpgufe6wlsfa1u4HHjMW0ZEFgA/Adaq6vuATycd7qOq+gFVrc/xqRpGwWAu0TwxVWVAchEnlhwLt6iimNauQYJht/5YcixXpsfMR1LEbEZEfMCduJnTLcAzIrJNVV9NGPYcUK+qAyLyFeDvgKunXlpjLrN161Z2794NwPr162loaGDz5s0jxjz66KM0NjZSXV0NQGNjI9u3b6ehoQHAUdUnAUTkPtz2hI/gti1s8KZoAnbj9pn+LPBLVT0EoKr2X58x5zALW54oxDIg6Ugu5VFREuCUiiLKinyTstzNlWLDOeSDwJuqekBVh4EHcB9gcVT1v1Q1dgH3AHVTLKNhcPToUWprawGora2lvX20/tTa2sqSJUviy3V1dbS2ttLa2goQShjaApzufU7XtvBcoEpEdovIXhH5QsL+Cuzw1l+fTuaJtDA0jELCLGx5YiYFsKfKjgz4fNxxzfmTkrdQiw0XMKcDhxOWW4APjTH+WlyrxCi8B9f1AGeccUau5DPmEKtXr+bdd98dtf62227LaH9VHbVORFKux1W6xsIPXIxbDqoUeFJE9qjqG8AfqOoREakBdorIPlV9IoU89wD3ANTX1493PMMoOExhyyMzpaxFvpTLmV4mI99lWVIgKdalfLCIyOeBeuAjqbbbw8mYLLt27Uq7bfHixbS1tVFbW0tbWxs1NaPvi7q6urjbFKClpYWGhgbq6uoAEusR1QFHvM9HRaRWVduS2ha2AB2q2g/0i8gTwAXAG6p6BFw3qYj8CtdSPUphM4yZjrlEDSA/2ZFT2aUg10xTwkQLsCRhOfFBFkdEVgN/hRuAHUzebhj5Zu3atfGsz6amJtatWzdqzJo1a9ixYwddXV10dXWxY8cO1qxZE3OlRkXkEi879AucbE8Ya1sII9sWbgUuExG/iJThWp5fE5F5IlIBICLzgD8EXs7HORvGdGMWNiOvzBQrYzLTlDDxDLBcRM4CWoFrcIOt44jIhcDdwBUWeG1MFxs2bOCqq67i3nvv5YwzzuAXv3DbPTc3N3PXXXexZcsWqqurueWWW1i5ciUAGzdujCcgAO8AW3Ddm49w0rW/CXhIRK4FDuFlg6rqayKyHXgRiAJbVPVlEVkG/MqrCuIH/m9V3Z73C2AY04CkiSeYsdTX12tzs5XiMSbHpZsfZ0FpAJGTXkpVpXswxG9v+lhWc4nI3kzLDYjIJ4AfAT7gp6p6m4h8F2hW1W0isgv4PaDN2+WQqq4da067J4xCI5t7Ih/YPWEUEpneD2ZhM2YNuYw5m66ECVX9NfDrpHUbEz6vzqsAhmEYRkFiMWzGrCDXMWczqSyLYRiGMfsxhc2YFeS6FdhMTpgwDMMwZh/mEjVmBcndGmDyRXpnasKEYRiGMfswC5sxK0ju1gBWpNcwDMOYPZjCZswKLObMMAzDmM3MKZfoNFSuN6aImdQKzDAMwzCyZc4obLEswoBPRmQRfhfsoT5LsJgzwzAMY7YyZ1yiuc4iNAzDMAzDmCrmjIUtH1mEMw1zCRuGYRjGzGTOWNjmehbhNDUzNwzDMAwjB8wZhW2uZxGaS9gwDMMwZi7T4hIVkWrgQWApcBC4SlW7ksacCfwStwl2APgHVb1rosec61mEc8UlbG5fwzAMYzYyXTFsG4DHVHWTiGzwlm9KGtMG/L6qBkWkHHhZRLap6pGJHnQuZxFOVzPzqcQygQ3DMIzZynS5RNcBTd7nJuCTyQNUdVhVg95iMXPIfZsP5oJL2Ny+hmEYxmxlupSgxaraBuC9pzR/iMgSEXkROAxsTmddE5HrRaRZRJqPHTuWN6FnMnOhmfnhrgFKA74R62aj29cwDMOYe+TNJSoiu4BTU2z6q0znUNXDwPkichrwHyLysKoeTTHuHuAegPr6ep2gyLOe2e4SngtuX8MwDGNukjcLm6quVtX3p3htBY6KSC2A9z5mbQnPsvYKcFm+5DVmPnPB7WsYhmHMTabLJboNWO99Xg9sTR4gInUiUup9rgL+AHh9yiQ0xmT3vnY+c88eLt38OJ+5Z09B1HObC25fwzAMY24yXVmim4CHRORa4BDwaQARqQe+rKrXAecBPxARBQS4XVVfmiZ5jQQKORtztrt9DcMwjLnJtChsqnocWJVifTNwnfd5J3D+FItmZEBiNiZAWZGfgeEwdz9xwJQlwzAMw8gDVirDyBrLxjQMwzCMqWXONH+fCuZKlX3LxjQMwzCMqcUsbDliLjVXt2xMwzAMw5haTGHLEXOpyr5lYxqGYRjG1GIu0RwxV5qrx7BsTMMwDMOYOszCliOWVJUxGIqMWGdxXYZhGIZh5AJT2HKExXUZhjFX6OzspLGxkeXLl9PY2EhXV1fKcU1NTSxfvpzly5fT1NSUuKlMRF4SkTdF5A4REQARqRaRnSKy33uviu0gIg0i8ryIvCIiv0lYv0BEHhaRfSLymoh8OE+nbRjTiilsOcLiugzDmCts2rSJVatWsX//flatWsWmTZtGjens7OTWW2/lqaee4umnn+bWW29NVOzOBK4HlnuvK7z1G4DHVHU58Ji3jIgsAH4CrFXV9+EVW/f4MbBdVVcAFwCv5fp8DaMQsBi2HGJxXYZhzAW2bt3K7t27AVi/fj0NDQ1s3rx5xJhHH32UxsZGqqurAWhsbGT79u00NDQAOKr6JICI3Ad8EngEWAc0eFM0AbuBm4DPAr9U1UMAqtru7VsJXA78mbd+GBjO/RkbxvRjFjbDMAwjK44ePUptbS0AtbW1tLePLl/U2trKkiVL4st1dXW0trbS2toKEEoY2gKc7n1erKptAN577D/gc4EqEdktIntF5Ave+mXAMeBfROQ5EdkiIvNSySwi14tIs4g0Hzt2bGInbhjTiFnYDMMwjFGsXr2ad999d9T62267LaP9VXXUOhFJuR5IuTIBP3AxbkvDUuBJEdnjrb8I+LqqPiUiP8Z1o96SQp57gHsA6uvrxzueYRQcprAZhmEYo9i1a1fabYsXL6atrY3a2lra2tqoqRkdClJXVxd3mwK0tLTQ0NBAXV0dQGINpDrgiPf5qIjUqmqbiNQCMdNdC9Chqv1Av4g8gRuv9lugRVWf8sY9jBf3ZhizDXOJGoZhGFmxdu3aeNZnU1MT69atGzVmzZo17Nixg66uLrq6utixYwdr1qyJuVKjInKJlx36BWCrt9s2YL33eX3C+q3AZSLiF5Ey4EPAa6r6LnBYRN7jjVsFvJrzEzaMAsAUNsMwDCMrNmzYwM6dO1m+fDk7d+5kwwbXqNXc3Mx1110HQHV1NbfccgsrV65k5cqVbNy4MZ6AALwDbAHeBN7CTTgA2AQ0ish+oNFbRlVfA7YDLwJPA1tU9WVvn68D/yYiLwIfAP6vfJ67YUwXkiaeYMZSX1+vzc3N0y2GYcQRkb2qWj9dx7d7wig07J4wjJNkej+Yhc0wDMMwDKPAMYXNMAoIEblCRF73KsCPCp4WkWIRedDb/pSILJ16KQ3DMIypxhQ2wygQRMQH3Al8HHgv8BkReW/SsGuBLlU9B/ghsBnDMAxj1mMKm2EUDh8E3lTVA17F9gdwK78nsg63Ajy4JQxWxfowGoZhGLOXWVeHbe/evR0i8k4GQ08BOvItTxaYPGNTSPJkK8uZGY47HTicsNyCW74g5RhVDYtIN7AwWR4RuR63VyNAn4i8PsZxC+naxjCZMqcQ5RpPpkzvibyQxXOiUCjE7zhTTPbxyeh+mHUKm6ouymSciDRPZ5ZSMibP2BSSPHmUJZWlLDmNO5MxI6q6j3vQArq2MUymzClEuQpRpkQyfU4UCoV+PcfCZM8d5hI1jMKhBViSsJxYAX7UGBHxA/OBzimRzjAMw5g2TGEzjMLhGWC5iJwlIkXANbiV3xNJrAR/JfC4zrZiioZhGMYoZp1LNAsychdNISbP2BSSPHmRxYtJ+xrwKOADfqqqr4jId4FmVd0G3Av8TETexLWsXZODQxfStY1hMmVOIcpViDLNZGby9TTZc8Ss63RgGIZhGIYx2zCXqGEYhmEYRoFjCpthGIZhGEaBM2cUNhH5tIi8IiJREUmbpjtea6AcylMtIjtFZL/3XpVmXEREnvdeyQHouZCjYFohZSDLn4nIsYTrcV2+ZPGO91MRaReRl9NsFxG5w5P3RRG5KJ/yZMtkvlsR+Utv/esismaK5fqmiLzqXdPHROTMhG15uR8m89sTkfXefbxfRNYn75tHmX6YIM8bInIiYVu+rtOE74l8XaeZRgbf6+Ui8qyIhEXkyqRtKb9XEflXEXk7YdsHClD2M0Rkh4i85t3fS731Z3l/f/Z7f4+KZpDsU3Ld46jqnHgB5wHvAXYD9WnG+IC3gGVAEfAC8N48yfN3wAbv8wZgc5pxfXm8JuOeL/DnwF3e52uAB6dRlj8D/nEKfzOXAxcBL6fZ/gngEdzaaJcAT02VbPn8bnHbYr0AFANnefP4plCujwJl3uevJP7m8nE/TOa3B1QDB7z3Ku9z1VTIlDT+67hJKnm7Tt68E7on8nWdZtorw9/aUuB84D7gyqRtKb9X4F+Txxag7LuBRu9zecI9/hBwjff5LuArM0j2vF/3xNecsbCp6muqOla1d8isNVCuSGwx1AR8Mk/HGYtCaoU0ldc+I1T1CcaucbYOuE9d9gALRKR2aqQbl8l8t+uAB1Q1qKpvA296802JXKr6X6o64C3uwa1Hl08m89tbA+xU1U5V7QJ2AldMg0yfAe7PwXHHZBL3RL6u00wjk9//QVV9EYhOh4BjMGHZxe2J7FfVnd64PlUd8P7efAz37w/k71mYc9nzIOO4zBmFLUNStQY6PU/HWqyqbQDee02acSUi0iwie0Qk1z/kTM53RCskINYKKddkeu3/xHO1PCwiS1Jsn0qm8veSLZP5bvN5XtnOfS2uxSZGPu6Hyfz28nWtMp7XcxmfBTyesDqffzfGIp3chXyvTCWTvQ5jfa+3eb/PH4pI8aQlHc1kZD8XOCEivxSR50Tk+yLiw/17c8L7+5PtnNmQD9lj5Pu6x5lVCpuI7BKRl1O8Mv1vOaO2P1MoD8AZ6rbG+CzwIxE5e6LypBIxxboJtUKaIln+H2Cpqp4P7OKkdWi6mKprMxEm893m87wynltEPg/UA99PWJ2P+2Eyv718Xats5r0GeFhVIwnr8vl3Yyym4zc1k5jsdUj3vf4lsAJYiet2vmlSUqZmMrL7gcuAb+HKuAw3zKCQni/pSCc7TM11jzOrFDZVXa2q70/x2prhFJm0BsqVPEdj7jPvvT3NHEe89wO4fvQLJypPCgqpFdK4sqjqcVUNeov/DFycBzmyIae/lxwzme82n+eV0dwishr4K2Btwneer/thMr+9fF2rbOa9hiR3aJ7/boxFOrkL+V6ZSiZ1HdJ9r6ra5rmhg8C/kLsQhkQmI3sL8JznkgwD/4EbC9mB6zaPFfHP1+8iH7JP1XWPM6sUthyQSWugXJHYYmg9MEqpFJGqmIlVRE4B/gB4NYcyFFIrpHFlSYoPWwu8lgc5smEb8AVxuQTojrm5C4DJfLfbgGvEzSI9C1gOPD1VconIhcDduMpae8L6fN0Pk/ntPQr8oSdbFfCH3rq8y+TJ9R7cIP4nE9bl++/GWKS7J/J1nWYaE37GjPW9JvzzL7gxYCmzeKdLdm/fKhFZ5C1/DHjV+3vzX7h/fyDNszAH5Fx2mLLrfpJMMhNmwwv4FK6mHASOAo96608Dfp0w7hPAG7gZJX+VR3kWAo8B+733am99PbDF+/z7wEu4GS0vAdfmQY5R5wt8F/dhCVAC/AI38PxpYFker8l4svwt8Ip3Pf4LWJHn38z9QBsQ8n471wJfBr7sbRfgTk/el0iTfTxdr8l8t7jWrbeA14GPT7Fcu7x79Hnvtc1bn7f7YTK/PeCL3jV8E/gfUyWTt/zXwKak/fJ5nSZ8T+TrOs20Vwa/tZXete0HjgOvjPe94sYvvoSrMPwcKC8k2b1tjcCLnpz/ChR565fh/v15E/fvUfEMkn1KrnvsZa2pDMMwDMMwChxziRqGYRiGYRQ4prAZhmEYhmEUOKawGYZhGIZhFDimsBmGYRiGYRQ4prAZhmEYhmEUOKawzQBEJCIizye8lopIvYjc4W1vEJHfTxj/SXH7n2V7nL4U63aLyJqkdX8hIj/Jdi7DmEpiv0Hvfvlsjuf+TtLyf+dyfsMwjGRMYZsZDKrqBxJeB1W1WVVv9LY34NboifFJIGuFLQ334xYZTGRUZXXDKGCW4rbyyZikXoGpGKGwqervpxtoGIaRC0xhm6F4VrX/FJGluIUr/w/P+vYR3Ers3/eWz/Ze20Vkr4j8VkRW/P/t3VuIFmUcx/HvLxVZMvampQuJjKAiJS07LaUURXQhxHbAwJsoKMIOCBXeS6EQQRSdiC6KTSsjsS6ysFZxSdxY3U1D6WKNuuiAHTbp4KF/F89/bHZ73/WV3uht+X1uduaZmeeZF2Z2/jPzzPPPOs6V9LGkIUlrmjS1EVhWG2F7HmWw4R2S5kjaKmlY0qeNcqRW+1mbf0bSnTm9WNK23K8tk0aTN2uXtcCSPB9WSZqhksB5SCVp871w4lj9SNJrlMEwkbQpj899ku7JsrVAV9bXn2XV0zxl3XvznFheq3tAJXH8fkn9OTq6mVlLZp58FesAXZL25PRYRPRVCyLioKTngcMR8QSApM3AuxGxMee3UkYi/1zSlcCzlPQaTwHPRcQrklY2ajgiDknaBdxESRlyB/B6RISk34C+iBjPVCk7JW2OFkZjljQLeBq4OSK+ywvbY5TR0M3aaTXwcEQsA8jA66eIuDxvRAYlvZ/rXgEsiIixnL8rIr6X1AUMSXorIlZLuj8iFjVo6xZgEbAQODO32Z7LLgHmU3IYDlJSC+1o/881s+nIAdv/w69NLg4nJWkO5XXpm7Ub+tn592rg1px+FVjXpJrqtWgVsFVBlYDHJS0F/gDmAmcBX7ewaxcAC4APcr9mUFLemP3bbgQullTlL+ym5Es9AuyqBWsAD0qqbpDOzvUOTVH3NcD6iDgOfCNpGyXlzXjW/RVA3oDNwwGbmbXIAdv0dxrw4xQBXyu5yTYBT0q6FOiKiOEsXwH0AIsj4qikg5T8lHXHmPjqvVouSq623hbaN2snAQ9ExITk45KupeQRrM/fAPRGxC+SBvj78d2o7mZ+r00fx/9/zewUuA/b9PAzcEaj+YgYB8Yk3Q4n+tgszPUG+euDghXNKo+Iw8AA8DITPzboBr7NYO064JwGm38BXCRptqRu4PosPwD0SOrN/ZolaX6Lv9fsVEw+P7YA9+VreSSdL+n0Btt1Az9ksHYhcFVt2dFq+0m2A8uzn1wPsJSS2NrM7B9xwDY9vAP0ZSfoJcAG4BFJuyWdRwnG7pY0AuwDqo8DHgJWShqiXJymsp7SL2dDrawfuEzSJ9nG/skbRcSXwBvAaK6/O8uPALcB63K/9jDxS1ezdhkFjkkakbQKeAn4DBiWtBd4gcZPu94DZkoaBdYAO2vLXgRGq48Oat7O9kaAD4FHI6KVLgJmZlNSC/3DzczMzOw/5CdsZmZmZh3OAZuZmZlZh3PAZmZmZtbhHLCZmZmZdTgHbGZmZmYdzgGbmZmZWYdzwGZmZmbW4f4EZYFPN5MfE/4AAAAASUVORK5CYII=\n", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "text/plain": "
" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from bartpy.diagnostics.diagnostics import plot_diagnostics\n", - "plot_diagnostics(model)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4-final" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} \ No newline at end of file diff --git a/examples/features/Feature Selection.ipynb b/examples/features/Feature Selection.ipynb new file mode 100644 index 0000000..32bc5f9 --- /dev/null +++ b/examples/features/Feature Selection.ipynb @@ -0,0 +1,489 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Feature Selection\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.pipeline import make_pipeline\n", + "\n", + "from bartpy.sklearnmodel import SklearnModel\n", + "from bartpy.features.featureselection import SelectNullDistributionThreshold, SelectSplitProportionThreshold\n", + "from bartpy.diagnostics.features import *\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'X v y')" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(0, 5, 1000)\n", + "X = np.random.normal(0, 3, size = 1000 * 2).reshape(-1, 2)\n", + "X[:, 0] = x\n", + "X = pd.DataFrame(X).sample(frac=1.0).values\n", + "y = np.random.normal(0, 0.1, size=1000) + np.sin(X[:, 0])\n", + "plt.scatter(X[:, 0], y)\n", + "plt.scatter(X[:, 1], y)\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.title(\"X v y\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50/50 [00:00<00:00, 254.49it/s]\n 0%| | 0/200 [00:00)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = SklearnModel(n_samples=200, n_burn=50, n_trees=10, store_in_sample_predictions=False, n_jobs=1)\n", + "model.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import pyplot as plt\n", + "\n", + "from bartpy.diagnostics.residuals import plot_qq, plot_homoskedasity_diagnostics\n", + "from bartpy.diagnostics.sampling import plot_tree_mutation_acceptance_rate\n", + "from bartpy.diagnostics.sigma import plot_sigma_convergence\n", + "from bartpy.diagnostics.trees import plot_tree_depth\n", + "from bartpy.sklearnmodel import SklearnModel\n", + "\n", + "\n", + "def plot_diagnostics(model: SklearnModel):\n", + " fig, ((ax1, ax2, ax3), (ax4, ax5, ax6)) = plt.subplots(2, 3, figsize=(10, 10))\n", + " fig.suptitle(\"Diagnostics\")\n", + " plot_qq(model, ax1)\n", + " plot_tree_depth(model, ax2)\n", + " plot_sigma_convergence(model, ax3)\n", + " plot_homoskedasity_diagnostics(model, ax4)\n", + " plot_tree_mutation_acceptance_rate(model, ax5)\n", + " plt.show()\n", + "\n", + "plot_diagnostics(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Sklearn API\n", + "\n", + "Feature selection can be done in BartPy using the Sklearn selector API. This allows for deep integration with the Sklearn pipelines" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Proportion Threshold\n", + "\n", + "The simplest way to select features is to set a threshold on how often a variable is used in splits in the model trees. The more times a tree appears in the model, the more likely it is that the feature is important and captures a meaningful pattern.\n", + "\n", + "While this method is simple, the downside is that it is hard to set the threshold appropriately. Cross validation is recommended" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "model = SklearnModel(n_samples=200, n_burn=50, n_trees=20, store_in_sample_predictions=False)\n", + "pipeline = make_pipeline(SelectSplitProportionThreshold(model, 0.3), model)\n", + "pipeline_model = pipeline.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature Proportions {0: 0.3870967741935484, 1: 0.2903225806451613}\nIs Kept [ True False]\n" + ] + } + ], + "source": [ + "print(\"Feature Proportions\", pipeline_model.named_steps[\"selectsplitproportionthreshold\"].feature_proportions)\n", + "print(\"Is Kept\", pipeline_model.named_steps[\"selectsplitproportionthreshold\"]._get_support_mask())" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(pipeline.predict(X), y)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pipeline_model.named_steps[\"selectsplitproportionthreshold\"].plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Null Distribution Threshold\n", + "\n", + "For a more principled analysis, BartPy implements the method described in https://repository.upenn.edu/cgi/viewcontent.cgi?article=1555&context=statistics_papers.\n", + "\n", + "This is significantly more computationally expensive, but offers a principled way to set proportions" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1]\n" + ] + } + ], + "source": [ + "model = SklearnModel(n_samples=200, n_burn=200, n_trees=5, store_in_sample_predictions=False, n_jobs=-1)\n", + "pipeline = make_pipeline(SelectNullDistributionThreshold(model, 0.75, \"local\"), model)\n", + "pipeline_model = pipeline.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Thresholds {0: 0.2355833333333333, 1: 0.20002080123266563}\nFeature Proportions {0: 0.36666666666666664, 1: 0.3}\n[0, 1]\nIs Kept [ True True]\n" + ] + } + ], + "source": [ + "print(\"Thresholds\", pipeline_model.named_steps[\"selectnulldistributionthreshold\"].thresholds)\n", + "print(\"Feature Proportions\", pipeline_model.named_steps[\"selectnulldistributionthreshold\"].feature_proportions)\n", + "print(\"Is Kept\", pipeline_model.named_steps[\"selectnulldistributionthreshold\"]._get_support_mask())" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(model.predict(X), y)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(X[:,0], model.predict(X))\n", + "plt.scatter(X[:,1], model.predict(X))" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pipeline_model.named_steps[\"selectnulldistributionthreshold\"].plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Feature Selection\n", + "\n", + "The approach so far is useful - but it doesn't give a complete picture of the importance of a single variable. There are at least two big limitations:\n", + "1. % of splits doesn't give up an idea of how much a variable is improving accuracy\n", + "2. In cases of high correlation, the model might be able to as easily split on different variables\n", + "\n", + "To get a more direct account of a single variable, we can instead permute that variable, and see how the out of sample RMSE changes. The bigger the increase in RMSE that scrambling a variable, the more important the variable is." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " sampling\n100%|██████████| 500/500 [00:03<00:00, 150.15it/s]\n 6%|▌ | 11/200 [00:00<00:01, 108.69it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 134.82it/s]\n 3%|▎ | 13/500 [00:00<00:03, 129.28it/s]Starting sampling\n100%|██████████| 500/500 [00:03<00:00, 153.04it/s]\n 8%|▊ | 17/200 [00:00<00:01, 160.23it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 166.83it/s]\n 3%|▎ | 17/500 [00:00<00:02, 168.59it/s]Starting sampling\n100%|██████████| 500/500 [00:02<00:00, 176.90it/s]\n 10%|▉ | 19/200 [00:00<00:01, 180.85it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 186.67it/s]\n 8%|▊ | 38/500 [00:00<00:02, 187.68it/s]Starting sampling\n100%|██████████| 500/500 [00:02<00:00, 187.61it/s]\n 8%|▊ | 17/200 [00:00<00:01, 166.14it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 189.05it/s]\n 4%|▍ | 19/500 [00:00<00:02, 184.14it/s]Starting sampling\n100%|██████████| 500/500 [00:02<00:00, 189.95it/s]\n 10%|▉ | 19/200 [00:00<00:00, 185.51it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 190.00it/s]\n 4%|▎ | 18/500 [00:00<00:02, 172.04it/s]Starting sampling\n100%|██████████| 500/500 [00:02<00:00, 189.14it/s]\n 10%|█ | 20/200 [00:00<00:00, 191.06it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 196.06it/s]\n 4%|▍ | 20/500 [00:00<00:02, 193.30it/s]Starting sampling\n100%|██████████| 500/500 [00:02<00:00, 192.01it/s]\n 19%|█▉ | 38/200 [00:00<00:00, 181.98it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 163.02it/s]\n 3%|▎ | 15/500 [00:00<00:03, 145.17it/s]Starting sampling\n100%|██████████| 500/500 [00:02<00:00, 172.72it/s]\n 10%|▉ | 19/200 [00:00<00:00, 186.14it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 180.94it/s]\n 2%|▏ | 12/500 [00:00<00:04, 118.13it/s]Starting sampling\n100%|██████████| 500/500 [00:03<00:00, 152.25it/s]\n 6%|▋ | 13/200 [00:00<00:01, 127.42it/s]Starting burn\n100%|██████████| 200/200 [00:01<00:00, 167.98it/s]\n 4%|▍ | 19/500 [00:00<00:02, 181.46it/s]Starting sampling\n100%|██████████| 500/500 [00:03<00:00, 159.40it/s]\n 0%| | 0/200 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from bartpy.features.featureimportance import feature_importance\n", + "feature_importance(model, X, y, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from bartpy.diagnostics.diagnostics import plot_diagnostics\n", + "plot_diagnostics(model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4-final" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/score/__init__.py b/examples/features/__init__.py similarity index 100% rename from examples/score/__init__.py rename to examples/features/__init__.py diff --git a/examples/score/features/ols.py b/examples/features/ols.py similarity index 97% rename from examples/score/features/ols.py rename to examples/features/ols.py index 9e57799..e2f3610 100644 --- a/examples/score/features/ols.py +++ b/examples/features/ols.py @@ -27,7 +27,7 @@ def run(n: int=10000, k_true: int=3, k_null: int=2): n_trees=20, store_in_sample_predictions=False, n_jobs=3, - n_chains=1) + n_chains=-1) pipeline = make_pipeline(SelectNullDistributionThreshold(model, n_permutations=20), model) pipeline_model = pipeline.fit(X_train, y_train) diff --git a/examples/ols.py b/examples/ols.py deleted file mode 100644 index 179b9c4..0000000 --- a/examples/ols.py +++ /dev/null @@ -1,30 +0,0 @@ -import pandas as pd -import numpy as np -from matplotlib import pyplot as plt - -from bartpy.extensions.baseestimator import ResidualBART -from bartpy.sklearnmodel import SklearnModel - - -def run(alpha, beta, n_trees, n_regressors, n_burn=50, n_samples=200, n_obsv=1000): - b_true = np.random.uniform(-2, 2, size = n_regressors) - x = np.random.normal(0, 1, size=n_obsv * n_regressors).reshape(n_obsv, n_regressors) - x[:50, 1] = 4 - X = pd.DataFrame(x) - y = np.random.normal(0, 0.1, size=n_obsv) + np.array(X.multiply(b_true, axis = 1).sum(axis=1)) - model = SklearnModel(n_samples=n_samples, n_burn=n_burn, n_trees=n_trees, alpha=alpha, beta=beta, n_jobs=1, n_chains=1, initializer=None, store_acceptance_trace=False, store_in_sample_predictions=False) - model.fit(X, y) - # predictions = model.predict() - # plt.scatter(y, predictions) - # plt.show() - return model, x, y - - -if __name__ == "__main__": - import cProfile - from datetime import datetime as dt - print(dt.now()) - # model, x, y = run(0.95, 2., 200, 50, n_obsv=100000) - cProfile.run("run(0.95, 2., 200, 40)", "restats") - - print(dt.now()) diff --git a/examples/score/core/__init__.py b/examples/score/core/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/examples/score/core/sin.py b/examples/score/core/sin.py deleted file mode 100644 index f63a3fd..0000000 --- a/examples/score/core/sin.py +++ /dev/null @@ -1,47 +0,0 @@ -import pandas as pd -import numpy as np -from matplotlib import pyplot as plt -from sklearn.model_selection import train_test_split - -from bartpy.sklearnmodel import SklearnModel - - -def run(size=100, - alpha=0.95, - beta=2.0, - n_trees=50): - - import warnings - - warnings.simplefilter("error", UserWarning) - x = np.linspace(0, 5, size) - X = pd.DataFrame(x) - y = np.random.normal(0, 0.1, size=size) + np.sin(x) - - model = SklearnModel( - n_samples=100, - n_burn=50, - n_trees=n_trees, - alpha=alpha, - beta=beta, - n_jobs=1, - n_chains=1) - - X_train, X_test, y_train, y_test = train_test_split(X, - y, - test_size=0.33, - random_state=42, - shuffle=True) - - model.fit(X_train, y_train) - y_pred = model.predict(X_test) - - plt.scatter(y_test, y_pred) - plt.show() - - rmse = np.sqrt(np.sum(np.square(y_test - y_pred))) - print(rmse) - - -if __name__ == "__main__": - run(50, 0.95, 2.0) diff --git a/examples/score/extensions/__init__.py b/examples/score/extensions/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/examples/score/extensions/sin.py b/examples/score/extensions/sin.py deleted file mode 100644 index 1f48d99..0000000 --- a/examples/score/extensions/sin.py +++ /dev/null @@ -1,47 +0,0 @@ -import pandas as pd -import numpy as np -from matplotlib import pyplot as plt -from sklearn.model_selection import train_test_split - -from bartpy.extensions.baseestimator import ResidualBART - - -def run(size=100, - alpha=0.95, - beta=2.0, - n_trees=50): - - import warnings - - warnings.simplefilter("error", UserWarning) - x = np.linspace(0, 5, size) - X = pd.DataFrame(x) - y = np.random.normal(0, 0.1, size=size) + np.sin(x) - - model = ResidualBART( - n_samples=100, - n_burn=50, - n_trees=n_trees, - alpha=alpha, - beta=beta, - n_jobs=1, - n_chains=1) - - X_train, X_test, y_train, y_test = train_test_split(X, - y, - test_size=0.33, - random_state=42, - shuffle=True) - - model.fit(X_train, y_train) - y_pred = model.predict(X_test) - - plt.scatter(y_test, y_pred) - plt.show() - - rmse = np.sqrt(np.sum(np.square(y_test - y_pred))) - print(rmse) - - -if __name__ == "__main__": - run(50, 0.95, 2.0) diff --git a/examples/score/features/__init__.py b/examples/score/features/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/examples/sin.py b/examples/sin.py deleted file mode 100644 index b811851..0000000 --- a/examples/sin.py +++ /dev/null @@ -1,53 +0,0 @@ -import pandas as pd -import numpy as np -from matplotlib import pyplot as plt - -from bartpy.initializers.initializer import Initializer -from bartpy.sklearnmodel import SklearnModel -from bartpy.diagnostics.trees import plot_tree_depth -from bartpy.diagnostics.features import plot_feature_split_proportions -from bartpy.diagnostics.residuals import plot_qq - -from bartpy.samplers.oblivioustrees.treemutation import get_tree_sampler -import statsmodels.api as sm -from bartpy.extensions.baseestimator import ResidualBART -from bartpy.extensions.ols import OLS - - -def run(alpha, beta, n_trees, size=100): - import warnings - - warnings.simplefilter("error", UserWarning) - x = np.linspace(0, 5, size) - X = pd.DataFrame(x) - y = np.random.normal(0, 1.0, size=size) + np.sin(x) - from bartpy.samplers.unconstrainedtree.treemutation import get_tree_sampler - - model = SklearnModel( - n_samples=50, - n_burn=50, - n_trees=n_trees, - alpha=alpha, - beta=beta, - n_jobs=1, - n_chains=1, tree_sampler=get_tree_sampler(0.5, 0.5)) - model.fit(X, y) - plt.plot(y) - plt.plot(model.predict(X)) - plt.show() - # plot_tree_depth(model) - # plot_feature_split_proportions(model) - # plot_qq(model) - # null_distr = null_feature_split_proportions_distribution(model, X, y) - # print(null_distr) - return model, x, y - - -if __name__ == "__main__": - import cProfile - from datetime import datetime as dt - print(dt.now()) - - run(0.95, 2., 200, size=500) - #cProfile.run("run(0.95, 2., 200, size=500)", "restats") - print(dt.now()) diff --git a/examples/sklearnbase.py b/examples/sklearnbase.py deleted file mode 100644 index 1382d6f..0000000 --- a/examples/sklearnbase.py +++ /dev/null @@ -1,28 +0,0 @@ -import pandas as pd -import numpy as np -from matplotlib import pyplot as plt - -from bartpy.extensions.baseestimator import ResidualBART - - -def run(alpha, beta, n_trees): - x = np.random.normal(0, 1, size=3000) - X = pd.DataFrame(x) - y = np.random.normal(0, 0.1, size=3000) + 2 * x + np.sin(x) - plt.scatter(x, y) - plt.show() - model = ResidualBART(n_samples=200, n_burn=50, n_trees=n_trees, alpha=alpha, beta=beta) - model.fit(X, y) - predictions = model.predict() - plt.scatter(x, y) - plt.scatter(x, predictions) - plt.show() - return model, x, y - - -if __name__ == "__main__": - print("here") - from datetime import datetime as dt - print(dt.now()) - model, x, y = run(0.95, 2., 100) - print(dt.now()) diff --git a/tests/test_data.py b/tests/test_data.py index c752ca7..6f571be 100644 --- a/tests/test_data.py +++ b/tests/test_data.py @@ -3,32 +3,41 @@ import pandas as pd import numpy as np -from bartpy.data import CovariateMatrix, Data, Target, is_not_constant, format_covariate_matrix +from bartpy.covariates import is_not_constant, is_unique +from bartpy.data import Data, format_covariate_matrix +from bartpy.target import Target +from bartpy.covariates import CovariateMatrix from bartpy.errors import NoSplittableVariableException class TestIsNotConstant(unittest.TestCase): def setUp(self): - self.non_constant_array = np.array([1, 1, 2, 3]).view(np.ma.MaskedArray) - self.non_constant_array.mask = np.zeros_like(self.non_constant_array) - self.constant_array = np.array([1, 1, 1, 1]).view(np.ma.MaskedArray) - self.constant_array.mask = np.zeros_like(self.constant_array) + self.non_constant_array = np.array([1, 1, 2, 3]) + self.constant_array = np.array([1, 1, 1, 1]) - def test_unmasked(self): + def test(self): self.assertTrue(is_not_constant(self.non_constant_array)) self.assertFalse(is_not_constant(self.constant_array)) - def test_masked(self): - self.non_constant_array.mask = np.array([False, False, True, True]) - self.assertFalse(is_not_constant(self.non_constant_array)) + + +class TestIsUnique(unittest.TestCase): + + def setUp(self): + self.unique_array = np.array([1, 2, 3, 4]) + self.non_unique_array = np.array([1, 2, 3, 3]) + + def test(self): + self.assertTrue(is_unique(self.unique_array)) + self.assertFalse(is_unique(self.non_unique_array)) class TestDataNormalization(unittest.TestCase): def setUp(self): self.y_raw = [1, 2, 3, 4, 5] - self.y = Target(np.array(self.y_raw), mask=np.zeros(5).astype(bool), n_obsv=5, normalize=True) + self.y = Target(np.array(self.y_raw), mask=np.ones(5).astype(bool), n_obsv=5, normalize=True) def test_unnormalization(self): self.assertListEqual(list(self.y.unnormalized_y), self.y_raw) @@ -43,7 +52,7 @@ class TestTargetCaching(unittest.TestCase): def setUp(self): self.y_raw = np.array([1, 2, 3, 4, 5]) - self.y = Target(self.y_raw, np.zeros(5).astype(bool), 5, False) + self.y = Target(self.y_raw, np.ones(5).astype(bool), 5, False) def test_summed_y(self): self.assertEqual(self.y.summed_y(), np.sum(self.y_raw)) @@ -63,10 +72,11 @@ def setUp(self): self.y = np.array([1, 2, 3, 4, 5]) self.X = pd.DataFrame({"a": [1, 2, 3, 4, 5], "b": [1, 1, 1, 1, 1], "c": [1, 2, 3, 3, 4]}) self.X = format_covariate_matrix(self.X) - self.mask = np.array([True, True, False, False, False]) + self.mask = np.array([False, False, True, True, True]) self.data = Data(self.X, self.y, self.mask, normalize=False) def test_y_sum(self): + print(self.data.y.summed_y()) self.assertEqual(self.data.y.summed_y(), 12) def test_updating_y_sum(self): @@ -82,9 +92,9 @@ def test_updating_mask(self): s = SplitCondition(0, 4, le) updated_data = self.data + s - self.assertListEqual(list(updated_data.mask), [True, True, False, False, True]) - self.assertListEqual(list(updated_data.X.mask), [True, True, False, False, True]) - self.assertListEqual(list(updated_data.y._mask), [True, True, False, False, True]) + self.assertListEqual(list(updated_data.mask), [False, False, True, True, False]) + self.assertListEqual(list(updated_data.X.mask), [False, False, True, True, False]) + self.assertListEqual(list(updated_data.y._mask), [False, False, True, True, False]) self.assertEqual(updated_data.X.n_obsv, 2) self.assertEqual(updated_data.X._n_obsv, 2) self.assertEqual(updated_data.y.summed_y(), 7) @@ -95,7 +105,7 @@ class TestCovariateMatrix(unittest.TestCase): def setUp(self): self.X = pd.DataFrame({"a": [1, 2, 3, 4, 5], "b": [1, 1, 1, 1, 1], "c": [1, 2, 3, 3, 4]}) self.X = format_covariate_matrix(self.X) - self.X = CovariateMatrix(self.X, mask=np.zeros(5).astype(bool), n_obsv=5, unique_columns=None, splittable_variables=None) + self.X = CovariateMatrix(self.X, mask=np.ones(5).astype(bool), n_obsv=5, unique_columns=None, splittable_variables=None) def test_unique_proportion_of_value_in_variable(self): self.assertEqual(self.X.proportion_of_value_in_variable(0, 1), 0.2) @@ -115,7 +125,7 @@ def test_splittable_variables(self): self.assertListEqual(list(self.X.splittable_variables()), [0, 2]) def test_random_splittable_value(self): - for _ in range(10000): + for _ in range(100): self.assertIn(self.X.random_splittable_value(0), [1, 2, 3, 4]) with self.assertRaises(NoSplittableVariableException): self.assertIsNone(self.X.random_splittable_value(1)) @@ -124,9 +134,9 @@ def test_random_splittable_variable(self): for _ in range(100): self.assertIn(self.X.random_splittable_variable(), [0, 2]) - filtered_X = CovariateMatrix(self.X.values[:, [1]], mask=np.zeros(5).astype(bool), n_obsv=5, unique_columns=None, splittable_variables=None) + filtered_X = CovariateMatrix(self.X.values[:, [1]], mask=np.ones(5).astype(bool), n_obsv=5, unique_columns=None, splittable_variables=None) with self.assertRaises(NoSplittableVariableException): - filtered_X.random_splittable_variable() + print(filtered_X.random_splittable_variable()) def test_n_splittable_variables(self): self.assertEqual(self.X.n_splittable_variables, 2) diff --git a/tests/test_model.py b/tests/test_model.py index 8654b83..341e4a4 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -1,4 +1,3 @@ -from operator import gt, le import unittest import pandas as pd @@ -6,11 +5,7 @@ from bartpy.data import Data, format_covariate_matrix from bartpy.model import Model -from bartpy.mutation import GrowMutation, PruneMutation -from bartpy.node import DecisionNode, LeafNode, split_node from bartpy.sigma import Sigma -from bartpy.split import Split -from bartpy.splitcondition import SplitCondition class TestSplitModel(unittest.TestCase): @@ -20,8 +15,7 @@ def setUp(self): self.raw_y = np.array([1.0, 2.0, 3.0, 4.0, 5.0]) self.data = Data(format_covariate_matrix(self.X), self.raw_y, normalize=True) normalizing_scale = self.data.y.normalizing_scale - self.model = Model(self.data, Sigma(0.001, 0.001, scaling_factor=normalizing_scale), n_trees=2, initializer=None) - self.model.initialize_trees() + self.model = Model(self.data, Sigma(0.001, 0.001, scaling_factor=normalizing_scale), n_trees=2) def test_tree_updating(self): updated_y = np.ones(5) diff --git a/tests/test_split.py b/tests/test_split.py index 33690db..7a04f68 100644 --- a/tests/test_split.py +++ b/tests/test_split.py @@ -63,8 +63,8 @@ def test_multiple_conditions(self): ] combined_condition = CombinedCondition([0], conditions) - self.assertEqual(combined_condition.variables[0].min_value, 2) - self.assertEqual(combined_condition.variables[0].max_value, 5) + self.assertEqual(combined_condition.variable_conditions[0].min_value, 2) + self.assertEqual(combined_condition.variable_conditions[0].max_value, 5) self.assertListEqual(list(combined_condition.condition(self.X)), [False, False, True, False, True, True]) def test_multiple_variables(self): diff --git a/tests/test_tree.py b/tests/test_tree.py index b68abe2..f044b03 100644 --- a/tests/test_tree.py +++ b/tests/test_tree.py @@ -13,8 +13,6 @@ from bartpy.split import Split, SplitCondition - - class TestTreeStructureNodeRetrieval(TestCase): def setUp(self): @@ -86,10 +84,10 @@ def test_update_pushed_through_split(self): self.tree.update_y(updated_y) # Left child keeps LTE condition self.assertListEqual([5, 6, 7], list(self.a.data.y.values)) - self.assertListEqual([5], list(self.b.data.y.values[~self.b.data.y._mask])) - self.assertListEqual([6, 7], list(self.c.data.y.values[~self.c.data.y._mask])) - self.assertListEqual([6], list(self.d.data.y.values[~self.d.data.y._mask])) - self.assertListEqual([7], list(self.e.data.y.values[~self.e.data.y._mask])) + self.assertListEqual([5], list(self.b.data.y.values[self.b.data.y._mask])) + self.assertListEqual([6, 7], list(self.c.data.y.values[self.c.data.y._mask])) + self.assertListEqual([6], list(self.d.data.y.values[self.d.data.y._mask])) + self.assertListEqual([7], list(self.e.data.y.values[self.e.data.y._mask])) class TestTreeStructureMutation(TestCase):