Systemdesign med flera modeller: När en modell inte räcker

Välj det enklaste mönster som fungerar.

Sidinnehåll

Enkelmodellsystem är enkla. Multimodellsystem är kraftfulla. Utmaningen handlar inte om att välja modeller — det handlar om att designa arkitekturen som orkestrerar dem.

Ett multimodellsystem handlar inte om att ha fler modeller. Det handlar om att ha rätt modell för rätt uppgift vid rätt tidpunkt.

Multi-model LLM system design patterns

Arkitekturmodeller

Fem modeller täcker de flesta användningsfall:

Modell Komplexitet När man ska använda den Kompromiss
Enkelmodell Lägsta Prototyper, enkla uppgifter Begränsad kapacitet
Sekventiell Låg Flöden med flera steg Högre latens
Parallell Medel Oberoende uppgifter Högre kostnad
Hierarkisk Hög Komplex resonemang Komplex orkestrering
Ensemble Högst Kritiska beslut Högst kostnad

Välj den enklaste som fungerar. Komplexitet är verklig, och den ackumuleras.

Sekventiell arkitektur

Bearbeta uppgifter genom en kedja av modeller, där varje modell specialiserar sig på ett steg.

Modell 1: Pipeline

Pipeline-modellen — varje modells utdata matas in i nästa:

class ModelPipeline:
    def __init__(self):
        self.models = [
            {"model": "qwen2.5-1.5b", "task": "classify"},
            {"model": "qwen2.5-7b", "task": "extract"},
            {"model": "qwen2.5-32b", "task": "reason"},
        ]

    def process(self, input: str) -> str:
        current = input
        for model_config in self.models:
            current = self.call_model(
                model_config["model"],
                self.create_prompt(model_config["task"], current)
            )
        return current

Latensen adderas. Tre modeller i sekvens betyder tre gånger latensen. Använd detta endast när varje steg faktiskt behöver en annan modell.

Modell 2: Router

Router-modellen — klassificera uppgiften, dirigera till specialisten:

class ModelRouter:
    def __init__(self):
        self.classifier = "qwen2.5-1.5b"
        self.specialists = {
            "code": "qwen2.5-coder-7b",
            "math": "qwen2.5-32b",
            "creative": "claude-sonnet-4",
            "general": "qwen2.5-7b",
        }

    def route(self, prompt: str) -> str:
        task_type = self.classify(prompt)
        model = self.specialists.get(task_type, self.specialists["general"])
        return self.call_model(model, prompt)

Klassificeraren är den svaga länken. Om den klassificerar fel, dirigerar du till fel modell och förlorar kvalitet. Använd en klassificerare som är god nog — även en liten fungerar om kategorierna är tydliga.

Parallell arkitektur

Bearbeta oberoende uppgifter samtidigt.

Modell 1: Fan-Out

Fan-out — kör samma prompt genom flera modeller:

import asyncio

class ModelFanOut:
    def __init__(self):
        self.models = [
            "qwen2.5-7b",
            "qwen2.5-32b",
            "claude-sonnet-4",
        ]

    async def process(self, prompt: str) -> list[str]:
        tasks = [self.call_model(model, prompt) for model in self.models]
        return await asyncio.gather(*tasks)

Användbart för jämförelser, A/B-tester, eller när du vill välja den bästa utdata. Dyrt, men kvalitetsvinnet är värt det vid kritiska beslut.

Modell 2: Voting

Röstning — kombinera utdata genom konsensus:

class ModelVoting:
    def __init__(self):
        self.models = [
            "qwen2.5-7b",
            "qwen2.5-32b",
            "claude-sonnet-4",
        ]

    def vote(self, prompt: str) -> str:
        responses = [self.call_model(model, prompt) for model in self.models]
        from collections import Counter
        votes = Counter(responses)
        return votes.most_common(1)[0][0]

Majoritetsröstning fungerar för klassificering. För genereringsuppgifter är det svårare — du behöver semantisk likhet, inte exakta matchningar.

Hierarkisk arkitektur

Använd modeller på olika abstraktionsnivåer.

Modell 1: Planner-Executor

Planerare-exekutor — en stark modell planerar, mindre modeller exekverar:

