ML - 数据归一化_ml归一化

作者：weixin_40725706 | 2024-03-20 17:52:40

踩

ml归一化

文章目录

为什么要归一化

当使用距离评估的时候，有些数据取值范围比较大，有些比较小。
比如：特征A 房间面积为 70、100、120，特征B 房间个数为 3，4，5。A,B 值范围差异比较大，如果只根据数值大小来计算，会非常不合理，所以需要进行数据标准化或归一化的操作。

数据归一化：将所有数据映射到等比例空间（同一个尺度中）。

量纲：连续变量进行预处理，进行数据标准化，对于无序的分类变量，需要生成哑变量。

归一化方式

1、最值归一化 normalization

最值归一化：就是常说的 0-1 归一化。
英文：Min-Max scaling，或者叫做 normalization。
是最常用的归一化方式。

方法：压缩到 0–1 的区间上，这样做可以抑制 离群值 对结果的影响。

$x_{scale} = \frac{x - x_{min}}{x_{max} - x_{min}}$

适用于：分布有明显边界的情况；如分数（0–100分），颜色（0–255）；
缺点：受 outlier 影响比较大。比如收入范围分布很广。

2、均值方差归一化 standardization

均值方差归一化，也可以称为标准化。
英文为 standardization 或 Z-score normailization。

方法：将所有数据归一到均值为0 方差为1 的分布中。

计算公式：
$x_{scale} = \frac{x - x_{mean}}{s}$

也可记作： $z=\frac{x-\mu}{\sigma}$
均值为 $\mu=0$ ，标准差 $\sigma=1$ ；

结果数据形态上以原点为对称，特征的取值范围都差不多。

适用于：数据没有明显的边界，有可能存在极端数据值。

测试数据的归一化

是否让训练数据和测试数据各自做归一化？

正确做法：将测试数据集使用训练数据集得到的 mean_train 和 std_train 来进行归一化：
(x_test - mean_train) / std_train

这样做的原因：

测试数据是模拟真实环境；真实环境很有可能无法得到所有的测试数据的均值和方差；
对数据的归一化也是算法的一部分。

sklearn 中的归一化 StandardScaler
https://scikit-learn.org/0.20/modules/generated/sklearn.preprocessing.StandardScaler.html

Python 代码实现归一化

import numpy as np
 
x = np.random.randint(0, 100, size = 100)
 
x
''' 
    array([29, 45, 97, 97,  5, 56, 36, 74, 50, 26, 19, 48, 36, 36, 23,  3, 63,
           10, 85, 74, 89, 24, 93, 11, 78, 79,  4, 75, 10, 86, 85, 39, 28, 24,
           32, 42, 74, 75, 15, 51, 98, 66, 69, 74, 88, 78, 33,  3, 28, 68, 93,
           25, 88, 91, 60, 59, 74, 90, 22, 12, 14, 17, 61, 59, 15, 28, 52,  6,
           97,  7, 75, 87, 58, 21, 37, 68, 26, 18, 49, 93,  3, 82, 57,  2, 92,
           18, 51, 32, 62, 10, 76, 90, 44, 60, 38, 14, 92, 70,  3, 56])
''' 


