Untitled
unknown
plain_text
a month ago
30 kB
2
Indexable
import pandas as pd import numpy as np from datetime import datetime from dateutil.relativedelta import relativedelta from scipy.stats import zscore ############################################### # 1. Data Loading (Filtering Out Weekends) ############################################### def load_price_data(filepath): """ Load historical prices from an Excel file. Assumes that the first column is dates and the remaining columns are tickers. Removes weekend data. """ df = pd.read_excel(filepath, index_col=0) df.index = pd.to_datetime(df.index) df = df.sort_index() # Filter out weekends (Saturday=5, Sunday=6) df = df[df.index.dayofweek < 5] return df def load_macro_data(filepath): """ Load macro indicators from an Excel file. Loads VIX and VIX3M from 'Eq' sheet, LF98TRUU Index from 'FI' sheet, and other macro indicators from 'Macro' sheet. Removes weekend data. Also computes slopes for selected macro indicators. """ # VIX data vix_data = pd.read_excel(filepath, sheet_name='Eq', index_col=0, parse_dates=True, usecols=[0, 3, 4, 5]) vix_data.columns = ['VIX9D', 'VIX', 'VIX3M'] vix_data = vix_data[vix_data.index.dayofweek < 5] # FI data cdx_data = pd.read_excel(filepath, sheet_name='FI', index_col=0, parse_dates=True, usecols=[0, 2], skiprows=1) cdx_data.columns = ['LF98TRUU'] cdx_data = cdx_data[cdx_data.index.dayofweek < 5] # Macro data (assumed to include columns "CESIUSD Index", "INJCJC Index", ".HG/GC G Index", and "Consumer Confidence") macro_data = pd.read_excel(filepath, sheet_name='Macro', index_col=0, parse_dates=True, usecols=range(8), skiprows=1) macro_data = macro_data[macro_data.index.dayofweek < 5] # Compute slopes for selected macro indicators. macro_data["Surprise Index Slope"] = macro_data["CESIUSD Index"].diff() macro_data["Jobless Claims Slope"] = macro_data["INJCJC Index"].diff() macro_data["Copper Gold Slope"] = macro_data['.HG/GC G Index'].diff() # Assume "Consumer Confidence" column already exists. combined_data = pd.concat([vix_data, cdx_data, macro_data], axis=1) combined_data = combined_data.fillna(method='ffill').fillna(method='bfill') combined_data = combined_data.sort_index() # ensure sorted index return combined_data ############################################### # 2. Helper: Observation Dates (Monthly) ############################################### def get_observation_dates(prices, start_date, end_date, rebalance_period): """ Returns observation dates using the trading calendar. For a monthly rebalancing (rebalance_period=1), for each target month, it starts at the first calendar day and checks sequentially until it finds a trading day. Parameters: prices: DataFrame with a DatetimeIndex containing trading days. start_date: Starting date (should be a valid trading day). end_date: End date for observations. rebalance_period: Number of months between rebalances. Returns: List of observation dates. """ dates = [] current_date = start_date while current_date < end_date: # Move forward by the rebalance period (in months) and set candidate to the first day of that month candidate_date = (current_date + relativedelta(months=rebalance_period)).replace(day=1) # Check sequentially until a trading day is found in prices index while candidate_date not in prices.index: candidate_date += pd.Timedelta(days=1) # Safety: if candidate_date moves into the next month, break out (unlikely if market is active) if candidate_date.month != (current_date + relativedelta(months=rebalance_period)).month: candidate_date = None break if candidate_date is None or candidate_date > end_date: break dates.append(candidate_date) current_date = candidate_date return dates ############################################### # 3. Portfolio Initialization ############################################### def initialize_portfolio(prices, date, tickers, initial_aum): """ On the start date, invest equal notional amounts in each asset. Returns a dictionary mapping ticker -> quantity. """ portfolio = {} mask = prices.index < date prev_date = prices.index[mask][-1] allocation = initial_aum / len(tickers) for ticker in tickers: price = prices.loc[prev_date, ticker] portfolio[ticker] = allocation / price return portfolio ############################################### # 4. Lookback Metric Computation ############################################### def compute_lookback_metric(prices, current_date, ticker, lookback_period, metric_type='simple'): """ Computes the lookback metric for one ticker using previous day's data. """ prices = prices.sort_index() mask = prices.index < current_date prev_date = prices.index[mask][-1] lookback_date = prev_date - relativedelta(months=lookback_period) current_price = prices[ticker].asof(prev_date) # Use previous day's price lookback_price = prices[ticker].asof(lookback_date) if pd.isna(current_price) or pd.isna(lookback_price): raise ValueError(f"Missing price data for {ticker} on {prev_date} or {lookback_date}.") if metric_type == 'simple': metric = (current_price / lookback_price) - 1 elif metric_type == 'sma': window = prices[ticker].loc[lookback_date:current_date] if window.empty: raise ValueError(f"No price data for {ticker} between {lookback_date} and {current_date}.") sma = window.mean() metric = (current_price - sma) / sma else: raise ValueError("Invalid metric type. Choose 'simple' or 'sma'.") return metric ############################################### # 5. Ranking Assets by Momentum ############################################### def rank_assets(prices, current_date, tickers, lookback_period, metric_type): """ For a given observation date, compute the chosen lookback metric for each asset, then sort (in descending order) so that the highest momentum gets rank 1. Returns: sorted_tickers: list of tickers in sorted order (best first) ranks: dictionary mapping ticker -> rank (1 is best) metrics: dictionary mapping ticker -> computed metric value """ metrics = {} for ticker in tickers: metric = compute_lookback_metric(prices, current_date, ticker, lookback_period, metric_type) metrics[ticker] = metric sorted_tickers = sorted(metrics, key=metrics.get, reverse=True) ranks = {ticker: rank+1 for rank, ticker in enumerate(sorted_tickers)} return sorted_tickers, ranks, metrics ############################################### # 6. Compute Current Portfolio Value ############################################### def compute_portfolio_value(portfolio, prices, current_date): """ Returns the portfolio AUM as of current_date. """ value = 0 for ticker, quantity in portfolio.items(): price = prices.loc[current_date, ticker] value += quantity * price return value ############################################### # 7. Rebalance the Momentum Portfolio ############################################### def rebalance_portfolio(portfolio, prices, current_date, tickers, sorted_tickers, internal_rebalance_ratios, rebalance_ratio): prev_date = prices.index[prices.index < current_date][-1] prev_prices = prices.loc[prev_date] curr_prices = prices.loc[current_date] portfolio_value = sum(portfolio[ticker] * prev_prices[ticker] for ticker in tickers) rebalance_amount = portfolio_value * rebalance_ratio target_trades = {ticker: rebalance_amount * internal_rebalance_ratios[i] for i, ticker in enumerate(sorted_tickers)} total_sold = 0 actual_trades = {} for ticker, target_trade in target_trades.items(): execution_price = curr_prices[ticker] if target_trade < 0: available_notional = portfolio[ticker] * curr_prices[ticker] sell_target = abs(target_trade) actual_sell = min(available_notional, sell_target) actual_trades[ticker] = -actual_sell total_sold += actual_sell else: actual_trades[ticker] = 0 total_buy_target = sum(t for t in target_trades.values() if t > 0) if total_buy_target > 0: for ticker, target_trade in target_trades.items(): if target_trade > 0: proportion = target_trade / total_buy_target buy_amount = total_sold * proportion actual_trades[ticker] = buy_amount new_portfolio = portfolio.copy() for ticker, trade_notional in actual_trades.items(): execution_price = curr_prices[ticker] qty_change = trade_notional / execution_price new_portfolio[ticker] += qty_change return new_portfolio, actual_trades, portfolio_value def adjust_overweight(portfolio, prices, current_date, sorted_tickers, threshold=0.70): prev_date = prices.index[prices.index < current_date][-1] prev_prices = prices.loc[prev_date] curr_prices = prices.loc[current_date] portfolio_value = sum(portfolio[ticker] * prev_prices[ticker] for ticker in portfolio) weights = {ticker: (portfolio[ticker] * prev_prices[ticker]) / portfolio_value for ticker in portfolio} new_portfolio = portfolio.copy() adjustments = {} for overweight in portfolio: if weights[overweight] > threshold: extra_weight = weights[overweight] - threshold extra_value = extra_weight * portfolio_value execution_price_over = curr_prices[overweight] qty_reduce = extra_value / execution_price_over new_portfolio[overweight] -= qty_reduce adjustments[overweight] = {'removed_qty': qty_reduce, 'reallocated': {}} remaining_value = extra_value for candidate in sorted_tickers: if candidate == overweight: continue candidate_value = new_portfolio[candidate] * curr_prices[candidate] candidate_weight = candidate_value / portfolio_value if candidate_weight < threshold: capacity = (threshold - candidate_weight) * portfolio_value allocation = min(remaining_value, capacity) qty_add = allocation / curr_prices[candidate] new_portfolio[candidate] += qty_add adjustments[overweight]['reallocated'][candidate] = qty_add remaining_value -= allocation if remaining_value <= 0: break if remaining_value > 0: adjustments[overweight]['leftover_value'] = remaining_value return new_portfolio ############################################### # 8. VIX-based Allocation Function ############################################### def momentum_allocation(vix_9d, vix_mean, vix_std, max_alloc=1.0, min_alloc=0.6): """ Maps composite score to a target momentum allocation fraction using a piecewise linear approach. - If vix_9d < vix_mean + vix_std, return max_alloc (fully risk on). - If vix_9d >= vix_mean + 2*vix_std, return min_alloc (fully risk off). - Otherwise, return 0.8 as an intermediate allocation. """ if vix_9d < vix_mean + vix_std: return max_alloc elif (vix_9d >= vix_mean + vix_std) and (vix_9d < vix_mean + 2*vix_std): return 0.8 else: return min_alloc ############################################### # 9. Compute FI Signal Functions ############################################### def compute_fi_target_allocation(macro_data, current_date, fi_max_alloc, fi_min_alloc, slope_threshold=0.01): """ Computes the FI target allocation based on a refined logic using only the 8-day and 13-day EMAs. The computation uses data only up to the previous trading day. Returns: target_alloc: the target allocation. signal_label: a string label ("risk-on", "neutral", or "risk-off"). """ # Determine the reference date as the previous trading day. available_dates = macro_data.index[macro_data.index < current_date] if len(available_dates) == 0: return fi_max_alloc, "risk-on" ref_date = available_dates[-1] fi_8 = macro_data["FI_EMA_8"].asof(ref_date) fi_13 = macro_data["FI_EMA_13"].asof(ref_date) if pd.isna(fi_8) or pd.isna(fi_13): return fi_max_alloc, "risk-on" # Compute slope of FI_EMA_8 using ref_date. available_ref_dates = macro_data.loc[:ref_date].index if len(available_ref_dates) < 2: slope = 0 else: prev_ref_date = available_ref_dates[-2] fi_8_prev = macro_data["FI_EMA_8"].asof(prev_ref_date) slope = (fi_8/fi_8_prev) - 1 if fi_8 < fi_13: return fi_max_alloc, "risk-on" else: # fi_8 > fi_13 if slope > slope_threshold: return fi_min_alloc, "risk-off" else: return fi_max_alloc, "no signal" ############################################### # 10. Simulation: VIX-based (current) Strategy with Signal Logging ############################################### def simulate_strategy(prices, macro_data, eq_tickers, fi_tickers, alts_tickers, initial_aum, start_date, end_date, rebalance_period, rebalance_ratio, lookback_period, metric_type, internal_rebalance_ratios, macro_max_alloc=1.0, macro_min_alloc=0.6): """ Runs the simulation with: - Daily macro overlay adjustments - Monthly momentum rebalancing based on total returns. This version computes and logs the following signals daily: • VIX signal (and corresponding target allocation) • Composite macro signal (and target allocation) • FI signal (and target allocation) """ tickers = eq_tickers + fi_tickers + alts_tickers monthly_dates = get_observation_dates(prices, start_date, end_date, rebalance_period) daily_dates = prices.index.sort_values() # initiate vars vix_target_alloc = macro_max_alloc # Default to max allocation vix_signal = "risk-on" # Default to risk-on macro_target_alloc = macro_max_alloc macro_signal = "risk-on" fi_target_alloc = macro_max_alloc fi_signal = "no signal" # Prepare macro data: compute VIX EMA fields macro_data = macro_data.copy() macro_data['VIX 1M 3M_Spread'] = macro_data['VIX'] - macro_data['VIX3M'] macro_data['VIX1M_EMA'] = macro_data["VIX 1M 3M_Spread"].ewm(span=5, adjust=False).mean() macro_data["Mean"] = macro_data['VIX1M_EMA'].rolling(window=504).mean() macro_data["Std"] = macro_data['VIX1M_EMA'].rolling(window=504).std() # Precompute FI EMAs macro_data["FI_EMA_8"] = macro_data["LF98TRUU"].ewm(span=8, adjust=False).mean() macro_data["FI_EMA_13"] = macro_data["LF98TRUU"].ewm(span=13, adjust=False).mean() macro_data["FI_EMA_21"] = macro_data["LF98TRUU"].ewm(span=21, adjust=False).mean() portfolio = initialize_portfolio(prices, start_date, tickers, initial_aum) CASH = 0.0 current_regime = 'risk-on' target_alloc = macro_max_alloc previous_regime = current_regime prev_total_aum = initial_aum ret = 0.0 previous_regime = current_regime results = [] prev_total_aum = initial_aum # Filter daily_dates to ensure they're within range daily_dates = daily_dates[(daily_dates >= start_date) & (daily_dates <= end_date)] for current_date in daily_dates: daily_adjustment_note = "No adjustment" cash_adjustment = 0 # Determine reference date (previous trading day) available_macro_dates = macro_data.index[macro_data.index < current_date] print if len(available_macro_dates) == 0: ref_date = current_date else: ref_date = available_macro_dates[-1] # Calculate FI metrics fi_8 = macro_data["FI_EMA_8"].asof(ref_date) fi_13 = macro_data["FI_EMA_13"].asof(ref_date) # Calculate FI slope available_ref_dates = macro_data.loc[:ref_date].index if len(available_ref_dates) < 2: fi_slope = 0 else: prev_ref_date = available_ref_dates[-2] fi_8_prev = macro_data["FI_EMA_8"].asof(prev_ref_date) fi_slope = (fi_8/fi_8_prev) - 1 # Get VIX metrics vix_1m = macro_data['VIX'].asof(ref_date) vix_3m = macro_data['VIX3M'].asof(ref_date) # Calculate z-scores vix_window = macro_data.loc[:ref_date].tail(504) # Using 2-year window (504 trading days) vix_1m_zscore = zscore(vix_window['VIX'])[-1] if len(vix_window) > 0 else np.nan vix_3m_zscore = zscore(vix_window['VIX3M'])[-1] if len(vix_window) > 0 else np.nan # Daily macro signal computation and adjustment using ref_date try: vix_ema = macro_data['VIX1M_EMA'].asof(ref_date) vix_mean = macro_data['Mean'].asof(ref_date) vix_std = macro_data['Std'].asof(ref_date) except Exception as e: raise ValueError(f"Error retrieving VIX data for {current_date}: {e}") vix_target_alloc = momentum_allocation(vix_ema, vix_mean, vix_std, max_alloc=macro_max_alloc, min_alloc=macro_min_alloc) if vix_ema >= (vix_mean + vix_std): vix_signal = 'risk-off' elif vix_ema <= (vix_mean - vix_std): vix_signal = 'risk-on' else: vix_signal = 'no-signal' # Compute FI Signal using data up to ref_date fi_target_alloc, fi_signal = compute_fi_target_allocation( macro_data, current_date, macro_max_alloc, macro_min_alloc, slope_threshold=0.01) # ---- Daily Check: Force regime if SPY weight is low and current regime is risk-off ---- mask = prices.index < current_date prev_date = prices.index[mask][-1] mom_value = compute_portfolio_value(portfolio, prices, prev_date) spy_price = prices.loc[prev_date, 'SPY US Equity'] spy_qty = portfolio.get('SPY US Equity', 0) spy_weight = (spy_price * spy_qty) / mom_value if mom_value > 0 else 0 hyg_price = prices.loc[prev_date, 'HYG US Equity'] hyg_qty = portfolio.get('HYG US Equity', 0) hyg_weight = (hyg_price * hyg_qty) / mom_value if mom_value > 0 else 0 if (fi_signal == 'risk-off' or vix_signal == 'risk-off'): if ((spy_weight + hyg_weight) < 0.40): current_regime = 'risk-on' target_alloc = 1.0 daily_adjustment_note = "Forced regime to risk-on & target alloc to 1 due to HYG + SPY weight < 40%" else: current_regime = 'risk-off' target_alloc = min(fi_target_alloc, vix_target_alloc) else: current_regime = 'risk-on' # Use VIX signal for adjustment if regime changed. if current_regime != previous_regime: mask = prices.index < current_date prev_date = prices.index[mask][-1] mom_value = compute_portfolio_value(portfolio, prices, prev_date) total_investment = mom_value + CASH desired_mom_value = target_alloc * total_investment mom_value = compute_portfolio_value(portfolio, prices, current_date) if mom_value > desired_mom_value: excess = mom_value - desired_mom_value cash_adjustment = excess for ticker in portfolio: price = prices.loc[current_date, ticker] ticker_value = portfolio[ticker] * price sell_amount = (ticker_value / mom_value) * excess qty_to_sell = sell_amount / price portfolio[ticker] -= qty_to_sell CASH += excess daily_adjustment_note = f"Adj: Sold excess {excess:.2f} to CASH." elif mom_value < desired_mom_value and CASH > 0: shortage = desired_mom_value - mom_value available = min(shortage, CASH) cash_adjustment = -available for ticker in portfolio: price = prices.loc[current_date, ticker] ticker_value = portfolio[ticker] * price target_weight = ticker_value / mom_value if mom_value > 0 else 1/len(portfolio) invest_amount = target_weight * available qty_to_buy = invest_amount / price portfolio[ticker] += qty_to_buy CASH -= available daily_adjustment_note = f"Adj: Bought using {available:.2f} CASH." # Monthly momentum rebalancing block. if current_date in monthly_dates: sorted_tickers, ranks, metrics = rank_assets( prices, current_date, tickers, lookback_period, metric_type) portfolio, trades, pre_rebalance_value = rebalance_portfolio( portfolio, prices, current_date, tickers, sorted_tickers, internal_rebalance_ratios, rebalance_ratio) mask = prices.index < current_date prev_date = prices.index[mask][-1] mom_value = compute_portfolio_value(portfolio, prices, prev_date) total_aum = mom_value + CASH desired_mom_value = target_alloc * total_aum mom_value = compute_portfolio_value(portfolio, prices, current_date) if mom_value > desired_mom_value: excess = mom_value - desired_mom_value cash_adjustment = excess for ticker in portfolio: price = prices.loc[current_date, ticker] ticker_value = portfolio[ticker] * price sell_amount = (ticker_value / mom_value) * excess qty_to_sell = sell_amount / price portfolio[ticker] -= qty_to_sell CASH += excess daily_adjustment_note = f"Monthly: Sold excess {excess:.2f} to CASH." elif mom_value < desired_mom_value and CASH > 0: shortage = desired_mom_value - mom_value available = min(shortage, CASH) cash_adjustment = -available for ticker in portfolio: price = prices.loc[current_date, ticker] ticker_value = portfolio[ticker] * price target_weight = ticker_value / mom_value if mom_value > 0 else 1/len(portfolio) invest_amount = target_weight * available qty_to_buy = invest_amount / price portfolio[ticker] += qty_to_buy CASH -= available daily_adjustment_note = f"Monthly: Bought using {available:.2f} CASH." else: daily_adjustment_note = "Monthly: No cash adjustment needed." # Overweight Adjustment Process. portfolio = adjust_overweight(portfolio, prices, current_date, sorted_tickers, threshold=0.70) # Recalculate portfolio value after overweight adjustments. mom_value = compute_portfolio_value(portfolio, prices, current_date) total_aum = mom_value + CASH ret = (total_aum - prev_total_aum) / prev_total_aum prev_total_aum = total_aum # Log monthly rebalancing event with additional metrics row = { 'Date': current_date, 'Momentum AUM': mom_value, 'CASH': CASH, 'Total AUM': total_aum, 'Current Regime (VIX)': current_regime, 'VIX Target': vix_target_alloc, 'VIX Signal': vix_signal, 'FI Target': fi_target_alloc, 'FI Signal': fi_signal, 'Target Momentum Alloc': target_alloc, 'Adjustment Note': daily_adjustment_note, 'Cash Adjustment': cash_adjustment, 'Return': ret, 'Event': 'Monthly Rebalance', 'FI_EMA_8': fi_8, 'FI_EMA_13': fi_13, 'FI_Slope': fi_slope, 'VIX_1M': vix_1m, 'VIX_3M': vix_3m, 'VIX_1M_ZScore': vix_1m_zscore, 'VIX_3M_ZScore': vix_3m_zscore } for ticker in tickers: price = prices.loc[current_date, ticker] qty = portfolio[ticker] notional = qty * price row[f'qty_{ticker}'] = qty row[f'notional_{ticker}'] = notional row[f'weight_{ticker}'] = (notional / mom_value) if mom_value > 0 else np.nan row[f'rank_{ticker}'] = ranks.get(ticker, np.nan) row[f'metric_{ticker}'] = metrics.get(ticker, np.nan) row[f'trade_{ticker}'] = trades.get(ticker, 0) results.append(row) else: # Log daily signal checks with additional metrics current_mom_value = compute_portfolio_value(portfolio, prices, current_date) total_aum = current_mom_value + CASH ret = (total_aum - prev_total_aum) / prev_total_aum if prev_total_aum > 0 else 0 prev_total_aum = total_aum row = { 'Date': current_date, 'Momentum AUM': current_mom_value, 'CASH': CASH, 'Total AUM': total_aum, 'Current Regime (VIX)': current_regime, 'VIX Target': vix_target_alloc, 'VIX Signal': vix_signal, 'FI Target': fi_target_alloc, 'FI Signal': fi_signal, 'Target Momentum Alloc': target_alloc, 'Adjustment Note': daily_adjustment_note, 'Cash Adjustment': cash_adjustment, 'Return': ret, 'Event': 'Daily Check', 'FI_EMA_8': fi_8, 'FI_EMA_13': fi_13, 'FI_Slope': fi_slope, 'VIX_1M': vix_1m, 'VIX_3M': vix_3m, 'VIX_1M_ZScore': vix_1m_zscore, 'VIX_3M_ZScore': vix_3m_zscore } for ticker in tickers: price = prices.loc[current_date, ticker] qty = portfolio[ticker] notional = qty * price row[f'qty_{ticker}'] = qty row[f'notional_{ticker}'] = notional row[f'weight_{ticker}'] = (notional / current_mom_value) if current_mom_value > 0 else np.nan row[f'rank_{ticker}'] = np.nan row[f'metric_{ticker}'] = np.nan row[f'trade_{ticker}'] = 0 results.append(row) result_df = pd.DataFrame(results) result_df.set_index('Date', inplace=True) return result_df ############################################### # 11. Main – Example Usage ############################################### if __name__ == '__main__': # Define asset tickers. eq_tickers = ['SPY US Equity'] fi_tickers = ['TLT US Equity', 'HYG US Equity'] alts_tickers = ['GLD US Equity', 'SHV US Equity'] initial_aum = 100e6 # 100 million start_date = pd.to_datetime('2008-01-01') end_date = pd.to_datetime('2025-02-01') rebalance_period = 1 # monthly (or adjust as desired) rebalance_ratio = 0.1 # 20% of current momentum AUM rebalanced each period lookback_period = 6 metric_type = 'simple' internal_rebalance_ratios = [0.8, 0.2, 0, -0.2, -0.8] # File paths (adjust these to your environment). price_filepath = r"\\asiapac.nom\data\MUM\IWM\India_IWM_IPAS\Reet\Momentum Strategy\Codes\Historic Prices.xlsx" macro_filepath = r"\\asiapac.nom\data\MUM\IWM\India_IWM_IPAS\Reet\Momentum Strategy\Momentum Strategy Overlay Data.xlsx" prices = load_price_data(price_filepath) macro_data = load_macro_data(macro_filepath) # Run simulation. result_df = simulate_strategy(prices, macro_data, eq_tickers, fi_tickers, alts_tickers, initial_aum, start_date, end_date, rebalance_period, rebalance_ratio, lookback_period, metric_type, internal_rebalance_ratios, macro_max_alloc=1.0, macro_min_alloc=0.6) pd.set_option('display.float_format', lambda x: f'{x:,.2f}') print(result_df)
Editor is loading...
Leave a Comment