Upload 4 files

app.py

@@ -0,0 +1,112 @@
+import re
+import pandas as pd
+import pickle
+import numpy as np
+from sklearn.preprocessing import MinMaxScaler
+import joblib
+from io import StringIO
+import gradio as gr
+import os
+import sys
+from json import load
+from skforecast.utils import load_forecaster
+from skforecast.preprocessing import RollingFeatures
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.preprocessing import FunctionTransformer
+from sklearn.pipeline import Pipeline
+from exog_creation import create_exog
+import contextlib
+import warnings
+# Función para cargar el archivo CSV y mostrar las primeras 5 filas
+def load_csv(input_file):
+    try:
+        # Leer el archivo CSV
+        df = pd.read_csv(input_file)
+        
+        # Verificar si el DataFrame está vacío
+        if df.empty:
+            return "El archivo subido está vacío o no tiene datos válidos."
+        
+        # Retornar las primeras 5 filas como tabla HTML
+        # return df.head().to_html()
+        return df
+    except Exception as e:
+        return f"Error al procesar el archivo: {e}"
+
+def set_datetime_index(df):
+    df['datetime'] = pd.to_datetime(df['datetime'])
+    df = df.set_index('datetime')
+    df = df.asfreq('h')
+    return df
+
+def load_model(name):
+    current_dir = os.getcwd()
+    ROOT_PATH = os.path.dirname(current_dir)
+    sys.path.insert(1, ROOT_PATH)
+    import root
+    model = load_forecaster(root.DIR_DATA_ANALYTICS + name,
+                    verbose=True)
+    return model
+
+def load_pipeline(name):
+    with open('pipeline.pkl', 'rb') as file:
+        pipeline = pickle.load(file)
+    return pipeline
+
+
+def flujo(input_file):
+    
+    warnings.filterwarnings("ignore")
+    
+    datos = load_csv("archivo.csv")
+
+    datos = set_datetime_index(datos)
+
+    datos_exog = create_exog(datos)
+
+    # Redirigir stdout a os.devnull para suprimir cualquier impresión
+    sys.stdout = open(os.devnull, 'w')
+
+    # Cargar el modelo
+    forecaster = load_model('tree_model.joblib')
+
+    # Restaurar stdout a la consola
+    sys.stdout = sys.__stdout__
+    
+    exog_selectec = ['temperature', 'rain', 'surface_pressure', 'cloudcover_total', 'windspeed_10m', 'winddirection_10m', 'shortwave_radiation', 'euros_per_mwh', 'installed_capacity', 'hour_sin', 'poly_month_sin__week_sin', 'poly_month_sin__week_cos', 'poly_month_sin__day_of_week_sin', 'poly_month_sin__day_of_week_cos', 'poly_month_sin__hour_sin', 'poly_month_sin__hour_cos', 'poly_month_sin__sunrise_hour_cos', 'poly_month_cos__week_sin', 'poly_month_cos__day_of_week_sin', 'poly_month_cos__day_of_week_cos', 'poly_month_cos__hour_sin', 'poly_month_cos__hour_cos', 'poly_month_cos__sunset_hour_sin', 'poly_week_sin__week_cos', 'poly_week_sin__day_of_week_sin', 'poly_week_sin__day_of_week_cos', 'poly_week_sin__hour_sin', 'poly_week_sin__hour_cos', 'poly_week_sin__sunrise_hour_cos', 'poly_week_sin__sunset_hour_cos', 'poly_week_cos__day_of_week_sin', 'poly_week_cos__day_of_week_cos', 'poly_week_cos__hour_sin', 'poly_week_cos__hour_cos', 'poly_week_cos__sunrise_hour_sin', 'poly_week_cos__sunrise_hour_cos', 'poly_week_cos__sunset_hour_sin', 'poly_day_of_week_sin__day_of_week_cos', 'poly_day_of_week_sin__hour_sin', 'poly_day_of_week_sin__hour_cos', 'poly_day_of_week_sin__sunrise_hour_sin', 'poly_day_of_week_sin__sunrise_hour_cos', 'poly_day_of_week_sin__sunset_hour_sin', 'poly_day_of_week_sin__sunset_hour_cos', 'poly_day_of_week_cos__hour_sin', 'poly_day_of_week_cos__hour_cos', 'poly_day_of_week_cos__sunrise_hour_sin', 'poly_day_of_week_cos__sunrise_hour_cos', 'poly_day_of_week_cos__sunset_hour_sin', 'poly_day_of_week_cos__sunset_hour_cos', 'poly_hour_sin__hour_cos', 'poly_hour_sin__sunrise_hour_sin', 'poly_hour_sin__sunrise_hour_cos', 'poly_hour_sin__sunset_hour_sin', 'poly_hour_sin__sunset_hour_cos', 'poly_hour_cos__sunrise_hour_sin', 'poly_hour_cos__sunrise_hour_cos', 'poly_hour_cos__sunset_hour_sin', 'poly_hour_cos__sunset_hour_cos']
+
+    predictions = forecaster.predict(steps=24, exog  = datos_exog[exog_selectec])
+
+    datos['target'] = predictions
+
+    target_column = 'target'
+
+    columns_order = [target_column] + [col for col in datos.columns if col != target_column]
+
+    datos = datos[columns_order]
+
+    pipeline = load_pipeline('pipeline.pkl')
+
+    pred_scaled = pipeline.inverse_transform(datos)
+
+    pred_scaled_df = pd.DataFrame(pred_scaled, columns=datos.columns, index=datos.index)
+    
+    df_reset = pred_scaled_df.reset_index()
+    
+    df_target = df_reset[['datetime', 'target']]
+    
+
+    return df_target.to_html()
+
+# Crear la interfaz con Gradio
+interface = gr.Interface(
+    fn=flujo,  # Función principal
+    inputs=gr.File(label="Sube tu archivo CSV"),  # Entrada de archivo
+    outputs="html",  # Salida como tabla HTML
+    title="Prediccion geenracion de energia",
+    description="Sube un archivo CSV y perdice la geenracion de energia."
+)
+
+interface.launch(share = True)
+
+