(x - np.min(x)) / (np.max(x) - np.min(x))
''' 
    array([0.28125   , 0.44791667, 0.98958333, 0.98958333, 0.03125   ,
           0.5625    , 0.35416667, 0.75      , 0.5       , 0.25      ,
           0.17708333, 0.47916667, 0.35416667, 0.35416667, 0.21875   ,
           0.01041667, 0.63541667, 0.08333333, 0.86458333, 0.75      ,
           0.90625   , 0.22916667, 0.94791667, 0.09375   , 0.79166667,
           0.80208333, 0.02083333, 0.76041667, 0.08333333, 0.875     ,
           0.86458333, 0.38541667, 0.27083333, 0.22916667, 0.3125    ,
           0.41666667, 0.75      , 0.76041667, 0.13541667, 0.51041667,
           1.        , 0.66666667, 0.69791667, 0.75      , 0.89583333,
           0.79166667, 0.32291667, 0.01041667, 0.27083333, 0.6875    ,
           0.94791667, 0.23958333, 0.89583333, 0.92708333, 0.60416667,
           0.59375   , 0.75      , 0.91666667, 0.20833333, 0.10416667,
           0.125     , 0.15625   , 0.61458333, 0.59375   , 0.13541667,
           0.27083333, 0.52083333, 0.04166667, 0.98958333, 0.05208333,
           0.76041667, 0.88541667, 0.58333333, 0.19791667, 0.36458333,
           0.6875    , 0.25      , 0.16666667, 0.48958333, 0.94791667,
           0.01041667, 0.83333333, 0.57291667, 0.        , 0.9375    ,
           0.16666667, 0.51041667, 0.3125    , 0.625     , 0.08333333,
           0.77083333, 0.91666667, 0.4375    , 0.60416667, 0.375     ,
           0.125     , 0.9375    , 0.70833333, 0.01041667, 0.5625    ])
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

处理矩阵

X = np.random.randint(0, 100, (50, 2))
X[:10,:]

''' 
    array([[23, 47],
           [18,  6],
           [11,  0],
           [92, 76],
           [78, 57],
           [66,  7],
           [52, 78],
           [97, 83],
           [58, 48],
           [65, 88]])

''' 
# 将 X 转为浮点数
X = np.array(X, dtype = float)
 
# 对第一列数据进行特征归一化
X1 = X[:,0]
X11 = (X1 - np.min(X1))/ (np.max(X1) - np.min(X1))
X11

''' 
    array([0.23232323, 0.18181818, 0.11111111, 0.92929293, 0.78787879,
           0.66666667, 0.52525253, 0.97979798, 0.58585859, 0.65656566,
           0.07070707, 0.94949495, 0.70707071, 0.33333333, 0.11111111,
           0.33333333, 0.90909091, 0.58585859, 0.93939394, 0.38383838,
           0.13131313, 1.        , 0.46464646, 0.98989899, 0.87878788,
           0.58585859, 0.11111111, 0.56565657, 0.19191919, 0.05050505,
           0.54545455, 0.32323232, 0.92929293, 0.82828283, 0.93939394,
           0.11111111, 0.8989899 , 0.13131313, 0.54545455, 0.13131313,
           0.57575758, 0.62626263, 0.95959596, 0.1010101 , 0.82828283,
           0.        , 0.96969697, 0.02020202, 0.5959596 , 0.66666667])
''' 

X2 = X[:,1]
X21 = (X2 - np.min(X2))/ (np.max(X2) - np.min(X2))
X21

''' 
    array([0.47474747, 0.06060606, 0.        , 0.76767677, 0.57575758,
           0.07070707, 0.78787879, 0.83838384, 0.48484848, 0.88888889,
           0.81818182, 0.01010101, 0.1010101 , 0.24242424, 0.17171717,
           0.18181818, 0.11111111, 0.05050505, 0.11111111, 0.63636364,
           0.71717172, 0.87878788, 1.        , 0.28282828, 0.63636364,
           0.02020202, 0.5959596 , 0.91919192, 0.60606061, 0.43434343,
           0.05050505, 0.95959596, 0.42424242, 0.66666667, 0.57575758,
           0.65656566, 0.22222222, 0.33333333, 0.61616162, 0.67676768,
           0.12121212, 0.12121212, 0.67676768, 0.87878788, 0.97979798,
           0.64646465, 0.09090909, 0.41414141, 0.08080808, 0.61616162])
''' 


 
# 查看标准差
print('均值1：', np.mean(X11))
print('方差1：', np.std(X11))
print('均值2：', np.mean(X21))
print('方差2：', np.std(X21))


''' 
    均值1： 0.5335353535353535
    方差1： 0.3290554389302859
    均值2： 0.4656565656565656
    方差2： 0.31417389159473386
''' 

import matplotlib.pyplot as plt
 
plt.scatter(X11, X21)
# 可以看到数值都在 0--1 之间
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

均值方差归一化

# (X - np.min(X)) / (np.max(X) - np.min(X))
  
X12 = (X1 - np.mean(X1))/ np.std(X1)
X22 = (X2 - np.mean(X2))/ np.std(X2)
 
print('均值1：', np.mean(X12))
print('方差1：', np.std(X12))
print('均值2：', np.mean(X22))
print('方差2：', np.std(X22))

# 均值为0，方差为1
''' 
    均值1： -8.881784197001253e-18
    方差1： 1.0
    均值2： -4.5519144009631415e-17
    方差2： 0.9999999999999999
