06_dx_portfolio_parallel.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"http://hilpisch.com/tpq_logo.png\" alt=\"The Python Quants\" width=\"45%\" align=\"right\" border=\"4\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**CURRENTLY NOT WORKING WITH PYTHON 3.5**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parallel Valuation of Large Portfolios "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Derivatives (portfolio) valuation by Monte Carlo simulation is a **computationally demanding task**. For practical applications, when valuation speed plays an important role, **parallelization of both simulation and valuation tasks** might prove a useful strategy. DX Analytics has built in a basic parallelization option which allows the use of the Python `mulitprocessing` module. Depending on the tasks at hand this can already lead to significant speed-ups."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from dx import *\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns; sns.set()\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Single Risk Factor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The example is based on a **single risk factor**, a `geometric_brownian_motion` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# constant short rate\n",
    "r = constant_short_rate('r', 0.02)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# market environments\n",
    "me_gbm = market_environment('gbm', dt.datetime(2015, 1, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# geometric Brownian motion\n",
    "me_gbm.add_constant('initial_value', 100.)\n",
    "me_gbm.add_constant('volatility', 0.2) \n",
    "me_gbm.add_constant('currency', 'EUR')\n",
    "me_gbm.add_constant('model', 'gbm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# valuation environment\n",
    "val_env = market_environment('val_env', dt.datetime(2015, 1, 1))\n",
    "val_env.add_constant('paths', 25000)\n",
    "val_env.add_constant('frequency', 'M')\n",
    "val_env.add_curve('discount_curve', r)\n",
    "val_env.add_constant('starting_date', dt.datetime(2015, 1, 1))\n",
    "val_env.add_constant('final_date', dt.datetime(2015, 12, 31))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# add valuation environment to market environments\n",
    "me_gbm.add_environment(val_env)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "risk_factors = {'gbm' : me_gbm}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## American Put Option"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also model only a **single derivative instrument**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "gbm = geometric_brownian_motion('gbm_obj', me_gbm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "me_put = market_environment('put', dt.datetime(2015, 1, 1))\n",
    "me_put.add_constant('maturity', dt.datetime(2015, 12, 31))\n",
    "me_put.add_constant('strike', 40.)\n",
    "me_put.add_constant('currency', 'EUR')\n",
    "me_put.add_environment(val_env)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "am_put = valuation_mcs_american_single(\n",
    "                'am_put', mar_env=me_put, underlying=gbm,\n",
    "                payoff_func='np.maximum(strike - instrument_values, 0)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Large Portfolio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, the `derivatives_portfolio` object we compose consists of **100 derivatives positions**. Each option differes with respect to the strike."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "positions = {}\n",
    "strikes = np.linspace(80, 120, 100)\n",
    "for i, strike in enumerate(strikes):\n",
    "    positions[i] = derivatives_position(\n",
    "                        name='am_put_pos_%s' % strike,\n",
    "                        quantity=1,\n",
    "                        underlyings=['gbm'],\n",
    "                        mar_env=me_put,\n",
    "                        otype='American single',\n",
    "        payoff_func='np.maximum(%5.3f - instrument_values, 0)' % strike)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sequential Valuation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, the derivatives portfolio with **sequential valuation**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "port_sequ = derivatives_portfolio(\n",
    "                name='portfolio',\n",
    "                positions=positions,\n",
    "                val_env=val_env,\n",
    "                risk_factors=risk_factors,\n",
    "                correlations=None,\n",
    "                parallel=False)  # sequential calculation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The call of the `get_values` method to **value all instruments** ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "t0 = time.time()\n",
    "ress = port_sequ.get_values()\n",
    "ts = time.time() - t0\n",
    "print('Time in sec %.2f' % ts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and the **results visualized**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ress['strike'] = strikes\n",
    "ress.set_index('strike')['value'].plot(figsize=(10, 6))\n",
    "plt.ylabel('option value estimates')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parallel Valuation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Second, the derivatives portfolio with **parallel valuation**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "port_para = derivatives_portfolio(\n",
    "                'portfolio',\n",
    "                positions,\n",
    "                val_env,\n",
    "                risk_factors,\n",
    "                correlations=None,\n",
    "                parallel=True)  # parallel valuation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The call of the `get_values` method for the parall valuation case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "t0 = time.time()\n",
    "resp = port_para.get_values()\n",
    "  # parallel valuation with as many cores as available\n",
    "tp = time.time() - t0\n",
    "print('Time in sec %.2f' % tp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, the **results visualized** (and compared to the sequential results)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(strikes, resp['value'].values, 'r.', label='parallel')\n",
    "plt.plot(strikes, ress['value'].values, 'b', label='sequential')\n",
    "plt.legend(loc=0)\n",
    "plt.ylabel('option value estimates')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Speed-up"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **realized speed-up** is of course dependend on the hardware used, and in particular the number of cores (threads) available."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ts / tp\n",
    "  # speed-up factor\n",
    "  # of course harware-dependent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "wi = 0.4\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar((1.5 - wi/2, 2.5 - wi/2), (ts/ts, tp/ts), width=wi)\n",
    "plt.xticks((1.5, 2.5), ('sequential', 'parallel'))\n",
    "plt.ylim(0, 1.1), plt.xlim(0.75, 3.25)\n",
    "plt.ylabel('relative performance (lower = better)')\n",
    "plt.title('DX Analytics Portfolio Valuation')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Copyright, License & Disclaimer**\n",
    "\n",
    "&copy; Dr. Yves J. Hilpisch | The Python Quants GmbH\n",
    "\n",
    "DX Analytics (the \"dx library\") is licensed under the GNU Affero General Public License\n",
    "version 3 or later (see [http://www.gnu.org/licenses/](http://www.gnu.org/licenses/)).\n",
    "\n",
    "DX Analytics comes with no representations\n",
    "or warranties, to the extent permitted by applicable law.\n",
    "\n",
    "\n",
    "<img src=\"http://hilpisch.com/tpq_logo.png\" alt=\"The Python Quants\" width=\"35%\" align=\"right\" border=\"0\"><br>\n",
    "\n",
    "[http://tpq.io](http://tpq.io) | [team@tpq.io](mailto:team@tpq.io) | [http://twitter.com/dyjh](http://twitter.com/dyjh)\n",
    "\n",
    "**Quant Platform** |\n",
    "[http://quant-platform.com](http://quant-platform.com)\n",
    "\n",
    "**Derivatives Analytics with Python (Wiley Finance)** |\n",
    "[http://derivatives-analytics-with-python.com](http://derivatives-analytics-with-python.com)\n",
    "\n",
    "**Python for Finance (O'Reilly)** |\n",
    "[http://python-for-finance.com](http://python-for-finance.com)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda env:py3]",
   "language": "python",
   "name": "conda-env-py3-py"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}