Policy Gradiant using Keras

DQN_v1.ipynb

@@ -11,6 +11,28 @@
         "#### This version implements DQN with Keras\n"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Hi everybody, I just finished coding a DQN from scratch that can solve CartPole-v1. https://huggingface.co/bonadio/rl-fin/blob/main/DQN_v1.ipynb \n",
+        "It takes 6000 steps, here is the result https://huggingface.co/bonadio/rl-fin/blob/main/DQN_v1_result.mp4.\n",
+        "\n",
+        "I can say that coding a RL algorithm is really challenge. The biggest difficult is that there are a lot of parameters to tune and it is hard to know when you are on the right track. \n",
+        "For me, the DQN main points where: \n",
+        "1- number of layers of the NN I started with only 2 layers of 64, but had to grow to 3 layers with 512,256,128\n",
+        "\n",
+        "2- NN frequency update, when you copy the weights from one NN to the other. I started with 50 steps, but end up with 5, the more often you update the better.\n",
+        "\n",
+        "3- Size of the batch, the number of samples that you take from the replay memory, seems that the bigger the best. I started with 10 and end up with 100. \n",
+        "\n",
+        "4- Epsilon decay, seen that the network only really starts to learn after it stops taking random positions. A very small value as end value is good, I used 0.001\n",
+        "\n",
+        "5- The size of the memory replay does not play a big difference I used 10.000 but I think it could be smaller like 5.000\n",
+        "\n",
+        "Now that I have a working DQN I will adapt it to trade Ethereum. I will convert my code from Q-learning to DQN. "
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 1,

Policy_gradiant_cartpole_v1.ipynb

