Upload 2 files

game_engine.py

@@ -1,9 +1,9 @@
 # ==========================================
-# game_engine.py - Avec métriques OCR et dataset optimisé
+# game_engine.py - Avec métriques OCR et dataset optimisé + modèles commutables
 # ==========================================
 
 """
-Moteur de jeu avec tracking complet des performances OCR
+Moteur de jeu avec tracking complet des performances OCR et support modèles commutables
 """
 
 import random
@@ -22,10 +22,13 @@ from image_processing_gpu import (
     create_thumbnail_fast, 
     create_white_canvas,
     cleanup_memory,
-    get_ocr_model_info
+    get_ocr_model_info,
+    get_available_models,
+    set_ocr_model,
+    get_current_model_info
 )
 
-print("✅ Game Engine: Mode GPU avec métriques OCR")
+print("✅ Game Engine: Mode GPU avec métriques OCR et modèles commutables")
 
 # Imports dataset
 try:
@@ -47,6 +50,37 @@ DIFFICULTY_RANGES = {
     "÷": {"Facile": (1, 10), "Difficile": (2, 12)}
 }
 
+def get_ocr_models_info() -> dict:
+    """Retourne les informations sur les modèles OCR disponibles"""
+    try:
+        available_models = get_available_models()
+        current_model = get_current_model_info()
+        
+        return {
+            "available_models": available_models,
+            "current_model": current_model,
+            "model_names": list(available_models.keys())
+        }
+    except Exception as e:
+        print(f"❌ Erreur get_ocr_models_info: {e}")
+        return {
+            "available_models": {},
+            "current_model": {"model_name": "hoololi/trocr-base-handwritten-calctrainer"},
+            "model_names": []
+        }
+
+def switch_ocr_model(model_name: str) -> str:
+    """Change le modèle OCR et retourne un message de statut"""
+    try:
+        success = set_ocr_model(model_name)
+        if success:
+            model_info = get_current_model_info()
+            return f"✅ Modèle changé vers: {model_info['display_name']}\n📍 {model_info['description']}"
+        else:
+            return f"❌ Échec du changement vers: {model_name}"
+    except Exception as e:
+        return f"❌ Erreur lors du changement: {str(e)}"
+
 def create_result_row_with_metrics(i: int, image: dict | np.ndarray | Image.Image, expected: int, operation_data: tuple[int, int, str, int]) -> dict:
     """Traite une image avec OCR et mesure les métriques"""
     
@@ -104,7 +138,7 @@ def create_result_row_with_metrics(i: int, image: dict | np.ndarray | Image.Imag
 
 
 class MathGame:
-    """Moteur de jeu avec métriques OCR complètes"""
+    """Moteur de jeu avec métriques OCR complètes et modèles commutables"""
     
     def __init__(self):
         self.is_running = False
@@ -345,14 +379,14 @@ class MathGame:
         
         print(f"🔄 Traitement OCR avec métriques de {total_questions} images...")
         
-        # Récupérer infos modèle OCR une seule fois
+        # Récupérer infos modèle OCR une seule fois - MODIFIÉ pour utiliser le nouveau système
         try:
             ocr_model_info = get_ocr_model_info()
-            model_name = ocr_model_info.get("model_name", "microsoft/trocr-base-handwritten")
+            model_name = ocr_model_info.get("model_name", "hoololi/trocr-base-handwritten-calctrainer")
             hardware = f"{ocr_model_info.get('device', 'Unknown')}-{ocr_model_info.get('gpu_name', 'Unknown')}"
         except Exception as e:
             print(f"❌ Erreur get_ocr_model_info: {e}")
-            model_name = "microsoft/trocr-base-handwritten"
+            model_name = "hoololi/trocr-base-handwritten-calctrainer"
             hardware = "ZeroGPU-Unknown"
         
         # Boucle OCR avec métriques
@@ -407,7 +441,7 @@ class MathGame:
                 "session_total_questions": total_questions,
                 
                 # Métadonnées techniques
-                "app_version": "3.1_with_ocr_metrics",
+                "app_version": "3.2_with_switchable_models",
                 "hardware": hardware
             }
             

image_processing_gpu.py

@@ -1,5 +1,5 @@
 # ==========================================
