DeepSeek R1 Demo-Projekt mit Gradio und EasyOCR

In dieser praktischen Anleitung verwende ich die DeepSeek-R1 Modell zum Aufbau eines Assistenten für mathematische Rätsel zu entwickeln, der mit EasyOCR und Gradio.

Ich erkläre dir Schritt für Schritt, wie du eine funktionale Web-App erstellst, mit der du eine Vielzahl mathematischer Rätsel lösen und hilfreiche Lösungen generieren kannst, indem du die hervorragenden Denkfähigkeiten des DeepSeek R1-Modells nutzt.

Wenn du dir nur einen Überblick über DeepSeek-R1 verschaffen willst, empfehle ich dir diesen DeepSeek-R1 Überblick. Für die Feinabstimmung des Modells empfehle ich dieses Tutorial über Feinabstimmung von DeepSeek-R1.

DeepSeek-R1 Demo Project: Übersicht

Um unseren Puzzlelöser-Assistenten zu bauen, gehen wir die folgenden Schritte durch:

• Schaffe die notwendigen Voraussetzungen.
• Initialisiere das Modell mit optimierten Konfigurationen.
• Definiere die Kernfunktionalitäten, indem du die Fähigkeiten des Modells nutzt.
• Integriere die Komponenten in eine benutzerfreundliche Gradio-Oberfläche für eine einfache Interaktion.

Schritt 1: Voraussetzungen

Bevor wir mit der Implementierung beginnen, müssen wir sicherstellen, dass wir die folgenden Tools und Bibliotheken installiert haben:

• Python 3.8+
• PyTorch: Für eine effiziente Handhabung von Deep Learning-Modellen.
• EasyOCR: Ein Python-Modul zum Extrahieren von Text aus Bildern.
• Gradio: Um eine benutzerfreundliche Weboberfläche zu schaffen.

Führe die folgenden Befehle aus, um die notwendigen Abhängigkeiten zu installieren:

!pip install torch gradio pillow easyocr -q

Sobald die oben genannten Abhängigkeiten installiert sind, führst du die folgenden Importbefehle aus:

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

Schritt 2: Einrichten der DeepSeek-R1 API

Das folgende Skript zeigt, wie man mit der DeepSeek-API interagiert, um Antworten auf Benutzeranfragen zu erhalten. Beachte, dass die API von DeepSeek mit dem Format von OpenAI kompatibel ist und eine Basis-URL für API-Anfragen verwendet.

Du kannst den API-Schlüssel entweder direkt eingeben (aus Datenschutzgründen nicht empfehlenswert) oder, wenn du wie ich Google Colab nutzt, den API-Schlüssel mit der Funktion Secrets speichern. Alternativ kannst du auch Umgebungsvariablen verwenden.

# 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' 

Zum Zeitpunkt der Veröffentlichung dieses Artikels sind die DeepSeek-Dienste stark belastet und ihre Leistung ist beeinträchtigt - auch ich hatte große Schwierigkeiten, den Code für dieses Projekt auszuführen. Bitte prüfe die Statusseite von DeepSeek, bevor du versuchst, den Code in diesem Projekt auszuführen.

Schritt 3: Gestaltung der Kernfunktionen

Jetzt, wo die API fertig ist, können wir an den Code-Funktionen arbeiten. In diesem Abschnitt verarbeiten wir ein Bild mit einem Logikrätsel, extrahieren den Rätseltext mit OCR, verfeinern den Text und senden ihn zur Lösung an die DeepSeek-API. Schauen wir uns zuerst den Code an, dann erkläre ich ihn.

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)}"

Die Funktion solve_puzzle() verarbeitet ein Bild, das ein Logikrätsel enthält, und löst es mithilfe der OCR und des R1-Modells. Er folgt diesen Schritten:

1. Initialisiere EasyOCR: Wir beginnen mit der Initialisierung des EasyOCR-Readers auf Englisch.
2. Bildbearbeitung: Das hochgeladene Bild wird zwischengespeichert und mit EasyOCR verarbeitet, um den Text zu extrahieren.
3. Textverfeinerung: Der extrahierte Text ist standardisiert, um Konsistenz und Genauigkeit zu gewährleisten.
4. Zusammensetzung der Abfrage: Es wird eine strukturierte Abfrage erstellt, die den verfeinerten Rätseltext und spezifische Anweisungen zum Lösen enthält.
5. API-Interaktion: Die Anfrage wird an die DeepSeek API gesendet, die das Rätsel analysiert und löst. Achte darauf, dass du das Modell deepseek-reasoner verwendest, um DeepSeek-R1 zu nutzen. Wenn du DeepSeek-V3 verwenden möchtest, benutze deepseek-chat. Achte immer auf die Preise, also sieh auf der Preisseite nach, um die aktuellsten Informationen zu erhalten.
6. Antwortbearbeitung: Die API-Antwort wird verarbeitet, um die Lösung oder entsprechende Fehlermeldungen zu extrahieren und zurückzugeben.
7. Fehlerbehandlung: Die Funktion kümmert sich auch um Probleme wie Zeitüberschreitungen oder unerwartete Ausnahmen und sorgt so für einen stabilen Betrieb.

Diese Pipeline kombiniert OCR zur Textextraktion und die DeepSeek-API zum intelligenten Lösen von Rätseln.

Schritt 4: Erstellen der Gradio-Schnittstelle

Gradio ermöglicht es uns, eine interaktive Weboberfläche für unsere Anwendung zu erstellen. Der folgende Codeschnipsel erstellt eine benutzerfreundliche Gradio-Weboberfläche für die Funktion solve_puzzle(). Die Gradio-Schnittstelle nimmt die Eingaben des Nutzers entgegen und leitet sie zur Validierung an das Modell weiter.

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)

Die oben beschriebene Einrichtung umfasst drei Komponenten:

• Eingabe: Eine gr.Image Komponente, in die Nutzer ihre Bilder hochladen können.
• Ausgabe: Eine text Komponente zur Anzeige der Antwort von DeepSeek-R1.
• Schnittstelle: DieFunktion gr.Interface() verbindet die Ein- und Ausgabe miteinander und startet eine Web-App für die Interaktion mit dem Nutzer.

Schritt 5: Teste die App

Testen wir unsere App mit einem Rätsel, das Mathe und Logik beinhaltet.

Wenn du dir die erste Zeile ansiehst, siehst du, dass 1 + 4 = 5 ist, und du kannst sagen, dass dies eine einfache Addition ist. Aber in der zweiten Reihe haben wir 2 + 5 = 12, und dann 3 + 6 = 21. Kannst du das Muster herausfinden und 8 + 11 = lösen?

Wenn du auf die rechte Seite der Gradio-Oberfläche schaust, siehst du, dass die Puzzle Solver App das Muster erkannt hat:

Fazit

In diesem Tutorial haben wir einen Assistenten zum Lösen von Mathe-Rätseln gebaut, der DeepSeek R1 mit OCR und Gradio kombiniert, um Mathe-Rätsel zu lösen. Um über das Neueste in Sachen KI auf dem Laufenden zu bleiben, empfehle ich diese Blogs:

• Qwen 2.5-Max
• DeepSeek's Janus-Pro
• Wie du DeepSeek Janus-Pro vor Ort verwendest