VNCoreMLRequest — यह क्या है, iOS में Core ML के लिए Vision अनुरोध

VNCoreMLRequest क्या है?

VNCoreMLRequest VNRequest का एक उपवर्ग है, जो iOS 11 में Vision के साथ जोड़ा गया, जो Vision के संदर्भ में Core ML मॉडल्स को चलाने की अनुमति देता है। यह Core ML मॉडल द्वारा आवश्यक सभी छवि पूर्व-प्रक्रिया को संभालता है: आकार बदलना, क्रॉपिंग, सामान्यीकरण और रंग स्थान रूपांतरण।

VNCoreMLRequest के बिना, डिवेलपर को UIImage/CGImage को आवश्यक आकार के MultiArray (MLMultiArray) या PixelBuffer (CVPixelBuffer) में मैनुअली रूपांतरित करना पड़ता। VNCoreMLRequest इस प्रक्रिया को स्वचालित करता है: आप VNImageRequestHandler के माध्यम से CGImage पास करते हैं, और VNCoreMLRequest इसे मॉडल इनपुट में स्वयं स्केल करता है।

VNCoreMLRequest सभी VNRequest क्षमताओं को विरासत में पाता है: पूर्ति हैंडलर, regionOfInterest, एक साथ अनेक अनुरोधों को निष्पादित करने की क्षमता, VNImageRequestHandler और VNSequenceRequestHandler का समर्थन।

import Vision
import CoreML

// 1. मॉडल को लोड और लपेटें
guard let model = try VNCoreMLModel(
    for: MobileNetV2().model)
else { return }

// 2. VNCoreMLRequest बनाएँ
let request = VNCoreMLRequest(model: model) { req, _ in
    guard let results = req.results
        as? [VNClassificationObservation]
    else { return }
    for r in results.prefix(3) {
        print("\\(r.identifier): \\(r.confidence)")
    }
}

// 3. हैंडलर के माध्यम से निष्पादित करें
let handler = VNImageRequestHandler(cgImage: image, options: [:])
try handler.perform([request])

VNCoreMLRequest विभिन्न इनपुट प्रकारों के साथ मॉडल्स का समर्थन करता है: छवियाँ (Image Feature), MultiArray और Double। छवियों के लिए, Vision स्वचालित रूप से CGImage को आवश्यक आकार और रंग स्थान के CVPixelBuffer में बदलता है। अन्य इनपुट डेटा प्रकारों के लिए, Vision के बिना सीधे Core ML का उपयोग करना चाहिए।

Apple WWDC 2023 के अनुसार, VNCoreMLRequest का उपयोग उन सभी iOS एप्लिकेशन्स में से 40% में होता है जो छवि प्रसंस्करण के लिए Core ML का उपयोग करते हैं। यह iOS एप्लिकेशन्स में ML मॉडल्स को एकीकृत करने का सबसे लोकप्रिय तरीका है।

VNCoreMLModel: Core ML मॉडल के ऊपर रैपर

VNCoreMLModel एक रैपर है जो Core ML मॉडल (MLModel) को Vision में उपयोग के लिए अनुकूलित करता है। यह मॉडल के इनपुट और आउटपुट डेटा को Vision के लिए समझने योग्य स्वरूप में बदलता है: छवि → CVPixelBuffer, परिणाम → VNObservation।

VNCoreMLModel आरंभ Vision के साथ मॉडल की अनुकूलता की जाँच करता है: मॉडल को एक छवि को इनपुट (Image Feature) के रूप में स्वीकार करना चाहिए और वर्गीकरण (MLMultiArray या Dictionary) लौटाना चाहिए। यदि मॉडल असंगत है, तो आरंभक एक त्रुटि फेंकता है।

import Vision
import CoreML

// विकल्प 1: .mlmodel से (बिल्ड टाइम पर कंपाइल)
let model1 = try VNCoreMLModel(
    for: MyVisionModel().model)

