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

Izvērsti raksti

Nodarbība 11 no 14 Atjaunota 2026. gada 3. novembris Augstākais
Šajā lapā
  1. Tālāk par lineārām darbplūsmām
  2. Darbplūsmu ķēžu veidošana
  3. Paralēlizpilde ar asyncio.gather
  4. Lēmumu pieņemšana darbplūsmā
  5. Fan-out / Fan-in
  6. Galvenās atziņas

Atjaunināts 2026. gada 3. novembrī: Iepriekš apakšdarbplūsma atgrieza execution.output, kas trūkst mistralai SDK 3.7.0 versijā. Tagad rezultāts tiek nolasīts no result, izmantojot wait_for_result=True, lai sagaidītu pabeigšanu.

Tālāk par lineārām darbplūsmām

Līdz šim esam aplūkojuši darbplūsmas, kas izpilda aktivitātes secīgi. Praksē reāli lietojumi prasa sarežģītākus rakstus: darbplūsmu ķēžu veidošanu, aktivitāšu paralēlu izpildi vai kompleksu nosacītu lēmumu pieņemšanu. Šie četri raksti — ķēžu veidošana, turpināšana, paralēlisms un “fan-out/fan-in” — aptver gandrīz katru arhitektūru, kas tev būs jāizveido.

Darbplūsmu ķēžu veidošana

Darbplūsma var iedarbināt citu darbplūsmu. Šī iespēja kalpo diviem atšķirīgiem mērķiem: sarežģītas loģikas sadalīšanai atkārtoti izmantojamās apakšdarbplūsmās un 51 200 notikumu limita apietu vienā izpildē, jo katrai bērna darbplūsmai ir savs budžets. Mehānisms balstās uz aktivitāti, kas ir vienīgā vieta, kur SDK likumīgi var veikt tīkla pieprasījumu.

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

@workflows.activity()
async def launch_sub_workflow(workflow_name: str, input_data: dict) -> dict:
    """Iedarbina bērna darbplūsmu un sagaida tās rezultātu."""
    client = Mistral()
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier=workflow_name,
        input=input_data,
        wait_for_result=True,  # sagaida bērna darbplūsmas rezultātu
    )
    return execution.result

@workflows.workflow.define(name="main_pipeline")
class MainPipeline:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        # 1. solis: Datu vākšana (atsevišķa apakšdarbplūsma)
        data = await launch_sub_workflow(
            "data_collection",
            {"sources": params["sources"]}
        )

        # 2. solis: Analīze (atsevišķa apakšdarbplūsma)
        analysis = await launch_sub_workflow(
            "content_analysis",
            {"data": data}
        )

        # 3. solis: Pārskata ģenerēšana (atsevišķa apakšdarbplūsma)
        report = await launch_sub_workflow(
            "report_generation",
            {"analysis": analysis, "format": params["format"]}
        )

        return report

Ieguvums sniedzas tālāk par vienkāršu lasāmību: data_collection kļūst par patstāvīgu darbplūsmu, ko var testēt izolēti un izmantot citās cauruļvados, ar saviem noilgumiem un mēģinājumu politikām.

Tas pats mehānisms, pielietots darbplūsmai, kas izsauc pati sevi, rada turpināšanas rakstu. Tā vietā, lai vienā izpildē apstrādātu simts tūkstošus vienību — ko notikumu limits aizliedz —, darbplūsma apstrādā paketi un deleģē pārējo jaunam eksemplāram.

@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

        # Iegūst pašreizējo paketi
        batch = await retrieve_batch(offset, batch_size)

        if not batch["items"]:
            # Visas paketes apstrādātas
            return {"status": "completed", "total_processed": offset}

        # Apstrādā pašreizējo paketi
        await process_batch(batch["items"])

        # Iedarbina nākamo paketi, izmantojot jaunu darbplūsmu
        next_batch = await launch_sub_workflow(
            "batch_processing",
            {"offset": offset + batch_size}
        )

        return next_batch

Katra jauna izpilde sākas ar tīru žurnālu. Apstrādājamo vienību skaits kļūst neierobežots, un apturēšanas nosacījums ir vienkārši tukša pakete.

Paralēlizpilde ar asyncio.gather

Kad vairākas aktivitātes ir savstarpēji neatkarīgas, nav iemesla tās izpildīt secīgi. asyncio.gather iesniedz tās platformai vienlaicīgi, un kopējais laiks tuvojas lēnākās aktivitātes laikam, nevis visu laiku summai.

import asyncio
import mistralai.workflows as workflows

@workflows.activity()
async def analyze_source(url: str) -> dict:
    """Analizē datu avotu."""
    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:
        # Iedarbina visas analīzes paralēli
        results = await asyncio.gather(
            *[analyze_source(url) for url in urls]
        )

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

