Machine Learning Mastery 数据准备教程（七）
Python 中用于特征选择的递归特征消除（RFE）
最后更新于 2020 年 8 月 28 日
递归特征消除，简称 RFE，是一种流行的特征选择算法。
RFE 之所以受欢迎，是因为它易于配置和使用，并且可以有效地选择训练数据集中与预测目标变量更相关或最相关的特征(列)。
使用 RFE 时，有两个重要的配置选项:选择要选择的特征数量和选择用于帮助选择特征的算法。这两个超参数都可以探索，尽管该方法的表现并不强烈依赖于这些超参数的良好配置。
在本教程中，您将发现如何在 Python 中使用递归特征消除(RFE)进行特征选择。
完成本教程后，您将知道:
- RFE 是一种从训练数据集中消除特征以进行特征选择的有效方法。
- 如何使用 RFE 进行分类和回归预测建模问题的特征选择。
- 如何探索 RFE 程序使用的选定特征和包装算法的数量。
用我的新书机器学习的数据准备启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
Python 中特征选择的递归特征消除(RFE)摄于djandywdocom，保留部分权利。
教程概述
本教程分为三个部分；它们是:
- 递归特征消除
- RFE 与科学知识——学习
- RFE 分类协会
- 回归的 RFE
- RFE 超参数
- 探索功能数量
- 自动选择特征数量
- 选择了哪些功能
- 探索基础算法
递归特征消除
递归特征消除，简称 RFE，是一种特征选择算法。
用于分类或回归的机器学习数据集由行和列组成，就像 excel 电子表格一样。行通常被称为样本，列被称为特征，例如问题域中的观察特征。
要素选择是指为数据集选择最相关要素(列)子集的技术。更少的特性可以让机器学习算法更高效地运行(更少的空间或时间复杂度)并且更有效。一些机器学习算法会被不相关的输入特征误导，导致预测表现变差。
有关一般特征选择的更多信息，请参见教程:
RFE 是一种包装类型的特征选择算法。这意味着在该方法的核心中给出并使用了不同的机器学习算法，该算法由 RFE 包装，并用于帮助选择特征。这与基于过滤器的特征选择形成对比，基于过滤器的特征选择对每个特征进行评分，并选择那些得分最大(或最小)的特征。
从技术上讲，RFE 是一种包装器风格的特征选择算法，它也在内部使用基于过滤器的特征选择。
RFE 的工作原理是从训练数据集中的所有要素开始搜索要素子集，并成功移除要素，直到剩余所需数量。
这是通过拟合模型核心中使用的给定机器学习算法、按重要性排列特征、丢弃最不重要的特征以及重新拟合模型来实现的。重复此过程，直到保留指定数量的特征。
当完整的模型被创建时，可变重要性的度量被计算，其将预测器从最重要到最不重要排序。[……]在搜索的每个阶段，在重建模型之前，迭代地消除最不重要的预测因子。
—第 494-495 页，应用预测建模，2013。
使用所提供的机器学习模型(例如，像决策树这样的一些算法提供重要性分数)或使用统计方法对特征进行评分。
重要性计算可以基于模型(例如，随机森林重要性标准)或者使用独立于完整模型的更一般的方法。
—第 494 页，应用预测建模，2013 年。
现在我们已经熟悉了 RFE 程序，让我们回顾一下如何在我们的项目中使用它。
RFE 与科学知识——学习
RFE 可以从零开始实现，尽管对初学者来说很有挑战性。
Sklearn Python 机器学习库为机器学习提供了 RFE 的实现。
它有现代版本的图书馆。
首先，通过运行以下脚本来确认您使用的是现代版本的库:
# check Sklearn version
import sklearn
print(sklearn.__version__)
运行脚本将打印您的 Sklearn 版本。
您的版本应该相同或更高。如果没有，您必须升级 Sklearn 库的版本。
0.22.1
RFE 方法可通过 Sklearn 中的 RFE 课程获得。
RFE 是一个转变。要使用它，首先用通过“估计器参数指定的选择算法和通过“ n_features_to_select 参数选择的特征数量来配置类。
该算法必须提供一种计算重要分数的方法，例如决策树。在 RFE 使用的算法不必是适合所选特征的算法；可以使用不同的算法。
配置后，该类必须适合训练数据集，以便通过调用 fit() 函数来选择特征。类拟合后，输入变量的选择可以通过“ support_ ”属性看到，该属性为每个输入变量提供一个真或假。
然后可以通过调用*变换()*函数将其应用于训练和测试数据集。
...
# define the method
rfe = RFE(estimator=DecisionTreeClassifier(), n_features_to_select=3)
# fit the model
rfe.fit(X, y)
# transform the data
X, y = rfe.transform(X, y)
通常使用 k 倍交叉验证来评估数据集上的机器学习算法。当使用交叉验证时，最好像 RFE 一样执行数据转换，作为管道的一部分，以避免数据泄漏。
现在我们已经熟悉了 RFE API，让我们看看如何为分类和回归开发一个 RFE。
RFE 分类协会
在这一节中，我们将研究使用 RFE 进行分类的问题。
首先，我们可以使用 make_classification()函数创建一个包含 1000 个示例和 10 个输入特征的合成二进制分类问题，其中 5 个是重要的，5 个是冗余的。
下面列出了完整的示例。
# test classification dataset
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
# summarize the dataset
print(X.shape, y.shape)
运行该示例将创建数据集并总结输入和输出组件的形状。
(1000, 10) (1000,)
接下来，我们可以在这个数据集上评估 RFE 特征选择算法。我们将使用决策树分类器来选择特征，并将特征数量设置为 5。然后，我们将在所选特征上安装一个新的决策树分类器模型。
我们将使用重复的分层 k 折叠交叉验证来评估模型，重复 3 次，折叠 10 次。我们将报告所有重复和折叠的模型准确率的平均值和标准偏差。
下面列出了完整的示例。
# evaluate RFE for classification
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.feature_selection import RFE
from sklearn.tree import DecisionTreeClassifier
from sklearn.pipeline import Pipeline
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
# create pipeline
rfe = RFE(estimator=DecisionTreeClassifier(), n_features_to_select=5)
model = DecisionTreeClassifier()
pipeline = Pipeline(steps=[('s',rfe),('m',model)])
# evaluate model
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例会报告模型的均值和标准差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到使用决策树并选择五个特征，然后将决策树拟合到所选特征上的 RFE 分类准确率约为 88.6%。
Accuracy: 0.886 (0.030)
我们还可以使用 RFE 模型管道作为最终模型，并对分类进行预测。
首先，RFE 和模型适用于所有可用数据，然后可以调用 predict() 函数对新数据进行预测。
下面的示例在我们的二进制类别数据集上演示了这一点。
# make a prediction with an RFE pipeline
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.feature_selection import RFE
from sklearn.tree import DecisionTreeClassifier
from sklearn.pipeline import Pipeline
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
# create pipeline
rfe = RFE(estimator=DecisionTreeClassifier(), n_features_to_select=5)
model = DecisionTreeClassifier()
pipeline = Pipeline(steps=[('s',rfe),('m',model)])
# fit the model on all available data
pipeline.fit(X, y)
# make a prediction for one example
data = [[2.56999479,-0.13019997,3.16075093,-4.35936352,-1.61271951,-1.39352057,-2.48924933,-1.93094078,3.26130366,2.05692145]]
yhat = pipeline.predict(data)
print('Predicted Class: %d' % (yhat))
运行该示例使 RFE 管道适用于整个数据集，然后用于对新的数据行进行预测，就像我们在应用程序中使用模型时可能做的那样。
Predicted Class: 1
现在我们已经熟悉了使用 RFE 进行分类，让我们看看回归的 API。
回归的 RFE
在这一节中，我们将研究使用 RFE 来解决回归问题。
首先，我们可以使用make _ revolution()函数创建一个包含 1000 个示例和 10 个输入特征的合成回归问题，其中 5 个是重要的，5 个是冗余的。
下面列出了完整的示例。
# test regression dataset
from sklearn.datasets import make_regression
# define dataset
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, random_state=1)
# summarize the dataset
print(X.shape, y.shape)
运行该示例将创建数据集并总结输入和输出组件的形状。
(1000, 10) (1000,)
接下来，我们可以在这个数据集上评估 REFE 算法。
正如我们在上一节中所做的那样，我们将使用决策树来评估管道，使用重复的 k-fold 交叉验证，重复 3 次，重复 10 次。
我们将报告所有重复和折叠模型的平均绝对误差(MAE)。Sklearn 库使 MAE 为负，因此它被最大化而不是最小化。这意味着负 MAE 越大越好，完美模型的 MAE 为 0。
下面列出了完整的示例。
# evaluate RFE for regression
from numpy import mean
from numpy import std
from sklearn.datasets import make_regression
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
from sklearn.feature_selection import RFE
from sklearn.tree import DecisionTreeRegressor
from sklearn.pipeline import Pipeline
# define dataset
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, random_state=1)
# create pipeline
rfe = RFE(estimator=DecisionTreeRegressor(), n_features_to_select=5)
model = DecisionTreeRegressor()
pipeline = Pipeline(steps=[('s',rfe),('m',model)])
# evaluate model
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(pipeline, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
# report performance
print('MAE: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例会报告模型的均值和标准差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到具有决策树模型的 RFE 管道实现了大约 26 的 MAE。
MAE: -26.853 (2.696)
我们也可以使用 c 作为最终模型，并对回归进行预测。
首先，管道适合所有可用数据，然后可以调用 predict() 函数对新数据进行预测。
下面的例子在我们的回归数据集上演示了这一点。
# make a regression prediction with an RFE pipeline
from numpy import mean
from numpy import std
from sklearn.datasets import make_regression
from sklearn.feature_selection import RFE
from sklearn.tree import DecisionTreeRegressor
from sklearn.pipeline import Pipeline
# define dataset
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, random_state=1)
# create pipeline
rfe = RFE(estimator=DecisionTreeRegressor(), n_features_to_select=5)
model = DecisionTreeRegressor()
pipeline = Pipeline(steps=[('s',rfe),('m',model)])
# fit the model on all available data
pipeline.fit(X, y)
# make a prediction for one example
data = [[-2.02220122,0.31563495,0.82797464,-0.30620401,0.16003707,-1.44411381,0.87616892,-0.50446586,0.23009474,0.76201118]]
yhat = pipeline.predict(data)
print('Predicted: %.3f' % (yhat))
运行该示例使 RFE 管道适用于整个数据集，然后用于对新的数据行进行预测，就像我们在应用程序中使用模型时可能做的那样。
Predicted: -84.288
既然我们已经熟悉了使用 Sklearn API 来评估和使用 RFE 进行特征选择，那么让我们来看看如何配置模型。
RFE 超参数
在本节中，我们将仔细研究一些超参数，您应该考虑针对特征选择的 RFE 方法进行调整，以及它们对模型表现的影响。
探索功能数量
RFE 算法的一个重要超参数是要选择的特征数量。
在前一节中，我们使用了任意数量的选定要素，即五个，这与合成数据集中的信息要素数量相匹配。在实践中，我们无法知道选择 RFE 的最佳特征数量；相反，测试不同的值是很好的做法。
下面的示例演示了在合成二进制类别数据集上选择 2 到 10 个不同数量的要素。
# explore the number of selected features for RFE
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.feature_selection import RFE
from sklearn.tree import DecisionTreeClassifier
from sklearn.pipeline import Pipeline
from matplotlib import pyplot
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
return X, y
# get a list of models to evaluate
def get_models():
models = dict()
for i in range(2, 10):
rfe = RFE(estimator=DecisionTreeClassifier(), n_features_to_select=i)
model = DecisionTreeClassifier()
models[str(i)] = Pipeline(steps=[('s',rfe),('m',model)])
return models
# evaluate a give model using cross-validation
def evaluate_model(model, X, y):
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
return scores
# define dataset
X, y = get_dataset()
# get the models to evaluate
models = get_models()
# evaluate the models and store results
results, names = list(), list()
for name, model in models.items():
scores = evaluate_model(model, X, y)
results.append(scores)
names.append(name)
print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
# plot model performance for comparison
pyplot.boxplot(results, labels=names, showmeans=True)
pyplot.show()
运行该示例首先报告每个配置数量的输入要素的平均准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到表现随着特征数量的增加而提高，并且可能在 4-7 左右达到峰值，正如我们可能预期的那样，假设只有五个特征与目标变量相关。
>2 0.715 (0.044)
>3 0.825 (0.031)
>4 0.876 (0.033)
>5 0.887 (0.030)
>6 0.890 (0.031)
>7 0.888 (0.025)
>8 0.885 (0.028)
>9 0.884 (0.025)
为每个配置数量的特征的准确率分数分布创建一个方框和须图。
选定要素的 RFE 数与分类准确率的箱线图
自动选择特征数量
也可以自动选择 RFE 选择的特征数量。
这可以通过对不同数量的特征进行交叉验证评估来实现，就像我们在上一节中所做的那样，并自动选择获得最佳平均得分的特征数量。
RFECV 类为我们实现了这一点。
RFECV 的配置就像 RFE 类一样，涉及到所包装算法的选择。此外，可以通过“ min_features_to_select ”参数(默认为 1)指定要考虑的最小特征数量，我们还可以通过“ cv ”(默认为 5)和“评分”参数(使用准确性进行分类)指定要使用的交叉验证和评分类型。
...
# automatically choose the number of features
rfe = RFECV(estimator=DecisionTreeClassifier())
我们可以在我们的合成二进制分类问题上演示这一点，并在我们的管道中使用 RFECV 而不是 RFE 来自动选择所选特征的数量。
下面列出了完整的示例。
# automatically select the number of features for RFE
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.feature_selection import RFECV
from sklearn.tree import DecisionTreeClassifier
from sklearn.pipeline import Pipeline
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
# create pipeline
rfe = RFECV(estimator=DecisionTreeClassifier())
model = DecisionTreeClassifier()
pipeline = Pipeline(steps=[('s',rfe),('m',model)])
# evaluate model
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例会报告模型的均值和标准差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到使用决策树并自动选择多个特征，然后将决策树拟合到所选特征上的 RFE 分类准确率约为 88.6%。
Accuracy: 0.886 (0.026)
选择了哪些功能
使用 RFE 时，我们可能有兴趣知道哪些功能被选中，哪些被删除。
这可以通过查看拟合 RFE 对象(或拟合 RFECV 对象)的属性来实现。“ support_ ”属性报告按照列索引的顺序包含哪些要素的真或假，而“ ranking_ ”属性报告按照相同顺序要素的相对排名。
下面的示例在整个数据集上拟合一个 RFE 模型并选择五个要素，然后报告每个要素列索引(0 到 9)、是否被选择(真或假)以及相对要素排名。
# report which features were selected by RFE
from sklearn.datasets import make_classification
from sklearn.feature_selection import RFE
from sklearn.tree import DecisionTreeClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
# define RFE
rfe = RFE(estimator=DecisionTreeClassifier(), n_features_to_select=5)
# fit RFE
rfe.fit(X, y)
# summarize all features
for i in range(X.shape[1]):
print('Column: %d, Selected %s, Rank: %.3f' % (i, rfe.support_[i], rfe.ranking_[i]))
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
运行 10 个输入特征的示例列表，以及它们是否被选中以及它们的相对重要性排名。
Column: 0, Selected False, Rank: 5.000
Column: 1, Selected False, Rank: 4.000
Column: 2, Selected True, Rank: 1.000
Column: 3, Selected True, Rank: 1.000
Column: 4, Selected True, Rank: 1.000
Column: 5, Selected False, Rank: 6.000
Column: 6, Selected True, Rank: 1.000
Column: 7, Selected False, Rank: 3.000
Column: 8, Selected True, Rank: 1.000
Column: 9, Selected False, Rank: 2.000
探索基础算法
有许多算法可以在核心 RFE 中使用，只要它们提供一些可变重要性的指示。
大多数决策树算法可能会报告相同的特征重要性的一般趋势，但这并不能保证。探索 RFE 包装的不同算法的使用可能会有所帮助。
下面的示例演示了如何探索这个配置选项。
# explore the algorithm wrapped by RFE
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression
from sklearn.linear_model import Perceptron
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.pipeline import Pipeline
from matplotlib import pyplot
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
return X, y
# get a list of models to evaluate
def get_models():
models = dict()
# lr
rfe = RFE(estimator=LogisticRegression(), n_features_to_select=5)
model = DecisionTreeClassifier()
models['lr'] = Pipeline(steps=[('s',rfe),('m',model)])
# perceptron
rfe = RFE(estimator=Perceptron(), n_features_to_select=5)
model = DecisionTreeClassifier()
models['per'] = Pipeline(steps=[('s',rfe),('m',model)])
# cart
rfe = RFE(estimator=DecisionTreeClassifier(), n_features_to_select=5)
model = DecisionTreeClassifier()
models['cart'] = Pipeline(steps=[('s',rfe),('m',model)])
# rf
rfe = RFE(estimator=RandomForestClassifier(), n_features_to_select=5)
model = DecisionTreeClassifier()
models['rf'] = Pipeline(steps=[('s',rfe),('m',model)])
# gbm
rfe = RFE(estimator=GradientBoostingClassifier(), n_features_to_select=5)
model = DecisionTreeClassifier()
models['gbm'] = Pipeline(steps=[('s',rfe),('m',model)])
return models
# evaluate a give model using cross-validation
def evaluate_model(model, X, y):
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
return scores
# define dataset
X, y = get_dataset()
# get the models to evaluate
models = get_models()
# evaluate the models and store results
results, names = list(), list()
for name, model in models.items():
scores = evaluate_model(model, X, y)
results.append(scores)
names.append(name)
print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
# plot model performance for comparison
pyplot.boxplot(results, labels=names, showmeans=True)
pyplot.show()
运行该示例首先报告每个包装算法的平均准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，结果表明，像逻辑回归这样的线性算法可能比所选择的决策树和决策树算法的集成更可靠地选择更好的特征。
>lr 0.893 (0.030)
>per 0.843 (0.040)
>cart 0.887 (0.033)
>rf 0.858 (0.038)
>gbm 0.891 (0.030)
为每个配置的包装算法的准确度分数的分布创建一个方框和须图。
我们可以通过逻辑回归、CART，或许还有 GBM，看到表现良好的大趋势。这突出表明，即使用于拟合所选特征的实际模型在每种情况下都是相同的，但在 RFE 使用的模型可以对所选特征产生重要影响，进而影响预测问题的表现。
RFE 包裹算法的箱线图与分类准确率
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
教程
书
- 应用预测建模，2013。
报纸
- 使用支持向量机进行癌症分类的基因选择，2002。
蜜蜂
文章
摘要
在本教程中，您发现了如何在 Python 中使用递归特征消除(RFE)进行特征选择。
具体来说，您了解到:
- RFE 是一种从训练数据集中消除特征以进行特征选择的有效方法。
- 如何使用 RFE 进行分类和回归预测建模问题的特征选择。
- 如何探索 RFE 程序使用的选定特征和包装算法的数量。
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
如何为机器学习缩放带有异常值的数据
最后更新于 2020 年 8 月 28 日
当数值输入变量被缩放到标准范围时，许多机器学习算法表现更好。
这包括使用输入加权和的算法，如线性回归，以及使用距离度量的算法，如 k 近邻。
标准化是一种流行的缩放技术，它从值中减去平均值，除以标准偏差，将输入变量的概率分布转换为标准高斯分布(零平均值和单位方差)。如果输入变量包含异常值，标准化会变得偏斜或有偏差。
为了克服这一点，在标准化数字输入变量时，可以使用中位数和四分位数范围，通常称为稳健缩放。
在本教程中，您将发现如何使用健壮的定标器变换来标准化用于分类和回归的数字输入变量。
完成本教程后，您将知道:
- 当数值输入变量被缩放时，许多机器学习算法更喜欢或表现得更好。
- 使用百分位数的稳健缩放技术可用于缩放包含异常值的数值输入变量。
- 如何使用稳健缩放器使用中位数和四分位数范围来缩放数字输入变量。
用我的新书机器学习的数据准备启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
如何使用鲁棒的缩放器变换进行机器学习 图片由雷在马尼拉拍摄，版权所有。
教程概述
本教程分为五个部分；它们是:
- 缩放数据
- 鲁棒缩放器变换
- 声纳数据集
- IQR 鲁棒定标器变换
- 探索强大的定标器系列
稳健的缩放数据
在拟合机器学习模型之前缩放数据是很常见的。
这是因为数据通常由许多不同的输入变量或特征(列)组成，每个变量或特征可能有不同的值或度量单位范围，如英尺、英里、公斤、美元等。
如果存在相对于其他输入变量具有非常大值的输入变量，这些大值会支配或偏斜一些机器学习算法。结果是算法把大部分注意力放在大值上，而忽略了小值的变量。
这包括使用线性回归、逻辑回归和人工神经网络等输入加权和的算法，以及使用示例间距离度量的算法，如 k 近邻和支持向量机。
因此，在拟合模型之前，作为一种数据准备技术，将输入变量缩放到一个公共范围是正常的。
数据缩放的一种方法包括计算每个变量的平均值和标准偏差，并使用这些值来缩放这些值，使其平均值为零，标准偏差为 1，这就是所谓的“T0”标准正态概率分布。这个过程被称为标准化，当输入变量具有高斯概率分布时最有用。
标准化是通过减去平均值并除以标准偏差来计算的。
- 值=(值–平均值)/ stdev
有时一个输入变量可能有个异常值。这些值处于分布的边缘，出现的概率可能很低，但由于某种原因，它们的出现率过高。异常值会偏斜概率分布，并使使用标准化进行数据缩放变得困难，因为异常值的存在会偏斜计算的平均值和标准偏差。
存在异常值时标准化输入变量的一种方法是忽略平均值和标准偏差计算中的异常值，然后使用计算值来缩放变量。
这被称为稳健标准化或稳健数据缩放。
这可以通过计算中位数(第 50 个百分点)以及第 25 个和第 75 个百分点来实现。然后减去每个变量的中值，除以第 75 个和第 25 个百分点之间的差值四分位数区间 (IQR)。
- 值=(值–中间值)/(p75–p25)
所得变量的平均值和中值为零，标准偏差为 1，尽管没有被异常值偏斜，并且异常值仍然以与其他值相同的相对关系存在。
鲁棒缩放器变换
通过鲁棒缩放器类，在 Sklearn Python 机器学习库中可以获得鲁棒缩放器转换。
带中心的“”参数控制值是否以零为中心(减去中间值)，默认为真*。*
*“ with_scaling ”参数控制值是否缩放到 IQR(标准偏差设置为 1)并默认为 True 。
有趣的是，缩放范围的定义可以通过“分位数 _ 范围”参数来指定。它采用 0 到 100 之间的两个整数的元组，默认为 IQR 的百分位值，具体为(25，75)。改变这一点将改变异常值的定义和缩放的范围。
我们将仔细研究如何在真实数据集上使用健壮的定标器变换。
首先，让我们介绍一个真实的数据集。
声纳数据集
声纳数据集是用于二进制分类的标准机器学习数据集。
它涉及 60 个实值输入和一个两类目标变量。数据集中有 208 个示例，类别相当均衡。
使用重复的分层 10 倍交叉验证，基线分类算法可以达到大约 53.4%的分类准确率。使用重复的分层 10 倍交叉验证，该数据集的最高表现约为 88%。
该数据集描述了岩石或模拟地雷的雷达回波。
您可以从这里了解有关数据集的更多信息:
不需要下载数据集；我们将从我们的工作示例中自动下载它。
首先，让我们加载并总结数据集。下面列出了完整的示例。
# load and summarize the sonar dataset
from pandas import read_csv
from pandas.plotting import scatter_matrix
from matplotlib import pyplot
# Load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv"
dataset = read_csv(url, header=None)
# summarize the shape of the dataset
print(dataset.shape)
# summarize each variable
print(dataset.describe())
# histograms of the variables
dataset.hist()
pyplot.show()
运行该示例首先总结加载数据集的形状。
这确认了 60 个输入变量、一个输出变量和 208 行数据。
提供了输入变量的统计摘要，显示值是数值，范围大约从 0 到 1。
(208, 61)
0 1 2 ... 57 58 59
count 208.000000 208.000000 208.000000 ... 208.000000 208.000000 208.000000
mean 0.029164 0.038437 0.043832 ... 0.007949 0.007941 0.006507
std 0.022991 0.032960 0.038428 ... 0.006470 0.006181 0.005031
min 0.001500 0.000600 0.001500 ... 0.000300 0.000100 0.000600
25% 0.013350 0.016450 0.018950 ... 0.003600 0.003675 0.003100
50% 0.022800 0.030800 0.034300 ... 0.005800 0.006400 0.005300
75% 0.035550 0.047950 0.057950 ... 0.010350 0.010325 0.008525
max 0.137100 0.233900 0.305900 ... 0.044000 0.036400 0.043900
[8 rows x 60 columns]
最后，为每个输入变量创建一个直方图。
如果我们忽略图中杂乱的东西，专注于直方图本身，我们可以看到许多变量都有一个偏斜的分布。
数据集为在存在偏斜分布和异常值的情况下使用稳健的定标器变换来标准化数据提供了一个很好的候选。
声纳二进制类别数据集输入变量的直方图
接下来，让我们在原始数据集上拟合和评估一个机器学习模型。
我们将使用带有默认超参数的 k 近邻算法，并使用重复分层 K 折交叉验证对其进行评估。下面列出了完整的示例。
# evaluate knn on the raw sonar dataset
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import LabelEncoder
from matplotlib import pyplot
# load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv"
dataset = read_csv(url, header=None)
data = dataset.values
# separate into input and output columns
X, y = data[:, :-1], data[:, -1]
# ensure inputs are floats and output is an integer label
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
# define and configure the model
model = KNeighborsClassifier()
# evaluate the model
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
# report model performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例会评估原始声纳数据集上的 KNN 模型。
我们可以看到，该模型实现了大约 79.7%的平均分类准确率，表明它具有技巧性(优于 53.4%)，并且处于良好表现的球园区(88%)。
Accuracy: 0.797 (0.073)
接下来，让我们探索数据集的稳健缩放变换。
IQR 鲁棒定标器变换
我们可以将稳健的定标器直接应用于声纳数据集。
我们将使用默认配置并将值缩放到 IQR。首先，用默认超参数定义一个鲁棒定标器实例。一旦定义，我们就可以调用 fit_transform() 函数，并将其传递给我们的数据集，以创建数据集的分位数转换版本。
...
# perform a robust scaler transform of the dataset
trans = RobustScaler()
data = trans.fit_transform(data)
让我们在声纳数据集上试试。
下面列出了创建声纳数据集的鲁棒定标器变换和绘制结果直方图的完整示例。
# visualize a robust scaler transform of the sonar dataset
from pandas import read_csv
from pandas import DataFrame
from pandas.plotting import scatter_matrix
from sklearn.preprocessing import RobustScaler
from matplotlib import pyplot
# load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv"
dataset = read_csv(url, header=None)
# retrieve just the numeric input values
data = dataset.values[:, :-1]
# perform a robust scaler transform of the dataset
trans = RobustScaler()
data = trans.fit_transform(data)
# convert the array back to a dataframe
dataset = DataFrame(data)
# summarize
print(dataset.describe())
# histograms of the variables
dataset.hist()
pyplot.show()
运行该示例首先报告每个输入变量的摘要。
我们可以看到分布已经调整。中值现在为零，标准偏差值现在接近 1.0。
0 1 ... 58 59
count 208.000000 208.000000 ... 2.080000e+02 208.000000
mean 0.286664 0.242430 ... 2.317814e-01 0.222527
std 1.035627 1.046347 ... 9.295312e-01 0.927381
min -0.959459 -0.958730 ... -9.473684e-01 -0.866359
25% -0.425676 -0.455556 ... -4.097744e-01 -0.405530
50% 0.000000 0.000000 ... 6.591949e-17 0.000000
75% 0.574324 0.544444 ... 5.902256e-01 0.594470
max 5.148649 6.447619 ... 4.511278e+00 7.115207
[8 rows x 60 columns]
创建了变量的直方图，尽管这些分布看起来与上一节中看到的原始分布没有太大不同。
声纳数据集的鲁棒定标器变换输入变量的直方图
接下来，让我们评估与上一节相同的 KNN 模型，但在这种情况下，是基于数据集的鲁棒定标器变换。
下面列出了完整的示例。
# evaluate knn on the sonar dataset with robust scaler transform
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import RobustScaler
from sklearn.pipeline import Pipeline
from matplotlib import pyplot
# load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv"
dataset = read_csv(url, header=None)
data = dataset.values
# separate into input and output columns
X, y = data[:, :-1], data[:, -1]
# ensure inputs are floats and output is an integer label
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
# define the pipeline
trans = RobustScaler(with_centering=False, with_scaling=True)
model = KNeighborsClassifier()
pipeline = Pipeline(steps=[('t', trans), ('m', model)])
# evaluate the pipeline
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
# report pipeline performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
运行该示例，我们可以看到稳健的定标器变换将表现从无变换时的 79.7%提升到有变换时的约 81.9%。
Accuracy: 0.819 (0.076)
接下来，让我们探索不同缩放范围的效果。
探索强大的定标器系列
默认情况下，用于缩放每个变量的范围是选定的，因为 IQR 以第 25 个和第 75 个百分点为界。
这由作为元组的“分位数 _ 范围”参数指定。
可以指定其他值，这些值可能会提高模型的表现，例如更宽的范围允许更少的值被视为异常值，或者更窄的范围允许更多的值被视为异常值。
下面的例子探讨了从第 1 到第 99 个百分点到第 30 到第 70 个百分点范围的不同定义的影响。
下面列出了完整的示例。
# explore the scaling range of the robust scaler transform
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import RobustScaler
from sklearn.preprocessing import LabelEncoder
from sklearn.pipeline import Pipeline
from matplotlib import pyplot
# get the dataset
def get_dataset():
# load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv"
dataset = read_csv(url, header=None)
data = dataset.values
# separate into input and output columns
X, y = data[:, :-1], data[:, -1]
# ensure inputs are floats and output is an integer label
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
return X, y
# get a list of models to evaluate
def get_models():
models = dict()
for value in [1, 5, 10, 15, 20, 25, 30]:
# define the pipeline
trans = RobustScaler(quantile_range=(value, 100-value))
model = KNeighborsClassifier()
models[str(value)] = Pipeline(steps=[('t', trans), ('m', model)])
return models
# evaluate a give model using cross-validation
def evaluate_model(model, X, y):
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
return scores
# define dataset
X, y = get_dataset()
# get the models to evaluate
models = get_models()
# evaluate the models and store results
results, names = list(), list()
for name, model in models.items():
scores = evaluate_model(model, X, y)
results.append(scores)
names.append(name)
print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
# plot model performance for comparison
pyplot.boxplot(results, labels=names, showmeans=True)
pyplot.show()
运行该示例会报告每个值定义的 IQR 范围的平均分类准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
我们可以看到，默认的第 25 到第 75 百分位达到了最好的结果，尽管 20-80 和 30-70 的值达到了非常相似的结果。
>1 0.818 (0.069)
>5 0.813 (0.085)
>10 0.812 (0.076)
>15 0.811 (0.081)
>20 0.811 (0.080)
>25 0.819 (0.076)
>30 0.816 (0.072)
创建方框图和触须图来总结每个 IQR 范围的分类准确度分数。
在 25-75%和 30-70%的较大范围内，我们可以看到分布和平均准确率的显著差异。
声呐数据集上鲁棒定标器 IQR 距离与 KNN 分类准确率的箱线图
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
教程
蜜蜂
文章
- 四分之一区间，维基百科。
摘要
在本教程中，您发现了如何使用健壮的定标器变换来标准化用于分类和回归的数字输入变量。
具体来说，您了解到:
- 当数值输入变量被缩放时，许多机器学习算法更喜欢或表现得更好。
- 使用百分位数的稳健缩放技术可用于缩放包含异常值的数值输入变量。
- 如何使用稳健缩放器使用中位数和四分位数范围来缩放数字输入变量。
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。*
如何选择性缩放机器学习的数值输入变量
最后更新于 2020 年 8 月 17 日
许多机器学习模型在建模前仔细转换或缩放输入变量时表现更好。
将相同的数据转换(如标准化和规范化)同等地应用于所有输入变量是方便的，因此也是常见的。这样可以在很多问题上取得很好的效果。然而，通过在建模之前仔细选择要应用于每个输入变量的数据变换，可以获得更好的结果。
在本教程中，您将发现如何应用数字输入变量的选择性缩放。
完成本教程后，您将知道:
- 如何加载和计算糖尿病类别数据集的基线预测表现？
- 如何评估数据转换盲目应用于所有数值输入变量的建模管道。
- 如何用应用于输入变量子集的选择性规范化和标准化来评估建模管道？
用我的新书机器学习的数据准备启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
如何有选择地缩放机器学习的数字输入变量 图片由马可·韦奇提供，版权所有。
教程概述
本教程分为三个部分；它们是:
- 糖尿病数值数据集
- 数字输入的非选择性缩放
- 标准化所有输入变量
- 标准化所有输入变量
- 数字输入的选择性缩放
- 仅归一化非高斯输入变量
- 仅标准化类似高斯的输入变量
- 选择性地规范化和标准化输入变量
糖尿病数值数据集
作为本教程的基础，我们将使用自 20 世纪 90 年代以来作为机器学习数据集被广泛研究的所谓“糖尿病”数据集。
该数据集将患者数据分为五年内糖尿病发作和非糖尿病发作。共有 768 个例子和 8 个输入变量。这是一个二分类问题。
您可以在此了解有关数据集的更多信息:
不需要下载数据集；我们将自动下载它，作为下面工作示例的一部分。
查看数据，我们可以看到所有九个输入变量都是数值。
6,148,72,35,0,33.6,0.627,50,1
1,85,66,29,0,26.6,0.351,31,0
8,183,64,0,0,23.3,0.672,32,1
1,89,66,23,94,28.1,0.167,21,0
0,137,40,35,168,43.1,2.288,33,1
...
我们可以使用熊猫库将这个数据集加载到内存中。
以下示例下载并总结了糖尿病数据集。
# load and summarize the diabetes dataset
from pandas import read_csv
from pandas.plotting import scatter_matrix
from matplotlib import pyplot
# Load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.csv"
dataset = read_csv(url, header=None)
# summarize the shape of the dataset
print(dataset.shape)
# histograms of the variables
dataset.hist()
pyplot.show()
运行该示例首先下载数据集，并将其作为数据帧加载。
打印数据集的形状，确认行数、九个变量、八个输入和一个目标。
(768, 9)
最后，创建一个图，显示数据集中每个变量的直方图。
这很有用，因为我们可以看到一些变量具有高斯或类高斯分布(1，2，5)，而其他变量具有类指数分布(0，3，4，6，7)。这可能意味着不同类型的输入变量需要不同的数字数据转换。
糖尿病类别数据集中每个变量的直方图
现在我们对数据集有点熟悉了，让我们尝试在原始数据集上拟合和评估模型。
我们将使用逻辑回归模型，因为它们是用于二进制分类任务的健壮且有效的线性模型。我们将使用重复的分层 k 折叠交叉验证来评估模型，这是一种最佳实践，并使用 10 次折叠和 3 次重复。
下面列出了完整的示例。
# evaluate a logistic regression model on the raw diabetes dataset
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.linear_model import LogisticRegression
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
# separate into input and output elements
X, y = data[:, :-1], data[:, -1]
# minimally prepare dataset
X = X.astype('float')
y = LabelEncoder().fit_transform(y.astype('str'))
# define the model
model = LogisticRegression(solver='liblinear')
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model
m_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# summarize the result
print('Accuracy: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
运行该示例评估模型，并报告在原始数据集上拟合逻辑回归模型的平均值和标准偏差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到模型达到了大约 76.8%的准确率。
Accuracy: 0.768 (0.040)
现在，我们已经在数据集上建立了表现基线，让我们看看是否可以使用数据缩放来提高表现。
数字输入的非选择性缩放
许多算法喜欢或要求在拟合模型之前将输入变量缩放到一致的范围。
这包括假设输入变量具有高斯概率分布的逻辑回归模型。如果输入变量标准化，它还可以提供一个数值更稳定的模型。然而，即使当这些期望被违反时，逻辑回归对于给定的数据集可以表现良好或最好，糖尿病数据集可能就是这种情况。
缩放数字输入变量的两种常用技术是标准化和规范化。
标准化将每个输入变量缩放到 0-1 的范围，并且可以使用 Sklearn 中的最小最大缩放器类来实现。标准化将每个输入变量的平均值和标准偏差分别调整为 0.0 和 1.0，可以使用 Sklearn 中的标准缩放器类来实现。
要了解有关规范化、标准化以及如何在 Sklearn 中使用这些方法的更多信息，请参见教程:
一种简单的数据缩放方法对所有输入变量应用单一的变换，而不管它们的规模或概率分布如何。这通常是有效的。
让我们尝试直接规范化和标准化所有输入变量，并将表现与原始数据上的基线逻辑回归模型进行比较。
标准化所有输入变量
我们可以更新基线代码示例来使用建模管道，其中第一步是应用缩放器，最后一步是拟合模型。
这确保了缩放操作仅适用于或准备用于训练集，然后在交叉验证过程中应用于训练集和测试集，从而避免数据泄漏。数据泄露会导致对模型表现的乐观估计。
这可以使用 pipeline 类来实现，在 Pipeline 类中，管道中的每个步骤都被定义为一个元组，该元组具有要使用的转换或模型的名称和实例。
...
# define the modeling pipeline
scaler = MinMaxScaler()
model = LogisticRegression(solver='liblinear')
pipeline = Pipeline([('s',scaler),('m',model)])
将这些联系在一起，下面列出了在糖尿病数据集上评估逻辑回归的完整示例，其中所有输入变量都进行了标准化。
# evaluate a logistic regression model on the normalized diabetes dataset
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import MinMaxScaler
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
# separate into input and output elements
X, y = data[:, :-1], data[:, -1]
# minimally prepare dataset
X = X.astype('float')
y = LabelEncoder().fit_transform(y.astype('str'))
# define the modeling pipeline
model = LogisticRegression(solver='liblinear')
scaler = MinMaxScaler()
pipeline = Pipeline([('s',scaler),('m',model)])
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model
m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# summarize the result
print('Accuracy: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
运行该示例评估建模管道，并报告在标准化数据集上拟合逻辑回归模型的平均值和标准偏差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到，输入变量的标准化导致平均分类准确率从原始数据模型拟合的 76.8%下降到标准化管道的 76.4%。
Accuracy: 0.764 (0.045)
接下来，让我们尝试标准化所有输入变量。
标准化所有输入变量
在拟合和评估逻辑回归模型之前，我们可以更新建模管道，对所有输入变量使用标准化，而不是标准化。
这可能是对具有类似高斯分布的输入变量的适当转换，但可能不是对其他变量的转换。
...
# define the modeling pipeline
scaler = StandardScaler()
model = LogisticRegression(solver='liblinear')
pipeline = Pipeline([('s',scaler),('m',model)])
将这些联系在一起，下面列出了在糖尿病数据集上评估逻辑回归模型的完整示例，其中所有输入变量都已标准化。
# evaluate a logistic regression model on the standardized diabetes dataset
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
# separate into input and output elements
X, y = data[:, :-1], data[:, -1]
# minimally prepare dataset
X = X.astype('float')
y = LabelEncoder().fit_transform(y.astype('str'))
# define the modeling pipeline
scaler = StandardScaler()
model = LogisticRegression(solver='liblinear')
pipeline = Pipeline([('s',scaler),('m',model)])
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model
m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# summarize the result
print('Accuracy: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
运行该示例评估建模管道，并报告在标准化数据集上拟合逻辑回归模型的均值和标准差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到，标准化所有数字输入变量已导致平均分类准确率从原始数据集上评估的模型的 76.8%提升到标准化输入变量数据集上评估的模型的约 77.2%。
Accuracy: 0.772 (0.043)
到目前为止，我们已经了解到标准化所有变量对表现没有帮助，但是标准化所有输入变量对表现有帮助。
接下来，让我们探讨一下选择性地对输入变量应用缩放是否能提供进一步的改进。
数字输入的选择性缩放
使用 Sklearn 中的 ColumnTransformer 类，可以有选择地将数据转换应用于输入变量。
它允许您指定要应用的转换(或转换管道)以及要应用它们的列索引。然后，这可以用作建模管道的一部分，并使用交叉验证进行评估。
您可以在教程中了解有关如何使用 ColumnTransformer 的更多信息:
我们可以探索使用 ColumnTransformer 对糖尿病数据集的数字输入变量选择性地应用规范化和标准化，以查看我们是否能够实现进一步的表现改进。
仅归一化非高斯输入变量
首先，让我们试着规范化那些没有高斯概率分布的输入变量，让其余的输入变量单独处于原始状态。
我们可以使用列索引定义两组输入变量，一组用于高斯分布的变量，另一组用于指数分布的输入变量。
...
# define column indexes for the variables with "normal" and "exponential" distributions
norm_ix = [1, 2, 5]
exp_ix = [0, 3, 4, 6, 7]
然后，我们可以有选择地规范化“ exp_ix ”组，让其他输入变量通过，而无需任何数据准备。
...
# define the selective transforms
t = [('e', MinMaxScaler(), exp_ix)]
selective = ColumnTransformer(transformers=t, remainder='passthrough')
然后，选择性转换可以用作我们的建模管道的一部分。
...
# define the modeling pipeline
model = LogisticRegression(solver='liblinear')
pipeline = Pipeline([('s',selective),('m',model)])
将这些联系在一起，下面列出了对一些输入变量进行选择性标准化的数据进行逻辑回归模型评估的完整示例。
# evaluate a logistic regression model on the diabetes dataset with selective normalization
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import MinMaxScaler
from sklearn.compose import ColumnTransformer
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
# separate into input and output elements
X, y = data[:, :-1], data[:, -1]
# minimally prepare dataset
X = X.astype('float')
y = LabelEncoder().fit_transform(y.astype('str'))
# define column indexes for the variables with "normal" and "exponential" distributions
norm_ix = [1, 2, 5]
exp_ix = [0, 3, 4, 6, 7]
# define the selective transforms
t = [('e', MinMaxScaler(), exp_ix)]
selective = ColumnTransformer(transformers=t, remainder='passthrough')
# define the modeling pipeline
model = LogisticRegression(solver='liblinear')
pipeline = Pipeline([('s',selective),('m',model)])
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model
m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# summarize the result
print('Accuracy: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
运行该示例评估建模管道，并报告平均值和标准偏差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到稍好的表现，随着基线模型在原始数据集上的拟合度从 76.8%提高到约 76.9%，并对一些输入变量进行选择性归一化。
结果不如标准化所有的输入变量。
Accuracy: 0.769 (0.043)
仅标准化类似高斯的输入变量
我们可以重复上一节的实验，尽管在这种情况下，有选择地标准化那些具有类似高斯分布的输入变量，而保持剩余的输入变量不变。
...
# define the selective transforms
t = [('n', StandardScaler(), norm_ix)]
selective = ColumnTransformer(transformers=t, remainder='passthrough')
将这些联系在一起，下面列出了在对一些输入变量进行选择性标准化的数据上评估逻辑回归模型的完整示例。
# evaluate a logistic regression model on the diabetes dataset with selective standardization
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.compose import ColumnTransformer
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
# separate into input and output elements
X, y = data[:, :-1], data[:, -1]
# minimally prepare dataset
X = X.astype('float')
y = LabelEncoder().fit_transform(y.astype('str'))
# define column indexes for the variables with "normal" and "exponential" distributions
norm_ix = [1, 2, 5]
exp_ix = [0, 3, 4, 6, 7]
# define the selective transforms
t = [('n', StandardScaler(), norm_ix)]
selective = ColumnTransformer(transformers=t, remainder='passthrough')
# define the modeling pipeline
model = LogisticRegression(solver='liblinear')
pipeline = Pipeline([('s',selective),('m',model)])
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model
m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# summarize the result
print('Accuracy: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
运行该示例评估建模管道，并报告平均值和标准偏差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到，我们的表现提升了 76.8%，超过了原始数据集上基线模型拟合的 76.8%，也超过了所有输入变量标准化的 77.2%。通过选择性标准化，我们实现了大约 77.3%的平均准确率，这是一个适度但可测量的提升。
Accuracy: 0.773 (0.041)
选择性地规范化和标准化输入变量
到目前为止的结果提出了一个问题，即我们是否可以通过在数据集上同时结合使用选择性规范化和标准化来获得进一步的提升。
这可以通过为 ColumnTransformer 类定义转换和它们各自的列索引来实现，并且不传递任何剩余的变量。
...
# define the selective transforms
t = [('e', MinMaxScaler(), exp_ix), ('n', StandardScaler(), norm_ix)]
selective = ColumnTransformer(transformers=t)
将这些联系在一起，下面列出了对输入变量进行选择性规范化和标准化的数据进行逻辑回归模型评估的完整示例。
# evaluate a logistic regression model on the diabetes dataset with selective scaling
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import StandardScaler
from sklearn.compose import ColumnTransformer
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
# separate into input and output elements
X, y = data[:, :-1], data[:, -1]
# minimally prepare dataset
X = X.astype('float')
y = LabelEncoder().fit_transform(y.astype('str'))
# define column indexes for the variables with "normal" and "exponential" distributions
norm_ix = [1, 2, 5]
exp_ix = [0, 3, 4, 6, 7]
# define the selective transforms
t = [('e', MinMaxScaler(), exp_ix), ('n', StandardScaler(), norm_ix)]
selective = ColumnTransformer(transformers=t)
# define the modeling pipeline
model = LogisticRegression(solver='liblinear')
pipeline = Pipeline([('s',selective),('m',model)])
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model
m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# summarize the result
print('Accuracy: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
运行该示例评估建模管道，并报告平均值和标准偏差准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
有趣的是，在这种情况下，我们可以看到，我们实现了与标准化所有输入变量相同的表现，达到了 77.2%。
此外，结果表明，当非高斯型变量保持原样时，所选模型的表现优于标准化或规范化模型。
我不会猜到这个发现，它强调了仔细实验的重要性。
Accuracy: 0.772 (0.040)
你能做得更好吗？
尝试其他变换或变换组合，看看是否能获得更好的结果。 在下面的评论中分享你的发现。
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
教程
蜜蜂
摘要
在本教程中，您发现了如何应用数字输入变量的选择性缩放。
具体来说，您了解到:
- 如何加载和计算糖尿病类别数据集的基线预测表现？
- 如何评估数据转换盲目应用于所有数值输入变量的建模管道。
- 如何用应用于输入变量子集的选择性规范化和标准化来评估建模管道？
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
Python 中用于降维的奇异值分解
最后更新于 2020 年 8 月 18 日
减少预测模型的输入变量的数量被称为降维。
较少的输入变量可以导致更简单的预测模型，该模型在对新数据进行预测时可能具有更好的表现。
也许机器学习中更流行的降维技术是奇异值分解，简称 SVD。这是一种来自线性代数领域的技术，可以用作数据准备技术，在拟合模型之前创建稀疏数据集的投影。
在本教程中，您将发现在开发预测模型时如何使用奇异值分解进行降维。
完成本教程后，您将知道:
- 降维包括减少建模数据中输入变量或列的数量。
- 奇异值分解是一种来自线性代数的技术，可用于自动执行降维。
- 如何评估使用奇异值分解投影作为输入的预测模型，并使用新的原始数据进行预测。
用我的新书机器学习的数据准备启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
- 2020 年 5 月更新:改进代码注释。
Python 中降维的奇异值分解 图片由金伯利·瓦德曼提供，保留部分权利。
教程概述
本教程分为三个部分；它们是:
- 降维与奇异值分解
- 学习应用编程接口
- 面向维度的奇异值分解工作示例
降维与奇异值分解
降维是指减少数据集的输入变量数量。
如果您的数据是用行和列来表示的，例如在电子表格中，那么输入变量就是作为输入提供给模型以预测目标变量的列。输入变量也称为特征。
我们可以将 n 维特征空间上表示维度的数据列和数据行视为该空间中的点。这是数据集的一种有用的几何解释。
在具有 k 个数字属性的数据集中，您可以将数据可视化为 k 维空间中的点云…
—第 305 页，数据挖掘:实用机器学习工具与技术，2016 年第 4 版。
特征空间中有大量的维度可能意味着该空间的体积非常大，反过来，我们在该空间中的点(数据行)通常代表一个小的且不具有代表性的样本。
这可能会极大地影响机器学习算法在具有许多输入特征的数据上的表现，通常被称为“维度诅咒””
因此，通常希望减少输入特征的数量。这减少了特征空间的维数，因此被称为“降维”
降维的一种流行方法是使用线性代数领域的技术。这通常被称为“T0”特征投影，所使用的算法被称为“T2”投影方法
投影方法寻求减少特征空间中的维数，同时保留数据中观察到的变量之间最重要的结构或关系。
当处理高维数据时，通过将数据投影到捕捉数据“本质”的低维子空间来降低维数通常是有用的。这叫做降维。
—第 11 页，机器学习:概率视角，2012。
得到的数据集，即投影，可以用作训练机器学习模型的输入。
本质上，原始特征不再存在，而新特征是从与原始数据不直接可比的可用数据构建的，例如没有列名。
未来在进行预测时，任何新数据(如测试数据集和新数据集)都必须使用相同的技术进行投影。
当数据稀疏时，奇异值分解可能是最流行的降维技术。
稀疏数据是指许多值为零的数据行。这在一些问题领域中经常出现，例如推荐系统，其中用户对数据库中很少的电影或歌曲有评级，而对所有其他情况没有评级。另一个常见的例子是一个文本文档的单词包模型，其中文档有一些单词的计数或频率，大多数单词的值为 0。
适用于应用奇异值分解进行降维的稀疏数据示例:
- 推荐系统
- 客户-产品购买
- 用户-歌曲收听次数
- 用户-电影分级
- 文本分类
- 一种热编码
- 单词包很重要
- TF/以色列国防军
有关稀疏数据和稀疏矩阵的更多信息，请参见教程:
奇异值分解可以被认为是一种投影方法，其中具有 m 列(特征)的数据被投影到具有 m 列或更少列的子空间中，同时保留原始数据的本质。
奇异值分解广泛应用于其他矩阵运算的计算，如矩阵求逆，也可作为机器学习中的一种数据约简方法。
有关如何详细计算奇异值分解的更多信息，请参见教程:
现在我们已经熟悉了用于降维的 SVD，让我们看看如何将这种方法用于 Sklearn 库。
学习应用编程接口
我们可以使用奇异值分解来计算数据集的投影，并选择投影的多个维度或主成分作为模型的输入。
Sklearn 库提供了截断数据集类，该类可以适合数据集，并用于转换训练数据集和未来的任何附加数据集。
例如:
...
data = ...
# define transform
svd = TruncatedSVD()
# prepare transform on dataset
svd.fit(data)
# apply transform to dataset
transformed = svd.transform(data)
奇异值分解的输出可以用作训练模型的输入。
也许最好的方法是使用管道，其中第一步是奇异值分解变换，下一步是将变换后的数据作为输入的学习算法。
...
# define the pipeline
steps = [('svd', TruncatedSVD()), ('m', LogisticRegression())]
model = Pipeline(steps=steps)
现在我们已经熟悉了 SVD API，让我们来看一个工作示例。
面向维度的奇异值分解工作示例
奇异值分解通常用于稀疏数据。
这包括推荐系统的数据或文本的单词包模型。如果数据密集，那么最好使用 PCA 方法。
然而，为了简单起见，我们将在本节中演示密集数据上的奇异值分解。您可以根据自己的稀疏数据集轻松调整它。
首先，我们可以使用 make_classification()函数创建一个包含 1000 个示例和 20 个输入特征的合成二进制分类问题，其中 15 个输入是有意义的。
下面列出了完整的示例。
# test classification dataset
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# summarize the dataset
print(X.shape, y.shape)
运行该示例将创建数据集并总结输入和输出组件的形状。
(1000, 20) (1000,)
接下来，我们可以在拟合逻辑回归模型时对该数据集使用降维。
我们将使用管道，其中第一步执行奇异值分解转换并选择 10 个最重要的维度或组件，然后在这些特征上拟合逻辑回归模型。我们不需要标准化这个数据集中的变量，因为所有的变量都有相同的设计比例。
管道将使用重复分层交叉验证进行评估，重复三次，每次重复 10 次。表现表示为平均分类准确率。
下面列出了完整的示例。
# evaluate svd with logistic regression algorithm for classification
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.decomposition import TruncatedSVD
from sklearn.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# define the pipeline
steps = [('svd', TruncatedSVD(n_components=10)), ('m', LogisticRegression())]
model = Pipeline(steps=steps)
# evaluate model
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例评估模型并报告分类准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到带有逻辑回归的奇异值分解变换获得了大约 81.4%的表现。
Accuracy: 0.814 (0.034)
我们如何知道将输入的 20 个维度减少到 10 个是好的还是我们能做的最好的？
我们没有；10 是一个任意的选择。
更好的方法是用不同数量的输入特征评估相同的变换和模型，并选择导致最佳平均表现的特征数量(降维量)。
下面的示例执行了该实验，并总结了每种配置的平均分类准确率。
# compare svd number of components with logistic regression algorithm for classification
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.decomposition import TruncatedSVD
from sklearn.linear_model import LogisticRegression
from matplotlib import pyplot
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
return X, y
# get a list of models to evaluate
def get_models():
models = dict()
for i in range(1,20):
steps = [('svd', TruncatedSVD(n_components=i)), ('m', LogisticRegression())]
models[str(i)] = Pipeline(steps=steps)
return models
# evaluate a give model using cross-validation
def evaluate_model(model, X, y):
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
return scores
# define dataset
X, y = get_dataset()
# get the models to evaluate
models = get_models()
# evaluate the models and store results
results, names = list(), list()
for name, model in models.items():
scores = evaluate_model(model, X, y)
results.append(scores)
names.append(name)
print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
# plot model performance for comparison
pyplot.boxplot(results, labels=names, showmeans=True)
pyplot.xticks(rotation=45)
pyplot.show()
运行该示例首先报告所选组件或特征的每个数量的分类准确率。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
随着维度数量的增加，我们可以看到表现提高的总体趋势。在这个数据集上，结果显示了维度数量和模型分类准确率之间的权衡。
有趣的是，我们没有看到超过 15 个组件的任何改进。这与我们对问题的定义相匹配，其中只有前 15 个组件包含关于该类的信息，其余 5 个是冗余的。
>1 0.542 (0.046)
>2 0.626 (0.050)
>3 0.719 (0.053)
>4 0.722 (0.052)
>5 0.721 (0.054)
>6 0.729 (0.045)
>7 0.802 (0.034)
>8 0.800 (0.040)
>9 0.814 (0.037)
>10 0.814 (0.034)
>11 0.817 (0.037)
>12 0.820 (0.038)
>13 0.820 (0.036)
>14 0.825 (0.036)
>15 0.865 (0.027)
>16 0.865 (0.027)
>17 0.865 (0.027)
>18 0.865 (0.027)
>19 0.865 (0.027)
为每个配置的尺寸数量的准确率分数的分布创建一个方框和触须图。
我们可以看到分类准确率随着组件数量的增加而增加的趋势，限制在 15。
奇异值分解组件数与分类准确率的箱线图
我们可以选择使用奇异值分解变换和逻辑回归模型组合作为最终模型。
这包括在所有可用数据上拟合管道，并使用管道对新数据进行预测。重要的是，必须对这个新数据执行相同的转换，这是通过管道自动处理的。
下面的代码提供了一个在新数据上拟合和使用带有奇异值分解变换的最终模型的例子。
# make predictions using svd with logistic regression
from sklearn.datasets import make_classification
from sklearn.pipeline import Pipeline
from sklearn.decomposition import TruncatedSVD
from sklearn.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# define the model
steps = [('svd', TruncatedSVD(n_components=15)), ('m', LogisticRegression())]
model = Pipeline(steps=steps)
# fit the model on the whole dataset
model.fit(X, y)
# make a single prediction
row = [[0.2929949,-4.21223056,-1.288332,-2.17849815,-0.64527665,2.58097719,0.28422388,-7.1827928,-1.91211104,2.73729512,0.81395695,3.96973717,-2.66939799,3.34692332,4.19791821,0.99990998,-0.30201875,-4.43170633,-2.82646737,0.44916808]]
yhat = model.predict(row)
print('Predicted Class: %d' % yhat[0])
运行该示例使管道适用于所有可用数据，并对新数据进行预测。
这里，转换使用了 SVD 转换中最重要的 15 个分量，正如我们在上面的测试中发现的那样。
提供具有 20 列的新数据行，并自动转换为 15 个分量，并馈送到逻辑回归模型，以便预测类别标签。
Predicted Class: 1
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
教程
报纸
- 寻找具有随机性的结构:构造近似矩阵分解的概率算法，2009。
书
- 机器学习:概率视角，2012。
- 数据挖掘:实用机器学习工具与技术，第 4 版，2016。
- 模式识别与机器学习，2006。
蜜蜂
文章
摘要
在本教程中，您发现了如何在开发预测模型时使用奇异值分解进行降维。
具体来说，您了解到:
- 降维包括减少建模数据中输入变量或列的数量。
- 奇异值分解是一种来自线性代数的技术，可用于自动执行降维。
- 如何评估使用奇异值分解投影作为输入的预测模型，并使用新的原始数据进行预测。
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
如何在 Python 中使用标准缩放器和最小最大缩放器变换
最后更新于 2020 年 8 月 28 日
当数值输入变量被缩放到标准范围时，许多机器学习算法表现更好。
这包括使用输入加权和的算法，如线性回归，以及使用距离度量的算法，如 k 近邻。
建模前缩放数值数据的两种最流行的技术是标准化和规范化。归一化将每个输入变量分别缩放到 0-1 范围，这是我们准确率最高的浮点值范围。标准化通过减去平均值(称为对中)并除以标准差来分别缩放每个输入变量，以使分布的平均值为零，标准差为 1。
在本教程中，您将发现如何使用 scaler 变换来标准化和规范化用于分类和回归的数字输入变量。
完成本教程后，您将知道:
- 当使用许多机器学习算法时，数据缩放是推荐的预处理步骤。
- 数据缩放可以通过规范化或标准化实值输入和输出变量来实现。
- 如何应用标准化和规范化提高预测建模算法的表现？
用我的新书机器学习的数据准备启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
如何使用标准缩放器和最小最大缩放器变换 照片作者马可·韦奇，版权所有。
教程概述
本教程分为六个部分；它们是:
- 您的数据规模很重要
- 数值数据缩放方法
- 数据标准化
- 数据标准化
- 声纳数据集
- 最小最大缩放器变换
- 标准缩放器变换
- 常见问题
您的数据规模很重要
机器学习模型学习从输入变量到输出变量的映射。
因此，从域中提取的数据的规模和分布对于每个变量可能是不同的。
输入变量可能具有不同的单位(例如英尺、公里和小时)，这反过来意味着变量具有不同的标度。
输入变量之间的比例差异可能会增加建模问题的难度。这方面的一个例子是，大的输入值(例如数百或数千个单位的分布)会导致模型学习大的权重值。具有大权重值的模型通常是不稳定的，这意味着它可能在学习过程中表现不佳，并且对输入值敏感，从而导致较高的泛化误差。
预处理最常见的形式之一是对输入变量进行简单的线性重新缩放。
—第 298 页，用于模式识别的神经网络，1995。
输入变量的比例差异不会影响所有的机器学习算法。
例如，适合使用输入变量加权和的模型的算法会受到影响，例如线性回归、逻辑回归和人工神经网络(深度学习)。
例如，当使用预测器之间的距离或点积(如 K 近邻或支持向量机)时，或者当为了应用惩罚而要求变量是共同的尺度时，标准化过程是必不可少的。
—第 124 页，特征工程与选择，2019。
此外，使用示例或样本之间距离度量的算法也会受到影响，例如 k 近邻和支持向量机。还有一些算法不受数字输入变量规模的影响，最显著的是决策树和树的集合，如随机森林。
不同的属性是在不同的尺度上测量的，所以如果直接使用欧几里德距离公式，一些属性的效果可能会与其他具有更大测量尺度的属性完全相形见绌。因此，通常会标准化所有属性值…
—第 145 页，数据挖掘:实用机器学习工具与技术，2016。
缩放回归预测建模问题的目标变量也是一个好主意，以使问题更容易学习，尤其是在神经网络模型的情况下。具有大范围值的目标变量反过来可能导致大的误差梯度值，导致权重值急剧变化，使得学习过程不稳定。
缩放输入和输出变量是使用神经网络模型的关键步骤。
在实践中，在将输入数据呈现给网络之前，对其应用预处理变换几乎总是有利的。类似地，网络的输出经常被后处理以给出所需的输出值。
—第 296 页，用于模式识别的神经网络，1995。
数值数据缩放方法
使用 Sklearn 库可以实现标准化和规范化。
让我们依次仔细看看每一个。
数据标准化
规范化是对原始范围内的数据进行重新缩放，以便所有值都在 0 和 1 的新范围内。
规范化要求您知道或能够准确估计最小和最大可观察值。您可能能够从您的可用数据中估计这些值。
通过将所有值除以遇到的最大值或减去最小值并除以最大值和最小值之间的范围，属性通常被规范化为位于固定范围内(通常从 0 到 1)。
—第 61 页，数据挖掘:实用机器学习工具与技术，2016。
值标准化如下:
- y =(x–最小值)/(最大值–最小值)
其中最小值和最大值属于被归一化的值 x。
例如，对于一个数据集，我们可以猜测最小和最大可观察值为 30 和-10。然后，我们可以对任何值进行归一化，如 18.8，如下所示:
- y =(x–最小值)/(最大值–最小值)
- y =(18.8 –(-10))/(30 –(-10))
- y = 28.8 / 40
- y = 0.72
您可以看到，如果提供的 x 值超出了最小值和最大值的界限，则结果值将不会在 0 和 1 的范围内。您可以在进行预测之前检查这些观察值，并从数据集中删除它们，或者将它们限制在预定义的最大值或最小值。
您可以使用 Sklearn 对象最小最大缩放器来规范化数据集。
最小最大缩放器和其他缩放技术的良好实践用法如下:
- 使用可用的训练数据安装定标器。对于归一化，这意味着训练数据将用于估计最小和最大可观察值。这是通过调用 fit() 函数来实现的。
- 将量表应用于训练数据。这意味着您可以使用规范化的数据来训练您的模型。这是通过调用*变换()*函数来完成的。
- 将刻度应用于向前的数据。这意味着你可以在未来准备新的数据来做预测。
最小最大缩放器的默认比例是将变量重新缩放到范围[0，1]，尽管可以通过“特征 _ 范围参数指定首选比例，并指定一个元组，包括所有变量的最小值和最大值。
我们可以通过将两个变量转换为 0 到 1 的范围来演示这个类的用法，0 到 1 是规范化的默认范围。第一个变量的值介于约 4 和 100 之间，第二个变量的值介于约 0.1 和 0.001 之间。
下面列出了完整的示例。
# example of a normalization
from numpy import asarray
from sklearn.preprocessing import MinMaxScaler
# define data
data = asarray([[100, 0.001],
[8, 0.05],
[50, 0.005],
[88, 0.07],
[4, 0.1]])
print(data)
# define min max scaler
scaler = MinMaxScaler()
# transform data
scaled = scaler.fit_transform(data)
print(scaled)
运行该示例首先报告原始数据集，显示 2 列 4 行。这些值是用科学符号表示的，如果你不习惯，可能很难读懂。
接下来，定义定标器，使其适合整个数据集，然后用于创建数据集的转换版本，每个列独立地标准化。我们可以看到，每个列的最大原始值现在为值 1.0，每个列的最小值现在为值 0.0。
[[1.0e+02 1.0e-03]
[8.0e+00 5.0e-02]
[5.0e+01 5.0e-03]
[8.8e+01 7.0e-02]
[4.0e+00 1.0e-01]]
[[1\. 0\. ]
[0.04166667 0.49494949]
[0.47916667 0.04040404]
[0.875 0.6969697 ]
[0\. 1\. ]]
现在我们已经熟悉了标准化，让我们更仔细地看看标准化。
数据标准化
数据集标准化涉及重新调整值的分布，以便观察值的平均值为 0，标准偏差为 1。
这可以被认为是减去平均值或使数据居中。
像标准化一样，标准化可能是有用的，甚至在某些机器学习算法中，当您的数据具有不同比例的输入值时，标准化是必需的。
标准化假设你的观测值符合一个具有良好均值和标准差的高斯分布(钟形曲线)。如果没有达到这个期望，你仍然可以标准化你的数据，但是你可能得不到可靠的结果。
另一种[…]技术是计算属性值的统计平均值和标准偏差，从每个值中减去平均值，并将结果除以标准偏差。这个过程被称为标准化统计变量，产生一组平均值为零、标准差为一的值。
—第 61 页，数据挖掘:实用机器学习工具与技术，2016。
标准化要求你知道或能够准确估计可观察值的平均值和标准偏差。您可能能够从训练数据而不是整个数据集来估计这些值。
再次强调，变换所需的统计量(例如，平均值)是从训练集中估计的，并且被应用于所有数据集(例如，测试集或新样本)。
—第 124 页，特征工程与选择，2019。
从数据中减去平均值称为居中，而除以标准偏差称为缩放。因此，该方法有时被称为“中心缩放”。
最直接和常见的数据转换是对预测变量进行中心缩放。为了使预测变量居中，从所有值中减去平均预测值。居中的结果是，预测值的平均值为零。类似地，为了缩放数据，预测变量的每个值除以其标准偏差。缩放数据会强制这些值具有 1 的共同标准偏差。
—第 30 页，应用预测建模，2013 年。
值标准化如下:
- y =(x–平均值)/标准偏差
其中表示计算如下:
- 平均值=总和(x) /计数(x)
标准偏差计算如下:
- 标准偏差= sqrt(总和((x–mean)²)/计数(x))
我们可以推测平均值为 10.0，标准偏差约为 5.0。使用这些值，我们可以将第一个值 20.7 标准化如下:
- y =(x–平均值)/标准偏差
- y =(20.7–10)/5
- y = (10.7) / 5
- y = 2.14
数据集的均值和标准差估计值比最小值和最大值对新数据更稳健。
您可以使用 Sklearn 对象标准缩放器来标准化数据集。
我们可以通过将两个变量转换为上一节中定义的 0 到 1 的范围来演示这个类的用法。我们将使用缺省配置，它将对每一列中的值进行居中和缩放，例如完全标准化。
下面列出了完整的示例。
# example of a standardization
from numpy import asarray
from sklearn.preprocessing import StandardScaler
# define data
data = asarray([[100, 0.001],
[8, 0.05],
[50, 0.005],
[88, 0.07],
[4, 0.1]])
print(data)
# define standard scaler
scaler = StandardScaler()
# transform data
scaled = scaler.fit_transform(data)
print(scaled)
运行该示例首先报告原始数据集，像以前一样显示 2 列 4 行。
接下来，定义定标器，使其适合整个数据集，然后用于创建数据集的转换版本，每个列独立标准化。我们可以看到，如果存在，每一列的平均值被赋予 0.0 的值，并且这些值以 0.0 为中心，具有正值和负值。
[[1.0e+02 1.0e-03]
[8.0e+00 5.0e-02]
[5.0e+01 5.0e-03]
[8.8e+01 7.0e-02]
[4.0e+00 1.0e-01]]
[[ 1.26398112 -1.16389967]
[-1.06174414 0.12639634]
[ 0\. -1.05856939]
[ 0.96062565 0.65304778]
[-1.16286263 1.44302493]]
接下来，我们可以引入一个真实的数据集，作为建模的一部分，它为应用规范化和标准化转换提供了基础。
声纳数据集
声纳数据集是用于二进制分类的标准机器学习数据集。
它涉及 60 个实值输入和一个两类目标变量。数据集中有 208 个示例，类别相当均衡。
使用重复分层 10 倍交叉验证，基线分类算法可以达到约 53.4%的分类准确率。使用重复的分层 10 倍交叉验证，该数据集的最高表现约为 88%。
该数据集描述了岩石或模拟地雷的雷达回波。
您可以从这里了解有关数据集的更多信息:
不需要下载数据集；我们将从我们的工作示例中自动下载它。
首先，让我们加载并总结数据集。下面列出了完整的示例。
# load and summarize the sonar dataset
from pandas import read_csv
from pandas.plotting import scatter_matrix
from matplotlib import pyplot
# Load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv"
dataset = read_csv(url, header=None)
# summarize the shape of the dataset
print(dataset.shape)
# summarize each variable
print(dataset.describe())
# histograms of the variables
dataset.hist()
pyplot.show()
运行该示例首先总结加载数据集的形状。
这确认了 60 个输入变量、一个输出变量和 208 行数据。
提供了输入变量的统计摘要，显示值是数值，范围大约从 0 到 1。
(208, 61)
0 1 2 ... 57 58 59
count 208.000000 208.000000 208.000000 ... 208.000000 208.000000 208.000000
mean 0.029164 0.038437 0.043832 ... 0.007949 0.007941 0.006507
std 0.022991 0.032960 0.038428 ... 0.006470 0.006181 0.005031
min 0.001500 0.000600 0.001500 ... 0.000300 0.000100 0.000600
25% 0.013350 0.016450 0.018950 ... 0.003600 0.003675 0.003100
50% 0.022800 0.030800 0.034300 ... 0.005800 0.006400 0.005300
75% 0.035550 0.047950 0.057950 ... 0.010350 0.010325 0.008525
max 0.137100 0.233900 0.305900 ... 0.044000 0.036400 0.043900
[8 rows x 60 columns]
最后，为每个输入变量创建一个直方图。
如果我们忽略图中杂乱的东西，专注于直方图本身，我们可以看到许多变量都有一个偏斜的分布。
由于变量具有不同的最小值和最大值以及不同的数据分布，因此数据集为使用定标器变换提供了一个很好的候选对象。
声纳二进制类别数据集输入变量的直方图
接下来，让我们在原始数据集上拟合和评估一个机器学习模型。
我们将使用带有默认超参数的 k 近邻算法，并使用重复的分层 K 折交叉验证对其进行评估。下面列出了完整的示例。
# evaluate knn on the raw sonar dataset
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import LabelEncoder
from matplotlib import pyplot
# load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv"
dataset = read_csv(url, header=None)
data = dataset.values
# separate into input and output columns
X, y = data[:, :-1], data[:, -1]
# ensure inputs are floats and output is an integer label
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
# define and configure the model
model = KNeighborsClassifier()
# evaluate the model
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
# report model performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
运行该示例会评估原始声纳数据集上的 KNN 模型。
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
我们可以看到，该模型实现了大约 79.7%的平均分类准确率，表明它具有技巧性(优于 53.4%)，并且处于良好表现的球园区(88%)。
Accuracy: 0.797 (0.073)
接下来，让我们探索数据集的缩放变换。
最小最大缩放器变换
我们可以将最小最大缩放器直接应用到声纳数据集，对输入变量进行归一化。
我们将使用默认配置并将值缩放到 0 到 1 的范围。首先，用默认超参数定义一个最小最大缩放器实例。一旦定义，我们可以调用 fit_transform() 函数，并将其传递给我们的数据集，以创建数据集的转换版本。
...
# perform a robust scaler transform of the dataset
trans = MinMaxScaler()
data = trans.fit_transform(data)
让我们在声纳数据集上试试。
下面列出了创建声纳数据集的最小最大缩放器变换并绘制结果直方图的完整示例。
# visualize a minmax scaler transform of the sonar dataset
from pandas import read_csv
from pandas import DataFrame
from pandas.plotting import scatter_matrix
from sklearn.preprocessing import MinMaxScaler
from matplotlib import pyplot
# load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv"
dataset = read_csv(url, header=None)
# retrieve just the numeric input values
data = dataset.values[:, :-1]
# perform a robust scaler transform of the dataset
trans = MinMaxScaler()
data = trans.fit_transform(data)
# convert the array back to a dataframe
dataset = DataFrame(data)
# summarize
print(dataset.describe())
# histograms of the variables
dataset.hist()
pyplot.show()
运行该示例首先报告每个输入变量的摘要。
我们可以看到，分布已经调整，每个变量的最小值和最大值现在分别是清晰的 0.0 和 1.0。
0 1 2 ... 57 58 59
count 208.000000 208.000000 208.000000 ... 208.000000 208.000000 208.000000
mean 0.204011 0.162180 0.139068 ... 0.175035 0.216015 0.136425
std 0.169550 0.141277 0.126242 ... 0.148051 0.170286 0.116190
min 0.000000 0.000000 0.000000 ... 0.000000 0.000000 0.000000
25% 0.087389 0.067938 0.057326 ... 0.075515 0.098485 0.057737
50% 0.157080 0.129447 0.107753 ... 0.125858 0.173554 0.108545
75% 0.251106 0.202958 0.185447 ... 0.229977 0.281680 0.183025
max 1.000000 1.000000 1.000000 ... 1.000000 1.000000 1.000000
[8 rows x 60 columns]
创建了变量的直方图，尽管这些分布看起来与上一节中看到的原始分布没有太大不同。
声纳数据集最小最大缩放器变换输入变量的直方图
接下来，让我们评估与前面部分相同的 KNN 模型，但是在这种情况下，在数据集的最小最大缩放器变换上。
下面列出了完整的示例。
# evaluate knn on the sonar dataset with minmax scaler transform
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import MinMaxScaler
from sklearn.pipeline import Pipeline
from matplotlib import pyplot
# load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv"
dataset = read_csv(url, header=None)
data = dataset.values
# separate into input and output columns
X, y = data[:, :-1], data[:, -1]
# ensure inputs are floats and output is an integer label
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
# define the pipeline
trans = MinMaxScaler()
model = KNeighborsClassifier()
pipeline = Pipeline(steps=[('t', trans), ('m', model)])
# evaluate the pipeline
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
# report pipeline performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
运行该示例，我们可以看到，最小最大缩放器变换将表现从没有变换时的 79.7%提升到有变换时的 81.3%。
Accuracy: 0.813 (0.085)
接下来，让我们探索标准化输入变量的效果。
标准缩放器变换
我们可以将标准缩放器直接应用于声纳数据集，以标准化输入变量。
我们将使用默认配置和比例值减去平均值，使它们集中在 0.0，除以标准偏差，得到标准偏差 1.0。首先，用默认超参数定义一个标准缩放器实例。
一旦定义，我们就可以调用 fit_transform() 函数，并将其传递给我们的数据集，以创建数据集的转换版本。
...
# perform a robust scaler transform of the dataset
trans = StandardScaler()
data = trans.fit_transform(data)
让我们在声纳数据集上试试。
下面列出了创建声纳数据集的标准缩放器变换并绘制结果直方图的完整示例。
# visualize a standard scaler transform of the sonar dataset
from pandas import read_csv
from pandas import DataFrame
from pandas.plotting import scatter_matrix
from sklearn.preprocessing import StandardScaler
from matplotlib import pyplot
# load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv"
dataset = read_csv(url, header=None)
# retrieve just the numeric input values
data = dataset.values[:, :-1]
# perform a robust scaler transform of the dataset
trans = StandardScaler()
data = trans.fit_transform(data)
# convert the array back to a dataframe
dataset = DataFrame(data)
# summarize
print(dataset.describe())
# histograms of the variables
dataset.hist()
pyplot.show()
运行该示例首先报告每个输入变量的摘要。
我们可以看到，分布已经被调整，平均值是一个非常小的接近零的数字，每个变量的标准偏差非常接近 1.0。
0 1 ... 58 59
count 2.080000e+02 2.080000e+02 ... 2.080000e+02 2.080000e+02
mean -4.190024e-17 1.663333e-16 ... 1.283695e-16 3.149190e-17
std 1.002413e+00 1.002413e+00 ... 1.002413e+00 1.002413e+00
min -1.206158e+00 -1.150725e+00 ... -1.271603e+00 -1.176985e+00
25% -6.894939e-01 -6.686781e-01 ... -6.918580e-01 -6.788714e-01
50% -2.774703e-01 -2.322506e-01 ... -2.499546e-01 -2.405314e-01
75% 2.784345e-01 2.893335e-01 ... 3.865486e-01 4.020352e-01
max 4.706053e+00 5.944643e+00 ... 4.615037e+00 7.450343e+00
[8 rows x 60 columns]
创建了变量的直方图，尽管除了它们在 x 轴上的比例之外，分布看起来与上一节中看到的原始分布没有太大不同。
声纳数据集的标准标度变换输入变量的直方图
接下来，让我们评估与上一节相同的 KNN 模型，但在本例中，是基于数据集的标准缩放器变换。
下面列出了完整的示例。
# evaluate knn on the sonar dataset with standard scaler transform
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from matplotlib import pyplot
# load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv"
dataset = read_csv(url, header=None)
data = dataset.values
# separate into input and output columns
X, y = data[:, :-1], data[:, -1]
# ensure inputs are floats and output is an integer label
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
# define the pipeline
trans = StandardScaler()
model = KNeighborsClassifier()
pipeline = Pipeline(steps=[('t', trans), ('m', model)])
# evaluate the pipeline
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
# report pipeline performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
运行该示例，我们可以看到标准缩放器变换将表现从无变换时的 79.7%提升到有变换时的 81.0%，尽管比使用最小最大缩放器的结果略低。
Accuracy: 0.810 (0.080)
常见问题
本节列出了缩放数字数据时的一些常见问题和答案。
问:我应该规范化还是标准化？
输入变量是否需要缩放取决于您的问题和每个变量的具体情况。
您可能有一系列数量作为输入，例如价格或温度。
如果数量的分布是正态的，那么就应该标准化，否则，数据就应该标准化。如果数量值的范围很大(10s、100s 等)，则适用。)或小(0.01，0.0001)。
如果数量值很小(接近 0-1)并且分布是有限的(例如，标准偏差接近 1)，那么也许您可以不按比例缩放数据。
这些操作通常用于提高某些计算的数值稳定性。一些模型[…]受益于共同尺度上的预测器。
—第 30-31 页，应用预测建模，2013 年。
预测建模问题可能很复杂，并且可能不清楚如何最好地缩放输入数据。
如果有疑问，标准化输入序列。如果您有资源，探索使用原始数据、标准化数据和规范化数据建模，并查看结果模型的表现是否有有益的差异。
如果输入变量是线性组合的，如在 MLP[多层感知器]中，那么很少严格需要标准化输入，至少在理论上是这样。[……]然而，有各种各样的实际原因，为什么标准化输入可以使训练更快，并减少陷入局部最优的机会。
— 我应该对数据进行规范化/标准化/重新缩放吗？神经网络常见问题
问:我应该先标准化然后再标准化吗？
标准化可以给出以零为中心的正值和负值。
可能需要在数据标准化后对其进行标准化。
这可能是一个好主意，因为您混合了标准化和规范化变量，并且希望所有输入变量都具有与给定算法(例如计算距离度量的算法)相同的最小值和最大值。
问:但是哪一个最好？
这是不可知的。
根据每次转换准备的数据评估模型，并使用转换或转换组合，为模型上的数据集带来最佳表现。
问:我如何处理越界值？
您可以通过计算训练数据的最小值和最大值来标准化数据。
稍后，您可能会有值分别小于或大于最小值或最大值的新数据。
处理这种情况的一种简单方法是检查这种超出界限的值，并在缩放之前将其值更改为已知的最小值或最大值。或者，您可能希望基于领域知识手动估计标准化中使用的最小值和最大值。
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
教程
- 如何使用数据缩放提高深度学习模型的稳定性和表现
- 使用 Sklearn 重新缩放 Python 中的机器学习数据
- 4 时间序列预测的常用机器学习数据转换
- 如何在 Python 中扩展长短期记忆网络的数据
- 如何在 Python 中对时间序列数据进行规范化和标准化
书
- 用于模式识别的神经网络，1995。
- 特征工程与选择，2019。
- 数据挖掘:实用机器学习工具与技术，2016。
- 应用预测建模，2013。
蜜蜂
文章
- 我是否应该对数据进行规范化/标准化/重新缩放？神经网络常见问题
摘要
在本教程中，您发现了如何使用 scaler 变换来标准化和规范化用于分类和回归的数字输入变量。
具体来说，您了解到:
- 当使用许多机器学习算法时，数据缩放是推荐的预处理步骤。
- 数据缩放可以通过规范化或标准化实值输入和输出变量来实现。
- 如何应用标准化和规范化提高预测建模算法的表现？
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
