Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Mąstymo gabalėliai: modelio samprotavimo skaitymas

Paskaita 3 iš 12 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Dvi atsakymo formos
  2. Mąstymo gabalėlio sandara
  3. Atsakymo analizavimas naudojant Python
  4. Samprotavimo rodymas sąsajoje
  5. Srautinis perdavimas trimis etapais
  6. Svarbiausi punktai

Pamoka perrašyta 2026 m. lapkričio 2 d. remiantis skyriumi Handling thinking chunks iš Mistral dokumentacijos. Ankstesnėje versijoje samprotavimas buvo nuskaitytas iš text lauko mąstymo gabalėlyje: tokio lauko nėra; samprotavimas yra teksto gabalėlių sąrašas.

Dvi atsakymo formos

Nustačius reasoning_effort="high", atsakymo laukas message.content nebėra eilutė, o tampa gabalėlių sąrašu. Nustačius reasoning_effort="none", tai vėl paprasta eilutė be jokių samprotavimo pėdsakų. Patikimas kodas visada tvarko abi formas: tai yra auksinė šios pamokos taisyklė.

Mąstymo gabalėlio sandara

Sąraše atsiranda dviejų tipų gabalėliai:

  • ThinkChunk (type: "thinking") perduoda samprotavimo eigą. Jo laukas thinking pats savaime yra sąrašas, sudarytas iš TextChunk fragmentų;
  • TextChunk (type: "text") perduoda galutinį atsakymą savo lauke text.

Štai „Mistral Small 4“ atsakymo struktūra, paimta iš oficialaus pavyzdžio (tekstai sutrumpinti):

{
  "model": "mistral-small-2603",
  "usage": {"prompt_tokens": 77, "completion_tokens": 1114, "total_tokens": 1191},
  "choices": [{
    "finish_reason": "stop",
    "message": {
      "role": "assistant",
      "content": [
        {"type": "thinking", "thinking": [
          {"type": "text", "text": "Okay, let's try to figure out John's age..."}
        ]},
        {"type": "text", "text": "Let's denote the ages of the sisters as follows..."}
      ]
    }
  }]
}

Python SDK objektų modelis tiksliai atitinka šią struktūrą: ThinkChunk.thinking saugo samprotavimo gabalėlius, o kiekvienas TextChunk savo turinį pateikia per .text.

Atsakymo analizavimas naudojant Python

Oficialiame kode gabalėliai atskiriami naudojant isinstance, pirmiausia atmestus paprastos eilutės atvejį:

from mistralai.client.models import TextChunk, ThinkChunk

content = chat_response.choices[0].message.content

if isinstance(content, str):          # reasoning_effort="none"
    print(content)
else:
    for chunk in content:
        if isinstance(chunk, ThinkChunk):
            print("--- reasoning ---")
            for inner in chunk.thinking:
                if isinstance(inner, TextChunk):
                    print(inner.text)
            print("--- end of reasoning ---")
        elif isinstance(chunk, TextChunk):
            print(chunk.text)

Programoje tau prireiks funkcijos, kuri atskirai grąžintų samprotavimą ir atsakymą. Pavadinkime ją separate ir panaudosime vėliau kurse:

from mistralai.client.models import TextChunk, ThinkChunk

def separate(content):
    """Grąžina (samprotavimas, atsakymas) turiniui, kuris yra arba eilutė, arba gabalėlių sąrašas."""
    if isinstance(content, str):
        return "", content
    reasoning, answer = [], []
    for chunk in content or []:
        if isinstance(chunk, ThinkChunk):
            reasoning.extend(i.text for i in chunk.thinking if isinstance(i, TextChunk))
        elif isinstance(chunk, TextChunk):
            answer.append(chunk.text)
    return "".join(reasoning), "".join(answer)

reasoning, answer = separate(chat_response.choices[0].message.content)

Samprotavimo rodymas sąsajoje

Atskyrus šias dvi dalis, gali nuspręsti, ką matys naudotojas. Trys dažniausi būdai:

  • Slėpti samprotavimą ir rodyti tik atsakymą – tinkama vartotojams skirtam asistentui;
  • Sutraukti samprotavimą į bloką, kurį naudotojas gali atidaryti, jei pageidauja – tinkama ekspertų įrankiui;
  • Rodyti visą samprotavimą – tinkama edukaciniam tutoriui, kur procesas toks pat svarbus kaip ir rezultatas.
def render_html(content, show_reasoning=False):
    reasoning, answer = separate(content)
    html = f"<div class='answer'>{answer}</div>"
    if show_reasoning and reasoning:
        html = (
            "<details><summary>View model reasoning</summary>"
            f"<pre>{reasoning}</pre></details>" + html
        )
    return html

Realiam projektui prieš įterpiant tekstą į HTML būtina jį ekranuoti (pavyzdžiui, naudojant html.escape): tiek samprotavimas, tiek atsakymas yra sugeneruotas tekstas, o ne patikima žymėjimo kalba.

Srautinis perdavimas trimis etapais

Srautinio perdavimo metu delta.content forma keičiasi atsakymui formuojantis:

  1. Samprotavimo etapas: delta.content yra sąrašas, kuriame yra ThinkChunk;
  2. Perėjimas: vienas sąrašas, kuriame yra ir uždaromas ThinkChunk, ir pirmasis TextChunk;
  3. Atsakymo etapas: delta.content yra paprasta eilutė.

Toliau pateiktas kodas, pritaikytas iš oficialaus pavyzdžio, rodo abu etapus stebint būsenos žymę:

import os
from mistralai.client import Mistral
from mistralai.client.models import TextChunk, ThinkChunk

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
in_reasoning = False

for event in client.chat.stream(
    model="mistral-large-4-0",
    messages=[{"role": "user", "content": "What is 17 × 23?"}],
    reasoning_effort="high",
):
    delta = event.data.choices[0].delta.content
    if not delta:
        continue
    if isinstance(delta, str):            # answer phase
        if in_reasoning:
            print("\n--- end of reasoning ---")
            in_reasoning = False
        print(delta, end="", flush=True)
        continue
    for chunk in delta:                   # reasoning phase and transition
        if isinstance(chunk, ThinkChunk):
            if not in_reasoning:
                print("--- reasoning ---")
                in_reasoning = True
            for inner in chunk.thinking:
                if isinstance(inner, TextChunk):
                    print(inner.text, end="", flush=True)
        elif isinstance(chunk, TextChunk):
            if in_reasoning:
                print("\n--- end of reasoning ---")
                in_reasoning = False
            print(chunk.text, end="", flush=True)

Srautinis perdavimas keičia patirtį: vietoj to, kad lauktumėte, kol ilgas samprotavimo procesas baigsis prieš sustingusį ekraną, naudotojas mato modelį dirbantį, arba bent jau veiklos indikatorių, jei pasirenkate slėpti samprotavimą.

Svarbiausi punktai

  • content yra eilutė, kai nustatyta none, ir gabalėlių sąrašas, kai nustatyta high: visada tvarkyk abu atvejus
  • ThinkChunk.thinking yra sąrašas iš TextChunk; galutinis atsakymas yra viršutinio lygio TextChunk
  • Funkcija separate, grąžinanti (samprotavimas, atsakymas), supaprastina likusį tavo kodą
  • Srautiniu režimu: samprotavimo sąrašas, mišrus perėjimas, tada atsakymo eilutės
  • Prieš rodydami ir samprotavimą, ir atsakymą, juos ekranuokite