sklearn实现---归类为5大类
- sklearn.preprocessing.scale()（最常用，易受异常值影响）
- sklearn.preprocessing.StandardScaler()
- sklearn.preprocessing.minmax_scale()（一般缩放到[0,1]之间，若新数据集最大最小值范围有变，需重新minmax_scale）
- sklearn.preprocessing.MinMaxScaler()
- sklearn.preprocessing.maxabs_scale()（为稀疏数据而生）
- sklearn.preprocessing.MaxAbsScaler()
- sklearn.preprocessing.robust_scale()（为异常值而生）
- sklearn.preprocessing.RobustScaler()
- sklearn.preprocessing.normalize()(文本分类or聚类时常用，默认对样本正则化，上述4种默认对列，即特征来规范化）
- sklearn.preprocessing.preprocessing.Normalizer()
借用iris数据集
import pandas as pd
import numpy as np
from sklearn import datasets
iris = datasets.load_iris()
x, y = iris.data, iris.targetprint(x[:10])[[ 5.1 3.5 1.4 0.2][ 4.9 3. 1.4 0.2][ 4.7 3.2 1.3 0.2][ 4.6 3.1 1.5 0.2][ 5. 3.6 1.4 0.2][ 5.4 3.9 1.7 0.4][ 4.6 3.4 1.4 0.3][ 5. 3.4 1.5 0.2][ 4.4 2.9 1.4 0.2][ 4.9 3.1 1.5 0.1]]print(x.shape,x.max(),x.min())(150, 4) 7.9 0.1官网对不同方法的比较文档：
https://scikit-learn.org/stable/auto_examples/preprocessing/plot_all_scaling.html#sphx-glr-auto-examples-preprocessing-plot-all-scaling-py
一.z-score 标准化(zero-mean normalization)
也叫标准差标准化。先减去均值，后除以均方根。提高了数据可比性，同时削弱了数据解释性，是用的最多的数据的标准化方法。输出：每个属性值均值为0，方差为1，呈正态分布。
公式如下：
x* = (x-μ)/σ
( 其中μ为所有样本数据的均值，σ为所有样本数据的标准差。)
使用原因：
部分机器学习算法求解目标函数时，要求特征的均值为0，方差为1.（如：SVM的RFB内核、线性模型的L1和L2正则化）此时，如果某个特征的方差比其他特征的方差大几个数量级别，如：3000:2等，会造成方差大的特征在算法中占据主导地位，使得机器学习效果不佳。
缺点：
- 当特征明显不遵从高斯正态分布时，标准化出来的效果较差。
- 还要注意，均值和标准差受离群点的影响很大，所以如果有很多异常值，使用RobustScaler或robust_scaler 的效果更好。
- scale和 StandardScaler都能接受 scipy.sparse 作为输入，但参数必须设置： with_mean=False。Or会报错： ValueError ，因为默认的中心化会破坏稀疏性，并且此时内存一般会炸，然后崩溃------>dead。
- 实际应用中，经常忽略特征数据的分布形状，移除每个特征均值，划分离散特征的标准差，从而等级化，进而实现数据中心化。
实现：
- sklearn.preprocessing.scale
- sklearn.preprocessing.StandardScaler（两个基本一样，但一般用这个就ok了，比较高级、方法比较齐全）
1.1 sklearn.preprocessing.scale(X, axis=0, with_mean=True, with_std=True, copy=True)
参数说明：
axis=0,默认。计算列。axis=1，则会按行进行标准化。
with_mean、with_std，默认为True，设置将数据转化成0均值、方差为1的标准正态分布，基本不用管。
from sklearn.preprocessing import scale
iris_scale = scale(x)
print(iris_scale[:5]) #显示4个被scale后的特征[[-0.90068117 1.03205722 -1.3412724 -1.31297673][-1.14301691 -0.1249576 -1.3412724 -1.31297673][-1.38535265 0.33784833 -1.39813811 -1.31297673][-1.50652052 0.10644536 -1.2844067 -1.31297673][-1.02184904 1.26346019 -1.3412724 -1.31297673]]print("平均值：",iris_scale.mean(axis=0))
print("样本方差：",iris_scale.std(axis=0))平均值： [ -1.69031455e-15 -1.63702385e-15 -1.48251781e-15 -1.62314606e-15]
样本方差： [ 1. 1. 1. 1.]1.2 class sklearn.preprocessing.StandardScaler(copy=True, with_mean=True, with_std=True)
from sklearn.preprocessing import StandardScaler
Stan_scaler = StandardScaler()
Stan_scaler.fit(x)
x_test = np.array([[6,4,6,2],[4.999,3,5,2.3]]) #假设新的数据集，可当作我们平时用到的测试集
Stan_scaler.transform(x_test)array([[ 0.18982966, 2.18907205, 1.27454998, 1.05353673],[-1.02306072, -0.1249576 , 0.70589294, 1.44795564]])transform时，用到的是原先x中的均值与标准差，相当于我们平时的训练集例的均值与标准差，然后用这两个值去标准化测试集的数据。
二.最小最大值标准化（将数据缩放到一定范围内）
公式如下：
x* = (x-min)/(max-min) （当使用默认[0,1]范围时）
( 其中min为特征的最小值，max为特征的最大值。)
使用原因：
- 对于方差非常小的属性可以增强其稳定性。有时数据集的标准差非常非常小，有时数据中有很多很多零（稀疏数据）需要保存住０元素。
- 维持稀疏矩阵中为0的条目。
缺点：
当数据出现新的最大最小值时，需要重来一遍。
若数值集中且某个数值很大，则规范化后各值接近于0，并且将会相差不大。（如：100、101、102、108、20001）
实现：
- sklearn.preprocessing.minmax_scale
- sklearn.preprocessing.MinMaxScaler(这两者的关系跟上面的标准差标准化差不多，这里只讲后者）
sklearn.preprocessing.MinMaxScaler(feature_range=(0, 1), copy=True)
官网文档：
https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html#sklearn.preprocessing.MinMaxScaler
参数说明：
feature_range : tuple (min, max), default=(0, 1)
转化步骤如下：
X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0)) #每列最大、最小值
X_scaled = X_std * (max - min) + min
from sklearn.preprocessing import MinMaxScaler
MiMaScaler = MinMaxScaler()
MiMaScaler.fit(x)
x_test = np.array([[4.563,4,6,2],[4.999,3,3,1]]) #假设新的数据集，可当作我们平时用到的测试集
MiMaScaler.transform(x_test) #如果新数据集中最大最小值超出原来fit的数据的最大最小值，请注意transform出来的数据将不在[0,1]内，需重新fitarray([[ 0.07305556, 0.83333333, 0.84745763, 0.79166667],[ 0.19416667, 0.41666667, 0.33898305, 0.375 ]])举一个栗子（反例）：当transform的数据集的最大最小值超出fit数据集中的最大最小值
x_test_out = np.array([[9,10,77,88],[33,29,10,3]])
MiMaScaler.transform(x_test_out) array([[ 1.30555556, 3.33333333, 12.88135593, 36.625 ],[ 7.97222222, 11.25 , 1.52542373, 1.20833333]])Obviously，转换出来的数据范围并不在[0,1]内。所以应用中需引起注意。
另外，说明一下：fit_transform存在的意义
1 MiMaScaler.fit(x)
2 MiMaScaler.transform(x)
3 MinMaxScaler().fit_transform(x)
注意第3句效果跟1、2句联合起来一样，第3句省一步，飞快实现转换~~
三.绝对值标准化（暂时这么叫）（将数据缩放到一定范围内，专为稀疏数据而生）
使用原因：
将每个要素缩放到[-1,1]范围，它不会移动/居中数据，因此不会破坏任何稀疏性。
该估计器单独地缩放每个特征，使得训练集中的每个特征的最大绝对值将是1.0。
该缩放器也可以应用于稀疏CSR或CSC矩阵。
实现：
- sklearn.preprocessing.maxabs_scale(X, axis=0, copy=True)
- sklearn.preprocessing.MaxAbsScaler(copy=True)（这两者的关系同上）
from sklearn.preprocessing import MaxAbsScaler
MaAbScaler = MaxAbsScaler().fit(x)
MaAbScaler.transform(x)[:10]array([[ 0.64556962, 0.79545455, 0.20289855, 0.08 ],[ 0.62025316, 0.68181818, 0.20289855, 0.08 ],[ 0.59493671, 0.72727273, 0.1884058 , 0.08 ],[ 0.58227848, 0.70454545, 0.2173913 , 0.08 ],[ 0.63291139, 0.81818182, 0.20289855, 0.08 ],[ 0.6835443 , 0.88636364, 0.24637681, 0.16 ],[ 0.58227848, 0.77272727, 0.20289855, 0.12 ],[ 0.63291139, 0.77272727, 0.2173913 , 0.08 ],[ 0.55696203, 0.65909091, 0.20289855, 0.08 ],[ 0.62025316, 0.70454545, 0.2173913 , 0.04 ]])MaAbScaler.transform(x).max(axis=0)array([ 1., 1., 1., 1.])每列值的Max值的绝对值将会是1.
四.鲁棒性标准化（暂时这么叫）（将数据缩放到一定范围内，专为异常值而生）
使用原因：
标准差标准化（第一种，最常用的那种）对数据中出现的异常值处理能力不佳，因此诞生了robust_scale，这种不怕异常值扰动的数据缩放法。
此Scaler根据分位数范围（默认为IQR：Interquartile Range）删除中位数并缩放数据。 IQR是第1四分位数（第25个分位数）和第3个四分位数（第75个分位数）之间的范围。
实现：
- sklearn.preprocessing.robust_scale(X, axis=0, with_centering=True, with_scaling=True, quantile_range=(25.0, 75.0), copy=True)
- sklearn.preprocessing.RobustScaler(with_centering=True, with_scaling=True, quantile_range=(25.0, 75.0), copy=True)
from sklearn.preprocessing import RobustScaler
Robust_Scaler = RobustScaler()
Robust_Scaler.fit(x)
Robust_Scaler.transform(x)[:10]array([[-0.53846154, 1. , -0.84285714, -0.73333333],[-0.69230769, 0. , -0.84285714, -0.73333333],[-0.84615385, 0.4 , -0.87142857, -0.73333333],[-0.92307692, 0.2 , -0.81428571, -0.73333333],[-0.61538462, 1.2 , -0.84285714, -0.73333333],[-0.30769231, 1.8 , -0.75714286, -0.6 ],[-0.92307692, 0.8 , -0.84285714, -0.66666667],[-0.61538462, 0.8 , -0.81428571, -0.73333333],[-1.07692308, -0.2 , -0.84285714, -0.73333333],[-0.69230769, 0.2 , -0.81428571, -0.8 ]])五.正则化
使用原因：
每个样本被单独缩放，使得其范数等于1。注意，是对每个样本，不再像之前的（默认对列进行规范化）规范化。
文本分类或聚类中常用。可用于密集的numpy数组和scipy.sparse矩阵（如果你想避免复制/转换的负担，请使用CSR格式）
Normalization主要思想是对每个样本计算其p-范数，然后对该样本中每个元素除以该范数，这样处理的结果是使得每个处理后样本的p-范数（l1-norm,l2-norm）等于1。
p-范数的计算公式：||X||p=(|x1|^p+|x2|^p+...+|xn|^p)^1/p
实现：
- sklearn.preprocessing.normalize(X, norm=’l2’, axis=1, copy=True, return_norm=False)
- sklearn.preprocessing.Normalizer(norm=’l2’, copy=True)
5.1 sklearn.preprocessing.normalize(X, norm=’l2’, axis=1, copy=True, return_norm=False)
官方文档:
https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.normalize.html#sklearn.preprocessing.normalize
5.2 sklearn.preprocessing.Normalizer(norm=’l2’, copy=True)
官方文档：
https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.Normalizer.html#sklearn.preprocessing.Normalizer
参数说明：
norm :‘l1’,‘l2’, or ‘max’, 默认l2。
from sklearn.preprocessing import Normalizer
Normalizer_ = Normalizer()
Normalizer_.fit(x)
Normalizer_.transform(x)[:10]array([[ 0.80377277, 0.55160877, 0.22064351, 0.0315205 ],[ 0.82813287, 0.50702013, 0.23660939, 0.03380134],[ 0.80533308, 0.54831188, 0.2227517 , 0.03426949],[ 0.80003025, 0.53915082, 0.26087943, 0.03478392],[ 0.790965 , 0.5694948 , 0.2214702 , 0.0316386 ],[ 0.78417499, 0.5663486 , 0.2468699 , 0.05808704],[ 0.78010936, 0.57660257, 0.23742459, 0.0508767 ],[ 0.80218492, 0.54548574, 0.24065548, 0.0320874 ],[ 0.80642366, 0.5315065 , 0.25658935, 0.03665562],[ 0.81803119, 0.51752994, 0.25041771, 0.01669451]]) 0.80377277* 0.80377277+0.55160877*0.55160877+ 0.22064351*0.22064351 + 0.0315205 * 0.0315205 1.0000000013597559下面验证一下每个样本的范数，随机挑选第四个样本、第77个样本来验证：
output_3 = []
aa = Normalizer_.transform(x)[3]
for i in aa:output_3.append(i*i)
print(output_3)
print("样本范数：",sum(output_3))[0.64004839685420423, 0.29068360556563821, 0.068058076225045352, 0.0012099213551119174]
样本范数： 1.0output_76 = []
bb = Normalizer_.transform(x)[76]
for i in bb:output_76.append(i*i)
print(output_76)
print("样本范数：",sum(output_76))[0.58472432979261513, 0.099140111279716753, 0.29135053110773901, 0.024785027819929188]
样本范数： 1.0拓：向量范数的内容：
欢迎指错。 Thanks！
