Workflow निष्पादन

एक Workflow कैसे चलता है: कंपाइलेशन, बैच-आधारित डेटा, डायमेंशनलिटी लेवल्स, सशर्त निष्पादन, और आउटपुट निर्माण।

वर्कफ़्लो निष्पादन एक जटिल विषय है, लेकिन प्रभावी ढंग से शुरुआत करने के लिए आपको हर विवरण समझने की ज़रूरत नहीं है। कुछ बुनियादी अवधारणाएँ समझ लेने से Workflows इकोसिस्टम के साथ आपकी सीखने की प्रक्रिया काफी तेज़ हो सकती है। यह दस्तावेज़ एक स्पष्ट और सरल अवलोकन प्रदान करता है, जिसे आपको जल्दी से मूल बातें समझने और अधिक शक्तिशाली एप्लिकेशन बनाने में मदद करने के लिए डिज़ाइन किया गया है।

जो लोग गहरी तकनीकी समझ में रुचि रखते हैं, उन्हें हम अधिक विस्तृत जानकारी के लिए डेवलपर गाइड देखने के लिए आमंत्रित करते हैं।

संकलन

वर्कफ़्लो निष्पादन की शुरुआत वर्कफ़्लो परिभाषा को संकलित करने से होती है। जैसा कि आप जानते हैं, वर्कफ़्लो परिभाषा एक JSON दस्तावेज़ है जो इनपुट, चरण, आउटपुट और तत्वों के बीच कनेक्शनों का वर्णन करती है। इस दस्तावेज़ को निष्पादन योग्य प्रारूप में बदलने के लिए, इसे संकलित करना आवश्यक है।

निष्पादन इंजन के दृष्टिकोण से, इस प्रक्रिया में एक गणना ग्राफ बनाना और उसकी अखंडता तथा शुद्धता की जाँच करना शामिल है। यह सत्यापन चरण महत्वपूर्ण है, क्योंकि यह त्रुटियों को शुरुआती चरण में ही पहचानने और आपको सूचित करने में मदद करता है, जिससे समस्याओं को डीबग करना आसान और तेज़ हो जाता है। उदाहरण के लिए, यदि आप असंगत ब्लॉक जोड़ते हैं, कोई अमान्य सेलेक्टर उपयोग करते हैं, या अपने वर्कफ़्लो में एक लूप बनाते हैं, तो कम्पाइलर आपको त्रुटि संदेशों के साथ सूचित करेगा।

एक बार संकलन पूरा हो जाने पर, इसका अर्थ है कि आपका वर्कफ़्लो चलाने के लिए तैयार है। इससे पुष्टि होती है कि:

• आपका वर्कफ़्लो आपके वातावरण में मौजूद निष्पादन इंजन के संस्करण के साथ संगत है।

• आपके वर्कफ़्लो के सभी ब्लॉक सफलतापूर्वक लोड और आरंभ किए गए हैं।

• ब्लॉकों के बीच कनेक्शन मान्य हैं।

• वर्कफ़्लो के लिए आपने जो इनपुट डेटा दिया है, उसे मान्य किया जा चुका है।

इस बिंदु पर, निष्पादन इंजन वर्कफ़्लो का निष्पादन शुरू कर सकता है।

वर्कफ़्लो निष्पादन में डेटा

जब आप कोई वर्कफ़्लो चलाते हैं, तो आप हर बार इनपुट डेटा प्रदान करते हैं। प्रोग्रामिंग में किसी फ़ंक्शन की तरह, जो अलग-अलग इनपुट मानों को संभाल सकता है, एक वर्कफ़्लो भी हर बार चलाए जाने पर अलग-अलग डेटा संसाधित कर सकता है। आइए देखें कि वर्कफ़्लो निष्पादन ट्रिगर करने के बाद डेटा के साथ क्या होता है।

