Zaawansowany RAG: LongRAG, Self-RAG i GraphRAG wyjaśnione

LongRAG, Self-RAG, GraphRAG – techniki przyszłościowego pokolenia

Page content

Generacja Augmentowana Przeszukiwaniem (RAG) zaawansowała się znacznie dalej niż proste przeszukiwanie podobieństwa wektorów. LongRAG, Self-RAG i GraphRAG reprezentują najnowsze osiągnięcia w tej dziedzinie.

Nowoczesne systemy RAG muszą radzić sobie z masowymi dokumentami, rozumieć złożone relacje między obiektami i wiele więcej.

a-pirate-captain To piękne zdjęcie zostało wygenerowane przez model AI Flux 1 dev.

Rozwój Później niż Podstawowe RAG

Tradycyjne systemy RAG opierają się na prostym schemacie: dzielenie dokumentów, zakodowanie ich w wektory, odzyskiwanie podobnych fragmentów poprzez podobieństwo kosinusowe i przekazanie ich do LLM. Choć skuteczne w wielu przypadkach, ten podejście ma trudności z trzema krytycznymi scenariuszami:

  1. Długofalowe zależności: Ważny kontekst może się rozciągać na tysiące tokenów w wielu fragmentach
  2. Pewność przeszukiwania: System nie ma sposobu na ocenę, czy odzyskany materiał rzeczywiście jest istotny
  3. Złożoność relacji: Podobieństwo wektorowe nie może wyrazić skomplikowanych połączeń między obiektami

Zaawansowane wersje RAG rozwiązują te ograniczenia za pomocą specjalistycznych architektur dopasowanych do konkretnych wyzwań.

LongRAG: Zwyciężanie Długiego Kontekstu

Omówienie Architektury

LongRAG fundamentalnie przeanalizował strategię podziału, korzystając z LLM z rozszerzonymi oknami kontekstowymi (32K, 100K, nawet 1M tokenów). Zamiast dzielić dokumenty na małe fragmenty 512-tokenowe, LongRAG stosuje podejście hierarchiczne:

Zaawansowane zakodowanie dokumentu: Cały dokument (lub bardzo duże sekcje) jest przetwarzany jako jednostka. Zakodowanie na poziomie dokumentu przechwytuje ogólny znaczeniowy sens, jednocześnie zachowując pełny tekst dla dalszego przetwarzania.

Minimalna fragmentacja: Gdy konieczny jest podział, LongRAG używa znacznie większych fragmentów (4K-8K tokenów) z dużym nakładaniem się (20-30%). To zachowuje płynność narracji i zmniejsza fragmentację kontekstu.

Złożenie kontekstu: Podczas przeszukiwania, LongRAG zwraca pełne dokumenty lub duże spójne sekcje zamiast rozproszonych fragmentów. LLM otrzymuje ciągły kontekst, który zachowuje relacje strukturalne i znaczeniowe.

Strategia Implementacji

Oto koncepcyjna implementacja za pomocą Pythona i nowoczesnych modeli zakodowania:

from typing import List, Dict
import numpy as np

