Computer Vision skalieren: So verarbeitest du Bilder mit 900 Tiles effizient

Die Entwicklung eines Computer-Vision-Modells beginnt meist mit einem einzigen Bild in Standardauflösung. Doch die Realität sieht anders aus: 4K-Videoframes, hochauflösende Satellitenbilder oder medizinische Whole-Slide-Scans sprengen jeden einzelnen Inferenzdurchlauf. Die Lösung? Bilder in kleinere, handhabbare Abschnitte – sogenannte Tiles – zu zerlegen. Doch was als technisch einfache Lösung erscheint, wird in der Praxis schnell zu einem komplexen Orchestrierungsproblem.

Warum einzelne Inferenzen bei großen Bildern scheitern

Ein Computer-Vision-Modell ist für die Verarbeitung eines Bildes mit 3×3 Tiles konzipiert. Doch bereits hier zeigt sich ein fundamentales Problem: Jedes zusätzliche Tile erhöht die Anfälligkeit für Fehler. Bei neun gleichzeitigen Inferenzen mag die Stabilität noch gegeben sein. Bei 64 Tiles steigt die Wahrscheinlichkeit von Timeout- oder Throttle-Fehlern jedoch spürbar. Ab 900 Tiles – etwa bei hochauflösenden Whole-Slide-Scans in der Pathologie – werden Teilausfälle zur Regel. Eine einzige gescheiterte Inferenz kann das gesamte Bild unbrauchbar machen.

Die Herausforderung liegt nicht in der Inferenz selbst, sondern in der fehlenden Skalierbarkeit der Orchestrierung. Viele Projekte scheitern, weil Entwickler:innen individuelle Lösungen für ein Problem bauen, das bereits gelöst wurde. Die Antwort auf diese Skalierungsfrage liegt in einer robusten Pipeline, die Tiles parallel verarbeitet und Fehler isoliert behandelt.

Der Standardansatz: Tiled Inference und bewährte Tools

Tiled Inference ist längst kein Nischenthema mehr – es ist der De-facto-Standard für die Verarbeitung von Bildern, die die Modellgrenzen überschreiten. Tools wie SAHI (Slicing Aided Hyper Inference) haben sich in der Community durchgesetzt und verzeichnen über 35.000 GitHub-Sterne. SAHI unterteilt Bilder in überlappende Slices, führt Detektionen pro Slice aus und kombiniert die Ergebnisse anschließend.

Doch SAHI läuft auf einem einzigen Rechner – für den produktiven Einsatz in Unternehmen fehlt die Skalierbarkeit. Pathologie-Pipelines benötigen eigene Koordinatoren, Worker-Pools und explizite Fehlerbehandlungsmechanismen. Jedes Unternehmen entwickelt hier individuelle Lösungen – oft mit ähnlicher Architektur, aber unterschiedlicher Implementierung.

Hier setzt eine moderne Lösung an: AWS Lambda Durable Functions mit der context.map()-Funktion. Diese orchestriert die parallele Verarbeitung von Tiles, indem sie jedes Tile als eigenständige, fehlertolerante Einheit behandelt. Bei einem Fehler wird nur das betroffene Tile neu gestartet – nicht das gesamte Bild. Ein einzelner Code-Abschnitt reicht aus, um von 9 auf 900 Tiles zu skalieren.

Eine vollständige Pipeline in nur zwei Lambda-Funktionen

Wie lässt sich diese Orchestrierung in der Praxis umsetzen? Die folgende Pipeline demonstriert, wie Bilder effizient analysiert werden können – von der Verarbeitung bis zur Echtzeit-Darstellung. Der Ansatz basiert auf AWS Lambda und benötigt keine zusätzliche Infrastruktur wie Message Queues oder separate Orchestrierungsservices.

Schritt 1: Vorverarbeitung und Grid-Erstellung

Bevor ein Bild analysiert wird, durchläuft es eine Vorverarbeitung. Dazu gehört die Inhaltsmoderation, um unangemessene Inhalte zu filtern, sowie die Erstellung eines Gitters aus Tiles. Die Grid-Größe ist dabei variabel: Für ein 3×3-Gitter werden neun Tiles erstellt, für komplexe Bilder kann die Auflösung auf 8×8 oder höher angepasst werden.

