Update app.py

app.py

@@ -1,9 +1,9 @@
 # ==============================================================================
-# APLICAȚIA FASTAPI CU SISTEM DE INCERTITUDINE INTEGRATĂ
+# FASTAPI APPLICATION WITH INTEGRATED UNCERTAINTY SYSTEM
 # ==============================================================================
-# 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
+# This application replaces the simple prediction system with an advanced
+# uncertainty quantification framework, providing engineers not only predictions
+# but also calibrated confidence intervals for informed decision making
 
 from fastapi import FastAPI, HTTPException, Request, Depends, Query
 from fastapi.responses import JSONResponse, HTMLResponse
@@ -16,47 +16,47 @@ import os
 import time
 import pickle
 from datetime import datetime
-from sklearn.ensemble import RandomForestRegressor  # Necesar pentru deserializare
+from sklearn.ensemble import RandomForestRegressor  # Required for deserialization
 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
+# FASTAPI APPLICATION CONFIGURATION
 # ==============================================================================
 
 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**
+    **Advanced API for predicting Unconfined Compressive Strength (UCS) of cement-stabilized soils**
     
-    Această aplicație implementează sistemul de cuantificare a incertitudinii dezvoltat în cercetarea
+    This application implements the uncertainty quantification system developed in the research
     "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
+    **Main features:**
+    - Accurate UCS predictions using optimized Random Forest
+    - Complete uncertainty quantification with calibrated confidence intervals
+    - Sensitivity analysis for parameter optimization
+    - Interpretability through feature importance analysis
     
-    **Dezvoltat de:** Echipa de cercetare - Universitatea Tehnică Gheorghe Asachi din Iași
+    **Developed by:** Research Team - Technical University Gheorghe Asachi of Iași
     """,
     version="2.0.0",
     contact={
-        "name": "Echipa de Dezvoltare UCS",
+        "name": "UCS Development Team",
         "email": "iancu-bogdan.teodoru@academic.tuiasi.ro",
     }
 )
 
-# Configurarea CORS pentru interfața web
+# CORS configuration for web interface
 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ă
+        "http://localhost:3000",  # For local development
+        "http://localhost:8000"   # For local testing
     ],
     allow_credentials=True,
     allow_methods=["GET", "POST", "OPTIONS"],
@@ -64,19 +64,19 @@ app.add_middleware(
 )
 
 # ==============================================================================
-# CONFIGURAȚIA MODELELOR ȘI ÎNCĂRCAREA SISTEMULUI
+# MODEL CONFIGURATION AND SYSTEM LOADING
 # ==============================================================================
 
-# Căile către modelele serializate
+# Paths to serialized models
 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']
+# Feature order (critical for compatibility)
+DEFAULT_FEATURE_ORDER = ['cement_percent', 'curing_period', 'compaction_rate']
 
-# Variabile globale pentru sistem
+# Global variables for system
 primary_model = None
 uncertainty_model = None
 system_metadata = None
@@ -84,43 +84,43 @@ FEATURE_ORDER = None
 
 def load_uncertainty_system():
     """
-    Încarcă și validează întregul sistem de incertitudine.
+    Loads and validates the entire uncertainty system.
     
