Update app.py

app.py

@@ -1,813 +1,230 @@
-# ==============================================================================
-# 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
+import sys
+import traceback
+from pathlib import Path
 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, Union
-from scipy import stats
-import json
-
-# ==============================================================================
-# CONFIGURAȚIA APLICAȚIEI FASTAPI
-# ==============================================================================
-
-app = FastAPI(
-    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",
-    }
-)
-
-# Configurarea CORS pentru interfața web
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=[
-        "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", "OPTIONS"],
-    allow_headers=["*"],
-)
-
-# ==============================================================================
-# CONFIGURAȚIA MODELELOR ȘI ÎNCĂRCAREA SISTEMULUI
-# ==============================================================================
-
-# 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()
-    
-    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="Procentajul de cement în amestec",
-        ge=0, le=15,
-        example=5.0
-    )
-    curing_period: float = Field(
-        ...,
-        description="Perioada de maturare în zile",
-        ge=0, le=90,
-        example=28.0
-    )
-    compaction_rate: float = Field(
-        ...,
-        description="Rata de compactare în mm/min",
-        ge=0.5, le=2.0,
-        example=1.0
-    )
 
-    @model_validator(mode="after")
-    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
-        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
-
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "cement_perecent": 5.0,
-                "curing_period": 28.0,
-                "compaction_rate": 1.0
-            }
-        }
-
-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):
+# Funcție de logging foarte verbos pentru debugging
+def debug_log(message, level="INFO"):
     """
-    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.
+    Funcție de logging care afișează informații detaliate despre starea aplicației.
+    Aceasta ne ajută să vedem exact unde se oprește procesul de inițializare.
     """
-    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"
-    )
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    print(f"[{timestamp}] [{level}] {message}", flush=True)
     
-    # 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ă")
+    # Forțăm flush-ul pentru ca mesajele să apară imediat în loguri
+    sys.stdout.flush()
 
-# ==============================================================================
-# FUNCȚIILE CORE PENTRU PREDICȚIA CU INCERTITUDINE
-# ==============================================================================
+# Începem logging-ul imediat la încărcarea modulului
+debug_log("🚀 PORNIREA APLICAȚIEI UCS - Început încărcare modul app.py")
 
-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]
+try:
+    # Importurile necesare cu logging pentru fiecare pas major
+    debug_log("📚 Încărcare biblioteci Python...")
+    from fastapi import FastAPI, HTTPException, Request, Depends, Query
+    from fastapi.responses import JSONResponse, HTMLResponse
+    from fastapi.middleware.cors import CORSMiddleware
+    debug_log("✅ FastAPI și dependențele încărcate cu succes")
     
-    # Etapa 4: Calcularea intervalelor de încredere
-    confidence_intervals = {}
+    import pandas as pd
+    import joblib
+    import numpy as np
+    debug_log("✅ Biblioteci științifice (pandas, numpy, joblib) încărcate")
     
-    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.
+    from pydantic import BaseModel, ValidationError, Field, field_validator, model_validator
+    debug_log("✅ Pydantic încărcat pentru validarea datelor")
     
-    Această funcție traduce rezultatele statistice în limbaj practic pentru ingineri,
-    oferind contextul necesar pentru luarea deciziilor informate în proiecte.
-    """
+    debug_log("📊 Verificare directoare și fișiere disponibile...")
     
-    # Calculăm intervalul 95% pentru interpretare
-    interval_95 = confidence_intervals.get('95%')
+    # Verificăm ce fișiere sunt disponibile în directorul de lucru
+    current_dir = Path("/code")
+    debug_log(f"📁 Directorul de lucru: {current_dir}")
+    debug_log(f"📁 Conținutul directorului /code: {list(current_dir.iterdir())}")
     
-    # Clasificarea încrederii bazată pe incertitudinea relativă
-    relative_unc = (uncertainty_estimate / central_prediction) * 100
+    # Verificăm specific directorul cu modelele
+    models_dir = current_dir / "models_for_deployment"
+    debug_log(f"📁 Calea către modele: {models_dir}")
+    debug_log(f"📁 Directorul modele există: {models_dir.exists()}")
     
-    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ă."
+    if models_dir.exists():
+        debug_log(f"📁 Conținutul directorului modele: {list(models_dir.iterdir())}")
     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 "",
+        debug_log("❌ PROBLEMĂ: Directorul models_for_deployment nu există!")
         
-        "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="Sistemul de modele nu este încărcat corect. Contactați administratorul."
-        )
-    return True
+    # Verificăm și modelele vechi pentru compatibilitate
+    old_model_files = ["rf_model.joblib", "rf_model_optim.joblib"]
+    for filename in old_model_files:
+        file_path = current_dir / filename
+        debug_log(f"📄 {filename} există: {file_path.exists()}")
 
-# ==============================================================================
-# ENDPOINT-URILE API
-# ==============================================================================
+except Exception as e:
+    debug_log(f"❌ EROARE la importuri inițiale: {str(e)}", "ERROR")
+    debug_log(f"❌ Traceback complet: {traceback.format_exc()}", "ERROR")
+    # Nu facem exit aici - lăsăm aplicația să încerce să continue
+    
+# Variabile globale pentru sistemul de modele
+sistem_incertitudine = None
+system_loaded = False
 
-@app.get("/", response_class=HTMLResponse, summary="Pagina principală")
-async def root():
-    """
-    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>
+def load_uncertainty_system_with_detailed_logging():
     """
-
-@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)
-):
+    Funcție de încărcare a sistemului de incertitudine cu logging foarte detaliat.
+    Aceasta ne va arăta exact unde se oprește procesul dacă apar probleme.
     """
