Upload 2 files

app.py

@@ -123,8 +123,7 @@ 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 !
+
         """
     )
     
@@ -132,26 +131,26 @@ with gr.Blocks(
     duration_choice = gr.Radio(
         choices=["30 secondes", "60 secondes"],
         value="30 secondes",
-        label="**⏱️ Durée**"
+        label="⏱️ Durée"
     )
 
     operation_choice = gr.Radio(
         choices=["×", "+", "-", "÷", "Aléatoire"],
         value="×",
-        label="**🔢 Opération**"
+        label="🔢 Opération"
     )
 
     difficulty_choice = gr.Radio(
         choices=["Facile", "Difficile"],
         value="Facile",
-        label="**🎯 Difficulté**"
+        label="🎯 Difficulté"
     )
     
     with gr.Row():
         with gr.Column(scale=1):
             # Question
             question_display = gr.HTML(
-                value='<div style="font-size: 2.5em; font-weight: bold; text-align: center; padding: 20px; background: linear-gradient(45deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px;">Prêt à jouer ?</div>'
+                value='<div style="font-size: 2.5em; font-weight: bold; text-align: center; padding: 20px; background: linear-gradient(45deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px;">Prêt(e) ?</div>'
             )
 
             # Contrôles

game_engine.py

@@ -1,10 +1,9 @@
 # ==========================================
-# game_engine.py - Calcul OCR v3.0 ULTRA SIMPLIFIÉ
+# game_engine.py - Avec métriques OCR et dataset optimisé
 # ==========================================
 
 """
-Moteur de jeu mathématique ultra-simplifié pour ZeroGPU
-OCR en fin de session uniquement - Performance optimale
+Moteur de jeu avec tracking complet des performances OCR
 """
 
 import random
@@ -26,7 +25,7 @@ from image_processing_gpu import (
     get_ocr_model_info
 )
 
-print("✅ Game Engine: Mode GPU ultra-simplifié")
+print("✅ Game Engine: Mode GPU avec métriques OCR")
 
 # Imports dataset
 try:
@@ -37,8 +36,8 @@ except ImportError as e:
     DATASET_AVAILABLE = False
     print(f"⚠️ Modules dataset non disponibles: {e}")
 
-# Dataset name
-DATASET_NAME = "hoololi/calcul_ocr_dataset_with_images_v2"
+# Dataset name avec nouvelle structure cohérente
+DATASET_NAME = "hoololi/CalcTrainer_dataset"
 
 # Configuration des difficultés par opération
 DIFFICULTY_RANGES = {
@@ -48,13 +47,17 @@ DIFFICULTY_RANGES = {
     "÷": {"Facile": (1, 10), "Difficile": (2, 12)}
 }
 
-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"""
+def create_result_row_with_metrics(i: int, image: dict | np.ndarray | Image.Image, expected: int, operation_data: tuple[int, int, str, int]) -> dict:
+    """Traite une image avec OCR et mesure les métriques"""
     
-    print(f"🔍 Traitement OCR image #{i+1}")
+    print(f"🔍 Traitement OCR image #{i+1}...")
     
-    # OCR avec TrOCR
-    recognized, optimized_image, dataset_image_data = recognize_number_fast_with_image(image, debug=True)
+    # Mesurer temps OCR précisément
+    ocr_start_time = time.time()
+    recognized, optimized_image, dataset_image_data = recognize_number_fast_with_image(image, debug=False)
+    ocr_processing_time = time.time() - ocr_start_time
+    
+    print(f"  ⏱️ OCR temps: {ocr_processing_time:.3f}s → '{recognized}'")
     
     try:
         recognized_num = int(recognized) if recognized.isdigit() else 0