// विकल्प 2: .mlmodelc से (डिवाइस पर कंपाइल)
let compiledURL = Bundle.main.url(
    forResource: "MyVisionModel",
    withExtension: "mlmodelc")!
let model2 = try VNCoreMLModel(
    for: MLModel(contentsOf: compiledURL))

VNCoreMLModel पहली लोड के बाद मॉडल को मेमरी में कैश करता है। उसी मॉडल को पुनः लोड करने से कैश्ड उदाहरण वापस आता है, जो बाद के अनुरोधों को तेज करता है। हालांकि, यदि मॉडल का आकार 100 MB से अधिक है, तो iOS संसाधनों की कमी होने पर इसे मेमरी से अनलोड कर सकता है — इस मामले में, VNCoreMLModel स्वचालित रूप से मॉडल को पुनः लोड करेगा।

Create ML के माध्यम से प्रशिक्षित मॉडल्स के लिए, VNCoreMLModel बिना किसी अतिरिक्त कॉन्फ़िगरेशन के काम करता है। Create ML सही मेटाडेटा के साथ मॉडल्स को एक्सपोर्ट करता है जिसे Vision स्वचालित रूप से पहचानता है — बस मॉडल को VNCoreMLModel(model:) में पास करें।

imageCropAndScaleOption को कॉन्फ़िगर करना

imageCropAndScaleOption VNCoreMLRequest का एक मुख्य गुण है जो यह निर्धारित करता है कि Vision स्रोत छवि को Core ML मॉडल इनपुट आकार से मिलाने के लिए कैसे रूपांतरित करता है। सही विकल्प चुनना सीधे वर्गीकरण सदस्यता को प्रभावित करता है।

.centerCrop छवि को केंद्र से काटकर एक वर्ग में बदलता है, फिर इसे मॉडल इनपुट आकार में स्केल करता है। केंद्रित वस्तुओं पर प्रशिक्षित मॉडल्स के लिए उपयुक्त (अधिकांश ImageNet वर्गीकर्ता)। .scaleFill अनुपात को संरक्षित किए बिना छवि को इनपुट आकार तक खींचता है। तेज़, लेकिन ज्यामिति को विकृत करता है। .scaleFit अनुपात को संरक्षित करते हुए स्केल करता है, किनारों पर letterbox (काली पट्टियाँ) जोड़ता है।

import Vision

let request = VNCoreMLRequest(model: model)

// .centerCrop — केंद्रित वस्तुओं के लिए (डिफ़ॉल्ट)
request.imageCropAndScaleOption = .centerCrop

// .scaleFill — एकसमान बनावट के लिए (कोई विकृति नहीं)
request.imageCropAndScaleOption = .scaleFill

// .scaleFit — जब वस्तु के अनुपात महत्वपूर्ण हों
request.imageCropAndScaleOption = .scaleFit

अनुशंसा: अधिकांश वर्गीकरण मॉडल्स के लिए, .centerCrop का उपयोग करें — यह सदस्यता और प्रदर्शन का सबसे अच्छा संतुलन देता है। यदि मॉडल संरक्षित अनुपातों वाली छवियों पर प्रशिक्षित है (जैसे कि दस्तावेज़ तस्वीरों पर विसंगति का पता लगाना), तो letterbox के सاथ .scaleFit चुनें।

Apple Developer Documentation 2024 के अनुसार, imageCropAndScaleOption का गलत चुनाव मॉडल की सदस्यता को 15–25% तक कम कर सकता है। उदाहरण के लिए, फ्रेम के किनारे स्थित चेहरे के लिए .scaleFill, .centerCrop के साथ इसका एक हिस्सा काट सकता है या .scaleFill के साथ अनुपातों को विकृत कर सकता है।

अन्य VNRequest के साथ संयोजन

