How Can My SME Predict Trends and Plan Better with Time Series Analysis?

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from statsmodels.tsa.seasonal import seasonal_decompose
from statsmodels.tsa.holtwinters import ExponentialSmoothing
from datetime import datetime, timedelta

class TimeSeriesAnalyzer:
    def __init__(self, data):
        """
        Initializes the analyzer with time series data
        data: DataFrame with 'date' and 'value' columns
        """
        self.data = data.copy()
        self.data['date'] = pd.to_datetime(self.data['date'])
        self.data = self.data.set_index('date').sort_index()
        self.components = None
        self.model = None
        
    def decompose_series(self, seasonal_period=12):
        """
        Decomposes the series into trend, seasonality, and noise
        """
        self.components = seasonal_decompose(
            self.data['value'], 
            model='multiplicative',
            period=seasonal_period
        )
        
        return self.components
    
    def visualize_components(self):
        """
        Creates graphs of the series components
        """
        if self.components is None:
            self.decompose_series()
        
        fig, axes = plt.subplots(4, 1, figsize=(15, 12))
        
        # Original series
        self.components.observed.plot(ax=axes[0], title='Original Series')
        axes[0].set_ylabel('Value')
        
        # Trend
        self.components.trend.plot(ax=axes[1], title='Trend', color='orange')
        axes[1].set_ylabel('Trend')
        
        # Seasonality
        self.components.seasonal.plot(ax=axes[2], title='Seasonality', color='green')
        axes[2].set_ylabel('Seasonal Factor')
        
        # Noise
        self.components.resid.plot(ax=axes[3], title='Noise/Residuals', color='red')
        axes[3].set_ylabel('Residuals')
        
        plt.tight_layout()
        return fig
    
    def calculate_seasonal_statistics(self):
        """
        Calculates useful statistics about seasonality
        """
        if self.components is None:
            self.decompose_series()
        
        # Extract seasonal component
        seasonal = self.components.seasonal.dropna()
        
        # Calculate statistics by period
        statistics = {
            'maximum_factor': seasonal.max(),
            'minimum_factor': seasonal.min(),
            'seasonal_variation': seasonal.max() - seasonal.min(),
            'peak_period': seasonal.idxmax().month if hasattr(seasonal.idxmax(), 'month') else seasonal.idxmax(),
            'valley_period': seasonal.idxmin().month if hasattr(seasonal.idxmin(), 'month') else seasonal.idxmin(),
            'coefficient_variation': seasonal.std() / seasonal.mean()
        }
        
        return statistics
    
    def train_prediction_model(self, prediction_horizon=12):
        """
        Trains Holt-Winters model for prediction
        """
        # Determine if there's significant seasonality
        if self.components is None:
            self.decompose_series()
        
        statistics = self.calculate_seasonal_statistics()
        has_seasonality = statistics['coefficient_variation'] > 0.1
        
        # Configure model
        if has_seasonality:
            self.model = ExponentialSmoothing(
                self.data['value'],
                trend='add',
                seasonal='mul',
                seasonal_periods=12
            ).fit()
        else:
            self.model = ExponentialSmoothing(
                self.data['value'],
                trend='add'
            ).fit()
        
        # Make predictions
        predictions = self.model.forecast(prediction_horizon)
        
        # Calculate confidence intervals (approximate)
        error_std = np.std(self.model.resid)
        lower_interval = predictions - 1.96 * error_std
        upper_interval = predictions + 1.96 * error_std
        
        return {
            'predictions': predictions,
            'lower_interval': lower_interval,
            'upper_interval': upper_interval,
            'model_info': {
                'aic': self.model.aic,
                'has_seasonality': has_seasonality,
                'average_error': error_std
            }
        }
    
    def generate_insights_report(self):
        """
        Generates report with business insights
        """
        if self.components is None:
            self.decompose_series()
        
        statistics = self.calculate_seasonal_statistics()
        
        # Analyze trend
        trend = self.components.trend.dropna()
        annual_growth = ((trend.iloc[-12:].mean() / trend.iloc[:12].mean()) - 1) * 100
        
        # Volatility
        volatility = self.data['value'].pct_change().std() * 100
        
        report = {
            'trend_summary': {
                'annual_growth_pct': annual_growth,
                'direction': 'Growing' if annual_growth > 5 else 'Declining' if annual_growth < -5 else 'Stable'
            },
            'seasonality_summary': {
                'maximum_variation_pct': (statistics['seasonal_variation'] - 1) * 100,
                'peak_month': statistics['peak_period'],
                'valley_month': statistics['valley_period'],
                'is_significant': statistics['coefficient_variation'] > 0.1
            },
            'volatility': {
                'monthly_volatility_pct': volatility,
                'level': 'High' if volatility > 20 else 'Medium' if volatility > 10 else 'Low'
            },
            'recommendations': self._generate_recommendations(annual_growth, statistics, volatility)
        }
        
        return report
    
    def _generate_recommendations(self, growth, statistics, volatility):
        """
        Generates specific recommendations based on analysis
        """
        recommendations = []
        
        # Trend-based recommendations
        if growth > 10:
            recommendations.append("Consider expanding operational capacity to sustain growth")
            recommendations.append("Plan hiring additional staff")
        elif growth < -10:
            recommendations.append("Review commercial strategy - significant decline detected")
            recommendations.append("Consider product or market diversification")
        
        # Seasonality-based recommendations
        if statistics['coefficient_variation'] > 0.2:
            recommendations.append("Plan inventory and staff according to seasonal patterns")
            recommendations.append("Consider complementary products to stabilize income")
        
        # Volatility-based recommendations
        if volatility > 25:
            recommendations.append("Maintain financial reserves to manage high volatility")
            recommendations.append("Implement alert system for sudden changes")
        
        return recommendations