-    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.
+    This function orchestrates the loading of all system components
+    and performs basic validations to ensure proper operation.
+    The process is designed to be robust and provide detailed information
+    about any issues encountered during loading.
     """
     global primary_model, uncertainty_model, system_metadata, FEATURE_ORDER
     
-    print("🚀 Încărcarea sistemului de incertitudine...")
+    print("🚀 Loading uncertainty system...")
     start_time = time.time()
     
     try:
-        # Încărcăm modelul principal
+        # Load primary model
         if os.path.exists(PRIMARY_MODEL_PATH):
             primary_model = joblib.load(PRIMARY_MODEL_PATH)
-            print(f"✅ Model principal încărcat: {type(primary_model).__name__}")
+            print(f"✅ Primary model loaded: {type(primary_model).__name__}")
         else:
-            raise FileNotFoundError(f"Modelul principal nu a fost găsit la: {PRIMARY_MODEL_PATH}")
+            raise FileNotFoundError(f"Primary model not found at: {PRIMARY_MODEL_PATH}")
         
-        # Încărcăm modelul de incertitudine
+        # Load uncertainty model
         if os.path.exists(UNCERTAINTY_MODEL_PATH):
             uncertainty_model = joblib.load(UNCERTAINTY_MODEL_PATH)
-            print(f"✅ Model incertitudine încărcat: {type(uncertainty_model).__name__}")
+            print(f"✅ Uncertainty model loaded: {type(uncertainty_model).__name__}")
         else:
-            raise FileNotFoundError(f"Modelul de incertitudine nu a fost găsit la: {UNCERTAINTY_MODEL_PATH}")
+            raise FileNotFoundError(f"Uncertainty model not found at: {UNCERTAINTY_MODEL_PATH}")
         
-        # Încărcăm metadata-ul sistemului
+        # Load system metadata
         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")
+            print(f"✅ System metadata loaded: {len(system_metadata)} keys")
         else:
-            print("⚠️ Metadata-ul sistemului nu a fost găsit, se folosesc valorile default")
+            print("⚠️ System metadata not found, using default values")
             system_metadata = {"feature_names": DEFAULT_FEATURE_ORDER}
         
-        # Determinăm ordinea features-urilor
+        # Determine feature order
         if hasattr(primary_model, 'feature_names_in_'):
             FEATURE_ORDER = primary_model.feature_names_in_
         elif system_metadata and 'feature_names' in system_metadata:
@@ -128,83 +128,83 @@ def load_uncertainty_system():
         else:
             FEATURE_ORDER = np.array(DEFAULT_FEATURE_ORDER)
         
-        # Validăm compatibilitatea modelelor
+        # Validate model compatibility
         validation_result = validate_models_compatibility()
         if not validation_result:
-            raise ValueError("Modelele nu sunt compatibile între ele")
+            raise ValueError("Models are not compatible with each other")
         
         load_time = time.time() - start_time
-        print(f"🎉 Sistem de incertitudine încărcat cu succes în {load_time:.2f} secunde!")
+        print(f"🎉 Uncertainty system loaded successfully in {load_time:.2f} seconds!")
         print(f"📊 Features: {FEATURE_ORDER.tolist()}")
         
         return True
         
     except Exception as e:
-        print(f"❌ Eroare la încărcarea sistemului: {str(e)}")
+        print(f"❌ Error loading system: {str(e)}")
         import traceback
         print(traceback.format_exc())
         return False
 
 def validate_models_compatibility():
     """
-    Validează că modelele sunt compatibile și funcționează împreună.
+    Validates that models are compatible and work together.
     
-    Această validare include teste de compatibilitate dimensională,
-    verificarea tipurilor de date și un test funcțional complet.
+    This validation includes dimensional compatibility tests,
+    data type checks and a complete functional test.
     """
     try:
-        # Test cu date sintetice
+        # Test with synthetic data
         test_input = np.array([[5.0, 14.0, 1.0]])  # cement, curing, compaction
         
-        # Testăm modelul principal
+        # Test primary model
         primary_pred = primary_model.predict(test_input)[0]
         
-        # Testăm modelul de incertitudine cu feature augmentation
+        # Test uncertainty model with 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
+        # Check that results are numeric and reasonable
         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")
+        print(f"✅ Compatibility test: UCS={primary_pred:.1f} kPa, σ={uncertainty_pred:.1f} kPa")
         return True
         
     except Exception as e:
-        print(f"❌ Test compatibilitate eșuat: {str(e)}")
+        print(f"❌ Compatibility test failed: {str(e)}")
         return False
 
-# Încărcăm sistemul la pornirea aplicației
+# Load system at application startup
 system_loaded = load_uncertainty_system()
 
 # ==============================================================================
-# MODELELE PYDANTIC PENTRU INPUT ȘI OUTPUT
+# PYDANTIC MODELS FOR INPUT AND OUTPUT
 # ==============================================================================
 
 class SoilInput(BaseModel):
     """
