1import sys
 2from pathlib import Path
 3import numpy as np
 4import pandas as pd
 5import matplotlib.pyplot as plt
 6import seaborn as sns
 7from datetime import datetime, timedelta
 8import warnings
 9warnings.filterwarnings('ignore')
10
11# Add parent to path
12sys.path.insert(0, str(Path().absolute().parent))
13
14# Import hidden_regime using the full API
15import hidden_regime as hr
16
17# Plotting
18plt.style.use('seaborn-v0_8-whitegrid')
19sns.set_palette(sns.color_palette())
20
21print("Imports complete")
22print(f"hidden-regime version: {hr.__version__}")

 1# Create a complete financial pipeline with one function call
 2ticker = 'NVDA'
 3n_states = 3
 4
 5pipeline = hr.create_financial_pipeline(
 6    ticker=ticker,
 7    n_states=n_states,
 8    include_report=False  # We'll do custom analysis
 9)
10
11# Display pipeline components
12print(f"Pipeline created for {ticker} with {n_states} states")
13print(f"  Data loader: {type(pipeline.data).__name__}")
14print(f"  Observations: {type(pipeline.observation).__name__}")
15print(f"  Model: {type(pipeline.model).__name__}")
16print(f"  Analysis: {type(pipeline.analysis).__name__}")

1# Execute pipeline
2report = pipeline.update()
3
4# Get analysis results
5result = pipeline.component_outputs['analysis']
6
7# Display summary
8print(f"Analysis complete: {result.shape[0]} days, {result.shape[1]} metrics")
9print(f"Date range: {result.index[0].date()} to {result.index[-1].date()}")

  1# Get raw data with log returns
  2raw_data = pipeline.data.get_all_data()
  3
  4# Find log_return column (case-insensitive)
  5log_return_col = None
  6for col in raw_data.columns:
  7    if col.lower() == 'log_return':
  8        log_return_col = col
  9        break
 10
 11# Prepare regime data for visualization
 12regimes = result['regime_name'].unique()
 13regime_stats = []
 14
 15for regime in sorted(regimes):
 16    regime_data = result[result['regime_name'] == regime]
 17    n_days = len(regime_data)
 18    pct_time = n_days / len(result) * 100
 19    state_num = regime_data['predicted_state'].iloc[0]
 20    
 21    stats = {
 22        'regime': regime,
 23        'state': state_num,
 24        'days': n_days,
 25        'pct_time': pct_time
 26    }
 27    
 28    # Get log returns for this regime by aligning indices
 29    if log_return_col is not None:
 30        regime_indices = regime_data.index
 31        obs_returns = raw_data.loc[regime_indices, log_return_col].dropna()
 32        
 33        if len(obs_returns) > 0:
 34            avg_log = obs_returns.mean()
 35            avg_pct = hr.log_return_to_percent_change(avg_log) * 100
 36            vol_daily = obs_returns.std() * 100
 37            vol_annual = vol_daily * np.sqrt(252)
 38            
 39            stats.update({
 40                'daily_return': avg_pct,
 41                'daily_vol': vol_daily,
 42                'annual_return': avg_pct * 252,
 43                'annual_vol': vol_annual
 44            })
 45    
 46    regime_stats.append(stats)
 47
 48# Create visualization with larger figure size
 49fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(18, 7))
 50
 51# Get regime colors
 52unique_regimes = sorted(result['regime_name'].unique())
 53from hidden_regime.visualization import get_regime_colors
 54color_list = get_regime_colors(len(unique_regimes), color_scheme="colorblind_safe")
 55regime_colors = dict(zip(unique_regimes, color_list))
 56
 57# Left: Pie chart of regime distribution
 58sizes = [s['pct_time'] for s in regime_stats]
 59labels = [f"{s['regime']}\n{s['pct_time']:.1f}%" for s in regime_stats]
 60colors = [regime_colors[s['regime']] for s in regime_stats]
 61
 62wedges, texts, autotexts = ax1.pie(sizes, labels=labels, colors=colors, autopct='',
 63                                     startangle=90, textprops={'fontsize': 13, 'fontweight': 'bold'})
 64ax1.set_title('Regime Distribution\n(% of Time)', fontsize=15, fontweight='bold', pad=20)
 65
 66# Right: Bar chart of returns by regime
 67regime_names = [s['regime'] for s in regime_stats]
 68returns = [s.get('annual_return', 0) for s in regime_stats]
 69bar_colors = [regime_colors[s['regime']] for s in regime_stats]
 70
 71bars = ax2.barh(regime_names, returns, color=bar_colors, alpha=0.7, edgecolor='black', linewidth=1.5)
 72ax2.axvline(x=0, color='black', linestyle='-', linewidth=0.8)
 73ax2.set_xlabel('Annualized Return (%)', fontsize=13)
 74ax2.set_ylabel('Regime', fontsize=13)
 75ax2.set_title('Expected Returns by Regime', fontsize=15, fontweight='bold', pad=20)
 76ax2.grid(True, alpha=0.3, axis='x')
 77ax2.tick_params(axis='both', labelsize=12)
 78
 79# Add value labels on bars
 80for i, (bar, val) in enumerate(zip(bars, returns)):
 81    if val != 0:  # Only add label if we have data
 82        label_x = val + (3 if val > 0 else -3)
 83        ha = 'left' if val > 0 else 'right'
 84        ax2.text(label_x, bar.get_y() + bar.get_height()/2, 
 85                 f'{val:+.1f}%', ha=ha, va='center', fontweight='bold', fontsize=12)
 86
 87plt.tight_layout()
 88plt.show()
 89
 90# Print detailed statistics
 91print("\nDetailed Regime Characteristics")
 92print("=" * 80)
 93for s in regime_stats:
 94    print(f"\n{s['regime']} (State {s['state']})")
 95    print("-" * 80)
 96    print(f"  Frequency:   {s['days']} days ({s['pct_time']:.1f}% of period)")
 97    if 'daily_return' in s:
 98        print(f"  Daily:       mu = {s['daily_return']:+.3f}%  sigma = {s['daily_vol']:.3f}%")
 99        print(f"  Annualized:  mu = {s['annual_return']:+.1f}%  sigma = {s['annual_vol']:.1f}%")
