Update app.py

app.py

@@ -3,18 +3,18 @@ import pandas as pd
 from datetime import datetime
 import logging
 import plotly.express as px
-from sklearn.ensemble import IsolationForest
+from sklearn.ensemble import IsolationForest  # For anomaly detection
 from transformers import pipeline
-import torch
+import torch  # For GPU availability check
 
-# Configure logging
+# Configure logging for debugging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# Preload Hugging Face summarization model
+# Preload Hugging Face summarization model at startup
 logging.info("Preloading Hugging Face model...")
 try:
     device = 0 if torch.cuda.is_available() else -1
-    summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-12-6", device=device)
+    summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-12-6", device=device)  # Lighter model
     logging.info(f"Hugging Face model preloaded successfully on device: {'GPU' if device == 0 else 'CPU'}")
 except Exception as e:
     logging.error(f"Failed to preload model: {str(e)}")
@@ -26,57 +26,73 @@ def summarize_logs(df, progress=gr.Progress()):
     try:
         total_devices = df["device_id"].nunique()
         most_used = df.groupby("device_id")["usage_hours"].sum().idxmax() if not df.empty else "N/A"
+
         prompt = f"Maintenance logs: {total_devices} devices. Most used: {most_used}."
         summary = summarizer(prompt, max_length=50, min_length=10, do_sample=False)[0]["summary_text"]
+        logging.info("Summary generated successfully")
         return summary
     except Exception as e:
         logging.error(f"Summary generation failed: {str(e)}")
         return "Failed to generate summary."
 
-# Anomaly Detection
+# Anomaly Detection using Isolation Forest with sampling for large datasets
 def detect_anomalies(df, progress=gr.Progress()):
     progress(0.4, "Detecting anomalies...")
     try:
         if "usage_hours" not in df.columns or "downtime" not in df.columns:
-            return None, "Anomaly detection requires 'usage_hours' and 'downtime' columns."
+            logging.warning("Required columns for anomaly detection not found")
+            return "Anomaly detection requires 'usage_hours' and 'downtime' columns."
+
         if len(df) > 5000:
             df = df.sample(n=5000, random_state=42)
             logging.info("Sampled data for anomaly detection to 5,000 rows")
+
         features = df[["usage_hours", "downtime"]].fillna(0)
         iso_forest = IsolationForest(contamination=0.1, random_state=42, n_jobs=-1)
         df["anomaly"] = iso_forest.fit_predict(features)
+        
         anomalies = df[df["anomaly"] == -1][["device_id", "usage_hours", "downtime", "timestamp"]]
         if anomalies.empty:
-            return None, "No anomalies detected."
-        anomaly_lines = []
+            return "No anomalies detected."
+        
+        anomaly_lines = ["**Detected Anomalies:**"]
         for idx, row in anomalies.head(5).iterrows():
-            anomaly_lines.append(f"Device ID: {row['device_id']}, Usage Hours: {row['usage_hours']}, Downtime: {row['downtime']}, Timestamp: {row['timestamp']}")
-        return anomaly_lines, None
+            anomaly_lines.append(f"- Device ID: {row['device_id']}, Usage Hours: {row['usage_hours']}, Downtime: {row['downtime']}, Timestamp: {row['timestamp']}")
+        anomaly_list = "\n".join(anomaly_lines)
+        logging.info("Anomalies detected successfully")
+        return anomaly_list
     except Exception as e:
         logging.error(f"Anomaly detection failed: {str(e)}")
-        return None, f"Anomaly detection failed: {str(e)}"
+        return f"Anomaly detection failed: {str(e)}"
 
-# AMC Reminders
+# AMC Reminders based on device and AMC date
 def check_amc_reminders(df, current_date, progress=gr.Progress()):
     progress(0.6, "Checking AMC reminders...")
     try:
         if "device_id" not in df.columns or "amc_date" not in df.columns:
