Code Editor for app.py

import streamlit as st
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
import plotly.express as px
import plotly.graph_objects as go

# Set page config
st.set_page_config(page_title="Household Electricity Prediction", layout="wide")

# Title and description
st.title("Household Electricity Consumption Prediction")
st.write("""
This app predicts household electricity consumption based on various factors.
Enter the required information below to get a prediction.
""")

# Generate sample data
@st.cache_data
def generate_sample_data():
    np.random.seed(42)
    n_samples = 1000
    
    # Generate features
    temperature = np.random.uniform(10, 35, n_samples)
    humidity = np.random.uniform(30, 90, n_samples)
    hour_of_day = np.random.randint(0, 24, n_samples)
    day_of_week = np.random.randint(0, 7, n_samples)
    appliances_running = np.random.randint(1, 8, n_samples)
    
    # Generate target with some noise
    consumption = (
        0.5 * temperature +
        0.3 * humidity +
        0.8 * appliances_running +
        np.sin(hour_of_day * np.pi / 12) * 5 +
        np.random.normal(0, 1, n_samples)
    )
    
    # Create DataFrame
    df = pd.DataFrame({
        'Temperature': temperature,
        'Humidity': humidity,
        'Hour_of_Day': hour_of_day,
        'Day_of_Week': day_of_week,
        'Appliances_Running': appliances_running,
        'Consumption_kWh': consumption
    })
    
    return df

# Load data and train model
@st.cache_data
def train_model(df):
    X = df[['Temperature', 'Humidity', 'Hour_of_Day', 'Day_of_Week', 'Appliances_Running']]
    y = df['Consumption_kWh']
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    
    model = LinearRegression()
    model.fit(X_train, y_train)
    
    return model, X_train, X_test, y_train, y_test

# Load data and train model
df = generate_sample_data()
model, X_train, X_test, y_train, y_test = train_model(df)

# Sidebar inputs
st.sidebar.header("Input Parameters")

temperature = st.sidebar.slider("Temperature (°C)", 10.0, 35.0, 25.0)
humidity = st.sidebar.slider("Humidity (%)", 30.0, 90.0, 60.0)
hour = st.sidebar.slider("Hour of Day", 0, 23, 12)
day = st.sidebar.selectbox("Day of Week", 
                          ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"])
appliances = st.sidebar.slider("Number of Appliances Running", 1, 7, 3)

# Convert day to number
day_map = {"Monday": 0, "Tuesday": 1, "Wednesday": 2, "Thursday": 3, "Friday": 4, "Saturday": 5, "Sunday": 6}
day_num = day_map[day]

# Make prediction
input_data = np.array([[temperature, humidity, hour, day_num, appliances]])
prediction = model.predict(input_data)[0]

# Display prediction
col1, col2 = st.columns(2)

with col1:
    st.subheader("Predicted Consumption")
    st.metric("Predicted Electricity Consumption", f"{prediction:.2f} kWh")

    # Model performance metrics
    y_pred_test = model.predict(X_test)
    r2 = r2_score(y_test, y_pred_test)
    rmse = np.sqrt(mean_squared_error(y_test, y_pred_test))
    
    st.subheader("Model Performance")
    st.write(f"R² Score: {r2:.3f}")
    st.write(f"RMSE: {rmse:.3f} kWh")

with col2:
    # Scatter plot of actual vs predicted values
    fig = px.scatter(
        x=y_test,
        y=y_pred_test,
        labels={'x': 'Actual Consumption (kWh)', 'y': 'Predicted Consumption (kWh)'},
        title='Actual vs Predicted Consumption'
    )
    
    # Add perfect prediction line
    min_val = min(min(y_test), min(y_pred_test))
    max_val = max(max(y_test), max(y_pred_test))
    fig.add_trace(
        go.Scatter(x=[min_val, max_val], y=[min_val, max_val],
                  mode='lines', name='Perfect Prediction',
                  line=dict(color='red', dash='dash'))
    )
    
    st.plotly_chart(fig)

# Feature importance
st.subheader("Feature Importance")
feature_importance = pd.DataFrame({
    'Feature': ['Temperature', 'Humidity', 'Hour of Day', 'Day of Week', 'Appliances Running'],
    'Importance': abs(model.coef_)
})
feature_importance = feature_importance.sort_values('Importance', ascending=True)

fig_importance = px.bar(
    feature_importance,
    x='Importance',
    y='Feature',
    orientation='h',
    title='Feature Importance in Prediction'
)
st.plotly_chart(fig_importance)

# Historical data visualization
st.subheader("Historical Data Visualization")
chart_type = st.selectbox("Select Chart Type", 
                         ["Consumption vs Temperature", 
                          "Consumption vs Hour of Day",
                          "Average Consumption by Day of Week"])

if chart_type == "Consumption vs Temperature":
    fig = px.scatter(df, x='Temperature', y='Consumption_kWh',
                    title='Consumption vs Temperature',
                    trendline="ols")
    st.plotly_chart(fig)
    
elif chart_type == "Consumption vs Hour of Day":
    hourly_avg = df.groupby('Hour_of_Day')['Consumption_kWh'].mean().reset_index()
    fig = px.line(hourly_avg, x='Hour_of_Day', y='Consumption_kWh',
                  title='Average Consumption by Hour of Day')
    st.plotly_chart(fig)
    
else:
    daily_avg = df.groupby('Day_of_Week')['Consumption_kWh'].mean().reset_index()
    daily_avg['Day'] = daily_avg['Day_of_Week'].map(
        {v: k for k, v in day_map.items()}
    )
    fig = px.bar(daily_avg, x='Day', y='Consumption_kWh',
                 title='Average Consumption by Day of Week')
    st.plotly_chart(fig)

# Tips for reducing consumption
st.subheader("Tips for Reducing Electricity Consumption")
tips = """
1. 🌡️ Maintain optimal temperature settings (20-22°C in winter, 24-26°C in summer)
2. 📱 Unplug devices when not in use to avoid standby power consumption
3. 💡 Switch to LED lighting
4. 🌞 Use natural light when possible
5. 🧺 Run full loads in washing machines and dishwashers
6. 🔍 Regular maintenance of appliances
7. ⏰ Use appliances during off-peak hours
"""
st.markdown(tips)