数据预处理：归一化和标准化skerlean

最新推荐文章于 2023-06-08 13:06:38 发布
最新推荐文章于 2023-06-08 13:06:38 发布
阅读量952 收藏
点赞数
分类专栏： 机器学习+数学
原文链接：https://blog.csdn.net/pipisorry/article/details/52247679
版权

http://blog.csdn.net/pipisorry/article/details/52247679

        本blog内容有特征预处理（标准化、归一化、正则化、特征二值化、缺失值处理）和标签label预处理（label二值化、multi-label多值化）。

特征的预处理

基础知识参考

[数据标准化/归一化normalization ]

[均值、方差与协方差矩阵 ]

[矩阵论：向量范数和矩阵范数 ]

Note: 一定要注意归一化是归一化什么，归一化features还是samples。

数据标准化：去除均值和方差进行缩放

Standardization: mean removal and variance scaling

        数据标准化：当单个特征的样本取值相差甚大或明显不遵从高斯正态分布时，标准化表现的效果较差。实际操作中，经常忽略特征数据的分布形状，移除每个特征均值，划分离散特征的标准差，从而等级化，进而实现数据中心化。

Note: test set要和training set做相同的预处理操作（standardization、data transformation、etc）。
[数据标准化/归一化normalization ]

scale函数标准化

from sklearn import preprocessing

preprocessing.scale(X)

def scale(X, axis=0, with_mean=True, with_std=True, copy=True)

        注意，scikit-learn中assume that all features are centered around zero and have variance in the same order.同时这个默认操作是对features进行的（如mean removal），所以操作都是针对axis=0的操作，如果数据不是这样的要注意！公式为：(X-X_mean)/X_std 计算时对每个属性/每列分别进行。

参数解释：
    X：{array-like, sparse matrix} 数组或者矩阵，一维的数据都可以（但是在0.19版本后一维的数据会报错了！）
    axis：int类型，初始值为0，axis用来计算均值 means 和标准方差 standard deviations. 如果是0，则单独的标准化每个特征（列），如果是1，则标准化每个观测样本（行）。
    with_mean: boolean类型，默认为True，表示将数据均值规范到0
    with_std: boolean类型，默认为True，表示将数据方差规范到1

这种标准化相当于z-score 标准化(zero-mean normalization)

[sklearn.preprocessing.scale]

scale标准化示例


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> from sklearn import preprocessing
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> import numpy as np
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> X = np.array([[ 1., -1.,  2.],
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     ...               [ 2.,  0.,  0.],
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     ...               [ 0.,  1., -1.]])
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> X_scaled = preprocessing.scale(X)
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> X_scaled
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     array([[ 0.  ..., -1.22...,  1.33...],
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
            [ 1.22...,  0.  ..., -0.26...],
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
            [-1.22...,  1.22..., -1.06...]])

对于一维数据的一种可能的处理：先转换成二维，再在结果中转换为一维

cn = preprocessing.scale([[p] for _, _, p in cn]).reshape(-1)

转换后的数据有0均值（zero mean）和单位方差（unit variance，方差为1）


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> X_scaled.mean(axis=0)
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     array([ 0.,  0.,  0.])
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> X_scaled.std(axis=0)
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     array([ 1.,  1.,  1.])

使用StandardScaler使标准化应用在测试集上：保存标准化参数

        一般我们的标准化先在训练集上进行，在测试集上也应该做同样mean和variance的标准化，这样就应该将训练集上的标准化参数保存下来。

        The preprocessing module further provides a utility class StandardScaler that implements the Transformer API to computethe mean and standard deviation on a training set so as to beable to later reapply the same transformation on the testing set.This class is hence suitable for use in the early steps of a sklearn.pipeline.Pipeline:


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> scaler = preprocessing.StandardScaler().fit(X)
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> scaler
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     StandardScaler(copy=True, with_mean=True, with_std=True)
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> scaler.mean_
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     array([ 1. ...,  0. ...,  0.33...])
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> scaler.scale_      
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     array([ 0.81...,  0.81...,  1.24...])
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> scaler.transform(X)                               
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     array([[ 0.  ..., -1.22...,  1.33...],
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
            [ 1.22...,  0.  ..., -0.26...],
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
            [-1.22...,  1.22..., -1.06...]])

