如何在NumPy中规范化数组？

Question

我想拥有一个NumPy数组的规范.更具体地说,我正在寻找此功能的等效版本

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

是否有类似的东西skearn还是numpy？

此函数适用于v0向量的情况.

Answer 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

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

Answer 3

您可以指定ord来获得L1规范.为了避免零分割,我使用eps,但这可能不是很好.

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

Answer 4

你提到了sci-kit学习，所以我想分享另一个解决方案。

sci-kit 学习 MinMaxScaler

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

它还为我们处理 NaN 问题。

NaN 被视为缺失值：在拟合中被忽略，并在转换中保持不变。... 见参考文献 [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

Answer 5

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

Answer 6

如果您使用多维数组遵循快速解决方案是可能的。

假设我们有一个二维数组，我们希望通过最后一个轴对其进行归一化，而有些行的范数为零。

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

Answer 7

如果您有多维数据并希望每个轴都标准化为自身:

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 峰峰功能.

Answer 8

如果您正在处理 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 中过于冗长。

Answer 9

这可能也适合你

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

但是当v长度为0 时失败.

Answer 10

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

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

Answer 11

没有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.]])

Answer 12

如果要对存储在 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()

Answer 13

对于 2D 数组，您可以使用以下一行来规范化跨行。要跨列标准化，只需设置axis=0.

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