def simulate(startdate, enddate, ls_symbols, ls_alloc): dt_timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(startdate, enddate, dt_timeofday) c_dataobj = da.DataAccess('Yahoo', cachestalltime=0) ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) for s_key in ls_keys: d_data[s_key] = d_data[s_key].fillna(method='ffill') d_data[s_key] = d_data[s_key].fillna(method='bfill') d_data[s_key] = d_data[s_key].fillna(1.0) na_price = d_data['close'].values na_normalized_price = na_price / na_price[0, :] na_port_price = np.sum(ls_alloc * na_normalized_price, 1) na_daily_rets = na_port_price.copy() tsu.returnize0(na_daily_rets) vol = np.std(na_daily_rets) daily_ret = np.average(na_daily_rets) sharpe_ratio = np.sqrt(252) * daily_ret / vol cum_ret = na_port_price[-1] return vol, daily_ret, sharpe_ratio, cum_ret
def simulate(dt_start, dt_end, ls_symbols, ls_allocation): ''' Simulate function ''' # Get closing prices (hours=16) dt_timeofday = dt.timedelta(hours=16) # Get a list of trading days. ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) # Open Yahoo data set and read (adjusted) closing price ls_keys = ['close'] c_dataobj = da.DataAccess('Yahoo') ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) # Compute portfolio value tmp = d_data['close'].values.copy() d_normal = tmp / tmp[0, :] alloc = np.array(ls_allocation).reshape(4, 1) portVal = np.dot(d_normal, alloc) # Compute daily returns dailyVal = portVal.copy() tsu.returnize0(dailyVal) # Compute statistics daily_ret = np.mean(dailyVal) vol = np.std(dailyVal) sharpe = np.sqrt(252) * daily_ret / vol cum_ret = portVal[portVal.shape[0] - 1][0] # return return vol, daily_ret, sharpe, cum_ret
def compute_stats(ts_daily_value): # Normalize the values to start at 1.0 and see # the daily values relative to the initial value ts_norm_value = ts_daily_value / ts_daily_value[0] total_norm_return = ts_norm_value[len(ts_norm_value) - 1] # calculate the daily returns # ret(t) = (price(t)/price(t-1)) - 1 # returnize works on numpy arrays and not in dataframes na_daily_return = ts_norm_value.values tsu.returnize0(na_daily_return) mean_rets = np.mean(na_daily_return) volatility = np.std(na_daily_return) # hardcode 252 instead of using actual year daycount to keep it comparable sharpe = math.sqrt(252) * mean_rets / volatility return { "avg_day_ret": mean_rets, "volatility": volatility, "sharpe": sharpe, "total_return": total_norm_return, "day_ret": na_daily_return, }
def getPortfolioStats(na_price, allocation): # Getting the numpy ndarray or pandas dataframe of close prices. #Normalize the prices according to the first day. The first row for each stock should have a value of 1.0 at this point. # Normalizing the prices to start at 1 and see relative returns if type(na_price) == type(pd.DataFrame()): na_price = na_price.values na_normalized_price = na_price / na_price[0,:] else: na_normalized_price = na_price / na_price[0] #Multiply each colunpmn by the allocation to the corresponding equity. allocatedprice = na_normalized_price * allocation #Sum each row for each day. That is your cumulative daily portfolio value. cum_daily_port_value = allocatedprice cum_ret = cum_daily_port_value[-1] #daily return daily_port_returns = cum_daily_port_value.copy() tsu.returnize0(daily_port_returns) vol = np.std(daily_port_returns) daily_ret = np.average(daily_port_returns) sharpe = tsu.get_sharpe_ratio(daily_port_returns) #tsu.sharpeRatio(cum_daily_port_value) return cum_ret, vol, daily_ret, sharpe, na_normalized_price
def simulate(dt_start, dt_end, ls_symbols, ls_allocation): # Formatting the date timestamps dt_timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) # Open the dataset and read in the closing price ls_keys = ['close'] c_dataobj = da.DataAccess('Yahoo') ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) # Calculate the portfolio value temp = d_data['close'].values.copy() d_normal = temp / temp[0, :] alloc = np.array(ls_allocation).reshape(4, 1) portVal = np.dot(d_normal, alloc) # Caluclate the daily returns dailyVal = portVal.copy() tsu.returnize0(dailyVal) # Calculate statistics daily_ret = np.mean(dailyVal) vol = np.std(dailyVal) sharpe = np.sqrt(NUM_TRADING_DAYS) * daily_ret / vol cum_ret = portVal[portVal.shape[0] - 1][0] return vol, daily_ret, sharpe, cum_ret
def calculateMetrics(prices, verbosity=2): """ Compute metrics of a series of prices @param prices: a series of prices. the dates are assumed consecutive and in increasing order @return stdDailyRets, avgDailyRets, sharpeRatio, cumRet """ dailyReturns = copy(prices) returnize0(dailyReturns) stdDailyRets = np.std(dailyReturns) avgDailyRets = np.mean(dailyReturns) sharpeRatio = avgDailyRets / stdDailyRets * np.sqrt(252) cumRet = prices[-1] / prices[0] if verbosity >= 2: print '-------- Portfolio Prices ------------\n', prices print '\n-------- Portfolio Returns ------------\n', dailyReturns if verbosity >= 1: print '\n--------- Metrics -------------' print 'Final portfolio value =', prices[-1] print 'Date Range:', prices.index[0], 'to', prices.index[-1] print 'Sharpe Ratio =', sharpeRatio print 'Total return =', cumRet print 'Standard deviation of daily returns =', stdDailyRets print 'Average daily returns =', avgDailyRets return stdDailyRets, avgDailyRets, sharpeRatio, cumRet
def simulate_failed2(date_start, date_end, symbols, allocations): '''rebalances daily''' date_timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(date_start, date_end, date_timeofday) c_dataobj = da.DataAccess('Yahoo') ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] ldf_data = c_dataobj.get_data(ldt_timestamps, symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) na_price = d_data['close'].values na_normalized_price = na_price / na_price[0, :] na_rets = na_normalized_price.copy() print na_rets seclist = {} for x in range(len(allocations)): seclist[x] = na_rets[:,x] * allocations[x] print seclist for sec in seclist.iterkeys(): tsu.returnize0(seclist[sec]) # tsu.returnize0(na_alloc) # # print na_alloc print seclist portrets = [] for index in range(len(seclist[0])): tempsum = 0.0 print "Index %s" % index for sec in seclist.iterkeys(): print "sec %s" % sec if np.isnan(seclist[sec][index]): print "Passing: [%s] [%s]" % (sec, index) pass else: tempsum += seclist[sec][index] portrets.append(tempsum) na_portrets = np.array(portrets) na_port_total = np.prod(na_portrets + 1) print na_portrets #na_portrets = np.sum(na_rets, axis = 1) #na_port_total = np.cumprod(portrets + 1) rf_rate = 0 vol = np.std(na_portrets) daily_ret = np.average(na_portrets) cum_ret = na_port_total sharpe = np.sqrt(252)*((daily_ret - rf_rate)/vol) return vol, daily_ret, sharpe, cum_ret
def compare(start_day, start_month, start_year, end_day, end_month, end_year, ls_symbols): # Start and End date of the charts dt_start = dt.datetime(start_year, start_month, start_day) dt_end = dt.datetime(end_year, end_month, end_day) # We need closing prices so the timestamp should be hours=16. dt_timeofday = dt.timedelta(hours=16) # Get a list of trading days between the start and the end. ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) # Creating an object of the dataaccess class with Yahoo as the source. c_dataobj = da.DataAccess('Yahoo') # Keys to be read from the data, it is good to read everything in one go. ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] # Reading the data, now d_data is a dictionary with the keys above. # Timestamps and symbols are the ones that were specified before. ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) # Filling the data for NAN for s_key in ls_keys: d_data[s_key] = d_data[s_key].fillna(method='ffill') d_data[s_key] = d_data[s_key].fillna(method='bfill') d_data[s_key] = d_data[s_key].fillna(1.0) # Getting the numpy ndarray of close prices. na_price = d_data['close'].values # Normalizing the prices to start at 1 and see relative returns na_normalized_price = na_price / na_price[0, :] # Plotting the prices with x-axis=timestamps plt.clf() fig1 = plt.figure() plt.plot(ldt_timestamps, na_normalized_price) plt.legend(ls_symbols) plt.ylabel('Normalized Close') plt.xlabel('Date') fig1.autofmt_xdate(rotation=45) plt.savefig('normalized_returns.jpg', format='jpg') # Copy the normalized prices to a new ndarry to find returns. na_rets = na_normalized_price.copy() # Calculate the daily returns of the prices. (Inplace calculation) # returnize0 works on ndarray and not dataframes. tsu.returnize0(na_rets) # Plotting the scatter plot of daily returns between Company-1 & Company-2 plt.clf() fig2 = plt.figure() plt.scatter(na_rets[:, 0], na_rets[:, 1], c='blue') plt.ylabel(ls_symbols[0]) plt.xlabel(ls_symbols[1]) plt.savefig('scatter1v2.jpg', format='jpg')
def portfolio_analyzer(na_port_vals): # Normalizing the prices to start at 1 and see relative returns # na_vals = ls_port_vals.values na_normalized_vals = na_port_vals / na_port_vals[0] print(na_normalized_vals) # Numpy matrix of filled data values na_portrets = na_normalized_vals.copy() tsu.returnize0(na_portrets) port_length = len(na_portrets) print("Data Points: ") print(port_length) port_length = 252 port_avg = np.average(na_portrets) port_div = np.std(na_portrets) port_sharp = math.sqrt(port_length)*port_avg/port_div # Estimate portfolio returns print("Days: ") print(port_length) print("Sharp Ratio:") print(port_sharp) print("Stdev:") print(port_div) print("Avg Ret:") print(port_avg)
def calcStats(na_normalized_price, lf_allocations): #Calculate cumulative daily portfolio value #row-wise multiplication by weights na_weighted_price = na_normalized_price * lf_allocations; #row-wise sum na_portf_value = na_weighted_price.copy().sum(axis=1); #Calculate daily returns on portfolio na_portf_rets = na_portf_value.copy() tsu.returnize0(na_portf_rets); #Calculate volatility (stdev) of daily returns of portfolio f_portf_volatility = np.std(na_portf_rets); #Calculate average daily returns of portfolio f_portf_avgret = np.mean(na_portf_rets); #Calculate portfolio sharpe ratio (avg portfolio return / portfolio stdev) * sqrt(252) f_portf_sharpe = (f_portf_avgret / f_portf_volatility) * np.sqrt(250); #Calculate cumulative daily return #...using recursive function def cumret(t, lf_returns): #base-case if t==0: return (1 + lf_returns[0]); #continuation return (cumret(t-1, lf_returns) * (1 + lf_returns[t])); f_portf_cumrets = cumret(na_portf_rets.size - 1, na_portf_rets); return [f_portf_volatility, f_portf_avgret, f_portf_sharpe, f_portf_cumrets, na_portf_value];
def simulate(startDate, endDate, tickers, allocations): tradingDays = getTradingDays(startDate, endDate) numberOfTradingDays = len(tradingDays) # Keys to be read from the data, it is good to read everything in one go. keys = ['close'] dataObject = da.DataAccess('Yahoo') data = dataObject.get_data(tradingDays, tickers, keys) # assuming there is at least one ticker finalNormalizedData = np.zeros(numberOfTradingDays) for x in range(0, len(tickers)): # get the data for the ticker normalizedData = data[0].values[:,x] # normalize the data normalizedData = normalizedData / normalizedData[0] # allocate the appropriate percentage normalizedData = normalizedData * allocations[x] # add the normalizedData to the finalized array finalNormalizedData = finalNormalizedData + normalizedData cum_ret = finalNormalizedData[numberOfTradingDays - 1]\ # calculate average daily return tsu.returnize0(finalNormalizedData) volatility = np.std(finalNormalizedData) avg_daily_return = np.mean(finalNormalizedData) sharpe = (avg_daily_return * 252 - 0) / ( volatility * sqrt(252) ) return(volatility, avg_daily_return, sharpe, cum_ret)
def do_benchmark_calculations(start_date, end_date, ls_symbols): # We need closing prices so the timestamp should be hours=16. dt_timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(start_date, end_date, dt_timeofday) c_dataobj = da.DataAccess('Yahoo', cachestalltime=0) ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) df_rets = d_data['close'] df_rets = df_rets.fillna(method='ffill') df_rets = df_rets.fillna(method='bfill') df_rets = df_rets.fillna(1.0) na_price = df_rets.values.copy() normalized_price = na_price / na_price[0:1] tsu.returnize0(normalized_price) cummulative_return = np.cumprod(normalized_price + 1)[-1] avg = normalized_price.mean() std = normalized_price.std() print "benchmark sharpe_ratio:", avg / std * math.sqrt(252) print "benchmark total return:", cummulative_return print "benchmark standard deviation", std print "benchmark average return", avg
def process_benchmark(dt_start, dt_end, benchmark_symbol): ldt_timestamps = du.getNYSEdays(dt_start, dt_end + dt.timedelta(days=1), dt.timedelta(hours=16)) dt_start = ldt_timestamps[0] dt_end = ldt_timestamps[-1] dataobj = da.DataAccess('Yahoo') ls_keys = ['close'] ldf_data = dataobj.get_data(ldt_timestamps, [benchmark_symbol], ls_keys) d_data = dict(zip(ls_keys, ldf_data)) for s_key in ls_keys: d_data[s_key] = d_data[s_key].fillna(method='ffill') d_data[s_key] = d_data[s_key].fillna(method='bfill') d_data[s_key] = d_data[s_key].fillna(1.0) # Extract the data/values na_prices = d_data['close'].values # Normalizing the prices to start at 1 and see relative returns na_normalized_price = na_prices / na_prices[0, :] na_benchmark_returns = na_normalized_price.copy() tsu.returnize0(na_benchmark_returns) # Calculate values statistics f_benchmark_avg_return = np.mean(na_benchmark_returns) total_ret_benchmark = np.prod(na_benchmark_returns + 1.0) stddev_benchmark = np.std(na_benchmark_returns) sharpe_benchmark = math.sqrt( 252.0) * f_benchmark_avg_return / stddev_benchmark return dt_start, dt_end, sharpe_benchmark, total_ret_benchmark, stddev_benchmark, f_benchmark_avg_return
def simulate(begindate, enddate, tickers, weightings): dt_delta = date.timedelta(hours=16) ldt_timestamps = dateUtil.getNYSEdays(begindate, enddate, dt_delta) ls_keys = ['close'] c_dataobj = dataAccess.DataAccess('Yahoo') ldf_data = c_dataobj.get_data(ldt_timestamps, tickers, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) # Grab the closing values of every stock temp = d_data['close'].values.copy() # Normalize those values with respect to the initial value d_normal = temp / temp[0, :] alloc = numpy.array(weightings).reshape(4, 1) # Multiply the normalized daily changes by the allocation # This gives us an array reflecting the amount allocated to each stock portVal = numpy.dot(d_normal, alloc) dailyVal = portVal.copy() tsUtil.returnize0(dailyVal) daily_ret = numpy.mean(dailyVal) volatility = numpy.std(dailyVal) sharpe = numpy.sqrt(252) * daily_ret / volatility total_returns = portVal[portVal.shape[0] - 1][0] return volatility, daily_ret, sharpe, total_returns
def analyse(na_close, ls_allocations): # Normalize the close price na_norm_close = na_close / na_close[0, :] # Get weighted daily returns weighted_daily_close = np.dot(na_norm_close, ls_allocations) # Copy the weighted daily close to a new ndarray to find returns port_daily_ret = weighted_daily_close.copy() # Calculate daily returns of the portfolio close price tsu.returnize0(port_daily_ret) # Get average portfolio daily returns daily_ret = np.average(port_daily_ret) # Calculate volatility of average weighted daily returns vol = np.std(port_daily_ret) # Calculate Sharpe Ratio k = math.sqrt(252) sharpe = k * (daily_ret/vol) # Calculate Cumulative Return cum_ret = np.dot((na_close[-1]/na_close[0]),ls_allocations) return vol, daily_ret, sharpe, cum_ret
def computestats(self): #nothing fancy, just use library functions to compute daily returns, standard deviation and average of daily returns self.daily_portfolio_val /= self.daily_portfolio_val[0] daily_portfolio_return = tsu.returnize0(self.daily_portfolio_val) avg = np.mean(daily_portfolio_return) stdev = np.std(daily_portfolio_return) SR = avg / stdev * math.sqrt(252) total_return = 1 for ret in range(1,len(daily_portfolio_return)): total_return = total_return * (1 + daily_portfolio_return[ret]) spy_ldf_data = self.dataobj.get_data(self.ldt_timestamps, ['SPY'], ls_keys) #ldf_data_2008 = dataobj.get_data(ldt_timestamps, ls_symbols_2008, ls_keys) spy_d_data = dict(zip(ls_keys, spy_ldf_data)) close_prices = spy_d_data['close'].copy() close_prices = close_prices.fillna(method='ffill') close_prices = close_prices.fillna(method='bfill') na_rets_spy = close_prices['SPY'].values daily_spy_return = tsu.returnize0(na_rets_spy) print "AVG return: ",avg, "stdev of return: ", stdev, "sharp ratio: ", SR , "total cumulative return", total_return plt.clf() plt.plot(self.ldt_timestamps, daily_portfolio_return) plt.plot(self.ldt_timestamps, daily_spy_return) plt.legend(self.ls_symbols) plt.ylabel('Return comparison') plt.xlabel('Date')
def simulate(dt_start, dt_end, ls_symbols, lf_weights): # We need closing prices so the timestamp should be hours=16. dt_timeofday = dt.timedelta(hours=16) # Get a list of trading days between the start and the end. ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) # Creating an object of the dataaccess class with Yahoo as the source. c_dataobj = da.DataAccess('Yahoo') # Keys to be read from the data, it is good to read everything in one go. ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] # Reading the data, now d_data is a dictionary with the keys above. # Timestamps and symbols are the ones that were specified before. ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) # Filling the data for NAN for s_key in ls_keys: d_data[s_key] = d_data[s_key].fillna(method='ffill') d_data[s_key] = d_data[s_key].fillna(method='bfill') d_data[s_key] = d_data[s_key].fillna(1.0) # Getting the numpy ndarray of close prices. na_price = d_data['close'].values #print "Close prices:\n", na_price # Normalizing the prices to start at 1 and see relative returns na_normalized_price = na_price / na_price[0, :] # Copy the normalized prices to a new ndarry to find returns. na_rets = na_normalized_price.copy() #print "normalized returns:\n", na_rets # Calculate value of portfolio portfolio_daily_value = np.sum(na_rets * lf_weights, axis=1) #print "Portfolio daily value: ", portfolio_daily_value # Cumulative return is the last day's value cum_ret = portfolio_daily_value[-1] # Calculate the daily returns of the prices. (Inplace calculation) # returnize0 works on ndarray and not dataframes. tsu.returnize0(portfolio_daily_value) #print "daily returns \n", portfolio_daily_value # Calculate volatility as portfolio's standart deviation vol = np.std(portfolio_daily_value) # Calculate daily return daily_ret = np.mean(portfolio_daily_value, axis=0) # Calculate Sharpe ratio with assumption that risk free rate is 0 # and year has 252 trading days risk_free_rate=0 sharpe = (daily_ret - risk_free_rate)/vol*np.sqrt(252)#len(portfolio_daily_value)) # Return calculated values return vol, daily_ret, sharpe, cum_ret
def simulate(dt_start, dt_end, ls_symbols, ratio): dt_timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) c_dataobj = da.DataAccess('Yahoo', cachestalltime=0) ls_keys = ['open','high','low','close','volume','actual_close'] ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) #for l in ls_symbols: na_price = d_data['close'].values na_normalized_price = na_price / na_price[0,:] na_normalized_price_ratio = np.multiply(na_normalized_price, ratio) all_price_ratio = np.sum(na_normalized_price_ratio, axis=1) """ calculate Volatility """ vol = np.std(tsu.returnize0(all_price_ratio)) """ daily return """ daily_ret = np.mean(tsu.returnize0(all_price_ratio)) """ cumulative daily return""" cum_ret = 0 sharpe = 0 return vol, daily_ret, sharpe, cum_ret
def simulate(start, end, equities, allocs): vol, daily_ret, sharpe, cum_ret = 0,0,0,0 # setup, get matrix of normalized closing prices dt_timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(start, end, dt_timeofday) c_dataobj = da.DataAccess('Yahoo', cachestalltime=0) ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] ldf_data = c_dataobj.get_data(ldt_timestamps, equities, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) na_price = d_data['close'].values na_normalized_price = na_price / na_price[0,:] # first, compute (normalized) daily returns na_weighted_cumulative_ret = np.sum(na_normalized_price * allocs, axis=1) na_normalized_weighted_daily_ret = na_weighted_cumulative_ret.copy() tsu.returnize0(na_normalized_weighted_daily_ret) # compute volatility of daily returns of total portfolio vol = np.std(na_normalized_weighted_daily_ret) # compute average daily return daily_ret = np.mean(na_normalized_weighted_daily_ret) #compute Sharpe ratio sharpe = np.sqrt(252) * daily_ret / vol # compute cumulative return of portfolio cum_ret = na_weighted_cumulative_ret[len(na_weighted_cumulative_ret)-1] return vol, daily_ret, sharpe, cum_ret
def print_results(cumm_port, mkt_benchmark): norm_port = cumm_port['VAL'].copy() norm_port = norm_port/norm_port[0] norm_bench = mkt_benchmark[mkt_benchmark.columns[0]].copy() norm_bench = norm_bench/norm_bench[0] norm_port_ret = norm_port.copy() norm_bench_ret = norm_bench.copy() tsu.returnize0(norm_port_ret) tsu.returnize0(norm_bench_ret) msg = """Data Range : {0} to {1} Sharpe Ratio of Fund : {2} Sharpe Ratio of Benchmark : {3} Total Return of Fund : {4} Total Return of Benchmark : {5} Standard Deviation of Fund : {6} Standard Deviation of Benchmark : {7} Average Daily Return of Fund : {8} Average Daily Return of Benchmark : {9}""".format(cumm_port.index[0], cumm_port.index[-1], calc_sharpeRatio(norm_port), calc_sharpeRatio(norm_bench), norm_port[-1], norm_bench[-1], np.std(norm_port_ret), np.std(norm_bench_ret), np.mean(norm_port_ret), np.mean(norm_bench_ret)) print(msg)
def get_returns(symbols, beg, end, time_of_day, price_type): # Trading days between the beg and the end. ldt_timestamps = du.getNYSEdays(beg, end, time_of_day) # Data Access class with Yahoo as the source. data_access = da.DataAccess('Yahoo') # Keys to be read from the data, it is good to read everything in one go. keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] # Reading the data, now data is a dictionary with the keys above. # Timestamps and symbols are the ones that were specified before. data_df = data_access.get_data(ldt_timestamps, symbols, keys) data = dict(zip(keys, data_df)) # Filling the data for NAN for s_key in keys: data[s_key] = data[s_key].fillna(method='ffill') data[s_key] = data[s_key].fillna(method='bfill') data[s_key] = data[s_key].fillna(1.0) # Getting the numpy ndarray of close prices. na_price = data[price_type].values # Normalizing the prices to start at 1 and see relative returns na_normalized_price = na_price / na_price[0, :] # Copy the normalized prices to a new ndarry to find returns. na_rets = na_normalized_price.copy() # Calculate the daily returns of the prices. (Inplace calculation) # returnize0 works on ndarray and not dataframes. tsu.returnize0(na_rets) return ldt_timestamps, na_price, na_rets
def simulate(dt_start, dt_end, ls_symbols, allocations): dt_timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) c_dataobj = da.DataAccess('Yahoo', cachestalltime=0) ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) na_price = d_data['close'].values na_normalized_price = na_price / na_price[0, :] na_normalized_price_alloc = na_normalized_price * allocations sum_daily = np.zeros( len(na_normalized_price_alloc) ) for index, item in enumerate(na_normalized_price_alloc): for value in item: sum_daily[index] += value na_rets = sum_daily.copy() tsu.returnize0(na_rets) daily_cum_ret = np.ones( len(na_rets) ) for i in range (1, len(na_rets)): daily_cum_ret[i] = daily_cum_ret[i - 1] * (1 + na_rets[i]) cum_ret = daily_cum_ret[len(daily_cum_ret) - 1] vol = np.std(na_rets) daily_ret = np.average(na_rets) sharpe = math.sqrt(252) * (daily_ret/vol) return vol, daily_ret, sharpe, cum_ret
def simulate(dt_start, dt_end, ls_symbols, allocations): dt_timeofday = dt.timedelta(hours=16) # Get a list of trading days between the start and the end. ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) c_dataobj = da.DataAccess('Yahoo') # Keys to be read from the data, it is good to read everything in one go. ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] # Reading the data, now d_data is a dictionary with the keys above. # Timestamps and symbols are the ones that were specified before. ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) # Getting the numpy ndarray of close prices. na_price = d_data['close'].values # Normalizing the prices to start at 1 and see relative returns na_normalized_price = na_price / na_price[0, :] na_rets = na_normalized_price.copy() # Calculate the daily returns of the prices. (Inplace calculation) # returnize0 works on ndarray and not dataframes. tsu.returnize0(na_rets) #print na_normalized_price daily = np.zeros(len(na_normalized_price)) i = 0 for row in na_normalized_price: daily[i] = row[0]*allocations[0]+row[1]*allocations[1]+row[2]*allocations[2]+row[3]*allocations[3] i += 1 #print daily daily_returns = daily.copy() tsu.returnize0(daily_returns) #print daily_returns return (tsu.get_sharpe_ratio(daily_returns), np.std(daily_returns), np.average(daily_returns), (daily[-1]/daily[0]))
def simulate(dt_start, dt_end, ls_symbols, ls_allocation): #date timestamps dt_timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) # read closing values ls_keys = ['close'] c_dataobj = da.DataAccess('Yahoo') ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) #agg portfolio value temp = d_data['close'].values.copy() d_normal = temp / temp[0,:] alloc = np.array(ls_allocation).reshape(4,1) portfolio = np.dot(d_normal, alloc) #daily returns dailyVal = portfolio.copy() tsu.returnize0(dailyVal) # who named this function? # calc. daily return, trading vol., sharpe ratio, and total returns daily_return = np.mean(dailyVal) vol = np.std(dailyVal) sharpe = np.sqrt(trading_days) * daily_return / vol cum_return = portfolio[portfolio.shape[0] -1][0] return vol, daily_return, sharpe, cum_return
def simulate(dt_start, dt_end, ls_symbols, allocations): dt_timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) c_dataobj = da.DataAccess("Yahoo") ls_keys = ["open", "high", "low", "close", "volume", "actual_close"] ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) na_price = d_data["close"].values na_normalized_price = na_price / na_price[0, :] na_rets = na_normalized_price.copy() tsu.returnize0(na_rets) daily_cum_ret = np.ones((len(na_rets), len(ls_symbols))) for i in range(1, len(na_rets)): daily_cum_ret[i] = daily_cum_ret[i - 1] * (1 + na_rets[i]) accum_ret = daily_cum_ret[len(daily_cum_ret) - 1] cum_ret = 0 for index, item in enumerate(allocations): cum_ret += item * accum_ret[index] return cum_ret
def simulateNoCapital (start_date, end_date, symbol_list, allocation): market_close_time = dt.timedelta(hours=16) trade_day_list = du.getNYSEdays(start_date, end_date, market_close_time) data_access_service = da.DataAccess('Yahoo') column_list = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] trade_data = data_access_service.get_data(trade_day_list, symbol_list, column_list) trade_dictionary = dict(zip(column_list, trade_data)) price_list = trade_dictionary['close'].values daily_returns = price_list.copy() # init_allocation = np.array([item * initial_investment for item in allocation], np.float); # start_price = price_list[0, :] # number_of_stocks = (init_allocation//start_price).astype(int) # portfolio_daily_values = (number_of_stocks * price_list)[:, :].sum(1) # portfolio_daily_returns = portfolio_daily_values.copy() # Calculate the daily returns of the prices. (Inplace calculation) # returnize0 works on ndarray and not dataframes. tsu.returnize0(daily_returns) print daily_returns portfolio_daily_returns = (daily_returns * allocation)[:, :].sum(1) average_daily_return = portfolio_daily_returns[:].mean() daily_return_stddev = portfolio_daily_returns[:].std() sharpe_ratio = math.sqrt(portfolio_daily_returns.size) * average_daily_return / daily_return_stddev; cum_return = portfolio_daily_returns[:].sum(); return (daily_return_stddev, average_daily_return, sharpe_ratio, cum_return)
def simulate(start_date, end_date, symbols_list, allocation_list): timeofday_date = dt.timedelta(hours=16) timestamps_list = du.getNYSEdays(start_date, end_date, timeofday_date) # Let's use dynamic trading days count based on data trading_days = len(timestamps_list) keys_list = ['close'] data_object = da.DataAccess('Yahoo', cachestalltime=0) data_list = data_object.get_data(timestamps_list, symbols_list, keys_list) data_dictionary = dict(zip(keys_list, data_list)) price_array_raw = data_dictionary['close'].values.copy() price_array_normalized = Helpers.normalize_price_array(price_array_raw) allocation_vector = np.array(allocation_list).reshape(4, 1) portfolio_values = np.dot(price_array_normalized, allocation_vector) daily_returns = portfolio_values.copy() tsu.returnize0(daily_returns) # Compute volatility and mean (daily return) values of portfolio volatility = Helpers.get_volatility(daily_returns) daily_return = np.mean(daily_returns) # Compute Shrape ratio of portfolio shrape_ratio = Helpers.get_shrape_ratio(daily_return, volatility, trading_days) # Compute Cumulative Return of portfolio daily_cum_return = Helpers.get_cumulative_return(portfolio_values) return volatility, daily_return, shrape_ratio, daily_cum_return
def simulate(dt_start, dt_end, ls_symbols, ls_allocation): assert len(ls_symbols) == len(ls_allocation) # 4:00 PM timestamp for closing prices dt_timeofday = dt.timedelta(hours=16) # get trading dates ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) # access data from Yahoo c_dataobj = da.DataAccess('Yahoo') # data to read ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] # read the data and create a dictionary ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) # get closing prices na_price = d_data['close'].values.copy() na_normal_price = na_price / na_price[0, :] portfolio_value = np.dot(na_normal_price, np.array(ls_allocation).reshape(len(ls_symbols), 1)) daily_returns = portfolio_value.copy() tsu.returnize0(daily_returns) avg_daily_returns = np.mean(daily_returns) volatility = np.std(daily_returns) sharpe_ratio = np.sqrt(len(ldt_timestamps)) * avg_daily_returns / volatility cumulative_returns = portfolio_value[portfolio_value.shape[0] - 1][0] return volatility, avg_daily_returns, sharpe_ratio, cumulative_returns
def simulate(startDate, endDate, symbolsEq, allocationEq) : dt_timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) c_dataobj = da.DataAccess('Yahoo') ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) na_price = d_data['close'].values na_normalized_price = na_price / na_price[0, :] symbolSP = ["$SPX"] sp_data = c_dataobj.get_data(ldt_timestamps, symbolSP, ls_keys) sp_d_data = dict(zip(ls_keys, sp_data)) sp_price = sp_d_data['close'].values sp_price_normalized = sp_price / sp_price[0, :] dailyReturnSP = sp_price_normalized.copy() tsu.returnize0(dailyReturnSP) na_normalizedPriceAllocation = na_normalized_price*allocationEq na_sumRows = na_normalizedPriceAllocation.sum(axis=1) dailyReturn = na_sumRows.copy() tsu.returnize0(dailyReturn) avgDailyReturn = np.average(dailyReturn) dailyReturnStdDev = np.std(dailyReturn) sharpeRatio = np.sqrt(252)*avgDailyReturn/dailyReturnStdDev excessReturn = dailyReturn - dailyReturnSP avgExcessReturn = np.average(excessReturn) excessReturnStdDev = np.std(excessReturn) cumulativeReturn = na_sumRows[-1] return dailyReturnStdDev, avgDailyReturn, sharpeRatio, cumulativeReturn
def simulate(start_date, end_date, symbols, allocations): ldt_timestamps = du.getNYSEdays(start_date, end_date, dt_timeofday) ldf_data = c_dataobj.get_data(ldt_timestamps, symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) na_price = d_data['close'].values na_normalized_price = na_price / na_price[0, :] na_rets = na_normalized_price.copy() na_portrets = np.sum(na_rets * allocations, axis=1) cum_ret = na_portrets[-1] tsu.returnize0(na_portrets) avg_daily_return = np.mean(na_portrets) std_dev = np.std(na_portrets) k = np.sqrt(250) sharpe_ratio = k * avg_daily_return/std_dev ## sqStdDev = np.std(squareArray) return std_dev, avg_daily_return, sharpe_ratio, cum_ret
def simulate(startdate, enddate, ls_symbols, ls_alloc): dt_timeofday = dt.timedelta(hours = 16) ldt_timestamps = du.getNYSEdays(startdate, enddate, dt_timeofday) c_dataobj = da.DataAccess('Yahoo', cachestalltime = 0) ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) for s_key in ls_keys: d_data[s_key] = d_data[s_key].fillna(method='ffill') d_data[s_key] = d_data[s_key].fillna(method='bfill') d_data[s_key] = d_data[s_key].fillna(1.0) na_price = d_data['close'].values na_normalized_price = na_price / na_price[0,:] na_port_price = np.sum(ls_alloc * na_normalized_price, 1) na_daily_rets = na_port_price.copy() tsu.returnize0(na_daily_rets) vol = np.std(na_daily_rets) daily_ret = np.average(na_daily_rets) sharpe_ratio = np.sqrt(252) * daily_ret / vol cum_ret = na_port_price[-1] return vol, daily_ret, sharpe_ratio, cum_ret
def analyse(na_close, ls_allocations): # Normalize the close price na_norm_close = na_close / na_close[0, :] # Get weighted daily returns weighted_daily_close = np.dot(na_norm_close, ls_allocations) # Copy the weighted daily close to a new ndarray to find returns port_daily_ret = weighted_daily_close.copy() # Calculate daily returns of the portfolio close price tsu.returnize0(port_daily_ret) # Get average portfolio daily returns daily_ret = np.average(port_daily_ret) # Calculate volatility of average weighted daily returns vol = np.std(port_daily_ret) # Calculate Sharpe Ratio k = math.sqrt(252) sharpe = k * (daily_ret / vol) # Calculate Cumulative Return cum_ret = np.dot((na_close[-1] / na_close[0]), ls_allocations) return vol, daily_ret, sharpe, cum_ret
def simulate(startdate, enddate, equities, allocations): # Date timestamps ldt_timestamps = du.getNYSEdays(startdate, enddate, dt.timedelta(hours=16)) # Data access c_dataobj = da.DataAccess('Yahoo') ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] ldf_data = c_dataobj.get_data(ldt_timestamps, equities, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) # Calculate normalized close data close_data = d_data['close'].values normalized_close_data = close_data / close_data[0, :] # Make sure allocations is a column vector: allocations = np.array(allocations).reshape(len(allocations), 1) # Calculate portfolio close data portfolio_close_data = np.dot(normalized_close_data, allocations) # Calculate total return portfolio_close_data_copy = portfolio_close_data.copy() portfolio_normalized_cumulative_daily_return = np.sum( portfolio_close_data_copy, axis=1) cum_ret = portfolio_normalized_cumulative_daily_return[-1] # Calculate volatility, average daily return and sharpe ratio portfolio_close_data_copy = portfolio_close_data.copy() tsu.returnize0(portfolio_close_data_copy) avg_daily_ret = np.mean(portfolio_close_data_copy) std_dev = np.std(portfolio_close_data_copy) sharpe = np.sqrt(252) * avg_daily_ret / std_dev return std_dev, avg_daily_ret, sharpe, cum_ret
def simulate(dt_start, dt_end, ls_symbols, allocation): dt_timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) c_dataobj = da.DataAccess('Yahoo') ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) #noramlize and accumulate values = d_data['close'].values values = values / values[0, :] values = values * allocation # sum per day cum_day = values.sum(axis=1) na_rets = cum_day.copy() # diff between current & perv date tsu.returnize0(na_rets) std_dev = np.std(na_rets) mean = np.mean(na_rets) sharpe = math.sqrt(252) * mean / std_dev # perv val * current val cum_daily = np.cumprod(1 + na_rets, axis=0, dtype=float) return std_dev, mean, sharpe, cum_daily[len(cum_daily) -1]
def portfolio_analyzer(na_port_vals): # Normalizing the prices to start at 1 and see relative returns # na_vals = ls_port_vals.values na_normalized_vals = na_port_vals / na_port_vals[0] print(na_normalized_vals) # Numpy matrix of filled data values na_portrets = na_normalized_vals.copy() tsu.returnize0(na_portrets) port_length = len(na_portrets) print("Data Points: ") print(port_length) port_length = 252 port_avg = np.average(na_portrets) port_div = np.std(na_portrets) port_sharp = math.sqrt(port_length)*port_avg/port_div # Estimate portfolio returns print("Days: ") print(port_length) print("Sharpe Ratio:") print(port_sharp) print("Stdev:") print(port_div) print("Avg Ret:") print(port_avg)
def computestats(self): #nothing fancy, just use library functions to compute daily returns, standard deviation and average of daily returns self.daily_portfolio_val /= self.daily_portfolio_val[0] daily_portfolio_return = tsu.returnize0(self.daily_portfolio_val) avg = np.mean(daily_portfolio_return) stdev = np.std(daily_portfolio_return) SR = avg / stdev * math.sqrt(252) total_return = 1 for ret in range(1,len(daily_portfolio_return)): total_return = total_return * (1 + daily_portfolio_return[ret]) spy_ldf_data = self.dataobj.get_data(self.ldt_timestamps, ['SPY'], ls_keys) #ldf_data_2008 = dataobj.get_data(ldt_timestamps, ls_symbols_2008, ls_keys) spy_d_data = dict(zip(ls_keys, spy_ldf_data )) close_prices = spy_d_data['close'].copy() close_prices = close_prices.fillna(method='ffill') close_prices = close_prices.fillna(method='bfill') na_rets_spy = close_prices['SPY'].values daily_spy_return = tsu.returnize0(na_rets_spy) print "AVG return: ",avg, "stdev of return: ", stdev, "sharp ratio: ", SR , "total cumulative return", total_return plt.clf() plt.plot(self.ldt_timestamps, daily_portfolio_return) plt.plot(self.ldt_timestamps, daily_spy_return) plt.legend(self.ls_symbols) plt.ylabel('Return comparison') plt.xlabel('Date')
def simulate( start, end, symbols, allocations): #calculate daily returns of portfolio timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(start, end, timeofday) c_dataobj = da.DataAccess('Yahoo') ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] ldf_data = c_dataobj.get_data(ldt_timestamps, symbols, ls_keys) #print("test") d_data = dict(zip(ls_keys, ldf_data)) # Filling the data for NAN for s_key in ls_keys: d_data[s_key] = d_data[s_key].fillna(method='ffill') d_data[s_key] = d_data[s_key].fillna(method='bfill') d_data[s_key] = d_data[s_key].fillna(1.0) # Getting the numpy ndarray of close prices. na_price = d_data['close'].values na_normalized_price = na_price / na_price[0, :] na_portfolio_price = (allocations * na_normalized_price).sum(1) # Copy the normalized prices to a new ndarry to find returns. na_rets = na_portfolio_price.copy() # Calculate the daily returns of the prices. (Inplace calculation) # returnize0 works on ndarray and not dataframes. tsu.returnize0(na_rets) # Plotting the plot of daily returns dev = na_rets.std() #if dev==0: # print na_rets[:5] avg = na_rets.mean() cum_ret=(na_portfolio_price[-1]) sharpe = avg/dev*(252**0.5) return dev, avg, sharpe, cum_ret
def main(fund_tx_file, comparision_symbol): fund_txn = pd.read_csv(fund_tx_file, parse_dates=[[0, 1, 2]], header=None, index_col=[0]) fund_txn.sort_index(inplace=True) sorted_dates = fund_txn.index start_date = sorted_dates[0] end_date = sorted_dates[-1] + dt.timedelta(days=1) total_daily_rets = fund_txn.iloc[:, -1].astype('f4') # print total_daily_rets daily_ret = tsu.returnize0(total_daily_rets.copy()) avg_daily_ret = np.mean(daily_ret) std_dev = np.std(daily_ret) sharpe = np.sqrt(252) * avg_daily_ret/std_dev cum_ret = total_daily_rets[-1]/total_daily_rets[0] comp_sym_vol, comp_sym_daily_ret, comp_sym_sharpe, comp_sym_cum_ret = optimizer.simulate( start_date, end_date, [comparision_symbol], [1.0]) print("Details of the Performance of the portfolio :") print("Data Range : {} to {}").format(str(start_date + dt.timedelta(hours=16)), str(end_date + dt.timedelta(hours=16))) print("Sharpe Ratio of Fund : {}").format(sharpe) print("Sharpe Ratio of {} : {}").format(comparision_symbol,comp_sym_sharpe) print("Total Return of Fund : {}").format(cum_ret) print("Total Return of {} : {}").format(comparision_symbol, comp_sym_cum_ret) print("Standard Deviation of Fund : {}").format(std_dev) print("Standard Deviation of {} : {}").format(comparision_symbol, comp_sym_vol) print("Average Daily Return of Fund : {}").format(avg_daily_ret) print("Average Daily Return of {} : {}").format(comparision_symbol, comp_sym_daily_ret) # Plot Fund vs comparing symbol plt.clf() fig = plt.figure(1) ax = plt.subplot(111) daily_ret_cummulative = np.cumprod(daily_ret + 1, axis=0) # Calculate daily returns for comparing symbol ldt_timestamps, na_price = optimizer.get_close_price_for_symbols(start_date, end_date, [comparision_symbol]) na_normalized_price = na_price / na_price[0, :] all_sum_daily = np.sum(na_normalized_price, 1) comp_sym_daily_ret = tsu.returnize0(all_sum_daily.copy()) comp_sym_cummulative = np.cumprod(comp_sym_daily_ret + 1, axis=0) plt.plot(sorted_dates, daily_ret_cummulative, label='Fund', alpha=0.4) plt.plot(sorted_dates, comp_sym_cummulative, label=comparision_symbol) plt.ylabel('Cumulative Returns') plt.xlabel('Date') fig.autofmt_xdate(rotation=45) box = ax.get_position() ax.set_position([box.x0, box.y0, box.width * 0.8, box.height]) # Put a legend to the right of the current axis ax.legend(loc='center left', bbox_to_anchor=(1, 0.5)) plt.show()
def simulate(startdate, enddate, symbols, alloc): ls_symbols = symbols lf_alloc = alloc dt_start = startdate dt_end = enddate dt_timeofday=dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) c_dataobj = da.DataAccess('Yahoo', cachestalltime=0) ls_keys = ['open', 'close', 'high', 'low', 'volume'] ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) for s_key in ls_keys: d_data[s_key] = d_data[s_key].fillna(method='ffill') d_data[s_key] = d_data[s_key].fillna(method='bfill') d_data[s_key] = d_data[s_key].fillna(1.0) na_price = d_data['close'].values na_normalized_price = na_price/na_price[0, :] na_port = na_normalized_price*lf_alloc na_port_daily_totals = np.sum(na_port, axis = 1) na_rets = na_port_daily_totals.copy() tsu.returnize0(na_rets) vol = np.std(na_rets) daily_ret = np.mean(na_rets) sharpe = mt.sqrt(252)*daily_ret/vol cum_ret = na_port_daily_totals[-1]/na_port_daily_totals[0] return (vol, daily_ret, sharpe, cum_ret)
def plot(): ls_alloc = optimal_allocation_4(dt_start, dt_end, ls_symbols) dt_timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) c_dataobj = da.DataAccess('Yahoo') ls_key = ['close'] ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_key) d_data = dict(zip(ls_key, ldf_data)) df_rets = d_data['close'].copy() df_rets = df_rets.fillna(method='ffill') df_rets = df_rets.fillna(method='bfill') na_rets = df_rets.values tsu.returnize0(na_rets) na_portrets = np.sum(na_rets * ls_alloc, axis=1) na_port_total = np.cumprod(na_portrets + 1) na_component_total = np.cumprod(na_rets + 1, axis=0) plt.clf() fig = plt.figure() fig.add_subplot(111) plt.plot(ldt_timestamps, na_component_total, alpha=0.4) plt.plot(ldt_timestamps, na_port_total) ls_names = ls_symbols ls_names.append('Portfolio') plt.legend(ls_names) plt.ylabel('Cumulative Returns') plt.xlabel('Date') fig.autofmt_xdate(rotation=45)
def simulate(na_price, allocations, trading_days): # Normalizing the prices to start at 1 and see relative returns na_normalized_price = na_price / na_price[0, :] # Copy the normalized prices to a new ndarry to find returns. na_rets = na_normalized_price.copy() # portifolio price port_rets = np.sum(na_rets * allocations, axis=1) port_price = port_rets.copy() # Calculate the daily returns of the prices. (Inplace calculation) # returnize0 works on ndarray and not dataframes. tsu.returnize0(port_rets) #print port_rets # portifolio cumulative return port_cum = port_price[-1] - 1 # standard deviation vol = np.std(port_rets) daily_ret = np.mean(port_rets) sharpe = np.sqrt(trading_days) * daily_ret / vol cum_ret = port_cum return vol,daily_ret,sharpe,cum_ret
def compute_stats(na_price): ''' Compute Sharpe etc ''' # Calculate cumulative returns na_cum = na_price / na_price[0] # Calculate total returns na_total = na_price[-1] - na_price[0] # Calculate daily returns # Copy the normalized prices to a new ndarry to find returns. na_rets = na_cum.copy() # Calculate the daily returns of the prices. (Inplace calculation) # returnize0 works on ndarray and not dataframes. tsu.returnize0(na_rets) # Calculate std and mean of returns na_std = np.std(na_rets) na_mean = np.mean(na_rets) # Calculate Sharpe ratio na_sharpe = na_mean / na_std return(na_sharpe, na_total, na_std, na_mean, na_cum)
def simulate(date_start, date_end, symbols, allocations): date_timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(date_start, date_end, date_timeofday) c_dataobj = da.DataAccess('Yahoo') ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] ldf_data = c_dataobj.get_data(ldt_timestamps, symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) na_price = d_data['close'].values # Normalizing the prices to start at 1 and see relative returns na_normalized_price = na_price / na_price[0, :] # Copy the normalized prices to a new ndarry to find returns. na_rets = na_normalized_price.copy() na_portrets = np.sum(na_rets * allocations, axis = 1) na_port_total = np.cumprod(na_portrets + 1) tsu.returnize0(na_portrets) tsu.returnize0(na_port_total) rf_rate = 0 vol = np.std(na_portrets) daily_ret = np.average(na_portrets) cum_ret = na_port_total[-1] #sharpe = np.sqrt(len(ldt_timestamps))*((cum_ret - rf_rate)/vol) sharpe = np.sqrt(252)*((daily_ret - rf_rate)/vol) return vol, daily_ret, sharpe, cum_ret
def simulate(startdate, enddate, equities, allocations): # Date timestamps ldt_timestamps = du.getNYSEdays(startdate, enddate, dt.timedelta(hours = 16)) # Data access c_dataobj = da.DataAccess('Yahoo') ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] ldf_data = c_dataobj.get_data(ldt_timestamps, equities, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) # Calculate normalized close data close_data = d_data['close'].values normalized_close_data = close_data / close_data[0, :] # Make sure allocations is a column vector: allocations = np.array(allocations).reshape(len(allocations), 1) # Calculate portfolio close data portfolio_close_data = np.dot(normalized_close_data, allocations) # Calculate total return portfolio_close_data_copy = portfolio_close_data.copy() portfolio_normalized_cumulative_daily_return = np.sum(portfolio_close_data_copy, axis = 1) cum_ret = portfolio_normalized_cumulative_daily_return[-1] # Calculate volatility, average daily return and sharpe ratio portfolio_close_data_copy = portfolio_close_data.copy() tsu.returnize0(portfolio_close_data_copy) avg_daily_ret = np.mean(portfolio_close_data_copy) std_dev = np.std(portfolio_close_data_copy) sharpe = np.sqrt(252) * avg_daily_ret / std_dev return std_dev, avg_daily_ret, sharpe, cum_ret
def simulate(dt_start, dt_end, ls_symbols, lf_port_alloc): # Formatting timestamps dt_timeofday = dt.timedelta(hours=16) ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) # Creating dataset, read in closing price and create dictionary c_dataobj = da.DataAccess('Yahoo') ls_keys = ['close'] ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) # Filling the data for NAN for s_key in ls_keys: d_data[s_key] = d_data[s_key].fillna(method='ffill') d_data[s_key] = d_data[s_key].fillna(method='bfill') d_data[s_key] = d_data[s_key].fillna(1.0) # Getting the numpy ndarray of close prices and calculate daily portfolio returns na_price = d_data['close'].values na_normalized_price = na_price / na_price[0, :] na_daily_rets = na_normalized_price.copy() tsu.returnize0(na_daily_rets) na_daily_portrets = np.sum(na_daily_rets * lf_port_alloc, axis=1) # Calculate portfolio returns and estimate statistics mean_portret = np.mean(na_daily_portrets) port_vol = np.std(na_daily_portrets) port_sharpe = np.sqrt(252) * mean_portret / port_vol cum_portrets = np.cumprod(na_daily_portrets + 1) cum_portret = cum_portrets[-1] return port_vol, mean_portret, port_sharpe, cum_portret
def analyze(self): self._parse_value_file() self._read_benchmark() self.portfolio_values = self.values self.values = zip(self.portfolio_values, self.bm_values) self._plot() values = np.array(self.portfolio_values, float) tsu.returnize0(values) bench_values = np.array(self.bm_values, float) tsu.returnize0(bench_values) return { "portfolio": { 'stdev': values.std(), 'avg': values.mean(), 'sharp': np.sqrt(252) * values.mean() / values.std(), 'return': (self.portfolio_values[-1] / self.portfolio_values[0]) }, self.benchmark: { 'stdev': bench_values.std(), 'avg': bench_values.mean(), 'sharp': np.sqrt(252) * bench_values.mean() / bench_values.std(), 'return': (self.bm_values[-1] / self.bm_values[0]) } }
def main(argv): input_file = argv[0] output_dir = argv[1] benchmark = argv[2] dates, prices = read_orders(input_file) bm_prices = read_prices(dates[0], dates[-1], benchmark) total = prices[-1] returns = prices[-1] / prices[0] bm_returns = bm_prices[-1] / bm_prices[0] n_prices = prices / prices[0] n_bm_prices = bm_prices / bm_prices[0] plot_timeseries( dates, n_prices, n_bm_prices, benchmark, file_name(output_dir, dates[0], dates[-1]), ylabel = 'Normalized Close' ) tsu.returnize0(prices) tsu.returnize0(bm_prices) print_results( dates, benchmark, prices, bm_prices, returns, bm_returns, total )
def eventprofiler(df_events, d_data, i_lookback=20, i_lookforward=20, s_filename='study', b_market_neutral=True, b_errorbars=True, s_market_sym='SPY'): ''' Event Profiler for an event matix''' df_close = d_data['close'].copy() df_rets = df_close.copy() tsu.returnize0(df_rets.values) if b_market_neutral == True: df_rets = df_rets - df_rets[s_market_sym] del df_rets[s_market_sym] del df_events[s_market_sym] df_close = df_close.reindex(columns=df_events.columns) # Removing the starting and the end events df_events.values[0:i_lookback, :] = np.NaN df_events.values[-i_lookforward:, :] = np.NaN # Number of events i_no_events = int(np.nansum(df_events.values)) na_event_rets = "False" # Looking for the events and pushing them to a matrix for i, s_sym in enumerate(df_events.columns): for j, dt_date in enumerate(df_events.index): if df_events[s_sym][dt_date] == 1: na_ret = df_rets[s_sym][j - i_lookback:j + 1 + i_lookforward] if type(na_event_rets) == type(""): na_event_rets = na_ret else: na_event_rets = np.vstack((na_event_rets, na_ret)) # Computing daily rets and retuns na_event_rets = np.cumprod(na_event_rets + 1, axis=1) na_event_rets = (na_event_rets.T / na_event_rets[:, i_lookback]).T # Study Params na_mean = np.mean(na_event_rets, axis=0) na_std = np.std(na_event_rets, axis=0) li_time = range(-i_lookback, i_lookforward + 1) # Plotting the chart plt.clf() plt.axhline(y=1.0, xmin=-i_lookback, xmax=i_lookforward, color='k') if b_errorbars == True: plt.errorbar(li_time[i_lookback:], na_mean[i_lookback:], yerr=na_std[i_lookback:], ecolor='#AAAAFF', alpha=0.1) plt.plot(li_time, na_mean, linewidth=3, label='mean', color='b') plt.xlim(-i_lookback - 1, i_lookforward + 1) if b_market_neutral == True: plt.title('Market Relative mean return of ' +\ str(i_no_events) + ' events') else: plt.title('Mean return of ' + str(i_no_events) + ' events') plt.xlabel('Days') plt.ylabel('Cumulative Returns') plt.savefig(s_filename, format='pdf')
def calculate_weighted_daily_returns_from_close_data( data_dictionary_of_close_market_data, allocation): normalised_close_data = normalise_prices( data_dictionary_of_close_market_data) allocated_returns = create_weighted_portfolio_from(normalised_close_data, allocation) tsu.returnize0(allocated_returns) return allocated_returns
def main(): capital = int(sys.argv[1]) order_file = sys.argv[2] value_output_file = sys.argv[3] ##symbols and dates are ordered dates_set, symbols_set = load_dates_and_symbols(order_file) start_date = dates_set[0] end_date = dates_set[len(dates_set) - 1] + dt.timedelta(days=1) df_close = getData(start_date, end_date, symbols_set)['close'] df_close = df_close.fillna(method='ffill') df_close = df_close.fillna(method='bfill') df_close = df_close.fillna(1.0) df_trades = copy.deepcopy(df_close) df_trades = df_trades * 0 ##fill trade matrix with actual trades fill_trade_matrix(df_trades, order_file) ##cash values df_cash_flows = df_close * df_trades ##time series with cash inflows and outflows cash_trades = np.sum(df_cash_flows.values.copy() * -1, axis=1) df_close['_CASH'] = 1.0 df_trades['_CASH'] = cash_trades ##now we need a cummulative sum of df_trades to got holding matrix df_holding = df_trades.cumsum() df_portafolio_value = df_close * df_holding df_portafolio_value = df_portafolio_value.sum(axis=1) + capital for row_index in df_portafolio_value.index: print row_index, "--", df_portafolio_value[row_index] na_portafolio_value = df_portafolio_value.values tsu.returnize0(na_portafolio_value) cummulative_return = np.cumprod(na_portafolio_value + 1)[-1] avg = na_portafolio_value.mean() std = na_portafolio_value.std() print "start_date", start_date, " -- ", "end_date", end_date print "fund sharpe_ratio:", avg / std * math.sqrt(252) print "fund total return:", cummulative_return print "fund standard deviation", std print "fund average return", avg print "-----" do_benchmark_calculations(start_date, end_date, ["$SPX"])
def simulate(start_date, end_date, symbols, allocations): # List of symbols ls_symbols = symbols # Start and End date of the simualte function dt_start = start_date dt_end = end_date # We need closing prices so the timestamp should be hours=16. (time = 4PM) dt_timeofday = dt.timedelta(hours=16) # Get a list of trading days between the start and the end. ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) # Creating an object of the dataaccess class with Yahoo as the source. c_dataobj = da.DataAccess('Yahoo') # Keys to be read from the data, it is good to read everything in one go. ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] # Reading the data, now d_data is a dictionary with the keys above. # Timestamps and symbols are the ones that were specified before. ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) # Copying close price into separate dataframe to find rets df_rets = d_data['close'].values.copy() # Normalizing the prices to start at 1 and see relative returns df_normal = df_rets / df_rets[0, :] #reshape the list of allocations alloc = np.array(allocations).reshape(4,1) #Calculate the portfolio value portVal = np.dot(df_normal, alloc) #Calculate the daily value dailyVal = portVal.copy() # returnize0 works on ndarray and not dataframes. tsu.returnize0(dailyVal) #Calculate daily returns daily_ret = np.mean(dailyVal) vol = np.std(dailyVal) #sharpe ratio = K * mean(daily return) / std(daily return) #K = sqrt(Number of trading days) sharpe_ratio = np.sqrt(Number_Trading_Days) * (daily_ret / vol) cum_ret = portVal[portVal.shape[0] -1][0] #Taking the last cumulative return value in PortVal array return daily_ret,vol,sharpe_ratio,cum_ret
def simulate(na_normalized_price, ls_alloc): # Calculate the daily returns of the prices. na_port_daily_returns = np.sum(na_normalized_price * ls_alloc, axis=1) tsu.returnize0(na_port_daily_returns) std_dev = na_port_daily_returns.std() daily_ret = na_port_daily_returns.mean() sharpe = sqrt(252) * daily_ret / std_dev cum_ret = 1 + na_port_daily_returns.sum() return std_dev, daily_ret, sharpe, cum_ret
def calcInfo(originalPrice, normalized, timeStamp, ratio): tempValue = np.sum(normalized * ratio, axis=1) #Calculate daily return dailyReturn = tempValue.copy() tsu.returnize0(dailyReturn) volatility = np.std(dailyReturn) average = np.mean(dailyReturn) sharpeRatio = (average / volatility) * np.sqrt(len(timeStamp)) totalReturn = np.cumprod(dailyReturn + 1, axis=0) return sharpeRatio
def simulate (startdate="January 1,2006", enddate="December 31, 2010", ls_symbols=["AAPL", "GLD", "GOOG", "$SPX", "XOM"], allocations=[0.2,0.3,0.4,0.1]): dt_start = dtParser.parse(startdate) #print dt_start dt_end=dtParser.parse(enddate) #print dt_end dt_timeofday=dt.timedelta(hours=16) # Get a list of trading days between the start and the end. ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) # Creating an object of the dataaccess class with Yahoo as the source. c_dataobj = da.DataAccess('Yahoo') # Keys to be read from the data, it is good to read everything in one go. ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] #print ls_symbols # Reading the data, now d_data is a dictionary with the keys above. # Timestamps and symbols are the ones that were specified before. ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) #define dictionary (relate ls_keys to data columns) d_data = dict(zip(ls_keys, ldf_data)) # Filling the data for NAN for s_key in ls_keys: d_data[s_key] = d_data[s_key].fillna(method='ffill') d_data[s_key] = d_data[s_key].fillna(method='bfill') d_data[s_key] = d_data[s_key].fillna(1.0) # Getting the numpy ndarray of close prices. na_price = d_data['close'].values # Normalizing the prices to start at 1 and see relative returns na_normalized_price = na_price / na_price[0, :] # Copy the normalized prices to a new ndarry to find returns. na_rets = na_normalized_price.copy() na_portrets = np.sum(na_rets * allocations, axis=1) # Calculate the daily returns of the prices. (Inplace calculation) # returnize0 works on ndarray and not dataframes. tsu.returnize0(na_portrets) na_port_total = np.cumprod(na_portrets+1) dailyReturnAverage = np.average(na_portrets) stdev = np.std(na_portrets) sharpe = sqrt(252)*np.mean(na_portrets)/stdev cumReturn = na_port_total[na_port_total.size-1]/na_port_total[0] return (sharpe,stdev,dailyReturnAverage,cumReturn, na_port_total)
def assessPortfolio(na_price, allocations): na_normalized = (na_price / na_price[0, :]) * allocations daily_ret = np.zeros([np.size(na_price, 0), 1]) for i in range(np.size(daily_ret, 0)): daily_ret[[i]] = sum(na_normalized[i, :]) norm_daily_ret = daily_ret.copy() tsu.returnize0(norm_daily_ret) daily_ret_avg = np.mean(norm_daily_ret) vol = np.std(norm_daily_ret) sharpe = np.sqrt(252) * daily_ret_avg / vol cum_ret = float(daily_ret[-1]) return vol, daily_ret_avg, sharpe, cum_ret
def main(): ''' Main Function''' # List of symbols ls_symbols = ["ETH-BTC", "DASH-BTC", "LTC-BTC"] # Start and End date of the charts dt_start = dt.datetime(2017, 1, 10) dt_end = dt.datetime(2017, 12, 30) # We need closing prices so the timestamp should be hours=16. dt_timeofday = dt.timedelta(hours=16) # Get a list of trading days between the start and the end. ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday) # Creating an object of the dataaccess class with Yahoo as the source. c_dataobj = da.DataAccess('Yahoo') # Keys to be read from the data, it is good to read everything in one go. ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close'] # Reading the data, now d_data is a dictionary with the keys above. # Timestamps and symbols are the ones that were specified before. ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys) d_data = dict(zip(ls_keys, ldf_data)) # Filling the data for NAN for s_key in ls_keys: d_data[s_key] = d_data[s_key].fillna(method='ffill') d_data[s_key] = d_data[s_key].fillna(method='bfill') d_data[s_key] = d_data[s_key].fillna(1.0) # Getting the numpy ndarray of close prices. na_price = d_data['close'].values # Plotting the prices with x-axis=timestamps plt.clf() plt.plot(ldt_timestamps, na_price) plt.legend(ls_symbols) plt.ylabel('Adjusted Close') plt.xlabel('Date') plt.savefig('adjustedclose.pdf', format='pdf') # Normalizing the prices to start at 1 and see relative returns na_normalized_price = na_price / na_price[0, :] na_rets = na_normalized_price.copy() tsu.returnize0(na_rets) dev = na_rets.std(axis=0) #if dev==0: # print na_rets[:5] avg = na_rets.mean(axis=0) cum_ret=(na_normalized_price[-1]) sharpe = avg/dev*(252**0.5) print "Sharpe ratio of Symbol:", sharpe print "Total returns of Symbol: ", cum_ret print "Standard deviation of Symbols:", dev print "Daily returns of Symbols:", avg