100print("=" * 80)

 1# Analyze current regime
 2current = result.iloc[-1]
 3current_regime = current['regime_name']
 4
 5# Count consecutive days in regime
 6days_in_regime = 1
 7for i in range(len(result)-2, -1, -1):
 8    if result.iloc[i]['regime_name'] == current_regime:
 9        days_in_regime += 1
10    else:
11        break
12
13# Get state probabilities
14state_probs = []
15state_names = []
16for state in range(n_states):
17    col_name = f'state_{state}_prob'
18    if col_name in result.columns:
19        prob = current[col_name]
20        # Find regime name for this state
21        state_regime = result[result['predicted_state'] == state]['regime_name'].iloc[0] \
22                      if len(result[result['predicted_state'] == state]) > 0 else f"State {state}"
23        state_probs.append(prob)
24        state_names.append(state_regime)
25
26# Create bar chart
27fig, ax = plt.subplots(figsize=(12, 5))
28
29# Get colors for bars
30unique_regimes = sorted(result['regime_name'].unique())
31from hidden_regime.visualization import get_regime_colors
32color_list = get_regime_colors(len(unique_regimes), color_scheme="colorblind_safe")
33regime_colors = dict(zip(unique_regimes, color_list))
34bar_colors = [regime_colors.get(name, 'gray') for name in state_names]
35
36# Create horizontal bar chart
37bars = ax.barh(state_names, state_probs, color=bar_colors, alpha=0.7, edgecolor='black', linewidth=2)
38
39# Highlight the current regime (max probability)
40max_idx = np.argmax(state_probs)
41bars[max_idx].set_alpha(1.0)
42bars[max_idx].set_linewidth(3)
43
44# Add percentage labels
45for i, (bar, prob) in enumerate(zip(bars, state_probs)):
46    ax.text(prob + 0.02, bar.get_y() + bar.get_height()/2, 
47            f'{prob*100:.1f}%', ha='left', va='center', fontweight='bold', fontsize=11)
48
49# Formatting
50ax.set_xlim(0, 1.1)
51ax.set_xlabel('Probability', fontsize=12)
52ax.set_title(f'Current Market Regime: {current_regime} ' +
53             f'(Confidence: {current["confidence"]*100:.1f}%)', 
54             fontsize=14, fontweight='bold', pad=15)
55ax.grid(True, alpha=0.3, axis='x')
56
57# Add vertical line at confidence threshold
58ax.axvline(x=0.8, color='green', linestyle='--', alpha=0.5, linewidth=2, label='High confidence (>80%)')
59ax.legend(loc='lower right')
60
61plt.tight_layout()
62plt.show()
63
64# Print summary
65print(f"\nCurrent Market Status")
66print("=" * 70)
67print(f"  Date:       {result.index[-1].date()}")
68print(f"  Regime:     {current_regime}")
69print(f"  Confidence: {current['confidence']*100:.1f}%")
70print(f"  Duration:   {days_in_regime} days in current regime")
71print("=" * 70)

 1# Calculate regime durations
 2def calculate_regime_durations(df):
 3    """Calculate duration of each regime period"""
 4    durations = []
 5    current_regime = df.iloc[0]['regime_name']
 6    current_duration = 1
 7    
 8    for i in range(1, len(df)):
 9        if df.iloc[i]['regime_name'] == current_regime:
