ResultsAnalyzer

class ResultsAnalyzer:
    """Analyzes ML experiment results using Gemini 3.

    Key features:
    - Compares metrics against baseline, best, and previous
    - Detects performance trends (improving, degrading, plateau)
    - Handles lower-is-better vs higher-is-better metrics correctly
    - Generates key observations for next iteration
    - Maintains conversation context for Thought Signature continuity
    """

    def __init__(self, gemini_client: GeminiClient):
        """Initialize the results analyzer.

        Args:
            gemini_client: Shared GeminiClient instance for API calls.
        """

def analyze(
    self,
    current_result: ExperimentResult,
    state: ExperimentState,
) -> AnalysisResult:
    """Analyze the results of a completed experiment.

    Args:
        current_result: The experiment result to analyze.
        state: Current experiment state with history.

    Returns:
        AnalysisResult with comparisons and observations.
    """

def get_analysis_count(self) -> int:
    """Get the number of analyses performed."""

@dataclass
class MetricComparison:
    metric_name: str
    current_value: float
    baseline_value: Optional[float]
    best_value: Optional[float]
    previous_value: Optional[float]
    change_from_baseline_pct: Optional[float]
    change_from_best_pct: Optional[float]
    change_from_previous_pct: Optional[float]
    is_improvement: bool
    is_new_best: bool

class TrendPattern(Enum):
    INITIAL = "initial"          # Fewer than 3 experiments
    IMPROVING = "improving"      # Consistent improvement over 2+ iterations
    DEGRADING = "degrading"      # Consistent degradation over 2+ iterations
    PLATEAU = "plateau"          # Less than 0.5% change for 2+ iterations
    FLUCTUATING = "fluctuating"  # Alternating improvement/degradation

from src.cognitive.gemini_client import GeminiClient
from src.cognitive.results_analyzer import ResultsAnalyzer

# Initialize
client = GeminiClient()
analyzer = ResultsAnalyzer(gemini_client=client)

# Analyze latest result
analysis = analyzer.analyze(
    current_result=latest_result,
    state=experiment_state
)

print(f"Success: {analysis.success}")
print(f"Trend: {analysis.trend_pattern.value}")
print(f"\nKey Observations:")
for obs in analysis.key_observations:
    print(f"  - {obs}")

analysis = analyzer.analyze(current_result, state)

if analysis.primary_metric:
    mc = analysis.primary_metric
    print(f"Metric: {mc.metric_name}")
    print(f"Current: {mc.current_value:.6f}")
    print(f"Baseline: {mc.baseline_value:.6f}")
    print(f"Best: {mc.best_value:.6f}")
    print(f"")
    print(f"Change from baseline: {mc.change_from_baseline_pct:+.2f}%")
    print(f"Change from best: {mc.change_from_best_pct:+.2f}%")
    print(f"Change from previous: {mc.change_from_previous_pct:+.2f}%")
    print(f"")
    print(f"Is improvement: {mc.is_improvement}")
    print(f"Is new best: {mc.is_new_best}")

analysis = analyzer.analyze(current_result, state)

trend = analysis.trend_pattern

if trend == TrendPattern.IMPROVING:
    print("Performance is consistently improving!")
elif trend == TrendPattern.PLATEAU:
    print("Performance has plateaued - consider new approaches")
elif trend == TrendPattern.DEGRADING:
    print("Performance is degrading - revert to previous approach")
elif trend == TrendPattern.FLUCTUATING:
    print("Performance is unstable - need more consistent approach")
else:
    print("Too early to detect a trend")

# Failed experiment
failed_result = ExperimentResult(
    experiment_name="test_xgboost",
    iteration=3,
    model_type="XGBRegressor",
    metrics={},
    success=False,
    error_message="Memory error during training"
)

analysis = analyzer.analyze(failed_result, state)

if not analysis.success:
    print(f"Experiment failed: {analysis.key_observations[0]}")
    print(f"Reasoning: {analysis.reasoning}")

from src.orchestration.state import ExperimentState

# Initialize components
client = GeminiClient()
analyzer = ResultsAnalyzer(gemini_client=client)
state = ExperimentState(config=config)

# Execute and analyze experiments
for iteration in range(1, 11):
    # Execute experiment (returns ExperimentResult)
    result = execute_experiment(spec)
    
    # Analyze results
    analysis = analyzer.analyze(
        current_result=result,
        state=state
    )
    
    # Log insights
    print(f"\n=== Iteration {iteration} Analysis ===")
    print(f"Trend: {analysis.trend_pattern.value}")
    
    if analysis.primary_metric and analysis.primary_metric.is_new_best:
        print("NEW BEST RESULT!")
    
    print("\nObservations:")
    for obs in analysis.key_observations:
        print(f"  - {obs}")
    
    # Update state
    state.add_experiment(result)
    
    # Use analysis for early stopping
    if analysis.trend_pattern == TrendPattern.PLATEAU:
        if state.iterations_without_improvement >= 3:
            print("Stopping: Plateau detected for 3 iterations")
            break

print(f"\nTotal analyses: {analyzer.get_analysis_count()}")

# Access the internal comparison method for custom metrics
from src.cognitive.results_analyzer import ResultsAnalyzer

analyzer = ResultsAnalyzer(client)

# Compute comparison for a specific metric
comparison = analyzer._compute_metric_comparison(
    current_result=result,
    state=state,
    primary_metric="mae"  # Custom metric
)

if comparison:
    print(f"MAE comparison: {comparison.change_from_baseline_pct:+.2f}%")

# When Gemini fails, analyzer provides basic template-based analysis
try:
    analysis = analyzer.analyze(current_result, state)
    
    # Check if fallback was used
    if "fallback" in analysis.reasoning.lower():
        print("Using fallback analysis (Gemini unavailable)")
        # Fallback still includes metric comparisons and trend detection
        print(f"Trend: {analysis.trend_pattern.value}")
        if analysis.primary_metric:
            print(f"Change: {analysis.primary_metric.change_from_baseline_pct:+.2f}%")
except Exception as e:
    print(f"Analysis failed: {e}")