# सबसे अधिक स्पष्ट .OcrNer | - | NuGet पैकेज [![न्यूगेटGenericName](https://img.shields.io/nuget/v/Mostlylucid.OcrNer)](https://www.nuget.org/packages/Mostlylucid.OcrNer/) [![नूगेट डाउनलोड्स](https://img.shields.io/nuget/dt/Mostlylucid.OcrNer)](https://www.nuget.org/packages/Mostlylucid.OcrNer/) [![GitHub प्रकाशन (CLI)](https://img.shields.io/github/v/release/scottgal/mostlylucidweb?filter=ocrner-*&label=CLI)](https://github.com/scottgal/mostlylucidweb/releases?q=ocrner) में [भाग 1](/blog/simple-ocr-ner-extraction) मैने कच्चे पाइपलाइन को दिखाया। अब यह एक NuGet पैकेज है **सेटअप का एक लाइन-, zero मॉडल डाउनलोड** - सब कुछ स्वचालित > **नोट** यह पैकेज छवियों से पाठ और इकाइयों को निकालने के लिए एक सरल युक्ति के लिए केंद्रित है। *कुछ भी* (photos,documents ,screenshots,handwritingM SK4animated gifs and even videosMST5 with fuzzy matchingM ST6 OCR consensusSST7 and structured extractionS ST8 check out [***सुदृढ़*आरएजी**](https://www.lucidrag.com) जहां इस पाइपलाइन के उत्पादन की श्रेणी संस्करण रहता है [TOC] --- ## त्वरित शब्दकोश (यदि आप'इसमें नया है हम में डुबोने से पहले - **ओसीआर** ऑप्टिकल अक्षर पहचान - **एनईआर** Named Entity Recognition - **ऑनिक्स रनटाइम** मशीन सीखने के मॉडल चलाने का एक तरीका `.onnx` सिर्फ अपने सीपीयू का उपयोग करते हुए - **BERT** Google से प्रशिक्षित भाषा मॉडल जो पाठ में संदर्भ को समझता है [कोएनएलएमएसके0](https://www.clips.uantwerpen.be/conll2003/ner/) व्यक्तियों को पहचानने के लिए डेटा-सेट - **फ्लोरेंस** - माइक्रोसॉफ्ट का एक छोटा दृश्य मॉडल है जो यह क्या वर्णन कर सकता है *देखना* एक छवि में (captionsM SK1 objects, textMSC3 Tesseract से भिन्न है कि यह पूरे दृश्य को समझता है --- ## Plain Tesseract से अधिक क्यों Tesseract साफ दस्तावेज़ पाठ के लिए मजबूत है, लेकिन यह शोरयुक्त फोटो पर गिरता है। यह पैकेज उन अंतरों को समाप्त करता है 1. **[छवि आकार](https://sixlabors.com/products/imagesharp/) पूर्वप्रसंस्करण** - ग्रेस्केल 2. **[ओपन सीवी](https://opencv.org/) उन्नत पूर्वप्रसंस्करण** - deskewM SK1 denoise, और क्षतिग्रस्त दस्तावेज़ों के लिए द्विआधारी बनाना 3. **[फ्लोरेंस](https://huggingface.co/microsoft/Florence-2-base)** दृश्य - ONNX के माध्यम से स्थानीय छवि शीर्षक और ओसीआर 4. **ओसीआर पाठ के ऊपर BERT NER** - निकाली गई पाठ को टाइप किए गए अस्तित्व में बदलें 5. **[माइक्रोसॉफ्ट](https://github.com/microsoft/Recognizers-Text)** नियम-- datesbased extraction of dates, numbers, URLs, phones, emailsM SK6 and IPs 6. **उचित डीआई सम्मिलन** - `AddOcrNer()` और आप' कर रहे हैं 7. **सीएलआई उपकरण** - A [SPECTRE.कॉन्सोल](https://spectreconsole.net/) कमांड-लाइन एप्लिकेशन जो सिर्फ बॉक्स से बाहर काम करता है --- ## भाग से क्या बदला गया 1 ```mermaid 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 शैक्षिक था। --- ## प्रारंभ हो रहा है ### संस्थापित करें ```bash dotnet add package Mostlylucid.OcrNer ``` ### पंजीकरण सेवाएँ `AddOcrNer()` एक्सटेंशन विधि सब कुछ पंजीकृत करता है: OCR , NERM SK2 संयुक्त पाइपलाइन, फ्लोरेंसMSC4 दृश्यMST5 मॉडल डाउनलोडरMSP6 और छवि प्रीप्रोसेसर यहाँ से वास्तविक पंजीकरण कोड है `ServiceCollectionExtensions.cs`: ```csharp // 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()` इन सेवाओं को पंजीकृत करता है ```csharp // From ServiceCollectionExtensions.cs - what gets registered services.AddSingleton(); // Auto-downloads models on first use services.AddSingleton(); // ImageSharp-based image enhancement services.AddSingleton(); // OpenCV advanced preprocessing services.AddSingleton(); // BERT NER from text services.AddSingleton(); // Tesseract OCR from images services.AddSingleton(); // Combined OCR + NER services.AddSingleton(); // Microsoft.Recognizers services.AddSingleton(); // Florence-2 vision ``` ### कॉन्फ़िगरेशन ```json { "OcrNer": { "EnableOcr": true, "TesseractLanguage": "eng", "MinConfidence": 0.5, "MaxSequenceLength": 512, "ModelDirectory": "models/ocrner", "Preprocessing": "Default", "EnableAdvancedPreprocessing": false, "EnableRecognizers": false, "RecognizerCulture": "en-us" } } ``` यहाँ-' वास्तविक है `OcrNerConfig` इन नक्शे को वर्गीकृत करें ```csharp // 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 --- ## चार सेवाएँ पैकेज पांच सेवाओं को पंजीकृत करता है। ```mermaid flowchart TD subgraph Services NER["INerService
Text → Entities"] OCR["IOcrService
Image → Text"] REC["ITextRecognizerService
Text → Signals"] PIPE["IOcrNerPipeline
Image → Entities + Signals"] VIS["IVisionService
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` अंतरफलक सरल है ```csharp // From INerService.cs public interface INerService { Task ExtractEntitiesAsync(string text, CancellationToken ct = default); } ``` यहाँ यह कैसे अपने सेवा में उपयोग करता है ```csharp 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 } } } ``` परिणाम मॉडल सरल हैं ```csharp // From NerResult.cs / NerEntity.cs public class NerResult { public string SourceText { get; init; } = string.Empty; public List 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`: ```csharp // From OcrNerPipeline.cs - the actual pipeline code public async Task 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 }; } ``` इसका उपयोग कर रहा है ```csharp var pipeline = serviceProvider.GetRequiredService(); 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... } ``` ### हूड के नीचे क्या होता है ```mermaid flowchart LR IMG[Image bytes] PRE["ImageSharp
or OpenCV"] TESS["Tesseract
OCR"] TOK["WordPiece
Tokenize"] BERT["BERT NER
ONNX"] REC["Recognizers
(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 ```csharp // From ImagePreprocessor.cs - the actual preprocessing steps public byte[] Preprocess(byte[] imageBytes, PreprocessingOptions? options = null) { options ??= PreprocessingOptions.Default; using var image = Image.Load(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` वर्ग उन्हें परिभाषित करता है ```csharp // 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](https://github.com/scottgal/lucidrag). ओपन सीवी प्रीप्रोसेसर श्रृंखला चार चरणों में चलायी जाती है ```mermaid flowchart LR IMG[Image] QA["Quality
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: पर इसे सक्षम करें ```csharp config.EnableAdvancedPreprocessing = true; ``` ```bash ocrner ocr damaged-scan.png -a ``` --- ## माइक्रोसॉफ्ट.Recognizers:RuleM SK2Based Entity Extraction BERT NER लोग ढूंढता है। सक्षम करें `EnableRecognizers` एक दूसरे निष्कर्ष पास का उपयोग करने के लिए जोड़ने [माइक्रोसॉफ्ट](https://github.com/microsoft/Recognizers-Text). यह चलाता है **बाद** एनईआर और निष्कर्ष प्रकार | उदाहरण |------|----------| तारीख़ समय संख्या यूआरएल फोन ईमेल आईपी पता यह पहचानकर्ता बहुविध संस्कारों को समर्थन करता है (enM SK1us, en\-gbMST4 deMSC5deMSP6 frMSV7frMSSP8 आदि ```csharp config.EnableRecognizers = true; config.RecognizerCulture = "en-us"; ``` ```bash ocrner ner "John Smith joined Microsoft on January 15, 2024. Call 555-1234." -r ``` दो निष्कर्षन विधि एक-दूसरे को संपूरित करते हैं: BERT NER संदर्भ को समझता है। `OcrNerResult` मॉडल अब एक वैकल्पिक शामिल है `Signals` संपत्ति ```csharp 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 से पूरी तरह अलग दृष्टिकोण है। **दृष्टि मॉडल** जो संपूर्ण छवि को समझता है ```csharp // From IVisionService.cs public interface IVisionService { Task CaptionAsync(string imagePath, bool detailed = true, CancellationToken ct = default); Task ExtractTextAsync(string imagePath, CancellationToken ct = default); Task IsAvailableAsync(CancellationToken ct = default); } ``` इसका उपयोग कर रहा है ```csharp var vision = serviceProvider.GetRequiredService(); // 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 } ``` ### जब किसको प्रयोग करना है उपयोग केस | Tesseract`IOcrService`फ्लोरेंस`IVisionService`) | |----------|--------------------------|-------------------------------| | **दस्तावेज़ स्कैन** सबसे अच्छा विकल्प - तेजी से , सटीक | **चिह्नों के फोटो** | सटीक | | | बेहतर |- | दृश्य संदर्भ को समझता है | **स्क्रीनशॉट** अच्छी | | **छवि शीर्षक** यह नहीं कर सकता | **गति** तेजी से | **मॉडल आकार** | बात है कि **दक्षता**दस्तावेज़ और पाठ उद्धरण के लिए Tesseract का उपयोग करें (it's \10x एक छोटा मॉडल के साथ अधिक तेजी से *समझ*. फ्लोरेंस-2 auto-अपने मॉडलों को डाउनलोड करता है `{ModelDirectory}/florence2/`. --- ## एनईआर पाइपलाइन का आंतरिक कार्य एनईआर पाइपलाइन एक ही तीन चरण प्रक्रिया का अनुसरण करता है-- [भाग 1](/blog/simple-ocr-ner-extraction): **चिह्नित करें → infer**भाग 1 हर संकल्पना के माध्यम से चलता है | - | WordPiece टोकनाइजेशन |, | ONNX Tensor inference | МSK4 | BIO टैग डेकोडिंग यहाँ क्या पैकेज हस्तचालित दृष्टिकोण से परे जोड़ता है ### ऑफसेट ट्रैकिंग भाग 1's टोकनाइजर पाठ को टोकन आईडी में बदलता है `BertNerTokenizer` ट्रैक भी **अक्षर ऑफसेट** - तो आप जानते हैं कि सही कहाँ स्रोत पाठ में प्रत्येक अस्तित्व पाया गया था ```csharp // 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 डिकोडर सभी इकाइयां उत्पन्न करता है. पैकेज डिकोडिंग के दौरान फिल्टर करता है ```csharp // From NerService.cs private void FlushEntity( List 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: यह कैसे काम करता है सभी मॉडलों को पहले प्रयोग पर स्वचालित रूप से डाउनलोड करें ```mermaid flowchart TD CALL["First API call"] CHECK{"Files exist
in cache?"} YES[Use cached model] NO["Download to .tmp file"] MOVE["Atomic rename
.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` पैटर्न - यदि एक डाउनलोड विच्छेदित है तो | , | कोई दूषित फ़ाइलें पीछे नहीं छोड़ी जाती हैं ```csharp // 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/` ```text 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`, फ्लोरेंस ```mermaid flowchart TD DI["AddOcrNer()"] DI --> MD["ModelDownloader
(singleton)"] DI --> PP["ImagePreprocessor
(singleton)"] DI --> CV["OpenCvPreprocessor
(singleton)"] DI --> NER["NerService
(singleton)"] DI --> OCR["OcrService
(singleton)"] DI --> PIPE["OcrNerPipeline
(singleton)"] DI --> REC["TextRecognizerService
(singleton)"] DI --> VIS["VisionService
(singleton)"] MD --> NER MD --> OCR PP --> OCR CV --> OCR NER --> PIPE OCR --> PIPE REC --> PIPE style DI stroke:#090,stroke-width:3px ``` थ्रेड सुरक्षा `SemaphoreSlim` आरंभीकरण के लिए. पहली बार उपयोग पर सेवा को एक साथ कॉल करने वाले कई थ्रेडों से केवल एक डाउनलोड ट्रिगर होगा ```csharp // 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.कॉन्सोल](https://spectreconsole.net/)यह एक सफलता के बिंदु के रूप में डिजाइन किया गया है ### त्वरित प्रारंभ ```bash # 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`: ```csharp // 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 ` पाठ से अस्तित्व निकालें | `ocr ` छवियों से NER | OCR | + | Tesseract | `caption ` छवि कैप्सनिंग + वैकल्पिक ओसीआर **Tesseract डिफ़ॉल्ट ओसीआर इंजन है** क्योंकि यह अधिक तेजी से और दस्तावेज़ पाठ के लिए अनुकूलित है। ### वास्तविक आउटपुट यहाँ वास्तविक नमूना दस्तावेजों के साथ सीएलआई चलाने से वास्तविक आउटपुट **पाठ से NER** ```bash ocrner ner "Marie Curie won the Nobel Prize in Stockholm" ``` ```text ╭──────┬─────────────┬────────────┬──────────╮ │ Type │ Entity │ Confidence │ Position │ ├──────┼─────────────┼────────────┼──────────┤ │ PER │ Marie Curie │ 100% │ 0-11 │ │ MISC │ Nobel Prize │ 100% │ 20-31 │ │ LOC │ Stockholm │ 100% │ 35-44 │ ╰──────┴─────────────┴────────────┴──────────╯ ``` **पहचानकर्ताओं के साथ एनईआर** - BERT इकाइयों को नियम के साथ जोड़ना ```bash ocrner ner "Shelby Lucier from SCS Agency in Cambridge, UK sent an invoice on 13/02/15. Call 07981423683." -r ``` ```text ╭──────┬───────────────┬────────────┬──────────╮ │ 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 शेयरधारक का पत्र ```bash ocrner ocr shareholder-letter.jpg -q ``` ```text ╭──────┬───────────────┬────────────┬──────────╮ │ 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: एक वास्तविक तुलना दोनों इंजनों द्वारा प्रक्रमित एक ही स्कैन किया गया शेयरधारक पत्र Tesseract`ocrner 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 के साथ सभी लॉगिंग दबाया - अन्य उपकरणों में पाइपिंग के लिए डिजाइन किया गया है ```bash ocrner ner "Shelby Lucier from SCS Agency in Cambridge, UK sent an invoice on 13/02/15. Call 07981423683." -r --json ``` ```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`एक एजेंट फ्रेमवर्क में फीड करें ```bash # 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` एक्सटेंशन - उसी संरचनात्मक डेटा को लिखा गया ```bash ocrner ocr "scans/*.png" -o results.json ``` ### बैच प्रक्रमण ग्लोब पैटर्न या निर्देशिकाओं के साथ बहुविध छवियों को प्रक्रिया करें: ```bash # 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 रिपो इंगित करने का समर्थन करता है ```json { "OcrNer": { "NerModelRepo": "protectai/bert-base-NER-onnx-quantized" } } ``` संरचना इस के लिए डिज़ाइन की गई है --- ## बड़ी तस्वीर: जहां यह ठीक है यह पैकेज एक है **एकल-- चरण पाइपलाइन**एक ओसीआर इंजन1 एक एनईआर मॉडल2 एक वैकल्पिक दृश्य मॉडल3 यह सामान्य केस के लिए सरल और कुशल बनाया गया है अधिक जटिल परिदृश्यों के लिए - से पाठ पढ़ने *कुछ भी* (हैन्डरलिखित नोट्स\,\बाइलेटबोर्डों के फोटो\,\नीच\M SK3\गुणवत्ता कैमरे कैप्चर\MSC4\मल्टीसेंटी के साथ\ -\ इंजिन ओसीआर समझौते से\ MSC6\अस्पष्ट मिलान\ ,\ और संरचनात्मक निष्कर्षण \ M SK8\ पूरी पाइपलाइन पर जाँचें [***सुदृढ़*आरएजी**](https://www.lucidrag.com)यह है कि इस कार्य के चरण संस्करण में उत्पादन की जगह है ### क्या's अगला:मल्टीमोडल एलएलएम फ्लोरेंस-2 इस पैकेज में स्थानीय दृश्य के लिए मौजूदा छत है **बहुमोडल एलएलएम** - एक मॉडल जो एक छवि देख सकता है *और* प्राकृतिक भाषा में इसका कारण यहाँ roughly what that API could look like ```csharp // Hypothetical future IMultimodalService public interface IMultimodalService { Task 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(); 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](https://huggingface.co/microsoft/Phi-3.5-vision-instruct) या [LLaVA](https://llava-vl.github.io/)इस के लिए पर्याप्त अच्छी हो रही हैं। ```mermaid flowchart LR subgraph Staged["Staged Approach: Pick Your Level"] T1["Tesseract OCR
4MB | ~100ms
Text extraction"] T2["BERT NER
430MB | ~50ms
Entity extraction"] T3["Florence-2
450MB | ~1-3s
Image understanding"] T4["Multimodal LLM
2-8GB | ~5-30s
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 ``` प्रत्येक स्तर आकार और विलंब की लागत पर क्षमता जोड़ता है [***सुदृढ़*आरएजी**](https://www.lucidrag.com) शीर्षक है. --- ## संसाधन **यह पैकेज**: - **[Mostlylucid.OcrNer on NuGet](https://www.nuget.org/packages/Mostlylucid.OcrNer)** - इसे स्थापित करें - **[स्रोत कोड](https://github.com/scottgal/mostlylucidweb/tree/main/Mostlylucid.OcrNer)** - कार्यान्वयन को ब्राउज़ करें **भाग 1**: - **[सरल ओसीआर और एनईआर विशेषता निष्कर्ष](/blog/simple-ocr-ner-extraction)** - पाठ्य जो प्रत्येक टुकड़ा समझता है **निर्भरताएं**: - **[टेसरेक्ट](https://github.com/charlesw/tesseract)** टेसरेक्ट ओसीआर के लिए - CM SK1 रॉपर - **[BERT-base-NER ONNX](https://huggingface.co/protectai/bert-base-NER-onnx)** - एनईआर मॉडल - **[फ्लोरेंस](https://www.nuget.org/packages/Florence2)** - दृश्य मॉडल न्यूगेट पैकेज - **[छवि आकार](https://sixlabors.com/products/imagesharp/)** - क्रॉस - **[OpenCvSharp](https://github.com/shimat/opencvsharp)** उन्नत पूर्वप्रसंस्करण के लिए - ओपनसीवी wrapper - **[माइक्रोसॉफ्ट](https://github.com/microsoft/Recognizers-Text)** - नियम - **[ऑनिक्स रनटाइम](https://onnxruntime.ai/)** - क्रॉस-प्लेटफॉर्म मॉडल निष्कर्ष **संबंधित लेख**: - **[तीन--Tier OCR पाइपलाइन](/blog/constrained-fuzzy-image-ocr-pipeline)** - जब आप सरल ओसीआर से अधिक की जरूरत है - **[कम RAG](/blog/reduced-rag-concept)** - जहाँ बाहर निकाले गए इकाइयां बड़ी तस्वीर में फिट हो - **[*सुदृढ़*आरएजी](https://www.lucidrag.com)** - पूर्ण बहुphase पाईपलाइन