examples/quickstart/rtb/rtb_synthetic_continuous_zoo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quickstart Example of Off-Policy Evaluation with Various Estimators (Continuous)\n",
    "This notebook provides an example of conducting **Off-policy Evaluation (OPE)** with a synthetic Real-Time Bidding (RTB) dataset and various OPE estimators (e.g., model-based vs importance sampling-based, marginal importance sampling, and double reinforcement learning).\n",
    "\n",
    "This example consists of the following 3 steps: \n",
    "1. Setup, Synthetic Data Generation, and Offline Policy Learning\n",
    "2. Off-Policy Evaluation (OPE) with various estimators\n",
    "\n",
    "\\* This library uses [d3rlpy](https://github.com/takuseno/d3rlpy)'s algorithm implementations of offline rl policies and model-based evaluation.  \n",
    "\\* Also, our implementations of OPE are highly inspired by [Open Bandit Pipeline](https://github.com/st-tech/zr-obp)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import SCOPE-RL modules\n",
    "import scope_rl\n",
    "from rtbgym import RTBEnv, CustomizedRTBEnv\n",
    "from scope_rl.dataset import SyntheticDataset\n",
    "from scope_rl.policy import OnlineHead, ContinuousEvalHead\n",
    "from scope_rl.policy import TruncatedGaussianHead\n",
    "from scope_rl.ope.online import (\n",
    "    calc_on_policy_policy_value,\n",
    "    visualize_on_policy_policy_value,\n",
    ")\n",
    "\n",
    "# import d3rlpy algorithms\n",
    "from d3rlpy.algos import RandomPolicy\n",
    "from d3rlpy.preprocessing import MinMaxObservationScaler, MinMaxActionScaler\n",
    "\n",
    "# import from other libraries\n",
    "import gym\n",
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "from glob import glob\n",
    "from tqdm import tqdm\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1.2\n"
     ]
    }
   ],
   "source": [
    "# version\n",
    "print(scope_rl.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set random state\n",
    "random_state = 12345"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# log directory\n",
    "from pathlib import Path\n",
    "Path(\"logs/\").mkdir(exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ignore warnings\n",
    "import warnings\n",
    "warnings.simplefilter('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Setup, Synthetic Data Generation, and Offline Policy Learning\n",
    "To begin with, we briefly describe how the RTB environment works.\n",
    "\n",
    "#### RL setup for RTB\n",
    "In RTB, the objective of the RL agent is to maximize some KPIs (number of clicks or conversions) within an episode under given budget constraints.  \n",
    "\n",
    "We often try to achieve this by adjusting bidding price function parameter $\\alpha$. By using $\\alpha$, we can adjust the bid price as follows.  \n",
    "$bid_{t,i} = \\alpha \\cdot r^{\\ast}$, \n",
    "where $r^{\\ast}$ denotes a predicted or expected reward (KPIs).\n",
    "\n",
    "We often formulate this RTB problem as the following Constrained Markov Decision Process (CMDP):\n",
    "- `timestep`: One episode (a day or a week) consists of several timesteps (24 hours or seven days, for instance).\n",
    "- `state`: We observe some feedback from the environment at each timestep, which includes the following.\n",
    "  - timestep\n",
    "  - remaining budget\n",
    "  - impression level features (budget consumption rate, cost per mille of impressions, auction winning rate, reward) at the previous timestep\n",
    "  - adjust rate (RL agent's decision making) at the previous timestep\n",
    "- `action`: Agent chooses adjust rate parameter $\\alpha$ to maximize KPIs.\n",
    "- `reward`: Total number of clicks or conversions obtained during the timestep.\n",
    "- `constraints`: The pre-determined episodic budget should not be exceeded.\n",
    "\n",
    "For more about the environmental configuration and its customization, please refer to [examples/quickstart/rtb/rtb_synthetic_customize_env.ipynb](https://github.com/hakuhodo-technologies/scope-rl/blob/main/examples/quickstart/rtb/rtb_synthetic_customize_env.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# standardized environment for continuous action\n",
    "env = gym.make(\"RTBEnv-continuous-v0\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Synthetic Data Generation\n",
    "Next, we collect logged data with a behavior policy $\\pi_0$:\n",
    "\n",
    "$$\\mathcal{D}_0 := \\{ \\{ s_t, a_t, s_{t+1}, r_t \\}_{t=1}^T \\}_{i=1}^n \\sim \\prod_{i=1}^n d_{s_0}(s_0) \\prod_{t=1}^T \\pi_0(a_t | s_t) p(s_{t+1} | s_t, a_t) p(r_t | s_t, a_t),$$\n",
    "\n",
    "where $s_t \\in \\mathcal{S}$ is the state observed at timestep $t$, $a_t$ is the action chosen by the behavior policy $\\pi_0$, and $r_t$ is the reward. \n",
    "\n",
    "`SyntheticDataset` has the following arguments:\n",
    "- `env`: RTB environment for RL defined in the previous section.\n",
    "- `state_keys`: Name of the state variable at each dimension.\n",
    "- `max_episode_steps`: Maximum number of timesteps in an episode.\n",
    "- `info_keys`: Dictionary containing of key and the type of info components.\n",
    "\n",
    "For more about the data collection and visualization, please refer to [examples/quickstart/rtb/rtb_synthetic_data_collection.ipynb](https://github.com/hakuhodo-technologies/scope-rl/blob/main/examples/quickstart/rtb/rtb_synthetic_data_collection.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# behavior policy\n",
    "from d3rlpy.algos import SACConfig\n",
    "from d3rlpy.models.encoders import VectorEncoderFactory\n",
    "from d3rlpy.models.q_functions import MeanQFunctionFactory\n",
    "from d3rlpy.dataset import create_fifo_replay_buffer\n",
    "\n",
    "# model\n",
    "sac = SACConfig(\n",
    "    actor_encoder_factory=VectorEncoderFactory(hidden_units=[30, 30]),\n",
    "    critic_encoder_factory=VectorEncoderFactory(hidden_units=[30, 30]),\n",
    "    q_func_factory=MeanQFunctionFactory(),\n",
    "    action_scaler=MinMaxActionScaler(\n",
    "        minimum=env.action_space.low,   # 0.1\n",
    "        maximum=env.action_space.high,  # 10\n",
    "    ),\n",
    ").create(device=device)\n",
    "\n",
    "# setup replay buffer\n",
    "buffer = create_fifo_replay_buffer(\n",
    "    limit=10000,\n",
    "    env=env,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# start training\n",
    "# skip if there is a pre-trained model\n",
    "sac.fit_online(\n",
    "    env,\n",
    "    buffer,\n",
    "    eval_env=env,\n",
    "    n_steps=100000,\n",
    "    n_steps_per_epoch=1000,\n",
    "    update_start_step=1000,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save model\n",
    "sac.save_model(\"d3rlpy_logs/sac.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-07-22 17:15:57 [warning  ] Parameters will be reinitialized.\n"
     ]
    }
   ],
   "source": [
    "# reload model\n",
    "sac.build_with_env(env)\n",
    "sac.load_model(\"d3rlpy_logs/sac.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "behavior_policy = TruncatedGaussianHead(\n",
    "    sac, \n",
    "    minimum=env.action_space.low,\n",
    "    maximum=env.action_space.high,\n",
    "    sigma=np.array([1.0]),\n",
    "    name=\"sac_sigma_1.0\",\n",
    "    random_state=random_state,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize dataset class\n",
    "dataset = SyntheticDataset(\n",
    "    env=env,\n",
    "    state_keys=env.obs_keys,\n",
    "    max_episode_steps=env.step_per_episode,\n",
    "    info_keys={\n",
    "        \"search_volume\": int,\n",
    "        \"impression\": int,\n",
    "        \"click\": int,\n",
    "        \"conversion\": int,\n",
    "        \"average_bid_price\": float,\n",
    "    },\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# collect logged data by a behavior policy\n",
    "# skip if there is a preserved logged dataset\n",
    "train_logged_dataset = dataset.obtain_episodes(\n",
    "    behavior_policies=behavior_policy,\n",
    "    n_trajectories=10000, \n",
    "    obtain_info=True,\n",
    "    random_state=random_state,\n",
    ")\n",
    "test_logged_dataset = dataset.obtain_episodes(\n",
    "    behavior_policies=behavior_policy,\n",
    "    n_trajectories=10000, \n",
    "    obtain_info=True,\n",
    "    random_state=random_state + 1,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"logs/train_dataset_continuous_sac.pkl\", \"wb\") as f:\n",
    "    pickle.dump(train_logged_dataset, f)\n",
    "with open(\"logs/test_dataset_continuous_sac.pkl\", \"wb\") as f:\n",
    "    pickle.dump(test_logged_dataset, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"logs/train_dataset_continuous_sac.pkl\", \"rb\") as f:\n",
    "    train_logged_dataset = pickle.load(f)\n",
    "with open(\"logs/test_dataset_continuous_sac.pkl\", \"rb\") as f:\n",
    "    test_logged_dataset = pickle.load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Offline Policy Learning\n",
    "Here, we learn several \"candidate\" policies to be evaluated and selected using [d3rlpy](https://github.com/takuseno/d3rlpy)'s algorithm implementation.\n",
    "\n",
    "For more about the offline RL procedure, please refer to [examples/quickstart/rtb/rtb_synthetic_discrete_basic.ipynb](https://github.com/hakuhodo-technologies/scope-rl/blob/main/examples/quickstart/rtb/rtb_synthetic_discrete_basic.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import modules from d3rlpy\n",
    "from d3rlpy.dataset import MDPDataset\n",
    "from d3rlpy.algos import CQLConfig\n",
    "# transform offline dataset for d3rlpy\n",
    "offlinerl_dataset = MDPDataset(\n",
    "    observations=train_logged_dataset[\"state\"],\n",
    "    actions=train_logged_dataset[\"action\"],\n",
    "    rewards=train_logged_dataset[\"reward\"],\n",
    "    terminals=train_logged_dataset[\"done\"],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use Conservative Q-Learning policy\n",
    "cql = CQLConfig(\n",
    "    actor_encoder_factory=VectorEncoderFactory(hidden_units=[30, 30]),\n",
    "    critic_encoder_factory=VectorEncoderFactory(hidden_units=[30, 30]),\n",
    "    q_func_factory=MeanQFunctionFactory(),\n",
    "    action_scaler=MinMaxActionScaler(\n",
    "        minimum=env.action_space.low,  # minimum value that policy can take\n",
    "        maximum=env.action_space.high,  # maximum value that policy can take\n",
    "    )\n",
    ").create(device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cql.fit(\n",
    "    offlinerl_dataset,\n",
    "    n_steps=10000,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save model\n",
    "cql.save_model(\"d3rlpy_logs/cql_continuous.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-07-22 17:25:04 [warning  ] Parameters will be reinitialized.\n"
     ]
    }
   ],
   "source": [
    "# reload model\n",
    "cql.build_with_env(env)\n",
    "cql.load_model(\"d3rlpy_logs/cql_continuous.pt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Off-Policy Evaluation\n",
    "In this section, we aim at evaluating the various performance statistics of policies in an offline manner using (basic) model-based and importance sampling-based estimators.\n",
    "\n",
    "#### Estimation Target\n",
    "\n",
    "The goal to estimate the estimators' average policy performance, the *policy value*.\n",
    "\n",
    "$$ V(\\pi) := \\mathbb{E}\\left[\\sum_{t=1}^T \\gamma^{t-1} r_t \\mid \\pi \\right] $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import ope modules from SCOPE-RL\n",
    "from scope_rl.ope import CreateOPEInput\n",
    "from scope_rl.ope import OffPolicyEvaluation as OPE\n",
    "# basic estimators\n",
    "from scope_rl.ope.continuous import DirectMethod as DM\n",
    "from scope_rl.ope.continuous import TrajectoryWiseImportanceSampling as TIS\n",
    "from scope_rl.ope.continuous import PerDecisionImportanceSampling as PDIS\n",
    "from scope_rl.ope.continuous import DoublyRobust as DR\n",
    "# self normalized estimators\n",
    "from scope_rl.ope.continuous import SelfNormalizedTIS as SNTIS\n",
    "from scope_rl.ope.continuous import SelfNormalizedPDIS as SNPDIS\n",
    "from scope_rl.ope.continuous import SelfNormalizedDR as SNDR\n",
    "# marginal estimators\n",
    "from scope_rl.ope.continuous import StateActionMarginalIS as SAMIS\n",
    "from scope_rl.ope.continuous import StateActionMarginalDR as SAMDR\n",
    "from scope_rl.ope.continuous import StateMarginalIS as SMIS\n",
    "from scope_rl.ope.continuous import StateMarginalDR as SMDR\n",
    "from scope_rl.ope.continuous import StateActionMarginalSNIS as SAMSNIS\n",
    "from scope_rl.ope.continuous import StateActionMarginalSNDR as SAMSNDR\n",
    "from scope_rl.ope.continuous import StateMarginalSNIS as SMSNIS\n",
    "from scope_rl.ope.continuous import StateMarginalSNDR as SMSNDR\n",
    "# double reinforcement learning estimators\n",
    "from scope_rl.ope.continuous import DoubleReinforcementLearning as DRL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define evaluation policies (should be deterministic policy)\n",
    "cql_ = ContinuousEvalHead(\n",
    "    base_policy=cql,\n",
    "    name=\"cql\",\n",
    ")\n",
    "sac_ = ContinuousEvalHead(\n",
    "    base_policy=sac, \n",
    "    name=\"sac\", \n",
    ")\n",
    "evaluation_policies = [cql_, sac_]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# first, prepare OPE inputs\n",
    "prep = CreateOPEInput(\n",
    "    env=env,\n",
    "    model_args={\n",
    "        \"fqe\": {\n",
    "            \"encoder_factory\": VectorEncoderFactory(hidden_units=[30, 30]),\n",
    "            \"q_func_factory\": MeanQFunctionFactory(),\n",
    "            \"learning_rate\": 1e-4,\n",
    "        },\n",
    "    },\n",
    "    state_scaler=MinMaxObservationScaler(\n",
    "        minimum=test_logged_dataset[\"state\"].min(axis=0),\n",
    "        maximum=test_logged_dataset[\"state\"].max(axis=0),\n",
    "    ),\n",
    "    action_scaler=MinMaxActionScaler(\n",
    "        minimum=env.action_space.low,  # minimum value that policy can take\n",
    "        maximum=env.action_space.high,  # maximum value that policy can take\n",
    "    ),\n",
    "    gamma=0.95,\n",
    "    bandwidth=1.0,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# takes time\n",
    "input_dict = prep.obtain_whole_inputs(\n",
    "    logged_dataset=test_logged_dataset,\n",
    "    evaluation_policies=evaluation_policies,\n",
    "    require_value_prediction=True,\n",
    "    require_weight_prediction=True,\n",
    "    n_trajectories_on_policy_evaluation=100,\n",
    "    random_state=random_state,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"logs/ope_input_dict_continuous_zoo.pkl\", \"wb\") as f:\n",
    "    pickle.dump(input_dict, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"logs/ope_input_dict_continuous_zoo.pkl\", \"rb\") as f:\n",
    "    input_dict = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "basic_estimators = [DM(), TIS(), PDIS(), DR(), SNTIS(), SNPDIS(), SNDR()]\n",
    "state_marginal_estimators = [SMIS(), SMDR(), SMSNIS(), SMSNDR()]\n",
    "state_action_marginal_estimators = [SAMIS(), SAMDR(), SAMSNIS(), SAMSNDR()]\n",
    "drl_estimators = [DRL()]\n",
    "all_estimators = basic_estimators + state_marginal_estimators + state_action_marginal_estimators + drl_estimators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "basic_estimators_name = [\"dm\", \"tis\", \"pdis\", \"dr\", \"sntis\", \"snpdis\", \"sndr\"]\n",
    "state_marginal_estimators_name = [\"sm_is\", \"sm_dr\", \"sm_snis\", \"sm_sndr\"]\n",
    "state_action_marginal_estimators_name = [\"sam_is\", \"sam_dr\", \"sam_snis\", \"sam_sndr\"]\n",
    "drl_estimators_name = [\"drl\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "ope = OPE(\n",
    "    logged_dataset=test_logged_dataset,\n",
    "    ope_estimators=all_estimators,\n",
    "    action_scaler=MinMaxActionScaler(\n",
    "        minimum=env.action_space.low,  # minimum value that policy can take\n",
    "        maximum=env.action_space.high,  # maximum value that policy can take\n",
    "    ),\n",
    "    bandwidth=1.0,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'cql':            policy_value  relative_policy_value\n",
       " on_policy     13.259526               1.000000\n",
       " dm            14.657949               1.105466\n",
       " tis          541.412158              40.831940\n",
       " pdis          74.560998               5.623203\n",
       " dr            17.363731               1.309529\n",
       " sntis         14.393356               1.085511\n",
       " snpdis        14.660934               1.105691\n",
       " sndr          14.395977               1.085708\n",
       " sm_is          0.005094               0.000384\n",
       " sm_dr         14.662665               1.105821\n",
       " sm_snis       13.985693               1.054766\n",
       " sm_sndr       27.434111               2.069012\n",
       " sam_is         0.000071               0.000005\n",
       " sam_dr        14.658015               1.105471\n",
       " sam_snis      14.209119               1.071616\n",
       " sam_sndr      27.993215               2.111178\n",
       " drl           14.657952               1.105466,\n",
       " 'sac':            policy_value  relative_policy_value\n",
       " on_policy     13.274484               1.000000\n",
       " dm            13.990937               1.053972\n",
       " tis          569.503679              42.902135\n",
       " pdis          79.987155               6.025632\n",
       " dr            11.230118               0.845993\n",
       " sntis         14.331970               1.079663\n",
       " snpdis        14.523499               1.094091\n",
       " sndr          14.333608               1.079786\n",
       " sm_is          0.004334               0.000326\n",
       " sm_dr         13.994839               1.054266\n",
       " sm_snis       13.922870               1.048845\n",
       " sm_sndr       26.592781               2.003301\n",
       " sam_is         0.000033               0.000002\n",
       " sam_dr        13.990967               1.053974\n",
       " sam_snis      14.093018               1.061662\n",
       " sam_sndr      26.733830               2.013926\n",
       " drl           13.990937               1.053972}"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# policy value estimation by ope\n",
    "# in this case, DM produces high bias due to extrapolation error\n",
    "policy_value_df_dict, policy_value_interval_df_dict = ope.summarize_off_policy_estimates(\n",
    "    input_dict, \n",
    "    random_state=random_state,\n",
    ")\n",
    "# dictionary of the estimation\n",
    "policy_value_df_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1400x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize and compare the result\n",
    "ope.visualize_off_policy_estimates(\n",
    "    input_dict, \n",
    "    compared_estimators=basic_estimators_name,\n",
    "    random_state=random_state, \n",
    ")\n",
    "# relative policy value to the behavior policy\n",
    "# ope.visualize_off_policy_estimates(input_dict, random_state=random_state, is_relative=True, sharey=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize and compare the result\n",
    "ope.visualize_off_policy_estimates(\n",
    "    input_dict, \n",
    "    compared_estimators=state_marginal_estimators_name,\n",
    "    random_state=random_state, \n",
    "    sharey=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize and compare the result\n",
    "ope.visualize_off_policy_estimates(\n",
    "    input_dict, \n",
    "    compared_estimators=state_action_marginal_estimators_name,\n",
    "    random_state=random_state, \n",
    "    sharey=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize and compare the result\n",
    "ope.visualize_off_policy_estimates(\n",
    "    input_dict, \n",
    "    compared_estimators=[\"dm\", \"sm_is\", \"sm_dr\", \"sam_is\", \"sam_dr\", \"drl\"],\n",
    "    random_state=random_state, \n",
    "    sharey=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ope.visualize_off_policy_estimates(\n",
    "    input_dict, \n",
    "    compared_estimators=[\"dm\", \"snpdis\", \"sndr\", \"sm_snis\", \"sm_sndr\", \"sam_snis\", \"sam_sndr\", \"drl\"],\n",
    "    random_state=random_state, \n",
    "    sharey=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more advanced topics in OPE (e.g., cumulative distribution function estimation) and OPS, please refer to [examples/quickstart/rtb/rtb_synthetic_continuous_advanced.ipynb](https://github.com/hakuhodo-technologies/scope-rl/blob/main/examples/quickstart/rtb/rtb_synthetic_continuous_advanced.ipynb). \n",
    "\n",
    "For the examples in the discrete action space, please refer to [examples/quickstart/rtb/rtb_synthetic_discrete_zoo.ipynb](https://github.com/hakuhodo-technologies/scope-rl/blob/main/examples/quickstart/rtb/rtb_synthetic_discrete_zoo.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reference\n",
    "\n",
    "- Haanvid Lee, Jongmin Lee, Yunseon Choi, Wonseok Jeon, Byung-Jun Lee, Yung-Kyun Noh, and Kee-Eung Kim. \\\n",
    "\"Local Metric Learning for Off-Policy Evaluation in Contextual Bandits with Continuous Actions.\", 2022.\n",
    "\n",
    "- Yuta Saito, Shunsuke Aihara, Megumi Matsutani, and Yusuke Narita. \\\n",
    "\"Open Bandit Dataset and Pipeline: Towards Realistic and Reproducible Off-Policy Evaluation.\", 2021.\n",
    "\n",
    "- Takuma Seno and Michita Imai. \\\n",
    "\"d3rlpy: An Offline Deep Reinforcement Library.\", 2021.\n",
    "\n",
    "- Christina J. Yuan, Yash Chandak, Stephen Giguere, Philip S. Thomas, and Scott Niekum. \\\n",
    "\"SOPE: Spectrum of Off-Policy Estimators.\", 2021.\n",
    "\n",
    "- Nathan Kallus and Masatoshi Uehara. \\\n",
    "\"Double Reinforcement Learning for Efficient Off-Policy Evaluation in Markov Decision Processes.\", 2020.\n",
    "\n",
    "- Masatoshi Uehara, Jiawei Huang, and Nan Jiang. \\\n",
    "\"Minimax Weight and Q-Function Learning for Off-Policy Evaluation.\", 2020.\n",
    "\n",
    "- Mengjiao Yang, Ofir Nachum, Bo Dai, Lihong Li, and Dale Schuurmans. \\\n",
    "\"Off-Policy Evaluation via the Regularized Lagrangian.\", 2020.\n",
    "\n",
    "- Sergey Levine, Aviral Kumar, George Tucker, and Justin Fu. \\\n",
    "\"Offline Reinforcement Learning: Tutorial, Review, and Perspectives on Open Problems.\" 2020.\n",
    "\n",
    "- Aviral Kumar, Aurick Zhou, George Tucker, and Sergey Levine. \\\n",
    "\"Conservative Q-Learning for Offline Reinforcement Learning.\", 2020.\n",
    "\n",
    "- Nathan Kallus and Angela Zhou. \\\n",
    "\"Policy Evaluation and Optimization with Continuous Treatments.\", 2019.\n",
    "\n",
    "- Nathan Kallus and Masatoshi Uehara. \\\n",
    "\"Intrinsically Efficient, Stable, and Bounded Off-Policy Evaluation for Reinforcement Learning.\", 2019.\n",
    "\n",
    "- Hoang Le, Cameron Voloshin, and Yisong Yue. \\\n",
    "\"Batch Policy Learning under Constraints.\", 2019.\n",
    "\n",
    "- Qiang Liu, Lihong Li, Ziyang Tang, and Dengyong Zhou. \\\n",
    "\"Breaking the Curse of Horizon: Infinite-Horizon Off-Policy Estimation.\", 2018\n",
    "\n",
    "- Di Wu, Xiujun Chen, Xun Yang, Hao Wang, Qing Tan, Xiaoxun Zhang, Jian Xu, and Kun Gai. \\\n",
    "\"Budget Constrained Bidding by Model-free Reinforcement Learning in Display Advertising.\", 2018.\n",
    "\n",
    "- Jun Zhao, Guang Qiu, Ziyu Guan, Wei Zhao, and Xiaofei He. \\\n",
    "\"Deep Reinforcement Learning for Sponsored Search Real-time Bidding.\", 2018.\n",
    "\n",
    "- Josiah P. Hanna, Peter Stone, and Scott Niekum. \\\n",
    "\"Bootstrapping with Models: Confidence Intervals for Off-Policy Evaluation.\", 2017.\n",
    "\n",
    "- Nan Jiang and Lihong Li. \\\n",
    "\"Doubly Robust Off-policy Value Evaluation for Reinforcement Learning.\", 2016.\n",
    "\n",
    "- Philip S. Thomas and Emma Brunskill. \\\n",
    "\"Data-Efficient Off-Policy Policy Evaluation for Reinforcement Learning.\", 2016.\n",
    "\n",
    "- Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. \\\n",
    "\"OpenAI Gym.\", 2016.\n",
    "\n",
    "- Philip S. Thomas, Georgios Theocharous, and Mohammad Ghavamzadeh. \\\n",
    "\"High Confidence Policy Improvement.\", 2015.\n",
    "\n",
    "- Philip S. Thomas, Georgios Theocharous, and Mohammad Ghavamzadeh. \\\n",
    "\"High Confidence Off-Policy Evaluation.\", 2015.\n",
    "\n",
    "- Adith Swaminathan and Thorsten Joachims. \\\n",
    "\"The Self-Normalized Estimator for Counterfactual Learning.\", 2015.\n",
    "\n",
    "- Hado van Hasselt, Arthur Guez, and David Silver. \\\n",
    "\"Deep Reinforcement Learning with Double Q-learning.\", 2015.\n",
    "\n",
    "- Miroslav Dudík, Dumitru Erhan, John Langford, and Lihong Li. \\\n",
    "\"Doubly Robust Policy Evaluation and Optimization.\", 2014.\n",
    "\n",
    "- Alex Strehl, John Langford, Sham Kakade, and Lihong Li. \\\n",
    "\"Learning from Logged Implicit Exploration Data.\", 2010.\n",
    "\n",
    "- Alina Beygelzimer and John Langford. \\\n",
    "\"The Offset Tree for Learning with Partial Labels.\", 2009.\n",
    "\n",
    "- Doina Precup, Richard S. Sutton, and Satinder P. Singh. \\\n",
    "\"Eligibility Traces for Off-Policy Policy Evaluation.\", 2000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.6"
  },
  "vscode": {
   "interpreter": {
    "hash": "70404ee114725fce8ed9e697d67827f8546c678889944e6d695790702cbfe1f5"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}