Upload 2 files

app.py

@@ -1,17 +1,15 @@
 # ==========================================
-# app.py - Calcul OCR v3.0 - Version GPU simplifiée
+# app.py - Calcul OCR v3.0 - Version ultra-simplifiée
 # ==========================================
 
 """
-Application principale optimisée pour ZeroGPU HuggingFace Spaces
+Application principale ultra-simplifiée pour ZeroGPU HuggingFace Spaces
+OCR en fin de session uniquement - Performance optimale
 """
 
 import gradio as gr
 import warnings
 import os
-import gc
-import numpy as np
-from PIL import Image
 
 warnings.filterwarnings("ignore")
 
@@ -19,7 +17,7 @@ warnings.filterwarnings("ignore")
 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 (GPU)...")
+print("🚀 Initialisation Calcul OCR v3.0 (Ultra-simplifié)...")
 print("🔄 Chargement modèle TrOCR...")
 init_ocr_model()
 print("✅ Modèle TrOCR prêt")
@@ -29,24 +27,24 @@ def create_new_game_session():
     return MathGame()
 
 def start_game_wrapper(duration: str, operation: str, difficulty: str, game_state) -> tuple:
-    """Wrapper avec isolation de session"""
+    """Démarre une nouvelle session de jeu"""
     if game_state is None:
         game_state = create_new_game_session()
     
     cleanup_memory()
     result = game_state.start_game(duration, operation, difficulty)
-    return result + (game_state, "")  # Retourner l'état mis à jour
+    return result + (game_state, "")
 
 def next_question_wrapper(image_data, game_state) -> tuple:
-    """Wrapper avec isolation de session"""
+    """Passe à la question suivante - Stockage simple, pas d'OCR"""
     if game_state is None:
         game_state = create_new_game_session()
     
     result = game_state.next_question(image_data)
-    return result + (game_state,)  # Retourner l'état mis à jour
+    return result + (game_state,)
 
 def export_current_session(game_state) -> str:
-    """Export avec isolation de session"""
+    """Export de la session vers le dataset"""
     if game_state is None:
         return "❌ Aucune session active"
     
@@ -81,7 +79,7 @@ def export_current_session(game_state) -> str:
         game_state.export_status = "not_exported"
         return f"❌ Erreur export: {str(e)}"
 
