Upload 6 files

app.py

@@ -1,9 +1,9 @@
 # ==========================================
-# app_fixed.py - Calcul OCR v3.0 - Sessions isolées
+# app.py - Calcul OCR v3.0 - Version GPU simplifiée
 # ==========================================
 
 """
-Application principale avec isolation des sessions utilisateurs
+Application principale optimisée pour ZeroGPU HuggingFace Spaces
 """
 
 import gradio as gr
@@ -12,29 +12,17 @@ import os
 import gc
 import numpy as np
 from PIL import Image
-import simple_gpu
 
 warnings.filterwarnings("ignore")
 
-# Import avec structure claire : GPU ou CPU uniquement
-try:
-    import torch
-    if torch.cuda.is_available():
-        from image_processing_gpu import init_ocr_model, create_white_canvas, cleanup_memory
-        print("📱 Interface: Mode GPU détecté - TrOCR")
-    else:
-        from image_processing_cpu import init_ocr_model, create_white_canvas, cleanup_memory
-        print("📱 Interface: Mode CPU détecté - EasyOCR")
-except ImportError:
-    from image_processing_cpu import init_ocr_model, create_white_canvas, cleanup_memory
-    print("📱 Interface: Mode CPU détecté - EasyOCR")
-
+# Import GPU uniquement
+from image_processing_gpu import init_ocr_model, create_white_canvas, cleanup_memory
 from game_engine import MathGame, export_to_clean_dataset
 
-print("🚀 Initialisation Calcul OCR v3.0...")
-print("🔄 Chargement modèle OCR...")
+print("🚀 Initialisation Calcul OCR v3.0 (GPU)...")
+print("🔄 Chargement modèle TrOCR...")
 init_ocr_model()
-print("✅ Modèle OCR prêt")
+print("✅ Modèle TrOCR prêt")
 
 def create_new_game_session():
     """Crée une nouvelle instance de jeu pour chaque session"""
@@ -123,7 +111,7 @@ with gr.Blocks(
     head="<meta name='viewport' content='width=device-width, initial-scale=1.0'>"
 ) as demo:
 
