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

Samospójność: wiele ścieżek rozumowania

Lekcja 6 z 16 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Samospójność: wiele ścieżek rozumowania
  2. Problem, który to rozwiązuje
  3. Podstawowa implementacja
  4. Co mówi Ci głosowanie
  5. Wersja równoległa z asyncio
  6. Kiedy stosować samospójność
  7. Dostrajanie stosunku kosztu do niezawodności
  8. Kluczowe wnioski

Lekcja zaktualizowana 3 listopada 2026 r. na podstawie dokumentacji OpenAI: parametry temperature i top_p są akceptowane tylko przy wysiłku rozumowania (reasoning effort) ustawionym na none, podczas gdy modele GPT-5.6 domyślnie przeprowadzają rozumowanie (medium). Wywołania ustawiające te parametry muszą zatem określać reasoning={"effort": "none"} (Responses API) lub reasoning_effort="none" (Chat Completions). Źródła: Using GPT-6 · GPT-5.6 Terra.

Samospójność: wiele ścieżek rozumowania

Samospójność polega na generowaniu wielu niezależnych odpowiedzi na ten sam prompt, a następnie wybieraniu tej, która występuje najczęściej lub jest najbardziej spójna. Zasada jest prosta: głosowanie. Pojedyncze wywołanie naraża Cię na losowość złego trafienia, podczas gdy pięć wywołań daje rozkład, który możesz analizować. Technika ta znacząco poprawia niezawodność odpowiedzi, szczególnie w zadaniach wymagających rozumowania logicznego i obliczeń matematycznych.

Problem, który to rozwiązuje

LLM może za każdym razem podać inną odpowiedź, nawet przy identycznym prompcie. Niektóre z tych odpowiedzi są poprawne, inne nie, a nic w wyjściu nie sygnalizuje, którą właśnie czytasz: błędna odpowiedź jest stwierdzana z taką samą pewnością jak poprawna. Samospójność zamienia tę zmienność w Twoją zaletę. Jeśli model dochodzi do tego samego wniosku poprzez kilka różnych ścieżek rozumowania, wniosek ten jest prawdopodobnie poprawny; błąd z kolei rzadko powtarza się identycznie z jednego losowania na drugie, ponieważ zależy on właśnie od obranej ścieżki.

Podstawowa implementacja

Mechanizm składa się z trzech kroków: generuj, wyodrębnij końcową odpowiedź, głosuj. Znacznik >>> ANSWER: wymuszony w instrukcjach nie jest ozdobnikiem – to on sprawia, że wyjście można przetwarzać automatycznie bez konieczności interpretowania poprzedzającego je rozumowania. Bez tego kotwiczenia musiałbyś napisać kruchy heurystyk, aby zgadywać, gdzie kończy się refleksja, a zaczyna wniosek.

from openai import OpenAI
from collections import Counter

client = OpenAI()

def self_consistency(prompt: str, system: str = "",
                     n: int = 5, model: str = "gpt-5.6-terra") -> dict:
    """Generuje n odpowiedzi i zwraca tę najczęstszą."""
    responses = []

    for _ in range(n):
        response = client.responses.create(
            model=model,
            reasoning={"effort": "none"},  # temperature wymaga effort none
            instructions=system + "\nRozumuj krok po kroku, a następnie podaj "
                         "swoją końcową odpowiedź po '>>> ANSWER:'",
            input=prompt,
            temperature=0.7  # Temperature > 0 dla różnorodności
        )
        responses.append(response.output_text)

    # Wyodrębnij końcowe odpowiedzi
    answers = []
    for r in responses:
        if ">>> ANSWER:" in r:
            answer = r.split(">>> ANSWER:")[-1].strip()
            answers.append(answer)

    # Głosowanie większościowe
    if answers:
        counter = Counter(answers)
        best_answer, count = counter.most_common(1)[0]
        return {
            "answer": best_answer,
            "confidence": count / len(answers),
            "all_answers": dict(counter),
            "total_responses": len(answers)
        }
    return {"answer": None, "confidence": 0}

Co mówi Ci głosowanie

Zastosowane do klasyfikacji sentymentu, funkcja zwraca nie tylko etykietę, ale także rozkład, który często jest cenniejszy niż sama etykieta. Dla poniższej recenzji, która jest rzeczywiście niejednoznaczna – produkt jest w porządku, ale dostawa była katastrofalna – cztery wywołania głosują na „negatywny“, a trzy na „neutralny“. 57-procentowe pewność mówi Ci, że ten przypadek może zasługiwać na specjalne处理: skierowanie do przeglądu przez człowieka, poproszenie użytkownika o wyjaśnienia lub po prostu wykluczenie go ze statystyk zagregowanych. Pojedyncze wywołanie wyświetliłoby „negatywny“ bez niuansów i potraktowałbyś to zgłoszenie dokładnie tak samo jak recenzję pełną gniewu, co do której panuje jednomyślność.

system = """Jesteś klasyfikatorem sentymentu.
Przeanalizuj tekst i rozumuj krok po kroku.
Podaj swoją końcową odpowiedź po '>>> ANSWER:' wybierając spośród:
positive, negative, neutral"""

