Snelle verwerking van arrayprestaties in Numpy/Python

Ik probeer de optimale manier (snelste prestaties) te achterhalen om coördinaat- en meetgegevens te verwerken die zijn opgeslagen in verschillende numpy-arrays.

Ik moet de afstand van elk rasterpunt (partij, lon, alt-waarde in groen in de bijgevoegde afbeelding) berekenen naar elke meetlocatie (lat, lon, alt, bereik van grijs in de bijgevoegde afbeelding). Aangezien er honderden rasterpunten zijn en duizenden meetbereiken om voor elk rasterpunt te berekenen, wil ik de arrays op de meest efficiënte manier herhalen

enter image description here

Ik probeer te beslissen tussen het opslaan van de LLA-metingen voor het raster en metingen en wat de ideale manier is om de gemiddelde kwadratische fout voor elk punt op het raster te berekenen op basis van de delta tussen de gemeten bereikwaarde en het werkelijke bereik .

Alle ideeën over hoe deze waarden het beste kunnen worden opgeslagen en vervolgens over het raster worden herhaald om het bereik van elke meting te bepalen, worden zeer op prijs gesteld. Bedankt!!!

Momenteel gebruik ik een 2D meshgrid om de LLA-waarden voor het raster op te slaan

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

Ik heb de LLA-punten en bereikwaarden van de metingen die zijn opgeslagen in een meetklasse

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]

Meetklasse

class RangeMeasurement:

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

Echt slechte pseudocode voor bereikberekening (iteratief en erg traag)

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]      
5
Je kunt het plaatsen op een site voor het delen van afbeeldingen en de link plaatsen, dan dat een van ons met voldoende reputatie het correct in de post kan integreren.
toegevoegd de auteur mac, de bron
Helaas kan ik de afbeelding nog niet plaatsen omdat ik een nieuwe gebruiker ben - stuur me een bericht als je geïnteresseerd bent en ik kan je de voorbeeldafbeelding e-mailen
toegevoegd de auteur Alex, de bron
Heb je het - bedankt voor het aanbod!
toegevoegd de auteur Alex, de bron

1 antwoord

I think the scipy.spatial.distance module will help you out with this problem: http://docs.scipy.org/doc/scipy/reference/spatial.distance.html

U moet uw punten opslaan als 2-d numpy arrays met 2 kolommen en N rijen, waarbij N het aantal punten in de array is. Om uw grid_lon en grid_lat naar dit formaat te converteren, gebruikt u

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

Dit neemt alle waarden in grid_lon op, die zijn gerangschikt in een rechthoekige array die dezelfde vorm heeft als het raster en plaatst ze in een array met één kolom en N rijen. Het doet hetzelfde voor grid_lat. De twee één kolom brede arrays worden vervolgens gecombineerd om een ​​array met twee kolommen te maken.

Een vergelijkbare methode kan worden gebruikt om uw meetgegevens te converteren:

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

Zodra uw gegevens in dit formaat zijn, kunt u eenvoudig de afstanden tussen elk paar punten vinden met scipy.spatial.distance:

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

d is een array met N1 rijen en N2 kolommen, en d [i, j] is de afstand tussen gridpunt i en meetpunt j.

EDIT Bedankt voor het verduidelijken van bereikfout. Klinkt als een interessant project. Dit zou je het roosterpunt moeten geven met de kleinste gecumuleerde kwadratische fout:

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

Dit maakt gebruik van uitzending om het verschil te maken tussen de gemeten waarden van een punt bereik en de afstand tot elk rasterpunt. Alle fouten voor een bepaald roosterpunt worden vervolgens gesommeerd en de resulterende 1-D-array moet de verzamelde fout zijn waarnaar u op zoek bent. argmin() wordt aangeroepen om de positie van de kleinste waarde te vinden. Gebruik de x- en y-rastercoördinaten van de afgevlakte index

grid_x = flat_grid_idx % gridsize_x
grid_y = flat_grid_idx//gridsize_x

(De//is gehele divisie.)

3
toegevoegd
Bedankt- dit werkte prima voor mij. Ik heb de LLA-rasterpunten geconverteerd naar ECEF-posities (Earth Centered Earth Fixed) om deze in 3D op te lossen en ook dus zou de uitvoer in meters zijn bij het uitvoeren van scipy.spatial.cistance.cdist op de XYZ-coördinaten.
toegevoegd de auteur Alex, de bron
Om het bereik "Actueel" versus "Berekend" uit te leggen, heeft elk van de metingen (in het groen hierboven) een LLA en een geschat bereik voor de zender. Het doel van het rekenrooster is om de zendinrichting te vinden, dus ik doorloop elk punt op het raster en vind de geaccumuleerde fout van alle metingen naar elk specifiek punt. het punt met de kleinste fout moet het dichtst bij de doelpositie liggen.
toegevoegd de auteur Alex, de bron