10            current_duration += 1
11        else:
12            durations.append({
13                'regime': current_regime,
14                'duration': current_duration,
15                'start': df.index[i-current_duration],
16                'end': df.index[i-1]
17            })
18            current_regime = df.iloc[i]['regime_name']
19            current_duration = 1
20    
21    # Add final period
22    durations.append({
23        'regime': current_regime,
24        'duration': current_duration,
25        'start': df.index[len(df)-current_duration],
26        'end': df.index[-1]
27    })
28    
29    return pd.DataFrame(durations)
30
31durations_df = calculate_regime_durations(result)
32
33# Display statistics
34print("Regime Duration Statistics")
35print("=" * 70)
36print(f"Total regime transitions: {len(durations_df)}\n")
37
38for regime in sorted(durations_df['regime'].unique()):
39    regime_durs = durations_df[durations_df['regime'] == regime]['duration']
40    
41    print(f"{regime}:")
42    print(f"  Occurrences: {len(regime_durs)} periods")
43    print(f"  Average:     {regime_durs.mean():.1f} days  (median: {regime_durs.median():.0f})")
44    print(f"  Range:       {regime_durs.min()} - {regime_durs.max()} days")
45    print()
46
47# Show longest periods
48print("Longest Regime Periods:")
49print("-" * 70)
50longest = durations_df.nlargest(5, 'duration')
51for idx, row in longest.iterrows():
52    print(f"  {row['regime']:<12} {row['duration']:>3} days  " +
53          f"({row['start'].date()} → {row['end'].date()})")
54print("=" * 70)

 1# Create regime visualization
 2fig, axes = plt.subplots(3, 1, figsize=(16, 12), sharex=True)
 3
 4# Get raw price data
 5raw_data = pipeline.data.get_all_data()
 6close_col = next((col for col in raw_data.columns if col.lower() == 'close'), None)
 7
 8if close_col is None:
 9    raise ValueError("Could not find 'close' column in data")