आप वर्कफ़्लो में परिभाषित इनपुट प्लेसहोल्डर के स्थान पर इनपुट डेटा देते हैं। इन प्लेसहोल्डरों का संदर्भ आपके वर्कफ़्लो के चरण से सेलेक्टरों का उपयोग करके लिया जाता है। जब कोई चरण चलता है, तो उस समय आपने जो वास्तविक डेटा दिया था, उसका उपयोग गणना करने के लिए किया जाता है। इसके आउटपुट बाद में अन्य चरणों द्वारा उपयोग किए जा सकते हैं, जो वर्कफ़्लो परिभाषा में घोषित चरण आउटपुट सेलेक्टरों पर आधारित होते हैं, और यह प्रक्रिया तब तक जारी रहती है जब तक वर्कफ़्लो पूरा नहीं हो जाता और सभी आउटपुट उत्पन्न नहीं हो जाते।

वर्कफ़्लो परिभाषा में निर्धारित निश्चित मानों वाले पैरामीटरों के अलावा, स्वयं परिभाषा में वास्तविक डेटा मान शामिल नहीं होते। यह केवल निष्पादन इंजन को यह बताती है कि आपके दिए गए डेटा को इनपुट के रूप में कैसे निर्देशित और संभालना है।

डेटा क्या है?

वर्कफ़्लो में इनपुट डेटा को दो प्रकारों में विभाजित किया जा सकता है:

• प्रसंस्करण के लिए बैच-उन्मुख डेटा: वह मुख्य डेटा जिसे संसाधित किया जाना है, जिससे आप परिणाम निकालने की अपेक्षा करते हैं (उदाहरण के लिए: अपने मॉडल से इन्फ़ेरेंस करना)

• स्केलर: ये एकल मान होते हैं, जिनका उपयोग विशिष्ट सेटिंग्स या कॉन्फ़िगरेशन के लिए किया जाता है।

नीचे प्रस्तुत मानक डेटा प्रोसेसिंग के बारे में सोचते हुए, आपको स्केलर और बैच-उन्मुख डेटा के बीच का अंतर कृत्रिम लग सकता है।

def is_even(number: int) -> bool:
    return number % 2 == 0

आप विभिन्न मानों को आसानी से संख्या पैरामीटर के रूप में भेज सकते हैं और उस पैरामीटर को इन दोनों श्रेणियों में से किसी एक से जोड़ने की चिंता नहीं करनी पड़ती।

is_even(number=1)
is_even(number=2)
is_even(number=3)

स्थिति मशीन लर्निंग मॉडलों के साथ अधिक जटिल हो जाती है। is_even(...), जो एक समय में एक संख्या को संसाधित करता है, उसके विपरीत ML मॉडल अक्सर एक बार में डेटा के कई टुकड़े संभालते हैं। उदाहरण के लिए, किसी वर्गीकरण मॉडल को केवल एक छवि देने के बजाय, आप आमतौर पर छवियों की एक सूची भेज सकते हैं और उन सभी के लिए एक साथ पूर्वानुमान प्राप्त कर सकते हैं, एक ही ऑपरेशन हर छवि पर लागू करते हुए।

यह हमारे is_even(...) फ़ंक्शन से अलग है, जिसे परिणामों की सूची पाने के लिए हर संख्या के लिए अलग-अलग कॉल करना पड़ता। यह अंतर इस बात से आता है कि ML मॉडल कैसे काम करते हैं, खासकर GPU डेटा को कैसे संसाधित करते हैं - एक ही ऑपरेशन को कई डेटा टुकड़ों पर एक साथ लागू करते हुए, सिंगल इंस्ट्रक्शन मल्टीपल डेटा ऑपरेशनों को निष्पादित करते हैं।

https://www.youtube.com/watch?v=-P28LKWTzrIwww.youtube.com

यह is_even(...) फ़ंक्शन को लूप का उपयोग करके डेटा के बैचों को संभालने के लिए इस तरह अनुकूलित किया जा सकता है:

