notebooks/talib.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Technical Analysis using TaLib\n",
    "\n",
    "Roboquant comes out of box with support for technical analysis. It does this by having dedicate support for the popular technical analysis libraries TaLib. TaLib contains over 150 technical indicators. These are indicators ranging from RSI and Bollinger Bands to Candlestick pattern recognition. Directly using the TA-Lib library can be difficult due to its API, but roboquant makes it fairly easy by providing a convenient wrapper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%use roboquant(1.5.0)\n",
    "Welcome()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// We first setup the feed we'll use in all examples below\n",
    "val feed = AvroFeed.sp500()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start by defining the  strategy using TALib indicators we want to test in combination with the `TaLibStrategy` class. There are three steps:\n",
    "\n",
    "1) Create an instance of `TaLibStrategy` and define how much history it should maintain before invoking the indicators. If you choose this value too low, certain indicators will fail and an exception will be thrown. For example if you want a moving average over 20 days, the history should be at least 20. If you choose the history value too large, it will take longer before your strategy starts to generate signals since it will wait until it has enough history. For many of the technical indicators like candle stick patterns, 15 is sufficient (also the default value).\n",
    "\n",
    "2) Define what you logic to use for generating BUY signals. This can be a combination of indicators and you can also include regular Kotlin code. The only restriction is that the last statement has to be a boolean; true if you want to BUY, false otherwise.\n",
    "\n",
    "3) Define what you logic to use for generating SELL signals. The same rules and conditions apply as for the BUY method.\n",
    "\n",
    "Please note, that although not common practice, the framework doesn't stop you from using bullish indicators to generate a SELL signal and bearish indicators to generate a BUY signal. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Define a strategy with maximum of 15 days of history. It is important that these are enough days to calculate the various indicators.\n",
    "// This example just shows how to use different indicators, they don't make much sense in this combination\n",
    "val strategy = TaLibStrategy(15)\n",
    "\n",
    "// We want to generate a BUY signal if we detect either one of the following two candlestick pattern: Morningstar or Three WhiteSoldiers\n",
    "strategy.buy {\n",
    "    cdlMorningStar(it) || cdl3WhiteSoldiers(it)\n",
    "}\n",
    "\n",
    "// We want to generate a SELL signal if we detect the candlestick pattern Two Crows and also observe that the 5 day weighted average is below the 9 day weighted average \n",
    "strategy.sell {\n",
    "    cdl2Crows(it) && ema(it.close, 5) < ema(it.close, 9)\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can use this strategy just like any other strategy. In this case we use the S&P500 feed. \n",
    "\n",
    "Besides strategies, we can also use TALib indicators as metrics that are captured during a run. The following code creates a custom metric that calculates the Money Flow Index (aka mfi), one of the many indicators that comes with TALib. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val mfiMetric = TaLibMetric(\"mfi\") {\n",
    "    mfi(it)    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "val roboquant =  Roboquant(strategy, AccountMetric(), mfiMetric)\n",
    "roboquant.run(feed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now lets see what the outcome is. Spoiler alert, this strategy won't make you rich ;) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val account = roboquant.broker.account\n",
    "account.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let find out which trade generated most profit (realized PnL) and plot mfi for that asset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Lets find out the most profitable trade\n",
    "val mostProfitableTrade = account.trades.maxByOrNull { it.pnl.value } !!\n",
    "val asset = mostProfitableTrade.asset\n",
    "\n",
    "// Lets plot the Money Flow Index for one of the assets\n",
    "val symbol = asset.symbol.lowercase()\n",
    "val metricData = roboquant.logger.getMetric(\"mfi.$symbol\")\n",
    "MetricChart(metricData)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bollinger Bands\n",
    "This example is more realistic and shows how to implement a strategy based on Bollinger Bands. The underlying assumptions are:\n",
    "\n",
    "1. If the current price is higher than the upper bound, it will continue to go up.\n",
    "2. If the current price is lower than lower bound, it will continue to go down.\n",
    "\n",
    "Of course you can easily reverse this logic from trend following to mean reversion if you prefer and compare the outcomes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Define a strategy with maximum of bars of history. \n",
    "val barCount = 20\n",
    "val strategy = TaLibStrategy(barCount)\n",
    "\n",
    "// We want to BUY if current price is higher than the Bollinger Bands higher bound \n",
    "strategy.buy {\n",
    "    val (h, m, l) = bbands(it, barCount)\n",
    "    it.close.last() > h \n",
    "}\n",
    "\n",
    "// We want to SELL if current price is lower than the Bollinger Bands lower bound \n",
    "strategy.sell {\n",
    "    val (h, m, l) = bbands(it, barCount)\n",
    "    it.close.last() < l   \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val roboquant =  Roboquant(strategy, AccountMetric())\n",
    "roboquant.run(feed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val equity = roboquant.logger.getMetric(\"account.equity\")\n",
    "MetricChart(equity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indicators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Indicator that returns multiple values\n",
    "val asset = feed.assets.getBySymbol(\"GOOG\")\n",
    "val data = feed.apply(TaLibIndicator.bbands(), asset)\n",
    "MetricChart(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Compare indicators across different assets\n",
    "val rsi = TaLibIndicator.rsi(20)\n",
    "val apple = feed.assets.getBySymbol(\"AAPL\")\n",
    "val tesla = feed.assets.getBySymbol(\"TSLA\")\n",
    "val data = feed.apply(rsi, apple, tesla)\n",
    "MetricChart(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// see where sma crossovers appear\n",
    "val data1 = feed.apply(TaLibIndicator.sma(15), apple)\n",
    "val data2 = feed.apply(TaLibIndicator.sma(50), apple)\n",
    "MetricChart(data1 + data2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Kotlin",
   "language": "kotlin",
   "name": "kotlin"
  },
  "language_info": {
   "codemirror_mode": "text/x-kotlin",
   "file_extension": ".kt",
   "mimetype": "text/x-kotlin",
   "name": "kotlin",
   "nbconvert_exporter": "",
   "pygments_lexer": "kotlin",
   "version": "1.8.20-Beta"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}