Vectorización del cálculo de la distancia de Haversine en Python

Esta reseña ha sido probado por nuestros especialistas para que tengas la seguridad de la exactitud de esta sección.

Solución:

Desde haversine's function definition, se veía bonito paralelizable. Entonces, usando una de las mejores herramientas para la vectorización con NumPy alias broadcasting y reemplazando las funciones matemáticas con los equivalentes NumPy ufuncs, aquí hay una solución vectorizada:

# Get data as a Nx2 shaped NumPy array
data = np.array(df['coordinates'].tolist())

# Convert to radians
data = np.deg2rad(data)                     

# Extract col-1 and 2 as latitudes and longitudes
lat = data[:,0]                     
lng = data[:,1]         

# Elementwise differentiations for lattitudes & longitudes
diff_lat = lat[:,None] - lat
diff_lng = lng[:,None] - lng

# Finally Calculate haversine
d = np.sin(diff_lat/2)**2 + np.cos(lat[:,None])*np.cos(lat) * np.sin(diff_lng/2)**2
return 2 * 6371 * np.arcsin(np.sqrt(d))

Pruebas de tiempo de ejecución –

El otro np.vectorize based solution ha mostrado una promesa positiva en la mejora del rendimiento con respecto al código original, por lo que esta sección comparará el enfoque basado en la transmisión publicado con ese.

Definiciones de funciones –

def vectotized_based(df):
    haver_vec = np.vectorize(haversine, otypes=[np.int16])
    return df.groupby('id').apply(lambda x: pd.Series(haver_vec(df.coordinates, x.coordinates)))

def broadcasting_based(df):
    data = np.array(df['coordinates'].tolist())
    data = np.deg2rad(data)                     
    lat = data[:,0]                     
    lng = data[:,1]         
    diff_lat = lat[:,None] - lat
    diff_lng = lng[:,None] - lng
    d = np.sin(diff_lat/2)**2 + np.cos(lat[:,None])*np.cos(lat) * np.sin(diff_lng/2)**2
    return 2 * 6371 * np.arcsin(np.sqrt(d))

Horarios –

In [123]: # Input
     ...: length = 500
     ...: d1 = np.random.uniform(-90, 90, length)
     ...: d2 = np.random.uniform(-180, 180, length)
     ...: coords = tuple(zip(d1, d2))
     ...: df = pd.DataFrame('id':np.arange(length), 'coordinates':coords)
     ...: 

In [124]: %timeit vectotized_based(df)
1 loops, best of 3: 1.12 s per loop

In [125]: %timeit broadcasting_based(df)
10 loops, best of 3: 68.7 ms per loop

Proporcionaría su función como un argumento para np.vectorize(), y luego podría usarlo como un argumento para pandas.groupby.apply como se ilustra a continuación:

haver_vec = np.vectorize(haversine, otypes=[np.int16])
distance = df.groupby('id').apply(lambda x: pd.Series(haver_vec(df.coordinates, x.coordinates)))

Por ejemplo, con datos de muestra de la siguiente manera:

length = 500
df = pd.DataFrame('id':np.arange(length), 'coordinates':tuple(zip(np.random.uniform(-90, 90, length), np.random.uniform(-180, 180, length))))

comparar por 500 puntos:

def haver_vect(data):
    distance = data.groupby('id').apply(lambda x: pd.Series(haver_vec(data.coordinates, x.coordinates)))
    return distance

%timeit haver_loop(df): 1 loops, best of 3: 35.5 s per loop

%timeit haver_vect(df): 1 loops, best of 3: 593 ms per loop

---

---

Utiliza Nuestro Buscador