Upload 5 files

game_engine.py

@@ -2,10 +2,6 @@
 # game_engine.py - Calcul OCR v3.0 CLEAN
 # ==========================================
 
-"""
-Moteur de jeu mathématique avec traitement parallèle et auto-détection OCR
-"""
-
 import random
 import time
 import datetime
@@ -25,10 +21,6 @@ from typing import Dict, Tuple, Optional
 ocr_module = None
 ocr_info = {"model_name": "Unknown", "device": "Unknown"}
 
-# Auto-détection adaptée ZeroGPU
-ocr_module = None
-ocr_info = {"model_name": "Unknown", "device": "Unknown"}
-
 # Debug des variables d'environnement HF
 import os
 space_id = os.getenv("SPACE_ID")
@@ -53,11 +45,9 @@ if is_zerogpu:
     # On est sur ZeroGPU, forcer le mode GPU
     try:
         print("🚀 Force mode ZeroGPU - Import GPU...")
-        # Créer un simple import qui satisfait ZeroGPU
         from simple_gpu import gpu_dummy_function
         print("✅ Simple GPU importé")
         
-        # Utiliser le vrai TrOCR qu'on a chargé !
         from image_processing_gpu import (
             recognize_number_fast_with_image as gpu_recognize,
             create_thumbnail_fast, 
@@ -67,7 +57,6 @@ if is_zerogpu:
             get_ocr_model_info
         )
         
-        # Pas de wrapper, utiliser directement TrOCR
         recognize_number_fast_with_image = gpu_recognize
         
         ocr_module = "zerogpu_trocr"
@@ -75,7 +64,6 @@ if is_zerogpu:
         
     except Exception as e:
         print(f"❌ Erreur ZeroGPU: {e}")
-        # Fallback CPU pur
         from image_processing_cpu import (
             recognize_number_fast_with_image, 
             create_thumbnail_fast, 
@@ -92,7 +80,6 @@ else:
         recognize_number_fast_with_image, 
         create_thumbnail_fast, 
         create_white_canvas,
-        cleanup_memory,
         log_memory_usage,
         get_ocr_model_info
     )
@@ -109,7 +96,7 @@ except Exception as e:
 
 # Imports dataset avec gestion d'erreur
 try:
-    from datasets import Dataset, load_dataset
+    from datasets import Dataset, load_dataset, Image # AJOUT DE Image ici
     DATASET_AVAILABLE = True
     print("✅ Modules dataset disponibles")
 except ImportError as e:
