Update app.py

app.py

@@ -25,28 +25,22 @@ except Exception as e:
 def validate_data(data_input):
     """Validate and process input data"""
     try:
-        if isinstance(data_input, str):
-            df = pd.read_csv(StringIO(data_input))
-        else:
-            raise ValueError("Input must be CSV text")
+        df = pd.read_csv(StringIO(data_input))
         
         # Validate columns
         if not all(col in df.columns for col in ['timestamp', 'value']):
-            raise ValueError("CSV must contain 'timestamp' and 'value' columns")
+            raise ValueError("CSV must contain timestamp and value columns")
         
-        # 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')
+        # Convert and validate data
+        df['timestamp'] = pd.to_datetime(df['timestamp'])
+        df['value'] = pd.to_numeric(df['value'])
+        df = df.sort_values('timestamp').reset_index(drop=True)
         
-        return df.sort_values('timestamp')
+        return df
     
     except Exception as e:
         logger.error(f"Data validation error: {str(e)}")
-        raise
+        raise ValueError(f"Invalid data format: {str(e)}")
 
 def detect_anomalies(data_input, sensitivity=3.0):
     """Perform reconstruction-based anomaly detection"""
@@ -54,17 +48,19 @@ def detect_anomalies(data_input, sensitivity=3.0):
         df = validate_data(data_input)
         values = df['value'].values.astype(np.float32)
         
-        # Reshape to 3D format (batch, sequence, features)
+        # Reshape to 3D format expected by MOMENT
         values_3d = values.reshape(1, -1, 1)
         
-        # Get reconstruction - using explicit parameter name
-        reconstructed = model.reconstruct(X=values_3d)
-        
-        # Calculate reconstruction error (MAE)
+        # Get reconstruction
+        reconstructed = model.reconstruct(values_3d)
         errors = np.abs(values - reconstructed[0,:,0])
         
-        # Dynamic threshold (z-score based)
-        threshold = np.mean(errors) + sensitivity * np.std(errors)
+        # Dynamic threshold (modified z-score)
+        median = np.median(errors)
+        mad = np.median(np.abs(errors - median))
+        threshold = median + sensitivity * (1.4826 * mad)
+        
+        # Store results
         df['anomaly_score'] = errors
         df['is_anomaly'] = errors > threshold
         
@@ -74,38 +70,36 @@ def detect_anomalies(data_input, sensitivity=3.0):
         ax.scatter(
             df.loc[df['is_anomaly'], 'timestamp'],
             df.loc[df['is_anomaly'], 'value'],
-            color='red', s=100, label=f'Anomaly (>{threshold:.2f})'
+            color='red', s=100, label=f'Anomaly (score > {threshold:.2f})'
         )
-        ax.set_title('Sensor Data Anomaly Detection')
+        ax.set_title('Sensor Data with Anomalies Detected')
         ax.set_xlabel('Timestamp')
         ax.set_ylabel('Value')
         ax.legend()
         ax.grid(True)
         plt.tight_layout()
         
-        # Limit DataFrame display size
-        display_df = df[['timestamp', 'value', 'anomaly_score', 'is_anomaly']].head(20)
+        # Prepare statistics
+        stats = {
+            "data_points": len(df),
+            "anomalies_detected": int(df['is_anomaly'].sum()),
+            "detection_threshold": float(threshold),
+            "max_anomaly_score": float(np.max(errors)),
+            "median_value": float(median),
+            "mean_value": float(np.mean(values))
+        }
         
-        return (
-            fig, 
-            {"statistics": {
-                "data_points": len(df),
-                "anomalies_detected": int(df['is_anomaly'].sum()),
-                "detection_threshold": float(threshold),
-                "max_anomaly_score": float(np.max(errors))
-            }},
-            display_df.to_dict('records')
-        )
+        # Prepare sample records (first 20)
+        sample_records = df.head(20).to_dict('records')
+        
+        return fig, stats, sample_records
     
     except Exception as e:
-        logger.error(f"Detection error: {str(e)}")
-        return (
-            None,
-            {"error": str(e)},
-            None
-        )
+        error_msg = str(e)
+        logger.error(f"Detection error: {error_msg}")
+        return None, {"error": error_msg}, None
 
-# Default data with clear anomaly
+# Default sample data
 DEFAULT_DATA = """timestamp,value
 2025-04-01 00:00:00,100
 2025-04-01 01:00:00,102
@@ -121,36 +115,36 @@ DEFAULT_DATA = """timestamp,value
 2025-04-01 11:00:00,102
 2025-04-01 12:00:00,101"""
 
-# Gradio Interface
+# Create Gradio interface
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # 📈 Equipment Anomaly Detection
-    Detect unusual patterns in sensor data using MOMENT-1-large model
+    # 🏭 Equipment Anomaly Detection
+    ### Using MOMENT-1-large foundation model
     """)
     
     with gr.Row():
         with gr.Column():
-            data_input = gr.Textbox(
-                label="Paste CSV Data",
+            input_data = gr.Textbox(
+                label="Enter CSV Data",
                 value=DEFAULT_DATA,
                 lines=10,
-                placeholder="timestamp,value\n2025-01-01, 100\n2025-01-02, 105..."
+                placeholder="timestamp,value\n2025-01-01 00:00:00,100\n..."
             )
             sensitivity = gr.Slider(
                 1.0, 5.0, value=3.0, step=0.1,
-                label="Detection Sensitivity (z-score)"
+                label="Detection Sensitivity"
             )
-            analyze_btn = gr.Button("Analyze", variant="primary")
+            analyze_btn = gr.Button("Detect Anomalies!", variant="primary")
             
         with gr.Column():
-            plot = gr.Plot(label="Results")
-            stats = gr.JSON(label="Detection Statistics")
-            results = gr.JSON(label="Top 20 Records")
+            plot_output = gr.Plot(label="Detection Results")
+            stats_output = gr.JSON(label="Statistics Summary")
+            records_output = gr.JSON(label="Sample Records (First 20)")
     
     analyze_btn.click(
         detect_anomalies,
-        inputs=[data_input, sensitivity],
-        outputs=[plot, stats, results]
+        inputs=[input_data, sensitivity],
+        outputs=[plot_output, stats_output, records_output]
     )
 
 if __name__ == "__main__":