class LongRAGRetriever:
    def __init__(self, model, chunk_size=8000, overlap=1600):
        self.model = model
        self.chunk_size = chunk_size
        self.overlap = overlap
        self.doc_embeddings = []
        self.documents = []
    
    def create_long_chunks(self, text: str) -> List[str]:
        """Utwórz duże fragmenty z nakładaniem się"""
        chunks = []
        start = 0
        while start < len(text):
            end = start + self.chunk_size
            chunk = text[start:end]
            chunks.append(chunk)
            start += (self.chunk_size - self.overlap)
        return chunks
    
    def index_document(self, doc: str, metadata: Dict):
        """Zindeksuj dokument z hierarchicznym zakodowaniem"""
        # Zakoduj cały dokument
        doc_embedding = self.model.embed(doc)
        
        # Utwórz duże fragmenty z nakładaniem się
        chunks = self.create_long_chunks(doc)
        chunk_embeddings = [self.model.embed(c) for c in chunks]
        
        self.doc_embeddings.append({
            'doc_id': len(self.documents),
            'doc_embedding': doc_embedding,
            'chunk_embeddings': chunk_embeddings,
            'chunks': chunks,
            'full_text': doc,
            'metadata': metadata
        })
        self.documents.append(doc)
    
    def retrieve(self, query: str, top_k: int = 3) -> List[Dict]:
        """Odzyskaj odpowiednie treści w formacie długim"""
        query_embedding = self.model.embed(query)
        
        # Ocena na poziomie dokumentu
        doc_scores = [
            np.dot(query_embedding, doc['doc_embedding'])
            for doc in self.doc_embeddings
        ]
        
        # Pobierz najlepsze dokumenty
        top_doc_indices = np.argsort(doc_scores)[-top_k:][::-1]
        
        results = []
        for idx in top_doc_indices:
            doc_data = self.doc_embeddings[idx]
            
            # Dla każdego dokumentu, znajdź najlepsze fragmenty
            chunk_scores = [
                np.dot(query_embedding, emb)
                for emb in doc_data['chunk_embeddings']
            ]
            best_chunk_idx = np.argmax(chunk_scores)
            
            # Zwróć rozszerzony kontekst wokół najlepszego fragmentu
            context_chunks = self._get_extended_context(
                doc_data['chunks'], 
                best_chunk_idx
            )
            
            results.append({
                'text': ''.join(context_chunks),
                'score': doc_scores[idx],
                'metadata': doc_data['metadata']
            })
        
        return results
    
    def _get_extended_context(self, chunks: List[str], 
                             center_idx: int) -> List[str]:
        """Pobierz rozszerzony kontekst wokół istotnego fragmentu"""
        start = max(0, center_idx - 1)
        end = min(len(chunks), center_idx + 2)
        return chunks[start:end]

Przypadki użycia i wydajność

LongRAG świetnie radzi sobie w sytuacjach, gdzie kontekst ma znaczenie:

  • Analiza dokumentów prawnych: Umowy i prawni skargi często mają zależności rozciągnięte na setki stron
  • Pobieranie artykułów naukowych: Zrozumienie metodologii wymaga spójnych sekcji, nie izolowanych akapitów
  • Repozytoria kodu: Funkcje i klasy muszą być zrozumiałe w kontekście ich modułów

Charakterystyka wydajności:

  • Opóźnienie: Wysokie ze względu na przetwarzanie dużych fragmentów (2-5x wolniejsze niż standardowe RAG)
  • Dokładność: 15-25% poprawa na testach QA w formacie długim
  • Pamięć: Wymaga 3-4x więcej pamięci dla okien kontekstowych

Self-RAG: Przeszukiwanie Odbiorcze

Podstawowe zasady

Self-RAG wprowadza warstwę metakognitywną do systemów RAG. Zamiast przeszukiwać i generować bezrefleksyjnie, system aktywnie reflektuje nad swoimi procesami za pomocą specjalnych tokenów refleksji:

Token przeszukiwania: Decyduje, czy przeszukiwanie jest konieczne dla danego zapytania Token istotności: Ocenia, czy odzyskane dokumenty rzeczywiście są istotne Token wsparcia: Sprawdza, czy wygenerowana odpowiedź jest wspierana przez odzyskane treści Token krytyki: Ocenia ogólną jakość wygenerowanej odpowiedzi

Komponenty architektury

Architektura Self-RAG składa się z trzech wzajemnie przenikających faz:

