Construyendo un sistema de generación (trapo) de recuperación con recuperación con Deepseek R1: una guía paso a paso

Con el lanzamiento de Deepseek r1hay un zumbido en la comunidad de IA. El modelo de código abierto ofrece un rendimiento mejor en la clase en muchas métricas, incluso a la par con los modelos patentados de última generación en muchos casos. Tal gran éxito invita a la atención y la curiosidad para aprender más al respecto. En este artículo, analizaremos la implementación de una generación de recuperación acuática (TRAPO) Sistema utilizando Deepseek R1. Cubriremos todo, desde configurar su entorno hasta consultas en ejecución con explicaciones adicionales y fragmentos de código.

Como ya se extendió, RAG combina las fortalezas de los enfoques basados ​​en la recuperación y basados ​​en la generación. Recupera información relevante de una base de conocimiento y la utiliza para generar respuestas precisas y contextualmente relevantes a las consultas de los usuarios.

Algunos requisitos previos para ejecutar los códigos en este tutorial son los siguientes:

• Python instalado (preferiblemente versión 3.7 o superior).
• Ollama instalado: este marco permite ejecutar modelos como Deepseek R1 localmente.

Ahora, veamos la implementación paso a paso:

Paso 1: Instale Ollama

Primero, instale Ollama siguiendo las instrucciones en su sitio web. Una vez instalado, verifique la instalación ejecutando:

Paso 2: Ejecutar el modelo Deepseek R1

Para comenzar el modelo Deepseek R1, abra su terminal y ejecute:

# bash
ollama run deepseek-r1:1.5b

Este comando inicializa la versión de 1.5 mil millones de parámetros de Deepseek R1, que es adecuado para varias aplicaciones.

Paso 3: Prepare su base de conocimiento

Un sistema de recuperación requiere una base de conocimiento a partir de la cual puede extraer información. Esto puede ser una colección de documentos, artículos o cualquier datos de texto relevantes para su dominio.

3.1 Cargue sus documentos

Puede cargar documentos de varias fuentes, como archivos de texto, bases de datos o raspado web. Aquí hay un ejemplo de carga de archivos de texto:

# python
import os

def load_documents(directory):
    documents = []
    for filename in os.listdir(directory):
        if filename.endswith('.txt'):
            with open(os.path.join(directory, filename), 'r') as file:
                documents.append(file.read())
    return documents

documents = load_documents('path/to/your/documents')

Paso 4: crea una tienda vectorial para la recuperación

Para habilitar la recuperación eficiente de documentos relevantes, puede usar una tienda vectorial como FAISS (búsqueda de similitud de IA de Facebook). Esto implica generar incrustaciones para sus documentos.

4.1 Instalar bibliotecas requeridas

Es posible que deba instalar bibliotecas adicionales para incrustaciones y FAISS:

# bash
pip install faiss-cpu huggingface-hub

4.2 Generar incrustaciones y configurar Faiss

Aquí le mostramos cómo generar incrustaciones y configurar la tienda Faiss Vector:

# python
from huggingface_hub import HuggingFaceEmbeddings
import faiss
import numpy as np

# Initialize the embeddings model
embeddings_model = HuggingFaceEmbeddings()

# Generate embeddings for all documents
document_embeddings = [embeddings_model.embed(doc) for doc in documents]
document_embeddings = np.array(document_embeddings).astype('float32')

# Create FAISS index
index = faiss.IndexFlatL2(document_embeddings.shape[1])  # L2 distance metric
index.add(document_embeddings)  # Add document embeddings to the index

Paso 5: Configure el Retriever

Debe crear un retriever basado en consultas de usuarios para obtener los documentos más relevantes.

# python
class SimpleRetriever:
    def __init__(self, index, embeddings_model):
        self.index = index
        self.embeddings_model = embeddings_model
    
    def retrieve(self, query, k=3):
        query_embedding = self.embeddings_model.embed(query)
        distances, indices = self.index.search(np.array([query_embedding]).astype('float32'), k)
        return [documents[i] for i in indices[0]]

retriever = SimpleRetriever(index, embeddings_model)

Paso 6: Configurar Deepseek R1 para trapo

A continuación, se establecerá una plantilla rápida para instruir a Deepseek R1 que responda en función del contexto recuperado.

# python
from ollama import Ollama
from string import Template

# Instantiate the model
llm = Ollama(model="deepseek-r1:1.5b")

# Craft the prompt template using string. Template for better readability
prompt_template = Template("""
Use ONLY the context below.
If unsure, say "I don't know".
Keep answers under 4 sentences.

Context: $context
Question: $question
Answer:
""")

Paso 7: Implementar la funcionalidad de manejo de consultas

Ahora, puede crear una función que combine la recuperación y la generación para responder consultas de los usuarios:

# python
def answer_query(question):
    # Retrieve relevant context from the knowledge base
    context = retriever.retrieve(question)
    
    # Combine retrieved contexts into a single string (if multiple)
    combined_context = "n".join(context)
    
    # Generate an answer using DeepSeek R1 with the combined context
    response = llm.generate(prompt_template.substitute(context=combined_context, question=question))
    
    return response.strip()

Paso 8: Ejecutando su sistema de trapo

Ahora puede probar su sistema RAG llamando a la función `Respuesta_Query` con cualquier pregunta sobre su base de conocimiento.

# python
if __name__ == "__main__":
    user_question = "What are the key features of DeepSeek R1?"
    answer = answer_query(user_question)
    print("Answer:", answer)

Acceda al cuaderno Colab con el código completo

En conclusión, después de estos pasos, puede implementar con éxito un sistema de generación (trapo) de recuperación (RAG) utilizando Deepseek R1. Esta configuración le permite recuperar información de sus documentos de manera efectiva y generar respuestas precisas basadas en esa información. Además, explore el potencial del modelo Deepseek R1 para su caso de uso específico a través de esto.

Fuentes