diff --git a/examples/use_lstm_rllib.ipynb b/examples/use_lstm_rllib.ipynb
new file mode 100644
index 000000000..02c7150c9
--- /dev/null
+++ b/examples/use_lstm_rllib.ipynb
@@ -0,0 +1,525 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e24b9f08",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tensortrade.oms.instruments import Instrument\n",
+    "\n",
+    "USD = Instrument(\"USD\", 2, \"U.S. Dollar\")\n",
+    "TTC = Instrument(\"TTC\", 8, \"TensorTrade Coin\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "41df0225",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Things to understand here:\n",
+    "# Portfolio\n",
+    "# Wallet\n",
+    "# proportion_order\n",
+    "# Order\n",
+    "\n",
+    "\n",
+    "from gym.spaces import Discrete\n",
+    "\n",
+    "from tensortrade.env.default.actions import TensorTradeActionScheme\n",
+    "\n",
+    "from tensortrade.env.generic import ActionScheme, TradingEnv\n",
+    "from tensortrade.core import Clock\n",
+    "from tensortrade.oms.instruments import ExchangePair\n",
+    "from tensortrade.oms.wallets import Portfolio\n",
+    "from tensortrade.oms.orders import (\n",
+    "    Order,\n",
+    "    proportion_order,\n",
+    "    TradeSide,\n",
+    "    TradeType\n",
+    ")\n",
+    "\n",
+    "\n",
+    "class BSH(TensorTradeActionScheme):\n",
+    "\n",
+    "    registered_name = \"bsh\"\n",
+    "\n",
+    "    def __init__(self, cash: 'Wallet', asset: 'Wallet'):\n",
+    "        super().__init__()\n",
+    "        self.cash = cash\n",
+    "        self.asset = asset\n",
+    "\n",
+    "        self.listeners = []\n",
+    "        self.action = 0\n",
+    "\n",
+    "    @property\n",
+    "    def action_space(self):\n",
+    "        return Discrete(2)\n",
+    "\n",
+    "    def attach(self, listener):\n",
+    "        self.listeners += [listener]\n",
+    "        return self\n",
+    "\n",
+    "    def get_orders(self, action: int, portfolio: 'Portfolio'):\n",
+    "        order = None\n",
+    "\n",
+    "        if abs(action - self.action) > 0:\n",
+    "            src = self.cash if self.action == 0 else self.asset\n",
+    "            tgt = self.asset if self.action == 0 else self.cash\n",
+    "            order = proportion_order(portfolio, src, tgt, 1.0)\n",
+    "            self.action = action\n",
+    "\n",
+    "        for listener in self.listeners:\n",
+    "            on_action = getattr(listener, \"on_action\", None)\n",
+    "            if callable(on_action):\n",
+    "                on_action(action)\n",
+    "\n",
+    "        return [order]\n",
+    "\n",
+    "    def reset(self):\n",
+    "        super().reset()\n",
+    "        self.action = 0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "c41c5e70",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Things to understand here:\n",
+    "# Stream\n",
+    "# DataFeed\n",
+    "\n",
+    "from tensortrade.env.default.rewards import TensorTradeRewardScheme, RiskAdjustedReturns, SimpleProfit\n",
+    "from tensortrade.feed.core import Stream, DataFeed\n",
+    "\n",
+    "\n",
+    "class PBR(TensorTradeRewardScheme):\n",
+    "\n",
+    "    registered_name = \"pbr\"\n",
+    "\n",
+    "    def __init__(self, price: 'Stream'):\n",
+    "        super().__init__()\n",
+    "        self.position = -1\n",
+    "\n",
+    "        r = Stream.sensor(price, lambda p: p.value, dtype=\"float\").diff()\n",
+    "        position = Stream.sensor(self, lambda rs: rs.position, dtype=\"float\")\n",
+    "\n",
+    "        reward = (r * position).fillna(0).rename(\"reward\")\n",
+    "\n",
+    "        self.feed = DataFeed([reward])\n",
+    "        self.feed.compile()\n",
+    "\n",
+    "    def on_action(self, action: int):\n",
+    "        self.position = -1 if action == 0 else 1\n",
+    "\n",
+    "    def get_reward(self, portfolio: 'Portfolio'):\n",
+    "        return self.feed.next()[\"reward\"]\n",
+    "\n",
+    "    def reset(self):\n",
+    "        self.position = -1\n",
+    "        self.feed.reset()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "705bd1b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Things to understand here:\n",
+    "# Writing a Renderer\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from tensortrade.env.generic import Renderer\n",
+    "\n",
+    "\n",
+    "class PositionChangeChart(Renderer):\n",
+    "\n",
+    "    def __init__(self, color: str = \"orange\"):\n",
+    "        self.color = \"orange\"\n",
+    "\n",
+    "    def render(self, env, **kwargs):\n",
+    "        history = pd.DataFrame(env.observer.renderer_history)\n",
+    "\n",
+    "        actions = list(history.action)\n",
+    "        p = list(history.price)\n",
+    "\n",
+    "        buy = {}\n",
+    "        sell = {}\n",
+    "\n",
+    "        for i in range(len(actions) - 1):\n",
+    "            a1 = actions[i]\n",
+    "            a2 = actions[i + 1]\n",
+    "\n",
+    "            if a1 != a2:\n",
+    "                if a1 == 0 and a2 == 1:\n",
+    "                    buy[i] = p[i]\n",
+    "                else:\n",
+    "                    sell[i] = p[i]\n",
+    "\n",
+    "        buy = pd.Series(buy)\n",
+    "        sell = pd.Series(sell)\n",
+    "\n",
+    "        fig, axs = plt.subplots(1, 2, figsize=(15, 5))\n",
+    "\n",
+    "        fig.suptitle(\"Performance\")\n",
+    "\n",
+    "        axs[0].plot(np.arange(len(p)), p, label=\"price\", color=self.color)\n",
+    "        axs[0].scatter(buy.index, buy.values, marker=\"^\", color=\"green\")\n",
+    "        axs[0].scatter(sell.index, sell.values, marker=\"^\", color=\"red\")\n",
+    "        axs[0].set_title(\"Trading Chart\")\n",
+    "\n",
+    "        performance_df = pd.DataFrame().from_dict(env.action_scheme.portfolio.performance, orient='index')\n",
+    "        performance_df.plot(ax=axs[1])\n",
+    "        axs[1].set_title(\"Net Worth\")\n",
+    "\n",
+    "        plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "1ae7f27d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Things to understand here:\n",
+    "# execution_order\n",
+    "# Types of execution logic\n",
+    "# Exchange\n",
+    "# DataFeed\n",
+    "# renderer_feed\n",
+    "# default (env)\n",
+    "\n",
+    "import ray\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "from ray import tune\n",
+    "from ray.tune.registry import register_env\n",
+    "\n",
+    "import tensortrade.env.default as default\n",
+    "\n",
+    "from tensortrade.feed.core import DataFeed, Stream\n",
+    "from tensortrade.oms.exchanges import Exchange\n",
+    "from tensortrade.oms.services.execution.simulated import execute_order\n",
+    "from tensortrade.oms.wallets import Wallet, Portfolio\n",
+    "\n",
+    "\n",
+    "def generate_sin_data():\n",
+    "    x = np.arange(0, 2*np.pi, 2*np.pi / 1001)\n",
+    "    y = 50*np.sin(3*x) + 100\n",
+    "    return y\n",
+    "\n",
+    "\n",
+    "def create_env(config):\n",
+    "    y = generate_sin_data()\n",
+    "    p = Stream.source(y, dtype=\"float\").rename(\"USD-TTC\")\n",
+    "\n",
+    "    bitfinex = Exchange(\"bitfinex\", service=execute_order)(\n",
+    "        p\n",
+    "    )\n",
+    "\n",
+    "    cash = Wallet(bitfinex, 100000 * USD)\n",
+    "    asset = Wallet(bitfinex, 0 * TTC)\n",
+    "\n",
+    "    portfolio = Portfolio(USD, [\n",
+    "        cash,\n",
+    "        asset\n",
+    "    ])\n",
+    "\n",
+    "    feed = DataFeed([\n",
+    "        p,\n",
+    "        p.rolling(window=10).mean().rename(\"fast\"),\n",
+    "        p.rolling(window=50).mean().rename(\"medium\"),\n",
+    "        p.rolling(window=100).mean().rename(\"slow\"),\n",
+    "        p.log().diff().fillna(0).rename(\"lr\")\n",
+    "    ])\n",
+    "\n",
+    "    reward_scheme = PBR(price=p)\n",
+    "\n",
+    "    action_scheme = BSH(\n",
+    "        cash=cash,\n",
+    "        asset=asset\n",
+    "    ).attach(reward_scheme)\n",
+    "\n",
+    "    renderer_feed = DataFeed([\n",
+    "        Stream.source(y, dtype=\"float\").rename(\"price\"),\n",
+    "        Stream.sensor(action_scheme, lambda s: s.action, dtype=\"float\").rename(\"action\")\n",
+    "    ])\n",
+    "\n",
+    "    environment = default.create(\n",
+    "        feed=feed,\n",
+    "        portfolio=portfolio,\n",
+    "        action_scheme=action_scheme,\n",
+    "        reward_scheme=reward_scheme,\n",
+    "        renderer_feed=renderer_feed,\n",
+    "        renderer=PositionChangeChart(),\n",
+    "        window_size=config[\"window_size\"],\n",
+    "        max_allowed_loss=0.6\n",
+    "    )\n",
+    "    return environment\n",
+    "\n",
+    "register_env(\"TradingEnv\", create_env)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "ad7ad833",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setting this flag to true will wrap the model in an LSTM\n",
+    "use_lstm = True\n",
+    "\n",
+    "# Determine the size of the LSTM cell which will correspond to the size of the hidden state output of the LSTM\n",
+    "lstm_cell_size = 256"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1082cb70",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "analysis = tune.run(\n",
+    "    \"PPO\",\n",
+    "    stop={\n",
+    "        \"episode_reward_mean\": 500,\n",
+    "        \"training_iteration\": 20,\n",
+    "    },\n",
+    "    config={\n",
+    "        \"env\": \"TradingEnv\",\n",
+    "        \"env_config\": {\n",
+    "            \"window_size\": 25,\n",
+    "        },\n",
+    "        \"log_level\": \"ERROR\",\n",
+    "        \"framework\": \"torch\",\n",
+    "        \"ignore_worker_failures\": True,\n",
+    "        \"num_workers\": 3,\n",
+    "        \"num_gpus\": 0,\n",
+    "        \"clip_rewards\": True,\n",
+    "        \"lr\": 8e-6,\n",
+    "        \"lr_schedule\": [\n",
+    "            [0, 1e-1],\n",
+    "            [int(1e2), 1e-2],\n",
+    "            [int(1e3), 1e-3],\n",
+    "            [int(1e4), 1e-4],\n",
+    "            [int(1e5), 1e-5],\n",
+    "            [int(1e6), 1e-6],\n",
+    "            [int(1e7), 1e-7]\n",
+    "        ],\n",
+    "        \"model\": {\n",
+    "            \"use_lstm\": use_lstm,\n",
+    "            \"lstm_cell_size\": lstm_cell_size\n",
+    "        },\n",
+    "        \"gamma\": 0,\n",
+    "        \"observation_filter\": \"MeanStdFilter\",\n",
+    "        \"lambda\": 0.72,\n",
+    "        \"vf_loss_coeff\": 0.5,\n",
+    "        \"entropy_coeff\": 0.01\n",
+    "    },\n",
+    "    checkpoint_at_end=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "56485836",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ray.rllib.agents.ppo as ppo\n",
+    "\n",
+    "checkpoint_metric = 'episode_reward_mean'\n",
+    "\n",
+    "# Get checkpoint\n",
+    "checkpoints = analysis.get_trial_checkpoints_paths(\n",
+    "    trial=analysis.get_best_trial(checkpoint_metric),\n",
+    "    metric=checkpoint_metric\n",
+    ")\n",
+    "checkpoint_path = checkpoints[0][0]\n",
+    "\n",
+    "# Restore agent\n",
+    "agent = ppo.PPOTrainer(\n",
+    "    env=\"TradingEnv\",\n",
+    "    config={\n",
+    "        \"env_config\": {\n",
+    "            \"window_size\": 25,\n",
+    "        },\n",
+    "        \"framework\": \"torch\",\n",
+    "        \"log_level\": \"ERROR\",\n",
+    "        \"ignore_worker_failures\": True,\n",
+    "        \"num_workers\": 1,\n",
+    "        \"num_gpus\": 0,\n",
+    "        \"clip_rewards\": True,\n",
+    "        \"lr\": 8e-6,\n",
+    "        \"lr_schedule\": [\n",
+    "            [0, 1e-1],\n",
+    "            [int(1e2), 1e-2],\n",
+    "            [int(1e3), 1e-3],\n",
+    "            [int(1e4), 1e-4],\n",
+    "            [int(1e5), 1e-5],\n",
+    "            [int(1e6), 1e-6],\n",
+    "            [int(1e7), 1e-7]\n",
+    "        ],\n",
+    "        \"model\": {\n",
+    "            \"use_lstm\": use_lstm,\n",
+    "            \"lstm_cell_size\": lstm_cell_size\n",
+    "        },\n",
+    "        \"gamma\": 0,\n",
+    "        \"observation_filter\": \"MeanStdFilter\",\n",
+    "        \"lambda\": 0.72,\n",
+    "        \"vf_loss_coeff\": 0.5,\n",
+    "        \"entropy_coeff\": 0.01\n",
+    "    }\n",
+    ")\n",
+    "agent.restore(checkpoint_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "a0d8cd97",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "FullyConnectedNetwork_as_LSTMWrapper(\n",
+       "  (_hidden_layers): Sequential(\n",
+       "    (0): SlimFC(\n",
+       "      (_model): Sequential(\n",
+       "        (0): Linear(in_features=125, out_features=256, bias=True)\n",
+       "        (1): Tanh()\n",
+       "      )\n",
+       "    )\n",
+       "    (1): SlimFC(\n",
+       "      (_model): Sequential(\n",
+       "        (0): Linear(in_features=256, out_features=256, bias=True)\n",
+       "        (1): Tanh()\n",
+       "      )\n",
+       "    )\n",
+       "  )\n",
+       "  (_value_branch_separate): Sequential(\n",
+       "    (0): SlimFC(\n",
+       "      (_model): Sequential(\n",
+       "        (0): Linear(in_features=125, out_features=256, bias=True)\n",
+       "        (1): Tanh()\n",
+       "      )\n",
+       "    )\n",
+       "    (1): SlimFC(\n",
+       "      (_model): Sequential(\n",
+       "        (0): Linear(in_features=256, out_features=256, bias=True)\n",
+       "        (1): Tanh()\n",
+       "      )\n",
+       "    )\n",
+       "  )\n",
+       "  (_value_branch): SlimFC(\n",
+       "    (_model): Sequential(\n",
+       "      (0): Linear(in_features=256, out_features=1, bias=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (lstm): LSTM(256, 256, batch_first=True)\n",
+       "  (_logits_branch): SlimFC(\n",
+       "    (_model): Sequential(\n",
+       "      (0): Linear(in_features=256, out_features=2, bias=True)\n",
+       "    )\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# See how the model is wrapped by LSTM\n",
+    "agent.get_policy().model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "9f1e6d4f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Instantiate the environment\n",
+    "env = create_env({\n",
+    "    \"window_size\": 25,\n",
+    "})\n",
+    "\n",
+    "# Run until episode ends\n",
+    "done = False\n",
+    "obs = env.reset()\n",
+    "# Initialize hidden_state variable that will correspond to lstm_cell_size\n",
+    "hidden_state = [np.zeros(lstm_cell_size), np.zeros(lstm_cell_size)]\n",
+    "\n",
+    "i = 0\n",
+    "while not done:\n",
+    "    # In order for use_lstm to work we set full_fetch to True\n",
+    "    # This changes the output of compute action to a tuple (action, hidden_state, info)\n",
+    "    # We also pass in the previous hidden state in order for the model to use correctly use the LSTM\n",
+    "    action, hidden_state, _ = agent.compute_action(obs, state=hidden_state, full_fetch=True)\n",
+    "    obs, reward, done, info = env.step(action)\n",
+    "\n",
+    "env.render()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e62238fd",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}