Upload 6 files

README-HF.md

@@ -0,0 +1,22 @@
+---
+title: Energy Consumption Estimator
+emoji: ⚡
+colorFrom: green
+colorTo: blue
+sdk: streamlit
+sdk_version: 1.30.0
+app_file: main.py
+pinned: false
+---
+
+# Energy Consumption Estimator
+
+This Streamlit app estimates energy consumption based on client attributes using a machine learning model.
+
+## Important Note
+
+For the app to function properly, you need to upload the following files to this Space:
+- `model.pickle` (your trained model)
+- `encoder.pickle` (your encoder)
+
+These files should be placed in the same directory as `main.py`.

README.md

@@ -1,13 +1,61 @@
----
-title: Energy Forecast
-emoji: 🏆
-colorFrom: green
-colorTo: indigo
-sdk: streamlit
-sdk_version: 1.43.1
-app_file: app.py
-pinned: false
-short_description: 'ISA 414: Deployment example'
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Energy Consumption Estimator
+
+A Streamlit web application for estimating energy consumption based on various client attributes. This is a web-based version of the original PyQt5 desktop application.
+
+## Features
+
+- User-friendly web interface
+- Form-based input for client information
+- Instant energy consumption estimation
+- Responsive design that works on desktop and mobile
+
+## Requirements
+
+- Python 3.7+
+- Streamlit
+- Pandas
+- Scikit-learn (for the model)
+
+## Setup and Running Locally
+
+1. Clone this repository
+2. Install the required packages:
+   ```
+   pip install -r requirements.txt
+   ```
+3. Place your `model.pickle` and `encoder.pickle` files in the same directory as `main.py`
+4. Run the Streamlit app:
+   ```
+   streamlit run main.py
+   ```
+
+## Deploying to Hugging Face Spaces
+
+1. Create a new Space on [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Choose Streamlit as the SDK
+3. Upload the following files to your Space:
+   - `main.py`
+   - `requirements.txt`
+   - `model.pickle` (your trained model)
+   - `encoder.pickle` (your encoder)
+4. The app will automatically deploy and be available at your Space's URL
+
+## Input Parameters
+
+- **Age**: Client's age
+- **Marital Status**: Single, Married, Separated, Divorced, Widowed, or Other
+- **Day/Night Consumption**: Current consumption value
+- **Income Level**: Income bracket
+- **Dwelling Area**: Type of area where the client lives
+- **Children**: Whether the client has children
+- **Solar Panel**: Whether the client has solar panels
+- **Attitude Towards Sustainability**: Client's attitude towards sustainability
+- **Tariff**: Type of tariff plan
+
+## How It Works
+
+The application takes the input parameters, processes them using the same encoding and transformation logic as the original application, and then uses a machine learning model to predict the estimated annual energy consumption in kWh.
+
+## Note
+
+This application requires the same model and encoder files as the original PyQt5 application. Make sure to include these files when deploying.

encoder.pickle

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

main.py

@@ -0,0 +1,145 @@
+import streamlit as st
+import pandas as pd
+import pickle
+import os
+from pathlib import Path
+
+# Set page title and configuration
+st.set_page_config(page_title="ISA414: Energy Consumption Estimator", layout="wide")
+st.title("ISA 414: Energy Consumption Estimator")
+
+# Create a function to load models
+@st.cache_resource
+def load_models():
+    # Check if model files exist in the current directory
+    model_path = Path("model.pickle")
+    encoder_path = Path("encoder.pickle")
+    
+    if not model_path.exists() or not encoder_path.exists():
+        st.error("Model files not found. Please make sure 'model.pickle' and 'encoder.pickle' are in the same directory as this script.")
+        st.stop()
+    
+    # Load model and encoding from files
+    model = pickle.load(open("model.pickle", 'rb'))
+    enc = pickle.load(open("encoder.pickle", 'rb'))
+    return model, enc
+
+# Try to load models
+try:
+    model, enc = load_models()
+except Exception as e:
+    st.error(f"Error loading models: {str(e)}")
+    st.info("For demonstration purposes, you can continue using the app without the models.")
+    model, enc = None, None
+
+# Create sidebar with form inputs
+with st.form("consumption_form"):
+    st.subheader("Enter Client Information")
+    
+    # Create two columns for form layout
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        age = st.number_input("Age", min_value=0, max_value=120, value=30)
+        
+        marital_status_options = ["Single", "Married", "Separated", "Divorced", "Widowed", "Other"]
+        marital_status = st.selectbox("Marital Status", options=marital_status_options, index=0)
+        marital_status_value = str(marital_status_options.index(marital_status) + 1)
+        
+        consumption = st.number_input("Day/Night Consumption", min_value=0.0, value=100.0, format="%.2f")
+        
+        income_options = ["Less than 10,000", "Between 10,000 and 30,000", 
+                          "Between 40,000 and 60,000", "Between 60,000 and 100,000", "More than 100,000"]
+        income = st.selectbox("Income Level", options=income_options, index=0)
+        income_value = str(income_options.index(income) + 1)
+        
+        area_options = ["City centre", "City outskirts", "Rural", "Remote"]
+        area = st.selectbox("Dwelling Area", options=area_options, index=0)
+        area_value = str(area_options.index(area) + 1)
+    
+    with col2:
+        children_options = ["No", "Yes"]
+        children = st.selectbox("Children", options=children_options, index=0)
+        children_value = False if children_options.index(children) == 0 else True
+        
+        solar_options = ["No", "Yes"]
+        solar = st.selectbox("Solar Panel", options=solar_options, index=0)
+        solar_value = False if solar_options.index(solar) == 0 else True
+        
+        sustainability_options = ["Favorable", "Undecided", "Unfavorable"]
+        sustainability = st.selectbox("Attitude Towards Sustainability", options=sustainability_options, index=0)
+        sustainability_value = str(sustainability_options.index(sustainability) + 1)
+        
+        tariff_options = ["Flat", "Time-of-Use", "Dynamic"]
+        tariff = st.selectbox("Tariff", options=tariff_options, index=0)
+        tariff_value = "Tariff " + str(tariff_options.index(tariff) + 1)
+    
+    # Submit button
+    submitted = st.form_submit_button("Estimate Consumption")
+
+# Function to make prediction
+def forecast(age, marital_status, consumption, income, area, children, solar, sustainability, tariff):
+    # Creating a DataFrame having a new client
+    new_client = [age, marital_status, consumption, income, area, children, solar, sustainability, tariff]
+    
+    new_client = pd.DataFrame([new_client], 
+                    columns=("Age", "MaritalStatus", "DayNightConsumption", "IncomeLevel", 
+                             "DwellingArea", "HasChildren", "SolarRoof", "AttitudeSustainability", "Tariff"))
+    
+    # Categorical columns
+    cat_columns = ["MaritalStatus", "IncomeLevel", "DwellingArea", "AttitudeSustainability", "Tariff"]
+    
+    # Using the previously created encoding and list of categorical variables to generate dummies
+    dummies = enc.transform(new_client[cat_columns])
+    
+    # Creating a DataFrame of the dummies
+    dummies_df = pd.DataFrame(dummies, columns=enc.get_feature_names_out(input_features=cat_columns))
+    
+    # Concatenating with the original data
+    new_client = pd.concat([new_client, dummies_df], axis=1)
+    
+    # Dropping old columns
+    new_client = new_client.drop(columns=cat_columns, axis=1)
+    
+    # Making prediction
+    prediction = model.predict(new_client)[0]
+    
+    return prediction
+
+# Display results if form is submitted
+if submitted:
+    try:
+        if model is not None and enc is not None:
+            # Make prediction
+            prediction = forecast(
+                age, 
+                marital_status_value, 
+                consumption, 
+                income_value, 
+                area_value, 
+                children_value, 
+                solar_value, 
+                sustainability_value, 
+                tariff_value
+            )
+            
+            # Display result
+            st.success(f"Estimated annual consumption: {prediction:.2f} kWh")
+        else:
+            st.warning("This is a demo mode. Models are not loaded.")
+            st.info("In a real deployment, the prediction would be calculated here.")
+    except Exception as e:
+        st.error(f"Error making prediction: {str(e)}")
+
+# Add information about the app
+with st.expander("About this app"):
+    st.write("""
+    This app estimates energy consumption based on various client attributes.
+    It uses a machine learning model to make predictions.
+    
+    To use the app:
+    1. Enter the client information in the form
+    2. Click 'Estimate Consumption' to see the prediction
+    
+    Note: This app requires 'model.pickle' and 'encoder.pickle' files to make actual predictions.
+    """)

model.pickle

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

requirements.txt

@@ -0,0 +1,3 @@
+streamlit==1.30.0
+pandas==2.1.3
+scikit-learn==1.3.2