10
11# Get regime colors
12unique_regimes = sorted(result['regime_name'].unique())
13from hidden_regime.visualization import get_regime_colors
14color_list = get_regime_colors(len(unique_regimes), color_scheme="colorblind_safe")
15regime_colors = dict(zip(unique_regimes, color_list))
16
17# Panel 1: Price with regime shading
18ax = axes[0]
19ax.plot(raw_data.index, raw_data[close_col], linewidth=1.5, color='black', zorder=2)
20ax.set_ylabel('Price ($)', fontsize=12)
21ax.set_title(f'{ticker} Price with Detected Regimes', fontsize=14, fontweight='bold')
22ax.grid(True, alpha=0.3)
23
24# Shade background by regime
25for i in range(len(result)):
26    regime = result.iloc[i]['regime_name']
27    color = regime_colors.get(regime, 'gray')
28    ax.axvspan(result.index[i], result.index[min(i+1, len(result)-1)], 
29               alpha=0.2, color=color, zorder=1)
30
31# Add legend
32from matplotlib.patches import Patch
33legend_elements = [Patch(facecolor=regime_colors.get(r, 'gray'), alpha=0.3, label=r) 
34                   for r in unique_regimes]
35ax.legend(handles=legend_elements, loc='upper left')
36
37# Panel 2: Confidence levels
38ax = axes[1]
39confidence_pct = result['confidence'] * 100
40
41ax.plot(result.index, confidence_pct, linewidth=1.5, color='blue', label='Confidence')
42ax.axhline(y=80, color='green', linestyle='--', alpha=0.5, label='High (>80%)')
43ax.axhline(y=60, color='orange', linestyle='--', alpha=0.5, label='Medium')
44
45# Shade confidence regions
46ax.fill_between(result.index, 0, confidence_pct, 
47                where=(confidence_pct > 80), alpha=0.2, color='green')
48ax.fill_between(result.index, 0, confidence_pct, 
49                where=(confidence_pct < 60), alpha=0.2, color='red')
50
51ax.set_ylabel('Confidence (%)', fontsize=12)
52ax.set_title('Regime Detection Confidence', fontsize=14, fontweight='bold')
53ax.grid(True, alpha=0.3)
54ax.legend(loc='lower left')
55ax.set_ylim(0, 105)
56
57# Panel 3: Regime timeline
58ax = axes[2]
59for i in range(len(result)):
60    regime = result.iloc[i]['regime_name']
61    color = regime_colors.get(regime, 'gray')
62    ax.bar(result.index[i], 1, width=1, color=color, edgecolor='none', alpha=0.7)
63
64ax.set_ylabel('Regime', fontsize=12)
65ax.set_xlabel('Date', fontsize=12)
66ax.set_title('Regime Sequence Timeline', fontsize=14, fontweight='bold')
67ax.set_ylim(0, 1.2)
68ax.set_yticks([])
69ax.grid(True, alpha=0.3, axis='x')
70
71plt.tight_layout()
72plt.show()

 1# Compare models with different numbers of states
 2comparison_results = []
 3
 4print("Training models with 2-5 states...\n")
 5
 6for n in [2, 3, 4, 5]:
 7    print(f"  {n} states... ", end='', flush=True)
 8    
 9    test_pipeline = hr.create_financial_pipeline(
10        ticker=ticker,
11        n_states=n,
12        include_report=False
13    )
14    
15    _ = test_pipeline.update()
16    test_result = test_pipeline.component_outputs['analysis']
17    
18    # Calculate metrics
19    n_params = n**2 + 2*n  # Transitions + emissions
20    n_obs = len(test_result)
21    switches = (test_result['predicted_state'].diff() != 0).sum()
22    avg_duration = n_obs / switches if switches > 0 else n_obs
23    avg_conf = test_result['confidence'].mean() * 100
24    
25    comparison_results.append({
26        'States': n,
27        'Parameters': n_params,
28        'Switches': switches,
29        'Avg Duration': f"{avg_duration:.1f}",
30        'Avg Confidence': f"{avg_conf:.1f}%"
31    })
32    
33    print("done")
34
35# Display comparison table
36comp_df = pd.DataFrame(comparison_results)
37print("\n" + "=" * 70)
38print("Model Comparison Results")
39print("=" * 70)
40print(comp_df.to_string(index=False))
41print("=" * 70)