notebooks/policies.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Policies\n",
    "This notebook shows how to create your own policy. There are two ways to do so:\n",
    "\n",
    "1. Extend the `FlexPolicy`: this approach is mostly suitable if you just require some minor changes to the default behavior, like creating different order types.\n",
    "2. Implement the `Policy` from scratch: this approach provides full flexibility on what the policy should do."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%use roboquant(1.3.0-SNAPSHOT)\n",
    "Welcome()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extending the `FlexPolicy`\n",
    "\n",
    "We're now ready to develop a \"custom policy\". For this first example we extend the `FlexPolicy` and create our own Order type by overriding the `createOrder` method. The default behavior is to create a `MarketOrder`, but we change it to a `BracketOrder`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyPolicy(val trailPercentage: Double = 0.02, val stopPercentage: Double = 0.01) : FlexPolicy() {\n",
    "    \n",
    "   \n",
    "        override fun createOrder(signal: Signal, size: Size, price: Double): Order? {\n",
    "            \n",
    "            // In this example we don't short and exit orders are covered by the initial bracket order.\n",
    "            if (size < 0) return null\n",
    "            \n",
    "            val asset = signal.asset\n",
    "      \n",
    "            return BracketOrder(\n",
    "                MarketOrder(asset, size), // Entry Order\n",
    "                TrailOrder(asset, -size, trailPercentage), // Take profit order\n",
    "                StopOrder(asset, -size, price * (1.0 - stopPercentage)) // Stop loss order\n",
    "            )\n",
    "        }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create a new roboquant and evaluate it\n",
    "We are now ready to back-test our strategy using the just created Policy. And suppose we want to find out what is the optimal percentage to use in our policy, we'll iterate over 10 values to see what results in the best solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val feed = AvroFeed.sp500()\n",
    "val strategy = EMAStrategy()\n",
    "val policy = MyPolicy()\n",
    "val roboquant =  Roboquant(strategy, AccountMetric(), policy = policy)\n",
    "roboquant.run(feed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var data = roboquant.logger.getMetric(\"account.equity\")\n",
    "MetricChart(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementing the `Policy` interface\n",
    "\n",
    "The following cell shows a very minimalistic implementation of a Policy in which BUY ratings are generating buy market orders and SELL ratings are generating sell market orders if there is an open position.\n",
    "\n",
    "NOTE: In general it is important that a Policy is very robust, especially if you intent to use it also for live trading. It means that all kind of corner cases need to be catered for. A simple implementation as the one below isn't sufficient. Have a look at the `FlexPolicy` in the roboquant GitHub repo to see a more complete implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyPolicy2 : Policy {\n",
    "    \n",
    "    // This is the only method that is required to implement and transforms incoming signals into orders \n",
    "    override public fun act(signals: List<Signal>, account: Account, event: Event): List<Order> {\n",
    "        \n",
    "        val orders = mutableListOf<Order>()\n",
    "        \n",
    "        for (signal in signals) {\n",
    "            val asset = signal.asset\n",
    "            if (signal.rating.isPositive) \n",
    "                orders.add(MarketOrder(asset, 10))\n",
    "            else if (signal.rating.isNegative && account.positions.getPosition(asset).long)\n",
    "                orders.add(MarketOrder(asset, -10))\n",
    "        }\n",
    "        \n",
    "        return orders\n",
    "    }\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val strategy = EMAStrategy()\n",
    "val policy = MyPolicy2()\n",
    "val roboquant =  Roboquant(strategy, AccountMetric(), policy = policy)\n",
    "roboquant.run(feed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "roboquant.broker.account"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var data = roboquant.logger.getMetric(\"account.equity\")\n",
    "MetricChart(data)"
   ]
  },
  {
   "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
}