Construire une application de chiffon (génération auprès de la récupération) utilisant Deep Seek Rrom Scratch

La génération (RAG) de la récupération (RAG) combine des systèmes de récupération avec des modèles génératifs pour fournir des réponses plus précises et riches en contexte. Deep Seek R1 est un outil puissant qui nous aide à construire de tels systèmes efficacement en intégrant les capacités de récupération avec des modèles de langage avancés. Dans ce blog, nous allons parcourir le processus de création d'une application de chiffon à partir de zéro en utilisant Deep Seek R1.

---

1. Comprendre l'architecture de Rag

Les applications de chiffon sont construites autour de trois composants principaux:

1. retriever : trouve des documents pertinents à partir d'une base de connaissances.
2. générateur : utilise des documents récupérés comme contexte pour générer des réponses.
3. Base de connaissances : stocke tous les documents ou informations dans un format facilement récupérable.

---

2. Configuration de l'environnement

Étape 1: Installer les dépendances requises

Pour commencer, assurez-vous que Python soit installé. Ensuite, configurez les bibliothèques requises, y compris la recherche profonde R1. Installez les dépendances en utilisant les commandes suivantes:

pip install deep-seek-r1 langchain transformers sentence-transformers faiss-cpu

Étape 2: Initialisez le projet

Créez un nouveau répertoire de projet et configurez un environnement virtuel pour l'isolement.

mkdir rag-deepseek-app
cd rag-deepseek-app
python -m venv venv
source venv/bin/activate  # or venv\Scripts\activate for Windows

---

3. Construire la base de connaissances

La base de connaissances est le cœur d'un système de chiffon. Pour cet exemple, nous utiliserons des documents texte, mais vous pouvez l'étendre aux PDF, bases de données ou autres formats.

Étape 1: Préparez les données

Organisez vos documents dans un dossier nommé Data.

rag-deepseek-app/
└── data/
    ├── doc1.txt
    ├── doc2.txt
    └── doc3.txt

Étape 2: Intégrez les documents

Utiliser Deep Seek R1 pour intégrer les documents pour une récupération efficace.

from deep_seek_r1 import DeepSeekRetriever
from sentence_transformers import SentenceTransformer
import os

# Load the embedding model
embedding_model = SentenceTransformer('all-MiniLM-L6-v2')

# Prepare data
data_dir = './data'
documents = []
for file_name in os.listdir(data_dir):
    with open(os.path.join(data_dir, file_name), 'r') as file:
        documents.append(file.read())

# Embed the documents
embeddings = embedding_model.encode(documents, convert_to_tensor=True)

# Initialize the retriever
retriever = DeepSeekRetriever()
retriever.add_documents(documents, embeddings)
retriever.save('knowledge_base.ds')  # Save the retriever state

---

4. Construire le pipeline de récupération et de génération

Maintenant, nous allons configurer le pipeline pour récupérer des documents pertinents et générer des réponses.

Étape 1: Chargez le retriever

retriever = DeepSeekRetriever.load('knowledge_base.ds')

Étape 2: Intégrez le générateur

Nous utiliserons les modèles GPT d'Openai ou les transformateurs de visage étreintes pour la génération.

from transformers import AutoModelForCausalLM, AutoTokenizer

# Load the generator model
generator_model = AutoModelForCausalLM.from_pretrained("gpt2")
tokenizer = AutoTokenizer.from_pretrained("gpt2")

def generate_response(query, retrieved_docs):
    # Combine the query and retrieved documents
    input_text = query + "\n\n" + "\n".join(retrieved_docs)

    # Tokenize and generate a response
    inputs = tokenizer.encode(input_text, return_tensors='pt', max_length=512, truncation=True)
    outputs = generator_model.generate(inputs, max_length=150, num_return_sequences=1)

    return tokenizer.decode(outputs[0], skip_special_tokens=True)

---

5. Interroger le système

Voici comment nous assemblons tout pour gérer les requêtes utilisateur.

def rag_query(query):
    # Retrieve relevant documents
    retrieved_docs = retriever.search(query, top_k=3)

    # Generate a response
    response = generate_response(query, retrieved_docs)

    return response

Exemple de requête

query = "What is the impact of climate change on agriculture?"
response = rag_query(query)
print(response)

---

6. Déploiement de l'application

Pour rendre le système de chiffon accessible, vous pouvez le déployer en utilisant Flask ou Fastapi.

Étape 1: Configurez Flask

Installez Flask:

pip install deep-seek-r1 langchain transformers sentence-transformers faiss-cpu

Créer un fichier app.py:

mkdir rag-deepseek-app
cd rag-deepseek-app
python -m venv venv
source venv/bin/activate  # or venv\Scripts\activate for Windows

Exécutez le serveur:

rag-deepseek-app/
└── data/
    ├── doc1.txt
    ├── doc2.txt
    └── doc3.txt

Étape 2: Testez l'API

Utilisez Postman ou Curl pour envoyer une requête:

from deep_seek_r1 import DeepSeekRetriever
from sentence_transformers import SentenceTransformer
import os

# Load the embedding model
embedding_model = SentenceTransformer('all-MiniLM-L6-v2')

# Prepare data
data_dir = './data'
documents = []
for file_name in os.listdir(data_dir):
    with open(os.path.join(data_dir, file_name), 'r') as file:
        documents.append(file.read())

# Embed the documents
embeddings = embedding_model.encode(documents, convert_to_tensor=True)

# Initialize the retriever
retriever = DeepSeekRetriever()
retriever.add_documents(documents, embeddings)
retriever.save('knowledge_base.ds')  # Save the retriever state

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!