में भाग 1 मैने कच्चे पाइपलाइन को दिखाया।
अब यह एक NuGet पैकेज है सेटअप का एक लाइन-, zero मॉडल डाउनलोड - सब कुछ स्वचालित
नोट यह पैकेज छवियों से पाठ और इकाइयों को निकालने के लिए एक सरल युक्ति के लिए केंद्रित है। कुछ भी (photos,documents ,screenshots,handwritingM SK4animated gifs and even videosMST5 with fuzzy matchingM ST6 OCR consensusSST7 and structured extractionS ST8 check out सुदृढ़आरएजी जहां इस पाइपलाइन के उत्पादन की श्रेणी संस्करण रहता है
हम में डुबोने से पहले
.onnx सिर्फ अपने सीपीयू का उपयोग करते हुएTesseract साफ दस्तावेज़ पाठ के लिए मजबूत है, लेकिन यह शोरयुक्त फोटो पर गिरता है।
यह पैकेज उन अंतरों को समाप्त करता है
AddOcrNer() और आप' कर रहे हैं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 फ्लोरेंस |
यदि आप के पास पहले से ही पाठ है (पीडीएफ से | , | डाटाबेसों |, | उपयोक्ता इनपुट ), | आप सीधे एनईआर का उपयोग कर सकते हैं
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 से डाउनलोड करता है
छवियों के लिए, पाइपलाइन एक कॉल में पूर्वप्रसंस्करण 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
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
});
}
सभी मॉडलों को पहले प्रयोग पर स्वचालित रूप से डाउनलोड करें
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(); }
}
रिपो में एक कमांड-लाइन उपकरण के साथ बनाया गया है 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 |, | तथा उत्तरी अमरीका को
दोनों इंजनों द्वारा प्रक्रमित एक ही स्कैन किया गया शेयरधारक पत्र
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 फ्लैग आउटपुट का संरचना 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
| फ्लैग | के लिए लागू होता है। | |
|---|---|---|
--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\ पूरी पाइपलाइन पर जाँचें सुदृढ़आरएजीयह है कि इस कार्य के चरण संस्करण में उत्पादन की जगह है
फ्लोरेंस-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
प्रत्येक स्तर आकार और विलंब की लागत पर क्षमता जोड़ता है सुदृढ़आरएजी शीर्षक है.
यह पैकेज:
भाग 1:
निर्भरताएं:
संबंधित लेख:
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.