results = []
for number in [1, 2, 3, 4]:
    results.append(is_even(number))

आमतौर पर Workflows में आपको चिंता करने की ज़रूरत नहीं होती कि ऑपरेशनों को डेटा के बैचों में ब्रॉडकास्ट किया जाए - यह निष्पादन इंजन आपके लिए पर्दे के पीछे से कर रहा होता है, लेकिन जब आप बैच-उन्मुख डेटा की भूमिका समझ लेते हैं, तो आइए सोचें कि क्या सभी डेटा को बैच के रूप में दर्शाया जा सकता है।

वर्गीकरण मॉडल से पूर्वानुमान प्राप्त करने का मानक तरीका निम्न छद्म-कोड से दर्शाया जा सकता है:

images = [PIL.Image(...), PIL.Image(...), PIL.Image(...), PIL.Image(...)]
model = MyClassificationModel()

predictions = model.infer(images=images, confidence_threshold=0.5)

आप शायद छवियाँ और confidence_thresholdके बीच का अंतर देख सकते हैं। पहला डेटा का बैच है जिस पर एकल ऑपरेशन (मॉडल से पूर्वानुमान) लागू करना है, और दूसरा एक ऐसा पैरामीटर है जो बैच के सभी तत्वों की प्रोसेसिंग को प्रभावित करता है; इस प्रकार के डेटा को हम स्केलर.

की प्रकृति batches और स्केलर

जिसे हम कहते हैं scalar वर्कफ़्लोज़ इकोसिस्टम में 100% उस गणितीय शब्द के समान नहीं है, जिसे आमतौर पर "एकल मान" से जोड़ा जाता है, लेकिन Workflows में हम थोड़ी अलग परिभाषा को प्राथमिकता देते हैं।

Workflows इकोसिस्टम में, एक scalar ऐसा डेटा अंश है जो इस बात की परवाह किए बिना स्थिर रहता है कि कितने तत्व संसाधित किए जा रहे हैं। इस बात से कोई रोक नहीं है कि वस्तुओं की सूची को scalar मान के रूप में रखा जाए। उदाहरण के लिए, यदि आपके पास इनपुट छवियों की एक सूची और संदर्भ छवियों की एक निश्चित सूची है, तो प्रत्येक इनपुट को संसाधित करते समय संदर्भ छवियाँ अपरिवर्तित रहती हैं। इसलिए, संदर्भ छवियों को scalar डेटा माना जाता है, जबकि इनपुट छवियों की सूची बैच-उन्मुख.

अच्छी खबर!

चूँकि Execution Engine v1.6.0, स्केलर और batches से निपटने के व्यावहारिक पहलू निष्पादन इंजन को सौंप दिए जाते हैं (अधिक जानकारी के लिए चेंजलॉग देखें)। एक ब्लॉक डेवलपर के रूप में, इस अंतर को समझना अभी भी महत्वपूर्ण है, लेकिन ब्लॉक बनाते समय आपको इन बारीकियों के बारे में बहुत अधिक सोचने की ज़रूरत नहीं होती।

इस अंतर को स्पष्ट करने के लिए, वर्कफ़्लो परिभाषाएँ दो श्रेणियों के इनपुट रखती हैं:

• स्केलर इनपुट - जैसे WorkflowParameter

• बैच इनपुट - जैसे WorkflowImage, WorkflowVideoMetadata या WorkflowBatchInput

जब आप एकल छवि को WorkflowImage इनपुट के रूप में देते हैं, तो उसे स्वचालित रूप से बैच बनाने के लिए विस्तारित किया जाता है। यदि आपकी वर्कफ़्लो परिभाषा में कई WorkflowImage प्लेसहोल्डर शामिल हैं, तो निष्पादन के लिए आपका दिया गया वास्तविक डेटा इन सभी इनपुटों के लिए समान बैच आकार का होना चाहिए। एकमात्र अपवाद तब है जब आप एकल छवि भेजते हैं; अन्य इनपुटों की बैच आकार आवश्यकताओं को पूरा करने के लिए उसे ब्रॉडकास्ट कर दिया जाएगा।