-# image_processing_gpu.py - Version ZeroGPU simplifiée
+# image_processing_gpu.py - Version ZeroGPU avec modèles OCR commutables
 # ==========================================
 
 """
@@ -21,23 +21,137 @@ from utils import (
     validate_ocr_result
 )
 
+# ==========================================
+# Configuration des modèles OCR disponibles
+# ==========================================
+
+AVAILABLE_OCR_MODELS = {
+    "microsoft/trocr-base-handwritten": {
+        "description": "Modèle de base Microsoft pour écriture manuscrite",
+        "display_name": "TrOCR Base Handwritten (Microsoft)",
+        "optimized_for": "general_handwriting"
+    },
+    "hoololi/trocr-base-handwritten-calctrainer": {
+        "description": "Modèle fine tuné pour les nombres entiers",
+        "display_name": "TrOCR CalcTrainer (Hoololi)",
+        "optimized_for": "mathematical_numbers"
+    }
+}
+
+# Modèle par défaut
+DEFAULT_OCR_MODEL = "hoololi/trocr-base-handwritten-calctrainer"
+current_ocr_model_name = DEFAULT_OCR_MODEL
+
 # Variables globales pour OCR
 processor = None
 model = None
-#OCR_MODEL_NAME = "TrOCR-base-handwritten"
-OCR_MODEL_NAME = "hoololi/trocr-base-handwritten-calctrainer"
+current_loaded_model = None
+
+def get_available_models() -> dict:
+    """Retourne la liste des modèles OCR disponibles"""
+    return AVAILABLE_OCR_MODELS
+
+def get_current_model_info() -> dict:
+    """Retourne les informations du modèle OCR actuellement chargé"""
+    global current_ocr_model_name, current_loaded_model
+    
+    model_config = AVAILABLE_OCR_MODELS.get(current_ocr_model_name, AVAILABLE_OCR_MODELS[DEFAULT_OCR_MODEL])
+    
+    if torch.cuda.is_available():
+        device = "ZeroGPU"
+        gpu_name = torch.cuda.get_device_name()
+    else:
+        device = "CPU"
+        gpu_name = "N/A"
+    
+    return {
+        "model_name": current_ocr_model_name,
+        "display_name": model_config["display_name"],
+        "description": model_config["description"],
+        "current_loaded": current_loaded_model,
+        "device": device,
+        "gpu_name": gpu_name,
+        "framework": "HuggingFace-Transformers-ZeroGPU",
+        "optimized_for": model_config["optimized_for"],
+        "is_loaded": processor is not None and model is not None,
+        # Compatibilité avec l'ancien code
+        "version": current_ocr_model_name
+    }
+
+def set_ocr_model(model_name: str) -> bool:
+    """
+    Change le modèle OCR actif
+    
+    Args:
+        model_name: Nom exact du modèle (ex: "microsoft/trocr-base-handwritten")
+        
+    Returns:
+        bool: True si le changement a réussi
+    """
+    global current_ocr_model_name
+    
+    if model_name not in AVAILABLE_OCR_MODELS:
+        print(f"❌ Modèle '{model_name}' non disponible. Modèles disponibles: {list(AVAILABLE_OCR_MODELS.keys())}")
+        return False
+    
+    if model_name == current_ocr_model_name and processor is not None and model is not None:
+        print(f"✅ Modèle '{model_name}' déjà chargé")
+        return True
+    
+    model_config = AVAILABLE_OCR_MODELS[model_name]
+    print(f"🔄 Changement vers le modèle: {model_config['display_name']}")
+    current_ocr_model_name = model_name
+    
+    # Nettoyer le modèle précédent
+    cleanup_current_model()
+    
+    # Charger le nouveau modèle
+    return init_ocr_model()
 
-def init_ocr_model() -> bool:
-    """Initialise TrOCR pour ZeroGPU"""
-    global processor, model
+def cleanup_current_model():
+    """Nettoie le modèle actuellement chargé pour libérer la mémoire"""
+    global processor, model, current_loaded_model
+    
+    if model is not None:
+        del model
+        model = None
+    
+    if processor is not None:
+        del processor
+        processor = None
+    
+    current_loaded_model = None
+    
+    # Nettoyage mémoire GPU si disponible
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+    
+    print("🧹 Modèle précédent nettoyé")
+
+def init_ocr_model(model_name: str = None) -> bool:
+    """
+    Initialise TrOCR pour ZeroGPU avec le modèle spécifié
+    
+    Args:
+        model_name: Nom exact du modèle à charger (optionnel, utilise current_ocr_model_name par défaut)
+    """
+    global processor, model, current_ocr_model_name, current_loaded_model
+    
+    if model_name is not None:
+        if model_name not in AVAILABLE_OCR_MODELS:
+            print(f"❌ Modèle '{model_name}' non disponible")
+            return False
+        current_ocr_model_name = model_name
+    
+    model_config = AVAILABLE_OCR_MODELS[current_ocr_model_name]
     
     try:
-        print("🔄 Chargement TrOCR (ZeroGPU)...")
+        print(f"🔄 Chargement {model_config['display_name']} (ZeroGPU)...")
+        print(f"   📍 Modèle: {current_ocr_model_name}")
         
-        #processor = TrOCRProcessor.from_pretrained('microsoft/trocr-base-handwritten')
-        #model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-base-handwritten')
-        processor = TrOCRProcessor.from_pretrained('hoololi/trocr-base-handwritten-calctrainer')
-        model = VisionEncoderDecoderModel.from_pretrained('hoololi/trocr-base-handwritten-calctrainer')
+        processor = TrOCRProcessor.from_pretrained(current_ocr_model_name)
+        model = VisionEncoderDecoderModel.from_pretrained(current_ocr_model_name)
+        current_loaded_model = current_ocr_model_name
         
         # Optimisations
         model.eval()
@@ -45,39 +159,26 @@ def init_ocr_model() -> bool:
         if torch.cuda.is_available():
             model = model.cuda()
             device_info = f"GPU ({torch.cuda.get_device_name()})"
-            print(f"✅ TrOCR prêt sur {device_info} !")
+            print(f"✅ {model_config['display_name']} prêt sur {device_info} !")
         else:
             device_info = "CPU (ZeroGPU pas encore alloué)"
-            print(f"⚠️ TrOCR sur CPU - {device_info}")
+            print(f"⚠️ {model_config['display_name']} sur CPU - {device_info}")
         
         return True
         
     except Exception as e:
-        print(f"❌ Erreur lors du chargement TrOCR: {e}")
+        print(f"❌ Erreur lors du chargement {model_config['display_name']}: {e}")
         return False
 
+# Alias pour compatibilité avec l'ancien code
 def get_ocr_model_info() -> dict:
-    """Retourne les informations du modèle OCR utilisé"""
-    if torch.cuda.is_available():
-        device = "ZeroGPU"
-        gpu_name = torch.cuda.get_device_name()
-    else:
-        device = "CPU"
-        gpu_name = "N/A"
-    
-    return {
-        "model_name": OCR_MODEL_NAME,
-        "device": device,
-        "gpu_name": gpu_name,
-        "framework": "HuggingFace-Transformers-ZeroGPU",
-        "optimized_for": "accuracy",
-        "version": "microsoft/trocr-base-handwritten"
-    }
+    """Alias pour get_current_model_info() - compatibilité"""
+    return get_current_model_info()
 
 @spaces.GPU
 def recognize_number_fast_with_image(image_dict, debug: bool = False) -> tuple[str, any, dict | None]:
     """
