DeepSeek R1-demoproject met Gradio en EasyOCR

In deze praktische gids gebruik ik het DeepSeek-R1-model om een assistent voor het oplossen van wiskundepuzzels te bouwen die is geïntegreerd met EasyOCR en Gradio.

Ik leg stap voor stap uit hoe je een functionele webapp bouwt die een breed scala aan wiskundepuzzels kan oplossen en behulpzame oplossingen kan genereren met de uitstekende redeneercapaciteiten van het DeepSeek R1-model.

Als je alleen een overzicht van DeepSeek-R1 wilt, raad ik je aan deze DeepSeek-R1-overview te bekijken. Voor het fine-tunen van het model raad ik deze tutorial aan over DeepSeek-R1 fine-tunen.

DeepSeek-R1-demoproject: overzicht

Om onze puzzeloplossende assistent te bouwen, doorlopen we de volgende stappen:

• Stel de benodigde vereisten in.
• Initialiseer het model met geoptimaliseerde configuraties.
• Definieer kernfunctionaliteiten met behulp van de instructmogelijkheden van het model.
• Integreer de componenten in een gebruiksvriendelijke Gradio-interface voor eenvoudige interactie.

Stap 1: Vereisten

Voordat we met de implementatie aan de slag gaan, controleren we of de volgende tools en libraries zijn geïnstalleerd:

• Python 3.8+
• PyTorch: voor efficiënte verwerking van deep learning-modellen.
• EasyOCR: een Python-module om tekst uit afbeeldingen te halen.
• Gradio: om een gebruiksvriendelijke webinterface te maken.

Voer de volgende opdrachten uit om de benodigde dependencies te installeren:

!pip install torch gradio pillow easyocr -q

Zodra bovenstaande dependencies zijn geïnstalleerd, voer je de volgende importopdrachten uit:

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

Stap 2: De DeepSeek-R1 API instellen

Het volgende script laat zien hoe je met de DeepSeek-API communiceert om reacties te krijgen op basis van gebruikersprompts. Let op: de API van DeepSeek is compatibel met het formaat van OpenAI en gebruikt een basis-URL voor API-verzoeken.

Je kunt de API-sleutel rechtstreeks doorgeven (niet aanbevolen om privacyredenen), of als je net als ik Google Colab gebruikt, kun je de API-sleutel opslaan via de Secrets-functie. Je kunt ook omgevingsvariabelen gebruiken.

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

Op het moment van publicatie staan de diensten van DeepSeek onder zware belasting en is de performance verminderd—ik had ook grote moeite om de code voor dit project uit te voeren. Controleer de statuspagina van DeepSeek voordat je probeert de code in dit project uit te voeren.

Stap 3: De kernfunctionaliteiten ontwerpen

Nu de API is ingesteld, kunnen we aan de codefunctionaliteiten werken. In deze sectie verwerken we een afbeelding met een logische puzzel, halen we de puzzeltekst eruit met OCR, verfijnen we de tekst en sturen we die naar de DeepSeek-API om op te lossen. Laten we eerst naar de code kijken, daarna leg ik het uit.

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

De functie solve_puzzle() verwerkt een afbeelding met een logische puzzel en lost die op met de OCR en het R1-model. De stappen zijn als volgt:

1. EasyOCR initialiseren: we starten met het initialiseren van de EasyOCR-reader in het Engels.
2. Beeldverwerking: de geüploade afbeelding wordt tijdelijk opgeslagen en verwerkt met EasyOCR om tekst te extraheren.
3. Tekstverfijning: de geëxtraheerde tekst wordt gestandaardiseerd om consistentie en nauwkeurigheid te waarborgen.
4. Query samenstellen: er wordt een gestructureerde query gemaakt met de verfijnde puzzeltekst en specifieke instructies voor het oplossen.
5. API-interactie: de query wordt naar de DeepSeek-API gestuurd, die de puzzel analyseert en oplost. Zorg dat je het model deepseek-reasoner gebruikt om DeepSeek-R1 te gebruiken. Als je DeepSeek-V3 wilt gebruiken, kies dan deepseek-chat. En wees altijd bewust van de prijzen, dus bekijk de prijspagina voor de meest actuele informatie.
6. Afhandeling van de response: de API-respons wordt verwerkt om de oplossing of passende foutmeldingen te retourneren.
7. Foutafhandeling: de functie gaat ook om met problemen zoals time-outs of onverwachte uitzonderingen, voor een robuuste werking.

Deze pijplijn combineert OCR voor tekstextractie en de DeepSeek-API voor intelligent puzzeloplossen.

Stap 4: De Gradio-interface maken

Gradio stelt ons in staat een interactieve webinterface voor onze applicatie te maken. De volgende code maakt een gebruiksvriendelijke Gradio-webinterface voor de functie solve_puzzle(). De Gradio-interface neemt de invoer van de gebruiker en geeft die door aan het model voor validatie.

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)

De bovenstaande setup bevat drie componenten:

• Invoer: een gr.Image-component waar gebruikers hun afbeeldingen kunnen uploaden.
• Uitvoer: een text-component voor het tonen van het antwoord van DeepSeek-R1.
• Interface: de functie gr.Interface() koppelt invoer en uitvoer en start een webapp voor gebruikersinteractie.

Stap 5: Test de app

Laten we onze app testen met een puzzel die wiskunde en logica combineert.

Als je naar de eerste rij kijkt, zie je 1 + 4 = 5, en je zou zeggen: dit is een simpele optelsom. Maar op de tweede rij staat 2 + 5 = 12, en dan 3 + 6 = 21. Kun je het patroon ontdekken en 8 + 11 = ? oplossen?

Aan de rechterkant van de Gradio-interface zie je dat de Puzzle Solver-app het patroon heeft gevonden:

Conclusie

In deze tutorial hebben we een assistent gebouwd die wiskundepuzzels oplost met DeepSeek R1, gecombineerd met OCR en Gradio. Om bij te blijven met het laatste AI-nieuws raad ik deze blogs aan:

• Qwen 2.5-Max
• DeepSeek's Janus-Pro
• DeepSeek Janus-Pro lokaal gebruiken