में भाग 1 मैने कच्चे पाइपलाइन को दिखाया।

अब यह एक NuGet पैकेज है सेटअप का एक लाइन-, zero मॉडल डाउनलोड - सब कुछ स्वचालित

नोट यह पैकेज छवियों से पाठ और इकाइयों को निकालने के लिए एक सरल युक्ति के लिए केंद्रित है। कुछ भी (photos,documents ,screenshots,handwritingM SK4animated gifs and even videosMST5 with fuzzy matchingM ST6 OCR consensusSST7 and structured extractionS ST8 check out सुदृढ़आरएजी जहां इस पाइपलाइन के उत्पादन की श्रेणी संस्करण रहता है

---

त्वरित शब्दकोश (यदि आप'इसमें नया है

हम में डुबोने से पहले

• ओसीआर ऑप्टिकल अक्षर पहचान
• एनईआर Named Entity Recognition
• ऑनिक्स रनटाइम मशीन सीखने के मॉडल चलाने का एक तरीका .onnx सिर्फ अपने सीपीयू का उपयोग करते हुए
• BERT Google से प्रशिक्षित भाषा मॉडल जो पाठ में संदर्भ को समझता है कोएनएलएमएसके0 व्यक्तियों को पहचानने के लिए डेटा-सेट
• फ्लोरेंस - माइक्रोसॉफ्ट का एक छोटा दृश्य मॉडल है जो यह क्या वर्णन कर सकता है देखना एक छवि में (captionsM SK1 objects, textMSC3 Tesseract से भिन्न है कि यह पूरे दृश्य को समझता है

---

Plain Tesseract से अधिक क्यों

Tesseract साफ दस्तावेज़ पाठ के लिए मजबूत है, लेकिन यह शोरयुक्त फोटो पर गिरता है।

यह पैकेज उन अंतरों को समाप्त करता है

1. छवि आकार पूर्वप्रसंस्करण - ग्रेस्केल
2. ओपन सीवी उन्नत पूर्वप्रसंस्करण - deskewM SK1 denoise, और क्षतिग्रस्त दस्तावेज़ों के लिए द्विआधारी बनाना
3. फ्लोरेंस दृश्य - ONNX के माध्यम से स्थानीय छवि शीर्षक और ओसीआर
4. ओसीआर पाठ के ऊपर BERT NER - निकाली गई पाठ को टाइप किए गए अस्तित्व में बदलें
5. माइक्रोसॉफ्ट नियम-- datesbased extraction of dates, numbers, URLs, phones, emailsM SK6 and IPs
6. उचित डीआई सम्मिलन - AddOcrNer() और आप' कर रहे हैं
7. सीएलआई उपकरण - A SPECTRE.कॉन्सोल कमांड-लाइन एप्लिकेशन जो सिर्फ बॉक्स से बाहर काम करता है

---

भाग से क्या बदला गया 1

flowchart LR
    subgraph Part1["Part 1: Manual"]
        M1[Download models]
        M2[Write tokenizer]
        M3[Wire ONNX]
        M4[BIO decode]
    end

    subgraph Part2["Part 2: NuGet Package"]
        N1["AddOcrNer()"]
        N2[Auto-download]
        N3[ImageSharp + OpenCV]
        N4[Florence-2]
        N5[Recognizers]
        N6[CLI Tool]
    end

    Part1 -->|"packaged into"| Part2

    style N1 stroke:#090,stroke-width:3px
    style N2 stroke:#090,stroke-width:3px
    style N3 stroke:#f60,stroke-width:3px
    style N4 stroke:#f60,stroke-width:3px
    style N5 stroke:#f60,stroke-width:3px
    style N6 stroke:#f60,stroke-width:3px

भाग 1 शैक्षिक था।

---

प्रारंभ हो रहा है

संस्थापित करें

dotnet add package Mostlylucid.OcrNer

पंजीकरण सेवाएँ

AddOcrNer() एक्सटेंशन विधि सब कुछ पंजीकृत करता है: OCR , NERM SK2 संयुक्त पाइपलाइन, फ्लोरेंसMSC4 दृश्यMST5 मॉडल डाउनलोडरMSP6 और छवि प्रीप्रोसेसर

यहाँ से वास्तविक पंजीकरण कोड है ServiceCollectionExtensions.cs:

// Option 1: From appsettings.json (reads the "OcrNer" section)
builder.Services.AddOcrNer(builder.Configuration);

// Option 2: Inline configuration
builder.Services.AddOcrNer(config =>
{
    config.EnableOcr = true;
    config.TesseractLanguage = "eng";
    config.MinConfidence = 0.5f;
});

कि-' यह है-. कोई नमूना डाउनलोड नहीं करता है, , कोई फ़ाइल पथ नहीं देता है,, कोई ONNX तार नहीं होता है AddOcrNer() इन सेवाओं को पंजीकृत करता है

// From ServiceCollectionExtensions.cs - what gets registered
services.AddSingleton<ModelDownloader>();           // Auto-downloads models on first use
services.AddSingleton<ImagePreprocessor>();         // ImageSharp-based image enhancement
services.AddSingleton<OpenCvPreprocessor>();        // OpenCV advanced preprocessing
services.AddSingleton<INerService, NerService>();   // BERT NER from text
services.AddSingleton<IOcrService, OcrService>();   // Tesseract OCR from images
services.AddSingleton<IOcrNerPipeline, OcrNerPipeline>();         // Combined OCR + NER
services.AddSingleton<ITextRecognizerService, TextRecognizerService>(); // Microsoft.Recognizers
services.AddSingleton<IVisionService, VisionService>();           // Florence-2 vision

कॉन्फ़िगरेशन

{
  "OcrNer": {
    "EnableOcr": true,
    "TesseractLanguage": "eng",
    "MinConfidence": 0.5,
    "MaxSequenceLength": 512,
    "ModelDirectory": "models/ocrner",
    "Preprocessing": "Default",
    "EnableAdvancedPreprocessing": false,
    "EnableRecognizers": false,
    "RecognizerCulture": "en-us"
  }
}

यहाँ-' वास्तविक है OcrNerConfig इन नक्शे को वर्गीकृत करें

// From OcrNerConfig.cs
public class OcrNerConfig
{
    public string ModelDirectory { get; set; } =
        Path.Combine(AppContext.BaseDirectory, "models", "ocrner");
    public bool EnableOcr { get; set; } = true;
    public string TesseractLanguage { get; set; } = "eng";
    public int MaxSequenceLength { get; set; } = 512;
    public float MinConfidence { get; set; } = 0.5f;
    public string NerModelRepo { get; set; } = "protectai/bert-base-NER-onnx";
    public PreprocessingLevel Preprocessing { get; set; } = PreprocessingLevel.Default;
    public bool EnableAdvancedPreprocessing { get; set; } = false;  // OpenCV pipeline
    public bool EnableRecognizers { get; set; } = false;            // Microsoft.Recognizers
    public string RecognizerCulture { get; set; } = "en-us";       // Recognizer language
}

सभी सेटिंग में समझदार डिफ़ॉल्ट हैं. आप पूरे खंड को छोड़ सकते हैं और सब कुछ काम करता हैEnableAdvancedPreprocessing और EnableRecognizers) डिफ़ॉल्ट में false इसलिए पैकेज उन उपयोगकर्ताओं के लिए हल्का रहता है जो नहीं need them

Preprocessing विकल्प OCR से पहले छवि वृद्धि को नियंत्रित करता है

मूल्य	क्या करता है
None कोई पूर्वप्रसंस्करण नहीं है	छवियाँ पहले से ही अनुकूलित हैं
Minimal सिर्फ ग्रेस्केल
Default	ग्रेस्केल	+	कंट्रास्ट	+	सस्पष्ट करें
Aggressive Strong contrast + sharpen

---

चार सेवाएँ

पैकेज पांच सेवाओं को पंजीकृत करता है।

flowchart TD
    subgraph Services
        NER["INerService<br>Text → Entities"]
        OCR["IOcrService<br>Image → Text"]
        REC["ITextRecognizerService<br>Text → Signals"]
        PIPE["IOcrNerPipeline<br>Image → Entities + Signals"]
        VIS["IVisionService<br>Image → Caption"]
    end

    OCR --> PIPE
    NER --> PIPE
    REC -.-> PIPE

    style PIPE stroke:#090,stroke-width:3px
    style VIS stroke:#f60,stroke-width:3px
    style REC stroke:#f60,stroke-width:2px,stroke-dasharray: 5 5

अपने उपयोग के लिए सही सेवा का चयन करना

प्रमुख सिद्धांत है दक्षतासबसे हल्का उपकरण चुनें जो कार्य करता है

सेवा	यह क्या करता है
INerService पाठ से	BERT NER
IOcrService छवियों से Tesseract OCR		~4	MB			~100	ms	МSK5	आपको दस्तावेज़ स्कैन से पाठ की आवश्यकता होती है
IOcrNerPipeline एक कॉल में ओसीआर और एनईआर
ITextRecognizerService नियम
IVisionService फ्लोरेंस

---

पाठ से NER

यदि आप के पास पहले से ही पाठ है (पीडीएफ से | , | डाटाबेसों |, | उपयोक्ता इनपुट ), | आप सीधे एनईआर का उपयोग कर सकते हैं

INerService अंतरफलक सरल है

// From INerService.cs
public interface INerService
{
    Task<NerResult> ExtractEntitiesAsync(string text, CancellationToken ct = default);
}

यहाँ यह कैसे अपने सेवा में उपयोग करता है

public class MyService
{
    private readonly INerService _nerService;

    public MyService(INerService nerService)
    {
        _nerService = nerService;
    }

    public async Task ProcessDocumentAsync(string text)
    {
        var result = await _nerService.ExtractEntitiesAsync(text);

        foreach (var entity in result.Entities)
        {
            // entity.Label: "PER", "ORG", "LOC", or "MISC"
            // entity.Text: "John Smith"
            // entity.Confidence: 0.9996
            // entity.StartOffset / EndOffset: character positions in the source
        }
    }
}

परिणाम मॉडल सरल हैं

// From NerResult.cs / NerEntity.cs
public class NerResult
{
    public string SourceText { get; init; } = string.Empty;
    public List<NerEntity> Entities { get; init; } = [];
}

public class NerEntity
{
    public string Text { get; init; } = string.Empty;     // "John Smith"
    public string Label { get; init; } = string.Empty;    // "PER", "ORG", "LOC", "MISC"
    public float Confidence { get; init; }                 // 0.0 to 1.0
    public int StartOffset { get; init; }                  // Where in the source text
    public int EndOffset { get; init; }                    // End position (exclusive)
}

पहला कॉल BERT NER मॉडल को HuggingFace से डाउनलोड करता है

---

OCR + एनईआर पाइपलाइन

छवियों के लिए, पाइपलाइन एक कॉल में पूर्वप्रसंस्करण handles IOcrNerPipeline जोड़ता है IOcrService और INerService:

// From OcrNerPipeline.cs - the actual pipeline code
public async Task<OcrNerResult> ProcessImageAsync(string imagePath, CancellationToken ct = default)
{
    // Step 1: OCR (includes preprocessing automatically)
    var ocrResult = await _ocrService.ExtractTextAsync(imagePath, ct);

    if (string.IsNullOrWhiteSpace(ocrResult.Text))
        return new OcrNerResult
        {
            OcrResult = ocrResult,
            NerResult = new NerResult { SourceText = string.Empty }
        };

    // Step 2: NER on extracted text
    var nerResult = await _nerService.ExtractEntitiesAsync(ocrResult.Text, ct);

    return new OcrNerResult
    {
        OcrResult = ocrResult,
        NerResult = nerResult
    };
}

इसका उपयोग कर रहा है

var pipeline = serviceProvider.GetRequiredService<IOcrNerPipeline>();

var result = await pipeline.ProcessImageAsync("invoice.png");

// What OCR found
var text = result.OcrResult.Text;           // The full extracted text
var confidence = result.OcrResult.Confidence; // 0.0 to 1.0

// What NER found in that text
foreach (var entity in result.NerResult.Entities)
{
    // [PER] John Smith, [ORG] Microsoft, [LOC] Seattle...
}

हूड के नीचे क्या होता है

flowchart LR
    IMG[Image bytes]
    PRE["ImageSharp<br>or OpenCV"]
    TESS["Tesseract<br>OCR"]
    TOK["WordPiece<br>Tokenize"]
    BERT["BERT NER<br>ONNX"]
    REC["Recognizers<br>(optional)"]
    OUT[Result]

    IMG --> PRE
    PRE --> TESS
    TESS --> TOK
    TOK --> BERT
    BERT --> REC
    REC --> OUT

    style PRE stroke:#f60,stroke-width:3px
    style BERT stroke:#f60,stroke-width:3px
    style REC stroke:#f60,stroke-width:2px,stroke-dasharray: 5 5

---

छवि पूर्वप्रसंस्करण

भाग 1 में कच्चे Tesseract कॉल थे. व्यावहारिक रूप सेM SK2 दोनों Tesserac और फ्लोरेंस के साथ बेहतर काम करता है डिफ़ॉल्ट पर लेकिन पूरी तरह से वैकल्पिक - आप यह के साथ अक्षम कर सकते हैं Preprocessing = "None" कॉन्फ़िग या --preprocess none CLI. पर

ImagePreprocessor उपयोग छवि आकार (pure C

// From ImagePreprocessor.cs - the actual preprocessing steps
public byte[] Preprocess(byte[] imageBytes, PreprocessingOptions? options = null)
{
    options ??= PreprocessingOptions.Default;
    using var image = Image.Load<Rgba32>(imageBytes);

    image.Mutate(ctx =>
    {
        // Step 1: Upscale small images (Tesseract wants 300+ DPI equivalent)
        if (options.EnableUpscale && (image.Width < options.MinWidth || image.Height < options.MinHeight))
        {
            var scale = Math.Max(
                (float)options.MinWidth / image.Width,
                (float)options.MinHeight / image.Height);
            scale = Math.Min(scale, options.MaxUpscaleFactor);
            ctx.Resize((int)(image.Width * scale), (int)(image.Height * scale),
                KnownResamplers.Lanczos3);
        }

        // Step 2: Grayscale (single channel = faster, more accurate)
        if (options.EnableGrayscale)
            ctx.Grayscale();

        // Step 3: Contrast boost (text stands out from background)
        if (options.EnableContrast && options.ContrastAmount != 1.0f)
            ctx.Contrast(options.ContrastAmount);

        // Step 4: Sharpen (crisp character edges)
        if (options.EnableSharpen)
            ctx.GaussianSharpen(options.SharpenSigma);
    });

    using var ms = new MemoryStream();
    image.SaveAsPng(ms);  // PNG = lossless, no additional artifacts
    return ms.ToArray();
}

तीन पूर्वनिर्धारित में निर्मित हैं PreprocessingOptions वर्ग उन्हें परिभाषित करता है

// From ImagePreprocessor.cs
public static PreprocessingOptions Default => new();  // Grayscale + 1.5x contrast + sharpen

public static PreprocessingOptions Minimal => new()   // Grayscale only
{
    EnableContrast = false,
    EnableSharpen = false,
    EnableUpscale = false
};

public static PreprocessingOptions Aggressive => new() // For poor quality images
{
    ContrastAmount = 1.8f,
    SharpenSigma = 1.5f,
    MinWidth = 1024,
    MinHeight = 768,
    MaxUpscaleFactor = 4.0f
};

प्रिसेट करें |--------|------------|--------------| | Default अधिकतर छवियाँ | ग्रेस्केल | Minimal साफ स्कैन करें | Aggressive | खराब गुणवत्ता वाली फोटों | | | \ 1.8 | x व्यतिरेक |+ | मजबूत तीक्ष्णता | МSK4 | बड़े पैमाने पर

ओपनसीवी के साथ उन्नत पूर्वप्रसंस्करण

गंभीर रूप से ह्रासग्रस्त दस्तावेजों के लिए - विकृत स्कैन EnableAdvancedPreprocessing एक पूर्ण OpenCV पाइपलाइन से पोर्ट करने के लिए स्विच ImageSummarizerComment.

ओपन सीवी प्रीप्रोसेसर श्रृंखला चार चरणों में चलायी जाती है

flowchart LR
    IMG[Image]
    QA["Quality<br>Assess"]
    SK["Deskew"]
    DN["Denoise"]
    BIN["Binarize"]
    OUT[Clean image]

    IMG --> QA
    QA --> SK
    SK --> DN
    DN --> BIN
    BIN --> OUT

    style QA stroke:#f60,stroke-width:2px

गुणवत्ता मूल्यांकन (ImageQualityAssessorपरिणामों के आधार पर यह सिफारिश करता है कि कौन से चरण लागू किए जाएँ, जिससे साफ छवियाँ अनावश्यक प्रक्रमण को छोड़ दें

डेस्कुCity name (optional, probably does not need a translation) (SkewCorrectorतीन विधियों के उपयोग से घुमाए गए दस्तावेजों को सुधारता है: हाफ लाइन पता लगाना

डेनोइसCity name (optional, probably does not need a translation) (NoiseReducerगॉसियन अस्पष्टता प्रदान करता है।

द्विआयामी (InkExtractor) Otsu के प्रयोग से शुद्ध काला में परिवर्तित करता है।

कॉन्फ़िगरेशन में या CLI: पर इसे सक्षम करें

config.EnableAdvancedPreprocessing = true;

ocrner ocr damaged-scan.png -a

---

माइक्रोसॉफ्ट.Recognizers:RuleM SK2Based Entity Extraction

BERT NER लोग ढूंढता है।

सक्षम करें EnableRecognizers एक दूसरे निष्कर्ष पास का उपयोग करने के लिए जोड़ने माइक्रोसॉफ्ट. यह चलाता है बाद एनईआर और निष्कर्ष

प्रकार | उदाहरण |------|----------| तारीख़ समय संख्या यूआरएल फोन ईमेल आईपी पता

यह पहचानकर्ता बहुविध संस्कारों को समर्थन करता है (enM SK1us, en-gbMST4 deMSC5deMSP6 frMSV7frMSSP8 आदि

config.EnableRecognizers = true;
config.RecognizerCulture = "en-us";

ocrner ner "John Smith joined Microsoft on January 15, 2024. Call 555-1234." -r

दो निष्कर्षन विधि एक-दूसरे को संपूरित करते हैं: BERT NER संदर्भ को समझता है। OcrNerResult मॉडल अब एक वैकल्पिक शामिल है Signals संपत्ति

public class OcrNerResult
{
    public OcrResult OcrResult { get; init; } = new();
    public NerResult NerResult { get; init; } = new();
    public RecognizedSignals? Signals { get; init; }  // Only when EnableRecognizers = true
}

---

फ्लोरेंस

फ्लोरेंस-2 Tesseract से पूरी तरह अलग दृष्टिकोण है। दृष्टि मॉडल जो संपूर्ण छवि को समझता है

// From IVisionService.cs
public interface IVisionService
{
    Task<VisionCaptionResult> CaptionAsync(string imagePath, bool detailed = true,
        CancellationToken ct = default);
    Task<VisionOcrResult> ExtractTextAsync(string imagePath,
        CancellationToken ct = default);
    Task<bool> IsAvailableAsync(CancellationToken ct = default);
}

इसका उपयोग कर रहा है

var vision = serviceProvider.GetRequiredService<IVisionService>();

// Generate a caption describing the image
var caption = await vision.CaptionAsync("photo.jpg", detailed: true);
if (caption.Success)
{
    // caption.Caption: "A man in a blue suit standing at a podium"
    // caption.DurationMs: how long it took
}

// Extract visible text using Florence-2's built-in OCR
var ocrResult = await vision.ExtractTextAsync("screenshot.png");
if (ocrResult.Success)
{
    // ocrResult.Text: the visible text Florence-2 detected
}

जब किसको प्रयोग करना है

उपयोग केस	TesseractIOcrServiceफ्लोरेंसIVisionService)
दस्तावेज़ स्कैन सबसे अच्छा विकल्प - तेजी से , सटीक
चिह्नों के फोटो	सटीक			बेहतर	-	दृश्य संदर्भ को समझता है
स्क्रीनशॉट अच्छी
छवि शीर्षक यह नहीं कर सकता
गति तेजी से
मॉडल आकार

बात है कि दक्षतादस्तावेज़ और पाठ उद्धरण के लिए Tesseract का उपयोग करें (it's \10x एक छोटा मॉडल के साथ अधिक तेजी से समझ.

फ्लोरेंस-2 auto-अपने मॉडलों को डाउनलोड करता है {ModelDirectory}/florence2/.

---

एनईआर पाइपलाइन का आंतरिक कार्य

एनईआर पाइपलाइन एक ही तीन चरण प्रक्रिया का अनुसरण करता है-- भाग 1: चिह्नित करें → inferभाग 1 हर संकल्पना के माध्यम से चलता है | - | WordPiece टोकनाइजेशन |, | ONNX Tensor inference | МSK4 | BIO टैग डेकोडिंग

यहाँ क्या पैकेज हस्तचालित दृष्टिकोण से परे जोड़ता है

ऑफसेट ट्रैकिंग

भाग 1's टोकनाइजर पाठ को टोकन आईडी में बदलता है BertNerTokenizer ट्रैक भी अक्षर ऑफसेट - तो आप जानते हैं कि सही कहाँ स्रोत पाठ में प्रत्येक अस्तित्व पाया गया था

// From BertNerTokenizer.cs
// "John Smith works at Microsoft" becomes:
// [CLS] John Smith works at Micro ##soft [SEP] [PAD] ...
//
// Each token tracks its source position:
// "John"     → chars 0-4
// "Smith"    → chars 5-10
// "Micro"    → chars 20-29  (WordPiece splits "Microsoft")
// "##soft"   → chars 20-29  (same source range)

यह कैसे है NerEntity.StartOffset और EndOffset काम करें - वे आपके मूल पाठ में सही अक्षर स्थिति को वापस मानचित्रित करते हैं

विश्वसनीयता-फिल्टरित इकाई निष्कर्षण

भाग 1's डिकोडर सभी इकाइयां उत्पन्न करता है. पैकेज डिकोडिंग के दौरान फिल्टर करता है

// From NerService.cs
private void FlushEntity(
    List<NerEntity> entities, string text,
    string type, int start, int end, float confidence)
{
    if (confidence < _config.MinConfidence) return;  // Filter low-confidence

    var entityText = text[start..end].Trim();
    if (string.IsNullOrWhiteSpace(entityText)) return;

    entities.Add(new NerEntity
    {
        Text = entityText,
        Label = type,
        Confidence = confidence,
        StartOffset = start,
        EndOffset = end
    });
}

---

Auto-Download: यह कैसे काम करता है

सभी मॉडलों को पहले प्रयोग पर स्वचालित रूप से डाउनलोड करें

flowchart TD
    CALL["First API call"]
    CHECK{"Files exist<br>in cache?"}
    YES[Use cached model]
    NO["Download to .tmp file"]
    MOVE["Atomic rename<br>.tmp → final"]

    CALL --> CHECK
    CHECK -->|Yes| YES
    CHECK -->|No| NO
    NO --> MOVE
    MOVE --> YES

    style NO stroke:#f60,stroke-width:3px
    style MOVE stroke:#090,stroke-width:3px

ModelDownloader HuggingFace से डाउनलोड्स (NER मॉडल) और GitHub (tessdataM SK3 यह एक परमाणु का उपयोग करता है .tmp पैटर्न - यदि एक डाउनलोड विच्छेदित है तो | , | कोई दूषित फ़ाइलें पीछे नहीं छोड़ी जाती हैं

// From ModelDownloader.cs - atomic download pattern
await using var fileStream = new FileStream(tempPath, FileMode.Create,
    FileAccess.Write, FileShare.None, 81920, true);
// ... stream download to .tmp file ...
await fileStream.FlushAsync(ct);
fileStream.Close();

File.Move(tempPath, localPath, overwrite: true);  // Atomic rename

डिफ़ॉल्ट कैश स्थान: {AppBaseDir}/models/ocrner/

models/ocrner/
  ner/
    model.onnx      (~430MB - BERT NER)
    vocab.txt       (~230KB - WordPiece vocabulary)
    config.json     (~1KB - label mapping)
  tessdata/
    eng.traineddata (~4MB - English OCR data)
  florence2/
    ...             (~450MB - Vision model files)

---

वास्तुकला

Everything is a singleton with lazy initialization InferenceSession, TesseractEngine, फ्लोरेंस

flowchart TD
    DI["AddOcrNer()"]

    DI --> MD["ModelDownloader<br>(singleton)"]
    DI --> PP["ImagePreprocessor<br>(singleton)"]
    DI --> CV["OpenCvPreprocessor<br>(singleton)"]
    DI --> NER["NerService<br>(singleton)"]
    DI --> OCR["OcrService<br>(singleton)"]
    DI --> PIPE["OcrNerPipeline<br>(singleton)"]
    DI --> REC["TextRecognizerService<br>(singleton)"]
    DI --> VIS["VisionService<br>(singleton)"]

    MD --> NER
    MD --> OCR
    PP --> OCR
    CV --> OCR
    NER --> PIPE
    OCR --> PIPE
    REC --> PIPE

    style DI stroke:#090,stroke-width:3px

थ्रेड सुरक्षा SemaphoreSlim आरंभीकरण के लिए. पहली बार उपयोग पर सेवा को एक साथ कॉल करने वाले कई थ्रेडों से केवल एक डाउनलोड ट्रिगर होगा

// From NerService.cs - lazy init pattern used by all services
private async Task EnsureInitializedAsync(CancellationToken ct)
{
    if (_initialized) return;           // Fast path: already loaded

    await _initLock.WaitAsync(ct);      // Only one thread enters
    try
    {
        if (_initialized) return;       // Double-check after lock

        var paths = await _downloader.EnsureNerModelAsync(ct);
        _tokenizer = new BertNerTokenizer(paths.VocabPath, _config.MaxSequenceLength);
        _session = new InferenceSession(paths.ModelPath, sessionOptions);
        _initialized = true;
    }
    finally { _initLock.Release(); }
}

---

सीएलआई उपकरणName

रिपो में एक कमांड-लाइन उपकरण के साथ बनाया गया है SPECTRE.कॉन्सोलयह एक सफलता के बिंदु के रूप में डिजाइन किया गया है

त्वरित प्रारंभ

# NER from text (auto-detected)
ocrner "John Smith works at Microsoft in Seattle"

# OCR from an image (auto-detected)
ocrner invoice.png

# Explicit commands
ocrner ner "Marie Curie won the Nobel Prize in Stockholm"
ocrner ocr scan.png
ocrner caption photo.jpg

स्मार्ट रूटिंग: सीएलआई स्वचालित Program.cs:

// From Program.cs - smart routing logic
if (IsImageFile(args2[0]) || IsGlobPattern(args2[0]) || Directory.Exists(args2[0]))
{
    args2 = ["ocr", .. args2];   // Image file → ocr command
}
else
{
    args2 = ["ner", .. args2];   // Text string → ner command
}

यदि आप एक पाठ स्ट्रिंग को पास करते हैं, तो यह NER चलाता है।

तीन कमांड

कमांड |---------|-------------|--------|-------| | ner <text> पाठ से अस्तित्व निकालें | ocr <path> छवियों से NER | OCR | + | Tesseract | caption <path> छवि कैप्सनिंग + वैकल्पिक ओसीआर

Tesseract डिफ़ॉल्ट ओसीआर इंजन है क्योंकि यह अधिक तेजी से और दस्तावेज़ पाठ के लिए अनुकूलित है।

वास्तविक आउटपुट

यहाँ वास्तविक नमूना दस्तावेजों के साथ सीएलआई चलाने से वास्तविक आउटपुट

पाठ से NER

ocrner ner "Marie Curie won the Nobel Prize in Stockholm"

╭──────┬─────────────┬────────────┬──────────╮
│ Type │ Entity      │ Confidence │ Position │
├──────┼─────────────┼────────────┼──────────┤
│ PER  │ Marie Curie │ 100%       │ 0-11     │
│ MISC │ Nobel Prize │ 100%       │ 20-31    │
│ LOC  │ Stockholm   │ 100%       │ 35-44    │
╰──────┴─────────────┴────────────┴──────────╯

पहचानकर्ताओं के साथ एनईआर - BERT इकाइयों को नियम के साथ जोड़ना

ocrner ner "Shelby Lucier from SCS Agency in Cambridge, UK sent an invoice on 13/02/15. Call 07981423683." -r

╭──────┬───────────────┬────────────┬──────────╮
│ Type │ Entity        │ Confidence │ Position │
├──────┼───────────────┼────────────┼──────────┤
│ PER  │ Shelby Lucier │ 100%       │ 0-13     │
│ ORG  │ SCS Agency    │ 100%       │ 19-29    │
│ LOC  │ Cambridge     │ 100%       │ 33-42    │
│ LOC  │ UK            │ 100%       │ 44-46    │
╰──────┴───────────────┴────────────┴──────────╯

── Recognized Signals ─────────────────────────
  Type       Text          Details
  DateTime   13/02/15      datetimeV2.date
  Phone      07981423683

BERT लोगों को ढूंढता है।

स्कैन किए गए दस्तावेज़ से ओसीआर Amazon शेयरधारक का पत्र

ocrner ocr shareholder-letter.jpg -q

╭──────┬───────────────┬────────────┬──────────╮
│ Type │ Entity        │ Confidence │ Position │
├──────┼───────────────┼────────────┼──────────┤
│ ORG  │ Amazon        │ 87%        │ 285-291  │
│ PER  │ Jeff          │ 99%        │ 293-297  │
│ ORG  │ AWS           │ 95%        │ 984-987  │
│ LOC  │ America       │ 98%        │ 2315-2322│
╰──────┴───────────────┴────────────┴──────────╯
OCR Confidence: 89%

टेसरेक्ट ने स्कैन किए गए अक्षर से 89% विश्वसनीयता के पास |, |verbatim पाठ निकाला है और एनईआर Amazon को सही रूप से पहचानता है | , | Jeff | МSK4 | Bezos | ), | AWS |, | तथा उत्तरी अमरीका को

टेसरेक्ट vs फ्लोरेंस-2: एक वास्तविक तुलना

दोनों इंजनों द्वारा प्रक्रमित एक ही स्कैन किया गया शेयरधारक पत्र

Tesseractocrner ocrफ्लोरेंसocrner caption --ocr)
गति
ओसीआर सटीकता निकट
कुंजी पाठ Amazon में पिछले 25 वर्षों के दौरान
एनईआर इकाइयां Jeff (PER),Amazon (ORG),AWS (ORG),America (LOC)	N/A NER(text too garbled for reliable
कैप्सन कुछ पाठ के साथ एक कागज

फ्लोरेंस-2 एक है दृष्टि मॉडल | - | यह दृश्यों को समझता है |, | ऑब्जेक्ट | МSK2 | और अंतरिक्ष संबंध | एमSK3 | इसे कभी भी दस्तावेज पाठ पढ़ने में Tesseract के साथ प्रतिस्पर्धा करने के लिए तैयार नहीं किया गया था | समझ इस फोटो में क्या है उच्छेदन इस दस्तावेज में क्या कहा गया है

स्वचालन के लिए JSON आउटपुट & LLM उपकरण

--json फ्लैग आउटपुट का संरचना JSON से stdout के साथ सभी लॉगिंग दबाया - अन्य उपकरणों में पाइपिंग के लिए डिजाइन किया गया है

ocrner ner "Shelby Lucier from SCS Agency in Cambridge, UK sent an invoice on 13/02/15. Call 07981423683." -r --json

{
  "command": "ner",
  "success": true,
  "sourceText": "Shelby Lucier from SCS Agency in Cambridge, UK...",
  "entityCount": 4,
  "entities": [
    { "type": "PER", "text": "Shelby Lucier", "confidence": 0.9996, "startOffset": 0, "endOffset": 13 },
    { "type": "ORG", "text": "SCS Agency", "confidence": 0.999, "startOffset": 19, "endOffset": 29 },
    { "type": "LOC", "text": "Cambridge", "confidence": 0.9975, "startOffset": 33, "endOffset": 42 },
    { "type": "LOC", "text": "UK", "confidence": 0.9991, "startOffset": 44, "endOffset": 46 }
  ],
  "signals": {
    "dateTimes": [{ "text": "13/02/15", "typeName": "datetimeV2.date" }],
    "phoneNumbers": [{ "text": "07981423683" }]
  }
}

यह CLI एक के रूप में उपयोगीय बनाता है औजार LLMs और एजेंटों के लिए. एक LLM कॉल कर सकता है ocrner ner "..." --json, JSON प्रतिक्रिया को पद वर्णन करें, और संरचनात्मक इकाइयों पर तर्क jqएक एजेंट फ्रेमवर्क में फीड करें

# Pipe to jq for quick filtering
ocrner ocr invoice.png --json | jq '.results[0].entities[] | select(.type == "PER")'

# Use from Python, Node, or any language that can shell out
echo "John Smith at Microsoft" | ocrner ner --json

इसके बजाय फ़ाइल में सहेजने के लिए प्रयोग करें -o के साथ .json एक्सटेंशन - उसी संरचनात्मक डेटा को लिखा गया

ocrner ocr "scans/*.png" -o results.json

बैच प्रक्रमण

ग्लोब पैटर्न या निर्देशिकाओं के साथ बहुविध छवियों को प्रक्रिया करें:

# All PNGs in a directory
ocrner ocr "scans/*.png" -o results.json

# All images in a folder
ocrner ocr ./documents/

# Batch captioning with Florence-2
ocrner caption "photos/*.jpg" --ocr -o captions.md

सभी CLI विकल्प

फ्लैग	के लिए लागू होता है।
--json	ner, ocr, caption Structured JSON to stdout (implies --quietसभी लॉगिंग को दबाता है
-c	ner, ocr न्यूनतम इकाई विश्वास थ्रेसहोल्ड
--language	ocr उदाहरण के लिए eng, fra)
--max-tokens	ner, ocr अधिकतम BERT अनुक्रम लंबाई
--model-dir	ner, ocr, caption मॉडल कैश निर्देशिका अधिरोहित करें
-p, --preprocess	ocr, caption पूर्वप्रसंस्करण पूर्वनिर्धारित none, minimal, default, aggressive
-a, --advanced-preprocess	ocr, caption OpenCV पूर्वप्रसंस्करण का उपयोग करें
-r, --recognizers	ner, ocr नियम सक्षम करें
--culture	ner, ocr	रेकॉन्जिजर संस्कृति en-us, de-de डिफ़ॉल्ट en-us)
--brief	caption एक छोटा बनाएँ
-q, --quiet	ner, ocr, caption कम कंसोल आउटपुट
-o	ner, ocr, caption आउटपुट फ़ाइल पथ.txt, .md, .json)
--ocr	caption क्याप्सन कमांड के दौरान ओसीआर भी चलाएँ
--ner	caption OCR पाठ से NER निकालें --ocr)

---

निष्पादन: क्वांटाइजेड मॉडल और क्या

मौजूदा एनआरई मॉडल पूर्ण '-' मूल्यांक है protectai/bert-base-NER-onnx अधिकतर उपयोग के लिए - विशेष रूप से संसाधन पर | - | सीमित मशीनों या उच्च मात्राओं को प्रसंस्करण करते समय परिमाणित एक ही मॉडल का संस्करण न्यूनतम शुद्धता हानि के साथ उल्लेखनीय रूप से तेजी से होगा

ONNX रनटाइम आउट बाक्स से INT8 क्वांटाइजेशन समर्थित करता है। NerModelRepo कॉन्फ़िग विकल्प पहले से ही एक भिन्न HuggingFace रिपो इंगित करने का समर्थन करता है

{
  "OcrNer": {
    "NerModelRepo": "protectai/bert-base-NER-onnx-quantized"
  }
}

संरचना इस के लिए डिज़ाइन की गई है

---

बड़ी तस्वीर: जहां यह ठीक है

यह पैकेज एक है एकल-- चरण पाइपलाइनएक ओसीआर इंजन1 एक एनईआर मॉडल2 एक वैकल्पिक दृश्य मॉडल3 यह सामान्य केस के लिए सरल और कुशल बनाया गया है

अधिक जटिल परिदृश्यों के लिए - से पाठ पढ़ने कुछ भी (हैन्डरलिखित नोट्स,\बाइलेटबोर्डों के फोटो,\नीच\M SK3\गुणवत्ता कैमरे कैप्चर\MSC4\मल्टीसेंटी के साथ\ -\ इंजिन ओसीआर समझौते से\ MSC6\अस्पष्ट मिलान\ ,\ और संरचनात्मक निष्कर्षण \ M SK8\ पूरी पाइपलाइन पर जाँचें सुदृढ़आरएजीयह है कि इस कार्य के चरण संस्करण में उत्पादन की जगह है

क्या's अगला:मल्टीमोडल एलएलएम

फ्लोरेंस-2 इस पैकेज में स्थानीय दृश्य के लिए मौजूदा छत है बहुमोडल एलएलएम - एक मॉडल जो एक छवि देख सकता है और प्राकृतिक भाषा में इसका कारण

यहाँ roughly what that API could look like

// Hypothetical future IMultimodalService
public interface IMultimodalService
{
    Task<StructuredExtractionResult> ExtractAsync(
        string imagePath,
        string prompt = "Extract all people, organizations, and locations from this image. Return as JSON.",
        CancellationToken ct = default);
}

// Usage
var multimodal = serviceProvider.GetRequiredService<IMultimodalService>();
var result = await multimodal.ExtractAsync("business-card.jpg");

// result.Entities: [{ "John Smith", PER }, { "Acme Corp", ORG }, { "New York", LOC }]
// result.RawText: "John Smith, VP Engineering, Acme Corp, New York, NY 10001"
// result.Summary: "Business card for John Smith at Acme Corp in New York"

लघु स्थानीय बहुमोडल मॉडल (जैसे Phi-3.5-vision या LLaVAइस के लिए पर्याप्त अच्छी हो रही हैं।

flowchart LR
    subgraph Staged["Staged Approach: Pick Your Level"]
        T1["Tesseract OCR<br>4MB | ~100ms<br>Text extraction"]
        T2["BERT NER<br>430MB | ~50ms<br>Entity extraction"]
        T3["Florence-2<br>450MB | ~1-3s<br>Image understanding"]
        T4["Multimodal LLM<br>2-8GB | ~5-30s<br>Full reasoning"]
    end

    T1 --> T2
    T2 --> T3
    T3 -.->|"future"| T4

    style T1 stroke:#090,stroke-width:2px
    style T2 stroke:#090,stroke-width:2px
    style T3 stroke:#f60,stroke-width:2px
    style T4 stroke:#999,stroke-width:2px,stroke-dasharray: 5 5

प्रत्येक स्तर आकार और विलंब की लागत पर क्षमता जोड़ता है सुदृढ़आरएजी शीर्षक है.

---

संसाधन

यह पैकेज:

• Mostlylucid.OcrNer on NuGet - इसे स्थापित करें
• स्रोत कोड - कार्यान्वयन को ब्राउज़ करें

भाग 1:

• सरल ओसीआर और एनईआर विशेषता निष्कर्ष - पाठ्य जो प्रत्येक टुकड़ा समझता है

निर्भरताएं:

• टेसरेक्ट टेसरेक्ट ओसीआर के लिए - CM SK1 रॉपर
• BERT-base-NER ONNX - एनईआर मॉडल
• फ्लोरेंस - दृश्य मॉडल न्यूगेट पैकेज
• छवि आकार - क्रॉस
• OpenCvSharp उन्नत पूर्वप्रसंस्करण के लिए - ओपनसीवी wrapper
• माइक्रोसॉफ्ट - नियम
• ऑनिक्स रनटाइम - क्रॉस-प्लेटफॉर्म मॉडल निष्कर्ष

संबंधित लेख:

• तीन--Tier OCR पाइपलाइन - जब आप सरल ओसीआर से अधिक की जरूरत है
• कम RAG - जहाँ बाहर निकाले गए इकाइयां बड़ी तस्वीर में फिट हो
• सुदृढ़आरएजी - पूर्ण बहुphase पाईपलाइन