Zaawansowane RAG: wyjaśnienie LongRAG, Self-RAG i GraphRAG

LongRAG, Self-RAG, GraphRAG – techniki nowej generacji

Page content

Generowanie wspomagane wyszukiwaniem (RAG) ewoluowało znacznie dalej niż proste wyszukiwanie podobieństwa wektorowego. LongRAG, Self-RAG i GraphRAG reprezentują w tych możliwościach stan najnowocześniejszy.

Nowoczesne systemy RAG muszą obsługiwać ogromne dokumenty, rozumieć złożone relacje między encjami i wiele więcej.

a-pirate-captain Ta wspaniała ilustracja została wygenerowana przez model AI Flux 1 dev.

Ewolucja poza podstawowym RAG

Tradycyjne systemy RAG podążają za prostym wzorcem: dzielą dokumenty na fragmenty, zamieniają je na wektory, pobierają podobne fragmenty za pomocą podobieństwa kosinusowego i przekazują je do modelu LLM. Choć jest to skuteczne dla wielu przypadków użycia, to podejście napotyka trudności w trzech kluczowych scenariuszach:

Zrozumienie różnicy między wyszukiwaniem (search), wyszukiwaniem pogłębionym (deepsearch) i badaniami pogłębionymi (deep research) pomaga wyjaśnić, dlaczego zaawansowane warianty RAG są niezbędne do złożonych zadań wyszukiwania informacji. Aby głębiej zagłębić się w te koncepcje, zobacz Wyszukiwanie vs Deepsearch vs Deep Research.

  1. Zależności długoterminowe: Ważny kontekst może obejmować tysiące tokenów w wielu fragmentach
  2. Pewność wyszukiwania: System nie ma sposobu, aby ocenić, czy pobrana treść jest w rzeczywistości relewantna
  3. Złożoność relacji: Podobieństwo wektorowe nie może uchwycić skomplikowanych połączeń między encjami

Zaawansowane warianty RAG odpowiadają na te ograniczenia, stosując specjalne architektury dostosowane do konkretnych wyzwań.

LongRAG: Pokonywanie rozszerzonego kontekstu

Przegląd architektury

LongRAG fundamentalnie przeanalizuje strategię dzielenia na fragmenty, wykorzystując modele LLM z rozszerzonymi oknami kontekstu (32K, 100K, a nawet 1M tokenów). Zamiast dzielić dokumenty na małe fragmenty 512-tokenowe, LongRAG stosuje podejście hierarchiczne:

Wektoryzacja na poziomie dokumentu: Cały dokument (lub bardzo duże sekcje) jest przetwarzany jako pojedyncza jednostka. Wektor na poziomie dokumentu uchwycia ogólny znaczeniowy sens, zachowując jednocześnie pełny tekst do dalszego przetwarzania.

Minimalna fragmentacja: Kiedy dzielenie jest konieczne, LongRAG używa znacznie większych fragmentów (4K-8K tokenów) z istotnym nakładaniem się (20-30%). To zachowuje spójność narracji i redukuje fragmentację kontekstu.

Złożenie kontekstu: W momencie wyszukiwania LongRAG zwraca kompletne dokumenty lub duże spójne sekcje, a nie rozproszone fragmenty. Model LLM otrzymuje ciągły kontekst, który zachowuje relacje strukturalne i znaczeniowe.

Strategia implementacji

Oto koncepcyjna implementacja używająca Pythona i nowoczesnych modeli wektoryzujących:

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]:
        """Create overlapping large chunks"""
        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):
        """Index document with hierarchical embedding"""
        # Embed entire document
        doc_embedding = self.model.embed(doc)
        
        # Create large chunks with overlap
        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]:
        """Retrieve relevant long-form content"""
        query_embedding = self.model.embed(query)
        
        # Score at document level first
        doc_scores = [
            np.dot(query_embedding, doc['doc_embedding'])
            for doc in self.doc_embeddings
        ]
        
        # Get top documents
        top_doc_indices = np.argsort(doc_scores)[-top_k:][::-1]
        
        results = []
        for idx in top_doc_indices:
            doc_data = self.doc_embeddings[idx]
            
            # For each document, find best chunks
            chunk_scores = [
                np.dot(query_embedding, emb)
                for emb in doc_data['chunk_embeddings']
            ]
            best_chunk_idx = np.argmax(chunk_scores)
            
            # Return extended context around best chunk
            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]:
        """Get extended context around relevant chunk"""
        start = max(0, center_idx - 1)
        end = min(len(chunks), center_idx + 2)
        return chunks[start:end]