export const handler = withDurableExecution(
  async (event: AnalysisPipelineEvent, context: DurableContext) => {
    // Schritt 1: Vorverarbeitung
    const preprocessed = await context.step('preprocess', async () => {
      const gridSize = Number(event.gridSize ?? 3);
      const imageBase64 = await fetchImageBase64(event);
      await moderateImage(imageBase64, imageFormat);
      return { regions: buildRegions(gridSize) };
    });

Das Vorverarbeitungsmodul prüft zunächst die Bildqualität und -eigenschaften. Anschließend wird das Bild in ein Raster unterteilt, wobei jedes Tile die maximale unterstützte Auflösung des Modells nicht überschreitet. Dieser Schritt ist entscheidend, um sicherzustellen, dass jeder Inferenzdurchlauf stabil läuft.

Schritt 2: Parallele Inferenz mit context.map()

Der Kern der Pipeline ist die parallele Analyse der einzelnen Tiles. Die context.map()-Funktion von AWS Lambda Durable Functions orchestriert die Ausführung und stellt sicher, dass jede Inferenz unabhängig voneinander durchgeführt wird. Die maximale Parallelität kann dabei dynamisch angepasst werden – je nach Systemlast.

// Schritt 2: Parallele Inferenz über alle Tiles
const mapResults = await context.map(
  'analyze-regions',
  preprocessed.regions,
  async (ctx: DurableContext, region: ImageRegion, index: number) => {
    return await ctx.step(`analyze-region-${index}`, async () => {
      const imageBase64 = await fetchImageBase64(event);
      const finding = await analyzeRegion(imageBase64, imageFormat, region);
      await publish(ch, [{ type: 'region', index, status: 'done', finding }]);
      return { regionIndex: finding.regionIndex, regionLabel: finding.regionLabel, analysis: finding.analysis.slice(0, 500), detectedObjects: (finding.detectedObjects ?? []).slice(0, 8), };
    });
  },
  { maxConcurrency: 5 },
);

Jedes Tile wird als eigenständiger Prozess ausgeführt. Die Ergebnisse werden in Echtzeit an ein Dashboard gesendet, das den Fortschritt visualisiert. Bei einem Fehler wird nur das betroffene Tile neu gestartet – die Pipeline läuft weiter, ohne dass das gesamte Bild neu verarbeitet werden muss.

Schritt 3: Zusammenführung der Ergebnisse

Nach Abschluss aller Inferenzen werden die Teilergebnisse zu einem vollständigen Bild zusammengeführt. Dieser Schritt umfasst die Konsolidierung der detektierten Objekte, die Entfernung von Duplikaten und die Erstellung einer semantischen Beschreibung des Bildinhalts.

// Schritt 3: Synthese der Ergebnisse
const synthesis = await context.step('synthesize', () => synthesizeFindings(successfulFindings));

Die Synthesephase ist besonders wichtig, da sie potenzielle Überlappungen zwischen Tiles berücksichtigt. Durch die Verwendung überlappender Slices in der Vorverarbeitung wird sichergestellt, dass Objekte, die an den Rändern zweier Tiles liegen, korrekt erkannt und zugeordnet werden.

Schritt 4: Speicherung und Echtzeit-Dashboard

Die finalen Ergebnisse werden in einer Datenbank gespeichert, während gleichzeitig ein WebSocket-basiertes Dashboard aktualisiert wird. Nutzer:innen erhalten so eine Echtzeit-Visualisierung der analysierten Objekte – inklusive Bounding-Box-Overlays und Klassifizierungen.

// Schritt 4: Speicherung der Ergebnisse
const stored = await context.step('store', async () => {
  // Ergebnisse in DynamoDB speichern und über AppSync an das Dashboard senden
});

Die gesamte Pipeline läuft asynchron und ermöglicht es, auch bei hohen Bildauflösungen eine stabile Performance zu gewährleisten. Durch die Isolierung der Fehlerbehandlung und die parallele Verarbeitung wird die Skalierbarkeit deutlich verbessert.

Fazit: Skalierbare Computer Vision ohne Infrastruktur-Overhead

Die Verarbeitung großer Bilder in Computer-Vision-Pipelines erfordert mehr als nur ein funktionierendes Modell. Der Schlüssel liegt in einer robusten Orchestrierung, die Tiles parallel verarbeitet, Fehler isoliert behandelt und Ergebnisse in Echtzeit visualisiert. Mit AWS Lambda Durable Functions lässt sich eine solche Pipeline in nur zwei Lambda-Funktionen umsetzen – ohne zusätzliche Infrastruktur.

Dieser Ansatz ist nicht nur für die Verarbeitung von 4K-Videoframes oder Whole-Slide-Scans geeignet. Er bietet auch eine stabile Grundlage für zukünftige Erweiterungen, etwa die Integration von KI-Modellen mit höheren Auflösungsanforderungen oder die Verarbeitung von Videostreams in Echtzeit. Die Zukunft der Computer Vision liegt nicht in größeren Modellen, sondern in intelligenteren Orchestrierungssystemen.