Add KPA model integration and update configuration for label predictions

config.py

@@ -14,9 +14,11 @@ PROJECT_ROOT = API_DIR.parent
 # Hugging Face configuration
 HUGGINGFACE_API_KEY = os.getenv("HUGGINGFACE_API_KEY", "")
 HUGGINGFACE_STANCE_MODEL_ID = os.getenv("HUGGINGFACE_STANCE_MODEL_ID")
+HUGGINGFACE_LABEL_MODEL_ID = os.getenv("HUGGINGFACE_LABEL_MODEL_ID")
 
 # Use Hugging Face model ID instead of local path
 STANCE_MODEL_ID = HUGGINGFACE_STANCE_MODEL_ID
+LABEL_MODEL_ID = HUGGINGFACE_LABEL_MODEL_ID
 
 # API configuration
 API_TITLE = "NLP Project API"

main.py

@@ -19,8 +19,10 @@ from config import (
     API_DESCRIPTION,
     API_VERSION,
     STANCE_MODEL_ID,
+    LABEL_MODEL_ID,
     HUGGINGFACE_API_KEY,
     HUGGINGFACE_STANCE_MODEL_ID,
+    HUGGINGFACE_LABEL_MODEL_ID,
     HOST,
     PORT,
     RELOAD,
@@ -29,7 +31,7 @@ from config import (
     CORS_METHODS,
     CORS_HEADERS,
 )
-from services import stance_model_manager
+from services import stance_model_manager, kpa_model_manager
 from routes import api_router
 
 # Configure logging
@@ -51,6 +53,14 @@ async def lifespan(app: FastAPI):
         logger.error(f"✗ Failed to load stance model: {str(e)}")
         logger.error("⚠️  Stance detection endpoints will not work!")
     
+    # Load KPA (label) model
+    try:
+        logger.info(f"Loading KPA model from Hugging Face: {HUGGINGFACE_LABEL_MODEL_ID}")
+        kpa_model_manager.load_model(HUGGINGFACE_LABEL_MODEL_ID, HUGGINGFACE_API_KEY)
+    except Exception as e:
+        logger.error(f"✗ Failed to load KPA model: {str(e)}")
+        logger.error("⚠️  KPA/Label prediction endpoints will not work!")
+    
     logger.info("✓ API startup complete")
     logger.info("https://nlp-debater-project-fastapi-backend-models.hf.space/docs")
     

routes/label.py

@@ -11,7 +11,7 @@ from models import (
     BatchPredictionResponse
 )
 
-from services import label_model_manage  # ton ModelManager clean
+from services import kpa_model_manager
 
 router = APIRouter()
 logger = logging.getLogger(__name__)
@@ -23,7 +23,7 @@ async def get_model_info():
     Return information about the loaded KPA model.
     """
     try:
-        model_info = label_model_manage.get_model_info()
+        model_info = kpa_model_manager.get_model_info()
 
         return {
             "model_name": model_info.get("model_name", "unknown"),
@@ -42,7 +42,7 @@ async def get_model_info():
 @router.post("/predict", response_model=PredictionResponse, tags=["KPA"])
 async def predict_kpa(request: PredictionRequest):
     """
-    Predict keypoint–argument matching for a single pair.
+    Predict keypoint-argument matching for a single pair.
 
     - **argument**: The argument text  
     - **key_point**: The key point to evaluate  
@@ -50,7 +50,7 @@ async def predict_kpa(request: PredictionRequest):
     Returns the predicted class (apparie / non_apparie) with probabilities.
     """
     try:
-        result = label_model_manage.predict(
+        result = kpa_model_manager.predict(
             argument=request.argument,
             key_point=request.key_point
         )
@@ -88,7 +88,7 @@ async def batch_predict_kpa(request: BatchPredictionRequest):
 
         for item in request.pairs:
             try:
-                result = label_model_manage.predict(
+                result = kpa_model_manager.predict(
                     argument=item.argument,
                     key_point=item.key_point
                 )
@@ -115,7 +115,8 @@ async def batch_predict_kpa(request: BatchPredictionRequest):
         logger.info(f"Batch KPA prediction completed — {len(results)} items processed")
 
         return BatchPredictionResponse(
-            predictions=results
+            predictions=results,
+            total_processed=len(results)
         )
 
     except Exception as e:

services/__init__.py

@@ -1,8 +1,11 @@
 """Services for business logic and external integrations"""
 
 from .stance_model_manager import StanceModelManager, stance_model_manager
+from .label_model_manage import KpaModelManager, kpa_model_manager
 
 __all__ = [
     "StanceModelManager",
     "stance_model_manager",
+    "KpaModelManager",
+    "kpa_model_manager",
 ]

services/label_model_manage.py

@@ -17,52 +17,46 @@ class KpaModelManager:
         self.device = None
         self.model_loaded = False
         self.max_length = 256
+        self.model_id = None
 
-    def load_model(self, model_path: str = None):
-        """Load fine-tuned model weights and tokenizer"""
+    def load_model(self, model_id: str, api_key: str = None):
+        """Load model and tokenizer from Hugging Face"""
         if self.model_loaded:
             logger.info("KPA model already loaded")
             return
 
         try:
-            # Detect device
+            logger.info(f"Loading KPA model from Hugging Face: {model_id}")
+            
+            # Determine device
             self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
             logger.info(f"Using device: {self.device}")
-
-            # Resolve model path
-            if model_path is None:
-                base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-                model_path = os.path.join(base_dir, "models", "modele_appariement_rapide.pth")
-
-            logger.info(f"Loading KPA model weights from: {model_path}")
-
-            if not os.path.exists(model_path):
-                raise FileNotFoundError(f"Model file not found: {model_path}")
-
-            # Load tokenizer + architecture
-            model_name = "distilbert-base-uncased"
+            
+            # Store model ID
+            self.model_id = model_id
+            
+            # Prepare token for authentication if API key is provided
+            token = api_key if api_key else None
+            
+            # Load tokenizer and model from Hugging Face
             logger.info("Loading tokenizer...")
-            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-
-            logger.info("Loading base architecture...")
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                model_id,
+                token=token,
+                trust_remote_code=True
+            )
+            
+            logger.info("Loading model...")
             self.model = AutoModelForSequenceClassification.from_pretrained(
-                model_name,
-                num_labels=2
+                model_id,
+                token=token,
+                trust_remote_code=True
             )
-
-            # Load trained weights
-            checkpoint = torch.load(model_path, map_location=self.device)
-
-            if "model_state_dict" in checkpoint:
-                self.model.load_state_dict(checkpoint["model_state_dict"])
-            else:
-                self.model.load_state_dict(checkpoint)
-
             self.model.to(self.device)
             self.model.eval()
 
             self.model_loaded = True
-            logger.info("✓ KPA model loaded successfully!")
+            logger.info("✓ KPA model loaded successfully from Hugging Face!")
 
         except Exception as e:
             logger.error(f"Error loading KPA model: {str(e)}")
@@ -109,12 +103,12 @@ class KpaModelManager:
         
     def get_model_info(self):
         return {
-            "model_name": self.model_name,
+            "model_name": self.model_id,
             "device": str(self.device),
             "max_length": self.max_length,
             "num_labels": 2,
             "loaded": self.model_loaded
-               }
+        }