class SelfRAGSystem:
    def __init__(self, retriever, generator, critic):
        self.retriever = retriever
        self.generator = generator
        self.critic = critic
    
    def generate_with_reflection(self, query: str, 
                                 max_iterations: int = 3):
        """Wygeneruj odpowiedź z refleksją"""
        
        # Faza 1: Decyduj, czy przeszukiwanie jest potrzebne
        retrieve_decision = self.critic.should_retrieve(query)
        
        if not retrieve_decision:
            # Generacja bez przeszukiwania
            return self.generator.generate(query)
        
        # Faza 2: Przeszukaj i ocen istotność
        retrieved_docs = self.retriever.retrieve(query)
        relevant_docs = []
        
        for doc in retrieved_docs:
            relevance_score = self.critic.assess_relevance(
                query, doc
            )
            if relevance_score > 0.7:  # Próg
                relevant_docs.append(doc)
        
        if not relevant_docs:
            # Ujemna generacja bez przeszukiwania
            return self.generator.generate(query)
        
        # Faza 3: Generuj i weryfikuj wsparcie
        best_answer = None
        best_score = -1
        
        for _ in range(max_iterations):
            # Generuj odpowiedź kandydatkę
            answer = self.generator.generate(
                query, context=relevant_docs
            )
            
            # Ocena wsparcia i jakości
            support_score = self.critic.check_support(
                answer, relevant_docs
            )
            quality_score = self.critic.assess_quality(answer)
            
            total_score = 0.6 * support_score + 0.4 * quality_score
            
            if total_score > best_score:
                best_score = total_score
                best_answer = answer
            
            # Przerywanie wczesne, jeśli osiągnięto wysoką jakość
            if total_score > 0.9:
                break
        
        return {
            'answer': best_answer,
            'confidence': best_score,
            'sources': relevant_docs,
            'reflections': {
                'retrieved': retrieve_decision,
                'relevance': len(relevant_docs),
                'support': support_score
            }
        }

Trenowanie mechanizmów refleksji

Self-RAG wymaga trenowania komponentu krytyka, aby dokonywać niezawodnych ocen. Zwykle obejmuje to:

  1. Przetransformowanie z nadzorem na danych z anotacjami oceny istotności
  2. Uczenie wzmocnieniowe z nagrodami za dokładne przewidywania
  3. Uczenie kontrastowe do rozróżniania stwierdzeń wspieranych i niewspieranych

Tokeny refleksji mogą być zaimplementowane jako:

  • Specjalne tokeny w słowniku (np. [PRZESZUKAJ], [ISTOTNY])
  • Oddzielne głowy klasyfikatora na modelu
  • Zewnętrzne modele krytyki (podejście ensemblowe)

Rozważania w środowisku produkcyjnym

Podczas wdrażania Self-RAG w systemach produkcyjnych:

Zamiany opóźnienia: Każdy krok refleksji dodaje 20-40% opóźnienia w inferencji. Zrównoważ dokładność z wymaganiami czasu odpowiedzi.

Próg zaufania: Dostosuj progi refleksji do swojego przypadku użycia. Aplikacje prawne lub medyczne wymagają wyższego zaufania niż ogólni chatboty.

Monitorowanie: Śledź decyzje refleksji, aby zidentyfikować wzorce. Jeśli przeszukiwanie rzadko jest potrzebne, możesz skorzystać z prostszej architektury.

GraphRAG: Przeszukiwanie wzbogacone Grafem Wiedzy

Podstawy koncepcyjne

GraphRAG przekształca problem przeszukiwania z podobieństwa wektorowego na przejście po grafie. Zamiast znajdować semantycznie podobne fragmenty tekstu, GraphRAG identyfikuje istotne podgrafy połączonej sieci obiektów i relacji.

Ekstrakcja obiektów: Zidentyfikuj nazwane obiekty, pojęcia i ich typy Mapowanie relacji: Ekstrahuj relacje między obiektami (czasowe, przyczynowe, hierarchiczne) Konstrukcja grafu: Buduj graf wiedzy z obiektami jako węzłami i relacjami jako krawędziami Przeszukiwanie podgrafów: Dla zapytania, znajdź istotne połączone podgrafy

Potok konstrukcji grafu

Budowanie grafu wiedzy z tekstu niesformatowanego obejmuje kilka etapów:

