tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gradient Boosting Reinforcement Learning (GBTModel)\n",
    "GBTModel is a Python-based GBT library designed and optimized for reinforcement learning (RL).\n",
    "GBTModel is designed to be integrated in popular RL python libraries as part of the standard RL training loop.  \n",
    "\n",
    "## GBTModel Design\n",
    "The standard GBT supervised learning training procedure for K boosting iterations on a given set on inputs x and targets y is as follows:  \n",
    "***For K boosting iterations***   \n",
    "1. Generate predictions using current GBT ensemble.\n",
    "2. Calculate loss L(y, predictions).\n",
    "3. Calculate gradients of the loss function w.r.t predictions  \n",
    "4. Fit a binary decision tree on the gradients and add it to the ensemble.\n",
    "5. Repeat from step 1.\n",
    "\n",
    "The training procedure is typically done end-to-end (E2E) within a GBT framework and is optimized for pre-defined loss functions.  However, E2E learning is not optimal for RL settings, where the training procedure requires interactions with an environment.\n",
    "\n",
    "GBTModel draws inspiration from PyTorch and is designed to be easily integrated into RL or other online learning settings. As such, GBTModel can be viewed as a functional optimizer that incrementally adjusts a learned function by taking steps in the direction of the gradient.\n",
    "\n",
    "## Get Started with GBTModel\n",
    "This is a quick tutorial demonstrating usage examples\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Usage: Training, Saving, Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import torch as th\n",
    "import gymnasium as gym \n",
    "\n",
    "from sklearn import datasets\n",
    "from torch.nn.functional import mse_loss \n",
    "from torch.distributions import Categorical\n",
    "\n",
    "from gbrl import cuda_available\n",
    "from gbrl.models.gbt import GBTModel \n",
    "from gbrl.models.actor import ParametricActor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# toy dataset\n",
    "X_numpy, y_numpy = datasets.load_diabetes(return_X_y=True, as_frame=False, scaled=False)\n",
    "\n",
    "out_dim = 1 if len(y_numpy.shape) == 1  else y_numpy.shape[1]\n",
    "input_dim = X_numpy.shape[1]\n",
    "\n",
    "X, y = th.tensor(X_numpy, dtype=th.float32), th.tensor(y_numpy, dtype=th.float32)\n",
    "# CUDA is not deterministic\n",
    "device = 'cuda' if cuda_available else 'cpu'\n",
    "\n",
    "# initializing model parameters\n",
    "tree_struct = {'max_depth': 4, # maximum tree depth\n",
    "               'n_bins': 256, # maximum number of candidates to generate per numeric feature\n",
    "               'min_data_in_leaf': 0, # minimum samples in each child when splitting\n",
    "               'grow_policy': 'oblivious' # tree growth policy: [oblivious, greedy]\n",
    "        }\n",
    "\n",
    "optimizer = { 'algo': 'SGD', # optimizer algorithm: [SGD/Adam], Adam is available for cpu only  \n",
    "              'lr': 1.0, # learning rate\n",
    "              'start_idx': 0,\n",
    "              'stop_idx': out_dim\n",
    "            }\n",
    "params = {\n",
    "               \"split_score_func\": \"Cosine\", # split score function: [L2, Cosine]\n",
    "               \"generator_type\": \"Quantile\" # candidate generation policy - [Uniform, Quantile]. \n",
    "                }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# setting up model\n",
    "model = GBTModel(input_dim=input_dim,\n",
    "                      output_dim=out_dim,\n",
    "                      tree_struct=tree_struct,\n",
    "                      optimizers=optimizer,\n",
    "                      params=params,\n",
    "                      verbose=0,\n",
    "                      device=device)\n",
    "# set GBTModel bias\n",
    "model.set_bias_from_targets(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rmse_incremental_step(model, X, y):\n",
    "    # forward pass - y_pred is a torch tensor with requires_grad = True by default\n",
    "    y_pred = model(X)\n",
    "    # calculate loss - we must scale pytorch's mse loss function by 0.5 to get the correct MSE gradient\n",
    "    loss = 0.5*mse_loss(y_pred, y) \n",
    "    loss.backward()\n",
    "    # perform a boosting step\n",
    "    model.step()\n",
    "    # return RMSE\n",
    "    return loss.sqrt().item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper function to plot results\n",
    "def plot_loss(n_iterations, losses, x_label, y_label):\n",
    "    plt.close('all')\n",
    "    _, ax = plt.subplots()\n",
    "\n",
    "    ax.plot(np.arange(n_iterations), losses)\n",
    "    ax.set_xlabel(x_label)\n",
    "    ax.set_ylabel(y_label)\n",
    "    plt.show()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# training for 100 iterations\n",
    "n_iterations = 100\n",
    "losses = []\n",
    "for _ in range(n_iterations):\n",
    "    rmse_loss = rmse_incremental_step(model, X, y)\n",
    "    losses.append(rmse_loss)\n",
    "    \n",
    "plot_loss(n_iterations, losses, y_label='Training loss', x_label='Boosting Iterations')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "GBT work with per-sample gradients but PyTorch losses are typically calculated as the expected loss and derivated w.r.t fixed parameters. GBTModel internally multiplies the gradients with the number of samples when calling the step function. This allows to get similar results when using PyTorch losses on 1-dimensional outputs. However, when working with PyTorch losses and multi-output targets or different reductions one should take this into consideration.  \n",
    "For example:\n",
    "1. When using a summation reduction we should use:  \n",
    "    `loss = 0.5*mse_loss(y_pred, y, reduction='sum') / len(y_pred)`\n",
    "2. When working with multiple outputs dimensions we should use:  \n",
    "    `0.5*mse_loss(y_pred, y_multi) * output_dim`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving, loading, and copying a GBTModel Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current GBRL Library Version 1.1.0\n",
      "Reading GBRL Library Version 1.1.0\n",
      "######## Loaded GBRL model ########\n",
      "input_dim: 10 output_dim: 1 max_depth: 4 min_data_in_leaf: 0\n",
      "generator_type: Quantile n_bins: 256 cv_beta: 0.9 split_score_func: Cosine\n",
      "grow_policy: Oblivous verbose: 0 device: cpu use_cv: 0 batch_size: 5000\n",
      "Loaded: 1600 leaves from 100 trees\n",
      "Model has: 1 optimizers \n"
     ]
    }
   ],
   "source": [
    "# Call the save_model method of a GBTModel class\n",
    "# GBTModel will automatically save the file with the .gbrl_model ending\n",
    "# The file will be saved in the current working directory\n",
    "# Provide the absolute path to save the file in a different directory.\n",
    "model.save_learner('gbt_model_tutorial')\n",
    "# Loading a saved model is similar and is done by calling the specific class instance.\n",
    "loaded_model = GBTModel.load_learner('gbt_model_tutorial', device=device)\n",
    "# Copying a model is even more straighforward\n",
    "copied_model = model.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Manually Calculated Gradients\n",
    "Alternatively GBTModel can use manually calculated gradients. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def manual_rmse_incremental_step(model, X, y):\n",
    "    # forward pass - y_pred is a torch tensor with requires_grad = True by default\n",
    "    y_pred = model(X)\n",
    "    # calculate loss - we must scale pytorch's mse loss function by 0.5 to get the correct MSE gradient\n",
    "    loss = 0.5*mse_loss(y_pred, y) \n",
    "    grad = y_pred - y\n",
    "    # perform a boosting step\n",
    "    model.step(X, grad)\n",
    "    print(loss.sqrt().item())\n",
    "    # return RMSE\n",
    "    return loss.sqrt().item()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple iterations at once (standard supervised learning)\n",
    "GBTModel supports training multiple boosting iterations with targets similar to other GBT libraries. This is done using the `fit` method.  \n",
    "***Note: only the RMSE loss function is supported for the `fit` method***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Setting GBRL device to cuda\n",
      "Setting GBRL feature weights \n",
      "Setting GBRL bias \n",
      "Boosting iteration: 1 - MultiRMSE Loss: 38.5951\n",
      "Boosting iteration: 2 - MultiRMSE Loss: 36.2837\n",
      "Boosting iteration: 3 - MultiRMSE Loss: 34.776\n",
      "Boosting iteration: 4 - MultiRMSE Loss: 33.0491\n",
      "Boosting iteration: 5 - MultiRMSE Loss: 31.3666\n",
      "Boosting iteration: 6 - MultiRMSE Loss: 30.3322\n",
      "Boosting iteration: 7 - MultiRMSE Loss: 28.9714\n",
      "Boosting iteration: 8 - MultiRMSE Loss: 28.1049\n",
      "Boosting iteration: 9 - MultiRMSE Loss: 27.1679\n",
      "Boosting iteration: 10 - MultiRMSE Loss: 26.5319\n",
      "Boosting iteration: 11 - MultiRMSE Loss: 25.8842\n",
      "Boosting iteration: 12 - MultiRMSE Loss: 25.0436\n",
      "Boosting iteration: 13 - MultiRMSE Loss: 24.406\n",
      "Boosting iteration: 14 - MultiRMSE Loss: 23.6656\n",
      "Boosting iteration: 15 - MultiRMSE Loss: 22.8392\n",
      "Boosting iteration: 16 - MultiRMSE Loss: 22.0018\n",
      "Boosting iteration: 17 - MultiRMSE Loss: 21.4084\n",
      "Boosting iteration: 18 - MultiRMSE Loss: 20.6872\n",
      "Boosting iteration: 19 - MultiRMSE Loss: 20.1075\n",
      "Boosting iteration: 20 - MultiRMSE Loss: 19.8477\n",
      "Boosting iteration: 21 - MultiRMSE Loss: 19.3059\n",
      "Boosting iteration: 22 - MultiRMSE Loss: 18.935\n",
      "Boosting iteration: 23 - MultiRMSE Loss: 18.5213\n",
      "Boosting iteration: 24 - MultiRMSE Loss: 18\n",
      "Boosting iteration: 25 - MultiRMSE Loss: 17.5027\n",
      "Boosting iteration: 26 - MultiRMSE Loss: 16.962\n",
      "Boosting iteration: 27 - MultiRMSE Loss: 16.4759\n",
      "Boosting iteration: 28 - MultiRMSE Loss: 16.1435\n",
      "Boosting iteration: 29 - MultiRMSE Loss: 15.8082\n",
      "Boosting iteration: 30 - MultiRMSE Loss: 15.5273\n",
      "Boosting iteration: 31 - MultiRMSE Loss: 14.8211\n",
      "Boosting iteration: 32 - MultiRMSE Loss: 14.3402\n",
      "Boosting iteration: 33 - MultiRMSE Loss: 13.9641\n",
      "Boosting iteration: 34 - MultiRMSE Loss: 13.6616\n",
      "Boosting iteration: 35 - MultiRMSE Loss: 13.1279\n",
      "Boosting iteration: 36 - MultiRMSE Loss: 12.9784\n",
      "Boosting iteration: 37 - MultiRMSE Loss: 12.701\n",
      "Boosting iteration: 38 - MultiRMSE Loss: 12.3825\n",
      "Boosting iteration: 39 - MultiRMSE Loss: 12.0357\n",
      "Boosting iteration: 40 - MultiRMSE Loss: 11.7789\n",
      "Boosting iteration: 41 - MultiRMSE Loss: 11.5447\n",
      "Boosting iteration: 42 - MultiRMSE Loss: 11.3354\n",
      "Boosting iteration: 43 - MultiRMSE Loss: 11.052\n",
      "Boosting iteration: 44 - MultiRMSE Loss: 10.9167\n",
      "Boosting iteration: 45 - MultiRMSE Loss: 10.8169\n",
      "Boosting iteration: 46 - MultiRMSE Loss: 10.5474\n",
      "Boosting iteration: 47 - MultiRMSE Loss: 10.3306\n",
      "Boosting iteration: 48 - MultiRMSE Loss: 10.017\n",
      "Boosting iteration: 49 - MultiRMSE Loss: 9.68732\n",
      "Boosting iteration: 50 - MultiRMSE Loss: 9.52608\n",
      "Boosting iteration: 51 - MultiRMSE Loss: 9.18445\n",
      "Boosting iteration: 52 - MultiRMSE Loss: 8.8628\n",
      "Boosting iteration: 53 - MultiRMSE Loss: 8.59999\n",
      "Boosting iteration: 54 - MultiRMSE Loss: 8.37054\n",
      "Boosting iteration: 55 - MultiRMSE Loss: 8.08745\n",
      "Boosting iteration: 56 - MultiRMSE Loss: 7.86751\n",
      "Boosting iteration: 57 - MultiRMSE Loss: 7.5473\n",
      "Boosting iteration: 58 - MultiRMSE Loss: 7.25898\n",
      "Boosting iteration: 59 - MultiRMSE Loss: 6.87677\n",
      "Boosting iteration: 60 - MultiRMSE Loss: 6.78597\n",
      "Boosting iteration: 61 - MultiRMSE Loss: 6.55775\n",
      "Boosting iteration: 62 - MultiRMSE Loss: 6.44449\n",
      "Boosting iteration: 63 - MultiRMSE Loss: 6.2052\n",
      "Boosting iteration: 64 - MultiRMSE Loss: 6.01824\n",
      "Boosting iteration: 65 - MultiRMSE Loss: 5.90581\n",
      "Boosting iteration: 66 - MultiRMSE Loss: 5.7684\n",
      "Boosting iteration: 67 - MultiRMSE Loss: 5.62882\n",
      "Boosting iteration: 68 - MultiRMSE Loss: 5.4886\n",
      "Boosting iteration: 69 - MultiRMSE Loss: 5.39817\n",
      "Boosting iteration: 70 - MultiRMSE Loss: 5.24318\n",
      "Boosting iteration: 71 - MultiRMSE Loss: 5.07324\n",
      "Boosting iteration: 72 - MultiRMSE Loss: 4.86056\n",
      "Boosting iteration: 73 - MultiRMSE Loss: 4.76481\n",
      "Boosting iteration: 74 - MultiRMSE Loss: 4.66925\n",
      "Boosting iteration: 75 - MultiRMSE Loss: 4.54386\n",
      "Boosting iteration: 76 - MultiRMSE Loss: 4.40063\n",
      "Boosting iteration: 77 - MultiRMSE Loss: 4.34168\n",
      "Boosting iteration: 78 - MultiRMSE Loss: 4.24133\n",
      "Boosting iteration: 79 - MultiRMSE Loss: 4.14816\n",
      "Boosting iteration: 80 - MultiRMSE Loss: 4.0163\n",
      "Boosting iteration: 81 - MultiRMSE Loss: 3.83626\n",
      "Boosting iteration: 82 - MultiRMSE Loss: 3.74013\n",
      "Boosting iteration: 83 - MultiRMSE Loss: 3.66784\n",
      "Boosting iteration: 84 - MultiRMSE Loss: 3.57126\n",
      "Boosting iteration: 85 - MultiRMSE Loss: 3.51416\n",
      "Boosting iteration: 86 - MultiRMSE Loss: 3.44788\n",
      "Boosting iteration: 87 - MultiRMSE Loss: 3.38364\n",
      "Boosting iteration: 88 - MultiRMSE Loss: 3.32461\n",
      "Boosting iteration: 89 - MultiRMSE Loss: 3.21603\n",
      "Boosting iteration: 90 - MultiRMSE Loss: 3.16097\n",
      "Boosting iteration: 91 - MultiRMSE Loss: 3.10395\n",
      "Boosting iteration: 92 - MultiRMSE Loss: 3.01338\n",
      "Boosting iteration: 93 - MultiRMSE Loss: 2.93486\n",
      "Boosting iteration: 94 - MultiRMSE Loss: 2.83311\n",
      "Boosting iteration: 95 - MultiRMSE Loss: 2.73086\n",
      "Boosting iteration: 96 - MultiRMSE Loss: 2.66423\n",
      "Boosting iteration: 97 - MultiRMSE Loss: 2.62645\n",
      "Boosting iteration: 98 - MultiRMSE Loss: 2.5546\n",
      "Boosting iteration: 99 - MultiRMSE Loss: 2.51901\n",
      "Boosting iteration: 100 - MultiRMSE Loss: 2.48984\n"
     ]
    }
   ],
   "source": [
    "gbrl_model = GBTModel(input_dim=input_dim,\n",
    "                      output_dim=1,\n",
    "                      tree_struct=tree_struct,\n",
    "                      optimizers=optimizer,\n",
    "                      params=params,\n",
    "                      verbose=1,\n",
    "                      device=device)\n",
    "final_loss = gbrl_model.fit(X, y, iterations=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RL using GBTModel\n",
    "Now that we have seen how GBTModel is trained using incremental learning and PyTorch we can use it within an RL training loop\n",
    "\n",
    "For simplicity, we train an agent using REINFORCE, which might not give the best results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_returns(rewards, gamma):\n",
    "    returns = []\n",
    "    running_g = 0.0\n",
    "    for reward in rewards[::-1]:\n",
    "        running_g = reward + gamma * running_g\n",
    "        returns.insert(0, running_g)\n",
    "    return returns\n",
    "\n",
    "def perform_rollout(rollout_buffer, agent, env):\n",
    "    obs, _ = env.reset(seed=0)\n",
    "    rollout_buffer['rewards'] = []\n",
    "    done = False\n",
    "    while not done:\n",
    "        action_logits = agent(obs, requires_grad=False)\n",
    "        action = Categorical(logits=action_logits).sample()\n",
    "        action_numpy = action.cpu().numpy().squeeze()\n",
    "        \n",
    "        obs, reward, terminated, truncated, _ = env.step(action_numpy)\n",
    "        rollout_buffer['rewards'].append(reward)\n",
    "        rollout_buffer['obs'].append(obs)\n",
    "        rollout_buffer['actions'].append(action)\n",
    "\n",
    "        done = terminated or truncated\n",
    "\n",
    "    \n",
    "def reinforce_step(agent, observations, actions, returns, batch_size=64):\n",
    "     # model update\n",
    "    indices = th.randperm(len(observations))\n",
    "    n_samples = len(observations)\n",
    "\n",
    "    # Process in mini-batches\n",
    "    for start in range(0, len(observations), batch_size):\n",
    "        end = start + batch_size\n",
    "        if end > n_samples:\n",
    "            end = n_samples\n",
    "        batch_idx = indices[start:end]\n",
    "\n",
    "        # Slice mini-batch\n",
    "        obs_batch = observations[batch_idx]\n",
    "        act_batch = actions[batch_idx]\n",
    "        ret_batch = returns[batch_idx]\n",
    "\n",
    "        # Forward pass\n",
    "        action_logits = agent(obs_batch)\n",
    "        dist = Categorical(logits=action_logits)\n",
    "        log_probs = dist.log_prob(act_batch)\n",
    "\n",
    "        # Losses\n",
    "        policy_loss = -(log_probs * (ret_batch - ret_batch.mean())).mean()\n",
    "        loss = policy_loss\n",
    "\n",
    "        # Backprop + update\n",
    "        loss.backward()\n",
    "        agent.step()\n",
    "\n",
    "# Helper function to plot results\n",
    "def plot_returns(iterations, losses, x_label, y_label):\n",
    "    plt.close('all')\n",
    "    _, ax = plt.subplots()\n",
    "\n",
    "    ax.plot(iterations, losses)\n",
    "    ax.set_xlabel(x_label)\n",
    "    ax.set_ylabel(y_label)\n",
    "    plt.show()\n",
    "        \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21.82\n",
      "28.58\n",
      "33.5\n",
      "44.86\n",
      "46.06\n",
      "49.08\n",
      "44.16\n",
      "57.64\n",
      "84.72\n",
      "53.66\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "device = 'cuda'if th.cuda.is_available() else 'cpu'\n",
    "\n",
    "env = gym.make(\"CartPole-v1\")\n",
    "wrapped_env = gym.wrappers.RecordEpisodeStatistics(env, 50)  # Records episode-reward\n",
    "num_episodes = 1000\n",
    "gamma = 0.95\n",
    "optimizer = { 'algo': 'SGD',\n",
    "              'lr': 0.032,\n",
    "              'start_idx': 0,\n",
    "              'stop_idx': env.action_space.n,\n",
    "            }\n",
    "tree_struct = {'max_depth': 4, # maximum tree depth\n",
    "               'n_bins': 50, # maximum number of candidates to generate per numeric feature\n",
    "               'min_data_in_leaf': 0, # minimum samples in each child when splitting\n",
    "               'grow_policy': 'oblivious' # tree growth policy: [oblivious, greedy]\n",
    "        }\n",
    "\n",
    "bias = np.zeros(env.action_space.n, dtype=np.single)\n",
    "agent = ParametricActor(input_dim=env.observation_space.shape[0],\n",
    "                        output_dim=env.action_space.n,\n",
    "                        tree_struct=tree_struct,\n",
    "                        policy_optimizer=optimizer,\n",
    "                        params=params,\n",
    "                        verbose=0,\n",
    "                        bias=bias, \n",
    "                        device=device)\n",
    "\n",
    "update_every = 100\n",
    "mean_returns = []\n",
    "iterations = []\n",
    "rollout_buffer = {'actions': [], 'obs': [], 'returns': []}\n",
    "\n",
    "for episode in range(1, num_episodes + 1):\n",
    "    perform_rollout(rollout_buffer, agent, wrapped_env)\n",
    "    rollout_buffer['returns'].extend(calculate_returns(rollout_buffer['rewards'], gamma))\n",
    "\n",
    "    if episode % update_every == 0:\n",
    "        returns = th.tensor(rollout_buffer['returns'], device=device)\n",
    "        actions = th.cat(rollout_buffer['actions']).to(device)\n",
    "        # input to model can be either a torch tensor or a numpy ndarray\n",
    "        observations = np.stack(rollout_buffer['obs'])\n",
    "        reinforce_step(agent, observations, actions, returns)\n",
    "        rollout_buffer = {'actions': [], 'obs': [], 'returns': []}\n",
    "\n",
    "        mean_returns.append(np.mean(wrapped_env.return_queue))\n",
    "        print(np.mean(wrapped_env.return_queue))\n",
    "        iterations.append(agent.get_iteration())\n",
    "\n",
    "plot_returns(iterations, mean_returns, y_label='Episodic Returns', x_label='Boosting Iterations')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Explainability\n",
    "GBTModel implements SHAP value calculation. SHAP values can be calculated over the entire ensemble as well as for individual trees.\n",
    "GBTModel returns SHAP values with shap: [n_samples, n_features, n_actions]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs, info = wrapped_env.reset(seed=0)\n",
    "# per tree shap values\n",
    "tree_shap = agent.tree_shap(0, obs)\n",
    "# for the entire ensemble\n",
    "shap_values = agent.shap(obs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SHAP values are calculated internally and can be plotted using the [SHAP library](https://github.com/shap/shap).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "CARTPOLE_FEATURE_NAMES = ['Cart Position', 'Cart Velocity', 'Pole Angle', 'Pole Angular Velocity']\n",
    "import shap\n",
    "import matplotlib.pyplot as plt\n",
    "plt.close('all')\n",
    "explainable_values_action_1 = shap.Explanation(shap_values.squeeze()[: , 0], feature_names=CARTPOLE_FEATURE_NAMES)\n",
    "explainable_values_action_2 = shap.Explanation(shap_values.squeeze()[: , 1], feature_names=CARTPOLE_FEATURE_NAMES)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.set_title(\"SHAP values Action 1 - initial observation\")\n",
    "shap.plots.bar(explainable_values_action_1, ax=ax)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.set_title(\"SHAP values Action 2 - initial observation\")\n",
    "shap.plots.bar(explainable_values_action_2, ax=ax)\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}