-    Modelul pentru datele de input ale solului.
+    Model for soil input data.
     
-    Această clasă definește și validează parametrii de intrare,
-    asigurându-se că valorile sunt în intervalele experimentale validate.
+    This class defines and validates input parameters,
+    ensuring values are within validated experimental ranges.
     """
-    cement_perecent: float = Field(
+    cement_percent: float = Field(
         ..., 
-        description="Procentajul de cement în amestec",
+        description="Cement percentage in mixture",
         ge=0, le=15,
         example=5.0
     )
     curing_period: float = Field(
         ...,
-        description="Perioada de maturare în zile",
+        description="Curing period in days",
         ge=0, le=90,
         example=28.0
     )
     compaction_rate: float = Field(
         ...,
-        description="Rata de compactare în mm/min",
+        description="Compaction rate in mm/min",
         ge=0.5, le=2.0,
         example=1.0
     )
@@ -212,113 +212,113 @@ class SoilInput(BaseModel):
     @model_validator(mode="after")
     def validate_cement_curing_relationship(self):
         """
-        Validează relația dintre conținutul de cement și perioada de maturare.
+        Validates the relationship between cement content and curing period.
         
-        Pentru solul netratat (0% cement), perioada de maturare este forțată la 0
-        deoarece nu există proces de hidratare a cimentului.
+        For untreated soil (0% cement), curing period is forced to 0
+        because there is no cement hydration process.
         """
-        if self.cement_perecent == 0:
+        if self.cement_percent == 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")
+        elif self.cement_percent > 0 and self.curing_period < 1:
+            raise ValueError("For cement-treated soil, curing period must be ≥ 1 day")
         return self
 
     class Config:
         json_schema_extra = {
             "example": {
-                "cement_perecent": 5.0,
+                "cement_percent": 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")
+    """Model for a confidence interval."""
+    lower: float = Field(..., description="Lower bound of the interval")
+    upper: float = Field(..., description="Upper bound of the interval")
+    width: float = Field(..., description="Width of the interval")
 
 class UncertaintyPredictionResponse(BaseModel):
     """
-    Răspunsul complet cu cuantificare de incertitudine.
+    Complete response with uncertainty quantification.
     
