Projet de démonstration Deepseek-R1 avec Gradio et Easyocr

Dans ce guide pratique, j'utiliserai le modèle Deepseek-R1 pour construire un assistant de solveur de puzzle mathématique intégré à Easyocr et Gradio.

Je vais expliquer étape par étape comment créer une application Web fonctionnelle capable de résoudre un large éventail de puzzles mathématiques et de générer des solutions utiles en utilisant les excellentes capacités de raisonnement du modèle R1 Deepseek.

Si vous voulez seulement obtenir un aperçu de Deepseek-R1, je vous recommande de consulter cette vue d'ensemble Deepseek-R1. Pour affiner le modèle, je recommande ce didacticiel sur le tas fin de profondeur-R1.

Projet de démonstration Deepseek-R1: Présentation

Pour construire notre assistant de solveur de puzzle, nous passerons en revue les étapes suivantes:

• Configurez les conditions préalables nécessaires.
• Initialiser le modèle avec des configurations optimisées.
• Définissez les fonctionnalités centrales, en utilisant les capacités d'instruction du modèle.
• Intégrez les composants dans une interface Gradio conviviale pour une interaction facile.

Étape 1: Prérequis

Avant de plonger dans l'implémentation, assurez-vous que nous avons installé les outils et bibliothèques suivants:

• python 3.8
• pytorch: pour une manipulation efficace du modèle d'apprentissage en profondeur.
• Easyocr: un module Python pour extraire du texte de l'image.
• gradio: pour créer une interface Web conviviale.

Exécutez les commandes suivantes pour installer les dépendances nécessaires:

!pip install torch gradio pillow easyocr -q

Une fois les dépendances ci-dessus installées, exécutez les commandes d'importation suivantes:

Import torch
from PIL import Image
import easyocr
import requests
import json
import gradio as gr

Étape 2: Configuration de l'API Deepseek-R1

Le script suivant montre comment interagir avec l'API Deepseek pour obtenir des réponses en fonction des invites utilisateur. Notez que l'API de Deepseek est compatible avec le format d'Openai et utilise une URL de base pour les demandes d'API.

Vous pouvez soit transmettre directement la touche API (non recommandée pour des raisons de confidentialité), ou si vous utilisez Google Colab comme moi, vous pouvez enregistrer la clé API à l'aide de la fonction Secrets. Alternativement, vous pouvez utiliser des variables d'environnement.

# DeepSeek API configuration
DEEPSEEK_API_URL = "https://api.deepseek.com/v1/chat/completions"

# If you're using Colab and storing your key in the Secrets tab:
from google.colab import userdata
API_KEY = userdata.get('SECRET_KEY')

# If you are running this code elsewhere then, replace 'YOUR_API_KEY' with your actual DeepSeek API key. Uncomment the following line of code.
#API_KEY = 'YOUR_API_KEY' 

Au moment de la publication de cet article, les services de Deepseek sont soumis à une charge lourde et leurs performances sont dégradées - j'ai également eu des difficultés majeures à exécuter le code pour ce projet. Veuillez vérifier la page d'état de Deepseek avant d'essayer d'exécuter le code dans ce projet.

Étape 3: Concevoir les fonctionnalités principales

Maintenant, l'API est définie, nous pouvons travailler sur les fonctionnalités du code. Dans cette section, nous traiterons une image contenant un puzzle logique, extraire le texte du puzzle à l'aide de l'OCR, affiner le texte et l'envoyer à l'API Deepseek pour la résolution. Voyons d'abord le code, puis je vais l'expliquer.

reader = easyocr.Reader(['en'])