-    **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)
+    global sistem_incertitudine, system_loaded
     
-    **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
-    
-    **Utilizare tipică:**
-    ```json
-    {
-        "cement_perecent": 7.5,
-        "curing_period": 28,
-        "compaction_rate": 1.0
-    }
-    ```
-    """
+    debug_log("🔍 ÎNCEPEREA ÎNCĂRCĂRII SISTEMULUI DE INCERTITUDINE")
     
     try:
-        start_time = time.time()
-        
-        # Pregătirea datelor de input în formatul așteptat de model
-        input_data = soil_data.dict()
-        input_df = pd.DataFrame([input_data])
-        
-        # 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]
+        # Strategia de încărcare cu mai multe opțiuni de fallback
+        models_dir = Path("/code/models_for_deployment")
+        possible_files = [
+            "sistem_incertitudine_final_sistem_complet.pkl",
+            "sistem_final_ncv_sistem_complet.pkl",  # Numele posibil diferit
+        ]
+        
+        sistem_loaded_successfully = False
+        
+        for filename in possible_files:
+            file_path = models_dir / filename
+            debug_log(f"🔍 Verific fișierul: {file_path}")
+            
+            if file_path.exists():
+                debug_log(f"✅ Fișierul găsit: {filename}")
+                debug_log(f"📏 Dimensiunea fișierului: {file_path.stat().st_size / (1024*1024):.2f} MB")
+                
+                try:
+                    debug_log(f"📖 Încep încărcarea fișierului: {filename}")
+                    
+                    with open(file_path, 'rb') as f:
+                        sistem_incertitudine = pickle.load(f)
+                    
+                    debug_log(f"✅ Fișierul {filename} încărcat cu succes!")
+                    
+                    # Verificăm că sistemul are componentele necesare
+                    required_attrs = ['model_principal', 'model_incertitudine', 'predict_cu_incertitudine']
+                    missing_attrs = [attr for attr in required_attrs if not hasattr(sistem_incertitudine, attr)]
+                    
+                    if missing_attrs:
+                        debug_log(f"⚠️ Sistemul nu are atributele: {missing_attrs}", "WARNING")
+                    else:
+                        debug_log("✅ Sistemul are toate atributele necesare")
+                        sistem_loaded_successfully = True
+                        break
+                        
+                except Exception as load_error:
+                    debug_log(f"❌ Eroare la încărcarea {filename}: {str(load_error)}", "ERROR")
+                    debug_log(f"❌ Traceback: {traceback.format_exc()}", "ERROR")
+                    continue
             else:
-                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)
+                debug_log(f"❌ Fișierul nu există: {filename}")
         
-        # Generarea ghidului de interpretare
-        interpretation = generate_interpretation_guide(
-            prediction_result['central_prediction'],
-            prediction_result['uncertainty_estimate'],
-            prediction_result['confidence_intervals']
-        )
+        if not sistem_loaded_successfully:
+            debug_log("🔄 Încerc încărcarea modelelor individuale ca fallback...")
+            return load_individual_models_fallback()
         
-        # 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"
-            }
-        
-        # Calcularea timpului de procesare
-        processing_time = (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
-        )
+        system_loaded = True
+        debug_log("🎉 SISTEM DE INCERTITUDINE ÎNCĂRCAT CU SUCCES!")
+        return True
         
-    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)}")
+        debug_log(f"❌ EROARE GENERALĂ la încărcarea sistemului: {str(e)}", "ERROR")
+        debug_log(f"❌ Traceback complet: {traceback.format_exc()}", "ERROR")
+        return False
 
-@app.post("/sensitivity-analysis", summary="Analiza Sensibilității Parametrilor")
-async def perform_sensitivity_analysis(
-    request: SensitivityAnalysisRequest,
-    _: bool = Depends(validate_models_loaded)
-):
+def load_individual_models_fallback():
     """
