Image Summarizer: Un moteur RAG d'images Fuzzy restreint (Français (French))

Image Summarizer: Un moteur RAG d'images Fuzzy restreint

Tuesday, 06 January 2026

//

36 minute read

Comments Raw Edit
AI Architecture DiSE LLM Patterns

Parties 1-3 Description Constrained Fuzziness as an abstract pattern. Cet article applique ces modèles à un pipeline d’analyse de l’image qui démontre les principes en action.

REMARQUE: Il y a toujours un réglage du système . Mais il existe maintenant une version de bureaux ainsi que la CLI. Il fonctionne très bien mais quelques bords pour s'éliminer.

Guide des lecteurs

Cet article sert à plusieurs fins. Naviger vers ce qui vous intéresse

  • Méthodes d'architecture → Voir "Architecture des vagues", "Contract de signatureM SK4 |
  • Détails de l'OCR → Voir Partie 4.1: Pipeline OCR pour des défaillances techniques profondes
  • Utilisation de CLI → Passer à "Le CLIM SK2 En l'utilisant"
  • Caractéristiques du GUI → Voir la section "Desktop GUIM SK2
  • Mise en œuvre → Exemples de code dans l'ensemble , source complète sur GitHub

Écart de mouvement

ImageSummarizer est un pipeline d'ingestion RAG pour les images qui extrait des métadonnées structurées, texteM SK1 captions, et des signaux visuels en utilisant une architecture basée sur les ondes-. Le système élargit de l’analyse locale rapide à des LLM Vision seulement lorsqu’il est nécessaire

Principes clés:

  • Aucune autonomie (les modèles ne déterminent jamais les voies d’exécutionM SK1
  • Aucun état naturel-de langue M SK1les signaux sont typés , pas de prose)
  • Les modèles proposent des signaux; La politique déterministe décide ce qui persiste

ImageSummarizer démontre que les LLM multimodaux peuvent être utilisés sans renoncer au déterminisme. La règle de base: probabilité propose, le déterminisme persiste.

Règles de conception

  • Les modèles ne consomment jamais les autres modèles' prose
  • La langue naturelle n'est jamais un état
  • L'évacuation est un seuil déterministe
  • Chaque sortie porte la confiance + provenance

Licence: Non-licence Relâche Établissement .NET

Ce qu'elle fait