class GraphRAGBuilder:
    def __init__(self, entity_extractor, relation_extractor):
        self.entity_extractor = entity_extractor
        self.relation_extractor = relation_extractor
        self.graph = NetworkGraph()
    
    def build_graph(self, documents: List[str]):
        """Zbuduj graf wiedzy z dokumentów"""
        for doc in documents:
            # Ekstrahuj obiekty
            entities = self.entity_extractor.extract(doc)
            
            # Dodaj obiekty jako węzły
            for entity in entities:
                self.graph.add_node(
                    entity['text'],
                    entity_type=entity['type'],
                    context=entity['surrounding_text']
                )
            
            # Ekstrahuj relacje
            relations = self.relation_extractor.extract(
                doc, entities
            )
            
            # Dodaj relacje jako krawędzie
            for rel in relations:
                self.graph.add_edge(
                    rel['source'],
                    rel['target'],
                    relation_type=rel['type'],
                    confidence=rel['score'],
                    evidence=rel['text_span']
                )
    
    def enrich_graph(self):
        """Dodaj pochodne relacje i metadane"""
        # Oblicz ważność węzłów (PageRank itp.)
        self.graph.compute_centrality()
        
        # Zidentyfikuj społeczności/klastery
        self.graph.detect_communities()
        
        # Dodaj porządkowanie czasowe, jeśli dostępne są znaczniki czasu
        self.graph.add_temporal_edges()

Przetwarzanie zapytań z użyciem grafów

Zapytania w GraphRAG obejmują wielokrotny przemyślenie wzdłuż grafu wiedzy:

class GraphRAGRetriever:
    def __init__(self, graph, embedder):
        self.graph = graph
        self.embedder = embedder
    
    def retrieve_subgraph(self, query: str, 
                         max_hops: int = 2,
                         max_nodes: int = 50):
        """Pobierz istotny podgraf dla zapytania"""
        
        # Zidentyfikuj początkowe obiekty w zapytaniu
        query_entities = self.entity_extractor.extract(query)
        
        # Znajdź pasujące węzły w grafie
        seed_nodes = []
        for entity in query_entities:
            matches = self.graph.find_similar_nodes(
                entity['text'],
                similarity_threshold=0.85
            )
            seed_nodes.extend(matches)
        
        # Rozszerz podgraf poprzez przejście
        subgraph = self.graph.create_subgraph()
        visited = set()
        
        for seed in seed_nodes:
            self._expand_from_node(
                seed, 
                subgraph, 
                visited,
                current_hop=0,
                max_hops=max_hops
            )
        
        # Uporządkuj węzły według istotności
        ranked_nodes = self._rank_subgraph_nodes(
            subgraph, query
        )
        
        # Ekstrahuj i sformatuj kontekst
        context = self._format_graph_context(
            ranked_nodes[:max_nodes],
            subgraph
        )
        
        return context
    
    def _expand_from_node(self, node, subgraph, visited,
                         current_hop, max_hops):
        """Rekurencyjnie rozszerz podgraf"""
        if current_hop >= max_hops or node in visited:
            return
        
        visited.add(node)
        subgraph.add_node(node)
        
        # Pobierz sąsiadów
        neighbors = self.graph.get_neighbors(node)
        
        for neighbor, edge_data in neighbors:
            # Dodaj krawędź do podgrafu
            subgraph.add_edge(node, neighbor, edge_data)
            
            # Rekurencyjnie rozszerz
            self._expand_from_node(
                neighbor,
                subgraph,
                visited,
                current_hop + 1,
                max_hops
            )
    
    def _format_graph_context(self, nodes, subgraph):
        """Konwertuj podgraf na tekstowy kontekst"""
        context_parts = []
        
        for node in nodes:
            # Dodaj kontekst węzła
            context_parts.append(f"Obiekt: {node.text}")
            context_parts.append(f"Typ: {node.entity_type}")
            
            # Dodaj informacje o relacjach
            edges = subgraph.get_edges(node)
            for edge in edges:
                context_parts.append(
                    f"- {edge.relation_type} -> {edge.target.text}"
                )
        
        return "\n".join(context_parts)

Implementacja GraphRAG w Microsoft

Microsoft’s GraphRAG podejmuje unikalny sposób, generując podsumowania społeczności:

  1. Zbuduj początkowy graf z dokumentów za pomocą ekstrakcji obiektów i relacji opartych na LLM
  2. Wykryj społeczności za pomocą algorytmu Leiden lub podobnego
  3. Wygeneruj podsumowania dla każdej społeczności za pomocą LLM
  4. Struktura hierarchiczna: Buduj wiele poziomów abstrakcji społeczności
  5. Czas przeszukiwania: Pobierz istotne społeczności i przejdź do konkretnych obiektów

