我想将 NumPy 数组转换为单位向量。更具体地说，我正在寻找此规范化函数的等效版本：
def normalize(v):
norm = np.linalg.norm(v)
if norm == 0:
return v
return v / norm
此函数处理向量v的范数值为 0 的情况。
sklearn或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)))
这可能也适合您
import numpy as np
normalized_v = v / np.sqrt(np.sum(v**2))
但当v长度为 0 时失败。
在这种情况下，引入一个小常数来防止零除就可以解决这个问题。
正如评论中所建议的，也可以使用
v/np.linalg.norm(v)
为了避免零除法，我使用了eps，但这可能不是很好。
def normalize(v):
norm=np.linalg.norm(v)
if norm==0:
norm=np.finfo(v.dtype).eps
return v/norm
如果您不需要最高精度，您的函数可以简化为：
v_norm = v / (np.linalg.norm(v) + 1e-16)
如果您有多维数据，并且希望将每个轴归一化为其最大值或总和：
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
使用峰峰值函数。
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
你提到了sci-kit learn，所以我想分享另一个解决方案。
科普套件学习MinMaxScaler
在sci-kit learn中，有一个名为MinMaxScaler的API，它可以根据需要自定义值范围。
它还为我们处理 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
在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))
如果您使用多维数组，则可以遵循快速解决方案。
假设我们有 2D 数组，我们希望按最后一个轴对其进行规范化，而某些行的范数为零。
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]]
如果你想规范化存储在 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 中太冗长了。
没有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.]])
对于 2D 数组，可以使用以下单行跨行规范化。要跨列规范化，只需设置 axis=0 。
a / np.linalg.norm(a, axis=1, keepdims=True)
如果你想要 [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