Przejdź do głównej treści
Polski— Wybierz język
Menu

Zaawansowany RAG: Multi-Query, HyDE, Step-Back

Lekcja 14 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Cele
  2. Problem: Jedno zapytanie to za mało
  3. Multi-Query: Zadaj pytanie inaczej
  4. HyDE: Hipotetyczne embeddingi dokumentów
  5. Promptowanie Step-Back
  6. Porównanie technik
  7. Łączenie technik
  8. Kluczowe wnioski

Cele

  • Usprawnienie wyszukiwania dzięki zaawansowanym technikom
  • Wdrożenie promptów typu multi-query, HyDE i step-back
  • Zrozumienie, kiedy stosować każdą z tych technik

Problem: Jedno zapytanie to za mało

Ponowne rangowanie (reranking) z poprzedniej lekcji poprawiło sposób sortowania kandydatów, ale nie pomogło w przypadku dokumentów, których wyszukiwarka w ogóle nie znalazła. Najczęstszą przyczyną takich przeoczeń nie jest model ani indeks, lecz samo zapytanie. Użytkownik może wpisać „to nie działa na moim telefonie“, podczas gdy dokumentacja mówi o „niezgodności z wersjami Androida wcześniejszymi niż 12“. Żaden model embeddingów spontanicznie nie zbliży do siebie tych dwóch sformułowań.

Poniższe techniki łączy jedna zasada: zamiast przyjmować zapytanie w takiej formie, w jakiej zostało zadane, przekształcamy je lub mnożymy przed rozpoczęciem wyszukiwania. Wszystkie wpływają na recall, czyli zdolność do umieszczenia właściwego dokumentu na liście kandydatów.

Multi-Query: Zadaj pytanie inaczej

Pierwsze podejście jest najbardziej bezpośrednie. Prosimy LLM o przeformułowanie pytania z kilku różnych perspektyw, uruchamiamy wyszukiwanie dla każdej wersji i scalamy wyniki. Pytanie „jak anulować subskrypcję?“ staje się również „procedura anulowania“, „zatrzymanie miesięcznego obciążenia“ i „usunięcie płatnego konta“ – trzy różne słownictwa, trzy szanse na trafienie w frazeologię użytą przez autora dokumentacji.

Warto zwrócić uwagę na etap scalania: linia z np.maximum zachowuje dla każdego dokumentu najlepszy wynik osiągnięty we wszystkich zapytaniach. Dokument, który dobrze pasuje tylko do jednego przeformułowania, i tak awansuje na szczyt listy, co nie miałoby miejsca przy uśrednianiu wyników. Temperatura na poziomie 0,7 jest tutaj celowa, ponieważ zależy nam na różnorodności, a nie na powtarzalności.

from openai import OpenAI
import numpy as np

client = OpenAI()

def generer_multi_queries(question: str, n: int = 3) -> list[str]:
    """Generate n rephrasings of the question."""
    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"Generate {n} different rephrasings of this question "
                f"for document search. Each rephrasing "
                f"should cover a different angle.\n\n"
                f"Original question: {question}\n\n"
                f"Return only the rephrasings, one per line."
            )
        }],
        temperature=0.7
    )
    queries = response.choices[0].message.content.strip().split("\n")
    return [q.strip().lstrip("0123456789.-) ") for q in queries if q.strip()]

def recherche_multi_query(
    question: str,
    corpus_embeddings: np.ndarray,
    documents: list[dict],
    k: int = 5,
    n_queries: int = 3
) -> list[dict]:
    """Search with multiple rephrasings."""
    queries = [question] + generer_multi_queries(question, n_queries)
    print(f"Queries: {queries}")

    tous_scores = np.zeros(len(documents))
    for query in queries:
        query_emb = client.embeddings.create(
            input=query, model="text-embedding-3-large"
        ).data[0].embedding
        scores = corpus_embeddings @ np.array(query_emb)
        tous_scores = np.maximum(tous_scores, scores)

    top_k = np.argsort(tous_scores)[-k:][::-1]
    return [
        {**documents[i], "score": float(tous_scores[i])}
        for i in top_k
    ]

HyDE: Hipotetyczne embeddingi dokumentów

HyDE rozwiązuje problem z drugiej strony. Zamiast mnożyć pytania, prosimy model o wygenerowanie prawdopodobnej odpowiedzi – nawet jeśli jest częściowo błędna, to nie ma znaczenia – a następnie wyszukujemy dokumenty zbliżone do tej odpowiedzi. Pytanie „jak skonfigurować SSO?“ generuje akapit mówiący o dostawcach tożsamości, SAML i metadanych, czyli dokładnie to słownictwo, które znajduje się w rzeczywistej dokumentacji.

def recherche_hyde(
    question: str,
    corpus_embeddings: np.ndarray,
    documents: list[dict],
    k: int = 5
) -> list[dict]:
    """Search with a hypothetical document (HyDE)."""
    # 1. Generate a hypothetical document
    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"Write a short paragraph (3-5 sentences) that would answer "
                f"this question. Write as if it were an excerpt "
                f"from technical documentation.\n\n"
                f"Question: {question}"
            )
        }],
        temperature=0.3
    )
    doc_hypothetique = response.choices[0].message.content

    # 2. Encode the hypothetical document
    hyde_emb = client.embeddings.create(
        input=doc_hypothetique,
        model="text-embedding-3-large"
    ).data[0].embedding

    # 3. Search for similar documents
    scores = corpus_embeddings @ np.array(hyde_emb)
    top_k = np.argsort(scores)[-k:][::-1]

    return [
        {**documents[i], "score": float(scores[i])}
        for i in top_k
    ]

