Update app.py

app.py

@@ -1,106 +1,64 @@
-import gradio as gr
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-from io import StringIO
-from momentfm import MOMENTPipeline
-import logging
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Initialize model with reconstruction task
-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_data(data_input):
-    """Validate and process input data"""
+def generate_analysis_report(data_input, sensitivity=3.0):
+    """Generate a textual analysis report without visual outputs"""
     try:
+        # Process and validate data
         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")
-        
-        # 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)
+        df = df.sort_values('timestamp')
         
-        return df
-    
-    except Exception as e:
-        logger.error(f"Data validation error: {str(e)}")
-        raise ValueError(f"Invalid data format: {str(e)}")
-
-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)
-        
-        # Reshape to 3D format expected by MOMENT
-        values_3d = values.reshape(1, -1, 1)
+        # Prepare data for model
+        values = df['value'].values.astype(np.float32).reshape(1, -1, 1)
         
         # Get reconstruction
-        reconstructed = model.reconstruct(values_3d)
-        errors = np.abs(values - reconstructed[0,:,0])
+        reconstructed = model.reconstruct(values)
+        errors = np.abs(df['value'].values - reconstructed[0,:,0])
         
-        # Dynamic threshold (modified z-score)
+        # Calculate 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
-        
-        # Create plot
-        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', s=100, label=f'Anomaly (score > {threshold:.2f})'
-        )
-        ax.set_title('Sensor Data with Anomalies Detected')
-        ax.set_xlabel('Timestamp')
-        ax.set_ylabel('Value')
-        ax.legend()
-        ax.grid(True)
-        plt.tight_layout()
+        # Identify anomalies
+        anomalies = df[errors > threshold]
+        normal_points = df[errors <= threshold]
         
-        # 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))
-        }
-        
-        # Prepare sample records (first 20)
-        sample_records = df.head(20).to_dict('records')
-        
-        return fig, stats, sample_records
+        # Generate report
+        report = f"""
+EQUIPMENT ANALYSIS REPORT
+========================
+
+Basic Statistics:
+- Total data points: {len(df)}
+- Time period covered: {df['timestamp'].min()} to {df['timestamp'].max()}
+- Value range: {df['value'].min():.2f} to {df['value'].max():.2f}
+- Median value: {df['value'].median():.2f}
+
+Anomaly Detection Results:
+- 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']}
+
+Anomaly Details:
+{anomalies.to_string(index=False)}
+
+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())}
+
+Recommendations:
+1. Investigate {len(anomalies)} anomalous readings
+2. Focus on period around {anomalies['timestamp'].iloc[0]} for root cause analysis
+3. Consider recalibration if anomalies persist
+"""
+        return report
     
     except Exception as e:
-        error_msg = str(e)
-        logger.error(f"Detection error: {error_msg}")
-        return None, {"error": error_msg}, None
+        return f"Analysis failed: {str(e)}"
 
-# Default sample data
-DEFAULT_DATA = """timestamp,value
+# Example usage:
+report = generate_analysis_report("""
+timestamp,value
 2025-04-01 00:00:00,100
 2025-04-01 01:00:00,102
 2025-04-01 02:00:00,98
@@ -113,39 +71,7 @@ DEFAULT_DATA = """timestamp,value
 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"""
-
-# Create Gradio interface
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🏭 Equipment Anomaly Detection
-    ### Using MOMENT-1-large foundation model
-    """)
-    
-    with gr.Row():
-        with gr.Column():
-            input_data = gr.Textbox(
-                label="Enter CSV Data",
-                value=DEFAULT_DATA,
-                lines=10,
-                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"
-            )
-            analyze_btn = gr.Button("Detect Anomalies!", variant="primary")
-            
-        with gr.Column():
-            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=[input_data, sensitivity],
-        outputs=[plot_output, stats_output, records_output]
-    )
+2025-04-01 12:00:00,101
+""")
 
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+print(report)