Ten podejście jest szczególnie skuteczne dla:

  • Zapytań eksploracyjnych (“Jakie są główne tematy w tej kolekcji?”)
  • Wielokrotnego przemyślenia (“Jak A jest połączony z C przez B?”)
  • Analizy czasowej (“Jak ewoluowały relacje tego obiektu?”)

Porównanie analizy

Kiedy używać każdej wersji

Użyj LongRAG, gdy:

  • Dokumenty mają silną spójność wewnętrznie
  • Okna kontekstowe Twojego LLM obsługują duże wejścia (32K+)
  • Odpowiedzi na zapytania wymagają zrozumienia długofalowych zależności
  • Pracujesz z dokumentami strukturalnymi (raporty, artykuły, książki)

Użyj Self-RAG, gdy:

  • Dokładność i zaufanie są krytyczne
  • Potrzebujesz zrozumiałych decyzji o przeszukiwaniu
  • Fałszywe pozytywy z nieistotnego przeszukiwania są drogie
  • Złożoność zapytań się różni szeroko (niektóre potrzebują przeszukiwania, inne nie)

Użyj GraphRAG, gdy:

  • Twoja dziedzina ma bogate relacje między obiektami
  • Zapytania obejmują wielokrotny przemyślenie
  • Relacje czasowe lub hierarchiczne mają znaczenie
  • Potrzebujesz zrozumienia połączeń między obiektami

Porównanie wskaźników wydajności

Wskaźnik Standardowy RAG LongRAG Self-RAG GraphRAG
Czas indeksowania 1x 0.8x 1.1x 3-5x
Opóźnienie zapytania 1x 2-3x 1.4x 1.5-2x
Użycie pamięci 1x 3-4x 1.2x 2-3x
Dokładność (QA) podstawowy +15-25% +20-30% +25-40%*
Interpretowalność Niski Średni Wysoki Wysoki

*Poprawki GraphRAG są bardzo zależne od dziedziny

Złożone podejścia

Najbardziej potężne systemy produkcyjne często łączą wiele technik:

LongRAG + GraphRAG: Użyj struktury grafu do identyfikacji istotnych klastrów dokumentów, a następnie odzyskaj pełne dokumenty zamiast fragmentów

Self-RAG + GraphRAG: Zastosuj mechanizmy refleksji do decyzji o przejściu po grafie (które ścieżki śledzić, kiedy zatrzymać rozwinięcie)

Trzyetapowy potok: Użyj GraphRAG do początkowego przeszukiwania opartego na obiektach → Self-RAG do filtrowania istotności → LongRAG do złożenia kontekstu

Rozważania implementacyjne

Modele zakodowania

Różne wersje RAG mają różne wymagania dotyczące zakodowania:

LongRAG: Potrzebuje zakodowań, które dobrze działają zarówno na poziomie dokumentu, jak i fragmentu. Rozważ modele wytrenowane z kontrastowym uczeniem na długich sekwencjach.

Self-RAG: Korzysta z zakodowań, które przechwytują subtelne znaczeniowe nuance dla szczegółowej oceny istotności.

GraphRAG: Wymaga zakodowań świadomych obiektów. Modele wytrenowane na zadaniach łączenia obiektów działają lepiej.

Wybór modelu zakodowania znacząco wpływa na wydajność. Pracując z lokalnymi modelami, narzędzia takie jak Ollama oferują prosty sposób eksperymentowania z różnymi modelami zakodowania przed przyjęciem decyzji wdrożeniowej.

Przeanalizowanie strategii podziału

Tradycyjne podziały stało się niewystarczające dla zaawansowanego RAG:

Podział semantyczny: Podział na naturalne granice (akapity, sekcje, zmiany tematów) Rekurencyjny podział: Tworzenie hierarchicznych fragmentów z relacjami rodzic-dziecko Okno przesuwne: Używanie nakładających się fragmentów, aby zachować kontekst na granicach Zachowanie struktury: Szacowanie struktury dokumentu (nagłówki markdown, znaczniki XML, bloki kodu)

Dla implementacji opartych na Pythonie, biblioteki takie jak LangChain i LlamaIndex oferują wbudowaną obsługę tych strategii podziału.

Wstępne ocenianie