text = "Produkt jest w porządku, ale dostawa trwała 3 tygodnie."

result = self_consistency(text, system, n=7)
print(f"Sentyment: {result['answer']}")
print(f"Pewność: {result['confidence']:.0%}")
print(f"Rozkład: {result['all_answers']}")
# Przykładowe wyjście:
# Sentyment: negative
# Pewność: 57%
# Rozkład: {'negative': 4, 'neutral': 3}

Wersja równoległa z asyncio

Koszt tej techniki to nie tylko kwestia finansowa: pięć sekwencyjnych wywołań oznacza również pięciokrotnie większe opóźnienie, co wyklucza to podejście w każdym interfejsie, gdzie ktoś czeka przed ekranem. Tymczasem wywołania są całkowicie niezależne; nie ma żadnego uzasadnienia, aby czekać na nie jedno po drugim. asyncio.gather redukuje całkowity czas do czasu najwolniejszego wywołania, czyniąc samospójność kompatybilną z użytkowaniem online, gdzie narzut staje się czysto finansowy.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def self_consistency_async(prompt: str, system: str = "",
                                  n: int = 5) -> dict:
    """Asynchroniczna wersja samospójności."""

    async def single_call():
        response = await async_client.responses.create(
            model="gpt-5.6-terra",
            reasoning={"effort": "none"},  # temperature wymaga effort none
            instructions=system + "\nRozumuj, a następnie podaj odpowiedź "
                         "po '>>> ANSWER:'",
            input=prompt,
            temperature=0.7
        )
        return response.output_text

    # Uruchom wszystkie żądania równolegle
    tasks = [single_call() for _ in range(n)]
    results = await asyncio.gather(*tasks)

    # Wyodrębnij i głosuj
    answers = []
    for r in results:
        if ">>> ANSWER:" in r:
            answers.append(r.split(">>> ANSWER:")[-1].strip())

    counter = Counter(answers)
    best, count = counter.most_common(1)[0] if answers else (None, 0)

    return {
        "answer": best,
        "confidence": count / len(answers) if answers else 0,
        "distribution": dict(counter)
    }

Kiedy stosować samospójność

Kryterium decyzji jest proste do sformułowania: głosowanie ma sens tylko wtedy, gdy odpowiedź jest dyskretna i porównywalna. Dwa dobrze napisane podsumowania nie mogą być zliczane, ponieważ nigdy nie będą identyczne znak po znaku; dwie etykiety kategorii – już tak.

Przypadek użycia Przydatne? Dlaczego
Klasyfikacja Tak Odpowiedź dyskretna, proste głosowanie
Rozumowanie matematyczne Tak Wiele ścieżek prowadzących do poprawnej odpowiedzi
Wyodrębnianie encji Tak Konsensus dotyczący wykrytych encji
Pisanie kreatywne Nie Brak jednej „poprawnej“ odpowiedzi
Podsumowywanie tekstu Częściowo Przydatne dla kluczowych faktów, nie dla stylu

Dostrajanie stosunku kosztu do niezawodności

Trzy wywołania to minimalna liczba, aby głosowanie większościowe miało jakikolwiek sens; pięć oferuje najlepszy kompromis dla większości aplikacji; od siedmiu do jedenastu jest uzasadnione w przypadku decyzji krytycznych, gdzie błąd kosztuje znacznie więcej niż kilka dodatkowych wywołań. Jednak prawdziwa korzyść płynie z tego, jak wykorzystujesz wynik pewności, a nie z samej liczby próbek. Poniżej 60% uznaj, że nie ma konsensusu i eskaluj sprawę – either do operatora ludzkiego, albo do potężniejszego modelu z większą liczbą próbek, jak pokazano poniżej.

result = self_consistency(question, system, n=5)

if result["confidence"] < 0.6:
    # Brak wyraźnego konsensusu, eskalacja
    result = self_consistency(question, system, n=9, model="gpt-5.6-sol")

Pozostaje pytanie, czy gra warta jest świeczki w Twoim konkretnym przypadku, i trzeba to zmierzyć, a nie zakładać. Zaimplementuj wersję asynchroniczną, uruchom ją na tuzinie pytań dotyczących klasyfikacji sentymentu, dla których znasz oczekiwaną odpowiedź, a następnie porównaj dokładność uzyskaną przy pojedynczym wywołaniu z tą przy pięciu wywołaniach. Uzyskana liczba rozstrzygnie kwestię narzutu dla Twojego konkretnego przypadku – czego żadna ogólna rekomendacja nie jest w stanie dla Ciebie zrobić.

Kluczowe wnioski

  • Samospójność generuje wiele odpowiedzi i głosuje na najlepszą
  • Używaj temperatury > 0, aby osiągnąć różnorodność
  • Skuteczne w zadaniach z odpowiedzią dyskretną (klasyfikacja, obliczenia)
  • Bezcelowe w zadaniach kreatywnych bez jednej poprawnej odpowiedzi
  • Równolegluj wywołania za pomocą asyncio, aby ograniczyć opóźnienia