blocks|key|172090|text|如果你正在使用scikit+learn，你可以使用sklearn.preprocessing.normalize|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|172091|import+numpy+as+np
from+sklearn.preprocessing+import+normalize

x+=+np.random.rand(1000)*10
norm1+=+x+/+np.linalg.norm(x)
norm2+=+normalize(x[:,np.newaxis],+axis=0).ravel()
print+np.all(norm1+==+norm2)
#+True|code-block|syntax|javascript|172092|entityMap|0|LINK|mutability|MUTABLE|url|http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.normalize.html#sklearn.preprocessing.normalize^0|P|V|P|V|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

If you're using scikit-learn you can use <a href="http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.normalize.html#sklearn.preprocessing.normalize" rel="noreferrer"><code>sklearn.preprocessing.normalize</code></a>:

<pre><code>import numpy as np
from sklearn.preprocessing import normalize

x = np.random.rand(1000)*10
norm1 = x / np.linalg.norm(x)
norm2 = normalize(x[:,np.newaxis], axis=0).ravel()
print np.all(norm1 == norm2)
# True
</code></pre>

blocks|key|4677997|text|我同意，如果这样的函数是所包含的库的一部分，那就太好了。但据我所知，情况并非如此。因此，这里是一个版本的任意轴，提供最佳的性能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4677998|import+numpy+as+np

def+normalized(a,+axis=-1,+order=2):
++++l2+=+np.atleast_1d(np.linalg.norm(a,+order,+axis))
++++l2[l2==0]+=+1
++++return+a+/+np.expand_dims(l2,+axis)

A+=+np.random.randn(3,3,3)
print(normalized(A,0))
print(normalized(A,1))
print(normalized(A,2))

print(normalized(np.arange(3)[:,None]))
print(normalized(np.arange(3)))|code-block|syntax|javascript|4677999|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I agree that it would be nice if such a function were part of the included libraries. But it isn't, as far as I know. So here is a version for arbitrary axes that gives optimal performance.
<pre><code>import numpy as np

def normalized(a, axis=-1, order=2):
 l2 = np.atleast_1d(np.linalg.norm(a, order, axis))
 l2[l2==0] = 1
 return a / np.expand_dims(l2, axis)

A = np.random.randn(3,3,3)
print(normalized(A,0))
print(normalized(A,1))
print(normalized(A,2))

print(normalized(np.arange(3)[:,None]))
print(normalized(np.arange(3)))
</code></pre>

blocks|key|172178|text|您可以指定ord来获取L1范数。为了避免零除，我使用了eps，但这可能不是很好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|172179|def+normalize(v):
++++norm=np.linalg.norm(v,+ord=1)
++++if+norm==0:
++++++++norm=np.finfo(v.dtype).eps
++++return+v/norm|code-block|syntax|javascript|172180|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can specify ord to get the L1 norm.
To avoid zero division I use eps, but that's maybe not great.

<pre><code>def normalize(v):
 norm=np.linalg.norm(v, ord=1)
 if norm==0:
 norm=np.finfo(v.dtype).eps
 return v/norm
</code></pre>

blocks|key|172234|text|Christoph+Gohlke在流行的transformations模块中还有unit_vector()函数来标准化向量：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|172235|import+transformations+as+trafo
import+numpy+as+np

data+=+np.array([[1.0,+1.0,+0.0],
+++++++++++++++++[1.0,+1.0,+1.0],
+++++++++++++++++[1.0,+2.0,+3.0]])

print(trafo.unit_vector(data,+axis=1))|code-block|syntax|javascript|172236|entityMap|0|LINK|mutability|MUTABLE|url|https://www.lfd.uci.edu/~gohlke/code/transformations.py.html^0|14|D|K|F|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

There is also the function <code>unit_vector()</code> to normalize vectors in the popular <a href="https://www.lfd.uci.edu/~gohlke/code/transformations.py.html" rel="noreferrer">transformations</a> module by Christoph Gohlke:

<pre><code>import transformations as trafo
import numpy as np

data = np.array([[1.0, 1.0, 0.0],
 [1.0, 1.0, 1.0],
 [1.0, 2.0, 3.0]])

print(trafo.unit_vector(data, axis=1))
</code></pre>