@@ -134,7 +121,8 @@ def create_result_row_with_images(i: int, image: dict | np.ndarray | Image.Image
     print(f"🔍 Image type: {type(image)}")
     
     # OCR optimisé avec debug
-    recognized, optimized_image, dataset_image_data = recognize_number_fast_with_image(image, debug=True)
+    # dataset_image_data contiendra maintenant directement l'objet PIL.Image ou None
+    recognized, optimized_image, dataset_image_object = recognize_number_fast_with_image(image, debug=True)
     
     print(f"🔍 OCR recognized: '{recognized}' (type: {type(recognized)})")
     
@@ -152,7 +140,7 @@ def create_result_row_with_images(i: int, image: dict | np.ndarray | Image.Image
     status_text = "Correct" if is_correct else "Incorrect"
     row_color = "#e8f5e8" if is_correct else "#ffe8e8"
     
-    # Miniature
+    # Miniature pour l'affichage HTML
     image_thumbnail = create_thumbnail_fast(optimized_image, size=(50, 50))
     
     # Libérer mémoire
@@ -161,6 +149,7 @@ def create_result_row_with_images(i: int, image: dict | np.ndarray | Image.Image
             optimized_image.close()
         except:
             pass
+    # Attention: ne pas close dataset_image_object ici, il sera utilisé plus tard pour l'export
 
     return {
         'html_row': f"""
@@ -178,7 +167,7 @@ def create_result_row_with_images(i: int, image: dict | np.ndarray | Image.Image
         'is_correct': is_correct,
         'recognized': recognized,
         'recognized_num': recognized_num,
-        'dataset_image_data': dataset_image_data
+        'dataset_image_object': dataset_image_object # MODIFIÉ : stocke l'objet PIL.Image directement
     }
 
 
@@ -334,6 +323,7 @@ class MathGame:
         self.difficulty = difficulty
         
         # Nettoyage
+        # Suppression des références aux objets Image pour libérer la mémoire
         if hasattr(self, 'user_images') and self.user_images:
             for img in self.user_images:
                 if hasattr(img, 'close'):
@@ -341,11 +331,16 @@ class MathGame:
                         img.close()
                     except:
                         pass
+            self.user_images.clear() # Vider la liste
         
         if hasattr(self, 'session_data') and self.session_data:
+            # S'assurer de libérer les objets Image dans session_data aussi
             for entry in self.session_data:
-                if 'user_drawing' in entry and entry['user_drawing']:
-                    entry['user_drawing'] = None
+                if 'handwriting_image' in entry and isinstance(entry['handwriting_image'], Image.Image):
+                    try:
+                        entry['handwriting_image'].close()
+                    except:
+                        pass
             self.session_data.clear()
         
         # Réinit avec nettoyage parallèle
@@ -359,12 +354,12 @@ class MathGame:
         
         self.is_running = True
         self.start_time = time.time()
-        self.user_images = []
+        self.user_images = [] # Récemment nettoyé, mais assure la réinit
         self.expected_answers = []
         self.operations_history = []
         self.question_count = 0
         self.time_remaining = self.duration
-        self.session_data = []
+        self.session_data = [] # Récemment nettoyé, mais assure la réinit
         
         # Reset export
         self.export_status = "not_exported"
@@ -419,16 +414,13 @@ class MathGame:
             return self.end_game(image_data)
 
         if image_data is not None:
-            # Ajouter l'image à la liste ET au traitement parallèle
             self.user_images.append(image_data)
             self.expected_answers.append(self.correct_answer)
             
-            # Parser l'opération actuelle pour le traitement
             parts = self.current_operation.split()
             a, op, b = int(parts[0]), parts[1], int(parts[2])
             current_operation_data = (a, b, op, self.correct_answer)
             
-            # Lancer le traitement en parallèle de l'image qu'on vient de recevoir
             self._add_image_to_processing_queue(self.question_count, image_data, self.correct_answer, current_operation_data)
             
             self.question_count += 1
@@ -449,7 +441,6 @@ class MathGame:
         if time_remaining <= 0:
             return self.end_game(image_data)
 
-        # Emoji pour l'opération
         operation_emoji = {
             "×": "✖️", "+": "➕", "-": "➖", "÷": "➗", "Aléatoire": "🎲"
         }
@@ -469,7 +460,6 @@ class MathGame:
 
         self.is_running = False
         
-        # Arrêter le traitement parallèle
         self._stop_background_processing()
         
         print("🏁 Fin de jeu - Assemblage des résultats...")
@@ -478,12 +468,10 @@ class MathGame:
             self.user_images.append(final_image)
             self.expected_answers.append(self.correct_answer)
             
-            # Traitement de la dernière image
             parts = self.current_operation.split()
             a, op, b = int(parts[0]), parts[1], int(parts[2])
             final_operation_data = (a, b, op, self.correct_answer)
             
-            # Traiter la dernière image immédiatement (pas en parallèle)
             print(f"🔄 Traitement final de l'image {self.question_count}...")
             final_result = create_result_row_with_images(self.question_count, final_image, self.correct_answer, final_operation_data)
             self.results_cache[self.question_count] = final_result
@@ -492,7 +480,6 @@ class MathGame:
             if len(self.operations_history) < len(self.user_images):
                 self.operations_history.append((a, b, op, self.correct_answer))
 
-        # Attendre que toutes les images soient traitées
         max_wait = 10
         wait_start = time.time()
         expected_results = len(self.user_images)
@@ -504,7 +491,6 @@ class MathGame:
         results_ready = len(self.results_cache)
         print(f"✅ {results_ready}/{expected_results} résultats prêts")
 
-        # Assembler les résultats dans l'ordre
         correct_answers = 0
         total_questions = len(self.user_images)
         table_rows_html = ""
@@ -514,7 +500,6 @@ class MathGame:
         
         self.session_data = []
         images_saved = 0
-        total_image_size_kb = 0
         
         print(f"📊 Assemblage de {total_questions} résultats...")
         
@@ -532,7 +517,7 @@ class MathGame:
                         'is_correct': False,
                         'recognized': "0",
                         'recognized_num': 0,
-                        'dataset_image_data': None
+                        'dataset_image_object': None # MODIFIÉ
                     }
             
             table_rows_html += row_data['html_row']
@@ -540,7 +525,6 @@ class MathGame:
             if row_data['is_correct']:
                 correct_answers += 1
 
-            # Structure pour dataset avec debug OCR
             a, b, operation, correct_result = self.operations_history[i] if i < len(self.operations_history) else (0, 0, "×", 0)
             
             try:
@@ -572,16 +556,23 @@ class MathGame:
             
             print(f"🔍 Debug entry OCR fields: ocr_model={entry['ocr_model']}, ocr_device={entry['ocr_device']}")
             
-            
-            if row_data['dataset_image_data']:
-                entry["handwriting_image"] = row_data['dataset_image_data']["image_base64"]
-                entry["image_width"] = int(row_data['dataset_image_data']["compressed_size"][0])
-                entry["image_height"] = int(row_data['dataset_image_data']["compressed_size"][1])
-                entry["image_size_kb"] = float(row_data['dataset_image_data']["file_size_kb"])
+            # MODIFICATION ICI : Ne plus stocker le Base64, mais l'objet PIL.Image directement.
+            # Les infos de taille seront obtenues de l'objet PIL.Image lui-même.
+            if row_data['dataset_image_object'] is not None:
+                entry["handwriting_image"] = row_data['dataset_image_object'] # Stoque l'objet PIL.Image
+                entry["image_width"] = row_data['dataset_image_object'].size[0]
+                entry["image_height"] = row_data['dataset_image_object'].size[1]
+                
+                # Calcul de la taille en KB pour l'information, mais pas pour le stockage direct
+                buffer_temp = BytesIO()
+                row_data['dataset_image_object'].save(buffer_temp, format='PNG', optimize=True, quality=60) # Utiliser la même qualité que prepare_image_for_dataset
+                entry["image_size_kb"] = round(len(buffer_temp.getvalue()) / 1024, 1)
+                buffer_temp.close()
+                
                 entry["has_image"] = True
                 images_saved += 1
-                total_image_size_kb += row_data['dataset_image_data']["file_size_kb"]
             else:
+                entry["handwriting_image"] = None # Assurer que c'est None pour les entrées sans image
                 entry["has_image"] = False
                 
             self.session_data.append(entry)
@@ -591,17 +582,24 @@ class MathGame:
         for entry in self.session_data:
             entry["session_accuracy"] = accuracy
 
-        # Nettoyage mémoire
+        # Nettoyage mémoire : s'assurer de fermer les objets PIL.Image
         for img in self.user_images:
             if hasattr(img, 'close'):
                 try:
                     img.close()
                 except:
                     pass
+        self.user_images.clear() # Vider la liste après utilisation
+
+        for entry in self.session_data:
+            if 'handwriting_image' in entry and isinstance(entry['handwriting_image'], Image.Image):
+                try:
+                    entry['handwriting_image'].close()
+                except:
+                    pass
         
         gc.collect()
 
-        # HTML résultats
         table_html = f"""
         <div style="overflow-x: auto; margin: 20px 0;">
             <table style="width: 100%; border-collapse: collapse; border: 2px solid #4a90e2;">
@@ -624,7 +622,6 @@ class MathGame:
         </div>
         """
 
-        # Configuration session pour affichage
         config_display = f"{self.operation_type} • {self.difficulty} • {self.duration}s"
         operation_emoji = {
             "×": "✖️", "+": "➕", "-": "➖", "÷": "➗", "Aléatoire": "🎲"
@@ -632,13 +629,15 @@ class MathGame:
         emoji = operation_emoji.get(self.operation_type, "🔢")
 
         export_info = self.get_export_status()
+        # Ne plus afficher total_image_size_kb car le calcul est maintenant fait pour chaque image
+        # et n'est pas cumulé dans le même style que l'ancienne version.
         if export_info["can_export"]:
             export_section = f"""
             <div style="margin-top: 20px; padding: 15px; background-color: #e8f5e8; border-radius: 8px;">
                 <h3 style="color: #2e7d32;"> Résumé de la série</h3>
                 <p style="color: #2e7d32;">
                     ✅ {total_questions} réponses • 📊 {accuracy:.1f}% de précision<br>
-                    📸 {images_saved} opérations et images sauvegardées ({total_image_size_kb:.1f}KB)<br>
+                    📸 {images_saved} opérations et images sauvegardées<br>
                     ⚙️ Configuration: {config_display}
                 </p>
             </div>
@@ -689,7 +688,7 @@ class MathGame:
 def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None) -> str:
     """Export vers le nouveau dataset calcul_ocr_dataset"""
     if dataset_name is None:
-        dataset_name = DATASET_NAME  # Utiliser la variable globale
+        dataset_name = DATASET_NAME
         
     if not DATASET_AVAILABLE:
         return "❌ Modules dataset non disponibles"
@@ -702,10 +701,8 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
         print(f"\n🚀 === EXPORT VERS DATASET CALCUL OCR ===")
         print(f"📊 Dataset: {dataset_name}")
         
-        # Filtrer les entrées avec images et ajouter les infos OCR globalement
-        clean_entries = []
+        clean_entries_for_dataset = [] # Va contenir les dicts prêts pour Dataset.from_list
         
-        # Récupérer une seule fois les infos OCR pour toute la session
         try:
             global_ocr_info = get_ocr_model_info()
             print(f"🔍 Infos OCR globales: {global_ocr_info}")
@@ -714,40 +711,89 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
             global_ocr_info = {"model_name": "Unknown", "device": "Unknown"}
         
         for entry in session_data:
-            if entry.get('has_image', False):
-                # Ajouter explicitement les champs OCR manquants
-                entry_with_ocr = entry.copy()
-                entry_with_ocr["ocr_model"] = global_ocr_info.get("model_name", "Unknown")
-                entry_with_ocr["ocr_device"] = global_ocr_info.get("device", "Unknown")
+            if entry.get('has_image', False) and entry.get('handwriting_image') is not None:
+                # Créer une nouvelle entrée avec seulement les champs pertinents pour le dataset
+                # et le champ 'handwriting_image' contenant l'objet PIL.Image
                 
-                print(f"🔍 Entry avec OCR: ocr_model={entry_with_ocr['ocr_model']}, ocr_device={entry_with_ocr['ocr_device']}")
-                clean_entries.append(entry_with_ocr)
-        
-        # Créer un dataset de test avec structure forcée
-        if len(clean_entries) == 0:
+                # MODIFICATION ICI : Adapter la structure pour le type Image
+                # Utilise une copie pour éviter de modifier l'entrée originale de session_data
+                ds_entry = {
+                    "session_id": entry.get("session_id"),
+                    "timestamp": entry.get("timestamp"),
+                    "question_number": entry.get("question_number"),
+                    "session_duration": entry.get("session_duration"),
+                    "operation_type": entry.get("operation_type"),
+                    "difficulty_level": entry.get("difficulty_level"),
+                    "operand_a": entry.get("operand_a"),
+                    "operand_b": entry.get("operand_b"),
+                    "operation": entry.get("operation"),
+                    "correct_answer": entry.get("correct_answer"),
+                    "ocr_model": entry.get("ocr_model"),
+                    "ocr_device": entry.get("ocr_device"),
+                    "user_answer_ocr": entry.get("user_answer_ocr"),
+                    "user_answer_parsed": entry.get("user_answer_parsed"),
+                    "is_correct": entry.get("is_correct"),
+                    "total_questions": entry.get("total_questions"),
+                    "app_version": entry.get("app_version"),
+                    "handwriting_image": entry['handwriting_image'] # C'EST L'OBJET PIL.Image !
+                }
+                clean_entries_for_dataset.append(ds_entry)
+        
+        if len(clean_entries_for_dataset) == 0:
             return "❌ Aucune entrée avec image à exporter"
         
-        # Vérifier la structure de la première entrée
-        sample_entry = clean_entries[0]
-        print(f"🔍 Structure première entrée: {list(sample_entry.keys())}")
-        print(f"🔍 OCR dans entrée: ocr_model={sample_entry.get('ocr_model', 'MISSING')}, ocr_device={sample_entry.get('ocr_device', 'MISSING')}")
-        
+        # Définir les features pour le nouveau dataset.
+        # C'est CRUCIAL pour indiquer que 'handwriting_image' est de type Image.
+        from datasets import Features, Value, Image as ImageFeature
+        
+        # Vous devez définir toutes les colonnes attendues avec leurs types
+        # Assurez-vous que cette structure correspond à toutes les colonnes que vous voulez dans le dataset
+        # et que leurs types sont corrects.
+        # J'ai ajouté des types de base pour les colonnes que j'ai pu identifier.
+        # Vérifiez que tous vos champs sont couverts et que les types sont exacts.
+        
+        features = Features({
+            "session_id": Value("string"),
+            "timestamp": Value("string"),
+            "question_number": Value("int32"),
+            "session_duration": Value("int32"),
+            "operation_type": Value("string"),
+            "difficulty_level": Value("string"),
+            "operand_a": Value("int32"),
+            "operand_b": Value("int32"),
+            "operation": Value("string"),
+            "correct_answer": Value("int32"),
+            "ocr_model": Value("string"),
+            "ocr_device": Value("string"),
+            "user_answer_ocr": Value("string"),
+            "user_answer_parsed": Value("int32"),
+            "is_correct": Value("bool"),
+            "total_questions": Value("int32"),
+            "app_version": Value("string"),
+            "handwriting_image": ImageFeature(), # <--- LA COLONNE IMAGE
+        })
+
         # Charger dataset existant et combiner (IMPORTANT!)
         try:
-            existing_dataset = load_dataset(dataset_name, split="train")
+            # Tente de charger le dataset existant avec la structure de features prévue
+            # pour assurer la compatibilité.
+            existing_dataset = load_dataset(dataset_name, split="train", features=features, download_mode='force_redownload')
             existing_data = existing_dataset.to_list()
             print(f"📊 {len(existing_data)} entrées existantes trouvées")
             
             # Combiner ancien + nouveau
-            combined_data = existing_data + clean_entries
-            clean_dataset = Dataset.from_list(combined_data)
-            print(f"📊 Dataset combiné: {len(existing_data)} existantes + {len(clean_entries)} nouvelles = {len(combined_data)} total")
+            combined_data = existing_data + clean_entries_for_dataset
+            clean_dataset = Dataset.from_list(combined_data, features=features) # Passer les features ici aussi
+            print(f"📊 Dataset combiné: {len(existing_data)} existantes + {len(clean_entries_for_dataset)} nouvelles = {len(combined_data)} total")
             
         except Exception as e:
-            print(f"📊 Dataset non trouvé, création nouveau: {e}")
-            # Si le dataset n'existe pas, créer depuis les nouvelles entrées
-            clean_dataset = Dataset.from_list(clean_entries)
-            print(f"📊 Nouveau dataset créé avec {len(clean_entries)} entrées")
+            print(f"📊 Dataset non trouvé ou incompatible, création nouveau: {e}")
+            import traceback
+            traceback.print_exc() # Pour aider au débogage si le chargement échoue
+            
+            # Si le dataset n'existe pas ou est incompatible, créer depuis les nouvelles entrées
+            clean_dataset = Dataset.from_list(clean_entries_for_dataset, features=features)
+            print(f"📊 Nouveau dataset créé avec {len(clean_entries_for_dataset)} entrées")
         
         print(f"✅ Dataset créé - Features:")
         for feature_name in clean_dataset.features:
@@ -755,7 +801,7 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
         
         # Statistiques par opération
         operations_count = {}
-        for entry in clean_entries:
+        for entry in clean_entries_for_dataset: # Utiliser clean_entries_for_dataset
             op = entry.get('operation_type', 'unknown')
             operations_count[op] = operations_count.get(op, 0) + 1
         
@@ -767,7 +813,7 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
             dataset_name,
             private=False,
             token=hf_token,
-            commit_message=f"Add {len(clean_entries)} handwriting samples for math OCR ({operations_summary})"
+            commit_message=f"Add {len(clean_entries_for_dataset)} handwriting samples for math OCR ({operations_summary})"
         )
         
         cleanup_memory()
@@ -775,14 +821,14 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
         return f"""✅ Session ajoutée au dataset avec succès !
 
 📊 Dataset: {dataset_name}
-📸 Images: {len(clean_entries)}
+📸 Images: {len(clean_entries_for_dataset)}
 🔢 Opérations: {operations_summary}
 📈 Total: {len(clean_dataset)}
 
 🔗 Le dataset est consultable ici : https://huggingface.co/datasets/{dataset_name}"""
         
     except Exception as e:
-        print(f"❌ ERREUR: {e}")
+        print(f"❌ ERREUR lors de l'exportation du dataset: {e}")
         import traceback
         traceback.print_exc()
         return f"❌ Erreur: {str(e)}"

image_processing_cpu.py

@@ -2,53 +2,21 @@
 # image_processing_cpu.py - Version CPU avec EasyOCR
 # ==========================================
 
-"""
-Module de traitement d'images CPU-optimisé pour calculs mathématiques
-Utilise EasyOCR pour des performances rapides sur CPU
-"""
-
 import time
 from utils import (
     optimize_image_for_ocr,
-    prepare_image_for_dataset, 
+    prepare_image_for_dataset, # Cette fonction retournera maintenant l'image PIL
     create_thumbnail_fast,
     create_white_canvas,
     log_memory_usage,
     cleanup_memory,
-    decode_image_from_dataset,
+    # decode_image_from_dataset, # Cette fonction ne sera plus utilisée
     validate_ocr_result
 )
 
-# Variables globales pour OCR EasyOCR
-easyocr_reader = None
-OCR_MODEL_NAME = "EasyOCR"
-
-def init_ocr_model() -> bool:
-    """Initialise EasyOCR (optimisé CPU)"""
-    global easyocr_reader
-    
-    try:
-        print("🔄 Chargement EasyOCR (CPU optimisé)...")
-        import easyocr
-        easyocr_reader = easyocr.Reader(['en'], gpu=False, verbose=False)
-        print("✅ EasyOCR prêt (CPU) !")
-        return True
-        
-    except Exception as e:
-        print(f"❌ Erreur lors du chargement EasyOCR: {e}")
-        return False
-
-def get_ocr_model_info() -> dict:
-    """Retourne les informations du modèle OCR utilisé"""
-    return {
-        "model_name": OCR_MODEL_NAME,
-        "device": "CPU",
-        "framework": "EasyOCR",
-        "optimized_for": "speed",
-        "version": "1.7.x"
-    }
+# ... (le reste du code est inchangé jusqu'à recognize_number_fast_with_image) ...
 
-def recognize_number_fast_with_image(image_dict, debug: bool = False) -> tuple[str, any, dict | None]:
+def recognize_number_fast_with_image(image_dict, debug: bool = False) -> tuple[str, any, Image.Image | None]: # MODIFICATION DU TYPE DE RETOUR
     """
     OCR avec EasyOCR (CPU optimisé)
     
@@ -57,7 +25,7 @@ def recognize_number_fast_with_image(image_dict, debug: bool = False) -> tuple[s
         debug: Afficher les logs de debug
         
     Returns:
-        (résultat_ocr, image_optimisée, données_dataset)
+        (résultat_ocr, image_optimisée, image_pour_dataset) # MODIFIÉ
     """
     if image_dict is None or easyocr_reader is None:
         if debug:
@@ -92,24 +60,17 @@ def recognize_number_fast_with_image(image_dict, debug: bool = False) -> tuple[s
             final_result = "0"
         
         # Préparer pour dataset (fonction commune)
-        dataset_image_data = prepare_image_for_dataset(optimized_image)
+        # MODIFICATION ICI : prepare_image_for_dataset retourne maintenant l'objet PIL.Image directement
+        dataset_image = prepare_image_for_dataset(optimized_image)
         
         if debug:
             total_time = time.time() - start_time
             print(f"  ✅ EasyOCR terminé en {total_time:.1f}s → '{final_result}'")
         
-        return final_result, optimized_image, dataset_image_data
+        return final_result, optimized_image, dataset_image # MODIFIÉ
 
     except Exception as e:
         print(f"❌ Erreur OCR EasyOCR: {e}")
         return "0", None, None
 
-def recognize_number_fast(image_dict) -> tuple[str, any]:
-    """Version rapide standard"""
-    result, optimized_image, _ = recognize_number_fast_with_image(image_dict)
-    return result, optimized_image
-
-def recognize_number(image_dict) -> str:
-    """Interface standard"""
-    result, _ = recognize_number_fast(image_dict)
-    return result
+# ... (le reste du code est inchangé) ...

image_processing_gpu.py

@@ -2,12 +2,8 @@
 # image_processing_gpu.py - Version ZeroGPU compatible
 # ==========================================
 
-"""
-Module de traitement d'images GPU-optimisé pour calculs mathématiques
-Compatible ZeroGPU HuggingFace Spaces
-"""
-
 import time
+import torch # Assurez-vous que torch est importé
 
 # Import spaces avec gestion d'erreur complète
 try:
@@ -16,7 +12,6 @@ try:
     SPACES_AVAILABLE = True
 except ImportError as e:
     print(f"❌ Import spaces échoué: {e}")
-    # Créer un mock si spaces n'est pas disponible
     class MockSpaces:
         @staticmethod
         def GPU(func):
@@ -34,73 +29,19 @@ except ImportError:
 
 from utils import (
     optimize_image_for_ocr,
-    prepare_image_for_dataset, 
+    prepare_image_for_dataset, # Cette fonction retournera maintenant l'image PIL
     create_thumbnail_fast,
     create_white_canvas,
     log_memory_usage,
     cleanup_memory,
-    decode_image_from_dataset,
+    # decode_image_from_dataset, # Cette fonction ne sera plus utilisée
     validate_ocr_result
 )
 
-# Variables globales pour OCR
-processor = None
-model = None
-OCR_MODEL_NAME = "TrOCR-base-handwritten"
+# ... (le reste du code est inchangé jusqu'à recognize_number_fast_with_image) ...
 
-def init_ocr_model() -> bool:
-    """Initialise TrOCR (ZeroGPU compatible)"""
-    global processor, model
-    
-    try:
-        print("🔄 Chargement TrOCR (ZeroGPU optimisé)...")
-        
-        if not TORCH_AVAILABLE:
-            print("❌ Torch non disponible, impossible de charger TrOCR")
-            return False
-            
-        from transformers import TrOCRProcessor, VisionEncoderDecoderModel
-        
-        processor = TrOCRProcessor.from_pretrained('microsoft/trocr-base-handwritten')
-        model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-base-handwritten')
-        
-        # Optimisations
-        model.eval()
-        
-        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} !")
-        else:
-            device_info = "CPU (ZeroGPU pas encore alloué)"
-            print(f"⚠️ TrOCR sur CPU - {device_info}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ Erreur lors du chargement TrOCR: {e}")
-        return False
-
-def get_ocr_model_info() -> dict:
-    """Retourne les informations du modèle OCR utilisé"""
-    if TORCH_AVAILABLE and torch.cuda.is_available():
-        device = "ZeroGPU"
-        gpu_name = torch.cuda.get_device_name() if torch.cuda.is_available() else "N/A"
-    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"
-    }
-
-@spaces.GPU  # Décorateur ZeroGPU
-def recognize_number_fast_with_image(image_dict, debug: bool = False) -> tuple[str, any, dict | None]:
+@spaces.GPU
+def recognize_number_fast_with_image(image_dict, debug: bool = False) -> tuple[str, any, Image.Image | None]: # MODIFICATION DU TYPE DE RETOUR
     """
     OCR avec TrOCR (ZeroGPU optimisé)
     """
@@ -131,14 +72,11 @@ def recognize_number_fast_with_image(image_dict, debug: bool = False) -> tuple[s
             print("  🤖 Lancement TrOCR ZeroGPU...")
         
         with torch.no_grad():
-            # Preprocessing
             pixel_values = processor(images=optimized_image, return_tensors="pt").pixel_values
             
-            # GPU transfer si disponible
             if torch.cuda.is_available():
                 pixel_values = pixel_values.cuda()
             
-            # Génération optimisée
             generated_ids = model.generate(
                 pixel_values,
                 max_length=4,
@@ -148,30 +86,22 @@ def recognize_number_fast_with_image(image_dict, debug: bool = False) -> tuple[s
                 pad_token_id=processor.tokenizer.pad_token_id
             )
             
-            # Décodage
             result = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
             final_result = validate_ocr_result(result, max_length=4)
         
         # Préparer pour dataset
-        dataset_image_data = prepare_image_for_dataset(optimized_image)
+        # MODIFICATION ICI : prepare_image_for_dataset retourne maintenant l'objet PIL.Image directement
+        dataset_image = prepare_image_for_dataset(optimized_image)
         
         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}'")
         
-        return final_result, optimized_image, dataset_image_data
+        return final_result, optimized_image, dataset_image # MODIFIÉ
 
     except Exception as e:
         print(f"❌ Erreur OCR TrOCR ZeroGPU: {e}")
         return "0", None, None
 
-def recognize_number_fast(image_dict) -> tuple[str, any]:
-    """Version rapide standard"""
-    result, optimized_image, _ = recognize_number_fast_with_image(image_dict)
-    return result, optimized_image
-
-def recognize_number(image_dict) -> str:
-    """Interface standard"""
-    result, _ = recognize_number_fast(image_dict)
-    return result
+# ... (le reste du code est inchangé) ...

utils.py

@@ -59,7 +59,7 @@ def optimize_image_for_ocr(image_dict: dict | np.ndarray | Image.Image | None, m
         elif isinstance(image_dict, np.ndarray):
             image = image_dict
         elif isinstance(image_dict, Image.Image):
-            image = image_dict
+            image = image
         else:
             return None
 
@@ -79,53 +79,19 @@ def optimize_image_for_ocr(image_dict: dict | np.ndarray | Image.Image | None, m
         print(f"❌ Erreur optimisation image: {e}")
         return None
 
-def prepare_image_for_dataset(image: Image.Image, max_size: tuple[int, int] = (100, 100), quality: int = 60) -> dict[str, str | int | float | tuple] | None:
+# MODIFICATION ICI : Ne plus retourner de base64, mais l'objet PIL.Image directement.
+# La fonction `datasets.Image()` s'occupera de la sérialisation pour le dataset.
+def prepare_image_for_dataset(image: Image.Image) -> Image.Image | None:
     """
-    Prépare une image pour l'inclusion dans le dataset
-    
-    Args:
-        image: Image PIL à traiter
-        max_size: Taille maximale (largeur, hauteur)
-        quality: Qualité de compression PNG
-        
-    Returns:
-        Dictionnaire avec image_base64, taille, etc. ou None
+    Prépare une image pour l'inclusion dans le dataset en retournant l'objet PIL.Image.
+    La compression et le redimensionnement sont déjà faits par optimize_image_for_ocr si nécessaire.
     """
-    try:
-        if image is None:
-            return None
-            
-        # Copier et redimensionner
-        dataset_image = image.copy()
-        dataset_image.thumbnail(max_size, Image.Resampling.LANCZOS)
-        compressed_size = dataset_image.size
-        
-        # Convertir en base64
-        buffer = BytesIO()
-        dataset_image.save(buffer, format='PNG', optimize=True, quality=quality)
-        
-        buffer_data = buffer.getvalue()
-        image_base64 = base64.b64encode(buffer_data).decode()
-        file_size_kb = len(image_base64) / 1024
-        
-        # Structure propre pour dataset
-        result = {
-            "image_base64": image_base64,
-            "compressed_size": compressed_size,
-            "file_size_kb": round(file_size_kb, 1),
-            "format": "PNG",
-            "quality": quality
-        }
-        
-        # Nettoyage
-        dataset_image.close()
-        buffer.close()
-        
-        return result
-        
-    except Exception as e:
-        print(f"❌ Erreur préparation image dataset: {e}")
-        return None
+    # Ici, nous retournons l'image telle quelle.
+    # Si vous voulez une taille spécifique pour le dataset (différente de celle d'OCR),
+    # vous pouvez ajouter un redimensionnement ici, mais il faut être prudent avec la taille pour éviter des images géantes.
+    # Pour le moment, nous allons simplement retourner l'image optimisée par l'OCR.
+    # Le type Image de datasets gère automatiquement la compression optimale pour le Hub.
+    return image
 
 def create_thumbnail_fast(optimized_image: Image.Image | None, size: tuple[int, int] = (40, 40)) -> str:
     """
@@ -146,7 +112,7 @@ def create_thumbnail_fast(optimized_image: Image.Image | None, size: tuple[int,
         thumbnail.thumbnail(size, Image.Resampling.LANCZOS)
         
         buffer = BytesIO()
-        thumbnail.save(buffer, format='PNG', optimize=True, quality=70)
+        thumbnail.save(buffer, format='PNG', optimize=True, quality=70) # Garde le Base64 ici pour l'affichage HTML
         img_str = base64.b64encode(buffer.getvalue()).decode()
         
         thumbnail.close()
@@ -157,15 +123,12 @@ def create_thumbnail_fast(optimized_image: Image.Image | None, size: tuple[int,
     except Exception:
         return "📝"
 
+# MODIFICATION ICI : Cette fonction devient obsolète car nous ne stockons plus de Base64 dans le dataset.
+# Laissez-la si elle est appelée ailleurs pour l'instant, mais elle ne sera plus utilisée pour le dataset.
 def decode_image_from_dataset(base64_string: str) -> Image.Image | None:
     """
     Décode une image depuis le dataset pour fine-tuning ou analyse
-    
-    Args:
-        base64_string: String base64 de l'image
-        
-    Returns:
-        Image PIL ou None si erreur
+    (sera obsolète si le dataset est en type Image natif)
     """
     try:
         image_bytes = base64.b64decode(base64_string)
@@ -178,25 +141,15 @@ def decode_image_from_dataset(base64_string: str) -> Image.Image | None:
 def validate_ocr_result(raw_result: str, max_length: int = 4) -> str:
     """
     Valide et nettoie un résultat OCR
-    
-    Args:
-        raw_result: Résultat brut de l'OCR
-        max_length: Longueur maximale autorisée
-        
-    Returns:
-        Résultat nettoyé (chiffres uniquement)
     """
     if not raw_result:
         return "0"
     
-    # Extraire uniquement les chiffres
     cleaned_result = ''.join(filter(str.isdigit, str(raw_result)))
     
-    # Valider la longueur
     if cleaned_result and len(cleaned_result) <= max_length:
         return cleaned_result
     elif cleaned_result:
-        # Si trop long, prendre les premiers chiffres
         return cleaned_result[:max_length]
     else:
         return "0"
@@ -204,14 +157,6 @@ def validate_ocr_result(raw_result: str, max_length: int = 4) -> str:
 def analyze_calculation_complexity(operand_a: int, operand_b: int, operation: str) -> dict:
     """
     Analyse la complexité d'un calcul pour enrichir les métadonnées dataset
-    
-    Args:
-        operand_a: Premier opérande
-        operand_b: Deuxième opérande  
-        operation: Type d'opération (×, +, -, ÷)
-        
-    Returns:
-        Dictionnaire avec score de complexité et catégorie
     """
     complexity_score = 0
     
@@ -224,7 +169,6 @@ def analyze_calculation_complexity(operand_a: int, operand_b: int, operation: st
     elif operation == "÷":
         complexity_score = operand_a / 10
     
-    # Catégorisation
     if complexity_score < 5:
         category = "easy"
     elif complexity_score < 10: