Additional historical return data:

- Return 5-year rolling returns in efficient frontier portfolios
- Return 5-year rolling returns for assets in /performance route
- Return full historical returns for assets in /performance route

Author: brandonparsons

lib/assets.py

@@ -7,6 +7,8 @@
 import os
 import json
 import datetime
+from   dateutil.relativedelta import relativedelta
+
 import pandas           as pd
 import pandas.io.data   as web
 import numpy            as np
@@ -32,6 +34,9 @@ def asset_json():
 def mean_return_json():
     return _mean_returns().to_json()
 
+def five_year_mean_return_json():
+    return _five_year_mean_returns().to_json()
+
 def reverse_optimized_returns_json():
     return _reverse_optimized_returns().to_json()
 
@@ -75,6 +80,17 @@ def _mean_returns():
     means           = means.sort_index()
     return means
 
+def _five_year_mean_returns():
+    today           = datetime.date.today()
+    five_years_ago  = ( today - relativedelta(years=5) )
+
+    five_year_returns   = _monthly_returns()[five_years_ago:today]
+    means               = five_year_returns.mean()
+    means               = means.sort_index()
+    means.index         = _replacement_values_for_tickers()
+    means               = means.sort_index()
+    return means
+
 def _std_dev_returns():
     stds         = _monthly_returns().std()
     stds         = stds.sort_index()

lib/efficient_frontier.py

@@ -22,22 +22,22 @@
 # PUBLIC API #
 ##############
 
-def efficient_frontier(asset_ids, mean_returns, covariance_matrix):
+def efficient_frontier(asset_ids, asset_returns, historical_returns, covariance_matrix):
     """
     Generates and formats an efficient frontier for a given set of asset ids,
-    and their corresponding mean returns and covariances. ID's and the columns
-    / indexes of means/covars are expected to match.
+    and their corresponding mean returns and covariances. ID's and the columns/indexes of means/covars are expected to match.
     :param asset_ids: array of asset ID's (e.g. INTL-STOCK)
-    :param mean_returns: numpy array of the mean returns corresponding to passed in asset_ids
+    :param asset_returns: numpy array of the relevant returns corresponding to passed in asset_ids - typically the market implied returns
+    :param historical_returns: numpy array of the historical mean returns corresponding to passed in asset_ids
     :param covariance_matrix: numpy matrix of the covariances corresponding to passed in asset_ids
     """
 
     # Generate the frontier
-    rfr = risk_free_rate.monthly_risk_free_rate()
-    frontier = _solve_frontier(mean_returns, covariance_matrix, rfr)
+    rfr      = risk_free_rate.monthly_risk_free_rate()
+    frontier = _solve_frontier(asset_returns, covariance_matrix, rfr)
 
-    # Format frontier
-    formatted = _format_frontier(frontier, asset_ids)
+    # Format the frontier, pass in the historical returns so that historical portfolio returns can be calculated
+    formatted = _format_frontier(frontier, asset_ids, historical_returns)
 
     # Sort & cull
     culled = _sort_and_cull_frontier(formatted)
@@ -63,7 +63,7 @@ def _sort_and_cull_frontier(frontier):
 
     return culled_frontier
 
-def _format_frontier(frontier, asset_ids):
+def _format_frontier(frontier, asset_ids, historical_returns):
     frontier_means      = frontier[0]
     frontier_variances  = frontier[1]
     frontier_weights    = frontier[2]
@@ -75,10 +75,11 @@ def _format_frontier(frontier, asset_ids):
         formatted_frontier.append({
             "allocation": dict(zip(asset_ids, rounded_portfolio_allocation)),
             "statistics": {
-            "mean_return":              this_portfolios_mean,
-            "std_dev":                  this_portfolios_std_dev,
-            "annual_nominal_return":    _annual_nominal_return(this_portfolios_mean),
-            "annual_std_dev":           _annual_std_dev(this_portfolios_std_dev),
+                "mean_return":              this_portfolios_mean,
+                "std_dev":                  this_portfolios_std_dev,
+                "annual_nominal_return":    _annual_nominal_return(this_portfolios_mean),
+                "annual_std_dev":           _annual_std_dev(this_portfolios_std_dev),
+                "annual_alternate_return":  _annual_nominal_return(_port_mean(portfolio_allocation, historical_returns))
             }
         })
     return formatted_frontier
