tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gradient Boosting Reinforcement Learning (GBRL)\n",
    "GBRL is a Python-based GBT library designed and optimized for reinforcement learning (RL).\n",
    "GBRL is designed to be integrated in popular RL python libraries as part of the standard RL training loop.  \n",
    "\n",
    "## GBRL 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",
    "GBRL draws inspiration from PyTorch and is designed to be easily integrated into RL or other online learning settings. As such, GBRL 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 GBRL\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 GBRL, cuda_available, 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",
    "\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",
    "gbrl_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": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Setting GBRL device to cuda\n"
     ]
    }
   ],
   "source": [
    "# setting up model\n",
    "gbrl_model = GBRL(\n",
    "                    output_dim=out_dim,\n",
    "                    tree_struct=tree_struct,\n",
    "                    optimizer=optimizer,\n",
    "                    gbrl_params=gbrl_params,\n",
    "                    verbose=0,\n",
    "                    device=device)\n",
    "# set GBRL bias\n",
    "gbrl_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(X)\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(gbrl_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. GBRL 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 GBRL Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current GBRL Library Version 1.0.4\n",
      "Reading GBRL Library Version 1.0.4\n",
      "######## Loaded GBRL model ########\n",
      "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",
      "Setting GBRL device to cpu\n"
     ]
    }
   ],
   "source": [
    "# Call the save_model method of a GBRL class\n",
    "# GBRL 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",
    "gbrl_model.save_model('gbt_model_tutorial')\n",
    "# Loading a saved model is similar and is done by calling the specific class instance.\n",
    "loaded_gbt_model = GBRL.load_model('gbt_model_tutorial')\n",
    "# Copying a model is even more straighforward\n",
    "copied_model = gbrl_model.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Manually Calculated Gradients\n",
    "Alternatively GBRL 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=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",
    "GBRL 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",
      "Boosting iteration: 1 - MultiRMSE Loss: 45.6837\n",
      "Boosting iteration: 2 - MultiRMSE Loss: 41.0103\n",
      "Boosting iteration: 3 - MultiRMSE Loss: 37.8042\n",
      "Boosting iteration: 4 - MultiRMSE Loss: 36.158\n",
      "Boosting iteration: 5 - MultiRMSE Loss: 34.3719\n",
      "Boosting iteration: 6 - MultiRMSE Loss: 33.3726\n",
      "Boosting iteration: 7 - MultiRMSE Loss: 32.4287\n",
      "Boosting iteration: 8 - MultiRMSE Loss: 31.5564\n",
      "Boosting iteration: 9 - MultiRMSE Loss: 30.8898\n",
      "Boosting iteration: 10 - MultiRMSE Loss: 30.1213\n",
      "Boosting iteration: 11 - MultiRMSE Loss: 29.5286\n",
      "Boosting iteration: 12 - MultiRMSE Loss: 29.1362\n",
      "Boosting iteration: 13 - MultiRMSE Loss: 28.5909\n",
      "Boosting iteration: 14 - MultiRMSE Loss: 28.0667\n",
      "Boosting iteration: 15 - MultiRMSE Loss: 27.5238\n",
      "Boosting iteration: 16 - MultiRMSE Loss: 26.9552\n",
      "Boosting iteration: 17 - MultiRMSE Loss: 26.4736\n",
      "Boosting iteration: 18 - MultiRMSE Loss: 25.9978\n",
      "Boosting iteration: 19 - MultiRMSE Loss: 25.1341\n",
      "Boosting iteration: 20 - MultiRMSE Loss: 24.7468\n",
      "Boosting iteration: 21 - MultiRMSE Loss: 24.4723\n",
      "Boosting iteration: 22 - MultiRMSE Loss: 24.0116\n",
      "Boosting iteration: 23 - MultiRMSE Loss: 23.6174\n",
      "Boosting iteration: 24 - MultiRMSE Loss: 23.0389\n",
      "Boosting iteration: 25 - MultiRMSE Loss: 22.6742\n",
      "Boosting iteration: 26 - MultiRMSE Loss: 22.1056\n",
      "Boosting iteration: 27 - MultiRMSE Loss: 21.4225\n",
      "Boosting iteration: 28 - MultiRMSE Loss: 21.067\n",
      "Boosting iteration: 29 - MultiRMSE Loss: 20.5893\n",
      "Boosting iteration: 30 - MultiRMSE Loss: 20.376\n",
      "Boosting iteration: 31 - MultiRMSE Loss: 19.9524\n",
      "Boosting iteration: 32 - MultiRMSE Loss: 19.506\n",
      "Boosting iteration: 33 - MultiRMSE Loss: 19.199\n",
      "Boosting iteration: 34 - MultiRMSE Loss: 18.6847\n",
      "Boosting iteration: 35 - MultiRMSE Loss: 18.4608\n",
      "Boosting iteration: 36 - MultiRMSE Loss: 18.0919\n",
      "Boosting iteration: 37 - MultiRMSE Loss: 17.7628\n",
      "Boosting iteration: 38 - MultiRMSE Loss: 17.4896\n",
      "Boosting iteration: 39 - MultiRMSE Loss: 17.1724\n",
      "Boosting iteration: 40 - MultiRMSE Loss: 16.9016\n",
      "Boosting iteration: 41 - MultiRMSE Loss: 16.4126\n",
      "Boosting iteration: 42 - MultiRMSE Loss: 16.2241\n",
      "Boosting iteration: 43 - MultiRMSE Loss: 15.9164\n",
      "Boosting iteration: 44 - MultiRMSE Loss: 15.7721\n",
      "Boosting iteration: 45 - MultiRMSE Loss: 15.5468\n",
      "Boosting iteration: 46 - MultiRMSE Loss: 15.1676\n",
      "Boosting iteration: 47 - MultiRMSE Loss: 14.8433\n",
      "Boosting iteration: 48 - MultiRMSE Loss: 14.5884\n",
      "Boosting iteration: 49 - MultiRMSE Loss: 14.1943\n",
      "Boosting iteration: 50 - MultiRMSE Loss: 13.8891\n",
      "Boosting iteration: 51 - MultiRMSE Loss: 13.6252\n",
      "Boosting iteration: 52 - MultiRMSE Loss: 13.392\n",
      "Boosting iteration: 53 - MultiRMSE Loss: 13.1921\n",
      "Boosting iteration: 54 - MultiRMSE Loss: 12.9335\n",
      "Boosting iteration: 55 - MultiRMSE Loss: 12.7583\n",
      "Boosting iteration: 56 - MultiRMSE Loss: 12.497\n",
      "Boosting iteration: 57 - MultiRMSE Loss: 12.2809\n",
      "Boosting iteration: 58 - MultiRMSE Loss: 12.0752\n",
      "Boosting iteration: 59 - MultiRMSE Loss: 11.8426\n",
      "Boosting iteration: 60 - MultiRMSE Loss: 11.7026\n",
      "Boosting iteration: 61 - MultiRMSE Loss: 11.5198\n",
      "Boosting iteration: 62 - MultiRMSE Loss: 11.2283\n",
      "Boosting iteration: 63 - MultiRMSE Loss: 11.0366\n",
      "Boosting iteration: 64 - MultiRMSE Loss: 10.8907\n",
      "Boosting iteration: 65 - MultiRMSE Loss: 10.7128\n",
      "Boosting iteration: 66 - MultiRMSE Loss: 10.4434\n",
      "Boosting iteration: 67 - MultiRMSE Loss: 10.2387\n",
      "Boosting iteration: 68 - MultiRMSE Loss: 10.1145\n",
      "Boosting iteration: 69 - MultiRMSE Loss: 9.96329\n",
      "Boosting iteration: 70 - MultiRMSE Loss: 9.69015\n",
      "Boosting iteration: 71 - MultiRMSE Loss: 9.47011\n",
      "Boosting iteration: 72 - MultiRMSE Loss: 9.24967\n",
      "Boosting iteration: 73 - MultiRMSE Loss: 9.12534\n",
      "Boosting iteration: 74 - MultiRMSE Loss: 8.97243\n",
      "Boosting iteration: 75 - MultiRMSE Loss: 8.84787\n",
      "Boosting iteration: 76 - MultiRMSE Loss: 8.7207\n",
      "Boosting iteration: 77 - MultiRMSE Loss: 8.61494\n",
      "Boosting iteration: 78 - MultiRMSE Loss: 8.49335\n",
      "Boosting iteration: 79 - MultiRMSE Loss: 8.3455\n",
      "Boosting iteration: 80 - MultiRMSE Loss: 8.23905\n",
      "Boosting iteration: 81 - MultiRMSE Loss: 8.13715\n",
      "Boosting iteration: 82 - MultiRMSE Loss: 7.98508\n",
      "Boosting iteration: 83 - MultiRMSE Loss: 7.88632\n",
      "Boosting iteration: 84 - MultiRMSE Loss: 7.77416\n",
      "Boosting iteration: 85 - MultiRMSE Loss: 7.61906\n",
      "Boosting iteration: 86 - MultiRMSE Loss: 7.44399\n",
      "Boosting iteration: 87 - MultiRMSE Loss: 7.33107\n",
      "Boosting iteration: 88 - MultiRMSE Loss: 7.18596\n",
      "Boosting iteration: 89 - MultiRMSE Loss: 7.05457\n",
      "Boosting iteration: 90 - MultiRMSE Loss: 7.00124\n",
      "Boosting iteration: 91 - MultiRMSE Loss: 6.90132\n",
      "Boosting iteration: 92 - MultiRMSE Loss: 6.80752\n",
      "Boosting iteration: 93 - MultiRMSE Loss: 6.71986\n",
      "Boosting iteration: 94 - MultiRMSE Loss: 6.63359\n",
      "Boosting iteration: 95 - MultiRMSE Loss: 6.56054\n",
      "Boosting iteration: 96 - MultiRMSE Loss: 6.41324\n",
      "Boosting iteration: 97 - MultiRMSE Loss: 6.35224\n",
      "Boosting iteration: 98 - MultiRMSE Loss: 6.21616\n",
      "Boosting iteration: 99 - MultiRMSE Loss: 6.13456\n",
      "Boosting iteration: 100 - MultiRMSE Loss: 6.0776\n"
     ]
    }
   ],
   "source": [
    "gbrl_model = GBRL(\n",
    "                    output_dim=1,\n",
    "                    tree_struct=tree_struct,\n",
    "                    optimizer=optimizer,\n",
    "                    gbrl_params=gbrl_params,\n",
    "                    verbose=1,\n",
    "                    device=device)\n",
    "final_loss = gbrl_model.fit(X, y, iterations=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RL using GBRL\n",
    "Now that we have seen how GBRL 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": 10,
   "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, info = env.reset(seed=0)\n",
    "    rollout_buffer['rewards'] = []\n",
    "    done = False\n",
    "    while not done:\n",
    "        action_logits = agent(obs)\n",
    "        action = Categorical(logits=action_logits).sample()\n",
    "        action_numpy = action.cpu().numpy()\n",
    "        \n",
    "        obs, reward, terminated, truncated, info = env.step(action_numpy.squeeze())\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):\n",
    "     # model update\n",
    "    action_logits = agent(observations)\n",
    "    dist = Categorical(logits=action_logits)\n",
    "    log_probs = dist.log_prob(actions)\n",
    "    # calculate reinforce loss with subtracted baseline\n",
    "    loss = -(log_probs*(returns - returns.mean())).mean()\n",
    "    loss.backward()\n",
    "    agent.step(observations)\n",
    "\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": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Setting GBRL device to cuda\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.99\n",
    "optimizer = { 'algo': 'SGD',\n",
    "              'lr': 0.025,\n",
    "              'start_idx': 0,\n",
    "              'stop_idx': env.action_space.n,\n",
    "            }\n",
    "\n",
    "bias = np.zeros(env.action_space.n, dtype=np.single)\n",
    "agent = ParametricActor(\n",
    "                    output_dim=env.action_space.n,\n",
    "                    tree_struct=tree_struct,\n",
    "                    policy_optimizer=optimizer,\n",
    "                    gbrl_params=gbrl_params,\n",
    "                    verbose=0,\n",
    "                    bias=bias, \n",
    "                    device=device)\n",
    "\n",
    "update_every = 20\n",
    "mean_returns = []\n",
    "iterations = []\n",
    "rollout_buffer = {'actions': [], 'obs': [], 'returns': []}\n",
    "\n",
    "for episode in range(num_episodes):\n",
    "    perform_rollout(rollout_buffer, agent, wrapped_env)\n",
    "    \n",
    "    rollout_buffer['returns'].extend(calculate_returns(rollout_buffer['rewards'], gamma))\n",
    "\n",
    "    if episode % update_every == 0 and episode > 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",
    "        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",
    "GBRL implements SHAP value calculation. SHAP values can be calculated over the entire ensemble as well as for individual trees.\n",
    "GBRL returns SHAP values with shap: [n_samples, n_features, n_actions]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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": 13,
   "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}