Update app.py

app.py

@@ -1,241 +1,813 @@
-from fastapi import FastAPI, HTTPException, Request, Depends
-from fastapi.responses import JSONResponse
+# ==============================================================================
+# APLICAȚIA FASTAPI CU SISTEM DE INCERTITUDINE INTEGRATĂ
+# ==============================================================================
+# Această aplicație înlocuiește sistemul simplu de predicție cu un framework
+# avansat de cuantificare a incertitudinii, oferind inginierilor nu doar predicții
+# ci și intervale de încredere calibrate pentru luarea deciziilor informate
+
+from fastapi import FastAPI, HTTPException, Request, Depends, Query
+from fastapi.responses import JSONResponse, HTMLResponse
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
 import pandas as pd
 import joblib
 import numpy as np
 import os
 import time
-from sklearn.ensemble import RandomForestRegressor  # Important for model deserialization
+import pickle
+from datetime import datetime
+from sklearn.ensemble import RandomForestRegressor  # Necesar pentru deserializare
 from pydantic import BaseModel, ValidationError, Field, field_validator, model_validator
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
+from scipy import stats
+import json
+
+# ==============================================================================
+# CONFIGURAȚIA APLICAȚIEI FASTAPI
+# ==============================================================================
 
-# Create FastAPI application
 app = FastAPI(
-    title="Soil UCS Prediction API",
-    description="API for predicting the unconfined compressive strength (UCS) of cement-stabilized soils",
-    version="1.0.0"
+    title="UCS Prediction API with Uncertainty Quantification",
+    description="""
+    **API avansat pentru predicția rezistenței la compresiune simplă (UCS) a solurilor stabilizate cu cement**
+    
+    Această aplicație implementează sistemul de cuantificare a incertitudinii dezvoltat în cercetarea
+    "Prediction of Unconfined Compressive Strength in Cement-Treated Soil: A Machine Learning Approach".
+    
+    **Caracteristici principale:**
+    - Predicții precise ale UCS folosind Random Forest optimizat
+    - Cuantificare completă a incertitudinii cu intervale de încredere calibrate
+    - Analiză de sensibilitate pentru optimizarea parametrilor
+    - Interpretabilitate prin analiza importanței features-urilor
+    
+    **Dezvoltat de:** Echipa de cercetare - Universitatea Tehnică Gheorghe Asachi din Iași
+    """,
+    version="2.0.0",
+    contact={
+        "name": "Echipa de Dezvoltare UCS",
+        "email": "iancu-bogdan.teodoru@academic.tuiasi.ro",
+    }
 )
 
-# Add CORS middleware to allow requests only from your interface server
+# Configurarea CORS pentru interfața web
 app.add_middleware(
     CORSMiddleware,
     allow_origins=[
-        "http://www.bi4e-at.tuiasi.ro/ucs-prediction/",
-        "https://www.bi4e-at.tuiasi.ro/ucs-prediction/"
+        "http://www.bi4e-at.tuiasi.ro",
+        "https://www.bi4e-at.tuiasi.ro",
+        "http://localhost:3000",  # Pentru dezvoltarea locală
+        "http://localhost:8000"   # Pentru testarea locală
     ],
     allow_credentials=True,
-    allow_methods=["GET", "POST"],  # Restrict to only necessary methods
+    allow_methods=["GET", "POST", "OPTIONS"],
     allow_headers=["*"],
 )
 
-# Global variables
-MODEL_PATH = 'rf_model_optim.joblib'  # Path to the model
-DEFAULT_FEATURE_ORDER = ['cement_perecent', 'curing_period', 'compaction_rate']  # Default feature order
+# ==============================================================================
+# CONFIGURAȚIA MODELELOR ȘI ÎNCĂRCAREA SISTEMULUI
+# ==============================================================================
 
-# Load the model
-try:
+# Căile către modelele serializate
+MODELS_DIR = "./models_for_deployment"
+PRIMARY_MODEL_PATH = os.path.join(MODELS_DIR, "rf_primary_model.joblib")
+UNCERTAINTY_MODEL_PATH = os.path.join(MODELS_DIR, "rf_uncertainty_model.joblib")
+METADATA_PATH = os.path.join(MODELS_DIR, "system_metadata.pkl")
+
+# Ordinea features-urilor (critică pentru compatibilitate)
+DEFAULT_FEATURE_ORDER = ['cement_perecent', 'curing_period', 'compaction_rate']
+
+# Variabile globale pentru sistem
+primary_model = None
+uncertainty_model = None
+system_metadata = None
+FEATURE_ORDER = None
+
+def load_uncertainty_system():
+    """
+    Încarcă și validează întregul sistem de incertitudine.
+    
+    Această funcție orchestrează încărcarea tuturor componentelor sistemului
+    și efectuează validări de bază pentru a asigura funcționarea corectă.
+    Procesul este proiectat să fie robust și să ofere informații detaliate
+    despre orice probleme întâlnite în timpul încărcării.
+    """
+    global primary_model, uncertainty_model, system_metadata, FEATURE_ORDER
+    
+    print("🚀 Încărcarea sistemului de incertitudine...")
     start_time = time.time()