'''

plt.scatter(X12, X22)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

sklearn 的实现

sklearn 使用 Scaler 来处理归一化，封装方法来尽量像其他算法

from sklearn import datasets

iris = datasets.load_iris()

X = iris.data
y = iris.target
 
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42)
 
from sklearn.preprocessing import MinMaxScaler, StandardScaler
 
# 均值方差归一化

std_scaler = StandardScaler()
std_scaler.fit(X_train) 
# StandardScaler(copy=True, with_mean=True, with_std=True)
 
# 查看均值；特征矩阵四个特征对应的均值
std_scaler.mean_
# array([5.80916667, 3.06166667, 3.72666667, 1.18333333])
 
# 查看方差；原来版本使用 std_ ， 后面替换为 scale_ , 意思是 描述数据分布范围；
std_scaler.scale_
# array([0.82036535, 0.44724776, 1.74502786, 0.74914766])
 
X_train_std = std_scaler.transform(X_train)
X_train_std

'''  
    array([[-1.47393679,  1.20365799, -1.56253475, -1.31260282],
           [-0.13307079,  2.99237573, -1.27600637, -1.04563275],
           [ 1.08589829,  0.08570939,  0.38585821,  0.28921757],
             ...
           [-0.01117388, -1.0322392 ,  0.15663551,  0.02224751],
           [ 1.57348593, -0.13788033,  1.24544335,  1.22361279]])
''' 

X_test_std = std_scaler.transform(X_test)
X_test_std
''' 
    array([[ 0.35451684, -0.58505976,  0.55777524,  0.02224751],
           [-0.13307079,  1.65083742, -1.16139502, -1.17911778], 
           ... 
           [-1.23014297, -0.13788033, -1.33331205, -1.17911778],
           [-1.23014297,  0.08570939, -1.2187007 , -1.31260282]])
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

使用归一化后的数据来对 iris 进行 knn 分类

from sklearn.neighbors import KNeighborsClassifier

knn_clf = KNeighborsClassifier(n_neighbors=3)

knn_clf.fit(X_train_std, y_train)
# KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski', metric_params=None, n_jobs=None, n_neighbors=3, p=2, weights='uniform')

 
knn_clf.score(X_test_std, y_test) # 注意上面 X_train 是 std，这里的 X_test 也需要使用 std 之后的
# 1.0
1
2
3
4
5
6
7
8
9
10

其他数据集常见使用

from sklearn.preprocessing import StandardScaler, MinMaxScaler

std_scaler = StandardScaler().fit(df[['alcohol', 'acid']])
df_std = std_scaler.transform(df[['alcohol', 'acid']])

minmax_scaler = StandardScaler().fit( df[['alcohol', 'acid']] )
df_minmax = minmax_scaler.transform( df[['alcohol', 'acid']] )
1
2
3
4
5
6
7

封装归一化类

import numpy as np
 
class StandardScaler:

    def __init__(self):
        self.mean_ = None
        self.scale_ = None
    
    def fit(self, X):
        """根据训练数据集X获得数据的均值和方差"""
        assert X.ndim == 2, "The dimension of X must be 2"
        self.mean_ = np.array([np.mean(X[:,i]) for i in range(X.shape[1])])
        self.scale_ = np.array([np.std(X[:,i]) for i in range(X.shape[1])])
        return self
    
  # 将X根据这个StandardScaler进行均值方差归一化处理
    def transform(self, X):
        """""" 
        # 只处理二维的数据
        assert X.ndim == 2, "The dimension of X must be 2"
        assert self.mean_ is not None and self.scale_ is not None,  "must fit before transform!"
        assert X.shape[1] == len(self.mean_),   "the feature number of X must be equal to mean_ and std_"
    
        resX = np.empty(shape=X.shape, dtype=float)
        for col in range(X.shape[1]):
            resX[:,col] = (X[:,col] - self.mean_[col]) / self.scale_[col]
        return resX
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/275499