minimal_OPE.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "if (!(\"Notification\" in window)) {\n",
       "    alert(\"This browser does not support desktop notifications, so the %%notify magic will not work.\");\n",
       "} else if (Notification.permission !== 'granted' && Notification.permission !== 'denied') {\n",
       "    Notification.requestPermission(function (permission) {\n",
       "        if(!('permission' in Notification)) {\n",
       "            Notification.permission = permission;\n",
       "        }\n",
       "    })\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/az/anaconda/lib/python2.7/site-packages/sklearn/cross_validation.py:44: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.\n",
      "  \"This module will be removed in 0.20.\", DeprecationWarning)\n",
      "/Users/az/anaconda/lib/python2.7/site-packages/sklearn/grid_search.py:43: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. This module will be removed in 0.20.\n",
      "  DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "import jupyternotify\n",
    "ip = get_ipython()\n",
    "ip.register_magics(jupyternotify.JupyterNotifyMagics)\n",
    "from off_pol_eval_functions import * \n",
    "from sklearn.linear_model import LinearRegression\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline \n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np \n",
    "# from off_pol_eval_functions import * \n",
    "\n",
    "\n",
    "from scipy.optimize import minimize\n",
    "import datetime as datetime\n",
    "import pickle\n",
    "from matplotlib.backends.backend_pdf import PdfPages\n",
    "from matplotlib import collections as matcoll\n",
    "from sklearn import svm\n",
    "import sys\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from scipy.stats import norm\n",
    "\n",
    "np.random.seed(2)\n",
    "\n",
    "\n",
    "d = 10  # dimension of x \n",
    "n = 1500; \n",
    "mu_x = np.zeros(d); \n",
    "sigma_x = np.random.normal(size = (d,1))\n",
    "sigma_x += np.abs(np.min(sigma_x))+0.5\n",
    "sigma_x = np.multiply(sigma_x, np.eye(d))\n",
    "sigma_x /= 2# normalize covariances a little bit \n",
    "\n",
    "W = 1.5 #treatment effect\n",
    "# interact_x = 2\n",
    "white_noise_coef = 0.1\n",
    "\n",
    "# # generate propensity model \n",
    "# def real_prop(x, beta_prop): \n",
    "#     T_SIG = 5\n",
    "#     if len(x.shape) > 1: \n",
    "#         n= x.shape[1]\n",
    "#     else:\n",
    "#         n= len(x)\n",
    "#     return np.dot(x, beta_prop) + np.random.normal(size = (n,1))*T_SIG\n",
    "#     # T is normally distributed conditional on covariates \n",
    "    \n",
    "# # coefficient of treatment effect\n",
    "# beta_cons = -5\n",
    "# beta_x = np.random.normal(size = (d,1))\n",
    "# # interaction term with treatment \n",
    "# beta_x_T = np.random.normal(size = (d,1))*1.5\n",
    "\n",
    "# # sparse interaction terms \n",
    "# sparse_entries = np.random.choice(range(d),size =  int(round(0.7*d)),replace = False)\n",
    "# beta_x_T[sparse_entries] = 0     \n",
    "# sparse_entries = np.random.choice(range(d),size =  int(round(0.35*d)),replace = False)\n",
    "# beta_x[sparse_entries] = 0  \n",
    "\n",
    "# FREQ = 20 \n",
    "# beta_x_quad_T = np.random.normal(size = (d,1))*0.2\n",
    "# sparse_entries = np.random.choice(range(d),size =  int(round(0.6*d)),replace = False)\n",
    "# beta_x_quad_T[sparse_entries] = 0\n",
    "\n",
    "# TRUE_PROP_BETA = np.asarray(beta_x_quad_T + np.random.normal( loc= np.ones((d,1))*2, size = (d,1))).flatten()\n",
    "# print TRUE_PROP_BETA\n",
    "# def real_risk(T, beta_cons, beta_x, beta_x_T, beta_x_quad_T, x):    \n",
    "#     n = len(T); risk = np.zeros(n)\n",
    "#     if np.isscalar(T):\n",
    "#         risk = T*beta_cons + np.dot(beta_x.T, x) + np.dot(beta_x_T.T, x*T) + (T-np.dot(beta_x_quad_T.T,x))**2\n",
    "#     else: \n",
    "#         for i in range(len(T)): \n",
    "#             risk[i] = T[i]*beta_cons + np.dot(beta_x.T, x[i,:]) + np.dot(beta_x_T.T, x[i,:]*T[i]) + (T[i]-np.dot(beta_x_quad_T.T,x[i,:]))**2#+ np.dot(beta_x_quad_T.T, (x[i,:]**2)*T[i]) + np.dot(beta_x_high_freq.T, np.sin(x[i,0:HIGH_FREQ_N]*FREQ)*T[i])\n",
    "#     return risk\n",
    "\n",
    "# T_SIG = 4\n",
    "# def generate_data(mu_x, sigma_x_mat, n, beta_cons, beta_x, beta_x_T): \n",
    "# #     x = np.random.normal(mu_x, sigma_x, size = n)\n",
    "#     # generate n datapoints from the same multivariate normal distribution\n",
    "#     x = np.random.multivariate_normal(mean = mu_x, cov= sigma_x_mat, size = n ) \n",
    "#     print x.shape \n",
    "#     print \"xshape\"\n",
    "#     T = np.random.normal(0, T_SIG, n) + np.dot(x, TRUE_PROP_BETA) + 2*x[:,1] + 4*x[:,2] - 2*x[:,3]\n",
    "#     true_resid = T - np.dot(x, TRUE_PROP_BETA)\n",
    "#     true_Q = norm.pdf( T - np.dot(x, TRUE_PROP_BETA), loc = 0, scale = T_SIG )\n",
    "#     y_sigma = 0.5\n",
    "#     white_noise_coef = 5\n",
    "    \n",
    "#     clf = LinearRegression(); clf.fit(x, T)\n",
    "#     y_hat = clf.predict(x)\n",
    "#     Y = np.zeros(n)\n",
    "#     for i in range(n): \n",
    "#         Y[i] = T[i]*beta_cons + np.dot(beta_x.T, x[i,:]) + T[i]*np.dot(beta_x_T.T, x[i,:]) + (T[i] - np.dot(beta_x_quad_T.T,x[i,:]))**2 #+ np.dot(beta_x_quad_T.T, (x[i,:]**2)*T[i]) + np.dot(beta_x_high_freq.T, np.sin(x[i,0:HIGH_FREQ_N]*FREQ)*T[i])\n",
    "#     Y += np.random.multivariate_normal(mean = np.zeros(n), cov=white_noise_coef * np.eye(n))\n",
    "#     # get pdf from residuals \n",
    "#     resid = Y - y_hat\n",
    "#     # get norm pdf \n",
    "#     Q = norm.pdf(resid, loc = np.mean(resid), scale=np.std(resid))\n",
    "#     T = T.flatten()\n",
    "#     return [x, T, Y, true_Q, clf]\n",
    "\n",
    "# [x_full, T_full, Y_full, true_Q_full, clf] = generate_data(mu_x, sigma_x, n, beta_cons, beta_x, beta_x_T)\n",
    "\n",
    "# #compute real risk \n",
    "# print np.mean( real_risk(T_full, beta_cons, beta_x, beta_x_T, beta_x_quad_T, x_full))\n",
    "\n",
    "# plt.hist(Y_full); plt.title('Y')\n",
    "# plt.figure()\n",
    "# plt.title('T')\n",
    "# plt.hist(T_full)\n",
    "# Q = true_Q_full\n",
    "# plt.figure()\n",
    "# plt.hist(true_Q_full)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simpler synthetic example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.04262406 0.84193477]\n",
      "(700, 2)\n",
      "xshape\n",
      "(700, 2)\n",
      "xshape\n",
      "1.2423927788694011\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([ 24.,  36.,  39.,  42.,  43.,  43.,  67.,  76.,  88., 242.]),\n",
       " array([1.94517234e-05, 9.99094057e-03, 1.99624294e-02, 2.99339182e-02,\n",
       "        3.99054071e-02, 4.98768959e-02, 5.98483848e-02, 6.98198736e-02,\n",
       "        7.97913625e-02, 8.97628513e-02, 9.97343401e-02]),\n",
       " <a list of 10 Patch objects>)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEICAYAAABRSj9aAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114f40d50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEICAYAAABRSj9aAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nLFdyL6cAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10bfc8590>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1185003d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(2)\n",
    "\n",
    "d = 2  # dimension of x \n",
    "n = 700; \n",
    "mu_x = np.zeros(d); \n",
    "sigma_x = np.random.normal(size = (d,1))\n",
    "sigma_x += np.abs(np.min(sigma_x))+0.5\n",
    "sigma_x = np.multiply(sigma_x, np.eye(d))\n",
    "sigma_x /= 2# normalize covariances a little bit \n",
    "\n",
    "W = 1.5 #treatment effect\n",
    "# interact_x = 2\n",
    "white_noise_coef = 0.1\n",
    "\n",
    "# generate propensity model \n",
    "def real_prop(x, beta_prop): \n",
    "    T_SIG = 5\n",
    "    if len(x.shape) > 1: \n",
    "        n= x.shape[1]\n",
    "    else:\n",
    "        n= len(x)\n",
    "    return np.dot(x, beta_prop) + np.random.normal(size = (n,1))*T_SIG\n",
    "    # T is normally distributed conditional on covariates \n",
    "    \n",
    "# coefficient of treatment effect\n",
    "beta_cons = -5\n",
    "beta_x = np.random.normal(size = (d,1))\n",
    "# interaction term with treatment \n",
    "beta_x_T = np.random.normal(size = (d,1))*1.5\n",
    "FREQ = 20 \n",
    "beta_x_quad_T = np.random.normal(size = (d,1))*0.2\n",
    "\n",
    "TRUE_PROP_BETA = np.asarray(beta_x_quad_T + np.random.normal( loc= np.ones((d,1))*2, size = (d,1))).flatten()\n",
    "print TRUE_PROP_BETA\n",
    "\n",
    "def real_risk(T, beta_cons, beta_x, beta_x_T, beta_x_quad_T, x):    \n",
    "    n = len(T); risk = np.zeros(n)\n",
    "    for i in range(len(T)): \n",
    "        risk[i] = -5 + np.abs(T[i])\n",
    "        if x[i,0] > 0 and x[i,1] > 0: \n",
    "            risk[i] = (np.abs(T[i] - x[i,0]))**1.5 #- (np.abs(np.dot(x[i,:],beta_x_quad_T)))**1.5\n",
    "#             risk[i] = T[i]*beta_cons + np.dot(beta_x.T, x[i,:]) + np.dot(beta_x_T.T, x[i,:]*T[i]) + (T[i]-np.dot(beta_x_quad_T.T,x[i,:]))**2#+ np.dot(beta_x_quad_T.T, (x[i,:]**2)*T[i]) + np.dot(beta_x_high_freq.T, np.sin(x[i,0:HIGH_FREQ_N]*FREQ)*T[i])\n",
    "    return risk\n",
    "\n",
    "T_SIG = 4\n",
    "beta_x_quad_T = np.asarray( [1,2] )\n",
    "def generate_data(mu_x, sigma_x_mat, n, beta_x_quad_T, unconfounded=False): \n",
    "    x = np.random.uniform( low = -2,high=2, size = [n,len(mu_x )] )\n",
    "#     x = np.random.multivariate_normal(mean = mu_x, cov= sigma_x_mat, size = n ) \n",
    "    print x.shape \n",
    "    print \"xshape\"\n",
    "    T = np.random.normal(0, T_SIG, n) + np.dot(x, beta_x_quad_T) \n",
    "    true_resid = T - np.dot(x, beta_x_quad_T); true_Q = norm.pdf( T - np.dot(x, beta_x_quad_T), loc = 0, scale = T_SIG ); y_sigma = 0.5; white_noise_coef = 5\n",
    "    clf = LinearRegression(); clf.fit(x, T); y_hat = clf.predict(x); Y = np.zeros(n)\n",
    "    Y = real_risk(T, beta_cons, beta_x, beta_x_T, beta_x_quad_T, x)\n",
    "    return [x, T, Y, true_Q, clf]\n",
    "\n",
    "[x_full, T_full, Y_full, true_Q_full, clf] = generate_data(mu_x, sigma_x, n, beta_x_quad_T)\n",
    "\n",
    "[x_full, T_full, Y_full, true_Q_full, clf] = generate_data(mu_x, sigma_x, n, beta_x_quad_T,unconfounded=True)\n",
    "\n",
    "\n",
    "#compute real risk \n",
    "print np.mean( real_risk(T_full, beta_cons, beta_x, beta_x_T, beta_x_quad_T, x_full))\n",
    "\n",
    "plt.hist(Y_full); plt.title('Y'); plt.figure(); plt.title('T'); plt.hist(T_full); Q = true_Q_full; plt.figure(); plt.hist(true_Q_full)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## train/test split and scale data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n = 300\n",
    "x_test = x_full[n:]; Y_test = Y_full[n:]; T_test = T_full[n:]; true_Q_test = true_Q_full[n:]\n",
    "x = x_full[0:n]; Y = Y_full[0:n];T = T_full[0:n]; true_Q = true_Q_full[0:n]\n",
    "\n",
    "x_ = x - np.mean(x) #demean data\n",
    "mean_x = np.mean(x) \n",
    "n = len(T)\n",
    "X_T = np.hstack([ x,T.reshape([n,1])])\n",
    "T_ = T.reshape([n,1])\n",
    "\n",
    "from sklearn import preprocessing\n",
    "scaler = preprocessing.StandardScaler().fit(X_T)\n",
    "X_T_scaled = scaler.transform(X_T)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use these variants for continuous policy evaluation comparison "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## given Known propensities\n",
    "def off_policy_evaluation_known_Q(**params):\n",
    "    \"\"\"\n",
    "    Takes in a choice of kernel and dictionary of parameters and data required for evaluation\n",
    "    tau is a vector of treatment values (assumed given)\n",
    "    If y_samp, T_samp is present, use that instead. \n",
    "    \"\"\"\n",
    "    [loss, norm_sum] = off_pol_estimator_known_Q(**params)\n",
    "    h = params['h']\n",
    "    n = params['n']\n",
    "    return loss/(norm_sum*1.0*h*n)\n",
    "\n",
    "def off_pol_estimator_known_Q(**params): \n",
    "    THRESH = params['threshold']\n",
    "    y_out = params['y']; x = params['x']; h = params['h'];n = params['n']; t_lo = params['t_lo'];  t_hi = params['t_hi']\n",
    "    kernel = params['kernel_func'];kernel_int =  params['kernel_int_func']\n",
    "    Q = params['Q_known']; \n",
    "    if ('y_samp' in params.keys()):\n",
    "        y_out = params['y_samp']\n",
    "    if ('T_samp' in params.keys()): \n",
    "        T = params['T_samp']\n",
    "    else: \n",
    "        T = params['T']\n",
    "    if ('x_samp' in params.keys()):\n",
    "        x = params['x_samp']\n",
    "\n",
    "    BMI_IND = params.get('BMI_IND') # propensity score for warfarin data evaluations \n",
    "    if (params.get('DATA_TYPE') == 'warfarin'): \n",
    "        x = params['x'][:,BMI_IND]\n",
    "\n",
    "    loss = 0\n",
    "    tau = params['tau']\n",
    "    clip_tau = np.clip(tau, t_lo, t_hi)\n",
    "    Qs = np.zeros(n)\n",
    "    for i in np.arange(n): \n",
    "        Q_i = Q[i]\n",
    "        if (abs(clip_tau[i] - t_lo) <= h):\n",
    "            alpha = kernel_int((t_lo-clip_tau[i])/h, 1)\n",
    "        elif (abs(clip_tau[i] - t_hi) <= h):\n",
    "            alpha = kernel_int(-1,  (t_hi - clip_tau[i])/h )\n",
    "        else:\n",
    "            alpha = 1\n",
    "        Qs[i] = (1.0/h)*kernel( (clip_tau[i] - T[i])/h )/max(Q_i,THRESH)\n",
    "        loss += kernel( (clip_tau[i] - T[i])/h )*1.0 * y_out[i]/max(Q_i,THRESH) * 1.0/alpha\n",
    "    norm_sum = np.mean(np.maximum(Qs,THRESH*np.ones(n)))\n",
    "    return [loss, norm_sum]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## unit test that continuous policy evaluation works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29.92270098541192"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.stats import norm\n",
    "\n",
    "t_lo = np.min(X_T_scaled[:,d])\n",
    "t_hi = np.max(X_T_scaled[:,d])\n",
    "lr = LinearRegression(); lr.fit(X_T_scaled[:,0:d], X_T_scaled[:,d])\n",
    "T_hat = lr.predict(X_T_scaled[:,0:d]); #beta_T_gps = np.dot(x[trainind,:],lr.coef_)\n",
    "resid = X_T_scaled[:,d] - T_hat\n",
    "# Assume normal noise\n",
    "mu_resid = np.mean(resid); sigma_resid = np.std(resid)\n",
    "def norm_T_Q_est(x,t,t_lo,t_hi): \n",
    "    return norm.pdf( t - np.dot(x, lr.coef_), loc =  mu_resid, scale = sigma_resid )\n",
    "\n",
    "n = len(Y)\n",
    "data = { 'n': n, 'y': Y,'Q': norm_T_Q_est,'x_full': X_T_scaled[:,0:d], 'x': X_T_scaled[:,0:d],'x_samp': X_T_scaled[:,0:d], 'T_samp': X_T_scaled[:,d], 'd': d, 'T': X_T_scaled[:,d],'t_lo': t_lo ,'t_hi': t_hi  }\n",
    "data['kernel_int_func'] = epanechnikov_int\n",
    "data['kernel_func'] = epanechnikov_kernel\n",
    "data['sgn'] = 1; data['threshold'] = 0.03\n",
    "data['h'] = 1.2; data['Q_known'] = true_Q\n",
    "# assign tau \n",
    "# standardized or not? \n",
    "data['tau'] = X_T_scaled[:,d] +2\n",
    "\n",
    "off_policy_evaluation_known_Q(**data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### helper function to evaluate different methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 545,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "$(document).ready(\n",
       "    function() {\n",
       "        function appendUniqueDiv(){\n",
       "            // append a div with our uuid so we can check that it's already\n",
       "            // been sent and avoid duplicates on page reload\n",
       "            var notifiedDiv = document.createElement(\"div\")\n",
       "            notifiedDiv.id = \"0893a3a7-d02a-4ad9-aaa7-5bed9a750f4d\"\n",
       "            element.append(notifiedDiv)\n",
       "        }\n",
       "\n",
       "        // only send notifications if the pageload is complete; this will\n",
       "        // help stop extra notifications when a saved notebook is loaded,\n",
       "        // which during testing gives us state \"interactive\", not \"complete\"\n",
       "        if (document.readyState === 'complete') {\n",
       "            // check for the div that signifies that the notification\n",
       "            // was already sent\n",
       "            if (document.getElementById(\"0893a3a7-d02a-4ad9-aaa7-5bed9a750f4d\") === null) {\n",
       "                var notificationPayload = {\"body\": \"Cell execution has finished!\", \"requireInteraction\": false, \"icon\": \"/static/base/images/favicon.ico\"};\n",
       "                if (Notification.permission !== 'denied') {\n",
       "                    if (Notification.permission !== 'granted') { \n",
       "                        Notification.requestPermission(function (permission) {\n",
       "                            if(!('permission' in Notification)) {\n",
       "                                Notification.permission = permission\n",
       "                            }\n",
       "                        })\n",
       "                    }\n",
       "                    if (Notification.permission === 'granted') {\n",
       "                    var notification = new Notification(\"Jupyter Notebook\", notificationPayload)\n",
       "                    appendUniqueDiv()\n",
       "                    notification.onclick = function () {\n",
       "                        window.focus();\n",
       "                        this.close();\n",
       "                        };\n",
       "                    } \n",
       "                }     \n",
       "            }\n",
       "        }\n",
       "    }\n",
       ")\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%notify\n",
    "def get_mse(data, mean_risk): \n",
    "    return np.mean((data - mean_risk)**2) + (np.mean(data) - mean_risk)**2 # variance + bias \n",
    "\n",
    "'''\n",
    "POL_X is input wrt standardized treatment space \n",
    "needs to be scaled back to normal to evaluate outcome model \n",
    "Assume POL_X is unit normalized!\n",
    "'''\n",
    "def eval_possibilities(POL_X, x_T_test_sc, x_test, Y_test, Q, Y_mean_old): \n",
    "    print \"true-in-sample counterfactuals: \"\n",
    "    true_risk = np.mean(real_risk((POL_X*np.std(T))+np.mean(T), beta_cons, beta_x, beta_x_T, beta_x_quad_T, x_test))\n",
    "#     true_risk = np.mean( real_risk((POL_X*np.std(T_))+np.mean(T_), beta_cons, beta_x, beta_x_T, beta_x_quad_T, x_test))\n",
    "    print true_risk\n",
    "    n = len(Y_test); POL_X=POL_X.reshape([n,1])\n",
    "    T_sc_test = x_T_test_sc[:,d].reshape([n,1]); \n",
    "    X_test_pi = np.hstack([ x_T_test_sc[:,0:d], POL_X ])\n",
    "    K_T_pi = k_T(T_sc_test, POL_X)\n",
    "    K_pi_pi = k_T(POL_X, POL_X)\n",
    "    K_XT_XT = k_XT( x_T_test_sc, x_T_test_sc ) + np.eye(n)*10e-3\n",
    "\n",
    "    print \"direct method: \"\n",
    "    dm = np.mean(gp.predict(X_test_pi)) + Y_mean_old # add the empirical mean! \n",
    "    print dm\n",
    "    test_params = {'x_sc': x_T_test_sc[:,0:d], 'T_sc': x_T_test_sc[:,d], 'k_T': k_T, 'k_XT': k_XT, 'k_X': k_X, 'X_pi': X_test_pi, 'K_T_T':K_T_T, 'K_T_pi': K_T_pi, 'K_pi_pi': K_pi_pi, 'K_XT_XT': K_XT_XT }\n",
    "    test_params['x_aug'] = np.hstack([x_T_test_sc[:,0:d], np.ones(n).reshape([n,1])])\n",
    "    test_params['pi'] = assignment_rule_2d\n",
    "    [val, test_wghts] = opt_wghts(POL_X, **test_params)\n",
    "    print \"prop. of strictly positive weights: \" + str(sum(test_wghts >0.001)*1.0 / n)\n",
    "    \n",
    "    pol_eval =  test_wghts.T * Y_test.reshape([n,1]) * 1.0/n \n",
    "    print \"weight-based evaluation: \"\n",
    "    print pol_eval + mean_x\n",
    "    print \"continuous off policy evaluator\"\n",
    "    data = { 'n': len(Y_test), 'y': Y_test,'Q': Q,'x_full': x_T_test_sc[:,0:d], 'x': x_T_test_sc[:,0:d],'x_samp': x_T_test_sc[:,0:d], 'T_samp': x_T_test_sc[:,d], 'd': d, 'T': x_T_test_sc[:,d],'t_lo': t_lo ,'t_hi': t_hi}\n",
    "    data['kernel_int_func'] = epanechnikov_int; data['kernel_func'] = epanechnikov_kernel; data['sgn'] = 1; data['threshold'] = 0.03\n",
    "    data['h'] = 1.2; data['Q_known'] = Q\n",
    "    data['tau'] = POL_X#*np.std(T))+np.mean(T)\n",
    "    \n",
    "    ope = off_policy_evaluation_known_Q(**data)\n",
    "    print ope\n",
    "    return [true_risk, dm, pol_eval, ope]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 552,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(300, 2)"
      ]
     },
     "execution_count": 552,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_sc.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_pol(tht,**params): \n",
    "    n = params['x_sc'].shape[0]\n",
    "    POL_X = np.asarray( [ params['pi']( tht, params['x_sc'][i,:] ) for i in range(n) ] ).flatten().reshape([n,1]) ; \n",
    "    return POL_X\n",
    "\n",
    "n = x_test.shape[0]\n",
    "test_n = len(Y_test); N_REPS = 10\n",
    "# thts = np.asarray([ [1,0,0], [0,1,0], [.5,.5,1], [0,0,2], [2,0,3] ])\n",
    "\n",
    "\n",
    "def eval_over_reps(thts, N_REPS, POL_FN): \n",
    "    n_pols = 4 # number of different evaluation methods \n",
    "    risks = np.zeros([len(test_range), n_pols, N_REPS])\n",
    "    for k in range(N_REPS):\n",
    "        n=400; \n",
    "        [x_test, T_test, Y_test, true_Q, clf] = generate_data(mu_x, sigma_x, n, beta_x_quad_T)\n",
    "        X_test_T = np.hstack([ x_test,T_test.reshape([n,1])])\n",
    "        x_T_test_sc = scaler.transform(X_test_T)   ; T_sc_test = x_T_test_sc[:,d].reshape([n,1])\n",
    "        POL_X = np.dot(x_T_test_sc[:,0:d], beta_x_quad_T).reshape([n,1]); X_test_pi = np.hstack([ x_T_test_sc[:,0:d], POL_X ])\n",
    "        K_T_pi = k_T(T_sc_test, POL_X); K_T_T = k_T(T_sc_test, T_sc_test); K_pi_pi = k_T(POL_X, POL_X); K_XT_XT = k_XT( x_T_test_sc, x_T_test_sc ) + np.eye(n)*10e-3\n",
    "\n",
    "        test_params = {'x_sc': x_T_test_sc[:,0:d],'n':n, 'T_sc': x_T_test_sc[:,d], 'k_T': k_T, 'k_XT': k_XT, 'k_X': k_X, 'X_pi': X_test_pi, 'K_T_T':K_T_T, 'K_T_pi': K_T_pi, 'K_pi_pi': K_pi_pi, 'K_XT_XT': K_XT_XT }\n",
    "        test_params['pi'] = assignment_rule_2d\n",
    "\n",
    "        for (ind, test_t) in enumerate(test_range): \n",
    "            print '-------t------------'\n",
    "            print test_t\n",
    "            print '---------'\n",
    "            #(np.ones(test_n)*test_t)*np.std(T)+np.mean(T)\n",
    "            pol = get_pol(thts[ind,:], **test_params)\n",
    "            # evaluate policy projected to scaled space \n",
    "            risks[ind,:, k] = eval_possibilities( (pol-np.mean(T))/np.std(T), x_T_test_sc, x_test, Y_test, true_Q, np.mean(Y) )\n",
    "    return risks\n",
    "\n",
    "\n",
    "risks = eval_over_reps( thts, N_REPS, get_pol )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 551,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------t------------\n",
      "-0.2\n",
      "---------\n",
      "true-in-sample counterfactuals: \n",
      "2.57469696802\n",
      "direct method: \n",
      "2.36644618097\n",
      "prop. of strictly positive weights: [[ 0.3575]]\n",
      "weight-based evaluation: \n",
      "[[ 1.09024674]]\n",
      "continuous off policy evaluator\n",
      "[ 0.23957388]\n",
      "-------t------------\n",
      "-0.1\n",
      "---------\n",
      "true-in-sample counterfactuals: \n",
      "-1.41776786459\n",
      "direct method: \n",
      "-1.41513931895\n",
      "prop. of strictly positive weights: [[ 0.2]]\n",
      "weight-based evaluation: \n",
      "[[-1.83435438]]\n",
      "continuous off policy evaluator\n",
      "[-0.96295469]\n",
      "-------t------------\n",
      "0.0\n",
      "---------\n",
      "true-in-sample counterfactuals: \n",
      "-3.00004517945\n",
      "direct method: \n",
      "-2.70574447571\n",
      "prop. of strictly positive weights: [[ 0.2775]]\n",
      "weight-based evaluation: \n",
      "[[-3.0313785]]\n",
      "continuous off policy evaluator\n",
      "[-1.11988048]\n",
      "-------t------------\n",
      "0.1\n",
      "---------\n",
      "true-in-sample counterfactuals: \n",
      "0.0773798099922\n",
      "direct method: \n",
      "-0.730489219331\n",
      "prop. of strictly positive weights: [[ 0.3425]]\n",
      "weight-based evaluation: \n",
      "[[ 0.40965942]]\n",
      "continuous off policy evaluator\n",
      "[ 0.3345952]\n",
      "-------t------------\n",
      "0.2\n",
      "---------\n",
      "true-in-sample counterfactuals: \n",
      "4.0899116162\n",
      "direct method: \n",
      "3.47468214519\n",
      "prop. of strictly positive weights: [[ 0.555]]\n",
      "weight-based evaluation: \n",
      "[[ 5.0375693]]\n",
      "continuous off policy evaluator\n",
      "[ 3.69088536]\n"
     ]
    }
   ],
   "source": [
    "test_params = {'x_sc': x_T_test_sc[:,0:d], 'T_sc': x_T_test_sc[:,d], 'k_T': k_T, 'k_XT': k_XT, 'k_X': k_X, 'X_pi': X_test_pi, 'K_T_T':K_T_T, 'K_T_pi': K_T_pi, 'K_pi_pi': K_pi_pi, 'K_XT_XT': K_XT_XT }\n",
    "test_range = np.linspace(-.2,.2,5)\n",
    "n_pols = 4 \n",
    "test_n = len(Y_test)\n",
    "risks = np.zeros([len(test_range), n_pols])\n",
    "for (ind, test_t) in enumerate(test_range): \n",
    "    print '-------t------------'\n",
    "    print test_t\n",
    "    print '---------'\n",
    "    risks[ind,:] = eval_possibilities( (np.ones(test_n)*test_t)*np.std(T)+np.mean(T) , x_T_test_sc, x_test, Y_test,true_Q_test, np.mean(Y) )\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "eval_possibilities(np.zeros(n), x_T_test_sc, x_test, Y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "eval_possibilities(np.ones(n), x_T_test_sc, x_test, Y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "reps = 10\n",
    "vals = np.zeros([reps, 4])\n",
    "for i in range(reps): \n",
    "    print i \n",
    "    [true_risk, dm, wght_eval, ope] = eval_possibilities(np.dot(x_T_test_sc[:,0:d], np.random.uniform(size=d)) , x_T_test_sc, x_test, Y_test)\n",
    "    vals[0,:] = [true_risk, dm, wght_eval, ope]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "np.dot(x_test,beta_x_quad_T)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}