# Example usage with simulated data
np.random.seed(42)
dates = pd.date_range('2022-01-01', '2024-12-31', freq='M')

# Simulate series with trend, seasonality, and noise
trend = np.linspace(1000, 1500, len(dates))
seasonality = 100 * np.sin(2 * np.pi * np.arange(len(dates)) / 12)
noise = np.random.normal(0, 50, len(dates))
values = trend + seasonality + noise

example_data = pd.DataFrame({
    'date': dates,
    'value': values
})

# Create analyzer
analyzer = TimeSeriesAnalyzer(example_data)

# Decompose and analyze
components = analyzer.decompose_series()
report = analyzer.generate_insights_report()
predictions = analyzer.train_prediction_model(6)

print("=== TIME SERIES ANALYSIS REPORT ===")
print(f"Annual growth: {report['trend_summary']['annual_growth_pct']:.1f}%")
print(f"Direction: {report['trend_summary']['direction']}")
print(f"Maximum seasonal variation: {report['seasonality_summary']['maximum_variation_pct']:.1f}%")
print(f"Volatility: {report['volatility']['level']} ({report['volatility']['monthly_volatility_pct']:.1f}%)")
print("\nRecommendations:")
for rec in report['recommendations']:
    print(f"- {rec}")

import pandas as pd
import numpy as np
from datetime import datetime

