v3

app.py

@@ -1,88 +1,105 @@
-from __future__ import annotations
-from typing import Any, Callable, Literal
+import xgboost as xgb
+import pandas as pd
 import gradio as gr
-import datetime
+import os
+from datetime import datetime
+from pandas.tseries.holiday import USFederalHolidayCalendar as calendar
 
-class DateTimePicker(gr.components.Component):
-    """
-    A component that allows users to select a date and time.
-    
-    Preprocessing: The date and time passed to the Python function will be a string formatted as YYYY-MM-DD HH:MM:SS or a datetime.datetime object
-    depending on the value of the type parameter.
-
-    Postprocessing: The value returned from the function can be a string or a datetime.datetime object. 
-    
-    Parameters:
-        value: The default date and time value, formatted as YYYY-MM-DD HH:MM:SS. Can be either a string or datetime.datetime object.
-        type: The type of the value to pass to the Python function. Either "string" or "datetime".
-        label: The label for the component.
-        info: Extra text to render below the component.
-        show_label: Whether to show the label for the component.
-        container: Whether to show the component in a container.
-        scale: The relative size of the component compared to other components in the same row.
-        min_width: The minimum width of the component.
-        interactive: Whether to allow the user to interact with the component.
-        visible: Whether to show the component.
-        elem_id: The id of the component. Useful for custom js or css.
-        elem_classes: The classes of the component. Useful for custom js or css.
-        render: Whether to render the component in the parent Blocks scope.
-        load_fn: A function to run when the component is first loaded onto the page to set the initial value.
-        every: Whether load_fn should be run on a fixed time interval.
-    """
-
-    EVENTS = ["change", "input", "submit"]
+# Load your trained XGBoost model from a .bin file
+model = xgb.Booster()
+model.load_model(os.path.join(os.path.dirname(__file__), "xgb_model.bin"))
 
-    def __init__(self, value: str | datetime.datetime = None, *, 
-                 type: Literal["string", "datetime"] = "datetime",
-                 label: str | None = None, info: str | None = None,
-                 show_label: bool | None = None, container: bool = True, scale: int | None = None,
-                 min_width: int | None = None, interactive: bool | None = None, visible: bool = True,
-                 elem_id: str | None = None, elem_classes: list[str] | str | None = None,
-                 render: bool = True,
-                 load_fn: Callable[..., Any] | None = None,
-                 every: float | None = None):
-        self._format_str = "%Y-%m-%d %H:%M:%S"
-        self.type = type
-        super().__init__(value, label=label, info=info, show_label=show_label, container=container, scale=scale, min_width=min_width, interactive=interactive, visible=visible, elem_id=elem_id, elem_classes=elem_classes, render=render, load_fn=load_fn, every=every)
+# Load the unseen data from a CSV file
+df = pd.read_csv(os.path.join(os.path.dirname(__file__), "unseen_data.csv"))
 
+# Define the expected columns for prediction
+expected_columns = ['temperature', 'year', 'month', 'day', 'hr', 'day_of_week', 'is_weekend', 'holiday']
 
-    def preprocess(self, payload: str | None) -> str | datetime.datetime | None:
-        if payload is None:
-            return None
-        if self.type == "string":
-            return payload
-        else:
-            return datetime.datetime.strptime(payload, self._format_str)
+def get_random_data():
+    # Select 5 random rows from the unseen data
+    random_data = df.sample(5).copy()
+    return random_data
 
+def predict_demand(input_df):
+    # Prepare data for prediction
+    prediction_data = input_df[expected_columns]
+    dmatrix = xgb.DMatrix(prediction_data)
+    predictions = model.predict(dmatrix)
+    # Add predictions to the dataframe
+    input_df['predicted_demand'] = predictions.round(0).astype(int)
+    return input_df
 