Tomēr pastāv viens nosacījums: pēc noklusējuma gather propagē pirmo sastapto izņēmumu un pārtrauc visu kopu. Ja analizē četrdesmit ārējos avotus, tikai viena nepieejamība liek zaudēt pārējos trīsdesmit deviņus. Parametrs return_exceptions=True maina šo uzvedību: kļūdas tiek atgrieztas kā parastas vērtības, ļaujot tev tās sakārtot.

@workflows.workflow.define(name="fault_tolerant_analysis")
class FaultTolerantAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, urls: list) -> dict:
        # return_exceptions=True novērš vienas kļūdas bloķēšanu pārējām
        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)
        }

Šī darbplūsma atgriež daļēju rezultātu kopā ar veiksmes koeficientu, ļaujot lejupplūsmas procesiem izlemt, vai kvalitāte ir pietiekama vai vai nepieciešams atkārtots mēģinājums.

Lēmumu pieņemšana darbplūsmā

Sarežģīta zarošana ir ne tikai atļauta, bet bieži vien ir galvenais darbplūsmu izmantošanas mērķis, ja nosacījumi izriet no aktivitāšu rezultātiem. Satura moderācijas gadījums labi ilustrē šo kaskādes loģiku: automātisks lēmums, ja modelis ir ļoti pārliecināts, otrais atzinums pie mērenas pārliecības un eskalācija cilvēkam neatbilstības vai zemas pārliecības gadījumā.

@workflows.workflow.define(name="content_moderation")
class ContentModeration:
    @workflows.workflow.entrypoint
    async def run(self, content: dict) -> dict:
        # 1. solis: Automātiska analīze
        analysis = await auto_analyze_content(content["text"])

        if analysis["confidence_score"] > 0.95:
            # Augsta pārliecība: automātisks lēmums
            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:
            # Mērena pārliecība: otrā analīze ar citu modeli
            second_analysis = await analyze_content_model_b(content["text"])

            if analysis["category"] == second_analysis["category"]:
                # Abi modeļi vienojas
                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:
                # Neatbilstība: eskalācija cilvēkam
                await escalate_moderation(content["id"], analysis, second_analysis)
                return {"decision": "pending", "method": "human_escalation"}

        else:
            # Zema pārliecība: tieša eskalācija
            await escalate_moderation(content["id"], analysis, None)
            return {"decision": "pending", "method": "human_escalation"}

Ņem vērā lauku method, kas tiek atgriezts katrā izejas punktā: tas ļauj retrospektīvi izmērīt, kāda daļa satura tika apstrādāta bez cilvēka iejaukšanās, un tādējādi attiecīgi pielāgot sliekšņus.

Fan-out / Fan-in

Pēdējais raksts apvieno iepriekšējos: darba sadale paralēli, pēc tam rezultātu apkopošana vienā punktā. Šeit dokuments tiek tulkots vienlaicīgi trīs valodās, katrs tulkojums tiek analizēts paralēli, un viss saplūst kopsavilkumā.

@workflows.workflow.define(name="multi_language_analysis")
class MultiLanguageAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, document: dict) -> dict:
        # Fan-out: tulko paralēli 3 valodās
        translations = await asyncio.gather(
            translate(document["text"], "en"),
            translate(document["text"], "de"),
            translate(document["text"], "es")
        )

        # Fan-out: analizē katru tulkojumu paralēli
        analyses = await asyncio.gather(
            *[analyze_sentiment(trad["translated_text"]) for trad in translations]
        )

        # Fan-in: apkopo rezultātus
        summary = await aggregate_analyses(list(analyses))

        return summary

Abi paralēlisma viļņi ir secīgi, jo otrais ir atkarīgs no pirmā rezultātiem. Stingrā secībā šī darbplūsma prasītu septiņus ķēdētus izsaukumus; šeit tā izmaksā tikai trīs orķestrācijas soļus.

Rezumējot: sadali sarežģītas darbplūsmas atkārtoti izmantojamās apakšdarbplūsmās, veic paralēlizpildi, kad aktivitātes ir neatkarīgas, ieslēdz return_exceptions=True, ja daļējas kļūdas ir pieņemamas, paturi turpināšanu rezervē ļoti gariem apstrādes uzdevumiem un vienmēr nodrošini, ka tava zarošana balstās uz aktivitāšu rezultātiem, nevis nedeterminētām vērtībām.

Galvenās atziņas

  • Darbplūsma var iedarbināt citas darbplūsmas, izmantojot aktivitāti, kas izsauc SDK
  • Turpināšanas raksts ļauj apstrādāt neierobežotu vienību skaitu secīgās paketēs
  • asyncio.gather ļauj izpildīt aktivitātes paralēli, lai samazinātu kopējo laiku
  • Sarežģīta nosacīta zarošana ir atbalstīta, ja tā ir atkarīga no aktivitāšu rezultātiem
  • Fan-out / fan-in raksts sadala darbu un pēc tam apkopo rezultātus