Accéder au contenu principal

Projet de démonstration DeepSeek R1 avec Gradio et EasyOCR

Dans ce tutoriel DeepSeek-R1, vous apprendrez comment construire une application de résolution de puzzle mathématique en intégrant DeepSeek-R1 avec EasyOCR et Gradio.
Actualisé 30 janv. 2025  · 12 min de lecture

Dans ce guide pratique, j'utiliserai le logiciel DeepSeek-R1 pour construire un assistant de résolution de assistant de résolution d'énigmes mathématiques intégré à EasyOCR et Gradio.

Je vais vous expliquer étape par étape comment construire une application web fonctionnelle capable de résoudre un large éventail d'énigmes mathématiques et de générer des solutions utiles en utilisant les excellentes capacités de raisonnement du modèle DeepSeek R1.

Si vous souhaitez simplement avoir une vue d'ensemble de DeepSeek-R1, je vous recommande de consulter le document suivant Aperçu de DeepSeek-R1. Pour affiner le modèle, je vous recommande ce tutoriel sur le réglage fin de DeepSeek-R1.

Projet de démonstration DeepSeek-R1 : Vue d'ensemble

Pour construire notre assistant de résolution de puzzle, nous allons suivre les étapes suivantes :

  • Mettez en place les conditions préalables nécessaires.
  • Initialiser le modèle avec des configurations optimisées.
  • Définir les fonctionnalités de base, en utilisant les capacités d'instruction du modèle.
  • Intégrez les composants dans une interface Gradio conviviale pour faciliter l'interaction.

Étape 1 : Conditions préalables

Avant de plonger dans la mise en œuvre, assurons-nous que les outils et bibliothèques suivants sont installés :

  • Python 3.8+.
  • PyTorch : Pour un traitement efficace des modèles d'apprentissage profond.
  • EasyOCR: Un module Python pour l'extraction de texte à partir d'une image.
  • Gradio : 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 basées sur les invites de l'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 clé API (ce qui n'est pas recommandé pour des raisons de confidentialité), soit, si vous utilisez Google Colab comme moi, enregistrer la clé API à l'aide de la fonction Secrets. Vous pouvez également 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 fortement sollicités et leurs performances sont dégradées. J'ai également eu de grandes difficultés à faire fonctionner le code de ce projet. Veuillez consulter la page d'état de DeepSeek avant d'essayer d'exécuter le code de ce projet.

Étape 3 : Conception des fonctionnalités de base

Maintenant que l'API est définie, nous pouvons travailler sur les fonctionnalités du code. Dans cette section, nous allons traiter une image contenant une énigme logique, extraire le texte de l'énigme à l'aide de l'OCR, affiner le texte et l'envoyer à l'API DeepSeek pour qu'il soit résolu. Voyons d'abord le code, puis je l'expliquerai.

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 les étapes suivantes :

  1. Initialize EasyOCR: Nous commençons par initialiser le lecteur EasyOCR en anglais.
  2. Traitement de l'image : L'image téléchargée est sauvegardée temporairement et traitée à l'aide d'EasyOCR pour en extraire le texte.
  3. Amélioration du texte : Le texte extrait est normalisé afin d'en garantir la cohérence et la précision.
  4. Composition de la requête : Une requête structurée est créée, comprenant le texte affiné de l'énigme et des instructions spécifiques pour la résoudre.
  5. Interaction avec l'API : La requête est envoyée à l'API DeepSeek, qui analyse et résout l'énigme. Veillez à utiliser le modèle deepseek-reasoner pour utiliser DeepSeek-R1. Si vous souhaitez utiliser DeepSeek-V3, utilisez deepseek-chat. Et soyez toujours attentifs aux prix, consultez la page des prix pour obtenir les informations les plus récentes.
  6. Traitement des réponses : 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 les problèmes tels que les dépassements de délai ou les exceptions inattendues, garantissant ainsi un fonctionnement robuste.

Ce pipeline combine l'OCR pour l'extraction de texte et l'API DeepSeek pour la résolution intelligente d'énigmes.

É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 données de l'utilisateur et les transmet au modèle pour validation.

interface = gr.Interface(
    fn=solve_puzzle,
    inputs=gr.Image(type="pil"),
    outputs="text",
    title="Logic Puzzle Solver with EasyOCR & DeepSeek",
    description="Upload an image of a logic puzzle, and the model will solve it for you."
)
interface.launch(debug=True)

La configuration ci-dessus comprend trois éléments :

  • Entrée : Un composant gr.Image où les utilisateurs peuvent télécharger leurs images.
  • Sortie: Un composant text pour afficher la réponse de DeepSeek-R1.
  • Interface: Lafonction gr.Interface() relie l'entrée et la sortie, en lançant une application web pour l'interaction avec l'utilisateur.

Étape 5 : Testez l'application

Testons notre application avec un puzzle qui fait appel aux mathématiques et à la logique.

Si vous regardez la première ligne, vous verrez 1 + 4 = 5, et vous pourrez dire qu'il s'agit d'une simple addition. Mais sur la deuxième ligne, nous avons 2 + 5 = 12, puis 3 + 6 = 21. Pouvez-vous trouver 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 Puzzle Solver a identifié le motif :

deepseek-r1 app avec gradio

Conclusion

Dans ce tutoriel, nous avons construit un assistant de résolution de puzzles mathématiques en utilisant DeepSeek R1 combiné avec OCR et Gradio pour résoudre des puzzles mathématiques. Pour vous tenir au courant des dernières nouveautés en matière d'IA, je vous recommande ces blogs :


Aashi Dutt's photo
Author
Aashi Dutt
LinkedIn
Twitter

Je suis un expert Google Developers en ML (Gen AI), un expert Kaggle 3x, et un ambassadeur Women Techmakers avec plus de 3 ans d'expérience dans la technologie. J'ai cofondé une startup dans le domaine de la santé en 2020 et je poursuis un master en informatique à Georgia Tech, avec une spécialisation dans l'apprentissage automatique.

Sujets

Apprenez l'IA avec ces cours !

Certification disponible

cours

Retrieval Augmented Generation (RAG) avec LangChain

3 hr
2.6K
Apprenez des méthodes de pointe pour intégrer des données externes aux LLM en utilisant Retrieval Augmented Generation (RAG) avec LangChain.
Afficher les détailsRight Arrow
Commencer le cours
Voir plusRight Arrow