def historical_simulation(self):
results = []
portfolio = Portfolio(assets=[], balance=self.starting_capital, trades=[], date=self.starting_date)
# First, populate stock returns universe
securities_universe_prices_df = pd.DataFrame()
for stock in os.listdir(path=config.STOCK_PRICES_DIR_PATH):
ticker = stock.strip('.pkl')
series = pd.read_pickle(os.path.join(config.STOCK_PRICES_DIR_PATH, stock))['Adj Close']
dummy_dates = pd.date_range(start=series.index[0], end=series.index[-1])
zeros_dummy = pd.Series(data=np.zeros(shape=len(dummy_dates)).fill(np.nan),
index=dummy_dates, name='Dummy', dtype='float64')
series = pd.concat([series, zeros_dummy], axis=1).iloc[:, 0]
securities_universe_prices_df[ticker] = series.ffill()
securities_universe_returns_df = securities_universe_prices_df.pct_change()
for date in pd.date_range(start=self.starting_date, end=self.ending_date):
portfolio.date = datetime(year=date.year, month=date.month, day=date.day)
for trade in portfolio.trades: # update portfolio float
date_loc = trade.stock.index.get_loc(date - timedelta(seconds=1))
daily_pct_return = (trade.stock.iloc[date_loc] - trade.stock.iloc[date_loc - 1]) \
/ trade.stock.iloc[date_loc - 1]
daily_doll_return = daily_pct_return * trade.stock.loc[date - timedelta(seconds=1)] * trade.shares
portfolio.float = portfolio.float + daily_doll_return if trade.direction \
else portfolio.float - daily_doll_return
if not (self.is_time_to_reschedule(current_date=date,
last_rebalancing_day=portfolio.last_rebalancing_day)
or date == self.starting_date):
continue
portfolio.last_rebalancing_day = date # rebalancing day, now can go on:
stocks_to_trade = self.generate_assets_to_trade(portfolio.date)
long_stocks, short_stocks = stocks_to_trade
for trade in portfolio.trades: # close portfolio trades that no longer meet condition
if trade.stock.name not in long_stocks + short_stocks:
portfolio.make_position(trade, entry=False)
# Get portfolio returns of selected stocks up to current date, and optimize portfolio allocation
portfolio.df_returns = securities_universe_returns_df[long_stocks]
sliced_portfolio = portfolio.slice_dataframe(to_date=date, inplace=False)
weights = self.allocation_regime(portfolio=sliced_portfolio)
portfolio.rebalance_portfolio(long_stocks=securities_universe_prices_df[long_stocks],
short_stocks=securities_universe_prices_df[short_stocks],
weights=weights, commission=self.commission,
fractional_shares=self.fractional_shares)
# Aggregate trades for better formatting in the dataframe
dictionary = dict()
for trade in portfolio.trades:
dictionary[trade.stock.name] = dictionary.get(trade.stock.name, 0) + trade.shares
aggregated_trades = [(key, val) for (key, val) in dictionary.items()]
results.append([date.strftime("%Y-%m-%d"), aggregated_trades,
round(portfolio.balance, 2), round(portfolio.float, 2)])
evolution_df = pd.DataFrame(results, columns=['Date', 'Holdings', 'Balance', 'Float'])
evolution_df.set_index('Date', inplace=True)
evolution_df['Cumulative (%) Return'] = evolution_df.filter(['Float']).pct_change().apply(
lambda x: x + 1).cumprod()
evolution_df['Float'].plot(grid=True, figsize=(10, 6))
plt.show()
with pd.option_context('display.max_rows', None, 'display.max_columns', None):
print(evolution_df.to_string())
return evolution_df
def roys_safety_first_criterion(portfolio_returns: pd.Series,
minimum_threshold=0.02,
period=252):
"""
:param portfolio_returns: Pandas series or dataframe representing percentage changes of the security (or portfolio) returns over time. It should be same time range and frequency as risk free rates
:param minimum_threshold: minimum acceptable return, below which the returns are less desirable.
:param period: period to compute statistics of returns for. For instance, to compute yearly, then input 252, and to compute monthly, then input 21.
:return:
"""
return (portfolio_returns.mean() * period -
minimum_threshold) / (portfolio_returns.std() * math.sqrt(period))
if __name__ == '__main__':
from matilda.portfolio_management.Portfolio import Portfolio
from datetime import datetime
assets = ['AAPL', 'V', 'KO', 'CAT']
portfolio = Portfolio(assets=assets)
portfolio.slice_dataframe(to_date=datetime(2021, 1, 1),
from_date=datetime(2016, 1, 1))
# portfolio_returns = portfolio.get_weighted_sum_returns(weights=np.ones(len(assets)) / len(assets))
# print(portfolio_returns.head())
print(
roys_safety_first_criterion(portfolio_returns=portfolio.df_returns,
minimum_threshold=0.02,
period=252))
class NestedClusteredOptimization(PortfolioAllocationModel):
def __init__(self, portfolio: Portfolio):
super().__init__(portfolio)
def solve_weights(self, risk_metric=None, objective=None, leverage=0, long_short_exposure=0):
pass
if __name__ == '__main__':
from matilda.data_pipeline.db_crud import companies_in_classification
from matilda import config
assets = companies_in_classification(class_=config.MarketIndices.DOW_JONES)
portfolio = Portfolio(assets=assets)
portfolio.set_frequency(frequency='M', inplace=True)
portfolio.slice_dataframe(from_date=datetime(2016, 1, 1), to_date=datetime(2020, 1, 1), inplace=True)
print(portfolio.df_returns.tail(10))
MPT = ModernPortfolioTheory(portfolio)
weights = MPT.solve_weights(use_sharpe=True)
print(weights)
market_portfolio = Portfolio(assets='^DJI')
market_portfolio.set_frequency(frequency='M', inplace=True)
market_portfolio.slice_dataframe(from_date=datetime(2016, 1, 1), to_date=datetime(2020, 1, 1), inplace=True)
stats = MPT.markowitz_efficient_frontier(market_portfolio=market_portfolio, plot_assets=True, plot_cal=True)
pd.set_option('display.max_columns', None)
print(stats.head())
# portfolio = Portfolio(assets=['AAPL', 'MSFT', 'CSCO'])