Przypadki użycia i wydajność

LongRAG wyróżnia się w scenariuszach, w których kontekst ma znaczenie:

  • Analiza dokumentów prawnych: Umowy i skargi prawne często mają zależności rozciągające się przez dziesiątki stron
  • Wyszukiwanie w artykułach naukowych: Zrozumienie metodyki wymaga spójnych sekcji, a nie izolowanych akapitów
  • Repozytoria kodu: Funkcje i klasy muszą być rozumiane w kontekście ich modułu

Charakterystyki wydajności:

  • Opóźnienia: Wyższe z powodu przetwarzania dużych fragmentów (2-5 razy wolniej niż standardowe RAG)
  • Dokładność: Ulepszenie o 15-25% w testach pytań i odpowiedzi dla treści długich
  • Pamięć: Wymaga 3-4 razy więcej pamięci dla okien kontekstu

Self-RAG: Refleksywne wyszukiwanie

Zasady podstawowe

Self-RAG wprowadza warstwę metapoznańową do systemów RAG. Zamiast ślepo wyszukiwać i generować, system aktywnie refleksuje nad własnymi procesami za pomocą specjalnych tokenów refleksji. Ta sama samo-refleksyjna, iteracyjna idea wyszukiwania pojawia się na poziomie aplikacji w systemach Deep Research hostowanych samodzielnie — zobacz Systemy Self-Hosted Deep Research: 12 narzędzi porównanych aby zobaczyć, jak narzędzia takie jak Local Deep Research i lukeswade/deep-research oceniają własne luki dowodowe i decydują, co dalej przeszukiwać:

Token Wyszukiwania: Decyduje, czy wyszukiwanie jest niezbędne dla danego zapytania Token Relewantności: Ocenia, czy pobrane dokumenty są w rzeczywistości relewantne Token Wsparcia: Sprawdza, czy wygenerowana odpowiedź jest wspierana przez pobraną treść Token Krytyki: Ocenia ogólną jakość wygenerowanej odpowiedzi

Składniki architektury

Architektura Self-RAG składa się z trzech naprzemienne 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):
        """Generate answer with self-reflection"""
        
        # Phase 1: Decide if retrieval needed
        retrieve_decision = self.critic.should_retrieve(query)
        
        if not retrieve_decision:
            # Direct generation without retrieval
            return self.generator.generate(query)
        
        # Phase 2: Retrieve and evaluate relevance
        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:  # Threshold
                relevant_docs.append(doc)
        
        if not relevant_docs:
            # Fallback to generation without retrieval
            return self.generator.generate(query)
        
        # Phase 3: Generate and verify support
        best_answer = None
        best_score = -1
        
        for _ in range(max_iterations):
            # Generate candidate answer
            answer = self.generator.generate(
                query, context=relevant_docs
            )
            
            # Evaluate support and quality
            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
            
            # Early stopping if high quality achieved
            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
            }
        }

Szkolenie mechanizmów refleksji

Self-RAG wymaga szkolenia komponentu krytyka, aby dokonywał wiarygodnych ocen. Typowo obejmuje to:

  1. Fine-tuning nadzorowany na zbiorach danych oznakowanych ocenami relewantności
  2. Nauka z wzmacnianiem z nagrodami za dokładne przewidywania
  3. Nauka kontrastowa do rozróżniania twierdzeń wspieranych i niewspieranych