Technika ta działa, ponieważ embedding odpowiedzi jest bardziej podobny do embeddingu dokumentu niż embedding pytania. Pytanie jest krótkie, interrogatywne i często sformułowane własnymi słowami użytkownika; dokument jest długi, afirmatywny i napisany żargonem branżowym. HyDE niweluje tę lukę między zapytaniem a dokumentem, przenosząc zapytanie na grunt korpusu. Dlatego też prompt zawiera instrukcję „napisz tak, jakby był to fragment dokumentacji technicznej“: naśladujemy docelowy rejestr.

Promptowanie Step-Back

Trzecia technika radzi sobie z przypadkiem odwrotnym: pytaniami tak szczegółowymi, że żaden dokument nie odpowiada na nie wprost. „Czy mogę odliczyć rower elektryczny zakupiony w lutym?“ nie pojawia się nigdzie, ale sekcja dotycząca odliczalnych kosztów firmowych już tak. Prosimy więc model o ogólne pytanie kryjące się za tym szczegółowym, a następnie wyszukujemy, używając obu, ważąc je odpowiednio 0,7 dla oryginalnego pytania i 0,3 dla szerszego – szeroki kontekst pomaga, ale nie powinien dominować.

def recherche_step_back(
    question: str,
    corpus_embeddings: np.ndarray,
    documents: list[dict],
    k: int = 5
) -> list[dict]:
    """Two-pass search: general then specific."""
    # 1. Generate a step-back question
    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"What is the more general question or underlying concept "
                f"behind this specific question?\n\n"
                f"Specific question: {question}\n\n"
                f"Return only the general question."
            )
        }],
        temperature=0.3
    )
    question_generale = response.choices[0].message.content.strip()

    # 2. Search with both questions
    resultats_combines = {}

    for q, poids in [(question, 0.7), (question_generale, 0.3)]:
        q_emb = client.embeddings.create(
            input=q, model="text-embedding-3-large"
        ).data[0].embedding
        scores = corpus_embeddings @ np.array(q_emb)

        for i, s in enumerate(scores):
            if i not in resultats_combines:
                resultats_combines[i] = 0.0
            resultats_combines[i] += float(s) * poids

    top_k = sorted(
        resultats_combines.items(),
        key=lambda x: x[1], reverse=True
    )[:k]

    return [
        {**documents[idx], "score": score}
        for idx, score in top_k
    ]

Porównanie technik

Każda z nich rozwiązuje specyficzną patologię wyszukiwania i każda wiąże się z kosztem dodatkowych wywołań, a co za tym idzie – większym opóźnieniem.

TechnikaKiedy stosowaćDodatkowy koszt
Multi-queryZapytania niejednoznaczne, zróżnicowane słownictwon wywołań embeddingów + 1 wywołanie LLM
HyDELuka między zapytaniem a dokumentem, domeny techniczne1 wywołanie LLM + 1 wywołanie embeddingu
Step-backBardzo szczegółowe pytania, potrzeba kontekstu1 wywołanie LLM + 2 wywołania embeddingów

Łączenie technik

Nie musisz wybierać tylko jednej. Poniższa funkcja przyjmuje listę strategii, akumulując wyniki generowane przez każdą z nich w słowniku indeksowanym przez dokument, i zachowuje maksimum. Dokument znaleziony tylko przez HyDE zostaje więc uszeregowany obok dokumentu znalezionego w wyszukiwaniu bezpośrednim. Pamiętaj jednak, że połączenie trzech strategii potraja budżet i wydłuża czas odpowiedzi: zarezerwuj tę kombinację dla trudnych zapytań lub dla przetwarzania offline, gdzie opóźnienie nie ma znaczenia.

def recherche_avancee(
    question: str,
    corpus_embeddings: np.ndarray,
    documents: list[dict],
    k: int = 5,
    strategies: list[str] = ["direct", "multi_query", "hyde"]
) -> list[dict]:
    """Combine multiple search strategies."""
    tous_resultats = {}

    if "direct" in strategies:
        q_emb = client.embeddings.create(
            input=question, model="text-embedding-3-large"
        ).data[0].embedding
        scores = corpus_embeddings @ np.array(q_emb)
        for i, s in enumerate(scores):
            tous_resultats.setdefault(i, []).append(float(s))

    if "hyde" in strategies:
        res_hyde = recherche_hyde(
            question, corpus_embeddings, documents, k=k*2
        )
        for r in res_hyde:
            tous_resultats.setdefault(r["id"], []).append(r["score"])

    # Final score = max of scores
    scores_finaux = {
        idx: max(scores) for idx, scores in tous_resultats.items()
    }

    top_k = sorted(
        scores_finaux.items(), key=lambda x: x[1], reverse=True
    )[:k]

    return [
        {**documents[idx], "score": score}
        for idx, score in top_k
    ]

Kluczowe wnioski

  • Multi-query przeformułowuje pytanie z wielu perspektyw, aby objąć szersze słownictwo
  • HyDE generuje hipotetyczną odpowiedź, która bardziej przypomina dokumenty docelowe
  • Step-back zadaje bardziej ogólne pytanie, aby uchwycić szeroki kontekst
  • Techniki te wprowadzają opóźnienia, ale znacząco poprawiają recall