NumPy: làm thế nào để nhanh chóng chuẩn hóa nhiều vectơ?

Question

Làm thế nào để danh sách các vectơ được chuẩn hóa một cách thanh lịch, trong NumPy?

Dưới đây là một ví dụ mà không không công việc:

from numpy import * 

vectors = array([arange(10), arange(10)]) # All x's, then all y's 
norms = apply_along_axis(linalg.norm, 0, vectors) 

# Now, what I was expecting would work: 
print vectors.T/norms # vectors.T has 10 elements, as does norms, but this does not work 

Lợi suất hoạt động cuối cùng "hình dạng không phù hợp: đối tượng không thể được phát sóng đến một hình dạng duy nhất".

Làm cách nào để chuẩn hóa các vectơ 2D trong vectors được thực hiện một cách tao nhã, với NumPy?

Chỉnh sửa: Tại sao điều trên không hoạt động khi thêm thứ nguyên vào norms hoạt động (theo câu trả lời của tôi bên dưới)?

Answer 1

Vâng, trừ khi tôi bị mất một cái gì đó, điều này không làm việc:

vectors/norms 

Vấn đề trong đề xuất của bạn là các quy tắc truyền thông.

vectors # shape 2, 10 
norms # shape 10 

Hình dạng không có cùng độ dài! Vì vậy, nguyên tắc là lần đầu tiên mở rộng hình dạng nhỏ bởi một trên trái:

norms # shape 1,10 

Bạn có thể làm điều đó bằng tay bằng cách gọi:

vectors/norms.reshape(1,-1) # same as vectors/norms 

Nếu bạn muốn tính toán vectors.T/norms, bạn sẽ phải để làm tái tạo hình bằng tay, như sau:

vectors.T/norms.reshape(-1,1) # this works 

Answer 2

Được rồi: Phát sóng hình dạng mảng của NumPy thêm thứ nguyên vào bên trái của hình dạng mảng chứ không phải ở bên phải. Tuy nhiên, NumPy có thể được hướng dẫn thêm một thứ nguyên ở bên phải của mảng norms:

print vectors.T/norms[:, newaxis] 

không hoạt động!

Answer 3

Đang tính toán độ lớn

Tôi đã xem qua câu hỏi này và trở nên tò mò về phương pháp của bạn để bình thường hóa. Tôi sử dụng một phương pháp khác để tính toán độ lớn. Lưu ý: Tôi cũng thường tính toán các chỉ tiêu trên chỉ mục cuối cùng (các hàng trong trường hợp này, không phải cột).

magnitudes = np.sqrt((vectors ** 2).sum(-1))[..., np.newaxis] 

Thông thường, tuy nhiên, tôi chỉ bình thường như vậy:

vectors /= np.sqrt((vectors ** 2).sum(-1))[..., np.newaxis] 

Một thời gian so sánh

Tôi chạy một thử nghiệm để so sánh thời gian, và thấy rằng phương pháp của tôi là nhanh hơn bằng cách khá một chút, nhưng đề xuất của Freddie Witherdon thậm chí còn nhanh hơn.

import numpy as np  
vectors = np.random.rand(100, 25) 

# OP's 
%timeit np.apply_along_axis(np.linalg.norm, 1, vectors) 
# Output: 100 loops, best of 3: 2.39 ms per loop 

# Mine 
%timeit np.sqrt((vectors ** 2).sum(-1))[..., np.newaxis] 
# Output: 10000 loops, best of 3: 13.8 us per loop 

# Freddie's (from comment below) 
%timeit np.sqrt(np.einsum('...i,...i', vectors, vectors)) 
# Output: 10000 loops, best of 3: 6.45 us per loop 

Cẩn thận mặc dù, vì điều này StackOverflow answer ghi chú, có một số kiểm tra an toàn không xảy ra với einsum, vì vậy bạn nên chắc chắn rằng dtype của vectors là đủ để lưu trữ các bình phương của cường độ chính xác đủ.

Answer 4

đã có một chức năng trong scikit học:

import sklearn.preprocessing as preprocessing 
norm =preprocessing.normalize(m, norm='l2')* 

Thông tin thêm tại địa chỉ:

http://scikit-learn.org/stable/modules/preprocessing.html

Answer 5

cách ưa thích của tôi bình thường hóa vectơ được bằng cách sử dụng inner1d NumPy để tính toán độ lớn của họ. Dưới đây là những gì đang được đề xuất cho đến nay so với inner1d

import numpy as np 
from numpy.core.umath_tests import inner1d 
COUNT = 10**6 # 1 million points 

points = np.random.random_sample((COUNT,3,)) 
A  = np.sqrt(np.einsum('...i,...i', points, points)) 
B  = np.apply_along_axis(np.linalg.norm, 1, points) 
C  = np.sqrt((points ** 2).sum(-1)) 
D  = np.sqrt((points*points).sum(axis=1)) 
E  = np.sqrt(inner1d(points,points)) 

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

hiệu suất kiểm tra với cProfile:

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

inner1d tính độ lớn một sợi tóc nhanh hơn einsum. Vì vậy, sử dụng inner1d để bình thường hóa:

n = points/np.sqrt(inner1d(points,points))[:,None] 
cProfile.run('points/np.sqrt(inner1d(points,points))[:,None]') # 2 function calls in 0.026 seconds 

kiểm tra chống scikit:

import sklearn.preprocessing as preprocessing 
n_ = preprocessing.normalize(points, norm='l2') 
cProfile.run("preprocessing.normalize(points, norm='l2')") # 47 function calls in 0.047 seconds 
np.allclose(n,n_) # True 

Kết luận: sử dụng inner1d dường như là lựa chọn tốt nhất