Bauen Sie Ihr erstes Lappensystem mit Python und OpenAI auf

Dieses Tutorial führt Sie durch den Bau eines RAG -Systems (Abruf Augmented Generation) mit Python und OpenAI. RAG verbessert die KI -Antworten, indem relevante Informationen aus Ihren Dokumenten abgerufen werden, bevor eine Antwort generiert wird.

Was werden Sie lernen:

Erstellen eines Lappensystems von Grund auf neu.
Vorbereitung und Verarbeitung von Dokumenten für Rag.
unter Verwendung von OpenAI -Einbettungen.
Erstellen eines grundlegenden Abrufsystems.
in die OpenAI -API integrieren.

Projektstruktur:

<code>rag-project/
│
├── src/
│   ├── __init__.py
│   ├── document_loader.py
│   ├── text_processor.py
│   ├── embeddings_manager.py
│   ├── retrieval_system.py
│   └── rag_system.py
│
├── data/
│   └── documents/
│
├── requirements.txt
├── test.py
├── README.md
└── .env</code>

Schritt 1: Umgebungsaufbau:

Erstellen Sie eine virtuelle Umgebung:
1. (unter Windows: python -m venv venv) venvScriptsactivate
Aktivieren Sie es:
2. source venv/bin/activate
Pakete installieren:
3. pip install openai python-dotenv numpy pandas
erstellen
4. : requirements.txt

<code>openai==1.12.0
python-dotenv==1.0.0
numpy==1.24.3
pandas==2.1.0</code>

konfigurieren
5. : .env

<code>OPENAI_API_KEY=your_api_key_here</code>

Schritt 2: Dokumentlade (): src/document_loader.py

import os
from typing import List

class DocumentLoader:
    def __init__(self, documents_path: str):
        self.documents_path = documents_path

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

Schritt 3: Textverarbeitung (): src/text_processor.py

from typing import List

class TextProcessor:
    def __init__(self, chunk_size: int = 1000):
        self.chunk_size = chunk_size

    def split_into_chunks(self, text: str) -> List[str]:
        words = text.split()
        chunks = []
        current_chunk = []
        current_size = 0

        for word in words:
            if current_size + len(word) > self.chunk_size:
                chunks.append(' '.join(current_chunk))
                current_chunk = [word]
                current_size = len(word)
            else:
                current_chunk.append(word)
                current_size += len(word) + 1

        if current_chunk:
            chunks.append(' '.join(current_chunk))

        return chunks

Schritt 4: Einbettungserstellung (): src/embeddings_manager.py

from typing import List
import openai
import numpy as np

class EmbeddingsManager:
    def __init__(self, api_key: str):
        openai.api_key = api_key

    def create_embeddings(self, texts: List[str]) -> List[np.ndarray]:
        embeddings = []
        for text in texts:
            response = openai.embeddings.create(
                model="text-embedding-ada-002",
                input=text
            )
            embeddings.append(np.array(response.data[0].embedding))
        return embeddings

Schritt 5: Abrufsystem (): src/retrieval_system.py

import numpy as np
from typing import List, Tuple

class RetrievalSystem:
    def __init__(self, chunks: List[str], embeddings: List[np.ndarray]):
        self.chunks = chunks
        self.embeddings = embeddings

    def find_similar_chunks(self, query_embedding: np.ndarray, top_k: int = 3) -> List[Tuple[str, float]]:
        similarities = []
        for i, embedding in enumerate(self.embeddings):
            similarity = np.dot(query_embedding, embedding) / (
                np.linalg.norm(query_embedding) * np.linalg.norm(embedding)
            )
            similarities.append((self.chunks[i], similarity))

        return sorted(similarities, key=lambda x: x[1], reverse=True)[:top_k]

Schritt 6: OpenAI -Integration (): src/rag_system.py

import os
from dotenv import load_dotenv
from typing import List
import openai

from .document_loader import DocumentLoader
from .text_processor import TextProcessor
from .embeddings_manager import EmbeddingsManager
from .retrieval_system import RetrievalSystem

class RAGSystem:
    def __init__(self):
        load_dotenv()
        self.api_key = os.getenv('OPENAI_API_KEY')
        self.loader = DocumentLoader('data/documents')
        self.processor = TextProcessor()
        self.embeddings_manager = EmbeddingsManager(self.api_key)

        # Initialize system
        self.initialize_system()

    def initialize_system(self):
        # Load and process documents
        documents = self.loader.load_documents()
        self.chunks = []
        for doc in documents:
            self.chunks.extend(self.processor.split_into_chunks(doc))

        # Create embeddings
        self.embeddings = self.embeddings_manager.create_embeddings(self.chunks)

        # Initialize retrieval system
        self.retrieval_system = RetrievalSystem(self.chunks, self.embeddings)

    def answer_question(self, question: str) -> str:
        # Get question embedding
        question_embedding = self.embeddings_manager.create_embeddings([question])[0]

        # Get relevant chunks
        relevant_chunks = self.retrieval_system.find_similar_chunks(question_embedding)

        # Prepare context
        context = "\n".join([chunk[0] for chunk in relevant_chunks])

        # Create prompt
        prompt = f"""Context: {context}\n\nQuestion: {question}\n\nAnswer:"""

        # Get response from OpenAI
        response = openai.chat.completions.create(
            model="gpt-4-turbo-preview",
            messages=[
                {"role": "system", "content": "You are a helpful assistant. Use the provided context to answer the question."},
                {"role": "user", "content": prompt}
            ]
        )

        return response.choices[0].message.content

Schritt 7: Systemverwendung (): test.py

Probe

Dokumente in .txt platzieren. Dann führen Sie data/documents: test.py aus

# test.py
from src.rag_system import RAGSystem

# Initialize the RAG system
rag = RAGSystem()

# Ask a question
question = "What was the answer to the guardian’s riddle, and how did it help Kai?" #Replace with your question based on your documents
answer = rag.answer_question(question)
print(answer)

Schlussfolgerung:

Dies liefert ein grundlegendes Lappensystem. Zukünftige Verbesserungen könnten erweitertes Chunking, Einbettung von Caching, Fehlerbehebung, raffiniertem Eingabeaufenthalt und Integration der Vektordatenbank sein. Denken Sie daran, Ihren OpenAI -API -Schlüssel sicher zu verwalten und die Nutzung zu überwachen.

Das obige ist der detaillierte Inhalt vonBauen Sie Ihr erstes Lappensystem mit Python und OpenAI auf. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!