Update app.py

app.py

@@ -3,73 +3,40 @@ import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
 from io import StringIO
-import logging
 from momentfm import MOMENTPipeline
+from datetime import datetime
 
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# Initialize model correctly
+model = MOMENTPipeline.from_pretrained(
+    "AutonLab/MOMENT-1-large",
+    model_kwargs={"task_name": "anomaly_detection"},  # Changed task name
+)
+model.init()
 
-# 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"""
+def detect_anomalies(data_input, threshold=3.0):  # Changed default threshold
     try:
-        # Read data
-        if isinstance(data_input, str):
-            df = pd.read_csv(StringIO(data_input))
-        else:
-            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}")
-        
-        # Convert and validate timestamp
-        df['timestamp'] = pd.to_datetime(df['timestamp'], errors='coerce')
-        if df['timestamp'].isnull().any():
-            raise ValueError("Invalid timestamp format")
+        # Process input data
+        df = pd.read_csv(StringIO(data_input))
         
-        # Validate values
-        try:
-            df['value'] = pd.to_numeric(df['value'])
-        except:
-            raise ValueError("Non-numeric values found")
+        # 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
         
-        # Sort by timestamp
-        df = df.sort_values('timestamp').reset_index(drop=True)
+        df['timestamp'] = pd.to_datetime(df['timestamp'])
+        df = df.sort_values('timestamp')
         
-        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)
+        # Prepare input for MOMENT (must be 3D array: [samples, timesteps, features])
         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
         
-        # Get reconstruction
-        reconstruction = model.reconstruct(values)
-        errors = np.abs(values - reconstruction)
+        # Calculate errors (flatten back to 1D)
+        errors = np.abs(values - reconstruction[0,:,0])
         
-        # Dynamic threshold (3σ from mean)
-        threshold_value = np.mean(errors) + 3 * np.std(errors)
+        # Dynamic threshold (using z-score)
+        threshold_value = np.mean(errors) + threshold * np.std(errors)
         df['anomaly_score'] = errors
         df['is_anomaly'] = errors > threshold_value
         
@@ -83,30 +50,28 @@ def detect_anomalies(data_input, threshold=0.1):
         )
         ax.set_title(f'Anomaly Detection (Threshold: {threshold_value:.2f})')
         ax.legend()
-        plt.close(fig)  # Prevents duplicate plots
         
         # Prepare outputs
         stats = {
             "data_points": len(df),
             "anomalies": int(df['is_anomaly'].sum()),
-            "threshold_used": float(threshold_value),
+            "threshold": float(threshold_value),
             "max_score": 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(title="Anomaly Detector") as demo:
+# Gradio interface
+with gr.Blocks() as demo:
     gr.Markdown("# 🚨 Time-Series Anomaly Detection")
     
     with gr.Row():
         with gr.Column():
             data_input = gr.Textbox(
-                label="Paste CSV Data",
+                label="Paste CSV Data", 
                 value="""timestamp,value
 2025-04-01 00:00:00,100
 2025-04-01 01:00:00,102
@@ -123,13 +88,13 @@ with gr.Blocks(title="Anomaly Detector") as demo:
 2025-04-01 12:00:00,101""",
                 lines=15
             )
-            threshold = gr.Slider(0.01, 1.0, value=0.3, label="Sensitivity (higher = stricter)")
+            threshold = gr.Slider(1.0, 5.0, value=3.0, step=0.1, label="Z-Score Threshold")
             submit_btn = gr.Button("Analyze", variant="primary")
             
         with gr.Column():
-            plot_output = gr.Plot(label="Results")
-            stats_output = gr.JSON(label="Statistics")
-            data_output = gr.JSON(label="Detailed Data")
+            plot_output = gr.Plot()
+            stats_output = gr.JSON()
+            data_output = gr.JSON()
     
     submit_btn.click(
         detect_anomalies,
@@ -138,4 +103,4 @@ with gr.Blocks(title="Anomaly Detector") as demo:
     )
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch()