Update app.py

app.py

@@ -4,41 +4,69 @@ import numpy as np
 import matplotlib.pyplot as plt
 from io import StringIO
 from momentfm import MOMENTPipeline
-from datetime import datetime
+import logging
 
-# Initialize model correctly
-model = MOMENTPipeline.from_pretrained(
-    "AutonLab/MOMENT-1-large",
-    model_kwargs={"task_name": "anomaly_detection"},  # Changed task name
-)
-model.init()
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-def detect_anomalies(data_input, threshold=3.0):  # Changed default threshold
+# Initialize model with reconstruction task
+try:
+    model = MOMENTPipeline.from_pretrained(
+        "AutonLab/MOMENT-1-large",
+        model_kwargs={"task_name": "reconstruction"},  # Correct task name
+    )
+    model.init()
+    logger.info("Model loaded successfully")
+except Exception as e:
+    logger.error(f"Model loading failed: {str(e)}")
+    raise
+
+def validate_data(data_input):
+    """Validate and process input data"""
     try:
-        # Process input data
-        df = pd.read_csv(StringIO(data_input))
+        if isinstance(data_input, str):
+            df = pd.read_csv(StringIO(data_input))
+        else:
+            raise ValueError("Input must be CSV text")
         
-        # Validate data
-        if 'timestamp' not in df.columns or 'value' not in df.columns:
-            return None, {"error": "CSV must contain 'timestamp' and 'value' columns"}, None
+        # Validate columns
+        if not all(col in df.columns for col in ['timestamp', 'value']):
+            raise ValueError("CSV must contain 'timestamp' and 'value' columns")
         
-        df['timestamp'] = pd.to_datetime(df['timestamp'])
-        df = df.sort_values('timestamp')
+        # Convert timestamps
+        df['timestamp'] = pd.to_datetime(df['timestamp'], errors='coerce')
+        if df['timestamp'].isnull().any():
+            raise ValueError("Invalid timestamp format")
+            
+        # Convert values to numeric
+        df['value'] = pd.to_numeric(df['value'], errors='raise')
         
-        # Prepare input for MOMENT (must be 3D array: [samples, timesteps, features])
+        return df.sort_values('timestamp')
+    
+    except Exception as e:
+        logger.error(f"Data validation error: {str(e)}")
+        raise
+
+def detect_anomalies(data_input, sensitivity=3.0):
+    """Perform reconstruction-based anomaly detection"""
+    try:
+        df = validate_data(data_input)
         values = df['value'].values.astype(np.float32)
-        values_3d = values.reshape(1, -1, 1)  # Reshape to 3D
         
-        # Correct reconstruction call
-        reconstruction = model.reconstruct(X=values_3d)  # Using named parameter
+        # Reshape to 3D format (batch, sequence, features)
+        values_3d = values.reshape(1, -1, 1)
+        
+        # Get reconstruction
+        reconstructed = model.reconstruct(values_3d)
         
-        # Calculate errors (flatten back to 1D)
-        errors = np.abs(values - reconstruction[0,:,0])
+        # Calculate reconstruction error (MAE)
+        errors = np.abs(values - reconstructed[0,:,0])
         
-        # Dynamic threshold (using z-score)
-        threshold_value = np.mean(errors) + threshold * np.std(errors)
+        # Dynamic threshold (z-score based)
+        threshold = np.mean(errors) + sensitivity * np.std(errors)
         df['anomaly_score'] = errors
-        df['is_anomaly'] = errors > threshold_value
+        df['is_anomaly'] = errors > threshold
         
         # Create plot
         fig, ax = plt.subplots(figsize=(12, 5))
@@ -48,30 +76,31 @@ def detect_anomalies(data_input, threshold=3.0):  # Changed default threshold
             df.loc[df['is_anomaly'], 'value'],
             color='red', s=100, label='Anomaly'
         )
-        ax.set_title(f'Anomaly Detection (Threshold: {threshold_value:.2f})')
+        ax.set_title(f'Anomaly Detection (Threshold: {threshold:.2f})')
         ax.legend()
         
         # Prepare outputs
         stats = {
             "data_points": len(df),
-            "anomalies": int(df['is_anomaly'].sum()),
-            "threshold": float(threshold_value),
-            "max_score": float(np.max(errors))
+            "anomalous_points": int(df['is_anomaly'].sum()),
+            "detection_threshold": float(threshold),
+            "max_error": float(np.max(errors))
         }
         
         return fig, stats, df.to_dict('records')
-        
+    
     except Exception as e:
+        logger.error(f"Detection error: {str(e)}")
         return None, {"error": str(e)}, None
 
-# Gradio interface
-with gr.Blocks() as demo:
-    gr.Markdown("# 🚨 Time-Series Anomaly Detection")
+# Gradio Interface
+with gr.Blocks(title="MOMENT Anomaly Detector") as demo:
+    gr.Markdown("## 🔍 Equipment Anomaly Detection using MOMENT")
     
     with gr.Row():
         with gr.Column():
             data_input = gr.Textbox(
-                label="Paste CSV Data", 
+                label="Paste time-series data (CSV format)",
                 value="""timestamp,value
 2025-04-01 00:00:00,100
 2025-04-01 01:00:00,102
@@ -88,19 +117,28 @@ with gr.Blocks() as demo:
 2025-04-01 12:00:00,101""",
                 lines=15
             )
-            threshold = gr.Slider(1.0, 5.0, value=3.0, step=0.1, label="Z-Score Threshold")
-            submit_btn = gr.Button("Analyze", variant="primary")
+            sensitivity = gr.Slider(
+                minimum=1.0,
+                maximum=5.0,
+                value=3.0,
+                step=0.1,
+                label="Detection Sensitivity (Z-Score)"
+            )
+            submit_btn = gr.Button("Analyze Data", variant="primary")
             
         with gr.Column():
-            plot_output = gr.Plot()
-            stats_output = gr.JSON()
-            data_output = gr.JSON()
+            plot_output = gr.Plot(label="Anomaly Detection Results")
+            stats_output = gr.JSON(label="Detection Statistics")
+            data_output = gr.JSON(
+                label="Processed Data",
+                max_lines=15
+            )
     
     submit_btn.click(
         detect_anomalies,
-        inputs=[data_input, threshold],
+        inputs=[data_input, sensitivity],
         outputs=[plot_output, stats_output, data_output]
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(server_name="0.0.0.0", server_port=7860)