def prepare_time_series_data(data_file, date_column, value_column):
    """
    Prepares and cleans data for time series analysis
    """
    # Load data
    df = pd.read_csv(data_file)
    
    # Convert date
    df[date_column] = pd.to_datetime(df[date_column])
    
    # Sort by date
    df = df.sort_values(date_column)
    
    # Detect and handle missing values
    print(f"Missing values detected: {df[value_column].isnull().sum()}")
    
    # Strategies for missing values
    if df[value_column].isnull().sum() > 0:
        # Option 1: Linear interpolation
        df[value_column + '_interpolated'] = df[value_column].interpolate(method='linear')
        
        # Option 2: Moving average
        df[value_column + '_moving_avg'] = df[value_column].fillna(
            df[value_column].rolling(window=7, min_periods=1).mean()
        )
        
        # Option 3: Forward fill
        df[value_column + '_forward_fill'] = df[value_column].fillna(method='ffill')
    
    # Detect outliers using IQR method
    Q1 = df[value_column].quantile(0.25)
    Q3 = df[value_column].quantile(0.75)
    IQR = Q3 - Q1
    lower_bound = Q1 - 1.5 * IQR
    upper_bound = Q3 + 1.5 * IQR
    
    outliers = (df[value_column] < lower_bound) | (df[value_column] > upper_bound)
    print(f"Outliers detected: {outliers.sum()} ({outliers.mean()*100:.1f}% of total)")
    
    # Mark outliers but don't remove (they might be important events)
    df['is_outlier'] = outliers
    
    # Create temporal features
    df['year'] = df[date_column].dt.year
    df['month'] = df[date_column].dt.month
    df['day'] = df[date_column].dt.day
    df['day_of_week'] = df[date_column].dt.dayofweek
    df['week_of_year'] = df[date_column].dt.isocalendar().week
    df['quarter'] = df[date_column].dt.quarter
    
    # Identify special days
    df['is_weekend'] = df['day_of_week'].isin([5, 6])
    df['is_month_start'] = df['day'] <= 5
    df['is_month_end'] = df['day'] >= 26
    
    # Calculate lag features (previous values)
    for lag in [1, 7, 30, 365]:
        if len(df) > lag:
            df[f'lag_{lag}'] = df[value_column].shift(lag)
    
    # Calculate moving averages
    for window in [7, 30, 90]:
        if len(df) >= window:
            df[f'moving_avg_{window}'] = df[value_column].rolling(window=window).mean()
    
    # Calculate growth rates
    df['daily_growth'] = df[value_column].pct_change()
    df['weekly_growth'] = df[value_column].pct_change(periods=7)
    df['monthly_growth'] = df[value_column].pct_change(periods=30)
    
    # Summary statistics
    summary = {
        'total_period': f"{df[date_column].min().date()} to {df[date_column].max().date()}",
        'number_observations': len(df),
        'average_frequency': (df[date_column].max() - df[date_column].min()).days / len(df),
        'average_value': df[value_column].mean(),
        'median_value': df[value_column].median(),
        'standard_deviation': df[value_column].std(),
        'coefficient_variation': df[value_column].std() / df[value_column].mean(),
        'annual_growth_rate': ((df[value_column].iloc[-30:].mean() / df[value_column].iloc[:30].mean()) ** (365/((df[date_column].max() - df[date_column].min()).days)) - 1) * 100
    }
    
    print("\n=== DATA SUMMARY ===")
    for key, value in summary.items():
        if isinstance(value, float):
            print(f"{key}: {value:.2f}")
        else:
            print(f"{key}: {value}")
    
    return df, summary

def validate_data_quality(df, date_column, value_column):
    """
    Validates data quality for time series analysis
    """
    problems = []
    
    # Check temporal regularity
    differences = df[date_column].diff().dropna()
    mode_frequency = differences.mode()[0] if len(differences.mode()) > 0 else None
    irregularities = (differences != mode_frequency).sum()
    
    if irregularities > len(df) * 0.1:  # More than 10% irregular
        problems.append(f"Irregular data: {irregularities} observations don't follow expected frequency")
    
    # Check duplicates
    duplicates = df[date_column].duplicated().sum()
    if duplicates > 0:
        problems.append(f"Duplicate dates: {duplicates} records")
    
    # Check minimum length
    if len(df) < 24:  # Minimum 2 years of monthly data
        problems.append(f"Insufficient data: {len(df)} observations (recommended: >24)")
    
    # Check negative values in series that should be positive
    if (df[value_column] < 0).any():
        negative_values = (df[value_column] < 0).sum()
        problems.append(f"Negative values detected: {negative_values} observations")
    
    # Check variance
    if df[value_column].std() == 0:
        problems.append("Series without variance - all values are equal")
    
    return problems

# Example usage
if __name__ == "__main__":
    # Simulate example data
    dates = pd.date_range('2022-01-01', '2024-12-31', freq='D')
    values = 1000 + np.cumsum(np.random.normal(0, 10, len(dates)))
    
    # Introduce some missing values and outliers
    values[50:55] = np.nan  # Missing values
    values[200] = values[200] * 5  # Outlier
    
    example_data = pd.DataFrame({
        'date': dates,
        'sales': values
    })
    
    # Save example
    example_data.to_csv('example_data.csv', index=False)
    
    # Prepare data
    prepared_df, summary = prepare_time_series_data(
        'example_data.csv', 'date', 'sales'
    )
    
    # Validate quality
    problems = validate_data_quality(prepared_df, 'date', 'sales')
    
    if problems:
        print("\n⚠️ QUALITY PROBLEMS DETECTED:")
        for problem in problems:
            print(f"- {problem}")
    else:
        print("\n✅ Data suitable for time series analysis")