-    # ✅ STATE MANAGEMENT - Chaque utilisateur a sa propre instance
+    # State management - Chaque utilisateur a sa propre instance
     game_state = gr.State(value=None)
 
     gr.Markdown(
@@ -196,7 +184,7 @@ with gr.Blocks(
     export_button = gr.Button("📤 Exporter la série vers le dataset", variant="primary", size="lg")
     export_status = gr.Markdown("")
 
-    # ✅ ÉVÉNEMENTS avec State management
+    # Événements avec State management
     go_button.click(
         fn=start_game_wrapper,
         inputs=[duration_choice, operation_choice, difficulty_choice, game_state],
@@ -216,8 +204,8 @@ with gr.Blocks(
     )
 
 if __name__ == "__main__":
-    print("🚀 Lancement Calcul OCR v3.0 - Sessions isolées...")
-    print("🔒 Isolation: Chaque utilisateur a sa propre instance")
+    print("🚀 Lancement Calcul OCR v3.0 - Version GPU simplifiée")
+    print("🎯 ZeroGPU HuggingFace Spaces")
     print("🎯 Dataset: calcul_ocr_dataset")
     print("📊 Opérations: ×, +, -, ÷, Aléatoire")
     print("⚙️ Durées: 30s, 60s")

game_engine.py

@@ -1,10 +1,9 @@
 # ==========================================
-# game_engine.py - Calcul OCR v3.0 CLEAN (VERSION SANS BASE64)
+# game_engine.py - Calcul OCR v3.0 GPU simplifié
 # ==========================================
 
 """
-Moteur de jeu mathématique avec traitement parallèle et auto-détection OCR
-VERSION MODIFIÉE: Utilise le format Image natif au lieu de Base64
+Moteur de jeu mathématique optimisé pour ZeroGPU HuggingFace Spaces
 """
 
 import random
@@ -20,81 +19,27 @@ import threading
 import queue
 from typing import Dict, Tuple, Optional
 
-# Auto-détection adaptée ZeroGPU
-ocr_module = None
-ocr_info = {"model_name": "Unknown", "device": "Unknown"}
+# Import GPU uniquement
+from image_processing_gpu import (
+    recognize_number_fast_with_image,
+    create_thumbnail_fast, 
+    create_white_canvas,
+    cleanup_memory,
+    log_memory_usage,
+    get_ocr_model_info
+)
 
-# Debug des variables d'environnement HF
-space_id = os.getenv("SPACE_ID")
-space_hardware = os.getenv("SPACE_HARDWARE") 
-hf_space = os.getenv("HF_SPACE")
-space_author = os.getenv("SPACE_AUTHOR_NAME")
-zero_gpu = os.getenv("ZERO_GPU")
+print("✅ Game Engine: Mode GPU TrOCR")
 
-print(f"🔍 Debug HF Env:")
-print(f"  SPACE_ID: {space_id}")
-print(f"  SPACE_HARDWARE: {space_hardware}")
-print(f"  HF_SPACE: {hf_space}")
-print(f"  SPACE_AUTHOR_NAME: {space_author}")
-print(f"  ZERO_GPU: {zero_gpu}")
-
-# Détecter ZeroGPU (GPU dynamique HF)
-is_zerogpu = space_id and ("hoololi" in str(space_id))
-
-print(f"🎯 ZeroGPU détecté: {is_zerogpu}")
-
-if is_zerogpu:
-    try:
-        print("🚀 Force mode ZeroGPU - Import GPU...")
-        from simple_gpu import gpu_dummy_function
-        print("✅ Simple GPU importé")
-        
-        from image_processing_gpu import (
-            recognize_number_fast_with_image as gpu_recognize,
-            create_thumbnail_fast, 
-            create_white_canvas,
-            cleanup_memory,
-            log_memory_usage,
-            get_ocr_model_info
-        )
-        
-        recognize_number_fast_with_image = gpu_recognize
-        ocr_module = "zerogpu_trocr"
-        print("✅ Game Engine: Mode ZeroGPU - TrOCR directement utilisé")
-        
-    except Exception as e:
-        print(f"❌ Erreur ZeroGPU: {e}")
-        from image_processing_cpu import (
-            recognize_number_fast_with_image, 
-            create_thumbnail_fast, 
-            create_white_canvas,
-            cleanup_memory,
-            log_memory_usage,
-            get_ocr_model_info
-        )
-        ocr_module = "cpu"
-        print("✅ Game Engine: Mode CPU - EasyOCR (fallback)")
-else:
-    from image_processing_cpu import (
-        recognize_number_fast_with_image, 
-        create_thumbnail_fast, 
-        create_white_canvas,
-        cleanup_memory,
-        log_memory_usage,
-        get_ocr_model_info
-    )
-    ocr_module = "cpu"
-    print("✅ Game Engine: Mode CPU - EasyOCR standard")
-
-# Récupérer les infos du modèle sélectionné
+# Récupérer les infos du modèle OCR
 try:
     ocr_info = get_ocr_model_info()
     print(f"🎯 OCR sélectionné: {ocr_info['model_name']} sur {ocr_info['device']}")
 except Exception as e:
     print(f"⚠️ Impossible de récupérer les infos OCR: {e}")
-    ocr_info = {"model_name": "Error", "device": "Unknown"}
+    ocr_info = {"model_name": "TrOCR", "device": "ZeroGPU"}
 
-# Imports dataset avec gestion d'erreur
+# Imports dataset
 try:
     from datasets import Dataset, Image as DatasetImage, load_dataset
     DATASET_AVAILABLE = True
@@ -103,7 +48,7 @@ except ImportError as e:
     DATASET_AVAILABLE = False
     print(f"⚠️ Modules dataset non disponibles: {e}")
 
-# Nom du dataset modifié pour la version avec images natives
+# Dataset name
 DATASET_NAME = "hoololi/calcul_ocr_dataset_with_images_v2"
 
 # Configuration des difficultés par opération
@@ -170,7 +115,7 @@ def create_result_row_with_images(i: int, image: dict | np.ndarray | Image.Image
 
 
 class MathGame:
-    """Moteur de jeu mathématique avec traitement parallèle"""
+    """Moteur de jeu mathématique avec traitement parallèle GPU"""
     
     def __init__(self):
         self.is_running = False
@@ -222,22 +167,22 @@ class MathGame:
             self.processing_active = True
             self.worker_thread = threading.Thread(target=self._process_images_worker, daemon=True)
             self.worker_thread.start()
-            print("🔄 Thread de traitement parallèle démarré")
+            print("🔄 Thread de traitement GPU parallèle démarré")
 
     def _stop_background_processing(self) -> None:
         """Arrête le thread de traitement"""
         self.processing_active = False
         if self.worker_thread and self.worker_thread.is_alive():
-            print("⏹️ Arrêt du thread de traitement parallèle")
+            print("⏹️ Arrêt du thread de traitement GPU parallèle")
 
     def _process_images_worker(self) -> None:
-        """Worker thread qui traite les images en arrière-plan"""
-        print("🚀 Worker thread démarré")
+        """Worker thread qui traite les images en arrière-plan avec GPU"""
+        print("🚀 Worker thread GPU démarré")
         while self.processing_active:
             try:
                 if not self.processing_queue.empty():
                     question_num, image, expected, operation_data = self.processing_queue.get(timeout=1)
-                    print(f"🔄 Traitement parallèle image {question_num}...")
+                    print(f"🔄 Traitement GPU parallèle image {question_num}...")
                     
                     start_time = time.time()
                     result_data = create_result_row_with_images(question_num, image, expected, operation_data)
@@ -245,7 +190,7 @@ class MathGame:
                     
                     # Stocker le résultat
                     self.results_cache[question_num] = result_data
-                    print(f"✅ Image {question_num} traitée en {processing_time:.1f}s (parallèle)")
+                    print(f"✅ Image {question_num} traitée en {processing_time:.1f}s (GPU parallèle)")
                     
                 else:
                     time.sleep(0.1)
@@ -253,16 +198,16 @@ class MathGame:
             except queue.Empty:
                 continue
             except Exception as e:
-                print(f"❌ Erreur traitement parallèle: {e}")
+                print(f"❌ Erreur traitement GPU parallèle: {e}")
                 
-        print("🛑 Worker thread terminé")
+        print("🛑 Worker thread GPU terminé")
 
     def _add_image_to_processing_queue(self, question_num: int, image: dict | np.ndarray | Image.Image, 
                                      expected: int, operation_data: tuple) -> None:
-        """Ajoute une image à la queue de traitement"""
+        """Ajoute une image à la queue de traitement GPU"""
         if image is not None:
             self.processing_queue.put((question_num, image, expected, operation_data))
-            print(f"📝 Image {question_num} ajoutée à la queue de traitement")
+            print(f"📝 Image {question_num} ajoutée à la queue de traitement GPU")
 
     def generate_multiplication(self, difficulty: str) -> tuple[str, int]:
         """Génère une multiplication"""
@@ -358,7 +303,7 @@ class MathGame:
         self.export_timestamp = None
         self.export_result = None
         
-        # Démarrer le traitement parallèle
+        # Démarrer le traitement parallèle GPU
         self._start_background_processing()
         
         gc.collect()
@@ -406,7 +351,7 @@ class MathGame:
             return self.end_game(image_data)
 
         if image_data is not None:
-            # Ajouter l'image à la liste ET au traitement parallèle
+            # Ajouter l'image à la liste ET au traitement parallèle GPU
             self.user_images.append(image_data)
             self.expected_answers.append(self.correct_answer)
             
@@ -415,7 +360,7 @@ class MathGame:
             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
+            # Lancer le traitement GPU 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
@@ -456,10 +401,10 @@ class MathGame:
 
         self.is_running = False
         
-        # Arrêter le traitement parallèle
+        # Arrêter le traitement parallèle GPU
         self._stop_background_processing()
         
-        print("🏁 Fin de jeu - Assemblage des résultats...")
+        print("🏁 Fin de jeu - Assemblage des résultats GPU...")
 
         if final_image is not None:
             self.user_images.append(final_image)
@@ -470,8 +415,8 @@ class MathGame:
             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}...")
+            # Traiter la dernière image immédiatement avec GPU
+            print(f"🔄 Traitement GPU 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
             
@@ -479,17 +424,17 @@ 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
+        # Attendre que toutes les images soient traitées par GPU
         max_wait = 10
         wait_start = time.time()
         expected_results = len(self.user_images)
         
-        print(f"⏳ Attente de {expected_results} résultats...")
+        print(f"⏳ Attente de {expected_results} résultats GPU...")
         while len(self.results_cache) < expected_results and (time.time() - wait_start) < max_wait:
             time.sleep(0.1)
             
         results_ready = len(self.results_cache)
-        print(f"✅ {results_ready}/{expected_results} résultats prêts")
+        print(f"✅ {results_ready}/{expected_results} résultats GPU prêts")
 
         # Assembler les résultats dans l'ordre
         correct_answers = 0
@@ -502,14 +447,14 @@ class MathGame:
         self.session_data = []
         images_saved = 0
         
-        print(f"📊 Assemblage de {total_questions} résultats...")
+        print(f"📊 Assemblage de {total_questions} résultats GPU...")
         
         for i in range(total_questions):
             if i in self.results_cache:
                 row_data = self.results_cache[i]
-                print(f"  ✅ Résultat {i} du cache parallèle")
+                print(f"  ✅ Résultat {i} du cache GPU parallèle")
             else:
-                print(f"  🔄 Traitement fallback pour résultat {i}...")
+                print(f"  🔄 Traitement GPU fallback pour résultat {i}...")
                 if i < len(self.operations_history):
                     row_data = create_result_row_with_images(i, self.user_images[i], self.expected_answers[i], self.operations_history[i])
                 else:
@@ -526,15 +471,15 @@ class MathGame:
             if row_data['is_correct']:
                 correct_answers += 1
 
-            # Structure pour dataset avec debug OCR
+            # Structure pour dataset avec info OCR GPU
             a, b, operation, correct_result = self.operations_history[i] if i < len(self.operations_history) else (0, 0, "×", 0)
             
             try:
                 ocr_info_data = get_ocr_model_info()
-                print(f"🔍 Debug OCR info: {ocr_info_data}")
+                print(f"🔍 Debug OCR info GPU: {ocr_info_data}")
             except Exception as e:
                 print(f"❌ Erreur get_ocr_model_info: {e}")
-                ocr_info_data = {"model_name": "Error", "device": "Unknown"}
+                ocr_info_data = {"model_name": "TrOCR", "device": "ZeroGPU"}
             
             entry = {
                 "session_id": session_id,
@@ -547,18 +492,18 @@ class MathGame:
                 "operand_b": b,
                 "operation": operation,
                 "correct_answer": self.expected_answers[i] if i < len(self.expected_answers) else 0,
-                "ocr_model": ocr_info_data.get("model_name", "Unknown"),
-                "ocr_device": ocr_info_data.get("device", "Unknown"),
+                "ocr_model": ocr_info_data.get("model_name", "TrOCR"),
+                "ocr_device": ocr_info_data.get("device", "ZeroGPU"),
                 "user_answer_ocr": row_data['recognized'],
                 "user_answer_parsed": row_data['recognized_num'],
                 "is_correct": row_data['is_correct'],
                 "total_questions": total_questions,
-                "app_version": "3.0_calcul_ocr_native_images"
+                "app_version": "3.0_calcul_ocr_gpu_simplified"
             }
             
-            print(f"🔍 Debug entry OCR fields: ocr_model={entry['ocr_model']}, ocr_device={entry['ocr_device']}")
+            print(f"🔍 Debug entry OCR GPU: ocr_model={entry['ocr_model']}, ocr_device={entry['ocr_device']}")
             
-            # MODIFICATION CLÉE: Utiliser l'image PIL native au lieu de Base64
+            # Image PIL native pour dataset
             if row_data['dataset_image_data']:
                 entry["handwriting_image"] = row_data['dataset_image_data']["handwriting_image"]  # Image PIL native
                 entry["image_width"] = int(row_data['dataset_image_data']["width"])
@@ -575,7 +520,7 @@ class MathGame:
         for entry in self.session_data:
             entry["session_accuracy"] = accuracy
 
-        # Nettoyage mémoire
+        # Nettoyage mémoire GPU
         for img in self.user_images:
             if hasattr(img, 'close'):
                 try:
@@ -597,7 +542,7 @@ class MathGame:
                         <th style="padding: 8px;">B</th>
                         <th style="padding: 8px;">Réponse</th>
                         <th style="padding: 8px;">Votre dessin</th>
-                        <th style="padding: 8px;">OCR</th>
+                        <th style="padding: 8px;">OCR GPU</th>
                         <th style="padding: 8px;">Statut</th>
                     </tr>
                 </thead>
@@ -619,10 +564,11 @@ class MathGame:
         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>
+                <h3 style="color: #2e7d32;">📊 Résumé de la série (GPU)</h3>
                 <p style="color: #2e7d32;">
                     ✅ {total_questions} réponses • 📊 {accuracy:.1f}% de précision<br>
                     🖼️ {images_saved} images natives sauvegardées<br>
+                    🎯 OCR: TrOCR ZeroGPU<br>
                     ⚙️ Configuration: {config_display}
                 </p>
             </div>
@@ -653,7 +599,7 @@ class MathGame:
                     </div>
                 </div>
             </div>
-            <h2 style="color: #4a90e2;">📊 Détail des Réponses</h2>
+            <h2 style="color: #4a90e2;">📊 Détail des Réponses (TrOCR GPU)</h2>
             {table_html}
             {export_section}
         </div>
@@ -662,7 +608,7 @@ class MathGame:
         return (
             """<div style="font-size: 3em; font-weight: bold; text-align: center; padding: 20px; background: linear-gradient(45deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px;">🏁 C'est fini !</div>""",
             create_white_canvas(),
-            f"✨ Session {config_display} terminée !",
+            f"✨ Session GPU {config_display} terminée !",
             "⏱️ Temps écoulé !",
             gr.update(interactive=True),
             gr.update(interactive=False),
@@ -671,9 +617,9 @@ class MathGame:
 
 
 def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None) -> str:
-    """Export vers le nouveau dataset avec images natives (PAS DE BASE64)"""
+    """Export vers le dataset avec images natives optimisé GPU"""
     if dataset_name is None:
-        dataset_name = DATASET_NAME  # Utiliser le dataset avec images natives
+        dataset_name = DATASET_NAME
         
     if not DATASET_AVAILABLE:
         return "❌ Modules dataset non disponibles"
@@ -683,41 +629,40 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
         return "❌ Token HuggingFace manquant (HF_TOKEN ou tk_calcul_ocr)"
     
     try:
-        print(f"\n🚀 === EXPORT VERS DATASET CALCUL OCR (IMAGES NATIVES) ===")
+        print(f"\n🚀 === EXPORT VERS DATASET CALCUL OCR GPU ===")
         print(f"📊 Dataset: {dataset_name}")
         
-        # Filtrer les entrées avec images et ajouter les infos OCR globalement
+        # Filtrer les entrées avec images et ajouter les infos OCR GPU
         clean_entries = []
         
-        # Récupérer une seule fois les infos OCR pour toute la session
+        # Récupérer les infos OCR GPU pour toute la session
         try:
             global_ocr_info = get_ocr_model_info()
-            print(f"🔍 Infos OCR globales: {global_ocr_info}")
+            print(f"🔍 Infos OCR GPU globales: {global_ocr_info}")
         except Exception as e:
-            print(f"❌ Erreur infos OCR globales: {e}")
-            global_ocr_info = {"model_name": "Unknown", "device": "Unknown"}
+            print(f"❌ Erreur infos OCR GPU: {e}")
+            global_ocr_info = {"model_name": "TrOCR", "device": "ZeroGPU"}
         
         for entry in session_data:
             if entry.get('has_image', False):
-                # Ajouter explicitement les champs OCR manquants
+                # Ajouter explicitement les champs OCR GPU
                 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")
+                entry_with_ocr["ocr_model"] = global_ocr_info.get("model_name", "TrOCR")
+                entry_with_ocr["ocr_device"] = global_ocr_info.get("device", "ZeroGPU")
                 
-                print(f"🔍 Entry avec OCR: ocr_model={entry_with_ocr['ocr_model']}, ocr_device={entry_with_ocr['ocr_device']}")
+                print(f"🔍 Entry GPU avec OCR: ocr_model={entry_with_ocr['ocr_model']}, ocr_device={entry_with_ocr['ocr_device']}")
                 print(f"🖼️ Image type: {type(entry_with_ocr.get('handwriting_image', 'None'))}")
                 clean_entries.append(entry_with_ocr)
         
-        # Créer un dataset de test avec structure forcée
         if len(clean_entries) == 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')}")
+        print(f"🔍 Structure première entrée GPU: {list(sample_entry.keys())}")
+        print(f"🔍 OCR GPU dans entrée: ocr_model={sample_entry.get('ocr_model', 'MISSING')}, ocr_device={sample_entry.get('ocr_device', 'MISSING')}")
         
-        # Charger dataset existant et combiner (IMPORTANT!)
+        # Charger dataset existant et combiner
         try:
             existing_dataset = load_dataset(dataset_name, split="train")
             existing_data = existing_dataset.to_list()
@@ -734,14 +679,14 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
             clean_dataset = Dataset.from_list(clean_entries)
             print(f"📊 Nouveau dataset créé avec {len(clean_entries)} entrées")
         
-        # MODIFICATION CLÉE: Spécifier que la colonne handwriting_image est de type Image
+        # Spécifier que la colonne handwriting_image est de type Image
         try:
             clean_dataset = clean_dataset.cast_column("handwriting_image", DatasetImage())
             print("✅ Colonne handwriting_image convertie au type Image natif")
         except Exception as e:
             print(f"⚠️ Impossible de convertir au type Image: {e}")
         
-        print(f"✅ Dataset créé - Features:")
+        print(f"✅ Dataset GPU créé - Features:")
         for feature_name in clean_dataset.features:
             print(f"  - {feature_name}: {clean_dataset.features[feature_name]}")
         
@@ -754,20 +699,21 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
         operations_summary = ", ".join([f"{op}: {count}" for op, count in operations_count.items()])
         
         # Push vers HuggingFace  
-        print(f"📤 Push vers {dataset_name}...")
+        print(f"📤 Push GPU vers {dataset_name}...")
         clean_dataset.push_to_hub(
             dataset_name,
             private=False,
             token=hf_token,
-            commit_message=f"Add {len(clean_entries)} native image samples for math OCR ({operations_summary})"
+            commit_message=f"Add {len(clean_entries)} GPU TrOCR native image samples for math OCR ({operations_summary})"
         )
         
         cleanup_memory()
         
-        return f"""### ✅ Session ajoutée au dataset avec succès !
+        return f"""### ✅ Session GPU ajoutée au dataset avec succès !
 
 📊 **Dataset:** {dataset_name}  
-🖼️ **Images natives:** {len(clean_entries)}  
+🖼️ **Images natives (GPU):** {len(clean_entries)}  
+🎯 **OCR:** TrOCR ZeroGPU  
 🔢 **Opérations:** {operations_summary}  
 📈 **Total:** {len(clean_dataset)}  
 
@@ -776,7 +722,7 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
 
         
     except Exception as e:
-        print(f"❌ ERREUR: {e}")
+        print(f"❌ ERREUR GPU: {e}")
         import traceback
         traceback.print_exc()
-        return f"❌ Erreur: {str(e)}"
+        return f"❌ Erreur GPU: {str(e)}"

image_processing_gpu.py

@@ -1,37 +1,15 @@
 # ==========================================
-# image_processing_gpu.py - Version ZeroGPU compatible (SANS BASE64)
+# image_processing_gpu.py - Version ZeroGPU simplifiée
 # ==========================================
 
 """
-Module de traitement d'images GPU-optimisé pour calculs mathématiques
-Compatible ZeroGPU HuggingFace Spaces
-VERSION MODIFIÉE: Format Image natif au lieu de Base64
+Module de traitement d'images GPU-optimisé pour ZeroGPU HuggingFace Spaces
 """
 
 import time
-
-# Import spaces avec gestion d'erreur complète
-try:
-    import spaces
-    print("✅ Import spaces réussi dans image_processing_gpu")
-    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):
-            print(f"MockSpaces.GPU décorateur appliqué à {func.__name__}")
-            return func
-    spaces = MockSpaces()
-    SPACES_AVAILABLE = False
-
-try:
-    import torch
-    TORCH_AVAILABLE = True
-except ImportError:
-    print("❌ Torch non disponible")
-    TORCH_AVAILABLE = False
+import torch
+import spaces
+from transformers import TrOCRProcessor, VisionEncoderDecoderModel
 
 from utils import (
     optimize_image_for_ocr,
@@ -49,17 +27,11 @@ model = None
 OCR_MODEL_NAME = "TrOCR-base-handwritten"
 
 def init_ocr_model() -> bool:
-    """Initialise TrOCR (ZeroGPU compatible)"""
+    """Initialise TrOCR pour ZeroGPU"""
     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
+        print("🔄 Chargement TrOCR (ZeroGPU)...")
         
         processor = TrOCRProcessor.from_pretrained('microsoft/trocr-base-handwritten')
         model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-base-handwritten')
@@ -83,9 +55,9 @@ def init_ocr_model() -> bool:
 
 def get_ocr_model_info() -> dict:
     """Retourne les informations du modèle OCR utilisé"""
-    if TORCH_AVAILABLE and torch.cuda.is_available():
+    if torch.cuda.is_available():
         device = "ZeroGPU"
-        gpu_name = torch.cuda.get_device_name() if torch.cuda.is_available() else "N/A"
+        gpu_name = torch.cuda.get_device_name()
     else:
         device = "CPU"
         gpu_name = "N/A"
@@ -99,10 +71,10 @@ def get_ocr_model_info() -> dict:
         "version": "microsoft/trocr-base-handwritten"
     }
 
-@spaces.GPU  # Décorateur ZeroGPU
+@spaces.GPU
 def recognize_number_fast_with_image(image_dict, debug: bool = False) -> tuple[str, any, dict | None]:
     """
-    OCR avec TrOCR (ZeroGPU optimisé) - VERSION SANS BASE64
+    OCR avec TrOCR ZeroGPU - Version simplifiée
     """
     if image_dict is None:
         if debug:
@@ -152,7 +124,7 @@ def recognize_number_fast_with_image(image_dict, debug: bool = False) -> tuple[s
             result = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
             final_result = validate_ocr_result(result, max_length=4)
         
-        # Préparer pour dataset (NOUVELLE VERSION SANS BASE64)
+        # Préparer pour dataset
         dataset_image_data = prepare_image_for_dataset(optimized_image)
         
         if debug:

requirements.txt

@@ -1,4 +1,4 @@
-# Requirements unifiés avec fallbacks intelligents
+# Requirements simplifiés pour GPU/ZeroGPU uniquement
 gradio>=4.0.0
 pillow>=9.0.0
 numpy>=1.21.0
@@ -7,11 +7,8 @@ huggingface_hub>=0.16.0
 pandas>=1.5.0
 psutil>=5.8.0
 
-# EasyOCR (toujours installé - fonctionne partout)
-easyocr>=1.7.0
-
-# GPU/TrOCR (optionnel - installé si GPU disponible)
-# Ces packages seront installés automatiquement sur les spaces GPU
-torch>=2.0.0; sys_platform != "emscripten"
-torchvision>=0.15.0; sys_platform != "emscripten" 
-transformers>=4.30.0; sys_platform != "emscripten"
+# GPU/TrOCR pour ZeroGPU HuggingFace Spaces
+torch>=2.0.0
+torchvision>=0.15.0
+transformers>=4.30.0
+spaces

utils.py

@@ -1,17 +1,15 @@
 # ==========================================
-# utils.py - Fonctions communes CPU/GPU (VERSION SANS BASE64)
+# utils.py - Fonctions communes GPU simplifiées
 # ==========================================
 
 """
-Utilitaires partagés pour le traitement d'images OCR
-Fonctions communes aux versions CPU et GPU - Format Image natif
+Utilitaires partagés pour le traitement d'images OCR GPU
 """
 
 from PIL import Image, ImageEnhance
 import numpy as np
 import gc
 import os
-import time
 
 def create_white_canvas(width: int = 300, height: int = 300) -> Image.Image:
     """Crée un canvas blanc pour le dessin de calculs"""
@@ -28,12 +26,18 @@ def log_memory_usage(context: str = "") -> None:
         pass
 
 def cleanup_memory() -> None:
-    """Force le nettoyage mémoire"""
+    """Force le nettoyage mémoire GPU"""
     gc.collect()
+    try:
+        import torch
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+    except:
+        pass
 
 def optimize_image_for_ocr(image_dict: dict | np.ndarray | Image.Image | None, max_size: int = 300) -> Image.Image | None:
     """
-    Optimisation image commune pour tous types d'OCR
+    Optimisation image pour OCR GPU
     
     Args:
         image_dict: Image d'entrée (format Gradio, numpy ou PIL)
@@ -121,14 +125,13 @@ def create_thumbnail_fast(optimized_image: Image.Image | None, size: tuple[int,
         size: Taille de la miniature (largeur, hauteur)
         
     Returns:
-        HTML img tag avec image base64 ou icône par défaut (pour affichage uniquement)
+        HTML img tag avec image base64 ou icône par défaut
     """
     try:
         if optimized_image is None:
             return "📝"
             
         # Pour l'affichage dans l'interface, on garde le base64 temporairement
-        # mais seulement pour les miniatures d'affichage
         import base64
         from io import BytesIO
         
@@ -171,41 +174,4 @@ def validate_ocr_result(raw_result: str, max_length: int = 4) -> str:
         # Si trop long, prendre les premiers chiffres
         return cleaned_result[:max_length]
     else:
-        return "0"
-
-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
-    
-    if operation == "×":
-        complexity_score = max(operand_a, operand_b)
-    elif operation == "+":
-        complexity_score = (operand_a + operand_b) / 20
-    elif operation == "-":
-        complexity_score = max(operand_a, operand_b) / 10
-    elif operation == "÷":
-        complexity_score = operand_a / 10
-    
-    # Catégorisation
-    if complexity_score < 5:
-        category = "easy"
-    elif complexity_score < 10:
-        category = "medium"
-    else:
-        category = "hard"
-    
-    return {
-        "complexity_score": round(complexity_score, 2),
-        "difficulty_category": category,
-        "operation_type": operation
-    }
+        return "0"