blocks|key|4678119|text|如果您有多维数据并希望将每个轴归一化为其最大值或其总和：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4678120|def+normalize(_d,+to_sum=True,+copy=True):
++++#+d+is+a+(n+x+dimension)+np+array
++++d+=+_d+if+not+copy+else+np.copy(_d)
++++d+-=+np.min(d,+axis=0)
++++d+/=+(np.sum(d,+axis=0)+if+to_sum+else+np.ptp(d,+axis=0))
++++return+d|code-block|syntax|javascript|4678121|使用numpys+peak+to+peak函数。|offset|length|4678122|a+=+np.random.random((5,+3))

b+=+normalize(a,+copy=False)
b.sum(axis=0)+#+array([1.,+1.,+1.]),+the+rows+sum+to+1

c+=+normalize(a,+to_sum=False,+copy=False)
c.max(axis=0)+#+array([1.,+1.,+1.]),+the+max+of+each+row+is+1|4678123|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.scipy.org/doc/numpy-1.14.0/reference/generated/numpy.ptp.html^0|0|0|9|C|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@$I|X|J|Y|1|Z]]|A|$]]|$1|K|3|L|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

If you have multidimensional data and want each axis normalized to its max or its sum:

<pre><code>def normalize(_d, to_sum=True, copy=True):
 # d is a (n x dimension) np array
 d = _d if not copy else np.copy(_d)
 d -= np.min(d, axis=0)
 d /= (np.sum(d, axis=0) if to_sum else np.ptp(d, axis=0))
 return d
</code></pre>

Uses numpys <a href="https://docs.scipy.org/doc/numpy-1.14.0/reference/generated/numpy.ptp.html" rel="nofollow noreferrer">peak to peak</a> function.

<pre><code>a = np.random.random((5, 3))

b = normalize(a, copy=False)
b.sum(axis=0) # array([1., 1., 1.]), the rows sum to 1

c = normalize(a, to_sum=False, copy=False)
c.max(axis=0) # array([1., 1., 1.]), the max of each row is 1
</code></pre>

blocks|key|4678165|text|这可能也适用于你。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4678166|import+numpy+as+np
normalized_v+=+v+/+np.sqrt(np.sum(v**2))|code-block|syntax|javascript|4678167|但当v的长度为0时会失败。|offset|length|style|CODE|4678168|在这种情况下，引入一个小常量来防止零除可以解决这个问题。|4678169|entityMap^0|0|0|2|1|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|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This might also work for you
<pre><code>import numpy as np
normalized_v = v / np.sqrt(np.sum(v**2))
</code></pre>
but fails when <code>v</code> has length 0.
In that case, introducing a small constant to prevent the zero division solves this.

blocks|key|4678207|text|如果你想标准化存储在3D张量中的n维特征向量，你也可以使用PyTorch：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4678208|import+numpy+as+np
from+torch+import+FloatTensor
from+torch.nn.functional+import+normalize

vecs+=+np.random.rand(3,+16,+16,+16)
norm_vecs+=+normalize(FloatTensor(vecs),+dim=0,+eps=1e-16).numpy()|code-block|syntax|javascript|4678209|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you want to normalize n dimensional feature vectors stored in a 3D tensor, you could also use PyTorch:

<pre><code>import numpy as np
from torch import FloatTensor
from torch.nn.functional import normalize

vecs = np.random.rand(3, 16, 16, 16)
norm_vecs = normalize(FloatTensor(vecs), dim=0, eps=1e-16).numpy()
</code></pre>

blocks|key|4678260|text|如果您正在使用3D矢量，您可以使用toolbelt+vg简洁地完成此操作。它是numpy之上的一个轻量级，它支持单值和堆叠向量。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4678261|import+numpy+as+np
import+vg

x+=+np.random.rand(1000)*10
norm1+=+x+/+np.linalg.norm(x)
norm2+=+vg.normalize(x)
print+np.all(norm1+==+norm2)
#+True|code-block|syntax|javascript|4678262|我在上一次创业时创建了这个库，它的动机是这样的:简单的想法在NumPy中太过冗长。|4678263|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/lace/vg^0|Q|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]]]]