The scaler instance can then be used on new data to transform it thesame way it did on the training set:


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> scaler.transform([[-1.,  1., 0.]])                
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     array([[-2.44...,  1.22..., -0.26...]])

It is possible to disable either centering or scaling by eitherpassing with_mean=False or with_std=False to the constructorof StandardScaler.[StandardScaler]

[Standardization, or mean removal and variance scaling]

StandardScaler示例


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     def preprocess():
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         if not os.path.exists(os.path.join(DIR, train_file1)) or not os.path.exists(os.path.join(DIR, test_file1)) or 0:
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             xy = np.loadtxt(os.path.join(DIR, train_file), delimiter=',', dtype=float)
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             x, y = xy[:, 0:-1], xy[:, -1]
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             scaler = preprocessing.StandardScaler().fit(x)
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             xy = np.hstack([scaler.transform(x), y])
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             np.savetxt(os.path.join(DIR, train_file1), xy, fmt='%.7f')
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             x_test = np.loadtxt(os.path.join(DIR, test_file), delimiter=',', dtype=float)
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             x_test = scaler.transform(x_test)
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             np.savetxt(os.path.join(DIR, test_file1), x_test, fmt='%.7f')
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         else:
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             print('data loading...')
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             xy = np.loadtxt(os.path.join(DIR, train_file1), dtype=float)
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             x_test = np.loadtxt(os.path.join(DIR, test_file1), dtype=float)
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         return xy[:, 0:-1], xy[:, -1], x_test

Note:

pipeline能简化该过程（ See  Pipeline and FeatureUnion: combining estimators ，翻译后的文章：http://www.voidcn.com/blog/mmc2015/article/p-3379231.html）：


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> from sklearn.pipeline import make_pipeline
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> clf = make_pipeline(preprocessing.StandardScaler(), svm.SVC(C=1))
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     >>> cross_validation.cross_val_score(clf, iris.data, iris.target, cv=cv)
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     ...                                                 
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     array([ 0.97...,  0.93...,  0.95...])

MinMaxScaler函数：将特征的取值缩小到一个范围（如0到1）

        将属性缩放到一个指定的最大值和最小值(通常是1-0)之间，这可以通过preprocessing.MinMaxScaler类来实现。
使用这种方法的目的包括：
    1、对于方差非常小的属性可以增强其稳定性；
    2、维持稀疏矩阵中为0的条目。
min_max_scaler = preprocessing.MinMaxScaler()
X_minMax = min_max_scaler.fit_transform(X)

有大量异常值的归一化

sklearn.preprocessing.robust_scale(X, axis=0, with_centering=True, with_scaling=True, quantile_range=(25.0, 75.0), copy=True)

Center to the median and component wise scaleaccording to the interquartile range.

[Scaling data with outliers]

其它

[Scaling sparse data

Centering kernel matrices]

自定义归一化函数

Constructs a transformer from an arbitrary callable.

lz自定义了一个归一化函数：大于某个THRESHOLD时其属于1的概率值要大于0.5，小于THRESHOLD时概率值小于0.5，接近最大值时其概率值越接近1，接近最小值时其概率值越接近0。相当于min-max归一化的一点改进吧。


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     from sklearn.preprocessing import FunctionTransformer
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     import numpy as np
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     def scalerFunc(x, maxv, minv, THRESHOLD=200):
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         '''
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         :param x: (n_samples, n_features)!!
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         '''
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         label = x >= THRESHOLD
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         result = 0.5 * (1 + (x - THRESHOLD) * (label / (maxv - THRESHOLD) + (label - 1) / (minv - THRESHOLD)))
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         # print(result)
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         return result
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     x = np.array([100, 150, 201, 250, 300]).reshape(-1, 1)
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     scaler = FunctionTransformer(func=scalerFunc, kw_args={'maxv': x.max(), 'minv': x.min()}).fit(x)
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(scaler.transform(x))
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     [[ 0.   ] [ 0.25 ] [ 0.505] [ 0.75 ] [ 1.   ]]

