Projeto de demonstração do DeepSeek R1 com Gradio e EasyOCR

Neste guia prático, usarei o DeepSeek-R1 para criar um assistente de solução de quebra-cabeças matemáticos integrado ao EasyOCR e ao Gradio.

Explicarei passo a passo como criar um aplicativo da Web funcional capaz de resolver uma grande variedade de quebra-cabeças matemáticos e gerar soluções úteis usando os excelentes recursos de raciocínio do modelo DeepSeek R1.

Se você quiser apenas ter uma visão geral do DeepSeek-R1, recomendo que consulte esta Visão geral do DeepSeek-R1. Para fazer o ajuste fino do modelo, recomendo este tutorial sobre ajuste fino do DeepSeek-R1.

DeepSeek-R1 Demo Project: Visão geral

Para criar nosso assistente de solução de quebra-cabeças, vamos seguir as etapas a seguir:

• Configure os pré-requisitos necessários.
• Inicialize o modelo com configurações otimizadas.
• Defina as principais funcionalidades, usando os recursos de instrução do modelo.
• Integre os componentes em uma interface Gradio amigável para facilitar a interação.

Etapa 1: Pré-requisitos

Antes de mergulhar na implementação, vamos garantir que você tenha as seguintes ferramentas e bibliotecas instaladas:

• Python 3.8+
• PyTorch: Para um manuseio eficiente do modelo de aprendizagem profunda.
• EasyOCR: Um módulo Python para extrair texto de imagens.
• Gradio: Para criar uma interface da Web fácil de usar.

Execute os seguintes comandos para instalar as dependências necessárias:

!pip install torch gradio pillow easyocr -q

Quando as dependências acima estiverem instaladas, execute os seguintes comandos de importação:

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

Etapa 2: Configurando a API do DeepSeek-R1

O script a seguir demonstra como você pode interagir com a API do DeepSeek para obter respostas com base nas solicitações do usuário. Observe que a API do DeepSeek é compatível com o formato da OpenAI e usa um URL básico para solicitações de API.

Você pode passar diretamente a chave da API (não recomendado por motivos de privacidade) ou, se estiver usando o Google Colab como eu, pode salvar a chave da API usando o recurso Secrets. Como alternativa, você pode usar variáveis de 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' 

No momento da publicação deste artigo, os serviços do DeepSeek estão sob carga pesada e seu desempenho está degradado - também tive grandes dificuldades para executar o código deste projeto. Verifique a página de status do DeepSeek antes de tentar executar o código neste projeto.

Etapa 3: Projetando os principais recursos

Agora que a API está definida, podemos trabalhar nos recursos de código. Nesta seção, processaremos uma imagem que contém um quebra-cabeça lógico, extrairemos o texto do quebra-cabeça usando OCR, refinaremos o texto e o enviaremos para a API do DeepSeek para solução. Primeiro, vamos ver o código e, depois, explicarei a você.

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

A função solve_puzzle() processa uma imagem que contém um quebra-cabeça lógico e o resolve usando o OCR e o modelo R1. Você deve seguir estas etapas:

1. Initialize EasyOCR: Começamos inicializando o leitor EasyOCR em inglês.
2. Processamento de imagens: A imagem carregada é salva temporariamente e processada usando o EasyOCR para extrair o texto.
3. Refinamento de texto: O texto extraído é padronizado para garantir a consistência e a precisão.
4. Composição da consulta: Uma consulta estruturada é criada, incluindo o texto refinado do quebra-cabeça e instruções específicas para a solução.
5. Interação da API: A consulta é enviada para a API do DeepSeek, que analisa e resolve o quebra-cabeça. Certifique-se de usar o modelo deepseek-reasoner para usar o DeepSeek-R1. Se você quiser usar o DeepSeek-V3, use deepseek-chat. E sempre fique atento aos preços, portanto, verifique a página de preços para obter as informações mais atualizadas.
6. Tratamento de respostas: A resposta da API é processada para extrair e retornar a solução ou as mensagens de erro apropriadas.
7. Tratamento de erros: A função também gerencia problemas como timeouts ou exceções inesperadas, garantindo uma operação robusta.

Esse pipeline combina OCR para extração de texto e a API DeepSeek para solução inteligente de quebra-cabeças.

Etapa 4: Criando a interface do Gradio

O Gradio nos permite criar uma interface da Web interativa para o nosso aplicativo. O trecho de código a seguir cria uma interface da Web do Gradio fácil de usar para a função solve_puzzle(). A interface do Gradio recebe as entradas do usuário e as passa para o modelo para validação.

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)

A configuração acima inclui três componentes:

• Entrada: Um componente gr.Image no qual os usuários podem carregar suas imagens.
• Saída: Um componente text para exibir a resposta do DeepSeek-R1.
• Interface: Afunção gr.Interface() une a entrada e a saída, iniciando um aplicativo da Web para a interação do usuário.

Etapa 5: Teste o aplicativo

Vamos testar nosso aplicativo com um quebra-cabeça que envolva matemática e lógica.

Se você observar a primeira linha, verá que 1 + 4 = 5, e poderá dizer que essa é uma adição simples. Mas na segunda linha temos 2 + 5 = 12, e depois 3 + 6 = 21. Você consegue descobrir o padrão e resolver 8 + 11 = ?

Se você olhar no lado direito da interface do Gradio, verá que o aplicativo Puzzle Solver identificou o padrão:

Conclusão

Neste tutorial, criamos um assistente de solução de quebra-cabeças matemáticos usando o DeepSeek R1 combinado com OCR e Gradio para resolver quebra-cabeças matemáticos. Para você ficar por dentro das últimas novidades em IA, recomendo estes blogs:

• Qwen 2.5-Max
• Janus-Pro da DeepSeek
• Como usar o DeepSeek Janus-Pro localmente