डेटा के साथ चरणों की परस्पर क्रिया

यदि हम इन परिदृश्यों में चरण आउटपुट की प्रकृति के बारे में आपसे पूछें:

• A: चरण को इनपुट के रूप में केवल स्केलर पैरामीटर मिलते हैं।

• B: चरण को इनपुट के रूप में बैच-उन्मुख डेटा मिलता है।

• C: चरण को इनपुट के रूप में स्केलर पैरामीटर और बैच-उन्मुख डेटा दोनों मिलते हैं।

आप शायद कहेंगे:

• विकल्प A में, आउटपुट नॉन-बैच होगा।

• विकल्प B और C में, आउटपुट एक बैच होगा। विकल्प C में, नॉन-बैच-उन्मुख पैरामीटर डेटा के बैच आकार से मेल खाने के लिए ब्रॉडकास्ट किए जाएंगे।

और आप सही होंगे। यह जान लेने के बाद, Workflows विशेषज्ञ बनने के लिए आपको समझने के लिए केवल दो और अवधारणाएँ बचती हैं।

मान लीजिए आप इन चरणों के साथ एक वर्कफ़्लो बनाना चाहते हैं:

1. इनपुट छवियों के बैच में वस्तुओं का पता लगाएँ।

2. छवियों से प्रत्येक पहचानी गई वस्तु को काटें।

3. विस्तृत लेबल जोड़ने के लिए प्रत्येक कटी हुई वस्तु को दूसरे मॉडल से वर्गीकृत करें।

क्रॉपिंग चरण में डेटा के साथ यही होता है:

1. आप छवियों के एक बैच से शुरू करते हैं, मान लीजिए आपके पास n छवियाँ हैं।

2. ऑब्जेक्ट डिटेक्शन मॉडल प्रत्येक छवि में अलग-अलग संख्या में वस्तुएँ ढूँढता है।

3. इसके बाद क्रॉपिंग चरण प्रत्येक पहचानी गई वस्तु के लिए एक नई छवि बनाता है, जिसके परिणामस्वरूप प्रत्येक मूल छवि के लिए छवियों का एक नया बैच बनता है।

तो, अंत में आपके पास छवियों की एक नेस्टेड सूची होती है, जिसका आकार कुछ इस तरह होता है [(k[1], ), (k[2], ), ... (k[n])], जहाँ प्रत्येक k[i] पहचानों की संख्या के आधार पर परिवर्ती आकार वाला छवियों का एक बैच है। दूसरा मॉडल (क्लासिफ़ायर) इन क्रॉप की गई छवियों के नेस्टेड बैचों को संसाधित करेगा। नेस्टेड बैचों की दुनिया में और गहराई तक जाने से आपको कोई नहीं रोकता।

यहीं से मामला जटिल हो जाता है, लेकिन निष्पादन इंजन इस जटिलता को सरल बना देता है। यह डेटा की नेस्टिंग को आभासी रूप से प्रबंधित करता है, इसलिए ब्लॉक हमेशा समतल, गैर-नेस्टेड प्रारूप में डेटा प्राप्त करते हैं। इससे ऑब्जेक्ट डिटेक्शन मॉडल या क्लासिफ़ायर जैसे उसी ब्लॉक को लागू करना आसान हो जाता है, चाहे आपका डेटा कितना भी गहराई से नेस्टेड क्यों न हो। लेकिन इसकी एक कीमत है - आयामीय स्तर की अवधारणा

यह आयामीय स्तर जो तय करती है कि कौन-से चरण आपस में जोड़े जा सकते हैं और कौन-से नहीं। अवधारणा बैच की नेस्टिंग के स्तर को दर्शाती है। बैच-उन्मुख वर्कफ़्लो इनपुट मेंआयामीता स्तर 1 होती है, जबकि हमारे उदाहरण में वर्णित क्रॉप्स में आयामीता स्तर 2

