Update app.py

app.py

@@ -1,77 +1,112 @@
 import gradio as gr
 import pandas as pd
 import numpy as np
-from momentfm import MOMENTPipeline
 import matplotlib.pyplot as plt
 from io import StringIO
+import logging
+from momentfm import MOMENTPipeline
 
-# Initialize model
-model = MOMENTPipeline.from_pretrained(
-    "AutonLab/MOMENT-1-large",
-    model_kwargs={"task_name": "reconstruction"},
-)
-model.init()
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-def detect_anomalies(data_input, threshold=0.1):
+# Initialize model (with error handling)
+try:
+    model = MOMENTPipeline.from_pretrained(
+        "AutonLab/MOMENT-1-large",
+        model_kwargs={"task_name": "reconstruction"},
+    )
+    model.init()
+    logger.info("Model loaded successfully")
+except Exception as e:
+    logger.error(f"Model loading failed: {str(e)}")
+    raise
+
+def validate_and_process_data(data_input):
+    """Handle all data validation and processing"""
     try:
         # Read data
         if isinstance(data_input, str):
             df = pd.read_csv(StringIO(data_input))
         else:
-            return "Error: Please provide CSV data"
-            
-        # Validate columns
-        if 'timestamp' not in df.columns or 'value' not in df.columns:
-            return "Error: CSV must contain 'timestamp' and 'value' columns", None, None
-            
-        # Convert timestamp and sort
-        df['timestamp'] = pd.to_datetime(df['timestamp'])
-        df = df.sort_values('timestamp')
+            raise ValueError("Input must be CSV text")
+        
+        # Check required columns
+        required = ['timestamp', 'value']
+        if not all(col in df.columns for col in required):
+            missing = [col for col in required if col not in df.columns]
+            raise ValueError(f"Missing columns: {missing}")
         
-        # Get values as numpy array
-        values = df['value'].values.astype(float)
+        # Convert and validate timestamp
+        df['timestamp'] = pd.to_datetime(df['timestamp'], errors='coerce')
+        if df['timestamp'].isnull().any():
+            raise ValueError("Invalid timestamp format")
+        
+        # Validate values
+        try:
+            df['value'] = pd.to_numeric(df['value'])
+        except:
+            raise ValueError("Non-numeric values found")
+        
+        # Sort by timestamp
+        df = df.sort_values('timestamp').reset_index(drop=True)
+        
+        return df
+    
+    except Exception as e:
+        logger.error(f"Data processing error: {str(e)}")
+        raise
+
+def detect_anomalies(data_input, threshold=0.1):
+    """Main anomaly detection function"""
+    try:
+        # Process input data
+        df = validate_and_process_data(data_input)
+        values = df['value'].values.astype(np.float32)
         
-        # Detect anomalies
+        # Get reconstruction
         reconstruction = model.reconstruct(values)
         errors = np.abs(values - reconstruction)
         
-        # Apply threshold (using relative error)
-        threshold_value = threshold * np.max(errors)
+        # Dynamic threshold (3σ from mean)
+        threshold_value = np.mean(errors) + 3 * np.std(errors)
         df['anomaly_score'] = errors
         df['is_anomaly'] = errors > threshold_value
         
         # Create plot
-        fig, ax = plt.subplots(figsize=(10, 4))
-        ax.plot(df['timestamp'], df['value'], label='Value', color='blue')
+        fig, ax = plt.subplots(figsize=(12, 5))
+        ax.plot(df['timestamp'], df['value'], 'b-', label='Value')
         ax.scatter(
             df.loc[df['is_anomaly'], 'timestamp'],
             df.loc[df['is_anomaly'], 'value'],
-            color='red', label='Anomaly'
+            color='red', s=100, label='Anomaly'
         )
-        ax.set_title('Sensor Data with Anomalies')
+        ax.set_title(f'Anomaly Detection (Threshold: {threshold_value:.2f})')
         ax.legend()
+        plt.close(fig)  # Prevents duplicate plots
         
-        # Prepare results
+        # Prepare outputs
         stats = {
-            "total_points": len(df),
-            "anomalies_detected": sum(df['is_anomaly']),
-            "max_anomaly_score": float(np.max(errors)),
-            "threshold_used": float(threshold_value)
+            "data_points": len(df),
+            "anomalies": int(df['is_anomaly'].sum()),
+            "threshold_used": float(threshold_value),
+            "max_score": float(np.max(errors))
         }
         
         return fig, stats, df.to_dict('records')
         
     except Exception as e:
-        return f"Error: {str(e)}", None, None
+        logger.error(f"Detection error: {str(e)}")
+        return None, {"error": str(e)}, None
 
-# Gradio interface
-with gr.Blocks() as demo:
-    gr.Markdown("## 🛠️ Equipment Anomaly Detection")
+# Gradio Interface
+with gr.Blocks(title="Anomaly Detector") as demo:
+    gr.Markdown("# 🚨 Time-Series Anomaly Detection")
     
     with gr.Row():
         with gr.Column():
             data_input = gr.Textbox(
-                label="Paste CSV data (timestamp,value)",
+                label="Paste CSV Data",
                 value="""timestamp,value
 2025-04-01 00:00:00,100
 2025-04-01 01:00:00,102
@@ -86,15 +121,15 @@ with gr.Blocks() as demo:
 2025-04-01 10:00:00,99
 2025-04-01 11:00:00,102
 2025-04-01 12:00:00,101""",
-                lines=10
+                lines=15
             )
-            threshold = gr.Slider(0.01, 0.5, value=0.1, label="Anomaly Threshold")
-            submit_btn = gr.Button("Detect Anomalies")
+            threshold = gr.Slider(0.01, 1.0, value=0.3, label="Sensitivity (higher = stricter)")
+            submit_btn = gr.Button("Analyze", variant="primary")
             
         with gr.Column():
-            plot_output = gr.Plot()
+            plot_output = gr.Plot(label="Results")
             stats_output = gr.JSON(label="Statistics")
-            data_output = gr.JSON(label="Detailed Results")
+            data_output = gr.JSON(label="Detailed Data")
     
     submit_btn.click(
         detect_anomalies,
@@ -102,4 +137,5 @@ with gr.Blocks() as demo:
         outputs=[plot_output, stats_output, data_output]
     )
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)