oo_adaptive_learning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools as it\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import sklearn.model_selection as ms\n",
    "from sklearn.linear_model import Lasso\n",
    "from abc import ABC, abstractmethod\n",
    "from scipy import stats\n",
    "import warnings\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The scenario being modeled here involves the impact of combinations of drugs on a given output metric. We assume that individual drugs inmpact the output, and that there are higher-order effects of drug combinations on the output as well, but that those effects decay as the combinations increase (i.e., 4th-order effects are less likely/impactful than 2nd-order effects).\n",
    "\n",
    "The goal is to be able to predict the entire combination space with as few measurements as possible. \n",
    "\n",
    "I've implemented an adaptive learning scheme, which takes a model and a current set of data and makes a decision about which sample in the sample space to measure next. Additionally, I've implemented classes to simulate using this scheme, and also a scheme that randomly chooses the next sample to measure, for comparison."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate Test Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "drugs = ['A', 'B', 'C', 'D', 'E', 'F', 'G']\n",
    "\n",
    "# generate all possible combinations of drugs\n",
    "all_combos = []\n",
    "for combo_size in range(1, len(drugs) + 1):\n",
    "    for combo in it.combinations(drugs, combo_size):\n",
    "        all_combos.append(''.join(combo))\n",
    "        \n",
    "# make design matrix of all combinations\n",
    "condition_mat = pd.DataFrame(0, index = all_combos, columns = all_combos)\n",
    "for combo in all_combos:\n",
    "    sub_combos = []\n",
    "    for sub_size in range(1, len(combo) + 1):\n",
    "        for sub_combo in it.combinations(combo, sub_size):\n",
    "            sub_combos.append(''.join(sub_combo))\n",
    "    condition_mat.loc[combo, sub_combos] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_effect = 3\n",
    "error = 0.25\n",
    "rng = np.random.default_rng()\n",
    "\n",
    "# generate effect for each drug combination\n",
    "# possible effect size decays with order of combination\n",
    "effects = [rng.normal(scale = base_effect * 10**-len(combo)) \n",
    "           for combo in all_combos]\n",
    "# base value for each combination (sum of sub-combo effects)\n",
    "y = pd.Series(np.matmul(np.array(condition_mat), np.array(effects)))\n",
    "y.index = condition_mat.index\n",
    "# add error\n",
    "y += rng.normal(scale = error, size = len(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MeasurementIterator (ABC):\n",
    "    \n",
    "    '''\n",
    "    Abstract class for learning model iterators.\n",
    "    Iterates through sample space, \"measuring\" a new sample each time.\n",
    "    _next_step function decides which sample to measure next.\n",
    "    '''\n",
    "    \n",
    "    def __init__(self, x, y, starting_fraction, model):\n",
    "        self.full_x = x\n",
    "        self.full_y = y\n",
    "        self.model = model\n",
    "\n",
    "        train_test = ms.train_test_split(x.index,\n",
    "                                         train_size = starting_fraction)\n",
    "        self.measured = list(train_test[0])\n",
    "        self.unmeasured = list(train_test[1])\n",
    "\n",
    "    def assess_model(self):\n",
    "        # assess predictive power of model given currrently measured samples        \n",
    "        self.model.fit(self.full_x.loc[self.measured, :], \n",
    "                       self.full_y[self.measured])\n",
    "        predictions = self.model.predict(self.full_x.loc[self.unmeasured, :])\n",
    "        return stats.pearsonr(predictions, self.full_y[self.unmeasured])[0]\n",
    "    \n",
    "        \n",
    "    def n_measured(self):\n",
    "        return len(self.measured)\n",
    "    \n",
    "    def __iter__(self):\n",
    "        return self\n",
    "        \n",
    "    def __next__(self):\n",
    "        if len(self.unmeasured) == 0:\n",
    "            raise StopIteration\n",
    "            \n",
    "        next_step = self._next_step()    \n",
    "        \n",
    "        self.measured.append(next_step)\n",
    "        self.unmeasured.remove(next_step)\n",
    "\n",
    "        return next_step\n",
    "    \n",
    "    @abstractmethod\n",
    "    def _next_step(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MeasuringModelSimulator:\n",
    "    \n",
    "    '''\n",
    "    Class for simulating a model in which measurements are taken over time,\n",
    "    increasing the size of the data the model is trained on.\n",
    "    The measurer is a MeasurementIterator, which determines which samples\n",
    "    to measure as it is iterated over.\n",
    "    '''\n",
    "    \n",
    "    def __init__(self, x, y, model, MeasurerClass):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self.model = model\n",
    "        self.MeasurerClass = MeasurerClass\n",
    "    \n",
    "    def __iter__(self):\n",
    "        start_fraction = .25\n",
    "        return self.MeasurerClass(self.x, self.y, start_fraction, self.model)\n",
    "    \n",
    "    def simulate (self, start_point = None, stop_point = None):\n",
    "        # start fraction is passed to train_test_split\n",
    "        # determines how much of the data starts as \"measured\"\n",
    "        if start_point is None:\n",
    "            start_fraction = .25\n",
    "        else:\n",
    "            start_fraction = start_point / len(self.y)\n",
    "        if stop_point is None:\n",
    "            stop_point = len(self.y) - 5\n",
    "                        \n",
    "        measurer = self.MeasurerClass(self.x, self.y,\n",
    "                                      start_fraction, self.model)\n",
    "        n_measureds = []\n",
    "        scores = []\n",
    "        for step in measurer:\n",
    "            n_measureds.append(measurer.n_measured())\n",
    "            scores.append(measurer.assess_model())\n",
    "            \n",
    "            if measurer.n_measured() >= stop_point:\n",
    "                break\n",
    "\n",
    "        return (pd.DataFrame({'n': n_measureds, 'score': scores}))\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AdaptiveIterator (MeasurementIterator):\n",
    "    \n",
    "    '''\n",
    "    Chooses new sample to measure using an adaptive learning scheme.\n",
    "    This scheme prioritizes samples with the highest uncertainity in the model,\n",
    "    to predict the whole samples space as quickly as possible.\n",
    "    '''\n",
    "    \n",
    "    def __init__(self, x, y, starting_fraction, model):\n",
    "        super().__init__(x, y, starting_fraction, model)\n",
    "\n",
    "    def _next_step(self):\n",
    "        # split samples into folds\n",
    "        kfold = ms.KFold(5, shuffle = True)\n",
    "        folds = kfold.split(self.full_x.loc[self.measured, :])\n",
    "        predictions = []\n",
    "        for f in folds:\n",
    "            # use fold to predict unmeasured\n",
    "            self.model.fit(self.full_x.iloc[f[0]], self.full_y[f[0]])\n",
    "            prediction = self.model.predict(self.full_x.loc[self.unmeasured, :])\n",
    "            predictions.append(prediction)\n",
    "        predictions = np.array(predictions)\n",
    "\n",
    "        # next step has highest variance among fold predictions\n",
    "        variances = np.var(predictions, axis = 0)\n",
    "        next_step = self.unmeasured[np.argmax(variances)]\n",
    "\n",
    "        return next_step\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RandomIterator (MeasurementIterator):\n",
    "    \n",
    "    '''\n",
    "    Chooses next sample to measure randomly.\n",
    "    '''\n",
    "    \n",
    "    def __init__(self, x, y, starting_fraction, model):\n",
    "        super().__init__(x, y, starting_fraction, model)\n",
    "        self.rng = np.random.default_rng()\n",
    "\n",
    "    def _next_step(self):\n",
    "        next_step = self.rng.choice(self.unmeasured)\n",
    "        return next_step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because we expect that number of drugs/combinations that have actual effects is small, we can use LASSO regression, which minimizes the number of non-zero coefficients. We use scikit-learn `GridSearchCV` class to try out a number of `alpha` parameter in the LASSO model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "warnings.filterwarnings('ignore', message = 'Objective did not converge')\n",
    "params = {\"alpha\": [1e-5, 1e-4, 1e-3, 5e-3, 1e-2, 5e-2, 1e-1, 1, 3, 5, 7, 10, 15]}\n",
    "lasso_regressor = ms.GridSearchCV(Lasso(), params, \n",
    "                                  scoring = 'neg_mean_squared_error',\n",
    "                                  cv=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# number of simulations to run\n",
    "n_tests = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "ad_simulator = MeasuringModelSimulator(condition_mat, y, \n",
    "                                       lasso_regressor, AdaptiveIterator)\n",
    "ad_runs = [ad_simulator.simulate() for i in range(n_tests)]\n",
    "ad_runs = pd.concat(ad_runs, keys = range(n_tests), names = ['run'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand_simulator = MeasuringModelSimulator(condition_mat, y, \n",
    "                                         lasso_regressor, RandomIterator)\n",
    "rand_runs = [rand_simulator.simulate() for i in range(n_tests)]\n",
    "rand_runs = pd.concat(rand_runs, keys = range(n_tests), names = ['run'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "combined_res = pd.concat([ad_runs, rand_runs], \n",
    "                    keys = ['adaptive', 'random'], \n",
    "                    names = ['method'])\n",
    "combined_res = combined_res.reset_index(['run', 'method'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fd967edd710>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.lineplot(data = combined_res, x = 'n', y = 'score', hue = 'method')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}