Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Pravilo determinizma

Lekcija 8 od 14 Posodobljeno 2. november 2026 Napredni
Na tej strani
  1. Zakaj je determinizem obvezen
  2. Kako to izgleda v kodi
  3. Nadomestki v SDK
  4. Meja, ki si jo moraš zapomniti
  5. Diagnosticiranje napake nedeterminizma
  6. Ključne ugotovitve

Zakaj je determinizem obvezen

Determinizem je najpomembnejša omejitev v delovnih tokovih Mistral in izhaja neposredno iz mehanizma ponovnega predvajanja, ki si se ga naučil prej. Ko delavec nadaljuje prekinjen delovni tok, ponovno izvede kodo delovnega toka od začetka in operacijo za operacijo primerja, kaj koda proizvede, s tem, kar je zabeleženo v dnevniku zgodovine. Dokler se obe zaporedji ujemata, je nadaljevanje nevidno. V trenutku, ko se razideta, platforma nima načina, da bi ugotovila, kje je ostala: zazna neskladje in odpove delovni tok z napako nedeterminizma.

V praksi determinističen delovni tok vsakič, ko se zažene z istimi vhodi, proizvede popolnoma enako zaporedje operacij. Opazi odtenek: rezultati aktivnosti se lahko med izvedbami razlikujejo, saj prihajajo iz dnevnika. Identično mora ostati le zaporedje klicev.

Kako to izgleda v kodi

Razmisli o delovnem toku, ki uporabniku pošlje poročilo glede na status njegove naročnine.

@workflows.workflow.define(name="deterministic_workflow")
class DeterministicWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # Vedno enako zaporedje klicev za isti vhod
        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 {"status": "completed"}

Ta delovni tok je determinističen, čeprav vsebuje vejo. Razlog leži v viru pogoja: profile["premium"] prihaja iz rezultata aktivnosti, torej iz dnevnika. Med ponovnim predvajanjem get_profile vrne popolnoma enako vrednost kot pri prvi izvedbi in izbrana je ista pot.

Zdaj to primerjaj s to različico, ki videti neškodljiva, a poruši vse.

import datetime
import random

@workflows.workflow.define(name="non_deterministic_workflow")
class NonDeterministicWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # PREPOVEDANO: datetime.now() se ob vsaki izvedbi spremeni
        if datetime.datetime.now().hour < 12:
            await send_morning_email(user_id)
        else:
            await send_afternoon_email(user_id)
        
        # PREPOVEDANO: random.random() vsakič vrne drugačen rezultat
        if random.random() > 0.5:
            await send_notification(user_id)
        
        return {"status": "completed"}

Predstavljaj si, da delavec odpove ob 11:58 in se ponovno zažene ob 12:03. Ob ponovnem predvajanju datetime.now() vrne popoldanski čas, medtem ko zgodovina vsebuje klic send_morning_email. Delovni tok odpove. random.random() povzroči enak učinek, le da ga je težje diagnosticirati.

Nadomestki v SDK

SDK teh klicev ne prepoveduje le, temveč ponuja deterministične ekvivalente za tri najpogostejše operacije.

from mistralai.workflows import workflow

# Pridobi trenutni čas (determinističen med ponovnim predvajanjem)
current_time = workflow.now()          # Namesto datetime.now()

# Generiraj edinstven ID (determinističen med ponovnim predvajanjem)
request_id = workflow.uuid4()          # Namesto uuid.uuid4()

# Pridobi naključno število (determinističen med ponovnim predvajanjem)
rand_value = workflow.random()         # Namesto random.random()

Načelo je enako kot pri aktivnostih: vrednost se ob prvi izvedbi izračuna in zabeleži v dnevnik, nato pa se preprosto ponovno predvaja. Prejšnji primer tako postane popolnoma varen.

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:
        # PRAVILNO: workflow.now() je med ponovnim predvajanjem determinističen
        current_hour = workflow.now()
        if current_hour.hour < 12:
            await send_morning_email(user_id)
        else:
            await send_afternoon_email(user_id)
        
        # PRAVILNO: workflow.random() je med ponovnim predvajanjem determinističen
        if workflow.random() > 0.5:
            await send_notification(user_id)
        
        # PRAVILNO: workflow.uuid4() je med ponovnim predvajanjem determinističen
        trace_id = workflow.uuid4()
        await log_trace(str(trace_id), user_id)
        
        return {"status": "completed", "trace_id": str(trace_id)}

Meja, ki si jo moraš zapomniti

V kodi delovnega toka so prepovedani naslednji klici: datetime.now(), datetime.utcnow() in time.time(); uuid.uuid4() in uuid.uuid1(); random.random(), random.randint() in random.choice(); kateri koli neposredni omrežni klic (httpx, aiohttp, requests); katero koli branje ali pisanje datotek (open(), aiofiles); kateri koli dostop do baze podatkov; os.environ, saj se spremenljivke okolja lahko med ponovnimi predvajanji spremenijo; in nazadnje threading ter multiprocessing, saj platforma obravnava notranjo vzporednost.

Vse reproducibilno ostaja dovoljeno: klicanje aktivnosti prek await, uporaba workflow.now(), workflow.uuid4() in workflow.random(), zapisovanje pogojne logike ali zank, katerih pogoji so odvisni od rezultatov aktivnosti, manipulacija s podatki v pomnilniku (izračuni, nizi) in beleženje dogodkov – beleženje velja za sprejemljiv stranski učinek.

Diagnosticiranje napake nedeterminizma

Ko pride do napake, običajno zadostujejo štirje pregledi, da jo lociraš.

  1. Prisotnost nedeterminističnih klicev – V kodi delovnega toka poišči datetime.now, uuid.uuid4, random.random
  2. Neposredni V/I – Vsak omrežni ali datotečni klic mora biti v aktivnosti
  3. Spremenljivke okolja – Če za razvejanje uporabljaš os.environ, premakni branje v aktivnost
  4. Knjižnice tretjih strani – Nekatere knjižnice internio izvajajo omrežne klice ali uporabljajo naključnost

Zadnja točka je najbolj zahrbtna: knjižnica za serializacijo, ki razvršča po naključno generiranem ID-ju, ali odjemalec HTTP, inicializiran ob nalaganju modula, lahko povzroči neuspeh ponovnega predvajanja, ne da bi se v tvojem delovnem toku pojavila sumljiva vrstica.

Najučinkovitejša obramba je ohranjanje delovnega toka čim bolj vitkega in premik vse kompleksne logike v aktivnosti. Delovni tok, ki preprosto poveže tri klice, mehansko nima priložnosti, da bi bil nedeterminističen.

# NAJBOLJŠA PRAKSA: preprost delovni tok, logika v aktivnostih
@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

Ključne ugotovitve

  • Koda delovnega toka mora biti deterministična: isti vhodi = enako zaporedje operacij
  • Namesto standardnih ekvivalentov v Pythonu uporabi workflow.now(), workflow.uuid4(), workflow.random()
  • Vse operacije V/I (omrežje, datoteka, baza podatkov) morajo biti v aktivnosti, nikoli v delovnem toku
  • Pogojne veje so dovoljene, če so odvisne od rezultatov aktivnosti
  • Kršitev determinizma povzroči neuspeh delovnega toka med ponovnim predvajanjem
  • Ko si v dvomih, premakni logiko v aktivnost