• होता है, और इसी तरह आगे। किसी विशिष्ट चरण के इनपुट जोड़ते समय जो बात मायने रखती है, वह है: आयामीय स्तर के बीच अंतर

• चरण इनपुटों में आयामीय स्तर आउटपुट पर चरण का प्रभाव (चरण आयामीता को घटा, समान रख या बढ़ा सकता है)

अधिकांश ब्लॉक समान आयामीता स्तर वाले इनपुट के साथ काम करने के लिए डिज़ाइन किए गए हैं और अपने आउटपुट की आयामीता नहीं बदलते, हालांकि कुछ इस नियम के अपवाद हैं। हमारे उदाहरण में, ऑब्जेक्ट-डिटेक्शन मॉडल के पूर्वानुमान अवधारणा बैच की नेस्टिंग के स्तर को दर्शाती है। बैच-उन्मुख वर्कफ़्लो इनपुट मेंपर होते हैं, जबकि वर्गीकरण परिणाम होती है, जबकि हमारे उदाहरण में वर्णित क्रॉप्स मेंपर होते हैं, क्योंकि क्रॉपिंग चरण ने एक नया, गतिशील आयामीता स्तर पेश किया था।

अब, यदि आपको ऐसा ब्लॉक मिल जाए जो ऑब्जेक्ट डिटेक्शन पूर्वानुमान और वर्गीकरण पूर्वानुमान दोनों को स्वीकार करता हो, तो आप हमारे पूर्वानुमानों को केवल तभी एक साथ उपयोग कर सकते हैं जब ब्लॉक स्पष्ट रूप से बताए कि वह इस संयोजन के आयामीता स्तरोंको स्वीकार करता है, अन्यथा आपको संकलन त्रुटि दिखाई देगी। आशा है कि इस संदर्भ में उपयोग करने के लिए कोई ब्लॉक मौजूद है।

डिटेक्शन्स क्लासेस प्रतिस्थापन

Detections Classes Replacement ब्लॉक को पहले मॉडल द्वारा अनुमानित बाउंडिंग बॉक्सों के संदर्भ में मूल छवि के क्रॉप्स पर किए गए वर्गीकरण मॉडल के पूर्वानुमानों से बाउंडिंग बॉक्सों के वर्ग लेबलों को बदलने के लिए डिज़ाइन किया गया है।

हम इसे बदलने के लिए कड़ी मेहनत कर रहे हैं, लेकिन अभी तक Roboflow APP में वर्कफ़्लो UI आयामीय स्तरकी अवधारणा प्रदर्शित करने में सक्षम नहीं है। हम जानते हैं कि यह UX के दृष्टिकोण से उपयुक्त नहीं है और बहुत भ्रमित करने वाला है, लेकिन इस स्थिति के बेहतर होने तक हमें धैर्य रखने के लिए कहना होगा।

वर्कफ़्लोज़ कम्पाइलर डेटा वंशावली का ट्रैक रखता है आयामीता स्तरों जो वर्कफ़्लो परिभाषा में उच्चतर स्तर के

सशर्त निष्पादन

सच कहें तो - प्रोग्रामर ब्रांचिंग को पसंद करते हैं, और इसके पीछे अच्छे कारण हैं। यह प्रोग्रामिंग भाषाओं में एक सामान्य और उपयोगी संरचना है।

उदाहरण के लिए, इस कोड में क्या हो रहा है, इसे समझना आसान है:

def is_string_lower_cased(my_string: str) -> str:
    if my_string.lower() == my_string:
        return "स्ट्रिंग लोअर-कैस्ड थी"
    return "स्ट्रिंग लोअर-कैस्ड नहीं थी"

लेकिन इस कोड का क्या?