Tokeny refleksji mogą być zaimplementowane jako:

  • Specjalne tokeny w słowniku (jak [RETRIEVE], [RELEVANT])
  • Osobne warstwy klasyfikatora na modelu
  • Zewnętrzne modele krytyka (podejście ensemble)

Rozważania produkcyjne

Przy wdrażaniu Self-RAG w systemach produkcyjnych:

Kompromisy opóźnień: Każdy krok refleksji dodaje 20-40% overheadu inferencji. Wyważaj szczegółowość z wymaganiami czasu odpowiedzi.

Próg pewności: Dostosuj progi refleksji na podstawie przypadku użycia. Aplikacje prawne lub medyczne wymagają wyższej pewności niż ogólne chatboty.

Monitoring: Śledź decyzje refleksji, aby identyfikować wzorce. Jeśli wyszukiwanie jest rzadko potrzebne, można by odnieść korzyść z prostszej architektury.

GraphRAG: Wyszukiwanie wzmocnione grafem wiedzy

Podłoże koncepcyjne

GraphRAG transformuje problem wyszukiwania z podobieństwa wektorowego na przejścia grafowe. Zamiast szukać semantycznie podobnych fragmentów tekstu, GraphRAG identyfikuje relewantne podgrafy połączonych encji i relacji.

Ekstrakcja encji: Identyfikacja nazwanych encji, koncepcji i ich typów Mapowanie relacji: Ekstrakcja relacji między encjami (temporalnych, przyczynowych, hierarchicznych) Budowa grafu: Budowanie grafu wiedzy z encjami jako węzłami i relacjami jako krawędziami Wyszukiwanie podgrafu: Na podstawie zapytania, odnalezienie relewantnych połączonych podgrafów

Linia budowy grafu

Budowanie grafu wiedzy z niestrukturowanego tekstu 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]):
        """Build knowledge graph from documents"""
        for doc in documents:
            # Extract entities
            entities = self.entity_extractor.extract(doc)
            
            # Add entities as nodes
            for entity in entities:
                self.graph.add_node(
                    entity['text'],
                    entity_type=entity['type'],
                    context=entity['surrounding_text']
                )
            
            # Extract relationships
            relations = self.relation_extractor.extract(
                doc, entities
            )
            
            # Add relationships as edges
            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):
        """Add derived relationships and metadata"""
        # Compute node importance (PageRank, etc.)
        self.graph.compute_centrality()
        
        # Identify communities/clusters
        self.graph.detect_communities()
        
        # Add temporal ordering if timestamps available
        self.graph.add_temporal_edges()

Przetwarzanie zapytań z grafami

Zapytania GraphRAG obejmują rozumowanie wielokrokowe na grafie 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):
        """Retrieve relevant subgraph for query"""
        
        # Identify seed entities in query
        query_entities = self.entity_extractor.extract(query)
        
        # Find matching nodes in graph
        seed_nodes = []
        for entity in query_entities:
            matches = self.graph.find_similar_nodes(
                entity['text'],
                similarity_threshold=0.85
            )
            seed_nodes.extend(matches)
        
        # Expand subgraph via traversal
        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
            )
        
        # Rank nodes by relevance
        ranked_nodes = self._rank_subgraph_nodes(
            subgraph, query
        )
        
        # Extract and format context
        context = self._format_graph_context(
            ranked_nodes[:max_nodes],
            subgraph
        )
        
        return context
    
    def _expand_from_node(self, node, subgraph, visited,
                         current_hop, max_hops):
        """Recursively expand subgraph"""
        if current_hop >= max_hops or node in visited:
            return
        
        visited.add(node)
        subgraph.add_node(node)
        
        # Get neighbors
        neighbors = self.graph.get_neighbors(node)
        
        for neighbor, edge_data in neighbors:
            # Add edge to subgraph
            subgraph.add_edge(node, neighbor, edge_data)
            
            # Recursively expand
            self._expand_from_node(
                neighbor,
                subgraph,
                visited,
                current_hop + 1,
                max_hops
            )
    
    def _format_graph_context(self, nodes, subgraph):
        """Convert subgraph to textual context"""
        context_parts = []
        
        for node in nodes:
            # Add node context
            context_parts.append(f"Entity: {node.text}")
            context_parts.append(f"Type: {node.entity_type}")
            
            # Add relationship information
            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 Microsoft