-    model = joblib.load(MODEL_PATH)
     
-    # Determine feature order from model or use default
-    if hasattr(model, 'feature_names_in_'):
-        FEATURE_ORDER = model.feature_names_in_
-    else:
-        FEATURE_ORDER = np.array(DEFAULT_FEATURE_ORDER)
-    
-    load_time = time.time() - start_time
-    print(f"Model loaded successfully in {load_time:.2f} seconds! Feature Order: {FEATURE_ORDER}")
-except Exception as e:
-    import traceback
-    print(f"Error loading model: {str(e)}")
-    print(traceback.format_exc())
-    model = None
-    FEATURE_ORDER = np.array(DEFAULT_FEATURE_ORDER)
-
-# Input data model definition
+    try:
+        # Încărcăm modelul principal
+        if os.path.exists(PRIMARY_MODEL_PATH):
+            primary_model = joblib.load(PRIMARY_MODEL_PATH)
+            print(f"✅ Model principal încărcat: {type(primary_model).__name__}")
+        else:
+            raise FileNotFoundError(f"Modelul principal nu a fost găsit la: {PRIMARY_MODEL_PATH}")
+        
+        # Încărcăm modelul de incertitudine
+        if os.path.exists(UNCERTAINTY_MODEL_PATH):
+            uncertainty_model = joblib.load(UNCERTAINTY_MODEL_PATH)
+            print(f"✅ Model incertitudine încărcat: {type(uncertainty_model).__name__}")
+        else:
+            raise FileNotFoundError(f"Modelul de incertitudine nu a fost găsit la: {UNCERTAINTY_MODEL_PATH}")
+        
+        # Încărcăm metadata-ul sistemului
+        if os.path.exists(METADATA_PATH):
+            with open(METADATA_PATH, 'rb') as f:
+                system_metadata = pickle.load(f)
+            print(f"✅ Metadata sistem încărcată: {len(system_metadata)} chei")
+        else:
+            print("⚠️ Metadata-ul sistemului nu a fost găsit, se folosesc valorile default")
+            system_metadata = {"feature_names": DEFAULT_FEATURE_ORDER}
+        
+        # Determinăm ordinea features-urilor
+        if hasattr(primary_model, 'feature_names_in_'):
+            FEATURE_ORDER = primary_model.feature_names_in_
+        elif system_metadata and 'feature_names' in system_metadata:
+            FEATURE_ORDER = np.array(system_metadata['feature_names'])
+        else:
+            FEATURE_ORDER = np.array(DEFAULT_FEATURE_ORDER)
+        
+        # Validăm compatibilitatea modelelor
+        validation_result = validate_models_compatibility()
+        if not validation_result:
+            raise ValueError("Modelele nu sunt compatibile între ele")
+        
+        load_time = time.time() - start_time
+        print(f"🎉 Sistem de incertitudine încărcat cu succes în {load_time:.2f} secunde!")
+        print(f"📊 Features: {FEATURE_ORDER.tolist()}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Eroare la încărcarea sistemului: {str(e)}")
+        import traceback
+        print(traceback.format_exc())
+        return False
+
+def validate_models_compatibility():
+    """
+    Validează că modelele sunt compatibile și funcționează împreună.
+    
+    Această validare include teste de compatibilitate dimensională,
+    verificarea tipurilor de date și un test funcțional complet.
+    """
+    try:
+        # Test cu date sintetice
+        test_input = np.array([[5.0, 14.0, 1.0]])  # cement, curing, compaction
+        
+        # Testăm modelul principal
+        primary_pred = primary_model.predict(test_input)[0]
+        
+        # Testăm modelul de incertitudine cu feature augmentation
+        uncertainty_input = np.column_stack([test_input, [[primary_pred]]])
+        uncertainty_pred = uncertainty_model.predict(uncertainty_input)[0]
+        
+        # Verificăm că rezultatele sunt numerice și rezonabile
+        assert isinstance(primary_pred, (int, float, np.number))
+        assert isinstance(uncertainty_pred, (int, float, np.number))
+        assert primary_pred > 0
+        assert uncertainty_pred > 0
+        
+        print(f"✅ Test compatibilitate: UCS={primary_pred:.1f} kPa, σ={uncertainty_pred:.1f} kPa")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Test compatibilitate eșuat: {str(e)}")
+        return False
+
+# Încărcăm sistemul la pornirea aplicației
+system_loaded = load_uncertainty_system()
+
+# ==============================================================================
+# MODELELE PYDANTIC PENTRU INPUT ȘI OUTPUT
+# ==============================================================================
+
 class SoilInput(BaseModel):