-            return None, "AMC reminders require 'device_id' and 'amc_date' columns."
+            logging.warning("Required columns for AMC reminders not found")
+            return "AMC reminders require 'device_id' and 'amc_date' columns."
+
         df["amc_date"] = pd.to_datetime(df["amc_date"], errors='coerce')
         current_date = pd.to_datetime(current_date)
+        
         df["days_to_amc"] = (df["amc_date"] - current_date).dt.days
         reminders = df[(df["days_to_amc"] >= 0) & (df["days_to_amc"] <= 30)][["device_id", "amc_date"]]
+        
         if reminders.empty:
-            return None, "No AMC reminders due within the next 30 days."
-        reminder_lines = []
+            return "No AMC reminders due within the next 30 days."
+        
+        reminder_lines = ["**Upcoming AMC Reminders:**"]
         for idx, row in reminders.head(5).iterrows():
-            reminder_lines.append(f"Device ID: {row['device_id']}, AMC Date: {row['amc_date']}")
-        return reminder_lines, None
+            reminder_lines.append(f"- Device ID: {row['device_id']}, AMC Date: {row['amc_date']}")
+        reminder_list = "\n".join(reminder_lines)
+        logging.info("AMC reminders generated successfully")
+        return reminder_list
     except Exception as e:
         logging.error(f"AMC reminder generation failed: {str(e)}")
-        return None, f"AMC reminder generation failed: {str(e)}"
+        return f"AMC reminder generation failed: {str(e)}"
 
-# Dashboard Insights
+# Dashboard Insights (AI-generated executive-level insights)
 def generate_dashboard_insights(df, progress=gr.Progress()):
     progress(0.8, "Generating dashboard insights...")
     try:
@@ -84,41 +100,57 @@ def generate_dashboard_insights(df, progress=gr.Progress()):
         avg_usage = df["usage_hours"].mean() if "usage_hours" in df.columns else 0
         prompt = f"Insights: {total_devices} devices, avg usage {avg_usage:.2f} hours."
         insights = summarizer(prompt, max_length=50, min_length=10, do_sample=False)[0]["summary_text"]
+        logging.info("Dashboard insights generated successfully")
         return insights
     except Exception as e:
         logging.error(f"Dashboard insights generation failed: {str(e)}")
         return f"Dashboard insights generation failed: {str(e)}"
 
-# Create usage chart data for LaTeX table
-def create_usage_chart_data(df, progress=gr.Progress()):
-    progress(0.9, "Creating usage chart data...")
+# Create a bar chart for usage hours per device
+def create_usage_chart(df, progress=gr.Progress()):
+    progress(0.9, "Creating usage chart...")
     try:
         usage_data = df.groupby("device_id")["usage_hours"].sum().reset_index()
         if len(usage_data) > 5:
             usage_data = usage_data.nlargest(5, "usage_hours")
             logging.info("Limited chart data to top 5 devices")
-        chart_lines = []
-        for idx, row in usage_data.iterrows():
-            chart_lines.append(f"{row['device_id']} & {row['usage_hours']:.2f} \\\\")
-        return chart_lines
+
+        custom_colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4']
+        fig = px.bar(
+            usage_data,
+            x="device_id",
+            y="usage_hours",
+            title="Usage Hours per Device",
+            labels={"device_id": "Device ID", "usage_hours": "Usage Hours"},
+            color="device_id",
+            color_discrete_sequence=custom_colors
+        )
+        fig.update_layout(
+            title_font_size=16,
+            margin=dict(l=20, r=20, t=40, b=20),
+            plot_bgcolor="white",
+            paper_bgcolor="white",
+            font=dict(size=12)
+        )
+        return fig
     except Exception as e:
-        logging.error(f"Failed to create usage chart data: {str(e)}")
-        return []
+        logging.error(f"Failed to create usage chart: {str(e)}")
+        return None
 
 # Main Gradio function
 async def process_logs(file_obj, row_limit=10000, progress=gr.Progress()):
     try:
         progress(0, "Starting file processing...")
         if file_obj is None:
