Pular para o conteúdo principal

Como configurar e executar o DeepSeek R1 localmente com o Ollama

Saiba como instalar, configurar e executar o DeepSeek-R1 localmente com o Ollama e criar um aplicativo RAG simples.
Actualizado 30 de jan. de 2025  · 12 min de leitura

Neste tutorial, explicarei passo a passo como executar o DeepSeek-R1 localmente e como configurá-lo usando o Ollama. Também exploraremos a criação de um aplicativo RAG simples que seja executado em seu laptop usando o modelo R1, LangChain e Gradio.

Se você quiser apenas uma visão geral do modelo R1, recomendo este artigo do DeepSeek-R1. Para saber como fazer o ajuste fino do R1, recomendo este tutorial sobre o ajuste fino do DeepSeek-R1.

Por que executar o DeepSeek-R1 localmente?

Ao executar o DeepSeek-R1 localmente, você tem controle total sobre a execução do modelo sem depender de servidores externos. Aqui estão algumas vantagens de executar o DeepSeek-R1 localmente:

  • Privacidade e segurança: Nenhum dado sai do seu sistema.
  • Acesso ininterrupto: Evite limites de taxa, tempo de inatividade ou interrupções de serviço.
  • Desempenho: Obtenha respostas mais rápidas com inferência local, evitando a latência da API.
  • Personalização: Modifique os parâmetros, ajuste os avisos e integre o modelo aos aplicativos locais.
  • Eficiência de custo: Elimine as taxas de API executando o modelo localmente.
  • Disponibilidade off-line: Trabalhe sem conexão com a Internet depois que o modelo for baixado.

Configurando o DeepSeek-R1 localmente com o Ollama

O Ollama simplifica a execução de LLMs localmente, lidando com downloads de modelos, quantização e execução de forma integrada.

Etapa 1: Instalar Ollama

Primeiro, faça o download e instale o Ollama no site oficial oficial.

Baixando o Ollama

Quando o download estiver concluído, instale o aplicativo Ollama como você faria com qualquer outro aplicativo.

Etapa 2: Faça o download e execute o DeepSeek-R1

Vamos testar a configuração e fazer o download do nosso modelo. Abra o terminal e digite o seguinte comando.

ollama run deepseek-r1

A Ollama oferece uma variedade de modelos DeepSeek R1, abrangendo desde parâmetros de 1,5B até o modelo completo de 671B parâmetros. O modelo 671B é o DeepSeek-R1 original, enquanto os modelos menores são versões destiladas baseadas nas arquiteturas Qwen e Llama. Se o seu hardware não for compatível com o modelo 671B, você poderá executar facilmente uma versão menor usando o seguinte comando e substituindo o X abaixo pelo tamanho do parâmetro desejado (1.5b, 7b, 8b, 14b, 32b, 70b, 671b):

ollama run deepseek-r1: Xb

Com essa flexibilidade, você pode usar os recursos do DeepSeek-R1 mesmo que não tenha um supercomputador.

Etapa 3: Executando o DeepSeek-R1 em segundo plano

Para executar o DeepSeek-R1 continuamente e servi-lo por meio de uma API, inicie o servidor Ollama:

ollama serve

Isso tornará o modelo disponível para integração com outros aplicativos.

Usando o DeepSeek-R1 localmente

Etapa 1: Execução de inferência via CLI

Depois que o modelo for baixado, você poderá interagir com o DeepSeek-R1 diretamente no terminal.

DeepSeek-R1 em execução no terminal

Etapa 2: Acesso ao DeepSeek-R1 via API

Para integrar o DeepSeek-R1 aos aplicativos, use a API Ollama usando curl:

curl http://localhost:11434/api/chat -d '{
  "model": "deepseek-r1",
  "messages": [{ "role": "user", "content": "Solve: 25 * 25" }],
  "stream": false
}'

curl é uma ferramenta de linha de comando nativa do Linux, mas também funciona no macOS. Ele permite que os usuários façam solicitações HTTP diretamente do terminal, o que o torna uma excelente ferramenta para interagir com APIs.

Acessando o DeepSeek-R1 via API no terminal

