पायथन numpy मुखौटा मतलब प्रदर्शन

Question

ठीक है, कुछ खोज के बाद मुझे ऐसा कोई प्रश्न नहीं मिल रहा है जो सीधे इसे हल करता है। मैंने मुखौटा सरणी में देखा है और हालांकि वे शांत लगते हैं, मुझे यकीन नहीं है कि वे मुझे क्या चाहिए।

zone_data एक ही मूल्य के साथ तत्वों की गुच्छों के साथ 2 डी numpy सरणी है:

2 NumPy सरणी पर विचार करें। यह मेरा 'जोन' है।

value_data मनमाना मूल्यों के साथ एक 2-डी numpy सरणी (zone_data का सटीक आकार) है।

मैं जोन_डेटा/value_data के समान आकार की एक numpy सरणी चाहता हूं जिसमें ज़ोन संख्याओं के स्थान पर प्रत्येक जोन का औसत मान है।

उदाहरण ... ascii कला रूप में।

zone_data (4 अलग क्षेत्र):

1, 1, 2, 2 
1, 1, 2, 2 
3, 3, 4, 4 
3, 4, 4, 4 

value_data:

1, 2, 3, 6 
3, 0, 2, 5 
1, 1, 1, 0 
2, 4, 2, 1 

मेरी परिणाम है, यह result_data फोन:

1.5, 1.5, 4.0, 4.0 
1.5, 1.5, 4.0, 4.0 
2.0, 2.0, 1.0, 1.0 
2.0, 2.0, 1.0, 1.0 

यहाँ कोड मैं है। यह एक सही परिणाम देने के रूप में ठीक काम करता है।

result_data = np.zeros(zone_data.shape) 
for i in np.unique(zone_data): 
    result_data[zone_data == i] = np.mean(value_data[zone_data == i]) 

मेरे सरणियों बड़े हैं और मेरे कोड स्निपेट कई सेकंड लेता है। मुझे लगता है कि मेरे पास ज्ञान अंतर है और कुछ भी उपयोगी नहीं है। लूप पहलू को लाइब्रेरी या कुछ ... को सौंपने की जरूरत है!

मुझे यह तेज़ बनाने में मदद चाहिए! पाइथन देवताओं, मैं तुम्हारा ज्ञान चाहता हूँ!

संपादित करें - जोड़ने बेंचमार्क स्क्रिप्ट

import numpy as np 
import time 

zones = np.random.randint(1000, size=(2000,1000)) 
values = np.random.rand(2000,1000) 

print 'start method 1:' 
start_time = time.time() 

result_data = np.zeros(zones.shape) 
for i in np.unique(zones): 
    result_data[zones == i] = np.mean(values[zones == i]) 

print 'done method 1 in %.2f seconds' % (time.time() - start_time) 

print 
print 'start method 2:' 
start_time = time.time() 

#your method here! 

print 'done method 2 in %.2f seconds' % (time.time() - start_time) 

मेरी उत्पादन:

start method 1: 
done method 1 in 4.34 seconds 

start method 2: 
done method 2 in 0.00 seconds 

Answer 1

आप np.bincount इस्तेमाल कर सकते हैं:

count = np.bincount(zones.flat) 
tot = np.bincount(zones.flat, weights=values.flat) 
avg = tot/count 
result_data2 = avg[zones] 

जो मुझे

start method 1: 
done method 1 in 3.13 seconds 

start method 2: 
done method 2 in 0.01 seconds 
>>> 
>>> np.allclose(result_data, result_data2) 
True 

Answer 2

मैंने सोचा कि मैं कहीं scipy में यह देखा था, लेकिन मैं इसे अब और नहीं मिल सकता है। क्या तुमने वहां देखा है?

वैसे भी, आप अपने पाश को बदलने के द्वारा पहली बार एक सुधार प्राप्त कर सकते हैं:

result_data = np.empty(zones.shape) # minor speed gain 
for label in np.unique(zones): 
    mask = zones==label 
    result_data[mask] = np.mean(values[mask]) 

इस तरह आप बेकार में दो बार बूलियन तुलना नहीं करते हैं। वह निष्पादन समय थोड़ा सा कट जाएगा।