Progetto demo DeepSeek R1 con Gradio ed EasyOCR

In questa guida pratica userò il modello DeepSeek-R1 per creare un assistente che risolve rompicapi matematici integrato con EasyOCR e Gradio.

Ti spiegherò passo dopo passo come creare una web app funzionante capace di risolvere un'ampia gamma di rompicapi matematici e generare soluzioni utili sfruttando le eccellenti capacità di ragionamento del modello DeepSeek R1.

Se vuoi solo una panoramica di DeepSeek-R1, ti consiglio di dare un'occhiata a questa panoramica su DeepSeek-R1. Per il fine-tuning del modello, ti consiglio questo tutorial su come fare fine-tuning di DeepSeek-R1.

Progetto demo DeepSeek-R1: panoramica

Per costruire il nostro assistente risolutore di rompicapi, seguiremo questi passaggi:

• Configura i prerequisiti necessari.
• Inizializza il modello con configurazioni ottimizzate.
• Definisci le funzionalità principali, usando le capacità instruct del modello.
• Integra i componenti in un'interfaccia Gradio intuitiva per un'interazione semplice.

Passaggio 1: Prerequisiti

Prima di passare all'implementazione, assicuriamoci di avere installati i seguenti strumenti e librerie:

• Python 3.8+
• PyTorch: per una gestione efficiente dei modelli di deep learning.
• EasyOCR: un modulo Python per estrarre testo dalle immagini.
• Gradio: per creare un'interfaccia web intuitiva.

Esegui i seguenti comandi per installare le dipendenze necessarie:

!pip install torch gradio pillow easyocr -q

Una volta installate le dipendenze, esegui i seguenti comandi di import:

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

Passaggio 2: Configurare l'API DeepSeek-R1

Il seguente script mostra come interagire con l'API di DeepSeek per ottenere risposte in base ai prompt dell'utente. Nota che l'API di DeepSeek è compatibile con il formato di OpenAI e utilizza un URL di base per le richieste API.

Puoi passare direttamente la chiave API (sconsigliato per motivi di privacy) oppure, se usi Google Colab come me, puoi salvare la chiave API usando la funzionalità Secrets. In alternativa, puoi usare le variabili d'ambiente.

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

Al momento della pubblicazione di questo articolo, i servizi di DeepSeek sono fortemente sovraccarichi e le loro prestazioni sono degradate: ho avuto anch'io grosse difficoltà a eseguire il codice per questo progetto. Controlla la pagina di stato di DeepSeek prima di provare a eseguire il codice di questo progetto.

Passaggio 3: Progettare le funzionalità principali

Ora che l'API è configurata, possiamo lavorare sulle funzionalità del codice. In questa sezione elaboreremo un'immagine contenente un rompicapo logico, estrarremo il testo del rompicapo con l'OCR, lo perfezioneremo e lo invieremo all'API di DeepSeek per la soluzione. Vediamo prima il codice e poi te lo spiego.

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 funzione solve_puzzle() elabora un'immagine contenente un rompicapo logico e lo risolve usando l'OCR e il modello R1. Segue questi passaggi:

1. Inizializza EasyOCR: iniziamo inizializzando il reader di EasyOCR in inglese.
2. Elaborazione dell'immagine: l'immagine caricata viene salvata temporaneamente ed elaborata con EasyOCR per estrarre il testo.
3. Rifinitura del testo: il testo estratto viene standardizzato per garantire coerenza e accuratezza.
4. Composizione della query: viene creata una query strutturata, con il testo del rompicapo rifinito e istruzioni specifiche per la risoluzione.
5. Interazione con l'API: la query viene inviata all'API di DeepSeek, che analizza e risolve il rompicapo. Assicurati di usare il modello deepseek-reasoner per usare DeepSeek-R1. Se vuoi usare DeepSeek-V3, usa deepseek-chat. E tieni sempre d'occhio i costi: consulta la pagina dei prezzi per le informazioni più aggiornate.
6. Gestione della risposta: la risposta dell'API viene elaborata per estrarre e restituire la soluzione o i messaggi di errore appropriati.
7. Gestione degli errori: la funzione gestisce anche problemi come timeout o eccezioni inattese, garantendo un funzionamento robusto.

Questa pipeline combina l'OCR per l'estrazione del testo e l'API di DeepSeek per una risoluzione intelligente dei rompicapi.

Passaggio 4: Creare l'interfaccia Gradio

Gradio ci permette di creare un'interfaccia web interattiva per la nostra applicazione. Il seguente snippet crea un'interfaccia web Gradio intuitiva per la funzione solve_puzzle(). L'interfaccia Gradio acquisisce gli input dell'utente e li passa al modello per la validazione.

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 configurazione sopra include tre componenti:

• Input: un componente gr.Image in cui gli utenti possono caricare le loro immagini.
• Output: un componente text per mostrare la risposta di DeepSeek-R1.
• Interfaccia: la funzione gr.Interface() collega input e output, avviando una web app per l'interazione con l'utente.

Passaggio 5: Testare l'app

Testiamo la nostra app con un rompicapo che coinvolge matematica e logica.

Se guardi la prima riga, vedrai 1 + 4 = 5, e potresti dire che è una semplice addizione. Ma nella seconda riga abbiamo 2 + 5 = 12, e poi 3 + 6 = 21. Riesci a individuare lo schema e risolvere 8 + 11 = ?

Se guardi sul lato destro dell'interfaccia Gradio, vedrai che l'app Puzzle Solver ha identificato lo schema:

Conclusione

In questo tutorial abbiamo creato un assistente per risolvere rompicapi matematici usando DeepSeek R1, combinato con OCR e Gradio per risolvere esercizi di matematica. Per restare al passo con le ultime novità dell'IA, ti consiglio questi blog:

• Qwen 2.5-Max
• Janus-Pro di DeepSeek
• Come usare DeepSeek Janus-Pro in locale