Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Determinismi reegel

Õppetund 8 / 14 Värskendatud 2. november 2026 Edasijõudnutele
Sellel lehel
  1. Miks on determinism kohustuslik
  2. Kuidas see koodis välja näeb
  3. SDK asendused
  4. Piir, mida meeles pidada
  5. Mitte-determinismi vea diagnoosimine
  6. Peamised punktid

Miks on determinism kohustuslik

Determinism on Mistrali töövoogude kõige kriitilisem piirang, mis tuleneb otseselt eelnevalt õpitud taasesitamise mehhanismist. Kui töötaja katkenud töövoogu jätkab, esitab ta töövoogu koodi algusest uuesti ja võrdleb tehte haaval seda, mida kood toodab, ajaloo logisse salvestatuga. Niikaua kui need kaks jada kattuvad, on jätkamine nähtamatu. Hetkel, mil need lahknema hakkavad, ei tea platvorm enam, kus ta pooleli jäi: ta tuvastab lahknevuse ja nurjab töövoogu mitte-determinismi veaga.

Praktikas tähendab deterministlik töövoog seda, et sama sisendiga käivitamisel tekitab see iga kord täpselt sama tehtejada. Pane tähele nüanssi: tegevuste tulemused võivad täitmiste vahel erineda, kuna need pärinevad ajakirjast. Just väljakutsete järjekord peab jääma identseks.

Kuidas see koodis välja näeb

Vaatleme töövoogu, mis saadab kasutajale aruande tema tellimuse staatuse põhjal.

@workflows.workflow.define(name="deterministic_workflow")
class DeterministicWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # Sama sisendi korral alati sama väljakutsete jada
        profile = await get_profile(user_id)
        
        if profile["premium"]:
            report = await generate_full_report(user_id)
        else:
            report = await generate_basic_report(user_id)
        
        await send_email(profile["email"], report)
        return {"skis": "completed"}

See töövoog on deterministlik, kuigi see sisaldab haru. Põhjus peitub tingimuse allikas: profile["premium"] pärineb tegevuse tulemusest, seega tuleb see ajakirjast. Taasesitamise ajal tagastab get_profile täpselt sama väärtuse kui esimesel käivitamisel ja valitakse sama tee.

Võrdle seda nüüd selle versiooniga, mis tundub kahjutu, kuid rikub kõik.

import datetime
import random

@workflows.workflow.define(name="non_deterministic_workflow")
class NonDeterministicWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # KEELATUD: datetime.now() muutub iga käivitamisega
        if datetime.datetime.now().hour < 12:
            await send_morning_email(user_id)
        else:
            await send_afternoon_email(user_id)
        
        # KEELATUD: random.random() annab iga kord erineva tulemuse
        if random.random() > 0.5:
            await send_notification(user_id)
        
        return {"skis": "completed"}

Kujuta ette, et töötaja jookseb kokku kell 11:58 ja taaskäivitub kell 12:03. Taasesitamisel tagastab datetime.now() pärastlõunase aja, samas kui ajalugu sisaldab väljakutset send_morning_email. Töövoog nurjub. random.random() tekitab sama efekti, ainult et seda on raskem diagnoosida.

SDK asendused

SDK ei keela neid väljakutseid lihtsalt ära; see pakub deterministlikke ekvivalente kolmele kõige levinumale operatsioonile.

from mistralai.workflows import workflow

# Hangi praegune aeg (taasesitamisel deterministlik)
current_time = workflow.now()          # Asemel datetime.now()

# Genereeri unikaalne ID (taasesitamisel deterministlik)
request_id = workflow.uuid4()          # Asemel uuid.uuid4()

# Hangi juhuslik arv (taasesitamisel deterministlik)
rand_value = workflow.random()         # Asemel random.random()

Põhimõte on sama mis tegevuste puhul: väärtus arvutatakse ja salvestatakse ajakirja esimesel käivitamisel, seejärel lihtsalt esitatakse see uuesti. Eelnev näide muutub seejärel täiesti ohutuks.

