समझना == एक NumPy सरणी पर लागू

Question

मैं पाइथन के लिए नया हूं, और मैं सीख रहा हूं TensorFlow। एक ट्यूटोरियल notMNIST डाटासेट का उपयोग कर में, वे एक एक की-एन एन्कोडेड सरणी के लिए लेबल मैट्रिक्स को बदलने के लिए उदाहरण कोड दे।

0 -> [1, 0, 0, 0, 0, 0, 0, 0, 0, 0] 
1 -> [0, 1, 0, 0, 0, 0, 0, 0, 0, 0] 
2 -> [0, 0, 1, 0, 0, 0, 0, 0, 0, 0] 
... 

:

लक्ष्य एक सरणी लेबल पूर्णांक 0 ... 9 से मिलकर लेने के लिए, और वापसी एक मैट्रिक्स जहां प्रत्येक पूर्णांक इस तरह एक एक की-एन इनकोडिंग सरणी के रूप में तब्दील कर दिया गया है वे जो कोड देते हैं वह यह है:

# Map 0 to [1.0, 0.0, 0.0 ...], 1 to [0.0, 1.0, 0.0 ...] 
labels = (np.arange(num_labels) == labels[:,None]).astype(np.float32) 

हालांकि, मुझे नहीं पता कि यह कोड बिल्कुल कैसे करता है। ऐसा लगता है कि यह 0 से 9 की सीमा में पूर्णांक की एक सरणी उत्पन्न करता है, और उसके बाद लेबल मैट्रिक्स के साथ तुलना करता है, और परिणाम को एक फ्लोट में परिवर्तित करता है। कैसे काम करता है में एक == ऑपरेटर परिणाम एक एक के- n मैट्रिक्स इनकोडिंग? numpy के वेक्टर ऑप्स, एक सिंगलटन अक्ष, और प्रसारण जोड़ने:

Answer 1

कुछ चीजें यहाँ पर जा रहे हैं।

सबसे पहले, आप कैसे == जादू करता है देखने के लिए सक्षम होना चाहिए।

मान लीजिए कि हम एक सरल लेबल सरणी के साथ शुरू करते हैं। == एक वेक्टरीकृत फैशन में व्यवहार करता है, जिसका अर्थ है कि हम पूरे सरणी को स्केलर से तुलना कर सकते हैं और प्रत्येक तत्व की तुलना के मूल्यों से युक्त एक सरणी प्राप्त कर सकते हैं। उदाहरण के लिए:

>>> labels = np.array([1,2,0,0,2]) 
>>> labels == 0 
array([False, False, True, True, False], dtype=bool) 
>>> (labels == 0).astype(np.float32) 
array([ 0., 0., 1., 1., 0.], dtype=float32) 

पहले हम एक बूलियन सरणी मिलता है, और फिर हम तैरता के लिए मजबूर: गलत == 0 अजगर में है, और यह सच है == 1। तो हम एक सरणी के साथ हवा बनाते हैं जो 0 है labels 0 और 1 के बराबर नहीं है जहां यह है।

लेकिन वहाँ 0 की तुलना के बारे में कुछ खास नहीं है, लेकिन इसके बदले हम इसी तरह के परिणाम के लिए 1 या 2 या 3 करने के लिए तुलना कर सकते हैं:

>>> (labels == 2).astype(np.float32) 
array([ 0., 1., 0., 0., 1.], dtype=float32) 

वास्तव में, हम हर संभव लेबल पर पाश सकता है और इस सरणी उत्पन्न करते हैं। हम एक listcomp इस्तेमाल कर सकते हैं:

>>> np.array([(labels == i).astype(np.float32) for i in np.arange(3)]) 
array([[ 0., 0., 1., 1., 0.], 
     [ 1., 0., 0., 0., 0.], 
     [ 0., 1., 0., 0., 1.]], dtype=float32) 

लेकिन यह वास्तव में numpy का लाभ लेने है। क्या हम क्या करना चाहते हैं प्रत्येक संभव लेबल प्रत्येक तत्व के साथ तुलना में है, IOW तुलना करने के लिए

>>> np.arange(3) 
array([0, 1, 2]) 

>>> labels 
array([1, 2, 0, 0, 2]) 

साथ

और यहाँ जहां numpy प्रसारण का जादू काम आती है। अभी, labels एक है आकार की 1-आयामी वस्तु (5,)। यदि हम इसे आकार की 2-आयामी वस्तु (5,1) बनाते हैं, तो ऑपरेशन अंतिम धुरी पर "प्रसारण" करेगा और हमें प्रत्येक प्रविष्टि की तुलना करने के परिणामों के साथ आकार (5,3) का आउटपुट मिलेगा लेबल के प्रत्येक तत्व के साथ सीमा।

पहले हम None (या np.newaxis) का उपयोग करने के लिए labels एक "अतिरिक्त" अक्ष में जोड़ सकते हैं, तो उसका आकार बदल रहा है:

>>> labels[:,None] 
array([[1], 
     [2], 
     [0], 
     [0], 
     [2]]) 
>>> labels[:,None].shape 
(5, 1) 

और फिर हम तुलना कर सकते हैं (इस व्यवस्था हम थे की पक्षांतरित है पहले देख रहे हैं, लेकिन यह वास्तव में कोई फर्क नहीं पड़ता)।

>>> np.arange(3) == labels[:,None] 
array([[False, True, False], 
     [False, False, True], 
     [ True, False, False], 
     [ True, False, False], 
     [False, False, True]], dtype=bool) 
>>> (np.arange(3) == labels[:,None]).astype(np.float32) 
array([[ 0., 1., 0.], 
     [ 0., 0., 1.], 
     [ 1., 0., 0.], 
     [ 1., 0., 0.], 
     [ 0., 0., 1.]], dtype=float32) 

numpy में प्रसारण बहुत शक्तिशाली है, और पढ़ने के लायक है।

Answer 2

संक्षेप में, == एक numpy सरणी पर लागू होता है जिसका अर्थ तत्व-वार == को सरणी में लागू करना है। परिणाम बुलियन की एक सरणी है।

>>> b = np.array([1,0,0,1,1,0]) 
>>> b == 1 
array([ True, False, False, True, True, False], dtype=bool) 

कहना है कि कितने 1s b में, आप सरणी फ्लोट करने के लिए कास्ट करने के लिए, यानी .astype(np.float32) बचाया जा सकता है, जरूरत नहीं है क्योंकि अजगर बूलियन में की एक उपवर्ग है देखते हैं गिनती करने के लिए: यहाँ एक उदाहरण है int और पायथन 3 में आपके पास True == 1 False == 0 है।

>>> np.sum((b == 1)) 
3 

या::

>>> np.count_nonzero(b == 1) 
3