python 数据标准化常用方法，z-score\min-max标准化

                                            <div class="article-copyright">
            <span class="creativecommons">
            <a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">
                </a>
        <span>
            版权声明：本文为博主原创文章，遵循<a href="http://creativecommons.org/licenses/by-sa/4.0/" target="_blank" rel="noopener"> CC 4.0 BY-SA </a>版权协议，转载请附上原文出处链接和本声明。            </span>
           <div class="article-source-link2222">
                本文链接：<a href="https://blog.csdn.net/HHTNAN/article/details/80668746">https://blog.csdn.net/HHTNAN/article/details/80668746</a>
            </div>
        </span>
                </div>
                                                <link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/ck_htmledit_views-3019150162.css">
                                    <div id="content_views" class="markdown_views prism-atom-one-dark">
                <!-- flowchart 箭头图标 勿删 -->
                <svg xmlns="http://www.w3.org/2000/svg" style="display: none;">
                    <path stroke-linecap="round" d="M5,0 0,2.5 5,5z" id="raphael-marker-block" style="-webkit-tap-highlight-color: rgba(0, 0, 0, 0);"></path>
                </svg>
                                        <p></p><div class="toc"><h3>文章目录</h3><ul><ul><ul><ul><li><a href="#_4" rel="nofollow" data-token="b9ab0ec6298f266af105c1dfcfe9a077" target="_self">数据标准化</a></li><li><a href="#_7" rel="nofollow" data-token="cd47b6def2f5b8901521d02b02d6f57a" target="_self">常见的几种形式</a></li><ul><li><a href="#Minmax__9" rel="nofollow" data-token="458337058966d39bdf02c529666ac5d8" target="_self">Min-max 标准化数据缩放：</a></li><li><a href="#zscore__16" rel="nofollow" data-token="99cf14c6d9543c132cc6f29b3fc2e5fd" target="_self">z-score 标准化</a></li></ul><li><a href="#Python_21" rel="nofollow" data-token="ee34e32b391d718d7cd032226fbf3314" target="_self">Python标准化预处理函数：</a></li><li><a href="#_41" rel="nofollow" data-token="c7f3081d3c675884c7810bd6cd5d834a" target="_self">对应的标准化预处理类：</a></li><ul><ul><li><a href="#classpreprocessingStandardScalercopyTrue_with_meanTruewith_stdTrue_42" rel="nofollow" data-token="e91785b8f56adb2f4d9b6ffc1421853c" target="_self">classpreprocessing.StandardScaler(copy=True, with_mean=True,with_std=True)：</a></li><li><a href="#classpreprocessingMinMaxScalerfeature_range0_1copyTrue_53" rel="nofollow" data-token="22dda7dd5f4e901132a6a12fd3f4c9c3" target="_self">classpreprocessing.MinMaxScaler(feature_range=(0, 1),copy=True)：</a></li><li><a href="#classpreprocessingMaxAbsScalercopyTrue_63" rel="nofollow" data-token="19df8e888e4535b888cb788f1bab2e70" target="_self">classpreprocessing.MaxAbsScaler(copy=True)：</a></li><li><a href="#classpreprocessingKernelCenterer_80" rel="nofollow" data-token="00333c1870cb0f048d299de70c371726" target="_self">classpreprocessing.KernelCenterer：</a></li><li><a href="#_82" rel="nofollow" data-token="ca558b2cf19a0f53801d4d83916dd19a" target="_self">以上几个标准化类的方法：</a></li></ul></ul><li><a href="#_93" rel="nofollow" data-token="a3736b80752b1bb7fb5cb1324e460739" target="_self">数据归一化</a></li><li><a href="#_119" rel="nofollow" data-token="b7bf2e654791c15fa85954d7d3ec541a" target="_self">类别数据编码</a></li><li><a href="#_160" rel="nofollow" data-token="5acb6145f51a0b38b123fb1a11ae18e2" target="_self">数据缺失</a></li><li><a href="#_176" rel="nofollow" data-token="aacf7ef70c359f839c54d903f857dfc5" target="_self">生成多项式数据</a></li><li><a href="#_195" rel="nofollow" data-token="d344075690b62620c794600c87f4621e" target="_self">增加伪特征</a></li><li><a href="#_202" rel="nofollow" data-token="b5be9292109b1cd8f2baf6a098334716" target="_self">自定义数据转换</a></li><li><a href="#_214" rel="nofollow" data-token="8b04ee4c8548401018c391146e183514" target="_self">案例</a></li><ul><li><a href="#scale_237" rel="nofollow" data-token="920a6234eed7d76f766e5e87ebf70ae1" target="_self">使用scale方法进行标准化</a></li></ul><li><a href="#MaxMinScaler_252" rel="nofollow" data-token="4b86c1ca3c6359b8faae1384b2c46d3c" target="_self">MaxMinScaler方法</a></li></ul></ul></ul></ul></div><p></p>

