blocks|key|3043789|text|好的:NumPy的数组形状广播将维度添加到数组形状的左侧，而不是右侧。但是，可以指示NumPy在norms数组的右侧添加一个维度：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3043790|print+vectors.T+/+norms[:,+newaxis]|code-block|syntax|javascript|3043791|确实起作用了！|3043792|entityMap^0|1C|5|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Alright: NumPy's array shape broadcast adds dimensions to the left of the array shape, not to its right. NumPy can however be instructed to add a dimension to the right of the <code>norms</code> array:

<pre><code>print vectors.T / norms[:, newaxis]
</code></pre>

does work!

blocks|key|310415|text|好吧，除非我漏掉了什么，这是有效的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|310416|vectors+/+norms|code-block|syntax|javascript|310417|你的建议中的问题是广播规则。|310418|vectors++#+shape+2,+10
norms++#+shape+10|310419|形状的长度不一样！因此，规则是首先在left上将小形状扩展一|offset|length|style|BOLD|310420|norms++#+shape+1,10|310421|您可以通过调用以下命令手动完成此操作：|310422|vectors+/+norms.reshape(1,-1)++#+same+as+vectors/norms|310423|如果要计算vectors.T/norms，则必须手动进行整形，如下所示：|CODE|310424|vectors.T+/+norms.reshape(-1,1)++#+this+works|310425|entityMap^0|0|0|0|0|I|4|0|0|0|0|5|F|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|15|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|17|8|@$M|18|N|19|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1B|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1D|8|@$M|1E|N|1F|O|Y]]|9|@]|A|$]]|$1|Z|3|10|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|11|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|12|$]]

Well, unless I missed something, this does work:

<pre><code>vectors / norms
</code></pre>

The problem in your suggestion is the broadcasting rules.

<pre><code>vectors # shape 2, 10
norms # shape 10
</code></pre>

The shape do not have the same length! So the rule is to first extend the small shape by one on the left:

<pre><code>norms # shape 1,10
</code></pre>

You can do that manually by calling:

<pre><code>vectors / norms.reshape(1,-1) # same as vectors/norms
</code></pre>

If you wanted to compute <code>vectors.T/norms</code>, you would have to do the reshaping manually, as follows:

<pre><code>vectors.T / norms.reshape(-1,1) # this works
</code></pre>

blocks|key|3043852|text|计算大小|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3043853|我遇到了这个问题，并对你的规范化方法感到好奇。我使用一种不同的方法来计算大小。注意:我通常也会计算最后一个索引(在本例中是行，而不是列)的规范。|3043854|magnitudes+=+np.sqrt((vectors+**+2).sum(-1))[...,+np.newaxis]|code-block|syntax|javascript|3043855|然而，通常情况下，我只是这样标准化：|3043856|vectors+/=+np.sqrt((vectors+**+2).sum(-1))[...,+np.newaxis]|3043857|时间比较|3043858|我运行了一个测试来比较时间，发现我的方法快了相当多，但Freddie+Witherdon的建议更快。|offset|length|3043859|import+numpy+as+np++++
vectors+=+np.random.rand(100,+25)

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

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

#+Freddie's+(from+comment+below)
%25timeit+np.sqrt(np.einsum('...i,...i',+vectors,+vectors))
#+Output:+10000+loops,+best+of+3:+6.45+us+per+loop|3043860|但要注意，正如这篇StackOverflow+answer所指出的那样，einsum没有进行一些安全检查，因此您应该确保vectors的dtype足以足够准确地存储幅度的平方。|style|CODE|3043861|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/315974/freddie-witherden|1|https://stackoverflow.com/a/18366008/310165^0|0|0|0|0|0|0|R|H|0|0|0|10|6|1O|7|1W|5|9|K|1|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1B|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1C|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1D|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1E|8|@]|9|@$Q|1F|R|1G|1|1H]]|A|$]]|$1|S|3|T|5|F|7|1I|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1J|8|@$Q|1K|R|1L|W|X]|$Q|1M|R|1N|W|X]|$Q|1O|R|1P|W|X]]|9|@$Q|1Q|R|1R|1|1S]]|A|$]]|$1|Y|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]|16|$5|11|12|13|A|$14|17]]]]

<h1>Computing the magnitude</h1>

I came across this question and became curious about your method for normalizing. I use a different method to compute the magnitudes. Note: I also typically compute norms across the last index (rows in this case, not columns).

<pre><code>magnitudes = np.sqrt((vectors ** 2).sum(-1))[..., np.newaxis]
</code></pre>

Typically, however, I just normalize like so:

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

<h1>A time comparison</h1>

I ran a test to compare the times, and found that my method is faster by quite a bit, but <a href="https://stackoverflow.com/users/315974/freddie-witherden">Freddie Witherdon</a>'s suggestion is even faster.

<pre><code>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
</code></pre>

