मैं यह समझने की कोशिश कर रहा हूं कि यूएनईटी के मामले में 21 वर्गों वाले डेटासेट पर प्रशिक्षित होने के मामले में नुकसान की गणना कैसे की जाती है (21 अलग-अलग रंगों वाला 1 मुखौटा, प्रत्येक रंग एक वर्ग को दर्शाता है)। तो, ग्रौड सत्य आकार एन * एम * 1 है (ग्रेस्केल छवि, प्रत्येक पिक्सेल मान वर्ग रंग का प्रतिनिधित्व करता है (पृष्ठभूमि के लिए काला, पेड़ों के लिए हरा, आदि))। लेकिन आउटपुट आकार N*M*21 है (यह इनपुट के समान आकार की 21 छवियां देता है)। मेरा प्रश्न यह है कि ऐसे परिदृश्यों में हानि की गणना कैसे की जाती है? जब आपके पास N * M * 1 का लक्ष्य आकार होता है और आउटपुट आकार (अनुमानित टेंसर) N * M * 21 होता है।

मेरी व्याख्या है, एन * एम प्रत्येक वर्ग लेबल के लिए भविष्यवाणी छवि है (पहली एन * एम भविष्यवाणी छवि 0 वें (चलिए पृष्ठभूमि कहें) लेबल, दूसरा एन * एम भविष्यवाणी छवि 1 लेबल के लिए (चलो पेड़ कहते हैं) और इसी तरह कुछ हद तक एक बनाम बाकी दृष्टिकोण की तरह।

मैं इस लाइब्रेरी में कार्यान्वित यूएनईटी का उपयोग कर रहा हूं segmentation_models। मैं वास्तव में उलझन में हूँ, कृपया मदद करें।

1
yin yang 15 जून 2020, 11:34

1 उत्तर

सबसे बढ़िया उत्तर

हाँ, आपकी व्याख्या अच्छी है।

व्यावहारिक रूप से मुखौटे (जमीनी सच्चाई ys) इस तरह से बनाए जाते हैं कि, यदि आपके पास K वर्ग हैं, तो आपके पास आयाम H x W के K मैट्रिक्स होंगे।

मान लीजिए कि आपको एक समस्या के रूप में पेड़ों, पैदल चलने वालों और कारों के विभाजन की समस्या है। यहां K = 3, और पेड़ों के लिए इनपुट मास्क, उदाहरण के लिए, आयाम H x W के साथ एक मैट्रिक्स है, जहां जमीनी सच्चाई को केवल 1 के साथ चिह्नित किया जाता है जहां पेड़ हैं, और 0 के साथ अन्यथा। फिर, दूसरे मुखौटा के लिए जो पैदल चलने वालों से मेल खाता है, जमीनी सच्चाई को केवल 1 के साथ चिह्नित किया जाता है जहां पैदल यात्री हैं, और 0 के साथ अन्यथा। यह वह तरीका है जिससे हम डेटासेट का निर्माण कर रहे हैं, इस तथ्य के कारण कि हमारे पास मल्टी-क्लास सेगमेंटेशन है, न कि मल्टी-लेबल सेगमेंटेशन, जहां अलग-अलग पर 1 का ओवरलैपिंग है। मास्क संभव है।

हां, यह सच है कि इनपुट छवियां ग्रेस्केल हैं, जैसा आपने वर्णन किया है, [0,number_of_classes] के बीच के मानों के साथ, फिर भी नेटवर्क को वह इनपुट जमीनी सच्चाई प्राप्त नहीं होती है जिस तरह से आपको संदेह हो सकता है।

वास्तव में, यदि आप ट्यूटोरियल से कोड की इन पंक्तियों को करीब से देखते हैं (केरस और पायटॉर्च दोनों के लिए समान है), तो आप निम्नलिखित स्निपेट देख सकते हैं:

# extract certain classes from mask (e.g. cars)
masks = [(mask == v) for v in self.class_values]
mask = np.stack(masks, axis=-1).astype('float')

जिसमें ऊपर वर्णित प्रक्रिया होती है।

अब जब हमारे पास यह जगह है, तो नुकसान फ़ंक्शन के लिए आगे बढ़ना सरल है: यह काम करता है जैसे कि आपके पास 1s और 0s के साथ केवल एक मुखौटा था, लेकिन यह H x W x K के बजाय H x W x K स्थिति के अनुकूल है।

इसे ध्यान में रखते हुए:

    gt: ground truth 4D keras tensor (B, H, W, C) or (B, C, H, W)
    pr: prediction 4D keras tensor (B, H, W, C) or (B, C, H, W)

कोड की उन पंक्तियों का निरीक्षण करके, आप अपनी दुविधा का समाधान करेंगे:

backend = kwargs['backend']

gt, pr = gather_channels(gt, pr, indexes=class_indexes, **kwargs)
pr = round_if_needed(pr, threshold, **kwargs)
axes = get_reduce_axes(per_image, **kwargs)

# score calculation
intersection = backend.sum(gt * pr, axis=axes)
union = backend.sum(gt + pr, axis=axes) - intersection

score = (intersection + smooth) / (union + smooth)
score = average(score, per_image, class_weights, **kwargs)
2
Timbus Calin 2 फरवरी 2021, 10:37