2018博客之星评选，如果喜欢我的文章，请投我一票，编号：No.009 支持连接 ,万分感谢！！！

数据标准化

在数据分析之前，我们通常需要先将数据标准化(normalization)，利用标准化后的数据进行数据分析。数据标准化也就是统计数据的指数化。数据标准化处理主要包括数据同趋化处理和无量纲化处理两个方面。数据同趋化处理主要解决不同性质数据问题，对不同性质指标直接加总不能正确反映不同作用力的综合结果，须先考虑改变逆指标数据性质，使所有指标对测评方案的作用力同趋化，再加总才能得出正确结果。数据无量纲化处理主要解决数据的可比性。数据标准化的方法有很多种，常用的有"最小-最大标准化"、"Z-score标准化"和"按小数定标标准化"等。经过上述标准化处理，原始数据均转换为无量纲化指标测评值，即各指标值都处于同一个数量级别上，可以进行综合测评分析。

常见的几种形式

通常数据标准化有以下几种：

Min-max 标准化数据缩放：

$x’=x-xminxmax-xminx’=x-xminxmax-xminx’=\frac{x-x_{min}}{x_{max}-x_{min}}$x’=δx−μ​ μ为数据的均值 δ为方差

Python标准化预处理函数：

preprocessing.scale(X,axis=0, with_mean=True, with_std=True, copy=True)：

 
 

 
 
1

将数据转化为标准正态分布（均值为0，方差为1）

preprocessing.minmax_scale(X,feature_range=(0, 1), axis=0, copy=True)：

 
 

 
 
1

将数据在缩放在固定区间，默认缩放到区间 [0, 1]

preprocessing.maxabs_scale(X,axis=0, copy=True)：

 
 

 
 
1

数据的缩放比例为绝对值最大值，并保留正负号，即在区间 [-1.0, 1.0] 内。唯一可用于稀疏数据
scipy.sparse的标准化

preprocessing.robust_scale(X,axis=0, with_centering=True, with_scaling=True,copy=True)：

 
 

 
 
1

通过 Interquartile Range (IQR) 标准化数据，即四分之一和四分之三分位点之间

对应的标准化预处理类：

classpreprocessing.StandardScaler(copy=True, with_mean=True,with_std=True)：

标准正态分布化的类
属性：

scale_：ndarray，缩放比例
mean_：ndarray，均值
var_：ndarray，方差
n_samples_seen_：int，已处理的样本个数，调用partial_fit()时会累加，调用fit()会重设

 
 

 
 
1
2
3
4

classpreprocessing.MinMaxScaler(feature_range=(0, 1),copy=True)：

将数据在缩放在固定区间的类，默认缩放到区间 [0, 1]，对于方差非常小的属性可以增强其稳定性，维持稀疏矩阵中为0的条目
属性：

min_：ndarray，缩放后的最小值偏移量
scale_：ndarray，缩放比例
data_min_：ndarray，数据最小值
data_max_：ndarray，数据最大值
data_range_：ndarray，数据最大最小范围的长度

 
 

 
 
1
2
3
4
5

classpreprocessing.MaxAbsScaler(copy=True)：

数据的缩放比例为绝对值最大值，并保留正负号，即在区间 [-1.0, 1.0] 内。可以用于稀疏数据scipy.sparse
属性：

