standardscaler「standardscaler函数」
数据预处理的无量纲化
1.1数据无量纲化
将不同规格的数据转化到同一规格或是将不同分布的数据转换到某个特定分布的需求，这种需求统称将数据“无量纲化”。在梯度和矩阵为核心的算法中，无量纲化可以加快求解速度，而在距离类模型中，无量纲化可以帮助我们提升模型精度，避免某一个取值范围特别大的特征对距离计算造成影响。决策树和树的集成模型是一个特例，它们不需要无量纲化，它们可以把任何数据处理的很好。
数据的无量纲化可以是线性的也可以是非线性的，线性的无量纲化包括中心化处理和缩放处理。中心化的本质是将所有记录减去一个固定值，就是使数据样本平移到某个位置，缩放的本质就是通过除以一个固定值，将数据固定到某个范围之中，取对数也算一种缩放。
1.2 preprocession.MinMaxScaler
当数据按照最小值中心化后，再按极差（最大值-最小值）缩放，数据移动到了最小值个单位，并且会收敛到[0,1]之间，这个过程称为数据的归一化（Normalization,又称Min-Max-Scaler）,Normalization是归一化的意思不是正则化，正则化是regularization,不是数据预处理的手段。归一化后数据服从正态分布。
sklearn中，使用preprocess.MinMaxScaler来实现数据归一化，MinMaxScaler重要参数：feature_range,控制数据压缩到的范围，默认是[0,1]
1.3 preprocession.StandardScaler
当数据按均值中心化后，再按标准差缩放，数据会浮动均值为0，方差为1的正态分布（标准的正态分布），而这个过程称为数据标准化（StandardScaler,又称Z-score normalization）
对于StandardScaler和MinMaxScaler来说，空值NaN会被当成缺失值，在fit的时候忽视，在transform的时候保存缺失NaN的状态显示，无量纲化的过程不是具体的算法，但是在fit接口中，依然只允许导入至少二维数组，如果导入一维的数组会报错。
1.4 StandardScaler和MinMaxScaler选哪个？
大多数机器学习算法中，都是用StandardScaler来进行特征的缩放，因为MinMaxScaler对异常值非常敏感，在PCA,聚类，逻辑回归，SVM,神经网络这些算法中，StandardScaler会是比较好的选择。
MinMaxScaler用在不涉及度量距离、梯度、协方差计算以及数据需要被压缩到特定区间时使用，比如数字图像处理中量化像素强度时，都会使用MinMaxScaler将数据压缩到[0,1]区间之间。
可以先尝试一下StandardScaler，效果不好再换MinMaxScaler。
Sklearn中其他缩放处理：
［转］sklearn中MinMaxScaler/StandardScaler的区别
原文链接：，感谢作者
通常来说，它们都是指特征工程中的特征缩放过程，由于中文翻译的原因，网上对它们的解释也是五花八门，但其实我们不考虑它们的名字，直接看它们的作用和操作方法，可能会更容易理解。
使用特征缩放的作用是：
使不同量纲的特征处于同一数值量级，减少方差大的特征的影响，使模型更准确。
加快学习算法的收敛速度。
参考sklearn的官方文档的数据预处理章节，
5.3. Preprocessing datascikit-learn.org
缩放过程可以分为以下几种：
缩放到均值为0，方差为1（ Standardization—— StandardScaler()）
缩放到0和1之间（ Standardization—— MinMaxScaler()）
缩放到-1和1之间（ Standardization—— MaxAbsScaler()）
缩放到0和1之间，保留原始数据的分布（ Normalization—— Normalizer()）
1就是常说的z-score归一化，2是min-max归一化。
举个例子来看看它们之间的区别，假设一个数据集包括「身高」和「体重」两个特征，它们都满足正态分布，画出原始数据图像为：
使用1.StandardScaler()缩放，结果为：
使用2.MinMaxScaler()缩放，结果为：
使用3.MaxAbsScaler()缩放，结果为：
使用4.Normalizer()缩放，结果为：
按需选择。
附：
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import preprocessing
def plot(data, title):
sns.set_style('dark')
f, ax = plt.subplots()
ax.set(ylabel='frequency')
ax.set(xlabel='height(blue) / weight(green)')
ax.set(title=title)
sns.distplot(data[:, 0:1], color='blue')
sns.distplot(data[:, 1:2], color='green')
plt.savefig(title + '.png')
plt.show()
np.random.seed(42)
height = np.random.normal(loc=168, scale=5, size=1000).reshape(-1, 1)
weight = np.random.normal(loc=70, scale=10, size=1000).reshape(-1, 1)
original_data = np.concatenate((height, weight), axis=1)
plot(original_data, 'Original')
standard_scaler_data = preprocessing.StandardScaler().fit_transform(original_data)
plot(standard_scaler_data, 'StandardScaler')
min_max_scaler_data = preprocessing.MinMaxScaler().fit_transform(original_data)
plot(min_max_scaler_data, 'MinMaxScaler')
max_abs_scaler_data = preprocessing.MaxAbsScaler().fit_transform(original_data)
plot(max_abs_scaler_data, 'MaxAbsScaler')
normalizer_data = preprocessing.Normalizer().fit_transform(original_data)
plot(normalizer_data, 'Normalizer')
robust_scaler_data = preprocessing.RobustScaler().fit_transform(original_data)
plot(robust_scaler_data, 'RobustScaler')
sklearn.preprocessing.scale 和standardscale的区别
一、标准化（Z-Score），或者去除均值和方差缩放
公式为：(X-mean)/std 计算时对每个属性/每列分别进行。
将数据按期属性（按列进行）减去其均值，并处以其方差。得到的结果是，对于每个属性/每列来说所有数据都聚集在0附近，方差为1。
实现时，有两种不同的方式：
使用sklearn.preprocessing.scale()函数，可以直接将给定数据进行标准化。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from sklearn import preprocessing
import numpy as np
X = np.array([[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]])
X_scaled = preprocessing.scale(X)
X_scaled
array([[ 0. ..., -1.22..., 1.33...],
[ 1.22..., 0. ..., -0.26...],
[-1.22..., 1.22..., -1.06...]])
#处理后数据的均值和方差
X_scaled.mean(axis=0)
array([ 0., 0., 0.])
X_scaled.std(axis=0)
array([ 1., 1., 1.])
使用sklearn.preprocessing.StandardScaler类，使用该类的好处在于可以保存训练集中的参数（均值、方差）直接使用其对象转换测试集数据。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
scaler = preprocessing.StandardScaler().fit(X)
scaler
StandardScaler(copy=True, with_mean=True, with_std=True)
scaler.mean_
array([ 1. ..., 0. ..., 0.33...])
scaler.std_
array([ 0.81..., 0.81..., 1.24...])
scaler.transform(X)
array([[ 0. ..., -1.22..., 1.33...],
[ 1.22..., 0. ..., -0.26...],
[-1.22..., 1.22..., -1.06...]])
#可以直接使用训练集对测试集数据进行转换
scaler.transform([[-1., 1., 0.]])
array([[-2.44..., 1.22..., -0.26...]])
二、将属性缩放到一个指定范围
除了上述介绍的方法之外，另一种常用的方法是将属性缩放到一个指定的最大和最小值（通常是1-0）之间，这可以通过preprocessing.MinMaxScaler类实现。
使用这种方法的目的包括：
1、对于方差非常小的属性可以增强其稳定性。
2、维持稀疏矩阵中为0的条目。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
X_train = np.array([[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]])
...
min_max_scaler = preprocessing.MinMaxScaler()
X_train_minmax = min_max_scaler.fit_transform(X_train)
X_train_minmax
array([[ 0.5 , 0. , 1. ],
[ 1. , 0.5 , 0.33333333],
[ 0. , 1. , 0. ]])
#将相同的缩放应用到测试集数据中
X_test = np.array([[ -3., -1., 4.]])
X_test_minmax = min_max_scaler.transform(X_test)
X_test_minmax
array([[-1.5 , 0. , 1.66666667]])
#缩放因子等属性
min_max_scaler.scale_
array([ 0.5 , 0.5 , 0.33...])
min_max_scaler.min_
array([ 0. , 0.5 , 0.33...])
当然，在构造类对象的时候也可以直接指定最大最小值的范围：feature_range=(min, max)，此时应用的公式变为：
X_std=(X-X.min(axis=0))/(X.max(axis=0)-X.min(axis=0))
X_scaled=X_std/(max-min)+min
三、正则化（Normalization）
正则化的过程是将每个样本缩放到单位范数（每个样本的范数为1），如果后面要使用如二次型（点积）或者其它核方法计算两个样本之间的相似性这个方**很有用。
Normalization主要思想是对每个样本计算其p-范数，然后对该样本中每个元素除以该范数，这样处理的结果是使得每个处理后样本的p-范数（l1-norm,l2-norm）等于1。
p-范数的计算公式：||X||p=(|x1|^p+|x2|^p+...+|xn|^p)^1/p
该方法主要应用于文本分类和聚类中。例如，对于两个TF-IDF向量的l2-norm进行点积，就可以得到这两个向量的余弦相似性。
1、可以使用preprocessing.normalize()函数对指定数据进行转换：
1
2
3
4
5
6
7
8
9
X = [[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]]
X_normalized = preprocessing.normalize(X, norm='l2')
X_normalized
array([[ 0.40..., -0.40..., 0.81...],
[ 1. ..., 0. ..., 0. ...],
[ 0. ..., 0.70..., -0.70...]])
2、可以使用processing.Normalizer()类实现对训练集和测试集的拟合和转换：
1
2
3
4
5
6
7
8
9
10
11
12
normalizer = preprocessing.Normalizer().fit(X) # fit does nothing
normalizer
Normalizer(copy=True, norm='l2')
normalizer.transform(X)
array([[ 0.40..., -0.40..., 0.81...],
[ 1. ..., 0. ..., 0. ...],
[ 0. ..., 0.70..., -0.70...]])
normalizer.transform([[-1., 1., 0.]])
array([[-0.70..., 0.70..., 0. ...]])
补充：
数据变换-归一化与标准化
一般在机器学习的 模型训练 之前，有一个比较重要的步骤是 数据变换 。
因为，一般情况下，原始数据的各个特征的值并不在一个统一的范围内，这样数据之间就没有 可比性 。
数据变换的目的是 将不同渠道，不同量级的数据转化到统一的范围之内，方便后续的分析处理 。
数据变换的方法有很多，比如 数据平滑，数据聚集，数据概化，数据规范化 和 属性构造 等。
本篇文章主要介绍数据规范化，这是一种比较常用，也比较简单的方法。
数据规范化是 使属性数据按比例缩放，这样就将原来的数值映射到一个新的特定区域中 ，包括 归一化，标准化 等。
归一化就是获取原始数据的最大值和最小值，然后把原始值线性变换到 [0,1] 范围之内，变换公式为：
其中：
从公式中可以看出，归一化与最大最小值有关，这也是归一化的缺点，因为最大值与最小值非常容易受 噪音数据 的影响。
比如，我们有以下数据：
通过数据可以观察出：
这里我们用第一条数据来举例，看看是如何变换的。
sklearn 库的 preprocessing 模块中的 MinMaxScaler 类就是用来做归一化处理的。
首先引入 MinMaxScaler 类：
准备要变换的 data 数据，并初始化 MinMaxScaler 对象：
拟合数据：
输出每个特征的最大最小值：
变换所有数据：
可以对比我们计算的第一行数据，结果是一样的。
z-score 标准化 是基于正态分布的，该方法假设数据呈现 标准正态分布 。
正态分布也叫高斯分布 ，是 连续随机变量 概率分布的一种，它的数学公式是：
其中， u 为 均值 （平均数）， σ 为 标准差 。均值和标准差是正态分布的关键参数，它们会决定分布的具体形态。
正态分布有以下特点：
正态分布就是常态分布，正常状态的分布。在现实生活中，大量随机现象的数据分布都近似于正态分布。
正态分布的分布图为：
当 μ 为 0 ， σ 为 1 时，正态分布为 标准正态分布 。
图中的百分数表示所在面积占总面积的百分比。
z-score 标准化 利用正态分布的特点， 计算一个给定分数距离平均数有多少个标准差 。它的转换公式如下：
其中 x 为原始值， u 为均值， σ 为标准差， x’ 是变换后的值。
经过 z-score 标准化 后，高于平均数的分数会得到一个正的标准分，而低于平均数的分数会得到一个负的标准分数。
和归一化相比， z-score 标准化 不容易受到噪音数据的影响，并且保留了各维特征对目标函数的影响权重。
sklearn 库的 preprocessing 模块中的 StandardScaler 类就是用来做 z-score 标准化 处理的。
首先引入 StandardScaler 类：
准备要变换的 data 数据，并初始化 StandardScaler 对象：
拟合数据：
输出每个特征的均值和标准差：
变换所有数据：
数据变换的目的是 将不同渠道，不同量级的数据转化到统一的范围之内，方便后续的分析处理 。
不同的机器学习算法，对数据有不同的要求，所以要针对不同的算法，对原始数据进行不同的转换。
数据规范化 是常用的数据变化方法，包括归一化和标准化等：
数据变换不一定能提高模型的准确度，但是会提高数据的可解释性。
需要注意的是，对训练数据进行了数据变换之后，在测试模型准确度或者预测数据之前，也要对数据进行同样的数据变换。
（本节完。）
推荐阅读：
决策树算法-理论篇-如何计算信息纯度
决策树算法-实战篇-鸢尾花及波士顿房价预测
朴素贝叶斯分类-理论篇-如何通过概率解决分类问题
朴素贝叶斯分类-实战篇-如何进行文本分类
计算机如何理解事物的相关性-文档的相似度判断
sklearn.preprocessing.StandardScaler数据标准化
参考链接: sklearn.preprocessing.StandardScaler数据标准化 - LoveWhale - 博客园
如果某个特征的方差远大于其它特征的方差，那么它将会在算法学习中占据主导位置，导致我们的学习器不能像我们期望的那样，去学习其他的特征，这将导致最后的模型收敛速度慢甚至不收敛，因此我们需要对这样的特征数据进行标准化/归一化。
1.StandardScaler
标准化数据通过减去均值然后除以方差（或标准差），这种数据标准化方法经过处理后数据符合标准正态分布，即均值为0，标准差为1，转化函数为：x =(x - ?)/?
高斯核函数RBF
5-11、高斯核函数RBF
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from matplotlib.colors import ListedColormap
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.pipeline import Pipeline
from sklearn.model_selection import train_test_split
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
x, y = datasets.make_moons(n_samples=1000, noise=0.25, random_state=2020) # 生成1000个数据样本
plt.figure()
plt.scatter(x[y == 0, 0], x[y == 0, 1], color="r")
plt.scatter(x[y == 1, 0], x[y == 1, 1], color="g")
plt.title('散点图')
plt.show()
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=2020)
# 绘制边界曲线
def plot_decision_boundary(model, axis):
x0, x1 = np.meshgrid(
np.linspace(axis[0], axis[1], int((axis[1] - axis[0]) * 100)).reshape(-1, 1),
np.linspace(axis[2], axis[3], int((axis[3] - axis[2]) * 100)).reshape(-1, 1)
)
x_new = np.c_[x0.ravel(), x1.ravel()]
y_pre = model.predict(x_new)
zz = y_pre.reshape(x0.shape)
# 设置颜色
cus = ListedColormap(["#BA55D3", "#FF69B4", "#FFE4C4"])
plt.contourf(x0, x1, zz, cmap=cus)
def RBFkernelSVC(gamma):#高斯核函数RBF
return Pipeline([
("std", StandardScaler()),
("svc", SVC(kernel="rbf", gamma=gamma))
])
sv = RBFkernelSVC(gamma=1)
sv.fit(x_train, y_train)
plot_decision_boundary(sv, axis=([-1.8, 2.5, -1.4, 1.8]))
plt.scatter(x[y == 0, 0], x[y == 0, 1], color="r")
plt.scatter(x[y == 1, 0], x[y == 1, 1], color="g")
plt.title('高斯核函数RBF')
plt.show()
# 打印出分数
print(sv.score(x_test, y_test))
d = datasets.load_iris()
x = d.data
y = d.target
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=2020)
sv = RBFkernelSVC(gamma=10)
sv.fit(x_train, y_train)
# 打印出分数
print(sv.score(x_test, y_test))
