如何将 numpy 数组规范化为单位向量

问题描述：

我想将 NumPy 数组转换为单位向量。更具体地说，我正在寻找此规范化函数的等效版本：

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

v此函数处理向量范数值为 0 的情况。

sklearn或中是否提供了类似的功能numpy？

解决方案 1：

如果你使用 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

解决方案 2：

我同意如果这样的函数是包含库的一部分那就太好了。但据我所知，它不是。因此，这里有一个针对任意轴的版本，可以提供最佳性能。

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

解决方案 3：

这也可能对你有用

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

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

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

正如评论中所建议的那样，也可以使用

v/np.linalg.norm(v)

解决方案 4：

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

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

解决方案 5：

如果您不需要最高精度，那么您的功能可以简化为：

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

解决方案 6：

如果您有多维数据并希望将每个轴归一化为其最大值或其总和：

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

解决方案 7：

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

解决方案 8：

您提到了 sci-kit learn，所以我想分享另一种解决方案。

科学工具包学习MinMaxScaler

在 sci-kit learn 中，有一个名为的 API MinMaxScaler，可以根据需要自定义值的范围。

它还为我们处理 NaN 问题。

NaN 被视为缺失值：在 fit 中忽略，在 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

解决方案 9：

如果您使用多维数组，则以下快速解决方案是可能的。

假设我们有一个二维数组，我们想通过最后一个轴对其进行规范化，但有些行具有零范数。

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

解决方案 10：

如果要规范化存储在 3D 张量中的 n 维特征向量，也可以使用 PyTorch：

import numpy as np
from torch import from_numpy
from torch.nn.functional import normalize

vecs = np.random.rand(3, 16, 16, 16)
norm_vecs = normalize(from_numpy(vecs), dim=0, eps=1e-16).numpy()

解决方案 11：

如果您正在使用 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 中太过冗长。

解决方案 12：

不用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.]])

解决方案 13：

对于二维数组，可以使用以下一行代码跨行进行规范化。要跨列进行规范化，只需设置axis=0。

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

解决方案 14：

如果你想要 [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`

解决方案 15：

一个简单的点积就可以完成这个任务。不需要任何额外的包。

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

解决方案 16：

不幸的是，如果是向量数组，简单的解决方案x/numpy.linalg.norm(x)就不起作用。但是使用简单的解决方案，您可以将其强制放入平面列表中，使用列表推导，然后再次使用它来恢复原始形状。x`reshape()`reshape()

s=x.shape
np.array([ v/np.linalg.norm(v)  for v in x.reshape(-1, s[-1])]).reshape(s)

首先我们存储数组的形状

s=x.shape

然后我们将其重塑为一个简单的（一维）向量数组

x.reshape(-1, s[-1])

通过使用 '-1' 参数，reshape()其本质上意味着“取其所需的数量”，例如。如果x是 (4,5,3) 数组，x.reshape(-1,3)则其形状为 (20,3)。使用s[-1]允许向量具有任意维度。

然后我们使用列表推导来遍历数组并一次计算一个单位向量

[ v/np.linalg.norm(v)  for v in x.reshape(-1, s[-1])]

最后我们把它转回一个numpy数组，并让它恢复原来的形状

np.array([ v/np.linalg.norm(v)  for v in x.reshape(-1, s[-1])]).reshape(s)