Note: 自定义函数的参数由FunctionTransformer中的kw_args指定，是字典类型，key必须是字符串。

[preprocessing.FunctionTransformer([func, ...])]

[sklearn.preprocessing: Preprocessing and Normalization]

正则化Normalization

        正则化的过程是将每个样本缩放到单位范数(每个样本的范数为1)，如果要使用如二次型(点积)或者其它核方法计算两个样本之间的相似性这个方法会很有用。
        该方法是文本分类和聚类分析中经常使用的向量空间模型（Vector Space Model)的基础.
Normalization主要思想是对每个样本计算其p-范数，然后对该样本中每个元素除以该范数，这样处理的结果是使得每个处理后样本的p-范数(l1-norm,l2-norm)等于1。

        Normalization is the process of scaling individual samples to haveunit norm.This process can be useful if you plan to use a quadratic formsuch as the dot-product or any other kernel to quantify the similarityof any pair of samples.This assumption is the base of the Vector Space Model often used in textclassification and clustering contexts.

def normalize(X, norm='l2', axis=1, copy=True)

注意，这个操作是对所有样本（而不是features）进行的，也就是将每个样本的值除以这个样本的Li范数。所以这个操作是针对axis=1进行的。

>>> 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...]])

[Normalization]

皮皮blog

缺失值处理Imputation of missing values

        由于不同的原因，许多现实中的数据集都包含有缺失值，要么是空白的，要么使用NaNs或者其它的符号替代。这些数据无法直接使用scikit-learn分类器直接训练，所以需要进行处理。幸运地是，sklearn中的Imputer类提供了一些基本的方法来处理缺失值，如使用均值、中位值或者缺失值所在列中频繁出现的值来替换。
        Imputer类同样支持稀疏矩阵。
>>> import numpy as np
>>> from sklearn.preprocessing import Imputer
>>> imp = Imputer(missing_values='NaN', strategy='mean', axis=0)
>>> imp.fit([[1, 2], [np.nan, 3], [7, 6]])
Imputer(axis=0, copy=True, missing_values='NaN', strategy='mean', verbose=0)
>>> X = [[np.nan, 2], [6, np.nan], [7, 6]]
>>> print(imp.transform(X))                           
[[ 4.          2.        ]
 [ 6.          3.666...]
 [ 7.          6.        ]]

不过lz更倾向于使用pandas进行数据的这种处理[pandas小记：pandas高级功能 ]。

[Imputation of missing values]

其它

[Generating polynomial features]

[Custom transformers]

皮皮blog

 

 

label的预处理

multi-class二值化：Binarization

        Binarize data (set feature values to 0 or 1) according to a threshold. LabelBinarizer is a utility class to help create a label indicator matrix from a list of multi-class labels. 特征的二值化主要是为了将数据特征转变成boolean变量。

        sklearn.preprocessing.Binarizer函数可以设定一个阈值，结果数据值大于阈值的为1，小于阈值的为0。

>>> X = [[ 1., -1.,  2.],
...      [ 2.,  0.,  0.],
...      [ 0.,  1., -1.]]
>>> binarizer = preprocessing.Binarizer().fit(X)  # fit does nothing
>>> binarizer
Binarizer(copy=True, threshold=0.0)
>>> binarizer.transform(X)
array([[ 1.,  0.,  1.],
       [ 1.,  0.,  0.],
       [ 0.,  1.,  0.]])

[Binarization]

multi-label多值化：MultiLabelBinarizer

Transform between iterable of iterables and a multilabel format

fit字典中所有的字