-    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.
+    This extended structure provides the engineer with a complete picture
+    of the prediction, including not only the estimated value but also confidence
+    in that estimate through calibrated intervals.
     """
-    success: bool = Field(..., description="Statusul procesării cererii")
+    success: bool = Field(..., description="Request processing status")
     
-    # 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ă")
+    # Central prediction
+    central_prediction: float = Field(..., description="Most probable UCS prediction")
+    units: str = Field(default="kPa", description="Units of measurement")
     
-    # Informații despre incertitudine
-    uncertainty_estimate: float = Field(..., description="Estimarea incertitudinii absolute (1-sigma)")
-    relative_uncertainty: float = Field(..., description="Incertitudinea relativă ca procent")
+    # Uncertainty information
+    uncertainty_estimate: float = Field(..., description="Absolute uncertainty estimate (1-sigma)")
+    relative_uncertainty: float = Field(..., description="Relative uncertainty as percentage")
     
-    # Intervale de încredere
+    # Confidence intervals
     confidence_intervals: Dict[str, ConfidenceInterval] = Field(
         ..., 
-        description="Intervale de încredere pentru multiple nivele de probabilitate"
+        description="Confidence intervals for multiple probability levels"
     )
     
-    # Interpretarea pentru utilizator
-    interpretation: Dict[str, str] = Field(..., description="Ghid de interpretare pentru rezultate")
+    # User interpretation
+    interpretation: Dict[str, str] = Field(..., description="Interpretation guide for results")
     
     # 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")
+    input_parameters: Dict[str, float] = Field(..., description="Input parameters used")
+    prediction_time_ms: Optional[float] = Field(None, description="Processing time in milliseconds")
+    model_info: Optional[Dict[str, Any]] = Field(None, description="Information about models used")
 
 class SensitivityAnalysisRequest(BaseModel):
-    """Cererea pentru analiza de sensibilitate."""
+    """Request for sensitivity analysis."""
     base_parameters: SoilInput
-    parameter_to_vary: str = Field(..., pattern="^(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ă")
+    parameter_to_vary: str = Field(..., pattern="^(cement_percent|curing_period|compaction_rate)$")
+    variation_range: float = Field(default=10.0, ge=1.0, le=50.0, description="Variation range in percentage")
+    num_points: int = Field(default=11, ge=5, le=21, description="Number of points for analysis")
 
 # ==============================================================================
-# FUNCȚIILE CORE PENTRU PREDICȚIA CU INCERTITUDINE
+# CORE FUNCTIONS FOR UNCERTAINTY PREDICTION
 # ==============================================================================
 
 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.
+    Performs complete prediction with uncertainty quantification.
     
-    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ă
+    This function implements the two-stage algorithm developed in research:
+    1. Primary model generates central UCS prediction
+    2. Uncertainty model estimates magnitude of probable error
+    3. Confidence intervals are constructed assuming normal distribution
     
     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
+        input_data: Numpy array with features [cement%, curing_days, compaction_rate]
+        confidence_levels: List of confidence levels for which to calculate intervals
     
     Returns:
-        Dicționar cu predicția centrală, estimarea incertitudinii și intervalele de încredere
+        Dictionary with central prediction, uncertainty estimation and confidence intervals
     """
     
-    # Etapa 1: Predicția centrală cu modelul principal
+    # Stage 1: Central prediction with primary model
     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ă
+    # Stage 2: Preparing input for uncertainty model
+    # Uncertainty model uses feature augmentation:
+    # original features + central prediction
     uncertainty_input = np.column_stack([input_data, [[central_prediction]]])
     
-    # Etapa 3: Predicția incertitudinii (magnitudinea erorii așteptate)
+    # Stage 3: Uncertainty prediction (magnitude of expected error)
     uncertainty_estimate = uncertainty_model.predict(uncertainty_input)[0]
     
-    # Etapa 4: Calcularea intervalelor de încredere
+    # Stage 4: Calculating confidence intervals
     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 corresponding to confidence level
