def test_case(of, sd, ed, ret, avg, std, sharp, fin, sv=1000000): portvals = compute_portvals(orders_file=of, start_val=sv) if not isinstance(portvals, pd.DataFrame): print "Test FAILED portvals not a pd.DataFrame, type: {}".format( type(portvals)) return else: portvals = portvals[portvals.columns[0]] # just get the first column cr, adr, sddr, sr = compute_portfolio_stats(portvals) act = [cr, adr, sddr, sr, portvals[-1]] ex = [ret, avg, std, sharp, fin] if pd.Timestamp(sd) != portvals.index[0]: print "Test FAILED start-date: {}, expected: {}, actual: {}".format( of, sd, portvals.index[0]) return if pd.Timestamp(ed) != portvals.index[-1]: print "Test FAILED end-date: {}, expected: {}, actual: {}".format( of, ed, portvals.index[-1]) return if np.allclose(ex, act): print "Test PASSED: {}".format(of) else: print "Test FAILED: {}, expected: {}, actual: {}".format(of, ex, act)
def optimize_portfolio(sd=dt.datetime(2008,1,1), ed=dt.datetime(2009,1,1), syms=['GOOG','AAPL','GLD','XOM'], gen_plot=False): # Read in adjusted closing prices for given symbols, date range dates = pd.date_range(sd, ed) prices_all = get_data(syms, dates) # automatically adds SPY prices = prices_all[syms] # only portfolio symbols prices_SPY = prices_all['SPY'] # only SPY, for comparison later # find the allocations for the optimal portfolio # note that the values here ARE NOT meant to be correct for a test case sv = 1000000 rfr = 0.0 sf = 252.0 allocs = find_optimal_allocations(prices, sv, rfr, sf) # add code here to find the allocations port_val = analysis.get_portfolio_value(prices,allocs,sv) cr, adr, sddr, sr = analysis.compute_portfolio_stats(port_val, rfr, sf) # Compare daily portfolio value with SPY using a normalized plot if gen_plot: # add code to plot here df_temp = pd.concat([port_val, prices_SPY], keys=['Portfolio', 'SPY'], axis=1) pass return allocs, cr, adr, sddr, sr
def sharpe_maximizer(allocs, prices): """Optimization function to be passed to the optimizer. Parameters ---------- prices: daily prices for each stock in portfolio allocs: Allocation for each portfolio component Returns ------- sharpe_ratio: Negative sharpe ratio so the minimizer finds the maximum """ #Get portfolio statistics cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = compute_portfolio_stats( prices, allocs) return -sharpe_ratio
def optimize_portfolio(sd, ed, syms, gen_plot): """ :param sd: dt.datetime :param ed: dt.datetime :param syms: list of strings :param gen_plot: boolean :return: tuple (allocs, cr, adr, sddr, sr) """ n = len(syms) dates = pd.date_range(sd, ed) prices_all = get_data(syms, dates) prices = prices_all[syms] prices_SPY = prices_all['SPY'] prices = prices.ffill() prices = prices.bfill() normed = prices / prices.iloc[0] x0 = np.ones(n) / n bounds = [(0.0, 1.0) for i in range(n)] constraints = ({'type': 'eq', 'fun': lambda x: 1 - np.sum(x)}) allocs = minimize(f, x0, args=(normed, 0.0, 252.0), method='SLSQP', bounds=bounds, constraints=constraints).x alloced = normed * allocs port_val = alloced.sum(axis=1) cr, adr, sddr, sr = compute_portfolio_stats(port_val=port_val) if gen_plot: df_temp = pd.concat([port_val, prices_SPY], keys=['Portfolio', 'SPY'], axis=1) df_temp = df_temp / df_temp.iloc[0] plot_data(df_temp, "Daily Portfolio Value and SPY") return allocs, cr, adr, sddr, sr
def optimize_portfolio(sd=dt.datetime(2008, 1, 1), ed=dt.datetime(2009, 1, 1), syms=['GOOG', 'AAPL', 'GLD', 'XOM'], gen_plot=False): """Simulate and optimize portfolio allocations.""" # Read in adjusted closing prices for given symbols, date range dates = pd.date_range(sd, ed) prices_all = get_data(syms, dates) # automatically adds SPY prices = prices_all[syms] # only portfolio symbols prices_SPY = prices_all['SPY'] # only SPY, for comparison later # Get optimal allocations for sharpe ration and tehn compute portfolio stats - THE DIFFERENCE FROM MC1_P1 allocs = find_optimal_allocations(prices) allocs = allocs / np.sum( allocs) # normalize allocations, if they don't sum to 1.0 # Get daily portfolio value (already normalized since we use default start_val=1.0) port_val = compute_portfolio_value(prices, allocs) # Get portfolio statistics (note: std_daily_ret = volatility) cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = compute_portfolio_stats( prices, allocs) # Print statistics print "Start Date:", start_date print "End Date:", end_date print "Symbols:", symbols print "Optimal allocations:", allocs print "Sharpe Ratio:", sharpe_ratio print "Volatility (stdev of daily returns):", std_daily_ret print "Average Daily Return:", avg_daily_ret print "Cumulative Return:", cum_ret # Compare daily portfolio value with normalized SPY df_temp = pd.concat([port_val, prices_all['SPY']], keys=['Portfolio', 'SPY'], axis=1) plot_normalized_data(df_temp, "Daily portfolio value and SPY") return allocs, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio
def optimize_portfolio(sd=dt.datetime(2008,1,1), ed=dt.datetime(2009,1,1), \ syms=['GOOG','AAPL','GLD','XOM'], gen_plot=False): # Read in adjusted closing prices for given symbols, date range dates = pd.date_range(sd, ed) prices_all = get_data(syms, dates) # automatically adds SPY prices = prices_all[syms] # only portfolio symbols prices_SPY = prices_all['SPY'] # only SPY, for comparison later sv = 1000000 # find the allocations for the optimal portfolio # note that the values here ARE NOT meant to be correct for a test case guess = [] for symbols in syms: guess.append(1.0 / len(syms)) bounds = [] for symbols in syms: bounds.append((0.0, 1.0)) constraints = ({'type': 'eq', 'fun': lambda x: 1.0 - np.sum(x)}) res = spo.minimize(volatility, guess, args=(prices, syms), bounds=bounds, constraints=constraints) allocs = res.x ############################################################################################################ # CODE FROM analysis.py ############################################################################################################ # normalized data in "normalized_prices" dataframe normalized_prices = prices.copy() #print normalized_prices[0:11] for symbol in normalized_prices: normalized_prices[symbol] = (normalized_prices[symbol]) / ( prices.at[prices.first_valid_index(), symbol]) # normalize the SPY prices normalized_prices_SPY = prices_SPY.copy() # normalized SPY for comparison normalized_prices_SPY = (normalized_prices_SPY) / prices_SPY[0] # Get daily portfolio value allocs_prices = normalized_prices.copy() i = 0 # multiply by allocation for symbols in prices: allocs_prices[symbols] = normalized_prices[symbols] * allocs[i] i = i + 1 # multiply by sv to get pos_val (position value) pos_val = allocs_prices.copy() for symbols in pos_val: pos_val[symbols] = pos_val[symbols] * sv # get daily portfolio value port_val = pd.DataFrame port_val = allocs_prices.sum(axis=1) # Get portfolio statistics (note: std_avg_daily_ret = volatility) cr, adr, sddr, sr = compute_portfolio_stats(port_val, allocs, rfr=0.0, sf=252.0) # Compare daily portfolio value with SPY using a normalized plot if gen_plot: # add code to plot here df_temp = pd.concat([port_val, normalized_prices_SPY], keys=['Portfolio', 'SPY'], axis=1) plot_data(df_temp) pass ########################################################################################################## ########################################################################################################## return allocs, cr, adr, sddr, sr