Cálculo de la distancia euclidiana con NumPy

En esta guía, veremos cómo calcular la distancia euclidiana entre dos vectores (puntos) en Python con NumPy y el módulo matemático.

En esta guía, veremos cómo calcular la distancia euclidiana entre dos puntos en Python, usando Numpy.

¿Qué es la distancia euclidiana?

La distancia euclidiana es una métrica de distancia fundamental que pertenece a los sistemas en el espacio euclidiano.

El espacio euclidiano es el espacio geométrico clásico con el que te familiarizas en la clase de Matemáticas, generalmente vinculado a 3 dimensiones. Sin embargo, también se puede prescribir a cualquier dimensión entera no negativa.

La distancia euclidiana es la línea más corta entre dos puntos en el espacio euclidiano.

El nombre proviene de Euclid, quien es ampliamente reconocido como "el padre de la geometría", ya que este era el único espacio que la gente en ese momento concebiría típicamente. A lo largo del tiempo se han observado diferentes tipos de espacios en Física y Matemáticas, como el espacio afín, y los espacios no euclidianos y la geometría son muy poco intuitivos para nuestra percepción cognitiva.

En el espacio euclidiano tridimensional, la línea más corta entre dos puntos siempre será una línea recta entre ellos, aunque esto no es válido para dimensiones más altas.

Dado este hecho, la distancia euclidiana no siempre es la métrica más útil para realizar un seguimiento cuando se trata de muchas dimensiones, y nos centraremos en el espacio euclidiano 2D y 3D para calcular la distancia euclidiana.

La medición de la distancia para datos de alta dimensión generalmente se realiza con otras métricas de distancia, como distancia de Manhattan.

En términos generales, la distancia euclidiana tiene un uso importante en el desarrollo de mundos 3D, así como algoritmos de aprendizaje automático que incluyen métricas de distancia, como [K-vecinos más cercanos](/k-algoritmo-de-vecinos-mas-cercanos- en-python-y-scikit-aprender/). Por lo general, la distancia euclidiana representará cuán similares son dos puntos de datos, suponiendo que ya se haya realizado alguna agrupación basada en otros datos.

