Update app.py

app.py

@@ -1,79 +1,105 @@
 import gradio as gr
 import pandas as pd
 import numpy as np
-from sklearn.linear_model import LogisticRegression
-from sklearn.model_selection import train_test_split
-from statsmodels.tsa.arima.model import ARIMA
 import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.linear_model import LogisticRegression
+from sklearn.preprocessing import StandardScaler
+import io
+import base64
 
-# Sample data (this would be replaced with real equipment usage/maintenance data)
-data = {
-    'equipment_id': ['Excavator', 'Crane', 'Tractor'],
-    'usage_hours': [120, 140, 100],
-    'idle_hours': [30, 20, 50],
-    'movement_frequency': [5, 7, 3],
-    'cost_per_hour': [10, 15, 12],
-}
-
-# Convert data to DataFrame
-df = pd.DataFrame(data)
+# Load equipment data
+def load_data():
+    df = pd.read_csv("equipment_data.csv")
+    return df
 
-# Function to perform Time Series Analysis (using ARIMA)
-def time_series_analysis(equipment_id, usage_hours):
-    # Simulate time series data (here using random data for demonstration)
-    dates = pd.date_range('2025-01-01', periods=10, freq='D')
-    usage_data = np.random.randint(100, 200, size=10)  # Dummy usage data
+# Mock AI model for suggestions
+def predict_suggestions(df):
+    X = df[["Usage_Hours__c", "Idle_Hours__c", "Utilization_Score__c"]].fillna(0)
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X)
+    
+    suggestions = ["Move", "Pause Rent", "Repair", "Replace"]
+    y = np.random.choice(suggestions, size=len(df))  # Mock model
+    
+    model = LogisticRegression()
+    model.fit(X_scaled, y)
     
-    # Create a DataFrame for time series data
-    ts_df = pd.DataFrame({'ds': dates, 'usage': usage_data})
+    probs = model.predict_proba(X_scaled)
+    df["AI_Suggestion__c"] = model.predict(X_scaled)
+    df["Suggestion_Confidence__c"] = probs.max(axis=1) * 100
+    return df
+
+# Generate equipment cards
+def generate_cards(df, project_filter, suggestion_filter):
+    filtered_df = df
+    if project_filter and project_filter != "All":
+        filtered_df = filtered_df[filtered_df["Project_ID__c"] == project_filter]
+    if suggestion_filter and suggestion_filter != "All":
+        filtered_df = filtered_df[filtered_df["AI_Suggestion__c"] == suggestion_filter]
     
-    # Fit ARIMA model (for simplicity, we use ARIMA(1,1,1) here)
-    model = ARIMA(ts_df['usage'], order=(1, 1, 1))
-    model_fit = model.fit()
+    cards = ""
+    for _, row in filtered_df.iterrows():
+        card = f"""
+        **Equipment ID**: {row['Equipment_ID__c']}  
+        **Project**: {row['Project_ID__c']}  
+        **Usage Hours**: {row['Usage_Hours__c']}  
+        **Idle Hours**: {row['Idle_Hours__c']}  
+        **Utilization Score**: {row['Utilization_Score__c']}%  
+        **AI Suggestion**: {row['AI_Suggestion__c']} (Confidence: {row['Suggestion_Confidence__c']:.2f}%)  
+        **Last Maintenance**: {row['Last_Maintenance__c']}  
+        """
+        cards += card + "\n---\n"
+    return cards if cards else "No equipment matches the filters."
 
-    # Forecast the next value (predict the future usage)
-    forecast = model_fit.forecast(steps=1)
+# Generate heatmap
+def generate_heatmap(df):
+    dates = pd.date_range(start="2025-05-01", end="2025-05-07", freq="D")
+    equipment = df["Equipment_ID__c"].unique()
+    heatmap_data = np.random.rand(len(equipment), len(dates)) * 100  # Mock data
+    plt.figure(figsize=(10, 6))
+    sns.heatmap(heatmap_data, xticklabels=dates.strftime("%Y-%m-%d"), yticklabels=equipment, cmap="YlGnBu")
+    plt.title("Weekly Utilization Heatmap")
     
-    # Return forecasted value
-    return f"Forecasted usage for the next day: {forecast[0]:.2f}"
+    buffer = io.BytesIO()
+    plt.savefig(buffer, format="png")
+    buffer.seek(0)
+    img_str = base64.b64encode(buffer.getvalue()).decode()
+    plt.close()
+    return f"![Heatmap](data:image/png;base64,{img_str})"
 
-# Logistic Regression model (using usage and idle hours to predict equipment status)
-def model_prediction(equipment_id, usage_hours, idle_hours, movement_frequency, cost_per_hour):
-    # Feature extraction (from usage data)
-    features = np.array([usage_hours, idle_hours, movement_frequency, cost_per_hour]).reshape(1, -1)
+# Export data as CSV
+def export_csv(df):
+    return df.to_csv(index=False)
 
-    # Logistic Regression model (this is an example, replace with your trained model)
-    model = LogisticRegression()
+# Main Gradio interface
+def main(project_filter="All", suggestion_filter="All"):
+    df = load_data()
+    df = predict_suggestions(df)
+    cards = generate_cards(df, project_filter, suggestion_filter)
+    heatmap = generate_heatmap(df)
+    csv_data = export_csv(df)
+    return cards, heatmap, csv_data
+
+# Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("# Equipment Utilization Dashboard")
     
-    # Train on dummy data (replace this with historical usage data for actual training)
-    X = df[['usage_hours', 'idle_hours', 'movement_frequency', 'cost_per_hour']]
-    y = [0, 1, 0]  # 0 = Repair, 1 = Move (example)
-    model.fit(X, y)
+    with gr.Row():
+        project_filter = gr.Dropdown(choices=["All", "PRJ001", "PRJ002"], label="Filter by Project")
+        suggestion_filter = gr.Dropdown(choices=["All", "Move", "Pause Rent", "Repair", "Replace"], label="Filter by Suggestion")
     
-    # Predict suggestion (0 = Repair, 1 = Move)
-    prediction = model.predict(features)[0]
+    with gr.Row():
+        cards_output = gr.Markdown(label="Equipment Cards")
     
-    # Define suggestions
-    suggestions = {0: 'Repair', 1: 'Move'}
+    with gr.Row():
+        heatmap_output = gr.Markdown(label="Utilization Heatmap")
     
-    # Confidence score (example)
-    confidence = model.predict_proba(features)[0][prediction] * 100
+    with gr.Row():
+        export_button = gr.File(label="Download CSV", value=lambda: export_csv(load_data()))
     
-    # Return the suggestion and confidence
-    return f"Suggestion: {suggestions[prediction]}\nConfidence: {confidence:.2f}%"
-
-# Gradio Interface
-interface = gr.Interface(
-    fn=model_prediction,
-    inputs=[
-        gr.Dropdown(choices=df['equipment_id'].tolist(), label="Select Equipment"),
-        gr.Number(label="Usage Hours"),
-        gr.Number(label="Idle Hours"),
-        gr.Number(label="Movement Frequency"),
-        gr.Number(label="Cost per Hour")
-    ],
-    outputs="text"
-)
+    project_filter.change(main, inputs=[project_filter, suggestion_filter], outputs=[cards_output, heatmap_output, export_button])
+    suggestion_filter.change(main, inputs=[project_filter, suggestion_filter], outputs=[cards_output, heatmap_output, export_button])
 
-# Launch Gradio interface
-interface.launch()
+if __name__ == "__main__":
+    demo.launch()