@@ -0,0 +1,483 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "nwaAZRu1NTiI"
+      },
+      "source": [
+        "# Policy Gradiant\n",
+        "\n",
+        "#### This version implements Policy Gradiant with Keras to solve cartpole\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "id": "Nm5rvpUZNxDp"
+      },
+      "outputs": [],
+      "source": [
+        "# %%capture\n",
+        "# !pip install gym==0.22\n",
+        "# !pip install pygame\n",
+        "# !apt install python-opengl\n",
+        "# !apt install ffmpeg\n",
+        "# !apt install xvfb\n",
+        "# !pip install pyvirtualdisplay\n",
+        "# !pip install pyglet==1.5.1"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "LNXxxKojNTiL",
+        "outputId": "c48489ab-d67f-448e-9362-746a4e6bcba2"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "2.9.2\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": [
+              "<pyvirtualdisplay.display.Display at 0x7fbeaf7ea190>"
+            ]
+          },
+          "execution_count": 14,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "import tensorflow as tf\n",
+        "from tensorflow.keras import layers, Model, Input\n",
+        "from tensorflow.keras.utils import to_categorical\n",
+        "import tensorflow.keras.backend as K\n",
+        "\n",
+        "import gym\n",
+        "from gym import spaces\n",
+        "from gym.utils import seeding\n",
+        "from gym import wrappers\n",
+        "\n",
+        "from tqdm.notebook import tqdm\n",
+        "from collections import deque\n",
+        "import numpy as np\n",
+        "import random\n",
+        "from matplotlib import pyplot as plt\n",
+        "from sklearn.preprocessing import MinMaxScaler\n",
+        "\n",
+        "import io\n",
+        "import base64\n",
+        "from IPython.display import HTML, Video\n",
+        "print(tf.__version__)\n",
+        "\n",
+        "# Virtual display\n",
+        "from pyvirtualdisplay import Display\n",
+        "\n",
+        "virtual_display = Display(visible=0, size=(1400, 900))\n",
+        "virtual_display.start()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "id": "c84LoGsXNnJo"
+      },
+      "outputs": [],
+      "source": [
+        "# custom model to be able to run a custom loss with parameters\n",
+        "class CustomModel(tf.keras.Model):\n",
+        "    def custom_loss(self,y, y_pred, d_returns):\n",
+        "        # print(\"y\", y.shape)\n",
+        "        # K.print_tensor(y)\n",
+        "        # print(\"y Pred\", y_pred.shape)    \n",
+        "        # K.print_tensor(y_pred)\n",
+        "        # print(\"d_retur\", d_returns.shape)    \n",
+        "        # K.print_tensor(d_returns)\n",
+        "        # crossentropy \n",
+        "        log_like = y * K.log(y_pred)\n",
+        "        # print(\"-log_like\", log_like.shape)    \n",
+        "        # K.print_tensor(log_like)\n",
+        "        # print(\"-Log_lik * d_returns\")\n",
+        "        # K.print_tensor(-log_like * d_returns)\n",
+        "        # print(\"k_sum\")\n",
+        "        # K.print_tensor(K.sum(-log_like * d_returns ))\n",
+        "        return K.sum(-log_like * d_returns )\n",
+        "        \n",
+        "    def train_step(self, data):\n",
+        "        # Unpack the data. Its structure depends on your model and\n",
+        "        # on what you pass to `fit()`.\n",
+        "        if len(data) == 3:\n",
+        "            x, y, sample_weight = data\n",
+        "        else:\n",
+        "            sample_weight = None\n",
+        "            x, y = data\n",
+        "\n",
+        "        # check if we passed the d_return\n",
+        "        if isinstance(x, tuple):\n",
+        "            x, d_return = x\n",
+        "\n",
+        "        with tf.GradientTape() as tape:\n",
+        "            y_pred = self(x, training=True)  # Forward pass\n",
+        "            # Compute the loss value.\n",
+        "            y = tf.cast(y, tf.float32)\n",
+        "            loss = self.custom_loss(y, y_pred, d_return)\n",
+        "\n",
+        "        # Compute gradients\n",
+        "        trainable_vars = self.trainable_variables\n",
+        "        gradients = tape.gradient(loss, trainable_vars)\n",
+        "\n",
+        "        # Update weights\n",
+        "        self.optimizer.apply_gradients(zip(gradients, trainable_vars))\n",
+        "\n",
+        "        # Update the metrics.\n",
+        "        # Metrics are configured in `compile()`.\n",
+        "        self.compiled_metrics.update_state(y, y_pred, sample_weight=sample_weight)\n",
+        "\n",
+        "        # Return a dict mapping metric names to current value.\n",
+        "        # Note that it will include the loss (tracked in self.metrics).\n",
+        "        return {m.name: m.result() for m in self.metrics}"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {
+        "id": "sF8L5d-GNnJp"
+      },
+      "outputs": [],
+      "source": [
+        "class Policy:\n",
+        "    def __init__(self, env=None, action_size=2):\n",
+        "\n",
+        "        self.action_size = action_size\n",
+        "\n",
+        "        # Hyperparameters\n",
+        "        self.gamma = 0.95           # Discount rate\n",
+        "\n",
+        "        self.learning_rate = 1e-2\n",
+        "        \n",
+        "        # Construct DQN models\n",
+        "        self.env = env\n",
+        "        self.action_size = action_size\n",
+        "        self.action_space = [i for i in range(action_size)]\n",
+        "        print(\"action space\",self.action_space)\n",
+        "        # self.saved_log_probs = None\n",
+        "        self.model= self._build_model()\n",
+        "        self.model.summary()\n",
+        "\n",
+        "    def _build_model(self):\n",
+        "        \n",
+        "        x = Input(shape=(4,), name='x_input')\n",
+        "        # y_true = Input( shape=(2,), name='y_true' )\n",
+        "        d_returns = Input(shape=[1], name='d_returns')\n",
+        "\n",
+        "        l = layers.Dense(16, activation = 'relu')(x)\n",
+        "        l = layers.Dense(16, activation = 'relu')(l)\n",
+        "        y_pred = layers.Dense(self.action_size, activation = 'softmax', name='y_pred')(l)\n",
+        "        \n",
+        "        optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)\n",
+        "\n",
+        "        # model_train = Model( inputs=[x], outputs=[y_pred], name='train_only' )\n",
+        "        model_train = CustomModel( inputs=x, outputs=y_pred, name='train_only' )\n",
+        "        # model_predict = Model( inputs=x, outputs=y_pred, name='predict_only' )\n",
+        "        model_train.compile(loss=None, optimizer=optimizer, metrics = ['accuracy'])\n",
+        "        # model_train.compile(loss=None, optimizer=optimizer, metrics = ['accuracy'], run_eagerly = True)\n",
+        "\n",
+        "        return model_train\n",
+        "\n",
+        "\n",
+        "    def act(self, state):\n",
+        "        # print(\"Act state\",state)\n",
+        "        probs = self.model.predict(np.array([state]), verbose=0)[0]\n",
+        "        # print(\"probs\",probs)\n",
+        "        action = np.random.choice(self.action_space, p=probs)\n",
+        "        # print(\"Action\",action)\n",
+        "        # return the action and the log of the probability \n",
+        "        # return action, np.log(probs[action])\n",
+        "        return action\n",
+        "\n",
+        "\n",
+        "    # this implements the reinforce \n",
+        "    def learn(self, n_training_episodes=None, max_t=None, print_every=100):\n",
+        "        # Help us to calculate the score during the training\n",
+        "        scores_deque = deque(maxlen=100)\n",
+        "        scores = []\n",
+        "        # Line 3 of pseudocode\n",
+        "        for i_episode in range(1, n_training_episodes+1):\n",
+        "            # saved_log_probs = []\n",
+        "            saved_actions = []\n",
+        "            saved_state = []\n",
+        "            rewards = []\n",
+        "            state = self.env.reset()\n",
+        "            # Line 4 of pseudocode\n",
+        "            for t in range(max_t):\n",
+        "                saved_state.append(state)\n",
+        "                action = self.act(state)\n",
+        "                # action, log_prob = self.act(state)\n",
+        "                # saved_log_probs.append(log_prob)\n",
+        "                saved_actions.append(action)\n",
+        "                state, reward, done, _ = self.env.step(action)\n",
+        "                rewards.append(reward)\n",
+        "                if done:\n",
+        "                    break \n",
+        "            scores_deque.append(sum(rewards))\n",
+        "            scores.append(sum(rewards))\n",
+        "            \n",
+        "            # Line 6 of pseudocode: calculate the return\n",
+        "            returns = deque(maxlen=max_t) \n",
+        "            n_steps = len(rewards) \n",
+        "            # Compute the discounted returns at each timestep,\n",
+        "            # as \n",
+        "            #      the sum of the gamma-discounted return at time t (G_t) + the reward at time t\n",
+        "            #\n",
+        "            # In O(N) time, where N is the number of time steps\n",
+        "            # (this definition of the discounted return G_t follows the definition of this quantity \n",
+        "            # shown at page 44 of Sutton&Barto 2017 2nd draft)\n",
+        "            # G_t = r_(t+1) + r_(t+2) + ...\n",
+        "            \n",
+        "            # Given this formulation, the returns at each timestep t can be computed \n",
+        "            # by re-using the computed future returns G_(t+1) to compute the current return G_t\n",
+        "            # G_t = r_(t+1) + gamma*G_(t+1)\n",
+        "            # G_(t-1) = r_t + gamma* G_t\n",
+        "            # (this follows a dynamic programming approach, with which we memorize solutions in order \n",
+        "            # to avoid computing them multiple times)\n",
+        "            \n",
+        "            # This is correct since the above is equivalent to (see also page 46 of Sutton&Barto 2017 2nd draft)\n",
+        "            # G_(t-1) = r_t + gamma*r_(t+1) + gamma*gamma*r_(t+2) + ...\n",
+        "            \n",
+        "            \n",
+        "            ## Given the above, we calculate the returns at timestep t as: \n",
+        "            #               gamma[t] * return[t] + reward[t]\n",
+        "            #\n",
+        "            ## We compute this starting from the last timestep to the first, in order\n",
+        "            ## to employ the formula presented above and avoid redundant computations that would be needed \n",
+        "            ## if we were to do it from first to last.\n",
+        "            \n",
+        "            ## Hence, the queue \"returns\" will hold the returns in chronological order, from t=0 to t=n_steps\n",
+        "            ## thanks to the appendleft() function which allows to append to the position 0 in constant time O(1)\n",
+        "            ## a normal python list would instead require O(N) to do this.\n",
+        "            for t in range(n_steps)[::-1]:\n",
+        "                disc_return_t = (returns[0] if len(returns)>0 else 0)\n",
+        "                returns.appendleft( self.gamma*disc_return_t + rewards[t]   )    \n",
+        "                \n",
+        "            ## standardization of the returns is employed to make training more stable\n",
+        "            eps = np.finfo(np.float32).eps.item()\n",
+        "            ## eps is the smallest representable float, which is \n",
+        "            # added to the standard deviation of the returns to avoid numerical instabilities        \n",
+        "            returns = np.array(returns)\n",
+        "            returns = (returns - returns.mean()) / (returns.std() + eps)\n",
+        "            # self.saved_log_probs = saved_log_probs\n",
+        "            \n",
+        "            # Line 7:\n",
+        "            saved_state = np.array(saved_state)\n",
+        "            # print(\"Saved state\", saved_state, saved_state.shape)\n",
+        "            saved_actions = np.array(to_categorical(saved_actions, num_classes=self.action_size))\n",
+        "            # print(\"Saved actions\", saved_actions, saved_actions.shape)\n",
+        "            returns = returns.reshape(-1,1)\n",
+        "            # print(\"Returns\", returns, returns.shape)\n",
+        "            # this is the trick part, we send a tuple so the CustomModel is able to split the x  and use \n",
+        "            # the returns inside to calculate the custom loss\n",
+        "            self.model.train_on_batch(x=(saved_state,returns), y=saved_actions)\n",
+        "\n",
+        "            # policy_loss = []\n",
+        "            # for action, log_prob, disc_return in zip(saved_actions, saved_log_probs, returns):\n",
+        "            #     policy_loss.append(-log_prob * disc_return)\n",
+        "            # policy_loss = torch.cat(policy_loss).sum()\n",
+        "            \n",
+        "            # # Line 8: PyTorch prefers gradient descent \n",
+        "            # optimizer.zero_grad()\n",
+        "            # policy_loss.backward()\n",
+        "            # optimizer.step()\n",
+        "            \n",
+        "            if i_episode % print_every == 0:\n",
+        "                print('Episode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_deque)))\n",
+        "        \n",
+        "        return scores\n",
+        "\n",
+        "    #\n",
+        "    # Loads a saved model\n",
+        "    #https://medium.com/@Bloomore/how-to-write-a-custom-loss-function-with-additional-arguments-in-keras-5f193929f7a0\n",
+        "    #\n",
+        "    def load(self, name):\n",
+        "        self.model.load_weights(name)\n",
+        "\n",
+        "    #\n",
+        "    # Saves parameters of a trained model\n",
+        "    #\n",
+        "    def save(self, name):\n",
+        "        self.model.save_weights(name)\n",
+        "\n",
+        "    def play(self, state):\n",
+        "        return np.argmax(self.model.predict(np.array([state]), verbose=0)[0])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "z64C2rO7NnJq",
+        "outputId": "fd4c1942-c7b6-49af-cead-e6a48ee987d0"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "action space [0, 1]\n",
+            "Model: \"train_only\"\n",
+            "_________________________________________________________________\n",
+            " Layer (type)                Output Shape              Param #   \n",
+            "=================================================================\n",
+            " x_input (InputLayer)        [(None, 4)]               0         \n",
+            "                                                                 \n",
+            " dense_6 (Dense)             (None, 16)                80        \n",
+            "                                                                 \n",
+            " dense_7 (Dense)             (None, 16)                272       \n",
+            "                                                                 \n",
+            " y_pred (Dense)              (None, 2)                 34        \n",
+            "                                                                 \n",
+            "=================================================================\n",
+            "Total params: 386\n",
+            "Trainable params: 386\n",
+            "Non-trainable params: 0\n",
+            "_________________________________________________________________\n",
+            "Episode 100\tAverage Score: 66.31\n",
+            "Episode 200\tAverage Score: 161.58\n",
+            "Episode 300\tAverage Score: 282.58\n"
+          ]
+        }
+      ],
+      "source": [
+        "env = gym.make('CartPole-v1')\n",
+        "\n",
+        "model = Policy(env=env, action_size=2)\n",
+        "# model.learn(total_steps=6_000)\n",
+        "\n",
+        "model.learn(n_training_episodes=1000, max_t=1000, print_every=100)\n",
+        "env.close()\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "id": "7zS2PuLSNnJr"
+      },
+      "outputs": [],
+      "source": [
+        "model.save(\"./alt/policy_grad_cartpole.h5\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "vgDMDokeNnJr",
+        "outputId": "13a744e9-5119-4c5f-d681-39b0933fd661"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "action space [0, 1]\n",
+            "Model: \"train_only\"\n",
+            "_________________________________________________________________\n",
+            " Layer (type)                Output Shape              Param #   \n",
+            "=================================================================\n",
+            " x_input (InputLayer)        [(None, 4)]               0         \n",
+            "                                                                 \n",
+            " dense_4 (Dense)             (None, 16)                80        \n",
+            "                                                                 \n",
+            " dense_5 (Dense)             (None, 16)                272       \n",
+            "                                                                 \n",
+            " y_pred (Dense)              (None, 2)                 34        \n",
+            "                                                                 \n",
+            "=================================================================\n",
+            "Total params: 386\n",
+            "Trainable params: 386\n",
+            "Non-trainable params: 0\n",
+            "_________________________________________________________________\n",
+            "Total reward 189.0\n"
+          ]
+        }
+      ],
+      "source": [
+        "eval_env = gym.make('CartPole-v1')\n",
+        "model = Policy(env=eval_env, action_size=2)\n",
+        "model.load(\"./alt/policy_grad_cartpole.h5\")\n",
+        "eval_env = wrappers.Monitor(eval_env, \"./alt/gym-results\", force=True)\n",
+        "state = eval_env.reset()\n",
+        "total_reward = 0\n",
+        "for _ in range(1000):\n",
+        "    action = model.play(state)\n",
+        "    observation, reward, done, info = eval_env.step(action)\n",
+        "    total_reward +=reward\n",
+        "    state = observation\n",
+        "    if done: \n",
+        "        print(f\"Total reward {total_reward}\")\n",
+        "        break\n",
+        "eval_env.close()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "2HxBAnLQUoZW"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "provenance": []
+    },
+    "gpuClass": "standard",
+    "kernelspec": {
+      "display_name": "Python 3.9.16 ('rl3')",
+      "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.16"
+    },
+    "orig_nbformat": 4,
+    "vscode": {
+      "interpreter": {
+        "hash": "9070e15ca35f8308b0c5d51e893fc04d77e428fe4d803a6d9ae4f68a65d8ce17"
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

Test_custom_loss.ipynb

@@ -0,0 +1,804 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "nwaAZRu1NTiI"
+      },
+      "source": [
+        "# Test custom loss in Keras\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "LNXxxKojNTiL"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "2023-02-06 12:11:59.127639: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
+            "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "2.11.0\n"
+          ]
+        }
+      ],
+      "source": [
+        "import tensorflow as tf\n",
+        "from tensorflow.keras import layers, Model, Input\n",
+        "from tensorflow.keras.utils import to_categorical\n",
+        "import tensorflow.keras.backend as K\n",
+        "\n",
+        "from matplotlib import pyplot as plt\n",
+        "import numpy as np\n",
+        "\n",
+        "print(tf.__version__)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 184,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "class CustomModel(tf.keras.Model):\n",
+        "    def train_step(self, data):\n",
+        "        # Unpack the data. Its structure depends on your model and\n",
+        "        # on what you pass to `fit()`.\n",
+        "        if len(data) == 3:\n",
+        "            x, y, sample_weight = data\n",
+        "        else:\n",
+        "            sample_weight = None\n",
+        "            x, y = data\n",
+        "\n",
+        "        # check if we passed the d_return\n",
+        "        if isinstance(x, tuple):\n",
+        "            x = x[0]\n",
+        "            d_return = x[1]\n",
+        "\n",
+        "\n",
+        "        with tf.GradientTape() as tape:\n",
+        "            y_pred = self(x, training=True)  # Forward pass\n",
+        "            # Compute the loss value.\n",
+        "            # The loss function is configured in `compile()`.\n",
+        "            # loss = self.compiled_loss(\n",
+        "            #     y,\n",
+        "            #     y_pred,\n",
+        "            #     sample_weight=sample_weight,\n",
+        "            #     regularization_losses=self.losses,\n",
+        "            # )\n",
+        "            y = tf.cast(y, tf.float32)\n",
+        "            loss = K.mean(K.square(y_pred - y), axis=-1)\n",
+        "\n",
+        "        # Compute gradients\n",
+        "        trainable_vars = self.trainable_variables\n",
+        "        gradients = tape.gradient(loss, trainable_vars)\n",
+        "\n",
+        "        # Update weights\n",
+        "        self.optimizer.apply_gradients(zip(gradients, trainable_vars))\n",
+        "\n",
+        "        # Update the metrics.\n",
+        "        # Metrics are configured in `compile()`.\n",
+        "        self.compiled_metrics.update_state(y, y_pred, sample_weight=sample_weight)\n",
+        "\n",
+        "        # Return a dict mapping metric names to current value.\n",
+        "        # Note that it will include the loss (tracked in self.metrics).\n",
+        "        return {m.name: m.result() for m in self.metrics}"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 185,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Model: \"train_only\"\n",
+            "_________________________________________________________________\n",
+            " Layer (type)                Output Shape              Param #   \n",
+            "=================================================================\n",
+            " x_input (InputLayer)        [(None, 1)]               0         \n",
+            "                                                                 \n",
+            " dense_47 (Dense)            (None, 1)                 2         \n",
+            "                                                                 \n",
+            "=================================================================\n",
+            "Total params: 2\n",
+            "Trainable params: 2\n",
+            "Non-trainable params: 0\n",
+            "_________________________________________________________________\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Simplest NN without custom loss\n",
+        "\n",
+        "x_input = Input(shape=(1,), name='x_input')\n",
+        "output = layers.Dense(1, activation=None)(x_input)\n",
+        "\n",
+        "model = CustomModel(inputs=x_input, outputs=output, name='train_only')\n",
+        "model.compile(loss=None, optimizer=tf.keras.optimizers.Adam(learning_rate=0.1))\n",
+        "\n",
+        "model.summary()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 186,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "x = np.array([ [i] for i in range(1,100) ])\n",
+        "y = np.array([ [i] for i in range(1,100) ])\n",
+        "\n",
+        "history = model.train_on_batch(x=(x,x),y=y)\n",
+        "# history = model.fit([x,x], y, epochs=700, verbose=0)\n",
+        "# history = model.fit(x, y, validation_split=0.2, epochs=500, verbose=0)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 147,
+      "metadata": {},
+      "outputs": [
+        {
+          "ename": "AttributeError",
+          "evalue": "'float' object has no attribute 'history'",
+          "output_type": "error",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+            "Cell \u001b[0;32mIn[147], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m plt\u001b[38;5;241m.\u001b[39mplot(\u001b[43mhistory\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhistory\u001b[49m[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mloss\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[1;32m      2\u001b[0m \u001b[38;5;66;03m# plt.plot(history.history['val_loss'])\u001b[39;00m\n\u001b[1;32m      3\u001b[0m plt\u001b[38;5;241m.\u001b[39mtitle(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmodel loss\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
+            "\u001b[0;31mAttributeError\u001b[0m: 'float' object has no attribute 'history'"
+          ]
+        }
+      ],
+      "source": [
+        "plt.plot(history.history['loss'])\n",
+        "# plt.plot(history.history['val_loss'])\n",
+        "plt.title('model loss')\n",
+        "plt.ylim(-0.1, 1)\n",
+        "plt.ylabel('loss')\n",
+        "plt.xlabel('epoch')\n",
+        "plt.legend(['train', 'test'], loc='upper left')\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 97,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "0.0"
+            ]
+          },
+          "execution_count": 97,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "history.history['loss'][-1]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "pred = model.predict(x)\n",
+        "pred"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 99,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "\n",
+        "plt.scatter(x, y, c='blue')\n",
+        "plt.plot(x, pred, color='g')\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "for i in np.arange(1.5,100.5, 1):\n",
+        "    print(i)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3.9.16 ('rl3')",
+      "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.16"
+    },
+    "orig_nbformat": 4,
+    "vscode": {
+      "interpreter": {
+        "hash": "9070e15ca35f8308b0c5d51e893fc04d77e428fe4d803a6d9ae4f68a65d8ce17"
+      }
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "01a2dbcb714e40148b41c761fcf43147": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "20b0f38ec3234ff28a62a286cd57b933": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "PasswordModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "PasswordModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "PasswordView",
+            "continuous_update": true,
+            "description": "Token:",
+            "description_tooltip": null,
+            "disabled": false,
+            "layout": "IPY_MODEL_01a2dbcb714e40148b41c761fcf43147",
+            "placeholder": "​",
+            "style": "IPY_MODEL_90c874e91b304ee1a7ef147767ac00ce",
+            "value": ""
+          }
+        },
+        "270cbb5d6e9c4b1e9e2f39c8b3b0c15f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "VBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "VBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "VBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_a02224a43d8d4af3bd31d326540d25da",
+              "IPY_MODEL_20b0f38ec3234ff28a62a286cd57b933",
+              "IPY_MODEL_f6c845330d6743c0b35c2c7ad834de77",
+              "IPY_MODEL_f1675c09d16a4251b403f9c56255f168",
+              "IPY_MODEL_c1a82965ae26479a98e4fdbde1e64ec2"
+            ],
+            "layout": "IPY_MODEL_3fa248114ac24656ba74923936a94d2d"
+          }
+        },
+        "2dc5fa9aa3334dfcbdee9c238f2ef60b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "3e753b0212644990b558c68853ff2041": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "3fa248114ac24656ba74923936a94d2d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": "center",
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "flex",
+            "flex": null,
+            "flex_flow": "column",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "50%"
+          }
+        },
+        "42d140b838b844819bc127afc1b7bc84": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "90c874e91b304ee1a7ef147767ac00ce": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "9d847f9a7d47458d8cd57d9b599e47c6": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "a02224a43d8d4af3bd31d326540d25da": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_caef095934ec47bbb8b64eab22049284",
+            "placeholder": "​",
+            "style": "IPY_MODEL_2dc5fa9aa3334dfcbdee9c238f2ef60b",
+            "value": "<center> <img\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.svg\nalt='Hugging Face'> <br> Copy a token from <a\nhref=\"https://huggingface.co/settings/tokens\" target=\"_blank\">your Hugging Face\ntokens page</a> and paste it below. <br> Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file. </center>"
+          }
+        },
+        "a2cfb91cf66447d7899292854bd64a07": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c1a82965ae26479a98e4fdbde1e64ec2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_9d847f9a7d47458d8cd57d9b599e47c6",
+            "placeholder": "​",
+            "style": "IPY_MODEL_42d140b838b844819bc127afc1b7bc84",
+            "value": "\n<b>Pro Tip:</b> If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. </center>"
+          }
+        },
+        "caef095934ec47bbb8b64eab22049284": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "eaba3f1de4444aabadfea2a3dadb1d80": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "ee4a21bedc504171ad09d205d634b528": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ButtonStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ButtonStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "button_color": null,
+            "font_weight": ""
+          }
+        },
+        "f1675c09d16a4251b403f9c56255f168": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ButtonModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ButtonModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ButtonView",
+            "button_style": "",
+            "description": "Login",
+            "disabled": false,
+            "icon": "",
+            "layout": "IPY_MODEL_a2cfb91cf66447d7899292854bd64a07",
+            "style": "IPY_MODEL_ee4a21bedc504171ad09d205d634b528",
+            "tooltip": ""
+          }
+        },
+        "f6c845330d6743c0b35c2c7ad834de77": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "CheckboxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "CheckboxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "CheckboxView",
+            "description": "Add token as git credential?",
+            "description_tooltip": null,
+            "disabled": false,
+            "indent": true,
+            "layout": "IPY_MODEL_3e753b0212644990b558c68853ff2041",
+            "style": "IPY_MODEL_eaba3f1de4444aabadfea2a3dadb1d80",
+            "value": true
+          }
+        }
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

fin_rl_dqn_v1.ipynb

@@ -2045,6 +2045,11 @@
         "Sequential random (175 days)- Trade the test set sequentially from start to end day with random actions "
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": []
+    },
     {
       "cell_type": "markdown",
       "metadata": {},

fin_rl_qlearning_v1.ipynb

@@ -784,7 +784,7 @@
         "\n",
         "| Model      | 1000 trades 20 steps | Sequential trading | 1000 trades 20 steps random actions | Sequential random|\n",
         "|------------|----------------------|--------------------|-------------------------------------|------------------|\n",
-        "|Q-learning  | 109.01               | 563.67             | -18.10                              | 39.30            |\n",
+        "|Q-learning  | 113.14               | 563.67             | -18.10                              | 39.30            |\n",
         "\n"
       ]
     },