Etapa 3: Acesso ao DeepSeek-R1 via Python

Você pode executar o Ollama em qualquer ambiente de desenvolvimento integrado (IDE) de sua preferência. Você pode instalar o pacote Ollama Python usando o seguinte código:

!pip install ollama

Depois que o Ollama estiver instalado, use o script a seguir para interagir com o modelo:

import ollama
response = ollama.chat(
    model="deepseek-r1",
    messages=[
        {"role": "user", "content": "Explain Newton's second law of motion"},
    ],
)
print(response["message"]["content"])

A função ollama.chat() usa o nome do modelo e um prompt do usuário, processando-o como uma troca de conversas. Em seguida, o script extrai e imprime a resposta do modelo.

Executando o DeepSeek R1 localmente em VSCode

Executando um aplicativo Gradio local para RAG com DeepSeek-R1

Vamos criar um aplicativo de demonstração simples usando o Gradio para consultar e analisar documentos com o DeepSeek-R1.

Etapa 1: Pré-requisitos

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

  • Python 3.8+
  • Langchain: Estrutura para a criação de aplicativos alimentados por grandes modelos de linguagem (LLMs), permitindo fácil recuperação, raciocínio e integração de ferramentas.
  • Chromadb: Um banco de dados de vetores de alto desempenho projetado para pesquisas de similaridade eficientes e armazenamento de embeddings.
  • Gradio: Para criar uma interface da Web fácil de usar.

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

!pip install langchain chromadb gradio 
!pip install -U langchain-community

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

import gradio as gr
from langchain_community.document_loaders import PyMuPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain_community.embeddings import OllamaEmbeddings
import ollama

Etapa 2: Processar o PDF carregado

Depois que as bibliotecas forem importadas, processaremos o PDF carregado.

def process_pdf(pdf_bytes):
    if pdf_bytes is None:
        return None, None, None
    loader = PyMuPDFLoader(pdf_bytes)
    data = loader.load()
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)
    chunks = text_splitter.split_documents(data)
    embeddings = OllamaEmbeddings(model="deepseek-r1")
vectorstore=Chroma.from_documents(documents=chunks, embedding=embeddings)
    retriever = vectorstore.as_retriever()
    return text_splitter, vectorstore, retriever

A função process_pdf:

  • Carrega e prepara conteúdo PDF para respostas baseadas em recuperação.
  • Verifica se foi feito o upload de um PDF.
  • Extrai texto usando PyMuPDFLoader.
  • Divide o texto em partes usando RecursiveCharacterTextSplitter.
  • Gera embeddings de vetores usando OllamaEmbeddings.
  • Armazena as incorporações em um armazenamento de vetor Chroma para recuperação eficiente.

Etapa 3: Combinação de partes de documentos recuperados

Depois que os embeddings são recuperados, precisamos uni-los. A função combine_docs() mescla vários pedaços de documentos recuperados em uma única string.

def combine_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

Como os modelos baseados em recuperação extraem trechos relevantes em vez de documentos inteiros, essa função garante que o conteúdo extraído permaneça legível e formatado adequadamente antes de ser passado para o DeepSeek-R1.

Etapa 4: Consultando o DeepSeek-R1 usando Ollama

Agora, nossa entrada para o modelo está pronta. Vamos configurar o DeepSeek R1 usando o Ollama.

def ollama_llm(question, context):
   formatted_prompt = f"Question: {question}\n\nContext: {context}"

 response = ollama.chat(model="deepseek-r1", messages=[{'role': 'user', 'content': formatted_prompt}])

   response_content = response['message']['content']
    
    # Remove content between <think> and </think> tags to remove thinking output
final_answer = re.sub(r'<think>.*?</think>', '', response_content, flags=re.DOTALL).strip()

    return final_answer

A função ollama_llm() formata a pergunta do usuário e o contexto do documento recuperado em um prompt estruturado. Essa entrada formatada é então enviada ao DeepSeek-R1 por meio do site ollama.chat(), que processa a pergunta dentro do contexto fornecido e retorna uma resposta relevante. Se você precisar da resposta sem o script de raciocínio do modelo, use a função strip() para retornar a resposta final.

Etapa 5: O pipeline RAG

