create space

app.py

@@ -18,15 +18,18 @@ import xml.etree.ElementTree as ET
 from fastapi.responses import JSONResponse
 from sklearn.base import BaseEstimator, TransformerMixin
 import sys
-from huggingface_hub import hf_hub_download
-from transformers import AutoTokenizer, AutoModelForCausalLM
-import torch
+from huggingface_hub import hf_hub_download, InferenceClient
+from transformers import pipeline as hf_textgen_pipeline
 
 app = FastAPI()
 
+# Configure CORS for local dev and Spaces by env var (default: allow all)
+cors_env = os.getenv("CORS_ALLOW_ORIGINS", "*")
+allow_origins = ["*"] if cors_env.strip() == "*" else [o.strip() for o in cors_env.split(",") if o.strip()]
+
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["http://localhost:4200"],  # URL de votre frontend Angular
+    allow_origins=allow_origins,
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -54,54 +57,42 @@ class NumericConverter(BaseEstimator, TransformerMixin):
 
 sys.modules['__main__'].NumericConverter = NumericConverter
 
-# Charger les modèles ML depuis Hugging Face
-def load_models_from_hf():
-    """Charge tous les modèles depuis Hugging Face"""
-    global pipeline, analyze_risk_model, llm_tokenizer, llm_model
-    
-    print("Loading models from Hugging Face...")
-    
-    # Charger le modèle d'analyse médicale
-    try:
-        model_path = hf_hub_download(
-            repo_id="HendSta/analyse_medicale",
-            filename="modele_analyse_medicale_final.joblib"
-        )
-        pipeline = joblib.load(model_path)
-        print("✅ Modèle d'analyse médicale chargé avec succès")
-    except Exception as e:
-        print(f"❌ Erreur lors du chargement du modèle d'analyse médicale: {e}")
-        raise
-    
-    # Charger le modèle d'analyse de risque
-    try:
-        analyze_risk_model_path = hf_hub_download(
-            repo_id="HendSta/analyse_row",
-            filename="analyze_row_final.joblib"
-        )
-        analyze_risk_model = joblib.load(analyze_risk_model_path)
-        print("✅ Modèle d'analyse de risque chargé avec succès")
-    except Exception as e:
-        print(f"❌ Erreur lors du chargement du modèle d'analyse de risque: {e}")
-        raise
-    
-    # Charger le modèle LLM
-    try:
-        llm_tokenizer = AutoTokenizer.from_pretrained("HendSta/biomistral-finetuned-fullv3")
-        llm_model = AutoModelForCausalLM.from_pretrained("HendSta/biomistral-finetuned-fullv3")
-        print("✅ Modèle LLM chargé avec succès")
-    except Exception as e:
-        print(f"❌ Erreur lors du chargement du modèle LLM: {e}")
-        raise
-
-# Initialiser les modèles avec gestion d'erreur
-try:
-    load_models_from_hf()
-    print("🎉 Tous les modèles ont été chargés avec succès!")
-except Exception as e:
-    print(f"💥 Erreur critique lors du chargement des modèles: {e}")
-    print("L'application ne peut pas démarrer sans les modèles.")
-    raise
+# ==== Hugging Face Hub model loading ====
+HF_REPO_MEDICALE = os.getenv("HF_REPO_MEDICALE", "HendSta/analyse_medicale")
+HF_REPO_ROW = os.getenv("HF_REPO_ROW", "HendSta/analyse_row")
+HF_REPO_LLM = os.getenv("HF_REPO_LLM", "HendSta/biomistral-finetuned-fullv3")
+
+def load_joblib_from_hub(repo_id: str, candidate_filenames: List[str]):
+    last_error: Optional[Exception] = None
+    for filename in candidate_filenames:
+        try:
+            file_path = hf_hub_download(repo_id=repo_id, filename=filename, local_dir="hub_models", local_dir_use_symlinks=False)
+            return joblib.load(file_path)
+        except Exception as e:
+            last_error = e
+            continue
+    raise RuntimeError(f"Impossible de charger un modèle depuis {repo_id}. Dernière erreur: {last_error}")
+
+# Charger les modèles ML depuis le Hub
+medical_pipeline = load_joblib_from_hub(
+    HF_REPO_MEDICALE,
+    [
+        "modele_analyse_medicale_final.joblib",
+        "pipeline.joblib",
+        "model.joblib",
+        "model.pkl",
+    ],
+)
+
+risk_model = load_joblib_from_hub(
+    HF_REPO_ROW,
+    [
+        "analyze_row_final.joblib",
+        "analyse_row_final.joblib",
+        "model.joblib",
+        "model.pkl",
+    ],
+)
 
 # Créer un imputer pour gérer les valeurs NaN
 imputer = SimpleImputer(strategy='constant', fill_value=0)
@@ -419,35 +410,10 @@ def to_native(val):
     return val
 
 # ==== API Endpoints ====