-    def postprocess(self, value: str | datetime.datetime | None) -> str | None:
-        if not value:
-            return None
-        if isinstance(value, str):
-            return datetime.datetime.strptime(value, self._format_str).strftime(self._format_str)
-        elif isinstance(value, datetime.datetime):
-            return datetime.datetime.strftime(value, self._format_str)
-        else:
-            raise ValueError(f"Unexpected value type {type(value)} for DateTimePicker (value: {value})")
-
-    def example_inputs(self):
-        return "2023-01-01 12:00:00"
+def format_random_output(prediction_df):
+    # Calculate percentage error
+    prediction_df['error_percentage'] = ((prediction_df['predicted_demand'] - prediction_df['demand']) / prediction_df['demand'] * 100).round(2)
+    
+    # Format date and time
+    prediction_df['datetime'] = pd.to_datetime(prediction_df['date'] + ' ' + prediction_df['hr'].astype(str) + ':00:00')
+    
+    # Select and rename columns
+    output_df = prediction_df[['datetime', 'temperature', 'predicted_demand', 'demand', 'error_percentage']]
+    output_df.columns = ['Date and Time', 'Temperature (°C)', 'Predicted Demand (MW)', 'Actual Demand (MW)', 'Error (%)']
+    
+    return output_df
 
-    def api_info(self):
-        return {"type": "string", "description": f"Date and time string formatted as YYYY-MM-DD HH:MM:SS."}
+def gradio_interface():
+    # Get random data and predict
+    random_data = get_random_data()
+    prediction_df = predict_demand(random_data)
+    formatted_output = format_random_output(prediction_df)
+    return formatted_output
 
+def custom_predict(date_time, temperature):
+    # Parse date and time
+    dt = pd.to_datetime(date_time)
+    
+    # Calculate additional parameters
+    is_weekend = dt.dayofweek >= 5
+    holidays = calendar().holidays(start=dt.floor('D'), end=dt.ceil('D'))
+    is_holiday = dt.floor('D') in holidays
 
-def display_datetime(selected_datetime: datetime.datetime):
-    # Return a formatted string showing the selected date and time
-    return f"You selected: {selected_datetime}"
+    # Create custom data
+    custom_data = pd.DataFrame([[
+        temperature,
+        dt.year,
+        dt.month,
+        dt.day,
+        dt.hour,
+        dt.dayofweek,
+        int(is_weekend),
+        int(is_holiday)
+    ]], columns=expected_columns)
+    
+    # Predict
+    prediction_df = predict_demand(custom_data)
+    
+    # Format output
+    output_df = pd.DataFrame({
+        'Date and Time': [dt],
+        'Temperature (°C)': [temperature],
+        'Predicted Demand (MW)': prediction_df['predicted_demand']
+    })
+    
+    return output_df
 
-demo = gr.Interface(
-    fn=display_datetime,
-    inputs=DateTimePicker(label="Select a date and time", type="datetime"),
-    outputs=gr.Textbox(label="Selected Date and Time"),
-    examples=["2023-01-01 12:00:00", "2023-12-31 18:30:00"],
-    title="Date and Time Picker"
-)
+# Create the Gradio app
+with gr.Blocks(title="Electricity Demand Prediction") as demo:
+    gr.Markdown("# Electricity Demand Prediction")
+    gr.Markdown("Predict electricity demand based on various factors.")
+    
+    with gr.Tab("Random Predictions"):
+        random_output = gr.DataFrame(label="Random Predictions")
+        random_button = gr.Button("Predict for 5 Random Data Points")
+        random_button.click(fn=gradio_interface, outputs=random_output)
+    
+    with gr.Tab("Custom Prediction"):
+        with gr.Row():
+            date_time = gr.DateTime(label="Date and Time")
+            temperature = gr.Slider(0, 40, label="Temperature (°C)")
+        custom_output = gr.DataFrame(label="Custom Prediction")
+        custom_button = gr.Button("Predict for Custom Input")
+        custom_button.click(fn=custom_predict, 
+                            inputs=[date_time, temperature],
+                            outputs=custom_output)
 
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()