Премини към основното съдържание
Български— Изберете език
Меню

Самосъгласуваност: множество пътища на разсъждение

Урок 6 от 16 Обновен 3 ноември 2026 г. Програмист
На тази страница
  1. Самосъгласуваност: множество пътища на разсъждение
  2. Проблемът, който решава
  3. Основна реализация
  4. Какво Ви казва гласуването
  5. Паралелна версия с asyncio
  6. Кога да използвате самосъгласуваност
  7. Настройване на съотношението разходи/надеждност
  8. Ключови изводи

Урокът е актуализиран на 3 ноември 2026 г. въз основа на документацията на OpenAI: параметрите temperature и top_p се приемат само при усилие за разсъждение (reasoning effort) със стойност none, докато моделите от серията GPT-5.6 разсъждават по подразбиране (medium). Следователно заявките, които задават тези параметри, трябва изрично да включват reasoning={"effort": "none"} (Responses API) или reasoning_effort="none" (Chat Completions). Източници: Използване на GPT-6 · GPT-5.6 Terra.

Самосъгласуваност: множество пътища на разсъждение

Самосъгласуваността (Self-consistency) включва генерирането на множество независими отговори на един и същ промпт, след което се избира най-честият или най-последователният от тях. Принципът е гласуване: едно единствено извикване Ви излага на риска от лош случаен избор, докато пет извиквания Ви предоставят разпределение, което можете да анализирате. Тази техника значително подобрява надеждността на отговорите, особено при задачи за логическо разсъждение и математически изчисления.

Проблемът, който решава

Един езиков модел (LLM) може да даде различен отговор при всяко извикване, дори при напълно идентичен промпт. Някои от тези отговори са верни, други – не, и нищо в изхода не сигнализира кой точно четете: грешният отговор се твърди със същата увереност като верния. Самосъгласуваността превръща тази вариативност във Ваше предимство. Ако моделът стигне до едно и също заключение чрез няколко различни пътя на разсъждение, това заключение вероятно е вярно; напротив, една грешка рядко се възпроизвежда идентично от един опит до друг, тъй като тя зависи точно от избрания път на разсъждение.

Основна реализация

Механизмът има три стъпки: генериране, извличане на крайния отговор и гласуване. Маркерът >>> ANSWER:, наложен в инструкциите, не е козметичен – той е това, което прави изхода подлежащ на автоматичен анализ (parsing), без да се налага да интерпретирате разсъжденията, които му предхождат. Без тази котва бихте трябвало да напишете крехка евристика, за да познаете къде завършва размисълът и къде започва заключението.

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:
    """Генерира n отговора и връща най-честия."""
    responses = []

    for _ in range(n):
        response = client.responses.create(
            model=model,
            reasoning={"effort": "none"},  # temperature изисква effort none
            instructions=system + "\nРазсъждавайте стъпка по стъпка, след това дайте "
                         "крайния си отговор след '>>> ANSWER:'",
            input=prompt,
            temperature=0.7  # Temperature > 0 за разнообразие
        )
        responses.append(response.output_text)

    # Извличане на крайните отговори
    answers = []
    for r in responses:
        if ">>> ANSWER:" in r:
            answer = r.split(">>> ANSWER:")[-1].strip()
            answers.append(answer)

    # Гласуване с мнозинство
    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}

Какво Ви казва гласуването

Приложена към класификация на настроенията, функцията връща не просто етикет, а разпределение, и това разпределение често е по-ценно от самия етикет. За рецензията по-долу, която е истински двусмислена – продуктът е добър, но доставката е катастрофална – четири извиквания гласуват „отрицателно“, а три гласуват „неутрално“. Увереността от 57% Ви подсказва, че този случай може да заслужи специално внимание: поставяне в опашка за човешки преглед, искане на изясняване от потребителя или просто изключване от агрегираната статистика. Едно единствено извикване би показало „отрицателно“ без нюанси и бихте третирали този tiket точно както рецензия, изпълнена с единодушен гняв.