exog_creation.py

@@ -0,0 +1,192 @@
+# Tratamiento de datos
+# ==============================================================================
+import re
+import numpy as np
+import pandas as pd
+from astral.sun import sun
+from astral import LocationInfo
+from skforecast.datasets import fetch_dataset
+from feature_engine.datetime import DatetimeFeatures
+from feature_engine.creation import CyclicalFeatures
+from feature_engine.timeseries.forecasting import WindowFeatures
+from sklearn.preprocessing import PolynomialFeatures
+import sys
+import os
+##########################################################################################
+
+
+# current_dir = os.getcwd()
+# ROOT_PATH = os.path.dirname(current_dir)
+# sys.path.insert(1, ROOT_PATH)
+# import root
+# datos = pd.read_pickle(root.DIR_DATA_STAGE + 'train.pkl')
+
+# Variables basadas en el calendario
+def calendar_features(datos):
+    features_to_extract = [
+    'month',
+    'week',
+    'day_of_week',
+    'hour'
+    ]   
+    calendar_transformer = DatetimeFeatures(
+        variables='index',
+        features_to_extract=features_to_extract,
+        drop_original=True,
+    )
+    variables_calendario = calendar_transformer.fit_transform(datos)[features_to_extract]
+    
+    return variables_calendario
+
+# Variables basadas en la luz solar
+def solar_features(datos):
+    location = LocationInfo(
+        name      = 'Taillin',
+        region    = 'Estonia',
+        timezone  = 'Europe/Riga',
+        latitude  = 56.946285,
+        longitude = 24.105078
+    )
+    sunrise_hour = [
+        sun(location.observer, date=date, tzinfo=location.timezone)['sunrise']
+        for date in datos.index
+    ]
+    sunset_hour = [
+        sun(location.observer, date=date, tzinfo=location.timezone)['sunset']
+        for date in datos.index
+    ]
+    sunrise_hour = pd.Series(sunrise_hour, index=datos.index).dt.round("h").dt.hour
+    sunset_hour = pd.Series(sunset_hour, index=datos.index).dt.round("h").dt.hour
+    variables_solares = pd.DataFrame({
+                            'sunrise_hour': sunrise_hour,
+                            'sunset_hour': sunset_hour
+                        })
+    variables_solares['daylight_hours'] = (
+        variables_solares['sunset_hour'] - variables_solares['sunrise_hour']
+    )
+    variables_solares["is_daylight"] = np.where(
+        (datos.index.hour >= variables_solares["sunrise_hour"])
+        & (datos.index.hour < variables_solares["sunset_hour"]),
+        1,
+        0,
+    )
+    
+    return variables_solares
+
+# Unión de variables exógenas
+
+def union_exog_features(variables_calendario, variables_solares):
+    assert all(variables_calendario.index == variables_solares.index)
+    variables_exogenas = pd.concat([
+                            variables_calendario,
+                            variables_solares
+                        ], axis=1)
+    
+    return variables_exogenas
+
+def ciclic_features(variables_exogenas):
+    features_to_encode = [
+        "month",
+        "week",
+        "day_of_week",
+        "hour",
+        "sunrise_hour",
+        "sunset_hour",
+    ]
+    max_values = {
+        "month": 12,
+        "week": 52,
+        "day_of_week": 6,
+        "hour": 23,
+        "sunrise_hour": 23,
+        "sunset_hour": 23,
+    }
+    cyclical_encoder = CyclicalFeatures(
+        variables     = features_to_encode,
+        max_values    = max_values,
+        drop_original = False
+    )
+
+    variables_exogenas = cyclical_encoder.fit_transform(variables_exogenas)   
+
+    return variables_exogenas
+
+def pol_features(variables_exogenas):
+# Interacción entre variables exógenas
+    transformer_poly = PolynomialFeatures(
+                            degree           = 2,
+                            interaction_only = True,
+                            include_bias     = False
+                        ).set_output(transform="pandas")
+    poly_cols = [
+        'month_sin', 
+        'month_cos',
+        'week_sin',
+        'week_cos',
+        'day_of_week_sin',
+        'day_of_week_cos',
+        'hour_sin',
+        'hour_cos',
+        'sunrise_hour_sin',
+        'sunrise_hour_cos',
+        'sunset_hour_sin',
+        'sunset_hour_cos',
+        'daylight_hours',
+        'is_daylight',
+    ]
+    variables_poly = transformer_poly.fit_transform(variables_exogenas[poly_cols])
+    variables_poly = variables_poly.drop(columns=poly_cols)
+    variables_poly.columns = [f"poly_{col}" for col in variables_poly.columns]
+    variables_poly.columns = variables_poly.columns.str.replace(" ", "__")
+    assert all(variables_exogenas.index == variables_poly.index)
+    variables_exogenas = pd.concat([variables_exogenas, variables_poly], axis=1)   
+ 
+    return variables_exogenas  
+
+
+def select_exog_features(variables_exogenas):
+    # Selección de variables exógenas incluidas en el modelo
+    exog_features = []
+    # Columnas que terminan con _seno o _coseno son seleccionadas
+    exog_features.extend(variables_exogenas.filter(regex='_sin$|_cos$').columns.tolist())
+    
+    return exog_features
+     
+def merge_df(datos,variables_exogenas, exog_features):
+    datos = datos.merge(variables_exogenas[exog_features],
+           left_index=True,
+           right_index=True,
+           how='left'  # Usar solo las filas que coinciden en ambos DataFrames
+       )
+    
+    return datos
+    
+
+def create_exog(datos):
+    # Read datasets
+    
+    ################### Train ######################
+    # Prepare date columns
+    variables_calendario = calendar_features(datos)
+    
+    #solar features
+    variables_solares = solar_features(datos)
+    
+    # mergin variables
+    variables_exogenas = union_exog_features(variables_calendario, variables_solares)
+    
+    # cyclical features
+    variables_exogenas = ciclic_features(variables_exogenas)
+    
+    # polynomial features
+    variables_exogenas = pol_features(variables_exogenas)
+    
+    # Select exog features
+    exog_features = select_exog_features(variables_exogenas)
+    
+    # Merge datasets
+    datos = merge_df(datos,variables_exogenas, exog_features)
+    
+    return datos
+    
+    

pipeline.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6fa69d47a46f823b38783c73e2d36215e1884b6b30742c45c9912ed1542a4be
+size 2283

requirements.txt

@@ -0,0 +1,9 @@
+astral==3.2
+feature_engine==1.8.2
+gradio==5.6.0
+joblib==1.4.2
+numpy==2.1.3
+pandas==2.2.3
+scikit_learn==1.5.2
+seaborn==0.13.2
+skforecast==0.14.0