Làm thế nào để bạn có được độ lớn của một vectơ trong Numpy?

Để phù hợp với "Chỉ có một cách rõ ràng để làm điều đó", làm thế nào để bạn có được độ lớn của một vectơ (mảng 1D) trong Numpy?

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

Các công việc trên, nhưng tôi không thể tin rằng tôi phải tự xác định một chức năng tầm thường và cốt lõi như vậy.

Chức năng bạn đang theo đuổi là numpy.linalg.norm. (Tôi nghĩ rằng nó nên ở trong cơ sở numpy như là một thuộc tính của một mảng - nói x.norm()- nhưng tốt thôi).

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

Bạn cũng có thể cung cấp tùy chọn ordcho định mức thứ n bạn muốn. Giả sử bạn muốn 1-Norm:

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

Và như thế.

Nếu bạn lo lắng về tốc độ, thay vào đó bạn nên sử dụng:

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

Dưới đây là một số điểm chuẩn:

>>> 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: Sự cải thiện tốc độ thực sự đến khi bạn phải lấy chỉ tiêu của nhiều vectơ. Sử dụng các hàm numpy thuần túy không yêu cầu bất kỳ vòng lặp nào. Ví dụ:

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

Tuy nhiên, một cách khác là sử dụng einsumhàm trong numpy cho một trong hai mảng:

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

hoặc vectơ:

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

Tuy nhiên, dường như có một số chi phí liên quan đến việc gọi nó có thể làm cho nó chậm hơn với các đầu vào nhỏ:

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

Cách nhanh nhất tôi tìm thấy là thông qua Internal1d. Đây là cách nó so sánh với các phương pháp numpy khác:

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

Internal1d nhanh hơn ~ 3 lần so với linalg.norm và tóc nhanh hơn einsum

sử dụng định mức hàm trong scipy.linalg (hoặc 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

Bạn có thể làm điều này một cách chính xác bằng cách sử dụng toolbelt vg . Đó là một lớp ánh sáng trên đỉnh của numpy và nó hỗ trợ các giá trị đơn và các vectơ xếp chồng lên nhau.

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

Tôi đã tạo ra thư viện ở lần khởi động cuối cùng của mình, nơi nó được thúc đẩy bởi những cách sử dụng như thế này: những ý tưởng đơn giản quá dài dòng trong NumPy.