File size: 3,426 Bytes
c40c447
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
"""
Interface para modelos de forecasting.

Este m贸dulo define la abstracci贸n IForecastModel que permite
diferentes implementaciones de modelos (Chronos, Prophet, ARIMA, etc.)
cumpliendo con DIP (Dependency Inversion Principle).
"""

from abc import ABC, abstractmethod
from typing import List, Dict, Any, Optional
import pandas as pd


class IForecastModel(ABC):
    """
    Interface para modelos de forecasting.
    
    Esta abstracci贸n permite que diferentes implementaciones de modelos
    sean intercambiables sin modificar el c贸digo que las usa (DIP + LSP).
    
    Ejemplos de implementaciones:
        - ChronosModel (Chronos-2)
        - ProphetModel (Facebook Prophet)
        - ARIMAModel (ARIMA tradicional)
    """
    
    @abstractmethod
    def predict(
        self,
        context_df: pd.DataFrame,
        prediction_length: int,
        quantile_levels: List[float],
        **kwargs
    ) -> pd.DataFrame:
        """
        Genera pron贸sticos probabil铆sticos.
        
        Args:
            context_df: DataFrame con datos hist贸ricos.
                       Debe contener columnas: id, timestamp, target
            prediction_length: N煤mero de pasos a predecir
            quantile_levels: Lista de cuantiles a calcular (ej: [0.1, 0.5, 0.9])
            **kwargs: Par谩metros adicionales espec铆ficos del modelo
        
        Returns:
            pd.DataFrame: Pron贸sticos con columnas:
                         - id: Identificador de serie
                         - timestamp: Timestamp de predicci贸n
                         - predictions: Valor mediano
                         - {q}: Valor para cada cuantil q
        
        Raises:
            ValueError: Si los datos de entrada son inv谩lidos
            RuntimeError: Si el modelo falla al predecir
        """
        pass
    
    @abstractmethod
    def get_model_info(self) -> Dict[str, Any]:
        """
        Retorna informaci贸n del modelo.
        
        Returns:
            Dict con informaci贸n del modelo:
                - type: Tipo de modelo (ej: "Chronos2", "Prophet")
                - model_id: ID del modelo
                - version: Versi贸n del modelo
                - device: Dispositivo usado (cpu/cuda)
                - otros campos espec铆ficos del modelo
        """
        pass
    
    def validate_context(self, context_df: pd.DataFrame) -> bool:
        """
        Valida que el DataFrame de contexto tenga el formato correcto.
        
        Args:
            context_df: DataFrame a validar
        
        Returns:
            bool: True si es v谩lido
        
        Raises:
            ValueError: Si el DataFrame es inv谩lido
        """
        required_columns = {"id", "timestamp", "target"}
        
        if not isinstance(context_df, pd.DataFrame):
            raise ValueError("context_df debe ser un pandas DataFrame")
        
        missing_columns = required_columns - set(context_df.columns)
        if missing_columns:
            raise ValueError(
                f"Faltan columnas requeridas: {missing_columns}. "
                f"Se encontraron: {set(context_df.columns)}"
            )
        
        if context_df.empty:
            raise ValueError("context_df no puede estar vac铆o")
        
        if context_df["target"].isnull().any():
            raise ValueError("La columna 'target' contiene valores nulos")
        
        return True