Come si ottiene la grandezza di un vettore in Numpy?

In linea con "C'è solo un modo ovvio per farlo", come si ottiene la grandezza di un vettore (array 1D) in Numpy?

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

Quanto sopra funziona, ma non posso credere di dover specificare una funzione così banale e fondamentale.

La funzione che stai cercando è numpy.linalg.norm. (Immagino che dovrebbe essere in base numpy come una proprietà di un array - diciamo x.norm()- ma vabbè).

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

Puoi anche inserire un facoltativo ordper la norma del n ordine che desideri. Di 'che volevi la norma 1:

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

E così via.

Se sei preoccupato per la velocità, dovresti invece usare:

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

Ecco alcuni parametri di riferimento:

>>> 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

EDIT: il vero miglioramento della velocità arriva quando devi prendere la norma di molti vettori. L'uso di funzioni intorpidite pure non richiede alcun ciclo. Per esempio:

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

Un'altra alternativa è usare la einsumfunzione numpy per entrambi gli array:

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 vettori:

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

Tuttavia, sembra esserci qualche sovraccarico associato alla chiamata che può rallentare con piccoli input:

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

Il modo più veloce che ho trovato è tramite inner1d. Ecco come si confronta con altri metodi intorpiditi:

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 è ~ 3 volte più veloce di linalg.norm e un pelo più veloce di einsum

usa la norma di funzione in 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

Puoi farlo in modo conciso usando la toolbelt vg . È uno strato leggero sopra intorpidito e supporta valori singoli e vettori impilati.

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

Ho creato la libreria al mio ultimo avvio, dove è stata motivata da usi come questo: idee semplici che sono troppo dettagliate in NumPy.