From 98b2bf32347a6cdb4f8c5f81a2a584339b96eeaa Mon Sep 17 00:00:00 2001 From: vsyrgkanis Date: Mon, 22 Mar 2021 18:56:25 -0400 Subject: [PATCH] Vasilis/policy (#377) * added policy learning module * added cython policy tree and policy forest * extended policy cate interpreter to interpret multiple treatments using the new policy tree * added doubly robust policy learning tree and doubly robust policy learning forest * fixed randomness in weightedkfold, that was causing tests to fail due to non-fixed-randomness behavior * added notebook on policy learning --- doc/reference.rst | 12 + doc/spec/estimation/dr.rst | 2 +- econml/__init__.py | 30 +- econml/_ensemble/__init__.py | 14 + econml/{grf => _ensemble}/_ensemble.py | 0 econml/_ensemble/_utilities.py | 117 ++ econml/_tree_exporter.py | 820 +++++++++++++ econml/cate_interpreter/_interpreters.py | 537 ++++----- econml/cate_interpreter/_tree_exporter.py | 418 ------- econml/dr/_drlearner.py | 21 +- econml/grf/_base_grf.py | 118 +- econml/grf/_base_grftree.py | 336 +----- econml/policy/__init__.py | 10 + econml/policy/_base.py | 19 + econml/policy/_drlearner.py | 1025 +++++++++++++++++ econml/policy/_forest/__init__.py | 8 + econml/policy/_forest/_criterion.pxd | 22 + econml/policy/_forest/_criterion.pyx | 48 + econml/policy/_forest/_forest.py | 472 ++++++++ econml/policy/_forest/_tree.py | 333 ++++++ econml/sklearn_extensions/linear_model.py | 10 +- econml/sklearn_extensions/model_selection.py | 19 +- econml/tests/test_cate_interpreter.py | 46 +- econml/tests/test_grf_python.py | 37 +- econml/tests/test_policy_forest.py | 436 +++++++ econml/tests/test_refit.py | 20 +- econml/tests/test_rscorer.py | 16 +- econml/tree/__init__.py | 4 +- econml/tree/_tree_classes.py | 349 ++++++ ...nline Media Company - EconML + DoWhy.ipynb | 104 +- ...mentation at An Online Media Company.ipynb | 40 +- ... Testing at An Online Travel Company.ipynb | 52 +- .../Double Machine Learning Examples.ipynb | 31 +- ...licy Learning with Trees and Forests.ipynb | 572 +++++++++ 34 files changed, 4758 insertions(+), 1340 deletions(-) create mode 100644 econml/_ensemble/__init__.py rename econml/{grf => _ensemble}/_ensemble.py (100%) create mode 100644 econml/_ensemble/_utilities.py create mode 100644 econml/_tree_exporter.py delete mode 100644 econml/cate_interpreter/_tree_exporter.py create mode 100644 econml/policy/__init__.py create mode 100644 econml/policy/_base.py create mode 100644 econml/policy/_drlearner.py create mode 100644 econml/policy/_forest/__init__.py create mode 100644 econml/policy/_forest/_criterion.pxd create mode 100644 econml/policy/_forest/_criterion.pyx create mode 100644 econml/policy/_forest/_forest.py create mode 100644 econml/policy/_forest/_tree.py create mode 100644 econml/tests/test_policy_forest.py create mode 100644 econml/tree/_tree_classes.py create mode 100644 notebooks/Policy Learning with Trees and Forests.ipynb diff --git a/doc/reference.rst b/doc/reference.rst index 9aa2730d0..c7f9f3ca7 100644 --- a/doc/reference.rst +++ b/doc/reference.rst @@ -104,6 +104,18 @@ Sieve Methods econml.iv.sieve.HermiteFeatures econml.iv.sieve.DPolynomialFeatures +.. _policy_api: + +Policy Learning +--------------- + +.. autosummary:: + :toctree: _autosummary + + econml.policy.DRPolicyForest + econml.policy.DRPolicyTree + econml.policy.PolicyForest + econml.policy.PolicyTree .. _interpreters_api: diff --git a/doc/spec/estimation/dr.rst b/doc/spec/estimation/dr.rst index 15946047f..33c9bf63e 100644 --- a/doc/spec/estimation/dr.rst +++ b/doc/spec/estimation/dr.rst @@ -438,7 +438,7 @@ Usage FAQs .. testcode:: - from econml.drlearner import DRLearner + from econml.dr import DRLearner from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier from sklearn.model_selection import GridSearchCV model_reg = lambda: GridSearchCV( diff --git a/econml/__init__.py b/econml/__init__.py index f10559ece..2d961e546 100644 --- a/econml/__init__.py +++ b/econml/__init__.py @@ -1,12 +1,28 @@ # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. -__all__ = ['automated_ml', 'bootstrap', - 'cate_interpreter', 'causal_forest', - 'data', 'deepiv', 'dml', 'dr', 'drlearner', - 'inference', 'iv', - 'metalearners', 'ortho_forest', 'orf', 'ortho_iv', - 'score', 'sklearn_extensions', 'tree', - 'two_stage_least_squares', 'utilities', "dowhy", "__version__"] +__all__ = ['automated_ml', + 'bootstrap', + 'cate_interpreter', + 'causal_forest', + 'data', + 'deepiv', + 'dml', + 'dr', + 'drlearner', + 'inference', + 'iv', + 'metalearners', + 'ortho_forest', + 'orf', + 'ortho_iv', + 'policy', + 'score', + 'sklearn_extensions', + 'tree', + 'two_stage_least_squares', + 'utilities', + 'dowhy', + '__version__'] __version__ = '0.9.2' diff --git a/econml/_ensemble/__init__.py b/econml/_ensemble/__init__.py new file mode 100644 index 000000000..bffd9e92f --- /dev/null +++ b/econml/_ensemble/__init__.py @@ -0,0 +1,14 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from ._ensemble import BaseEnsemble, _partition_estimators +from ._utilities import (_get_n_samples_subsample, _accumulate_prediction, _accumulate_prediction_var, + _accumulate_prediction_and_var, _accumulate_oob_preds) + +__all__ = ["BaseEnsemble", + "_partition_estimators", + "_get_n_samples_subsample", + "_accumulate_prediction", + "_accumulate_prediction_var", + "_accumulate_prediction_and_var", + "_accumulate_oob_preds"] diff --git a/econml/grf/_ensemble.py b/econml/_ensemble/_ensemble.py similarity index 100% rename from econml/grf/_ensemble.py rename to econml/_ensemble/_ensemble.py diff --git a/econml/_ensemble/_utilities.py b/econml/_ensemble/_utilities.py new file mode 100644 index 000000000..00b786dd1 --- /dev/null +++ b/econml/_ensemble/_utilities.py @@ -0,0 +1,117 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import numbers +import numpy as np + + +def _get_n_samples_subsample(n_samples, max_samples): + """ + Get the number of samples in a sub-sample without replacement. + Parameters + ---------- + n_samples : int + Number of samples in the dataset. + max_samples : int or float + The maximum number of samples to draw from the total available: + - if float, this indicates a fraction of the total and should be + the interval `(0, 1)`; + - if int, this indicates the exact number of samples; + - if None, this indicates the total number of samples. + Returns + ------- + n_samples_subsample : int + The total number of samples to draw for the subsample. + """ + if max_samples is None: + return n_samples + + if isinstance(max_samples, numbers.Integral): + if not (1 <= max_samples <= n_samples): + msg = "`max_samples` must be in range 1 to {} but got value {}" + raise ValueError(msg.format(n_samples, max_samples)) + return max_samples + + if isinstance(max_samples, numbers.Real): + if not (0 < max_samples <= 1): + msg = "`max_samples` must be in range (0, 1) but got value {}" + raise ValueError(msg.format(max_samples)) + return int(round(n_samples * max_samples)) + + msg = "`max_samples` should be int or float, but got type '{}'" + raise TypeError(msg.format(type(max_samples))) + + +def _accumulate_prediction(predict, X, out, lock, *args, **kwargs): + """ + This is a utility function for joblib's Parallel. + It can't go locally in ForestClassifier or ForestRegressor, because joblib + complains that it cannot pickle it when placed there. + """ + prediction = predict(X, *args, check_input=False, **kwargs) + with lock: + if len(out) == 1: + out[0] += prediction + else: + for i in range(len(out)): + out[i] += prediction[i] + + +def _accumulate_prediction_var(predict, X, out, lock, *args, **kwargs): + """ + This is a utility function for joblib's Parallel. + It can't go locally in ForestClassifier or ForestRegressor, because joblib + complains that it cannot pickle it when placed there. + Accumulates the mean covariance of a tree prediction. predict is assumed to + return an array of (n_samples, d) or a tuple of arrays. This method accumulates in the placeholder + out[0] the (n_samples, d, d) covariance of the columns of the prediction across + the trees and for each sample (or a tuple of covariances to be stored in each element + of the list out). + """ + prediction = predict(X, *args, check_input=False, **kwargs) + with lock: + if len(out) == 1: + out[0] += np.einsum('ijk,ikm->ijm', + prediction.reshape(prediction.shape + (1,)), + prediction.reshape((-1, 1) + prediction.shape[1:])) + else: + for i in range(len(out)): + pred_i = prediction[i] + out[i] += np.einsum('ijk,ikm->ijm', + pred_i.reshape(pred_i.shape + (1,)), + pred_i.reshape((-1, 1) + pred_i.shape[1:])) + + +def _accumulate_prediction_and_var(predict, X, out, out_var, lock, *args, **kwargs): + """ + This is a utility function for joblib's Parallel. + It can't go locally in ForestClassifier or ForestRegressor, because joblib + complains that it cannot pickle it when placed there. + Combines `_accumulate_prediction` and `_accumulate_prediction_var` in a single + parallel run, so that out will contain the mean of the predictions across trees + and out_var the covariance. + """ + prediction = predict(X, *args, check_input=False, **kwargs) + with lock: + if len(out) == 1: + out[0] += prediction + out_var[0] += np.einsum('ijk,ikm->ijm', + prediction.reshape(prediction.shape + (1,)), + prediction.reshape((-1, 1) + prediction.shape[1:])) + else: + for i in range(len(out)): + pred_i = prediction[i] + out[i] += prediction + out_var[i] += np.einsum('ijk,ikm->ijm', + pred_i.reshape(pred_i.shape + (1,)), + pred_i.reshape((-1, 1) + pred_i.shape[1:])) + + +def _accumulate_oob_preds(tree, X, subsample_inds, alpha_hat, jac_hat, counts, lock): + mask = np.ones(X.shape[0], dtype=bool) + mask[subsample_inds] = False + alpha, jac = tree.predict_alpha_and_jac(X[mask]) + with lock: + alpha_hat[mask] += alpha + jac_hat[mask] += jac + counts[mask] += 1 diff --git a/econml/_tree_exporter.py b/econml/_tree_exporter.py new file mode 100644 index 000000000..dcf281761 --- /dev/null +++ b/econml/_tree_exporter.py @@ -0,0 +1,820 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +# +# This code contains some snippets of code from: +# https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/tree/_export.py +# published under the following license and copyright: +# BSD 3-Clause License +# +# Copyright (c) 2007-2020 The scikit-learn developers. +# All rights reserved. + +import abc +import numpy as np +import re +from io import StringIO +import graphviz +from sklearn.utils.validation import check_is_fitted + +try: + import matplotlib + matplotlib.use('Agg') + import matplotlib.pyplot as plt +except ImportError as exn: + from ..utilities import MissingModule + + # make any access to matplotlib or plt throw an exception + matplotlib = plt = MissingModule("matplotlib is no longer a dependency of the main econml package; " + "install econml[plt] or econml[all] to require it, or install matplotlib " + "separately, to use the tree interpreters", exn) + + +# HACK: We're relying on some of sklearn's non-public classes which are not completely stable. +# However, the alternative is reimplementing a bunch of intricate stuff by hand +from sklearn.tree import _tree +try: + from sklearn.tree._export import _BaseTreeExporter, _MPLTreeExporter, _DOTTreeExporter +except ImportError: # prior to sklearn 0.22.0, the ``export`` submodule was public + from sklearn.tree.export import _BaseTreeExporter, _MPLTreeExporter, _DOTTreeExporter + + +def _color_brew(n): + """Generate n colors with equally spaced hues. + Parameters + ---------- + n : int + The number of colors required. + Returns + ------- + color_list : list, length n + List of n tuples of form (R, G, B) being the components of each color. + """ + color_list = [] + + # Initialize saturation & value; calculate chroma & value shift + s, v = 0.75, 0.9 + c = s * v + m = v - c + + for h in np.arange(25, 385, 360. / n).astype(int): + # Calculate some intermediate values + h_bar = h / 60. + x = c * (1 - abs((h_bar % 2) - 1)) + # Initialize RGB with same hue & chroma as our color + rgb = [(c, x, 0), + (x, c, 0), + (0, c, x), + (0, x, c), + (x, 0, c), + (c, 0, x), + (c, x, 0)] + r, g, b = rgb[int(h_bar)] + # Shift the initial RGB values to match value and store + rgb = [(int(255 * (r + m))), + (int(255 * (g + m))), + (int(255 * (b + m)))] + color_list.append(rgb) + + return color_list + + +class _TreeExporter(_BaseTreeExporter): + """ + Tree exporter that supports replacing the "value" part of each node's text with something customized + """ + + def node_replacement_text(self, tree, node_id, criterion): + return None + + def node_to_str(self, tree, node_id, criterion): + text = super().node_to_str(tree, node_id, criterion) + replacement = self.node_replacement_text(tree, node_id, criterion) + if replacement is not None: + # HACK: it's not optimal to use a regex like this, but the base class's node_to_str doesn't expose any + # clean way of achieving this + text = re.sub("value = .*(?=" + re.escape(self.characters[5]) + ")", + # make sure we don't accidentally escape anything in the substitution + replacement.replace('\\', '\\\\'), + text, + flags=re.S) + return text + + +class _MPLExporter(_MPLTreeExporter): + """ + Base class that supports adding a title to an MPL tree exporter + """ + + def __init__(self, *args, title=None, **kwargs): + self.title = title + super().__init__(*args, **kwargs) + + def export(self, decision_tree, node_dict=None, ax=None): + if ax is None: + ax = plt.gca() + self.node_dict = node_dict + anns = super().export(decision_tree, ax=ax) + if self.title is not None: + ax.set_title(self.title) + return anns + + +class _DOTExporter(_DOTTreeExporter): + """ + Base class that supports adding a title to a DOT tree exporter + """ + + def __init__(self, *args, title=None, **kwargs): + self.title = title + super().__init__(*args, **kwargs) + + def export(self, decision_tree, node_dict=None): + self.node_dict = node_dict + return super().export(decision_tree) + + def tail(self): + if self.title is not None: + self.out_file.write("labelloc=\"t\"; \n") + self.out_file.write("label=\"{}\"; \n".format(self.title)) + super().tail() + + +class _CateTreeMixin(_TreeExporter): + """ + Mixin that supports writing out the nodes of a CATE tree + """ + + def __init__(self, include_uncertainty=False, uncertainty_level=0.1, + *args, treatment_names=None, **kwargs): + self.include_uncertainty = include_uncertainty + self.uncertainty_level = uncertainty_level + self.treatment_names = treatment_names + super().__init__(*args, **kwargs) + + def get_fill_color(self, tree, node_id): + + # Fetch appropriate color for node + if 'rgb' not in self.colors: + # red for negative, green for positive + self.colors['rgb'] = [(179, 108, 96), (81, 157, 96)] + + # in multi-target use mean of targets + tree_min = np.min(np.mean(tree.value, axis=1)) - 1e-12 + tree_max = np.max(np.mean(tree.value, axis=1)) + 1e-12 + + node_val = np.mean(tree.value[node_id]) + + if node_val > 0: + value = [max(0, tree_min) / tree_max, node_val / tree_max] + elif node_val < 0: + value = [node_val / tree_min, min(0, tree_max) / tree_min] + else: + value = [0, 0] + + return self.get_color(value) + + def node_replacement_text(self, tree, node_id, criterion): + + # Write node mean CATE + node_info = self.node_dict[node_id] + node_string = 'CATE mean' + self.characters[4] + value_text = "" + mean = node_info['mean'] + if hasattr(mean, 'shape') and (len(mean.shape) > 0): + if len(mean.shape) == 1: + for i in range(mean.shape[0]): + value_text += "{}".format(np.around(mean[i], self.precision)) + if 'ci' in node_info: + value_text += " ({}, {})".format(np.around(node_info['ci'][0][i], self.precision), + np.around(node_info['ci'][1][i], self.precision)) + if i != mean.shape[0] - 1: + value_text += ", " + value_text += self.characters[4] + elif len(mean.shape) == 2: + for i in range(mean.shape[0]): + for j in range(mean.shape[1]): + value_text += "{}".format(np.around(mean[i, j], self.precision)) + if 'ci' in node_info: + value_text += " ({}, {})".format(np.around(node_info['ci'][0][i, j], self.precision), + np.around(node_info['ci'][1][i, j], self.precision)) + if j != mean.shape[1] - 1: + value_text += ", " + value_text += self.characters[4] + else: + raise ValueError("can only handle up to 2d values") + else: + value_text += "{}".format(np.around(mean, self.precision)) + if 'ci' in node_info: + value_text += " ({}, {})".format(np.around(node_info['ci'][0], self.precision), + np.around(node_info['ci'][1], self.precision)) + value_text += self.characters[4] + node_string += value_text + + # Write node std of CATE + node_string += "CATE std" + self.characters[4] + std = node_info['std'] + value_text = "" + if hasattr(std, 'shape') and (len(std.shape) > 0): + if len(std.shape) == 1: + for i in range(std.shape[0]): + value_text += "{}".format(np.around(std[i], self.precision)) + if i != std.shape[0] - 1: + value_text += ", " + elif len(std.shape) == 2: + for i in range(std.shape[0]): + for j in range(std.shape[1]): + value_text += "{}".format(np.around(std[i, j], self.precision)) + if j != std.shape[1] - 1: + value_text += ", " + if i != std.shape[0] - 1: + value_text += self.characters[4] + else: + raise ValueError("can only handle up to 2d values") + else: + value_text += "{}".format(np.around(std, self.precision)) + node_string += value_text + + return node_string + + +class _PolicyTreeMixin(_TreeExporter): + """ + Mixin that supports writing out the nodes of a policy tree + + Parameters + ---------- + treatment_names : list of strings, optional, default None + The names of the two treatments + """ + + def __init__(self, *args, treatment_names=None, **kwargs): + self.treatment_names = treatment_names + super().__init__(*args, **kwargs) + + def get_fill_color(self, tree, node_id): + # TODO. Create our own color pallete for multiple treatments. The one below is for binary treatments. + # Fetch appropriate color for node + if 'rgb' not in self.colors: + self.colors['rgb'] = _color_brew(tree.n_outputs) # [(179, 108, 96), (81, 157, 96)] + + node_val = tree.value[node_id][:, 0] + node_val = node_val - np.min(node_val) + if np.max(node_val) > 0: + node_val = node_val / np.max(node_val) + return self.get_color(node_val) + + def node_replacement_text(self, tree, node_id, criterion): + if self.node_dict is not None: + return self._node_replacement_text_with_dict(tree, node_id, criterion) + value = tree.value[node_id][:, 0] + node_string = 'value = %s' % np.round(value[1:] - value[0], self.precision) + + if tree.children_left[node_id] == _tree.TREE_LEAF: + node_string += self.characters[4] + # Write node mean CATE + node_string += 'Treatment = ' + if self.treatment_names: + class_name = self.treatment_names[np.argmax(value)] + else: + class_name = "T%s%s%s" % (self.characters[1], + np.argmax(value), + self.characters[2]) + node_string += class_name + + return node_string + + def _node_replacement_text_with_dict(self, tree, node_id, criterion): + + # Write node mean CATE + node_info = self.node_dict[node_id] + node_string = 'CATE' + self.characters[4] + value_text = "" + mean = node_info['mean'] + if hasattr(mean, 'shape') and (len(mean.shape) > 0): + if len(mean.shape) == 1: + for i in range(mean.shape[0]): + value_text += "{}".format(np.around(mean[i], self.precision)) + if 'ci' in node_info: + value_text += " ({}, {})".format(np.around(node_info['ci'][0][i], self.precision), + np.around(node_info['ci'][1][i], self.precision)) + if i != mean.shape[0] - 1: + value_text += ", " + value_text += self.characters[4] + else: + raise ValueError("can only handle up to 1d values") + else: + value_text += "{}".format(np.around(mean, self.precision)) + if 'ci' in node_info: + value_text += " ({}, {})".format(np.around(node_info['ci'][0], self.precision), + np.around(node_info['ci'][1], self.precision)) + value_text += self.characters[4] + node_string += value_text + + if tree.children_left[node_id] == _tree.TREE_LEAF: + # Write recommended treatment and value - cost + value = tree.value[node_id][:, 0] + node_string += 'value - cost = %s' % np.round(value[1:], self.precision) + self.characters[4] + + value = tree.value[node_id][:, 0] + node_string += "Treatment: " + if self.treatment_names: + class_name = self.treatment_names[np.argmax(value)] + else: + class_name = "T%s%s%s" % (self.characters[1], + np.argmax(value), + self.characters[2]) + node_string += "{}".format(class_name) + node_string += self.characters[4] + + return node_string + + +class _PolicyTreeMPLExporter(_PolicyTreeMixin, _MPLExporter): + """ + Exports policy trees to matplotlib + + Parameters + ---------- + treatment_names : list of strings, optional, default None + The names of the treatments + + title : string, optional, default None + A title for the final figure to be printed at the top of the page. + + feature_names : list of strings, optional, default None + Names of each of the features. + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool, optional, default False + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + rounded : bool, optional, default False + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + precision : int, optional, default 3 + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + + fontsize : int, optional, default None + Fontsize for text + """ + + def __init__(self, treatment_names=None, title=None, feature_names=None, + max_depth=None, + filled=True, + rounded=False, precision=3, fontsize=None): + super().__init__(treatment_names=treatment_names, title=title, + feature_names=feature_names, + max_depth=max_depth, + filled=filled, rounded=rounded, precision=precision, + fontsize=fontsize, + impurity=False) + + +class _CateTreeMPLExporter(_CateTreeMixin, _MPLExporter): + """ + Exports CATE trees into matplotlib + + Parameters + ---------- + include_uncertainty: bool + whether the tree includes uncertainty information + + uncertainty_level: float + the confidence level of the confidence interval included in the tree + + title : string, optional, default None + A title for the final figure to be printed at the top of the page. + + feature_names : list of strings, optional, default None + Names of each of the features. + + treatment_names : list of strings, optional, default None + The names of the treatments + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool, optional, default False + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + rounded : bool, optional, default False + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + precision : int, optional, default 3 + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + + fontsize : int, optional, default None + Fontsize for text + """ + + def __init__(self, include_uncertainty, uncertainty_level, title=None, + feature_names=None, + treatment_names=None, + max_depth=None, + filled=True, rounded=False, precision=3, fontsize=None): + super().__init__(include_uncertainty, uncertainty_level, title=None, + feature_names=feature_names, + treatment_names=treatment_names, + max_depth=max_depth, + filled=filled, + rounded=rounded, precision=precision, fontsize=fontsize, + impurity=False) + + +class _PolicyTreeDOTExporter(_PolicyTreeMixin, _DOTExporter): + """ + Exports policy trees to dot files + + Parameters + ---------- + out_file : file object or string, optional, default None + Handle or name of the output file. If ``None``, the result is + returned as a string. + + title : string, optional, default None + A title for the final figure to be printed at the top of the page. + + feature_names : list of strings, optional, default None + Names of each of the features. + + treatment_names : list of strings, optional, default None + The names of the treatments + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool, optional, default False + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + leaves_parallel : bool, optional, default False + When set to ``True``, draw all leaf nodes at the bottom of the tree. + + rotate : bool, optional, default False + When set to ``True``, orient tree left to right rather than top-down. + + rounded : bool, optional, default False + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + special_characters : bool, optional, default False + When set to ``False``, ignore special characters for PostScript + compatibility. + + precision : int, optional, default 3 + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + """ + + def __init__(self, out_file=None, title=None, treatment_names=None, feature_names=None, + max_depth=None, + filled=True, leaves_parallel=False, + rotate=False, rounded=False, special_characters=False, precision=3): + super().__init__(title=title, out_file=out_file, feature_names=feature_names, + max_depth=max_depth, filled=filled, leaves_parallel=leaves_parallel, + rotate=rotate, rounded=rounded, special_characters=special_characters, + precision=precision, treatment_names=treatment_names, + impurity=False) + + +class _CateTreeDOTExporter(_CateTreeMixin, _DOTExporter): + """ + Exports CATE trees to dot files + + Parameters + ---------- + include_uncertainty: bool + whether the tree includes uncertainty information + + uncertainty_level: float + the confidence level of the confidence interval included in the tree + + out_file : file object or string, optional, default None + Handle or name of the output file. If ``None``, the result is + returned as a string. + + title : string, optional, default None + A title for the final figure to be printed at the top of the page. + + feature_names : list of strings, optional, default None + Names of each of the features. + + treatment_names : list of strings, optional, default None + The names of the treatments + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool, optional, default False + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + leaves_parallel : bool, optional, default False + When set to ``True``, draw all leaf nodes at the bottom of the tree. + + rotate : bool, optional, default False + When set to ``True``, orient tree left to right rather than top-down. + + rounded : bool, optional, default False + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + special_characters : bool, optional, default False + When set to ``False``, ignore special characters for PostScript + compatibility. + + precision : int, optional, default 3 + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + """ + + def __init__(self, include_uncertainty, uncertainty_level, out_file=None, title=None, feature_names=None, + treatment_names=None, + max_depth=None, filled=True, leaves_parallel=False, + rotate=False, rounded=False, special_characters=False, precision=3): + super().__init__(include_uncertainty, uncertainty_level, + out_file=out_file, title=title, feature_names=feature_names, + treatment_names=treatment_names, + max_depth=max_depth, filled=filled, leaves_parallel=leaves_parallel, + rotate=rotate, rounded=rounded, special_characters=special_characters, + precision=precision, + impurity=False) + + +class _SingleTreeExporterMixin(metaclass=abc.ABCMeta): + + tree_model_ = None + node_dict_ = None + + @abc.abstractmethod + def _make_dot_exporter(self, *, out_file, feature_names, treatment_names, max_depth, filled, + leaves_parallel, rotate, rounded, + special_characters, precision): + """ + Make a dot file exporter + + Parameters + ---------- + out_file : file object + Handle to write to. + + feature_names : list of strings + Names of each of the features. + + treatment_names : list of strings, optional, default None + Names of each of the treatments, starting with a name for the baseline/control treatment + (alphanumerically smallest in case of discrete treatment or the all-zero treatment + in the case of continuous) + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + leaves_parallel : bool + When set to ``True``, draw all leaf nodes at the bottom of the tree. + + rotate : bool + When set to ``True``, orient tree left to right rather than top-down. + + rounded : bool + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + special_characters : bool + When set to ``False``, ignore special characters for PostScript + compatibility. + + precision : int + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + """ + pass + + @abc.abstractmethod + def _make_mpl_exporter(self, *, title=None, feature_names=None, treatment_names=None, max_depth=None, + filled=True, rounded=True, precision=3, fontsize=None): + """ + Make a matplotlib exporter + + Parameters + ---------- + title : string + A title for the final figure to be printed at the top of the page. + + feature_names : list of strings + Names of each of the features. + + treatment_names : list of strings, optional, default None + Names of each of the treatments + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + rounded : bool + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + precision : int + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + + fontsize : int + Fontsize for text + """ + pass + + def export_graphviz(self, out_file=None, feature_names=None, treatment_names=None, + max_depth=None, + filled=True, leaves_parallel=True, + rotate=False, rounded=True, special_characters=False, precision=3): + """ + Export a graphviz dot file representing the learned tree model + + Parameters + ---------- + out_file : file object or string, optional, default None + Handle or name of the output file. If ``None``, the result is + returned as a string. + + feature_names : list of strings, optional, default None + Names of each of the features. + + treatment_names : list of strings, optional, default None + Names of each of the treatments + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool, optional, default False + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + leaves_parallel : bool, optional, default True + When set to ``True``, draw all leaf nodes at the bottom of the tree. + + rotate : bool, optional, default False + When set to ``True``, orient tree left to right rather than top-down. + + rounded : bool, optional, default True + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + special_characters : bool, optional, default False + When set to ``False``, ignore special characters for PostScript + compatibility. + + precision : int, optional, default 3 + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + """ + + check_is_fitted(self.tree_model_, 'tree_') + own_file = False + try: + if isinstance(out_file, str): + out_file = open(out_file, "w", encoding="utf-8") + own_file = True + + return_string = out_file is None + if return_string: + out_file = StringIO() + + exporter = self._make_dot_exporter(out_file=out_file, feature_names=feature_names, + treatment_names=treatment_names, + max_depth=max_depth, filled=filled, + leaves_parallel=leaves_parallel, rotate=rotate, rounded=rounded, + special_characters=special_characters, precision=precision) + exporter.export(self.tree_model_, node_dict=self.node_dict_) + + if return_string: + return out_file.getvalue() + + finally: + if own_file: + out_file.close() + + def render(self, out_file, format='pdf', view=True, feature_names=None, + treatment_names=None, + max_depth=None, + filled=True, leaves_parallel=True, rotate=False, rounded=True, + special_characters=False, precision=3): + """ + Render the tree to a flie + + Parameters + ---------- + out_file : file name to save to + + format : string, optional, default 'pdf' + The file format to render to; must be supported by graphviz + + view : bool, optional, default True + Whether to open the rendered result with the default application. + + feature_names : list of strings, optional, default None + Names of each of the features. + + treatment_names : list of strings, optional, default None + Names of each of the treatments + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool, optional, default False + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + leaves_parallel : bool, optional, default True + When set to ``True``, draw all leaf nodes at the bottom of the tree. + + rotate : bool, optional, default False + When set to ``True``, orient tree left to right rather than top-down. + + rounded : bool, optional, default True + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + special_characters : bool, optional, default False + When set to ``False``, ignore special characters for PostScript + compatibility. + + precision : int, optional, default 3 + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + """ + dot_source = self.export_graphviz(out_file=None, # want the output as a string, only write the final file + feature_names=feature_names, treatment_names=treatment_names, + max_depth=max_depth, + filled=filled, + leaves_parallel=leaves_parallel, rotate=rotate, + rounded=rounded, special_characters=special_characters, + precision=precision) + graphviz.Source(dot_source).render(out_file, format=format, view=view) + + def plot(self, ax=None, title=None, feature_names=None, treatment_names=None, + max_depth=None, filled=True, rounded=True, precision=3, fontsize=None): + """ + Exports policy trees to matplotlib + + Parameters + ---------- + ax : :class:`matplotlib.axes.Axes`, optional, default None + The axes on which to plot + + title : string, optional, default None + A title for the final figure to be printed at the top of the page. + + feature_names : list of strings, optional, default None + Names of each of the features. + + treatment_names : list of strings, optional, default None + Names of each of the treatments + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool, optional, default False + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + rounded : bool, optional, default True + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + precision : int, optional, default 3 + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + + fontsize : int, optional, default None + Font size for text + """ + check_is_fitted(self.tree_model_, 'tree_') + exporter = self._make_mpl_exporter(title=title, feature_names=feature_names, treatment_names=treatment_names, + max_depth=max_depth, + filled=filled, + rounded=rounded, precision=precision, fontsize=fontsize) + exporter.export(self.tree_model_, node_dict=self.node_dict_, ax=ax) diff --git a/econml/cate_interpreter/_interpreters.py b/econml/cate_interpreter/_interpreters.py index f3147f373..1146f8680 100644 --- a/econml/cate_interpreter/_interpreters.py +++ b/econml/cate_interpreter/_interpreters.py @@ -2,18 +2,17 @@ # Licensed under the MIT License. import abc +import numbers import numpy as np -from io import StringIO from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier -from sklearn.utils.validation import check_is_fitted -import graphviz -from ._tree_exporter import _CateTreeDOTExporter, _CateTreeMPLExporter, _PolicyTreeDOTExporter, _PolicyTreeMPLExporter +from sklearn.utils import check_array +from ..policy import PolicyTree +from .._tree_exporter import (_SingleTreeExporterMixin, + _CateTreeDOTExporter, _CateTreeMPLExporter, + _PolicyTreeDOTExporter, _PolicyTreeMPLExporter) -class _SingleTreeInterpreter(metaclass=abc.ABCMeta): - - tree_model = None - node_dict = None +class _SingleTreeInterpreter(_SingleTreeExporterMixin, metaclass=abc.ABCMeta): @abc.abstractmethod def interpret(self, cate_estimator, X): @@ -32,226 +31,6 @@ def interpret(self, cate_estimator, X): """ pass - @abc.abstractmethod - def _make_dot_exporter(self, *, out_file, feature_names, filled, - leaves_parallel, rotate, rounded, - special_characters, precision): - """ - Make a dot file exporter - - Parameters - ---------- - out_file : file object - Handle to write to. - - feature_names : list of strings - Names of each of the features. - - filled : bool - When set to ``True``, paint nodes to indicate majority class for - classification, extremity of values for regression, or purity of node - for multi-output. - - leaves_parallel : bool - When set to ``True``, draw all leaf nodes at the bottom of the tree. - - rotate : bool - When set to ``True``, orient tree left to right rather than top-down. - - rounded : bool - When set to ``True``, draw node boxes with rounded corners and use - Helvetica fonts instead of Times-Roman. - - special_characters : bool - When set to ``False``, ignore special characters for PostScript - compatibility. - - precision : int - Number of digits of precision for floating point in the values of - impurity, threshold and value attributes of each node. - """ - pass - - @abc.abstractmethod - def _make_mpl_exporter(self, *, title=None, feature_names=None, - filled=True, rounded=True, precision=3, fontsize=None): - """ - Make a matplotlib exporter - - Parameters - ---------- - title : string - A title for the final figure to be printed at the top of the page. - - feature_names : list of strings - Names of each of the features. - - filled : bool - When set to ``True``, paint nodes to indicate majority class for - classification, extremity of values for regression, or purity of node - for multi-output. - - rounded : bool - When set to ``True``, draw node boxes with rounded corners and use - Helvetica fonts instead of Times-Roman. - - precision : int - Number of digits of precision for floating point in the values of - impurity, threshold and value attributes of each node. - - fontsize : int - Fontsize for text - """ - pass - - def export_graphviz(self, out_file=None, feature_names=None, - filled=True, leaves_parallel=True, - rotate=False, rounded=True, special_characters=False, precision=3): - """ - Export a graphviz dot file representing the learned tree model - - Parameters - ---------- - out_file : file object or string, optional, default None - Handle or name of the output file. If ``None``, the result is - returned as a string. - - feature_names : list of strings, optional, default None - Names of each of the features. - - filled : bool, optional, default False - When set to ``True``, paint nodes to indicate majority class for - classification, extremity of values for regression, or purity of node - for multi-output. - - leaves_parallel : bool, optional, default True - When set to ``True``, draw all leaf nodes at the bottom of the tree. - - rotate : bool, optional, default False - When set to ``True``, orient tree left to right rather than top-down. - - rounded : bool, optional, default True - When set to ``True``, draw node boxes with rounded corners and use - Helvetica fonts instead of Times-Roman. - - special_characters : bool, optional, default False - When set to ``False``, ignore special characters for PostScript - compatibility. - - precision : int, optional, default 3 - Number of digits of precision for floating point in the values of - impurity, threshold and value attributes of each node. - """ - - check_is_fitted(self.tree_model, 'tree_') - own_file = False - try: - if isinstance(out_file, str): - out_file = open(out_file, "w", encoding="utf-8") - own_file = True - - return_string = out_file is None - if return_string: - out_file = StringIO() - - exporter = self._make_dot_exporter(out_file=out_file, feature_names=feature_names, filled=filled, - leaves_parallel=leaves_parallel, rotate=rotate, rounded=rounded, - special_characters=special_characters, precision=precision) - exporter.export(self.tree_model, node_dict=self.node_dict) - - if return_string: - return out_file.getvalue() - - finally: - if own_file: - out_file.close() - - def render(self, out_file, format='pdf', view=True, feature_names=None, - filled=True, leaves_parallel=True, rotate=False, rounded=True, - special_characters=False, precision=3): - """ - Render the tree to a flie - - Parameters - ---------- - out_file : file name to save to - - format : string, optional, default 'pdf' - The file format to render to; must be supported by graphviz - - view : bool, optional, default True - Whether to open the rendered result with the default application. - - feature_names : list of strings, optional, default None - Names of each of the features. - - filled : bool, optional, default False - When set to ``True``, paint nodes to indicate majority class for - classification, extremity of values for regression, or purity of node - for multi-output. - - leaves_parallel : bool, optional, default True - When set to ``True``, draw all leaf nodes at the bottom of the tree. - - rotate : bool, optional, default False - When set to ``True``, orient tree left to right rather than top-down. - - rounded : bool, optional, default True - When set to ``True``, draw node boxes with rounded corners and use - Helvetica fonts instead of Times-Roman. - - special_characters : bool, optional, default False - When set to ``False``, ignore special characters for PostScript - compatibility. - - precision : int, optional, default 3 - Number of digits of precision for floating point in the values of - impurity, threshold and value attributes of each node. - """ - dot_source = self.export_graphviz(out_file=None, # want the output as a string, only write the final file - feature_names=feature_names, filled=filled, - leaves_parallel=leaves_parallel, rotate=rotate, - rounded=rounded, special_characters=special_characters, - precision=precision) - graphviz.Source(dot_source).render(out_file, format=format, view=view) - - def plot(self, ax=None, title=None, feature_names=None, - filled=True, rounded=True, precision=3, fontsize=None): - """ - Exports policy trees to matplotlib - - Parameters - ---------- - ax : :class:`matplotlib.axes.Axes`, optional, default None - The axes on which to plot - - title : string, optional, default None - A title for the final figure to be printed at the top of the page. - - feature_names : list of strings, optional, default None - Names of each of the features. - - filled : bool, optional, default False - When set to ``True``, paint nodes to indicate majority class for - classification, extremity of values for regression, or purity of node - for multi-output. - - rounded : bool, optional, default True - When set to ``True``, draw node boxes with rounded corners and use - Helvetica fonts instead of Times-Roman. - - precision : int, optional, default 3 - Number of digits of precision for floating point in the values of - impurity, threshold and value attributes of each node. - - fontsize : int, optional, default None - Font size for text - """ - check_is_fitted(self.tree_model, 'tree_') - exporter = self._make_mpl_exporter(title=title, feature_names=feature_names, filled=filled, - rounded=rounded, precision=precision, fontsize=fontsize) - exporter.export(self.tree_model, node_dict=self.node_dict, ax=ax) - class SingleTreeCateInterpreter(_SingleTreeInterpreter): """ @@ -259,12 +38,12 @@ class SingleTreeCateInterpreter(_SingleTreeInterpreter): Parameters ---------- - include_uncertainty : bool, optional, default False + include_model_uncertainty : bool, optional, default False Whether to include confidence interval information when building a simplified model of the cate model. If set to True, then cate estimator needs to support the `const_marginal_ate_inference` method. - uncertainty_level : double, optional, default .05 + uncertainty_level : double, optional, default .1 The uncertainty level for the confidence intervals to be constructed and used in the simplified model creation. If value=alpha then a multitask decision tree will be built such that all samples @@ -311,6 +90,22 @@ class SingleTreeCateInterpreter(_SingleTreeInterpreter): the input samples) required to be at a leaf node. Samples have equal weight when sample_weight is not provided. + max_features : int, float or {"auto", "sqrt", "log2"}, default=None + The number of features to consider when looking for the best split: + + - If int, then consider `max_features` features at each split. + - If float, then `max_features` is a fraction and + `int(max_features * n_features)` features are considered at each + split. + - If "auto", then `max_features=n_features`. + - If "sqrt", then `max_features=sqrt(n_features)`. + - If "log2", then `max_features=log2(n_features)`. + - If None, then `max_features=n_features`. + + Note: the search for a split does not stop until at least one + valid partition of the node samples is found, even if it requires to + effectively inspect more than ``max_features`` features. + random_state : int, RandomState instance or None, optional, default None If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; @@ -338,7 +133,7 @@ class SingleTreeCateInterpreter(_SingleTreeInterpreter): if ``sample_weight`` is passed. """ - def __init__(self, + def __init__(self, *, include_model_uncertainty=False, uncertainty_level=.1, uncertainty_only_on_leaves=True, @@ -366,26 +161,43 @@ def __init__(self, self.min_impurity_decrease = min_impurity_decrease def interpret(self, cate_estimator, X): - self.tree_model = DecisionTreeRegressor(criterion=self.criterion, - splitter=self.splitter, - max_depth=self.max_depth, - min_samples_split=self.min_samples_split, - min_samples_leaf=self.min_samples_leaf, - min_weight_fraction_leaf=self.min_weight_fraction_leaf, - max_features=self.max_features, - random_state=self.random_state, - max_leaf_nodes=self.max_leaf_nodes, - min_impurity_decrease=self.min_impurity_decrease) + """ + Interpret the heterogeneity of a CATE estimator when applied to a set of features + + Parameters + ---------- + cate_estimator : :class:`.LinearCateEstimator` + The fitted estimator to interpret + + X : array-like + The features against which to interpret the estimator; + must be compatible shape-wise with the features used to fit + the estimator + + Returns + ------- + self: object instance + """ + self.tree_model_ = DecisionTreeRegressor(criterion=self.criterion, + splitter=self.splitter, + max_depth=self.max_depth, + min_samples_split=self.min_samples_split, + min_samples_leaf=self.min_samples_leaf, + min_weight_fraction_leaf=self.min_weight_fraction_leaf, + max_features=self.max_features, + random_state=self.random_state, + max_leaf_nodes=self.max_leaf_nodes, + min_impurity_decrease=self.min_impurity_decrease) y_pred = cate_estimator.const_marginal_effect(X) - self.tree_model.fit(X, y_pred.reshape((y_pred.shape[0], -1))) - paths = self.tree_model.decision_path(X) + self.tree_model_.fit(X, y_pred.reshape((y_pred.shape[0], -1))) + paths = self.tree_model_.decision_path(X) node_dict = {} for node_id in range(paths.shape[1]): mask = paths.getcol(node_id).toarray().flatten().astype(bool) Xsub = X[mask] if (self.include_uncertainty and - ((not self.uncertainty_only_on_leaves) or (self.tree_model.tree_.children_left[node_id] < 0))): + ((not self.uncertainty_only_on_leaves) or (self.tree_model_.tree_.children_left[node_id] < 0))): res = cate_estimator.const_marginal_ate_inference(Xsub) node_dict[node_id] = {'mean': res.mean_point, 'std': res.std_point, @@ -394,22 +206,28 @@ def interpret(self, cate_estimator, X): cate_node = y_pred[mask] node_dict[node_id] = {'mean': np.mean(cate_node, axis=0), 'std': np.std(cate_node, axis=0)} - self.node_dict = node_dict + self.node_dict_ = node_dict return self - def _make_dot_exporter(self, *, out_file, feature_names, filled, + def _make_dot_exporter(self, *, out_file, feature_names, treatment_names, max_depth, filled, leaves_parallel, rotate, rounded, special_characters, precision): return _CateTreeDOTExporter(self.include_uncertainty, self.uncertainty_level, - out_file=out_file, feature_names=feature_names, filled=filled, + out_file=out_file, feature_names=feature_names, + treatment_names=treatment_names, + max_depth=max_depth, + filled=filled, leaves_parallel=leaves_parallel, rotate=rotate, rounded=rounded, special_characters=special_characters, precision=precision) - def _make_mpl_exporter(self, *, title, feature_names, + def _make_mpl_exporter(self, *, title, feature_names, treatment_names, max_depth, filled, rounded, precision, fontsize): return _CateTreeMPLExporter(self.include_uncertainty, self.uncertainty_level, - title=title, feature_names=feature_names, filled=filled, + title=title, feature_names=feature_names, + treatment_names=treatment_names, + max_depth=max_depth, + filled=filled, rounded=rounded, precision=precision, fontsize=fontsize) @@ -420,7 +238,24 @@ class SingleTreePolicyInterpreter(_SingleTreeInterpreter): Parameters ---------- - risk_level : float or None, + include_model_uncertainty : bool, optional, default False + Whether to include confidence interval information when building a + simplified model of the cate model. If set to True, then + cate estimator needs to support the `const_marginal_ate_inference` method. + + uncertainty_level : double, optional, default .1 + The uncertainty level for the confidence intervals to be constructed + and used in the simplified model creation. If value=alpha + then a multitask decision tree will be built such that all samples + in a leaf have similar target prediction but also similar alpha + confidence intervals. + + uncertainty_only_on_leaves : bool, optional, default True + Whether uncertainty information should be displayed only on leaf nodes. + If False, then interpretation can be slightly slower, especially for cate + models that have a computationally expensive inference method. + + risk_level : float or None, optional (default=None) If None then the point estimate of the CATE of every point will be used as the effect of treatment. If any float alpha and risk_seeking=False (default), then the lower end point of an alpha confidence interval of the CATE will be used. @@ -431,11 +266,6 @@ class SingleTreePolicyInterpreter(_SingleTreeInterpreter): Whether to use an optimistic or pessimistic value for the effect estimate at a sample point. Used only when risk_level is not None. - splitter : string, optional, default "best" - The strategy used to choose the split at each node. Supported - strategies are "best" to choose the best split and "random" to choose - the best random split. - max_depth : int or None, optional, default None The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than @@ -466,16 +296,29 @@ class SingleTreePolicyInterpreter(_SingleTreeInterpreter): the input samples) required to be at a leaf node. Samples have equal weight when sample_weight is not provided. - random_state : int, RandomState instance or None, optional, default None - If int, random_state is the seed used by the random number generator; - If RandomState instance, random_state is the random number generator; - If None, the random number generator is the RandomState instance used - by `np.random`. - - max_leaf_nodes : int or None, optional, default None - Grow a tree with ``max_leaf_nodes`` in best-first fashion. - Best nodes are defined as relative reduction in impurity. - If None then unlimited number of leaf nodes. + max_features : int, float or {"auto", "sqrt", "log2"}, default=None + The number of features to consider when looking for the best split: + + - If int, then consider `max_features` features at each split. + - If float, then `max_features` is a fraction and + `int(max_features * n_features)` features are considered at each + split. + - If "auto", then `max_features=n_features`. + - If "sqrt", then `max_features=sqrt(n_features)`. + - If "log2", then `max_features=log2(n_features)`. + - If None, then `max_features=n_features`. + + Note: the search for a split does not stop until at least one + valid partition of the node samples is found, even if it requires to + effectively inspect more than ``max_features`` features. + + min_balancedness_tol: float in [0, .5], default=.45 + How imbalanced a split we can tolerate. This enforces that each split leaves at least + (.5 - min_balancedness_tol) fraction of samples on each side of the split; or fraction + of the total weight of samples, when sample_weight is not None. Default value, ensures + that at least 5% of the parent node weight falls in each side of the split. Set it to 0.0 for no + balancedness and to .5 for perfectly balanced splits. For the formal inference theory + to be valid, this has to be any positive constant bounded away from zero. min_impurity_decrease : float, optional, default 0. A node will be split if this split induces a decrease of the impurity @@ -492,45 +335,52 @@ class SingleTreePolicyInterpreter(_SingleTreeInterpreter): ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, if ``sample_weight`` is passed. + random_state : int, RandomState instance or None, optional, default None + If int, random_state is the seed used by the random number generator; + If RandomState instance, random_state is the random number generator; + If None, the random number generator is the RandomState instance used + by `np.random`. + Attributes ---------- - tree_model : :class:`~sklearn.tree.DecisionTreeClassifier` - The classifier that determines whether units should be treated; available only after + tree_model_ : :class:`~econml.policy.PolicyTree` + The policy tree model that represents the learned policy; available only after :meth:`interpret` has been called. - policy_value : float + policy_value_ : float The value of applying the learned policy, applied to the sample used with :meth:`interpret` - always_treat_value : float + always_treat_value_ : float The value of the policy that always treats all units, applied to the sample used with :meth:`interpret` - treatment_names : list - The list of treatment names that were passed to :meth:`interpret` """ - def __init__(self, + def __init__(self, *, + include_model_uncertainty=False, + uncertainty_level=.1, + uncertainty_only_on_leaves=True, risk_level=None, risk_seeking=False, - splitter="best", max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0., max_features=None, - random_state=None, - max_leaf_nodes=None, - min_impurity_decrease=0.): + min_balancedness_tol=.45, + min_impurity_decrease=0., + random_state=None): + self.include_uncertainty = include_model_uncertainty + self.uncertainty_level = uncertainty_level + self.uncertainty_only_on_leaves = uncertainty_only_on_leaves self.risk_level = risk_level self.risk_seeking = risk_seeking - self.criterion = "gini" - self.splitter = splitter self.max_depth = max_depth self.min_samples_split = min_samples_split self.min_samples_leaf = min_samples_leaf self.min_weight_fraction_leaf = min_weight_fraction_leaf self.max_features = max_features self.random_state = random_state - self.max_leaf_nodes = max_leaf_nodes self.min_impurity_decrease = min_impurity_decrease + self.min_balancedness_tol = min_balancedness_tol - def interpret(self, cate_estimator, X, sample_treatment_costs=None, treatment_names=None): + def interpret(self, cate_estimator, X, sample_treatment_costs=None): """ Interpret a policy based on a linear CATE estimator when applied to a set of features @@ -545,21 +395,26 @@ def interpret(self, cate_estimator, X, sample_treatment_costs=None, treatment_na the estimator sample_treatment_costs : array-like, optional - The cost of treatment. Can be a scalar or a variable cost with the same number of rows as ``X`` + The cost of treatment. Can be a scalar or have dimension (n_samples, n_treatments) + or (n_samples,) if T is a vector - treatment_names : list of string, optional - The names of the two treatments + Returns + ------- + self: object instance """ - self.tree_model = DecisionTreeClassifier(criterion=self.criterion, - splitter=self.splitter, - max_depth=self.max_depth, - min_samples_split=self.min_samples_split, - min_samples_leaf=self.min_samples_leaf, - min_weight_fraction_leaf=self.min_weight_fraction_leaf, - max_features=self.max_features, - random_state=self.random_state, - max_leaf_nodes=self.max_leaf_nodes, - min_impurity_decrease=self.min_impurity_decrease) + X = check_array(X) + self.tree_model_ = PolicyTree(criterion='neg_welfare', + splitter='best', + max_depth=self.max_depth, + min_samples_split=self.min_samples_split, + min_samples_leaf=self.min_samples_leaf, + min_weight_fraction_leaf=self.min_weight_fraction_leaf, + max_features=self.max_features, + min_impurity_decrease=self.min_impurity_decrease, + min_balancedness_tol=self.min_balancedness_tol, + honest=False, + random_state=self.random_state) + if self.risk_level is None: y_pred = cate_estimator.const_marginal_effect(X) elif not self.risk_seeking: @@ -567,34 +422,52 @@ def interpret(self, cate_estimator, X, sample_treatment_costs=None, treatment_na else: _, y_pred = cate_estimator.const_marginal_effect_interval(X, alpha=self.risk_level) - # TODO: generalize to multiple treatment case? - assert all(d == 1 for d in y_pred.shape[1:]), ("Interpretation is only available for " - "single-dimensional treatments and outcomes") - - y_pred = y_pred.ravel() + # average the outcome dimension if it exists and ensure 2d y_pred + if y_pred.ndim == 3: + y_pred = np.mean(y_pred, axis=1) + elif y_pred.ndim == 2: + if (len(cate_estimator._d_y) > 0) and cate_estimator._d_y[0] > 1: + y_pred = np.mean(y_pred, axis=1, keepdims=True) + elif y_pred.ndim == 1: + y_pred = y_pred.reshape((-1, 1)) if sample_treatment_costs is not None: - assert np.ndim(sample_treatment_costs) < 2, "Sample treatment costs should be a vector or scalar" - y_pred -= sample_treatment_costs + if isinstance(sample_treatment_costs, numbers.Real): + y_pred -= sample_treatment_costs + else: + sample_treatment_costs = check_array(sample_treatment_costs, ensure_2d=False) + if sample_treatment_costs.ndim == 1: + sample_treatment_costs = sample_treatment_costs.reshape((-1, 1)) + if sample_treatment_costs.shape == y_pred.shape: + y_pred -= sample_treatment_costs + else: + raise ValueError("`sample_treatment_costs` should be a double scalar " + "or have dimension (n_samples, n_treatments) or (n_samples,) if T is a vector") # get index of best treatment - all_y = np.hstack([np.zeros((y_pred.shape[0], 1)), y_pred.reshape(-1, 1)]) - best_y = np.argmax(all_y, axis=-1) - - used_t = np.unique(best_y) - if len(used_t) == 1: - best_y, = used_t - if best_y > 0: - raise AttributeError("All samples should be treated with the given treatment costs. " + - "Consider increasing the cost!") + all_y = np.hstack([np.zeros((y_pred.shape[0], 1)), np.atleast_1d(y_pred)]) + + self.tree_model_.fit(X, all_y) + self.policy_value_ = np.mean(np.max(self.tree_model_.predict_value(X), axis=1)) + self.always_treat_value_ = np.mean(y_pred, axis=0) + + paths = self.tree_model_.decision_path(X) + node_dict = {} + for node_id in range(paths.shape[1]): + mask = paths.getcol(node_id).toarray().flatten().astype(bool) + Xsub = X[mask] + if (self.include_uncertainty and + ((not self.uncertainty_only_on_leaves) or (self.tree_model_.tree_.children_left[node_id] < 0))): + res = cate_estimator.const_marginal_ate_inference(Xsub) + node_dict[node_id] = {'mean': res.mean_point, + 'std': res.std_point, + 'ci': res.conf_int_mean(alpha=self.uncertainty_level)} else: - raise AttributeError("No samples should be treated with the given treatment costs. " + - "Consider decreasing the cost!") + cate_node = y_pred[mask] + node_dict[node_id] = {'mean': np.mean(cate_node, axis=0), + 'std': np.std(cate_node, axis=0)} + self.node_dict_ = node_dict - self.tree_model.fit(X, best_y, sample_weight=np.abs(y_pred)) - self.policy_value = np.mean(all_y[:, self.tree_model.predict(X)]) - self.always_treat_value = np.mean(y_pred) - self.treatment_names = treatment_names return self def treat(self, X): @@ -610,30 +483,36 @@ def treat(self, X): Returns ------- T : array-like - The treatments implied by the policy learned by the interpreter + The treatments implied by the policy learned by the interpreter, with treatment 0, meaning + no treatment, and treatment 1 meains the first treatment, etc. """ - assert self.tree_model is not None, "Interpret must be called prior to trying to assign treatment." - return self.tree_model.predict(X) + assert self.tree_model_ is not None, "Interpret must be called prior to trying to assign treatment." + return self.tree_model_.predict(X) - def _make_dot_exporter(self, *, out_file, feature_names, filled, + def _make_dot_exporter(self, *, out_file, feature_names, treatment_names, max_depth, filled, leaves_parallel, rotate, rounded, special_characters, precision): - title = "Average policy gains over no treatment: {} \n".format(np.around(self.policy_value, precision)) - title += "Average policy gains over always treating: {}".format( - np.around(self.policy_value - self.always_treat_value, precision)) + title = "Average policy gains over no treatment: {} \n".format(np.around(self.policy_value_, precision)) + title += "Average policy gains over constant treatment policies for each treatment: {}".format( + np.around(self.policy_value_ - self.always_treat_value_, precision)) return _PolicyTreeDOTExporter(out_file=out_file, title=title, - treatment_names=self.treatment_names, feature_names=feature_names, + treatment_names=treatment_names, + feature_names=feature_names, + max_depth=max_depth, filled=filled, leaves_parallel=leaves_parallel, rotate=rotate, rounded=rounded, special_characters=special_characters, precision=precision) - def _make_mpl_exporter(self, *, title, feature_names, filled, + def _make_mpl_exporter(self, *, title, feature_names, treatment_names, max_depth, filled, rounded, precision, fontsize): title = "" if title is None else title - title += "Average policy gains over no treatment: {} \n".format(np.around(self.policy_value, precision)) - title += "Average policy gains over always treating: {}".format( - np.around(self.policy_value - self.always_treat_value, precision)) - return _PolicyTreeMPLExporter(treatment_names=self.treatment_names, title=title, - feature_names=feature_names, filled=filled, + title += "Average policy gains over no treatment: {} \n".format(np.around(self.policy_value_, precision)) + title += "Average policy gains over constant treatment policies for each treatment: {}".format( + np.around(self.policy_value_ - self.always_treat_value_, precision)) + return _PolicyTreeMPLExporter(treatment_names=treatment_names, + title=title, + feature_names=feature_names, + max_depth=max_depth, + filled=filled, rounded=rounded, precision=precision, fontsize=fontsize) diff --git a/econml/cate_interpreter/_tree_exporter.py b/econml/cate_interpreter/_tree_exporter.py deleted file mode 100644 index cb7186cf3..000000000 --- a/econml/cate_interpreter/_tree_exporter.py +++ /dev/null @@ -1,418 +0,0 @@ -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. - -import numpy as np -import re -try: - import matplotlib - matplotlib.use('Agg') - import matplotlib.pyplot as plt -except ImportError as exn: - from ..utilities import MissingModule - - # make any access to matplotlib or plt throw an exception - matplotlib = plt = MissingModule("matplotlib is no longer a dependency of the main econml package; " - "install econml[plt] or econml[all] to require it, or install matplotlib " - "separately, to use the tree interpreters", exn) - - -# HACK: We're relying on some of sklearn's non-public classes which are not completely stable. -# However, the alternative is reimplementing a bunch of intricate stuff by hand -from sklearn.tree import _tree -try: - from sklearn.tree._export import _BaseTreeExporter, _MPLTreeExporter, _DOTTreeExporter -except ImportError: # prior to sklearn 0.22.0, the ``export`` submodule was public - from sklearn.tree.export import _BaseTreeExporter, _MPLTreeExporter, _DOTTreeExporter - - -class _TreeExporter(_BaseTreeExporter): - """ - Tree exporter that supports replacing the "value" part of each node's text with something customized - """ - - def node_replacement_text(self, tree, node_id, criterion): - return None - - def node_to_str(self, tree, node_id, criterion): - text = super().node_to_str(tree, node_id, criterion) - replacement = self.node_replacement_text(tree, node_id, criterion) - if replacement is not None: - # HACK: it's not optimal to use a regex like this, but the base class's node_to_str doesn't expose any - # clean way of achieving this - text = re.sub("value = .*(?=" + re.escape(self.characters[5]) + ")", - # make sure we don't accidentally escape anything in the substitution - replacement.replace('\\', '\\\\'), - text, - flags=re.S) - return text - - -class _MPLExporter(_MPLTreeExporter): - """ - Base class that supports adding a title to an MPL tree exporter - """ - - def __init__(self, *args, title=None, **kwargs): - self.title = title - super().__init__(*args, **kwargs) - - def export(self, decision_tree, node_dict=None, ax=None): - if ax is None: - ax = plt.gca() - self.node_dict = node_dict - anns = super().export(decision_tree, ax=ax) - if self.title is not None: - ax.set_title(self.title) - return anns - - -class _DOTExporter(_DOTTreeExporter): - """ - Base class that supports adding a title to a DOT tree exporter - """ - - def __init__(self, *args, title=None, **kwargs): - self.title = title - super().__init__(*args, **kwargs) - - def export(self, decision_tree, node_dict=None): - self.node_dict = node_dict - return super().export(decision_tree) - - def tail(self): - if self.title is not None: - self.out_file.write("labelloc=\"t\"; \n") - self.out_file.write("label=\"{}\"; \n".format(self.title)) - super().tail() - - -class _CateTreeMixin(_TreeExporter): - """ - Mixin that supports writing out the nodes of a CATE tree - """ - - def __init__(self, include_uncertainty=False, uncertainty_level=0.1, *args, **kwargs): - self.include_uncertainty = include_uncertainty - self.uncertainty_level = uncertainty_level - super().__init__(*args, **kwargs) - - def get_fill_color(self, tree, node_id): - - # Fetch appropriate color for node - if 'rgb' not in self.colors: - # red for negative, green for positive - self.colors['rgb'] = [(179, 108, 96), (81, 157, 96)] - - # in multi-target use first target - tree_min = np.min(np.mean(tree.value, axis=1)) - tree_max = np.max(np.mean(tree.value, axis=1)) - - node_val = np.mean(tree.value[node_id]) - - if node_val > 0: - value = [max(0, tree_min) / tree_max, node_val / tree_max] - else: - value = [node_val / tree_min, min(0, tree_max) / tree_min] - - return self.get_color(value) - - def node_replacement_text(self, tree, node_id, criterion): - - # Write node mean CATE - node_info = self.node_dict[node_id] - node_string = 'CATE mean' + self.characters[4] - value_text = "" - mean = node_info['mean'] - if hasattr(mean, 'shape') and (len(mean.shape) > 0): - if len(mean.shape) == 1: - for i in range(mean.shape[0]): - value_text += "{}".format(np.around(mean[i], self.precision)) - if 'ci' in node_info: - value_text += " ({}, {})".format(np.around(node_info['ci'][0][i], self.precision), - np.around(node_info['ci'][1][i], self.precision)) - if i != mean.shape[0] - 1: - value_text += ", " - value_text += self.characters[4] - elif len(mean.shape) == 2: - for i in range(mean.shape[0]): - for j in range(mean.shape[1]): - value_text += "{}".format(np.around(mean[i, j], self.precision)) - if 'ci' in node_info: - value_text += " ({}, {})".format(np.around(node_info['ci'][0][i, j], self.precision), - np.around(node_info['ci'][1][i, j], self.precision)) - if j != mean.shape[1] - 1: - value_text += ", " - value_text += self.characters[4] - else: - raise ValueError("can only handle up to 2d values") - else: - value_text += "{}".format(np.around(mean, self.precision)) - if 'ci' in node_info: - value_text += " ({}, {})".format(np.around(node_info['ci'][0], self.precision), - np.around(node_info['ci'][1], self.precision)) + self.characters[4] - node_string += value_text - - # Write node std of CATE - node_string += "CATE std" + self.characters[4] - std = node_info['std'] - value_text = "" - if hasattr(std, 'shape') and (len(std.shape) > 0): - if len(std.shape) == 1: - for i in range(std.shape[0]): - value_text += "{}".format(np.around(std[i], self.precision)) - if i != std.shape[0] - 1: - value_text += ", " - elif len(std.shape) == 2: - for i in range(std.shape[0]): - for j in range(std.shape[1]): - value_text += "{}".format(np.around(std[i, j], self.precision)) - if j != std.shape[1] - 1: - value_text += ", " - if i != std.shape[0] - 1: - value_text += self.characters[4] - else: - raise ValueError("can only handle up to 2d values") - else: - value_text += "{}".format(np.around(std, self.precision)) - node_string += value_text - - return node_string - - -class _PolicyTreeMixin(_TreeExporter): - """ - Mixin that supports writing out the nodes of a policy tree - - Parameters - ---------- - treatment_names : list of strings, optional, default None - The names of the two treatments - """ - - def __init__(self, treatment_names=None, *args, **kwargs): - self.treatment_names = treatment_names - super().__init__(*args, **kwargs) - - def get_fill_color(self, tree, node_id): - # Fetch appropriate color for node - if 'rgb' not in self.colors: - # red for negative, green for positive - self.colors['rgb'] = [(179, 108, 96), (81, 157, 96)] - - node_val = tree.value[node_id][0, :] / tree.weighted_n_node_samples[node_id] - return self.get_color(node_val) - - def node_replacement_text(self, tree, node_id, criterion): - value = tree.value[node_id][0, :] - node_string = '(effect - cost) mean = %s' % np.round((value[1] - - value[0]) / tree.n_node_samples[node_id], - self.precision) - node_string += self.characters[4] - - if tree.children_left[node_id] == _tree.TREE_LEAF: - # Write node mean CATE - node_string += 'Recommended Treatment = ' - if self.treatment_names: - class_name = self.treatment_names[np.argmax(value)] - else: - class_name = "T%s%s%s" % (self.characters[1], - np.argmax(value), - self.characters[2]) - node_string += class_name + self.characters[4] - - return node_string - - -class _PolicyTreeMPLExporter(_PolicyTreeMixin, _MPLExporter): - """ - Exports policy trees to matplotlib - - Parameters - ---------- - treatment_names : list of strings, optional, default None - The names of the two treatments - - title : string, optional, default None - A title for the final figure to be printed at the top of the page. - - feature_names : list of strings, optional, default None - Names of each of the features. - - filled : bool, optional, default False - When set to ``True``, paint nodes to indicate majority class for - classification, extremity of values for regression, or purity of node - for multi-output. - - rounded : bool, optional, default False - When set to ``True``, draw node boxes with rounded corners and use - Helvetica fonts instead of Times-Roman. - - precision : int, optional, default 3 - Number of digits of precision for floating point in the values of - impurity, threshold and value attributes of each node. - - fontsize : int, optional, default None - Fontsize for text - """ - - def __init__(self, treatment_names=None, title=None, feature_names=None, - filled=True, - rounded=False, precision=3, fontsize=None): - super().__init__(treatment_names=treatment_names, title=title, - feature_names=feature_names, filled=filled, rounded=rounded, precision=precision, - fontsize=fontsize, - impurity=False) - - -class _CateTreeMPLExporter(_CateTreeMixin, _MPLExporter): - """ - Exports CATE trees into matplotlib - - Parameters - ---------- - include_uncertainty: bool - whether the tree includes uncertainty information - - uncertainty_level: float - the confidence level of the confidence interval included in the tree - - title : string, optional, default None - A title for the final figure to be printed at the top of the page. - - feature_names : list of strings, optional, default None - Names of each of the features. - - filled : bool, optional, default False - When set to ``True``, paint nodes to indicate majority class for - classification, extremity of values for regression, or purity of node - for multi-output. - - rounded : bool, optional, default False - When set to ``True``, draw node boxes with rounded corners and use - Helvetica fonts instead of Times-Roman. - - precision : int, optional, default 3 - Number of digits of precision for floating point in the values of - impurity, threshold and value attributes of each node. - - fontsize : int, optional, default None - Fontsize for text - """ - - def __init__(self, include_uncertainty, uncertainty_level, title=None, - feature_names=None, filled=True, rounded=False, precision=3, fontsize=None): - super().__init__(include_uncertainty, uncertainty_level, title=None, - feature_names=feature_names, filled=filled, - rounded=rounded, precision=precision, fontsize=fontsize, - impurity=False) - - -class _PolicyTreeDOTExporter(_PolicyTreeMixin, _DOTExporter): - """ - Exports policy trees to dot files - - Parameters - ---------- - out_file : file object or string, optional, default None - Handle or name of the output file. If ``None``, the result is - returned as a string. - - title : string, optional, default None - A title for the final figure to be printed at the top of the page. - - treatment_names : list of strings, optional, default None - The names of the two treatments - - feature_names : list of strings, optional, default None - Names of each of the features. - - filled : bool, optional, default False - When set to ``True``, paint nodes to indicate majority class for - classification, extremity of values for regression, or purity of node - for multi-output. - - leaves_parallel : bool, optional, default False - When set to ``True``, draw all leaf nodes at the bottom of the tree. - - rotate : bool, optional, default False - When set to ``True``, orient tree left to right rather than top-down. - - rounded : bool, optional, default False - When set to ``True``, draw node boxes with rounded corners and use - Helvetica fonts instead of Times-Roman. - - special_characters : bool, optional, default False - When set to ``False``, ignore special characters for PostScript - compatibility. - - precision : int, optional, default 3 - Number of digits of precision for floating point in the values of - impurity, threshold and value attributes of each node. - """ - - def __init__(self, out_file=None, title=None, treatment_names=None, feature_names=None, - filled=True, leaves_parallel=False, - rotate=False, rounded=False, special_characters=False, precision=3): - super().__init__(title=title, out_file=out_file, feature_names=feature_names, - filled=filled, leaves_parallel=leaves_parallel, - rotate=rotate, rounded=rounded, special_characters=special_characters, - precision=precision, treatment_names=treatment_names, - impurity=False) - - -class _CateTreeDOTExporter(_CateTreeMixin, _DOTExporter): - """ - Exports CATE trees to dot files - - Parameters - ---------- - include_uncertainty: bool - whether the tree includes uncertainty information - - uncertainty_level: float - the confidence level of the confidence interval included in the tree - - out_file : file object or string, optional, default None - Handle or name of the output file. If ``None``, the result is - returned as a string. - - title : string, optional, default None - A title for the final figure to be printed at the top of the page. - - feature_names : list of strings, optional, default None - Names of each of the features. - - filled : bool, optional, default False - When set to ``True``, paint nodes to indicate majority class for - classification, extremity of values for regression, or purity of node - for multi-output. - - leaves_parallel : bool, optional, default False - When set to ``True``, draw all leaf nodes at the bottom of the tree. - - rotate : bool, optional, default False - When set to ``True``, orient tree left to right rather than top-down. - - rounded : bool, optional, default False - When set to ``True``, draw node boxes with rounded corners and use - Helvetica fonts instead of Times-Roman. - - special_characters : bool, optional, default False - When set to ``False``, ignore special characters for PostScript - compatibility. - - precision : int, optional, default 3 - Number of digits of precision for floating point in the values of - impurity, threshold and value attributes of each node. - """ - - def __init__(self, include_uncertainty, uncertainty_level, out_file=None, title=None, feature_names=None, - filled=True, leaves_parallel=False, - rotate=False, rounded=False, special_characters=False, precision=3): - - super().__init__(include_uncertainty, uncertainty_level, - out_file=out_file, title=title, feature_names=feature_names, - filled=filled, leaves_parallel=leaves_parallel, - rotate=rotate, rounded=rounded, special_characters=special_characters, - precision=precision, - impurity=False) diff --git a/econml/dr/_drlearner.py b/econml/dr/_drlearner.py index 3e0e48d52..03edf8e62 100644 --- a/econml/dr/_drlearner.py +++ b/econml/dr/_drlearner.py @@ -1314,12 +1314,31 @@ class ForestDRLearner(ForestModelFinalCateEstimatorDiscreteMixin, DRLearner): ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, if ``sample_weight`` is passed. + max_samples : int or float in (0, .5], default=.45, + The number of samples to use for each subsample that is used to train each tree: + + - If int, then train each tree on `max_samples` samples, sampled without replacement from all the samples + - If float, then train each tree on ceil(`max_samples` * `n_samples`), sampled without replacement + from all the samples. + + min_balancedness_tol: float in [0, .5], default=.45 + How imbalanced a split we can tolerate. This enforces that each split leaves at least + (.5 - min_balancedness_tol) fraction of samples on each side of the split; or fraction + of the total weight of samples, when sample_weight is not None. Default value, ensures + that at least 5% of the parent node weight falls in each side of the split. Set it to 0.0 for no + balancedness and to .5 for perfectly balanced splits. For the formal inference theory + to be valid, this has to be any positive constant bounded away from zero. + honest : boolean, optional (default=True) Whether to use honest trees, i.e. half of the samples are used for creating the tree structure and the other half for the estimation at the leafs. If False, then all samples are used for both parts. - n_jobs : int or None, optional (default=None) + subforest_size : int, default=4, + The number of trees in each sub-forest that is used in the bootstrap-of-little-bags calculation. + The parameter `n_estimators` must be divisible by `subforest_size`. Should typically be a small constant. + + n_jobs : int or None, optional (default=-1) The number of jobs to run in parallel for both `fit` and `predict`. ``None`` means 1 unless in a :func:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` diff --git a/econml/grf/_base_grf.py b/econml/grf/_base_grf.py index fc4136da1..4b3ea8bee 100644 --- a/econml/grf/_base_grf.py +++ b/econml/grf/_base_grf.py @@ -14,7 +14,9 @@ from abc import ABCMeta, abstractmethod import numpy as np import threading -from ._ensemble import BaseEnsemble, _partition_estimators +from .._ensemble import (BaseEnsemble, _partition_estimators, _get_n_samples_subsample, + _accumulate_prediction, _accumulate_prediction_var, _accumulate_prediction_and_var, + _accumulate_oob_preds) from ..utilities import check_inputs, cross_product from ..tree._tree import DTYPE, DOUBLE from ._base_grftree import GRFTree @@ -30,118 +32,6 @@ MAX_INT = np.iinfo(np.int32).max - -def _get_n_samples_subsample(n_samples, max_samples): - """ - Get the number of samples in a sub-sample without replacement. - Parameters - ---------- - n_samples : int - Number of samples in the dataset. - max_samples : int or float - The maximum number of samples to draw from the total available: - - if float, this indicates a fraction of the total and should be - the interval `(0, 1)`; - - if int, this indicates the exact number of samples; - - if None, this indicates the total number of samples. - Returns - ------- - n_samples_subsample : int - The total number of samples to draw for the subsample. - """ - if max_samples is None: - return n_samples - - if isinstance(max_samples, numbers.Integral): - if not (1 <= max_samples <= n_samples): - msg = "`max_samples` must be in range 1 to {} but got value {}" - raise ValueError(msg.format(n_samples, max_samples)) - return max_samples - - if isinstance(max_samples, numbers.Real): - if not (0 < max_samples <= 1): - msg = "`max_samples` must be in range (0, 1) but got value {}" - raise ValueError(msg.format(max_samples)) - return int(round(n_samples * max_samples)) - - msg = "`max_samples` should be int or float, but got type '{}'" - raise TypeError(msg.format(type(max_samples))) - - -def _accumulate_prediction(predict, X, out, lock, *args, **kwargs): - """ - This is a utility function for joblib's Parallel. - It can't go locally in ForestClassifier or ForestRegressor, because joblib - complains that it cannot pickle it when placed there. - """ - prediction = predict(X, *args, check_input=False, **kwargs) - with lock: - if len(out) == 1: - out[0] += prediction - else: - for i in range(len(out)): - out[i] += prediction[i] - - -def _accumulate_prediction_var(predict, X, out, lock, *args, **kwargs): - """ - This is a utility function for joblib's Parallel. - It can't go locally in ForestClassifier or ForestRegressor, because joblib - complains that it cannot pickle it when placed there. - Accumulates the mean covariance of a tree prediction. predict is assumed to - return an array of (n_samples, d) or a tuple of arrays. This method accumulates in the placeholder - out[0] the (n_samples, d, d) covariance of the columns of the prediction across - the trees and for each sample (or a tuple of covariances to be stored in each element - of the list out). - """ - prediction = predict(X, *args, check_input=False, **kwargs) - with lock: - if len(out) == 1: - out[0] += np.einsum('ijk,ikm->ijm', - prediction.reshape(prediction.shape + (1,)), - prediction.reshape((-1, 1) + prediction.shape[1:])) - else: - for i in range(len(out)): - pred_i = prediction[i] - out[i] += np.einsum('ijk,ikm->ijm', - pred_i.reshape(pred_i.shape + (1,)), - pred_i.reshape((-1, 1) + pred_i.shape[1:])) - - -def _accumulate_prediction_and_var(predict, X, out, out_var, lock, *args, **kwargs): - """ - This is a utility function for joblib's Parallel. - It can't go locally in ForestClassifier or ForestRegressor, because joblib - complains that it cannot pickle it when placed there. - Combines `_accumulate_prediction` and `_accumulate_prediction_var` in a single - parallel run, so that out will contain the mean of the predictions across trees - and out_var the covariance. - """ - prediction = predict(X, *args, check_input=False, **kwargs) - with lock: - if len(out) == 1: - out[0] += prediction - out_var[0] += np.einsum('ijk,ikm->ijm', - prediction.reshape(prediction.shape + (1,)), - prediction.reshape((-1, 1) + prediction.shape[1:])) - else: - for i in range(len(out)): - pred_i = prediction[i] - out[i] += prediction - out_var[i] += np.einsum('ijk,ikm->ijm', - pred_i.reshape(pred_i.shape + (1,)), - pred_i.reshape((-1, 1) + pred_i.shape[1:])) - - -def _accumulate_oob_preds(tree, X, subsample_inds, alpha_hat, jac_hat, counts, lock): - mask = np.ones(X.shape[0], dtype=bool) - mask[subsample_inds] = False - alpha, jac = tree.predict_alpha_and_jac(X[mask]) - with lock: - alpha_hat[mask] += alpha - jac_hat[mask] += jac - counts[mask] += 1 - # ============================================================================= # Base Generalized Random Forest # ============================================================================= @@ -485,7 +375,7 @@ def fit(self, X, T, y, *, sample_weight=None, sample_var=None, **kwargs): # Advancing subsample_random_state. Assumes each prior fit call has the same number of # samples at fit time. If not then this would not exactly replicate a single batch execution, # but would still advance randomness enough so that tree subsamples will be different. - for _, n_, ns_ in range(len(self.estimators_), self.n_samples_, self.n_samples_subsample_): + for _, n_, ns_ in zip(range(len(self.estimators_)), self.n_samples_, self.n_samples_subsample_): subsample_random_state.choice(n_, ns_, replace=False) new_slices = [] s_inds = [subsample_random_state.choice(n_samples, n_samples_subsample, replace=False) diff --git a/econml/grf/_base_grftree.py b/econml/grf/_base_grftree.py index b302c5199..4454420d1 100644 --- a/econml/grf/_base_grftree.py +++ b/econml/grf/_base_grftree.py @@ -10,20 +10,11 @@ # All rights reserved. import numpy as np -import numbers -from math import ceil -from ..tree import Tree from ._criterion import LinearMomentGRFCriterionMSE, LinearMomentGRFCriterion -from ..tree._criterion import Criterion -from ..tree._splitter import Splitter, BestSplitter -from ..tree import DepthFirstTreeBuilder -from . import _criterion -from ..tree import _tree -from sklearn.base import BaseEstimator +from ..tree import BaseTree from sklearn.model_selection import train_test_split from sklearn.utils import check_array from sklearn.utils import check_random_state -from sklearn.utils.validation import _check_sample_weight from sklearn.utils.validation import check_is_fitted import copy @@ -31,22 +22,16 @@ # Types and constants # ============================================================================= -DTYPE = _tree.DTYPE -DOUBLE = _tree.DOUBLE CRITERIA_GRF = {"het": LinearMomentGRFCriterion, "mse": LinearMomentGRFCriterionMSE} -SPLITTERS = {"best": BestSplitter, } - -MAX_INT = np.iinfo(np.int32).max - # ============================================================================= # Base GRF tree # ============================================================================= -class GRFTree(BaseEstimator): +class GRFTree(BaseTree): """A tree of a Generalized Random Forest [grftree1]. This method should be used primarily through the BaseGRF forest class and its derivatives and not as a standalone estimator. It fits a tree that solves the local moment equation problem:: @@ -314,43 +299,28 @@ def __init__(self, *, min_impurity_decrease=0., min_balancedness_tol=0.45, honest=True): - self.criterion = criterion - self.splitter = splitter - self.max_depth = max_depth - self.min_samples_split = min_samples_split - self.min_samples_leaf = min_samples_leaf - self.min_weight_fraction_leaf = min_weight_fraction_leaf - self.min_var_leaf = min_var_leaf - self.min_var_leaf_on_val = min_var_leaf_on_val - self.max_features = max_features - self.random_state = random_state - self.min_impurity_decrease = min_impurity_decrease - self.min_balancedness_tol = min_balancedness_tol - self.honest = honest - - def get_depth(self): - """Return the depth of the decision tree. - The depth of a tree is the maximum distance between the root - and any leaf. - - Returns - ------- - self.tree_.max_depth : int - The maximum depth of the tree. - """ - check_is_fitted(self) - return self.tree_.max_depth - - def get_n_leaves(self): - """Return the number of leaves of the decision tree. - - Returns - ------- - self.tree_.n_leaves : int - Number of leaves. - """ - check_is_fitted(self) - return self.tree_.n_leaves + super().__init__(criterion=criterion, + splitter=splitter, + max_depth=max_depth, + min_samples_split=min_samples_split, + min_samples_leaf=min_samples_leaf, + min_weight_fraction_leaf=min_weight_fraction_leaf, + min_var_leaf=min_var_leaf, + min_var_leaf_on_val=min_var_leaf_on_val, + max_features=max_features, + random_state=random_state, + min_impurity_decrease=min_impurity_decrease, + min_balancedness_tol=min_balancedness_tol, + honest=honest) + + def _get_valid_criteria(self): + return CRITERIA_GRF + + def _get_valid_min_var_leaf_criteria(self): + return (LinearMomentGRFCriterion,) + + def _get_store_jac(self): + return True def init(self,): """ This method should be called before fit. We added this pre-fit step so that this step @@ -394,217 +364,8 @@ def fit(self, X, y, n_y, n_outputs, n_relevant_outputs, sample_weight=None, chec forest class that spawned this tree. """ - random_state = self.random_state_ - - # Determine output settings - n_samples, self.n_features_ = X.shape - self.n_outputs_ = n_outputs - self.n_relevant_outputs_ = n_relevant_outputs - self.n_y_ = n_y - self.n_samples_ = n_samples - self.honest_ = self.honest - - # Important: This must be the first invocation of the random state at fit time, so that - # train/test splits are re-generatable from an external object simply by knowing the - # random_state parameter of the tree. Can be useful in the future if one wants to create local - # linear predictions. Currently is also useful for testing. - inds = np.arange(n_samples, dtype=np.intp) - if self.honest: - random_state.shuffle(inds) - samples_train, samples_val = inds[:n_samples // 2], inds[n_samples // 2:] - else: - samples_train, samples_val = inds, inds - - if check_input: - if getattr(y, "dtype", None) != DOUBLE or not y.flags.contiguous: - y = np.ascontiguousarray(y, dtype=DOUBLE) - y = np.atleast_1d(y) - if y.ndim == 1: - # reshape is necessary to preserve the data contiguity against vs - # [:, np.newaxis] that does not. - y = np.reshape(y, (-1, 1)) - if len(y) != n_samples: - raise ValueError("Number of labels=%d does not match " - "number of samples=%d" % (len(y), n_samples)) - - if (sample_weight is not None): - sample_weight = _check_sample_weight(sample_weight, X, DOUBLE) - - # Check parameters - max_depth = (np.iinfo(np.int32).max if self.max_depth is None - else self.max_depth) - - if isinstance(self.min_samples_leaf, numbers.Integral): - if not 1 <= self.min_samples_leaf: - raise ValueError("min_samples_leaf must be at least 1 " - "or in (0, 0.5], got %s" - % self.min_samples_leaf) - min_samples_leaf = self.min_samples_leaf - else: # float - if not 0. < self.min_samples_leaf <= 0.5: - raise ValueError("min_samples_leaf must be at least 1 " - "or in (0, 0.5], got %s" - % self.min_samples_leaf) - min_samples_leaf = int(ceil(self.min_samples_leaf * n_samples)) - - if isinstance(self.min_samples_split, numbers.Integral): - if not 2 <= self.min_samples_split: - raise ValueError("min_samples_split must be an integer " - "greater than 1 or a float in (0.0, 1.0]; " - "got the integer %s" - % self.min_samples_split) - min_samples_split = self.min_samples_split - else: # float - if not 0. < self.min_samples_split <= 1.: - raise ValueError("min_samples_split must be an integer " - "greater than 1 or a float in (0.0, 1.0]; " - "got the float %s" - % self.min_samples_split) - min_samples_split = int(ceil(self.min_samples_split * n_samples)) - min_samples_split = max(2, min_samples_split) - - min_samples_split = max(min_samples_split, 2 * min_samples_leaf) - - if isinstance(self.max_features, str): - if self.max_features == "auto": - max_features = self.n_features_ - elif self.max_features == "sqrt": - max_features = max(1, int(np.sqrt(self.n_features_))) - elif self.max_features == "log2": - max_features = max(1, int(np.log2(self.n_features_))) - else: - raise ValueError("Invalid value for max_features. " - "Allowed string values are 'auto', " - "'sqrt' or 'log2'.") - elif self.max_features is None: - max_features = self.n_features_ - elif isinstance(self.max_features, numbers.Integral): - max_features = self.max_features - else: # float - if self.max_features > 0.0: - max_features = max(1, - int(self.max_features * self.n_features_)) - else: - max_features = 0 - - self.max_features_ = max_features - - if not 0 <= self.min_weight_fraction_leaf <= 0.5: - raise ValueError("min_weight_fraction_leaf must in [0, 0.5]") - if max_depth < 0: - raise ValueError("max_depth must be greater than or equal to zero. ") - if not (0 < max_features <= self.n_features_): - raise ValueError("max_features must be in (0, n_features]") - if not 0 <= self.min_balancedness_tol <= 0.5: - raise ValueError("min_balancedness_tol must be in [0, 0.5]") - - if self.min_var_leaf is None: - min_var_leaf = -1.0 - elif isinstance(self.min_var_leaf, numbers.Real) and (self.min_var_leaf >= 0.0): - min_var_leaf = self.min_var_leaf - else: - raise ValueError("min_var_leaf must be either None or a real in [0, infinity). " - "Got {}".format(self.min_var_leaf)) - if not isinstance(self.min_var_leaf_on_val, bool): - raise ValueError("min_var_leaf_on_val must be either True or False. " - "Got {}".format(self.min_var_leaf_on_val)) - - # Set min_weight_leaf from min_weight_fraction_leaf - if sample_weight is None: - min_weight_leaf = (self.min_weight_fraction_leaf * - n_samples) - else: - min_weight_leaf = (self.min_weight_fraction_leaf * - np.sum(sample_weight)) - - # Build tree - - # We calculate the maximum number of samples from each half-split that any node in the tree can - # hold. Used by criterion for memory space savings. - max_train = len(samples_train) if sample_weight is None else np.count_nonzero(sample_weight[samples_train]) - if self.honest: - max_val = len(samples_val) if sample_weight is None else np.count_nonzero(sample_weight[samples_val]) - # Initialize the criterion object and the criterion_val object if honest. - if callable(self.criterion): - criterion = self.criterion(self.n_outputs_, self.n_relevant_outputs_, self.n_features_, self.n_y_, - n_samples, max_train, - random_state.randint(np.iinfo(np.int32).max)) - if not isinstance(criterion, Criterion): - raise ValueError("Input criterion is not a valid criterion") - if self.honest: - criterion_val = self.criterion(self.n_outputs_, self.n_relevant_outputs_, self.n_features_, self.n_y_, - n_samples, max_val, - random_state.randint(np.iinfo(np.int32).max)) - else: - criterion_val = criterion - else: - criterion = CRITERIA_GRF[self.criterion]( - self.n_outputs_, self.n_relevant_outputs_, self.n_features_, self.n_y_, n_samples, max_train, - random_state.randint(np.iinfo(np.int32).max)) - if self.honest: - criterion_val = CRITERIA_GRF[self.criterion]( - self.n_outputs_, self.n_relevant_outputs_, self.n_features_, self.n_y_, n_samples, max_val, - random_state.randint(np.iinfo(np.int32).max)) - else: - criterion_val = criterion - - if (min_var_leaf >= 0.0 and (not isinstance(criterion, LinearMomentGRFCriterion)) and - (not isinstance(criterion_val, LinearMomentGRFCriterion))): - raise ValueError("This criterion does not support min_var_leaf constraint!") - - splitter = self.splitter - if not isinstance(self.splitter, Splitter): - splitter = SPLITTERS[self.splitter](criterion, criterion_val, - self.max_features_, - min_samples_leaf, - min_weight_leaf, - self.min_balancedness_tol, - self.honest, - min_var_leaf, - self.min_var_leaf_on_val, - random_state.randint(np.iinfo(np.int32).max)) - - self.tree_ = Tree(self.n_features_, self.n_outputs_, self.n_relevant_outputs_, store_jac=True) - - builder = DepthFirstTreeBuilder(splitter, min_samples_split, - min_samples_leaf, - min_weight_leaf, - max_depth, - self.min_impurity_decrease) - builder.build(self.tree_, X, y, samples_train, samples_val, - sample_weight=sample_weight, - store_jac=True) - - return self - - def _validate_X_predict(self, X, check_input): - """Validate X whenever one tries to predict, apply, or any other of the prediction - related methods. """ - if check_input: - X = check_array(X, dtype=DTYPE, accept_sparse=False) - - n_features = X.shape[1] - if self.n_features_ != n_features: - raise ValueError("Number of features of the model must " - "match the input. Model n_features is %s and " - "input n_features is %s " - % (self.n_features_, n_features)) - - return X - - def get_train_test_split_inds(self,): - """ Regenerate the train_test_split of input sample indices that was used for the training - and the evaluation split of the honest tree construction structure. Uses the same random seed - that was used at ``fit`` time and re-generates the indices. - """ - check_is_fitted(self) - random_state = check_random_state(self.random_seed_) - inds = np.arange(self.n_samples_, dtype=np.intp) - if self.honest_: - random_state.shuffle(inds) - return inds[:self.n_samples_ // 2], inds[self.n_samples_ // 2:] - else: - return inds, inds + return super().fit(X, y, n_y, n_outputs, n_relevant_outputs, + sample_weight=sample_weight, check_input=check_input) def predict(self, X, check_input=True): """Return the prefix of relevant fitted local parameters for each X, i.e. theta(X). @@ -699,51 +460,6 @@ def predict_moment(self, X, parameter, check_input=True): alpha, jac = self.predict_alpha_and_jac(X) return alpha - np.einsum('ijk,ik->ij', jac.reshape((-1, self.n_outputs_, self.n_outputs_)), parameter) - def apply(self, X, check_input=True): - """Return the index of the leaf that each sample is predicted as. - - Parameters - ---------- - X : {array-like} of shape (n_samples, n_features) - The input samples. Internally, it will be converted to - ``dtype=np.float64`` - check_input : bool, default=True - Allow to bypass several input checking. - Don't use this parameter unless you know what you do. - - Returns - ------- - X_leaves : array-like of shape (n_samples,) - For each datapoint x in X, return the index of the leaf x - ends up in. Leaves are numbered within - ``[0; self.tree_.node_count)``, possibly with gaps in the - numbering. - """ - check_is_fitted(self) - X = self._validate_X_predict(X, check_input) - return self.tree_.apply(X) - - def decision_path(self, X, check_input=True): - """Return the decision path in the tree. - - Parameters - ---------- - X : {array-like} of shape (n_samples, n_features) - The input samples. Internally, it will be converted to - ``dtype=np.float64`` - check_input : bool, default=True - Allow to bypass several input checking. - Don't use this parameter unless you know what you do. - - Returns - ------- - indicator : sparse matrix of shape (n_samples, n_nodes) - Return a node indicator CSR matrix where non zero elements - indicates that the samples goes through the nodes. - """ - X = self._validate_X_predict(X, check_input) - return self.tree_.decision_path(X) - def feature_importances(self, max_depth=4, depth_decay_exponent=2.0): """The feature importances based on the amount of parameter heterogeneity they create. The higher, the more important the feature. diff --git a/econml/policy/__init__.py b/econml/policy/__init__.py new file mode 100644 index 000000000..eebcbcbea --- /dev/null +++ b/econml/policy/__init__.py @@ -0,0 +1,10 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from ._forest import PolicyTree, PolicyForest +from ._drlearner import DRPolicyTree, DRPolicyForest + +__all__ = ["PolicyTree", + "PolicyForest", + "DRPolicyTree", + "DRPolicyForest"] diff --git a/econml/policy/_base.py b/econml/policy/_base.py new file mode 100644 index 000000000..d2e1d847d --- /dev/null +++ b/econml/policy/_base.py @@ -0,0 +1,19 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +"""Base classes for all Policy estimators.""" + +import abc +import numpy as np + + +class PolicyLearner(metaclass=abc.ABCMeta): + + def fit(self, Y, T, *, X=None, **kwargs): + pass + + def predict_value(self, X): + pass + + def predict(self, X): + pass diff --git a/econml/policy/_drlearner.py b/econml/policy/_drlearner.py new file mode 100644 index 000000000..145a36fd9 --- /dev/null +++ b/econml/policy/_drlearner.py @@ -0,0 +1,1025 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from warnings import warn +import numpy as np +from sklearn.base import clone +from ..utilities import check_inputs, filter_none_kwargs +from ..dr import DRLearner +from ..dr._drlearner import _ModelFinal +from .._tree_exporter import _SingleTreeExporterMixin +from ._base import PolicyLearner +from . import PolicyTree, PolicyForest + + +class _PolicyModelFinal(_ModelFinal): + + def fit(self, Y, T, X=None, W=None, *, nuisances, sample_weight=None, sample_var=None): + if sample_var is not None: + warn('Parameter `sample_var` is ignored by the final estimator') + sample_var = None + Y_pred, = nuisances + self.d_y = Y_pred.shape[1:-1] # track whether there's a Y dimension (must be a singleton) + if (X is not None) and (self._featurizer is not None): + X = self._featurizer.fit_transform(X) + filtered_kwargs = filter_none_kwargs(sample_weight=sample_weight, sample_var=sample_var) + ys = Y_pred[..., 1:] - Y_pred[..., [0]] # subtract control results from each other arm + if self.d_y: # need to squeeze out singleton so that we fit on 2D array + ys = ys.squeeze(1) + ys = np.hstack([np.zeros((ys.shape[0], 1)), ys]) + self.model_cate = self._model_final.fit(X, ys, **filtered_kwargs) + return self + + def predict(self, X=None): + if (X is not None) and (self._featurizer is not None): + X = self._featurizer.transform(X) + pred = self.model_cate.predict_value(X)[:, 1:] + if self.d_y: # need to reintroduce singleton Y dimension + return pred[:, np.newaxis, :] + return pred + + def score(self, Y, T, X=None, W=None, *, nuisances, sample_weight=None, sample_var=None): + return 0 + + +class _DRLearnerWrapper(DRLearner): + + def _gen_ortho_learner_model_final(self): + return _PolicyModelFinal(self._gen_model_final(), self._gen_featurizer(), self.multitask_model_final) + + +class _BaseDRPolicyLearner(PolicyLearner): + + def _gen_drpolicy_learner(self): + pass + + def fit(self, Y, T, *, X=None, W=None, sample_weight=None, groups=None): + """ + Estimate a policy model from data. + + Parameters + ---------- + Y: (n,) vector of length n + Outcomes for each sample + T: (n,) vector of length n + Treatments for each sample + X: optional(n, d_x) matrix or None (Default=None) + Features for each sample + W: optional(n, d_w) matrix or None (Default=None) + Controls for each sample + sample_weight: optional(n,) vector or None (Default=None) + Weights for each samples + groups: (n,) vector, optional + All rows corresponding to the same group will be kept together during splitting. + If groups is not None, the `cv` argument passed to this class's initializer + must support a 'groups' argument to its split method. + + Returns + ------- + self: object instance + """ + self.drlearner_ = self._gen_drpolicy_learner() + self.drlearner_.fit(Y, T, X=X, W=W, sample_weight=sample_weight, groups=groups) + return self + + def predict_value(self, X): + """ Get effect values for each non-baseline treatment and for each sample. + + Parameters + ---------- + X : array-like of shape (n_samples, n_features) + The training input samples. + + Returns + ------- + values : array-like of shape (n_samples, n_treatments - 1) + The predicted average value for each sample and for each non-baseline treatment, as compared + to the baseline treatment value and based on the feature neighborhoods defined by the trees. + """ + return self.drlearner_.const_marginal_effect(X) + + def predict(self, X): + """ Get recommended treatment for each sample. + + Parameters + ---------- + X : array-like of shape (n_samples, n_features) + The training input samples. + + Returns + ------- + treatment : array-like of shape (n_samples,) + The index of the recommended treatment in the same order as in categories, or in + lexicographic order if `categories='auto'`. 0 corresponds to the baseline/control treatment. + """ + values = self.predict_value(X) + return np.argmax(np.hstack([np.zeros((values.shape[0], 1)), values]), axis=1) + + def policy_feature_names(self, *, feature_names=None): + """ + Get the output feature names. + + Parameters + ---------- + feature_names: list of strings of length X.shape[1] or None + The names of the input features. If None and X is a dataframe, it defaults to the column names + from the dataframe. + + Returns + ------- + out_feature_names: list of strings or None + The names of the output features on which the policy model is fitted. + """ + return self.drlearner_.cate_feature_names(feature_names=feature_names) + + def policy_treatment_names(self, *, treatment_names=None): + """ + Get the names of the treatments. + + Parameters + ---------- + treatment_names: list of strings of length n_categories + The names of the treatments (including the baseling). If None then values are auto-generated + based on input metadata. + + Returns + ------- + out_treatment_names: list of strings + The names of the treatments including the baseline/control treatment. + """ + if treatment_names is not None: + if len(treatment_names) != len(self.drlearner_.cate_treatment_names()) + 1: + raise ValueError('The variable `treatment_names` should have length equal to ' + 'n_treatments + 1, containing the value of the control/none/baseline treatment as ' + 'the first element and the names of all the treatments as subsequent elements.') + return treatment_names + return ['None'] + self.drlearner_.cate_treatment_names() + + def feature_importances(self, max_depth=4, depth_decay_exponent=2.0): + """ + + Parameters + ---------- + max_depth : int, default=4 + Splits of depth larger than `max_depth` are not used in this calculation + depth_decay_exponent: double, default=2.0 + The contribution of each split to the total score is re-weighted by ``1 / (1 + `depth`)**2.0``. + + Returns + ------- + feature_importances_ : ndarray of shape (n_features,) + Normalized total parameter heterogeneity inducing importance of each feature + """ + return self.policy_model_.feature_importances(max_depth=max_depth, + depth_decay_exponent=depth_decay_exponent) + + @property + def feature_importances_(self): + return self.feature_importances() + + @property + def policy_model_(self): + """ The trained final stage policy model + """ + return self.drlearner_.multitask_model_cate + + +class DRPolicyTree(_BaseDRPolicyLearner): + """ + Policy learner that uses doubly-robust correction techniques to account for + covariate shift (selection bias) between the treatment arms. + + In this estimator, the policy is estimated by first constructing doubly robust estimates of the counterfactual + outcomes + + .. math :: + Y_{i, t}^{DR} = E[Y | X_i, W_i, T_i=t]\ + + \\frac{Y_i - E[Y | X_i, W_i, T_i=t]}{Pr[T_i=t | X_i, W_i]} \\cdot 1\\{T_i=t\\} + + Then optimizing the objective + + .. math :: + V(\\pi) = \\sum_i \\sum_t \\pi_t(X_i) * (Y_{i, t} - Y_{i, 0}) + + with the constraint that only one of :math:`\\pi_t(X_i)` is 1 and the rest are 0, for each :math:`X_i`. + + Thus if we estimate the nuisance functions :math:`h(X, W, T) = E[Y | X, W, T]` and + :math:`p_t(X, W)=Pr[T=t | X, W]` in the first stage, we can estimate the final stage cate for each + treatment t, by running a constructing a decision tree that maximizes the objective :math:`V(\\pi)` + + The problem of estimating the nuisance function :math:`p` is a simple multi-class classification + problem of predicting the label :math:`T` from :math:`X, W`. The :class:`.DRLearner` + class takes as input the parameter ``model_propensity``, which is an arbitrary scikit-learn + classifier, that is internally used to solve this classification problem. + + The second nuisance function :math:`h` is a simple regression problem and the :class:`.DRLearner` + class takes as input the parameter ``model_regressor``, which is an arbitrary scikit-learn regressor that + is internally used to solve this regression problem. + + Parameters + ---------- + model_propensity : scikit-learn classifier or 'auto', optional (default='auto') + Estimator for Pr[T=t | X, W]. Trained by regressing treatments on (features, controls) concatenated. + Must implement `fit` and `predict_proba` methods. The `fit` method must be able to accept X and T, + where T is a shape (n, ) array. + If 'auto', :class:`~sklearn.linear_model.LogisticRegressionCV` will be chosen. + + model_regression : scikit-learn regressor or 'auto', optional (default='auto') + Estimator for E[Y | X, W, T]. Trained by regressing Y on (features, controls, one-hot-encoded treatments) + concatenated. The one-hot-encoding excludes the baseline treatment. Must implement `fit` and + `predict` methods. If different models per treatment arm are desired, see the + :class:`.MultiModelWrapper` helper class. + If 'auto' :class:`.WeightedLassoCV`/:class:`.WeightedMultiTaskLassoCV` will be chosen. + + featurizer : :term:`transformer`, optional, default None + Must support fit_transform and transform. Used to create composite features in the final CATE regression. + It is ignored if X is None. The final CATE will be trained on the outcome of featurizer.fit_transform(X). + If featurizer=None, then CATE is trained on X. + + min_propensity : float, optional, default ``1e-6`` + The minimum propensity at which to clip propensity estimates to avoid dividing by zero. + + categories: 'auto' or list, default 'auto' + The categories to use when encoding discrete treatments (or 'auto' to use the unique sorted values). + The first category will be treated as the control treatment. + + cv: int, cross-validation generator or an iterable, optional (default is 2) + Determines the cross-validation splitting strategy. + Possible inputs for cv are: + + - None, to use the default 3-fold cross-validation, + - integer, to specify the number of folds. + - :term:`CV splitter` + - An iterable yielding (train, test) splits as arrays of indices. + + For integer/None inputs, if the treatment is discrete + :class:`~sklearn.model_selection.StratifiedKFold` is used, else, + :class:`~sklearn.model_selection.KFold` is used + (with a random shuffle in either case). + + Unless an iterable is used, we call `split(concat[W, X], T)` to generate the splits. If all + W, X are None, then we call `split(ones((T.shape[0], 1)), T)`. + + mc_iters: int, optional (default=None) + The number of times to rerun the first stage models to reduce the variance of the nuisances. + + mc_agg: {'mean', 'median'}, optional (default='mean') + How to aggregate the nuisance value for each sample across the `mc_iters` monte carlo iterations of + cross-fitting. + + max_depth : integer or None, optional (default=None) + The maximum depth of the tree. If None, then nodes are expanded until + all leaves are pure or until all leaves contain less than + min_samples_split samples. + + min_samples_split : int, float, optional (default=10) + The minimum number of splitting samples required to split an internal node. + + - If int, then consider `min_samples_split` as the minimum number. + - If float, then `min_samples_split` is a fraction and + `ceil(min_samples_split * n_samples)` are the minimum + number of samples for each split. + + min_samples_leaf : int, float, optional (default=5) + The minimum number of samples required to be at a leaf node. + A split point at any depth will only be considered if it leaves at + least ``min_samples_leaf`` splitting samples in each of the left and + right branches. This may have the effect of smoothing the model, + especially in regression. After construction the tree is also pruned + so that there are at least min_samples_leaf estimation samples on + each leaf. + + - If int, then consider `min_samples_leaf` as the minimum number. + - If float, then `min_samples_leaf` is a fraction and + `ceil(min_samples_leaf * n_samples)` are the minimum + number of samples for each node. + + min_weight_fraction_leaf : float, optional (default=0.) + The minimum weighted fraction of the sum total of weights (of all + splitting samples) required to be at a leaf node. Samples have + equal weight when sample_weight is not provided. After construction + the tree is pruned so that the fraction of the sum total weight + of the estimation samples contained in each leaf node is at + least min_weight_fraction_leaf + + max_features : int, float, string or None, optional (default="auto") + The number of features to consider when looking for the best split: + + - If int, then consider `max_features` features at each split. + - If float, then `max_features` is a fraction and + `int(max_features * n_features)` features are considered at each + split. + - If "auto", then `max_features=n_features`. + - If "sqrt", then `max_features=sqrt(n_features)`. + - If "log2", then `max_features=log2(n_features)`. + - If None, then `max_features=n_features`. + + Note: the search for a split does not stop until at least one + valid partition of the node samples is found, even if it requires to + effectively inspect more than ``max_features`` features. + + min_impurity_decrease : float, optional (default=0.) + A node will be split if this split induces a decrease of the impurity + greater than or equal to this value. + + The weighted impurity decrease equation is the following:: + + N_t / N * (impurity - N_t_R / N_t * right_impurity + - N_t_L / N_t * left_impurity) + + where ``N`` is the total number of split samples, ``N_t`` is the number of + split samples at the current node, ``N_t_L`` is the number of split samples in the + left child, and ``N_t_R`` is the number of split samples in the right child. + + ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, + if ``sample_weight`` is passed. + + min_balancedness_tol: float in [0, .5], default=.45 + How imbalanced a split we can tolerate. This enforces that each split leaves at least + (.5 - min_balancedness_tol) fraction of samples on each side of the split; or fraction + of the total weight of samples, when sample_weight is not None. Default value, ensures + that at least 5% of the parent node weight falls in each side of the split. Set it to 0.0 for no + balancedness and to .5 for perfectly balanced splits. For the formal inference theory + to be valid, this has to be any positive constant bounded away from zero. + + honest : boolean, optional (default=True) + Whether to use honest trees, i.e. half of the samples are used for + creating the tree structure and the other half for the estimation at + the leafs. If False, then all samples are used for both parts. + + random_state: int, :class:`~numpy.random.mtrand.RandomState` instance or None, optional (default=None) + If int, random_state is the seed used by the random number generator; + If :class:`~numpy.random.mtrand.RandomState` instance, random_state is the random number generator; + If None, the random number generator is the :class:`~numpy.random.mtrand.RandomState` instance used + by :mod:`np.random`. + """ + + def __init__(self, *, + model_regression="auto", + model_propensity="auto", + featurizer=None, + min_propensity=1e-6, + categories='auto', + cv=2, + mc_iters=None, + mc_agg='mean', + max_depth=None, + min_samples_split=10, + min_samples_leaf=5, + min_weight_fraction_leaf=0., + max_features="auto", + min_impurity_decrease=0., + min_balancedness_tol=.45, + honest=True, + random_state=None): + self.model_regression = clone(model_regression, safe=False) + self.model_propensity = clone(model_propensity, safe=False) + self.featurizer = clone(featurizer, safe=False) + self.min_propensity = min_propensity + self.categories = categories + self.cv = cv + self.mc_iters = mc_iters + self.mc_agg = mc_agg + self.max_depth = max_depth + self.min_samples_split = min_samples_split + self.min_samples_leaf = min_samples_leaf + self.min_weight_fraction_leaf = min_weight_fraction_leaf + self.max_features = max_features + self.min_impurity_decrease = min_impurity_decrease + self.min_balancedness_tol = min_balancedness_tol + self.honest = honest + self.random_state = random_state + + def _gen_drpolicy_learner(self): + return _DRLearnerWrapper(model_regression=self.model_regression, + model_propensity=self.model_propensity, + featurizer=self.featurizer, + min_propensity=self.min_propensity, + categories=self.categories, + cv=self.cv, + mc_iters=self.mc_iters, + mc_agg=self.mc_agg, + model_final=PolicyTree(max_depth=self.max_depth, + min_samples_split=self.min_samples_split, + min_samples_leaf=self.min_samples_leaf, + min_weight_fraction_leaf=self.min_weight_fraction_leaf, + max_features=self.max_features, + min_impurity_decrease=self.min_impurity_decrease, + min_balancedness_tol=self.min_balancedness_tol, + honest=self.honest, + random_state=self.random_state), + multitask_model_final=True, + random_state=self.random_state) + + def plot(self, *, feature_names=None, treatment_names=None, ax=None, title=None, + max_depth=None, filled=True, rounded=True, precision=3, fontsize=None): + """ + Exports policy trees to matplotlib + + Parameters + ---------- + ax : :class:`matplotlib.axes.Axes`, optional, default None + The axes on which to plot + + title : string, optional, default None + A title for the final figure to be printed at the top of the page. + + feature_names : list of strings, optional, default None + Names of each of the features. + + treatment_names : list of strings, optional, default None + Names of each of the treatments including the baseline/control + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool, optional, default False + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + rounded : bool, optional, default True + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + precision : int, optional, default 3 + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + + fontsize : int, optional, default None + Font size for text + """ + return self.policy_model_.plot(feature_names=self.policy_feature_names(feature_names=feature_names), + treatment_names=self.policy_treatment_names(treatment_names=treatment_names), + ax=ax, + title=title, + max_depth=max_depth, + filled=filled, + rounded=rounded, + precision=precision, + fontsize=fontsize) + + def export_graphviz(self, *, out_file=None, + feature_names=None, treatment_names=None, + max_depth=None, filled=True, leaves_parallel=True, + rotate=False, rounded=True, special_characters=False, precision=3): + """ + Export a graphviz dot file representing the learned tree model + + Parameters + ---------- + out_file : file object or string, optional, default None + Handle or name of the output file. If ``None``, the result is + returned as a string. + + feature_names : list of strings, optional, default None + Names of each of the features. + + treatment_names : list of strings, optional, default None + Names of each of the treatments, including the baseline treatment + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool, optional, default False + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + leaves_parallel : bool, optional, default True + When set to ``True``, draw all leaf nodes at the bottom of the tree. + + rotate : bool, optional, default False + When set to ``True``, orient tree left to right rather than top-down. + + rounded : bool, optional, default True + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + special_characters : bool, optional, default False + When set to ``False``, ignore special characters for PostScript + compatibility. + + precision : int, optional, default 3 + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + """ + return self.policy_model_.export_graphviz(out_file=out_file, + feature_names=self.policy_feature_names(feature_names=feature_names), + treatment_names=self.policy_treatment_names( + treatment_names=treatment_names), + max_depth=max_depth, + filled=filled, + leaves_parallel=leaves_parallel, + rotate=rotate, + rounded=rounded, + special_characters=special_characters, + precision=precision) + + def render(self, out_file, *, format='pdf', view=True, feature_names=None, + treatment_names=None, max_depth=None, + filled=True, leaves_parallel=True, rotate=False, rounded=True, + special_characters=False, precision=3): + """ + Render the tree to a flie + + Parameters + ---------- + out_file : file name to save to + + format : string, optional, default 'pdf' + The file format to render to; must be supported by graphviz + + view : bool, optional, default True + Whether to open the rendered result with the default application. + + feature_names : list of strings, optional, default None + Names of each of the features. + + treatment_names : list of strings, optional, default None + Names of each of the treatments, including the baseline/control + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool, optional, default False + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + leaves_parallel : bool, optional, default True + When set to ``True``, draw all leaf nodes at the bottom of the tree. + + rotate : bool, optional, default False + When set to ``True``, orient tree left to right rather than top-down. + + rounded : bool, optional, default True + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + special_characters : bool, optional, default False + When set to ``False``, ignore special characters for PostScript + compatibility. + + precision : int, optional, default 3 + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + """ + return self.policy_model_.render(out_file, + format=format, + view=view, + feature_names=self.policy_feature_names(feature_names=feature_names), + treatment_names=self.policy_treatment_names(treatment_names=treatment_names), + max_depth=max_depth, + filled=filled, + leaves_parallel=leaves_parallel, + rotate=rotate, + rounded=rounded, + special_characters=special_characters, + precision=precision) + + +class DRPolicyForest(_BaseDRPolicyLearner): + """ + Policy learner that uses doubly-robust correction techniques to account for + covariate shift (selection bias) between the treatment arms. + + In this estimator, the policy is estimated by first constructing doubly robust estimates of the counterfactual + outcomes + + .. math :: + Y_{i, t}^{DR} = E[Y | X_i, W_i, T_i=t]\ + + \\frac{Y_i - E[Y | X_i, W_i, T_i=t]}{Pr[T_i=t | X_i, W_i]} \\cdot 1\\{T_i=t\\} + + Then optimizing the objective + + .. math :: + V(\\pi) = \\sum_i \\sum_t \\pi_t(X_i) * (Y_{i, t} - Y_{i, 0}) + + with the constraint that only one of :math:`\\pi_t(X_i)` is 1 and the rest are 0, for each :math:`X_i`. + + Thus if we estimate the nuisance functions :math:`h(X, W, T) = E[Y | X, W, T]` and + :math:`p_t(X, W)=Pr[T=t | X, W]` in the first stage, we can estimate the final stage cate for each + treatment t, by running a constructing a decision tree that maximizes the objective :math:`V(\\pi)` + + The problem of estimating the nuisance function :math:`p` is a simple multi-class classification + problem of predicting the label :math:`T` from :math:`X, W`. The :class:`.DRLearner` + class takes as input the parameter ``model_propensity``, which is an arbitrary scikit-learn + classifier, that is internally used to solve this classification problem. + + The second nuisance function :math:`h` is a simple regression problem and the :class:`.DRLearner` + class takes as input the parameter ``model_regressor``, which is an arbitrary scikit-learn regressor that + is internally used to solve this regression problem. + + Parameters + ---------- + model_propensity : scikit-learn classifier or 'auto', optional (default='auto') + Estimator for Pr[T=t | X, W]. Trained by regressing treatments on (features, controls) concatenated. + Must implement `fit` and `predict_proba` methods. The `fit` method must be able to accept X and T, + where T is a shape (n, ) array. + If 'auto', :class:`~sklearn.linear_model.LogisticRegressionCV` will be chosen. + + model_regression : scikit-learn regressor or 'auto', optional (default='auto') + Estimator for E[Y | X, W, T]. Trained by regressing Y on (features, controls, one-hot-encoded treatments) + concatenated. The one-hot-encoding excludes the baseline treatment. Must implement `fit` and + `predict` methods. If different models per treatment arm are desired, see the + :class:`.MultiModelWrapper` helper class. + If 'auto' :class:`.WeightedLassoCV`/:class:`.WeightedMultiTaskLassoCV` will be chosen. + + featurizer : :term:`transformer`, optional, default None + Must support fit_transform and transform. Used to create composite features in the final CATE regression. + It is ignored if X is None. The final CATE will be trained on the outcome of featurizer.fit_transform(X). + If featurizer=None, then CATE is trained on X. + + min_propensity : float, optional, default ``1e-6`` + The minimum propensity at which to clip propensity estimates to avoid dividing by zero. + + categories: 'auto' or list, default 'auto' + The categories to use when encoding discrete treatments (or 'auto' to use the unique sorted values). + The first category will be treated as the control treatment. + + cv: int, cross-validation generator or an iterable, optional (default is 2) + Determines the cross-validation splitting strategy. + Possible inputs for cv are: + + - None, to use the default 3-fold cross-validation, + - integer, to specify the number of folds. + - :term:`CV splitter` + - An iterable yielding (train, test) splits as arrays of indices. + + For integer/None inputs, if the treatment is discrete + :class:`~sklearn.model_selection.StratifiedKFold` is used, else, + :class:`~sklearn.model_selection.KFold` is used + (with a random shuffle in either case). + + Unless an iterable is used, we call `split(concat[W, X], T)` to generate the splits. If all + W, X are None, then we call `split(ones((T.shape[0], 1)), T)`. + + mc_iters: int, optional (default=None) + The number of times to rerun the first stage models to reduce the variance of the nuisances. + + mc_agg: {'mean', 'median'}, optional (default='mean') + How to aggregate the nuisance value for each sample across the `mc_iters` monte carlo iterations of + cross-fitting. + + n_estimators : integer, optional (default=100) + The total number of trees in the forest. The forest consists of a + forest of sqrt(n_estimators) sub-forests, where each sub-forest + contains sqrt(n_estimators) trees. + + max_depth : integer or None, optional (default=None) + The maximum depth of the tree. If None, then nodes are expanded until + all leaves are pure or until all leaves contain less than + min_samples_split samples. + + min_samples_split : int, float, optional (default=10) + The minimum number of splitting samples required to split an internal node. + + - If int, then consider `min_samples_split` as the minimum number. + - If float, then `min_samples_split` is a fraction and + `ceil(min_samples_split * n_samples)` are the minimum + number of samples for each split. + + min_samples_leaf : int, float, optional (default=5) + The minimum number of samples required to be at a leaf node. + A split point at any depth will only be considered if it leaves at + least ``min_samples_leaf`` splitting samples in each of the left and + right branches. This may have the effect of smoothing the model, + especially in regression. After construction the tree is also pruned + so that there are at least min_samples_leaf estimation samples on + each leaf. + + - If int, then consider `min_samples_leaf` as the minimum number. + - If float, then `min_samples_leaf` is a fraction and + `ceil(min_samples_leaf * n_samples)` are the minimum + number of samples for each node. + + min_weight_fraction_leaf : float, optional (default=0.) + The minimum weighted fraction of the sum total of weights (of all + splitting samples) required to be at a leaf node. Samples have + equal weight when sample_weight is not provided. After construction + the tree is pruned so that the fraction of the sum total weight + of the estimation samples contained in each leaf node is at + least min_weight_fraction_leaf + + max_features : int, float, string or None, optional (default="auto") + The number of features to consider when looking for the best split: + + - If int, then consider `max_features` features at each split. + - If float, then `max_features` is a fraction and + `int(max_features * n_features)` features are considered at each + split. + - If "auto", then `max_features=n_features`. + - If "sqrt", then `max_features=sqrt(n_features)`. + - If "log2", then `max_features=log2(n_features)`. + - If None, then `max_features=n_features`. + + Note: the search for a split does not stop until at least one + valid partition of the node samples is found, even if it requires to + effectively inspect more than ``max_features`` features. + + min_impurity_decrease : float, optional (default=0.) + A node will be split if this split induces a decrease of the impurity + greater than or equal to this value. + + The weighted impurity decrease equation is the following:: + + N_t / N * (impurity - N_t_R / N_t * right_impurity + - N_t_L / N_t * left_impurity) + + where ``N`` is the total number of split samples, ``N_t`` is the number of + split samples at the current node, ``N_t_L`` is the number of split samples in the + left child, and ``N_t_R`` is the number of split samples in the right child. + + ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, + if ``sample_weight`` is passed. + + max_samples : int or float in (0, 1], default=.5, + The number of samples to use for each subsample that is used to train each tree: + + - If int, then train each tree on `max_samples` samples, sampled without replacement from all the samples + - If float, then train each tree on ceil(`max_samples` * `n_samples`), sampled without replacement + from all the samples. + + min_balancedness_tol: float in [0, .5], default=.45 + How imbalanced a split we can tolerate. This enforces that each split leaves at least + (.5 - min_balancedness_tol) fraction of samples on each side of the split; or fraction + of the total weight of samples, when sample_weight is not None. Default value, ensures + that at least 5% of the parent node weight falls in each side of the split. Set it to 0.0 for no + balancedness and to .5 for perfectly balanced splits. For the formal inference theory + to be valid, this has to be any positive constant bounded away from zero. + + honest : boolean, optional (default=True) + Whether to use honest trees, i.e. half of the samples are used for + creating the tree structure and the other half for the estimation at + the leafs. If False, then all samples are used for both parts. + + n_jobs : int or None, optional (default=-1) + The number of jobs to run in parallel for both `fit` and `predict`. + ``None`` means 1 unless in a :func:`joblib.parallel_backend` context. + ``-1`` means using all processors. See :term:`Glossary ` + for more details. + + verbose : int, optional (default=0) + Controls the verbosity when fitting and predicting. + + random_state: int, :class:`~numpy.random.mtrand.RandomState` instance or None, optional (default=None) + If int, random_state is the seed used by the random number generator; + If :class:`~numpy.random.mtrand.RandomState` instance, random_state is the random number generator; + If None, the random number generator is the :class:`~numpy.random.mtrand.RandomState` instance used + by :mod:`np.random`. + """ + + def __init__(self, *, + model_regression="auto", + model_propensity="auto", + featurizer=None, + min_propensity=1e-6, + categories='auto', + cv=2, + mc_iters=None, + mc_agg='mean', + n_estimators=100, + max_depth=None, + min_samples_split=10, + min_samples_leaf=5, + min_weight_fraction_leaf=0., + max_features="auto", + min_impurity_decrease=0., + max_samples=.5, + min_balancedness_tol=.45, + honest=True, + n_jobs=-1, + verbose=0, + random_state=None): + self.model_regression = clone(model_regression, safe=False) + self.model_propensity = clone(model_propensity, safe=False) + self.featurizer = clone(featurizer, safe=False) + self.min_propensity = min_propensity + self.categories = categories + self.cv = cv + self.mc_iters = mc_iters + self.mc_agg = mc_agg + self.n_estimators = n_estimators + self.max_depth = max_depth + self.min_samples_split = min_samples_split + self.min_samples_leaf = min_samples_leaf + self.min_weight_fraction_leaf = min_weight_fraction_leaf + self.max_features = max_features + self.min_impurity_decrease = min_impurity_decrease + self.max_samples = max_samples + self.min_balancedness_tol = min_balancedness_tol + self.honest = honest + self.n_jobs = n_jobs + self.verbose = verbose + self.random_state = random_state + + def _gen_drpolicy_learner(self): + return _DRLearnerWrapper(model_regression=self.model_regression, + model_propensity=self.model_propensity, + featurizer=self.featurizer, + min_propensity=self.min_propensity, + categories=self.categories, + cv=self.cv, + mc_iters=self.mc_iters, + mc_agg=self.mc_agg, + model_final=PolicyForest(max_depth=self.max_depth, + min_samples_split=self.min_samples_split, + min_samples_leaf=self.min_samples_leaf, + min_weight_fraction_leaf=self.min_weight_fraction_leaf, + max_features=self.max_features, + min_impurity_decrease=self.min_impurity_decrease, + max_samples=self.max_samples, + min_balancedness_tol=self.min_balancedness_tol, + honest=self.honest, + n_jobs=self.n_jobs, + verbose=self.verbose, + random_state=self.random_state), + multitask_model_final=True, + random_state=self.random_state) + + def plot(self, tree_id, *, feature_names=None, treatment_names=None, + ax=None, title=None, + max_depth=None, filled=True, rounded=True, precision=3, fontsize=None): + """ + Exports policy trees to matplotlib + + Parameters + ---------- + tree_id : int + The id of the tree of the forest to plot + + ax : :class:`matplotlib.axes.Axes`, optional, default None + The axes on which to plot + + title : string, optional, default None + A title for the final figure to be printed at the top of the page. + + feature_names : list of strings, optional, default None + Names of each of the features. + + treatment_names : list of strings, optional, default None + Names of each of the treatments, starting with a name for the baseline/control treatment + (alphanumerically smallest) + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool, optional, default False + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + rounded : bool, optional, default True + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + precision : int, optional, default 3 + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + + fontsize : int, optional, default None + Font size for text + """ + return self.policy_model_[tree_id].plot(feature_names=self.policy_feature_names(feature_names=feature_names), + treatment_names=self.policy_treatment_names( + treatment_names=treatment_names), + ax=ax, + title=title, + max_depth=max_depth, + filled=filled, + rounded=rounded, + precision=precision, + fontsize=fontsize) + + def export_graphviz(self, tree_id, *, out_file=None, feature_names=None, treatment_names=None, + max_depth=None, + filled=True, leaves_parallel=True, + rotate=False, rounded=True, special_characters=False, precision=3): + """ + Export a graphviz dot file representing the learned tree model + + Parameters + ---------- + tree_id : int + The id of the tree of the forest to plot + + out_file : file object or string, optional, default None + Handle or name of the output file. If ``None``, the result is + returned as a string. + + feature_names : list of strings, optional, default None + Names of each of the features. + + treatment_names : list of strings, optional, default None + Names of each of the treatments, starting with a name for the baseline/control/None treatment + (alphanumerically smallest in case of discrete treatment) + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool, optional, default False + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + leaves_parallel : bool, optional, default True + When set to ``True``, draw all leaf nodes at the bottom of the tree. + + rotate : bool, optional, default False + When set to ``True``, orient tree left to right rather than top-down. + + rounded : bool, optional, default True + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + special_characters : bool, optional, default False + When set to ``False``, ignore special characters for PostScript + compatibility. + + precision : int, optional, default 3 + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + """ + feature_names = self.policy_feature_names(feature_names=feature_names) + return self.policy_model_[tree_id].export_graphviz(out_file=out_file, + feature_names=feature_names, + treatment_names=self.policy_treatment_names( + treatment_names=treatment_names), + max_depth=max_depth, + filled=filled, + leaves_parallel=leaves_parallel, + rotate=rotate, + rounded=rounded, + special_characters=special_characters, + precision=precision) + + def render(self, tree_id, out_file, *, format='pdf', view=True, + feature_names=None, + treatment_names=None, + max_depth=None, + filled=True, leaves_parallel=True, rotate=False, rounded=True, + special_characters=False, precision=3): + """ + Render the tree to a flie + + Parameters + ---------- + tree_id : int + The id of the tree of the forest to plot + + out_file : file name to save to + + format : string, optional, default 'pdf' + The file format to render to; must be supported by graphviz + + view : bool, optional, default True + Whether to open the rendered result with the default application. + + feature_names : list of strings, optional, default None + Names of each of the features. + + treatment_names : list of strings, optional, default None + Names of each of the treatments, starting with a name for the baseline/control treatment + (alphanumerically smallest in case of discrete treatment) + + max_depth: int or None, optional, default None + The maximum tree depth to plot + + filled : bool, optional, default False + When set to ``True``, paint nodes to indicate majority class for + classification, extremity of values for regression, or purity of node + for multi-output. + + leaves_parallel : bool, optional, default True + When set to ``True``, draw all leaf nodes at the bottom of the tree. + + rotate : bool, optional, default False + When set to ``True``, orient tree left to right rather than top-down. + + rounded : bool, optional, default True + When set to ``True``, draw node boxes with rounded corners and use + Helvetica fonts instead of Times-Roman. + + special_characters : bool, optional, default False + When set to ``False``, ignore special characters for PostScript + compatibility. + + precision : int, optional, default 3 + Number of digits of precision for floating point in the values of + impurity, threshold and value attributes of each node. + """ + feature_names = self.policy_feature_names(feature_names=feature_names) + return self.policy_model_[tree_id].render(out_file, + feature_names=feature_names, + treatment_names=self.policy_treatment_names( + treatment_names=treatment_names), + format=format, + view=view, + max_depth=max_depth, + filled=filled, + leaves_parallel=leaves_parallel, + rotate=rotate, + rounded=rounded, + special_characters=special_characters, + precision=precision) diff --git a/econml/policy/_forest/__init__.py b/econml/policy/_forest/__init__.py new file mode 100644 index 000000000..39bd122f1 --- /dev/null +++ b/econml/policy/_forest/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from ._tree import PolicyTree +from ._forest import PolicyForest + +__all__ = ["PolicyTree", + "PolicyForest"] diff --git a/econml/policy/_forest/_criterion.pxd b/econml/policy/_forest/_criterion.pxd new file mode 100644 index 000000000..15f732ed5 --- /dev/null +++ b/econml/policy/_forest/_criterion.pxd @@ -0,0 +1,22 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +# published under the following license and copyright: +# BSD 3-Clause License +# +# Copyright (c) 2007-2020 The scikit-learn developers. +# All rights reserved. + +# See _criterion.pyx for implementation details. + +from ...tree._tree cimport DTYPE_t # Type of X +from ...tree._tree cimport DOUBLE_t # Type of y, sample_weight +from ...tree._tree cimport SIZE_t # Type for indices and counters +from ...tree._tree cimport INT32_t # Signed 32 bit integer +from ...tree._tree cimport UINT32_t # Unsigned 32 bit integer + +from ...tree._criterion cimport RegressionCriterion + +cdef class LinearPolicyCriterion(RegressionCriterion): + """ + """ + pass diff --git a/econml/policy/_forest/_criterion.pyx b/econml/policy/_forest/_criterion.pyx new file mode 100644 index 000000000..82a3017f7 --- /dev/null +++ b/econml/policy/_forest/_criterion.pyx @@ -0,0 +1,48 @@ +# cython: cdivision=True +# cython: boundscheck=False +# cython: wraparound=False + +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import numpy as np + +cdef double INFINITY = np.inf + +################################################################################### +# Policy Criteria +################################################################################### + +cdef class LinearPolicyCriterion(RegressionCriterion): + r""" + """ + + cdef double node_impurity(self) nogil: + """Evaluate the impurity of the current node, i.e. the impurity of + samples[start:end]. + """ + return - _max(self.sum_total, self.n_outputs) / self.weighted_n_node_samples + + cdef double proxy_impurity_improvement(self) nogil: + """Compute a proxy of the impurity reduction. + """ + return (_max(self.sum_left, self.n_outputs) + _max(self.sum_right, self.n_outputs)) + + cdef void children_impurity(self, double* impurity_left, + double* impurity_right) nogil: + """Evaluate the impurity in children nodes, i.e. the impurity of the + left child (samples[start:pos]) and the impurity the right child + (samples[pos:end]). + """ + impurity_left[0] = - _max(self.sum_left, self.n_outputs) / self.weighted_n_left + impurity_right[0] = - _max(self.sum_right, self.n_outputs) / self.weighted_n_right + + +cdef inline double _max(double* array, SIZE_t n) nogil: + cdef SIZE_t k + cdef double max_val + max_val = - INFINITY + for k in range(n): + if array[k] > max_val: + max_val = array[k] + return max_val diff --git a/econml/policy/_forest/_forest.py b/econml/policy/_forest/_forest.py new file mode 100644 index 000000000..d3d2b6bd3 --- /dev/null +++ b/econml/policy/_forest/_forest.py @@ -0,0 +1,472 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +# +# This code contains snippets of code from +# https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/ensemble/_forest.py +# published under the following license and copyright: +# BSD 3-Clause License +# +# Copyright (c) 2007-2020 The scikit-learn developers. +# All rights reserved. + +import numbers +from warnings import catch_warnings, simplefilter, warn +from abc import ABCMeta, abstractmethod +import numpy as np +import threading +from ..._ensemble import (BaseEnsemble, _partition_estimators, _get_n_samples_subsample, _accumulate_prediction) +from ...utilities import check_inputs, cross_product +from ...tree._tree import DTYPE, DOUBLE +from ._tree import PolicyTree +from joblib import Parallel, delayed +from scipy.sparse import hstack as sparse_hstack +from sklearn.utils import check_random_state, compute_sample_weight +from sklearn.utils.validation import _check_sample_weight, check_is_fitted +from sklearn.utils import check_X_y + +__all__ = ["PolicyForest"] + +MAX_INT = np.iinfo(np.int32).max + +# ============================================================================= +# Policy Forest +# ============================================================================= + + +class PolicyForest(BaseEnsemble, metaclass=ABCMeta): + """ Welfare maximization policy forest. Trains a forest to maximize the objective: + :math:`1/n \\sum_i \\sum_j a_j(X_i) * y_{ij}`, where, where :math:`a(X)` is constrained + to take value of 1 only on one coordinate and zero otherwise. This corresponds to a policy + optimization problem. + + Parameters + ---------- + n_estimators : integer, optional (default=100) + The total number of trees in the forest. The forest consists of a + forest of sqrt(n_estimators) sub-forests, where each sub-forest + contains sqrt(n_estimators) trees. + + criterion : {``'neg_welfare'``}, default='neg_welfare' + The criterion type + + max_depth : int, default=None + The maximum depth of the tree. If None, then nodes are expanded until + all leaves are pure or until all leaves contain less than + min_samples_split samples. + + min_samples_split : int or float, default=10 + The minimum number of samples required to split an internal node: + + - If int, then consider `min_samples_split` as the minimum number. + - If float, then `min_samples_split` is a fraction and + `ceil(min_samples_split * n_samples)` are the minimum + number of samples for each split. + + min_samples_leaf : int or float, default=5 + The minimum number of samples required to be at a leaf node. + A split point at any depth will only be considered if it leaves at + least ``min_samples_leaf`` training samples in each of the left and + right branches. This may have the effect of smoothing the model, + especially in regression. + + - If int, then consider `min_samples_leaf` as the minimum number. + - If float, then `min_samples_leaf` is a fraction and + `ceil(min_samples_leaf * n_samples)` are the minimum + number of samples for each node. + + min_weight_fraction_leaf : float, default=0.0 + The minimum weighted fraction of the sum total of weights (of all + the input samples) required to be at a leaf node. Samples have + equal weight when sample_weight is not provided. + + max_features : int, float or {"auto", "sqrt", "log2"}, default=None + The number of features to consider when looking for the best split: + + - If int, then consider `max_features` features at each split. + - If float, then `max_features` is a fraction and + `int(max_features * n_features)` features are considered at each + split. + - If "auto", then `max_features=n_features`. + - If "sqrt", then `max_features=sqrt(n_features)`. + - If "log2", then `max_features=log2(n_features)`. + - If None, then `max_features=n_features`. + + Note: the search for a split does not stop until at least one + valid partition of the node samples is found, even if it requires to + effectively inspect more than ``max_features`` features. + + min_impurity_decrease : float, default=0.0 + A node will be split if this split induces a decrease of the impurity + greater than or equal to this value. + The weighted impurity decrease equation is the following:: + + N_t / N * (impurity - N_t_R / N_t * right_impurity + - N_t_L / N_t * left_impurity) + + where ``N`` is the total number of samples, ``N_t`` is the number of + samples at the current node, ``N_t_L`` is the number of samples in the + left child, and ``N_t_R`` is the number of samples in the right child. + ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, + if ``sample_weight`` is passed. + + max_samples : int or float in (0, 1], default=.5, + The number of samples to use for each subsample that is used to train each tree: + + - If int, then train each tree on `max_samples` samples, sampled without replacement from all the samples + - If float, then train each tree on ceil(`max_samples` * `n_samples`), sampled without replacement + from all the samples. + + min_balancedness_tol: float in [0, .5], default=.45 + How imbalanced a split we can tolerate. This enforces that each split leaves at least + (.5 - min_balancedness_tol) fraction of samples on each side of the split; or fraction + of the total weight of samples, when sample_weight is not None. Default value, ensures + that at least 5% of the parent node weight falls in each side of the split. Set it to 0.0 for no + balancedness and to .5 for perfectly balanced splits. For the formal inference theory + to be valid, this has to be any positive constant bounded away from zero. + + honest: bool, default=True + Whether the data should be split in two equally sized samples, such that the one half-sample + is used to determine the optimal split at each node and the other sample is used to determine + the value of every node. + + n_jobs : int or None, optional (default=-1) + The number of jobs to run in parallel for both `fit` and `predict`. + ``None`` means 1 unless in a :func:`joblib.parallel_backend` context. + ``-1`` means using all processors. See :term:`Glossary ` + for more details. + + verbose : int, optional (default=0) + Controls the verbosity when fitting and predicting. + + random_state: int, :class:`~numpy.random.mtrand.RandomState` instance or None, optional (default=None) + If int, random_state is the seed used by the random number generator; + If :class:`~numpy.random.mtrand.RandomState` instance, random_state is the random number generator; + If None, the random number generator is the :class:`~numpy.random.mtrand.RandomState` instance used + by :mod:`np.random`. + + warm_start : bool, default=False + When set to ``True``, reuse the solution of the previous call to fit + and add more estimators to the ensemble, otherwise, just fit a whole + new forest. + + Attributes + ---------- + feature_importances_ : ndarray of shape (n_features,) + The feature importances based on the amount of parameter heterogeneity they create. + The higher, the more important the feature. + """ + + def __init__(self, + n_estimators=100, *, + criterion='neg_welfare', + max_depth=None, + min_samples_split=10, + min_samples_leaf=5, + min_weight_fraction_leaf=0., + max_features="auto", + min_impurity_decrease=0., + max_samples=.5, + min_balancedness_tol=.45, + honest=True, + n_jobs=-1, + random_state=None, + verbose=0, + warm_start=False): + super().__init__( + base_estimator=PolicyTree(), + n_estimators=n_estimators, + estimator_params=("criterion", "max_depth", "min_samples_split", + "min_samples_leaf", "min_weight_fraction_leaf", + "max_features", "min_impurity_decrease", "honest", + "min_balancedness_tol", + "random_state")) + + self.criterion = criterion + self.max_depth = max_depth + self.min_samples_split = min_samples_split + self.min_samples_leaf = min_samples_leaf + self.min_weight_fraction_leaf = min_weight_fraction_leaf + self.max_features = max_features + self.min_impurity_decrease = min_impurity_decrease + self.min_balancedness_tol = min_balancedness_tol + self.honest = honest + self.n_jobs = n_jobs + self.random_state = random_state + self.verbose = verbose + self.warm_start = warm_start + self.max_samples = max_samples + + def apply(self, X): + """ + Apply trees in the forest to X, return leaf indices. + + Parameters + ---------- + X : array-like of shape (n_samples, n_features) + The input samples. Internally, it will be converted to + ``dtype=np.float64``. + + Returns + ------- + X_leaves : ndarray of shape (n_samples, n_estimators) + For each datapoint x in X and for each tree in the forest, + return the index of the leaf x ends up in. + """ + X = self._validate_X_predict(X) + results = Parallel(n_jobs=self.n_jobs, verbose=self.verbose, backend="threading")( + delayed(tree.apply)(X, check_input=False) + for tree in self.estimators_) + + return np.array(results).T + + def decision_path(self, X): + """ + Return the decision path in the forest. + + Parameters + ---------- + X : array-like of shape (n_samples, n_features) + The input samples. Internally, it will be converted to + ``dtype=np.float64``. + + Returns + ------- + indicator : sparse matrix of shape (n_samples, n_nodes) + Return a node indicator matrix where non zero elements indicates + that the samples goes through the nodes. The matrix is of CSR + format. + n_nodes_ptr : ndarray of shape (n_estimators + 1,) + The columns from indicator[n_nodes_ptr[i]:n_nodes_ptr[i+1]] + gives the indicator value for the i-th estimator. + """ + X = self._validate_X_predict(X) + indicators = Parallel(n_jobs=self.n_jobs, verbose=self.verbose, backend='threading')( + delayed(tree.decision_path)(X, check_input=False) + for tree in self.estimators_) + + n_nodes = [0] + n_nodes.extend([i.shape[1] for i in indicators]) + n_nodes_ptr = np.array(n_nodes).cumsum() + + return sparse_hstack(indicators).tocsr(), n_nodes_ptr + + def fit(self, X, y, *, sample_weight=None, **kwargs): + """ + Build a forest of trees from the training set (X, y) and any other auxiliary variables. + + Parameters + ---------- + X : array-like of shape (n_samples, n_features) + The training input samples. Internally, its dtype will be converted + to ``dtype=np.float64``. + y : array-like of shape (n_samples,) or (n_samples, n_treatments) + The outcome values for each sample and for each treatment. + sample_weight : array-like of shape (n_samples,), default=None + Sample weights. If None, then samples are equally weighted. Splits + that would create child nodes with net zero or negative weight are + ignored while searching for a split in each node. + **kwargs : dictionary of array-like items of shape (n_samples, d_var) + Auxiliary random variables + + Returns + ------- + self : object + """ + + X, y = check_X_y(X, y, multi_output=True) + + if sample_weight is not None: + sample_weight = _check_sample_weight(sample_weight, X, DOUBLE) + + # Remap output + n_samples, self.n_features_ = X.shape + + y = np.atleast_1d(y) + if y.ndim == 1: + # reshape is necessary to preserve the data contiguity against vs + # [:, np.newaxis] that does not. + y = np.reshape(y, (-1, 1)) + + self.n_outputs_ = y.shape[1] + + if getattr(y, "dtype", None) != DOUBLE or not y.flags.contiguous: + y = np.ascontiguousarray(y, dtype=DOUBLE) + + if getattr(X, "dtype", None) != DTYPE: + X = X.astype(DTYPE) + + # Get subsample sample size + n_samples_subsample = _get_n_samples_subsample( + n_samples=n_samples, + max_samples=self.max_samples + ) + + # Check parameters + self._validate_estimator() + + random_state = check_random_state(self.random_state) + # We re-initialize the subsample_random_seed_ only if we are not in warm_start mode or + # if this is the first `fit` call of the warm start mode. + if (not self.warm_start) or (not hasattr(self, 'subsample_random_seed_')): + self.subsample_random_seed_ = random_state.randint(MAX_INT) + else: + random_state.randint(MAX_INT) # just advance random_state + subsample_random_state = check_random_state(self.subsample_random_seed_) + + if not self.warm_start or not hasattr(self, "estimators_"): + # Free allocated memory, if any + self.estimators_ = [] + self.slices_ = [] + # the below are needed to replicate randomness of subsampling when warm_start=True + self.n_samples_ = [] + self.n_samples_subsample_ = [] + + n_more_estimators = self.n_estimators - len(self.estimators_) + + if n_more_estimators < 0: + raise ValueError('n_estimators=%d must be larger or equal to ' + 'len(estimators_)=%d when warm_start==True' + % (self.n_estimators, len(self.estimators_))) + + elif n_more_estimators == 0: + warn("Warm-start fitting without increasing n_estimators does not " + "fit new trees.", UserWarning) + else: + + if self.warm_start and len(self.estimators_) > 0: + # We draw from the random state to get the random state we + # would have got if we hadn't used a warm_start. + random_state.randint(MAX_INT, size=len(self.estimators_)) + + trees = [self._make_estimator(append=False, + random_state=random_state).init() + for i in range(n_more_estimators)] + + if self.warm_start: + # Advancing subsample_random_state. Assumes each prior fit call has the same number of + # samples at fit time. If not then this would not exactly replicate a single batch execution, + # but would still advance randomness enough so that tree subsamples will be different. + for _, n_, ns_ in zip(range(len(self.estimators_)), self.n_samples_, self.n_samples_subsample_): + subsample_random_state.choice(n_, ns_, replace=False) + s_inds = [subsample_random_state.choice(n_samples, n_samples_subsample, replace=False) + for _ in range(n_more_estimators)] + + # Parallel loop: we prefer the threading backend as the Cython code + # for fitting the trees is internally releasing the Python GIL + # making threading more efficient than multiprocessing in + # that case. However, for joblib 0.12+ we respect any + # parallel_backend contexts set at a higher level, + # since correctness does not rely on using threads. + trees = Parallel(n_jobs=self.n_jobs, verbose=self.verbose, backend='threading')( + delayed(t.fit)(X[s], y[s], + sample_weight=sample_weight[s] if sample_weight is not None else None, + check_input=False) + for t, s in zip(trees, s_inds)) + + # Collect newly grown trees + self.estimators_.extend(trees) + self.n_samples_.extend([n_samples] * len(trees)) + self.n_samples_subsample_.extend([n_samples_subsample] * len(trees)) + + return self + + def get_subsample_inds(self,): + """ Re-generate the example same sample indices as those at fit time using same pseudo-randomness. + """ + check_is_fitted(self) + subsample_random_state = check_random_state(self.subsample_random_seed_) + return [subsample_random_state.choice(n_, ns_, replace=False) + for n_, ns_ in zip(self.n_samples_, self.n_samples_subsample_)] + + def feature_importances(self, max_depth=4, depth_decay_exponent=2.0): + """ + The feature importances based on the amount of parameter heterogeneity they create. + The higher, the more important the feature. + + Parameters + ---------- + max_depth : int, default=4 + Splits of depth larger than `max_depth` are not used in this calculation + depth_decay_exponent: double, default=2.0 + The contribution of each split to the total score is re-weighted by 1 / (1 + `depth`)**2.0. + + Returns + ------- + feature_importances_ : ndarray of shape (n_features,) + Normalized total parameter heterogeneity inducing importance of each feature + """ + check_is_fitted(self) + + all_importances = Parallel(n_jobs=self.n_jobs, backend='threading')( + delayed(tree.feature_importances)( + max_depth=max_depth, depth_decay_exponent=depth_decay_exponent) + for tree in self.estimators_ if tree.tree_.node_count > 1) + + if not all_importances: + return np.zeros(self.n_features_, dtype=np.float64) + + all_importances = np.mean(all_importances, + axis=0, dtype=np.float64) + return all_importances / np.sum(all_importances) + + @property + def feature_importances_(self): + return self.feature_importances() + + def _validate_X_predict(self, X): + """ + Validate X whenever one tries to predict, apply, and other predict methods.""" + check_is_fitted(self) + + return self.estimators_[0]._validate_X_predict(X, check_input=True) + + def predict_value(self, X): + """ Predict the expected value of each treatment for each sample + + Parameters + ---------- + X : {array-like} of shape (n_samples, n_features) + The input samples. Internally, it will be converted to + ``dtype=np.float64``. + + Returns + ------- + welfare : array-like of shape (n_samples, n_treatments) + The conditional average welfare for each treatment for the group of each sample defined by the tree + """ + + check_is_fitted(self) + # Check data + X = self._validate_X_predict(X) + + # Assign chunk of trees to jobs + n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs) + + # avoid storing the output of every estimator by summing them here + y_hat = np.zeros((X.shape[0], self.n_outputs_), dtype=np.float64) + + # Parallel loop + lock = threading.Lock() + Parallel(n_jobs=n_jobs, verbose=self.verbose, backend='threading', require="sharedmem")( + delayed(_accumulate_prediction)(e.predict_value, X, [y_hat], lock) + for e in self.estimators_) + + y_hat /= len(self.estimators_) + + return y_hat + + def predict(self, X): + """ Predict the best treatment for each sample + + Parameters + ---------- + X : {array-like} of shape (n_samples, n_features) + The input samples. Internally, it will be converted to + ``dtype=np.float64``. + + Returns + ------- + treatment : array-like of shape (n_samples) + The recommded treatment, i.e. the treatment index with the largest reward for each sample + """ + return np.argmax(self.predict_value(X), axis=1) diff --git a/econml/policy/_forest/_tree.py b/econml/policy/_forest/_tree.py new file mode 100644 index 000000000..7bd49a668 --- /dev/null +++ b/econml/policy/_forest/_tree.py @@ -0,0 +1,333 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +# +# This code contains snippets of code from: +# https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/tree/_classes.py +# published under the following license and copyright: +# BSD 3-Clause License +# +# Copyright (c) 2007-2020 The scikit-learn developers. +# All rights reserved. + +import numpy as np +import numbers +from math import ceil +from ...tree import Tree +from ...tree._criterion import Criterion +from ...tree._splitter import Splitter, BestSplitter +from ...tree import DepthFirstTreeBuilder +from ...tree import _tree +from ..._tree_exporter import _SingleTreeExporterMixin, _PolicyTreeDOTExporter, _PolicyTreeMPLExporter +from ._criterion import LinearPolicyCriterion +from . import _criterion +from ...tree import BaseTree +from sklearn.model_selection import train_test_split +from sklearn.utils import check_array, check_X_y +from sklearn.utils import check_random_state +from sklearn.utils.validation import _check_sample_weight +from sklearn.utils.validation import check_is_fitted +import copy + +# ============================================================================= +# Types and constants +# ============================================================================= + +CRITERIA_POLICY = {"neg_welfare": LinearPolicyCriterion} + +# ============================================================================= +# Base Policy tree +# ============================================================================= + + +class PolicyTree(_SingleTreeExporterMixin, BaseTree): + """ Welfare maximization policy tree. Trains a tree to maximize the objective: + :math:`1/n \\sum_i \\sum_j a_j(X_i) * y_{ij}`, where, where :math:`a(X)` is constrained + to take value of 1 only on one coordinate and zero otherwise. This corresponds to a policy + optimization problem. + + Parameters + ---------- + criterion : {``'neg_welfare'``}, default='neg_welfare' + The criterion type + + splitter : {"best"}, default="best" + The strategy used to choose the split at each node. Supported + strategies are "best" to choose the best split. + + max_depth : int, default=None + The maximum depth of the tree. If None, then nodes are expanded until + all leaves are pure or until all leaves contain less than + min_samples_split samples. + + min_samples_split : int or float, default=10 + The minimum number of samples required to split an internal node: + + - If int, then consider `min_samples_split` as the minimum number. + - If float, then `min_samples_split` is a fraction and + `ceil(min_samples_split * n_samples)` are the minimum + number of samples for each split. + + min_samples_leaf : int or float, default=5 + The minimum number of samples required to be at a leaf node. + A split point at any depth will only be considered if it leaves at + least ``min_samples_leaf`` training samples in each of the left and + right branches. This may have the effect of smoothing the model, + especially in regression. + + - If int, then consider `min_samples_leaf` as the minimum number. + - If float, then `min_samples_leaf` is a fraction and + `ceil(min_samples_leaf * n_samples)` are the minimum + number of samples for each node. + + min_weight_fraction_leaf : float, default=0.0 + The minimum weighted fraction of the sum total of weights (of all + the input samples) required to be at a leaf node. Samples have + equal weight when sample_weight is not provided. + + max_features : int, float or {"auto", "sqrt", "log2"}, default=None + The number of features to consider when looking for the best split: + + - If int, then consider `max_features` features at each split. + - If float, then `max_features` is a fraction and + `int(max_features * n_features)` features are considered at each + split. + - If "auto", then `max_features=n_features`. + - If "sqrt", then `max_features=sqrt(n_features)`. + - If "log2", then `max_features=log2(n_features)`. + - If None, then `max_features=n_features`. + + Note: the search for a split does not stop until at least one + valid partition of the node samples is found, even if it requires to + effectively inspect more than ``max_features`` features. + + random_state : int, RandomState instance or None, default=None + Controls the randomness of the estimator. The features are always + randomly permuted at each split, even if ``splitter`` is set to + ``"best"``. When ``max_features < n_features``, the algorithm will + select ``max_features`` at random at each split before finding the best + split among them. But the best found split may vary across different + runs, even if ``max_features=n_features``. That is the case, if the + improvement of the criterion is identical for several splits and one + split has to be selected at random. To obtain a deterministic behaviour + during fitting, ``random_state`` has to be fixed to an integer. + + min_impurity_decrease : float, default=0.0 + A node will be split if this split induces a decrease of the impurity + greater than or equal to this value. + The weighted impurity decrease equation is the following:: + + N_t / N * (impurity - N_t_R / N_t * right_impurity + - N_t_L / N_t * left_impurity) + + where ``N`` is the total number of samples, ``N_t`` is the number of + samples at the current node, ``N_t_L`` is the number of samples in the + left child, and ``N_t_R`` is the number of samples in the right child. + ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, + if ``sample_weight`` is passed. + + min_balancedness_tol: float in [0, .5], default=.45 + How imbalanced a split we can tolerate. This enforces that each split leaves at least + (.5 - min_balancedness_tol) fraction of samples on each side of the split; or fraction + of the total weight of samples, when sample_weight is not None. Default value, ensures + that at least 5% of the parent node weight falls in each side of the split. Set it to 0.0 for no + balancedness and to .5 for perfectly balanced splits. For the formal inference theory + to be valid, this has to be any positive constant bounded away from zero. + + honest: bool, default=True + Whether the data should be split in two equally sized samples, such that the one half-sample + is used to determine the optimal split at each node and the other sample is used to determine + the value of every node. + + Attributes + ---------- + feature_importances_ : ndarray of shape (n_features,) + The feature importances based on the amount of parameter heterogeneity they create. + The higher, the more important the feature. + + max_features_ : int + The inferred value of max_features. + + n_features_ : int + The number of features when ``fit`` is performed. + + n_samples_ : int + The number of training samples when ``fit`` is performed. + + honest_ : int + Whether honesty was enabled when ``fit`` was performed + + tree_ : Tree instance + The underlying Tree object. Please refer to + ``help(econml.tree._tree.Tree)`` for attributes of Tree object. + + policy_value_ : float + The value achieved by the recommended policy + + always_treat_value_ : float + The value of the policy that treats all samples + + """ + + def __init__(self, *, + criterion='neg_welfare', + splitter="best", + max_depth=None, + min_samples_split=10, + min_samples_leaf=5, + min_weight_fraction_leaf=0., + max_features=None, + random_state=None, + min_impurity_decrease=0., + min_balancedness_tol=0.45, + honest=True): + super().__init__(criterion=criterion, + splitter=splitter, + max_depth=max_depth, + min_samples_split=min_samples_split, + min_samples_leaf=min_samples_leaf, + min_weight_fraction_leaf=min_weight_fraction_leaf, + max_features=max_features, + random_state=random_state, + min_impurity_decrease=min_impurity_decrease, + min_balancedness_tol=min_balancedness_tol, + honest=honest) + + def _get_valid_criteria(self): + return CRITERIA_POLICY + + def _get_store_jac(self): + return False + + def init(self,): + return self + + def fit(self, X, y, *, sample_weight=None, check_input=True): + """ Fit the tree from the data + + Parameters + ---------- + X : (n, n_features) array + The features to split on + + y : (n, n_treatments) array + The reward for each of the m treatments (including baseline treatment) + + sample_weight : (n,) array, default=None + The sample weights + + check_input : bool, defaul=True + Whether to check the input parameters for validity. Should be set to False to improve + running time in parallel execution, if the variables have already been checked by the + forest class that spawned this tree. + + Returns + ------- + self : object instance + """ + + self.random_seed_ = self.random_state + self.random_state_ = check_random_state(self.random_seed_) + if check_input: + X, y = check_X_y(X, y, multi_output=True, y_numeric=True) + n_y = 1 if y.ndim == 1 else y.shape[1] + super().fit(X, y, n_y, n_y, n_y, + sample_weight=sample_weight, check_input=check_input) + + # The values below are required and utilitized by methods in the _SingleTreeExporterMixin + self.tree_model_ = self + self.policy_value_ = np.mean(np.max(self.predict_value(X), axis=1)) + self.always_treat_value_ = np.mean(y, axis=0) + return self + + def predict(self, X, check_input=True): + """ Predict the best treatment for each sample + + Parameters + ---------- + X : {array-like} of shape (n_samples, n_features) + The input samples. Internally, it will be converted to + ``dtype=np.float64``. + check_input : bool, default=True + Allow to bypass several input checking. + Don't use this parameter unless you know what you do. + + Returns + ------- + treatment : array-like of shape (n_samples) + The recommded treatment, i.e. the treatment index with the largest reward for each sample + """ + check_is_fitted(self) + X = self._validate_X_predict(X, check_input) + pred = self.tree_.predict(X) + return np.argmax(pred, axis=1) + + def predict_value(self, X, check_input=True): + """ Predict the expected value of each treatment for each sample + + Parameters + ---------- + X : {array-like} of shape (n_samples, n_features) + The input samples. Internally, it will be converted to + ``dtype=np.float64``. + check_input : bool, default=True + Allow to bypass several input checking. + Don't use this parameter unless you know what you do. + + Returns + ------- + welfare : array-like of shape (n_samples, n_treatments) + The conditional average welfare for each treatment for the group of each sample defined by the tree + """ + check_is_fitted(self) + X = self._validate_X_predict(X, check_input) + pred = self.tree_.predict(X) + return pred + + def feature_importances(self, max_depth=4, depth_decay_exponent=2.0): + """ + + Parameters + ---------- + max_depth : int, default=4 + Splits of depth larger than `max_depth` are not used in this calculation + depth_decay_exponent: double, default=2.0 + The contribution of each split to the total score is re-weighted by ``1 / (1 + `depth`)**2.0``. + + Returns + ------- + feature_importances_ : ndarray of shape (n_features,) + Normalized total parameter heterogeneity inducing importance of each feature + """ + check_is_fitted(self) + + return self.tree_.compute_feature_importances(normalize=True, max_depth=max_depth, + depth_decay=depth_decay_exponent) + + @property + def feature_importances_(self): + return self.feature_importances() + + def _make_dot_exporter(self, *, out_file, feature_names, treatment_names, max_depth, filled, + leaves_parallel, rotate, rounded, + special_characters, precision): + title = "Average policy gains over no treatment: {} \n".format(np.around(self.policy_value_, precision)) + title += "Average policy gains over constant treatment policies for each treatment: {}".format( + np.around(self.policy_value_ - self.always_treat_value_, precision)) + return _PolicyTreeDOTExporter(out_file=out_file, title=title, + treatment_names=treatment_names, feature_names=feature_names, + max_depth=max_depth, + filled=filled, leaves_parallel=leaves_parallel, rotate=rotate, + rounded=rounded, special_characters=special_characters, + precision=precision) + + def _make_mpl_exporter(self, *, title, feature_names, treatment_names, max_depth, filled, + rounded, precision, fontsize): + title = "" if title is None else title + title += "Average policy gains over no treatment: {} \n".format(np.around(self.policy_value_, precision)) + title += "Average policy gains over constant treatment policies for each treatment: {}".format( + np.around(self.policy_value_ - self.always_treat_value_, precision)) + return _PolicyTreeMPLExporter(treatment_names=treatment_names, title=title, + feature_names=feature_names, max_depth=max_depth, + filled=filled, + rounded=rounded, + precision=precision, fontsize=fontsize) diff --git a/econml/sklearn_extensions/linear_model.py b/econml/sklearn_extensions/linear_model.py index de63bbf14..dc9020c46 100644 --- a/econml/sklearn_extensions/linear_model.py +++ b/econml/sklearn_extensions/linear_model.py @@ -37,14 +37,14 @@ from joblib import Parallel, delayed -def _weighted_check_cv(cv=5, y=None, classifier=False): +def _weighted_check_cv(cv=5, y=None, classifier=False, random_state=None): cv = 5 if cv is None else cv if isinstance(cv, numbers.Integral): if (classifier and (y is not None) and (type_of_target(y) in ('binary', 'multiclass'))): - return WeightedStratifiedKFold(cv) + return WeightedStratifiedKFold(cv, random_state=random_state) else: - return WeightedKFold(cv) + return WeightedKFold(cv, random_state=random_state) if not hasattr(cv, 'split') or isinstance(cv, str): if not isinstance(cv, Iterable) or isinstance(cv, str): @@ -435,7 +435,7 @@ def fit(self, X, y, sample_weight=None): """ # Make weighted splitter cv_temp = self.cv - self.cv = _weighted_check_cv(self.cv).split(X, y, sample_weight=sample_weight) + self.cv = _weighted_check_cv(self.cv, random_state=self.random_state).split(X, y, sample_weight=sample_weight) # Fit weighted model self._fit_weighted_linear_model(X, y, sample_weight) self.cv = cv_temp @@ -546,7 +546,7 @@ def fit(self, X, y, sample_weight=None): """ # Make weighted splitter cv_temp = self.cv - self.cv = _weighted_check_cv(self.cv).split(X, y, sample_weight=sample_weight) + self.cv = _weighted_check_cv(self.cv, random_state=self.random_state).split(X, y, sample_weight=sample_weight) # Fit weighted model self._fit_weighted_linear_model(X, y, sample_weight) self.cv = cv_temp diff --git a/econml/sklearn_extensions/model_selection.py b/econml/sklearn_extensions/model_selection.py index 8cb610c90..06eeab09a 100644 --- a/econml/sklearn_extensions/model_selection.py +++ b/econml/sklearn_extensions/model_selection.py @@ -17,7 +17,7 @@ from sklearn.model_selection._validation import (_check_is_permutation, _fit_and_predict) from sklearn.preprocessing import LabelEncoder -from sklearn.utils import indexable +from sklearn.utils import indexable, check_random_state from sklearn.utils.validation import _num_samples @@ -29,12 +29,18 @@ def _split_weighted_sample(self, X, y, sample_weight, is_stratified=False): else: kfold_model = KFold(n_splits=self.n_splits, shuffle=self.shuffle, random_state=random_state) + if sample_weight is None: return kfold_model.split(X, y) + else: + random_state = self.random_state + kfold_model.shuffle = True + kfold_model.random_state = random_state + weights_sum = np.sum(sample_weight) max_deviations = [] all_splits = [] - for i in range(self.n_trials + 1): + for _ in range(self.n_trials + 1): splits = [test for (train, test) in list(kfold_model.split(X, y))] weight_fracs = np.array([np.sum(sample_weight[split]) / weights_sum for split in splits]) if np.all(weight_fracs > .95 / self.n_splits): @@ -45,7 +51,6 @@ def _split_weighted_sample(self, X, y, sample_weight, is_stratified=False): max_deviation = np.max(np.abs(weight_fracs - 1 / self.n_splits)) max_deviations.append(max_deviation) # Reseed random generator and try again - kfold_model.shuffle = True if isinstance(kfold_model.random_state, numbers.Integral): kfold_model.random_state = kfold_model.random_state + 1 elif kfold_model.random_state is not None: @@ -65,6 +70,7 @@ def _split_weighted_sample(self, X, y, sample_weight, is_stratified=False): else: stratified_weight_splits = self._get_splits_from_weight_stratification(sample_weight) weight_fracs = np.array([np.sum(sample_weight[split]) / weights_sum for split in stratified_weight_splits]) + if np.all(weight_fracs > .95 / self.n_splits): # Found a good split, return. return self._get_folds_from_splits(stratified_weight_splits, X.shape[0]) @@ -141,20 +147,21 @@ def _get_folds_from_splits(self, splits, sample_size): def _get_splits_from_weight_stratification(self, sample_weight): # Weight stratification algorithm # Sort weights for weight strata search + random_state = check_random_state(self.random_state) sorted_inds = np.argsort(sample_weight) sorted_weights = sample_weight[sorted_inds] max_split_size = sorted_weights.shape[0] // self.n_splits max_divisible_length = max_split_size * self.n_splits sorted_inds_subset = np.reshape(sorted_inds[:max_divisible_length], (max_split_size, self.n_splits)) - shuffled_sorted_inds_subset = np.apply_along_axis(np.random.permutation, axis=1, arr=sorted_inds_subset) + shuffled_sorted_inds_subset = np.apply_along_axis(random_state.permutation, axis=1, arr=sorted_inds_subset) splits = [list(shuffled_sorted_inds_subset[:, i]) for i in range(self.n_splits)] if max_divisible_length != sorted_weights.shape[0]: # There are some leftover indices that have yet to be assigned subsample = sorted_inds[max_divisible_length:] if self.shuffle: - np.random.shuffle(subsample) + random_state.shuffle(subsample) new_splits = np.array_split(subsample, self.n_splits) - np.random.shuffle(new_splits) + random_state.shuffle(new_splits) # Append stratum splits to overall splits splits = [split + list(new_split) for split, new_split in zip(splits, new_splits)] return splits diff --git a/econml/tests/test_cate_interpreter.py b/econml/tests/test_cate_interpreter.py index 74190eaa6..a36140d14 100644 --- a/econml/tests/test_cate_interpreter.py +++ b/econml/tests/test_cate_interpreter.py @@ -7,6 +7,7 @@ import graphviz from econml.cate_interpreter import SingleTreeCateInterpreter, SingleTreePolicyInterpreter from econml.dml import LinearDML +from sklearn.linear_model import LinearRegression, LogisticRegression graphviz_works = True try: @@ -28,7 +29,7 @@ def test_can_use_interpreters(self): X = np.random.normal(size=(n, 4)) T = np.random.binomial(1, 0.5, size=t_shape) Y = (T.flatten() * (2 * (X[:, 0] > 0) - 1)).reshape(y_shape) - est = LinearDML(discrete_treatment=True) + est = LinearDML(model_y=LinearRegression(), model_t=LogisticRegression(), discrete_treatment=True) est.fit(Y, T, X=X) for intrp in [SingleTreeCateInterpreter(), SingleTreePolicyInterpreter()]: with self.subTest(t_shape=t_shape, y_shape=y_shape, intrp=intrp): @@ -49,7 +50,7 @@ def test_cate_uncertainty_needs_inference(self): X = np.random.normal(size=(n, 4)) T = np.random.binomial(1, 0.5, size=(n,)) Y = (2 * (X[:, 0] > 0) - 1) * T.flatten() - est = LinearDML(discrete_treatment=True) + est = LinearDML(model_y=LinearRegression(), model_t=LogisticRegression(), discrete_treatment=True) est.fit(Y, T, X=X, inference=None) # can interpret without uncertainty @@ -70,7 +71,7 @@ def test_can_assign_treatment(self): X = np.random.normal(size=(n, 4)) T = np.random.binomial(1, 0.5, size=(n,)) Y = (2 * (X[:, 0] > 0) - 1) * T.flatten() - est = LinearDML(discrete_treatment=True) + est = LinearDML(model_y=LinearRegression(), model_t=LogisticRegression(), discrete_treatment=True) est.fit(Y, T, X=X) # can interpret without uncertainty @@ -82,20 +83,32 @@ def test_can_assign_treatment(self): intrp.interpret(est, X) T_policy = intrp.treat(X) assert T.shape == T_policy.shape + intrp.interpret(est, X, sample_treatment_costs=np.ones((T.shape[0], 1))) + T_policy = intrp.treat(X) + assert T.shape == T_policy.shape + with np.testing.assert_raises(ValueError): + intrp.interpret(est, X, sample_treatment_costs=np.ones((T.shape[0], 2))) def test_random_cate_settings(self): """Verify that we can call methods on the CATE interpreter with various combinations of inputs""" n = 100 for _ in range(100): - t_shape = (n,) if self.coinflip else (n, 1) - y_shape = (n,) if self.coinflip else (n, 1) + t_shape = (n,) if self.coinflip() else (n, 1) + y_shape = (n,) if self.coinflip() else (n, 1) discrete_t = self.coinflip() X = np.random.normal(size=(n, 4)) X2 = np.random.normal(size=(10, 4)) - T = np.random.binomial(1, 0.5, size=t_shape) if discrete_t else np.random.normal(size=t_shape) - Y = (T.flatten() * (2 * (X[:, 0] > 0) - 1)).reshape(y_shape) + T = np.random.binomial(2, 0.5, size=t_shape) if discrete_t else np.random.normal(size=t_shape) + Y = ((T.flatten() == 1) * (2 * (X[:, 0] > 0) - 1) + + (T.flatten() == 2) * (2 * (X[:, 1] > 0) - 1)).reshape(y_shape) + + if self.coinflip(): + y_shape = (n, 2) + Y = np.tile(Y.reshape((-1, 1)), (1, 2)) - est = LinearDML(discrete_treatment=discrete_t) + est = LinearDML(model_y=LinearRegression(), + model_t=LogisticRegression() if discrete_t else LinearRegression(), + discrete_treatment=discrete_t) fit_kwargs = {} cate_init_kwargs = {} @@ -119,13 +132,16 @@ def test_random_cate_settings(self): if self.coinflip(): policy_init_kwargs.update(risk_seeking=True) - if self.coinflip(): - policy_intrp_kwargs.update(treatment_names=['control gp', 'treated gp']) - if self.coinflip(1 / 3): policy_intrp_kwargs.update(sample_treatment_costs=0.1) elif self.coinflip(): - policy_intrp_kwargs.update(sample_treatment_costs=np.random.normal(size=(10,))) + if discrete_t: + policy_intrp_kwargs.update(sample_treatment_costs=np.random.normal(size=(10, 2))) + else: + if self.coinflip(): + policy_intrp_kwargs.update(sample_treatment_costs=np.random.normal(size=(10, 1))) + else: + policy_intrp_kwargs.update(sample_treatment_costs=np.random.normal(size=(10,))) if self.coinflip(): common_kwargs.update(feature_names=['A', 'B', 'C', 'D']) @@ -146,6 +162,12 @@ def test_random_cate_settings(self): if self.coinflip(): render_kwargs.update(leaves_parallel=False) export_kwargs.update(leaves_parallel=False) + if discrete_t: + render_kwargs.update(treatment_names=['control gp', 'treated gp', 'more gp']) + export_kwargs.update(treatment_names=['control gp', 'treated gp', 'more gp']) + else: + render_kwargs.update(treatment_names=['control gp', 'treated gp']) + export_kwargs.update(treatment_names=['control gp', 'treated gp']) if self.coinflip(): render_kwargs.update(format='png') diff --git a/econml/tests/test_grf_python.py b/econml/tests/test_grf_python.py index eb29e2e3c..bc8d30134 100644 --- a/econml/tests/test_grf_python.py +++ b/econml/tests/test_grf_python.py @@ -611,7 +611,7 @@ def test_raise_exceptions(self,): forest.inference = False forest.n_estimators = 8 forest.fit(X, y) - with np.testing.assert_raises(KeyError): + with np.testing.assert_raises(ValueError): forest = CausalForest(n_estimators=4, criterion='peculiar').fit(X, y, y) with np.testing.assert_raises(ValueError): forest = CausalForest(n_estimators=4, max_depth=-1).fit(X, y, y) @@ -632,25 +632,28 @@ def test_raise_exceptions(self,): def test_warm_start(self,): n_features = 2 - n = 10 + n = 100 random_state = 123 X, y, _ = self._get_regression_data(n, n_features, random_state) - forest = RegressionForest(n_estimators=4, warm_start=True, random_state=123).fit(X, y) - forest.n_estimators = 8 - forest.fit(X, y) - pred1 = forest.predict(X) - inds1 = forest.get_subsample_inds() - tree_states1 = [t.random_state for t in forest] - - forest = RegressionForest(n_estimators=8, warm_start=True, random_state=123).fit(X, y) - pred2 = forest.predict(X) - inds2 = forest.get_subsample_inds() - tree_states2 = [t.random_state for t in forest] - - np.testing.assert_allclose(pred1, pred2) - np.testing.assert_allclose(inds1, inds2) - np.testing.assert_allclose(tree_states1, tree_states2) + for inference in [True, False]: + forest = RegressionForest(n_estimators=4, inference=inference, + warm_start=True, random_state=123).fit(X, y) + forest.n_estimators = 8 + forest.fit(X, y) + pred1 = forest.predict(X) + inds1 = forest.get_subsample_inds() + tree_states1 = [t.random_state for t in forest] + + forest = RegressionForest(n_estimators=8, inference=inference, + warm_start=True, random_state=123).fit(X, y) + pred2 = forest.predict(X) + inds2 = forest.get_subsample_inds() + tree_states2 = [t.random_state for t in forest] + + np.testing.assert_allclose(pred1, pred2) + np.testing.assert_allclose(inds1, inds2) + np.testing.assert_allclose(tree_states1, tree_states2) return def test_multioutput(self,): diff --git a/econml/tests/test_policy_forest.py b/econml/tests/test_policy_forest.py new file mode 100644 index 000000000..6434a50ba --- /dev/null +++ b/econml/tests/test_policy_forest.py @@ -0,0 +1,436 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import unittest +import logging +import time +import random +import numpy as np +import pandas as pd +import pytest +import joblib +from econml.policy import PolicyTree, PolicyForest +from econml.policy import DRPolicyTree, DRPolicyForest +from econml.utilities import cross_product +from copy import deepcopy +from sklearn.utils import check_random_state +import scipy.stats +from sklearn.preprocessing import PolynomialFeatures +from sklearn.dummy import DummyClassifier, DummyRegressor +from sklearn.model_selection import GroupKFold + + +graphviz_works = True +try: + from graphviz import Graph + g = Graph() + g.render() +except Exception: + graphviz_works = False + + +class TestPolicyForest(unittest.TestCase): + + def _get_base_config(self): + return {'n_estimators': 1, 'max_depth': 2, + 'min_samples_split': 2, 'min_samples_leaf': 1, + 'max_samples': 1.0, 'honest': False, + 'n_jobs': None, 'random_state': 123} + + def _get_policy_data(self, n, n_features, random_state, n_outcomes=2): + random_state = np.random.RandomState(random_state) + X = random_state.normal(size=(n, n_features)) + if n_outcomes == 1: + y = (X[:, 0] > 0.0) - .5 + else: + y = np.hstack([np.zeros((X.shape[0], 1)), (X[:, [0]] > 0.0) - .5]) + return (X, y, y) + + def _get_true_quantities(self, X, y, mask, sample_weight=None): + if sample_weight is None: + sample_weight = np.ones(X.shape[0]) + X, y, sample_weight = X[mask], y[mask], sample_weight[mask] + node_value = np.average(y, axis=0, weights=sample_weight) + impurity = - np.max(node_value) + return node_value, impurity + + def _get_node_quantities(self, tree, node_id): + return (tree.full_value[node_id, :, 0], tree.impurity[node_id]) + + def _train_policy_forest(self, X, y, config, sample_weight=None): + return PolicyForest(**config).fit(X, y, sample_weight=sample_weight) + + def _train_dr_policy_forest(self, X, y, config, sample_weight=None): + config.pop('criterion') + if sample_weight is not None: + sample_weight = np.repeat(sample_weight, 2) + groups = np.repeat(np.arange(X.shape[0]), 2) + X = np.repeat(X, 2, axis=0) + T = np.zeros(y.shape) + T[:, 1] = 1 + T = T.flatten() + y = y.flatten() + return DRPolicyForest(model_regression=DummyRegressor(strategy='constant', constant=0), + model_propensity=DummyClassifier(strategy='uniform'), + featurizer=PolynomialFeatures(degree=1, include_bias=False), + cv=GroupKFold(n_splits=2), + **config).fit(y, T, X=X, + sample_weight=sample_weight, + groups=groups).policy_model_ + + def _train_dr_policy_tree(self, X, y, config, sample_weight=None): + config.pop('n_estimators') + config.pop('max_samples') + config.pop('n_jobs') + config.pop('criterion') + if sample_weight is not None: + sample_weight = np.repeat(sample_weight, 2) + groups = np.repeat(np.arange(X.shape[0]), 2) + X = np.repeat(X, 2, axis=0) + T = np.zeros(y.shape) + T[:, 1] = 1 + T = T.flatten() + y = y.flatten() + return [DRPolicyTree(model_regression=DummyRegressor(strategy='constant', constant=0), + model_propensity=DummyClassifier(strategy='uniform'), + featurizer=PolynomialFeatures(degree=1, include_bias=False), + cv=GroupKFold(n_splits=2), + **config).fit(y, T, X=X, sample_weight=sample_weight, + groups=groups).policy_model_] + + def _test_policy_tree_internals(self, trainer): + config = self._get_base_config() + for criterion in ['neg_welfare']: + config['criterion'] = criterion + config['max_depth'] = 2 + config['min_samples_leaf'] = 5 + n, n_features = 100, 2 + random_state = 123 + X, y, _ = self._get_policy_data(n, n_features, random_state) + forest = trainer(X, y, config) + tree = forest[0].tree_ + paths = np.array(forest[0].decision_path(X).todense()) + for node_id in range(len(tree.feature)): + mask = paths[:, node_id] > 0 + [np.testing.assert_allclose(a, b, atol=1e-4) + for a, b in zip(self._get_true_quantities(X, y, mask), + self._get_node_quantities(tree, node_id))] + + def _test_policy_honesty(self, trainer, dr=False): + n_outcome_list = [1, 2] if not dr else [2] + for criterion in ['neg_welfare']: + for min_impurity_decrease in [0.0, 0.07]: + for sample_weight in [None, 'rand']: + for n_outcomes in n_outcome_list: + config = self._get_base_config() + config['honest'] = True if not dr else False + config['criterion'] = criterion + config['max_depth'] = 2 + config['min_samples_leaf'] = 5 + config['min_impurity_decrease'] = min_impurity_decrease + n, n_features = 800, 2 + config['n_estimators'] = 4 + config['max_samples'] = .4 if not dr else 1.0 + config['n_jobs'] = 1 + random_state = 123 + if sample_weight is not None: + sample_weight = check_random_state(random_state).randint(0, 4, size=n) + X, y, truth = self._get_policy_data(n, n_features, random_state, n_outcomes) + forest = trainer(X, y, config, sample_weight=sample_weight) + subinds = forest.get_subsample_inds() + forest_paths, ptr = forest.decision_path(X) + forest_paths = np.array(forest_paths.todense()) + forest_apply = forest.apply(X) + for it, tree in enumerate(forest): + tree_paths = np.array(tree.decision_path(X).todense()) + np.testing.assert_array_equal(tree_paths, forest_paths[:, ptr[it]:ptr[it + 1]]) + tree_apply = tree.apply(X) + np.testing.assert_array_equal(tree_apply, forest_apply[:, it]) + _, samples_val = tree.get_train_test_split_inds() + inds_val = subinds[it][samples_val] + if dr: + inds_val = inds_val[np.array(inds_val) % 2 == 0] // 2 + Xval, yval, _ = X[inds_val], y[inds_val], truth[inds_val] + sample_weightval = sample_weight[inds_val] if sample_weight is not None else None + paths = np.array(tree.decision_path(Xval).todense()) + for node_id in range(len(tree.tree_.feature)): + mask = paths[:, node_id] > 0 + [np.testing.assert_allclose(a, b, atol=1e-4) + for a, b in zip(self._get_true_quantities(Xval, yval, mask, + sample_weight=sample_weightval), + self._get_node_quantities(tree.tree_, node_id))] + if (sample_weight is None) and min_impurity_decrease > 0.0005: + assert np.all((tree.tree_.feature == 0) | (tree.tree_.feature == -2)) + + def test_policy_tree(self,): + self._test_policy_tree_internals(self._train_policy_forest) + self._test_policy_honesty(self._train_policy_forest) + + def test_drpolicy_tree(self,): + self._test_policy_tree_internals(self._train_dr_policy_tree) + + def test_drpolicy_forest(self,): + self._test_policy_tree_internals(self._train_dr_policy_forest) + self._test_policy_honesty(self._train_dr_policy_forest, dr=True) + + def test_subsampling(self,): + # test that the subsampling scheme past to the trees is correct + random_state = 123 + n, n_features = 10, 2 + n_estimators = 600 + config = self._get_base_config() + config['n_estimators'] = n_estimators + config['max_samples'] = .7 + config['max_depth'] = 1 + X, y, _ = self._get_policy_data(n, n_features, random_state) + forest = self._train_policy_forest(X, y, config) + subinds = forest.get_subsample_inds() + inds, counts = np.unique(subinds, return_counts=True) + np.testing.assert_allclose(counts / n_estimators, .7, atol=.06) + counts = np.zeros(n) + for it, tree in enumerate(forest): + samples_train, samples_val = tree.get_train_test_split_inds() + np.testing.assert_equal(samples_train, samples_val) + config = self._get_base_config() + config['n_estimators'] = n_estimators + config['max_samples'] = 7 + config['max_depth'] = 1 + X, y, _ = self._get_policy_data(n, n_features, random_state) + forest = self._train_policy_forest(X, y, config) + subinds = forest.get_subsample_inds() + inds, counts = np.unique(subinds, return_counts=True) + np.testing.assert_allclose(counts / n_estimators, .7, atol=.06) + config = self._get_base_config() + config['n_estimators'] = n_estimators + config['max_samples'] = .4 + config['max_depth'] = 1 + config['honest'] = True + X, y, _ = self._get_policy_data(n, n_features, random_state) + forest = self._train_policy_forest(X, y, config) + subinds = forest.get_subsample_inds() + inds, counts = np.unique(subinds, return_counts=True) + np.testing.assert_allclose(counts / n_estimators, .4, atol=.06) + counts = np.zeros(n) + for it, tree in enumerate(forest): + _, samples_val = tree.get_train_test_split_inds() + inds_val = subinds[it][samples_val] + counts[inds_val] += 1 + np.testing.assert_allclose(counts / n_estimators, .2, atol=.05) + return + + def test_feature_importances(self,): + # test that the estimator calcualtes var correctly + for trainer in [self._train_policy_forest]: + for criterion in ['neg_welfare']: + for sample_weight in [None, 'rand']: + config = self._get_base_config() + config['honest'] = True + config['criterion'] = criterion + config['max_depth'] = 2 + config['min_samples_leaf'] = 5 + config['min_impurity_decrease'] = 0.0 + config['n_estimators'] = 4 + config['max_samples'] = .4 + config['n_jobs'] = 1 + + n, n_features = 800, 2 + random_state = 123 + if sample_weight is not None: + sample_weight = check_random_state(random_state).randint(0, 4, size=n) + X, y, _ = self._get_policy_data(n, n_features, random_state) + forest = trainer(X, y, config, sample_weight=sample_weight) + forest_het_importances = np.zeros(n_features) + for it, tree in enumerate(forest): + tree_ = tree.tree_ + tfeature = tree_.feature + timpurity = tree_.impurity + tdepth = tree_.depth + tleft = tree_.children_left + tright = tree_.children_right + tw = tree_.weighted_n_node_samples + tvalue = tree_.value + + for max_depth in [0, 2]: + feature_importances = np.zeros(n_features) + for it, (feat, impurity, depth, left, right, w) in\ + enumerate(zip(tfeature, timpurity, tdepth, tleft, tright, tw)): + if (left != -1) and (depth <= max_depth): + gain = w * impurity - tw[left] * timpurity[left] - tw[right] * timpurity[right] + feature_importances[feat] += gain / (depth + 1)**2.0 + feature_importances /= tw[0] + totest = tree.tree_.compute_feature_importances(normalize=False, + max_depth=max_depth, depth_decay=2.0) + np.testing.assert_array_equal(feature_importances, totest) + + het_importances = np.zeros(n_features) + for it, (feat, depth, left, right, w) in\ + enumerate(zip(tfeature, tdepth, tleft, tright, tw)): + if (left != -1) and (depth <= max_depth): + gain = tw[left] * tw[right] * np.mean((tvalue[left] - tvalue[right])**2) / w + het_importances[feat] += gain / (depth + 1)**2.0 + het_importances /= tw[0] + totest = tree.tree_.compute_feature_heterogeneity_importances(normalize=False, + max_depth=max_depth, + depth_decay=2.0) + np.testing.assert_allclose(het_importances, totest) + het_importances /= np.sum(het_importances) + forest_het_importances += het_importances / len(forest) + + np.testing.assert_allclose(forest_het_importances, + forest.feature_importances(max_depth=2, depth_decay_exponent=2.0)) + np.testing.assert_allclose(forest_het_importances, forest.feature_importances_) + return + + def test_non_standard_input(self,): + # test that the estimator accepts lists, tuples and pandas data frames + n_features = 2 + n = 2000 + random_state = 123 + X, y, _ = self._get_policy_data(n, n_features, random_state) + forest = PolicyForest(n_estimators=20, n_jobs=1, random_state=123).fit(X, y) + pred = forest.predict(X) + pred_val = forest.predict_value(X) + feat_imp = forest.feature_importances() + forest = PolicyForest(n_estimators=20, n_jobs=1, random_state=123).fit(X.astype(np.float32), + np.asfortranarray(y)) + np.testing.assert_allclose(pred, forest.predict(tuple(X))) + np.testing.assert_allclose(pred_val, forest.predict_value(tuple(X))) + forest = PolicyForest(n_estimators=20, n_jobs=1, random_state=123).fit(tuple(X), tuple(y)) + np.testing.assert_allclose(pred, forest.predict(tuple(X))) + np.testing.assert_allclose(pred_val, forest.predict_value(tuple(X))) + forest = PolicyForest(n_estimators=20, n_jobs=1, random_state=123).fit(list(X), list(y)) + np.testing.assert_allclose(pred, forest.predict(list(X))) + np.testing.assert_allclose(pred_val, forest.predict_value(list(X))) + forest = PolicyForest(n_estimators=20, n_jobs=1, random_state=123).fit(pd.DataFrame(X), pd.DataFrame(y)) + np.testing.assert_allclose(pred, forest.predict(pd.DataFrame(X))) + np.testing.assert_allclose(pred_val, forest.predict_value(pd.DataFrame(X))) + + groups = np.repeat(np.arange(X.shape[0]), 2) + Xraw = X.copy() + X = np.repeat(X, 2, axis=0) + T = np.zeros(y.shape) + T[:, 1] = 1 + T = T.flatten() + y = y.flatten() + forest = DRPolicyForest(model_regression=DummyRegressor(strategy='constant', constant=0), + model_propensity=DummyClassifier(strategy='uniform'), + featurizer=PolynomialFeatures(degree=1, include_bias=False), + cv=GroupKFold(n_splits=2), + n_estimators=20, n_jobs=1, random_state=123).fit(y, T, X=X, + groups=groups) + mask = np.abs(Xraw[:, 0]) > .1 + np.testing.assert_allclose(pred[mask], forest.predict(Xraw[mask])) + np.testing.assert_allclose(pred_val[mask, 1] - pred_val[mask, 0], + forest.predict_value(Xraw[mask]).flatten(), atol=.08) + np.testing.assert_allclose(feat_imp, forest.feature_importances(), atol=1e-4) + np.testing.assert_allclose(feat_imp, forest.feature_importances_, atol=1e-4) + return + + def test_raise_exceptions(self,): + # test that we raise errors in mishandled situations. + n_features = 2 + n = 10 + random_state = 123 + X, y, _ = self._get_policy_data(n, n_features, random_state) + with np.testing.assert_raises(ValueError): + forest = PolicyForest(n_estimators=20, max_samples=20).fit(X, y) + with np.testing.assert_raises(ValueError): + forest = PolicyForest(n_estimators=20, max_samples=1.2).fit(X, y) + with np.testing.assert_raises(ValueError): + forest = PolicyForest(n_estimators=4, criterion='peculiar').fit(X, y) + with np.testing.assert_raises(ValueError): + forest = PolicyForest(n_estimators=4, max_depth=-1).fit(X, y) + with np.testing.assert_raises(ValueError): + forest = PolicyForest(n_estimators=4, min_samples_split=-1).fit(X, y) + with np.testing.assert_raises(ValueError): + forest = PolicyForest(n_estimators=4, min_samples_leaf=-1).fit(X, y) + with np.testing.assert_raises(ValueError): + forest = PolicyForest(n_estimators=4, min_weight_fraction_leaf=-1.0).fit(X, y) + with np.testing.assert_raises(ValueError): + forest = PolicyForest(n_estimators=4, max_features=10).fit(X, y) + with np.testing.assert_raises(ValueError): + forest = PolicyForest(n_estimators=4, min_balancedness_tol=.55).fit(X, y) + + return + + def test_warm_start(self,): + n_features = 2 + n = 10 + random_state = 123 + X, y, _ = self._get_policy_data(n, n_features, random_state) + + forest = PolicyForest(n_estimators=4, warm_start=True, random_state=123).fit(X, y) + with pytest.warns(UserWarning): + forest.fit(X, y) + forest.n_estimators = 3 + with np.testing.assert_raises(ValueError): + forest.fit(X, y) + forest.n_estimators = 8 + forest.fit(X, y) + pred1 = forest.predict(X) + inds1 = forest.get_subsample_inds() + tree_states1 = [t.random_state for t in forest] + + forest = PolicyForest(n_estimators=8, warm_start=True, random_state=123).fit(X, y) + pred2 = forest.predict(X) + inds2 = forest.get_subsample_inds() + tree_states2 = [t.random_state for t in forest] + + np.testing.assert_allclose(pred1, pred2) + np.testing.assert_allclose(inds1, inds2) + np.testing.assert_allclose(tree_states1, tree_states2) + return + + @pytest.mark.skipif(not graphviz_works, reason="graphviz must be installed to test plotting") + def test_plotting(self): + n_features = 2 + n = 1000 + random_state = 123 + X, y, _ = self._get_policy_data(n, n_features, random_state) + + tree = PolicyTree(max_depth=4, random_state=123).fit(X, y) + tree.plot(max_depth=2) + tree.render('test', max_depth=2) + + groups = np.repeat(np.arange(X.shape[0]), 2) + Xraw = X.copy() + X = np.repeat(X, 2, axis=0) + T = np.zeros(y.shape) + T[:, 1] = 1 + T = T.flatten() + y = y.flatten() + forest = DRPolicyForest(model_regression=DummyRegressor(strategy='constant', constant=0), + model_propensity=DummyClassifier(strategy='uniform'), + featurizer=PolynomialFeatures(degree=1, include_bias=False), + cv=GroupKFold(n_splits=2), + n_estimators=20, n_jobs=1, random_state=123).fit(y, T, X=X, + groups=groups) + forest.plot(0, max_depth=2) + forest.render(0, 'testdrf', max_depth=2) + forest.export_graphviz(0, max_depth=2) + + tree = DRPolicyTree(model_regression=DummyRegressor(strategy='constant', constant=0), + model_propensity=DummyClassifier(strategy='uniform'), + featurizer=PolynomialFeatures(degree=1, include_bias=False), + cv=GroupKFold(n_splits=2), random_state=123).fit(y, T, X=X, + groups=groups) + tree.plot(max_depth=2) + tree.render('testdrt', max_depth=2) + tree.export_graphviz(max_depth=2) + + def test_pickling(self,): + + n_features = 2 + n = 10 + random_state = 123 + X, y, _ = self._get_policy_data(n, n_features, random_state) + + forest = PolicyForest(n_estimators=4, warm_start=True, random_state=123).fit(X, y) + forest.n_estimators = 8 + forest.fit(X, y) + pred1 = forest.predict(X) + + joblib.dump(forest, 'forest.jbl') + loaded_forest = joblib.load('forest.jbl') + np.testing.assert_equal(loaded_forest.n_estimators, forest.n_estimators) + np.testing.assert_allclose(loaded_forest.predict(X), pred1) diff --git a/econml/tests/test_refit.py b/econml/tests/test_refit.py index 5ba0c0074..dcfb0b560 100644 --- a/econml/tests/test_refit.py +++ b/econml/tests/test_refit.py @@ -57,7 +57,7 @@ def test_dml(self): dml.intercept_ with pytest.raises(AttributeError): dml.intercept__interval() - dml.model_final = DebiasedLasso(fit_intercept=False) + dml.model_final = DebiasedLasso(fit_intercept=False, random_state=123) dml.refit_final() assert isinstance(dml.model_cate, DebiasedLasso) dml.featurizer = PolynomialFeatures(degree=2, include_bias=False) @@ -77,10 +77,10 @@ def test_dml(self): dml.discrete_treatment = True dml.featurizer = None dml.linear_first_stages = True - dml.model_t = LogisticRegression() + dml.model_t = LogisticRegression(random_state=123) dml.fit(y, T, X=X, W=W) newdml = DML(model_y=LinearRegression(), - model_t=LogisticRegression(), + model_t=LogisticRegression(random_state=123), model_final=StatsModelsLinearRegression(fit_intercept=False), discrete_treatment=True, linear_first_stages=True, @@ -116,13 +116,13 @@ def test_nonparam_dml(self): dml = NonParamDML(model_y=LinearRegression(), model_t=LinearRegression(), - model_final=WeightedLasso(), + model_final=WeightedLasso(random_state=123), random_state=123) dml.fit(y, T, X=X, W=W) with pytest.raises(Exception): dml.refit_final() dml.fit(y, T, X=X, W=W, cache_values=True) - dml.model_final = DebiasedLasso(fit_intercept=False) + dml.model_final = DebiasedLasso(fit_intercept=False, random_state=123) dml.refit_final() assert isinstance(dml.model_cate, DebiasedLasso) dml.effect_interval(X[:1]) @@ -133,12 +133,12 @@ def test_nonparam_dml(self): dml.discrete_treatment = True dml.featurizer = None dml.linear_first_stages = True - dml.model_t = LogisticRegression() - dml.model_final = DebiasedLasso() + dml.model_t = LogisticRegression(random_state=123) + dml.model_final = DebiasedLasso(random_state=123) dml.fit(y, T, X=X, W=W) newdml = NonParamDML(model_y=LinearRegression(), - model_t=LogisticRegression(), - model_final=DebiasedLasso(), + model_t=LogisticRegression(random_state=123), + model_final=DebiasedLasso(random_state=123), discrete_treatment=True, random_state=123).fit(y, T, X=X, W=W) np.testing.assert_array_equal(dml.effect(X[:1]), newdml.effect(X[:1])) @@ -152,7 +152,7 @@ def test_drlearner(self): est.fit(y, T, X=X, W=W, cache_values=True) np.testing.assert_equal(est.model_regression, 'auto') est.model_regression = LinearRegression() - est.model_propensity = LogisticRegression() + est.model_propensity = LogisticRegression(random_state=123) est.fit(y, T, X=X, W=W, cache_values=True) assert isinstance(est.model_regression, LinearRegression) with pytest.raises(ValueError): diff --git a/econml/tests/test_rscorer.py b/econml/tests/test_rscorer.py index 93f4779a9..185769f72 100644 --- a/econml/tests/test_rscorer.py +++ b/econml/tests/test_rscorer.py @@ -22,9 +22,9 @@ def _fit_model(name, model, Y, T, X): class TestRScorer(unittest.TestCase): def _get_data(self): - X = np.random.normal(0, 1, size=(500, 2)) - T = np.random.binomial(1, .5, size=(500,)) - y = X[:, 0] * T + np.random.normal(size=(500,)) + X = np.random.normal(0, 1, size=(2000, 2)) + T = np.random.binomial(1, .5, size=(2000,)) + y = X[:, 0] * T + np.random.normal(size=(2000,)) return y, T, X, X[:, 0] def test_comparison(self): @@ -56,9 +56,9 @@ def clf(): linear_first_stages=False, cv=3)) ] - models = Parallel(n_jobs=-1, verbose=1)(delayed(_fit_model)(name, mdl, - Y_train, T_train, X_train) - for name, mdl in models) + models = Parallel(n_jobs=1, verbose=1)(delayed(_fit_model)(name, mdl, + Y_train, T_train, X_train) + for name, mdl in models) scorer = RScorer(model_y=reg(), model_t=clf(), discrete_treatment=True, cv=3, mc_iters=2, mc_agg='median') @@ -69,7 +69,7 @@ def clf(): assert LinearRegression().fit(np.array(rscore).reshape(-1, 1), np.array(rootpehe_score)).coef_ < 0.5 mdl, _ = scorer.best_model([mdl for _, mdl in models]) rootpehe_best = np.sqrt(np.mean((true_eff_val.flatten() - mdl.effect(X_val).flatten())**2)) - assert rootpehe_best < 1.2 * np.min(rootpehe_score) + assert rootpehe_best < 1.2 * np.min(rootpehe_score) + 0.05 mdl, _ = scorer.ensemble([mdl for _, mdl in models]) rootpehe_ensemble = np.sqrt(np.mean((true_eff_val.flatten() - mdl.effect(X_val).flatten())**2)) - assert rootpehe_ensemble < 1.2 * np.min(rootpehe_score) + assert rootpehe_ensemble < 1.2 * np.min(rootpehe_score) + 0.05 diff --git a/econml/tree/__init__.py b/econml/tree/__init__.py index f727dba42..ebccae49e 100644 --- a/econml/tree/__init__.py +++ b/econml/tree/__init__.py @@ -5,8 +5,10 @@ from ._splitter import Splitter, BestSplitter from ._tree import DepthFirstTreeBuilder from ._tree import Tree +from ._tree_classes import BaseTree -__all__ = ["Tree", +__all__ = ["BaseTree", + "Tree", "Splitter", "BestSplitter", "DepthFirstTreeBuilder", diff --git a/econml/tree/_tree_classes.py b/econml/tree/_tree_classes.py new file mode 100644 index 000000000..272421793 --- /dev/null +++ b/econml/tree/_tree_classes.py @@ -0,0 +1,349 @@ +import abc +import numbers +from math import ceil +import numpy as np +from sklearn.base import BaseEstimator +from sklearn.utils.validation import check_is_fitted +from ._tree import Tree, DepthFirstTreeBuilder +from ._splitter import Splitter, BestSplitter +from ._criterion import Criterion +from . import _tree +from sklearn.model_selection import train_test_split +from sklearn.utils import check_array, check_X_y +from sklearn.utils import check_random_state +from sklearn.utils.validation import _check_sample_weight + + +DTYPE = _tree.DTYPE +DOUBLE = _tree.DOUBLE + +SPLITTERS = {"best": BestSplitter, } + + +class BaseTree(BaseEstimator): + + def __init__(self, *, + criterion, + splitter="best", + max_depth=None, + min_samples_split=10, + min_samples_leaf=5, + min_weight_fraction_leaf=0., + min_var_leaf=None, + min_var_leaf_on_val=False, + max_features=None, + random_state=None, + min_impurity_decrease=0., + min_balancedness_tol=0.45, + honest=True): + self.criterion = criterion + self.splitter = splitter + self.max_depth = max_depth + self.min_samples_split = min_samples_split + self.min_samples_leaf = min_samples_leaf + self.min_weight_fraction_leaf = min_weight_fraction_leaf + self.min_var_leaf = min_var_leaf + self.min_var_leaf_on_val = min_var_leaf_on_val + self.max_features = max_features + self.random_state = random_state + self.min_impurity_decrease = min_impurity_decrease + self.min_balancedness_tol = min_balancedness_tol + self.honest = honest + + def _get_valid_criteria(self): + pass + + def _get_valid_min_var_leaf_criteria(self): + return () + + def _get_store_jac(self): + pass + + def get_depth(self): + """Return the depth of the decision tree. + The depth of a tree is the maximum distance between the root + and any leaf. + + Returns + ------- + self.tree_.max_depth : int + The maximum depth of the tree. + """ + check_is_fitted(self) + return self.tree_.max_depth + + def get_n_leaves(self): + """Return the number of leaves of the decision tree. + + Returns + ------- + self.tree_.n_leaves : int + Number of leaves. + """ + check_is_fitted(self) + return self.tree_.n_leaves + + def fit(self, X, y, n_y, n_outputs, n_relevant_outputs, sample_weight=None, check_input=True): + """ A generitc tree fit method used by many childen tree classes + Child class needs to have initialized the property `random_state_` before + calling this super `fit`. + """ + random_state = self.random_state_ + + # Determine output settings + n_samples, self.n_features_ = X.shape + self.n_outputs_ = n_outputs + self.n_relevant_outputs_ = n_relevant_outputs + self.n_y_ = n_y + self.n_samples_ = n_samples + self.honest_ = self.honest + + # Important: This must be the first invocation of the random state at fit time, so that + # train/test splits are re-generatable from an external object simply by knowing the + # random_state parameter of the tree. Can be useful in the future if one wants to create local + # linear predictions. Currently is also useful for testing. + inds = np.arange(n_samples, dtype=np.intp) + if self.honest: + random_state.shuffle(inds) + samples_train, samples_val = inds[:n_samples // 2], inds[n_samples // 2:] + else: + samples_train, samples_val = inds, inds + + if check_input: + if getattr(y, "dtype", None) != DOUBLE or not y.flags.contiguous: + y = np.ascontiguousarray(y, dtype=DOUBLE) + y = np.atleast_1d(y) + if y.ndim == 1: + # reshape is necessary to preserve the data contiguity against vs + # [:, np.newaxis] that does not. + y = np.reshape(y, (-1, 1)) + if len(y) != n_samples: + raise ValueError("Number of labels=%d does not match " + "number of samples=%d" % (len(y), n_samples)) + + if (sample_weight is not None): + sample_weight = _check_sample_weight(sample_weight, X, DOUBLE) + + # Check parameters + max_depth = (np.iinfo(np.int32).max if self.max_depth is None + else self.max_depth) + + if isinstance(self.min_samples_leaf, numbers.Integral): + if not 1 <= self.min_samples_leaf: + raise ValueError("min_samples_leaf must be at least 1 " + "or in (0, 0.5], got %s" + % self.min_samples_leaf) + min_samples_leaf = self.min_samples_leaf + else: # float + if not 0. < self.min_samples_leaf <= 0.5: + raise ValueError("min_samples_leaf must be at least 1 " + "or in (0, 0.5], got %s" + % self.min_samples_leaf) + min_samples_leaf = int(ceil(self.min_samples_leaf * n_samples)) + + if isinstance(self.min_samples_split, numbers.Integral): + if not 2 <= self.min_samples_split: + raise ValueError("min_samples_split must be an integer " + "greater than 1 or a float in (0.0, 1.0]; " + "got the integer %s" + % self.min_samples_split) + min_samples_split = self.min_samples_split + else: # float + if not 0. < self.min_samples_split <= 1.: + raise ValueError("min_samples_split must be an integer " + "greater than 1 or a float in (0.0, 1.0]; " + "got the float %s" + % self.min_samples_split) + min_samples_split = int(ceil(self.min_samples_split * n_samples)) + min_samples_split = max(2, min_samples_split) + + min_samples_split = max(min_samples_split, 2 * min_samples_leaf) + + if isinstance(self.max_features, str): + if self.max_features == "auto": + max_features = self.n_features_ + elif self.max_features == "sqrt": + max_features = max(1, int(np.sqrt(self.n_features_))) + elif self.max_features == "log2": + max_features = max(1, int(np.log2(self.n_features_))) + else: + raise ValueError("Invalid value for max_features. " + "Allowed string values are 'auto', " + "'sqrt' or 'log2'.") + elif self.max_features is None: + max_features = self.n_features_ + elif isinstance(self.max_features, numbers.Integral): + max_features = self.max_features + else: # float + if self.max_features > 0.0: + max_features = max(1, + int(self.max_features * self.n_features_)) + else: + max_features = 0 + + self.max_features_ = max_features + + if not 0 <= self.min_weight_fraction_leaf <= 0.5: + raise ValueError("min_weight_fraction_leaf must in [0, 0.5]") + if max_depth < 0: + raise ValueError("max_depth must be greater than or equal to zero. ") + if not (0 < max_features <= self.n_features_): + raise ValueError("max_features must be in (0, n_features]") + if not 0 <= self.min_balancedness_tol <= 0.5: + raise ValueError("min_balancedness_tol must be in [0, 0.5]") + + if self.min_var_leaf is None: + min_var_leaf = -1.0 + elif isinstance(self.min_var_leaf, numbers.Real) and (self.min_var_leaf >= 0.0): + min_var_leaf = self.min_var_leaf + else: + raise ValueError("min_var_leaf must be either None or a real in [0, infinity). " + "Got {}".format(self.min_var_leaf)) + if not isinstance(self.min_var_leaf_on_val, bool): + raise ValueError("min_var_leaf_on_val must be either True or False. " + "Got {}".format(self.min_var_leaf_on_val)) + + # Set min_weight_leaf from min_weight_fraction_leaf + if sample_weight is None: + min_weight_leaf = (self.min_weight_fraction_leaf * + n_samples) + else: + min_weight_leaf = (self.min_weight_fraction_leaf * + np.sum(sample_weight)) + + # Build tree + + # We calculate the maximum number of samples from each half-split that any node in the tree can + # hold. Used by criterion for memory space savings. + max_train = len(samples_train) if sample_weight is None else np.count_nonzero(sample_weight[samples_train]) + if self.honest: + max_val = len(samples_val) if sample_weight is None else np.count_nonzero(sample_weight[samples_val]) + # Initialize the criterion object and the criterion_val object if honest. + if callable(self.criterion): + criterion = self.criterion(self.n_outputs_, self.n_relevant_outputs_, self.n_features_, self.n_y_, + n_samples, max_train, + random_state.randint(np.iinfo(np.int32).max)) + if not isinstance(criterion, Criterion): + raise ValueError("Input criterion is not a valid criterion") + if self.honest: + criterion_val = self.criterion(self.n_outputs_, self.n_relevant_outputs_, self.n_features_, self.n_y_, + n_samples, max_val, + random_state.randint(np.iinfo(np.int32).max)) + else: + criterion_val = criterion + else: + valid_criteria = self._get_valid_criteria() + if not (self.criterion in valid_criteria): + raise ValueError("Input criterion is not a valid criterion") + criterion = valid_criteria[self.criterion]( + self.n_outputs_, self.n_relevant_outputs_, self.n_features_, self.n_y_, n_samples, max_train, + random_state.randint(np.iinfo(np.int32).max)) + if self.honest: + criterion_val = valid_criteria[self.criterion]( + self.n_outputs_, self.n_relevant_outputs_, self.n_features_, self.n_y_, n_samples, max_val, + random_state.randint(np.iinfo(np.int32).max)) + else: + criterion_val = criterion + + if (min_var_leaf >= 0.0 and (not isinstance(criterion, self._get_valid_min_var_leaf_criteria())) and + (not isinstance(criterion_val, self._get_valid_min_var_leaf_criteria()))): + raise ValueError("This criterion does not support min_var_leaf constraint!") + + splitter = self.splitter + if not isinstance(self.splitter, Splitter): + splitter = SPLITTERS[self.splitter](criterion, criterion_val, + self.max_features_, + min_samples_leaf, + min_weight_leaf, + self.min_balancedness_tol, + self.honest, + min_var_leaf, + self.min_var_leaf_on_val, + random_state.randint(np.iinfo(np.int32).max)) + + self.tree_ = Tree(self.n_features_, self.n_outputs_, self.n_relevant_outputs_, store_jac=self._get_store_jac()) + + builder = DepthFirstTreeBuilder(splitter, min_samples_split, + min_samples_leaf, + min_weight_leaf, + max_depth, + self.min_impurity_decrease) + builder.build(self.tree_, X, y, samples_train, samples_val, + sample_weight=sample_weight, + store_jac=self._get_store_jac()) + + return self + + def _validate_X_predict(self, X, check_input): + """Validate X whenever one tries to predict, apply, or any other of the prediction + related methods. """ + if check_input: + X = check_array(X, dtype=DTYPE, accept_sparse=False) + + n_features = X.shape[1] + if self.n_features_ != n_features: + raise ValueError("Number of features of the model must " + "match the input. Model n_features is %s and " + "input n_features is %s " + % (self.n_features_, n_features)) + + return X + + def get_train_test_split_inds(self,): + """ Regenerate the train_test_split of input sample indices that was used for the training + and the evaluation split of the honest tree construction structure. Uses the same random seed + that was used at ``fit`` time and re-generates the indices. + """ + check_is_fitted(self) + random_state = check_random_state(self.random_seed_) + inds = np.arange(self.n_samples_, dtype=np.intp) + if self.honest_: + random_state.shuffle(inds) + return inds[:self.n_samples_ // 2], inds[self.n_samples_ // 2:] + else: + return inds, inds + + def apply(self, X, check_input=True): + """Return the index of the leaf that each sample is predicted as. + + Parameters + ---------- + X : {array-like} of shape (n_samples, n_features) + The input samples. Internally, it will be converted to + ``dtype=np.float64`` + check_input : bool, default=True + Allow to bypass several input checking. + Don't use this parameter unless you know what you do. + + Returns + ------- + X_leaves : array-like of shape (n_samples,) + For each datapoint x in X, return the index of the leaf x + ends up in. Leaves are numbered within + ``[0; self.tree_.node_count)``, possibly with gaps in the + numbering. + """ + check_is_fitted(self) + X = self._validate_X_predict(X, check_input) + return self.tree_.apply(X) + + def decision_path(self, X, check_input=True): + """Return the decision path in the tree. + + Parameters + ---------- + X : {array-like} of shape (n_samples, n_features) + The input samples. Internally, it will be converted to + ``dtype=np.float64`` + check_input : bool, default=True + Allow to bypass several input checking. + Don't use this parameter unless you know what you do. + + Returns + ------- + indicator : sparse matrix of shape (n_samples, n_nodes) + Return a node indicator CSR matrix where non zero elements + indicates that the samples goes through the nodes. + """ + X = self._validate_X_predict(X, check_input) + return self.tree_.decision_path(X) diff --git a/notebooks/CustomerScenarios/Case Study - Customer Segmentation at An Online Media Company - EconML + DoWhy.ipynb b/notebooks/CustomerScenarios/Case Study - Customer Segmentation at An Online Media Company - EconML + DoWhy.ipynb index 3e976932e..a833eb08b 100644 --- a/notebooks/CustomerScenarios/Case Study - Customer Segmentation at An Online Media Company - EconML + DoWhy.ipynb +++ b/notebooks/CustomerScenarios/Case Study - Customer Segmentation at An Online Media Company - EconML + DoWhy.ipynb @@ -347,7 +347,7 @@ "INFO:dowhy.causal_identifier:Instrumental variables for treatment and outcome:[]\n", "INFO:dowhy.causal_identifier:Frontdoor variables for treatment and outcome:[]\n", "INFO:dowhy.causal_estimator:INFO: Using EconML Estimator\n", - "INFO:dowhy.causal_estimator:b: log_demand~log_price+has_membership+is_US+friends_count+age+income+days_visited+songs_purchased+account_age+avg_hours | income\n" + "INFO:dowhy.causal_estimator:b: log_demand~log_price+has_membership+age+songs_purchased+friends_count+is_US+income+avg_hours+account_age+days_visited | income\n" ] } ], @@ -362,11 +362,19 @@ "execution_count": 8, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:dowhy.causal_graph:Warning: Pygraphviz cannot be loaded. Check that graphviz and pygraphviz are installed.\n", + "INFO:dowhy.causal_graph:Using Matplotlib for plotting\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "\"dot\" with args ['-Tpng', 'C:\\\\Users\\\\mehei\\\\AppData\\\\Local\\\\Temp\\\\tmpz7c4pyy2'] returned code: 1\n", + "\"dot\" with args ['-Tpng', 'C:\\\\Users\\\\vasy\\\\AppData\\\\Local\\\\Temp\\\\tmpti_g4dz8'] returned code: 1\n", "\n", "stdout, stderr:\n", " b''\n", @@ -374,17 +382,9 @@ "\n" ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:dowhy.causal_graph:Warning: Pygraphviz cannot be loaded. Check that graphviz and pygraphviz are installed.\n", - "INFO:dowhy.causal_graph:Using Matplotlib for plotting\n" - ] - }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADnCAYAAAC9roUQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOydd5gV5fXHP2d36R1EEekQlSY2VMSGvaYpioqCCiJoNGrsJpr81KjRxEIssTcUiEaDYgcL2LBFEVE6KMUKSlt2l/P747yXOzu393t35/s88+zdmXfeeaedOe/3NFFVAgQIECBAflBW6AEECBAgQH1CIHQDBAgQII8IhG6AAAEC5BGB0A0QIECAPCIQugECBAiQRwRCN0CAAAHyiEDoBggQIEAeEQjdAAECBMgjAqEbIECAAHlEIHQDBAgQII8IhG6AAAEC5BGB0A0QIECAPCIQugECBAiQRwRCN0CAAAHyiEDoBighSH+Qf4LMAakEUfd3jlvfv9AjDBAgESTIpxug+CE9gEeAnYFGQHmURtXAJuAj4FTQhfkbX4AAySMQugGKHDIUeJDYwtaPGqASGAk6OXfjChAgPQRCN0ARQ4YCDwFN0th5AzAiELwBig2B0A1QpJAewKdA0ww6WQ/0A12UnTEFCJA5AkNagGLFIxilkAkauX4CBCgaBEI3QBFCdsKMZslwuLXQrRu88sqWf8uBXQKvhgDFhEDoBihGjCFzLTeEhq6/AAGKAoHQDZAURORSEVkgIj+LyBwR+Y1n22gR+dyzbVe3vrOIPCUi34rI9yIy3q0vE5ErRWSJiHwjIg+LSCu37YAOHTgTj5br1V6vvhqOPx5OPRVatIC+feH9923bKafA0qVwzDHQvDnceCMAFcCQGOc0WURWisgaEXlDRPp6trUTkSki8pOIzBKRa0Rkhmf7jiLysoj8ICJfiMjxWbjMAeoBAqEbIFksAPYFWgF/Bh4VkW1FZChwNXAq0BL4JfC9iJQDzwJLgG7AdsATrq+RbhkC9ACaA+NDB6qooCLeQP77Xxg2DFavhl/+Es45x9Y/8gh06QJTpsDatXDxxVt26RWjq+eBXwBbAx8Cj3m2/RNYB3QARrgFABFpBrwMTHD7ngjc4RXaAQLEQiB0AyQFVZ2sqstVdbOqTgTmAXsAo4AbVXWWGuar6hK3rSNwkaquU9WNqhrSFE8G/q6qC1V1LXAZMExE4grbEPbZB448EsrLTbv93/8S7tIgxjndr6o/q2ol9uEYICKt3AfjWOAqVV2vqnMw17UQjgYWq+oDqlqtqh8CTwLHJTP+APUbST3kAQKIyKnABZjWCqadbgV0xrRgPzoDS1S1Osq2jpgGHMIS7FncJpmxdOgQ/t20KWzcCNXVUBH7aa7yr3CC9VpgKNAe2Ow2bYX5BVcAyzy7eH93BfYUkdWedRUEnhIBkkCg6RYliivHgIh0Be4BzgHaqWprYDYgmDDqGWW3ZUCXGNrrckxwhdAFC+NdBaxbu3aLAKSmBr79NpWxRl09P8q6k4BfAQdjlEm3UBfAt248nTztO3t+LwNeV9XWnqW5qo5NfqTZQnE9KwESIxC6RQXpATITeAezuPfGrO+4v72BM227zHABBPlAM0AxYYSInAb0c9vuBf4gIruJoZcT0u8BK4DrRaSZiDQWkcFun8eB80Wku4g0B64DJjqt+Mv169n87LPUVFXBNddAZWXyA91mG1joybpQU4MuWMAckQhx3AILF/4eC8C4LrRBVWuAp4CrRaSpiOyIcdYhPAtsLyKniEgDtwwUkd7JjzRTFO2zEiABAqFbNJChWATWnpgQiOWjWuG272XtZWiuR+Y4zZuBtzFttD8w022bjE3TJwA/A08DbZ3gOgYzYi0FvgJOcF3ej03F3wAWARuB37n+1gwcyJ9HjaJsu+2gWTPo5NU3E+Cyy0xQt24NN90EmzdTfcIJ7A587jwwtnNNH8Zoja+BOZjw8uIcTANe6cb6OCakUdWfgUOBYZjWvhK4gey5uSVA8T4rARIjCAMuCgQ5BiIhMzGhknKARAg1NejmzbzbsCF7Y4JnJMbhvocl0XlGVTckNRqRG4AOqjoiYeOcInhWSh2B0C04ghwD0ZH5damspLpfP76ZP5/RqjoVQESaAL/GBPDuwGRMAL+rnpfBUQoN3RgGAlOBUar6dLrjyRzBs1IXENALhUeQYyAqdCEmGJPSRKNgw5gx3DF/Pm2BZ0WkSkTWYrz0lap6GDAAoxgeIpJ+aIHxuuuASRi98kzapxMFIvKZiByQwi7Bs1IHEGi6BYXshPGkmWguIawH9gL9NAt9FREyz6frghn+gnks/B6Y5NNqhQzph9wjeFbqCgJNt7AIcgwkhE7GDHfvYMIimt8vbv16166fl7d0wRkXYrTCn4CnPRotLqjjbVUdg0XOPQScBnwlIneJyF5RvB/yjeBZqSMIhG5hMeT66ynv2dPyCPTpA//5j22oqYELL4SttoLu3WH8ePNBrXYiZ80aOOMM2HZb2G47uPJKKqqro+cYKH3oQtB9MG30bszbYBPmxrbJ/X+3bdd9YvGVqvousCtW0udjlzNCfG02qOrjSdAPGUNEFovIwSJytYhMcjkofna0w+6edp2POIJT2renvF27cNjz5s3mqdG1K2y9teWjWLPGti1ebM/LAw9A587Qpg3cdRfMmgU77URFy5aMDeXC8BzndJdD40cRedG5/gXINlQ1WAq2UDlpEvr112hNDfrEE2jTpujy5eidd6K9e6PLlqE//IAedBAKaFWV7fqrX6FnnomuXYuuWoUOHIjecQdVhT+n0lgw7XkWMA3omaCtAIMwwf4D8ALmLtYkwzEsxoIzrsbc5o7EKJS/Au+4NuXA/849l+q1a9ENG9A337Qu7rsP7dkTXbAA/fln9De/QYcPt22LFtnzMmaM7fPii2ijRvbcrFqFLltGJfANsL87zq+xIJLemKvZlcBbhb5PdXEp+ADq9xK5asAA9Omn0SFD0LvuCq9/+eWw0F25Em3YEF2/Prx9wgT0gAPQwp9T6SxOuFwIfIeFOJcnsU8TLMHNi1hgxV2YBi5pHN8rdF/xrO8DbHC/BwHfhj623uXAA9F//jP8/9y5aEWFPSMhofvVV+Htbdvah939vxnLF/F7d5zngTM8YyjD6Jquhb5PdW0J6IXCYtPDD8POO5szf+vWMHs2fPcdLF9u08IQvL+XLIGqKqMWQvuNGQOrVoGI/EZEfuFyCwSIA7VkNTdjQvOXwFsi0i/BPrmiH1Z6fq8HGrsQ6s7AkooKNvl3WL7cqIUQunY1+mnVqvC6bTzZLJo0qfV/FeYZ0jy0O3CriKx2OSV+wDT8rNEpAQyB0C0g5s1j6ejRxtd+/72lKuzXD1RNoH71VbjtMk+6lc6doVEjE86rV9vy008wbRrfAadjaQd/EpH3ReQBEblARA51qRgLbRAqOqjqfOBA4D5guohcJSINE+yGqn6lqn8FdsQMb92BT0XkBREZ5nyCM8UyoEtVVWRSoY4d7QMcwtKllvRnm6TSBkXko1gGjNHa+SSaqOpb6Q89QDQEQreA+OorZolA+/b2/wMPmKYLlqj71lvh669NqN5wQ3i/bbeFQw81Q9tPP5lB5Ysv4L77+Bb4nap2A7bFQmvfwpK5XIY51n8nIq+JyHgRGSMig0MJxOsz1FJW/gvYBQua+EBE9khyX9XceT+8B6wYNozKtWup3rgRZs60DSeeCP/4ByxaZPmDL78cTjghbra1EKqB6b51dwGXhXICuxSXQdhwDhAI3QJiyBCu//3vqRo0yLSTTz+FwS4lzOjRJlh32gl22cXyx1ZUWA5ZgIcfhk2bzOOhTRs4/nj0oYf4AXhfRKZhhpFPVPUeVT1XVYdgKQz7Atdg6Rj3AP4BfC0iS0XkORG5QUSGi8gAEclTLoHigap+hVEN1wH/FZGbRCRp39hs0w/qcli8/jo/du1KRadOMHGibTv9dMsnvN9+5uHSuDHcfntS3W7CjILe4/wHyx/xhIj8hGWROyKVsQZIDkFwRMGRXI6B55+Hs86qPZ30oAZ4B3QfJyiPwRz9BwP/wRz939QYN1tEyrCpcT/Mqt/f/e6BJaSZjWnJob+LnDCo0xCR9sAt2P0Zrap+7TDZfvzBF7Owe/K0phR8kZ18FNXVzGrUSPdMt48AmSEQugVH9Hj6DRtg+nTTdletgmOPhb32gltuidpJ1Hh6EdkWq9IwErO6PwQ8rKqLkxqZCfAdCAvh0N/2mG+sVxDPBlbGEuylDBE5BrgDy79wsaquyaAvb+6HgVjuhwfw5X6IsXfGuRc2baK6Tx9WL1jABcCjdfF+FTsCoVsUiMwctX497L8/zJ1rVuejjjKOt2XLiJ0TZo5ymtZu2Is+DPgE07SeVNV1KY9WpCUmfL2COJQs268Vf5aJkCoWON77BuAoYJyqTslCn52AU7D7otg9eURVv46zV9pZxlTZIMIIERZiRsMVmPFsaap9BcgAhfZZC5bQwlBV1qlSneQu1a790FSOg4WSHgtMAX7EctvuB5RlMn7MvagDcAhwvut3FpYwZgnwHHA9pnkPABoV/pqndZ4HYJb/x4H2WerTH3zxIuYLHCP4IrVnZfNmqjdupOrMM/k0dN2xunFXYD7KZ2d6/4Ml+SXQdIsK0gNLrr0LFh8fzQ5djRlCPgJOySRFn4h0AIaTJv2Q5DHKMG7YrxV3x/hiP0WxUFU3R++tOOAMa3/GtNQLgMc1Sy+Sh344jdqpJ9+pfYzUnpXvv2fEVlvxNyzybXjoGrtqF/dhdoFRqvpFNs4jQGwEQrcoIf2xhCRDsMoLDTBn9vmYq8/d2cwQlW36IcljNiY6X9wO44v9NMWqbAm2bEFEBmICaykwVlWXJdgl1f699AOE6QePB3fyz4oT6K8AM1V1S4F6F0gzDrgKuAm4SaMXFA2QBQRCN0AtOOPZ0diLvg9h74cZ+dBAHXfal9peFP0xztOvFc9W1Z9yPaZ4cEEUl2I+0VcC92T7OmXP+wFEpB1WaukOVb3Nt60b8C/sw3eGqn6c4dADREEgdAPERD7ohyTHEeKL/VpxHywpuV8r/kJVUyhnmZUx9sW03o2Ye9m8HB0nmvfDg0TQD3H76AbMwPIu/Nu3TYARwI1YBej/U9WN2Rl9AAiEboAkUAj6IclxlWPcsF8r7gYsJLp/cc60dTeekMZ7A/CPXE7Tk6MfYu67M/AScKyqvhll+7bAeGzWcYaqzszSsOs9AqEbICUUmn5IBo4v3pFI411bovsXZ5UvFpEe2DS9FSawPslW3zGOlxb9ICKHAI8CQ9QqPkdrcxxwG/Bv4HJVXZvVwddDBEI3QNpw9MPJmKW9YPRDshCR1oT5Ym/0XQ2RWvFstVLr6R5LsORD1wN3Atfmg/JIlX4QkVOwsPC9NYZ/sIi0Bf6Oucudqaov5WLs9QWB0A2QMZyA2RV70U+kSOiHZODGvi2RIdC9Mb7YrxXPVdWINItx+u+IRbP9AtN638nqCcQ/dlL0g4hcit23/TROIIuIHIb5Ek8HLlTVH3Iw7DqPQOgGyCpKgX5IBo6f7UGk8a4bxhd/Sm2BvDjW+TnBPhS4FXgCq0act49RIvrBbb8d+9AcEe+jIiItsGRAx2IZ7Z7M7ejrHgKhGyBnKDX6IRk4vrg3kXxxG+AzfDSFqq7y7NsOy+q2DzZNfyW/o49LP7znfm8ATkn0gRSRfYB7sXM+R1VX5G7UdQuB0A2Qc0ShHz4lTD/UCcOM44uj5aOoJpIv7ogJ31ewafrqAo3ZTz88iqW1nO4Nnoizf2Pgj8Bo4GLgoWILYClGBEI3QF7hox/2xeiHBygx+iEZePhiv0tbb6wopAJbYZ4OD2L+xUnzxVkeZ4h+OB6Lavs3FmWXMPjCuZ/dj+VxOLOUZzL5QCB0AxQMdZF+SAaOL+6JCeGjMZ5VMWG3gEjjXUy+OAdjawKMAv6GhRNPIIngCxFpgBX5/AOWl+IOrQc5l9NBIHQDFBz1gX6IByforsI+PrdjuRy8NEVrwv7FXr74mxyOaWeM/ngScxWDJIIvRGQHjOstwxLofO7ZtqOqzs3VmEsFdUzoSn/gLCz5R08s+9ImTHuYDtyVzUQxAbKP+kQ/+CEiuxElz62ItCG6f3EVkVrxZ5n4F/vGsyV4Agv0GEkSwRcus9xYTOP9BxZSfBiWTnSIqr4W5Wj15t2tI0JXegCPADtj+WKjlTPxpkQ8FXRh/sYXIB3UR/rBTdMvwlJGXgXcGe1j42YHHYnuX7ySSOPdl+nwxf7giVSCL0SkK+bX2xHoggnuRcD24fDo+vfu1gGhK0Oxmx7rhvlRA1QCI+NVWwhQPKiP9EO6eW49fLHfv7grlu7RL4yXJOEedglwEr7giWSCL9y9W4ZVSQZLan+5ZTirn+9uiQvd9EuXkESZmwDFhyjBF08TLrxZp+iHbOa5dRrqjkRSFK0wX1t/CPQ3nn3jBk/EC77AstT9yzecDfPn87uePbmdevjulrDQjV6kb+RI6NQJrrkmqU6iFnQMUBrw0Q9NCdMPdep+5jLPreOLQ/7FNwCLgc7YdD4khD/FDHmXAmuJEzwRhX6oxNJyhrCxe3caX3op+vDDyIwZaQ89L++uiFwN9FLV4dnqsyxbHRUAj2DTkkzQyPUToAShqitV9WZMYxuK+bzOEpHpIjJCRJoXdoTZgeOwD8O0zZdE5FoXmJCNvn9U1TdV9U6sPtsFWDa2XTG3sa+wGnr/xOrfHQt84cYwTET6OR461N8GVX1cVQ8DDqW2wK0Bvnr7bb6oqCBTba9k390SFbqyE0a8J8MDxUM5sIuznKY2ApFoNakCFABq+EBVf4dxh+OB44BlIvKAiOzvLOolC3eOD2JFPXcEPhaRwTk81teq+oKq3qSqI1R1V6AFsD9GCeyKXeMngZ9E5BMRmSAil4nIMU47P9rfd//+9GrZkl+UlWUse9J+dwuNvDyIInKpiCwQkZ9FZI6I/EZEGonIahHp52nXXkQ2iMjW7v+LRWSFiCwXkVEioiLSC6sJFVPL/fFHK1neogXsuScsWBDe9tZbMHAgtGplf2fOpJHrDxFZLCIHe8ZztYg86n53c8c/Q0SWAtNEpLGIPCoi37tzmSUi22T36gVIBapaqapPquoxGAc5G9PS5ovIVSLSvbAjzAyqukJVj8Uq+U4WkduyrdG7d/MW994td78bqWqNqr6LaZiHAgdi2nBjLHH7C5iWfDZWmeJK79CBsnnz2LzffpR530mAuXPhkEOgbVvYYQeYNCm8beRIGDcOjjgCmjeHwYNh5Uo47zwaN2vGLBGZKyK7eMYfIW8820aKyAwRuUlEfhSRRSJyhGd7dxF53e37MjZ7yi40DyWHsalfR0zIn4BZMLfFQgev9bQ7G3jB/T4cc33pi/F1j2A3rpcqc2IdbsQItE0b9N130aoq9KST0BNOsG3ff4+2bo0+/LBtmzDB/l+5krnumIuBgz3juRp41P3u5o7/MNAM+9qPwXwPm2Jf3t2Alvm4psGS0vMXqnxxOxaqOh0rSdO80GPL8LzaYj7Mi4FDs9DfYuBg4C/AO8DWQHvgLaxsj/e9/C0Wyvxi+L2M6G+l27Zlef999NNP0Y4d0cGDrenatWinTuj999t7+cEHaLt26OzZtn3ECPv//ffRDRvQIUPQbt3Qhx5Cq6r4DHNpm+45blR547aNxPybR7t3diywnLB9620sd3AjjFb5OSQDsrUUxJAmIh9jFtl1wL9UtYdbPxO4W1UfFpH7sYz+l7ltvYB5wC9U+Qxzno7AyJFQUQH33mv/T50KF1xgX9JHHoHbb4f33gu3HzQIRo2iZtQohmMv5d2YdgQ2fdoG05TaYxn0z8MeNrBInSGEK8IGKH5UYFPj/bFqxO8DrwNzIWOesVDYCRMin2HKSbppI0PP/2hMmIcMdqH+f4cpGmuwFJX9gHMx2uH3wCpffw9Se0ZatWkT5Q0aUHb55fDGGzBjBkycCOPHw5ueokFjxkDHjnDVVfZON2gA99zjBnk73HEHfG6xbptE2B3zXmkd7aRC8kZVnxGRkVhqzV5uW1PCSmBDLG1nK3WpN0VkArBZs2hIywsvKSKnYgR9N7eqOaa2TwGaiMie2FdxZywCCexL9b6nG29566gCN4QOHuq+aVNY6zw5ly+Hrl1rt+3aFVasoByzuDYFBmOlrMG4s+ZuWzO3bjDhl1MwK+8VbkyLsQTepfry1ifMw56prtiHtAJz3F9M+kKrkHgdE47jgQ8wA1iqCD3/7Vxf3dz6FphW/Wvsnfja/QbzatgTOAabRXjRwPd/WYMGRml638MlS+Ddd6G1R2RWV8Mpp4T/38ZD2jVpUuv/BpgL2RaKJY68CWFl6IeqrjePty1tftTauY6XYN4cWUPOha6LSrkHOAh4W1Vr3JdHVHWziEzCHN5XAc9qOIRxBdDJ05X3xDeRQPBGQ8eOdoO9WLoUDj6YzcAkbAp6q6o+7cZ+FzYFHe4xDJysUXwl3fapwEuqel+qYwtQONSl4AtnXLsPEyznqOrKBLt4910MXItpu+NVdapbfyjQV1WHicgDwApVvdxtC81At8OKXHqDJw6itrCTykpo1MjeuxA6d4b994eXX07njKnynUNMeZNEXyuANiLSzCN4u5BlJSofhrRm2KC/BRCR07BpSQgTMN7lZPc7hEnAaSLS200B/uTZ5qPhk8ORR8KXX8KECfYlnTgR5syBvfbiR8zXc1vg3yLygYhMwRy7txUruRIBERkiIv3FnNh/wh6AILNSiUENdcL7Qa1q787AF8AnznCUjMDx4nHgSmfY3gp79x5122K9l+8D/xWRA0VknIjcSXh2GILMm0flnDnw0EPhlUcfbe/lI49AVZUts2ZtoQ8SYb7v/0TyJiZUdYk7jz+LSEOxRO3HJDWKFJDzB0mtyujNGEG9CvOpnOnZ/i42nesIPO9Z/zzGoU7HLuzbblOlW5dyZE67dvDss3Dzzfb7xhthyhRq+vXjCTVr904Yj9WbcNhkX4wy+Mh1c6uInOU0ih5Y3tGfgM+xKd6jBChZaB3wflDVjap6BeZhcC7wopuJJYtrMOHzCab1f+jWhd7LO4A3MZohROYdAuwNTAR2wd6Haf6OBw6k0YgRcNpp4XUtWsBLL8ETT9hstEMHuOQSqExcxrMakwVbkEjeJIGTMLrkB8zu9HAK+yaFkolIE4tFnw00UqUPdlGbxt8rKawH9oqXwchpCtsQWRWgD3ZzvJE7s4HPNQ+VXwPkB6VMP0hkntt/apLh0mK+6NHyOHTBFJJPMcF2LrA9Nj1/CXhLVS8WkYFYGaAtGDCAyg8+QMvLyUZwR8J3txhR1ELX+dc9h00ZHsKsiI7Al5nYFymTAIka4B3QfdIcXxnQnciHsidmlPGn3VuoQWLnkoZETz35IEWe+0Hi57kVjFbxKxU7Ytyw/znuDTxDlPdSrA7cW5iW3A2jOkK2o83ADzNnstUee6AVFUnxrLGQ0btbSBS70H0BGIRd4NeBcaq6QkQ+E6Fb06a1Nd2774aTT07pEDmJ33Yv5g5ElmnZCpt2+SvJrtRivhEBokJKLPeDUxIuwIIWXsc0077Y8+nNtRD6O0ej5OaN9l5iHOoCTHiHFKEqzIBVy2Dfowc1X35JVYbabsnmTSlqoZsYpZVlTERaEX7IvcJYiNQmZnstwQGKF8VIP4glnolWtbgV5m3QHnvu/g/4j6ZZhUJE+mLnPRxzt3sQ43W7YVTDiZitJuQ+VgVMuewyGlx5Jcc0TY8gDLKMFRalnZPTwxf7teI+mN+jX/uYG/DFxYt80w8SPX9uf8K8a9T8ue65G46ljLwf+IsmUYTSHbMtJkxHYgbwh7FKwHN97Q7BcjMoNhOowN6/aqDB0KHIE09QWVZGA0rw3U0XdUDogkvz+DBmNW1IdP9jb/b5U4p9WuJepu5Eaio9sKgZv/FuYTFzivUR2aQfnJDsSKT9oDdmzPJTVklVihDLFXI7lkhnlKq+GaNdBZbpbCTmFTEV+5i8Es1OISLbYxzythj3+yUWBejFjxs3svvy5UzbZhu6Nm5MTVlZpPCtqWFzZSVla9fy+dZbc1Sxv7uJUEeEbgjSHwtTHIJFlTXApjPzMdeSu0vN0umHWEq/EF/sffm2Ily80KvdBHxxgZEq/SAirYn82PbDFIec1ERzRuvxWOLxS0N9xqIPVHV1jH4qMN74Yoy6GI95TpyMGfF+QTiwaSLmbjmif3/KH3+cqX370rO6mh2c8K0qK2Pe9OmsOfdcBs2eTSVwsarelun5FhJ1TOjWX3j4Yj9NoURqxbNV9acCDbVeIwr98Dp2TxpQu/rvZ/iogXR51xTG1gajGw4F/gvsQRz6IMr+AzCq4gfgzJBG7z46t2PKUCfC/O4CbObWFDOMjcbomBUY9/yBqu4uIn/DBDeu3QPAuaU6swtywtYROKPbW24BtjzsHQi/zIOwB7uPiHxHpNYU8MU5gId39Wqtv8DsEHtg0+7NWGrEkylA5WOnoe4NtATaYFnY3gGOVNVvE+zbCPOIGANcAjzonV2pqorIM8Ao4FWMmrgNs1uEArTKsJwPYwgL5R1F5ABM8IfQFMsM9hNweZqnW1AEmm49hIcv9mvF3THtw298WVSqWkU+4T5y2xJp1NoRy0znn3F8oaqbCun9EMf7oBqLQjsBC374dzSaSkQGYbke5gJnq+qKKG0GAC9jH5SrMMXg31hmsuOxD04DLO/D2ZimH8IHwI9YyslqzJh2J3CzegpglhICoRtgCxxfvCORfGJbjC/2C41V9ZUv9vCu/mtVQ6RRa06ydE4+vB+S9T5wbUNC9Qucn7xb3xwTysdjQvnJGEK5K5bQ/EJVneSOPRMTnI9j7mt/w3x9Z2G5DtZimc1+xjTvGZj2PRnTwHuVshIQCN0ACeEETIgv9mpwNURqxZ/VJb7Y8yHyG7XaEr2Krj+nbCbHDnk/jCQc/ZWu90NK3ge+fRth6UvPwopTLsMKZb4BXKCq38fYry0mMP+lqrd41nfFBO90oFpVT3PafjMsgq2NO9dfYlrwe6pa7drMwvLhvpDqNSgWBEI3QFrwTKW9QjjkwonjReYAACAASURBVPQtkVrx3GRcmAoFR7n0IFK4diM65bI4X9qWu9a7EKYfZpMk/ZCq90GCvkIl75sBY9VqtsVq2xijFN5V1T9E2b4rJkDPUtV7fNu2AT5R1YjSVyJyBvArVf1lquMvFgRCN0BWkUB4LSTSeJdXvjjKxyL0N/SxiObvWjTGRad1HkWYfngaH/2QCn2QwnFDLmX/wfIx/B6jF273a8ruGZiIuWueHO3+isiRwD8w/naIyw4W2hZP6DbFqrTs5lIxlhwCoRsgL4gxTe+PTSUj3KOAbzLli50bnZd3DR17M5HCv+RoESecQsEXzTADVRtgH1KgDxIcowPm7tUfC56Y4dZvjyULbwicERKa7qN2q2t/eKwPlli+6v9gAUvXAnur6tee84oqdN32W4B1Ln1lySEQugEKiiQMUl6aImoggNP+ouUZCPGuWRfoxQIPfTASs+43x3JC30sG3g9OeJ6CGbnuw8KEN/ralAFnYkEQtwE3YKWPTgX2jRNA0Q3L19tFrVzOJdjHY19VXZOE0N0B82/uUsyUVSwEQjdA0cHneuWnAL7HprfrMT/X9tgUuuDURb7gow+2JUwffJEM/ZBE/12xkj3bYFrshwnadwbuwu5TQ2BgPHcuEbkOaKKq57v/BRPafYEjMMohptB1+7wC3KuqTyRzTsWEkihBEqBeIlS2e7Pvr7jF61Qfah/tb52AiFSIyFEiMhnL1bwP5lHQVVUvV9UvYEvli6ecoWlH7AM0niQqX4hImYicTbhC8h6JBK475jKsbHlrzN/2XMe9RjtGI+AMTEiH9leMI16NRZslk2f3TszNrOQQaLoBCgoRaUn0PAMQadSKyrs6vrh3lD5CfHHO3LpyjWx4HyTj/eCm7KGCqqNSMbp5gh+GYvmibwV2d/287mt7EnCaqh4SpZ8mrp+PgaEJNN0G2PU4TFVnJzvWYkAgdAPkBU7D8QZehARjO3IUeOFyCUTzL66KcrysJI7JBuLRB1no208/PIMZs34LXA3ckQol4w9+8Kz/JVZLbQpwSehjKSJvAv9Q1adi9NcWCz/uoKotExz7KmBrVT072fEWAwKhGyCrcMaVHkRqr92pnZKyICHGTutLlCLRO8Yv8mGsiRG88ADwaibeBwmOeRAWhNAKC7W9jxSCL2IFP3i2twZuBA7H8iUsw86rm6rGLCwrIrthtdVOUNV/x2m3HXafuhbLBzMZBEI3QFpwwiuUfN0rvPpgxi6/58EXxeTv6ofUTgbuPadQVWg/1bEkGx8LEemHhbZmHLyQwjEbY6XTRwEXEc5FPZIkgy8SBT/42h6IuZfVYFUqLknQfhts9lMDHKeqb8Rp+2/MLe6uWG2KDYHQDZAQHt41Vpkh/zS9zpQZkvhlb9JKv5hL+iCJYw/GNNpPgd+p6krf9mSCLxIGP0Q5bgfMAPgzlqthYiz6KOQyhrmRPQYcqKqfxWh7EBZkMaBU3AADoRtgC6R2QU2vkGlPkCC9Fhxf7BfE/bFyMhH5KICNhOmDQwgHL+SMPvCNtwVwHXAscE4sTtW3jz/44iHsA3E+CYIfovQ1DsunexMm9BdgCXS+jnHcT1R1GxEZji94wtdWMOPdlsCNYkcgdOshJHbp+B6YNhKNdw1KxyeAEwD+UuYDsdy5guWAfQdLa/geRrlU5WFch2F+t9Mwg9ePKe7v9X443a2+CHgkmeALt/8nwHmqOk1EGmK5cM92f+/1frz9wRH+4Iko/Z+HubelVgu8QAiEbh2Gh3f1a2Qh3tUvXL/wRx0FSB1R6INHML/X5tS+F6Hikf4ZRLb44rbY1Hs/rJLDyxn2dxLwVyznwjEkGXwhIvtinG5vn3Dtj2m9a4HRqrrArfcL3VrBE37t2hnsFgE7JEPvFBqB0K0jcNPHaP6uZQTl3XMOn/dBUvSBhy/2G+9aEvYv9vLFcSs4+Po+DhNUk4Er0g0H9vR3EDABD78ai37wez+IyOPA2xqltpnjh38PXIbRH7di9f5qRaS5dpMxmma4X8CLyL3AfFW9PpPzzAcCoVticFOzaInG22Pclt/KXm9513zA532wCBO0kzLxPnAaajTDZSXRE/Ws9ey7LRaB1gcL4X2LDOENfvAHO7jtMYMvMGE8F+ge75qISC9MG26KFbWc5A+O8ARPvK2qF/m27eaO17PYqbBA6BYpHO/ajUhDTQ/Mtcj/8i0s9oetrqAQ3gcevtivFe+AFXKcjfHG+2MVGf6QqXbrjhs1+CFOe7/3w0JgOZYDNy5l4p75MzAKozHQ1u8jLeHKE3dhH5fxwFeqeq2IvAv8n6o+m9JJ5hmB0C0CuGmanxboi1VV9fOucwPeNf9Ihz7I47j2B24Gtsa8TLoAnbFSOP7IuyXJznwSBT8ksf+2GE3yPVBOkpUvnGb9rhv/Gar6nm97qPLEdxg9s1xVu4vICOB4VT0q1bHmE4HQzSMc7+oPS+2HVWWOlsYwZw7yAZJDLuiDbMHxnGdjgQ43An8PRXq5hDPR8lG0IHo+im99fScd/BBnfMdgSXkGkULwhcdP9zzgFuBR4E+qut5t74uViO+OafeVWBDLT1iC8z1VdWE6Y84HikDoSn+s9tIQLCKoIRYLvgCroXQX6KeFG1/qcLxrNH/XrTHe1a+9rgh41+KBiLQDhlGA4IVkISK9Mct/Neaj+mWS+7Uj/OEPPZf9MAOV97k8CdNQh6XrSSEizwOPq+rDnnXJBF94/XS3woxrewKjgTextJ4NwkdiHTBGVR8TkZsOP5w2zz/PRopUphRQ6EoPzJVmZywvanmURtXYxfoIOBWK6+vl4V39Bo+ewBIiedcFAe9anChW+sAPl13rYszi/yfg7kzdyxxf3InwM3w6xh9XYHys/zn+MpF/sYj0xHySO8eiw+IEX6wn0nvhaCyd40o3zgZYmLC4cT6rynnr1jFZhF2bNKFGpDhlSoGErgzFHuhYwtaPGmwKMRJ0cu7GFRvuAYnm77qaSN7s84B3LQ0UM33gh7PQ3w98jRV0XJqDY1yEVYzYD/Of7UWkMbcT8CWRM7aloRmbiNyIyZeL/MeIcky/98MX7jjb+TwzzsA8HEL5dtdj9+uM44+nfOJENlECMqUAQleGYl+0JmnsvAEYkcuL5OFd/QK2AdHzu6YU3ROg8CgF+sAL5yp1FaYRXgg8lgs6yhP8MFjjV35oiikc/nekOU7pAI7HaMMXVfW7FMbQCKM27sTe9y30A6bgtPA03wxMXLeOKY0a8UB5OY2SPY4HOZcpfuRZ6EoPTFhFzSofC0uXQp8+sGYNlJezHugHkRZQETkZGKGqhyYcifGu2xPpgrMNYd61D2ZBvQizkAa8a4miVOgDP0RkP6ze2YfAubmKuIoW/JBGH+0I0xNDsFSO/TCN1K8Vz8EMeqNU9RVfPyFD2k6YAD4NS0i/HWEtV4HN3btTPm8eG8vLaZzOmB3WA/1E+BTYKddGuHwL3ZkYIZ6M+h8LNcA7oPskPJqIYoK1mkijVi/M0unXXrfwriLyIOYDeGUG4w1QQJQSfeCFy+x2PfBL4GxVfSaHx4ob/JBGf28Df1XV/zrqoDORWvEOGBf7HpYTIvT+zcMKivrDgD/E7D8hbAJu+OYbjttqK7aPwd8mi6RlSjZQkY+DGGQn7KJlcnFw++9iXg+1LZAisjWRJV8+wqYlIcH6PFbh9HNV3ZDhWAIUIWLQBwcUK33gh4gciU2vXwL65fID4Xxen8Myj2VD4O6CaaTPwZb6Z0vdMtXTrgIzNk/DtNZhWE6HTlhARUsRuZTwe9vHc5gaoLx/f/7Yti2VGQpcqqspr6iILlNyAlWNuWAq/bPAt1hm+WeBTm7bUOADX/sLgafd7yOxKcTPwNdjxzJTlepYh9txR3TKlPD/VVVou3boBx+gixZZkcKqKtt2331Ub7UVazE3lzW48i6Y68garEzIPOxmrsMMAie4cR2N1WBaDbyFTSdC498F+6L+jOULfQK4Jt41CpbiWDAF4igsPn81NlU+FCgv9NhSOIetMI+eBcBBeTheW/eOnpfFPv+F5XpIpu1i4GDM+HUL5imxAnjKvcc3Yx+enwkXKg0t38+axcubN0eXKSNGoGPGoAcfjDZvju63H7p4cXg7oOPHo716od26oapUuX57ubE1ccdf4sYyA6tgDLCXkx2rgf9hH/Tkr1GCi9IOy7/ZFCOwJ3uEaiMsYqq3p/1HwLHu9wosFRtAm5kzWRhvLH/+M3rSSeH/n30W3WEH++0VumvXoi1aoC+8wEbMIPcX4EzsCzkSmOEZz5aL6P7fFfiGMMUxwt34Rpgv3xIsV2gD4DgsSXMgdIt4wWY0f3PP21vuWWhd6HGleA6CGZ5WYFV1m+XhmI0x49RNWeyzNaacdUiyfUjo/gVzL9sayyEyC1jr2hyORZ75ha7Om0dlrO5HjDBh+/rr6MaN6LnnooMHh7eDCeTvv0fXrw+v8wjdfwKvYVp7ObC3kxPbYf7LR2LJpA5x/7dP9jrFpRdU9XssiQQAInIt5lyMqlaKyESMK7vCRYl0w7RhnMDqIyL/U9UfQbaLd6yTToJddoH166FpU5gwwdZFQ1kZrFlDA0xjrcIE5q8xYbqtiJzjaT5cRELW0xOAD7AcpwPduibADdgFb+X6G+O2LQN29/UXoPBoCuyGaRwtMV7wHuyD2hC754UbXWpohQncrbEqCYuB03I8fsGMXTXAkiw+3/tj1MBxSY6/BfArjFqYjF0HMEphNzeuk7GPUTvfvmu6d6dZvM6POgr2289+X3sttGoFy5ZB58627rLLoG3byP2c//3pwF4aTpz+lts2HJiqqiGq5GUReR8Twg8lc9Jxha5zDfkH9rVp41a3EJFyNWPTQ8DjInIl5ts3ScO5Lo8FrgSuF5FP3nqLhoMGxT5Wr17QuzdMmQLHHAP//S989FFku2bNYOJEuOkmyjBDwwpM9V+N8XdNsCxcIfTEpm1ghP52wIGe7WVYuCSY355332rsZnvXBSgMBMsp0Bu7j0uwj+5X2AezrVtKCb2xENnZwH8w7TMfz9q+2HP9X8yglS0chGmHyZ5DA+xetsG05NB+LbH7vSNWRDSaz3uz8vL48iskXAGaNzcBu3x5eL13uw9bYfdiQZRtXYGhLsTZex7T442lFhKo/3/ELmIH9//O2ANe4WnzBeZIvRTYJ0ofDYDzO3VKrHn//e/or36FTpiA7rFHeL2f03VLJWHe5U13rJHEpxfuJgbfhH2ll+M8Oty6mQT0QkEX6gB9EOWcegCvYtPo/nk+9kWYO1ZWryHmIjbb+/4ksc9ijF5YABzpWX88UON+P4Apd356oaayks2xuh8xAj3hhPD/P/+MlpWhS5fa/xg9UWufkLzAFLENWN01/5gvA+7J5FqVJZDJLdzBV7uMQ1dFafMwll6tWl2NIhFpKCIni0grtXDBn9SI6rgYNgxeegnuvDM2tbBqlWnBP/3EAkwzXYtNk6I2xx7wEO4BzhKRPcXQTESOcgERb2Oa7bkiUiEivwX2SDTmANmHiLQTkbNFZBbwAkb5HKCqe6vqv7TI3b1iQUTKReR8jA6ZCgxSzV8OAOfHfg4m4LJ9DccCd6qTTCniceBKEWnvci1cBGwSkdHY7OXEKPtsWreOFfE6nToVZsyATZvgj3+EPfeMq91ugVpY9f3A30Wko7tvg1zgxqPAMSJymFvfWEQOEJFOSZ9tgi9RR0zTXYuF/Y0hUtPtgkWG/NmzriH2svyIZf6Z9fjjPKVKVaIPwYEHouXl6IoV4XVeTXf5cnTffdncuDGVGKXwGtDHHXcktTXdszANaTWW8g2MKpnl1q3AuKQWbtvumDEw5L0wkUDTzctCHfA+SHB+fTFj0Wt4Zl95PP5BmBLSNwd9d3TvessU91uMJbEZAbyP0QjV2Ee2CvOpvtAJQL+mWz1+PFpTk9h7oVkzdN990YULw9uJ1HSjeS/cgoVcrwHeIOy9sCdWfukHzLPrOaBLsuedcXCEC1H8BthVVefFabkTpk2mFI0WA+uBvUot+1iASJRq8EKycJGPlwK/w9Ic3qtZqH+W4hhCwQ/HqeobOej/T0BHVT0rxvZoCfn7UTsxlDdAaS3wsdZOePMpYd97gKoDDuDladMYIhKZUmDkSOjUCa65JunTyJtMyUZwxFhgVnyBC6CfgHxMdiLSPgoEbumi1IMXkoWIDMTSLy4BdtE4+QxyOIZQ8MPZORK4FRjPfpT735sYypuQ/0fCgvU5zGMoamIo10eo70Oxj1U3TBMNuUXUvPYah731FuWDBlFTVlY6MiUjoSsii7GL8Otk2nfvzlvffsve/vX77gvPP5/0YSsxT4kAJYQYuQ+uoMhzH6QD5/XzZ+w5PR94QjOdUqY3jra4CEzV7CZ08SSGOhUzPP3DzVq8CflnYYaw2SnOXLbHkucsxT5YLTAK0+uH1hhg333Z3LRpbYF7990pn05+ZUr++S2GqrI+zd3X2/75HnOwpLtQB70PEpzvAVhZ9cdIwWE+B+PISvADZp/pjxmzrsPczBZh0/EPMI+fx7AP6nak4L3gO05bYBxmZFyBRZLu6GtzBSZ8Q7zueuAPw4fz7bp1aZ9i3mVKkE83QNZRaqkTswERaYWVzDkSGKeqUwo4lnLMCFwFnKxJcMiOd+1KZNa9EO/qzxm9wG17EzMiVUbpNtExQ/TBSPf3eUwufEIkp9sHo2q6Yj7GZTiDGtBk1Cjm3nMPXVRplGQuhvqUT3fLoXtgL+Mu2Nc0GtXhzfJ+SrR0jgGKA6WaOjEb8FQ1eA64RFXXFHAsAtyGTf2PiCYMXWKoaIVQvQn5vYVQoyaGEpG/A5tU9dIUx9gHe06GYwL9QWCiOgpCapfraQhcApyLxQ085sbpdXfdCJx33XV8ecABvDJgAOVNm1JNscqUQk1/wgv9VRmvymeqVKqy2f39zK3Pq/N4sKS2UM/oA9+5t8dc2+YDQwo9Hjemi3HBDxgvuicwCqsz9irmafQj5gL1T8wQvg/QJsXjNMVyInRPsr2XPvgaS5a+Y4y222DubbtjCWWew8r+hLb/BhO8IaphPfBbzLVLd96Zb7SIZUoRFKYMUGqoj/SBF06bHIaFyD8CXKWuUm2BxhNKyH8WZhB6F4us6kD0QqgZJ+QXkdMwF7SY5c7j0AevaJzZj/O4mIO5jl0ATPCO11E5b2MfvVaEC1WG3FF/VNWiDQkPhG6ApFCf6QMvXOTRnRi3eIaqzsrjsUO8qz8heC9M62yP8Z7T8CXkz8FYZgFXq+pzUbbFpQ8S9Ls/5vHQEeOKv/Ftb4QJ788ww9prGEXpRbWqNqBIEQjdAHHh3IBGYi/QQupY8EKycAJvFHAtcDtwvapuyuHx2hNp1OqLTaH91XkrsOx+OQl+iDK2gcAkLHorVGWlLeHZz3aEZz9zk+yzJea7ewyW3+Am9RjSXJsyjNNtiEWY1rh1v8b43p0x42EFlh6zKIsU5LFyRIBSgaMPTsReoA7YC7R/faEP/BCRXljejiZYEEdaNcRi9N2c6IVQGxIWrB9i92C2+gqhuqn4THIU/BADY7HkUeKqXIwkTB/8kQT0gR8ichQ2e3gBO/9YBSZvwPJmHxrqX80z4ykRGYT5BW/ChHDRyrZA0w0ABPRBNLhr8nssjPda4LZ0r4WINCB6IdQOwFwitdevE/GuTrucAdytqremM65U4Y65GPsI/JYU6QNfX1th+Q0GAaNVdZpbv8V7wdP2PCz3yz6q+oOvnyZYIMWemuOiktlA0X4NAuQHMeiD0fWNPvBDRPpj/OjPwB7JvsxuutuFSJesX2CCISRYH3a/F6hqdRrja4IFKkzNh8D10AeXYHLjZ6xycFL0ga8vwQoK3ILRBTup6ro47YdimccG+wWuw/FYKoKiF7gQCN16iYA+iA1nqLkcm0JfBtwfS+N0vKufFuiLZdYLCdcXgZvIYiFUF/zwKFbZ5OJs9BnjONG8D8qBw1T1zTT73A6rYdgT+JWqvpug/X6Ya9shqrokRrOxWFHLkkAgdOsJYtAHl1OP6QM/RGRPTLudD+ysqsvd+maYMPVrr40JR2l9jLmPfRZDG8vWGAXTENtgwQ9Zz1gmVnorlPktRB+ciZW46oNRGqn2KZgh8jpMiA5NZIh045gMnKiq/4vRZldMcUg+e0uBEQjdOg4PfXAyYfpglBYwaqrY4ITq/2Ha/01YCaBx7tr1x3yR5xLWXl9yfxPyrjnARViVk301jdDbWIjhfVCLPhCRtBKVi0hPzBDZ3PWZTDavMkwxuEBVX43TbizGaZeM4hAY0uogYtAH9SZ4IRGc1hXiXX+N8YvVmOa6jNpGrZC/a8q8a7bhKj9cB+yt4YKJmfSXdPCC80/+BOiqqj8n2X85cB42o/orcEsywtF5i3yOlda6MU671ljynR38/rzFjEDTrSMI6IPocBZyPy3Qj3CZp1bAv7Bw3s8LGVkWDyJyEFae/cBMBW4s+iCB8XQ0FhmWrMDth1E167GquvOT3K8RFhxRhYWXx8MI4PlSErgQaLoljxj0waT6Rh84iqAPtQVsf0x79WfI6oz5fD4DXKaqPxVizMkiG5UfMglecO5uSzBjVlwfZReSfBlWi+1y4L5keWdP8EMLYKA/OMLXVjBteJS62oylgkDTLUH46INtqKOVF6LBCYBfEKm9dsQqU4cE68vu71chDtJl17oN2BU4KY/BBGkjk8oPMeiDlIMXMApmXhICdw9Mu12EGSJT1chDwQ/DscQ48TAE04ZnpniMgiMQuiUC9wIdjr1AB2Mv4mXAtLpIH3h4V79L1vYY7xrSXh9zf+fH4l1dXycDN2NT19OKNUTUC6edvkCKlR889MEpWCDDgySmD+JhLBYxFut4TTFD5MlYMMnENIxt52Elf/bBktckwjjgjgIYMjNGQC8UOeoDfeA092h5BtYSmSErJd5VRLoAd2Ga8Bmq+kF2R58buOCHl4B3VPWiJNpnlPsgTr+9gelY8pkIFy8RGQLci1U6Pk9Vv0vjGEOxjG2DVXVJtIg0X/uO2POQtFGvmBBoukWIukofeHhXv/baBHuJZmMW8glYnoHvMzhWGRY2+hfMr/VGVa3K6ATyBE/ww1dYBFisdtmiD+LhLKyCcS2B69Ir/g04Ahirqs+m07nLKpYo+MGP0VjduZITuBAI3aJBXaIP3LmEeFevcN2O2rzrK+73V9mcJorI9pj2VQHsp6qfZ6vvXCOZ4Icc0AexxtIM41d38a0/Bosqew7ol+6sy53HJOIEP0TZpwEmdI9I55jFgEDoFhgx6IMzSoE+cAKiM5FGre2x6gAhSmCC+z0vl/6uTthfgIXG/gX4Z6l9sIgR/ODog9DspyM2+xmSKX2QACcBM1R1qRtDe8wQuTtwiqq+lm7Hzu83meAHP44BFiUZYFGUCIRuAVCK9IEbs9cVK+Tvuo6wcH0V09I+j5fAJEfjGwDcD3yPuRuVXD09F/xwNhb8sMZDH5zm/k4FriS79EGssQhmrLrU/T4R8xN+GFMK0vZndtTEVOyj+FiKu4/DtOySRSB084RSoQ+cJdrv79oPaEaYdw1pr5+lYzjJJkSkMSaIzsQ03IdK0qItcjAu+AFo7az5Xvog35nf9sT8ZT8HpmCeJEer6vuZdOqCH/6DVXxIFPzg33cH7Fl8KpMxFBqB0M0xipU+8PCufqNWJ4x3DQnXW93fZcUmzERkb8wv9HNggKquKPCQ0oKI7Aw8jhnPHiR/9EE8jMWS+HyAUQq/TZSgJhGccfNBrDDm+Wk8T2dhWd+ylnOiEAiEbg5QTPSBmxp2ItKotQPGu4aMWk9gGuO8Yrfyi1VbuBYYCvxOVZ8s8JDSgvvwDcemy4rlycgLfZBgXHtgSsLHZLdSRkTlhxTG1BTT/HfL0lgKhkDoZgnFQB84Y0u0PAMbCGuu0zDNZU6+eddsQEQOwXIlvI5ZznOWRjFXcFb7kZgQaYlN38fkmT6INq4K4HzgaqxE0KBsPbsi8ntc8EOagSnDgLdTcCsrWgRCN0NI7coLC8gDfeDhXf3UQHNqBxM8gfm7FpR3zQZEpA0WUXYgJqBeLPCQUkIU74MJ2EzjkWSCH3INEdkJo2rWYJWFf5dFgTsU+ANmIEz3IzkO80EuedQxoSv9Md5nCJaZviFWqG4BFlVzF2TuahKDPthPVb/MtG/fcSqw8tp+7bUz8CVhAXu7+7u02HjXbEBEfoud41NA/1JxivdlfvN6H0zDPohfEif4IR9whq0rsPfmUmA5lj4yUe6DZPv3Bj8sjdNyy7u7eTM9RWgIUgksWLSIz3bdlW0+/JCS+tDGQh0JA5YeWNb+nbFKouVRGlVjAvgj4FRIrZ5SDPrgQbJAH/h4V69w3QFYQWR+16LnXbMBEekAjMeuRclkk/LQB8MJex9MVNXV7l7fhoU5H1FIo5BYBd37MOE/TlWXi8gzwBRVvTcL/ffFPjAnxfbFTfzu1tSgmzdT3aAB75HGu1t0UNUSXxiqyjpVqpPcpdq1H5pMY+yFvwlYiWU0Gg20Sne8QFtgP8wf806s9Mlq1//LWAz66cAeQPPCX9/8L4BgEVerMK2rcaHHlOR9PRsrA/41lrR7xyjtLsZCndN+hrIw1maYP/UKzBgZUr66Yn7OzbJwjE5YOsiTY7fL7btbrEuJ0wsyFHgIi91PFuVAU9tPgMjsTdmgD1zCEi/vGtJeW1Kbd52E8a7fpnAOdRYuleHd2HU/XFU/KvCQYiIOfRDV+8Af/JDHoXrHcDBmiJyBGSK9+S3OBB7VDA2sYhUdnidu8ENu3t1SQAnTC9IDE1xNM+hkPdAPdFG69IGHd/UbtToD86hNDcwGlmjpXvScwflwjsMs5zcDN2mRUijx6IM4+xyMpaE8ULPngpU0nCC8GXu2z1LV533bG2Il4g/QDHyDHUf8Ava8nxf9Wc/uu5tBH4VBhlOIHTCO9Gfg3CjbOBp5rwAAGntJREFU7wL+mAsVHdAvv0x6WhJzuvLTT3xIEvQB9mnthCXauAjTfj/Ebv4CrArBNZhrS1+gQaGnMaWyADtimtcMokzJi2EhSfogxr47A99gs6VCjP3XbszjgRYx2gzDFIxMjlOGBXn8GyiP3ZaZGoVSAHTevNrrrroKPfnkqN1UqzKj0M9FOkum9MLFwGuquku0jap6Vob9x4DsBCAS1WCWCsorKtj5yCN5f+rUMH0gIm1EZD8i/V03EdZYX8ce4jmqujbhiEUOwKZunTIcc52Byxh1EZak5iqs0mzWS4qni1Tpgxh9dAWeJY3KD5nC5aW9HRgADFPVN+M0H+vaZoIbMcXkkNjXR3bCPkIZv7vALub1UFrJbzIVul0x15cIiEh5sg9mGhiTrY4aN2bzVVfRY+pURotISMC2Aj4j7C0wGeNdS6oAXjFDRHbBEtSsAnbTInJ6j0EfpJz7wFP54UZNofJDpnAeEqdguQ3uB0ZonIAE52veC5utpXvM84AjseCHjXGajsG8FLKBhq6/c7LUX36QwVRiGlZNdSOW4X8CZo2fimWeOhh7WK/x7HM0Flq4GngL2MmzbTHmQP0J5qA9EY/VGtOIVgDLb7uN5XimIs89h/bujTZvjnbsiP7tb4lP4emn0QED0BYt0M6dqcHKuByDJfr4L/ADMB972UJj8J/PAVgu2LjngFmLNwCb3bVaC3Qs9DSnEIu7Hn/FhO2pOLtCoRcyoA9i9NcEo0v+lufz6IIZsT7GPmbJ7PNP4M8ZHHMolnC9S+L2zIm1idTohdDyWaGfnZSvV4Y3+DXMfzIkkNYAgzFup7FXSGHFAL9xQq0ccwlaDDRy2xdjDtkd3QvwOUb4gxm4VuGyXQ0bRo33BnXogL7xhv3+4Qf0gw/iD/3dd9GWLdGXXkJratBly6gMvWAYbXCHG//OwLfAQZ5zTCR0Y51Drbb1ccHqX32BzRy2KYLxVGChqZPds/s4RifE4SOT6rcceBJTRMrydC5l7qPxHVaFNymbApZJ7AegU5rH3d+91wOS24fKWJvSFLqVhX6OUl2y7TL2jKqGqnNutFnOFowG7lbVd93/D4nI5cBemKADuE1VlwOIyBRM6AEcDzygqrMBvvxSyp7wkBoNGsCcOTBgALRpY0s83HcfnH46HHKI/d+pEw1Uda6IdMYEw9FqU6SPReRebKqWbKLlWOdQbyEiLTDN8TdYeGlBU/Nliz6I0XfCyg/Zhkt5eC8mePfV1CplnAxMV9Wv0jhuP1Ks/IBRAlFRXg5VPn+Vqip7v+MgmSKWRYWyLPe3LM62rsCFIrI6tGBuVR09bVZ6fq/Hcgng2mzpu0sXaqWYe/JJmDoVunaF/feHt99OMMhl0LNnrVWhW90R+EFrh5kuwcrMJItY51AvISKHY4bHpphfaEEEroi0FZGzRWQWVvCxGkudOEhV786GwHUIVX74jeY42kxEKkTkUszrZhIpClxPovKYlX7j7Jtu5YeY6SG7dIHFi2uvW7TI3us4KEq3wnjItqYbz/90GXCtql6bRr8rMAENwIIFLMNyKwAwcCA884x9FcePh+OPN8EaC507w4IFtVbNd3+XA21FpIVH8HbBOD4wrtrrW9ghhXOoV765LsDk71j03ShVfbkAY8jY+yDF4w0nT8EPLgfvfVgE2e6qujiNbvbGjFrTUjx2KPhhvKZe+WEB0DvahhNOgGuugf79oWNHmDYNpkxJqETNj7u1CJFtTTce7gHOEpE9xdBMRI5yU89EmASMFJE+ItJ03Di2vDCbNsFjj8GaNTYNadnSpinxcMYZ8MAD8OqrUFND9ezZvCciO6rqMszA91cRaewyL52BObWDGSeOdFpTB+D3KZz/KqCdK1VSZ+Hu7XGY18ePWIKavApcEeknIn/DPvRXYgUwu6rqiar6Yo4E7sFY8MGRqvp1ovYZHKexiFyLaeu3A4elKXDBtNy7UqFAJFz5YTopVn5wmI7NMiLwpz/B3nvDPvsYRXjxxfZu9+sXs69q119pIRNCmEhD2jW+7bXWYQaxWZj3wgrMgNHCbVsMHOxpezXm1xr6/1Js6r580CD+hCPdKyvRww5DW7c2T4Tdd0fffDPx8J96Cu3f3zweGjViKfbwgvkZPosZFxbgDGFuW2PMI+EnzEPhfCINafHOIVTDazV10HsB2BbLBDYHy8Waz2Nn1fsgxWOHgh/2zfFxBgNzMSNdhwz72hr7KLZJYZ8kgx/iLeyklj8hG5dknSr983GPs3ofCz2A9JfoUS0pLiUb1VJMCxatd7oTPP+H80jJw3Fz4n2Q4hi6Yu5Sx+XwGM2xzGTLgWOz1OelwH0p7nMT8CYZJyCq3+9ukHuhVOO3iwQi0h1LoNIGS96erBU7k2P2w1wOk859kKNxtMWMWHeq6m05Osah2PWdDlyoWaiUISLl2CzuOE2y0KSr/HAmFvyQ4Rjq97ubT043y9CFmIEkaqTNdddB8+aRyxFHbGmywfYvvZtWDBCRcheFNAtLSblXLgWuiLTzeB+8SO68D5IdTxMsiObZXAhcZzd4ABO4Z6rqadkQuA6HA9+kIHCPx4J+Ds/OGOK/u0mgtN/dQqvamS/1MydnIRcsZeXbwBvA9jk8TsHpgxjjymnwA3AsRiXcRg5yKmMZ9E5Lsm2KwQ+pLPXz3S34ALJ083qoMsPdkKoYzarc9hmqdC/8mEtvwRzb/4hF6Y3NhcBxx+mHWcZXOOE+Bmhd6PN3YxMs0dGrZJm7xgyRT2LGssE5Gn93LGqtaZL3YRUuIjM3S/17d0s8iXkIuhDYx9VZGoPVSOuFRatUYb5804G7Sy0jUbFARHbH/EK/BnZVc6/LZv/tsPSCIzHhU7Cy9QlwMbAvlqYxK8EPLkhhBJal6x6s2kK8pDGZYAzwkKquTzCmdIMfUkT9e3dL2JAWIB9w3OWfMaFwATBBs/TQxAheeAB4VfNUtj4VuOCHa7Hgh6z44opIN4y33Qo4XVU/zka/MY7VCPNdHqyq8+K0a415KTyiqjfmajz1FSVsSAuQa7hKrp9gUXn9VfWxbAjcBMELLxWpwA0FPxyRDYErImUi8jvMEPkqsGcuBa7DccDHCQRupsEPARKgjtALAbIJEWkJ3IClujxbVdPOs+rps1Togwi4kNsJmI/snCz01xtLULMZc8HK1zUYRxxB6komPYQF8JyfrRlNgNoINN0AtSAiR2EJaiqwBDWZJLaucKHekzG/0MHAFZhWe3mJCNxuWITiOI1feSGZvhqIyBXY1P0xYP98XQMRGYDNWJ6N0+xGLLnT8GKcbdQVBJpuAABEZCssJeEgzJ0obeOJL3hhEVlMnZhPuOCH57HKD//OsK9dsTDwFRSmUsZY4F+qGjXvgQt+SKbyQ4AMEQjdeg5nOT8BE7iPYdU8Ui7BXcr0QTR4gh+maAbBD66fq4DTsACDR/M9bXd00QmYf3W07aHgh701ewEYAWIgELr1GCKyHVYloxfwKw0nmE92f6/3wSGY98EVFKn3QbJwYbKPYSXJL82gn30x7vZ/2MdsVXZGmDJOAV5W1RX+Dc5YOh4rJrk07yOrhwiEbj2E025HAddh9bGOT8XntK7QB9Hgrs2tWHHSEzWNyg8uXen1WOnzc1T1P9kdZUpjCSUqPzvKtnQqPwTIEIHQrWcQkZ6YA34L4EDV5BzO6xp9EAcZBT+IyBHAXVg+in6q+mOWx5cq9sWi6F73rsxf8EMAPwKhW0/gpsznYUUL/wrcGsuo4tmnTtIHseCCH8aRRuUH91H6B1Zj7wxVfSUHQ0wH47AsaFt45AwrPwTIEEFEWj2Am0beh6XDG62qcUucuPYjMfpgIUYfTKoL9EEsiMghwKNY5rKkfXHd9H0oRkk8AVyZjiEyF3DVTT4HuoU+Ii744QUsteJ5gS9u/hFounUYItIQuAw4B9NQ743FUTpN7URM2HbA6IO8+ZEWEi744TFSDH4QkY4YJ74D8FtVTVASNe84A5jsEbih4IcfCIIfCoZA6BYlpD9wFpb8oyeW3WsTFmAwHbgrUfIPEdkD024XA7tolBLbMeiDy6mj9EE0pBP84LTb0zGa5i5gWLaS36SO6M+KKgvvvZdO337LaZ7GoeCHQ+vL/S1GBPRCUUF6AI9gNbcaYXlb/ajGBPBHwKkuS1O4B5GmWMmck7Eabk/4NZr6SB9EQzqVH0SkB5agpjWWoOaTHA4x3kgSPivV1WhFBRuAjw46iOnTpnEsWan8ECAj5DuXZLDEWjJP6IxpOwuwqXJ7b2OgHUYzvI/V9LoO2KHw512YBWgCzMCizZJpX45Vf/4OuAioKJVnpaaGmnXr2PzRR4wt9HUPlpKukVaXIEMxrq1JGjtvWL6csdttx2DgCGyaPAVi0gcPUo/og2hwnhyTgY1YnoG4vrgi0hejaiqx6tcxs3TlHpk9K8AI0MnZHVOAVFCnha6ILMZekmJx34mCzIr0XX01zJ0L8+Yx4cMPGaeqa3JBHzjucxHQQKO4monI5UAPVR2V7jHyAcfH3g70Bo7UOFysM0ReApyLVcz4VyIBnVvktqBjonucL4iIAr/QBF42pYrAkFZ4PIJxcmmjvBx9+216NmrEKSL/3975R1lVVXH8850BZIAhhBkIBCREsgg1FWfCDGphilm21H4YmoO51KIsshZlGZSsDDV/ZqmYkmL+oNRSS1sp6kKbhaEtE7IcHMQYfggxDDAyv9z9sc+buQzzyxl48+bN+az11rvvnnPPPefeffc7d5+z91EJ3TD7wMx+mo7z7Ac65PwgaQreu32TA7BSRifpsqyE4+/G5xNHuoEY2rFb0ZH4QEhLA2YdL0Wovp6iadOYic8+ONQ6EToxmCOyFknn4tG2Zlorzg+SBki6Cp/RsAg4LTMU7v6Rlfp6coEPh1kPkW6gNyjdoyW9LGmHpPsl9Zd0sKRHJb0laXvYHp06QFKJpNcl7ZRULmlWWycI+Z+TdJ2kynDs1LD/TUlbJJ2XyH+QpGuGDeO5ESMYcPHF8HZYjPrpp2H0aLjqKhg+HEaOhIcfhj/9CSZOhKFDfXn5JHv2QEkJVlrKSbjP/4cS5xol6fehreWSLkmkLZD0O0lLJVUBJZKOl/R3SVWSNku6tllzZ0laL2lriA2bLGtp2B4nySRdKKlC0kZJl3bwfh0QgvPDNbhJoaJZ2jxJGyRVA5XAccCxwBRgQ2jD9cGxAEnTJf1X0qXh3m6UNDtR3jBJj4Rr+IKkhZJWhDQFOdkSZPLlYA5qq+5LZs7ktzNmkJefD9OmwRshMOS6dSBBfcIYMH063H67by9ZAiecAHPnuuwsWADV1fQ74wzukvRGqMMKeTS0FK3d4+Ml/S3I+EZJvwgmmDbblZL3UOZmSbckzyfpu6G8Cknnt3cvezzdPZJ3ID/4HNWVwChgKO6dczE+kn8mbhvLxwdVHg7HDASqCCP7eJyBSe2cpwSfyjUb74ksxCNU3Yy/zn0S2ElYThsPo/jHzZt5taoKO+007Hvf8+KWL8dyc7Ef/xirrcVuuw0rKMDOPhurqsJeeQU76CBs7VrPP38+1qcPtmwZVlPDajxEXzm+sF8OsAr4ET5/czxu4z051GMBvvjfZ0PePHz13XND+iCgOGyPAwyP25AHHIUPLH0gUdbSZnnvDddzMr6C8IxukoOj8WXET2wh7f34bI67wvcF+HzXnwClwHCgEHgeuCIcMz3c75+E63wqbis9OKTfFz4D8HCKbwIrQtrJ4Z4MwWMifAAY2U79lwwYQMMzz2B79mCXXIKdcIInl5djgNXVNR0ybRq2eLFv33mny9ONN3qe6mrsa1/DiorYjc/ZzQWmBjlt7x4fCxTjZslx+PP0rfbalZJ3/BnMBx4Brgxpp+ArDn8oyMpvQx0mdLf+OGDy2N0VOKCNc6V7TuL3VcAtLeQ7GtgetgfivZ0zgbwOnqcEeC3xe3IQnBGJfdvCeQTsBg4zo8YMe/55bNw4L275cqx/f6y+3n9XVflDVVradMpjjsEeesi358/Hiooa02pw5bkRt1sWAeub1fX7wJ1hewHwbLP0Z/GFKAua7U89kKMT+1bijgGpspor3SOaXftfd4MMjMOV6VmtpF8ANACPAcMS+9fiveLU75OBdWF7Oj4ToE8ifUtQSLn4H9n7E2kLaVK6nwD+E/J2aAl7YMnnP09DatfOnVhODrZ+fceU7pgxTWkNDS5fL71EbSvXqtV73EL+bwEPtdWuveW9cd9HgPKwfQfws0TaRLJc6fYG88KmxHY1MCjY7W4Nr1dVuKIZIinX3G/+C3iPeKOkxyQd0YHzJGOlvg1ge8dPfRvvORbiPaBVQ4bQb8gQOOUUeOutpozDhkFusNzlhZewESOa0vPyYNeupt9jxjRu9jUfXf8v3rs/FBgVXgcrJVXiNt9EaTS3V34FF/xXw6vxac3S97metE6y7DdCndKG3LX5cWCRNVv5QVKhpHvwP6Er8VCOZZLuk7v3jgp1TtG8/tts7xH+1LUoxHuCybY3bpvZU3j82puBzZJukwcZb5OxY5ue1UGD3FRQUdHWEU0k5IOtW90cddhhbQ6it3iPJU0MprhN4bn5Kb6KcVvtapT3hAw+HvaDX9PmcpLV9Aal2xKX4q+VRWY2GPhY2C8AM3vCzE7CTQuv4q9b+4utuAKeVFlJbWUl7NixtxJ9t7zZJLJ1cv/60UAFLszlZjYk8ck3s1MTh+81Z9DMXjOzs/HX6kXA7yQN7GTVEo87Y0Od0oKaVn74o5ndlNgvSV/Ep15twlc5/qGZfRT/kzK83RXh97ut/1u46WF0Yl/yOmBmN5rZscAk/A/uu+0Vun49jVPVdu2C//0PRo2CgeHOVFc35d20ae9jpabtggLo3x/WrqUzU8J+hT8Ph4fn5jLCMwOttqtR3hMy+B4zS/1Zb2RfOclqeqvSzccFoVLuCjo/lSBphKTPBEVTA+zCXz/3C6Enuhi4rqKCdQAbNsATT3S+zFWr4MEHoa6OMvyVrwa3R64EqsJAUZ6kXPny51NaK0vSOZIKQz1T83o72/7Lw1vFJNzefX8ny0nVbjLoZtAaUA3IwveasH9yaENq5Yd1JFZ+kK+U8Qd82ffTzexSYIykT4RBsj24XDTg9ugfhh5xAW4XX9peDc2dTh4EFoS2HwF8OVGHKZKKJPXFX7v30IHr+9hjsGIF1NbC5ZdDUZH3YAsL4ZBDYOlSaGiAO+6AtWtbLycnB84/H+bMoVY+yJor6SOpQcJ2yMfHO3aFdn21vXYl5V3S8JD3EEknh0MfwAdwPyh3YZ9PltNble71+EDBVlw5PZ5Iy8F7whV4NKZpeEzS/ck8oOyoo3jv4MEwYwb8uwuzaU8/He67D8vP53B8aZYzzKwuKIBP47bkcry9t+Ov0q1xCrBa0i48XOEXrfMLFT4DlAFPAteY2V86V4zGg57D79VF+CBNv5DYL/y+ECg104opU7gTb+NsM3tHUo6kC4F/4IM9x1jT0kQH4TM+tuI93+F4D24h7jL9Mt4rfjHs6whfD+ffhM+JvRf/IwQYjCuh7fir9DZ8VkWbnHgi/1qwABs61P9k70lEwV28GK6+2s1Sq1fD1Kltl3X11dQXFlIGvIDL+CI6pgu+A3wJHxRezN5/om21ax4uB6XBLPFX/E0TM/sz/jw+FfI81YF69Giy2iMt89GR+GyBrngYpagGituLPpYOtF89m/Q53KOutQBAe9HQwDu1tWj7dmaPGmW/kTQBVwYD8ODir3StPu8eSYuA95rZee1mbvn4JRMmUPvaa8wiy2SlN9Jbe7oZgr2M9766ar5oAF7KvoeoMc7AADroFJCbS05eHho5kl9deaV+g/eOH8FXg0iLwpV0hKQjg/34eHxwskvrpJWVsYUoK1lBVLodJEzo3tXC55YuFn0uTa+enaUmlJNFaDzew+1MYBck8ubO5ZyFCznTzK619Ab4ycfturtxm+XPcVtyq0ha3Yp8JR1zoqxkAdG8kBH03shRklYDc8zs6WYpz+HzjDvt9mpGg0QpWBbFGei9spItxJ5uRmDL8CXNq+n462NDyN+jHyIzm9SCwm03zkDKXbo5SRfYHTvIPe88ivr21Va5S/d/JM3bT1XvJnqvrGQLUelmDLYM92QrxR+Q1gag6kN6KR6iLxsfoovoejQt5s6F6mpyy8t5CJ9N8Bnc06yHE2WlJxOVbkZhr4dX4WLgVmANvjSPhe81YX+x59s3JmpPQ9I6STOUCLRTUMBF3/5216JpAbzwAsyahUaPZqqZvWNmrzb3TOu59D5ZyRayOpRfz8X+ic/17E3cANxgZnfv3Kma1au7rnSLi+EHP4Bt25h4wQU63Lp1xYcDRa+UlR5N7OlGMoU6YIKkgvx8+hUXd73Am26CWbPgl7+kD7BGUpmkmV0vORLpPFHpRjKFxkA7xx2HPfpo25n79IG6un3319VB376+nZcHl10Gq1ZRi4fzfABYFly/I5FuISrdSEaQDLTzjW+w4ayzYPfu1vOPHesRs5KBgsw8uPehh+6TvczMUlGxBgLv28/Vj0Q6TFS6kYwgGWinoYEXoSm8ZUuMHetBX+bNc8VbU+PxB/r0cVsuwBVXwMqVNOzezTOS+gPfxIP4pGXduEikJaLSjWQKjYF25sxh0j33UNO/f9sH3H8/bNkCEyZ4pK0nn/RljVLHSTB7NjmDB/NlPIDRScCnzKwLgTQjka4RPdIiGUrXPdJwp4As80iL9HSi0o1kKBqPh1TsSlStatwpIM5RjWQM0bwQyVDs9ZISbh80yJenSX4mTepQAW8DJVHhRjKN2NONZDjvLp4ublKowRVudHuNZBxR6UZ6ABqPL5H+YXyliJY8Ketx99eXgHNjDzeSqUSlG+lBaDIeDOfjwASgL+7JVgYsB26NwbkjmU5UupFIJJJG4kBaJBKJpJGodCORSCSNRKUbiUQiaSQq3UgkEkkjUelGIpFIGolKNxKJRNJIVLqRSCSSRqLSjUQikTQSlW4kEomkkah0I5FIJI1EpRuJRCJpJCrdSCQSSSNR6UYikUgaiUo3EolE0sj/AfTxvdRgJzMvAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -420,13 +420,13 @@ "Estimand name: backdoor1 (Default)\n", "Estimand expression:\n", " d \n", - "────────────(Expectation(log_demand|has_membership,is_US,friends_count,age,inc\n", + "────────────(Expectation(log_demand|has_membership,age,songs_purchased,friends\n", "d[log_price] \n", "\n", " \n", - "ome,days_visited,songs_purchased,account_age,avg_hours))\n", + "_count,is_US,income,avg_hours,account_age,days_visited))\n", " \n", - "Estimand assumption 1, Unconfoundedness: If U→{log_price} and U→log_demand then P(log_demand|log_price,has_membership,is_US,friends_count,age,income,days_visited,songs_purchased,account_age,avg_hours,U) = P(log_demand|log_price,has_membership,is_US,friends_count,age,income,days_visited,songs_purchased,account_age,avg_hours)\n", + "Estimand assumption 1, Unconfoundedness: If U→{log_price} and U→log_demand then P(log_demand|log_price,has_membership,age,songs_purchased,friends_count,is_US,income,avg_hours,account_age,days_visited,U) = P(log_demand|log_price,has_membership,age,songs_purchased,friends_count,is_US,income,avg_hours,account_age,days_visited)\n", "\n", "### Estimand : 2\n", "Estimand name: iv\n", @@ -539,13 +539,13 @@ "Estimand type: nonparametric-ate\n", "\n", "## Realized estimand\n", - "b: log_demand~log_price+has_membership+is_US+friends_count+age+income+days_visited+songs_purchased+account_age+avg_hours | income\n", + "b: log_demand~log_price+has_membership+age+songs_purchased+friends_count+is_US+income+avg_hours+account_age+days_visited | income\n", "Target units: ate\n", "\n", "## Estimate\n", - "Mean value: -0.9916221544699865\n", - "Effect estimates: [-1.08504186 -1.47252767 -0.8270136 ... -1.32545964 -1.90661168\n", - " -0.40606115]\n", + "Mean value: -0.995160166332067\n", + "Effect estimates: [-1.10245137 -1.48197402 -0.84719356 ... -1.33838032 -1.90324458\n", + " -0.4240255 ]\n", "\n" ] } @@ -574,7 +574,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 14, @@ -583,7 +583,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -640,10 +640,10 @@ " point_estimate stderr zstat pvalue ci_lower ci_upper\n", "\n", "\n", - " income 2.46 0.075 32.86 0.0 2.337 2.583 \n", + " income 2.346 0.082 28.606 0.0 2.211 2.481 \n", "\n", "\n", - " income^2 -0.451 0.026 -17.496 0.0 -0.493 -0.408 \n", + " income^2 -0.404 0.028 -14.598 0.0 -0.45 -0.358 \n", "\n", "\n", "\n", @@ -652,7 +652,7 @@ " \n", "\n", "\n", - " \n", + " \n", "\n", "
point_estimate stderr zstat pvalue ci_lower ci_upper
cate_intercept -3.032 0.046 -65.801 0.0 -3.108 -2.957cate_intercept -2.984 0.051 -58.786 0.0 -3.067 -2.9


A linear parametric conditional average treatment effect (CATE) model was fitted:
$Y = \\Theta(X)\\cdot T + g(X, W) + \\epsilon$
where for every outcome $i$ and treatment $j$ the CATE $\\Theta_{ij}(X)$ has the form:
$\\Theta_{ij}(X) = \\phi(X)' coef_{ij} + cate\\_intercept_{ij}$
where $\\phi(X)$ is the output of the `featurizer` or $X$ if `featurizer`=None. Coefficient Results table portrays the $coef_{ij}$ parameter vector for each outcome $i$ and treatment $j$. Intercept Results table portrays the $cate\\_intercept_{ij}$ parameter." ], @@ -663,13 +663,13 @@ "===============================================================\n", " point_estimate stderr zstat pvalue ci_lower ci_upper\n", "---------------------------------------------------------------\n", - "income 2.46 0.075 32.86 0.0 2.337 2.583\n", - "income^2 -0.451 0.026 -17.496 0.0 -0.493 -0.408\n", + "income 2.346 0.082 28.606 0.0 2.211 2.481\n", + "income^2 -0.404 0.028 -14.598 0.0 -0.45 -0.358\n", " CATE Intercept Results \n", "=====================================================================\n", " point_estimate stderr zstat pvalue ci_lower ci_upper\n", "---------------------------------------------------------------------\n", - "cate_intercept -3.032 0.046 -65.801 0.0 -3.108 -2.957\n", + "cate_intercept -2.984 0.051 -58.786 0.0 -3.067 -2.9\n", "---------------------------------------------------------------------\n", "\n", "A linear parametric conditional average treatment effect (CATE) model was fitted:\n", @@ -722,7 +722,7 @@ "INFO:dowhy.causal_identifier:Instrumental variables for treatment and outcome:[]\n", "INFO:dowhy.causal_identifier:Frontdoor variables for treatment and outcome:[]\n", "INFO:dowhy.causal_estimator:INFO: Using EconML Estimator\n", - "INFO:dowhy.causal_estimator:b: log_demand~log_price+has_membership+is_US+friends_count+age+income+days_visited+songs_purchased+account_age+avg_hours | income\n" + "INFO:dowhy.causal_estimator:b: log_demand~log_price+has_membership+age+songs_purchased+friends_count+is_US+income+avg_hours+account_age+days_visited | income\n" ] } ], @@ -753,7 +753,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 18, @@ -762,7 +762,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -831,7 +831,7 @@ "output_type": "stream", "text": [ "INFO:dowhy.causal_estimator:INFO: Using EconML Estimator\n", - "INFO:dowhy.causal_estimator:b: log_demand~log_price+has_membership+is_US+friends_count+age+income+days_visited+songs_purchased+account_age+avg_hours+w_random | income\n" + "INFO:dowhy.causal_estimator:b: log_demand~log_price+has_membership+age+songs_purchased+friends_count+is_US+income+avg_hours+account_age+days_visited+w_random | income\n" ] }, { @@ -839,8 +839,8 @@ "output_type": "stream", "text": [ "Refute: Add a Random Common Cause\n", - "Estimated effect:-0.9580402878312985\n", - "New effect:-0.9543974584750428\n", + "Estimated effect:-0.9541062505955941\n", + "New effect:-0.9567991329993085\n", "\n" ] } @@ -869,7 +869,7 @@ "output_type": "stream", "text": [ "INFO:dowhy.causal_estimator:INFO: Using EconML Estimator\n", - "INFO:dowhy.causal_estimator:b: log_demand~log_price+has_membership+is_US+friends_count+age+income+days_visited+songs_purchased+account_age+avg_hours | income\n" + "INFO:dowhy.causal_estimator:b: log_demand~log_price+has_membership+age+songs_purchased+friends_count+is_US+income+avg_hours+account_age+days_visited | income\n" ] }, { @@ -877,8 +877,8 @@ "output_type": "stream", "text": [ "Refute: Add an Unobserved Common Cause\n", - "Estimated effect:-0.9580402878312985\n", - "New effect:0.19244868852546373\n", + "Estimated effect:-0.9541062505955941\n", + "New effect:0.18928228066056693\n", "\n" ] } @@ -914,11 +914,11 @@ "text": [ "INFO:dowhy.causal_refuters.placebo_treatment_refuter:Refutation over 3 simulated datasets of permute treatment\n", "INFO:dowhy.causal_estimator:INFO: Using EconML Estimator\n", - "INFO:dowhy.causal_estimator:b: log_demand~placebo+has_membership+is_US+friends_count+age+income+days_visited+songs_purchased+account_age+avg_hours | income\n", + "INFO:dowhy.causal_estimator:b: log_demand~placebo+has_membership+age+songs_purchased+friends_count+is_US+income+avg_hours+account_age+days_visited | income\n", "INFO:dowhy.causal_estimator:INFO: Using EconML Estimator\n", - "INFO:dowhy.causal_estimator:b: log_demand~placebo+has_membership+is_US+friends_count+age+income+days_visited+songs_purchased+account_age+avg_hours | income\n", + "INFO:dowhy.causal_estimator:b: log_demand~placebo+has_membership+age+songs_purchased+friends_count+is_US+income+avg_hours+account_age+days_visited | income\n", "INFO:dowhy.causal_estimator:INFO: Using EconML Estimator\n", - "INFO:dowhy.causal_estimator:b: log_demand~placebo+has_membership+is_US+friends_count+age+income+days_visited+songs_purchased+account_age+avg_hours | income\n", + "INFO:dowhy.causal_estimator:b: log_demand~placebo+has_membership+age+songs_purchased+friends_count+is_US+income+avg_hours+account_age+days_visited | income\n", "WARNING:dowhy.causal_refuters.placebo_treatment_refuter:We assume a Normal Distribution as the sample has less than 100 examples.\n", " Note: The underlying distribution may not be Normal. We assume that it approaches normal with the increase in sample size.\n" ] @@ -928,9 +928,9 @@ "output_type": "stream", "text": [ "Refute: Use a Placebo Treatment\n", - "Estimated effect:-0.9580402878312985\n", - "New effect:-0.0035545157067004107\n", - "p value:0.2675050399595329\n", + "Estimated effect:-0.9541062505955941\n", + "New effect:-0.0007540292387552173\n", + "p value:0.46950460937416916\n", "\n" ] } @@ -963,11 +963,11 @@ "text": [ "INFO:dowhy.causal_refuters.data_subset_refuter:Refutation over 0.8 simulated datasets of size 8000.0 each\n", "INFO:dowhy.causal_estimator:INFO: Using EconML Estimator\n", - "INFO:dowhy.causal_estimator:b: log_demand~log_price+has_membership+is_US+friends_count+age+income+days_visited+songs_purchased+account_age+avg_hours | income\n", + "INFO:dowhy.causal_estimator:b: log_demand~log_price+has_membership+age+songs_purchased+friends_count+is_US+income+avg_hours+account_age+days_visited | income\n", "INFO:dowhy.causal_estimator:INFO: Using EconML Estimator\n", - "INFO:dowhy.causal_estimator:b: log_demand~log_price+has_membership+is_US+friends_count+age+income+days_visited+songs_purchased+account_age+avg_hours | income\n", + "INFO:dowhy.causal_estimator:b: log_demand~log_price+has_membership+age+songs_purchased+friends_count+is_US+income+avg_hours+account_age+days_visited | income\n", "INFO:dowhy.causal_estimator:INFO: Using EconML Estimator\n", - "INFO:dowhy.causal_estimator:b: log_demand~log_price+has_membership+is_US+friends_count+age+income+days_visited+songs_purchased+account_age+avg_hours | income\n", + "INFO:dowhy.causal_estimator:b: log_demand~log_price+has_membership+age+songs_purchased+friends_count+is_US+income+avg_hours+account_age+days_visited | income\n", "WARNING:dowhy.causal_refuters.data_subset_refuter:We assume a Normal Distribution as the sample has less than 100 examples.\n", " Note: The underlying distribution may not be Normal. We assume that it approaches normal with the increase in sample size.\n" ] @@ -977,9 +977,9 @@ "output_type": "stream", "text": [ "Refute: Use a subset of data\n", - "Estimated effect:-0.9580402878312985\n", - "New effect:-0.9533429945511095\n", - "p value:0.16643169840197264\n", + "Estimated effect:-0.9541062505955941\n", + "New effect:-0.955504419131402\n", + "p value:0.3540851081425652\n", "\n" ] } @@ -1008,7 +1008,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1054,7 +1054,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1067,9 +1067,9 @@ ], "source": [ "intrp = SingleTreePolicyInterpreter(risk_level=0.05, max_depth=2, min_samples_leaf=1, min_impurity_decrease=0.001)\n", - "intrp.interpret(est_nonparam_dw, X_test, sample_treatment_costs=-1, treatment_names=[\"Discount\", \"No-Discount\"])\n", + "intrp.interpret(est_nonparam_dw, X_test, sample_treatment_costs=-1)\n", "plt.figure(figsize=(25, 5))\n", - "intrp.plot(feature_names=[\"income\"], fontsize=12)" + "intrp.plot(feature_names=[\"income\"], treatment_names=[\"Discount\", \"No-Discount\"], fontsize=12)" ] }, { @@ -1249,7 +1249,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.7.1" } }, "nbformat": 4, diff --git a/notebooks/CustomerScenarios/Case Study - Customer Segmentation at An Online Media Company.ipynb b/notebooks/CustomerScenarios/Case Study - Customer Segmentation at An Online Media Company.ipynb index 97bf732ff..c90197a97 100644 --- a/notebooks/CustomerScenarios/Case Study - Customer Segmentation at An Online Media Company.ipynb +++ b/notebooks/CustomerScenarios/Case Study - Customer Segmentation at An Online Media Company.ipynb @@ -399,7 +399,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 10, @@ -408,7 +408,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmkAAAGDCAYAAABwRoerAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAACMeklEQVR4nOzdd5zT9f3A8dcnO7k9gePYe90dCIoTUAHFvQetYm219adWrQNHrUWt1FGt1mq1Wrfi1iJuoSoqCggCsvc4jts7+/P745scd3ALuCQ33s+HkSTfb76fT77JJe+8P0tprRFCCCGEEO2LKdYVEEIIIYQQ+5MgTQghhBCiHZIgTQghhBCiHZIgTQghhBCiHZIgTQghhBCiHZIgTQghhBCiHZIgTQgRc0qp55RS90SxvL5KKa2UsrTxcXsrpaqUUuYW9jtWKbW2LcsWQnQ+EqQJ0UEopY5RSn2jlCpXSpUopRYqpcbFul5hSqlspdRbSqmiUB1XKKVmxLA+zymlvKGgKXxZ3sZlbFFKnRi+rbXeprWO11oHmnuc1vorrfWQpo4TC0qpBUqpX8eyDkKIhtr0V6QQIjKUUonAXOB3wOuADTgW8MSyXvt4EVgO9MGo1yige0xrBPdrre+IcR2EEOKgSCZNiI5hMIDW+lWtdUBrXau1/kRr/ROAUsqklLpDKbVVKbVHKfWCUioptC3ctHepUmpbKNN1e/jASimnUup5pVSpUmq1UupmpdSOettvUUrtVEpVKqXWKqVOaKKO44DntNbVWmu/1vpHrfWH9Y7zhlJqdyjL9qVSakRTT1YpdapSaplSqiyUPcw5iPq0mlLqstBzr1RKbVJKXVlvW7pSam6oLiVKqa9C5/tFoDfw31CW7uZ9m1GVUqlKqf8opXaFzu+7ofsnhs9xE8f5QCl1zT51/EkpdWYjdf9IKXX1PvctV0qdrQwPh94T5aFjjGzF+ZiolNqhlPpD6LH5SqnL6m13KqUeCr3fypVSXyulnKFtpyulVoXO1wKl1LB6j9uilLopVI9qpdQzSqluSqkPQ+f+M6VUSr39x4de/7LQc5rYUt2F6FS01nKRi1za+QVIBIqB54GTgZR9tv8K2AD0B+KBt4EXQ9v6Ahp4GnACuRiZrmGh7bOB/wEpQDbwE7AjtG0IsB3IqnesAU3U8TNgIXAh0LuR7b8CEgA78AiwrN6254B7QtfHAHuAIwAzcCmwJfS4A6lP3TEb2RY+J5bQ7VOAAYACJgA1wJjQtvuAJwFr6HIsoELbtgAnNnPcD4A5oXNrBSaE7p8YPsdNHOd8YFG927mh19/WyHO5BFhY7/ZwoCx0vqYCS4Dk0HMbBvRo4pwsAH5dr35+YFao3tNC5yQltP3x0P49Q6/RUaHyBgPVwOTQ427GeF/a6j3P74BuocfuAZYCo0OP/wL4U2jfnqHnPA0joTA5dDsj1n+PcpFLtC6SSROiA9BaVwDHsDfYKlRKva+U6hbaZTrwN631Jq11FXArcKFq2DH+z9rIwC3HaJbMDd1/PvAXrXWp1noH8Gi9xwQwvjyHK6WsWustWuuNTVTzPOAr4I/A5lAmrK7PnNb6Wa11pdbaA9wF5Iazffv4DfAvrfUibWQNn8cIKscfYH0AbgxlYcKX5xvbSWv9gdZ6ozb8D/gEIxgD8AE9gD5aa582+pO1uOixUqoHRkD929C59YWO3RrvAYOUUoNCt38JzNFaexvZ9x0gTynVJ3R7OvB26Dz7MALjoRiB5WqtdX4r6+ADZoXqPQ+oAoYopUwYAffvtdY7Q6/RN6HyLgA+0Fp/qrX2AQ9i/DA4qt5xH9NaF2itd2K8XxZpI+vqCT2X0aH9fgHM01rP01oHtdafAosxgjYhugQJ0oToIEJfsDO01tnASCALIyNF6PrWertvxehz2q3efbvrXa/ByLiFH7u93ra661rrDcB1GEHVHqXUa0qprCbqV6q1nqm1HhEqdxnwbqjJzayUmq2U2qiUqsDIqACkN3KoPsAf6gdXQC+M7Fmr6xPyoNY6ud7l0sZ2UkqdrJT6LtScWYYRCITr9gBGNuiTUFPozGbKq68XUKK1Lm3l/nVCAcvrwC9CQdFFGH3+Gtu3EiNjd2HorguBl0PbvgD+gZH5KlBKPaWM/o2tUay19te7HX7PpAMOoLHguMH7UGsdxHg/9ay3T0G967WN3A6/L/sA5+3zPjgGI2AWokuQIE2IDkhrvQajOS/cv2gXxpdaWG+M5qoCWpaP0cwZ1mufsl7RWh8TOr4G/tqK+hVhZFGygFTgYuAM4EQgCaNZEIwmuH1tB+7dJ7hyaa1fPdj6NEcpZQfeCtW3m9Y6GZgXrlso+/cHrXV/4DTghnr94JrLqG0HUpVSya2oRmPHeR4jK3YCUKO1/raZx78KXKSUOhIjczW/7sBaP6q1PgwYgdEceVMr6tOcIsCN0Ty8rwbvQ6WUwng/7TyIcrZjNNnXfx/Eaa1nH0ylheiIJEgTogNQSg0NdeLODt3uhZFd+S60y6vA9UqpfkqpeOAvGM1j/saP2MDrwK1KqRSlVE+grhO6UmqIUur4UCDjxsh0NDq9hFLqr0qpkUopi1IqAWMk6gatdTFGk5sHo0+RK1S/pjwN/FYpdUQoCxenlDpFKZVwIPU5ADaMJtRCwK+UOhmYUu95naqUGhgKOCpC5YXLLMDoB7ifULPih8A/Q+fWqpQ6rok67HecUFAWBB6iiSxaPfMwgqNZGK97MFT3caHzaMXoK+bmEM9X6NjPAn9TSmWFsqRHhl6T14FTlFInhMr8A8br/s1BFPUScJpSamqoDIcyBjRkt/hIIToJCdKE6BgqMTrSL1JKVWMEZysxvgTB+NJ8EfgS2IzxZXxNI8dpzCxgR+hxnwFvsndqDzvGwIIijObSTOC2Jo7jwuhTVAZswggaTg9tewGjGWwn8DN7g8v9aK0XY/RL+wdQitHUOOMg6gNws2o4T1pRI+VVAtdiBBilGFm/9+vtMgjjvFQB3wL/1FovCG27D7gj1Bx3YyPl/xKjb9cajE7y1zVRz6aO8wLGVCYvNfMcw82jb2NkKl+ptykRI+gtxTj/xRgZw0N1I7AC+AEowchmmrTWazH6kj2G8RqdBpzWRF+6Zmmtt2NkX2/DCKC3Y2QB5XtLdBnhEUpCCAGAUup3wIVa6wmxrktXp5S6BLgi1LwrhOhi5BeJEF2cUqqHUupoZcz9NQQjO/dOrOvV1SmlXMBVwFOxrosQIjYkSBNC2IB/YTSpfoEx/cM/Y1qjLk4pNRWjia+Ahs2XQoguRJo7hRBCCCHaIcmkCSGEEEK0QxKkCSGEEEK0Q5aWd+l40tPTdd++fWNdDSGEEEKIFi1ZsqRIa52x7/2dMkjr27cvixcvjnU1hBBCCCFapJTa2tj90twphBBCCNEOSZAmhBBCCNEOSZAmhBBCCNEOSZAmhBBCCNEOSZAmhBBCCNEOSZAmhBBCCNEOxTRIU0qdpJRaq5TaoJSa2cj2iUqpcqXUstDlzljUUwghhBAi2mI2T5pSygw8DkwGdgA/KKXe11r/vM+uX2mtT416BYUQQgghYiiWmbTDgQ1a601aay/wGnBGDOsjhBBCCNFuxDJI6wlsr3d7R+i+fR2plFqulPpQKTWiqYMppa5QSi1WSi0uLCxs67oKIYQQQkRVLIM01ch9ep/bS4E+Wutc4DHg3aYOprV+Sms9Vms9NiNjv+WvhBBCCCE6lFgGaTuAXvVuZwO76u+gta7QWleFrs8DrEqp9OhVUQghhBAiNmK5wPoPwCClVD9gJ3AhcHH9HZRS3YECrbVWSh2OEVQWR72mQgjRDmitCQQ1gfC/QU0wCEGtQxfQaLQGvW+7RIhSoQsKkwKTUsbFBGaTcd1sUlhMCqUaa/AQQkRLzII0rbVfKXU18DFgBp7VWq9SSv02tP1J4Fzgd0opP1ALXKh1Ux89QgjRcQWCGl8giMcfxBcwLv6AcZ+xzQjKoslsUljMRsBmMZmwWhRWswmr2YTNbMJqVljMMt2mEJGiOmPMM3bsWL148eJYV0MIIRrQWuPxB/H4gnj8AeO637geDMa6dgfHZAK7xYzdYsJuMWGzmHBYjduSiROidZRSS7TWY/e9P5bNnUII0Wn5A0FqfAHcvgAeX9D41x9sshmyowoGodYboNYbaHC/UmAPB2xWE06rGZfNgtkkgZsQrSVBmhBCHKJgUFPrC1ATClZqfH58/k4WjR0grcHtC+L2NUwR2iwmXDYzDquZOLsZp9UsGTchmiBBmhBCHCB/IEi1N0CN10+1x8iWdbYMWaR4/UG8/iDgA4yMm8tmJs5uMf61WTBJtk0IQII0IYRoUTCoqfb6qfL4qXL798sOtfh4ramo9VFc7aWk2kul20eF2zhWhdtHlceP2xfAW9dHLYjHFyCgQyM1CY/W1JhUuPO+wmYxOvE7rEZwE2c3E2+3EGe3kOCwkOqykeyykRpnI8lpbZdNjVpDtSdAtcdoLlUKnDYzCXYL8Q6LZNpElyZBmhBCNMLtCxgBlNtPjbflTFlFrY/8cjf55bV1/+6u8FBc5aGk2ou/kZGZJgXxdgvxdgsOmxm7xWgGTHJasVtMmEwKE4rQfyhl9AHzBvaOAPX6g5TX+thVVku1xwgkGxsEalKQ7LTRLdFOt0RH6GKne5KTXilOkpzWdhEMaQ01ngA1ngAFFR5MJuMcJTisJDgsWGU0qehCJEgTQgiMbFmV10+l20+l29dknzK3L8CW4mq2FtewNfxvSQ3ltb66fRSQnmCne6KD4VmJpMXZSY+3kRZnIzXOTqLTCDpcNjOmNg6MwiNIy2t9lNZ4Ka3xUVrtpbTGS3GVl4IKNz/nV/Dl+sIGwVyCw0LvVBe9Ulz0SnUxICOOfulxuGyx/ZoIBqGi1k9FrR8wsmyJDguJTisOqzmmdRMi0iRIE0J0WcGgptLtp7zWR4Xbt1+2zBcIsqWomvV7qli/p5L1BVVsL62pC24cVhN9UuM4vF8qvVNdZCU56JHkpFuiA5slNhkfpRQOq5GR65boaHI/fyBIUZWXXeW17CitYVtJLdtLavh6QxFVHiMgUkBWspOBmfEMyIhjaPdEBmbGxzSbFR5JWlDhwWYxkeS0kuS04rRJwCY6H5knTQjRpQSDmgq3j/JaH5Vuf4PAzO0LsHZ3Jat2lbNqVwVrCipDndwh0WFhULcEBmXGMyAjnr7pcWQm2Ns8ExZrWmtKqr1sKqpmw54qNhYal6IqLwBWs2JgZgLDeyQwvEciw7OSiLfH/ve+1aJIclpJdtokYBMdTlPzpEmQJoTo9LTWVLj9lNc0zJgFgpr1BZX8uL2MH7eVsm5PFYGgxqSgX3ocI7KSGNYjkUGZ8WQm2NtFn61YKa3xsia/gp/zK1mdX8HGwir8oXM1MDOe3Oxk8nolM7R7YsyyiGF2q4lklxGwxbouQrSGBGlCiC6n2uOntMZLea2vbkb/kmovP2wpYem2UpbvKKPaE0ABg7rFk9MzmRE9ExnWPZG4VmSHTCawmU1YQqMtzabQRRnLKJlMe9fGDK+ZGc681f/oDa+3GV5/M6g1weDe9Tn9QY0/oPEHg/iDGm87mBTX4w+wrqCKn3aUsXx7GWsLKglq43yMyk5iXN9UxvVNITOh6SbXaHDZzaS6jNGtMrWHaK8kSBNCdAm+QJDSGi9lNT48viBaa7aX1rJoUzGLNpewtqASgPR4G6N7pzC6VzK52ckkOq2NHs9qUdgtZmz1lj2yhdaujOWXvj8QxBfQeEMjPMMrGsRqiakar5+VOytYtr2UxVtLyS93A0ZGclzfVI7ol8qgzPiYZSNNJkhyWkmNs8V8MIQQ+5IgTQjRaYWbM0urvVS6jU7vW4ur+XJ9EV+vL2RXKGAYmBHPEf1TOaJfGn3TXA0CBqWMgQDhTvfO0L/tcW6xloQXaq/1GhPt1oaWpooWrTU7ymr5YXMJ328pYXV+BUENmQl2jh6YzjED02MasDmsJlLjbKS4bJJdE+2CBGlCiE7H6zeyZiXVXvwBza6yWr5cX8iX64vYXlKDScGonkkcOSCdI/qlkh5vr3usxaxw2Yz1JI1/O/ekqeGlq6q9fmo8xr/RyrhVun0s2lzCwg1FLNtehj+oyUywc8zAdI4fmkmftLjoVGQfJhOkhCb7lek8RCxJkCaE6DSqPH6KqzyhOc38fLW+kM9X76lryhyRlcixgzI4akAaKS4bQN2kqPGhmeztFvlSdvsCdRPgVnmiE7RVuf0s2lzM1xuK+HF7GYGgpn96HJOGZjJhUAYpcbbIV6IRcXYz6Ql2Eh2NN3sLEUkSpAkhOrRgUFNW66O4ykO1J8DyHWV8vrqAbzcV4wtoeqe6OGFoJscNzqjLmIUnPo13WKQfUgu0NjJtVW4/lR4/ta1YZeFQldf6+Gp9IV+s2cP6PVWYFIzpncLUEd0Z1zc1Jk3NdquJNGkKFVEmQZoQokPyBYIUVxlNmsVVHj5dXcBHK3ezp9JDvN3ChMEZnDA0k4GZ8ZhMKrSEkDEjvSwhdPD8gSCVobVF951PLhK2l9Ywf80ePl+zh5JqL6lxNiYP68aU4d3IbGZS3kgxmxRpoVUiLPI+EhEmQZoQokNx+wIUVnooq/GyalcF81bs5puNRfiDmlE9kzh5ZHfG90/DZjERb7eQ7LKS4Gifi4h3dOEls8LzzEWyWTQQ1CzeWsJHK3ezZGspAGP6pHBqTg/G9E6J+uTBSkFqnI30eLvMuSYiRoI0IUSHUO3xU1hpLEr+5bpC3lu+i81F1cTZzBw/NJOTR/agV6qLOLuZZJeNRIdFMh1R1NJSWm1pT6WbT38u4ONVuymt8dEz2clpOT04fmi3qK8qoBQku6xkJNilP6NocxKkCSHatUq3jz2VHvLL3Hy0Mp8PVuRTWuOjd6qL03OzmDA4g3iHhdQ4G8kuq3xRtgOBoK5byL3GE4hYOb5AkIUbinh/+S7W76kizmZm8vBunJabFfXJcpUy5lvLTJRgTbQdCdKEEO1ShdvHngoPm4uqeXvpDj5fvQdvIMiY3imcmZfF6N7GRLMpcTYS7JZOPU1GR+b2BSirMQI2fyAy3ytaa9buruT9n3axcEMRSikmDM7gnDHZ9E51RaTMpkiwJtqSBGlCiHalvNZHYaWbtbureHPJdv63rhCTUhw/NJMz8nrSLz2O1DhjDivpC9RxaK2pqPVTXG2Mwo2UPRVu3l22k49/LsDrD3JEv1TOHZPN0B6JESuzMeFm0MwEh7xPxUGTIE0I0S5Uun0UVHhYsaOc1xdv59tNxdgtJk4e2Z0z83qSneokLc5OsssqWbMOzu0LUFztpazGG7HBBuW1Pj74aRdzf8qn0uMnr1cyF47rxYispMgU2ASlIC3eRka8XfpIigMmQZoQIqaqPX4KKtys3FnBy4u2smhzCXF2M6fmZHFaThY9U5xkJNiJb8XC5qJjCQQ1pTVeiqo8+PyR+c6p9Qb4eNVu3vpxB2U1vpgFayYTZCTYSY+zyzxrotUkSBNCxITbF2B3uZtVuyp45fttLNxQRJzNzBl5PTkjL4usZCM4k2V5Oj+tjYEGRVUear2RSa25fQE+WrWbt5buDdamH9Gbod2j2wxqMSu6JTpIjdEKCqJjkSBNCBFVvkCQggo3a3dX8tJ3W1mwthCH1czpuVmcNdpo1pTpDLquSrePwsrI9Vtz+wJ8tDIUrNX6GN8/lUvG96VXlAcYOG0muic5JUMsmiVBmhAiKgJBTWGlh02FVby+eDtzf8rHpBSn5fbg7DHZ9ElzSSdrUafa42dPpYcqtz8ix6/1Bnh/+U7eWroTjz/ACUO7cdHhvclIsEekvKYkOi10T3LIjxLRKAnShBARV1LtZVtJNe/+uIs3Fm+n1md8KU4f35sBGfEyXYFoUo3XT0FF5IK18lofbyzezgcr8lEKTs/N4vyxvaK6pqtSkB5vJzNB+quJhiRIE0JETLXHz66yGj5ZtYf/fLOFoioPY/ukMOOovozKTqJbokP6nIlWqfH62V3ujlgz6J4KNy8v2sYXa/eQ7LQy/Yg+TB7eLarLiVnMiqwkJ0kua9TKFO2bBGlCiDbn9QfZXe5mydZSnvpqE6vzK+ifEcevj+7HEQPS6J7oIE764oiDYEzV4o7YAIP1BZX8++vN/JxfQd80F78+pj+5vZIjUlZT4uxmspKd8gNGSJAmhGg7WmsKqzys3V3Ji99u5dOfC0h0Wvnl+D6cktODrGQnSU7JEohDV1bjpaDCg9ff9sGa1ppvNhbz7MLN7Kn0cES/VH5zbH+6JUZvqSlpAhXQToM0pdRJwN8BM/BvrfXsfbar0PZpQA0wQ2u9tKXjSpAmRORUefxsL6nhnaU7eWnRVjz+IKflZHHxEb3olx5PerxNJqEVbUprTVGVlz2V7ohMiuv1B3lv2U7mLN6OBs4f24uzR/fEGsVJaa0WRc9kJwkO+XHTFbW7IE0pZQbWAZOBHcAPwEVa65/r7TMNuAYjSDsC+LvW+oiWji1BmhBtzxcwmja/31zC4ws2sKmwmtG9krniuP6Myk6ie6JDZloXEeUPBCmo9FBa7SUSX12FlR6e+XoTCzcW0yPJwW+PG8CYPiltX1Azkl1Wuic5ohogithrKkiLZWeRw4ENWutNAEqp14AzgJ/r7XMG8II2IsnvlFLJSqkeWuv86FdXiK6rpNrLuoJKnlu4hY9X7SbFZePmqUOYMqIbPZNdOG3Sp0ZEnsVsomeyk7Q4G7vKatt8cEFGgp2ZJw9j6bZSnvpyE3/67yqOGpDGFcf2Jy0+OlN2lNX4qHD76JHklIlwRUyDtJ7A9nq3d2Bky1rapyewX5CmlLoCuAKgd+/ebVpRIboqjz/AjpIaPlxZwNNfbaLS7eO03CwuGd+HAZnxpMiXiIgBh9VM/4x4ymt87CqvxR9o27TamN4pPHbRaN75cSdzftjO8u1LufSovkwd0R1TFJryg0HYWVpLWY2X7BSXzCnYhcUySGvsnb7vX1pr9jHu1Pop4CkwmjsPrWpCdG3hgQE/76rg8fkb+GFLKQMz4/nz6SMY2zdFmjZFu5DkspLgsFBQ6aa4qm2bQK1mE+eP7cUxA9N5fMEG/rlgIwvWFnL1pIFRW7Wg2hNgXUEl3ZMcpEcpkyfal1gGaTuAXvVuZwO7DmIfIUQbcvsCdRPS/mfhFgJac/nR/ThvbDa9Ul0ypYZoV0wmRY8kJykuGzvLaqlp4ybQrGQn95wxks/X7OGZrzdz7Ws/cv7YXpx7WHZU+o1pDfllbsprfWSnOGUy6C4mlp+2PwCDlFL9gJ3AhcDF++zzPnB1qL/aEUC59EcTIjLC2bNl28r4++frWbWrgpzsJK49fhA52UlkJNhl1KZotxxWMwMy4imp9pJfXtumo0CVUpw4rBtj+6Tw9FebeeX7bXy7qZjrTxxEv/T4tiuoGTWeAOsLqiSr1sXEegqOacAjGFNwPKu1vlcp9VsArfWToSk4/gGchDEFx2Va6xaHbcroTiEOjJE9q+HtJTv4zzdbsJgUlx/Tj9Nys+iV6pLJNkWH4gsE2VVWS0VtZJaY+m5TMY8v2ECl288FY3tx3mHZUW3+j3dY6JnslL5qnUi7m4IjkiRIE6L1Cis9rNhZxt8/W8/yHeWM6Z3CtScMZGTPJPnFLjq0SA0sAKio9fHUV5v437pC+mfEcd0Jg+mXHtfm5TTFZIKeyU6SXTJ4pzOQIE0I0YDXH2R7STXvL8vnqa82AXD5Mf04c7SRPZO+L6IzCAQ1u8pqKavxReT4324s4p8LNlLl8fOL8X04M69nVNcBTXJa6ZnijGqZou21x3nShBAxUl7jY1V+OX//bD2LNpcwMiuR604cTG6vZDISJHsmOg+zSdEr1UWiw8fOsloCwbZNTBw5IJ3hWUk8Pn8Dz32zhSVbS7nuxEFkJkRnaanyWh81Pj/ZKS7iZVBPpyOZNNG51JaBr9ZYEA8A1fB6mFKgg8bQKR0EtHEdTYszv2gdOqaq96+pXjn7lKWD9coIX1d769GgPL23jObsW36Dx9V7LuHytHFfIBhgT3kNCzZV88C3FVR6Nb/KdXJhThJZacnYHU4w28Fs3ec4+zz/cF33ux6+HTonJrNRR2WCYAACPgh4jH/9HmN/sw1MFuNfsxWUef/z1dj5UGqf+/cpu8E5auTcoEL1C9XRZN77ftBBo746sM8xQ5e651y/frrhPuH9ggEI+iDoN563Du49NybL3ovWRnl1xwzWq6MpVM/QMevvo0M95OvvZzIZjw1vq1/HBu89Gh4vWK98Ve85N3j+9c5rg3NLE8cL7C1/3/NT93cYpNHXuqm/qfD9Deqm6t1WDW+Hzr3f56GgrJLq6lqjmiYLOvQe0HXnV6H3+cxQOggYdVPh92a97VoptNZ8tqGSJ74rwmRSXH1kOpP6xYdeg6DxuAavQaic0LkwyjcbdVKm0HsiiAr6UUFf3SX8+aOVCQg/1nj+aYlOMhKcqLrXbd/XRe99TYL+0CWw/z5gvIeUee/fiMnc8Pw2OKa/4aXBZ0H4VIXf89bQ37vVuK+x996+7+Xw50f991Qw0Ph7tO7vst7fZ4PP6X3/hvf5jNv3s9WZAubIB7+SSRNdQ20puMtiXYt2qdYXYHupm3/9WMtba730TjTxlwkuxmU7SXWZUP4KqKqIfsUC3uiXKbokC9DTARVaU1jl3i8+OVQnZ0Pu1Dj++l0tf/3fHhZvKeWawxzE2aLTFFleA54iM92S7NhkHsO2YXNFJUhrigRponPZ9h388JRxXdf9D465HpJ7G9tXvBHaud4vwuNuhPhusGkBrP5vw193AFPuAWcyrJkHa+eFHl7v1/vUe8HqgpVvw4bP9v5C1QHj1+A5Txv7LXsFti6kwa9/iwNO/qtxzMX/gR3f1ytbGeVOe8DY/t2TkL+8YcYlPhNOmm1s//IBKFy393kF/ZDcm9Kjbmfpzhpc//szv/dv55Z4M0k2C9blZkz5w2DiTGP/z/4M1YXGL9nwL9fuI2H8Vcb2D2eCtzL0C9di7JeVB3nTje0fzTQyZPV/xfY5GvIuMu5758p6v7K18c+gyZB7Ifhq4O0r939NR5wFI882AvD3rw2de7X3l3bO+TB4KlTtgfn30uBXMMCoc6HPUVC2Db5+hP2yfqN/CdljoWgdLPz73vdG2BFXQvdRsHsFfP/U3vvDv96P/D9IHwQ7FsOPL+7NmAX9xvM/4U5I7Q9bFsKK1/dm7MLn94Q7jddww2ew6t2G2TWCcPwfwZ4Aq+fC2g8alq2U8d6wOGDVO8b7twEFpz1iXF3+Gmz71rgefv4Wx9731uJnYefShg93JhvvfTCe++6Ve7MYwQDEpcNJ9xnbFz4KpVv2fqEFg5CUDcdcZ9z+4l4o27r33AT9kDnMeP7h90518d4sIECPXBj/O+P6vJvAU9Ew09Z7PIz9lXH9v78Hv9c4Z8HQe6//BBhziVHXty6ve1giEI+ivNeJFPU/A+Wroec3f2RfFX2nUtFnCiZPOT0W3x/KclnqMkAVfaZQ3eMILNUFdPvx76BMZCnF63Emdmq4d/tkfleUy325RRy+7SlUXQbIjDaZKRlyEbUZOdjKN5G2+pW6lyycaSseciHe5P44ilaSvvoFVDgTi5HRKxhzPZ7kAcTt/p7U1S/VHTegzPgtFiyTbobEnrDpf/DTaw2TWwqYPAviMmDdx8Z7z3hzUPc3cspDxntv5duh9169vzuTCU75G1jssPIt2Pwlde/JcCbr9EeNQ373JGz5MvS+thp/A/ZEOOXB0Hvradi1tOFntjMVTvqLcf2bx6BwbcPMWUIPmHBzaPs/jPdWmNaQ0geOusa4veA+KN9ZL8MWMN57x1xvbP/wZqguCp2X0PF7Hmb87ceYBGmicwn4Qh/UIfs2BwYDe5vZ6n9R6322hz8MzLbw56XBZDE+lMIBxr7NlyaLEayFAxhlDgVqoV+1Zpvxxbhvc2SYxQa2eBo0bdnqjRgzW8Feb7vJBK70vdudKcaHLsYxg8pCjTWdV1ZU8thiN9dZ+pKZkUBGnMJqVpgIhPYPl2836qiDoeduMuobZovb+wUb8II/fD7rnf+gf+8HnTkcbIReC1cqdSc0HEg6kkLbzZA2sN7rFuJK3X97+NwFA8YvXWikaY+9wWL4McFw5/H6TdX1ms4sTvZ+k+m994f/NVnrld9Ikw4Yx7AnGM+77pj1+L31zo917/3KbJzzoN8IWIN+477wDwWz1XhvhJ8X4ed5EFma8A8EU72vAJM19N4O0/WeL0bgYzKDsu19byd0b3jcoM+oe7iM+llSWxy40vYGoGYrpPTbuz0uAzCxt4kZ428pzJ5olEm9p1z/b8MWD2Yvdc3XyrT3vQWQ3KfBczNpSE5JJxhno6yshqB131UEFNpkjJxUOogKeDH5alBBP8bflwmTv2bv3kE/4eBJ6SB9rEH+LxeuWQv3fefm6SQ/aXHGOVbhH1khpoAXa00BDd57Wu89vlJoZSFoc4aaNkPNsqHXJ2i243emo3QAFfpx6PP7Ka/ykJoAymQJfa7s0zxd97kU/lyp38xb731lj4f47vV+fIXqX9dsGK52uFnbbHyWhSVlQ+bwep8d/obbLfZ69QuVa0+ot91h7BMOsMJdJ8L8bvBW7W1JRhn31b044fqEPjMxNTx+XDfjbw/2BvjWff5uY0T6pInOZffKel/EXVutN8Dm0loeXlTLp1t85GaaufVIJ8MzXSQ65feZEGG13gC7K92RmarDo/nb97Us3Onn8B4Wbh7vIMkevaZIh8VEtySHNH8erPTBDX8MRIj0SROd37JXjCaXS+eCPa5es0hz2YbGMiL7dDpu1oF09G90Q+PHq7u570CA+p1b69V1n4EIhVUefthTxn2fbGBHqY+LDuvBZeN70ic9DrvFsn8WqX5ZjT6fxgYO1L9/n+exX52a0CCjuO/Ag3068DZWh/322a+Afeq87+vdijo2WmcavgaNlRned9/9mups39QxGuzb1GMaO19NHbORDvhNDaDZd2BMY+dx37o1GFhTv0M/ezPH9cvbdxBNU+erwXnY51y0eC6bf32dQG+t2VlaQ4V7n6UKGntv7FsPrVFodCMDguzAzFODzF1VyDPf7OCKjz3cfGI/RvbYf6UC1eD8h18Dk3HcRl/Xfc/5/vX0oqkKaLLinSQ563f+3+e1aea5NSirMY0NMKp//LrXf9/3D018ljX2/oImPxOaymqHjxs+ToP3eCPHa+wcmmM72l2CNNF5lO+AwtXgSGyYSu9CAkHNjtIa3l5awBP/24jLZubuM0YyaVgmWUkOWdZJiCaYgd7d4yiq8rC73H3Ai7W3tPupeX0Y3jONv360htv+u44ZR/XlzLyeDf4mI9GuFWoYZ1s1pCkbPeRzoEORIE10Ht7qUL8ea8v7dkJuX4ANe6p47PP1fPxzATnZSdw0dQg5PZNJcnXNcyLEgUqPt+OymdlWUoPP37ZhU/+MeP52fh5//3w9zy7cwur8Sn5/wiDiojS/WXGVlxpvgD5prqgsDi8OnbxKovPwVhkdjbvgr8SyGi/fbCjiujnL+PjnAs47LJsHzs3h8H6pEqAJcYBcNguDMhNIcLR98BRnt3DryUP51dF9WbS5mBteX8aWouo2L6cptV7jx1yVJzLrmoq2JUGa6Dy8NWBrHyNyokVrTX55Le8v28Xv5yxjV1ktt00bxu9PHMTgbgmytJMQB8lsUvRNj6NbUtv3SVJKcdbobP5y1ijcviB/eHM5C9buafNymuIPaLYUVVNY6Wl5ZxFTEqSJziOlD/Q+Kta1iBp/IMjmomqemL+RP72/ihSXjYfPz+Pcw7LJTnFJvxMh2kBmgoO+6a6IrI05IiuJRy7IY1BmPA99uo5nvt7U5stWNUVr2F3uZltxDcEolSkOnEzBITqPqkJjLh1HYqxrEnFuX4C1uyu5/+O1LNxQxHGD0rlhymCGdEvEaZPsmRBtzeMPsK24Brcv2PLOB8gfCPLM15uZuyKfvF7J3DRlCInO6HVTcFhN9EmLw2aRvE2sNDUFh7wiovMI+rtEf7TyWl9d/7NvNhRx2VF9uev0EYzMSpIATYgIsVvMDMiIJzkCfTwtZhNXThjAtccPZOXOcm54Yxmbo9hPze0LSj+1dkqCNNF5vHcV/Pe6WNciovZUuJn3Uz7XzVnGngo3d542nCsm9Kd/RjwWGa0lRESZTIpeqS66Jzla3vkgTB7endln5+ALaG56czkLNxRFpJzGBIJGP7WiKumn1p7Ip7roPMp3gqc81rWICK0120tqeO6bLdzx3koSHFYeOj+Xs0b3pEdS1xosIUSsZSTY6ZPuMlYYamNDuifw8Pl59EuPY/ZHa3jth21Eq1uS1pBf5mZHaU3UyhTNkyBNdB6+WrBGfvmOaPMHgqzfU8X9H63hnws2MrpXMn+/MI8JgzNJdnXNSXuFiLVEh5UBGfER6ceVGmfj3jNHMXFIBi8v2sZDn67D62/7vnBNKa32sbmoGn8gemWKxslktqLz8Ne2m0Vx24rbF2B1fgX3frCaxVtLOSM3i6smDaR/RpxMRilEjDmsZgZkxLGtpIZqT6DlBxwAm8XEDScOpneKixe+28rucje3TxtGSlx0fphVewJsLKymT5oLh1X6usaKfMqLzsPnjspCuNFS5fHz7aYirp+zjKXbSrlq4gBunDqEwd3iJUATop2wmE30S48jJa7tBxQopThvbC9uPXkoW4qrueGN5Wwuqmrzcpri9QfZWCgDCmJJPulF59F7PHTPiXUt2kRptZePV+7m+jnLKaz0cNdpI5hxdF96pcr8Z0K0N0opslNcEZn4FuCoAenMPjsHrTW3vLWCJVtLI1JOY4JB2FJUTUm1N2plir0kSBOdQzAAx98OeRfHuiaHbE+lmzeW7ODWt1dgt5h44LxczsjrSWZCZEaUCSHaRmaCg96projMBDQwM56Hzsule5KDWXNX8fGq3W1fSBO0hp2lteSX10atTGGQIE10DsFwOr7jZpm01uwsq+WZrzZz37zV9EuP45EL8pg4JEPW3xSig0hyWemXHheRFQrS4u3MPnsUeb1S+Mf8Dbzw7ZaojsIsqvSyrVhGfkaTBGmic6jIh/+cAj/NiXVNDkowqNlcVM1DH6/lX19u4vB+qTx4Xg6H9UnFZZPxPUJ0JHF2CwMyIzODv8tm4Y+nDGPK8G68sWQHD326Dl8UR2GW1/rYJCM/o0Y+/UXn4KkAX3WHXHHAHwiyrqCK2R+u5sv1RZw8sjs3TB5M/4z4iPwaF0JEnrFCQRxbiqup9bZtQGMxm7h60kC6JTp48butlFR7uX3aMOLs0flKr/EE2FRkjPy0W2TkZyRJJk10Dp5K41+rK7b1OEBef5CfdpRz85vL+XJ9EZce2ZdbTx7KwEwJ0ITo6CxmE/3T44l3tH3wpJTi/LG9+MPkwfycX8Gt76yIaud+jy/Ixj3V1HrbduoR0ZAEaaJz8IaGpdviY1uPA+D2Bfhhawk3vL6MNbsr+cPkwfxu4gB6p8XJCE4hOgmTSdE3zRWRNT8BJg7J5M5Th5NfXstNby5nV1n0OvcHgpqNhVVUun1RK7OrkSBNdA7e0GLEHWQy21pvgK/XF3HDnGXsDq3BOX18n4itCSiEiB2ljDU/0xMiMxHtmN4p3HvmKNy+ADe/9RPrCyojUk5jtIatxTWU1cgUHZEgQZroHBxJMGQaJPaIdU1aVOXx8+nPu7nxzeXUeAPce+Yozhzdk9QozSQuhIiNHknOiM2lNrhbAvefk4vdYuK2d1ewdFv05lLTGraX1FJYKYuztzUJ0kTnkNofJt1m/NuOVbh9/Hf5Lma+vQKLycQD5+Zw0sjuJDpkig0huoLMBAdZyZHJmPdMcfLAubl0T3Rw99yfWbihKCLlNGV3uVvmUmtjMQnSlFKpSqlPlVLrQ/+mNLHfFqXUCqXUMqXU4mjXU3QgAT/tfY608hofb/ywnTvfW0lanI2/nZ/LxCGZURuRJYRoH9Li7fRKdUZkMHpqnI37zs5hULcE7v94DZ/+HL1Jb8GYS217icyl1lZilUmbCXyutR4EfB663ZRJWus8rfXY6FRNdEjLX4WnjoOakljXpFGl1V5e/G4r985bTd+0OB6+II/x/dNk4WIhuqhkl43eaZFZnSDebmHW6SPIzU7m0S828N6ynW1fSDPKanxsk0CtTcQqSDsDeD50/XngzBjVQ3QWvmpjaah2OHCgqMrDM19v5qFP1jK8RyIPnZ9DXq/kiEx0KYToOBIdVvqmx0UkUHNYzfzx1OEcNSCNf3+9mVe/3xbVoKmi1s+W4hqCQQnUDkWsviW6aa3zAUL/ZjaxnwY+UUotUUpdEbXaiY7HWwMosLSv0ZF7Kt08uWAj/5i/gdG9U7j/3BxGZCVjMUuAJoQwsl79M+IwReAjwWo2cfPUoZwwNJNXvt/Gv7/eHNVArcrtZ1NRNQEJ1A5axDrDKKU+A7o3sun2AzjM0VrrXUqpTOBTpdQarfWXTZR3BXAFQO/evQ+4vqIDCwbA7zYCtHY0v1hBeS2PfrGBlxdt46gBadx12ggGZsZjkklqhRD1uGwW+qfHszkCAY3ZpLj2hEG4bGbeX74Lrz/I7yYOwBSlz8pab4BNhVX0TY/DKj9OD1jEgjSt9YlNbVNKFSilemit85VSPYA9TRxjV+jfPUqpd4DDgUaDNK31U8BTAGPHjpWwvSsJ+sFf266aOneX1/Lgx+t4c+kOjh+SyR2nDqNfukxSK4RonNNmpn9GHJsK2z5QMynFb47tj91i5s2lO/AHg1w9aVDUVjVx+4JsKqymX3pk1jPtzGJ1tt4HLg1dvxR4b98dlFJxSqmE8HVgCrAyajUUHUfQD1mjYeQ5sa4JYARof/1oLW8u3cFJI7pz1xnD6Z8RLwGaEKJZDqsRqEUieFJKccmRfbj48N58tnoPj3y2LqrNkF5/kE1FVXj8sozUgYjV2P/ZwOtKqcuBbcB5AEqpLODfWutpQDfgndAXmwV4RWv9UYzqK9qzoB8GHA+2hFjXhN3ltfxl3hreX76LU0f14NZpQ+mZ0rHWExVCxE44UNtcVI0/0LZBlFKKiw7vjcWkeOG7rfiCmhsnD45aH1mfX7O5qJq+aXEysr2VYhKkaa2LgRMauX8XMC10fROQG+WqiY4oGABfDVhi29yZX1bLPR+s5oMV+Zyem8WtJw+lR3L7aYIVQnQMDquZfumRCdQAzhvbC6vZxDMLNxMIBrl56tCo9RcLB2r90iVQaw1pHBYdXzAAH86E9/8vZlXIL69l1tyf+WBFPmeN7slt0yRAE0IcvHCgZjFHppvEmaN7cuVx/fluUwl//WgNvkAwIuU0xh/QbCqsptYrTZ8tkSBNdHxBf2h0Z2yCot3ltdz13io+XLmb8w7LZuZJQ+ieJAGaEOLQhAO1SHXwPzUni99OGMCizSXc/3F0A7VA0MioSaDWPAnSRMcXDtJiMLqzoKKWP//3Zz7+uYDzDsvmpqlD6CYBmhCijURyMAHAKaN61GXUHvh4Lf4oB2qbiqokUGuGBGmi4wv6weeO+kS2hZVu7p67mg9X7uacMdncfNIQMhPb12S6QoiOL9KB2qk5Wfzm2P58u6mYBz6JbqAWDCKBWjMkSBMdX3gy2yhm0opCAdrcn/I5M68nM08eQkaCBGhCiMgIN31GYmUCgNNzs/j1Mf34ZmMxD8YoUKvx+qNWZkchQZro+IJ+yL0A+k2ISnElVR7uDU2zcXpuFrdNGyoBmhAi4pw2c2hS7Mgc/4y8nlx+TD8Wbizm4c/WR3UetWAQNhdVS6C2j1jNkyZE2wn6IW86xGVEvKjyGh+zP1rDOz/uZNqoHtxxyjBp4hRCRI3LZqFvehxbiqqJxDKcZ+b1JBDUPPfNFmwWxTXHD4raElLhQK1/ejxOm0zPAZJJE52B3wNVe4x/I6jC7eOhT9by+uIdTB3ejT+dNlwCNCFE1MXbLfROc0Uso3bOmGwuGteLz1bv4akvN0V1UfZwoOb2SR81kCBNdHTBALjL4JXzYdU7ESum2uPnsc/X88J3W5k4JIM/nzmCbhKgCSFiJNFhpVdK5AK1iw7vzdmje/LBinz+882WqAZqgaAxj5oEatLcKTq6oH9vBs0ameWXarx+/vXlRp7+ajNH9k/jL2eNpHuiTLMhhIitJJeVoHayo7S2zY+tlGLGUX3x+IO88+NOHBYTFx/Rp83LaUp4HrWuvjKBBGmiYwv6wR/6gIrA6E63L8Dz32zhsc83MKZ3Cn89J4esZFmLUwjRPqTE2QhoTX6Zu82PrZTiiuP64/UHefWH7TisZs4ek93m5TTFHzACtf4ZcdgtXTNQkyBNdGwRzKR5/UFe+2EbD36yjuFZiTx4Xg690yRAE0K0L+nxdvwBTWFl2/fLNSnF/00aiNsf4D/fbCHObmHqiO5tXk5T6gK19Hhslq7XQ6vrPWPRuYTnSIM2DdL8gSDvLdvJvR+spn96HH87P5f+GfFtdnwhhGhL3ZMcpMRZI3Jss0lx/YmDOaxPCo/P38DXG4oiUk5TwouyR3PZqvZCgjTRsQX9kNADxl8Fqf3a5pBBzac/F3Dne6vonuTk4QvyGNI9sU2OLYQQkZKd4iLJGZlAzWo2MfOkoQztkchDn6xl6dbSiJTTFK8/yJai6qhOstseSJAmOrZgABK6Q875RrB2iLTWfL2hiJlvryDBYeHh83MZkSUBmhCiY+iV6iTOHpn+Ww6rmTtPHU6vVBd/+XA1q/MrIlJOU9y+IFuKq6M6yW6stRikKaVSo1ERIQ5K0A/uCijbBvrQh2sv3VbKH95YDsCD5+VwWJ8UVJQmchRCiEOllKJPWhxOW2RyMPF2C38+fQSpcTb+PHcVm4uqI1JOU2q9RqAW7CKBWmtexUVKqTeUUtOUfFuJ9iboh42fw+uXQG3ZIR1qdX4F1722jGqPn9nnjOKYgRkSoAkhOhyzyQjUItXRPsVl454zRuKwmPnT+yspqGj7kaXNqfEE2FpSE9W522KlNa/gYOAp4JfABqXUX5RSgyNbLSFaKRgAX+gDwnbwAwe2Fdfw+9d+ZHeFm1lnjGDysG6YTBKgCSE6JqvZRJ80F+YIfY5lJjr48+kj8AaC/On9VZTX+iJSTlOq3P6IzA/X3rQYpGnDp1rri4BfA5cC3yul/qeUOjLiNRSiOUH/IY/uLKr0cMPry9iwp4rbpg3jjLyeWMzSXVMI0bE5rGb6pkduVYI+aXH88ZThFFZ6mDV3VdRXCCir8bGzrHMHaq3pk5amlPq9UmoxcCNwDZAO/AF4JcL1E6J54SDNbAfTgXeWrXT7uPWdFSzeWsr/TRrIxUf0xioBmhCik3DZLPRKjdz8jiOykrhp6hA27Kli9kdroj76sqTKG/Xm1mhqzbfRt0AicKbW+hSt9dtaa7/WejHwZGSrJ0QLwkGaxQ4c2M9Fty/AvR+s5tOfC7jo8F7836SBXXZWayFE55XktJKVHLm1hsf3T+OqiQNZsrWUx+ZviHpfsT0VHoqq2n4i3/agNSsO3KG1fr3+HUqp87TWb2it/xqhegnRsmAA0DDwROg2AlTrM2C+QJDH52/gtR+2M2V4N26bNqxLrw8nhOjc0uLt+CK0KgHA1BHdKan28sr320h12bj0qL4RKacp+WVuLCZFsssW1XIjrTXfajMbue/Wtq6IEAcs6Df+7T4KBk2htR0vgkHNK4u28vj8DYzrm8J9Z48iwRGZCSCFEKK96J7kiNhktwAXjuvFySO78+bSHcxbkR+xcpqyo7SWSnd0BzBEWpOZNKXUycA0oKdS6tF6mxIBf6QrJkSLwkFayWYwmSB9SIsP0Vrz4cp87v1gDYMyE3j4/DzS4u0RrqgQQrQP2SlOvIEgtd627+SvlOLK4wZQVOXhX19uJD3ezuH9ojfVqtawtbiGARnxOG2do2WkuUzaLmAx4AaW1Lu8D0yNfNWEaEE4SFv4CHz5UKsyaT9sKeHWt1eQFm/j7xfmkR3BDrVCCNHemEyKvmmuiM2hZjYpbp46lP7p8dz/8RrWF1RGpJymaA2bi6rx+KM70jRSmnyVtNbLtdbPAwO01s/Xu7yttY7uol1CNCYY+iP0e8DqoKWBAxv2VHLda8vQwN/Oz2VoD1nuSQjR9VhCc6iZIjSQPbx8VJLTyqy5P7M7yqMvA0HNlqKaTrEge5MvkVIqPFjgR6XUT/teolQ/IZoWzqT53WBxNJtJ21Pp5ppXl1FY5eEvZ41ifP+0KFVSCCHaH4fVTJ+0uIjNoZYSZ+Ou00fgD2ruen9V1PuKef1BtnaC5aOai6N/H/r3VOC0Ri5CxFY4SPPVGkFaE5m0arefP7y+nNX5Fdxy0lBOGdVDlnsSQnR58XYLWcnOiB2/V4qLO04ZRkGFm3vnrY56ZqvWG+zwy0c1OXBAax0emmEC8rXWbgCllBPoFoW6tV9ag7vcyNwoExD+VxtNcDoAwaARRChlBBBWJ5j3GVXj94C3GrxVxtJGygRmC5jCF+ve7JBSoXLCwUX9+wFlNiZzrfs3dH8wYNSj7hIw6q+Dey9glK1Mex9bvw7m1szUEn5OXgj6jHqYbTSaT9faeO4Bj1GfBudRNdwvzGQxzmH97XWZNE+TmTRfIMif567iq/VFXH5MXy49qq8s9ySEECGpcTY8/gBFld6IHH9EVhI3TB7M/R+v5bEv1nP9iYOj+iM5vHxUJCf0jaTWfPu+ARxV73YgdN+4iNSoI9BBKN184I9TZiPQMJnBW2MEM5GiTKEgpy1+QSgjwDRZ9gZz9QOrgA8CXuOyb3kmqxGsma3GefN7Gt+vVdUwgy0udIk3ygU47iaIS99vnrRgUPPkgg28vngHJ4/szo1ThshqAkIIsY8eSU48viCV7shM3HDsoAx2ldXy0qJt9Ex2csG43hEppyllNT7sFjeZiZGb0DdSWhOkWbTWdSG21tqrlOpcs8VFiw4YWbOolNWWaWVdLwg7QEGfcWmLeFQHwFNhXOrre3ToSsNfZ+8v38Ujn29gdO9k7jt7FE7bAWQEhRCiC+mV6mJjYRUeX2SaJM8f24udoUAtK9nJsYMyIlJOUwoqPFjNJlLiOlb40pq0QqFS6vTwDaXUGUDRoRSqlDpPKbVKKRVUSo1tZr+TlFJrlVIblFKNTaorurqgH7Yvgqo9DZo7f9hcwh3vriQr2cmjF+Z1ulmohRCiLZlNij5pLswR6g6ilOKa4wcxvEciD3+2jjX5FS0/qI3tLKulytOxpnltTZD2W+A2pdQ2pdR24BbgykMsdyVwNvBlUzsopczA48DJwHDgIqXU8EMsV3Q23ir48BbY8nVdkLa1uJrfv/YjJgV/vyCPXqlxMa6kEEK0f3aLmd5proiN+LSaTdw2bRjp8Xbumbc66gujG5PdVuP2dZw51FoM0rTWG7XW4zECpeFa66O01hsOpVCt9Wqt9doWdjsc2KC13hRqbn0NOONQyhWdkC/0R24x+hqU1Xi55tUf2VPp4b6zRzGmT0oMKyeEEB1LpEd8Jjmt3HnqcPzBILPm/kyNN7qZrWAQthRXd5g51JqbJ+0XoX9vUErdAFwB/Kbe7UjrCWyvd3tH6L5GKaWuUEotVkotLiwsjHjlRDvhDwVpVidef4Bb3vqJn3aU84cpg5k2qkds6yaEEB1QapyN1PjIdRHJTnFx68nD2FFawwMfryUQ5bnMfH7dYeZQay6TFm4jSmjkEt/SgZVSnymlVjZyaW02rLGEa5NnVGv9lNZ6rNZ6bEZGdDskihgKBWna4uBvn67n41UFXDiuF785tr/MhSaEEAcpK8mByx659S9zs5O58rgBLN5ayovfbYlYOU2p9QbZXloT9XIPVHPzpP0rdPUzrfXC+tuUUkc38pB9H3/iIdZtB9Cr3u1sjPVEhdgr1Ny5cJfmqcUbOXJAGneeOhyLTLUhhBAHTSlFn1QXGwqr8Pkjk3GaNqoHW4qreWvpTnqnujh+aHSnYK2o9ZNfXkuPpMg17x6q1nyTPdbK+9raD8AgpVS/0JQfF2Is7i7EXqn92XjEPdy8LJ3eqS4eOT8Xl12m2hBCiENlMZvokxq5paMArji2Pzk9k3jsiw0xGfFZVOmlpDoyE/m2heb6pB2plPoDkBHuhxa63AUcUg5UKXWWUmoHcCTwgVLq49D9WUqpeQBaaz9wNfAxsBp4XWu96lDKFZ1Pvs/BjKUDqTYl8OhFo+nWjn8RCSFER+O0mclOidznqsVs4paThpKRYOfeeavZUxndEZ8Au9rx1BzNZdJsGH3PLDTsj1YBnHsohWqt39FaZ2ut7VrrblrrqaH7d2mtp9Xbb57WerDWeoDW+t5DKVN0PrW+APd8sIZRNd9x//EucrKTY10lIYTodJJdNtITIjeQINFp5Y+nDMcbCHLvB6ujPkVGe56ao8kgTWv9P631n4HxWus/h67fDfxba70+ajUUohHBIPx5QRkpxT/yT+sjTOkjTZxCCBEp3RMdxEVwIEGvVBc3TRnC5qJqHvtifdQXRQ8GYWtxTdRHmrakNX3S7lNKJSql4oCfgbVKqZsiXC8hmvX8snJeW+1hbLrxy0dZpZlTCCEiRSlF71QXVkvkOqiN7ZvKL8f34cv1Rbzz486IldMUrz/ItpKaqAeIzWlNkDZca10BnAnMA3oDv4xkpYRozsJtNdz3bTW5mWZO7hf6wLC4YlspIYTo5CxmE71TI7ciAcC5h2Vz9IA0nv92C0u3lkauoCZUuf3sKo9+v7imtCZIsyqlrBhB2ntaax/NzFcmRCRtL/dy/SflJNkVj56cgl17wWwFszR3CiFEpLlsFnokOSJ2fKUUvz9hML1TXdz/yRryy2sjVlZTSqq8FFd5ol5uY1oTpP0L2IIxue2XSqk+GIMHhIiqGl+Aaz4spdStefjERPok2YzJbC0OGp/7WAghRFtLi7eT7LJG7PhOm5nbpw1Hobj3g9XUeqPfoT+/3N0uRny2Zu3OR7XWPbXW07RhKzApCnUTok54oMCyPQFmHhXHMX1DC2LkXAAn309E8+9CCCEa6JnsxGmL3KTh3ZMc3Dx1CNtLa3jk83VR7yemNWwrron5Gp+taiNSSp0CjADq5zhnRaRGQjTixZ/KmbPawzlDbFyWl7R3Q0J34yJBmhBCRI3JpOiV6mLDniqCEYpjRvdOYcZRfXl24RbeWrqTcw/LjkxBTQgENb5AEGsMV7BpsWSl1JPABcA1GG1K5wF9IlwvIep8t72WvyysJifDzKxJKZjqv2u3LYJt3yLNnUIIEV12i5nslMgO2jozryfHDkrnxe+2sHx7WUTLao9aEx4epbW+BCgNzZV2JA3X1BQiYnZX+bjukzISbYrHTk4hzrbPPD0/zYEfX5ZMmhBCxECS0xrRiW6VUlwzaRDZKS7u/3hNTFYkiKXWBGnhoRU1SqkswAf0i1yVhDB4A0F+/1EpRbWaBycn0ie5kQ8Cfy1YnUgmTQghYqN7ogNXBCe6ddrM3HbyMPxBzewP1+D1x7afWDS1Jkibq5RKBh4AlmKM9HwtgnUSAq3h/q/LWLTLz3XjXEwIDxTYl99jjO6UTJoQQsREeKJbsylyn8M9U5xcf+Jg1u+p4qmvNkWsnPamNaM779Zal2mt38LoizZUa/3HyFdNdGVz11bxzHI3k/tZ+e3YpKZ39LnBYkcyaUIIETtWs4leqZFd+WV8/zTOOyybj1ft5tOfd0e0rPaiydGdSqmzm9mG1vrtyFRJdHVrizzctqCSvkkmHjgxFYu5mQDM7waLUzJpQggRYwkOK90S7RRURG4i2OlH9GH9niqe+N9G+qXHMzAzPmJltQfNTcFxWjPbNCBBmmhzlZ4A135USkBrHjsphWRnC/0cTn9UMmlCCNFOZCY6qPYGqHJHZiJYs0lx45QhXDdnGbM/Ws0j548m3tF5V5xp8plprS+LZkWECAbh9s9LWVsS5MHjExjZrRVLjySF5s1RsZvHRgghxF7ZKU427KnCH4jMBLRJTiu3nDSEW99ewSOfr+P2acNQnbQ1pclvNqXUI/Wu/36fbc9Frkqiq3pheTnvb/By8Qg754xIaPkBQb8xBUfROmnuFEKIdsJqNpGdEtn+aUO7J3LZ0f1YtLmEd37cGdGyYqm59MNx9a5fus+2nAjURXRhy/PdzP6mmlEZZv44IaV1MZe3Br57AvJ/Qpo7hRCi/UhwWMlIsEe0jNNyenD0wHSe/3YLq3aVR7SsWGkuSFNNXBeiTZXW+vn9J2U4LIq/T03GaWll06U/NKmhTMEhhBDtTrdEe0TnT1NKce3xA+me6OD+j9ZSWuONWFmx0ty3oUkplaKUSqt3PVUplQpE7qyLLiUQ0Mz8vJSt5UHunZRA/9QD+OUVDtKsDuR3hBBCtC9KKXqlRHb+NJfNwsyTh1Hl8fPgJ2sJBKO7EHukNRekJQFLgMVAIsZEtktCl1Z0GBKiZc8uq+DjTT5m5Dg4ZfABDqX2h4Z5SyZNCCHaJZvFRM8I90/rlx7H7yYM4Kcd5bz2w7aIlhVtzY3u7BvFeogu6Icdbh74rpox3czcckzygR/AH1qxzCKZNCGEaK+SnFbS4m0UV0WuOfLE4d1YsaucOT9sZ2RWErm9kiNWVjTJvAUiJkpq/Vz/aRkJVsUjU1NwtLYfWn0Zw2D6G9B9lGTShBCiHeuR5MBhjWzI8bsJA+iZ4uTBTztP/zQJ0kTUBYMw87NSdlUFue/4BHo3tnB6a5itEJdhTGYrQZoQQrRbSil6pboi+lHtsJq5ZepQajwB/vbpOoK64/dPkyBNRN1/lpXzyWYfM0Y5mDLwEJb0KFoHS54DTyXS3CmEEO2bw2qmR1IrJik/BH3T47jiuP4s217GG0t2RLSsaGgxSFNKDVBK2UPXJyqlrlVKJUe8ZqJTWp7v5oFvq8nLPMh+aPUVrjWCNL9bMmlCCNEBpMXbSXRGdhmnKcO7cdygDF5ZtLXDz5/WmkzaW0BAKTUQeAboB7wS0VqJTqncHeD6T8uwWxQPT03GfjD90Orz1ZsnTTJpQgjRIfRMdmIxR+4zWynF/00aQLdEBw98vJbyWl/Eyoq01nxLBrXWfuAs4BGt9fVAj8hWS3Q2wSD8aUEpm8qCzDougX4pbTATdd08aU7JpAkhRAdhMZvoleqKaBkum4VbThpKea2PRz5bh+6g/dNaE6T5lFIXYSwNNTd0nzVyVRKd0eurKnh3nZcLh9k5fegh9EOrz+8GZQaTBcmkCSFExxFvt0R82agBGfH86uh+LN5ayn9/yo9oWZHSmiDtMuBI4F6t9WalVD/gpchWS3Qma4s83P11FUPTTK1fl7M1/O7QagNIJk0IITqYbol2nLbIjl88NacH4/qm8J+Fm9lUWBXRsiKhxbOjtf4ZuAVjxQG01pu11rMjXTHROdT6gvzhkzK0hr9NTiGuLf8gx/8OLp4TuiFBmhBCdCRKKbJTIjsth1KK358wmESHlfs/XovbF4hcYRHQmtGdpwHLgI9Ct/OUUu8fSqFKqfOUUquUUkGl1Nhm9tuilFqhlFqmlFp8KGWK6NMaHlhYxsqiADOPimN4Zhuntk0WsIWaTpXMJiOEEB2Nw2qme4Sn5UhyWrlhymB2ldXy1FebIlpWW2vNN9tdwOFAGYDWehnGCM9DsRI4G/iyFftO0lrnaa2bDOZE+/T5pmqeW+FmSj8rv8hJavsCVv8XVrxhXJfmTiGE6JDS4+3EOyI7LUdudjLnHpbNpz8X8NX6woiW1ZZaE6T5tdb7TjRySMMktNartdZrD+UYon3bXenjtvkVdHMp/nJ8CqZIJLo2LTAugDR3CiFEx5Wd4sRsiuzn+MWH92ZItwQen7+Bggp3RMtqK6356lyplLoYMCulBimlHgO+iXC9wjTwiVJqiVLqiuZ2VEpdoZRarJRaXFjYcaLkzsgXCDLz8zKKazV/PSGR9LgI/ULyu40loUAyaUII0YFZzSZ6JjsjWobFbOLGqUPQwEOfrCUQbP/TcrQmSLsGGAF4gFeBCuC6lh6klPpMKbWykcsZB1C/o7XWY4CTgf9TSh3X1I5a66e01mO11mMzMjIOoAjR1p77sZIF23z8OtfBcX3jIleQ3w2W8B+1BGlCCNGRJbmsJLsiO8NX90QHv5swgNW7K3ljyfaIltUWWkxxaK1rgNtDl1bTWp94sJWqd4xdoX/3KKXewegb15p+bCJGlufX8tD3xrJP1x+ZHNnC/B7JpAkhRCeSleyk2uvH549clmvikEwWby3l1e+3kdcrmaHdEyNW1qFqMkhTSv2XZvqeaa1Pj0iN9pYfB5i01pWh61OAWZEsUxyaKk+AWz4vx2qCB05MxmGN8IjLgC+0JBRIJk0IITo+s8mYlmNzYXVEy/nthAH8nF/B3z5dxyMX5OGyRXbgwsFqrlYPRqpQpdRZwGNABvCBUmqZ1nqqUioL+LfWehrQDXhHGRkSC/CK1vqjSNVJHBqt4cFvylhTEuTeifEMSo/sTNKAMUeaDhrXJZMmhBCdQrzdQlq8jeIqb0TL+MPkwdz2zgr+/dVmrj1hUMTKOhRNBmla6/9FqlCt9TvAO43cvwuYFrq+CciNVB1E2/picxUvrPQwpZ+VC0dGMXUcnh9NgjQhhOg0uic6qPL48fiCEStjRFYS54zJ5o0lOzisTwpHD0yPWFkHqzWT2Q5SSr2plPpZKbUpfIlG5UTHsKfKyx3zK8l0Ke6ZlIw5GvPKBv2wYDZsX4Q0dQohROdiMimyU5wR//198eG9GZgZzz/mb6C4yhPZwg5Ca75O/wM8AfiBScALwIuRrJToOPxBzZ8WlFNQo5k1IYHM+MiOzNlbsBvWfQSl22S1ASGE6IRctsgvwm4xm7hx8hB8gSAPf7aOoG5f03K05tvNqbX+HFBa661a67uA4yNbLdFRvL6ikg83+Zg+ws7kAfHRK9gXmojQYpemTiGE6KQyEyK/CHvPFCe/PqY/y3eUM/en/IiWdaBa88zdSikTsF4pdXWo039mhOslOoD1RW7u+7aawakmbj4qObqxkj8cpDmQ5k4hhOicorEIO8DUEd0Y2yeF57/ZwvaSmsgWdgBaE6RdB7iAa4HDgF8Cl0awTqIDcPsC3D6/Ak9Ac9+kRBIc5uhWIBykWR2SSRNCiE7MYTWTGeFmT6UU1x4/CLvVxN8+XYc/ELkBCweixSBNa/2D1rpKa70DuAE4R2v9XeSrJtorreGZpRV8n+/nd6OdjMlyRb8SQT/Y4sDqRDJpQgjRuWVEodkzJc7G/00cyIbCKuYsbh+rETT5jJVSdyqlhoau25VS84GNQIFS6pBXExAd1/LdtTy2pJbR3cz87vDE2CSyMobCjA8ge5xk0oQQopOLVrPn0QPTmTQkg9cXb2ddQWVkC2uF5sLSC4C1oevh5s0MYALwl0hWqsvRGqoKIBg4uMcH/XsndY2wKrefO+ZXYFbwl0lJOCxRbuZslARpQgjR2UWj2RPgyuMGkBpn52+frqPWe5Dfy22kuSDNq3XdWNSpwGta64DWejWtWPNTHKDvn4aXzob5f4GNX4CnlRG8twqePwPe/BXsWBzRKgaC8I8fKlhZFOC6w10My3S0/KBI2bUMPrsLaoolkyaEEF1ENJo94+wWrjtxEDvLannok7UtPyCCmnumHqXUSKVUBsb8aJ/U2xaDTkidUOVuqNhpBBl5FxtNd9u+g89nwQtnwGd/bvxxWsPuFcZ1WzyM+aXRkX7ejfDRbVC+IyLV/XZ7Fc8sd3NMtoVLchOgugh+fBm2f29k8w5U6VYo2Ww8nwNVsQM2LTCyjzJPmhBCdAnRavbMzU7m9NwsPl5VQFlN5JanaklzGbHfA29iNHE+rLXeDKCUmgb8GIW6dXxBP9SWgStt/2xP/nL49E5IyobT/wGp/eH4O4ygY89q2Pbt3sXDtYYPboD0QdBtJKx8y3j86Y9B91GQeyGMPBtWvAU/vgBvzIDzX4DErDZ7KiU1Pu78XxVxVsWfJyRhX/cBLPoX+EKL4DqS4LDLYMSZLR+scA0sed54jgAJWTB2BgyasnefYMBoAi7bZlz6T4T4TChYBRvnQ/EGYz+ZgkMIIbqUcLNnQUVkVwi45Mg+3DR1MMkuW0TLaU5za3cuAoY2cv88YF4kK9UplGwyMmKlW2DA8XDCncb9hWuNIOybx4wgasItDQM4kxm6jzQuYd4qMFlg5dvw0+tgT4RjrofM4Xv3Mdsg7yIYPAU2f7k3QNv2LXTPMUZCNiXoNwKhks1GWcPPMO7f+g3YE/GlD+Vv31awqSzI7IlxDEizw/pdkDkUjrzayAZu/MII1MDI5C1+FtIHQ8YQI7i0hSa61Rq+fNAIwMb+CpwpsGUhmO17H/vJHcYxA769deyRawRpZdtg7TxAQdpAsLmkuVMIIbqYjAQ75bU+3BFc29NuMZMWH/k+cM1Rup0tgdAWxo4dqxcvjmD/LE8VvHgmDDsd+h7dsLlNa/j5Xfjun0ZgMvJcSOkNfY81+pk9fzqgodd4OOGOvcFLa3irjQAvfTA4WrGIeW0pvHyeMU3FqPONbFv9YG3NPFgzF4rW7W2utCfCJe8Zgc+cX0D5DnyWeD7yjCI+IZFjJ0zG0mussb8yNx4g7frRWFezqmDvfQk94OynwJ4AZVvBld544LhtkXH+knvXu/QCR3LTz9OeCGkDWj4fQgghOo1ab4CNhVUH1WOmtQZkxuGyRb4bvlJqidZ67H73S5B2EApWGcFPxU5I6QdjLoF+xxlZsM1fGs2YvcbDxFuMTFGY3wM7fjD6j/WfZOwfaYVrYMkLsO0bI0BK7Q9T7zMyUD++ZGTauo0ygpzU/kZQZA6tv+mppGLDIhZ++xXjgstIpxwOm2FcWqO2zAgAi9ZB8UYjSOw+qu2foyPJqLsQQoguJb+8lqLKyPUZkyAtAiIepAUDsGup0TfqxxeNJrjk3nDao0aGa/NXRtDWnprhCtcaQVl1EUy61ahvC7yBIH/6ooRXV3t5YJKL8wabjUCvvXEkQ2q/WNdCCCFElAWDmvV7qvD6I9PsGesgrcWSlVLnAR9prSuVUncAY4B7tNZLI1DPjsNkgUGTjf5mm780MmSOJCMw6z8h1rXbX8YQmHL3AT3ki43VzFnj5eT+Vs4YngjmdjqKsj0Fw0IIIaLGZFJkpzjZVFgd66pERGu+df8YCtCOwZgv7XngichWqwMxmWHAJJhwc6cKFvIrvNz7TTVpTsWtxyRia68BGiCjO4UQouuKs1tIjY/dCMxIas03b3i63VOAJ7TW7wGd82wIADz+IH/7roLtFUFuPTKO3smxHd3SIpknTQghurTuiQ6sls73g7013247lVL/As4H5iml7K18nOiAtIbPN1bx5hovpw6wcsqQAxh9GiudKIMphBDiwJlNiqxkZ6yr0eZaE2ydD3wMnKS1LgNSgZsiWSkRO7srPNz3TQ2ZLsUtRyVgt3SEeFyCNCGE6OoSHVaSXdZYV6NNteYb2AEsAIqVUqmAB5gfyUqJ2HD7gvz9+0q2Vwa55UgX2ckxXJvzQEgmTQghBNAjyYHZ1Hm+E1oTpC0FCoF1wPrQ9c1KqaVKqcMiWTkRPVrDl1uqeD00mnPa4IQOFPt0mIoKIYSIIIvZRI+kDpJgaIXWBGkfAdO01ula6zTgZOB14Crgn5GsnIiecDNnikNx05HxOKwdoZkzpONEk0IIISIsJc5GnD0Kk8VHQWu+icdqrT8O39BafwIcp7X+Dmjnw/5Ea9T6AjyxpIrN5UH+cLiLvikdrfOlBGlCCCH26pni7BS/31sTpJUopW5RSvUJXW4GSpVSZiByK5uKqAgG4dttNby8ysMJfaycMSwOUwdKogGSSRNCCNGA3WImM7Hj55Fa83V8MZANvAu8B/QO3WfGGPkpOrCCKjf3fVNNgk1x85FxxEVh+Ys2J/OkCSGE2EdGvL1jdd1pRIvfyFrrIuCaJjZvaNvqiGiq9QX494/VrC8N8qejXQxI72jNnGGSSRNCCNGQUoqeKU427um4S0a1Zu3OwcCNQN/6+2utj49ctUSkBYOwdGcNL6zwcEy2hXNHxGPpqMOWpblTCCFEI1w2Y8mokipvrKtyUFrTtvUG8CTwb/YuESU6uMJqN3/9tgabGW4aH0+CowM2cwohhBAt6J7ooKLWhz+gY12VA9aab2a/1loWVO9Ean0BXltZw0+FAW4Y52BYtw4+p4xk0oQQQjTBbFJkJTnZVlIT66ocsNb0qPuvUuoqpVQPpVRq+HIohSqlHlBKrVFK/aSUekcpldzEficppdYqpTYopWYeSpnCEAzCzwW1PLXMTV6mmek5cdjMHbtjpfRJE0II0Zwkl5X4Dthi1Jpv50sx1ur8BlgSuiw+xHI/BUZqrXMwVjK4dd8dQlN8PI4xee5w4CKl1PBDLLfLK67x8Lfva/AF4eYjXaS6Ov4QZcmkCSGEaElWsqPDfV20ZnRnv7YuNDQhbth3wLmN7HY4sEFrvQlAKfUacAbwc1vXp6uo9QX479oaFu7w8+tcO6N7uDrcG7ZxneJJCCGEiKDw3GkF5Z5YV6XVWsykKaWsSqlrlVJvhi5XK6Xacpn5XwEfNnJ/T2B7vds7QveJg6A1bCqq5R9L3AxMMXFZrgunrXMsmyHzpAkhhGiNjHg79g40d1pravoEcBjGOp3/DF1vcSCBUuozpdTKRi5n1NvndsAPvNzYIRq5r8mhGUqpK5RSi5VSiwsLC1uqXpdTUuPlH0tqKfNobjzcRffEjjonWiM6RzpQCCFEhCml6Jnccb7/WtOLbpzWOrfe7S+UUstbepDW+sTmtiulLgVOBU7QWjcWfO0AetW7nQ3saqa8p4CnAMaOHdvxxtlGkMcf5H+ba/hwk4/zh9o4uo+LDj9WoAEJ0oQQQrROnN1CsstKWY0v1lVpUWu+qgNKqQHhG0qp/hzifGlKqZOAW4DTtdZNjYn9ARiklOqnlLIBFwLvH0q5XZHWsKO0lod/cNM9TvGbPFfnmxNNMmlCCCEOQI8kR4dYp7o1VbwJmK+UWqCU+h/wBfCHQyz3H0AC8KlSaplS6kkApVSWUmoegNbaD1wNfAysBl7XWq86xHK7nNJaL8+vcLO9Msi1Y530Tu3gc6I1SoI0IYQQrWcxm+ie2P6/D1szuvNzpdQgYAjGt+EarfUhDY3QWg9s4v5dwLR6t+cB8w6lrK7M4w+ybFctr/7sYVJvC1MHurBbOsBPhwMlmTQhhBAHKC3eTmmNl1pvMNZVaVKT39hKqXFKqe4AoaAsD5gFPHCok9mK6CiocPPID27sZrhmrIsUpy3WVYoQCdKEEEIcuKx2PoigubTKvwAvgFLqOGA28AJQTqiDvmi/Smt8vLfOzU+FAX6T52BwZsdofz8okkkTQghxEMILsLdXzX1tm7XWJaHrFwBPaa3f0lr/EWi0uVK0D76AZmOxsfTTqAwz5w5zEm/rZIMF6pN50oQQQhyk7okOzKb2+WO/2SBNKRX+Zj8BY8BAWCf+xu/4Cis9PLHUQ60frhvrIDOh/XeOPDTt849LCCFE+2c2KXoktc/vyeaCrVeB/ymlioBa4CsApdRAjCZP0Q5Vuv18tc3N51t9TB9hY3RPJ1ZzJw9ipLlTCCHEIUiJs1FS46XGc0gzjLW5JoM0rfW9SqnPgR7AJ/UmnDUB10SjcuLA+IOanWVuHlviJitecWmOsxMPFqhHgjQhhBCHKCvJyYY9VbGuRgPNNltqrb9r5L51kauOOBRFVR5e/dnDjsogf5ngomeSvQvEL53+CQohhIgCp81MaryNkipvrKtSR3pcdxLVXj9rCr288rOHib0tTOrrIK4zDxYI6/xRqBBCiCjplmBvV4MIJEjrBIJB2FPh4bEltVhN8NvRDtLj7bGuVpS0nz8mIYQQHZvFbKJbYvv5/pQgrRMorvHw+RYvS3YHuCzHweB0R+cfLBAmmTQhhBBtKC3ejtPWPsKj9lELcdDcviA7y7z8c6mbQSkmzh5iJ8XVBQYL1JEgTQghRNtqLysRSJDWwRVWenhuhYdSt+b345x06xKDBeqRiWyFEEK0MZfNQrLLGutqSJDWkZXW+Fixx8v7G7ycOtDKmO72zr2yQGO6VEQqhBAiWnokOTDF+Dumi32jdx6+gKaw0pgTLdGmuDzHQXpCV2rmDJMgTQghRNuzmE1YzLGtg2TSOqiiKg8fb/axujjAb/Ls9EqxYzN3wZdTMmlCCCE6qS74rd7xVXr87Krw8e/lHkammzl5gK1rrCzQKAnShBBCdE4SpHUwgSAUVXr4zwo3lV7NNWMdZMQ7MHXVV1IyaUIIITqprvrV3mGVVHtYVejngw0+zhxkY3iGjQRHV+5aKEGaEEKIzkmCtA7E7QtSXO3l0SW1pDgUl4y0k9FlVhZogmTShBBCdFISpHUQWkNhpZsPN/lYVxLkijwHPRKtOKxd/CWUIE0IIUQn1cW/4TuOslofBdV+nv3JTU6GmRP7Wkjr6lk0QJo7hRBCdFYSpHUAvqCmpNrDf37yUO2Dqw9zkBbvwGKSAEUyaUIIITorCdI6gKJKD2uKA8zbaAwWGJJuJdkZ++Uq2gcJ0oQQQnROEqS1c1VePxVuH48vcZNkNwYLpMXbJIEUJidCCCFEJyVBWjsWDEJRpZfPt/j4uTjA5bl2MuKtXW99zmZJkCaEEKJzkiCtHSup8VJWG+Dp5R6GppmZ2s9KenxXXVmgCZJJE0II0UlJkNZOefxBymq8vLjKQ5lbc/VhDpJdNuwWeckakiBNCCFE5yTf+O1UYaWHLeUB3l3n5aT+VoalmUmNkyzafpS8hYUQQnRO8g3XDlW6/dR4/Ty+1I3TAr/KsZMaZ5cpNxojzZ1CCCE6KQnS2plAEIqqPHy9w8+PBQEuHeUgI84iU240SYI0IYQQnZMEae1MSY2HGl+Qp5a56Ztk4rSBVplyozlyYoQQQnRSMZnLQSn1AHAa4AU2Apdprcsa2W8LUAkEAL/WemwUqxl1Hn+Q8hofb6zxsrtac/8kJ/F2Cwl2mXKjaRKkCSGE6JxilUn7FBiptc4B1gG3NrPvJK11XmcP0AD2VHoorAny2s8ejsm2MLqbhYwEWZ+zWZJJE0II0UnFJEjTWn+itfaHbn4HZMeiHu1JRa0fty/Av5d7CGi4Is9BosMiU260SII0IYQQnVN7iAB+BXzYxDYNfKKUWqKUuqK5gyilrlBKLVZKLS4sLGzzSkZSeLDAz0V+Pt/q49yhNrLiTaTGSxatRZJJE0II0UlFrLOTUuozoHsjm27XWr8X2ud2wA+83MRhjtZa71JKZQKfKqXWaK2/bGxHrfVTwFMAY8eO1Yf8BKKopNqDLxjk8aVu0pyKi4bZSYmzYZUpN1omQZoQQohOKmJBmtb6xOa2K6UuBU4FTtBaNxpUaa13hf7do5R6BzgcaDRI66g8/iDltT4+3exjXUmQW8Y7SLCbSHHKxLWtI0GaEEKIzikmzZ1KqZOAW4DTtdY1TewTp5RKCF8HpgAro1fL6NhT6aHKp3nmJw/D0swc38dKapwdU3toiO4IJJMmhBCik4pVKPAPIAGjCXOZUupJAKVUllJqXmifbsDXSqnlwPfAB1rrj2JT3cgIDxZ47WcPpW7NVWMcOK1mEh0y5UbrSZAmhBCic4pJNKC1HtjE/buAaaHrm4DcaNYrmgJBKK72kF8V5K21Xib3tTI0zUyqTFx7YORkCSGE6KSkUS1GSqo9+IOap5e7MStjfU6XzUK8TbJoB0aCNCGEEJ2TBGkxEB4ssGKPn6+2+zl/mJ10l4n0eBkscMAkkyaEEKKTkiAtBgorPQS05okf3WQ4FecNtZEgE9ceJAnShBBCdE4SFURZpdtPrS/Ap5t9rC8NcnmuA6dFkSYT1x4cJW9hIYQQnZN8w0VRMAhF1R5qfZpnf/IwNM3MpD4Wkl0yce1Bk+ZOIYQQnZT0Uo+i0lov/oBmzmoPJW7Nn46xYzWZSHFJX7SDJ0GaEKJ5Pp+PHTt24Ha7Y10V0cU5HA6ys7OxWq2t2l+CtCjxBTSl1V72VAd5Y62XSb0tDE+3kBJnwyz5zIMnmTQhRAt27NhBQkICffv2RclnhogRrTXFxcXs2LGDfv36teoxEh5ESVGVBw0885PxS+7XuQ4sZkWys3XRtGiKfOAKIZrndrtJS0uTAE3ElFKKtLS0A8roSpAWBdVeP1UeP2uLA3yx1c85Q2xkxplIj7NLIuhQyQkUQrSCBGiiPTjQ96EEaRGmNRRVedFa869lbpLtiguH2XFYTCTI8k9tQD54hRDt37333suIESPIyckhLy+PRYsWNbv/jBkzePPNNw+pzAULFpCUlEReXl7d5bPPPgMgPj7+oI75yCOPUFOzd8ntadOmUVZW1uT+Tz75JC+88AIAzz33HLt27Tqg8iZOnMiQIUPIzc3l6KOPZu3atQdV73D5V1999X71asyWLVt45ZVX6m4vXryYa6+99qDLPlgSJURYWa0Prz/Iwp1+VhQG+P1YBy6rIlUmrm0b8utYCNHOffvtt8ydO5elS5dit9spKirC6/VGpexjjz2WuXPnttnxHnnkEX7xi1/gcrkAmDdvXrP7//a3v627/txzzzFy5EiysrIOqMyXX36ZsWPH8tRTT3HTTTfx/vvvN9geCAQwm80HdMz69WpMOEi7+OKLARg7dixjx449oDLagmTSIsgf1JRUe/AFNE8v89An0cTJ/a24bBbiZPmntiFBmhCincvPzyc9PR273ZgPMz09vS5QmTVrFuPGjWPkyJFcccUVaK33e/ySJUuYMGEChx12GFOnTiU/Px+ARx99lOHDh5OTk8OFF154UHWrqqrihBNOYMyYMYwaNYr33nsPgOrqak455RRyc3MZOXIkc+bM4dFHH2XXrl1MmjSJSZMmAdC3b1+KiooAeOGFF8jJySE3N5df/vKXANx11108+OCDvPnmmyxevJjp06eTl5fHBx98wFlnnVVXj08//ZSzzz672boed9xxbNiwATAygXfeeSdHHHEE3377LS+99BKHH344eXl5XHnllQQCAQD+85//MHjwYCZMmMDChQvrjhWuF8CGDRs48cQTyc3NZcyYMWzcuJGZM2fy1VdfkZeXx8MPP8yCBQs49dRTASgpKeHMM88kJyeH8ePH89NPP9Ud81e/+hUTJ06kf//+PProowf1mtQnkUIElVR7CWqYu9HLrqog9xznxGxSpMVJFq1tSIAmhDgwf/7vKn7eVdGmxxyelcifThvR5PYpU6Ywa9YsBg8ezIknnsgFF1zAhAkTALj66qu58847AfjlL3/J3LlzOe200+oe6/P5uOaaa3jvvffIyMhgzpw53H777Tz77LPMnj2bzZs3Y7fbm2xyDAcaYW+99RYDBgyou+1wOHjnnXdITEykqKiI8ePHc/rpp/PRRx+RlZXFBx98AEB5eTlJSUn87W9/Y/78+aSnpzcoZ9WqVdx7770sXLiQ9PR0SkpKGmw/99xz+cc//sGDDz7I2LFj0Vrzhz/8gcLCQjIyMvjPf/7DZZdd1ux5/u9//8uoUaMAI4gcOXIks2bNYvXq1fz1r39l4cKFWK1WrrrqKl5++WUmT57Mn/70J5YsWUJSUhKTJk1i9OjR+x13+vTpzJw5k7POOgu3200wGGT27Nk8+OCDdVnIBQsW1O3/pz/9idGjR/Puu+/yxRdfcMkll7Bs2TIA1qxZw/z586msrGTIkCH87ne/a/V0G42RIC1CwutzVno1L670MqabmcN7WEhwWHBYJYHZJmS1ASFEBxAfH8+SJUv46quvmD9/PhdccAGzZ89mxowZzJ8/n/vvv5+amhpKSkoYMWJEgyBt7dq1rFy5ksmTJwNG016PHj0AyMnJYfr06Zx55pmceeaZjZbdUnOn1prbbruNL7/8EpPJxM6dOykoKGDUqFHceOON3HLLLZx66qkce+yxzT7HL774gnPPPbcueEtNTW12f6UUv/zlL3nppZe47LLL+Pbbb5vsIzZ9+nScTid9+/blscceA8BsNnPOOecA8Pnnn7NkyRLGjRsHQG1tLZmZmSxatIiJEyeSkZEBwAUXXMC6desaHLuyspKdO3fWZfUcDkez9Qb4+uuveeuttwA4/vjjKS4upry8HIBTTjkFu92O3W4nMzOTgoICsrOzWzxmUyRIi5DCSg8Ar6zyUOXVXJHnwKQUqZJFazvS1CmEOEDNZbwiyWw2M3HiRCZOnMioUaN4/vnnufDCC7nqqqtYvHgxvXr14q677tpvegatNSNGjODbb7/d75gffPABX375Je+//z533303q1atwmI5sK/1l19+mcLCQpYsWYLVaqVv37643W4GDx7MkiVLmDdvHrfeeitTpkypy/g1Rmt9wCMXL7vsMk477TQcDgfnnXdek3UP90mrz+Fw1PVD01pz6aWXct999zXY5913322xTo01L7eksceEywk3aYPxmvv9/gM+fn2SioiA8Pqc+VVB3lvvZWo/KwNSzCQ6rdhk5to2JEGaEKL9W7t2LevXr6+7vWzZMvr06VMXkKWnp1NVVdXoaM4hQ4ZQWFhYF6T5fD5WrVpFMBhk+/btTJo0ifvvv5+ysjKqqqoOuG7l5eVkZmZitVqZP38+W7duBWDXrl24XC5+8YtfcOONN7J06VIAEhISqKys3O84J5xwAq+//jrFxcUA+zV3NvbYrKwssrKyuOeee5gxY8YB171+2W+++SZ79uypK3vr1q0cccQRLFiwgOLiYnw+H2+88cZ+j01MTCQ7O5t3330XAI/HQ01NTZPPE4y+cS+//DJgNIOmp6eTmJh40PVvjmTS2lgwCMXVxqidZ39yY1ZwaY4dBaRIFq1tSSZNCNEBVFVVcc0111BWVobFYmHgwIE89dRTJCcn85vf/IZRo0bRt2/fuua6+mw2G2+++SbXXnst5eXl+P1+rrvuOgYPHswvfvELysvL0Vpz/fXXk5ycvN/j9+2Tdscdd3DuuefW3Z4+fTqnnXYaY8eOJS8vj6FDhwKwYsUKbrrpJkwmE1arlSeeeAKAK664gpNPPpkePXowf/78uuOMGDGC22+/nQkTJmA2mxk9ejTPPfdcg7rMmDGD3/72tzidTr799lucTifTp0+nsLCQ4cOHH/T5HT58OPfccw9TpkwhGAxitVp5/PHHGT9+PHfddRdHHnkkPXr0YMyYMXUDCup78cUXufLKK7nzzjuxWq288cYb5OTkYLFYyM3NZcaMGQ36st11111cdtll5OTk4HK5eP755w+67i1RB5Pqa+/Gjh2rFy9eHLkCggHY/VOjm0pqvBRXeVlTHOCaT6v5xQgbl45ykOKykS7TbrQtsx26HfwfthCia1i9ejXDhg2LdTVEI66++mpGjx7N5ZdfHuuqRE1j70el1BKt9X5zfEgmrQ35gpqS0MS1T4Umrj1vqB2zUrKIeiRIJk0IITqsww47jLi4OB566KFYV6XdkiCtDRWH1uf8bpcxce21hxkT1ybHWWUR9YiQIE0IITqqJUuWxLoK7Z6EDm2k1heg0u0nENT8e7mH7AQTJw+wYjEpkh2SRYsIyaQJIYToxCRIayNFVcZggY82+dhWEeTyXDsWkyI1zo5JznJkyDxpQgghOjH5lmsDlW4/bl+AWp/mhZUeRqSbObqnBavZRKIsoh5BkkkTQgjReUmQdoi03jvlxptrvZS4NVfk2VHKWP5JWuQiSE6uEEKITkyCtENUWuvFFwhSUhvk9TUejs22MDzdgt1iIkGyaEII0aUVFxeTl5dHXl4e3bt3p2fPnnW3vV5vm5QxceJEhgwZUnfc8Dxo9RcRPxDLli1j3rx5dbfff/99Zs+e3exjjjrqKAC2bNnCK6+8csBlisZJFHEI/EFNaSiL9uIqD74A/CrHWBJCJq6NAsmkCSHaubS0tLrFt++66y7i4+O58cYb67b7/f4DXsqpMY0tnXSwli1bxuLFi5k2bRoAp59+Oqeffnqzj/nmm2+AvUHaxRdf3CZ16eokk3YIiqs8BDXsqAgwb6OPaQOsZCeacVjMJNgl/o08CdKEEB3PjBkzuOGGG5g0aRK33HLLfhmvkSNHsmXLFgBeeuklDj/8cPLy8rjyyisbnTG/NZ5++mnGjRtHbm4u55xzDjU1NQC88cYbjBw5ktzcXI477ji8Xi933nknc+bMIS8vjzlz5vDcc89x9dVXA1BQUMBZZ51Fbm4uubm5dcFZfHw8ADNnzqxb5eDhhx/m2GOPrQtSAY4++mh++qnxyeDF/iSSOEgef5BKt7Fw6n9WeLCZ4RcjjCxamqwsEB2SSRNCHIz/nLL/fSPOhMN/A94aePm8/bfnXQyjp0N1Mbx+ScNtl31wwFVYt24dn332GWazmbvuuqvRfVavXs2cOXNYuHAhVquVq666ipdffplLLrlkv32nT5+O0+kEYPLkyTzwwAMNtp999tn85je/AYyloZ555hmuueYaZs2axccff0zPnj0pKyvDZrMxa9YsFi9ezD/+8Q+ABss7XXvttUyYMIF33nmHQCCw33qhs2fP5sEHH2Tu3LkApKam8txzz/HII4+wbt06PB4POTk5B3y+uioJ0g5SUZUXDawtDvDldj+/GGEj1WnCaTXjspljXb0uQoI0IUTHdN5552E2N/9d8fnnn7NkyZK6NT1ra2vJzMxsdN+WmjtXrlzJHXfcUbcQ+9SpUwEjszVjxgzOP/98zj777Bbr/cUXX/DCCy8AYDabSUpKanb/8847j7vvvpsHHniAZ5999pAWUu+KJEg7CIGgpsbrR2vNv5cbyz+dO1SyaFEn86QJIQ5Gc5kvm6v57XFpB5U52+8wcXF11y0WC8FgsO622+0GQGvNpZdeyn333XfI5c2YMYN3332X3NxcnnvuORYsWADAk08+yaJFi/jggw/Iy8tr0DTZFlwuF5MnT+a9997j9ddfJ6LrandCMfmWU0rdrZT6SSm1TCn1iVIqq4n9TlJKrVVKbVBKzYx2PVuyeHeAZXsCXDzCRpxVEWez4LRKFi1qpLlTCNEJ9O3bl6VLlwKwdOlSNm/eDMAJJ5zAm2++yZ49ewAoKSlh69atB1VGZWUlPXr0wOfz8fLLL9fdv3HjRo444ghmzZpFeno627dvJyEhgcrKykaPc8IJJ/DEE08AEAgEqKioaLC9scf++te/5tprr2XcuHGkpqYeVP27qlilIh7QWudorfOAucCd++6glDIDjwMnA8OBi5RSw6Nay2YEQ1m07nGKUwYY2TPJokWbBGlCiI7vnHPOoaSkhLy8PJ544gkGDx4MwPDhw7nnnnuYMmUKOTk5TJ48mfz8/EaPMX369LopOE488cT9tt99990cccQRTJ48maFDh9bdf9NNNzFq1ChGjhzJcccdR25uLpMmTeLnn3+uGzhQ39///nfmz5/PqFGjOOyww1i1alWD7Tk5OVgsFnJzc3n44YcBYyH1xMRELrvsskM6T12R0lrHtgJK3Qr01lr/bp/7jwTu0lpPrbcfWusW875jx47VkUypBvx+/j33S+77rpZbxzs5vq+VeLuFHkmOiJUpGhHfDRIbTcIKIUSd1atXM2zYsFhXo8vatWsXEydOZM2aNZhkncRG349KqSVa6/06FcbsbCml7lVKbQem00gmDegJbK93e0fovqaOd4VSarFSanFhYWHbVnYfHn+Q/6xwMyDZxMQ+Rre+VJkXLQYkkyaEEO3ZCy+8wBFHHMG9994rAdpBiNgZU0p9ppRa2cjlDACt9e1a617Ay8DVjR2ikfuaTPtprZ/SWo/VWo/NyMhomyfRhFd/2M7uas3luQ5MSpHgMFYYEFEmfdKEEKJdu+SSS9i+fTvnndfItCaiRREb3am13r9RvHGvAB8Af9rn/h1Ar3q3s4FdbVC1QxIMap7/dit5mWbGdjejkCxa7EiQJoQQovOK1ejOQfVung6saWS3H4BBSql+SikbcCHwfjTq1xyTSfHmleO5fpwTFcqi2cySRYsJyaQJIYToxGI1T9pspdQQIAhsBX4LEJqK499a62laa79S6mrgY8AMPKu1XtXkEaMoLc5GVoIplEWzx7o6XZfMkyaEEKITi0mQprU+p4n7dwHT6t2eB8yLVr0OVKLTitUs2ZzYkXMvhBCi85JUxEFSQIpL+qLFlDR3CiE6iL///e+MHDmSESNG8Mgjj9TdX1JSwuTJkxk0aBCTJ0+mtLQUgIULF5KTk8O4cePYsGEDAGVlZUydOpWmps7y+XzMnDmTQYMGMXLkSA4//HA+/PDDg6pvYWEhRxxxBKNHj+arr75i2rRplJWV7bffvovDR0v9Rd+bsmXLFl555ZWo1Ce8wHxbk2WhDlJSp8qiKZoZOCuEEJ3Kih3lbXq8UdnNr1+5cuVKnn76ab7//ntsNhsnnXQSp5xyCoMGDWL27NmccMIJzJw5k9mzZzN79mz++te/8tBDD/HWW2+xZcsWnnjiCR566CHuvvtubrvtNlQTP1D/+Mc/kp+fz8qVK7Hb7RQUFPC///3voJ7T559/ztChQ3n++ecBOPbYYw/qOLEUDtIuvvjiVj8mEAi0uKZqNEkm7SAoILmzjOh0pUNqfzpk06Fk0oQQHcDq1asZP348LpcLi8XChAkTeOeddwB47733uPTSSwG49NJLeffddwGwWq3U1tZSU1OD1Wpl48aN7Ny5kwkTJjRaRk1NDU8//TSPPfYYdrvRV7pbt26cf/75ALz66qt1KwvccsstdY+Lj4/n9ttvJzc3l/Hjx1NQUMCyZcu4+eabmTdvHnl5edTW1tK3b1+KiooAuPfeexkyZAgnnngia9eurTvWxo0bOemkkzjssMM49thjWbPGGBM4Y8YMrr32Wo466ij69+/Pm2++WfeY+++/n1GjRpGbm8vMmTObPU5Tmjr+zJkz+eqrr8jLy+Phhx8mEAhw0003MW7cOHJycvjXv/4FwIIFC5g0aRIXX3wxo0aN4pZbbuGf//xn3fHvuusuHnroIaqqqjjhhBMYM2YMo0aN4r333mu2Xm1BMmkHwWRSmEztPEAw20CZwV/b9D6OJEgOzXKS0gdKt0Slam2nnb8GQggBjBw5kttvv53i4mKcTifz5s1j7FhjcvmCggJ69OgBQI8ePerW6bz11lu54oorcDqdvPjii9x4443cfffdTZaxYcMGevfuTWJi4n7bdu3axS233MKSJUtISUlhypQpvPvuu5x55plUV1czfvx47r33Xm6++Waefvpp7rjjDmbNmsXixYv5xz/+0eBYS5Ys4bXXXuPHH3/E7/czZswYDjvsMACuuOIKnnzySQYNGsSiRYu46qqr+OKLLwDIz8/n66+/Zs2aNZx++umce+65fPjhh7z77rssWrQIl8tFSUlJi8dpSmPHnz17Ng8++CBz584F4KmnniIpKYkffvgBj8fD0UcfzZQpUwD4/vvvWblyJf369ePHH3/kuuuu46qrrgLg9ddf56OPPsLhcPDOO++QmJhIUVER48eP5/TTT28ys9kWJEiLBWUGHYhsGXGZ4EqDsq3gLtt/uy0BUvrtve1MgWAAyrfvv297ZbbGugZCCNGiYcOGccsttzB58mTi4+PJzc3FYmn+6zcvL4/vvvsOgC+//JKsrCy01lxwwQVYrVYeeughunXr1qryf/jhByZOnEh4ovfp06fz5ZdfcuaZZ2Kz2Tj11FMBY43NTz/9tNljffXVV5x11lm4XC4ATj/9dACqqqr45ptvGkxa6/F46q6feeaZmEwmhg8fTkFBAQCfffYZl112Wd2xUlNTWzxOUxo7/r4++eQTfvrpp7pMW3l5OevXr8dms3H44YfTr5/xnTh69Gj27NnDrl27KCwsJCUlhd69e+Pz+bjtttv48ssvMZlM7Ny5k4KCArp3795i/Q6WBGnRZnUZ600Wb4hcGSaLEaCZTJDaDyoLoLLePMBWl3H/vtF/XDoEfFC1O3J1aytmG9jiYl0LIYRolcsvv5zLL78cgNtuu43s7GzAaJLMz8+nR48e5Ofnk5mZ2eBxWmvuuece5syZw9VXX82f//xntmzZwqOPPsq9995bt9/AgQPZtm0blZWVJCQk7HeMplit1rpMkNlsxu/3t/hcGsscBYNBkpOTWbZsWaOPCTfB1q+P1nq/Y7V0nKY0dvx9aa157LHHmDp1aoP7FyxYQFxcw++Tc889lzfffJPdu3dz4YUXAvDyyy9TWFjIkiVLsFqt9O3bF7fbfUD1PFDSJy3akrLBngD2/VPSbcaVbgRoYQndIHWAEbyZ7UYfNFMTHSMTexiPb++cKbGugRBCtFq4GXPbtm28/fbbXHTRRYCRiQp3zn/++ec544wzGjzu+eef55RTTiElJYWamhpMJhMmk4mampoG+7lcLi6//HKuvfZavF4vYDQBvvTSSxxxxBH873//o6ioiEAgwKuvvtpk37aWHHfccbzzzjvU1tZSWVnJf//7XwASExPp168fb7zxBmAERMuXL2/2WFOmTOHZZ5+tey4lJSUHdZymJCQkUFlZWXd76tSpPPHEE/h8PgDWrVtHdXV1o4+98MILee2113jzzTc599xzASPzlpmZidVqZf78+WzduvWg6nUgJJMWTc7UvdmfhB7gqWj7MpQJ4hpZu9SRCOlDAN1yM2FyLwh4I1O/tiJBmhCiAznnnHMoLi7GarXy+OOPk5JifIbNnDmT888/n2eeeYbevXvXBSdgDAZ4/vnn+eSTTwC44YYbOOecc7DZbLz66qv7lXHPPfdwxx13MHz4cBwOB3FxccyaNYsePXpw3333MWnSJLTWTJs2bb9gsLXGjBnDBRdcQF5eHn369Gkw6vPll1/md7/7Hffccw8+n48LL7yQ3NzcJo910kknsWzZMsaOHYvNZmPatGn85S9/OeDjNCUnJweLxUJubi4zZszg97//PVu2bGHMmDForcnIyKgbqLGvESNGUFlZSc+ePev6DE6fPp3TTjuNsWPHkpeXx9ChQw+4TgdKNZcG7ajGjh2rFy9eHLkCggHY/dOBPUaZIXNYwwCpZHPj/cUafbzJyMDZEoymSx1sfD9X+t7BAIfCWw1F6w79OJFgcUJm5P84hBCdw+rVqxk2bFisqyEE0Pj7USm1RGs9dt99JZMWLfHd9s9gJfQAdzlNzlGmTEazqDMZ7El7mzDNliZGYiqIz2zk/oNgiwNbPHir2uZ4bcmZHOsaCCGEEBEnQVo0WByNB09WB7hSoaa4kcc4jb5jlkbmY3OmgM+9fwd/RxJY2nAt0fhMKGmPQZo0dQohhOj8JEiLhsSeTU+8Gt8dakpokE2zJ0JK36Y794PRwd9fG8rEhY/VuuHYreZIMkaC+mqa3ieplxGE6iCgjX8DfqjYSURWMbDGtW0gKoQQQrRTMroz0uyJRqf9plhsxtQXYa605kdf1pfc18i4gdFXzeY6pKo2qrFBCGHOVKPu9njjOTqSjCxXfIYxOW4kSBZNCCFEFyFBWqRYHEaAk9SKTvzx3Y2BBYk9Ibl365c7MplCAZ2l7fqi7cuZYkzbsS+zvfnn5kwxnk+bUtIfTQghRJchzZ1tRhmZJHuiMQqzsb5kTTFbIGPogT0mzGKDtIFgdR74Y1tDhQYjNFiJQBmZMlMLMX58pjGVR3VhYwc2+uP5aptvTq3PFi+rDAghhOgyJJN2yJTRRJk53JjFPy7t4IOtgxWpAC3MlQamesFRQvfWz/aflA2O5Ib32RONoDS5N6QNMppNW0OaOoUQHUxxcTF5eXnk5eXRvXt3evbsWXc7POnsoZo4cSJDhgypO2548tW77rqLBx988ICPt2zZMubNm1d3+/3332f27NnNPuaoo44CYMuWLbzyyisHVN6CBQtISkpi9OjRDB06lBtvvPGA69xZSSbtUDhTjGk0OntHdqWMptvKXUY2K+EA1ylL7gMlftDaWBLLHr93m8lkZOVscVC+g6YHG0hTpxCijez6sW2PlzW6yU1paWl1SxzdddddxMfHNwhC/H5/i+t4tsbLL79ct2j7oVq2bBmLFy9m2rRpgLEqQniNzqZ88803wN4g7eKLLz6gMo899ljmzp1LbW0to0eP5qyzzuLoo48+uCfQiUgm7WAok5EJSunb+QO0sLh0Y73M5IMYEGAyGctSZQxuGKDte/z0QUYZjXEktm4whRBCtHMzZszghhtuYNKkSdxyyy37ZbxGjhzJli1bAHjppZc4/PDDycvL48orryQQCBxUmU8//TTjxo0jNzeXc845p24ppjfeeIORI0eSm5vLcccdh9fr5c4772TOnDnk5eUxZ84cnnvuOa6++moACgoKOOuss8jNzSU3N7cuOIuPNz7bZ86cyVdffUVeXh4PP/wwxx57bIN1OI8++mh++qnpyeCdTid5eXns3Lmz2XrPmDGDa6+9lqOOOor+/fvXLZoeDAa56qqrGDFiBKeeeirTpk2r27ZkyRImTJjAYYcdxtSpU8nPzz+ocxlNEqQdDKUi38TY3pjMkD744JtlW+q/BkY2LX2IMeAgLsNoJrXGGU2t0tQphOhE1q1bx2effcZDDz3U5D6rV69mzpw5LFy4kGXLlmE2m3n55Zcb3Xf69Ol1zZ033XTTftvPPvtsfvjhB5YvX86wYcN45plnAJg1axYff/wxy5cv5/3338dmszFr1iwuuOACli1bxgUXXNDgONdeey0TJkxg+fLlLF26lBEjRjTYPnv27LrA7Prrr+fXv/41zz33XN1z9ng85OTkNPmcS0tLWb9+Pccdd1yz9QZjbdKvv/6auXPnMnPmTADefvtttmzZwooVK/j3v//Nt99+C4DP5+Oaa67hzTffZMmSJfzqV7/i9ttvb7Ie7YU0d4rWi0anfXMER6oKIUQ7cd5552E2N9868Pnnn7NkyRLGjRsHQG1tLZmZjX8+ttTcuXLlSu644w7Kysqoqqpi6tSpgJHZmjFjBueffz5nn312i/X+4osveOGFFwAwm80kJSU1u/95553H3XffzQMPPMCzzz7LjBkzGt3vq6++Iicnh7Vr1zJz5ky6d+/ebL0BzjzzTEwmE8OHD6egoACAr7/+mvPOOw+TyUT37t2ZNGkSAGvXrmXlypVMnjwZgEAgULcmZ3smQZoQQggRZXFxewdfWSwWgsG96zG73W4AtNZceuml3HfffYdc3owZM3j33XfJzc3lueeeY8GCBQA8+eSTLFq0iA8++IC8vLwGTZNtweVyMXnyZN577z1ef/11mlpXO9wnbd26dRxzzDGcddZZ5OXlNVlvALt9b3ej8DrkTa1HrrVmxIgRdZm1jkKaO4UQQogY6tu3L0uXLv3/9u4/tqryjuP4+6PA7sIPF4Mz6HVKFgu6/mL8aDIIAaHEOaJLmsUtbo1GoyRzsJg4Roj7IS6Z2QIaE8mM2xIyndvK3KYmTpZhmGwOBGEMqJtYCU2NZW2ANllE5bs/7qEr6y1QHfc59H5eSZNzzn3uc7+3T3987znf5zwA7Ny5k46ODgAWLVpEW1sb3d3dAPT29nLw4MEP9Bp9fX1MmTKFd99995RLpgcOHKCpqYn777+fyZMnc+jQISZOnEhfX1/ZfhYtWsT69euB0tmoY8eOnfJ4uefecccdLF++nNmzZ3PxxaefzV9TU8OqVat48MEHTxv3cObNm8fGjRs5ceIEb7/99kBSN23aNA4fPnzK5c+9e/eesb/UnKSZmZkl1NLSQm9vL42Njaxfv56amhoArr32Wh544AGWLFlCfX09zc3Nwxa7D65JW7x48ZDH16xZQ1NTE83NzUyfPn3g+L333ktdXR21tbXMnz+fhoYGFi5cyL59+wYmDgz28MMPs3nzZurq6pg5c+aQRKe+vp4xY8bQ0NDAunXrAJg5cyaTJk3itttuO6vvx7Jly9iyZQsdHR3Dxj2clpYWisUitbW13HXXXTQ1NXHRRRcxbtw42traWLlyJQ0NDTQ2Ng5MesgzDXdq8Hw2a9asGO6UqpmZVZf9+/dzzTXXpA6janV1dbFgwQLa29u54GwmkX1I/f39TJgwgZ6eHubMmcPWrVsHatzyoNzPo6QdETGkqNA1aWZmZnZObNiwgdWrV7N27dqKJGgAS5cu5ciRIxw/fpz77rsvVwnaSDlJMzMzs3OitbWV1tbWir7m4MkF5zvXpJmZmZnlkJM0MzMb9UZj/bWdf0b6c+gkzczMRrVCoUBPT48TNUsqIujp6aFQKJz1c1yTZmZmo1qxWKSzs5PDhw+nDsWqXKFQoFgsnnX7JEmapDXATcAJoBu4NSK6yrR7E+gD3gfeKzc91czM7HTGjh3L1KlTU4dhNmKpLnf+ICLqI6IReBb41mnaLoyIRidoZmZmVk2SJGkRMXgdifGACwXMzMzMBklWkybpe0ArcBRYOEyzAF6QFMCPIuKxSsVnZmZmltI5WxZK0h+Acrf5XR0Rvx3UbhVQiIhvl+njsojokvRxYBPwtYjYMszr3Qncme1OA177sO/hDCYD/zrHr2Ej4zHJJ49L/nhM8snjkj+VGpMrI+KS/z2YfO1OSVcCz0VE7RnafQfoj4gfViSwM5D0iuvk8sVjkk8el/zxmOSTxyV/Uo9Jkpo0SVcP2r0RaC/TZrykiSe3gSXA3ysToZmZmVlaqWrSvi9pGqVbcBwElkHp8ibweETcAFwKPC3pZJxPRsTzieI1MzMzq6gkSVpEtAxzvAu4Idt+A2ioZFwj5EkM+eMxySePS/54TPLJ45I/ScckeU2amZmZmQ3ltTvNzMzMcshJ2ghJul7Sa5Jel/TN1PEYSPqJpG5JnliSE5KukLRZ0n5JeyWtSB2TgaSCpG2Sdmfj8t3UMVmJpAslvSrp2dSxWImkNyXtkbRL0itJYvDlzrMn6ULgH0Az0AlsB74UEfuSBlblJM0H+oENZ7qVi1WGpCnAlIjYmc3S3gF83r8raak0E2t8RPRLGgu8BKyIiJcTh1b1JN0DzAImRcTS1PHYwPrhsyIi2b3rfCZtZOYAr0fEGxFxHHiK0kLxllB2g+Pe1HHYf0XEWxGxM9vuA/YDl6eNyqKkP9sdm335k3pikorA54DHU8di+eIkbWQuBw4N2u/E/3jMTkvSVcAM4K+JQzEGLqvtArqBTRHhcUnvIeAblG5LZflxcmnKHdmqRhXnJG1kVOaYP4WaDUPSBGAj8PWIOJY6HoOIeD8iGoEiMEeSSwQSkrQU6I6IHaljsSHmRsSngc8CX81KayrKSdrIdAJXDNovAl2JYjHLtazmaSPwRET8OnU8dqqIOAK8CFyfNpKqNxe4Mat/egq4TtLP0oZkMHDvViKiG3iaUslTRTlJG5ntwNWSpkoaB3wR+F3imMxyJytQ/zGwPyLWpo7HSiRdIulj2fZHgcWUWZbPKiciVkVEMSKuovQ/5Y8R8eXEYVW9vCxN6SRtBCLiPeBu4PeUCqF/GRF700Zlkn4O/AWYJqlT0u2pYzLmAl+hdFZgV/Z1Q+qgjCnAZkl/o/Shc1NE+JYPZkNdCrwkaTewDXguxdKUvgWHmZmZWQ75TJqZmZlZDjlJMzMzM8shJ2lmZmZmOeQkzczMzCyHnKSZmZmZ5ZCTNDMb9ST1n7mVmVm+OEkzMzMzyyEnaWZWNSQtkPSipDZJ7ZKeyFZHQNJsSX+WtFvSNkkTJRUk/VTSHkmvSlqYtb1V0m8kPSOpQ9Ldku7J2rws6eKs3SclPZ8t0PwnSdNTvn8zO7+MSR2AmVmFzQA+RWnd3a3AXEnbgF8AN0fEdkmTgH8DKwAioi5LsF6QVJP1U5v1VQBeB1ZGxAxJ64BW4CHgMWBZRPxTUhPwKHBdhd6nmZ3nnKSZWbXZFhGdAJJ2AVcBR4G3ImI7QEQcyx6fBzySHWuXdBA4maRtjog+oE/SUeCZ7PgeoF7SBOAzwK+yk3UAHzm3b83MRhMnaWZWbd4ZtP0+pb+DAsqtkacyx8r1c2LQ/omszwuAIxHR+IEjNbOq5po0MzNoBy6TNBsgq0cbA2wBbsmO1QCfAF47mw6zs3Edkr6QPV+SGs5F8GY2OjlJM7OqFxHHgZuBRyTtBjZRqjV7FLhQ0h5KNWu3RsQ7w/c0xC3A7Vmfe4Gb/r+Rm9lopohyZ/jNzMzMLCWfSTMzMzPLISdpZmZmZjnkJM3MzMwsh5ykmZmZmeWQkzQzMzOzHHKSZmZmZpZDTtLMzMzMcshJmpmZmVkO/QeAlA/GuU9tAQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -465,19 +465,19 @@ " point_estimate stderr zstat pvalue ci_lower ci_upper\n", "\n", "\n", - " income 2.467 0.073 33.765 0.0 2.347 2.587 \n", + " income 2.421 0.079 30.68 0.0 2.291 2.55 \n", "\n", "\n", - " income^2 -0.45 0.025 -18.147 0.0 -0.491 -0.409 \n", + " income^2 -0.431 0.027 -16.106 0.0 -0.475 -0.387 \n", "\n", "\n", "\n", "\n", "\n", - " \n", + " \n", "\n", "\n", - " \n", + " \n", "\n", "
CATE Intercept Results
point_estimate stderr zstat pvalue ci_lower ci_upper point_estimate stderr zstat pvalue ci_lower ci_upper
cate_intercept -3.041 0.046 -66.745 0.0 -3.116 -2.967cate_intercept -3.027 0.049 -61.92 0.0 -3.107 -2.946


A linear parametric conditional average treatment effect (CATE) model was fitted:
$Y = \\Theta(X)\\cdot T + g(X, W) + \\epsilon$
where for every outcome $i$ and treatment $j$ the CATE $\\Theta_{ij}(X)$ has the form:
$\\Theta_{ij}(X) = \\phi(X)' coef_{ij} + cate\\_intercept_{ij}$
where $\\phi(X)$ is the output of the `featurizer` or $X$ if `featurizer`=None. Coefficient Results table portrays the $coef_{ij}$ parameter vector for each outcome $i$ and treatment $j$. Intercept Results table portrays the $cate\\_intercept_{ij}$ parameter." ], @@ -488,14 +488,14 @@ "===============================================================\n", " point_estimate stderr zstat pvalue ci_lower ci_upper\n", "---------------------------------------------------------------\n", - "income 2.467 0.073 33.765 0.0 2.347 2.587\n", - "income^2 -0.45 0.025 -18.147 0.0 -0.491 -0.409\n", - " CATE Intercept Results \n", - "=====================================================================\n", - " point_estimate stderr zstat pvalue ci_lower ci_upper\n", - "---------------------------------------------------------------------\n", - "cate_intercept -3.041 0.046 -66.745 0.0 -3.116 -2.967\n", - "---------------------------------------------------------------------\n", + "income 2.421 0.079 30.68 0.0 2.291 2.55\n", + "income^2 -0.431 0.027 -16.106 0.0 -0.475 -0.387\n", + " CATE Intercept Results \n", + "====================================================================\n", + " point_estimate stderr zstat pvalue ci_lower ci_upper\n", + "--------------------------------------------------------------------\n", + "cate_intercept -3.027 0.049 -61.92 0.0 -3.107 -2.946\n", + "--------------------------------------------------------------------\n", "\n", "A linear parametric conditional average treatment effect (CATE) model was fitted:\n", "$Y = \\Theta(X)\\cdot T + g(X, W) + \\epsilon$\n", @@ -554,7 +554,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 13, @@ -563,7 +563,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -623,7 +623,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -671,7 +671,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -684,9 +684,9 @@ ], "source": [ "intrp = SingleTreePolicyInterpreter(risk_level=0.05, max_depth=2, min_samples_leaf=1, min_impurity_decrease=0.001)\n", - "intrp.interpret(est, X_test, sample_treatment_costs=-1, treatment_names=[\"Discount\", \"No-Discount\"])\n", + "intrp.interpret(est, X_test, sample_treatment_costs=-1)\n", "plt.figure(figsize=(25, 5))\n", - "intrp.plot(feature_names=X.columns, fontsize=12)" + "intrp.plot(feature_names=X.columns, treatment_names=[\"Discount\", \"No-Discount\"], fontsize=12)" ] }, { diff --git a/notebooks/CustomerScenarios/Case Study - Recommendation AB Testing at An Online Travel Company.ipynb b/notebooks/CustomerScenarios/Case Study - Recommendation AB Testing at An Online Travel Company.ipynb index 8477343de..05cc69180 100644 --- a/notebooks/CustomerScenarios/Case Study - Recommendation AB Testing at An Online Travel Company.ipynb +++ b/notebooks/CustomerScenarios/Case Study - Recommendation AB Testing at An Online Travel Company.ipynb @@ -467,7 +467,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -517,34 +517,34 @@ " point_estimate stderr zstat pvalue ci_lower ci_upper\n", "\n", "\n", - " days_visited_exp_pre 0.001 0.007 0.127 0.899 -0.01 0.012 \n", + " days_visited_exp_pre 0.0 0.007 0.017 0.986 -0.011 0.011 \n", "\n", "\n", - " days_visited_free_pre 0.283 0.007 38.176 0.0 0.271 0.295 \n", + " days_visited_free_pre 0.285 0.007 38.416 0.0 0.273 0.297 \n", "\n", "\n", - " days_visited_fs_pre -0.01 0.007 -1.49 0.136 -0.021 0.001 \n", + " days_visited_fs_pre -0.008 0.007 -1.214 0.225 -0.019 0.003 \n", "\n", "\n", - " days_visited_hs_pre -0.191 0.007 -28.288 0.0 -0.202 -0.18 \n", + " days_visited_hs_pre -0.191 0.007 -28.198 0.0 -0.202 -0.18 \n", "\n", "\n", - " days_visited_rs_pre 0.001 0.007 0.084 0.933 -0.011 0.012 \n", + " days_visited_rs_pre 0.001 0.007 0.089 0.929 -0.011 0.012 \n", "\n", "\n", - " days_visited_vrs_pre -0.0 0.007 -0.072 0.942 -0.012 0.011 \n", + " days_visited_vrs_pre -0.001 0.007 -0.14 0.889 -0.012 0.01 \n", "\n", "\n", - " locale_en_US -0.037 0.113 -0.324 0.746 -0.223 0.149 \n", + " locale_en_US -0.044 0.113 -0.387 0.699 -0.23 0.142 \n", "\n", "\n", - " revenue_pre -0.0 0.0 -1.2 0.23 -0.0 0.0 \n", + " revenue_pre -0.0 0.0 -0.806 0.42 -0.0 0.0 \n", "\n", "\n", - " os_type_osx 0.985 0.139 7.103 0.0 0.757 1.214 \n", + " os_type_osx 0.964 0.139 6.948 0.0 0.736 1.192 \n", "\n", "\n", - " os_type_windows 0.037 0.138 0.27 0.787 -0.19 0.265 \n", + " os_type_windows 0.024 0.138 0.172 0.863 -0.204 0.251 \n", "\n", "\n", "\n", @@ -553,7 +553,7 @@ " \n", "\n", "\n", - " \n", + " \n", "\n", "
point_estimate stderr zstat pvalue ci_lower ci_upper
cate_intercept 0.568 0.27 2.101 0.036 0.123 1.012cate_intercept 0.53 0.27 1.965 0.049 0.086 0.974


A linear parametric conditional average treatment effect (CATE) model was fitted:
$Y = \\Theta(X)\\cdot T + g(X, W) + \\epsilon$
where for every outcome $i$ and treatment $j$ the CATE $\\Theta_{ij}(X)$ has the form:
$\\Theta_{ij}(X) = \\phi(X)' coef_{ij} + cate\\_intercept_{ij}$
where $\\phi(X)$ is the output of the `featurizer` or $X$ if `featurizer`=None. Coefficient Results table portrays the $coef_{ij}$ parameter vector for each outcome $i$ and treatment $j$. Intercept Results table portrays the $cate\\_intercept_{ij}$ parameter." ], @@ -564,21 +564,21 @@ "============================================================================\n", " point_estimate stderr zstat pvalue ci_lower ci_upper\n", "----------------------------------------------------------------------------\n", - "days_visited_exp_pre 0.001 0.007 0.127 0.899 -0.01 0.012\n", - "days_visited_free_pre 0.283 0.007 38.176 0.0 0.271 0.295\n", - "days_visited_fs_pre -0.01 0.007 -1.49 0.136 -0.021 0.001\n", - "days_visited_hs_pre -0.191 0.007 -28.288 0.0 -0.202 -0.18\n", - "days_visited_rs_pre 0.001 0.007 0.084 0.933 -0.011 0.012\n", - "days_visited_vrs_pre -0.0 0.007 -0.072 0.942 -0.012 0.011\n", - "locale_en_US -0.037 0.113 -0.324 0.746 -0.223 0.149\n", - "revenue_pre -0.0 0.0 -1.2 0.23 -0.0 0.0\n", - "os_type_osx 0.985 0.139 7.103 0.0 0.757 1.214\n", - "os_type_windows 0.037 0.138 0.27 0.787 -0.19 0.265\n", + "days_visited_exp_pre 0.0 0.007 0.017 0.986 -0.011 0.011\n", + "days_visited_free_pre 0.285 0.007 38.416 0.0 0.273 0.297\n", + "days_visited_fs_pre -0.008 0.007 -1.214 0.225 -0.019 0.003\n", + "days_visited_hs_pre -0.191 0.007 -28.198 0.0 -0.202 -0.18\n", + "days_visited_rs_pre 0.001 0.007 0.089 0.929 -0.011 0.012\n", + "days_visited_vrs_pre -0.001 0.007 -0.14 0.889 -0.012 0.01\n", + "locale_en_US -0.044 0.113 -0.387 0.699 -0.23 0.142\n", + "revenue_pre -0.0 0.0 -0.806 0.42 -0.0 0.0\n", + "os_type_osx 0.964 0.139 6.948 0.0 0.736 1.192\n", + "os_type_windows 0.024 0.138 0.172 0.863 -0.204 0.251\n", " CATE Intercept Results \n", "===================================================================\n", " point_estimate stderr zstat pvalue ci_lower ci_upper\n", "-------------------------------------------------------------------\n", - "cate_intercept 0.568 0.27 2.101 0.036 0.123 1.012\n", + "cate_intercept 0.53 0.27 1.965 0.049 0.086 0.974\n", "-------------------------------------------------------------------\n", "\n", "A linear parametric conditional average treatment effect (CATE) model was fitted:\n", @@ -624,7 +624,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -670,7 +670,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -714,7 +714,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/notebooks/Double Machine Learning Examples.ipynb b/notebooks/Double Machine Learning Examples.ipynb index d792c5dc4..6cd657f74 100644 --- a/notebooks/Double Machine Learning Examples.ipynb +++ b/notebooks/Double Machine Learning Examples.ipynb @@ -72,7 +72,9 @@ "# Helper imports\n", "import numpy as np\n", "from itertools import product\n", - "from sklearn.linear_model import Lasso, LassoCV, LogisticRegression, LogisticRegressionCV,LinearRegression,MultiTaskElasticNet,MultiTaskElasticNetCV\n", + "from sklearn.linear_model import (Lasso, LassoCV, LogisticRegression,\n", + " LogisticRegressionCV,LinearRegression,\n", + " MultiTaskElasticNet,MultiTaskElasticNetCV)\n", "from sklearn.ensemble import RandomForestRegressor,RandomForestClassifier\n", "from sklearn.preprocessing import PolynomialFeatures\n", "import matplotlib.pyplot as plt\n", @@ -195,7 +197,15 @@ "cell_type": "code", "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The number of features in the final model (< 5) is too small for a sparse model. We recommend using the LinearDML estimator for this low-dimensional setting.\n" + ] + } + ], "source": [ "est1 = SparseLinearDML(model_y=RandomForestRegressor(),\n", " model_t=RandomForestRegressor(),\n", @@ -402,6 +412,14 @@ "execution_count": 15, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Final model doesn't have a `coef_stderr_` and `intercept_stderr_` attributes, only point estimates will be available.\n", + "Final model doesn't have a `coef_stderr_` and `intercept_stderr_` attributes, only point estimates will be available.\n" + ] + }, { "data": { "text/html": [ @@ -473,7 +491,7 @@ "\n", "\n", "\n", - " \n", + " \n", "\n", "\n", " \n", @@ -660,6 +678,13 @@ "execution_count": 19, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Final model doesn't have a `prediction_stderr` method, only point estimates will be returned.\n" + ] + }, { "data": { "text/html": [ diff --git a/notebooks/Policy Learning with Trees and Forests.ipynb b/notebooks/Policy Learning with Trees and Forests.ipynb new file mode 100644 index 000000000..02f160b3e --- /dev/null +++ b/notebooks/Policy Learning with Trees and Forests.ipynb @@ -0,0 +1,572 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "designed-drain", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "retired-asbestos", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from econml.policy import PolicyTree, PolicyForest\n", + "from econml.policy import DRPolicyTree, DRPolicyForest\n", + "from econml.dml import LinearDML\n", + "from econml.cate_interpreter import SingleTreePolicyInterpreter, SingleTreeCateInterpreter\n", + "import pandas as pd\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "neither-nudist", + "metadata": {}, + "source": [ + "# PolicyTree and PolicyForest\n", + "\n", + "These are basic tree and forest classes, that accept `X, y` where `y` is `(n_samples, n_outputs)` and\n", + "trains a tree to maximize the linear welfare criterion: ``, where the maximization is over functions from `X` to `{e_1, ..., e_{n_outputs}}`, representable by either a tree or a forest. The `predict` method returns the coordinate that achieves the maximum `y[i]` for each `X` based on the tree policy. The `predict_value` method returns the conditional mean value of all coordinates, conditional on `X`, for the leaf that `X` falls in. These classes can be used as building blocks for other functionalities, such as the `SingleTreePolicyInterpreter` or the `DRPolicyTree` or `DRPolicyForest`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "narrow-dutch", + "metadata": {}, + "outputs": [], + "source": [ + "X = np.random.normal(size=(1000, 10))\n", + "y = np.hstack([X[:, [0]] > 0, X[:, [0]] < 0])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "included-payday", + "metadata": {}, + "outputs": [], + "source": [ + "est = PolicyTree(min_impurity_decrease=.001, honest=True).fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "reserved-lover", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est.feature_importances_" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "accepted-collar", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(25, 5))\n", + "est.plot(treatment_names=['A', 'B'])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "chemical-coverage", + "metadata": {}, + "outputs": [], + "source": [ + "est = PolicyForest(honest=True).fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "compatible-audience", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est.feature_importances_" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "integral-interface", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 5))\n", + "plt.subplot(1, 2, 1)\n", + "plt.title('Policy')\n", + "plt.scatter(X[:, 0], est.predict(X))\n", + "plt.subplot(1, 2, 2)\n", + "plt.title('Conditional Values')\n", + "plt.scatter(X[:, 0], est.predict_value(X)[:, 0])\n", + "plt.scatter(X[:, 0], est.predict_value(X)[:, 1])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cultural-harbor", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 5))\n", + "est[0].plot(max_depth=2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "revolutionary-germany", + "metadata": {}, + "source": [ + "# Using Them for CATE Policy Interpretation\n", + "\n", + "We can use the `PolicyTree` to interpret a CATE model, in terms of actionable insights. This functionality is wrapped in the `SingleTreePolicyInterpreter` class." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "hazardous-shelf", + "metadata": {}, + "outputs": [], + "source": [ + "X = np.random.normal(size=(1000, 10))\n", + "T = np.random.binomial(2, .5, size=(1000,))\n", + "y = (X[:, 0]) * (T==1) + (-X[:, 0]) * (T==2) " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "affected-static", + "metadata": {}, + "outputs": [], + "source": [ + "est = LinearDML(discrete_treatment=True, linear_first_stages=False).fit(y, T, X=X)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "suspended-person", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "intrp = SingleTreePolicyInterpreter(include_model_uncertainty=True, max_depth=2, min_impurity_decrease=.001)\n", + "intrp.interpret(est, X, sample_treatment_costs=.2 * np.ones((X.shape[0], 2)))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "first-drunk", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 8))\n", + "intrp.plot(treatment_names=['None', 'A', 'B'])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "generous-internship", + "metadata": {}, + "source": [ + "# StandAlone Policy Learning\n", + "\n", + "We can also learn optimal policies directly from data without the need to train a CATE model first. This is achieved by our `DRPolicyTree` and `DRPolicyForest`, which trains a `PolicyTree` and `PolicyForest` correspondingly, on the doubly robust counterfactual outcome targets. This is the policy learning analogoue of the `DRLearner`, but rather than now trying to learn a good model of the treatment effect heterogeneity, we are learning a good treatment policy directly." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "superior-pocket", + "metadata": {}, + "outputs": [], + "source": [ + "X = np.random.normal(size=(4000, 10))\n", + "T = np.random.binomial(2, .5, size=(4000,))\n", + "y = (X[:, 0]) * (T==1) + (-X[:, 0]) * (T==2) + np.random.normal(0, 2, size=(4000,))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "educational-preference", + "metadata": {}, + "outputs": [], + "source": [ + "T = pd.DataFrame(T, columns=['A'])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "floral-packing", + "metadata": {}, + "outputs": [], + "source": [ + "est = DRPolicyTree(max_depth=2, min_impurity_decrease=0.01, honest=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "chicken-consultancy", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est.fit(y, T, X=X)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "sunrise-africa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "PolicyTree(max_depth=2, max_features='auto', min_impurity_decrease=0.01)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est.policy_model_" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "commercial-lodge", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,5))\n", + "est.plot(feature_names=['a'+str(i) for i in range(10)])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "level-outside", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.0000000e+00, 0.0000000e+00, 0.0000000e+00, 1.4362264e-16,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est.feature_importances_" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "immediate-environment", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 5))\n", + "plt.subplot(1, 2, 1)\n", + "plt.title('Policy')\n", + "plt.scatter(X[:, 0], est.predict(X))\n", + "plt.subplot(1, 2, 2)\n", + "plt.title('Conditional Values')\n", + "plt.scatter(X[:, 0], est.predict_value(X)[:, 0])\n", + "plt.scatter(X[:, 0], est.predict_value(X)[:, 1])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "monthly-milton", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est = DRPolicyForest(n_estimators=1000,\n", + " max_depth=2, \n", + " min_samples_leaf=50,\n", + " max_samples=.8,\n", + " honest=True,\n", + " min_impurity_decrease=0.01,\n", + " random_state=123)\n", + "est.fit(y, T, X=X)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "proper-strand", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 9.99995737e-01, -8.22828803e-18, 0.00000000e+00, 4.26279159e-06,\n", + " -1.93624697e-18, 0.00000000e+00, 6.35500631e-18, -1.60548923e-17,\n", + " -5.05463704e-18, -9.23837499e-18])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est.feature_importances_" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "commercial-quantum", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "PolicyForest(max_depth=2, max_samples=0.8, min_impurity_decrease=0.01,\n", + " min_samples_leaf=50, random_state=123)" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est.policy_model_" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "regulation-breakdown", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 5))\n", + "plt.subplot(1, 2, 1)\n", + "plt.title('Policy')\n", + "plt.scatter(X[:, 0], est.predict(X))\n", + "plt.subplot(1, 2, 2)\n", + "plt.title('Conditional Values')\n", + "plt.scatter(X[:, 0], est.predict_value(X)[:, 0])\n", + "plt.scatter(X[:, 0], est.predict_value(X)[:, 1])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "mental-invasion", + "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.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}
Coefficient Results
point_estimate stderr zstat pvalue ci_lower ci_upper point_estimate stderr zstat pvalue ci_lower ci_upper
X0 -0.054 0.685 -0.079 0.937 -1.18 1.072