{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "87f54819",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data and analysis libraries\n",
    "import polars as pl                         # Fast dataframes for financial data\n",
    "import numpy as np                          # Numerical computing library\n",
    "from datetime import datetime, timedelta    # Date and time operations\n",
    "import random\n",
    "\n",
    "# Machine learning libraries  \n",
    "import torch                                # PyTorch framework\n",
    "import torch.nn as nn                       # Neural network modules\n",
    "import torch.optim as optim                 # Optimization algorithms\n",
    "import research                             # Model building and training utilities\n",
    "\n",
    "# Visualization and \n",
    "import altair as alt                        # Interactive visualization library\n",
    "\n",
    "# data sources\n",
    "import binance                              # Binance market data utilities"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e8cc3fb",
   "metadata": {},
   "source": [
    "# Part 3 - Implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2718194d",
   "metadata": {},
   "source": [
    "## Recap"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fd78781",
   "metadata": {},
   "source": [
    "### Part 1: Reasearch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "ced8e0ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearModel(\n",
       "  (linear): Linear(in_features=3, out_features=1, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import models\n",
    "\n",
    "model = models.LinearModel(3)\n",
    "model.load_state_dict(torch.load('model_weights.pth', weights_only=True))\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c43665f",
   "metadata": {},
   "source": [
    "### AR(3) Model to predict future log return - 12h forecast horizon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d26b6d5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "linear.weight:\n",
      "[[-0.02849757 -0.08180149 -0.05941094]]\n",
      "linear.bias:\n",
      "[0.00058626]\n"
     ]
    }
   ],
   "source": [
    "research.print_model_params(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8250c71",
   "metadata": {},
   "source": [
    "## Part 2: Strategy Recap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "13a8bba8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ~14% without any optimization\n",
    "# 1. Compounding Trade Sizing\n",
    "# 2. Leverage\n",
    "# ~14% to >40%"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c0d6f13",
   "metadata": {},
   "source": [
    "## Tick"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "8c0d69f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "from typing import Generic, TypeVar\n",
    "\n",
    "T = TypeVar('T')  # input type\n",
    "R = TypeVar('R')  # output type\n",
    "\n",
    "class Tick(ABC, Generic[T, R]):\n",
    "    @abstractmethod\n",
    "    def on_tick(self, val: T) -> R:\n",
    "        \"\"\"Handle a new tick and optionally return a result.\"\"\"\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c684fbf",
   "metadata": {},
   "source": [
    "## Sliding Window"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "9d331f96",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "from typing import Deque, Optional\n",
    "import numpy as np\n",
    "\n",
    "class DequeWindow(Tick[T, Optional[T]], Generic[T]):\n",
    "    def __init__(self, n: int):\n",
    "        self._data: Deque[T] = deque(maxlen=n)\n",
    "\n",
    "    def on_tick(self, val: T) -> Optional[T]:\n",
    "        \"\"\"Append a value and return the oldest value dropped (if any).\"\"\"\n",
    "        dropped = None\n",
    "        if self.is_full():\n",
    "            dropped = self._data[0]\n",
    "        self._data.append(val)\n",
    "        return dropped\n",
    "    \n",
    "    def is_full(self) -> bool:\n",
    "        return self._data.maxlen == len(self._data)\n",
    "\n",
    "    def append_left(self, val: T) -> Optional[T]:\n",
    "        dropped = None\n",
    "        if self.is_full():\n",
    "            dropped = self._data[-1]\n",
    "        self._data.appendleft(val)\n",
    "        return dropped\n",
    "    \n",
    "    def to_numpy(self) -> np.ndarray:\n",
    "        return np.array(self._data)\n",
    "    \n",
    "    def __repr__(self) -> str:\n",
    "        cls_name = self.__class__.__name__\n",
    "        return f\"{cls_name}(capacity={self._data.maxlen}, values={list(self._data)})\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b1af130",
   "metadata": {},
   "source": [
    "### Array based window"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "f4fc79a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from typing import Optional\n",
    "\n",
    "class NumpyWindow(Tick[T, Optional[T]]):\n",
    "    def __init__(self, n: int, dtype=np.float64):\n",
    "        if n <= 0:\n",
    "            raise ValueError(\"Capacity must be positive.\")\n",
    "        self._capacity = n\n",
    "        self._data = np.zeros(n, dtype=dtype)\n",
    "        self._size = 0\n",
    "\n",
    "    def on_tick(self, val: float) -> Optional[float]:\n",
    "        dropped = None\n",
    "\n",
    "        if self._size < self._capacity:\n",
    "            self._data[self._size] = val\n",
    "            self._size += 1\n",
    "        else:\n",
    "            dropped = self._data[0]\n",
    "            # shift left in-place\n",
    "            for i in range(1, self._capacity):\n",
    "                self._data[i - 1] = self._data[i]\n",
    "            self._data[-1] = val\n",
    "\n",
    "        return dropped\n",
    "\n",
    "\n",
    "    def __getitem__(self, idx: int) -> float:\n",
    "        \"\"\"Index access (0 = oldest).\"\"\"\n",
    "        if not 0 <= idx < self._size:\n",
    "            raise IndexError(\"Index out of range.\")\n",
    "        return self._data[idx]\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self._size\n",
    "\n",
    "    def capacity(self) -> int:\n",
    "        return self._capacity\n",
    "\n",
    "    def is_full(self) -> bool:\n",
    "        return self._size == self._capacity\n",
    "\n",
    "    def values(self) -> np.ndarray:\n",
    "        return self._data[:self._size]\n",
    "\n",
    "    def __repr__(self) -> str:\n",
    "        vals = self.values().tolist()\n",
    "        return f\"{self.__class__.__name__}(capacity={self._capacity}, size={self._size}, values={vals})\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9213b19",
   "metadata": {},
   "source": [
    "### Stream the Last Known Value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "e3b6ae13",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Last(Tick[T, T], Generic[T]):\n",
    "    def __init__(self):\n",
    "        self._value: Optional[T] = None\n",
    "\n",
    "    def on_tick(self, val: T) -> Optional[T]:\n",
    "        self._value = val\n",
    "        return val\n",
    "\n",
    "    def __repr__(self) -> str:\n",
    "        cls_name = self.__class__.__name__\n",
    "        return f\"{cls_name}(value={self._value})\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d93282e7",
   "metadata": {},
   "source": [
    "## Streaming Log Returns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "e14f546c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "class LogReturn(Tick[float, Optional[float]], Generic[T]):\n",
    "    def __init__(self):\n",
    "        self._window = NumpyWindow(2)\n",
    "\n",
    "    def on_tick(self, val: float) -> Optional[float]:\n",
    "        self._window.on_tick(val)\n",
    "        if self._window.is_full():\n",
    "            return np.log(self._window[1] / self._window[0])\n",
    "        else:\n",
    "            return None\n",
    "        \n",
    "    def __repr__(self) -> str:\n",
    "        cls_name = self.__class__.__name__\n",
    "        return f\"{cls_name}(window={self._window})\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c2ef8a2",
   "metadata": {},
   "source": [
    "## Streaming Auto-Regressive Log Returns Lags"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "cf955e23",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LogReturnLags(Tick[float, torch.Tensor]):\n",
    "    def __init__(self, no_lags: int):\n",
    "        self._lags = DequeWindow(no_lags)\n",
    "        self._log_return = LogReturn()\n",
    "    \n",
    "    def on_tick(self, val: float) -> torch.Tensor | None:\n",
    "        log_ret = self._log_return.on_tick(val)\n",
    "        if log_ret is not None:\n",
    "            self._lags.append_left(log_ret)\n",
    "            return torch.tensor(self._lags.to_numpy(), dtype=torch.float32) if self._lags.is_full() else None\n",
    "        else:\n",
    "            return None\n",
    "        \n",
    "    def __repr__(self) -> str:\n",
    "        cls_name = self.__class__.__name__\n",
    "        return f\"{cls_name}(lags={self._lags}, log_return={self._log_return})\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "7d62e078",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 0.3747, -0.3102,  0.4055])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lags = LogReturnLags(3)\n",
    "lags.on_tick(90)\n",
    "lags.on_tick(100)\n",
    "lags.on_tick(150)\n",
    "lags.on_tick(110)\n",
    "features = lags.on_tick(160)\n",
    "features"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ab400f2",
   "metadata": {},
   "source": [
    "### Streaming features into our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "43b202c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([-0.0088])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = features\n",
    "with torch.no_grad():\n",
    "    y_hat = model(X)\n",
    "y_hat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "d57f4837",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(-0.0088)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_hat[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1f09327",
   "metadata": {},
   "source": [
    "## Build the Trading System"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "study (3.14.5.final.0)",
   "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.14.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}