Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Thinking chunks: lasīšana modeļa spriešanā

Nodarbība 3 no 12 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Divas atbildes formas
  2. Domāšanas čunka uzbūve
  3. Atbildes parsēšana Python valodā
  4. Spriešanas attēlošana saskarnē
  5. Straumēšana trīs fāzēs
  6. Galvenās atziņas

Nodarbība pārrakstīta 2026. gada 2. novembrī, balstoties uz sadaļu Handling thinking chunks Mistral dokumentācijā. Iepriekšējā versijā spriešana tika nolasīta no text lauka domāšanas čunkā: šāds lauks nepastāv; spriešana ir teksta čunku saraksts.

Divas atbildes formas

Izmantojot reasoning_effort="high", atbildes lauks message.content vairs nav virkne, bet gan čunku saraksts. Ar reasoning_effort="none" tas atkal ir parasts teksts bez jebkādām spriešanas pēdām. Stabilam kodam vienmēr jāapstrādā abas formas: tas ir šīs nodarbības zelta likums.

Domāšanas čunka uzbūve

Sarakstā parādās divu veidu čunki:

  • ThinkChunk (type: "thinking") nes spriešanas pēdas. Tā lauks thinking pats par sevi ir TextChunk fragmentu saraksts;
  • TextChunk (type: "text") nes galīgo atbildi savā laukā text.

Lūk, kā izskatās Mistral Small 4 atbilde, ņemta no oficiālā piemēra (teksti saīsināti):

{
  "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 objektu modelis precīzi atbilst šai struktūrai: ThinkChunk.thinking satur spriešanas čunkus, un katrs TextChunk dara savu saturu pieejamu, izmantojot .text.

Atbildes parsēšana Python valodā

Oficiālais kods atšķir čunkus, izmantojot isinstance, pēc tam, kad ir izslēgts parastās virknes gadījums:

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)

Lietotnē tev būs nepieciešama funkcija, kas atdala spriešanu un atbildi. Nosauksim to par separate un izmantosim to vēlāk kursa gaitā:

from mistralai.client.models import TextChunk, ThinkChunk

def separate(content):
    """Atgriež (spriešana, atbilde) saturam, kas ir vai nu virkne, vai čunku saraksts."""
    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)

Spriešanas attēlošana saskarnē

Abu daļu atdalīšana ļauj tev izlemt, ko lietotājs redz. Trīs izplatītas pieejas:

  • Slēpt spriešanu un rādīt tikai atbildi, kas paredzēts patērētājiem domātam asistentam;
  • Sakļaut spriešanu blokā, ko lietotājs var atvērt pēc vēlēšanās, kas piemērots ekspertu rīkiem;
  • Rādīt pilnu spriešanu, kas paredzēts izglītojošam tutoram, kur process ir tikpat svarīgs kā rezultāts.
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

Reālā projektā pirms teksta ievietošanas HTML kodā tas ir jāatbrīvo (piemēram, izmantojot html.escape): gan spriešana, gan atbilde ir ģenerēts teksts, nevis uzticama iezīmēšana.

Straumēšana trīs fāzēs

Straumēšanas laikā delta.content maina savu formu, kamēr atbilde veidojas:

  1. Spriešanas fāze: delta.content ir saraksts, kas satur ThinkChunk;
  2. Pāreja: viens saraksts, kas satur gan noslēdzošo ThinkChunk, gan pirmo TextChunk;
  3. Atbildes fāze: delta.content ir parasta virkne.

Tālāk minētais kods, pielāgots no oficiālā piemēra, attēlo abas fāzes, izsekojot stāvokļa karodziņu:

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)

Straumēšana maina pieredzi: tā vietā, lai gaidītu, kamēr garš spriešanas process beidzas pie sasaluša ekrāna, lietotājs redz modeli darbībā vai vismaz aktivitātes indikatoru, ja izvēlies slēpt spriešanu.

Galvenās atziņas

  • content ir virkne ar none, čunku saraksts ar high: vienmēr apstrādā abus gadījumus
  • ThinkChunk.thinking ir TextChunk saraksts; galīgā atbilde atrodas augšējā līmeņa TextChunk
  • Funkcija separate, kas atgriež (spriešana, atbilde), vienkāršo pārējo kodu
  • Straumēšanā: spriešanas saraksts, jaukta pāreja, tad atbildes virknes
  • Pirms attēlošanas atbrīvo gan spriešanu, gan atbildi