scale_：ndarray，缩放比例
max_abs_：ndarray，绝对值最大值
n_samples_seen_：int，已处理的样本个数

 
 

 
 
1
2
3

classpreprocessing.RobustScaler(with_centering=True,with_scaling=True, copy=True)：

 
 

 
 
1

通过 Interquartile Range (IQR) 标准化数据，即四分之一和四分之三分位点之间
属性：

center_：ndarray，中心点
scale_：ndarray，缩放比例

 
 

 
 
1
2

classpreprocessing.KernelCenterer：

生成 kernel 矩阵，用于将 svm kernel 的数据标准化（参考资料不全）

以上几个标准化类的方法：

fit(X[,y])：根据数据 X 的值，设置标准化缩放的比例
transform(X[,y, copy])：用之前设置的比例标准化 X
fit_transform(X[, y])：根据 X设置标准化缩放比例并标准化
partial_fit(X[,y])：累加性的计算缩放比例
inverse_transform(X[,copy])：将标准化后的数据转换成原数据比例
get_params([deep])：获取参数
set_params(**params)：设置参数

数据归一化

preprocessing.normalize(X,norm='l2', axis=1, copy=True)：

 
 

 
 
1

将数据归一化到区间 [0, 1]，norm 可取值 ‘l1’、‘l2’、‘max’。可用于稀疏数据 scipy.sparse

classpreprocessing.Normalizer(norm='l2', copy=True)：

 
 

 
 
1

数据归一化的类。可用于稀疏数据 scipy.sparse

方法：fit(X[,y])、transform(X[, y,copy])、fit_transform(X[,y])、get_params([deep])、
set_params(**params)

 
 

 
 
1
2

数据二值化

preprocessing.binarize(X,threshold=0.0, copy=True)：

 
 

 
 
1

将数据转化为 0 和 1，其中小于等于 threshold 为 0，可用于稀疏数据 scipy.sparse

classpreprocessing.Binarizer(threshold=0.0,copy=True)：

 
 

 
 
1

二值化处理的类，可用于稀疏数据 scipy.sparse

方法：fit(X[,y])、transform(X[, y,copy])、fit_transform(X[,y])、get_params([deep])、set_params(**params)，其中fit 函数不会做任何操作

类别数据编码

数据的某些特征是文本，特征是无序的，比如国籍，但数字是有序的，所以不能直接用数字编码

classpreprocessing.OneHotEncoder(n_values='auto',categorical_features='all', dtype='float', sparse=True,handle_unknown='error')：

 
 

 
 
1

将具有多个类别的特征转换为多维二元特征，所有二元特征互斥，当某个二元特征为 1 时，表示取某个类别
参数：
n_values：处理的类别个数，可以为‘auto’，int或者 int数组
categorical_features：被当作类别来处理的特征，可以为“all”或者下标数组指定或者mask数组指定
属性：
active_features_：ndarray，实际处理的类别数
feature_indices_：ndarray，第 i个原特征在转换后的特征中的下标在 feature_indices_[i] 和 feature_indices_[i+1]之间
n_values_：ndarray，每维的类别数
方法：fit(X[, y])、transform(X[, y,copy])、fit_transform(X[,y])、get_params([deep])、set_params(**params)

classpreprocessing.LabelBinarizer(neg_label=0, pos_label=1,sparse_output=False)：

 
 

 
 
1

和 OneHotEncoder 类似，将类别特征转换为多维二元特征，并将每个特征扩展成用一维表示
属性：
classes：ndarry，所有类别的值
y_type_：str
multilabel_：bool
sparse_input_：bool
indicator_matrix_：str
方法：fit(X[,y])、transform(X[, y,copy])、fit_transform(X[,y])、inverse_transform(y)、get_params([deep])、set_params(**params)

preprocessing.label_binarize(y,classes, neg_label=0, pos_label=1, sparse_output=False)：
LabelBinarizer 类对应的处理函数
classpreprocessing.LabelEncoder：
将类别特征标记为 0 到 n_classes - 1 的数
方法：fit(X[,y])、transform(X[, y,copy])、fit_transform(X[,y])、inverse_transform(y)、get_params([deep])、set_params(**params)
classpreprocessing.MultiLabelBinarizer(classes=None,sparse_output=False)：
和 LabelBinarizer 类似

