Tengo una matriz 2D y quiero tomar la norma de cada fila. Pero cuando lo uso numpy.linalg.norm(X)directamente, toma la norma de toda la matriz.
Puedo tomar la norma de cada fila usando un bucle for y luego tomando la norma de cada una X[i], pero lleva mucho tiempo ya que tengo 30k filas.
¿Alguna sugerencia para encontrar una forma más rápida? ¿O es posible aplicarlo np.linalg.norma cada fila de una matriz?
Respuestas:
Tenga en cuenta que, como muestra perimosocordiae , a partir de la versión 1.9 de NumPy, np.linalg.norm(x, axis=1)es la forma más rápida de calcular la norma L2.
Si está calculando una norma L2, podría calcularla directamente (usando el axis=-1argumento para sumar filas):
np.sum(np.abs(x)**2,axis=-1)**(1./2)
Por supuesto, las normas Lp se pueden calcular de manera similar.
Es considerablemente más rápido que np.apply_along_axis, aunque quizás no tan conveniente:
In [48]: %timeit np.apply_along_axis(np.linalg.norm, 1, x)
1000 loops, best of 3: 208 us per loop
In [49]: %timeit np.sum(np.abs(x)**2,axis=-1)**(1./2)
100000 loops, best of 3: 18.3 us per loop
También se pueden calcular directamente otras ordformas de norm(con aceleraciones similares):
In [55]: %timeit np.apply_along_axis(lambda row:np.linalg.norm(row,ord=1), 1, x)
1000 loops, best of 3: 203 us per loop
In [54]: %timeit np.sum(abs(x), axis=-1)
100000 loops, best of 3: 10.9 us per loop
xes complejo, entonces marca la diferencia. Por ejemplo, si x = np.array([(1+1j,2+1j)])entonces np.sum(np.abs(x)**2,axis=-1)**(1./2)es array([ 2.64575131]), mientras que np.sum(x**2,axis=-1)**(1./2)es array([ 2.20320266+1.36165413j]).
numpy.linalg.normcon su nuevo axis argumento es actualmente el enfoque más rápido.
np.linalg.norm(x, axis=0). El se axisrefiere al eje que se suma. Para una matriz 2D, el eje 0 se refiere a filas, por lo que axis=0hace normque se sumen las filas para cada columna fija.
Resucitando una vieja pregunta debido a una gran actualización. A partir de la versión 1.9, numpy.linalg.normahora acepta un axisargumento. [ código , documentación ]
Este es el nuevo método más rápido de la ciudad:
In [10]: x = np.random.random((500,500))
In [11]: %timeit np.apply_along_axis(np.linalg.norm, 1, x)
10 loops, best of 3: 21 ms per loop
In [12]: %timeit np.sum(np.abs(x)**2,axis=-1)**(1./2)
100 loops, best of 3: 2.6 ms per loop
In [13]: %timeit np.linalg.norm(x, axis=1)
1000 loops, best of 3: 1.4 ms per loop
Y para demostrar que está calculando lo mismo:
In [14]: np.allclose(np.linalg.norm(x, axis=1), np.sum(np.abs(x)**2,axis=-1)**(1./2))
Out[14]: True
Mucho más rápido que la respuesta aceptada está usando einsum de NumPy ,
numpy.sqrt(numpy.einsum('ij,ij->i', a, a))
Tenga en cuenta la escala logarítmica:
Código para reproducir la trama:
import numpy
import perfplot
def sum_sqrt(a):
return numpy.sqrt(numpy.sum(numpy.abs(a) ** 2, axis=-1))
def apply_norm_along_axis(a):
return numpy.apply_along_axis(numpy.linalg.norm, 1, a)
def norm_axis(a):
return numpy.linalg.norm(a, axis=1)
def einsum_sqrt(a):
return numpy.sqrt(numpy.einsum("ij,ij->i", a, a))
perfplot.show(
setup=lambda n: numpy.random.rand(n, 3),
kernels=[sum_sqrt, apply_norm_along_axis, norm_axis, einsum_sqrt],
n_range=[2 ** k for k in range(20)],
xlabel="len(a)",
)
Intente lo siguiente:
In [16]: numpy.apply_along_axis(numpy.linalg.norm, 1, a)
Out[16]: array([ 5.38516481, 1.41421356, 5.38516481])
¿Dónde aestá tu matriz 2D?
Lo anterior calcula la norma L2. Para una norma diferente, podría usar algo como:
In [22]: numpy.apply_along_axis(lambda row:numpy.linalg.norm(row,ord=1), 1, a)
Out[22]: array([9, 2, 9])