def is_string_lower_cased_batched(my_string: Batch[str]) -> str:
    pass

इस मामले में, यह तुरंत स्पष्ट नहीं है कि स्ट्रिंगों के बैच के साथ ब्रांचिंग कैसे काम करेगी। एक अकेले आइटम के लिए निर्णय लेने की अवधारणा सीधी है, लेकिन बैचों के साथ काम करते समय तर्क को एक साथ कई इनपुटों का ध्यान रखना पड़ता है। समस्या इस तथ्य से उत्पन्न होती है कि बैच के प्रत्येक तत्व के लिए स्वतंत्र निर्णय लेना आवश्यक होता है - जिससे बैच के अलग-अलग तत्वों के लिए अलग-अलग निष्पादन शाखाएँ बन सकती हैं। ऐसे सरल उदाहरण में, जैसा यहाँ दिया गया है, इसे आसानी से संबोधित किया जा सकता है:

def is_string_lower_cased_batched(my_string: Batch[str]) -> Batch[str]:
    result = []
    for element in my_string:
        if element.lower() == my_string:
            result.append("स्ट्रिंग लोअर-कैस्ड थी")
        else:
            result.append("स्ट्रिंग लोअर-कैस्ड नहीं थी") 
    return result

हालाँकि, Workflows में हम चाहते हैं कि ब्लॉक यह तय करें कि निष्पादन कहाँ जाएगा, न कि ब्लॉक बॉडी के अंदर सशर्त कथन लागू करके संयुक्त परिणाम लौटाएँ। इसी कारण Workflows निष्पादन इंजन में सशर्त निष्पादन की पूरी व्यवस्था विकसित हुई। यह अवधारणा महत्वपूर्ण है और इसकी अपनी तकनीकी गहराई है, लेकिन उपयोगकर्ता के दृष्टिकोण से समझने योग्य कुछ बातें हैं:

• कुछ Workflows ब्लॉक निष्पादन प्रवाह को प्रभावित कर सकते हैं - उन ब्लॉकों से बने चरणों को चरण सेलेक्टरों का एक सेट दिया जाएगा, जो यह तय करेगा कि बैच के प्रत्येक तत्व के लिए कौन-से संभावित अगले चरण चुने जा सकते हैं (नॉन-बैच-उन्मुख चरण पारंपरिक प्रोग्रामिंग if-else कथनों की तरह काम करते हैं)

• एक बार जब सशर्त निष्पादन द्वारा कोई डेटा तत्व बैच से हटा दिया जाता है, तो वह प्रोसेसिंग पथ में नीचे की ओर प्रभावित सभी चरणों से छिपा दिया जाएगा और आउटपुट में None

• के रूप में निरूपित किया जाएगा

• यदि सशर्त निष्पादन तर्क के मूल्यांकन के बाद चरण के लिए कोई इनपुट शेष नहीं रहता, तो चरण निष्पादित नहीं किया जा सकता

• ऐसे विशेष ब्लॉक होते हैं जो वैकल्पिक निष्पादन शाखाओं को मर्ज कर सकते हैं, ताकि उन शाखाओं से डेटा को एकल सेलेक्टर के माध्यम से संदर्भित किया जा सके (उदाहरण के लिए आउटपुट बनाने के लिए)। ऐसे ब्लॉक का एक उदाहरण है पहला गैर-रिक्त या डिफ़ॉल्ट - जो निष्पादन शाखाओं को संकुचित करके पहला प्राप्त मान लेता है, या यदि कोई मान न मिले तो निर्दिष्ट मान को डिफ़ॉल्ट के रूप में उपयोग करता है