Fórmula matemática {#fórmula matemática}

La fórmula matemática para calcular la distancia euclidiana entre 2 puntos en el espacio 2D:
$$
d(p,q) = \raíz cuadrada[2]{(q_1-p_1)^2 + (q_2-p_2)^2 }
$$
La fórmula se adapta fácilmente al espacio 3D, así como a cualquier dimensión:
$$
d(p,q) = \raíz cuadrada[2]{(q_1-p_1)^2 + (q_2-p_2)^2 + (q_3-p_3)^2 }
$$
La fórmula general se puede simplificar a:
$$
d(p,q) = \raíz cuadrada[2]{(q_1-p_1)^2 + ... + (q_n-p_n)^2 }
$$
Un ojo agudo puede notar la similitud entre la distancia euclidiana y el teorema de Pitágoras: $$
C^2 = A^2 + B^2
$$

$$
d(p,q)^2 = (q_1-p_1)^2 + (q_2-p_2)^2
$$

De hecho, existe una relación entre estos: la distancia euclidiana se calcula a través del teorema de Pitágoras, dadas las coordenadas cartesianas de dos puntos.

Debido a esto, la distancia euclidiana a veces se conoce como distancia de Pitágoras, aunque el nombre anterior es mucho más conocido.

{.icon aria-hidden=“true”}

Nota: Los dos puntos son vectores, pero la salida debe ser un escalar (que es la distancia).

Usaremos NumPy para calcular esta distancia para dos puntos, y el mismo enfoque se usa para espacios 2D y 3D:

1
2
3
4
5
6
7
8
9
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure()
ax = fig.add_subplot(111, projection = '3d')

ax.scatter(0, 0, 0)
ax.scatter(3, 3, 3)
plt.show()

two points in euclidean space

Cálculo de la distancia euclidiana en Python con NumPy

Primero, necesitaremos instalar la biblioteca NumPy:

1
$ pip install numpy

Ahora, importémoslo y configuremos nuestros dos puntos, con las coordenadas cartesianas como (0, 0, 0) y (3, 3, 3):

1
2
3
4
import numpy as np
# Initializing the points
point_1 = np.array((0, 0, 0))
point_2 = np.array((3, 3, 3))

Ahora, en lugar de realizar el cálculo manualmente, ¡utilicemos los métodos auxiliares de NumPy para hacerlo aún más fácil!

np.sqrt() y np.sum()

Las operaciones y funciones matemáticas requeridas para calcular la distancia euclidiana son bastante simples: suma, resta, así como la función de raíz cuadrada. Las adiciones múltiples también se pueden reemplazar con una suma:
$$
d(p,q) = \raíz cuadrada[2]{(q_1-p_1)^2 + (q_2-p_2)^2 + (q_3-p_3)^2 }
$$

NumPy nos proporciona una función np.sqrt(), que representa la función de raíz cuadrada, así como una función np.sum(), que representa una suma. Con estos, calcular la Distancia Euclidiana en Python es simple e intuitivo:

1
2
3
4
# Get the square of the difference of the 2 vectors
square = np.square(point_1 - point_2)
# Get the sum of the square
sum_square = np.sum(square)

Esto nos da un resultado bastante simple:

1
(0-3)^2 + (0-3)^2 + (0-3)^2

Que es igual a 27. Todo lo que queda es obtener la raíz cuadrada de ese número:

1
2
3
# The last step is to get the square root and print the Euclidean distance
distance = np.sqrt(sum_square)
print(distance)

Esto resulta en:

1
5.196152422706632

En el verdadero espíritu de Pythonic, esto se puede acortar a una sola línea:

1
distance = np.sqrt(np.sum(np.square(point_1 - point_2)))

E incluso puede usar los métodos incorporados pow() y sum() del módulo math de Python, aunque requieren que modifique un poco la entrada, que se abstrae convenientemente usando NumPy , ya que la función pow() solo funciona con escalares (cada elemento en la matriz individualmente) y acepta un argumento: a qué potencia estás elevando el número.

Este enfoque, sin embargo, intuitivamente se parece más a la fórmula que hemos usado antes:

1
2
3
from math import *
distance = np.sqrt(sum(pow(a-b, 2) for a, b in zip(point_1, point_2)))
print(distance)

Esto también resulta en:

1
5.196152422706632

np.linalg.norm()

La función np.linalg.norm() representa una norma matemática. En esencia, una norma de un vector es su longitud. Esta longitud no tiene que ser necesariamente la distancia euclidiana, y también puede ser otras distancias. La distancia euclidiana es la norma L2 de un vector (a veces conocida como la norma euclidiana) y, de forma predeterminada, la función norm() usa L2: el parámetro ord se establece en 2.

{.icon aria-hidden=“true”}

Si tuviera que establecer el parámetro ord en algún otro valor p, calcularía otras p-normas. Por ejemplo, la norma L1 de un vector es la distancia Manhattan.

Con eso en mente, podemos usar la función np.linalg.norm() para calcular la distancia euclidiana fácilmente y mucho más limpiamente que usando otras funciones:

1
2
distance = np.linalg.norm(point_1-point_2)
print(distance)

Esto da como resultado que se imprima la distancia L2/Euclidiana:

1
5.196152422706632

La normalización L2 y la normalización L1 se utilizan mucho en el aprendizaje automático para normalizar los datos de entrada.

If you'd like to learn more about feature scaling - read our Guía de datos de escalado de características con Scikit-Learn!

np.punto()

También podemos usar un Producto escalar para calcular la distancia euclidiana. En Matemáticas, el Producto Punto es el resultado de multiplicar dos vectores de igual longitud y el resultado es un solo número - un valor escalar. Debido al tipo de retorno, a veces también se lo conoce como "producto escalar". Esta operación a menudo se denomina producto interno de los dos vectores.

Para calcular el producto escalar entre 2 vectores puedes usar la siguiente fórmula:
$$
\vec{p} \cdot \vec{q} = {(q_1-p_1) + (q_2-p_2) + (q_3-p_3) }
$$

Con NumPy, podemos usar la función np.dot(), pasando dos vectores.

Si calculamos un producto escalar de la diferencia entre ambos puntos, con esa misma diferencia, obtenemos un número que está relacionado con la distancia euclidiana entre esos dos vectores. Extraer la raíz cuadrada de ese número nos da la distancia que estamos buscando:

1
2
3
4
5
6
7
# Take the difference between the 2 points
diff = point_1 - point_2
# Perform the dot product on the point with itself to get the sum of the squares
sum_square = np.dot(diff, diff)
# Get the square root of the result
distance = np.sqrt(sum_square)
print(distance)

Por supuesto, también puede acortar esto a una sola línea:

1
2
distance = np.sqrt(np.dot(point_1-point_2, point_1-point_2))
print(distance)
1
5.196152422706632

Usando el math.dist() integrado

Python tiene su método incorporado, en el módulo math, que calcula la distancia entre 2 puntos en el espacio 3D. Sin embargo, esto solo funciona con Python 3.8 o posterior.

math.dist() toma dos parámetros, que son los dos puntos, y devuelve la distancia euclidiana entre esos puntos.

{.icon aria-hidden=“true”}

Nota: Tenga en cuenta que los dos puntos deben tener las mismas dimensiones (es decir, ambos en el espacio 2d o 3d).

Ahora, para calcular la distancia euclidiana entre estos dos puntos, simplemente los metemos en el método dist():

1
2
3
import math
distance = math.dist(point_1, point_2)
print(distance)
1
5.196152422706632

Conclusión

La distancia euclidiana es una métrica de distancia fundamental que pertenece a los sistemas en el espacio euclidiano.

El espacio euclidiano es el espacio geométrico clásico con el que te familiarizas en la clase de Matemáticas, generalmente vinculado a 3 dimensiones. Sin embargo, también se puede prescribir a cualquier dimensión entera no negativa.

La distancia euclidiana es la línea más corta entre dos puntos en el espacio euclidiano.

La métrica se usa en muchos contextos dentro de la minería de datos, el aprendizaje automático y varios otros campos, y es una de las métricas de distancia fundamentales.