diff --git a/.gitignore b/.gitignore
index 9f28f47..e239121 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,4 +5,6 @@ data/*
 *.temporary*
 *data.txt
 *.DS_Store*
-*.ipynb_checkpoints*
\ No newline at end of file
+*.ipynb_checkpoints*
+*.png
+*.csv
\ No newline at end of file
diff --git a/lib/__init__.py b/lib/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/lib/data_aug_utils.py b/lib/data_aug_utils.py
new file mode 100644
index 0000000..019a545
--- /dev/null
+++ b/lib/data_aug_utils.py
@@ -0,0 +1,49 @@
+import typing
+
+import pandas as pd
+
+
+"""
+    Returns df column with tip percentages. If the total amount 
+    of a trip is 0, the tip percent is calculated as 0 by default.
+"""
+def tip_percent_column(total_amount_series: pd.Series,
+                       tip_amount_series: pd.Series):
+    zero_total_indices = total_amount_series == 0
+    tip_percents_including_nans = tip_amount_series / total_amount_series
+    tip_percents_including_nans[zero_total_indices] = 0
+    return tip_percents_including_nans
+
+
+def dollars_per_mile(total_amount_series: pd.Series,
+                       trip_distance_series: pd.Series):
+    zero_distance_indices = trip_distance_series == 0
+    dollars_per_mile = total_amount_series / trip_distance_series
+    dollars_per_mile[zero_distance_indices] = 0
+    return dollars_per_mile
+
+
+"""
+    Returns df column with day picked up in month.
+"""
+def pickup_day_in_month(pickup_date_series: pd.Series):
+    return pickup_date_series.dt.day
+
+"""
+    Returns pickup time in mins since midnight of the day.
+"""
+def pickup_time_sice_midnight(pickup_date_series: pd.Series):
+    return pickup_date_series.dt.hour * 60 + pickup_date_series.dt.minute
+
+"""
+    Returns pickup day of week from 0-6.
+"""
+def pickup_day_in_week(pickup_date_series: pd.Series):
+    return pickup_date_series.dt.weekday
+
+"""
+    Returns month from 0 BC to make it easier for plotting across months across years.
+"""
+def pickup_month_inc_year(pickup_date_series: pd.Series):
+    return pickup_date_series.dt.year * 12 + pickup_date_series.dt.month
+
diff --git a/lib/data_clean_utils.py b/lib/data_clean_utils.py
new file mode 100644
index 0000000..278f248
--- /dev/null
+++ b/lib/data_clean_utils.py
@@ -0,0 +1,15 @@
+import typing
+
+import pandas as pd
+
+"""
+    Cleans up all strings from each column of the NYC Taxi dataset.
+"""
+def hard_coded_cleaning_steps_mutation(df: pd.DataFrame):
+    # Correct string type confusion in vendorid, payment_type
+    df['vendorid'] = df['vendorid'].astype(float).astype(int)
+    df['payment_type'] = df['payment_type'].astype(float).astype(int)
+
+    # Y/N more useful as 0/1 for graphing and analysis
+    df.loc[df['store_and_fwd_flag'] == 'N', 'store_and_fwd_flag'] = 0
+    df.loc[df['store_and_fwd_flag'] == 'Y', 'store_and_fwd_flag'] = 1
\ No newline at end of file
diff --git a/lib/data_load_utils.py b/lib/data_load_utils.py
new file mode 100644
index 0000000..400638e
--- /dev/null
+++ b/lib/data_load_utils.py
@@ -0,0 +1,236 @@
+import typing
+
+import numpy as np
+import pandas as pd
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from enum import Enum
+from ttb import Dataset
+from typing import Optional
+from tqdm.auto import tqdm
+
+
+class TrainTestDataFrameAccessor:
+    '''
+        Supports querying for dataframes corresponding to the training label
+        and nonlabel features of the original df.
+    '''
+    def __init__(self, df_data: pd.DataFrame,
+        time_index_col: pd.Series,
+        x_labels: tuple[str, ...],
+        y_label: str,
+        date_slice_fit: tuple[datetime, datetime],
+        date_slices_infer: tuple[tuple[datetime, datetime], ...]):
+
+        self.x_accessor = SingleDataFrameAccessor(
+            df_data[list(x_labels)], time_index_col,
+            date_slice_fit, date_slices_infer)
+        self.y_accessor = SingleDataFrameAccessor(
+            df_data[[y_label]], time_index_col,
+            date_slice_fit, date_slices_infer)
+
+    def get_fit_dates(self) -> tuple[datetime, datetime]:
+        return self.x_accessor.get_fit_dates()
+
+    def get_dates_infer(self) -> tuple[tuple[datetime, datetime], ...]:
+        return self.x_accessor.get_dates_infer()
+    
+    def get_x_fit(self) -> pd.DataFrame:
+        return self.x_accessor.get_df_fit()
+
+    def get_x_infer_iterable(self) -> Iterable[pd.DataFrame]:
+        yield from self.x_accessor.get_df_infer_iterable()
+    
+    def get_y_fit(self) -> pd.DataFrame:
+        return self.y_accessor.get_df_fit()
+
+    def get_y_infer_iterable(self) -> Iterable[pd.DataFrame]:
+        yield from self.y_accessor.get_df_infer_iterable()
+
+    def get_xy_fit_np(self) -> tuple[np.array, np.array]:
+        return (self.get_x_fit().values.astype(np.float32),
+            self.get_y_fit().values.astype(np.float32))
+
+    def get_xy_infer_iterable_np(self) -> Iterable[np.array, np.array]:
+        for x_df, y_df in zip(self.get_x_infer_iterable(),
+            self.get_y_infer_iterable()):
+            yield (x_df.values.astype(np.float32),
+                y_df.values.astype(np.float32))
+
+
+class AnnotatedTrainTestDataFrameAccessor(TrainTestDataFrameAccessor):
+    def __init__(self, df_data: pd.DataFrame,
+        time_index_col: pd.Series,
+        x_labels: tuple[str, ...],
+        y_label: str,
+        date_slice_fit: tuple[datetime, datetime],
+        date_slices_infer: tuple[tuple[datetime, datetime], ...],
+        is_continuous_annotations: dict):
+        TrainTestDataFrameAccessor.__init__(
+            self, df_data, time_index_col, x_labels, y_label,
+            date_slice_fit, date_slices_infer)
+        self.x_accessor.is_continuous_annotations = is_continuous_annotations
+        self.y_accessor.is_continuous_annotations = is_continuous_annotations
+
+    def get_xy_fit_np(self) -> tuple[
+        tuple[np.array, np.array], tuple[np.array, np.array]]:
+        x_np, y_np = super().get_xy_fit_np()
+        return ((x_np, self.x_accessor.get_annotations()),
+            (y_np, self.y_accessor.get_annotations()))
+
+    def get_xy_infer_iterable_np(self) -> Iterable[
+        tuple[np.array, np.array], tuple[np.array, np.array]]:
+        '''
+            TODO: properly propogate the logic of annotations into the inner class
+            because clearly the annotations are tied to each of x and y values
+            and can be set as an attribute during init
+        '''
+        for xy_tup in super().get_xy_infer_iterable_np():
+            x_np, y_np = xy_tup
+            yield ((x_np, self.x_accessor.get_annotations()),
+                (y_np, self.y_accessor.get_annotations()))
+
+@dataclass
+class SingleDataFrameAccessor:
+    '''
+        Supports iterating through a df by date_slices.
+    '''
+    df_data: pd.DataFrame
+    time_index_col: pd.Series
+    date_slice_fit: tuple[datetime, datetime]
+    date_slices_infer: tuple[tuple[datetime, datetime], ...]
+    is_continuous_annotations: Optional[dict] = None
+
+    def get_fit_dates(self) -> tuple[datetime, datetime]:
+        return self.date_slice_fit
+
+    def get_annotations(self) -> np.array:
+        return np.array(list(
+            map(self.is_continuous_annotations.get,
+            list(self.df_data.columns))))
+    '''
+        Unpacks date_slice into inclusive, exclusive start_date, end_date
+        for slicing df_data.
+    '''
+    def get_date_indices_(self, date_slice: tuple[datetime, datetime]):
+        start_date, end_date = date_slice
+        return (self.time_index_col >= start_date) & \
+            (self.time_index_col < end_date)
+
+    def get_df_fit(self) -> pd.DataFrame:
+        return self.df_data[self.get_date_indices_(self.date_slice_fit)]
+    
+    def get_dates_infer(self) -> tuple[tuple[datetime, datetime], ...]:
+        return self.date_slices_infer
+
+    def get_df_infer_iterable(self) -> Iterable[pd.DataFrame]:
+        for date_slice in self.date_slices_infer:
+            yield self.df_data[self.get_date_indices_(date_slice)]
+    
+    '''
+        Yields the inclusive start date for each df slice for display
+        purposes. Yield datetime instead of Tuple[datetime, datetime]
+        for ease of display.
+    '''
+    def get_curr_date_iterable(self) -> Iterable[datetime]:
+        for date_slice in self.date_slices_infer:
+            yield date_slice[0]
+
+    def get_future_date_iterable(self) -> Iterable[datetime]:
+        for date_slice in self.date_slices_infer:
+            yield date_slice[1]
+
+@dataclass
+class AccessorFactory:
+    '''
+        Dependent on whether is_continuous_annotations
+        is set or not, returns TrainTestDataFrameAccessor
+        or AnnotatedTrainTestDataFrameAccessor
+    '''
+    df_data: pd.DataFrame
+    time_index_col: pd.Series
+    date_slice_fit: tuple[datetime, datetime]
+    date_slices_infer: tuple[tuple[datetime, datetime], ...]
+    is_continuous_annotations: Optional[dict] = None
+
+    def get(self, x_labels: tuple[str, ...], y_label: str):
+        if self.is_continuous_annotations is None:
+            return TrainTestDataFrameAccessor(
+                self.df_data,
+                self.time_index_col,
+                x_labels,
+                y_label,
+                self.date_slice_fit,
+                self.date_slices_infer)
+        else:
+            return AnnotatedTrainTestDataFrameAccessor(
+                self.df_data,
+                self.time_index_col,
+                x_labels,
+                y_label,
+                self.date_slice_fit,
+                self.date_slices_infer,
+                self.is_continuous_annotations)
+
+'''
+    Batches and appends pandas dataframes. Useful for loading
+    large datasets because memory swaps kill performance.
+    Args:
+        progress_format: either 'print' or 'tqdm'
+'''
+def batch_load_df(dataset: Dataset, load_start: datetime, 
+    load_end: datetime, no_batches: int,
+    progress_format: str) -> pd.DataFrame:
+    
+    date_iter = date_iter_step_no(load_start, load_end,
+        step_no = no_batches)
+    if progress_format == 'tqdm':
+        date_iter = tqdm(date_iter, total=no_batches)
+    
+    df_list = []
+    for curr_date, future_date in date_iter:
+        start_time = datetime.now()
+        df_list.append(dataset.load(curr_date, future_date))
+        if progress_format == 'print':
+            print(f"Loaded { curr_date } to { future_date } in "\
+                f"{ datetime.now() - start_time }", end="\r")
+        
+    df_intermonth = pd.concat(df_list)
+    del df_list[:] # free space since loading is so expensive
+    return df_intermonth
+
+
+'''
+    Iterate between start_date (inc) and end_date(inc) for chunking
+    data for loading and graphing.
+
+    args:
+        step_no: subdivisions of delta to advance by for memory
+        management in batch loading
+    
+    yields:
+        (curr_date, future_date), inclusive exclusive tuple whose
+        union covers entire date range.
+'''
+def date_iter_step_no(
+    start_date: typing.Union[str, datetime],
+    end_date: typing.Union[str, datetime],
+    step_no: int = 100,
+    ):
+    delta = (end_date - start_date) / step_no
+    curr_date = start_date
+    while curr_date < end_date:
+        yield (curr_date, curr_date + delta)
+        curr_date += delta
+
+def date_iter_step_size(
+    start_date: typing.Union[str, datetime],
+    end_date: typing.Union[str, datetime],
+    step_size: timedelta = timedelta(days=7),
+    ):
+    curr_date = start_date
+    while curr_date < end_date:
+        yield (curr_date, curr_date + step_size)
+        curr_date += step_size
\ No newline at end of file
diff --git a/lib/model.py b/lib/model.py
new file mode 100644
index 0000000..1dba10c
--- /dev/null
+++ b/lib/model.py
@@ -0,0 +1,169 @@
+import abc
+
+import numpy as np
+import torch
+from alibi_detect.cd import (ChiSquareDrift, ClassifierDrift,
+                             ClassifierUncertaintyDrift, CVMDrift, FETDrift,
+                             KSDrift, LearnedKernelDrift, LSDDDrift, MMDDrift,
+                             SpotTheDiffDrift, TabularDrift)
+from alibi_detect.utils.pytorch.kernels import DeepKernel
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import f1_score
+from torch import nn
+
+# TODO: implement preprocessing for feature reduction in all models
+class ModelWrapperInterface(abc.ABC):
+    '''
+        Drift detector wrapper.
+    '''
+    @abc.abstractmethod
+    def fit(self, x_fit, y_fit):
+        '''
+            Initializes a drift detector with some combination of
+            x_fit, y_fit. x_fit, y_fit can be of any type, depending
+            on the data loader implementation.
+        '''
+        pass
+    @abc.abstractmethod
+    def infer(self, x_infer, y_infer) -> float:
+        '''
+            Returns p-value corresponding to drift for the drift
+            detector initialized in fit method.
+        '''
+        pass
+
+class CVMModel(ModelWrapperInterface):
+    def fit(self, x_fit, y_fit):
+        self.model = CVMDrift(x_fit)
+    def infer(self, x_infer, y_infer) -> float:
+        return self.model.predict(x_infer)['data']['p_val'][0]
+
+class MMDModel(ModelWrapperInterface):
+    def fit(self, x_fit, y_fit):
+        self.model = MMDDrift(x_fit)
+    def infer(self, x_infer, y_infer) -> float:
+        return self.model.predict(x_infer)['data']['p_val']
+
+class TabularModel(ModelWrapperInterface):
+    def fit(self, x_fit_annotated, y_fit_annotated):
+        '''
+            Because TabularModel chooses between KS and Chi-Squared
+            feature-wise drift detection depending on user labels,
+            each argument should be composed of a numpy array of features
+            and a boolean numpy array of whether each feature is continuous.
+        '''
+        x_fit, x_is_continuous_annotations = x_fit_annotated
+        tabular_continuous_annotation = {}
+        for i in range(x_is_continuous_annotations.shape[0]):
+            if not x_is_continuous_annotations[i]:
+                tabular_continuous_annotation[i] = None
+        self.model = TabularDrift(x_fit,
+            categories_per_feature = tabular_continuous_annotation)
+    def infer(self, x_infer_annotated, y_infer_annotated) -> float:
+        x_infer, _ = x_infer_annotated
+        return self.model.predict(x_infer)['data']['p_val'][0]
+
+class FETModel(ModelWrapperInterface):
+    def __init__(self, classifier_model = None, train_drift_frac = .7):
+        if classifier_model is None:
+            classifier_model = RandomForestClassifier()
+        self.classifier_model = classifier_model
+        self.train_drift_frac = train_drift_frac
+    def fit(self, x_fit, y_fit) -> float:
+        shuffled_indices = np.random.permutation(x_fit.shape[0])
+        split_index = round(x_fit.shape[0] * self.train_drift_frac)
+        x_fit_class, x_fit_fet = np.split(x_fit, [split_index,])
+        y_fit_class, y_fit_fet = np.split(y_fit.reshape(-1), [split_index,])
+        self.classifier_model.fit(x_fit_class, y_fit_class)
+        x_fit_classifier_output = np.array(
+            self.classifier_model.predict(x_fit_fet), dtype='bool')
+        self.model = FETDrift(x_fit_classifier_output, alternative='two-sided')
+    def infer(self, x_infer, y_infer) -> float:
+        x_infer_classified = self.classifier_model.predict(x_infer)
+        return self.model.predict(x_infer_classified)['data']['p_val'][0]
+
+class LearnedKernelModel(ModelWrapperInterface):
+    def __init__(self, kernel:DeepKernel):
+        self.kernel = kernel
+    def fit(self, x_fit, y_fit):
+        # pytorch models accept float32 by default.
+        x_fit = x_fit.astype(np.float32)
+        self.model = LearnedKernelDrift(x_fit, self.kernel, backend='pytorch')
+    def infer(self, x_infer, y_infer) -> float:
+        x_infer = x_infer.astype(np.float32)
+        return self.model.predict(x_infer)['data']['p_val']
+
+class ClassifierDriftModel(ModelWrapperInterface):
+    def __init__(self, classifier_model:nn.Module):
+        self.classifier_model = classifier_model
+    def fit(self, x_fit, y_fit):
+        # pytorch models accept float32 by default.
+        x_fit = x_fit.astype(np.float32)
+        self.model = ClassifierDrift(
+            x_fit, self.classifier_model, backend='pytorch')
+    def infer(self, x_infer, y_infer) -> float:
+        x_infer = x_infer.astype(np.float32)
+        return self.model.predict(x_infer)['data']['p_val']
+
+class SpotTheDiffModel(ModelWrapperInterface):
+    def fit(self, x_fit, y_fit):
+        x_fit = x_fit.astype(np.float32)
+        self.model = SpotTheDiffDrift(x_fit, backend='pytorch')
+    def infer(self, x_infer, y_infer) -> float:
+        x_infer = x_infer.astype(np.float32)
+        return self.model.predict(x_infer)['data']['p_val']
+
+class ClassifierUncertaintyModel(ModelWrapperInterface):
+    def __init__(self, classifier_model = None, train_fxn = None, train_drift_frac = .7):
+        if classifier_model is None:
+            classifier_model = nn.Sequential(
+                nn.Linear(18,10),
+                nn.ReLU(),
+                nn.Linear(10,2))
+        if train_fxn is None:
+            train_fxn = lambda *args: None
+        self.train_fxn = train_fxn
+        self.classifier_model = classifier_model
+        self.train_drift_frac = train_drift_frac
+    def fit(self, x_fit, y_fit):
+        shuffled_indices = np.random.permutation(x_fit.shape[0])
+        split_index = round(x_fit.shape[0] * self.train_drift_frac)
+        x_fit_class, x_fit_uncertainty = np.split(x_fit, [split_index,])
+        y_fit_class, y_fit_uncertainty = np.split(y_fit.reshape(-1), [split_index,])
+        self.train_fxn(self.classifier_model, x_fit_class, y_fit_class)
+        x_fit_uncertainty = x_fit_uncertainty.astype(np.float32)
+        self.model = ClassifierUncertaintyDrift(
+            x_fit_uncertainty, self.classifier_model, preds_type='logits', backend='pytorch')
+    def infer(self, x_infer, y_infer) -> float:
+        x_infer = x_infer.astype(np.float32)
+        return self.model.predict(x_infer)['data']['p_val']
+
+# TODO: track the runtime
+class CVMModel(ModelWrapperInterface):
+    def fit(self, x_fit, y_fit):
+        self.model = CVMDrift(x_fit)
+    def infer(self, x_infer, y_infer) -> float:
+        return self.model.predict(x_infer)['data']['p_val'][0]
+
+class OutputClassifierAccuracyBaselineModel(ModelWrapperInterface):
+    '''
+        Wrapper for sklearn classifier model.
+    '''
+    def __init__(self, model):
+        self.model = model
+    def fit(self, x_fit, y_fit):
+        self.model.fit(x_fit, y_fit.reshape(-1))
+    def infer(self, x_infer, y_infer) -> float:
+        return self.model.score(x_infer, y_infer.reshape(-1))
+
+class OutputClassifierF1ScoreBaselineModel(ModelWrapperInterface):
+    '''
+        Wrapper for sklearn classifier model.
+    '''
+    def __init__(self, model):
+        self.model = model
+    def fit(self, x_fit, y_fit):
+        self.model.fit(x_fit, y_fit.reshape(-1))
+    def infer(self, x_infer, y_infer) -> float:
+        y_pred = self.model.predict(x_infer)
+        return f1_score(y_infer.reshape(-1), y_pred, average='micro')
\ No newline at end of file
diff --git a/model.ipynb b/model.ipynb
new file mode 100644
index 0000000..5f33cce
--- /dev/null
+++ b/model.ipynb
@@ -0,0 +1,507 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "%matplotlib inline\n",
+    "\n",
+    "import abc\n",
+    "import joypy\n",
+    "import matplotlib as mpl\n",
+    "import numpy as np\n",
+    "import os\n",
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "import time\n",
+    "import torch\n",
+    "import typing\n",
+    "\n",
+    "from datetime import datetime, timedelta\n",
+    "from matplotlib import pyplot as plt\n",
+    "from matplotlib.ticker import MaxNLocator\n",
+    "from operator import itemgetter\n",
+    "from scipy.stats import entropy\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.ensemble import RandomForestRegressor\n",
+    "from torch import nn\n",
+    "from ttb import Dataset\n",
+    "\n",
+    "from lib.model import (\n",
+    "    ClassifierDriftModel,\n",
+    "    ClassifierUncertaintyModel,\n",
+    "    CVMModel,\n",
+    "    FETModel,\n",
+    "    LearnedKernelModel,\n",
+    "    MMDModel,\n",
+    "    ModelWrapperInterface,\n",
+    "    OutputClassifierAccuracyBaselineModel,\n",
+    "    OutputClassifierF1ScoreBaselineModel,\n",
+    "    SpotTheDiffModel,\n",
+    "    TabularModel,\n",
+    ")\n",
+    "from alibi_detect.utils.pytorch.kernels import DeepKernel\n",
+    "from lib.data_aug_utils import (\n",
+    "    dollars_per_mile,\n",
+    "    pickup_day_in_month,\n",
+    "    pickup_day_in_week,\n",
+    "    pickup_month_inc_year,\n",
+    "    pickup_time_sice_midnight,\n",
+    "    tip_percent_column,\n",
+    ")\n",
+    "from lib.data_clean_utils import hard_coded_cleaning_steps_mutation\n",
+    "from lib.data_load_utils import (\n",
+    "    AccessorFactory,\n",
+    "    AnnotatedTrainTestDataFrameAccessor,\n",
+    "    batch_load_df,\n",
+    "    date_iter_step_size,\n",
+    "    TrainTestDataFrameAccessor,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/1 [00:00<?, ?it/s]C:\\Users\\HP\\anaconda3\\envs\\ttb\\lib\\site-packages\\pandas\\io\\sql.py:758: UserWarning: pandas only support SQLAlchemy connectable(engine/connection) ordatabase string URI or sqlite3 DBAPI2 connectionother DBAPI2 objects are not tested, please consider using SQLAlchemy\n",
+      "  warnings.warn(\n",
+      "100%|██████████| 1/1 [00:46<00:00, 46.91s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "global_start_date = datetime.strptime(\"2020-11-15\", \"%Y-%m-%d\")\n",
+    "global_end_date = datetime.strptime(\"2021-01-01\", \"%Y-%m-%d\")\n",
+    "dataset = Dataset(\"taxi_data\", cutoff_date=global_end_date, backend=\"pandas\")\n",
+    "\n",
+    "# Loading large datasets can cause memory use to spike, so we batch loading here.\n",
+    "df = batch_load_df(dataset, global_start_date, global_end_date, 1, 'tqdm')\n",
+    "hard_coded_cleaning_steps_mutation(df)\n",
+    "df.insert(1, 'pickup_month_inc_year', pickup_month_inc_year(df['tpep_pickup_datetime']))\n",
+    "df.insert(2, 'pickup_day_in_month', pickup_day_in_month(df['tpep_pickup_datetime']))\n",
+    "df.insert(3, 'pickup_mins_since_midnight', pickup_time_sice_midnight(df['tpep_pickup_datetime']))\n",
+    "df.insert(14, 'tip_percent', tip_percent_column(df['total_amount'], df['tip_amount']))\n",
+    "df.insert(15, 'tip_percent_greater_15', df['tip_percent'] > .15)\n",
+    "df.insert(21, 'total_amount_per_mile', dollars_per_mile(df['total_amount'], df['trip_distance']))\n",
+    "\n",
+    "df_sample = df.sample(frac=.0005)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "'''\n",
+    "    Some drift detection methods benefit from the knowledge of\n",
+    "    what features are categorical.\n",
+    "'''\n",
+    "is_continuous_annotations = {\n",
+    "    'congestion_surcharge': False,\n",
+    "    'dolocationid': False,\n",
+    "    'extra': False,\n",
+    "    'fare_amount': True,\n",
+    "    'id': False,\n",
+    "    'improvement_surcharge': False,\n",
+    "    'mta_tax': False,\n",
+    "    'passenger_count': False,\n",
+    "    'payment_type': False,\n",
+    "    'pickup_day_in_month': True,\n",
+    "    'pickup_mins_since_midnight': True,\n",
+    "    'pickup_month_inc_year': False,\n",
+    "    'pulocationid': False,\n",
+    "    'ratecodeid': False,\n",
+    "    'store_and_fwd_flag': False,\n",
+    "    'tip_amount': True,\n",
+    "    'tip_percent_greater_15': False,\n",
+    "    'tip_percent': True,\n",
+    "    'tolls_amount': True,\n",
+    "    'total_amount_per_mile': True,\n",
+    "    'total_amount': True,\n",
+    "    'trip_distance': True,\n",
+    "    'vendorid': False,\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Column payment_type has importance 0.2960063208140351\n",
+      "Column total_amount has importance 0.1687998908281589\n",
+      "Column total_amount_per_mile has importance 0.1179741944185749\n",
+      "Column trip_distance has importance 0.08283040863279292\n",
+      "Column fare_amount has importance 0.0825911048375515\n",
+      "Column pickup_mins_since_midnight has importance 0.07252801181412957\n",
+      "Column pulocationid has importance 0.059496986688820884\n",
+      "Column dolocationid has importance 0.05789193624889628\n",
+      "Column extra has importance 0.02349043962559546\n",
+      "Column passenger_count has importance 0.01653958057372789\n"
+     ]
+    }
+   ],
+   "source": [
+    "x_labels = [\n",
+    "       'congestion_surcharge',\n",
+    "       'dolocationid',\n",
+    "       'extra',\n",
+    "       'fare_amount',\n",
+    "       'improvement_surcharge',\n",
+    "       'mta_tax',\n",
+    "       'passenger_count',\n",
+    "       'payment_type',\n",
+    "       'pickup_mins_since_midnight',\n",
+    "       'pulocationid',\n",
+    "       'ratecodeid',\n",
+    "       'store_and_fwd_flag',\n",
+    "       'tolls_amount',\n",
+    "       'total_amount_per_mile',\n",
+    "       'total_amount',\n",
+    "       'trip_distance',\n",
+    "       'vendorid',\n",
+    "]\n",
+    "y_label = 'tip_percent_greater_15'\n",
+    "\n",
+    "classifier_model = RandomForestClassifier()\n",
+    "classifier_model.fit(df_sample[x_labels], df_sample[y_label])\n",
+    "\n",
+    "name_and_importance = list(zip(x_labels, classifier_model.feature_importances_))\n",
+    "name_and_importance.sort(key = itemgetter(1), reverse=True)\n",
+    "for col_name, importance in name_and_importance[:10]:\n",
+    "    print(f\"Column {col_name} has importance {importance}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_periodic_model_performance(\n",
+    "    df_accessor: TrainTestDataFrameAccessor, \n",
+    "    model: ModelWrapperInterface) -> np.array:\n",
+    "    '''\n",
+    "        Returns performance list when fitted on Accessor\n",
+    "        fit method and inferred on Accessor iterable.\n",
+    "    '''\n",
+    "    perf_list, _ = get_periodic_model_performance_with_time(\n",
+    "        df_accessor, model)\n",
+    "    return perf_list\n",
+    "\n",
+    "def get_periodic_model_performance_with_time(\n",
+    "    df_accessor: TrainTestDataFrameAccessor, \n",
+    "    model: ModelWrapperInterface) -> tuple[np.array, np.array]:\n",
+    "    '''\n",
+    "        Returns performance list when fitted on Accessor\n",
+    "        fit method and inferred on Accessor iterable.\n",
+    "    '''\n",
+    "    model.fit(*df_accessor.get_xy_fit_np())\n",
+    "    \n",
+    "    perf_list = []\n",
+    "    time_list = []\n",
+    "\n",
+    "    for args in df_accessor.get_xy_infer_iterable_np():\n",
+    "        start = time.time()\n",
+    "        perf_list.append(model.infer(*args))\n",
+    "        time_list.append(time.time() - start)\n",
+    "    return np.array(perf_list), np.array(time_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_feature_wise_interweek_performance(\n",
+    "    accessor_factory: AccessorFactory,\n",
+    "    model: ModelWrapperInterface,\n",
+    "    y_label: str):\n",
+    "    fig, axs = plt.subplots(5, 5, figsize=(25,17))\n",
+    "    strftime_rep = '%Y-%m-%d'\n",
+    "\n",
+    "    for ax, col_name in zip(axs.reshape(-1), df_data.columns):\n",
+    "        df_accessor = accessor_factory.get((col_name,), y_label)\n",
+    "        drifts_arr = get_periodic_model_performance(df_accessor, model)\n",
+    "        \n",
+    "        # Can't see 0 or 1 on graph if (0,1)\n",
+    "        ax.set_ylim((-.1, 1.1))\n",
+    "        ax.title.set_text(f'Feature Drift for {col_name}')\n",
+    "        ax.set_ylabel('P-val for No Drift')\n",
+    "        ax.set_xlabel(f'Weeks since {df_accessor.get_fit_dates()[0].strftime(strftime_rep)}')\n",
+    "        ax.xaxis.set_major_locator(MaxNLocator(integer=True))\n",
+    "        ax.plot(range(1, drifts_arr.size + 1), drifts_arr)\n",
+    "    fig.tight_layout()\n",
+    "\n",
+    "def get_drift_perf(\n",
+    "    accessor_factory: AccessorFactory,\n",
+    "    model: ModelWrapperInterface,\n",
+    "    x_labels: tuple[str, ...],\n",
+    "    y_label: str) -> np.array:\n",
+    "\n",
+    "    df_accessor = accessor_factory.get(x_labels, y_label)\n",
+    "    return get_periodic_model_performance(df_accessor, model)\n",
+    "\n",
+    "def get_drift_perf_with_runtimes(\n",
+    "    accessor_factory: AccessorFactory,\n",
+    "    model: ModelWrapperInterface,\n",
+    "    x_labels: tuple[str, ...],\n",
+    "    y_label: str) -> np.array:\n",
+    "\n",
+    "    df_accessor = accessor_factory.get(x_labels, y_label)\n",
+    "    return get_periodic_model_performance_with_time(\n",
+    "        df_accessor, model)\n",
+    "\n",
+    "\n",
+    "def create_df_model_performance(\n",
+    "    model_name: str,\n",
+    "    model_perf: np.array,\n",
+    "    date_slices: tuple[datetime, datetime]) -> pd.DataFrame:\n",
+    "\n",
+    "    strftime_rep = '%Y-%m-%d'\n",
+    "    start_dates = (start_date for start_date, _ in date_slices)\n",
+    "\n",
+    "    date_dict = {start_date.strftime(strftime_rep): perf for start_date, perf in zip(start_dates, model_perf)}\n",
+    "    return pd.DataFrame(date_dict, index=[model_name])\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1800x1224 with 25 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data_cols = [\n",
+    "       'vendorid',\n",
+    "       'pickup_mins_since_midnight',\n",
+    "       'passenger_count',\n",
+    "       'trip_distance',\n",
+    "       'ratecodeid',\n",
+    "       'store_and_fwd_flag',\n",
+    "       'pulocationid',\n",
+    "       'dolocationid',\n",
+    "       'payment_type',\n",
+    "       'fare_amount',\n",
+    "       'extra',\n",
+    "       'mta_tax',\n",
+    "       'tolls_amount',\n",
+    "       'improvement_surcharge',\n",
+    "       'total_amount_per_mile',\n",
+    "       'total_amount',\n",
+    "       'congestion_surcharge',\n",
+    "       'tip_percent_greater_15']\n",
+    "df_data = df_sample[data_cols]\n",
+    "time_index_col = df_sample['tpep_pickup_datetime']\n",
+    "date_slices = tuple(\n",
+    "    date_iter_step_size(global_start_date, global_end_date))\n",
+    "accessor_factory_annotated = AccessorFactory(\n",
+    "    df_data, time_index_col, date_slices[0], date_slices[1:],\n",
+    "    is_continuous_annotations)\n",
+    "\n",
+    "plot_feature_wise_interweek_performance(\n",
+    "    accessor_factory_annotated,\n",
+    "    TabularModel(),\n",
+    "    'tip_percent_greater_15')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "'''\n",
+    "    depend on alibi_detect implementation of trainer for\n",
+    "    fast implementation of train loop\n",
+    "'''\n",
+    "from alibi_detect.models.pytorch.trainer import trainer\n",
+    "from torch.utils.data import TensorDataset, DataLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "No GPU detected, fall back on CPU.\n",
+      "No GPU detected, fall back on CPU.\n",
+      "No GPU detected, fall back on CPU.\n"
+     ]
+    }
+   ],
+   "source": [
+    "x_labels = (\n",
+    "       'vendorid',\n",
+    "       'pickup_mins_since_midnight',\n",
+    "       'passenger_count',\n",
+    "       'trip_distance',\n",
+    "       'ratecodeid',\n",
+    "       'store_and_fwd_flag',\n",
+    "       'pulocationid',\n",
+    "       'dolocationid',\n",
+    "       'payment_type',\n",
+    "       'fare_amount',\n",
+    "       'extra',\n",
+    "       'mta_tax',\n",
+    "       'tolls_amount',\n",
+    "       'improvement_surcharge',\n",
+    "       'total_amount_per_mile',\n",
+    "       'total_amount',\n",
+    "       'congestion_surcharge')\n",
+    "y_label = 'tip_percent_greater_15'\n",
+    "df_data = df_sample[list(x_labels + (y_label,))]\n",
+    "time_index_col = df_sample['tpep_pickup_datetime']\n",
+    "date_slices = tuple(\n",
+    "    date_iter_step_size(global_start_date, global_end_date))\n",
+    "accessor_factory_default = AccessorFactory(\n",
+    "    df_data, time_index_col, date_slices[0], date_slices[1:])\n",
+    "accessor_factory_annotated = AccessorFactory(\n",
+    "    df_data, time_index_col, date_slices[0], date_slices[1:],\n",
+    "    is_continuous_annotations)\n",
+    "\n",
+    "model_perf_dfs = []\n",
+    "runtime_dfs = []\n",
+    "\n",
+    "model_baseline_perf, runtime = get_drift_perf_with_runtimes(accessor_factory_default,\n",
+    "    OutputClassifierAccuracyBaselineModel(RandomForestClassifier()), x_labels, y_label)\n",
+    "model_perf_dfs.append(create_df_model_performance('AccuracyBaseline', model_baseline_perf, date_slices))\n",
+    "runtime_dfs.append(create_df_model_performance('AccuracyBaseline', runtime, date_slices))\n",
+    "\n",
+    "# TODO: verify with Shreya that 'micro' arguments to sklearn f1_score\n",
+    "# is what works for this binary classifier case.\n",
+    "model_baseline_perf, runtime = get_drift_perf_with_runtimes(accessor_factory_default,\n",
+    "    OutputClassifierF1ScoreBaselineModel(RandomForestClassifier()), x_labels, y_label)\n",
+    "model_perf_dfs.append(create_df_model_performance('F1ScoreBaseline', model_baseline_perf, date_slices))\n",
+    "runtime_dfs.append(create_df_model_performance('F1ScoreBaseline', runtime, date_slices))\n",
+    "\n",
+    "drift_perf, runtime = get_drift_perf_with_runtimes(\n",
+    "    accessor_factory_annotated, TabularModel(), x_labels, y_label)\n",
+    "model_perf_dfs.append(create_df_model_performance('TabularModel', drift_perf, date_slices))\n",
+    "runtime_dfs.append(create_df_model_performance('TabularModel', runtime, date_slices))\n",
+    "\n",
+    "drift_perf, runtime = get_drift_perf_with_runtimes(\n",
+    "    accessor_factory_default, CVMModel(), x_labels, y_label)\n",
+    "model_perf_dfs.append(create_df_model_performance('CVMModel', drift_perf, date_slices))\n",
+    "runtime_dfs.append(create_df_model_performance('CVMModel', runtime, date_slices))\n",
+    "\n",
+    "drift_perf, runtime = get_drift_perf_with_runtimes(\n",
+    "    accessor_factory_default, FETModel(), x_labels, y_label)\n",
+    "model_perf_dfs.append(create_df_model_performance('FETModel', drift_perf, date_slices))\n",
+    "runtime_dfs.append(create_df_model_performance('FETModel', runtime, date_slices))\n",
+    "\n",
+    "drift_perf, runtime = get_drift_perf_with_runtimes(\n",
+    "    accessor_factory_default, MMDModel(), x_labels, y_label)\n",
+    "model_perf_dfs.append(create_df_model_performance('MMDModel', drift_perf, date_slices))\n",
+    "runtime_dfs.append(create_df_model_performance('MMDModel', runtime, date_slices))\n",
+    "\n",
+    "proj = nn.Sequential(\n",
+    "    nn.Linear(len(x_labels),  10),\n",
+    "    nn.Linear(10, 10),\n",
+    ")\n",
+    "kernel = DeepKernel(proj, eps=0.01)\n",
+    "drift_perf, runtime = get_drift_perf_with_runtimes(\n",
+    "    accessor_factory_default, LearnedKernelModel(kernel), x_labels, y_label)\n",
+    "model_perf_dfs.append(create_df_model_performance('LearnedKernelModel', drift_perf, date_slices))\n",
+    "runtime_dfs.append(create_df_model_performance('LearnedKernelModel', runtime, date_slices))\n",
+    "\n",
+    "model = nn.Sequential(\n",
+    "    nn.Linear(len(x_labels), 10),\n",
+    "    nn.ReLU(),\n",
+    "    nn.Linear(10, 2),\n",
+    ")\n",
+    "drift_perf, runtime = get_drift_perf_with_runtimes(\n",
+    "    accessor_factory_default, ClassifierDriftModel(model), x_labels, y_label)\n",
+    "model_perf_dfs.append(create_df_model_performance('ClassifierDriftModel', drift_perf, date_slices))\n",
+    "runtime_dfs.append(create_df_model_performance('ClassifierDriftModel', runtime, date_slices))\n",
+    "\n",
+    "drift_perf, runtime = get_drift_perf_with_runtimes(\n",
+    "    accessor_factory_default, SpotTheDiffModel(), x_labels, y_label)\n",
+    "model_perf_dfs.append(create_df_model_performance('SpotTheDiffModel', drift_perf, date_slices))\n",
+    "runtime_dfs.append(create_df_model_performance('SpotTheDiffModel', runtime, date_slices))\n",
+    "\n",
+    "model = nn.Sequential(\n",
+    "    nn.Linear(len(x_labels), 10),\n",
+    "    nn.ReLU(),\n",
+    "    nn.Linear(10, 2),\n",
+    ")\n",
+    "def train_model_function(model, train_x, train_y):\n",
+    "    x_tensor = torch.tensor(train_x, dtype=torch.float)\n",
+    "    y_tensor = torch.tensor(train_y, dtype=torch.long)\n",
+    "    dataloader = DataLoader(TensorDataset(x_tensor, y_tensor))\n",
+    "    trainer(model, nn.CrossEntropyLoss(), dataloader, 'cpu', verbose=0)\n",
+    "drift_perf, runtime = get_drift_perf_with_runtimes(\n",
+    "    accessor_factory_default, ClassifierUncertaintyModel(model, train_model_function), x_labels, y_label)\n",
+    "model_perf_dfs.append(create_df_model_performance('ClassifierUncertaintyModel', drift_perf, date_slices))\n",
+    "runtime_dfs.append(create_df_model_performance('ClassifierUncertaintyModel', runtime, date_slices))\n",
+    "\n",
+    "pd.concat(model_perf_dfs).to_csv('ModelPerfAggregated.csv')\n",
+    "pd.concat(runtime_dfs).to_csv('ModelRuntimeAggregated.csv')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "16005896cb84f99e64a5e3de5f8f72988fbd89dfc36078e24fdce82fe5ee90e7"
+  },
+  "kernelspec": {
+   "display_name": "Python 3.9.7 ('ttb')",
+   "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.9.7"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}