Comment configurer et exécuter DeepSeek R1 localement avec Ollama

Dans ce tutoriel, je vais vous expliquer étape par étape comment exécuter DeepSeek-R1 localement et comment le configurer à l'aide d'Ollama. Nous explorerons également la construction d'une application RAG simple qui fonctionne sur votre ordinateur portable en utilisant le modèle R1, LangChain et Gradio.

Si vous ne souhaitez qu'une vue d'ensemble du modèle R1, je vous recommande cet article de DeepSeek-R1. Pour apprendre à affiner le réglage de R1, je vous recommande ce tutoriel sur l'affinement de DeepSeek-R1.

Pourquoi faire fonctionner DeepSeek-R1 localement ?

L'exécution locale de DeepSeek-R1 vous permet de contrôler entièrement l'exécution du modèle sans dépendre de serveurs externes. Voici quelques avantages à exécuter DeepSeek-R1 localement :

• Vie privée et sécurité: Aucune donnée ne quitte votre système.
• Accès ininterrompu: Évitez les limites de taux, les temps d'arrêt ou les interruptions de service.
• Performance: Obtenez des réponses plus rapides grâce à l'inférence locale, en évitant la latence de l'API.
• Personnalisation: Modifiez les paramètres, affinez les messages-guides et intégrez le modèle dans les applications locales.
• Coût-efficacité: Éliminez les frais d'API en exécutant le modèle localement.
• Disponibilité hors ligne: Travailler sans connexion internet une fois le modèle téléchargé.

Configurer DeepSeek-R1 localement avec Ollama

Ollama simplifie l'exécution locale des LLM en gérant les téléchargements de modèles, la quantification et l'exécution de manière transparente.

Étape 1 : Installer Ollama

Tout d'abord, téléchargez et installez Ollama depuis le officiel.

Une fois le téléchargement terminé, installez l'application Ollama comme vous le feriez pour n'importe quelle autre application.

Étape 2 : Téléchargez et exécutez DeepSeek-R1

Testons la configuration et téléchargeons notre modèle. Lancez le terminal et tapez la commande suivante.

ollama run deepseek-r1

Ollama propose une gamme de modèles DeepSeek R1, allant de 1,5B paramètres au modèle complet de 671B paramètres. Le modèle 671B est le DeepSeek-R1 original, tandis que les modèles plus petits sont des versions distillées basées sur les architectures Qwen et Llama. Si votre matériel ne supporte pas le modèle 671B, vous pouvez facilement exécuter une version plus petite en utilisant la commande suivante et en remplaçant le X ci-dessous par la taille de paramètre que vous souhaitez (1.5b, 7b, 8b, 14b, 32b, 70b, 671b) :

ollama run deepseek-r1: Xb

Grâce à cette flexibilité, vous pouvez utiliser les capacités de DeepSeek-R1 même si vous ne disposez pas d'un superordinateur.

Étape 3 : Exécution de DeepSeek-R1 en arrière-plan

Pour exécuter DeepSeek-R1 en continu et le servir via une API, démarrez le serveur Ollama :

ollama serve

Le modèle pourra ainsi être intégré à d'autres applications.

Utilisation locale de DeepSeek-R1

Étape 1 : Exécution de l'inférence via l'interface de programmation

Une fois le modèle téléchargé, vous pouvez interagir avec DeepSeek-R1 directement dans le terminal.

Étape 2 : Accès à DeepSeek-R1 via l'API

Pour intégrer DeepSeek-R1 dans des applications, utilisez l'API Ollama à l'aide de curl:

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

curl est un outil de ligne de commande natif de Linux, mais qui fonctionne également sur macOS. Il permet aux utilisateurs de faire des requêtes HTTP directement à partir du terminal, ce qui en fait un excellent outil pour interagir avec les API.

Étape 3 : Accéder à DeepSeek-R1 via Python

Nous pouvons exécuter Ollama dans l'environnement de développement intégré (IDE) de notre choix. Vous pouvez installer le paquetage Python d'Ollama en utilisant le code suivant :

!pip install ollama

Une fois Ollama installé, utilisez le script suivant pour interagir avec le modèle :

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

La fonction ollama.chat() prend le nom du modèle et une invite de l'utilisateur, qu'elle traite comme un échange conversationnel. Le script extrait et imprime ensuite la réponse du modèle.

Exécuter une application locale Gradio pour RAG avec DeepSeek-R1

Construisons une application de démonstration simple utilisant Gradio pour interroger et analyser des documents avec DeepSeek-R1.

Étape 1 : Conditions préalables

