Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Edistyneet mallit

Oppitunti 11 / 14 Päivitetty 3. marraskuuta 2026 Edistynyt
Tällä sivulla
  1. Lineaaristen työvuojen tuolla puolen
  2. Työvuoja ketjuttamalla
  3. Rinnakkaisuus asyncio.gatherilla
  4. Päätöksenteko työvuoissa
  5. Fan-out / Fan-in
  6. Keskeiset asiat

Päivitetty 3. marraskuuta 2026: Aiemmin alityövuo palautti execution.output, joka puuttuu mistralai SDK:n versiosta 3.7.0. Tulos luetaan nyt kentästä result käyttämällä parametria wait_for_result=True odottamaan valmistumista.

Lineaaristen työvuojen tuolla puolen

Olemme tähän mennessä tarkastelleet työvuoja, jotka suorittavat aktiviteetteja peräkkäin. Käytännössä todelliset käyttötapaukset vaativat kuitenkin kehittyneempiä malleja: työvuoja ketjutetaan, aktiviteetteja suoritetaan rinnakkain tai tehdään monimutkaisia ehdollisia päätöksiä. Nämä neljä mallia – ketjutus, jatkuvuus, rinnakkaisuus sekä fan-out/fan-in – kattavat lähes kaiken tarvitsemasi arkkitehtuurin.

Työvuoja ketjuttamalla

Työvuo voi käynnistää toisen työvuo. Tämä ominaisuus palvelee kahta erillistä tavoitetta: monimutkaisen logiikan jakamista uudelleenkäytettäviin alityövuoisiin ja 51 200 tapahtuman rajan kiertämistä suorituksen kohdalla, sillä jokainen alityövuo saa oman kiintiönsä. Mekanismi perustuu aktiviteettiin, joka on ainoa paikka, jossa SDK voi laillisesti tehdä verkkopyynnön.

import mistralai.workflows as workflows
from mistralai.client import Mistral

@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
    """Käynnistää alityövuo ja odottaa sen tulosta."""
    client = Mistral()
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier=workflow_name,
        input=input_data,
        wait_for_result=True,  # odota alityövuo tulosta
    )
    return execution.result

@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        # Vaihe 1: Tiedonkeruu (erillinen alityövuo)
        data = await launch_sub_workflow(
            "data_collection",
            {"sources": params["sources"]}
        )

        # Vaihe 2: Analyysi (erillinen alityövuo)
        analysis = await launch_sub_workflow(
            "content_analysis",
            {"data": data}
        )

        # Vaihe 3: Raportin generointi (erillinen alityövuo)
        report = await launch_sub_workflow(
            "report_generation",
            {"analysis": analysis, "format": params["format"]}
        )

        return report

Hyöty ulottuu pelkkää luettavuutta pidemmälle: data_collection muuttuu itsenäiseksi työvuoaksi, jota voidaan testata erillään ja käyttää muissa putkistoissa omilla aikakatkaisuillaan ja uudelleenyrityskäytännöillään.

Sama mekanismi sovellettuna työvuoön, joka kutsuu itseään, luo jatkuvuusmallin. Sen sijaan, että käsiteltäisiin sata tuhatta kohdetta yhdessä suorituksessa – mikä tapahtumaraja estää – työvuo käsittelee erän ja delegoi loput uudelle instanssille.

@workflows.workflow.define(name="batch_processing")
class BatchProcessing:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        offset = params.get("offset", 0)
        batch_size = 100

        # Nouda nykyinen erä
        batch = await retrieve_batch(offset, batch_size)

        if not batch["items"]:
            # Kaikki erät käsitelty
            return {"status": "completed", "total_processed": offset}

        # Käsittele nykyinen erä
        await process_batch(batch["items"])

        # Käynnistä seuraava erä uuden työvuo kautta
        next_batch = await launch_sub_workflow(
            "batch_processing",
            {"offset": offset + batch_size}
        )

        return next_batch

Jokainen uusi suoritus alkaa puhtaalla lokilla. Käsiteltävien kohteiden määrä muuttuu rajattomaksi, ja pysäytysehtona on yksinkertaisesti tyhjä erä.

Rinnakkaisuus asyncio.gatherilla

Kun useat aktiviteetit ovat toisistaan riippumattomia, niitä ei ole syytä suorittaa peräkkäin. asyncio.gather lähettää ne alustalle samanaikaisesti, jolloin kokonaisaika lähestyy hitaimman aktiviteetin kestoa eikä kaikkien summaa.

import asyncio
import mistralai.workflows as workflows

@workflows.activity()
async def analyze_source(url: str) -> dict:
    """Analysoi tietolähteen."""
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
    return {"url": url, "size": len(response.text)}

@workflows.workflow.define(name="parallel_analysis")
class ParallelAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, urls: list) -> dict:
        # Käynnistä kaikki analyysit rinnakkain
        results = await asyncio.gather(
            *[analyze_source(url) for url in urls]
        )

        return {
            "source_count": len(results),
            "results": list(results)
        }

On kuitenkin yksi varoitus: oletusarvoisesti gather välittää ensimmäisen kohdatun poikkeuksen ja keskeyttää koko joukon. Jos analysoit neljääkymmentä ulkoista lähdettä, jo yhden ollessa offline menetat muut kolmekymmentäyhdeksän. Parametri return_exceptions=True muuttaa tätä käyttäytymistä: virheet palautetaan tavallisina arvoina, jolloin voit lajitella ne itse.