Beware though, as this <a href="https://stackoverflow.com/a/18366008/310165">StackOverflow answer</a> notes, there are some safety checks not happening with <code>einsum</code>, so you should be sure that the <code>dtype</code> of <code>vectors</code> is sufficient to store the square of the magnitudes accurately enough.

blocks|key|310481|text|在scikit+learn中已经有了一个函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|310482|import+sklearn.preprocessing+as+preprocessing
norm+=preprocessing.normalize(m,+norm='l2')*|code-block|syntax|javascript|310483|更多信息请访问：|310484|http://scikit-learn.org/stable/modules/preprocessing.html|offset|length|310485|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|1L|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|V|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|W|8|@]|9|@$K|X|L|Y|1|Z]]|A|$]]|$1|M|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|J]]]]

there is already a function in scikit learn:

<pre><code>import sklearn.preprocessing as preprocessing
norm =preprocessing.normalize(m, norm='l2')*
</code></pre>

More info at:

<a href="http://scikit-learn.org/stable/modules/preprocessing.html">http://scikit-learn.org/stable/modules/preprocessing.html</a>

blocks|key|310505|text|我喜欢的归一化向量的方法是使用numpy的inner1d来计算它们的幅度。以下是到目前为止与inner1d相比所建议的内容|type|unstyled|depth|inlineStyleRanges|entityRanges|data|310506|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]|code-block|syntax|javascript|310507|使用cProfile测试性能：|310508|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|310509|inner1d计算幅值的速度比einsum快一丝一毫。所以使用inner1d来标准化：|310510|n+=+points/np.sqrt(inner1d(points,points))[:,None]
cProfile.run('points/np.sqrt(inner1d(points,points))[:,None]')+#+2+function+calls+in+0.026+seconds|310511|针对scikit的测试：|310512|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|310513|结论:使用inner1d似乎是最好的选择|310514|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

My preferred way to normalize vectors is by using numpy's inner1d to calculate their magnitudes. Here's what's been suggested so far compared to inner1d

<pre><code>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]
</code></pre>

Testing performance with cProfile:

<pre><code>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
</code></pre>

inner1d computed the magnitudes a hair faster than einsum. So using inner1d to normalize:

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

Testing against scikit:

<pre><code>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
</code></pre>

Conclusion: using inner1d seems to be the best option

blocks|key|305515|text|对于二维情况，使用np.hypot(vectors[:,0],vectors[:,1])计算幅度似乎比Freddie+Witherden的np.sqrt(np.einsum('...i,...i',+vectors,+vectors))更快。(参考Geoff的回答)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|305516|import+numpy+as+np

#+Generate+array+of+2D+vectors.
vectors+=+np.random.random((1000,2))

#+Using+Freddie's
%25timeit+np.sqrt(np.einsum('...i,...i',+vectors,+vectors))
#+Output:+11.1+µs+±+173+ns+per+loop+(mean+±+std.+dev.+of+7+runs,+100000+loops+each)

#+Using+numpy.hypot()
%25timeit+np.hypot(vectors[:,0],+vectors[:,1])
#+Output:+6.81+µs+±+112+ns+per+loop+(mean+±+std.+dev.+of+7+runs,+100000+loops+each)|code-block|syntax|javascript|305517|要获得归一化后的向量，请执行以下操作：|305518|vectors+/=+np.hypot(vectors[:,0],+vectors[:,1])|305519|entityMap^0|9|Z|1X|1D|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

For the two-dimensional case, using <code>np.hypot(vectors[:,0],vectors[:,1])</code> looks to be faster than Freddie Witherden's <code>np.sqrt(np.einsum('...i,...i', vectors, vectors))</code> for calculating the magnitudes. (Referencing answer by Geoff)

<pre><code>import numpy as np

# Generate array of 2D vectors.
vectors = np.random.random((1000,2))

# Using Freddie's
%timeit np.sqrt(np.einsum('...i,...i', vectors, vectors))
# Output: 11.1 µs ± 173 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

# Using numpy.hypot()
%timeit np.hypot(vectors[:,0], vectors[:,1])
# Output: 6.81 µs ± 112 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
</code></pre>

To get the normalised vectors then do:

<pre><code>vectors /= np.hypot(vectors[:,0], vectors[:,1])
</code></pre>

How can a list of vectors be elegantly normalized, in NumPy?

Here is an example that does not work:

<pre><code>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
</code></pre>

The last operation yields "shape mismatch: objects cannot be broadcast to a single shape".

How can the normalization of the 2D vectors in <code>vectors</code> be elegantly done, with NumPy?

Edit: Why does the above not work while adding a dimension to <code>norms</code> does work (as per my answer below)?

NumPy: how to quickly normalize many vectors?

如何在NumPy中优雅地规范化向量列表？下面是一个不起作用的例子：from numpy import *vectors = array([arange(10), arange(10)])  # All x's, then all y'snorms = apply_along_axis(linalg.norm, 0, v...

问NumPy:如何快速归一化许多向量？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问NumPy:如何快速归一化许多向量？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问NumPy:如何快速归一化许多向量？
EN