-            logging.warning("No file uploaded")
-            return "No file uploaded."
+            logging.warning("No file uploaded, returning empty results")
+            return "No file uploaded.", "No data to preview.", None, "No anomalies detected.", "No AMC reminders.", "No insights generated."
         
         file_name = file_obj.name if hasattr(file_obj, 'name') else file_obj
         logging.info(f"Processing file: {file_name}")
         
         if not file_name.endswith(".csv"):
             logging.error("Unsupported file format")
-            return "Unsupported file format. Please upload a CSV file."
+            return "Unsupported file format. Please upload a CSV file.", None, None, None, None, None
 
         progress(0.05, "Loading CSV file...")
         try:
@@ -133,177 +165,109 @@ async def process_logs(file_obj, row_limit=10000, progress=gr.Progress()):
             logging.info(f"File loaded successfully with {len(df)} rows (limited to {row_limit} rows)")
         except Exception as e:
             logging.error(f"Failed to load CSV: {str(e)}")
-            return f"Failed to load CSV: {str(e)}"
+            return f"Failed to load CSV: {str(e)}", None, None, None, None, None
 
         progress(0.1, "Converting timestamps...")
         try:
             df["timestamp"] = pd.to_datetime(df["timestamp"], errors='coerce')
         except Exception as e:
             logging.error(f"Date conversion failed: {str(e)}")
-            return f"Failed to convert timestamp to datetime: {str(e)}"
+            return f"Failed to convert timestamp to datetime: {str(e)}", None, None, None, None, None
 
         if df.empty:
             logging.warning("No data in the file")
-            return "No data available in the file."
+            return "No data available in the file.", "No data to preview.", None, "No anomalies detected.", "No AMC reminders.", "No insights generated."
 
         # Step 1: Summary Report
-        summary = summarize_logs(df, progress)
+        progress(0.2, "Generating summary...")
+        summary = f"**Step 1: Summary Report**  \n{summarize_logs(df, progress)}"
 
         # Step 2: Log Preview
-        preview_lines = []
+        progress(0.3, "Previewing logs...")
         if not df.empty:
+            preview_lines = ["**Step 2: Log Preview (First 5 Rows)**"]
             for idx, row in df.head().iterrows():
-                preview_lines.append(f"Row {idx + 1}: Device ID: {row['device_id']}, Timestamp: {row['timestamp']}, Usage Hours: {row['usage_hours']}, Downtime: {row['downtime']}, AMC Date: {row['amc_date']}")
+                preview_lines.append(f"**Row {idx + 1}:** Device ID: {row['device_id']}, Timestamp: {row['timestamp']}, Usage Hours: {row['usage_hours']}, Downtime: {row['downtime']}, AMC Date: {row['amc_date']}")
+            preview = "\n".join(preview_lines)
         else:
-            preview_lines = ["No data available."]
+            preview = "**Step 2: Log Preview**  \nNo data available."
 
-        # Step 3: Usage Chart (Textual Data)
-        chart_data = create_usage_chart_data(df, progress)
+        # Step 3: Usage Chart
+        chart = create_usage_chart(df, progress)
 
         # Step 4: Anomaly Detection
-        anomaly_lines, anomaly_error = detect_anomalies(df, progress)
-        if anomaly_error:
-            anomaly_lines = [anomaly_error]
+        anomalies = f"**Step 3: Anomaly Detection**  \n{detect_anomalies(df, progress)}"
 
         # Step 5: AMC Reminders
-        reminder_lines, reminder_error = check_amc_reminders(df, datetime.now(), progress)
-        if reminder_error:
-            reminder_lines = [reminder_error]
+        amc_reminders = f"**Step 4: AMC Reminders**  \n{check_amc_reminders(df, datetime.now(), progress)}"
 
         # Step 6: Dashboard Insights
