Update app.py

app.py

@@ -1,112 +1,98 @@
-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)
-
-
+import pandas as pd
+import seaborn as sns
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.compose import ColumnTransformer
+from sklearn.pipeline import Pipeline
+from sklearn.ensemble import RandomForestRegressor
+import gradio as gr
+
+# Load the diamonds dataset
+diamonds = sns.load_dataset("diamonds")
+
+# Prepare the features and target
+X = diamonds.drop("price", axis=1)
+y = diamonds["price"]
+
+# Split the data
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+# Define the preprocessing steps
+numeric_features = ["carat", "depth", "table", "x", "y", "z"]
+categorical_features = ["cut", "color", "clarity"]
+
+preprocessor = ColumnTransformer(
+    transformers=[
+        ("num", StandardScaler(), numeric_features),
+        ("cat", OneHotEncoder(drop="first"), categorical_features),
+    ]
+)
+
+
+# Create a pipeline with preprocessing and model
+model = Pipeline(
+    [
+        ("preprocessor", preprocessor),
+        ("regressor", RandomForestRegressor(n_estimators=100, random_state=42)),
+    ]
+)
+
+# Fit the model
+model.fit(X_train, y_train)
+
+# Create the Gradio interface
+def predict_price(carat, cut, color, clarity, depth, table, x, y, z):
+  
+   input_data = pd.DataFrame(
+       {
+           "carat": [carat],
+           "cut": [cut],
+           "color": [color],
+           "clarity": [clarity],
+           "depth": [depth],
+           "table": [table],
+           "x": [x],
+           "y": [y],
+           "z": [z],
+       }
+   )
+  
+   prediction = model.predict(input_data)[0]
+   return f"Predicted Price: ${prediction:.2f}"
+
+iface = gr.Interface(
+   fn=predict_price,
+   inputs=[
+       gr.Slider(
+           minimum=diamonds["carat"].min(),
+           maximum=diamonds["carat"].max(),
+           label="Carat",
+       ),
+       gr.Dropdown(["Fair", "Good", "Very Good", "Premium", "Ideal"], label="Cut"),
+       gr.Dropdown(["D", "E", "F", "G", "H", "I", "J"], label="Color"),
+       gr.Dropdown(
+           ["I1", "SI2", "SI1", "VS2", "VS1", "VVS2", "VVS1", "IF"], label="Clarity"
+       ),
+       gr.Slider(
+           minimum=diamonds["depth"].min(),
+           maximum=diamonds["depth"].max(),
+           label="Depth",
+       ),
+       gr.Slider(
+           minimum=diamonds["table"].min(),
+           maximum=diamonds["table"].max(),
+           label="Table",
+       ),
+       gr.Slider(minimum=diamonds["x"].min(), maximum=diamonds["x"].max(), label="X"),
+       gr.Slider(minimum=diamonds["y"].min(), maximum=diamonds["y"].max(), label="Y"),
+       gr.Slider(minimum=diamonds["z"].min(), maximum=diamonds["z"].max(), label="Z"),
+   ],
+   outputs="text",
+   title="Diamond Price Predictor",
+   description="Enter the characteristics of a diamond to predict its price.",
+)
+iface.launch(share=True)
+
+