Proyecto de demostración de DeepSeek R1 con Gradio y EasyOCR

En esta guía práctica, utilizaré el programa DeepSeek-R1 para construir un asistente para resolver puzzles matemáticos integrado con EasyOCR y Gradio.

Explicaré paso a paso cómo construir una aplicación web funcional capaz de resolver una amplia gama de enigmas matemáticos y generar soluciones útiles utilizando las excelentes capacidades de razonamiento del modelo DeepSeek R1.

Si sólo quieres tener una visión general de DeepSeek-R1, te recomiendo que eches un vistazo a esto Visión general de DeepSeek-R1. Para afinar el modelo, recomiendo este tutorial sobre ajuste fino de DeepSeek-R1.

DeepSeek-R1 Demo Project: Visión general

Para construir nuestro asistente solucionador de puzzles, seguiremos los siguientes pasos:

• Establece los requisitos previos necesarios.
• Inicializa el modelo con las configuraciones optimizadas.
• Define las funcionalidades básicas, utilizando las capacidades de instrucción del modelo.
• Integra los componentes en una interfaz Gradio fácil de usar para facilitar la interacción.

Paso 1: Requisitos previos

Antes de sumergirnos en la implementación, asegurémonos de que tenemos instaladas las siguientes herramientas y bibliotecas:

• Python 3.8+
• PyTorch: Para un manejo eficaz de los modelos de aprendizaje profundo.
• EasyOCR: Un módulo de Python para extraer texto de una imagen.
• Gradio: Crear una interfaz web fácil de usar.

Ejecuta los siguientes comandos para instalar las dependencias necesarias:

!pip install torch gradio pillow easyocr -q

Una vez instaladas las dependencias anteriores, ejecuta los siguientes comandos de importación:

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

Paso 2: Configuración de la API DeepSeek-R1

El siguiente script demuestra cómo interactuar con la API DeepSeek para obtener respuestas basadas en las peticiones del usuario. Ten en cuenta que la API de DeepSeek es compatible con el formato de OpenAI y utiliza una URL base para las solicitudes de la API.

Puedes introducir directamente la clave API (no se recomienda por motivos de privacidad), o si utilizas Google Colab como yo, puedes guardar la clave API utilizando la función Secretos. Como alternativa, puedes utilizar variables de entorno.

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

En el momento de publicar este artículo, los servicios de DeepSeek están sometidos a una gran carga, y su rendimiento está degradado; yo también he tenido grandes dificultades para ejecutar el código de este proyecto. Comprueba la página de estado de DeepSeek antes de intentar ejecutar el código de este proyecto.

Paso 3: Diseñar las funciones básicas

Ahora que la API está configurada, podemos trabajar en las características del código. En esta sección, procesaremos una imagen que contiene un puzzle lógico, extraeremos el texto del puzzle mediante OCR, refinaremos el texto y lo enviaremos a la API DeepSeek para que lo resuelva. Veamos primero el código y luego lo explicaré.

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 función solve_puzzle() procesa una imagen que contiene un puzzle lógico y lo resuelve utilizando el OCR y el modelo R1. Sigue estos pasos:

1. Inicializa EasyOCR: Empezamos inicializando el lector EasyOCR en inglés.
2. Tratamiento de imágenes: La imagen cargada se guarda temporalmente y se procesa con EasyOCR para extraer el texto.
3. Refinamiento del texto: El texto extraído se normaliza para garantizar su coherencia y precisión.
4. Composición de la consulta: Se crea una consulta estructurada, que incluye el texto refinado del puzzle y las instrucciones específicas para resolverlo.
5. Interacción con la API: La consulta se envía a la API de DeepSeek, que analiza y resuelve el enigma. Asegúrate de utilizar el modelo deepseek-reasoner para utilizar DeepSeek-R1. Si quieres utilizar DeepSeek-V3, utiliza deepseek-chat. Y ten siempre en cuenta los precios, así que consulta la página de precios para obtener la información más actualizada.
6. Gestión de la respuesta: La respuesta de la API se procesa para extraer y devolver la solución o los mensajes de error apropiados.
7. Tratamiento de errores: La función también gestiona problemas como tiempos de espera o excepciones inesperadas, garantizando un funcionamiento sólido.

Este pipeline combina OCR para la extracción de texto y la API DeepSeek para la resolución inteligente de puzzles.

Paso 4: Crear la interfaz de Gradio

Gradio nos permite crear una interfaz web interactiva para nuestra aplicación. El siguiente fragmento de código crea una interfaz web de Gradio fácil de usar para la función solve_puzzle(). La interfaz de Gradio toma las entradas del usuario y las pasa al modelo para su validación.

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 configuración anterior incluye tres componentes:

• Entrada: Un componente de gr.Image donde los usuarios pueden subir sus imágenes.
• Salida: Un componente text para mostrar la respuesta de DeepSeek-R1.
• Interfaz: Lafunción gr.Interface() une la entrada y la salida, lanzando una aplicación web para la interacción del usuario.

Paso 5: Prueba la aplicación

Pongamos a prueba nuestra aplicación con un puzzle que implique matemáticas y lógica.

Si miras la primera fila, verás que 1 + 4 = 5, y puedes decir que se trata de una suma simple. Pero en la segunda fila tenemos 2 + 5 = 12, y luego 3 + 6 = 21. ¿Puedes descifrar el patrón y resolver 8 + 11 = ?

Si miras a la derecha de la interfaz de Gradio, verás que la aplicación Puzzle Solver ha identificado el patrón:

Conclusión

En este tutorial, construimos un asistente para resolver puzzles matemáticos utilizando DeepSeek R1 combinado con OCR y Gradio para resolver puzzles matemáticos. Para estar al día de lo último en IA, te recomiendo estos blogs:

• Qwen 2,5-Max
• DeepSeek's Janus-Pro
• Cómo utilizar DeepSeek Janus-Pro localmente