Elaborazione di array a prestazioni veloci in Numpy/Python

Question

Sto cercando di trovare il modo ottimale (prestazioni più veloci) per elaborare coordinate e dati di misurazione memorizzati in diversi array di numpy.

Ho bisogno di calcolare la distanza da ciascun punto della griglia (lotto, lon, valore alt in verde nell'immagine allegata) ad ogni posizione di misurazione (lat, lon, alt, range da target in grigio nell'immagine allegata). Visto che ci sono centinaia di punti della griglia, e migliaia di campi di misura per calcolare per ogni punto della griglia, vorrei per scorrere le matrici nel modo più efficiente possibile

sto cercando di decidere tra come memorizzare le misurazioni LLA per la griglia e le misurazioni, e quindi quale è il modo ideale per calcolare l'errore al quadrato per ogni punto della griglia in base al delta tra il valore del campo misurato e il campo effettivo.

Qualsiasi idea su come memorizzare al meglio questi valori e quindi scorrere lungo la griglia per determinare l'intervallo da ciascuna misurazione sarebbe molto apprezzata. Grazie!!!

Attualmente, sto usando un meshgrid 2D per memorizzare i valori LLA per la griglia

# 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) 

ho il punti di LLA e valori sono compresi tra le misure memorizzate in una classe di valutazione

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] 

Classe di misurazione

class RangeMeasurement: 

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

Pseudocodice veramente brutto per il calcolo dell'intervallo (iterativo E e molto lento)

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

penso che il modulo scipy.spatial.distance vi aiuterà con questo problema: http://docs.scipy.org/doc/scipy/reference/spatial.distance.html

funzione consente di memorizzare i punti da 2-d array NumPy con 2 colonne e N righe, dove N è il numero di punti nella matrice. Per convertire il grid_lon e grid_lat a questo formato, utilizzare

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

Questo prende tutti i valori in grid_lon, che sono disposti in una matrice rettangolare che è la stessa forma della griglia, e li mette in un array con una colonna e N righe. Fa lo stesso per grid_lat. I due array a una colonna vengono quindi combinati per creare un array a due colonne.

Un metodo simile può essere utilizzato per convertire i dati di misura:

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

Una volta che i dati sono in questo formato, si può facilmente trovare le distanze tra ogni coppia di punti con scipy.spatial.distance:

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

d sarà un array con righe N1 e colonne N2 e d [i, j] sarà la distanza tra il punto di griglia i e il punto di misurazione j.

MODIFICA Grazie per l'errore di campo di chiarificazione. Suona come un progetto interessante.Questo dovrebbe dare il punto della griglia con il più piccolo errore quadratico accumulato:

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

Questa sfrutta broadcasting per ottenere la differenza tra il campo di misurazione di un punto e la sua distanza da ogni punto della griglia. Tutti gli errori per un dato punto di griglia vengono quindi sommati e la matrice 1-D risultante dovrebbe essere l'errore accumulato che stai cercando. argmin() è chiamato per trovare la posizione del valore più piccolo. Per ottenere il x ed y coordinate reticolo dall'indice appiattito, utilizzare

grid_x = flat_grid_idx % gridsize_x 
grid_y = flat_grid_idx // gridsize_x 

(Il // è divisione intera.)