diff --git a/.gitignore b/.gitignore index 4ec86e3..6aa9052 100644 --- a/.gitignore +++ b/.gitignore @@ -53,15 +53,15 @@ junit/ *.mo *.pot -# Django stuff: +# Django stuff *.log local_settings.py -# Flask stuff: +# Flask stuff instance/ .webassets-cache -# Scrapy stuff: +# Scrapy stuff .scrapy # Sphinx documentation diff --git a/README.rst b/README.rst index 22bf451..e7c2898 100644 --- a/README.rst +++ b/README.rst @@ -1,4 +1,6 @@ +.. image:: https://github.com/PythonPredictions/cobra/raw/master/material/logo.png + :width: 700 .. image:: https://img.shields.io/pypi/v/pythonpredictions-cobra.svg :target: https://pypi.org/project/pythonpredictions-cobra/ @@ -9,15 +11,9 @@ ------------------------------------------------------------------------------------------------------------------------------------ -===== -cobra -===== -.. image:: material\logo.png - :width: 300 +**Cobra** is a Python package to build predictive models using linear or logistic regression with a focus on performance and interpretation. It consists of several modules for data preprocessing, feature selection and model evaluation. The underlying methodology was developed at `Python Predictions `_ in the course of hundreds of business-related prediction challenges. It has been tweaked, tested and optimized over the years based on feedback from clients, our team, and academic researchers. -**cobra** is a Python package to build predictive models using logistic regression with a focus on performance and interpretation. It consists of several modules for data preprocessing, feature selection and model evaluation. The underlying methodology was developed at Python Predictions in the course of hundreds of business-related prediction challenges. It has been tweaked, tested and optimized over the years based on feedback from clients, our team, and academic researchers. - -Main Features +Main features ============= - Prepare a given pandas DataFrame for predictive modelling: @@ -25,10 +21,10 @@ Main Features - partition into train/selection/validation sets - create bins from continuous variables - regroup categorical variables based on statistical significance - - replace missing values and - - add columns with incidence rate per category/bin + - replace missing values + - add columns where categories/bins are replaced with average of target values (linear regression) or with incidence rate (logistic regression) -- Perform univariate feature selection based on AUC +- Perform univariate feature selection based on RMSE (linear regression) or AUC (logistic regression) - Compute correlation matrix of predictors - Find the suitable variables using forward feature selection - Evaluate model performance and visualize the results @@ -41,49 +37,40 @@ These instructions will get you a copy of the project up and running on your loc Requirements ------------ -This package requires the usual Python packages for data science: - -- numpy (>=1.19.4) -- pandas (>=1.1.5) -- scipy (>=1.5.4) -- scikit-learn (>=0.23.1) -- matplotlib (>=3.3.3) -- seaborn (>=0.11.0) - - -These packages, along with their versions are listed in ``requirements.txt`` and can be installed using ``pip``: :: - +This package requires only the usual Python libraries for data science, being numpy, pandas, scipy, scikit-learn, matplotlib, seaborn, and tqdm. These packages, along with their versions are listed in ``requirements.txt`` and can be installed using ``pip``: :: pip install -r requirements.txt -**Note**: if you want to install cobra with e.g. pip, you don't have to install all of these requirements as these are automatically installed with cobra itself. +**Note**: if you want to install Cobra with e.g. pip, you don't have to install all of these requirements as these are automatically installed with Cobra itself. Installation ------------ -The easiest way to install cobra is using ``pip``: :: +The easiest way to install Cobra is using ``pip``: :: pip install -U pythonpredictions-cobra -Contributing to cobra -===================== -We'd love you to contribute to the development of cobra! There are many ways in which you can contribute, the most common of which is to contribute to the source code or documentation of the project. However, there are many other ways you can contribute (report issues, improve code coverage by adding unit tests, ...). -We use GitHub issue to track all bugs and feature requests. Feel free to open an issue in case you found a bug or in case you wish to see a new feature added. +Documentation and extra material +================================ + +- A `blog post `_ on the overall methodology. + +- A `research article `_ by Geert Verstraeten (co-founder Python Predictions) discussing the preprocessing approach we use in Cobra. -For more details, check our `wiki `_. +- HTML documentation of the `individual modules `_. -Help and Support -================ +- A step-by-step `tutorial `_ for **logistic regression**. -Documentation -------------- +- A step-by-step `tutorial `__ for **linear regression**. -- HTML documentation of the `individual modules `_ -- A step-by-step `tutorial `_ +- Check out the Data Science Leuven Meetup `talk `_ by one of the core developers (second presentation). His `slides `_ and `related material `_ are also available. + +Contributing to Cobra +===================== -Outreach -------------- +We'd love you to contribute to the development of Cobra! There are many ways in which you can contribute, the most common of which is to contribute to the source code or documentation of the project. However, there are many other ways you can contribute (report issues, improve code coverage by adding unit tests, ...). +We use GitHub issues to track all bugs and feature requests. Feel free to open an issue in case you found a bug or in case you wish to see a new feature added. -- Check out the Data Science Leuven Meetup `talk `_ by one of the core developers (second presentation) +For more details, check out our `wiki `_. diff --git a/cobra/__init__.py b/cobra/__init__.py index e69de29..7152555 100644 --- a/cobra/__init__.py +++ b/cobra/__init__.py @@ -0,0 +1 @@ +from .version import __version__ \ No newline at end of file diff --git a/cobra/evaluation/__init__.py b/cobra/evaluation/__init__.py index a757fe0..1f8f487 100644 --- a/cobra/evaluation/__init__.py +++ b/cobra/evaluation/__init__.py @@ -8,8 +8,8 @@ from .plotting_utils import plot_univariate_predictor_quality from .plotting_utils import plot_correlation_matrix -from .evaluator import Evaluator - +# from .evaluator import Evaluator +from .evaluator import ClassificationEvaluator, RegressionEvaluator __all__ = ["generate_pig_tables", "compute_pig_table", @@ -18,4 +18,5 @@ "plot_variable_importance", "plot_univariate_predictor_quality", "plot_correlation_matrix", - "Evaluator"] + "ClassificationEvaluator", + "RegressionEvaluator"] diff --git a/cobra/evaluation/evaluator.py b/cobra/evaluation/evaluator.py index b5ac92f..5a530dc 100644 --- a/cobra/evaluation/evaluator.py +++ b/cobra/evaluation/evaluator.py @@ -1,9 +1,15 @@ + import numpy as np import pandas as pd import matplotlib.pyplot as plt +import matplotlib.ticker as mticker import seaborn as sns +from numpy import sqrt +from scipy.stats import norm + +# classification from sklearn.metrics import precision_score from sklearn.metrics import recall_score from sklearn.metrics import f1_score @@ -14,38 +20,50 @@ from sklearn.metrics import matthews_corrcoef from sklearn.exceptions import NotFittedError +# regression +from sklearn.metrics import mean_absolute_error +from sklearn.metrics import mean_squared_error +from sklearn.metrics import r2_score -class Evaluator(): - - """Summary +class ClassificationEvaluator(): + """Evaluator class encapsulating classification model metrics + and plotting functionality. Attributes ---------- + y_true : np.ndarray + True binary target data labels. + y_pred : np.ndarray + Target scores of the model. confusion_matrix : np.ndarray - Confusion matrix computed for a particular cut-off + Confusion matrix computed for a particular cut-off. cumulative_gains : tuple - data for plotting cumulative gains curve + Data for plotting cumulative gains curve. evaluation_metrics : dict - map containing various scalar evaluation metics such as AUC, ... + Map containing various scalar evaluation metrics (precision, recall, accuracy, AUC, F1, etc.). lift_at : float - parameter to determine at which top level percentage the lift of the - model should be computed + Parameter to determine at which top level percentage the lift of the + model should be computed. lift_curve : tuple - data for plotting lift curve(s) + Data for plotting lift curve(s). probability_cutoff : float - probability cut off to convert probability scores to a binary score + Probability cut off to convert probability scores to a binary score. roc_curve : dict - map containing true-positive-rate, false-positive-rate at various - thresholds (also incl.) + Map containing true-positive-rate, false-positive-rate at various + thresholds (also incl.). n_bins : int, optional - defines the number of bins used to calculate the lift curve for - (by default 10, so deciles) + Defines the number of bins used to calculate the lift curve for + (by default 10, so deciles). """ - def __init__(self, probability_cutoff: float=None, + def __init__(self, + probability_cutoff: float=None, lift_at: float=0.05, n_bins: int = 10): + self.y_true = None + self.y_pred = None + self.lift_at = lift_at self.probability_cutoff = probability_cutoff self.n_bins = n_bins @@ -59,64 +77,73 @@ def __init__(self, probability_cutoff: float=None, def fit(self, y_true: np.ndarray, y_pred: np.ndarray): """Fit the evaluator by computing the relevant evaluation metrics on - the inputs + the inputs. Parameters ---------- y_true : np.ndarray - true labels + True labels. y_pred : np.ndarray - model scores (as probability) + Model scores (as probability). """ fpr, tpr, thresholds = roc_curve(y_true=y_true, y_score=y_pred) - # if probability_cutoff is not set, take the optimal cut off + # if probability_cutoff is not set, take the optimal cut-off if not self.probability_cutoff: - self.probability_cutoff = (Evaluator. + self.probability_cutoff = (ClassificationEvaluator. _compute_optimal_cutoff(fpr, tpr, thresholds)) - # Transform probabilities to binary array using cut off: + # Transform probabilities to binary array using cut-off y_pred_b = np.array([0 if pred <= self.probability_cutoff else 1 for pred in y_pred]) # Compute the various evaluation metrics - self.scalar_metrics = Evaluator.compute_scalar_metrics( + self.scalar_metrics = ClassificationEvaluator._compute_scalar_metrics( y_true, y_pred, y_pred_b, self.lift_at ) + self.y_true = y_true + self.y_pred = y_pred + self.roc_curve = {"fpr": fpr, "tpr": tpr, "thresholds": thresholds} self.confusion_matrix = confusion_matrix(y_true, y_pred_b) - self.lift_curve = Evaluator._compute_lift_per_bin(y_true, y_pred, self.n_bins) - self.cumulative_gains = Evaluator._compute_cumulative_gains(y_true, - y_pred) + self.lift_curve = ClassificationEvaluator._compute_lift_per_bin(y_true, y_pred, self.n_bins) + self.cumulative_gains = ClassificationEvaluator._compute_cumulative_gains(y_true, y_pred) @staticmethod - def compute_scalar_metrics(y_true: np.ndarray, - y_pred: np.ndarray, - y_pred_b: np.ndarray, - lift_at: float) -> pd.Series: + def _compute_scalar_metrics(y_true: np.ndarray, + y_pred: np.ndarray, + y_pred_b: np.ndarray, + lift_at: float) -> pd.Series: """Convenient function to compute various scalar performance measures - and return them in a pd.Series + and return them in a pd.Series. Parameters ---------- y_true : np.ndarray - True binary target data labels + True binary target data labels. y_pred : np.ndarray - Target scores of the model + Target scores of the model. y_pred_b : np.ndarray - Predicted target data labels (binary) + Predicted target data labels (binary). lift_at : float - At what top level percentage the lift should be computed + At what top level percentage the lift should be computed. Returns ------- pd.Series - contains various performance measures of the model + Contains various performance measures of the model, being: + Accuracy + AUC + Precision + Recall + F1 + Matthews correlation coefficient + Lift at given percentage """ return pd.Series({ "accuracy": accuracy_score(y_true, y_pred_b), @@ -125,22 +152,21 @@ def compute_scalar_metrics(y_true: np.ndarray, "recall": recall_score(y_true, y_pred_b), "F1": f1_score(y_true, y_pred_b, average=None)[1], "matthews_corrcoef": matthews_corrcoef(y_true, y_pred_b), - "lift at {}".format(lift_at): np.round(Evaluator - ._compute_lift( - y_true=y_true, - y_pred=y_pred, - lift_at=lift_at), 2) + "lift at {}".format(lift_at): np.round(ClassificationEvaluator + ._compute_lift(y_true=y_true, + y_pred=y_pred, + lift_at=lift_at), 2) }) def plot_roc_curve(self, path: str=None, dim: tuple=(12, 8)): - """Plot ROC curves of the model + """Plot ROC curve of the model. Parameters ---------- path : str, optional - path to store the figure + Path to store the figure. dim : tuple, optional - tuple with width and lentgh of the plot + Tuple with width and length of the plot. """ if self.roc_curve is None: @@ -165,7 +191,7 @@ def plot_roc_curve(self, path: str=None, dim: tuple=(12, 8)): ax.set_xlabel("False Positive Rate", fontsize=15) ax.set_ylabel("True Positive Rate", fontsize=15) ax.legend(loc="lower right") - ax.set_title("ROC Curve", fontsize=20) + ax.set_title("ROC curve", fontsize=20) if path: plt.savefig(path, format="png", dpi=300, bbox_inches="tight") @@ -174,16 +200,16 @@ def plot_roc_curve(self, path: str=None, dim: tuple=(12, 8)): def plot_confusion_matrix(self, path: str=None, dim: tuple=(12, 8), labels: list=["0", "1"]): - """Plot the confusion matrix + """Plot the confusion matrix. Parameters ---------- path : str, optional - path to store the figure + Path to store the figure. dim : tuple, optional - tuple with width and lentgh of the plot + Tuple with width and length of the plot. labels : list, optional - Optional list of labels, default "0" and "1" + Optional list of labels, default "0" and "1". """ if self.confusion_matrix is None: @@ -205,14 +231,14 @@ def plot_confusion_matrix(self, path: str=None, dim: tuple=(12, 8), plt.show() def plot_cumulative_response_curve(self, path: str=None, dim: tuple=(12, 8)): - """Plot cumulative response curve + """Plot cumulative response curve. Parameters ---------- path : str, optional - path to store the figure + Path to store the figure. dim : tuple, optional - tuple with width and lentgh of the plot + Tuple with width and length of the plot. """ if self.lift_curve is None: @@ -238,17 +264,17 @@ def plot_cumulative_response_curve(self, path: str=None, dim: tuple=(12, 8)): plt.axhline(y=inc_rate*100, color="darkorange", linestyle="--", xmin=0.05, xmax=0.95, linewidth=3, label="Incidence") - #Legend + # Legend ax.legend(loc="upper right") - ##Set Axis - make them pretty + # Set Axis - make them pretty sns.despine(ax=ax, right=True, left=True) - #Remove white lines from the second axis + # Remove white lines from the second axis ax.grid(False) - ##Description - ax.set_title("Cumulative response", fontsize=20) + # Description + ax.set_title("Cumulative Response curve", fontsize=20) if path is not None: plt.savefig(path, format="png", dpi=300, bbox_inches="tight") @@ -256,14 +282,14 @@ def plot_cumulative_response_curve(self, path: str=None, dim: tuple=(12, 8)): plt.show() def plot_lift_curve(self, path: str=None, dim: tuple=(12, 8)): - """Plot lift per decile + """Plot lift per decile. Parameters ---------- path : str, optional - path to store the figure + Path to store the figure. dim : tuple, optional - tuple with width and lentgh of the plot + Tuple with width and length of the plot. """ if self.lift_curve is None: @@ -287,17 +313,17 @@ def plot_lift_curve(self, path: str=None, dim: tuple=(12, 8)): plt.axhline(y=1, color="darkorange", linestyle="--", xmin=0.05, xmax=0.95, linewidth=3, label="Baseline") - #Legend + # Legend ax.legend(loc="upper right") - ##Set Axis - make them pretty + # Set Axis - make them pretty sns.despine(ax=ax, right=True, left=True) - #Remove white lines from the second axis + # Remove white lines from the second axis ax.grid(False) - ##Description - ax.set_title("Cumulative Lift", fontsize=20) + # Description + ax.set_title("Cumulative Lift curve", fontsize=20) if path is not None: plt.savefig(path, format="png", dpi=300, bbox_inches="tight") @@ -305,14 +331,14 @@ def plot_lift_curve(self, path: str=None, dim: tuple=(12, 8)): plt.show() def plot_cumulative_gains(self, path: str=None, dim: tuple=(12, 8)): - """Plot lift per decile + """Plot cumulative gains per decile. Parameters ---------- path : str, optional - path to store the figure + Path to store the figure. dim : tuple, optional - tuple with width and lentgh of the plot + Tuple with width and length of the plot. """ with plt.style.context("seaborn-whitegrid"): @@ -324,68 +350,72 @@ def plot_cumulative_gains(self, path: str=None, dim: tuple=(12, 8)): ax.plot(ax.get_xlim(), ax.get_ylim(), linewidth=3, ls="--", color="darkorange", label="random selection") - ax.set_title("Cumulative Gains", fontsize=20) + ax.set_title("Cumulative Gains curve", fontsize=20) - #Format axes + # Format axes ax.set_xlim([0, 100]) ax.set_ylim([0, 105]) - #Format ticks - ax.set_yticklabels(["{:3.0f}%".format(x) - for x in ax.get_yticks()]) - ax.set_xticklabels(["{:3.0f}%".format(x) - for x in ax.get_xticks()]) - #Legend + + # Format ticks + ticks_loc_y = ax.get_yticks().tolist() + ax.yaxis.set_major_locator(mticker.FixedLocator(ticks_loc_y)) + ax.set_yticklabels(["{:3.0f}%".format(x) for x in ticks_loc_y]) + + ticks_loc_x = ax.get_xticks().tolist() + ax.xaxis.set_major_locator(mticker.FixedLocator(ticks_loc_x)) + ax.set_xticklabels(["{:3.0f}%".format(x) for x in ticks_loc_x]) + + # Legend ax.legend(loc="lower right") if path is not None: plt.savefig(path, format="png", dpi=300, bbox_inches="tight") - plt.show() @staticmethod - def find_optimal_cutoff(y_true: np.ndarray, - y_pred: np.ndarray) -> float: + def _find_optimal_cutoff(y_true: np.ndarray, + y_pred: np.ndarray) -> float: """Find the optimal probability cut off point for a - classification model. Wrapper around _compute_optimal_cutoff + classification model. Wrapper around _compute_optimal_cutoff. Parameters ---------- y_true : np.ndarray - True binary target data labels + True binary target data labels. y_pred : np.ndarray - Target scores of the model + Target scores of the model. Returns ------- float - Optimal cut off probability for the model + Optimal cut-off probability for the model. """ - return Evaluator._compute_optimal_cutoff(roc_curve(y_true=y_true, - y_score=y_pred)) + return ClassificationEvaluator._compute_optimal_cutoff(roc_curve(y_true=y_true, + y_score=y_pred)) @staticmethod def _compute_optimal_cutoff(fpr: np.ndarray, tpr: np.ndarray, thresholds: np.ndarray) -> float: - """Find the optimal probability cut off point for a - classification model + """Find the optimal probability cut-off point for a + classification model. + + The optimal cut-off would be where TPR is high and FPR is low, hence + TPR - (1-FPR) should be zero or close to zero for the optimal cut-off. Parameters ---------- fpr : np.ndarray - false positive rate for various thresholds + False positive rate for various thresholds. tpr : np.ndarray - true positive rate for various thresholds + True positive rate for various thresholds. thresholds : np.ndarray - list of thresholds for which fpr and tpr were computed + List of thresholds for which fpr and tpr were computed. Returns ------- float - Description + Optimal probability cut-off point. """ - - # The optimal cut off would be where tpr is high and fpr is low, hence - # tpr - (1-fpr) should be zero or close to zero for the optimal cut off temp = np.absolute(tpr - (1-fpr)) # index for optimal value is the one for which temp is minimal @@ -397,7 +427,7 @@ def _compute_optimal_cutoff(fpr: np.ndarray, tpr: np.ndarray, def _compute_cumulative_gains(y_true: np.ndarray, y_pred: np.ndarray) -> tuple: """Compute cumulative gains of the model, returns percentages and - gains cummulative gains curves + gains cumulative gains curves. Code from (https://github.com/reiinakano/scikit-plot/blob/ 2dd3e6a76df77edcbd724c4db25575f70abb57cb/ @@ -406,14 +436,14 @@ def _compute_cumulative_gains(y_true: np.ndarray, Parameters ---------- y_true : np.ndarray - True binary target data labels + True binary target data labels. y_pred : np.ndarray - Target scores of the model + Target scores of the model. Returns ------- tuple - x-labels, gains + With x-labels, and gains. """ # make y_true a boolean vector @@ -436,29 +466,29 @@ def _compute_cumulative_gains(y_true: np.ndarray, @staticmethod def _compute_lift_per_bin(y_true: np.ndarray, y_pred: np.ndarray, - n_bins: int = 10) -> tuple: + n_bins: int=10) -> tuple: """Compute lift of the model for a given number of bins, returns x-labels, - lifts and the target incidence to create cumulative response curves + lifts and the target incidence to create cumulative response curves. Parameters ---------- y_true : np.ndarray - True binary target data labels + True binary target data labels. y_pred : np.ndarray - Target scores of the model + Target scores of the model. n_bins : int, optional - defines the number of bins used to calculate the lift curve for - (by default 10, so deciles) + Defines the number of bins used to calculate the lift curve for + (by default 10, so deciles). Returns ------- tuple - x-labels, lifts per decile and target incidence + Includes x-labels, lifts per decile, and target incidence. """ - lifts = [Evaluator._compute_lift(y_true=y_true, - y_pred=y_pred, - lift_at=perc_lift) + lifts = [ClassificationEvaluator._compute_lift(y_true=y_true, + y_pred=y_pred, + lift_at=perc_lift) for perc_lift in np.linspace(1/n_bins, 1, num=n_bins, endpoint=True)] x_labels = [len(lifts)-x for x in np.arange(0, len(lifts), 1)] @@ -468,50 +498,233 @@ def _compute_lift_per_bin(y_true: np.ndarray, @staticmethod def _compute_lift(y_true: np.ndarray, y_pred: np.ndarray, lift_at: float=0.05) -> float: - """Calculates lift given two arrays on specified level - %timeit - 50.3 µs ± 1.94 µs per loop (mean ± std. dev. of 7 runs, - 10000 loops each) + """Calculates lift given two arrays on specified level. Parameters ---------- y_true : np.ndarray - True binary target data labels + True binary target data labels. y_pred : np.ndarray - Target scores of the model + Target scores of the model. lift_at : float, optional - At what top level percentage the lift should be computed + At what top level percentage the lift should be computed. Returns ------- float - lift of the model + Lift of the model. """ - #Make sure it is numpy array + # Make sure it is numpy array y_true_ = np.array(y_true) y_pred_ = np.array(y_pred) - #Make sure it has correct shape + # Make sure it has correct shape y_true_ = y_true_.reshape(len(y_true_), 1) y_pred_ = y_pred_.reshape(len(y_pred_), 1) - #Merge data together + # Merge data together y_data = np.hstack([y_true_, y_pred_]) - #Calculate necessary variables + # Calculate necessary variables nrows = len(y_data) stop = int(np.floor(nrows*lift_at)) avg_incidence = np.einsum("ij->j", y_true_)/float(len(y_true_)) - #Sort and filter data + # Sort and filter data data_sorted = (y_data[y_data[:, 1].argsort()[::-1]][:stop, 0] .reshape(stop, 1)) - #Calculate lift (einsum is very fast way of summing, - # needs specific shape) + # Calculate lift (einsum is a very fast way of summing, but needs specific shape) inc_in_top_n = np.einsum("ij->j", data_sorted)/float(len(data_sorted)) lift = np.round(inc_in_top_n/avg_incidence, 2)[0] return lift + + +class RegressionEvaluator(): + """Evaluator class encapsulating regression model metrics + and plotting functionality. + + Attributes + ---------- + y_true : np.ndarray + True binary target data labels. + y_pred : np.ndarray + Target scores of the model. + scalar_metrics : dict + Map containing various scalar evaluation metrics (R-squared, MAE, MSE, RMSE) + qq : pd.Series + Theoretical quantiles and associated actual residuals. + """ + + def __init__(self): + + self.y_true = None + self.y_pred = None + + # Placeholder to store fitted output + self.scalar_metrics = None + self.qq = None + + def fit(self, y_true: np.ndarray, y_pred: np.ndarray): + """Fit the evaluator by computing the relevant evaluation metrics on + the inputs. + + Parameters + ---------- + y_true : np.ndarray + True labels. + y_pred : np.ndarray + Model scores. + """ + # Compute the various evaluation metrics + self.scalar_metrics = RegressionEvaluator._compute_scalar_metrics(y_true, y_pred) + + self.y_true = y_true + self.y_pred = y_pred + + # Compute qq info + self.qq = RegressionEvaluator._compute_qq_residuals(y_true, y_pred) + + @staticmethod + def _compute_scalar_metrics(y_true: np.ndarray, + y_pred: np.ndarray) -> pd.Series: + """Convenient function to compute various scalar performance measures + and return them in a pd.Series. + + Parameters + ---------- + y_true : np.ndarray + True binary target data labels. + y_pred : np.ndarray + Target scores of the model. + + Returns + ------- + pd.Series + Contains various performance measures of the model, being: + R-squared (coefficient of determination, usually denoted as R-squared) + Mean absolute error (expected value of the absolute error loss) + Mean squared error (expected value of the quadratic error) + Root mean squared error (sqrt of expected value of the quadratic error) + """ + return pd.Series({ + "R2": r2_score(y_true, y_pred), + "MAE": mean_absolute_error(y_true, y_pred), + "MSE": mean_squared_error(y_true, y_pred), + "RMSE": sqrt(mean_squared_error(y_true, y_pred)) + }) + + @staticmethod + def _compute_qq_residuals(y_true: np.ndarray, + y_pred: np.ndarray) -> pd.Series: + """Convenience function to compute various scalar performance measures + and return them in a pd.Series. + + Parameters + ---------- + y_true : np.ndarray + True binary target data labels. + y_pred : np.ndarray + Target scores of the model. + + Returns + ------- + pd.Series + Theoretical quantiles and associated actual residuals. + """ + ## also possible directly via statsmodels.api.qqplot() + + n = len(y_true) + + df = pd.DataFrame({"res": sorted((y_true - y_pred))}) # ascending order + m, s = df["res"].mean(), df["res"].std() + + df["z_res"] = df["res"].apply(lambda x: (x-m)/s) + df["rank"] = df.index+1 + df["percentile"] = df["rank"].apply(lambda x: x/(n+1)) # divide by n+1 to avoid inf + df["q_theoretical"] = norm.ppf(df["percentile"]) + + return pd.Series({ + "quantiles": df["q_theoretical"].values, + "residuals": df["z_res"].values, + }) + + def plot_predictions(self, path: str=None, dim: tuple=(12, 8)): + """Plot predictions from the model against actual values. + + Parameters + ---------- + path : str, optional + Path to store the figure. + dim : tuple, optional + Tuple with width and length of the plot. + """ + if self.y_true is None and self.y_pred is None: + msg = ("This {} instance is not fitted yet. Call 'fit' with " + "appropriate arguments before using this method.") + + y_true = self.y_true + y_pred = self.y_pred + + with plt.style.context("seaborn-whitegrid"): + + fig, ax = plt.subplots(figsize=dim) + + x = np.arange(1, len(y_true)+1) + + ax.plot(x, y_true, ls="--", label="actuals", color="darkorange", linewidth=3) + ax.plot(x, y_pred, label="predictions", color="cornflowerblue", linewidth=3) + + ax.set_xlabel("Index", fontsize=15) + ax.set_ylabel("Value", fontsize=15) + ax.legend(loc="best") + ax.set_title("Predictions vs. Actuals", fontsize=20) + + if path: + plt.savefig(path, format="png", dpi=300, bbox_inches="tight") + + plt.show() + + def plot_qq(self, path: str=None, dim: tuple=(12, 8)): + """Display a Q-Q plot from the standardized prediction residuals. + + Parameters + ---------- + path : str, optional + Path to store the figure. + dim : tuple, optional + Tuple with width and length of the plot. + """ + + if self.qq is None: + msg = ("This {} instance is not fitted yet. Call 'fit' with " + "appropriate arguments before using this method.") + + raise NotFittedError(msg.format(self.__class__.__name__)) + + with plt.style.context("seaborn-whitegrid"): + + fig, ax = plt.subplots(figsize=dim) + + x = self.qq["quantiles"] + y = self.qq["residuals"] + + ax.plot(x, x, ls="--", label="perfect model", color="darkorange", linewidth=3) + ax.plot(x, y, label="current model", color="cornflowerblue", linewidth=3) + + ax.set_xlabel("Theoretical quantiles", fontsize=15) + ax.set_xticks(range(int(np.floor(min(x))), int(np.ceil(max(x[x < float("inf")])))+1, 1)) + + ax.set_ylabel("Standardized residuals", fontsize=15) + ax.set_yticks(range(int(np.floor(min(y))), int(np.ceil(max(y[x < float("inf")])))+1, 1)) + + ax.legend(loc="best") + ax.set_title("Q-Q plot", fontsize=20) + + if path: + plt.savefig(path, format="png", dpi=300, bbox_inches="tight") + + plt.show() \ No newline at end of file diff --git a/cobra/evaluation/pigs_tables.py b/cobra/evaluation/pigs_tables.py index 3e39411..7f03b42 100644 --- a/cobra/evaluation/pigs_tables.py +++ b/cobra/evaluation/pigs_tables.py @@ -1,3 +1,4 @@ + import pandas as pd import matplotlib.pyplot as plt import seaborn as sns @@ -6,113 +7,132 @@ import cobra.utils as utils - -def generate_pig_tables(data: pd.DataFrame, +def generate_pig_tables(basetable: pd.DataFrame, id_column_name: str, target_column_name: str, preprocessed_predictors: list) -> pd.DataFrame: - """Compute PIG tables for all predictors in preprocessed_predictors. The - output is a DataFrame with columns ``variable``, ``label``, ``pop_size``, - ``avg_incidence`` and ``incidence`` + """Compute PIG tables for all predictors in preprocessed_predictors. + + The output is a DataFrame with columns ``variable``, ``label``, + ``pop_size``, ``global_avg_target`` and ``avg_target``. Parameters ---------- - data : pd.DataFrame - basetable to compute PIG tables of + basetable : pd.DataFrame + Basetable to compute PIG tables from. id_column_name : str - column name of the id (e.g. customernumber) + Name of the basetable column containing the IDs of the basetable rows + (e.g. customernumber). target_column_name : str - column name of the target - predictors: list - list of preprocessed predictor names + Name of the basetable column containing the target values to predict. + preprocessed_predictors: list + List of basetable column names containing preprocessed predictors. Returns ------- pd.DataFrame - DataFrame containing a PIG table for all predictors + DataFrame containing a PIG table for all predictors. """ - - pigs = [compute_pig_table(data, column_name, target_column_name, - id_column_name) - for column_name in sorted(preprocessed_predictors) - if column_name not in [id_column_name, target_column_name]] - + pigs = [ + compute_pig_table(basetable, + column_name, + target_column_name, + id_column_name) + for column_name in sorted(preprocessed_predictors) + if column_name not in [id_column_name, target_column_name] + ] output = pd.concat(pigs) - return output -def compute_pig_table(data: pd.DataFrame, - column_name: str, +def compute_pig_table(basetable: pd.DataFrame, + predictor_column_name: str, target_column_name: str, id_column_name: str) -> pd.DataFrame: - """Compute the pig table of a given predictor for a given target + """Compute the PIG table of a given predictor for a given target. Parameters ---------- - data : pd.DataFrame - input data from which to compute the pig table - column_name : str - predictor name of which to compute the pig table + basetable : pd.DataFrame + Input data from which to compute the pig table. + predictor_column_name : str + Predictor name of which to compute the pig table. target_column_name : str - name of the target variable + Name of the target variable. id_column_name : str - name of the id column (used to count population size) + Name of the id column (used to count population size). Returns ------- pd.DataFrame - pig table as a DataFrame + PIG table as a DataFrame """ - avg_incidence = data[target_column_name].mean() + global_avg_target = basetable[target_column_name].mean() # group by the binned variable, compute the incidence # (=mean of the target for the given bin) and compute the bin size # (e.g. COUNT(id_column_name)). After that, rename the columns - res = (data.groupby(column_name) - .agg({target_column_name: "mean", id_column_name: "size"}) - .reset_index() - .rename(columns={column_name: "label", - target_column_name: "incidence", - id_column_name: "pop_size"})) + res = (basetable.groupby(predictor_column_name) + .agg({target_column_name: "mean", id_column_name: "size"}) + .reset_index() + .rename(columns={predictor_column_name: "label", + target_column_name: "avg_target", + id_column_name: "pop_size"})) # add the column name to a variable column # add the average incidence # replace population size by a percentage of total population - res["variable"] = utils.clean_predictor_name(column_name) - res["avg_incidence"] = avg_incidence - res["pop_size"] = res["pop_size"]/len(data.index) + res["variable"] = utils.clean_predictor_name(predictor_column_name) + res["global_avg_target"] = global_avg_target + res["pop_size"] = res["pop_size"]/len(basetable.index) # make sure to always return the data with the proper column order column_order = ["variable", "label", "pop_size", - "avg_incidence", "incidence"] + "global_avg_target", "avg_target"] return res[column_order] -def plot_incidence(df: pd.DataFrame, variable: str, - column_order: list = None, dim: tuple = (12, 8)): - """Function plots Predictor Incidence Graphs (PIGs). - Bins are ordered in descening order of bin incidence - unless specified otherwise with `column_order` list. +def plot_incidence(pig_tables: pd.DataFrame, + variable: str, + model_type: str, + column_order: list=None, + dim: tuple=(12, 8)): + """Plots a Predictor Insights Graph (PIG), a graph in which the mean + target value is plotted for a number of bins constructed from a predictor + variable. When the target is a binary classification target, + the plotted mean target value is a true incidence rate. + + Bins are ordered in descending order of mean target value + unless specified otherwise with the `column_order` list. + Parameters ---------- - df: pd.DataFrame - dataframe with cleaned, binned, partitioned and prepared data + pig_tables: pd.DataFrame + Dataframe with cleaned, binned, partitioned and prepared data, + as created by generate_pig_tables() from this module. variable: str - variable for which the incidence plot will be shown + Name of the predictor variable for which the PIG will be plotted. + model_type: str + Type of model (either "classification" or "regression"). column_order: list, default=None - explicit order of variable + Explicit order of the value bins of the predictor variable to be used + on the PIG. dim: tuple, default=(12, 8) - tuple with width and lentgh of the plot + Optional tuple to configure the width and length of the plot. """ - df_plot = df[df['variable'] == variable].copy() + if model_type not in ["classification", "regression"]: + raise ValueError("An unexpected value was set for the model_type " + "parameter. Expected 'classification' or " + "'regression'.") - if column_order is not None: + df_plot = pig_tables[pig_tables['variable'] == variable].copy() + if column_order is not None: if not set(df_plot['label']) == set(column_order): raise ValueError( - 'Variables in column_order and dataframe are not equal') + 'The column_order and pig_tables parameters do not contain ' + 'the same set of variables.') df_plot['label'] = df_plot['label'].astype('category') df_plot['label'].cat.reorder_categories(column_order, @@ -121,39 +141,62 @@ def plot_incidence(df: pd.DataFrame, variable: str, df_plot.sort_values(by=['label'], ascending=True, inplace=True) df_plot.reset_index(inplace=True) else: - df_plot.sort_values(by=['incidence'], ascending=False, inplace=True) + df_plot.sort_values(by=['avg_target'], ascending=False, inplace=True) df_plot.reset_index(inplace=True) with plt.style.context("seaborn-ticks"): fig, ax = plt.subplots(figsize=dim) - # ----------------- - # Left axis - incidence - # ----------------- - ax.plot(df_plot['label'], df_plot['incidence'], + # -------------------------- + # Left axis - average target + # -------------------------- + ax.plot(df_plot['label'], df_plot['avg_target'], color="#00ccff", marker=".", - markersize=20, linewidth=3, label='incidence rate per bin', + markersize=20, linewidth=3, + label='incidence rate per bin' if model_type == "classification" else "mean target value per bin", zorder=10) - ax.plot(df_plot['label'], df_plot['avg_incidence'], + ax.plot(df_plot['label'], df_plot['global_avg_target'], color="#022252", linestyle='--', linewidth=4, - label='average incidence rate', + label='average incidence rate' if model_type == "classification" else "global mean target value", zorder=10) - # dummy line to have label on second axis from first + # Dummy line to have label on second axis from first ax.plot(np.nan, "#939598", linewidth=6, label='bin size') - # set labels & ticks - ax.set_ylabel('incidence', fontsize=16) + # Set labels & ticks + ax.set_ylabel('incidence' if model_type == "classification" else "mean target value", + fontsize=16) ax.set_xlabel('{} bins' ''.format(variable), fontsize=16) - ax.xaxis.set_tick_params(rotation=45, labelsize=14) + ax.xaxis.set_tick_params(labelsize=14) + plt.setp(ax.get_xticklabels(), + rotation=45, ha="right", rotation_mode="anchor") ax.yaxis.set_tick_params(labelsize=14) - ax.set_yticks(np.arange(0, max(df_plot['incidence'])+0.05, 0.05)) - ax.yaxis.set_major_formatter( - FuncFormatter(lambda y, _: '{:.1%}'.format(y))) - - # removes ticks but keeps the labels + if model_type == "classification": + # Mean target values are between 0 and 1 (target incidence rate), + # so format them as percentages + ax.set_yticks(np.arange(0, max(df_plot['avg_target'])+0.05, 0.05)) + ax.yaxis.set_major_formatter( + FuncFormatter(lambda y, _: '{:.1%}'.format(y))) + elif model_type == "regression": + # If the difference between the highest avg. target of all bins + # versus the global avg. target AND the difference between the + # lowest avg. target versus the global avg. target are both smaller + # than 25% of the global avg. target itself, we increase the + # y-axis range, to avoid that the minor avg. target differences are + # spread out over the configured figure height, suggesting + # incorrectly that there are big differences in avg. target across + # the bins and versus the global avg. target. + # (Motivation for the AND above: if on one end there IS enough + # difference, the effect that we discuss here does not occur.) + global_avg_target = max(df_plot['global_avg_target']) # series of same number, for every bin. + if ((np.abs((max(df_plot['avg_target']) - global_avg_target)) / global_avg_target < 0.25) + and (np.abs((min(df_plot['avg_target']) - global_avg_target)) / global_avg_target < 0.25)): + ax.set_ylim(global_avg_target * 0.75, + global_avg_target * 1.25) + + # Remove ticks but keep the labels ax.tick_params(axis='both', which='both', length=0) ax.tick_params(axis='y', colors="#00ccff") ax.yaxis.label.set_color('#00ccff') @@ -166,14 +209,14 @@ def plot_incidence(df: pd.DataFrame, variable: str, ax2.bar(df_plot['label'], df_plot['pop_size'], align='center', color="#939598", zorder=1) - # set labels & ticks - ax2.set_ylabel('population size', fontsize=16) + # Set labels & ticks ax2.set_xlabel('{} bins' ''.format(variable), fontsize=16) ax2.xaxis.set_tick_params(rotation=45, labelsize=14) + ax2.yaxis.set_tick_params(labelsize=14) ax2.yaxis.set_major_formatter( FuncFormatter(lambda y, _: '{:.1%}'.format(y))) - + ax2.set_ylabel('population size', fontsize=16) ax2.tick_params(axis='y', colors="#939598") ax2.yaxis.label.set_color('#939598') @@ -184,17 +227,24 @@ def plot_incidence(df: pd.DataFrame, variable: str, ax2.grid(False) - # title & legend - fig.suptitle('Incidence Plot - ' + variable, fontsize=22, y=1.02) + # Title & legend + if model_type == "classification": + title = "Incidence plot - " + variable + else: + title = "Mean target plot - " + variable + fig.suptitle(title, fontsize=22) ax.legend(frameon=False, bbox_to_anchor=(0., 1.01, 1., .102), loc=3, ncol=1, mode="expand", borderaxespad=0., prop={"size": 14}) - # Sets order ot layers + # Set order of layers ax.set_zorder(1) ax.patch.set_visible(False) del df_plot + plt.tight_layout() + plt.margins(0.01) + # Show plt.show() diff --git a/cobra/evaluation/plotting_utils.py b/cobra/evaluation/plotting_utils.py index 99a673f..7683f24 100644 --- a/cobra/evaluation/plotting_utils.py +++ b/cobra/evaluation/plotting_utils.py @@ -1,3 +1,4 @@ + # third party imports import numpy as np import pandas as pd @@ -5,40 +6,46 @@ import matplotlib.pyplot as plt import seaborn as sns - -def plot_univariate_predictor_quality(df_auc: pd.DataFrame, +def plot_univariate_predictor_quality(df_metric: pd.DataFrame, dim: tuple=(12, 8), path: str=None): - """Plot univariate quality of the predictors + """Plot univariate quality of the predictors. Parameters ---------- - df_auc : pd.DatFrame - Contains for each variable the train auc and selection auc along with - a boolean indicating whether or not it is selected based on the - criteria + df_metric : pd.DatFrame + DataFrame containing for each variable the train AUC or RMSE and + test AUC or RMSE along with a boolean indicating whether or not it is selected + based on the criteria. dim : tuple, optional - tuple with width and length of the plot + Width and length of the plot. path : str, optional - path to store the figure + Path to store the figure. """ - df = (df_auc[df_auc["preselection"]] - .sort_values(by='AUC selection', ascending=False)) + if "AUC selection" in df_metric.columns: + metric = "AUC" + ascending = False + elif "RMSE selection" in df_metric.columns: + metric = "RMSE" + ascending = True + + df = (df_metric[df_metric["preselection"]] + .sort_values(by=metric+" selection", ascending=ascending)) df = pd.melt(df, id_vars=["predictor"], - value_vars=["AUC train", "AUC selection"], + value_vars=[metric+" train", metric+" selection"], var_name="split", - value_name="AUC") + value_name=metric) # plot data with plt.style.context("seaborn-ticks"): fig, ax = plt.subplots(figsize=dim) - ax = sns.barplot(x="AUC", y="predictor", hue="split", data=df) - ax.set_title('Univariate Quality of Predictors') + ax = sns.barplot(x=metric, y="predictor", hue="split", data=df) + ax.set_title("Univariate Quality of Predictors") - # Set Axis - make them pretty + # Set pretty axis sns.despine(ax=ax, right=True) # Remove white lines from the second axis @@ -49,20 +56,19 @@ def plot_univariate_predictor_quality(df_auc: pd.DataFrame, plt.show() - def plot_correlation_matrix(df_corr: pd.DataFrame, dim: tuple=(12, 8), path: str=None): - """Plot correlation matrix amongst the predictors + """Plot correlation matrix amongst the predictors. Parameters ---------- df_corr : pd.DataFrame - Correlation matrix + Correlation matrix. dim : tuple, optional - tuple with width and length of the plot + Width and length of the plot. path : str, optional - path to store the figure + Path to store the figure. """ fig, ax = plt.subplots(figsize=dim) ax = sns.heatmap(df_corr, cmap='Blues') @@ -73,53 +79,77 @@ def plot_correlation_matrix(df_corr: pd.DataFrame, plt.show() - def plot_performance_curves(model_performance: pd.DataFrame, dim: tuple=(12, 8), path: str=None, colors: dict={"train": "#0099bf", "selection": "#ff9500", - "validation": "#8064a2"}): + "validation": "#8064a2"}, + metric_name: str=None): """Plot performance curves generated by the forward feature selection - for the train-selection-validation sets + for the train-selection-validation sets. Parameters ---------- model_performance : pd.DataFrame - contains train-selection-validation performance for each model trained - in the forward feature selection + Contains train-selection-validation performance for each model trained + in the forward feature selection. dim : tuple, optional - tuple with width and length of the plot + Width and length of the plot. path : str, optional - path to store the figure + Path to store the figure. + colors : dict, optional + Map with colors for train-selection-validation curves. + metric_name : str, optional + Name to indicate the metric used in model_performance. + Defaults to RMSE in case of regression and AUC in case of + classification. """ - highest_auc = np.round(max(max(model_performance['train_performance']), - max(model_performance['selection_performance']), - max(model_performance['validation_performance']) - ), 1) + + model_type = model_performance["model_type"][0] + + if metric_name is None: + if model_type == "classification": + metric_name = "AUC" + elif model_type == "regression": + metric_name = "RMSE" + + max_metric = np.round(max(max(model_performance['train_performance']), + max(model_performance['selection_performance']), + max(model_performance['validation_performance'])), 1) with plt.style.context("seaborn-whitegrid"): fig, ax = plt.subplots(figsize=dim) plt.plot(model_performance['train_performance'], marker=".", - markersize=20, linewidth=3, label='AUC train', + markersize=20, linewidth=3, label="train", color=colors["train"]) plt.plot(model_performance['selection_performance'], marker=".", - markersize=20, linewidth=3, label='AUC selection', + markersize=20, linewidth=3, label="selection", color=colors["selection"]) plt.plot(model_performance['validation_performance'], marker=".", - markersize=20, linewidth=3, label='AUC validation', + markersize=20, linewidth=3, label="validation", color=colors["validation"]) - # Set x/yticks + + # Set x- and y-ticks ax.set_xticks(np.arange(len(model_performance['last_added_predictor']))) ax.set_xticklabels(model_performance['last_added_predictor'].tolist(), rotation=40, ha='right') - ax.set_yticks(np.arange(0.5, highest_auc + 0.02, 0.05)) - #Make Pretty + + if model_type == "classification": + ax.set_yticks(np.arange(0.5, max_metric + 0.02, 0.05)) + elif model_type == "regression": + # In regression, the scale of the y-axis can largely vary depending + # on the dataset, it is easier to just set the y-axis bounds, + # but not the tick distance. + ax.set_ylim(0, max_metric*1.1) + + # Make pretty ax.legend(loc='lower right') - fig.suptitle('Performance curves - forward feature selection', + fig.suptitle('Performance curves forward feature selection', fontsize=20) + plt.title("Metric: "+metric_name, fontsize=15, loc="left") plt.ylabel('Model performance') if path is not None: @@ -127,23 +157,22 @@ def plot_performance_curves(model_performance: pd.DataFrame, plt.show() - def plot_variable_importance(df_variable_importance: pd.DataFrame, title: str=None, dim: tuple=(12, 8), path: str=None): - """Plot variable importance of a given model + """Plot variable importance of a given model. Parameters ---------- df_variable_importance : pd.DataFrame - DataFrame containing columns predictor and importance + DataFrame containing columns predictor and importance. title : str, optional - Title of the plot + Title of the plot. dim : tuple, optional - tuple with width and length of the plot + Width and length of the plot. path : str, optional - path to store the figure + Path to store the figure. """ with plt.style.context("seaborn-ticks"): fig, ax = plt.subplots(figsize=dim) diff --git a/cobra/model_building/__init__.py b/cobra/model_building/__init__.py index 63d074b..7a646c3 100644 --- a/cobra/model_building/__init__.py +++ b/cobra/model_building/__init__.py @@ -2,11 +2,12 @@ from .univariate_selection import get_preselected_predictors from .univariate_selection import compute_correlations -from .models import LogisticRegressionModel +from .models import LogisticRegressionModel, LinearRegressionModel from .forward_selection import ForwardFeatureSelection __all__ = ['compute_univariate_preselection', 'get_preselected_predictors', 'compute_correlations', 'LogisticRegressionModel', + 'LinearRegressionModel', 'ForwardFeatureSelection'] diff --git a/cobra/model_building/forward_selection.py b/cobra/model_building/forward_selection.py index 58b7620..29e06b3 100644 --- a/cobra/model_building/forward_selection.py +++ b/cobra/model_building/forward_selection.py @@ -1,66 +1,84 @@ + import logging +from typing import Callable, Optional import pandas as pd from tqdm.auto import tqdm -from cobra.model_building import LogisticRegressionModel as MLModel +from cobra.model_building import LogisticRegressionModel, LinearRegressionModel log = logging.getLogger(__name__) - class ForwardFeatureSelection: - """Perform forward feature selection for a given dataset using a given algorithm. + Predictors are sequentially added to the model, starting with the one that + has the highest univariate predictive power, and then proceeding with those that + jointly lead to the best fit, optimizing for selection AUC or RMSE. Interaction + effects are not explicitly modeled, yet they are implicitly present given the + feature selection and the underlying feature correlation structure. + Attributes ---------- + model_type : str + Model type (``classification`` or ``regression``). + MLModel: Cobra model + LogisticRegressionModel or LinearRegressionModel. max_predictors : int - maximum number of predictors allowed in any model. This corresponds + Maximum number of predictors allowed in any model. This corresponds more or less with the maximum number of steps in the forward feature - selection - model_name : str - name of the model to use for forward feature selection + selection. pos_only : bool - whether or not the model coefficients should all be positive + Whether or not the model coefficients should all be positive (no sign flips). + self._fitted_models : list + List of fitted models. """ - def __init__(self, max_predictors: int=50, - model_name: str="logistic-regression", pos_only: bool=True): + def __init__(self, + model_type: str="classification", + max_predictors: int=50, + pos_only: bool=True): + + self.model_type = model_type + if model_type == "classification": + self.MLModel = LogisticRegressionModel + elif model_type == "regression": + self.MLModel = LinearRegressionModel - self.pos_only = pos_only self.max_predictors = max_predictors - self.model_name = model_name + self.pos_only = pos_only self._fitted_models = [] - def get_model_from_step(self, step: int) -> MLModel: - """Get fitted model from a particular step + def get_model_from_step(self, step: int): + """Get fitted model from a particular step. Parameters ---------- step : int - Particular step in the forward selection + Particular step in the forward selection. Returns ------- - MLModel - Fitted model from the given step + self.MLModel + Fitted model from the given step. Raises ------ ValueError - in case step is larger than the number of available models + In case step is larger than the number of available models. """ - if len(self._fitted_models) < step: - raise ValueError(f"No model available for step {step}") + if len(self._fitted_models) <= step: + raise ValueError(f"No model available for step {step}. " + "The first step starts from index 0.") return self._fitted_models[step] def compute_model_performances(self, data: pd.DataFrame, target_column_name: str, - splits: list=["train", "selection", - "validation"] + splits: list=["train", "selection", "validation"], + metric: Optional[Callable]=None, ) -> pd.DataFrame: """Compute for each model the performance for different sets (e.g. train-selection-validation) and return them along with a list of @@ -71,22 +89,29 @@ def compute_model_performances(self, data: pd.DataFrame, Parameters ---------- data : pd.DataFrame - dataset for which to compute performance of each model + Dataset for which to compute performance of each model. target_column_name : str - name of the target column + Name of the target column. splits : list, optional - list of splits to compute performance on + List of splits to compute performance on. + metric: Callable (function), optional + Function that computes an evaluation metric to evaluate the model's + performances, instead of the default metric (AUC for + classification, RMSE for regression). + The function should require y_true and y_pred arguments. + Metric functions from sklearn can be used, for example, see + https://scikit-learn.org/stable/modules/classes.html#module-sklearn.metrics. Returns ------- DatFrame - contains for each model the performance for train, selection and - validation sets as well as the set of predictors used in this model + Contains for each model the performance for train, selection and + validation sets as well as the set of predictors used in this model. """ results = [] predictor_set = set([]) - for model in self._fitted_models: + for model in self._fitted_models: last_added_predictor = (set(model.predictors) .difference(predictor_set)) tmp = { @@ -94,14 +119,15 @@ def compute_model_performances(self, data: pd.DataFrame, "last_added_predictor": list(last_added_predictor)[0] } - # Evaluate model on each data set split, + # Evaluate model on each dataset split, # e.g. train-selection-validation tmp.update({ f"{split}_performance": model.evaluate( data[data["split"] == split], data[data["split"] == split][target_column_name], - split=split # parameter used for caching - ) + split=split, # parameter used for caching + metric=metric + ) for split in splits }) @@ -109,32 +135,44 @@ def compute_model_performances(self, data: pd.DataFrame, predictor_set = predictor_set.union(set(model.predictors)) - return pd.DataFrame(results) + df = pd.DataFrame(results) + df["model_type"] = self.model_type + + return df def fit(self, train_data: pd.DataFrame, target_column_name: str, predictors: list, forced_predictors: list=[], excluded_predictors: list=[]): - """Fit the forward feature selection estimator + """Fit the forward feature selection estimator. Parameters ---------- - data : pd.DataFrame - Data on which to fit the model + train_data : pd.DataFrame + Data on which to fit the model. Should include a "train" + and "selection" split for correct model selection! The + "train" split is used to train a model, the "selection" + split is used to evaluate which model to include in the + actual forward feature selection. target_column_name : str - Name of the target column + Name of the target column. predictors : list - List of predictors on which to train the estimator + List of predictors on which to train the estimator. forced_predictors : list, optional - List of predictors to force in the estimator + List of predictors to force in the estimator. excluded_predictors : list, optional - List of predictors to exclude from the estimator + List of predictors to exclude from the estimator. Raises ------ ValueError In case the number of forced predictors is larger than the maximum - number of allowed predictors in the model + number of allowed predictors in the model. """ + + assert "split" in train_data.columns, "The train_data input df does not include a split column." + assert len(set(["train", "selection"]).difference(set(train_data["split"].unique()))) == 0, \ + "The train_data input df does not include a 'train' and 'selection' split." + # remove excluded predictors from predictor lists filtered_predictors = [var for var in predictors if (var not in excluded_predictors and @@ -143,13 +181,13 @@ def fit(self, train_data: pd.DataFrame, target_column_name: str, # checks on predictor lists and self.max_predictors attr if len(forced_predictors) > self.max_predictors: raise ValueError("Size of forced_predictors cannot be bigger than " - "max_predictors") + "max_predictors.") elif len(forced_predictors) == self.max_predictors: log.info("Size of forced_predictors equals max_predictors " "only one model will be trained...") # train model with all forced_predictors (only) (self._fitted_models - .append(self._train_model(train_data, + .append(self._train_model(train_data[train_data["split"] == "train"], target_column_name, forced_predictors))) else: @@ -158,40 +196,43 @@ def fit(self, train_data: pd.DataFrame, target_column_name: str, filtered_predictors, forced_predictors) - def _forward_selection(self, train_data: pd.DataFrame, - target_column_name: str, predictors: list, - forced_predictors: list=[]) -> list: + def _forward_selection(self, + train_data: pd.DataFrame, + target_column_name: str, + predictors: list, + forced_predictors: list = []) -> list: """Perform the forward feature selection algorithm to compute a list - of models (with increasing performance?). The length of the list, - i.e. the number of models is bounded by the max_predictors class + of models (with increasing performance). The length of the list, + i.e. the number of models, is bounded by the max_predictors class attribute. Parameters ---------- train_data : pd.DataFrame - Data on which to fit the model + Data on which to fit the model. target_column_name : str - Name of the target column + Name of the target column. predictors : list - List of predictors on which to train the models + List of predictors on which to train the models. forced_predictors : list, optional - List of predictors to force in the models + List of predictors to force in the models. Returns ------- list List of fitted models where the index of the list indicates the - number of predictors minus one (as indices start from 0) + number of predictors minus one (as indices start from 0). """ fitted_models = [] current_predictors = [] max_steps = 1 + min(self.max_predictors, len(predictors) + len(forced_predictors)) + for step in tqdm(range(1, max_steps), desc="Sequentially adding best " "predictor..."): if step <= len(forced_predictors): - # first, we go through forced predictors + # first, we go through the forced predictors candidate_predictors = [var for var in forced_predictors if var not in current_predictors] else: @@ -210,82 +251,103 @@ def _forward_selection(self, train_data: pd.DataFrame, .union(set(model.predictors))) fitted_models.append(model) + # else: + # # If model returns None for the first time, + # # one can in theory stop the feature selection process + # # but we leave it run such that tqdm cleanly finishes + # break if not fitted_models: - log.error("No models found in forward selection") + log.error("No models found in forward selection.") return fitted_models - def _find_next_best_model(self, train_data: pd.DataFrame, + def _find_next_best_model(self, + train_data: pd.DataFrame, target_column_name: str, candidate_predictors: list, - current_predictors: list) -> MLModel: - """Given a list of current predictors which are already to selected to - be include in the model, Find amongst a list candidate predictors + current_predictors: list): + """Given a list of current predictors which are already selected to + be include in the model, find amongst a list candidate predictors the predictor to add to the selected list so that the resulting model has the best performance. Parameters ---------- train_data : pd.DataFrame - Data on which to fit the model + Data on which to fit the model. target_column_name : str - Name of the target column + Name of the target column. candidate_predictors : list - List of candidate predictors to test + List of candidate predictors to test. current_predictors : list - List of predictors on which to train the models + List of predictors on which to train the models. Returns ------- - MLModel - Best performing model + self.MLModel + Best performing model. """ # placeholders best_model = None - best_performance = -1 + if self.MLModel == LogisticRegressionModel: + best_performance = -1 # AUC metric is used + elif self.MLModel == LinearRegressionModel: + best_performance = float("inf") # RMSE metric is used + else: + raise ValueError("No metric comparison method has been configured " + "for the given model_type specified as " + "ForwardFeatureSelection argument.") - for pred in candidate_predictors: + fit_data = train_data[train_data["split"] == "train"] # data to fit the models with + sel_data = train_data[train_data["split"] == "selection"] # data to compare the models with - # train model with additional predictor - model = self._train_model(train_data, target_column_name, + for pred in candidate_predictors: + # Train a model with an additional predictor + model = self._train_model(fit_data, target_column_name, (current_predictors + [pred])) - # Evaluate model + + # Evaluate the model performance = (model - .evaluate(train_data[current_predictors + [pred]], - train_data[target_column_name], - split="train")) + .evaluate(sel_data[current_predictors + [pred]], + sel_data[target_column_name], + split="selection")) - if (self.pos_only and (not (model.get_coef() >= 0).all())): + if self.pos_only and (not (model.get_coef() >= 0).all()): continue - # check if model is better than current best model - # and if yes, replace current best! - if (performance >= best_performance): + # Check if the model is better than the current best model + # and if it is, replace the current best. + if self.MLModel == LogisticRegressionModel \ + and performance > best_performance: # AUC metric is used + best_performance = performance + best_model = model + elif self.MLModel == LinearRegressionModel \ + and performance < best_performance: # RMSE metric is used best_performance = performance best_model = model return best_model def _train_model(self, train_data: pd.DataFrame, target_column_name: str, - predictors: list) -> MLModel: - """Train the model with a given set of predictors + predictors: list): + """Train the model with a given set of predictors. Parameters ---------- train_data : pd.DataFrame - Data on which to fit the model + Data on which to fit the model. target_column_name : str - Name of the target column + Name of the target column. predictors : list - List of predictors on which to train the models + List of predictors on which to train the models. Returns ------- - MLModel - trained model + self.MLModel + Trained model. """ - model = MLModel() + model = self.MLModel() model.fit(train_data[predictors], train_data[target_column_name]) diff --git a/cobra/model_building/models.py b/cobra/model_building/models.py index b326111..233162c 100644 --- a/cobra/model_building/models.py +++ b/cobra/model_building/models.py @@ -1,25 +1,30 @@ + +from typing import Callable, Optional + # third party imports import numpy as np import pandas as pd from scipy import stats -from sklearn.metrics import roc_auc_score -from sklearn.linear_model import LogisticRegression +from sklearn.metrics import roc_auc_score, mean_squared_error +from numpy import sqrt +from sklearn.linear_model import LogisticRegression, LinearRegression +from sklearn.metrics import roc_curve + # custom imports import cobra.utils as utils - +from cobra.evaluation import ClassificationEvaluator class LogisticRegressionModel: - """Wrapper around the LogisticRegression class, with additional methods - implemented such as evaluation (using auc), getting a list of coefficients, - a ditionary of coefficients per predictor, ... for convenience + implemented such as evaluation (using AUC), getting a list of coefficients, + a dictionary of coefficients per predictor, ... for convenience. Attributes ---------- logit : LogisticRegression - scikit-learn logistic regression model + scikit-learn logistic regression model. predictors : list - List of predictors used in the model + List of predictors used in the model. """ def __init__(self): @@ -31,12 +36,12 @@ def __init__(self): self._eval_metrics_by_split = {} def serialize(self) -> dict: - """Serialize model as JSON + """Serialize model as JSON. Returns ------- dict - dictionary containing the serialized JSON + Dictionary containing the serialized JSON. """ serialized_model = { "meta": "logistic-regression", @@ -56,17 +61,17 @@ def serialize(self) -> dict: return serialized_model def deserialize(self, model_dict: dict): - """Deserialize a model previously stored as JSON + """Deserialize a model previously stored as JSON. Parameters ---------- model_dict : dict - Serialized JSON file as a dict + Serialized JSON file as a dict. Raises ------ ValueError - In case JSON file is no valid serialized model + In case JSON file is no valid serialized model. """ if not self._is_valid_dict(model_dict): @@ -74,122 +79,137 @@ def deserialize(self, model_dict: dict): self.logit = LogisticRegression() self.logit.set_params(**model_dict["params"]) - self.logit.classes_ = np.array(model_dict['classes_']) - self.logit.coef_ = np.array(model_dict['coef_']) - self.logit.intercept_ = np.array(model_dict['intercept_']) - self.logit.n_iter_ = np.array(model_dict['intercept_']) + self.logit.classes_ = np.array(model_dict["classes_"]) + self.logit.coef_ = np.array(model_dict["coef_"]) + self.logit.intercept_ = np.array(model_dict["intercept_"]) + self.logit.n_iter_ = np.array(model_dict["intercept_"]) self.predictors = model_dict["predictors"] self._eval_metrics_by_split = model_dict["_eval_metrics_by_split"] def get_coef(self) -> np.array: - """Returns the model coefficients + """Returns the model coefficients. Returns ------- np.array - array of model coefficients + Array of model coefficients. """ return self.logit.coef_[0] def get_intercept(self) -> float: - """Returns the intercept of the model + """Returns the intercept of the model. Returns ------- float - intercept of the model + Intercept of the model. """ return self.logit.intercept_[0] def get_coef_by_predictor(self) -> dict: - """Returns a dictionary mapping predictor (key) to coefficient (value) + """Returns a dictionary mapping predictor (key) to coefficient (value). Returns ------- dict - map ``{predictor: coefficient}`` + A map ``{predictor: coefficient}``. """ return dict(zip(self.predictors, self.logit.coef_[0])) def fit(self, X_train: pd.DataFrame, y_train: pd.Series): - """Fit the model + """Fit the model. Parameters ---------- X_train : pd.DataFrame - predictors of train data + Predictors of train data. y_train : pd.Series - target of train data + Target of train data. """ self.predictors = list(X_train.columns) self.logit.fit(X_train, y_train) self._is_fitted = True def score_model(self, X: pd.DataFrame) -> np.ndarray: - """Score a model on a (new) dataset + """Score a model on a (new) dataset. Parameters ---------- X : pd.DataFrame - dataset of predictors to score the model + Dataset of predictors to score the model. Returns ------- np.ndarray - score of the model for each observation + Score (i.e. predicted probabilities) of the model for each observation. """ # We select predictor columns (self.predictors) here to - # ensure we have the proper predictors and the proper order!!! + # ensure we have the proper predictors and the proper order return self.logit.predict_proba(X[self.predictors])[:, 1] def evaluate(self, X: pd.DataFrame, y: pd.Series, - split: str=None) -> float: - """Evaluate the model on a given data set (X, y). The optional split - parameter is to indicate that the data set belongs to + split: str=None, + metric: Optional[Callable]=None) -> float: + """Evaluate the model on a given dataset (X, y). The optional split + parameter is to indicate that the dataset belongs to (train, selection, validation), so that the computation on these sets can be cached! Parameters ---------- X : pd.DataFrame - dataset containing the predictor values for each observation + Dataset containing the predictor values for each observation. y : pd.Series - dataset containig the target of each observation + Dataset containing the target of each observation. split : str, optional - split of the dataset (e.g. train-selection-validation) + Split name of the dataset (e.g. "train", "selection", or "validation"). + metric: Callable (function), optional + Function that computes an evaluation metric to evaluate the model's + performances, instead of the default metric (AUC). + The function should require y_true and y_pred (binary output) arguments. + Metric functions from sklearn can be used, for example, see + https://scikit-learn.org/stable/modules/classes.html#module-sklearn.metrics. Returns ------- float - the performance score of the model (e.g. AUC) + The performance score of the model (AUC by default). """ + if metric is not None: # decouple from _eval_metrics_by_split attribute + y_pred = self.score_model(X) - if (split is None) or (split not in self._eval_metrics_by_split): + fpr, tpr, thresholds = roc_curve(y_true=y, y_score=y_pred) + cutoff = (ClassificationEvaluator._compute_optimal_cutoff(fpr, tpr, thresholds)) + y_pred_b = np.array([0 if pred <= cutoff else 1 for pred in y_pred]) - y_pred = self.score_model(X) + performance = metric(y_true=y, y_pred=y_pred_b) - performance = roc_auc_score(y_true=y, y_score=y_pred) + return performance + else: + if (split is None) or (split not in self._eval_metrics_by_split): + y_pred = self.score_model(X) + performance = roc_auc_score(y_true=y, y_score=y_pred) - if split is None: - return performance - else: - self._eval_metrics_by_split[split] = performance + if split is None: + return performance + else: + self._eval_metrics_by_split[split] = performance return self._eval_metrics_by_split[split] def compute_variable_importance(self, data: pd.DataFrame) -> pd.DataFrame: """Compute the importance of each predictor in the model and return - it as a DataFrame + it as a DataFrame. Parameters ---------- data : pd.DataFrame - data to score the model + Data to score the model. Returns ------- pd.DataFrame - DataFrame containing columns predictor and importance + DataFrame containing columns predictor and importance. """ y_pred = self.score_model(data) @@ -203,7 +223,7 @@ def compute_variable_importance(self, data: pd.DataFrame) -> pd.DataFrame: } df = pd.DataFrame.from_dict(importance_by_variable, - orient='index').reset_index() + orient="index").reset_index() df.columns = ["predictor", "importance"] return (df.sort_values(by="importance", ascending=False) @@ -225,3 +245,226 @@ def _is_valid_dict(self, model_dict: dict) -> bool: return False return True + + +class LinearRegressionModel: + """Wrapper around the LinearRegression class, with additional methods + implemented such as evaluation (using RMSE), getting a list of coefficients, + a dictionary of coefficients per predictor, ... for convenience. + + Attributes + ---------- + linear : LinearRegression + scikit-learn linear regression model. + predictors : list + List of predictors used in the model. + """ + + def __init__(self): + self.linear = LinearRegression(fit_intercept=True, normalize=False) + self._is_fitted = False + # placeholder to keep track of a list of predictors + self.predictors = [] + self._eval_metrics_by_split = {} + + def serialize(self) -> dict: + """Serialize model as JSON. + + Returns + ------- + dict + Dictionary containing the serialized JSON. + """ + serialized_model = { + "meta": "linear-regression", + "predictors": self.predictors, + "_eval_metrics_by_split": self._eval_metrics_by_split, + "params": self.linear.get_params() + } + + if self._is_fitted: + serialized_model.update({ + "coef_": self.linear.coef_.tolist(), + "intercept_": self.linear.intercept_.tolist() + }) + + return serialized_model + + def deserialize(self, model_dict: dict): + """Deserialize a model previously stored as JSON. + + Parameters + ---------- + model_dict : dict + Serialized JSON file as a dict. + + Raises + ------ + ValueError + In case JSON file is no valid serialized model. + """ + + if not self._is_valid_dict(model_dict): + raise ValueError("No valid serialized model") + + self.linear = LinearRegression() + self.linear.set_params(**model_dict["params"]) + self.linear.coef_ = np.array(model_dict["coef_"]) + self.linear.intercept_ = np.array(model_dict["intercept_"]) + self.predictors = model_dict["predictors"] + self._eval_metrics_by_split = model_dict["_eval_metrics_by_split"] + + def get_coef(self) -> np.array: + """Returns the model coefficients. + + Returns + ------- + np.array + Array of model coefficients. + """ + return self.linear.coef_ + + def get_intercept(self) -> float: + """Returns the intercept of the model. + + Returns + ------- + float + Intercept of the model. + """ + return self.linear.intercept_[0] + + def get_coef_by_predictor(self) -> dict: + """Returns a dictionary mapping predictor (key) to coefficient (value). + + Returns + ------- + dict + A map ``{predictor: coefficient}``. + """ + return dict(zip(self.predictors, self.linear.coef_)) + + def fit(self, X_train: pd.DataFrame, y_train: pd.Series): + """Fit the model. + + Parameters + ---------- + X_train : pd.DataFrame + Predictors of train data. + y_train : pd.Series + Target of train data. + """ + self.predictors = list(X_train.columns) + self.linear.fit(X_train, y_train) + self._is_fitted = True + + def score_model(self, X: pd.DataFrame) -> np.ndarray: + """Score a model on a (new) dataset. + + Parameters + ---------- + X : pd.DataFrame + Dataset of predictors to score the model. + + Returns + ------- + np.ndarray + Score of the model for each observation. + """ + # We select predictor columns (self.predictors) here to + # ensure we have the proper predictors and the proper order + return self.linear.predict(X[self.predictors]) + + def evaluate(self, X: pd.DataFrame, y: pd.Series, + split: str=None, + metric: Optional[Callable]=None) -> float: + """Evaluate the model on a given dataset (X, y). The optional split + parameter is to indicate that the dataset belongs to + (train, selection, validation), so that the computation on these sets + can be cached! + + Parameters + ---------- + X : pd.DataFrame + Dataset containing the predictor values for each observation. + y : pd.Series + Dataset containing the target of each observation. + split : str, optional + Split name of the dataset (e.g. "train", "selection", or "validation"). + metric: Callable (function), optional + Function that computes an evaluation metric to evaluate the model's + performances, instead of the default metric (RMSE). + The function should require y_true and y_pred arguments. + Metric functions from sklearn can be used, for example, see + https://scikit-learn.org/stable/modules/classes.html#module-sklearn.metrics. + + Returns + ------- + float + The performance score of the model (RMSE by default). + """ + if metric is not None: # decouple from _eval_metrics_by_split attribute + y_pred = self.score_model(X) + performance = metric(y_true=y, y_pred=y_pred) + + return performance + else: + if (split is None) or (split not in self._eval_metrics_by_split): + y_pred = self.score_model(X) + performance = sqrt(mean_squared_error(y_true=y, y_pred=y_pred)) + + if split is None: + return performance + else: + self._eval_metrics_by_split[split] = performance + + return self._eval_metrics_by_split[split] + + def compute_variable_importance(self, data: pd.DataFrame) -> pd.DataFrame: + """Compute the importance of each predictor in the model and return + it as a DataFrame. + + Parameters + ---------- + data : pd.DataFrame + Data to score the model. + + Returns + ------- + pd.DataFrame + DataFrame containing columns predictor and importance. + """ + + y_pred = self.score_model(data) + + importance_by_variable = { + utils.clean_predictor_name(predictor): stats.pearsonr( + data[predictor], + y_pred + )[0] + for predictor in self.predictors + } + + df = pd.DataFrame.from_dict(importance_by_variable, + orient="index").reset_index() + df.columns = ["predictor", "importance"] + + return (df.sort_values(by="importance", ascending=False) + .reset_index(drop=True)) + + def _is_valid_dict(self, model_dict: dict) -> bool: + + if ("meta" not in model_dict + or model_dict["meta"] != "linear-regression"): + return False + + attr = ["coef_", "intercept_", "predictors"] + for key in attr: + if not (key in model_dict or type(model_dict[key]) != list): + return False + + if ("params" not in model_dict + or "_eval_metrics_by_split" not in model_dict): + return False + + return True diff --git a/cobra/model_building/univariate_selection.py b/cobra/model_building/univariate_selection.py index 60cf8ff..2db4abb 100644 --- a/cobra/model_building/univariate_selection.py +++ b/cobra/model_building/univariate_selection.py @@ -1,27 +1,25 @@ -""" -Module to perform univariate preselection and compute correlation amongst -predictors -Authors: -- Geert Verstraeten (methodology) -- Matthias Roels (current implementation) -- Jan Benisek (initial implementation) -""" + import pandas as pd -from sklearn.metrics import roc_auc_score -import cobra.utils as utils +from sklearn.metrics import roc_auc_score, mean_squared_error +from numpy import sqrt +import cobra.utils as utils def compute_univariate_preselection(target_enc_train_data: pd.DataFrame, target_enc_selection_data: pd.DataFrame, predictors: list, target_column: str, - preselect_auc_threshold: float=0.053, - preselect_overtrain_threshold: float=0.05 + model_type: str = "classification", + preselect_auc_threshold: float = 0.053, + preselect_rmse_threshold: float = 5, + preselect_overtrain_threshold: float = 0.05 ) -> pd.DataFrame: - """Perform a preselection of predictors based on an AUC threshold of - a univariate model on a train and selection dataset and return a datframe - containing for each variable the train and selection AUC along with a + """Perform a preselection of predictors based on an AUC (in case of + classification) or a RMSE (in case of regression) threshold of + a univariate model on a train and selection dataset and return a DataFrame + containing for each variable the train and selection AUC or RMSE along with a boolean "preselection" column. + As the AUC just calculates the quality of a ranking, all monotonous transformations of a given ranking (i.e. transformations that do not alter the ranking itself) will lead to the same AUC. @@ -32,104 +30,147 @@ def compute_univariate_preselection(target_enc_train_data: pd.DataFrame, the training set. Therefore, no univariate model is trained here as the target encoded train and selection data is/must be used as inputs for this function. These will - be used as predicted scores to compute the AUC with against the target + be used as predicted scores to compute the AUC with against the target. Parameters ---------- + model_type : str + Model type ("classification" or "regression"). target_enc_train_data : pd.DataFrame - Train data + Train data. target_enc_selection_data : pd.DataFrame - Selection data + Selection data. predictors : list - list of predictors (e.g. column names in the train set and selection - data sets) + List of predictors (e.g. column names in the train set and selection + data sets). target_column : str - name of the target column + Name of the target column. preselect_auc_threshold : float, optional - threshold on AUC to select predictor + Threshold on min. AUC to select predictor. Ignored if model_type is "regression". + preselect_rmse_threshold : float, optional + Threshold on max. RMSE to select predictor. Ignored if model_type is "classification". + It is important to note that the threshold depends heavily on the scale of + the target variable, and should be modified accordingly. preselect_overtrain_threshold : float, optional - threshold on the difference between train and selection AUC + Threshold on the difference between train and selection AUC or RMSE (in case + of the latter, as a proportion). Returns ------- pd.DataFrame - DataFrame containing for each variable the train auc and - selection auc allong with a boolean indicating whether or not it is - selected based on the criteria + DataFrame containing for each variable the train AUC or RMSE and + selection AUC or RMSE along with a boolean indicating whether or not it is + selected based on the criteria. """ result = [] - for predictor in predictors: + if model_type == "classification": + for predictor in predictors: + + cleaned_predictor = utils.clean_predictor_name(predictor) + + auc_train = roc_auc_score( + y_true=target_enc_train_data[target_column], + y_score=target_enc_train_data[predictor]) + + auc_selection = roc_auc_score( + y_true=target_enc_selection_data[target_column], + y_score=target_enc_selection_data[predictor]) + + result.append({"predictor": cleaned_predictor, + "AUC train": auc_train, + "AUC selection": auc_selection}) - cleaned_predictor = utils.clean_predictor_name(predictor) + df_auc = pd.DataFrame(result) - auc_train = roc_auc_score( - y_true=target_enc_train_data[target_column], - y_score=target_enc_train_data[predictor]) + # Filter based on min. AUC + auc_thresh = df_auc.loc[:, "AUC selection"] > preselect_auc_threshold - auc_selection = roc_auc_score( - y_true=target_enc_selection_data[target_column], - y_score=target_enc_selection_data[predictor] - ) + # Identify those variables for which the AUC difference between train + # and selection is within a user-defined ratio + auc_overtrain = ((df_auc["AUC train"] - df_auc["AUC selection"]) + < preselect_overtrain_threshold) - result.append({"predictor": cleaned_predictor, - "AUC train": auc_train, - "AUC selection": auc_selection}) + df_auc["preselection"] = auc_thresh & auc_overtrain - df_auc = pd.DataFrame(result) + df_out = df_auc.sort_values(by="AUC selection", ascending=False).reset_index(drop=True) - # Filter based on min AUC - auc_thresh = df_auc.loc[:, "AUC selection"] > preselect_auc_threshold + elif model_type == "regression": + for predictor in predictors: + cleaned_predictor = utils.clean_predictor_name(predictor) - # Identify those variables for which the AUC difference between train - # and selection is within a user-defined ratio - auc_overtrain = ((df_auc["AUC train"] - df_auc["AUC selection"]) - < preselect_overtrain_threshold) + rmse_train = sqrt(mean_squared_error( + y_true=target_enc_train_data[target_column], + y_pred=target_enc_train_data[predictor])) - df_auc["preselection"] = auc_thresh & auc_overtrain + rmse_selection = sqrt(mean_squared_error( + y_true=target_enc_selection_data[target_column], + y_pred=target_enc_selection_data[predictor])) - return (df_auc.sort_values(by='AUC selection', ascending=False) - .reset_index(drop=True)) + result.append({"predictor": cleaned_predictor, + "RMSE train": rmse_train, + "RMSE selection": rmse_selection}) + df_rmse = pd.DataFrame(result) -def get_preselected_predictors(df_auc: pd.DataFrame) -> list: - """Wrapper function to extract a list of predictors from df_auc + # Filter based on max. RMSE + rmse_thresh = df_rmse.loc[:, "RMSE selection"] < preselect_rmse_threshold + + # Identify those variables for which the RMSE difference between train + # and selection is within a user-defined ratio + rmse_overtrain = ((df_rmse["RMSE selection"] - df_rmse["RMSE train"]) # flip subtraction vs. AUC + < preselect_overtrain_threshold) + + df_rmse["preselection"] = rmse_thresh & rmse_overtrain + + df_out = df_rmse.sort_values(by="RMSE selection", ascending=True).reset_index(drop=True) # lower is better + + return df_out + +def get_preselected_predictors(df_metric: pd.DataFrame) -> list: + """Wrapper function to extract a list of predictors from df_metric. Parameters ---------- - df_auc : pd.DataFrame - DataFrame containing for each variable the train auc and - test auc allong with a boolean indicating whether or not it is selected - based on the criteria + df_metric : pd.DataFrame + DataFrame containing for each variable the train AUC or RMSE and + test AUC or RMSE along with a boolean indicating whether or not it is selected + based on the criteria. + Returns ------- list - list of preselected predictors + List of preselected predictors. """ - predictor_list = (df_auc[df_auc["preselection"]] - .sort_values(by='AUC selection', ascending=False) - .predictor.tolist()) - return [col + "_enc" for col in predictor_list] + if "AUC selection" in df_metric.columns: + predictor_list = (df_metric[df_metric["preselection"]] + .sort_values(by="AUC selection", ascending=False) + .predictor.tolist()) + elif "RMSE selection" in df_metric.columns: + predictor_list = (df_metric[df_metric["preselection"]] + .sort_values(by="RMSE selection", ascending=True) # lower is better + .predictor.tolist()) + return [col + "_enc" for col in predictor_list] def compute_correlations(target_enc_train_data: pd.DataFrame, predictors: list) -> pd.DataFrame: """Given a DataFrame and a list of predictors, compute the correlations - amongst the predictors in the DataFrame + amongst the predictors in the DataFrame. Parameters ---------- target_enc_train_data : pd.DataFrame - data to compute correlation + Data to compute correlation. predictors : list List of column names of the DataFrame between which to compute - the correlation matrix + the correlation matrix. Returns ------- pd.DataFrame - The correlation matrix of the training set + The correlation matrix of the training set. """ correlations = target_enc_train_data[predictors].corr() diff --git a/cobra/preprocessing/categorical_data_processor.py b/cobra/preprocessing/categorical_data_processor.py index 5993b5d..175bfb5 100644 --- a/cobra/preprocessing/categorical_data_processor.py +++ b/cobra/preprocessing/categorical_data_processor.py @@ -1,19 +1,3 @@ -""" -This class implements the Python Prediction's way of dealing with -categorical data preprocessing. There are three steps involved here: - -- An optional regrouping of the different categories based on category size - and significance of the category w.r.t. the target -- Missing value replacement with the additional category ``Missing`` -- Change of dtype to ``category`` (could potentially lead to memory - optimization) - -Authors: - -- Geert Verstraeten (methodology) -- Jan Benisek (implementation) -- Matthias Roels (implementation) -""" # standard lib imports import re @@ -30,18 +14,37 @@ log = logging.getLogger(__name__) - class CategoricalDataProcessor(BaseEstimator): - """ - Regroups the categories of categorical variables based on significance + """Regroups the categories of categorical variables based on significance with target variable. + This class implements the Python Prediction's way of dealing with + categorical data preprocessing. There are three steps involved: + + - An optional regrouping of the different categories based on category size + and significance of the category w.r.t. the target. + - For a given categorical variable, all categories below the (weighted) + category size threshold are put into a rest category (by default ``Other``) + - The remaining categories are subject to a statistical test, if there is + sufficient dependence with the target variable compared to all other categories, + the category is kept as-is, otherwise it is also put into the rest category + - Beware: one can force categories to be kept, and if no single category passes + the statistical test, the categorical variable is left unprocessed altogether + - Missing value replacement with the additional category ``Missing``. + - Change of dtype to ``category`` (could potentially lead to memory + optimization). + + See the README of the GitHub repository for more methodological background information. + Attributes ---------- category_size_threshold : int - Minimal size of a category to keep it as a separate category. + All categories with a size (corrected for incidence if applicable) + in the training set above this threshold are kept as a separate category, + if statistical significance w.r.t. target is detected. Remaining + categories are converted into ``Other`` (or else, cf. regroup_name). forced_categories : dict - Map to prevent certain categories from being group into ``Other`` + Map to prevent certain categories from being grouped into ``Other`` for each column - dict of the form ``{col:[forced vars]}``. keep_missing : bool Whether or not to keep missing as a separate category. @@ -62,17 +65,17 @@ class CategoricalDataProcessor(BaseEstimator): "scale_contingency_table", "forced_categories"] def __init__(self, - model_type: str = "classification", - regroup: bool = True, - regroup_name: str = "Other", - keep_missing: bool = True, - category_size_threshold: int = 5, - p_value_threshold: float = 0.001, - scale_contingency_table: bool = True, - forced_categories: dict = {}): - + model_type: str="classification", + regroup: bool=True, + regroup_name: str="Other", + keep_missing: bool=True, + category_size_threshold: int=5, + p_value_threshold: float=0.001, + scale_contingency_table: bool=True, + forced_categories: dict={}): + if model_type not in ["classification", "regression"]: - raise ValueError("An unexpected model_type was provided. Valid model_types are either 'classification' or 'regression'.") + raise ValueError("An unexpected model_type was provided. A valid model_type is either 'classification' or 'regression'.") self.model_type = model_type self.regroup = regroup @@ -87,13 +90,13 @@ def __init__(self, self._cleaned_categories_by_column = {} def attributes_to_dict(self) -> dict: - """Return the attributes of CategoricalDataProcessor as a dictionary + """Return the attributes of CategoricalDataProcessor as a dictionary. Returns ------- dict Contains the attributes of CategoricalDataProcessor instance with - the attribute name as key + the attribute name as key. """ params = self.get_params() @@ -117,7 +120,7 @@ def set_attributes_from_dict(self, params: dict): Raises ------ ValueError - In case _cleaned_categories_by_column is not of type dict + In case _cleaned_categories_by_column is not of type dict. """ _fitted_output = params.pop("_cleaned_categories_by_column", {}) @@ -141,7 +144,7 @@ def set_attributes_from_dict(self, params: dict): def fit(self, data: pd.DataFrame, column_names: list, target_column: str): - """Fit the CategoricalDataProcessor + """Fit the CategoricalDataProcessor. Parameters ---------- @@ -179,7 +182,8 @@ def fit(self, data: pd.DataFrame, column_names: list, def _fit_column(self, data: pd.DataFrame, column_name: str, target_column) -> set: """Compute which categories to regroup into "Other" - for a particular column + for a particular column, and return those that need + to be kept as-is. Parameters ---------- @@ -191,7 +195,7 @@ def _fit_column(self, data: pd.DataFrame, column_name: str, Returns ------- list - list of categories to combine into a category "Other" + List of categories to combine into a category "Other". """ model_type = self.model_type @@ -252,20 +256,20 @@ def _fit_column(self, data: pd.DataFrame, column_name: str, def transform(self, data: pd.DataFrame, column_names: list) -> pd.DataFrame: - """Transform the data + """Transform the data. Parameters ---------- data : pd.DataFrame - data used to compute the mapping to encode the categorical + Data used to compute the mapping to encode the categorical variables with. column_names : list - Columns of data to be processed + Columns of data to be processed. Returns ------- pd.DataFrame - data with additional transformed variables + Data with additional transformed variables. """ if self.regroup and len(self._cleaned_categories_by_column) == 0: @@ -289,19 +293,19 @@ def _transform_column(self, data: pd.DataFrame, column_name: str) -> pd.DataFrame: """Given a DataFrame, a column name and a list of categories to combine, create an additional column which combines these categories - into "Other" + into "Other". Parameters ---------- data : pd.DataFrame - Original data to be tranformed + Original data to be transformed. column_name : str - name of the column to transform + Name of the column to transform. Returns ------- pd.DataFrame - original DataFrame with an added processed column + Original DataFrame with an added processed column. """ column_name_clean = column_name + "_processed" @@ -339,25 +343,25 @@ def _transform_column(self, data: pd.DataFrame, def fit_transform(self, data: pd.DataFrame, column_names: list, target_column: str) -> pd.DataFrame: - """Fits to data, then transform it + """Fits the data, then transforms it. Parameters ---------- data : pd.DataFrame - data used to compute the mapping to encode the categorical + Data used to compute the mapping to encode the categorical variables with. column_names : list - Columns of data to be processed + Columns of data to be processed. target_column : str - Column name of the target + Column name of the target. Returns ------- pd.DataFrame - data with additional transformed variables + Data with additional transformed variables. """ - self.fit(data, column_names) + self.fit(data, column_names, target_column) return self.transform(data, column_names) @staticmethod @@ -374,7 +378,7 @@ def _get_small_categories(predictor_series: pd.Series, incidence : float Global train incidence. category_size_threshold : int - Minimal size of a category to keep it as a separate category. + Minimal size of a category to keep as a separate category. Returns ------- @@ -394,19 +398,19 @@ def _get_small_categories(predictor_series: pd.Series, @staticmethod def _replace_missings(data: pd.DataFrame, column_names: Optional[list] = None) -> pd.DataFrame: - """Replace missing values (incl empty strings) + """Replace missing values (incl. empty strings). Parameters ---------- data : pd.DataFrame - data to replace missings in + Data to replace missings in. column_names: list, optional - list of predictors to replace missings in + List of predictors to replace missings in. Returns ------- list - list of unique values in the data + List of unique values in the data. """ # replace missings (incl. empty string) regex = re.compile("^\\s+|\\s+$") @@ -450,7 +454,7 @@ def _compute_p_value(X: pd.Series, y: pd.Series, category: str, Returns ------- float - p-value of applied statistical test + The p-value of applied statistical test. """ df = pd.concat([X, y], axis=1) df.columns = ["X", "y"] @@ -480,13 +484,13 @@ def _compute_p_value(X: pd.Series, y: pd.Series, category: str, @staticmethod def _replace_categories(data: pd.Series, categories: set, replace_with: str) -> pd.Series: - """replace categories in set with "Other" and transform the remaining - categories to strings to avoid type errors later on in the pipeline + """Replace categories in set with "Other" and transform the remaining + categories to strings to avoid type errors later on in the pipeline. Parameters ---------- data : pd.Series - Dataset which contains the variable to be replaced + Dataset which contains the variable to be replaced. categories : set Cleaned categories. replace_with: str @@ -495,7 +499,7 @@ def _replace_categories(data: pd.Series, categories: set, Returns ------- pd.Series - Series with replaced categories + Series with replaced categories. """ return data.apply( lambda x: str(x) if x in categories else replace_with) diff --git a/cobra/preprocessing/kbins_discretizer.py b/cobra/preprocessing/kbins_discretizer.py index 0fbb29d..c30d7de 100644 --- a/cobra/preprocessing/kbins_discretizer.py +++ b/cobra/preprocessing/kbins_discretizer.py @@ -1,17 +1,4 @@ -""" -This module is a rework of -https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/preprocessing/_discretization.py -However, it is purely written in pandas instead of numpy because it is more -intuitive -Also, some custom modifications were included to allign it with our -Python Predictions methodology - -Authors: - -- Geert Verstraeten (methodology) -- Matthias Roels (implementation) -""" # standard lib imports from copy import deepcopy from typing import List @@ -28,30 +15,36 @@ log = logging.getLogger(__name__) - class KBinsDiscretizer(BaseEstimator): - """Bin continuous data into intervals of predefined size. It provides a - way to partition continuous data into discrete values, i.e. tranform + way to partition continuous data into discrete values, i.e. transform continuous data into nominal data. This can make a linear model more expressive as it introduces nonlinearity to the model, while maintaining the interpretability of the model afterwards. + This module is a rework of + https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/preprocessing/_discretization.py, + though it is purely written in pandas instead of numpy because it is more intuitive. It also includes + some custom modifications to align it with the Python Predictions methodology. See the README of the + GitHub repository for more background information. + Attributes ---------- auto_adapt_bins : bool - reduces the number of bins (starting from n_bins) as a function of - the number of missings + Reduces the number of bins (starting from n_bins) as a function of + the number of missings. change_endpoint_format : bool Whether or not to change the format of the lower and upper bins into ``<= x`` and ``> y`` resp. closed : str Whether to close the bins (intervals) from the left or right label_format : str - format string to display the bin labels + Format string to display the bin labels e.g. ``min - max``, ``(min, max]``, ... n_bins : int - Number of bins to produce. Raises ValueError if ``n_bins < 2``. + Number of bins to produce. Raises ValueError if ``n_bins < 2``. A warning + is issued when a variable can only produce a lower number of bins than + asked for. starting_precision : int Initial precision for the bin edges to start from, can also be negative. Given a list of bin edges, the class will @@ -62,7 +55,7 @@ class KBinsDiscretizer(BaseEstimator): ``146 -> 100``, ... strategy : str Binning strategy. Currently only `uniform` and `quantile` - e.g. equifrequency is supported + e.g. equifrequency is supported. """ valid_strategies = ("uniform", "quantile") @@ -370,15 +363,15 @@ def _compute_bin_edges(self, data: pd.DataFrame, column_name: str, Parameters ---------- data : pd.DataFrame - Data to be discretized + Data to be discretized. column_name : str - name of the column to discretize + Name of the column to discretize. n_bins : int Number of bins to produce. col_min : float - min value of the variable + Min value of the variable. col_max : float - max value of the variable + Max value of the variable. Returns ------- @@ -390,34 +383,10 @@ def _compute_bin_edges(self, data: pd.DataFrame, column_name: str, if self.strategy == "quantile": bin_edges = list(data[column_name] .quantile(np.linspace(0, 1, n_bins + 1), - interpolation='linear')) + interpolation="linear")) elif self.strategy == "uniform": bin_edges = list(np.linspace(col_min, col_max, n_bins + 1)) - # elif self.strategy == "kmeans": - - # if data[column_name].isnull().sum() > 0: - # raise ValueError("{}: kmeans strategy cannot handle NULL " - # "values in the data." - # .format(KBinsDiscretizer.__name__)) - - # # Deterministic initialization with uniform spacing - # uniform_edges = np.linspace(col_min, col_max, n_bins + 1) - # init = (uniform_edges[1:] + uniform_edges[:-1])[:, None] * 0.5 - - # # 1D k-means - # kmeans = KMeans(n_clusters=n_bins, init=init, n_init=1) - # centers = (kmeans.fit(data[column_name][:, None]) - # .cluster_centers_[:, 0]) - - # # Make sure to sort centers as they may be unsorted, - # # even with sorted init! - # centers.sort() - - # # compute bin_edges from centers - # bin_edges = (centers[1:] + centers[:-1]) * 0.5 - # bin_edges = np.r_[col_min, bin_edges, col_max] - # nans lead to unexpected behavior during sorting, # by replacing with inf we ensure these stay at the # outermost edges @@ -431,13 +400,19 @@ def _compute_bin_edges(self, data: pd.DataFrame, column_name: str, log.warning(f"Column {column_name} " "has NaNs present in bin definitions") + # Make absolutely sure bin edges are ordered, + # in very rare situations this wasn't the case + # due to rounding in quantile calculation (e.g. + # distributions with strong mass for same value) + bin_edges = sorted(bin_edges) + # Make sure the bin_edges are unique # and order remains the same return list(dict.fromkeys(bin_edges)) def _compute_minimal_precision_of_bin_edges(self, bin_edges: list) -> int: """Compute the minimal precision of a list of bin_edges so that we end - up with a strictly ascending sequence of numbers. + up with a strictly ascending sequence of different numbers even when rounded. The starting_precision attribute will be used as the initial precision. In case of a negative starting_precision, the bin edges will be rounded to the nearest 10, 100, ... (e.g. 5.55 -> 10, 246 -> 200, ...) @@ -485,7 +460,7 @@ def _compute_bins_from_edges(self, bin_edges: list) -> List[tuple]: # this can be a negative number, which then # rounds numbers to the nearest 10, 100, ... precision = self._compute_minimal_precision_of_bin_edges(bin_edges) - + bins = [] for a, b in zip(bin_edges, bin_edges[1:]): fmt_a = round(a, precision) @@ -507,7 +482,7 @@ def _create_index(intervals: List[tuple], Parameters ---------- intervals : List[tuple] - a list of tuples describing the intervals + A list of tuples describing the intervals. closed : str, optional Whether the intervals should be closed on the left-side, right-side, both or neither. diff --git a/cobra/preprocessing/preprocessor.py b/cobra/preprocessing/preprocessor.py index 3338ec4..e03d352 100644 --- a/cobra/preprocessing/preprocessor.py +++ b/cobra/preprocessing/preprocessor.py @@ -1,60 +1,51 @@ -""" -This module is a rework of the old cobra data_preparation.py. Here we will make -use of the classes for discretization, preprocessing of categorical variables -and incidence replacement. All of which will be employed to create a -preprocessing pipeline, which can be stored as a JSON file so that it can -easily be re-used for scoring. - -Authors: - -- Geert Verstraeten (methodology) -- Matthias Roels (implementation) -""" -# std lib imports + +# standard lib imports import inspect -from datetime import datetime import time import math import logging from random import shuffle +from datetime import datetime # third party imports import pandas as pd -from sklearn.model_selection import train_test_split from sklearn.base import BaseEstimator from sklearn.exceptions import NotFittedError + # custom imports +from cobra.preprocessing import CategoricalDataProcessor from cobra.preprocessing import KBinsDiscretizer from cobra.preprocessing import TargetEncoder -from cobra.preprocessing import CategoricalDataProcessor log = logging.getLogger(__name__) - class PreProcessor(BaseEstimator): - """This class implements a so-called facade pattern to define a higher-level interface to work with the CategoricalDataProcessor, KBinsDiscretizer and TargetEncoder classes, so that their fit and transform - methods are called in the correct order. Additionally, it provides features - such as (de)serialization to/from JSON so that preprocessing pipelines can - be stored and reloaded. + methods are called in the correct order. + + Additionally, it provides methods such as (de)serialization to/from JSON + so that preprocessing pipelines can be stored and reloaded, example for scoring. + + We refer to the README of the GitHub repository for more background information + on the preprocessing methodology. Attributes ---------- categorical_data_processor : CategoricalDataProcessor Instance of CategoricalDataProcessor to do the preprocessing of - categorical variables. The model_type variable is specified - here (``classification`` or ``regression``). + categorical variables. discretizer : KBinsDiscretizer - Instance of KBinsDiscretizer to do the prepocessing of continuous + Instance of KBinsDiscretizer to do the preprocessing of continuous variables by means of discretization. - serialization_path : str - Path to save the pipeline to. - stratify_split : bool - Whether or not to stratify the train-test split. target_encoder : TargetEncoder Instance of TargetEncoder to do the incidence replacement. + is_fitted : bool + Whether or not object is yet fit. + model_type : str + The model_type variable as specified in CategoricalDataProcessor + (``classification`` or ``regression``). """ def __init__(self, @@ -63,33 +54,33 @@ def __init__(self, target_encoder: TargetEncoder, is_fitted: bool = False): - self.model_type = categorical_data_processor.model_type - self._categorical_data_processor = categorical_data_processor self._discretizer = discretizer self._target_encoder = target_encoder self._is_fitted = is_fitted + self.model_type = categorical_data_processor.model_type + @classmethod def from_params(cls, - model_type: str = "classification", - n_bins: int = 10, - strategy: str = "quantile", - closed: str = "right", - auto_adapt_bins: bool = False, - starting_precision: int = 0, - label_format: str = "{} - {}", - change_endpoint_format: bool = False, - regroup: bool = True, - regroup_name: str = "Other", - keep_missing: bool = True, - category_size_threshold: int = 5, - p_value_threshold: float = 0.001, - scale_contingency_table: bool = True, - forced_categories: dict = {}, - weight: float = 0.0, - imputation_strategy: str = "mean"): + model_type: str="classification", + n_bins: int=10, + strategy: str="quantile", + closed: str="right", + auto_adapt_bins: bool=False, + starting_precision: int=0, + label_format: str="{} - {}", + change_endpoint_format: bool=False, + regroup: bool=True, + regroup_name: str="Other", + keep_missing: bool=True, + category_size_threshold: int=5, + p_value_threshold: float=0.001, + scale_contingency_table: bool=True, + forced_categories: dict={}, + weight: float=0.0, + imputation_strategy: str="mean"): """Constructor to instantiate PreProcessor from all the parameters that can be set in all its required (attribute) classes along with good default values. @@ -129,11 +120,14 @@ def from_params(cls, keep_missing : bool Whether or not to keep missing as a separate category. category_size_threshold : int - Minimal size of a category to keep it as a separate category. + All categories with a size (corrected for incidence if applicable) + in the training set above this threshold are kept as a separate category, + if statistical significance w.r.t. target is detected. Remaining + categories are converted into ``Other`` (or else, cf. regroup_name). p_value_threshold : float Significance threshold for regrouping. forced_categories : dict - Map to prevent certain categories from being group into ``Other`` + Map to prevent certain categories from being grouped into ``Other`` for each column - dict of the form ``{col:[forced vars]}``. scale_contingency_table : bool Whether contingency table should be scaled before chi^2. @@ -151,29 +145,26 @@ def from_params(cls, Returns ------- PreProcessor - class encapsulating CategoricalDataProcessor, - KBinsDiscretizer, and TargetEncoder instances - """ - categorical_data_processor = CategoricalDataProcessor( - model_type, - regroup, - regroup_name, - keep_missing, - category_size_threshold, - p_value_threshold, - scale_contingency_table, - forced_categories) - + Class encapsulating CategoricalDataProcessor, + KBinsDiscretizer, and TargetEncoder instances. + """ + categorical_data_processor = CategoricalDataProcessor(model_type, + regroup, + regroup_name, keep_missing, + category_size_threshold, + p_value_threshold, + scale_contingency_table, + forced_categories) + discretizer = KBinsDiscretizer(n_bins, strategy, closed, auto_adapt_bins, starting_precision, label_format, change_endpoint_format) - + target_encoder = TargetEncoder(weight, imputation_strategy) - return cls(model_type, - categorical_data_processor, discretizer, target_encoder) + return cls(categorical_data_processor, discretizer, target_encoder) @classmethod def from_pipeline(cls, pipeline: dict): @@ -183,27 +174,29 @@ def from_pipeline(cls, pipeline: dict): Parameters ---------- pipeline : dict - The (fitted) pipeline as a dictionary + The (fitted) pipeline as a dictionary. Returns ------- PreProcessor - Instance of PreProcessor instantiated from a stored pipeline + Instance of PreProcessor instantiated from a stored pipeline. Raises ------ ValueError - Description + If the loaded pipeline does not have all required parameters + and no others. """ if not PreProcessor._is_valid_pipeline(pipeline): - raise ValueError("Invalid pipeline") ## TODO: specify error + raise ValueError("Invalid pipeline, as it does not " + "contain all and only the required parameters.") categorical_data_processor = CategoricalDataProcessor() categorical_data_processor.set_attributes_from_dict( pipeline["categorical_data_processor"] ) - model_type = categorical_data_processor.model_type + # model_type = categorical_data_processor.model_type discretizer = KBinsDiscretizer() discretizer.set_attributes_from_dict(pipeline["discretizer"]) @@ -211,24 +204,23 @@ def from_pipeline(cls, pipeline: dict): target_encoder = TargetEncoder() target_encoder.set_attributes_from_dict(pipeline["target_encoder"]) - return cls(model_type, - categorical_data_processor, discretizer, target_encoder, + return cls(categorical_data_processor, discretizer, target_encoder, is_fitted=pipeline["_is_fitted"]) def fit(self, train_data: pd.DataFrame, continuous_vars: list, discrete_vars: list, target_column_name: str): - """Fit the data to the preprocessing pipeline + """Fit the data to the preprocessing pipeline. Parameters ---------- train_data : pd.DataFrame - Data to be preprocessed + Data to be preprocessed. continuous_vars : list - list of continuous variables + List of continuous variables. discrete_vars : list - list of discrete variables + List of discrete variables. target_column_name : str - Column name of the target + Column name of the target. """ # get list of all variables @@ -277,26 +269,26 @@ def fit(self, train_data: pd.DataFrame, continuous_vars: list, def transform(self, data: pd.DataFrame, continuous_vars: list, discrete_vars: list) -> pd.DataFrame: - """Transform the data by applying the preprocessing pipeline + """Transform the data by applying the preprocessing pipeline. Parameters ---------- data : pd.DataFrame - Data to be preprocessed + Data to be preprocessed. continuous_vars : list - list of continuous variables + List of continuous variables. discrete_vars : list - list of discrete variables + List of discrete variables. Returns ------- pd.DataFrame - Transformed (preprocessed) data + Transformed (preprocessed) data. Raises ------ NotFittedError - In case PreProcessor was not fitted first + In case PreProcessor was not fitted first. """ start = time.time() @@ -329,23 +321,23 @@ def transform(self, data: pd.DataFrame, continuous_vars: list, def fit_transform(self, train_data: pd.DataFrame, continuous_vars: list, discrete_vars: list, target_column_name: str) -> pd.DataFrame: - """Fit preprocessing pipeline and transform the data + """Fit preprocessing pipeline and transform the data. Parameters ---------- train_data : pd.DataFrame Data to be preprocessed continuous_vars : list - list of continuous variables + List of continuous variables. discrete_vars : list - list of discrete variables + List of discrete variables. target_column_name : str - Column name of the target + Column name of the target. Returns ------- pd.DataFrame - Transformed (preprocessed) data + Transformed (preprocessed) data. """ self.fit(train_data, continuous_vars, discrete_vars, @@ -355,27 +347,31 @@ def fit_transform(self, train_data: pd.DataFrame, continuous_vars: list, @staticmethod def train_selection_validation_split(data: pd.DataFrame, - train_prop: float = 0.6, - selection_prop: float = 0.2, - validation_prop: float = 0.2)-> pd.DataFrame: + train_prop: float=0.6, + selection_prop: float=0.2, + validation_prop: float=0.2) -> pd.DataFrame: """Adds `split` column with train/selection/validation values to the dataset. + Train set = data on which the model is trained and on which the encoding is based. + Selection set = data used for univariate and forward feature selection. Often called the validation set. + Validation set = data that generates the final performance metrics. Often called the test set. + Parameters ---------- data : pd.DataFrame - Input dataset to split into train-selection and validation sets + Input dataset to split into train-selection and validation sets. train_prop : float, optional - Percentage data to put in train set + Percentage data to put in train set. selection_prop : float, optional - Percentage data to put in selection set + Percentage data to put in selection set. validation_prop : float, optional - Percentage data to put in validation set + Percentage data to put in validation set. Returns ------- pd.DataFrame - DataFrame with additional split column + DataFrame with additional split column. """ if not math.isclose(train_prop + selection_prop + validation_prop, 1.0): raise ValueError("The sum of train_prop, selection_prop and " @@ -404,7 +400,6 @@ def train_selection_validation_split(data: pd.DataFrame, return data - def serialize_pipeline(self) -> dict: """Serialize the preprocessing pipeline by writing all its required parameters to a dictionary to later store it as a JSON file. @@ -412,7 +407,7 @@ def serialize_pipeline(self) -> dict: Returns ------- dict - Return the pipeline as a dictionary + Return the pipeline as a dictionary. """ pipeline = { "metadata": { @@ -440,7 +435,7 @@ def _is_valid_pipeline(pipeline: dict) -> bool: Parameters ---------- pipeline : dict - Loaded pipeline from json file + Loaded pipeline from JSON file. """ keys = inspect.getfullargspec(PreProcessor.from_params).args valid_keys = set([key for key in keys @@ -461,30 +456,30 @@ def _is_valid_pipeline(pipeline: dict) -> bool: @staticmethod def _get_variable_list(continuous_vars: list, discrete_vars: list) -> list: - """merge lists of continuous_vars and discrete_vars and add suffix - "_bin" resp. "_processed" to the predictors + """Merge lists of continuous_vars and discrete_vars and add suffix + "_bin" resp. "_processed" to the predictors. Parameters ---------- continuous_vars : list - list of continuous variables + List of continuous variables. discrete_vars : list - list of discrete variables + List of discrete variables. Returns ------- list - Merged list of predictors with proper suffixes added + Merged list of predictors with proper suffixes added. Raises ------ ValueError - in case both lists are empty + In case both lists are empty. """ var_list = ([col + "_processed" for col in discrete_vars] + [col + "_bin" for col in continuous_vars]) if not var_list: - raise ValueError("Variable var_list is None or empty list") + raise ValueError("Variable var_list is None or empty list.") return var_list diff --git a/cobra/preprocessing/target_encoder.py b/cobra/preprocessing/target_encoder.py index 64cdfcd..3eda39d 100644 --- a/cobra/preprocessing/target_encoder.py +++ b/cobra/preprocessing/target_encoder.py @@ -1,12 +1,4 @@ -""" -Incidence Replacement Module. The implementation is inspired by -https://github.com/scikit-learn-contrib/category_encoders. -Authors: - -- Geert Verstraeten (methodology) -- Matthias Roels (implementation) -""" import logging import pandas as pd @@ -16,9 +8,7 @@ log = logging.getLogger(__name__) - class TargetEncoder(BaseEstimator): - """Target encoding for categorical features, inspired by http://contrib.scikit-learn.org/category_encoders/targetencoder.html. @@ -28,15 +18,14 @@ class TargetEncoder(BaseEstimator): Note that, when applying this target encoding, values of the categorical feature that have not been seen during fit will be imputed according to the - configured imputation strategy: replacement with the mean, minimum or - maximum value of the categorical variable. + configured imputation strategy (replacement with the mean, minimum or + maximum value of the categorical variable). The main problem with Target encoding is overfitting; the fact that we are encoding the feature based on target classes may lead to data leakage, - rendering the feature biased. - This can be solved using some type of regularization. A popular way to - handle this is to use cross-validation and compute the means in each - out-of-fold. However, the approach implemented here makes use of + rendering the feature biased. This can be solved using some type of regularization. + A popular way to handle this is to use cross-validation and compute the means + in each out-of-fold. However, the approach implemented here makes use of additive smoothing (https://en.wikipedia.org/wiki/Additive_smoothing). In summary: @@ -44,19 +33,19 @@ class TargetEncoder(BaseEstimator): - with a binary classification target, a value of a categorical variable is replaced with: - [count(variable=value) * P(target=1|variable=value) + weight * P(target=1)] - / [count(variable=value) + weight] + [count(variable=value) * P(target=1|variable=value) + weight * P(target=1)] + / [count(variable=value) + weight] - with a regression target, a value of a categorical variable is replaced with: - [count(variable=value) * E(target|variable=value) + weight * E(target)] - / [count(variable=value) + weight] + [count(variable=value) * E(target|variable=value) + weight * E(target)] + / [count(variable=value) + weight] Attributes ---------- imputation_strategy : str - in case there is a particular column which contains new categories, + In case there is a particular column which contains new categories, the encoding will lead to NULL values which should be imputed. Valid strategies then are to replace the NULL values with the global mean of the train set or the min (resp. max) incidence of the @@ -77,7 +66,7 @@ def __init__(self, weight: float=0.0, imputation_strategy: str="mean"): if weight < 0: - raise ValueError("The value of weight cannot be smaller than zero") + raise ValueError("The value of weight cannot be smaller than zero.") elif imputation_strategy not in self.valid_imputation_strategies: raise ValueError("Valid options for 'imputation_strategy' are {}." " Got imputation_strategy={!r} instead." @@ -87,7 +76,8 @@ def __init__(self, weight: float=0.0, if weight == 0: log.warning("The target encoder's additive smoothing weight is " "set to 0. This disables smoothing and may make the " - "encoding prone to overfitting.") + "encoding prone to overfitting. Increase the weight " + "if needed.") self.weight = weight self.imputation_strategy = imputation_strategy @@ -103,7 +93,7 @@ def attributes_to_dict(self) -> dict: ------- dict Contains the attributes of TargetEncoder instance with the names - as keys + as keys. """ params = self.get_params() @@ -159,12 +149,12 @@ def fit(self, data: pd.DataFrame, column_names: list, Parameters ---------- data : pd.DataFrame - data used to compute the mapping to encode the categorical + Data used to compute the mapping to encode the categorical variables with. column_names : list - Columns of data to be encoded + Columns of data to be encoded. target_column : str - Column name of the target + Column name of the target. """ # compute global mean (target incidence in case of binary target) y = data[target_column] @@ -186,10 +176,10 @@ def _fit_column(self, X: pd.Series, y: pd.Series) -> pd.Series: Parameters ---------- X : pd.Series - data used to compute the encoding mapping for an individual + Data used to compute the encoding mapping for an individual categorical variable. y : pd.Series - series containing the targets for each observation (value) of + Series containing the targets for each observation (value) of this categorical variable. Returns @@ -218,14 +208,14 @@ def transform(self, data: pd.DataFrame, Parameters ---------- data : pd.DataFrame - the data to encode. + Data to encode. column_names : list - the name of the categorical columns in the data to be encoded. + Name of the categorical columns in the data to be encoded. Returns ------- pd.DataFrame - the resulting transformed data. + The resulting transformed data. Raises ------ @@ -261,14 +251,14 @@ def _transform_column(self, data: pd.DataFrame, Parameters ---------- data : pd.DataFrame - the data to encode. + Data to encode. column_name : str - the name of the column in the data to be encoded. + Name of the column in the data to be encoded. Returns ------- pd.DataFrame - the resulting transformed data. + Resulting transformed data. """ new_column = TargetEncoder._clean_column_name(column_name) @@ -298,21 +288,21 @@ def _transform_column(self, data: pd.DataFrame, def fit_transform(self, data: pd.DataFrame, column_names: list, target_column: str) -> pd.DataFrame: - """Fit the encoder and transform the data + """Fit the encoder and transform the data. Parameters ---------- data : pd.DataFrame - Data to be encoded + Data to be encoded. column_names : list - Columns of data to be encoded + Columns of data to be encoded. target_column : str - Column name of the target + Column name of the target. Returns ------- pd.DataFrame - data with additional columns, holding the target-encoded variables. + Data with additional columns, holding the target-encoded variables. """ self.fit(data, column_names, target_column) return self.transform(data, column_names) @@ -326,12 +316,12 @@ def _clean_column_name(column_name: str) -> str: Parameters ---------- column_name : str - column name to be cleaned + Column name to be cleaned. Returns ------- str - cleaned column name + Cleaned column name. """ if "_bin" in column_name: return column_name.replace("_bin", "") + "_enc" diff --git a/cobra/utils.py b/cobra/utils.py index c129270..f394caf 100644 --- a/cobra/utils.py +++ b/cobra/utils.py @@ -1,12 +1,7 @@ -def clean_predictor_name(predictor: str) -> str: - """Strip-off redundant suffix (e.g. "_enc" or "_bin") from the predictor - name to return a clean version of the predictor - - Args: - predictor (str): Description - - Returns: - str: Description +def clean_predictor_name(predictor_name: str) -> str: + """Strip the redundant suffix (e.g. "_enc" or "_bin") off from the end + of the predictor name to return a clean version of the predictor """ - return (predictor.replace("_enc", "").replace("_bin", "") - .replace("_processed", "")) + return (predictor_name.replace("_enc", "") + .replace("_bin", "") + .replace("_processed", "")) diff --git a/cobra/version.py b/cobra/version.py new file mode 100644 index 0000000..ff1068c --- /dev/null +++ b/cobra/version.py @@ -0,0 +1 @@ +__version__ = "1.1.0" \ No newline at end of file diff --git a/docs/Makefile b/docs/Makefile index cb7f749..92f501f 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -1,44 +1,19 @@ # Minimal makefile for Sphinx documentation -# # You can set these variables from the command line, and also # from the environment for the first two. SPHINXOPTS ?= SPHINXBUILD ?= sphinx-build SOURCEDIR = source -PAPER = BUILDDIR = build -# Internal variables. -PAPEROPT_a4 = -D latex_paper_size=a4 -PAPEROPT_letter = -D latex_paper_size=letter - -.PHONY: help Makefile clean html man changes linkcheck doctest - - # Put it first so that "make" without argument is like "make help". help: - @echo "Please use \`make ' where is one of" - @echo " html to make standalone HTML files" - @echo " man to make manual pages" - @echo " changes to make an overview of all changed/added/deprecated items" - @echo " linkcheck to check all external links for integrity" - @echo " doctest to run all doctests embedded in the documentation (if enabled)" - -clean: - -rm -rf $(BUILDDIR)/* - -html: - $(SPHINXBUILD) -b html $(SOURCEDIR) $(BUILDDIR)/html $(SPHINXOPTS) - -man: - $(SPHINXBUILD) -b man $(SPHINXOPTS) $(BUILDDIR)/man - -changes: - $(SPHINXBUILD) -b changes $(SPHINXOPTS) $(BUILDDIR)/changes + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) -linkcheck: - $(SPHINXBUILD) -b linkcheck $(SPHINXOPTS) $(BUILDDIR)/linkcheck +.PHONY: help Makefile -doctest: - $(SPHINXBUILD) -b doctest $(SPHINXOPTS) $(BUILDDIR)/doctest +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/make.bat b/docs/make.bat index 6247f7e..6fcf05b 100644 --- a/docs/make.bat +++ b/docs/make.bat @@ -21,7 +21,7 @@ if errorlevel 9009 ( echo.may add the Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from - echo.http://sphinx-doc.org/ + echo.https://www.sphinx-doc.org/ exit /b 1 ) diff --git a/docs/source/conf.py b/docs/source/conf.py index 449fd5a..64d3d6f 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -1,5 +1,5 @@ # Configuration file for the Sphinx documentation builder. -# + # This file only contains a selection of the most common options. For a full # list see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html @@ -14,16 +14,14 @@ import sys sys.path.insert(0, os.path.abspath('../../')) - # -- Project information ----------------------------------------------------- -project = 'cobra' -copyright = '2020, Python Predictions' +project = 'Cobra' +copyright = '2021, Python Predictions' author = 'Python Predictions' # The full version, including alpha/beta/rc tags -release = '1.0.0' - +release = '1.1.0' # -- General configuration --------------------------------------------------- @@ -72,12 +70,12 @@ # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. -# + html_theme = 'sphinx_rtd_theme' # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = ['_static'] +# html_static_path = ['_static'] # uncomment if exists, currently doesn't -html_favicon = 'images/cobra_icon.png' +html_favicon = 'images/cobra-icon2.png' diff --git a/docs/source/images/cobra_Icon.png b/docs/source/images/cobra_Icon.png deleted file mode 100644 index d915c5c..0000000 Binary files a/docs/source/images/cobra_Icon.png and /dev/null differ diff --git a/docs/source/index.rst b/docs/source/index.rst index 92055b9..69b1fb1 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -1,37 +1,17 @@ -.. cobra documentation master file, created by +.. Cobra documentation master file, created by sphinx-quickstart on Thu Dec 3 11:55:07 2020. You can adapt this file completely to your liking, but it should at least contain the root `toctree` directive. ********************************* -Welcome to cobra's documentation! +Welcome to Cobra's documentation! ********************************* .. include:: ../../README.rst -.. toctree:: - :maxdepth: 2 - :hidden: - :caption: Contents: - -.. toctree:: - :maxdepth: 4 - :hidden: - :caption: Tutorial - - tutorial - .. toctree:: :maxdepth: 4 :hidden: :caption: API Reference docstring/modules - - -Indices and tables -================== - -* :ref:`genindex` -* :ref:`modindex` -* :ref:`search` diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst deleted file mode 100644 index d8d69b1..0000000 --- a/docs/source/tutorial.rst +++ /dev/null @@ -1,224 +0,0 @@ -Tutorial -======== - -This section we will walk you through all the required steps to build a predictive model using cobra. All classes and functions used here are well-documented. In case you want more information on a class or function, simply read the corresponding parts in the documentation or run the following python snippet from e.g. a notebook: - -.. code-block:: python - - help(function_or_class_you_want_info_from) - -Building a good model involves three steps - - - preprocessing: properly prepare the predictors (a synonym for "feature" or variable that we use throughout this tutorial) for modelling. - - feature selection: automatically select a subset of predictors which contribute most to the target variable or output in which you are interested. - - model evaluation: once a model has been build, a detailed evaluation can be performed by computing all sorts of evaluation metrics. - -In the examples below, we assume the data for model building is available in a pandas DataFrame called ``basetable``. This DataFrame should at least contain an ID column (e.g. "customernumber"), a target column (e.g. "TARGET") and a number of candidate predictors (features) to build a model with. - -Preprocessing -------------- - -The first part focusses on preparing the predictors for modelling by: - -- Splitting the dataset into training, selection and validation datasets. -- binning continuous variables into discrete intervals -- Replacing missing values of both categorical and continuous variables (which are now binned) with an additional "Missing" bin/category -- Regrouping categories in new category "other" -- Replacing bins/categories with their corresponding incidence rate per category/bin. - -This will be taken care of by the ``PreProcessor`` class, which has a scikit-learn like interface (i.e. ``fit`` & ``transform``) - -.. code-block:: python - - import json - from cobra.preprocessing import PreProcessor - - # Prepare data - # create instance of PreProcessor from parameters - # There are many options possible, see API reference, but here - # we will use all the defaults - preprocessor = PreProcessor.from_params() - - # split data into train-selection-validation set - # in the result, an additional column "split" will be created - # containing each of those values - basetable = preprocessor.train_selection_validation_split( - basetable, - train_prop=0.6, selection_prop=0.2, - validation_prop=0.2) - - # create list containing the column names of the discrete resp. - # continuous variables - continuous_vars = [] - discrete_vars = [] - - # fit the pipeline - preprocessor.fit(basetable[basetable["split"]=="train"], - continuous_vars=continuous_vars, - discrete_vars=discrete_vars, - target_column_name=target_column_name) - - # store fitted preprocessing pipeline as a JSON file - pipeline = preprocessor.serialize_pipeline() - - # I/O outside of PreProcessor to allow flexibility (e.g. upload to S3, ...) - path = "path/to/store/preprocessing/pipeline/as/json/file/for/later/re-use.json" - with open(path, "w") as file: - json.dump(pipeline, file) - - # transform the data (e.g. perform discretisation, incidence replacement, ...) - basetable = preprocessor.transform(basetable, - continuous_vars=continuous_vars, - discrete_vars=discrete_vars) - - # When you want to reuse the pipeline the next time, simply load it back in again - # using the following snippet: - # with open(path, "r") as file: - # pipeline = json.load(file) - # preprocessor = PreProcessor.from_pipeline(pipeline) and you're good to go! - -Feature selection ------------------ - -Once the predictors are properly prepared, we can start building a predictive model, which boils down to selecting the right predictors from the dataset to train a model on. As a dataset typically contains many predictors, we can first perform a univariate preselection to rule out any predictor with little to no predictive power. - -This preselection is based on an AUC threshold of a univariate model on the train and selection datasets. As the AUC just calculates the quality of a ranking, all monotonous transformations of a given ranking (i.e. transformations that do not alter the ranking itself) will lead to the same AUC. Hence, pushing a categorical variable (incl. a binned continuous variable) through a logistic regression will produce exactly the same ranking as using target encoding, as it will produce the exact same output: a ranking of the categories on the training/selection set. Therefore, no univariate model is trained here as the target encoded train and selection data is used as predicted scores to compute the AUC with against the target. - -.. code-block:: python - - from cobra.model_building import univariate_selection - from cobra.evaluation import plot_univariate_predictor_quality - from cobra.evaluation import plot_correlation_matrix - - # Get list of predictor names to use for univariate_selection - preprocessed_predictors = [col for col in basetable.columns if col.endswith("_enc")] - - # perform univariate selection on preprocessed predictors: - df_auc = univariate_selection.compute_univariate_preselection( - target_enc_train_data=basetable[basetable["split"] == "train"], - target_enc_selection_data=basetable[basetable["split"] == "selection"], - predictors=preprocessed_predictors, - target_column=target_column_name, - preselect_auc_threshold=0.53, # if auc_selection <= 0.53 exclude predictor - preselect_overtrain_threshold=0.05 # if (auc_train - auc_selection) >= 0.05 --> overfitting! - ) - - # Plot df_auc to get a horizontal barplot: - plot_univariate_predictor_quality(df_auc) - - # compute correlations between preprocessed predictors: - df_corr = (univariate_selection - .compute_correlations(basetable[basetable["split"] == "train"], - preprocessed_predictors)) - - # plot correlation matrix - plot_correlation_matrix(df_corr) - - # get a list of predictors selection by the univariate selection - preselected_predictors = (univariate_selection - .get_preselected_predictors(df_auc)) - -After an initial preselection on the predictors, we can start building the model itself using forward feature selection to choose the right set of predictors. Since we use target encoding on all our predictors, we will only consider models with positive coefficients (no sign flip should occur) as this makes the model more interpretable. - -.. code-block:: python - - from cobra.model_building import ForwardFeatureSelection - from cobra.evaluation import plot_performance_curves - from cobra.evaluation import plot_variable_importance - - forward_selection = ForwardFeatureSelection(max_predictors=30, - pos_only=True) - - # fit the forward feature selection on the train data - # has optional parameters to force and/or exclude certain predictors (see docs) - forward_selection.fit(basetable[basetable["split"] == "train"], - target_column_name, - preselected_predictors) - - # compute model performance (e.g. AUC for train-selection-validation) - performances = (forward_selection - .compute_model_performances(basetable, target_column_name)) - - # plot performance curves - plot_performance_curves(performances) - -Based on the performance curves (AUC per model with a particular number of predictors in case of logistic regression), a final model can then be chosen and the variables importance can be plotted: - -.. code-block:: python - - # After plotting the performances and selecting the model, - # we can extract this model from the forward_selection class: - model = forward_selection.get_model_from_step(5) - - # Note that chosen model has 6 variables (python lists start with index 0), - # which can be obtained as follows: - final_predictors = model.predictors - # We can also compute and plot the importance of each predictor in the model: - variable_importance = model.compute_variable_importance( - basetable[basetable["split"] == "selection"] - ) - plot_variable_importance(variable_importance) - -**Note**: variable importance is based on correlation of the predictor with the *model scores* (and not the true labels!). - -Finally, we can again export the model to a dictionary to store it as JSON - -.. code-block:: python - - model_dict = model.serialize() - - with open(path, "w") as file: - json.dump(model_dict, file) - - # To reload the model again from a JSON file, run the following snippet: - # from cobra.model_building import LogisticRegressionModel - # with open(path, "r") as file: - # model_dict = json.load(file) - # model = LogisticRegressionModel() - # model.deserialize(model_dict) - -Evaluation ----------- - -Now that we have build and selected a final model, it is time to evaluate it against various evaluation metrics: - -.. code-block:: python - - from cobra.evaluation import Evaluator - - # get numpy array of True target labels and predicted scores: - y_true = basetable[basetable["split"] == "selection"][target_column_name].values - y_pred = model.score_model(basetable[basetable["split"] == "selection"]) - - evaluator = Evaluator() - evaluator.fit(y_true, y_pred) # Automatically find the best cut-off probability - - # Get various scalar metrics such as accuracy, AUC, precision, recall, ... - evaluator.scalar_metrics - - # Plot non-scalar evaluation metrics: - evaluator.plot_roc_curve() - - evaluator.plot_confusion_matrix() - - evaluator.plot_cumulative_gains() - - evaluator.plot_lift_curve() - - evaluator.plot_cumulative_response_curve() - -Additionally, we can also compute the output needed to plot the so-called Predictor Insights Graphs (PIGs in short). These are graphs that represents the insights of the relationship between a single predictor (e.g. age) and the target (e.g. burnouts). This is a graph where the predictor is binned into groups, and where we represent group size in bars and group (target) incidence in a colored line. We have the option to force order of predictor values. - -.. code-block:: python - - from cobra.evaluation import generate_pig_tables - from cobra.evaluation import plot_incidence - - predictor_list = [col for col in basetable.columns - if col.endswith("_bin") or col.endswith("_processed")] - pig_tables = generate_pig_tables(basetable[basetable["split"] == "selection"], - id_column_name=id_column_name, - target_column_name=target_column_name, - preprocessed_predictors=predictor_list) - # Plot PIGs - plot_incidence(pig_tables, 'predictor_name', predictor_order) \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 9f3d508..f2c226f 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,7 +1,7 @@ numpy>=1.19.4 pandas>=1.1.5 scipy>=1.5.4 -scikit-learn>=0.23.1 -matplotlib>=3.3.3 +scikit-learn>=0.24.1 +matplotlib>=3.4.3 seaborn>=0.11.0 -tqdm>=4.59.0 \ No newline at end of file +tqdm>=4.62.2 \ No newline at end of file diff --git a/setup.py b/setup.py index ae9d925..3653165 100644 --- a/setup.py +++ b/setup.py @@ -1,3 +1,6 @@ + +exec(open("cobra/version.py").read()) # reads in __version__ + import pathlib from setuptools import setup, find_packages @@ -9,12 +12,12 @@ setup( name="pythonpredictions-cobra", - version="1.0.2", - description=("Package to build predictive models using " - "logistic regression"), + version=__version__, + description=("A Python package to build predictive linear and logistic regression " + "models focused on performance and interpretation."), long_description=README, long_description_content_type="text/x-rst", - packages=find_packages(include=['cobra', 'cobra.*']), + packages=find_packages(include=["cobra", "cobra.*"]), url="https://github.com/PythonPredictions/cobra", license="MIT", author="Python Predictions", @@ -23,8 +26,8 @@ "numpy>=1.19.4", "pandas>=1.1.5", "scipy>=1.5.4", - "scikit-learn>=0.23.1", - "matplotlib>=3.3.3", + "scikit-learn>=0.24.1", + "matplotlib>=3.4.3", "seaborn>=0.11.0", - "tqdm>=4.59.0"] + "tqdm>=4.62.2"] ) diff --git a/tests/evaluation/test_evaluation.py b/tests/evaluation/test_evaluation.py index 16273f2..0ed388f 100644 --- a/tests/evaluation/test_evaluation.py +++ b/tests/evaluation/test_evaluation.py @@ -1,9 +1,10 @@ + import pytest import pandas as pd import numpy as np -from cobra.evaluation import plot_incidence -from cobra.evaluation import Evaluator +from cobra.evaluation import plot_incidence +from cobra.evaluation import ClassificationEvaluator, RegressionEvaluator def mock_data(): d = {'variable': ['education', 'education', 'education', 'education'], @@ -23,11 +24,66 @@ def mock_preds(n, seed = 505): class TestEvaluation: - def test_plot_incidence(self): + def test_plot_incidence_with_unsupported_model_type(self): + with pytest.raises(ValueError): + plot_incidence(pig_tables=None, + variable="", + model_type="anomaly_detection") + + def test_plot_incidence_with_different_column_orders(self): + data = mock_data() + with pytest.raises(ValueError): + plot_incidence(pig_tables=data, + variable='education', + model_type="classification", + # different bins than in the data variable: + column_order=['1st-4th', '5th-6th', '7th-8th']) + + # Stubs for later (requires exposing df_plot and testing matplotlib's + # plot object fix and ax internals): + """ + def test_plot_incidence_without_column_order(self): + data = mock_data() + plot_incidence(pig_tables=data, + variable='education', + model_type="classification", + column_order=None) + + def test_plot_incidence_with_column_order(self): + data = mock_data() + plot_incidence(pig_tables=data, + variable='education', + model_type="classification", + column_order=['1st-4th', '5th-6th', '7th-8th', '9th']) + + def test_plot_incidence_visual_result_for_classification(self): data = mock_data() - column_order = ['1st-4th', '5th-6th', '7th-8th'] - with pytest.raises(Exception): - plot_incidence(data, 'education', column_order) + plot_incidence(pig_tables=data, + variable='education', + model_type="classification", + column_order=['1st-4th', '5th-6th', '7th-8th', '9th']) + + def test_plot_incidence_visual_result_for_regression(self): + data = mock_data() # change into regression target though. + plot_incidence(pig_tables=data, + variable='education', + model_type="regression", + column_order=['1st-4th', '5th-6th', '7th-8th', '9th']) + + def test_plot_predictions_regression(self): + y_true, y_pred = mock_preds(50, seed=123) + + evaluator = RegressionEvaluator() + evaluator.fit(y_true, y_pred) + evaluator.plot_predictions() + + def test_plot_qq(self): + y_true, y_pred = mock_preds(50, seed=631993) + + evaluator = RegressionEvaluator() + evaluator.fit(y_true, y_pred) + evaluator.plot_qq() + """ def test_lift_curve_n_bins(self): n_bins_test = [5, 10, 15, 35] @@ -36,9 +92,38 @@ def test_lift_curve_n_bins(self): n_bins_out = [] for n_bins in n_bins_test: - e = Evaluator(n_bins = n_bins) - out = Evaluator._compute_lift_per_bin(y_true, y_pred, e.n_bins) + e = ClassificationEvaluator(n_bins=n_bins) + out = ClassificationEvaluator._compute_lift_per_bin(y_true, y_pred, e.n_bins) lifts = out[1] n_bins_out.append(len(lifts)) - assert n_bins_test == n_bins_out \ No newline at end of file + assert n_bins_test == n_bins_out + + def test_fit_classification(self): + y_true, y_pred = mock_preds(50) + y_true = (y_true > 0.5).astype(int) # convert to 0-1 labels + + evaluator = ClassificationEvaluator(n_bins=5) + evaluator.fit(y_true, y_pred) + + assert (evaluator.y_true == y_true).all() + assert (evaluator.y_pred == y_pred).all() + for metric in ["accuracy", "AUC", "precision", "recall", + "F1", "matthews_corrcoef", "lift at {}".format(evaluator.lift_at)]: + assert evaluator.scalar_metrics[metric] is not None + assert evaluator.roc_curve is not None + assert evaluator.confusion_matrix is not None + assert evaluator.lift_curve is not None + assert evaluator.cumulative_gains is not None + + def test_fit_regression(self): + y_true, y_pred = mock_preds(50, seed=789) + y_true, y_pred = y_true*10, y_pred*10 # rescale so it looks more regression-like + evaluator = RegressionEvaluator() + evaluator.fit(y_true, y_pred) + + assert (evaluator.y_true == y_true).all() + assert (evaluator.y_pred == y_pred).all() + for metric in ["R2", "MAE", "MSE", "RMSE"]: + assert evaluator.scalar_metrics[metric] is not None + assert evaluator.qq is not None diff --git a/tests/model_building/test_forward_selection.py b/tests/model_building/test_forward_selection.py index 8c7c6ce..19f7157 100644 --- a/tests/model_building/test_forward_selection.py +++ b/tests/model_building/test_forward_selection.py @@ -1,41 +1,44 @@ + from contextlib import contextmanager import pytest - import pandas as pd -import numpy as np -from cobra.model_building.models import LogisticRegressionModel +from cobra.model_building.models import LogisticRegressionModel, LinearRegressionModel from cobra.model_building.forward_selection import ForwardFeatureSelection - @contextmanager def does_not_raise(): yield - -def mock_model_num_pred(n_predictors): - predictors = [f"var{i + 1}_enc" for i in range(n_predictors)] - return mock_model(predictors) - - -def mock_model(predictor_list): - model = LogisticRegressionModel() - model.predictors = predictor_list - - return model - - -def mock_data(add_split_col: bool=False): +def mock_data(add_split_col: bool=False, model_type="classification"): data = pd.DataFrame({"var1_enc": [0.42] * 10, "var2_enc": [0.94] * 10, - "var3_enc": [0.87] * 10, - "target": ([0] * 5 + [1] * 2 + [0] * 2 + [1])}) + "var3_enc": [0.87] * 10}) + + if model_type == "classification": + data["target"] = ([0] * 5 + [1] * 2 + [0] * 2 + [1]) + elif model_type == "regression": + data["target"] = [7, 2, 2, 9, 7, 3, 1, 4, 8, 5] if add_split_col: data.loc[:, "split"] = (["train"] * 7 + ["selection"] * 3) return data +def mock_model_num_pred(n_predictors, model_type="classification"): + predictors = [f"var{i + 1}_enc" for i in range(n_predictors)] + return mock_model(predictors, model_type) + +def mock_model(predictor_list, model_type="classification"): + if model_type == "classification": + model = LogisticRegressionModel() + elif model_type == "regression": + model = LinearRegressionModel() + + model.predictors = predictor_list + + return model + class TestForwardFeatureSelection: @@ -46,83 +49,109 @@ def test_get_model_from_step(self): with pytest.raises(ValueError): forward_selection.get_model_from_step(2) - def test_compute_model_performances(self, mocker): + @pytest.mark.parametrize("model_type", ["classification", "regression"]) + def test_compute_model_performances(self, mocker, model_type): - data = mock_data(add_split_col=True) + data = mock_data(add_split_col=True, model_type=model_type) - fw_selection = ForwardFeatureSelection() + fw_selection = ForwardFeatureSelection(model_type=model_type) fw_selection._fitted_models = [ - mock_model_num_pred(1), - mock_model_num_pred(2), - mock_model_num_pred(3) + mock_model_num_pred(1, model_type=model_type), + mock_model_num_pred(2, model_type=model_type), + mock_model_num_pred(3, model_type=model_type) ] - def mock_evaluate(self, X, y, split): + def mock_evaluate(self, X, y, split, metric): # on AUC scale, but gives the same for RMSE as it is a mock if split == "train": return 0.612 else: return 0.609 - (mocker - .patch(("cobra.model_building.forward_selection" - ".MLModel.evaluate"), - mock_evaluate)) + if model_type == "classification": + patch_fct = "cobra.model_building.forward_selection.LogisticRegressionModel.evaluate" + elif model_type == "regression": + patch_fct = "cobra.model_building.forward_selection.LinearRegressionModel.evaluate" + + mocker.patch(patch_fct, mock_evaluate) actual = (fw_selection .compute_model_performances(data, "target", - splits=["train", "selection"])) + splits=["train", "selection"], + metric=None)) + expected = pd.DataFrame([ - {"predictors": ["var1_enc"], "last_added_predictor": "var1_enc", - "train_performance": 0.612, "selection_performance": 0.609}, + {"predictors": ["var1_enc"], + "last_added_predictor": "var1_enc", + "train_performance": 0.612, "selection_performance": 0.609, + "model_type": model_type}, {"predictors": ["var1_enc", "var2_enc"], "last_added_predictor": "var2_enc", - "train_performance": 0.612, "selection_performance": 0.609}, + "train_performance": 0.612, "selection_performance": 0.609, + "model_type": model_type}, {"predictors": ["var1_enc", "var2_enc", "var3_enc"], "last_added_predictor": "var3_enc", - "train_performance": 0.612, "selection_performance": 0.609} + "train_performance": 0.612, "selection_performance": 0.609, + "model_type": model_type} ]) pd.testing.assert_frame_equal(actual, expected) - @pytest.mark.parametrize("max_predictors, expectation", - [(2, pytest.raises(ValueError)), - (3, does_not_raise()), - (5, does_not_raise()), - (10, does_not_raise()), - (15, does_not_raise())]) - def test_fit(self, mocker, max_predictors: int, expectation): - - # create list of elements [var1_enc, var2_c, ..., var10_enc] + @pytest.mark.parametrize("model_type", ["classification", "regression"]) + def test_ffs_train_data_assertions(self, model_type): + + fw_selection = ForwardFeatureSelection(model_type=model_type) + + with pytest.raises(AssertionError): # no split column + fw_selection.fit(pd.DataFrame(), "target", predictors=[""]) + + df = mock_data(add_split_col=True, model_type=model_type) + with pytest.raises(AssertionError): # not at least train & selection sets + fw_selection.fit(df[df["split"] == "train"], "target", predictors=[""]) + + @pytest.mark.parametrize("model_type, max_predictors, expectation", + [("classification", 2, pytest.raises(ValueError)), + ("classification", 3, does_not_raise()), + ("classification", 5, does_not_raise()), + ("classification", 10, does_not_raise()), + ("classification", 15, does_not_raise()), + ("regression", 2, pytest.raises(ValueError)), + ("regression", 3, does_not_raise()), + ("regression", 5, does_not_raise()), + ("regression", 10, does_not_raise()), + ("regression", 15, does_not_raise()) + ]) + def test_fit(self, mocker, model_type, max_predictors: int, expectation): + + # create list of elements [var1_enc, var2_enc, ..., var10_enc] predictors_list = [f"var{i+1}_enc" for i in range(10)] - # extract sublist [var1_enc, var5_enc, var9_enc]: + # extract sublist [var1_enc, var5_enc, var9_enc] forced_predictors_list = predictors_list[::4] ordered_output_list = (forced_predictors_list + [pred for pred in predictors_list if pred not in forced_predictors_list]) - fw_selection = ForwardFeatureSelection(max_predictors=max_predictors) + fw_selection = ForwardFeatureSelection(model_type=model_type, max_predictors=max_predictors) def mock_train_model(self, train_data, target_column_name, predictors): - return mock_model(predictors) + return mock_model(predictors, model_type=model_type) def mock_forward_selection(self, train_data, target_column_name, predictors, forced_predictors): - n_models = min(max_predictors, - len(predictors) + len(forced_predictors)) + n_models = min(max_predictors, len(predictors) + len(forced_predictors)) - return [mock_model(ordered_output_list[:i+1]) + return [mock_model(ordered_output_list[:i+1], model_type=model_type) for i in range(n_models)] - (mocker - .patch("cobra.model_building.ForwardFeatureSelection._train_model", - mock_train_model)) + mocker.patch("cobra.model_building.ForwardFeatureSelection._train_model", + mock_train_model) - mocker.patch(("cobra.model_building.ForwardFeatureSelection" - "._forward_selection"), mock_forward_selection) + mocker.patch("cobra.model_building.ForwardFeatureSelection._forward_selection", + mock_forward_selection) + df = mock_data(add_split_col=True, model_type=model_type) with expectation: - fw_selection.fit(pd.DataFrame(), "target", + fw_selection.fit(df, "target", # data is ignored predictors=predictors_list, forced_predictors=forced_predictors_list, excluded_predictors=[]) @@ -140,8 +169,14 @@ def mock_forward_selection(self, train_data, target_column_name, assert actual == expected - @pytest.mark.parametrize("max_predictors", [5, 10, 15]) - def test_forward_selection(self, mocker, max_predictors: int): + @pytest.mark.parametrize("model_type, max_predictors", [("classification", 5), + ("classification", 10), + ("classification", 15), + ("regression", 5), + ("regression", 10), + ("regression", 15) + ]) + def test_forward_selection(self, mocker, model_type, max_predictors: int): # create list of elements [var1_enc, var2_c, ..., var10_enc] predictors_list = [f"var{i+1}_enc" for i in range(10)] @@ -157,12 +192,12 @@ def test_forward_selection(self, mocker, max_predictors: int): def mock_find_next_best_model(self, train_data, target_column_name, candidate_predictors, current_predictors): - return mock_model(current_predictors + candidate_predictors[0:1]) + return mock_model(current_predictors + candidate_predictors[0:1], model_type=model_type) mocker.patch(("cobra.model_building.ForwardFeatureSelection." "_find_next_best_model"), mock_find_next_best_model) - fw_selection = ForwardFeatureSelection(max_predictors=max_predictors) + fw_selection = ForwardFeatureSelection(model_type=model_type, max_predictors=max_predictors) fitted_models = (fw_selection. _forward_selection(pd.DataFrame(), "target", diff --git a/tests/model_building/test_models.py b/tests/model_building/test_models.py index 80623f5..d7c04aa 100644 --- a/tests/model_building/test_models.py +++ b/tests/model_building/test_models.py @@ -1,8 +1,8 @@ + import numpy as np import pandas as pd -from cobra.model_building.models import LogisticRegressionModel - +from cobra.model_building.models import LogisticRegressionModel, LinearRegressionModel def mock_data(): return pd.DataFrame({"var1_enc": [0.42] * 10, @@ -10,9 +10,11 @@ def mock_data(): "var3_enc": [0.87] * 10}) -def mock_score_model(self, data): +def mock_score_model_classification(self, data): return np.array([0.5, 0.8, 0.2, 0.9, 0.1, 0.7, 0.3, 0.6, 0.4, 0.5]) +def mock_score_model_regression(self, data): + return np.array([0.7, 0.2, 0.2, 0.9, 0.7, 0.3, 0.1, 0.4, 0.8, 0.5])*15 class TestLogisticRegressionModel: @@ -26,7 +28,7 @@ def mock_roc_auc_score(y_true, y_score): (mocker .patch("cobra.model_building.LogisticRegressionModel.score_model", - mock_score_model)) + mock_score_model_classification)) (mocker .patch("cobra.model_building.models.roc_auc_score", @@ -45,8 +47,7 @@ def test_evaluate_cached(self): model = LogisticRegressionModel() model._eval_metrics_by_split["train"] = expected - actual = model.evaluate(pd.DataFrame(), pd.Series(dtype="float64"), - split) + actual = model.evaluate(pd.DataFrame(), pd.Series(dtype="float64"), split) assert actual == expected @@ -57,7 +58,7 @@ def mock_pearsonr(ypred, ytrue): (mocker .patch("cobra.model_building.LogisticRegressionModel.score_model", - mock_score_model)) + mock_score_model_classification)) (mocker .patch("cobra.model_building.models.stats.pearsonr", @@ -78,7 +79,7 @@ def mock_pearsonr(ypred, ytrue): pd.testing.assert_frame_equal(actual, expected) - def test_serialize(self, mocker): + def test_serialize(self): model = LogisticRegressionModel() actual = model.serialize() @@ -145,6 +146,115 @@ def test_deserialize(self): assert logit.get_params() == model_dict["params"] assert logit.classes_.all() == np.array(model_dict["classes_"]).all() assert logit.n_iter_.all() == np.array(model_dict["n_iter_"]).all() - assert logit.intercept_.all() == (np.array(model_dict["intercept_"]) - .all()) + assert logit.intercept_.all() == (np.array(model_dict["intercept_"]).all()) assert logit.coef_.all() == np.array(model_dict["coef_"]).all() + +class TestLinearRegressionModel: + + def test_evaluate(self, mocker): + + X = mock_data() + y = pd.Series(np.array([0.6, 0.1, 0.2, 0.9, 0.8, 0.3, 0.2, 0.4, 0.9, 0.5])*12) + + def mock_mean_squared_error(y_true, y_pred): + return 1.23 + + (mocker + .patch("cobra.model_building.LinearRegressionModel.score_model", + mock_score_model_regression)) + + (mocker + .patch("cobra.model_building.models.mean_squared_error", + mock_mean_squared_error)) + + model = LinearRegressionModel() + actual = model.evaluate(X, y) + + assert actual == np.sqrt(1.23) + + def test_evaluate_cached(self): + + split = "train" + expected = np.sqrt(1.23) + + model = LinearRegressionModel() + model._eval_metrics_by_split["train"] = expected + + actual = model.evaluate(pd.DataFrame(), pd.Series(dtype="float64"), split) + + assert actual == expected + + def test_compute_variable_importance(self, mocker): + + def mock_pearsonr(ypred, ytrue): + return [ypred.unique()[0]] + + (mocker + .patch("cobra.model_building.LinearRegressionModel.score_model", + mock_score_model_regression)) + + (mocker + .patch("cobra.model_building.models.stats.pearsonr", + mock_pearsonr)) + + model = LinearRegressionModel() + model.predictors = ["var1_enc", "var2_enc", "var3_enc"] + + data = mock_data() + + actual = model.compute_variable_importance(data) + + expected = pd.DataFrame([ + {"predictor": "var1", "importance": data["var1_enc"].unique()[0]}, + {"predictor": "var2", "importance": data["var2_enc"].unique()[0]}, + {"predictor": "var3", "importance": data["var3_enc"].unique()[0]} + ]).sort_values(by="importance", ascending=False).reset_index(drop=True) + + pd.testing.assert_frame_equal(actual, expected) + + def test_serialize(self): + + model = LinearRegressionModel() + actual = model.serialize() + + expected = { + "meta": "linear-regression", + "predictors": [], + "_eval_metrics_by_split": {}, + "params": { + "copy_X": True, + "fit_intercept": True, + "n_jobs": None, + "normalize": False, + "positive": False + } + } + + assert actual == expected + + def test_deserialize(self): + + model = LinearRegressionModel() + + model_dict = { + "meta": "linear-regression", + "predictors": [], + "_eval_metrics_by_split": {}, + "params": { + "copy_X": True, + "fit_intercept": True, + "n_jobs": None, + "normalize": False, + "positive": False + }, + "coef_": [[0.5, 0.75]], + "intercept_": [-3] + } + + model.deserialize(model_dict) + + linear = model.linear + assert linear.get_params() == model_dict["params"] + assert linear.intercept_.all() == (np.array(model_dict["intercept_"]).all()) + assert linear.coef_.all() == np.array(model_dict["coef_"]).all() + diff --git a/tests/model_building/test_univariate_selection.py b/tests/model_building/test_univariate_selection.py new file mode 100644 index 0000000..c69a4de --- /dev/null +++ b/tests/model_building/test_univariate_selection.py @@ -0,0 +1,59 @@ + +import pandas as pd + +from cobra.model_building import univariate_selection + +def mock_data(): + return pd.DataFrame({"var1_enc": [0.42] * 10, + "var2_enc": [0.94] * 10, + "var3_enc": [0.87] * 10}) + +class TestUnivariateSelection: + + def test_preselection_classification(self): + + X = mock_data() + y = pd.DataFrame([1] * 5 + [0] * 5, columns=["target"]) + + basetable = pd.concat([y, X], axis=1) + basetable["split"] = ["train"] * 3 + ["selection"] * 6 + ["train"] + + df_auc = univariate_selection.compute_univariate_preselection( + target_enc_train_data=basetable[basetable["split"] == "train"], + target_enc_selection_data=basetable[basetable["split"] == "selection"], + predictors=X.columns, + target_column="target", + model_type="classification", + preselect_auc_threshold=0.48, + preselect_overtrain_threshold=0.05) + + assert all(c in df_auc.columns for c in ["AUC train", "AUC selection"]) + + preselected_predictors = (univariate_selection + .get_preselected_predictors(df_auc)) + + assert preselected_predictors == ["var1_enc", "var2_enc", "var3_enc"] + + def test_preselection_regression(self): + + X = mock_data() + y = pd.DataFrame([6.0, 9.0, 4.2, 5.5, 0.7, 1.9, 8.7, 8.0, 2.0, 7.2], columns=["target"]) + + basetable = pd.concat([y, X], axis=1) + basetable["split"] = ["train"] * 3 + ["selection"] * 6 + ["train"] + + df_rmse = univariate_selection.compute_univariate_preselection( + target_enc_train_data=basetable[basetable["split"] == "train"], + target_enc_selection_data=basetable[basetable["split"] == "selection"], + predictors=X.columns, + target_column="target", + model_type="regression", + preselect_auc_threshold=5, + preselect_overtrain_threshold=0.05) + + assert all(c in df_rmse.columns for c in ["RMSE train", "RMSE selection"]) + + preselected_predictors = (univariate_selection + .get_preselected_predictors(df_rmse)) + + assert preselected_predictors == ["var2_enc", "var3_enc"] diff --git a/tests/preprocessing/test_categorical_data_processor.py b/tests/preprocessing/test_categorical_data_processor.py index 6e026d3..dd53434 100644 --- a/tests/preprocessing/test_categorical_data_processor.py +++ b/tests/preprocessing/test_categorical_data_processor.py @@ -1,11 +1,10 @@ -import pytest +import pytest import numpy as np import pandas as pd from cobra.preprocessing import CategoricalDataProcessor - class TestCategoricalDataProcessor: def test_attributes_to_dict(self): diff --git a/tests/preprocessing/test_kbins_discretizer.py b/tests/preprocessing/test_kbins_discretizer.py index 5b0aeeb..d3a643a 100644 --- a/tests/preprocessing/test_kbins_discretizer.py +++ b/tests/preprocessing/test_kbins_discretizer.py @@ -1,13 +1,11 @@ + from contextlib import contextmanager import pytest - import numpy as np import pandas as pd -import math from cobra.preprocessing.kbins_discretizer import KBinsDiscretizer - @contextmanager def does_not_raise(): yield diff --git a/tests/preprocessing/test_preprocessor.py b/tests/preprocessing/test_preprocessor.py index 2e42759..0dd6694 100644 --- a/tests/preprocessing/test_preprocessor.py +++ b/tests/preprocessing/test_preprocessor.py @@ -1,14 +1,12 @@ -from contextlib import contextmanager -import pytest +from contextlib import contextmanager from typing import Any - +import pytest import numpy as np import pandas as pd from cobra.preprocessing.preprocessor import PreProcessor - @contextmanager def does_not_raise(): yield diff --git a/tests/preprocessing/test_target_encoder.py b/tests/preprocessing/test_target_encoder.py index d6007c9..51ebd79 100644 --- a/tests/preprocessing/test_target_encoder.py +++ b/tests/preprocessing/test_target_encoder.py @@ -1,10 +1,10 @@ + import pytest import pandas as pd from sklearn.exceptions import NotFittedError from cobra.preprocessing.target_encoder import TargetEncoder - class TestTargetEncoder: def test_target_encoder_constructor_weight_value_error(self): diff --git a/tutorials/tutorial_Cobra_linear_regression.ipynb b/tutorials/tutorial_Cobra_linear_regression.ipynb new file mode 100644 index 0000000..520e06b --- /dev/null +++ b/tutorials/tutorial_Cobra_linear_regression.ipynb @@ -0,0 +1,1935 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, \"C:/Users/samuel.borms/Desktop/code/cobra\")\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cobra's approach to linear regression" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cobra requires the usual Python packages for data science, such as numpy, pandas and scikit-learn. These packages, along with their versions are listed in requirements.txt and can be installed using pip." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# pip install -r requirements.txt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you want to install Cobra with e.g. pip, you don't have to install all of these requirements as these are automatically installed with Cobra itself. Hence, the easiest way to install Cobra is using pip:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# pip install -U pythonpredictions-cobra" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*****" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This section we will walk you through all the required steps to build a predictive linear regression model using **Cobra**. All classes and functions used here are well-documented. In case you want more information on a class or function, run `help(function_or_class_you_want_info_from)`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Building a good model involves three steps:\n", + "\n", + "1. **Preprocessing**: properly prepare the predictors (a synonym for “feature” or variable that we use throughout this tutorial) for modelling.\n", + "\n", + "2. **Feature selection**: automatically select a subset of predictors which contribute most to the target variable or output in which you are interested.\n", + "\n", + "3. **Model evaluation**: once a model has been build, a detailed evaluation can be performed by computing all sorts of evaluation metrics.\n", + "\n", + "Let's dive in!\n", + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Miles per gallon prediction\n", + "\n", + "- BASETABLE: seaborn dataset MPG.\n", + "- GOAL: Predict the distance (measured in miles) that a car can travel per gallon of fuel." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Import the necessary libraries first." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import os\n", + "import random\n", + "import pandas as pd\n", + "import numpy as np\n", + "import seaborn as sns\n", + "from pandas.api.types import is_datetime64_any_dtype\n", + "from sklearn import metrics\n", + "\n", + "pd.set_option(\"display.max_columns\", 50)\n", + "pd.set_option(\"display.max_rows\", 50)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from cobra import __version__\n", + "\n", + "from cobra.preprocessing import PreProcessor\n", + "\n", + "from cobra.model_building import univariate_selection\n", + "from cobra.model_building import ForwardFeatureSelection\n", + "# from cobra.model_building import LinearRegressionModel\n", + "\n", + "from cobra.evaluation import RegressionEvaluator\n", + "from cobra.evaluation import generate_pig_tables\n", + "from cobra.evaluation import plot_univariate_predictor_quality\n", + "from cobra.evaluation import plot_correlation_matrix\n", + "from cobra.evaluation import plot_performance_curves\n", + "from cobra.evaluation import plot_variable_importance\n", + "from cobra.evaluation import plot_incidence" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The version of Cobra being used is 1.1.0.\n" + ] + } + ], + "source": [ + "print(f\"The version of Cobra being used is {__version__}.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mpgcylindersdisplacementhorsepowerweightaccelerationmodel_yearoriginname
018.08307.0130.0350412.070usachevrolet chevelle malibu
115.08350.0165.0369311.570usabuick skylark 320
218.08318.0150.0343611.070usaplymouth satellite
316.08304.0150.0343312.070usaamc rebel sst
417.08302.0140.0344910.570usaford torino
\n", + "
" + ], + "text/plain": [ + " mpg cylinders displacement horsepower weight acceleration \\\n", + "0 18.0 8 307.0 130.0 3504 12.0 \n", + "1 15.0 8 350.0 165.0 3693 11.5 \n", + "2 18.0 8 318.0 150.0 3436 11.0 \n", + "3 16.0 8 304.0 150.0 3433 12.0 \n", + "4 17.0 8 302.0 140.0 3449 10.5 \n", + "\n", + " model_year origin name \n", + "0 70 usa chevrolet chevelle malibu \n", + "1 70 usa buick skylark 320 \n", + "2 70 usa plymouth satellite \n", + "3 70 usa amc rebel sst \n", + "4 70 usa ford torino " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = sns.load_dataset(\"mpg\")\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the example below, we assume the data for model building is available in a pandas DataFrame. This DataFrame should contain an ID column, a target column (e.g. “**mpg**”) and a number of candidate predictors (features) to build a model with.\n", + "\n", + "***" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "mpg float64\n", + "cylinders int64\n", + "displacement float64\n", + "horsepower float64\n", + "weight int64\n", + "acceleration float64\n", + "model_year int64\n", + "origin object\n", + "name object\n", + "dtype: object" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.dtypes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is required to set all category vars to object dtype." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "df.loc[:, df.dtypes==\"category\"] = (df.select_dtypes([\"category\"]).apply(lambda x: x.astype(\"object\")))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data preprocessing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### The first part focusses on preparing the predictors for modelling by:\n", + "\n", + "1. Defining the ID column, the target, discrete and contineous variables.\n", + "\n", + "2. Splitting the dataset into training, selection and validation datasets.\n", + "\n", + "3. Binning continuous variables into discrete intervals.\n", + "\n", + "4. Replacing missing values of both categorical and continuous variables (which are now binned) with an additional “Missing” bin/category.\n", + "\n", + "5. Regrouping categories in new category “other”.\n", + "\n", + "6. Replacing bins/categories with their corresponding average of the target values.\n", + "\n", + "*Note to user*: as any good data scientist knows, you still need to deal in your data with irregularities, such as outliers or very skewed distributions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this toy dataset, the index will serve as ID." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "df[\"id\"] = df.index + 1\n", + "id_col = \"id\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The target is the \"MPG\" column." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "count 398.000000\n", + "mean 23.514573\n", + "std 7.815984\n", + "min 9.000000\n", + "25% 17.500000\n", + "50% 23.000000\n", + "75% 29.000000\n", + "max 46.600000\n", + "Name: mpg, dtype: float64" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "target_col = \"mpg\"\n", + "df[target_col].describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(398, 10)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to find out which variables are categorical (discrete) and which are continuous.\n", + "\n", + "Discrete variables are definitely those that contain strings." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['origin', 'name']\n" + ] + } + ], + "source": [ + "col_dtypes = df.dtypes\n", + "discrete_vars = [col for col in col_dtypes[col_dtypes==object].index.tolist() if col not in [id_col, target_col]] \n", + "print(discrete_vars)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we also check for numerical columns that only contain a few different values, thus to be interpreted as discrete, categorical variables." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cylinders\n" + ] + } + ], + "source": [ + "for col in df.columns:\n", + " if col not in discrete_vars and col not in [id_col, target_col]: # omit discrete because a string, and target\n", + " val_counts = df[col].nunique()\n", + " if val_counts > 1 and val_counts <= 10: # the column contains less than 10 different values\n", + " print(col)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By taking a look at the printed variables, it is clear that we have to include those in the list of discrete variables." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['origin', 'name', 'cylinders']" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "discrete_vars.extend([\"cylinders\"])\n", + "discrete_vars" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The remaining variables can be labeled continous predictors, without including the target variable." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['weight', 'displacement', 'horsepower', 'acceleration', 'model_year']" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "continuous_vars = list(set(df.columns)\n", + " - set(discrete_vars) \n", + " - set([id_col, target_col]))\n", + "continuous_vars " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we can prepare **Cobra's PreProcessor** object." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "model_type = \"regression\"" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The target encoder's additive smoothing weight is set to 0. This disables smoothing and may make the encoding prone to overfitting. Increase the weight if needed.\n" + ] + } + ], + "source": [ + "# using all Cobra's default parameters for preprocessing here\n", + "preprocessor = PreProcessor.from_params(\n", + " model_type=model_type\n", + ")\n", + "\n", + "# these are all available options: help(PreProcessor.from_params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Split the data into train-selection-validation sets." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "random.seed(1212)\n", + "basetable = preprocessor.train_selection_validation_split(data=df,\n", + " train_prop=0.6,\n", + " selection_prop=0.25,\n", + " validation_prop=0.15)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Fit the preprocessor pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cf6c51a8c50248cdbffd9b6bba982ff6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Computing discretization bins...: 0%| | 0/5 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mpgcylindersdisplacementhorsepowerweightaccelerationmodel_yearoriginnameidsplitweight_bindisplacement_binhorsepower_binacceleration_binmodel_year_binorigin_processedname_processedcylinders_processedorigin_encname_enccylinders_encweight_encdisplacement_enchorsepower_encacceleration_encmodel_year_enc
018.08307.0130.0350412.070usachevrolet chevelle malibu1validation3432.0 - 3883.0250.0 - 318.0113.0 - 145.08.0 - 12.070.0 - 71.0usachevrolet chevelle malibu820.3587117.015.05151517.12916716.79333318.76923116.18518519.057143
115.08350.0165.0369311.570usabuick skylark 3202train3432.0 - 3883.0318.0 - 350.0162.0 - 230.08.0 - 12.070.0 - 71.0usabuick skylark 320820.3587115.015.05151517.12916715.03529413.61250016.18518519.057143
218.08318.0150.0343611.070usaplymouth satellite3train3432.0 - 3883.0250.0 - 318.0145.0 - 162.08.0 - 12.070.0 - 71.0usaplymouth satellite820.3587118.015.05151517.12916716.79333314.38095216.18518519.057143
316.08304.0150.0343312.070usaamc rebel sst4train3432.0 - 3883.0250.0 - 318.0145.0 - 162.08.0 - 12.070.0 - 71.0usaamc rebel sst820.3587116.015.05151517.12916716.79333314.38095216.18518519.057143
417.08302.0140.0344910.570usaford torino5train3432.0 - 3883.0250.0 - 318.0113.0 - 145.08.0 - 12.070.0 - 71.0usaford torino820.3587117.015.05151517.12916716.79333318.76923116.18518519.057143
\n", + "" + ], + "text/plain": [ + " mpg cylinders displacement horsepower weight acceleration \\\n", + "0 18.0 8 307.0 130.0 3504 12.0 \n", + "1 15.0 8 350.0 165.0 3693 11.5 \n", + "2 18.0 8 318.0 150.0 3436 11.0 \n", + "3 16.0 8 304.0 150.0 3433 12.0 \n", + "4 17.0 8 302.0 140.0 3449 10.5 \n", + "\n", + " model_year origin name id split \\\n", + "0 70 usa chevrolet chevelle malibu 1 validation \n", + "1 70 usa buick skylark 320 2 train \n", + "2 70 usa plymouth satellite 3 train \n", + "3 70 usa amc rebel sst 4 train \n", + "4 70 usa ford torino 5 train \n", + "\n", + " weight_bin displacement_bin horsepower_bin acceleration_bin \\\n", + "0 3432.0 - 3883.0 250.0 - 318.0 113.0 - 145.0 8.0 - 12.0 \n", + "1 3432.0 - 3883.0 318.0 - 350.0 162.0 - 230.0 8.0 - 12.0 \n", + "2 3432.0 - 3883.0 250.0 - 318.0 145.0 - 162.0 8.0 - 12.0 \n", + "3 3432.0 - 3883.0 250.0 - 318.0 145.0 - 162.0 8.0 - 12.0 \n", + "4 3432.0 - 3883.0 250.0 - 318.0 113.0 - 145.0 8.0 - 12.0 \n", + "\n", + " model_year_bin origin_processed name_processed \\\n", + "0 70.0 - 71.0 usa chevrolet chevelle malibu \n", + "1 70.0 - 71.0 usa buick skylark 320 \n", + "2 70.0 - 71.0 usa plymouth satellite \n", + "3 70.0 - 71.0 usa amc rebel sst \n", + "4 70.0 - 71.0 usa ford torino \n", + "\n", + " cylinders_processed origin_enc name_enc cylinders_enc weight_enc \\\n", + "0 8 20.35871 17.0 15.051515 17.129167 \n", + "1 8 20.35871 15.0 15.051515 17.129167 \n", + "2 8 20.35871 18.0 15.051515 17.129167 \n", + "3 8 20.35871 16.0 15.051515 17.129167 \n", + "4 8 20.35871 17.0 15.051515 17.129167 \n", + "\n", + " displacement_enc horsepower_enc acceleration_enc model_year_enc \n", + "0 16.793333 18.769231 16.185185 19.057143 \n", + "1 15.035294 13.612500 16.185185 19.057143 \n", + "2 16.793333 14.380952 16.185185 19.057143 \n", + "3 16.793333 14.380952 16.185185 19.057143 \n", + "4 16.793333 18.769231 16.185185 19.057143 " + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "basetable = preprocessor.transform(basetable,\n", + " continuous_vars=continuous_vars,\n", + " discrete_vars=discrete_vars)\n", + "basetable.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Predictor Insights Graphs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we can the create the so-called Predictor Insights Graphs (PIGs in short). These are graphs that represents the insights of the relationship between a single predictor and the target. More specifically, the predictor is binned into groups, and we represent group size in bars and group target mean in a colored line. Moreover, we have the option to force order of predictor values. First, we compute the output needed to plot the PIG." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
variablelabelpop_sizeglobal_avg_targetavg_target
0acceleration8.0 - 12.00.11250023.54083316.185185
1acceleration12.0 - 13.40.09583323.54083318.069565
2acceleration13.4 - 14.00.09583323.54083317.560870
3acceleration14.0 - 14.80.10416723.54083326.832000
4acceleration14.8 - 15.50.12916723.54083323.645161
..................
5weight2792.0 - 3076.00.10000023.54083322.729167
6weight3076.0 - 3432.00.10000023.54083319.800000
7weight3432.0 - 3883.00.10000023.54083317.129167
8weight3883.0 - 4280.00.10000023.54083315.250000
9weight4280.0 - 5140.00.10000023.54083313.229167
\n", + "

254 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " variable label pop_size global_avg_target avg_target\n", + "0 acceleration 8.0 - 12.0 0.112500 23.540833 16.185185\n", + "1 acceleration 12.0 - 13.4 0.095833 23.540833 18.069565\n", + "2 acceleration 13.4 - 14.0 0.095833 23.540833 17.560870\n", + "3 acceleration 14.0 - 14.8 0.104167 23.540833 26.832000\n", + "4 acceleration 14.8 - 15.5 0.129167 23.540833 23.645161\n", + ".. ... ... ... ... ...\n", + "5 weight 2792.0 - 3076.0 0.100000 23.540833 22.729167\n", + "6 weight 3076.0 - 3432.0 0.100000 23.540833 19.800000\n", + "7 weight 3432.0 - 3883.0 0.100000 23.540833 17.129167\n", + "8 weight 3883.0 - 4280.0 0.100000 23.540833 15.250000\n", + "9 weight 4280.0 - 5140.0 0.100000 23.540833 13.229167\n", + "\n", + "[254 rows x 5 columns]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predictor_list = [col for col in basetable.columns if col.endswith(\"_bin\") or col.endswith(\"_processed\")]\n", + "pig_tables = generate_pig_tables(basetable[basetable[\"split\"]==\"train\"],\n", + " id_column_name=id_col,\n", + " target_column_name=target_col,\n", + " preprocessed_predictors=predictor_list)\n", + "pig_tables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, we can plot a PIG graph for each of the predictors in the basetable. For instance, for the variable \"acceleration\"." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "col_order = list(basetable[\"horsepower_bin\"].unique().sort_values())\n", + "plot_incidence(pig_tables, variable=\"horsepower\", model_type=model_type, column_order=col_order)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['validation', 'train', 'selection'], dtype=object)" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "basetable[\"split\"].unique()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Feature selection" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once the predictors are properly prepared, we can start building a predictive model, which boils down to selecting the right predictors from the dataset to train a model on.\n", + "\n", + "As a dataset typically contains many predictors, **we first perform a univariate preselection** to rule out any predictor with little to no predictive power. \n", + "\n", + "Later, using the list of preselected features, we build a multiple regression model using **forward feature selection** to choose the right set of predictors." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In previous steps, these were the predictors, as preprocessed so far:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['acceleration_bin',\n", + " 'cylinders_processed',\n", + " 'displacement_bin',\n", + " 'horsepower_bin',\n", + " 'model_year_bin',\n", + " 'name_processed',\n", + " 'origin_processed',\n", + " 'weight_bin']" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preprocessed_predictors = [\n", + " col for col in basetable.columns\n", + " if col.endswith(\"_bin\") or col.endswith(\"_processed\")\n", + "]\n", + "sorted(preprocessed_predictors)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But for feature selection, we use the target encoded version of each of these." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "preprocessed_predictors = [col for col in basetable.columns.tolist() if \"_enc\" in col]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A univariate selection on the preprocessed predictors is conducted. The thresholds for retaining a feature can be changed by the user, for instance both at 10 for now." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_rmse = univariate_selection.compute_univariate_preselection(\n", + " target_enc_train_data=basetable[basetable[\"split\"]==\"train\"],\n", + " target_enc_selection_data=basetable[basetable[\"split\"]==\"selection\"],\n", + " predictors=preprocessed_predictors,\n", + " target_column=target_col,\n", + " model_type=model_type,\n", + " preselect_rmse_threshold=10, # max. RMSE for selection\n", + " preselect_overtrain_threshold=10) # difference between RMSE on train and selection set\n", + "\n", + "# as the square root of a variance, RMSE can be interpreted as the standard deviation of \n", + "# the unexplained variance, and has the useful property of being in the same unit as the response variable\n", + "# lower values of RMSE indicate better fit\n", + "\n", + "plot_univariate_predictor_quality(df_rmse)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we compute correlations between the preprocessed predictors and plot it using a correlation matrix." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " origin name cylinders weight displacement \\\n", + "origin 1.000000 0.562702 0.550413 0.592037 0.654441 \n", + "name 0.562702 1.000000 0.798929 0.854352 0.835537 \n", + "cylinders 0.550413 0.798929 1.000000 0.876777 0.895527 \n", + "weight 0.592037 0.854352 0.876777 1.000000 0.941594 \n", + "displacement 0.654441 0.835537 0.895527 0.941594 1.000000 \n", + "horsepower 0.517409 0.832600 0.812487 0.878684 0.879012 \n", + "acceleration 0.292586 0.561621 0.640407 0.550888 0.586090 \n", + "model_year 0.169058 0.591282 0.344348 0.300008 0.334152 \n", + "\n", + " horsepower acceleration model_year \n", + "origin 0.517409 0.292586 0.169058 \n", + "name 0.832600 0.561621 0.591282 \n", + "cylinders 0.812487 0.640407 0.344348 \n", + "weight 0.878684 0.550888 0.300008 \n", + "displacement 0.879012 0.586090 0.334152 \n", + "horsepower 1.000000 0.695982 0.397575 \n", + "acceleration 0.695982 1.000000 0.347110 \n", + "model_year 0.397575 0.347110 1.000000 \n" + ] + } + ], + "source": [ + "# compute correlations between preprocessed predictors\n", + "df_corr = (univariate_selection\n", + " .compute_correlations(basetable[basetable[\"split\"]==\"train\"],\n", + " preprocessed_predictors))\n", + "print(df_corr)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot correlation matrix\n", + "plot_correlation_matrix(df_corr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get a list of the selected predictors after the univariate selection, run the following call:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['weight_enc',\n", + " 'displacement_enc',\n", + " 'horsepower_enc',\n", + " 'cylinders_enc',\n", + " 'origin_enc',\n", + " 'model_year_enc',\n", + " 'name_enc',\n", + " 'acceleration_enc']" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preselected_predictors = univariate_selection.get_preselected_predictors(df_rmse)\n", + "preselected_predictors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After an initial preselection on the predictors, we can start building the model itself using forward feature selection to choose the right set of predictors. Since we use target encoding on all our predictors, we will only consider models with positive coefficients (no sign flip should occur) as this makes the model more interpretable." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modelling" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0f50f7a164524b7fae1b1013b16fae41", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sequentially adding best predictor...: 0%| | 0/8 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
predictorslast_added_predictortrain_performanceselection_performancevalidation_performancemodel_type
0[weight_enc]weight_enc4.2250884.0068564.348181regression
1[weight_enc, model_year_enc]model_year_enc3.0004212.9637713.132604regression
2[weight_enc, model_year_enc, horsepower_enc]horsepower_enc2.9100802.8502273.044059regression
3[weight_enc, model_year_enc, horsepower_enc, o...origin_enc2.8591032.7377702.937309regression
4[origin_enc, weight_enc, model_year_enc, horse...cylinders_enc2.8579952.7133052.934307regression
\n", + "" + ], + "text/plain": [ + " predictors last_added_predictor \\\n", + "0 [weight_enc] weight_enc \n", + "1 [weight_enc, model_year_enc] model_year_enc \n", + "2 [weight_enc, model_year_enc, horsepower_enc] horsepower_enc \n", + "3 [weight_enc, model_year_enc, horsepower_enc, o... origin_enc \n", + "4 [origin_enc, weight_enc, model_year_enc, horse... cylinders_enc \n", + "\n", + " train_performance selection_performance validation_performance \\\n", + "0 4.225088 4.006856 4.348181 \n", + "1 3.000421 2.963771 3.132604 \n", + "2 2.910080 2.850227 3.044059 \n", + "3 2.859103 2.737770 2.937309 \n", + "4 2.857995 2.713305 2.934307 \n", + "\n", + " model_type \n", + "0 regression \n", + "1 regression \n", + "2 regression \n", + "3 regression \n", + "4 regression " + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "forward_selection = ForwardFeatureSelection(model_type=model_type,\n", + " # model_name=\"my-linear-regression\",\n", + " pos_only=True)\n", + "\n", + "# fit the forward feature selection on the train and selection data\n", + "# there are optional parameters to force and/or exclude certain predictors (see docs)\n", + "forward_selection.fit(basetable[basetable[\"split\"]!=\"validation\"],\n", + " target_column_name=target_col,\n", + " predictors=preselected_predictors)\n", + "\n", + "# compute model performance\n", + "performances = (forward_selection\n", + " .compute_model_performances(basetable, target_column_name=target_col))\n", + "performances" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As can be seen, model improvement gradually flattens when more variables are added." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot performance curves\n", + "plot_performance_curves(performances)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# one can also compute using another metric function and plot the according performance curves\n", + "performances_ = (forward_selection\n", + " .compute_model_performances(basetable, target_column_name=target_col, \n", + " metric=metrics.r2_score))\n", + "plot_performance_curves(performances_, metric_name=\"R\\N{SUPERSCRIPT TWO} coefficient\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Based on the performance curves (RMSE per model with a particular number of predictors in case of linear regression), a final model can then be chosen and the variable importance can be plotted." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['weight_enc', 'model_year_enc', 'horsepower_enc', 'origin_enc']" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# pick the optimal step based on visual inspection in the plot above (try to find a knee point in the selection curve)\n", + "model = forward_selection.get_model_from_step(3)\n", + "\n", + "final_predictors = model.predictors\n", + "final_predictors" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'weight_enc': 0.6043307579612891,\n", + " 'model_year_enc': 0.5934134477782865,\n", + " 'horsepower_enc': 0.23995291830303533,\n", + " 'origin_enc': 0.15250622734284758}" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_coef_by_predictor()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "variable_importance = model.compute_variable_importance(\n", + " basetable[basetable[\"split\"]==\"selection\"])\n", + "plot_variable_importance(variable_importance)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note**: variable importance is based on correlation of the predictor with the model predictions (and not the true values!)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, if wanted, we can convert the model to a dictionary to store it as JSON." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'meta': 'linear-regression',\n", + " 'predictors': ['weight_enc',\n", + " 'model_year_enc',\n", + " 'horsepower_enc',\n", + " 'origin_enc'],\n", + " '_eval_metrics_by_split': {'selection': 2.7377702963941544,\n", + " 'train': 2.8591028950870387,\n", + " 'validation': 2.937308715353213},\n", + " 'params': {'copy_X': True,\n", + " 'fit_intercept': True,\n", + " 'n_jobs': None,\n", + " 'normalize': False},\n", + " 'coef_': [0.6043307579612891,\n", + " 0.5934134477782865,\n", + " 0.23995291830303533,\n", + " 0.15250622734284758],\n", + " 'intercept_': -13.89387872773985}" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_dict = model.serialize()\n", + "model_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "if False:\n", + " # to save the model as a JSON file, run the following snippet\n", + " model_path = os.path.join(\"output\", \"model.json\")\n", + " with open(model_path, \"w\") as file:\n", + " json.dump(model_dict, file)\n", + "\n", + " # to reload the model again from a JSON file, run the following snippet\n", + " with open(model_path, \"r\") as file:\n", + " model_dict = json.load(file)\n", + " model = LinearRegressionModel()\n", + " model.deserialize(model_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have build and selected a final model, it is time to evaluate its predictions on the test set against various evaluation metrics. The used evaluation metrics are:\n", + "\n", + "1. Coefficient of Determination (R2)\n", + "2. Mean Absolute Error (MAE)\n", + "3. Mean Squared Error (MSE)\n", + "4. Root Mean Squared Error (RMSE)\n", + "\n", + "Furthermore, plotting makes the evaluation of a linear regression model a lot easier. We will use a **prediction plot**, which presents predictions from the model against actual values and a **Q-Q plot** from the standardized prediction residuals." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "# get numpy array of True target labels and predicted values\n", + "y_true = basetable[basetable[\"split\"]==\"validation\"][target_col].values\n", + "y_pred = model.score_model(basetable[basetable[\"split\"]==\"validation\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "evaluator = RegressionEvaluator()\n", + "evaluator.fit(y_true, y_pred)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "R2 0.849835\n", + "MAE 2.068583\n", + "MSE 8.627782\n", + "RMSE 2.937309\n", + "dtype: float64" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "evaluator.scalar_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "evaluator.plot_predictions()" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "quantiles [-2.128045234184984, -1.8339146358159146, -1.6...\n", + "residuals [-1.8528672099028305, -1.8306478949888074, -1....\n", + "dtype: object" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "evaluator.qq" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtQAAAH2CAYAAABQoRtQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAB2DElEQVR4nO3dd3RU1d7G8e/MZNJDCqTQe5PeOyiCIIoggldRRPRaEEHEhvXaRUWRor5WFL3XqwKC5SpIUelNFJDQa4BQQoD0TGbO+8fAJGMITEiZTPJ81spizj5lfuEk8GRnn71NhmEYiIiIiIjIJTF7uwAREREREV+mQC0iIiIiUgQK1CIiIiIiRaBALSIiIiJSBArUIiIiIiJFoEAtIiIiIlIECtQiIlIojRs3ZsSIEd4uQ0SkzPDzdgEiIuXJ5s2b+c9//sPatWs5fvw4fn5+1KhRgx49enD77bcTHR1dpOsfPXqUTz/9lOXLl5OQkEBOTg4xMTF06NCBESNGcNlllxXTZ1Ky1qxZw2233cb999/P2LFjvV2OiEiRqIdaRKQYGIbB66+/ztChQ/n222+pV68eI0aMYOjQoQQEBPDhhx9y1VVXsXTp0kt+j59++ol+/frx0Ucf4e/vz9ChQxkxYgT169fnu+++Y8iQIUyfPr0YPysREfGEeqhFRIrB22+/zYcffkj16tV57733aNiwodv+BQsW8MgjjzB27Fj+/e9/06pVq0Jdf9WqVUyYMAE/Pz+mTp1K//793fbv3LmTe+65hxkzZhAaGsqoUaOK/DmJiIhnTFp6XESkaBISEujXrx8mk4k5c+bQuHHj8x73xRdf8Oyzz9K0aVPmzZvn8fUdDgdXX301+/bt47nnnuOmm24673Hbt2/nhhtuwGQysWTJEo+Gl4wYMYK1a9eyefNm3n77bb777juOHTtGXFwcgwcP5u6778bf39/tnMaNG9OxY0c+++wzt/aUlBTef/99Fi5cyOHDhwkMDKRly5bceeeddO3a1XXcxIkT+eabb85bz6xZs+jUqdNF6xYRKUs05ENEpIjmzp1LTk4Offr0KTBMAwwbNozo6Gji4+P5448/PL7+2rVr2bdvHzExMQwbNqzA4xo3bsyVV15JdnZ2gYG1IA888ABz5syhd+/e3HrrrZhMJqZPn864cePwpN/lzJkz3HTTTbz//vuEhYUxcuRIrrrqKjZu3Mgdd9zBf//7X9exffr04frrrwegY8eO3H///a6P6tWrF6puEZGyQEM+RESKaMOGDQBuvbDn4+fnR6dOnfj+++9Zt24drVu3LtT1O3bsiMViueCx3bp146effmLdunXcfffdHl0fYM+ePfzwww+Eh4cD8OCDD3LbbbexdOlS5s+fz+DBgy94/uTJk9m1axf/+Mc/eO655zCZTADcdddd3HDDDbz44ot0796dGjVq0KdPH8LCwvjmm2/o2LGjHkoUEZ+nHmoRkSI6fvw4AHFxcRc9tmrVqoBzto7CXv/cuRdyrobExESPrw8wevRoV5gGCAgIYMKECQDMmTPngudmZ2fz7bffEhwczIQJE1xhGqBOnTqMGDECm81WqGEuIiK+RD3UIiJekJWV5Xo9d+5cDh065La/Y8eORRpLnJ2dXajjO3bsmK+tXbt2WCwW4uPjL3ju3r17ycjIoG3btkREROTb37lzZ959992LXkdExFcpUIuIFFGVKlXYvXu3R73CR44cASAqKsrV9s0337B27Vq34+6//35XoK5SpYrbuRdyrobIyEjPij/r3Hvk5efnR2RkJElJSRc8NyUlBaDAhyDPtZ85c6ZQNYmI+AoFahGRImrXrh1r1qxh5cqV3HjjjQUeZ7fbXcG5WbNmrva/z5ZxvuuD8+FEu91+wXHUK1euBKB58+Ye1w9w4sQJqlWr5taWk5NDcnIyoaGhFzw3LCzMdY3zOTdk5dxxIiLljcZQi4gU0ZAhQ/Dz82PRokXs3LmzwOPmzJnDsWPHiIiIoEePHh5fv1OnTtSpU4djx45dcDzzzp07WbRoEQDXXnut558A5OshB+fDkHa7naZNm17w3Lp16xIUFMS2bdvO2wu9Zs0aALdVHM/9UGC32wtVp4hIWaRALSJSRDVr1mT06NHYbDZGjx7Nrl278h2zaNEiXnrpJQAefvhhgoKCPL6+2Wzm2WefxWKx8NJLL/Hzzz/nO2b37t2uGgYOHOjxDCLnvPvuu5w+fdq1nZWVxZtvvgnADTfccMFz/f39GThwIGlpaUydOtVt34EDB/jss8+wWq0MGjTI1X5urLUnw1hERMo6DfkQESkGY8aMIT09nY8++ohBgwbRvXt3GjRoQE5ODhs3buTPP/8E4J///OcF55IuSJcuXXjjjTd4/PHHuf/++2nZsiVt27bFarWya9culi9fjs1mo2PHjq7gXhj16tXjmmuuoX///vj5+bF48WIOHDjA5Zdf7haEC/LQQw+xfv16Pv/8czZv3kynTp1ITk7mxx9/JC0tjaeffpqaNWu6jq9bty6xsbH88MMP+Pn5Ua1aNUwmE4MGDdJc1CLic7RSoohIMdq0aRP/+c9/WLt2LcePH3fNthEdHc1rr7120bmqLyYxMZFPP/2U5cuXk5CQQHp6OuAcQvHEE08wfPhwzGbPf/lY0EqJsbGxXH/99YVaKfHMmTO89957/Pzzz66VElu0aMGdd95J9+7d8733pk2beOONN9iyZQtpaWkYhqGVEkXEJylQi4iUoNTUVIYPH87u3buZOnUqffr0Kfb3ePzxx5k7dy533HEHjz32WKHOPReot2/fXux1iYhUFBpDLSJSgkJDQ3nvvfeIjIxk/Pjx/Pbbb8X+Hs8//zydOnXi448/zjeGWURESp4CtYhICatatSoffvgh99xzD9u3by/0oisXY7VamTFjBmPHjsVisehBPxGRUqYhHyIiFZiGfIiIFF2ZDNR2u50bbriB2NhY3nvvPW+XIyIiIiJSoDI5bd6sWbOoX78+qamp+fZt2LDBCxWJiIiISEV0brXaCylzgToxMZFffvmFe++9l08++eS8x3jyiUnZFB8ff9FV16Ts0v3zXbp3vk33z3fp3vk2Tztyy1ygfvnll3nkkUdIS0sr8Jj4+PhSrEiKU2Zmpu6fD9P98126d75N98936d5VDGUqUC9dupSoqCiaN2/OmjVrCjxOP+n5Lv2k7tt0/3yX7p1v0/3zXbp3vs0ne6h///13lixZwm+//UZWVhapqak8/PDDTJ482duliYiIiIicV5kK1A899BAPPfQQAGvWrOHjjz9WmBYRERGRMk0Lu4iIiIiIFEGZ6qHOq1OnTnTq1MnbZYiIiIiIXJB6qEVEREREikCBWkRERESkCBSoy4iTJ08ybNgwBg8ezPr16wt1bnx8PL/++msJVZYrISGBa6+9tsjHiIiIiJQnCtRlQE5ODqtWraJRo0bMmzeP9u3bF+r80grUIiIiIpJfmX0o0ZckJCTwz3/+k2bNmrF161YaNmzIq6++SlBQEFu2bGHSpEmkp6cTGRnJK6+8QkxMDCNGjKBJkyZs2LCBa6+9llmzZpGZmcmWLVv48ssvWb9+PdOnTyc7O5uaNWvyyiuvEBISwqZNm3j55ZdJT0/H39+fmTNnMm3aNDIzM9mwYQP33HMPAwYMcNU2d+5cFi1aREZGBvv37+eOO+7AZrMxf/58/P39ef/994mIiCA+Pp5//etfZGRkUKtWLV5++WXCw8PZsmULTzzxBADdunVzXddutzN58mTWrl1LdnY2t9xyCzfddFOp/92LiIiIeFv57KFe+Sy8YfLsY+Hd+c9feLf7MSufvehb7t27l+HDh/Pjjz8SEhLCf/7zH2w2Gy+++CLTpk1j7ty53HDDDUyZMsV1js1mY+7cudxxxx2MGzeOAQMGMH/+fNLT03n33XeZOXMm33zzDc2bN2fmzJlkZ2fz4IMP8sQTT/Dtt9/yySefEBQU5HZu3jB9zs6dO5k+fTqzZ89mypQpBAYGMm/ePFq3bs28efMAePTRR3n44Yf57rvvaNSoETNmzADg8ccf5+mnn+bbb791u+bs2bMJCwtjzpw5zJkzh6+++oqDBw96fItEREREygv1UBeTqlWr0q5dOwCuu+46PvvsM3r06MGOHTsYNWoUAA6Hg+joaNc55wu/AH/++Se7du3i5ptvBpzBu3Xr1uzdu5fo6GhatmwJQGhoqEe1derUyXVsWFgYvXv3BqBRo0Zs376dlJQUUlJS6NixIwDXX389DzzwAGfOnCElJYUOHToAMGjQIJYtWwbAihUr2L59OwsWLAAgJSWF/fv3U6dOHc/+wkRERETKCQXqYmIymfJtG4ZBw4YN+fLLL897TlBQ0HnbDcOgW7duvPnmm27t27dvv6Ta/P39Xa/NZjNWq9X12m63X9I1DcPgqaeeokePHm7tCQkJl3Q9EREREV9VPgN112edH5fqqvedH4Vw+PBhNm7cSJs2bfj+++9p164ddevW5eTJk652m83Gvn37aNiw4QWv1bp1a55//nn2799P7dq1SU9P5+jRo9StW5fjx4+zadMmWrZsSWpqKoGBgYSEhJCWlnbJn25YWBiVKlVi/fr1tG/fnvnz59OhQwcqVapEWFiYq/27775zndO9e3e++OILOnfujNVqZe/evcTGxl5yDSIiIiK+qnwGai+oW7cu//73v3niiSdo0KABN998M/7+/kybNo0XX3yRlJQU7HY7I0eOvGigjoqK4pVXXmHChAlkZ2cDMH78eOrWrcuUKVN48cUXyczMJDAwkJkzZ9KpUyfef/99Bg0alO+hRE+9+uqrrocSzz0ECfDKK6/wxBNPYDKZ3B5KHDZsGIcOHWLIkCEYhkFkZCTvvPNOod9XRERExNeZDMMwvF1EYWzYsME1VrmsSEhI4N577+X777/3dillXnx8PE2bNvV2GXKJdP98l+6db9P9812Xcu8MwyAhyU5EiJmwoPI5f4Sv8DR3qodaREREpAz5YUMm89dmEBli5rmbwwnyN138JPEq/dhTDGrUqKHeaRERESmyLJvBTxszAEhOc5Ce5fByReIJBWoRERGRMmLD7myybM7XcRFmokIV1XyB7pKIiIhIGbFyW5brddcmAfmm5ZWySYFaREREpAw4ftrO9sM5AJhM0KVxgJcrEk8pUIuIiIiUASu35/ZON69pJSJEMc1X6E6VE5988gkZGRkl/j4TJ07kp59+KvIxIiIiksthGKzanu3a7tZUvdO+RIHay3Jyci647alZs2aVSqAWERGR4rf9UA5JKc4ZPUICTLSsY/VyRVIYmoe6mMybN4+PPvoIk8lE48aNef3115k4cSKXX345/fv3B6BNmzZs3LiRNWvWMHXqVCpVqsTevXt5/vnn3bb/97//MXnyZNauXUt2dja33HILN910E2vWrGHGjBlERkayY8cOmjVrxuTJk/nss884duwYI0eOJCIigs8++8yttt69e3PNNdfw22+/YbFYeOGFF3jzzTfZv38/d955JzfffDOGYfDaa6+xbNkyTCYTo0ePZsCAARiGwQsvvMCKFSuoWrUqVmvuN/iWLVuYNGkS6enpREZG8sorrxATE1Oqf+8iIiLlwfL43OEenRr5Y7XoYURfUu4C9cI/Mvh2XYZrypniEGCF6zoEcVXroPPu37lzJ++++y5ffPEFUVFRnDp16qLX3Lp1K9999x01a9ZkzZo1bttffvklYWFhzJkzh+zsbG666SbXst9bt27lhx9+ICYmhptvvpkNGzZw22238cknn/Dpp58SFRV13verWrUq8+fP5+WXX2bixIl88cUXZGdnc+2113LzzTezcOFCtm3bxvz580lOTmbo0KG0b9+eP/74wxXyT5w4wTXXXMMNN9yAzWbjxRdf5J133iEqKor//e9/TJkyxbVkuYiIiHgmPcvBxj0a7uHLymGgzizWMA2QZXNet6BAvXr1avr37+8KsxERERe9ZosWLahZs+Z5t1esWMH27dtZsGABACkpKezfvx+r1UrLli2Ji4sDoEmTJhw6dIj27dtf9P2uvPJKABo1akR6ejqhoaEA+Pv7c+bMGTZs2MA111yDxWKhSpUqdOjQgc2bN7Nu3TpXe2xsLJ07dwZg79697Nixg1GjRgHgcDiIjo6+aB0iIiLibt2ubGx25+uaVSzUqlLu4lm5V+7u2FWtA0ukh/qq1oGFPs9iseBwOMdDORwObLbcooKDg92OzbttGAZPPfUUPXr0cDtmzZo1+Pv7u13fbrd7VMu5oRpms9ntGmaz+ZLGbRuGQcOGDfnyyy8Lfa6IiIjkWpFn7uluTdQ77YvKYaAueGhGSencuTP3338/t99+O5GRkZw6dYqIiAiqV6/OX3/9xYABA1iyZIlboL6Q7t2788UXX9C5c2esVit79+4lNjb2gueEhISQlpZW4JCPi2nfvj1ffvkl119/PadPn2b9+vU8+uij2O12V3tSUhJr1qzh2muvpW7dupw8eZKNGzfSpk0bbDYb+/bto2HDhpf0/iIiIhXRkZN29h51do5ZzNCxof9FzpCyqNwFam9o2LAh9957LyNGjMBsNnPZZZcxadIkbrzxRu677z6uu+46evToka9XuiDDhg3j0KFDDBkyBMMwiIyM5J133rngOTfeeCP//Oc/iYmJyfdQoif69u3Lxo0bGTRoECaTiUceeYTo6Gj69u3L6tWrGTBgANWqVaN169aAc6jItGnTePHFF0lJScFutzNy5EgFahERkULI2zvdqo6VsCBNwOaLTIZhGN4uojA2bNhAu3btvF2GXKL4+HiaNm3q7TLkEun++S7dO9+m++e7LnTv7A6Dx2ad4nS6M4qNHRBKyzrqoS5LPM2d+jFIRERExAu2HLC5wnR4sIlmtTT3tK9SoBYRERHxgpV5hnt0bhyAxay5p32VArWIiIhIKUvJcPDnvtzJCjS7h29ToBYREREpZWt2ZGN3zqxLvVgLVSMt3i1IikSBWkRERKQUGYbhPve0Vkb0eQrUIiIiIqXowAk7CUnOuaf9/aBDAwVqX6dALSIiIlKK8vZOt63nT5C/Hkb0dQrUIiIiIqXEZjdYuyPbtd1VDyOWCwrUIiIiIqXkz7020rKcc09XDjPTuLoWrS4PFKhFRERESkne4R5dG/tjNmm4R3mgQC0iIiJSCpJTHfx1MHfu6S4a7lFuKFCLiIiIlILVO7IwnKM9aFzdj+hKmnu6vFCgFhERESlh+eaeVu90uaJALSIiIlLCdifmcPSUc2nEQKtzujwpPxSoRURERErYym25U+V1aBhAgFUPI5YnCtQiIiIiJSjLZrB2V97hHuqdLm8UqEVERERK0Ibd2WSdndwjLsJMvVjNPV3eKFCLiIiIlKCVeeeebhKASXNPlzsK1CIiIiIl5FSGhe2HcwAwmaBLY83uUR4pUIuIiIiUkK2Jga7XzWtaiQhR9CqPdFdFRERESoDDMNiaGOTa7tZUvdPllQK1iIiISAnYfiiHM5nO1RBDAky0rGP1ckVSUhSoRURERErAivjchxE7NfLHatHDiOWVArWIiIhIMUvPcvD7ntzFXLTUePmmQC0iIiJSzNbvysZmd76uUdlCrWjNPV2eKVCLiIiIFLMVeeae7q6HEcs9BWoRERGRYnTkpJ09R53d02aTQceGWmq8vFOgFhERESlGeXun61fJIixIcau80x0WERERKSZ2h8HqHbmBullchherkdKiQC0iIiJSTLYcsHE63QAgPNhEnajsi5wh5YECtYiIiEgxWZlnuEfnxgGYlbQqBN1mERERkWKQkuHgz30217bmnq44ytSkiFlZWdxyyy1kZ2djt9vp168f48aN83ZZIiIiIhe1Zkc2dofzdb1YC1UjLZxK9G5NUjrKVKD29/fn008/JSQkBJvNxvDhw+nZsyetW7f2dmkiIiIiF5R3dg/1TlcsZWrIh8lkIiQkBICcnBxycnIwmbTuvYiIiJRtB47nkJDknHva3w/aN9Dc0xVJmeqhBrDb7QwZMoQDBw4wfPhwWrVqle+Y+Ph4L1QmxSEzM1P3z4fp/vku3TvfpvtX9i3ZEQYEA1C/cgb79xwFdO8qijIXqC0WC/Pnz+fMmTOMGTOGHTt20KhRI7djmjZt6qXqpKji4+N1/3yY7p/v0r3zbbp/ZZvNbvDeylOAc7q8qzvF0LRGdUD3ztdt2LDBo+PK1JCPvCpVqkSnTp1YtmyZt0sRERERKdCfe22kZTnDdOUwM42rl7n+SilhZSpQnzx5kjNnzgDOX5GsXLmSevXqebkqERERkYLlfRixa2N/zHr+q8IpUz9CHTt2jIkTJ2K32zEMg/79+3PFFVd4uywRERGR80pOdfDXwdy5p7todo8KqUwF6iZNmjBv3jxvlyEiIiLikdU7sjCcoz1oXN2P6EoW7xYkXlGmhnyIiIiI+ArDMDT3tAAK1CIiIiKXZHdiDkdPOZdGDLRC23qae7qiUqAWERERuQQrt2W7XndoEECAVQ8jVlQK1CIiIiKFlGUzWLcrz+weTdQ7XZEpUIuIiIgU0u97ssk8O7lHXISZ+nFlap4HKWUK1CIiIiKF5Db3dJMATJp7ukJToBYREREphONn7Gw/lAOAyQRdGmt2j4pOgVpERESkEFbm6Z1uXtNKRIjiVEWnrwARERERDzkMg1Xbc2f36NZUvdOiQC0iIiLise2HckhKcc49HRJgomUdq5crkrJAgVpERETEQyvic4d7dGrkj9WihxFFgVpERETEI+lZDn7fk2e4h5Yal7MUqEVEREQ8sH5XNja783WNyhZqRWvuaXFSoBYRERHxQN65p9U7LXkpUIuIiIhcxJGTdvYcdXZPW8zO8dMi5yhQi4iIiFzEiu25vdOt6lgJC1KEklz6ahARERG5ALvDYPV2DfeQgilQi4iIiFzAXwdsnE43AAgPNtGsluaeFncK1CIiIiIXkPdhxM6NA7CYNfe0uFOgFhERESlASoaDP/fZXNsa7iHno0AtIiIiUoA1O7KxO1cap16shaqRFu8WJGWSArWIiIhIATT3tHhCgVpERETkPA4czyEhyTn3tL8ftG+guafl/BSoRURERM4jb+90m7r+BAcoNsn56StDRERE5G9sdoM1O7Jd292aariHFEyBWkRERORvNu2zkZblnHu6cpiZxtX9vFyRlGUK1CIiIiJ/syI+d7hH18b+mE2ae1oKpkAtIiIiksepNAdbDubOPd1Fs3vIRShQi4iIiOSxansWhnO0B42r+xFdSXNPy4UpUIuIiIicZRiG5p6WQlOgFhERETlr55Ecjp5yLo0YaIW29TT3tFycHlkVERERAbYcyOaDn9Nc2x0aBBBg1cOIcnEK1CIiIlKhGYbBj79nMm9NBmeHTmO1QJ9WgV6tS3yHArWIiIhUWJnZBjOXpPL7ntxZPSJDzIzuH0q1KD2MKJ5RoBYREZEK6egpO2//mMqRZLurrVE1P+65KpRKwXrMTDynQC0iIiIVzp/7svloURoZ2Yar7cqWAQztEoyfReOmpXAUqEVERKTCcBgGP6zP5Nt1Ga42qwVuuzyEzo01RZ5cGgVqERERqRDSsxx8vDiNP/fljpeuHOYcL107WpFILp2+ekRERKTcO3LSzjs/pZB4do5pgKY1/LirbyhhQRovLUWjQC0iIiLl2u97svl4cSpZuR3TXNU6kCGdg7CYNV5aik6BWkRERMolh8Pg23UZ/LAh09Xm7wcjrwihY0ONl5bio0AtIiIi5U5apoMPF6Wx5UBut3R0JTP39Q+lRhXFHyle+ooSERGRcuVQUg5v/5jK8TO546Wb1bRyV98QQgI1XlqKnwK1iIiIlBvrd2XzyZJUsnJy265uG8jgjkGYNV5aSogCtYiIiPg8h8Ng7poMFmzMHS8d4AejrgylXX1/L1YmFYECtYiIiPi01EwHHyxMZWtCbrd0TLiZ+64OpXqUoo6UPH2ViYiIiM86cCKHd35MJSkld7x0i9pW/tknhOAAjZeW0qFALSIiIj7HYRj89lcWX69MJzvPeOlr2wcysEMQZpPGS0vpUaAWERERn3L8jJ1Pl6ax/VBukg60wp19QmldV+OlpfQpUIuIiIhPcBgGv27JYs6qdLdZPKpGWhjdP5SqkRbvFScVmgK1iIiIlHnHTjt7pXcczk3SJhP0b+0c4mH10xAP8R4FahERESmzHIbBkk1ZfLPGfax0tSgLt18RQt1YRRnxPn0VioiISJl09JSdT5amsetIbpI2m6B/20CubR+E1aJeaSkbFKhFRESkTHE4DBZvzuKb1enY7Lnt1aMsjOodQu2YchhfbGmACazB3q5ELkE5/IoUERERX5WYbOeTJWnsPprbK20xO5cPv6ZdEH7lrVfaMGDXN7B0PFw2Arq/5O2K5BIoUIuIiIjXORwGP/+Zyby1GeTk6ZWuUdnCqCtDqFWlHEaW5J2wZCzsW+DcXvc6XHYbRDX2bl1SaOXwq1NERER8yZGTdmYuTWXv0dwkbTHDNe2CuLptYPnrlbZlwNpXYN2rYM/ObQ+IgDP7Fah9kAK1iIiIeIXDYbDgj0y+XefeK10r2sKoK0KoUR57pXd/D0vHwem9eRpN0Ope53CPwEivlSaXrhx+pYqIiIgvmL8ug/9tyHRtW8wwsH0Q/dqUw17p0/tg6QOw+1v39riO0OcdiG3nlbKkeHgUqHNycnA4HPj75y7nuXz5cnbt2kWHDh1o1qxZsRRz5MgRHn30UZKSkjCZTNx4442MHDmyWK4tIiIiZcufe22u17WjnTN4VK9cDvv6EtfBl70gJyO3LTASekyCFv8Ek9l7tUmx8Oir9sEHHyQ0NJRXXnkFgFmzZvHyyy/j7++Pw+Fg+vTpXHHFFUUuxmKxMHHiRJo1a0Zqaio33HAD3bp1o0GDBkW+toiIiJQdOXaDxFO54zwmXBdGcEA5DZYxbSCyERz/07nd/E5nmA6u4t26pNh49JX7xx9/0KtXL9f2Rx99xKhRo9i0aRNDhw7l//7v/4qlmJiYGFdvd2hoKPXq1ePo0aPFcm0REREpOxJP2bE7nK8rh5nLV5g2DPdtsx/0eRdi2sLNq6DfhwrT5YxHPdSnTp2iShXnjd++fTvHjh3j5ptvBqB///589913xV5YQkIC8fHxtGrVKt+++Pj4Yn8/KR2ZmZm6fz5M98936d75tvJ4/+ITA4FwACIC0omPP+LdgoqDw0bUvlmEnFjNwQ7vgcmc595FQLvP4LQJTpeveykeBuoqVapw6NAh2rdvz7Jly6hWrRq1atUCICsrC7O5eH+qTEtLY9y4cTzxxBOEhobm29+0adNifT8pPfHx8bp/Pkz3z3fp3vm28nj//jqVDjgfSGxSO4KmTat5t6CiOvgLLB4DSVsBaGpfAy3uKJf3riLZsGGDR8d5FKj79+/P5MmT2bZtG3PnzuXWW2917du6dSu1a9e+tCrPw2azMW7cOAYOHMhVV11VbNcVERGRsuNQUu746Rq+/CBi6hH49WHY9h/39vjPoPko79Qkpc6jr+CHHnqIkJAQtmzZws0338w999zj2vfXX38xYMCAYinGMAyefPJJ6tWrx6hR+iIUEREprxKScpcWr1HZ4sVKLpEjB/54G1Y8A9lnctutodD1OWgzFkzlbOo/KZBHgdrPz4/777//vPtmzJhRbMVs2LCB+fPn06hRIwYNGgTAhAkT3B6IFBEREd+WkuHgVJrzwT2rBWLCfeyBxEMrYPF9cHyTe3vjf0CvNyCsunfqEq8pU79jad++Pdu3b/d2GSIiIlKCDp3MHe5RLcqC2ewjPbmGAT/fDZs/dG+PbAxXzoDafbxTl3hdgYG6c+fOmArxq4pVq1YVS0EiIiJSviWcyDt+2oeGe5hM4BeUu+0XBJ2fhnYTwC/Ae3WJ1xUYqG+55ZZCBWoRERERT7iPny5Tvyy/uG4vwPavoFpXuGIKVCq+iRnEdxX4VTx27NjSrENEREQqiIQ8M3xUL6s91BlJsOo56PQEhMTltgeEw21/Qkis92qTMsfHfiwUERERX+ZwGBw+WYaHfBgO2DITfnsMMpMg8yQM+Nz9GIVp+RuPA/XGjRuZPXs2+/btIysrK9/+2bNnF2thIiIiUv4cO+3AdjZPhwebCAsqQzN8HPsDFt0HR/I8Fxb/b2j/CMTkX7lZ5ByPvopXrFjBrbfeSmJiIhs2bCAqKorg4GC2bdvGqVOnaNiwYUnXKSIiIuVAQllc0CXzFCwZB5+3cw/TlWrDoHkQ3dJblYmP8ChQT5s2jdtuu433338fgAceeIBZs2axYMEC/Pz86NSpU4kWKSIiIuVDmVrQxTBg62cwswlsnO4c7gFgtjrHTt++FRoM0gItclEeBepdu3bRs2dPzGYzJpOJjIwMAKpXr87YsWN59913S7RIERERKR/ce6i9GKhP/AVfXQ4/3gbpR3Pba/eFkVug+0tgDfZaeeJbPArUAQEBOBwOTCYT0dHRHDhwwLUvNDSUo0ePXuBsEREREacyE6iTd0LCb7nbodXh2q/ghgUQ1ch7dYlP8mjwUpMmTdi7dy/dunWjS5cuvPfee8TGxmK1Wpk6dSqNGukLT0RERC4sI9sgKcU5rMJihrhILwbqBoOg7gDYvxDajocuz4B/mPfqEZ/mUaAeOXIkCQkJAEyYMIF7772XO++8E4C4uDhmzJhRchWKiIhIuXAoz/jpuAgLfpZSGpt8crtz+rtqXXLbTCa48m2wpUGVZqVTh5RbHgXqXr16uV7HxsYyd+5c9u/fT2ZmJvXq1cPf37/EChQREZHyodSHe9jSYPVLsH4yhNV0jo225lk6PLxOydcgFcIlzVdjMpmoU6dOMZciIiIi5dmhvIG6SgkGasOAXfNh6QOQcva5r9N7YN2r0PXZkntfqbA8CtSvvfbaRY959NFHi1yMiIiIlF+l0kN9ajcsGQt7f3Rvr9oFGgwumfeUCs+jQP3TTz/laztz5gypqamEhYVRqVIlBWoREREpkGEYf5uDupgXdbFlOHug104Ce54VnYOqQM/XoNlIMJWhVRmlXPHoq3nJkiXnbf/zzz95+umnee6554q1KBERESlfklIcZNqcr0MDTYQHF+MDiXt+cK50eHpPnkYTtLoHur0EQVHF914i51GkH9VatWrFnXfeyQsvvFBc9YiIiEg5lHe4R/XKFkzFtfpgRhJ8f5N7mI5tD7esgT7vKkxLqSjy7z4iIiLYu3dvcdQiIiIi5VSJjZ8Oqpz7oGFgJPT5Pxi+GuI6FN97iFyER0M+zi01npfNZmP37t1MmzaNBg0aFHthIiIiUn64B+oijJ8+tRsi6ru3tRkHWaecfwZHX/q1RS6RR1/Rbdq0Oe+vZgzDIDY2lrfffrvYCxMREZHyI++iLtWjLqGHOiUBfpkAu76BERuhSvPcfRYrdNPwU/EejwL1yy+/nC9QBwQEEBsbS8uWLbFarSVSnIiIiPi+LJvB0dPOJcdNQLXCBGq7DX6fCquedS7UArB4DNz4i3O1Q5EywKNAPWTIkJKuQ0RERMqpI8l2DMP5OibCTIDVwyB88FdneE76y709rBbkZIA1uHgLFblExTwJpIiIiIi7Qj+QmJYIvz4C8Z+7t1duBle+DTV7FXOFIkVTYKBu0qRJoaa0iY+PL5aCREREpHzxeEEXRw788Q6seBqyz+S2W0Ogy7PQ9gHneGmRMqbAr+qnnnrKFahtNhszZ84kODiYK6+8ksqVK3PixAkWL15MRkYGo0aNKrWCRURExLd43EO98C746xP3tkY3wuVvQFiNkilOpBgUGKhvvfVW1+tXXnmFVq1aMXXqVLde64cffpgHHniAhISEkq1SREREfJJhGBz626IuBWo9Bv76FDAgshH0ngF1+pZ8kSJF5NHCLvPmzWPYsGH5hoCYTCaGDRvGd999VyLFiYiIiG87nW6Qmul8IjHQCpXDzkYPh935kVdce2j3IHR/CW7bpDAtPsOjQO1wONi9e/d59+3atQuHw1GsRYmIiEj5kHf8dPXKfphNJkhcD190gc0f5D/h8jeg0xPgF1CKVYoUjUezfAwcOJApU6Zgt9vp3bs3lStXJikpicWLFzNt2jSGDh1a0nWKiIiID8o73KNGeA4sGg1/vgcYcGoXNLxBqxuKz/MoUE+cOBE/Pz+mTZvG5MmTXe3+/v784x//4JFHHimxAkVERMR3uT2QuP1ZyPi/3J22dDi8EhoMKv3CRIqRR4Ha39+fJ554gvvuu48dO3Zw4sQJqlSpQqNGjYiIiCjhEkVERMRXJRxNBfwBqJG1JndH3auh93SIqO+dwkSKUaEWdomIiKBjx44lVYuIiIiUF1mnyVn+LEdOPeZcbxyo5oh3rnJ4xVRnr7SWDpdyosBA/euvv9KuXTtCQ0P59ddfL3qhXr20apGIiIgARzfA3GtIzIjCHvg0AJWNAwR3vB86P+lcqEWkHCkwUN9zzz189dVXtGzZknvuuQeTyYRhGOc91mQyaaVEERERcYpsDGY/EszNXE01qsdCj5e9WJRIySkwUC9evJjo6GjXaxERERGP+IfC5VNIWLIfzvbF1aga7t2aREpQgYG6evXq530tIiIiAoBhwI7ZcGg59J7qvq/RUA5tPwUJzkR9wRUSRXycRw8l7t69m5SUFFq3bg1AZmYm77zzDrt27aJLly6MGDGiJGsUERGRsubkDlhyP+z/2bld7xqoc1XufpOJhOTczRqVCzUPgohP8WilxGeffZalS5e6tl977TVmzZpFVlYWkydP5sMPPyyxAkVERKQMsaXD8qdgVovcMA2w+kW3w1IyHJxKc/ZOWy0QE+5R5BDxSR59de/cudPVO22z2Zg/fz5PPPEEH330EQ8++CBz5swpyRpFRETE2wwDds2HTy6DNS+BPdvZbjJDm7Ew+Fu3ww+dzF3QpVqUBYtZU+RJ+eXR718yMjIIDQ0F4M8//yQjI4O+ffsC0KxZMw4fPlxyFYqIiIh3ndoDS8fBnh/c26t2hivfgdg2+U5JOJFnhUSNn5ZyzqMe6ho1avDHH38A8PPPP9O0aVMiIyMBSE5OJiRE80mKiIiUO4YDVj0PnzZzD9OBleGqD+HmFecN0wAJSTmu1xo/LeWdR1/ht99+O8899xw//fQT8fHxvPxy7jySa9eupXHjxiVWoIiIiHiJyQzH/oCczHMN0PJu6P4SBFW+4KkJSbk91JrhQ8o7jwL1sGHDqFOnDps3b+bhhx+mS5curn3h4eGMHDmyxAoUERERL7riLdj3E1S+zDm8o2rHi57icBgcSdaQD6k4PP4dTIcOHejQoUO+9rFjxxZrQSIiIuIF9mz4811o8U/3pcEr1YKbVkB0SzB7FoyPnXGQfXbER3iwibAgzfAh5ZvHX+FJSUm8/vrrjBw5kn79+rFz504APv30UzZu3FhiBYqIiEgJO7AEZrWCpePzTX8HOMdJeximAQ4l5e2d1vhpKf88CtSbNm2ib9++LFy4kOrVq3PgwAGys53T5Rw/fpyZM2eWaJEiIiJSAlIOwfc3w9dXwsltzrb1bzgXbSkC9wcSNdxDyj+PAvXLL79M586dWbBgAc8//zyGYbj2tWzZkk2bNpVYgSIiIlLM7DZY/ybMbALb/5vb7h8GvV6HiHpFunxCksZPS8Xi0e9htm7dyjvvvIPZbHYL0wAREREkJSWVSHEiIiJSzBKWweL74MQW9/Ymw6HXZAitWvS3UKCWCsajQB0WFsbJkyfPu+/gwYNUqVKlWIsSERGRYpZ2FH57FLbOcm+PagpXvg21riiWt8nINjhxxgGAxQxxkQrUUv55NOSjd+/eTJ8+nYMHD7raTCYTJ0+e5OOPP3atmigiIiJl1M457mHaGgI9X4Pb/ii2MA1wKM/46bgIC34WLTku5Z9Hgfrhhx8mNDSUAQMGcMsttwDwr3/9i6uvvpqAgADGjRtXokWKiIhIEbW8B2LOrmrYaCjcHg8dHgGLf7G+jYZ7SEXk0ZCP8PBwvvzyS+bPn8/q1asJDg4mPDycYcOGMXjwYPz9i/ebUURERIog/QRknYLIBrltZgv0fR8yT0Kdq0rsrQ9phUSpgC4aqLOyshg9ejT33HMPw4YNY9iwYaVRl4iIiBSW4YDNH8KyxyGyIdy80rl8+Dlx7Uu8BPVQS0V00SEfAQEBbN68GYfDURr1iIiIyKU4ugH+0wV+vsfZC31kDWz+uFRLMAzjb3NQa1EXqRg8fihx0aJFJV2LiIiIFFZmMiwaA593gMS1ue3hdaFSzVItJSnFQabN+TokwEREiB5IlIrBox8du3fvzmuvvcbx48fp2bMnVapUwWRy/ybp1atXiRQoIiIi52EYzlk7fn0EMo7ntlv8ocNj0PFxsAaVakl/H+7x96wgUl55FKgfeeQRABYuXMjChQvz7TeZTMTHxxdvZSIiInJ+xzfB4jFwaLl7e53+0Hu6+8OIpUjjp6Wi8ihQL168uKTrEBEREU+kHYV/dwR7Vm5bWE244i1ocD14sVc4wW2GD42florDo6/26tWrl3QdLo8//ji//PILlStX5vvvvy+19xUREfEJIbHQ6l74fSqY/aDdQ9DlaedCLV52yO2BRPVQS8Xh0UOJpWnIkCF8+OGH3i5DRESkbMhOzd/W9TlodCPctgl6TioTYTo7x+DoaeeMYCagWpQCtVQcZS5Qd+jQgfDwcG+XISIi4l3ZqfDbY/BBHfwyj7vvCwiHgV9C5abeqe08jpy0YxjO1zERZgKseiBRKg6fHOCkByB9V2Zmpu6fD9P98126dz7EMAhL/JnY+ElYMxMBqPzXJOIDo71c2IVtORIIODvEKlnTiY8/4t2Cygh971UMPhmomzYtOz+RS+HEx8fr/vkw3T/fpXvnI5J3wuL7Yb/7jFqB2Udp2qBOqU+DVxibktIA54OSl9WNpGnTat4tqIzQ955v27Bhg0fH+WSgFhERKVds6bD2FVj3Gtizc9uDoqHX6+w3daBpGQvT2TkGh0/aOXjCzqGkHNbvzq1bDyRKRVNgoJ43b16hLjR48OAiliIiIlIB7f4OloyDM/ty20xmaDUaur0IgRHgxSEDhmGQnGaQcCKHhCQ7CUl2Dp7I4ehph2vM9N9VV6CWCqbAQD1x4kS37XOrHRl5vnvyroBUXIF6woQJrF27luTkZHr27MnYsWMZNmxYsVxbRESkTFk0Bv58x72taie48h2Ibeudms46lJTDj79nsuWAjbSsApLzeXRu5E90JQVqqVgKDNS///676/WePXsYP348Q4cOpW/fvlSuXJmkpCQWLlzInDlzeOutt4qtoDfffLPYriUiIlKm1emXG6gDK0OPSdDiDmcPtZfsP57DD+sz2LjXdsHjTDhn86hR2UKNyn7UrGKhRmULlcMUpqXiKTBQBwcHu16/+uqrDB8+nDvuuMPVFhERwejRowkICGDSpEl8/vnnJVupiIhIeVN/INQbCCFx0OMVCKrstVJ2J+bww4YMNu/PH6SD/E1Ur2yhZmULNao4A3T1KIumxhM5y6OHEjdt2sTdd9993n0NGzZk6tSpxVqUiIhIuXLmIPzyIDS7Hepfm9tuMsGguc4VD71kx2Eb36/PID4hJ9++1nWtDGgbRJ0Yi9swTxFx59F3cFxcHHPnzqVHjx759s2ePZu4uLhiL0xERMTn2bNhwxRY9TzkpMOx36HWle7T33khTBuGQXyCs0d6x2H3IG0C2tb359p2gdSoosnARDzh0XfKhAkTmDBhAtdeey29e/cmKiqKkydPsmTJEvbs2cOUKVNKuk4RERHfcmApLB4DJ/PM0HF6L+z7ERoOKfa3y84x2HUkh/gEG0dP2bHZnW22HMP1OidPW9bfOqRNJujU0J8BbYOoqmXDRQrFo0Ddr18/vvrqK95//32+//57Tpw4QZUqVWjRogWTJk2iefPmJV2niIiIb0g9DL8+DNu+cG+v0sI5e0eN7sXyNg6Hwf7jduITbMQn2NiVmEOOvfDXsZidM3MMaBdETLiCtMil8Ph3Oc2aNdNYaRERkYI4cmDjdFj5L8hOyW33D4Ouz0GbsUUe3mGzG6zens2WA9lsO5RDeiGms/s7fz/o0jiA/m0CqaJp7kSKpFDf2adPn2bnzp0cOXKEnj17Eh4eTlZWFlarFbPZe1P8iIiIeNWJLfDDcDix2b29yc3QazKEFn0Z7i0HsvliWTrHTjsKPCYuwkzTmlbqx/kRZDVh9TPh7wdWS/7XAX5gNutBQ5Hi4FGgttvtvPHGG/znP/8hMzMTk8nE7NmzCQ8PZ+zYsTRv3pxx48aVdK0iIiJlU0Ckc3z0OVFN4Mq3oVbvIl/6+Bk78zeHs/tEar594cEmmtawuj4iQ9W5JeINHgXqN998k6+//pqnn36aTp060adPH9e+K6+8kv/+978K1CIiUnGFVXcO61jxNHR5Bto9CBb/Il0yO8fgp98z+HFjJjn2QFd7kL+J/m0CaV3Xn6qRZk1nJ1IGeBSo58+fz0MPPcQNN9yA3e7+xEOtWrU4ePBgiRQnIiJS5hxZC4lroc397u1txkKjYVCpZpEubxgGf+y18eWKdJJS3Id3dGviz5DOwVQKVk+0SFniUaA+c+YMtWrVOu++7OzsfCFbRESk3MlIgmWPw+YPnUuD1+gF0S1y91usRQ7TSSl2Pv81nS0H3FcrjA2zMapvZerHaV5okbLIo+/Mhg0bsnjxYrp27Zpv37Jly2jWrFmxFyYiIlImGA7Y/DEsmwiZSWfb7PDrQzB0YbG8hcMw+GVLFnNXpbvNDx0SYGJI5yAqm/ZSPy62WN5LRIqfR4F69OjRjBs3jszMTPr374/JZCI+Pp6ff/6Z//73v7z77rslXaeIiEjpO7oRFt8HR1a7t9e7Fq4onqlkE5PtfLo0jV2JuUnaBPRsFsDgTkGEBpqJjy/4fBHxPo8CdZ8+fZg8eTKTJ09mzpw5ADz11FPExsby2muvnXdJchEREZ+Vecr5gOGf7zh7qM+pVBuumAYNrivyW+TYDX7+M5Nv12W4LchSNdLCyCtCNLxDxId4/N06YMAABgwYwN69e0lOTiY8PJx69erp6WIRESk/DAO2fga/PQLpx3LbLf7Q4VHo+DhYgy/58g7DIC3T4EiynS+Xp3PgRG6Stpjh6raBDGgXhNWi/1tFfIlHgXrdunXExcVRs2ZN6tatS926dV37UlNTiY+Pp0OHDiVWpIiISOkw4I+33cN07aug93SIauT5VQyD9buy+WOfjZQMB2fSDVIyHKRmGjjOs7hh7Whnr3TNKuqVFvFFHn3njhgxgsDAQJ577jkGDRrktm/37t3cdtttxGuAl4iI+DqTGfq8A593cK5ueMVb0PAGKORvY79dl8H36zMvepzVAoM6BtGnVSAWrVoo4rM8/lG4V69eTJw4kc2bN/P4449jsVhKsi4REZGSZRiw5weoezWY8/yfFtsOrpsLtfuAf2ihL7t0S+YFw3RwgImwIBM1K/sxqFMQcRH6/1TE13kcqO+8804GDx7Mo48+Snx8PNOmTaNy5colWZuIiEjJSNoGS8bAgSXOJcJb3+e+v+HgS7rsul1ZfPFbumv7spp+XNUqiLBgE2GBZsKCTPhpfLRIuVOopZauuOIKvvrqK5KTkxk8eDAbN24sqbpERESKny3NuTjLrJbOMA2w/En3MdOXKD7BxkeL0jg3RLpurIX7+ofRrJaVWlX8iAw1K0yLlFOFXru0bt26fP3117Rq1YrbbruNr7/+uiTqEhERKT6GATu/gZmXwdpJ4Di7EqHJAs1uB0tgkS6//3gOb/+Ygv3sDHtxEWbGXRNGgFUBWqQiuKTHiUNCQpgxYwZvv/02M2bMKO6aREREik/yLlg6Dvb+6N5erStc+Q7EtCrS5Y+dtjP1+xSyzmb0yBAz4weGERpY6D4rEfFRHgXqxYsXEx0dna99zJgxdOrUiYMHDxZ7YSIiIkViy3D2Rq97FexZue1B0dDzNWh2m3NWjyI4lJTDjB9TSclwDvQIDjDxwMBQKofpQUORisSjQF29evUC97Vv35727dsXW0EiIiLFYsObsPr5PA0maDUaur8IgZGXfNljp+2s25nNul3ZHDqZuzCLvx+MHRBK9SjNJS1S0RT4Xf/aa69x2223ERcXx2uvvXbBi5hMJh555JFiL05EROSStX0A/vw/SE2AuA7O4R1xF+4AOpliZ89ROznnVl8xcD1keCrNwYbd2ew/bs93ntkE91wVSoOq1mL+JETEFxQYqH/66Seuu+464uLi+Omnny54EQVqERHxqpwssKVCUJ7pXP1DnVPipSdCi3+ed3iHwzDYd8zOn/uy2bTPRkJS/rB8IVYLtKxjpU/LQIVpkQqswEC9ZMmS874WEREpU/YthCX3Q5WWcN1s930Nrst3uGEY7Dmaw7KtWWzab3ONf/aUxQzNa1np0MCfVnX8CfTXTB4iFZ0GeomIiG86cxB+eRB2znFuJ++EfQugTr/zHm7LMVi7K5ulmzPPO2wDnGG5UTU/woJye7PPxWU/CzSsZqVNXSvBAZrBQ0RyFRio582bV6gLDR48uIiliIiIeMCeDb9PhVXPORdqOce/EmQk5Tv8ZKqDXzZnsiw+i9TM/L3RYUEmWtS20qq2P5fVtKrHWUQKrcBAPXHiRLdtk8n5D4xhGPnaQIFaRERKwcFfYNF9cDLevf2yEdDzdQiJdWvesDubjxenkp3jfrjVAh0b+tPjsgDqxvphNilEi8ilKzBQ//77767Xe/bsYfz48QwdOpS+fftSuXJlkpKSWLhwIXPmzOGtt94qjVpFRKSiSj0Cvz4M2/7j3l65GfR5B2r0dGt2GAbfrcvg+/WZ7oeHmbm8eQDdmwZo4RURKTYFBurg4GDX61dffZXhw4dzxx13uNoiIiIYPXo0AQEBTJo0ic8//7xkKxURkYopJQE+aQbZZ3LbrKHQ9TloMxYs7rNrZNoMPl6Uysa9NldbdCUzw7oG06qOFbNZvdEiUrw8+vF806ZNNGzY8Lz7GjZsyObNm4u1KBEREZewGlC7T+5243/AqG3QfkK+MH38jJ1Jc864hemmNfx4cmgl2tTzV5gWkRLh0SwfcXFxzJ07lx49euTbN3v2bOLi4oq9MBERqaAMR/45oy+fAqf3OZcMr33leU87cCKHKd+muD142KdlAEO7BmNRkBaREuRRoJ4wYQITJkzg2muvpXfv3kRFRXHy5EmWLFnCnj17mDJlSknXKSIi5Z3DDpveh03vwc0rwBqSu69SLbh1PVzg4cH//JbuCtN+Zri1VwjdmgaUdNUiIp4F6n79+vH111/z3nvv8f3333PixAmqVKlCixYtmDRpEs2bNy/pOkVEpDxLXOecvePoeuf2qheg5yT3Yy4Qpo+ctLM70TmVh8UMDw0K08qFIlJqLhqos7Oz+emnn2jZsiVTp04tjZpERKSiyDgJy59w9kyTZ47o3d9Ct+fB4u/RZZZvy3K9blXHqjAtIqXqog8l+vv789RTT3Hs2LHSqEdERCoCwwGbP4aZjZ1DPM6FaUsAdHkWRvzucZjOsRus2p4bqLs10TAPESldHg35aNSoEfv27aNjx44lXY+IiJR3RzfC4jFwZJV7e90B0HsaRNQv1OW2HLCRkuEM5BEhJprVUu+0iJQujwL1448/zuOPP050dDQ9evTAz8+j00RERNwtfwrWvuLsoT6nUm24YirUv+6C46QLvGR8bu90l8YBmtFDREqdR8l4zJgxZGZmct9992EymahUqZLbsuMAq1atKuBsERGRs0Kq5oZpsxU6PAKdngRr8IXPK8CpNAeb9+fOOd1ds3qIiBd4FKhvueWWfAFaRESk0FrdC1s+gsDKcOUMiGpcpMut2p6F4+zw60bV/IgJtxRDkSIiheNRoB47dmxJ1yEiIuVJdgqsfA6aDofYtrntZgsMXQSBkZc0vCMvwzBYsU0PI4qI92kwtIiIFB/DgO1fwa8TIPUwHF4ON690X/kwKKpY3mp3Yg5HTzmHjwRaoV19z2YFEREpbh4H6o0bNzJ79mz27dtHVlZWvv2zZ88u1sJERMTHJG2DJWPhwKLctiNrYNe30HBwsb9d3ocROzQMIMCqoYki4h0XnYcaYMWKFdx6660kJiayYcMGoqKiCA4OZtu2bZw6dYqGDRuWdJ0iIlJW2dJg2eMwq6V7mA6OhQGfQ4NBxf6WmdkG63dlu7b1MKKIeJNHgXratGncdtttvP/++wA88MADzJo1iwULFuDn50enTp1KtEgRESmDDAN2fgMzL4O1k8BxdrYNkxnajIM7tkPTW4o8Vvp81u/OJsu50jhVIy3UjdHDiCLiPR4N+di1axfjx4/HbDZjMpnIyMgAoHr16owdO5Zp06YxePDgkqxTRETKktN7nYuz7P3Rvb1qF+jzDsS0LtTlDMPgxBkHe47lkHTGgWE41040DOe+bDskpzpITnVwMtXBqbTceay7N/XXTFQi4lUeBeqAgAAcDgcmk4no6GgOHDhA+/btAQgNDeXo0aMlWqSIiJQx2Smwb2HudlAV6PEqNL/d/QHEs9IyHew5mkN2jnOp8BwH2O0Gp9Ic7D1mZ9+xHFIzjUKXYTFD50Ya7iEi3uVRoG7SpAl79+6lW7dudOnShffee4/Y2FisVitTp06lUaNGJV2niIh4m2HkDt+IbgltxsLvU6HVPdDtpQJn70jPcvDC12dISnGcd/+lCgsyMbB9EJWCPRq9KCJSYjwK1CNHjiQhIQGACRMmcO+993LnnXcCEBcXx4wZM0quQhER8a4z++H4Jqh3rXt71+ecY6Tj2l/w9LmrMzwK08EBJurG+FE9yoKfBTDBuVXE/cwmIkLMRIaaiQp1/qlZPUSkrPAoUPfq1cv1OjY2lrlz57J//34yMzOpV68e/v6a+1NEpNzJyYINb8DqF8HsB6O2QWi13P0BlS4apncn5vDbX7nT2zWvZSXI34SfBfwsJgKtJmpFW6gb40dMuFljoUXEJ13Swi4mk4k6deoUcykiIlJm7F8Ei++H5O25bb88BNd+4fElcuwGn/+axrmR0S1qWxk7IFShWUTKnQIDdWGHcdx///1FLkZERLws5RD8MgF2fOXeHt3KOWa6EBZvyiQhyQ6Avx8M7xGsMC0i5VKBgfrzzz93287KynJNlxccHEx6ejoAQUFBBAYGKlCLiPgyuw02ToOVz4ItNbfdvxJ0ewFa3+cc9uGhpBQ7367LcG0P7BBElUqaK1pEyqcC/3VcvXq16/XGjRt5+OGHGT9+PH379iUwMJDMzEwWLlzI1KlTmTx5cqkUKyIiJeDgr845pZP+cm9veiv0fA1CqxbqcoZh8MWydLLPLrxSPcpCn5aBxVSsiEjZ41F3w4svvsi9997LwIEDXW2BgYFcd911ZGRk8Pzzz/PNN9+UWJEiIlJC7DZYMMq5UMs5lS+DK9+Bmr0KPu8CNu618ec+m2v71l7B+Fk01ENEyi+PJu/cuXMnMTEx590XGxvL7t27i7UoEREpJRYrXDHV+doaAj1fhxF/XHKY3rw/m0+WpLm2e14WQIOq1mIoVESk7PIoUNepU4eZM2eSnZ3t1p6VlcXMmTOpW7duiRQnIiLFLGlr/rb6A51DO0Ztgw4PO0N2IRmGwaI/M5n+v1Qysp3zelQKMjGkc1BRKxYRKfM8GvLx9NNPc/fdd9OzZ0+6detGVFQUJ0+eZMWKFWRmZvLBBx8UW0G//fYbL730Eg6Hg2HDhnH33XcX27VFRCoqS9ZJWHAnbPkYBs2HBte5H9DhkUu+do7d4D/L0lm2NXe+6ahQM2MHhBISqFUMRaT88yhQd+jQgQULFvDJJ5+wefNmtm7dSpUqVRgyZAgjR44kNja2WIqx2+08//zzzJw5k9jYWIYOHUrv3r1p0KBBsVxfRKTCcdhh84fU/+1RsJ1xti0dB7X7gDW4yJc/fsbOp0vS2H44x9VWL9bCfVeHEa4lwUWkgvB4DqSYmBgeffTRkqyFTZs2Ubt2bWrWrAnANddcw+LFixWoRUQuReJ6WHwfJK7DbcK66NZgS7vkQJ1jN9i038Zvf2Wx9aDNtXALQKeG/oy8IgSrnx5CFJGK45JWSiwpR48eJS4uzrUdGxvLpk2b8h0XHx9fmmVJMcrMzNT982G6f77BbDtNzPapRBz4ElOeuJsdXJOjlz1Bakwv2H8COOF2XlaOibRsMxnZZjJszo+sHBM5DhN2B+Q4TNjsJnafCCAtO/+c0t3qptCxejq7dpb0Z1jx6HvPd+neVQweBWqbzcasWbP4+eefSUxMJCsrK98xq1atKvbiCtK0adNSey8pXvHx8bp/Pkz3r4wzHPDXp7D8UcjIE5YtARyveyfRAyZT05r/IcHjZ+zMXpnOxj3uvc2eMAHNalm5qnUgTWtEFal8KZi+93yX7p1v27Bhg0fHeRSoX3nlFb788ksuv/xyOnXqhNVaMlMgxcbGkpiY6No+evRosY3PFhEp91a9AKuedW+rezVcMY0TiTai/xams2wGP/6ewYI/MsmxF+6twoNNdGsaQI+mAVoBUUQqPI8C9U8//cRDDz3EHXfcUaLFtGjRgn379nHw4EFiY2P54YcfeOONN0r0PUVEyo2Wd8OGNyA7BcJqOeeXbjAITCZIdP7KOSPbIOmMnX3H7Xy7NoPkNIfbJaIrmQkLMhEaaCY0yERwgAl/iwmrnwmrBfwsJqpUMtOsplWLtYiInOVRoDYMg8aNG5d0Lfj5+fHMM8/wz3/+E7vdzg033EDDhg1L/H1FRHyOYYDDBhb/3LbQqtD9FUhNgM5PgTWEIyft/PJXJlv2RpG6Mpn0rPMP6qgdbeHmHiHUjytTj9aIiPgEj/7lvPHGG/n+++/p1q1bSddDr1696NXr0lboEhGpEJK2wuIxztk6rpjivq/NGOwOgz/32Vi6+QzbDp2bzs4K5xkhHRZkYkjnYLo28cdsUo+ziMil8ChQV65cme+++44RI0bQrVs3wsLC3PabTCaGDx9eIgWKiMhZ2amw6nn4fQo4ciBhGTQfRUpocxKS7Bw8kcPBE3a2H8rJN5TjHD8LVAkzExVmpn6sH31aBRIcoPmiRUSKwqNA/fLLLwNw+PBh1q1bl2+/ArWISAkyDNgxG2PpgySnGRww9+GAX0sOmFuxf34Up7JPFXiqyQSt61ipE3aMbm3rEhZkUk+0iEgx8yhQb9u2raTrEBERnIum7DySw6Z92exOzCE9I4vMtDNk2TuSxR8YQX/rTc4+/3XCgkz0aBpAz2YBVA6zEB+foJULRURKiJ4+ERHxkiybQXKag+RUB8fP2Nl60MZfB2xk2vIe5QdEOSd8LoDVAtUrW6hZ2Y8aVSzUqGyhbqwfVs3CISJSKgoVqBMTE9m7dy/Z2fm7RPQgoYjIxR04kcPslensP24vcMaNCwnyh5pV/KgVbaF2FT9qRfsRG2HGYlZ4FhHxFo8CdWpqKuPHj2fFihWAcxo9cI6dPkfLaoqIFMxhGPz8RybfrMnAfv7nBV0qh5lplTWPFimfUdlIICCmIYGXv0hAtVYKziIiZZBHgfrNN9/kyJEj/Pvf/2b48OHMmDGD8PBwvv32W1avXq3FV0RELiA51cHMJanEJ+S4tfuZISLUTGSImYgQM7WiLbSs7U/VSDOmY61g7mPQ/WVoPgpMGv8sIlJWeRSof/31V8aPH0+rVq0AiImJoWXLlnTo0IFJkybx0UcfMXXq1BItVETEV2TnGCSnOjiZ6uBIsnNFwrQ8wztqR1sYdWUI1SItmPb9BJs/gj5fgjnPEt6xbeCu/eAX6IXPQERECsOjQJ2UlETVqlWxWCwEBQVx+vRp175evXoxduzYEitQRMQX7D2aw08bM9hxOIfUzPOPjTYBV7cNZGCHIPzSDsK342HXN86df74Lbe53P0FhWkTEJ3gUqOPi4khOTgagTp06/PLLL/To0QOAP//8k4CAgJKrUESkDNudaOP79ZlsOWC74HFRoWbuuDKExnEGrJ8Eq1+AnIzcA9a/Aa3uBbMmXxIR8TUe/cvdrVs3Vq5cSd++fRk5ciQTJ07kr7/+wmq1sn79ekaNGlXSdYqIlCl7j+bwzZr0fOOiAcwmiAgxExVqJjLUTPXKFi5vFkDI0aXw6RhI3u5+QrPboeerCtMiIj7Ko3+9H374YTIynD0pgwcPJiQkhJ9++omsrCyefvppbrrpphItUkSkLDl4IofX5p0hx57bZgLaN/Cnf9tAakRZMOedjSPlECx6CLZ/6X6h6JbQ+22o0b1U6hYRkZLhUaAOCgoiKCjItd23b1/69u1bYkWJiJRVDsPgs1/TXGHabIKODf0Z0C6IqpGW/Cf8Ph2WPwG21Nw2/zDo+rxzzLR6pUVEfJ5H8zA1bdqUTZs2nXffli1baNq0abEWJSJSVi3bmsXeo8407WeGJ4dV4s4+oecP0wCph9zDdJPhMGobtBuvMC0iUk549K/5uYVczicnJweLpYD/SEREypEz6Q7mrs59kLB/20BqVbnIP6NdnoZt/wFrKFz5NtS6ooSrFBGR0lbg/wSHDx/m0KFDru2tW7eSlZXldkxWVhbffPMNNWrUKLkKRUTKiK9XpruWC4+uZObqtrlD4XDYYdN7UO9aqFQrt90aAkN/hvC6YPEv5YpFRKQ0FBio586dy4wZMzCZTJhMJp599tnzHhcYGMiLL75YUvWJiJQJ8Qk2Vu/Idm0P7xmMv9/ZBw8Pr4bF98GxjXBgMVw3x/3kqMalWKmIiJS2AgP18OHD6devH4ZhcN111zF58mQaN3b/T8FqtVKtWjX8/dXrIiLll81u8O/f0lzbHRr407yWP6SfgOWPw+YPcw/eORf2L4LafbxQqYiIeEOBgToqKoqoqCgAFi9eTHR0tIKziFRICzZmcvSUA4AgfxM3dg2ETR/AsomQeTL3QL9A6PQkVNc0eCIiFYlHDyVWr17d9TojI4PZs2ezZ88eqlSpwuDBg932i4j4uiybwY7DNrYm2Ig/mMOhk7kTTg9uepyI+f0hca37SfWvgyumQnid0i1WRES8rsBAPWnSJJYuXcqCBQtcbampqQwdOpT9+/dTqVIlUlNTmTlzJl9//TV169YtlYJFRIrD8TN2flifwZkMgxy7QY7dObTDlgNHT9nJceQ/p3bAIS5f3QbIs6JLpTrQezrUv7a0ShcRkTKmwHmo16xZw8CBA93aPv74Y/bt28cLL7zAmjVrWLZsGdWrV+edd94p8UJFRIqLw2Hwzo+prNiWzeb9NuITcth5JId9x+wcOpk/TFvM0CL6FPed6o/5XJi2+EPnp+H2rQrTIiIVXIE91IcOHaJ58+ZubQsXLqRBgwYMHToUcI6zHjVqFNOnTy/ZKkVEitGy+CwSkuwXPKZalIXLavhxWU0rjapZCbBGwXddYcdsqNPf2Ssd2aCUKhYRkbKswECdk5NDQECAa/vUqVPs3r2bW265xe24GjVqcOLEiZKrUESkGKVlOpi3JndxliuaB9Cqjj9+FvCzmLBaINwvjfDsPRDbxv3ky6dAk5uhwfVgMpVy5SIiUlYVGKjr1KnDmjVr6NKlCwC//PILAN27uz+9npSURHh4eMlVKCJSjL5fn0FqpnNxlsphZoZ2zTOftGHAti/g14fAZHEuEe4fmntyWA3nh4iISB4FBupbb72Vp59+mtTUVCpXrsxnn31GjRo16Natm9txK1asoGHDhiVeqIhIUR05aWfpltwVX4flDdNJW2Hx/XBwae4Jq56HXq+VcpUiIuJrCgzUQ4YM4fjx4/z73/8mJSWFyy67jGeeeQar1eo65uTJkyxevJgxY8aUSrEiIpfKMAz+uyIN+9kHDhtV86NtPStkp8LqF2DDm+DIyT0hpCrEtfdOsSIi4lMuOA/1Pffcwz333FPg/qioKFasWFHsRYmIFLdN+21sPegMzCYT3NQtCNPOubB0PKQm5B5oskCbsdD1OQio5J1iRUTEp3i0sIuIiC+z2Q2+WpHu2u5ZP5Oav94M+xe6H1i9O1z5NkS3LOUKRUTElylQi0i5lprpYNGfmRw77RzrEewPg3ZdCRnbcg8KioZer8Nlt2n2DhERKTQFahEpN9KzHCzbmsWhk3aOnrJz9JSDtCzD7ZiBHYIJM8bC4jFgMkPLe6H7SxAY4Z2iRUTE5ylQi0i5YBgG7y9M46+DtgKPqRpp5vLmAWC6B45thFajIbZtKVYpIiLlkQK1iJQLa3ZknzdM+xsZxESYqR4TxrXtg/CzmAALXPVB6RcpIiLlkgK1iPi8lAwHX+Z56LBj1SS6n3ia2DPLiOAIZjpAn1XOIR4iIiLFTIFaRHze1yvTXasfRlmSGLGnDYGk5R7gsEH6cQiJ9VKFIiJSnilQi4hPi0+wsWp7tmt7ePr9uWE6IBy6vQSt7gWzxUsViohIeadALSI+KzvH4PNFJ4AAANrlzKOV4+zc0s1GQs/XIDjGewWKiEiFoEAtIj7rh28XcyzdOUtHkHGam2xPQJUWzsVZavTwcnUiIlJRKFCLiE9KSMphwdE2ru2hxiQiLn8MWt8PFqsXKxMRkYpGgVpEfIdhgMmEw2Ew65c07IZzVcMGAbvofuO/IKyalwsUEZGKSHNIiUjZl34Mfrodfn+LTJvBh4vS2HvUDoDFDLdd3w6zwrSIiHiJeqhFpOxy2GHTe7D8Scg6xRFrK97dNoIjp3P7Aq5uG0jVKM3gISIi3qNALSJl05E1sOg+OPY7ABvMA5lpmUFWnjDd87IArm0f5K0KRUREAAVqESlrMpJg2eOw+UPAIAc/5vo9w8/WMa5DrBa4tVcIXZsEeK9OERGRsxSoRaRsMByw+WNYNhEykwA4RRzvBXzMLnMn12HRlcyM7h9KzSr650tERMoG/Y8kIt535iB8fyMcWe1q2mq+nA+DZpLiqORqa1XHyh1XhhAcoOepRUSk7FCgFhHvC6oC6UcBcGDm+5AX+d5xN4bDOS2eyQSDOwbRv20gZpPJm5WKiIjko0AtIt5nDYIrpnHmu3v4MOp74lNru3aFB5v4Z99QmlTXYi0iIlI2KVCLSOk6vhm2fwndXnB2PQMOh8HOwH58EP4np1Nzh3M0ru7HXX1DCQ/WEA8RESm7FKhFpFidSnOwcU82aVkGthyDbLuBLQeys7OxHf2LrOQEMuhCxp4EMggjI9sgI9s4e7YzOJuAa9oHMrB9EGazhniIiEjZpkAtIsXm993ZfLI0LU9A/rvLwHKZ82UqgCPfEaGBJv7ZJ5RmtTTEQ0REfIMCtYgUWY7dYM6qdBZtyrrkawT5m2hS3Y+be4QQGaohHiIi4jsUqEWkSJJS7Ly/MJU9R+2utsqh0CloFdYjv+JvpGE1MrGSiTUgkIBmNxNUvydBAWaC/U0EB5gItJo0tENERHyWArWIXLLN+7P5aFEaaVm5QzxaVTnBqOQhhBz/K/dAkwXajIWuz0FApfNcSURExHcpUItIodkdBvPXZvDj75muNrMJhnQO4qpDz2E6mCdMV+sGV74NMa28UKmIiEjJU6AWEY9l2Ews3ZzJb1uzSEjKHeIREWLinqtCaVDVCg0nw97vwRIAPV+DZreBSWOiRUSk/FKgFpELyrEbbNpvY9X2LDbti8ZhpLvtv6w6/POqcMKCzobm0KowaB7EtIbAyFKvV0REpLQpUItIPoZhsO+YnVXbs1i7MzvPGOncBwf9sHGN7XUGhOVgDnrL/QK1rii1WkVERLytzATqH3/8kRkzZrB7926+/vprWrRo4e2SRCqcQ0k5rN2Vzbqd2Rw/k3+OaIB6IYl0OTOV9tlfE0oy/GGG5qM0RlpERCqsMhOoGzVqxPTp0/nXv/7l7VJEKpTEU3bW78pm3a5sDp+0n/eYqFAznWMP0W7PGGqd+NV9Z7NREFq9FCoVEREpm8pMoK5fv763SxApVxzG2SW/c4yzH3le2yDhbG/0gePnD9GBVmhb35+uNc/QMP5BzFu+cj8gujX0eQeqdSn5T0ZERKQMKzOBujDi4+O9XYJcoszMTN2/IrLZITXLQmqWOffP7HPbZlKyLGTYzNgdhV8oxc9sUL9KFo1iMqkbmUrMgVlE//AOZnuG6xi7XxjHG40judY/4LQfnNb99AX63vNtun++S/euYijVQH377bdz4sSJfO3jx4+nT58+Hl+nadOmxVmWlKL4+Hjdv0KyOww277fx219Z7Dma47aISnHwM0Pz2lY6NPCnZR1/Aq1ng3j8F7DtDbdjT1W/joiB7xMXEktcsVYhJU3fe75N98936d75tg0bNnh0XKkG6k8++aQ0307Ep51MdbA8PotlWzM5lXZpIdpqAX8/k/PDeva1xfk6JMBMi9pWWte1Ehxwnnmim/wDNk6DI6uhcjPo8w5HUqKJCIkt4mcmIiJSvvjkkA+R8sphGGw9aOPXv7L4c58N4zw52mKG8GAzkSFmIkJNRISce332zxAzlYLN+PuB2eThsA9HDqQdhbA8DxeazHDlO3BwCbQZBxYr6NeWIiIi+ZSZQP3zzz/zwgsvcPLkSe655x6aNm3KRx995O2yRErFmfSzvdHxWZw4z3R1YUEmujcNoGuTAGLCzZ4HZU8cWgmL7wNMcOs6MOf5ZyG2jfNDREREClRmAnXfvn3p27evt8sQKTWZNoNdR2ysiM9m495s7OeZ9rlxdT96NQugTV1//CzFGKIB0o/Db4/BXzNz2/78P2hzf/G+j4iISDlXZgK1SHmWYzc4fNLO3mM57D2aw75jdg4n2887pCMkwETXJgH0vCyAuEhL8RfjsMPmD2D5E5CZnNvuFwTG+RdzERERkYIpUIsUM8MwOH7Gwd5jOew7msPeY3YOHM/Bdv7pnl0axDl7o9vV98fqV8y90eckroNF98HR9X978+vhiregUq2SeV8REZFyTIFapBikZzlYujmLXYnOHmhPprYzmaB6lIXG1fzoflkANSqX4LdjRhIsfxI2vQ/kqS2iPvSeDnWvLrn3FhERKecUqEWKwee/prNuV/YFj6kcZqZOjB91YyzUjfWjdrQfAdYS6onOy5YBs1pC6uHcNksAdHwcOj4GfoElX4OIiEg5pkAtUkQpGQ5+3+MepoMDTNSN8aNurOVsiPajUvB55nouDdYguOw2WDvJuV3vGrhiGkTU8049IiIi5YwCtUgRrduVO0NHrWgLd/cNJSbcjKk4p7YrDIcdzH97mLHzU3B4JbSbAPWvc443ERERkWLhpS4zkfJj9fYs1+vuTQOIjbB4J0wbBmz9HD5uBGf2u++zhsA/foUGgxSmRUREipkCtUgRJCbb2XvMOX2HxQwdGvh7p5ATf8FXV8CPI+D0Hlj6oHfqEBERqYA05EOkCFbvyO2dblHbSmhgKf+Mmp0CK5+DjVOdy4efk7gW0o9BcEzp1iMiIlIBKVCLXCKHYbB6R+7DiF0aBZTemxsG7PgafpkAqYdy281+0HY8dHkG/MNKrx4REZEKTIFa5BLtOpJDUorzacTgABMt6lhL541PboclY2H/z+7tNXrCle9AlWalU4eIiIgACtQilyxv73T7+v5YLaXwsN/Gt+GXB8Fhy20LjoVek6HpLXrgUERExAsUqEUugS3HYH2ehVy6NC6lhxEjG+WGaZMZWt8PXZ+DwIjSeX8RERHJR4Fa5BJs2m8jI9u5hHd0JTP140rpW6lOX2g0DFISoM87ENO6dN5XRERECqRALXIJVuWZe7pTI//in3falgHrXoUqLaDRDe77+n3knFfapFkvRUREygIFapFCSslwsOVA7hjmzsU9u8ee/zkfOjy9B0KrQZ2r3Gfs0OwdIiIiZYq6uEQKaX2epcbrxVqIjbBc+ARPndkP8wbDN9c4wzRA6mHY9EHxXF9ERERKhHqoRQppVZ7FXDo3Lobe6Zws2PAGrH4RcjJy2wMjofvL0OKuor+HiIiIlBgFapFCSDxlZ+/RYlxqfP8iWDwGkne4tze/A3pMguDool1fRERESpwCtUghrCmupcbTjsKScbDjK/f26FbOxVmqdy1ClSIiIlKaFKhFPGT8banxIj2MaDLDgTwrHfpXgm4vQOv7nMuHi4iIiM/QQ4kiHtqVmMOJM7lLjbcsylLjwdHO8dEATW+FO7ZD23EK0yIiIj5I/3uLeGj19ktcajwtEfYtgGYj3dtb3AUxbaBqp2KsUkREREqbArWIB2w5But35xnu4clS444c+ONdWPEUZKdA5csgrkPufrNFYVpERKQc0JAPEQ9s2m8jPcu51HiVSmYaXGyp8cOr4PMOsHQcZJ8BDFh0HxiOki9WRERESpV6qEU8kHep8c4XWmo8/QQsewy2fOzeHtkIur+k5cJFRETKIQVqkYvwaKlxw+Fc0XD545CZnNvuFwSdn4J2D4FfMS9RLiIiImWCArXIRVx0qfHE9bD4Pkhc595efxBc8RaE1ymNMkVERMRLFKhFLuKiS40ve8w9TIfXhd7Tod41pVCdiIiIeJsGdIpcgEdLjV8xDUwWsARA52dg5F8K0yIiIhWIeqhFLiDfUuOpW8HaGCx5FnWp0gyu+gCq94DIBl6oUkRERLxJPdQiBci31HjWv2FWK/h9av6Dm49SmBYREamgFKhFCuC21Dinabn7AedsHquehZQE7xYnIiIiZYYCtUgBVv951PW6fc43WDnbW121EzhsBZwlIiIiFY0CtcjfZadiW/q4+1Lj9q8gtBpc818Yusg5k4eIiIgIeihRJJdhwM45sPRBNqW3IT0gAoAqjv00aN0Nuj0L/mFeLVFERETKHgVqkXO2zoKfbgdgtf8rrubOzSIxXfGGl4oSERGRsk5DPkTOaXQjhNcjlUg2W/q4mju3qenFokRERKSsUw+1VEyGATkZYA3ObbMGwZUzWLfhOPZjzgVc6p5vqXERERGRPNRDLRXPqT0wbyB8N8wZrPOqezWrTYNcm10anWepcREREZE81EMtFUdOJqx7Dda+4nwNsGs+NBzsOuToKTt78iw13v58S42LiIiI5KEeaqkY9v4InzaHlf/KDdOY4NhGt8NW51lqvHktK2FB+hYRERGRC1MPtZRvZw7A0vGw6xv39pi20OddqNrR1WQYBmvyLDXepbGGe4iIiMjFKVBL+WTPhvVvwuoXICc9tz0gArq/DC3vBrP7w4a7E3M4fnap8SB/Ey1rW0uxYBEREfFVCtRS/mSnwr87wsl49/Zmt0PPVyE45rynrdqe2zvdvoE/Vj9TCRYpIiIi5YUCtZQ//qEQ2y43UEe3hN5vQ43uBZ5isxvuS4030sOIIiIi4hkFaimfer0OB3+B9g9Bm/vBfP4vdVuOQXKagz/32UjPck6hVznMTIOq+tYQERERzyg1iG9LWAarnoeBX0NgRG57SBxZI3dxKtOPk4cdJKdmkZzm4FSqg5OpDpLTHCSnOkjNNPJdsktjf8wmDfcQERERzyhQi88xDIOs08c49evrJO9ZR7KpGie/XURyzNWuoJyc6iAtK39YvhizCTprMRcREREpBAVqKTGGYWCzQ5bNcH0cPm2FBBtZNoNMm0H22T+zbGePyzHyHE/ucWfbz51jYAWegHPZ9wRwIusC1Zyf2QQRIWYiQ8xEhprp1MhfS42LiIhIoShQS6Fk2gxWxGdx9JQ9T9DlbCj+20dO/pW9IQp+TyliFZ4Nx7CY3cNyZKj766hQM5WCTJjNGt4hIiIil06BWgrl27UZ/Pxn5sUPLGFWI4Nw00kiIysRWaWye1gOMRMVZiYsyKSx0CIiIlLiFKilUKyFHA3hZ4FAqwl/PxMBVhNGTibhlYIItDq3A/xMBFhxvs7z4TwHAg4vJvD3l/HPOkKgkUYAafj7ObB0mgjtHwa/wJL5REVEREQ8pEAthXJt+yBqVvHjdLojNxTnDcR+7m2Wvw2niI8/TNOmTT1/w5REyFyeu13/OrjiLQivWzyfkIiIiEgRKVBLoVj9TLRvUIqLnjQbCZs+gLQj0Hs61L+29N5bRERExAMK1FI2GAZsnQWRjaFa59x2kxmu/RKCqoA1yHv1iYiIiBRAgVq87/gmWDwGDi13LhN+6wb3lQ0r1fRebSIiIiIXYfZ2AVKBZZ2BpQ/CZ22dYRqc4Xrzh96tS0RERKQQ1EMtpc8wYNsX8OtDkJaY2272g3YPwWUjvFebiIiISCGVmUD96quvsnTpUqxWK7Vq1eKVV16hUqVK3i5Lipl/yi74egwcXOq+o+YVcOXbULkQM4CIiIiIlAFlZshHt27d+P777/nuu++oU6cO7733nrdLkuKUnQq/PUa95UPcw3RIVbjmCxi2WGFaREREfFKZCdTdu3fHz8/ZYd66dWsSExMvcob4lNTDsGEKJiPHuW2yQLsHYdQ2aHITaEVDERER8VFlZshHXnPmzOHqq68ucH98fHwpViPFJbruKKrsfp/0yLYkNnuGrEqNYM8h4JC3SxMPZWZm6vvPR+ne+TbdP9+le1cxlGqgvv322zlx4kS+9vHjx9OnTx8A3n33XSwWC9ddd12B1ynUSntS+mzpkLgOavZyb28whUO/NaR674eopx5pnxQfH6/vPx+le+fbdP98l+6db9uwYYNHx5VqoP7kk08uuH/u3Ln88ssvfPLJJ5gUuHzT7u9gyThIPwq3b4XwOrn7rMGcqXYN1XVvRUREpBwpM2Oof/vtNz788EPeffddgoK0Ip7POb0XvrkO5l0HZ/ZBTgYsfcDbVYmIiIiUuDIzhvqFF14gOzubUaNGAdCqVSuef/55L1clF5WTCeteh7UvO1+fExgF9a51zjmtHmkREREpx8pMoP7555+9XYIU1r4FsPh+OLXLvb3FXdDjFQiq7J26REREREpRmQnU4kPOHIRfHoSdc9zbY9pAn3ehaifv1CUiIiLiBQrUUjiGAd9eD0fzPPUaEA7dXoJW94LZ4r3aRERERLygzDyUKD7CZIIek3K3m42EO3ZAmzEK0yIiIlIhqYdaCq92H+j0BNTpDzV6eLsaEREREa9SoJZL0/0lb1cgIiIiUiZoyIeIiIiISBEoUIuIiIiIFIECtYiIiIhIEShQi4iIiIgUgQK1iIiIiEgRKFCLiIiIiBSBArWIiIiISBEoUIuIiIiIFIECtYiIiIhIEShQi4iIiIgUgQK1iIiIiEgRKFCLiIiIiBSBArWIiIiISBEoUIuIiIiIFIECtYiIiIhIEShQi4iIiIgUgQK1iIiIiEgRmAzDMLxdRGFs2LDB2yWIiIiISAXRrl27ix7jc4FaRERERKQs0ZAPEREREZEiUKAWERERESkCBWoRERERkSLwyUD91ltvMXDgQAYNGsQdd9zB0aNHvV2SFMKrr75K//79GThwIGPGjOHMmTPeLkk89OOPP3LNNdfQpEkTNm/e7O1yxEO//fYb/fr1o2/fvrz//vveLkcK4fHHH6dLly5ce+213i5FCunIkSOMGDGCAQMGcM011/Dpp596uyQphKysLIYOHcp1113HNddcw7Rp0y54vE8+lJiamkpoaCgAs2bNYteuXTz//PNerko8tXz5cjp37oyfnx+vv/46AI888oiXqxJP7N69G5PJxL/+9S8effRRWrRo4e2S5CLsdjv9+vVj5syZxMbGMnToUN58800aNGjg7dLEA+vWrSM4OJjHHnuM77//3tvlSCEcO3aM48eP06xZM1JTU7nhhht4++239b3nIwzDID09nZCQEGw2G8OHD+fJJ5+kdevW5z3eJ3uoz4VpgIyMDEwmkxerkcLq3r07fn5+ALRu3ZrExEQvVySeql+/PvXq1fN2GVIImzZtonbt2tSsWRN/f3+uueYaFi9e7O2yxEMdOnQgPDzc22XIJYiJiaFZs2aAM7fUq1dPv1H3ISaTiZCQEABycnLIycm5YN70K63CituUKVOYN28eYWFhzJo1y9vlyCWaM2cOV199tbfLECm3jh49SlxcnGs7NjaWTZs2ebEikYonISGB+Ph4WrVq5e1SpBDsdjtDhgzhwIEDDB8+/IL3r8wG6ttvv50TJ07kax8/fjx9+vThwQcf5MEHH+S9997j888/Z9y4cV6oUgpysfsH8O6772KxWLjuuutKuzy5AE/unYiIeCYtLY1x48bxxBNPuP2GXco+i8XC/PnzOXPmDGPGjGHHjh00atTovMeW2UD9ySefeHTcwIEDufvuuxWoy5iL3b+5c+fyyy+/8Mknn2jIThnj6fee+IbY2Fi3YVVHjx4lNjbWixWJVBw2m41x48YxcOBArrrqKm+XI5eoUqVKdOrUiWXLlhUYqH1yDPW+fftcrxcvXqwxnT7mt99+48MPP+Tdd98lKCjI2+WIlGstWrRg3759HDx4kOzsbH744Qd69+7t7bJEyj3DMHjyySepV68eo0aN8nY5UkgnT550zUKWmZnJypUrL5g3fXKWj7Fjx7J3715MJhPVq1fnueeeU4+LD+nbty/Z2dlEREQA0KpVK83S4iN+/vlnXnjhBU6ePEmlSpVo2rQpH330kbfLkov49ddfefnll7Hb7dxwww2MHj3a2yWJhyZMmMDatWtJTk6mcuXKjB07lmHDhnm7LPHA+vXrueWWW2jUqBFms7P/csKECfTq1cvLlYkntm3bxsSJE7Hb7RiGQf/+/bn//vsLPN4nA7WIiIiISFnhk0M+RERERETKCgVqEREREZEiUKAWERERESkCBWoRERERkSJQoBYRERERKQIFahHxGY0bN77ox5o1a5g7dy6NGzcmLS3N2yVfVFJSEtOnTychIcGtfc2aNTRu3JgdO3YU6/tNnz6dTp06Fes1S8vy5cvPu/DQxIkTGTJkiGvbl+6/iJQPZXalRBGRv/vyyy9drzMzMxk5ciSjR4/m8ssvd7U3aNCAQ4cOeaG6S5OUlMSMGTPo2LEjNWrUcLU3a9aML7/8klq1anmxurJlxYoVLFiwgNtvv92t/b777iMzM9M7RYmIoEAtIj6kdevWrtfneh9r1arl1l5WZGZmEhgYeMnnh4aGlsnPqyzSDx0i4m0a8iEi5VZCQgKjRo2idevW9O/fn4ULF+Y7ZtGiRQwZMoQWLVrQrVs3XnvtNWw2m9sxq1atYtiwYbRo0YKuXbvy7LPPug0nODc8Y9myZdx77720adPGtfrn4cOHefDBB+nYsSOtWrXizjvvZM+ePa76Bg4cCMBtt93mGraS95p5h3zY7Xbee+89+vXrR/PmzenZsycTJ0507f/ll18YNWoUXbp0oW3bttx4440sX778kv7uFixYQL9+/WjZsiW33HILmzdvpnHjxsydO9d1TOPGjfn888/dzvv7kJJjx47x+OOPc+WVV9KyZUv69evHlClTyM7Odh2TkJBA48aN+d///sczzzxDu3bt6NmzJ9OmTcPhcLiu+/HHH3Po0CHX39O5z/3vQz7OJysri9dee41evXrRvHlzrrvuOn799Ve3YxYvXsyQIUNo3bo1HTp0YNiwYaxdu/aS/v5EpGJRD7WIlFsPP/wwN954I3feeSeff/45EyZMYNGiRcTFxQHwv//9j4ceeoh//OMfTJgwgQMHDvDmm29iGAaPPfYYADt37uSuu+6ia9euTJ8+nSNHjvDGG29w8ODBfMuuP/nkkwwZMoSRI0cSEBDAqVOnGD58OBERETz77LMEBQXx/vvvM2rUKBYsWEBMTAyTJ0/m4Ycf5plnnqFZs2YX/HyeeeYZ5s+fz5133knHjh05ffo0CxYscO1PSEjgiiuu4I477sBsNvPbb79x11138fnnn9OuXTuP/97++usvHnzwQfr06cMTTzzBzp07GT9+vMfn55WcnExERASPP/44lSpVYt++fUyfPp3k5GTXDx3nTJ48mauuuopp06axatUq3n77bRo0aMCAAQMYNmwY+/btY82aNcyYMQOAqKgoj+sYN24cmzZtYuzYsdSqVYsff/yR0aNHM2fOHJo2bcqBAwd44IEHGDFiBI888gjZ2dls2bKF06dPX9LnLSIViwK1iJRbI0eOZOjQoYBzTHK3bt1YunQpN998M4Zh8PrrrzN48GCeffZZ1zn+/v48//zz3H333URGRvLOO+9QrVo13n33XSwWCwDh4eE8+OCDbNy4kTZt2rjO7d+/v1vwfOutt8jIyGDevHlEREQA0LZtW3r37s2cOXO45ZZbXD3SDRo0uOAQj927dzN79myefPJJbrvtNlf7gAEDXK9vvfVW12uHw0GnTp3YtWsXs2fPLlSgfv/996lTpw5Tp07FZDLRq1cvbDYbb731lsfXOKdx48auH07A+fkHBQXxxBNP8NRTT+Hv7+/a1759e1evc7du3Vi2bBk///wzAwYMIC4ujpiYGPz9/Qs9FGbVqlX88ssvfPbZZ3Ts2BGA7t27s2/fPt59912mTZvG1q1bCQkJcau1V69ehf58RaRi0pAPESm3unfv7nodGRlJVFQUiYmJAOzdu5fDhw/Tv39/cnJyXB+dO3cmKyuLnTt3ArBp0yb69OnjCtMA/fr1w8/Pjw0bNri9X96HI8EZ5Lp27UpoaKjr+iEhITRr1owtW7YU6nNZs2YNwAWHNiQmJvLYY4/Ro0cPLrvsMpo1a8by5cvZt29fod5r8+bN9O7dG5PJ5Gq76qqrCnWNcwzD4JNPPmHAgAG0bNmSZs2a8fDDD5Odnc2RI0fcju3WrZvbdoMGDVz3qyhWrlxJdHQ0bdu2dbvXXbp0cd2HRo0akZKSwmOPPcby5ctJT08v8vuKSMWhHmoRKbfCwsLctv39/V1jd5OTkwG4++67z3vuubB3/PhxqlSp4rbPYrEQERGRbzhA5cqV3baTk5P5448/+N///pfv+l26dCnEZwKnTp0iODiY0NDQ8+53OByMHj2atLQ0xo0bR+3atQkKCmLatGkkJSUV6r2OHz+e73MpzPCKvD799FNee+017rrrLjp06EClSpXYvHkzzz//PFlZWW7HVqpUyW3barXmO+ZSJCcnc/z48fMOqTn3g1K9evV45513eP/997n77rvx8/Ojb9++PPnkk5f8uYtIxaFALSIV0rkhGC+88AJNmzbNt//cFHbR0dH5AqndbufUqVOEh4e7teft0QXn0JDevXtz33335bt+SEhIoetNT08nNTX1vKF6//79bN26lQ8++ICePXu62i9lOrnzfc4nT57Md5y/v3++Bzj//kPGTz/9RL9+/XjwwQddbbt37y50TUURHh5ObGwsb7/99gWPu/zyy7n88stJSUnhl19+4eWXX+aFF15gypQppVSpiPgqBWoRqZDq1q1LbGwshw4d4sYbbyzwuFatWrFo0SImTJjg6s1cuHAhOTk5Fx2X3KVLF3788UcaNmxY4BR6VqsV4KI9sZ07dwZg3rx5bmOlzzl3ft4xyYcOHWLjxo00atTogtf+u+bNm7NkyRIeeugh1w8J55shJS4uzi0cOxwOVq9e7XZMZmamW00A3333XaHqOedSe6y7dOnCzJkzCQ4Opn79+hc9PiwsjIEDB7Ju3To2btx4KaWKSAWjQC0iFZLZbGbixIk8+uijpKam0rNnT6xWKwcPHmTRokVMmzaNoKAgRo8ezfXXX8+YMWO4+eabSUxMZPLkyXTv3t3tgcTzuf322/n2228ZOXIkt956K7GxsZw4cYJ169bRrl07rr32WqpVq0ZgYCDz5s0jLCwMPz8/WrRoke9a9erV4x//+AeTJk0iKSmJDh06cObMGRYsWMCUKVOoV68ecXFxvPrqqzzwwAOkpaUxbdo0YmJiCv13c9ddd3HjjTfywAMPMHToUHbu3Mns2bPzHdenTx/+85//0LRpU2rWrMns2bNJTU11O6Zr16589tlntGzZklq1avHdd9+xf//+Qtd07u/gxIkTzJ07l4YNGxIZGem2GE5BunXrRvfu3bnjjju46667aNCgAampqWzbto2srCweeugh/vvf//LHH3/Qo0cPYmJi2LdvHz/99BODBg26pFpFpGJRoBaRCmvAgAGEhITw3nvvMWfOHMxmMzVr1uTyyy939Rw3bNiQDz74gDfffJP777+f0NBQrrnmGh555JGLXj8qKoovv/ySt956i1deeYUzZ84QExND27ZtXbN7BAQE8MILL/D2228zYsQIbDYb27dvP+/1/vWvf1GtWjW+/vprPvjgA6KiolwP8vn7+zN9+nSef/55xo0bR1xcHPfeey9r164t9PLlLVq04M033+TNN99kzJgxNG/enClTpjBs2DC34+6//35OnjzJ1KlTsVqt3HLLLTRo0IB///vfrmPGjBlDcnIyU6dOBaBv37489dRT3HvvvYWqCeDqq69mzZo1vP7665w8eZLrr7+eSZMmXfQ8k8nEjBkz+L//+z8+/fRTjhw5Qnh4OE2aNGHEiBGAczaSJUuW8Morr3D69Gmio6MZNmwYDzzwQKHrFJGKx2QYhuHtIkREpGxLS0ujbdu2vPLKKxddREVEpKLRtHkiIiIiIkWgQC0iIiIiUgQa8iEiIiIiUgTqoRYRERERKQIFahERERGRIlCgFhEREREpAgVqEREREZEiUKAWERERESmC/wcLnWv2SO1UEwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "evaluator.plot_qq()" + ] + } + ], + "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.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorials/tutorial_Cobra_logistic_regression.ipynb b/tutorials/tutorial_Cobra_logistic_regression.ipynb new file mode 100644 index 0000000..13061d2 --- /dev/null +++ b/tutorials/tutorial_Cobra_logistic_regression.ipynb @@ -0,0 +1,2604 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, \"C:/Users/samuel.borms/Desktop/code/cobra\")\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cobra's approach to logistic regression" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cobra requires the usual Python packages for data science, such as numpy, pandas and scikit-learn. These packages, along with their versions are listed in requirements.txt and can be installed using pip." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# pip install -r requirements.txt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you want to install Cobra with e.g. pip, you don't have to install all of these requirements as these are automatically installed with Cobra itself. Hence, the easiest way to install Cobra is using pip:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# pip install -U pythonpredictions-cobra" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*****" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This section we will walk you through all the required steps to build a predictive logistic regression model using **Cobra**. All classes and functions used here are well-documented. In case you want more information on a class or function, run `help(function_or_class_you_want_info_from)`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Building a good model involves three steps:\n", + "\n", + "1. **Preprocessing**: properly prepare the predictors (a synonym for “feature” or variable that we use throughout this tutorial) for modelling.\n", + "\n", + "2. **Feature selection**: automatically select a subset of predictors which contribute most to the target variable or output in which you are interested.\n", + "\n", + "3. **Model evaluation**: once a model has been build, a detailed evaluation can be performed by computing all sorts of evaluation metrics.\n", + "\n", + "Let's dive in!\n", + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Survival prediction using Titanic data\n", + "\n", + "- BASETABLE: seaborn dataset Titanic.\n", + "- GOAL: Predict if individual survives in Titanic sinking." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Import the necessary libraries first." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import os\n", + "import random\n", + "import pandas as pd\n", + "import numpy as np\n", + "import seaborn as sns\n", + "from pandas.api.types import is_datetime64_any_dtype\n", + "from sklearn import metrics\n", + "\n", + "pd.set_option(\"display.max_columns\", 50)\n", + "pd.set_option(\"display.max_rows\", 50)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from cobra import __version__\n", + "\n", + "from cobra.preprocessing import PreProcessor\n", + "\n", + "from cobra.model_building import univariate_selection\n", + "from cobra.model_building import ForwardFeatureSelection\n", + "# from cobra.model_building import LogisticRegressionModel\n", + "\n", + "from cobra.evaluation import ClassificationEvaluator\n", + "from cobra.evaluation import generate_pig_tables\n", + "from cobra.evaluation import plot_univariate_predictor_quality\n", + "from cobra.evaluation import plot_correlation_matrix\n", + "from cobra.evaluation import plot_performance_curves\n", + "from cobra.evaluation import plot_variable_importance\n", + "from cobra.evaluation import plot_incidence" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The version of Cobra being used is 1.1.0.\n" + ] + } + ], + "source": [ + "print(f\"The version of Cobra being used is {__version__}.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
survivedpclasssexagesibspparchfareembarkedclasswhoadult_maledeckembark_townalivealone
003male22.0107.2500SThirdmanTrueNaNSouthamptonnoFalse
111female38.01071.2833CFirstwomanFalseCCherbourgyesFalse
213female26.0007.9250SThirdwomanFalseNaNSouthamptonyesTrue
311female35.01053.1000SFirstwomanFalseCSouthamptonyesFalse
403male35.0008.0500SThirdmanTrueNaNSouthamptonnoTrue
\n", + "
" + ], + "text/plain": [ + " survived pclass sex age sibsp parch fare embarked class \\\n", + "0 0 3 male 22.0 1 0 7.2500 S Third \n", + "1 1 1 female 38.0 1 0 71.2833 C First \n", + "2 1 3 female 26.0 0 0 7.9250 S Third \n", + "3 1 1 female 35.0 1 0 53.1000 S First \n", + "4 0 3 male 35.0 0 0 8.0500 S Third \n", + "\n", + " who adult_male deck embark_town alive alone \n", + "0 man True NaN Southampton no False \n", + "1 woman False C Cherbourg yes False \n", + "2 woman False NaN Southampton yes True \n", + "3 woman False C Southampton yes False \n", + "4 man True NaN Southampton no True " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = sns.load_dataset(\"titanic\")\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the example below, we assume the data for model building is available in a pandas DataFrame. This DataFrame should contain an ID column, a target column (e.g. “**survived**”) and a number of candidate predictors (features) to build a model with.\n", + "\n", + "***" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "survived int64\n", + "pclass int64\n", + "sex object\n", + "age float64\n", + "sibsp int64\n", + "parch int64\n", + "fare float64\n", + "embarked object\n", + "class category\n", + "who object\n", + "adult_male bool\n", + "deck category\n", + "embark_town object\n", + "alive object\n", + "alone bool\n", + "dtype: object" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.dtypes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is required to set all category vars to object dtype." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "df.loc[:, df.dtypes==\"category\"] = (df.select_dtypes([\"category\"]).apply(lambda x: x.astype(\"object\")))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data preprocessing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### The first part focusses on preparing the predictors for modelling by:\n", + "\n", + "1. Defining the ID column, the target, discrete and contineous variables.\n", + "\n", + "2. Splitting the dataset into training, selection and validation datasets.\n", + "\n", + "3. Binning continuous variables into discrete intervals.\n", + "\n", + "4. Replacing missing values of both categorical and continuous variables (which are now binned) with an additional “Missing” bin/category.\n", + "\n", + "5. Regrouping categories in new category “other”.\n", + "\n", + "6. Replacing bins/categories with their corresponding incidence rate per category/bin.\n", + "\n", + "*Note to user*: as any good data scientist knows, you still need to deal in your data with irregularities, such as outliers or very skewed distributions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this toy dataset, the index will serve as ID." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "df[\"id\"] = df.index + 1\n", + "id_col = \"id\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The target is the \"survived\" column." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "target_col = \"survived\"" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(891, 16)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we remove the columns \"who\" and \"adult_male\" since they are duplicate of \"sex\", and also \"alive\", which seems to be a duplicate of \"survived\"." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "df.drop([\"who\", \"adult_male\", \"alive\"], axis=1, inplace=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to find out which variables are categorical (discrete) and which are continuous.\n", + "\n", + "Discrete variables are definitely those that contain strings." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['sex', 'embarked', 'class', 'deck', 'embark_town']\n" + ] + } + ], + "source": [ + "col_dtypes = df.dtypes\n", + "discrete_vars = [col for col in col_dtypes[col_dtypes==object].index.tolist() if col not in [id_col, target_col]] \n", + "print(discrete_vars)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we also check for numerical columns that only contain a few different values, thus to be interpreted as discrete, categorical variables." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pclass\n", + "sibsp\n", + "parch\n", + "alone\n" + ] + } + ], + "source": [ + "for col in df.columns:\n", + " if col not in discrete_vars and col not in [id_col, target_col]: # omit discrete because a string, and target\n", + " val_counts = df[col].nunique()\n", + " if val_counts > 1 and val_counts <= 10: # the column contains less than 10 different values\n", + " print(col)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By taking a look at the printed variables, it is clear that we have to include those in the list of discrete variables." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['sex',\n", + " 'embarked',\n", + " 'class',\n", + " 'deck',\n", + " 'embark_town',\n", + " 'pclass',\n", + " 'sibsp',\n", + " 'parch',\n", + " 'class',\n", + " 'deck',\n", + " 'alone']" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "discrete_vars.extend([\"pclass\", \"sibsp\", \"parch\", \"class\", \"deck\", \"alone\"])\n", + "discrete_vars" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The remaining variables can be labelled continous predictors, without including the target variable.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['age', 'fare']" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "continuous_vars = list(set(df.columns)\n", + " - set(discrete_vars) \n", + " - set([id_col, target_col]))\n", + "continuous_vars " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we can prepare **Cobra's PreProcessor** object." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "model_type = \"classification\"" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The target encoder's additive smoothing weight is set to 0. This disables smoothing and may make the encoding prone to overfitting. Increase the weight if needed.\n" + ] + } + ], + "source": [ + "# using all Cobra's default parameters for preprocessing here\n", + "preprocessor = PreProcessor.from_params(\n", + " model_type=model_type\n", + ")\n", + "\n", + "# these are all available options: help(PreProcessor.from_params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Split data into train-selection-validation sets." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "random.seed(1212)\n", + "basetable = preprocessor.train_selection_validation_split(data=df,\n", + " train_prop=0.6,\n", + " selection_prop=0.25,\n", + " validation_prop=0.15)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Fit the preprocessor pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1f75c64218b34df38497d1109e621a40", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Computing discretization bins...: 0%| | 0/2 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
survivedpclasssexagesibspparchfareembarkedclassdeckembark_townaloneidsplitage_binfare_binsex_processedembarked_processedclass_processeddeck_processedembark_town_processedpclass_processedsibsp_processedparch_processedalone_processedsex_encembarked_encclass_encdeck_encembark_town_encpclass_encsibsp_encparch_encalone_encage_encfare_enc
003male22.0107.2500SThirdNaNSouthamptonFalse1train19.0 - 22.07.2 - 7.9maleOtherOtherMissingOtherOther10False0.1908830.3895130.3117210.3009710.3895130.3117210.5403230.3543690.5167460.2708330.232143
111female38.01071.2833CFirstCCherbourgFalse2train35.0 - 42.039.6 - 78.1femaleOtherFirstOtherOther110False0.7729730.3895130.6296300.6478870.3895130.6296300.5403230.3543690.5167460.3571430.566038
213female26.0007.9250SThirdNaNSouthamptonTrue3selection24.0 - 28.07.9 - 8.1femaleOtherOtherMissingOtherOther00True0.7729730.3895130.3117210.3009710.3895130.3117210.3505430.3543690.3119270.3200000.222222
311female35.01053.1000SFirstCSouthamptonFalse4train31.0 - 35.039.6 - 78.1femaleOtherFirstOtherOther110False0.7729730.3895130.6296300.6478870.3895130.6296300.5403230.3543690.5167460.5365850.566038
403male35.0008.0500SThirdNaNSouthamptonTrue5train31.0 - 35.07.9 - 8.1maleOtherOtherMissingOtherOther00True0.1908830.3895130.3117210.3009710.3895130.3117210.3505430.3543690.3119270.5365850.222222
\n", + "" + ], + "text/plain": [ + " survived pclass sex age sibsp parch fare embarked class deck \\\n", + "0 0 3 male 22.0 1 0 7.2500 S Third NaN \n", + "1 1 1 female 38.0 1 0 71.2833 C First C \n", + "2 1 3 female 26.0 0 0 7.9250 S Third NaN \n", + "3 1 1 female 35.0 1 0 53.1000 S First C \n", + "4 0 3 male 35.0 0 0 8.0500 S Third NaN \n", + "\n", + " embark_town alone id split age_bin fare_bin sex_processed \\\n", + "0 Southampton False 1 train 19.0 - 22.0 7.2 - 7.9 male \n", + "1 Cherbourg False 2 train 35.0 - 42.0 39.6 - 78.1 female \n", + "2 Southampton True 3 selection 24.0 - 28.0 7.9 - 8.1 female \n", + "3 Southampton False 4 train 31.0 - 35.0 39.6 - 78.1 female \n", + "4 Southampton True 5 train 31.0 - 35.0 7.9 - 8.1 male \n", + "\n", + " embarked_processed class_processed deck_processed embark_town_processed \\\n", + "0 Other Other Missing Other \n", + "1 Other First Other Other \n", + "2 Other Other Missing Other \n", + "3 Other First Other Other \n", + "4 Other Other Missing Other \n", + "\n", + " pclass_processed sibsp_processed parch_processed alone_processed \\\n", + "0 Other 1 0 False \n", + "1 1 1 0 False \n", + "2 Other 0 0 True \n", + "3 1 1 0 False \n", + "4 Other 0 0 True \n", + "\n", + " sex_enc embarked_enc class_enc deck_enc embark_town_enc pclass_enc \\\n", + "0 0.190883 0.389513 0.311721 0.300971 0.389513 0.311721 \n", + "1 0.772973 0.389513 0.629630 0.647887 0.389513 0.629630 \n", + "2 0.772973 0.389513 0.311721 0.300971 0.389513 0.311721 \n", + "3 0.772973 0.389513 0.629630 0.647887 0.389513 0.629630 \n", + "4 0.190883 0.389513 0.311721 0.300971 0.389513 0.311721 \n", + "\n", + " sibsp_enc parch_enc alone_enc age_enc fare_enc \n", + "0 0.540323 0.354369 0.516746 0.270833 0.232143 \n", + "1 0.540323 0.354369 0.516746 0.357143 0.566038 \n", + "2 0.350543 0.354369 0.311927 0.320000 0.222222 \n", + "3 0.540323 0.354369 0.516746 0.536585 0.566038 \n", + "4 0.350543 0.354369 0.311927 0.536585 0.222222 " + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "basetable = preprocessor.transform(basetable,\n", + " continuous_vars=continuous_vars,\n", + " discrete_vars=discrete_vars)\n", + "basetable.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Predictor Insights Graphs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we can the create the so-called Predictor Insights Graphs (PIGs in short). These are graphs that represents the insights of the relationship between a single predictor and the target. More specifically, the predictor is binned into groups, and we represent group size in bars and group (target) incidence in a colored line. Moreover, we have the option to force order of predictor values. First, we compute the output needed to plot the PIG." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Other 889\n", + "Missing 2\n", + "Name: embark_town_processed, dtype: int64" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "basetable[\"embark_town_processed\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "61 NaN\n", + "829 NaN\n", + "Name: embark_town, dtype: object" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "basetable[\"embark_town\"][basetable[\"embark_town\"].isnull()]" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "survived 1\n", + "pclass 1\n", + "sex female\n", + "age 38.0\n", + "sibsp 0\n", + "parch 0\n", + "fare 80.0\n", + "embarked NaN\n", + "class First\n", + "deck B\n", + "embark_town NaN\n", + "alone True\n", + "id 62\n", + "split train\n", + "age_bin 35.0 - 42.0\n", + "fare_bin 78.1 - 512.3\n", + "sex_processed female\n", + "embarked_processed Missing\n", + "class_processed First\n", + "deck_processed B\n", + "embark_town_processed Missing\n", + "pclass_processed 1\n", + "sibsp_processed 0\n", + "parch_processed 0\n", + "alone_processed True\n", + "sex_enc 0.772973\n", + "embarked_enc 1.0\n", + "class_enc 0.62963\n", + "deck_enc 0.766667\n", + "embark_town_enc 1.0\n", + "pclass_enc 0.62963\n", + "sibsp_enc 0.350543\n", + "parch_enc 0.354369\n", + "alone_enc 0.311927\n", + "age_enc 0.357143\n", + "fare_enc 0.740741\n", + "Name: 61, dtype: object" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "basetable.iloc[61, :]" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Southampton 644\n", + "Cherbourg 168\n", + "Queenstown 77\n", + "Name: embark_town, dtype: int64" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "basetable[\"embark_town\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "survived embark_town\n", + "0 Southampton 107\n", + " Cherbourg 14\n", + " Queenstown 11\n", + "1 Southampton 60\n", + " Cherbourg 24\n", + " Queenstown 6\n", + "Name: embark_town, dtype: int64" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[df[\"split\"]==\"selection\"].groupby(\"survived\")[\"embark_town\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
variablelabelpop_sizeglobal_avg_targetavg_target
0age1.0 - 14.00.0839550.3917910.577778
1age14.0 - 19.00.0951490.3917910.411765
2age19.0 - 22.00.0895520.3917910.270833
3age22.0 - 24.00.0503730.3917910.518519
4age24.0 - 28.00.0932840.3917910.320000
5age28.0 - 31.00.0690300.3917910.459459
6age31.0 - 35.00.0764930.3917910.536585
7age35.0 - 42.00.0783580.3917910.357143
8age42.0 - 51.00.0727610.3917910.410256
9age51.0 - 80.00.0746270.3917910.400000
10ageMissing0.2164180.3917910.293103
0aloneFalse0.3899250.3917910.516746
1aloneTrue0.6100750.3917910.311927
0classFirst0.2518660.3917910.629630
1classOther0.7481340.3917910.311721
0deckB0.0559700.3917910.766667
1deckD0.0429100.3917910.739130
2deckMissing0.7686570.3917910.300971
3deckOther0.1324630.3917910.647887
0embark_townMissing0.0037310.3917911.000000
1embark_townOther0.9962690.3917910.389513
0embarkedMissing0.0037310.3917911.000000
1embarkedOther0.9962690.3917910.389513
0fare0.0 - 7.20.0503730.3917910.074074
1fare7.2 - 7.90.2089550.3917910.232143
2fare7.9 - 8.10.0671640.3917910.222222
3fare8.1 - 10.50.0839550.3917910.244444
4fare10.5 - 14.50.1007460.3917910.444444
5fare14.5 - 21.10.0914180.3917910.408163
6fare21.1 - 27.40.0970150.3917910.519231
7fare27.4 - 39.60.1007460.3917910.407407
8fare39.6 - 78.10.0988810.3917910.566038
9fare78.1 - 512.30.1007460.3917910.740741
0parch00.7686570.3917910.354369
1parch10.1212690.3917910.553846
2parch20.0914180.3917910.510204
3parch30.0074630.3917910.500000
4parch40.0055970.3917910.000000
5parch50.0055970.3917910.333333
0pclass10.2518660.3917910.629630
1pclassOther0.7481340.3917910.311721
0sexfemale0.3451490.3917910.772973
1sexmale0.6548510.3917910.190883
0sibsp00.6865670.3917910.350543
1sibsp10.2313430.3917910.540323
2sibsp20.0317160.3917910.529412
3sibsp30.0205220.3917910.181818
4sibsp40.0205220.3917910.272727
5sibsp50.0055970.3917910.000000
6sibsp80.0037310.3917910.000000
\n", + "
" + ], + "text/plain": [ + " variable label pop_size global_avg_target avg_target\n", + "0 age 1.0 - 14.0 0.083955 0.391791 0.577778\n", + "1 age 14.0 - 19.0 0.095149 0.391791 0.411765\n", + "2 age 19.0 - 22.0 0.089552 0.391791 0.270833\n", + "3 age 22.0 - 24.0 0.050373 0.391791 0.518519\n", + "4 age 24.0 - 28.0 0.093284 0.391791 0.320000\n", + "5 age 28.0 - 31.0 0.069030 0.391791 0.459459\n", + "6 age 31.0 - 35.0 0.076493 0.391791 0.536585\n", + "7 age 35.0 - 42.0 0.078358 0.391791 0.357143\n", + "8 age 42.0 - 51.0 0.072761 0.391791 0.410256\n", + "9 age 51.0 - 80.0 0.074627 0.391791 0.400000\n", + "10 age Missing 0.216418 0.391791 0.293103\n", + "0 alone False 0.389925 0.391791 0.516746\n", + "1 alone True 0.610075 0.391791 0.311927\n", + "0 class First 0.251866 0.391791 0.629630\n", + "1 class Other 0.748134 0.391791 0.311721\n", + "0 deck B 0.055970 0.391791 0.766667\n", + "1 deck D 0.042910 0.391791 0.739130\n", + "2 deck Missing 0.768657 0.391791 0.300971\n", + "3 deck Other 0.132463 0.391791 0.647887\n", + "0 embark_town Missing 0.003731 0.391791 1.000000\n", + "1 embark_town Other 0.996269 0.391791 0.389513\n", + "0 embarked Missing 0.003731 0.391791 1.000000\n", + "1 embarked Other 0.996269 0.391791 0.389513\n", + "0 fare 0.0 - 7.2 0.050373 0.391791 0.074074\n", + "1 fare 7.2 - 7.9 0.208955 0.391791 0.232143\n", + "2 fare 7.9 - 8.1 0.067164 0.391791 0.222222\n", + "3 fare 8.1 - 10.5 0.083955 0.391791 0.244444\n", + "4 fare 10.5 - 14.5 0.100746 0.391791 0.444444\n", + "5 fare 14.5 - 21.1 0.091418 0.391791 0.408163\n", + "6 fare 21.1 - 27.4 0.097015 0.391791 0.519231\n", + "7 fare 27.4 - 39.6 0.100746 0.391791 0.407407\n", + "8 fare 39.6 - 78.1 0.098881 0.391791 0.566038\n", + "9 fare 78.1 - 512.3 0.100746 0.391791 0.740741\n", + "0 parch 0 0.768657 0.391791 0.354369\n", + "1 parch 1 0.121269 0.391791 0.553846\n", + "2 parch 2 0.091418 0.391791 0.510204\n", + "3 parch 3 0.007463 0.391791 0.500000\n", + "4 parch 4 0.005597 0.391791 0.000000\n", + "5 parch 5 0.005597 0.391791 0.333333\n", + "0 pclass 1 0.251866 0.391791 0.629630\n", + "1 pclass Other 0.748134 0.391791 0.311721\n", + "0 sex female 0.345149 0.391791 0.772973\n", + "1 sex male 0.654851 0.391791 0.190883\n", + "0 sibsp 0 0.686567 0.391791 0.350543\n", + "1 sibsp 1 0.231343 0.391791 0.540323\n", + "2 sibsp 2 0.031716 0.391791 0.529412\n", + "3 sibsp 3 0.020522 0.391791 0.181818\n", + "4 sibsp 4 0.020522 0.391791 0.272727\n", + "5 sibsp 5 0.005597 0.391791 0.000000\n", + "6 sibsp 8 0.003731 0.391791 0.000000" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predictor_list = [col for col in basetable.columns\n", + " if col.endswith(\"_bin\") or col.endswith(\"_processed\")]\n", + "pig_tables = generate_pig_tables(basetable[basetable[\"split\"]==\"train\"],\n", + " id_column_name=id_col,\n", + " target_column_name=target_col,\n", + " preprocessed_predictors=predictor_list)\n", + "pig_tables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, we can plot a PIG graph for each of the predictors in the basetable. For instance, for the variable age." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAI4CAYAAAB3HEhGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd3xT1fvA8U+66aKlLd0tUGjZqywRUAFRQFAUFzLdgH4V+SHDPcCBigoOFCeoKIIKCgiKA2TvUTaUDrr3nvn9cdKMNi0F2qbjeb9eeTX33pObkzZN7nPGczRarVaLEEIIIYQQQoirZmXpCgghhBBCCCFEYyEBlhBCCCGEEELUEAmwhBBCCCGEEKKGSIAlhBBCCCGEEDVEAiwhhBBCCCGEqCESYAkhhBBXSBLxCiGEKE8CLCGEuExhYWGEhYURExNTJ88XExNDWFgYN954Y7Uf07FjR8LCwmqxVg3TlfwuzcnKyuLVV19l7dq1NVQzIYQQjYUEWEIIIcRlevPNN1m+fDklJSWWrooQQoh6xsbSFRBCCFE1b29v1q9fj52dnaWrInRKS0stXQUhhBD1lARYQghRz9na2hISEmLpagghhBCiGmSIoBBC1IA1a9YQFhbGihUr2Lt3L5MnTyY8PJwePXowefJk9uzZY/Zx586d49lnn+WGG26ga9eu3HTTTcyfP5/U1FR9marmDf37779MmDCBXr160bdvX+bOnUtKSkql9czIyGDhwoUMGzaMLl260K9fP/73v/9x4sSJCmUnTJhAWFgYWVlZLFu2jOHDh9OlSxcGDhzISy+9ZFJHYxs2bGDixIn07duXXr16ceedd/Lzzz+b7fVZt24d48aNo2fPnnTv3p2xY8eyatWqaieP2LVrF2FhYcyfP5+jR48yYcIEevTowbXXXsuMGTM4e/Zstc4DcPr0aWbNmsWAAQPo3LkzAwcO5Omnn65wjrCwMH788UcA5s6dS1hYGLt27ar281yubdu2MX36dH29evbsydixY1mxYoXZ32lsbCzPPPMM119/PV27dmXMmDH8+uuv/PLLL4SFhbFmzRqT8sXFxXzzzTfcfvvt9OjRg549ezJ+/Hg2bdpUa69JCCEaM+nBEkKIGrRt2zYWLFiAn58f11xzDefOnWPHjh3s3buXFStW0L17d33Z7du3M336dHJzcwkLC6NLly6cPHmSr7/+mr/++osffviBFi1aVPpc3333HS+99BJWVlb06dMHBwcHNm7cyMGDB80GKBcvXmTixIlER0fj7+/PoEGDSElJYdOmTfz111+8//773HDDDRUeN2fOHLZs2UL37t1p06YNO3fu5Ntvv+XAgQOsXr0aa2trfdnnn3+e77//Hjs7O/r06YOtrS27du1i9uzZHD16lGeffVZf9plnnuHHH3/E0dGRrl270qxZM/bs2cOzzz7Lrl27WLhwIRqNplq/91OnTjFhwgSaNWvGwIEDiYyMZP369WzdupXPP/+crl27Vvn4P/74gxkzZlBYWEj79u0JDw/n/Pnz/PLLL2zatIn333+fQYMGATBq1CgOHTpEVFQUPXr0ICAgAE9Pz2rV83J9+umnvPXWW9ja2tKrVy9cXV2JiYnhyJEjHDlyhOjoaObOnasvf/bsWSZOnEhycjIhISF07dqV48ePM3PmTLp161bh/EVFRUydOpWtW7fSvHlzwsPD0Wq17Nmzh8cff5xHH32UGTNm1MprE0KIRksrhBDisoSGhmpDQ0O10dHR+n2rV6/W73/nnXe0xcXFWq1Wqy0tLdXOmjVLGxoaqn3yySf15bOzs7UDBgzQhoaGaletWqXfX1xcrJ03b542NDRU+/zzz2u1Wq02OjpaGxoaqh06dKi+3MWLF7Vdu3bVduvWTbtv3z79/ri4OO2wYcP0dTF27733akNDQ7ULFy7U10+r1Wq3bdum7dKlizY8PFybnJys3z9+/HhtaGioNjw8XHvw4EH9/vj4eO0111yjDQ0N1f7zzz/6/b///rs2NDRUO3jwYG1UVJRJnQYNGqQNDQ3Vn+eHH37QhoaGam+99VbtxYsX9WVTUlK0d955pzY0NFS7cuXKS/4tdu7cqX+t48eP12ZlZemPLV68WBsaGqodNWqUtqSkpNLfZUJCgrZbt27a9u3ba3/++WeT869atUobFhamDQ8P1yYlJen3l/2NVq9efck6Xqn4+Hhtp06dtH379tVeuHDB5FjZ77pbt27awsJC/f5x48ZpQ0NDtYsWLdKWlpZqtVr1nnrllVf0vyfjOi9atEgbGhqqnTJlijYtLU2/Pzo6Wjt06FBtaGioduvWrbX2GoUQojGSIYJCCFGDfH19eeKJJ/S9OhqNhnHjxgFw5swZfbk///yTxMREbrrpJsaOHavfb21tzdNPP01QUBCZmZmVPs9PP/1Efn4+EydOpGfPnvr9Pj4+PPPMMxXKHzx4kH379tGpUydmzpxp0ut07bXXct9995GVlaUf+mbsvvvuM+n98Pb2ZujQoRVe03fffQfAs88+S2BgoEmdpk+fTmhoKOfPnwfgs88+A+D111/H19dXX7ZFixbMnz8fgM8//7zS11+era0tb731Fs7Ozvp906dPp2PHjpw8eZL9+/dX+tgffviBvLw87rzzTm699VaTY2PHjmXMmDFkZWXx/fffV7s+NSElJYUbb7yRxx57jKCgIJNjw4YNw93dnby8PNLS0gCIiIhg7969dOzYkSeeeELf+2dtbc3cuXNp3bq1yTkKCwtZsWIF9vb2vPnmm7i5uemPBQQE6N9HX3zxRS2+SiGEaHwkwBJCiBrUpUsXrKxMP1rLho/l5ubq9+3evRvA7JC85s2bs3nzZhYtWlTp85TN6Sobtmbs2muvxcHBwWRf2RyhPn36mB12N3DgQJN6GTM3tMzLywswvCatbliZra0tAwYMqFD+rrvuYt26ddx2220kJiZy/vx53NzcaN++fYWy7dq1w9vbm8jISJKSkiocN6dXr154e3ub7NNoNAwePBig0jlwxseGDx9u9viIESMueY7a0LFjRxYtWsT48eP1+4qKijhz5gyrV6/Wp4gvKioC1JBTgCFDhlT4G1tbW1eYw3fs2DGysrJo27at2SGO11xzDTY2Nuzbt0/S0QshxGWQOVhCCFGDXFxcKuyzsVEftVqjeVFlgYOPj88VPU9iYiJAhaAC1MW0j48PkZGR+n1xcXGA6o2oqkciPj6+wj5XV1ezzwGG15SWlkZRURG+vr7Y2tpWWfey50hPT7/kYshxcXH6YK4q5Xt4ypT9fst+X+aUHfP39zd7PCAgAIDk5ORL1sOcvXv3snLlygr7e/fuzd13313lY4uLi/ntt9/YsGEDp0+fJi4uTh/slAVRZX+Dsr+xcY+gsfKvr6z8sWPHqvw7FBcXk5GRUeV8QCGEEAYSYAkhRA2qblKG4uLiWn2esqCuTFm2ue7du5sM3yvvSi+iL6eHo6ysh4cH/fv3r7Ksk5NTtc5pPOTxco9rL5GxsOx3d6XrkEVFRbFu3boK+21sbKoMsHJzc5kwYQJHjx7F0dGRzp07c/311xMaGkqfPn146KGHiI6O1pcv68mqbI2u8q+zrFxAQAA9evS47NclhBDCPAmwhBDCAsp6ZRISEswe/+2337C1tTU7BBBUz9Xp06eJjY01GzCVH1pX9nzXXXcd06ZNu5qqm9W8eXNsbW1JTk6muLi4QoCXlpbG77//TlhYmL4uTk5OvPXWWzXy/JX9HmNjY4GqewpbtmzJ+fPniYmJMdsTVhbEeHh4XFHdbr/9dm6//fbLftznn3/O0aNHGTRoEIsWLTKZXwaQlZVlsl32Gst6psor3ztZ9ncIDAyssb+DEEIImYMlhBAWUZaY4t9//61wLD8/n2eeeYZnnnmm0p6Xa665BlDpxcs7ePAgGRkZJvt69eqlfz5zPTYrV67klltu4YMPPri8F6JjZ2dH586dKSoqYseOHRWO//3337zwwgusXbuWgIAAfH19iYmJMbtOVUpKCjfddBOTJ08mJyenWs+/Z88e8vLyTPZptVq2bNkCYHZeWJnevXsDsHHjRrPHN2zYAKj5a2Wq21N5NQ4dOgTAxIkTKwRXR48eJT09HTD0TPXt2xdQv+vytFotf/31l8m+Ll264ODgwJEjR8yuaXby5EluvPFGHn/88WqvSyaEEEICLCGEsIgRI0bg5ubGhg0b9BfwoIYOzp8/n7y8PIYPH17pfKYxY8bg6urKypUr+eeff/T7U1NTeeGFFyqU79evH+3bt+fAgQMsWrTIZIhiREQEixYt4vTp05ecE1WV++67D4D58+eb9CjFx8fz/vvvo9FoGDVqFACTJk2itLSUWbNmcfHiRX3ZvLw85s6dS2RkJE5OTtUeIpiZmclLL72kf11arZb33nuPkydP0qdPH7PJNMrcddddODo6smrVKtauXWtybPXq1fzyyy+4uLgwevRo/X57e3ugYi9STSqbS1U+MDp37hyzZs3SbxcUFAAQHh5Op06dOHbsGB9++KH+uFarZfHixZw8eRIwBIeOjo7ceeedZGdn8/TTT+uzEYLqcZw7dy5RUVH4+vrWSUAphBCNhQwRFEIIC3B2dmbhwoU89thjPPnkk3z22Wf4+fkRERFBdHQ0bdq04emnn6708R4eHsyfP5+nnnqKRx55hF69euHm5sauXbtwcXHB09PTJCmDRqPhnXfeYdKkSSxdupRffvmFjh07kp2dzd69eyktLWXChAn69OtXYtSoUWzfvp01a9Zw880306dPH0pKSti3bx+5ubk8+uij+p67SZMmceDAAX7//XdGjBhBly5dcHZ25uDBg6SmptKqVSteeumlaj+3p6cnv/76K3v27KFz586cOXOGM2fO4Ofnp0/7Xhlvb2/eeOMNnnrqKWbNmsXnn39OcHAwkZGRnDhxAkdHRxYuXGiSUCQ4OBiADz74gH379jFp0iTCw8Ov4LdWuXHjxrFmzRq++eYbdu/eTZs2bUhKSuLgwYPY2toSEBBATEwMSUlJtG3bFoDXXnuN8ePH895777F+/XpCQkI4ffo0Z8+eJTAwkOjoaJPhmzNnzuTYsWNs3bqVG2+8ka5du2JjY8PevXvJycmhR48ePPnkkzX6uoQQorGTHiwhhLCQQYMGsWrVKkaMGMHFixf5888/KSkpYeLEiXz33XcVhoWVN2zYMFasWMGgQYM4deoUO3bsoG/fvqxYsQJHR8cK5UNCQvj555+ZPHky9vb2bNu2jbNnz9KrVy/ef/99s+tnXa4FCxbw+uuvExYWxu7du9m9ezchISG88cYbzJgxQ1/OysqKd999lwULFtChQweOHTvGzp078fT0ZOrUqfzwww9mU4dXpl27dnz++ed4eXnx119/kZOTw4QJE1i1alWlGQaNDRs2jB9//JFbbrmFpKQk/vzzT7KysrjzzjtZs2ZNhXT6d911F6NHj6a4uJitW7dy+vTp6v+Sqql9+/asWLGCAQMGkJKSwpYtW4iLi2PUqFGsWbOGCRMmAKY9XGFhYfz444+MHDmS5ORktmzZgoODA4sXL2bIkCGAaabLZs2a8dVXXzF37lyCgoLYv38/+/btIzg4mNmzZ/PFF1+YfS8JIYSonEYrA6uFEEI0ULt27WLixIlcc801fPnll5aujkVlZmYSFxeHv7+/2eB86tSpbNmyRd+zJYQQonZID5YQQgjRCCQlJTF69GjuuOOOCnPD/v33X/755x9CQkIkuBJCiFomc7CEEEKIRiAkJIQbbriBv/76i+uvv56ePXvSrFkzYmJiOHbsGM7Ozrz22muWrqYQQjR6EmAJIYQQjcT777+vz3x45MgRcnJyaNmyJXfffTcPPfRQlYtMCyGEqBkyB0sIIYQQQgghaojMwRJCCCGEEEKIGiIBlhBCCCGEEELUEAmwhBBCCCGEEKKGSIAlhBBCCCGEEDVEAiwhhBBCCCGEqCESYAkhhBBCCCFEDZEASwghhBBCCCFqiARYQgghhBBCCFFDJMASQgghhBBCiBoiAZYQQgghhBBC1BAJsIQQQgghhBCihkiAJYQQQgghhBA1RAIsIYQQQgghhKghEmAJIYQQQgghRA2RAEsIIYQQQgghaogEWEIIIYQQQghRQyTAaiRiYmIICwvjwoULV3WeXbt2ERYWRnFxsdnjixYtYsKECVf1HPVBSkoK69evt3Q1zFqzZg2DBg2q9PicOXP4v//7vzqskRBCCCGEqC4bS1egsTpbAG8nwIoUyC4FZysY7wEzvSHEvuafz9fXl23bttGiRYurOk+PHj3Ytm0bNjaN+63x1ltvUVRUxIgRIyxdlcv2zDPPWLoKQgghhBCiEtKDVQs2ZEDXCFiWBFmloEX9XJak9m/IqPnntLa2xsvLC2tr66s6j52dHV5eXjVUq/pLq9VaugpXzMXFBRcXF0tXQwghhBBCmCEBVg07WwBjz0FuKRSVO1aE2j/2nCpXk8oPEQwLC+Pnn39m1KhRdOnShXvuuYeoqCh9+YiICMaPH0+3bt0YMmQIP/74I1BxiOCZM2e499576datG1OmTCE9Pd3keffu3cvYsWPp2rUrI0eO5Oeff9YfmzNnDq+++ipPPfUU3bt3Z9CgQaxZs0Z/PC8vj5dffpl+/frRu3dvnn76abKzswEoLCxk/vz59OvXj759+/LEE0+QnJxs9rXv2rWLQYMG8fLLLxMeHs7ixYspKirijTfeYNCgQXTq1IkbbriBb7/9FoDFixfz008/sW7dOgYPHgxAVlYWs2fPJjw8nGuvvZbnnntOX5fy1qxZw1133cWiRYvo2bMn1113HStXrjQp8/333zNkyBB69OjBvffey+HDh/XHBg8ezJtvvsmAAQMYMWJElcMxw8PDGTBgAF9++aXJ77VsiODixYuZMWOG/rX369ePpUuXmj2fEEIIIYSofRJg1bC3E6CotOoyRaWwKKH267JkyRLmzZvH6tWrycjI4J133gEgNTWVyZMn06ZNG3766SdmzJjBiy++yN69e00eX1hYyMMPP0xAQABr1qxh6NChrFq1Sn88KSmJhx9+mFGjRrFu3TqmT5/Oq6++ypYtW/RlVq5cSYcOHVi3bh033XQTL774oj5Ie/7559mxYwdLlixh+fLlnD59mtdffx2Ad955h4MHD7J06VKWL1+OVqvlkUceqbTnKSEhgezsbH766SfGjBnDp59+ypYtW3j//ffZuHEjY8aMYf78+SQkJHD//fczfPhwbrrpJn1gOW/ePNLS0vjmm29YunQp58+fZ+7cuZX+biMiIjh69CgrV67kf//7H6+++ir//PMPAFu2bOG9995j7ty5/PTTTwwaNIhJkyaRmJiof/zatWtZtmwZb7/9ttnhmAkJCZw4cYKVK1cyc+ZM3nrrLbZv3262Lps3b8ba2po1a9bw4IMP8s4773DmzJlK6y6EEEIIIWpP455oU4PeToAXL6r5VFerCPggSd2q4mwFL/qpeVtXYtKkSVxzzTUA3HvvvXz11VcAbNiwAScnJ1544QWsra1p06YN6enplJaavrjt27eTlpbGiy++iJOTEyEhIezatYu0tDQAvvnmG/r27cukSZMACA4O5ty5c3z11Vf6nqHQ0FAeeughAJ544gm+/vprTp8+Tfv27Vm/fj2ffvopvXr1AuCll15i9+7d5OXlsWLFCn744Qc6duwIwJtvvknfvn3Zt2+fvnx5Dz74IEFBQfrnnT9/Pt27dwfg0Ucf5YMPPuD8+fP069cPBwcHiouLadGiBVFRUWzevJmdO3fi5uYGwBtvvMHgwYOJi4vD19fX7PO98cYbeHp6Ehoayu7du/n++++57rrrWLZsGQ8//DBDhw4FYOrUqWzfvp1Vq1Yxffp0AEaNGkX79u0r/dvZ2try2muv0aJFC9q1a8fu3btZuXIl/fv3r1DWxcWFOXPmYG1tzYMPPsinn37K0aNHadu2baXnF0IIIYQQtUMCrGp6O6FmgqvLkV2qnvdKA6yyYAPA2dnZZNhf+/btTeZrjR8/HlDD7cqcOXOGwMBAnJyc9Ps6d+7M1q1bATh37hxbt26lR48e+uNlQUuZwMBAkzqUlTl//jzFxcV06tRJf7xr16507dqVU6dOUVRUxH333WfyegoKCjh//nylAZa/v7/+/tChQ/nvv/94/fXXOXfuHBEREQAVgkiAs2fPotVqueGGGyoci4yMNBtgBQYG4unpafJ7WbFihf5877zzDu+9957+eGFhIT4+Pmbrak5AQIDJ77Fjx44VhiEan8v4b+nk5ERRUfkBqkIIIYQQoi5IgFVNM71rrgerupytrjy4AtULYqxseF35/VUpPyTPeDhbcXExI0eOZNq0aSZlrKwMI0/NPZdWq8XOzq7S5ywpKQFg+fLlFZI5VJUl0d7ekJ5x0aJFfP/999xxxx3ceuutvPDCC/peNXPP5+joaDJ/rExlCT/KD+srKSnRv+6SkhJmz57NgAEDTMo4Ojqaras5xr9DUIFhZX+3y/l7CiGEEEKI2iVzsKpppjdk9QBteNW3qV5wqctdW2C616XPldXj6gKsygQHB3Py5EmT3py5c+ea9LgAtGvXjqioKDIyDGkPy3qCAFq3bs2FCxcIDg7W37Zt26af11SVgIAArK2tTc63fft2brrpJv2xtLQ0/XlbtGjBa6+9RmxsbLVe48qVK3n22WeZNWsWI0eOJC8vDzAEjBqNxuR15ObmUlJSon8+gNdee63SRBfR0dEmx44ePUpYWJj+fPHx8Sa/l88//5zdu3dXq+6gkpbk5OTotw8fPkxISEi1Hy+EEEIIISxDAqwaNtMbbC/xW7W1ghm1EDhV1+jRo8nJyWHBggWcP3+edevW8euvvzJw4ECTcv3798fPz4958+Zx5swZfvzxR37//Xf98XHjxhEREcHbb79NZGQkGzduZOHChXh7X/rFOTs7c/vtt7NgwQIOHjxIREQECxcupF+/fri4uHDnnXfyyiuvsGPHDs6ePcvs2bM5deoUrVq1qtZrdHNz46+//iI6Opq9e/fy9NNPA2qoHqjepIsXL5KQkEBISAgDBw7k6aef5tChQ5w4cYLZs2eTkpJCy5YtzZ4/Ly+P559/nrNnz/LDDz+wceNG/ZDGKVOmsHz5cn766SeioqJYsmQJq1evpk2bNtWqO0BRURFz5szh1KlTrFy5kt9//53JkydX+/FCCCGEEMIyJMCqYSH28GMbcLSq2JNli9r/Y5vaWWy4ulxcXPjkk084fPgwo0ePZsmSJSxYsICePXualLO1teWTTz4hOzub22+/nR9++IFx48bpj/v7+7N06VK2b9/OLbfcwhtvvMHjjz9uUqYqc+fOpUuXLjz44INMmTKFzp07M3v2bEClIr/22muZMWMGY8eOpaCggM8++wwHB4dqnXvBggWcOnWKkSNHMmfOHG6++Wa6d++u7zG79dZbiYqKYvTo0Wi1Wt58802Cg4O5//77GT9+PC1btuTDDz+s9PwtW7bE39+fsWPHsmzZMt5880169+4NwIgRI5g5cyZLlixh5MiRbN68mQ8++IAOHTpUq+4AHTp0wM/Pj7vvvpulS5eyYMECunTpUu3HCyGEEEIIy9BoG/KKq/XY2QKVin15ipq35WwFEzxUz5Ulgytx9dasWcO7777Lv//+a+mqCCGEEEKIekaSXNSSEHtYEqRuQgghhBBCiKZBhggKIYQQQgghRA2RIYJCCCGEEEIIUUOkB0sIIYQQQgghaogEWEIIIYQQQghRQyTAEkIIIYQQQogaIgGWEEIIIYQQQtQQCbCEEEIIIYQQooZIgCWEEEIIIYQQNUQCLFHvTZgwgUWLFl31eQYPHsyqVavMHrtw4QJhYWHExMRc9fNYklar5bvvvqO0tNTSVRFCCCGEaJJkHSxR76Wnp2Nra4uTk9NVnSc1NRVHR0ccHBwqHLtw4QLDhg3jzz//JCAg4Kqex5J2797NhAkTOHbsGDY2NpaujhBCCCFEkyNXYKLec3Nzq5HztGjRokbOU59Je4kQQgghhGXJEMFG5MCBA4wbN45u3brRvXt3HnjgARISEigtLWXgwIH88MMPJuVHjBjBihUrANi7dy9jx46la9eujBw5kp9//llfbs6cOcyePZvbbruNvn37cvLkSc6ePcuDDz5Ijx496NKlC/feey+nT5/WP+bo0aPcdddddO3alXvuuYf33nuPCRMm6I9X9XzlGQ8RnDNnDq+++ipPPfUU3bt3Z9CgQaxZs0ZfNi8vj5dffpl+/frRu3dvnn76abKzswHTIYJFRUW8/PLL9OrVi+uuu46tW7eaPGdWVhazZ88mPDyca6+9lueee05/nl27djFo0CC+//57Bg0aRPfu3Zk5cyb5+fn6x//222+MHDmSbt26MXbsWA4cOKA/9scff+iPjRkzhn///bfS1z548GDefPNNBgwYwIgRIyguLuavv/5izJgxdOnShfDwcJ588kmys7OJiYlh4sSJAHTq1Ildu3YB8P333zNkyBB69OjBvffey+HDhyt9PiGEEEIIcXUkwLoM1iF3XNGt9+hZlZ6z9+hZlT7ucmRnZ/PII4/Qv39/fv31Vz777DNiYmL46KOPsLKyYvjw4WzatElf/tSpU0RGRnLzzTeTlJTEww8/zKhRo1i3bh3Tp0/n1VdfZcuWLfrya9euZfr06Xz66ae0bduWadOm4efnxy+//MLKlSspLS3lzTffBFRw8uCDD9KhQwd++uknbrnlFj755BP9uarzfFVZuXIlHTp0YN26ddx00028+OKLpKenA/D888+zY8cOlixZwvLlyzl9+jSvv/56hXMsXryYv//+m48++oh3332X5cuXmxyfN28eaWlpfPPNNyxdupTz588zd+5c/fGUlBTWr1/Pp59+yuLFi/njjz/0gd6OHTt4+umnGTduHGvXrqVv37488sgjZGdnc+LECWbNmsVDDz3EunXruOuuu3jsscc4fvx4pa937dq1LFu2jLfffpu4uDgef/xx7rnnHjZs2MB7773Hzp07+e677/D19WXx4sUA/Pvvv/To0YMtW7bw3nvvMXfuXH766ScGDRrEpEmTSExMrNbvWgghhBBCXB4ZIthI5OXl8cgjj3D//fej0WgIDAxk2LBh+p6TkSNHct9995GVlYWLiwsbN26kT58+eHp68u6779K3b18mTZoEQHBwMOfOneOrr75i8ODBAHTo0IEbb7wRgNzcXO68807uvfde/byoMWPGsHTpUgDWr1+Pg4MDzz33HDY2NoSEhLB//36SkpIA+Oabby75fFUJDQ3loYceAuCJJ57g66+/5vTp07Rv314f9PTq1QuAl156id27d5s8XqvVsmrVKmbNmkXv3r0B1TP26KOPAhAVFcXmzZvZuXOnfnjiG2+8weDBg4mLiwOguLiYefPmERYWRlhYGAMHDuTIkSMAfPfddwwfPpz77rsPgJkzZ6LVasnMzOSzzz7jjjvu4LbbbgMgKCiIw4cPs3z5chYsWGD29Y4aNYr27dsDEBkZyTPPPMPdd98NQEBAAP379+fMmTNYW1vTvHlzADw8PLCxsWHZsmU8/PDDDB06FICpU6eyfft2Vq1axfTp0y/5uxZCCCGEEJdHAqxGwsvLizFjxvDll19y/Phxzpw5w8mTJ+natSsA3bp1w8fHhy1btnDrrbeyceNGpkyZAsC5c+fYunUrPXr00J+vuLjYZM6SceIHR0dH7r33Xn755ReOHj3KuXPniIiI0AcjJ0+epEOHDiZJFrp3787mzZur/XxVCQwM1N93dnbWP/78+fMUFxfTqVMn/fGuXbvqfwdl0tLSSE1N1QctAJ07d9bfP3v2LFqtlhtuuKHCc0dGRmJlpTp+g4KCTOpRXFysf/ydd96pP2ZlZcXTTz+tP3bq1ClWr16tP15UVFShjsb8/f3191u1aoWdnR0fffQRp0+f5vTp05w5c4aRI0eafezZs2d55513eO+99/T7CgsL8fHxqfT5hBBCCCHElZMAq5FISEjgjjvuoEOHDgwYMIC77rqLv//+m3379unLjBgxgk2bNtGxY0eioqIYNmwYoIKTkSNHMm3aNJNzlgUSAHZ2dvr7OTk5jB07lubNmzN06FBuueUWzp07px8GaG1tXSHZgvF2dZ6vKra2thX2abVakzpWh3GdjIPBkpISHB0dzc4L8/Ly0vdUla9H2fnM1c/43A888AC33367yf6q6m5vb6+/f+LECe69915uuOEGwsPDmTx5Ml999VWVzzd79mwGDBhgst/R0bHSxwghhBBCiCsnAdZlKDm7+tKFLtOetQtr5DybN2/GycmJTz/9VL9v+fLlJkHEyJEjueeeewgNDeXaa6/VDydr3bo1+/btIzg4WF/2m2++ITExkRkzZlR4rt27dxMfH8/atWv1wcS2bdv0z9WuXTv++OMPSkpKsLa2BuDYsWP6x1/u81VXQEAA1tbWREREcM011wCwfft2XnrpJTZs2KAv5+7ujqenJ0eOHNH3dhnPgWrdujW5ubmUlJTQpk0bQKVxf+2113j55ZcvWY/g4GAiIiL021qtlpEjRzJnzhxat25NdHS0yWt///33cXNz0yeoqMovv/xCz549eeedd/T7Lly4oD+fRqMxKd+6dWvi4+NNnu+FF16gT58+lfZ6CSGEEEKIKydJLhoJNzc3EhMT+e+//4iOjuaTTz5h06ZNFBYW6suEhYXh5+fHl19+yYgRI/T7x40bR0REBG+//TaRkZFs3LiRhQsX4u3tXelz5eXlsXnzZmJiYli1ahXffPON/rlGjhxJbm4uCxYs4Ny5c6xatYr169df8fNVl7OzM7fffjsLFizg4MGDREREsHDhQvr162fSO6bRaBg3bhxLlizhv//+4/DhwyaJMEJCQhg4cCBPP/00hw4d4sSJE8yePZuUlBRatmx5yXpMnDiR9evXs2rVKi5cuMBbb71FRkYGPXr0YPLkyWzcuJEvv/ySCxcu8N133/Hxxx+bBEBVcXNz49SpUxw6dIjIyEhef/11jhw5QlFREWDomYqIiKCgoIApU6awfPlyfvrpJ6KioliyZAmrV6/WB45CCCGEEKJmSYDVSAwfPpzRo0fz5JNPcvvtt7Nz507mzp3L+fPnTdKHjxw5ktLSUoYMGaLf5+/vz9KlS9m+fTu33HILb7zxBo8//jjjxo0z+1w9evTgscce45VXXmH06NGsXr2aF154gfT0dC5evIiTkxMff/wx+/btY/To0axZs4ZRo0bph8Fd7vNdjrlz59KlSxcefPBBpkyZQufOnZk9e3aFclOnTmXMmDE89dRTPProo/qkEWXefPNNgoODuf/++xk/fjwtW7bkww8/rFYdwsPDeeWVV1i6dCmjRo1i3759LF26FBcXF7p3785bb73FDz/8wMiRI/nyyy9ZsGAB1113XbXOPWHCBHr27MmUKVO45557iI2N5bHHHtP3mIWGhjJgwADGjRvHP//8w4gRI5g5cyZLlixh5MiRbN68mQ8++IAOHTpU6/mEEEIIIcTl0WhlZVJRw6Kjo0lISNBn8gOVzS8vL89synQhhBBCCCEaC+nBEjUuOztbPxQuNjaWTZs28csvv3DzzTdbumpCCCGEEELUKunBErVi1apVfPrpp8TFxeHn58eDDz5okrpcCCGEEEKIxkgCLCGEEEIIIYSoITJEUAghhBBCCCFqiARYQgghhBBCCFFDJMASQgghhBBCiBoiAZYQQgghhBBC1BAJsIQQQgghhBCihkiAJYQQQgghhBA1RAKsRiImJoawsDAuXLhg9viaNWsYNGhQjT/vnDlz+L//+78aP68QQgghhBANkayD1UjExMQwZMgQNm3aRHBwcIXj+fn55Obm0qJFixp93qysLABcXFxq9LxCCCGEEEI0RDaWroCoGw4ODjg4ONT4eSWwEkIIIYQQwkACrEvQarXs3rOXk6dOk5mZVafP7erqQlhoO/r07oVGo6nWYzZt2sSKFSvIyspixIgRPPfcc9jb27NmzRreffdd/v33X3bt2sWsWbOYPn06H3zwAZmZmQwZMoT58+ebDcLi4uJ47rnn2L9/PzY2NgwZMoRnn30WJycn5syZQ3FxMW+99RaDBw8mNja2wuNPnjwJwPfff88nn3xCamoq7du3Z+7cuXTt2vXqfklCCCGEEELUIzIH6xJ279nLnr376zy4AsjMzGLP3v3s3rO32o9ZtWoV77zzDh9//DHbtm3jww8/NFsuJSWF9evX8+mnn7J48WL++OMP1qxZY7bsyy+/jI2NDatXr+bzzz/nwIEDfPzxxxXK/fjjj2zbto1t27axefNm/P39uf/++wHYsmUL7733HnPnzuWnn35i0KBBTJo0icTExGq/NiGEEEIIIeo7CbAu4eSp05auwmXVYc6cOYSHh9OnTx+eeOIJVq5cabZccXEx8+bNIywsjIEDBzJw4ECOHDlitmxsbCwuLi74+/vTuXNnlixZwm233VahXIsWLfDy8sLLy4t3332Xli1bMnPmTACWLVvGww8/zNChQ2nVqhVTp06lc+fOrFq1qtqvTQghhBBCiPpOhgg2Ml26dNHf79ixI+np6aSmppotGxQUpL/v7OxMcXGx2XIPP/wwc+bM4c8//2TAgAEMGzaMESNGVFqHr7/+mu3bt/Pzzz9jY6PeYmfPnuWdd97hvffe05crLCzEx8fnsl6fEEIIIYQQ9ZkEWJcQFtqOPXv3W7wO1WVlZeiULEsQaWtra7Zs+f2VJZS85ZZb6N+/P3/88Qf//vsvc+fOZdu2bbz++usVyu7fv5+FCxfy4YcfmgRPJSUlzJ49mwEDBpiUd3R0rN4LE0IIIYQQogGQIYKX0Kd3L3r36omra91ny3N1daF3r5706d2r2o85deqU/v7hw4fx8vK66kx/ixYtIj4+nrvuuoslS5bw6quvsn79+grlkpOTeeKJJ3jggQcYOHCgybHWrVsTHx9PcHCw/vb555+ze/fuq6qbEEIIIYQQ9Yn0YF2CRqOhb5/e9O3T29JVqZZXX32V+fPnk5uby/vvv69PMnE1zp07x8svv8zzzz+Pg4MDmzZtolOnTiZlSkpKmDFjBq1atWLChAkkJSXpjzVv3pwpU6Ywb9482rRpQ3h4OGvXrmX16tXcc889V10/IYQQQggh6gsJsBqZ8ePHM336dAoLC7nzzjuZPHnyVZ/zxRdf5OWXX2by5MkUFhbSr18/3n77bZMycXFx+t6o/v37mxz7+uuvGTFiBCkpKSxZsoTExETatGnDBx98QIcOHa66fkIIIYQQQtQXGm1lE2+EEEIIIYQQQlwWmYMlhBBCCCGEEDVEAiwhhBBCCCGEqCESYAkhhBBCCCFEDZEASwghhBBCCCFqiARYQgghhBBCCFFD6jzAKtLCU9HgeRA8DsLUC1BQqo5dKIBhp8DpAHQ4Bhsyqj7XD6nQ9ig47odbz0BikeHYf9kQcgS8DsGnSaaPmxkNX6XU5KsSQgghhBBCCAsEWLNiYE06/NIW1rWFDZnwShxotXDrWfCwgT3tYZIH3HEWzheYP8+eHJgUCc/6wM72kFkCEyMNxx+Lgoe8YGVr+F80JBer/fFF8GcWjG9Ryy9UCCGEEEII0eTU6TpY6cXgfRh+bQs3uqp9XybD92kwyxtGnoHEbuBirY4NPQX9nOBV/4rnmngeSoEVrdV2dCEEHYHTnaCtAzTbD4c6QqgD+B5SAV0fJ3giGno7wniPOnnJQgghhBBCiCakTnuwtmWDoxUMdTHsm+wJG9rBzhzo4WgIrgAGOMOOHPPn2pkDg5wN24F2EGxnKB9kB/tz1bDDtBIIsIXYQvgnC+6V3ishhBBCCCFELajTAOtsgQqCvkuDTscg+Aj8XwwUlkJcEfjZmpb3toWYQvPnMlvexlD+dX+4PxJCjsLTPuBnBwvi1X1rTY2/NCGEEEIIIYTApi6fLKtUzalanAhLgyGrBKZGQbEWckvBvly4Z6+BgkoGMJotb2UoP8YdUpqrBBpuNmoI4X/ZsDgQ5sXCihTo7wyft1K9akIIIYQQQghxteo0tLDRQGapmjc1wBmGN4e3AmBpEthpDNkEyxRoKw9+HKzMlC81Ld/MSgVXAPPjYI4P7MqB71LhWCcV2C1OrLnXJ4QQQgghhGja6jTA8rNVXWYh9oZ9YQ6QrwUfW5Xhz1h8EfiWGwZYxt8W4ovLlS82X/5CgQqs7nJXc7T6Oqm5XkNd1VwuIYQQQgghhKgJdRpgXeMExcCRPMO+iDxwsYJrnOFgHuSUGI5ty1ZZBM3p56SOl4kuhKhC8+VfiYO5PmClAQ0q+yCoHqy6y6EohBBCCCGEaOzqNMBq5wC3NocpkbAvB7ZmwZxYeMgThrioBBiTI+FYHrwRr3qXHvJUjy0sVT1aJbqAaKoXfJuqFhE+kqfWxBruqp7D2LkClU3wTne13ctRZRI8lAs/paveLCGEEEIIIYSoCXW6DhaoxBZPRMPqNDUna5KHyvhnZwVn8uGBC2o4X4g9LAqEYbr1sv7OghtOwfnO0Eo3xPCrFHj+IqQUq3W1PgkCr3JDBKdEwsjmMNbdsO/JaPgiGa5zgW9bg7M1QgghhBBCXLYlHy61dBVqzGPTHrF0FRqFOg+whBBCCCGEaCwkwBLlSYJyIYQQQgghhKghEmAJIYQQQgghRA2RAEsIIYQQQgghaogEWPXI2QKYFgWuB8Bqn/o5LUrtF0IIIYQQQtR/EmDVExsyoGsELEuCrFLQon4uS1L7N2RYuoZCCCGEEEKIS5EAqx44WwBjz0FuKRSVO1aE2j/2nPRkCSGEEEIIUd9JgFUPvJ0ARaVVlykqhUUJdVMfIYQQQgghxJWRAKseWJFSseeqvCJgeUpd1EYIIYQQQghxpSTAqgeyL9F7dbnlhBBCCCGEEJYhAVY94FzNv0J1ywkhhBBCCCEsQy7Z64HxHmB7iTK2wASPuqiNEEIIIYQQ4kpJgFUPzPQG20v9JTQww7tOqiOEEEIIIYS4QhJg1QMh9vBjG3C0qrwnS6tVNyGEEEIIIUT9JQFWPTG8ORzuCA97gauV+sO4WoGntTpeDDwaJUGWEEIIIYQQ9ZkEWPVIiD0sCYKMHlASrn5ubGf4I/2ZBd+kWrSKQgghhBBCiCpIgFXPhTvB/1oatmfEQEqx5eojhBBCCCGEqJwEWA3Ay34QoJuclVwMT8dYtj5CCCGEEEII8yTAagBcrOGDIMP25ynwT5bl6iOEEEIIIYQwTwKsBmK0G9zuZth+5AIUlFqqNkIIIYQQQghz6jzA+i4VNPtMb7edUcceuVDx2LsJlZ/rh1RoexQc98OtZyCxyHDsv2wIOQJeh+DTJNPHzYyGr1Jq/rXVtvcDwUX3FztZAK/HW7Y+QgghhBBCCFM2df2Ex/JgjBt8aDTkzUFjOLbQH8Z7GI65Wps/z54cmBQJHwVBT0d4IhomRqqsewCPRcFDXtDbEW45A2PcwdMG4otUNr43A2rhxdUyfztY4A+PR6vtBfFwdwto72DZegkhhBBCCFEmIyODrdu2Excfj42NLe3ahtCvb29sbGzIzMrir7/+JS4+HhdnZwZcew3BwUGVnuv0mbPs3LmbnNxcAgP8ueH663B0bAZAXFw8m//8i8LCQq7p14dOHTvoH7ftvx14eLSgQ/uwWn+95dV5D1ZEPnRtBj62hpubLsw7ng+9nEyPOVZSw8WJcIc7TPaEro7wdWv4PRPO5KvjJ/LVkLohruBmDecK1P7X4uH/vMFaU+svtVZM9YI+jup+oRYevSBrYwkhhBBCiPqhpKSEX9dvxNramjvG3MawoYM5dz6Snbv2oNVqWb/+dxwc7Llr7O20bx/Kht83k5mZafZcCQmJ/PHnX/Tq1ZOxt99GYWERf/y5RX/8n63b6NSxPTcNG8K/W/8jLy8PgJzcXGJiYgkLbVcnr7m8ug+w8iDMTI9LfBGklpg/Zs7OHBjkbNgOtINgO9iRo7aD7GB/LlwogLQSlYUvtlAlh7i3xdW/Dkux1sAnwVDWsfdPNnzZAIc7CiGEEEKIxichMZGMjEyGDLmBFi3c8ff3o2+fXpw6dZrY2Iukpadzw/WDaNHCnfCePfDx8Sbi+Amz5zp85CghbVrToX0Ynp4eDB1yA1HRMaRnZACQlpZOmzatCQwIwN7ensxMlQVu374D9OjeFSsry6SbqNNnLSyFswXwa4aaOxVyBObEqGQNEXlqvOJzseB/GLpFwJfJlZ8rrgj8bE33edtATKG6/7o/3B8JIUfhaR/ws1ND6p72abi9V2W6OcJT3obt/4uBpKLKywshhBBCCFEX3N3cGDVyOHa2hgt1jUZDQWEh8QkJeHl6Ymdnpz/m6+NDfLz5pAvxCYn4+fnqt11cnHFxcdaXd3FxJikpmcysLAoKCnBydiI7O4eLF+No165tLb3CS6vTOVinC6AYcLKC1W1UsPVENGSVQkddz1U3R7Ww7t/Z8EgUOFnDne4Vz5VbCvblwkN7KyjQDZcb4w4pzVXw5mYD0YUq8cXiQJgXCytSoL8zfN6q8mGI9dkLvvBDGlwoVD1/M2PUMEkhhBBCCCEspVmzZgQGGpIdaLVaDh85SkCAPzm5uTg5OZqUd3RsRnZOjtlz5ebm4uTkZFq+mSPZ2ar8Nf36svmPLZSUlNArvAfOTk788+9WevToZrHeK6jjAKtTM0juBh66Z+3mCFrg3vOQ00MN3WuhO9bVEU7nw0dJ5gMsB6uKacoLSk2DpWZW6gYwPw7m+MCuHJXJ8FgnmBKp5nLN9qnpV1r7nKxVgo8RugyMy1NhogcMdbVsvYQQQgghhCiz7b/tJCencOfYMRw8eBhra9MMdtbW1pSUlJh9bHFxsZnyVvryIW1aE3z/JEpKSrC3tycrK5u4uAQGDRzAjp27OHnqDL4+3gy+4TpsbW3NPUWtqPPQzqNcSNfBAYq0kFxsCK6Mj8UWmj+Pvy3EF5vuiy8GXzO/uwsFKrC6y13N0errpBbvHeqq5nI1VMObw91GweejUZAna2MJIYQQQggL02q1/Lv1P44cjWDYjUPwaNECG5uKwVRJSQk2Nub7fMwFXyUlpdjaGsrb2Nhgb28PwN59++nZszvxCQmcOn2WcffcSWlpKYePHKvhV1e1Og2w1qSB9yE1F6vMgVyV5e+teJVO3diBvMpTkPdzgm3Zhu3oQogqVPvLeyUO5vqAlQY0QNnTF2sbfga+dwOhuS6wP1ugeuqEEEIIIYSwFK1Wy59//c3RYxHcdOMQ2rRuBYCTkxO5uXkmZXNzc3FydDRzlrLyuRXKO5opn5mVRUJiIu3ahhAfn4iPd0vs7OwIDAggIaGKhXVrQZ0GWNe5qCGBD0fBqXz4LQNmxcIsbxjlBhsy4P1EFSgsSYSvU2CWbvheYanKNFiiC4imesG3qWoR4SN5ak2s4a7QrlxAdq5AZRMsG2bYy1FlEjyUCz+lq96shszHFt7wN2y/Ea/WExNCCNFwnS2AaVHgegCs9qmf06LUfiGEqO+2/beDU6fOMPzmYYSEtNHv9/H2Jjk5maIiQ3a2uLh4vL29zZ0GH++WxMXF67ezsrLJys7Gx0z5vXv3E96zBxqNBo1GBXkApdpS6ro/pU4DLA8b+L2dGrLX8zg8fAEe9VS9S9e7wHet4ZMk6HQMPkxS2wN0qdi354DvYdVTBXCNM3waDK/GwzUnVC/OV60qPucrcTDPFzS6zIEDXdRcr0EnVbKNx1vWyUuvVQ95Qn9doFiM+r2WNvCeOSGEaKo2ZEDXCFiWpJJAaVE/lyWp/RsyLF1DIYSoXHx8AocOH6Fvn160bOlFTm6u/ubn54uLiwt/bPmblNRU9u0/SHxCon6B4JKSEnJycyktVePNOnfuyKnTZzgWcZzklBT+2PIXwUGBuLk1N3nOjIxMkpKSaasL5lp6eRF7MY7k5BTOnTuPd8u6veDXaLUNfZCcADiaBz0iVIAFsDQIHvayaJWEEEJcprMFKojKrWI+raMVHO4IIfZ1Vy8hROWWfLjU0lWoMY9Ne+Sqz7Htvx0cPHTY7LFpjz5EZlYWW/76h4SERJq7ujLg2msICgoEICb2Ij//so6J48fh6uoCwPETJ9m9ey/5+fkEBgZww/WDaNasmcl5/9jyF62Cg/UBFsDWbf9x/MQp/Px8GXbjEJO08bVNAqxG5JlYtdYXqB69E53UEEIhhBANw7Qo1VNV1dKGtqgGtCVBdVUrIURVJMAS5TXAFaBEZZ71NbRoZpTAjGjL1kcIIcTlWZFSdXAF6vjylLqojRBCiCshAVYj0swKPjZq0VyZBhtlrL4QQjQY2dVcaqO65YQQQtQ9CbAamaGuML6FYXtqFOSYX7tNCCFEPaLVgr2memWd5dtbCCHqLfmIboTeDoAWurWxIgvhZVkbSwgh6rWsEpgYCfnVmBVtC0zwqO0aCSGEuFISYDVCLW1hYYBh++0Ete6XEEKI+udgLvQ6DitSq1fe1gpmmF8yRgghRD0gAVYjNcUDBunWECtBrY1VIvkihRCi3tBq4cNE6HcCThktIHyjCzhqVE+VOa/4Sop2IYSozyTAaqQ0GlgaDHa68fy7c+HjJMvWSQghhJJeDHeeg+nRUKBr/HKygq9bwaZQONxJpWJ3tVJf1DZGj/0uTRaTF0KI+kwCrEasvQPM9TFsz42F2ELL1UeI6jhboNYCcj0AVvvUz2lRar8QjcGuHOhxHFanG/Z1awb7OhjmVoXYq3WuMnpASTic7gwOugazvbnwlaRpF0KIeksCrEZurg+E6oaSZJXCE7I2lqjHNmRA1wi10GpWKWhRP5clqf0bZNkB0YCVauGteBhwQiUgKjPNC3a2hzCHyh/byh5mlWswy5QMsUIIUS9JgNXI2VupoYJlVqfDunRL1UaIyp0tgLHnILe04kKrRaj9Y89JT5ZomJKLYdQZmBULxbp9za3hxzbwQRA4VOPbeLY3BOgmZiUUw6uSIVYIIeolCbCagOtdVNKLMtOjIFtaPkU983YCFF1i8dSiUliUUDf1EaKm/JMF3SJgfaZhXx9HONAB7nCv/nmcrOFNowyx7ybCqfyaq6cQQoiaIQFWE7EwADx1s6Sji+D5i5atjxDlrUip2HNVXhGwXOaeiAaiRAsvX4TBp+Ci0Zv7/7xhaxi0voJMgPe4w7VO6n6RFp6KqZm6CiGEqDkSYDURHjbwjlHL53uJsC/HcvURorzsS/ReXW45ISwprghuPA0vxEHZW9bDGn5rqxq87K7w21ejgfeDQJfvgt8yZG6iEELUNxJgNSHjW8AQF3W/FHg4Cool1a+oJ5yr+WlU3XJCWMrvGWpI4F9Zhn2DnOFQRxjR/OrP39MRHvA0bM+IhkJpeBBCiHpDLlWaEI0GPg4Ce13T5/5cWJJo2ToJUWa8R+ULq5axxZDGWoj6pkirsvvdfAaSdJksNMDzvvBnKPjb1dxzzfdTa2QBnCyAD2SdQyGEqDckwGpi2jrAc76G7WcvQpSsjSXqgZneYHuJTyRbK5jhXTf1EeJyXCiA607C6/GGfT428Ec7eMkPbDSVP/ZKtLSFF/wM2y9ehMRLTWIUQghRJyTAaoJmeUNH3XorOaXwWBRoZaigsLAQe3jJt+oyX7dS5YSoT35Oh+7HYYfRvNZhrmpI4GDX2nvex7wgTPf/kFkKz0jyIiGEqBckwGqC7MqtjbUuA35Kt1h1hNDbm2u4b6tRH1DGDf9H8uq6RkJUrkC3ePuYs5CuW/rCGnjdHza0Vb1MtcnOChYFGrY/S1ZDv4UQQlhWnQdY36WCZp/p7bYz6tiFAhh2CpwOQIdjl86M9EMqtD0Kjvvh1jOmwyP+y4aQI+B1CD4tNzZ9ZjR81cRTPQ9whoeNJkk/Hg0ZsjaWsKC4IlidZtje0x5KwlWvVZm3EyBJhkGJeuBMPvQ/Ce8bzWMNsoN/w2C2D1jV8JDAygxvDiN1iTO0wP9kRIIQQlhcnQdYx/JgjBvEdTXcvmylvhBuPavSie9pD5M84I6zcL7A/Hn25MCkSHjWB3a2h8wSmBhpOP5YFDzkBStbw/+iIVk34Ti+CP7MUhn1mrrX/cFbtzbWxSJ4Ntay9RFN2ydJoPs3ZYAzdHNU9+9tAZ10Q1qzS03nuAhhCd+lQs/jpr1Ft7mphYP7O9d9fd4JUD2+AP/lwMq0qssLIYSoXXUeYEXkQ9dm4GNruLnZqHS2J/Phk2Do2Azm+Kgvqs+SzZ9ncSLc4Q6TPaGrI3zdGn7PVK2KACfy4XY3GOIKbtZwTheovRavFnm0rqPWxfrM3QbeNRpe8kES7JK1sYQFFJbCx0Y9zY95Ge5ba+BVf8P2B0kQI4lZhAXklsJDF2DcecjSpUW308D7gbCmDbSwsUy9Qh3giZaG7adjIEdGJAghhMXUfYCVB2EOFffvzIEejuBibdg3wNl00nD58oOMWgoD7SDYzlA+yE61Ll4ogLQSCLCF2EL4J0u1iAvlbne4WTcJWws8fEGlGhaiLv2UDvG67isfG9XLbezW5tBH16NVoIWX4+qydkKo0Rd9jsMyo0a/tvawoz083lItg2FJz/lCS12AF1MEbyRYtj5CCNGU1WmAVVgKZwvg1ww1dyrkCMyJUROF44rAr9yEYG/byluqzZa3MZR/3R/uj4SQo/C0D/jZwYJ4dV96rww0GvgwCJrpfieH8+Bd+WIWdcx4DZ9HvNTkfWMaDSww6sX6PBlO59dN3UTTptWq91vv43DM6D13rzvs66AW/a0PXK3hNaP/kYXxEFnJEHshhBC1q04DrNMFao6FkxWsbgMLA+CbVHgqRg29sC9XG3uNaq02x2x5K0P5Me6Q0h2Su8HLfhBdqBJf3OMO82Ih6DDcc06dp6lrbQ8vGq2n8sLFyue+CVHTDufC1mx13wbT5CvGhrjCYBd1vwT1PhWiNmWVwPhIeOAC5Om+W5ppYFkwfNNaBTX1yWQPCNcFfPlamBVj2foIIURTVacBVqdmKuD5JFhNYL/dXc0B+jQZHKxUT5axAi04VlJDs+VLTcs3s1LzuwDmx6l5Xbty1ATlY52gWKvmcgm1eGvXZup+nhamSSYqUUeMe69ud1e9zZUx7sX6Lg0OSUpqUUv256pEFt+mGvZ1dIA9HeABT8sPCTTHSjcfrMyP6Wp+sxBCiLpV53OwPMpNAu7goOb8+NmqDH/G4ovAt5J1RPxtDXM29OWLzZe/UKACq7vc1Rytvk5qrtdQVzWXS6gMVJ8EG9Yc2pgJP0gmKlHL0ophhdEFrHFyC3P6Oqn5WGWelV4sUcO0WliSCNecgDNGPfkPeKjgqlMzy9WtOvo7w31G84yfjFaNiUIIIepOnQZYa9LA+5Cai1XmQK7K8tfPCQ7mmWY+2pat9pvTz0kdLxNdCFGF5su/EgdzdeuSaICypy/WSi+Nsb5OMM3oAveJaHUBLERt+TLFMEy3azOV2OZSXvU3NAT8mgHbs6ssLkS1pRXDHefUuoCFuu8GZys1HHBZq8pHVNQ3b/gb6no4T40SEUIIUXfq9OviOhddprooOJUPv2XArFiY5Q3Xu6gsgJMjVbamN+JV79JDuvkYhaWqR6tE96U31UsN3fg0CY7kqTWxhrtCu3IZCs8VqKEed7qr7V6OKpPgoVyVuaxvJQFcU7XA35A8JKEY5sraWKKWlGrhw3Kp2asz7KpzM9MW+nmx0lAirt6ObOhxXH0vlOnRDPZ3gHENLPOsvx3M8zFsPxcLqdJYJoQQdaZOAywPG/i9nRqy1/O4Sgn+qKfqXbLWwC8hkFgM4cfh6xT4KQRa2avHbs8B38OqpwrgGmf4NBhejVdDOZpbw1etKj7nK3Ewz9dw4TbQRaVpH3RSJdt4vGXFxzRlrtaw2GgM/9JklRxEiJq2KdMwBKu59eVdxL7opxJiAPyTDZtlnom4QqVaeDMeBp6EC0ZZax/3UinYyzfaNRQzvaGVbj5jSgm8KMNphRCizmi0Wmn7Faa0Wrj1LKzLUNsdHeBAh4qps4W4GrecUb3YADNawjuBVZcvb+oF+Fg39CncEfa0r5+JB0T9lVgEEyPVIvVl3Kzhi1Zwm5uFKlWD1qSpIY8A1sDBjqoHWAhRs5Z8uNTSVagxj017xNJVaBTkkllUoNHAkiDVwwcQkQ9vydpYogadK4D1GYbtaZdIbmHOc77goAuo9uXCmvQaqZpoIv7Ogu7HTYOrfk5wsEPjCK5ALdhtvLTBk9EynFYIIeqCzaWLiKYoyA5e8VNrlAG8HKeyMLZtoMNlRP3yUZKajwlws+uVva/87NQQ34W64P/Zi+rCWBYSF1Up0aqh46/EGRIeAcz2hlf8VUbVxkKjgfcCoVuEeq1/ZsEvGY0ngBRC1H8lJSV8v2o1A6/tT2BgALt272XP3n1my1bWe7bi25Wkp2eY7Lv7rjvw8vQkLS2NjZv+IDs7m65dutC3Ty99mUOHj1JQkE+f3r3Kn7LWSYAlKvV4S5VCe3+uWpPs0SjY3E6GYYmrk1sKnxllNXvsKuZBzvaBpUmQWQon8tX7dZLH1ddRNE6xhXDfeTVvr4yXDXzdCm5uXunDGrTOzVRSqLL15p6KVo0aDjJ+RQhRy4qLi9m0+U9SUw3r/vTo0Y3OnTvqt0uKi1nz01ratg0xe46SkhIyMjK5Y8ytuDZ31e9v5qBaZnfs3I2fny8d2ofx8y+/EtKmNZ6eHhQXF3MsIoI7xtxaS6+uavIRKyplo4FPggxvkj+z4JvUKh8ixCWtTIU03XIMbezUxd6V8rCB/zPKlvbCxYoLkAsBsCFDDQk0Dq5ucFFDAhtrcFXmZT9oYa3uny+ERTLkWwhRy1JT0/hx9c9kZGaa7LeztcXJ0VF/O3zkGLZ2tlzTr4/Z86SlpaPRaGjZ0svkcVZWVvrjrYODaenlhbu7G2np6QAcPRZBu7Ztsbe3r9XXWRkJsESVwp3gf0Y9DDNiIEXS/YorpNXC4kTD9lSvqx/S92RL8NT1xV8olDV/hKkiLTwdAyPOQLLus8sKeMlX9cj72Vm0enWihY0KssrMj1e9eUIIUVtiL17E39+PsbffVmmZzMwsDh85yoD+12BtbW22TGpaGq6uLpUed3ZxJik5mYKCAjIzM3FxdqaoqIhjEcfp1rVzTbyUKyIBlrikV/wgULc2VnKxulgR4krsyFELioNKUHG/59Wf08XadM2fV+NMFywXTVdkgVqSY6FRj42fLWwJhef9mtZ8vUe8oIsug2BOqaxxKISoXV06d2LggP7Y2tpWWubAwUN4eXoSHBxUaZm0tDQ0Gg1rf13P5198zZqf1xKfYPhQ79MrnP0HDrHs868ICgrCx8ebI0ePERbaDjs7y7WgSYAlLsnZGj4weu9/nqIWaxbicn1gtLDwfS1Uy3pNmOoFAUYLZL+fWHV50fitSVMLB+/MMewb7qqGBF7nYrl6WYqNBt4NMGwvT4WdssahEMJCioqKOHnqNN27damyXGpaOgUFhXTp3JFbbhlOC3d3fv7lVzIz1YWor68P90+ewP1TJnLjkBsoKiri+PGTdO3SmcNHjvLV8m9Yu+43cnPz6uJl6UmAJapllBvc7mbYfuSCzHURlye+CFYZ5rkyvQYX+XawgheMhkC9mQBpMpS1Scovhcej1PpP6bqeTBtgoT/82ha8Km9MbfQGu5p+jv8vWi20LIQQde1CVDRarZY2bVpXWW7Y0MGMH3c3rVu1oqWXF9cNGkBzV1dOnDylL2Ntba1PenH4yFHatw+lsLCQnbv2MPaOMbi3cGf3nr21+nrKkwBLVNv7geCie8ecLIDX4y1bH9GwfJqs5sMA9HeCHo41e/7JHtBON5c1vUTWbmuKTuXDNSdgiVFPabAdbGuvkqFYNaEhgZV5KwDsdb+HPbnwdYpl6yOEaJqioqJpFRxU6dyqMtbW1iZD/TQaDe7ubuTk5FQoW1hYyPETp+jSpTMJCYm4u7vh5OhIUGCAybDCuiABlqg2fzt4zd+wvSBepcYW4lKKtCqdepmrSc1eGRuNmi9Y5t1E1WsmmoZvUiD8uGGOH6jemgMdoK+TxapV77S2h1nehu05sZApcxaFEHUsPiEBfz+/S5b74cc17Nt/UL+t1WpJTknF3d2tQtlDh4/SsUMYdra2oNGg1a2sXlqqNSy+WUckwBKX5VEvw8VKoRYevaAywwlRlV/SIVYX7HjbwB1utfM8d7pDN91E/txSWBBXO88j6o+cErg/EsZHQrZu2LKdBj4IhB/bgLus9ljBHB/wN5qzOF/+T4QQdai0tJT09AxatHA3eywnN5eSEtXy0yo4mAMHDxF5IYq0tHT+/mcrBQX5dGgfZvK4goICTp46RZfOnQDw8vQkNTWNuLh4zpw5i7d3LbTsVkECLHFZrHVrY5V16P6TDV/KEBNxCUuMkk487AV2tfTJY6WB+Ua9rB8nw4WC2nkuYXlH86D3CfjC6DMo1B52tYdpLWVR9Mo4WcObRgkvFiXCaRmNIISoI/n5+ZSWlmLvUHGNquzsHL74cjlx8WpIX6/wHnTp3JG//9nKyh9+JD09g1tH31JhfatDh4/QsUMHfdZCV1cX+vQO59f1G8nMyqJP7/Daf2FGNFqt9D+Iyzc7RiUSALWA5YlOTXvyuKjc0TzoEqHuWwMXuqjhprVFq4WBJ+E/3fDsyR7wRavaez5R97RaWJaskjTkG32DjW8BHwap1P2ialotDDgJ23X/J7c0h3VtLVsnIRqqJR8utXQVasxj0x6xdBUaBenBElfkeV9opbtITi2BmbI2lqjEB0a9V2Pcaje4AtVrscCoF+vrFDhet9lZRS3KLIFx5+HhKENw5WgFXwTD160kuKoujUYlLirr5Ps1AzZmWLRKQgjRaEiAJa6Ik7VqKS6zPBX+yLRcfUT9lFGi3htlaiO5hTmDXOAmV3W/FHj+Yt08r6gZZwtgWhS4HgCrferntCj4JQ16HoeVRun+OzvAnvYw2VOGBF6ucCe438OwPSPGkOlTCCHElZMAS1yx4c3hbqP5iY9GQZ6sjSWMfJUCObr3RGcHGORcd8893yg50Y/psK9iRldRD23IgK4RsCwJskpV4qesUpWF8rZzKvgq87An7O4AHZtZrLoN3nx/cNVdCZzIN50vKYQQ4spIgCWuyruB4KYbknO2QLJRCYNSrenwwOl1nHQg3AnGuhm2n5FerHrvbAGMPacyQJbPsG/cduOkgZWtYWkwNJNvsavibQvPGzVGvBQHibK8gRBCXBX5ahJXxccW3jCa7/JGPByT+S4C+CMLTul6G1ytVAKCuvayn+FD7vdM+Cer7usgqu/tBCiqRi/4be5wtwXeT43V414q+yKoYb3PSmOEEEJcFQmwxFV70BOu1a2NVQw8fEH1Xoimzbj3aoonOFsg+UCHZjDJaI7JvFhZt60+W5FSsefKnHXptV2TpsXOChYFGraXJcOBXMvVRwghGjqLBlgPXYDrTxq2bzoNmn2mt5/TK3/84kQIOAwuB2BKpFpwssyaNPA9BIGHK34Zjz0rLdk1yUqjhurY6oZ/bc9RX9Ci6YosgHVGGcmmeVmuLi/4mr4310sylnoru5pzOKtbTlTfiOYwQpcYRotKgS+NEUIIcWUsFmD9mVnxIvxYnhpXH9fVcBvuav7xa9Lg2ViVye6vUNiTY0gVXqJVvShvBah0zVMiDV8UB3MhvQSuc6m1l9YkdWoGT3sbtp+OhXgZx99kfZSkLtIAhrlCqIPl6hJsD496GrafiZUe1vrKuZrfSNUtJy7PO4Fgo7u/LRu+T6uyuBBCiEpY5Gsqp0QFQGXDykCtbRJbBH2d1Lyespt9JTV8NxEebwmj3aCXE3wcDF+mQHYJJBdDSgnc6Q53uav7ScXqcS9ehBf9zJ9TXJ1nfKGt0Tj+GdGWrY+wjLxS+Myo8eQxC/ZelXnGV62VBHAoD36QC8d6abyHWoy6KrbABI9LFBJXJMwBnjBqKJsVoxKOCCGEuDwWCbCeuQjXu6hbmYg8cNBAUDUWIS3Rqh6rQUaP7+cExVo1btzTRl1M7c+FfbngZAUeNipNc24pDKjDVNFNSTMr+NhobayVabJwZVP0fapq1AAItlNDjyzN2xaeNFqD67mLst5PfXRrcyi5RBlbK5jhfYlC4oo95wstdd1YMUUqcZEQQojLU+cB1o5sWJWmhu8Zi8hX6b7vOa/mTvU5DusruThPL4F8LfjZGvbZaFQQFVME1hqV2W7gSbj+FLwToPa9ECe9V7VtiCtMMMruNTXKdG6caNy0WliSZNie5qX+9+qD//M2LClwpkCt0SXqj9xS+L+Yyo/bohrOfmwDIfZ1Vq0mp7m1Glpf5s14uFBQeXkhhBAV1WmAVVAKD1xQaye525geO56vJi6Pbg4b26lW71FnYJeZxUHLhizYl7tws9eo5wB4rCWkdofUbvCwF+zOUS3WfZzgwUiV/GJ6lMzFqA1vB0AL3YVsZCG8LGtjNRm7db3GoHqkH/CsunxdcreB2T6G7ZcuQr4Mf6o3/hcFR/PVfTvUIuauVupLytVKfY4f7qgWOBe1a4oHhDuq+/lamBVr2foIIURDU6cB1stx0M5ezY0q73V/iO6ixuB3c1Q9TSOaw9KkimUddIFVQbngqEBrmGcB4GJtSA39wkV4yVf1nh3Lh5OdYW+O2hY1y8vWtIfy7QQ4JCl/m4QlRqnZ72mhepXrk8e9wNto+NNHZj5fRN37JgU+M+pR/CAYVraBjB5QEq5+LgmSnqu6YqWB94zStq9Kg78l864QQlRbnQZY36aqxT6dD6jbmwmwNVvdt9aAW7mLsQ4OKvFFeR42KsgyzlJXrIWUYvC1rVh+e7b62c9ZDVG8zlkFYje4wE4zPWTi6k32UL9nUHMqHr6g5s6JxiuxyDR5RH1IblGekzU862vYXhAPWTKE1aJO5sMjUYbtcS3gAUliYXHXOqu/RZknouUzXAghqqtOA6y/Q+FoRzjYQd0e8oRejur+2LMwLcq0/IFcaG8mvbOVBno7qTSyZXZkq3lYPRwrln/BKHOgRgNlo4KKMaSSFjVLo1sby07X27g7Fz6W3oJGbVkyFOr+ofo5QbhT1eUt5WFPaKVLppNcDIsSLFufpiyvFO46Bzm6D+VQe5UoR1NP5u01dW/4G0aFHM6DT2V9QyGEqJY6DbCC7aGtg+Hmbq0yz7V1UOnWP09WvVyn81VQtC0b/qfL/JVXatpjNc1LDT1bk6aG+k2Lgvs9DUMCy/ybpS7y++ou9no5wm8Zas2tDRmG/aLmhTnAPKM5L3NjIbbQcvURtadYazrcbno97L0qY2dlmuzmrQTV+y3q3pPR6sId1BzaH9qood2ifgiwg7lGn+HPxkKa/K8IIcQl1ZvlGid6qHk7z1+ELhEqg+Dv7Qxj7r9PBd/DhvL3tFBDfaZGwdDTai2stwMqnvfFcpkD72kBXZtB/xMq4cVdZuaDiZozxwfCdH/DrFI1zEQ0PmvT1ZwmAC8b8/Ms65PxLdQQZFDvS0lFXfdWpsInRj0i7wWq+beifpnpbejxTSlR36lCCCGqptFqtTJKTtSqf7JUuvwya0NglJvFqiNqwZBTsEU3Cf4ZH3jVv+ry9cGaNLjjnLrvoIEzncG/Guvwiat3Oh96HleZY0FlDPyutQwNrK9Wp8FY3f+KNXCoI3RqZtEqCVGvLPlwqaWrUGMem/aIpavQKNSbHizReF3nAvcbTVqfHgXZklig0YjIMwRXVsAj9Xh4oLExbqapqF+Vlvk6ka+bd1UWXLW1h0+CJbiqz253U0mhQCUtmhGt1rwTQghhngRYok68GQCeuiyR0UVqKKhoHD4wmnt1mxsENpBeII3GdEHVZclwVhZUrXVPxcBB3bwrO928K1eZd1WvaTTwboDhgmFzFqzNsGiVhBCiXpMAS9QJDxtYZDRH7r1E2Ccp8hu8zBL42mj9osdaWq4uV+JGF7het5xAMSq5jqg9P6SaJkNZFGA+86uof7o6wqNGvdNPRctC3UIIURkJsESdua8FDNUNMykFHo5S2edEw/V1imGoV0cHQ7DSUGg0MN+oF+vbVDiSZ7n6NGZnC+DBC4btsW4wtYEMJxXKy34q+y/AuUJ4N7Hq8kII0VRJgCXqjEYDHwWphAIA+3NhiXxBN1harenwwOleDXMeTX9nuKW5uq8Fnou1aHUapQLdvKssXTDexg6WtWqY75emzMNGBVllXo2Di7L0hhBCVCABlqhTbR3gOV/D9rMXIUq+oBukLVlwIl/dd7GCCR5Vl6/P5htdNP6SATuzKy8rLt+sGNWgAmCrge/bQHOZd9UgPeoFnXVLHOSUwhxpkBBCiAokwBJ17v+8oZPRF/RjUZKRqiFaYtR7NcmjYS8Q29UR7jVau+sZmYtVY1anwWKj98pbAWrdQtEw2Wjg3UDD9vJUaZAQQojyJMASdc7OCpYGG7bXZcBP6RarjrgCUYVqceEy0xtYcgtzXvJTa/yA6p37M9Oi1WkUzhXAA0bzrsa4weMy76rBG+Kq/pZl/hcNpdJIJoQQehJgCYu41hke8TRsPx4NGbI2VoPxcZJKVAIqcUl7B4tWp0a0c4AHjN6T82KlZ/VqFJbCPecM/9et7OBzWe+q0XgrAOx1f8s9uaonSwghhCIBlrCY1/3BW7c21sUieFbG8jcI+aXwabJhuzH0XpV5ztdw0bg7V83HEldmdqy68AbDvCs3G8vWSdScNvYw09uwPScGsqSRTAghAAmwhAW52cB7RmP5P0iCXbI2Vr33QxokF6v7QXaGDHyNQYCdyoZY5tlYKJFerMv2c7ppCu83/KGPzLtqdOb6gJ+tuh9frLIKCiGEkABLWNhd7jDcVd3XAg9fgCK5oK3XPjC6cJ7qpSa9NyZzfcFZ98l4LF+tjSWqL7IApkQatkc3hycbUS+nMHC2hjeN1pFblAin8y1XHyGEqC9kwIawKI0GPgiCTscgTwuH8+DdBJjlY+maCXN256ihcwB2GnigAadmr4ynjRr69JKuNf6Fi3C3u0rOIqpWWAr3nId03VCxIDv4opXMu2rMxrVQow925KjGsZkxsLatpWslhKgvSkpK+H7VagZe25/AwAAA9u47wM5du03KdevamYEDrjV7jpjYWLZu3U5GZiYtW3ox+IbrcGuuhs+kpaWxcdMfZGdn07VLF/r26aV/3KHDRykoyKdP715mz1ub5JJBWFxre5XBrczcWHA5AFb7wPUATIuCswWWq58wMO69uscdvGwtV5fa9JQ3eOhSCp4vhM9SLFufhmLeRcMwXxvg+9bQQprxGjWNBt43Guq9LgN+l7mLQgiguLiY3zf9QWpqmsn+1NRUunbpzJTJE/S3vn16mz1HVlY2v63/nbCwdtw19nacHB1Zv/53tLosVDt27sbPz5dbR9/CocNHSE5O0T/3sYgIunXtUrsvshISYIl64UlvaG2n7pcA2aVqyGBWKSxLgq4RsEG+tC0qqQi+N/qMfKwRD/tytVZDBcu8Ege5pZWXF7AuHd5OMGy/5g/9nC1WHVGHejnBFKPe7BkxMtS7JpwtUA2MrtLgKBqg1NQ0flz9MxmZFdc8SUtLx8vLEydHR/3Nzs7O7Hkijh/H08ODnj2606KFO4NvuI6s7GxiYmL152odHExLLy/c3d1IS08H4OixCNq1bYu9vX2tvcaqSIAl6oWoQogrMn+sCHVxO/acfLFY0mcpUKC7aOrtCL0bedKCaV6GCfxxRbAkseryTVlUIUyKNGyPbK56AUXTscAfXHRXFMfzTXu7xeXbkKEaFpclqYZGaXAUDU3sxYv4+/sx9vbbTPZrtVrS0tNxc6tehqz4+ET8/AzzRmxtbfHy8iQ+QbXoObs4k5ScTEFBAZmZmbg4O1NUVMSxiON069q5xl7P5ZIAS9QLbydcOltbUSksSqi6jKgdJVr4KMmw3Zh7r8o0s4LnjXqxXo+XtdrMKdKq9a7SdL+bAFv4qhVYybyrJsXH1vT/5cU41estLt/ZAtWgmFuqGhiNSYOjaCi6dO7EwAH9sbU1nUuQmZlFcXExEREn+Orrb/jm2+/Zf+CgfshfeTm5uTg5mbboOjZrRna2Go/ep1c4+w8cYtnnXxEUFISPjzdHjh4jLLRdpb1idUECLFEvrEip+EVSXhGwXObCWMSvGaqXAlQSiLvcLVufunK/J4ToRheklcBb8ZatT330bKxKcABgjVrvykPmXTVJ/2sJ7XT/Lxkl8OxFy9anoXo7QTUoViW/FCaeV1lO/8qCE/mQWSKLo4v6Ly1NzTVwcnJi5Mib6dmzO3v3HeDAwUNmyxcXF2NtbW2yz9rampIS1arn6+vD/ZMncP+Uidw45AaKioo4fvwkXbt05vCRo3y1/BvWrvuN3Ny82n1h5cjXoKgXsqs5v6W65UTNMh4e96AnODSRphlbDbzsB/edV9uLEuHxltCykSb3uFzrM+BNo17l+f7QX+ZdNVl2VrAoEG45o7Y/TYZHvaCHo2Xr1dBUp8GxFNieA9vPm+53tAJfW8PNz9Z0u2yfu7Vk9xSW0apVMA/cP4lmDg4AeHp4kJ+fz5Gjx+jZo3uF8jZGwVSZkpISHHSPBxVwNdMFYYePHKV9+1AKCwvZuWsP9427m/0HDrJ7z16uv25g7b2w8vWus2cy46ELas2Mv8PU9qFceDRK/ezQDD4Oqnqex+JEeEM3bGesOywJBCddkLsmDaZHqTV6PgyCUW6Gx409qy6SrnOptZcmLpOzlRpfXp1yom6dyIc/stR9K+BRT4tWp87d466GBx7Jg5xSeC1eXUQ2dTGFqgW9zHBXmCXzrpq8Ea5wsytszFTzhp6Ihn9C5WK+urZlV++7sDK5pWro4KWGD9pr1LDOqoIwX1s1YkGG+4qa1swoOAJwd3cnJyfXbFknJydyc02P5ebl4eHRokLZwsJCjp84xV133k50VDTu7m44OToSFBjAjp27K5SvTRYLsP7MhGXJcJ2utTOnBIafUevNfB4MS5Nh5Bk42xlcrCs+fk2aGpqyvLX6IJgcqdbf+DhYzRd5+AK8F6haeaZEQlI39QF/MFet0SLBVf0y3kNN3q2q1c4WmNAI112q7z406r0a7QbBlknIYzFWGpjvB6PPqu0Pk2CGt1rjqakq1sK95yFF16joJ/OuhI5Goxog/jgGxcDWbPghDe6ueC0kjOzMhucvwuas6j/GTqMW8o4rgotF6md+NYcIFmjhQqG6VcUG8K5GINbStnYWnT9boIZMrkhRI1icrdT1wkxvw/Bt0bAcOnSEiOMnuPeeO/X7kpOSK0164ePTktiLcfrtoqIikpKS6RXes+K5Dx+lY4cw7GxtQaPRz+sqLdWqFp86ZJEAK6dEBUDXGvVOfZ+mhuO8HaC+pBcFwG8Zav+DZlrM39UN1RntprY/Doahp+CtANXKnFICd7qr3+fESEgqVh8AL16EF/0qnk9Y1kxv+Cql6nHnpcCTTSC5Qn2SVQJfGs17m+5lubpY0i3NoZ8T7MyBQi28fBGWtbJ0rSzn+YuqpR1Ur+bK1o13TTRx+do7qPlY7+gaZ2bFqFEkjjICoYJ9Oer/aX3FTNZVsgUe8oQlQYZ9Wq0a0RNXZBp0Gd/K9lV3uH0xEFukblWxArxsKgnC7Az3fWyqv2j7hgyVzKPIKNlHWSbFr1LgxzYwvHqJ6EQ9EhQUyPadu9i+YxcdO7YnISGRfQcO6ofvlZaWkpefj4O9PdbW1nRo3579Bw6xd+9+2rRpzZ69+3BxcSYwwN/kvAUFBZw8dYq777wDAC9PT1JT04iLi+fMmbN4e9ftBaRFAqxnLsL1LuqfrexLemeOCrjKWkA1GrjWGXZkVwywSrSwJweeNcpY1M9JtaoeyFVzABytYH+uuih3slKTrvflqO7zATJHoN4JsVcfluU/TI2VoN4vbR3MHBS1YnmKYbhKmD0MaaI9vxqNSkM9+JTa/jIFZvlAWBN8L/6eoYZJlnnFDwY20feFqNxzvrA8VTVuRhfBm/HSuGnsUC68cBF+KZdu3Qq41Q02ZkBeFS3utlaqJ92YRgNuNurWoVnVz59dzUAsvZqZU0uBhGJ1O3CJXAIe1qZBl7n5YnmlhkyK5RWhrhPGnoPDHaUnq6Fxd3fjlpE3s2PHbg4fOYqjYzP6X9OXsNB2AGRn5/D1im+57dZRBPj74erqwoibh7H1vx3s3X8Ab++WjBx+E5py444PHT5Cxw4d9FkLXV1d6NM7nF/Xb6RFC3duHja0Tl+nRltZXsRasiNb/VMc7ai6fbdlqzlYo86oi5W3AgxlZ8fAwTz4vZ3pOVKKwfMQHOkInY0+RLwPwbuBcG8LNSl/RrT6wFkSCA97qYm383xkEnZ9drZApWJfbjQcwM8WTujGkztawd72l/7yEFdPq4XOERCRr7YXBzaN9OxVufGUYT7aXe4qY15TElsI3Y9DcrHaHuYKG9rK0EBh3rJkNdcawEEDJzo1vSHG5R3LUyNpfkw33a9Bzfd8wU9dC5nrvQHVc2VrVXe9N3mlEF9JIGa8XfaZUJdsUdd2xr14lrLkw6WWrkKNeWzaI5auQqNQpz1YBaXwwAUVBLmXe+bcUjXp0pi9lXpMeWUtGhXKawzlH2sJkzzUh5azNezOUeu19HGCByPh90w1vHBxoFwc1Cch9urD0vgDM6cEep9Qi1fmlsLd52FXe7VOkag9f2cbgitnK5go899Y4A9/nFD3f0iDOblNJ0NasRbGnTdcSPnawvJW8vkpKjfFQ83hPJCn5gY9Hdv0GiXKnMyHl+Pgu9SKU0HGuqnevU5GDYfDm6vemfINjhM8VM9VXfXaNLOC1vbqVpXCUtV7ZbY3rNBwP7FY9XbVhLKlW+pDgCVEeXUaYL0cp9bIuNPMGjoOGjXp0lhBqfkx2w66L/QK5bWm5Y2TY7xwEV7yhVVpcCwfTnaGG06qbZl8W785Wasv5T7H1Zf0kTx4Kho+CrZ0zRo349TsEz3A1UyymaamtxOMcYOf0tX2s7HwW7uqHtF4vHQR/jWad/Vta0lXL6pmrYH3g2DgSbX9QxpMy2paSabOFsArcSoQKB9Y3NocXvKDbpU00phrcKyv7Kwg0E7dqlKsVcNGjYMucz1iMdVcpFqWbhH1VZ0GWN+mqn8c5wNqu1Cr5lM5H4BxLVQ3tLH4ItVKWp6HjQqy4osMQwSLtWrooLny23UXBf2c4dsolbnQ0QpucFFzvyTAqv+6NFM9n49Gqe2Pk2Gwq/lgXVy96EL4Jd2w3VSTW5jzih/8nK5aoddnqmHOjX1e5x+ZMN9o3tWLfmoerRCXMsAZ7nWH79TaojwRDfs6qOCrMbtQAK/GwxfJav6wsRGuan298CqWoWmsbDSGeVZVcT0gS7eIhq1O35p/h6q5Vwc7qNtDntDLUd3v56QCobIZYVot/Jej9leotEa1JJclyAA1t8tGY364zgtGmQM1GkMrUjF1nrVRXIWHPdW8lzIPRsK5S6z1Ia7M0iTDRcFgF+goc970OjWDCUaNMnNjDZ9bjVFckVpouewlDnFRc1mFqK43AqCZLqA6lKfmZjVWMYUwLQraHVOv0zi4utEFdoSpXu+mGFxdjvEeao5VVayQpVtE/VWnPVjlJ7e6W6vxvW0d1FCTObHweDRM81IrwGeVwD26C5m8UpV+1Ef3HzfNS02e7dpMrUczLQru91TzrYz9m6XWiuir+zDr5agWDZ3koSaRGmcirE+sQ+64osf17NSGPWsXmj3We/Qs9h87d0XnLTm72uz+R+Z9xLLv/7iic+7++U3Cu4RU2P/Jd5uY+mzlE0bLWgWygfKjsz569REevndYhcfsO3KWPrc9fUX1fPDuoSxdMNXsscb8dyr7Pd+8/E0Ivfy/U1Ua+t/pRT9Y8dAsOH+O7Vz+B2l9+n+qyoevPsL34cNI1M278raBb1rDwaMN4+8E9ef/qUxt/J0ayv+TpnUbtG8s5JlY1VhmPBe7Mf6dyrdgj331EfqF1v+/U336f7pUL0DBsjchqP7/P13TxZ97hnUye+yJtzdV6xzvzaxYJ1F/1ZvOVVdr+K2t6sXqeRz+y4b1bQ3zqL5PBd/DhvL3tFDB0dQoGHoaejmpNbTKezHONDXsPS1UUNb/hEp4cZcMMROiSk1pvkR1tbYHT4st0153fsuAv3RZEzWo4Mpb5l2JK2Sn68VKKYGX4qouK0R1LEuGj5MsXQshKrLoJcKrpmuE0dsJ9nc0X3ayp7oZm+2jblXZEmq6bauB75poFiMhroTktjDP1xYa8UgnAH41WqPneV8Y4mq5uoiGL8AOzuruL0lUw75l+LG4WlOjVPB+v+elywpRV+pND5YQQjQkto18kj4Y5l3d4KIWjhXiarhbw/W6hDAlwJPRDW/+Yp5krauXHrygMjUKUV/U+ULDQtSU5GLoHgGxuuyTg5zhz1CV7ERcmfsj4Qvdl9T4FrC8tUWrU++lFkObo2p+KMBnwQ2/FbVECzedhj91QwNb2sDBjpfO+iVEdRzOhR7HDcmmfglRa1LWd5kl8F4ivJ1g+H8v06WZygp4a3OVSEvUjbRiGHJKrbMGhuUjLJEZWhYaFuVJD5ZosDxt4LvWhjfxv9lqvRFxZVKK1VIKZR5rabm6NBQtbGCWt2H7xYvmF0dvSBbEG4IrDbCitQRXouZ0dYRHjJZ9eCqmfv/PZJeoxFitj8DzF02Dqw4O8EMblQn5NjcJruqauw1sDlUBLqig/b7zsCbNotUSApAASzRwA11Mk5i8EgdbMi1Xn4bss2TD4t3hjtCnksUvhaknWoKXbjZrdBEsbcATs/7JUkFimXk+cKPMuxI17BU/NVwQ1EK87yZWXd4SckvhnQTVQz03FlKNAqt29rCiFRzpqNZitJLAymI8bOCPdtDRQW2XAPech3XplqyVaAxKS0vJyc2ltPTKWoAkwBIN3jwftVYTqDkj952HxGquAi+UEi18ZJSJ6TEvaY2tLmdreMYo2c6rcarVu6FJLIJ7zxuGbg1yNm28EKKmeNjAS0bvrVfj1Hpr9UF+KSxOhJAjMDMGkooNx1rbwRfBENEJ7vNo/IslNxQtbeGPUAjVLQVUpIWx52BjRtWPE8Kc+PgEfl77K0s//Zwvv1pBckoKmzb/yc5duy/rPBJgiQbPWqOGMZX1IsQXw8RIKJXZhdW2PgMiC9V9D2vLjGFvyB71gkDdMLqkYjVXoyEp1cKESMNFrqeNmssg8xlFbZnqBZ10vQ7ZpTAnxrL1KSxV6b7bHYX/RavvkTKBtvBJEJzsrLIZy/9F/eNrq7JGt7FT24VaGHMW/pQRLeIyxMTEsubntQD069tbv9/DowX79h/kwMHDlT20AgmwRKPgawvLWxm2f8+EtxIsVp0GZ4lR79UDnmoBcFF99lamvT0LE1QCjIbi9XjYZHQhsrwV+NtZrDqiCbDRwLuBhu2vU2FXTt3Xo0irhkeHHlPpvmOMetL8bOGDQDjdGR7yahqZQxsyfzsVZAXpPrvytTDqDPybZdl6iYZj+45dtGsbwm2jb6Fb1y6U5QEM79mDXuE9OBZxvNrnksso0Wjc1BxmGyUceCYWdmZbrj4Nxal8w8W1BtWyLC7fRA8I0w1RySiBN+MtW5/q2poFzxnNu5rjAzc3t1x9RNMx1FUlhyjzv6i6G3lQrIWvU6DDMZXi+0Kh4Zi3DbwbAGc7w7SWqgFFNAzB9vBXKPjrRhTkaWHEGdgu1wKiGlJSUwkLbWf2mL+/P1lZ1Y/W5WNDNCqv+MM1Tup+MWqya1oD6kmwhA+Neq9GNYdW9parS0Nmo1HvvzLvJ9afeSWVSS42nXd1rZNKQCBEXXk7QC0SC7A7F1akVl3+apVo4btU6HwMJkWqJBtlPG1goT+c6wJPeIODXCE1SG10QZaPbtpATikMPw17LNBDKhoWx2bNSE0zn4YyLS0Nx2bVXxldPj5Eo2KrUanb3XQZqi4UwgMXGt5ilnUluwS+MMp6N11Ss1+VO9ygh+7zN08L8+vxsgGlWph43rCOnIc1rGwj80tE3WpjDzONRh7MjoGsWkgSU6qFH9OgWwSMOw8njQIrd2tY4AfnOsP/+YCjXBk1eO0c1HDBsrnZmaUw7DQcyLVsvUT91r59KLt27yXi+Any8vMB0JZqiY6OYfeefbRr17ba55KPEdHoBNvDF60M2z+lm/bSCINvUtUXD6gMTENdLFufhs5KA/ONerE+SYbzBZWXt6SFCbDBaN7V160hQOZdCQuY52NYay2+uGYbJrRa+CUdeh6HO8/BsXzDsebW8JIvnO8Cc33BxbrmnldYXodm8GeoajwCSC+BoafgSJ5l6yXqr969wgkJac2Wv/7hy69WAPDjmp9Z++t6/Px86dunV7XPpdFqpW1fNE6PRxmSN9hpYFd76C5rO+lptdA1Ao7qLjjeC4T/SQ/WVdNq4bpTsFU35n9iC/iqtWXrVN5/2XDdSbVmDKjFkt8MsGiVRBO3PEVlfwX1eX2sI7R1uPLzabWqAeH5i7CvXK+FsxU82RKe8laL1YrG7UAuDD6lAixQvVr/hKoArKYs+XBpzZ3Mwh6b9oilq2BxaWnpxF68SH5+PnZ2dvj5+uLp6XFZ55AeLNFoLQyA7roP0EIt3H2udoaeNFT/ZhuCKycrmHR5nx2iEhoNzDeax7Q8FY7VoxbTlGK455whuLrGybTXTQhLuK8F9NPNny3UqjWoroRWC5szof9JGHnGNLhytFKJkM53UfMlJbhqGno4wqZ24Kq74k0qVgHXqfyqHyeantiLFykuLsbd3Y3OnTrSK7wnXbt0xtPTg+zsHHbv2Vftc0mAJRotByv4vo0KHgBOFcC0KJmPVeYDo2GTE1qo4TKiZgx0geGu6r4W0yx9lqTVwuRIQypqd928K0k/LSzNSgPvG6VtX5thunRAdfyTpXqPh52GnUYJDRw08FRLON8ZXg9QySxE09LbCTa0U72XoIaiDj4F5+rpEG5hGT/9vI5Vq38iPaPiKtXZOdns2SsBlhAAhDrA0iDD9opU+CrFcvWpL2ILYY1RohxJblHzjHuFfkqvHxms3kmEX42+N75qZVgzRghL6+0Ek4160p+MVutUXcr2bBhyCq43GpoLaqjh414q3frbgdDStubrLBqO/s7wW1tDEpPYIhVkXZAgSxgpKirih1VrOHvu/FWdRwIs0ejd5wFTjL60p0fD8Xo0ZMsSliYbhohd5wyda3AsulB6OMJd7obtZ2ItVxdQa8LNMRp29VRLGOVmseoIYdZr/oZehuP5cMNJcD0AVvvUz2lRhtTqu3Pg5tNw7UnYYrQ8ja0GHvWEM53h/SDwk0YEoTPIBdaGqF5NUJmGB5+CmMKqHyeajhuHDCYsrB0bf9/Mf9t3cKWpKiTAEk3C4kDooJswnVsKd5+HvNKqH9NYFZbCJ0bDAx+T3qta87IflI283JwFf1V/jcIalVqs3vNlS8L1cVQXskLUNz628JyvYfu/HMgqVUNts0phWZJaw6rvceh7An43GkZoDTzgAac6wUfBECiBlTBjiCv8HGJYf+1coeoBre/rFoq6YWVlxXUDBzD4hus4fOQYP/2yjtzcXDSaywuZJMASTYKTtZqPVdZqdSQPZkRbtk6WsjodEnRX2v62cKubJWvTuIU5mA55mhdb93MAtVqYEglRuhZaN93/gp18+ot66pbmUNm0wCIgX6sWJS5jhcrWeaITLGsli6WLS7upOaw2mn96qkAFWYkSZAmdDu3DuP220WRkZPL9qtUkJydf+kFG5CtWNBldmqlU5GWWJsMq8wt2N2pLEg33H/GSBAe17Xk/Q0vpzhzTOVB14b1ElTCgzBet5AJU1G9Lkqp/cXKPOxzrpJZCuJq07qLpucUNvm9tGGVwPB+GnlaZVoUA8PZuyd133o6rqyt//f3vZT22zgOsE/lqoTfnAxB8BBbGG449cgE0+0xv7yZUfq4fUqHtUXDcD7eeMW15+C8bQo6A1yH4tNwiszOjJdFBU/WQp+m8mAcjm1YWoQO5sF2XbMFWo34fonYF2cFUL8P2MxehtI56sXbnwNNGc7+eaAm3udXNcwtxpVakGOaIVsXZCr5rA+0lsBJXaIw7fNPacDF8JA9uPAVpEmQ1SX16h+Pk7GSyz9HRkTG3jqJL5044OztX+1x1GmAVaWH4aXXBcbADfBAIr8TBN7pg51geLPSHuK6G28Ne5s+1JwcmRcKzPrCzPWSWGBYpBHgsCh7ygpWt4X/RkKz7Z4kvgj+zYHyL2nylor7SaOCTYGijG5ufWarWBCpsIvOxPjDqvbrTXc13ELVvno9huYAjebCyDnpO04vV2m9lWdh6OcKbMu9KNADZ1fw8zm0in9uidt3dQmVULRvMcSAPbjoNGbJuZpPTp3cvnJ2cKuy3srLiukEDmDRhXLXPVaerQcQWQh8n+CAImlmp7vyhrvBPtsr0djwfXnWq3kXf4kS4wx0m61rgv24NQUfgTL4674l8uN1Npel2s1a9FJ428Fo8/J83WMuwqCaruW7tn2tPqovPPbkw7yK8FWDpmtWu1GL4JtWwPb2SxgtR81rawoyW8Kqux/75iyrAra3hmVot3H8BInXzrlytZN6VaDicrVRCi+qUE6ImjPdQC1w/cEFt78mFEadhYztwkTUiG7XvVq5i2I1D8PBowXcrV1VdWAP33n1ntc5bpx9PrezVl3wzK3UB8F82/JsFQ1xUz1JqiZoUXh07c2CQUU9doB0E28EO3fCnIDvYn6vWN0grgQBbFeD9kwX3Su9Vk9fbCV43as1/OwF+q+O5MXXtixQ1ORygRzO4pmIjjahFM73Vwr6g0kx/fnnzZS/LkiS19laZz1tBG5l3JRqI8R5wqXZWW2CCxyUKCXEZ7veEj4zWzdyeA7ecgRzpyWrUvFp6Ymur+pu8vDzxalnFzav68yostp55wBG4WKSyBY11V4GPDfBcLGzIVL1NM1oaeqjKiysCv3KfwN42hrUMXveH+86rFol5vmodjOlR8LSP9F4JZUZLlTa7LOnApPNwsCMENMLUviVa+NBoeOBjLdVwSVF33Gxgjg/M1s2JejkOJnqoBqeatDcH/s9ovavHvFRvvxANxUxvNU+6qIpeLFsrmOFdd3USTcOjXuq68QldluF/s+HWs7Cubc1/Vov6YejgGwz3h9xQRcnLY7EA65cQFWBNjVLpsst6rro5wv9awt/Z8EiUSq99p5mLg9xSsC/3Zre3ggJdC/0Yd0hpDgWl6sImulD1mC0OVKmSV6SoVb0/b2VY1Vs0LRqNyqjWPUKt6J5SooLyP0PBppEFHxsz1VofoHpR7pFeXIt4rCUsSoD4YvX592GSupisKRklat5Voe5zsKdj4x/6KhqfEHv4sQ2MPaeCLOPM2bao4OrHNqqcEDXtfy3VvOxZusawP7Pg9rNq7azy153i0kpKSvh+1WoGXtufwED1hZSYlMS2/3aQlJSMg4MDnTp2ILxndzSVtPyu+HYl6emmw4zuvusOvDw9SUtLY+OmP8jOzqZrly707dNLX+bQ4aMUFOTTp3ev8qesVFpaOqXaUjxatCA/P59du/eQlZVNSEgbOrQPq/Z5LivAKtbCylT1ZosvgvcDYVs2hDtCV8fLORP00g1Pyi1VySoyu6uhey10NerqCKfz4aMk8wGWg5UKnowVlJoGS82sDC0O8+NU6/GuHPguVaV1nRKp5nLN9rm8uovGw9MGvmsN15+CUlRr1Stx8JKfpWtWs4yTWzzgKY0KluJopRZRna5rHX0tTmVydK2BMf5arS4rpi6QdrFSKYjlgkA0RMObw+GOqkFieYpKfOFspYYFzvCW4ErUrv/zUQ1Vz1xU2xsz4c5zKrCXuazVV1xczKbNf5KaasjslJ+fz7pfN9C2bRtuuH4Q6ekZ/Lnlb2xtbenWtXOFc5SUlJCRkckdY27Ftbmrfn8zB9Uzs2Pnbvz8fOnQPoyff/mVkDat8fT0oLi4mGMREdwx5tZq1/fsufP8vukPunXtzLX9r+GPLX8THR2Dj483f/39L0VFRXTtUrGO5lT7bZJSDP1OqKBkfy5sylSTUNekQ/+TKnC5lNhCWJtuuq+jg3oTZ5UagqsyHRzUY8zxt1WtwMbii8HXzMDtCwWqfne5qzlafZ3UpMWhrmoul2jaBrrAi0YB1StxsCXTcvWpaWfy1bBbUFmSpkpyC4t60BNa64ahppTAO1UsRXE5PkqCH9MN28uCZV0g0bCF2MOSIMjoASXh6ueSIAmuRN2Y5wvP+xq212XAvecNmVlF1VJT0/hx9c9kZJpeUF24EIWVlRWDBlyLu5sbrVsF071bF06dPm32PGlp6Wg0Glq29MLJ0VF/s7Ky0h9vHRxMSy8v3N3dSEtPB+DosQjatW2LvX31PzD27ttPu7YhXNOvLzk5OVy4EEXvXuGMuXUUffv04vCRY9U+V7UDrBnRavjJmc6wrwOUvb9+bKMClnmxVT4cUFkCbz9rul7VvlzwslEtubecMS1/IK/y9S36OaneszLRhRBVqPaX90oczPUBK426wCzr+CrWqlZfIeb5wGAXdV+LGirYWFZ0/9BoHbgRzSXZgaXZWZn2kL6dYFhG4kodyIUZRvOupnrBXTIMVAghrsqLvjDbaBj3mnSYeF7NaxZVi714EX9/P8befpvJfj8/P24aNqTccEANBQXme1RS09JwdXXB2tr8UA9nF2eSkpMpKCggMzMTF2dnioqKOBZx3GyPWFXS0tLp2KE9VlZWRF6IAqBtSBsAfLy9ycrKqva5qh1grcuA+X4QbG9YKwDU8JOZ3ipQupTrXKBjM5gcCcfz4Nd0mBMLz/jAKDfYkAHvJ6oMW0sS4esUmKUbvldYqoYllr2pp3rBt6lqEeEjeWqY4XBXaFcuIDtXoHrcyoYZ9nJUCTUO5aosW30lk5pAJT5Z0VoF+6B6QydG1t2CsLUlp0RlDyzzmPRe1QvjWkAn3WdVdqlqYLpSmSVq6ErZvKvuzeAdmXclhBBXTaOB1/xVUqwyK9Pg/siGf31Q27p07sTAAf2xtTUdWubi4oyfr6FrsLi4mIjjxwkMML9QY1paGhqNhrW/rufzL75mzc9riU8wDP3o0yuc/QcOsezzrwgKCsLHx5sjR48RFtoOO7vLy1pmZ2dHfn4+AJGRF3B1ccHNrbmqR3o6js2aVftc1Q6wSrRq3pM51e0JstXAb21VAoG+J1QSiydbqgmF17uouTCfJEGnY6rV/bvWMECXin17DvgeVj1VANc4w6fBal2Za06otY2+alXxOV+JU928ZYHyQBc112vQSbXw5+MtKz5GNE2+trC8lWH790x4q4aGb1nKt6mQrksx29YehrlWXV7UDWsNvGr0XfJBkiED6uXQauHhC6pRCtQclR/aVP5ZLYQQ4vJoNPB2gOnakV+nqmtYCbKuTmlpKZv+2EJRUTG9evU0WyY1LZ2CgkK6dO7ILbcMp4W7Oz//8iuZmao3ydfXh/snT+D+KRO5ccgNFBUVcfz4Sbp26czhI0f5avk3rF33G7m5eZesT6vgILbv2MXf/2wl8kIUYWHtADh06Ag7du6mTZtW1X5t1U5yMdgFXoqDgc6GCdka1FjU9xJV71R1BNrB2rbmj93VovJhLde7gDbcdN8kD3WryhetKu57N1DdhCjvpuZqOMAbusDqmVj1nr/GuerH1UdarVoPqcw0LzVMVtQPtzaH3o5qQcsCrWoMWhp8eef4JBm+TzPaDq7Yiy+EEOLqaDQqsVuhFj7VrWG4LFl1HHwg15NXpKSkhE2b/yQ6OoZbR4/EydF8trxhQwdTUlKi743yGuRJXFw8J06eok9vFRhYW1vTTDeE8PCRo7RvH0phYSE7d+3hvnF3s//AQXbv2cv11w2ssk4DB/Rn67btxMZepEOHMMJ79gDg2PEThLRpzTX9+lb79VU7wHo7EK49ASFH1QKlGuC5i3AiH9KLYVv7aj+nEPXaK/4qm+COHCgG7jkPBzuAu8UWNbgy/+XAYV2DjaMVTJZFOesVjQYW+MONunm9nyXD/3lXP0A6lGtYqwXgYU9ZRF0IIWqLlQY+DlJB1le6ofcfJYGdBkIwnT4jqlZcXMz6Db8Tn5DI6FtG4ONd+Xol1tbWJvOvNBoN7u5u5ORUzFJXWFjI8ROnuOvO24mOisbd3Q0nR0eCAgPYsXP3Jetla2vL4Buuq7D/3rvHVppCvjLVHkgSYq9Spj7iBaklajuhCEY1hwMdK09GIURDY6tRw1PddP/PUYXwwIWGlxBliVFq9vEtGl6A2BQMdTUkVykBXrhYvcdl6eZdla3717WZ9MoLIURts9LAZ8FqHm2Z9xJhbWBfGtglgkVt2vwnCYmJ3DpqJL6+Va+V9MOPa9i3/6B+W6vVkpySiru7W4Wyhw4fpWOHMOxsbUGjQau7cCst1XI1f6DLDa7gMgIsgJa28LQ37GgPpzrDH6FqTGrg5c0hE6LeC7Y3HV76U7ppNr76Lq4IVhsNHZsuyS3qrflGGQW/S1M9U1XRauHRKDitm3flpJt31UzmXQkhRK2z1qg5/2PdDPv+8OvOev/qL2bblJ0+fYZz5yMZNHAAzi7O5OTmkpObS16eGnJTWlpKTm4uJSVqAnmr4GAOHDxE5IUo0tLS+fufrRQU5FdY9LegoICTp07RpXMnALw8PUlNTSMuLp4zZ87i7V23SReq3aadVqxSV58rgBO6rIc7smHEGRjrDl+2ksVLReNym5vKulc2j+mpGLjWGbpf5qLalvBJkhreCGoO2eUuBC7qTj9nGN0c1uoWqX/2IqyrZJ4qwGcpKnlJmY+DIExGEAghRJ2x0cC3baDoLPyi++zeGBCOtbaEmy8esGzl6rkzZ88BsPmPLSb7nZycmDJpPNnZOXy94ltuu3UUAf5+9ArvgVZbyt//bCUvLw8fb29uHX1LhfWtDh0+QscOHfRZC11dXejTO5xf12+kRQt3bh42tG5eoI5Gq63ewKcHItXiwh8GqZTqoFKn/5mlWlNvd4NFMkRFNDL5pSpL5UHdXKZ29modOBfzyzHUC4WlEHzEsBD3961lTaT67kgedIswjGD4Lwz6m0msciQP+hyHfF3B+z3gs1Z1VUshhBDGCkrV+q7rjdbSvTVqJ0PjDlmuUlfpsWmPWLoKjUK1+5x+y4B3Ag3BFagFM4c3h9f9YVVapQ8VosFysILv26j016CGZU2Lqt/zsX5KNwRXvrYwxt2i1RHV0KWZ6Zj+ebEV32PZJXDXOUNw1ckBFgfVXR2FEEKYsreC1SHQPsOQceiXoH785dPFgrUS9UG1hwjmlYJDJXO8XKwMa+0I0diEOqhhWOMj1faKVBjiApM9LVqtSn1gNFfsEU+VtEPUfy/5wfepamjnP9mwOcuwbplWqwL7E2r9QxytYFUbGZYthBCW5mAFD53axMdhN3PaVS1wuCa4P9alJQxKjLBw7cTl0Gq1HIs4zoULURQVF1N+kJ8GuO3WUdU6V7W/nvs7wxvxkFMukMothYUJam6KEI3VfR4wxSjN+fRoOH7pNevq3KFc2Jqt7tsAD0tyiwYjxB4eNArajXuxvkyB5Ubzrj4Mgg7VX1BeCCFELbIrLeaRkxtpkxWn37eq9UC2e8kaRg3Jtv928Pc/W8nOycHWxgZ7OzuTW9laXNVR7R6sN/xh4EkIOqIWFW5pA0nF8E+WSi/8T+iVvBQhGo7FgbAzB47nq4aFu8/Drvb1K3ubce/VHe5qiKBoOJ71VcFUvhb25YLTAXXfuA2tOgusCyGEqFv2pcU8enIDH7YfSaSzWtdpZetBWGtL6Jt82sK1E9Vx8tRp+vQOp0/vq88IWe1Lw66OcKQTTPSAi0WwJUutD3SfBxzoIFnKROPnZK3mY5UNlT2SBzOiq35MXUorhm+Mejkeq9uMpKIG+NvBiOaG7bxywZUGuLV5+UcJIYSoD5qVFDH1xHoCc1Rrp1aj4Zs217OvRYiFayaqo6SkBD8/3xo512W1vQfZqUyBO3XrYO3pAO8FQiv7Sz9WiMagSzP1ni+zNLn+JHj5MkX1rAF0awbXOlm2PuLynS2ADRmVH9ei5gKeLairGgkhhLgcjiWFTD/+G345KQBoNVZ83XYwB91bW7hm4lJaBQdx7lxkjZyr2kMEAdKL4a8syCmFUjPHJ8qwFdEEPOSplif4QRdYPRgJ4Y7QxoINDaVa0+GB073gChYeFxb2dgIUXyJDZVEpLEqAJZJBUAgh6iWnkgIeO/Er73cYRbxjC0o1VnzRdggPnt5Ml/QLlq6eqERQUCDb/ttBZmYm3t7e2NiYhkkaDXTv1rVa56r2Oljr0uGe8yqboNkTASXh1XpOIRq8jBLoGQHnCtV2b0fYFqaWLrCEjRkw/Iy672YNMV3UkEbRsLgegKxKPmNNyllBRo/ar48QQohLW/LhUrP7M22b8V6H0SQ2cwPAprSEB0/9TqeMejS/oJymvA5WZX/HMhqNhulTH67WuaodYHU6Bp42qtU0wBaszLSON5cLOtGE7MmBa09Cke4/6KmW8LaFFtu+5Yxaq87S9RBXx2qf6ZyrSsshDVpCCFFfVHVhnm7ryHsdR5PsoCbQ2ugyDrbPjK2r6l2Wphxg1aRqt7efLYDnfdUcFHcbFUyVvwnRlPR2Utk1y7yTaAhy6tK5Alhv9LxTJTV7g+VczU/k6pYTQghhWW5FuTx+/Fda5GcCUGxlwyehN3HapWaSKYial5+fT+SFKE6dPkN0dAyFhYWXfY5qz8Hq4AAXLv/8QjRqT7ZUGTV/1QU4k87DwY4QUP2lEq7aR0mGXo/hrtDWoe6eW9Ss8R6wLAmKqihjC0yQ+a5CCNFgtCjM5vETv/Jeh9Gk2ztTZG3Lx2HDmX7iN9pkJ1i6esLIrt172H/gECUlhoV/rays6N6tK/2v6Vvt81Q7wHo7AB64oHqq+jqBo5kW1BaXlTJDiIZPo4EvWkH3CIgtgpQSuO88/BkKNnWQZCK3FD5LNmxLavaGbaY3fJWiEllUxtYKZnjXXZ2EEEJcPc+CLP53fB3vdhxNpp0Thda2fNR+BNOP/0qrnKRLn0DUukOHjrB33wF69uhGu7ZtcXRsRm5uHqdOn+HgocM4OzvRtUvnap2r2gNN7j4PcUVw1zkIPgJehyrehGiKPG3gu9aGf6Z/s+GVuCofUmO+S4U0XSNLGzu42bVunlfUjhB7+LGNasAqv0a0LWr/j21UOSGEEA2LV0Emjx//FZei3P9n777Do6i+Bo5/dze990ogIYSAdAgd6SJNEBCx+8OG+qKoICgWLAgqVUQUpYmC0osCdor03ksKJQRIIIX0ZDfZef8YdsmSAFFTyOZ8nicP2Zm7w53JzuycufeeC0Cezo5Z9fpw3smnkmsmAA4fPUaL5k1p26Y1Pj7eODk54ePjTbu2rWnerClHjhwr9bZK3eY0uca/qqsQ1cLdrvBeELx7UX394SXo5AJdyzHgURSYefn66xf9Sk4+I6qWXu5w+C41Fft3KZBlVMdcPe6ttlxJcCWEEFVXQN5Vhp9QU7hn2zqSa2PPzHp9ePnETwTnplZ29aq17OxsgoOCSlwXHBTIgYOlb00qdYD1pPT5F+KWxgbApkx1TJaC2lXw0F3gd2NTRBnZkQ0Hc9XfHTUwVM5RqxFur2ZslbmuhBDC+gTlpjH85Do+r9+XHBsHcmwdmFm/Ly+fWEtg7tXKrl615e7mxsVLlwgJKd6qdPHSJVycnUu9rX+Ui+pMvjqpatgRcNwP+3PgtfMwJ/m2bzU7mQfdo8HlgNrVcFLi9XXn8qFHNDgfgPrHYMNtMrItTYU6R8FpP/SPhctFRoZvy4Lwa10Zv7mha+vI8+o4ByHKkk4D34eB77XHFokF8MRZdRLg8lC09epRbxkDKYQQQlQVNXJS+L+T63AoyAcgy9aRmfX6cvlaOndR8Ro3bsi+/QfZuWs3V5KTyc7O5kpyMjt27mbf/oM0aFC/1NsqdYB1MAeanYCtWXCfO+iv3TQqwLBzaleW2zEo0CsGatrBwfrwRYjalWpRitrdqX8ceNvAnnpqi9mgODWoK8mebHjyLLwdADvrQUahejNrMjwenvWFH8Pg5fOQXKAuTzTAn5nwmFdp91yI0gu0he9Cr7/+NQMml0OCoEQDLL96/fX/SWp2IYQQokqpmZ3Mi6fWY1+opunOsHPm8/p9uWIvA6orQ4O76tO0SWMOHDzM0mUrWbBwEUuXreTAwUM0adyQ5s2alnpbpZ5ouMspcNDCujpgBOz2w9760NwJ/i9ebTE6eNett3E2H8ZcgAWh4HgttBsYpyYJeMgT+sTC5Sbgem1Ore7R0MYZxgcX39YTZ9R6fB+mvj6vh5pHIKaBmqbacb/aPauuAwQegjV1oJUzjDgPLZ3UdMhClJc3EuCTa4GVDvg7Etq6lN32P7x0fbxXe2fYWq/sti2EEEKI0rvVRMOlEesawJeRvdHr1DEFnvmZvHJ8LV76rLKo3j8iEw2r82AlJl0mPz8fB3t7/Pz9cHT4Z3PglLoFa1c2vHRtEP2N4+gHe0LMTVqaigq1hyW11eBKUdSgbEsmdHOFndnQzOl6cAXQwUUdZ1KSndnQscgNa4gd1LK7Xr6mndqF8Vy+mmWthi1c0MPmTHhYWq9EOfswGNpe66pbCDx0BtIKymbbBgW+KtLtVVKzCyGEEFVXncxEnov+BVujeqOQZu/KjPr3kWZX+jE/4t/Jy8vD1NaUl5dHXl4eAAH+ftSqGYK/vx+aG9aVRqlHbbjp1G5JJYnXg9s/Gs0FNY7ARQP0dYcHPOGV8xB0QzIAf1tIuMnkxpcMJZS3uV7+42A1yYBegbGBEGSntrSNDlDHyghRnmw1aur2pifgaqF6jjx9DlbUVufO+i/WXFXPHVA/8wM9/mtthRBCCFGZIjMu8mz0r3xdtycFWh0pDm5Mr9+POhmXOOwVRp7OFodCA1EpMXS9dBjf/IzKrrJVmDt/IQ8MvB9/fz/mzPsWzW1u0v7vhedKtd1SB1iDPeHNCxBmD3dfaznSANF58P5FuN+jtFtSrQlXbxJfiIdXz6sTptrfEKTZayD/Jh0YSyyvvV5+gCekuEO+ETxs1C6E27Lg8xAYewG+T4F2LjAvtORJk4X4r2rZq5MQD4hTX6+6CrOuwP/9xxanoskthvmCnXx+hRBCiCqvfnoCT8f8xpyIHhRqdaQ6uLHb3tX8ZDbPxo7tvvXY7VOXp2J+p0H6+UqucdXXtUsn3NzVMW/dunYus+2W+tbskxrQ0BG6RYPnQXVZ7xi46xj42qrr/4koZ+jnAVNqwOxksNOowVBR+crNgx8HbQnljZblHbVqcAXw0SV4I0Dt6vhDKhxrAAUKfH4ZIcrN/R4wvEgCitcS1IQx/9aRXNh8rUu2DTBM5iYUQgghrEbDq/EMOrdNHUsDxbq9GLU69Dpb5kXcI8kwykD9epHm8VVubq6Eh9emfr3IYj+1w0KxtSl9uuZSB1hOWvizLmyoo2Yse8ZHTRSxIhy2R6pdCG/ngh7WXrVcdpeD2o0v0LZ4F8REg7q8JMG2ahpsi/IFJZc/l68GVg96qmO0WjurY726u6ljuYQoT5NqQFNH9Xe9Ag+ehszCf7etWUUeCAzwVLu+CiGEEMJ6XHTyRsOtc9AVaLRsDGhUQTWqHlav+Zm01LQS112+fIXf/9xY6m3945lz7nVXf/6NE3lq1sCLja9PvrovR503qIMLfJoE2YXgfC1Y25qlZhEsSRtndf0z157gn9er41xKKv/hJXgz4HqCDlPDV4Fy/QGBEOXFQasmd2lxArKMakKYF+NhYeg/G491tQAWFpnkfbikZhdCCCGszl7vCBTNrdtAjFode3zq8uC5bRVUK+u04ZffuHpVnXhXURR+++NPbHTFw6Os7GzcXF1Lvd1bBlgvx/+zSs6oeev1nVzhLkf431m1a2BcPrxxAd4KUNfVslPXvRcEP6errUtza6nv1RshtVANxnQaeMEXOkWrKarbuKjp13u5QcQNWRRP56vZBL+5tp0oJ/g4EQ7lqGNiupf+WAnxr9V1gK9qwmNn1dffp6rZM//3D7r4fZuijj0EaOR4fSykEEIIIaxHnu4m3bdukF/KcuLmmjZpzLETJwBISU3Fw8MDR0fLYEKr0RJiZ0fDBreZj6qIWwZYP6Vbvr5oUFNEh9pBgC2kFKhBkr0Wmjje/j+z1ajzaP1fPLQ+qXbTe8UPXvZTn+SvCVczrbU4AeH2sCpcTe0OsD0bukTDmYbqsrYuatD07kW1Hve4wdclBHgfXlKzCJpaCu52VdO0dzylBnUvSYprUUEe9VYnuZ5/bVLu/zuvdletX4pzx6ioCTJM/s/3v2cjFEIIIcSdx6HQQJ7N7ccA2BfeJL23KLXAwAACAwPMr1u2aIG7+38f21bqiYa/S4FxF9UxV82cri8/da3b31BvGBVw8/cLIdQusC1Pqt1lARo6wO761yfevpnfMuDeGPV3dx0kNAKXUox7FEIIIUT5+q8TDd9oSWgHtvvWw6i9+Re91lhI+8snyryLoEw0fHNJSZfx9y9dy0ypx2CNvaB26ysaXAFEOsCHQeqYEgmwhLg1Z506HqvVCchT4GieOk3BV7Vu/b6iqdmHektwJYQQQlirrpcOs9unLnpu/mVvoxjpknikAmtl/bKysvl723YuXrxIYaGRom1QhYWFKIpS6nmwSp1FMNOoJokoSY5R7ToohLi9Ro7wWcj117OTYVnJSWsAOJuvjkk0eVGSWwghhBBWyzc/g6difseu0IDWaJl2WGssxK7QwFMxv8tkw2Vsy9ZtnD+fQN2IOri7u+Hj402jhnfh7u6Goij0vPeeUm+r1AHWPa4wJgH23JDWfFMmjLnwzycaFqI6e9ZHnTbA5JmzakKWknx5BXOy1ntLSOQihBBCCOvSIP08bxxZTvvLJ3Ao0KNRFBwK9LS/fII3jiyXSYbLwYULF2nXpjV3d2jPXfXrodNqade2DUMGDyKkRjCnT58p9bZK3UVwZk3oEQNtToKnDnxs4HIBpBeq2cymh9x+G0IIlUYDX9eCvdlwWg8ZRnjoNGyNBLsijz1yjTA3+fprSc0uhBBCVA+++Rk8eG5blU7FXlhYyJJlK7i7fTtCQmoAkJeXx8bNfxMffx4HB3tatYyifr3Im24j4cIF/v57O+kZGfj5+dK1Syc83NU5o9LS0vjltz/IysqicaNGtG4VZX7focNHyc/Po1XLqJtt2kJBQQFeXurTb09PD64kq1nJNBoNjRo2YMvfpf87lLoFy98WDtRXM/s946Nm4HveF36JgE2RakZAIUTpuevgx9pqdk2APTnw5gXLMktSIeVa74BQO+j1L+egE0IIIYSoSAUFBfz62x+k3jB57x9/bSIvL49BA/vTMqoFmzb/zaVLiSVuIzMzi3XrfyUyMoIHHxiIs5MT69f/ah4ftWPnboKCAunfry+HDh8h+VpQVFBQwLHjx2nSuPSTMbu6upCeoXa79PDwID8/n4xrr21sbMjNyyv1tkodYIE6BqufB3xcA2bXggnBanp0IcS/09IZPgm+/nrqZVh3bbyVosDMIqnZX/RV54ATQgghhLiTpaamsXzFanPAYpKens7Zs+fo0rkjPt7e3FW/HpF1Izhy9FiJ2zl+4gQ+3t40b9YULy9PunbpRGZWFgkJ6hPptLSrhNWqhZ+vL56eHqRdvQrA0WPHiahTB3t7+1LXOaJOONu27+TEyVO4ODvj7e3F1m07SLhwkb37D+Dp4VHqbd0ywGp8HI7mqr83Oqa+vtlPk+Ol/j+FEEW84gd9i7RMPXYanjgDLgdhX466TAd0kUmxhRBCCFEFXLh4keDgIB4YeL/F8sSkyzg5OZm7+IE6F1Vi0mVKkph4maCg62nKbW1t8fX1ITEpCQAXVxeuJCebW5tcXVwwGAwcO36CJo0b/qM6t4xqQUSdcOLj1fFtnTvezYWLl1i95ieuXEmmXbvWpd7WLcdgtXAC52shWAtnkIfnQpQ9jQbmh0LT43DBAFeN8F2qZRkj0CkalteWboJCCCGEuLM1atigxOU5OTk4O1vO+eTk6EhWVlaJ5bNzcnB2di6hvJp1r1VUC35e/ws7d+2hbt0IAgL82X/gIJF1I7Czu/1kzUVptVo6dexgfh0YGMCTjz9CWtpVPD09/tH2bhlgzQ+9/vuCa78rinpDCOoAfKOizu0jhPj3fGxgcjA8fLbk9QrqdAgPnIbDd0F46Vu8hRBCCCHuCAUFBeh0loGDTqfDaFTnndJoNKUqX1ioDlAPDAzgqf89jt5gwNHBAYPBwIkTpxj8wAAOHznKgYOH8PTwoHu3rjg5Of7j+trZ2ZV6cuGiSp1FUG+EVxJgXzbsqq8u25YF98XCS34wMVjGhwjxX2zJVvvsGm9RxmCEaUlqVk8hhBBCiKqkaHBkUlhYiI2NTbHgCsDmJuUdHK7PWaPT6XC8FoQdPnKUevXqotfr2blrD48+MoT9Bw6ye89eOne6u9j2Z38z7x/Vf9izT5WqXKkDrDcvwOJU+Cjo+rIWTjA1BN6+oGYRfCfwH9VRCFHE9ym3Dq4ADMB3KRJgCSGEEKLqcXZ2Jicn12JZdk4OTk5OtyifY7EsJzcXb2+vYmX1ej0nTkbz4OCBnI8/j6enB85OTtQMqcGOnbtL3H7TJo0pIa77z0odYC1Ng2k1YKjP9WWeNvCCr7qRCYkSYAnxX2TdLrr6h+WEEEIIIe4kAf7+ZGdnk5GRiZubmr3r0qVEAm7SDS8gwI8LFy+ZXxsMBq5cSSaqRfNiZQ8dPspd9SOxs7UFjcacyt1oVNSxFiUoOm9WWSp1gHW1EAJsS15X0w6SDGVVJSGqJxctZJYieHL5R5MrCCGEEELcGdzd3agZUoM//vyLjnd34PKVK0THxHJ//74AGI1GcvPycLC3R6fTUb9ePfYfOMTevfupXTuMPXv34erqQkiNYIvt5ufncyo6miGDBwHg6+NDamoaly4lEhsbV6pxVCdPRt+2TL16dUu1n6UOsJo7wewr0NONYk1pXydDs5Jb9oQQpfSYN8y5onYDvBlb4HHviqqREEIIIUTZ6t6tK39t2syyFatwcnKia+eOBAaoqdizsrJZ+P1i7u9/HzWCg3Bzc6V3zx78vW0He/cfwN/fjz697i02XuvQ4SPcVb8+trZqa5CbmyutWqoZBr28POnZo/tt6/XHXxtLXK7RaNDpdNja2pQ6wNIopvaz29iUCT1ioLYd9HYHP1u4YoANGRCXD79FQCeZp0eIfy0uX51TLucWrVhOWskiKIQQQtxJZs6aXdlVKDPDXxxW2VWoNPn5+cWWGQwFXLx0iR07d9Oje1cCAwNKeGdxpe5s1NkVtkZCfUc12cW7F2FhKkTYw5ZICa6E+K/C7dV5rpy0aktVUbaoy5fXluBKCCGEEKKs2dvbF/txcXGmbkQdWrZozpat20q9rVJ3EQRo5Qyrwv9xfYUQpdTLXW2hmpakZgvMMqpjrh73hlf9JbgSQgghhKhorq4upKamlbr8PwqwjAocyoXsaxMM36ijtGJVC9bUFA53XnN4uL2ahl1SsQshhBBCVIy8vLxiyxRFITs7h737DuDu7lbqbZU6wNqRBQ+ehouGkjMdaoDCFqX+f4UQQgghhBDijjBn3rclTnYM6mTGpUmUYVLqAGvEefDQwayaUMPuHwzeukFcPrxyHrZmgbMWhnjCR8HgoIVh59SMhEVNqwGv+Je8raWpMPYiXNTDPW7wTS01+QbAtix44gxkGGFCEDzre/19I89DYyd4UrKxCSGEEEIIUe1169q52DINGuzsbAkODsLevvTjNEodYB3JhZXh6hiRf0tvhPti4S4H2B4JlwvgqbPquikhcCwXJgWr6apN3HQlb2tPNjx5Fr6sqaaQH3EenjgLv0So64fHq0FVSyfoGwsDPMHHBhIN8GcmfFrj3++HEEJIV1khhBDCetSvF1lm2yp1gFXTDjIK/9t/tjsHYvNhdz1w0UF94MNgeO28GmCdyIPxzjef0Liozy/DIE/4n4/6emEY1DwCsXlQxwFO5sFAD6jroLa8nc5XA6yJiTDKH3QltwAKIYQQQgghqqHU1DQOHDzExUuJ5Ofn4+joQI3gYJo1a4Kba+mTTZS6p9/7QWpq9n3Z/6q+AETaw/o6anBlogGuFqotS6mFEOlQum3tzIaOLtdfh9hBLTvYca1+Ne1gfw6cy4e0QqhhCxf0sDkTHvb69/sghBBCCCGEsC4JFy6wZNkKzp9PIDgokAZ31SMwIIDTZ87w45LlJKeklHpbpW7BmpKkBkGtToKNBuxvaAHSAOnNbr0NX1voXqR1yqjAzMvQ3Q2O56qVeeeCOnmxjw286ne9hepGlwwQdENLl78NJOjV3z8OhkfPgF6BsYEQZAf/Fw+jA6T1SgghhBBCCHHd9u27qBEcTO9ePdDprrcGFRYW8vP6X9i6bQf39+tbqm2VOsDq6w78h/FXJXktAQ7kwJ76sClTXdbECV72g01ZMCwenHUw2LP4e3OMYH9D+5u9FvKvpTgc4Akp7pBvBA8bOK9XE198HgJjL8D3KdDOBeaFqhO4CiGEEEIIIaqn1LQ0erWOsgiuQM0g2LRxI3759fdSb6vUAda4oNJX8HYUBV5JgFmXYXk4NHBUE1887AVe12rU2Ali8uDLKyUHWA5aNXgqKt9oGSw5atUfgI8uwRsBsCsbfkiFYw1g6Fl1LNeYgLLbNyGEEEIIIUTV4unpweXLydSqWXwi0rSrV3F1K/0YrFsGWFOT4FEv8LdVf78VDfDqTdKpF2VU4OlzsCgVltSG/h7X3q+5HlyZ1HeA3zJK3k6wLSQWWC5LLIDAEhJknMtXA6tZNWH6ZWjtDK46tWvirzfZvhBCCCGEEKJ6aNumNb/9/icFBQVE1AnH2dmJvLw8zpyNZ8/efbRv14bLV66Yy/v5+t50W7cMsEYlQAcXNcAalXDrSpU2wBqZAItTYWVt6OtRZPl5OJUPP9e5vuxALtS7SdKLNs7qXFrPXBujdV4P8Xp1+Y0+vARvBoBWo9bT1PBVoKitaUL8U9aUolvScwshhBCiulv70zoA9u0/wP4DB83LlWvBwuYtW82vNRoN//fCczfd1i0DLGOLkn//t3ZmqS1IE4MhyllNmmFynwdMj4YZl6GPO2xIh4Up8Gdddb3eqGYZ9LVRk1S84AudoqG9M7RxUefB6uUGETcEZKfz1WyC39RSX0c5wceJcCgHVl2F7qVv7RNCCCGEEEJYoQH97yuzbZV6DFZZWH5V/ffNC+pPUYbm8EMYfHAJRidAbXv1dYdrqdi3Z0OXaDjTEELtoa2LGjS9exFSCuAeN/i6eJdJPrykZhHUXMsceLerOtar4yno5Aov+ZXb7gohhBBCCCGqgODg6wknDAYDeoMBB3v7YkkvSqNCA6zJNdSfm3nQS/0pSWdXUG5oRXvSW/25lfmhxZdND1F/hBBCCCGEEAIg/nwCO3fu5kpysnmZn68vrVq2oFatElpybkISlAshhBBCCCGqtfjzCfy8bgNarZYO7dvSo3tX2rdrAxr4ef0vxJ+/TUKKIiq0BUsIIYQQQggh7jS7du2hdlgoPe+9x2J50yaN+eXX39mzZx81Q27RFa8IacESQgghhBBCVGspqanUr1+vxHX169cjuUi3wduRAEsIIYQQQghRrTk5OZKVlVXiuqysLGxsS5hs9yYkwBJCCCGEEEJUa+G1w9i5azfnbxhrFX8+gZ279hBeO6zU25IxWP+QNU0wCzLJrBBCCCGEEK1aRpGYeJk1P63Dzs4OJydHcnJyMRgM+Pn50q5t61JvSwIsIYQQQgghRLVma2vLwAH9OHvuHBcvJpKfn4+Dgz2BgQGE1qqFxjSpbilIgCWEEEIIIYSo9jQaDWGhofj6+pKfl4+jowNOTk7/eDsSYAkhhBBCCCGqvePHT7Jv/wEyMjPNyzw9PGjduqWMwRJCCCGEEEKI0jpy9Bibt2ylTnhtWrWKwtHBgdzcXOLOnOWXX3+nZ4/uhIfXLtW2JMASQgghhBBCVGsHDh6iaZPGdGjf1mJ5ZGRdtvy9jd179pU6wJI07UIIIYQQQohqLScnl5ohNUpcFxpai/SMjFJvSwIsIYQQQgghRLUWElKDU9ExJa47c/YswUGBpd6WdBEUQgghhBBCVGu1aoawY+dulq9cTUSdOjg7OZKXl8+Zc+eIjz9P82ZNOHDwMAAaDTRt0vim25IASwghhBBCCFGtbdr8NwCJiUkkJiYVW79v/0Hz7xqNRgIsIYQQQpS9mbNmV3YVyszwF4dVdhWEsAonTp7iz782lbjuyccfwdXV1WLZmp/Wcf58gsWy3j17ULt2GNk5Ofzy6+8kJ6cQERFOl04dzRP+njl7lrjTZ+jetUuZ1LssrwESYAkhhBBCCCHKRESdcGrWDDG/VhSFdet+wc3NtVhwBZCamsa993QjKDjIvMzB3h6A/fsP4ujgwOBBA/hp3QbOnj1HWFgoAHv3HqDHPd3Kd2f+JQmwhBBCCCGEEGXCxsYGG5vrIcbhI0fJzMqif7++xcrq9Xqys7Px9/fH2cmp2Pq0q1epHRaKl5cnAf5+pF29ShgQd/oM3t5euLu7leeu/GsSYAkhhBD/gjV1jwPpIieEKHt6vZ7de/bRulUUDg72xdanpqah0+lwdXUp8f2uLi4kJ6dQUFBAamoaYWGhKIrC3n376XVvj/Ku/r9W4Wna4/LhvljwPAg1DsPI85BnVNedy4ce0eB8AOofgw3pt97W0lSocxSc9kP/WLhsuL5uWxaEHwHfQ/DNFcv3jTwP36aU6W4JIYQQQgghijh67AQ6nY676tcrcX1qWhr29vb8+tsfzFvwHUuXr+TsuXjz+mZNm3D2XDyzv5mHo5Mj4bXDiIs7ja+vD25uxbsb3ikqtAVLb1SDq7scYHskXC6Ap86q6ybXgP5xUN8B9tSDtekwKA6ONYCw4gEve7LhybPwZU1o7gQjzsMTZ+GXCHX98Hh41hdaOkHfWBjgCT42kGiAPzPh05LnERNCCCGEEEL8R4qicOz4cRo3aohOpyuxTFpaGgaDgbDQWkS1aE7c6TOsW/8Lgwb2J8DfHw8Pd5547GHy8vJxcnJEURT27T9Ir149iI07zY6du3BwcOCebl3x8HCv4D28uQoNsHbnQGw+7K4HLjqoD3wYDK+dhz7ucCoP/o4EVx3c5Qh/ZMDcZBgfXHxbn1+GQZ7wPx/19cIwqHkEYvOgjgOczIOBHlDXATx0cDpfDbAmJsIof9BpKnLPhRBCCCGsj3SVFTdz5Uoy6ekZREZG3LRM2zatiWrRHPtrSS18fLy5cuUKx46dIMDfHwCtVouTkyMAMbFx+Pn54uToyMZNWxhw/31cuHCRLVu30a9v7/LfqVKq0C6Ckfawvo4aXJlogKuFsDMbmjmpwZVJBxfYkV3ytnZmQ8ci3TVD7KCW3fXyNe1gf47a7TCtEGrYwgU9bM6Eh73KfNeEEEIIIYQQ15yLP4+/vx8uzs43LaPVas3BlYmnpydZ2cUDAEVR2L//IFEtmpGaloZOq8XH25uaITVISio+b1VlqtAWLF9b6G57/bVRgZmXobsbXDJAkK1leX9bSNCXvK0Sy9tcL/9xMDx6BvQKjA2EIDv4v3gYHSCtV0IIIYQQQpSnxKQkgoOCbllmwy+/4ejoSOdOd5uXJScn4+npWaxsdHQMAQH+uLq6kpeXj4ICgNGooChlW/f/qlKzCL6WAAdyYE99mJoE9je0p9lrIP8mByzHWEJ57fXyAzwhxR3yjeBhA+f1auKLz0Ng7AX4PgXaucC8UHCq8FQfQgghhKjqpHucEDeXmppKRJ3wYsuzc3Kwt7PDxsaGsNBQNm7eQmBgAP5+fpyKjubipUSLgAvAaDSy78Ah+vXtBYCHhzuFhUZOnzlLYmIS/v5+FbJPpVUpoYWiqEkpvrgMP9SGBo7goFWDoaLylZsHPyWWN1qWd9SqwRXAR5fgjQDYlQ0/pKrJMwoUdSyXEEIIIYQQouzk5OSaJwwuav6C74iJjQOgXr26tG/Xht279/LDkmWcO3eefvf1xt3dMmHFqegYgoMCcXFRxwfZ2trSqWMHNm7azLlz8dzdvl3579A/UOEtWEYFnj4Hi1JhSW3o76EuD7aFQzmWZRMNEGhbbBPm8okFN5QvKLn8uXw1sJpVE6ZfhtbO6liv7m7wa8Z/3iUhhBBCCCFEES8Me6bE5Te2lDZu1JDGjRreclv160VSv16kxbLIuhFE1r15Ao3KVOEtWCMTYHEqrKwNA4t0r2zjDAdzIbvw+rKtWerykrRxVtebnNdDvL7k8h9egjcDQKtRk2qYGr4KFO64PptCCCGEEEKIqqtCA6ydWWoL0vtBEOWstlCZfjq5qlkA/3cWjuXCJ4lqpsBnr6Vh1xvVcoXXAqIXfNVA7ZsrcCRXnROrlxtEOFj+n6fz1WyCg68Fc1FOaibBQzmw6qramiWEEEIIIYQQZaFCA6zlV9V/37wAgYctfxRgTbg6+XCLE7AwBVaFQ+i1rpvbs9Vy569lCWzrAt/UgvGJ0PYkuOvg29Di/+eHl9QsgpprmQPvdlXTtHc8Bc5aeOnOGhMnhBBCCCGEqMIqdAzW5Brqz83UcYDNkSWv6+wKSgvLZU96qz+3Mj+0+LLpIeqPEEKIf8+aMqhJ9jQhhBBlRRKUCyGEEEIIIUQZkQBLCCGEEEIIIcqIBFhCCCGEEEIIUUYkwBJCCCGEEEKIMiIBlhBCCCGEEEKUEQmwhBBCCCGEEKKMSIAlhBBCCCGEEGVEAiwhhBBCCCGEKCMSYAkhhBBCCCFEGZEASwghhBBCCCHKiARYQgghhBBCCFFGJMASQgghhBBCiDIiAZYQQgghhBBClBEJsIQQQgghhBCijEiAJYQQQgghhBBlRAIsIYQQQgghhCgjEmAJIYQQQgghRBmRAEsIIYQQQgghyogEWEIIIYQQQghRRiotwMo3QsNj8EfG9WUTL4Fmn+XPK+dvvo2NmdD4ODjth86nIDbv+rqTedDkOHgehPcuWr7v88vw/g3LhBBCCCGEEOK/qpQAK88ID5+BY3mWy4/lwct+cKnx9Z8Pg0rexnk99IuFx7xgb30IsIX+cWBU1PVvXoCOLvBnXZiWBIdzrv/fs6/AK/7lt39CCCGEEEKI6qnCA6zjudDmJMTll7yumaMaLJl+XHUlb+ebZGjiCKMD4C5HmBeqBl1/ZarrT+bBfR7Q3Eldf/JaMPflFXjIC9xvsl0hhBBCCCGE+LcqPMDanAVdXGFHPcvlRgVO5UOkQ+m2szMLOrpef+2kVYOpHdnq65p2sD8HrhaowVxNO8gxqoHZy35lsy9CCCGEEEIIUVSFB1gv+MK0EDUgKuqs/noAVOsI1D8GkxKvd/m70SUDBNlaLvO3hQS9+vu4QPg0EbwPQS83aOMCX1xWuxS6SeuVEEIIIYQQohzYVHYFTE5c68IXbAs/11Fbn0ZcS3DxekDx8jlGsNdYLrPXQP61gKydCyQ2hkwjeNtAdiHMS4Hd9WDmZZicBPUcYGEo+NkW27wQQgghhBBC/GN3TIDVxx2Sm6jBEEAjR0guUFudSgqwHLTXgymTfAW8i7RO2WnB+1pL2edX4ElvSC+Ety/CyQZqC9e4i/BlrfLZJyGEEEIIIUT1cscEWHA9uDKp7wAXDSWXDbaFxBvWJRqgoWPxspmFsCBZzTb4W4bachVgCz3c1GyDQgghhBBCiLIRHRPLb7//abEsLCyUPr3uLVY2OTmFjZu3kJKSiqenB5073o2/v5owITsnh19+/Z3k5BQiIsLp0qkjGo3ahe3M2bPEnT5D965dyn+H/qE7JsD6LAnmpsDhu64vO5Bz86QXbVxgS+b11zlGtfzbgSVs+zI85QMuOtBwfVxXgQI3GeIlhBBCCCGE+BdSU1OpHRZKp053m5fZ6IonQTAYDKz9eT0RdcLp1qUzx44f5+f1G3j80Yexs7Nj//6DODo4MHjQAH5at4GzZ88RFhYKwN69B+hxT7cK2qN/ptImGr5RT3eIyVNblGLzYHEqfJIIY651DyxU1BYqvVF9/ZQ37MqGjy6p6d2fPqtmCuzmarnd9EL4LgX+z1d93cwJjubC9ixYkgatnStsF4UQQgghhLB6qalpeHt74+zkZP6xt7cvVi4mNg6dVkuH9m3x8vKkQ/t22NnZERMbB0Da1avUrBmCl5cnAf5+pF29CkDc6TN4e3vh7u5WkbtVandMgBXpoCa3+CMDGh+Hty/AJzXgES91/Xk9BB6G7dfSsIfaw8pwNXiKOgFJBbCmDmhvSHwxPQme9QFn3fX3vR8EfWPVzIXv3WQiYyGEEEIIIcQ/l5p2FU9Pj9uWS0xKIiAwwNztT6PREBgQQGJiEgCuLi4kJ6dQUFBAamoaLi4uKIrC3n37iWrRvDx34T+p1C6CSgvL193cYM9NAtFQ++Lle7mrP7cyroQA6vWAkhNnCCGEEEIIIf69wsJCMjIyOHv2HLt27UEB6oTXpnWrKHQ3dBPMyc7Bw8PDYpmTkyNXklMAaNa0CavX/syx4ycIDg4ivHYYcXGn8fX1wc3thm5rd5A7ZgyWEKLqmDlrdmVXoUwNf3FYZVdBCCGEsApX09MxGo3Y2NrQq2cP0tPT+XvrdgwGPZ063m1RtqCgoFjQpdPpKCwsBMDDw50nHnuYvLx8nJwcURSFffsP0qtXD2LjTrNj5y4cHBy4p1tXPDxu0+pSge6YLoJCCCGEEEKIqs3by4unn3qSrp074ePjTXh4bTp0aMex4ycxGo0WZXU6G3MwZVJYWIitzfU2IK1Wi5OTmiY8JjYOPz9fnBwd2bhpC7169qBuRB22bN1W/jv2D0iAJYQQQgghhCgzjg6WacC9PD0xGo3k5uZaLHd2cSInJ8diWXZOLk5OTsW2qSgK+/cfJKpFM1LT0tBptfh4e1MzpAZJSUllvxP/gQRYQgghhBBCiDIRF3eaufMXWrRMXUlOxt7erljgFODvT2JSEoqiTpykKAqJlxIJCPAvtt3o6BgCAvxxdXVFgwbl2mRLRqOCcofNuyQBlhBCCCGEEKJMBAUHAQobN20h7epVzp49x7btO2nWtAkajYbsnBwKCgoANfmFwWBgy9/bSE1NY+u2HegNBiLqhFts02g0su/AIaJaNAPUsVmFhUZOnznLqegY88TEdwoJsIQQQgghhBBlwtHBgX59+5CZmcXSpSvYuHkLDRvcRYvmanA0f8F35nmu7Ozs6Nu7F4mJSSxZtoJLiYnc16cXdnZ2Fts8FR1DcFAgLi4uANja2tKpYwc2btrMuXPx3N2+XcXu5G1IFkEhhBBCCCFEmfH19WHA/feVuO7GzL3+/n4MeXDQLbdXv14k9etFWiyLrBtBZN2I/1bRciItWEIIIYQQQghRRiTAEkIIIYQQQogyIgGWEEIIIYQQQpQRCbCEEEIIIYQQooxIgCWEEEIIIYQQZUQCLCGEEEIIIYQoIxJgCSGEEEIIIUQZkQBLCCGEEEIIIcqIBFhCCCGEEEIIUUYkwBJCCCGEEEKIMiIBlhBCCCGEEEKUEQmwhBBCCCGEEKKMVFqAlW+Ehsfgj4zry1ILYHAcuB2A0CPwbcqtt7ExExofB6f90PkUxOZdX3cyD5ocB8+D8N5Fy/d9fhnev2GZEEIIIYQQQvxXlRJg5Rnh4TNwLM9y+f/OQkohbKsH7wbCsHOwPavkbZzXQ79YeMwL9taHAFvoHwdGRV3/5gXo6AJ/1oVpSXA45/r/PfsKvOJfbrsnhBBCCCGEqKYqPMA6ngttTkJcvuXyuHz4KR2+rgmNHOEpHzV4mnWl5O18kwxNHGF0ANzlCPNC1aDrr0x1/ck8uM8Dmjup609eC+a+vAIPeYG7rrz2UAghhBBCCFFdVXiAtTkLurjCjnqWy3dlQ6At1HG4vqyDC+y4SQvWzizo6Hr9tZNWDaZ2ZKuva9rB/hy4WqAGbzXtIMeoBmYv+5XtPgkhhBBCCCEEgE1F/4cv+Ja8/JIBgmwtl/nbQoLhH5bXq7+PC4S+sfDWBbUlrI0LTEpUf3eT1ishhBBCCCFEOajwAOtmcoxgr7FcZq8BvQKKAhpN6crnXxuD1c4FEhtDphG8bSC7EOalwO56MPMyTE6Ceg6wMBT8bgjUhBBCCCGEEOLfuGPStDsUCY5M8hVw1BQPrgActCWXdyqyR3ZaNbgC+PwKPOkN6YXw9kXYWQ/ucoBxkk1QCCGEEEIIUUbumAAr2A4Sb+gOmGhQx2WVWN629OUzC2FBMgz3hd3ZastVgC30cIOd2WVTfyGEEEIIIYS4YwKsNs5wwQBni2QX3Jqljp0qsbyLut4kxwgHctTt3Oizy2pWQhcdaLieyr1AAaV4cSGEEEIIIYT4V+6YAKu2PdzrBk+cVeesmp8Mi1LVVieAQkVtodIb1ddPeauZBz+6pKZ+f/qsmimwm6vldtML4bsU+L9r22nmBEdz1fm1lqRB6xICMiGEEEIIIYT4N+6YAAvUhBMeOmh9Ej64BHNqQdtrLVjn9RB4GLZf69IXag8rw9XgKeoEJBXAmjqgvWG81vQkeNYHnHXX3/d+kJph8Kwe3guqsN0TQgghhBBCWLlKzSKotLB87WcLa+uUXDbUvnj5Xu7qz62MKyGAej1A/RFCCCGEEEKIsnRHtWAJIYQQQgghRFUmAZYQQgghhBBClBEJsIQQQgghhBCijEiAJYQQQgghhBBlRAIsIYQQQgghhCgjEmAJIYQQQgghRBmRAEsIIYQQQgghykilzoMlhBBCCCGEsC7p6en8vXU7lxITsbGxJaJOOG1at8TGpnjoseandZw/n2CxrHfPHtSuHUZ2Tg6//Po7yckpRESE06VTRzQaDQBnzp4l7vQZunftUiH79E9IgCWEEEIIIYQoE4WFhfy8/he8PD0ZNOB+cnNz+XPjZgA6tG9brHxqahr33tONoOAg8zIHe3sA9u8/iKODA4MHDeCndRs4e/YcYWGhAOzde4Ae93Qr/x36F6SLoBBCCCGEEKJMJF2+THp6Bt26dcHLy5Pg4CBat4oiOjqmWFm9Xk92djb+/v44OzmZf3Q6HQBpV69Ss2YIXl6eBPj7kXb1KgBxp8/g7e2Fu7tbRe5aqUmAJYQQQgghhCgTnh4e3NenF3a2tuZlGo2GfL2+WNnU1DR0Oh2uri4lbsvVxYXk5BQKCgpITU3DxcUFRVHYu28/US2al9s+/FfSRVAIIYQQQghRJhwdHQkJqWF+rSgKh48cpUaN4GJlU9PSsLe359ff/uDipURcXJxp1TKK0Fo1AWjWtAmr1/7MseMnCA4OIrx2GHFxp/H19cHNzbXC9umfkgBLCCGEEEIIUS62bttOcnIKgx8YUGxdWloaBoOBsNBaRLVoTtzpM6xb/wuDBvYnwN8fDw93nnjsYfLy8nFyckRRFPbtP0ivXj2IjTvNjp27cHBw4J5uXfHwcK+EvSuZBFhCCCGEEEKIMqUoCn9v3c7RY8fpee89eHt5FSvTtk1rolo0x/5aUgsfH2+uXLnCsWMnCPD3B0Cr1eLk5AhATGwcfn6+ODk6snHTFgbcfx8XLlxky9Zt9Ovbu+J27jZkDJYQQgghhBCizCiKwp8bN3H02HHuvacbta9l/ruRVqs1B1cmnp6eZGVnl7jN/fsPEtWiGalpaei0Wny8vakZUoOkpKTy2I1/TQIsIYQQQgghRJnZum0H0dGx9OrZg/Dw2jctt+GX39i0+W+LZcnJyXh6eBQrGx0dQ0CAP66urmjQoKAAYDQqKEqZVv8/kwBLCCGEEEIIUSYSE5M4dPgIrVtF4efnS3ZOjvkHIDsnh4KCAgDCQkM5cfIUp6JjuHo1nV2793DxUiJNGje02KbRaGTfgUNEtWgGgIeHO4WFRk6fOcup6Bj8/f0qdidvQ8ZgCSGEEEIIIcpEbNxpAHbs3M2Onbst1r34/LPMX/Ad3bp2pn69SOrVq4veoGf37r1kZWfj7eVFv/t64+5umbDiVHQMwUGBuLio6dxtbW3p1LEDGzdtxsnRiXt7dK+YnSslCbCEEEIIIYQQZaJD+7Z0aN/2puuHvzjM4nXjRg1p3KjhTUqr6teLpH69SItlkXUjiKwb8e8rWo7uuC6CP6SCZp/lz/2xJZc9lANtT4LTfmhxAvYUGQ+XaIC7T4HbAXjuHBZ9M3+6CkPPludeCCGEEEIIIaqjOy7AOpYLAzzgUuPrPwtCi5fLLoResdDGGfbVh7tdoE8sZBaq6z9JBF8b2FkPfs+An9Kvv3f8JXgnsCL2RgghhBBCCFGd3HEB1vE8aOwIAbbXfzxK6Mi4JA1sNTClBtR3hGk1wF2nLgc4mQc93eAuRzUIO5mnLl+VBo0cobZ98W0KIYQQQgghxH9x5wVYuRDpcPtyO7OhvTNoNeprjQbau8COLPV1TTs4kAN5RjiWp75WFPgoEd6W1ishhBBCCCFEObijAiy9EeLy4ed0qHMUwo/AGwmQbyxe9pIBguwsl/nbQIJB/X2UP6xLB+cD4GcDgzxh+VVo7gSh0nolhBBCCCGEKAd3VBbBmHwoAJy1sKK2GmyNOA+ZRviipmXZHCPYayyX2WuvB2MRDnCmEaQUgJ8tGBWYeAlWhcPyNHjzAvjYwMJQtawQQgghhBBC/Fd3VIDVwBGSm4D3tVo1cQIFePgMfBYCNkUCKgcN5N8wa3O+EZyKtMnpNGpwBbA0DVo5q6+fOwebI2FjJrx8HjbcmRkehRBCCCGEEFXMHdVFEK4HVyb1HcCgwJUCy+XBdmoq9qISDRBoW3ybRgU+ToSxgXAiD+w0aqKLHm7qWC4hhBBCCCGEKAt3VIC1Mg38D6ljsUwO5ICHDgJuCLzaOMP2rOvzWykKbMtWl99ocSq0c1ETXWgA0+YLFLWFTAghhBBCCCHKwh0VYHVyVQOe5+IhOk9NUvH6BXjdX80SmGiA3GvR0QOekGWEl86rmQdfS1DnwHrIy3KbhYo6J9bYAPV1XXu1K+Gaq7AoFVqXEJAJIYQQQgghxL9xRwVY3jbwawScy4fmJ9SxUs/7wJvXgqPAw7AkVf3dTQfr6qitWM1PwLYsWF8HXHWW2/w+VQ3calzLOOisg1k14dlzagA3vUbF7Z8QQgghhBDCut1RSS4AmjnBxsiS1yktLF+3dIb9d916e096qz9FPeqt/gghhBBCCCFEWbqjWrCEEEIIIYQQoiqTAEsIIYQQQgghyogEWEIIIYQQQghRRiTAEkIIIYQQQogyIgGWEEIIIYQQQpQRCbCEEEIIIYQQooxIgCWEEEIIIYQQZUQCLCGEEEIIIYQoIxJgCSGEEEIIIUQZkQBLCCGEEEIIIcqIBFhCCCGEEEIIUUYkwBJCCCGEEEKIMiIBlhBCCCGEEEKUEQmwhBBCCCGEEKKMSIAlhBBCCCGEEGVEAiwhhBBCCCGEKCMSYAkhhBBCCCFEGZEASwghhBBCCCHKiARYQgghhBBCCFFGbCq7AjfKN8JL52FZGthr4DV/GB1QctlDOfB8vPpvfUf4qia0dFbXJRpg8Gl13UNeMLsmaDTqup+uwsqrMD+0AnZICCGEEEKIaqSwsJDNf28lLu40Oq2Opk0b07xZ0xLLJiensHHzFlJSUvH09KBzx7vx9/cDIDsnh19+/Z3k5BQiIsLp0qkjmms39GfOniXu9Bm6d+1SUbtVandcC9brCbAjC/6IgNm1YPwl+DG1eLnsQugVC22cYV99uNsF+sRCZqG6/pNE8LWBnfXg9wz4Kf36e8dfgncCK2Z/hBBCCCGEqE62bd9JYuJl+t/Xl86dO7Jn736iY2KLlTMYDKz9eT0B/v48+MBAggID+Hn9BvR6PQD79x/E0cGBwYMGcP78Bc6ePWd+7969B2jZokWF7dM/cUcFWNmF8E0yTAuBFs7Q30NtvZp5uXjZJWlgq4EpNdTWq2k1wF2nLgc4mQc93eAuRzUIO5mnLl+VBo0cobZ9he2WEEIIIYQQ1YLBYODY8RPc3b4tfn6+1A4LpXmzphw5cqxY2ZjYOHRaLR3at8XLy5MO7dthZ2dHTGwcAGlXr1KzZgheXp4E+PuRdvUqAHGnz+Dt7YW7u1tF7lqp3VEB1qFcyFegg8v1ZR1cYE8OFCqWZXdmQ3tn0F7r9qfRQHsXtfULoKYdHMiBPCMcy1NfKwp8lAhvS+uVEEIIIYQQZS45OYXCwkICA6+P8QkMDCDp8mWMRqNF2cSkJAICA8zd/jQaDYEBASQmJgHg6uJCcnIKBQUFpKam4eLigqIo7N23n6gWzStup/6hO2oM1iUDeOnAoUjY528DegUuF0CgrWXZSAfL9/vbwMFc9fdR/tAtGr5Ohi6uMMgTll+F5k4QeovWq7y8PI4ePXrT9RcvJPzzHbuD7d279x+/R46BdR2D6r7/IMcA5BhU9/0HOQbVff9BjgHIMbjd/jds2BAHB4dblsnOycHBwQEbm+thhpOjI0ajkdzcXJydnc3Lc7Jz8PDwsHi/k5MjV5JTAGjWtAmr1/7MseMnCA4OIrx2GHFxp/H19cHNzfUf7l3FuaMCrBwj2N/QpmZ6nW8soaymeFlTuQgHONMIUgrAzxaMCky8BKvCYXkavHkBfGxgYaha1uTo0aM8+uijZbpfd7IVy5dWdhUqXXU/BtV9/0GOAcgxqO77D3IMqvv+gxwDkGNwu/1ftGgRUVFRtyxTUFCATmd5Q6/T6QAoLDSWUFZXrGxhoZpUwcPDnScee5i8vHycnBxRFIV9+w/Sq1cPYuNOs2PnLhwcHLinW1c8PNxLtY8V4Y4KsBy0xQMp02unGwIvB43anfDGskXL6TRqcAWwNA1aOauvnzsHmyNhYya8fB42RFx/T8OGDVm0aFHZ7JAQQgghhBBWomHDhrctY6PTFQukTAFT0VYtAJ3OxryuaFnbIuW0Wi1OTo6AOmbLz88XJ0dHNm7awoD77+PChYts2bqNfn17/6t9Kg93VIAVbAtphaA3gt21QCmxQG2p8rqhpsF2air2ohINlt0ITYwKfJwIa+vAiTyw06iJLmw1MO6iZVkHB4fbRuZCCCGEEEKI4pydncnPz6ewsNDcOpWTm4NOp8PBwXKcjrOLEzk5ORbLsnNycXJyKrZdRVHYv/8gfXrfS2paGjqtFh9vb3RaLbv3/POuneXpjkpy0dRJDX62Z19ftjULWjiBzQ3dAds4w/YsNXEFqP9uy1aX32hxKrRzURNdaABTTF2ggFK8uBBCCCGEEOJf8PHxRqvVculaogqAS5cS8fX1Qau1DD0C/P1JTEpCuXZDrygKiZcSCQjwL7bd6OgYAgL8cXV1RYMG5dpdvNGomOOBO8UdFWA5aeFJb3gxHnZnw9qrMDkRRqhzjZFogNxr0dEDnpB1bVLi47nwWoI6B9ZDXpbbLFTUObHGXktkUtde7Uq45iosSoXWJQRkovIoRc4Q5U47WyqIHIPi+11dj0N1Vt3Pg+q+/yDXASHnQVVla2tLvci6bN7yN0lJlzlz5iwHDh6mSeNGgJoEo6CgAIA64bUxGAxs+XsbqalpbN22A73BQESdcIttGo1G9h04RFSLZoA6Nquw0MjpM2c5FR1jnpj4TqFR7rBPbI4RXjgHK66Cmw5G+qs/AJp9ML8W/M9Hfb0nG4adg+N50NgRvqypzp9V1LcparmZNa8vW5QCryZAgC0sCVPn0boTbNmyBaPRSGFhId26davs6lSK9PR0HB0dsbOzA9QLqil1Z3VR3Y/BokWLiIuLQ6vV0rp1a7p164ZWq7XoamDtDAYDtrbX+zsbjcZiT/2sXXU/D3Jyciy6yFS3z4BcB1TV/VpQ3a8DVZnBYGDTlq2cjjuNrZ0dzZo2plnTJgDMnDWbbl07U79eJABJSZfZtPlvUtPS8Pb2onPHu/Hz87XY3omTp7h8+QqdOnYwLzsVHcPWbdtxcnTi3h7d8fLyrLgdvI07LsCqrj755BPWrFmDv78/CQkJNG7cmGHDhtG8efNiAwKt1cyZM9myZQtarRZPT0/eeecdgoKCKrtaFaq6H4NZs2bx7bffMnDgQI4dO4bRaMTFxYWZM2diY2NTLW6u5s+fz+HDh9FqtTRq1IjHH38cnU5XrW4sqvt58NVXX7Fr1y50Oh21atVi1KhRODreIU8CK4BcB1TV/VpQ3a8DRVWXv7k1qT6PQe5gMTEx/PXXX3z55Zd89913/PHHHxgMBj7//HPWrl2LXq+v7CqWu6VLl/Ldd9/x+OOPM2jQIAwGA4MGDWLdunVkZWVVdvUqRHU+BoqikJ2dzdatW3njjTcYM2YM8+fPZ9iwYSQnJzNgwAAMBgM6na7YJIXW5JtvvuGrr74iMjISnU7Hr7/+ysCBA0lOTq42X67V+TwA+Pbbb5k/fz733HMPDRs25NSpU/Tp04dDhw5VdtXKnVwHrqvu14Lqfh0oqmhwtX37drZv317JNRKlIQHWHSA7O5uMjAz8/PxwcXHB3d2d2bNnExgYyKpVq/j111/NfVWtVUxMDP369eO+++5j8ODBzJkzh169ejFlyhQ2bNhQLMOMNarOx0Cj0ZhvmkxPpnU6He3bt2fixInY2toyZMgQCgsL0Wq1VtcXX1EU9Ho9u3fvZvjw4Tz//PN8+umnTJgwATc3Nx588EHOnTtnLmvNqut5oCgKRqORw4cP88QTT/DII4/wyiuvMHfuXBo2bMhzzz1n9TdW1f06AHItMKmu14EbGY1Gi+Dqiy++YMmSJRw7dqySayZuRwKsO0CtWrWoWbMmO3bsMF8wHR0d+eCDD/Dz82Pp0qVER0dXci3Ll6OjI6dPnyY3N9e87N133+Xee+/lyy+/NN9YWPMXSnU/Bg4ODvj5+fHtt9+al2m1WiIiIpgwYQK2traMHDnSKrtKaDQa7OzssLGxISMjA1D/zmFhYXz55ZeEhYXx9NNPk5mZiUajseqn99X1PNBoNGi1WhwcHLh06RKKoqAoCvb29syYMYOOHTsycuRITp48CWC1n4HqfB0AuRaYVNfrwI1M4+0+/fRTZsyYQXp6Ohs3bmTevHns3XtnpSUXliTAugM4OzsTGhrKunXriI2NNS93cHBg/Pjx5OTkMHPmzEqsYfmrV68eiYmJHDlyBLg+Id2YMWPo0KED77zzDunp6Vb5hWpSnY+B6SZh1KhRFBQU8Pbbb1usr1OnDs888wwpKSlW/eSuRo0arF271vzUsqCgABcXF6ZPn46fnx/PPPOM1Q9yr87nAUBYWBg7d+7kwoULaDQacxfxSZMm0bx5c15++WUKCgqs8jMg14Hrqvu1oLpfB4r6+++/WblyJaNHj2bJkiUsWLCA3NxcVq9ezYEDByq7euImrPPMrEIURcHOzo4xY8Zw6dIlPv30Uy5cuGBe7+joyKRJkzh8+LD5yaU16t27N7Vr1+bNN9/k/Pnz6HQ68wX1gw8+oHbt2nz++eeVXMvyVZ2PgekmISAggKFDhxITE8NHH31kXm9jY0Pbtm2Jj4/n4MGDlVTL8mN6Cvv6669jZ2fHs88+C6j7XVBQgKurK++88w5arZY///yzMqta7qrzeQDwzDPPEBAQwPDhwzEajdjZ2ZmDrIkTJ+Lh4cHChQsruZblo7pfB0CuBSbV/TpQVFJSEoGBgTRv3hxnZ2eaN2/Oc889R1xcHPPnz+fo0aOVXUVRAgmwKonpIqrRaCgsLMTLy4sFCxZw4sQJxo0bx/Hjxy3Kuru7W20WKdNF8/PPPycoKIhnn32Wc+fOWWSJqlu3rlUPbJVjoLKzs6N79+7cd999HDp0iDFjxpjXubi4EBkZaZXngUajMT9sGTduHMnJyQwfPhzAnEU0LCyM/Px8Tp06VZlVLVfV/Tww7f+UKVMoLCxkyJAhGAwGc4pqJycnvL29SUxMrMxqlouik4xW1+sAyLUAqvd1oKQun4GBgWRmZppb8wCaNm3KQw89xG+//cbixYs5fPhwRVZTlIIEWBVo3bp1/PLLL8D1iyiog3gLCgrw8/Nj5cqVXL58mSlTpvD111+zZ88eVq1ahV6vt5gTxZoUzQg1e/Zs/Pz8GDp0KH///TcpKSkAFBQUUFhYSEFBQZXvc20wGIplhqxOx2D+/Pm8/vrrJX6RKIqCi4sLAwYM4IknnuDkyZP06dOHjz/+mNdff509e/YQFRVVCbUuP6abCVNXlyZNmvDqq68SHx/PE088gV6vR1EUHBwcqFGjhvlm21oU/SxXp/Pg66+/trhhAsw3kP7+/kybNg29Xs/AgQM5c+YM2dnZ2NjY4Orqak6IUZX3f82aNcyePZuPPvqIhIQE8+ff9N1Y3a4DRVXXa4FJdboOFFW0y2d0dDRXrlwhOzub+vXr4+Pjw5o1azhz5oy5vK+vLw0aNCAhIYENGzYA1j8mrSqRebAqgNFoJCMjgwcffBAXFxdeeuklunTpAlim3ywoKMDGxoa0tDS+/vprDhw4QEpKCo6Ojnz88cfcddddlbkb/9mSJUtITEwkNjaWwYMHEx4eTnBwMFB8jofXX3+d06dPk5GRQVBQEEeOHOHHH3+kbt26lVX9MvHNN99w4sQJYmJiGDRoEO3btyciIqLEstZ6DObMmcPkyZMZNmwYr7zySrE+9KbPgum8mTlzJlevXkVRFJ577jkiIyMrqeZl46effiI5OZnc3Fyefvpp7O3ti83rYzAYOH78OO+//z7p6ek0aNAAUPvir1ixgtq1a1dW9cvEmjVryMvLY8iQIcCt53ixxvPg448/ZsGCBWzYsIGwsLCblktNTeX1118nISEBT09P3N3d2b17N8uWLaNOnToVWOOyNWXKFNauXUvjxo25cOECCQkJzJgxgzZt2phvMq39OgCwdetWnJ2dadas2U3LWPO1YMGCBZw+fZqkpCQee+wx6tSpQ2BgIFB97glKMmnSJNasWQPAvffey4svvsipU6d4//33iYqKok2bNtx1111MmDCBunXr0qZNG/7v//6PVatW3fR+QlQ8CbAq0Pvvv8/GjRtp0KAB9913Hz179gQsn1qYbrSMRiMFBQWkpqbi7OyMq6trZVb9P/vss89YtmwZgwYN4vTp0yQkJFC7dm2GDh1Kw4YNgetpik03mnv27OHMmTMUFBTQvn17atWqVZm78J/NmDGDH3/8kZdffplTp04RFxdHjRo1GDVqFF5eXuZyRW+2re0YAGzevJlXXnmF3NxcBgwYwMSJE4uVKWnwtjVMLjp58mTWrl1LREQEiYmJaLVaVq5cia2trfmG4sYbi2+++Ybk5GQMBgOPPPJIlb6xNpk4cSK//fYbY8eO5Z577gGK31BZ63kwYcIEVq9ezcKFC6lXr57Fft/sM/DTTz9x8eJF9Ho9ffr0qdI31Xv37uWtt97i888/N98cjxgxglOnTvHzzz+bu8FByYG3NVwHjEYjWVlZvPjiiwQEBPDMM89Qr169277Pmq4Fs2bNYuHChTz44IPExcWRkJBAZGQkDz/8sDngtPZ7AhPTw3WAXbt2MXLkSCZMmMChQ4fYt28fPj4+vPXWW5w+fZrFixezZcsWAgICsLe3Z/HixSiKwhNPPMHEiROr9LXB6iiiwsycOVPp2rWr8tprrylPP/20smHDBov1BQUFlVSz8nXlyhXlwQcfVH7//XfzsnXr1in9+/dXHnvsMeXIkSPm5Uaj0SqPw5UrV5SHH35Y2bx5s3nZ0qVLlVatWilHjx4tVt4aj4FJXFyc8sILLyi7du1SWrVqpbzxxhvmdTk5ORZlY2Njzb8bjcYKq2N5OH78uNKnTx/l5MmTSn5+vnLo0CGlV69eSnJycrGyRqNRKSwsLLasqjPtw+eff640bdpUuf/++5VVq1YVW29ibefB0qVLlcjISCUmJsZiuV6vV/Ly8iyWWeu1cPv27UrPnj2Vixcvmv/e27dvV+6++26L870oa7oOKIpiPreHDRumtGrVSnnnnXdK/B64sbxJVT8GBQUFyrBhw5QlS5aYl/3666/KiBEjlEcffVTZvXu3ebm1ngeKoijvvPOOkpWVZX69aNEiZezYscrMmTPNy37++Wflf//7n/Laa68ply5dUhRFUZKSkpTY2FglIyNDURRFmTx5snLPPfeU+F0iKo+MwapAHTp0oGPHjrzwwgs4OTmxcuVKduzYwYIFC8jMzDQ/pZkxYwZLly6t5NqWHdNg3KLjjnr37k2LFi04cOAAM2fONCf1ME00uXnz5sqqbrkwGAycOnXKYk6PwYMH4+7uztatW4HiY1Gs7RiYhIaGcvHiRTQaDdOnT+fXX3/lww8/5JNPPuGvv/4y971funQpEydONA9krurpeDUaDRkZGeTn52NnZ0dAQAAZGRlMmjSJYcOG8ccff5CcnGwuq9VqrS47lOlveObMGSIjI2nVqhULFy40d4cpOjYVrO88CAsLQ6vVmuc1NBgMjBo1imeffZY+ffowe/Zs81Qdpmvh7t27K7PKZc5gMJCYmEheXp758xAcHExGRgZJSUnFyi9dupQJEyZYzXUArmdLzM7OJiwsjFOnTrF48eKbpp63pmuBcm0i5XPnzlkkqejRowePPfYYgYGBfPHFF+akDdZ6T3DixAkKCgosxtGdPXuWFStWcP78efOyPn36MHjwYNLS0pgyZQrHjh3Dz8+PnJwcRo8ezYMPPsiKFSuYPn063t7elbEr4iYkwConJQ3g9/DwYPPmzeZxWB4eHrz55pt8+eWXFBQUAGowAlT58VbKtUkyFUXB09OTqKgojh07xtWrV81l7rrrLrp3746bmxu//vqred8PHTrEiBEjSExMtJoBmwEBATRu3JizZ8+Sn59vTmxgb29vnpG+6I3DwYMHeemll6r8MTh37hxHjhwhIyPD/BlXFIWQkBBOnz5N27ZtWbRoEcuWLWPBggU0bNjQfPMRGhrKm2++iYuLS2XuQpmxt7endu3aLF++nPXr1/Pss8/i7++Pj48PTk5OTJw4kWXLlpk/D+vXr+fdd98lLS0NsI4bS0VRyM3NxWAwMGjQIB577DGaNWvGt99+W2KQZW3XgqioKN5++23GjRvHrl27ePfdd0lOTqZ379706NGDzZs3s2DBAi5fvgyo42zGjBnDlStXqvT+b9++nfj4eAA6duzIoEGDzJ9rULPjaTQaDAZDsfeGh4czduxYq7gOmAIKRVFISUkhNzeXN954gxEjRhATE3PTIMuargUajQZHR0d69+7Nzz//TFxcnHldVFQUgwcPxs3NjeXLl5OamgpY33UA1Hm+PvroI2xtbVm5ciWZmZmMHTuWp59+mrVr17Jp0yZz2d69e/PAAw8QFxfHxo0bAfV+8t5772Xw4MEsWbKkyt8zWqVKaDWzeqtWrVL++usvxWAwmJcVFhYqBQUFyv/+9z8lOjpaURRFef7555VmzZopjzzyiLJp0yaLslVdYmKioijXuzJ89dVXSu/evZW5c+cq+/fvV06cOKG0bdtWWbNmjbJ27VqlY8eO5vdkZGQoKSkplVb3srJr1y5lw4YNyrZt25T8/Hxl7969yqFDh5TCwkLz37h///7KpEmTLN6XlpamKIpS5Zv7p0yZovTt21dp0aKFMmTIEGXmzJlKdna2oiiKsmDBAuXdd99VFEVR3nzzTaVjx45K06ZNlXHjxlVijcteYmKicvr0afPrJUuWKIMHD1Z69eqldOnSRUlNTTWvmzt3rtK+fXvl3LlziqIoyokTJ5T4+PgKr3NZO3funHLixAlFr9ebrwd79+5Vjh8/riiK2v3rww8/VAYMGKCsXr3a4r3WcC0w7X9+fr5iNBqV/Px8Zfz48cqAAQOUp556yuI8X7t2rdKjRw9zt+mEhATzdbEqKiwsVOLj45XIyEjlo48+UuLi4szr9Hq9+fekpCSlTZs2Ft+D8+fPt3hd1b399tvK22+/bdHdbeXKlebuj3/88YcyePBgZezYscW6C1rDteDkyZPKnj17lCtXrigFBQXK0aNHlaefflqZMGGCcvHiRYuyP//8s3LPPfcoJ0+eVBTFOq4DRRXt4nnhwgWlb9++ygMPPKBkZmYqiqIoH3zwgVK/fn3l77//tnjf9u3brba7pDWSAKscvPrqq0r37t2VrVu3WgRZiqJeZOfMmaO8+eabSvfu3ZVff/1Vef3115UhQ4Yof/75ZyXVuGwdPXpUiYqKMl8cTT7//HPl0UcfVVq0aKG0adPGfIOtKIrSvXt3ZcWKFRVd1XLz6aefKj169FDuuecepX///srQoUOVq1evFivXv39/Zfz48ebXX3zxhfLqq68q+fn5FVndMrd48WKlXbt2ys6dO5XTp08rn332mTJo0CDzOLz169crjz32mDJ27FilW7duSnx8vHLw4EElMjJS+fDDDyu59mVj+vTpyoABA5RWrVopjz76qLJ+/XpFURQlPT1d2bp1q/LEE08Uu2no0aOHsmDBgsqobrmYPHmy0rdvXyUqKkoZPHiwcujQIYv1phuNokHW2rVrK6Oq5aLo/j/wwAPK4cOHFUVRA8z7779f6devn5KRkWHxUK1v377K9OnTK6vKZcr09+3fv7/Spk0bZerUqRaBgmm/z5w5ozRt2lTZtm2boiiK8tlnnymRkZHKqVOnKr7S5WDixIlK8+bNiwVOpptl03EqGmQdO3aswutZXj799FPl3nvvVVq1aqUMHjzYPP580aJFypAhQ5SpU6cqFy5csHhP//79lWnTplVCbctXSQ/QDx48qDz22GPKkCFDzEHW+++/rzRo0EDZunVrsfISZFUN0kWwDJm6QIWGhnL+/HneeecdduzYYdFdMDw8nEmTJnH06FG+/PJLc7/jsLCwUmURqgqcnZ3JzMzk1VdftZgwefjw4XzyyScsXLiQRYsW8f777wOQm5uLl5cXfn5+lVXlMrV+/XrWrFnD9OnTWbp0KWPHjiUnJ4fPP//cPHeNcq2bg8FgME+YOX36dD7//HOeeeaZKj2/iaIoxMTEMGTIEFq3bk1YWBgvvPACoM4FB2o3ofj4ePbv38/s2bMJCQmhSZMmLF68mEceeaQyq18mvv32W5YtW8bLL7/MnDlz8Pf3Z/bs2URHR+Pm5kaNGjXIzMzk4sWL5vfk5eXh6+trnrqgqluyZAnLly/n7bffZuXKleTl5bF48WKLMqausuHh4Tz88MO0bNmSzz77jPXr11dGlcvUjfufn5/Pd999B0CLFi0YPnw4U6dOxdXV1WKqDm9vb2rWrFmZVS8zpv1q3LgxgYGBrFy5koULF3Lu3DkAi+y5er0enU7HvHnzmDNnDitWrLCKFNyffPIJK1euZNGiReYU6yamcdem86Bbt24MGzaM06dP880333Dy5MkKr29ZM30ffvrpp6xevRovLy9+/PFHAB555BH69OnD9u3bmTt3LqdPnwbU7xBvb2+ruScwKZod96effuLrr79mzpw5NGnShBEjRmBjY8MzzzxDVlYW7777Lg899BBPP/10sUmEq3oWzerC5vZFRGmZ0mwmJyczePBgFEXhtddeY+rUqbRr1w6dTkf//v3ZuXMnr732mjnFauPGjalXr16Vvqkuyt3dHV9fX9zc3HjppZeYPn06jRo1AiAoKIjg4GCSkpKYO3cuPj4+xMfHc+nSJatJL5qcnEyLFi2oX78+AC1btqR+/focPHjQfHE1Go0YDAaMRiN2dnYsWLCAefPmsWzZsirfl1qj0ZCenk5MTIx5ma2tLZ07d+avv/4C1BurV199lRYtWhASEmIu17x58wqvb1nT6/UcOnSIZ555hs6dOwNqWvKePXuyfPlyxo4dS61atfDz82P48OG89dZbODo6cvDgQeLj461ifh9QB2wPGjSI1q1bAzBo0CAOHTrEihUr8PPzo1mzZri4uJhTFIeHhzNo0CDs7OzM14uq7Gb7v2zZMmrUqEHr1q1xcXHh8OHD7N+/H39/f06ePMmJEyfMD5+qOtMNZc2aNalTpw7169fn1VdfxcbGhueff569e/fSrl073N3dqVGjBu+//z4XL14sMRipik6ePMn8+fP55JNPzA9QFUXh1KlTXL58mcaNG+Ps7Iytra35POjWrRsGg4ElS5ZYTN9RVWVkZBAVFUXjxo0BeOyxx1i8eDFLly4lJCSEhx56iJCQEBYvXszzzz9PixYtyMnJ4fDhw7z11luVXPuyZfr+//jjj1m9ejWNGjUiMjKSgoICWrRowahRo5g0aRLPPPMMc+bM4e233yY4OLjK3xNUVxJglbGiXyhPPfUUOTk5jBw5kilTptC6dWs8PT2ZNWtWsTl+rCW4Ati3bx/29va8/vrrLF++nFdeecUcZJnmtDh//jxxcXGsWLECb29vvvrqK4KCgiq76mUiOzubHTt2mF9rNBo6dOjA+vXrSUlJwcvLC61Wi52dHVFRUcycORNHR0cWLVpknhOsqmvZsiXHjh3j4sWL5r+rm5sbqamp5OXl4ejoSP/+/c1PuK1hbhsTOzs7srOzzU+fFUXBzs6Otm3bmp/cA3z11Ve89tprfPrpp+h0Ory8vMytedbgxha6zz77DH9/f/bs2YOXlxeenp5MmzYNT09P83Wzbt26vPTSS1ZxPbzd/ru7uzNz5kwOHTpkfqLv4+PDggULrGZ+H9P3XOPGjZk2bRpPPPEE77//Ph988AGbNm3C1dWV1q1b4+Pjg5+fH/v27WPVqlVW85ChXr16PPzww0ydOpX77rsPrVbLE088QWZmJtHR0dSvX59u3brxv//9DycnJ/N50LNnT+6++26cnZ0rexf+s7y8PHbs2MG5c+dwcHBgwoQJFBYWEhMTg7OzMwaDgR9++IFGjRrxyy+/sGvXLry9vVm0aJHVPHQtatOmTfz222/8+OOPhIaGkpqaSlxcHDExMbRr145XX32Vzz77jEGDBrFq1SqGDh0KWM6VJaoG+WuVMa1WS5cuXcxdPKZOncqoUaPMQZapJcuaubi4cNddd9GoUSPzE+qiQRao2YKaNGlCbm4uOp3OKr5ITHr06MG5c+c4efKk+amlra0tubm55OfnW2SAqlu3LlqtlmXLllXpSSNvdP/999O2bVv8/f3Ny/Ly8rC1tcXBwQFQA88dO3bQpEkTnJycKquqZU5RFGrXrk12djapqal4enoC4Ovra84QptfrsbOzY+rUqVy4cAGtVouzszNubm6VWfUy9cQTT3DmzBlAbdUdMmQIjz/+OO7u7uzdu5cFCxYwc+ZM3nrrLYsHTtYQXMHt93/+/Pl8+eWXjBkzhnvvvRcbGxtsbW2r/KTyNzJ198rIyCA3N5du3brx/fffs3v3bvr27UtGRgYuLi68/vrreHt7W00XWVOwNG7cOM6fP8+zzz5rbrl+66238Pb2ZuHChWzbto3Q0FB69+5tMcm0tVwTH3nkETZt2kSvXr3w9vbG3d2dRYsW4ejoyNmzZ5k0aRKvvPIKs2bN4tFHH+XRRx+t7CqXK71ej7OzM56enubr4P79+8nKyiIsLIzFixfz0ksvsWHDBuzt7c3vk+CqCqqswV/VQdEsSSNHjlRatmypbN261SqyBN5O0cxX0dHRyqhRo5SuXbuaB3kXFhZW+ckSb6awsFBJS0uzGIj6119/Ka1atbJIarBmzRpFr9dbVXYkRSk+Cabp9cyZM5UuXbqYl0+dOlXp2rVrlc6SdjNZWVnKyZMnLT4DEydOVO6//36LckePHlVyc3MrunoVoujnwGg0FptE+uuvv1Yeeughq70OlGb/H3zwwYquVqV54YUXlMOHDytvvPGG0qNHD+W7775TunTporz11ltWeQ0oau/evcqwYcOUu+++W9m+fbvFuhdffFF56aWXKqlmFaOgoEDZvHmzMm7cOGXq1KkW6/766y+lT58+SkJCQiXVrvyUdK93/PhxpXfv3kqXLl2UyMhI5eWXX1ZWrlyp5OTkKFFRUcqvv/5qUV4SWlRdkuSiHNna2poHr06ePJkuXbrw9NNPs2vXrkquWflRriVv8Pf3Nyf3iIiI4LnnnqN58+aMGjXKPBapKs/lcStarRYPDw90Op35eOTl5WEwGMxP6mfMmMHo0aO5cOGCVfSzL+rGv6vpta2trXn/p06dyrx585g+fbpFK5c1MBqNODs7ExkZadFaXVBQYDGHy9SpU3nnnXfM815ZG9PfXbn2RN7R0dFi/+vVq0d6ejrp6emVVcVyVZr9z8zMtJgb0Bop15L62NjY8Oijj3Lw4EG++OILHnvsMUaNGsX+/futvleHaZy1m5ubucu06fuxTZs2pKSkmO8VrJFOp6Njx440atSIQ4cOWZwHgYGBGI3GEucOrcqKJrRYuXIlM2bMYOrUqdSvX5/Ro0fzyCOPMG/ePCZMmMCAAQMwGo3UqlXL3MPDxNrPDWsmAVY50+l05gvnJ598woMPPmh1N5RFFb25LtrtJyIigmHDhlG7dm3ee+899Hq91UwYeCtFgwvT52DGjBnmLFmhoaGVWLuKZfo8TJs2jfnz55v73VubG8dXmtja2pq7eUyZMoX58+fz3nvvWV2AfSPTOXD16lW2bNmCXq9Hr9ezY8cO3N3dLbrBWCPZfw0ajcacJXLGjBnUqVMHRVHo3bs3y5Ytw8fHp7KrWW4URcHW1pbnn3+ehQsXUqtWLfOEwwCnTp3C29vbqr8PTfsWERFBXl4eU6ZMQa/Xk52dzR9//IGDg4NVdY8uLCw0fw988sknfPrpp8TExJgn0+7UqRPPPPMMERER/Pzzz2zatImRI0dSUFBA+/btK7n2oqxIp84KoNPpzAMUP/jgg8quTqWpU6cOo0aNwsXFxWrGWZSWra0tTk5OTJw4kQ0bNrB48WKryJL1TzRo0ICEhAR+/PFHfvjhB6tJ6FFaWq0Wo9HIrFmzmD9/PkuWLKlWn4G4uDg+//xzXnrpJZo0aUJsbCzz5s0zT1Ng7ar7/rdo0cKcNa8oaxlrdDMajQaj0YiDgwMODg5ER0fzySefAOq4zN9//53Fixdb9Rgb00OGevXq0blzZ/744w++++4783fC7NmzcXd3r+Ra/nezZs2ymGZl27Zt/Pbbb/zwww+EhYWRnJzMqVOnOHDgAN26dSMmJoZ169aRlpZGcHAwy5YtMz+Ul5arqk+jWPNjkwpiOhmKNgkLS6ZuMtbsVvuYkpJCr169KCws5LvvvrPKtKumhwimxCU3BtFZWVm8/PLLvPHGG1Yxv80/tWrVKt58803c3d2ZO3eu1QaYNzsP9Ho958+f58CBA/j4+FCnTh1q1KhRCTUsX9V9/293HajuMjMzmTVrFunp6bi5uTF48GDCw8Mru1pl7sbzwHR/pNfrSU5OZseOHQQGBhIaGmoVGYQ3b97MunXrmDBhgjlY3rJlCxMmTOCbb77h0qVLzJs3j8OHD1NQUICrqytLly7FwcGBvLw8vLy80Gg0ki3QikiA9R+ZgqvExESWLl3KU089hYuLS2VXq0LJF+r1z0F6ejppaWnFuv7p9XpmzZpF//79CQsLq5xKliPT/ickJPDiiy/y0UcfWXT/qw4PIUzngSlD4I1SUlJ49tlnmTBhgtVMKn4j0zHIysoiPz8fb29voHo8YAHZ/9tdB6qLm10LTMfH9Hmw1uthdTsP4uPjLSYH/+OPP+jQoQOXL1/m5ZdfJi0tjaSkJHr16kWXLl3o168fHTt25KWXXmLw4MHm91nr56G6kr/kf6AoCjqdjgsXLvDAAw+Ql5dX7YKrwsJCbGxsSEhIYMiQIZw6daqyq1ThTF+aFy5c4MEHHzSn4jZRrs2DNGLEiCodXN3qWYxp/x9++GEaNGhQrHXG1N3BGr9c4fp5cP78eR566CHOnz9fbL23tzdLliyx2uDqxmuBaR4wsN6/e1HVZf//y3WgOrjVteDGbl/W9LkwqS7ngcnLL7/MSy+9xM6dOwGIiYlh6tSpvP/++wQHBzNhwgSee+45vvvuOyZOnEi/fv3Iy8vDz8/PPIWHiQRX1kX+mv+BRqMhLS2NPn360LVrV15//fXKrlK5kC/UWysaZLdq1YrevXtbrDd9qVjjl4uJXq9n5syZdOnShQkTJtx0X6vyMSjNefDYY4+V2PXLdGNla2tbrnUsb6U5BkOGDKFJkya0a9euAmtWMar7/t9Oaa8DVd1/uRZA1f9OkPNAlZycTFpaGnFxcaxevZpt27ZRp04dnnnmGc6cOcO4ceMIDw/n0UcfJTg4mOXLl/Pzzz8zYsQIDAYDXbp0qexdEOVIugjewu7du7l69So1a9bE39/f/LShaDN3fn4+GzZsoF+/flb79OFWzfp6vZ5x48Zha2vL+++/X2W/MG7FlGK96ASgRZvyFUXh22+/5fTp01Z5DBYsWMCxY8fIz8+nc+fO9O3b19ztpehn4/Tp09SuXbsyq1ppcnNzefnllwkMDLTKzwCof2uDwWDR5ano37+goIDPPvuM9PR0qzwG1X3/5TpQOtZ+Laju58GNli5dyrvvvktUVBQBAQEMGTKEli1bsnr1an788Udq1arFhx9+SExMDDNmzCApKYmaNWsyZcoUc3ZhSWhhnSTAuonJkyezatUqPD09ycrKolmzZvTr18/8xMFa+xIXJV+o8Pnnn7Nnzx4SEhLo1asXHTp0oG3btoBlkJWTk2OV2bC+/PJLFixYwMCBAzEYDCxZsoT77ruPgQMHEhUVBWD1XxA//PADsbGx2Nra0rZtWzp16lRiucOHD9O4ceMKrl3FmD17NgcOHCA5OZmePXtyzz33UKtWLcDyWnDlyhV8fX0rs6rlorrvv1wHVNX9WlDdz4Oiin7/v/POOyQnJ5OdnY2rqytDhw4lKirKHGRFREQwbtw4bGxsuHr1Ku7u7pLQohqQAKsER48eZfjw4UyePJnmzZuza9cuNmzYwO7du3n++ee5//77AesOsuQLFRYtWsTMmTMZNWoUer2e9evXY2dnR7t27Xj66acB6z4Ger2eUaNG0bVrV/Nn/vDhw3z00Uf4+fkxZMgQOnToULmVLGczZsxg0aJFdO3aldzcXH755ReefPJJHn/8cXPXH2v+DADMnTuXb775hmeeeQaDwcCyZcto2LAh9957L3369AGs+xhU9/2X64Cqul8Lqvt5UBJTEpN169YRHR1N+/bt+eKLL3B0dOSZZ56xCLK8vLyYPn26+SG1JLSwfhI6l0Cj0eDq6kp4eDharZa2bdsSFBSEp6cn06dPR6vV0q9fP6sNrvR6PSdOnODNN980f6H269ePjz76iG+//Za8vDw6dOhg9RfShIQE7r//fgYNGgTA3XffzbJly/j111/Jzc1l+PDhFhmhrI1WqyUhIYFjx46ZPweNGzfmgw8+YOLEiSxfvhw3NzerfFILkJ6ezv79+5kwYQLdunUDYMeOHYwcOZKMjAyefvpp6tSpY/XnwZkzZxg2bBhDhw4FoHv37nz11VcsX76c3NxcHnjgAas+D6r7/lf36wDItQDkPAB47rnnCA8Pp2PHjrRt29YcLLVp04bZs2dTo0YNPv30U0aPHs28efPQaDTcf//95ObmcuLECYvWKgmurJ/8hUvg5uZGfHw8e/fuNS+rVasWDz/8MP369WPu3Lls27atEmtYvop+oZqYvlAzMzNZvnw5hw8frsQaVoykpCSLDEg1atTg8ccfp0uXLmzdupXvvvsOqLoDlW9FURRsbGzo2bMniYmJxMXFmddFRkbyxhtvEB8fz4oVKyqxluXLwcGBK1eucPr0aUA9Jm3btuXLL79kz549zJ8/n8uXL1dyLctfQkICR44cMb+OiIjglVdeISgoiF9++YXff/8dsM7zAKr3/st1QCXXgup9HgDExsayZcsWFixYwKxZs3jttddIT08nNzcXb29vxo0bx4oVK9Dr9bz99tvk5OSwYMECduzYwcMPP8wHH3xgnmxeVA8SYN3AaDQSEhLCk08+yddff83+/fvN6wICAujfvz+RkZH8/vvvFBQU3DKbTlUkX6jXPfzww1y5coXVq1ebl/n4+PDAAw/QrFkztmzZwvHjxyuvguXI9CXZvn17oqOjWbZsGenp6eb19erVY9y4cSxbtoy//vqrsqpZrrRaLS1atOD8+fNkZGSY561p0qQJkydP5vfff2fRokWVXc1yN2jQIC5fvsyOHTvMy0JCQhg2bBhOTk5s2LCBlJSUSqxh+arO+y/XAZVcC6r3eQBQp04dvvvuOxRFoXbt2sTHxzN06FDmzJnDqVOnaNGiBU2bNmXPnj1EREQwcuRIzp07x/bt283bUBRFWq6qEflL38D04b/nnnsIDg5m/vz5Fk9twsPD6dy5Mxs2bCA1NdXqntbIF+p1YWFhNGvWjN9//52tW7eal/v6+vL4449z6dIliy8ba6MoCg0aNOCtt95i0aJFfP3116SlpZnXm1LwRkdHV2Ity4+trS19+vRhzZo1/PjjjwDmJ5BNmzZl8uTJzJ071+IhjDVq1KgRdnZ2rF27lpiYGPPymjVrMmLECLZt28aWLVsqsYblq7rvf3W/DoBcC0DOA4CWLVsyZ84c1q9fz/Dhw+nbty8XL17kySefZM2aNTg7OzN//nyuXLlCo0aNmD59Oq+++qr5/dZ2vyhuTQKsm2jUqBEDBgzAYDDw1VdfWXQXbNq0KQEBAeTm5lZiDcuPfKGqfHx8ePTRR8nLy2Pp0qUWXx5BQUG0adOG/fv3W10rJqgtuRqNBkVR6NixI9OnT+f7779n1qxZFt0mTeWskaIotG7dmg8++IBp06bx/fffA9e/JNu0aUP9+vWJj4+vzGqWu9DQUP7v//6PAwcOsHDhQovJxMPDw7n77rs5ePBg5VWwnFWn/V+5ciWHDh2yWFbdrwMg1wKoXufBrXTo0IFJkyYxevRoQkJCeOONNxgzZgwLFiwgJSWF2NhY5s2bh16vp3bt2mi1WgoLCyu72qISVOskF6mpqXh6ehb7YjAN0jSlYF27di3vvfceQ4cOJTQ0lD/++IPMzEyLeZGqqpSUFLy9vS2W3fiF+tprr6HX6xk0aBD16tUDrPsL1ZQJSVEU6tWrx6uvvsr06dP54YcfSEpKYvDgwRQWFpKeno63t3eVPw4rV64kOjoajUZDixYt6N69O1qt1nweKIpCt27d+OKLL5g8eTJnzpxBURS8vLw4fPgwb7/9dmXvwn9W0vls+rv279+f7OxsPvzwQzIzMxkyZAheXl7Y2dlha2tr1Q9aTH//Fi1a8N577/HBBx9gMBjo1auX+fqYl5eHv79/Jde2bJSUNrm67P/48eNZsWIF69atK7auulwHSlI021t1uRZU5/OgNDp37sykSZMYMWIEEyZMYMCAATRu3JjDhw/z+++/c+HCBYt5wqw5+Ym4uWqbpv2vv/5iwYIFvP3229StW7fY+qKZcGJjY9m4cSNz587F398fvV7PlClTuOuuuyq62mVq7dq1/PTTT4wePZqIiIhi603HYOvWrUyePBkfHx/zF+rGjRtZunRplZ//auXKlZw7dw69Xk+dOnXMGQNNX6qmYxAdHc3y5cvZvHkzAH5+fpw4cYJFixYRGRlZmbvwn0ydOpWVK1fSo0cPTp06hdFopFOnTjz//PMW5UzHITY2lhMnTrBp0yb8/PwYMGBAiedPVbJ06VJOnDjBs88+S1BQ0E3LrV+/nvfee4+7777bfEP1yy+/sHz5cmrWrFmBNS57q1ev5syZM9jb29OxY0caNmxosd709z9w4ABz5szh8uXLGI1G/P392b17Nz/++CN16tSppNr/d4sXL6ZPnz64u7uXmGra2vf/o48+4ueff2bu3Lklfq8VDbat9ToA6jmekJCARqOhTZs2NGrUCCg+JYu1Xguq+3nwT23evJnhw4fz6aef0qtXL0DNwqzT6aw+o6K4vWobYJ09e5aePXvSpUsXXnvttVsGGCYpKSnodDo0Gg3u7u4VWd1yMWfOHCZPnkzfvn0ZOnQoDRo0KFbGmr9QZ8yYwdKlS+nfvz/x8fGcO3cOb29vvv76a2xtbYvdVGRmZpKSksL69evx8fGhZcuWhIWFVfZu/GunTp3i5ZdfZvz48bRs2ZLMzExmzJjBkSNH+PLLL/H09DSXLemLwlq+PCZMmMDixYt5+umnGTRoUIk3SKZ9PXToEFu3buXQoUN4enoydOhQc6tuVTVt2jSWL19Op06d2L17NxEREXz00Ud4eXkBxW+uExMTSUhIYMOGDfj7+9OtWzfCw8MreS/+G9N8fz/88AMuLi63vLm0tv1ftmwZ77zzDkuWLKFJkybm5QUFBebvO1Bb9rVardVeByZPnszq1atp3bo1R44coUaNGvTr18+cmt7Emq8F1fk8+Le2bNnCiBEjGDduHL179za3XFW3OcFECZRqKj4+XmnXrp3SrFkzZcCAAUpsbOwty+fl5VVQzcqf0WhUFEVRDh06pLRq1Up57rnnlNdee005duyYRZnCwkJz2ZLeX5UlJSUpvXv3Vn755RdFURSloKBA2bNnj3L33XcrTz31lJKRkWFebg37W5Ldu3crnTp1UtLS0szLTp48qdSrV0/Zs2dPie+5dOlSBdWu/Jn+rr/++qvSoEED5bHHHlMmT56sxMfHW5Qp+qMoilJYWKgoiqLo9fqKr3QZi4+PV3r27Kns2LFDURRFiY2NVZo3b66cOHHCopzBYLDK88D0t3zttdeUyMhIpVevXkp6erqiKOq5X5Q17r+iKMq8efOUIUOGKAcOHFAURf1bf/TRR8pTTz2lvPzyy8qcOXPMZU3Hy5quA4qiKPv371e6d+9uPgbJycnK888/rwwbNsy8zybWeC2Q8+C/+f3335Unnniisqsh7jDVNsnF0aNHCQwMZOvWrRgMBsaMGWORkryoBQsWsHz5cqtJZmB62li7dm1CQkKoX78+V69e5ZtvviE2NtZcpujTysTExGLvr8oKCgpIS0szjz/T6XQ0bdqUzp07s23bNl588UXzctPffe/evVy9erWyqlzmatWqRV5enjlDosFgwNfXFzc3NwwGQ7Hyq1ev5oEHHrCacQamz3GTJk1o3rw5zZo14++//2bx4sUkJSWZyxT9yc7ONo/HsLW1rbS6lxWDwUBBQQEhISGAOpDdx8eHadOm8corrzBt2jQAbGxszPO3REdHl/j5qIpMf8vMzEzuu+8+AgMDGTBgABkZGeh0OovB6abPizXtP8DQoUPx9fXlk08+IT8/n1deeYUTJ07QqFEjnJ2dWb16Ne+++y6gHq81a9ZY1XUA1N4pGo3G3ALl7e3Nk08+ydatW83fiSbWeC2Q8+C/6d69OwsWLKjsaog7TLUNsPz9/bnrrrtwcnJi6dKl5OTkMHr0aIsgy3RjffToUVq2bGkVgYVJQUEBdnZ2eHp6cs899/DMM8+QmZnJ3LlzeeGFF5g1a5a57Nq1a63uCzUoKAhXV1d++ukn8zIbGxuaNGnC8OHDuXr1KqNHjwbUL58dO3YwdOhQCgoKKqvKZSImJoa4uDji4uLw8/PjpZdeombNmhiNRmxtbXF2djYHnzfq3LkzixYtwtHRsRJqXj70ej02NjZkZWXx0EMP8eSTT7Jr1y6WLVvGW2+9ZU7JDPDjjz/Sr18/q5r/LiwsDK1Wy+jRo1mxYgX9+/fHxcWFFi1aEBgYyM8//2wej6fT6fjjjz945JFHyMnJqeSal52MjAy0Wi1du3ZlwoQJ+Pr6MnDgwBJvLq1l/y9dukRycrL5PJ8xYwZpaWkMHDgQLy8vpkyZwiuvvMJ7773H//73P06dOmXOGti6dWuruw4EBwej1+vNWfAKCwvx8/OzeLBQ1OLFi63iWnDu3Dnz71lZWdXuPChLpm7UQphVZvNZZcrMzFSSkpLMr/Pz85VevXopAwcOvG13waooJSWlxKb9jz/+WJkyZYqiKIqyefNmpWPHjkqzZs3MXecURVEuXryonD17tsLqWl5uPAbLly9X7rvvPuWTTz5REhMTlUOHDiktWrRQVqxYofz999/KI488opw5c8ZcPjExsRJqXXamTp2q9O3bV+ncubNy7733KosXL1YUxbLLR05OjtKsWTNl3bp15mWzZ89WZs+eXeH1LQ/R0dFKbGxssXN87NixytKlSxVFUZRly5YprVq1Ulq0aKFs377dXObAgQNWcW0wHYPo6GhFURTlxIkTSv/+/ZUhQ4Yobdq0UU6fPq0oivq52Llzp9K3b1/l999/Ny9LSEiotLqXhYsXLypXrlwxdwNWFEWZM2eOuWtofHy88vDDDyvdunUrsZtUVd//adOmKYMHD1bat2+vvP7668r+/fsVRVGU48ePKy1atFAee+wxJT8/33xduHz5stKqVSvlp59+qsxql7nff/9dSU1NVRRF/UxMmTJFOXHihLm7XFpamtKoUSOLa4DJ8ePHq/y1YOLEicrTTz+t5OTkmJfNnTu32pwHQpS3apum3cXFBRcXF0DtJmNnZ8fq1au5//77GTt2LB9++GGVT+JgUlLGRFOWPB8fH/PkiH/99ReFhYXUq1ePjRs3EhgYSOPGjQkMDKzM6peJoscgIiICjUZDly5d0Ov1zJkzhzVr1pCdnc3AgQMZOHAgKSkpxMTEEB0dTWhoKKBmDqyqFi1axKpVq/j8888xGAzExsYyfvx4PDw8zNmPCgsLycjIoKCgADc3NwCmT5/O3LlzWbZsWWVWv0xMmzaNv/76i6ysLBwcHHjwwQcZOnQoAI6OjuzZs4fBgwdz9OhRdDodPj4+7N69m8DAQEJDQ2natGnl7kAZuNkxWL58Obt27eL77783f941Gg0NGjRAURQSEhLMy4KDgytxD/6b6dOns337di5evEi7du149NFHadKkCU8//bS5TEhICJ988gljxoxh4MCBrFq1CldXV3Pq6qq8/wsWLGDZsmVMnTqV+Ph4li9fztGjR2nWrBlhYWG89dZb1K9f3yLFtLu7O3Xr1rWKaUlMYmJiGDduHO3ateOtt94iMDCQ5557DicnJ3N3ucLCwmItEt9//z2urq7079+/MqpdZiZOnMjSpUv58ccfcXR0NCdkeOqpp8xlrPk8EKIiVNsugkXZ2tqau8ytXr2aCxcuMH78ePR6fWVXrUzUrl2b3bt3M23aNPMM7KYvkV69eqHT6Xjuuef4+++/Wbp0Kc8++yynT59m6dKlVnkMYmNjzenmH3roIX766SdmzZrFTz/9ZB5r4OHhQYMGDfDw8DBvoyp3EY2OjqZ37940adKEqKgo7r33XqKioiwmhtTpdNja2ppTzH7xxRfMnz+fH374ocpnxzIFmOPHj2fSpEn873//Y+rUqaxfvx6A+++/H1tbW1599VW2bt3KqlWr+N///sfatWv5+eefrWKswY3H4Mknn2TKlCmsW7cOGxsbmjdvzuXLl5k3b575PS4uLoSEhFjFzbUpuBg5ciQjRozg3LlzHDlyxKKMqRuU6eYyMDCQrl27kpmZWWxeoKro1KlTPPzww7Ru3ZrBgwcTHh7OkSNH2LFjB9HR0QwYMIB69epx6tQpFi1aRGxsLJ9//jmxsbFWlX67Vq1aeHp6smPHDsaNG0dqaiouLi7ma7yiKFy9epWCggLzg9jp06fz8ccfl5httyr5+OOPWbVqFStXrjRPMXJjtjtTV3hrPQ+EqAhyplxjY2NjDrL++usvEhMTLZ7iVWU6nQ5vb2927drFmDFjmDRpkjmdqtFoZNOmTfj4+PD1118TFBREUFCQeZJdpmrzqAAADhVJREFUaz8GGo0GJycnmjRpwrlz55g5cybNmjVj27ZtxMTEmAf/V2WFhYUkJCRYpF339PQkNDSUnTt3otfrzX9nT09PgoKCGDNmDFevXmXx4sXF5kSqiooGmADh4eFs2LCBQ4cO0bt3b+zt7VmxYgXBwcF89dVX+Pv7M3jwYADatGlT5QexQ8nH4JdffuHw4cP06dMHRVHo0KEDGzduJCMjg6ioKLZv386hQ4cYO3ZsJdf+vysaXLRu3ZoDBw5w5MgRdu3ahU6nIyoqCp1OZ27dDwkJYfz48YwfP57U1NQqH2QaDAbOnDljvg4UFhby999/4+TkxI4dO8jKyuKRRx7h9ddf56effmLRokUEBQWh1WqZO3eu1bRYGI1G7OzsCAkJwd/fH0VReP/993nnnXfw8fHBYDBga2uLRqNBp9NhZ2dnfthU1ed5SkhIYNOmTfTr1888xUhhYSHbt2+noKAAV1dXoqKisLGxMadjt7bzQIiKIgFWEUWDrKo8WeCNTBkTFy5cyJAhQxgzZgyffPIJtWvXpkaNGnz//fc4OzsTHh5uvrno2rVrZVe7TN3sGBSdt0NRFDZv3syWLVtQFIVvvvnGKrpH6nQ67rvvPr777jsuX76Mt7c3Op0OPz8/c7ZIUG88CgoKCAsLMyd6qMqTKJvcLsDMz88nIiKC2bNnU6NGDcLDw81dZkxBVlVXmiDbycmJBx54AAcHB1auXMmmTZtwcXFh3rx5Vf5Bw+2Ci8zMTB5//HFee+01tFqt+TpYq1YtvvzyS6t4am9ra8uIESOIjo4G4MiRI0RERPD+++8D6jXy9ddfJyIiglGjRvH444+Tm5uLh4eHRUt+VWe63nXo0IHo6GhatWrFokWLmDhxIlOmTDF3mfT398fPz49Ro0Zx5swZfvzxxyr/sMnHx4fBgwdz8OBB9u/fT7NmzXjqqadIS0sjIyOD9PR0Hn30UUaNGoVGo7HK80CIiiJnyw2s8QJyY8bEQYMGMXr0aHOQ1bhxY3NZ05ePtbnZMfj000/NQVZoaCjLli0jMzMTrVaLs7NzJde67PTt25eWLVvi5eVl0dXRlHIY1L/9xYsXee+998jJybGahwylDTA7depkfk9V7g5aktsdA9PNVEhICM8//zxPPfUUubm52NnZ4eTkVNnV/89KE1yMHj0af39/Hn30UYvroDV9J7Rp04a2bdsC0LRpU2bNmoWDgwOgdgc7ffo0v/76Kz179sTf378yq1puTC0zLi4uxMfH8/7776PVas2Tbefm5ppbdJydnYmPj2fFihVW8bDJwcGBvn37snfvXpYtW8Yff/yBm5sbEyZMQFEUTp48yauvvoqvry9PPvmk1Z4HQlQE67ybFhbq1q3L8OHDAXUw/+rVq8nNzWXMmDGcOXOmkmtXMW52DG5MzQ/g6upqVcEVYB6UbGNjY/7SzMnJIScnxzzuZOrUqfTs2RNbW1urCa5M+vbty4wZM24ZYAIcPnwYsM4HDbc6BkXnvDt06BD29vZ4eHhYRXBl0qZNG5588kngenAREhJCSEgIvXr14oUXXmD79u3k5+dbbbpl09/YlHrcFFyZODg4kJKSYhVdYm/GdAy6detGdnY2er2eXr16kZeXR2ZmJo0aNSIvLw93d3c++OADi7FK1sDf359Ro0axbds2Vq5cSa9evQgODqZGjRp0796dl156iS1btpCdnW2154EQFcH67iJEMS4uLuYMeEUzJubm5jJ27FjzU11rJsfgOtOXpqIo2NraYmdnx4wZM/juu+9YunQp7u7ulVzDsnerANN0szlt2jQefPBBUlNTrfLG4nZBtkajYdq0aTz00ENWeQxuF1zY29tz5coVbGxsrK4F80amv/+VK1fM81sBJCcn4+PjU+Xn+7sdUytWbm4uR44cYeLEiSQlJfHCCy+g0WgYMWIEqampNGvWzKIbubUIDw/ngw8+wNnZmUaNGlmss7e3Jz09HXt7e6s/D4QoT9LmW83cmDGxa9eujB8/njlz5lhNQovbkWOgcnV1xdHRkYkTJ7J48WJ++OGHKj/GoDRMN1c3BpgLFy5k6dKleHl5VXYVy111PgZFg4uUlBRzhsyiwcWNWdWskaIoxMXF8eyzzxIREYGzszMxMTEsWLAAe3v7yq5eudJoNDg7O3P33Xfz4osv4uHhwfz58wkJCcHDw4ONGzdaRebQW+ncuTPNmzfHzc2N9PR084O1xMRE83kg3QKF+Pc0irU9phSlYrp46vV6EhMTra5LWGlU92OwY8cOhg4dip2dHT/88EOVTz9cWqbg4quvvuLPP/+kefPm1SrABDkGiqKwa9euEoOLqj4lwT+h1+vZtWsXhw8fxtPTk/bt21OrVq3KrlaFOXLkCOPGjbPIrKsoCtnZ2eb07NbuwoULPPTQQ4SGhuLo6MihQ4f49ttvq9V5IER5kACrGpMnVNX7GGRkZDB+/HiGDRtmld1gbqe6BphFVedjUN2DC6HKz883t9iZHjxUJzk5Ofz222/s37+fwMBA7r33XmrXrl3Z1RKiypMAS4hqrOgcWNVNdQ8wQY6BEEIIUR4kwBJCVFvVOcA0kWMghBBClC0JsIQQQgghhBCijEiadiGEEEIIIYQoIxJgCSGEEEIIIUQZkQBLCCGEEEIIIcqIBFhCCCGEEEIIUUYkwBJCCHHHe+ONN+jbt+8tyzz++OMMGzasgmokhBBClKx6zrAqhBDC6owbNw6tVp4bCiGEqFwSYAkhhLAKderUqewqCCGEENJFUAghROlkZWUxfvx4unTpQsOGDWnTpg1jxowhIyPDXCY/P5/x48fTtm1bmjdvzltvvcXUqVPp2rWrxbYWLlxIjx49aNiwIX369GH9+vWlqsOcOXNo164dzZs3Z+TIkaSkpJjXFe0iuGvXLiIjI9m7dy8PPfQQjRo1olu3bixbtqzY9u655x4aNWpE9+7d+eKLLzAajf/2EAkhhBDSgiWEEKJ0Ro4cSUxMDCNHjsTX15dDhw7x2Wef4enpyRtvvAHA2LFj2bhxIyNHjiQoKIh58+axdu1afH19zduZOXMmX375Jc8++yxRUVFs3ryZ1157DY1GQ69evW76/58+fZqlS5fy7rvvkpeXx6RJkxg2bBhLly69adfAV199laeeeooRI0awePFi3n77bZo1a0adOnVYs2YNn332GW+88QYREREcOHCAadOm4e3tzUMPPVS2B08IIUS1IQGWEEKI28rPz8dgMPDee+/RsWNHAFq3bs2BAwfYvXs3AGfOnOHnn39m4sSJDBw4EIA2bdrQrVs383YyMjL4+uuveeaZZ3jllVcA6NChA9nZ2UyZMuWWARbA7NmzCQsLA8DT05PnnnuOnTt30q5duxLLP/HEEwwdOhSABg0a8Pvvv7Nlyxbq1KnDvn37CA4O5pFHHkGj0dCqVStsbGzw8/P79wdKCCFEtSddBIUQQtyWvb098+bNo2PHjiQkJLB161bmz59PXFwcBoMBgD179gDQvXt38/scHR3p1KmT+fXBgwfJz8+nc+fOFBQUmH86duzI+fPnOX/+/E3rEBERYQ6uADp27IitrS379u276XuaNm1q/t3NzQ0nJydycnIAiIqK4syZMwwaNIivv/6a6Ohonn766WLdGYUQQoh/QlqwhBBClMqff/7JxIkTOX/+PJ6enjRs2BAHBwfzmKW0tDRsbW1xc3OzeJ+Pj4/596tXrwLctAvelStXCAkJKXFd0e0AaDQaPDw8yMzMvGmdHRwcLF5rtVoURQGgX79+FBYWsmjRIqZOncqUKVOIjIzko48+olGjRjfdphBCCHErEmAJIYS4rbNnzzJixAgGDBjA999/T0BAAAAjRowgLi4OAH9/fwwGAxkZGRZBVmpqqvl3V1dXAL744gv8/f2L/T9FW6hulJ6ebvHaaDSSlpaGl5fXv96vAQMGMGDAAFJSUvjrr7/44osvGD16NBs2bPjX2xRCCFG9SRdBIYQQt3X8+HEMBgPPPfecObjKyclh37595hahZs2aodVq+euvv8zv0+v1/P333+bXTZo0wdbWlpSUFBo1amT+iYmJ4YsvvrhlHU6ePElycrL59Z9//klBQQGtWrX6V/v01ltv8fLLLwPg7e3N4MGDeeCBB7h06dK/2p4QQggB0oIlhBCiFOrXr49Op2PSpEk8/PDDpKWlMW/ePJKTk7GzswOgVq1a3HfffYwfP56cnByCg4NZuHAhV65cISgoCAAvLy8ef/xxPv74Y9LT02ncuDEnT55k2rRpdOvWDRcXl5vWQavV8vzzz/PSSy9x5coVJk2aRMeOHWnevPm/2qeWLVsyZswYpk6dSrt27UhMTOSHH37gnnvu+VfbE0IIIUACLCGEEKUQFhbGJ598wsyZM3nuuefw9fWlU6dODBo0iA8++ICkpCT8/f157733cHBwYPr06RQUFNC3b1969uxJbGyseVuvv/46Xl5eLF26lBkzZuDn58eTTz7J8OHDb1mHli1b0qxZM0aPHk1hYSG9e/c2p4f/N+6//36ysrJYtGgRCxYswNXVlXvvvZeRI0f+620KIYQQGsXUt0MIIYT4D1JTU9m2bRtdunSxaIl66KGH8PHxYebMmZVYOyGEEKJiSAuWEEKIMuHg4MD777/PL7/8wkMPPYSNjQ0bNmzg4MGDzJ8/v7KrJ4QQQlQIacESQghRZg4fPsy0adM4evQoBoOByMhIXnjhBTp37lzZVRNCCPH/7dwxDQAAAIMw/65nguxqXfDAhcACAACI2LQDAABEBBYAAEBEYAEAAEQEFgAAQERgAQAARAQWAABAZLaLgxa7QqGVAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "col_order = list(basetable[\"age_bin\"].unique().sort_values())\n", + "plot_incidence(pig_tables, variable=\"age\", model_type=model_type, column_order=col_order)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Feature selection" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once the predictors are properly prepared, we can start building a predictive model, which boils down to selecting the right predictors from the dataset to train a model on.\n", + "\n", + "As a dataset typically contains many predictors, **we first perform a univariate preselection** to rule out any predictor with little to no predictive power. \n", + "\n", + "Later, using the list of preselected features, we build a logistic regression model using **forward feature selection** to choose the right set of predictors." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In previous steps, these were the predictors, as preprocessed so far:" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['age_bin',\n", + " 'alone_processed',\n", + " 'class_processed',\n", + " 'deck_processed',\n", + " 'embark_town_processed',\n", + " 'embarked_processed',\n", + " 'fare_bin',\n", + " 'parch_processed',\n", + " 'pclass_processed',\n", + " 'sex_processed',\n", + " 'sibsp_processed']" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preprocessed_predictors = [\n", + " col for col in basetable.columns\n", + " if col.endswith(\"_bin\") or col.endswith(\"_processed\")]\n", + "sorted(preprocessed_predictors)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But for feature selection, we use the target encoded version of each of these." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "preprocessed_predictors = [col for col in basetable.columns.tolist() if \"_enc\" in col]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A univariate selection on the preprocessed predictors is conducted. The thresholds for retaining a feature are now the default values but can be changed by the user." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_auc = univariate_selection.compute_univariate_preselection(\n", + " target_enc_train_data=basetable[basetable[\"split\"]==\"train\"],\n", + " target_enc_selection_data=basetable[basetable[\"split\"]==\"selection\"],\n", + " predictors=preprocessed_predictors,\n", + " target_column=target_col,\n", + " model_type=model_type,\n", + " preselect_auc_threshold=0.53, # if auc_selection <= 0.53 exclude predictor\n", + " preselect_overtrain_threshold=0.05) # if (auc_train - auc_selection) >= 0.05 --> overfitting!\n", + "\n", + "plot_univariate_predictor_quality(df_auc)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we compute correlations between the preprocessed predictors and plot it using a correlation matrix." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df_corr = (univariate_selection\n", + " .compute_correlations(basetable[basetable[\"split\"]==\"train\"],\n", + " preprocessed_predictors))\n", + "plot_correlation_matrix(df_corr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get a list of the selected predictors after the univariate selection, run the following call:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['sex_enc',\n", + " 'fare_enc',\n", + " 'sibsp_enc',\n", + " 'alone_enc',\n", + " 'deck_enc',\n", + " 'class_enc',\n", + " 'pclass_enc',\n", + " 'age_enc',\n", + " 'parch_enc']" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preselected_predictors = univariate_selection.get_preselected_predictors(df_auc)\n", + "preselected_predictors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After an initial preselection on the predictors, we can start building the model itself using forward feature selection to choose the right set of predictors. Since we use target encoding on all our predictors, we will only consider models with positive coefficients (no sign flip should occur) as this makes the model more interpretable." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modelling" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0507af8ee58244a2b7be709da11c27b8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sequentially adding best predictor...: 0%| | 0/9 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
predictorslast_added_predictortrain_performanceselection_performancevalidation_performancemodel_type
0[sex_enc]sex_enc0.7760590.7441920.768315classification
1[sex_enc, fare_enc]fare_enc0.8316970.8091330.816327classification
2[sex_enc, fare_enc, age_enc]age_enc0.8419440.8257150.816457classification
3[sex_enc, age_enc, fare_enc, class_enc]class_enc0.8461510.8375000.830717classification
4[sex_enc, age_enc, class_enc, fare_enc, sibsp_...sibsp_enc0.8520890.8443600.827708classification
5[age_enc, fare_enc, sibsp_enc, sex_enc, class_...deck_enc0.8544620.8446550.824568classification
6[age_enc, fare_enc, sibsp_enc, sex_enc, class_...pclass_enc0.8544620.8446550.824568classification
7[age_enc, fare_enc, sibsp_enc, sex_enc, class_...parch_enc0.8561930.8439810.825615classification
\n", + "" + ], + "text/plain": [ + " predictors last_added_predictor \\\n", + "0 [sex_enc] sex_enc \n", + "1 [sex_enc, fare_enc] fare_enc \n", + "2 [sex_enc, fare_enc, age_enc] age_enc \n", + "3 [sex_enc, age_enc, fare_enc, class_enc] class_enc \n", + "4 [sex_enc, age_enc, class_enc, fare_enc, sibsp_... sibsp_enc \n", + "5 [age_enc, fare_enc, sibsp_enc, sex_enc, class_... deck_enc \n", + "6 [age_enc, fare_enc, sibsp_enc, sex_enc, class_... pclass_enc \n", + "7 [age_enc, fare_enc, sibsp_enc, sex_enc, class_... parch_enc \n", + "\n", + " train_performance selection_performance validation_performance \\\n", + "0 0.776059 0.744192 0.768315 \n", + "1 0.831697 0.809133 0.816327 \n", + "2 0.841944 0.825715 0.816457 \n", + "3 0.846151 0.837500 0.830717 \n", + "4 0.852089 0.844360 0.827708 \n", + "5 0.854462 0.844655 0.824568 \n", + "6 0.854462 0.844655 0.824568 \n", + "7 0.856193 0.843981 0.825615 \n", + "\n", + " model_type \n", + "0 classification \n", + "1 classification \n", + "2 classification \n", + "3 classification \n", + "4 classification \n", + "5 classification \n", + "6 classification \n", + "7 classification " + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "forward_selection = ForwardFeatureSelection(model_type=model_type,\n", + " # model_name=\"my-logistic-regression\",\n", + " pos_only=True)\n", + "\n", + "# fit the forward feature selection on the train and selection data\n", + "# there are optional parameters to force and/or exclude certain predictors (see docs)\n", + "forward_selection.fit(basetable[basetable[\"split\"]!=\"validation\"],\n", + " target_column_name=target_col,\n", + " predictors=preselected_predictors)\n", + "\n", + "# compute model performance\n", + "performances = (forward_selection\n", + " .compute_model_performances(basetable, target_column_name=target_col))\n", + "performances" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As can be seen, model improvement gradually flattens when more variables are added." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot performance curves\n", + "plot_performance_curves(performances)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# one can also compute using another metric function and plot the according performance curves\n", + "performances_ = (forward_selection\n", + " .compute_model_performances(basetable, target_column_name=target_col, \n", + " metric=metrics.accuracy_score))\n", + "plot_performance_curves(performances_, metric_name=\"Accuracy\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Based on the performance curves (AUC per model with a particular number of predictors in case of logistic regression), a final model can then be chosen and the variable importance can be plotted." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['sex_enc', 'age_enc', 'class_enc', 'fare_enc', 'sibsp_enc']" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# pick the optimal step based on visual inspection in the plot above (try to find a knee point in the selection curve)\n", + "model = forward_selection.get_model_from_step(4)\n", + "\n", + "final_predictors = model.predictors\n", + "final_predictors" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'sex_enc': 4.4803259699087965,\n", + " 'age_enc': 3.643976017538859,\n", + " 'class_enc': 4.016803499516308,\n", + " 'fare_enc': 0.7172923586397533,\n", + " 'sibsp_enc': 2.5251121628937665}" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_coef_by_predictor()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtkAAAHuCAYAAABK2hAWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAn2ElEQVR4nO3de5SWdb3//9fAgAICHjA0TeOg4Gm2gpaFpoYpCLXTUA6KaB5i2e7E9qzfRFJDSs3DVkwliW0ClroLsWVoheXWPKSlxvYQopSKhAqIMsBcvz9azm+zNSL6zAyjj8daruVc99z39b7ws1jPPl33fddUVVUFAAAopk1LDwAAAO81IhsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ2wAUaPHp1rr732HcenTJmSsWPHrvfr3Hzzzfnud7+7zt954IEHMnTo0Hd97Mwzz8wNN9yw3udLkpNOOinPPPPMP/ScEq666qrMmTOn2c8L0BJENsAGOProo3Prrbe+4/jMmTNzzDHHrPfrjBw5MieffHLJ0f6u6667Lr17927WcyZ//R8Lq1evbvbzArSE2pYeAKA1Ovjgg3PhhRfmoYceyt57750k+c1vfpOqqjJgwIBMnjw5c+bMycqVK/Pmm2/mjDPOyKc+9alceeWVefTRR7No0aL06dMnO+64Y1599dV8/etfz89//vNce+21qa+vz5IlS/LZz342X/3qV5MkK1asyJe//OUsWLAgXbp0yYQJE9KjR4+1Znr22Wdz4YUX5rXXXsuaNWsyevToDBs27B2zf/KTn8zll1+eFStW5NJLL80HPvCBPP300+nQoUO+9KUvZdq0aZk/f34OOeSQnH322XnggQcyadKkdO/ePS+88EI23XTTTJw4Mb169cqyZcty/vnnZ968eampqcn++++fcePGpba2NrvvvnsGDhyYefPm5dOf/nQef/zxTJo0KW3btk3v3r0zYcKErFixIosWLUrfvn3zne98J5tsskn22GOPnHzyyfn1r3+dRYsW5dhjj81xxx2XJLn22mtz2223pba2NjvuuGMmTpyYzp0755ZbbsnNN9+choaGbL755vl//+//pVevXk26BgDWqQJgg1x55ZXVGWec0fjzuHHjqhtvvLFauHBhNXr06OrNN9+sqqqqZs2aVQ0dOrSqqqq64oorqkMPPbRatWpV48/nn39+1dDQUB1zzDHV/Pnzq6qqqpdeeqnaZZddqr/85S/V/fffX/Xt27d6+OGHq6qqqunTp1fDhg2rqqqqzjjjjOr666+vVq1aVR122GHV448/XlVVVS1durQaPHhw9dvf/vYdcx900EHV7373u+r++++vdtlll+qJJ56oqqqqTjjhhGr48OHVypUrq7/85S/VbrvtVr300kuN53/wwQerqqqqH/zgB9Xhhx9eVVVVnX766dU3vvGNqqGhoVq5cmX1+c9/vrr22murqqqqnXfeubrtttsaz3vMMcdUd955Z1VVVTVx4sTq9ttvr6qqqurr66uhQ4dWP/3pTxufN23atKqqqur3v/99tfvuu1dvvfVWNWfOnOqQQw6pXnvttaqqquqiiy6qrr766uqBBx6oRo0aVa1YsaKqqqq69957q8GDB/+D/zUByrKTDbCBjjrqqAwZMiTLly/P6tWr86tf/Srjx49P586dc/HFF+cnP/lJFixYkMceeyxvvPFG4/P23HPP1Nau/ddvTU1NJk+enF/84heZNWtWnn322VRVlTfffDNJ0qdPn/Tr1y9Jcvjhh2f8+PFZtmxZ4/Ofe+65PP/88zn77LMbj7311lt58skns+eee/7Na9h+++2z6667Jkl22GGHdO7cOe3bt8+WW26ZTp065fXXX0+S9O3bt3HH/nOf+1wmTJiQV199NXPnzs3NN9+cmpqatG/fPiNGjMjUqVMbb4F5+zn/12mnnZZf//rXue666/Lcc89l0aJFWbFiRePjAwcOTJLstttuqa+vz4oVK/Lf//3fGTRoULp27ZokOeuss5IkkyZNyoIFCzJixIjG57/++ut57bXXsvnmm//NawdoSiIbYAN94AMfyMc//vHMnj07K1asyKGHHprOnTvniSeeyCmnnJLjjjsuAwYMyD777JPzzz+/8XkdO3Z8x2utWLEihx9+eA4++ODsvffe+dznPpc5c+akqqokSZs2a7+FpqamZq1QX7NmTbp06ZL/+q//ajy2ePHidO7ceZ3X0L59+7V+/r/x/7a2bduu9XNVVWnbtm0aGhrWOt7Q0LDWfdfvdq1JMm7cuKxZsyaDBw/OgQcemBdffLHxWpNkk002SfLX6/zf53v75yRZunRpli5dmoaGhvzrv/5rTjvttMYZFi1a1BjjAC3BGx8B/gmjRo3KT37yk9x+++05+uijkyQPPvhgdt999xx//PH5yEc+krvvvjtr1qxZ5+ssWLAgy5cvz1e/+tV88pOfzG9+85vU19c3Ruz//M//5A9/+EOSZMaMGenfv386dOjQ+PwePXpkk002aYzsF198MUOHDs3jjz9e5DrnzZuXefPmNZ6/X79+6dKlS/bbb7/cdNNNqaoq9fX1mTlzZj7+8Y+/62u0bdu2McB/9atf5Ytf/GIOO+yw1NTU5LHHHvu7f0Yf//jH87Of/SzLly9Pklx55ZW58cYbM2DAgNxxxx1ZtGhRkr9+YsuYMWOKXDfAhrKTDfBP+OhHP5oLLrggXbt2TZ8+fZIkQ4cOzV133ZXDDjss7dq1y8c+9rG8/vrrjXH4bvr06ZMDDzwwgwcPTpcuXbLDDjukd+/eWbBgQdq3b5+ePXvmqquuygsvvJCtttoqEydOXOv57du3z9VXX50LL7ww119/fVavXp2vfOUr6d+/f5Hr7NatW77zne/kT3/6U7bccstMmjQpSXLuuefmggsuyKc//emsWrUq+++//9/8CMODDjooF198cVatWpWvfe1r+eIXv5iuXbumQ4cO2WefffL888+vc4YDDjggzzzzTEaOHJkk6d27d77xjW9ks802y0knnZTPf/7zqampyWabbZarrrpqrV1vgOZWU/3v/38OAP6PBx54IN/4xjcya9aslh4FoNVwuwgAABRmJxsAAAqzkw0AAIW95yJ79erVWbhwoa/uBQCgxbznIvull17KwIED89JLL7X0KAAAvE+95yIbAABamsgGAIDCRDYAABQmsgEAoDCRDQAAhYlsAAAoTGQDAEBhIhsAAAqrbekBmsrE6c+nY9eVLT0GAABNaNJJvVp6hHdlJxsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ0AAIWJbAAAKExkAwBAYSIbAAAKE9kAAFCYyAYAgMJENgAAFCayAQCgMJENAACFiWwAAChMZAMAQGEiGwAAChPZAABQmMgGAIDCRDYAABQmsgEAoDCRDQAAhYlsAAAoTGQDAEBhIhsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ0AAIWJbAAAKExkAwBAYSIbAAAKa/bInj9/fkaMGJFjjjkmo0aNyosvvphLLrkkI0eOzPDhw3PnnXdm9erVGTFiRO69994sXrw4Q4YMyYsvvtjcowIAwAapbe4T3nfffamrq8tpp52Whx56KHPmzMnChQtz8803Z+XKlTnqqKMyYMCAfPvb387YsWOz9dZb5/TTT8+22277jteaMWNGZsyYsdax+vr65roUAAB4V80e2cOGDct1112XE088MZ07d07fvn3zxBNPZPTo0UmS1atX509/+lN22WWX9OvXL48++mg+8YlPvOtrDR8+PMOHD1/r2MKFCzNw4MAmvw4AAPhbmv12kbvvvjv9+/fP1KlTM2jQoNx666356Ec/mmnTpmXq1KkZPHhwPvShD+XRRx/N008/nX322SdTpkxp7jEBAGCDNftO9u67754zzjgj11xzTRoaGnLFFVfkJz/5SUaNGpUVK1bk4IMPTlVVOeecc3LVVVflgx/8YI488sh85CMfyR577NHc4wIAwD+spqqqqqWHKOnt20U+ddL30rFr95YeBwCAJjTppF4tPcK78hF+AABQmMgGAIDCRDYAABQmsgEAoDCRDQAAhYlsAAAoTGQDAEBhIhsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ0AAIWJbAAAKExkAwBAYSIbAAAKE9kAAFCYyAYAgMJENgAAFCayAQCgMJENAACFiWwAAChMZAMAQGEiGwAAChPZAABQmMgGAIDCRDYAABQmsgEAoDCRDQAAhYlsAAAorLalB2gqZ47YIdtvv31LjwEAwPuQnWwAAChMZAMAQGEiGwAAChPZAABQmMgGAIDCRDYAABQmsgEAoDCRDQAAhYlsAAAoTGQDAEBhIhsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ0AAIXVtvQATWXi9OfTsevKlh4D4D1v0km9WnoEgI2OnWwAAChMZAMAQGEiGwAAChPZAABQmMgGAIDCRDYAABQmsgEAoDCRDQAAhYlsAAAoTGQDAEBhIhsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ0AAIWJbAAAKExkAwBAYSIbAAAKE9kAAFCYyAYAgMJENgAAFCayAQCgMJENAACFiWwAAChMZAMAQGEiGwAAChPZAABQmMgGAIDCRDYAABQmsgEAoLBmi+zVq1dn9OjRGTFiRF5//fXmOi0AADS72uY60aJFi/LGG2/k1ltvba5TAgBAi2i2yD7vvPPy3HPP5eyzz86SJUuycuXKvPLKK/nqV7+agw8+OEOHDs2HP/zhtGvXLhMmTMg555yTV199NUly7rnnpk+fPs01KgAA/FOaNbLHjRuXoUOHpm3btvnoRz+aRx55JFdeeWUOPvjgrFixIqecckp23XXXfOtb38q+++6bUaNG5bnnnstZZ52Vm2+++R2vOWPGjMyYMWOtY/X19c11SQAA8K6aLbLftvXWW+eaa67JD3/4w9TU1GT16tWNj/Xo0SNJ8tRTT+X+++/PnXfemSR/8x7u4cOHZ/jw4WsdW7hwYQYOHNhE0wMAwN/X7JF9+eWX58gjj8wBBxyQH/3oR7ntttsaH2vT5q/vw+zZs2c+85nP5NOf/nT+8pe/5JZbbmnuMQEAYIM1+0f4DRo0KJMmTcrRRx+d++67r/G+6/9t7NixufPOOzN69OiceOKJ2WmnnZp7TAAA2GA1VVVVLT1ESW/fLvKpk76Xjl27t/Q4AO95k07q1dIjAGx0fBkNAAAUJrIBAKAwkQ0AAIWJbAAAKExkAwBAYSIbAAAKE9kAAFCYyAYAgMJENgAAFCayAQCgMJENAACFiWwAAChMZAMAQGEiGwAAChPZAABQmMgGAIDCRDYAABQmsgEAoDCRDQAAhYlsAAAoTGQDAEBhIhsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ0AAIWJbAAAKExkAwBAYSIbAAAKq23pAZrKmSN2yPbbb9/SYwAA8D5kJxsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ0AAIWJbAAAKExkAwBAYSIbAAAKE9kAAFCYyAYAgMJENgAAFCayAQCgMJENAACFiWwAAChMZAMAQGG1LT1AU5k4/fl07LqypccAWqFJJ/Vq6REAaOXsZAMAQGEiGwAAChPZAABQmMgGAIDCRDYAABQmsgEAoDCRDQAAhYlsAAAoTGQDAEBhIhsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ0AAIWJbAAAKGy9InvZsmVNPQcAALxnrFdkn3zyyU09BwAAvGfUrs8vde3aNVOnTk2PHj3Sps1fu3y//fZr0sEAAKC1Wq/I3mKLLTJv3rzMmzev8ZjIBgCAd7dekf3Nb34zTz31VJ555pn06NEju+yyS1PPBQAArdZ6Rfa0adMya9as1NXVZcqUKRk8eHBOOOGEpp4NAABapfWK7FmzZuWmm25KbW1tVq1alREjRohsAAD4G9br00Wqqkpt7V97vF27dmnXrl2TDgUAAK3Zeu1k9+vXL1/+8pfTv3//PPzww9lrr72aei4AAGi11iuyzzzzzPziF7/Is88+myOOOCIHHnhgE48FAACt1zpvF1mzZk3q6+vzb//2bxkwYEBGjx6dfffdN8cee2xzzQcAAK3OOneyf/SjH2Xy5MlZvHhxBg0alCRp06ZN+vfv3yzDAQBAa7TOyD7qqKNy1FFH5Yc//GGGDRuWJKmvr0/79u2bZTgAAGiN1uvTRdasWZOLL744STJ27NjcfvvtTTkTAAC0ausV2dOnT8+///u/J0muvfba3HzzzU06FAAAtGbrFdlt2rRZ63Oya2pq/qGT3Hrrrfn2t7/9j08HAACt0Hp9hN/AgQMzatSo1NXV5YknnsgnP/nJpp4LAABarfWK7FNOOSUHHXRQ5s+fn89+9rPp27fvOn//rbfeyllnnZU///nPWbVqVQ499NDGxy655JI8/vjjee2119K3b99885vfzMMPP5yLL744tbW16dChQy6//PK88sorOeuss1JbW5uGhoZccskl2Xbbbf+5qwUAgGawzsi+5ZZbcuSRR+aSSy5pvEVk3rx5mT17dsaNG/c3nzd9+vRst912ueyyy/Lcc8/lF7/4RZYtW5bly5enS5cu+d73vpeGhoYMGTIkL7/8cubMmZPBgwdnzJgxueeee7J06dLcd999qaury2mnnZaHHnooy5Yte0dkz5gxIzNmzFjrWH19/Yb+WQAAQBHrjOxtttkmSdKzZ89/6EX/+Mc/5hOf+ESS5MMf/nC6dOmSxYsXZ5NNNsmSJUsybty4dOzYMStWrMiqVasyduzYTJ48OWPGjEn37t1TV1eXYcOG5brrrsuJJ56Yzp0752tf+9o7zjN8+PAMHz58rWMLFy7MwIED/6F5AQCgpHW+8XHTTTfNgw8+mO233/4d/6xLr1698vvf/z5J8sILL+TSSy9NksydOzcvvvhiLr300owbNy5vvfVWqqrKj3/84xx++OGZNm1adtppp8ycOTN33313+vfvn6lTp2bQoEG5/vrrC10yAAA0rXXuZL/9UX3PP/98Vq1alT322CNPPvlkOnXqlGnTpv3N540YMSJnn312jjnmmKxZsybHH398Xn311dTV1eXqq6/O0UcfnZqamnzoQx/KokWLUldXl3PPPTcdOnRImzZtMmHChFRVlTPOOCPXXHNNGhoactZZZ5W9cgAAaCI1VVVVf++XTj755Fx99dWpra3NmjVrcvLJJ+eGG25ojvn+YW/fLvKpk76Xjl27t/Q4QCs06aReLT0CAK3cen1O9iuvvNL472vWrMmSJUuabCAAAGjt1usj/IYNG5YhQ4Zk5513ztNPP52TTjqpqecCAIBWa70i++ijj86gQYPy/PPPZ8cdd8yWW27Z1HMBAECrtV6R/fTTT+e8887L0qVL85nPfCY77bRTDjrooKaeDQAAWqX1uif7ggsuyDe/+c1sscUWGTZsWK688sqmngsAAFqt9YrsJNlxxx1TU1OTLbfcMp06dWrKmQAAoFVbr8ju2rVrpk+fnjfffDN33HFHunTp0tRzAQBAq7VekX3RRRdl4cKF2WKLLfL444/nwgsvbOq5AACg1VqvNz6ed955ueSSS5p6FgAAeE9Yr53s+vr6zJs3LytXrkx9fX3q6+ubei4AAGi11msn+7nnnsvYsWOzZMmSbLXVVmnTpk3uvvvupp4NAABapfXayf7Sl76UNm3apGfPnmnbtm3OP//8pp4LAABarfXayb766qtzyy23ZKuttsrixYszduzY7Lfffk09GwAAtErrtZO9+eabZ6uttkqSdOvWLZtttlmTDgUAAK3Zeu1kd+rUKSeccEL22WefPPHEE3nrrbdy6aWXJknGjRvXpAMCAEBrs16RffDBBzf+e/fu3ZtsGAAAeC9Yr8g+/PDDm3oOAAB4z1ive7IBAID1J7IBAKAwkQ0AAIWJbAAAKExkAwBAYSIbAAAKE9kAAFCYyAYAgMJENgAAFCayAQCgMJENAACFiWwAAChMZAMAQGG1LT1AUzlzxA7ZfvvtW3oMAADeh+xkAwBAYSIbAAAKE9kAAFCYyAYAgMJENgAAFCayAQCgMJENAACFiWwAAChMZAMAQGEiGwAAChPZAABQmMgGAIDCRDYAABQmsgEAoDCRDQAAhYlsAAAorLalB2gqE6c/n45dV7b0GEAzmnRSr5YeAQCS2MkGAIDiRDYAABQmsgEAoDCRDQAAhYlsAAAoTGQDAEBhIhsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ0AAIWJbAAAKExkAwBAYSIbAAAKE9kAAFCYyAYAgMJENgAAFCayAQCgMJENAACFiWwAAChMZAMAQGEiGwAAChPZAABQmMgGAIDCRDYAABQmsgEAoDCRDQAAhYlsAAAoTGQDAEBhIhsAAAprlsj+wx/+kKuuuipJMmDAgOY4JQAAtJja5jjJLrvskl122aU5TgUAAC2uSSJ7/vz5Oeuss1JbW5uGhoYcddRR+eUvf5nLLrss9fX1+drXvpYXX3wxffr0yfjx4/PII4/k4osvTm1tbTp06JDLL788d911V+bMmZM33ngjr776ar74xS/m0EMPbYpxAQCgqCaJ7Pvuuy91dXU57bTT8tBDD+XZZ59tfOytt97Kqaeemu222y5f+cpXcs899+Shhx7K4MGDM2bMmNxzzz1ZunRpkuTNN9/M9773vSxZsiRHHnlkBg4cmNra/3/kGTNmZMaMGWudu76+vikuCQAA1luTRPawYcNy3XXX5cQTT0znzp3Xug/7gx/8YLbbbrskyV577ZX58+dn7NixmTx5csaMGZPu3bunrq4uSbLPPvukTZs26datW7p06ZIlS5bkAx/4QONrDR8+PMOHD1/r3AsXLszAgQOb4rIAAGC9NMkbH+++++70798/U6dOzaBBg3Ldddc1PvbSSy9l0aJFSZJHHnkkO+20U3784x/n8MMPz7Rp07LTTjtl5syZSZInnngiSbJ48eIsX748W221VVOMCwAARTXJTvbuu++eM844I9dcc00aGhoyevTo/O53v0uSbL755rngggvy8ssvZ6+99soBBxyQxx57LOeee246dOiQNm3aZMKECXnwwQezePHijBkzJsuWLct5552Xtm3bNsW4AABQVE1VVVVLD/Fubr311vzxj3/Mqaee+g897+3bRT510vfSsWv3JpoO2BhNOqlXS48AAEl8GQ0AABTXLJ+TvSGOOOKIlh4BAAA2iJ1sAAAoTGQDAEBhIhsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ0AAIWJbAAAKExkAwBAYSIbAAAKE9kAAFCYyAYAgMJENgAAFCayAQCgMJENAACFiWwAAChMZAMAQGEiGwAAChPZAABQmMgGAIDCRDYAABQmsgEAoDCRDQAAhYlsAAAoTGQDAEBhIhsAAAoT2QAAUFhtSw/QVM4csUO23377lh4DAID3ITvZAABQmMgGAIDCRDYAABQmsgEAoDCRDQAAhYlsAAAoTGQDAEBhIhsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ0AAIWJbAAAKExkAwBAYSIbAAAKq23pAZrKxOnPp2PXlS09Bq3EpJN6tfQIAMB7iJ1sAAAoTGQDAEBhIhsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ0AAIWJbAAAKExkAwBAYSIbAAAKE9kAAFCYyAYAgMJENgAAFCayAQCgMJENAACFiWwAAChMZAMAQGEiGwAAChPZAABQmMgGAIDCRDYAABQmsgEAoDCRDQAAhYlsAAAoTGQDAEBhIhsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ0AAIWJbAAAKKy2OU+2fPnynHPOOVm2bFkWLVqUUaNGZffdd8/555+fTp06Zauttsomm2ySiRMnZtq0aZk1a1Zqampy2GGH5dhjj23OUQEAYIM1a2QvWLAgQ4YMySGHHJKXX345o0ePTqdOnTJp0qTstNNOueyyy/Lyyy/nmWeeyezZs/ODH/wgSXL88cdnv/32S8+ePdd6vRkzZmTGjBlrHauvr2+26wEAgHfTrJHdrVu3TJ06NXfddVc222yzrF69OosWLcpOO+2UJOnfv39mz56dp556Kn/+859z3HHHJUlef/31LFiw4B2RPXz48AwfPnytYwsXLszAgQOb5XoAAODdNGtkT5kyJXvuuWdGjRqV+++/P7/85S+zzTbb5Jlnnknv3r3z2GOPJUl69uyZ3r175/rrr09NTU1uvPHG9OnTpzlHBQCADdaskX3QQQflggsuyOzZs9O5c+e0bds2X//613P22WenY8eOadeuXbp3756+ffvmYx/7WEaOHJn6+vrU1dWle/fuzTkqAABssGaN7H333TezZs1a69hNN92UyZMnZ8stt8xll12Wdu3aJUlOPPHEnHjiic05HgAAFNGskf1uttpqq3z+859Px44d07lz50ycOLGlRwIAgH9Ki0f2oEGDMmjQoJYeAwAAivFlNAAAUJjIBgCAwkQ2AAAUJrIBAKAwkQ0AAIWJbAAAKExkAwBAYSIbAAAKE9kAAFCYyAYAgMJENgAAFCayAQCgMJENAACFiWwAAChMZAMAQGEiGwAAChPZAABQmMgGAIDCRDYAABQmsgEAoDCRDQAAhYlsAAAoTGQDAEBhIhsAAAoT2QAAUJjIBgCAwkQ2AAAUJrIBAKCw2pYeoKmcOWKHbL/99i09BgAA70N2sgEAoDCRDQAAhYlsAAAoTGQDAEBhIhsAAAoT2QAAUNh77iP81qxZkyR56aWXWngSAADeD7bZZpvU1q6d1e+5yH7llVeSJEcffXQLTwIAwPvB3Xff/Y7vZ3nPRfbuu++eD3/4w/nud7+btm3btvQ4tDJjx47N5MmTW3oMWiFrhw1l7bChrJ2NxzbbbPOOY++5yN50003TqVOn7Ljjji09Cq1Q+/btfVMoG8TaYUNZO2woa2fj5o2PAABQmMgGAIDCRDYAABT2nozs4cOHt/QItFLWDhvK2mFDWTtsKGtn41ZTVVXV0kMAAMB7yXtyJxsAAFqSyAYAgMJENgAAFNaqI7uhoSFf//rXM3z48IwePToLFixY6/GZM2fmiCOOyFFHHZWf//znLTQlG5u/t25uvPHGHHnkkTnyyCNz1VVXtdCUbIz+3tp5+3dOPPHE3HzzzS0wIRurv7d2fvnLX+aoo47KkUcemfHjx8fbpXjb31s7U6ZMyRFHHJHPfe5z+dnPftZCU/JuWnVkz5kzJ/X19ZkxY0b+/d//PRMnTmx87JVXXsm0adMyffr03HDDDbn00ktTX1/fgtOysVjXunnhhRfy4x//ONOnT8/MmTPzq1/9KvPmzWvBadmYrGvtvO073/lOli5d2gLTsTFb19pZvnx5vvWtb2Xy5Mm55ZZbst122+XVV19twWnZmKxr7SxdujTf//73M3369EyZMiUXXXRRC07K/9WqI/vhhx/O/vvvnyTZc8898/jjjzc+9rvf/S577bVX2rdvn86dO2eHHXYQSyRZ97rZZpttcv3116dt27apqanJ6tWrs8kmm7TUqGxk1rV2kuSnP/1pampqGn8H3rautfPb3/42O++8cy6++OKMGjUq3bp1y5ZbbtlSo7KRWdfa6dChQz74wQ/mzTffzJtvvpmampqWGpN3UdvSA/wzli9fns0226zx57Zt22b16tWpra3N8uXL07lz58bHOnXqlOXLl7fEmGxk1rVu2rVrly233DJVVWXSpEnZdddd06NHjxaclo3JutbOU089lVmzZuWKK67If/zHf7TglGyM1rV2Xn311TzwwAO5/fbb07Fjxxx99NHZc889/d1DknWvnSTZdtttM2TIkKxZsyZf+MIXWmpM3kWrjuzNNtssb7zxRuPPDQ0NjYvu/z72xhtvrBXdvH+ta90kycqVK3P22WenU6dOOe+881piRDZS61o7t99+e15++eWMGTMmf/rTn9KuXbtst912+cQnPtFS47IRWdfa2XzzzbPHHntk6623TpLsvffe+cMf/iCySbLutTN37twsWrQod999d5LkhBNOSL9+/VJXV9cis7K2Vn27SL9+/TJ37twkyaOPPpqdd9658bG6uro8/PDDWblyZZYtW5Znn312rcd5/1rXuqmqKqecckr69OmTCRMmpG3bti01Jhuhda2d008/PbfcckumTZuWww8/PMcdd5zAptG61s5uu+2Wp556KkuWLMnq1avz2GOPpXfv3i01KhuZda2drl27ZtNNN0379u2zySabpHPnzt4TshFp1d/42NDQkPHjx+epp55KVVW56KKLMnfu3Oywww4ZOHBgZs6cmRkzZqSqqnzhC1/IoYce2tIjsxFY17ppaGjIuHHjsueeezb+/rhx47LXXnu13MBsNP7e3zlvu/LKK9OtW7eMHDmyBadlY/L31s4dd9yRG264IUkyaNCgnHzyyS08MRuLv7d2rrjiitx7771p06ZN+vXrl9NPP9292RuJVh3ZAACwMWrVt4sAAMDGSGQDAEBhIhsAAAoT2QAAUJjIBgCAwkQ2QCsxd+7czJgxo0nP8Z//+Z9N+voA7xc+wg+ARgMGDMivf/3rlh4DoNVr1V+rDvB+cuutt+bee+/NwoULs+2222bhwoUZMmRInn766Tz55JM58MADM27cuIwePTo9evTI/PnzU1VVLrvssmy99daZOHFiHn744STJ0KFDM2bMmJx55pl57bXX8tprr+WAAw7I66+/nvHjx+fUU0/NOeeck2XLlmXRokUZNWpURo0aldGjR6dv3755+umns3z58lx++eXZbrvtcvXVV2fOnDlZs2ZNRo4cmREjRmTatGmZNWtWampqcthhh+XYY49t4T9BgOYjsgFamRdeeCFTpkzJW2+9lYEDB2bu3Lnp0KFDDjrooIwbNy7JX7+KecKECbnpppty7bXXZsCAAVm4cGFmzpyZ1atXZ9SoUdl3332TJPvuu2+OO+64JH+9XWT8+PF54oknMmTIkBxyyCF5+eWXM3r06IwaNSpJUldXl3POOSeXXXZZ7rjjjuy3336ZO3dubrnllqxZsyaXXnppnn766cyePTs/+MEPkiTHH3989ttvv/Ts2bP5/8AAWoDIBmhlPvShD6Vz585p3759unXrls033zxJ1voq5bcDul+/frnnnnuyzTbbZO+9905NTU3atWuXf/mXf8mzzz6bJOnRo8c7ztGtW7dMnTo1d911VzbbbLOsXr268bFdd901SbLNNttk8eLFmT9/furq6tK2bdu0bds2Z555ZmbPnp0///nPjfH++uuvZ8GCBSIbeN/wxkeAVuZ/x/Tf8vjjjydJHnnkkfTu3Tu9evVqvFVk1apV+e1vf5sdd9zxHa/39tt0pkyZkj333DPf/va3M2jQoKzr7Ts9e/bMk08+mYaGhqxatSrHH398evbsmd69e+f73/9+pk2bliOOOCJ9+vTZ4GsGaG3sZAO8B91222258cYb06FDh0yaNClbbLFFfvOb32T48OFZtWpVBg0alN122+0dz+vVq1dOPfXUDBs2LBdccEFmz56dzp07p23btqmvr3/Xc+2yyy7Zf//9M3LkyDQ0NGTkyJHp27dvPvaxj2XkyJGpr69PXV1dunfv3tSXDbDR8OkiAO8xo0ePzvjx49OrV6+WHgXgfcvtIgAAUJidbAAAKMxONgAAFCayAQCgMJENAACFiWwAAChMZAMAQGH/H8DX2JSuSSCoAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "variable_importance = model.compute_variable_importance(\n", + " basetable[basetable[\"split\"]==\"selection\"]\n", + ")\n", + "plot_variable_importance(variable_importance)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note**: variable importance is based on correlation of the predictor with the model scores (and not the true labels!)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, if wanted, we can convert the model to a dictionary to store it as JSON." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'meta': 'logistic-regression',\n", + " 'predictors': ['sex_enc', 'age_enc', 'class_enc', 'fare_enc', 'sibsp_enc'],\n", + " '_eval_metrics_by_split': {'selection': 0.8443602693602693,\n", + " 'train': 0.8520888109845166,\n", + " 'validation': 0.8277080062794349},\n", + " 'params': {'C': 1000000000.0,\n", + " 'class_weight': None,\n", + " 'dual': False,\n", + " 'fit_intercept': True,\n", + " 'intercept_scaling': 1,\n", + " 'l1_ratio': None,\n", + " 'max_iter': 100,\n", + " 'multi_class': 'auto',\n", + " 'n_jobs': None,\n", + " 'penalty': 'l2',\n", + " 'random_state': 42,\n", + " 'solver': 'liblinear',\n", + " 'tol': 0.0001,\n", + " 'verbose': 0,\n", + " 'warm_start': False},\n", + " 'classes_': [0, 1],\n", + " 'coef_': [[4.4803259699087965,\n", + " 3.643976017538859,\n", + " 4.016803499516308,\n", + " 0.7172923586397533,\n", + " 2.5251121628937665]],\n", + " 'intercept_': [-6.594091554183485],\n", + " 'n_iter_': [5]}" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_dict = model.serialize()\n", + "model_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "if False:\n", + " # to save the model as a JSON file, run the following snippet\n", + " model_path = os.path.join(\"output\", \"model.json\")\n", + " with open(model_path, \"w\") as file:\n", + " json.dump(model_dict, file)\n", + "\n", + " # to reload the model again from a JSON file, run the following snippet\n", + " with open(model_path, \"r\") as file:\n", + " model_dict = json.load(file)\n", + " model = LogisticRegressionModel()\n", + " model.deserialize(model_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have built and selected a final model, it is time to evaluate its predictions on the test set against various evaluation metrics. The used evaluation metrics are:\n", + "\n", + "1. Accuracy\n", + "2. Area Under Curve (AUC)\n", + "3. Precision\n", + "4. Recall\n", + "5. F1\n", + "6. Matthews correlation coefficient\n", + "7. Lift at given percentage\n", + "\n", + "Furthermore, we can evaluate the classification performance using a confusion matrix.\n", + "\n", + "Plotting makes the evaluation of a logistic regression model a lot easier. We will first use a **Receiver Operating Characteristic (ROC) curve**, which is a plot of the false positive rate (x-axis) versus the true positive rate (y-axis). Next, we display the **Cumulative Gains curve**, **Cumulative Lift curve** and **Cumulative Response curve**." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "# get numpy array of True target labels and predicted scores\n", + "y_true = basetable[basetable[\"split\"]==\"validation\"][target_col].values\n", + "y_pred = model.score_model(basetable[basetable[\"split\"]==\"validation\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "evaluator = ClassificationEvaluator()\n", + "evaluator.fit(y_true, y_pred)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.38764843102689206" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "evaluator.probability_cutoff # automatically finds the best cut-off probability" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "accuracy 0.759398\n", + "AUC 0.827708\n", + "precision 0.596154\n", + "recall 0.738095\n", + "F1 0.659574\n", + "matthews_corrcoef 0.483268\n", + "lift at 0.05 3.170000\n", + "dtype: float64" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "evaluator.scalar_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "evaluator.plot_confusion_matrix()" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "evaluator.plot_roc_curve()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "evaluator.plot_cumulative_gains()" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "evaluator.plot_lift_curve()" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "evaluator.plot_cumulative_response_curve()" + ] + } + ], + "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.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}