Direkt zum Inhalt

DeepSeek R1 Demo-Projekt mit Gradio und EasyOCR

In diesem DeepSeek-R1-Tutorial lernst du, wie du eine App zum Lösen von mathematischen Rätseln erstellst, indem du DeepSeek-R1 mit EasyOCR und Gradio integrierst.
Aktualisierte 30. Jan. 2025  · 12 Min. Lesezeit

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:

deepseek-r1 App mit gradio

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:


Aashi Dutt's photo
Author
Aashi Dutt
LinkedIn
Twitter

Ich bin ein Google Developers Expert in ML (Gen AI), ein Kaggle 3x Expert und ein Women Techmakers Ambassador mit mehr als 3 Jahren Erfahrung im Tech-Bereich. Ich habe 2020 ein Startup im Bereich Gesundheitstechnologie mitbegründet und mache einen Master in Informatik an der Georgia Tech, der sich auf maschinelles Lernen spezialisiert.

Themen

Lerne KI mit diesen Kursen!

Kurs

Retrieval Augmented Generation (RAG) with LangChain

3 hr
2.6K
Learn cutting-edge methods for integrating external data with LLMs using Retrieval Augmented Generation (RAG) with LangChain.
Siehe DetailsRight Arrow
Kurs starten
Mehr anzeigenRight Arrow
Verwandt

Der Blog

Top 30 Generative KI Interview Fragen und Antworten für 2024

Dieser Blog bietet eine umfassende Sammlung von Fragen und Antworten zu generativen KI-Interviews, die von grundlegenden Konzepten bis hin zu fortgeschrittenen Themen reichen.
Hesam Sheikh Hassani's photo

Hesam Sheikh Hassani

15 Min.

Der Blog

Die 20 besten Snowflake-Interview-Fragen für alle Niveaus

Bist du gerade auf der Suche nach einem Job, der Snowflake nutzt? Bereite dich mit diesen 20 besten Snowflake-Interview-Fragen vor, damit du den Job bekommst!
Nisha Arya Ahmed's photo

Nisha Arya Ahmed

20 Min.

Der Blog

Q2 2023 DataCamp Donates Digest

DataCamp Donates hat im zweiten Quartal 2023 über 20.000 Stipendien an unsere gemeinnützigen Partner vergeben. Erfahre, wie fleißige benachteiligte Lernende diese Chancen in lebensverändernde berufliche Erfolge verwandelt haben.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

Der Blog

Lehrer/innen und Schüler/innen erhalten das Premium DataCamp kostenlos für ihre gesamte akademische Laufbahn

Keine Hacks, keine Tricks. Schüler/innen und Lehrer/innen, lest weiter, um zu erfahren, wie ihr die Datenerziehung, die euch zusteht, kostenlos bekommen könnt.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

4 Min.

Der Blog

Die 32 besten AWS-Interview-Fragen und Antworten für 2024

Ein kompletter Leitfaden zur Erkundung der grundlegenden, mittleren und fortgeschrittenen AWS-Interview-Fragen, zusammen mit Fragen, die auf realen Situationen basieren. Es deckt alle Bereiche ab und sorgt so für eine abgerundete Vorbereitungsstrategie.
Zoumana Keita 's photo

Zoumana Keita

30 Min.

Der Blog

2022-2023 DataCamp Classrooms Jahresbericht

Zu Beginn des neuen Schuljahres ist DataCamp Classrooms motivierter denn je, das Lernen mit Daten zu demokratisieren. In den letzten 12 Monaten sind über 7.650 neue Klassenzimmer hinzugekommen.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

8 Min.

Mehr anzeigenMehr anzeigen