@@ -89,7 +90,7 @@ def _annual_nominal_return(monthly_mean_return, nominal=True):
     """
     annualized = math.pow((1 + monthly_mean_return), 12) - 1
     if not nominal:
-	annualized += 0.02 # Assume 2% inflation
+        annualized += 0.02 # Assume 2% inflation ## This is NOT getting called by default
     return annualized
 
 def _annual_std_dev(monthly_std_dev):

server.py

@@ -102,10 +102,16 @@ def cholesky_decomposition(asset_ids):
 
     return df.drop(asset_ids_to_eliminate, axis=0).drop(asset_ids_to_eliminate, axis=1)
 
-def mean_returns(asset_ids, returns_source="reverse_optimized_returns"):
+def mean_returns(asset_ids, returns_source):
+    """
+    Grabs mean return data, and returns a dataframe with only the relavant columns
+    :param asset_ids: array of asset ID's (e.g. INTL-STOCK)
+    :param returns_source: Which data we are interested in - one of: 'reverse_optimized_returns', 'mean_returns', 'five_year_returns'
+    """
+
     # No need to memoize this unless jsonify is taking lots of time - data from redis
     # Mean returns is a *Series*
-    json = redis_conn.get(returns_source) # other option: 'mean_returns'
+    json = redis_conn.get(returns_source)
     df   = pd.io.json.read_json(json, typ='series')
 
     if len(asset_ids) > 0:
@@ -130,15 +136,19 @@ def std_dev_returns(asset_ids):
     else:
         return df
 
-def build_efficient_frontier_for(asset_ids):
+def build_efficient_frontier_for(asset_ids, use_market_implied_returns=True):
     md5Hash = hashlib.md5("-".join(asset_ids)).hexdigest()
-    cache_key = "efficient_frontier/" + md5Hash
+    cache_key = "efficient_frontier/" + md5Hash + "/" + ("implied" if use_market_implied_returns else "historical")
     val = cache.get(cache_key)
     if val is None:
         app.logger.info("[Cache Miss] Building efficient frontier for: %s" % asset_ids)
-        means    = mean_returns(asset_ids)
-        covars   = covariance_matrix(asset_ids)
-        frontier = efficient_frontier(asset_ids, means, covars)
+        if use_market_implied_returns:
+            asset_returns = mean_returns(asset_ids, returns_source="reverse_optimized_returns")
+        else:
+            asset_returns = mean_returns(asset_ids, returns_source="mean_returns")
+        covars = covariance_matrix(asset_ids)
+        historical_returns = mean_returns(asset_ids, returns_source="five_year_returns")
+        frontier = efficient_frontier(asset_ids, asset_returns, historical_returns, covars)
         # FIXME: You are json dumping to store in memcache, marshalling to return
         # to request, then flask-jsonifying back again. Better way? For later......
         cache.set(cache_key, json.dumps(frontier))
@@ -191,7 +201,9 @@ def performance_route():
     asset_ids = get_key_in_json('asset_ids', request.json)
     asset_ids.sort()
     df = pd.DataFrame()
-    df['mean'] = mean_returns(asset_ids)
+    df['mean'] = mean_returns(asset_ids, returns_source="reverse_optimized_returns")
+    df['historical_mean'] = mean_returns(asset_ids, returns_source="mean_returns")
+    df['five_year_mean'] = mean_returns(asset_ids, returns_source="five_year_returns")
     df['std_dev'] = std_dev_returns(asset_ids)
     return Response(df.transpose().to_json(), mimetype='application/json')
 

update.py

@@ -9,6 +9,7 @@
 from lib.etfs         import quotes_json                      as quotes_json
 from lib.assets       import asset_json                       as asset_json
 from lib.assets       import mean_return_json                 as mean_return_json
+from lib.assets       import five_year_mean_return_json       as five_year_mean_return_json
 from lib.assets       import reverse_optimized_returns_json   as reverse_optimized_returns_json
 from lib.assets       import std_dev_returns_json             as std_dev_returns_json
 from lib.assets       import covariance_matrix_json           as covariance_matrix_json
@@ -40,8 +41,9 @@ def _get_redis_connection():
 pipe.set(name='inflation',                  value=inflation_json())
 pipe.set(name='real_estate',                value=real_estate_json())
 pipe.set(name='quotes',                     value=quotes_json())
-pipe.set(name='mean_returns',               value=mean_return_json())
-pipe.set(name='reverse_optimized_returns',  value=reverse_optimized_returns_json())
+pipe.set(name='mean_returns',               value=mean_return_json()) # Historical returns (all data)
+pipe.set(name='five_year_returns',          value=five_year_mean_return_json()) # Rolling 5 year returns
+pipe.set(name='reverse_optimized_returns',  value=reverse_optimized_returns_json()) # Market implied returns
 pipe.set(name='std_dev_returns',            value=std_dev_returns_json())
 pipe.set(name='covariance_matrix',          value=covariance_matrix_json())
 pipe.set(name='cholesky_decomposition',     value=cholesky_decomposition_json())