def get_portfolio(expected_returns, risk_array): cv = covariance_matrix(risk_array) ef = EfficientFrontier(expected_returns, cv) raw_weights = ef.max_sharpe() cleaned_weights = ef.clean_weights() print(cleaned_weights) ef.portfolio_performance(verbose=True)
def getMinVolatilityPortfolio(data): mu, Sigma = getMuSigma(data) ef = EfficientFrontier(mu, Sigma) raw_weights = ef.min_volatility() weights = ef.clean_weights() performance = ef.portfolio_performance() return weights, performance
def getMaxSharpePortfolio(data): mu, Sigma = getMuSigma(data) ef = EfficientFrontier(mu, Sigma) raw_weights = ef.max_sharpe() weights = ef.clean_weights() performance = ef.portfolio_performance() return weights, performance
def get_portfolio(universe, df_tr, port_value, cutoff, df_m): '''create a portfolio using the stocks from the universe and the closing prices from df_tr with a given portfolio value and a weight cutoff value using the value of a momemntum indicator to limit the quantity of the stocks''' df_t = select_columns(df_tr, universe) mu = capm_returns(df_t) S = CovarianceShrinkage(df_t).ledoit_wolf() # Optimize the portfolio for min volatility ef = EfficientFrontier(mu, S) # Use regularization (gamma=1) weights = ef.min_volatility() #weights = ef.max_sharpe() cleaned_weights = ef.clean_weights(cutoff=cutoff) # Allocate latest_prices = get_latest_prices(df_t) da = DiscreteAllocation(cleaned_weights, latest_prices, total_portfolio_value=port_value) allocation = da.greedy_portfolio()[0] non_trading_cash = da.greedy_portfolio()[1] # Put the stocks and the number of shares from the portfolio into a df symbol_list = [] mom = [] w = [] num_shares_list = [] l_price = [] tot_cash = [] for symbol, num_shares in allocation.items(): symbol_list.append(symbol) mom.append(df_m[df_m['stock'] == symbol].values[0]) w.append(round(cleaned_weights[symbol], 4)) num_shares_list.append(num_shares) l_price.append(latest_prices[symbol]) tot_cash.append(num_shares * latest_prices[symbol]) df_buy = pd.DataFrame() df_buy['stock'] = symbol_list df_buy['momentum'] = mom df_buy['weights'] = w df_buy['shares'] = num_shares_list df_buy['price'] = l_price df_buy['value'] = tot_cash df_buy = df_buy.append( { 'stock': 'CASH', 'momentum': 0, 'weights': round(1 - df_buy['weights'].sum(), 4), 'shares': 1, 'price': round(non_trading_cash, 2), 'value': round(non_trading_cash, 2) }, ignore_index=True) df_buy = df_buy.set_index('stock') return df_buy, non_trading_cash
def test_clean_weights_short(): ef = setup_efficient_frontier() ef = EfficientFrontier( *setup_efficient_frontier(data_only=True), weight_bounds=(-1, 1) ) ef.max_sharpe() # In practice we would never use such a high cutoff number_tiny_weights = sum(np.abs(ef.weights) < 0.05) cleaned = ef.clean_weights(cutoff=0.05) cleaned_weights = cleaned.values() clean_number_tiny_weights = sum(abs(i) < 0.05 for i in cleaned_weights) assert clean_number_tiny_weights == number_tiny_weights
def get_expected_returns(self): mu = expected_returns.mean_historical_return(self.df) S = risk_models.sample_cov(self.df) ef = EfficientFrontier(mu, S) weights = ef.max_sharpe() cleaned_weights = ef.clean_weights() port_performance_percentage = { 'cleanedWeights': cleaned_weights, 'portfolioPerformance': ef.portfolio_performance(verbose=True) } return port_performance_percentage
def build_portfolio(self, price_pivot, portfolio_total=10000): ''' build a portfolio from price data''' mu = expected_returns.mean_historical_return(price_pivot) shrink = risk_models.CovarianceShrinkage(price_pivot) S = shrink.ledoit_wolf() ef = EfficientFrontier(mu, S, weight_bounds=(0, 0.2), gamma=0.8) weights = ef.max_sharpe() weights = ef.clean_weights() latest_prices = get_latest_prices(price_pivot) weights = {k: v for k, v in weights.items() if weights[k] > 0.0} da = DiscreteAllocation(weights, latest_prices, total_portfolio_value=portfolio_total) allocation, leftover = da.lp_portfolio() # print("Discrete allocation:", allocation) return allocation