-    OCR avec TrOCR ZeroGPU - Version simplifiée
+    OCR avec TrOCR ZeroGPU - Version simplifiée avec modèle commutable
     """
     if image_dict is None:
         if debug:
@@ -87,7 +188,8 @@ def recognize_number_fast_with_image(image_dict, debug: bool = False) -> tuple[s
     try:
         start_time = time.time()
         if debug:
-            print("  🔄 Début OCR TrOCR ZeroGPU...")
+            model_info = get_current_model_info()
+            print(f"  🔄 Début OCR {model_info['display_name']} ZeroGPU...")
         
         # Optimiser image
         optimized_image = optimize_image_for_ocr(image_dict, max_size=384)
@@ -133,7 +235,8 @@ def recognize_number_fast_with_image(image_dict, debug: bool = False) -> tuple[s
         if debug:
             total_time = time.time() - start_time
             device = "ZeroGPU" if torch.cuda.is_available() else "CPU"
-            print(f"  ✅ TrOCR ({device}) terminé en {total_time:.1f}s → '{final_result}'")
+            model_name = get_current_model_info()['display_name']
+            print(f"  ✅ {model_name} ({device}) terminé en {total_time:.1f}s → '{final_result}'")
             if dataset_image_data:
                 print(f"  🖼️ Image dataset: {type(dataset_image_data.get('handwriting_image', 'None'))}")