GraphRAG Microsoft przyjmuje unikalne podejście, generując podsumowania społeczności:

  1. Budowa początkowego grafu z dokumentów, używając ekstrakcji encji/relacji opartej na LLM
  2. Wykrywanie społeczności używając algorytmu Leiden lub podobnego
  3. Generowanie podsumowań dla każdej społeczności za pomocą LLM
  4. Struktura hierarchiczna: Budowanie wielu poziomów abstrakcji społeczności
  5. W momencie zapytania: Wyszukiwanie relewantnych społeczności i przejście do konkretnych encji

To podejście jest szczególnie skuteczne dla:

  • Zapytań eksploracyjnych („Jakie są główne tematy w tym korpusie?")
  • Wnioskowania wielokrokowego („Jak A jest połączone z C przez B?")
  • Analizy temporalnej („Jak relacje tej encji ewoluowały?")

Analiza porównawcza

Kiedy używać każdego wariantu

Użyj LongRAG, gdy:

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

Użyj Self-RAG, gdy:

  • Dokładność i wiarygodność są krytyczne
  • Potrzebujesz wyjaśnialnych decyzji wyszukiwania
  • Fałszywe pozytywy z nierelewantnego wyszukiwania są kosztowne
  • Złożoność zapytań szeroko się zmienia (niektóre wymagają wyszukiwania, inne nie)

Użyj GraphRAG, gdy:

  • Twoja dziedzina ma bogate relacje między encjami
  • Zapytania obejmują wnioskowanie wielokrokowe
  • Relacje temporalne lub hierarchiczne są ważne
  • Musisz rozumieć połączenia między encjami

Porównanie metryk wydajności

Metryka Standardowe 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) bazowo +15-25% +20-30% +25-40%*
Interprytowalność Niska Średnia Wysoka Wysoka

*Ulepszenia GraphRAG są silnie zależne od dziedziny

Podejścia hybrydowe

Najsilniejsze systemy produkcyjne często łączą wiele technik:

LongRAG + GraphRAG: Użyj struktury grafu, aby zidentyfikować relewantne klastry dokumentów, a następnie pobierz pełne dokumenty zamiast fragmentów

Self-RAG + GraphRAG: Zastosuj mechanizmy refleksji do decyzji przejścia grafowego (które ścieżki podążyć, kiedy zakończyć ekspansję)

Trójfazowa linia przetwarzania: Użyj GraphRAG do początkowego wyszukiwania opartego na encjach → Self-RAG do filtrowania relewantności → LongRAG do złożenia kontekstu

Rozważania implementacyjne

Modele wektoryzujące

Różne warianty RAG mają różne wymagania dotyczące wektoryzacji:

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

Self-RAG: Korzysta z wektoryzacji, które uchwycają semantyczne niuanse do precyzyjnej oceny relewantności.

GraphRAG: Wymaga wektoryzacji świadomych encji. Modele fine-tuned na zadaniach łączenia encji działają lepiej.

Wybór modelu wektoryzującego znacząco wpływa na wydajność. Przy pracy z modelami lokalnymi, narzędzia takie jak Ollama zapewniają prosty sposób, aby eksperymentować z różnymi modelami wektoryzującymi przed zobowiązaniem się do wdrożenia produkcyjnego.

Strategie fragmentacji w odniesieniu ponownym

Tradycyjne fragmentowanie o stałym rozmiarze jest niewystarczające dla zaawansowanego RAG:

Semantyczne fragmentowanie: Dziel w naturalnych granicach (akapity, sekcje, zmiany tematu) Rekurencyjne fragmentowanie: Twórz hierarchiczne fragmenty z relacjami rodzic-dziecko Okno ślizgowe: Używaj nakładających się fragmentów, aby zachować kontekst na granicach Świadome struktury: Poszanuj strukturę dokumentu (nagłówki markdown, znaczniki XML, bloki kodu)

Dla implementacji opartych na Pythonie, biblioteki takie jak LangChain i LlamaIndex zapewniają wbudowane wsparcie dla tych strategii fragmentacji.

Integracja rerankingu

Reranking dramatycznie poprawia jakość wyszukiwania we wszystkich wariantach RAG. Po początkowym wyszukiwaniu, specjalny model rerankingu przelicza wyniki na podstawie cech interakcji zapytanie-dokument. To zapewnia znaczącą poprawę dokładności (10-20%) z minimalnym wpływem na opóźnienie, gdy jest zintegrowany przemyślanie.

Skalowanie do produkcji

Linia indeksowania:

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

Optymalizacja zapytań:

  • Cache’uj częste zapytania i ich wyniki
  • Zaimplementuj routowanie zapytań (różne warianty RAG dla różnych typów zapytań)
  • Użyj przybliżonego wyszukiwania najbliższego sąsiada dla skalowania niespodziewanego

Monitoring:

  • Śledź wyniki relewantności wyszukiwania
  • Monitoruj decyzje refleksji w Self-RAG
  • Mierz ścieżki i głębokość przejścia grafu
  • Rejestruj wyniki pewności i informację zwrotną od użytkowników

Aplikacje w świecie rzeczywistym

Wyszukiwanie w dokumentacji technicznej

Duży dostawca chmurowy wdrożył GraphRAG dla swojej dokumentacji:

  • Encje: końce API, parametry, kody błędów, nazwy usług
  • Relacje: zależności, kompatybilności wersji, ścieżki migracji
  • Wynik: 35% redukcja biletów wsparcia, 45% szybszy czas rozwiązania

Firma technologiczna prawnicza połączyła Self-RAG z LongRAG:

  • Self-RAG filtruje nierelewantne dokumenty na wczesnym etapie
  • LongRAG zachowuje kontekst w zachowanych dokumentach
  • Prawnicy przeglądają o 60% mniej fałszywych pozytywów
  • Zachowanie krytycznego kontekstu poprawiło się z 71% do 94%

Przegląd literatury naukowej

Silnik wyszukiwania akademicki używający podejścia hybrydowego:

  • GraphRAG identyfikuje sieci cytatów i społeczności badawcze
  • LongRAG pobiera pełne sekcje, zachowując kontekst metodyki
  • 40% poprawa w odkryciu relewantnych artykułów
  • Redukcja czasu przeglądu literatury z tygodni do dni

Zaawansowane tematy

RAG wielomodalny

Rozszerzenie tych wariantów, aby obsługiwać obrazy, tabele i kod:

  • Zacumowanie wizualne: Łączenie encji tekstowych z obrazami w dokumentach
  • Rozumienie tabeli: Parsowanie danych strukturalnych do formatu grafu
  • Analiza kodu: Budowanie grafów zależności z baz kodu

Adaptacyjny RAG

Dynamiczny wybór strategii RAG na podstawie charakterystyk zapytania:

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

Prywatnościowy RAG

Wdrażanie tych wariantów z ograniczeniami prywatności:

  • Federated retrieval w silosach danych
  • Prywatność różnicowa w wektorach
  • Szukanie podobieństwa szyfrowanego

Rozpoczęcie

Szybki start z Pythonem

Dla tych, którzy chcą wdrożyć te techniki, rozpoczęcie od solidnej podstawy Pythona jest niezbędne. Bogaty ekosystem Pythona dla machine learning sprawia, że jest to naturalny wybór dla rozwoju RAG.

Oto prosty punkt startowy do eksperymentów:

# Install dependencies
# pip install sentence-transformers faiss-cpu langchain

from sentence_transformers import SentenceTransformer
import faiss
import numpy as np

# Basic setup for experimenting with long chunks
model = SentenceTransformer('all-MiniLM-L6-v2')

documents = [
    # Your long-form documents here
]

# Create embeddings
embeddings = model.encode(documents)

# Build FAISS index
dimension = embeddings.shape[1]
index = faiss.IndexFlatL2(dimension)
index.add(embeddings.astype('float32'))

# Query
query = "Your question here"
query_embedding = model.encode([query])
distances, indices = index.search(
    query_embedding.astype('float32'), k=3
)

Wybór frameworka

LangChain: Najlepszy do szybkiego prototypowania, rozbudowane integracje LlamaIndex: Zoptymalizowany dla indeksowania i wyszukiwania dokumentów Haystack: Gotowy do produkcji, silne abstrakcje linii przetwarzania Custom: Kiedy potrzebujesz pełnej kontroli i optymalizacji

Framework oceny

Zaimplementuj rygorystyczną ocenę przed wdrożeniem produkcyjnym:

Metryki wyszukiwania:

  • Precision@K, Recall@K, MRR (Średnia Wzajemna Ranga)
  • NDCG (Znormalizowany Dyskontowany Skumulowany Zysk)

Metryki generowania:

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

Metryki end-to-end:

  • Skuteczność zadania
  • Wyniki satysfakcji użytkownika
  • Percentylne opóźnienia (p50, p95, p99)

Wniosek

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

LongRAG rozwiązuje problem fragmentacji kontekstu, przytulając rozszerzone okna kontekstu i minimalną fragmentację. To jest wybór do zastosowania, gdy spójność dokumentu ma znaczenie i masz zasoby obliczeniowe, aby obsługiwać duże konteksty.

Self-RAG dodaje krytyczną samoświadomość do systemów wyszukiwania. Przez refleksję nad własnymi decyzjami, redukuje fałszywe pozytywy i poprawia wiarygodność — niezbędne dla aplikacji o wysokich stawce, gdzie dokładność jest ważniejsza niż szybkość.

GraphRAG odblokowuje moc strukturalnej reprezentacji wiedzy. Kiedy Twoja dziedzina obejmuje złożone relacje między encjami, wyszukiwanie oparte na grafie może uwidocznić połączenia, które podobieństwo wektorowe całkowicie przegapia. Głębsze pytanie o to, jak strukturyzować wiedzę, zanim zostanie pobrana — i dlaczego reprezentacja jest tak ważna jak wyszukiwanie — jest zbadane w Wyszukiwanie vs Reprezentacja w Systemach Wiedzy.

Przyszłość RAG prawdopodobnie obejmuje podejścia hybrydowe, które łączą mocne strony tych wariantów. System produkcyjny mógłby użyć GraphRAG do identyfikacji relewantnych klastrów encji, Self-RAG do filtrowania i weryfikacji wyszukiwań, a LongRAG do złożenia spójnego kontekstu dla LLM.

W miarę dalszej poprawy LLM i rozszerzania okien kontekstu, zobaczymy jeszcze bardziej zaawansowane warianty RAG. Kluczem jest zrozumienie specyficznych wymagań Twojego przypadku użycia — struktury dokumentów, wzorców zapytań, wymagań dokładności i ograniczeń obliczeniowych — oraz wybranie odpowiedniej techniki lub jej kombinacji.

Ekosystem narzędzi dojrza bardzo szybko, z frameworkami takimi jak LangChain, LlamaIndex i Haystack, zapewniającymi coraz bardziej wyrafinowane wsparcie dla tych zaawansowanych wzorców. Połączone z potężnymi lokalnymi runtime’ami LLM i modelami wektoryzującymi, nigdy nie było łatwiej eksperymentować i wdrażać systemy RAG o jakości produkcyjnej.

Rozpocznij od podstaw, mierz wydajność rygorystycznie i ewoluuj swoją architekturę, gdy wymagają tego potrzeby. Zaawansowane warianty RAG omówione tutaj zapewniają mapę drogi dla tej ewolucji.

Przydatne linki

Zewnętrzne referencje

Subskrybuj

Otrzymuj nowe wpisy o systemach, infrastrukturze i inżynierii AI.