¿Cómo se obtiene la magnitud de un vector en Numpy?

De acuerdo con el "Solo hay una forma obvia de hacerlo", ¿cómo se obtiene la magnitud de un vector (matriz 1D) en Numpy?

def mag(x): 
    return math.sqrt(sum(i**2 for i in x))

Lo anterior funciona, pero no puedo creer que deba especificar yo mismo una función tan trivial y esencial.

La función que buscas es numpy.linalg.norm. (Creo que debería estar en la base numpy como una propiedad de una matriz, por ejemplo x.norm(), pero bueno).

import numpy as np
x = np.array([1,2,3,4,5])
np.linalg.norm(x)

También puede alimentar de forma opcional ordla norma de enésimo orden que desee. Digamos que quería la norma 1:

np.linalg.norm(x,ord=1)

Y así.

Si está preocupado por la velocidad, debería usar:

mag = np.sqrt(x.dot(x))

Aquí hay algunos puntos de referencia:

>>> import timeit
>>> timeit.timeit('np.linalg.norm(x)', setup='import numpy as np; x = np.arange(100)', number=1000)
0.0450878
>>> timeit.timeit('np.sqrt(x.dot(x))', setup='import numpy as np; x = np.arange(100)', number=1000)
0.0181372

EDITAR: La mejora de la velocidad real se produce cuando tienes que tomar la norma de muchos vectores. El uso de funciones numpy puras no requiere ninguna para bucles. Por ejemplo:

In [1]: import numpy as np

In [2]: a = np.arange(1200.0).reshape((-1,3))

In [3]: %timeit [np.linalg.norm(x) for x in a]
100 loops, best of 3: 4.23 ms per loop

In [4]: %timeit np.sqrt((a*a).sum(axis=1))
100000 loops, best of 3: 18.9 us per loop

In [5]: np.allclose([np.linalg.norm(x) for x in a],np.sqrt((a*a).sum(axis=1)))
Out[5]: True

Otra alternativa es usar la einsumfunción en numpy para cualquiera de las matrices:

In [1]: import numpy as np

In [2]: a = np.arange(1200.0).reshape((-1,3))

In [3]: %timeit [np.linalg.norm(x) for x in a]
100 loops, best of 3: 3.86 ms per loop

In [4]: %timeit np.sqrt((a*a).sum(axis=1))
100000 loops, best of 3: 15.6 µs per loop

In [5]: %timeit np.sqrt(np.einsum('ij,ij->i',a,a))
100000 loops, best of 3: 8.71 µs per loop

o vectores:

In [5]: a = np.arange(100000)

In [6]: %timeit np.sqrt(a.dot(a))
10000 loops, best of 3: 80.8 µs per loop

In [7]: %timeit np.sqrt(np.einsum('i,i', a, a))
10000 loops, best of 3: 60.6 µs per loop

Sin embargo, parece haber algo de sobrecarga asociada con la llamada que puede hacerlo más lento con entradas pequeñas:

In [2]: a = np.arange(100)

In [3]: %timeit np.sqrt(a.dot(a))
100000 loops, best of 3: 3.73 µs per loop

In [4]: %timeit np.sqrt(np.einsum('i,i', a, a))
100000 loops, best of 3: 4.68 µs per loop

La forma más rápida que encontré es a través de inner1d. Así es como se compara con otros métodos numpy:

import numpy as np
from numpy.core.umath_tests import inner1d

V = np.random.random_sample((10**6,3,)) # 1 million vectors
A = np.sqrt(np.einsum('...i,...i', V, V))
B = np.linalg.norm(V,axis=1)   
C = np.sqrt((V ** 2).sum(-1))
D = np.sqrt((V*V).sum(axis=1))
E = np.sqrt(inner1d(V,V))

print [np.allclose(E,x) for x in [A,B,C,D]] # [True, True, True, True]

import cProfile
cProfile.run("np.sqrt(np.einsum('...i,...i', V, V))") # 3 function calls in 0.013 seconds
cProfile.run('np.linalg.norm(V,axis=1)')              # 9 function calls in 0.029 seconds
cProfile.run('np.sqrt((V ** 2).sum(-1))')             # 5 function calls in 0.028 seconds
cProfile.run('np.sqrt((V*V).sum(axis=1))')            # 5 function calls in 0.027 seconds
cProfile.run('np.sqrt(inner1d(V,V))')                 # 2 function calls in 0.009 seconds

inner1d es ~ 3 veces más rápido que linalg.norm y un cabello más rápido que einsum

use la norma de función en scipy.linalg (o numpy.linalg )

>>> from scipy import linalg as LA
>>> a = 10*NP.random.randn(6)
>>> a
  array([  9.62141594,   1.29279592,   4.80091404,  -2.93714318,
          17.06608678, -11.34617065])
>>> LA.norm(a)
    23.36461979210312

>>> # compare with OP's function:
>>> import math
>>> mag = lambda x : math.sqrt(sum(i**2 for i in x))
>>> mag(a)
     23.36461979210312

Puede hacer esto de manera concisa usando el toolbelt vg . Es una capa ligera encima de numpy y admite valores individuales y vectores apilados.

import numpy as np
import vg

x = np.array([1, 2, 3, 4, 5])
mag1 = np.linalg.norm(x)
mag2 = vg.magnitude(x)
print mag1 == mag2
# True

Creé la biblioteca en mi último inicio, donde estaba motivada por usos como este: ideas simples que son demasiado detalladas en NumPy.