def solve_puzzle(image):
    """Extracts the puzzle from the image and sends it to DeepSeek for solving."""
    try:
        # 1. Save the uploaded image temporarily; EasyOCR uses file paths
        image_path = "uploaded_image.png"
        image.save(image_path)

        # 2. Extract text from the image using EasyOCR
        results = reader.readtext(image_path)
        extracted_text = " ".join([res[1] for res in results])

        # Standardize the text to avoid misinterpretation of "??" as "2?"
        extracted_text = extracted_text.replace('??', '?')
      
        if "?" not in extracted_text:
            extracted_text += "?"

        print("Extracted Text:", extracted_text)  # Debugging output

        # 3. Refine the extracted text to standardize expressions
        refined_text = extracted_text.replace('x', '*').replace('X', '*').replace('=', ' = ').strip()
        print("Refined Text:", refined_text)  # Debugging output

        # 4. Compose the user message with concise instructions
        puzzle_prompt = (
            f"You are an AI specialized in solving puzzles. Analyze the following, identify hidden patterns or rules, and provide the missing value with step-by-step reasoning in text format. Do not return an answer in Latex."
            f"\nPuzzle:\n{refined_text}\n"
            "Format your response strictly as follows:\n"
            "1. **Given Equation**:\n   - (original equations)\n"
            "2. **Pattern Identified**:\n   (explain the hidden logic)\n"
            "3. **Step-by-step Calculation**:\n   - For (input values):\n     (calculation and result)\n"
            "4. **Final Answer**:\n     (Answer = X)"
        )

        messages = [
            {"role": "user", "content": puzzle_prompt}
        ]

        # 5. Optimized API request for faster response
        data = {
            "model": "deepseek-reasoner",
            "messages": messages,
            "temperature": 0,  
            "max_tokens": 100  
        }

        headers = {
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        }

        # 6. Send the request to DeepSeek with a timeout
        response = requests.post(DEEPSEEK_API_URL, headers=headers, json=data, timeout=15)

        # 7. Check the result
        if response.status_code == 200:
            try:
                json_resp = response.json()
                return json_resp.get("choices", [{}])[0].get("message", {}).get("content", "Error: No response content.").strip()
            except json.JSONDecodeError:
                return "Error: Invalid JSON response from DeepSeek API."
        else:
            return f"Error: DeepSeek API failed with status code {response.status_code}, Response: {response.text}"
    except requests.exceptions.Timeout:
        return "Error: DeepSeek API request timed out. Please try again."
    except Exception as e:
        return f"Error: {str(e)}"

La fonction Solve_Puzzle () traite une image contenant un puzzle logique et le résout à l'aide du modèle OCR et R1. Il suit ces étapes:

1. Initialiser Easyocr: nous commençons par initialiser le lecteur Easyocr en anglais.
2. Traitement d'image: l'image téléchargée est enregistrée temporairement et traitée à l'aide de EasyOrCr pour extraire du texte.
3. Raffinement de texte: le texte extrait est standardisé pour garantir la cohérence et la précision.
4. Composition de requête: une requête structurée est créée, y compris le texte du puzzle raffiné et des instructions spécifiques pour la résolution.
5. Interaction API: La requête est envoyée à l'API Deepseek, qui analyse et résout le puzzle. Assurez-vous d'utiliser le modèle Deepseek-Reasoner pour utiliser Deepseek-R1. Si vous souhaitez utiliser Deepseek-V3, utilisez Deepseek-Chat. Et soyez toujours conscient des prix, alors vérifiez la page de prix pour les informations les plus à jour.
6. Gestion de la réponse: la réponse de l'API est traitée pour extraire et renvoyer la solution ou les messages d'erreur appropriés.
7. Gestion des erreurs: la fonction gère également des problèmes comme des délais d'attente ou des exceptions inattendues, assurant un fonctionnement robuste.

Ce pipeline combine l'OCR pour l'extraction de texte et l'API Deepseek pour la résolution intelligente de puzzle.

Étape 4: Création de l'interface Gradio

Gradio nous permet de créer une interface Web interactive pour notre application. L'extrait de code suivant crée une interface Web Gradio conviviale pour la fonction Solve_Puzzle (). L'interface Gradio prend les entrées de l'utilisateur et les transmet au modèle pour la validation.

!pip install torch gradio pillow easyocr -q

La configuration ci-dessus comprend trois composants:

• Entrée: un composant Gr.image où les utilisateurs peuvent télécharger leurs images.
• Sortie: un composant de texte pour afficher la réponse de Deepseek-R1.
• Interface: la fonction gr.interface () attache les entrées et les sorties ensemble, lançant une application Web pour l'interaction utilisateur.

Étape 5: Testez l'application

Testons notre application avec un puzzle qui implique les mathématiques et la logique.

Si vous regardez la première ligne, vous verrez 1 4 = 5, et vous pouvez dire que c'est un simple ajout. Mais sur la deuxième ligne, nous avons 2 5 = 12, puis 3 6 = 21. Pouvez-vous déterminer le modèle et résoudre 8 11 =?

Si vous regardez sur le côté droit de l'interface Gradio, vous verrez que l'application de solveur de puzzle a identifié le modèle:

Conclusion

Dans ce tutoriel, nous avons construit un assistant de solveur de puzzle mathématique en utilisant Deepseek R1 combiné avec OCR et Gradio pour résoudre les énigmes mathématiques. Pour suivre les dernières personnes de l'IA, je recommande ces blogs:

• qwen 2.5-max
• Janus-Pro
de Deepseek
• Comment utiliser Deepseek Janus-Pro localement

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!