@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, urls: list) -> dict:
        # return_exceptions=True estää yhtä virhettä tukkimasta muita
        results = await asyncio.gather(
            *[analyze_source(url) for url in urls],
            return_exceptions=True
        )

        successes = []
        errors = []
        for i, result in enumerate(results):
            if isinstance(result, Exception):
                errors.append({"url": urls[i], "error": str(result)})
            else:
                successes.append(result)

        return {
            "successes": successes,
            "errors": errors,
            "success_rate": len(successes) / len(urls)
        }

Tämä työvuo palauttaa osittaisen tuloksen onnistumisasteen kera, mikä mahdollistaa sen, että myöhemmät prosessit voivat päättää, onko laatu riittävä vai tarvitaanko uudelleenyritys.

Päätöksenteko työvuoissa

Monimutkainen haarautuminen ei ole vain sallittua, vaan se on usein työvuojen käytön päätarkoitus, edellyttäen että ehdot johdetaan aktiviteettien tuloksista. Sisällön moderointitapaus havainnollistaa tätä ketjureaktiologiikkaa hyvin: automaattinen päätös, kun malli on erittäin varma, toinen lausunto varmuuden ollessa kohtalainen ja ihmisen eskalointi erimielisyyden tai alhaisen varmuuden sattuessa.

@workflows.workflow.define(name="content_moderation")
class ContentModeration:
    @workflows.workflow.entrypoint
    async def run(self, content: dict) -> dict:
        # Vaihe 1: Automaattinen analyysi
        analysis = await auto_analyze_content(content["text"])

        if analysis["confidence_score"] > 0.95:
            # Korkea varmuus: automaattinen päätös
            if analysis["category"] == "acceptable":
                await publish_content(content["id"])
                return {"decision": "published", "method": "automatic"}
            else:
                await reject_content(content["id"], analysis["reason"])
                return {"decision": "rejected", "method": "automatic"}

        elif analysis["confidence_score"] > 0.7:
            # Kohtalainen varmuus: toinen analyysi eri mallilla
            second_analysis = await analyze_content_model_b(content["text"])

            if analysis["category"] == second_analysis["category"]:
                # Molemmat mallit samaa mieltä
                if analysis["category"] == "acceptable":
                    await publish_content(content["id"])
                    return {"decision": "published", "method": "ai_consensus"}
                else:
                    await reject_content(content["id"], analysis["reason"])
                    return {"decision": "rejected", "method": "ai_consensus"}
            else:
                # Erimielisyys: ihmisen eskalointi
                await escalate_moderation(content["id"], analysis, second_analysis)
                return {"decision": "pending", "method": "human_escalation"}

        else:
            # Alhainen varmuus: suora eskalointi
            await escalate_moderation(content["id"], analysis, None)
            return {"decision": "pending", "method": "human_escalation"}

Huomaa jokaisessa poistumispisteessä palautettu method-kenttä: sen avulla voit mitata jälkikäteen, mikä osuus sisällöstä käsiteltiin ilman ihmisen väliintuloa, ja säätää kynnysarvoja sen mukaisesti.

Fan-out / Fan-in

Viimeinen malli yhdistää edelliset: työ jaetaan rinnakkain, ja tulokset aggregoidaan yhteen pisteeseen. Tässä dokumentti käännetään samanaikaisesti kolmelle kielelle, jokainen käännös analysoidaan rinnakkain, ja kaikki suppenee yhteenvetoon.

@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, document: dict) -> dict:
        # Fan-out: käännä rinnakkain 3 kielelle
        translations = await asyncio.gather(
            translate(document["text"], "en"),
            translate(document["text"], "de"),
            translate(document["text"], "es")
        )

        # Fan-out: analysoi jokainen käännös rinnakkain
        analyses = await asyncio.gather(
            *[analyze_sentiment(trad["translated_text"]) for trad in translations]
        )

        # Fan-in: aggregoi tulokset
        summary = await aggregate_analyses(list(analyses))

        return summary

Kaksi rinnakkaisuusaaltoa ovat peräkkäisiä, koska toinen riippuu ensimmäisen tuloksista. Tiukassa sekvenssissä tämä työvuo vaatisi seitsemän ketjutettua kutsua; tässä se maksaa vain kolme orkestrointivaihetta.

Yhteenvetona: pilko monimutkaiset työvuo uudelleenkäytettäviin alityövuoisiin, rinnakkaista aina kun aktiviteetit ovat riippumattomia, ota käyttöön return_exceptions=True, kun osittaiset epäonnistumiset ovat hyväksyttäviä, pidä jatkuvuus varassa hyvin pitkiä käsittelytehtäviä varten ja varmista aina, että haarautumisesi perustuvat aktiviteettien tuloksiin eikä ei-deterministisiin arvoihin.

Keskeiset asiat

  • Työvuo voi käynnistää muita työvuoja aktiviteetin kautta, joka kutsuu SDK:ta
  • Jatkuvuus-malli mahdollistaa rajattoman määrän kohteiden käsittelyn peräkkäisinä erinä
  • asyncio.gather antaa sinun suorittaa aktiviteetteja rinnakkain kokonaisajan lyhentämiseksi
  • Monimutkainen ehdollinen haarautuminen on tuettua, kunhan se riippuu aktiviteettien tuloksista
  • Fan-out / Fan-in -malli jakaa työn ja aggregoi sitten tulokset