Wstępne ocenianie znacząco poprawia jakość przeszukiwania we wszystkich wersjach RAG. Po początkowym przeszukiwaniu, specjalizowany model wstępnej oceny ponownie ocenia wyniki na podstawie cech interakcji zapytania-dokumentu. To daje znaczącą poprawę dokładności (10-20%) z minimalnym wpływem na opóźnienie, jeśli zostanie odpowiednio zintegrowane.

Skalowanie do środowiska produkcyjnego

Potok indeksowania:

  • Użyj przetwarzania rozproszonego (Ray, Dask) dla dużych korpusów dokumentów
  • Zaimplementuj indeksowanie inkrementalne dla aktualizacji w czasie rzeczywistym
  • Przechowuj zakodowania w zoptymalizowanych bazach danych wektorowych (Pinecone, Weaviate, Qdrant)

Optymalizacja zapytań:

  • Kachuj częste zapytania i ich wyniki
  • Zaimplementuj routing zapytań (różne wersje RAG dla różnych typów zapytań)
  • Użyj przybliżonego wyszukiwania najbliższego sąsiada dla skalowania subliniowego

Monitorowanie:

  • Śledź wyniki oceny istotności przeszukiwania
  • Monitoruj decyzje refleksji w Self-RAG
  • Mierzy ścieżki i głębokość przejścia po grafie
  • Loguj wyniki zaufania i feedback użytkownika

Zastosowania w praktyce

Przeszukiwanie dokumentacji technicznej

Duży dostawca chmury zaimplementował GraphRAG dla swojej dokumentacji:

  • Obiekty: Punkty końcowe API, parametry, kody błędów, nazwy usług
  • Relacje: Zależności, kompatybilność wersji, ścieżki migracji
  • Wynik: 35% zmniejszenie liczby zgłoszeń wsparcia, 45% szybszy czas rozwiązywania problemów

Odkrywanie prawnego

Firma technologiczna łączy Self-RAG z LongRAG:

  • Self-RAG filtrowa nieistotne dokumenty wczesnie
  • LongRAG zachowuje kontekst w zachowanych dokumentach
  • Prawnicy przeglądają 60% mniej fałszywych pozytywów
  • Zachowanie kontekstu poprawiło się z 71% do 94%

Przegląd literatury naukowej

Wyszukiwarka akademicka z hybrydowym podejściem:

  • GraphRAG identyfikuje sieci cytowania i społeczności badawcze
  • LongRAG odzyskuje pełne sekcje, zachowując kontekst metodologii
  • 40% poprawa w odnalezieniu istotnych artykułów
  • Zmniejszenie czasu przeglądu literatury z tygodni do dni

Zaawansowane tematy

RAG wieloczłonkowy

Rozszerzanie tych wersji na obsługę obrazów, tabel i kodu:

  • Założenie wizualne: Łączenie tekstowych obiektów z obrazami w dokumentach
  • Zrozumienie tabel: Parsowanie danych strukturalnych do formatu grafu
  • Analiza kodu: Budowanie grafów zależności z baz kodu

RAG adaptacyjny

Dynamiczne wybieranie strategii RAG na podstawie cech zapytania:

  • Klasyfikator złożoności zapytania
  • Detektor typu dokumentu
  • Optymalizator kosztów-zysków dla wyboru strategii

RAG z zachowaniem prywatności

Implementacja tych wersji z ograniczeniami prywatności:

  • Federacyjne przeszukiwanie między izolowanymi danymi
  • Różnica prywatności w zakodowaniach
  • Zaszyfrowane przeszukiwanie podobieństwa

Rozpoczęcie pracy

Szybki start z Pythonem

Dla tych, którzy chcą zaimplementować te techniki, rozpoczęcie od solidnej podstawy w Pythonie jest kluczowe. Bogata ekosystem Pythona dla uczenia maszynowego czyni z niego naturalny wybór do tworzenia systemów RAG.

Oto prosty punkt wyjścia do eksperymentowania:

# Instalacja zależności
# pip install sentence-transformers faiss-cpu langchain

from sentence_transformers import SentenceTransformer
import faiss
import numpy as np

# Podstawowa konfiguracja do eksperymentowania z długimi fragmentami
model = SentenceTransformer('all-MiniLM-L6-v2')

