Update app.py

app.py

@@ -2,8 +2,9 @@ import pandas as pd
 import numpy as np
 from momentfm import MOMENTPipeline
 from io import StringIO
+import gradio as gr
 
-# Initialize model globally
+# Initialize model with proper configuration
 model = MOMENTPipeline.from_pretrained(
     "AutonLab/MOMENT-1-large",
     model_kwargs={"task_name": "reconstruction"},
@@ -11,95 +12,85 @@ model = MOMENTPipeline.from_pretrained(
 model.init()
 
 def generate_analysis_report(data_input, sensitivity=3.0):
-    """Generate a comprehensive textual analysis report"""
+    """Generate comprehensive textual analysis report"""
     try:
-        # Process and validate data
+        # Process and validate input data
         df = pd.read_csv(StringIO(data_input))
         
-        # Validate columns
         if 'timestamp' not in df.columns or 'value' not in df.columns:
             return "Error: CSV must contain 'timestamp' and 'value' columns"
             
-        # Convert data types
         df['timestamp'] = pd.to_datetime(df['timestamp'], errors='coerce')
         df['value'] = pd.to_numeric(df['value'], errors='coerce')
         
-        # Check for invalid data
-        if df.isnull().any().any():
-            return "Error: Invalid data format (check timestamp/value formats)"
+        if df.isnull().values.any():
+            return "Error: Invalid data in timestamp or value columns"
             
-        df = df.sort_values('timestamp')
+        df = df.sort_values('timestamp').dropna()
         
-        # Prepare data for model
-        values = df['value'].values.astype(np.float32).reshape(1, -1, 1)
+        # Prepare data for model (3D array format)
+        values = df['value'].values.astype(np.float32)
+        values_3d = values.reshape(1, -1, 1)  # Reshape to [batch, sequence, features]
         
-        # Get reconstruction
-        reconstructed = model.reconstruct(values)
-        errors = np.abs(df['value'].values - reconstructed[0,:,0])
+        # Correct reconstruction call with proper parameter
+        reconstructed = model.reconstruct(X=values_3d)  # Using named parameter
         
-        # Calculate threshold (modified z-score)
+        # Calculate errors and detect anomalies
+        errors = np.abs(values - reconstructed[0,:,0])
         median = np.median(errors)
         mad = np.median(np.abs(errors - median))
         threshold = median + sensitivity * (1.4826 * mad)
         
         # Identify anomalies
-        anomalies = df[errors > threshold].copy()
-        anomalies['anomaly_score'] = errors[errors > threshold]
-        anomalies = anomalies.sort_values('anomaly_score', ascending=False)
-        
-        normal_points = df[errors <= threshold]
+        anomalies = df.copy()
+        anomalies['anomaly_score'] = errors
+        anomalies = anomalies[errors > threshold].sort_values('anomaly_score', ascending=False)
         
         # Generate report
         report = f"""
 EQUIPMENT ANALYSIS REPORT
 ========================
-Generated at: {pd.Timestamp.now()}
-Detection sensitivity: {sensitivity} (z-score)
+Generated: {pd.Timestamp.now().strftime('%Y-%m-%d %H:%M:%S')}
+Sensitivity: {sensitivity} (z-score)
 
-DATA OVERVIEW
--------------
+DATA SUMMARY
+------------
 Time period: {df['timestamp'].min()} to {df['timestamp'].max()}
-Total observations: {len(df)}
+Data points: {len(df)}
 Value range: {df['value'].min():.2f} to {df['value'].max():.2f}
 Median value: {df['value'].median():.2f}
-Mean value: {df['value'].mean():.2f}
 
-ANOMALY DETECTION RESULTS
--------------------------
+ANOMALY FINDINGS
+----------------
 Detection threshold: {threshold:.2f}
-Anomalies detected: {len(anomalies)} ({len(anomalies)/len(df):.1%} of data)
-Strongest anomaly: {errors.max():.2f} at {df.loc[errors.argmax(), 'timestamp']}
+Anomalies found: {len(anomalies)} ({len(anomalies)/len(df):.1%})
+Most severe: {errors.max():.2f} at {df.loc[errors.argmax(), 'timestamp']}
 
 TOP ANOMALIES
 -------------
-{anomalies[['timestamp', 'value', 'anomaly_score']].head(15).to_string(index=False, float_format='%.2f')}
-
-NORMAL OPERATION SUMMARY
-------------------------
-Typical value range: {normal_points['value'].min():.2f} to {normal_points['value'].max():.2f}
-Stable period duration: {pd.Timedelta(normal_points['timestamp'].max() - normal_points['timestamp'].min())}
+{anomalies[['timestamp', 'value', 'anomaly_score']].head(10).to_string(index=False, float_format='%.2f')}
 
 RECOMMENDATIONS
 ---------------
-1. Investigate top {min(3, len(anomalies))} anomalous readings
-2. Check equipment around {anomalies['timestamp'].iloc[0]} for potential issues
-3. Consider recalibration if anomalies cluster in specific time periods
-4. Review maintenance logs around detected anomalies
+1. Investigate top 3 anomalies for potential equipment issues
+2. Check maintenance records around {anomalies['timestamp'].iloc[0].strftime('%Y-%m-%d %H:%M')}
+3. Consider recalibration if anomalies persist
+4. Review sensor health if anomalies cluster in time
 """
         return report.strip()
     
     except Exception as e:
-        return f"ANALYSIS ERROR: {str(e)}"
+        return f"ANALYSIS FAILED: {str(e)}"
 
-# Gradio Interface for the report-only version
-import gradio as gr
-
-with gr.Blocks() as demo:
-    gr.Markdown("## 📄 Equipment Analysis Report Generator")
+# Gradio Interface
+with gr.Blocks(title="Equipment Analysis Reporter") as demo:
+    gr.Markdown("## 🏭 Equipment Health Analysis Report")
     
     with gr.Row():
         with gr.Column():
-            data_input = gr.Textbox(label="Paste CSV Data", lines=10, value="""timestamp,value
+            data_input = gr.Textbox(
+                label="Paste CSV Data (timestamp,value)",
+                value="""timestamp,value
 2025-04-01 00:00:00,100
 2025-04-01 01:00:00,102
 2025-04-01 02:00:00,98
@@ -112,12 +103,18 @@ with gr.Blocks() as demo:
 2025-04-01 09:00:00,98
 2025-04-01 10:00:00,99
 2025-04-01 11:00:00,102
-2025-04-01 12:00:00,101""")
-            sensitivity = gr.Slider(1.0, 5.0, value=3.0, label="Detection Sensitivity")
+2025-04-01 12:00:00,101""",
+                lines=10
+            )
+            sensitivity = gr.Slider(1.0, 5.0, value=3.0, step=0.1, label="Detection Sensitivity")
             submit_btn = gr.Button("Generate Report", variant="primary")
-        
+            
         with gr.Column():
-            report_output = gr.Textbox(label="Analysis Report", lines=20, interactive=False)
+            report_output = gr.Textbox(
+                label="Analysis Report", 
+                lines=20,
+                interactive=False
+            )
     
     submit_btn.click(
         generate_analysis_report,