' VBA code to automate basic analysis in Excel
Sub AnalyzeTimeSeries()
    
    ' Set variables
    Dim ws As Worksheet
    Dim dateRange As Range
    Dim valueRange As Range
    Dim lastRow As Long
    
    Set ws = ActiveSheet
    lastRow = ws.Cells(ws.Rows.Count, "A").End(xlUp).Row
    
    ' Define data ranges
    Set dateRange = ws.Range("A2:A" & lastRow)
    Set valueRange = ws.Range("B2:B" & lastRow)
    
    ' Calculate trend (linear regression)
    ws.Range("D1").Value = "Trend"
    For i = 2 To lastRow
        ws.Cells(i, 4).Formula = "=TREND($B$2:$B$" & lastRow & ",$A$2:$A$" & lastRow & ",A" & i & ")"
    Next i
    
    ' Calculate moving average (12 periods)
    ws.Range("E1").Value = "Moving Average 12"
    For i = 13 To lastRow ' Start from period 13
        ws.Cells(i, 5).Formula = "=AVERAGE(B" & (i - 11) & ":B" & i & ")"
    Next i
    
    ' Calculate growth from previous period
    ws.Range("F1").Value = "Growth %"
    For i = 3 To lastRow
        ws.Cells(i, 6).Formula = "=(B" & i & "-B" & (i - 1) & ")/B" & (i - 1)
        ws.Cells(i, 6).NumberFormat = "0.0%"
    Next i
    
    ' Identify seasonality (comparison with previous year)
    ws.Range("G1").Value = "Seasonal"
    For i = 14 To lastRow ' Start from month 14 to have complete year
        ws.Cells(i, 7).Formula = "=B" & i & "/B" & (i - 12)
    Next i
    
    ' Create automatic chart
    Dim chart As ChartObject
    Set chart = ws.ChartObjects.Add(Left:=350, Top:=50, Width:=400, Height:=250)
    
    With chart.Chart
        .ChartType = xlLineMarkers
        .SetSourceData Source:=Union(dateRange, valueRange)
        .HasTitle = True
        .ChartTitle.Text = "Time Series Analysis"
        .Axes(xlCategory).HasTitle = True
        .Axes(xlCategory).AxisTitle.Text = "Date"
        .Axes(xlValue).HasTitle = True
        .Axes(xlValue).AxisTitle.Text = "Value"
    End With
    
    ' Calculate descriptive statistics
    ws.Range("I1").Value = "Statistics"
    ws.Range("I2").Value = "Average:"
    ws.Range("J2").Formula = "=AVERAGE(B:B)"
    ws.Range("I3").Value = "Median:"
    ws.Range("J3").Formula = "=MEDIAN(B:B)"
    ws.Range("I4").Value = "Std Deviation:"
    ws.Range("J4").Formula = "=STDEV(B:B)"
    ws.Range("I5").Value = "Coef. Variation:"
    ws.Range("J5").Formula = "=J4/J2"
    ws.Range("J5").NumberFormat = "0.0%"
    
    ' Simple prediction (next 3 months)
    ws.Range("I7").Value = "Predictions:"
    For i = 1 To 3
        ws.Cells(7 + i, 9).Value = "Month +" & i & ":"
        ws.Cells(7 + i, 10).Formula = "=FORECAST(A" & lastRow & "+" & (i * 30) & ",B:B,A:A)"
    Next i
    
    MsgBox "Analysis completed. Review results in columns D-J."
    
End Sub

' Function to detect outliers
Function IsOutlier(value As Double, range As Range) As Boolean
    Dim Q1 As Double, Q3 As Double, IQR As Double
    
    Q1 = Application.WorksheetFunction.Quartile(range, 1)
    Q3 = Application.WorksheetFunction.Quartile(range, 3)
    IQR = Q3 - Q1
    
    If value < (Q1 - 1.5 * IQR) Or value > (Q3 + 1.5 * IQR) Then
        IsOutlier = True
    Else
        IsOutlier = False
    End If
End Function