@@ -71,7 +74,7 @@ def create_result_row_with_images(i: int, image: dict | np.ndarray | Image.Image
     # Miniature pour affichage
     image_thumbnail = create_thumbnail_fast(optimized_image, size=(50, 50))
     
-    # Libérer mémoire optimisée
+    # Libérer mémoire
     if optimized_image and hasattr(optimized_image, 'close'):
         try:
             optimized_image.close()
@@ -89,17 +92,19 @@ def create_result_row_with_images(i: int, image: dict | np.ndarray | Image.Image
                 <td style="text-align: center; padding: 8px; border: 1px solid #ddd;">{image_thumbnail}</td>
                 <td style="text-align: center; padding: 8px; border: 1px solid #ddd; font-weight: bold; color: #333;">{recognized_num}</td>
                 <td style="text-align: center; padding: 8px; border: 1px solid #ddd; color: #333;">{status_icon} {status_text}</td>
+                <td style="text-align: center; padding: 8px; border: 1px solid #ddd; color: #666; font-size: 0.9em;">{ocr_processing_time:.3f}s</td>
             </tr>
         """,
         'is_correct': is_correct,
         'recognized': recognized,
         'recognized_num': recognized_num,
-        'dataset_image_data': dataset_image_data
+        'dataset_image_data': dataset_image_data,
+        'ocr_processing_time': ocr_processing_time
     }
 
 
 class MathGame:
-    """Moteur de jeu mathématique ultra-simplifié"""
+    """Moteur de jeu avec métriques OCR complètes"""
     
     def __init__(self):
         self.is_running = False
@@ -305,11 +310,11 @@ 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"""
+        """Fin de jeu - OCR AVEC MÉTRIQUES COMPLÈTES"""
 
         self.is_running = False
         
-        print("🏁 Fin de jeu - Début OCR séquentiel de toutes les images...")
+        print("🏁 Fin de jeu - Début OCR avec métriques détaillées...")
 
         # Ajouter la dernière image si présente
         if final_image is not None:
@@ -323,7 +328,7 @@ class MathGame:
                 a, op, b = int(parts[0]), parts[1], int(parts[2])
                 self.operations_history.append((a, b, op, self.correct_answer))
 
-        # OCR SÉQUENTIEL SIMPLE de toutes les images
+        # OCR SÉQUENTIEL AVEC MÉTRIQUES
         total_questions = len(self.user_images)
         correct_answers = 0
         table_rows_html = ""
@@ -331,17 +336,31 @@ class MathGame:
         session_timestamp = datetime.datetime.now().isoformat()
         session_id = f"session_{int(datetime.datetime.now().timestamp())}_{str(uuid.uuid4())[:8]}"
         
+        # Métriques OCR globales
+        total_ocr_start_time = time.time()
+        ocr_times = []
+        
         self.session_data = []
         images_saved = 0
         
-        print(f"🔄 Traitement OCR séquentiel de {total_questions} images...")
+        print(f"🔄 Traitement OCR avec métriques de {total_questions} images...")
         
-        # Boucle simple - une image à la fois
+        # Récupérer infos modèle OCR une seule fois
+        try:
+            ocr_model_info = get_ocr_model_info()
+            model_name = ocr_model_info.get("model_name", "microsoft/trocr-base-handwritten")
+            hardware = f"{ocr_model_info.get('device', 'Unknown')}-{ocr_model_info.get('gpu_name', 'Unknown')}"
+        except Exception as e:
+            print(f"❌ Erreur get_ocr_model_info: {e}")
+            model_name = "microsoft/trocr-base-handwritten"
+            hardware = "ZeroGPU-Unknown"
+        
+        # Boucle OCR avec métriques
         for i in range(total_questions):
             print(f"📷 OCR image {i+1}/{total_questions}...")
             
-            # OCR de cette image
-            row_data = create_result_row_with_images(
+            # OCR avec métriques
+            row_data = create_result_row_with_metrics(
                 i, 
                 self.user_images[i], 
                 self.expected_answers[i], 
@@ -349,56 +368,92 @@ class MathGame:
             )
             
             table_rows_html += row_data['html_row']
+            ocr_times.append(row_data['ocr_processing_time'])
             
             if row_data['is_correct']:
                 correct_answers += 1
 
-            # Structure pour dataset
+            # Structure dataset optimisée
             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()
-            except Exception as e:
-                print(f"❌ Erreur get_ocr_model_info: {e}")
-                ocr_info_data = {"model_name": "TrOCR", "device": "ZeroGPU"}
+            # ID unique pour cette question
+            question_id = f"{session_id}_q{i+1:02d}"
             
             entry = {
+                # Identification
                 "session_id": session_id,
+                "question_id": question_id,
                 "timestamp": session_timestamp,
-                "question_number": i + 1,
-                "session_duration": self.duration,
-                "operation_type": self.operation_type,
-                "difficulty_level": self.difficulty,
+                
+                # Données mathématiques
                 "operand_a": a,
                 "operand_b": b,
                 "operation": operation,
                 "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'],
+                "difficulty": self.difficulty,
+                
+                # Données OCR
+                "ocr_prediction": row_data['recognized'],
+                "ocr_parsed_number": row_data['recognized_num'],
                 "is_correct": row_data['is_correct'],
-                "total_questions": total_questions,
-                "app_version": "3.0_calcul_ocr_ultra_simplified"
+                
+                # Métriques modèle OCR
+                "ocr_model_name": model_name,
+                "ocr_processing_time": row_data['ocr_processing_time'],
+                "ocr_confidence": 0.0,  # Non disponible avec TrOCR actuel
+                
+                # Métriques session (calculées à la fin)
+                "session_duration": self.duration,
+                "session_total_questions": total_questions,
+                
+                # Métadonnées techniques
+                "app_version": "3.1_with_ocr_metrics",
+                "hardware": hardware
             }
             
             # Image PIL native pour dataset
             if row_data['dataset_image_data']:
                 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
                 images_saved += 1
-            else:
-                entry["has_image"] = False
                 
             self.session_data.append(entry)
 
+        # Calculs finaux métriques
+        total_ocr_time = time.time() - total_ocr_start_time
+        avg_ocr_time = sum(ocr_times) / len(ocr_times) if ocr_times else 0.0
         accuracy = (correct_answers / total_questions * 100) if total_questions > 0 else 0
         
-        # Ajouter accuracy à toutes les entrées
+        # Ajouter métriques session à toutes les entrées
         for entry in self.session_data:
             entry["session_accuracy"] = accuracy
+            entry["session_total_ocr_time"] = total_ocr_time
+            entry["session_avg_ocr_time"] = avg_ocr_time
+
+        # Statistiques détaillées
+        print(f"📊 === MÉTRIQUES OCR COMPLÈTES ===")
+        print(f"📷 Images traitées: {total_questions}")
+        print(f"⏱️ Temps total OCR: {total_ocr_time:.2f}s")
+        print(f"⚡ Temps moyen/image: {avg_ocr_time:.3f}s")
+        print(f"🎯 Précision: {accuracy:.1f}%")
+        print(f"🤖 Modèle: {model_name}")
+        print(f"💻 Hardware: {hardware}")
+        
+        # Statistiques par opération
+        operations_stats = {}
+        for entry in self.session_data:
+            op = entry['operation']
+            if op not in operations_stats:
+                operations_stats[op] = {'correct': 0, 'total': 0, 'times': []}
+            operations_stats[op]['total'] += 1
+            operations_stats[op]['times'].append(entry['ocr_processing_time'])
+            if entry['is_correct']:
+                operations_stats[op]['correct'] += 1
+        
+        print(f"📈 Détail par opération:")
+        for op, stats in operations_stats.items():
+            op_accuracy = (stats['correct'] / stats['total'] * 100) if stats['total'] > 0 else 0
+            op_avg_time = sum(stats['times']) / len(stats['times']) if stats['times'] else 0
+            print(f"  {op}: {op_accuracy:.1f}% précision, {op_avg_time:.3f}s/image ({stats['total']} images)")
 
         # Nettoyage mémoire
         for img in self.user_images:
@@ -410,9 +465,7 @@ class MathGame:
         
         cleanup_memory()
 
-        print(f"✅ OCR terminé: {correct_answers}/{total_questions} correct ({accuracy:.1f}%)")
-
-        # HTML résultats
+        # HTML résultats avec colonne temps
         table_html = f"""
         <div style="overflow-x: auto; margin: 20px 0;">
             <table style="width: 100%; border-collapse: collapse; border: 2px solid #4a90e2;">
@@ -426,6 +479,7 @@ class MathGame:
                         <th style="padding: 8px;">Votre dessin</th>
                         <th style="padding: 8px;">OCR</th>
                         <th style="padding: 8px;">Statut</th>
+                        <th style="padding: 8px;">Temps OCR</th>
                     </tr>
                 </thead>
                 <tbody>
@@ -442,11 +496,13 @@ 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;">📊 Métriques de la série</h3>
                 <p style="color: #2e7d32;">
                     ✅ {total_questions} réponses • 📊 {accuracy:.1f}% de précision<br>
                     🖼️ {images_saved} images sauvegardées<br>
-                    🤖 OCR: TrOCR ZeroGPU (séquentiel)<br>
+                    ⏱️ OCR: {total_ocr_time:.2f}s total, {avg_ocr_time:.3f}s/image<br>
+                    🤖 Modèle: {model_name}<br>
+                    💻 Hardware: {hardware}<br>
                     ⚙️ Configuration: {config_display}
                 </p>
             </div>
@@ -475,9 +531,13 @@ class MathGame:
                         <div style="font-size: 2em; font-weight: bold;">{accuracy:.1f}%</div>
                         <div>Précision</div>
                     </div>
+                    <div style="text-align: center; margin: 10px;">
+                        <div style="font-size: 1.5em; font-weight: bold; color: #87CEEB;">{avg_ocr_time:.3f}s</div>
+                        <div>Temps/image</div>
+                    </div>
                 </div>
             </div>
-            <h2 style="color: #4a90e2;">📊 Détail des Réponses (TrOCR séquentiel)</h2>
+            <h2 style="color: #4a90e2;">📊 Détail des Réponses avec Métriques OCR</h2>
             {table_html}
             {export_section}
         </div>
@@ -494,8 +554,8 @@ class MathGame:
         )
 
 
-def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None) -> str:
-    """Export vers le dataset - Version simplifiée"""
+def export_to_optimized_dataset(session_data: list[dict], dataset_name: str = None) -> str:
+    """Export vers le dataset optimisé avec métriques OCR"""
     if dataset_name is None:
         dataset_name = DATASET_NAME
         
@@ -507,15 +567,28 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
         return "❌ Token HuggingFace manquant"
     
     try:
-        print(f"\n🚀 === EXPORT DATASET ULTRA-SIMPLIFIÉ ===")
+        print(f"\n🚀 === EXPORT DATASET OPTIMISÉ AVEC MÉTRIQUES ===")
         print(f"📊 Dataset: {dataset_name}")
         
         # Filtrer les entrées avec images
-        clean_entries = [entry for entry in session_data if entry.get('has_image', False)]
+        clean_entries = [entry for entry in session_data if entry.get('handwriting_image') is not None]
         
         if len(clean_entries) == 0:
             return "❌ Aucune entrée avec image à exporter"
         
+        # Statistiques pré-export
+        total_ocr_time = clean_entries[0].get('session_total_ocr_time', 0)
+        avg_ocr_time = clean_entries[0].get('session_avg_ocr_time', 0)
+        model_name = clean_entries[0].get('ocr_model_name', 'Unknown')
+        session_accuracy = clean_entries[0].get('session_accuracy', 0)
+        
+        print(f"📈 Métriques session:")
+        print(f"  - {len(clean_entries)} images")
+        print(f"  - {session_accuracy:.1f}% précision")
+        print(f"  - {total_ocr_time:.2f}s total OCR")
+        print(f"  - {avg_ocr_time:.3f}s/image")
+        print(f"  - Modèle: {model_name}")
+        
         # Charger dataset existant et combiner
         try:
             existing_dataset = load_dataset(dataset_name, split="train")
@@ -537,35 +610,54 @@ def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None)
         except Exception as e:
             print(f"⚠️ Conversion image: {e}")
         
-        # Statistiques
+        # Statistiques par opération pour commit message
         operations_count = {}
         for entry in clean_entries:
-            op = entry.get('operation_type', 'unknown')
+            op = entry.get('operation', 'unknown')
             operations_count[op] = operations_count.get(op, 0) + 1
         
         operations_summary = ", ".join([f"{op}: {count}" for op, count in operations_count.items()])
         
+        # Message de commit enrichi avec métriques
+        commit_message = f"""Add {len(clean_entries)} samples with OCR metrics
+        
+Model: {model_name}
+Accuracy: {session_accuracy:.1f}%
+Avg OCR time: {avg_ocr_time:.3f}s/image
+Operations: {operations_summary}
+Hardware: {clean_entries[0].get('hardware', 'Unknown')}
+"""
+        
         # Push vers HuggingFace  
         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)} ultra-simplified samples ({operations_summary})"
+            commit_message=commit_message
         )
         
         cleanup_memory()
         
-        return f"""### ✅ Session ajoutée avec succès !
+        return f"""### ✅ Session ajoutée au dataset optimisé !
 
 📊 **Dataset:** {dataset_name}  
 🖼️ **Images:** {len(clean_entries)}  
+🎯 **Précision:** {session_accuracy:.1f}%  
+⏱️ **Performance:** {avg_ocr_time:.3f}s/image (total: {total_ocr_time:.1f}s)  
+🤖 **Modèle:** {model_name}  
 🔢 **Opérations:** {operations_summary}  
-📈 **Total:** {len(clean_dataset)}  
+📈 **Total dataset:** {len(clean_dataset)}  
 
 🔗 <a href="https://huggingface.co/datasets/{dataset_name}" target="_blank">{dataset_name}</a>
+
 """
         
     except Exception as e:
         print(f"❌ ERREUR: {e}")
-        return f"❌ Erreur: {str(e)}"
+        return f"❌ Erreur: {str(e)}"
+
+# Fonction de compatibilité pour ne pas casser l'interface
+def export_to_clean_dataset(session_data: list[dict], dataset_name: str = None) -> str:
+    """Wrapper pour compatibilité avec l'ancienne interface"""
+    return export_to_optimized_dataset(session_data, dataset_name)