If you're working with 3D vectors, you can do this concisely using the toolbelt <a href="https://github.com/lace/vg" rel="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.random.rand(1000)*10
norm1 = x / np.linalg.norm(x)
norm2 = vg.normalize(x)
print np.all(norm1 == norm2)
# True
</code></pre>

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

blocks|key|172443|text|如果你不需要最大的精度，你的函数可以简化为：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|172444|v_norm+=+v+/+(np.linalg.norm(v)+%2B+1e-16)|code-block|syntax|javascript|172445|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you don't need utmost precision, your function can be reduced to:

<pre><code>v_norm = v / (np.linalg.norm(v) + 1e-16)
</code></pre>

blocks|key|4678351|text|如果你使用多维数组，那么快速解决方案是可能的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4678352|假设我们有2D数组，我们希望通过最后一个轴对其进行标准化，而一些行的范数为零。|4678353|import+numpy+as+np
arr+=+np.array([
++++[1,+2,+3],+
++++[0,+0,+0],
++++[5,+6,+7]
],+dtype=np.float)

lengths+=+np.linalg.norm(arr,+axis=-1)
print(lengths)++#+[+3.74165739++0.+++++++++10.48808848]
arr[lengths+>+0]+=+arr[lengths+>+0]+/+lengths[lengths+>+0][:,+np.newaxis]
print(arr)
#+[[0.26726124+0.53452248+0.80178373]
#+[0.+++++++++0.+++++++++0.++++++++]
#+[0.47673129+0.57207755+0.66742381]]|code-block|syntax|javascript|4678354|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you work with multidimensional array following fast solution is possible.

Say we have 2D array, which we want to normalize by last axis, while some rows have zero norm.

<pre class="lang-py prettyprint-override"><code>import numpy as np
arr = np.array([
 [1, 2, 3], 
 [0, 0, 0],
 [5, 6, 7]
], dtype=np.float)

lengths = np.linalg.norm(arr, axis=-1)
print(lengths) # [ 3.74165739 0. 10.48808848]
arr[lengths &gt; 0] = arr[lengths &gt; 0] / lengths[lengths &gt; 0][:, np.newaxis]
print(arr)
# [[0.26726124 0.53452248 0.80178373]
# [0. 0. 0. ]
# [0.47673129 0.57207755 0.66742381]]
</code></pre>

blocks|key|172530|text|一个简单的点积就可以完成这项工作。不需要任何额外的套餐。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|172531|x+=+x/np.sqrt(x.dot(x))|code-block|syntax|javascript|172532|顺便说一句，如果x的范数为零，那么它本质上是一个零向量，并且不能转换为单位向量(范数为1)。如果您想了解np.array([0,0,...0])的情况，请使用|offset|length|style|CODE|172533|norm+=+np.sqrt(x.dot(x))
x+=+x/norm+if+norm+!=+0+else+x|172534|entityMap^0|0|0|8|1|1G|K|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|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

A simple dot product would do the job. No need for any extra package.
<pre><code>x = x/np.sqrt(x.dot(x))
</code></pre>
By the way, if the norm of <code>x</code> is zero, it is inherently a zero vector, and cannot be converted to a unit vector (which has norm 1). If you want to catch the case of <code>np.array([0,0,...0])</code>, then use
<pre><code>norm = np.sqrt(x.dot(x))
x = x/norm if norm != 0 else x
</code></pre>

I would like to convert a NumPy array to a unit vector. More specifically, I am looking for an equivalent version of this normalisation function:
<pre><code>def normalize(v):
 norm = np.linalg.norm(v)
 if norm == 0: 
 return v
 return v / norm
</code></pre>
This function handles the situation where vector <code>v</code> has the norm value of 0.
Is there any similar functions provided in <code>sklearn</code> or <code>numpy</code>?

How to normalize a NumPy array to a unit vector?

我想把一个NumPy数组转换成一个单位向量。更具体地说，我正在寻找此归一化函数的等效版本：def normalize(v):    norm = np.linalg.norm(v)    if norm == 0:        return v    return v / norm此函数用于处理向量v的范数值为0的情...

问如何将NumPy数组归一化为单位向量？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将NumPy数组归一化为单位向量？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将NumPy数组归一化为单位向量？
EN