From fa5e72823ef13afcbc14084873a1f955ab51c628 Mon Sep 17 00:00:00 2001 From: Bradlee Speice Date: Fri, 26 Feb 2016 14:24:27 -0500 Subject: [PATCH] Add new blog in --- .gitignore | 3 + .gitmodules | 6 + Makefile | 124 + _nb_header.html | 199 + content/articles/2015-11-14-welcome.md | 58 + content/articles/2015-11-27-autocallable.md | 20 + content/articles/2015-12-26-testing_cramer.md | 14 + .../2016-1-1-complaining-about-weather.md | 14 + .../articles/2016-1-23-cloudy-in-seattle.md | 14 + ...fitability-using-the-investment-formula.md | 14 + .../2016-2-3-guaranteed-money-maker.md | 14 + content/images/logo.svg | 246 + content/notebooks/2015-11-14-welcome.ipynb | 293 ++ .../notebooks/2015-11-27-autocallable.ipynb | 3974 +++++++++++++++++ .../notebooks/2015-12-26-testing_cramer.ipynb | 428 ++ .../2016-1-1-complaining-about-weather.ipynb | 734 +++ .../2016-1-23-cloudy-in-seattle.ipynb | 721 +++ ...ability-using-the-investment-formula.ipynb | 383 ++ .../2016-2-3-guaranteed-money-maker.ipynb | 260 ++ develop_server.sh | 103 + fabfile.py | 94 + nest | 1 + pelican-plugins | 1 + pelicanconf.py | 44 + publishconf.py | 24 + 25 files changed, 7786 insertions(+) create mode 100644 .gitignore create mode 100644 .gitmodules create mode 100644 Makefile create mode 100644 _nb_header.html create mode 100644 content/articles/2015-11-14-welcome.md create mode 100644 content/articles/2015-11-27-autocallable.md create mode 100644 content/articles/2015-12-26-testing_cramer.md create mode 100644 content/articles/2016-1-1-complaining-about-weather.md create mode 100644 content/articles/2016-1-23-cloudy-in-seattle.md create mode 100644 content/articles/2016-2-26-profitability-using-the-investment-formula.md create mode 100644 content/articles/2016-2-3-guaranteed-money-maker.md create mode 100644 content/images/logo.svg create mode 100644 content/notebooks/2015-11-14-welcome.ipynb create mode 100644 content/notebooks/2015-11-27-autocallable.ipynb create mode 100644 content/notebooks/2015-12-26-testing_cramer.ipynb create mode 100644 content/notebooks/2016-1-1-complaining-about-weather.ipynb create mode 100644 content/notebooks/2016-1-23-cloudy-in-seattle.ipynb create mode 100644 content/notebooks/2016-2-26-profitability-using-the-investment-formula.ipynb create mode 100644 content/notebooks/2016-2-3-guaranteed-money-maker.ipynb create mode 100755 develop_server.sh create mode 100644 fabfile.py create mode 160000 nest create mode 160000 pelican-plugins create mode 100644 pelicanconf.py create mode 100644 publishconf.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7968fb5 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +*.swp +*.pyc +output/ diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..a610057 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,6 @@ +[submodule "pelican-plugins"] + path = pelican-plugins + url = https://github.com/getpelican/pelican-plugins/ +[submodule "nest"] + path = nest + url = https://github.com/molivier/nest diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..7cf1029 --- /dev/null +++ b/Makefile @@ -0,0 +1,124 @@ +PY?=python +PELICAN?=pelican +PELICANOPTS= + +BASEDIR=$(CURDIR) +INPUTDIR=$(BASEDIR)/content +OUTPUTDIR=$(BASEDIR)/output +CONFFILE=$(BASEDIR)/pelicanconf.py +PUBLISHCONF=$(BASEDIR)/publishconf.py + +FTP_HOST=localhost +FTP_USER=anonymous +FTP_TARGET_DIR=/ + +SSH_HOST=localhost +SSH_PORT=22 +SSH_USER=root +SSH_TARGET_DIR=/var/www + +S3_BUCKET=my_s3_bucket + +CLOUDFILES_USERNAME=my_rackspace_username +CLOUDFILES_API_KEY=my_rackspace_api_key +CLOUDFILES_CONTAINER=my_cloudfiles_container + +DROPBOX_DIR=~/Dropbox/Public/ + +GITHUB_PAGES_BRANCH=master + +DEBUG ?= 0 +ifeq ($(DEBUG), 1) + PELICANOPTS += -D +endif + +RELATIVE ?= 0 +ifeq ($(RELATIVE), 1) + PELICANOPTS += --relative-urls +endif + +help: + @echo 'Makefile for a pelican Web site ' + @echo ' ' + @echo 'Usage: ' + @echo ' make html (re)generate the web site ' + @echo ' make clean remove the generated files ' + @echo ' make regenerate regenerate files upon modification ' + @echo ' make publish generate using production settings ' + @echo ' make serve [PORT=8000] serve site at http://localhost:8000' + @echo ' make serve-global [SERVER=0.0.0.0] serve (as root) to $(SERVER):80 ' + @echo ' make devserver [PORT=8000] start/restart develop_server.sh ' + @echo ' make stopserver stop local server ' + @echo ' make ssh_upload upload the web site via SSH ' + @echo ' make rsync_upload upload the web site via rsync+ssh ' + @echo ' make dropbox_upload upload the web site via Dropbox ' + @echo ' make ftp_upload upload the web site via FTP ' + @echo ' make s3_upload upload the web site via S3 ' + @echo ' make cf_upload upload the web site via Cloud Files' + @echo ' make github upload the web site via gh-pages ' + @echo ' ' + @echo 'Set the DEBUG variable to 1 to enable debugging, e.g. make DEBUG=1 html ' + @echo 'Set the RELATIVE variable to 1 to enable relative urls ' + @echo ' ' + +html: + $(PELICAN) $(INPUTDIR) -o $(OUTPUTDIR) -s $(CONFFILE) $(PELICANOPTS) + +clean: + [ ! -d $(OUTPUTDIR) ] || rm -rf $(OUTPUTDIR) + +regenerate: + $(PELICAN) -r $(INPUTDIR) -o $(OUTPUTDIR) -s $(CONFFILE) $(PELICANOPTS) + +serve: +ifdef PORT + cd $(OUTPUTDIR) && $(PY) -m pelican.server $(PORT) +else + cd $(OUTPUTDIR) && $(PY) -m pelican.server +endif + +serve-global: +ifdef SERVER + cd $(OUTPUTDIR) && $(PY) -m pelican.server 80 $(SERVER) +else + cd $(OUTPUTDIR) && $(PY) -m pelican.server 80 0.0.0.0 +endif + + +devserver: +ifdef PORT + $(BASEDIR)/develop_server.sh restart $(PORT) +else + $(BASEDIR)/develop_server.sh restart +endif + +stopserver: + $(BASEDIR)/develop_server.sh stop + @echo 'Stopped Pelican and SimpleHTTPServer processes running in background.' + +publish: + $(PELICAN) $(INPUTDIR) -o $(OUTPUTDIR) -s $(PUBLISHCONF) $(PELICANOPTS) + +ssh_upload: publish + scp -P $(SSH_PORT) -r $(OUTPUTDIR)/* $(SSH_USER)@$(SSH_HOST):$(SSH_TARGET_DIR) + +rsync_upload: publish + rsync -e "ssh -p $(SSH_PORT)" -P -rvzc --delete $(OUTPUTDIR)/ $(SSH_USER)@$(SSH_HOST):$(SSH_TARGET_DIR) --cvs-exclude + +dropbox_upload: publish + cp -r $(OUTPUTDIR)/* $(DROPBOX_DIR) + +ftp_upload: publish + lftp ftp://$(FTP_USER)@$(FTP_HOST) -e "mirror -R $(OUTPUTDIR) $(FTP_TARGET_DIR) ; quit" + +s3_upload: publish + s3cmd sync $(OUTPUTDIR)/ s3://$(S3_BUCKET) --acl-public --delete-removed --guess-mime-type + +cf_upload: publish + cd $(OUTPUTDIR) && swift -v -A https://auth.api.rackspacecloud.com/v1.0 -U $(CLOUDFILES_USERNAME) -K $(CLOUDFILES_API_KEY) upload -c $(CLOUDFILES_CONTAINER) . + +github: publish + ghp-import -m "Generate Pelican site" -b $(GITHUB_PAGES_BRANCH) $(OUTPUTDIR) + git push origin $(GITHUB_PAGES_BRANCH) + +.PHONY: html help clean regenerate serve serve-global devserver publish ssh_upload rsync_upload dropbox_upload ftp_upload s3_upload cf_upload github diff --git a/_nb_header.html b/_nb_header.html new file mode 100644 index 0000000..defd29d --- /dev/null +++ b/_nb_header.html @@ -0,0 +1,199 @@ + + + + + + + + + + + + + + diff --git a/content/articles/2015-11-14-welcome.md b/content/articles/2015-11-14-welcome.md new file mode 100644 index 0000000..f6892a8 --- /dev/null +++ b/content/articles/2015-11-14-welcome.md @@ -0,0 +1,58 @@ +Title: Welcome, and an algorithm +Date: 2015-11-19 +Tags: introduction, trading +Modified: 2015-12-05 +Category: Blog + + + + +Hello! Glad to meet you. I'm currently a student at Columbia University +studying Financial Engineering, and want to give an overview of the projects +I'm working on! + +To start things off, Columbia has been hosting a trading competition that +myself and another partner are competing in. I'm including a notebook of the +algorithm that we're using, just to give a simple overview of a miniature +algorithm. + +The competition is scored in 3 areas: + +- Total return +- [Sharpe ratio](1) +- Maximum drawdown + +Our algorithm uses a basic momentum strategy: in the given list of potential +portfolios, pick the stocks that have been performing well in the past 30 +days. Then, optimize for return subject to the drawdown being below a specific +level. We didn't include the Sharpe ratio as a constraint, mostly because +we were a bit late entering the competition. + +I'll be updating this post with the results of our algorithm as they come along! + +--- + +**UPDATE 12/5/2015**: Now that the competition has ended, I wanted to update +how the algorithm performed. Unfortunately, it didn't do very well. I'm planning +to make some tweaks over the coming weeks, and do another forward test in January. + +- After week 1: Down .1% +- After week 2: Down 1.4% +- After week 3: Flat + +And some statistics for all teams participating in the competition: + +| | | +|--------------------|--------| +| Max Return | 74.1% | +| Min Return | -97.4% | +| Average Return | -.1% | +| Std Dev of Returns | 19.6% | + +--- + +{% notebook 2015-11-14-welcome.ipynb %} + +[1]: https://en.wikipedia.org/wiki/Sharpe_ratio diff --git a/content/articles/2015-11-27-autocallable.md b/content/articles/2015-11-27-autocallable.md new file mode 100644 index 0000000..ad9dd9f --- /dev/null +++ b/content/articles/2015-11-27-autocallable.md @@ -0,0 +1,20 @@ +Title: Autocallable Bonds +Date: 2015-11-27 +Category: Blog +Tags: finance, simulation, monte carlo +Authors: Bradlee Speice +Summary: For a final project, my group was tasked with understanding three exotic derivatives: The Athena, Phoenix without memory, and Phoenix with memory autocallable products. +[//]: <> "Modified:" + + + + +My only non-core class this semester has been in Structure Products. We've been surveying a wide variety of products, and the final project was to pick one to report on. +Because these are all very similar, we decided to demonstrate all 3 products at once. + +What follows below is a notebook demonstrating the usage of [Julia](http://julialang.com) for Monte-Carlo simulation of some exotic products. + +{% notebook 2015-11-27-autocallable.ipynb language[julia] %} + diff --git a/content/articles/2015-12-26-testing_cramer.md b/content/articles/2015-12-26-testing_cramer.md new file mode 100644 index 0000000..39e6db0 --- /dev/null +++ b/content/articles/2015-12-26-testing_cramer.md @@ -0,0 +1,14 @@ +Title: Testing Cramer +Date: 2015-12-26 +Category: Blog +Tags: futures, data science +Authors: Bradlee Speice +Summary: +[//]: <> "Modified: " + + + + +{% notebook 2015-12-26-testing_cramer.ipynb %} diff --git a/content/articles/2016-1-1-complaining-about-weather.md b/content/articles/2016-1-1-complaining-about-weather.md new file mode 100644 index 0000000..f3ec6e5 --- /dev/null +++ b/content/articles/2016-1-1-complaining-about-weather.md @@ -0,0 +1,14 @@ +Title: Complaining about the Weather +Date: 2016-01-01 +Category: Blog +Tags: weather +Authors: Bradlee Speice +Summary: Figuring out whether people should be complaining about the recent weather in NC. +[//]: <> "Modified: " + + + + +{% notebook 2016-1-1-complaining-about-weather.ipynb %} diff --git a/content/articles/2016-1-23-cloudy-in-seattle.md b/content/articles/2016-1-23-cloudy-in-seattle.md new file mode 100644 index 0000000..167ac41 --- /dev/null +++ b/content/articles/2016-1-23-cloudy-in-seattle.md @@ -0,0 +1,14 @@ +Title: Cloudy in Seattle +Date: 2016-01-23 +Category: Blog +Tags: weather, data science +Authors: Bradlee Speice +Summary: Building on prior analysis, is Seattle's reputation as a depressing city actually well-earned? +[//]: <> "Modified: " + + + + +{% notebook 2016-1-23-cloudy-in-seattle.ipynb %} diff --git a/content/articles/2016-2-26-profitability-using-the-investment-formula.md b/content/articles/2016-2-26-profitability-using-the-investment-formula.md new file mode 100644 index 0000000..fe20f27 --- /dev/null +++ b/content/articles/2016-2-26-profitability-using-the-investment-formula.md @@ -0,0 +1,14 @@ +Title: Profitability using the Investment Formula +Date: 2016-02-26 +Category: Blog +Tags: algorithmic-trading, python +Authors: Bradlee Speice +Summary: After developing a formula to guide our investing, how do we actually evaluate its performance in the real world? +[//]: <> "Modified: " + + + + +{% notebook 2016-2-26-profitability-using-the-investment-formula.ipynb %} diff --git a/content/articles/2016-2-3-guaranteed-money-maker.md b/content/articles/2016-2-3-guaranteed-money-maker.md new file mode 100644 index 0000000..a2e0227 --- /dev/null +++ b/content/articles/2016-2-3-guaranteed-money-maker.md @@ -0,0 +1,14 @@ +Title: Guaranteed Money Maker +Date: 2016-02-03 +Category: Blog +Tags: martingale, strategy +Authors: Bradlee Speice +Summary: Developing an investment strategy based on the Martingale betting strategy +[//]: <> "Modified: " + + + + +{% notebook 2016-2-3-guaranteed-money-maker.ipynb %} diff --git a/content/images/logo.svg b/content/images/logo.svg new file mode 100644 index 0000000..def0f38 --- /dev/null +++ b/content/images/logo.svg @@ -0,0 +1,246 @@ + + + + + + image/svg+xml + + + + + + + + + + Layer 1 + + $ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/content/notebooks/2015-11-14-welcome.ipynb b/content/notebooks/2015-11-14-welcome.ipynb new file mode 100644 index 0000000..2fab0a3 --- /dev/null +++ b/content/notebooks/2015-11-14-welcome.ipynb @@ -0,0 +1,293 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Trading Competition Optimization\n", + "\n", + "### Goal: Max return given maximum Sharpe and Drawdown" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from IPython.display import display\n", + "import Quandl\n", + "from datetime import datetime, timedelta\n", + "\n", + "tickers = ['XOM', 'CVX', 'CLB', 'OXY', 'SLB']\n", + "market_ticker = 'GOOG/NYSE_VOO'\n", + "lookback = 30\n", + "d_col = 'Close'\n", + "\n", + "data = {tick: Quandl.get('YAHOO/{}'.format(tick))[-lookback:] for tick in tickers}\n", + "market = Quandl.get(market_ticker)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Calculating the Return\n", + "We first want to know how much each ticker returned over the prior period." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'CLB': -0.0016320202164526894,\n", + " 'CVX': 0.0010319531629488911,\n", + " 'OXY': 0.00093418904454400551,\n", + " 'SLB': 0.00098431254720448159,\n", + " 'XOM': 0.00044165797556096868}" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "returns = {tick: data[tick][d_col].pct_change() for tick in tickers}\n", + "\n", + "display({tick: returns[tick].mean() for tick in tickers})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Calculating the Sharpe ratio\n", + "Sharpe: ${R - R_M \\over \\sigma}$\n", + "\n", + "We use the average return over the lookback period, minus the market average return, over the ticker standard deviation to calculate the Sharpe. Shorting a stock turns a negative Sharpe positive." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'CLB': -0.10578734457846127,\n", + " 'CVX': 0.027303529817677398,\n", + " 'OXY': 0.022622210057414487,\n", + " 'SLB': 0.026950946344858676,\n", + " 'XOM': -0.0053519259698605499}" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "market_returns = market.pct_change()\n", + "\n", + "sharpe = lambda ret: (ret.mean() - market_returns[d_col].mean()) / ret.std()\n", + "sharpes = {tick: sharpe(returns[tick]) for tick in tickers}\n", + "\n", + "display(sharpes)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Calculating the drawdown\n", + "This one is easy - what is the maximum daily change over the lookback period? That is, because we will allow short positions, we are not concerned strictly with maximum downturn, but in general, what is the largest 1-day change?" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'CLB': 0.043551495607375035,\n", + " 'CVX': 0.044894389686214398,\n", + " 'OXY': 0.051424517867144637,\n", + " 'SLB': 0.034774627850375328,\n", + " 'XOM': 0.035851524605672758}" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "drawdown = lambda ret: ret.abs().max()\n", + "drawdowns = {tick: drawdown(returns[tick]) for tick in tickers}\n", + "\n", + "display(drawdowns)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Performing the optimization\n", + "\n", + "$\\begin{align}\n", + "max\\ \\ & \\mu \\cdot \\omega\\\\\n", + "s.t.\\ \\ & \\vec{1} \\omega = 1\\\\\n", + "& \\vec{S} \\omega \\ge s\\\\\n", + "& \\vec{D} \\cdot | \\omega | \\le d\\\\\n", + "& \\left|\\omega\\right| \\le l\\\\\n", + "\\end{align}$\n", + "\n", + "We want to maximize average return subject to having a full portfolio, Sharpe above a specific level, drawdown below a level, and leverage not too high - that is, don't have huge long/short positions." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'Optimization terminated successfully.'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "\"Holdings: [('XOM', 5.8337945679814904), ('CVX', 42.935064321851307), ('CLB', -124.5), ('OXY', 36.790387773552119), ('SLB', 39.940753336615096)]\"" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'Expected Return: 32.375%'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'Expected Max Drawdown: 4.34%'" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from scipy.optimize import minimize\n", + "\n", + "#sharpe_limit = .1\n", + "drawdown_limit = .05\n", + "leverage = 250\n", + "\n", + "# Use the map so we can guarantee we maintain the correct order\n", + "# sharpe_a = np.array(list(map(lambda tick: sharpes[tick], tickers))) * -1 # So we can write as upper-bound\n", + "dd_a = np.array(list(map(lambda tick: drawdowns[tick], tickers)))\n", + "returns_a = np.array(list(map(lambda tick: returns[tick].mean(), tickers))) # Because minimizing\n", + "\n", + "meets_sharpe = lambda x: sum(abs(x) * sharpe_a) - sharpe_limit\n", + "def meets_dd(x):\n", + " portfolio = sum(abs(x))\n", + " if portfolio < .1:\n", + " # If there are no stocks in the portfolio,\n", + " # we can accidentally induce division by 0,\n", + " # or division by something small enough to cause infinity\n", + " return 0\n", + " \n", + " return drawdown_limit - sum(abs(x) * dd_a) / sum(abs(x))\n", + "\n", + "is_portfolio = lambda x: sum(x) - 1\n", + "\n", + "def within_leverage(x):\n", + " return leverage - sum(abs(x))\n", + "\n", + "objective = lambda x: sum(x * returns_a) * -1 # Because we're minimizing\n", + "bounds = ((None, None),) * len(tickers)\n", + "x = np.zeros(len(tickers))\n", + "\n", + "constraints = [\n", + " {\n", + " 'type': 'eq',\n", + " 'fun': is_portfolio\n", + " }, {\n", + " 'type': 'ineq',\n", + " 'fun': within_leverage\n", + " #}, {\n", + " # 'type': 'ineq',\n", + " # 'fun': meets_sharpe\n", + " }, {\n", + " 'type': 'ineq',\n", + " 'fun': meets_dd\n", + " }\n", + "]\n", + "\n", + "optimal = minimize(objective, x, bounds=bounds, constraints=constraints,\n", + " options={'maxiter': 500})\n", + "\n", + "# Optimization time!\n", + "display(optimal.message)\n", + "\n", + "display(\"Holdings: {}\".format(list(zip(tickers, optimal.x))))\n", + "\n", + "expected_return = optimal.fun * -100 # multiply by -100 to scale, and compensate for minimizing\n", + "display(\"Expected Return: {:.3f}%\".format(expected_return))\n", + "\n", + "expected_drawdown = sum(abs(optimal.x) * dd_a) / sum(abs(optimal.x)) * 100\n", + "display(\"Expected Max Drawdown: {0:.2f}%\".format(expected_drawdown))\n", + "\n", + "# TODO: Calculate expected Sharpe" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.5.0" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/content/notebooks/2015-11-27-autocallable.ipynb b/content/notebooks/2015-11-27-autocallable.ipynb new file mode 100644 index 0000000..8e4038b --- /dev/null +++ b/content/notebooks/2015-11-27-autocallable.ipynb @@ -0,0 +1,3974 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "using Gadfly" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Athena/Phoenix Simulation\n", + "\n", + "## Underlying simulation\n", + "\n", + "In order to price the autocallable bonds, we need to simulate the underlying assets. Let's go ahead and set up the simulation first, as this lays the foundation for what we're trying to do. We're going to use [JNJ](http://finance.yahoo.com/q?s=jnj) as the basis for our simulation. This implies the following parameters:\n", + "\n", + "- $S_0$ = \\$102.2 (as of time of writing)\n", + "- $q$ = 2.84%\n", + "- $r$ = [.49, .9, 1.21, 1.45, 1.69] (term structure as of time of writing, linear interpolation)\n", + "- $\\mu$ = $r - q$ (note that this implies a negative drift because of current low rates)\n", + "- $\\sigma$ = $\\sigma_{imp}$ = 15.62% (from VIX implied volatility)\n", + "\n", + "We additionally define some parameters for simulation:\n", + "\n", + "- `T`: The number of years to simulate\n", + "- `m`: The number of paths to simulate\n", + "- `n`: The number of steps to simulate in a year" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "S0 = 102.2\n", + "nominal = 100\n", + "q = 2.84 / 100\n", + "σ = 15.37 / 100\n", + "term = [0, .49, .9, 1.21, 1.45, 1.69] / 100 + 1\n", + "\n", + "###\n", + "# Potential: Based on PEP\n", + "# S0 = 100.6\n", + "# σ = 14.86\n", + "# q = 2.7\n", + "###\n", + "\n", + "# Simulation parameters\n", + "T = 5 # Using years as the unit of time\n", + "n = 250 # simulations per year\n", + "m = 100000 # paths\n", + "num_simulations = 5; # simulation rounds per price" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining the simulation\n", + "To make things simpler, we simulate a single year at a time. This allows us to easily add in a dividend policy without too much difficulty, and update the simulation every year to match the term structure. The underlying uses GBM for simulation between years." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "simulate_gbm = function(S0, μ, σ, T, n)\n", + " # Set the initial state\n", + " m = length(S0)\n", + " t = T / n\n", + " motion = zeros(m, n)\n", + " motion[:,1] = S0\n", + " \n", + " # Build out all states\n", + " for i=1:(n-1)\n", + " motion[:,i+1] = motion[:,i] .* exp((μ - σ^2/2)*t) .* exp(sqrt(t) * σ .* randn(m))\n", + " end\n", + " \n", + " return motion\n", + "end\n", + "\n", + "function display_motion(motion, T)\n", + " # Given a matrix of paths, display the motion\n", + " n = length(motion[1,:])\n", + " m = length(motion[:,1])\n", + " x = repmat(1:n, m)\n", + " \n", + " # Calculate the ticks we're going to use. We'd like to\n", + " # have an xtick every month, so calculate where those\n", + " # ticks will actually be at.\n", + " if (T > 3)\n", + " num_ticks = T\n", + " xlabel = \"Years\"\n", + " else\n", + " num_ticks = T * 12\n", + " xlabel = \"Months\"\n", + " end\n", + " tick_width = n / num_ticks\n", + " x_ticks = []\n", + " for i=1:round(num_ticks)\n", + " x_ticks = vcat(x_ticks, i*tick_width)\n", + " end\n", + " \n", + " # Use one color for each path. I'm not sure if there's\n", + " # a better way to do this without going through DataFrames\n", + " colors = []\n", + " for i = 1:m\n", + " colors = vcat(colors, ones(n)*i)\n", + " end\n", + " \n", + " plot(x=x, y=motion', color=colors, Geom.line,\n", + " Guide.xticks(ticks=x_ticks, label=false),\n", + " Guide.xlabel(xlabel),\n", + " Guide.ylabel(\"Value\"))\n", + "end;" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example simulation\n", + "\n", + "Let's go ahead and run a sample simulation to see what the functions got us!" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " Months\n", + " \n", + " \n", + " \n", + " 1\n", + " 5\n", + " 2\n", + " 3\n", + " 4\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Color\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 95\n", + " 100\n", + " 105\n", + " 110\n", + " 115\n", + " 120\n", + " \n", + " \n", + " Value\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " Months\n", + " \n", + " \n", + " \n", + " 1\n", + " 5\n", + " 2\n", + " 3\n", + " 4\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Color\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 65\n", + " 70\n", + " 75\n", + " 80\n", + " 85\n", + " 90\n", + " 95\n", + " 100\n", + " 105\n", + " 110\n", + " 115\n", + " 120\n", + " 125\n", + " 130\n", + " 135\n", + " 140\n", + " 145\n", + " 150\n", + " 70\n", + " 71\n", + " 72\n", + " 73\n", + " 74\n", + " 75\n", + " 76\n", + " 77\n", + " 78\n", + " 79\n", + " 80\n", + " 81\n", + " 82\n", + " 83\n", + " 84\n", + " 85\n", + " 86\n", + " 87\n", + " 88\n", + " 89\n", + " 90\n", + " 91\n", + " 92\n", + " 93\n", + " 94\n", + " 95\n", + " 96\n", + " 97\n", + " 98\n", + " 99\n", + " 100\n", + " 101\n", + " 102\n", + " 103\n", + " 104\n", + " 105\n", + " 106\n", + " 107\n", + " 108\n", + " 109\n", + " 110\n", + " 111\n", + " 112\n", + " 113\n", + " 114\n", + " 115\n", + " 116\n", + " 117\n", + " 118\n", + " 119\n", + " 120\n", + " 121\n", + " 122\n", + " 123\n", + " 124\n", + " 125\n", + " 126\n", + " 127\n", + " 128\n", + " 129\n", + " 130\n", + " 131\n", + " 132\n", + " 133\n", + " 134\n", + " 135\n", + " 136\n", + " 137\n", + " 138\n", + " 139\n", + " 140\n", + " 141\n", + " 142\n", + " 143\n", + " 144\n", + " 145\n", + " 50\n", + " 100\n", + " 150\n", + " 70\n", + " 72\n", + " 74\n", + " 76\n", + " 78\n", + " 80\n", + " 82\n", + " 84\n", + " 86\n", + " 88\n", + " 90\n", + " 92\n", + " 94\n", + " 96\n", + " 98\n", + " 100\n", + " 102\n", + " 104\n", + " 106\n", + " 108\n", + " 110\n", + " 112\n", + " 114\n", + " 116\n", + " 118\n", + " 120\n", + " 122\n", + " 124\n", + " 126\n", + " 128\n", + " 130\n", + " 132\n", + " 134\n", + " 136\n", + " 138\n", + " 140\n", + " 142\n", + " 144\n", + " 146\n", + " \n", + " \n", + " Value\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Plot(...)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "initial = ones(5) * S0\n", + "# Using μ=0, T=.25 for now, we'll use the proper values later\n", + "motion = simulate_gbm(initial, 0, σ, .25, 200) \n", + "\n", + "display_motion(motion, .25)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Computing the term structure\n", + "\n", + "Now that we've got the basic motion set up, let's start making things a bit more sophisticated for the model. We're going to assume that the drift of the stock is the difference between the implied forward rate and the quarterly dividend rate.\n", + "\n", + "We're given the yearly term structure, and need to calculate the quarterly forward rate to match this structure. The term structure is assumed to follow:\n", + "\n", + "$d(0, t) = d(0,t-1)\\cdot f_{i-1, i}$\n", + "\n", + "Where $f_{i-1, i}$ is the quarterly forward rate." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "forward_term = function(yearly_term)\n", + " # It is assumed that we have a yearly term structure passed in, and starts at year 0\n", + " # This implies a nominal rate above 0 for the first year!\n", + " years = length(term)-1 # because we start at 0\n", + " structure = [(term[i+1] / term[i]) for i=1:years]\n", + "end;" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Illustrating the term structure\n", + "\n", + "Now that we've got our term structure, let's validate that we're getting the correct results! If we've done this correctly, then:\n", + "\n", + "```\n", + "term[2] == term[1] * structure[1]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual term[2]: 1.0049; Calculated term[2]: 1.0049\n" + ] + } + ], + "source": [ + "# Example term structure taken from:\n", + "# http://www.treasury.gov/resource-center/data-chart-center/interest-rates/Pages/TextView.aspx?data=yield\n", + "# Linear interpolation used years in-between periods, assuming real-dollar\n", + "# interest rates\n", + "forward_yield = forward_term(term)\n", + "calculated_term2 = term[1] * forward_yield[1]\n", + "\n", + "println(\"Actual term[2]: $(term[2]); Calculated term[2]: $(calculated_term2)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The full underlying simulation\n", + "\n", + "Now that we have the term structure set up, we can actually start doing some real simulation! Let's construct some paths through the full 5-year time frame. In order to do this, we will simulate 1 year at a time, and use the forward rates at those times to compute the drift. Thus, there will be 5 total simulations batched together." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " Years\n", + " \n", + " \n", + " \n", + " 1\n", + " 5\n", + " 2\n", + " 3\n", + " 4\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Color\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " 50\n", + " 100\n", + " 150\n", + " 200\n", + " \n", + " \n", + " Value\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " Years\n", + " \n", + " \n", + " \n", + " 1\n", + " 5\n", + " 2\n", + " 3\n", + " 4\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Color\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -250\n", + " -200\n", + " -150\n", + " -100\n", + " -50\n", + " 0\n", + " 50\n", + " 100\n", + " 150\n", + " 200\n", + " 250\n", + " 300\n", + " 350\n", + " 400\n", + " 450\n", + " -200\n", + " -190\n", + " -180\n", + " -170\n", + " -160\n", + " -150\n", + " -140\n", + " -130\n", + " -120\n", + " -110\n", + " -100\n", + " -90\n", + " -80\n", + " -70\n", + " -60\n", + " -50\n", + " -40\n", + " -30\n", + " -20\n", + " -10\n", + " 0\n", + " 10\n", + " 20\n", + " 30\n", + " 40\n", + " 50\n", + " 60\n", + " 70\n", + " 80\n", + " 90\n", + " 100\n", + " 110\n", + " 120\n", + " 130\n", + " 140\n", + " 150\n", + " 160\n", + " 170\n", + " 180\n", + " 190\n", + " 200\n", + " 210\n", + " 220\n", + " 230\n", + " 240\n", + " 250\n", + " 260\n", + " 270\n", + " 280\n", + " 290\n", + " 300\n", + " 310\n", + " 320\n", + " 330\n", + " 340\n", + " 350\n", + " 360\n", + " 370\n", + " 380\n", + " 390\n", + " 400\n", + " -200\n", + " 0\n", + " 200\n", + " 400\n", + " -200\n", + " -180\n", + " -160\n", + " -140\n", + " -120\n", + " -100\n", + " -80\n", + " -60\n", + " -40\n", + " -20\n", + " 0\n", + " 20\n", + " 40\n", + " 60\n", + " 80\n", + " 100\n", + " 120\n", + " 140\n", + " 160\n", + " 180\n", + " 200\n", + " 220\n", + " 240\n", + " 260\n", + " 280\n", + " 300\n", + " 320\n", + " 340\n", + " 360\n", + " 380\n", + " 400\n", + " \n", + " \n", + " Value\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Plot(...)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "full_motion = ones(5) * S0\n", + "full_term = vcat(term[1], forward_yield)\n", + "for i=1:T\n", + " μ = (full_term[i] - 1 - q)\n", + " year_motion = simulate_gbm(full_motion[:,end], μ, σ, 1, n)\n", + " full_motion = hcat(full_motion, year_motion)\n", + "end\n", + "\n", + "display_motion(full_motion, T)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Final simulation\n", + "\n", + "We're now going to actually build out the full motion that we'll use for computing the pricing of our autocallable products. It will be largely the same, but we will use far more sample paths for the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time to run simulation: 5.34s" + ] + } + ], + "source": [ + "full_simulation = function(S0, T, n, m, term)\n", + " forward = vcat(term[1], forward_term(term))\n", + "\n", + " # And an S0 to kick things off.\n", + " final_motion = ones(m) * S0\n", + " for i=1:T\n", + " μ = (forward[i] - 1 - q)\n", + " year_motion = simulate_gbm(final_motion[:,end], μ, σ, 1, n)\n", + " final_motion = hcat(final_motion, year_motion)\n", + " end\n", + " return final_motion\n", + "end\n", + "\n", + "tic()\n", + "full_simulation(S0, T, n, m, term)\n", + "time = toq()\n", + "@printf(\"Time to run simulation: %.2fs\", time)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Athena Simulation\n", + "\n", + "Now that we've defined our underlying simulation, let's actually try and price an Athena note. Athena has the following characteristics:\n", + "\n", + "- Automatically called if the underlying is above the **call barrier** at observation\n", + "- Accelerated coupon paid if the underlying is above the **call barrier** at observation\n", + " - The coupon paid is $c \\cdot i$ with $i$ as the current year, and $c$ the coupon rate\n", + "- Principle protection up until a **protection barrier** at observation; All principle at risk if this barrier not met\n", + "- Observed yearly" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean of simulation 1: $103.2805; Simulation time: 5.59s\n", + "Mean of simulation 2: $103.3796; Simulation time: 5.05s\n", + "Mean of simulation 3: $103.4752; Simulation time: 5.18s\n", + "Mean of simulation 4: $103.4099; Simulation time: 5.37s\n", + "Mean of simulation 5: $103.3260; Simulation time: 5.32s\n", + "Mean over 5 simulations: 103.37421610015554\n", + "Present value of Athena note: $95.00, notional: $100.00" + ] + } + ], + "source": [ + "call_barrier = S0\n", + "strike = S0\n", + "protection_barrier = S0 * .6\n", + "coupon = nominal * .07\n", + "\n", + "price_athena = function(initial_price, year_prices, call_barrier,\n", + " protection_barrier, coupon, forward_structure)\n", + "\n", + " total_coupons = 0\n", + " \n", + " t = length(year_prices)\n", + "\n", + " for i=1:t\n", + " price = year_prices[i]\n", + " if price ≥ call_barrier\n", + " return (nominal + coupon*i) * exp((prod(forward_structure[i:end])-1)*(t-i))\n", + " end\n", + " end\n", + "\n", + " # We've reached maturity, time to check capital protection\n", + " if year_prices[end] > protection_barrier\n", + " return nominal\n", + " else\n", + " put = (strike - year_prices[end]) / strike\n", + " return nominal*(1-put)\n", + " end\n", + "end\n", + "\n", + "forward_structure = forward_term(term)\n", + "price_function = (year_prices) -> price_athena(S0, year_prices,\n", + " call_barrier, protection_barrier, coupon, forward_structure)\n", + "\n", + "athena = function()\n", + " year_indexes = [n*i for i=1:T]\n", + " motion = full_simulation(S0, T, n, m, term)\n", + " payoffs = [price_function(motion[i, year_indexes]) for i=1:m]\n", + " return mean(payoffs)\n", + "end\n", + "\n", + "mean_payoffs = zeros(num_simulations)\n", + "for i=1:num_simulations\n", + " tic()\n", + " mean_payoffs[i] = athena()\n", + " time = toq()\n", + " @printf(\"Mean of simulation %i: \\$%.4f; Simulation time: %.2fs\\n\", i, mean_payoffs[i], time)\n", + "end\n", + "\n", + "final_mean = mean(mean_payoffs)\n", + "println(\"Mean over $num_simulations simulations: $(mean(mean_payoffs))\")\n", + "pv = final_mean * (exp(-(prod(forward_structure)-1)*T))\n", + "@printf(\"Present value of Athena note: \\$%.2f, notional: \\$%.2f\", pv, nominal)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Phoenix without Memory Simulation\n", + "\n", + "Let's move into pricing a Phoenix without memory. It's very similar to the Athena production, with the exception that we introduce a coupon barrier so coupons are paid even when the underlying is below the initial price.\n", + "\n", + "The Phoenix product has the following characteristics (example [here](https://www.rbccm.com/usstructurednotes/file-780079.pdf)):\n", + "\n", + "- Automatically called if the underlying is above the **call barrier** at observation\n", + "- Coupon paid if the underlying is above a **coupon barrier** at observation\n", + "- Principle protection up until a **protection barrier** at observation; All principle at risk if this barrier not met\n", + "- Observed yearly\n", + "\n", + "Some example paths (all assume that a call barrier of the current price, and coupon barrier some level below that):\n", + "\n", + "- At the end of year 1, the stock is above the call barrier; the note is called and you receive the value of the stock plus the coupon being paid.\n", + "- At the end of year 1, the stock is above the coupon barrier, but not the call barrier; you receive the coupon. At the end of year 2, the stock is below the coupon barrier; you receive nothing. At the end of year 3, the stock is above the call barrier; the note is called and you receive the value of the stock plus a coupon for year 3.\n", + "\n", + "We're going to re-use the same simulation, with the following parameters:\n", + "\n", + "- Call barrier: 100%\n", + "- Coupon barrier: 70%\n", + "- Coupon: 6%\n", + "- Capital protection until 70% (at maturity)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean of simulation 1: $106.0562; Simulation time: 5.72s\n", + "Mean of simulation 2: $106.0071; Simulation time: 5.85s\n", + "Mean of simulation 3: $105.9959; Simulation time: 5.87s\n", + "Mean of simulation 4: $106.0665; Simulation time: 5.93s\n", + "Mean of simulation 5: $106.0168; Simulation time: 5.81s\n", + "Mean over 5 simulations: 106.02850857209883\n", + "Present value of Phoenix without memory note: $97.44" + ] + } + ], + "source": [ + "call_barrier = S0\n", + "coupon_barrier = S0 * .8\n", + "protection_barrier = S0 * .6\n", + "coupon = nominal * .06\n", + "\n", + "price_phoenix_no_memory = function(initial_price, year_prices, call_barrier, coupon_barrier,\n", + " protection_barrier, coupon, forward_structure)\n", + "\n", + " total_coupons = 0\n", + " t = length(year_prices)\n", + "\n", + " for i=1:t\n", + " price = year_prices[i]\n", + " if price ≥ call_barrier\n", + " return (nominal + coupon + total_coupons)*exp((prod(forward_structure[i:end])-1)*(t-i))\n", + " elseif price ≥ coupon_barrier\n", + " total_coupons = total_coupons * exp(forward_structure[i]-1) + coupon\n", + " else\n", + " total_coupons *= exp(forward_structure[i]-1)\n", + " end\n", + " end\n", + "\n", + " # We've reached maturity, time to check capital protection\n", + " if year_prices[end] > protection_barrier\n", + " return nominal + total_coupons\n", + " else\n", + " put = (strike - year_prices[end]) / strike\n", + " return nominal*(1-put)\n", + " end\n", + "end\n", + "\n", + "forward_structure = forward_term(term)\n", + "price_function = (year_prices) -> price_phoenix_no_memory(S0, year_prices,\n", + " call_barrier, coupon_barrier, protection_barrier, coupon, forward_structure)\n", + "\n", + "phoenix_no_memory = function()\n", + " year_indexes = [n*i for i=1:T]\n", + " motion = full_simulation(S0, T, n, m, term)\n", + " payoffs = [price_function(motion[i, year_indexes]) for i=1:m]\n", + " return mean(payoffs)\n", + "end\n", + "\n", + "mean_payoffs = zeros(num_simulations)\n", + "for i=1:num_simulations\n", + " tic()\n", + " mean_payoffs[i] = phoenix_no_memory()\n", + " time = toq()\n", + " @printf(\"Mean of simulation %i: \\$%.4f; Simulation time: %.2fs\\n\", i, mean_payoffs[i], time)\n", + "end\n", + "\n", + "final_mean = mean(mean_payoffs)\n", + "println(\"Mean over $num_simulations simulations: $(mean(mean_payoffs))\")\n", + "pv = final_mean * exp(-(prod(forward_structure)-1)*(T))\n", + "@printf(\"Present value of Phoenix without memory note: \\$%.2f\", pv)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Phoenix with Memory Simulation\n", + "\n", + "The Phoenix with Memory structure is very similar to the Phoenix, but as the name implies, has a special \"memory\" property: **It remembers any coupons that haven't been paid at prior observation times, and pays them all if the underlying crosses the coupon barrier**. For example:\n", + "- Note issued with 100% call barrier, 70% coupon barrier. At year 1, the underlying is at 50%, so no coupons are paid. At year 2, the underlying is at 80%, so coupons for both year 1 and 2 are paid, resulting in a double coupon.\n", + "\n", + "You can also find an example [here](https://www.rbccm.com/usstructurednotes/file-781232.pdf).\n", + "\n", + "Let's go ahead and set up the simulation! The parameters will be the same, but we can expect that the value will go up because of the memory attribute" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean of simulation 1: $108.8612; Simulation time: 5.89s\n", + "Mean of simulation 2: $109.0226; Simulation time: 5.90s\n", + "Mean of simulation 3: $108.9175; Simulation time: 5.92s\n", + "Mean of simulation 4: $108.9426; Simulation time: 5.94s\n", + "Mean of simulation 5: $108.8087; Simulation time: 6.06s\n", + "Mean over 5 simulations: 108.91052564051816\n", + "Present value of Phoenix with memory note: $100.09" + ] + } + ], + "source": [ + "call_barrier = S0\n", + "coupon_barrier = S0 * .8\n", + "protection_barrier = S0 * .6\n", + "coupon = nominal * .07\n", + "\n", + "price_phoenix_with_memory = function(initial_price, year_prices, call_barrier,\n", + " coupon_barrier, protection_barrier, coupon, forward_structure)\n", + "\n", + " last_coupon = 0\n", + " total_coupons = 0\n", + " \n", + " t = length(year_prices)\n", + "\n", + " for i=1:t\n", + " price = year_prices[i]\n", + " if price > call_barrier\n", + " return (nominal + coupon + total_coupons)*exp((prod(forward_structure[i:end])-1)*(t-i))\n", + " elseif price > coupon_barrier\n", + " ####################################################################\n", + " # The only difference between with/without memory is the below lines\n", + " memory_coupons = (i - last_coupon) * coupon\n", + " last_coupon = i\n", + " total_coupons = total_coupons * exp(forward_structure[i]-1) + memory_coupons\n", + " ####################################################################\n", + " else\n", + " total_coupons *= exp(forward_structure[i]-1)\n", + " end\n", + " end\n", + "\n", + " # We've reached maturity, time to check capital protection\n", + " if year_prices[end] > protection_barrier\n", + " return nominal + total_coupons\n", + " else\n", + " put = (strike - year_prices[end]) / strike\n", + " return nominal*(1-put)\n", + " end\n", + "end\n", + "\n", + "forward_structure = forward_term(term)\n", + "price_function = (year_prices) -> price_phoenix_with_memory(S0, year_prices,\n", + " call_barrier, coupon_barrier, protection_barrier, coupon, forward_structure)\n", + "\n", + "phoenix_with_memory = function()\n", + " year_indexes = [n*i for i=1:T]\n", + " motion = full_simulation(S0, T, n, m, term)\n", + " payoffs = [price_function(motion[i, year_indexes]) for i=1:m]\n", + " return mean(payoffs)\n", + "end\n", + "\n", + "mean_payoffs = zeros(num_simulations)\n", + "for i=1:num_simulations\n", + " tic()\n", + " mean_payoffs[i] = phoenix_with_memory()\n", + " time = toq()\n", + " @printf(\"Mean of simulation %i: \\$%.4f; Simulation time: %.2fs\\n\",\n", + " i, mean_payoffs[i], time)\n", + "end\n", + "\n", + "final_mean = mean(mean_payoffs)\n", + "println(\"Mean over $num_simulations simulations: $(mean(mean_payoffs))\")\n", + "pv = final_mean * exp(-(prod(forward_structure)-1)*(T))\n", + "@printf(\"Present value of Phoenix with memory note: \\$%.2f\", pv)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 0.4.0", + "language": "julia", + "name": "julia-0.4" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "0.4.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/content/notebooks/2015-12-26-testing_cramer.ipynb b/content/notebooks/2015-12-26-testing_cramer.ipynb new file mode 100644 index 0000000..02a7b5b --- /dev/null +++ b/content/notebooks/2015-12-26-testing_cramer.ipynb @@ -0,0 +1,428 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import requests\n", + "import pandas as pd\n", + "import numpy as np\n", + "from dateutil import parser as dtparser\n", + "from dateutil.relativedelta import relativedelta\n", + "from datetime import datetime\n", + "from html.parser import HTMLParser\n", + "from copy import copy\n", + "import Quandl" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Testing Cramer\n", + "\n", + "Pursuant to attending a graduate school studying Financial Engineering, I've been a fan of the [Mad Money][3] TV show featuring the bombastic Jim Cramer. One of the things that he's said is that you shouldn't use the futures to predict where the stock market is going to go. But he says it often enough, I've begun to wonder - who is he trying to convince?\n", + "\n", + "It makes sense that because futures on things like the S&P 500 are traded continuously, they would price in market information before the stock market opens. So is Cramer right to be convinced that strategies based on the futures are a poor idea? I wanted to test it out.\n", + "\n", + "The first question is where to get the future's data. I've been part of [Seeking Alpha][2] for a bit, and they publish the [Wall Street Breakfast][3] newsletter which contains daily future's returns as of 6:20 AM EST. I'd be interested in using that data to see if we can actually make some money.\n", + "\n", + "First though, let's get the data:\n", + "\n", + "# Downloading Futures data from Seeking Alpha\n", + "\n", + "We're going to define two HTML parsing classes - one to get the article URL's from a page, and one to get the actual data from each article.\n", + "\n", + "[1]: http://www.cnbc.com/mad-money/\n", + "[2]: http://seekingalpha.com/\n", + "[3]: http://seekingalpha.com/author/wall-street-breakfast?s=wall-street-breakfast" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "class ArticleListParser(HTMLParser):\n", + " \"\"\"Given a web page with articles on it, parse out the article links\"\"\"\n", + " \n", + " articles = []\n", + " \n", + " def handle_starttag(self, tag, attrs):\n", + " #if tag == 'div' and (\"id\", \"author_articles_wrapper\") in attrs:\n", + " # self.fetch_links = True\n", + " if tag == 'a' and ('class', 'dashboard_article_link') in attrs:\n", + " href = list(filter(lambda x: x[0] == 'href', attrs))[0][1]\n", + " self.articles.append(href)\n", + " \n", + "base_url = \"http://seekingalpha.com/author/wall-street-breakfast/articles\"\n", + "article_page_urls = [base_url] + [base_url + '/{}'.format(i) for i in range(2, 20)]\n", + "\n", + "global_articles = []\n", + "for page in article_page_urls:\n", + " # We need to switch the user agent, as SA blocks the standard requests agent\n", + " articles_html = requests.get(page,\n", + " headers={\"User-Agent\": \"Wget/1.13.4\"})\n", + " parser = ArticleListParser()\n", + " parser.feed(articles_html.text)\n", + " global_articles += (parser.articles)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [], + "source": [ + "class ArticleReturnParser(HTMLParser):\n", + " \"Given an article, parse out the futures returns in it\"\n", + " \n", + " record_font_tags = False\n", + " in_font_tag = False\n", + " counter = 0\n", + " # data = {} # See __init__\n", + " \n", + " def __init__(self, *args, **kwargs):\n", + " super().__init__(*args, **kwargs)\n", + " self.data = {}\n", + " \n", + " def handle_starttag(self, tag, attrs):\n", + " if tag == 'span' and ('itemprop', 'datePublished') in attrs:\n", + " date_string = list(filter(lambda x: x[0] == 'content', attrs))[0][1]\n", + " date = dtparser.parse(date_string)\n", + " self.data['date'] = date\n", + " \n", + " self.in_font_tag = tag == 'font'\n", + " \n", + " def safe_float(self, string):\n", + " try:\n", + " return float(string[:-1]) / 100\n", + " except ValueError:\n", + " return np.NaN\n", + " \n", + " def handle_data(self, content):\n", + " if not self.record_font_tags and \"Futures at 6\" in content:\n", + " self.record_font_tags = True\n", + " \n", + " if self.record_font_tags and self.in_font_tag:\n", + " if self.counter == 0:\n", + " self.data['DOW'] = self.safe_float(content)\n", + " elif self.counter == 1:\n", + " self.data['S&P'] = self.safe_float(content)\n", + " elif self.counter == 2:\n", + " self.data['NASDAQ'] = self.safe_float(content)\n", + " elif self.counter == 3:\n", + " self.data['Crude'] = self.safe_float(content)\n", + " elif self.counter == 4:\n", + " self.data['Gold'] = self.safe_float(content)\n", + " \n", + " self.counter += 1\n", + " \n", + " def handle_endtag(self, tag):\n", + " self.in_font_tag = False\n", + "\n", + "def retrieve_data(url):\n", + " sa = \"http://seekingalpha.com\"\n", + " article_html = requests.get(sa + url,\n", + " headers={\"User-Agent\": \"Wget/1.13.4\"})\n", + " parser = ArticleReturnParser()\n", + " parser.feed(article_html.text)\n", + " parser.data.update({\"url\": url})\n", + " parser.data.update({\"text\": article_html.text})\n", + " return parser.data\n", + "\n", + "# This copy **MUST** be in place. I'm not sure why,\n", + "# as you'd think that the data being returned would already\n", + "# represent a different memory location. Even so, it blows up\n", + "# if you don't do this.\n", + "article_list = list(set(global_articles))\n", + "article_data = [copy(retrieve_data(url)) for url in article_list]\n", + "# If there's an issue downloading the article, drop it.\n", + "article_df = pd.DataFrame.from_dict(article_data).dropna()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fetching the Returns data\n", + "\n", + "Now that we have the futures data, we're going to compare across 4 different indices - the S&P 500 index, Dow Jones Industrial, Russell 2000, and NASDAQ 100. Let's get the data off of Quandl to make things easier!" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# article_df is sorted by date, so we get the first row.\n", + "start_date = article_df.sort_values(by='date').iloc[0]['date'] - relativedelta(days=1)\n", + "SPY = Quandl.get(\"GOOG/NYSE_SPY\", trim_start=start_date)\n", + "DJIA = Quandl.get(\"GOOG/AMS_DIA\", trim_start=start_date)\n", + "RUSS = Quandl.get(\"GOOG/AMEX_IWM\", trim_start=start_date)\n", + "NASDAQ = Quandl.get(\"GOOG/EPA_QQQ\", trim_start=start_date)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Running the Comparison\n", + "\n", + "There are two types of tests I want to determine: How accurate each futures category is at predicting the index's opening change over the close before, and predicting the index's daily return.\n", + "\n", + "Let's first calculate how good each future is at predicting the opening return over the previous day. I expect that the futures will be more than 50% accurate, since the information is recorded 3 hours before the markets open." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Articles Checked: \n", + " DJIA NASDAQ RUSS SPY\n", + "Crude 268 268 271 271\n", + "DOW 268 268 271 271\n", + "Gold 268 268 271 271\n", + "NASDAQ 268 268 271 271\n", + "S&P 268 268 271 271\n", + "\n", + "Prediction Accuracy:\n", + " DJIA NASDAQ RUSS SPY\n", + "Crude 0.544776 0.522388 0.601476 0.590406\n", + "DOW 0.611940 0.604478 0.804428 0.841328\n", + "Gold 0.462687 0.455224 0.464945 0.476015\n", + "NASDAQ 0.615672 0.608209 0.797048 0.830258\n", + "S&P 0.604478 0.597015 0.811808 0.848708\n" + ] + } + ], + "source": [ + "def calculate_opening_ret(frame):\n", + " # I'm not a huge fan of the appending for loop,\n", + " # but it's a bit verbose for a comprehension\n", + " data = {}\n", + " for i in range(1, len(frame)):\n", + " date = frame.iloc[i].name\n", + " prior_close = frame.iloc[i-1]['Close']\n", + " open_val = frame.iloc[i]['Open']\n", + " data[date] = (open_val - prior_close) / prior_close\n", + " \n", + " return data\n", + "\n", + "SPY_open_ret = calculate_opening_ret(SPY)\n", + "DJIA_open_ret = calculate_opening_ret(DJIA)\n", + "RUSS_open_ret = calculate_opening_ret(RUSS)\n", + "NASDAQ_open_ret = calculate_opening_ret(NASDAQ)\n", + "\n", + "def signs_match(list_1, list_2):\n", + " # This is a surprisingly difficult task - we have to match\n", + " # up the dates in order to check if opening returns actually match\n", + " index_dict_dt = {key.to_datetime(): list_2[key] for key in list_2.keys()}\n", + " \n", + " matches = []\n", + " for row in list_1.iterrows():\n", + " row_dt = row[1][1]\n", + " row_value = row[1][0]\n", + " index_dt = datetime(row_dt.year, row_dt.month, row_dt.day)\n", + " if index_dt in list_2:\n", + " index_value = list_2[index_dt]\n", + " if (row_value > 0 and index_value > 0) or \\\n", + " (row_value < 0 and index_value < 0) or \\\n", + " (row_value == 0 and index_value == 0):\n", + " matches += [1]\n", + " else:\n", + " matches += [0]\n", + " #print(\"{}\".format(list_2[index_dt]))\n", + " return matches\n", + " \n", + " \n", + "prediction_dict = {}\n", + "matches_dict = {}\n", + "count_dict = {}\n", + "index_dict = {\"SPY\": SPY_open_ret, \"DJIA\": DJIA_open_ret, \"RUSS\": RUSS_open_ret, \"NASDAQ\": NASDAQ_open_ret}\n", + "indices = [\"SPY\", \"DJIA\", \"RUSS\", \"NASDAQ\"]\n", + "futures = [\"Crude\", \"Gold\", \"DOW\", \"NASDAQ\", \"S&P\"]\n", + "for index in indices:\n", + " matches_dict[index] = {future: signs_match(article_df[[future, 'date']],\n", + " index_dict[index]) for future in futures}\n", + " count_dict[index] = {future: len(matches_dict[index][future]) for future in futures}\n", + " prediction_dict[index] = {future: np.mean(matches_dict[index][future])\n", + " for future in futures}\n", + "print(\"Articles Checked: \")\n", + "print(pd.DataFrame.from_dict(count_dict))\n", + "print()\n", + "print(\"Prediction Accuracy:\")\n", + "print(pd.DataFrame.from_dict(prediction_dict))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This data is very interesting. Some insights:\n", + "\n", + "- Both DOW and NASDAQ futures are pretty bad at predicting their actual market openings\n", + "- NASDAQ and Dow are fairly unpredictable; Russell 2000 and S&P are very predictable\n", + "- Gold is a poor predictor in general - intuitively Gold should move inverse to the market, but it appears to be about as accurate as a coin flip.\n", + "\n", + "All said though it appears that futures data is important for determining market direction for both the S&P 500 and Russell 2000. Cramer is half-right: futures data isn't very helpful for the Dow and NASDAQ indices, but is great for the S&P and Russell indices.\n", + "\n", + "# The next step - Predicting the close\n", + "\n", + "Given the code we currently have, I'd like to predict the close of the market as well. We can re-use most of the code, so let's see what happens:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Articles Checked:\n", + " DJIA NASDAQ RUSS SPY\n", + "Crude 268 268 271 271\n", + "DOW 268 268 271 271\n", + "Gold 268 268 271 271\n", + "NASDAQ 268 268 271 271\n", + "S&P 268 268 271 271\n", + "\n", + "Prediction Accuracy:\n", + " DJIA NASDAQ RUSS SPY\n", + "Crude 0.533582 0.529851 0.501845 0.542435\n", + "DOW 0.589552 0.608209 0.535055 0.535055\n", + "Gold 0.455224 0.451493 0.483395 0.512915\n", + "NASDAQ 0.582090 0.626866 0.531365 0.538745\n", + "S&P 0.585821 0.608209 0.535055 0.535055\n" + ] + } + ], + "source": [ + "def calculate_closing_ret(frame):\n", + " # I'm not a huge fan of the appending for loop,\n", + " # but it's a bit verbose for a comprehension\n", + " data = {}\n", + " for i in range(0, len(frame)):\n", + " date = frame.iloc[i].name\n", + " open_val = frame.iloc[i]['Open']\n", + " close_val = frame.iloc[i]['Close']\n", + " data[date] = (close_val - open_val) / open_val\n", + " \n", + " return data\n", + "\n", + "SPY_close_ret = calculate_closing_ret(SPY)\n", + "DJIA_close_ret = calculate_closing_ret(DJIA)\n", + "RUSS_close_ret = calculate_closing_ret(RUSS)\n", + "NASDAQ_close_ret = calculate_closing_ret(NASDAQ)\n", + "\n", + "def signs_match(list_1, list_2):\n", + " # This is a surprisingly difficult task - we have to match\n", + " # up the dates in order to check if opening returns actually match\n", + " index_dict_dt = {key.to_datetime(): list_2[key] for key in list_2.keys()}\n", + " \n", + " matches = []\n", + " for row in list_1.iterrows():\n", + " row_dt = row[1][1]\n", + " row_value = row[1][0]\n", + " index_dt = datetime(row_dt.year, row_dt.month, row_dt.day)\n", + " if index_dt in list_2:\n", + " index_value = list_2[index_dt]\n", + " if (row_value > 0 and index_value > 0) or \\\n", + " (row_value < 0 and index_value < 0) or \\\n", + " (row_value == 0 and index_value == 0):\n", + " matches += [1]\n", + " else:\n", + " matches += [0]\n", + " #print(\"{}\".format(list_2[index_dt]))\n", + " return matches\n", + " \n", + " \n", + "matches_dict = {}\n", + "count_dict = {}\n", + "prediction_dict = {}\n", + "index_dict = {\"SPY\": SPY_close_ret, \"DJIA\": DJIA_close_ret,\n", + " \"RUSS\": RUSS_close_ret, \"NASDAQ\": NASDAQ_close_ret}\n", + "indices = [\"SPY\", \"DJIA\", \"RUSS\", \"NASDAQ\"]\n", + "futures = [\"Crude\", \"Gold\", \"DOW\", \"NASDAQ\", \"S&P\"]\n", + "for index in indices:\n", + " matches_dict[index] = {future: signs_match(article_df[[future, 'date']],\n", + " index_dict[index]) for future in futures}\n", + " count_dict[index] = {future: len(matches_dict[index][future]) for future in futures}\n", + " prediction_dict[index] = {future: np.mean(matches_dict[index][future])\n", + " for future in futures}\n", + " \n", + "print(\"Articles Checked:\")\n", + "print(pd.DataFrame.from_dict(count_dict))\n", + "print()\n", + "print(\"Prediction Accuracy:\")\n", + "print(pd.DataFrame.from_dict(prediction_dict))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Well, it appears that the futures data is terrible at predicting market close. NASDAQ predicting NASDAQ is the most interesting data point, but 63% accuracy isn't accurate enough to make money consistently.\n", + "\n", + "# Final sentiments\n", + "\n", + "The data bears out very close to what I expected would happen:\n", + "\n", + "- Futures data is more accurate than a coin flip for predicting openings, which makes sense since it is recorded only 3 hours before the actual opening\n", + "- Futures data is about as acccurate as a coin flip for predicting closings, which means there is no money to be made in trying to predict the market direction for the day given the futures data.\n", + "\n", + "In summary:\n", + "\n", + "- Cramer is half right: Futures data is not good for predicting the market open of the Dow and NASDAQ indices. Contrary to Cramer though, it is very good for predicting the S&P and Russell indices - we can achieve an accuracy slightly over 80% for each. \n", + "- Making money in the market is hard. We can't just go to the futures and treat them as an oracle for where the market will close.\n", + "\n", + "I hope you've enjoyed this, I quite enjoyed taking a deep dive in the analytics this way. I'll be posting more soon!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.5.0" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/content/notebooks/2016-1-1-complaining-about-weather.ipynb b/content/notebooks/2016-1-1-complaining-about-weather.ipynb new file mode 100644 index 0000000..daa035d --- /dev/null +++ b/content/notebooks/2016-1-1-complaining-about-weather.ipynb @@ -0,0 +1,734 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + " \n", + "\n", + "\n", + " \n", + "\n", + "
\n", + " \n", + " BokehJS successfully loaded.\n", + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from bokeh.plotting import figure, output_notebook, show\n", + "from bokeh.palettes import PuBuGn9 as Palette\n", + "import pandas as pd\n", + "import numpy as np\n", + "from datetime import datetime\n", + "import pickle\n", + "\n", + "output_notebook()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I'm originally from North Carolina, and I've been hearing a lot of people talking about how often it's been raining recently. They're excited for any day that has sun.\n", + "\n", + "So I got a bit curious: Has North Carolina over the past few months actually had more cloudy and rainy days recently than in previous years? This shouldn't be a particularly challenging task, but I'm interested to know if people's perceptions actually reflect reality.\n", + "\n", + "The data we'll use comes from [forecast.io][1], since they can give us a cloud cover percentage. I've gone ahead and retrieved the data to a pickle file, and included the [code that was used to generate it](#Generating-the-Forecast-file). First up: What was the average cloud cover in North Carolina during August - November, and how many days were cloudy? We're going to assume that a \"cloudy\" day is defined as any day in which the cloud cover is above 50%.\n", + "\n", + "[1]: http://forecast.io/" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "city_forecasts = pickle.load(open('city_forecasts.p', 'rb'))\n", + "forecast_df = pd.DataFrame.from_dict(city_forecasts)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cary_forecast = forecast_df['cary']\n", + "years = range(1990, 2016)\n", + "months = range(7, 12)\n", + "months_str = ['July', 'August', 'September', 'October', 'November']\n", + "\n", + "def safe_cover(frame):\n", + " if frame and 'cloudCover' in frame:\n", + " return frame['cloudCover']\n", + " else:\n", + " return np.NaN\n", + "\n", + "def monthly_avg_cloudcover(year, month):\n", + " dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),\n", + " end=datetime(year, month + 1, 1, 12),\n", + " freq='D', closed='left')\n", + " cloud_cover_vals = list(map(lambda x: safe_cover(cary_forecast[x]['currently']), dates))\n", + " cloud_cover_samples = len(list(filter(lambda x: x is not np.NaN, cloud_cover_vals)))\n", + " return np.nanmean(cloud_cover_vals), cloud_cover_samples\n", + "\n", + "\n", + "monthly_cover_vals = [[monthly_avg_cloudcover(y, m)[0] for y in years] for m in months]\n", + "\n", + "f = figure(title='Monthly Average Cloud Cover',\n", + " x_range=(1990, 2015),\n", + " x_axis_label='Year')\n", + "for x in range(0, len(months)):\n", + " f.line(years, monthly_cover_vals[x], legend=months_str[x], color=Palette[x])\n", + "show(f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see from the chart above, on the whole the monthly average cloud cover has been generally trending down over time. The average cloud cover is also lower than it was last year - it seems people are mostly just complaining. There are some data issues that start in 2012 that we need to be aware of - the cloud cover percentage doesn't exist for all days. Even so, the data that we have seems to reflect the wider trend, so we'll assume for now that the missing data doesn't skew our results.\n", + "\n", + "There's one more metric we want to check though - how many cloudy days were there? This is probably a better gauge of sentiment than the average monthly cover." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def monthly_cloudy_days(year, month):\n", + " dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),\n", + " end=datetime(year, month + 1, 1, 12),\n", + " freq='D', closed='left')\n", + " cloud_cover_vals = list(map(lambda x: safe_cover(cary_forecast[x]['currently']), dates))\n", + " cloud_cover_samples = len(list(filter(lambda x: x is not np.NaN, cloud_cover_vals)))\n", + " cloudy_days = [cover > .5 for cover in cloud_cover_vals]\n", + " return np.count_nonzero(cloudy_days), cloud_cover_samples\n", + "\n", + "monthly_days_vals = [[monthly_cloudy_days(y, m)[0] for y in years] for m in months]\n", + "monthly_cover_samples = [[monthly_cloudy_days(y, m)[1] for y in years] for m in months]\n", + "\n", + "f = figure(title='Monthly Cloudy Days',\n", + " x_range=(1990, 2015),\n", + " x_axis_label='Year')\n", + "for x in range(0, len(months)):\n", + " f.line(years, monthly_days_vals[x], legend=months_str[x], color=Palette[x])\n", + "show(f)\n", + "\n", + "f = figure(title='Monthly Cloud Cover Samples',\n", + " x_range=(1990, 2015),\n", + " x_axis_label='Year',\n", + " height=300)\n", + "for x in range(0, len(months)):\n", + " f.line(years, monthly_cover_samples[x], legend=months_str[x], color=Palette[x])\n", + "show(f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On the whole, the number of cloudy days seems to reflect the trend with average cloud cover - it's actually becoming more sunny as time progresses. That said, we need to be careful in how we view this number - because there weren't as many samples in 2015 as previous years, the number of days can get thrown off. In context though, even if most days not recorded were in fact cloudy, the overall count for 2015 would still be lower than previous years.\n", + "\n", + "# Tracking Precipitation Chances\n", + "\n", + "In addition to checking cloud cover, I wanted to check precipitation data as well - what is the average precipitation chance over a month, and how many days during a month is rain likely? The thinking is that days with a high-precipitation chance will also be days in which it is cloudy or depressing." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def safe_precip(frame):\n", + " if frame and 'precipProbability' in frame:\n", + " return frame['precipProbability']\n", + " else:\n", + " return np.NaN\n", + "\n", + "def monthly_avg_precip(year, month):\n", + " dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),\n", + " end=datetime(year, month + 1, 1, 12),\n", + " freq='D', closed='left')\n", + " precip_vals = list(map(lambda x: safe_precip(cary_forecast[x]['currently']), dates))\n", + " precip_samples = len(list(filter(lambda x: x is not np.NaN, precip_vals)))\n", + " return np.nanmean(precip_vals), precip_samples\n", + "\n", + "monthly_avg_precip_vals = [[monthly_avg_precip(y, m)[0] for y in years] for m in months]\n", + "\n", + "f = figure(title='Monthly Average Precipitation Chance',\n", + " x_range=(1990, 2015),\n", + " x_axis_label='Year')\n", + "for x in range(0, len(months)):\n", + " f.line(years, monthly_avg_precip_vals[x], legend=months_str[x], color=Palette[x])\n", + "show(f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see from the chart, the average chance of precipitation over a month more or less stays within a band of 0 - .1 for all months over all years. This is further evidence that the past few months are no more cloudy or rainy than previous years. Like the cloud cover though, we still want to get a count of all the rainy days, in addition to the average chance. We'll define a \"rainy day\" as any day in which the chance of rain is greater than 25%." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def monthly_rainy_days(year, month):\n", + " dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),\n", + " end=datetime(year, month + 1, 1, 12),\n", + " freq='D', closed='left')\n", + " precip_prob_vals = list(map(lambda x: safe_precip(cary_forecast[x]['currently']), dates))\n", + " precip_prob_samples = len(list(filter(lambda x: x is not np.NaN, precip_prob_vals)))\n", + " precip_days = [prob > .25 for prob in precip_prob_vals]\n", + " return np.count_nonzero(precip_days), precip_prob_samples\n", + "\n", + "monthly_precip_days_vals = [[monthly_rainy_days(y, m)[0] for y in years] for m in months]\n", + "monthly_precip_samples = [[monthly_rainy_days(y, m)[1] for y in years] for m in months]\n", + "\n", + "f = figure(title='Monthly Rainy Days',\n", + " x_range=(1990, 2015),\n", + " x_axis_label='Year')\n", + "for x in range(0, len(months)):\n", + " f.line(years, monthly_precip_days_vals[x], legend=months_str[x], color=Palette[x])\n", + "show(f)\n", + "\n", + "f = figure(title='Monthly Rainy Days Samples',\n", + " x_range=(1990, 2015),\n", + " x_axis_label='Year',\n", + " height=300)\n", + "for x in range(0, len(months)):\n", + " f.line(years, monthly_precip_samples[x], legend=months_str[x], color=Palette[x])\n", + "show(f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After trying to find the number of days that are rainy, we can see that November hit its max value for rainy days in 2015. However, that value is 6, as compared to a previous maximum of 5. While it is a new record, the value isn't actually all that different. And for other months, the values are mostly in-line with the averages.\n", + "\n", + "# Summary and Conclusions\n", + "\n", + "After having looked at forecast data for Cary, it appears that the months of July - November this year in terms of weather were at worst on par with prior years, if not slightly more sunny. This seems to be a case of confirmation bias: someone complains about a string of cloudy or rainy days, and suddenly you start noticing them more.\n", + "\n", + "While this analysis doesn't take into account other areas of North Carolina, my initial guess would be to assume that other areas also will show similar results: nothing interesting is happening. Maybe that will be for another blog post later!\n", + "\n", + "Coming soon: I'll compare rain/cloud conditions in North Carolina to some other places in the U.S.!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generating the Forecast file\n", + "\n", + "The following code was generates the file that was used throughout the blog post. Please note that I'm retrieving data for other cities to use in a future blog post, only Cary data was used for this post.\n", + "\n", + "```python\n", + "import pandas as pd\n", + "from functools import reduce\n", + "import requests\n", + "from datetime import datetime\n", + "\n", + "# Coordinate data from http://itouchmap.com/latlong.html\n", + "cary_loc = (35.79154,-78.781117)\n", + "nyc_loc = (40.78306,-73.971249)\n", + "seattle_loc = (47.60621,-122.332071)\n", + "binghamton_loc = (42.098687,-75.917974)\n", + "cities = {\n", + " 'cary': cary_loc,\n", + " 'nyc': nyc_loc,\n", + " 'seattle': seattle_loc,\n", + " 'binghamton': binghamton_loc\n", + "}\n", + "\n", + "apikey = '' # My super-secret API Key\n", + "\n", + "def get_forecast(lat, long, date=None):\n", + " forecast_base = \"https://api.forecast.io/forecast/\"\n", + " if date is None:\n", + " url = forecast_base + apikey + '/{},{}'.format(lat, long)\n", + " else:\n", + " epoch = int(date.timestamp())\n", + " url = forecast_base + apikey + '/{},{},{}'.format(lat, long, epoch)\n", + " \n", + " return requests.get(url).json()\n", + " \n", + "years = range(1990,2016)\n", + "# For datetimes, the 12 is for getting the weather at noon.\n", + "# We're doing this over midnight because we're more concerned\n", + "# with what people see, and people don't typically see the weather\n", + "# at midnight.\n", + "dt_indices = [pd.date_range(start=datetime(year, 7, 1, 12),\n", + " end=datetime(year, 11, 30, 12))\n", + " for year in years]\n", + "dt_merge = reduce(lambda x, y: x.union(y), dt_indices)\n", + "\n", + "# Because we have to pay a little bit to use the API, we use for loops here\n", + "# instead of a comprehension - if something breaks, we want to preserve the\n", + "# data already retrieved\n", + "city_forecasts = {}\n", + "for city, loc in cities.items():\n", + " print(\"Retrieving data for {} starting at {}\".format(city,\n", + " datetime.now().strftime(\"%I:%M:%S %p\")))\n", + " for dt in dt_merge:\n", + " try:\n", + " city_forecasts[(city, dt)] = get_forecast(*loc, dt)\n", + " except Exception as e:\n", + " print(e)\n", + " city_forecasts[(city, dt)] = None\n", + "print(\"End forecast retrieval: {}\".format(datetime.now().strftime(\"%I:%M:%S %p\")))\n", + "\n", + "import pickle\n", + "pickle.dump(city_forecasts, open('city_forecasts.p', 'wb'))\n", + "\n", + "### Output:\n", + "# Retrieving data for binghamton starting at 05:13:42 PM\n", + "# Retrieving data for seattle starting at 05:30:51 PM\n", + "# Retrieving data for nyc starting at 05:48:30 PM\n", + "# Retrieving data for cary starting at 06:08:32 PM\n", + "# End forecast retrieval: 06:25:21 PM\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.5.0" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/content/notebooks/2016-1-23-cloudy-in-seattle.ipynb b/content/notebooks/2016-1-23-cloudy-in-seattle.ipynb new file mode 100644 index 0000000..b7e2d62 --- /dev/null +++ b/content/notebooks/2016-1-23-cloudy-in-seattle.ipynb @@ -0,0 +1,721 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + " \n", + "\n", + "\n", + " \n", + "\n", + "
\n", + " \n", + " BokehJS successfully loaded.\n", + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pickle\n", + "import pandas as pd\n", + "import numpy as np\n", + "from bokeh.plotting import output_notebook, figure, show\n", + "from bokeh.palettes import RdBu4 as Palette\n", + "from datetime import datetime\n", + "import warnings\n", + "\n", + "output_notebook()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After taking some time to explore how the weather in North Carolina stacked up over the past years, I was interested in doing the same analysis for other cities. Growing up with family from Binghamton, NY I was always told it was very cloudy there. And Seattle has a nasty reputation for being very depressing and cloudy. All said, the cities I want to examine are:\n", + "- Binghamton, NY\n", + "- Cary, NC\n", + "- Seattle, WA\n", + "- New York City, NY\n", + "\n", + "I'd be interested to try this analysis worldwide at some point - comparing London and Seattle might be an interesting analysis. For now though, we'll stick with trying out the US data.\n", + "\n", + "There will be plenty of charts. I want to know: **How has average cloud cover and precipitation chance changed over the years for each city mentioned?** This will hopefully tell us whether Seattle has actually earned its reputation for being a depressing city." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "city_forecasts = pickle.load(open('city_forecasts.p', 'rb'))\n", + "forecasts_df = pd.DataFrame.from_dict(city_forecasts)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "cities = ['binghamton', 'cary', 'nyc', 'seattle']\n", + "city_colors = {cities[i]: Palette[i] for i in range(0, 4)}\n", + "\n", + "def safe_cover(frame):\n", + " if frame and 'cloudCover' in frame:\n", + " return frame['cloudCover']\n", + " else:\n", + " return np.NaN\n", + "\n", + "def monthly_avg_cloudcover(city, year, month):\n", + " dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),\n", + " end=datetime(year, month + 1, 1, 12),\n", + " freq='D', closed='left')\n", + " cloud_cover_vals = list(map(lambda x: safe_cover(forecasts_df[city][x]['currently']), dates))\n", + " cloud_cover_samples = len(list(filter(lambda x: x is not np.NaN, cloud_cover_vals)))\n", + " # Ignore an issue with nanmean having all NaN values. We'll discuss the data issues below.\n", + " with warnings.catch_warnings():\n", + " warnings.simplefilter('ignore')\n", + " return np.nanmean(cloud_cover_vals), cloud_cover_samples" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "years = range(1990, 2016)\n", + "def city_avg_cc(city, month):\n", + " return [monthly_avg_cloudcover(city, y, month) for y in years]\n", + "\n", + "months = [\n", + " ('July', 7),\n", + " ('August', 8),\n", + " ('September', 9),\n", + " ('October', 10),\n", + " ('November', 11)\n", + "]\n", + "\n", + "for month, month_id in months:\n", + " month_averages = {city: city_avg_cc(city, month_id) for city in cities}\n", + " f = figure(title=\"{} Average Cloud Cover\".format(month),\n", + " x_axis_label='Year',\n", + " y_axis_label='Cloud Cover Percentage')\n", + " for city in cities:\n", + " f.line(years, [x[0] for x in month_averages[city]],\n", + " legend=city, color=city_colors[city])\n", + " show(f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Well, as it so happens it looks like there are some data issues. July's data is a bit sporadic, and 2013 seems to be missing from most months as well. I think really only two things can really be confirmed here:\n", + "- Seattle, specifically for the months of October and November, is in fact significantly more cloudy on average than are other cities\n", + "- All cities surveyed have seen average cloud cover decline over the months studied. There are data issues, but the trend seems clear.\n", + "\n", + "Let's now move from cloud cover data to looking at average rainfall chance." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def safe_precip(frame):\n", + " if frame and 'precipProbability' in frame:\n", + " return frame['precipProbability']\n", + " else:\n", + " return np.NaN\n", + "\n", + "def monthly_avg_precip(city, year, month):\n", + " dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),\n", + " end=datetime(year, month + 1, 1, 12),\n", + " freq='D', closed='left')\n", + " precip_vals = list(map(lambda x: safe_precip(forecasts_df[city][x]['currently']), dates))\n", + " precip_samples = len(list(filter(lambda x: x is not np.NaN, precip_vals)))\n", + " # Ignore an issue with nanmean having all NaN values. We'll discuss the data issues below.\n", + " with warnings.catch_warnings():\n", + " warnings.simplefilter('ignore')\n", + " return np.nanmean(precip_vals), precip_samples\n", + "\n", + "def city_avg_precip(city, month):\n", + " return [monthly_avg_precip(city, y, month) for y in years]\n", + "\n", + "for month, month_id in months:\n", + " month_averages = {city: city_avg_cc(city, month_id) for city in cities}\n", + " f = figure(title=\"{} Average Precipitation Chance\".format(month),\n", + " x_axis_label='Year',\n", + " y_axis_label='Precipitation Chance Percentage')\n", + " for city in cities:\n", + " f.line(years, [x[0] for x in month_averages[city]],\n", + " legend=city, color=city_colors[city])\n", + " show(f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The same data issue caveats apply here: 2013 seems to be missing some data, and July has some issues as well. However, this seems to confirm the trends we saw with cloud cover:\n", + "- Seattle, specifically for the months of August, October, and November has had a consistently higher chance of rain than other cities surveyed.\n", + "- Average precipitation chance, just like average cloud cover, has been trending down over time.\n", + "\n", + "# Conclusion\n", + "\n", + "I have to admit I was a bit surprised after doing this analysis. Seattle showed a higher average cloud cover and average precipitation chance than did the other cities surveyed. Maybe Seattle is actually an objectively more depressing city to live in.\n", + "\n", + "Well that's all for weather data at the moment. It's been a great experiment, but I think this is about as far as I'll be able to get with weather data without some domain knowledge. Talk again soon!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.5.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/content/notebooks/2016-2-26-profitability-using-the-investment-formula.ipynb b/content/notebooks/2016-2-26-profitability-using-the-investment-formula.ipynb new file mode 100644 index 0000000..a687fb7 --- /dev/null +++ b/content/notebooks/2016-2-26-profitability-using-the-investment-formula.ipynb @@ -0,0 +1,383 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Profitability using the Investment Formula\n", + "\n", + "I've previously talked about crafting an [Investment Formula][1] that would guarantee making money if you could predict which direction the stock market was going to go. This is going to be the first in a series of posts trying to flesh out what an actual investment strategy based on this formula would look like.\n", + "\n", + "But first, the formula doesn't take into account two very important things: **leverage**, and the **number of days invested**. That's why I want to set up what I'm going to call the **Profitability Score**.\n", + "\n", + "The definition is going to be very simple:\n", + "\n", + "- $p$: Profit made once you exit the investment\n", + "- $i$: Initial investment into the asset\n", + "- $m$: Maximum investment in the asset\n", + "- $l = m / i$: The maximum leverage of an investment, as the ratio of maximum invested to initial investment\n", + "- $d$: The number of days it takes to turn a profit\n", + "\n", + "$s = \\frac{1000 p}{i(l + d)} = \\frac{1000 p}{m + i\\cdot d}$\n", + "\n", + "Crazy, right? The score is simply the (normalized) profit you made divided by the leverage plus days invested. The $\\cdot 1000$ is just to turn the number into something more reasonable - people don't like hearing something with a profitability score of .001 for example.\n", + "\n", + "# Theoretical Justification\n", + "\n", + "The formula itself is designed to be simple in principle: I like making a profit, and I want to penalize the leverage you incur and days you have to invest. Ideally, we want to have a stock that goes up all the time. However, the investment formula takes advantage of a different case: trying to profit from highly volatile assets. If we can make money when the investment only has one day up, let's do it!\n", + "\n", + "Even so, there are two potential issues: First, stocks that trend upward will have a higher profitability score - both leverage and days invested will be 1. To protect against only investing in this trend, I can do things like taking $\\log(d)$. I don't want to start biasing the scoring function until I have a practical reason to do so, so right now I'll leave it standing.\n", + "\n", + "The second issue is how to penalize leverage and days invested relative to each other. As it currently stands, a leverage of 6x with only 1 day invested is the same as leveraging 2x with 3 days invested. In the future, I'd again want to look at making the impact of days invested smaller - I can get over an extra 3 days in the market if it means that I don't have to incur a highly leveraged position.\n", + "\n", + "So there could be things about the scoring function we change in the future, but I want to run some actual tests before we start worrying about things like that!\n", + "\n", + "# Running a simulation\n", + "\n", + "This won't be an incredibly rigorous backtest, I just want to see some results from the work so far. Let's set up the simulation code again, and start looking into some random stocks. **If you've read the last blog post, you can skip over the code.** The only difference is that it's been ported to python to make the data-wrangling easier. Julia doesn't yet support some of the multi-index things I'm trying to do.\n", + "\n", + "[1]: https://bspeice.github.io/guaranteed-money-maker.html" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from Quandl import get as qget\n", + "%matplotlib inline\n", + "api_key = 'QUJUp-dAKyo2y8DGsCv-'\n", + "\n", + "profitability = lambda p, i, m, d: 1000*p / (m + i*d)\n", + "\n", + "def is_profitable(current_price, purchase_history, open_history):\n", + " shares = (purchase_history / open_history).sum()\n", + " return current_price * shares > sum(purchase_history)\n", + "\n", + "def daily_investment(current_open, current_close, purchase_history, open_history):\n", + " t1 = current_close / current_open - 1\n", + " t2 = (purchase_history - purchase_history * current_close / open_history).sum()\n", + " return t2 / t1\n", + "\n", + "def simulate_day(open_vals, close_vals, init, expected, bias):\n", + " invested = np.array([init])\n", + " \n", + " day = 1\n", + " profitable = is_profitable(close_vals[day-1], invested, open_vals[0:len(invested)]) \\\n", + " or is_profitable(open_vals[day], invested, open_vals[0:len(invested)])\n", + "\n", + " while not profitable:\n", + " expected_close = open_vals[day] * expected\n", + " todays_purchase = daily_investment(open_vals[day], expected_close, invested, open_vals[0:day])\n", + " invested = np.append(invested, todays_purchase + bias)\n", + " # expected_profit = expected_close * (invested / open_vals[0:len(invested)]).sum() - invested.sum()\n", + " day += 1\n", + " profitable = is_profitable(close_vals[day-1], invested, open_vals[0:len(invested)]) \\\n", + " or is_profitable(open_vals[day], invested, open_vals[0:len(invested)])\n", + " \n", + " shares = (invested / open_vals[0:len(invested)]).sum()\n", + " \n", + " # Make sure we can't see into the future - we know either today's close or tomorrow's open\n", + " # will be profitable, but we need to check which one.\n", + " if is_profitable(close_vals[day-1], invested, open_vals[0:len(invested)]):\n", + " ending_price = close_vals[day-1]\n", + " else:\n", + " ending_price = open_vals[day]\n", + " \n", + " profit = shares * ending_price - sum(invested)\n", + " return invested, profit\n", + "\n", + "def simulate_ts(name, start, end, initial, expected, bias):\n", + " ticker_info = qget(name, trim_start=start, api_key=api_key)\n", + " evaluation_times = ticker_info[:end].index\n", + " \n", + " # Handle Google vs. YFinance data\n", + " if \"Adjusted Close\" in ticker_info.columns:\n", + " close_column = \"Adjusted Close\"\n", + " else:\n", + " close_column = \"Close\"\n", + " \n", + " sim = {d: simulate_day(ticker_info[d:][\"Open\"], ticker_info[d:][close_column],\n", + " 100, 1.02, 10) for d in evaluation_times}\n", + " sim_series = pd.Series(sim)\n", + " result = pd.DataFrame()\n", + " result[\"profit\"] = sim_series.apply(lambda x: x[1])\n", + " result[\"max\"] = sim_series.apply(lambda x: max(x[0]))\n", + " result[\"days\"] = sim_series.apply(lambda x: len(x[0]))\n", + " result[\"score\"] = sim_series.apply(lambda x: profitability(x[1], x[0][0], max(x[0]), len(x[0])))\n", + " result[\"investments\"] = sim_series.apply(lambda x: x[0])\n", + " \n", + " return result\n", + "\n", + "def simulate_tickers(tickers):\n", + " from datetime import datetime\n", + " results = {}\n", + " for ticker in tickers:\n", + " start = datetime(2015, 1, 1)\n", + " results_df = simulate_ts(ticker, start, datetime(2016, 1, 1), 100, 1.01, 10)\n", + " results[ticker] = results_df\n", + " \n", + " return pd.concat(list(results.values()), keys=list(results.keys()), axis=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# And now the interesting part\n", + "\n", + "Let's start looking into the data! FANG stocks have been big over the past year, let's see how they look:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "fang_df = simulate_tickers([\"YAHOO/FB\", \"YAHOO/AAPL\", \"YAHOO/NFLX\", \"YAHOO/GOOG\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABBgAAAIICAYAAADE513IAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fang_df.xs('days', axis=1, level=1).hist()\n", + "plt.gcf().set_size_inches(18, 8);\n", + "plt.gcf().suptitle(\"Distribution of Days Until Profitability\", fontsize=18);" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABBEAAAGECAYAAABgaLg8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fang_df.xs('score', axis=1, level=1).plot()\n", + "plt.gcf().set_size_inches(18, 6)\n", + "plt.gcf().suptitle(\"Profitability score over time\", fontsize=18);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's think about these graphs. First, the histogram. What we like seeing is a lot of 1's - that means there were a lot of days that the stock went up and we didn't have to worry about actually implementing the strategy - we were able to close the trade at a profit.\n", + "\n", + "Looking at the profitability score over time though is a bit more interesting. First off, stocks that are more volatile will tend to have a higher profitability score, no two ways about that. However, Netflix consistently outperformed on this metric. We know that 2015 was a good year for Netflix, so that's a (small) sign the strategy is performing as expected.\n", + "\n", + "The final interesting note happens around the end of August 2015. Around this period, the markets were selling off in a big way due to issues in China (not unlike what's happening now). Even so, all of the FANG stocks saw an uptick in profitability around this time. This is another sign that the strategy being developed performs better during periods of volatility, rather than from riding markets up or down.\n", + "\n", + "What about FANG vs. some cyclicals?" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "cyclic_df = simulate_tickers([\"YAHOO/X\", \"YAHOO/CAT\", \"YAHOO/NFLX\", \"YAHOO/GOOG\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABBgAAAIICAYAAADE513IAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cyclic_df.xs('days', axis=1, level=1).hist()\n", + "plt.gcf().set_size_inches(18, 8);\n", + "plt.gcf().suptitle(\"Distribution of Days Until Profitability\", fontsize=18);" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABBEAAAGECAYAAABgaLg8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhUKhUCgUpor/A9AnO0PoIItTAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cyclic_df.xs('score', axis=1, level=1).plot()\n", + "plt.gcf().set_size_inches(18, 6)\n", + "plt.gcf().suptitle(\"Profitability score over time\", fontsize=18);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Some more interesting results come from this as well. First off, US Steel (X) has a much smoother distribution of days until profitability - it doesn't have a huge number of values at 1 and then drop off. Intuitively, we're not terribly large fans of this, we want a stock to go up! However, on the profitability score it is the only serious contender to Netflix.\n", + "\n", + "Second, we see the same trend around August - the algorithm performs well in volatile markets.\n", + "\n", + "For a final test, let's try some biotech and ETFs!" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "biotech_df = simulate_tickers(['YAHOO/REGN', 'YAHOO/CELG', 'GOOG/NASDAQ_BIB', 'GOOG/NASDAQ_IBB'])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABBgAAAIICAYAAADE513IAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nWKBTQVcCAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "biotech_df.xs('days', axis=1, level=1).hist()\n", + "plt.gcf().set_size_inches(18, 8);\n", + "plt.gcf().suptitle(\"Distribution of Days Until Profitability\", fontsize=18);" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABBEAAAGECAYAAABgaLg8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "biotech_df.xs('score', axis=1, level=1).plot()\n", + "plt.gcf().set_size_inches(18, 6)\n", + "plt.gcf().suptitle(\"Profitability score over time\", fontsize=18);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example, we don't see a whole lot of interesting things: the scores are all fairly close together with notable exceptions in late August, and mid-October.\n", + "\n", + "What is interesting is that during the volatile period, the ETF's performed significantly better than the stocks did in terms of profitability. The leveraged ETF (BIB) performed far above anyone else, and it appears that indeed, it is most profitable during volatile periods. Even so, it was far more likely to take multiple days to give a return. Its count of 1-day investments trails the other ETF and both stocks by a decent margin.\n", + "\n", + "And consider me an OCD freak, but I just really like Celgene's distribution - it looks nice and smooth." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Summary and plans for the next post\n", + "\n", + "So far I'm really enjoying playing with this strategy - there's a lot of depth here to understand, though the preliminary results seem to indicate that it profits mostly from taking the other side of a volatile trade. I'd be interested to run results later on data from January - It's been a particularly volatile start to the year so it would be neat to see whether this strategy would work then.\n", + "\n", + "For the next post, I want to start playing with some of the parameters: How do the bias and expected close influence the process? The values have been fairly conservative so far, it will be interesting to see how the simulations respond afterward." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.5.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/content/notebooks/2016-2-3-guaranteed-money-maker.ipynb b/content/notebooks/2016-2-3-guaranteed-money-maker.ipynb new file mode 100644 index 0000000..8b99ee9 --- /dev/null +++ b/content/notebooks/2016-2-3-guaranteed-money-maker.ipynb @@ -0,0 +1,260 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### If you can see into the future, that is.\n", + "\n", + "My previous class in Stochastic Calculus covered a lot of interesting topics, and the important one for today\n", + "is the [Gambler's Ruin][1] problem. If you're interested in some of the theory behind it, also make sure to check out\n", + "[random walks][2]. The important bit is that we studied the [Martingale Betting Strategy][3], which describes for us\n", + "a **guaranteed way** to eventually make money.\n", + "\n", + "The strategy goes like this: You are going to toss a fair coin with a friend. If you guess heads or tails correctly, you get back double the money you bet. If you guess incorrectly, you lose money. How should you bet?\n", + "\n", + "The correct answer is that you should double your bet each time you lose. Then when you finally win, you'll be guaranteed to make back everything you lost and then $1 extra! Consider the scenario:\n", + "\n", + "1. You bet $1, and guess incorrectly. You're 1 dollar in the hole.\n", + "2. You bet $2, and guess incorrectly. You're 3 dollars in the hole now.\n", + "3. You bet $4, and guess incorrectly. You're 7 dollars in the hole.\n", + "4. You bet $8, and guess correctly! You now get back those 8 dollars you bet, plus 8 extra for winning, for a **total profit of one dollar**!\n", + "\n", + "Mathematically, we can prove that as long as you have unlimited money to bet, you are guaranteed to make money.\n", + "\n", + "# Applying the Martingale Strategy\n", + "\n", + "But we're all realistic people, and once you start talking about \"unlimited money\" eyebrows should be raised. Even still, this is an interesting strategy to investigate, and I want to apply it to the stock market. As long as we can guarantee there's a single day in which the stock goes up, we should be able to make money right? The question is just how much we have to invest to guarantee this.\n", + "\n", + "Now it's time for the math. We'll use the following definitions:\n", + "\n", + "- $o_i$ = the share price at the opening of day $i$\n", + "- $c_i$ = the share price at the close of day $i$\n", + "- $d_i$ = the amount of money we want to invest at the beginning of day $i$\n", + "\n", + "With those definitions in place, I'd like to present the formula that is **guaranteed to make you money**. I call it *Bradlee's Investment Formula*:\n", + "\n", + "$c_n \\sum_{i=1}^n \\frac{d_i}{o_i} > \\sum_{i=1}^{n} d_i$\n", + "\n", + "It might not look like much, but if you can manage to make it so that this formula holds true, you will be guaranteed to make money. The intuition behind the formula is this: The closing share price times the number of shares you have purchased ends up greater than the amount of money you invested.\n", + "\n", + "That is, on day $n$, if you know what the closing price will be you can set up the amount of money you invest that day to **guarantee you make money**. I'll even teach you to figure out how much money that is! Take a look:\n", + "\n", + "$\n", + "\\begin{align}\n", + "c_n \\sum_{i=1}^{n-1} \\frac{d_i}{o_i} + \\frac{c_nd_n}{o_n} &> \\sum_{i=1}^{n-1}d_i + d_n\\\\\n", + "\\frac{c_nd_n}{o_n} - d_n &> \\sum_{i=1}^{n-1}(d_i - \\frac{c_nd_i}{o_i})\\\\\n", + "d_n (\\frac{c_n - o_n}{o_n}) &> \\sum_{i=1}^{n-1} d_i(1 - \\frac{c_n}{o_i})\\\\\n", + "d_n &> \\frac{o_n}{c_n - o_n} \\sum_{i=1}^{n-1} d_i(1 - \\frac{1}{o_i})\n", + "\\end{align}$\n", + "\n", + "If you invest exactly $d_n$ that day, you'll break even. But if you can make sure the money you invest is greater than that quantity on the right (which requires that you have a crystal ball tell you the stock's closing price) you are **guaranteed to make money!**\n", + "\n", + "# Interesting Implications\n", + "\n", + "On a more serious note though, the formula above tells us a couple of interesting things:\n", + "\n", + "1. It's impossible to make money without the closing price at some point being greater than the opening price (or vice-versa if you are short selling) - there is no amount of money you can invest that will turn things in your favor.\n", + "2. Close prices of the past aren't important if you're concerned about the bottom line. While chart technicians use price history to make judgment calls, in the end, the closing price on anything other than the last day is irrelevant.\n", + "3. It's possible to make money as long as there is a single day where the closing price is greater than the opening price! You might have to invest a lot to do so, but it's possible.\n", + "4. You must make a prediction about where the stock will close at if you want to know how much to invest. That is, we can set up our investment for the day to make money if the stock goes up 1%, but if it only goes up .5% we'll still lose money.\n", + "5. It's possible the winning move is to scale back your position. Consider the scenario:\n", + " - You invest money and the stock closes down the day .5%\n", + " - You invest tomorrow expecting the stock to go up 1%\n", + " - The winning investment to break even (assuming a 1% increase) is to scale back the position, since the shares you purchased at the beginning would then be profitable\n", + "\n", + "# Running the simulation\n", + "\n", + "So now that we've defined our investment formula,we need to tweak a couple things in order to make an investment strategy we can actually work with. There are two issues we need to address:\n", + "\n", + "1. The formula only tells us how much to invest if we want to break even ($d_n$). If we actually want to turn a profit, we need to invest more than that, which we will refer to as the **bias**.\n", + "2. The formula assumes we know what the closing price will be on any given day. If we don't know this, we can still invest assuming the stock price will close at a level we choose. If the price doesn't meet this objective, we try again tomorrow! This predetermined closing price will be referred to as the **expectation**.\n", + "\n", + "Now that we've defined our *bias* and *expectation*, we can actually build a strategy we can simulate. Much like the martingale strategy told you to bet twice your previous bet in order to make money, we've designed a system that tells us how much to bet in order to make money as well.\n", + "\n", + "Now, let's get to the code!\n", + "\n", + "[1]: https://en.wikipedia.org/wiki/Gambler's_ruin\n", + "[2]: https://en.wikipedia.org/wiki/Random_walk\n", + "[3]: https://en.wikipedia.org/wiki/Martingale_%28betting_system%29" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "using Quandl\n", + "api_key = \"\"\n", + "daily_investment = function(current_open, current_close, purchase_history, open_history)\n", + " # We're not going to safeguard against divide by 0 - that's the user's responsibility\n", + " t1 = current_close / current_open - 1\n", + " t2 = sum(purchase_history - purchase_history*current_close ./ open_history)\n", + " return t2 / t1\n", + "end;" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And let's code a way to run simulations quickly:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "is_profitable = function(current_price, purchase_history, open_history)\n", + " shares = sum(purchase_history ./ open_history)\n", + " return current_price*shares > sum(purchase_history)\n", + "end\n", + "\n", + "simulate = function(name, start, init, expected, bias)\n", + " ticker_info = quandlget(name, from=start, api_key=api_key)\n", + " open_vals = ticker_info[\"Open\"].values\n", + " close_vals = ticker_info[\"Close\"].values\n", + " invested = [init]\n", + " \n", + " # The simulation stops once we've made a profit\n", + " day = 1\n", + " profitable = is_profitable(close_vals[day], invested, open_vals[1:length(invested)]) ||\n", + " is_profitable(open_vals[day+1], invested, open_vals[1:length(invested)])\n", + " while !profitable\n", + " expected_close = open_vals[day+1] * expected\n", + " todays_purchase = daily_investment(open_vals[day+1], expected_close, invested, open_vals[1:day])\n", + " invested = [invested; todays_purchase + bias]\n", + " # expected_profit = expected_close * sum(invested ./ open_vals[1:length(invested)]) - sum(invested)\n", + " day += 1\n", + " profitable = is_profitable(close_vals[day], invested, open_vals[1:length(invested)]) ||\n", + " is_profitable(open_vals[day+1], invested, open_vals[1:length(invested)])\n", + " end\n", + " \n", + " shares = sum(invested ./ open_vals[1:length(invested)])\n", + " max_profit = max(close_vals[day], open_vals[day+1])\n", + " profit = shares * max_profit - sum(invested)\n", + " return (invested, profit)\n", + "end\n", + "\n", + "sim_summary = function(investments, profit)\n", + " leverages = [sum(investments[1:i]) for i=1:length(investments)]\n", + " max_leverage = maximum(leverages) / investments[1]\n", + " println(\"Max leverage: $(max_leverage)\")\n", + " println(\"Days invested: $(length(investments))\")\n", + " println(\"Profit: $profit\")\n", + "end;" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's get some data and run a simulation! Our first test:\n", + "\n", + "- We'll invest 100 dollars in LMT, and expect that the stock will close up 1% every day. We'll invest $d_n$ + 10 dollars every day that we haven't turned a profit, and end the simulation once we've made a profit." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max leverage: 5.590373200042106\n", + "Days invested: 5\n", + "Profit: 0.6894803101560001\n" + ] + } + ], + "source": [ + "investments, profit = simulate(\"YAHOO/LMT\", Date(2015, 11, 29), 100, 1.01, 10)\n", + "sim_summary(investments, profit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The result: We need to invest 5.6x our initial position over a period of 5 days to make approximately .69¢\n", + "\n", + "- Now let's try the same thing, but we'll assume the stock closes up 2% instead." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max leverage: 1.854949900247809\n", + "Days invested: 25\n", + "Profit: 0.08304813163696423\n" + ] + } + ], + "source": [ + "investments, profit = simulate(\"YAHOO/LMT\", Date(2015, 11, 29), 100, 1.02, 10)\n", + "sim_summary(investments, profit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example, we only get up to a 1.85x leveraged position, but it takes 25 days to turn a profit of 8¢" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Summary\n", + "\n", + "We've defined an investment strategy that can tell us how much to invest when we know what the closing position of a stock will be. We can tweak the strategy to actually make money, but plenty of work needs to be done so that we can optimize the money invested.\n", + "\n", + "In the next post I'm going to post more information about some backtests and strategy tests on this strategy (unless of course this experiment actually produces a significant profit potential, and then I'm keeping it for myself)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Side note and disclaimer\n", + "\n", + "The claims made in this presentation about being able to guarantee making money are intended as a joke and do not constitute investment advice of any sort." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 0.4.2", + "language": "julia", + "name": "julia-0.4" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "0.4.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/develop_server.sh b/develop_server.sh new file mode 100755 index 0000000..8c2f27f --- /dev/null +++ b/develop_server.sh @@ -0,0 +1,103 @@ +#!/usr/bin/env bash +## +# This section should match your Makefile +## +PY=${PY:-python} +PELICAN=${PELICAN:-pelican} +PELICANOPTS= + +BASEDIR=$(pwd) +INPUTDIR=$BASEDIR/content +OUTPUTDIR=$BASEDIR/output +CONFFILE=$BASEDIR/pelicanconf.py + +### +# Don't change stuff below here unless you are sure +### + +SRV_PID=$BASEDIR/srv.pid +PELICAN_PID=$BASEDIR/pelican.pid + +function usage(){ + echo "usage: $0 (stop) (start) (restart) [port]" + echo "This starts Pelican in debug and reload mode and then launches" + echo "an HTTP server to help site development. It doesn't read" + echo "your Pelican settings, so if you edit any paths in your Makefile" + echo "you will need to edit your settings as well." + exit 3 +} + +function alive() { + kill -0 $1 >/dev/null 2>&1 +} + +function shut_down(){ + PID=$(cat $SRV_PID) + if [[ $? -eq 0 ]]; then + if alive $PID; then + echo "Stopping HTTP server" + kill $PID + else + echo "Stale PID, deleting" + fi + rm $SRV_PID + else + echo "HTTP server PIDFile not found" + fi + + PID=$(cat $PELICAN_PID) + if [[ $? -eq 0 ]]; then + if alive $PID; then + echo "Killing Pelican" + kill $PID + else + echo "Stale PID, deleting" + fi + rm $PELICAN_PID + else + echo "Pelican PIDFile not found" + fi +} + +function start_up(){ + local port=$1 + echo "Starting up Pelican and HTTP server" + shift + $PELICAN --debug --autoreload -r $INPUTDIR -o $OUTPUTDIR -s $CONFFILE $PELICANOPTS & + pelican_pid=$! + echo $pelican_pid > $PELICAN_PID + cd $OUTPUTDIR + $PY -m pelican.server $port & + srv_pid=$! + echo $srv_pid > $SRV_PID + cd $BASEDIR + sleep 1 + if ! alive $pelican_pid ; then + echo "Pelican didn't start. Is the Pelican package installed?" + return 1 + elif ! alive $srv_pid ; then + echo "The HTTP server didn't start. Is there another service using port" $port "?" + return 1 + fi + echo 'Pelican and HTTP server processes now running in background.' +} + +### +# MAIN +### +[[ ($# -eq 0) || ($# -gt 2) ]] && usage +port='' +[[ $# -eq 2 ]] && port=$2 + +if [[ $1 == "stop" ]]; then + shut_down +elif [[ $1 == "restart" ]]; then + shut_down + start_up $port +elif [[ $1 == "start" ]]; then + if ! start_up $port; then + shut_down + fi +else + usage +fi diff --git a/fabfile.py b/fabfile.py new file mode 100644 index 0000000..95796b5 --- /dev/null +++ b/fabfile.py @@ -0,0 +1,94 @@ +from fabric.api import * +import fabric.contrib.project as project +import os +import shutil +import sys +import SocketServer + +from pelican.server import ComplexHTTPRequestHandler + +# Local path configuration (can be absolute or relative to fabfile) +env.deploy_path = 'output' +DEPLOY_PATH = env.deploy_path + +# Remote server configuration +production = 'root@localhost:22' +dest_path = '/var/www' + +# Rackspace Cloud Files configuration settings +env.cloudfiles_username = 'my_rackspace_username' +env.cloudfiles_api_key = 'my_rackspace_api_key' +env.cloudfiles_container = 'my_cloudfiles_container' + +# Github Pages configuration +env.github_pages_branch = "gh-pages" + +# Port for `serve` +PORT = 8000 + +def clean(): + """Remove generated files""" + if os.path.isdir(DEPLOY_PATH): + shutil.rmtree(DEPLOY_PATH) + os.makedirs(DEPLOY_PATH) + +def build(): + """Build local version of site""" + local('pelican -s pelicanconf.py') + +def rebuild(): + """`clean` then `build`""" + clean() + build() + +def regenerate(): + """Automatically regenerate site upon file modification""" + local('pelican -r -s pelicanconf.py') + +def serve(): + """Serve site at http://localhost:8000/""" + os.chdir(env.deploy_path) + + class AddressReuseTCPServer(SocketServer.TCPServer): + allow_reuse_address = True + + server = AddressReuseTCPServer(('', PORT), ComplexHTTPRequestHandler) + + sys.stderr.write('Serving on port {0} ...\n'.format(PORT)) + server.serve_forever() + +def reserve(): + """`build`, then `serve`""" + build() + serve() + +def preview(): + """Build production version of site""" + local('pelican -s publishconf.py') + +def cf_upload(): + """Publish to Rackspace Cloud Files""" + rebuild() + with lcd(DEPLOY_PATH): + local('swift -v -A https://auth.api.rackspacecloud.com/v1.0 ' + '-U {cloudfiles_username} ' + '-K {cloudfiles_api_key} ' + 'upload -c {cloudfiles_container} .'.format(**env)) + +@hosts(production) +def publish(): + """Publish to production via rsync""" + local('pelican -s publishconf.py') + project.rsync_project( + remote_dir=dest_path, + exclude=".DS_Store", + local_dir=DEPLOY_PATH.rstrip('/') + '/', + delete=True, + extra_opts='-c', + ) + +def gh_pages(): + """Publish to GitHub Pages""" + rebuild() + local("ghp-import -b {github_pages_branch} {deploy_path}".format(**env)) + local("git push origin {github_pages_branch}".format(**env)) diff --git a/nest b/nest new file mode 160000 index 0000000..2cd60ed --- /dev/null +++ b/nest @@ -0,0 +1 @@ +Subproject commit 2cd60edff81da1f848b34bfc6209435c352c84a9 diff --git a/pelican-plugins b/pelican-plugins new file mode 160000 index 0000000..db9127f --- /dev/null +++ b/pelican-plugins @@ -0,0 +1 @@ +Subproject commit db9127f60fd65d3f1756bcb5ad477b89348b1c7f diff --git a/pelicanconf.py b/pelicanconf.py new file mode 100644 index 0000000..354e3a4 --- /dev/null +++ b/pelicanconf.py @@ -0,0 +1,44 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- # +from __future__ import unicode_literals + +AUTHOR = u'Bradlee Speice' +SITENAME = u'Bradlee Speice' +SITEURL = '' + +PATH = 'content' + +TIMEZONE = 'America/New_York' + +DEFAULT_LANG = u'en' + +# Feed generation is usually not desired when developing +FEED_ALL_ATOM = None +CATEGORY_FEED_ATOM = None +TRANSLATION_FEED_ATOM = None +AUTHOR_FEED_ATOM = None +AUTHOR_FEED_RSS = None + +# Blogroll +# LINKS = (('Pelican', 'http://getpelican.com/'), + # ('Python.org', 'http://python.org/'), + # ('Jinja2', 'http://jinja.pocoo.org/'), + # ('You can modify those links in your config file', '#'),) + +# Social widget +SOCIAL = (('Github', 'https://github.com/bspeice'), + ('LinkedIn', 'https://www.linkedin.com/in/bradleespeice'),) + +DEFAULT_PAGINATION = 10 + +# Uncomment following line if you want document-relative URLs when developing +#RELATIVE_URLS = True + +PLUGIN_PATHS = ['pelican-plugins/'] +PLUGINS = ['liquid_tags.notebook'] +NOTEBOOK_DIR = 'notebooks' + +THEME='nest' +#NEST_INDEX_HEADER_TITLE="Bradlee Speice" +NEST_INDEX_HEADER_SUBTITLE="Exploring the intersection of Computer Science and Financial Engineering" +NEST_HEADER_LOGO="images/logo.svg" diff --git a/publishconf.py b/publishconf.py new file mode 100644 index 0000000..3fa05f0 --- /dev/null +++ b/publishconf.py @@ -0,0 +1,24 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- # +from __future__ import unicode_literals + +# This file is only used if you use `make publish` or +# explicitly specify it as your config file. + +import os +import sys +sys.path.append(os.curdir) +from pelicanconf import * + +SITEURL = 'https://bspeice.github.io' +RELATIVE_URLS = False + +FEED_ALL_ATOM = 'feeds/all.atom.xml' +CATEGORY_FEED_ATOM = 'feeds/%s.atom.xml' + +DELETE_OUTPUT_DIRECTORY = True + +# Following items are often useful when publishing + +#DISQUS_SITENAME = "" +#GOOGLE_ANALYTICS = ""