notebooks/xgboost.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c1e58f18-c076-4254-ba2e-471db51f1243",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "This notebook shows how to use roboquant in combination with machine learning based strategies. For this particulair notebook XGBoost is used. \n",
    "\n",
    "The strategy will predict the next day return based on a configurable number of previous day returns. When the predicted next day return is above or below a certain configurable percentage, a BUY or SELL signal will be generated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70773d5b-d049-4cce-84b7-a9b719981c8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "%use roboquant(1.3.0)\n",
    "Welcome()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5351e55",
   "metadata": {},
   "outputs": [],
   "source": [
    "// Load the XGBoost library and import the package \n",
    "@file:DependsOn(\"ml.dmlc:xgboost4j_2.12:1.7.1\")\n",
    "import ml.dmlc.xgboost4j.java.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3166b1d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "/** \n",
    " * Small utility class to store daily return as a list of floats\n",
    " */\n",
    "class ReturnHistory(private val data: MutableList<Float> = mutableListOf()) : MutableList<Float> by data  {\n",
    "\n",
    "    private var previousPrice = Float.NaN\n",
    "\n",
    "    fun add(priceAction: PriceAction) {\n",
    "        val newPrice = priceAction.getPrice(\"CLOSE\").toFloat()\n",
    "        if (previousPrice.isFinite()) {\n",
    "            val returns = (newPrice - previousPrice) / previousPrice\n",
    "            data.add(returns)\n",
    "        }\n",
    "        previousPrice = newPrice\n",
    "    }\n",
    "\n",
    "    override fun clear() {\n",
    "        data.clear()\n",
    "        previousPrice = Float.NaN\n",
    "    }\n",
    "\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6032b803",
   "metadata": {},
   "outputs": [],
   "source": [
    "/**\n",
    " * Example XGBoost based strategy that predicts the next day return based on previous day returns\n",
    " *\n",
    " * @param asset the asset to use\n",
    " * @property windowSize the number of previous returns to take into account, default is 10\n",
    " * @property minPercentage the minimum predicted change required to generate a [Signal], default is 1%\n",
    " */\n",
    "class XGBoostStrategy(\n",
    "    asset: Asset,\n",
    "    private val windowSize: Int = 10,\n",
    "    private val minPercentage: Double = 0.01) : SingleAssetStrategy(asset)\n",
    "{\n",
    "    private val data = ReturnHistory()\n",
    "    var model: Booster? = null\n",
    "\n",
    "    /**\n",
    "     * @see SingleAssetStrategy.generate\n",
    "     */\n",
    "    override fun generate(priceAction: PriceAction, time: Instant): Signal? {\n",
    "\n",
    "        if (model != null) {\n",
    "            data.add(priceAction)\n",
    "            if (data.size >= windowSize) {\n",
    "                val predictedChange = predict()\n",
    "                return when {\n",
    "                    predictedChange > minPercentage -> Signal(asset, Rating.BUY)\n",
    "                    predictedChange < -minPercentage -> Signal(asset, Rating.SELL)\n",
    "                    else -> null\n",
    "                }\n",
    "            }\n",
    "        } else {\n",
    "            data.add(priceAction)\n",
    "        }\n",
    "        return null\n",
    "    }\n",
    "\n",
    "    /**\n",
    "     * At the start of the MAIN phase we delete the model and clear the data\n",
    "     *\n",
    "     * @param runPhase\n",
    "     */\n",
    "    override fun start(runPhase: RunPhase) {\n",
    "        if (runPhase == RunPhase.MAIN) {\n",
    "            data.clear()\n",
    "            model = null\n",
    "        }\n",
    "    }\n",
    "\n",
    "    /**\n",
    "     * At the end of the MAIN phase we train a new model with the data we collected that then can be used\n",
    "     * during the validation phase\n",
    "     */\n",
    "    override fun end(runPhase: RunPhase) {\n",
    "        if (runPhase == RunPhase.MAIN) {\n",
    "            train()\n",
    "            data.clear()\n",
    "        }\n",
    "    }\n",
    "\n",
    "    /**\n",
    "     * Predict the next day return\n",
    "     */\n",
    "    private fun predict(): Float {\n",
    "        val feature = data.takeLast(windowSize)\n",
    "        val dMatrix = DMatrix(feature.toFloatArray(), 1, windowSize, Float.NaN)\n",
    "        val result = model!!.predict(dMatrix)\n",
    "        return result.last().last()\n",
    "    }\n",
    "\n",
    "    /**\n",
    "     * Training method\n",
    "     */\n",
    "    private fun train() {\n",
    "        val features = mutableListOf<Float>()\n",
    "        val labels = mutableListOf<Float>()\n",
    "        val max = data.lastIndex - windowSize - 1\n",
    "        for (x in 0..max) {\n",
    "            val feature = data.subList(x, x+windowSize)\n",
    "            features.addAll(feature)\n",
    "            val label = data[x + windowSize]\n",
    "            labels.add(label)\n",
    "        }\n",
    "\n",
    "        val trainData = DMatrix(features.toFloatArray(), labels.size, windowSize, Float.NaN)\n",
    "        trainData.label = labels.toFloatArray()\n",
    "\n",
    "        val params: Map<String, Any> = mapOf(\n",
    "            \"eta\" to 0.3,\n",
    "            \"max_depth\" to 6,\n",
    "            \"objective\" to \"reg:squarederror\",\n",
    "            \"eval_metric\" to \"rmse\"\n",
    "        )\n",
    "\n",
    "        model = XGBoost.train(trainData, params, 1000, mapOf<String, DMatrix>(), null, null)\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fff81ffc",
   "metadata": {},
   "outputs": [],
   "source": [
    "val feed = AvroFeed.sp500()\n",
    "val asset = feed.assets.getBySymbol(\"TSLA\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83fecf7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "val strategy =  XGBoostStrategy(asset, 20)\n",
    "val roboquant = Roboquant(strategy, AccountMetric())\n",
    "\n",
    "// Run the back test\n",
    "val (train, validation) = feed.timeframe.splitTrainTest(0.3)\n",
    "roboquant.run(feed, train, validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "120cfe04",
   "metadata": {},
   "outputs": [],
   "source": [
    "roboquant.broker.account.fullSummary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dea2f0b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "val equity = roboquant.logger.getMetric(\"account.equity\").filter { it.info.phase == RunPhase.VALIDATE }\n",
    "MetricChart(equity)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6ae6c47",
   "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": 5
}