diff --git a/trade_flow/environments/metatrader/examples/SB3_a2c_ppo_syn_indices.ipynb b/trade_flow/environments/metatrader/examples/SB3_a2c_ppo_syn_indices.ipynb
deleted file mode 100644
index f7bf360..0000000
--- a/trade_flow/environments/metatrader/examples/SB3_a2c_ppo_syn_indices.ipynb
+++ /dev/null
@@ -1,458 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Imports"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 2,
-      "metadata": {
-        "tags": []
-      },
-      "outputs": [],
-      "source": [
-        "import os\n",
-        "from tqdm import tqdm\n",
-        "import random\n",
-        "\n",
-        "import numpy as np\n",
-        "import pandas as pd\n",
-        "import seaborn as sns\n",
-        "import matplotlib.pyplot as plt\n",
-        "\n",
-        "import gymnasium as gym\n",
-        "from trade_flow.environments import metatrader\n",
-        "\n",
-        "from stable_baselines3 import A2C, PPO\n",
-        "from stable_baselines3.common.callbacks import BaseCallback\n",
-        "\n",
-        "import torch"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Create Env"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Create Synthetics Environment"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 12,
-      "metadata": {},
-      "outputs": [
-        {
-          "data": {
-            "text/plain": [
-              "'/home/fortesenselabs/Tech/labs/Financial_Eng/Financial_Markets/lab/trade_flow/trade_flow/environments/metatrader/examples/data/synthetic_indices_symbols.joblib'"
-            ]
-          },
-          "execution_count": 12,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
-      "source": [
-        "from typing import List, Tuple\n",
-        "from datetime import datetime\n",
-        "from gymnasium.envs.registration import register\n",
-        "from trade_flow.environments.metatrader import Simulator, Timeframe, FOREX_DATA_PATH\n",
-        "\n",
-        "DATA_DIR = os.path.dirname(os.getcwd())\n",
-        "SYNTHETIC_INDICES_DATA_PATH = os.path.join(DATA_DIR, \"examples/data/synthetic_indices_symbols.joblib\")\n",
-        "SYNTHETIC_INDICES_DATA_PATH"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 13,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "def get_data(symbols: List[str] = [\"EURUSD\", \"GBPCAD\", \"USDJPY\"], \n",
-        "             time_range: Tuple[datetime, datetime] = (datetime(2011, 1, 1), datetime(2012, 12, 31)),\n",
-        "             timeframe: Timeframe = Timeframe.D1, \n",
-        "             filename: str = FOREX_DATA_PATH):\n",
-        "    \n",
-        "    mt_sim = metatrader.Simulator()\n",
-        "    mt_sim.download_data(symbols, time_range, timeframe)\n",
-        "    mt_sim.save_symbols(filename)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 14,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Define the time range for the data download\n",
-        "start_date = datetime(2020, 1, 1)\n",
-        "end_date = datetime(2023, 12, 31)\n",
-        "time_range = (start_date, end_date)\n",
-        "\n",
-        "# synthetic indices\n",
-        "\n",
-        "synthetic_indices_symbols = [\n",
-        "    # \"Volatility 10 Index\", \n",
-        "    # \"Volatility 25 Index\",  \n",
-        "    \"Volatility 75 (1s) Index\",\n",
-        "    \"Volatility 150 (1s) Index\",\n",
-        "    \"Volatility 200 (1s) Index\",\n",
-        "    \"Volatility 250 (1s) Index\"]\n",
-        "\n",
-        "get_data(synthetic_indices_symbols, time_range, Timeframe.H1, SYNTHETIC_INDICES_DATA_PATH)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 15,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "\n",
-        "register(\n",
-        "    id=\"synthetic-indices-hedge-v0\",\n",
-        "    entry_point=\"trade_flow.environments.metatrader.envs:MT5Env\",\n",
-        "    kwargs={\n",
-        "        \"original_simulator\": Simulator(symbols_filename=SYNTHETIC_INDICES_DATA_PATH, hedge=True),\n",
-        "        \"trading_symbols\": synthetic_indices_symbols,\n",
-        "        \"window_size\": 10,\n",
-        "        \"symbol_max_orders\": 2,\n",
-        "        \"fee\": 0.2,\n",
-        "    },\n",
-        ")\n",
-        "\n",
-        "register(\n",
-        "    id=\"synthetic-indices-unhedge-v0\",\n",
-        "    entry_point=\"trade_flow.environments.metatrader.envs:MT5Env\",\n",
-        "    kwargs={\n",
-        "        \"original_simulator\": Simulator(symbols_filename=SYNTHETIC_INDICES_DATA_PATH, hedge=False),\n",
-        "        \"trading_symbols\": synthetic_indices_symbols,\n",
-        "        \"window_size\": 10,\n",
-        "        \"fee\": 0.2,\n",
-        "    },\n",
-        ")"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 16,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "/home/fortesenselabs/anaconda3/envs/algo_trading/lib/python3.11/site-packages/gymnasium/utils/passive_env_checker.py:42: UserWarning: \u001b[33mWARN: A Box observation space has an unconventional shape (neither an image, nor a 1D vector). We recommend flattening the observation to have only a 1D vector or use a custom policy to properly process the data. Actual observation shape: (10, 8)\u001b[0m\n",
-            "  logger.warn(\n",
-            "/home/fortesenselabs/anaconda3/envs/algo_trading/lib/python3.11/site-packages/gymnasium/utils/passive_env_checker.py:29: UserWarning: \u001b[33mWARN: It seems a Box observation space is an image but the `dtype` is not `np.uint8`, actual type: float64. If the Box observation space is not an image, we recommend flattening the observation to have only a 1D vector.\u001b[0m\n",
-            "  logger.warn(\n",
-            "/home/fortesenselabs/anaconda3/envs/algo_trading/lib/python3.11/site-packages/gymnasium/utils/passive_env_checker.py:34: UserWarning: \u001b[33mWARN: It seems a Box observation space is an image but the lower and upper bounds are not [0, 255]. Actual lower bound: -10000000000.0, upper bound: 10000000000.0. Generally, CNN policies assume observations are within that range, so you may encounter an issue if the observation values are not.\u001b[0m\n",
-            "  logger.warn(\n"
-          ]
-        }
-      ],
-      "source": [
-        "# env_name = 'forex-hedge-v0'\n",
-        "# env_name = 'stocks-hedge-v0'\n",
-        "# env_name = 'crypto-hedge-v0'\n",
-        "# env_name = 'mixed-hedge-v0'\n",
-        "\n",
-        "# env_name = 'forex-unhedge-v0'\n",
-        "# env_name = 'stocks-unhedge-v0'\n",
-        "# env_name = 'crypto-unhedge-v0'\n",
-        "# env_name = 'mixed-unhedge-v0'\n",
-        "\n",
-        "env_name = 'synthetic-indices-hedge-v0'\n",
-        "# env_name = 'synthetic-indices-unhedge-v0'\n",
-        "\n",
-        "env = gym.make(env_name)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Define Functions"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 17,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "def print_stats(reward_over_episodes):\n",
-        "    \"\"\"  Print Reward  \"\"\"\n",
-        "\n",
-        "    avg = np.mean(reward_over_episodes)\n",
-        "    min = np.min(reward_over_episodes)\n",
-        "    max = np.max(reward_over_episodes)\n",
-        "\n",
-        "    print (f'Min. Reward          : {min:>10.3f}')\n",
-        "    print (f'Avg. Reward          : {avg:>10.3f}')\n",
-        "    print (f'Max. Reward          : {max:>10.3f}')\n",
-        "\n",
-        "    return min, avg, max\n",
-        "\n",
-        "\n",
-        "# ProgressBarCallback for model.learn()\n",
-        "class ProgressBarCallback(BaseCallback):\n",
-        "\n",
-        "    def __init__(self, check_freq: int, verbose: int = 1):\n",
-        "        super().__init__(verbose)\n",
-        "        self.check_freq = check_freq\n",
-        "\n",
-        "    def _on_training_start(self) -> None:\n",
-        "        \"\"\"\n",
-        "        This method is called before the first rollout starts.\n",
-        "        \"\"\"\n",
-        "        self.progress_bar = tqdm(total=self.model._total_timesteps, desc=\"model.learn()\")\n",
-        "\n",
-        "    def _on_step(self) -> bool:\n",
-        "        if self.n_calls % self.check_freq == 0:\n",
-        "            self.progress_bar.update(self.check_freq)\n",
-        "        return True\n",
-        "    \n",
-        "    def _on_training_end(self) -> None:\n",
-        "        \"\"\"\n",
-        "        This event is triggered before exiting the `learn()` method.\n",
-        "        \"\"\"\n",
-        "        self.progress_bar.close()\n",
-        "\n",
-        "\n",
-        "# TRAINING + TEST\n",
-        "def train_test_model(model, env, seed, total_num_episodes, total_learning_timesteps=10_000):\n",
-        "    \"\"\" if model=None then execute 'Random actions' \"\"\"\n",
-        "\n",
-        "    # reproduce training and test\n",
-        "    print('-' * 80)\n",
-        "    obs = env.reset(seed=seed)\n",
-        "    torch.manual_seed(seed)\n",
-        "    random.seed(seed)\n",
-        "    np.random.seed(seed)\n",
-        "\n",
-        "    vec_env = None\n",
-        "\n",
-        "    if model is not None:\n",
-        "        print(f'model {type(model)}')\n",
-        "        print(f'policy {type(model.policy)}')\n",
-        "        # print(f'model.learn(): {total_learning_timesteps} timesteps ...')\n",
-        "\n",
-        "        # custom callback for 'progress_bar'\n",
-        "        model.learn(total_timesteps=total_learning_timesteps, callback=ProgressBarCallback(100))\n",
-        "        # model.learn(total_timesteps=total_learning_timesteps, progress_bar=True)\n",
-        "        # ImportError: You must install tqdm and rich in order to use the progress bar callback. \n",
-        "        # It is included if you install stable-baselines with the extra packages: `pip install stable-baselines3[extra]`\n",
-        "\n",
-        "        vec_env = model.get_env()\n",
-        "        obs = vec_env.reset()\n",
-        "    else:\n",
-        "        print (\"RANDOM actions\")\n",
-        "\n",
-        "    reward_over_episodes = []\n",
-        "\n",
-        "    tbar = tqdm(range(total_num_episodes))\n",
-        "\n",
-        "    for episode in tbar:\n",
-        "        \n",
-        "        if vec_env: \n",
-        "            obs = vec_env.reset()\n",
-        "        else:\n",
-        "            obs, info = env.reset()\n",
-        "\n",
-        "        total_reward = 0\n",
-        "        done = False\n",
-        "\n",
-        "        while not done:\n",
-        "            if model is not None:\n",
-        "                action, _states = model.predict(obs)\n",
-        "                obs, reward, done, info = vec_env.step(action)\n",
-        "            else: # random\n",
-        "                action = env.action_space.sample()\n",
-        "                obs, reward, terminated, truncated, info = env.step(action)\n",
-        "                done = terminated or truncated\n",
-        "\n",
-        "            total_reward += reward\n",
-        "            if done:\n",
-        "                break\n",
-        "\n",
-        "        reward_over_episodes.append(total_reward)\n",
-        "\n",
-        "        if episode % 10 == 0:\n",
-        "            avg_reward = np.mean(reward_over_episodes)\n",
-        "            tbar.set_description(f'Episode: {episode}, Avg. Reward: {avg_reward:.3f}')\n",
-        "            tbar.update()\n",
-        "\n",
-        "    tbar.close()\n",
-        "    avg_reward = np.mean(reward_over_episodes)\n",
-        "\n",
-        "    return reward_over_episodes"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Train + Test Env"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "tags": []
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "env_name                 : synthetic-indices-hedge-v0\n",
-            "seed                     : 2024\n",
-            "--------------------------------------------------------------------------------\n",
-            "RANDOM actions\n"
-          ]
-        },
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "Episode: 0, Avg. Reward: -9999.991:  18%|█▊        | 9/50 [05:14<23:50, 34.90s/it]"
-          ]
-        }
-      ],
-      "source": [
-        "seed = 2024  # random seed\n",
-        "total_num_episodes = 50\n",
-        "\n",
-        "print (\"env_name                 :\", env_name)\n",
-        "print (\"seed                     :\", seed)\n",
-        "\n",
-        "# INIT matplotlib\n",
-        "plot_settings = {}\n",
-        "plot_data = {'x': [i for i in range(1, total_num_episodes + 1)]}\n",
-        "\n",
-        "# Random actions\n",
-        "model = None \n",
-        "total_learning_timesteps = 0\n",
-        "rewards = train_test_model(model, env, seed, total_num_episodes, total_learning_timesteps)\n",
-        "min, avg, max = print_stats(rewards)\n",
-        "class_name = f'Random actions'\n",
-        "label = f'Avg. {avg:>7.2f} : {class_name}'\n",
-        "plot_data['rnd_rewards'] = rewards\n",
-        "plot_settings['rnd_rewards'] = {'label': label}\n",
-        "\n",
-        "learning_timesteps_list_in_K = [25]\n",
-        "# learning_timesteps_list_in_K = [50, 250, 500]\n",
-        "# learning_timesteps_list_in_K = [500, 1000, 3000, 5000]\n",
-        "\n",
-        "# RL Algorithms: https://stable-baselines3.readthedocs.io/en/master/guide/algos.html\n",
-        "model_class_list = [A2C, PPO]\n",
-        "\n",
-        "for timesteps in learning_timesteps_list_in_K:\n",
-        "    total_learning_timesteps = timesteps * 1000\n",
-        "    step_key = f'{timesteps}K'\n",
-        "\n",
-        "    for model_class in model_class_list:\n",
-        "        policy_dict = model_class.policy_aliases\n",
-        "        # https://stable-baselines3.readthedocs.io/en/master/guide/custom_policy.html\n",
-        "        policy = policy_dict.get('MultiInputPolicy')\n",
-        "\n",
-        "        try:\n",
-        "            model = model_class(policy, env, verbose=0)\n",
-        "            class_name = type(model).__qualname__\n",
-        "            plot_key = f'{class_name}_rewards_'+step_key\n",
-        "            rewards = train_test_model(model, env, seed, total_num_episodes, total_learning_timesteps)\n",
-        "            min, avg, max, = print_stats(rewards)\n",
-        "            label = f'Avg. {avg:>7.2f} : {class_name} - {step_key}'\n",
-        "            plot_data[plot_key] = rewards\n",
-        "            plot_settings[plot_key] = {'label': label}     \n",
-        "\n",
-        "        except Exception as e:\n",
-        "            print(f\"ERROR: {str(e)}\")\n",
-        "            continue"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Plot Results"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 6,
-      "metadata": {},
-      "outputs": [
-        {
-          "data": {
-            "image/png": "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",
-            "text/plain": [
-              "<Figure size 800x600 with 1 Axes>"
-            ]
-          },
-          "metadata": {},
-          "output_type": "display_data"
-        }
-      ],
-      "source": [
-        "data = pd.DataFrame(plot_data)\n",
-        "\n",
-        "sns.set_style('whitegrid')\n",
-        "plt.figure(figsize=(8, 6))\n",
-        "\n",
-        "for key in plot_data:\n",
-        "    if key == 'x':\n",
-        "        continue\n",
-        "    label = plot_settings[key]['label']\n",
-        "    line = plt.plot('x', key, data=data, linewidth=1, label=label)\n",
-        "\n",
-        "plt.xlabel('episode')\n",
-        "plt.ylabel('reward')\n",
-        "plt.title('Random vs. SB3 Agents')\n",
-        "plt.legend()\n",
-        "plt.show()"
-      ]
-    }
-  ],
-  "metadata": {
-    "accelerator": "GPU",
-    "colab": {
-      "collapsed_sections": [],
-      "name": "p3.ipynb",
-      "provenance": []
-    },
-    "kernelspec": {
-      "display_name": "algo_trading",
-      "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.10"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 0
-}
diff --git a/trade_flow/environments/metatrader/examples/data/synthetic_indices_symbols.joblib b/trade_flow/environments/metatrader/examples/data/synthetic_indices_symbols.joblib
index 3f364ac..995dcc7 100644
Binary files a/trade_flow/environments/metatrader/examples/data/synthetic_indices_symbols.joblib and b/trade_flow/environments/metatrader/examples/data/synthetic_indices_symbols.joblib differ
diff --git a/trade_flow/environments/metatrader/examples/synthetic_indices.ipynb b/trade_flow/environments/metatrader/examples/synthetic_indices.ipynb
new file mode 100644
index 0000000..45b3686
--- /dev/null
+++ b/trade_flow/environments/metatrader/examples/synthetic_indices.ipynb
@@ -0,0 +1,459 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Imports"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 26,
+      "metadata": {
+        "tags": []
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "from tqdm import tqdm\n",
+        "import random\n",
+        "\n",
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import seaborn as sns\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "import gymnasium as gym\n",
+        "from trade_flow.environments import metatrader\n",
+        "\n",
+        "from stable_baselines3 import A2C, PPO, DQN\n",
+        "from stable_baselines3.common.callbacks import BaseCallback\n",
+        "\n",
+        "import torch"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create Env"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### Create Synthetics Environment"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from typing import List, Tuple\n",
+        "from datetime import datetime\n",
+        "from gymnasium.envs.registration import register\n",
+        "from trade_flow.environments.metatrader import Simulator, Timeframe, FOREX_DATA_PATH\n",
+        "\n",
+        "DATA_DIR = os.path.dirname(os.getcwd())\n",
+        "SYNTHETIC_INDICES_DATA_PATH = os.path.join(DATA_DIR, \"examples/data/synthetic_indices_symbols.joblib\")\n",
+        "SYNTHETIC_INDICES_DATA_PATH"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 28,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def get_data(symbols: List[str] = [\"EURUSD\", \"GBPCAD\", \"USDJPY\"], \n",
+        "             time_range: Tuple[datetime, datetime] = (datetime(2011, 1, 1), datetime(2012, 12, 31)),\n",
+        "             timeframe: Timeframe = Timeframe.D1, \n",
+        "             filename: str = FOREX_DATA_PATH):\n",
+        "    \n",
+        "    mt_sim = metatrader.Simulator()\n",
+        "    mt_sim.download_data(symbols, time_range, timeframe)\n",
+        "    mt_sim.save_symbols(filename)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 29,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Define the time range for the data download\n",
+        "start_date = datetime(2020, 1, 1)\n",
+        "end_date = datetime(2023, 12, 31)\n",
+        "time_range = (start_date, end_date)\n",
+        "\n",
+        "# synthetic indices\n",
+        "\n",
+        "# synthetic_indices_symbols = [\n",
+        "#     \"Volatility 10 Index\", \n",
+        "#     \"Volatility 25 Index\",  \n",
+        "#     \"Volatility 75 (1s) Index\",\n",
+        "#     \"Volatility 150 (1s) Index\",\n",
+        "#     \"Volatility 200 (1s) Index\",\n",
+        "#     \"Volatility 250 (1s) Index\"]\n",
+        "synthetic_indices_symbols = [\n",
+        "    \"Step Index\",\n",
+        "    \"Volatility 25 Index\",  \n",
+        "    \"Volatility 75 (1s) Index\",\n",
+        "    \"Volatility 150 (1s) Index\",]\n",
+        "get_data(synthetic_indices_symbols, time_range, Timeframe.H4, SYNTHETIC_INDICES_DATA_PATH)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "\n",
+        "register(\n",
+        "    id=\"synthetic-indices-hedge-v0\",\n",
+        "    entry_point=\"trade_flow.environments.metatrader.envs:MT5Env\",\n",
+        "    kwargs={\n",
+        "        \"original_simulator\": Simulator(balance=1000, leverage=500, symbols_filename=SYNTHETIC_INDICES_DATA_PATH, hedge=True),\n",
+        "        \"trading_symbols\": synthetic_indices_symbols,\n",
+        "        \"window_size\": 10,\n",
+        "        \"symbol_max_orders\": 3,\n",
+        "        \"hold_threshold\": 0.3,\n",
+        "        \"close_threshold\": 0.7,\n",
+        "        \"fee\": 0.1,\n",
+        "    },\n",
+        ")\n",
+        "\n",
+        "register(\n",
+        "    id=\"synthetic-indices-unhedge-v0\",\n",
+        "    entry_point=\"trade_flow.environments.metatrader.envs:MT5Env\",\n",
+        "    kwargs={\n",
+        "        \"original_simulator\": Simulator(balance=1000, leverage=500, symbols_filename=SYNTHETIC_INDICES_DATA_PATH, hedge=False),\n",
+        "        \"trading_symbols\": synthetic_indices_symbols,\n",
+        "        \"window_size\": 10,\n",
+        "        \"hold_threshold\": 0.5,\n",
+        "        \"close_threshold\": 0.5,\n",
+        "        \"fee\": 0.1,\n",
+        "    },\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# env_name = 'forex-hedge-v0'\n",
+        "# env_name = 'stocks-hedge-v0'\n",
+        "# env_name = 'crypto-hedge-v0'\n",
+        "# env_name = 'mixed-hedge-v0'\n",
+        "\n",
+        "# env_name = 'forex-unhedge-v0'\n",
+        "# env_name = 'stocks-unhedge-v0'\n",
+        "# env_name = 'crypto-unhedge-v0'\n",
+        "# env_name = 'mixed-unhedge-v0'\n",
+        "\n",
+        "env_name = 'synthetic-indices-hedge-v0'\n",
+        "# env_name = 'synthetic-indices-unhedge-v0'\n",
+        "\n",
+        "env = gym.make(env_name)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "env.observation_space"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "env.action_space"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Define Functions"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 36,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def print_stats(reward_over_episodes):\n",
+        "    \"\"\"  Print Reward  \"\"\"\n",
+        "\n",
+        "    avg = np.mean(reward_over_episodes)\n",
+        "    min = np.min(reward_over_episodes)\n",
+        "    max = np.max(reward_over_episodes)\n",
+        "\n",
+        "    print (f'Min. Reward          : {min:>10.3f}')\n",
+        "    print (f'Avg. Reward          : {avg:>10.3f}')\n",
+        "    print (f'Max. Reward          : {max:>10.3f}')\n",
+        "\n",
+        "    return min, avg, max\n",
+        "\n",
+        "\n",
+        "# ProgressBarCallback for model.learn()\n",
+        "class ProgressBarCallback(BaseCallback):\n",
+        "\n",
+        "    def __init__(self, check_freq: int, verbose: int = 1):\n",
+        "        super().__init__(verbose)\n",
+        "        self.check_freq = check_freq\n",
+        "\n",
+        "    def _on_training_start(self) -> None:\n",
+        "        \"\"\"\n",
+        "        This method is called before the first rollout starts.\n",
+        "        \"\"\"\n",
+        "        self.progress_bar = tqdm(total=self.model._total_timesteps, desc=\"model.learn()\")\n",
+        "\n",
+        "    def _on_step(self) -> bool:\n",
+        "        if self.n_calls % self.check_freq == 0:\n",
+        "            self.progress_bar.update(self.check_freq)\n",
+        "        return True\n",
+        "    \n",
+        "    def _on_training_end(self) -> None:\n",
+        "        \"\"\"\n",
+        "        This event is triggered before exiting the `learn()` method.\n",
+        "        \"\"\"\n",
+        "        self.progress_bar.close()\n",
+        "\n",
+        "\n",
+        "# TRAINING + TEST\n",
+        "def train_test_model(model, env, seed, total_num_episodes, total_learning_timesteps=10_000):\n",
+        "    \"\"\" if model=None then execute 'Random actions' \"\"\"\n",
+        "\n",
+        "    # reproduce training and test\n",
+        "    print('-' * 80)\n",
+        "    obs = env.reset(seed=seed)\n",
+        "    torch.manual_seed(seed)\n",
+        "    random.seed(seed)\n",
+        "    np.random.seed(seed)\n",
+        "\n",
+        "    vec_env = None\n",
+        "\n",
+        "    if model is not None:\n",
+        "        print(f'model {type(model)}')\n",
+        "        print(f'policy {type(model.policy)}')\n",
+        "        # print(f'model.learn(): {total_learning_timesteps} timesteps ...')\n",
+        "\n",
+        "        # custom callback for 'progress_bar'\n",
+        "        model.learn(total_timesteps=total_learning_timesteps, callback=ProgressBarCallback(100))\n",
+        "        # model.learn(total_timesteps=total_learning_timesteps, progress_bar=True)\n",
+        "        # ImportError: You must install tqdm and rich in order to use the progress bar callback. \n",
+        "        # It is included if you install stable-baselines with the extra packages: `pip install stable-baselines3[extra]`\n",
+        "\n",
+        "        vec_env = model.get_env()\n",
+        "        obs = vec_env.reset()\n",
+        "    else:\n",
+        "        print (\"RANDOM actions\")\n",
+        "\n",
+        "    reward_over_episodes = []\n",
+        "\n",
+        "    tbar = tqdm(range(total_num_episodes))\n",
+        "\n",
+        "    for episode in tbar:\n",
+        "        \n",
+        "        if vec_env: \n",
+        "            obs = vec_env.reset()\n",
+        "        else:\n",
+        "            obs, info = env.reset()\n",
+        "\n",
+        "        total_reward = 0\n",
+        "        done = False\n",
+        "\n",
+        "        while not done:\n",
+        "            if model is not None:\n",
+        "                action, _states = model.predict(obs)\n",
+        "                obs, reward, done, info = vec_env.step(action)\n",
+        "            else: # random\n",
+        "                action = env.action_space.sample()\n",
+        "                obs, reward, terminated, truncated, info = env.step(action)\n",
+        "                done = terminated or truncated\n",
+        "\n",
+        "            total_reward += reward\n",
+        "            if done:\n",
+        "                break\n",
+        "\n",
+        "        reward_over_episodes.append(total_reward)\n",
+        "\n",
+        "        if episode % 10 == 0:\n",
+        "            avg_reward = np.mean(reward_over_episodes)\n",
+        "            tbar.set_description(f'Episode: {episode}, Avg. Reward: {avg_reward:.3f}')\n",
+        "            tbar.update()\n",
+        "\n",
+        "    tbar.close()\n",
+        "    avg_reward = np.mean(reward_over_episodes)\n",
+        "\n",
+        "    return reward_over_episodes"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Train + Test Env"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "seed = 2024  # random seed\n",
+        "total_num_episodes = 50\n",
+        "\n",
+        "print (\"env_name                 :\", env_name)\n",
+        "print (\"seed                     :\", seed)\n",
+        "\n",
+        "# INIT matplotlib\n",
+        "plot_settings = {}\n",
+        "plot_data = {'x': [i for i in range(1, total_num_episodes + 1)]}\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### Random actions"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Random actions\n",
+        "model = None \n",
+        "total_learning_timesteps = 0\n",
+        "rewards = train_test_model(model, env, seed, total_num_episodes, total_learning_timesteps)\n",
+        "min, avg, max = print_stats(rewards)\n",
+        "class_name = f'Random actions'\n",
+        "label = f'Avg. {avg:>7.2f} : {class_name}'\n",
+        "plot_data['rnd_rewards'] = rewards\n",
+        "plot_settings['rnd_rewards'] = {'label': label}"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### SB3 Agents"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "tags": []
+      },
+      "outputs": [],
+      "source": [
+        "learning_timesteps_list_in_K = [25]\n",
+        "# learning_timesteps_list_in_K = [50, 250, 500]\n",
+        "# learning_timesteps_list_in_K = [500, 1000, 3000, 5000]\n",
+        "\n",
+        "# RL Algorithms: https://stable-baselines3.readthedocs.io/en/master/guide/algos.html\n",
+        "model_class_list = [A2C, PPO, DQN]\n",
+        "\n",
+        "for timesteps in learning_timesteps_list_in_K:\n",
+        "    total_learning_timesteps = timesteps * 1000\n",
+        "    step_key = f'{timesteps}K'\n",
+        "\n",
+        "    for model_class in model_class_list:\n",
+        "        policy_dict = model_class.policy_aliases\n",
+        "        # https://stable-baselines3.readthedocs.io/en/master/guide/custom_policy.html\n",
+        "        policy = policy_dict.get('MultiInputPolicy') # Try MlpPolicy or MlpLstmPolicy\n",
+        "\n",
+        "        try:\n",
+        "            model = model_class(policy, env, verbose=0)\n",
+        "            class_name = type(model).__qualname__\n",
+        "            plot_key = f'{class_name}_rewards_'+step_key\n",
+        "            rewards = train_test_model(model, env, seed, total_num_episodes, total_learning_timesteps)\n",
+        "            min, avg, max, = print_stats(rewards)\n",
+        "            label = f'Avg. {avg:>7.2f} : {class_name} - {step_key}'\n",
+        "            plot_data[plot_key] = rewards\n",
+        "            plot_settings[plot_key] = {'label': label}     \n",
+        "\n",
+        "        except Exception as e:\n",
+        "            print(f\"ERROR: {str(e)}\")\n",
+        "            continue"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Plot Results"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "data = pd.DataFrame(plot_data)\n",
+        "\n",
+        "sns.set_style('whitegrid')\n",
+        "plt.figure(figsize=(8, 6))\n",
+        "\n",
+        "for key in plot_data:\n",
+        "    if key == 'x':\n",
+        "        continue\n",
+        "    label = plot_settings[key]['label']\n",
+        "    line = plt.plot('x', key, data=data, linewidth=1, label=label)\n",
+        "\n",
+        "plt.xlabel('episode')\n",
+        "plt.ylabel('reward')\n",
+        "plt.title('Random vs. SB3 Agents')\n",
+        "plt.legend()\n",
+        "plt.show()"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "collapsed_sections": [],
+      "name": "p3.ipynb",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "algo_trading",
+      "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.10"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}