Download api/main.py from deropxyz/AC02-ML: direct link, hf CLI and curl.
- Browser
- Download file 35.8 kB
-
https://huggingface.co/spaces/deropxyz/AC02-ML/resolve/main/api/main.py
- Command line
-
hf download hf://spaces/deropxyz/AC02-ML/api/main.py
-
curl -L -o main.py https://huggingface.co/spaces/deropxyz/AC02-ML/resolve/main/api/main.py
35.8 kB
| """ | |
| FastAPI Predictive Maintenance API with Rule-Based Diagnostics | |
| Senior Backend Engineer & Reliability Engineer Implementation | |
| Features: | |
| - ML-based failure prediction using XGBoost | |
| - Physics-based diagnostic engine | |
| - Single prediction and batch processing endpoints | |
| - Production-ready with proper error handling | |
| """ | |
| from fastapi import FastAPI, HTTPException, UploadFile, File | |
| from fastapi.middleware.cors import CORSMiddleware | |
| from fastapi.responses import StreamingResponse | |
| from pydantic import BaseModel, Field, validator | |
| from typing import Optional, Dict, Any, List | |
| import joblib | |
| import numpy as np | |
| import pandas as pd | |
| from datetime import datetime | |
| from pathlib import Path | |
| import os | |
| import io | |
| import logging | |
| # Configure logging | |
| logging.basicConfig(level=logging.INFO) | |
| logger = logging.getLogger(__name__) | |
| # Initialize FastAPI | |
| app = FastAPI( | |
| title="Predictive Maintenance API", | |
| description="ML + Rule-Based Diagnostics for Industrial Equipment", | |
| version="1.0.0" | |
| ) | |
| # CORS Configuration | |
| app.add_middleware( | |
| CORSMiddleware, | |
| allow_origins=["*"], | |
| allow_credentials=True, | |
| allow_methods=["*"], | |
| allow_headers=["*"], | |
| ) | |
| from huggingface_hub import hf_hub_download | |
| # Global model pipeline | |
| MODEL_PIPELINE = None | |
| HF_MODEL_REPO = os.getenv("HF_MODEL_REPO", "deropxyz/AC02-ML") | |
| PRIMARY_MODEL_FILENAME = os.getenv("HF_PRIMARY_MODEL", "model_pipeline_improved.joblib") | |
| FALLBACK_MODEL_FILENAME = os.getenv("HF_FALLBACK_MODEL", "model_pipeline.joblib") | |
| HF_TOKEN = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN") | |
| def download_model_artifact(filename: str) -> Path: | |
| """ | |
| Download a model artifact from Hugging Face Hub and return the local cache path. | |
| """ | |
| if not filename: | |
| raise ValueError("Filename must be provided for model download") | |
| logger.info("Downloading model '%s' from repo '%s'...", filename, HF_MODEL_REPO) | |
| cache_path = hf_hub_download( | |
| repo_id=HF_MODEL_REPO, | |
| filename=filename, | |
| repo_type="model", | |
| token=HF_TOKEN, | |
| ) | |
| return Path(cache_path) | |
| # ============================================================================ | |
| # REQUEST/RESPONSE SCHEMAS | |
| # ============================================================================ | |
| class PredictionRequest(BaseModel): | |
| """Single prediction request schema matching dataset columns""" | |
| machine_id: Optional[str] = Field(None, description="Machine identifier (e.g., M_L_01)") | |
| air_temperature: float = Field(..., ge=250, le=350, description="Air temperature in Kelvin") | |
| process_temperature: float = Field(..., ge=250, le=400, description="Process temperature in Kelvin") | |
| rotational_speed: int = Field(..., ge=0, le=3000, description="Rotational speed in RPM") | |
| torque: float = Field(..., ge=0, le=100, description="Torque in Nm") | |
| tool_wear: int = Field(..., ge=0, le=300, description="Tool wear in minutes") | |
| type: str = Field(..., description="Machine type: L (Low), M (Medium), H (High)") | |
| def validate_type(cls, v): | |
| if v not in ['L', 'M', 'H']: | |
| raise ValueError('Type must be L, M, or H') | |
| return v | |
| class Config: | |
| schema_extra = { | |
| "example": { | |
| "machine_id": "M_L_01", | |
| "air_temperature": 298.1, | |
| "process_temperature": 308.6, | |
| "rotational_speed": 1551, | |
| "torque": 42.8, | |
| "tool_wear": 0, | |
| "type": "M" | |
| } | |
| } | |
| class DiagnosticResult(BaseModel): | |
| """Diagnostic analysis result""" | |
| primary_cause: str | |
| sensor_alert: str | |
| recommended_action: str | |
| severity: str # LOW, MEDIUM, HIGH, CRITICAL | |
| class AnomalyDetail(BaseModel): | |
| """Anomaly detection detail""" | |
| parameter: str | |
| value: str | |
| normal_range: str | |
| status: str # NORMAL, WARNING, CRITICAL | |
| explanation: str | |
| class PredictionResponse(BaseModel): | |
| """Single prediction response""" | |
| machine_id: Optional[str] | |
| timestamp: str | |
| prediction: str # HEALTHY or FAILURE | |
| confidence: float | |
| diagnostics: DiagnosticResult | |
| features: Optional[Dict[str, Any]] = None # Engineered features | |
| anomalies: Optional[List[AnomalyDetail]] = None # Parameter anomaly analysis | |
| overall_health: Optional[str] = None # Overall health status | |
| # ============================================================================ | |
| # STARTUP EVENT: LOAD MODEL | |
| # ============================================================================ | |
| async def load_model(): | |
| """Download and load model pipeline on startup""" | |
| global MODEL_PIPELINE | |
| last_error: Optional[Exception] = None | |
| for candidate in [PRIMARY_MODEL_FILENAME, FALLBACK_MODEL_FILENAME]: | |
| if not candidate: | |
| continue | |
| try: | |
| model_path = download_model_artifact(candidate) | |
| MODEL_PIPELINE = joblib.load(model_path) | |
| logger.info("✅ Model loaded from %s", candidate) | |
| break | |
| except Exception as err: | |
| last_error = err | |
| logger.error("Failed to load model '%s': %s", candidate, err) | |
| if MODEL_PIPELINE is None: | |
| raise RuntimeError(f"Unable to load any model artifact: {last_error}") from last_error | |
| # Validate model structure | |
| required_keys = ['model', 'scaler', 'features'] | |
| for key in required_keys: | |
| if key not in MODEL_PIPELINE: | |
| raise ValueError(f"Model pipeline missing key: {key}") | |
| logger.info("Model type: %s", type(MODEL_PIPELINE['model']).__name__) | |
| logger.info("Features: %s", MODEL_PIPELINE['features']) | |
| # ============================================================================ | |
| # FEATURE ENGINEERING (Must match training logic) | |
| # ============================================================================ | |
| def engineer_features(data: Dict[str, Any]) -> pd.DataFrame: | |
| """ | |
| Apply physics-based feature engineering matching training pipeline | |
| Features: | |
| - Temperature_Diff: Thermal stress indicator | |
| - Power_W: Mechanical power (P = τω) | |
| - Type_Encoded: Categorical encoding | |
| - Tool_wear_hours: Tool wear converted to hours | |
| """ | |
| # Create base dataframe | |
| df = pd.DataFrame([{ | |
| 'Air_temp_K': data['air_temperature'], | |
| 'Process_temp_K': data['process_temperature'], | |
| 'Speed_rpm': data['rotational_speed'], | |
| 'Torque_Nm': data['torque'], | |
| 'Tool_wear_min': data['tool_wear'] | |
| }]) | |
| # Physics-based features | |
| df['Tool_wear_hours'] = df['Tool_wear_min'] / 60.0 # Convert minutes to hours | |
| df['Temperature_Diff'] = df['Process_temp_K'] - df['Air_temp_K'] | |
| df['Power_W'] = df['Torque_Nm'] * df['Speed_rpm'] * (2 * np.pi / 60) | |
| # Type encoding | |
| type_mapping = {'L': 0, 'M': 1, 'H': 2} | |
| df['Type_Encoded'] = type_mapping[data['type']] | |
| # Ensure correct feature order matching training | |
| feature_cols = MODEL_PIPELINE['features'] | |
| return df[feature_cols] | |
| # ============================================================================ | |
| # DIAGNOSTIC ENGINE (Rule-Based Intelligence) | |
| # ============================================================================ | |
| def analyze_condition( | |
| data: Dict[str, Any], | |
| pred_class: int, | |
| pred_proba: float, | |
| engineered_features: pd.DataFrame | |
| ) -> DiagnosticResult: | |
| """ | |
| Advanced diagnostic engine combining ML predictions with physics-based rules | |
| Priority Rules: | |
| 1. Tool Wear Failure (CRITICAL) | |
| 2. Power Overstrain (HIGH) | |
| 3. Heat Dissipation Issue (MEDIUM) | |
| 4. ML Anomaly Detection (VARIABLE) | |
| 5. Healthy Operation (LOW) | |
| """ | |
| # Extract values for rule evaluation | |
| temp_diff = engineered_features['Temperature_Diff'].iloc[0] | |
| power_w = engineered_features['Power_W'].iloc[0] | |
| torque = data['torque'] | |
| tool_wear = data['tool_wear'] | |
| speed = data['rotational_speed'] | |
| air_temp = data['air_temperature'] | |
| process_temp = data['process_temperature'] | |
| # ======================================================================== | |
| # RULE 1: TOOL WEAR FAILURE (CRITICAL PRIORITY) | |
| # ======================================================================== | |
| if tool_wear > 200: | |
| return DiagnosticResult( | |
| primary_cause="Tool End of Life", | |
| sensor_alert=f"Tool wear ({tool_wear} min) exceeds safety threshold (200 min)", | |
| recommended_action="IMMEDIATE ACTION: Replace cutting tool before catastrophic failure. " | |
| "Schedule downtime within 4 hours.", | |
| severity="CRITICAL" | |
| ) | |
| # ======================================================================== | |
| # RULE 2: POWER OVERSTRAIN (HIGH PRIORITY) | |
| # ======================================================================== | |
| if power_w > 9000 or torque > 60: | |
| cause_details = [] | |
| if power_w > 9000: | |
| cause_details.append(f"Power output ({power_w:.0f} W) exceeds design limit (9000 W)") | |
| if torque > 60: | |
| cause_details.append(f"Torque ({torque:.1f} Nm) exceeds safety limit (60 Nm)") | |
| return DiagnosticResult( | |
| primary_cause="Power Overstrain / Mechanical Overload", | |
| sensor_alert=" | ".join(cause_details), | |
| recommended_action="URGENT: Reduce operational load immediately. " | |
| "Inspect shaft alignment, bearing condition, and drive belt tension. " | |
| "Check for material jamming or obstruction.", | |
| severity="HIGH" | |
| ) | |
| # ======================================================================== | |
| # RULE 3: HEAT DISSIPATION ISSUE (MEDIUM PRIORITY) | |
| # ======================================================================== | |
| if temp_diff < 8.0 and speed > 1300: | |
| return DiagnosticResult( | |
| primary_cause="Inefficient Cooling System", | |
| sensor_alert=f"Temperature differential ({temp_diff:.1f} K) too low at high speed ({speed} RPM). " | |
| f"Expected ≥8.0 K for proper heat dissipation.", | |
| recommended_action="MAINTENANCE REQUIRED: Inspect cooling system within 24 hours. " | |
| "Check heat exchanger efficiency, coolant flow rate, and radiator fins. " | |
| "Verify coolant temperature and pressure.", | |
| severity="MEDIUM" | |
| ) | |
| # ======================================================================== | |
| # RULE 4: THERMAL STRESS (MEDIUM PRIORITY) | |
| # ======================================================================== | |
| if temp_diff > 15.0: | |
| return DiagnosticResult( | |
| primary_cause="Excessive Thermal Stress", | |
| sensor_alert=f"Temperature differential ({temp_diff:.1f} K) exceeds normal range (8-12 K). " | |
| f"Process temp: {process_temp:.1f} K, Air temp: {air_temp:.1f} K", | |
| recommended_action="MONITOR CLOSELY: High thermal gradient detected. " | |
| "Check process parameters and reduce processing intensity if possible. " | |
| "Verify insulation integrity and ambient conditions.", | |
| severity="MEDIUM" | |
| ) | |
| # ======================================================================== | |
| # RULE 5: HIGH-SPEED OPERATION RISK (MEDIUM PRIORITY) | |
| # ======================================================================== | |
| if speed > 2500: | |
| return DiagnosticResult( | |
| primary_cause="High-Speed Operation Risk", | |
| sensor_alert=f"Rotational speed ({speed} RPM) in critical range (>2500 RPM). " | |
| f"Vibration and wear accelerate exponentially.", | |
| recommended_action="PREVENTIVE ACTION: Monitor vibration levels closely. " | |
| "Perform balance check and bearing inspection. " | |
| "Consider reducing speed if not operationally critical.", | |
| severity="MEDIUM" | |
| ) | |
| # ======================================================================== | |
| # RULE 6: ML DETECTED ANOMALY (VARIABLE PRIORITY) | |
| # ======================================================================== | |
| if pred_class == 1: | |
| # ML model detected failure but no specific rule matched | |
| confidence_level = "high" if pred_proba > 0.8 else "moderate" | |
| return DiagnosticResult( | |
| primary_cause="ML-Detected Anomaly Pattern", | |
| sensor_alert=f"Machine learning model detected failure risk with {confidence_level} confidence ({pred_proba:.1%}). " | |
| f"No specific rule violation identified.", | |
| recommended_action="DIAGNOSTIC SCAN REQUIRED: Perform comprehensive machine diagnostic. " | |
| "Check for: (1) Unusual vibration patterns, (2) Bearing wear, " | |
| "(3) Lubrication quality, (4) Electrical anomalies, (5) Sensor calibration. " | |
| "Review recent maintenance history.", | |
| severity="HIGH" if pred_proba > 0.8 else "MEDIUM" | |
| ) | |
| # ======================================================================== | |
| # RULE 7: HEALTHY OPERATION (LOW PRIORITY) | |
| # ======================================================================== | |
| # Calculate health score | |
| health_indicators = { | |
| 'tool_wear_ok': tool_wear <= 150, | |
| 'power_ok': power_w <= 8000, | |
| 'temp_ok': 8.0 <= temp_diff <= 12.0, | |
| 'speed_ok': speed <= 2000, | |
| 'torque_ok': torque <= 50 | |
| } | |
| health_score = sum(health_indicators.values()) / len(health_indicators) * 100 | |
| return DiagnosticResult( | |
| primary_cause="Normal Operation", | |
| sensor_alert=f"All parameters within optimal range. Health score: {health_score:.0f}%. " | |
| f"Tool wear: {tool_wear}/200 min, Power: {power_w:.0f}/9000 W, " | |
| f"Temp diff: {temp_diff:.1f} K, Speed: {speed}/2500 RPM", | |
| recommended_action="CONTINUE NORMAL OPERATION. Next scheduled maintenance as planned. " | |
| "Continue routine monitoring.", | |
| severity="LOW" | |
| ) | |
| # ============================================================================ | |
| # ANOMALY DETECTION & HEALTH ASSESSMENT | |
| # ============================================================================ | |
| def detect_anomalies(data: Dict[str, Any], features_df: pd.DataFrame) -> List[AnomalyDetail]: | |
| """ | |
| Detect anomalies in sensor readings and engineered features | |
| Returns list of anomaly details for visualization | |
| """ | |
| anomalies = [] | |
| # Extract values | |
| air_temp = data['air_temperature'] | |
| process_temp = data['process_temperature'] | |
| speed = data['rotational_speed'] | |
| torque = data['torque'] | |
| tool_wear = data['tool_wear'] | |
| temp_diff = features_df['Temperature_Diff'].iloc[0] | |
| power_w = features_df['Power_W'].iloc[0] | |
| # Define normal ranges and check each parameter | |
| # 1. Air Temperature | |
| if air_temp < 290 or air_temp > 310: | |
| status = "CRITICAL" if air_temp < 285 or air_temp > 315 else "WARNING" | |
| anomalies.append(AnomalyDetail( | |
| parameter="Air Temperature", | |
| value=f"{air_temp:.1f} K", | |
| normal_range="290-310 K", | |
| status=status, | |
| explanation=f"Air temperature is {'too low' if air_temp < 290 else 'too high'}. This can affect cooling efficiency and equipment performance." | |
| )) | |
| # 2. Process Temperature | |
| if process_temp < 300 or process_temp > 315: | |
| status = "CRITICAL" if process_temp < 295 or process_temp > 320 else "WARNING" | |
| anomalies.append(AnomalyDetail( | |
| parameter="Process Temperature", | |
| value=f"{process_temp:.1f} K", | |
| normal_range="300-315 K", | |
| status=status, | |
| explanation=f"Process temperature is {'below optimal' if process_temp < 300 else 'exceeding optimal'} range. May indicate cooling system issues or excessive load." | |
| )) | |
| # 3. Temperature Differential | |
| if temp_diff < 8.0 or temp_diff > 12.0: | |
| status = "CRITICAL" if temp_diff < 5.0 or temp_diff > 15.0 else "WARNING" | |
| anomalies.append(AnomalyDetail( | |
| parameter="Temperature Differential", | |
| value=f"{temp_diff:.1f} K", | |
| normal_range="8.0-12.0 K", | |
| status=status, | |
| explanation=f"Temperature gradient is {'insufficient' if temp_diff < 8.0 else 'excessive'}. This indicates {'poor heat dissipation' if temp_diff < 8.0 else 'thermal stress'}." | |
| )) | |
| # 4. Rotational Speed | |
| if speed < 1200 or speed > 2000: | |
| status = "CRITICAL" if speed < 1000 or speed > 2500 else "WARNING" | |
| anomalies.append(AnomalyDetail( | |
| parameter="Rotational Speed", | |
| value=f"{speed} RPM", | |
| normal_range="1200-2000 RPM", | |
| status=status, | |
| explanation=f"Speed is {'below normal' if speed < 1200 else 'above normal'} operating range. This affects wear rate and vibration levels." | |
| )) | |
| # 5. Torque | |
| if torque > 50: | |
| status = "CRITICAL" if torque > 60 else "WARNING" | |
| anomalies.append(AnomalyDetail( | |
| parameter="Torque", | |
| value=f"{torque:.1f} Nm", | |
| normal_range="20-50 Nm", | |
| status=status, | |
| explanation=f"Torque is {'significantly ' if torque > 60 else ''}exceeding normal range. This indicates mechanical overload or obstruction." | |
| )) | |
| # 6. Tool Wear | |
| if tool_wear > 150: | |
| status = "CRITICAL" if tool_wear > 200 else "WARNING" | |
| anomalies.append(AnomalyDetail( | |
| parameter="Tool Wear", | |
| value=f"{tool_wear} min", | |
| normal_range="0-150 min", | |
| status=status, | |
| explanation=f"Tool wear is {'critically high' if tool_wear > 200 else 'elevated'}. {'IMMEDIATE replacement required' if tool_wear > 200 else 'Schedule replacement soon'}." | |
| )) | |
| # 7. Power Output | |
| if power_w > 8000: | |
| status = "CRITICAL" if power_w > 9000 else "WARNING" | |
| anomalies.append(AnomalyDetail( | |
| parameter="Power Output", | |
| value=f"{power_w:.0f} W", | |
| normal_range="3000-8000 W", | |
| status=status, | |
| explanation=f"Power consumption is {'critically ' if power_w > 9000 else ''}high. This suggests mechanical resistance or overload conditions." | |
| )) | |
| return anomalies | |
| def determine_overall_health(prediction: int, confidence: float, severity: str, anomaly_count: int) -> str: | |
| """ | |
| Determine overall machine health status based on multiple factors | |
| Returns: EXCELLENT, GOOD, FAIR, or POOR health status | |
| """ | |
| if prediction == 1: | |
| # Failure predicted | |
| if severity == "CRITICAL" or confidence > 0.9: | |
| return "🔴 POOR HEALTH - Critical failure risk detected. Immediate action required." | |
| elif severity == "HIGH" or confidence > 0.75: | |
| return "🟠 POOR HEALTH - High failure risk. Urgent maintenance needed." | |
| else: | |
| return "🟡 FAIR HEALTH - Moderate failure risk detected. Schedule maintenance soon." | |
| else: | |
| # No failure predicted | |
| if anomaly_count == 0: | |
| return "🟢 EXCELLENT HEALTH - All systems operating optimally within normal parameters." | |
| elif anomaly_count <= 2: | |
| return "🟢 GOOD HEALTH - Minor anomalies detected but within acceptable limits." | |
| else: | |
| return "🟡 FAIR HEALTH - Multiple anomalies detected. Monitor closely and address issues." | |
| # ============================================================================ | |
| # ENDPOINT 1: SINGLE PREDICTION | |
| # ============================================================================ | |
| async def predict_single(request: PredictionRequest): | |
| """ | |
| Predict failure risk for a single machine reading | |
| Returns: | |
| - Prediction (HEALTHY/FAILURE) | |
| - Confidence score | |
| - Detailed diagnostics with actionable recommendations | |
| """ | |
| try: | |
| # Convert request to dict | |
| data = request.dict() | |
| # Feature engineering | |
| features_df = engineer_features(data) | |
| # Scale features | |
| features_scaled = MODEL_PIPELINE['scaler'].transform(features_df) | |
| # Predict | |
| prediction = MODEL_PIPELINE['model'].predict(features_scaled)[0] | |
| prediction_proba = MODEL_PIPELINE['model'].predict_proba(features_scaled)[0] | |
| # Get confidence (probability of predicted class) | |
| confidence = float(prediction_proba[prediction]) | |
| # Run diagnostic engine | |
| diagnostics = analyze_condition(data, prediction, confidence, features_df) | |
| # Prepare features dict for display | |
| features_dict = features_df.iloc[0].to_dict() | |
| # Detect anomalies | |
| anomalies = detect_anomalies(data, features_df) | |
| # Determine overall health | |
| overall_health = determine_overall_health(prediction, confidence, diagnostics.severity, len(anomalies)) | |
| # Format response | |
| return PredictionResponse( | |
| machine_id=request.machine_id, | |
| timestamp=datetime.now().isoformat(), | |
| prediction="FAILURE" if prediction == 1 else "HEALTHY", | |
| confidence=round(confidence, 4), | |
| diagnostics=diagnostics, | |
| features=features_dict, | |
| anomalies=anomalies, | |
| overall_health=overall_health | |
| ) | |
| except Exception as e: | |
| logger.error(f"Prediction error: {e}") | |
| raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}") | |
| # ============================================================================ | |
| # ENDPOINT 2: BATCH PREDICTION (CSV UPLOAD) | |
| # ============================================================================ | |
| async def predict_batch(file: UploadFile = File(...)): | |
| """ | |
| Batch prediction from CSV upload | |
| Input: CSV file with columns matching PredictionRequest | |
| Output: CSV with added columns: Prediction, Probability, Primary_Cause, | |
| Sensor_Alert, Recommended_Action, Severity | |
| """ | |
| try: | |
| # Validate file type | |
| if not file.filename.endswith('.csv'): | |
| raise HTTPException(status_code=400, detail="File must be CSV format") | |
| # Read CSV | |
| contents = await file.read() | |
| df = pd.read_csv(io.StringIO(contents.decode('utf-8'))) | |
| # Normalize column names (handle case-insensitive, spaces, brackets, etc) | |
| df.columns = df.columns.str.strip().str.lower().str.replace(' ', '_').str.replace('[', '_').str.replace(']', '').str.replace('__', '_').str.rstrip('_') | |
| # Create column mapping for different formats | |
| column_mapping = { | |
| 'air_temperature_k': 'air_temperature', | |
| 'process_temperature_k': 'process_temperature', | |
| 'rotational_speed_rpm': 'rotational_speed', | |
| 'torque_nm': 'torque', | |
| 'tool_wear_min': 'tool_wear' | |
| } | |
| # Apply mapping if columns have units | |
| df.rename(columns=column_mapping, inplace=True) | |
| # Validate required columns | |
| required_columns = [ | |
| 'air_temperature', 'process_temperature', 'rotational_speed', | |
| 'torque', 'tool_wear', 'type' | |
| ] | |
| missing_cols = [col for col in required_columns if col not in df.columns] | |
| if missing_cols: | |
| raise HTTPException( | |
| status_code=400, | |
| detail=f"Missing required columns: {missing_cols}. Found columns: {list(df.columns)}" | |
| ) | |
| # Initialize result columns | |
| predictions = [] | |
| probabilities = [] | |
| causes = [] | |
| alerts = [] | |
| actions = [] | |
| severities = [] | |
| # Process each row | |
| for idx, row in df.iterrows(): | |
| try: | |
| # Prepare data | |
| data = { | |
| 'machine_id': row.get('machine_id', f'MACHINE_{idx}'), | |
| 'air_temperature': float(row['air_temperature']), | |
| 'process_temperature': float(row['process_temperature']), | |
| 'rotational_speed': int(row['rotational_speed']), | |
| 'torque': float(row['torque']), | |
| 'tool_wear': int(row['tool_wear']), | |
| 'type': str(row['type']) | |
| } | |
| # Feature engineering | |
| features_df = engineer_features(data) | |
| # Scale and predict | |
| features_scaled = MODEL_PIPELINE['scaler'].transform(features_df) | |
| prediction = MODEL_PIPELINE['model'].predict(features_scaled)[0] | |
| prediction_proba = MODEL_PIPELINE['model'].predict_proba(features_scaled)[0] | |
| confidence = float(prediction_proba[prediction]) | |
| # Diagnostics | |
| diagnostics = analyze_condition(data, prediction, confidence, features_df) | |
| # Append results | |
| predictions.append("FAILURE" if prediction == 1 else "HEALTHY") | |
| probabilities.append(round(confidence, 4)) | |
| causes.append(diagnostics.primary_cause) | |
| alerts.append(diagnostics.sensor_alert) | |
| actions.append(diagnostics.recommended_action) | |
| severities.append(diagnostics.severity) | |
| except Exception as e: | |
| logger.warning(f"Row {idx} processing error: {e}") | |
| predictions.append("ERROR") | |
| probabilities.append(0.0) | |
| causes.append("Processing Error") | |
| alerts.append(str(e)) | |
| actions.append("Review input data") | |
| severities.append("UNKNOWN") | |
| # Add results to dataframe | |
| df['Prediction'] = predictions | |
| df['Confidence'] = probabilities | |
| df['Primary_Cause'] = causes | |
| df['Sensor_Alert'] = alerts | |
| df['Recommended_Action'] = actions | |
| df['Severity'] = severities | |
| df['Processed_At'] = datetime.now().isoformat() | |
| # Convert to CSV | |
| output = io.StringIO() | |
| df.to_csv(output, index=False) | |
| output.seek(0) | |
| # Return as downloadable file | |
| return StreamingResponse( | |
| iter([output.getvalue()]), | |
| media_type="text/csv", | |
| headers={ | |
| "Content-Disposition": f"attachment; filename=predictions_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv" | |
| } | |
| ) | |
| except HTTPException: | |
| raise | |
| except Exception as e: | |
| logger.error(f"Batch prediction error: {e}") | |
| raise HTTPException(status_code=500, detail=f"Batch prediction failed: {str(e)}") | |
| # ============================================================================ | |
| # ENDPOINT 3: BATCH PREDICTION JSON (For UI Display) | |
| # ============================================================================ | |
| async def predict_batch_json(file: UploadFile = File(...)): | |
| """ | |
| Batch prediction from CSV upload - returns detailed JSON for UI display | |
| Input: CSV file with required columns | |
| Output: JSON with detailed predictions, features, and anomalies for each row | |
| """ | |
| try: | |
| # Validate file type | |
| if not file.filename.endswith('.csv'): | |
| raise HTTPException(status_code=400, detail="File must be CSV format") | |
| # Read CSV | |
| contents = await file.read() | |
| df = pd.read_csv(io.StringIO(contents.decode('utf-8'))) | |
| # Normalize column names | |
| df.columns = df.columns.str.strip().str.lower().str.replace(' ', '_') | |
| # Validate required columns | |
| required_columns = [ | |
| 'air_temperature', 'process_temperature', 'rotational_speed', | |
| 'torque', 'tool_wear', 'type' | |
| ] | |
| missing_cols = [col for col in required_columns if col not in df.columns] | |
| if missing_cols: | |
| raise HTTPException( | |
| status_code=400, | |
| detail=f"Missing required columns: {missing_cols}. Found columns: {list(df.columns)}" | |
| ) | |
| # Limit batch size for JSON response (increased for better UX) | |
| if len(df) > 1000: | |
| raise HTTPException( | |
| status_code=400, | |
| detail=f"Batch JSON endpoint limited to 500 rows. Your file has {len(df)} rows. Use /predict/batch for larger files or download CSV results." | |
| ) | |
| results = [] | |
| # Process each row | |
| for idx, row in df.iterrows(): | |
| try: | |
| # Prepare data | |
| data = { | |
| 'machine_id': row.get('machine_id', f'MACHINE_{idx+1}'), | |
| 'air_temperature': float(row['air_temperature']), | |
| 'process_temperature': float(row['process_temperature']), | |
| 'rotational_speed': int(row['rotational_speed']), | |
| 'torque': float(row['torque']), | |
| 'tool_wear': int(row['tool_wear']), | |
| 'type': str(row['type']).strip().upper() | |
| } | |
| # Feature engineering | |
| features_df = engineer_features(data) | |
| # Scale and predict | |
| features_scaled = MODEL_PIPELINE['scaler'].transform(features_df) | |
| prediction = MODEL_PIPELINE['model'].predict(features_scaled)[0] | |
| prediction_proba = MODEL_PIPELINE['model'].predict_proba(features_scaled)[0] | |
| confidence = float(prediction_proba[prediction]) | |
| # Diagnostics | |
| diagnostics = analyze_condition(data, prediction, confidence, features_df) | |
| # Features dict | |
| features_dict = features_df.iloc[0].to_dict() | |
| # Detect anomalies | |
| anomalies = detect_anomalies(data, features_df) | |
| # Overall health | |
| overall_health = determine_overall_health(prediction, confidence, diagnostics.severity, len(anomalies)) | |
| # Append result | |
| results.append({ | |
| "row_number": idx + 1, | |
| "machine_id": data['machine_id'], | |
| "timestamp": datetime.now().isoformat(), | |
| "prediction": "FAILURE" if prediction == 1 else "HEALTHY", | |
| "confidence": round(confidence, 4), | |
| "diagnostics": { | |
| "primary_cause": diagnostics.primary_cause, | |
| "sensor_alert": diagnostics.sensor_alert, | |
| "recommended_action": diagnostics.recommended_action, | |
| "severity": diagnostics.severity | |
| }, | |
| "features": features_dict, | |
| "anomalies": [ | |
| { | |
| "parameter": a.parameter, | |
| "value": a.value, | |
| "normal_range": a.normal_range, | |
| "status": a.status, | |
| "explanation": a.explanation | |
| } for a in anomalies | |
| ], | |
| "overall_health": overall_health, | |
| "input_data": { | |
| "air_temperature": data['air_temperature'], | |
| "process_temperature": data['process_temperature'], | |
| "rotational_speed": data['rotational_speed'], | |
| "torque": data['torque'], | |
| "tool_wear": data['tool_wear'], | |
| "type": data['type'] | |
| } | |
| }) | |
| except Exception as e: | |
| logger.warning(f"Row {idx+1} processing error: {e}") | |
| results.append({ | |
| "row_number": idx + 1, | |
| "machine_id": row.get('machine_id', f'MACHINE_{idx+1}'), | |
| "timestamp": datetime.now().isoformat(), | |
| "prediction": "ERROR", | |
| "confidence": 0.0, | |
| "diagnostics": { | |
| "primary_cause": "Processing Error", | |
| "sensor_alert": str(e), | |
| "recommended_action": "Review input data format and values", | |
| "severity": "UNKNOWN" | |
| }, | |
| "error": str(e) | |
| }) | |
| # Summary statistics | |
| total = len(results) | |
| failures = sum(1 for r in results if r.get('prediction') == 'FAILURE') | |
| healthy = sum(1 for r in results if r.get('prediction') == 'HEALTHY') | |
| errors = sum(1 for r in results if r.get('prediction') == 'ERROR') | |
| return { | |
| "summary": { | |
| "total_records": total, | |
| "predictions": { | |
| "failure": failures, | |
| "healthy": healthy, | |
| "errors": errors | |
| }, | |
| "failure_rate": round(failures / total * 100, 2) if total > 0 else 0 | |
| }, | |
| "results": results, | |
| "processed_at": datetime.now().isoformat() | |
| } | |
| except HTTPException: | |
| raise | |
| except Exception as e: | |
| logger.error(f"Batch JSON prediction error: {e}") | |
| raise HTTPException(status_code=500, detail=f"Batch processing failed: {str(e)}") | |
| # ============================================================================ | |
| # HEALTH CHECK ENDPOINTS | |
| # ============================================================================ | |
| async def root(): | |
| """API root endpoint""" | |
| return { | |
| "service": "Predictive Maintenance API", | |
| "version": "1.0.0", | |
| "status": "operational", | |
| "model_loaded": MODEL_PIPELINE is not None, | |
| "endpoints": { | |
| "single_prediction": "/predict", | |
| "batch_prediction": "/predict/batch", | |
| "health": "/health", | |
| "model_info": "/model/info" | |
| } | |
| } | |
| async def health_check(): | |
| """Health check endpoint""" | |
| return { | |
| "status": "healthy" if MODEL_PIPELINE is not None else "unhealthy", | |
| "timestamp": datetime.now().isoformat(), | |
| "model_loaded": MODEL_PIPELINE is not None, | |
| "model_repo": HF_MODEL_REPO | |
| } | |
| async def model_info(): | |
| """Get model information""" | |
| if MODEL_PIPELINE is None: | |
| raise HTTPException(status_code=503, detail="Model not loaded") | |
| return { | |
| "model_type": type(MODEL_PIPELINE['model']).__name__, | |
| "features": MODEL_PIPELINE['features'], | |
| "model_name": MODEL_PIPELINE.get('model_name', 'Unknown'), | |
| "performance": MODEL_PIPELINE.get('performance', {}), | |
| "training_config": MODEL_PIPELINE.get('training_config', {}), | |
| "random_state": MODEL_PIPELINE.get('random_state', None) | |
| } | |
| # ============================================================================ | |
| # MAIN | |
| # ============================================================================ | |
| if __name__ == "__main__": | |
| import uvicorn | |
| uvicorn.run( | |
| "main:app", | |
| host="0.0.0.0", | |
| port=8000, | |
| reload=True, | |
| log_level="info" | |
| ) | |