class PlannerExecutor:
    def __init__(self):
        self.planner = "qwen2.5-32b"
        self.executors = {
            "code": "qwen2.5-coder-7b",
            "search": "qwen2.5-7b",
            "math": "qwen2.5-7b",
        }

    def process(self, task: str) -> str:
        plan = self.call_model(self.planner, f"Plan: {task}")
        results = []
        for step in self.parse_plan(plan):
            executor = self.executors.get(step["type"], "qwen2.5-7b")
            result = self.call_model(executor, step["prompt"])
            results.append(result)
        return self.call_model(self.planner, f"Synthesize: {results}")

Planeraren gör det tunga lyftet. Exekutorerna hanterar specifika uppgifter. Denna modell fungerar bra när planeringssteget är dyrt men exekveringsstegen är billiga.

Modell 2: Supervisor-Worker

Supervisor-worker — en supervisor delegerar och granskar:

class SupervisorWorker:
    def __init__(self):
        self.supervisor = "qwen2.5-32b"
        self.workers = ["qwen2.5-7b", "qwen2.5-coder-7b"]

    def process(self, task: str) -> str:
        assignments = self.call_model(self.supervisor, f"Assign: {task}")
        results = []
        for assignment in self.parse_assignments(assignments):
            result = self.call_model(
                assignment["worker"], assignment["task"]
            )
            results.append(result)
        return self.call_model(self.supervisor, f"Review: {results}")

Supervisor är flaskhalsen. Den planerar, delegerar och granskar. Se till att den är tillräckligt snabb, annars blir hela systemet långsamt.

Ensemble-arkitektur

Kombinera flera modeller för kritiska beslut.

Modell 1: Weighted Ensemble

Vägda ensemble — betygsätt varje modells utdata, välj högsta:

class WeightedEnsemble:
    def __init__(self):
        self.models = {
            "qwen2.5-32b": 0.5,
            "claude-sonnet-4": 0.3,
            "qwen2.5-7b": 0.2,
        }

    def decide(self, prompt: str) -> str:
        responses = {
            model: self.call_model(model, prompt)
            for model in self.models
        }
        scores = {}
        for model, response in responses.items():
            score = self.evaluate(response) * self.models[model]
            scores[response] = scores.get(response, 0) + score
        return max(scores, key=scores.get)

Vikterna speglar ditt förtroende för varje modell. Justera dem baserat på faktisk prestanda, inte benchmark-resultat.

Modell 2: Consensus Ensemble

Konsensusensemble — kräv enighet, eskalera om det inte finns någon:

class ConsensusEnsemble:
    def __init__(self, threshold: float = 0.7):
        self.threshold = threshold
        self.models = [
            "qwen2.5-32b",
            "claude-sonnet-4",
            "qwen2.5-7b",
        ]

    def decide(self, prompt: str) -> str:
        responses = [
            self.call_model(model, prompt)
            for model in self.models
        ]
        from collections import Counter
        votes = Counter(responses)
        max_votes = max(votes.values())

        if max_votes / len(self.models) >= self.threshold:
            return votes.most_common(1)[0][0]

        return self.call_model("qwen2.5-32b", prompt)

Tröskeln styr hur strikt konsensus är. 0,7 betyder två tredjedelar enighet. Sänk den för snabbare beslut, höj den för högre tillit.

När multimodellsystem gör mening

Multimodellsystem gör mening när du har blandade arbetsbelastningar, behöver hög kvalitet för kritiska beslut, eller optimerar för kostnad eller latens.

De gör inte mening när alla uppgifter har liknande komplexitet, du prototyper, eller när enkelhet väger tyngre än optimering.

Fingerregel: börja med en modell. Lägg till fler när du stöter på en verklig begränsning — kostnad, latens eller kvalitet. Designa inte komplexitet innan du behöver den.

Kompromisser

Modell Kostnad Latens Kvalitet Komplexitet
Enkelmodell Lägsta Lägsta Variabel Lägsta
Sekventiell Medel Hög Hög Medel
Parallell Hög Låg Hög Medel
Hierarkisk Hög Hög Högst Hög
Ensemble Högst Medel Högst Högst

Varje modell innebär en kompromiss. Välj den som matchar dina begränsningar.

Relaterat

Prenumerera

Få nya inlägg om system, infrastruktur och AI-ingenjörskonst.