Agora que temos todos os componentes necessários, vamos criar o pipeline RAG para nossa demonstração.

def rag_chain(question, text_splitter, vectorstore, retriever):
    retrieved_docs = retriever.invoke(question)
    formatted_content = combine_docs(retrieved_docs)
    return ollama_llm(question, formatted_content)

A função acima primeiro pesquisa o armazenamento de vetores usando retriever.invoke(question), retornando os trechos de documentos mais relevantes. Esses trechos são formatados em uma entrada estruturada usando a função combine_docs e enviados para ollama_llm, garantindo que o DeepSeek-R1 gere respostas bem informadas com base no conteúdo recuperado.

Etapa 6: Criando a interface do Gradio

Temos nosso pipeline RAG em funcionamento. Agora, podemos criar a interface do Gradio localmente junto com o modelo DeepSeek-R1 para processar a entrada de PDF e fazer perguntas relacionadas a ela.

def ask_question(pdf_bytes, question):
    text_splitter, vectorstore, retriever = process_pdf(pdf_bytes)
    if text_splitter is None:
        return None  # No PDF uploaded
    result = rag_chain(question, text_splitter, vectorstore, retriever)
    return {result}
interface = gr.Interface(
    fn=ask_question,
    inputs=[gr.File(label="Upload PDF (optional)"), gr.Textbox(label="Ask a question")],
    outputs="text",
    title="Ask questions about your PDF",
    description="Use DeepSeek-R1 to answer your questions about the uploaded PDF document.",
)
interface.launch()

Executamos as seguintes etapas:

  • Verifique se um PDF foi carregado.
  • Processe o PDF usando a função process_pdf para extrair o texto e gerar incorporação de documentos.
  • Passe a consulta do usuário e os embeddings de documentos para a função rag_chain() para recuperar informações relevantes e gerar uma resposta contextualmente precisa.
  • Configure uma interface da Web baseada no Gradio para permitir que os usuários carreguem um PDF e façam perguntas sobre seu conteúdo.
  • Defina o layout usando a função gr.Interface(), aceitando um arquivo PDF e uma consulta de texto como entradas.
  • Inicie o aplicativo usando interface.launch() para permitir perguntas e respostas interativas e sem interrupções baseadas em documentos por meio de um navegador da Web.

Executando um aplicativo Gradio local para RAG com DeepSeek-R1

Conclusão

A execução do DeepSeek-R1 localmente com o Ollama permite uma inferência de modelo mais rápida, privada e econômica. Com um processo de instalação simples, interação CLI, suporte a API e integração com Python, você pode usar o DeepSeek-R1 para uma variedade de aplicativos de IA, desde consultas gerais até tarefas complexas baseadas em recuperação.

Para que você fique por dentro dos últimos desenvolvimentos 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

Developing LLM Applications with LangChain

3 hr
13.3K
Discover how to build AI-powered applications using LLMs, prompts, chains, and agents in LangChain.
Ver DetalhesRight Arrow
Iniciar curso
Ver maisRight Arrow
Relacionado

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

RAG With Llama 3.1 8B, Ollama e Langchain: Tutorial

Aprenda a criar um aplicativo RAG com o Llama 3.1 8B usando Ollama e Langchain, configurando o ambiente, processando documentos, criando embeddings e integrando um retriever.
Ryan Ong's photo

Ryan Ong

12 min

tutorial

Guia de torchchat do PyTorch: Configuração local com Python

Saiba como configurar o torchchat do PyTorch localmente com Python neste tutorial prático, que fornece orientação e exemplos passo a passo.
François Aubry's photo

François Aubry

tutorial

Ajuste fino do Llama 3.1 para classificação de textos

Comece a usar os novos modelos Llama e personalize o Llama-3.1-8B-It para prever vários distúrbios de saúde mental a partir do texto.
Abid Ali Awan's photo

Abid Ali Awan

13 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

Como treinar um LLM com o PyTorch

Domine o processo de treinamento de grandes modelos de linguagem usando o PyTorch, desde a configuração inicial até a implementação final.
Zoumana Keita 's photo

Zoumana Keita

8 min

Ver maisVer mais