dokumenty = [
    # Twoje długie dokumenty tutaj
]

# Utworzenie wektorów
wektory = model.encode(dokumenty)

# Budowa indeksu FAISS
wymiar = wektory.shape[1]
indeks = faiss.IndexFlatL2(wymiar)
indeks.add(wektory.astype('float32'))

# Zapytanie
zapytanie = "Twoje pytanie tutaj"
wektor_zapytania = model.encode([zapytanie])
odległości, indeksy = indeks.search(
    wektor_zapytania.astype('float32'), k=3
)

Wybór frameworka

LangChain: Najlepszy do szybkiego prototypowania, szerokie integracje LlamaIndex: Optymalizowany do indeksowania i odzyskiwania dokumentów Haystack: Gotowy do produkcji, silne abstrakcje przepływów Własny: Gdy potrzebujesz pełnej kontroli i optymalizacji

Ramy oceny

Zaimplementuj rygorystyczną ocenę przed wdrożeniem w produkcji:

Metryki odzyskiwania:

  • Precision@K, Recall@K, MRR (Mean Reciprocal Rank)
  • NDCG (Normalized Discounted Cumulative Gain)

Metryki generowania:

  • ROUGE, BLEU do podobieństwa tekstu
  • BERTScore do podobieństwa semantycznego
  • Ocena ludzka do oceny jakości

Metryki end-to-end:

  • Stopień sukcesu zadania
  • Punkty oceny satysfakcji użytkownika
  • Percentyle opóźnień (p50, p95, p99)

Podsumowanie

Landscape systemów RAG dojrzał znacząco poza podstawowe wyszukiwanie podobieństwa wektorowego. LongRAG, Self-RAG i GraphRAG każde rozwiązuje konkretne ograniczenia tradycyjnych podejść:

LongRAG rozwiązuje problem fragmentacji kontekstu, przyjmując długie okna kontekstu i minimalne podziały. Jest to opcja pierwszego wyboru, gdy spójność dokumentów ma znaczenie, a masz zasoby obliczeniowe do obsługi dużych kontekstów.

Self-RAG dodaje krytyczną samoświadomość do systemów odzyskiwania. Poprzez refleksję nad własnymi decyzjami zmniejsza fałszywe pozytywy i poprawia wiarygodność — istotne w aplikacjach wysokiego ryzyka, gdzie dokładność ma większą wagę niż prędkość.

GraphRAG wypada z siły reprezentacji strukturalnej wiedzy. Gdy dziedzina obejmuje złożone relacje między jednostkami, odzyskiwanie oparte na grafach może odkrywać połączenia, które podobieństwo wektorowe całkowicie pomija.

Przyszłość RAG prawdopodobnie obejmie hybrydowe podejścia, łączące siły tych wariantów. System produkcyjny może wykorzystać GraphRAG do identyfikacji istotnych klastrów jednostek, Self-RAG do filtrowania i weryfikacji odzyskanych danych, a LongRAG do składania spójnego kontekstu dla modelu językowego.

Zarówno modele językowe, jak i okna kontekstu będą się rozwijać dalej, co będzie prowadzić do jeszcze bardziej zaawansowanych wariantów RAG. Kluczem jest zrozumienie konkretnych wymagań przypadku użycia — struktury dokumentów, wzorców zapytań, wymagań dokładności i ograniczeń obliczeniowych — i wyboru odpowiedniej techniki lub jej kombinacji.

Ekosystem narzędzi rozwija się bardzo szybko, a frameworki takie jak LangChain, LlamaIndex i Haystack zapewniają coraz bardziej zaawansowaną obsługę tych zaawansowanych wzorców. W połączeniu z potężnymi lokalnymi środowiskami uruchomieniowymi modeli językowych i modelami wektorów, nigdy nie było łatwiejsze eksperymentowanie i wdrażanie systemów RAG na poziomie produkcyjnym.

Zaczynaj od podstaw, rygorystycznie mierz wydajność i ewoluuj swoją architekturę w zależności od wymagań. Zaawansowane warianty RAG omówione tutaj dostarczają mapy drogowej dla tej ewolucji.

Przydatne linki

Zewnętrzne referencje