Upload 2 files

app.py

@@ -0,0 +1,515 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import plotly.express as px
+import plotly.graph_objects as go
+from sklearn.ensemble import IsolationForest
+from sklearn.linear_model import LinearRegression
+import random
+import calendar
+
+# Set random seed for reproducibility
+np.random.seed(42)
+
+def generate_device_data(num_days=90, device_type="home"):
+    """Generate synthetic energy consumption data for devices with enhanced patterns"""
+    dates = pd.date_range(end=datetime.now(), periods=num_days*24, freq='h')
+    
+    if device_type == "home":
+        devices = {
+            'HVAC': {'base': 8, 'var': 4, 'peak_hours': [14, 15, 16, 17], 'weekend_factor': 1.2},
+            'Refrigerator': {'base': 2, 'var': 0.5, 'peak_hours': [12, 13, 14], 'weekend_factor': 1.0},
+            'Washing Machine': {'base': 1, 'var': 0.8, 'peak_hours': [10, 19, 20], 'weekend_factor': 1.5},
+            'Lighting': {'base': 1.5, 'var': 0.3, 'peak_hours': [18, 19, 20, 21], 'weekend_factor': 1.1},
+            'Television': {'base': 0.5, 'var': 0.2, 'peak_hours': [20, 21, 22], 'weekend_factor': 1.3}
+        }
+    else:
+        devices = {
+            'HVAC System': {'base': 20, 'var': 8, 'peak_hours': [14, 15, 16, 17], 'weekend_factor': 0.6},
+            'Server Room': {'base': 15, 'var': 3, 'peak_hours': [12, 13, 14], 'weekend_factor': 0.9},
+            'Office Equipment': {'base': 10, 'var': 4, 'peak_hours': [9, 10, 11, 14, 15], 'weekend_factor': 0.4},
+            'Lighting': {'base': 8, 'var': 2, 'peak_hours': [9, 10, 11, 14, 15], 'weekend_factor': 0.5},
+            'Kitchen Appliances': {'base': 5, 'var': 2, 'peak_hours': [12, 13], 'weekend_factor': 0.3}
+        }
+
+    data = []
+    
+    for date in dates:
+        hour = date.hour
+        is_weekend = date.weekday() >= 5
+        
+        for device, params in devices.items():
+            # Add seasonal variation
+            seasonal_factor = 1 + 0.3 * np.sin(2 * np.pi * date.dayofyear / 365)
+            
+            # Add peak hour variation
+            peak_factor = 1.5 if hour in params['peak_hours'] else 1
+            
+            # Add weekend variation
+            weekend_factor = params['weekend_factor'] if is_weekend else 1
+            
+            # Base consumption with random variation
+            consumption = (params['base'] * seasonal_factor * peak_factor * weekend_factor + 
+                         np.random.normal(0, params['var']))
+            
+            # Add some anomalies (3% chance)
+            if np.random.random() < 0.03:
+                consumption *= np.random.choice([1.5, 2.0, 0.5])
+            
+            data.append({
+                'Date': date,
+                'Device': device,
+                'Consumption': max(0, consumption),
+                'Hour': hour,
+                'Weekday': date.strftime('%A'),
+                'Weekend': is_weekend
+            })
+    
+    return pd.DataFrame(data)
+
+def detect_anomalies(df):
+    """Enhanced anomaly detection using Isolation Forest with multiple features"""
+    iso_forest = IsolationForest(contamination=0.03, random_state=42)
+    by_device = df.groupby('Device')
+    
+    anomalies = []
+    for device, group in by_device:
+        # Use multiple features for anomaly detection
+        features = group[['Consumption', 'Hour']].copy()
+        features['Weekend'] = group['Weekend'].astype(int)
+        
+        predictions = iso_forest.fit_predict(features)
+        anomaly_indices = predictions == -1
+        
+        anomaly_data = group[anomaly_indices]
+        
+        for _, row in anomaly_data.iterrows():
+            anomalies.append({
+                'Device': device,
+                'Date': row['Date'],
+                'Consumption': row['Consumption'],
+                'Hour': row['Hour'],
+                'Weekday': row['Weekday']
+            })
+    
+    return pd.DataFrame(anomalies)
+
+def generate_insights(df):
+    """Generate detailed insights from the energy consumption data"""
+    insights = []
+    
+    # Peak usage analysis
+    peak_hours = df.groupby(['Device', 'Hour'])['Consumption'].mean().reset_index()
+    for device in df['Device'].unique():
+        device_peaks = peak_hours[peak_hours['Device'] == device].nlargest(3, 'Consumption')
+        insights.append({
+            'Type': 'Peak Hours',
+            'Device': device,
+            'Description': f"Peak usage hours: {', '.join(map(str, device_peaks['Hour']))}",
+            'Impact': 'High'
+        })
+    
+    # Weekend vs Weekday analysis
+    weekend_comparison = df.groupby(['Device', 'Weekend'])['Consumption'].mean().unstack()
+    for device in weekend_comparison.index:
+        diff_pct = ((weekend_comparison.loc[device, True] - weekend_comparison.loc[device, False]) / 
+                    weekend_comparison.loc[device, False] * 100)
+        insights.append({
+            'Type': 'Weekend Pattern',
+            'Device': device,
+            'Description': f"{'Higher' if diff_pct > 0 else 'Lower'} weekend usage by {abs(diff_pct):.1f}%",
+            'Impact': 'Medium' if abs(diff_pct) < 20 else 'High'
+        })
+    
+    return pd.DataFrame(insights)
+
+def predict_consumption(df, days_ahead=30):
+    """Predict future consumption using linear regression with multiple features"""
+    predictions = []
+    
+    for device in df['Device'].unique():
+        device_data = df[df['Device'] == device].copy()
+        
+        # Create features for prediction
+        device_data['Day_of_Week'] = device_data['Date'].dt.dayofweek
+        device_data['Month'] = device_data['Date'].dt.month
+        device_data['Day_of_Year'] = device_data['Date'].dt.dayofyear
+        
+        X = device_data[['Hour', 'Day_of_Week', 'Month', 'Day_of_Year']]
+        y = device_data['Consumption']
+        
+        model = LinearRegression()
+        model.fit(X, y)
+        
+        # Generate future dates
+        future_dates = pd.date_range(
+            start=df['Date'].max() + timedelta(hours=1),
+            periods=days_ahead*24,
+            freq='h'
+        )
+        
+        future_X = pd.DataFrame({
+            'Hour': future_dates.hour,
+            'Day_of_Week': future_dates.dayofweek,
+            'Month': future_dates.month,
+            'Day_of_Year': future_dates.dayofyear
+        })
+        
+        future_predictions = model.predict(future_X)
+        
+        for date, pred in zip(future_dates, future_predictions):
+            predictions.append({
+                'Date': date,
+                'Device': device,
+                'Predicted_Consumption': max(0, pred)
+            })
+    
+    return pd.DataFrame(predictions)
+
+# Streamlit UI
+st.set_page_config(page_title="SEMS - Smart Energy Management System", layout="wide", initial_sidebar_state="expanded")
+
+# Custom CSS
+st.markdown("""
+    <style>
+    .main {
+        padding: 2rem;
+    }
+    .stMetric {
+        background-color: #f0f2f6;
+        padding: 1rem;
+        border-radius: 0.5rem;
+    }
+    .insight-card {
+        background-color: #ffffff;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin: 0.5rem 0;
+        border: 1px solid #e0e0e0;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+st.title("🏢 SEMS - Smart Energy Management System")
+
+# Sidebar configuration
+st.sidebar.title("Configuration")
+user_type = st.sidebar.radio("Select User Type", ["Home", "Organization"])
+analysis_period = st.sidebar.slider("Analysis Period (Days)", 30, 180, 90)
+
+# Generate data
+data = generate_device_data(num_days=analysis_period, device_type=user_type.lower())
+
+# Main tabs
+tab1, tab2, tab3, tab4 = st.tabs([
+    "📊 Usage Dashboard",
+    "🔍 Detailed Analysis",
+    "⚠️ Peak Usage Detection",
+    "📈 Forecasting"
+])
+
+with tab1:
+    st.header("Energy Usage Dashboard")
+    
+    # Key metrics
+    col1, col2, col3 = st.columns(3)
+    
+    total_consumption = data['Consumption'].sum()
+    avg_daily = data.groupby(data['Date'].dt.date)['Consumption'].sum().mean()
+    peak_hour = data.groupby('Hour')['Consumption'].mean().idxmax()
+    
+    col1.metric("Total Consumption", f"{total_consumption:.1f} kWh")
+    col2.metric("Average Daily Usage", f"{avg_daily:.1f} kWh")
+    col3.metric("Peak Usage Hour", f"{peak_hour}:00")
+    
+    # Daily consumption trend
+    st.subheader("Daily Consumption Trend")
+    daily_consumption = data.groupby(['Date', 'Device'])['Consumption'].sum().reset_index()
+    fig = px.line(daily_consumption, x='Date', y='Consumption', color='Device',
+                  title='Energy Consumption Over Time')
+    fig.update_layout(height=400)
+    st.plotly_chart(fig, use_container_width=True)
+    
+    # Device-wise distribution
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        device_total = data.groupby('Device')['Consumption'].sum().sort_values(ascending=True)
+        fig = px.bar(device_total, orientation='h',
+                    title='Total Consumption by Device')
+        st.plotly_chart(fig, use_container_width=True)
+    
+    with col2:
+        hourly_avg = data.groupby(['Hour', 'Device'])['Consumption'].mean().reset_index()
+        fig = px.line(hourly_avg, x='Hour', y='Consumption', color='Device',
+                     title='Average Hourly Consumption Pattern')
+        st.plotly_chart(fig, use_container_width=True)
+
+with tab2:
+    st.header("Detailed Analysis")
+    
+    # Weekday vs Weekend analysis
+    st.subheader("Weekday vs Weekend Consumption")
+    weekly_pattern = data.groupby(['Weekday', 'Device'])['Consumption'].mean().reset_index()
+    fig = px.bar(weekly_pattern, x='Weekday', y='Consumption', color='Device',
+                 title='Average Consumption by Day of Week')
+    st.plotly_chart(fig, use_container_width=True)
+    
+    # Hourly heatmap
+    st.subheader("Hourly Consumption Heatmap")
+    hourly_data = data.pivot_table(
+        values='Consumption',
+        index='Hour',
+        columns='Weekday',
+        aggfunc='mean'
+    )
+    
+    fig = px.imshow(hourly_data,
+                    labels=dict(x="Day of Week", y="Hour of Day", color="Consumption"),
+                    aspect="auto",
+                    title="Consumption Intensity by Hour and Day")
+    st.plotly_chart(fig, use_container_width=True)
+    
+    # Display insights
+    st.subheader("Key Insights")
+    insights = generate_insights(data)
+    
+    for _, insight in insights.iterrows():
+        with st.expander(f"{insight['Device']} - {insight['Type']} (Impact: {insight['Impact']})"):
+            st.write(insight['Description'])
+
+with tab3:
+    st.header("Peak Usage Detection")
+    
+    # Detect anomalies
+    anomalies = detect_anomalies(data)
+    
+    if not anomalies.empty:
+        st.warning(f"Detected {len(anomalies)} anomalies in energy consumption")
+        
+        # Plot with anomalies
+        fig = go.Figure()
+        
+        for device in data['Device'].unique():
+            device_data = data[data['Device'] == device]
+            device_anomalies = anomalies[anomalies['Device'] == device]
+            
+            fig.add_trace(go.Scatter(
+                x=device_data['Date'],
+                y=device_data['Consumption'],
+                name=f"{device} (normal)",
+                mode='lines'
+            ))
+            
+            if not device_anomalies.empty:
+                fig.add_trace(go.Scatter(
+                    x=device_anomalies['Date'],
+                    y=device_anomalies['Consumption'],
+                    name=f"{device} (anomaly)",
+                    mode='markers',
+                    marker=dict(size=10, symbol='x', color='red')
+                ))
+        
+        fig.update_layout(
+            title='Energy Consumption with Detected Anomalies',
+            height=500
+        )
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Anomaly details in an expandable table
+        st.subheader("Peak Usage Details")
+        for device in anomalies['Device'].unique():
+            device_anomalies = anomalies[anomalies['Device'] == device].copy()
+            device_anomalies['Date'] = device_anomalies['Date'].dt.strftime('%Y-%m-%d %H:%M')
+            
+            with st.expander(f"Anomalies for {device}"):
+                st.dataframe(
+                    device_anomalies[['Date', 'Consumption', 'Hour', 'Weekday']],
+                    use_container_width=True
+                )
+
+with tab4:
+    st.header("Consumption Forecasting")
+    
+    # Generate predictions
+    predictions = predict_consumption(data)
+    
+    # Plot historical data and predictions
+    st.subheader("Consumption Forecast")
+    
+    for device in predictions['Device'].unique():
+        with st.expander(f"Forecast for {device}"):
+            historical = data[data['Device'] == device]
+            device_predictions = predictions[predictions['Device'] == device]
+            
+            fig = go.Figure()
+            
+            # Historical data
+            fig.add_trace(go.Scatter(
+                x=historical['Date'],
+                y=historical['Consumption'],
+                name='Historical',
+                line=dict(color='blue')
+            ))
+            
+            # Predictions
+            fig.add_trace(go.Scatter(
+                x=device_predictions['Date'],
+                y=device_predictions['Predicted_Consumption'],
+                name='Forecast',
+                line=dict(color='red', dash='dash')
+            ))
+            
+            fig.update_layout(
+                title=f'Energy Consumption Forecast - {device}',
+                xaxis_title='Date',
+                yaxis_title='Consumption (kWh)',
+                height=400
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # Summary statistics
+            col1, col2, col3 = st.columns(3)
+            
+            avg_historical = historical['Consumption'].mean()
+            avg_predicted = device_predictions['Predicted_Consumption'].mean()
+            change_pct = (avg_predicted - avg_historical) / avg_historical * 100
+            
+            col1.metric(
+                "Average Historical Usage",
+                f"{avg_historical:.2f} kWh"
+            )
+            col2.metric(
+                "Average Predicted Usage",
+                f"{avg_predicted:.2f} kWh"
+            )
+            col3.metric(
+                "Expected Change",
+                f"{change_pct:+.1f}%",
+                delta_color="inverse"
+            )
+
+    # Additional insights section
+    st.subheader("Energy Saving Opportunities")
+    
+    # Calculate potential savings based on patterns
+    def calculate_savings_opportunities(historical_data, predictions_data):
+        opportunities = []
+        
+        # Check for peak hour reduction potential
+        peak_hours = historical_data.groupby('Hour')['Consumption'].mean()
+        top_peak_hours = peak_hours.nlargest(3)
+        potential_peak_savings = top_peak_hours.sum() * 0.2  # Assume 20% reduction possible
+        
+        opportunities.append({
+            'Type': 'Peak Hour Reduction',
+            'Description': f'Reduce usage during peak hours ({", ".join(map(str, top_peak_hours.index))}:00)',
+            'Potential_Savings': f'{potential_peak_savings:.2f} kWh per day'
+        })
+        
+        # Check for weekend optimization
+        weekend_data = historical_data[historical_data['Weekend']]
+        weekday_data = historical_data[~historical_data['Weekend']]
+        if weekend_data['Consumption'].mean() > weekday_data['Consumption'].mean():
+            weekend_savings = (weekend_data['Consumption'].mean() - weekday_data['Consumption'].mean()) * 2
+            opportunities.append({
+                'Type': 'Weekend Optimization',
+                'Description': 'Optimize weekend consumption patterns',
+                'Potential_Savings': f'{weekend_savings:.2f} kWh per weekend'
+            })
+        
+        # Seasonal optimization
+        seasonal_data = historical_data.copy()
+        seasonal_data['Month'] = seasonal_data['Date'].dt.month
+        monthly_avg = seasonal_data.groupby('Month')['Consumption'].mean()
+        seasonal_variation = monthly_avg.max() - monthly_avg.min()
+        
+        if seasonal_variation > monthly_avg.mean() * 0.3:  # If variation is more than 30%
+            opportunities.append({
+                'Type': 'Seasonal Optimization',
+                'Description': 'Implement seasonal usage strategies',
+                'Potential_Savings': f'{seasonal_variation:.2f} kWh per month'
+            })
+        
+        return pd.DataFrame(opportunities)
+
+    savings_opportunities = calculate_savings_opportunities(data, predictions)
+    
+    for _, opportunity in savings_opportunities.iterrows():
+        with st.expander(f"💡 {opportunity['Type']}"):
+            st.write(f"**Description:** {opportunity['Description']}")
+            st.write(f"**Potential Savings:** {opportunity['Potential_Savings']}")
+            
+            # Add specific recommendations based on opportunity type
+            if opportunity['Type'] == 'Peak Hour Reduction':
+                st.write("""
+                **Recommendations:**
+                - Schedule high-energy activities during off-peak hours
+                - Use automated controls to limit non-essential usage during peak times
+                - Consider energy storage solutions for peak shifting
+                """)
+            elif opportunity['Type'] == 'Weekend Optimization':
+                st.write("""
+                **Recommendations:**
+                - Review weekend device scheduling
+                - Implement automatic shutdown for unused equipment
+                - Optimize temperature settings for unoccupied periods
+                """)
+            elif opportunity['Type'] == 'Seasonal Optimization':
+                st.write("""
+                **Recommendations:**
+                - Adjust HVAC settings seasonally
+                - Implement weather-based control strategies
+                - Schedule maintenance during shoulder seasons
+                """)
+
+# Add export functionality
+if st.sidebar.button("Export Analysis Report"):
+    # Create report dataframe
+    report_data = {
+        'Metric': [
+            'Total Consumption',
+            'Average Daily Usage',
+            'Peak Usage Hour',
+            'Number of Anomalies',
+            'Forecast Trend'
+        ],
+        'Value': [
+            f"{total_consumption:.1f} kWh",
+            f"{avg_daily:.1f} kWh",
+            f"{peak_hour}:00",
+            len(anomalies),
+            f"{change_pct:+.1f}% (30-day forecast)"
+        ]
+    }
+    report_df = pd.DataFrame(report_data)
+    
+    # Convert to CSV
+    csv = report_df.to_csv(index=False)
+    st.sidebar.download_button(
+        label="Download Report",
+        data=csv,
+        file_name="energy_analysis_report.csv",
+        mime="text/csv"
+    )
+
+# Add help section in sidebar
+with st.sidebar.expander("ℹ️ Help"):
+    st.write("""
+    **Using the Dashboard:**
+    1. Select your user type (Home/Organization)
+    2. Adjust the analysis period using the slider
+    3. Navigate through tabs to view different analyses
+    4. Use expanders to see detailed information
+    5. Export your analysis report using the button above
+    
+    For additional support, contact our team at [email protected]
+    """)
+
+# Add system status
+st.sidebar.markdown("---")
+st.sidebar.markdown("### System Status")
+st.sidebar.markdown("✅ All Systems Operational")
+st.sidebar.markdown(f"Last Updated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

requirements.txt

@@ -0,0 +1,58 @@
+altair==5.5.0
+attrs==24.3.0
+blinker==1.9.0
+cachetools==5.5.0
+certifi==2024.12.14
+charset-normalizer==3.4.1
+click==8.1.8
+cmdstanpy==1.2.5
+contourpy==1.3.1
+cycler==0.12.1
+fonttools==4.55.3
+gitdb==4.0.12
+GitPython==3.1.44
+holidays==0.64
+idna==3.10
+importlib_resources==6.5.2
+Jinja2==3.1.5
+joblib==1.4.2
+jsonschema==4.23.0
+jsonschema-specifications==2024.10.1
+kiwisolver==1.4.8
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+matplotlib==3.10.0
+mdurl==0.1.2
+narwhals==1.21.1
+numpy==2.2.1
+packaging==24.2
+pandas==2.2.3
+pillow==11.1.0
+plotly==5.24.1
+prophet==1.1.6
+protobuf==5.29.2
+pyarrow==18.1.0
+pydeck==0.9.1
+Pygments==2.19.1
+pyparsing==3.2.1
+python-dateutil==2.9.0.post0
+pytz==2024.2
+referencing==0.35.1
+requests==2.32.3
+rich==13.9.4
+rpds-py==0.22.3
+scikit-learn==1.6.0
+scipy==1.15.0
+six==1.17.0
+smmap==5.0.2
+stanio==0.5.1
+streamlit==1.41.1
+tenacity==9.0.0
+threadpoolctl==3.5.0
+toml==0.10.2
+tornado==6.4.2
+tqdm==4.67.1
+typing_extensions==4.12.2
+tzdata==2024.2
+urllib3==2.3.0
+watchdog==6.0.0