mlb = MultiLabelBinarizer()
with open(os.path.join(DATADIR, 'vocab.tags.txt'), 'r', encoding='utf-8') as f:
    mlb.fit([[l.strip() for l in f.readlines()]])

类数目

mlb.classes_.size

所有类名的ndarray

mlb.classes_

转换class_names为class_ids

transform(self, y)

y : iterable of iterables. 是一个可迭代对象就可以，当然其中的数据需要是mlb.classes_中的数据。返回一个二维的 (n_samples, n_classes) 的multi-hot表示。

转换class_ids为class_names

inverse_transform(self, yt)

其中参数：yt : array or sparse matrix of shape (n_samples, n_classes) .A matrix containing only 1s ands 0s. 必须是一个二维的有shape参数的ndarray或者tensor具体值（所以如果只是一个一维数据需要先转成np.array([ndarray_data])或者tf.expand_dims(tensor_data, 0)），且其中的数据不能是logits，而应该是0，1值的ids。

返回：y : list of tuples. The set of labels for each sample such that y[i] consists of classes_[j] for each yt[i, j] == 1. 返回的是一个一维列表，其中的元素为label的tuple（因为可能是multi-label）。

输出示例


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     from sklearn.preprocessing 
     
     import MultiLabelBinarizer
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     import numpy 
     
     as np
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     mlb = MultiLabelBinarizer()
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     ids = mlb.fit_transform([(
     
     'a', 
     
     'b'), (
     
     '大', 
     
     '小'), (
     
     '大',), (
     
     '左右', 
     
     '晨')])
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     ids = mlb.transform([
     
     'a', 
     
     '小'])
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     labels1 = mlb.inverse_transform(ids)
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     labels2 = mlb.inverse_transform(np.array([[
     
     0, 
     
     0, 
     
     0, 
     
     1, 
     
     0, 
     
     0]]))
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(ids)
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(mlb.classes_.size)
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(mlb.classes_)
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(ids)
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(labels1)
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(labels2)
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  17. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     [[
     
     1 
     
     0 
     
     0 
     
     0 
     
     0 
     
     0]
    
    
    
   
   
  18. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      [
     
     0 
     
     0 
     
     0 
     
     1 
     
     0 
     
     0]]
    
    
    
   
   
  19. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     6
    
    
    
   
   
  20. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     [
     
     'a' 
     
     'b' 
     
     '大' 
     
     '小' 
     
     '左右' 
     
     '晨']
    
    
    
   
   
  21. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     [[
     
     1 
     
     0 
     
     0 
     
     0 
     
     0 
     
     0]
    
    
    
   
   
  22. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      [
     
     0 
     
     0 
     
     0 
     
     1 
     
     0 
     
     0]]
    
    
    
   
   
  23. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     [(
     
     'a',), (
     
     '小',)]
    
    
    
   
   
  24. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     [(
     
     '小',)]

[preprocessing.MultiLabelBinarizer([classes, …])]

Encoding categorical features

[Encoding categorical features]

皮皮blog

from: http://blog.csdn.net/pipisorry/article/details/52247679

ref: [sklearn.preprocessing: Preprocessing and Normalization]

[Preprocessing data]

 