Avant de plonger dans la mise en œuvre, assurons-nous que les outils et bibliothèques suivants sont installés :

• Python 3.8+.
• Langchain : Cadre pour la création d'applications alimentées par de grands modèles de langage (LLM), permettant de faciliter la recherche, le raisonnement et l'intégration d'outils.
• Chromadb : Une base de données vectorielles à haute performance conçue pour des recherches de similarité efficaces et le stockage des embeddings.
• Gradio : Créer une interface web conviviale.

Exécutez les commandes suivantes pour installer les dépendances nécessaires :

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

Une fois les dépendances ci-dessus installées, exécutez les commandes d'importation suivantes :

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

Étape 2 : Traitement du PDF téléchargé

Une fois les bibliothèques importées, nous traiterons le PDF téléchargé.

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

La fonction process_pdf:

• Charge et prépare le contenu des PDF pour une réponse basée sur la recherche.
• Vérifie si un PDF a été téléchargé.
• Extraction de texte à l'aide de PyMuPDFLoader.
• Découpe le texte en morceaux à l'aide de RecursiveCharacterTextSplitter.
• Génère des encastrements vectoriels à l'aide de OllamaEmbeddings.
• Stocke les données d'intégration dans une mémoire vectorielle Chroma pour une récupération efficace.

Étape 3 : Combinaison de morceaux de documents récupérés

Une fois que les encastrements ont été récupérés, il faut les assembler. La fonction combine_docs() fusionne plusieurs morceaux de documents récupérés en une seule chaîne.

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

Étant donné que les modèles basés sur la recherche tirent des extraits pertinents plutôt que des documents entiers, cette fonction garantit que le contenu extrait reste lisible et correctement formaté avant d'être transmis à DeepSeek-R1.

Étape 4 : Interroger DeepSeek-R1 avec Ollama

Notre entrée dans le modèle est maintenant prête. Mettons en place DeepSeek R1 en utilisant 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

La fonction ollama_llm() formate la question de l'utilisateur et le contexte du document récupéré en une invite structurée. Cette entrée formatée est ensuite envoyée à DeepSeek-R1 via ollama.chat(), qui traite la question dans le contexte donné et renvoie une réponse pertinente. Si vous avez besoin de la réponse sans le script de réflexion du modèle, utilisez la fonction strip() pour obtenir la réponse finale.

Étape 5 : La filière RAG

Maintenant que nous avons tous les composants nécessaires, construisons le pipeline RAG pour notre démo.

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)

La fonction ci-dessus effectue d'abord une recherche dans le magasin de vecteurs à l'aide de retriever.invoke(question) et renvoie les extraits de documents les plus pertinents. Ces extraits sont formatés dans une entrée structurée à l'aide de la fonction combine_docs et envoyés à ollama_llm, ce qui permet à DeepSeek-R1 de générer des réponses bien informées sur la base du contenu récupéré.

Étape 6 : Création de l'interface Gradio

Nous avons mis en place notre pipeline RAG. Maintenant, nous pouvons construire l'interface Gradio localement avec le modèle DeepSeek-R1 pour traiter les entrées PDF et poser les questions qui s'y rapportent.

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()

Nous procédons aux étapes suivantes :

• Vérifier si un PDF est téléchargé.
• Traitez le PDF à l'aide de la fonction process_pdf pour extraire le texte et générer des incorporations de documents.
• Transmettez la requête de l'utilisateur et les enchâssements de documents à la fonction rag_chain() pour qu'elle récupère les informations pertinentes et génère une réponse adaptée au contexte.
• Mettez en place une interface web basée sur Gradio pour permettre aux utilisateurs de télécharger un PDF et de poser des questions sur son contenu.
• Définissez la mise en page à l'aide de la fonction gr.Interface(), qui accepte un fichier PDF et une requête de texte comme entrées.
• Lancez l'application à l'aide de interface.launch() pour permettre des questions-réponses interactives et transparentes basées sur des documents via un navigateur web.

Conclusion

L'exécution locale de DeepSeek-R1 avec Ollama permet une inférence de modèle plus rapide, privée et rentable. Avec un processus d'installation simple, une interaction CLI, une prise en charge API et une intégration Python, vous pouvez utiliser DeepSeek-R1 pour une variété d'applications d'IA, des requêtes générales aux tâches complexes basées sur l'extraction.

Pour vous tenir au courant des derniers développements en matière d'IA, je vous recommande ces blogs :

• Qwen 2.5-Max
• Le Janus-Pro de DeepSeek
• Projet de démonstration DeepSeek-R1 avec Gradio et EasyOCR
• Comment utiliser DeepSeek Janus-Pro localement ?