Pular para o conteúdo principal

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

Neste tutorial do DeepSeek-R1, você aprenderá a criar um aplicativo solucionador de quebra-cabeças matemáticos integrando o DeepSeek-R1 com o EasyOCR e o Gradio.
Actualizado 30 de jan. de 2025  · 12 min de leitura

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:

Aplicativo deepseek-r1 com gradio

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:


Aashi Dutt's photo
Author
Aashi Dutt
LinkedIn
Twitter

Sou Google Developers Expert em ML (Gen AI), Kaggle 3x Expert e Women Techmakers Ambassador com mais de 3 anos de experiência em tecnologia. Fui cofundador de uma startup de tecnologia de saúde em 2020 e estou fazendo mestrado em ciência da computação na Georgia Tech, com especialização em machine learning.

Temas

Aprenda IA com estes cursos!

curso

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.
Ver DetalhesRight Arrow
Iniciar curso
Ver maisRight Arrow
Relacionado

blog

Anunciando a série de codificação conjunta "Torne-se um desenvolvedor de IA

Comece a trabalhar com a IA generativa nesta nova série de código-along. Gratuito por tempo limitado.
DataCamp Team's photo

DataCamp Team

4 min

tutorial

DeepSeek-Coder-V2 Tutorial: Exemplos, instalação, padrões de referência

O DeepSeek-Coder-V2 é um modelo de linguagem de código de código aberto que rivaliza com o desempenho do GPT-4, Gemini 1.5 Pro, Claude 3 Opus, Llama 3 70B ou Codestral.
Dimitri Didmanidze's photo

Dimitri Didmanidze

8 min

tutorial

Tutorial do DeepChecks: Automatizando os testes de machine learning

Saiba como realizar a validação de dados e modelos para garantir um desempenho robusto de machine learning usando nosso guia passo a passo para automatizar testes com o DeepChecks.
Abid Ali Awan's photo

Abid Ali Awan

12 min

tutorial

AI do cursor: Um guia com 10 exemplos práticos

Saiba como instalar o Cursor AI no Windows, macOS e Linux e descubra como usá-lo em 10 casos de uso diferentes.
François Aubry's photo

François Aubry

10 min

tutorial

Como criar aplicativos LLM com o tutorial LangChain

Explore o potencial inexplorado dos modelos de linguagem grandes com o LangChain, uma estrutura Python de código aberto para criar aplicativos avançados de IA.
Moez Ali's photo

Moez Ali

12 min

tutorial

Visão GPT-4: Um guia abrangente para iniciantes

Este tutorial apresentará tudo o que você precisa saber sobre o GPT-4 Vision, desde o acesso a ele, passando por exemplos práticos do mundo real, até suas limitações.
Arunn Thevapalan's photo

Arunn Thevapalan

12 min

Ver maisVer mais