-    **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.
+    Funcție de fallback care încearcă să încarce modelele vechi dacă sistemul nou nu funcționează.
     """
+    debug_log("🔄 ÎNCĂRCARE FALLBACK - modele individuale")
     
     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))
-            }
-        }
+        # Încercăm să încărcăm modelele vechi pentru compatibilitate
+        model_files = ["/code/rf_model_optim.joblib", "/code/rf_model.joblib"]
+        
+        for model_file in model_files:
+            debug_log(f"🔍 Verific modelul: {model_file}")
+            if Path(model_file).exists():
+                debug_log(f"✅ Modelul {model_file} există")
+                try:
+                    model = joblib.load(model_file)
+                    debug_log(f"✅ Modelul {model_file} încărcat cu succes")
+                    # Pentru moment, doar confirmăm că modelul se încarcă
+                    # Puteți implementa logica de compatibilitate aici
+                except Exception as e:
+                    debug_log(f"❌ Eroare la încărcarea {model_file}: {str(e)}", "ERROR")
+            else:
+                debug_log(f"❌ Modelul {model_file} nu există")
         
-        return {
-            "success": True,
-            "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"
-            }
-        }
+        debug_log("⚠️ Sistem funcționând în modul de compatibilitate limitată", "WARNING")
+        return False
         
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Eroare în analiza sensibilității: {str(e)}")
+        debug_log(f"❌ EROARE în funcția de fallback: {str(e)}", "ERROR")
+        return False
 
-@app.get("/status", summary="Status Sistem")
-async def get_system_status():
-    """
-    **Returnează statusul complet al sistemului de incertitudine.**
-    
-    Useful pentru monitorizarea sănătății aplicației și diagnosticarea problemelor.
-    """
-    
-    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)}"
+# Încărcăm sistemul imediat după definirea funcțiilor
+debug_log("🎯 Pornesc încărcarea sistemului de modele...")
+model_loading_success = load_uncertainty_system_with_detailed_logging()
+debug_log(f"📊 Rezultatul încărcării modelelor: {model_loading_success}")
+
+# Creăm aplicația FastAPI cu logging
+debug_log("🌐 Creez aplicația FastAPI...")
+
+try:
+    app = FastAPI(
+        title="UCS Prediction API with Uncertainty Quantification - DEBUG VERSION",
+        description="Versiune de debugging pentru diagnoticarea problemelor de pornire",
+        version="2.0-debug"
+    )
+    debug_log("✅ Aplicația FastAPI creată cu succes")
+    
+    # Adăugăm middleware CORS cu logging
+    debug_log("🔧 Configurez CORS middleware...")
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # Pentru debugging, permittem toate originile
+        allow_credentials=True,
+        allow_methods=["GET", "POST", "OPTIONS"],
+        allow_headers=["*"],
+    )
+    debug_log("✅ CORS middleware configurat")
     
-    return status_info
+except Exception as e:
+    debug_log(f"❌ EROARE la crearea aplicației FastAPI: {str(e)}", "ERROR")
+    debug_log(f"❌ Traceback: {traceback.format_exc()}", "ERROR")
 
-@app.get("/model-info", summary="Informații Modele")
-async def get_model_information(_: bool = Depends(validate_models_loaded)):
+# Endpoint simplu de debugging pentru testarea stării sistemului
+@app.get("/debug-status")
+async def debug_status():
     """
-    **Returnează informații detaliate despre modelele utilizate.**
-    
-    Include parametrii modelelor, performanțele istorice și limitele de aplicabilitate.
+    Endpoint special pentru debugging care returnează informații complete despre starea sistemului.
     """
+    debug_log("🔍 Cerere pentru debug-status")
     
     try:
-        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": "%", "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"}
-            },
-            "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"
-            }
+        return {
+            "status": "API is running",
+            "timestamp": datetime.now().isoformat(),
+            "system_loaded": system_loaded,
+            "models_directory_exists": Path("/code/models_for_deployment").exists(),
+            "files_in_models_dir": list(Path("/code/models_for_deployment").iterdir()) if Path("/code/models_for_deployment").exists() else [],
+            "python_version": sys.version,
+            "current_directory": str(Path.cwd()),
+            "environment_variables": dict(os.environ),
         }
-        
-        # 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"Eroare la obținerea informațiilor: {str(e)}")
-
-# ==============================================================================
-# HANDLER-E PENTRU EXCEPȚII
-# ==============================================================================
-
-@app.exception_handler(ValidationError)
-async def validation_exception_handler(request: Request, exc: ValidationError):
-    """
-    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', '')
-        
-        # 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={
-            "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
-        }
-    )
+        debug_log(f"❌ EROARE în debug-status: {str(e)}", "ERROR")
+        return {"error": str(e), "traceback": traceback.format_exc()}
 
-# ==============================================================================
-# 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")
+# Endpoint simplu pentru verificarea că aplicația răspunde
+@app.get("/")
+async def root():
+    debug_log("🏠 Cerere pentru endpoint root")
+    return {"message": "UCS API Debug Version - System Running", "system_loaded": system_loaded}
 
-if __name__ == "__main__":
-    # Pentru rularea în dezvoltare
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)
+# La sfârșit, confirmăm că modulul s-a încărcat complet
+debug_log("🎉 MODULUL app.py S-A ÎNCĂRCAT COMPLET!")
+debug_log(f"📊 Starea finală: system_loaded = {system_loaded}")