Le pipeline extrait des métadonnées structurées provenant d'images pour les systèmes RAG. Étant donné toute image ou un GIF animé, il produit

  • Texte extrait (threeM SK1tier OCR: Tesseract → FlorenceMSC4 ONNX → Vision LLM fallbackMST6
  • Palette de couleurs (computée, non suggéréeM SK2
  • Mesures de qualité (sharpness, blurM SK2 exposureMSC3
  • Classification du type (Photo, ScreenshotM SK2 DiagrammeMSC3 Meme )
  • Analyse du mouvement (pour les images animéesM SK1
  • Caption facultative (FlorenceM SK1 local ou Vision LLM, restreint par des faits computésMSC3
  • Emplacements sémantiques (pour la recherche par vecteur)

Le mot clé est Structure. Tous les produits ont des cotes de confiance , l’attribution de la source M SK2 et des indicateurs d’éléments probants . Aucun modèle n’est la seule source de vérité MSC4

Trois-Tier Stratégie d’OCR

La plongée profonde: Le pipeline OCR est suffisamment complexe pour justifier son article propre. Partie 4.1: Les trois pipelines d'OCR pour la répartition technique complète incluant EAST, CRAFTM SK1 Real-ESRGAN , CLIPMSC4 et l'optimisation des pistes de filmsMNK5

Le système utilise une stratégie d’escalade de trois niveaux pour l’extraction des textes.

Niveau MSC1 Méthode SMC2 vitesse MSC3 coût SMC4 le meilleur pour ESC5
1 Tesseract ~50ms SMK2 En fr.
2 Florence-2 ONNX
3 Vision LLM ~1-5s

Routage intelligent

Détection du texte de l'ONNX (OUEST, CRAFT, ~20-30ms) détermine la voie optimaleM SK3

  • Route FAST: FlorenceM SK1 seulement (~100ms)
  • Route BALANCEDVote Tesseract (~300msM SK4
  • Route de QUALITÉ: Analyse de cadres multiples - analyse d'images multidimensionnelles

Appui aux modèles ONNX

  • Real-ESRGAN: 4× super-résolution pour des images de qualité faibleM SK3images de qualité inférieure
  • CLIP: Emplacements sémantiques pour la recherche d'images

Résultat: ~1.16GB de modèles locaux d'ONNX qui gèrent des images sans coûts API85%+

Voir en action

Détection des mouvements & Analyse de l'animation

Petit chat sur le couch

$ imagesummarizer demo-images/cat_wag.gif --pipeline caption --output text
Caption: A cat is sitting on a white couch.
Scene: indoor
Motion: MODERATE object_motion motion (partial coverage)

Les phrases de mouvement ne sont émises que lorsqu'elles sont appuyées par des mesures du débit optique et des deltas d'images.

Mémo & Extraction des sous-titres

Méme de l'anchorman

$ imagesummarizer demo-images/anchorman-not-even-mad.gif --pipeline caption --output text
"I'm not even mad."
"That's amazing."
Caption: A person wearing grey turtleneck sweater with neutral expression
Scene: meme
Motion: SUBTLE general motion (localized coverage)

Le sous-titre-aware frame deduplication détecte les changements du texte dans le bas M SK1 des cadres, pondération des pixels brillants (whiteMSC4yellow textMNK5 plus fortementMRK6

Technologie de la bande-cadre

Pour les GIF animés avec sous-titres, l'outil crée des bandes de cadre horizontales pour l'analyse Vision LLM

Texte- Seulement bande (NEWM SK1 - ≥30× réduction des cotes de monnaie

Le mode le plus efficace extrait uniquement des boîtes de bounding texte, réduisant considérablement les coûts du token:

Texte- Seulement bande

$ imagesummarizer export-strip demo-images/anchorman-not-even-mad.gif --mode text-only
Detecting subtitle regions (bottom 30%)...
  Found 2 unique text segments
Saved text-only strip to: anchorman-not-even-mad_textonly_strip.png
  Dimensions: 253×105 (83% token reduction)
Approche Dimensions
Encadrements complets (10) 3 4 5 6 Haut 7
bande d'OCR (2 cadres) ≥600×185
Texte-seulement bande 253×105 ~50 Faible

Comment cela fonctionne: OpenCV détecte les régions de sous-titre (bottom 30%), thresholds bright pixels MSC3whiteMSC4yellow text), extractes tight bounding boxesM SK6 and deduplicates based on text changesMNK7 Le Vision LLM reçoit uniquement les région de texteMRK8 préservant tout le contenu des sous-titles tout en éliminant les pixels de fondMMK9

Mode OCR Écart (changes de texte seulement - MSC2 cadres réduits à MSC3 cadre

La bande OCR

$ imagesummarizer export-strip demo-images/anchorman-not-even-mad.gif --mode ocr
Deduplicating 93 frames (OCR mode - text changes only)...
  Reduced to 2 unique text frames
Saved ocr strip to: anchorman-not-even-mad_ocr_strip.png
  Dimensions: 600x185 (2 frames)

Mode de mouvement bande (keyframes pour l'inférence du mouvementM SK1

Écart de mouvement

$ imagesummarizer export-strip demo-images/cat_wag.gif --mode motion --max-frames 6
Extracting 6 keyframes from 9 frames (motion mode)...
  Extracted 6 keyframes for motion inference
Saved motion strip to: cat_wag_motion_strip.png
  Dimensions: 3000x280 (6 frames)

Cela permet aux LLM Vision de lire tous les textes sous-titres dans un seul appel API, améliorant considérablement l’exactitude des mémes et du contenu captioné tout en réduisant au minimum l’utilisation des tokens.

Pourquoi ne pas simplement la mentionner?

Ce modèle bat "just caption it with a frontier model" for the same reason an XMSC2ray beats narrationMST3 the model is never asked to fill gapsMst4 It receives a closed ledgerMSt5measured colorsM st6 tracked motionM St7 deduped subtitle framesMstr8 OCR confidenceM ST9and renders only what the substrate already contains M st10 When GPTM sct11o captions an imageM S t12 itm s t13s guessingM sc14 When ImageSummarizer doesM se t15 it‘M s t16s summarizing signals that already existM স t17

L'architecture de la vague

Le système utilise un pipeline basée sur les ondes où chaque onde est un analyseur indépendant qui produit des signaux types. Les ondes sont exécutées dans l’ordre de priorité (un nombre inférieur est exécuté le premier ), et les ondes plus récentes peuvent lire les signaux des dernières

Ordonnance d'exécution: La vague 10 se déroule avant la vague

flowchart TB
    subgraph Wave10["Wave 10: Foundational Signals"]
        W1[IdentityWave - Format, dimensions]
        W2[ColorWave - Palette, saturation]
    end

    subgraph Wave40["Wave 40: Text Detection"]
        W9[TextLikelinessWave - OpenCV EAST/CRAFT]
    end

    subgraph Wave50["Wave 50: Traditional OCR"]
        W3[OcrWave - Tesseract]
    end

    subgraph Wave51["Wave 51: ML OCR"]
        W8[MlOcrWave - Florence-2 ONNX]
    end

    subgraph Wave55["Wave 55: ML Captioning"]
        W10[Florence2Wave - Local captions]
    end

    subgraph Wave58["Wave 58: Quality Gate"]
        W5[OcrQualityWave - Escalation decision]
    end

    subgraph Wave70["Wave 70: Embeddings"]
        W7[ClipEmbeddingWave - Semantic vectors]
    end

    subgraph Wave80["Wave 80: Vision LLM"]
        W6[VisionLlmWave - Cloud fallback]
    end

    Wave10 --> Wave40 --> Wave50 --> Wave51 --> Wave55 --> Wave58 --> Wave70 --> Wave80

    style Wave10 stroke:#22c55e,stroke-width:2px
    style Wave40 stroke:#06b6d4,stroke-width:2px
    style Wave50 stroke:#f59e0b,stroke-width:2px
    style Wave51 stroke:#8b5cf6,stroke-width:2px
    style Wave55 stroke:#8b5cf6,stroke-width:2px
    style Wave58 stroke:#ef4444,stroke-width:2px
    style Wave70 stroke:#3b82f6,stroke-width:2px
    style Wave80 stroke:#8b5cf6,stroke-width:2px

Ordre de priorité (la basse est la première à courirM SK1 10 | | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15

Il s'agit de MoM Fuzzy restreint Application à l'analyse d'images: plusieurs proposers publient sur un substrat partagé (le AnalysisContext), et la sortie finale regroupe leurs signaux

Les vagues clés

  • Écoule de la similitude des textes (NEWM SK1 OpenCV EAST/CRAFT détection du texte (~5-20msMSC4 détermine les décisions de routage
  • OcrWave: OCR traditionnel de Tesseract pour texte propre (Tier ≥1)
  • MlOcrWave: FlorenceM SK1 ONNX fonctionne localement (~200ms), manipule les caractères stylisés
  • Florence2Wave: Caption locale du ML lorsque Vision LLM n’est pas requise'
  • OcrQualityWave: SpellM SK1check gate, détermine la voie d'escalade
  • VisionLlmWave: CloudM SK1based Vision LLM, ne fonctionne que lorsque les vagues antérieures échouent ou signalent une faible confiance.

Note sur l'ordonnance des ondes: Les trois OCR Niveaux Les niveaux d’escalade conceptuelle sont les suivants : (Tesseract /FlorenceM SK2Vision LLM)Les ondes individuelles comme Advanced OCR ou Quality Gate a) Élaboration d'un programme de perfectionnement à l’intérieur de ces niveaux, ne comportent pas des niveaux d’escalade distincts —effectuent des vérifications de stabilisation temporelle et de qualitéM SK2 respectivement.

Le contrat de signalisation

Chaque onde produit des signaux en utilisant un contrat normalisé:

public record Signal
{
    public required string Key { get; init; }      // "color.dominant", "ocr.quality.is_garbled"
    public object? Value { get; init; }             // The measured value
    public double Confidence { get; init; } = 1.0;  // 0.0-1.0 reliability score
    public required string Source { get; init; }    // "ColorWave", "VisionLlmWave"
    public DateTime Timestamp { get; init; }        // When produced
    public List<string>? Tags { get; init; }        // "visual", "ocr", "quality"
    public Dictionary<string, object>? Metadata { get; init; }  // Additional context
}

Il s’agit de la partie 2 contrat de signaux en action . Les ondes ne parlent pas les uns avec les autres par le biais du langage naturel

Notez que Confidence est per-signalM SK1 non pas par-onde . Une seule onde peut émettre plusieurs signaux avec une force épistémique différenteMSC4ColorWaveMNK5 sa liste de couleurs dominantes a confiance MRK6 MNK7 calculéeMMK8 mais les pourcentages individuels de couleur utilisent la confiance comme facteur de pondération pour la sommation en avalMEK9

La confiance signifie fiabilité pour l'utilisation en avalLes signaux déterministes sont reproduits.

Avertissement du déterminisme: "Deterministe" signifie qu'il n'y a pas d'échantillonnage aléatoire et de résultats stables pour un temps d'exécution donné et une configuration donnéeM SK3 Les fournisseurs d'exploitation GPU ONNX peuvent introduire des variations numériques mineuresMSC4 acceptables pour les décisions de routage.

Taxonomie des signaux OCR

Pour éviter la confusion, ici' est le nom de domaine canonique du signal OCR utilisé dans tout le systèmeM SK2

clé de signalisation source
ocr.text Tesseract (Tier MSC2 MSC3 Singles bruts SMC4frame OCR SMC5
ocr.confidence Tesseract
ocr.ml.text FlorenceM SK1 (Tier MSC3 \MSC4 ML OCR single-frame \ MSC6
ocr.ml.multiframe_text FlorenceM SK1 (Tier 2) | Multi-frame GIF OCR SSK6préféré pour les animations
ocr.ml.confidence Note de confiance
ocr.quality.spell_check_score OcrQualityWave Spell déterministeM SK2 rapport de vérification
ocr.quality.is_garbled OcrQualityWave Signal d'escalade boulaire
ocr.vision.text VisionLlmWave (Tier MSC2 MSC3 Extraction de l'OCR du vision LLM SMC4
caption.text VisionLlmWave Caption descriptive MSC2 séparée du OCR

Distinction importante: ocr.vision.text est extraction de texte (OCRM SK1 pendant caption.text est description de la scène (captioningM SK1 Les deux peuvent provenir du même appel de vision LLM , mais servir à des fins différentes .

Priorité de la sélection finale du texte (la plus élevée à la plus basse

  1. ocr.vision.text (Vision LLM OCR
  2. ocr.ml.multiframe_text (Florence-2 GIFM SK2
  3. ocr.ml.text (FlorenceM SK1 unique-frameMSC3
  4. ocr.text (Tesseract)

L'interface de la vague

Chaque onde applique une interface simple:

public interface IAnalysisWave
{
    string Name { get; }
    int Priority { get; }           // Lower number = runs earlier (10 before 50 before 80)
    IReadOnlyList<string> Tags { get; }

    Task<IEnumerable<Signal>> AnalyzeAsync(
        string imagePath,
        AnalysisContext context,    // Shared substrate with earlier signals
        CancellationToken ct);
}

L'article 5 de la Loi sur l'immigration et le statut des réfugiés AnalysisContext est la espace de consensus de la partie 2. Cannes d'écoulementM SK1

  • Lire les signaux des ondes antérieures: context.GetValue<bool>("ocr.quality.is_garbled")
  • Accès aux résultats intermédiaires cachés: context.GetCached<Image<Rgba32>>("ocr.frames")
  • Ajouter de nouveaux signaux que les ondes en aval peuvent consommer

ColorWave: La fondation déterministe

ColorWave effectue la première (priorité 10) et calcule les faits qui restreignent tout le reste

public class ColorWave : IAnalysisWave
{
    public string Name => "ColorWave";
    public int Priority => 10;  // Runs first (lowest priority number)
    public IReadOnlyList<string> Tags => new[] { "visual", "color" };

    public async Task<IEnumerable<Signal>> AnalyzeAsync(
        string imagePath,
        AnalysisContext context,
        CancellationToken ct)
    {
        var signals = new List<Signal>();

        using var image = await LoadImageAsync(imagePath, ct);

        // Extract dominant colors (computed, not guessed)
        var dominantColors = _colorAnalyzer.ExtractDominantColors(image);
        signals.Add(new Signal
        {
            Key = "color.dominant_colors",
            Value = dominantColors,
            Confidence = 1.0,  // Reproducible measurement
            Source = Name,
            Tags = new List<string> { "color" }
        });

        // Individual colors for easy access
        for (int i = 0; i < Math.Min(5, dominantColors.Count); i++)
        {
            var color = dominantColors[i];
            signals.Add(new Signal
            {
                Key = $"color.dominant_{i + 1}",
                Value = color.Hex,
                Confidence = color.Percentage / 100.0,
                Source = Name,
                Metadata = new Dictionary<string, object>
                {
                    ["name"] = color.Name,
                    ["percentage"] = color.Percentage
                }
            });
        }

        // Cache the image for other waves (no need to reload)
        context.SetCached("image", image.CloneAs<Rgba32>());

        return signals;
    }
}

La Vision LLM reçoit plus tard ces couleurs comme b) Constraints. Il ne devrait pas revendiquer que l'image présente des rouges vibrants "" si ColorWave a calculé que la couleur dominante est bleue

OcrQualityWave: The Escalation Gate

C'est là où Fuzziness restreinte . OcrQualityWave est la Constrainer qui décide s’il convient d’élargir à Vision LLM:

public class OcrQualityWave : IAnalysisWave
{
    public string Name => "OcrQualityWave";
    public int Priority => 58;  // Runs after OCR waves
    public IReadOnlyList<string> Tags => new[] { "content", "ocr", "quality" };

    public async Task<IEnumerable<Signal>> AnalyzeAsync(
        string imagePath,
        AnalysisContext context,
        CancellationToken ct)
    {
        var signals = new List<Signal>();

        // Get OCR text from earlier waves (canonical taxonomy)
        string? ocrText =
            context.GetValue<string>("ocr.ml.multiframe_text") ??  // Florence-2 GIF
            context.GetValue<string>("ocr.ml.text") ??             // Florence-2 single
            context.GetValue<string>("ocr.text");                  // Tesseract

        if (string.IsNullOrWhiteSpace(ocrText))
        {
            signals.Add(new Signal
            {
                Key = "ocr.quality.no_text",
                Value = true,
                Confidence = 1.0,
                Source = Name
            });
            return signals;
        }

        // Tier 1: Spell check (deterministic, no LLM)
        var spellResult = _spellChecker.CheckTextQuality(ocrText);

        signals.Add(new Signal
        {
            Key = "ocr.quality.spell_check_score",
            Value = spellResult.CorrectWordsRatio,
            Confidence = 1.0,
            Source = Name,
            Metadata = new Dictionary<string, object>
            {
                ["total_words"] = spellResult.TotalWords,
                ["correct_words"] = spellResult.CorrectWords
            }
        });

        signals.Add(new Signal
        {
            Key = "ocr.quality.is_garbled",
            Value = spellResult.IsGarbled,  // < 50% correct words
            Confidence = 1.0,
            Source = Name
        });

        // This signal triggers Vision LLM escalation
        if (spellResult.IsGarbled)
        {
            signals.Add(new Signal
            {
                Key = "ocr.quality.correction_needed",
                Value = true,
                Confidence = 1.0,
                Source = Name,
                Tags = new List<string> { "action_required" },
                Metadata = new Dictionary<string, object>
                {
                    ["quality_score"] = spellResult.CorrectWordsRatio,
                    ["correction_method"] = "llm_sentinel"
                }
            });

            // Cache for Vision LLM to access
            context.SetCached("ocr.garbled_text", ocrText);
        }

        return signals;
    }
}

La décision d'escalade est déterministe: si le résultat de la vérification de l'orthographe < 50%, émet un signal qui déclenche la vision LLMM SK3 Aucun jugement probabiliste. Non " peut-être que nous devrions demander au LLM

Évacuation en action

Arse Biscuits

$ imagesummarizer demo-images/arse_biscuits.gif --pipeline caption --output text
OCR: "ARSE BISCUITS"
Caption: An elderly man dressed as bishop with text reading "arse biscuits"
Scene: meme

OCR a obtenu le texte; Vision LLM fournit le contexte de la scène. Chaque vague contribue à ce qu’elle faitM SK2 est bon à .

VisionLlmWave: Le promoteur restreint

La vague Vision LLM ne fonctionne que lorsque les signaux antérieurs l’indiquent's nécessaires. Et lorsqu’elle fonctionne, , elleM SK3 est restreinte par des faits computésMSC4

public class VisionLlmWave : IAnalysisWave
{
    public string Name => "VisionLlmWave";
    public int Priority => 50;  // Runs after quality assessment
    public IReadOnlyList<string> Tags => new[] { "content", "vision", "llm" };

    public async Task<IEnumerable<Signal>> AnalyzeAsync(
        string imagePath,
        AnalysisContext context,
        CancellationToken ct)
    {
        var signals = new List<Signal>();

        if (!Config.EnableVisionLlm)
        {
            signals.Add(new Signal
            {
                Key = "vision.llm.disabled",
                Value = true,
                Confidence = 1.0,
                Source = Name
            });
            return signals;
        }

        // Check if OCR was unreliable (garbled text)
        var ocrGarbled = context.GetValue<bool>("ocr.quality.is_garbled");
        var textLikeliness = context.GetValue<double>("content.text_likeliness");
        var ocrConfidence = context.GetValue<double>("ocr.ml.confidence",
            context.GetValue<double>("ocr.confidence"));

        // Only escalate when: OCR failed OR (text likely but low OCR confidence)
        // Models never decide paths; deterministic signals do (no autonomy)
        bool shouldEscalate = ocrGarbled ||
                              (textLikeliness > 0.7 && ocrConfidence < 0.5);

        if (shouldEscalate)
        {
            var llmText = await ExtractTextAsync(imagePath, ct);

            if (!string.IsNullOrEmpty(llmText))
            {
                // Emit OCR signal (Vision LLM tier)
                signals.Add(new Signal
                {
                    Key = "ocr.vision.text",  // Vision LLM OCR extraction
                    Value = llmText,
                    Confidence = 0.95,  // High but not 1.0 - still probabilistic
                    Source = Name,
                    Tags = new List<string> { "ocr", "vision", "llm" },
                    Metadata = new Dictionary<string, object>
                    {
                        ["ocr_was_garbled"] = ocrGarbled,
                        ["escalation_reason"] = ocrGarbled ? "quality_gate_failed" : "low_confidence_high_likeliness",
                        ["text_likeliness"] = textLikeliness,
                        ["prior_ocr_confidence"] = ocrConfidence
                    }
                });

                // Optionally emit caption (separate signal)
                var llmCaption = await GenerateCaptionAsync(imagePath, ct);
                if (!string.IsNullOrEmpty(llmCaption))
                {
                    signals.Add(new Signal
                    {
                        Key = "caption.text",  // Descriptive caption (not OCR)
                        Value = llmCaption,
                        Confidence = 0.90,
                        Source = Name,
                        Tags = new List<string> { "caption", "description" }
                    });
                }
            }
        }

        return signals;
    }
}

Le point de vue clé: Vision Le texte LLM a la confiance 0.95, non 1.0. Celle-ci ' est meilleure que l’OCR endommagée, mais c’est encore probabilisteM SK4 L’agrégation en aval sait ce qui suitMST5 MST6 Pourquoi ? avoir une valeur qui n’est pas't 1.0.)

Le livret: Synthèse restreinte

L'article 5 de la Loi sur l'immigration et le statut des réfugiés ImageLedger accumule les signaux dans des sections structurées pour la consommation en aval. Traçage du contexte Application à l'analyse d'images:

public class ImageLedger
{
    public ImageIdentity Identity { get; set; } = new();
    public ColorLedger Colors { get; set; } = new();
    public TextLedger Text { get; set; } = new();
    public MotionLedger? Motion { get; set; }
    public QualityLedger Quality { get; set; } = new();
    public VisionLedger Vision { get; set; } = new();

    public static ImageLedger FromProfile(DynamicImageProfile profile)
    {
        var ledger = new ImageLedger();

        // Text: Priority order - corrected > voting > temporal > raw
        ledger.Text = new TextLedger
        {
            ExtractedText =
                profile.GetValue<string>("ocr.final.corrected_text") ??  // Tier 2/3 corrections
                profile.GetValue<string>("ocr.voting.consensus_text") ?? // Temporal voting
                profile.GetValue<string>("ocr.full_text") ??             // Raw OCR
                string.Empty,
            Confidence = profile.GetValue<double>("ocr.voting.confidence"),
            SpellCheckScore = profile.GetValue<double>("ocr.quality.spell_check_score"),
            IsGarbled = profile.GetValue<bool>("ocr.quality.is_garbled")
        };

        // Colors: Computed facts, not guessed
        ledger.Colors = new ColorLedger
        {
            DominantColors = profile.GetValue<List<DominantColor>>("color.dominant_colors") ?? new(),
            IsGrayscale = profile.GetValue<bool>("color.is_grayscale"),
            MeanSaturation = profile.GetValue<double>("color.mean_saturation")
        };

        return ledger;
    }

    public string ToLlmSummary()
    {
        var parts = new List<string>();

        parts.Add($"Format: {Identity.Format}, {Identity.Width}x{Identity.Height}");

        if (Colors.DominantColors.Count > 0)
        {
            var colorList = string.Join(", ",
                Colors.DominantColors.Take(5).Select(c => $"{c.Name}({c.Percentage:F0}%)"));
            parts.Add($"Colors: {colorList}");
        }

        if (!string.IsNullOrWhiteSpace(Text.ExtractedText))
        {
            var preview = Text.ExtractedText.Length > 100
                ? Text.ExtractedText[..100] + "..."
                : Text.ExtractedText;
            parts.Add($"Text (OCR, {Text.Confidence:F0}% confident): \"{preview}\"");
        }

        return string.Join("\n", parts);
    }
}

Le compteur est le attachement en termes de CFCD. Il permet d’avancer ce qui a survécu à la sélection , et la synthèse du LLM doit tenir compte de ces faits

La décision d'évacuation

Vous avez vu la logique de l’escalade à deux endroits. OcrQualityWave émissions signals sur la qualité; EscalationService s'applique Politique sur ces signaux. Il s’agit d’une séparation intentionnelleM SK1

  • Wave- escalation locale: Chaque onde émet des faits sur son domaine.
  • Service- escalation de niveau: EscalationService agrégat les signaux et applique des seuils globaux

L'article 5 de la Loi sur l'immigration et le statut des réfugiés EscalationService Il met en œuvre le modèle de la partie 1 substrat → proposer → constrainer:

public class EscalationService
{
    private bool ShouldAutoEscalate(ImageProfile profile)
    {
        // Escalate if type detection confidence is low
        if (profile.TypeConfidence < _config.ConfidenceThreshold)
            return true;

        // Escalate if image is blurry
        if (profile.LaplacianVariance < _config.BlurThreshold)
            return true;

        // Escalate if high text content
        if (profile.TextLikeliness >= _config.TextLikelinessThreshold)
            return true;

        // Escalate for complex diagrams or charts
        if (profile.DetectedType is ImageType.Diagram or ImageType.Chart)
            return true;

        return false;
    }
}

Chaque décision d'escalade est déterministe: les mêmes intrants , les sames seuils M SK2 la même décision . Aucun jugement LLM dans la logique de l’escalade MSC4

La vision LLM Prompt: Constraints de preuve

Lorsque le Vision LLM fonctionne, il reçoit les faits calculés en tant que contraintes.

private static string BuildVisionPrompt(ImageProfile profile)
{
    var prompt = new StringBuilder();

    prompt.AppendLine("CRITICAL CONSTRAINTS:");
    prompt.AppendLine("- Only describe what is visually present in the image");
    prompt.AppendLine("- Only reference metadata values provided below");
    prompt.AppendLine("- Do NOT infer, assume, or guess information not visible");
    prompt.AppendLine();

    prompt.AppendLine("METADATA SIGNALS (computed from image analysis):");

    if (profile.DominantColors?.Any() == true)
    {
        prompt.Append("Dominant Colors: ");
        var colorDescriptions = profile.DominantColors
            .Take(3)
            .Select(c => $"{c.Name} ({c.Percentage:F0}%)");
        prompt.AppendLine(string.Join(", ", colorDescriptions));

        if (profile.IsMostlyGrayscale)
            prompt.AppendLine("  → Image is mostly grayscale");
    }

    prompt.AppendLine($"Sharpness: {profile.LaplacianVariance:F0} (Laplacian variance)");
    if (profile.LaplacianVariance < 100)
        prompt.AppendLine("  → Image is blurry or soft-focused");

    prompt.AppendLine($"Detected Type: {profile.DetectedType} (confidence: {profile.TypeConfidence:P0})");

    prompt.AppendLine();
    prompt.AppendLine("Use these metadata signals to guide your description.");
    prompt.AppendLine("Your description should be grounded in observable facts only.");

    return prompt.ToString();
}

La vision LLM ne devrait pas revendiquer "les couleurs vibrantes " si nous avons calculé une échelle grise-si elle le faitM SK3 la contradiction est détectableMSC4 Elle ne devrait ni revendiqué "les détails précisMNK6si nous avons compté une faible variance de LaplacianMMK7si celle-ci l’a fait MNK8nous pouvons rejeter la sortieMRK9 Le substrat déterministe limite la sortie probabiliste.

Ces contraintes réduisent les hallucinations, mais ne peuvent pas les éliminer.

Priorité du texte de sortie

Lors de l'extraction du texte final,, le système utilise un ordre strict de priorité:

static string? GetExtractedText(DynamicImageProfile profile)
{
    // Priority chain using canonical signal names (see OCR Signal Taxonomy above)
    //   1. Vision LLM OCR (best for complex/garbled)
    //   2. Florence-2 multi-frame GIF (temporal stability)
    //   3. Florence-2 single-frame (stylized fonts)
    //   4. Tesseract (baseline)

    var visionText = profile.GetValue<string>("ocr.vision.text");
    if (!string.IsNullOrEmpty(visionText))
        return visionText;

    var florenceMulti = profile.GetValue<string>("ocr.ml.multiframe_text");
    if (!string.IsNullOrEmpty(florenceMulti))
        return florenceMulti;

    var florenceText = profile.GetValue<string>("ocr.ml.text");
    if (!string.IsNullOrEmpty(florenceText))
        return florenceText;

    return profile.GetValue<string>("ocr.text") ?? string.Empty;
}

Remarque: Il s’agit d’une source unique , mais le livret expose toutes les sources de provenance profile.Ledger.Signals pour voir tous les essais OCR et leurs points de confiance.

Chaque source a une fiabilité connue:

  • Vision LLM: Le meilleur pour les scènes complexesM SK1 diagrammes, schémas ( confiance 0.95, coût élevéMSC5
  • Florence-2: Bon pour les caractères stylisésM SK1 fonctionne localement ( confiance
  • Vote Tesseract: Reliable pour un texte propre
  • Tesseract brut: Recul de base ( Confiance < M0.7 pour les caractères stylisés)

L’ordre prioritaire encode ces connaissances. Florence -2 siégeant entre Vision LLM et Tesseract fournit un M SK2point succulent" pour la plupart des imagesMSC4 meilleur que les OCR traditionnellesMST5 moins cher que les LLM de vision nuageuseMst6

Note: cette fonction sélectionne un source, mais le livret expose tous Sources avec leurs cotes de confiance. Les consommateurs en aval peuventM SK1et devraient -inspecter la provenance lorsque le domaine l’exige. L’ordre prioritaire est un défaut sensibleMSC4 non pas une courroie d’étranglement

Sélection et résolution des conflits

La chaîne de priorité ci-dessus est la mise en oeuvre actuelle-un simple retour d’échec. Mais l’architecture appuie l’ajout de règles de rejet sous forme de configuration -politique dirigéeM SK3 VoiciMSC4le modèle pour la détection des contradictions MNK5pas encore mis en œuvreMRK6 mais les signaux existent à l’appui de celle-ci MNK7

// Pattern: Contradiction detection as policy rules
public static class SelectionPolicy
{
    public static string? SelectTextWithConstraints(DynamicImageProfile profile)
    {
        var visionText = profile.GetValue<string>("vision.llm.text");
        if (!string.IsNullOrEmpty(visionText))
        {
            // Rule: Reject if Vision claims text but deterministic signals say no text
            var textLikeliness = profile.GetValue<double>("content.text_likeliness");
            if (textLikeliness < _config.TextLikelinessThreshold && visionText.Length > 50)
            {
                // Contradiction detected - log and fall through
                profile.AddSignal(new Signal
                {
                    Key = "selection.vision_rejected",
                    Value = "text_likeliness_contradiction",
                    Confidence = 1.0,
                    Source = "SelectionPolicy",
                    Metadata = new Dictionary<string, object>
                    {
                        ["text_likeliness"] = textLikeliness,
                        ["vision_text_length"] = visionText.Length,
                        ["threshold"] = _config.TextLikelinessThreshold
                    }
                });
                // Fall through to OCR sources
            }
            else
            {
                return visionText;
            }
        }

        // Continue with priority chain...
        return profile.GetValue<string>("ocr.voting.consensus_text")
            ?? profile.GetValue<string>("ocr.full_text");
    }
}

Le même schéma s’applique aux autres types de signaux:

  • Contradiction de couleur: Rejetez la sous-titre revendiquant : color.is_grayscale est vrai
  • Contradiction de précision: Rejetez la sous-titre revendiquant : quality.sharpness < seuil
  • Type de contradiction: Rejetez la caption revendiquant "une personneM SK2 si content.type est un diagramme avec une grande confiance

Les propriétés clés de la couche de sélection:

  • Chaîne de priorités: Chacune des sources a un ordre de retour défini, non adM SK2 sélection ponctuelle
  • Porte de qualité en amont: Le OCR est accepté lorsque la porte déterministe indique qu’elle n’est pas endommagée '
  • Point d'extension: Les règles de contradiction sont conduites par config- et mises à jour comme toute autre politique.
  • Voie de vérification: Les rejets émettent des signaux avec des valeurs observées et des seuils

C'est là où "le déterminisme persiste " devient mécaniquement vraiM SK2 Le LLM propose;les règles déterministes décident s'il convient d'accepter

Configuration du pipeline JSON

Les pipelines sont entièrement configurables par JSON, ce qui rend la composition des vagues explicite et vérifiable:

{
  "name": "advancedocr",
  "displayName": "Advanced OCR (Default)",
  "description": "Multi-frame temporal OCR with stabilization and voting",
  "estimatedDurationSeconds": 2.5,
  "accuracyImprovement": 25,
  "phases": [
    {
      "id": "color",
      "name": "Color Analysis",
      "priority": 100,
      "waveType": "ColorWave",
      "enabled": true
    },
    {
      "id": "simple-ocr",
      "name": "Simple OCR",
      "priority": 60,
      "waveType": "OcrWave",
      "earlyExitThreshold": 0.98
    },
    {
      "id": "advanced-ocr",
      "name": "Advanced Multi-Frame OCR",
      "priority": 59,
      "waveType": "AdvancedOcrWave",
      "dependsOn": ["simple-ocr"],
      "parameters": {
        "maxFrames": 30,
        "ssimThreshold": 0.95,
        "enableVoting": true
      }
    },
    {
      "id": "quality",
      "name": "OCR Quality Assessment",
      "priority": 58,
      "waveType": "OcrQualityWave",
      "dependsOn": ["advanced-ocr"]
    }
  ]
}

Les seuils de sortie précoces permettent d’éviter les vagues coûteuses lorsque des vagues bon marché ont déjà atteint une confiance élevée.

Le pipeline automatisé: Routage intelligent

L'article 5 de la Loi sur l'immigration et le statut des réfugiés auto pipeline implements smart routing based on image characteristics, selecting the optimal processing path:

Image Analysis (OpenCV ~5-20ms)
    │
    ├── Is animated (>1 frame)?
    │   └── ANIMATED route
    │       ├── Has subtitle regions? → Text-only strip extraction
    │       ├── Minimal text? → FAST (Florence-2 only)
    │       └── Motion significant? → Motion analysis
    │
    ├── Has text regions (OpenCV detection)?
    │   ├── High contrast, clean text → FAST route (Florence-2, ~100ms)
    │   ├── Moderate confidence → BALANCED route (Florence-2 + Tesseract, ~300ms)
    │   └── Low confidence → QUALITY route (Multi-frame + Vision LLM, ~1-5s)
    │
    ├── Is chart/diagram (type detection)?
    │   └── QUALITY route → Vision LLM caption
    │
    └── Default → FAST route (Florence-2 caption)

Rendement des routes

Route Triggers quand MSC2 Traitement MSC3 Temps SMC4 Coût SMC5
FAST Texte simpleM SK2 contraste élevé, caractères standard MSC4 FlorenceMSC5 seulement SMC6 ESC7ms SEC8 bas USC9localS MC10 \USC11
BALANCED MSC1 Texte normalMSc2 confiance modérée MSC3 FlorenceMS C4 SMC5 Vote Tesseract USC6 \USC7ms USC8 Faible OSC9localeUSSC10
QUALITÉ DiagrammesM SK2 diagrammes, caractères stylisésMNK4 faible confiance multi - cadre S+ Vision LLM SNK8 PSNK9s ESNK10 Moyenne USK11 APIMSNK12 \USK13
ANIMATED GIFs avec sous-titres MSC2 TexteMSc3carte unique MSC4cartes de films SMC5 ESC6s USC7 Moyen OSC8APIES C9 \USC10\

Exemple réelle: Choix d'autoroute

$ imagesummarizer anchorman-not-even-mad.gif --pipeline auto --output visual
[Route selection...]
  Image: 300×185, 93 frames
  Text detection: 15 regions found (bottom 30%)
  Subtitle pattern: DETECTED
  → Selected ANIMATED route (text-only filmstrip)

[Processing...]
  MlOcrWave: Extracted 10 frames → 2 unique text segments
  Text-only strip: 253×105 (83% token reduction)
  VisionLlmWave: Processing filmstrip...

[Results - 2.3s total]
Text: "I'm not even mad." + "That's amazing."
Caption: A person wearing grey turtleneck sweater with neutral expression
Scene: meme
Motion: SUBTLE general motion

La décision de routage est déterministe et enregistrée dans les signaux pour la vérification:

{
  "routing": {
    "selected_route": "ANIMATED",
    "reason": "subtitle_pattern_detected",
    "text_regions": 15,
    "frames": 93,
    "decision_time_ms": 18
  }
}

L’utilisation du CLI:

Usage de base

# Use auto pipeline (smart routing - recommended)
imagesummarizer meme.gif --pipeline auto

# Fast local caption with Florence-2 ONNX (~200ms)
imagesummarizer photo.jpg --pipeline florence2

# Best quality: Florence-2 + Vision LLM
imagesummarizer complex-diagram.png --pipeline florence2+llm

# Extract text only (three-tier OCR)
imagesummarizer screenshot.png --pipeline advancedocr

# Motion analysis for GIFs
imagesummarizer animation.gif --pipeline motion

# Process a directory with visual output
imagesummarizer ./photos/ --output visual

Collectes de signaux

Demander uniquement les signaux dont vous avez besoin en utilisant des collections prédéfinies-:

# Minimal metadata (fast)
imagesummarizer image.png --signals "@minimal"

# Alt text for accessibility
imagesummarizer image.png --signals "@alttext"

# Motion analysis
imagesummarizer animation.gif --signals "@motion"

# Full analysis
imagesummarizer image.png --signals "@full"

# Custom wildcard patterns
imagesummarizer image.png --signals "color.dominant*, ocr.text, motion.*"
Collection Systèmes MSC2 Case d'utilisation MSC3
@minimal identitéM SK1*, qualitéM SK1 précision Profil rapide seulement MSC3
@alttext sous-titre .texte, ocrM SK3textesMST4 couleurMSC5dominant* Accessibilité
@motion motionM SK1*,identitéM SK1frame_count Analyse de l'animation MSC4
@full Tous les signaux
@tool Sous-ensemble optimisé MCP

Résultats réels de JSON

$ imagesummarizer princess-bride.gif --output json

{
  "image": "princess-bride.gif",
  "duration_ms": 1838,
  "waves_executed": ["ColorWave", "OcrWave", "AdvancedOcrWave", "VisionLlmWave"],
  "text": {
    "value": "You keep using that word.\nI do not think it means what you think it means.",
    "source": "ocr.voting.consensus_text",
    "confidence": 0.95
  },
  "escalation": {
    "triggered": true,
    "reason": "text_likeliness_above_threshold",
    "threshold": 0.4,
    "observed": 0.67
  },
  "signals": {
    "color.dominant_1": { "value": "#1a1a2e", "confidence": 1.0 },
    "ocr.quality.spell_check_score": { "value": 0.82, "confidence": 1.0 },
    "ocr.quality.is_garbled": { "value": false, "confidence": 1.0 },
    "motion.type": { "value": "static", "confidence": 0.95 }
  }
}

Chaque champ a sa provenance. Le escalation affiches de bloc pourquoi la vision LLM était appelée.

Analyse du mouvement

Alan Shrug

$ imagesummarizer demo-images/alanshrug_opt.gif --pipeline motion
Motion: SUBTLE general motion (localized coverage)
Direction: up-down
Magnitude: 0.23

Mode interactif

$ imagesummarizer
ImageSummarizer Interactive Mode
Pipeline: advancedocr | Output: auto | LLM: auto
Commands: /help, /pipeline, /output, /llm, /model, /ollama, /models, /quit

Enter image path (or drag & drop): F:\Gifs\meme.gif
Processing...
I'm not even mad. That's amazing.

Enter image path: /llm true
Vision LLM: enabled

Enter image path: /model minicpm-v:8b
Vision model: minicpm-v:8b

GUI de bureau

Pour l’exploration visuelle,, l’application de bureau fournit

  • Drag & interface de chute: Déposer des images pour l'analyse immédiate
  • Log des signaux en direct: Les ondes d'observation sont exécutées en temps réel- avec coloration de confiance
  • Indicateurs de l'état du modèle: Système de signalisation routière (🟢 Préparé, 🟡 TraitementM SK4 ≥🔴 Défaut
  • Préview GIF animé: Voir la génération de bandes et l'extraction des cadres
  • Inspecteur des signaux: Cliquez sur un signal pour voir la provenance complète et les métadonnées
  • Sélectionneur de pipeline: Changer entre les modes d'action automatiquesM SK1florence2/qualité /motion
  • Options d'exportation: Copie des signaux comme JSON, sauvegarder les bandes de filmsM SK2 texte d'exportation

Le GUI de bureau démontre l'architecture visuellement— vous pouvez voir exactement quelles vagues ont été lancées, quels signaux elles ont émis , et comment les décisions d'acheminement ont été prisesM SK3 parfait pour comprendre le système ou débuger des pipelines personnalisés

Le CLI expose toute la complexité sous forme d’options simples. Vous pouvez changer les pipelinesM SK1 les modèles , et les formats de sortie sans comprendre l’architecture des vagues.

Où les patrons apparaissent

Partie Pattern Mise en œuvre de l'imageSummarizer M
1 Fuzziness restreinte ColorWave calcule les faits
2 MoM Fuzzy restreint Publier plusieurs vagues à l'analyseContexteM SK1 Coordonnées de l'orchestreur d'onde
3 Traçage du contexte ImageLedger accumule des caractéristiques saillantesM SK1 SignalDatabase caches results

Les mêmes patrons. Domaine différent. Règle identiqueM SK2 probabilité propose, le déterminisme persiste.

Ce que vous obtiez

  • RAG- sortie prête: JSON structuré avec cotes de confiance
  • Local-premier traitement: FlorenceM SK1 ONNX fonctionne localement (~200ms), aucun coût d'API pour la plupart des images
  • Routage intelligent: La conduite automatique sélectionne la voie optimale (FASTMSC2BALANCEDM SK3QUALITY)
  • Efficacité des symboles: TexteM SK1seulement les bandes atteignent une réduction de symbole 30× pour les sous-titres GIF
  • Décisions vérifiées: Chaque escalation a une raison explicite de provenance
  • Modèle-agnostique: Swap Ollama for OpenAI or Anthropic without changing architecture
  • Caché par contenu: La même image = la même analyseM SK2 même si rebaptisée ( Cache SQLite, SSK5 saisies par msMSC6
  • GUI de bureau: DragM SK1and-drop interface avec visualisation de signaux en direct
  • Mode de serveur MCP: Intégrer avec n'importe quel LLM qui supporte le protocole de contexte modèle.
  • API basé sur le signal-: Demander seulement ce dont vous avez besoin en utilisant des modèles de cartes sauvages ou des collections

Quels sont les coûts?

  • Dépenses cognitives: Vous devez comprendre le contrat de signalisation , les priorités des vagues M SK2 et la logique de l’escalade avant d’écrire une seule vague . Cela punit le malentendu
  • Disciplin de spécificité: Chacune des clés de signalement a besoin d’une définition claire . Chacun des points de confiance a besoin de la justification M SK2 Vous ne pouvez pas donner à quelqu’un - une vague.
  • Per-complexité des ondes: Chacune des vagues a sa propre configuration , cas de bord M SK2 modes d'échec . le débugging se produit au niveau de la vague MNK4 non au niveau du pipeline MMK5
  • Superficie d'essai: Plus de composants signifie plus d’essais . Déplacer le contexte M SK2 Assurer les signaux , Vérifier les voies d’escalade
  • Investissements anticipés: Vous définissez les ondesM SK1 les signaux , et la structure du livret avant de voir les résultats. La rémunération arrive plus tardMSC4

Ce n’est pas le chemin rapide. C’est le chemin fiable' . vaut la peine si vous avez besoin d’une compréhension de l’image vérifiable à grande échelleM SK3 surkill si vous n’avez que besoin de titres pour une galerie de photosMSC4

Modes de défaillance et comment cela les aborde

Mode de défaillance Qu'arrive-t-il ?
Noisy GIF Jitter du cadreM SK1 Artifacts de compression Stabilisation temporelle MSC3 Déduplication SSIM MSC4 Consens de vote SMC5 texte MSc6 extraction uniquement en bandes ESC7
OCR retourne les ordures Tesseract échoue sur les caractères stylisés Spell-check gate detects < \ 50% correct LLM de vision si encore médiocre
Coûts élevés de l'API Trop d'appels de Cloud Vision LLM Florence-2 ONNX gère MSC3 localement MSC4ms), texte MSc6seulement les bandes réduisent les tokens SMC7 pour les GIF SMC8
Hallucinations visuelles LLM réclame un texte qui n’est pas ' il n’y a pas de texte MSC2 Les signaux permettent la détection des contradictions MSC3 le modèle montré ci-dessus MSc4 les consommateurs en aval peuvent comparervision.llm.text contre content.text_likeliness
Changements du pipeline au fil du temps Nouvelles vagues ajoutéesM SK1 seuils ajustés Contenu- cache de l'hash CSK4 provenance complète dans chaque signal MCSK5 suivi de la version C
Modèle ne retourne rien Échéance de vision LLM ou réponse vide Chaîne d'amorçage MSC2 Vision LLM MSC3 Florence SMC4 SMC5 Vote Tesseract ESC6 OCR brut ESC7 ordre prioritaire garantit une dégradation graceuse OSC8

Chaque mode de défaillance a une réponse déterministe. Aucune dégradation silencieuse.

La plus grande image: Multi-Graphique modulaire RAG

Contexte important: ImageSummarizer est le pipeline d'ingestion de l'image pour l’écosystème LucidRAG.

Cet article se concentre sur l’extraction de signaux structurés des images. Mais le pouvoir réel apparaît lorsqu’il est combiné avec les autres résuméeurs:

  • DocSummarizer - Analyse de documents structurés
  • Système de gestion des données - Profilage des données de tableaux (CSVM SK2 bases de données)
  • ImageSummarizer (le présent articleM SK1 - Analyse des images et de l'animation

Lorsqu'ils sont associés à LucidRAG (à court termeM SK1 Ces trois pipelines permettent graphe multi-modal RAG:

Document → DocSummarizer → Structured signals
    ↓
Images → ImageSummarizer → Structured signals
    ↓
Data → DataSummarizer → Structured signals
    ↓
    ↓ (all signals)
    ↓
LucidRAG Graph Builder → Multi-modal knowledge graph
    ↓
Query → Multi-modal retrieval + constrained generation

Pourquoi cela est important?: Le RAG traditionnel traite les images comme des blobs opaques qui sont sous-titrés. sources de signaux de première classe- avec les relations entre le type et le texte, donnéesM SK1 et autres images . Les mêmes principes de détermination, échelle différenteMSC4

L'échelle du modèle: s'il est possible d'extraire des signaux structurés à partir d'images.DocSummarizer), et données (Système de gestion des données), vous pouvez construire un graphique de connaissances où chaque node porte une provenance et chaque bord a des notes de confiance.

Arrivée bientôt: Intégration LucidRAG complète montrant comment ces pipelines se composent en plusieurs graphes de RAG modauxM SK1Requêtes RAG modales. Les mêmes principes architecturaux , Substrait unifié du signalMSC4

Conclusion

L'architecture est structurée: chaque vague est indépendante , chaque signal est inséré, chaque escalation est déterministeM SK3 FlorenceMSC4 fournit une analyse locale rapideMST5 Vision LLM gère des cas complexesMSL6 mais aucun n'agit sans contraintes MST7 les signaux déterministes ancrent toujours la sortieMSP8

Depuis la publication initiale de l’article, le système a beaucoup évolué.

  • Florence-2 intégration ONNX réduit les coûts et la latence de l’API (~200ms local par rapport à ~1-5s cloud
  • Texte-seulement des pistes de films Réduction du symbole 30× pour les sous-titres GIF
  • Ligne de conduite automatique sélectionne le trajet optimal en fonction des caractéristiques de l'image
  • Collectes de signaux simplifier les cas d'utilisation communautaires (@alttext, @motionM SK3
  • GUI de bureau fournit une analyse de drag-et-drop avec visualisation du signal en direct

Le pipeline OCR seul, —, avec ses trois niveaux d’évacuation,-, ,, multi, M SK3 et le vote encadré de la ,, ainsi que l’optimisation des bandes de films et du texte,, et -, exclusivement à l’extraction de bandes,MSC7, est devenu suffisamment complexe pour justifier son article détaillé. Vision Intégration de l'OCR Guide pour la ventilation technique intégrale.

Si vous pouvez le faire pour les images—le type d'entrée le plus meurtrieux, avec bruit de l'OCRMSC2les caractères stylisés ,les cadres animésM SK4 et les hallucinationsMSSK5les titres propensesMST6vous pouvez le réaliser pour n'importe quel élément probabilisteMSS7

Que's Constrained Fuzziness in practice . Not an abstract pattern. Working codeM SK3

Ressources

Référentiel

Outil CLI

Bibliothèque de base

Articles connexes

La série

Partie Pattern MSC2 Axe MSC3
1 Fuzziness restreinte Composante unique
2 MoM Fuzzy restreint Composantes multiples
3 Traçage du contexte Temps / mémoire
4 Intelligence de l'image (le présent article) Architecture des vagues, patrons
4.1 Le pipeline Three-Tier OCR OCRM SK1 Modèles ONNX, bandes de films

Suivant: Partie 5 montrera comment ImageSummarizer DocSummarizer, et Système de gestion des données composer en graphe multi-modal RAG avec LucidRAG.

Toutes les parties suivent la même invariante: Les composantes probabilistes proposent; les systèmes déterministes persistent.

Finding related posts...
logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.