' Macro to identify trends
Sub IdentifyTrends()
    Dim ws As Worksheet
    Dim lastRow As Long
    Dim slope As Double
    
    Set ws = ActiveSheet
    lastRow = ws.Cells(ws.Rows.Count, "A").End(xlUp).Row
    
    ' Calculate trend slope
    slope = Application.WorksheetFunction.Slope(ws.Range("B2:B" & lastRow), ws.Range("A2:A" & lastRow))
    
    ' Interpret trend
    ws.Range("I12").Value = "Trend:"
    If slope > 0.1 Then
        ws.Range("J12").Value = "Growing"
    ElseIf slope < -0.1 Then
        ws.Range("J12").Value = "Declining"
    Else
        ws.Range("J12").Value = "Stable"
    End If
    
    ws.Range("I13").Value = "Slope:"
    ws.Range("J13").Value = Round(slope, 4)
    
End Sub

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import matplotlib.pyplot as plt

class TimeSeriesMonitor:
    def __init__(self):
        self.metrics_history = []
        self.thresholds = {
            'max_mape': 15,
            'min_directional_accuracy': 70,
            'min_r2': 0.7
        }
    
    def evaluate_model(self, dates, actual_values, predictions, series_name="Series"):
        """
        Evaluates model performance and updates historical metrics
        """
        # Calculate basic metrics
        mape = np.mean(np.abs((actual_values - predictions) / actual_values)) * 100
        mae = np.mean(np.abs(actual_values - predictions))
        rmse = np.sqrt(np.mean((actual_values - predictions)**2))
        
        # R² (coefficient of determination)
        ss_res = np.sum((actual_values - predictions)**2)
        ss_tot = np.sum((actual_values - np.mean(actual_values))**2)
        r2 = 1 - (ss_res / ss_tot) if ss_tot != 0 else 0
        
        # Directional accuracy (correctly predict ups/downs)
        actual_changes = np.diff(actual_values) > 0
        predicted_changes = np.diff(predictions) > 0
        directional_accuracy = np.mean(actual_changes == predicted_changes) * 100
        
        # Model bias
        bias = np.mean((predictions - actual_values) / actual_values) * 100
        
        # Create evaluation record
        evaluation = {
            'evaluation_date': datetime.now(),
            'series': series_name,
            'period_evaluated': f"{dates[0]} to {dates[-1]}",
            'num_observations': len(actual_values),
            'mape': mape,
            'mae': mae,
            'rmse': rmse,
            'r2': r2,
            'directional_accuracy': directional_accuracy,
            'bias': bias,
            'meets_mape': mape <= self.thresholds['max_mape'],
            'meets_accuracy': directional_accuracy >= self.thresholds['min_directional_accuracy'],
            'meets_r2': r2 >= self.thresholds['min_r2']
        }
        
        self.metrics_history.append(evaluation)
        
        return evaluation
    
    def generate_quality_alert(self, evaluation):
        """
        Generates alerts based on model quality
        """
        alerts = []
        
        if not evaluation['meets_mape']:
            alerts.append(f"⚠️ High MAPE: {evaluation['mape']:.1f}% (target: <{self.thresholds['max_mape']}%)")
        
        if not evaluation['meets_accuracy']:
            alerts.append(f"⚠️ Low directional accuracy: {evaluation['directional_accuracy']:.1f}% (target: >{self.thresholds['min_directional_accuracy']}%)")
        
        if not evaluation['meets_r2']:
            alerts.append(f"⚠️ Low R²: {evaluation['r2']:.3f} (target: >{self.thresholds['min_r2']})")
        
        if abs(evaluation['bias']) > 10:
            alerts.append(f"⚠️ Significant bias: {evaluation['bias']:.1f}% (model consistently over/underestimates)")
        
        return alerts
    
    def performance_dashboard(self):
        """
        Creates model performance dashboard
        """
        if len(self.metrics_history) == 0:
            print("No historical data to display")
            return
        
        df = pd.DataFrame(self.metrics_history)
        
        fig, axes = plt.subplots(2, 2, figsize=(15, 10))
        
        # MAPE evolution
        axes[0,0].plot(df['evaluation_date'], df['mape'], marker='o')
        axes[0,0].axhline(y=self.thresholds['max_mape'], color='r', linestyle='--', label=f'Target (<{self.thresholds["max_mape"]}%)')
        axes[0,0].set_title('MAPE Evolution')
        axes[0,0].set_ylabel('MAPE (%)')
        axes[0,0].legend()
        axes[0,0].grid(True, alpha=0.3)
        
        # Directional accuracy
        axes[0,1].plot(df['evaluation_date'], df['directional_accuracy'], marker='s', color='green')
        axes[0,1].axhline(y=self.thresholds['min_directional_accuracy'], color='r', linestyle='--', label=f'Target (>{self.thresholds["min_directional_accuracy"]}%)')
        axes[0,1].set_title('Directional Accuracy')
        axes[0,1].set_ylabel('Accuracy (%)')
        axes[0,1].legend()
        axes[0,1].grid(True, alpha=0.3)
        
        # R²
        axes[1,0].plot(df['evaluation_date'], df['r2'], marker='^', color='orange')
        axes[1,0].axhline(y=self.thresholds['min_r2'], color='r', linestyle='--', label=f'Target (>{self.thresholds["min_r2"]})')
        axes[1,0].set_title('Coefficient of Determination (R²)')
        axes[1,0].set_ylabel('R²')
        axes[1,0].legend()
        axes[1,0].grid(True, alpha=0.3)
        
        # Error distribution
        axes[1,1].hist(df['mape'], bins=10, alpha=0.7, color='skyblue', edgecolor='black')
        axes[1,1].axvline(x=self.thresholds['max_mape'], color='r', linestyle='--', label=f'Target (<{self.thresholds["max_mape"]}%)')
        axes[1,1].set_title('Error Distribution (MAPE)')
        axes[1,1].set_xlabel('MAPE (%)')
        axes[1,1].set_ylabel('Frequency')
        axes[1,1].legend()
        axes[1,1].grid(True, alpha=0.3)
        
        plt.tight_layout()
        plt.show()
        
        return fig
    
    def summary_report(self):
        """
        Generates executive performance report
        """
        if len(self.metrics_history) == 0:
            return "No data to generate report"
        
        df = pd.DataFrame(self.metrics_history)
        
        # General statistics
        report = {
            'analysis_period': f"{df['evaluation_date'].min().date()} to {df['evaluation_date'].max().date()}",
            'number_evaluations': len(df),
            'average_mape': df['mape'].mean(),
            'best_mape': df['mape'].min(),
            'worst_mape': df['mape'].max(),
            'average_directional_accuracy': df['directional_accuracy'].mean(),
            'average_r2': df['r2'].mean(),
            'mape_compliance_percentage': (df['meets_mape'].sum() / len(df)) * 100,
            'accuracy_compliance_percentage': (df['meets_accuracy'].sum() / len(df)) * 100,
            'r2_compliance_percentage': (df['meets_r2'].sum() / len(df)) * 100,
            'improvement_trend': df['mape'].iloc[-3:].mean() < df['mape'].iloc[:3].mean() if len(df) >= 6 else None
        }
        
        # Generate recommendations
        recommendations = []
        
        if report['average_mape'] > self.thresholds['max_mape']:
            recommendations.append("Review model: average MAPE above target")
        
        if report['mape_compliance_percentage'] < 70:
            recommendations.append("Consider retraining: low MAPE target compliance")
        
        if report['average_r2'] < 0.6:
            recommendations.append("Evaluate additional variables: low model explanatory power")
        
        if report['improvement_trend'] is False:
            recommendations.append("Investigate degradation: model is getting worse over time")
        
        report['recommendations'] = recommendations
        
        return report

# Example usage
monitor = TimeSeriesMonitor()

# Simulate monthly evaluations
for i in range(6):
    # Generate simulated data
    dates = pd.date_range(start=datetime.now() - timedelta(days=30*(i+1)), periods=30, freq='D')
    actual_values = np.random.normal(1000, 100, 30)
    # Simulate predictions with some error
    predictions = actual_values + np.random.normal(0, 50, 30)
    
    evaluation = monitor.evaluate_model(dates, actual_values, predictions, "Sales")
    alerts = monitor.generate_quality_alert(evaluation)
    
    if alerts:
        print(f"\nMonth {i+1} - Alerts detected:")
        for alert in alerts:
            print(alert)

# Generate final report
report = monitor.summary_report()
print("\n=== EXECUTIVE PERFORMANCE REPORT ===")
print(f"Analysis period: {report['analysis_period']}")
print(f"Average MAPE: {report['average_mape']:.1f}%")
print(f"MAPE target compliance: {report['mape_compliance_percentage']:.0f}%")
print(f"Directional accuracy: {report['average_directional_accuracy']:.1f}%")

if report['recommendations']:
    print("\nRecommendations:")
    for rec in report['recommendations']:
        print(f"- {rec}")