नम्पी/पायथन

Question

में फास्ट प्रदर्शन सरणी प्रसंस्करण मैं कई numpy arrays में संग्रहीत समन्वय और माप डेटा को संसाधित करने के लिए इष्टतम तरीका (सबसे तेज़ प्रदर्शन) खोजने का प्रयास कर रहा हूं।

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

मैं के बीच तय करने की कोशिश कर रहा हूँ में सरणियों के माध्यम से पुनरावृति करना चाहते हैं ग्रिड और माप के लिए एलएलए माप को कैसे स्टोर किया जाए, और उसके बाद मापित सीमा मान और वास्तविक सीमा के बीच डेल्टा के आधार पर ग्रिड पर प्रत्येक बिंदु के लिए मीन स्क्वायर त्रुटि की गणना करने का आदर्श तरीका क्या है।

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

वर्तमान में, मैं ग्रिड

# Create a 2D Grid that will be used to store the MSE estimations 
# First, create two 1-D arrays representing the X and Y coordinates of our grid 
x_delta = abs(xmax-xmin)/gridsize_x 
y_delta = abs(ymax-ymin)/gridsize_y 
X = np.arange(xmin,xmax+x_delta,x_delta) 
Y = np.arange(ymin,ymax+y_delta,y_delta) 

# Next, pass arrays to meshgrid to return 2-D coordinate matrices from the 1-D coordinate arrays 
grid_lon, grid_lat = np.meshgrid(X, Y) 

मैं एक माप वर्ग

measurement_lon = [measurement.gps.getlon() for measurement in target_measurements] 
measurement_lat = [measurement.gps.getlat() for measurement in target_measurements] 
measurement_range = [measurement.getrange() for measurement in target_measurements] 

में संग्रहीत माप से LLA अंक और सीमा मान के लिए LLA मान संग्रहीत करने के लिए एक 2 डी meshgrid उपयोग कर रहा हूँ मापन वर्ग

class RangeMeasurement: 

def __init__(self, lat, lon, alt, range): 
    self.gps = GpsLocation(lat,lon,alt) 
    self.range = range 

सीमा गणना के लिए वास्तव में खराब छद्म कोड (iterativ ई और बहुत धीमी गति से)

for i in len(grid_lon): 
    for j in len(measurement_lat): 
    range_error += distance(grid_lon[i],grid_lat[i],measurement_lon[j],measurement_lat[j])-measurement_range[j]  

Answer 1

मुझे लगता है कि scipy.spatial.distance मॉड्यूल इस समस्या के साथ तुम बाहर में मदद मिलेगी: http://docs.scipy.org/doc/scipy/reference/spatial.distance.html

आप 2 कॉलम और एन के साथ 2-डी NumPy सरणी के रूप में अपने अंक संग्रहीत करना चाहिए पंक्तियां, जहां एन सरणी में बिंदुओं की संख्या है। इस प्रारूप के लिए अपने grid_lon और grid_lat बदलने के लिए, का उपयोग

N1 = grid_lon.size 
grid_point_array = np.hstack([grid_lon.reshape((N1,1)), grid_lat.reshape((N1,1))]) 

यह grid_lon में मान है, जो एक आयताकार सरणी ग्रिड के रूप में ही आकार है कि में व्यवस्थित होते हैं के सभी लेता है, और साथ एक सरणी में उन्हें डालता है एक कॉलम और एन पंक्तियां। यह grid_lat के लिए भी वही करता है। दो कॉलम चौड़े सरणी को फिर दो कॉलम सरणी बनाने के लिए जोड़ा जाता है।

N2 = len(measurement_lon) 
measurment_data_array = np.hstack([np.array(measurement_lon).reshape((N2,1)), 
    np.array(measurement_lat).reshape((N2,1))]) 

एक बार आपके डेटा इस प्रारूप में है, तो आप आसानी से scipy.spatial.distance साथ अंक की प्रत्येक जोड़ी के बीच दूरी प्राप्त कर सकते हैं:

ऐसा ही एक विधि अपने माप डेटा कन्वर्ट करने के लिए इस्तेमाल किया जा सकता

d = scipy.spatial.distance.cdist(grid_point_array, measurement_data_array, 'euclidean') 

डी एन 1 पंक्तियों और एन 2 कॉलम के साथ एक सरणी होगी, और डी [i, j] ग्रिड बिंदु I और माप बिंदु जे के बीच की दूरी होगी।

संपादन त्रुटि को स्पष्ट करने के लिए धन्यवाद। एक दिलचस्प परियोजना की तरह लगता है।यह आपको सबसे छोटी संचित वर्ग त्रुटि के साथ ग्रिड अंक देना चाहिए:

measurement_range_array = np.array(measurement_range) 
flat_grid_idx = pow(measurement_range_array-d,2).sum(1).argmin() 

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

grid_x = flat_grid_idx % gridsize_x 
grid_y = flat_grid_idx // gridsize_x 

(// पूर्णांक प्रभाग है।)