केवल एक अभिव्यक्ति का उपयोग करके अजीब मैट्रिक्स बिनराइजेशन

Question

मैं केवल एक अभिव्यक्ति का उपयोग करके थ्रेसहोल्ड के आधार पर numpy N-d सरणी को बिनराइज़ करने का एक तरीका ढूंढ रहा हूं। एक अब है

np.random.seed(0) 
np.set_printoptions(precision=3) 
a = np.random.rand(4, 4) 
threshold, upper, lower = 0.5, 1, 0 

:

array([[ 0.02 , 0.833, 0.778, 0.87 ], 
     [ 0.979, 0.799, 0.461, 0.781], 
     [ 0.118, 0.64 , 0.143, 0.945], 
     [ 0.522, 0.415, 0.265, 0.774]]) 

अब मैं इन 2 भाव आग कर सकते हैं:

a[a>threshold] = upper 
a[a<=threshold] = lower 

और प्राप्त जो मैं चाहता: तो मैं इस तरह कुछ है

array([[ 0., 1., 1., 1.], 
     [ 1., 1., 0., 1.], 
     [ 0., 1., 0., 1.], 
     [ 1., 0., 0., 1.]]) 

लेकिन क्या ऐसा करने का कोई तरीका है ई अभिव्यक्ति?

Answer 1

हम np.where विचार कर सकते हैं:

np.where(a>threshold, upper, lower) 
Out[6]: 
array([[0, 1, 1, 1], 
     [1, 1, 0, 1], 
     [0, 1, 0, 1], 
     [1, 0, 0, 1]]) 

Answer 2

आप अभिव्यक्ति लिख सकते हैं सीधे, यह एक बूलियन सरणी वापस आ जाएगी, और यह बस एक 1-बाइट अहस्ताक्षरित पूर्णांक ("uint8") सरणी आगे के लिए के रूप में इस्तेमाल किया जा सकता गणना:

print a > 0.5 

उत्पादन

[[False True True True] 
[ True True False True] 
[False True False True] 
[ True False False True]] 

एक पंक्ति में और कस्टम ऊपरी/निचले मूल्यों के साथ आप उदाहरण के लिए इतना लिख ​​सकते हैं:

upper = 10 
lower = 3 
treshold = 0.5 

print lower + (a>treshold) * (upper-lower) 

Answer 3

Numpy वैक्टर (मैट्रिक्स) और 3 डी + एक सामान्य आतानक के रूप में सरणी के अनुक्रम के रूप में एक वेक्टर, 2 डी सरणी के रूप में हर 1 दिन सरणी व्यवहार करता है। इसका मतलब है कि जब हम संचालन करते हैं, हम वेक्टर गणित कर रहे हैं। तो आप बस कर सकते हैं:

>>> a = (a > 0.5).astype(np.int_) 

उदाहरण के लिए:

>>> np.random.seed(0) 
>>> np.set_printoptions(precision=3) 

>>> a = np.random.rand(4, 4) 

>>> a 
>>> array([[ 0.549, 0.715, 0.603, 0.545], 
     [ 0.424, 0.646, 0.438, 0.892], 
     [ 0.964, 0.383, 0.792, 0.529], 
     [ 0.568, 0.926, 0.071, 0.087]]) 

>>> a = (a > 0.5).astype(np.int_) # Where the numpy magic happens. 

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

क्या यहाँ पर जा रहा है कि आप स्वचालित रूप से 4x4 मैट्रिक्स में प्रत्येक पंक्ति के प्रत्येक तत्व के माध्यम से पुनरावृत्ति और प्रत्येक के लिए एक बूलियन तुलना आवेदन कर रहे हैं है तत्व।

यदि> 0.5 वापस लौटें, तो फिर गलत लौटें।

फिर .astype विधि बुला और np.int_ तर्क के रूप में पास करके, आप numpy अपनी तुलना मूल्य के आधार पर मैट्रिक्स binarizing प्रभाव में, उनके पूर्णांक प्रतिनिधित्व के साथ सभी बूलियन मूल्यों को बदलने के लिए कह रहे हैं।

Answer 4

एक छोटा तरीका यह है कि आप जिस प्रकार के प्रकार के आधार पर 1 या 1.0 तक शर्त से बूलियन मैट्रिक्स को गुणा करें।

>>> a = np.random.rand(4,4) 
>>> a 
array([[ 0.63227032, 0.18262573, 0.21241511, 0.95181594], 
     [ 0.79215808, 0.63868395, 0.41706148, 0.9153959 ], 
     [ 0.41812268, 0.70905987, 0.54946947, 0.51690887], 
     [ 0.83693151, 0.10929998, 0.19219377, 0.82919761]]) 
>>> (a>0.5)*1 
array([[1, 0, 0, 1], 
     [1, 1, 0, 1], 
     [0, 1, 1, 1], 
     [1, 0, 0, 1]]) 
>>> (a>0.5)*1.0 
array([[ 1., 0., 0., 1.], 
     [ 1., 1., 0., 1.], 
     [ 0., 1., 1., 1.], 
     [ 1., 0., 0., 1.]])