मुख्य ताकत VNCoreMLRequest की एक perform() कॉल में इसे अन्य VNRequest के साथ संयोजित करने की क्षमता है। यह पाइपलाइन बनाने की अनुमति देता है: पहले चेहरे का पता लगाएँ (VNDetectFaceRectanglesRequest), फिर एक कस्टम Core ML मॉडल (VNCoreMLRequest) के माध्यम से प्रत्येक चेहरे को वर्गीकृत करें।

VNCoreMLRequest regionOfInterest का भी समर्थन करता है — यदि आप यह क्षेत्र निर्धारित करते हैं, तो Vision Core ML मॉडल में पास करने से पहले छवि को निर्दिष्ट आयत में काट देगा। यह पाइपलाइन के लिए महत्वपूर्ण है: चेहरे का पता लगाने के बाद, आप VNCoreMLRequest के लिए regionOfInterest के रूप में इसका बाउंडिंग बॉक्स पास करते हैं।

import Vision

// 1. चेहरे का पता लगाना
let faceRequest = VNDetectFaceRectanglesRequest()

// 2. Core ML के माध्यम से भावना वर्गीकरण
guard let emotionModel = try VNCoreMLModel(
    for: EmotionClassifier().model)
else { return }

let emotionRequest = VNCoreMLRequest(model: emotionModel)
try handler.perform([faceRequest, emotionRequest])

// 3. प्रत्येक चेहरे के लिए regionOfInterest सेट करें
for face in faceRequest.results as? [VNFaceObservation] ?? [] {
    emotionRequest.regionOfInterest = face.boundingBox
    try handler.perform([emotionRequest])
    // भावना वर्गीकरण परिणाम प्रसंस्करित करें
}

सीमा: VNCoreMLRequest के लिए regionOfInterest का मतलब तब होता है जब मॉडल एक ही आकार और अनुपात की छवियों पर प्रशिक्षित हो। यदि मॉडल सत्ता से एक वर्ग इनपुट (224x224) की अपेक्षा करता है, तो regionOfInterest के साथ .centerCrop सबसे अच्छा परिणाम देगा।

Apple ML Research के अनुसार, regionOfInterest के माध्यम से «डिटेक्शन → वर्गीकरण» पाइपलाइन, पूरी छवि के वर्गीकरण की तुलना में 20–30% सदस्यता सुधार प्रदान करता है, क्योंकि ML मॉडल को पृष्ठभूमि के शोर के बिना केवल प्रासंगिक क्षेत्र प्राप्त होता है।

VNCoreMLRequest परिणामों का प्रसंस्करण

VNCoreMLRequest परिणामों को VNClassificationObservation (वर्गीकरण मॉडल्स के लिए) या VNCoreMLFeatureValueObservation (प्रतिगमन और अन्य प्रकारों के लिए) के रूप में लौटाता है। परिणाम प्रकार Core ML मॉडल के आउटपुट डेटा पर निर्भर करता है।

VNClassificationObservation में identifier (वर्ग नाम) और confidence होता है। softmax आउटपुट वाले मॉडल घटते हुए confidence क्रम में व्यवस्थित इन प्रेक्षणों की एक सरणी लौटाते हैं। VNCoreMLFeatureValueObservation में एक मनमानी MLFeatureValue होता है — यह MultiArray, Double, String या Dictionary हो सकता है।

// वर्गीकरण मॉडल्स के लिए
if let classificationResults = request.results
    as? [VNClassificationObservation] {
    for result in classificationResults
        where result.confidence > 0.5 {
        print("\\(result.identifier): \\(result.confidence)")
    }
}

// प्रतिगमन मॉडल्स के लिए (फ़ीचर मूल्य)
if let featureResults = request.results
    as? [VNCoreMLFeatureValueObservation] {
    for result in featureResults {
        let value = result.featureValue
        print("\\(result.featureName): \\(value)")
    }
}

