Comment puis-je calculer efficacement les distances Haversine pour des millions de points de données en Python ?

approximation rapide de Haversine en Python/Pandas à l'aide de la vectorisation Numpy

Lorsque vous traitez des millions de points de données impliquant des coordonnées de latitude et de longitude, calculez les distances à l'aide la formule Haversine peut prendre beaucoup de temps. Cet article fournit une implémentation Numpy vectorisée de la fonction Haversine pour améliorer considérablement les performances.

Fonction Haversine originale :

La fonction Haversine originale est écrite en Python :

<code class="python">from math import radians, cos, sin, asin, sqrt
def haversine(lon1, lat1, lon2, lat2):
    # convert decimal degrees to radians 
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])
    # haversine formula 
    dlon = lon2 - lon1 
    dlat = lat2 - lat1 
    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * asin(sqrt(a)) 
    km = 6367 * c
    return km</code>

Fonction Haversine Numpy vectorisée :

L'implémentation Numpy vectorisée tire parti des opérations de tableau optimisées de Numpy :

<code class="python">import numpy as np

def haversine_np(lon1, lat1, lon2, lat2):
    lon1, lat1, lon2, lat2 = map(np.radians, [lon1, lat1, lon2, lat2])
    
    dlon = lon2 - lon1
    dlat = lat2 - lat1
    
    a = np.sin(dlat/2.0)**2 + np.cos(lat1) * np.cos(lat2) * np.sin(dlon/2.0)**2
    
    c = 2 * np.arcsin(np.sqrt(a))
    km = 6378.137 * c
    return km</code>

Comparaison des performances :

La fonction Numpy vectorisée peut traiter instantanément des millions de points d'entrée. Par exemple, considérons des valeurs générées aléatoirement :

<code class="python">lon1, lon2, lat1, lat2 = np.random.randn(4, 1000000)
df = pandas.DataFrame(data={'lon1':lon1,'lon2':lon2,'lat1':lat1,'lat2':lat2})
km = haversine_np(df['lon1'],df['lat1'],df['lon2'],df['lat2'])</code>

Ce calcul, qui prendrait beaucoup de temps avec la fonction Python d'origine, est effectué instantanément.

Conclusion :

Vectoriser la fonction Haversine à l'aide de Numpy peut améliorer considérablement les performances pour les grands ensembles de données. Les opérations de tableau optimisées de Numpy permettent une gestion efficace de plusieurs points de données, réduisant ainsi la surcharge de calcul et accélérant les calculs de distance. Cette optimisation permet d'effectuer des analyses géospatiales en temps réel sur des ensembles de données à grande échelle.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!