+        # For normal distribution: 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 of error = z-score × uncertainty estimate
         margin = z_score * uncertainty_estimate
         
         confidence_intervals[f'{conf_level:.0%}'] = ConfidenceInterval(
@@ -327,7 +327,7 @@ def predict_with_uncertainty(input_data: np.ndarray,
             width=float(2 * margin)
         )
     
-    # Calcularea incertitudinii relative
+    # Calculating relative uncertainty
     relative_uncertainty = (uncertainty_estimate / central_prediction) * 100 if central_prediction != 0 else 0
     
     return {
@@ -340,65 +340,65 @@ def predict_with_uncertainty(input_data: np.ndarray,
 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.
+    Generates a personalized interpretation guide for prediction results.
     
-    Această funcție traduce rezultatele statistice în limbaj practic pentru ingineri,
-    oferind contextul necesar pentru luarea deciziilor informate în proiecte.
+    This function translates statistical results into practical language for engineers,
+    providing the necessary context for informed decision making in projects.
     """
     
-    # Calculăm intervalul 95% pentru interpretare
+    # Calculate 95% interval for interpretation
     interval_95 = confidence_intervals.get('95%')
     
-    # Clasificarea încrederii bazată pe incertitudinea relativă
+    # Confidence classification based on relative uncertainty
     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."
+        confidence_level = "very high"
+        reliability_desc = "The prediction is very reliable for design decision making."
     elif relative_unc <= 20:
-        confidence_level = "mare"
-        reliability_desc = "Predicția este fiabilă, recomandăm validare prin teste limitate."
+        confidence_level = "high"
+        reliability_desc = "The prediction is reliable, we recommend validation through limited testing."
     elif relative_unc <= 30:
-        confidence_level = "moderată"
-        reliability_desc = "Predicția oferă o estimare utilă, dar se recomandă testare suplimentară."
+        confidence_level = "moderate"
+        reliability_desc = "The prediction provides a useful estimate, but additional testing is recommended."
     else:
-        confidence_level = "limitată"
-        reliability_desc = "Predicția este indicativă, se recomandă testare extinsă pentru validare."
+        confidence_level = "limited"
+        reliability_desc = "The prediction is indicative, extensive testing is recommended for validation."
     
     interpretation = {
-        "central_prediction": f"Valoarea UCS cea mai probabilă este {central_prediction:.0f} kPa, bazată pe parametrii introduși.",
+        "central_prediction": f"The most probable UCS value is {central_prediction:.0f} kPa, based on the input parameters.",
         
-        "uncertainty": f"Incertitudinea estimată este ±{uncertainty_estimate:.0f} kPa ({relative_unc:.1f}%), "
-                      f"indicând o încredere {confidence_level} în predicție.",
+        "uncertainty": f"The estimated uncertainty is ±{uncertainty_estimate:.0f} kPa ({relative_unc:.1f}%), "
+                      f"indicating {confidence_level} confidence in the prediction.",
         
-        "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 "",
+        "confidence_95": f"We have 95% confidence that the actual UCS value is between "
+                        f"{interval_95.lower:.0f} and {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."
+        "practical_guidance": f"For applications with UCS requirements > {central_prediction + uncertainty_estimate:.0f} kPa, "
+                             f"consider increasing cement content or extending the curing period."
     }
     
     return interpretation
 
 async def validate_models_loaded():
-    """Dependency function pentru validarea încărcării modelelor."""
+    """Dependency function for validating model loading."""
     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."
+            detail="Model system is not loaded correctly. Contact administrator."
         )
     return True
 
 # ==============================================================================
-# ENDPOINT-URILE API
+# API ENDPOINTS
 # ==============================================================================
 
-@app.get("/", response_class=HTMLResponse, summary="Pagina principală")
+@app.get("/", response_class=HTMLResponse, summary="Main page")
 async def root():
     """
-    Returnează pagina principală cu informații despre API.
+    Returns the main page with API information.
     """
     return """
     <!DOCTYPE html>
@@ -413,61 +413,61 @@ async def root():
     </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>
+        <p>Advanced API for predicting unconfined compressive strength of cement-stabilized soils.</p>
         
-        <h2>📋 Endpoint-uri disponibile:</h2>
+        <h2>📋 Available endpoints:</h2>
         <div class="endpoint">
-            <strong>POST /predict</strong> - Predicție UCS cu cuantificare de incertitudine
+            <strong>POST /predict</strong> - UCS prediction with uncertainty quantification
         </div>
         <div class="endpoint">
-            <strong>POST /sensitivity-analysis</strong> - Analiza sensibilității parametrilor
+            <strong>POST /sensitivity-analysis</strong> - Parameter sensitivity analysis
         </div>
         <div class="endpoint">
-            <strong>GET /status</strong> - Statusul sistemului
+            <strong>GET /status</strong> - System status
         </div>
         <div class="endpoint">
-            <strong>GET /model-info</strong> - Informații detaliate despre modele
+            <strong>GET /model-info</strong> - Detailed model information
         </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>
+        <h2>📖 Documentation:</h2>
+        <p><a href="/docs">Swagger UI - Interactive documentation</a></p>
+        <p><a href="/redoc">ReDoc - Alternative documentation</a></p>
         
         <footer style="margin-top: 40px; color: #666;">
-            <p>Dezvoltat de echipa de cercetare - Universitatea Tehnică Gheorghe Asachi din Iași</p>
+            <p>Developed by the research team - Technical University Gheorghe Asachi of Iași</p>
         </footer>
     </body>
     </html>
     """
 
 @app.post("/predict", response_model=UncertaintyPredictionResponse, 
-          summary="Predicție UCS cu Cuantificare de Incertitudine")
+          summary="UCS Prediction with Uncertainty Quantification")
 async def predict_ucs_with_uncertainty(
     soil_data: SoilInput, 
-    include_model_info: bool = Query(False, description="Include informații detaliate despre modele"),
+    include_model_info: bool = Query(False, description="Include detailed model information"),
     _: bool = Depends(validate_models_loaded)
 ):
     """
-    **Realizează predicția UCS cu cuantificare completă a incertitudinii.**
+    **Performs UCS prediction with complete uncertainty quantification.**
     
-    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.
+    This endpoint implements the advanced uncertainty system developed in our research,
+    providing not only the central prediction but also calibrated confidence intervals at multiple levels.
     
-    **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)
+    **Input parameters:**
+    - **cement_percent**: Cement content (0-15%)
+    - **curing_period**: Curing period (0-90 days)  
+    - **compaction_rate**: Compaction rate (0.5-2.0 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
+    **Results include:**
+    - Central UCS prediction in kPa
+    - Absolute and relative uncertainty estimation
+    - Confidence intervals at 68%, 80%, 90% and 95%
+    - Personalized interpretation guide for results
     
-    **Utilizare tipică:**
+    **Typical usage:**
     ```json
     {
-        "cement_perecent": 7.5,
+        "cement_percent": 7.5,
         "curing_period": 28,
         "compaction_rate": 1.0
     }
@@ -477,32 +477,32 @@ async def predict_ucs_with_uncertainty(
     try:
         start_time = time.time()
         
-        # Pregătirea datelor de input în formatul așteptat de model
+        # Preparing input data in model-expected format
         input_data = soil_data.dict()
         input_df = pd.DataFrame([input_data])
         
-        # Asigurarea ordinii corecte a features-urilor
+        # Ensuring correct feature order
         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-ul '{feature}' lipsește din datele de intrare")
+                raise ValueError(f"Feature '{feature}' missing from input data")
         
-        # Convertirea la numpy array pentru modelele scikit-learn
+        # Converting to numpy array for scikit-learn models
         input_array = prediction_df.values
         
-        # Realizarea predicției cu incertitudine
+        # Performing prediction with uncertainty
         prediction_result = predict_with_uncertainty(input_array)
         
-        # Generarea ghidului de interpretare
+        # Generating interpretation guide
         interpretation = generate_interpretation_guide(
             prediction_result['central_prediction'],
             prediction_result['uncertainty_estimate'],
             prediction_result['confidence_intervals']
         )
         
-        # Informații opționale despre modele
+        # Optional model information
         model_info = None
         if include_model_info:
             model_info = {
@@ -512,10 +512,10 @@ async def predict_ucs_with_uncertainty(
                 "system_metadata": system_metadata if system_metadata else "Not available"
             }
         
-        # Calcularea timpului de procesare
+        # Calculating processing time
         processing_time = (time.time() - start_time) * 1000
         
-        # Construirea răspunsului complet
+        # Building complete response
         return UncertaintyPredictionResponse(
             success=True,
             central_prediction=prediction_result['central_prediction'],
@@ -530,62 +530,62 @@ async def predict_ucs_with_uncertainty(
         )
         
     except ValueError as ve:
-        raise HTTPException(status_code=400, detail=f"Eroare de validare: {str(ve)}")
+        raise HTTPException(status_code=400, detail=f"Validation error: {str(ve)}")
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Eroare de procesare: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Processing error: {str(e)}")
 
-@app.post("/sensitivity-analysis", summary="Analiza Sensibilității Parametrilor")
+@app.post("/sensitivity-analysis", summary="Parameter Sensitivity Analysis")
 async def perform_sensitivity_analysis(
     request: SensitivityAnalysisRequest,
     _: bool = Depends(validate_models_loaded)
 ):
     """
-    **Efectuează analiza sensibilității pentru un parametru specific.**
+    **Performs sensitivity analysis for a specific parameter.**
     
-    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.
+    This analysis shows how variation of an input parameter affects
+    both the central prediction and associated uncertainty, providing valuable
+    insights for mix design optimization.
     """
     
     try:
         base_params = request.base_parameters.dict()
         param_to_vary = request.parameter_to_vary
-        variation_range = request.variation_range / 100  # Convertim din procente
+        variation_range = request.variation_range / 100  # Convert from percentage
         num_points = request.num_points
         
-        # Valorile de bază
+        # Base values
         base_value = base_params[param_to_vary]
         
-        # Calculăm intervalul de variație
+        # Calculate variation range
         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":
+        # Respect physical parameter limits
+        if param_to_vary == "cement_percent":
             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)
+            min_variation = max(0 if base_params["cement_percent"] == 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ă
+        # Generate analysis points
         variation_values = np.linspace(min_variation, max_variation, num_points)
         
         results = []
         
         for value in variation_values:
-            # Creăm parametrii modificați
+            # Create modified parameters
             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:
+            # Validate cement-curing relationship for each point
+            if modified_params["cement_percent"] == 0:
                 modified_params["curing_period"] = 0
             
-            # Realizăm predicția
+            # Perform prediction
             input_df = pd.DataFrame([modified_params])
             prediction_df = pd.DataFrame()
             for feature in FEATURE_ORDER:
@@ -603,7 +603,7 @@ async def perform_sensitivity_analysis(
                 "confidence_95_upper": prediction_result['confidence_intervals']['95%'].upper
             })
         
-        # Calculăm statisticile sensibilității
+        # Calculate sensitivity statistics
         predictions = [r["central_prediction"] for r in results]
         uncertainties = [r["uncertainty_estimate"] for r in results]
         
@@ -633,23 +633,23 @@ async def perform_sensitivity_analysis(
             "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"
+                "parameter_impact": f"A {variation_range*100:.1f}% variation in {param_to_vary} "
+                                  f"produces a change of {sensitivity_stats['prediction_sensitivity']['range']:.1f} kPa in UCS",
+                "recommendation": "The parameter with the greatest impact should be carefully controlled in the field"
                                 if sensitivity_stats['prediction_sensitivity']['relative_change'] > 10 
-                                else "Parametrul are impact moderat, variațiile mici sunt acceptabile"
+                                else "The parameter has moderate impact, small variations are acceptable"
             }
         }
         
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Eroare în analiza sensibilității: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error in sensitivity analysis: {str(e)}")
 
-@app.get("/status", summary="Status Sistem")
+@app.get("/status", summary="System Status")
 async def get_system_status():
     """
-    **Returnează statusul complet al sistemului de incertitudine.**
+    **Returns complete system status for uncertainty quantification.**
     
-    Useful pentru monitorizarea sănătății aplicației și diagnosticarea problemelor.
+    Useful for monitoring application health and diagnosing problems.
     """
     
     status_info = {
@@ -667,7 +667,7 @@ async def get_system_status():
         }
     }
     
-    # Testul rapid de funcționalitate dacă modelele sunt încărcate
+    # Quick functionality test if models are loaded
     if system_loaded:
         try:
             test_result = validate_models_compatibility()
@@ -677,12 +677,12 @@ async def get_system_status():
     
     return status_info
 
-@app.get("/model-info", summary="Informații Modele")
+@app.get("/model-info", summary="Model Information")
 async def get_model_information(_: bool = Depends(validate_models_loaded)):
     """
-    **Returnează informații detaliate despre modelele utilizate.**
+    **Returns detailed information about the models used.**
     
-    Include parametrii modelelor, performanțele istorice și limitele de aplicabilitate.
+    Includes model parameters, historical performance and applicability limits.
     """
     
     try:
@@ -705,7 +705,7 @@ async def get_model_information(_: bool = Depends(validate_models_loaded)):
                 "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"},
+                "cement_percent": {"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"}
             },
@@ -718,7 +718,7 @@ async def get_model_information(_: bool = Depends(validate_models_loaded)):
             }
         }
         
-        # Adăugăm metadata-ul dacă este disponibil
+        # Add metadata if available
         if system_metadata:
             model_info["training_metadata"] = {
                 "training_samples": system_metadata.get("n_training_samples", "Unknown"),
@@ -729,17 +729,17 @@ async def get_model_information(_: bool = Depends(validate_models_loaded)):
         return model_info
         
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Eroare la obținerea informațiilor: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error obtaining information: {str(e)}")
 
 # ==============================================================================
-# HANDLER-E PENTRU EXCEPȚII
+# EXCEPTION HANDLERS
 # ==============================================================================
 
 @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.
+    Custom handler for Pydantic validation errors.
+    Provides more user-friendly error messages.
     """
     
     friendly_errors = []
@@ -747,13 +747,13 @@ async def validation_exception_handler(request: Request, exc: ValidationError):
         field = " -> ".join(str(loc) for loc in error.get('loc', []))
         message = error.get('msg', '')
         
-        # Personalizăm mesajele pentru cazuri comune
+        # Customize messages for common cases
         if "greater than or equal" in message:
-            message = f"Valoarea pentru {field} este prea mică"
+            message = f"Value for {field} is too small"
         elif "less than or equal" in message:
-            message = f"Valoarea pentru {field} este prea mare"
+            message = f"Value for {field} is too large"
         elif "string does not match regex" in message:
-            message = f"Valoarea pentru {field} nu este validă"
+            message = f"Value for {field} is not valid"
         
         friendly_errors.append({
             "field": field,
@@ -765,49 +765,49 @@ async def validation_exception_handler(request: Request, exc: ValidationError):
         status_code=422,
         content={
             "success": False,
-            "error": "Eroare de validare a datelor de intrare",
+            "error": "Input data validation error",
             "details": friendly_errors,
-            "help": "Verificați că toate valorile sunt în intervalele specificate și încercați din nou"
+            "help": "Check that all values are within specified ranges and try again"
         }
     )
 
 @app.exception_handler(Exception)
 async def general_exception_handler(request: Request, exc: Exception):
     """
-    Handler general pentru excepții neașteptate.
+    General handler for unexpected exceptions.
     """
     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
+            "error": "Internal server error",
+            "message": "An unexpected error occurred. Contact administrator if problem persists.",
+            "request_id": str(time.time())  # For tracking in logs
         }
     )
 
 # ==============================================================================
-# CONFIGURAȚIE FINALĂ ȘI STARTUP
+# FINAL CONFIGURATION AND 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.
+    Event executed at application startup.
+    Performs final checks and prepares system for production.
     """
-    print("🚀 Pornirea aplicației UCS Prediction API v2.0...")
+    print("🚀 Starting UCS Prediction API v2.0...")
     
     if system_loaded:
-        print("✅ Sistem de incertitudine încărcat și funcțional")
-        print(f"📊 Features configurate: {FEATURE_ORDER.tolist()}")
+        print("✅ Uncertainty system loaded and functional")
+        print(f"📊 Features configured: {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("❌ WARNING: System was not loaded correctly!")
+        print("   Check that model files are present in the models_for_deployment/ directory")
     
-    print("🌐 API disponibil pentru cereri")
+    print("🌐 API available for requests")
 
 if __name__ == "__main__":
-    # Pentru rularea în dezvoltare
+    # For development running
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)