如何规范化一个NumPy数组到一个单位矢量?

如果你正在使用scikit-learn，你可以使用sklearn.preprocessing.normalize:

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

我同意，如果这样的函数是包含的库的一部分，那就太好了。但据我所知，不是这样的。这是一个任意轴都能给出最佳性能的版本。

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)))

为了避免零除法，我用eps，但这可能不太好。

def normalize(v):
norm=np.linalg.norm(v)
if norm==0:
norm=np.finfo(v.dtype).eps
return v/norm

在Christoph Gohlke编写的流行转换模块中，还有函数unit_vector()用于规范化向量:

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))

如果你有多维数据，并希望每个轴都归一化到最大值或总和:

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

使用numpys 高峰到高峰函数。

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

这可能对你也有用

import numpy as np
normalized_v = v / np.sqrt(np.sum(v**2))

但当v的长度为0时失败。

在这种情况下，引入一个小常数来防止零除法可以解决这个问题。

正如评论中所建议的，人们也可以使用

v/np.linalg.norm(v)

如果你想将存储在3D张量中的n维特征向量归一化，你也可以使用PyTorch:

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()

如果你正在处理3D向量，你可以使用vg工具带简单地做到这一点。它是numpy之上的一个轻量级层，支持单值和堆叠向量。

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

我在上次创业时创建了这个库，它的动机是这样的:简单的想法在NumPy中太啰嗦了。

你提到了scikit learn，所以我想分享另一个解决方案。

MinMaxScaler是什么意思

在sci-kit learn中，有一个叫做MinMaxScaler的API，它可以自定义你喜欢的值范围。

它也为我们处理了NaN问题。

nan被视为缺失值:忽略适合性，并保持 在transform. ...参见参考[1]

代码示例

代码很简单，只需输入即可

# Let's say X_train is your input dataframe
from sklearn.preprocessing import MinMaxScaler
# call MinMaxScaler object
min_max_scaler = MinMaxScaler()
# feed in a numpy array
X_train_norm = min_max_scaler.fit_transform(X_train.values)
# wrap it up if you need a dataframe
df = pd.DataFrame(X_train_norm)

• [1] sklearn.preprocessing.MinMaxScaler

如果你不需要最大的精度，你的函数可以简化为:

v_norm = v / (np.linalg.norm(v) + 1e-16)

没有sklearn，只使用numpy。 只需定义一个函数:.

假设行是变量和列是样本 (axis= 1):

import numpy as np


# Example array
X = np.array([[1,2,3],[4,5,6]])


def stdmtx(X):
means = X.mean(axis =1)
stds = X.std(axis= 1, ddof=1)
X= X - means[:, np.newaxis]
X= X / stds[:, np.newaxis]
return np.nan_to_num(X)

输出:

X
array([[1, 2, 3],
[4, 5, 6]])


stdmtx(X)
array([[-1.,  0.,  1.],
[-1.,  0.,  1.]])

如果你使用多维数组，快速解决是可能的。

假设我们有一个二维数组，我们想用最后一个轴归一化，而有些行有零范数。

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]]

如果你想要[0;1] for 1d-array然后使用

(a - a.min(axis=0)) / (a.max(axis=0) - a.min(axis=0))

其中a是你的1d-array。

一个例子:

>>> a = np.array([0, 1, 2, 4, 5, 2])
>>> (a - a.min(axis=0)) / (a.max(axis=0) - a.min(axis=0))
array([0. , 0.2, 0.4, 0.8, 1. , 0.4])

对于保存值之间的比例有一个限制:1d-array必须至少有一个0，并且由0和positive数字组成。

一个简单的点积就可以了。不需要任何额外的包装。

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

顺便说一下，如果x的范数为零，则它本质上是一个零向量，并且不能转换为单位向量(单位向量的范数为1)。如果你想捕获np.array([0,0,...0])的情况，则使用

norm = np.sqrt(x.dot(x))
x = x/norm if norm != 0 else x

对于2D数组，可以使用下面的一行代码跨行规范化。要跨列归一化，只需设置axis=0。

a / np.linalg.norm(a, axis=1, keepdims=True)