+    """
+    Modelul pentru datele de input ale solului.
+    
+    Această clasă definește și validează parametrii de intrare,
+    asigurându-se că valorile sunt în intervalele experimentale validate.
+    """
     cement_perecent: float = Field(
         ..., 
-        description="Cement percentage in the mixture (0-15%)"
+        description="Procentajul de cement în amestec",
+        ge=0, le=15,
+        example=5.0
     )
     curing_period: float = Field(
         ...,
-        description="Curing period in days (1-90 days)"
+        description="Perioada de maturare în zile",
+        ge=0, le=90,
+        example=28.0
     )
     compaction_rate: float = Field(
         ...,
-        description="Compaction rate in mm/min (0.5-2.0 mm/min)"
+        description="Rata de compactare în mm/min",
+        ge=0.5, le=2.0,
+        example=1.0
     )
 
     @model_validator(mode="after")
-    def check_cement_and_curing(self):
+    def validate_cement_curing_relationship(self):
+        """
+        Validează relația dintre conținutul de cement și perioada de maturare.
+        
+        Pentru solul netratat (0% cement), perioada de maturare este forțată la 0
+        deoarece nu există proces de hidratare a cimentului.
+        """
         if self.cement_perecent == 0:
             self.curing_period = 0
-        else:
-            if not (1 <= self.curing_period <= 90):
-                raise ValueError("Curing period must be between 1 and 90 days")
+        elif self.cement_perecent > 0 and self.curing_period < 1:
+            raise ValueError("Pentru sol tratat cu cement, perioada de maturare trebuie să fie ≥ 1 zi")
         return self
 
-    @field_validator('cement_perecent')
-    @classmethod
-    def validate_cement(cls, v: float) -> float:
-        if not 0 <= v <= 15:
-            raise ValueError("Cement percentage must be between 0% and 15%")
-        return v
-
-    @field_validator('compaction_rate')
-    @classmethod
-    def validate_compaction(cls, v: float) -> float:
-        if not 0.5 <= v <= 2:
-            raise ValueError("Compaction rate must be between 0.5 and 2 mm/min")
-        return v
-    
     class Config:
-        schema_extra = {
+        json_schema_extra = {
             "example": {
-                "cement_perecent": 5,
-                "curing_period": 28,
+                "cement_perecent": 5.0,
+                "curing_period": 28.0,
                 "compaction_rate": 1.0
             }
         }
 
-# Prediction response model
-class PredictionResponse(BaseModel):
-    success: bool
-    prediction: float
-    units: str
-    input_parameters: Dict[str, float]
-    prediction_time_ms: Optional[float] = None
-
-# Function to check if model is loaded
-async def get_model():
-    if model is None:
+class ConfidenceInterval(BaseModel):
+    """Modelul pentru un interval de încredere."""
+    lower: float = Field(..., description="Limita inferioară a intervalului")
+    upper: float = Field(..., description="Limita superioară a intervalului")
+    width: float = Field(..., description="Lățimea intervalului")
+
+class UncertaintyPredictionResponse(BaseModel):
+    """
+    Răspunsul complet cu cuantificare de incertitudine.
+    
+    Această structură extinsă oferă inginerului o imagine completă
+    a predicției, incluzând nu doar valoarea estimată ci și încrederea
+    în acea estimare prin intervale calibrate.
+    """
+    success: bool = Field(..., description="Statusul procesării cererii")
+    
+    # Predicția centrală
+    central_prediction: float = Field(..., description="Predicția UCS cea mai probabilă")
+    units: str = Field(default="kPa", description="Unitățile de măsură")
+    
+    # Informații despre incertitudine
+    uncertainty_estimate: float = Field(..., description="Estimarea incertitudinii absolute (1-sigma)")
+    relative_uncertainty: float = Field(..., description="Incertitudinea relativă ca procent")
+    
+    # Intervale de încredere
+    confidence_intervals: Dict[str, ConfidenceInterval] = Field(
+        ..., 
+        description="Intervale de încredere pentru multiple nivele de probabilitate"
+    )
+    
+    # Interpretarea pentru utilizator
+    interpretation: Dict[str, str] = Field(..., description="Ghid de interpretare pentru rezultate")
+    
+    # Metadata
+    input_parameters: Dict[str, float] = Field(..., description="Parametrii de intrare folosiți")
+    prediction_time_ms: Optional[float] = Field(None, description="Timpul de procesare în milisecunde")
+    model_info: Optional[Dict[str, Any]] = Field(None, description="Informații despre modelele folosite")
+
+class SensitivityAnalysisRequest(BaseModel):
+    """Cererea pentru analiza de sensibilitate."""
+    base_parameters: SoilInput
+    parameter_to_vary: str = Field(..., regex="^(cement_perecent|curing_period|compaction_rate)$")
+    variation_range: float = Field(default=10.0, ge=1.0, le=50.0, description="Intervalul de variație în procente")
+    num_points: int = Field(default=11, ge=5, le=21, description="Numărul de puncte pentru analiză")
+
+# ==============================================================================
+# FUNCȚIILE CORE PENTRU PREDICȚIA CU INCERTITUDINE
+# ==============================================================================
+
+def predict_with_uncertainty(input_data: np.ndarray, 
+                            confidence_levels: List[float] = [0.68, 0.80, 0.90, 0.95]) -> Dict[str, Any]:
+    """
+    Realizează predicția completă cu cuantificare de incertitudine.
+    
+    Această funcție implementează algoritmul în două etape dezvoltat în cercetare:
+    1. Modelul principal generează predicția centrală UCS
+    2. Modelul de incertitudine estimează magnitudinea erorii probabile
+    3. Se construiesc intervale de încredere presupunând distribuție normală
+    
+    Args:
+        input_data: Array numpy cu features-urile [cement%, curing_days, compaction_rate]
+        confidence_levels: Lista nivelelor de încredere pentru care să calculăm intervale
+    
+    Returns:
+        Dicționar cu predicția centrală, estimarea incertitudinii și intervalele de încredere
+    """
+    
+    # Etapa 1: Predicția centrală cu modelul principal
+    central_prediction = primary_model.predict(input_data)[0]
+    
+    # Etapa 2: Pregătirea input-ului pentru modelul de incertitudine
+    # Modelul de incertitudine folosește feature augmentation:
+    # features originale + predicția centrală
+    uncertainty_input = np.column_stack([input_data, [[central_prediction]]])
+    
+    # Etapa 3: Predicția incertitudinii (magnitudinea erorii așteptate)
+    uncertainty_estimate = uncertainty_model.predict(uncertainty_input)[0]
+    
+    # Etapa 4: Calcularea intervalelor de încredere
+    confidence_intervals = {}
+    
+    for conf_level in confidence_levels:
+        # Z-score corespunzător nivelului de încredere
+        # Pentru distribuția normală: 68% → z≈1.0, 90% → z≈1.645, 95% → z≈1.96
+        z_score = stats.norm.ppf((1 + conf_level) / 2)
+        
+        # Marginea de eroare = z-score × estimarea incertitudinii
+        margin = z_score * uncertainty_estimate
+        
+        confidence_intervals[f'{conf_level:.0%}'] = ConfidenceInterval(
+            lower=float(central_prediction - margin),
+            upper=float(central_prediction + margin),
+            width=float(2 * margin)
+        )
+    
+    # Calcularea incertitudinii relative
+    relative_uncertainty = (uncertainty_estimate / central_prediction) * 100 if central_prediction != 0 else 0
+    
+    return {
+        'central_prediction': float(central_prediction),
+        'uncertainty_estimate': float(uncertainty_estimate),
+        'relative_uncertainty': float(relative_uncertainty),
+        'confidence_intervals': confidence_intervals
+    }
+
+def generate_interpretation_guide(central_prediction: float, uncertainty_estimate: float, 
+                                confidence_intervals: Dict[str, ConfidenceInterval]) -> Dict[str, str]:
+    """
+    Generează un ghid de interpretare personalizat pentru rezultatele predicției.
+    
+    Această funcție traduce rezultatele statistice în limbaj practic pentru ingineri,
+    oferind contextul necesar pentru luarea deciziilor informate în proiecte.
+    """
+    
+    # Calculăm intervalul 95% pentru interpretare
+    interval_95 = confidence_intervals.get('95%')
+    
+    # Clasificarea încrederii bazată pe incertitudinea relativă
+    relative_unc = (uncertainty_estimate / central_prediction) * 100
+    
+    if relative_unc <= 10:
+        confidence_level = "foarte mare"
+        reliability_desc = "Predicția este foarte fiabilă pentru luarea deciziilor de proiectare."
+    elif relative_unc <= 20:
+        confidence_level = "mare"
+        reliability_desc = "Predicția este fiabilă, recomandăm validare prin teste limitate."
+    elif relative_unc <= 30:
+        confidence_level = "moderată"
+        reliability_desc = "Predicția oferă o estimare utilă, dar se recomandă testare suplimentară."
+    else:
+        confidence_level = "limitată"
+        reliability_desc = "Predicția este indicativă, se recomandă testare extinsă pentru validare."
+    
+    interpretation = {
+        "central_prediction": f"Valoarea UCS cea mai probabilă este {central_prediction:.0f} kPa, bazată pe parametrii introduși.",
+        
+        "uncertainty": f"Incertitudinea estimată este ±{uncertainty_estimate:.0f} kPa ({relative_unc:.1f}%), "
+                      f"indicând o încredere {confidence_level} în predicție.",
+        
+        "confidence_95": f"Avem 95% încredere că valoarea reală UCS se află între "
+                        f"{interval_95.lower:.0f} și {interval_95.upper:.0f} kPa." if interval_95 else "",
+        
+        "reliability": reliability_desc,
+        
+        "practical_guidance": f"Pentru aplicații cu cerințe UCS > {central_prediction + uncertainty_estimate:.0f} kPa, "
+                             f"considerați mărirea conținutului de cement sau extinderea perioadei de maturare."
+    }
+    
+    return interpretation
+
+async def validate_models_loaded():
+    """Dependency function pentru validarea încărcării modelelor."""
+    if not system_loaded or primary_model is None or uncertainty_model is None:
         raise HTTPException(
             status_code=503,
-            detail="Model was not loaded correctly. Please try again later."
+            detail="Sistemul de modele nu este încărcat corect. Contactați administratorul."
         )
-    return model
+    return True
+
+# ==============================================================================
+# ENDPOINT-URILE API
+# ==============================================================================
 
-# Prediction endpoint
-@app.post("/predict", response_model=PredictionResponse, summary="UCS Prediction")
-async def predict(soil_data: SoilInput, model=Depends(get_model)):
+@app.get("/", response_class=HTMLResponse, summary="Pagina principală")
+async def root():
     """
-    Predicts the UCS (unconfined compressive strength) of soil.
+    Returnează pagina principală cu informații despre API.
+    """
+    return """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>UCS Prediction API</title>
+        <style>
+            body { font-family: Arial, sans-serif; margin: 40px; }
+            .header { color: #2c3e50; }
+            .endpoint { background: #f8f9fa; padding: 15px; margin: 10px 0; border-left: 4px solid #007bff; }
+        </style>
+    </head>
+    <body>
+        <h1 class="header">🏗️ UCS Prediction API with Uncertainty Quantification</h1>
+        <p>API avansat pentru predicția rezistenței la compresiune simplă a solurilor stabilizate cu cement.</p>
+        
+        <h2>📋 Endpoint-uri disponibile:</h2>
+        <div class="endpoint">
+            <strong>POST /predict</strong> - Predicție UCS cu cuantificare de incertitudine
+        </div>
+        <div class="endpoint">
+            <strong>POST /sensitivity-analysis</strong> - Analiza sensibilității parametrilor
+        </div>
+        <div class="endpoint">
+            <strong>GET /status</strong> - Statusul sistemului
+        </div>
+        <div class="endpoint">
+            <strong>GET /model-info</strong> - Informații detaliate despre modele
+        </div>
+        
+        <h2>📖 Documentație:</h2>
+        <p><a href="/docs">Swagger UI - Documentație interactivă</a></p>
+        <p><a href="/redoc">ReDoc - Documentație alternativă</a></p>
+        
+        <footer style="margin-top: 40px; color: #666;">
+            <p>Dezvoltat de echipa de cercetare - Universitatea Tehnică Gheorghe Asachi din Iași</p>
+        </footer>
+    </body>
+    </html>
+    """
+
+@app.post("/predict", response_model=UncertaintyPredictionResponse, 
+          summary="Predicție UCS cu Cuantificare de Incertitudine")
+async def predict_ucs_with_uncertainty(
+    soil_data: SoilInput, 
+    include_model_info: bool = Query(False, description="Include informații detaliate despre modele"),
+    _: bool = Depends(validate_models_loaded)
+):
+    """
+    **Realizează predicția UCS cu cuantificare completă a incertitudinii.**
+    
+    Acest endpoint implementează sistemul avansat de incertitudine dezvoltat în cercetarea noastră,
+    oferind nu doar predicția centrală ci și intervale de încredere calibrate la multiple nivele.
+    
+    **Parametrii de intrare:**
+    - **cement_perecent**: Conținutul de cement (0-15%)
+    - **curing_period**: Perioada de maturare (0-90 zile)  
+    - **compaction_rate**: Rata de compactare (0.5-2.0 mm/min)
     
-    - **cement_perecent**: Cement percentage in the mixture (0-15%)
-    - **curing_period**: Curing period in days (1-90 days)
-    - **compaction_rate**: Compaction rate in mm/min (0.5-2 mm/min)
+    **Rezultatele includ:**
+    - Predicția centrală UCS în kPa
+    - Estimarea incertitudinii absolute și relative
+    - Intervale de încredere la 68%, 80%, 90% și 95%
+    - Ghid de interpretare personalizat pentru rezultate
     
-    Returns the UCS strength in kPa.
+    **Utilizare tipică:**
+    ```json
+    {
+        "cement_perecent": 7.5,
+        "curing_period": 28,
+        "compaction_rate": 1.0
+    }
+    ```
     """
+    
     try:
         start_time = time.time()
         
-        # Build DataFrame for prediction
+        # Pregătirea datelor de input în formatul așteptat de model
         input_data = soil_data.dict()
         input_df = pd.DataFrame([input_data])
         
-        # Ensure correct feature order
+        # Asigurarea ordinii corecte a features-urilor
         prediction_df = pd.DataFrame()
         for feature in FEATURE_ORDER:
             if feature in input_df.columns:
                 prediction_df[feature] = input_df[feature]
             else:
-                raise ValueError(f"Feature '{feature}' is missing from input data")
+                raise ValueError(f"Feature-ul '{feature}' lipsește din datele de intrare")
+        
+        # Convertirea la numpy array pentru modelele scikit-learn
+        input_array = prediction_df.values
+        
+        # Realizarea predicției cu incertitudine
+        prediction_result = predict_with_uncertainty(input_array)
+        
+        # Generarea ghidului de interpretare
+        interpretation = generate_interpretation_guide(
+            prediction_result['central_prediction'],
+            prediction_result['uncertainty_estimate'],
+            prediction_result['confidence_intervals']
+        )
+        
+        # Informații opționale despre modele
+        model_info = None
+        if include_model_info:
+            model_info = {
+                "primary_model": type(primary_model).__name__,
+                "uncertainty_model": type(uncertainty_model).__name__,
+                "feature_order": FEATURE_ORDER.tolist(),
+                "system_metadata": system_metadata if system_metadata else "Not available"
+            }
         
-        # Make prediction
-        prediction = model.predict(prediction_df)
+        # Calcularea timpului de procesare
+        processing_time = (time.time() - start_time) * 1000
         
-        # Calculate prediction time
-        prediction_time_ms = (time.time() - start_time) * 1000
+        # Construirea răspunsului complet
+        return UncertaintyPredictionResponse(
+            success=True,
+            central_prediction=prediction_result['central_prediction'],
+            units="kPa",
+            uncertainty_estimate=prediction_result['uncertainty_estimate'],
+            relative_uncertainty=prediction_result['relative_uncertainty'],
+            confidence_intervals=prediction_result['confidence_intervals'],
+            interpretation=interpretation,
+            input_parameters=input_data,
+            prediction_time_ms=processing_time,
+            model_info=model_info
+        )
+        
+    except ValueError as ve:
+        raise HTTPException(status_code=400, detail=f"Eroare de validare: {str(ve)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Eroare de procesare: {str(e)}")
+
+@app.post("/sensitivity-analysis", summary="Analiza Sensibilității Parametrilor")
+async def perform_sensitivity_analysis(
+    request: SensitivityAnalysisRequest,
+    _: bool = Depends(validate_models_loaded)
+):
+    """
+    **Efectuează analiza sensibilității pentru un parametru specific.**
+    
+    Această analiză arată cum variația unui parametru de intrare afectează
+    atât predicția centrală cât și incertitudinea asociată, oferind insight-uri
+    valoroase pentru optimizarea mix design-ului.
+    """
+    
+    try:
+        base_params = request.base_parameters.dict()
+        param_to_vary = request.parameter_to_vary
+        variation_range = request.variation_range / 100  # Convertim din procente
+        num_points = request.num_points
+        
+        # Valorile de bază
+        base_value = base_params[param_to_vary]
+        
+        # Calculăm intervalul de variație
+        min_variation = base_value * (1 - variation_range)
+        max_variation = base_value * (1 + variation_range)
+        
+        # Respectăm limitele fizice ale parametrilor
+        if param_to_vary == "cement_perecent":
+            min_variation = max(0, min_variation)
+            max_variation = min(15, max_variation)
+        elif param_to_vary == "curing_period":
+            min_variation = max(0 if base_params["cement_perecent"] == 0 else 1, min_variation)
+            max_variation = min(90, max_variation)
+        elif param_to_vary == "compaction_rate":
+            min_variation = max(0.5, min_variation)
+            max_variation = min(2.0, max_variation)
+        
+        # Generăm punctele pentru analiză
+        variation_values = np.linspace(min_variation, max_variation, num_points)
+        
+        results = []
+        
+        for value in variation_values:
+            # Creăm parametrii modificați
+            modified_params = base_params.copy()
+            modified_params[param_to_vary] = float(value)
+            
+            # Validăm relația cement-curing pentru fiecare punct
+            if modified_params["cement_perecent"] == 0:
+                modified_params["curing_period"] = 0
+            
+            # Realizăm predicția
+            input_df = pd.DataFrame([modified_params])
+            prediction_df = pd.DataFrame()
+            for feature in FEATURE_ORDER:
+                prediction_df[feature] = input_df[feature]
+            
+            input_array = prediction_df.values
+            prediction_result = predict_with_uncertainty(input_array)
+            
+            results.append({
+                param_to_vary: float(value),
+                "central_prediction": prediction_result['central_prediction'],
+                "uncertainty_estimate": prediction_result['uncertainty_estimate'],
+                "relative_uncertainty": prediction_result['relative_uncertainty'],
+                "confidence_95_lower": prediction_result['confidence_intervals']['95%'].lower,
+                "confidence_95_upper": prediction_result['confidence_intervals']['95%'].upper
+            })
+        
+        # Calculăm statisticile sensibilității
+        predictions = [r["central_prediction"] for r in results]
+        uncertainties = [r["uncertainty_estimate"] for r in results]
+        
+        sensitivity_stats = {
+            "parameter_range": {
+                "min": float(min_variation),
+                "max": float(max_variation),
+                "base_value": float(base_value)
+            },
+            "prediction_sensitivity": {
+                "min_prediction": float(min(predictions)),
+                "max_prediction": float(max(predictions)),
+                "range": float(max(predictions) - min(predictions)),
+                "relative_change": float((max(predictions) - min(predictions)) / base_params.get("central_prediction", predictions[num_points//2]) * 100)
+            },
+            "uncertainty_sensitivity": {
+                "min_uncertainty": float(min(uncertainties)),
+                "max_uncertainty": float(max(uncertainties)),
+                "range": float(max(uncertainties) - min(uncertainties))
+            }
+        }
         
         return {
             "success": True,
-            "prediction": float(prediction[0]),
-            "units": "kPa",
-            "input_parameters": input_data,
-            "prediction_time_ms": prediction_time_ms
+            "parameter_analyzed": param_to_vary,
+            "base_parameters": base_params,
+            "sensitivity_data": results,
+            "sensitivity_statistics": sensitivity_stats,
+            "interpretation": {
+                "parameter_impact": f"Variația de {variation_range*100:.1f}% în {param_to_vary} "
+                                  f"produce o schimbare de {sensitivity_stats['prediction_sensitivity']['range']:.1f} kPa în UCS",
+                "recommendation": "Parametrul cu cel mai mare impact ar trebui controlat cu atenție în teren"
+                                if sensitivity_stats['prediction_sensitivity']['relative_change'] > 10 
+                                else "Parametrul are impact moderat, variațiile mici sunt acceptabile"
+            }
         }
+        
     except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Eroare în analiza sensibilității: {str(e)}")
 
-# Status endpoint
-@app.get("/status", summary="API Status")
-async def status():
+@app.get("/status", summary="Status Sistem")
+async def get_system_status():
     """
-    Returns the API status and model availability.
+    **Returnează statusul complet al sistemului de incertitudine.**
+    
+    Useful pentru monitorizarea sănătății aplicației și diagnosticarea problemelor.
     """
-    return {
-        "status": "API is running",
-        "model_loaded": model is not None,
-        "model_type": "Random Forest Regressor" if model is not None else None,
-        "feature_order": FEATURE_ORDER.tolist() if model is not None else [],
-        "server_time": time.time()
+    
+    status_info = {
+        "api_status": "running",
+        "timestamp": datetime.now().isoformat(),
+        "system_loaded": system_loaded,
+        "models_status": {
+            "primary_model": primary_model is not None,
+            "uncertainty_model": uncertainty_model is not None,
+            "metadata_available": system_metadata is not None
+        },
+        "feature_configuration": {
+            "feature_order": FEATURE_ORDER.tolist() if FEATURE_ORDER is not None else [],
+            "num_features": len(FEATURE_ORDER) if FEATURE_ORDER is not None else 0
+        }
     }
+    
+    # Testul rapid de funcționalitate dacă modelele sunt încărcate
+    if system_loaded:
+        try:
+            test_result = validate_models_compatibility()
+            status_info["functionality_test"] = "passed" if test_result else "failed"
+        except Exception as e:
+            status_info["functionality_test"] = f"error: {str(e)}"
+    
+    return status_info
 
-# Model info endpoint
-@app.get("/model-info", summary="Model Information")
-async def model_info(model=Depends(get_model)):
+@app.get("/model-info", summary="Informații Modele")
+async def get_model_information(_: bool = Depends(validate_models_loaded)):
     """
-    Returns detailed information about the model being used.
+    **Returnează informații detaliate despre modelele utilizate.**
+    
+    Include parametrii modelelor, performanțele istorice și limitele de aplicabilitate.
     """
+    
     try:
-        # Extract model parameters
-        model_params = model.get_params()
-        
-        return {
-            "model_type": type(model).__name__,
-            "features": FEATURE_ORDER.tolist(),
-            "target": "UCS (kPa)",
+        model_info = {
+            "system_type": "Two-stage Random Forest Uncertainty Quantification",
+            "models": {
+                "primary_model": {
+                    "type": type(primary_model).__name__,
+                    "parameters": primary_model.get_params(),
+                    "purpose": "Central UCS prediction"
+                },
+                "uncertainty_model": {
+                    "type": type(uncertainty_model).__name__,
+                    "parameters": uncertainty_model.get_params(),
+                    "purpose": "Prediction error magnitude estimation"
+                }
+            },
+            "features": {
+                "input_features": FEATURE_ORDER.tolist(),
+                "feature_engineering": "Feature augmentation for uncertainty model (original features + central prediction)"
+            },
             "valid_ranges": {
-                "cement_perecent": {"min": 0, "max": 15, "units": "%"},
-                "curing_period": {"min": 0, "max": 90, "units": "days"},
-                "compaction_rate": {"min": 0.5, "max": 2, "units": "mm/min"}
+                "cement_perecent": {"min": 0, "max": 15, "units": "%", "note": "Based on experimental data"},
+                "curing_period": {"min": 0, "max": 90, "units": "days", "note": "0 only valid for 0% cement"},
+                "compaction_rate": {"min": 0.5, "max": 2.0, "units": "mm/min", "note": "Within experimental range"}
             },
-            "model_parameters": {
-                "n_estimators": model_params.get("n_estimators", None),
-                "max_depth": model_params.get("max_depth", None),
-                "min_samples_split": model_params.get("min_samples_split", None),
-                "min_samples_leaf": model_params.get("min_samples_leaf", None)
+            "confidence_levels": ["68%", "80%", "90%", "95%"],
+            "target_variable": {
+                "name": "UCS",
+                "description": "Unconfined Compressive Strength",
+                "units": "kPa",
+                "typical_range": "150-5500 kPa based on experimental data"
             }
         }
+        
+        # Adăugăm metadata-ul dacă este disponibil
+        if system_metadata:
+            model_info["training_metadata"] = {
+                "training_samples": system_metadata.get("n_training_samples", "Unknown"),
+                "training_timestamp": system_metadata.get("training_timestamp", "Unknown"),
+                "model_version": "2.0.0"
+            }
+        
+        return model_info
+        
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error retrieving model information: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Eroare la obținerea informațiilor: {str(e)}")
 
-# Documentation endpoint
-@app.get("/", summary="API Documentation")
-async def root():
-    """
-    Returns information about the API.
-    """
-    return {
-        "message": "Welcome to the UCS prediction API for cement-stabilized soils",
-        "endpoints": {
-            "predict": "/predict - Make UCS predictions",
-            "status": "/status - Check API status",
-            "model-info": "/model-info - Get model information"
-        },
-        "docs": "/docs - Swagger documentation",
-        "redoc": "/redoc - ReDoc documentation"
-    }
+# ==============================================================================
+# HANDLER-E PENTRU EXCEPȚII
+# ==============================================================================
 
-# ValidationError exception handler
 @app.exception_handler(ValidationError)
 async def validation_exception_handler(request: Request, exc: ValidationError):
-    errors = []
+    """
+    Handler personalizat pentru erorile de validare Pydantic.
+    Oferă mesaje de eroare mai prietenoase pentru utilizatori.
+    """
+    
+    friendly_errors = []
     for error in exc.errors():
+        field = " -> ".join(str(loc) for loc in error.get('loc', []))
         message = error.get('msg', '')
-        if message.startswith("Value error, "):
-            message = message[12:]
         
-        errors.append({
-            "loc": error.get('loc', []),
-            "msg": message,
-            "type": error.get('type', '')
+        # Personalizăm mesajele pentru cazuri comune
+        if "greater than or equal" in message:
+            message = f"Valoarea pentru {field} este prea mică"
+        elif "less than or equal" in message:
+            message = f"Valoarea pentru {field} este prea mare"
+        elif "string does not match regex" in message:
+            message = f"Valoarea pentru {field} nu este validă"
+        
+        friendly_errors.append({
+            "field": field,
+            "message": message,
+            "error_type": error.get('type', '')
         })
     
     return JSONResponse(
         status_code=422,
-        content={"detail": errors}
-    )
+        content={
+            "success": False,
+            "error": "Eroare de validare a datelor de intrare",
+            "details": friendly_errors,
+            "help": "Verificați că toate valorile sunt în intervalele specificate și încercați din nou"
+        }
+    )
+
+@app.exception_handler(Exception)
+async def general_exception_handler(request: Request, exc: Exception):
+    """
+    Handler general pentru excepții neașteptate.
+    """
+    return JSONResponse(
+        status_code=500,
+        content={
+            "success": False,
+            "error": "Eroare internă a serverului",
+            "message": "A apărut o eroare neașteptată. Contactați administratorul dacă problema persistă.",
+            "request_id": str(time.time())  # Pentru tracking în loguri
+        }
+    )
+
+# ==============================================================================
+# CONFIGURAȚIE FINALĂ ȘI STARTUP
+# ==============================================================================
+
+@app.on_event("startup")
+async def startup_event():
+    """
+    Eveniment executat la pornirea aplicației.
+    Efectuează verificări finale și pregătește sistemul pentru producție.
+    """
+    print("🚀 Pornirea aplicației UCS Prediction API v2.0...")
+    
+    if system_loaded:
+        print("✅ Sistem de incertitudine încărcat și funcțional")
+        print(f"📊 Features configurate: {FEATURE_ORDER.tolist()}")
+    else:
+        print("❌ ATENȚIE: Sistemul nu a fost încărcat corect!")
+        print("   Verificați că fișierele de modele sunt prezente în directorul models_for_deployment/")
+    
+    print("🌐 API disponibil pentru cereri")
+
+if __name__ == "__main__":
+    # Pentru rularea în dezvoltare
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)