system = """Вие сте класификатор на настроения.
Анализирайте текста и разсъждавайте стъпка по стъпка.
Дайте крайния си отговор след '>>> ANSWER:', избирайки от:
positive, negative, neutral"""

text = "The product is fine but the delivery took 3 weeks."

result = self_consistency(text, system, n=7)
print(f"Настроение: {result['answer']}")
print(f"Увереност: {result['confidence']:.0%}")
print(f"Разпределение: {result['all_answers']}")
# Примерен изход:
# Настроение: negative
# Увереност: 57%
# Разпределение: {'negative': 4, 'neutral': 3}

Паралелна версия с asyncio

Цената на тази техника не е само финансова: пет последователни извиквания означават и пет пъти по-голяма латентност, което изключва подхода във всеки интерфейс, където някой чака пред екрана си. Въпреки това, извикванията са напълно независими; няма оправдание да ги чакате едно след друго. asyncio.gather намалява общото време до това на най-бавното извикване, правейки самосъгласуваността съвместима с онлайн употреба, като накладните разходи стават чисто парични.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def self_consistency_async(prompt: str, system: str = "",
                                  n: int = 5) -> dict:
    """Асинхронна версия на самосъгласуваността."""

    async def single_call():
        response = await async_client.responses.create(
            model="gpt-5.6-terra",
            reasoning={"effort": "none"},  # temperature изисква effort none
            instructions=system + "\nРазсъждавайте, след това дайте отговора си "
                         "след '>>> ANSWER:'",
            input=prompt,
            temperature=0.7
        )
        return response.output_text

    # Стартиране на всички заявки паралелно
    tasks = [single_call() for _ in range(n)]
    results = await asyncio.gather(*tasks)

    # Извличане и гласуване
    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)
    }

Кога да използвате самосъгласуваност

Критерият за вземане на решение е прост за формулиране: гласуването има смисъл само ако отговорът е дискретен и сравним. Две добре написани обобщения не могат да бъдат преброени, тъй като никога няма да бъдат идентични символ по символ; два етикета за категория – могат.

Случай на употреба Полезно? Защо
Класификация Да Дискретен отговор, просто гласуване
Математическо разсъждение Да Множество пътища до верния отговор
Извличане на entidades Да Консенсус относно откритите entidades
Креативно писане Не Няма един единствен „верен“ отговор
Обобщаване на текст Частично Полезно за ключови факти, не за стил

Настройване на съотношението разходи/надеждност

Три извиквания са минималният жизнеспособен брой, за да има гласуването с мнозинство някакъв смисъл; пет предлагат най-добрия компромис за повечето приложения; от седем до единадесет са оправдани за критични решения, където една грешка струва много повече от няколко допълнителни извиквания. Въпреки това, истинската полза идва от начина, по който използвате оценката за увереност, а не от броя на извадките. Под 60% приемете, че няма консенсус и ескалирайте – или към човешки оператор, или към по-мощен модел с повече извадки, както е показано по-долу.

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

if result["confidence"] < 0.6:
    # Няма ясен консенсус, ескалиране
    result = self_consistency(question, system, n=9, model="gpt-5.6-sol")

Оставащият въпрос е дали усилието си заслужава във Вашия конкретен случай и това трябва да се измери, а не да се предполага. Внедрете асинхронната версия, стартирайте я върху дузина въпроси за класификация на настроения, за които знаете очаквания отговор, след което сравнете получената точност при едно извикване спрямо пет извиквания. Фигурата, която получите, ще реши въпроса за накладните разходи за Вашия конкретен случай – нещо, което никоя обща препоръка не може да направи вместо Вас.

Ключови изводи

  • Самосъгласуваността генерира множество отговори и гласува за най-добрия
  • Използвайте температура > 0, за да постигнете разнообразие
  • Ефективна за задачи с дискретен отговор (класификация, изчисление)
  • Безполезна за креативни задачи без един единствен верен отговор
  • Паралелизирайте извикванията с asyncio, за да ограничите латентността