Upload 8 files

.gitattributes

@@ -1,35 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.gguf filter=lfs diff=lfs merge=lfs -text
+*.traineddata filter=lfs diff=lfs merge=lfs -text
+models/ filter=lfs diff=lfs merge=lfs -text 

Dockerfile

@@ -0,0 +1,36 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Installation des dépendances système
+RUN apt-get update && apt-get install -y \
+    tesseract-ocr \
+    tesseract-ocr-fra \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copier les fichiers nécessaires
+COPY requirements.txt .
+COPY app.py .
+COPY ocr_module.py .
+COPY README.md .
+
+# Créer le dossier pour les modèles et les fichiers temporaires
+RUN mkdir -p /app/models /app/temp
+
+# Installer les dépendances Python
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Définir les variables d'environnement
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONIOENCODING=UTF-8
+ENV GRADIO_SERVER_NAME=0.0.0.0
+ENV GRADIO_SERVER_PORT=7860
+
+# Exposer le port
+EXPOSE 7860
+
+# Commande de démarrage
+CMD ["python", "app.py"] 

README.md

@@ -1,12 +1,47 @@
----
-title: ImageVersTexte
-emoji: 🐨
-colorFrom: pink
-colorTo: yellow
-sdk: docker
-pinned: false
-license: apache-2.0
-short_description: Transformation de vieux documents en texte
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# OCR et Modernisation de Texte
+
+Cette application permet d'extraire du texte à partir d'images (OCR) et de le moderniser en utilisant un modèle Mistral.
+
+## Fonctionnalités
+
+- Extraction de texte à partir d'images avec OCR
+- Reconnaissance de formules mathématiques (LaTeX)
+- Modernisation du texte ancien en français contemporain
+- Interface web simple et intuitive
+
+## Comment utiliser
+
+1. Téléchargez une image contenant du texte
+2. L'application extraira automatiquement le texte
+3. Le modèle Mistral modernisera le texte
+4. Les résultats seront affichés avec le texte original et sa version modernisée
+
+## Technique
+
+Cette application utilise:
+- Tesseract OCR pour l'extraction de texte
+- Mathpix (si disponible) pour les formules mathématiques
+- Un modèle Mistral quantifié (GGUF) pour la modernisation du texte
+- Gradio pour l'interface utilisateur
+- Flask pour l'API
+
+## API
+
+L'application expose également une API REST:
+
+```
+POST /api/ocr
+```
+
+Avec un fichier image dans le corps de la requête (multipart/form-data) sous le nom "image".
+
+## Installation locale
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+---
+
+Développé pour Hugging Face Spaces 

app.py