-@app.get("/health")
-def health_check():
-    """Vérifie que tous les modèles sont chargés correctement"""
-    try:
-        # Vérifier que tous les modèles sont disponibles
-        models_status = {
-            "analyse_medicale_model": pipeline is not None,
-            "analyze_risk_model": analyze_risk_model is not None,
-            "llm_model": llm_model is not None,
-            "llm_tokenizer": llm_tokenizer is not None
-        }
-        
-        all_loaded = all(models_status.values())
-        
-        return {
-            "status": "healthy" if all_loaded else "unhealthy",
-            "models_loaded": models_status,
-            "message": "Tous les modèles sont chargés" if all_loaded else "Certains modèles ne sont pas chargés"
-        }
-    except Exception as e:
-        return {
-            "status": "error",
-            "error": str(e)
-        }
-
 @app.post("/predict", response_model=PredictionResult)
 def predict(data: InputData):
     df = pd.DataFrame([data.dict()])
-    preds = pipeline.predict(df)[0]
+    preds = medical_pipeline.predict(df)[0]
     return PredictionResult(
         **data.dict(),
         CodParametre=preds[0],
@@ -494,7 +460,7 @@ async def upload_file(file: UploadFile = File(...)):
         # Si on a du PDF et qu'on a besoin de prédire les paramètres
         if file_extension == "pdf":
             # Faire la prédiction
-            preds = pipeline.predict(df)
+            preds = medical_pipeline.predict(df)
             
             # Créer les résultats avec les prédictions
             results = []
@@ -531,8 +497,6 @@ async def upload_file(file: UploadFile = File(...)):
 def analyze_risk(param: dict = Body(...)):
     import pandas as pd
     import numpy as np
-    # Utiliser le modèle globalement chargé
-    model = analyze_risk_model
 
     # Préparer le DataFrame à partir du paramètre reçu
     df_test = pd.DataFrame([param])
@@ -579,7 +543,7 @@ def analyze_risk(param: dict = Body(...)):
     features_for_ml = df_result[['DeltaValeurPrecedente', 'RatioValeurPrecedente', 
                                  'PourcentageValeurMin', 'PourcentageValeurMax', 
                                  'EcartNormalise', 'ValeurActuelle', 'CodeParametre']]
-    predicted_risk_num = model.predict(features_for_ml)[0]
+    predicted_risk_num = risk_model.predict(features_for_ml)[0]
     risk_map = {0: 'Aucun', 1: 'Faible', 2: 'Modéré', 3: 'Élevé'}
     degre_risque = risk_map.get(int(predicted_risk_num), 'Inconnu')
 
@@ -618,6 +582,78 @@ def analyze_risk(param: dict = Body(...)):
         "conseil": to_native(conseil)
     }
 
+# ==== LLM (text-generation) endpoint ====
+_llm_generator = None
+_llm_via_api = False
+
+def get_llm_generator():
+    global _llm_generator, _llm_via_api
+    if _llm_generator is not None:
+        return _llm_generator
+
+    # Prefer Inference API by default to avoid OOM in CPU Spaces
+    use_api_default = os.getenv("USE_INFERENCE_API", "1")
+    use_api = use_api_default.lower() in {"1", "true", "yes"}
+
+    if use_api:
+        token = os.getenv("HF_TOKEN") or os.getenv("HF_API_TOKEN")
+        _llm_generator = InferenceClient(model=HF_REPO_LLM, token=token)
+        _llm_via_api = True
+        return _llm_generator
+
+    # Fallback to local transformers pipeline
+    try:
+        trust_code = os.getenv("HF_TRUST_REMOTE_CODE", "1") != "0"
+        _llm_generator = hf_textgen_pipeline(
+            task="text-generation",
+            model=HF_REPO_LLM,
+            trust_remote_code=trust_code,
+        )
+        _llm_via_api = False
+    except Exception:
+        token = os.getenv("HF_TOKEN") or os.getenv("HF_API_TOKEN")
+        _llm_generator = InferenceClient(model=HF_REPO_LLM, token=token)
+        _llm_via_api = True
+    return _llm_generator
+
+class GenerateRequest(BaseModel):
+    prompt: str
+    max_new_tokens: int = 256
+    temperature: float = 0.7
+    top_p: float = 0.95
+    repetition_penalty: float = 1.1
+
+class GenerateResponse(BaseModel):
+    output: str
+
+@app.post("/llm-generate", response_model=GenerateResponse)
+def llm_generate(req: GenerateRequest):
+    try:
+        generator = get_llm_generator()
+        if _llm_via_api:
+            text = generator.text_generation(
+                req.prompt,
+                max_new_tokens=req.max_new_tokens,
+                temperature=req.temperature,
+                top_p=req.top_p,
+                repetition_penalty=req.repetition_penalty,
+                do_sample=True,
+            )
+        else:
+            outputs = generator(
+                req.prompt,
+                max_new_tokens=req.max_new_tokens,
+                temperature=req.temperature,
+                top_p=req.top_p,
+                repetition_penalty=req.repetition_penalty,
+                do_sample=True,
+                pad_token_id=50256,
+            )
+            text = outputs[0].get("generated_text", "") if isinstance(outputs, list) and outputs else str(outputs)
+        return GenerateResponse(output=text)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur LLM: {str(e)}")
+
 # Fonction de debug temporaire pour tester l'extraction
 def debug_extraction(line):
     """Teste l'extraction d'une ligne et affiche les résultats"""