AIchiNiurou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据预处理：标准化和归一化
Java/Python/大数据干货分享
12-31 791
1、数据预处理概述2、数据标准化3、数据归一化4、标准化和归一化怎么选在选择了合适模型的前提下，机器学习可谓是“训练台上3分钟，数据数量和质量台下10年功”。数据的收集与准备是机器学习中的重要一步，是构建一个好的预测模型大厦的基石。数据的数量与质量直接决定了预测模型的好坏所以，在数据的收集与准备这一步中，必须做好数据预处理。Scikit-Learn提供了标准化和归一化等API方便我们进行数据预处理。标准化和归一化是常用的数据缩放方式。
数据预处理：归一化/标准化详解
雷恩Layne
07-23 2471
前言 一般而言，样本的原始特征中的每一维特征由于来源以及度量单位不同，其特征取值的分布范围往往差异很大，比如身高、体重、血压等它们的度量和分布范围往往是不一样的。当我们计算不同样本之间的欧氏距离时，取值范围大的特征会起到主导作用。这样，对于基于相似度比较的机器学习方法（比如最近邻分类器），必须先对样本进行预处理，将各个维度的特征归一化到同一个取值区间，并且消除不同特征之间的相关性，才能获得比较理想的结果。虽然神经网络可以通过参数的调整来适应不同特征的取值范围，但是会导致训练效率比较低。 归一化的必要性及价值
sklearn 归一化、标准化模型保存与加载
Aior100
04-23 423
【代码】sklearn 归一化、标准化模型保存与加载。
python基础技巧(四)——sklearn
洋石灰儿的博客
11-08 363
激活函数 tf.sigmoid(x) tf.tanh(x) tf.softsign(x) tf.nn.relu(x) tf.nn.elu(x) tf.nn.bias_add(values,bias) 损失优化方法 tf.train. tf.train.GradientDescentOptimizer(learning_rate=,use_locking=,name=) tf.tra...
非常全面详细的Sklearn介绍
AI蜗牛车
05-18 5622
全文共 26745 字，106 幅图表，预计阅读时间 67 分钟。0引言Sklearn (全称 Scikit-Learn) 是基于 Python 语言的机器学习工具。它建立在 NumPy, SciPy, Pandas 和 Matplotlib 之上，里面的 API 的设计非常好，所有对象的接口简单，很适合新手上路。在 Sklearn 里面有六大任务模块：分别是分类、回归、...
时间序列数据预处理：归一化和标准化等方法
yanghe4405的博客
06-08 6046
归一化是对原始范围内的数据进行重新缩放，以使所有值都在0和1的范围内。当您的时间序列数据具有不同比例的输入值时，归一化可能是有用的，甚至在某些机器学习算法中也是必需的。对于算法，例如k-最近邻，它使用距离计算和线性回归和人工神经网络可能需要归一化。重量输入值。标准化要求您知道或能够准确估计最小和最大可观察值。您可以从可用数据中估算这些值。如果您的时间序列趋势向上或向下，估计这些预期值可能会很困难，并且规范化可能不是用于解决问题的最佳方法。
sklearn特征预处理：归一化和标准化
qq_39375237的博客
11-17 761
sklearn特征预处理：归一化和标准化 特征预处理：通过一些转换函数，将特征数据转换成更加适合算法模型的特征数据。API：sklearn.preprocessing 数值型数据的无量纲化： 1、归一化：x_new = (x - min)/(max - min)，如果将其映射到指定的区间(a，b)，则：x_new_new = x_new * (b-a) + a，一般是映射到(0，1)，则：x_new_new = x_new。 归一化的缺点：如果数据中有异常值（最大值和最小值），影响比较大，鲁棒性比较差。 2
特征预处理方法：归一化，标准化
lian740930980的博客
02-26 849
1、归一化 特征的单位或者大小相差较大，或者某特征的方差相比其他的特征要大出几个数量级，容易影响（支配）目标结果 import pandas as pd from sklearn.preprocessing import MinMaxScaler def minmax_demo(): """ 归一化演示 :return: None """ data = pd.read_csv("./data/dating.txt") print(data)
深入理解机器学习——数据预处理：归一化 （Normalization）与标准化 （Standardization）
热门推荐
冯·诺依曼
04-30 1万+
归一化 （Normalization）和标准化 （Standardization）都是特征缩放的方法。特征缩放是机器学习预处理数据中最重要的步骤之一，可以加快梯度下降，也可以消除不同量纲之间的差异并提升模型精度。而标准化（Standardization）是在不改变原始的数据分布的情况下，将数据的分布变换为均值为0，标准差为1。所以标准化也可以视为一种特殊的归一化，故我们也称标准化为Z值归一化。归一化（Normalization）是将一组数据变换到某个固定区间中。区间，而图像中可能会映射到。
均值归一化_数据预处理：标准化和归一化
weixin_39670464的博客
10-19 1944
网上很多关于标准化和归一化的文章，不少是误人子弟的存在。这篇文字希望给大家讲清讲透这两个概念。一、标准化（standardization） 公式一般为：(X-mean)/std，其中mean是平均值，std是方差。从公式我们可以看出，标准化操作（standardization）是将数据按其属性（按列）减去平均值，然后再除以方差。这个过程从几何上理解就是，先将坐标轴零轴平移到均值这条线上，然后再进行...
【机器学习（6）】数据预处理：预处理、标准化和数据纠偏
12-22
模型评价体系 回顾一下以前提及的模型评价的体系 类别 概念 ...规律和经验 ...从数据中总结规律的过程 ...训练模型的数据集 ...测试学习模型泛化能力的数据集...    特征变换：预处理、标准化、纠偏     特征增加与删减：
Python数据预处理之数据规范化（归一化）示例
09-19
主要介绍了Python数据预处理之数据规范化,简单描述了数据规范化的原理、用法及相关操作技巧,需要的朋友可以参考下
数据挖掘-数据预处理-基于Python的数据标准化方法
03-25
数据挖掘-数据预处理-基于Python的数据标准化方法
pytorch 图像中的数据预处理和批标准化实例
09-18
今天小编就为大家分享一篇pytorch 图像中的数据预处理和批标准化实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
用sklearn进行数据预处理：缺失值处理、数据标准化、归一化.pdf
04-04
用sklearn进行数据预处理：缺失值处理、数据标准化、归一化.pdf
grpcio-1.63.0-cp38-cp38-linux_armv7l.whl
最新发布
05-28
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
SQLyog-13.1.3-0.x86Community.exe
05-28
SQLyog-13.1.3-0.x86Community
VB自动出题题库系统设计(源代码+系统).rar
05-28
计算机专业毕业设计VB精品论文资源
debugpy-1.0.0b2-cp35-cp35m-manylinux1_i686.whl
05-28
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
数据的预处理和归一化
11-14
数据预处理和归一化是机器学习中非常重要的步骤，可以提高模型的准确性和效率。下面是数据预处理和归一化的介绍和演示： 数据预处理： 1. 缺失值处理：可以通过填充均值、中位数或者众数等方法来处理缺失值。 2. 异常值处理：可以通过删除异常值或者用均值、中位数等方法来填充异常值。 3. 数据平滑：可以通过平滑算法来去除噪声，例如移动平均法、指数平滑法等。 4. 数据集成：可以将多个数据源的数据进行集成，例如数据表连接、数据记录合并等。 5. 数据变换：可以通过对数据进行函数变换、离散化、规范化等方法来改变数据的分布。 归一化： 1. 最小-最大规范化：将数据缩放到[0,1]区间内，公式为：(x-min)/(max-min)。 2. Z-score规范化：将数据缩放到均值为0，标准差为1的正态分布中，公式为：(x-mean)/std。 3. 小数定标规范化：将数据缩放到[-1,1]或者[-0.5,0.5]之间，公式为：x/10^k，其中k为使得所有数据的绝对值都小于1的整数。 下面是一个数据预处理和归一化的例子： ```python import pandas as pd from sklearn.preprocessing import MinMaxScaler, StandardScaler # 读取数据 data = pd.read_csv('data.csv') # 缺失值处理 data = data.fillna(data.mean()) # 异常值处理 data = data[(data['value'] >= 0) & (data['value'] <= 100)] # 数据平滑 data['value'] = data['value'].rolling(window=3).mean() # 数据集成 data = pd.merge(data, other_data, on='id') # 数据变换 data['value'] = data['value'].apply(lambda x: x**2) # 最小-最大规范化 scaler = MinMaxScaler() data['value'] = scaler.fit_transform(data[['value']]) # Z-score规范化 scaler = StandardScaler() data['value'] = scaler.fit_transform(data[['value']]) ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值