From 199ace6a635dfd7170ad120e95416fd05d022ba4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Tue, 2 Apr 2019 18:25:36 -0500
Subject: [PATCH 01/17] New model interface based on sqlalchemy. Copied code
 as-is from the old object interface.

---
 src/triage/component/postmodeling/__init__.py |  126 ++
 .../postmodeling/contrast/__init__.py         |    0
 .../contrast/db_credentials_example.yaml      |    6 -
 .../postmodeling/contrast/parameters.py       |   45 -
 .../contrast/postmodeling_tutorial.ipynb      | 1314 -----------------
 .../postmodeling/contrast/utils/__init__.py   |    0
 .../postmodeling/contrast/utils/aux_funcs.py  |   59 -
 .../component/postmodeling/error_analysis.py  |  169 +++
 src/triage/component/postmodeling/jaccard.py  |  422 ++++++
 src/triage/component/postmodeling/plots.py    |  394 +++++
 10 files changed, 1111 insertions(+), 1424 deletions(-)
 delete mode 100644 src/triage/component/postmodeling/contrast/__init__.py
 delete mode 100644 src/triage/component/postmodeling/contrast/db_credentials_example.yaml
 delete mode 100644 src/triage/component/postmodeling/contrast/parameters.py
 delete mode 100644 src/triage/component/postmodeling/contrast/postmodeling_tutorial.ipynb
 delete mode 100644 src/triage/component/postmodeling/contrast/utils/__init__.py
 delete mode 100644 src/triage/component/postmodeling/contrast/utils/aux_funcs.py
 create mode 100644 src/triage/component/postmodeling/error_analysis.py
 create mode 100644 src/triage/component/postmodeling/jaccard.py
 create mode 100644 src/triage/component/postmodeling/plots.py

diff --git a/src/triage/component/postmodeling/__init__.py b/src/triage/component/postmodeling/__init__.py
index e69de29bb..8d71b01a4 100644
--- a/src/triage/component/postmodeling/__init__.py
+++ b/src/triage/component/postmodeling/__init__.py
@@ -0,0 +1,126 @@
+# coding: utf-8
+
+import os
+import yaml
+import logging
+
+import sqlalchemy
+from sqlalchemy.engine.url import URL
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, relationship
+import sqlalchemy.dialects.postgresql as postgresql
+from sqlalchemy import Column, ForeignKey
+
+from triage.component.catwalk.storage import CSVMatrixStore, HDFMatrixStore, Store, ProjectStorage
+
+logging.basicConfig(level=logging.INFO)
+
+
+def __db_url():
+    environ_url = os.getenv('DATABASE_URL')
+    if environ_url:
+        logging.info("Getting db connection credentials from DATABASE_URL")
+        return environ_url
+
+    if os.path.isfile(os.getenv('DATABASE_FILE')):
+        logging.info("Getting db connection credentials from DATABASE_FILE")
+        dbfile = open(os.getenv('DATABASE_FILE'))
+    else:
+        raise EnvironmentError(
+            f"could not determine database connection information from "
+            f"either process environment (DATABASE_URL) or filesystem "
+            f"(DATABASE_FILE)"
+        )
+
+    with dbfile:
+        dbconfig = yaml.load(dbfile)
+
+    return URL(
+        'postgres',
+        host=dbconfig['host'],
+        username=dbconfig['user'],
+        database=dbconfig['db'],
+        password=dbconfig['pass'],
+        port=dbconfig['port'],
+    )
+
+
+__engine = create_engine(__db_url())
+__session = sessionmaker(bind=__engine)
+session = __session()
+
+Base = declarative_base()
+
+
+def get_model(model_id):
+    return session.query(Model).get(model_id)
+
+
+def get_model_group(model_group_id):
+    return session.query(ModelGroup).get(model_group_id)
+
+
+class ModelGroup(Base):
+    __tablename__ = 'model_groups'
+    __table_args__ = ({"schema": "model_metadata"})
+
+    id = Column('model_group_id', postgresql.INTEGER, primary_key=True)
+    type = Column('model_type', postgresql.TEXT)
+    features = Column('feature_list', postgresql.ARRAY(postgresql.TEXT))
+    config = Column('model_config', postgresql.JSONB)
+
+
+class Model(Base):
+    __tablename__ = 'models'
+    __table_args__ = ({"schema": "model_metadata"})
+
+    id = Column('model_id', postgresql.INTEGER, primary_key=True)
+    hash = Column('model_hash', postgresql.TEXT)
+    run_time = Column(postgresql.TIMESTAMP)
+    batch_run_time = Column(postgresql.TIMESTAMP)
+    comment = Column('model_comment', postgresql.TEXT)
+    experiment = Column('built_by_experiment', postgresql.TEXT)
+    train_matrix = Column('train_matrix_uuid', postgresql.TEXT)
+    train_end_time = Column(postgresql.TIMESTAMP)
+    training_label_timespan = Column(postgresql.INTERVAL)
+    size = Column('model_size', postgresql.FLOAT)
+
+    model_group_id = Column('model_group_id', postgresql.INTEGER, ForeignKey('model_metadata.model_groups.model_group_id'))
+    model_group = relationship("ModelGroup", backref="models")
+
+
+class Evaluation(Base):
+    __tablename__ = 'evaluations'
+    __table_args__ = ({"schema": "test_results"})
+
+    evaluation_start_time = Column(postgresql.TIMESTAMP, primary_key=True)
+    evaluation_end_time = Column(postgresql.TIMESTAMP, primary_key=True)
+    metric = Column(postgresql.TEXT, primary_key=True)
+    parameter = Column(postgresql.TEXT, primary_key=True)
+
+    value = Column(postgresql.FLOAT)
+    num_labeled_examples = Column(postgresql.INTEGER)
+    num_labeled_above_threshold = Column(postgresql.INTEGER)
+    num_positive_labels = Column(postgresql.INTEGER)
+    sort_seed =Column(postgresql.INTEGER)
+    matrix = Column('matrix_uuid', postgresql.TEXT)
+
+    model_id = Column('model_id', postgresql.INTEGER, ForeignKey('model_metadata.models.model_id'), primary_key=True)
+    model = relationship("Model", backref="evaluations")
+
+
+class Prediction(Base):
+    __tablename__ = 'predictions'
+    __table_args__ = ({"schema": "test_results"})
+
+    entity_id = Column(postgresql.INTEGER, primary_key=True)
+    as_of_date = Column(postgresql.TIMESTAMP, primary_key=True)
+
+    model_id = Column('model_id', postgresql.INTEGER, ForeignKey('model_metadata.models.model_id'), primary_key=True)
+    model = relationship("Model", backref="predictions")
+
+    score = Column(postgresql.FLOAT)
+    label_value = Column(postgresql.INTEGER)
+    test_label_timespan = Column(postgresql.INTERVAL)
+    matrix = Column('matrix_uuid', postgresql.TEXT)
diff --git a/src/triage/component/postmodeling/contrast/__init__.py b/src/triage/component/postmodeling/contrast/__init__.py
deleted file mode 100644
index e69de29bb..000000000
diff --git a/src/triage/component/postmodeling/contrast/db_credentials_example.yaml b/src/triage/component/postmodeling/contrast/db_credentials_example.yaml
deleted file mode 100644
index 8fe835cbc..000000000
--- a/src/triage/component/postmodeling/contrast/db_credentials_example.yaml
+++ /dev/null
@@ -1,6 +0,0 @@
-host:
-dbname: 
-user: 
-password:
-port: 
-role: '' 
diff --git a/src/triage/component/postmodeling/contrast/parameters.py b/src/triage/component/postmodeling/contrast/parameters.py
deleted file mode 100644
index 802d0806e..000000000
--- a/src/triage/component/postmodeling/contrast/parameters.py
+++ /dev/null
@@ -1,45 +0,0 @@
-"""
-Postmodeling parameters
-
-This script contain the parameters Class that will be used across all the
-postmodeling functions within the ModelEvaluator and ModelGroupEvaluator
-classes. This class will be initialized using the 'postmodeling_parameters.yaml' 
-file
-
-"""
-
-import yaml
-import json
-import warnings
-
-class PostmodelParameters(object):
-    '''
-    PostmodelParameters reads all parameters from a 'yaml' file and store them
-    in this object to be used in other functions. Different metrics can be
-    passed to this object, by default it will reads from a
-    'postmodeling_parameters.yaml', but an Audition config file can be passed
-    and will parse from it the needed parameters
-    '''
-    def __init__(self, path_params):
-
-        with open(path_params) as f:
-            params = yaml.load(f)
-
-        # Assign dict elements to Parameters object and flatten 
-        # thresholds
-        self.__dict__.update(params)
-        self.figsize = tuple(self.figsize) 
-
-        try:
-            if self.audition_output_path is not None: 
-                with open(self.audition_output_path) as f:
-                    json_models = json.load(f)
-
-                list_models = [model for model_list in json_models.values() 
-                               for model in model_list]
-                self.model_group_id = list_models
-
-        except AttributeError:
-            warnings.warn(
-                f'''No audition output file was defined. I will use the models
-                defined \n in the {path_params} configuration file.''') 
diff --git a/src/triage/component/postmodeling/contrast/postmodeling_tutorial.ipynb b/src/triage/component/postmodeling/contrast/postmodeling_tutorial.ipynb
deleted file mode 100644
index c0cf0f064..000000000
--- a/src/triage/component/postmodeling/contrast/postmodeling_tutorial.ipynb
+++ /dev/null
@@ -1,1314 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%load_ext autoreload\n",
-    "%autoreload 2"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Postmodel Analysis\n",
-    "\n",
-    "This notebook will guide the `triage` user through some useful rutines to compare individual models across `model_group_id`'s and also `model_group`s. This is an interactive process that combines huntches and some general ways to compare models. Before starting this process, is important to run `triage`'s _Audition_ component which will filter `model_group_id`'s using user-defined metrics (see [Audition](https://github.com/dssg/triage/blob/master/src/triage/component/audition/Audition_Tutorial.ipynb) to explore more). "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x119a45860>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "from collections import OrderedDict\n",
-    "from triage.component.postmodeling.contrast.utils.aux_funcs import create_pgconn, get_models_ids\n",
-    "from triage.component.catwalk.storage import ProjectStorage, ModelStorageEngine, MatrixStorageEngine\n",
-    "from triage.component.postmodeling.contrast.parameters import PostmodelParameters\n",
-    "from triage.component.postmodeling.contrast.model_evaluator import ModelEvaluator\n",
-    "from triage.component.postmodeling.contrast.model_group_evaluator import ModelGroupEvaluator"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Parameters\n",
-    "\n",
-    "Postmodel need a set of parameters to pass through some of its functions. This will allow the user to better analyize its models, This parameters can be readed from a `.yaml` file (a `postmodeling_parameters.yaml` example is included in this Notebook). If you want to set other parameters, you can pass them to the `.yaml` file, and the `PostmodelParameters` class, will create them. \n",
-    "\n",
-    "You can define de selected models by either defining a path to an `Audition` output, or by adding your own prefered models. \n",
-    "\n",
-    "This parameters include: \n",
-    " - `project_path`: Path to matrices and modes (normally under `triage/output`)\n",
-    " - `audition_output_path`: Path to Audition output `.json` file. \n",
-    " - `model_group_id`: List with selected `ModelGroup` from `Audition`\n",
-    " - `metric`: Selected metric string (i.e. `precision@`,`recall@`)\n",
-    " - `thresholds`: Selected threshold list (i.e. `rank_abs[50, 100]`)\n",
-    " - `baseline_query`:A SQL query that returns evaluation metrics for the baseline models\n",
-    " - `n_features_plots`: Number of features to plot importances (int)\n",
-    " - `max_depth_error_trees`: For residual DecisionTrees, number of splits (int)\n",
-    "\n",
-    "Some aesthetic parameters\n",
-    "\n",
-    " - `figsize`: Plot size (tuple)\n",
-    " - `fontsize`: Font size for plots (int)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params = PostmodelParameters('postmodeling_config.yaml')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "These are the parameters stored in the `postmodeling_config.yaml`, and the notebook will use this to set parameters in other functions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'project_path': '../../../../../../triage_output/output/',\n",
-       " 'audition_output_path': 'results_model_group_ids.json',\n",
-       " 'model_group_id': [19, 43, 55],\n",
-       " 'thresholds': {'rank_pct': [10]},\n",
-       " 'baseline_query': \"SELECT g.model_group_id,\\n       m.model_id,\\n       EXTRACT('YEAR' FROM m.evaluation_end_time) AS as_of_date_year,\\n       m.metric,\\n       m.parameter,\\n       m.value,\\n       m.num_labeled_examples,\\n       m.num_labeled_above_threshold,\\n       m.num_positive_labels\\n FROM test_results.evaluations m\\n LEFT JOIN model_metadata.models g\\n USING(model_id)\\n WHERE g.model_group_id IN (1, 2, 3)\\n       AND metric = 'precision@'\\n       AND parameter = '10.0_pct'\\n\",\n",
-       " 'max_depth_error_tree': 5,\n",
-       " 'n_features_plots': 10,\n",
-       " 'figsize': (12, 12),\n",
-       " 'fontsize': 20}"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "params.__dict__"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Create SQL Engine"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "engine = create_pgconn('db_credentials.yaml')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Engine(postgresql://ivan:***@localhost:5432/food)"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "engine"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model and Model Group Evaluators\n",
-    "\n",
-    "This class will contain all the individual `model_id`'s (the part of the `model_group_id`) for each of the `model_group_id`'s defined in the paramters configuration file. To instantiate all the models we can create a list with each of the models of interest\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# List individual models\n",
-    "list_tuple_models = get_models_ids(params.model_group_id, engine)\n",
-    "l_t = [ModelEvaluator(i.model_group_id, i.model_id, engine) for i in list_tuple_models]\n",
-    "\n",
-    "# Model group object (useful to compare across model_groups and models in time)\n",
-    "audited_models_class = ModelGroupEvaluator(tuple(params.model_group_id), engine)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can explore the contents of the `ModelEvaluator` for each `model_id` inside the specified `model_group_id`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'model_id': 44, 'model_group': 19, 'model_type': 'sklearn.ensemble.RandomForestClassifier', 'as_of_date': 'January 13, 2016', 'model_hyperparameters': {'criterion': 'gini', 'class_weight': 'balanced', 'max_features': 'sqrt', 'n_estimators': 1000, 'min_samples_leaf': 1, 'min_samples_split': 50}}\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(l_t[0])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[{'model_id': 152,\n",
-       "  'model_group_id': 43,\n",
-       "  'model_hash': '2dad45255e8e6ab538f96ead00c40e5c',\n",
-       "  'hyperparameters': {'criterion': 'gini',\n",
-       "   'class_weight': 'balanced',\n",
-       "   'max_features': 'sqrt',\n",
-       "   'n_estimators': 1000,\n",
-       "   'min_samples_leaf': 1,\n",
-       "   'min_samples_split': 50},\n",
-       "  'train_end_time': datetime.datetime(2018, 1, 13, 0, 0),\n",
-       "  'train_matrix_uuid': '4b09c67e31e6a0cba9f99aef600967c2',\n",
-       "  'training_label_timespan': datetime.timedelta(30),\n",
-       "  'model_type': 'sklearn.ensemble.RandomForestClassifier',\n",
-       "  'model_config': {'state': 'active',\n",
-       "   'label_name': 'inspected',\n",
-       "   'cohort_name': 'active_facilities',\n",
-       "   'feature_groups': ['prefix: results', 'prefix: risks'],\n",
-       "   'label_timespan': '1month',\n",
-       "   'as_of_date_frequency': '1month',\n",
-       "   'max_training_history': '5y'},\n",
-       "  'test_matrix_uuid': '3a1535f25b08cfe3749af36f8e7235bd'},\n",
-       " {'model_id': 80,\n",
-       "  'model_group_id': 55,\n",
-       "  'model_hash': '6d51a3c823df44e2b3f08bcbffc383e3',\n",
-       "  'hyperparameters': {'criterion': 'gini',\n",
-       "   'class_weight': 'balanced',\n",
-       "   'max_features': 'sqrt',\n",
-       "   'n_estimators': 1000,\n",
-       "   'min_samples_leaf': 1,\n",
-       "   'min_samples_split': 50},\n",
-       "  'train_end_time': datetime.datetime(2016, 1, 13, 0, 0),\n",
-       "  'train_matrix_uuid': '27064e1288bbd8d0fd712af48269364a',\n",
-       "  'training_label_timespan': datetime.timedelta(30),\n",
-       "  'model_type': 'sklearn.ensemble.RandomForestClassifier',\n",
-       "  'model_config': {'state': 'active',\n",
-       "   'label_name': 'inspected',\n",
-       "   'cohort_name': 'active_facilities',\n",
-       "   'feature_groups': ['prefix: inspections', 'prefix: results'],\n",
-       "   'label_timespan': '1month',\n",
-       "   'as_of_date_frequency': '1month',\n",
-       "   'max_training_history': '5y'},\n",
-       "  'test_matrix_uuid': '6be3faf964d1025ebd4f8fbae8c28890'},\n",
-       " {'model_id': 44,\n",
-       "  'model_group_id': 19,\n",
-       "  'model_hash': '24b5b54afdfd61cf89b10d02b5c5e31d',\n",
-       "  'hyperparameters': {'criterion': 'gini',\n",
-       "   'class_weight': 'balanced',\n",
-       "   'max_features': 'sqrt',\n",
-       "   'n_estimators': 1000,\n",
-       "   'min_samples_leaf': 1,\n",
-       "   'min_samples_split': 50},\n",
-       "  'train_end_time': datetime.datetime(2016, 1, 13, 0, 0),\n",
-       "  'train_matrix_uuid': '936d9a0559092efbde15043d36b557a0',\n",
-       "  'training_label_timespan': datetime.timedelta(30),\n",
-       "  'model_type': 'sklearn.ensemble.RandomForestClassifier',\n",
-       "  'model_config': {'state': 'active',\n",
-       "   'label_name': 'inspected',\n",
-       "   'cohort_name': 'active_facilities',\n",
-       "   'feature_groups': ['prefix: inspections',\n",
-       "    'prefix: results',\n",
-       "    'prefix: risks'],\n",
-       "   'label_timespan': '1month',\n",
-       "   'as_of_date_frequency': '1month',\n",
-       "   'max_training_history': '5y'},\n",
-       "  'test_matrix_uuid': '8a2f41920a5b27466c278751f7643b50'},\n",
-       " {'model_id': 68,\n",
-       "  'model_group_id': 43,\n",
-       "  'model_hash': '9bf207941550270baa0f46304e121fe1',\n",
-       "  'hyperparameters': {'criterion': 'gini',\n",
-       "   'class_weight': 'balanced',\n",
-       "   'max_features': 'sqrt',\n",
-       "   'n_estimators': 1000,\n",
-       "   'min_samples_leaf': 1,\n",
-       "   'min_samples_split': 50},\n",
-       "  'train_end_time': datetime.datetime(2016, 1, 13, 0, 0),\n",
-       "  'train_matrix_uuid': 'a4310fc069672a3df46a618d2acd8c43',\n",
-       "  'training_label_timespan': datetime.timedelta(30),\n",
-       "  'model_type': 'sklearn.ensemble.RandomForestClassifier',\n",
-       "  'model_config': {'state': 'active',\n",
-       "   'label_name': 'inspected',\n",
-       "   'cohort_name': 'active_facilities',\n",
-       "   'feature_groups': ['prefix: results', 'prefix: risks'],\n",
-       "   'label_timespan': '1month',\n",
-       "   'as_of_date_frequency': '1month',\n",
-       "   'max_training_history': '5y'},\n",
-       "  'test_matrix_uuid': 'a060396612b33981cdb16a653b254b87'},\n",
-       " {'model_id': 122,\n",
-       "  'model_group_id': 55,\n",
-       "  'model_hash': 'f019f15f92f018778ac5a0f2f9b6c513',\n",
-       "  'hyperparameters': {'criterion': 'gini',\n",
-       "   'class_weight': 'balanced',\n",
-       "   'max_features': 'sqrt',\n",
-       "   'n_estimators': 1000,\n",
-       "   'min_samples_leaf': 1,\n",
-       "   'min_samples_split': 50},\n",
-       "  'train_end_time': datetime.datetime(2017, 1, 13, 0, 0),\n",
-       "  'train_matrix_uuid': 'e9280b7305e1eb070484dcb8c88a0ee2',\n",
-       "  'training_label_timespan': datetime.timedelta(30),\n",
-       "  'model_type': 'sklearn.ensemble.RandomForestClassifier',\n",
-       "  'model_config': {'state': 'active',\n",
-       "   'label_name': 'inspected',\n",
-       "   'cohort_name': 'active_facilities',\n",
-       "   'feature_groups': ['prefix: inspections', 'prefix: results'],\n",
-       "   'label_timespan': '1month',\n",
-       "   'as_of_date_frequency': '1month',\n",
-       "   'max_training_history': '5y'},\n",
-       "  'test_matrix_uuid': 'a4d5d95528bce856a73c766aae68cb90'},\n",
-       " {'model_id': 110,\n",
-       "  'model_group_id': 43,\n",
-       "  'model_hash': 'ef01863eb3e92a0ff72c84581b9f2449',\n",
-       "  'hyperparameters': {'criterion': 'gini',\n",
-       "   'class_weight': 'balanced',\n",
-       "   'max_features': 'sqrt',\n",
-       "   'n_estimators': 1000,\n",
-       "   'min_samples_leaf': 1,\n",
-       "   'min_samples_split': 50},\n",
-       "  'train_end_time': datetime.datetime(2017, 1, 13, 0, 0),\n",
-       "  'train_matrix_uuid': 'c7450a6c72ff1b067a5d30e78b47c080',\n",
-       "  'training_label_timespan': datetime.timedelta(30),\n",
-       "  'model_type': 'sklearn.ensemble.RandomForestClassifier',\n",
-       "  'model_config': {'state': 'active',\n",
-       "   'label_name': 'inspected',\n",
-       "   'cohort_name': 'active_facilities',\n",
-       "   'feature_groups': ['prefix: results', 'prefix: risks'],\n",
-       "   'label_timespan': '1month',\n",
-       "   'as_of_date_frequency': '1month',\n",
-       "   'max_training_history': '5y'},\n",
-       "  'test_matrix_uuid': 'b19848609198b36cc9853ab5646d8685'},\n",
-       " {'model_id': 164,\n",
-       "  'model_group_id': 55,\n",
-       "  'model_hash': '869cc9251460cb65d14ced62ac7163cf',\n",
-       "  'hyperparameters': {'criterion': 'gini',\n",
-       "   'class_weight': 'balanced',\n",
-       "   'max_features': 'sqrt',\n",
-       "   'n_estimators': 1000,\n",
-       "   'min_samples_leaf': 1,\n",
-       "   'min_samples_split': 50},\n",
-       "  'train_end_time': datetime.datetime(2018, 1, 13, 0, 0),\n",
-       "  'train_matrix_uuid': '74faccd22f6762218a0a432dec469a79',\n",
-       "  'training_label_timespan': datetime.timedelta(30),\n",
-       "  'model_type': 'sklearn.ensemble.RandomForestClassifier',\n",
-       "  'model_config': {'state': 'active',\n",
-       "   'label_name': 'inspected',\n",
-       "   'cohort_name': 'active_facilities',\n",
-       "   'feature_groups': ['prefix: inspections', 'prefix: results'],\n",
-       "   'label_timespan': '1month',\n",
-       "   'as_of_date_frequency': '1month',\n",
-       "   'max_training_history': '5y'},\n",
-       "  'test_matrix_uuid': 'b44388f5b4e25442795aefb02033cdae'},\n",
-       " {'model_id': 86,\n",
-       "  'model_group_id': 19,\n",
-       "  'model_hash': 'e8b2ec36d2a3c13a2fb0f9daeeda440a',\n",
-       "  'hyperparameters': {'criterion': 'gini',\n",
-       "   'class_weight': 'balanced',\n",
-       "   'max_features': 'sqrt',\n",
-       "   'n_estimators': 1000,\n",
-       "   'min_samples_leaf': 1,\n",
-       "   'min_samples_split': 50},\n",
-       "  'train_end_time': datetime.datetime(2017, 1, 13, 0, 0),\n",
-       "  'train_matrix_uuid': 'd1abe0f61726575979c2194390af8ba3',\n",
-       "  'training_label_timespan': datetime.timedelta(30),\n",
-       "  'model_type': 'sklearn.ensemble.RandomForestClassifier',\n",
-       "  'model_config': {'state': 'active',\n",
-       "   'label_name': 'inspected',\n",
-       "   'cohort_name': 'active_facilities',\n",
-       "   'feature_groups': ['prefix: inspections',\n",
-       "    'prefix: results',\n",
-       "    'prefix: risks'],\n",
-       "   'label_timespan': '1month',\n",
-       "   'as_of_date_frequency': '1month',\n",
-       "   'max_training_history': '5y'},\n",
-       "  'test_matrix_uuid': 'b50965ba3b15e5d23c46aa7b00d65a30'},\n",
-       " {'model_id': 128,\n",
-       "  'model_group_id': 19,\n",
-       "  'model_hash': '0acae9e66399bc5a8f3bea02f2ac4e75',\n",
-       "  'hyperparameters': {'criterion': 'gini',\n",
-       "   'class_weight': 'balanced',\n",
-       "   'max_features': 'sqrt',\n",
-       "   'n_estimators': 1000,\n",
-       "   'min_samples_leaf': 1,\n",
-       "   'min_samples_split': 50},\n",
-       "  'train_end_time': datetime.datetime(2018, 1, 13, 0, 0),\n",
-       "  'train_matrix_uuid': '02a250d1df77a98b8979bdfb656d029a',\n",
-       "  'training_label_timespan': datetime.timedelta(30),\n",
-       "  'model_type': 'sklearn.ensemble.RandomForestClassifier',\n",
-       "  'model_config': {'state': 'active',\n",
-       "   'label_name': 'inspected',\n",
-       "   'cohort_name': 'active_facilities',\n",
-       "   'feature_groups': ['prefix: inspections',\n",
-       "    'prefix: results',\n",
-       "    'prefix: risks'],\n",
-       "   'label_timespan': '1month',\n",
-       "   'as_of_date_frequency': '1month',\n",
-       "   'max_training_history': '5y'},\n",
-       "  'test_matrix_uuid': 'dbee9d4fea8553cf6249ca782a143df5'}]"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "audited_models_class.metadata"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Let's talk about postmodeling:\n",
-    "\n",
-    "### How the scores looks like?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "One of the main metrics we want to evaluate from each of our models is their predictions. The way `triage` modeling component works pivot around `model_groups_id` as the main element of modeling. Model Groups have the same model configuration (hyperparameters, feature space, etc) with different models ran in different prediction windows. \n",
-    "\n",
-    "We want to check a few things when exploring score predictions: \n",
-    "\n",
-    "1. Score distributions\n",
-    "2. Score distributions by trained label\n",
-    "\n",
-    "Audition will output a dict object with a set of models for each of the defined metrics. We can either read from Audition output, or we can define a list (`audited_models`) to start the post-modeling exploration. We will get each individual `model_id` from the audited `model_groups_id`'s and get the relevant metadata and matrices for each models using the `Model` class. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x119f48630>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "l_t[0].plot_score_distribution(figsize=params.figsize)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11a93d550>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "l_t[0].plot_score_label_distributions(figsize=params.figsize)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x10ab4ca20>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "l_t[1].plot_score_distribution_thresh(figsize=params.figsize, param_type = 'rank_pct', param = 10)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### How's the precision across time for each of my selected model groups?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "But, how accurate are these scores? In the paramteres configuration fil we defined a set (or probably one) threshold that will help us to classify (label) predicted entities as 1's or O's. These will help us to assess each of the model groups across time. To have better insights about our model quality, we can compare our model groups against a baseline model (also defined in our configuration file). "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11a9032b0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "a = audited_models_class.plot_prec_across_time(param_type='rank_pct',\n",
-    "                                           param=10,\n",
-    "                                           baseline=True,\n",
-    "                                           baseline_query=params.baseline_query,\n",
-    "                                           metric='precision@',\n",
-    "                                           figsize=params.figsize)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Features: what's is happening behind this prediction?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can extract individual feature importances from `triage` results schema and indentify the important features for each model. In this `dirtyduck` example, we find that a significant set of features are correlated, usually corresponding to imputated values, or `NULL` values in their categorization. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### How are the model features correlated (and its feature groups)?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x1185bad68>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "l_t[0].cluster_correlation_features(path=params.project_path,\n",
-    "                                    feature_group_subset_list = ['results']) "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### How many zeroes/imputation our model feature space has?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11ca85278>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "l_t[0].cluster_correlation_sparsity(path=params.project_path)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Which is the feature that has the biggest relevance in my prediction?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11d2e5c18>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11a970978>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "l_t[0].plot_feature_importances(path=params.project_path,\n",
-    "                                n_features_plots=params.n_features_plots, \n",
-    "                                figsize=params.figsize)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### _Another way of exploring this relationship:_"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/ivan/.pyenv/versions/triage-3.6.2/lib/python3.6/site-packages/sklearn/base.py:251: UserWarning: Trying to unpickle estimator DecisionTreeClassifier from version 0.19.1 when using version 0.20.1. This might lead to breaking code or invalid results. Use at your own risk.\n",
-      "  UserWarning)\n",
-      "/Users/ivan/.pyenv/versions/triage-3.6.2/lib/python3.6/site-packages/sklearn/base.py:251: UserWarning: Trying to unpickle estimator RandomForestClassifier from version 0.19.1 when using version 0.20.1. This might lead to breaking code or invalid results. Use at your own risk.\n",
-      "  UserWarning)\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11a8aee10>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "l_t[0].plot_feature_importances_std_err(path= params.project_path, \n",
-    "                                        n_features_plots = params.n_features_plots)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 155,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/ivan/.pyenv/versions/triage-3.6.2/lib/python3.6/site-packages/sklearn/base.py:311: UserWarning: Trying to unpickle estimator DecisionTreeClassifier from version 0.19.1 when using version 0.19.2. This might lead to breaking code or invalid results. Use at your own risk.\n",
-      "  UserWarning)\n",
-      "/Users/ivan/.pyenv/versions/triage-3.6.2/lib/python3.6/site-packages/sklearn/base.py:311: UserWarning: Trying to unpickle estimator RandomForestClassifier from version 0.19.1 when using version 0.19.2. This might lead to breaking code or invalid results. Use at your own risk.\n",
-      "  UserWarning)\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x10a984898>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "l_t[0].plot_feature_importances_std_err(path= params.project_path, \n",
-    "                                        n_features_plots = 20,\n",
-    "                                        bar=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Which feature group has more relevance in my model performance? \n",
-    "\n",
-    "Feature inclusion and exclusion (LOI and LOO) performance allow us to compare different experiments made in each `model_group_id` and see how the exclusion or inclusion of new feature groups have a leverage in the user defined metric to assess performance. The method `feature_groups` depicts the expriment type for each of the models. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11d190550>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11a9cdbe0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "l_t[0].plot_feature_group_average_importances()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In a more detailed way, we can explore features and their distribution across label values"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11a8c15f8>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n",
-      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11d1904e0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "l_t[0].plot_feature_distribution(path=params.project_path)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/ivan/triage/src/triage/component/postmodeling/contrast/model_group_evaluator.py:459: SettingWithCopyWarning: \n",
-      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
-      "Try using .loc[row_indexer,col_indexer] = value instead\n",
-      "\n",
-      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
-      "  else row['feature_group_array'] + '_loi', axis=1)\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11a8a7358>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "audited_models_class.feature_loi_loo(param_type='rank_pct',\n",
-    "                                     param=10,\n",
-    "                                     metric='precision@',\n",
-    "                                     baseline=True,\n",
-    "                                     baseline_query=params.baseline_query)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Crosstabs: once predicted, what are the main difference between my groups? What's the feature that characterise my predictions? "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Crosstabs is already on development, you can [check out it](https://github.com/dssg/postmodel-analysis/tree/sqlqueries/postmodel/crosstabs). `crosstabs` will generate a table with the differences in feature distributions across predicted entites using a top-k precision. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11a93dfd0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "l_t[0].crosstabs_ratio_plot(n_features=params.n_features_plots, \n",
-    "                            figsize=params.figsize)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### What about the model metrics? "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x110442c88>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "l_t[0].plot_ROC(figsize=(8,8))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x110076748>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfwAAAITCAYAAADiqK7ZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3XdYFFf78PEvHWmW2IkG22IFS0QTO8UCiiIqqGCJQY0aiRprTLNENCZRo4n6i5XYW6ygorHEHiNYAhpRscSCoCJd2Hn/8GUfNxRB0KXcn+vKlezM2TP3nt1wz5w5c46eoigKQgghhCjW9HUdgBBCCCFeP0n4QgghRAkgCV8IIYQoASThCyGEECWAJHwhhBCiBJCEL4QQQpQAhroOQJQsP/74IwsXLtTapqenh6mpKRUrVqRFixYMGjSIWrVq6SjCN++PP/7AysoKOzs7ncVw/fp1IiIi6NKlS4HWu3LlSmbNmsWsWbPo2bNnjmVtbW2z3G5gYICFhQU2NjZ07dqV/v37Y2BgkGXZsLAw1qxZw59//kl0dDSlS5fmnXfeoUePHnTr1g1TU9Nsj5+YmMjOnTvZuXMnN27c4PHjx1SoUIEWLVowZMgQ6tSpk/sP/hrqEyK/JOELnXBycqJevXoAqNVq4uPjiYiIYOPGjezYsYP58+fTvn173Qb5Bqxdu5avv/6aRYsW6SyGiIgIevXqRd++fQs84eeVpaUlAwcO1Nr27Nkzbt26RUhICGFhYURGRvL1119rlVGr1cyePZuVK1diYmJCmzZtcHV15cmTJ5w8eZKpU6eyfPlyFi1aRM2aNTMd9+rVq4waNYrr169Tu3Zt2rdvj6WlJVevXuW3335j165dzJs3D2dn51x9joKuT4gCoQjxBi1YsEBRqVTKli1bstx/6NAhpUGDBkrjxo2VGzduvOHo3ryM9ti/f7/OYjh58qSiUqmUGTNmFHjdK1asyPH7fpFKpVI6dOiQ7f7Lly8rdnZ2iq2trRIZGam1LyAgQFGpVEq/fv2Uu3fvau1LS0tTVqxYodStW1dp0aKFEh0drbU/JiZGadWqlVKvXj1lw4YNilqt1tp/7tw5pUmTJkqDBg2Uv//++6Wfo6DrE6KgyD18Uai0a9cOf39/EhMT+emnn3QdjihEVCoVnTt3RlEUTp48qdl+6dIlVqxYgY2NDUuXLqVy5cpa7zMwMGDQoEF8/PHHPHr0iOnTp2vtnz17NtHR0YwePZo+ffqgp6entb9x48ZMnDiRZ8+esXTp0pfGWdD1CVFQJOGLQsfHxwcTExP27dtHWlqa1r4TJ04wePBgmjVrRuPGjfHy8iI4ODjLes6cOcOwYcNo0aIFzZo1w9vbm5CQkEzljh07xuDBg2natCl2dnZ4eHiwZs0a1Gq1VjlHR0d8fX2JjIxk+PDhNGvWjCZNmuDn50dERIRW2YSEBL755hs6d+5Mo0aNeO+99xg1ahSXLl3SlPH19dWMZxg5cqTmHvbWrVuxtbUlKCiIIUOG0KhRIzp06MCtW7fw9fXF1taWuLg4rePdvn0bW1tbRowYobU9KSmJBQsW0LlzZ+zt7XF0dOTrr78mNjYWeD6mYsCAAQCsXr0aW1tbTp06pXn/pUuXGDFiBC1atMDOzo7u3buzbt06lCxm5A4JCcHLy4vGjRvTrl07fv7550xtmF/lypUDIDU1VbMtMDAQRVHw8/PD3Nw82/d++OGHlCtXjv379/Pw4UMA4uPjCQ4OxtzcXNMOWenRowf+/v70798/x/jyU19evttJkyZha2vL+fPncXV1pVGjRnh7e9OtWzcaNWpEfHx8pmMuXboUW1tb9uzZo9kWFRXFp59+yvvvv0/Dhg3p0qULS5Ys4dmzZzl+TlE0ScIXhU6pUqWoX78+iYmJhIeHa7Zv2rSJwYMHc/nyZVxdXfHy8iImJgZ/f38WL16sVcf27dsZOHAgZ86coW3btnh6enL37l1GjhzJli1bNOUCAwP54IMPuHDhAi4uLnh6evL06VOmTZvGuHHjMiW2u3fv4u3tTUxMDH369KFFixYcOXIEX19fTRIF+OSTT1i1ahU2NjYMHDiQdu3aceTIEfr378+1a9cA8PDwwMHBAQBXV1dGjRqldawZM2YQGxuLr68vjRo1olq1anlqx6SkJPr27cuiRYuwsLDA29sbW1tb1q5dy8CBA4mPj8fBwQEPDw8A7O3tGTVqFNbW1gAcPnwYb29vTp48SYcOHfDx8UGtVvPVV1/xxRdfaB1r06ZNjBw5klu3buHu7o6DgwOLFy9m+fLleYo5J2q1mmPHjgFQt25dzfbjx48D0LZt2xzfb2xsTLt27UhPT+f3338H4PTp0yQnJ9O0aVPMzMyyfa+JiQkjRozg3XffzfEYBV3fy3z00UdUr14db29vWrRogbu7O6mpqVme2O7evRsLCwucnJyA5ydznp6eBAcH07JlSwYNGkTp0qX5/vvv+eijj0hPT89XbKLwkUF7olCqVKkSANHR0QDcu3ePadOmUbNmTdasWUPZsmUBGDNmDIMGDWL+/Pk4OjqiUql48uQJ06dPp0yZMqxZs4YaNWoAMHz4cLp3786cOXNwd3fn3r17BAQEULVqVVavXq1JqImJiXz00Ufs2bOHdu3a0aNHD01ct27don///nz++eeartrPP/+cjRs3snfvXvr27cuVK1c4cuQIPXr0YPbs2Zr3tm/fHn9/fzZt2sTEiRPp2bMnd+7c4fTp07i5uWUawGVoaMjatWspVarUK7Xh0qVLCQ8PZ+DAgUyePFkT75IlS/j+++81J1AA27Ztw97eno8//hh4frIwadIkLC0t2bhxI2+//TYAn376KZ988gkbN27E2dmZdu3aERcXx+zZs6lcuTIbNmzQdKkPGDAAHx+fV4r9RSkpKdy8eZMlS5Zw+fJlmjdvTsuWLYHn39X9+/cxNzenYsWKL60rY8De7du3gee/KwAbG5t8x/k66nuZpk2b8uOPP2od//vvvycoKEjrdxsZGUlERAQ9e/bExMQERVGYNGkSqamprF+/noYNG2rKzpo1i5UrV7J+/fqX9miIokWu8EWhZGxsDKDpmtyxYwepqamMHj1ak+wBTE1NGT16NGq1mm3btgHPr0yfPn3KgAEDNMkenncHT548mQ8//JDExER27NhBWloaI0eO1Lp6NjMzY+rUqQBavQEZ/Pz8tO7LtmvXDoA7d+4AaLqxr1+/rtW16uzsTEhICJ9++mmu2qBt27avnOzhf1d048aN04rXx8eHDz/8kNq1a2f73oMHDxIbG8uQIUM0yR5AX1+fcePGAf9rmxfb+8X7540aNdJKOrlx584dbG1ttf6xs7Oja9eu7Nq1C2dnZxYsWKAp//TpUwAsLCxyVX+ZMmUAePTokdb7c7oVkBcFXd/LdOzYUet15cqVad68OceOHePJkyea7UFBQQB069YNeP744pUrV+jVq5dWsgfw9/fHyMiIrVu3vuboxZsmV/iiUEpISADQdItevHgReH4P/59//tEqm5iYCKC5j57x78aNG2eq19XVVfPfGeWaN2+eqVydOnWwsrLKdG/exMSEKlWqaG3LSDYZ95VtbW1p0qQJ586do1WrVjg4ONC2bVs6dOiQp275FxNtXiUlJREVFUXz5s0xMTHR2mdubs748eNzfH9Ge1+6dEnrCjKDgYFBpvb+b+IAaNKkCevXr8913C8+lpeWlsa5c+c4deoU1apVY+HChVpd+QClS5cGnvcC5EbGbyXjpDHjBOC/981fVUHX9zJZ/Ubc3d05deoU+/fvp1evXgDs2bOHihUranpGMsaS3Lx5M8vv19zcnMuXL6MoSqZBh6LokoQvCqWMq+WMBJlx5ZRT8si4osn4Y/uyq76Mq29LS8ss91esWJGoqCitbRk9Dy/K+IOYcb9fT0+PZcuW8csvv7Bz506OHDnCkSNHmDFjBu+//z7Tp0/PVTL/b6LOi9y2QXYy2nv37t3Zlvlve2d1VZuRAHPLyspKc1shw6+//sr06dMZPXo0a9asoUKFCpp9pqamVKhQgejoaGJjYzWD+rITGRkJoBmnkPH7unnz5ktji4qKwtraGkPD7P9sFnR9L5PVREKdO3dm2rRpBAUF0atXLyIiIoiMjGTw4MHo6z/v1M34zo4ePcrRo0ezrT8hIeGVf0Oi8JGELwqdx48fc/XqVaysrDTdzhlX+iEhIS+9Ss4om9FL8KLU1FT09fUxNDTUJKj79+9nmSiePHmS54SVwdzcHH9/f/z9/bl+/TrHjh1j586dHD9+nDFjxrBp06ZXqjfDf0e/Jycna73OqQ3g+ZVuToPKMvatXLmS9957L8dYrKysgP+dJPz3OPnl4+PDxYsX2bZtG/7+/gQGBmrNtOfs7My6des4cOAAvXv3zraetLQ0Dh8+jIGBAR06dADg3XffxczMjLNnz5KcnJztTHypqan07t2b9PR0Dh48qOlZ+K+CqO9l3+3LWFhY0KFDB0JCQnj06JFmVH5Gdz787/udOXOmphdAFH9yD18UOhs3biQtLY0uXbpo/rBnPLJ24cKFTOVv3LjB7NmzOXjwIPD8eW2A8+fPZyq7bNky7O3tOX36tKZ7+OzZs5nKRUVFER0d/UrTn0ZERDB79mxCQ0MBqFGjBj4+PqxduxYbGxvOnz+v6f7Pa3dpRg9DUlKS1vb/XlFaWlpSpUoVwsPDtR5hg+fJplWrVnzwwQfZxpDR3hld+y96/PgxM2fOZPv27QA0aNAAgL/++itT2ay+r1cxdepUqlSpwtmzZzON/O/bty+Ghob8/PPPWZ50ZAgMDOT+/fs4OjpqegmMjY1xdXUlKSmJFStWZPve3377jSdPntCgQYNsk31+68vtd5sb7u7umhOc4OBgatWqpfmeIOfv99mzZwQEBBAYGJjn44rCTRK+KFROnDjBokWLMDMzY9iwYZrt7u7uGBgYMG/ePM3IfXh+1TZ9+nSWL1/O48ePgedXfGZmZqxevVpzawCeJ6oNGzZgbm5O48aN6d69O4aGhixevJhbt25pyiUmJjJt2jQAunfvnufPkJqayvLly/npp5+0HuuLj4/nyZMnVKhQQfPHPaM7979JOTsZgxAzHiuD5/evly1blqmsu7s7T58+zTRt7+rVq0lMTNRcuWfE8OKz1y4uLlhYWPDLL79w/fp1rfd/++23rF69WpOI2rVrR7ly5QgMDNQqGxkZyebNm3P1uV7GwsJC8yjgokWLtL4vW1tbhg8fzp07dxgyZAh3797Veq+iKKxdu5Zvv/2WMmXKZHqkcMyYMVhaWrJw4UI2bdqU6VHMI0eOMHPmTAwNDTUDFnPyqvXl5bt9mbZt21KmTBlWrFhBVFSU1tU9PB+38vbbb7N582bOnTuntW/p0qWsWLFCa84IUTxIl77QiZCQEK1R7fHx8fz999/8+eefmJqa8sMPP2jus8Lzx5zGjx9PQEAAXbt2xdHRkdKlS3PkyBEiIyPp0KED7u7uAJo/6pMnT8bDwwMnJyfMzc0JDg4mOjqahQsXYmxsTLVq1Zg4cSIzZ87Ew8NDc6Jw5MgRbt26hZubW55HmQPY2dnRqVMn9u7di4eHBy1btiQtLU3TxTpz5kxN2YzHD3/++WfCw8MzPYv/X7169WLt2rV88803hIWFUbZsWQ4cOIClpWWmLvphw4Zx6NAhFi9ezJkzZ7C3t+fatWscOnQIOzs7zeC4jBiCgoIwMzPDw8ODOnXqMGPGDD799FNN21SsWJEzZ85w/vx5GjVqpOkhMDc3Z/r06fj7+9O7d286deoEQHBwMOXKlSuwAWyOjo507NiRffv28dVXX2klwlGjRqGnp8fChQvp3Lkzbdu2xcbGhoSEBE6cOMG1a9ewsbFhwYIFmR7fK1++PMuXL8fPz4+pU6eycuVKmjdvjpGREeHh4Zw5cwYjIyNmzZqFvb39S+N81fry8t2+jJGREV26dGHdunUAdO3aVWu/gYEBs2fPxs/PDx8fH5ycnKhWrRoXL17k5MmTvP3224wdOzZPxxSFn8FXX331la6DECXH6dOnOX36NNevX9f895kzZ7hy5YqmO3T27NlZ/mFt0qQJdnZ23Lp1ixMnTnDx4kXKli2Ln58fEydOxMjISFO2Xr16NG3alKioKI4fP86FCxeoVasW06ZNw9HRUVPO3t4ee3t7bt++zYkTJwgPD6dq1aqMHj2aMWPGaHV3r1q1ipSUFIYOHaoV1507dzTPsWdM/tKhQwfMzc2JiIjgxIkTREREULt2baZOnYqbm5vmvTVr1uTGjRucP3+eS5cu0blzZ+7du8eBAwdo06ZNpicNypcvj729PTdu3ODEiRNcv36ddu3aMWfOHAIDA7G2ttbUb2xsTLdu3UhPTyc0NJTjx4/z9OlTevbsyaxZszRJxMrKCkNDQ8LCwvjrr7+oW7cu9evXp06dOrz//vvcv3+fU6dO8ddff2Fqakrfvn2ZNm2a1mCumjVr4uDgoBmvcPv2bTw9PenevTt79+7F2dlZs1hSdhYuXIiVlVWmxXNe1KxZMzZt2sTVq1d55513NF3Tenp6ODg44OzsTEpKCpcuXeKPP/7g5s2bVK1alWHDhvHll19mesIiQ6VKlejZsycWFhbcvHmT0NBQzp49i1qtplOnTsyZM+elYxnyW19evtuQkBAiIiLw9vbWGsT4IisrK7Zs2UKTJk0YMmRIpv1Vq1bF2dmZx48fa/4/VBQFd3d3Zs+enW29oujSU7KaI1MIIYQQxYrcwxdCCCFKAEn4QgghRAkgCV8IIYQoASThCyGEECWAJHwhhBCiBJCEL4QQQpQAMvGO0KmtW7cyefLkLPcZGxtTpkwZ7Ozs8PPzy3L1O12ytbWlbt26milmf/zxRxYuXMiiRYsyrW2vayNGjODAgQMcOHAgx4V7Tp06xYABA15a3+TJkxk0aBC3b9/Gyckp0349PT1MTU2pWrUq7du3Z+jQoVrrEkyaNEmznPF/mZmZUb58eVq2bMmoUaM0EwMVVll9Fn19fUxNTalSpQpt2rThgw8+eKOfIz09nXXr1tGzZ0/NfAuF+fcp3gxJ+KJQcHBwwMHBQWtbXFwc58+fJyQkhEOHDrFq1SreffddHUVYstStWzfHpPDfky9ra2s8PDw0rxVFITExkZMnT7Js2TJ+//13Nm/enGlFPQ8PD60ZFQGio6M5fvw4Gzdu5OjRo2zduvWlq+AVBi9+lrS0NOLj4wkLC2PlypVs27aNZcuW0ahRozcSy7hx4wgKCtLMPikESMIXhYSDg0OmZVEzzJ8/n59++om5c+fmaW118erq1auX7feRFWtr6yzLq9Vqhg4dytGjR1m1ahUjRozQ2u/h4UGLFi0yvS81NZXhw4dz7NgxVq5cWSSmec3us2zcuJHPP/+c4cOHs2fPnhwX3ykoMTExr/0YouiRe/ii0Pvoo48wMjLi3LlzmVYSE4Wbvr6+Zs79I0eO5Pp9xsbGmimMT5w48Vpie1P69OlD3759efjwIatWrdJ1OKIEk4QvCj1jY2PNvO0vrugGz5PB4MGDadasGY0bN8bLy4vg4OAs6zlz5gzDhg2jRYsWNGvWDG9vb0JCQjKV++233/D19aV58+Y0bNiQ1q1bM27cOK0V2vIrNjaW2bNn06VLF818/m5ubixevJi0tDRNuVOnTmFra8vWrVvZvHkz3bp1o1GjRrRt25bZs2dnOgFKT0/nl19+oVOnTtjZ2dGtWzf27dtXYHG/iox7148ePcrT+9566y3g5SsJZrRJfHx8pn1Lly7F1tZWsyb8w4cPmTJlCi4uLjRq1IjWrVszfvx4oqKi8hRbXmXMZb979+5M+4KCgvD29qZJkyY0bdqUgQMHcvLkSa0yt2/fxtbWlh9++IGgoCDc3Nw0izQtX74ctVqtKWtra8vp06eB56vi+fr6atWVkpLCvHnzcHR0pFGjRnTp0oW1a9cW9EcWhZAkfFHoXbx4kUePHlG1alWsrKw02zdt2sTgwYO5fPkyrq6ueHl5ERMTg7+/P4sXL9aqY/v27QwcOJAzZ87Qtm1bPD09uXv3LiNHjmTLli2acrNnz2bixInExcXh4eFB//79qVixIrt27cLX15fk5OR8f56nT5/Sp08fVq9eTe3atRkwYABdu3YlOjqaH374ge+++y7Te3799Ve++uor6tSpg6+vLyYmJixfvpypU6dqlZs0aRLffvsthoaGeHl5UblyZUaPHk1YWFi+435VGck0r4PWjh49CjwfT5ATd3d3UlNTszx52717NxYWFjg5OZGSkoKfnx/bt2+nQYMGDBo0iGbNmrF79268vb01yyu/DtWqVaNixYrcuHGD2NhYzfb58+fzySef8ODBAzw8PPDw8ODq1asMHjxYMxj0RUePHmXMmDFUq1YNb29v4PlvdsqUKZoyo0aN0owl8PPz0xpbATBz5kzWr19P27Zt6d27NzExMXz99desXr36dXx0UZgoQujQli1bFJVKpSxYsEBru1qtVp48eaIcOnRIcXZ2VlQqlbJp0ybN/rt37yoNGzZUunTposTGxmq2JyUlKV5eXkrdunWVy5cvK4qiKI8fP1aaNWumvPfee8q1a9c0ZWNiYpTWrVsrDg4OSmpqqnLv3j2lbt26Sv/+/ZW0tDStePz8/BSVSqUcPXpUs02lUinu7u6a1wsWLFBUKpWyf//+HD/zkiVLFJVKpWzcuFFr+7///qs0bNhQadWqlWbbyZMnFZVKpdSrV0/566+/NNvj4uKUli1bKvXr11fi4+MVRVGUEydOKCqVSvnggw+UlJQUTdlff/1VUalUikqlUm7dupVjbBnHc3d3VxYsWJDlP3///bem/K1btxSVSqX4+PhkWV9ycrLSu3dvRaVSKYGBgZrtEydOVFQqlXLy5Emt8mlpacqDBw+U9evXK/b29kqDBg2Uq1ev5hjz3bt3lbp16ypDhw7V2n716lVFpVIpkyZNUhRFUQ4ePKioVCpl/vz5WuV++eUXRaVSKb/++muOx8lOdp/lvzw9PRWVSqVEREQoiqIoYWFhiq2treLj46MkJiZqysXGxiouLi6Kvb29EhMToyjK/9pZpVIpv/zyi6ZsQkKC0qdPn0zH9/HxUVQqlfLkyRPNtozfZ7t27ZTo6GjN9kuXLim2trZKt27dXunzi6JDBu2JQmHhwoUsXLgwy32WlpZMmjSJXr16abbt2LGD1NRURo8eTdmyZTXbTU1NGT16NIMHD2bbtm1MnDiRw4cP8/TpU8aMGUONGjU0ZcuVK8fkyZO5c+cOiYmJGBsbM2fOHGrXro2BgYFWDM2bN+fw4cMFMhiqdevWWFlZ0aNHD63tVapUoVq1aty4cSPTe5o3b06TJk00ry0tLWnSpAkHDhzg3r171KpVS9Nd/Mknn2BsbKwp279/f3799VeuXbuW6xgjIiKIiIjIcp+1tXWmpW7v3LnDjz/+qHmtKAoxMTEcPXqUO3fu0LRpU7y8vDLVldMjgNWrV+fLL7+kVq1aOcZauXJlmjdvzrFjx3jy5IlmUFxQUBDwvMsf0HR7X758mZSUFExMTADo168frq6uVK5cOcfj5FfGd5Jx62Hz5s0oisKECRMoVaqUplzGks9Tp04lKCiI/v37a/ZZW1trLR9sZmbGJ598wqBBg9i5c2eWgwb/q3fv3pQvX17zun79+lSqVKlAb1mJwkkSvigUXnwsLz4+nuDgYO7du4e7uzvTp0/H1NRUq/zFixeB5/fw//nnH619iYmJAJqElfHvrJ7jd3V11XrdrVs31Go1V65cITIyklu3bnH58mWOHz8OoHWv9FXVr1+f+vXrk5CQQFhYGFFRUdy4cYMLFy4QFRVFenp6pvfY2Nhk2mZpaQn8b1xDREQEBgYGWa4736RJkzwlfA8PDwICAnJd/s6dO1onbPr6+pibm1OjRg28vb0ZMGAARkZGWR7H2toaRVG4f/8+e/bsITU1lQkTJjBgwAD09PRydXx3d3dOnTrF/v37NSeGe/bsoWLFirRs2RKA999/n2rVqhESEsL777/P+++/T9u2bWnfvj1VqlTJ9Wd9VQkJCQCaRxMvXboEwL59+zh06JBW2Xv37gEQHh6utb1JkyYYGmr/2c541C+7E7T/yuq3VKZMGc0xRfElCV8UCv99LM/f35+hQ4eyY8cOLC0t+eKLL7TKP336FCDHx/SePHkCPH+eH9AM/MvJvn37+O677zRX2WZmZjRs2JC6dety/PhxFEXJ0+fKSkpKCt9//z0bNmzQDLqrVKkSzZs3p2zZskRHR2d6z4tX7BkykmFGTHFxcZiYmGRKCMBrfxTMwcGBwMDAPL/vv4+yDR06lH79+hEQEECFChUynZBlp3PnzkybNo2goCB69epFREQEkZGRDB48GH3950OVSpUqxcaNG/n5558JCgpi37597Nu3D319fVxcXJg2bZrW5EAFSVEU/v33X/T09DT31zN+w0uXLs32fRm/4QxZjYOwsLCgVKlSmvpeJqNnQ5Q8kvBFoWRmZsa8efPo3r07a9asQaVSaQYpZewHCAkJoVq1ai+tC/53hfWi1NRU9PX1MTQ0JCwsDH9/fypXrsz3339Po0aNqFatGnp6eixdulRzlZ9fAQEBrF27lk6dOtG/f39sbW01iaZLly5ZJvzcsLKy4ubNmzx79izT1XRGr0dh98477zB37lwGDx7MxIkTqVmz5ksH7cHzpNehQwdCQkJ49OiRZlR+Rnd+hnLlyvHZZ58xZcoULl++zNGjR9m+fTt79+5FX1+fefPmvZbPdeXKFeLi4lCpVJqeGTMzMwwMDAgLC8uy9yMrKSkpmbalpqaSnJysdWtLiKzIKH1RaJUvX56vvvoKeJ4kb9++rdlna2sLwIULFzK978aNG8yePZuDBw8CoFKpADh//nymssuWLcPe3p7Tp0+ze/du1Go1X375JW5ublSvXl1zFZ3RHV4QV/i7du3irbfeYv78+bRo0UKT7JOTk/n3339f+TgNGjRArVZnOSI/4xZIUfDee+/h4+Oj6dp/8THFnLi7u5OWlsbhw4cJDg6mVq1aNGjQQLP/zJkzzJgxg5s3b6Knp0fdunXx8/Pi6KFmAAAgAElEQVRj06ZNmJmZ8eeff76uj8SaNWsA6Nq1q2abra0t6enpmbrtAUJDQ5k7d26mmLL6vYeFhaEoCvb29gUctShuJOGLQs3FxYWOHTuSlJSkSf7w/I+7gYEB8+bN07oiTktLY/r06SxfvlzzmJWzszNmZmasXr2aO3fuaMo+fvyYDRs2YG5uTuPGjTVdnQ8fPtSK4cSJE+zatUtTf36ZmJiQkpKiudUAz5+fnzlzpuaxv//ON5AbHh4e6OnpMXfuXK1n0nfv3l2kEj7A2LFjqVq1KpcvX2b58uW5ek/btm0pU6YMK1asICoqKtPVfXR0NIGBgZnqe/jwISkpKZmm+C0oO3bsYOPGjVSsWFFrAF7G43LffPON1vcVHx/PV199xf/93/9lGs8RFham6b3IKPvdd9+hr6+v9fhdRo/Bq/yORPElXfqi0Js6dSrHjx/n6NGj7Nq1i65du2JjY8P48eMJCAiga9euODo6Urp0aY4cOUJkZCQdOnTQzCNepkwZvvjiCyZPnoyHhwdOTk6Ym5sTHBxMdHQ0CxcuxNjYGFdXV1asWMHXX3/NmTNnqFChApcvX+aPP/6gbNmyxMTEFMiz2t26dWP58uV4enri7OxMWloaf/zxB9evX6dcuXLExsby+PFjKlasmKd67e3t+eCDD1i2bBk9evSgffv23Lt3j5CQEKpXr87NmzfzHfubYmZmxueff85HH33EokWL6NKly0tv3RgZGdGlSxfWrVsHaF9Nw/MTvyZNmrBu3TquXLlC48aNiY+PZ+/evQCMHj1aUzY8PJyQkBDq1auX64Vmtm3bppnwJj09nbi4OEJDQ7l06RJlypRh0aJFWuNIWrZsia+vL4GBgbi5udGuXTuMjY0JCQnh7t27eHt7Zxp1b2lpydixYwkKCqJSpUocOnSIW7duMWLECK1bHxn3+qdMmUKrVq1ytSCSKP7kCl8UepUqVWLMmDHA86uhjIFMgwcPZunSpdStW5d9+/axYcMGDA0NmTRpEgsWLNAavObh4cHy5cupV68ee/fuZePGjbz99tssXboUFxcX4Pn88UuXLqVBgwaEhISwceNGHj58yOjRo9m+fTv6+vocPnw4359nzJgxfPzxx+jr67N27VpCQkKwtrZm2bJlDB8+HOCVjzNhwgRmzJihGaB25coVZsyYQfv27fMd95vm6OhIp06dSE5O5ssvv8zVezJO8po0aZLpBMHY2JglS5bg5+dHbGwsa9asITg4GHt7ewIDA2nVqpWmbHh4OAsXLsxyMp/sbNu2TfN46eLFi9m2bRtqtRo/Pz92796NnZ1dpvdMnTqVOXPmUKVKFXbs2MG2bdsoX74833zzTZaf2cHBgZkzZ3LlyhU2bdqElZUVc+bMwd/fX6vc8OHDsbe359ixY5rbCULoKQVxU1IIIcRrk7EMsZOTEz/99JOuwxFFlFzhCyGEECWAJHwhhBCiBJCEL4QQQpQAcg9fCCGEKAHkCl8IIYQoAYrVc/ihoaEFOk/0iytqiVcn7Zh/0ob5J22Yf9KG+VfQbZiSkpLlwmBZKVYJ38TEJMuVwl5VeHh4gdZXUkk75p+0Yf5JG+aftGH+FXQbZjU1c3akS18IIYQoASThCyGEECWAJHwhhBCiBJCEL4QQQpQAkvCFEEKIEkASvhBCCFECSMIXQgghSgBJ+EIIIUQJIAlfCCGEKAEk4QshhBAlgCR8IYQQogSQhC+EEEKUAJLwhRBCiBJAEr4QQghRAkjCF0IIIUoAnSf8sLAwfH19M20/ePAgnp6eeHl5sXHjRh1EJoQQQhQfhro8+P/93/+xY8cOSpUqpbX92bNnzJo1i82bN1OqVCn69u2Lo6Mj5cuX11GkQgghRNGm0yv86tWr8+OPP2baHhkZSfXq1SldujTGxsY0a9aMM2fO6CBCIYQQouCkpqp1dmydJvxOnTphaJi5kyE+Ph5LS0vNa3Nzc+Lj499kaEIIIUSBefZMTY8eexk06LzOYtBpl352LCwsSEhI0LxOSEjQOgHITkpKCuHh4QUWR3JycoHWV1JJO+aftGH+SRvmn7Thq0lPVzNs2CmOH09j6lQbnbVhoUz4tWrVIioqisePH2NmZsaff/7JkCFDXvo+ExMT6tWrV2BxhIeHF2h9JZW0Y/5JG+aftGH+SRvmnVqtxt19HcePpzF8eCX69atW4HkqtwpVwt+5cyeJiYl4eXkxadIkhgwZgqIoeHp6UqlSJV2HJ4QQQuTJoEHb2L07gd69rfjpJ3ciIiJ0FovOE/7bb7+teeyuW7dumu2Ojo44OjrqKiwhhBAiXz75ZBeBgTE4O5uyfn0f9PT0dBqPzp/DF0IIIYqbX34JZ/78f2nRwpA9e/qhr6/7dKv7CIQQQohiZMuWawwb9gfOzlU5cKAfRkY670wHCkGXvhBCCFFcrFlzjkGDzuDgUIHffuuEubmRrkPSkIQvhBBCFIDduyMYPPg0FSsqbNzYrlAle5AufSGEECLfjh27Qe/eh7GyUjh4sDvVqpXTdUiZSMIXQggh8uH8+bu4uu7FyEghOLgTtrZVdB1SlqRLXwghhHhF//6bgLv7AdLSYOfOdrz7bg1dh5QtSfhCCCHEK4iOTqRjxz3ExDzjwIHutGxZWdch5UgSvhBCCJFHT54k8/77a4mKUhMc7Fbokz1IwhdCCCHyJDk5jbZt1xEZmc6cOTVxdLTWdUi5IoP2hBBCiFxKTU3H0XEd588/Y9Kkqnz6qYuuQ8o1SfhCCCFELqjVCm5umzhxIonhw8syc2ZXXYeUJ5LwhRBCiJdQFIVRo44REhKHr68FP/3US+eL4eSVJHwhhBDiJcaPP8bPP//NhAn2rFrVt8gle5BBe0IIIUSOJkw4wHffReLlVYWAAIcimexBrvCFEEKIbAUEHOfbbyN5912FZcucimyyB0n4QgghRJYWL/6LKVMuUL9+Ovv29cXc3EzXIeWLJHwhhBDiP7ZsucLIkWeoUSOd/ft7U7asla5DyjdJ+EIIIcQLDh36Fx+fo6hUpdi7152qVcvrOqQCIYP2hBBCiP/vyJFbuLnto2ZNKw4f7kb58qa6DqnASMIXQgghgHPnHuDqGkSpUmr27HEpVskepEtfCCGEIDLyCY6O29HTSycwsBnvvFNG1yEVOLnCF0IIUaL9+28CrVptIiUlneXLG9ClS3Ndh/RaSMIXQghRYsXGJtOu3RZiY9OYP98Gb++2ug7ptZGEL4QQokRKSHiGm1swN2+mMn9+XYYPb6frkF4rSfhCCCFKnJSUdDp23Mbp00/YtMmZnj1r6Dqk104G7QkhhChR0tPVuLv/xvHjj/H3L1sikj1IwhdCCFGCKIpCv3572LcvBi8vfWbP7q7rkN4YSfhCCCFKjJEjD7Bx47906aKwcqUPRkZGug7pjZGEL4QQokQICDjHzz9fo3XrNNav74upafGaWOdlJOELIYQo9pYuDWfy5DP07v0Ov/3mjZVV0V8MJ69klL4QQohibdWqSwwffgxX12qsWeOCkVHJvNYtmZ9aCCFEibBz5zWGDDlG9eqpLFpkX2KTPUjCF0IIUUwdPnyHXr1CqFDhGVu3OmFjU1XXIemUJHwhhBDFzrlz0bi67sbSMo11696jadN6ug5J5yThCyGEKFb++ecJnTrtwdAwnWXLGtG+fVNdh1QoyKA9IYQQxUZU1FMcHXehKHqEhHSlefNqug6p0JCEL4QQoli4fz+R1q238ORJOkeP9sDe/i1dh1SoSJe+EEKIIu/RoxTatt3C/fvJTJpkgZ1dOV2HVOhIwhdCCFGkJSQ8w9FxK5GRiYwda8bEib3Q09PTdViFjiR8IYQQRVZKSjqdO28nLCyOYcMMmD69LwYGBroOq1CShC+EEKJISktT06/fAf74IxYfH4W5c/uXqMVw8koG7QkhhChy1GoFP78jbN16g3nz3mPkyHoYGkpKy4m0jhBCiCJFURRGjDjEypX/MGZMbfz9G+k6pCJBuvSFEEIUKZ99dpIlS/6hVatkxo+XGfRySxK+EEKIImPu3HPMmnWBpk2TCAx0p0qVKroOqciQhC+EEKJI+OWXvxk//gz16ycTGNiJGjVsdBxR0SIJXwghRKG3efM1hg07hr29IatWtaV+/bq6DqnIkUF7QgghCrXg4Jv063eQli0rsndvFywsjHUdUpEkCV8IIUSh9ccf9+jRYy+VKqnZsqWDJPt8kC59IYQQhdK5cw/p3HkXFhbPCAioQqVKlroOqUiThC+EEKLQuXz5MU5OOzA0TGXmzPL069dN5sfPJ0n4QgghCpWbN+Pp0GE7qakpfPaZBR9+6CnJvgDIPXwhhBCFxv37iTg77yYxUc3MmRX56KNushhOAZGEL4QQolCIjU3G2Xknd+4ksH+/K++/X1nXIRUr0qUvhBBC5+Ljn9Gx404iIh4zaVJpSfavgSR8IYQQOpWSkk63bns4dy4WH58kRoxor+uQiiVJ+EIIIXQmPV1N3777OXToPp6eCcya5c1bb72l67CKJUn4QgghdEJRFIYNO8q2bTdxdY3n2289qVxZuvJfFxm0J4QQQicmTz7NsmWX8fevzYgRb/POO+/oOqRiTRK+EEKIN27OnFBmzw5j+PB6/PBDa3nO/g2QLn0hhBBv1LJlEUyceJoGDZKYOPEdSfZviCR8IYQQb8zWrdcZOvQItWsn8913DbGxqa7rkEoMSfhCCCHeiAMH7uDtHYK1dSqzZtnQsaOjrkMqUSThCyGEeO3OnHlA9+57KVs2lWnTKtKzZ1fpyn/DZNCeEEKI1yo8/BFdugRRqVIpAgNb0KJFXfT15XrzTZOEL4QQ4rWJinqKo+MO9PUV9u93o2ZNK12HVGLJKZYQQojX4sGDJBwdd/D4cRIffZRKjRqWug6pRJOEL4QQosA9eZKKs/NObt2KZ+jQVMaN85Z79jomCV8IIUSBSkpKw81tN5cuPWLAgES++KI/VlbSla9rkvCFEEIUmLQ0NV5eIRw/Hk2fPglMny6L4RQWMmhPCCFEgVCrFYYMOczOnTdZtKgVXl6VJdkXIpLwhRBC5JuiKIwZc5zVq//hs88aMmJEA12HJP5DuvSFEELk24wZf7FgwSVatoynTx8LXYcjsiAJXwghRL789NMlvvjiLPb2icyd2xI7OztdhySyoNOEr1ar+eKLL/Dy8sLX15eoqCit/cuXL6dnz554enqyf/9+HUUphBAiO+vWXWXUqGPY2iYzZ05DWrV6X9chiWzo9B5+SEgIqampbNiwgdDQUAICAvj5558BiIuLY/Xq1ezbt4+kpCR69OiBi4uLLsMVQgjxgqCgmwwY8Dt16sDMmTa4uDjpOiSRA50m/LNnz9KmTRsAGjduzMWLFzX7SpUqRdWqVUlKSiIpKUkmbBBCiELk2LF7eHrux87uLfbu7Ui5cmbyd7qQ02nCj4+Px8Lif4M7DAwMSEtLw9DweVhVqlTBzc2N9PR0hg0b9tL6UlJSCA8PL7D4kpOTC7S+kkraMf+kDfNP2jD/Mtrw8uUEfH1DsbJS8913NkRH3yI6WtfRFQ26/B3qNOFbWFiQkJCgea1WqzXJ/siRIzx48IADBw4AMGTIEJo2bZrjYBATExPq1atXYPGFh4cXaH0llbRj/kkb5p+0Yf6Fh4djbGyNn99W9PWf8cknBrz3XgNMTEx0HVqRUdC/w7ycPOh00F7Tpk05cuQIAKGhoahUKs2+0qVLY2pqirGxMSYmJlhaWhIXF6erUIUQosSLjk7F0XEHiYnJjB6tZvRoH0n2RYhOr/BdXFw4duwY3t7eKIrCN998w4oVK6hevTpOTk4cP36cPn36oK+vT9OmTWnVqpUuwxVCiBLr0aMUPvggjHv3khg5MpXx4wdhZmam67BEHug04evr6zNt2jStbbVq1dL89+jRoxk9evSbDksIIcQLEhKe4eYWzM2bKXz0kZrPPpPFcIoimVpXCCFEtlJT0+nZcx+nTj1g3ry6jBrVWkbjF1Ey054QQogspaer8fE5wL59dxg7tgLOzuUl2RdhkvCFEEJkoigKI0f+waZNN+jYMY4hQ+rqOiSRT5LwhRBCZDJ16hmWLImgdet4AgKcqFtXEn5RJwlfCCGElh9+OM8334TStGkiAQEtaNKkia5DEgVABu0JIYTQWLXqCmPHnsTF5S3Gj68lj0MXI5LwhRBCALB9+w2GDDmMi4s1O3d2xsTEQNchiQIkXfpCCCE4dOhf+vTZT5UqqcybV1eSfTEkCV8IIUq4s2ej6do1iNKlU5k82QKV6h1dhyReA0n4QghRgl2+/JiOHXdhZJTKp58aMWSIt2YRM1G8SMIXQogS6tateJycdpGamsLHH6czapQshlOcyWmcEEKUQA8fJtOx4x6ePn3G/Pm18PR0kMVwijlJ+EIIUcI8fZpKx467uHEjjn373GjTpoquQxJvgHTpCyFECZKcnEa3bkGEhcUwcGAKrVpV0nVI4g2RhC+EECVEWpoaL68QDh++T8+ecUyc6Iq+vqSBkkK+aSGEKAEURcHP7zA7dtykS5c4pk3rSo0aNXQdlniDJOELIUQxpygK48efYuXKf2jX7ikzZjhSr149XYcl3jAZtCeEEMVcQEAo3313no8+qsuIEeVo2LChrkMSOiAJXwghirGlS8OZMuUM3t41WbiwDfr6eroOSeiIdOkLIUQxtWnTNYYPP0qdOskMHWosyb6Ek4QvhBDF0L59t+nX7wDVqqUydWpF2rVrreuQhI5JwhdCiGLm5Mn79OgRTPnyqUycaEG/fr3k8TshCV8IIYqTixdjcXUNwsIijXHjjBgypK8shiMAGbQnhBDFxvXrcXTsuIdSpQwJCupGrVplZDEcoSEJXwghioF79xJxctpJfHwyx4550KjRW7oOSRQyeU74aWlq9u+/TWhoDLGxKXz7bUsuXIjF0tIIGxvL1xGjEEKIHDx+nELHjru4cyeeDz+Mp3p1uZYTmeXpHv6hQ/9Ss+Y6unbdy2efneH77y8AsHFjJHXqrGfu3LDXEqQQQoisJSam4eq6h7//fkT//nFMmeJN6dKldR2WKIRynfBDQx/i6hpEYmIaU6Y0xtPzf3Mwt2xZicqVzZg48TQ7d0a9lkCFEEJoe/ZMjafnPk6ejKZXrzimTvXE2tpa12GJQirXCf/LL89iamrI2bM9mT69OQ0bltPsc3OrzunTHpQrZ8L3359/LYEKIYT4H7VaYdCgQwQH38bd/SlffOFGzZo1dR2WKMRyfaPn6NF79OlTk3feyfo+fZUqZvTpU5ONG68VWHBCCCEyUxQFf//jrF17lVmzHBg1qjYWFha6DksUcrlO+MnJaZib51zc0FCfpKS0fAclhBAie199dZaFCy8xYEAVJk60R09PpswVL5frLv169cqyf/8d1Goly/3PnqnZu/cWtrZlCiw4IYQQ2hYsuMi0aX/RpEki/foZS7IXuZbrhO/nV5eLF2MZNOgQMTHJWvsePEiif/+D/PNPHIMHqwo8SCGEEPDrr//g73+cunWTmTrVho4dO+o6JFGE5LpLf/jw+hw/fp9ff/2HNWuuYmpqAICNzVpu305ArVbo0cOGkSMbvLZghRCipNq1K4pBg36nRo0UJk+uQI8e7nJ1L/IkT8/hr17dgQ0bnHFxscbc3BADAz3i4p7RunVlli9vx9atHeUHKIQQBezIkbv07h1C7dqmTJhgSb9+vWUxHJFneZ6OqXfvmvTunf2jH4mJaZiZySxPQghREM6de0i3bsHY2Fhy9Kg7ZcsaYWBgoOuwRBGU61PEmjXXsWDBxRzLTJt2FhubtfkOSgghBPzzzxM6dtyNgUEqq1c3o3x5U0n24pVleyl+48ZT4uJStV5HRDzm/PmYLMunpqoJCblDQoI8lieEEPl1+3Y8Tk47SUpKYtSoJOrUkcVwRP5km/BPnrxPv34HNffk9fT0WLIknCVLwrOtTFEUOnZ8u+CjFEKIEiQmJhkXl908eJDAsGEJjBs3gDJl5JFnkT/ZJnxv79qcOxfDgwdJKAqsXn0Fe/u3aNw481mmnh4YGeljbW0uo/SFECIf4uOf0bnzHq5efcygQU8YP74fFSpU0HVYohjIcXTd7NktNP99+PBdBg+2ZfTohq89KCGEKIlSUtLx8NjHuXMxjBtnwdChzrz9tvSaioKR6+H016/3fZ1xCCFEiZaerqZ//wOEhNxh1ar2DBggk5iJgpWn5+dSUtI5evQuDx4kk56uRvn/s+wqyvOpdWNikgkKusWhQ91eR6xCCFEsKYrCsGFH2bLlBr16qenXT1a9EwUvD1f4cXTosItbtxJyLCdzQQghRN5MmnSaZcsu06bNU0aPdsDQUOYyEQUv1+n588//5ObNeLp0qUZAgAPly5vi7GzNrFnN8fWtg6GhHhUrmnLnjs/rjFcIIYqVb78NY86cMN59N4EpUxrQunVrXYckiqlcn0YePPgvzZpVYNeuzgCEhsZw924iEyY0BsDXtw6dOu1h+fLLTJrU+PVEK4QQxciyZRFMmHCKBg2SmDTJhk6dOsn05OK1yfUVfkxMMu3aVdG8trcvx9mz0ZrXTk7WdOr0Nps3XyvYCIUQohjauvU6Q4cexdm5CrNmqfDw6C7JXrxWuU745uZGKBmj9ICaNa2Ij0/j+vU4zTY7u7e4ceNpwUYohBDFTEjIbfr2PUDLlhX47bfOdOvWRRbDEa9drn9h9vbl+P33fzVJv169MiiKwp9/PtSUuXs3kfR0JbsqhBCixDt9+gHdu++lbNlUJkwwx9zcSNchiRIi1wl/8GBbQkNjcHLazfnzMdSvX5batUszYcIpgoNvsXLlZTZsiKRhw3KvM14hhCiywsMf0bnzbkxNUxk1Kh0np/d0HZIoQXI9aG/AABXnz8cyb94F/v77EXZ2bxEQ4ECfPiG4uQU/r8xQj6+/bvbaghVCiKIqKuopTk67SEtL4eOPkxk1ajAWFha6DkuUIHl62HPu3JaMHdsIU9PnyzP27FmD48e7s359JKamBnh51cLeXlZ0EkKIFz14kISLy24eP05k6NB4/P1lMRzx5uV5doeqVc21Xjs4VMTBoaLm9fXrcdSoYZX/yIQQohh48iSVzp33cPt2AoGBLWnR4i0qVqz48jcKUcBeeg9fURQuX37M+fMxpKSkZ1tOrVYICAilUaPNBRqgEEIUVUlJaXTrFsSFC7Fs3doRT097WQxH6EyOV/ibNl1j/PiTmul0TUz0mTixMV980VTredHTpx8wdOhRLlyIfb3RCiFEEfHsmZo+fUL444/7eHo+5t13S+k6JFHCZXuFHxR0Ey+vEG7ejKd6dQuaNSuPWg3Tpv3F1KlngOdX9Z99dppWrbZz/nwM1aqZs2NHpzcWvBBCFEZqtcKQIYfYtesmrq5PmDChA+XLl9d1WKKEyzbh//jjJfT09Fi+vB3Xr/fl9GkPrl/vS5MmbzF//kUeP07B03M/AQFhAIwda8fff/fBza36GwteCCEKG0VRGDPmBIGBV+nQ4SkTJrSgefPmug5LiOwT/l9/PcTZ2ZpBg2w126pUMeP7798jMTENb+8DbN9+g7p1y3DyZA/mzm2JmZms8CSEKNlmzDjHggUXadkynvHj69OmTRtdhyQEkMM9/MePU7G3zzyJTrNmz7ul9u+/g5dXLZYvb0epUpLohRDip58u8cUXfzJwoIrPP69OzZo1ZH58UWhkm6lTU9OxsMg85WPGNJC2tqVZs8YRfX35MQshxLp1Vxk16hguLhX55Ze2GBrK3PiicHnlX2T37jaS7IUQgueDnAcM+J133knF2/upJHtRKL3yr7JUKYOCjEMIIYqkY8fu0bPnPipWfMbo0Yb069db1yEJkSU5DRVCiFd0/nwMbm5BWFg8Y8SINPz8fDA1NdV1WEJkKcfRdr/9diPb9e2z26enp8eyZe0KJjohhCikIiPj6NhxD0ZGaoYOTWLECFkMRxRuOSb80NAYQkNj8rRPEr4Qorj7998EXFx2k5am5vDhHrz9tiGlS5fWdVhC5CjbhP/7713fZBxCCFEkxMYm07Hjbu7efcqePS40aCArhIqiIduE365d1TcZhxBCFHoJCc9wcwvi8uXH9O//iOrV1boOSYhck0F7QgiRC6mp6Xh47OPUqWg8PWMZN86VWrVq6TosIXJNEr4QQrxEeroaX9/f2b//Dt26PWbcOCcaNWqk67CEyBOZE1cIIXKgKAojRx5j48ZreHio8feXxXBE0SQJXwghcvD553+yZEk4kyY15uuvG2NklHnKcSGKAkn4QgiRjR9+OM/MmedwdDRi2rQmkuxFkSb38IUQIgurVl1h7NiT1K+fxODBxujry59LUbTl+Qr/778fsWrVFUJDY3j0KIXTpz3YvfsmMTHJ+PjUkQV1hBBF3vbtNxgy5DC1aqUwerQFXl59MDCQ9UNE0ZanhB8QEMrnn58hPV0B0KzzfOjQv3z//QW2br3Opk0uGBnJmbAQomg6dOhfvLxCqFo1lVGjjBg4sL905YtiIdeZecuWa0yZcpoWLSqyf78bY8faafYNG1YPFxdrdu68yU8/Xcr1wdVqNV988QVeXl74+voSFRWltf/w4cP06dOH3r1789VXX6EoSq7rFkKIvDp7Nhp39728844ZY8caM2RIf1kMRxQbuU743313gVq1rDhwoCtOTtZYWv7vjLd27dLs3t2ZunXLsHLllVwfPCQkhNTUVDZs2MC4ceMICAjQ7IuPj+fbb79l8eLFbNq0CWtrax49epTruoUQIi8iIh7TufMe3nrLlIMHu+Pv/yGWlpa6DkuIApPrhH/+fAzdu9tgYpL1fSwDA326dKlGZGRcrg9+9uxZ2rRpA0Djxo25ePGiZt+5c+dQqVTMnj2bfv36Ub58ecqVK5fruoUQIrdu3ozHxWUXKSnJzJpVCWtrc80tSyGKi1zfwzc01J41aVIAACAASURBVCc+/lmOZR49SsHAIPf/k8THx2stJ2lgYEBaWhqGhoY8evSIU6dO8dtvv2FmZkb//v1p3LgxNWrUyLa+lJQUwsPDc338l0lOTi7Q+koqacf8kzbMv+zaMDY2FR+fMB4+TOKDDx5hbW0kbZ0N+R3mny7bMNcJv3nzCmzffoOAAAfKlDHJtP/+/US2b7/Bu+9WyPXBLSwsSEhI0LxWq9UYGj4PqUyZMjRq1IgKFZ7X9+677xIeHp5jwjcxMaFevXq5Pv7LhIeHF2h9JZW0Y/5JG+ZfVm0YF5eKj89O7txJxtf3EZ984kmdOnV0FGHhJ7/D/CvoNszLyUOuu/QnT27MgwfJtGmzg61br3P/fhIAUVFP2bz5Gm3b7uTRo1TGjbN7SU3/07RpU44cOQJAaGgoKpVKs69BgwZcuXKF2NhY0tLSCAsLo3bt2rmuWwghcpKcnEaPHnsJDY2hd+9YPvnETZK9KNZyfYXv6GjNkiVt+PjjY/TuHQI8n2O6Zs31AOjrw9y5LejcuVquD+7i4sKxY8fw9vZGURS++eYbVqxYQfXq1XFycmLcuHF8+OGHAHTu3FnrhEAIIV5VWpqavn0P8vvvd5k5sybOzo1lMRxR7OXpOfwPP6xLly7VCAz8h7/+esjjxylYWBhhZ1cOH5861K5dOk8H19fXZ9q0aVrbXlxu0s3NDTc3tzzVKYQQOVEUBT+/I/z22w0WLHifjz9uqOuQhHgjcp3w799PpFIlM6ytzZk0qfHrjEkIIV4LRVEYP/4UK1deoUOHBHr3Lq/rkIR4Y3J9D//tt9fQpUsQv/76DwkJOY/WF0KIwiggIJTvvjuPg0MCI0ZUo1KlSroOSYg3JtcJ38nJmgMH7jBw4CEqVQqkf/+D7Nlzk/R09euMTwghCsSGDXeZMuUMdnZJjBpVAQ8PD3nWXpQoue7SDw52JSYmmU2brrFhQyQbNkSyfn0k/4+9+w6L6szfBn4PVZqICGIBERWsiIgiKjaaUmyEKmhsibrGjfG3mmR3jTExPTEbdWNcY4koig0LAgoWLBEjFlBBrAh2IXQYmJnz/uHrJITiUAeY+3NdXpdzzpkz33kGuOc55XmMjbXh72+FadN6wcmJ35aJqPmJiLiDlStvw9pajL/9TR+BgQGcDIdUTq1muTE2boN58/rixAkfZGVNw3ffDUPPnob48cdUjBx5ED16hGP58ouNVSsRUa3FxmYiJOQEBg1qi3XrBiI0NJiT4ZBKqvO0dmZmuvj73wfg3LlJOHNmImxt2+PevQKsWnW5IesjIqqzX399iqlTj8LGpi3++99+cHUdBR0dHWWXRaQUtbot78/u3y/Arl13EBFxF1euZEMQBPTpY4SQEA6OQ0TKd+1aDjw9o6GrW44ZM3JhYMBD+KTaahX4WVmFiIh4eQ7/4sUXEAQBnTrp4t13+yMkpBcGDeItLkSkfHfv5sPNLQqCIMbMmfkICZnO2TZJ5Skc+CNGHEBi4jPIZAL09TUREtITISG94OLSBWpqvNKViJqHJ0+K4eYWhfz8Esye/TsWLgyGmZkZA59UnsKBf+HCM3h4dEVISC9MnmwJHZ06nw0gImoUublijB8fjUePChESko2FC31hYWGh7LKImgWFU/vRoxCYmPBiFyJqnoqLJfD2jsGNG79j/35X2NhIOeEW0Z9UG/jJydkwM9OFqenLkH/8uBiPHxcrtFNbW+OGqY6ISAHl5TL4+R3DuXNPsX37GHh5VT+NNpGqqjbw7ez2YsWKwVi+fLD8saKjUkmlcxumOiKi15DJBLz55kkcOZIJH59cWFsXKLskomap2sCfMcMadnZ/9NSnT7cGR6EkouZEEAQsWnQWO3bchotLPt5+ux/s7e2VXRZRs1Rt4G/ePKbC4y1bxlS5HRGRsqxYkYR1625g+PBCzJtnCU9PT46PT1QNhUfamzXrJA4evF/jNtu2pWP8+CP1rYmI6LV++OEaVq68hKFDyzF/viknwyF6DYWv0t+yJR3du7fFxImW1W5z9GgWTp163BB1ERFVa9u2dPz97+cwebIlNmwYDENDA06GQ/Qa1Qb+d98l49NPK46L//nnl7F6dUqV25eXy1BcLEG/fkYNWyER0Z8cOpSBmTNPYdAgHezYMRY6OpwIh0gR1Qb+3/7WD7t23cGzZ6UAgLy8Mmhrq8PQUKvStiIRoKmphi5d9PDll0Mbr1oiUmkJCY/h738MnTqVIyCgGIAEAAOfSBHVBr62tjoSE6fIH6upbcDixQPkt+kRETWly5dfwMcnBm3bSjBnTgnmzHmTM98R1YLC5/Dv3QtCu3bajVkLEVGVbt3Kg4fHEairl2HmzHy8/fZ0GBtzgC+i2lB4pL28vDLk5ZUptFOOtEdEDSUrqxBublGQSqWYOTMP8+cHwMzMTNllEbU4HGmPiJqt7OxSeHhEIydHjJMnfdCnjx4P4xPVEUfaI6JmqaCgDJ6e0bh163ds2NAf9vYdlF0SUYvGkfaIqNkRi6WYMuUoLl58Dn//HPTurfAYYURUjXr/FkmlMty+nYfCwvKGqIeIVJxUKsO0accRH/8IEyfmYu7coRg2bJiyyyJq8WoV+AkJjxEQEAepVAYAuHo1G927h8PGJgKmpr/g44+TGqVIIlINgiDg7bdPY+/ee/DwyMfs2X0xduxYZZdF1CooHPjHjz+Ei8th7NlzD5mZRQCAuXMTkJVVhLFjO8PS0gArV15CWNitRiuWiFq399+/gJ9/vomgIEPMmcPJcIgaksL34X/11VUYGGjh2DFPWFoaIDX1d1y8+BweHuaIjp6AsjIpBg3ah3XrriMkpFdj1kxErdBXX13BV19dxbx5ffDf/46EIAhQU+O5e6KGovBv02+/PUdgYA8MHmwCADh8+AFEIhH8/a0AAFpa6hg/viuuX/+9cSololZr48Y0LFt2AYMGSbB8uTVEIhHDnqiBKfwbJRZLK4yjHx2dCQBwc+siXyaTCdDQ4C8pESlu3757ePvtBFhbl+HNNwFDQwNll0TUKimczj16tEVi4jMAwNOnxTh79gn69TNC1676AICyMimiojLRo0fbxqmUiFqduLgsBAXFw9xcglmzJHjzzRDo6uoquyyiVknhwJ86tTtOnnyEsWMPYcSIg5BIBMycaQ0AiIp6ACenA7hzJx9z5/ZutGKJqPX49denmDQpFsbGEsycWYQ5c0LRti07DESNReGL9v71r0F48qQY//tfGgQBCAiwwqJF/QEA5849wdWr2XjvvQEMfCJ6rStXXsDTMxqdOuli2TI1eHtP4mQ4RI1M4cBXV1fDjz8646uvHCGTocL5/Llz+2DRov7o2JGH4oioZqmpv8PNLQp6ehqIj/dGt248Z0/UFBQO/FcMDLRQXi5DSkoOioslMDbWRrduBtDU5MV6RFSze/fy4eoahfJyMRYvVoO5uZ6ySyJSGbUK/NxcMf7xj0Rs334LYrFMvlxfXwMBAT3w1VeOaNdOu8GLJKKW7/HjYri5HUFeXgmmT38OT08v3npH1IQUDvz8/DKMGHEQqam/o0sXPQwZYoLOnXXx++9lOHPmCTZuTMOvvz5FYuIU6OrW+sABEbVi2dmlcHOLwsOHBZg27TlCQ8fBzs5O2WURqRSFk3nVqstITf0dy5bZ4eOPB0NLS12+ThAELF9+EatWXcZXX13BihUOjVIsEbU8f0xzm4vAwBcICnKEk5OTsssiUjkKH0/bu/cenJw64vPPh1YIewAQiUT45JMhGDasI3btutvgRRJRy1RSIsHEibFISnqBzZuHY+ZMJ4wbN07ZZRGpJIUDPzOzEE5OHWvcZvjwjsjIKKh3UUTU8pWXy+DvH4dTpx5j69YxCA7uhzFjxnAyHCIlUTjwjYy0cfdufo3b3LmTj7ZttWrchohav1dhf/jwA3h55aF79+fKLolI5Skc+K6uXXDoUAaOHcuqcn109AMcOpQBV9cuVa4nItUglcowY8YJREbex4QJBZg0yQgODryuh0jZFL5o76OPBiMy8j68vWMQHNwTzs5mMDTUwsOHxThz5gn27bsHPT0NLF9u35j1ElEzJpMJePvt0wgPv4Px44vg5dUGwcHB0NLikT8iZVM48Hv1MkR8vDdCQ09g69Z0/PLLLQAvr9AHgJ49DbF16xhYW7drnEqJqFkTBAGLF/+Kn3++CTe3Mnh4iBAaGsrJcIiaiVrdMO/oaIq0NH+cO/cUV668QH5+OQwMNGFnZ4yRI814MQ6RCvvooyT88MM1vPtuf7zzjhkMDQ05GQ5RM1LrEXLU1EQYOdIMI0eaNUY9RNQCffttMj755BJ8fTviu++c+OWfqBmq8aK9R4+K8NZbCejadTt0dH5Gz547sWxZIvLzy5qqPiJq5tavv4H/+7/zGDwYGDjwGgoLC5VdEhFVodoe/sOHRRg6dD+ePCmRn6e/ezcf33yTjEOHMvDrr5MrzJhHRKpn+/ZbWLDgDOzs1ODp+Qh+fv4wMODsd0TNUbU9/FWrLuPx42LMndsbt24Forh4FpKT38Dkyd2QlpaL775Lbso6iaiZOXjwPmbMOIm+fTXg5fUQU6b4oHfv3soui4iqUW3gHzuWBWfnTli/3hk9erRFmzYa6N+/PfbscUOfPkY4fPhBU9ZJRM3I8eMP4e8fj7599TFxYhY8Pd0waNAgZZdFRDWo8ZC+r2/3SstFIhFcXbtg69b0Ri2MiJqnxMRnmDgxFr16tcWJEz4oKnoGCwsLZZdFRK9RbeCLxbJqp7k1MtJCYWF5oxVFRM1TSkoOJkyIRrt2ati61R7Gxm1gbMywJ2oJqj2k/+pCvaqIRCLUsJqIWqHbt/Pg5hYFTU0Z3ngjCw8epCi7JCKqBYXH0ici1ZWVVQhX1yiIxeXw938Ee3sLeHt7K7ssIqqFGgOfg2cQ0aNHRRg3LgrZ2SUICnoOW1tTBAQEQEOj1uN2EZES1fgbu3p1CjZvvllpeW7uy4F3rKzCK60TiYA7d4IaqDwiUqbnz0vg6hqFx4+L8eGHBmjbthTTpk2Dtra2sksjolqqMfBzc8XIzRVXu/7+/YIGL4iImoe8vDKMHx+Ne/cKEBMzASNHdkRJSQknwyFqoaoNfJnsraasg4iakeJiCby9Y5CcnI333muDwYPbQl1dHfr6+soujYjqiBftEVEFZWVS+Poew9mzTzB9ugTt2mWhoIBH84haOgY+EclJJDIEBx9HTEwmpk8XoXv3bAQGBqJTp07KLo2I6omBT0QAAJlMwNy5Cdi79x6CgzVhZfUYvr6+6N698oibRNTy8L4aIoIgCHj33XPYsiUdH3zQH126XMbw4T7o06ePsksjogbCwCdScYIgYNmyRKxZcx2LFw/AqlXDIJUO5X32RK0MD+kTqbiVKy/h66+TMWmSIZycsiCTyRj2RK1QnQP/8eNiXL+eA+DlhT5E1PJ8/fVVrFiRBC8vIwwcmAZtbW2oqbEfQNQa1eo3u6REgvffT4SZ2TZ07bodAwfuBQB8+20yxo07jJs3cxulSCJqeP/973UsXZoIDw9jDB58A3379oa3tzeH1CZqpRQO/MLCcjg7H8RXX12FtrY6rKwM5DPmFRdLcPLkIzg7H+Toe0QtwNat6fjb385i7FhjODpeh5WVJXx9fdm7J2rFFP7t/vTTS7h06QV++GE47t8PwrRpPeXrPv7YAVu3jkFOjhiffHKpUQolooaxe/ddzJp1Cq6uXbB+vT169LBEYGAgz9sTtXIK/4ZHRNzF+PHmWLiwP4DKM+mFhlpj7957OHHiUcNWSEQNJirqAYKD4+Ho2AGRke7Q09NEr16WPIxPpAIU7uE/elQMOzvjGrexsWmHx4+L610UETW848cfwtf3GPr3bwdPz7u4ceMKAE6DTaQqFO7hm5i0QWpqzRflXbuWAxOTNvUuioga1vHjD+HjE4sePfTh5/cIGhpSWFpaKrssImpCCvfwfXy64dChDMTEZFa5fu/eu4iOzoSnp0WDFUdE9Rcf/xDe3jGwtNTD9Ok5AIowbdo0mJiYKLs0ImpCCvfwP/rIHocOZcDbOwaenubIzhYDAFasuIiLF18gOjoTpqY6+Pe/7RutWCKqnRMnHsHbOwY9e7bF7Nn5KCzMRnBwMLp06aLs0oioiSkc+B076uLcuUmYN+80oqIyIfz/e/JWrnx5Vf6oUZ2wYYMzunTRa5xKiahWzpx5Am/vGPTo0RYnTvjg/v1r0NV1gpWVlbJLIyIlqNV9OObm+oiKmoAnT4px6dIL5OaWQV9fA7a2xrC0NKj1i8tkMqxYsQI3b96ElpYWPv30U3Tr1q3SNm+99RZcXFwQFBRU69cgUkXnzz+Fp2c0zM31EBHhhA4d2qBDBwdll0VESlSnG2/NzHQrnKuv69C6cXFxKCsrw65du3DlyhV88cUX+PHHHyts8/333yM/P79O+ydSRRcuPIO7+xGYmurgww91sX//VnTqtABGRkbKLo2IlKhWw2rdupWHZcsS5YfzMzIK4OQUCW3tn9G163Zs3ZpeqxdPSkqCs7MzAMDOzg7Xrl2rsD4mJgYikUi+DRHV7NKlF3B3PwITkzb4/HNj3Lt3CUOGDEG7du2UXRoRKZnCPfzLl1/A2fkgSkqkWLCgL7p1M8DcuQlITHyGXr0M8fvvYsyadQomJm0UvlK/sLAQ+vr68sfq6uqQSCTQ0NBAeno6Dh8+jB9++AHr1q1TaH9isRipqamKvqXXKi0tbdD9qSq2Y/0p0oapqYWYOTMF+vrq+OCDNrhx4xwsLS3RtWtXpKWlNVGlzRd/DuuPbVh/ymxDhQP/008vQSYTEBHhAnNzfWRkFCAu7iGcnDrizJmJyM0tg53dXnz3XYrCga+vr4+ioiL54z9PyxkZGYmnT59ixowZePjwITQ1NdGlSxeMGjWq2v1pa2ujT58+ir6l10pNTW3Q/akqtmP9va4Nr13LwVtvXYChoTa2bx+E48d3w8bGBv7+/hwf///jz2H9sQ3rr6HbsDZfHhQO/DNnniIwsAd8fV9e4XvoUAYAYNq0nhCJRDAy0sbkyZa1Oqxvb2+PEydOwNPTE1euXIG1tbV83dKlS+X/X7NmDTp06FBj2BOpqps3c+HqGgUtLXUcP+4NKysDaGi4w8HBgWFPRHIKB35+fhnMzHTlj6OjMyESieDu3lW+TFNTTX5+XxFubm44e/YsAgMDIQgCPvvsM2zevBkWFhZwcXFReD9Eqio19Xe4uERBEIDw8CEwNRVBTU0NTk5Oyi6NiJoZhQPf0tIA16//DgAoKCjDyZOPYWVlgJ49DeXbHD/+sFa356mpqWHlypUVlvXo0aPSdu+8847C+yRSFenpuRg79jAAICJiGM6f34fMzC4ICQlRcmVE1BwpfLxv/PiuOHz4AWbOPAkPj2iUlkrlU+QmJj6Dj08Mrl7NqTBtLhE1jrt38zFuXBRkMgGRkaNw8eJBaGpqwtvbW9mlEVEzVYuL9obg5s08+Tl6J6eOWLrUDsDLcfSjoh7gjTes8Pe/D2icSokIAPDgQSFcXKJQUiLB4cNjceFCJKRSKWbOnMnb74ioWgoHvp6eJo4cmYDr13MgkwEDBrSXrwsJ6QU/PysMGWLaKEUS0Uu3b+fBxSUKeXlliI/3wv37CSgsLMT06dM5GQ4R1ajWI+3169e+0jJbW+MGKYaIqnfjxu9wdY1CebkMx497w96+A/r29cTQoUPRtWvX1++AiFRatYH/ww/Xqlv1WosW9a/zc4mosvv3SzBr1ssL9OLjPZGfnwaJZBh0dHRgbm6u5OqIqCWoNvDfffccRCJRrW6zAwCRSMTAJ2pAGRkFmDUrBRKJCCdPeuPmzZNISUlBhw4d0Lt3b2WXR0QtRLWBv3nzmCYsg4iqkpVViHHjDqO4WIqTJyfiwYNEpKSkYNy4cQx7IqqVagN/xgzr6lYRURN48qQYLi5ReP68FBs29EN+/nVcuHABw4YNw8iRI5VdHhG1MA027qZEIsPTp8XYvPlmQ+2SSGW9eFEKN7coPHxYhJiYCbCx0UJiYiIGDhwId3d3iEQiZZdIRC2MwlfpS6UyfPDBBezYcQfPnpVAKq3+3P7MmTYNUhyRKsrNFcPD4whu3crHkSPjMXy4GVJTf8fcuXNhaGjIsCeiOlG4h//VV1fxzTfJyM4uRa9ehlBXF8HMTAc2NoZo00YdgiDAxKQNVq/mGN5EdZWbK4ab2xGkpORg3z43WFiU4NSpUxAEAUZGRpwMh4jqTOG/Htu330b79tq4fTsQ16/7YfToThg7tjNu3PBHdvZ0zJnTG8+fl6JvX470RVQX+fllGD8+GlevZmP3blcMGCBCREQE0tLSIJVKlV0eEbVwCgf+vXsFmDq1O7p00QMADBligoSExwCANm00sH69M6ytDbF6dUrjVErUij15UozRow8hKek5IiJcMWyYDnbs2AEDAwOEhIRAQ6PWY2QREVVQq+ODJiZt5P+3tjbEw4fFyM0Vv9yRmggeHl3lM+oRkWKePi3GuHGHcetWHg4c8MDo0YYICwuDpqYmQkNDoaenp+wSiagVUDjwu3XTR3p6nvzxq2lxU1Jy5Ms0NNTw/HlpA5ZH1Lo9e1aCceOikJFRiCNHJsDT0wKPHj2CTCZDSEgIJ8MhogajcOB7eVng4MEMbN58E1KpDIMGGUNHRx3r1l0H8PJio8jI++jalb0RIkXk5Ly89e7evXxERY2Hs7MZAKBfv35YtGgRTE05GRURNRyFA//99+3Qtase5sxJwKZNN6Gnp4m33uqDiIi76NRpG7p3D8e9ewUIDe3VmPUStQp5eWVwdz+CmzdfHsYfMcIEYWFhSEtLAwBoa2sruUIiam0UDnxj4za4fNkXn302BEOHvux5fP75UMyf3xdisQw6OhpYsmQA3n/frtGKJWoNXl6NfwRXr2Zjzx5XjBvXCXv27MHdu3chkUiUXR4RtVK1uvS3bVstLFv2R6Bra6tj3bqRWLeOw3wSKaKgoAwTJkTj4sWXV+N7eVkgMjIS6enp8PLyQv/+nHiKiBpHtT38gwfvIz09tylrIWrVcnJKMX58NBITn2HnThdMnmyJ2NhYJCcnY+zYsXBwcFB2iUTUilUb+FOmHMPOnXcqLX/woFB+/z0RKebVoDoXLz5HeLgLfH2tAAAymQyOjo5wdnZWcoVE1NpVe0hfEKoeK3/z5ptYufISpNK5jVYUUWuSmyvG+PHRuHz5Bfbtc4ePTzeUl5dDU1MTEyZMAACOj09EjY4DcxM1ope33h3BpUsvsGuXK3x8uuHatWtYu3YtcnJyIBKJGPZE1CQY+ESNJCenFK6uUfKJcKZO7Y7bt29j//79aNeuHQwMDJRdIhGpEA7QTdQIsrNfhn1qai4iI90xfrw5srKyEBERARMTEwQFBUFTU1PZZRKRCmEPn6iB5eaK4e5+pELYv3jxAjt27IC+vj5CQkLQpk2b1++IiKgBsYdP1IBeXY2fkpIjD3sAMDAwQI8ePTBu3Djo6+sruUoiUkU1Bv7Jk48BJP1l2SMAwCefXKrySn6RSIR//9u+4SokaiHy818OqpOU9Bx79rjB09MCRUVF0NLSgra2Nnx9fZVdIhGpsNcE/iN5wP/VRx9drHI5A59U0atb75KSXt5nP2mSJUpLSxEWFgZdXV2EhITwanwiUqpqA3/z5jFNWAZRy/VquNxLl15g9243TJ5sifLycuzcuRPPnj1DUFAQw56IlK7awJ8xw7op6yBqkUpKJJg4MRa//fYcu3e7YvJkS8hkMuzduxcZGRmYOnUqevbsqewyiYh40R5RXZWVSeHrewynTj3Gtm1jMWVKdwDA0aNHcfPmTXh6emLAgAFKrpKI6CUGPlEdlJfLEBQUj+joTGzY4Ixp03rJ1w0ZMgRGRkYYMmSIEiskIqqIgU9USxKJDMHB8di37z5Wr3bC3Ll9AAD3799Ht27dYGxsDGNjYyVXSURUEQfeIaoFqVSGGTNOYs+ee/jmm2F4992Xh+yTkpKwdetWXLlyRckVEhFVjYFPpCCpVIa5cxOwY8dtfPHFUCxZYgsAuHHjBg4fPoxevXrB1tZWyVUSEVWNh/SJFCCVyjB7dgK2bk3HihWDsWyZHQDgzp072Lt3L8zNzeHn5wd1dXUlV0pEVDUGPtFrlJfLMHPmSWzffhsrVzrIB5YqLS3Fnj17YGJiguDgYE6GQ0TNGgOfqAZlZVIEBb28QG/VqiH48MNB8nVt2rSBn58fTExMOBkOETV7PIdPVI3ychn8/eOwb999fP+9kzzsc3NzkZqaCgCwsrLivPZE1CKwh09UBYlEhpCQ4zhwIANr1gzHwoX9AQBFRUXYtm0bSkpK0L17d/bsiajFYA+f6C9kMgGzZ59CRMRdfPPNMHnYi8VihIWFIT8/H0FBQQx7ImpRGPhEfyIIAhYsOINffrmFlSsd5LfeSSQShIeH49mzZ/D394e5ubmSKyUiqh0GPtH/JwgCFi06h59+SsX779vhX//64wK969evIyMjA5MnT0avXr1q2AsRUfPEc/hEeBn27733K9auvY4lS2zx2WdDKkxpO3DgQJiamqJTp05KrJKIqO7YwyeVJwgCli5NxPffX8Pf/94fX3/tCJFIBEEQkJCQgCdPngAAw56IWjT28EmlCYKADz64gG++Scbf/tYXq1c7yXv2Z8+exYkTJyAWi2FmZqbkSomI6oeBTyrrVc/+m2+SMW9eH6xZM0Ie9klJSYiPj0f//v3h6uqq5EqJiOqPgU8q6dU5+++/v4aFC/vhhx+Gy8P+xo0biIqKQs+ePTF58uQK5/KJiFoqnsMnlfPqMP6rc/Z/DntBEJCcnIyuXbvC39+fk+EQUavBHj6pnE8/vYwvv7yKefP6VDhnDwAikQh+fn4oLy/nZDhE1Kqwh08q5dtvk7F8+UVMn94L69aNlIf98+fPsX37dhQXF0NdXZ2jY7PgQQAAIABJREFU6BFRq8MePqmMr7++iqVLE+HnZ4Wffx4NNbWXYZ+Xl4ewsDBIpVKIxWLo6uoquVIioobHHj6phG+/TcbSpYkIDOyB7dvHQUPj5Y/+q8lwxGIxQkJCYGRkpORKiYgaBwOfWr1vvrmK//u/8wgIsMK2bWOhqfnyx14sFmP79u3Iy8tDcHAw77UnolaNgU+t2po11/CPfyTC398K27b90bMHgNLSUpSXl8PPzw8WFhZKrJKIqPHxHD61Wps2pWHRonOYNKkbwsLGyXv2MpkMIpEIhoaGmDdvHm+9IyKVwB4+tUo7d97GnDkJcHfvil27XOVhLwgCDh06hAMHDkAQBIY9EakMBj61Or/8ko6QkBNwdu6E/fvdoa39R6jHxcXhypUrMDQ05Ah6RKRSGPjUqmzalIY33zyJESPMcPiwB3R1/zhrdfbsWZw7dw4ODg4YM2aM8ookIlICBj61Gj/9dEN+GD82dgIMDLTk6y5fvoy4uDj0798fnp6e7N0Tkcph4FOrsGXLTcybdwaenhaIjHRHmzYVr0c1NDRE3759ORkOEaksXqVPLd7Onbcxe3YC3Ny6YM8e1wphX1RUBD09PVhZWcHKykqJVRIRKRd7+NSiRUTcQUjICYwcaYbISI8KYf/o0SOsWbMGycnJSqyQiKh5YOBTi3XgwH0EBx/H8OEdK12g9+LFC2zfvh06Ojro3r27EqskImoeGPjUIsXGZsLfPw4ODiaIihpf4QK9vLw8bNu2DSKRCKGhoTAwMFBipUREzQMDn1qcU6ceYcqUo+jb1wjR0RWvxi8vL0dYWJh8Mpz27dsrsVIiouaDF+1Ri7J7913MnHkSlpYGOHrUE0ZG2hXWa2pqwsHBAWZmZpwMh4joT9jDpxbjp59uwN8/Dra2xjh+3BsmJjrydRKJBM+ePQMAODo6olu3bsoqk4ioWWLgU4uwdWs65s07Ay8vC5w86Q0zM135OplMhn379mHTpk0oKipSYpVERM0XA5+avfDw25g165T8PnstrT/GxhcEAYcPH0ZqairGjBkDPT09JVZKRNR8MfCpWdu0KQ3Tph2Hs3Pl++wBID4+HpcvX4azszOGDRumpCqJiJo/Bj41Wz//nIbZs1+OjX/kyIQK99kDQGpqKs6ePYvBgwdj7NixSqqSiKhl4FX61Cz99NMNzJt3BuPHm2P/frdKPXsAsLa2hpeXF+zt7Tk+PhHRa7CHT83OunXX5RfoVRX2d+7cQWFhIdTV1eHg4AA1Nf4YExG9jlL/UspkMixfvhwBAQEIDQ1FRkZGhfVbtmyBn58f/Pz8sHbtWiVVSU1p7dprWLjwLCZO7Ia9eyuH/b179xAeHo6jR48qqUIiopZJqYEfFxeHsrIy7Nq1C0uWLMEXX3whX5eZmYmDBw9i586diIiIwJkzZ5CWlqbEaqmxrV6djHfeOYdJk7ph925XaGurV1j/6NEj7Ny5E+3bt8eECROUVCURUcuk1HP4SUlJcHZ2BgDY2dnh2rVr8nVmZmbYuHEj1NVf/tGXSCTQ1taucj/UsslkApYs+RXff38NU6daIjzcpcKtd0DFyXBCQkKgo6NTzd6IiKgqSg38wsJC6Ovryx+rq6tDIpFAQ0MDmpqaaN++PQRBwFdffYW+ffu+dtYzsViM1NTUBquvtLS0Qfenqmpqx9JSKT78MB0xMS8QEtIZy5Z1xZ076ZW2S0hIgFQqxejRo/Hw4UM8fPiwsctuVvizWH9sw/pjG9afMttQqYGvr69fYWQ0mUwGDY0/ShKLxfjwww+hp6eHjz766LX709bWRp8+fRqsvtTU1Abdn6qqrh0LCsrg5RWD06df4OuvHbFkiW21V9t369YNBQUF6NixY2OX2yzxZ7H+2Ib1xzasv4Zuw9p8eVDqOXx7e3skJCQAAK5cuQJra2v5OkEQsGDBAtjY2GDlypXyQ/vUOjx5UozRow/h3Lmn2LnTBf/3fwMrhb1YLMaJEycglUqhq6ursmFPRNQQlNrDd3Nzw9mzZxEYGAhBEPDZZ59h8+bNsLCwgEwmw4ULF1BWVobTp08DAN577z0MGjRImSVTA0hLy8W4cYeRmytGZKQ7vL0rT3QjkUgQERGBe/fuwcrKipPhEBHVk1IDX01NDStXrqywrEePHvL/p6SkNHVJ1Mh+/fUpfHxioKGhhrNnJ2HQoA6VtpHJZNi/fz/u3r2LSZMmMeyJiBoARyyhJvO//6Vi7NjDMDLSxpkzE6sMe0EQEBUVhRs3bsDd3R12dnZKqJSIqPVh4FOT+P77FLz11mmMGdMJ585NQs+ehlVul5ubi+vXr2PkyJFwcnJq4iqJiFovjqVPjW7z5ix8/fU9+Pp2R3i4CzQ1q/+eaWRkhPnz56Nt27ZNWCERUevHHj41GkEQ8PHHSfj663vw87OqMeyvXLmCs2fPAgAMDQ05GQ4RUQNj4FOjkMkELFp0DitWJGHyZFPs2DGu2rBPS0vDwYMHcffuXchksiaulIhINfCQPjU4iUSGWbNOYdu2W1iyxBazZrWFhkbVYX///n3s2bMHnTt3RkBAAGe+IyJqJPzrSg2qrEwKf/84bNt2CytXOuDrrx2rPTz/+PFjhIeHw8jICMHBwdDS0mriaomIVAd7+NRgSkslmDz5KGJjs/D99074+98H1Lj906dPoauri9DQUOjq6jZRlUREqomBTw2irEyKN96IQ2xsFtavH4m33+5b7baCIEAkEsHOzg79+vWDpqZmE1ZKRKSaeEif6q28XIbAwHhERT3ATz851xj2xcXF2LhxI27fvg0ADHsioibCHj7VS1FROfz84hAdnYkffhiOt96qfhaosrIy7NixA0+fPq0wKyIRETU+/tWlOnvypBheXjG4ciUbGzY4Y+7c6sNeIpFg165dePToEfz9/WFpadl0hRIREQOf6ubhwyKMHXsYWVmF2LfPDZMmWVa7rUwmQ2RkJO7evYuJEyeid+/eTVcoEREBYOBTHaSk5MDTMxp5eWWIi/PC8OFmr32OlpYW3NzcOL0xEZGSMPCpVi5efA539yPQ0VHHqVM+Vc5492disRhqamrw8fHhcLlERErEwCeFnTv3BBMmRKN9+zY4ccIblpYGNW7/66+/4sKFC3B2dmbYExEpGW/LI4UcP/4Q7u5H0LGjLhISfF4b9levXsXRo0fRqVMnaGtrN1GVRERUHQY+vVZsbCa8vGJgaWmAhAQfmJvr17j9zZs3ceDAAXTv3h1Tp07l+PhERM0A/xJTjfbsuYuJE2PRu3c7nDzpAzOzmofAzcrKwp49e9CpUycEBATwfnsiomaCf42pWuHhtxEScgJOTqY4dGg8jIxef2je2NgY/fr1g7u7Ow/lExE1I+zhU5V+/jkNwcHHMXKkGWJjPV8b9nl5eZBIJNDR0cHkyZM5GQ4RUTPDwKdK1qy5hjlzEuDh0RVHjoyHnl7N493n5+dj8+bN2L9/fxNVSEREtcXApwo2bEjFokXnMHmyJQ4e9Hht2JeUlCAsLAwlJSUYMWJEE1VJRES1xcAnua1b0zFv3ml4eppj504XaGmp17j9q8lwcnJyEBgYiM6dOzdRpUREVFsMfAIA/Pe/1zFr1im4uHTB3r1u0NauOewB4NChQ3j48CF8fX3RvXv3JqiSiIjqilfpqzhBEPDvf1/EqlWX4e1tgV27XNGmjWI/Fs7OzrC2tkafPtXPkkdERM0De/gqTCKRYe7cBKxadRlz5vTG/v3u0NWtOewFQcCtW7cgCAJMTU0xYMCAJqqWiIjqg4GvosrKpAgMjMfPP9/EP/85CBs2OEND4/U/DidPnsSOHTuQnp7eBFUSEVFD4SF9FVRQUIapU48hLu4hvvtuGBYvtlXoeefPn0dCQgIGDRoEa2vrRq6SiIgaEgNfxTx6VARv7xhcvZqDTZtGY+ZMG4Wel5ycjNjYWPTu3Rve3t6c/Y6IqIVh4KuQ27fz4O5+BM+eleDQIQ94eloo9LyCggIcPHgQ3bt3h6+vLyfDISJqgRj4KiI5ORsuLlEQBAEnTnhjyBBThZ9rYGCAoKAgdO3alZPhEBG1UOyqqYArV17AxSUK2trq+PXXyQqH/ZMnT3Dz5k0AQI8ePTgZDhFRC8buWiv322/P4OZ2BAYGmjhxwhs9exoq9LycnByEhYVBU1MTPXr0YM+eiKiFYw+/FTt16hFcXaPQvr02zp6dpHDYFxQUYNu2bZDJZAgODmbYExG1Agz8Vuro0SxMmBCNLl30cOqUDyws9BV63qvJcIqKijBt2jSYmJg0cqVERNQUGPit0KFDGfDxiYG1dTucOuUDc3PFwh4Arl69iuzsbAQGBqJLly6NWCURETUlHqttZfbsuYugoHgMGtQBMTET0L59m1o939HREVZWVjA1VfwqfiIiav7Yw29FwsJuISAgHo6Opjh2zEvhsBcEATExMXj+/DlEIhHDnoioFWLgtxIbN6Zh+vQTGD26E2JiPGFoqKXQ8wRBQHR0NBITE3H79u1GrpKIiJSFgd8KrF17DXPnJsDDwxxRUeOhr6+p8HNPnTqF3377DU5OThg2bFgjVklERMrEwG/hvv76Kt555xwmTeqGyEh36OgofllGYmIiTp06BTs7O7i5uXF8fCKiVoyB30IJgoDlyy9i6dJE+PtbYfduN2hrqyv8fJlMhrS0NNjY2MDHx4dhT0TUyvEq/RZIKpVh8eJfsWbNdcyebYOffnKGurri390EQYCamhqCg4MhEok4GQ4RkQrgX/oWprRUgqlTj2HNmutYssQW//vfqFqF/YMHDxAWFobS0lJoampyFD0iIhXBv/YtSH5+GSZNisWpU4+xZs1wLFzYv1bPf/r0KcLDw6GnpwepVNpIVRIRUXPEwG8hnj8vwYQJ0bh6NRthYeMQHNyzVs//82Q4ISEh0NPTa6RKiYioOWLgtwCZmYVwdz+C+/cLEBnpAS8vi1o9v6CgAGFhYZBKpZg5cybatWvXSJUSEVFzxcBv5tLTc+HmdgS5uWLExnpi1KhOtd5HWVkZNDQ0OBkOEZEKY+A3Y0lJz+HpGQNBEHDihA/s7TvU6vkSiQTq6uowNjbGvHnzeDU+EZEKYwI0U7/++hTjxh2Gjo46Tp+eWOuwl0qliIiIwJEjRwCAYU9EpOKYAs1QdPQDuLpGwcREB6dPT4SNTe3OuQuCgAMHDuDWrVswMzNrpCqJiKglYeA3M1u3psPHJxY2NoY4c2ZireayB/6Y+S4lJQXjxo3D4MGDG6lSIiJqSRj4zYQgCPj888t4882TGDOmM06e9IGZmW6t93P69GlcuHABw4YNw8iRIxuhUiIiaol40V4zUF4uw4IFZ7BxYxqCgnpgy5Yx0NJSfFz8P+vUqRMcHBzg7u7O8fGJiEiOga9kxcUS+PoeQ0xMJt5/3w6ffTakTkFdUFAAAwMD9OrVC7169WqESomIqCXjIX0lys8vw/jxRxAbm4n160fi88+H1insb9++jf/85z9IS0trhCqJiKg1YA9fSXJySjFhQjQuXXqB8HAXBAT0qNN+MjMzsWvXLpiYmMDS0rJhiyQiolaDga8Ejx8XY/z4I0hLy8XevW6YONGyTvt5+vQpduzYgbZt2yIkJARt2rRp2EKJiKjVYOA3sbt38+HiEoXnz0sQFTUerq5d67Sf4uJi+WQ4oaGhnAyHiIhqxMBvQrdu5cHVNQqFheU4edIHDg51H9deR0cHw4cPR48ePTgZDhERvRYDv4mcPfsEkybFAgDi4rwwaFDthsp9pbS0FPn5+TA1NYWTk1NDlkhERK0Yr9JvAkePZsHNLQrt27dBYuKUOod9eXk5wsPD8csvv6CsrKyBqyQiotaMgd/IIiPvw8cnBtbW7XD27ET06NG2TvuRSqXYs2cPHjx4gPHjx0NLS6uBKyUiotaMgd+IfvzxBnx9j2HQoA44ccIbJiY6ddqPIAg4ePAg0tPT4eXlhf79+zdwpURE1Nox8BuBIAhYteoSFiw4g/HjuyI+3gtGRtp13l9SUhKSk5MxduxYODg4NGClRESkKnjRXgOTSGR4552zWL8+FSEhPbF58xhoaNTve5WdnR00NTVha2vbQFUSEZGqYQ+/AZWWShAQEIf161OxdOlAbNlSv7C/ceMGiouLoaGhgYEDB3IyHCIiqjMGfgNJT8/FiBEHsW/ffXz/vRO+/NIR6up1b95r165h9+7dOHXqVANWSUREqoqH9BtAbGwm3ngjDlpaajh40AM+Pt3qtb/bt29j//79sLCwgKurawNVSUREqoyBX0+bNqXhrbdOY8CA9jh0yANdu+rXa39ZWVmIiIiAiYkJgoKCoKmp2UCVEhGRKuMh/TqSyQT84x/nMXt2AlxcuiAhwafeYS8IAqKjo2FgYMDJcIiIqEGxh18HMpmAt98+jY0b0zB/fl/85z/DoalZ/+9OIpEIQUFBkEgk0Nev35cHIiKiP2MPv5by88swdepRbNyYhn//2x7r1o2od9gXFhYiPj4eMpkM+vr6nAyHiIgaHHv4tZCSkoNJk2Lx4EEh/vOf4XjnnX71vlWutLQU27dvx4sXLzBgwACYmpo2ULVERER/UGoPXyaTYfny5QgICEBoaCgyMjIqrI+IiMDUqVPh7++PEydOKKnKlyIj78PJKRKlpVIkJPhg0aL+9Q778vJy7Ny5E8+ePUNAQADDnoiIGo1Se/hxcXEoKyvDrl27cOXKFXzxxRf48ccfAQDPnz/Htm3bsHfvXojFYgQHB2PEiBFNOmmMIAi4dy8fW7em4+OPL2HIEBNERrqjc2e9eu9bJpNhz549yMjIwNSpU9GzZ88GqJiIiKhqSg38pKQkODs7A3g5fOy1a9fk65KTkzFo0CBoaWlBS0sLFhYWSEtLa7LhZa9ceYHhw0+jpORlL97eXoQ5c3Lx8OENdO48BOXl5di+fXul59nZ2cHOzg7FxcWIiIiotN7BwQH9+/fHvXv3cP/+fXh6emLAgAGN/n6IiEi1KTXwCwsLK1yNrq6uDolEAg0NDRQWFsLAwEC+Tk9PD4WFhTXuTywWIzU1tUFq09YGkpJGVbnu1Ws4OjrWa/3kyZMrPG7NVOE9Nja2Yf2xDeuPbVh/DdmGYrFY4W2VGvj6+vooKiqSP5bJZNDQ0KhyXVFRUYUvAFWxs7NrnEKJiIhaOKVetGdvb4+EhAQAwJUrV2BtbS1fZ2tri6SkJIjFYhQUFODOnTsV1hMREZHiRIIgCMp6cZlMhhUrViA9PR2CIOCzzz5DQkICLCws4OLigoiICOzatQuCIODtt9+Gh4eHskolIiJq0ZQa+ERERNQ0ONIeERGRCmDgExERqQAGPlrWiH/N1evacMuWLfDz84Ofnx/Wrl2rpCqbt9e14att5syZg/DwcCVU2Py9rg1PnToFf39/+Pn5YcWKFeAZzcpe14abNm3C1KlT4evri2PHjimpypbh6tWrCA0NrbT8+PHj8PX1RUBAQJXjtTQagYTY2Fhh2bJlgiAIwuXLl4V58+bJ1z179kzw9vYWxGKxkJ+fL/8/VVRTGz548ECYMmWKIJFIBJlMJgQEBAipqanKKrXZqqkNX/n2228FPz8/YceOHU1dXotQUxsWFBQIXl5eQnZ2tiAIgrBhwwb5/+kPNbVhXl6eMHr0aEEsFgu5ubnCmDFjlFVms7dhwwbB29tb8PPzq7C8rKxMcHV1FXJzcwWxWCxMnTpVeP78eZPUxB4+FB/xz8DAQD7iH1VUUxuamZlh48aNUFdXh0gkgkQigba2trJKbbZqakMAiImJgUgkkm9DldXUhpcvX4a1tTW+/PJLBAcHo0OHDmjfvr2ySm22ampDHR0ddO7cGSUlJSgpKan3fCKtmYWFBdasWVNp+Z07d2BhYQFDQ0NoaWlh8ODB+O2335qkJs6Wh4Yf8U8V1dSGmpqaaN++PQRBwFdffYW+ffuie/fuSqy2eaqpDdPT03H48GH88MMPWLdunRKrbN5qasPff/8diYmJiIyMhK6uLqZNmwY7Ozv+LP5FTW0IAJ06dYKXlxekUinefvttZZXZ7Hl4eCArK6vScmVmCgMfDT/inyqqqQ2Bl8M/fvjhh9DT08NHH32kjBKbvZraMDIyEk+fPsWMGTPw8OFDaGpqokuXLhg1qurhn1VVTW3Yrl07DBgwACYmJgBezmuRmprKwP+LmtowISEBz549Q3x8PABg9uzZsLe3b7I5TloDZWYKD+mDI/41hJraUBAELFiwADY2Nli5ciXU1dWVVWazVlMbLl26FLt378a2bdswZcoUvPnmmwz7KtTUhv369UN6ejpycnIgkUhw9epVzlJZhZra0NDQEG3atIGWlha0tbVhYGCA/Px8ZZXaIvXo0QMZGRnIzc1FWVkZLl68iEGDBjXJa7OHD8DNzQ1nz55FYGCgfMS/zZs3y0f8Cw0NRXBwMARBwOLFi3n+uQo1taFMJsOFCxdQVlaG06dPAwDee++9Jvshbyle93NIr/e6NlyyZAnmzJkDABg/fjy/vFfhdW147tw5+Pv7Q01NDfb29hgxYoSyS24RDh06hOLiYgQEBOD999/H7NmzIQgCfH190bFjxyapgSPtERERqQAe0iciIlIBDHwiIiIVwMAnIiJSAQx8IiIiFcDAJyIiUgEMfGrW1qxZAxsbm0r/+vXrB0dHR4SGhuLAgQPKLrNBJScn48yZM/LHWVlZsLGxwYIFC5RYVe1s2LABY8aMQf/+/eHs7IySkpIqt2vJn6+NjQ0mTZpU5+cXFBQgLCyswrLQ0FDY2Njw3nZqFLwPn1oEFxcX9OnTR/5YIpEgJycH0dHRWLp0Ke7evYvFixcrscKGcfLkScyfPx/Lli3DyJEjAQBt27bFwoULYWVlpeTqFHP69Gl8++23MDU1xfTp06GtrQ0dHZ0an6Mqn++feXh4wMTEBCEhIfJlU6ZMwdChQznWBzUKBj61CK6urpg6dWql5bNnz8aUKVPwv//9D/7+/ujSpYsSqms4OTk5kMlkFZa1bdsW77zzjpIqqr0bN24AABYtWgQ/Pz+FnqMqn++fZWdny4f5faWqNiBqKDykTy2apaUlXFxcIJVKKxwGJ+UpKysDABgZGdV7X/x8iRoOA59avFfDUubm5gIA9u3bBxsbG0RHR2P27NkYMGAAxo4di8zMTADAs2fPsHz5cowePRr9+/fH6NGjsXz5cjx79qzCfl+dX7558yY+/fRTDBs2DIMHD8abb76JpKSkSnWUlZVh/fr18PT0RP/+/eHo6Ij58+cjJSWlwnbV1bd06VJ88MEHAIDPP/8cNjY2yMrKqvYcfm3fx507d/Ddd9/Jz617eXkhPDxc4XZOTk7GggUL4OjoiAEDBsDT0xPr16+XBzzw8rz22rVrAQB/+9vfYGNjg3379in8GlX56+cLvJzQZceOHZg8eTJsbW0xePBgzJw5E2fPnq3w3Fdtt3r1akRHR8PLywu2trbw8PDApk2bKhxNqelaiVdtGBcXV2OtOTk5+PLLLzFhwgQMHDgQAwcOhJeXF9avXw+JRAIASExMhI2NDQAgLS0NNjY28mlUqzqHX9v3umbNGsTHx+ONN96Ara0tnJyc8K9//Qs5OTmvbWtq3Rj41OI9ePAAACqNR/3pp58iJycHoaGhGDBgAMzNzfHgwQNMmTIFu3btgpWVFUJCQmBlZYVdu3Zh6tSp8i8Ff/bBBx/gwIED8PT0hKurKy5fvowZM2ZU6HGKxWK8+eabWL16NdTV1REUFIThw4fjzJkzCAoKqjIo/lqfu7u7fMz8kSNHYuHChWjbtm2177m27+Mf//gHIiIiMGrUKPj7++Pp06dYsWIFIiIiXtvGcXFxCAoKwunTpzF8+HAEBgZCXV0dq1evxsyZM+Whv3DhQgwdOhQA4OnpiYULF1Y4N18Xf/18ZTIZFi9ejI8//hiFhYXw9fWFq6srUlJSMHv2bGzfvr3SPk6fPo3FixfD3NwcgYGBAIAvv/wSH374Yb1q+7OCggL4+/vjl19+Qc+ePTF9+nR4e3vj+fPnWL16Nb799lsAQJcuXbBw4UIAQIcOHSq02V/V5b2eOHECCxcuhImJCUJDQ9GxY0fs3r27RV30SY1EIGrGfvjhB8Ha2lrYu3dvleuTk5OFvn37Cra2tkJ2drYgCIKwd+9ewdraWhg1apRQXFxcYfvp06cL1tbWQkRERIXl27dvF6ytrYXp06dXem17e3shIyNDvvzKlStC3759BRcXF0EqlQqCIAhr164VrK2thffff18oLy+Xb3vt2jXB1tZWcHBwEAoKCl5b36t1mzdvli/LzMwUrK2thfnz59frfYwdO1beRoIgCElJSYK1tbXg5+dXZdu+UlBQIAwZMkSwt7cXrl27Jl9eXl4uLFmyRLC2thbWrl1b6fWOHTtW437/vG1tPt/9+/cL1tbWwqxZs4SioiL5tg8ePBBGjBgh9O3bV3jw4IEgCH+0nbW1tbBx40b5tkVFRYK/v79gbW0tnD9/vsK2f27nmt6TtbW1MHHiRPnjn376qcrP5NGjR0L//v2FESNGVFj+1+cLgiCEhIQI1tbWQl5eXr3e65EjR+TblpWVCV5eXoK1tbVw+/btKtuZVAN7+NQixMXFYc2aNfJ/q1evxqJFizBt2jRIJBIsXboU7du3r/CcUaNGVbg6/PHjxzh//jwcHBwqXUwWHByMAQMG4Pz588jKyqqwLiQkBBYWFvLHAwcOhKenJzIzM3H58mUAwP79+6Gjo4N//vOf8rnDgZdTsgYHByM/Px9Hjx6tsT5F1fV9+Pr6Vmgje3t7tG3bFg8fPqzx9eLi4pCXl4fp06ejX79+8uUaGhr48MMP0aZNG+zdu7fW7+Ovr6Ho57t//34AwIoVK6Crqyvfh7m5OebPnw+JRILIyMgK++/SpQtmzJghf6yrq4t3330XwMtZzBrCyJEj8fHHH2Py5Mkpvt7gAAAGiUlEQVQVlnfq1Anm5uZ1OqRel/dqbm6OCRMmyB9ramrCyckJAF77WVPrxqv0qUWIj49HfHy8/LGmpibatWuHESNGYNq0afJb2P6sa9euFR6npqYCABwcHKp8DXt7e6SkpCAtLa3Cc6s63Gpra4uDBw/Kz8FmZmbC3t4e+vr6lbYdPHgwNm3ahLS0tBrrU1Rd30f37t0rbauvr4/CwsIaX+9V3UOGDKm0rn379ujevTtSU1NRUFAAAwMDhd/Hn9Xm801LS0PHjh1hbm5eaT+DBw+uUPMrgwYNqvBFDAAGDBhQ5bZ11bdvX/Tt2xdFRUW4evUqMjIycP/+faSkpCAjIwNSqbTW+6zLe7W0tKy07avP5c/XW5DqYeBTi/D555/X+palv97L/CrYqgslU1NTAEBpaWmF5VXNVd2hQwf5PouKiuq037rea13X96GlpVVpW5FIBOE1M2S/er2qvsy8er3U1FSUlJTUOfBr8/kWFhbK27+qWgDFPkN9fX3o6OigoKCgltVWTSwW47vvvsOuXbvkAw117NgRQ4YMgZGREZ4/f17rfdblvVb3ORMx8Ell6OnpAQCePn1a5fpXV0a3a9euwvK//kEFIA8JIyOjOu+3rpT1en+9+r+xXk+Reqp773l5eVXWIhaLK21bVlaG0tJS+e2Dr0Lxr+MgAKh2pMA/++KLL7Bjxw54eHhg2rRpsLGxkdcxYcKEOgV+Xd4rUXV4Dp9UxqurxS9dulTl+t9++w0ikQg9e/assPyvt9UBkJ+7t7W1hb6+Prp27Yr79+9XeZ72t99+A4BK+62KIj2xur6Punr1elXdilhYWIjU1FR069atyp5lY+jduzcKCgqQnp5ead3FixcBVG7rqj7Dq1evQhAEDBw4EMDL0whA1eFe1V0Pf3X48GEYGxvjP//5DxwdHeVBXFpaikePHgHAa4+m/FVd3itRdRj4pDI6d+4MR0dHXLt2DTt27Kiwbvfu3bh06RIcHR1hZmZWYd3PP/9coXd76dIlHDp0CP369UPv3r0BvBwStbS0FJ999pn8fmsAuH79OsLCwtC2bVuMGzfutTW+Os9cXl7e4O+jrlxdXWFgYIAdO3bg+vXr8uUSiQSrVq1CaWlpvcaUr61Xh/5XrVqF4uJi+fLMzEysW7cOmpqa8PLyqvCcq1ev4siRI/LHhYWF+Pbbb6GmpoYpU6YAAIyNjWFoaIjk5GRkZ2fLt71x4wZOnjz52rq0tbUhFosr3EMvlUrlbQRU/Fw1NTVr/Jzr+l6JqsND+qRSVq5ciWnTpuHjjz/GsWPHYGNjg/T0dJw9exampqb45JNPKj0nNzcXU6ZMgZubGwoLCxEbG4s2bdpU2Hbu3Lk4c+YMDh06hJs3b2LYsGHIzs5GXFwcBEHA6tWrqz0H/mevzjWHh4cjLy8PoaGhDfY+6kpfXx+fffYZFi9ejMDAQLi5ucHY2Bjnz59Heno6HBwcMHfu3AZ7vdeZNGkSjh8/jtjYWEycOBGjRo1CcXEx4uPjUVhYiH/9618V7qoAXl7v8N577yE6OhodO3bEyZMnkZmZiQULFsi/tKmrq8PX1xebNm2Cn58fPDw8kJOTg5iYGNja2sp71NXx8fHBpk2b5PfKSyQSnDlzBvfu3UP79u2Rk5OD3Nxc+bl3U1NT3L17Fx999BFGjx5d5RfCurxXouqwh08qxdLSEnv37oW/vz9u376NsLAw3L9/H6GhoYiMjKzyj+c///lPjBs3DlFRUTh9+jTGjh2LXbt2VbhFTVtbG1u2bMGiRYtQXl6O8PBwnD9/Xr6tq6urQvUNGTIE06ZNQ15eHrZv3447d+402PuoD3d3d+zYsQMjRozA6dOn5YP1LF26FFu2bGmyw/n4f+3bMWqEQBiG4S+2ghdwD2G1F/AYVnYLsojWq52NlaC73bLFgo16A0E8hI2190iKQGAJIQkpNjDvU8/ATPUy/Izexx5VVel0Osm2bfV9r2ma5HmebrebgiD4tGe/36soCq3rqq7r5DiOyrJUHMcP69I0VRRFkqT7/a5lWZRlmcIw/PZcSZLoeDzKsiy1batxHOW6rq7Xqw6HgyRpnueP9Xmea7fbaRiGhx8Kf70r8JWX198OlQBD1HWtpml0Pp9/HGz8L9u2yfd9+b6vy+Xy7OMAT8ULHwAAAxB8AAAMQPABADAAM3wAAAzACx8AAAMQfAAADEDwAQAwAMEHAMAABB8AAAMQfAAADPAGG7Y/xjroNxsAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x110076b00>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "l_t[0].plot_recall_fpr_n(figsize=(8,8))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11016dbe0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x1100767f0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "l_t[0].plot_precision_recall_n(figsize=(8,8))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Our model make mistakes, why? \n",
-    "\n",
-    "We can explore which features of our space, or at which values, are some features generating errors in the model. This function `error_analysis` runs a Decision Tree for each model based in one (or several) thresholds passed to the Postmodeling configuration file. The function will return the tree plot (saved as pdf under the `/error_analysis`). \n",
-    "\n",
-    "The function will make *four* comparisons:\n",
-    " - False Postives (1) vs. Rest of entities classified (0)\n",
-    " - False Negatives (1) vs. Rest of entities classified (0)\n",
-    " - False Positives (1) vs. True Negatives (0)\n",
-    " - False Negatives (1) vs. True Positives (0)\n",
-    " \n",
-    "This set of analysis will serve to understand why some classification errors arise, and give some hints on how our model is performing. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "rank_abs 10\n",
-      "error_analysis_FPRvsAll_44_rank_abs@10.gv\n",
-      "error_analysis_FNRvsAll_44_rank_abs@10.gv\n",
-      "error_analysis_FNRvsTP_44_rank_abs@10.gv\n",
-      "error_analysis_FPRvsTN_44_rank_abs@10.gv\n",
-      "rank_abs 20\n",
-      "error_analysis_FPRvsAll_44_rank_abs@20.gv\n",
-      "error_analysis_FNRvsAll_44_rank_abs@20.gv\n",
-      "error_analysis_FNRvsTP_44_rank_abs@20.gv\n",
-      "error_analysis_FPRvsTN_44_rank_abs@20.gv\n",
-      "rank_abs 50\n",
-      "error_analysis_FPRvsAll_44_rank_abs@50.gv\n",
-      "error_analysis_FNRvsAll_44_rank_abs@50.gv\n",
-      "error_analysis_FNRvsTP_44_rank_abs@50.gv\n",
-      "error_analysis_FPRvsTN_44_rank_abs@50.gv\n",
-      "rank_pct 10\n",
-      "error_analysis_FPRvsAll_44_rank_pct@10.gv\n",
-      "error_analysis_FNRvsAll_44_rank_pct@10.gv\n",
-      "error_analysis_FNRvsTP_44_rank_pct@10.gv\n",
-      "error_analysis_FPRvsTN_44_rank_pct@10.gv\n",
-      "rank_pct 20\n",
-      "error_analysis_FPRvsAll_44_rank_pct@20.gv\n",
-      "error_analysis_FNRvsAll_44_rank_pct@20.gv\n",
-      "error_analysis_FNRvsTP_44_rank_pct@20.gv\n",
-      "error_analysis_FPRvsTN_44_rank_pct@20.gv\n",
-      "rank_pct 50\n",
-      "error_analysis_FPRvsAll_44_rank_pct@50.gv\n",
-      "error_analysis_FNRvsAll_44_rank_pct@50.gv\n",
-      "error_analysis_FNRvsTP_44_rank_pct@50.gv\n",
-      "error_analysis_FPRvsTN_44_rank_pct@50.gv\n"
-     ]
-    }
-   ],
-   "source": [
-    "l_t[0].error_analysis(params.thresholds_iterator,\n",
-    "                      depth=params.max_depth_error_tree,\n",
-    "                      path=params.project_path,\n",
-    "                      view_plots=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Since each `model_id` has different temporal configurations, we can explore the prediction window for each of the models and identify the models that have the same temporal configuration. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Let's talk about model consistency\n",
-    "\n",
-    "We can compare `model_groups_id` overall by looking at how consistent they are in flagging the same individuals. We checked the temporal consistency inside each `model_group_id` in the precision/recall time line in the first part of this Notebook, but we can also compare `model_group_id`'s by the composition of both the predicted individuals in one especific time window, and its features. Here we present two ways of doing these using a Jaccard Similarity Index, and a Ranked Correlation.  \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11884e320>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "audited_models_class.plot_jaccard(param_type='rank_pct',\n",
-    "                                  param=10,\n",
-    "                                  temporal_comparison=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11ef2e6d8>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "audited_models_class.plot_ranked_corrlelation_preds(param_type='rank_abs',\n",
-    "                                                    param=50,\n",
-    "                                                    temporal_comparison=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Although, we can compare the selection of each model for each predicted `as_of_date` using the overall"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x120de5e10>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "audited_models_class.plot_jaccard(param_type='rank_pct', \n",
-    "                                  param=50,\n",
-    "                                  figsize=params.figsize)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Consistency also is desireable in the most relevant features for each of the models. We can explore this by exploring the correlation/overlap of ranked features across models"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11ef54cc0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "audited_models_class.plot_jaccard_features(top_n_features=5,\n",
-    "                                          temporal_comparison=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x118c93978>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "audited_models_class.plot_ranked_correlation_features(figsize=params.figsize,\n",
-    "                                                      top_n_features=params.n_features_plots)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Model _\"advanced\"_ comparison\n",
-    "\n",
-    "More than the mere overlap of ranked observations, we can think our comparisons from the distributions of our top observations. Not only we can visualize the distribution overlap, but also the ranking of the predicted entities in their percentiles"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/ivan/.pyenv/versions/triage-3.6.2/lib/python3.6/site-packages/matplotlib/cbook/deprecation.py:106: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
-      "  warnings.warn(message, mplDeprecation, stacklevel=1)\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x118e672b0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x118662b70>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11b79d390>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11dcf5940>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x1188884e0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11f01ef28>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "audited_models_class.plot_preds_comparison(param_type='rank_abs',\n",
-    "                                           model_subset=[125],\n",
-    "                                           param=20)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "triage_env",
-   "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.6.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}
diff --git a/src/triage/component/postmodeling/contrast/utils/__init__.py b/src/triage/component/postmodeling/contrast/utils/__init__.py
deleted file mode 100644
index e69de29bb..000000000
diff --git a/src/triage/component/postmodeling/contrast/utils/aux_funcs.py b/src/triage/component/postmodeling/contrast/utils/aux_funcs.py
deleted file mode 100644
index ab2eb4b39..000000000
--- a/src/triage/component/postmodeling/contrast/utils/aux_funcs.py
+++ /dev/null
@@ -1,59 +0,0 @@
-'''
-A4uxiliary functions and helpers:
-
-This set of functions are helper functions to format data 
-(i.e., prediction matrices, etc.) for plotting. This functions
-are called in both Model class and ModelGroup class in 
-evaluation.py.
-'''
-
-from sqlalchemy import create_engine
-from sqlalchemy.sql import text
-from collections import namedtuple
-import yaml
-
-
-ModelEvaluator = namedtuple('ModelEvaluator', 
-                           ('model_group_id', 'model_id'))
-
-
-def create_pgconn(credentials_yaml):
-    '''
-    Create SQL connection object using a psycopg2 cursor and abiding to new
-    dssg/dsapp db user configuration. 
-
-    Arguments:
-        - credentials_yaml: .yaml file with db credentials
-    '''
-    with open(credentials_yaml) as f:
-        configs = yaml.load(f)
-    try:
-        conn = create_engine("postgresql://{user}:{password}@{host}:{port}/{dbname}".format(**configs))
-    except:
-        print("Error connecting to db.")
-
-    return conn 
-
-
-def get_models_ids(audited_model_group_ids, conn):
-    '''
-    This helper functions will retrieve the model_id's from a set
-    of model_group_ids and will instantiate each model into the 
-    ModelEvaluator class. 
-
-    Aguments:
-        - audited_model_group_ids: List of model_group_ids 
-          (ideally from Audition's output)
-        - conn: sql engine
-
-    This function will return a list of ModelEvaluator objects
-    '''
-
-    query = conn.execute(text("""
-    SELECT model_group_id,
-           model_id
-    FROM model_metadata.models
-    WHERE model_group_id = ANY(:ids);
-    """), ids=audited_model_group_ids)
-
-    return [ModelEvaluator._make(row) for row in query]
diff --git a/src/triage/component/postmodeling/error_analysis.py b/src/triage/component/postmodeling/error_analysis.py
new file mode 100644
index 000000000..3a4c24d0e
--- /dev/null
+++ b/src/triage/component/postmodeling/error_analysis.py
@@ -0,0 +1,169 @@
+# coding: utf-8
+
+def _error_labeler(self,
+                  path,
+                  param=None,
+                  param_type=None):
+    '''
+    Explore the underlying causes of errors using decision trees to explain the
+    residuals base on the same feature space used in the model. This
+    exploration will get the most relevant features that determine y - y_hat
+    distance and may help to understand the outomes of some models.
+
+    This function will label the errors and return two elements relevant to
+    model these. First, a feature matrix (X) with all the features used by
+    the model. Second, an iterator with different labeled errors: FPR, FRR,
+    and the general error.
+
+    Arguments:
+        - param_type: (str) type of parameter to define a threshold. Possible
+          values come from triage evaluations: rank_abs, or rank_pct
+        - param: (int) value
+        - path: path for the ProjectStorage class object
+    '''
+
+    test_matrix = self.preds_matrix(path)
+
+    if param_type == 'rank_abs':
+        # Calculate residuals/errors
+        test_matrix_thresh = test_matrix.sort_values(['rank_abs'], ascending=True)
+        test_matrix_thresh['above_thresh'] = \
+                np.where(test_matrix_thresh['rank_abs'] <= param, 1, 0)
+        test_matrix_thresh['error'] = test_matrix_thresh['label_value'] - \
+                test_matrix_thresh['above_thresh']
+    elif param_type == 'rank_pct':
+        # Calculate residuals/errors
+        test_matrix_thresh = test_matrix.sort_values(['rank_pct'], ascending=True)
+        test_matrix_thresh['above_thresh'] = \
+                np.where(test_matrix_thresh['rank_pct'] <= param, 1, 0)
+        test_matrix_thresh['error'] = test_matrix_thresh['label_value'] - \
+                test_matrix_thresh['above_thresh']
+    else:
+        raise AttributeError('''Error! You have to define a parameter type to
+                             set up a threshold
+                             ''')
+
+    # Define labels using the errors
+    dict_errors = {'FP': (test_matrix_thresh['label_value'] == 0) &
+                          (test_matrix_thresh['above_thresh'] == 1),
+                   'FN': (test_matrix_thresh['label_value'] == 1) &
+                          (test_matrix_thresh['above_thresh'] == 0),
+                   'TP':  (test_matrix_thresh['label_value'] == 1) &
+                          (test_matrix_thresh['above_thresh'] == 1),
+                   'TN':  (test_matrix_thresh['label_value'] == 0) &
+                          (test_matrix_thresh['above_thresh'] == 0)
+                  }
+    test_matrix_thresh['class_error'] = np.select(condlist=dict_errors.values(),
+                                                 choicelist=dict_errors.keys(),
+                                                 default=None)
+
+    # Split data frame to explore FPR/FNR against TP and TN
+    test_matrix_thresh_0 = \
+    test_matrix_thresh[test_matrix_thresh['label_value'] == 0]
+    test_matrix_thresh_1 = \
+    test_matrix_thresh[test_matrix_thresh['label_value'] == 1]
+    test_matrix_predicted_1 = \
+    test_matrix_thresh[test_matrix_thresh['above_thresh'] == 1]
+
+    dict_error_class = {'FPvsAll': (test_matrix_thresh['class_error'] == 'FP'),
+                        'FNvsAll': (test_matrix_thresh['class_error'] == 'FN'),
+                        'FNvsTP': (test_matrix_thresh_1['class_error'] == 'FN'),
+                        'FPvsTN': (test_matrix_thresh_0['class_error'] == 'FP'),
+                        'FPvsTP': (test_matrix_predicted_1['class_error'] == 'FP')}
+
+    # Create label iterator
+    Y = [(np.where(condition, 1, -1), label) for label, condition in \
+         dict_error_class.items()]
+
+    # Define feature space to model: get the list of feature names
+    storage = ProjectStorage(path)
+    matrix_storage = MatrixStorageEngine(storage).get_store(self.pred_matrix_uuid)
+    feature_columns = matrix_storage.columns()
+
+    # Build error feature matrix
+    matrices = [test_matrix_thresh,
+                test_matrix_thresh,
+                test_matrix_thresh_1,
+                test_matrix_thresh_0,
+                test_matrix_predicted_1]
+    X = [matrix[feature_columns] for matrix in matrices]
+
+    return zip(Y, X)
+
+def _error_modeler(self,
+                  depth=None,
+                  view_plots=False,
+                  **kwargs):
+   '''
+   Model labeled errors (residuals) by the error_labeler (FPR, FNR, and
+   general residual) using a RandomForestClassifier. This function will
+   yield a plot tree for each of the label numpy arrays return by the
+   error_labeler (Y).
+   Arguments:
+       - depth: max number of tree partitions. This is passed directly to
+         the classifier.
+       - view_plot: the plot is saved to disk by default, but the
+         graphviz.Source also allow to load the object and see it in the
+         default OS image renderer
+       - **kwargs: more arguments passed to the labeler: param indicating
+         the threshold value, param_type indicating the type of threshold,
+         and the path to the ProjectStorage.
+   '''
+
+   # Get matrices from the labeler
+   zip_data = self._error_labeler(param_type = kwargs['param_type'],
+                              param = kwargs['param'],
+                              path=kwargs['path'])
+
+   # Model tree and output tree plot
+   for error_label, matrix in zip_data:
+
+       dot_path = 'error_analysis_' + \
+                  str(error_label[1]) + '_' + \
+                  str(self.model_id) + '_' + \
+                  str(kwargs['param_type']) + '@'+ \
+                  str(kwargs['param']) +  '.gv'
+
+       clf = tree.DecisionTreeClassifier(max_depth=depth)
+       clf_fit = clf.fit(matrix, error_label[0])
+       tree_viz = tree.export_graphviz(clf_fit,
+                                       out_file=None,
+                                       feature_names=matrix.columns.values,
+                                       filled=True,
+                                       rounded=True,
+                                       special_characters=True)
+       graph = graphviz.Source(tree_viz)
+       graph.render(filename=dot_path,
+                    directory='error_analysis',
+                    view=view_plots)
+
+       print(dot_path)
+
+def error_analysis(self, threshold, **kwargs):
+    '''
+    Error analysis function for ThresholdIterator objects. This function
+    have the same functionality as the _error.modeler method, but its
+    implemented for iterators, which can be a case use of this analysis.
+    If no iterator object is passed, the function will take the needed
+    arguments to run the _error_modeler.
+    Arguments:
+        - threshold: a threshold and threshold parameter combination passed
+        to the PostmodelingParamters. If multiple parameters are passed,
+        the function will iterate through them.
+        -**kwags: other arguments passed to _error_modeler
+    '''
+
+    error_modeler = partial(self._error_modeler,
+                           depth = kwargs['depth'],
+                           path = kwargs['path'],
+                           view_plots = kwargs['view_plots'])
+
+    if isinstance(threshold, dict):
+       for threshold_type, threshold_list in threshold.items():
+           for threshold in threshold_list:
+               print(threshold_type, threshold)
+               error_modeler(param_type = threshold_type,
+                             param = threshold)
+    else:
+       error_modeler(param_type=kwargs['param_type'],
+                     param=kwargs['param'])
diff --git a/src/triage/component/postmodeling/jaccard.py b/src/triage/component/postmodeling/jaccard.py
new file mode 100644
index 000000000..53c6bbd7b
--- /dev/null
+++ b/src/triage/component/postmodeling/jaccard.py
@@ -0,0 +1,422 @@
+# coding: utf-8
+
+def plot_jaccard_preds(self,
+                       param_type=None,
+                       param=None,
+                       model_subset=None,
+                       temporal_comparison=False,
+                       figsize=(24, 10),
+                       fontsize=12):
+
+    if model_subset is None:
+        model_subset = self.model_id
+
+    preds = self.predictions
+    preds_filter = preds[preds['model_id'].isin(self.model_id)]
+
+    if temporal_comparison == True:
+        try:
+            fig = plt.figure(figsize=figsize)
+            for key, values in \
+            self.same_time_models[['train_end_time', 'model_id_array']].iterrows():
+                preds_filter_group = \
+                preds_filter[preds_filter['model_id'].isin(values[1])]
+                # Filter predictions dataframe by individual dates
+                if param_type == 'rank_abs':
+                    df_preds_date = preds_filter_group.copy()
+                    df_preds_date['above_tresh'] = \
+                            np.where(df_preds_date['rank_abs'] <= param, 1, 0)
+                    df_sim_piv = df_preds_date.pivot(index='entity_id',
+                                                     columns='model_id',
+                                                     values='above_tresh')
+                elif param_type == 'rank_pct':
+                    df_preds_date = preds_filter_group.copy()
+                    df_preds_date['above_tresh'] = np.where(df_preds_date['rank_pct'] <= param, 1, 0)
+                    df_preds_date['new_entity_id'] = df_preds_date['entity_id'].astype(str) + ":" + df_preds_date['as_of_date'].astype(str)
+                    df_sim_piv = df_preds_date.pivot(index='new_entity_id',
+                                                     columns='model_id',
+                                                     values='above_tresh')
+                else:
+                    raise AttributeError('''Error! You have to define a parameter type to
+                                         set up a threshold
+                                         ''')
+                        # Calculate Jaccard Similarity for the selected models
+                res = pdist(df_sim_piv.T, 'jaccard')
+                df_jac = pd.DataFrame(1-squareform(res),
+                                  index=preds_filter_group.model_id.unique(),
+                                  columns=preds_filter_group.model_id.unique())
+                mask = np.zeros_like(df_jac)
+                mask[np.triu_indices_from(mask, k=1)] = True
+
+                # Plot matrix heatmap
+                ax = fig.add_subplot(np.ceil(self.same_time_models.shape[0]/4), 4, key+1)
+                ax.set_xlabel('Model Id', fontsize=fontsize)
+                ax.set_ylabel('Model Id', fontsize=fontsize)
+                plt.title(f'''(as_of_date:{values[0]})''', fontsize=fontsize)
+                sns.heatmap(df_jac,
+                            mask=mask,
+                            cmap='Greens',
+                            vmin=0,
+                            vmax=1,
+                            annot=True,
+                            linewidth=0.1)
+        except ValueError:
+            print(f'''
+                  Temporal comparison can be only made for more than one
+                  model group.
+                 ''')
+
+    else:
+            # Call predicitons
+            if param_type == 'rank_abs':
+                df_preds_date = preds_filter.copy()
+                df_preds_date['above_tresh'] = \
+                        np.where(df_preds_date['rank_abs'] <= param, 1, 0)
+                df_sim_piv = df_preds_date.pivot(index='entity_id',
+                                                 columns='model_id',
+                                                 values='above_tresh')
+            elif param_type == 'rank_pct':
+                df_preds_date = preds_filter.copy()
+                df_preds_date['above_tresh'] = \
+                        np.where(df_preds_date['rank_pct'] <= param, 1, 0)
+                df_preds_date['new_entity_id'] = df_preds_date['entity_id'].astype(str) + ":" + df_preds_date['as_of_date'].astype(str)
+                df_sim_piv = df_preds_date.pivot(index='new_entity_id',
+                                                 columns='model_id',
+                                                 values='above_tresh')
+            else:
+                raise AttributeError('''Error! You have to define a parameter type to
+                                     set up a threshold
+                                     ''')
+
+            # Calculate Jaccard Similarity for the selected models
+            res = pdist(df_sim_piv[model_subset].T, 'jaccard')
+            df_jac = pd.DataFrame(1-squareform(res),
+                                  index=model_subset,
+                                  columns=model_subset)
+            mask = np.zeros_like(df_jac)
+            mask[np.triu_indices_from(mask, k=1)] = True
+
+            # Plot matrix heatmap
+            fig, ax = plt.subplots(figsize=figsize)
+            ax.set_xlabel('Model Id', fontsize=fontsize)
+            ax.set_ylabel('Model Id', fontsize=fontsize)
+            plt.title('Jaccard Similarity Matrix Plot', fontsize=fontsize)
+            sns.heatmap(df_jac,
+                        mask=mask,
+                        cmap='Greens',
+                        vmin=0,
+                        vmax=1,
+                        annot=True,
+                        linewidth=0.1)
+
+
+def plot_jaccard_features(self,
+                          top_n_features=10,
+                          model_subset=None,
+                          temporal_comparison=False,
+                          figsize=(30, 10),
+                          fontsize=12):
+
+    if model_subset is None:
+        model_subset = self.model_id
+
+    f_importances = self.feature_importances
+    f_importances_filter = \
+    f_importances[f_importances['model_id'].isin(model_subset)]
+
+    if temporal_comparison == True:
+        try:
+            fig = plt.figure(figsize=figsize)
+            for key, values in \
+            self.same_time_models[['train_end_time', 'model_id_array']].iterrows():
+                f_imp_filter_group = \
+                f_importances_filter[f_importances_filter['model_id'].isin(values[1])]
+
+                if top_n_features is not None:
+                    f_imp_date = f_imp_filter_group.copy()
+                    f_imp_date_filter = \
+                            f_imp_filter_group.sort_values('rank_abs')
+                    f_imp_date_filter_top = \
+                            f_imp_date_filter[f_imp_date_filter['rank_abs']
+                                             <= top_n_features]
+
+                    df_sim_piv = f_imp_date_filter_top.pivot(index='feature',
+                                                             columns='model_id',
+                                                             values='rank_abs')
+                else:
+                    raise AttributeError('''Error! You have to define a top_n features to
+                                         set up a threshold
+                                         ''')
+
+                # Calculate Jaccard Similarity for the selected models
+                res = pdist(df_sim_piv.T, 'jaccard')
+                df_jac = pd.DataFrame(1-squareform(res),
+                                  index=values[1],
+                                  columns=values[1])
+                mask = np.zeros_like(df_jac)
+                mask[np.triu_indices_from(mask, k=1)] = True
+
+                # Plot matrix heatmap
+                ax = fig.add_subplot(np.ceil(self.same_time_models.shape[0]/4), 4, key+1)
+                ax.set_xlabel('Model Id', fontsize=fontsize)
+                ax.set_ylabel('Model Id', fontsize=fontsize)
+                plt.title(f'''(as_of_date:{values[0]})''', fontsize=fontsize)
+                sns.heatmap(df_jac,
+                            mask=mask,
+                            cmap='Greens',
+                            vmin=0,
+                            vmax=1,
+                            annot=True,
+                            linewidth=0.1)
+        except ValueError:
+            print(f'''
+                  Temporal comparison can be only made for more than one
+                  model group.
+                 ''')
+
+    else:
+            # Call predicitons
+            if top_n_features is not None:
+                f_importances_filter_all = f_importances_filter.copy()
+                f_importance_filter_all_rank = \
+                        f_importances_filter_all.sort_values('rank_abs')
+                f_importance_filter_all_rank_top = \
+                        f_importance_filter_all_rank[f_importance_filter_all_rank['rank_abs']
+                                                    <= top_n_features]
+
+                df_sim_piv = \
+                f_importance_filter_all_rank_top.pivot(index='feature',
+                                                       columns='model_id',
+                                                       values='rank_abs')
+            else:
+                raise AttributeError('''Error! You have to define a parameter type to
+                                     set up a threshold
+                                     ''')
+
+            # Calculate Jaccard Similarity for the selected models
+            res = pdist(df_sim_piv[model_subset].T, 'jaccard')
+            df_jac = pd.DataFrame(1-squareform(res),
+                                  index=model_subset,
+                                  columns=model_subset)
+            mask = np.zeros_like(df_jac)
+            mask[np.triu_indices_from(mask, k=1)] = True
+
+            # Plot matrix heatmap
+            fig, ax = plt.subplots(figsize=figsize)
+            ax.set_xlabel('Model Id', fontsize=fontsize)
+            ax.set_ylabel('Model Id', fontsize=fontsize)
+            plt.title('Jaccard Similarity Matrix Plot', fontsize=fontsize)
+            sns.heatmap(df_jac,
+                        mask=mask,
+                        cmap='Greens',
+                        vmin=0,
+                        vmax=1,
+                        annot=True,
+                        linewidth=0.1)
+
+
+def _plot_preds_compare_score_dist(self,
+                                   m0,
+                                   m1,
+                                   df_preds_date,
+                                   colors=['blue', 'orange'],
+                                   bins=np.arange(0,1.01,0.01)):
+
+    '''
+    Plotting function for comparing prediction distributions across models.
+    This function takes two model_ids with predictions in the same
+    prediction window and shows the relative distribution of
+    the first model top-k in the second model score distribution.
+
+    This function is meant to be used as a helper function of
+    plot_preds_comparisons.
+
+    Arguments:
+        - m0, m1: (int) model_id
+        - df_preds_date: (dataframe) predictions dataframe
+        - colors: (str) color strings. Defaults are blue and orange
+        - bins: (np array) number of bins to pass to the seaborn histogram
+        plotting function
+
+    Returns:
+        matplotlib plot object
+    '''
+
+    df_preds_m0 = df_preds_date[df_preds_date['model_id']==m0]
+    df_preds_m1 = df_preds_date[df_preds_date['model_id']==m1]
+
+    sns.distplot(df_preds_m0[df_preds_m0['above_tresh']==0]['score'],
+                 kde=False,
+                 bins=bins,
+                 color='grey',
+                 label="model " + str(m0) + " predicted label = 0")
+    sns.distplot(df_preds_m0[df_preds_m0['above_tresh']==1]['score'],
+                 kde=False,
+                 bins=bins,
+                 color=colors[1],
+                 label="model " + str(m0) + " predicted label = 1")
+
+    df_alt_model_scores = \
+            pd.merge(df_preds_m0, df_preds_m1[df_preds_m1.above_tresh==1][['entity_id', 'as_of_date']])
+
+    sns.distplot(df_alt_model_scores['score'],
+                 kde=False,
+                 bins=bins,
+                 color=colors[0],
+                 label="model " + str(m1) + " predicted label = 1")
+
+    plt.xlabel("Scores from model " + str(m0))
+    plt.legend()
+
+def _plot_preds_compare_rank(self,
+                             m0,
+                             m1,
+                             df_preds_date,
+                             colors=['black'],
+                             show_tp_fp=False,
+                             bins = np.arange(0,110,10)):
+    '''
+    Plot predictions rank comparison for two selected models.
+
+    This function will rank the predictions from one model into the decile
+    distribution of the second one. This function is meant to be used as a
+    part of the plot_preds_comparison function.
+
+    Arguments:
+        - m0, m1: (int) model_ids to compare, only two.
+        - df_preds_date: (dataframe) predictions dataframe
+        - colors: (str) color string. Default is black
+        - show_tp_tn: (bool) Plot true positive and true negatives in the
+                       rank distribution plot. Default is False
+        - bins: (np array) Number of bins to pass to the seaborn
+        histogram plot function.
+    '''
+
+    df_preds_m0 = df_preds_date[df_preds_date['model_id']==m0]
+    df_preds_m1 = df_preds_date[df_preds_date['model_id']==m1]
+    df_alt_model_rank = \
+            pd.merge(df_preds_m0, df_preds_m1[df_preds_m1.above_tresh==1][['entity_id', 'as_of_date']])
+
+    if show_tp_fp:
+        sns.distplot(df_alt_model_rank[df_alt_model_rank['label_value']==0]['rank_pct'],
+                     kde=False,
+                     bins=bins,
+                     hist=True,
+                     color=colors[0],
+                     label="false positives")
+        sns.distplot(df_alt_model_rank[df_alt_model_rank['label_value']==1]['rank_pct'],
+                     kde=False,
+                     bins=bins,
+                     hist=True,
+                     color=colors[1],
+                     label="true positives")
+        plt.legend()
+    else:
+        sns.distplot(df_alt_model_rank['rank_pct'],
+                     kde=False,
+                     bins=bins,
+                     hist=True,
+                     color=colors[0])
+    plt.xlabel("Percentile Rank in model " + str(m0))
+    plt.title("model "+str(m1)+" predicted label = 1")
+    plt.xticks(bins)
+
+def plot_preds_comparison(self,
+                          param_type=None,
+                          param=None,
+                          model_subset=None,
+                          figsize=(28, 16),
+                          fontsize=12):
+    '''
+    Plot predictor distribution comparison (distribution and rank)
+
+    This function compares the predictions of all models, or a subset passed to
+    model_subset. To compare predictions, the function will show the
+    relative position of the score distribution of the top-k of one of the
+    models into another model.
+
+    Also, to compare how "off" can predictions be, the function will plot
+    the rank position of the predictions of one model in to another. The
+    plot will show the decile position of one model into the other.
+
+    Arguments:
+        - param_type: (str) parameter type (i.e. 'rank_abs', 'rank_pct')
+        - param: (int) parameter threshold
+        - model_subset: (list) list of model_ids to compare. Default is
+        none, and the function will take all the models in self.model_id
+        - figsize, fontsize: aesthetics for plots.
+    '''
+
+    if model_subset is None:
+        model_subset = self.model_id
+
+    preds = self.predictions
+    preds_filter = preds[preds['model_id'].isin(self.model_id)]
+
+    fig = plt.figure(figsize=figsize)
+    try:
+        for key, values in \
+            self.same_time_models[['train_end_time', 'model_id_array']].iterrows():
+            preds_filter_group = \
+                                 preds_filter[preds_filter['model_id'].isin(values[1])]
+            # Filter predictions dataframe by individual dates
+            df_preds_date = preds_filter_group.copy()
+            if param_type == 'rank_abs':
+                df_preds_date['above_tresh'] = \
+                    np.where(df_preds_date['rank_abs'] <= param, 1, 0)
+            elif param_type == 'rank_pct':
+                df_preds_date['above_tresh'] = \
+                    np.where(df_preds_date['rank_pct'] <= param, 1, 0)
+
+            else:
+                raise AttributeError('''Error! You have to define a parameter type to
+                set up a threshold
+                ''')
+
+            sns.set_style('whitegrid')
+            sns.set_context("poster", font_scale=1.25, rc={"lines.linewidth": 2.25,"lines.markersize":12})
+            plt.clf()
+            fig = plt.figure(figsize=figsize)
+            for pair in itertools.combinations(values['model_id_array'], 2):
+                m0 = pair[0]
+                m1 = pair[1]
+                colors = {m0: 'blue', m1: 'orange'}
+                ax1 = plt.subplot(231)
+                self._plot_preds_compare_score_dist(pair[0], pair[1],
+                                                   df_preds_date,
+                                                   colors=[colors[m0], colors[m1]])
+                ax1 = plt.subplot(234)
+                self._plot_preds_compare_score_dist(pair[1],
+                                                   pair[0],
+                                                   df_preds_date,
+                                                   colors=[colors[m1], colors[m0]])
+                ax1 = plt.subplot(232)
+                self._plot_preds_compare_rank(pair[0],
+                                             pair[1],
+                                             df_preds_date,
+                                             colors=[colors[m0]])
+                ax1 = plt.subplot(235)
+                self._plot_preds_compare_rank(pair[1],
+                                             pair[0],
+                                             df_preds_date,
+                                             colors=[colors[m1]])
+                ax1 = plt.subplot(233)
+                self._plot_preds_compare_rank(pair[0],
+                                             pair[1],
+                                             df_preds_date,
+                                             show_tp_fp=True,
+                                             colors=['lightblue', 'darkblue'])
+                ax1 = plt.subplot(236)
+                self._plot_preds_compare_rank(pair[1],
+                                             pair[0],
+                                             df_preds_date,
+                                             show_tp_fp=True,
+                                             colors=['khaki', 'darkorange'])
+            plt.tight_layout()
+            fig.suptitle(values['train_end_time'])
+            plt.show()
+    except ValueError:
+        print(f'''
+        Temporal comparison can be only made for more than one
+        model group.
+        ''')
diff --git a/src/triage/component/postmodeling/plots.py b/src/triage/component/postmodeling/plots.py
new file mode 100644
index 000000000..ee09d15a1
--- /dev/null
+++ b/src/triage/component/postmodeling/plots.py
@@ -0,0 +1,394 @@
+# coding: utf-8
+
+def plot_ROC(self,
+             figsize=(16, 12),
+             fontsize=20):
+    '''
+    Plot an ROC curve for this model and label it with AUC
+    using the sklearn.metrics methods.
+    Arguments:
+        - figsize (tuple): figure size to pass to matplotlib
+        - fontsize (int): fontsize for title. Default is 20.
+    '''
+
+    fpr, tpr, thresholds, auc = self.compute_AUC()
+    auc = "%.2f" % auc
+
+    title = 'ROC Curve, AUC = ' + str(auc)
+    fig, ax = plt.subplots(figsize=figsize)
+    ax.plot(fpr, tpr, "#000099", label='ROC curve')
+    ax.plot([0, 1], [0, 1], 'k--', label='Baseline')
+    plt.xlim([0.0, 1.0])
+    plt.ylim([0.0, 1.05])
+    plt.xlabel('False Positive Rate', fontsize=fontsize)
+    plt.ylabel('True Positive Rate', fontsize=fontsize)
+    plt.legend(loc='lower right')
+    plt.title(title, fontsize=fontsize)
+    plt.show()
+
+def plot_recall_fpr_n(self,
+                      figsize=(16, 12),
+                      fontsize=20):
+    '''
+    Plot recall and the false positive rate against depth into the list
+    (esentially just a deconstructed ROC curve) along with optimal bounds.
+    Arguments:
+        - figsize (tuple): define a plot size to pass to matplotlib
+        - fontsize (int): define a custom font size to labels and axes
+    '''
+
+
+    _labels = self.predictions.filter(items=['label_value', 'score'])
+
+    # since tpr and recall are different names for the same metric, we can just
+    # grab fpr and tpr from the sklearn function for ROC
+    fpr, recall, thresholds, auc = self.compute_AUC()
+
+    # turn the thresholds into percent of the list traversed from top to bottom
+    pct_above_per_thresh = []
+    num_scored = float(len(_labels.score))
+    for value in thresholds:
+        num_above_thresh = len(_labels.loc[_labels.score >= value, 'score'])
+        pct_above_thresh = num_above_thresh / num_scored
+        pct_above_per_thresh.append(pct_above_thresh)
+    pct_above_per_thresh = np.array(pct_above_per_thresh)
+
+    # plot the false positive rate, along with a dashed line showing the optimal bounds
+    # given the proportion of positive labels
+    plt.clf()
+    fig, ax1 = plt.subplots(figsize=figsize)
+    ax1.plot([_labels.label_value.mean(), 1], [0, 1], '--', color='gray')
+    ax1.plot([0, _labels.label_value.mean()], [0, 0], '--', color='gray')
+    ax1.plot(pct_above_per_thresh, fpr, "#000099")
+    plt.title('Deconstructed ROC Curve\nRecall and FPR vs. Depth',fontsize=fontsize)
+    ax1.set_xlabel('Proportion of Population', fontsize=fontsize)
+    ax1.set_ylabel('False Positive Rate', color="#000099", fontsize=fontsize)
+    plt.ylim([0.0, 1.05])
+
+
+def plot_precision_recall_n(self,
+                            figsize=(16, 12),
+                            fontsize=20):
+    """
+    Plot recall and precision curves against depth into the list.
+    """
+
+
+    _labels = self.predictions.filter(items=['label_value', 'score'])
+
+    y_score = _labels.score
+    precision_curve, recall_curve, pr_thresholds = \
+        metrics.precision_recall_curve(_labels.label_value, y_score)
+
+    precision_curve = precision_curve[:-1]
+    recall_curve = recall_curve[:-1]
+
+    # a little bit of a hack, but ensure we start with a cut-off of 0
+    # to extend lines to full [0,1] range of the graph
+    pr_thresholds = np.insert(pr_thresholds, 0, 0)
+    precision_curve = np.insert(precision_curve, 0, precision_curve[0])
+    recall_curve = np.insert(recall_curve, 0, recall_curve[0])
+
+    pct_above_per_thresh = []
+    number_scored = len(y_score)
+    for value in pr_thresholds:
+        num_above_thresh = len(y_score[y_score >= value])
+        pct_above_thresh = num_above_thresh / float(number_scored)
+        pct_above_per_thresh.append(pct_above_thresh)
+    pct_above_per_thresh = np.array(pct_above_per_thresh)
+
+    plt.clf()
+    fig, ax1 = plt.subplots(figsize=figsize)
+    ax1.plot(pct_above_per_thresh, precision_curve, "#000099")
+    ax1.set_xlabel('Proportion of population', fontsize=fontsize)
+    ax1.set_ylabel('Precision', color="#000099", fontsize=fontsize)
+    plt.ylim([0.0, 1.05])
+    ax2 = ax1.twinx()
+    ax2.plot(pct_above_per_thresh, recall_curve, "#CC0000")
+    ax2.set_ylabel('Recall', color="#CC0000", fontsize=fontsize)
+    plt.xlim([0.0, 1.0])
+    plt.ylim([0.0, 1.05])
+    plt.title("Precision-recall at x-proportion", fontsize=fontsize)
+    plt.show()
+
+
+def plot_prec_across_time(self,
+                          param_type=None,
+                          param=None,
+                          metric=None,
+                          baseline=False,
+                          baseline_query=None,
+                          df=False,
+                          figsize=(12, 16),
+                          fontsize=20):
+
+    '''
+    Plot precision across time for all model_group_ids, and baseline,
+    if available.
+
+    This function plots the performance of each model_group_id following an
+    user defined performance metric. First, this function check if the
+    performance metrics are available to both the models, and the baseline.
+    Second, filter the data of interest, and lastly, plot the results as
+    timelines (model_id date).
+
+    Arguments:
+        - param_type (string): A parameter string with a threshold
+        definition: rank_pct, or rank_abs. These are usually defined in the
+        postmodeling configuration file.
+        - param (int): A threshold value compatible with the param_type.
+        This value is also defined in the postmodeling configuration file.
+        - metric (string): A string defnining the type of metric use to
+        evaluate the model, this can be 'precision@', or 'recall@'.
+        - baseline (bool): should we include a baseline for comparison?
+        - baseline_query (str): a SQL query that returns the evaluation data from
+        the baseline models. This value can also be defined in the
+        configuration file.
+        - df (bool): If True, no plot is rendered, but a pandas DataFrame
+        is returned with the data.
+        - figsize (tuple): tuple with figure size parameters
+        - fontsize (int): Fontsize for titles
+    '''
+
+    # Load metrics and prepare data for analysis
+    model_metrics = self.metrics
+    model_metrics[['param', 'param_type']] = \
+            model_metrics['parameter'].str.split('_', 1, expand=True)
+    model_metrics['param'] =  model_metrics['param'].astype(str).astype(float)
+    model_metrics['param_type'] = model_metrics['param_type'].apply(lambda x: 'rank_'+x)
+
+    # Filter model_group_id metrics and create pivot table by each
+    # model_group_id.
+    model_metrics_filter = model_metrics[(model_metrics['metric'] == metric) &
+                                  (model_metrics['param'] == param) &
+                                  (model_metrics['param_type'] == param_type)].\
+            filter(['model_group_id', 'model_id', 'as_of_date_year',
+                    'value'])
+
+    if baseline == True:
+
+        baseline_metrics = pd.read_sql(baseline_query, con=self.engine)
+        baseline_metrics[['param', 'param_type']] = \
+                baseline_metrics['parameter'].str.split('_', 1, expand=True)
+        baseline_metrics['param'] = baseline_metrics['param'].astype(str).astype(float)
+        baseline_metrics['param_type'] = baseline_metrics['param_type'].\
+                apply(lambda x: 'rank_'+x)
+
+        # Filter baseline metrics and create pivot table to join with
+        # selected models metrics
+        baseline_metrics_filter =  baseline_metrics.\
+                filter(['model_group_id', 'model_id', 'as_of_date_year', 'value'])
+
+        baseline_metrics_filter['model_group_id'] = \
+                baseline_metrics_filter.model_group_id.\
+                apply(lambda x: 'baseline_' + str(x))
+
+        # Join tables by index(as_of_date_year)
+        model_metrics_filter = \
+        model_metrics_filter.append(baseline_metrics_filter, sort=True)
+
+    model_metrics_filter['as_of_date_year'] = \
+            model_metrics_filter.as_of_date_year.astype('int')
+    model_metrics_filter = model_metrics_filter.sort_values('as_of_date_year')
+
+    if df == True:
+        return model_metrics_filter
+
+    else:
+        try:
+            sns.set_style('whitegrid')
+            fig, ax = plt.subplots(figsize=figsize)
+            for model_group, df in model_metrics_filter.groupby(['model_group_id']):
+                ax = ax = df.plot(ax=ax, kind='line',
+                                  x='as_of_date_year',
+                                  y='value',
+                                  marker='d',
+                                  label=model_group)
+            plt.title(str(metric).capitalize() +\
+                      ' for selected model_groups in time.',
+                      fontsize=fontsize)
+            ax.tick_params(labelsize=16)
+            ax.set_xlabel('Year of prediction (as_of_date)', fontsize=20)
+            ax.set_ylabel(f'{str(metric)+str(param_type)+str(param)}',
+                          fontsize=20)
+            plt.xticks(model_metrics_filter.as_of_date_year.unique())
+            plt.yticks(np.arange(0,1,0.1))
+            legend=plt.legend(bbox_to_anchor=(1.05, 1),
+                       loc=2,
+                       borderaxespad=0.,
+                       title='Model Group',
+                       fontsize=fontsize)
+            legend.get_title().set_fontsize('16')
+
+        except TypeError:
+                print(f'''
+                      Oops! model_metrics_pivot table is empty. Several problems
+                      can be creating this error:
+                      1. Check that {param_type}@{param} exists in the evaluations
+                      table
+                      2. Check that the metric {metric} is available to the
+                      specified {param_type}@{param}.
+                      3. You basline model can have different specifications.
+                      Check those!
+                      4. Check overlap between baseline dates and model dates.
+                      The join is using the dates for doing these, and it's
+                      possible that your timestamps differ.
+                      ''')
+
+def feature_loi_loo(self,
+                    model_subset=None,
+                    param_type=None,
+                    param=None,
+                    metric=None,
+                    baseline=False,
+                    baseline_query=None,
+                    df=False,
+                    figsize=(16,12),
+                    fontsize=20):
+    '''
+    Plot precision across time for the selected model_group_ids, and
+    include a leave-one-out, leave-one-in feature analysis to explore the
+    leverage/changes of the selected metric across different models.
+
+    This function plots the performance of each model_group_id following an
+    user defined performance metric. First, this function check if the
+    performance metrics are available to both the models, and the baseline.
+    Second, filter the data of interest, and lastly, plot the results as
+    timelines (model_id date).
+
+    Arguments:
+        -model_subset (list): A list of model_group_ids, in case you want
+        to override the selected models.
+        - param_type (string): A parameter string with a threshold
+        definition: rank_pct, or rank_abs. These are usually defined in the
+        postmodeling configuration file.
+        - param (int): A threshold value compatible with the param_type.
+        This value is also defined in the postmodeling configuration file.
+        - metric (string): A string defnining the type of metric use to
+        evaluate the model, this can be 'precision@', or 'recall@'.
+        - baseline (bool): should we include a baseline for comparison?
+        - baseline_query (str): a SQL query that returns the evaluation data from
+        the baseline models. This value can also be defined in the
+        configuration file.
+        - df (bool): If True, no plot is rendered, but a pandas DataFrame
+        is returned with the data.
+        - figsize (tuple): tuple with figure size parameters
+        - fontsize (int): Fontsize for titles
+
+'''
+
+    if model_subset is None:
+        model_subset = self.model_group_id
+
+    # Load feature groups and subset
+    feature_groups = self.feature_groups
+    feature_groups_filter = \
+    feature_groups[feature_groups['model_group_id'].isin(model_subset)]
+
+    # Format metrics columns and filter by metric of interest
+    model_metrics = self.metrics
+    model_metrics[['param', 'param_type']] = \
+            model_metrics['parameter'].str.split('_', 1, expand=True)
+    model_metrics['param'] =  model_metrics['param'].astype(str).astype(float)
+    model_metrics['param_type'] = model_metrics['param_type'].apply(lambda x: 'rank_'+x)
+
+    model_metrics_filter = model_metrics[(model_metrics['metric'] == metric) &
+                                         (model_metrics['param'] == param) &
+                                         (model_metrics['param_type'] == param_type)].\
+            filter(['model_group_id', 'model_id', 'as_of_date_year',
+                    'value'])
+
+    # Merge metrics and features and filter by threshold definition
+    metrics_merge = model_metrics_filter.merge(feature_groups_filter,
+                                              how='inner',
+                                              on='model_group_id')
+
+    # LOO and LOI definition
+    all_features = set(metrics_merge.loc[metrics_merge['experiment_type'] == 'All features'] \
+                       ['feature_group_array'][0])
+
+    metrics_merge_experimental = \
+    metrics_merge[metrics_merge['experiment_type'] != 'All features']
+
+    metrics_merge_experimental['feature_experiment'] = \
+            metrics_merge_experimental.apply(lambda row: \
+                               list(all_features.difference(row['feature_group_array']))[0] + '_loo' \
+                               if row['experiment_type'] == 'LOO' \
+                               else row['feature_group_array'] + '_loi', axis=1)
+
+    metrics_merge_experimental = \
+    metrics_merge_experimental.filter(['feature_experiment',
+                                       'as_of_date_year', 'value'])
+
+    if baseline == True:
+
+        baseline_metrics = pd.read_sql(baseline_query, con=self.engine)
+        baseline_metrics[['param', 'param_type']] = \
+                baseline_metrics['parameter'].str.split('_', 1, expand=True)
+        baseline_metrics['param'] = baseline_metrics['param'].astype(str).astype(float)
+        baseline_metrics['param_type'] = baseline_metrics['param_type'].apply(lambda x: 'rank_'+x)
+
+        # Filter baseline metrics and create pivot table to join with
+        # selected models metrics
+        baseline_metrics_filter =  baseline_metrics[(baseline_metrics['metric'] == metric) &
+                                                    (baseline_metrics['param'] == param) &
+                                                    (baseline_metrics['param_type'] == param_type)].\
+            filter(['model_group_id', 'model_id', 'as_of_date_year', 'value'])
+
+        baseline_metrics_filter['feature_experiment'] = \
+                baseline_metrics_filter.model_group_id.apply(lambda x: \
+                                                             'baseline_' + \
+                                                             str(x))
+
+        metrics_merge_experimental = \
+                metrics_merge_experimental.append(baseline_metrics_filter,
+                                                 sort=True)
+    if df == True:
+        return metrics_merge_experimental
+
+    else:
+        try:
+            sns.set_style('whitegrid')
+            fig, ax = plt.subplots(figsize=figsize)
+            for feature, df in metrics_merge_experimental.groupby(['feature_experiment']):
+                ax = df.plot(ax=ax, kind='line',
+                                  x='as_of_date_year',
+                                  y='value',
+                                  label=feature)
+            metrics_merge[metrics_merge['experiment_type'] == 'All features']. \
+                    groupby(['experiment_type']). \
+                    plot(ax=ax,
+                         kind='line',
+                         x='as_of_date_year',
+                         y='value',
+                         label='All features')
+            plt.title(str(metric).capitalize() +\
+                      ' for selected model_groups in time.',
+                      fontsize=fontsize)
+            ax.tick_params(labelsize=16)
+            ax.set_xlabel('Year of prediction (as_of_date)', fontsize=20)
+            ax.set_ylabel(f'{str(metric)+str(param_type)+str(param)}',
+                          fontsize=20)
+            plt.xticks(model_metrics_filter.as_of_date_year.unique())
+            plt.yticks(np.arange(0,1,0.1))
+            legend=plt.legend(bbox_to_anchor=(1.05, 1),
+                       loc=2,
+                       borderaxespad=0.,
+                       title='Experiment Type',
+                       fontsize=fontsize)
+            legend.get_title().set_fontsize('16')
+
+        except TypeError:
+                print(f'''
+                      Oops! model_metrics_pivot table is empty. Several problems
+                      can be creating this error:
+                      1. Check that {param_type}@{param} exists in the evaluations
+                      table
+                      2. Check that the metric {metric} is available to the
+                      specified {param_type}@{param}.
+                      3. You basline model can have different specifications.
+                      Check those!
+                      4. Check overlap between baseline dates and model dates.
+                      The join is using the dates for doing these, and it's
+                      possible that your timestamps differ.
+                      ''')

From 62e25a8b36f5b655d50b00fbdd968607052083f3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Wed, 3 Apr 2019 16:22:31 -0500
Subject: [PATCH 02/17] Plots: ROC, prec_recall_n

---
 src/triage/component/postmodeling/__init__.py |  28 ++
 src/triage/component/postmodeling/plots.py    | 465 ++++--------------
 2 files changed, 130 insertions(+), 363 deletions(-)

diff --git a/src/triage/component/postmodeling/__init__.py b/src/triage/component/postmodeling/__init__.py
index 8d71b01a4..8c4b39de1 100644
--- a/src/triage/component/postmodeling/__init__.py
+++ b/src/triage/component/postmodeling/__init__.py
@@ -12,6 +12,8 @@
 import sqlalchemy.dialects.postgresql as postgresql
 from sqlalchemy import Column, ForeignKey
 
+import pandas as pd
+
 from triage.component.catwalk.storage import CSVMatrixStore, HDFMatrixStore, Store, ProjectStorage
 
 logging.basicConfig(level=logging.INFO)
@@ -61,6 +63,16 @@ def get_model_group(model_group_id):
     return session.query(ModelGroup).get(model_group_id)
 
 
+def get_predictions(model):
+    predictions = pd.DataFrame([prediction.__dict__ for prediction in model.predictions])
+    return predictions.drop('_sa_instance_state', axis=1).set_index(['as_of_date', 'entity_id'])
+
+
+def get_evaluations(model):
+    evaluations =  pd.DataFrame([evaluation.__dict__ for evaluation in model.evaluations])
+    return evaluations.drop('_sa_instance_state', axis=1).set_index(['evaluation_start_time', 'metric', 'parameter'])
+
+
 class ModelGroup(Base):
     __tablename__ = 'model_groups'
     __table_args__ = ({"schema": "model_metadata"})
@@ -70,6 +82,10 @@ class ModelGroup(Base):
     features = Column('feature_list', postgresql.ARRAY(postgresql.TEXT))
     config = Column('model_config', postgresql.JSONB)
 
+    def get_models(self):
+        models = pd.DataFrame([model.__dict__ for model in self.models])
+        return models.drop('_sa_instance_state', axis=1).set_index(['model_group_id', 'id'])
+
 
 class Model(Base):
     __tablename__ = 'models'
@@ -89,6 +105,18 @@ class Model(Base):
     model_group_id = Column('model_group_id', postgresql.INTEGER, ForeignKey('model_metadata.model_groups.model_group_id'))
     model_group = relationship("ModelGroup", backref="models")
 
+    def get_predictions(self):
+        predictions = pd.DataFrame([prediction.__dict__ for prediction in self.predictions])
+        return predictions.drop('_sa_instance_state', axis=1).set_index(['as_of_date', 'entity_id'])
+
+    def get_evaluations(self):
+        evaluations =  pd.DataFrame([evaluation.__dict__ for evaluation in self.evaluations])
+        return evaluations.drop('_sa_instance_state', axis=1).set_index(['evaluation_start_time', 'metric', 'parameter'])
+
+    def to_df(self):
+        model = pd.DataFrame.from_dict({k: v for k,v in self.__dict__.items() if not k in ['predictions', 'evaluations']}, orient='columns')
+        return model.drop('_sa_instance_state', axis=1).set_index(['model_group_id', 'model_id'])
+
 
 class Evaluation(Base):
     __tablename__ = 'evaluations'
diff --git a/src/triage/component/postmodeling/plots.py b/src/triage/component/postmodeling/plots.py
index ee09d15a1..f3bbfb239 100644
--- a/src/triage/component/postmodeling/plots.py
+++ b/src/triage/component/postmodeling/plots.py
@@ -1,394 +1,133 @@
 # coding: utf-8
 
-def plot_ROC(self,
-             figsize=(16, 12),
-             fontsize=20):
-    '''
-    Plot an ROC curve for this model and label it with AUC
-    using the sklearn.metrics methods.
-    Arguments:
-        - figsize (tuple): figure size to pass to matplotlib
-        - fontsize (int): fontsize for title. Default is 20.
-    '''
 
-    fpr, tpr, thresholds, auc = self.compute_AUC()
-    auc = "%.2f" % auc
+import itertools
 
-    title = 'ROC Curve, AUC = ' + str(auc)
-    fig, ax = plt.subplots(figsize=figsize)
-    ax.plot(fpr, tpr, "#000099", label='ROC curve')
-    ax.plot([0, 1], [0, 1], 'k--', label='Baseline')
-    plt.xlim([0.0, 1.0])
-    plt.ylim([0.0, 1.05])
-    plt.xlabel('False Positive Rate', fontsize=fontsize)
-    plt.ylabel('True Positive Rate', fontsize=fontsize)
-    plt.legend(loc='lower right')
-    plt.title(title, fontsize=fontsize)
-    plt.show()
-
-def plot_recall_fpr_n(self,
-                      figsize=(16, 12),
-                      fontsize=20):
-    '''
-    Plot recall and the false positive rate against depth into the list
-    (esentially just a deconstructed ROC curve) along with optimal bounds.
-    Arguments:
-        - figsize (tuple): define a plot size to pass to matplotlib
-        - fontsize (int): define a custom font size to labels and axes
-    '''
-
-
-    _labels = self.predictions.filter(items=['label_value', 'score'])
-
-    # since tpr and recall are different names for the same metric, we can just
-    # grab fpr and tpr from the sklearn function for ROC
-    fpr, recall, thresholds, auc = self.compute_AUC()
-
-    # turn the thresholds into percent of the list traversed from top to bottom
-    pct_above_per_thresh = []
-    num_scored = float(len(_labels.score))
-    for value in thresholds:
-        num_above_thresh = len(_labels.loc[_labels.score >= value, 'score'])
-        pct_above_thresh = num_above_thresh / num_scored
-        pct_above_per_thresh.append(pct_above_thresh)
-    pct_above_per_thresh = np.array(pct_above_per_thresh)
-
-    # plot the false positive rate, along with a dashed line showing the optimal bounds
-    # given the proportion of positive labels
-    plt.clf()
-    fig, ax1 = plt.subplots(figsize=figsize)
-    ax1.plot([_labels.label_value.mean(), 1], [0, 1], '--', color='gray')
-    ax1.plot([0, _labels.label_value.mean()], [0, 0], '--', color='gray')
-    ax1.plot(pct_above_per_thresh, fpr, "#000099")
-    plt.title('Deconstructed ROC Curve\nRecall and FPR vs. Depth',fontsize=fontsize)
-    ax1.set_xlabel('Proportion of Population', fontsize=fontsize)
-    ax1.set_ylabel('False Positive Rate', color="#000099", fontsize=fontsize)
-    plt.ylim([0.0, 1.05])
+import math
+import matplotlib
+#matplotlib.use('Agg')  ## Needed since we could use this in non-interactive mode
+                       ## see https://matplotlib.org/faq/howto_faq.html
 
+import matplotlib.pyplot as plt
 
-def plot_precision_recall_n(self,
-                            figsize=(16, 12),
-                            fontsize=20):
-    """
-    Plot recall and precision curves against depth into the list.
-    """
+import seaborn as sns
+sns.set(style="darkgrid")
+sns.set_context("paper", rc={"font.size": 8, "axes.labelsize": 5})
 
+import sklearn.metrics as metrics
+from sklearn.metrics import precision_recall_curve, roc_curve, auc, precision_score, recall_score
+from sklearn.tree import export_graphviz
+import pydotplus
 
-    _labels = self.predictions.filter(items=['label_value', 'score'])
+import numpy as np
+import pandas as pd
 
-    y_score = _labels.score
-    precision_curve, recall_curve, pr_thresholds = \
-        metrics.precision_recall_curve(_labels.label_value, y_score)
+from triage.component.postmodeling import get_predictions, get_model, get_model_group, get_evaluations
 
-    precision_curve = precision_curve[:-1]
-    recall_curve = recall_curve[:-1]
 
-    # a little bit of a hack, but ensure we start with a cut-off of 0
-    # to extend lines to full [0,1] range of the graph
-    pr_thresholds = np.insert(pr_thresholds, 0, 0)
-    precision_curve = np.insert(precision_curve, 0, precision_curve[0])
-    recall_curve = np.insert(recall_curve, 0, recall_curve[0])
-
-    pct_above_per_thresh = []
-    number_scored = len(y_score)
-    for value in pr_thresholds:
-        num_above_thresh = len(y_score[y_score >= value])
-        pct_above_thresh = num_above_thresh / float(number_scored)
-        pct_above_per_thresh.append(pct_above_thresh)
-    pct_above_per_thresh = np.array(pct_above_per_thresh)
+def plot_roc(model, output_type='show', **kwargs):
+    predictions = get_predictions(model)
+    labels = predictions.label_value
+    scores = predictions.score
+    fpr, tpr, thresholds = roc_curve(labels, scores)
+    roc_auc = auc(fpr, tpr)
 
     plt.clf()
-    fig, ax1 = plt.subplots(figsize=figsize)
-    ax1.plot(pct_above_per_thresh, precision_curve, "#000099")
-    ax1.set_xlabel('Proportion of population', fontsize=fontsize)
-    ax1.set_ylabel('Precision', color="#000099", fontsize=fontsize)
-    plt.ylim([0.0, 1.05])
-    ax2 = ax1.twinx()
-    ax2.plot(pct_above_per_thresh, recall_curve, "#CC0000")
-    ax2.set_ylabel('Recall', color="#CC0000", fontsize=fontsize)
-    plt.xlim([0.0, 1.0])
+    plt.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc)
+    plt.plot([0, 1], [0, 1], 'k--')
+    plt.xlim([0.0, 1.05])
     plt.ylim([0.0, 1.05])
-    plt.title("Precision-recall at x-proportion", fontsize=fontsize)
-    plt.show()
-
-
-def plot_prec_across_time(self,
-                          param_type=None,
-                          param=None,
-                          metric=None,
-                          baseline=False,
-                          baseline_query=None,
-                          df=False,
-                          figsize=(12, 16),
-                          fontsize=20):
-
-    '''
-    Plot precision across time for all model_group_ids, and baseline,
-    if available.
-
-    This function plots the performance of each model_group_id following an
-    user defined performance metric. First, this function check if the
-    performance metrics are available to both the models, and the baseline.
-    Second, filter the data of interest, and lastly, plot the results as
-    timelines (model_id date).
-
-    Arguments:
-        - param_type (string): A parameter string with a threshold
-        definition: rank_pct, or rank_abs. These are usually defined in the
-        postmodeling configuration file.
-        - param (int): A threshold value compatible with the param_type.
-        This value is also defined in the postmodeling configuration file.
-        - metric (string): A string defnining the type of metric use to
-        evaluate the model, this can be 'precision@', or 'recall@'.
-        - baseline (bool): should we include a baseline for comparison?
-        - baseline_query (str): a SQL query that returns the evaluation data from
-        the baseline models. This value can also be defined in the
-        configuration file.
-        - df (bool): If True, no plot is rendered, but a pandas DataFrame
-        is returned with the data.
-        - figsize (tuple): tuple with figure size parameters
-        - fontsize (int): Fontsize for titles
-    '''
-
-    # Load metrics and prepare data for analysis
-    model_metrics = self.metrics
-    model_metrics[['param', 'param_type']] = \
-            model_metrics['parameter'].str.split('_', 1, expand=True)
-    model_metrics['param'] =  model_metrics['param'].astype(str).astype(float)
-    model_metrics['param_type'] = model_metrics['param_type'].apply(lambda x: 'rank_'+x)
-
-    # Filter model_group_id metrics and create pivot table by each
-    # model_group_id.
-    model_metrics_filter = model_metrics[(model_metrics['metric'] == metric) &
-                                  (model_metrics['param'] == param) &
-                                  (model_metrics['param_type'] == param_type)].\
-            filter(['model_group_id', 'model_id', 'as_of_date_year',
-                    'value'])
-
-    if baseline == True:
-
-        baseline_metrics = pd.read_sql(baseline_query, con=self.engine)
-        baseline_metrics[['param', 'param_type']] = \
-                baseline_metrics['parameter'].str.split('_', 1, expand=True)
-        baseline_metrics['param'] = baseline_metrics['param'].astype(str).astype(float)
-        baseline_metrics['param_type'] = baseline_metrics['param_type'].\
-                apply(lambda x: 'rank_'+x)
-
-        # Filter baseline metrics and create pivot table to join with
-        # selected models metrics
-        baseline_metrics_filter =  baseline_metrics.\
-                filter(['model_group_id', 'model_id', 'as_of_date_year', 'value'])
-
-        baseline_metrics_filter['model_group_id'] = \
-                baseline_metrics_filter.model_group_id.\
-                apply(lambda x: 'baseline_' + str(x))
-
-        # Join tables by index(as_of_date_year)
-        model_metrics_filter = \
-        model_metrics_filter.append(baseline_metrics_filter, sort=True)
-
-    model_metrics_filter['as_of_date_year'] = \
-            model_metrics_filter.as_of_date_year.astype('int')
-    model_metrics_filter = model_metrics_filter.sort_values('as_of_date_year')
-
-    if df == True:
-        return model_metrics_filter
-
+    plt.xlabel('False Positive Rate')
+    plt.ylabel('True Positive Rate')
+    plt.title(kwargs.get('title', ''))
+    plt.legend(loc="lower right")
+
+    if (output_type == 'save'):
+        filename = kwargs('filename', f"{model}")
+        extension = kwargs('extension', 'png')
+        plt.savefig(f"{filename}.{extension}")
+    elif (output_type == 'show'):
+        plt.show()
     else:
-        try:
-            sns.set_style('whitegrid')
-            fig, ax = plt.subplots(figsize=figsize)
-            for model_group, df in model_metrics_filter.groupby(['model_group_id']):
-                ax = ax = df.plot(ax=ax, kind='line',
-                                  x='as_of_date_year',
-                                  y='value',
-                                  marker='d',
-                                  label=model_group)
-            plt.title(str(metric).capitalize() +\
-                      ' for selected model_groups in time.',
-                      fontsize=fontsize)
-            ax.tick_params(labelsize=16)
-            ax.set_xlabel('Year of prediction (as_of_date)', fontsize=20)
-            ax.set_ylabel(f'{str(metric)+str(param_type)+str(param)}',
-                          fontsize=20)
-            plt.xticks(model_metrics_filter.as_of_date_year.unique())
-            plt.yticks(np.arange(0,1,0.1))
-            legend=plt.legend(bbox_to_anchor=(1.05, 1),
-                       loc=2,
-                       borderaxespad=0.,
-                       title='Model Group',
-                       fontsize=fontsize)
-            legend.get_title().set_fontsize('16')
+        plt.show()
 
-        except TypeError:
-                print(f'''
-                      Oops! model_metrics_pivot table is empty. Several problems
-                      can be creating this error:
-                      1. Check that {param_type}@{param} exists in the evaluations
-                      table
-                      2. Check that the metric {metric} is available to the
-                      specified {param_type}@{param}.
-                      3. You basline model can have different specifications.
-                      Check those!
-                      4. Check overlap between baseline dates and model dates.
-                      The join is using the dates for doing these, and it's
-                      possible that your timestamps differ.
-                      ''')
+def generate_binary_at_k(y_scores, k):
+    cutoff_index = int(len(y_scores) * (k / 100.0))
+    predictions_binary = [1 if x < cutoff_index else 0 for x in range(len(y_scores))]
+    return predictions_binary
 
-def feature_loi_loo(self,
-                    model_subset=None,
-                    param_type=None,
-                    param=None,
-                    metric=None,
-                    baseline=False,
-                    baseline_query=None,
-                    df=False,
-                    figsize=(16,12),
-                    fontsize=20):
-    '''
-    Plot precision across time for the selected model_group_ids, and
-    include a leave-one-out, leave-one-in feature analysis to explore the
-    leverage/changes of the selected metric across different models.
+def precision_at_k(y_true, y_scores, k):
+    y_scores_sorted, y_true_sorted = joint_sort_descending(np.array(y_scores), np.array(y_true))
+    preds_at_k = generate_binary_at_k(y_scores_sorted, k)
+    precision = precision_score(y_true_sorted, preds_at_k)
+    return precision
 
-    This function plots the performance of each model_group_id following an
-    user defined performance metric. First, this function check if the
-    performance metrics are available to both the models, and the baseline.
-    Second, filter the data of interest, and lastly, plot the results as
-    timelines (model_id date).
+def recall_at_k(y_true, y_scores, k):
+    y_scores_sorted, y_true_sorted = joint_sort_descending(np.array(y_scores), np.array(y_true))
+    preds_at_k = generate_binary_at_k(y_scores_sorted, k)
+    recall = recall_score(y_true_sorted, preds_at_k)
+    return recall
 
-    Arguments:
-        -model_subset (list): A list of model_group_ids, in case you want
-        to override the selected models.
-        - param_type (string): A parameter string with a threshold
-        definition: rank_pct, or rank_abs. These are usually defined in the
-        postmodeling configuration file.
-        - param (int): A threshold value compatible with the param_type.
-        This value is also defined in the postmodeling configuration file.
-        - metric (string): A string defnining the type of metric use to
-        evaluate the model, this can be 'precision@', or 'recall@'.
-        - baseline (bool): should we include a baseline for comparison?
-        - baseline_query (str): a SQL query that returns the evaluation data from
-        the baseline models. This value can also be defined in the
-        configuration file.
-        - df (bool): If True, no plot is rendered, but a pandas DataFrame
-        is returned with the data.
-        - figsize (tuple): tuple with figure size parameters
-        - fontsize (int): Fontsize for titles
 
-'''
+def precision_n(y_true, y_scores):
+    precisions = []
+    for i in range(101):
+        prec = precision_at_k(y_true, y_scores, i)
+        precisions.append(prec)
+    return precisions
 
-    if model_subset is None:
-        model_subset = self.model_group_id
 
-    # Load feature groups and subset
-    feature_groups = self.feature_groups
-    feature_groups_filter = \
-    feature_groups[feature_groups['model_group_id'].isin(model_subset)]
+def recall_n(y_true, y_scores):
+    recalls = []
+    for i in range(101):
+        rec = recall_at_k(y_true, y_scores, i)
+        recalls.append(rec)
+    return recalls
 
-    # Format metrics columns and filter by metric of interest
-    model_metrics = self.metrics
-    model_metrics[['param', 'param_type']] = \
-            model_metrics['parameter'].str.split('_', 1, expand=True)
-    model_metrics['param'] =  model_metrics['param'].astype(str).astype(float)
-    model_metrics['param_type'] = model_metrics['param_type'].apply(lambda x: 'rank_'+x)
 
-    model_metrics_filter = model_metrics[(model_metrics['metric'] == metric) &
-                                         (model_metrics['param'] == param) &
-                                         (model_metrics['param_type'] == param_type)].\
-            filter(['model_group_id', 'model_id', 'as_of_date_year',
-                    'value'])
+def plot_precision_recall_n(model, output_type='show', **kwargs):
+    predictions = get_predictions(model)
+    labels = predictions.label_value
+    scores = predictions.score
 
-    # Merge metrics and features and filter by threshold definition
-    metrics_merge = model_metrics_filter.merge(feature_groups_filter,
-                                              how='inner',
-                                              on='model_group_id')
+    y_axis = np.arange(0, 101, 1)
 
-    # LOO and LOI definition
-    all_features = set(metrics_merge.loc[metrics_merge['experiment_type'] == 'All features'] \
-                       ['feature_group_array'][0])
+    prec_k = precision_n(labels, scores)
+    rec_k = recall_n(labels, scores)
 
-    metrics_merge_experimental = \
-    metrics_merge[metrics_merge['experiment_type'] != 'All features']
-
-    metrics_merge_experimental['feature_experiment'] = \
-            metrics_merge_experimental.apply(lambda row: \
-                               list(all_features.difference(row['feature_group_array']))[0] + '_loo' \
-                               if row['experiment_type'] == 'LOO' \
-                               else row['feature_group_array'] + '_loi', axis=1)
-
-    metrics_merge_experimental = \
-    metrics_merge_experimental.filter(['feature_experiment',
-                                       'as_of_date_year', 'value'])
-
-    if baseline == True:
-
-        baseline_metrics = pd.read_sql(baseline_query, con=self.engine)
-        baseline_metrics[['param', 'param_type']] = \
-                baseline_metrics['parameter'].str.split('_', 1, expand=True)
-        baseline_metrics['param'] = baseline_metrics['param'].astype(str).astype(float)
-        baseline_metrics['param_type'] = baseline_metrics['param_type'].apply(lambda x: 'rank_'+x)
-
-        # Filter baseline metrics and create pivot table to join with
-        # selected models metrics
-        baseline_metrics_filter =  baseline_metrics[(baseline_metrics['metric'] == metric) &
-                                                    (baseline_metrics['param'] == param) &
-                                                    (baseline_metrics['param_type'] == param_type)].\
-            filter(['model_group_id', 'model_id', 'as_of_date_year', 'value'])
+    plt.clf()
+    fig, ax1 = plt.subplots()
+    ax1.plot(y_axis, prec_k, 'b')
+    ax1.set_xlabel('percent of population')
+    ax1.set_ylabel('precision', color='b')
+    ax2 = ax1.twinx()
+    ax2.plot(y_axis, rec_k, 'r')
+    ax2.set_ylabel('recall', color='r')
+    ax1.set_ylim([0,1])
+    ax2.set_ylim([0,1])
+    ax1.set_xlim([0,100])
+    ax2.set_xlim([0,100])
+
+    plt.title(kwargs.get('title', ''))
+    if (output_type == 'save'):
+        filename = kwargs('filename', f"{model}")
+        extension = kwargs('extension', 'png')
+        plt.savefig(f"{filename}.{extension}")
+    elif (output_type == 'show'):
+        plt.show()
+    else:
+        plt.show()
 
-        baseline_metrics_filter['feature_experiment'] = \
-                baseline_metrics_filter.model_group_id.apply(lambda x: \
-                                                             'baseline_' + \
-                                                             str(x))
 
-        metrics_merge_experimental = \
-                metrics_merge_experimental.append(baseline_metrics_filter,
-                                                 sort=True)
-    if df == True:
-        return metrics_merge_experimental
+def get_subsets(l):
+    subsets = []
+    for i in range(1, len(l) + 1):
+        for combo in itertools.combinations(l, i):
+            subsets.append(list(combo))
+    return subsets
 
-    else:
-        try:
-            sns.set_style('whitegrid')
-            fig, ax = plt.subplots(figsize=figsize)
-            for feature, df in metrics_merge_experimental.groupby(['feature_experiment']):
-                ax = df.plot(ax=ax, kind='line',
-                                  x='as_of_date_year',
-                                  y='value',
-                                  label=feature)
-            metrics_merge[metrics_merge['experiment_type'] == 'All features']. \
-                    groupby(['experiment_type']). \
-                    plot(ax=ax,
-                         kind='line',
-                         x='as_of_date_year',
-                         y='value',
-                         label='All features')
-            plt.title(str(metric).capitalize() +\
-                      ' for selected model_groups in time.',
-                      fontsize=fontsize)
-            ax.tick_params(labelsize=16)
-            ax.set_xlabel('Year of prediction (as_of_date)', fontsize=20)
-            ax.set_ylabel(f'{str(metric)+str(param_type)+str(param)}',
-                          fontsize=20)
-            plt.xticks(model_metrics_filter.as_of_date_year.unique())
-            plt.yticks(np.arange(0,1,0.1))
-            legend=plt.legend(bbox_to_anchor=(1.05, 1),
-                       loc=2,
-                       borderaxespad=0.,
-                       title='Experiment Type',
-                       fontsize=fontsize)
-            legend.get_title().set_fontsize('16')
 
-        except TypeError:
-                print(f'''
-                      Oops! model_metrics_pivot table is empty. Several problems
-                      can be creating this error:
-                      1. Check that {param_type}@{param} exists in the evaluations
-                      table
-                      2. Check that the metric {metric} is available to the
-                      specified {param_type}@{param}.
-                      3. You basline model can have different specifications.
-                      Check those!
-                      4. Check overlap between baseline dates and model dates.
-                      The join is using the dates for doing these, and it's
-                      possible that your timestamps differ.
-                      ''')
+def joint_sort_descending(l1, l2):
+    # l1 and l2 have to be numpy arrays
+    idx = np.argsort(l1)[::-1]
+    return l1[idx], l2[idx]

From b4e8a20747dc509c129ab4e80316d5257223e1ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Fri, 5 Apr 2019 12:34:05 -0500
Subject: [PATCH 03/17] Added __iter__ to model group

---
 src/triage/component/postmodeling/__init__.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/triage/component/postmodeling/__init__.py b/src/triage/component/postmodeling/__init__.py
index 8c4b39de1..e98163757 100644
--- a/src/triage/component/postmodeling/__init__.py
+++ b/src/triage/component/postmodeling/__init__.py
@@ -86,6 +86,8 @@ def get_models(self):
         models = pd.DataFrame([model.__dict__ for model in self.models])
         return models.drop('_sa_instance_state', axis=1).set_index(['model_group_id', 'id'])
 
+    def __iter__(self):
+        return iter(self.models)
 
 class Model(Base):
     __tablename__ = 'models'

From b3aed8882e69e8b927f2a2ba1de4eca88eaf9d28 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Mon, 8 Apr 2019 14:10:56 -0500
Subject: [PATCH 04/17] =?UTF-8?q?Plots=20added:=20Rayid=E2=80=99s=20curve,?=
 =?UTF-8?q?=20Metric=20over=20time=20(for=20model=20groups)=20and=20ROC.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/triage/component/postmodeling/__init__.py |   5 +-
 src/triage/component/postmodeling/plots.py    | 212 ++++++++++++------
 2 files changed, 147 insertions(+), 70 deletions(-)

diff --git a/src/triage/component/postmodeling/__init__.py b/src/triage/component/postmodeling/__init__.py
index e98163757..15d8b0a2a 100644
--- a/src/triage/component/postmodeling/__init__.py
+++ b/src/triage/component/postmodeling/__init__.py
@@ -70,7 +70,8 @@ def get_predictions(model):
 
 def get_evaluations(model):
     evaluations =  pd.DataFrame([evaluation.__dict__ for evaluation in model.evaluations])
-    return evaluations.drop('_sa_instance_state', axis=1).set_index(['evaluation_start_time', 'metric', 'parameter'])
+    evaluations['model_group_id'] = model.model_group_id
+    return evaluations.drop('_sa_instance_state', axis=1).set_index(['model_group_id', 'model_id', 'metric', 'parameter'])
 
 
 class ModelGroup(Base):
@@ -113,7 +114,7 @@ def get_predictions(self):
 
     def get_evaluations(self):
         evaluations =  pd.DataFrame([evaluation.__dict__ for evaluation in self.evaluations])
-        return evaluations.drop('_sa_instance_state', axis=1).set_index(['evaluation_start_time', 'metric', 'parameter'])
+        return evaluations.drop('_sa_instance_state', axis=1).set_index(['evaluation_start_time', 'model_id', 'metric', 'parameter'])
 
     def to_df(self):
         model = pd.DataFrame.from_dict({k: v for k,v in self.__dict__.items() if not k in ['predictions', 'evaluations']}, orient='columns')
diff --git a/src/triage/component/postmodeling/plots.py b/src/triage/component/postmodeling/plots.py
index f3bbfb239..b98715d32 100644
--- a/src/triage/component/postmodeling/plots.py
+++ b/src/triage/component/postmodeling/plots.py
@@ -1,91 +1,82 @@
 # coding: utf-8
 
-
 import itertools
 
 import math
+
+import numpy as np
+import pandas as pd
+
 import matplotlib
 #matplotlib.use('Agg')  ## Needed since we could use this in non-interactive mode
                        ## see https://matplotlib.org/faq/howto_faq.html
 
 import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+from matplotlib.ticker import FuncFormatter
 
 import seaborn as sns
 sns.set(style="darkgrid")
-sns.set_context("paper", rc={"font.size": 8, "axes.labelsize": 5})
+
 
 import sklearn.metrics as metrics
 from sklearn.metrics import precision_recall_curve, roc_curve, auc, precision_score, recall_score
 from sklearn.tree import export_graphviz
+
 import pydotplus
 
-import numpy as np
-import pandas as pd
 
 from triage.component.postmodeling import get_predictions, get_model, get_model_group, get_evaluations
 
+def _store(fig, **kwargs):
+    output_type=kwargs.get('output_type', 'show')
+
+    if (output_type == 'save'):
+        filename = kwargs.get('filename', f"{model}")
+        extension = kwargs.get('extension', 'png')
+        transparent = kwargs.get('transparent', False)
+        dpi = kwargs.get('dpi', 80)
+        bbox_inches = kwargs.get('bbox_inches', 'tight')
+        fig.savefig(f"{filename}.{extension}", transparent=transparent, dpi=dpi, bbox_inches=bbox_inches)
+
+
+def plot_roc(model, **kwargs):
+    fig, ax = plt.subplots()
 
-def plot_roc(model, output_type='show', **kwargs):
     predictions = get_predictions(model)
     labels = predictions.label_value
     scores = predictions.score
     fpr, tpr, thresholds = roc_curve(labels, scores)
     roc_auc = auc(fpr, tpr)
 
-    plt.clf()
-    plt.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc)
-    plt.plot([0, 1], [0, 1], 'k--')
-    plt.xlim([0.0, 1.05])
-    plt.ylim([0.0, 1.05])
-    plt.xlabel('False Positive Rate')
-    plt.ylabel('True Positive Rate')
-    plt.title(kwargs.get('title', ''))
-    plt.legend(loc="lower right")
+    fmt = kwargs.get('fmt', 'b')
 
-    if (output_type == 'save'):
-        filename = kwargs('filename', f"{model}")
-        extension = kwargs('extension', 'png')
-        plt.savefig(f"{filename}.{extension}")
-    elif (output_type == 'show'):
-        plt.show()
-    else:
-        plt.show()
+    # Random performance
+    ax.plot([0, 1], [0, 1], 'k--')
 
-def generate_binary_at_k(y_scores, k):
-    cutoff_index = int(len(y_scores) * (k / 100.0))
-    predictions_binary = [1 if x < cutoff_index else 0 for x in range(len(y_scores))]
-    return predictions_binary
+    # Actual model
+    ax.plot(fpr, tpr, fmt, label='ROC curve (area = %0.2f)' % roc_auc)
 
-def precision_at_k(y_true, y_scores, k):
-    y_scores_sorted, y_true_sorted = joint_sort_descending(np.array(y_scores), np.array(y_true))
-    preds_at_k = generate_binary_at_k(y_scores_sorted, k)
-    precision = precision_score(y_true_sorted, preds_at_k)
-    return precision
+    ax.set_xlim([0.0, 1.0])
+    ax.set_ylim([0.0, 1.0])
 
-def recall_at_k(y_true, y_scores, k):
-    y_scores_sorted, y_true_sorted = joint_sort_descending(np.array(y_scores), np.array(y_true))
-    preds_at_k = generate_binary_at_k(y_scores_sorted, k)
-    recall = recall_score(y_true_sorted, preds_at_k)
-    return recall
+    ax.set_xlabel('False Positive Rate')
+    ax.set_ylabel('True Positive Rate')
 
+    ax.set_title(kwargs.get('title', f"(Model {model.id} @ {model.train_end_time.strftime('%Y-%m-%d')})"))
 
-def precision_n(y_true, y_scores):
-    precisions = []
-    for i in range(101):
-        prec = precision_at_k(y_true, y_scores, i)
-        precisions.append(prec)
-    return precisions
+    ax.legend(loc="lower right")
 
+    fig.suptitle(kwargs.get('suptitle', f"Model Group {model.model_group.id}"))
 
-def recall_n(y_true, y_scores):
-    recalls = []
-    for i in range(101):
-        rec = recall_at_k(y_true, y_scores, i)
-        recalls.append(rec)
-    return recalls
+    _store(fig, **kwargs)
+
+    return fig, ax
 
 
-def plot_precision_recall_n(model, output_type='show', **kwargs):
+def plot_precision_recall_n(model, **kwargs):
+    fig, ax1 = plt.subplots()
+
     predictions = get_predictions(model)
     labels = predictions.label_value
     scores = predictions.score
@@ -95,30 +86,81 @@ def plot_precision_recall_n(model, output_type='show', **kwargs):
     prec_k = precision_n(labels, scores)
     rec_k = recall_n(labels, scores)
 
-    plt.clf()
-    fig, ax1 = plt.subplots()
-    ax1.plot(y_axis, prec_k, 'b')
-    ax1.set_xlabel('percent of population')
-    ax1.set_ylabel('precision', color='b')
-    ax2 = ax1.twinx()
-    ax2.plot(y_axis, rec_k, 'r')
-    ax2.set_ylabel('recall', color='r')
+    prec_color = kwargs.get('prec_fmt', 'tab:blue')
+    rec_color = kwargs.get('rec_fmt', 'tab:red')
+
+    ax1.plot(y_axis, prec_k, prec_color)
+    ax1.set_xlabel('Percent of population')
+    ax1.set_ylabel('Precision', color=prec_color)
+    ax1.tick_params(axis='y', labelcolor=prec_color)
+
     ax1.set_ylim([0,1])
-    ax2.set_ylim([0,1])
     ax1.set_xlim([0,100])
-    ax2.set_xlim([0,100])
 
-    plt.title(kwargs.get('title', ''))
-    if (output_type == 'save'):
-        filename = kwargs('filename', f"{model}")
-        extension = kwargs('extension', 'png')
-        plt.savefig(f"{filename}.{extension}")
-    elif (output_type == 'show'):
-        plt.show()
-    else:
-        plt.show()
+    ax1.set_title(kwargs.get('title', f"(Model {model.id} @ {model.train_end_time.strftime('%Y-%m-%d')})"))
+
+    ax2 = ax1.twinx()
+    ax2.plot(y_axis, rec_k, rec_color)
+    ax2.set_ylim([0,1])
+    ax2.set_ylabel('Recall', color=rec_color)
+    ax2.tick_params(axis='y', labelcolor=rec_color)
 
 
+    fig.suptitle(kwargs.get('suptitle', f"Model Group {model.model_group.id}"))
+
+    _store(fig, **kwargs)
+
+    return fig, ax1, ax2
+
+def plot_metric_over_time(model_groups, metric, parameter, **kwargs):
+
+    def get_model_group_evaluations(model_group):
+        evaluations = pd.concat([get_evaluations(model).query(f"metric == '{metric}@' and parameter == '{parameter}'") for model in model_group])
+        evaluations = evaluations.sort_values('evaluation_start_time', ascending=True)
+        evaluations = evaluations[['evaluation_start_time', 'value']]
+        evaluations['type'] = model_group.type.split('.')[-1]
+        return evaluations
+
+    metric = metric.replace('@','')
+
+    fig, ax = plt.subplots()
+
+    evaluations = pd.concat([get_model_group_evaluations(model_group) for model_group in model_groups])
+
+    for name, mg in evaluations.groupby(by='model_group_id'):
+        type = mg.type.unique()[0]
+        ax.plot_date(x=mg.evaluation_start_time, y=mg.value,  xdate=True, linestyle='-', label=f"Model group {name} ({type})")
+        ax.format_xdata = mdates.DateFormatter('%Y-%m-%d')
+
+    ax.xaxis.set_major_locator(mdates.YearLocator())
+    ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y'))
+    ax.xaxis.set_minor_locator(mdates.MonthLocator())
+    ax.set_yticks(np.arange(0.0, 1.1, 0.1))
+
+    ax.set_xlabel('')
+    ax.set_ylabel(f"{metric.capitalize()} at {parameter.replace('_', ' ').replace('pct', '%')}")
+
+    ax.set_ylim([0, 1])
+
+    ax.legend(loc='best',
+              borderaxespad=0.,
+              title='Model Group')
+
+    ax.set_title(kwargs.get('title', f"Model Groups: performance over time"))
+
+    ax.grid(which='minor', linewidth='0.5', alpha=0.8)
+    ax.grid(which='major', linewidth='3.0', alpha=0.3)
+
+    ax.tick_params(which='major', # Options for both major and minor ticks
+                   top='off', # turn off top ticks
+                   left='off', # turn off left ticks
+                   right='off',  # turn off right ticks
+                   bottom='on') # turn off bottom ticks
+
+    _store(fig, **kwargs)
+
+    return fig, ax
+
 def get_subsets(l):
     subsets = []
     for i in range(1, len(l) + 1):
@@ -131,3 +173,37 @@ def joint_sort_descending(l1, l2):
     # l1 and l2 have to be numpy arrays
     idx = np.argsort(l1)[::-1]
     return l1[idx], l2[idx]
+
+
+def generate_binary_at_k(y_scores, k):
+    cutoff_index = int(len(y_scores) * (k / 100.0))
+    predictions_binary = [1 if x < cutoff_index else 0 for x in range(len(y_scores))]
+    return predictions_binary
+
+def precision_at_k(y_true, y_scores, k):
+    y_scores_sorted, y_true_sorted = joint_sort_descending(np.array(y_scores), np.array(y_true))
+    preds_at_k = generate_binary_at_k(y_scores_sorted, k)
+    precision = precision_score(y_true_sorted, preds_at_k)
+    return precision
+
+def recall_at_k(y_true, y_scores, k):
+    y_scores_sorted, y_true_sorted = joint_sort_descending(np.array(y_scores), np.array(y_true))
+    preds_at_k = generate_binary_at_k(y_scores_sorted, k)
+    recall = recall_score(y_true_sorted, preds_at_k)
+    return recall
+
+
+def precision_n(y_true, y_scores):
+    precisions = []
+    for i in range(101):
+        prec = precision_at_k(y_true, y_scores, i)
+        precisions.append(prec)
+    return precisions
+
+
+def recall_n(y_true, y_scores):
+    recalls = []
+    for i in range(101):
+        rec = recall_at_k(y_true, y_scores, i)
+        recalls.append(rec)
+    return recalls

From e6ceb0d9272c37b173e6995d9632ad0c834feaf6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Mon, 8 Apr 2019 14:13:58 -0500
Subject: [PATCH 05/17] Removed this folder

---
 .../component/postmodeling/contrast/README.md |  196 ---
 .../postmodeling/contrast/model_evaluator.py  | 1198 ----------------
 .../contrast/model_group_evaluator.py         | 1210 -----------------
 3 files changed, 2604 deletions(-)
 delete mode 100644 src/triage/component/postmodeling/contrast/README.md
 delete mode 100644 src/triage/component/postmodeling/contrast/model_evaluator.py
 delete mode 100644 src/triage/component/postmodeling/contrast/model_group_evaluator.py

diff --git a/src/triage/component/postmodeling/contrast/README.md b/src/triage/component/postmodeling/contrast/README.md
deleted file mode 100644
index c2d69f79c..000000000
--- a/src/triage/component/postmodeling/contrast/README.md
+++ /dev/null
@@ -1,196 +0,0 @@
-# Post-modeling Analysis
-
-> ¿What is the distribution of my scores? ¿What is generating a higher FPR in
-> model x compared to model y? ¿What is the single most important feature in my
-> models?
-
-This questions, and other ones, are the kind of inquiries that the `triage` user
-may have in mind when scrolling trough the models selected by the `Audition`
-component. Choosing the right model for deployment and exploring its predictions
-and behavior in time is a pivotal task. `postmodeling` will help to answer some
-of this questions by exploring the outcomes of the model, and exploring "deeply"
-into the model behavior across time and features. 
-
-This library lays at the end of the `triage` pipeline and will use the output of
-`Audition` and some of its selection rules as a main input. The
-`postmodeling_tutorial.ipynb` notebook contains a user guide with some questions
-that the component is able to answer about the models, but the methods are
-expandable and allow the user to develop new insights.  
-
-## Configuration File
-
-Before running the postmodeling notebook, the user must first define a series
-of parameters relevant for the library: 
-
-  - `project_path`: Triage's project path (same as your `config_file.yml`)
-  - `audition_output_path`: path to Audition's output. If not passed, the class
-    will use the listed `model_group_id`.
-  - `thresholds`: list of thresholds. 
-  - `baseline_query`: SQL query with baseline models metrics.
-  - `max_depth_error_tree`: deep for error DTs.
-  - other aesthetic arguments. 
-
-This file is passed to the `PostmodelParameters` class to facilitate the use of
-this parameters thorough the notebook.
-[Here](triage/blob/master/examples/postmodeling_config_example.yaml) is an
-example of a valid configuration file.  
-
-## Two classes, two units of analysis: `model_id` and `model_group_id`
-
-We can inspect models in two levels. The first, the individual model level
-(identified by the `model_id`) with the `ModelEvaluator` class. The methods in
-this class  will help us to answer questions about different relevant features
-of each model: 
-
- - **Model Predictions**: 
-     - `plot_score_label_distribution` shows a hued distribution plot of the predicted
-       score colored by the label. A raw version of the plot without label can
-       be plotted using the `plot_score_distribution` instead.
-
-     - `plot_score_distribution_thresh` plots a score distribution plot with
-       a dotted vertical line showing the "location" of a threshold defined by
-       a model metric. For this the function need a pair of `param_type` and `param`
-       (i.e. param_type='rank_abs', param=10).
-       
- - **Feature relevance**:
-     - `plot_feature_importances` shows an horizontal bar-plot with the top-n most
-       relevant features defined by the model feature importance (when available). 
-
-     - `plot_feature_importances_std_err` plots the feature importance of the
-       top-n features with their standard deviation. This is highly informative
-       in RandomForest models where each three can have different relevant
-       features. The function needs the user to pass the project path to the `path`
-       argument. More details in the [Configuration File](#configuration-file) section.
-
-     - `plot_feature_group_average_importance` makes the same excercise, but it
-       aggreagates (averages) feature importance metrics to the feature group
-       level and plots the relevance of each feature group. 
-
- - **Model Matrix characteristics**: _These function need the user to pass
-   Triage's project to the `path` argument. More details in the [Configuration
-   File](#configuration-file) section._
-   
-     - `cluster_correlation_features` shows a correlation matrix ordered by the
-         correlation between features. This plot can be subsetted by a feature
-         group and explore the correlation in that set of the feature space. 
-  
-     - `cluster_correlation_sparsity` renders an image with the prediction matrix
-       colored by their data availabilty. This plot can shows different
-       consequences of data imputation and help the user to visualize the
-       zero-only features (it happens with individual constant features). 
-  
-     - `plot_feature_distribution` plots the distribution of the top_n features
-       comparing the positive and negative labeled entities. A three-column plot
-       is rendered, the first two corresponding to the individual label plots,
-       and the third one corresponding to both. 
-
- - **Model Metrics**:
-   - `plot_ROC` plots the AUC-ROC curve plot for the selected model. This is
-     just a wrapper of the `sklearn` library function to be compatible with
-     triage.
-
-   - `plot_precision_recall_n` renders the precision/recall curves for the
-     desired model
-     
-   - `plot_recall_fpr_n` plots the false positive rate against the threshold of
-     absolute population (another way of exploring recall).
-
- - **Error Analysis**: Error analysis is a powerful tool to identify where the
-   model is making classification mistakes. Error analysis involves several
-   other hidden functions, but it can be completely run using the
-   `error_analysis` function. This function will label the errors and use
-   a `DecisionTreeClassifier` to classify the errors and print the modeled
-   tree. This function needs a parameters object defined in the configuration
-   file. More details in the [Configuration File](#configuration-file)
-   section.
-
- - **Crosstabs Analysis**: `crosstabs_ratio_plot` will plots the mean ratio for
-   all relevant features in the model. This allows a good comparison of
-   true/false predicted groups and get the key differences between groups in
-   the feature space. The function expects that the user run
-   [crosstabs](docs/sources/postmodeling/index.md#crosstabs)
-   first. 
-
-The `ModelEvaluator` also contain a set of miscellaneous methods to retrieve
-different model results: 
-
-|            method           |                                     Description                                    |
-|:---------------------------:|:----------------------------------------------------------------------------------:|
-|          `metadata`         | Table with model metadata elements. You can explore the class `.__dict__`  as well |
-|        `predictions`        | Returns a `pd.DataFrame` with model predictions                                    |
-|    `feature_importances`    | Returns a `pd.DataFrame` with model feature importances                            |
-| `feature_group_importances` | Returns a `pd.DataFrame` with the importances mean  per feature group              |
-|        `test_metrics`       | Returns a `pd.DataFrame` with test model evaluation metrics                        |
-|       `train_metrics`       | Returns a `pd.DataFrame` with train model evaluation metrics                       |
-|         `crosstabs`         | Returns a `pd.DataFrame` with model cross tabs (when available)                    |
-|        `preds_matrix`       | Returns a `pd.DataFrame` with the test matrix                                      |
-|        `train_matrix`       | Returns a `pd.DataFrame` with the train matrix                                     |
-
-The second method will help us to answer questions related with models across
-time. The `model_group_id` contains all equal specified models with different
-`as_of_dates` (test/validation dates). The `ModelGroupEvaluator`
-contains modules helpful for:
-
- - **Models behavior across time**:
-     - `plot_prec_across_time`: this function will render the metric behavior
-       across time. This metric can be any of the common used metric on the
-       triage evaluations (i.e. `precision`, `recall`, etc.). The function can
-       also take an user predefined baseline, which is defined in the
-       postmodeling configuration file.
-
-     - `feature_loi_loo`: will renders the same plot as the
-       `plot_prec_across_time`, but it will detect the model features and
-       identify if the included models are part of a LOO (leave-one-out) or LOI
-       (leave-one-in) experiment and label the models and they LOI or LOO
-       feature accordingly.
-
- - *Model group predictions and feature comparisons*: These functions listed
-   below allow the user to compare model predictions and feature importances
-   using different methods. Although, be aware that some comparisons between
-   individual models inside the model groups can be invalid (i.e. comparing the
-   `model_id = 1` of the `model_group_id = 1` with an `as_of_date = 2012-01-01`
-   with  the `model_id = 5` of the `model_group_id = 2` with an `as_of_date
-   = 2013-01-01`). For this reason all the functions listed include
-   a `temporal_comparison=False` argument. This option will group the models by
-   `as_of_date` and make comparisons only between same-prediction-time models. 
- 
-     - `plot_ranked_correlation_preds`: this function will plot a heatmap with
-        the predictions ranked correlation for each of the individual `model_group_id`
-        and its `model_id` (which are equal but with different test_date). This
-        function uses the hidden function `_rank_corr_df` which calculates the
-        correlation in a pairwise manner. For succesfuly compare predictions,
-        the user must especify a threshold metric (`param_type` and `param`) to
-        select the true positive predictions. 
-
-     - `plot_ranked_correlation_features`: just as the `_preds` function above,
-       this function will plot a heatmap with the rank correlation matrix for
-       each of the model groups (you can pass a `top_n_features` argument to
-       select the top-n features to compare). 
-
-      - `plot_jaccard_preds`: as the rank correlation functions, this function
-        compare the prediction set overlap between different model groups. This
-        function needs the user to pass a `param_type` and a `param` value to
-        select the true positive entities to compare.
-
-      - `plot_jaccard_features`: Jaccard overlap for feature importances. Just
-        as the above function, the function will plot the feature importance set
-        overlap for each model inside the model group. 
-
-      - `plot_preds_comparison`: plots the comparison of score distributions
-        across models in the model groups. This plot needs a `param_type` and
-        a `param` to define a threshold to define the false positives. 
-
-The `ModelGroupEvaluator` class also has different objects that can be useful
-for further analysis:
-
-|       method       | Description                                                                                                     |
-|:------------------:|-----------------------------------------------------------------------------------------------------------------|
-|     `metadata`     | Table with model group elements. You can explore the class `.__dict__`  as well                                 |
-|     `model_id`     | List of `model_id` inside each model group.                                                                     |
-|    `model_hash`    | List of `model_hash` inside each model group.                                                                   |
-|  `hyperparameters` | List of model group hyperparameters.                                                                            |
-|  `train_end_time`  | List of model group train end times.                                                                            |
-|    `model_type`    | List of model types for each model group.                                                                       |
-|    `predictions`   | Returns a `pd.DataFrame` with model predictions.                                                                |
-|  `feature_groups`  | Returns a `pd.DataFrame` with model feature groups  used by each model-group (also experiment type: LOI or LOO) |
-| `same_time_models` | Returns a `pd.DataFrame` with `as_of_dates` and  a list of models estimated in that date.                       | 
diff --git a/src/triage/component/postmodeling/contrast/model_evaluator.py b/src/triage/component/postmodeling/contrast/model_evaluator.py
deleted file mode 100644
index 1e84b0da4..000000000
--- a/src/triage/component/postmodeling/contrast/model_evaluator.py
+++ /dev/null
@@ -1,1198 +0,0 @@
-"""
-Model Evaluator
-
-This module will use the model_id as a modeling unit of analysis to answer
-different type of questions related with the quality and behavior of my
-predictions. The ModelEvaluator (and by extension de ModelGroupEvaluator) are
-part of the triage framework, hence they depend on the results schema
-structure, and the rest of the triage elements.
-
-ModelEvaluator will use a tuple: (model_group_id, model_id) to run diffent
-functions that will help the triage user to explore the final models, ideally
-selected by the Audition module. To initiate this classes, the user need to
-have a tuple and a SQLAlchemy engine object to call the necesary data from the
-SQL database.
-"""
-
-import pandas as pd
-import numpy as np
-import pickle
-import graphviz
-import matplotlib.patches as mpatches
-import seaborn as sns
-from adjustText import adjust_text
-from functools import partial
-from matplotlib import pyplot as plt
-from descriptors import cachedproperty
-from sklearn import metrics
-from sklearn import tree
-from triage.component.catwalk.storage import ProjectStorage, ModelStorageEngine, MatrixStorageEngine
-
-
-class ModelEvaluator(object):
-    '''
-    ModelExtractor class calls the model metadata from the database
-    and hold model_id metadata features on each of the class attibutes.
-    This class will contain any information about the model, and will be
-    used to make comparisons and calculations across models.
-
-    A pair of (model_group_id, model_id) is needed to instate the class. These
-    can be feeded from the get models_ids.
-    '''
-    def __init__(self, model_group_id, model_id, engine):
-        self.engine = engine
-        self.model_id = model_id
-        self.model_group_id = model_group_id
-
-    @cachedproperty
-    def metadata(self):
-        return next(self.engine.execute(
-                    f'''WITH
-                    individual_model_ids_metadata AS(
-                    SELECT m.model_id,
-                           m.model_group_id,
-                           m.hyperparameters,
-                           m.model_hash,
-                           m.train_end_time,
-                           m.train_matrix_uuid,
-                           m.training_label_timespan,
-                           m.model_type,
-                           mg.model_config
-                        FROM model_metadata.models m
-                        JOIN model_metadata.model_groups mg
-                        USING (model_group_id)
-                        WHERE model_group_id = {self.model_group_id}
-                        AND model_id = {self.model_id}
-                    ),
-                    individual_model_id_matrices AS(
-                    SELECT DISTINCT ON (matrix_uuid)
-                           model_id,
-                           matrix_uuid,
-                           evaluation_start_time as as_of_date
-                        FROM test_results.evaluations
-                        WHERE model_id = ANY(
-                            SELECT model_id
-                            FROM individual_model_ids_metadata
-                        )
-                    )
-                    SELECT metadata.*, test.*
-                    FROM individual_model_ids_metadata AS metadata
-                    LEFT JOIN individual_model_id_matrices AS test
-                    USING(model_id);''')
-        )
-
-    @property
-    def model_type(self):
-        return self.metadata['model_type']
-
-    @property
-    def hyperparameters(self):
-        return self.metadata['hyperparameters']
-
-    @property
-    def model_hash(self):
-        return self.metadata['model_hash']
-
-    @property
-    def train_matrix_uuid(self):
-        return self.metadata['train_matrix_uuid']
-
-    @property
-    def pred_matrix_uuid(self):
-        return self.metadata['matrix_uuid']
-
-    @property
-    def as_of_date(self):
-        return self.metadata['as_of_date']
-
-    def __repr__(self):
-        return f"ModelEvaluator(model_group_id={self.model_group_id}, model_id={self.model_id})"
-
-    @cachedproperty
-    def predictions(self):
-        preds = pd.read_sql(
-            f'''
-            SELECT model_id,
-                   entity_id,
-                   as_of_date,
-                   score,
-                   label_value,
-                   COALESCE(rank_abs, RANK() OVER(ORDER BY score DESC)) AS rank_abs,
-                   COALESCE(rank_pct, percent_rank()
-                   OVER(ORDER BY score DESC)) * 100 as rank_pct,
-                   test_label_timespan
-            FROM test_results.predictions
-            WHERE model_id = {self.model_id}
-            AND label_value IS NOT NULL
-            ''', con=self.engine)
-
-        if preds.empty:
-            raise RuntimeError("No predictions were retrieved from the database."
-                               "Some functionality will not be available without predictions."
-                               "Please run catwalk.Predictor for each desired model and test matrix"
-                               )
-        return preds
-
-    def _feature_importance_slr(self, path):
-        '''
-        Calculate feature importances for ScaledLogisticRegression
-
-        Since triage do not calculate the feature importances of
-        ScaledLogisticRegression by default, this function will call the model
-        object and calculate a feature importance proxy using the coefficients
-        of the regression.
-
-        Arguments:
-            - path (str): triage's project path, or a path to find the model
-            objects
-
-        Return:
-            - Dataframe with feature_importances
-        '''
-
-        storage = ProjectStorage(path)
-        model_obj = ModelStorageEngine(storage).load(self.model_hash)
-
-        test_matrix = self.preds_matrix(path)
-        feature_names = [x for x in test_matrix.column.tolist() 
-                         if x not in self.predictions.column.tolist()]
-
-        raw_importances = pd.DataFrame(
-            {'feature': feature_names,
-             'model_id':  test_matrix['model_id'],
-             'feature_importance':  np.abs(1 - np.exp(model_obj.coef_.squeeze())),
-             'feature_group': [x.split('_entity_id')[0] for x in
-                               feature_names]
-            }
-        )
-        raw_importances['rank_abs'] = raw_importances['feature_importance'].\
-                                      rank(method='max')
-
-        return raw_importances
-
-
-    def feature_importances(self, path=None):
-        if "ScaledLogisticRegression" in self.model_type:
-            features = self._feature_importance_slr(path)
-        else:
-            features = pd.read_sql(
-                f'''
-                SELECT model_id,
-                       feature,
-                       feature_importance,
-                       CASE
-                       WHEN feature like 'Algorithm does not support a standard way to calculate feature importance.'
-		    	       THEN 'No feature group'
-		               ELSE split_part(feature, '_', 1)
-		    	       END AS feature_group,
-                       rank_abs
-                FROM train_results.feature_importances
-                WHERE model_id = {self.model_id}
-                ''', con=self.engine)
-        return features
-
-
-    def feature_group_importances(self, path=None):
-        if "ScaledLogisticRegression" in self.model_type:
-            raw_importances = self._feature_importance_slr(path)
-            feature_groups = raw_importances.\
-                              groupby(['feature_group', 'model_id'])['feature_importance']\
-                                      .mean()\
-                                      .reset_index()
-            feature_groups = feature_groups.rename(index=str, 
-                                                   columns={"feature_importance":"importance_average"})
-        else:
-            feature_groups = pd.read_sql(
-            f'''
-			WITH
-			raw_importances AS(
-			SELECT
-			model_id,
-			feature,
-			feature_importance,
-			CASE
-			WHEN feature like 'Algorithm does not support a standard way to calculate feature importance.'
-			THEN 'No feature group'
-			ELSE split_part(feature, '_', 1)
-			END AS feature_group,
-			rank_abs
-			FROM train_results.feature_importances
-			WHERE model_id = {self.model_id}
-			)
-			SELECT
-			model_id,
-			feature_group,
-			avg(feature_importance) as importance_average
-			FROM raw_importances
-			GROUP BY feature_group, model_id
-			ORDER BY model_id, feature_group
-            ''', con=self.engine)
-
-        return feature_groups
-
-    @cachedproperty
-    def test_metrics(self):
-        model_test_metrics = pd.read_sql(
-            f'''
-            SELECT model_id,
-                   metric,
-                   parameter,
-                   value,
-                   num_labeled_examples,
-                   num_labeled_above_threshold,
-                   num_positive_labels
-            FROM test_results.evaluations
-            WHERE model_id = {self.model_id}
-            ''', con=self.engine)
-        return model_test_metrics
-
-    @cachedproperty
-    def train_metrics(self):
-        model_train_metrics = pd.read_sql(
-            f'''
-            SELECT model_id,
-                   metric,
-                   parameter,
-                   value,
-                   num_labeled_examples,
-                   num_labeled_above_threshold,
-                   num_positive_labels
-            FROM test_results.evaluations
-            WHERE model_id = {self.model_id}
-            ''', con=self.engine)
-        return model_train_metrics
-
-    @cachedproperty
-    def crosstabs(self):
-        model_crosstabs = pd.read_sql(
-            f'''
-            SELECT model_id,
-                   as_of_date,
-                   metric,
-                   feature_column,
-                   value,
-                   threshold_unit,
-                   threshold_value
-            FROM test_results.crosstabs
-            WHERE model_id = {self.model_id}
-            ''', con=self.engine)
-
-        return model_crosstabs
-
-    def preds_matrix(self, path):
-        '''
-        Load predictions matrices using the catwalk.storage.ProjectStorage.
-        This class allow the user to define a project path that can be either a
-        system local path or an s3 path and it will handle itself this
-        different infrastructures.
-
-        Once defined, we can pass this object to the MatrixStorageEngine that
-        will read this object and return a MatrixSotre object with a set of
-        handy methods to handle matrices
-
-        Arguments:
-            path: project path to initiate the ProjectStorage object
-        '''
-        cache = self.__dict__.setdefault('_preds_matrix_cache', {})
-        try:
-            return cache[path]
-        except KeyError:
-            pass
-
-        storage = ProjectStorage(path)
-        matrix_storage = MatrixStorageEngine(storage).get_store(self.pred_matrix_uuid)
-        mat = matrix_storage.design_matrix
-
-        # Merge with predictions table and return complete matrix
-        merged_df = pd.merge(mat,
-                             self.predictions,
-                             on=['entity_id', 'as_of_date'],
-                             how='inner',
-                             suffixes=('test', 'pred'))
-
-        cache[path] = merged_df
-        return merged_df
-
-    def train_matrix(self, path):
-        '''
-        Load predictions matrices using the catwalk.storage.ProjectStorage.
-        This class allow the user to define a project path that can be either a
-        system local path or an s3 path and it will handle itself this
-        different infrastructures.
-
-        Once defined, we can pass this object to the MatrixStorageEngine that
-        will read this object and return a MatrixSotre object with a set of
-        handy methods to handle matrices
-
-        Arguments:
-            path: project path to initiate the ProjectStorage object
-        '''
-        cache = self.__dict__.setdefault('_train_matrix_cache', {})
-        try:
-            return cache[path]
-        except KeyError:
-            pass
-
-        storage = ProjectStorage(path)
-        matrix_storage = MatrixStorageEngine(storage).get_store(self.train_matrix_uuid)
-        mat = matrix_storage.design_matrix
-
-        # Merge with predictions table and return complete matrix
-        merged_df = mat.merge(self.predictions,
-                             on='entity_id',
-                             how='inner',
-                             suffixes=('test', 'pred'))
-
-        cache[path] = mat
-        return mat
-
-    def plot_score_distribution(self,
-                                nbins=10,
-                               figsize=(16,12),
-                               fontsize=20):
-        '''
-        Generate an histograms with the raw distribution of the predicted
-        scores for all entities.
-            - Arguments:
-                - nbins: bins to plot in histogram (default is 10).
-                - label_names(tuple): define custom label names for class.
-                - figsize (tuple): specify size of plot.
-                - fontsize (int): define custom fontsize. 20 is set by default.
-
-        '''
-
-        df_ = self.predictions.filter(items=['score'])
-
-        fig, ax = plt.subplots(1, figsize=figsize)
-        plt.hist(df_.score,
-                 bins=nbins,
-                 normed=True,
-                 alpha=0.5,
-                 color='blue')
-        plt.axvline(df_.score.mean(),
-                    color='black',
-                    linestyle='dashed')
-        ax.set_ylabel('Frequency', fontsize=fontsize)
-        ax.set_xlabel('Score', fontsize=fontsize)
-        plt.title('Score Distribution', y =1.2,
-                  fontsize=fontsize)
-        plt.show()
-
-    def plot_score_label_distributions(self,
-                                       nbins=10,
-                                       label_names = ('Label = 0', 'Label = 1'),
-                                       figsize=(16, 12),
-                                       fontsize=20):
-        '''
-        Generate a histogram showing the label distribution for predicted
-        entities:
-            - Arguments:
-                - label_names(tuple): define custom label names for class.
-                - nbins: bins to plot in histogram (default is 10).
-                - figsize (tuple): specify size of plot.
-                - fontsize (int): define custom fontsize. 20 is set by default.
-        '''
-
-        df_predictions = self.predictions.filter(items=['score', 'label_value'])
-        df__0 = df_predictions[df_predictions.label_value == 0]
-        df__1 = df_predictions[df_predictions.label_value == 1]
-
-        fig, ax = plt.subplots(1, figsize=figsize)
-        plt.hist(df__0.score,
-                 bins=nbins,
-                 normed=True,
-                 alpha=0.5,
-                 color='skyblue',
-                 label=label_names[0])
-        plt.hist(list(df__1.score),
-                 bins=nbins,
-                 normed=True,
-                 alpha=0.5,
-                 color='orange',
-                 label=label_names[1])
-        plt.axvline(df__0.score.mean(),
-                    color='skyblue',
-                    linestyle='dashed')
-        plt.axvline(df__1.score.mean(),
-                    color='orange',
-                    linestyle='dashed')
-        plt.legend(bbox_to_anchor=(0., 1.005, 1., .102),
-                   loc=8,
-                   ncol=2,
-                   borderaxespad=0.,
-                   fontsize=fontsize-2)
-        ax.set_ylabel('Frequency', fontsize=fontsize)
-        ax.set_xlabel('Score', fontsize=fontsize)
-        plt.title('Score Distribution across Labels', y =1.2,
-                  fontsize=fontsize)
-        plt.show()
-
-    def plot_score_distribution_thresh(self,
-                                       param_type,
-                                       param,
-                                       nbins = 10,
-                                       label_names = ('Label = 0', 'Label = 1'),
-                                       figsize=(16, 12),
-                                       fontsize=20):
-        '''
-        Generate a histogram showing the label distribution for predicted
-        entities using a threshold to classify between good prediction or not.
-            - Arguments:
-                - param_type (str): parameter to use,
-                - param (int/float): threshold value to use
-                - nbins: bins to plot in histogram (default is 10).
-                - label_names(tuple): define custom label names for class.
-                - figsize (tuple): specify size of plot.
-                - fontsize (int): define custom fontsize. 20 is set by default.
-        '''
-        df_predictions = self.predictions
-
-        if param_type == 'rank_abs':
-            # Calculate residuals/errors
-            preds_thresh = df_predictions.sort_values(['rank_abs'], ascending=True)
-            preds_thresh['above_thresh'] = \
-                    np.where(preds_thresh['rank_abs'] <= param/100, 1, 0)
-        elif param_type == 'rank_pct':
-            # Calculate residuals/errors
-            preds_thresh = df_predictions.sort_values(['rank_pct'], ascending=True)
-            preds_thresh['above_thresh'] = \
-                    np.where(preds_thresh['rank_pct'] <= param/100, 1, 0)
-        else:
-            raise ValueError('''Error! You have to define a parameter type to
-                                 set up a threshold
-                                 ''')
-        df__0 = df_predictions[df_predictions.label_value == 0]
-        df__1 = df_predictions[df_predictions.label_value == 1]
-
-        # Split dataframe for plotting
-        #preds_above_thresh = preds_thresh[preds_thresh['above_thresh'] == 1]
-        #preds_below_thresh = preds_thresh[preds_thresh['above_thresh'] == 0]
-        threshold_value = preds_thresh[preds_thresh['above_thresh'] == 1].score.min()
-        fig, ax = plt.subplots(1, figsize=figsize)
-        plt.hist(df__0.score,
-                 bins=nbins,
-                 normed=True,
-                 alpha=0.5,
-                 color='skyblue',
-                 label=label_names[0])
-        plt.hist(df__1.score,
-                 bins=nbins,
-                 normed=True,
-                 alpha=0.5,
-                 color='orange',
-                 label=label_names[1])
-        plt.axvline(threshold_value,
-                    color='black',
-                    linestyle='dashed')
-        plt.legend(bbox_to_anchor=(0., 1.005, 1., .102),
-                   loc=8,
-                   ncol=2,
-                   borderaxespad=0.,
-                   fontsize=fontsize-2)
-        ax.set_ylabel('Density', fontsize=fontsize)
-        ax.set_xlabel('Score', fontsize=fontsize)
-        plt.title('Score Distribution using prediction threshold', y=1.2,
-                  fontsize=fontsize)
-
-
-    def plot_feature_importances(self,
-                                 path,
-                                 n_features_plots=30,
-                                 figsize=(16, 12),
-                                 fontsize=20):
-        '''
-        Generate a bar chart of the top n feature importances (by absolute value)
-        Arguments:
-                - save_file (bool): save file to disk as png. Default is False.
-                - path (str): path to triage project_dir 
-                - name_file (string): specify name file for saved plot.
-                - n_features_plots (int): number of top features to plot
-                - figsize (tuple): figure size to pass to matplotlib
-                - fontsize (int): define custom fontsize for labels and legends.
-        '''
-
-        importances = self.feature_importances(path=path)
-        importances = importances.filter(items=['feature', 'feature_importance'])
-        importances = importances.set_index('feature')
-
-        # Sort by the absolute value of the importance of the feature
-        importances['sort'] = abs(importances['feature_importance'])
-        importances = \
-                importances.sort_values(by='sort', ascending=False).drop('sort', axis=1)
-        importances = importances[0:n_features_plots]
-
-        # Show the most important positive feature at the top of the graph
-        importances = importances.sort_values(by='feature_importance', ascending=True)
-
-        fig, ax = plt.subplots(figsize=figsize)
-        ax.tick_params(labelsize=16)
-        importances.plot(kind="barh", legend=False, ax=ax)
-        ax.set_frame_on(False)
-        ax.set_xlabel('Feature Importance', fontsize=20)
-        ax.set_ylabel('Feature', fontsize=20)
-        plt.tight_layout()
-        plt.title(f'Top {n_features_plots} Feature Importances',
-                  fontsize=fontsize).set_position([.5, 0.99])
-
-    def plot_feature_importances_std_err(self,
-                                         path,
-                                         bar=True,
-                                         n_features_plots=30,
-                                         figsize=(16,21),
-                                         fontsize=20):
-        '''
-        Generate a bar chart of the top n features importances showing the
-        error bars. This plot is valid for ensemble classifiers (i.e. Random
-        Forests or ExtraTrees), where many classifiers are bootstraped in
-        estimation. This plot will allow the user to explore the feature
-        importance variation inside the ensemble classifier.
-
-        Arguments:
-                - save_file (bool): save file to disk as png. Default is False.
-                - name_file (string): specify name file for saved plot.
-                - bar (bool): Should we plot a barplot or a scatter plot. If
-                true, it will print a bar plot (set True by default).
-                - n_features_plots (int): number of top features to plot.
-                - figsize (tuple): figuresize to pass to matplotlib.
-                - fontsize (int): define a custom fontsize for labels and legends.
-                - *path: path to retrieve model pickle
-        '''
-        if 'sklearn.ensemble' in self.model_type: 
-
-            storage = ProjectStorage(path)
-            model_object = ModelStorageEngine(storage).load(self.model_hash)
-            matrix_object = MatrixStorageEngine(storage).get_store(self.pred_matrix_uuid)
-
-            # Calculate errors from model
-            importances = model_object.feature_importances_
-            std = np.std([tree.feature_importances_ for tree in model_object.estimators_],
-                        axis=0)
-            # Create dataframe and sort select the most relevant features (defined
-            # by n_features_plot)
-            importances_df = pd.DataFrame({
-                'feature_name': matrix_object.columns(),
-                'std': std,
-                'feature_importance': importances
-            }).set_index('feature_name')
-
-            importances_sort = \
-            importances_df.sort_values(['feature_importance'], ascending=False)
-            importances_filter = importances_sort[:n_features_plots]
-
-            # Plot features in order
-            importances_ordered = \
-            importances_filter.sort_values(['feature_importance'], ascending=True)
-
-
-            if bar:
-                # Plot features with sd bars
-                fig, ax = plt.subplots(figsize=figsize)
-                ax.tick_params(labelsize=16)
-                importances_ordered['feature_importance'].\
-                                   plot.barh(legend=False, 
-                                             ax=ax,
-                                             xerr=importances_ordered['std'],
-                                             color='b')
-                ax.set_frame_on(False)
-                ax.set_xlabel('Feature Importance', fontsize=20)
-                ax.set_ylabel('Feature', fontsize=20)
-                plt.tight_layout()
-                plt.title(f'Top {n_features_plots} Feature Importances with SD',
-                          fontsize=fontsize).set_position([.5, 0.99])
-
-            else:
-                fig, ax = plt.subplots(figsize=figsize)
-                ax.tick_params(labelsize=16)
-                importances_ordered.plot.scatter(x = 'std',
-                                                 y = 'feature_importance',
-                                                 legend=False,
-                                                 ax=ax)
-                ax.set_xlabel('Std. Error', fontsize=20)
-                ax.set_ylabel('Feature Importance', fontsize=20)
-                plt.title(f'Top {n_features_plots} Feature Importances against SD',
-                          fontsize=fontsize).set_position([.5, 0.99])
-                feature_labels = []
-                for k, v in importances_ordered.iterrows():
-                    feature_labels.append(plt.text(v[0], v[1], k))
-                adjust_text(feature_labels,
-                            arrow_props=dict(arrowstype='->',
-                                            color='r',
-                                            lw=1))
-        else:
-            raise ValueError(f'''
-            This plot is only available for Ensemble models, not
-            {self.model_type}
-            ''')
-
-    def plot_feature_group_average_importances(self,
-                                               n_features_plots=30,
-                                               figsize=(16, 12),
-                                               fontsize=20,
-                                               path=None):
-        '''
-        Generate a bar chart of the average feature group importances (by absolute value)
-        Arguments:
-                - save_file (bool): save file to disk as png. Default is False.
-                - path (str): path to the triage's project_path
-                - name_file (string): specify name file for saved plot.
-                - n_features_plots (int): number of top features to plot
-                - figsize (tuple): figure size to pass to matplotlib
-                - fontsize (int): define custom fontsize for labels and legends.
-        '''
-
-        fg_importances = self.feature_group_importances(path=path)
-        fg_importances = fg_importances.filter(items=['feature_group', \
-                                               'importance_average'])
-        fg_importances = fg_importances.set_index('feature_group')
-
-        # Sort by the absolute value of the importance of the feature
-        fg_importances['sort'] = abs(fg_importances['importance_average'])
-        fg_importances = \
-                fg_importances.sort_values(by='sort', ascending=False).drop('sort', axis=1)
-
-        # Show the most important positive feature at the top of the graph
-        importances = fg_importances.sort_values(by='importance_average', ascending=True)
-
-        fig, ax = plt.subplots(figsize=figsize)
-        ax.tick_params(labelsize=16)
-        importances.plot(kind="barh", legend=False, ax=ax)
-        plt.setp(ax.get_xticklabels(), rotation=45, fontsize=15)
-        ax.set_xlabel('Feature Importance', fontsize=20)
-        ax.set_ylabel('Feature Group', fontsize=20)
-        plt.tight_layout()
-        plt.title(f'Feature Group Importances',
-                  fontsize=fontsize).set_position([.5, 1.0])
-
-
-    def cluster_correlation_features(self,
-                                     path,
-                                     feature_group_subset_list=None,
-                                     cmap_color_fgroups='Accent',
-                                     cmap_heatmap='mako',
-                                     figsize=(16,16),
-                                     fontsize=12):
-        '''
-        Plot correlation in feature space
-
-        This function simply renders the correlation between features and uses
-        hierarchical clustering to identify cluster of features. The idea bhind
-        this plot is not only to explore the correlation in the space, but also
-        to explore is this correlation is comparable with the feature groups.
-        Arguments:
-            - path (string): Project directory where to find matrices and
-            models. Usually is under 'triage/outcomes/'
-            - feature_group_subset_list (list): list of feature groups to plot.
-            By default, the function uses all the feature groups.
-            - cmap_color_fgroups (string): matplotlib pallete to color the
-            feature groups.
-            - cmap_heatmap (string):seaborn/matplotlib pallete to color the
-            correlation/clustering matrix
-            - figsize (tuple): define size of the plot (please use square
-            dimensions)
-            - fontsize (string): define size of plot title and axes.
-         '''
-        if feature_group_subset_list is None:
-             feature_group_subset = self.feature_importances(path).feature_group.unique()
-             feature_regex = '|'.join(feature_group_subset)
-        else:
-             feature_group_subset = feature_group_subset_list
-             feature_regex = '|'.join(feature_group_subset_list)
-
-        # Load Prediction Matrix
-        test_matrix = self.preds_matrix(path)
-
-        # Define feature space (remove predictions)
-        storage = ProjectStorage(path)
-        matrix_storage = \
-        MatrixStorageEngine(storage).get_store(self.pred_matrix_uuid)
-        feature_columns = matrix_storage.columns()
-
-        # Prepare and calculate feature correlation
-        test_matrix = test_matrix[feature_columns]
-        test_matrix_filter = test_matrix.filter(regex=feature_regex)
-        feature_groups = [x.split('_', 1)[0] for x in \
-                          test_matrix_filter.columns.tolist()]
-        corr = test_matrix_filter.corr()
-
-        # Define feature groups and colors
-        feature_groups = pd.DataFrame(feature_groups,
-                              columns = ['feature_group'],
-                              index = corr.index.tolist())
-
-        cmap = plt.get_cmap(cmap_color_fgroups)
-        colors = cmap(np.linspace(0, 1,
-                                  len(feature_groups.feature_group.unique())))
-        lut = dict(zip(feature_groups.feature_group.unique(), colors))
-        row_colors = feature_groups.feature_group.map(lut)
-
-        legend_feature_groups = \
-                [mpatches.Patch(color=value, label=key) for key,value in \
-                 lut.items()]
-
-        # Plot correlation/cluster map
-        ax = sns.clustermap(corr.fillna(0),
-                       row_colors=row_colors,
-                       cmap=cmap_heatmap)
-        plt.title(f'Clustered Correlation matrix plot for {self.model_id}',
-                  fontsize=fontsize)
-        plt.legend(handles=legend_feature_groups,
-                   title= 'Feature Group',
-                   bbox_to_anchor=(0., 1.005, 1., .102),
-                   loc=7,
-                   borderaxespad=0.)
-
-
-    def cluster_correlation_sparsity(self,
-                                     path,
-                                     figsize=(20,20),
-                                     fontsize=12):
-         '''
-        Plot sparcity in feature space
-
-        This function simply renders the correlation between features and uses
-        hierarchical clustering to identify cluster of features. The idea bhind
-        this plot is not only to explore the correlation in the space, but also
-        to explore is this correlation is comparable with the feature groups.
-        Arguments:
-            - path (string): Project directory where to find matrices and
-            models. Usually is under 'triage/outcomes/'
-            - cmap_heatmap (string):seaborn/matplotlib pallete to color the
-            correlation/clustering matrix
-            - figsize (tuple): define size of the plot (please use square
-            dimensions)
-            - fontsize (string): define size of plot title and axes.
-         '''
-
-         # Load Prediction Matrix
-         test_matrix = self.preds_matrix(path)
-
-         # Define feature space (remove predictions)
-         storage = ProjectStorage(path)
-         matrix_storage = \
-         MatrixStorageEngine(storage).get_store(self.pred_matrix_uuid)
-         feature_columns = matrix_storage.columns()
-
-         # Prepare and calculate feature correlation
-         test_matrix = test_matrix[feature_columns]
-
-         # Create sparse matrix
-         # 1: Values with more than 0, and 0 to values with 0
-         sparse_feature_matrix = test_matrix.where(test_matrix == 0).fillna(1)
-         sparse_feature_matrix_filter = sparse_feature_matrix.apply(lambda x: \
-                                                            x.sort_values().values)
-
-         sparse_feature_matrix = test_matrix.where(test_matrix == 0).fillna(1)
-         sparse_feature_matrix_filter = \
-                sparse_feature_matrix.apply(lambda x: x.sort_values().values)
-         num_zeros = sparse_feature_matrix.sum(axis=0)
-         sparse_feature_matrix_filter_columns = \
-                 sparse_feature_matrix_filter[num_zeros. \
-                                              sort_values(ascending=False).index.values]
-
-		 # Plot matrix
-         fig, ax = plt.subplots(figsize=figsize)
-         plt.title(f'Feature space sparse matrix for {self.model_id}',
-                   fontsize=fontsize)
-         ax.set_xlabel('Features', fontsize=fontsize)
-         ax.set_ylabel('Entity ID', fontsize=fontsize)
-         cbar_kws = {'ticks': range(2)}
-         sns.heatmap(sparse_feature_matrix_filter_columns,
-                     cmap=sns.color_palette("hls", 2),
-                     cbar_kws=cbar_kws)
-
-
-    def compute_AUC(self):
-        '''
-        Utility function to generate ROC and AUC data to plot ROC curve
-        Returns (tuple):
-            - (false positive rate, true positive rate, thresholds, AUC)
-        '''
-
-        label_ = self.predictions.label_value
-        score_ = self.predictions.score
-        fpr, tpr, thresholds = metrics.roc_curve(
-            label_, score_, pos_label=1)
-
-        return (fpr, tpr, thresholds, metrics.auc(fpr, tpr))
-
-
-    def plot_ROC(self,
-                 figsize=(16, 12),
-                 fontsize=20):
-        '''
-        Plot an ROC curve for this model and label it with AUC
-        using the sklearn.metrics methods.
-        Arguments:
-            - figsize (tuple): figure size to pass to matplotlib
-            - fontsize (int): fontsize for title. Default is 20.
-        '''
-
-        fpr, tpr, thresholds, auc = self.compute_AUC()
-        auc = "%.2f" % auc
-
-        title = 'ROC Curve, AUC = ' + str(auc)
-        fig, ax = plt.subplots(figsize=figsize)
-        ax.plot(fpr, tpr, "#000099", label='ROC curve')
-        ax.plot([0, 1], [0, 1], 'k--', label='Baseline')
-        plt.xlim([0.0, 1.0])
-        plt.ylim([0.0, 1.05])
-        plt.xlabel('False Positive Rate', fontsize=fontsize)
-        plt.ylabel('True Positive Rate', fontsize=fontsize)
-        plt.legend(loc='lower right')
-        plt.title(title, fontsize=fontsize)
-        plt.show()
-
-    def plot_recall_fpr_n(self,
-                          figsize=(16, 12),
-                          fontsize=20):
-        '''
-        Plot recall and the false positive rate against depth into the list
-        (esentially just a deconstructed ROC curve) along with optimal bounds.
-        Arguments:
-            - figsize (tuple): define a plot size to pass to matplotlib
-            - fontsize (int): define a custom font size to labels and axes
-        '''
-
-
-        _labels = self.predictions.filter(items=['label_value', 'score'])
-
-        # since tpr and recall are different names for the same metric, we can just
-        # grab fpr and tpr from the sklearn function for ROC
-        fpr, recall, thresholds, auc = self.compute_AUC()
-
-        # turn the thresholds into percent of the list traversed from top to bottom
-        pct_above_per_thresh = []
-        num_scored = float(len(_labels.score))
-        for value in thresholds:
-            num_above_thresh = len(_labels.loc[_labels.score >= value, 'score'])
-            pct_above_thresh = num_above_thresh / num_scored
-            pct_above_per_thresh.append(pct_above_thresh)
-        pct_above_per_thresh = np.array(pct_above_per_thresh)
-
-        # plot the false positive rate, along with a dashed line showing the optimal bounds
-        # given the proportion of positive labels
-        plt.clf()
-        fig, ax1 = plt.subplots(figsize=figsize)
-        ax1.plot([_labels.label_value.mean(), 1], [0, 1], '--', color='gray')
-        ax1.plot([0, _labels.label_value.mean()], [0, 0], '--', color='gray')
-        ax1.plot(pct_above_per_thresh, fpr, "#000099")
-        plt.title('Deconstructed ROC Curve\nRecall and FPR vs. Depth',fontsize=fontsize)
-        ax1.set_xlabel('Proportion of Population', fontsize=fontsize)
-        ax1.set_ylabel('False Positive Rate', color="#000099", fontsize=fontsize)
-        plt.ylim([0.0, 1.05])
-
-
-    def plot_precision_recall_n(self,
-                                figsize=(16, 12),
-                                fontsize=20):
-        """
-        Plot recall and precision curves against depth into the list.
-        """
-
-
-        _labels = self.predictions.filter(items=['label_value', 'score'])
-
-        y_score = _labels.score
-        precision_curve, recall_curve, pr_thresholds = \
-            metrics.precision_recall_curve(_labels.label_value, y_score)
-
-        precision_curve = precision_curve[:-1]
-        recall_curve = recall_curve[:-1]
-
-        # a little bit of a hack, but ensure we start with a cut-off of 0
-        # to extend lines to full [0,1] range of the graph
-        pr_thresholds = np.insert(pr_thresholds, 0, 0)
-        precision_curve = np.insert(precision_curve, 0, precision_curve[0])
-        recall_curve = np.insert(recall_curve, 0, recall_curve[0])
-
-        pct_above_per_thresh = []
-        number_scored = len(y_score)
-        for value in pr_thresholds:
-            num_above_thresh = len(y_score[y_score >= value])
-            pct_above_thresh = num_above_thresh / float(number_scored)
-            pct_above_per_thresh.append(pct_above_thresh)
-        pct_above_per_thresh = np.array(pct_above_per_thresh)
-
-        plt.clf()
-        fig, ax1 = plt.subplots(figsize=figsize)
-        ax1.plot(pct_above_per_thresh, precision_curve, "#000099")
-        ax1.set_xlabel('Proportion of population', fontsize=fontsize)
-        ax1.set_ylabel('Precision', color="#000099", fontsize=fontsize)
-        plt.ylim([0.0, 1.05])
-        ax2 = ax1.twinx()
-        ax2.plot(pct_above_per_thresh, recall_curve, "#CC0000")
-        ax2.set_ylabel('Recall', color="#CC0000", fontsize=fontsize)
-        plt.xlim([0.0, 1.0])
-        plt.ylim([0.0, 1.05])
-        plt.title("Precision-recall at x-proportion", fontsize=fontsize)
-        plt.show()
-
-    def _error_labeler(self,
-                      path,
-                      param=None,
-                      param_type=None):
-        '''
-        Explore the underlying causes of errors using decision trees to explain the
-        residuals base on the same feature space used in the model. This
-        exploration will get the most relevant features that determine y - y_hat
-        distance and may help to understand the outomes of some models.
-
-        This function will label the errors and return two elements relevant to
-        model these. First, a feature matrix (X) with all the features used by
-        the model. Second, an iterator with different labeled errors: FPR, FRR,
-        and the general error.
-
-        Arguments:
-            - param_type: (str) type of parameter to define a threshold. Possible
-              values come from triage evaluations: rank_abs, or rank_pct
-            - param: (int) value
-            - path: path for the ProjectStorage class object
-        '''
-
-        test_matrix = self.preds_matrix(path)
-
-        if param_type == 'rank_abs':
-            # Calculate residuals/errors
-            test_matrix_thresh = test_matrix.sort_values(['rank_abs'], ascending=True)
-            test_matrix_thresh['above_thresh'] = \
-                    np.where(test_matrix_thresh['rank_abs'] <= param, 1, 0)
-            test_matrix_thresh['error'] = test_matrix_thresh['label_value'] - \
-                    test_matrix_thresh['above_thresh']
-        elif param_type == 'rank_pct':
-            # Calculate residuals/errors
-            test_matrix_thresh = test_matrix.sort_values(['rank_pct'], ascending=True)
-            test_matrix_thresh['above_thresh'] = \
-                    np.where(test_matrix_thresh['rank_pct'] <= param, 1, 0)
-            test_matrix_thresh['error'] = test_matrix_thresh['label_value'] - \
-                    test_matrix_thresh['above_thresh']
-        else:
-            raise AttributeError('''Error! You have to define a parameter type to
-                                 set up a threshold
-                                 ''')
-
-        # Define labels using the errors
-        dict_errors = {'FP': (test_matrix_thresh['label_value'] == 0) &
-                              (test_matrix_thresh['above_thresh'] == 1),
-                       'FN': (test_matrix_thresh['label_value'] == 1) &
-                              (test_matrix_thresh['above_thresh'] == 0),
-                       'TP':  (test_matrix_thresh['label_value'] == 1) &
-                              (test_matrix_thresh['above_thresh'] == 1),
-                       'TN':  (test_matrix_thresh['label_value'] == 0) &
-                              (test_matrix_thresh['above_thresh'] == 0)
-                      }
-        test_matrix_thresh['class_error'] = np.select(condlist=dict_errors.values(),
-                                                     choicelist=dict_errors.keys(),
-                                                     default=None)
-
-        # Split data frame to explore FPR/FNR against TP and TN
-        test_matrix_thresh_0 = \
-        test_matrix_thresh[test_matrix_thresh['label_value'] == 0]
-        test_matrix_thresh_1 = \
-        test_matrix_thresh[test_matrix_thresh['label_value'] == 1]
-        test_matrix_predicted_1 = \
-        test_matrix_thresh[test_matrix_thresh['above_thresh'] == 1]
-
-        dict_error_class = {'FPvsAll': (test_matrix_thresh['class_error'] == 'FP'),
-                            'FNvsAll': (test_matrix_thresh['class_error'] == 'FN'),
-                            'FNvsTP': (test_matrix_thresh_1['class_error'] == 'FN'),
-                            'FPvsTN': (test_matrix_thresh_0['class_error'] == 'FP'),
-                            'FPvsTP': (test_matrix_predicted_1['class_error'] == 'FP')}
-
-        # Create label iterator
-        Y = [(np.where(condition, 1, -1), label) for label, condition in \
-             dict_error_class.items()]
-
-        # Define feature space to model: get the list of feature names
-        storage = ProjectStorage(path)
-        matrix_storage = MatrixStorageEngine(storage).get_store(self.pred_matrix_uuid)
-        feature_columns = matrix_storage.columns()
-
-        # Build error feature matrix
-        matrices = [test_matrix_thresh,
-                    test_matrix_thresh,
-                    test_matrix_thresh_1,
-                    test_matrix_thresh_0,
-                    test_matrix_predicted_1]
-        X = [matrix[feature_columns] for matrix in matrices]
-
-        return zip(Y, X)
-
-    def _error_modeler(self,
-                      depth=None,
-                      view_plots=False,
-                      **kwargs):
-       '''
-       Model labeled errors (residuals) by the error_labeler (FPR, FNR, and
-       general residual) using a RandomForestClassifier. This function will
-       yield a plot tree for each of the label numpy arrays return by the
-       error_labeler (Y).
-       Arguments:
-           - depth: max number of tree partitions. This is passed directly to
-             the classifier.
-           - view_plot: the plot is saved to disk by default, but the
-             graphviz.Source also allow to load the object and see it in the
-             default OS image renderer
-           - **kwargs: more arguments passed to the labeler: param indicating
-             the threshold value, param_type indicating the type of threshold,
-             and the path to the ProjectStorage.
-       '''
-
-       # Get matrices from the labeler
-       zip_data = self._error_labeler(param_type = kwargs['param_type'],
-                                  param = kwargs['param'],
-                                  path=kwargs['path'])
-
-       # Model tree and output tree plot
-       for error_label, matrix in zip_data:
-
-           dot_path = 'error_analysis_' + \
-                      str(error_label[1]) + '_' + \
-                      str(self.model_id) + '_' + \
-                      str(kwargs['param_type']) + '@'+ \
-                      str(kwargs['param']) +  '.gv'
-
-           clf = tree.DecisionTreeClassifier(max_depth=depth)
-           clf_fit = clf.fit(matrix, error_label[0])
-           tree_viz = tree.export_graphviz(clf_fit,
-                                           out_file=None,
-                                           feature_names=matrix.columns.values,
-                                           filled=True,
-                                           rounded=True,
-                                           special_characters=True)
-           graph = graphviz.Source(tree_viz)
-           graph.render(filename=dot_path,
-                        directory='error_analysis',
-                        view=view_plots)
-
-           print(dot_path)
-
-    def error_analysis(self, threshold, **kwargs):
-        '''
-        Error analysis function for ThresholdIterator objects. This function
-        have the same functionality as the _error.modeler method, but its
-        implemented for iterators, which can be a case use of this analysis.
-        If no iterator object is passed, the function will take the needed
-        arguments to run the _error_modeler.
-        Arguments:
-            - threshold: a threshold and threshold parameter combination passed
-            to the PostmodelingParamters. If multiple parameters are passed,
-            the function will iterate through them.
-            -**kwags: other arguments passed to _error_modeler
-        '''
-
-        error_modeler = partial(self._error_modeler,
-                               depth = kwargs['depth'],
-                               path = kwargs['path'],
-                               view_plots = kwargs['view_plots'])
-
-        if isinstance(threshold, dict):
-           for threshold_type, threshold_list in threshold.items():
-               for threshold in threshold_list:
-                   print(threshold_type, threshold)
-                   error_modeler(param_type = threshold_type,
-                                 param = threshold)
-        else:
-           error_modeler(param_type=kwargs['param_type'],
-                         param=kwargs['param'])
-
-
-    def crosstabs_ratio_plot(self,
-                             n_features=30,
-                             figsize=(12,16),
-                             fontsize=20):
-        '''
-        Plot to visualize the top-k features with the highest mean ratio. This
-        plot will show the biggest quantitative differences between the labeled/predicted
-        groups
-        '''
-        crosstabs_ratio = self.crosstabs.loc[self.crosstabs.metric == \
-                          'ratio_predicted_positive_over_predicted_negative']
-        crosstabs_ratio_subset = crosstabs_ratio.sort_values(by=['value'],
-                                 ascending=False)[:n_features]
-        crosstabs_ratio_plot = \
-        crosstabs_ratio_subset.filter(items=['feature_column','value']).\
-                set_index('feature_column').\
-                sort_values(['value'])
-
-        fig, ax = plt.subplots(figsize=figsize)
-        ax.tick_params(labelsize=16)
-        crosstabs_ratio_plot.plot(kind="barh", legend=False, ax=ax)
-        ax.set_frame_on(False)
-        ax.set_xlabel('Ratio means (positive/negative)', fontsize=20)
-        ax.set_ylabel('Feature', fontsize=20)
-        plt.tight_layout()
-        plt.title(f'Top {n_features} features with higher mean ratio',
-                  fontsize=fontsize).set_position([.5, 0.99])
-
-    def plot_feature_distribution(self,
-                                  path,
-                                  feature_list=None):
-        '''
-        Plot feature distributions (and compare feature distributions across
-        labels)
-        '''
-
-        if feature_list is None:
-            f_importances = self.feature_importances(path)
-            top_f = f_importances[f_importances['rank_abs'] <= 10]['feature'].tolist()
-            feature_list = top_f
-
-        n = len(feature_list)
-
-        fig, axs = plt.subplots(n, 3, figsize=(20,7*n))
-        axs = axs.ravel()
-
-        matrix = self.preds_matrix(path=path)
- 
-        for idx,feature in enumerate(feature_list):
-            i1 = 3*idx 
-            i2 = 3*idx + 1
-            i3 = 3*idx + 2
-            f_0 = matrix[matrix.label_value==0][feature]
-            f_1 = matrix[matrix.label_value==1][feature]
-
-            if len(matrix[feature].unique()) == 2:
-                axs[i1].hist(f_0,bins=20,normed=True,alpha=0.5, 
-                             label=str(yr), color=colors[yr], histtype='step')
-                axs[i2].hist(f_1,bins=20,normed=True,alpha=0.5, 
-                             label=str(yr), color=colors[yr], linestyle="--",histtype='step')
-                axs[i3].hist(f_0,bins=20,normed=True,alpha=0.8,histtype='step',
-                             label=str(yr), color=colors[yr])
-                axs[i3].hist(f_1,bins=20,normed=True,alpha=1, linestyle="--",histtype='step',
-                             label=str(yr), color=colors[yr])
-            else:
-                sns.distplot(matrix[matrix.label_value == 0][feature], 
-                             hist=False, 
-                             kde=True, 
-                             kde_kws={'linewidth': 2}, 
-                             ax=axs[i1]
-                        )
-                sns.distplot(matrix[matrix.label_value == 1][feature], 
-                             hist=False, 
-                             kde=True, 
-                             kde_kws={'linewidth': 2, 'linestyle':'--'}, 
-                             ax=axs[i2]
-                        )
-                sns.distplot(f_0, 
-                             hist=False, 
-                             kde=True, 
-                             kde_kws={'linewidth': 2} , 
-                             ax=axs[i3])
-                sns.distplot(f_1, 
-                             hist=False, 
-                              kde=True, 
-                             kde_kws={'linewidth': 2, 'linestyle':'--'}, 
-                             ax=axs[i3])
-
-            axs[i1].legend()
-            axs[i1].set_title("0 class")
-            axs[i1].set_xlabel(feature)
-            axs[i2].legend()
-            axs[i2].set_title("1 class")
-            axs[i2].set_xlabel(feature)
-            axs[i3].legend()
-            axs[i3].set_title("All classes")
-            axs[i3].set_xlabel(feature)
-    plt.tight_layout()
-    plt.show()
-
diff --git a/src/triage/component/postmodeling/contrast/model_group_evaluator.py b/src/triage/component/postmodeling/contrast/model_group_evaluator.py
deleted file mode 100644
index 23b8ed455..000000000
--- a/src/triage/component/postmodeling/contrast/model_group_evaluator.py
+++ /dev/null
@@ -1,1210 +0,0 @@
-"""
-Model Evaluator
-
-This script contain a set of elements to help the postmodeling evaluation
-of audited models by triage.Audition. This will be a continuing list of
-routines that can be scaled up and grow according to the needs of the
-project, or other postmodeling approaches.
-
-"""
-import itertools
-import pandas as pd
-import numpy as np
-import seaborn as sns
-from descriptors import cachedproperty
-from matplotlib import pyplot as plt
-from itertools import combinations
-from scipy.spatial.distance import squareform, pdist
-from scipy.stats import spearmanr
-
-# Get indivual model information/metadata from Audition output
-
-
-class ModelGroupEvaluator(object):
-    '''
-    ModelGroup class calls the model group metadata from the database
-    and hold metadata features on each of the class attibutes.
-    This class will contain any information about the model_group, and
-    will be used to make comparisons and calculations across models.
-
-    A model_group_id list is needed to instate the class.
-    '''
-    def __init__(self, model_group_id, engine):
-
-        self.engine = engine
-
-        if len(model_group_id) == 1:
-            self.model_group_id = model_group_id + model_group_id
-        else:
-            self.model_group_id = model_group_id
-
-    @cachedproperty
-    def metadata(self):
-        query_execute = list(self.engine.execute(
-            f'''
-            SELECT m.model_id,
-                   m.model_group_id,
-                   m.hyperparameters,
-                   m.model_hash,
-                   m.train_end_time,
-                   m.train_matrix_uuid,
-                   m.training_label_timespan,
-                   m.model_type,
-                   mg.model_config
-                FROM model_metadata.models m
-                JOIN model_metadata.model_groups mg
-                USING (model_group_id)
-                WHERE model_group_id IN {self.model_group_id}
-            ''')
-        )
-
-        row_dict, list_dict = {}, []
-        for row in query_execute:
-            for tup in row.items():
-                row_dict = {**row_dict, **{tup[0]: tup[1]}}
-            list_dict.append(row_dict)
-
-        return list_dict
-
-    @property
-    def model_id(self):
-        return [dict_row['model_id'] for dict_row in self.metadata]
-
-    @property
-    def model_hash(self):
-        return [dict_row['model_hash'] for dict_row in self.metadata]
-
-    @property
-    def hyperparameters(self):
-        return [dict_row['hyperparameters'] for dict_row in self.metadata]
-
-    @property
-    def train_end_time(self):
-        return [dict_row['train_end_time'] for dict_row in self.metadata]
-
-    @property
-    def train_matrix_uuid(self):
-        return [dict_row['train_matrix_uuid'] for dict_row in self.metadata]
-
-    @property
-    def training_label_timespan(self):
-        return [dict_row['training_label_timespan'] for dict_row in self.metadata]
-
-    @property
-    def model_type(self):
-        return [dict_row['model_type'] for dict_row in self.metadata]
-
-    @property
-    def model_config(self):
-        return [dict_row['model_config'] for dict_row in self.metadata]
-
-    def __repr__(self):
-        return f"ModelGroupEvaluator(model_group_id={self.model_group_id})"
-
-    @cachedproperty
-    def predictions(self):
-        preds = pd.read_sql(
-            f'''
-            SELECT
-                   g.model_group_id,
-                   m.model_id,
-                   m.entity_id,
-                   m.as_of_date,
-                   EXTRACT('YEAR' from m.as_of_date) AS as_of_date_year,
-                   m.score,
-                   m.label_value,
-                   COALESCE(rank_abs, RANK() OVER(PARTITION BY m.model_id
-                   ORDER BY m.score DESC)) AS rank_abs,
-                   COALESCE(m.rank_pct, percent_rank() OVER(PARTITION BY
-                   m.model_id ORDER BY m.score DESC)) * 100 AS rank_pct,
-                   m.test_label_timespan
-            FROM test_results.predictions m
-            LEFT JOIN model_metadata.models g
-            USING (model_id)
-            WHERE model_id IN {tuple(self.model_id)}
-            AND label_value IS NOT NULL
-            ''', con=self.engine)
-        if preds.empty:
-            raise RuntimeError("No predictions were retrieved from the database."
-                               "Some functionality will not be available without predictions."
-                               "Please run catwalk.Predictor for each desired model and test matrix"
-                               )
-        return preds
-
-    @cachedproperty
-    def feature_importances(self):
-        features = pd.read_sql(
-           f'''
-           SELECT g.model_group_id,
-                  m.model_id,
-                  m.feature,
-                  m.feature_importance,
-                  m.rank_abs
-           FROM train_results.feature_importances m
-           LEFT JOIN model_metadata.models g
-           USING (model_id)
-           WHERE m.model_id IN {tuple(self.model_id)}
-           ''', con=self.engine)
-        return features
-
-    @cachedproperty
-    def metrics(self):
-        model_metrics = pd.read_sql(
-            f'''
-            SELECT g.model_group_id,
-                   m.model_id,
-                   EXTRACT('YEAR' FROM m.evaluation_end_time) AS as_of_date_year,
-                   m.metric,
-                   m.parameter,
-                   m.value,
-                   m.num_labeled_examples,
-                   m.num_labeled_above_threshold,
-                   m.num_positive_labels
-            FROM test_results.evaluations m
-            LEFT JOIN model_metadata.models g
-            USING (model_id)
-            WHERE m.model_id IN {tuple(self.model_id)}
-            ''', con=self.engine)
-        return model_metrics
-
-    @cachedproperty
-    def feature_groups(self):
-        model_feature_groups = pd.read_sql(
-            f'''
-            WITH
-            feature_groups_raw AS(
-            SELECT
-            model_group_id,
-            model_config->>'feature_groups' as features
-            FROM model_metadata.model_groups
-            WHERE model_group_id IN {self.model_group_id}
-            ),
-            feature_groups_unnest AS(
-            SELECT model_group_id,
-            unnest(regexp_split_to_array(substring(features, '\[(.*?)\]'), ',')) AS group_array
-            FROM feature_groups_raw
-            ), feature_groups_array AS(
-            SELECT
-            model_group_id,
-            array_agg(split_part(substring(group_array,
-            '\"(.*?)\"'), ':', 2)) AS feature_group_array
-            FROM feature_groups_unnest
-            GROUP BY model_group_id
-            ), feature_groups_array_ AS(
-            SELECT
-            model_group_id,
-            feature_group_array,
-            array_length(feature_group_array, 1) AS number_feature_groups
-            FROM feature_groups_array
-            ), feature_groups_class_cases
-            AS(
-            SELECT
-            model_group_id,
-            feature_group_array,
-            number_feature_groups,
-            CASE
-            WHEN number_feature_groups = 1
-            THEN 'LOI'
-            WHEN  number_feature_groups = first_value(number_feature_groups) OVER w
-            THEN 'All features'
-            WHEN  number_feature_groups = (first_value(number_feature_groups) OVER w) - 1
-            THEN 'LOO'
-            ELSE NULL
-            END AS experiment_type
-            FROM feature_groups_array_
-            WINDOW w AS (ORDER BY number_feature_groups DESC)
-            ) SELECT * FROM feature_groups_class_cases
-            ''', con=self.engine)
-        return model_feature_groups
-
-    @cachedproperty
-    def same_time_models(self):
-        time_models = pd.read_sql(
-                      f'''
-                      SELECT
-                      train_end_time,
-                      array_agg(model_id) AS model_id_array
-                      FROM model_metadata.models
-                      WHERE model_group_id IN {self.model_group_id}
-                      GROUP BY train_end_time
-                      ''', con=self.engine)
-        return time_models
-
-    def plot_prec_across_time(self,
-                              param_type=None,
-                              param=None,
-                              metric=None,
-                              baseline=False,
-                              baseline_query=None,
-                              df=False,
-                              figsize=(12, 16),
-                              fontsize=20):
-
-        '''
-        Plot precision across time for all model_group_ids, and baseline,
-        if available.
-
-        This function plots the performance of each model_group_id following an
-        user defined performance metric. First, this function check if the
-        performance metrics are available to both the models, and the baseline.
-        Second, filter the data of interest, and lastly, plot the results as
-        timelines (model_id date).
-
-        Arguments:
-            - param_type (string): A parameter string with a threshold
-            definition: rank_pct, or rank_abs. These are usually defined in the
-            postmodeling configuration file.
-            - param (int): A threshold value compatible with the param_type.
-            This value is also defined in the postmodeling configuration file.
-            - metric (string): A string defnining the type of metric use to
-            evaluate the model, this can be 'precision@', or 'recall@'.
-            - baseline (bool): should we include a baseline for comparison?
-            - baseline_query (str): a SQL query that returns the evaluation data from
-            the baseline models. This value can also be defined in the
-            configuration file.
-            - df (bool): If True, no plot is rendered, but a pandas DataFrame
-            is returned with the data.
-            - figsize (tuple): tuple with figure size parameters
-            - fontsize (int): Fontsize for titles
-        '''
-
-        # Load metrics and prepare data for analysis
-        model_metrics = self.metrics
-        model_metrics[['param', 'param_type']] = \
-                model_metrics['parameter'].str.split('_', 1, expand=True)
-        model_metrics['param'] =  model_metrics['param'].astype(str).astype(float)
-        model_metrics['param_type'] = model_metrics['param_type'].apply(lambda x: 'rank_'+x)
-
-        # Filter model_group_id metrics and create pivot table by each
-        # model_group_id.
-        model_metrics_filter = model_metrics[(model_metrics['metric'] == metric) &
-                                      (model_metrics['param'] == param) &
-                                      (model_metrics['param_type'] == param_type)].\
-                filter(['model_group_id', 'model_id', 'as_of_date_year',
-                        'value'])
-
-        if baseline == True:
-
-            baseline_metrics = pd.read_sql(baseline_query, con=self.engine)
-            baseline_metrics[['param', 'param_type']] = \
-                    baseline_metrics['parameter'].str.split('_', 1, expand=True)
-            baseline_metrics['param'] = baseline_metrics['param'].astype(str).astype(float)
-            baseline_metrics['param_type'] = baseline_metrics['param_type'].\
-                    apply(lambda x: 'rank_'+x)
-
-            # Filter baseline metrics and create pivot table to join with
-            # selected models metrics
-            baseline_metrics_filter =  baseline_metrics.\
-                    filter(['model_group_id', 'model_id', 'as_of_date_year', 'value'])
-
-            baseline_metrics_filter['model_group_id'] = \
-                    baseline_metrics_filter.model_group_id.\
-                    apply(lambda x: 'baseline_' + str(x))
-
-            # Join tables by index(as_of_date_year)
-            model_metrics_filter = \
-            model_metrics_filter.append(baseline_metrics_filter, sort=True)
-
-        model_metrics_filter['as_of_date_year'] = \
-                model_metrics_filter.as_of_date_year.astype('int')
-        model_metrics_filter = model_metrics_filter.sort_values('as_of_date_year')
-
-        if df == True:
-            return model_metrics_filter
-
-        else:
-            try:
-                sns.set_style('whitegrid')
-                fig, ax = plt.subplots(figsize=figsize)
-                for model_group, df in model_metrics_filter.groupby(['model_group_id']):
-                    ax = ax = df.plot(ax=ax, kind='line',
-                                      x='as_of_date_year',
-                                      y='value',
-                                      marker='d',
-                                      label=model_group)
-                plt.title(str(metric).capitalize() +\
-                          ' for selected model_groups in time.',
-                          fontsize=fontsize)
-                ax.tick_params(labelsize=16)
-                ax.set_xlabel('Year of prediction (as_of_date)', fontsize=20)
-                ax.set_ylabel(f'{str(metric)+str(param_type)+str(param)}',
-                              fontsize=20)
-                plt.xticks(model_metrics_filter.as_of_date_year.unique())
-                plt.yticks(np.arange(0,1,0.1))
-                legend=plt.legend(bbox_to_anchor=(1.05, 1),
-                           loc=2,
-                           borderaxespad=0.,
-                           title='Model Group',
-                           fontsize=fontsize)
-                legend.get_title().set_fontsize('16')
-
-            except TypeError:
-                    print(f'''
-                          Oops! model_metrics_pivot table is empty. Several problems
-                          can be creating this error:
-                          1. Check that {param_type}@{param} exists in the evaluations
-                          table
-                          2. Check that the metric {metric} is available to the
-                          specified {param_type}@{param}.
-                          3. You basline model can have different specifications.
-                          Check those!
-                          4. Check overlap between baseline dates and model dates.
-                          The join is using the dates for doing these, and it's
-                          possible that your timestamps differ.
-                          ''')
-
-    def feature_loi_loo(self,
-                        model_subset=None,
-                        param_type=None,
-                        param=None,
-                        metric=None,
-                        baseline=False,
-                        baseline_query=None,
-                        df=False,
-                        figsize=(16,12),
-                        fontsize=20):
-        '''
-        Plot precision across time for the selected model_group_ids, and
-        include a leave-one-out, leave-one-in feature analysis to explore the
-        leverage/changes of the selected metric across different models.
-
-        This function plots the performance of each model_group_id following an
-        user defined performance metric. First, this function check if the
-        performance metrics are available to both the models, and the baseline.
-        Second, filter the data of interest, and lastly, plot the results as
-        timelines (model_id date).
-
-        Arguments:
-            -model_subset (list): A list of model_group_ids, in case you want
-            to override the selected models.
-            - param_type (string): A parameter string with a threshold
-            definition: rank_pct, or rank_abs. These are usually defined in the
-            postmodeling configuration file.
-            - param (int): A threshold value compatible with the param_type.
-            This value is also defined in the postmodeling configuration file.
-            - metric (string): A string defnining the type of metric use to
-            evaluate the model, this can be 'precision@', or 'recall@'.
-            - baseline (bool): should we include a baseline for comparison?
-            - baseline_query (str): a SQL query that returns the evaluation data from
-            the baseline models. This value can also be defined in the
-            configuration file.
-            - df (bool): If True, no plot is rendered, but a pandas DataFrame
-            is returned with the data.
-            - figsize (tuple): tuple with figure size parameters
-            - fontsize (int): Fontsize for titles
-
-    '''
-
-        if model_subset is None:
-            model_subset = self.model_group_id
-
-        # Load feature groups and subset
-        feature_groups = self.feature_groups
-        feature_groups_filter = \
-        feature_groups[feature_groups['model_group_id'].isin(model_subset)]
-
-        # Format metrics columns and filter by metric of interest
-        model_metrics = self.metrics
-        model_metrics[['param', 'param_type']] = \
-                model_metrics['parameter'].str.split('_', 1, expand=True)
-        model_metrics['param'] =  model_metrics['param'].astype(str).astype(float)
-        model_metrics['param_type'] = model_metrics['param_type'].apply(lambda x: 'rank_'+x)
-
-        model_metrics_filter = model_metrics[(model_metrics['metric'] == metric) &
-                                             (model_metrics['param'] == param) &
-                                             (model_metrics['param_type'] == param_type)].\
-                filter(['model_group_id', 'model_id', 'as_of_date_year',
-                        'value'])
-
-        # Merge metrics and features and filter by threshold definition
-        metrics_merge = model_metrics_filter.merge(feature_groups_filter,
-                                                  how='inner',
-                                                  on='model_group_id')
-
-        # LOO and LOI definition
-        all_features = set(metrics_merge.loc[metrics_merge['experiment_type'] == 'All features'] \
-                           ['feature_group_array'][0])
-
-        metrics_merge_experimental = \
-        metrics_merge[metrics_merge['experiment_type'] != 'All features']
-
-        metrics_merge_experimental['feature_experiment'] = \
-                metrics_merge_experimental.apply(lambda row: \
-                                   list(all_features.difference(row['feature_group_array']))[0] + '_loo' \
-                                   if row['experiment_type'] == 'LOO' \
-                                   else row['feature_group_array'] + '_loi', axis=1)
-
-        metrics_merge_experimental = \
-        metrics_merge_experimental.filter(['feature_experiment',
-                                           'as_of_date_year', 'value'])
-
-        if baseline == True:
-
-            baseline_metrics = pd.read_sql(baseline_query, con=self.engine)
-            baseline_metrics[['param', 'param_type']] = \
-                    baseline_metrics['parameter'].str.split('_', 1, expand=True)
-            baseline_metrics['param'] = baseline_metrics['param'].astype(str).astype(float)
-            baseline_metrics['param_type'] = baseline_metrics['param_type'].apply(lambda x: 'rank_'+x)
-
-            # Filter baseline metrics and create pivot table to join with
-            # selected models metrics
-            baseline_metrics_filter =  baseline_metrics[(baseline_metrics['metric'] == metric) &
-                                                        (baseline_metrics['param'] == param) &
-                                                        (baseline_metrics['param_type'] == param_type)].\
-                filter(['model_group_id', 'model_id', 'as_of_date_year', 'value'])
-
-            baseline_metrics_filter['feature_experiment'] = \
-                    baseline_metrics_filter.model_group_id.apply(lambda x: \
-                                                                 'baseline_' + \
-                                                                 str(x))
-
-            metrics_merge_experimental = \
-                    metrics_merge_experimental.append(baseline_metrics_filter,
-                                                     sort=True)
-        if df == True:
-            return metrics_merge_experimental
-
-        else:
-            try:
-                sns.set_style('whitegrid')
-                fig, ax = plt.subplots(figsize=figsize)
-                for feature, df in metrics_merge_experimental.groupby(['feature_experiment']):
-                    ax = df.plot(ax=ax, kind='line',
-                                      x='as_of_date_year',
-                                      y='value',
-                                      label=feature)
-                metrics_merge[metrics_merge['experiment_type'] == 'All features']. \
-                        groupby(['experiment_type']). \
-                        plot(ax=ax,
-                             kind='line',
-                             x='as_of_date_year',
-                             y='value',
-                             label='All features')
-                plt.title(str(metric).capitalize() +\
-                          ' for selected model_groups in time.',
-                          fontsize=fontsize)
-                ax.tick_params(labelsize=16)
-                ax.set_xlabel('Year of prediction (as_of_date)', fontsize=20)
-                ax.set_ylabel(f'{str(metric)+str(param_type)+str(param)}',
-                              fontsize=20)
-                plt.xticks(model_metrics_filter.as_of_date_year.unique())
-                plt.yticks(np.arange(0,1,0.1))
-                legend=plt.legend(bbox_to_anchor=(1.05, 1),
-                           loc=2,
-                           borderaxespad=0.,
-                           title='Experiment Type',
-                           fontsize=fontsize)
-                legend.get_title().set_fontsize('16')
-
-            except TypeError:
-                    print(f'''
-                          Oops! model_metrics_pivot table is empty. Several problems
-                          can be creating this error:
-                          1. Check that {param_type}@{param} exists in the evaluations
-                          table
-                          2. Check that the metric {metric} is available to the
-                          specified {param_type}@{param}.
-                          3. You basline model can have different specifications.
-                          Check those!
-                          4. Check overlap between baseline dates and model dates.
-                          The join is using the dates for doing these, and it's
-                          possible that your timestamps differ.
-                          ''')
-
-    def _rank_corr_df(self,
-                      model_pair,
-                      top_n_features: 10,
-                      corr_type=None,
-                      param_type=None,
-                      param=None):
-        '''
-        Calculates ranked correlations for ranked observations and features
-        using the stats.spearmanr scipy module.
-        Arguments:
-            - model_pair (tuple): tuple with model_ids
-              observations or features
-            - top_n (int): number of rows to rank (top-k model)
-        '''
-
-        if corr_type not in ['predictions', 'features']:
-            raise Exception(
-                f'''Wrong type! Rank correlation is not available\n
-                   for {type}. Try the following options:\n
-                   predictions and features''')
-
-        if corr_type == 'predictions':
-            # Split df for each model_id
-            model_1 = self.predictions[self.predictions['model_id'] == model_pair[0]]
-            model_2 = self.predictions[self.predictions['model_id'] == model_pair[1]]
-
-            # Slice df to take top-n observations
-            top_model_1 = model_1[model_1[param_type] < param].set_index('entity_id')
-            top_model_2 = model_2[model_2[param_type] < param].set_index('entity_id')
-
-            # Merge df's by entity_id and calculate corr
-            df_pair_merge = top_model_1.merge(top_model_2,
-                                              how='inner',
-                                              left_index=True,
-                                              right_index=True,
-                                              suffixes=['_1', '_2'])
-
-            df_pair_filter = df_pair_merge.filter(regex='rank_abs*')
-            rank_corr = spearmanr(df_pair_filter.iloc[:, 0], df_pair_filter.iloc[:, 1])
-
-            # Return corr value (not p-value)
-            return rank_corr[0]
-
-        elif corr_type == 'features':
-            # Split df for each model_id
-            model_1 = \
-                    self.feature_importances[self.feature_importances['model_id'] \
-                                             == model_pair[0]]
-            model_2 = \
-                    self.feature_importances[self.feature_importances['model_id'] \
-                                             == model_pair[1]]
-
-            # Slice df to take top-n observations
-            top_model_1 = model_1.sort_values('rank_abs', \
-                                              axis=0)[:top_n_features].set_index('feature')
-            top_model_2 = model_2.sort_values('rank_abs', \
-                                              axis=0)[:top_n_features].set_index('feature')
-
-            # Merge df's by entity_id and calculate corr
-            df_pair_merge = top_model_1.merge(top_model_2,
-                                              how='inner',
-                                              left_index=True,
-                                              right_index=True,
-                                              suffixes=['_1', '_2'])
-
-            df_pair_filter = df_pair_merge.filter(regex='rank_abs*')
-            rank_corr = spearmanr(df_pair_filter.iloc[:, 0], df_pair_filter.iloc[:, 1])
-
-            # Return corr value (not p-value)
-            return rank_corr[0]
-        else:
-            pass
-
-    def plot_ranked_correlation_preds(self,
-                                       model_subset=None,
-                                       temporal_comparison=False,
-                                       figsize=(24, 10),
-                                       fontsize=12,
-                                       **kwargs):
-        '''
-        Plot ranked correlation between model_id's using the _rank_corr_df
-        method. The plot will visualize the selected correlation matrix
-        including all the models
-        Arguments:
-            - model_subset (list): subset to only include a subset of model_ids
-            - corr_type (str): correlation type. Two options are available:
-                features and predictions.
-            - temporal_comparison (bool): Compare same prediction window models?
-              Default is False
-            - figzise (tuple): tuple with figure size. Default is (12, 16)
-            - fontsize (int): Fontsize for plot labels and titles. Default is
-              20
-            - **kwargs: other parameters passed to the _rank_corr_df method
-        '''
-        if model_subset is None:
-            model_subset = self.model_id
-        models_to_use = []
-        model_as_of_date = []
-        for key, values in \
-            self.same_time_models[['train_end_time', 'model_id_array']].iterrows():
-            if values[1][0] in model_subset:
-                models_to_use.append(values[1][0])
-                model_as_of_date.append(values[0])
-        model_subset = models_to_use
-
-        if temporal_comparison == True:
-            fig = plt.figure(figsize=figsize)
-            for key, values in \
-                self.same_time_models[['train_end_time', 'model_id_array']].iterrows():
-
-                model_subset = values[1]
-                model_as_of_date = values[0]
-
-                # Calculate rank correlations for predictions
-                corrs = [self._rank_corr_df(pair,
-                         corr_type='predictions',
-                         param=kwargs['param'],
-                         param_type=kwargs['param_type'],
-                         top_n_features=10
-                         ) for pair in combinations(model_subset, 2)]
-
-                # Store results in dataframe using tuples
-                corr_matrix = pd.DataFrame(index=model_subset, columns=model_subset)
-                for pair, corr in zip(combinations(model_subset, 2), corrs):
-                    corr_matrix.loc[pair] = corr
-
-                # Process data for plot: mask repeated tuples
-                corr_matrix_t = corr_matrix.T
-                mask = np.zeros_like(corr_matrix_t)
-                mask[np.triu_indices_from(mask, k=1)] = True
-
-                #fig, ax = plt.subplots(figsize=figsize)
-                ax = fig.add_subplot(np.ceil(self.same_time_models.shape[0]/4), 4, key+1)
-                ax.set_xlabel('Model Id', fontsize=fontsize)
-                ax.set_ylabel('Model Id', fontsize=fontsize)
-                plt.title(f'''Predictions Rank Correlation for
-                          {kwargs['param_type']}@{kwargs['param']}
-                          (date: {model_as_of_date})
-                        ''', fontsize=fontsize)
-                sns.heatmap(corr_matrix_t.fillna(1),
-                            mask=mask,
-                            vmax=1,
-                            vmin=0,
-                            cmap='YlGnBu',
-                            annot=True,
-                            square=True)
-
-        else:
-            corrs = [self._rank_corr_df(pair,
-                                        corr_type='predictions',
-                                        param=kwargs['param'],
-                                        param_type=kwargs['param_type'],
-                                        top_n_features=10
-                                        ) for pair in combinations(model_subset, 2)]
-
-            # Store results in dataframe using tuples
-            corr_matrix = pd.DataFrame(index=model_subset, columns=model_subset)
-            for pair, corr in zip(combinations(model_subset, 2), corrs):
-                corr_matrix.loc[pair] = corr
-
-            # Process data for plot: mask repeated tuples
-            corr_matrix_t = corr_matrix.T
-            mask = np.zeros_like(corr_matrix_t)
-            mask[np.triu_indices_from(mask, k=1)] = True
-
-            fig, ax = plt.subplots(figsize=figsize)
-            ax.set_xlabel('Model Id', fontsize=fontsize)
-            ax.set_ylabel('Model Id', fontsize=fontsize)
-            plt.title(f'''Predictions Rank Correlation for
-                      {kwargs['param_type']}@{kwargs['param']}
-                     ''', fontsize=fontsize)
-            sns.heatmap(corr_matrix_t.fillna(1),
-                        mask=mask,
-                        vmax=1,
-                        vmin=0,
-                        cmap='YlGnBu',
-                        annot=True,
-                        square=True)
-
-
-    def plot_ranked_correlation_features(self,
-                                         model_subset=None,
-                                         temporal_comparison=False,
-                                         figsize=(12, 16),
-                                         fontsize=20,
-                                         **kwargs):
-        '''
-        Plot ranked correlation between model_id's using the _rank_corr_df
-        method. The plot will visualize the selected correlation matrix
-        including all the models
-        Arguments:
-            - model_subset (list): subset to only include a subset of model_ids
-            - corr_type (str): correlation type. Two options are available:
-                features and predictions.
-            - temporal_comarison (bool): Compare same prediction window models?
-              Default is False
-            - figzise (tuple): tuple with figure size. Default is (12, 16)
-            - fontsize (int): Fontsize for plot labels and titles. Default is
-              20
-            - **kwargs: other parameters passed to the _rank_corr_df method
-        '''
-
-        if model_subset is None:
-            model_subset = self.model_id
-        models_to_use = []
-        model_as_of_date = []
-        for key, values in \
-            self.same_time_models[['train_end_time', 'model_id_array']].iterrows():
-            if values[1][0] in model_subset:
-                models_to_use.append(values[1][0])
-                model_as_of_date.append(values[0])
-        model_subset = models_to_use
-
-        if  temporal_comparison == True:
-
-            # Calculate rank correlations for features
-            corrs = [self._rank_corr_df(pair,
-                                        corr_type='features',
-                                        top_n_features = kwargs \
-                                        ['top_n_features']
-                                       ) for pair in combinations(model_subset, 2)]
-
-            # Store results in dataframe using tuples
-            corr_matrix = pd.DataFrame(index=model_subset, columns=model_subset)
-            for pair, corr in zip(combinations(model_subset, 2), corrs):
-                corr_matrix.loc[pair] = corr
-
-            # Process data for plot: mask repeated tuples
-            corr_matrix_t = corr_matrix.T
-            mask = np.zeros_like(corr_matrix_t)
-            mask[np.triu_indices_from(mask, k=1)] = True
-
-            fig, ax = plt.subplots(figsize=figsize)
-            ax.set_xlabel('Model Id', fontsize=fontsize)
-            ax.set_ylabel('Model Id', fontsize=fontsize)
-            plt.title(f'''Feature Rank Correlation for
-                      Top-{kwargs['top_n_features']}
-                     (date: {model_as_of_date})
-                    ''', fontsize=fontsize)
-            sns.heatmap(corr_matrix_t.fillna(1),
-                        mask=mask,
-                        vmax=1,
-                        vmin=0,
-                        cmap='YlGnBu',
-                        annot=True,
-                        square=True)
-
-        else:
-            corrs = [self._rank_corr_df(pair,
-                                        corr_type='features',
-                                        top_n_features=10
-                                        ) for pair in combinations(model_subset, 2)]
-            # Store results in dataframe using tuples
-            corr_matrix = pd.DataFrame(index=model_subset, columns=model_subset)
-            for pair, corr in zip(combinations(model_subset, 2), corrs):
-                corr_matrix.loc[pair] = corr
-
-            # Process data for plot: mask repeated tuples
-            corr_matrix_t = corr_matrix.T
-            mask = np.zeros_like(corr_matrix_t)
-            mask[np.triu_indices_from(mask, k=1)] = True
-
-            fig, ax = plt.subplots(figsize=figsize)
-            ax.set_xlabel('Model Id', fontsize=fontsize)
-            ax.set_ylabel('Model Id', fontsize=fontsize)
-            plt.title(f'''Feature Rank Correlation for
-                      Top-{kwargs['top_n_features']}
-                    ''', fontsize=fontsize)
-            sns.heatmap(corr_matrix_t.fillna(1),
-                        mask=mask,
-                        vmax=1,
-                        vmin=0,
-                        cmap='YlGnBu',
-                        annot=True,
-                        square=True)
-
-
-    def plot_jaccard_preds(self,
-                           param_type=None,
-                           param=None,
-                           model_subset=None,
-                           temporal_comparison=False,
-                           figsize=(24, 10),
-                           fontsize=12):
-
-        if model_subset is None:
-            model_subset = self.model_id
-
-        preds = self.predictions
-        preds_filter = preds[preds['model_id'].isin(self.model_id)]
-
-        if temporal_comparison == True:
-            try:
-                fig = plt.figure(figsize=figsize)
-                for key, values in \
-                self.same_time_models[['train_end_time', 'model_id_array']].iterrows():
-                    preds_filter_group = \
-                    preds_filter[preds_filter['model_id'].isin(values[1])]
-                    # Filter predictions dataframe by individual dates
-                    if param_type == 'rank_abs':
-                        df_preds_date = preds_filter_group.copy()
-                        df_preds_date['above_tresh'] = \
-                                np.where(df_preds_date['rank_abs'] <= param, 1, 0)
-                        df_sim_piv = df_preds_date.pivot(index='entity_id',
-                                                         columns='model_id',
-                                                         values='above_tresh')
-                    elif param_type == 'rank_pct':
-                        df_preds_date = preds_filter_group.copy()
-                        df_preds_date['above_tresh'] = np.where(df_preds_date['rank_pct'] <= param, 1, 0)
-                        df_preds_date['new_entity_id'] = df_preds_date['entity_id'].astype(str) + ":" + df_preds_date['as_of_date'].astype(str)
-                        df_sim_piv = df_preds_date.pivot(index='new_entity_id',
-                                                         columns='model_id',
-                                                         values='above_tresh')
-                    else:
-                        raise AttributeError('''Error! You have to define a parameter type to
-                                             set up a threshold
-                                             ''')
-                            # Calculate Jaccard Similarity for the selected models
-                    res = pdist(df_sim_piv.T, 'jaccard')
-                    df_jac = pd.DataFrame(1-squareform(res),
-                                      index=preds_filter_group.model_id.unique(),
-                                      columns=preds_filter_group.model_id.unique())
-                    mask = np.zeros_like(df_jac)
-                    mask[np.triu_indices_from(mask, k=1)] = True
-
-                    # Plot matrix heatmap
-                    ax = fig.add_subplot(np.ceil(self.same_time_models.shape[0]/4), 4, key+1)
-                    ax.set_xlabel('Model Id', fontsize=fontsize)
-                    ax.set_ylabel('Model Id', fontsize=fontsize)
-                    plt.title(f'''(as_of_date:{values[0]})''', fontsize=fontsize)
-                    sns.heatmap(df_jac,
-                                mask=mask,
-                                cmap='Greens',
-                                vmin=0,
-                                vmax=1,
-                                annot=True,
-                                linewidth=0.1)
-            except ValueError:
-                print(f'''
-                      Temporal comparison can be only made for more than one
-                      model group.
-                     ''')
-
-        else:
-                # Call predicitons
-                if param_type == 'rank_abs':
-                    df_preds_date = preds_filter.copy()
-                    df_preds_date['above_tresh'] = \
-                            np.where(df_preds_date['rank_abs'] <= param, 1, 0)
-                    df_sim_piv = df_preds_date.pivot(index='entity_id',
-                                                     columns='model_id',
-                                                     values='above_tresh')
-                elif param_type == 'rank_pct':
-                    df_preds_date = preds_filter.copy()
-                    df_preds_date['above_tresh'] = \
-                            np.where(df_preds_date['rank_pct'] <= param, 1, 0)
-                    df_preds_date['new_entity_id'] = df_preds_date['entity_id'].astype(str) + ":" + df_preds_date['as_of_date'].astype(str)
-                    df_sim_piv = df_preds_date.pivot(index='new_entity_id',
-                                                     columns='model_id',
-                                                     values='above_tresh')
-                else:
-                    raise AttributeError('''Error! You have to define a parameter type to
-                                         set up a threshold
-                                         ''')
-
-                # Calculate Jaccard Similarity for the selected models
-                res = pdist(df_sim_piv[model_subset].T, 'jaccard')
-                df_jac = pd.DataFrame(1-squareform(res),
-                                      index=model_subset,
-                                      columns=model_subset)
-                mask = np.zeros_like(df_jac)
-                mask[np.triu_indices_from(mask, k=1)] = True
-
-                # Plot matrix heatmap
-                fig, ax = plt.subplots(figsize=figsize)
-                ax.set_xlabel('Model Id', fontsize=fontsize)
-                ax.set_ylabel('Model Id', fontsize=fontsize)
-                plt.title('Jaccard Similarity Matrix Plot', fontsize=fontsize)
-                sns.heatmap(df_jac,
-                            mask=mask,
-                            cmap='Greens',
-                            vmin=0,
-                            vmax=1,
-                            annot=True,
-                            linewidth=0.1)
-
-
-    def plot_jaccard_features(self,
-                              top_n_features=10,
-                              model_subset=None,
-                              temporal_comparison=False,
-                              figsize=(30, 10),
-                              fontsize=12):
-
-        if model_subset is None:
-            model_subset = self.model_id
-
-        f_importances = self.feature_importances
-        f_importances_filter = \
-        f_importances[f_importances['model_id'].isin(model_subset)]
-
-        if temporal_comparison == True:
-            try:
-                fig = plt.figure(figsize=figsize)
-                for key, values in \
-                self.same_time_models[['train_end_time', 'model_id_array']].iterrows():
-                    f_imp_filter_group = \
-                    f_importances_filter[f_importances_filter['model_id'].isin(values[1])]
-                    
-                    if top_n_features is not None:
-                        f_imp_date = f_imp_filter_group.copy()
-                        f_imp_date_filter = \
-                                f_imp_filter_group.sort_values('rank_abs')
-                        f_imp_date_filter_top = \
-                                f_imp_date_filter[f_imp_date_filter['rank_abs']
-                                                 <= top_n_features]
-
-                        df_sim_piv = f_imp_date_filter_top.pivot(index='feature',
-                                                                 columns='model_id',
-                                                                 values='rank_abs')
-                    else:
-                        raise AttributeError('''Error! You have to define a top_n features to
-                                             set up a threshold
-                                             ''')
-
-                    # Calculate Jaccard Similarity for the selected models
-                    res = pdist(df_sim_piv.T, 'jaccard')
-                    df_jac = pd.DataFrame(1-squareform(res),
-                                      index=values[1],
-                                      columns=values[1])
-                    mask = np.zeros_like(df_jac)
-                    mask[np.triu_indices_from(mask, k=1)] = True
-
-                    # Plot matrix heatmap
-                    ax = fig.add_subplot(np.ceil(self.same_time_models.shape[0]/4), 4, key+1)
-                    ax.set_xlabel('Model Id', fontsize=fontsize)
-                    ax.set_ylabel('Model Id', fontsize=fontsize)
-                    plt.title(f'''(as_of_date:{values[0]})''', fontsize=fontsize)
-                    sns.heatmap(df_jac,
-                                mask=mask,
-                                cmap='Greens',
-                                vmin=0,
-                                vmax=1,
-                                annot=True,
-                                linewidth=0.1)
-            except ValueError:
-                print(f'''
-                      Temporal comparison can be only made for more than one
-                      model group.
-                     ''')
-
-        else:
-                # Call predicitons
-                if top_n_features is not None:
-                    f_importances_filter_all = f_importances_filter.copy()
-                    f_importance_filter_all_rank = \
-                            f_importances_filter_all.sort_values('rank_abs')
-                    f_importance_filter_all_rank_top = \
-                            f_importance_filter_all_rank[f_importance_filter_all_rank['rank_abs']
-                                                        <= top_n_features]
-
-                    df_sim_piv = \
-                    f_importance_filter_all_rank_top.pivot(index='feature',
-                                                           columns='model_id',
-                                                           values='rank_abs')
-                else:
-                    raise AttributeError('''Error! You have to define a parameter type to
-                                         set up a threshold
-                                         ''')
-
-                # Calculate Jaccard Similarity for the selected models
-                res = pdist(df_sim_piv[model_subset].T, 'jaccard')
-                df_jac = pd.DataFrame(1-squareform(res),
-                                      index=model_subset,
-                                      columns=model_subset)
-                mask = np.zeros_like(df_jac)
-                mask[np.triu_indices_from(mask, k=1)] = True
-
-                # Plot matrix heatmap
-                fig, ax = plt.subplots(figsize=figsize)
-                ax.set_xlabel('Model Id', fontsize=fontsize)
-                ax.set_ylabel('Model Id', fontsize=fontsize)
-                plt.title('Jaccard Similarity Matrix Plot', fontsize=fontsize)
-                sns.heatmap(df_jac,
-                            mask=mask,
-                            cmap='Greens',
-                            vmin=0,
-                            vmax=1,
-                            annot=True,
-                            linewidth=0.1)
-
-
-    def _plot_preds_compare_score_dist(self,
-                                       m0,
-                                       m1,
-                                       df_preds_date,
-                                       colors=['blue', 'orange'],
-                                       bins=np.arange(0,1.01,0.01)):
-
-        '''
-        Plotting function for comparing prediction distributions across models.
-        This function takes two model_ids with predictions in the same
-        prediction window and shows the relative distribution of
-        the first model top-k in the second model score distribution.
-
-        This function is meant to be used as a helper function of
-        plot_preds_comparisons.
-
-        Arguments:
-            - m0, m1: (int) model_id
-            - df_preds_date: (dataframe) predictions dataframe
-            - colors: (str) color strings. Defaults are blue and orange
-            - bins: (np array) number of bins to pass to the seaborn histogram
-            plotting function
-
-        Returns:
-            matplotlib plot object
-        '''
-
-        df_preds_m0 = df_preds_date[df_preds_date['model_id']==m0]
-        df_preds_m1 = df_preds_date[df_preds_date['model_id']==m1]
-
-        sns.distplot(df_preds_m0[df_preds_m0['above_tresh']==0]['score'],
-                     kde=False,
-                     bins=bins,
-                     color='grey',
-                     label="model " + str(m0) + " predicted label = 0")
-        sns.distplot(df_preds_m0[df_preds_m0['above_tresh']==1]['score'],
-                     kde=False,
-                     bins=bins,
-                     color=colors[1],
-                     label="model " + str(m0) + " predicted label = 1")
-
-        df_alt_model_scores = \
-                pd.merge(df_preds_m0, df_preds_m1[df_preds_m1.above_tresh==1][['entity_id', 'as_of_date']])
-
-        sns.distplot(df_alt_model_scores['score'],
-                     kde=False,
-                     bins=bins,
-                     color=colors[0],
-                     label="model " + str(m1) + " predicted label = 1")
-
-        plt.xlabel("Scores from model " + str(m0))
-        plt.legend()
-
-    def _plot_preds_compare_rank(self,
-                                 m0,
-                                 m1,
-                                 df_preds_date,
-                                 colors=['black'],
-                                 show_tp_fp=False,
-                                 bins = np.arange(0,110,10)):
-        '''
-        Plot predictions rank comparison for two selected models.
-
-        This function will rank the predictions from one model into the decile
-        distribution of the second one. This function is meant to be used as a
-        part of the plot_preds_comparison function.
-
-        Arguments:
-            - m0, m1: (int) model_ids to compare, only two.
-            - df_preds_date: (dataframe) predictions dataframe
-            - colors: (str) color string. Default is black
-            - show_tp_tn: (bool) Plot true positive and true negatives in the
-                           rank distribution plot. Default is False
-            - bins: (np array) Number of bins to pass to the seaborn
-            histogram plot function.
-        '''
-
-        df_preds_m0 = df_preds_date[df_preds_date['model_id']==m0]
-        df_preds_m1 = df_preds_date[df_preds_date['model_id']==m1]
-        df_alt_model_rank = \
-                pd.merge(df_preds_m0, df_preds_m1[df_preds_m1.above_tresh==1][['entity_id', 'as_of_date']])
-
-        if show_tp_fp:
-            sns.distplot(df_alt_model_rank[df_alt_model_rank['label_value']==0]['rank_pct'],
-                         kde=False,
-                         bins=bins,
-                         hist=True,
-                         color=colors[0],
-                         label="false positives")
-            sns.distplot(df_alt_model_rank[df_alt_model_rank['label_value']==1]['rank_pct'],
-                         kde=False,
-                         bins=bins,
-                         hist=True,
-                         color=colors[1],
-                         label="true positives")
-            plt.legend()
-        else:
-            sns.distplot(df_alt_model_rank['rank_pct'],
-                         kde=False,
-                         bins=bins,
-                         hist=True,
-                         color=colors[0])
-        plt.xlabel("Percentile Rank in model " + str(m0))
-        plt.title("model "+str(m1)+" predicted label = 1")
-        plt.xticks(bins)
-
-    def plot_preds_comparison(self,
-                              param_type=None,
-                              param=None,
-                              model_subset=None,
-                              figsize=(28, 16),
-                              fontsize=12):
-        '''
-        Plot predictor distribution comparison (distribution and rank)
-
-        This function compares the predictions of all models, or a subset passed to
-        model_subset. To compare predictions, the function will show the
-        relative position of the score distribution of the top-k of one of the
-        models into another model.
-
-        Also, to compare how "off" can predictions be, the function will plot
-        the rank position of the predictions of one model in to another. The
-        plot will show the decile position of one model into the other.
-
-        Arguments:
-            - param_type: (str) parameter type (i.e. 'rank_abs', 'rank_pct')
-            - param: (int) parameter threshold
-            - model_subset: (list) list of model_ids to compare. Default is
-            none, and the function will take all the models in self.model_id
-            - figsize, fontsize: aesthetics for plots.
-        '''
-
-        if model_subset is None:
-            model_subset = self.model_id
-
-        preds = self.predictions
-        preds_filter = preds[preds['model_id'].isin(self.model_id)]
-
-        fig = plt.figure(figsize=figsize)
-        try:
-            for key, values in \
-                self.same_time_models[['train_end_time', 'model_id_array']].iterrows():
-                preds_filter_group = \
-                                     preds_filter[preds_filter['model_id'].isin(values[1])]
-                # Filter predictions dataframe by individual dates
-                df_preds_date = preds_filter_group.copy()
-                if param_type == 'rank_abs':
-                    df_preds_date['above_tresh'] = \
-                        np.where(df_preds_date['rank_abs'] <= param, 1, 0)
-                elif param_type == 'rank_pct':
-                    df_preds_date['above_tresh'] = \
-                        np.where(df_preds_date['rank_pct'] <= param, 1, 0)
-
-                else:
-                    raise AttributeError('''Error! You have to define a parameter type to
-                    set up a threshold
-                    ''')
-
-                sns.set_style('whitegrid')
-                sns.set_context("poster", font_scale=1.25, rc={"lines.linewidth": 2.25,"lines.markersize":12})
-                plt.clf()
-                fig = plt.figure(figsize=figsize)
-                for pair in itertools.combinations(values['model_id_array'], 2):
-                    m0 = pair[0]
-                    m1 = pair[1]
-                    colors = {m0: 'blue', m1: 'orange'}
-                    ax1 = plt.subplot(231)
-                    self._plot_preds_compare_score_dist(pair[0], pair[1],
-                                                       df_preds_date,
-                                                       colors=[colors[m0], colors[m1]])
-                    ax1 = plt.subplot(234)
-                    self._plot_preds_compare_score_dist(pair[1],
-                                                       pair[0],
-                                                       df_preds_date,
-                                                       colors=[colors[m1], colors[m0]])
-                    ax1 = plt.subplot(232)
-                    self._plot_preds_compare_rank(pair[0],
-                                                 pair[1],
-                                                 df_preds_date,
-                                                 colors=[colors[m0]])
-                    ax1 = plt.subplot(235)
-                    self._plot_preds_compare_rank(pair[1],
-                                                 pair[0],
-                                                 df_preds_date,
-                                                 colors=[colors[m1]])
-                    ax1 = plt.subplot(233)
-                    self._plot_preds_compare_rank(pair[0],
-                                                 pair[1],
-                                                 df_preds_date,
-                                                 show_tp_fp=True,
-                                                 colors=['lightblue', 'darkblue'])
-                    ax1 = plt.subplot(236)
-                    self._plot_preds_compare_rank(pair[1],
-                                                 pair[0],
-                                                 df_preds_date,
-                                                 show_tp_fp=True,
-                                                 colors=['khaki', 'darkorange'])
-                plt.tight_layout()
-                fig.suptitle(values['train_end_time'])
-                plt.show()
-        except ValueError:
-            print(f'''
-            Temporal comparison can be only made for more than one
-            model group.
-            ''')

From 7ae96009fe2ba9996fb2ec024d3b90bbbff6fb29 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Mon, 8 Apr 2019 14:16:13 -0500
Subject: [PATCH 06/17] Removed redundant methods

---
 src/triage/component/postmodeling/__init__.py | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/src/triage/component/postmodeling/__init__.py b/src/triage/component/postmodeling/__init__.py
index 15d8b0a2a..bf3f9c745 100644
--- a/src/triage/component/postmodeling/__init__.py
+++ b/src/triage/component/postmodeling/__init__.py
@@ -108,14 +108,6 @@ class Model(Base):
     model_group_id = Column('model_group_id', postgresql.INTEGER, ForeignKey('model_metadata.model_groups.model_group_id'))
     model_group = relationship("ModelGroup", backref="models")
 
-    def get_predictions(self):
-        predictions = pd.DataFrame([prediction.__dict__ for prediction in self.predictions])
-        return predictions.drop('_sa_instance_state', axis=1).set_index(['as_of_date', 'entity_id'])
-
-    def get_evaluations(self):
-        evaluations =  pd.DataFrame([evaluation.__dict__ for evaluation in self.evaluations])
-        return evaluations.drop('_sa_instance_state', axis=1).set_index(['evaluation_start_time', 'model_id', 'metric', 'parameter'])
-
     def to_df(self):
         model = pd.DataFrame.from_dict({k: v for k,v in self.__dict__.items() if not k in ['predictions', 'evaluations']}, orient='columns')
         return model.drop('_sa_instance_state', axis=1).set_index(['model_group_id', 'model_id'])

From f82e22d0696f5d605f5c255c1e0a02fab48c6f56 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Tue, 16 Apr 2019 16:42:28 -0500
Subject: [PATCH 07/17] New README

---
 src/triage/component/postmodeling/README.org | 98 ++++++++++++++++++++
 src/triage/component/postmodeling/plots.py   |  4 +-
 2 files changed, 101 insertions(+), 1 deletion(-)
 create mode 100644 src/triage/component/postmodeling/README.org

diff --git a/src/triage/component/postmodeling/README.org b/src/triage/component/postmodeling/README.org
new file mode 100644
index 000000000..da12a3272
--- /dev/null
+++ b/src/triage/component/postmodeling/README.org
@@ -0,0 +1,98 @@
+#+TITLE: Post-modeling analysis
+
+* Introduction
+
+/Postmodeling/ is about exploring the model group in a point of time
+(i.e. a model) or over time.
+
+Choosing the right model for deployment and exploring its predictions
+and behavior in time is a pivotal task. =postmodeling= will help to
+answer some of this questions by exploring the outcomes of the model,
+and exploring /deeply/ into the model behavior across time and
+features.
+
+This library lays at the end of the =triage= pipeline and will use the
+output of *audition* and some of its selection rules as a main
+input.
+
+* What you can do?
+
+** Compare model groups
+
+*** Metric
+
+*** Overlaps
+
+** Display the model group over time
+
+*** Metric
+
+*** Top Features
+
+*** Top predicted entities
+
+** Drill in a model group in a specific time
+
+*** Top Features
+
+*** Score distribution
+
+*** /Crosstabs/
+
+
+* New API
+
+We encapsulate the model groups from the database in two objects
+=ModelGroup= and =Model=.
+
+You could manipulate those objects using functions using functions:
+
+- =plot_XXXX(object, **kwargs)= for plotting, located in =plot.py=. The
+  arguments for this set of functions are =model= or a =model_group= and
+  they always return a =fig, ax= matplotlib objects so you can modify
+  them on the fly and tailor them for your specific purposes.
+
+* Use
+
+*NOTE*: This module use the =triage='s /default/ (and recommended) way of specify the
+database connection: an environment variable =DATABASE_URL= or it will
+try to read the connection file fro =DATABASE_FILE=.
+
+If you are playing with this module in Jupyter notebooks, remember
+that you can set environment variables with =%env=.
+
+
+Most of the time you will need to import these:
+
+#+BEGIN_SRC jupyter-python :session postmodeling
+from triage.component.postmodeling import get_model_group, get_model
+from triage.component.postmodeling.plots import plot_roc, plot_precision_recall_n, plot_metric_over_time
+#+END_SRC
+
+If you want to get a particular =ModelGroup=
+
+#+BEGIN_SRC jupyter-python :session postmodeling
+mg = get_model_group(model_group_id=14)
+#+END_SRC
+
+If you want to plot the performance over time:
+
+
+#+BEGIN_SRC jupyter-python :session postmodeling
+## mgs is a list of ModelGroups
+plot_metric_over_time(mgs, metric='precision', parameter='10_pct')
+#+END_SRC
+
+or an individual =Model=
+
+#+BEGIN_SRC jupyter-python :session postmodeling
+m = get_model(model_id = 5)
+#+END_SRC
+
+#+BEGIN_SRC jupyter-python :session postmodeling
+plot_precision_recall_n(m)
+#+END_SRC
+
+#+BEGIN_SRC jupyter-python :session postmodeling
+plot_ROC(m)
+#+END_SRC
diff --git a/src/triage/component/postmodeling/plots.py b/src/triage/component/postmodeling/plots.py
index b98715d32..603e24df9 100644
--- a/src/triage/component/postmodeling/plots.py
+++ b/src/triage/component/postmodeling/plots.py
@@ -39,7 +39,6 @@ def _store(fig, **kwargs):
         bbox_inches = kwargs.get('bbox_inches', 'tight')
         fig.savefig(f"{filename}.{extension}", transparent=transparent, dpi=dpi, bbox_inches=bbox_inches)
 
-
 def plot_roc(model, **kwargs):
     fig, ax = plt.subplots()
 
@@ -161,6 +160,9 @@ def get_model_group_evaluations(model_group):
 
     return fig, ax
 
+
+
+
 def get_subsets(l):
     subsets = []
     for i in range(1, len(l) + 1):

From e6ffd4745bd9bb927d8ca74efca6aac874f35500 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Wed, 17 Apr 2019 14:16:15 -0500
Subject: [PATCH 08/17] Unit testing modified

---
 .../test_model_evaluator.py                   | 122 ------------------
 .../test_model_group_evaluator.py             |  74 -----------
 src/tests/postmodeling_tests/test_plots.py    |  55 ++++++++
 src/triage/component/postmodeling/README.org  |   2 +
 src/triage/component/postmodeling/__init__.py |  31 +++--
 5 files changed, 77 insertions(+), 207 deletions(-)
 delete mode 100644 src/tests/postmodeling_tests/test_model_evaluator.py
 delete mode 100644 src/tests/postmodeling_tests/test_model_group_evaluator.py
 create mode 100644 src/tests/postmodeling_tests/test_plots.py

diff --git a/src/tests/postmodeling_tests/test_model_evaluator.py b/src/tests/postmodeling_tests/test_model_evaluator.py
deleted file mode 100644
index cd2ca743f..000000000
--- a/src/tests/postmodeling_tests/test_model_evaluator.py
+++ /dev/null
@@ -1,122 +0,0 @@
-from triage.component.postmodeling.contrast.model_evaluator import ModelEvaluator
-from triage.component.postmodeling.crosstabs import run_crosstabs
-from tests.utils import sample_config, populate_source_data, assert_plot_figures_added
-from triage.experiments import SingleThreadedExperiment
-import pandas as pd
-import pytest
-
-
-@pytest.fixture(scope="module")
-def model_evaluator(shared_db_engine, shared_project_storage):
-    """Returns an instantiated ModelEvaluator available at module scope"""
-    populate_source_data(shared_db_engine)
-    base_config = sample_config()
-    # We need to have an ensemble model to test ModelEvaluator correctly
-    # so we can't use the finished_experiment fixture"""
-    base_config['grid_config'] = {
-        'sklearn.ensemble.ExtraTreesClassifier': {
-            'n_estimators': [10],
-            'criterion': ['gini'],
-            'max_depth': [1],
-            'max_features': ['sqrt'],
-            'min_samples_split': [2],
-        }
-    }
-    SingleThreadedExperiment(
-        base_config,
-        db_engine=shared_db_engine,
-        project_path=shared_project_storage.project_path
-    ).run()
-    return ModelEvaluator(1, 1, shared_db_engine)
-
-
-def test_ModelEvaluator_model_type(model_evaluator):
-    assert model_evaluator.model_type == 'sklearn.ensemble.ExtraTreesClassifier'
-
-
-def test_ModelEvaluator_predictions(model_evaluator):
-    assert isinstance(model_evaluator.predictions, pd.DataFrame)
-
-
-def test_ModelEvaluator_feature_importances(model_evaluator):
-    assert isinstance(model_evaluator.feature_importances(), pd.DataFrame)
-
-
-def test_ModelEvaluator_feature_group_importances(model_evaluator):
-    assert isinstance(model_evaluator.feature_group_importances(), pd.DataFrame)
-
-
-def test_ModelEvaluator_test_metrics(model_evaluator):
-    assert isinstance(model_evaluator.test_metrics, pd.DataFrame)
-
-
-def test_ModelEvaluator_train_metrics(model_evaluator):
-    assert isinstance(model_evaluator.train_metrics, pd.DataFrame)
-
-
-def test_ModelEvaluator_crosstabs(model_evaluator, crosstabs_config):
-    run_crosstabs(model_evaluator.engine, crosstabs_config)
-    assert isinstance(model_evaluator.crosstabs, pd.DataFrame)
-
-
-def test_ModelEvaluator_preds_matrix(model_evaluator, shared_project_storage):
-    assert isinstance(model_evaluator.preds_matrix(shared_project_storage.project_path), pd.DataFrame)
-
-
-def test_ModelEvaluator_plot_score_distribution(model_evaluator):
-    with assert_plot_figures_added():
-        model_evaluator.plot_score_distribution()
-
-
-def test_ModelEvaluator_plot_score_label_distributions(model_evaluator):
-    with assert_plot_figures_added():
-        model_evaluator.plot_score_label_distributions()
-
-
-def test_ModelEvaluator_plot_score_distribution_thresh(model_evaluator):
-    with assert_plot_figures_added():
-        model_evaluator.plot_score_distribution_thresh(param_type='rank_abs', param=10)
-
-
-def test_ModelEvaluator_plot_feature_importances(model_evaluator, shared_project_storage):
-    with assert_plot_figures_added():
-        model_evaluator.plot_feature_importances(shared_project_storage.project_path)
-
-
-def test_ModelEvaluator_plot_feature_importances_std_err(model_evaluator, shared_project_storage):
-    with assert_plot_figures_added():
-        model_evaluator.plot_feature_importances_std_err(shared_project_storage.project_path)
-
-
-def test_ModelEvaluator_plot_precision_recall_n(model_evaluator):
-    with assert_plot_figures_added():
-        model_evaluator.plot_precision_recall_n()
-
-
-def test_ModelEvaluator_plot_recall_fpr_n(model_evaluator):
-    with assert_plot_figures_added():
-        model_evaluator.plot_recall_fpr_n()
-
-
-def test_ModelEvaluator_plot_ROC(model_evaluator):
-    with assert_plot_figures_added():
-        model_evaluator.plot_ROC()
-
-
-def test_ModelEvaluator_compute_AUC(model_evaluator):
-    assert isinstance(model_evaluator.compute_AUC(), tuple)
-
-
-def test_ModelEvaluator_cluster_correlation_sparsity(model_evaluator, shared_project_storage):
-    with assert_plot_figures_added():
-        model_evaluator.cluster_correlation_sparsity(shared_project_storage.project_path)
-
-
-def test_ModelEvaluator_cluster_correlation_features(model_evaluator, shared_project_storage):
-    with assert_plot_figures_added():
-        model_evaluator.cluster_correlation_features(shared_project_storage.project_path)
-
-
-def test_ModelEvaluator_plot_feature_group_average_importances(model_evaluator, shared_project_storage):
-    with assert_plot_figures_added():
-        model_evaluator.plot_feature_group_average_importances(path=shared_project_storage.project_path)
diff --git a/src/tests/postmodeling_tests/test_model_group_evaluator.py b/src/tests/postmodeling_tests/test_model_group_evaluator.py
deleted file mode 100644
index 06a31482b..000000000
--- a/src/tests/postmodeling_tests/test_model_group_evaluator.py
+++ /dev/null
@@ -1,74 +0,0 @@
-from triage.component.postmodeling.contrast.model_group_evaluator import ModelGroupEvaluator
-import pandas as pd
-import pytest
-from tests.utils import assert_plot_figures_added
-
-
-@pytest.fixture(scope="module")
-def model_group_evaluator(finished_experiment):
-    return ModelGroupEvaluator((1,1), finished_experiment.db_engine)
-
-
-def test_ModelGroupEvaluator_metadata(model_group_evaluator):
-    assert isinstance(model_group_evaluator.metadata, list)
-    assert len(model_group_evaluator.metadata) == 8 # 8 model groups expected from basic experiment
-    for row in model_group_evaluator.metadata:
-        assert isinstance(row, dict)
-        
-
-def test_ModelGroupEvaluator_model_type(model_group_evaluator):
-    assert model_group_evaluator.model_type[0] == 'sklearn.tree.DecisionTreeClassifier'
-
-
-def test_ModelGroupEvaluator_predictions(model_group_evaluator):
-    assert isinstance(model_group_evaluator.predictions, pd.DataFrame)
-
-
-def test_ModelGroupEvaluator_feature_importances(model_group_evaluator):
-    assert isinstance(model_group_evaluator.feature_importances, pd.DataFrame)
-
-
-def test_ModelGroupEvaluator_metrics(model_group_evaluator):
-    assert isinstance(model_group_evaluator.metrics, pd.DataFrame)
-
-
-def test_ModelGroupEvaluator_feature_groups(model_group_evaluator):
-    assert isinstance(model_group_evaluator.feature_groups, pd.DataFrame)
-
-
-def test_ModelGroupEvaluator_same_time_models(model_group_evaluator):
-    assert isinstance(model_group_evaluator.same_time_models, pd.DataFrame)
-
-
-def test_ModelGroupEvaluator_plot_prec_across_time(model_group_evaluator):
-    with assert_plot_figures_added():
-        model_group_evaluator.plot_prec_across_time()
-
-
-def test_ModelGroupEvaluator_feature_loi_loo(model_group_evaluator):
-    with pytest.raises(IndexError):
-        model_group_evaluator.feature_loi_loo()
-
-
-def test_ModelGroupEvaluator_plot_ranked_correlation_preds(model_group_evaluator):
-    with assert_plot_figures_added():
-        model_group_evaluator.plot_ranked_correlation_preds(param_type='rank_abs', param=10, top_n_features=10)
-
-
-def test_ModelGroupEvaluator_plot_ranked_correlation_features(model_group_evaluator):
-    with assert_plot_figures_added():
-        model_group_evaluator.plot_ranked_correlation_features(param_type='rank_abs', param=10, top_n_features=10)
-
-def test_ModelGroupEvaluator_plot_jaccard_preds(model_group_evaluator):
-    with assert_plot_figures_added():
-        model_group_evaluator.plot_jaccard_preds(param_type='rank_abs', param=10)
-
-
-def test_ModelGroupEvaluator_plot_jaccard_features(model_group_evaluator):
-    with assert_plot_figures_added():
-        model_group_evaluator.plot_jaccard_features()
-
-
-def test_ModelGroupEvaluator_plot_preds_comparison(model_group_evaluator):
-    with assert_plot_figures_added():
-        model_group_evaluator.plot_preds_comparison(param_type='rank_abs', param=10)
diff --git a/src/tests/postmodeling_tests/test_plots.py b/src/tests/postmodeling_tests/test_plots.py
new file mode 100644
index 000000000..011732e91
--- /dev/null
+++ b/src/tests/postmodeling_tests/test_plots.py
@@ -0,0 +1,55 @@
+from triage.component.postmodeling import Model, ModelGroup, get_model, get_model_group, session
+from triage.component.postmodeling.plots import plot_roc, plot_precision_recall_n, plot_metric_over_time
+from triage.component.postmodeling.crosstabs import run_crosstabs
+from tests.utils import sample_config, populate_source_data, assert_plot_figures_added
+from triage.experiments import SingleThreadedExperiment
+import pandas as pd
+import pytest
+import os
+
+@pytest.fixture(scope="module")
+def model(shared_db_engine, shared_project_storage):
+    """Returns an instantiated ModelEvaluator available at module scope"""
+    populate_source_data(shared_db_engine)
+    base_config = sample_config()
+    # We need to have an ensemble model to test ModelEvaluator correctly
+    # so we can't use the finished_experiment fixture"""
+    base_config['grid_config'] = {
+        'sklearn.ensemble.ExtraTreesClassifier': {
+            'n_estimators': [10],
+            'criterion': ['gini'],
+            'max_depth': [1],
+            'max_features': ['sqrt'],
+            'min_samples_split': [2],
+        }
+    }
+    SingleThreadedExperiment(
+        base_config,
+        db_engine=shared_db_engine,
+        project_path=shared_project_storage.project_path
+    ).run()
+
+
+    session = create_session(shared_db_engine)
+
+    return get_model(1)
+
+@pytest.fixture(scope="module")
+def model_group(finished_experiment):
+    os.environ["DATABASE_URL"] = finished_experiment.db_engine.url
+
+    return get_model_group(1)
+
+
+def test_plot_metric_over_time(model_group):
+    with assert_plot_figures_added():
+        plot_metric_over_time(model_group, metric='precision', parameter='10_pct')
+
+
+def test_plot_precision_recall_n(model):
+    with assert_plot_figures_added():
+        plot_precision_recall_n(model)
+
+def test_plot_ROC(model):
+    with assert_plot_figures_added():
+        plot_ROC(model)
diff --git a/src/triage/component/postmodeling/README.org b/src/triage/component/postmodeling/README.org
index da12a3272..c326c3901 100644
--- a/src/triage/component/postmodeling/README.org
+++ b/src/triage/component/postmodeling/README.org
@@ -89,6 +89,8 @@ or an individual =Model=
 m = get_model(model_id = 5)
 #+END_SRC
 
+
+
 #+BEGIN_SRC jupyter-python :session postmodeling
 plot_precision_recall_n(m)
 #+END_SRC
diff --git a/src/triage/component/postmodeling/__init__.py b/src/triage/component/postmodeling/__init__.py
index bf3f9c745..09da6373b 100644
--- a/src/triage/component/postmodeling/__init__.py
+++ b/src/triage/component/postmodeling/__init__.py
@@ -3,6 +3,7 @@
 import os
 import yaml
 import logging
+import warnings
 
 import sqlalchemy
 from sqlalchemy.engine.url import URL
@@ -19,21 +20,18 @@
 logging.basicConfig(level=logging.INFO)
 
 
-def __db_url():
+def __db_url_from_environment():
     environ_url = os.getenv('DATABASE_URL')
     if environ_url:
         logging.info("Getting db connection credentials from DATABASE_URL")
         return environ_url
 
-    if os.path.isfile(os.getenv('DATABASE_FILE')):
+    if os.getenv('DATABASE_FILE') and os.path.isfile(os.getenv('DATABASE_FILE')):
         logging.info("Getting db connection credentials from DATABASE_FILE")
         dbfile = open(os.getenv('DATABASE_FILE'))
     else:
-        raise EnvironmentError(
-            f"could not determine database connection information from "
-            f"either process environment (DATABASE_URL) or filesystem "
-            f"(DATABASE_FILE)"
-        )
+        warnings.warn("There is no DATABASE_URL or DATABASE_FILE  environment variable")
+        return None
 
     with dbfile:
         dbconfig = yaml.load(dbfile)
@@ -48,12 +46,23 @@ def __db_url():
     )
 
 
-__engine = create_engine(__db_url())
-__session = sessionmaker(bind=__engine)
-session = __session()
+def create_session(engine=None):
+    if engine:
+        __engine = engine
+    else:
+        url = __db_url_from_environment()
+        if url:
+            __engine = create_engine()
+        else:
+            return None
 
-Base = declarative_base()
+    session = sessionmaker(bind=__engine)()
+
+    return session
 
+session = create_session()
+
+Base = declarative_base()
 
 def get_model(model_id):
     return session.query(Model).get(model_id)

From 5a55def2880eca0681e93214ca880086a246b61f Mon Sep 17 00:00:00 2001
From: Jesse London <jesselondon@gmail.com>
Date: Mon, 22 Apr 2019 10:47:12 -0500
Subject: [PATCH 09/17] Update src/triage/component/postmodeling/README.org

Co-Authored-By: nanounanue <nanounanue@users.noreply.github.com>
---
 src/triage/component/postmodeling/README.org | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/triage/component/postmodeling/README.org b/src/triage/component/postmodeling/README.org
index c326c3901..47e0152f7 100644
--- a/src/triage/component/postmodeling/README.org
+++ b/src/triage/component/postmodeling/README.org
@@ -56,7 +56,7 @@ You could manipulate those objects using functions using functions:
 
 *NOTE*: This module use the =triage='s /default/ (and recommended) way of specify the
 database connection: an environment variable =DATABASE_URL= or it will
-try to read the connection file fro =DATABASE_FILE=.
+try to read the connection file from a =DATABASE_FILE=.
 
 If you are playing with this module in Jupyter notebooks, remember
 that you can set environment variables with =%env=.

From 1596bb59353c09595e7cb78afe4358fd2b1e333b Mon Sep 17 00:00:00 2001
From: Jesse London <jesselondon@gmail.com>
Date: Mon, 22 Apr 2019 10:47:38 -0500
Subject: [PATCH 10/17] Update src/triage/component/postmodeling/__init__.py

Co-Authored-By: nanounanue <nanounanue@users.noreply.github.com>
---
 src/triage/component/postmodeling/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/triage/component/postmodeling/__init__.py b/src/triage/component/postmodeling/__init__.py
index 09da6373b..8b464578a 100644
--- a/src/triage/component/postmodeling/__init__.py
+++ b/src/triage/component/postmodeling/__init__.py
@@ -20,7 +20,7 @@
 logging.basicConfig(level=logging.INFO)
 
 
-def __db_url_from_environment():
+def _db_url_from_environment():
     environ_url = os.getenv('DATABASE_URL')
     if environ_url:
         logging.info("Getting db connection credentials from DATABASE_URL")

From ff19d0f7d439d61036da307043911882a6093c10 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Mon, 22 Apr 2019 11:16:03 -0500
Subject: [PATCH 11/17] warning -> logging

---
 src/triage/component/postmodeling/__init__.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/triage/component/postmodeling/__init__.py b/src/triage/component/postmodeling/__init__.py
index 8b464578a..b32c37795 100644
--- a/src/triage/component/postmodeling/__init__.py
+++ b/src/triage/component/postmodeling/__init__.py
@@ -3,7 +3,6 @@
 import os
 import yaml
 import logging
-import warnings
 
 import sqlalchemy
 from sqlalchemy.engine.url import URL
@@ -30,7 +29,7 @@ def _db_url_from_environment():
         logging.info("Getting db connection credentials from DATABASE_FILE")
         dbfile = open(os.getenv('DATABASE_FILE'))
     else:
-        warnings.warn("There is no DATABASE_URL or DATABASE_FILE  environment variable")
+        logging.warn("There is no DATABASE_URL or DATABASE_FILE  environment variable")
         return None
 
     with dbfile:

From 5131af7503174ddddf9de2da7a139bfc31fdbf4c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Mon, 22 Apr 2019 11:19:27 -0500
Subject: [PATCH 12/17] =?UTF-8?q?Trying=20to=20be=20more=20=E2=80=9Cfair?=
 =?UTF-8?q?=E2=80=9D=20:)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/triage/component/postmodeling/__init__.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/triage/component/postmodeling/__init__.py b/src/triage/component/postmodeling/__init__.py
index b32c37795..035a65f7a 100644
--- a/src/triage/component/postmodeling/__init__.py
+++ b/src/triage/component/postmodeling/__init__.py
@@ -25,14 +25,16 @@ def _db_url_from_environment():
         logging.info("Getting db connection credentials from DATABASE_URL")
         return environ_url
 
-    if os.getenv('DATABASE_FILE') and os.path.isfile(os.getenv('DATABASE_FILE')):
-        logging.info("Getting db connection credentials from DATABASE_FILE")
-        dbfile = open(os.getenv('DATABASE_FILE'))
+    dbfile_path = os.getenv('DATABASE_FILE')
+    if dbfile_path:
+        if not os.path.isfile(dbfile_path):
+            logging.error('No such database file path: %s', dbfile_path)
+            return None
     else:
-        logging.warn("There is no DATABASE_URL or DATABASE_FILE  environment variable")
+        logging.warn("Neither environment variable DATABASE_URL or DATABASE_FILE set")
         return None
 
-    with dbfile:
+    with open(dbfile_path) as dbfile:
         dbconfig = yaml.load(dbfile)
 
     return URL(

From be544e1b97960c12fbca1b0e3b6ca25d320e90ae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Mon, 22 Apr 2019 11:22:02 -0500
Subject: [PATCH 13/17] =?UTF-8?q?Removed=20=E2=80=9Cfunctional=20programmi?=
 =?UTF-8?q?ng=20imperative=E2=80=9D=20style?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/triage/component/postmodeling/__init__.py | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/src/triage/component/postmodeling/__init__.py b/src/triage/component/postmodeling/__init__.py
index 035a65f7a..8f86ea329 100644
--- a/src/triage/component/postmodeling/__init__.py
+++ b/src/triage/component/postmodeling/__init__.py
@@ -48,18 +48,14 @@ def _db_url_from_environment():
 
 
 def create_session(engine=None):
-    if engine:
-        __engine = engine
-    else:
-        url = __db_url_from_environment()
-        if url:
-            __engine = create_engine()
-        else:
+    if engine is None:
+        url = _db_url_from_environment()
+        if not url:
             return None
 
-    session = sessionmaker(bind=__engine)()
+        engine = create_engine(url)
 
-    return session
+    return sessionmaker(bind=engine)()
 
 session = create_session()
 

From 8885c58cfbae7f71b04099e8562d3291d3b41749 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Mon, 22 Apr 2019 11:25:57 -0500
Subject: [PATCH 14/17] sessionmaker -> Session (see
 https://docs.sqlalchemy.org/en/13/orm/session_api.html#session-and-sessionmaker)

---
 src/triage/component/postmodeling/__init__.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/triage/component/postmodeling/__init__.py b/src/triage/component/postmodeling/__init__.py
index 8f86ea329..4e6a66334 100644
--- a/src/triage/component/postmodeling/__init__.py
+++ b/src/triage/component/postmodeling/__init__.py
@@ -8,7 +8,7 @@
 from sqlalchemy.engine.url import URL
 from sqlalchemy import create_engine
 from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker, relationship
+from sqlalchemy.orm import Session, relationship
 import sqlalchemy.dialects.postgresql as postgresql
 from sqlalchemy import Column, ForeignKey
 
@@ -55,7 +55,7 @@ def create_session(engine=None):
 
         engine = create_engine(url)
 
-    return sessionmaker(bind=engine)()
+    return Session(bind=engine)
 
 session = create_session()
 

From a5fd6e731582243deec0a67cf567f6e0b6798a1e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Mon, 22 Apr 2019 11:28:38 -0500
Subject: [PATCH 15/17] Removed transitioning files

---
 .../component/postmodeling/error_analysis.py  | 169 -------
 src/triage/component/postmodeling/jaccard.py  | 422 ------------------
 2 files changed, 591 deletions(-)
 delete mode 100644 src/triage/component/postmodeling/error_analysis.py
 delete mode 100644 src/triage/component/postmodeling/jaccard.py

diff --git a/src/triage/component/postmodeling/error_analysis.py b/src/triage/component/postmodeling/error_analysis.py
deleted file mode 100644
index 3a4c24d0e..000000000
--- a/src/triage/component/postmodeling/error_analysis.py
+++ /dev/null
@@ -1,169 +0,0 @@
-# coding: utf-8
-
-def _error_labeler(self,
-                  path,
-                  param=None,
-                  param_type=None):
-    '''
-    Explore the underlying causes of errors using decision trees to explain the
-    residuals base on the same feature space used in the model. This
-    exploration will get the most relevant features that determine y - y_hat
-    distance and may help to understand the outomes of some models.
-
-    This function will label the errors and return two elements relevant to
-    model these. First, a feature matrix (X) with all the features used by
-    the model. Second, an iterator with different labeled errors: FPR, FRR,
-    and the general error.
-
-    Arguments:
-        - param_type: (str) type of parameter to define a threshold. Possible
-          values come from triage evaluations: rank_abs, or rank_pct
-        - param: (int) value
-        - path: path for the ProjectStorage class object
-    '''
-
-    test_matrix = self.preds_matrix(path)
-
-    if param_type == 'rank_abs':
-        # Calculate residuals/errors
-        test_matrix_thresh = test_matrix.sort_values(['rank_abs'], ascending=True)
-        test_matrix_thresh['above_thresh'] = \
-                np.where(test_matrix_thresh['rank_abs'] <= param, 1, 0)
-        test_matrix_thresh['error'] = test_matrix_thresh['label_value'] - \
-                test_matrix_thresh['above_thresh']
-    elif param_type == 'rank_pct':
-        # Calculate residuals/errors
-        test_matrix_thresh = test_matrix.sort_values(['rank_pct'], ascending=True)
-        test_matrix_thresh['above_thresh'] = \
-                np.where(test_matrix_thresh['rank_pct'] <= param, 1, 0)
-        test_matrix_thresh['error'] = test_matrix_thresh['label_value'] - \
-                test_matrix_thresh['above_thresh']
-    else:
-        raise AttributeError('''Error! You have to define a parameter type to
-                             set up a threshold
-                             ''')
-
-    # Define labels using the errors
-    dict_errors = {'FP': (test_matrix_thresh['label_value'] == 0) &
-                          (test_matrix_thresh['above_thresh'] == 1),
-                   'FN': (test_matrix_thresh['label_value'] == 1) &
-                          (test_matrix_thresh['above_thresh'] == 0),
-                   'TP':  (test_matrix_thresh['label_value'] == 1) &
-                          (test_matrix_thresh['above_thresh'] == 1),
-                   'TN':  (test_matrix_thresh['label_value'] == 0) &
-                          (test_matrix_thresh['above_thresh'] == 0)
-                  }
-    test_matrix_thresh['class_error'] = np.select(condlist=dict_errors.values(),
-                                                 choicelist=dict_errors.keys(),
-                                                 default=None)
-
-    # Split data frame to explore FPR/FNR against TP and TN
-    test_matrix_thresh_0 = \
-    test_matrix_thresh[test_matrix_thresh['label_value'] == 0]
-    test_matrix_thresh_1 = \
-    test_matrix_thresh[test_matrix_thresh['label_value'] == 1]
-    test_matrix_predicted_1 = \
-    test_matrix_thresh[test_matrix_thresh['above_thresh'] == 1]
-
-    dict_error_class = {'FPvsAll': (test_matrix_thresh['class_error'] == 'FP'),
-                        'FNvsAll': (test_matrix_thresh['class_error'] == 'FN'),
-                        'FNvsTP': (test_matrix_thresh_1['class_error'] == 'FN'),
-                        'FPvsTN': (test_matrix_thresh_0['class_error'] == 'FP'),
-                        'FPvsTP': (test_matrix_predicted_1['class_error'] == 'FP')}
-
-    # Create label iterator
-    Y = [(np.where(condition, 1, -1), label) for label, condition in \
-         dict_error_class.items()]
-
-    # Define feature space to model: get the list of feature names
-    storage = ProjectStorage(path)
-    matrix_storage = MatrixStorageEngine(storage).get_store(self.pred_matrix_uuid)
-    feature_columns = matrix_storage.columns()
-
-    # Build error feature matrix
-    matrices = [test_matrix_thresh,
-                test_matrix_thresh,
-                test_matrix_thresh_1,
-                test_matrix_thresh_0,
-                test_matrix_predicted_1]
-    X = [matrix[feature_columns] for matrix in matrices]
-
-    return zip(Y, X)
-
-def _error_modeler(self,
-                  depth=None,
-                  view_plots=False,
-                  **kwargs):
-   '''
-   Model labeled errors (residuals) by the error_labeler (FPR, FNR, and
-   general residual) using a RandomForestClassifier. This function will
-   yield a plot tree for each of the label numpy arrays return by the
-   error_labeler (Y).
-   Arguments:
-       - depth: max number of tree partitions. This is passed directly to
-         the classifier.
-       - view_plot: the plot is saved to disk by default, but the
-         graphviz.Source also allow to load the object and see it in the
-         default OS image renderer
-       - **kwargs: more arguments passed to the labeler: param indicating
-         the threshold value, param_type indicating the type of threshold,
-         and the path to the ProjectStorage.
-   '''
-
-   # Get matrices from the labeler
-   zip_data = self._error_labeler(param_type = kwargs['param_type'],
-                              param = kwargs['param'],
-                              path=kwargs['path'])
-
-   # Model tree and output tree plot
-   for error_label, matrix in zip_data:
-
-       dot_path = 'error_analysis_' + \
-                  str(error_label[1]) + '_' + \
-                  str(self.model_id) + '_' + \
-                  str(kwargs['param_type']) + '@'+ \
-                  str(kwargs['param']) +  '.gv'
-
-       clf = tree.DecisionTreeClassifier(max_depth=depth)
-       clf_fit = clf.fit(matrix, error_label[0])
-       tree_viz = tree.export_graphviz(clf_fit,
-                                       out_file=None,
-                                       feature_names=matrix.columns.values,
-                                       filled=True,
-                                       rounded=True,
-                                       special_characters=True)
-       graph = graphviz.Source(tree_viz)
-       graph.render(filename=dot_path,
-                    directory='error_analysis',
-                    view=view_plots)
-
-       print(dot_path)
-
-def error_analysis(self, threshold, **kwargs):
-    '''
-    Error analysis function for ThresholdIterator objects. This function
-    have the same functionality as the _error.modeler method, but its
-    implemented for iterators, which can be a case use of this analysis.
-    If no iterator object is passed, the function will take the needed
-    arguments to run the _error_modeler.
-    Arguments:
-        - threshold: a threshold and threshold parameter combination passed
-        to the PostmodelingParamters. If multiple parameters are passed,
-        the function will iterate through them.
-        -**kwags: other arguments passed to _error_modeler
-    '''
-
-    error_modeler = partial(self._error_modeler,
-                           depth = kwargs['depth'],
-                           path = kwargs['path'],
-                           view_plots = kwargs['view_plots'])
-
-    if isinstance(threshold, dict):
-       for threshold_type, threshold_list in threshold.items():
-           for threshold in threshold_list:
-               print(threshold_type, threshold)
-               error_modeler(param_type = threshold_type,
-                             param = threshold)
-    else:
-       error_modeler(param_type=kwargs['param_type'],
-                     param=kwargs['param'])
diff --git a/src/triage/component/postmodeling/jaccard.py b/src/triage/component/postmodeling/jaccard.py
deleted file mode 100644
index 53c6bbd7b..000000000
--- a/src/triage/component/postmodeling/jaccard.py
+++ /dev/null
@@ -1,422 +0,0 @@
-# coding: utf-8
-
-def plot_jaccard_preds(self,
-                       param_type=None,
-                       param=None,
-                       model_subset=None,
-                       temporal_comparison=False,
-                       figsize=(24, 10),
-                       fontsize=12):
-
-    if model_subset is None:
-        model_subset = self.model_id
-
-    preds = self.predictions
-    preds_filter = preds[preds['model_id'].isin(self.model_id)]
-
-    if temporal_comparison == True:
-        try:
-            fig = plt.figure(figsize=figsize)
-            for key, values in \
-            self.same_time_models[['train_end_time', 'model_id_array']].iterrows():
-                preds_filter_group = \
-                preds_filter[preds_filter['model_id'].isin(values[1])]
-                # Filter predictions dataframe by individual dates
-                if param_type == 'rank_abs':
-                    df_preds_date = preds_filter_group.copy()
-                    df_preds_date['above_tresh'] = \
-                            np.where(df_preds_date['rank_abs'] <= param, 1, 0)
-                    df_sim_piv = df_preds_date.pivot(index='entity_id',
-                                                     columns='model_id',
-                                                     values='above_tresh')
-                elif param_type == 'rank_pct':
-                    df_preds_date = preds_filter_group.copy()
-                    df_preds_date['above_tresh'] = np.where(df_preds_date['rank_pct'] <= param, 1, 0)
-                    df_preds_date['new_entity_id'] = df_preds_date['entity_id'].astype(str) + ":" + df_preds_date['as_of_date'].astype(str)
-                    df_sim_piv = df_preds_date.pivot(index='new_entity_id',
-                                                     columns='model_id',
-                                                     values='above_tresh')
-                else:
-                    raise AttributeError('''Error! You have to define a parameter type to
-                                         set up a threshold
-                                         ''')
-                        # Calculate Jaccard Similarity for the selected models
-                res = pdist(df_sim_piv.T, 'jaccard')
-                df_jac = pd.DataFrame(1-squareform(res),
-                                  index=preds_filter_group.model_id.unique(),
-                                  columns=preds_filter_group.model_id.unique())
-                mask = np.zeros_like(df_jac)
-                mask[np.triu_indices_from(mask, k=1)] = True
-
-                # Plot matrix heatmap
-                ax = fig.add_subplot(np.ceil(self.same_time_models.shape[0]/4), 4, key+1)
-                ax.set_xlabel('Model Id', fontsize=fontsize)
-                ax.set_ylabel('Model Id', fontsize=fontsize)
-                plt.title(f'''(as_of_date:{values[0]})''', fontsize=fontsize)
-                sns.heatmap(df_jac,
-                            mask=mask,
-                            cmap='Greens',
-                            vmin=0,
-                            vmax=1,
-                            annot=True,
-                            linewidth=0.1)
-        except ValueError:
-            print(f'''
-                  Temporal comparison can be only made for more than one
-                  model group.
-                 ''')
-
-    else:
-            # Call predicitons
-            if param_type == 'rank_abs':
-                df_preds_date = preds_filter.copy()
-                df_preds_date['above_tresh'] = \
-                        np.where(df_preds_date['rank_abs'] <= param, 1, 0)
-                df_sim_piv = df_preds_date.pivot(index='entity_id',
-                                                 columns='model_id',
-                                                 values='above_tresh')
-            elif param_type == 'rank_pct':
-                df_preds_date = preds_filter.copy()
-                df_preds_date['above_tresh'] = \
-                        np.where(df_preds_date['rank_pct'] <= param, 1, 0)
-                df_preds_date['new_entity_id'] = df_preds_date['entity_id'].astype(str) + ":" + df_preds_date['as_of_date'].astype(str)
-                df_sim_piv = df_preds_date.pivot(index='new_entity_id',
-                                                 columns='model_id',
-                                                 values='above_tresh')
-            else:
-                raise AttributeError('''Error! You have to define a parameter type to
-                                     set up a threshold
-                                     ''')
-
-            # Calculate Jaccard Similarity for the selected models
-            res = pdist(df_sim_piv[model_subset].T, 'jaccard')
-            df_jac = pd.DataFrame(1-squareform(res),
-                                  index=model_subset,
-                                  columns=model_subset)
-            mask = np.zeros_like(df_jac)
-            mask[np.triu_indices_from(mask, k=1)] = True
-
-            # Plot matrix heatmap
-            fig, ax = plt.subplots(figsize=figsize)
-            ax.set_xlabel('Model Id', fontsize=fontsize)
-            ax.set_ylabel('Model Id', fontsize=fontsize)
-            plt.title('Jaccard Similarity Matrix Plot', fontsize=fontsize)
-            sns.heatmap(df_jac,
-                        mask=mask,
-                        cmap='Greens',
-                        vmin=0,
-                        vmax=1,
-                        annot=True,
-                        linewidth=0.1)
-
-
-def plot_jaccard_features(self,
-                          top_n_features=10,
-                          model_subset=None,
-                          temporal_comparison=False,
-                          figsize=(30, 10),
-                          fontsize=12):
-
-    if model_subset is None:
-        model_subset = self.model_id
-
-    f_importances = self.feature_importances
-    f_importances_filter = \
-    f_importances[f_importances['model_id'].isin(model_subset)]
-
-    if temporal_comparison == True:
-        try:
-            fig = plt.figure(figsize=figsize)
-            for key, values in \
-            self.same_time_models[['train_end_time', 'model_id_array']].iterrows():
-                f_imp_filter_group = \
-                f_importances_filter[f_importances_filter['model_id'].isin(values[1])]
-
-                if top_n_features is not None:
-                    f_imp_date = f_imp_filter_group.copy()
-                    f_imp_date_filter = \
-                            f_imp_filter_group.sort_values('rank_abs')
-                    f_imp_date_filter_top = \
-                            f_imp_date_filter[f_imp_date_filter['rank_abs']
-                                             <= top_n_features]
-
-                    df_sim_piv = f_imp_date_filter_top.pivot(index='feature',
-                                                             columns='model_id',
-                                                             values='rank_abs')
-                else:
-                    raise AttributeError('''Error! You have to define a top_n features to
-                                         set up a threshold
-                                         ''')
-
-                # Calculate Jaccard Similarity for the selected models
-                res = pdist(df_sim_piv.T, 'jaccard')
-                df_jac = pd.DataFrame(1-squareform(res),
-                                  index=values[1],
-                                  columns=values[1])
-                mask = np.zeros_like(df_jac)
-                mask[np.triu_indices_from(mask, k=1)] = True
-
-                # Plot matrix heatmap
-                ax = fig.add_subplot(np.ceil(self.same_time_models.shape[0]/4), 4, key+1)
-                ax.set_xlabel('Model Id', fontsize=fontsize)
-                ax.set_ylabel('Model Id', fontsize=fontsize)
-                plt.title(f'''(as_of_date:{values[0]})''', fontsize=fontsize)
-                sns.heatmap(df_jac,
-                            mask=mask,
-                            cmap='Greens',
-                            vmin=0,
-                            vmax=1,
-                            annot=True,
-                            linewidth=0.1)
-        except ValueError:
-            print(f'''
-                  Temporal comparison can be only made for more than one
-                  model group.
-                 ''')
-
-    else:
-            # Call predicitons
-            if top_n_features is not None:
-                f_importances_filter_all = f_importances_filter.copy()
-                f_importance_filter_all_rank = \
-                        f_importances_filter_all.sort_values('rank_abs')
-                f_importance_filter_all_rank_top = \
-                        f_importance_filter_all_rank[f_importance_filter_all_rank['rank_abs']
-                                                    <= top_n_features]
-
-                df_sim_piv = \
-                f_importance_filter_all_rank_top.pivot(index='feature',
-                                                       columns='model_id',
-                                                       values='rank_abs')
-            else:
-                raise AttributeError('''Error! You have to define a parameter type to
-                                     set up a threshold
-                                     ''')
-
-            # Calculate Jaccard Similarity for the selected models
-            res = pdist(df_sim_piv[model_subset].T, 'jaccard')
-            df_jac = pd.DataFrame(1-squareform(res),
-                                  index=model_subset,
-                                  columns=model_subset)
-            mask = np.zeros_like(df_jac)
-            mask[np.triu_indices_from(mask, k=1)] = True
-
-            # Plot matrix heatmap
-            fig, ax = plt.subplots(figsize=figsize)
-            ax.set_xlabel('Model Id', fontsize=fontsize)
-            ax.set_ylabel('Model Id', fontsize=fontsize)
-            plt.title('Jaccard Similarity Matrix Plot', fontsize=fontsize)
-            sns.heatmap(df_jac,
-                        mask=mask,
-                        cmap='Greens',
-                        vmin=0,
-                        vmax=1,
-                        annot=True,
-                        linewidth=0.1)
-
-
-def _plot_preds_compare_score_dist(self,
-                                   m0,
-                                   m1,
-                                   df_preds_date,
-                                   colors=['blue', 'orange'],
-                                   bins=np.arange(0,1.01,0.01)):
-
-    '''
-    Plotting function for comparing prediction distributions across models.
-    This function takes two model_ids with predictions in the same
-    prediction window and shows the relative distribution of
-    the first model top-k in the second model score distribution.
-
-    This function is meant to be used as a helper function of
-    plot_preds_comparisons.
-
-    Arguments:
-        - m0, m1: (int) model_id
-        - df_preds_date: (dataframe) predictions dataframe
-        - colors: (str) color strings. Defaults are blue and orange
-        - bins: (np array) number of bins to pass to the seaborn histogram
-        plotting function
-
-    Returns:
-        matplotlib plot object
-    '''
-
-    df_preds_m0 = df_preds_date[df_preds_date['model_id']==m0]
-    df_preds_m1 = df_preds_date[df_preds_date['model_id']==m1]
-
-    sns.distplot(df_preds_m0[df_preds_m0['above_tresh']==0]['score'],
-                 kde=False,
-                 bins=bins,
-                 color='grey',
-                 label="model " + str(m0) + " predicted label = 0")
-    sns.distplot(df_preds_m0[df_preds_m0['above_tresh']==1]['score'],
-                 kde=False,
-                 bins=bins,
-                 color=colors[1],
-                 label="model " + str(m0) + " predicted label = 1")
-
-    df_alt_model_scores = \
-            pd.merge(df_preds_m0, df_preds_m1[df_preds_m1.above_tresh==1][['entity_id', 'as_of_date']])
-
-    sns.distplot(df_alt_model_scores['score'],
-                 kde=False,
-                 bins=bins,
-                 color=colors[0],
-                 label="model " + str(m1) + " predicted label = 1")
-
-    plt.xlabel("Scores from model " + str(m0))
-    plt.legend()
-
-def _plot_preds_compare_rank(self,
-                             m0,
-                             m1,
-                             df_preds_date,
-                             colors=['black'],
-                             show_tp_fp=False,
-                             bins = np.arange(0,110,10)):
-    '''
-    Plot predictions rank comparison for two selected models.
-
-    This function will rank the predictions from one model into the decile
-    distribution of the second one. This function is meant to be used as a
-    part of the plot_preds_comparison function.
-
-    Arguments:
-        - m0, m1: (int) model_ids to compare, only two.
-        - df_preds_date: (dataframe) predictions dataframe
-        - colors: (str) color string. Default is black
-        - show_tp_tn: (bool) Plot true positive and true negatives in the
-                       rank distribution plot. Default is False
-        - bins: (np array) Number of bins to pass to the seaborn
-        histogram plot function.
-    '''
-
-    df_preds_m0 = df_preds_date[df_preds_date['model_id']==m0]
-    df_preds_m1 = df_preds_date[df_preds_date['model_id']==m1]
-    df_alt_model_rank = \
-            pd.merge(df_preds_m0, df_preds_m1[df_preds_m1.above_tresh==1][['entity_id', 'as_of_date']])
-
-    if show_tp_fp:
-        sns.distplot(df_alt_model_rank[df_alt_model_rank['label_value']==0]['rank_pct'],
-                     kde=False,
-                     bins=bins,
-                     hist=True,
-                     color=colors[0],
-                     label="false positives")
-        sns.distplot(df_alt_model_rank[df_alt_model_rank['label_value']==1]['rank_pct'],
-                     kde=False,
-                     bins=bins,
-                     hist=True,
-                     color=colors[1],
-                     label="true positives")
-        plt.legend()
-    else:
-        sns.distplot(df_alt_model_rank['rank_pct'],
-                     kde=False,
-                     bins=bins,
-                     hist=True,
-                     color=colors[0])
-    plt.xlabel("Percentile Rank in model " + str(m0))
-    plt.title("model "+str(m1)+" predicted label = 1")
-    plt.xticks(bins)
-
-def plot_preds_comparison(self,
-                          param_type=None,
-                          param=None,
-                          model_subset=None,
-                          figsize=(28, 16),
-                          fontsize=12):
-    '''
-    Plot predictor distribution comparison (distribution and rank)
-
-    This function compares the predictions of all models, or a subset passed to
-    model_subset. To compare predictions, the function will show the
-    relative position of the score distribution of the top-k of one of the
-    models into another model.
-
-    Also, to compare how "off" can predictions be, the function will plot
-    the rank position of the predictions of one model in to another. The
-    plot will show the decile position of one model into the other.
-
-    Arguments:
-        - param_type: (str) parameter type (i.e. 'rank_abs', 'rank_pct')
-        - param: (int) parameter threshold
-        - model_subset: (list) list of model_ids to compare. Default is
-        none, and the function will take all the models in self.model_id
-        - figsize, fontsize: aesthetics for plots.
-    '''
-
-    if model_subset is None:
-        model_subset = self.model_id
-
-    preds = self.predictions
-    preds_filter = preds[preds['model_id'].isin(self.model_id)]
-
-    fig = plt.figure(figsize=figsize)
-    try:
-        for key, values in \
-            self.same_time_models[['train_end_time', 'model_id_array']].iterrows():
-            preds_filter_group = \
-                                 preds_filter[preds_filter['model_id'].isin(values[1])]
-            # Filter predictions dataframe by individual dates
-            df_preds_date = preds_filter_group.copy()
-            if param_type == 'rank_abs':
-                df_preds_date['above_tresh'] = \
-                    np.where(df_preds_date['rank_abs'] <= param, 1, 0)
-            elif param_type == 'rank_pct':
-                df_preds_date['above_tresh'] = \
-                    np.where(df_preds_date['rank_pct'] <= param, 1, 0)
-
-            else:
-                raise AttributeError('''Error! You have to define a parameter type to
-                set up a threshold
-                ''')
-
-            sns.set_style('whitegrid')
-            sns.set_context("poster", font_scale=1.25, rc={"lines.linewidth": 2.25,"lines.markersize":12})
-            plt.clf()
-            fig = plt.figure(figsize=figsize)
-            for pair in itertools.combinations(values['model_id_array'], 2):
-                m0 = pair[0]
-                m1 = pair[1]
-                colors = {m0: 'blue', m1: 'orange'}
-                ax1 = plt.subplot(231)
-                self._plot_preds_compare_score_dist(pair[0], pair[1],
-                                                   df_preds_date,
-                                                   colors=[colors[m0], colors[m1]])
-                ax1 = plt.subplot(234)
-                self._plot_preds_compare_score_dist(pair[1],
-                                                   pair[0],
-                                                   df_preds_date,
-                                                   colors=[colors[m1], colors[m0]])
-                ax1 = plt.subplot(232)
-                self._plot_preds_compare_rank(pair[0],
-                                             pair[1],
-                                             df_preds_date,
-                                             colors=[colors[m0]])
-                ax1 = plt.subplot(235)
-                self._plot_preds_compare_rank(pair[1],
-                                             pair[0],
-                                             df_preds_date,
-                                             colors=[colors[m1]])
-                ax1 = plt.subplot(233)
-                self._plot_preds_compare_rank(pair[0],
-                                             pair[1],
-                                             df_preds_date,
-                                             show_tp_fp=True,
-                                             colors=['lightblue', 'darkblue'])
-                ax1 = plt.subplot(236)
-                self._plot_preds_compare_rank(pair[1],
-                                             pair[0],
-                                             df_preds_date,
-                                             show_tp_fp=True,
-                                             colors=['khaki', 'darkorange'])
-            plt.tight_layout()
-            fig.suptitle(values['train_end_time'])
-            plt.show()
-    except ValueError:
-        print(f'''
-        Temporal comparison can be only made for more than one
-        model group.
-        ''')

From 6c8f89ffbd8b04fbfa3217c9dd79307a081b8166 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Mon, 22 Apr 2019 11:30:54 -0500
Subject: [PATCH 16/17] =?UTF-8?q?Removed=20=E2=80=9Csuperfluous=20list=20c?=
 =?UTF-8?q?onstruction=E2=80=9D?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/triage/component/postmodeling/plots.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/triage/component/postmodeling/plots.py b/src/triage/component/postmodeling/plots.py
index 603e24df9..f5d7d8a7d 100644
--- a/src/triage/component/postmodeling/plots.py
+++ b/src/triage/component/postmodeling/plots.py
@@ -114,7 +114,7 @@ def plot_precision_recall_n(model, **kwargs):
 def plot_metric_over_time(model_groups, metric, parameter, **kwargs):
 
     def get_model_group_evaluations(model_group):
-        evaluations = pd.concat([get_evaluations(model).query(f"metric == '{metric}@' and parameter == '{parameter}'") for model in model_group])
+        evaluations = pd.concat(get_evaluations(model).query(f"metric == '{metric}@' and parameter == '{parameter}'") for model in model_group)
         evaluations = evaluations.sort_values('evaluation_start_time', ascending=True)
         evaluations = evaluations[['evaluation_start_time', 'value']]
         evaluations['type'] = model_group.type.split('.')[-1]

From 3cda2e468cd2b33f66ba857285ad3b8900c27dbd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adolfo=20De=20Un=C3=A1nue?= <nanounanue@gmail.com>
Date: Mon, 22 Apr 2019 11:32:02 -0500
Subject: [PATCH 17/17] =?UTF-8?q?More=20superfluous=20lists=20construction?=
 =?UTF-8?q?=20removed=20(I=20really=20like=20the=20word=20=E2=80=9Csuperfl?=
 =?UTF-8?q?uous=E2=80=9D)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/triage/component/postmodeling/plots.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/triage/component/postmodeling/plots.py b/src/triage/component/postmodeling/plots.py
index f5d7d8a7d..82dc3c54c 100644
--- a/src/triage/component/postmodeling/plots.py
+++ b/src/triage/component/postmodeling/plots.py
@@ -124,7 +124,7 @@ def get_model_group_evaluations(model_group):
 
     fig, ax = plt.subplots()
 
-    evaluations = pd.concat([get_model_group_evaluations(model_group) for model_group in model_groups])
+    evaluations = pd.concat(get_model_group_evaluations(model_group) for model_group in model_groups)
 
     for name, mg in evaluations.groupby(by='model_group_id'):
         type = mg.type.unique()[0]