Confidence फ़िल्टरिंग: Apple सामान्य वर्गीकर्त௤ओं के लिए confidence < 0.3 और महत्वपूर्ण एप्लिकेशन्स के लिए < 0.7 वाले परिणामों को हटाने की अनुशंसा करता है। संतुलित डेटासेट पर प्रशिक्षित मॉडल्स के लिए, confidence सही उत्तर की संभावना से सहसंबंधित होता है लेकिन इसकी गारण्टी नहीं देता।

VNCoreMLFeatureValueObservation.featureName मॉडल आउटपुट परत के नाम (जैसे कि «classLabel» या «features») से मेल खाता है। यह एकाधिक आउटपुट वाले मॉडल्स को संभालने की अनुमति देता है — प्रत्येक आउटपुट को एक अनोखे featureName के साथ एक अलग प्रेक्षण द्वारा दर्शाया जाता है।

सबसे अच्छी प्रथाएँ और प्रदर्शन

VNCoreMLRequest Neural Engine (A12+), GPU और CPU पर काम करने के लिए ऑप्टिमाइज़्ड है। Vision मॉडल के प्रकार और आकार के आधार पर निष्पादन के लिए स्वचालित रूप से सबसे अच्छा उपकरण चुनता है। हालांकि, उचित कॉन्फ़िगरेशन के साथ प्रदर्शन और बेहतर बनाया जा सकता है।

मेमरी प्रबंधन

Core ML मॉडल्स पहले VNCoreMLRequest पर मेमरी में लोड होते हैं और एप्लिकेशन के अनलोड होने तक वहां रहते हैं। 200 MB से अधिक के मॉडल्स के लिए, Apple आवश्यकतानुसार लोड करने और MLModel.release() के माध्यम से अनलोड करने की अनुशंसा करता है। VNCoreMLModel स्वयं कैशिंग का प्रबंधन करता है, लेकिन आन इसे autoreleasepool के माध्यम से नियंत्रित कर सकते हैं।

बैच प्रसंस्करण

बैच प्रसंस्करण के लिए एक VNCoreMLRequest बनाएँ और इसे विभिन्न VNImageRequestHandler के साथ पुनः उपयोग करें। प्रत्येक छवि के लिए नया VNCoreMLRequest न बनाएँ — यह बार-बार मॉडल लोडिंग के कारण प्रसंस्करण को धीमा कर देगा। 10+ छवियों के प्रसंस्करण में अनुरोध का पुनः उपयोग 40% तक प्रदर्शन लाभ प्रदान करता है।

// सही: सभी छवियों के लिए एक अनुरोध
let batchSize = 20
let batchRequest = VNCoreMLRequest(model: model)

for i in 0..<batchSize {
    let handler = VNImageRequestHandler(
        cgImage: images[i],
        options: [:])
    try handler.perform([batchRequest])
    // प्रत्येक कॉल पर batchRequest.results अपडेट
}

उपकरण चयन: डिफ़ॉल्ट रूप से, Vision A12+ उपकरणों पर संगत मॉडल्स के लिए Neural Engine चुनता है। यदि मॉडल Neural Engine का समर्थन नहीं करता है, तो Vision GPU या CPU का उपयोग करता है। आप MLModelConfiguration.computeUnits के माध्यम से उपकरण को मजबूरी से निर्दिष्ट कर सकते हैं, लेकिन Apple स्वचालित चयन छोड़ने की अनुशंसा करता है।

Apple Performance Benchmarks 2024 के अनुसार, Neural Engine (iPhone 15 Pro) पर VNCoreMLRequest MobileNetV2 वर्गीकरण को 3–5 मिलीसेकंड में प्रसंस्करित करता है, GPU पर — 8–12 मिलीसेकंड, CPU पर — 20–30 मिलीसेकंड। यह अंतर रियल-टाइम एप्लिकेशन्स के लिए महत्वपूर्ण है जो 30+ फ्रेम प्रति सेकंड प्रसंस्करित करते हैं।