feature_extraction.DictVectorizer类
patsy包

数据缺失

classpreprocessing.Imputer(missing_values='NaN',strategy='mean', axis=0, verbose=0, copy=True)：

 
 

 
 
1

参数：

missing_values：int 或者“NaN”，对np.nan的值用 "NaN"
strategy："mean"、"median"、"most_frequent"

 
 

 
 
1
2

属性：

statistics_：ndarray，当axis==0时，取每列填补时用的值

 
 

 
 
1

方法：fit(X[,y])、transform(X[, y,copy])、fit_transform(X[,y])、get_params([deep])、set_params(**params)

生成多项式数据

可以将数据多项式结合生成多维特征，比如 [a,b] 的二次多项式特征为 [1, a, b, a^2, ab, b^2]

classpreprocessing.PolynomialFeatures(degree=2,interaction_only=False, include_bias=True)：

 
 

 
 
1

参数：

degree：int，多项式次数
interaction_only：boolean，是否只产生交叉相乘的特征
include_bias：boolean，是否包含偏移列，即全为1 的列
属性：
powers_：ndarray，二维数组。powers_[i,j] 表示第 i 维输出中包含的第 j 维输入的次数
n_input_features_：int，输入维数
n_output_features_：int，输出维数

 
 

 
 
1
2
3
4
5
6
7

方法：
fit(X[,y])、transform(X[, y,copy])、fit_transform(X[,y])、get_params([deep])、set_params(**params)

增加伪特征

preprocessing.add_dummy_feature(X,value=1.0)：

 
 

 
 
1

在 X 的第一列插入值为 value 的列

自定义数据转换

可以使用自定义的 python函数来转换数据

classpreprocessing.FunctionTransformer(func=None,validate=True, accept_sparse=False, pass_y=False)：

 
 

 
 
1

方法：

fit(X[,y])、transform(X[, y,copy])、fit_transform(X[,y])、get_params([deep])、set_params(**params)

 
 

 
 
1

案例

自己写一个公式来进行标准化：

def my_scale(data):
    mean = sum(data) / len(data)  #先求均值
    variance = ( sum([ (I-mean) ** 2 for I in data])  ) / len(data)  #再求方差
    normal = [(I - mean) / (variance ) ** 0.5 for I in data]  #按照公式标准化
    return normal

 
 

 
 
1
2
3
4
5

利用pandas处理
对每一列进行标准化（每个数值在0-1之间）

import numpy as np  
import pandas as pd  
np.random.seed(1)  
df = pd.DataFrame(np.random.randn(4,4)* 4 + 3)  
方法一  
df=df.apply(lambda x: (x - np.min(x)) / (np.max(x) - np.min(x)))    
方法二  
df=(df - df.min()) / (df.max() - df.min())  

 
 

 
 
1
2
3
4
5
6
7
8

使用scale方法进行标准化

from sklearn import preprocessing
import numpy as np
X_train = np.array([[ 1., -1.,  2.],
                    [ 2.,  0.,  0.],
                    [ 0.,  1., -1.]])

X_scaled = preprocessing.scale(X_train)
print(X_scaled)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

[[ 0. -1.22474487 1.33630621]
[ 1.22474487 0. -0.26726124]
[-1.22474487 1.22474487 -1.06904497]]

MaxMinScaler方法

import numpy as np
from sklearn import preprocessing

X_train = np.array([[ 1., -1., 2.],
[ 2., 0., 0.],
[ 0., 1., -1.]])

min_max_sacler = preprocessing.MinMaxScaler()
min_max_sacler.fit(X_train)

print(min_max_sacler.transform(X_train))

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

[[0.5 0. 1. ]
[1. 0.5 0.33333333]
[0. 1. 0. ]]

                                </div>
            <link href="https://csdnimg.cn/release/phoenix/mdeditor/markdown_views-095d4a0b23.css" rel="stylesheet">