-        insights = generate_dashboard_insights(df, progress)
-
-        # Define the LaTeX template
-        latex_template = r"""
-% Defining document class and basic setup
-\documentclass[a4paper,10pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{geometry}
-\geometry{margin=1in}
-\usepackage{amsmath}
-\usepackage{amsfonts}
-\usepackage{graphicx}
-\usepackage{booktabs}
-\usepackage{enumitem}
-\usepackage{hyperref}
-\usepackage{xcolor}
-\usepackage{titlesec}
-
-% Setting up fonts and language support (using PDFLaTeX compatible fonts)
-\usepackage{mathptmx} % Times-compatible font for math and text
-\usepackage{helvet}   % Helvetica for sans-serif
-\usepackage{courier}  % Courier for monospace
-
-% Customizing section headers
-\titleformat{\section}{\large\bfseries}{\thesection}{1em}{}
-\titleformat{\subsection}{\normalsize\bfseries}{\thesubsection}{1em}{}
-
-% Reducing spacing in lists and sections
-\setlist{itemsep=2pt,parsep=2pt,topsep=4pt}
-\titlespacing*{\section}{0pt}{8pt}{4pt}
-\titlespacing*{\subsection}{0pt}{6pt}{2pt}
-
-% Document begins here
-\begin{document}
-
-% Title and date
-\title{LabOps Log Analyzer Report}
-\author{Automated Analysis}
-\date{June 05, 2025}
-\maketitle
-
-% Introduction
-\section*{Introduction}
-This report presents the analysis of lab equipment logs as of June 05, 2025. The analysis includes a summary, log preview, usage statistics, anomaly detection, AMC reminders, and AI-generated insights.
-
-% Step 1: Summary Report
-\section{Summary Report}
-{{SUMMARY_REPORT}}
-
-% Step 2: Log Preview
-\section{Log Preview (First 5 Rows)}
-\begin{itemize}
-{{LOG_PREVIEW}}
-\end{itemize}
-
-% Step 3: Usage Chart (Textual Description)
-\section{Usage Chart}
-The following table summarizes the usage hours for the top 5 devices:
-\begin{table}[h]
-\centering
-\begin{tabular}{lc}
-\toprule
-\textbf{Device ID} & \textbf{Usage Hours} \\
-\midrule
-{{USAGE_CHART_DATA}}
-\bottomrule
-\end{tabular}
-\caption{Usage Hours per Device}
-\end{table}
-
-% Step 4: Anomaly Detection
-\section{Anomaly Detection}
-\begin{itemize}
-{{ANOMALY_DETECTION}}
-\end{itemize}
-
-% Step 5: AMC Reminders
-\section{AMC Reminders}
-\begin{itemize}
-{{AMC_REMINDERS}}
-\end{itemize}
-
-% Step 6: Dashboard Insights
-\section{Dashboard Insights (AI)}
-{{DASHBOARD_INSIGHTS}}
-
-% End of document
-\end{document}
-"""
-
-        # Populate the LaTeX template with the output data
-        latex_content = latex_template.replace("{{SUMMARY_REPORT}}", summary.replace("%", "\%"))
-        latex_content = latex_content.replace("{{LOG_PREVIEW}}", "\n".join([f"\\item {line}" for line in preview_lines]).replace("%", "\%"))
-        latex_content = latex_content.replace("{{USAGE_CHART_DATA}}", "\n".join(chart_data).replace("%", "\%"))
-        latex_content = latex_content.replace("{{ANOMALY_DETECTION}}", "\n".join([f"\\item {line}" for line in anomaly_lines]).replace("%", "\%"))
-        latex_content = latex_content.replace("{{AMC_REMINDERS}}", "\n".join([f"\\item {line}" for line in reminder_lines]).replace("%", "\%"))
-        latex_content = latex_content.replace("{{DASHBOARD_INSIGHTS}}", insights.replace("%", "\%"))
-
-        # Construct the xaiArtifact tag with proper indentation
-        artifact_content = (
-            '<xaiArtifact artifact_id="05686e4a-85a8-4140-8113-1e86048b96fc" '
-            'artifact_version_id="48e949a0-ea29-45d9-b47d-7f21069da965" '
-            'title="LabOps_Analysis_Report.tex" contentType="text/latex">\n'
-            f'{latex_content}\n'
-            '</xaiArtifact>'
-        )
-
-        return artifact_content
+        insights = f"**Step 5: Dashboard Insights (AI)**  \n{generate_dashboard_insights(df, progress)}"
 