@@ -0,0 +1,176 @@
+import os
+import sys
+import gradio as gr
+from PIL import Image
+import tempfile
+import json
+from flask import Flask, request, jsonify
+from ctransformers import AutoModelForCausalLM
+
+# Import du module OCR
+from ocr_module import process_image as ocr_process
+
+# Chemins
+CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+MODEL_PATH = os.path.join(CURRENT_DIR, "models", "Mistral-7B-Instruct-v0.3.Q4_K_M.gguf")
+TEMP_DIR = os.path.join(CURRENT_DIR, "temp")
+
+# Créer le dossier temp s'il n'existe pas
+if not os.path.exists(TEMP_DIR):
+    os.makedirs(TEMP_DIR)
+
+# Vérifier l'existence du modèle
+if not os.path.exists(MODEL_PATH):
+    print(f"ATTENTION: Le modèle n'existe pas à {MODEL_PATH}")
+    print("Exécutez d'abord le script download_model.py pour copier le modèle")
+    # Tenter de trouver le modèle à l'emplacement alternatif (pour le développement)
+    alt_path = os.path.join(os.path.dirname(CURRENT_DIR), "models", "Mistral-7B-Instruct-v0.3.Q4_K_M.gguf")
+    if os.path.exists(alt_path):
+        print(f"Modèle trouvé à l'emplacement alternatif: {alt_path}")
+        MODEL_PATH = alt_path
+    else:
+        print("Aucun modèle trouvé. L'application risque de ne pas fonctionner correctement.")
+
+# Chargement du modèle Mistral
+try:
+    print(f"Chargement du modèle depuis: {MODEL_PATH}")
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_PATH,
+        model_type="mistral",
+        local_files_only=True,
+        gpu_layers=1
+    )
+    print("Modèle chargé avec succès")
+except Exception as e:
+    print(f"Erreur lors du chargement du modèle: {e}")
+    model = None
+
+# Fonction pour prétraiter et OCR une image
+def process_image(image):
+    try:
+        # Sauvegarder l'image temporairement
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.png', dir=TEMP_DIR) as temp_file:
+            temp_path = temp_file.name
+            if isinstance(image, str):  # Si c'est un chemin
+                Image.open(image).save(temp_path)
+            else:  # Si c'est un objet image
+                image.save(temp_path)
+        
+        # Appeler la fonction OCR du module
+        ocr_result = ocr_process(temp_path)
+        
+        # Supprimer le fichier temporaire
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+        
+        return ocr_result
+    except Exception as e:
+        return {"error": str(e)}
+
+# Fonction pour moderniser le texte avec Mistral
+def modernize_text(text):
+    try:
+        if model is None:
+            return {
+                "status": "error",
+                "error": "Modèle non disponible"
+            }
+            
+        # Créer le prompt pour le modèle
+        prompt = f"""<s>[INST] Tu es un assistant spécialisé dans la modernisation de textes anciens. 
+Modernise le texte suivant en français contemporain tout en préservant son sens:
+
+{text} [/INST]"""
+        
+        # Générer la réponse
+        response = model(prompt, max_new_tokens=1024, temperature=0.7)
+        
+        return {
+            "status": "success",
+            "modern_text": response.strip()
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "error": str(e)
+        }
+
+# Fonction principale pour l'interface Gradio
+def ocr_and_modernize(image):
+    # Extraire le texte de l'image
+    ocr_result = process_image(image)
+    
+    if "text" in ocr_result and ocr_result["text"]:
+        # Moderniser le texte
+        modernization_result = modernize_text(ocr_result["text"])
+        
+        if modernization_result["status"] == "success":
+            result = {
+                "Texte original": ocr_result["text"],
+                "Texte modernisé": modernization_result["modern_text"]
+            }
+            
+            # Si LaTeX est disponible
+            if "latex" in ocr_result and ocr_result["latex"]:
+                result["Formules LaTeX"] = ocr_result["latex"]
+                
+            return result
+        else:
+            return {
+                "Texte original": ocr_result["text"],
+                "Erreur": f"Échec de la modernisation: {modernization_result.get('error', 'Erreur inconnue')}"
+            }
+    else:
+        return {
+            "Erreur": f"Échec de l'OCR: {ocr_result.get('error', 'Aucun texte détecté')}"
+        }
+
+# Interface Gradio
+interface = gr.Interface(
+    fn=ocr_and_modernize,
+    inputs=gr.Image(type="pil"),
+    outputs=gr.JSON(),
+    title="OCR et Modernisation de Texte",
+    description="Téléchargez une image contenant du texte pour extraire et moderniser son contenu.",
+    examples=["exemple1.jpg", "exemple2.jpg"] if os.path.exists("exemple1.jpg") else None
+)
+
+# API Flask pour intégration
+app = Flask(__name__)
+
+@app.route("/api/ocr", methods=["POST"])
+def api_ocr():
+    if "image" not in request.files:
+        return jsonify({"error": "Aucune image n'a été fournie"}), 400
+    
+    file = request.files["image"]
+    temp_path = os.path.join(TEMP_DIR, "temp_" + str(hash(file.filename)) + ".png")
+    file.save(temp_path)
+    
+    try:
+        # Extraire le texte
+        ocr_result = process_image(temp_path)
+        
+        # Moderniser le texte
+        if "text" in ocr_result and ocr_result["text"]:
+            modernization_result = modernize_text(ocr_result["text"])
+            if modernization_result["status"] == "success":
+                ocr_result["original_text"] = ocr_result["text"]
+                ocr_result["text"] = modernization_result["modern_text"]
+                
+        return jsonify(ocr_result)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+    finally:
+        # Nettoyer
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+
+# Point d'entrée
+if __name__ == "__main__":
+    # Si exécuté sur HF Spaces, utiliser Gradio
+    if os.environ.get("SPACE_ID"):
+        interface.launch()
+    else:
+        # En local, démarrer le serveur Flask
+        app.run(host="0.0.0.0", port=7860, debug=True) 

download_model.py

@@ -0,0 +1,57 @@
+import os
+import sys
+import shutil
+import argparse
+
+def copy_model(source_path, destination_dir):
+    """Copier le modèle GGUF depuis le répertoire source vers le répertoire destination"""
+    try:
+        # Vérifier si le fichier source existe
+        if not os.path.exists(source_path):
+            print(f"Erreur: Le fichier source '{source_path}' n'existe pas.")
+            return False
+        
+        # Créer le répertoire de destination s'il n'existe pas
+        if not os.path.exists(destination_dir):
+            os.makedirs(destination_dir)
+        
+        # Construire le chemin complet de destination
+        destination_path = os.path.join(destination_dir, os.path.basename(source_path))
+        
+        # Copier le fichier
+        print(f"Copie du modèle de {source_path} vers {destination_path}...")
+        shutil.copy2(source_path, destination_path)
+        
+        print(f"Le modèle a été copié avec succès vers {destination_path}")
+        return True
+    
+    except Exception as e:
+        print(f"Erreur lors de la copie du modèle: {str(e)}")
+        return False
+
+def main():
+    parser = argparse.ArgumentParser(description="Copie un modèle GGUF depuis un répertoire source")
+    parser.add_argument("--source", default="../models/Mistral-7B-Instruct-v0.3.Q4_K_M.gguf", 
+                        help="Chemin vers le fichier du modèle source")
+    parser.add_argument("--dest", default="./models", 
+                        help="Répertoire de destination pour le modèle")
+    
+    args = parser.parse_args()
+    
+    # Obtenir les chemins absolus
+    # Obtenir le chemin absolu du répertoire courant
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    # Construire le chemin source absolu
+    source_path = os.path.abspath(os.path.join(current_dir, "..", "models", "Mistral-7B-Instruct-v0.3.Q4_K_M.gguf"))
+    destination_dir = os.path.join(current_dir, "models")
+    
+    print(f"Recherche du modèle à: {source_path}")
+    
+    # Copier le modèle
+    success = copy_model(source_path, destination_dir)
+    
+    # Terminer avec le code approprié
+    sys.exit(0 if success else 1)
+
+if __name__ == "__main__":
+    main() 