-# Interface Gradio avec State management
+# Interface Gradio
 with gr.Blocks(
     title="🧮 Calcul OCR - Entraînement mathématiques",
     theme=gr.themes.Soft(),
@@ -111,7 +109,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 - Isolation par utilisateur
     game_state = gr.State(value=None)
 
     gr.Markdown(
@@ -125,6 +123,8 @@ with gr.Blocks(
         4. Cliquez sur **➡️ NEXT !** pour la question suivante
         
         À la fin, vous pourrez consulter vos résultats et contribuer au dataset ouvert !
+        
+        🚀 **Version ultra-optimisée** : OCR en fin de session pour une fluidité maximale !
         """
     )
     
@@ -180,11 +180,11 @@ with gr.Blocks(
     # Résultats
     results_display = gr.HTML("")
 
-    # Export vers dataset dédié
+    # Export vers dataset
     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
     go_button.click(
         fn=start_game_wrapper,
         inputs=[duration_choice, operation_choice, difficulty_choice, game_state],
@@ -204,8 +204,9 @@ with gr.Blocks(
     )
 
 if __name__ == "__main__":
-    print("🚀 Lancement Calcul OCR v3.0 - Version GPU simplifiée")
+    print("🚀 Lancement Calcul OCR v3.0 - Ultra-simplifié")
     print("🎯 ZeroGPU HuggingFace Spaces")
+    print("⚡ Performance optimale : OCR en fin de session")
     print("🎯 Dataset: calcul_ocr_dataset")
     print("📊 Opérations: ×, +, -, ÷, Aléatoire")
     print("⚙️ Durées: 30s, 60s")

game_engine.py

@@ -1,9 +1,10 @@
 # ==========================================
-# game_engine.py - Calcul OCR v3.0 GPU simplifié
+# game_engine.py - Calcul OCR v3.0 ULTRA SIMPLIFIÉ
 # ==========================================
 
 """
-Moteur de jeu mathématique optimisé pour ZeroGPU HuggingFace Spaces
+Moteur de jeu mathématique ultra-simplifié pour ZeroGPU
+OCR en fin de session uniquement - Performance optimale
 """
 
 import random
@@ -15,9 +16,6 @@ import uuid
 import gc
 import numpy as np
 from PIL import Image
-import threading
-import queue
-from typing import Dict, Tuple, Optional
 
 # Import GPU uniquement
 from image_processing_gpu import (
@@ -25,19 +23,10 @@ from image_processing_gpu import (
     create_thumbnail_fast, 
     create_white_canvas,
     cleanup_memory,
-    log_memory_usage,
     get_ocr_model_info
 )
 
-print("✅ Game Engine: Mode GPU TrOCR")
-
-# 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": "TrOCR", "device": "ZeroGPU"}
+print("✅ Game Engine: Mode GPU ultra-simplifié")
 
 # Imports dataset
 try:
@@ -60,22 +49,17 @@ DIFFICULTY_RANGES = {
 }
 
 def create_result_row_with_images(i: int, image: dict | np.ndarray | Image.Image, expected: int, operation_data: tuple[int, int, str, int]) -> dict:
+    """Traite une image avec OCR et génère la ligne de résultat"""
     
-    print(f"🔍 create_result_row_with_images #{i}")
-    print(f"🔍 Expected: {expected}")
-    print(f"🔍 Image type: {type(image)}")
+    print(f"🔍 Traitement OCR image #{i+1}")
     
-    # OCR optimisé avec debug
+    # OCR avec TrOCR
     recognized, optimized_image, dataset_image_data = recognize_number_fast_with_image(image, debug=True)
     
-    print(f"🔍 OCR recognized: '{recognized}' (type: {type(recognized)})")
-    
     try:
         recognized_num = int(recognized) if recognized.isdigit() else 0
     except:
         recognized_num = 0
-        
-    print(f"🔍 OCR parsed num: {recognized_num}")
 
     is_correct = recognized_num == expected
     a, b, operation, correct_result = operation_data
@@ -84,10 +68,10 @@ 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 affichage
     image_thumbnail = create_thumbnail_fast(optimized_image, size=(50, 50))
     
-    # Libérer mémoire
+    # Libérer mémoire optimisée
     if optimized_image and hasattr(optimized_image, 'close'):
         try:
             optimized_image.close()
@@ -115,7 +99,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 GPU"""
+    """Moteur de jeu mathématique ultra-simplifié"""
     
     def __init__(self):
         self.is_running = False
@@ -138,12 +122,6 @@ class MathGame:
         self.export_status = "not_exported"
         self.export_timestamp = None
         self.export_result = None
-        
-        # Traitement parallèle
-        self.processing_queue = queue.Queue()
-        self.results_cache: Dict[int, dict] = {}
-        self.worker_thread: Optional[threading.Thread] = None
-        self.processing_active = False
 
     def get_export_status(self) -> dict[str, str | bool | None]:
         return {
@@ -161,54 +139,6 @@ class MathGame:
         self.export_status = "exported"
         self.export_result = result
 
-    def _start_background_processing(self) -> None:
-        """Démarre le thread de traitement en arrière-plan"""
-        if self.worker_thread is None or not self.worker_thread.is_alive():
-            self.processing_active = True
-            self.worker_thread = threading.Thread(target=self._process_images_worker, daemon=True)
-            self.worker_thread.start()
-            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 GPU parallèle")
-
-    def _process_images_worker(self) -> None:
-        """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 GPU parallèle image {question_num}...")
-                    
-                    start_time = time.time()
-                    result_data = create_result_row_with_images(question_num, image, expected, operation_data)
-                    processing_time = time.time() - start_time
-                    
-                    # Stocker le résultat
-                    self.results_cache[question_num] = result_data
-                    print(f"✅ Image {question_num} traitée en {processing_time:.1f}s (GPU parallèle)")
-                    
-                else:
-                    time.sleep(0.1)
-                    
-            except queue.Empty:
-                continue
-            except Exception as e:
-                print(f"❌ Erreur traitement GPU parallèle: {e}")
-                
-        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 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 GPU")
-
     def generate_multiplication(self, difficulty: str) -> tuple[str, int]:
         """Génère une multiplication"""
         min_val, max_val = DIFFICULTY_RANGES["×"][difficulty]
@@ -265,7 +195,7 @@ class MathGame:
         self.operation_type = operation
         self.difficulty = difficulty
         
-        # Nettoyage
+        # Nettoyage simple
         if hasattr(self, 'user_images') and self.user_images:
             for img in self.user_images:
                 if hasattr(img, 'close'):
@@ -274,21 +204,7 @@ class MathGame:
                     except:
                         pass
         
-        if hasattr(self, 'session_data') and self.session_data:
-            for entry in self.session_data:
-                if 'user_drawing' in entry and entry['user_drawing']:
-                    entry['user_drawing'] = None
-            self.session_data.clear()
-        
-        # Réinit avec nettoyage parallèle
-        self._stop_background_processing()
-        self.results_cache.clear()
-        while not self.processing_queue.empty():
-            try:
-                self.processing_queue.get_nowait()
-            except queue.Empty:
-                break
-        
+        # Réinitialisation complète
         self.is_running = True
         self.start_time = time.time()
         self.user_images = []
@@ -303,9 +219,6 @@ class MathGame:
         self.export_timestamp = None
         self.export_result = None
         
-        # Démarrer le traitement parallèle GPU
-        self._start_background_processing()
-        
         gc.collect()
 
         # Première opération
@@ -318,7 +231,7 @@ class MathGame:
         a, op, b = int(parts[0]), parts[1], int(parts[2])
         self.operations_history.append((a, b, op, answer))
 
-        # Affichage adapté selon l'opération
+        # Affichage
         operation_emoji = {
             "×": "✖️", "+": "➕", "-": "➖", "÷": "➗", "Aléatoire": "🎲"
         }
@@ -335,6 +248,8 @@ class MathGame:
         )
 
     def next_question(self, image_data: dict | np.ndarray | Image.Image | None) -> tuple[str, Image.Image, str, str, gr.update, gr.update, str]:
+        """Passe à la question suivante - STOCKAGE SIMPLE, PAS D'OCR"""
+        
         if not self.is_running:
             return (
                 f'<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;">{self.current_operation}</div>',
@@ -350,20 +265,12 @@ class MathGame:
         if elapsed_time >= self.duration:
             return self.end_game(image_data)
 
+        # STOCKAGE SIMPLE - PAS D'OCR pendant le jeu !
         if image_data is not None:
-            # Ajouter l'image à la liste ET au traitement parallèle GPU
             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 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
+            print(f"📝 Image {self.question_count} stockée (pas d'OCR pendant le jeu)")
 
         # Nouvelle opération
         operation_str, answer = self.generate_operation(self.operation_type, self.difficulty)
@@ -398,47 +305,27 @@ class MathGame:
         )
 
     def end_game(self, final_image: dict | np.ndarray | Image.Image | None) -> tuple[str, Image.Image, str, str, gr.update, gr.update, str]:
+        """Fin de jeu - OCR DE TOUTES LES IMAGES EN SÉQUENTIEL"""
 
         self.is_running = False
         
-        # Arrêter le traitement parallèle GPU
-        self._stop_background_processing()
-        
-        print("🏁 Fin de jeu - Assemblage des résultats GPU...")
+        print("🏁 Fin de jeu - Début OCR séquentiel de toutes les images...")
 
+        # Ajouter la dernière image si présente
         if final_image is not None:
             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 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
-            
             self.question_count += 1
+            
+            # Ajouter l'opération finale à l'historique si nécessaire
             if len(self.operations_history) < len(self.user_images):
+                parts = self.current_operation.split()
+                a, op, b = int(parts[0]), parts[1], int(parts[2])
                 self.operations_history.append((a, b, op, self.correct_answer))
 
-        # 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 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 GPU prêts")
-
-        # Assembler les résultats dans l'ordre
-        correct_answers = 0
+        # OCR SÉQUENTIEL SIMPLE de toutes les images
         total_questions = len(self.user_images)
+        correct_answers = 0
         table_rows_html = ""
         
         session_timestamp = datetime.datetime.now().isoformat()
@@ -447,36 +334,30 @@ class MathGame:
         self.session_data = []
         images_saved = 0
         
-        print(f"📊 Assemblage de {total_questions} résultats GPU...")
+        print(f"🔄 Traitement OCR séquentiel de {total_questions} images...")
         
+        # Boucle simple - une image à la fois
         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 GPU parallèle")
-            else:
-                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:
-                    row_data = {
-                        'html_row': f'<tr><td>{i+1}</td><td colspan="7">Erreur traitement</td></tr>',
-                        'is_correct': False,
-                        'recognized': "0",
-                        'recognized_num': 0,
-                        'dataset_image_data': None
-                    }
+            print(f"📷 OCR image {i+1}/{total_questions}...")
+            
+            # OCR de cette image
+            row_data = create_result_row_with_images(
+                i, 
+                self.user_images[i], 
+                self.expected_answers[i], 
+                self.operations_history[i] if i < len(self.operations_history) else (0, 0, "×", 0)
+            )
             
             table_rows_html += row_data['html_row']
             
             if row_data['is_correct']:
                 correct_answers += 1
 
-            # Structure pour dataset avec info OCR GPU
+            # Structure pour dataset
             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 GPU: {ocr_info_data}")
             except Exception as e:
                 print(f"❌ Erreur get_ocr_model_info: {e}")
                 ocr_info_data = {"model_name": "TrOCR", "device": "ZeroGPU"}
@@ -491,21 +372,19 @@ class MathGame:
                 "operand_a": a,
                 "operand_b": b,
                 "operation": operation,
-                "correct_answer": self.expected_answers[i] if i < len(self.expected_answers) else 0,
+                "correct_answer": self.expected_answers[i],
                 "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_gpu_simplified"
+                "app_version": "3.0_calcul_ocr_ultra_simplified"
             }
             
-            print(f"🔍 Debug entry OCR GPU: ocr_model={entry['ocr_model']}, ocr_device={entry['ocr_device']}")
-            
             # 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["handwriting_image"] = row_data['dataset_image_data']["handwriting_image"]
                 entry["image_width"] = int(row_data['dataset_image_data']["width"])
                 entry["image_height"] = int(row_data['dataset_image_data']["height"])
                 entry["has_image"] = True
@@ -517,10 +396,11 @@ class MathGame:
 
         accuracy = (correct_answers / total_questions * 100) if total_questions > 0 else 0
         
+        # Ajouter accuracy à toutes les entrées
         for entry in self.session_data:
             entry["session_accuracy"] = accuracy
 
-        # Nettoyage mémoire GPU
+        # Nettoyage mémoire
         for img in self.user_images:
             if hasattr(img, 'close'):
                 try:
@@ -528,7 +408,9 @@ class MathGame:
                 except:
                     pass
         
-        gc.collect()
+        cleanup_memory()
+
+        print(f"✅ OCR terminé: {correct_answers}/{total_questions} correct ({accuracy:.1f}%)")
 
         # HTML résultats
         table_html = f"""
@@ -542,7 +424,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 GPU</th>
+                        <th style="padding: 8px;">OCR</th>
                         <th style="padding: 8px;">Statut</th>
                     </tr>
                 </thead>
@@ -555,20 +437,16 @@ class MathGame:
 
         # Configuration session pour affichage
         config_display = f"{self.operation_type} • {self.difficulty} • {self.duration}s"
-        operation_emoji = {
-            "×": "✖️", "+": "➕", "-": "➖", "÷": "➗", "Aléatoire": "🎲"
-        }
-        emoji = operation_emoji.get(self.operation_type, "🔢")
-
+        
         export_info = self.get_export_status()
         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 (GPU)</h3>
+                <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} images natives sauvegardées<br>
-                    🎯 OCR: TrOCR ZeroGPU<br>
+                    🖼️ {images_saved} images sauvegardées<br>
+                    🤖 OCR: TrOCR ZeroGPU (séquentiel)<br>
                     ⚙️ Configuration: {config_display}
                 </p>
             </div>
@@ -579,7 +457,7 @@ class MathGame:
         final_results = f"""
         <div style="margin: 20px 0;">
             <div style="background: linear-gradient(45deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 10px; margin: 20px 0;">
-                <h2 style="text-align: center; color: #4a90e2;">🎉 Session terminée !</h2>
+                <h2 style="text-align: center;">🎉 Session terminée !</h2>
                 <div style="display: flex; justify-content: space-around; flex-wrap: wrap;">
                     <div style="text-align: center; margin: 10px;">
                         <div style="font-size: 2em; font-weight: bold;">{total_questions}</div>
@@ -599,7 +477,7 @@ class MathGame:
                     </div>
                 </div>
             </div>
-            <h2 style="color: #4a90e2;">📊 Détail des Réponses (TrOCR GPU)</h2>
+            <h2 style="color: #4a90e2;">📊 Détail des Réponses (TrOCR séquentiel)</h2>
             {table_html}
             {export_section}
         </div>
@@ -608,7 +486,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 GPU {config_display} terminée !",
+            f"✨ Session {config_display} terminée !",
             "⏱️ Temps écoulé !",
             gr.update(interactive=True),
             gr.update(interactive=False),
@@ -617,7 +495,7 @@ class MathGame:
 
 
 def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None) -> str:
-    """Export vers le dataset avec images natives optimisé GPU"""
+    """Export vers le dataset - Version simplifiée"""
     if dataset_name is None:
         dataset_name = DATASET_NAME
         
@@ -626,71 +504,40 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
     
     hf_token = os.getenv("HF_TOKEN") or os.getenv("tk_calcul_ocr")
     if not hf_token:
-        return "❌ Token HuggingFace manquant (HF_TOKEN ou tk_calcul_ocr)"
+        return "❌ Token HuggingFace manquant"
     
     try:
-        print(f"\n🚀 === EXPORT VERS DATASET CALCUL OCR GPU ===")
+        print(f"\n🚀 === EXPORT DATASET ULTRA-SIMPLIFIÉ ===")
         print(f"📊 Dataset: {dataset_name}")
         
-        # Filtrer les entrées avec images et ajouter les infos OCR GPU
-        clean_entries = []
-        
-        # Récupérer les infos OCR GPU pour toute la session
-        try:
-            global_ocr_info = get_ocr_model_info()
-            print(f"🔍 Infos OCR GPU globales: {global_ocr_info}")
-        except Exception as e:
-            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 GPU
-                entry_with_ocr = entry.copy()
-                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 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)
+        # Filtrer les entrées avec images
+        clean_entries = [entry for entry in session_data if entry.get('has_image', False)]
         
         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 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
         try:
             existing_dataset = load_dataset(dataset_name, split="train")
             existing_data = existing_dataset.to_list()
-            print(f"📊 {len(existing_data)} entrées existantes trouvées")
+            print(f"📊 {len(existing_data)} entrées existantes")
             
-            # 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")
+            print(f"📊 Dataset combiné: {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
+            print(f"📊 Nouveau dataset: {e}")
             clean_dataset = Dataset.from_list(clean_entries)
-            print(f"📊 Nouveau dataset créé avec {len(clean_entries)} entrées")
         
-        # Spécifier que la colonne handwriting_image est de type Image
+        # Conversion colonne image
         try:
             clean_dataset = clean_dataset.cast_column("handwriting_image", DatasetImage())
-            print("✅ Colonne handwriting_image convertie au type Image natif")
+            print("✅ Colonne image convertie")
         except Exception as e:
-            print(f"⚠️ Impossible de convertir au type Image: {e}")
-        
-        print(f"✅ Dataset GPU créé - Features:")
-        for feature_name in clean_dataset.features:
-            print(f"  - {feature_name}: {clean_dataset.features[feature_name]}")
+            print(f"⚠️ Conversion image: {e}")
         
-        # Statistiques par opération
+        # Statistiques
         operations_count = {}
         for entry in clean_entries:
             op = entry.get('operation_type', 'unknown')
@@ -699,30 +546,26 @@ 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 GPU vers {dataset_name}...")
+        print(f"📤 Push vers {dataset_name}...")
         clean_dataset.push_to_hub(
             dataset_name,
             private=False,
             token=hf_token,
-            commit_message=f"Add {len(clean_entries)} GPU TrOCR native image samples for math OCR ({operations_summary})"
+            commit_message=f"Add {len(clean_entries)} ultra-simplified samples ({operations_summary})"
         )
         
         cleanup_memory()
         
-        return f"""### ✅ Session GPU ajoutée au dataset avec succès !
+        return f"""### ✅ Session ajoutée avec succès !
 
 📊 **Dataset:** {dataset_name}  
-🖼️ **Images natives (GPU):** {len(clean_entries)}  
-🎯 **OCR:** TrOCR ZeroGPU  
+🖼️ **Images:** {len(clean_entries)}  
 🔢 **Opérations:** {operations_summary}  
 📈 **Total:** {len(clean_dataset)}  
 
-🔗 **Le dataset est consultable ici :** <a href="https://huggingface.co/datasets/{dataset_name}" target="_blank" rel="noopener noreferrer">{dataset_name}</a>
+🔗 <a href="https://huggingface.co/datasets/{dataset_name}" target="_blank">{dataset_name}</a>
 """
-
         
     except Exception as e:
-        print(f"❌ ERREUR GPU: {e}")
-        import traceback
-        traceback.print_exc()
-        return f"❌ Erreur GPU: {str(e)}"
+        print(f"❌ ERREUR: {e}")
+        return f"❌ Erreur: {str(e)}"