+        progress(1.0, "Processing complete!")
+        return summary, preview, chart, anomalies, amc_reminders, insights
     except Exception as e:
         logging.error(f"Failed to process file: {str(e)}")
-        return f"Failed to process file: {str(e)}"
+        return f"Failed to process file: {str(e)}", None, None, None, None, None
 
-# Gradio Interface
+# Gradio Interface with Step-by-Step Layout
 try:
     logging.info("Initializing Gradio Blocks interface...")
-    with gr.Blocks() as iface:
+    with gr.Blocks(css="""
+        .dashboard-container {border: 1px solid #e0e0e0; padding: 10/* Reduced padding */ 10px; border-radius: 5px; background-color: #f9f9f9;}
+        .dashboard-title {font-size: 24px; font-weight: bold; margin-bottom: 5px; /* Reduced margin */}
+        .dashboard-section {margin-bottom: 5px; /* Reduced margin */}
+        .dashboard-section h3 {font-size: 18px; margin-bottom: 2px; /* Reduced margin */}
+        .dashboard-section p {margin: 1px 0; line-height: 1.2; /* Tighter line spacing */}
+        .dashboard-section li {margin: 1px 0; line-height: 1.2; /* Tighter spacing for list items */}
+        .dashboard-section ul {margin: 2px 0; padding-left: 20px; /* Reduced margin/padding for lists */}
+    """) as iface:
         gr.Markdown("<h1>LabOps Log Analyzer Dashboard (Hugging Face AI)</h1>")
-        gr.Markdown("Upload a CSV file to generate a PDF report.")
+        gr.Markdown("Upload a CSV file containing lab equipment logs to analyze usage.")
 
         with gr.Row():
             with gr.Column(scale=1):
                 file_input = gr.File(label="Upload Logs (CSV)", file_types=[".csv"])
-                submit_button = gr.Button("Generate PDF Report", variant="primary")
+                submit_button = gr.Button("Submit", variant="primary")
             
             with gr.Column(scale=2):
-                output = gr.Markdown()
+                with gr.Group(elem_classes="dashboard-container"):
+                    gr.Markdown("<div class='dashboard-title'>Analysis Results (Step-by-Step)</div>")
+                    
+                    # Step 1: Summary Report
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 1: Summary Report")
+                        summary_output = gr.Markdown()
+                    
+                    # Step 2: Log Preview
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 2: Log Preview")
+                        preview_output = gr.Markdown()
+                    
+                    # Step 3: Usage Chart
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 3: Usage Chart")
+                        chart_output = gr.Plot()
+                    
+                    # Step 4: Anomaly Detection
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 4: Anomaly Detection")
+                        anomaly_output = gr.Markdown()
+                    
+                    # Step 5: AMC Reminders
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 5: AMC Reminders")
+                        amc_output = gr.Markdown()
+                    
+                    # Step 6: Dashboard Insights
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 6: Dashboard Insights (AI)")
+                        insights_output = gr.Markdown()
 
         submit_button.click(
             fn=process_logs,
             inputs=[file_input],
-            outputs=[output]
+            outputs=[summary_output, preview_output, chart_output, anomaly_output, amc_output, insights_output]
         )
 
     logging.info("Gradio interface initialized successfully")