models/Qwen3-0.6B-Q8_0.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9465e63a22add5354d9bb4b99e90117043c7124007664907259bd16d043bb031
+size 639446688

ocr_module.py

@@ -0,0 +1,108 @@
+import os
+import sys
+import pytesseract
+import cv2
+import numpy as np
+from PIL import Image
+import json
+import logging
+import tempfile
+
+# Configuration du logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Chemin vers Tesseract (à ajuster selon l'environnement)
+if sys.platform.startswith('win'):
+    pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'
+
+# Répertoire temporaire
+TEMP_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "temp")
+if not os.path.exists(TEMP_DIR):
+    os.makedirs(TEMP_DIR)
+
+def preprocess_image(image_path):
+    """Prétraitement de l'image pour améliorer la reconnaissance OCR"""
+    try:
+        # Lire l'image avec OpenCV
+        img = cv2.imread(image_path)
+        if img is None:
+            logger.error(f"Impossible de lire l'image: {image_path}")
+            return None
+
+        # Convertir en niveaux de gris
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        
+        # Appliquer un filtre bilatéral pour réduire le bruit tout en préservant les bords
+        blur = cv2.bilateralFilter(gray, 9, 75, 75)
+        
+        # Normaliser la luminosité et le contraste
+        normalized = cv2.normalize(blur, None, 0, 255, cv2.NORM_MINMAX)
+        
+        # Seuillage adaptatif pour améliorer le contraste entre le texte et l'arrière-plan
+        thresh = cv2.adaptiveThreshold(normalized, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+                                       cv2.THRESH_BINARY, 11, 2)
+        
+        # Enregistrer l'image prétraitée
+        processed_image_path = os.path.join(TEMP_DIR, f"processed_{os.path.basename(image_path)}")
+        cv2.imwrite(processed_image_path, thresh)
+        
+        return processed_image_path
+    except Exception as e:
+        logger.error(f"Erreur lors du prétraitement de l'image: {str(e)}")
+        return None
+
+def perform_ocr(image_path, lang='fra'):
+    """Extraire le texte d'une image en utilisant Tesseract OCR"""
+    try:
+        # Prétraiter l'image
+        processed_image_path = preprocess_image(image_path)
+        if not processed_image_path:
+            processed_image_path = image_path  # Utiliser l'image originale si le prétraitement échoue
+        
+        # Configuration OCR
+        custom_config = r'--oem 3 --psm 6'
+        
+        # Effectuer l'OCR
+        text = pytesseract.image_to_string(Image.open(processed_image_path), lang=lang, config=custom_config)
+        
+        # Nettoyer le texte
+        text = text.strip()
+        
+        # Supprimer l'image prétraitée si elle existe
+        if processed_image_path != image_path and os.path.exists(processed_image_path):
+            os.remove(processed_image_path)
+            
+        return text
+    except Exception as e:
+        logger.error(f"Erreur OCR: {str(e)}")
+        return None
+
+def process_image(image_path, lang='fra'):
+    """Traiter une image et extraire son texte"""
+    try:
+        # Extraire le texte
+        extracted_text = perform_ocr(image_path, lang)
+        
+        if not extracted_text:
+            return {"error": "Aucun texte n'a pu être extrait de l'image"}
+        
+        # Préparer le résultat
+        result = {
+            "text": extracted_text,
+            "confidence": 0.9  # Valeur fictive car Tesseract ne fournit pas de score de confiance simple
+        }
+        
+        return result
+    except Exception as e:
+        logger.error(f"Erreur lors du traitement de l'image: {str(e)}")
+        return {"error": str(e)}
+
+# Test direct du module
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        image_path = sys.argv[1]
+        result = process_image(image_path)
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        print("Usage: python ocr_module.py <chemin_image>") 

requirements.txt

@@ -0,0 +1,9 @@
+gradio>=3.50.2
+pillow>=10.0.0
+flask>=2.0.0
+ctransformers>=0.2.24
+pytesseract>=0.3.10
+numpy>=1.24.0
+python-dotenv>=1.0.0
+transformers>=4.35.0
+opencv-python>=4.8.0