• सशर्त निष्पादन आमतौर पर वर्कफ़्लो आउटपुट को प्रभावित करता है - ब्रांचिंग से प्रभावित सभी मान वास्तव में वैकल्पिक होते हैं (यदि खाली मान भरने वाले विशेष ब्लॉक उपयोग नहीं किए जाते) और नेस्टेड परिणामों में डेटा भरा न भी हो सकता है, जिससे परिणामों में खाली (संभावित रूप से नेस्टेड) सूचियाँ रह सकती हैं - विवरण के लिए देखें आउटपुट निर्माण का वर्णन करने वाला अनुभाग.

आउटपुट निर्माण

समझने के लिए सबसे महत्वपूर्ण बात यह है कि वर्कफ़्लो का आउटपुट बैच तत्वों के क्रम के संदर्भ में उसके इनपुट के साथ संरेखित होता है। इसका मतलब है कि आउटपुट हमेशा डिक्शनरीयों की एक सूची होगा, और प्रत्येक डिक्शनरी इनपुट बैच के एक आइटम के अनुरूप होगी। यह संरचना परिणामों को पार्स करना और उन्हें क्रमिक रूप से संभालना आसान बनाती है, और आउटपुट को इनपुट से मिलाती है।

input_images = [...]
workflow_results = execution_engine.run(
    runtime_parameters={"images": input_images}
)

for image, result in zip(input_images, workflow_results):
    pass

सूची का प्रत्येक तत्व उन कुंजियों वाली एक डिक्शनरी है, जो वर्कफ़्लो परिभाषा में इस तरह की घोषणा के माध्यम से निर्दिष्ट होती हैं:

{"type": "JsonField", "name": "predictions", "selector": "$steps.detection.predictions"}

हालाँकि, आप उन कुंजियों के अंतर्गत किस मान की अपेक्षा कर सकते हैं, यह वर्कफ़्लो की संरचना पर निर्भर करता है। सभी नॉन-बैच परिणाम ब्रॉडकास्ट होकर हर आउटपुट डिक्शनरी में समान मान के साथ रखे जाते हैं। अवधारणा बैच की नेस्टिंग के स्तर को दर्शाती है। बैच-उन्मुख वर्कफ़्लो इनपुट में स्तरों आयामीता स्तरों वाले तत्व समान रूप से वितरित किए जाएँगे, और प्रत्येक डिक्शनरी में मान इनपुट डेटा के संरेखण के अनुसार होंगे (इनपुट छवि 3 के लिए पूर्वानुमान तीसरी डिक्शनरी में रखा जाएगा)। उच्चतर

को उस चरण आउटपुट के प्रकार की विशिष्ट वस्तुओं की सूचियों में एम्बेड किया जाएगा, जिसका संदर्भ लिया जा रहा है। "object_detection_predictions" और क्लासिफ़ायर के परिणामों को इस रूप में दर्ज किया गया है "classifier_predictions", तो आप निम्न आउटपुट की अपेक्षा कर सकते हैं जब तीन छवियाँ वर्कफ़्लो निष्पादन के लिए इनपुट के रूप में भेजी जाती हैं:

[
  {
    "object_detection_predictions": "यहाँ 2 बाउंडिंग बॉक्स वाला sv.Detections ऑब्जेक्ट है",
    "classifier_predictions": [
      {"classifier_prediction":  "पहले क्रॉप के लिए"},
      {"classifier_prediction":  "दूसरे क्रॉप के लिए"}
    ]
  },
  {
    "object_detection_predictions": "खाली sv.Detections",
    "classifier_predictions": []
  },
  {
    "object_detection_predictions": "यहाँ 3 बाउंडिंग बॉक्स वाला sv.Detections ऑब्जेक्ट है",
    "classifier_predictions": [
      {"classifier_prediction":  "पहले क्रॉप के लिए"},
      {"classifier_prediction":  "दूसरे क्रॉप के लिए"},
      {"classifier_prediction":  "तीसरे क्रॉप के लिए"}
    ]
  }
]

जैसा कि आप देख सकते हैं, "classifier_predictions" फ़ील्ड परिणामों की एक सूची से भरा जाता है, जिसका आकार "object_detection_predictions".

