blocks|key|1737666|text|您想要的函数是numpy.linalg.norm。(我认为它应该在base+numpy中作为数组的一个属性--比方说x.norm()+--但是哦，好吧)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1737667|import+numpy+as+np
x+=+np.array([1,2,3,4,5])
np.linalg.norm(x)|code-block|syntax|javascript|1737668|您还可以为您想要的第n阶规范输入一个可选的ord。假设你想要1-范数：|1737669|np.linalg.norm(x,ord=1)|1737670|诸若此类。|1737671|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.norm.html^0|7|H|1M|8|7|H|0|0|0|L|3|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1B|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

The function you're after is <a href="http://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.norm.html" rel="noreferrer"><code>numpy.linalg.norm</code></a>. (I reckon it should be in base numpy as a property of an array -- say <code>x.norm()</code> -- but oh well).

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

You can also feed in an optional <code>ord</code> for the nth order norm you want. Say you wanted the 1-norm:

<pre><code>np.linalg.norm(x,ord=1)
</code></pre>

And so on.

blocks|key|1951216|text|如果你担心速度，你应该改用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1951217|mag+=+np.sqrt(x.dot(x))|code-block|syntax|javascript|1951218|以下是一些基准测试：|1951219|>>>+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|1951220|编辑:当你必须采用许多向量的范数时，真正的速度提高才会到来。使用纯numpy函数不需要任何for循环。例如：|1951221|In+[1]:+import+numpy+as+np

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

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

In+[4]:+%25timeit+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|1951222|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

If you are worried at all about speed, you should instead use:

<pre><code>mag = np.sqrt(x.dot(x))
</code></pre>

Here are some benchmarks:

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

EDIT: The real speed improvement comes when you have to take the norm of many vectors. Using pure numpy functions doesn't require any for loops. For example:

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

blocks|key|1951412|text|另一种选择是对任一数组使用numpy中的einsum函数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1951413|In+[1]:+import+numpy+as+np

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

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

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

In+[5]:+%25timeit+np.sqrt(np.einsum('ij,ij->i',a,a))
100000+loops,+best+of+3:+8.71+µs+per+loop|code-block|syntax|javascript|1951414|或向量：|1951415|In+[5]:+a+=+np.arange(100000)

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

In+[7]:+%25timeit+np.sqrt(np.einsum('i,i',+a,+a))
10000+loops,+best+of+3:+60.6+µs+per+loop|1951416|然而，似乎确实有一些与调用它相关的开销，这可能会使它在小输入时变得更慢：|1951417|In+[2]:+a+=+np.arange(100)

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

In+[4]:+%25timeit+np.sqrt(np.einsum('i,i',+a,+a))
100000+loops,+best+of+3:+4.68+µs+per+loop|1951418|entityMap^0|K|6|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|T|$]]

Yet another alternative is to use the <code>einsum</code> function in numpy for either arrays:

<pre><code>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-&gt;i',a,a))
100000 loops, best of 3: 8.71 µs per loop
</code></pre>

or vectors:

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

There does, however, seem to be some overhead associated with calling it that may make it slower with small inputs:

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

blocks|key|1738022|text|我发现最快的方法是通过inner1d。下面是它与其他numpy方法的比较：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1738023|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|code-block|syntax|javascript|1738024|inner1d比linalg.norm快约3倍，比einsum快一点点|1738025|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Fastest way I found is via inner1d. Here's how it compares to other numpy methods:

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

inner1d is ~3x faster than linalg.norm and a hair faster than einsum

blocks|key|1951700|text|您可以使用toolbelt+vg简明扼要地完成此操作。它是numpy之上的一个轻量级，它支持单值和堆叠向量。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1951701|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|code-block|syntax|javascript|1951702|我在上一次创业时创建了这个库，在那里它的动机是这样的:简单的想法在NumPy中太过冗长。|1951703|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/lace/vg^0|E|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

You can do this concisely using the toolbelt <a href="https://github.com/lace/vg" rel="nofollow noreferrer">vg</a>. It's a light layer on top of numpy and it supports single values and stacked vectors.

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

I created the library at my last startup, where it was motivated by uses like this: simple ideas which are far too verbose in NumPy.

blocks|key|1951737|text|v1+=+np.array([+1,+2+,+3+])
v1_size+=+len(v1)
print(v1_size)+//+3|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1951738|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre class="lang-py prettyprint-override"><code>v1 = np.array([ 1, 2 , 3 ])
v1_size = len(v1)
print(v1_size) // 3
</code></pre>

blocks|key|1738305|text|给出一个一维矢量的例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1738306|x+=+np.array([1,-2,3,-4,5])|code-block|syntax|javascript|1738307|通常情况下，您会编写以下代码：|1738308|from+scipy+import+linalg+
mag+=+linalg.norm(x)|1738309|对于不同类型的输入(矩阵或一维向量的堆栈(批))，请查看一致描述API的参考文档。https://numpy.org/doc/stable/reference/generated/numpy.linalg.norm.html|offset|length|1738310|或|1738311|如果虚拟环境是全新的，并且缺少scipy，只需键入|style|CODE|1738312|mag+=+np.sqrt(x.dot(x))|1738313|entityMap|0|LINK|mutability|MUTABLE|url|https://numpy.org/doc/stable/reference/generated/numpy.linalg.norm.html^0|0|0|0|0|15|1Z|0|0|0|F|5|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|18|8|@]|9|@$M|19|N|1A|1|1B]]|A|$]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1D|8|@$M|1E|N|1F|S|T]]|9|@]|A|$]]|$1|U|3|V|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

Given an example 1-D vector:
<pre><code>x = np.array([1,-2,3,-4,5])
</code></pre>
Typically you code this:
<pre><code>from scipy import linalg 
mag = linalg.norm(x)
</code></pre>
For different types of input (matrices or a stack (batch) of 1-D vectors) check the reference documentation which describes the API consistently.
<a href="https://numpy.org/doc/stable/reference/generated/numpy.linalg.norm.html" rel="nofollow noreferrer">https://numpy.org/doc/stable/reference/generated/numpy.linalg.norm.html</a>
OR
If the virtual environment is fresh and <code>scipy</code> is missing just type
<pre><code>mag = np.sqrt(x.dot(x))
</code></pre>

In keeping with the "There's only one obvious way to do it", how do you get the magnitude of a vector (1D array) in Numpy?

<pre><code>def mag(x): 
 return math.sqrt(sum(i**2 for i in x))
</code></pre>

The above works, but I cannot believe that I must specify such a trivial and core function myself.

How do you get the magnitude of a vector in Numpy?

为了与“只有一种显而易见的方法”保持一致，如何在Numpy中获得向量(一维数组)的大小？def mag(x):     return math.sqrt(sum(i**2 for i in x))上面的方法是有效的，但我不相信我必须自己指定这样一个琐碎而核心的函数。

问如何在Numpy中获得向量的大小？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Numpy中获得向量的大小？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Numpy中获得向量的大小？
EN