import mistralai.workflows as workflows
from mistralai.workflows import workflow

@workflows.workflow.define(name="fixed_workflow")
class FixedWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # ÕIGE: workflow.now() on taasesitamisel deterministlik
        current_hour = workflow.now()
        if current_hour.hour < 12:
            await send_morning_email(user_id)
        else:
            await send_afternoon_email(user_id)
        
        # ÕIGE: workflow.random() on taasesitamisel deterministlik
        if workflow.random() > 0.5:
            await send_notification(user_id)
        
        # ÕIGE: workflow.uuid4() on taasesitamisel deterministlik
        trace_id = workflow.uuid4()
        await log_trace(str(trace_id), user_id)
        
        return {"skis": "completed", "trace_id": str(trace_id)}

Piir, mida meeles pidada

Järgmised on töövoogu koodis keelatud: datetime.now(), datetime.utcnow() ja time.time(); uuid.uuid4() ja uuid.uuid1(); random.random(), random.randint() ja random.choice(); kõik otsesed võrgukutsed (httpx, aiohttp, requests); kõik faili lugemise või kirjutamise operatsioonid (open(), aiofiles); kõik andmebaasi päringud; os.environ, sest keskkonnamuutujad võivad taasesitamiste vahel muutuda; ja lõpuks threading ning multiprocessing, kuna platvorm haldab sisemist paralleelsust ise.

Lubatud on kõik reprodutseeritav: tegevuste kutsumine await kaudu, workflow.now(), workflow.uuid4() ja workflow.random() kasutamine, tingimusliku loogika või tsüklite kirjutamine, mille tingimused sõltuvad tegevuste tulemustest, mälusiseste andmete manipuleerimine (arvutused, stringid) ja logimine – logimist peetakse vastuvõetavaks kõrvalmõjuks.

Mitte-determinismi vea diagnoosimine

Kui viga tabab, piisab selle leidmiseks tavaliselt neljast kontrollist.

  1. Mitte-deterministlike väljakutsete olemasolu – Otsi töövoogu koodist datetime.now, uuid.uuid4, random.random
  2. Otsene I/O – Igasugune võrgu- või failikutsed peavad asuma tegevuses
  3. Keskkonnamuutujad – Kui kasutad harude loomiseks os.environ, vii lugemine tegevusse
  4. Kolmandate osapoolte teegid – Mõned teegid teevad sisemiselt võrgukutseid või kasutavad juhuslikkust

Viimane punkt on kõige salakavalam: serialiseerimisteek, mis sorteerib juhuslikult genereeritud ID järgi, või mooduli laadimisel loodud HTTP-klient, võib taasesitamise nurjata, ilma et su töövoogu ilmneks ainustki kahtlast rida.

Kõige tõhusam kaitse on hoida töövoog võimalikult lihtsana ja suruda kogu keeruline loogika tegevustesse. Töövoog, mis lihtsalt aheldab kolme väljakutset, ei saa mehaaniliselt olla mitte-deterministlik.

# PARIM TAVA: lihtne töövoog, loogika tegevustes
@workflows.workflow.define(name="simple_pipeline")
class SimplePipeline:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        step1 = await prepare_data(params)
        step2 = await process_data(step1)
        step3 = await finalize(step2)
        return step3

Peamised punktid

  • Töövoogu kood peab olema deterministlik: sama sisend = sama tehtejada
  • Kasuta standardsete Pythoni ekvivalentide asemel workflow.now(), workflow.uuid4(), workflow.random()
  • Kõik I/O operatsioonid (võrk, fail, andmebaas) peavad asuma tegevuses, mitte kunagi töövoos
  • Tingimuslikud harud on lubatud, kui need sõltuvad tegevuste tulemustest
  • Determinismi rikkumine põhjustab töövoogu nurjumise taasesitamise ajal
  • Kahtluse korral vii loogika tegevusse