दिलचस्प बात यह है कि यदि हमारे वर्कफ़्लो में ContinueIf ब्लॉक हो, जो केवल तब क्रॉपिंग और क्लासिफ़ायर चलाता है जब बाउंडिंग बॉक्स की संख्या दो से भिन्न हो - तो वह classifier_predictions पहली डिक्शनरी में एक खाली सूची में बदल देगा। यदि सशर्त निष्पादन उच्चतर आयामीता स्तरों को आउटपुट बनाने से निष्पादन के साइड इफ़ेक्ट के रूप में बाहर कर देता है - तो उन मानों का चयन करने वाला आउटपुट फ़ील्ड खाली सूचियों की नेस्टेड सूची के रूप में प्रस्तुत होगा, जिसकी गहराई आयामीता स्तर - 1 के अनुरूप होगी।

चूँकि Execution Engine v1.6.0, वर्कफ़्लो के भीतर ब्लॉक बैचों को स्केलर में बदल सकते हैं, और स्केलर इनपुट से नए बैच भी बना सकते हैं। पहला परिदृश्य समझना काफी आसान है - आउटपुट सूची की हर डिक्शनरी बस समान स्केलर मान से भरी होगी। उद्भवित बैच का मामला थोड़ा अधिक जटिल है। ऐसे मामले में हम आयामीता स्तर 1 पर एक बैच पा सकते हैं, जिसका आकार या तत्वों का क्रम इनपुट बैचों के अनुरूप नहीं होता। अर्थगत अस्पष्टता से बचने के लिए, हम ऐसे बैच को ऐसे मानते हैं मानो उसकी आयामीता एक स्तर अधिक हो (जैसे ब्लॉक के इनपुट से जुड़ा आकार एक वाला अतिरिक्त बैच-उन्मुख इनपुट मौजूद हो, जो गतिशील रूप से बैच बनाता है)। ऐसे आभासी रूप से नेस्टेड आउटपुट ब्रॉडकास्ट किए जाते हैं, ताकि आउटपुट सूची की प्रत्येक डिक्शनरी को समान नेस्टेड आउटपुट के साथ एक नई कुंजी दी जाए। यह नेस्टिंग गुण तब भी बरकरार रहता है जब किसी दिए गए वर्कफ़्लो के लिए इनपुट-व्युत्पन्न आउटपुट न हों - ऐसे मामले में आउटपुट आकार 1 की एक सूची होती है, जिसमें नेस्टेड आउटपुट वाली डिक्शनरी होती है।

जब Workflows निष्पादन इंजन HTTP API के पीछे चलता है, तो कुछ आउटपुटों के लिए सीरियलाइज़ेशन की आवश्यकता होती है। हम निम्न सीरियलाइज़ेशन रणनीतियों का उपयोग करते हैं:

• छवियाँ इस रूप में सीरियलाइज़ की जाती हैं base64

• numpy arrays को सूचियों में सीरियलाइज़ किया जाता है

• sv.Detections को इस रूप में सीरियलाइज़ किया जाता है inference ऐसा प्रारूप जिसे वायर के दूसरे सिरे पर sv.Detections.from_inference(...)

sv.Detections का उपयोग करके डिकोड किया जा सकता है, जो डिटेक्शन-आधारित पूर्वानुमानों का हमारा मानक प्रतिनिधित्व है, आउटपुट कन्स्ट्रक्टर द्वारा विशेष रूप से संभाला जाता है। JsonField आउटपुट परिभाषा वैकल्पिक रूप से निर्दिष्ट कर सकती है coordinates_system गुण, जो वर्कफ़्लो में डिटेक्शन निर्देशांकों के अनुवाद को पैरेंट इमेज के निर्देशांक तंत्र में बाध्य कर सकता है। अधिक जानकारी के लिए देखें आउटपुट परिभाषाओं का वर्णन करने वाला docs पृष्ठ