目录
1）均值-标准差缩放--StandardScaler() (常用)
6）编码的分类特征--OneHotEncoder() (常用)
8）生成多项式特征--PolynomialFeatures() (常用)
一：sklearn中的归一化
1）均值-标准差缩放--StandardScaler()
目的:使数据成正态分布, 均值为0,方差为1
在sklearn的学习中，数据集的标准化是很多机器学习模型算法的常见要求。如果个别特征看起来不是很符合正态分布，那么他们可能为表现不好。
实际上，我们经常忽略分布的形状，只是通过减去整组数据的均值，使之更靠近数据中心分布，然后通过将非连续数特征除以其标准偏差进行分类。
例如，用于学习算法（例如支持向量机的RBF内核或线性模型的l1和l2正则化器）的目标函数中使用的许多元素假设所有特征都以零为中心并且具有相同顺序的方差。如果特征的方差大于其他数量级，则可能主导目标函数，使估计器无法按预期正确地学习其他特征。
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)
output:
array([[ 0. , -1.22474487, 1.33630621],
[ 1.22474487, 0. , -0.26726124],
[-1.22474487, 1.22474487, -1.06904497]])
预处理模块还提供了一个实用程序集StandardScaler，它实现了Transformer API来计算训练集上的平均值和标准偏差，以便在测试集上应用相同的变换。
StandardScaler(copy=True, with_mean=True, with_std=True)
from sklearn import preprocessing
import numpy as np
X_train = np.array([[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]])
scaler = preprocessing.StandardScaler().fit(X_train)
X_test = [[-1., 1., 0.]]
scaler.transform(X_test)
output:
array([[-2.44948974, 1.22474487, -0.26726124]])2）min-max标准化--MinMaxScaler()
from sklearn import preprocessing
import numpy as np
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)
print(X_train_minmax)
output:
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)
print(X_test_minmax)
output:
array([[-1.5 , 0. , 1.66666667]])
3）最大值标准化--MaxAbsScaler()
from sklearn import preprocessing
import numpy as np
X_train=array([[ 1., -1., 2.],
[ 2., 0., 0.],
[ 0., 1., -1.]])
max_abs_scaler = preprocessing.MaxAbsScaler()
X_train_maxabs = max_abs_scaler.fit_transform(X_train)
print(X_train_maxabs)
output:
array([[ 0.5, -1. , 1. ],
[ 1. , 0. , 0. ],
[ 0. , 1. , -0.5]])
用于新的测试数据
X_test = np.array([[ -3., -1., 4.]])
X_test_maxabs = max_abs_scaler.transform(X_test)
print(X_test_maxabs)
output:
array([[-1.5, -1. , 2. ]])4）规范化--normalize()
Normalizer(copy=True, norm='l2')
规范化是文本分类和聚类中向量空间模型的基础
from sklearn import preprocessing
import numpy as np
X = [[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]]
X_normalized = preprocessing.normalize(X, norm='l2')
print(X_normalized)
output:
array([[ 0.40824829, -0.40824829, 0.81649658],
[ 1. , 0. , 0. ],
[ 0. , 0.70710678, -0.70710678]])
使用方法2
from sklearn import preprocessing
import numpy as np
X = [[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]]
normalizer = preprocessing.Normalizer().fit(X)
normalizer.transform(X)
output:
array([[ 0.40824829, -0.40824829, 0.81649658],
[ 1. , 0. , 0. ],
[ 0. , 0.70710678, -0.70710678]])
normalizer.transform([[-1,1,0]])
output:
array([[-0.70710678, 0.70710678, 0. ]])5）二值化--Binarizer()
将数据转换到0-1 之间
from sklearn import preprocessing
import numpy as np
x=[[1.0, -1.0, 2.0],
[2.0, 0.0, 0.0],
[0.0, 1.0, -1.0]]
binarizer = preprocessing.Binarizer().fit(X)
output=binarizer.transform(X)
print(output)
array([[ 1., 0., 1.],
[ 1., 0., 0.],
[ 0., 1., 0.]])6）编码的分类特征--OneHotEncoder()
OneHotEncoder(n_values=’auto’, categorical_features=’all’, dtype=<class ‘numpy.float64’>, sparse=True, handle_unknown=’error’)
n_values=’auto’:表示每个特征使用几维的数值由数据集自动推断，即几种类别就使用几位来表示。当然也可以自己指定，
如果训练样本中有丢失的分类特征值，我们就必须显示地设置参数 n_values 了，这样防止编码出错。
categorical_features ='all'或columns_list，这个参数指定了对哪些特征进行编码，默认对所有类别都进行编码。也可以自己指定选择哪些特征，通过索引或者 bool 值来指定
dtype=<class ‘numpy.float64’> 表示编码数值格式，默认是浮点型。
sparse=True 表示编码的格式，默认为 True，即为稀疏的格式，指定 False输出为array
handle_unknown=’error’，其值可以指定为 "error" 或者 "ignore"，即如果碰到未知的类别，是返回一个错误还是忽略它。
from sklearn.preprocessing import OneHotEncoder
enc = OneHotEncoder(sparse=False,handle_unknown="ignore")
enc.fit([[0, 0, 3],
[1, 1, 0],
[0, 2, 1],
[1, 0, 2]])
ans = enc.transform([[0, 1, 3]])
print(ans)
output:
[[ 1. 0. 0. 1. 0. 0. 0. 0. 1.]]注释:
1.我们先来看第一个特征，即第一列 [0,1,0,1][0,1,0,1]，也就是说它有两个取值 0 或者 1，那么 one-hot 就会使用两位来表示这个特征，[1,0][1,0] 表示 0， [0,1][0,1] 表示 1，在上例输出结果中的前两位 [1,0...][1,0...] 也就是表示该特征为 0
2.第二个特征，第二列 [0,1,2,0][0,1,2,0]，它有三种值，那么 one-hot 就会使用三位来表示这个特征，[1,0,0][1,0,0] 表示 0， [0,1,0][0,1,0] 表示 1，[0,0,1][0,0,1] 表示 2，在上例输出结果中的第三位到第六位 [...0,1,0,0...][...0,1,0,0...] 也就是表示该特征为 1
3.第二个特征，第三列 [3,0,1,2][3,0,1,2]，它有四种值，那么 one-hot 就会使用四位来表示这个特征，[1,0,0,0][1,0,0,0] 表示 0， [0,1,0,0][0,1,0,0] 表示 1，[0,0,1,0][0,0,1,0] 表示 2，[0,0,0,1][0,0,0,1] 表示 3，在上例输出结果中的最后四位 [...0,0,0,1][...0,0,0,1] 也就是表示该特征为 3
7）填补缺失值--Imputer()
Imputer(missing_values=’NaN’, strategy=’mean’, axis=0, verbose=0, copy=True)
主要参数说明：
missing_values：缺失值，可以为整数或NaN(缺失值numpy.nan用字符串‘NaN’表示)，默认为NaN
strategy：替换策略，字符串，默认用均值‘mean’替换
①若为mean时，用特征列的均值替换
②若为median时，用特征列的中位数替换
③若为most_frequent时，用特征列的众数替换
axis：指定轴数，默认axis=0代表列，axis=1代表行
copy：设置为True代表不在原数据集上修改，设置为False时，就地修改，存在如下情况时，即使设置为False时，也不会就地修改
from sklearn.preprocessing import Imputer
import numpy as np
import pandas as pd
df=pd.DataFrame(np.arange(9).reshape(3,3))
df[1][1]=np.nan
df[2][2]=np.nan
print(df)
output:
array([[0. , 1. , 2. ],
[3. , NAN , 5. ],
[6. , 7. , NAN]])
column_names=df.columns
imp = Imputer(missing_values='NaN', strategy='mean', axis=0)
df=imp.fit_transform(df)
#或 :
#imp=imp.fit(df)
#df=imp.transform(df)
df=pd.DataFrame(df,columns=column_names)
print(df)output:
8）生成多项式特征--PolynomialFeatures()
通常，通过考虑输入数据的非线性特征来增加模型的复杂度是很有用的。一个简单而常用的方法是多项式特征，它可以得到特征的高阶和相互作用项。
其遵循的原则是
import numpy as np
from sklearn.preprocessing import PolynomialFeatures
X = np.arange(6).reshape(3, 2)
print(X)
output:
array([[0, 1],
[2, 3],
[4, 5]])
poly = PolynomialFeatures(2)
X=poly.fit_transform(X)
print(X)
output:
array([[ 1., 0., 1., 0., 0., 1.],
[ 1., 2., 3., 4., 6., 9.],
[ 1., 4., 5., 16., 20., 25.]])有些情况下，有相互关系的标签才是必须的，这个时候可以通过设置 interaction_only=True 来进行多项式特征的生成
poly = PolynomialFeatures(degree=3, interaction_only=True)
X=poly.fit_transform(X)
print(X)
output:
array([[ 1., 0., 1., 2., 0., 0., 2., 0.],
[ 1., 3., 4., 5., 12., 15., 20., 60.],
[ 1., 6., 7., 8., 42., 48., 56., 336.]])二 .补充:python实现数据归一化:
数据归一化（标准化）处理是数据挖掘的一项基础工作，不同评价指标往往具有不同的量纲和量纲单位，这样的情况会影响到数据分析的结果，为了消除指标之间的量纲影响，需要进行数据标准化处理，以解决数据指标之间的可比性。原始数据经过数据标准化处理后，各指标处于同一数量级，适合进行综合对比评价。
归一化方法有两种形式，一种是把数变为（0，1）之间的小数，一种是把有量纲表达式变为无量纲表达式。在机器学习中我们更关注的把数据变到0～1之间，接下来我们讨论的也是第一种形式。
1）min-max标准化
1.min-max标准化也叫做离差标准化，是对原始数据的线性变换，使结果落到[0,1]区间，其对应的数学公式如下：
def Normalization(x):
return [(float(i)-min(x))/float(max(x)-min(x)) for i in x]2.如果要将数据转换到[-1,1]之间，可以修改其数学公式为：
import numpy as np
def Normalization(x):
return [(float(i)-np.mean(x))/float(max(x)-min(x)) for i in x]这种方法有个缺陷就是当有新数据加入时，可能导致max和min的变化，需要重新定义。
该标准化方法有一个缺点就是，如果数据中有一些偏离正常数据的异常点，就会导致标准化结果的不准确性。比如说一个公司员工（A，B，C，D）的薪水为6k,8k,7k,10w,这种情况下进行归一化对每个员工来讲都是不合理的。
2）z-score标准化
z-score标准化也叫标准差标准化，代表的是分值偏离均值的程度，经过处理的数据符合标准正态分布，即均值为0，标准差为1。其转化函数为
其中μ为所有样本数据的均值，σ为所有样本数据的标准差。
import numpy as np
def z_score(x):
return (x - np.mean(x) )/np.std(x, ddof = 1)z-score标准化方法对于离群异常值的影响。接下来看一种改进的z-score标准化方法。
3) 改进的z-score标准化
将标准分公式中的均值改为中位数，将标准差改为绝对偏差。
中位数是指将所有数据进行排序，取中间的那个值，如数据量是偶数，则取中间两个数据的平均值。
σ1为所有样本数据的绝对偏差,其计算公式为：
1-6参考 https://blog.csdn.net/tongjinrui/article/details/79510720
onehot参考:https://www.cnblogs.com/zhoukui/p/9159909.html
scikit-learn资料为： http://scikit-learn.org/stable/modules/preprocessing.html
6064
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
