Machine-Learning-Mastery-数据准备教程-二-

Machine Learning Mastery 数据准备教程（二）

原文：Machine Learning Mastery

协议：CC BY-NC-SA 4.0

如何将列转换器用于数据准备

原文：machinelearningmastery.com/columntrans…

最后更新于 2020 年 12 月 31 日

在拟合机器学习模型之前，您必须使用数据转换来准备原始数据。

这是确保您最好地将预测建模问题的结构暴露给学习算法所必需的。

当所有输入变量都是相同类型时，应用数据转换(如缩放或编码分类变量)非常简单。当您有一个混合类型的数据集，并且您想要有选择地将数据转换应用于一些(但不是全部)输入要素时，这可能会很有挑战性。

值得庆幸的是，Sklearn Python 机器学习库提供了 ColumnTransformer ，允许您选择性地将数据转换应用到数据集中的不同列。

在本教程中，您将了解如何使用 ColumnTransformer 有选择地将数据转换应用于具有混合数据类型的数据集中的列。

完成本教程后，您将知道:

• 对具有混合数据类型的数据集使用数据转换的挑战。
• 如何定义、调整和使用 ColumnTransformer 选择性地将数据转换应用于列。
• 如何处理具有混合数据类型的真实数据集，并使用 ColumnTransformer 对分类和数字数据列应用不同的转换。

用我的新书机器学习的数据准备启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

• 2020 年 12 月更新:修正了 API 示例中的小错别字。

使用 Python 中的数值和类别数据的 ColumnTransformer】图片由 Kari 提供，保留部分权利。

教程概述

本教程分为三个部分；它们是:

1. 转换不同数据类型的挑战
2. 如何使用列转换器
3. 鲍鱼回归数据集的数据准备

转换不同数据类型的挑战

建模前准备数据很重要。

这可能涉及替换丢失的值、缩放数值和一个热编码类别数据。

可以使用 Sklearn 库执行数据转换；例如，simplementor类可以用来替换缺失的值， MinMaxScaler 类可以用来缩放数值， OneHotEncoder 可以用来编码分类变量。

例如:

...
# prepare transform
scaler = MinMaxScaler()
# fit transform on training data
scaler.fit(train_X)
# transform training data
train_X = scaler.transform(train_X)

不同变换的序列也可以使用管道链接在一起，例如输入缺失值，然后缩放数值。

例如:

...
# define pipeline
pipeline = Pipeline(steps=[('i', SimpleImputer(strategy='median')), ('s', MinMaxScaler())])
# transform training data
train_X = pipeline.fit_transform(train_X)

希望对输入数据中的不同列执行不同的数据准备技术是非常常见的。

例如，您可能希望用一个中值来估计缺失的数值，然后缩放这些值，并使用最频繁的值和一个热编码类别来估计缺失的分类值。

传统上，这将需要您分离数值和类别数据，然后在将列组合在一起之前，手动对这些要素组应用转换，以便拟合和评估模型。

现在，您可以使用 ColumnTransformer 为您执行此操作。

如何使用列转换器

ColumnTransformer 是 Sklearn Python 机器学习库中的一个类，允许您选择性地应用数据准备转换。

例如，它允许您将特定的转换或转换序列仅应用于数字列，将单独的转换序列仅应用于分类列。

要使用 ColumnTransformer，必须指定一个转换器列表。

每个转换器都是一个三元组，它定义了转换器的名称、要应用的转换以及要应用的列索引。例如:

• (名称、对象、列)

例如，下面的 ColumnTransformer 对第 0 列和第 1 列应用了一个 OneHotEncoder。

...
transformer = ColumnTransformer(transformers=[('cat', OneHotEncoder(), [0, 1])])

以下示例对数值列 0 和 1 应用中值输入的简单估计器，对分类列 2 和 3 应用最频繁输入的简单估计器。

...
t = [('num', SimpleImputer(strategy='median'), [0, 1]), ('cat', SimpleImputer(strategy='most_frequent'), [2, 3])]
transformer = ColumnTransformer(transformers=t)

默认情况下，任何未在“变压器列表中指定的列都会从数据集中删除；这可以通过设置“余数参数来更改。

设置*余数=“通过”*将意味着所有未在“变压器列表中指定的列都将在没有转换的情况下通过，而不是被删除。

例如，如果第 0 列和第 1 列是数字的，第 2 列和第 3 列是分类的，并且我们只想转换类别数据并不变地通过数字列，那么我们可以如下定义 ColumnTransformer:

...
transformer = ColumnTransformer(transformers=[('cat', OneHotEncoder(), [2, 3])], remainder='passthrough')

一旦定义了转换器，就可以使用它来转换数据集。

例如:

...
transformer = ColumnTransformer(transformers=[('cat', OneHotEncoder(), [0, 1])])
# transform training data
train_X = transformer.fit_transform(train_X)

ColumnTransformer 也可以在管道中使用，以便在对转换后的数据拟合模型之前，有选择地准备数据集的列。

这是最有可能的用例，因为它确保在拟合模型和进行预测时(例如，通过交叉验证在测试数据集上评估模型或在未来对新数据进行预测时)对原始数据自动执行转换。

例如:

...
# define model
model = LogisticRegression()
# define transform
transformer = ColumnTransformer(transformers=[('cat', OneHotEncoder(), [0, 1])])
# define pipeline
pipeline = Pipeline(steps=[('t', transformer), ('m',model)])
# fit the pipeline on the transformed data
pipeline.fit(train_X, train_y)
# make predictions
yhat = pipeline.predict(test_X)

现在我们已经熟悉了如何配置和使用 ColumnTransformer，让我们来看一个工作示例。

鲍鱼回归数据集的数据准备

鲍鱼数据集是一个标准的机器学习问题，包括在给定鲍鱼测量值的情况下预测鲍鱼的年龄。

您可以下载数据集并在此了解更多信息:

• 下载鲍鱼数据集(鲍鱼. csv)
• 了解更多鲍鱼数据集(鲍鱼. name)

数据集有 4，177 个示例，8 个输入变量，目标变量是一个整数。

一个简单的模型可以通过预测平均值达到大约 2.363(标准 0.092)的平均绝对误差(MAE)，通过 10 倍交叉验证进行评估。

我们可以用支持向量机模型( SVR )将其建模为回归预测建模问题。

查看数据，您可以看到前几行如下:

M,0.455,0.365,0.095,0.514,0.2245,0.101,0.15,15
M,0.35,0.265,0.09,0.2255,0.0995,0.0485,0.07,7
F,0.53,0.42,0.135,0.677,0.2565,0.1415,0.21,9
M,0.44,0.365,0.125,0.516,0.2155,0.114,0.155,10
I,0.33,0.255,0.08,0.205,0.0895,0.0395,0.055,7
...

我们可以看到第一列是分类的，其余的列是数字的。

我们可能希望对第一列进行热编码，并对剩余的数字列进行规范化，这可以使用 ColumnTransformer 来实现。

首先，我们需要加载数据集。我们可以使用 read_csv() Pandas 函数直接从 URL 加载数据集，然后将数据拆分为两个数据帧:一个用于输入，一个用于输出。

下面列出了加载数据集的完整示例。

# load the dataset
from pandas import read_csv
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/abalone.csv'
dataframe = read_csv(url, header=None)
# split into inputs and outputs
last_ix = len(dataframe.columns) - 1
X, y = dataframe.drop(last_ix, axis=1), dataframe[last_ix]
print(X.shape, y.shape)

注意:如果在从 URL 加载数据集时遇到问题，可以下载名为“鲍鱼. csv 的 CSV 文件，并将其放在与您的 Python 文件相同的目录中，并将调用更改为 read_csv() ，如下所示:

...
dataframe = read_csv('abalone.csv', header=None)

运行该示例，我们可以看到数据集被正确加载，并被分成八个输入列和一个目标列。

(4177, 8) (4177,)

接下来，我们可以使用*select _ dt types()*函数来选择匹配不同数据类型的列索引。

我们感兴趣的是熊猫中标记为“ float64 或“ int64 的数字列列表，以及熊猫中标记为“ object 或“ bool 类型的分类列列表。

...
# determine categorical and numerical features
numerical_ix = X.select_dtypes(include=['int64', 'float64']).columns
categorical_ix = X.select_dtypes(include=['object', 'bool']).columns

然后，我们可以在 ColumnTransformer 中使用这些列表对分类变量进行热编码，这应该只是第一列。

我们还可以使用数字列列表来规范化剩余的数据。

...
# define the data preparation for the columns
t = [('cat', OneHotEncoder(), categorical_ix), ('num', MinMaxScaler(), numerical_ix)]
col_transform = ColumnTransformer(transformers=t)

接下来，我们可以定义我们的 SVR 模型，并定义一个管道，该管道首先使用 ColumnTransformer，然后在准备好的数据集上拟合模型。

...
# define the model
model = SVR(kernel='rbf',gamma='scale',C=100)
# define the data preparation and modeling pipeline
pipeline = Pipeline(steps=[('prep',col_transform), ('m', model)])

最后，我们可以使用 10 倍交叉验证来评估模型，并计算管道的所有 10 次评估的平均绝对误差。

...
# define the model cross-validation configuration
cv = KFold(n_splits=10, shuffle=True, random_state=1)
# evaluate the pipeline using cross validation and calculate MAE
scores = cross_val_score(pipeline, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1)
# convert MAE scores to positive values
scores = absolute(scores)
# summarize the model performance
print('MAE: %.3f (%.3f)' % (mean(scores), std(scores)))

将这些结合在一起，完整的示例如下所示。

# example of using the ColumnTransformer for the Abalone dataset
from numpy import mean
from numpy import std
from numpy import absolute
from pandas import read_csv
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import MinMaxScaler
from sklearn.svm import SVR

# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/abalone.csv'
dataframe = read_csv(url, header=None)
# split into inputs and outputs
last_ix = len(dataframe.columns) - 1
X, y = dataframe.drop(last_ix, axis=1), dataframe[last_ix]
print(X.shape, y.shape)
# determine categorical and numerical features
numerical_ix = X.select_dtypes(include=['int64', 'float64']).columns
categorical_ix = X.select_dtypes(include=['object', 'bool']).columns
# define the data preparation for the columns
t = [('cat', OneHotEncoder(), categorical_ix), ('num', MinMaxScaler(), numerical_ix)]
col_transform = ColumnTransformer(transformers=t)
# define the model
model = SVR(kernel='rbf',gamma='scale',C=100)
# define the data preparation and modeling pipeline
pipeline = Pipeline(steps=[('prep',col_transform), ('m', model)])
# define the model cross-validation configuration
cv = KFold(n_splits=10, shuffle=True, random_state=1)
# evaluate the pipeline using cross validation and calculate MAE
scores = cross_val_score(pipeline, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1)
# convert MAE scores to positive values
scores = absolute(scores)
# summarize the model performance
print('MAE: %.3f (%.3f)' % (mean(scores), std(scores)))

运行该示例使用 10 倍交叉验证来评估数据准备管道。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们实现了大约 1.4 的平均 MAE，这比基线分数 2.3 要好。

(4177, 8) (4177,)
MAE: 1.465 (0.047)

现在，您有了一个模板，可以在具有混合数据类型的数据集中使用 ColumnTransformer，您可以在将来的项目中使用和调整该模板。

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

应用程序接口

• 硬化。化合物。ColumnTransformer API 。
• 熊猫. read_csv API 。
• 巩理。计费。简单计费 API 。
• 硬化。预处理。OneHotEncoder API 。
• 硬化。预处理。MinMaxScaler API
• sklearn . pipeline . pipeline API。

摘要

在本教程中，您发现了如何使用 ColumnTransformer 有选择地将数据转换应用于具有混合数据类型的数据集中的列。

具体来说，您了解到:

• 对具有混合数据类型的数据集使用数据转换的挑战。
• 如何定义、调整和使用 ColumnTransformer 选择性地将数据转换应用于列。
• 如何处理具有混合数据类型的真实数据集，并使用 ColumnTransformer 对分类和数字数据列应用不同的转换。

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。

如何为 Sklearn 创建自定义数据转换

原文：machinelearningmastery.com/create-cust…

最后更新于 2020 年 7 月 19 日

用于机器学习的 Sklearn Python 库提供了一套数据转换，用于改变输入数据的规模和分布，以及删除输入特征(列)。

有许多简单的数据清理操作，如移除异常值和移除观察值很少的列，这些操作通常是手动对数据执行的，需要自定义代码。

Sklearn 库提供了一种以标准方式包装这些自定义数据转换的方法，因此它们可以像任何其他转换一样使用，无论是直接用于数据还是作为建模管道的一部分。

在本教程中，您将发现如何为 Sklearn 定义和使用自定义数据转换。

完成本教程后，您将知道:

• 可以使用 FunctionTransformer 类为 Sklearn 创建自定义数据转换。
• 如何开发和应用自定义转换来移除几乎没有唯一值的列。
• 如何开发和应用自定义转换来替换每列的异常值？

用我的新书机器学习的数据准备启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

如何为 Scikit 创建自定义数据转换-了解贝瑞特·沃特金拍摄的 照片，保留部分权利。

教程概述

本教程分为四个部分；它们是:

1. Sklearn 中的自定义数据转换
2. 漏油数据集
3. 移除列的自定义转换
4. 替换异常值的自定义转换

Sklearn 中的自定义数据转换

数据准备是指以某种方式改变原始数据，使其更适合用机器学习算法进行预测建模。

Sklearn Python 机器学习库直接提供了许多不同的数据准备技术，例如缩放数值输入变量和改变变量概率分布的技术。

这些变换可以拟合，然后应用于数据集或用作预测建模管道的一部分，从而允许在使用数据采样技术(如 k 倍交叉验证)评估模型表现时，正确应用一系列变换，而不会出现数据泄漏。

尽管 Sklearn 中可用的数据准备技术非常广泛，但可能还需要额外的数据准备步骤。

通常，这些额外的步骤是在建模之前手动执行的，并且需要编写自定义代码。风险在于这些数据准备步骤的执行可能不一致。

解决方案是在 Sklearn 中使用 FunctionTransformer 类创建自定义数据转换。

此类允许您指定一个被调用来转换数据的函数。您可以定义函数并执行任何有效的更改，例如更改值或删除数据列(而不是删除行)。

该类可以像 Sklearn 中的任何其他数据转换一样使用，例如直接转换数据，或者在建模管道中使用。

问题是转换是无状态的，也就是说没有状态可以保持。

这意味着转换不能用于计算训练数据集中的统计数据，这些统计数据随后用于转换训练和测试数据集。

除了自定义缩放操作之外，这对于标准的数据清理操作也很有帮助，例如识别和移除几乎没有唯一值的列，以及识别和移除相对异常值。

我们将探索这两种情况，但是首先，让我们定义一个数据集，我们可以将其用作探索的基础。

漏油数据集

所谓的“漏油”数据集是标准的机器学习数据集。

这项任务包括预测一块区域是否有石油泄漏，例如非法或意外倾倒在海洋中的石油，给定一个描述卫星图像一块区域内容的向量。

有 937 例。每个案例由 48 个数值计算机视觉衍生特征、一个补丁号和一个类别标签组成。

正常情况下，没有漏油被指定为 0 级标签，而漏油被指定为 1 级标签。无漏油 896 例，漏油 41 例。

您可以在这里访问整个数据集:

• 漏油数据集(漏油 csv)
• 漏油数据集描述(漏油名称)

查看文件的内容。

文件的前几行应该如下所示:

1,2558,1506.09,456.63,90,6395000,40.88,7.89,29780,0.19,214.7,0.21,0.26,0.49,0.1,0.4,99.59,32.19,1.84,0.16,0.2,87.65,0,0.47,132.78,-0.01,3.78,0.22,3.2,-3.71,-0.18,2.19,0,2.19,310,16110,0,138.68,89,69,2850,1000,763.16,135.46,3.73,0,33243.19,65.74,7.95,1
2,22325,79.11,841.03,180,55812500,51.11,1.21,61900,0.02,901.7,0.02,0.03,0.11,0.01,0.11,6058.23,4061.15,2.3,0.02,0.02,87.65,0,0.58,132.78,-0.01,3.78,0.84,7.09,-2.21,0,0,0,0,704,40140,0,68.65,89,69,5750,11500,9593.48,1648.8,0.6,0,51572.04,65.73,6.26,0
3,115,1449.85,608.43,88,287500,40.42,7.34,3340,0.18,86.1,0.21,0.32,0.5,0.17,0.34,71.2,16.73,1.82,0.19,0.29,87.65,0,0.46,132.78,-0.01,3.78,0.7,4.79,-3.36,-0.23,1.95,0,1.95,29,1530,0.01,38.8,89,69,1400,250,150,45.13,9.33,1,31692.84,65.81,7.84,1
4,1201,1562.53,295.65,66,3002500,42.4,7.97,18030,0.19,166.5,0.21,0.26,0.48,0.1,0.38,120.22,33.47,1.91,0.16,0.21,87.65,0,0.48,132.78,-0.01,3.78,0.84,6.78,-3.54,-0.33,2.2,0,2.2,183,10080,0,108.27,89,69,6041.52,761.58,453.21,144.97,13.33,1,37696.21,65.67,8.07,1
5,312,950.27,440.86,37,780000,41.43,7.03,3350,0.17,232.8,0.15,0.19,0.35,0.09,0.26,289.19,48.68,1.86,0.13,0.16,87.65,0,0.47,132.78,-0.01,3.78,0.02,2.28,-3.44,-0.44,2.19,0,2.19,45,2340,0,14.39,89,69,1320.04,710.63,512.54,109.16,2.58,0,29038.17,65.66,7.35,0
...

我们可以看到第一列包含补丁号的整数。我们还可以看到，计算机视觉导出的特征是实值的，具有不同的比例，例如第二列中的千分之一和其他列中的分数。

该数据集包含具有极少唯一值的列和具有异常值的列，这为数据清理提供了良好的基础。

下面的示例下载数据集并将其加载为 numPy 数组，并总结了行数和列数。

# load the oil dataset
from pandas import read_csv
# define the location of the dataset
path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/oil-spill.csv'
# load the dataset
df = read_csv(path, header=None)
# split data into inputs and outputs
data = df.values
X = data[:, :-1]
y = data[:, -1]
print(X.shape, y.shape)

运行该示例将加载数据集并确认预期的行数和列数。

(937, 49) (937,)

现在我们有了一个数据集，可以用作数据转换的基础，让我们看看如何使用 FunctionTransformer 类定义一些自定义的数据清理转换。

移除列的自定义转换

几乎没有唯一值的列可能对预测目标值没有任何帮助。

这并不是绝对正确的，但是您应该在删除了这种类型的列的数据集上测试模型拟合的表现，这是足够正确的。

这是一种类型的数据清理，Sklearn 中提供了一种称为变量阈值的数据转换，试图利用每一列的方差来解决这个问题。

另一种方法是移除具有少于指定数量的唯一值(如 1)的列。

我们可以开发一个应用这种转换的函数，并使用最小数量的唯一值作为可配置的默认参数。我们还将添加一些调试，以确认它是否如我们预期的那样工作。

首先，可以计算每列的唯一值的数量。可以识别等于或小于唯一值最小数量的十列。最后，可以从数据集中删除那些已识别的列。

下面的 cust_transform() 函数实现了这一点。

# remove columns with few unique values
def cust_transform(X, min_values=1, verbose=True):
	# get number of unique values for each column
	counts = [len(unique(X[:, i])) for i in range(X.shape[1])]
	if verbose:
		print('Unique Values: %s' % counts)
	# select columns to delete
	to_del = [i for i,v in enumerate(counts) if v <= min_values]
	if verbose:
		print('Deleting: %s' % to_del)
	if len(to_del) is 0:
		return X
	# select all but the columns that are being removed
	ix = [i for i in range(X.shape[1]) if i not in to_del]
	result = X[:, ix]
	return result

然后我们可以在 FunctionTransformer 中使用这个函数。

这种转换的一个限制是，它根据提供的数据选择要删除的列。这意味着如果一个训练和测试数据集相差很大，那么就有可能从每一个中移除不同的列，使得模型评估具有挑战性(不稳定！？).因此，最好将唯一值的最小数量保持较小，例如 1。

我们可以在漏油数据集上使用这种转换。下面列出了完整的示例。

# custom data transform for removing columns with few unique values
from numpy import unique
from pandas import read_csv
from sklearn.preprocessing import FunctionTransformer
from sklearn.preprocessing import LabelEncoder

# load a dataset
def load_dataset(path):
	# load the dataset
	df = read_csv(path, header=None)
	data = df.values
	# split data into inputs and outputs
	X, y = data[:, :-1], data[:, -1]
	# minimally prepare dataset
	X = X.astype('float')
	y = LabelEncoder().fit_transform(y.astype('str'))
	return X, y

# remove columns with few unique values
def cust_transform(X, min_values=1, verbose=True):
	# get number of unique values for each column
	counts = [len(unique(X[:, i])) for i in range(X.shape[1])]
	if verbose:
		print('Unique Values: %s' % counts)
	# select columns to delete
	to_del = [i for i,v in enumerate(counts) if v <= min_values]
	if verbose:
		print('Deleting: %s' % to_del)
	if len(to_del) is 0:
		return X
	# select all but the columns that are being removed
	ix = [i for i in range(X.shape[1]) if i not in to_del]
	result = X[:, ix]
	return result

# define the location of the dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/oil-spill.csv'
# load the dataset
X, y = load_dataset(url)
print(X.shape, y.shape)
# define the transformer
trans = FunctionTransformer(cust_transform)
# apply the transform
X = trans.fit_transform(X)
# summarize new shape
print(X.shape)

运行该示例首先报告原始数据集中的行数和列数。

接下来，将打印一个列表，显示数据集中每列观察到的唯一值的数量。我们可以看到许多列只有很少的唯一值。

然后识别并报告具有一个(或更少)唯一值的列。在这种情况下，列索引为 22。此列将从数据集中删除。

最后，报告转换后数据集的形状，显示 48 列而不是 49 列，确认具有单个唯一值的列已被删除。

(937, 49) (937,)
Unique Values: [238, 297, 927, 933, 179, 375, 820, 618, 561, 57, 577, 59, 73, 107, 53, 91, 893, 810, 170, 53, 68, 9, 1, 92, 9, 8, 9, 308, 447, 392, 107, 42, 4, 45, 141, 110, 3, 758, 9, 9, 388, 220, 644, 649, 499, 2, 937, 169, 286]
Deleting: [22]
(937, 48)

您可以探索这种转换的许多扩展，例如:

• 确保它仅适用于数值输入变量。
• 尝试不同的最小唯一值数。
• 使用百分比而不是唯一值的绝对值。

如果您探索这些扩展中的任何一个，请在下面的评论中告诉我。

接下来，让我们看一下替换数据集中的值的转换。

替换异常值的自定义转换

异常值是与其他观测值不同或不一样的观测值。

如果我们一次只考虑一个变量，那么离群值将是远离质心(其余值)的值，这意味着它很少或被观察到的概率很低。

对于常见的概率分布，有识别异常值的标准方法。对于高斯数据，我们可以将异常值识别为偏离平均值三个或更多标准差的观测值。

对于具有许多输入变量的数据，这可能是识别异常值的理想方法，也可能不是，但在某些情况下可能是有效的。

我们可以通过这种方式识别异常值，并用修正值(如平均值)替换它们的值。

每一列被认为是一次一个，并计算平均和标准偏差统计。使用这些统计数据，定义了“正常”值的上下限，然后可以识别所有超出这些界限的值。如果识别出一个或多个异常值，则用已经计算的平均值替换它们的值。

下面的 cust_transform() 函数将其实现为应用于数据集的函数，在这里我们参数化平均值的标准偏差数以及是否显示调试信息。

# replace outliers
def cust_transform(X, n_stdev=3, verbose=True):
	# copy the array
	result = X.copy()
	# enumerate each column
	for i in range(result.shape[1]):
		# retrieve values for column
		col = X[:, i]
		# calculate statistics
		mu, sigma = mean(col), std(col)
		# define bounds
		lower, upper = mu-(sigma*n_stdev), mu+(sigma*n_stdev)
		# select indexes that are out of bounds
		ix = where(logical_or(col < lower, col > upper))[0]
		if verbose and len(ix) > 0:
			print('>col=%d, outliers=%d' % (i, len(ix)))
		# replace values
		result[ix, i] = mu
	return result

然后我们可以在 FunctionTransformer 中使用这个函数。

异常值检测的方法假设一个高斯概率分布并独立适用于每个变量，两者都是强假设。

此实现的另一个限制是，平均值和标准偏差统计是在提供的数据集上计算的，这意味着异常值的定义及其替换值都是相对于数据集而言的。这意味着，如果在训练集和测试集上使用变换，可以使用不同的异常值定义和不同的替换值。

我们可以在漏油数据集上使用这种转换。下面列出了完整的示例。

# custom data transform for replacing outliers
from numpy import mean
from numpy import std
from numpy import where
from numpy import logical_or
from pandas import read_csv
from sklearn.preprocessing import FunctionTransformer
from sklearn.preprocessing import LabelEncoder

# load a dataset
def load_dataset(path):
	# load the dataset
	df = read_csv(path, header=None)
	data = df.values
	# split data into inputs and outputs
	X, y = data[:, :-1], data[:, -1]
	# minimally prepare dataset
	X = X.astype('float')
	y = LabelEncoder().fit_transform(y.astype('str'))
	return X, y

# replace outliers
def cust_transform(X, n_stdev=3, verbose=True):
	# copy the array
	result = X.copy()
	# enumerate each column
	for i in range(result.shape[1]):
		# retrieve values for column
		col = X[:, i]
		# calculate statistics
		mu, sigma = mean(col), std(col)
		# define bounds
		lower, upper = mu-(sigma*n_stdev), mu+(sigma*n_stdev)
		# select indexes that are out of bounds
		ix = where(logical_or(col < lower, col > upper))[0]
		if verbose and len(ix) > 0:
			print('>col=%d, outliers=%d' % (i, len(ix)))
		# replace values
		result[ix, i] = mu
	return result

# define the location of the dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/oil-spill.csv'
# load the dataset
X, y = load_dataset(url)
print(X.shape, y.shape)
# define the transformer
trans = FunctionTransformer(cust_transform)
# apply the transform
X = trans.fit_transform(X)
# summarize new shape
print(X.shape)

运行该示例首先报告任何更改之前数据集的形状。

接下来，计算每列的异常值数量，并且在输出中只报告那些具有一个或多个异常值的列。我们可以看到数据集中总共有 32 列有一个或多个异常值。

然后移除异常值，并报告结果数据集的形状，确认行数或列数没有变化。

(937, 49) (937,)
>col=0, outliers=10
>col=1, outliers=8
>col=3, outliers=8
>col=5, outliers=7
>col=6, outliers=1
>col=7, outliers=12
>col=8, outliers=15
>col=9, outliers=14
>col=10, outliers=19
>col=11, outliers=17
>col=12, outliers=22
>col=13, outliers=2
>col=14, outliers=16
>col=15, outliers=8
>col=16, outliers=8
>col=17, outliers=6
>col=19, outliers=12
>col=20, outliers=20
>col=27, outliers=14
>col=28, outliers=18
>col=29, outliers=2
>col=30, outliers=13
>col=32, outliers=3
>col=34, outliers=14
>col=35, outliers=15
>col=37, outliers=13
>col=40, outliers=18
>col=41, outliers=13
>col=42, outliers=12
>col=43, outliers=12
>col=44, outliers=19
>col=46, outliers=21
(937, 49)

您可以探索这种转换的许多扩展，例如:

• 确保它仅适用于数值输入变量。
• 用与平均值不同数量的标准偏差进行实验，例如 2 或 4。
• 使用不同的异常值定义，如 IQR 或模型。

如果您探索这些扩展中的任何一个，请在下面的评论中告诉我。

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

相关教程

• 如何去除机器学习的异常值
• 如何用 Python 进行机器学习的数据清洗

蜜蜂

• 定制变压器，sci kit-学习用户指南。
• sklearn . preferences . function transformer API。

摘要

在本教程中，您发现了如何为 Sklearn 定义和使用自定义数据转换。

具体来说，您了解到:

• 可以使用 FunctionTransformer 类为 Sklearn 创建自定义数据转换。
• 如何开发和应用自定义转换来移除几乎没有唯一值的列。
• 如何开发和应用自定义转换来替换每列的异常值？

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。

机器学习的数据准备（7 天迷你课程）

原文：machinelearningmastery.com/data-prepar…

最后更新于 2020 年 6 月 30 日

机器学习速成班的数据准备。

用 Python 7 天搞定数据准备。

数据准备包括将原始数据转换成更适合建模的形式。

准备数据可能是预测建模项目中最重要的部分，也是最耗时的部分，尽管它似乎是讨论最少的部分。相反，重点是机器学习算法，其使用和参数化已经变得非常常规。

实际的数据准备需要数据清理、特征选择、数据转换、降维等知识。

在本速成课程中，您将发现如何在七天内开始并自信地用 Python 为预测建模项目准备数据。

这是一个又大又重要的岗位。你可能想把它做成书签。

用我的新书机器学习的数据准备启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

• 2020 年 6 月更新:更改了马绞痛数据集的目标。

机器学习数据准备(7 天迷你课程) 图片由克里斯蒂安·科林斯提供，保留部分权利。

这个速成班是给谁的？

在我们开始之前，让我们确保你在正确的地方。

本课程面向可能了解一些应用机器学习的开发人员。也许你知道如何用流行的工具来从头到尾解决一个预测建模问题，或者至少是大部分的主要步骤。

本课程中的课程假设了您的一些情况，例如:

• 你对编程的基本 Python 很熟悉。
• 您可能知道一些用于数组操作的基本 NumPy。
• 你可能知道一些基本的 sci kit-学习建模。

你不需要:

• 数学天才！
• 机器学习专家！

这门速成课程将把你从一个懂得一点机器学习的开发人员带到一个能够有效和胜任地为预测建模项目准备数据的开发人员。

注意:本速成课程假设您有一个至少安装了 NumPy 的工作 Python 3 SciPy 环境。如果您需要环境方面的帮助，可以遵循这里的逐步教程:

• 如何用 Anaconda 设置机器学习的 Python 环境

速成班概述

这门速成课分为七节课。

您可以每天完成一节课(推荐)或一天内完成所有课程(硬核)。这真的取决于你有多少时间和你的热情程度。

下面是用 Python 进行数据准备的七个经验教训:

• 第 01 课:数据准备的重要性
• 第 02 课:用插补填充缺失值
• 第 03 课:使用 RFE 选择要素
• 第 04 课:通过标准化来缩放数据
• 第 05 课:用一次编码转换类别
• 第 06 课:用 kBins 将数字转换为类别
• 第 07 课:主成分分析降维

每节课可能需要你 60 秒或 30 分钟。慢慢来，按照自己的节奏完成课程。提问，甚至在下面的评论中发布结果。

这些课程可能期望你去发现如何做事。我会给你一些提示，但是每节课的部分要点是迫使你学习去哪里寻找关于 Python 中的算法和最佳工具的帮助。(提示:我有这个博客上所有的答案；使用搜索框。)

在评论中发布您的结果；我会为你加油的！

坚持住。不要放弃。

第 01 课:数据准备的重要性

在本课中，您将发现数据准备在机器学习预测建模中的重要性。

预测建模项目涉及从数据中学习。

数据指的是领域中的例子或案例，它们描述了您想要解决的问题。

在预测建模项目中，例如分类或回归，原始数据通常不能直接使用。

出现这种情况有四个主要原因:

• 数据类型:机器学习算法要求数据为数字。
• 数据要求:有些机器学习算法对数据有要求。
• 数据错误:数据中的统计噪声和错误可能需要修正。
• 数据复杂度:数据中可能会梳理出复杂的非线性关系。

原始数据必须在用于拟合和评估机器学习模型之前进行预处理。预测建模项目中的这一步被称为“数据准备”

在机器学习项目的数据准备步骤中，您可以使用或探索一些常见或标准的任务。

这些任务包括:

• 数据清理:识别并纠正数据中的错误或差错。
• 特征选择:识别那些与任务最相关的输入变量。
• 数据转换:改变变量的规模或分布。
• 特征工程:从可用数据中导出新变量。
• 降维:创建数据的紧凑投影。

这些任务中的每一项都是具有专门算法的整个研究领域。

你的任务

在本课中，您必须列出三种您知道的或以前可能使用过的数据准备算法，并给出一行摘要。

数据准备算法的一个例子是数据标准化，它将数字变量缩放到 0 到 1 之间的范围。

在下面的评论中发表你的答案。我想看看你有什么想法。

在下一课中，您将发现如何修复缺失值的数据，称为数据插补。

第 02 课:用插补填补缺失值

在本课中，您将了解如何识别和填充数据中缺失的值。

真实世界的数据往往有缺失值。

由于多种原因，数据可能会丢失值，例如未记录的观察值和数据损坏。处理缺失数据很重要，因为许多机器学习算法不支持缺失值的数据。

用数据填充缺失值称为数据插补，一种流行的数据插补方法是计算每一列的统计值(如平均值)，并用统计值替换该列的所有缺失值。

马绞痛数据集描述了患有绞痛的马的医学特征以及它们是活的还是死的。它缺少标有问号“？”的值。我们可以用 read_csv()函数加载数据集，并确保问号值标记为 NaN。

一旦加载，我们就可以使用simple importer类将所有用 NaN 值标记的缺失值转换为列的平均值。

下面列出了完整的示例。

# statistical imputation transform for the horse colic dataset
from numpy import isnan
from pandas import read_csv
from sklearn.impute import SimpleImputer
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/horse-colic.csv'
dataframe = read_csv(url, header=None, na_values='?')
# split into input and output elements
data = dataframe.values
ix = [i for i in range(data.shape[1]) if i != 23]
X, y = data[:, ix], data[:, 23]
# print total missing
print('Missing: %d' % sum(isnan(X).flatten()))
# define imputer
imputer = SimpleImputer(strategy='mean')
# fit on the dataset
imputer.fit(X)
# transform the dataset
Xtrans = imputer.transform(X)
# print total missing
print('Missing: %d' % sum(isnan(Xtrans).flatten()))

你的任务

在本课中，您必须运行示例并查看数据插补转换前后数据集中缺失值的数量。

在下面的评论中发表你的答案。我想看看你有什么想法。

在下一课中，您将了解如何选择数据集中最重要的要素。

第 03 课:使用 RFE 选择要素

在本课中，您将了解如何选择数据集中最重要的要素。

特征选择是在开发预测模型时减少输入变量数量的过程。

希望减少输入变量的数量，以降低建模的计算成本，并在某些情况下提高模型的表现。

递归特征消除，简称 RFE，是一种流行的特征选择算法。

RFE 之所以受欢迎，是因为它易于配置和使用，并且可以有效地选择训练数据集中与预测目标变量更相关或最相关的特征(列)。

Sklearn Python 机器学习库为机器学习提供了一个 RFE 的实现。RFE 是一个转变。要使用它，首先，该类配置有通过“估计器”参数指定的所选算法，以及通过“ n_features_to_select ”参数选择的特征数量。

下面的示例定义了一个具有五个冗余输入要素的合成类别数据集。然后，使用决策树算法使用 RFE 来选择五个特征。

# 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: %d' % (i, rfe.support_[i], rfe.ranking_[i]))

你的任务

在本课中，您必须运行示例并查看选择了哪些要素以及每个输入要素的相对排名。

在下面的评论中发表你的答案。我想看看你有什么想法。

在下一课中，您将发现如何缩放数字数据。

第 04 课:通过标准化来缩放数据

在本课中，您将发现如何为机器学习缩放数字数据。

当数值输入变量被缩放到标准范围时，许多机器学习算法表现更好。

这包括使用输入加权和的算法，如线性回归，以及使用距离度量的算法，如 k 近邻。

建模前缩放数值数据的最流行技术之一是标准化。规范化将每个输入变量分别缩放到 0-1 的范围，这是我们准确率最高的浮点值范围。它要求你知道或能够准确估计每个变量的最小和最大可观察值。您可能能够从您的可用数据中估计这些值。

您可以使用 Sklearn 对象最小最大缩放器来规范化数据集。

下面的例子定义了一个合成类别数据集，然后使用最小最大缩放器来规范化输入变量。

# example of normalizing input data
from sklearn.datasets import make_classification
from sklearn.preprocessing import MinMaxScaler
# define dataset
X, y = make_classification(n_samples=1000, n_features=5, n_informative=5, n_redundant=0, random_state=1)
# summarize data before the transform
print(X[:3, :])
# define the scaler
trans = MinMaxScaler()
# transform the data
X_norm = trans.fit_transform(X)
# summarize data after the transform
print(X_norm[:3, :])

你的任务

对于本课，您必须运行该示例，并在规范化转换之前和之后报告输入变量的比例。

对于奖励点，计算转换前后每个变量的最小值和最大值，以确认它是否按预期应用。

在下面的评论中发表你的答案。我想看看你有什么想法。

在下一课中，您将发现如何将分类变量转换为数字。

第 05 课:使用单一热编码转换类别

在本课中，您将发现如何将分类输入变量编码为数字。

机器学习模型要求所有的输入和输出变量都是数字。这意味着，如果您的数据包含类别数据，您必须将其编码为数字，然后才能拟合和评估模型。

将分类变量转换为数字的最流行的技术之一是 one-hot 编码。

类别数据是包含标签值而不是数值的变量。

分类变量的每个标签可以映射到一个唯一的整数，称为序数编码。然后，可以对序数表示应用一次性编码。这是指为变量中的每个唯一整数值向数据集中添加一个新的二进制变量，并从数据集中移除原始分类变量。

例如，假设我们有一个带有三个类别的“颜色”变量(红色、绿色、蓝色)。在这种情况下，需要三个二进制变量。颜色的二进制变量中有一个“1”值，其他颜色的二进制变量中有“0”值。

例如:

red,	green,	blue
1,		0,		0
0,		1,		0
0,		0,		1

通过 OneHotEncoder 类，在 Sklearn Python 机器学习库中可以获得这种一次性编码转换。

乳腺癌数据集仅包含分类输入变量。

以下示例加载数据集，并对每个分类输入变量进行热编码。

# one-hot encode the breast cancer dataset
from pandas import read_csv
from sklearn.preprocessing import OneHotEncoder
# define the location of the dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/breast-cancer.csv"
# load the dataset
dataset = read_csv(url, header=None)
# retrieve the array of data
data = dataset.values
# separate into input and output columns
X = data[:, :-1].astype(str)
y = data[:, -1].astype(str)
# summarize the raw data
print(X[:3, :])
# define the one hot encoding transform
encoder = OneHotEncoder(sparse=False)
# fit and apply the transform to the input data
X_oe = encoder.fit_transform(X)
# summarize the transformed data
print(X_oe[:3, :])

你的任务

对于本课，您必须运行该示例，并报告转换前的原始数据，以及应用一次性编码后对数据的影响。

在下面的评论中发表你的答案。我想看看你有什么想法。

在下一课中，您将发现如何将数字变量转换为类别。

第 06 课:用 kBins 将数字转换为类别

在本课中，您将发现如何将数字变量转换为分类变量。

一些机器学习算法可能更喜欢或需要分类或顺序输入变量，例如一些决策树和基于规则的算法。

这可能是由数据中的异常值、多模态分布、高度指数分布等引起的。

当具有非标准分布的数值输入变量被转换为具有新的分布或全新的数据类型时，许多机器学习算法更喜欢或表现得更好。

一种方法是使用数值变量的变换来具有离散的概率分布，其中每个数值被分配一个标签，并且标签具有有序(序数)关系。

这被称为离散化变换，通过使数值输入变量的概率分布离散化，可以提高一些机器学习模型对数据集的表现。

离散化转换可通过KBinsDistrictzer 类在 Sklearn Python 机器学习库中获得。

它允许您指定要创建的离散面元的数量(n _ 面元)、转换的结果是序数还是单热编码(encode)以及用于划分变量值的分布(策略)，例如“统一”

下面的示例创建了一个包含 10 个数字输入变量的合成输入变量，然后用序数编码将每个变量编码到 10 个离散的容器中。

# discretize numeric input variables
from sklearn.datasets import make_classification
from sklearn.preprocessing import KBinsDiscretizer
# define dataset
X, y = make_classification(n_samples=1000, n_features=5, n_informative=5, n_redundant=0, random_state=1)
# summarize data before the transform
print(X[:3, :])
# define the transform
trans = KBinsDiscretizer(n_bins=10, encode='ordinal', strategy='uniform')
# transform the data
X_discrete = trans.fit_transform(X)
# summarize data after the transform
print(X_discrete[:3, :])

你的任务

对于本课，您必须在转换之前运行示例并报告原始数据，然后报告转换对数据的影响。

对于奖励点数，探索变换的替代配置，例如不同的策略和箱数。

在下面的评论中发表你的答案。我想看看你有什么想法。

在下一课中，您将发现如何降低输入数据的维度。

第七课:用主成分分析进行降维

在本课中，您将发现如何使用降维来减少数据集中输入变量的数量。

数据集的输入变量或特征的数量称为其维数。

降维是指减少数据集中输入变量数量的技术。

更多的输入特征通常会使预测建模任务更具挑战性，更一般地说，这被称为维数灾难。

尽管在高维统计中，降维技术经常用于数据可视化，但是这些技术可以用于应用机器学习来简化分类或回归数据集，以便更好地拟合预测模型。

也许机器学习中最流行的降维技术是主成分分析，简称 PCA。这是一种来自线性代数领域的技术，可以用作数据准备技术，在拟合模型之前创建数据集的投影。

得到的数据集，即投影，可以用作训练机器学习模型的输入。

Sklearn 库提供了主成分分析类，它可以适合数据集，并用于转换训练数据集和未来的任何附加数据集。

下面的示例创建了一个包含 10 个输入变量的合成二进制类别数据集，然后使用主成分分析将数据集的维度减少到三个最重要的组成部分。

# example of pca for dimensionality reduction
from sklearn.datasets import make_classification
from sklearn.decomposition import PCA
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=3, n_redundant=7, random_state=1)
# summarize data before the transform
print(X[:3, :])
# define the transform
trans = PCA(n_components=3)
# transform the data
X_dim = trans.fit_transform(X)
# summarize data after the transform
print(X_dim[:3, :])

你的任务

在本课中，您必须运行示例，并在应用转换后报告原始数据集和数据集的结构和形式。

对于加分，探索具有不同数量的选定组件的变换。

在下面的评论中发表你的答案。我想看看你有什么想法。

这是迷你课程的最后一课。

末日！

(看你走了多远)

你成功了。干得好！

花一点时间，回头看看你已经走了多远。

你发现了:

• 预测建模机器学习项目中数据准备的重要性。
• 如何标记缺失数据并使用统计插补来估计缺失值？
• 如何利用递归特征消除去除冗余输入变量？
• 如何将不同比例的输入变量转换为标准范围，称为标准化。
• 如何将分类输入变量转换为数字称为一热编码？
• 如何将数值变量转换成离散类别称为离散化。
• 如何使用主成分分析将数据集投影到较少的维度。

摘要

你觉得迷你课程怎么样？ 你喜欢这个速成班吗？

你有什么问题吗？有什么症结吗？ 让我知道。请在下面留言。

为什么数据准备在机器学习中如此重要

原文：machinelearningmastery.com/data-prepar…

最后更新于 2020 年 6 月 30 日

在预测建模项目中，机器学习算法学习从输入变量到目标变量的映射。

预测建模项目最常见的形式包括所谓的结构化数据或表格数据。这是电子表格或矩阵中的数据，每个示例都有行示例和列特征。

我们无法在原始数据上拟合和评估机器学习算法；相反，我们必须对数据进行转换，以满足单个机器学习算法的要求。更重要的是，我们必须为数据选择一种表示方式，最好地将预测问题的未知底层结构暴露给学习算法，以便在预测建模项目中获得最佳表现。

鉴于我们在开源库中有高度参数化的机器学习算法的标准实现，拟合模型已经成为常规。因此，每个预测建模项目最具挑战性的部分是如何准备项目特有的一件事:用于建模的数据。

在本教程中，您将发现数据准备对于每个机器学习项目的重要性。

完成本教程后，您将知道:

• 机器学习中的结构化数据由一个大表中的行和列组成。
• 数据准备是每个机器学习项目的必要步骤。
• 机器学习算法的常规性意味着每个项目的大部分精力都花在了数据准备上。

用我的新书机器学习的数据准备启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

为什么数据准备在机器学习中如此重要 图片由lwt 93提供，保留部分权利。

教程概述

本教程分为三个部分；它们是:

1. 什么是机器学习中的数据
2. 必须准备原始数据
   1. 机器学习算法期待数字
   2. 机器学习算法有要求
   3. 模型表现取决于数据
3. 预测建模主要是数据准备

什么是机器学习中的数据

预测建模项目涉及从数据中学习。

数据指的是领域中的例子或案例，它们描述了您想要解决的问题。在监督学习中，数据由示例组成，其中每个示例都有一个将提供给模型的输入元素和一个模型预期预测的输出或目标元素。

我们所说的数据是对现实世界现象的观察。[……]每一条数据都提供了一个了解现实有限方面的小窗口。

—第 1 页，机器学习的特征工程，2018。

分类是目标是标签的监督学习问题的例子，回归是目标是数字的监督学习问题的例子。

输入数据可以有多种形式，如图像、时间序列、文本、视频等。最常见的输入数据类型通常称为表格数据或结构化数据。这是您可能在电子表格、数据库或逗号分隔变量(CSV)文件中看到的数据。这是我们将关注的数据类型。

想象一个大的数据表。在线性代数中，我们把这个数据表称为矩阵。该表由行和列组成。一行代表问题域中的一个示例，可以称为“示例”、“实例”或“案例”。一列表示关于该示例观察到的属性，并且可以被称为“变量”、“特征”或“属性”。

• 排。领域中的单个例子，通常称为机器学习中的一个实例或例子。
• 列。为每个示例记录的单个属性，在机器学习中通常称为变量或特征。

例如，用于模型输入的列称为输入变量，包含要预测的目标的列称为输出变量。用于训练模型的行称为训练数据集，用于评估模型的行称为测试数据集。

• 输入变量:提供给模型的数据集中的列，以便进行预测。
• 输出变量。要由模型预测的数据集中的列。

当您收集数据时，您可能必须对其进行转换，使其形成一个大表。

例如，如果您的数据在关系数据库中，通常会以所谓的“范式”在单独的表中表示实体，从而最大限度地减少冗余。为了创建一个每个“主题”或“实体”一行的大型表，您可能需要反转这个过程，并在数据中引入冗余，这个过程称为反规格化。

如果您的数据在电子表格或数据库中，标准做法是以 CSV 格式提取并保存数据。这是一个标准的表示，它是可移植的，易于理解的，并且可以用于预测建模过程，没有外部依赖。

现在我们已经熟悉了结构化数据，让我们看看为什么我们需要在模型中使用数据之前准备数据。

必须准备原始数据

从您的域中收集的数据被称为原始数据，是在您想要解决的问题的上下文中收集的。

这意味着你必须首先定义你想要预测的东西，然后收集你认为有助于你做出最佳预测的数据。这种数据收集工作通常需要一位领域专家，并且可能需要多次重复收集更多的数据，无论是在新的数据行变得可用时，还是在新的列被确定为可能与进行预测相关时。

• 原始数据:域中提供的表单数据。

几乎在所有情况下，原始数据都需要更改，然后才能将其用作机器学习建模的基础。

要素是原始数据的一个方面的数字表示。特征位于机器学习管道中的数据和模型之间。特征工程是从原始数据中提取特征并将它们转换成适合机器学习模型的格式的行为。

—第七页，机器学习的特征工程，2018。

没有数据准备的情况是如此罕见或如此微不足道，以至于在每个机器学习项目中准备原始数据实际上是一条规则。

机器学习项目中必须准备原始数据的主要原因有三个。

让我们依次看一下每一个。

1.机器学习算法期待数字

即使您的数据表示在一个由行和列组成的大型表中，表中的变量也可能具有不同的数据类型。

有些变量可能是数字，如整数、浮点值、等级、比率、百分比等。其他变量可能是名称、类别或用字符或单词表示的标签，有些可能是二进制的，用 0 和 1 或 True 和 False 表示。

问题是，机器学习算法的核心是对数字数据进行操作。他们以数字为输入，预测数字为输出。使用线性代数的术语，所有数据都被视为向量和矩阵。

因此，在训练、评估和使用机器学习模型之前，必须改变原始数据。

有时数据的变化可以由机器学习算法在内部管理；最常见的是，这必须由机器学习从业者在建模之前在通常被称为“数据准备或“数据预处理”中处理。

2.机器学习算法有要求

即使您的原始数据只包含数字，也可能需要一些数据准备。

对于给定的预测建模项目，有许多不同的机器学习算法可供选择。我们无法知道哪种算法合适，更不用说最适合我们的任务了。因此，系统地评估一套不同的候选算法，并发现哪些算法在我们的数据上运行良好或最佳，是一种很好的做法。

问题是，每个算法对于数据都有特定的要求或期望。

…数据准备可以决定模型的预测能力。不同的模型对模型中预测因子的类型有不同的敏感性；预测者如何进入模型也很重要。

—第 27 页，应用预测建模，2013 年。

例如，一些算法假设每个输入变量，也许还有目标变量，都有特定的概率分布。对于期望每个数字输入变量具有高斯概率分布的线性机器学习模型来说，情况往往如此。

这意味着，如果您有非高斯或近似高斯的输入变量，您可能需要更改它们，使它们是高斯或更高斯的。或者，它可能会鼓励您重新配置算法，以便对数据有不同的预期。

众所周知，如果存在与目标变量无关或冗余的输入变量，某些算法的表现会更差。如果两个或多个输入变量高度相关，也有算法受到负面影响。在这些情况下，可能需要识别和移除不相关或高度相关的变量，或者可能需要使用替代算法。

还有一些算法对输入变量的概率分布或冗余的存在有很少的要求，但反过来，可能需要更多的例子(行)，以便学习如何做出好的预测。

数据预处理的需求由所使用的模型类型决定。一些程序，如基于树的模型，对预测数据的特征明显不敏感。其他的，像线性回归，不是。

—第 27 页，应用预测建模，2013 年。

因此，数据和算法的选择之间是相互影响的。首先，算法对数据施加了期望，遵守这些期望需要适当地准备数据。相反，数据的形式可能有助于选择更可能有效的算法进行评估。

3.模型表现取决于数据

即使您准备数据以满足每个模型的期望，您也可能无法获得最佳表现。

通常，具有强烈期望的机器学习算法的表现会优雅地降低到违背期望的程度。

此外，一个算法比其他方法表现好或更好是很常见的，即使它的期望被忽略或完全违背。这是一种很常见的情况，在准备和评估机器学习算法时必须考虑到这一点。

在模型中有不同的方法来表示预测器，并且其中一些表示比其他的更好，这种想法导致了特征工程的想法——创建数据表示的过程，以提高模型的有效性。

—第 3 页，特征工程与选择，2019。

机器学习算法的表现只有用来训练它的数据好。这常被概括为“垃圾进，垃圾出”。垃圾是苛刻的，但它可能意味着问题的“弱表示”，不足以捕捉学习如何将输入示例映射到输出所需的动态。

让我们理所当然地认为我们有“”足够的”数据来捕捉输入和输出变量之间的关系。这是一个狡猾的和特定领域的原则，在实践中，我们有我们拥有的数据，我们的工作是尽我们所能利用这些数据。

数据集可能是我们试图解决的问题的“弱表示”，原因有很多，尽管主要有两类原因。这可能是因为复杂的非线性关系被压缩在原始数据中，这些原始数据可以使用数据准备技术进行解包。这也可能是因为数据并不完美，从被称为统计噪声的观测值的轻微随机波动，到导致超范围值和数据冲突的误差。

• 复杂数据:原始数据包含可能需要暴露的压缩复杂非线性关系
• 杂乱的数据:原始数据包含统计噪声、错误、缺失值和冲突示例。

我们可以考虑通过两种方式充分利用我们的预测建模项目:关注模型和关注数据。

我们可以最低限度地准备原始数据并开始建模。这就把梳理数据中的关系和尽最大努力学习从输入到输出的映射函数的全部责任放在了模型上。这可能是一个合理的项目路径，可能需要一个大的数据集和一个灵活强大的机器学习算法，几乎没有期望，例如随机森林或梯度提升。

或者，我们可以将责任推回到数据和数据准备过程上。这要求每一行数据最大或最好地表达建模数据的信息内容。就像将关系数据库中的数据反规范化为行和列一样，数据准备可以反规范化每个单个观察中固有的复杂结构。这也是一条合理的路径。它可能需要比现有数据更多的数据知识，但是几乎不管所使用的机器学习算法如何，都可以实现良好甚至最佳的建模表现。

在任何给定的项目中，通常都会在这些方法之间寻求平衡。这既是探索强大而灵活的机器学习算法，也是使用数据准备来向学习算法最好地展示数据结构。

这就是说，数据预处理是获得更好数据的途径，进而获得更好的模型表现。

预测建模主要是数据准备

用机器学习算法建模数据已经成为常规。

大多数常见的、流行的和广泛使用的机器学习算法已经有几十年的历史了。线性回归已经有 100 多年的历史了。

也就是说，大多数算法都被很好地理解和参数化，并且在开源软件中有标准的定义和实现，比如 Python 中的 Sklearn 机器学习库。

虽然这些算法在操作上已经被很好地理解，但是大多数都没有令人满意的理论来解释它们为什么工作或者如何将算法映射到问题上。这就是为什么每个预测建模项目都是经验性的，而不是理论性的，需要对数据进行算法的系统实验。

考虑到机器学习算法在很大程度上是例行公事，不同项目之间唯一不同的是建模中使用的特定数据。

数据质量是数据管理中最重要的问题之一，因为脏数据通常会导致不准确的数据分析结果和不正确的业务决策。

—第十三页，数据清理，2019。

如果您已经为分类或回归预测建模问题收集了数据，这可能是有史以来第一次对问题进行建模。你正在开拓新的领域。这并不是说这类问题以前没有解决过；它可能有，如果结果被公布，你可以从发现的东西中学习。但正是在今天，您的特定观察集合使您的预测建模问题变得独特。

因此，您的项目的大部分将花费在数据上。收集数据、验证数据、清理数据、可视化数据、转换数据等等。

…据说高达 80%的数据分析花费在清理和准备数据的过程中。然而，作为数据分析工作流的其余部分(可视化、建模、报告)的先决条件，在数据争论技术方面变得流畅和高效是至关重要的。

—第五页，与 R 的数据角力，2016。

你的工作是发现如何最好地将学习算法暴露给你预测问题的未知底层结构。到达那里的途径是通过数据准备。

为了成为一名有效的机器学习实践者，您必须知道:

• 项目中需要考虑的不同类型的数据准备。
• 每类数据准备技术的前几个算法。
• 何时使用以及如何配置顶级数据准备技术。

这通常是来之不易的知识，因为很少有专门针对该主题的资源。相反，你必须经常查阅统计数据和应用论文的文献，以了解什么是可用的以及如何使用它。

从业者一致认为，构建机器学习管道的绝大部分时间都花在了特征工程和数据清理上。然而，尽管这个话题很重要，却很少单独讨论。

—第七页，机器学习的特征工程，2018。

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

书

• 特征工程和选择:预测模型的实用方法，2019。
• 应用预测建模，2013。
• 数据挖掘:实用机器学习工具与技术，第 4 版，2016。

文章

• 数据准备，维基百科。
• 数据清理，维基百科。
• 数据预处理，维基百科。

摘要

在本教程中，您发现了数据准备对于每个机器学习项目的重要性。

具体来说，您了解到:

• 机器学习中的结构化数据由一个大表中的行和列组成。
• 数据准备是每个机器学习项目的必要步骤。
• 机器学习算法的常规性意味着每个项目的大部分精力都花在了数据准备上。

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。

机器学习的数据准备技术之旅

原文：machinelearningmastery.com/data-prepar…

最后更新于 2020 年 6 月 30 日

预测建模机器学习项目，如分类和回归，总是涉及某种形式的数据准备。

数据集所需的具体数据准备取决于数据的具体情况，例如变量类型，以及用于建模它们的算法，这些算法可能会对数据提出期望或要求。

然而，有一组标准的数据准备算法可以应用于结构化数据(例如，像电子表格那样形成一个大表的数据)。这些数据准备算法可以按类型组织或分组到一个框架中，该框架在比较和选择特定项目的技术时很有帮助。

在本教程中，您将发现在预测建模机器学习任务中执行的常见数据准备任务。

完成本教程后，您将知道:

• 数据清理等技术可以识别和修复数据中的错误，如缺失值。
• 数据转换可以改变数据集中变量的规模、类型和概率分布。
• 特征选择和降维等技术可以减少输入变量的数量。

用我的新书机器学习的数据准备启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

机器学习数据准备技术之旅 尼古拉斯·雷蒙德摄，版权所有。

教程概述

本教程分为六个部分；它们是:

1. 常见数据准备任务
2. 数据清理
3. 特征选择
4. 数据转换
5. 特征工程
6. 降维

常见数据准备任务

我们可以将数据准备定义为将原始数据转换为更适合建模的形式。

尽管如此，在预测建模项目中，在数据准备步骤之前和之后都有一些步骤是重要的，并且通知将要执行的数据准备。

应用机器学习的过程由一系列步骤组成。

我们可以在任何给定项目的步骤之间来回跳转，但是所有项目都有相同的一般步骤；它们是:

• 第一步:定义问题。
• 第二步:准备数据。
• 第三步:评估模型。
• 第四步:定型。

我们关注的是数据准备步骤(步骤 2)，在机器学习项目的数据准备步骤中，您可能会使用或探索一些常见或标准的任务。

如您所料，所执行的数据准备类型取决于您的数据。

然而，当您处理多个预测建模项目时，您会一次又一次地看到并需要相同类型的数据准备任务。

这些任务包括:

• 数据清理:识别并纠正数据中的错误或差错。
• 特征选择:识别那些与任务最相关的输入变量。
• 数据转换:改变变量的规模或分布。
• 特征工程:从可用数据中导出新变量。
• 降维:创建数据的紧凑投影。

这提供了一个粗略的框架，我们可以使用它来思考和导航不同的数据准备算法，我们可以考虑在一个给定的项目中使用结构化或表格数据。

让我们依次仔细看看每一个。

数据清理

数据清理涉及修复“乱七八糟的数据中的系统问题或错误。

最有用的数据清理涉及深厚的领域专业知识，并可能涉及识别和解决可能不正确的特定观察。

数据可能具有不正确值的原因有很多，例如输入错误、损坏、重复等等。领域专业知识可能允许明显错误的观察被识别，因为它们与预期的不同，例如一个人 200 英尺的高度。

一旦识别出混乱、嘈杂、腐败或错误的观察结果，就可以解决它们。这可能涉及删除一行或一列。或者，它可能涉及用新值替换观察值。

尽管如此，仍可以执行一般的数据清理操作，例如:

• 使用统计定义正常数据并识别异常值。
• 识别具有相同值或没有差异的列并删除它们。
• 识别重复的数据行并删除它们。
• 将空值标记为缺失。
• 使用统计或学习模型输入缺失值。

数据清理是一种通常在其他数据准备操作之前首先执行的操作。

数据清理概述

有关数据清理的更多信息，请参见教程:

• 如何用 Python 进行机器学习的数据清洗

特征选择

特征选择是指用于选择与被预测的目标变量最相关的输入特征子集的技术。

这一点很重要，因为不相关和冗余的输入变量会分散或误导学习算法，可能导致较低的预测表现。此外，希望仅使用进行预测所需的数据来开发模型，例如倾向于最简单的可能表现良好的模型。

特征选择技术通常分为使用目标变量的技术(有监督的**)和不使用目标变量的技术(无监督的**)。此外，监督技术可以进一步分为自动选择特征作为拟合模型的一部分的模型(内在)、明确选择导致最佳表现模型的特征的模型(包装器)以及对每个输入特征评分并允许选择子集的模型(过滤器)。****

****

特征选择技术综述

统计方法是对输入特征进行评分的常用方法，例如相关性。然后可以根据得分对特征进行排序，得分最大的子集用作模型的输入。统计度量的选择取决于输入变量的数据类型以及对可以使用的不同统计度量的审查。

有关如何基于数据类型选择统计要素选择方法的概述，请参见教程:

• 如何选择机器学习的特征选择方法

此外，在预测建模项目中，我们可能会遇到不同的常见特征选择用例，例如:

• 分类目标变量的分类输入。
• 分类目标变量的数字输入。
• 回归目标变量的数值输入。

当混合输入变量数据类型时，可以使用不同的过滤方法。或者，可以使用包装器方法，如流行的 RFE 方法，它与输入变量类型无关。

对输入特征的相对重要性进行评分的更广泛的领域被称为特征重要性，并且存在许多基于模型的技术，其输出可用于帮助解释模型、解释数据集或选择用于建模的特征。

有关特征重要性的更多信息，请参见教程:

• 如何用 Python 计算特征重要性

数据转换

数据转换用于改变数据变量的类型或分布。

这是一个不同技术的大伞，它们可以同样容易地应用于输入和输出变量。

回想一下，数据可能有几种类型之一，如数值型或分类型，每种类型都有子类型，如数值型的整型和实值型，分类型的标称型、序数型和布尔型。

• 数值数据类型:数值。
  • 整数:没有小数部分的整数。
  • 实数:浮点值。
• 类别数据类型:标签值。
  • 序数:具有等级顺序的标签。
  • 标称:无等级排序的标签。
  • 布尔值:值为真和假。

下图概述了高级数据类型的相同细分。

数据变量类型概述

我们可能希望在一个称为离散化的过程中将一个数值变量转换成一个序数变量。或者，我们可以将分类变量编码为整数或布尔变量，这是大多数分类任务所需要的。

• 离散化变换:将数值变量编码为序数变量。
• 序数变换:将分类变量编码为整数变量。
• 一热变换:将一个分类变量编码成二进制变量。

对于实值数值变量，它们在计算机中的表示方式意味着 0-1 范围内的分辨率比更宽范围的数据类型要高得多。因此，可能希望将变量缩放到这个范围，称为规范化。如果数据具有高斯概率分布，将数据转换为平均值为零、标准偏差为 1 的标准高斯可能更有用。

• 归一化变换:将变量缩放到 0 到 1 的范围。
• 标准化变换:将变量缩放为标准高斯。

数值变量的概率分布可以改变。

例如，如果分布接近高斯，但有偏斜或偏移，则可以使用幂变换使其更具高斯性。或者，可以使用分位数变换来强制概率分布，例如具有异常自然分布的变量的均匀分布或高斯分布。

• 幂变换:将一个变量的分布变得更高斯。
• 分位数变换:施加均匀或高斯等概率分布。

数据转换的一个重要考虑因素是，通常对每个变量分别执行操作。因此，我们可能希望对不同的变量类型执行不同的操作。

数据转换技术综述

我们将来可能还想在新数据上使用转换。这可以通过将变换对象与在所有可用数据上训练的最终模型一起保存到文件中来实现。

特征工程

特征工程是指从可用数据创建新输入变量的过程。

设计新功能是高度特定于您的数据和数据类型的。因此，它通常需要主题专家的协作来帮助识别可以从数据构建的新特征。

这种专门化使得推广到一般方法成为一个具有挑战性的话题。

然而，有一些技术是可以重用的，例如:

• 为某些状态添加布尔标志变量。
• 添加组或全局汇总统计信息，如平均值。
• 为复合变量的每个组成部分添加新的变量，例如日期时间。

从统计学中提取的一种流行方法是创建数字输入变量的副本，这些变量已经通过简单的数学运算进行了更改，例如将它们提升到幂或与其他输入变量相乘，称为多项式特征。

• 多项式变换:创建数值输入变量的副本，这些变量被提升到一个幂。

特征工程的主题是给单个观察增加更广泛的背景或者分解复杂的变量，两者都是为了提供一个更直接的输入数据的视角。

我喜欢把特征工程看作一种数据转换，尽管把数据转换看作一种特征工程也是合理的。

降维

数据集的输入特征的数量可以被认为是数据的维度。

例如，两个输入变量一起可以定义一个二维区域，其中每行数据定义该空间中的一个点。然后，这个想法可以扩展到任何数量的输入变量，以创建大型多维超体。

问题是，这个空间的维数越多(例如，输入变量越多)，数据集越有可能代表该空间的非常稀疏且可能不具有代表性的采样。这被称为维度的诅咒。

这激发了特征选择，尽管特征选择的替代方法是创建数据到低维空间的投影，该投影仍然保留原始数据的最重要属性。

这通常被称为降维，并提供了特征选择的替代方案。与特征选择不同，投影数据中的变量与原始输入变量没有直接关系，使得投影难以解释。

降维最常见的方法是使用矩阵分解技术:

• 主成分分析
• 奇异值分解

这些技术的主要影响是它们消除了输入变量之间的线性相关性，例如相关变量。

存在发现较低维度缩减的其他方法。我们可以称之为基于模型的方法，比如线性判别分析，也许还有自动编码器。

• 线性判别分析

有时也可以使用流形学习算法，例如科霍宁自组织映射和 t-SNE。

降维技术综述

有关降维，请参见教程:

• 机器学习降维介绍

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

教程

• 如何为机器学习准备数据
• 应用机器学习过程
• 如何用 Python 进行机器学习的数据清洗
• 如何选择机器学习的特征选择方法
• 机器学习降维介绍

书

• 特征工程和选择:预测模型的实用方法，2019。
• 应用预测建模，2013。
• 数据挖掘:实用机器学习工具与技术，第 4 版，2016。

文章

• 数据准备，维基百科。
• 数据清理，维基百科。
• 数据预处理，维基百科。

摘要

在本教程中，您发现了在预测建模机器学习任务中执行的常见数据准备任务。

具体来说，您了解到:

• 数据清理等技术可以识别和修复数据中的错误，如缺失值。
• 数据转换可以改变数据集中变量的规模、类型和概率分布。
• 特征选择和降维等技术可以减少输入变量的数量。

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。****

执行数据准备时如何避免数据泄露

原文：machinelearningmastery.com/data-prepar…

最后更新于 2020 年 8 月 17 日

数据准备是将原始数据转换成适合建模的形式的过程。

准备数据的简单方法是在评估模型的表现之前对整个数据集应用转换。这导致了一个被称为数据泄漏的问题，其中，保持测试集的知识泄漏到用于训练模型的数据集中。在对新数据进行预测时，这可能导致对模型表现的不正确估计。

为了避免数据泄露，需要仔细应用数据准备技术，这取决于所使用的模型评估方案，如列车测试分割或 k 倍交叉验证。

在本教程中，您将发现如何在评估机器学习模型时避免数据准备过程中的数据泄漏。

完成本教程后，您将知道:

• 将数据准备方法天真地应用于整个数据集会导致数据泄漏，从而导致对模型表现的不正确估计。
• 数据准备必须仅在训练集上准备，以避免数据泄露。
• 如何在 Python 中实现训练-测试拆分和 k-fold 交叉验证的无数据泄露的数据准备。

用我的新书机器学习的数据准备启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

执行数据准备时如何避免数据泄露 图片由 kuhnmi 提供，保留部分权利。

教程概述

本教程分为三个部分；它们是:

1. 原始数据准备的问题
2. 用训练集和测试集准备数据
   1. 利用原始数据准备进行列车测试评估
   2. 正确准备数据的列车测试评估
3. k 倍交叉验证的数据准备
   1. 原始数据准备的交叉验证评估
   2. 正确准备数据的交叉验证评估

原始数据准备的问题

数据准备技术应用于数据事务的方式。

一种常见的方法是首先对整个数据集应用一个或多个转换。然后将数据集分割成训练集和测试集，或者使用 k 倍交叉验证来拟合和评估机器学习模型。

• 1.准备数据集
• 2.分割数据
• 3.评估模型

虽然这是一种常见的方法，但在大多数情况下，这是危险的错误。

在拆分数据进行模型评估之前应用数据准备技术的问题是，它可能导致数据泄露，进而可能导致对模型在该问题上的表现的不正确估计。

数据泄露指的是关于保持数据集的信息(例如测试或验证数据集)对训练数据集中的模型可用的问题。这种泄漏通常很小且很微妙，但会对表现产生显著影响。

……泄漏意味着信息被透露给模型，使其具有不切实际的优势来做出更好的预测。当测试数据泄露到训练集中时，或者当来自未来的数据泄露到过去时，就会发生这种情况。任何时候，当一个模型在生产中实时进行预测时，它被给予了它不应该得到的信息，就会有泄漏。

—第 93 页，机器学习的特征工程，2018。

我们通过对整个数据集应用数据准备技术来获得数据泄漏。

这不是一种直接的数据泄漏，我们将在测试数据集上训练模型。相反，这是一种间接类型的数据泄漏，其中在汇总统计中捕获的关于测试数据集的一些知识在训练期间对模型可用。这可能会使发现数据泄漏变得更加困难，尤其是对于初学者。

重采样的另一个方面与信息泄漏的概念有关，这是在训练过程中使用测试集数据(直接或间接)的地方。这可能会导致过于乐观的结果，不会在未来的数据点上复制，并且会以微妙的方式出现。

—第 55 页，特征工程与选择，2019 年。

例如，考虑我们想要规范化数据的情况，也就是将输入变量缩放到 0-1 的范围。

当我们标准化输入变量时，这要求我们首先计算每个变量的最小值和最大值，然后使用这些值来缩放变量。然后将数据集分为训练数据集和测试数据集，但是训练数据集中的示例对测试数据集中的数据有所了解；他们已经按全局最小值和最大值进行了缩放，因此他们比他们应该的更了解变量的全局分布。

几乎所有的数据准备技术都会出现相同类型的泄漏；例如，标准化估计来自域的平均值和标准偏差值，以便缩放变量；即使是使用模型或汇总统计数据估计缺失值的模型，也会利用整个数据集来填充训练数据集中的值。

解决方法很简单。

数据准备必须只适合训练数据集。也就是说，为数据准备过程准备的任何系数或模型必须只使用训练数据集中的数据行。

一旦适合，数据准备算法或模型就可以应用于训练数据集和测试数据集。

• 1.拆分数据。
• 2.在训练数据集上拟合数据准备。
• 3.将数据准备应用于训练和测试数据集。
• 4.评估模型。

更一般地说，必须只在训练数据集上准备整个建模管道，以避免数据泄漏。这可能包括数据转换，但也包括其他技术，如特征选择、降维、特征工程等。这意味着所谓的“模型评估”真的应该叫做“建模管道评估”。

为了使任何重采样方案产生推广到新数据的表现估计，它必须包含建模过程中可能显著影响模型有效性的所有步骤。

—第 54-55 页，特征工程与选择，2019。

既然我们已经熟悉了如何应用数据准备来避免数据泄漏，那么让我们来看看一些工作示例。

用训练集和测试集准备数据

在本节中，我们将在输入变量已经标准化的合成二进制类别数据集上使用训练和测试集来评估逻辑回归模型。

首先，让我们定义我们的合成数据集。

我们将使用 make_classification()函数创建包含 1000 行数据和 20 个数字输入特征的数据集。下面的示例创建数据集并总结输入和输出变量数组的形状。

# 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)

运行该示例将创建数据集，并确认数据集的输入部分对于 20 个输入变量有 1，000 行和 20 列，输出变量有 1，000 个示例来匹配 1，000 行输入数据，每行一个值。

(1000, 20) (1000,)

接下来，我们可以在缩放的数据集上评估我们的模型，从他们幼稚或不正确的方法开始。

利用原始数据准备进行列车测试评估

幼稚的方法包括首先应用数据准备方法，然后在最终评估模型之前拆分数据。

我们可以使用最小最大缩放器类来归一化输入变量，该类首先用默认配置定义，将数据缩放到 0-1 的范围，然后调用 fit_transform() 函数来拟合数据集上的变换，并在一个步骤中将其应用于数据集。结果是输入变量的规范化版本，其中数组中的每一列都被单独规范化(例如，计算出它自己的最小值和最大值)。

...
# standardize the dataset
scaler = MinMaxScaler()
X = scaler.fit_transform(X)

接下来，我们可以使用 train_test_split()函数将数据集分割成训练集和测试集。我们将 67%用于训练集，33%用于测试集。

...
# split into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)

然后，我们可以通过logisticreduction 类定义我们的逻辑回归算法，使用默认配置，并使其适合训练数据集。

...
# fit the model
model = LogisticRegression()
model.fit(X_train, y_train)

然后，拟合模型可以对测试集的输入数据进行预测，我们可以将预测值与期望值进行比较，并计算分类准确率分数。

...
# evaluate the model
yhat = model.predict(X_test)
# evaluate predictions
accuracy = accuracy_score(y_test, yhat)
print('Accuracy: %.3f' % (accuracy*100))

将这些联系在一起，完整的示例如下所示。

# naive approach to normalizing the data before splitting the data and evaluating the model
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# standardize the dataset
scaler = MinMaxScaler()
X = scaler.fit_transform(X)
# split into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# fit the model
model = LogisticRegression()
model.fit(X_train, y_train)
# evaluate the model
yhat = model.predict(X_test)
# evaluate predictions
accuracy = accuracy_score(y_test, yhat)
print('Accuracy: %.3f' % (accuracy*100))

运行该示例将数据标准化，将数据分成训练集和测试集，然后拟合和评估模型。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到模型的估计值约为 84.848%。

Accuracy: 84.848

鉴于我们知道存在数据泄露，我们知道这种对模型准确率的估计是错误的。

接下来，让我们探讨如何正确准备数据以避免数据泄漏。

正确准备数据的列车测试评估

使用训练-测试分割评估执行数据准备的正确方法是将数据准备适合训练集，然后将转换应用于训练集和测试集。

这要求我们首先将数据分成训练集和测试集。

...
# split into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)

然后我们可以定义最小最大缩放器并在训练集上调用 fit() 函数，然后在训练集和测试集上应用*变换()*函数来创建每个数据集的规范化版本。

...
# define the scaler
scaler = MinMaxScaler()
# fit on the training dataset
scaler.fit(X_train)
# scale the training dataset
X_train = scaler.transform(X_train)
# scale the test dataset
X_test = scaler.transform(X_test)

这避免了数据泄漏，因为每个输入变量的最小值和最大值的计算仅使用训练数据集( X_train )而不是整个数据集( X )来计算。

然后可以像以前一样评估模型。

将这些联系在一起，完整的示例如下所示。

# correct approach for normalizing the data after the data is split before the model is evaluated
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# split into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# define the scaler
scaler = MinMaxScaler()
# fit on the training dataset
scaler.fit(X_train)
# scale the training dataset
X_train = scaler.transform(X_train)
# scale the test dataset
X_test = scaler.transform(X_test)
# fit the model
model = LogisticRegression()
model.fit(X_train, y_train)
# evaluate the model
yhat = model.predict(X_test)
# evaluate predictions
accuracy = accuracy_score(y_test, yhat)
print('Accuracy: %.3f' % (accuracy*100))

运行该示例将数据分为训练集和测试集，正确地标准化数据，然后拟合和评估模型。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到模型的估计值约为 85.455%，这比上一节中具有数据泄漏的估计值更准确，后者达到了 84.848%的准确率。

我们预计数据泄露会导致对模型表现的错误估计。我们希望这是一个乐观的估计，数据泄漏会带来更好的表现，尽管在这种情况下，我们可以看到数据泄漏会导致表现略微下降。这可能是因为预测任务的难度。

Accuracy: 85.455

k 倍交叉验证的数据准备

在本节中，我们将在输入变量已经标准化的合成二进制类别数据集上使用 k 倍交叉验证来评估逻辑回归模型。

您可能还记得 K 折交叉验证涉及将数据集拆分为 k 个不重叠的行组。该模型然后在除一个组之外的所有组上训练以形成训练数据集，然后在保持折叠上评估。重复此过程，以便每个折叠都有机会用作保持测试集。最后，报告所有评估的平均绩效。

k-fold 交叉验证程序通常比训练测试分割给出更可靠的模型表现估计，尽管考虑到模型的重复拟合和评估，它的计算成本更高。

让我们首先来看看带有 k 倍交叉验证的幼稚数据准备。

原始数据准备的交叉验证评估

交叉验证的原始数据准备包括首先应用数据转换，然后使用交叉验证过程。

我们将使用上一节中准备的合成数据集，并直接对数据进行规范化。

...
# standardize the dataset
scaler = MinMaxScaler()
X = scaler.fit_transform(X)

必须首先定义 k 倍交叉验证程序。我们将使用重复的分层 10 倍交叉验证，这是分类的最佳实践。重复意味着整个交叉验证过程重复多次，在本例中为三次。分层意味着每组行将具有来自每个类的示例作为整个数据集的相对组成。我们将使用 k=10 或 10 倍交叉验证。

这可以通过使用repeated stratifiedfold来实现，它可以配置为三次重复和 10 次折叠，然后使用 cross_val_score()函数来执行该过程，传入定义的模型、交叉验证对象和度量来计算准确率，在这种情况下。

...
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model using cross-validation
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)

然后，我们可以报告所有重复和折叠的平均准确率。

将所有这些结合起来，下面列出了使用数据准备和数据泄漏来评估模型的交叉验证的完整示例。

# naive data preparation for model evaluation with k-fold cross-validation
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.preprocessing import MinMaxScaler
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)
# standardize the dataset
scaler = MinMaxScaler()
X = scaler.fit_transform(X)
# define the model
model = LogisticRegression()
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model using cross-validation
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(scores)*100, std(scores)*100))

运行该示例首先标准化数据，然后使用重复的分层交叉验证来评估模型。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到模型达到了大约 85.300%的估计准确率，考虑到数据准备过程允许的数据泄漏，我们知道这是不正确的。

Accuracy: 85.300 (3.607)

接下来，让我们看看如何通过交叉验证评估模型并避免数据泄漏。

正确准备数据的交叉验证评估

当使用交叉验证时，没有数据泄漏的数据准备工作稍微更具挑战性。

它要求在训练集上准备数据准备方法，并将其应用于交叉验证程序中的训练集和测试集，例如行的折叠组。

我们可以通过定义一个建模管道来实现这一点，该管道定义了一系列要执行的数据准备步骤，并在模型中结束以进行拟合和评估。

为了提供一个可靠的方法，我们应该限制自己开发预处理技术的列表，仅在训练数据点存在的情况下估计它们，然后将这些技术应用于未来的数据(包括测试集)。

—第 55 页，特征工程与选择，2019 年。

评估过程从简单且不正确地评估模型转变为正确地评估数据准备的整个管道和作为单个原子单元的模型。

这可以使用管道类来实现。

这个类列出了定义管道的步骤。列表中的每个步骤都是一个包含两个元素的元组。第一个元素是步骤的名称(字符串)，第二个元素是步骤的配置对象，例如转换或模型。该模型仅作为最后一步被支持，尽管我们可以在序列中拥有任意多的变换。

...
# define the pipeline
steps = list()
steps.append(('scaler', MinMaxScaler()))
steps.append(('model', LogisticRegression()))
pipeline = Pipeline(steps=steps)

然后，我们可以将配置的对象传递给 cross_val_score() 函数进行评估。

...
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model using cross-validation
scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1)

将这些结合在一起，下面列出了使用交叉验证时正确执行数据准备而不泄漏数据的完整示例。

# correct data preparation for model evaluation with k-fold cross-validation
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.preprocessing import MinMaxScaler
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
# 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 = list()
steps.append(('scaler', MinMaxScaler()))
steps.append(('model', LogisticRegression()))
pipeline = Pipeline(steps=steps)
# define the evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate the model using cross-validation
scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(scores)*100, std(scores)*100))

运行该示例可以在评估过程的交叉验证折叠中正确地标准化数据，以避免数据泄漏。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到，该模型的估计准确率约为 85.433%，而数据泄露的方法达到了约 85.300%的准确率。

与上一节中的训练测试示例一样，当我们的直觉认为数据泄漏通常会导致对模型表现的乐观估计时，消除数据泄漏会使表现略有提高。尽管如此，这些示例清楚地表明，数据泄漏确实会影响模型表现的估计，以及如何在数据拆分后通过正确执行数据准备来纠正数据泄漏。

Accuracy: 85.433 (3.471)

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

教程

• 如何为机器学习准备数据
• 应用机器学习过程
• 机器学习中的数据泄露

书

• 特征工程和选择:预测模型的实用方法，2019。
• 应用预测建模，2013。
• 数据挖掘:实用机器学习工具与技术，2016。
• 机器学习的特征工程，2018。

蜜蜂

• sklearn . datasets . make _ classification API。
• 硬化。预处理。MinMaxScaler API 。
• sklearn . model _ selection . train _ test _ split API。
• sklearn.linear_model。物流配送应用编程接口。
• sklearn.model_selection。重复的策略应用编程接口。
• sklearn . model _ selection . cross _ val _ score API。

文章

• 数据准备，维基百科。
• 数据清理，维基百科。
• 数据预处理，维基百科。

摘要

在本教程中，您发现了如何在评估机器学习模型时避免数据准备过程中的数据泄漏。

具体来说，您了解到:

• 将数据准备方法天真地应用于整个数据集会导致数据泄漏，从而导致对模型表现的不正确估计。
• 数据准备必须仅在训练集上准备，以避免数据泄露。
• 如何在 Python 中实现训练-测试拆分和 k-fold 交叉验证的无数据泄露的数据准备。

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。

6 种 Python 降维算法

原文：machinelearningmastery.com/dimensional…

最后更新于 2020 年 8 月 17 日

降维是一种无监督学习技术。

然而，它可以用作机器学习算法在分类和回归预测建模数据集上的数据变换预处理步骤。

有许多降维算法可供选择，没有一个最佳算法适用于所有情况。相反，探索一系列降维算法和每个算法的不同配置是一个好主意。

在本教程中，您将发现如何在 Python 中拟合和评估顶级降维算法。

完成本教程后，您将知道:

• 降维寻求保留数据中显著关系的数字输入数据的低维表示。
• 有许多不同的降维算法，没有一种最佳方法适用于所有数据集。
• 如何使用 Sklearn 机器学习库在 Python 中实现、拟合和评估顶级降维。

用我的新书机器学习的数据准备启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

用 Python 进行降维算法。新西兰，保留部分权利。

教程概述

本教程分为三个部分；它们是:

1. 降维
2. 降维算法
3. 降维的例子
   1. sci kit-学习库安装
   2. 类别数据集
   3. 主成分分析
   4. 奇异值分解
   5. 线性判别分析
   6. Isomap 嵌入
   7. 局部线性嵌入
   8. 改进的局部线性嵌入

降维

降维是指减少训练数据中输入变量数量的技术。

当处理高维数据时，通过将数据投影到捕捉数据“本质”的低维子空间来降低维数通常是有用的。这叫做降维。

—第 11 页，机器学习:概率视角，2012。

高维可能意味着数百、数千甚至数百万个输入变量。

更少的输入维数通常意味着机器学习模型中相应更少的参数或更简单的结构，称为自由度。具有太多自由度的模型可能会过度训练数据集，并且可能在新数据上表现不佳。

希望有简单的模型能够很好地概括，进而输入数据中的输入变量很少。对于输入数量和模型自由度通常密切相关的线性模型尤其如此。

降维是在建模之前对数据执行的数据准备技术。它可以在数据清理和数据缩放之后、训练预测模型之前执行。

…降维产生了目标概念的更紧凑、更容易解释的表示，将用户的注意力集中在最相关的变量上。

—第 289 页，数据挖掘:实用机器学习工具与技术，2016 年第 4 版。

因此，当使用最终模型进行预测时，对训练数据执行的任何降维也必须对新数据执行，例如测试数据集、验证数据集和数据。

降维算法

有许多算法可以用于降维。

两大类方法是从线性代数和流形学习中得出的。

线性代数方法

来自线性代数领域的矩阵分解方法可以用于维度。

有关矩阵分解的更多信息，请参见教程:

• 机器学习矩阵分解的简单介绍

一些比较流行的方法包括:

• 主成分分析
• 奇异值分解
• 非负矩阵分解

流形学习方法

流形学习方法寻求高维输入的低维投影，该投影捕捉输入数据的显著属性。

一些比较流行的方法包括:

• Isomap 嵌入
• 局部线性嵌入
• 多维排列
• 频谱嵌入
• t 分布随机邻居嵌入

每种算法都提供了一种不同的方法来应对在低维数据中发现自然关系的挑战。

没有最佳的降维算法，也没有简单的方法可以在不使用受控实验的情况下为您的数据找到最佳算法。

在本教程中，我们将回顾如何使用 Sklearn 库中这些流行的降维算法的每个子集。

这些示例将为您复制粘贴示例和在自己的数据上测试方法提供基础。

我们不会深入研究算法背后的理论，也不会直接比较它们。有关此主题的良好起点，请参见:

• 分解组件中的信号，Sklearn API 。
• 歧管学习，sci kit-学习 API 。

让我们开始吧。

降维的例子

在本节中，我们将回顾如何在 Sklearn 中使用流行的降维算法。

这包括使用降维技术作为建模管道中的数据转换并评估数据上的模型拟合的示例。

这些示例旨在让您复制粘贴到自己的项目中，并将这些方法应用到自己的数据中。Sklearn 库中有一些算法没有演示，因为鉴于算法的性质，它们不能直接用作数据转换。

因此，我们将在每个示例中使用合成类别数据集。

sci kit-学习库安装

首先，让我们安装库。

不要跳过这一步，因为您需要确保安装了最新版本。

您可以使用 pip Python 安装程序安装 Sklearn 库，如下所示:

sudo pip install Sklearn

有关特定于您的平台的其他安装说明，请参见:

• 安装 Sklearn

接下来，让我们确认库已安装，并且您使用的是现代版本。

运行以下脚本打印库版本号。

# check Sklearn version
import sklearn
print(sklearn.__version__)

运行该示例时，您应该会看到以下版本号或更高版本号。

0.23.0

类别数据集

我们将使用 make_classification()函数创建一个测试二进制类别数据集。

数据集将有 1，000 个包含 20 个输入要素的示例，其中 10 个是信息性的，10 个是冗余的。这为每种技术提供了识别和移除冗余输入特征的机会。

伪随机数发生器的固定随机种子确保我们在每次代码运行时生成相同的合成数据集。

下面列出了创建和汇总综合类别数据集的示例。

# synthetic classification dataset
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# summarize the dataset
print(X.shape, y.shape)

运行该示例会创建数据集，并报告符合我们预期的行数和列数。

(1000, 20) (1000,)

这是一个二分类任务，我们将在每次降维变换后评估一个物流分类模型。

模型将使用重复分层 10 倍交叉验证的金标准进行评估。将报告所有折叠和重复的平均和标准偏差分类准确率。

以下示例将原始数据集上的模型作为比较点进行评估。

# evaluate logistic regression model on raw data
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.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# define the model
model = LogisticRegression()
# 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)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

运行该示例会对包含所有 20 列的原始数据集进行逻辑回归评估，分类准确率约为 82.4%。

对该数据进行成功的降维变换应该会产生比该基线具有更好准确率的模型，尽管这可能不是所有技术都可以做到的。

注意:我们并不是试图“求解”这个数据集，只是提供可以作为起点的工作示例。

Accuracy: 0.824 (0.034)

接下来，我们可以开始查看应用于该数据集的降维算法的示例。

我已经做了一些最小的尝试来调整每个方法到数据集。每个降维方法将被配置为尽可能将 20 个输入列减少到 10 个。

我们将使用管道将数据转换和模型组合成一个原子单元，可以使用交叉验证程序进行评估；例如:

...
# define the pipeline
steps = [('pca', PCA(n_components=10)), ('m', LogisticRegression())]
model = Pipeline(steps=steps)

我们开始吧。

其中一个算法能得到更好的结果吗？ 在下面的评论里告诉我。

主成分分析

主成分分析可能是最流行的密集数据降维技术。

有关主成分分析如何工作的更多信息，请参见教程:

• 如何在 Python 中从头计算主成分分析

Sklearn 库提供了主成分分析的主成分分析类实现，可用作降维数据转换。可以设置“ n_components ”参数来配置变换输出中所需的维数。

下面列出了使用主成分分析降维评估模型的完整示例。

# evaluate pca 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 PCA
from sklearn.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# define the pipeline
steps = [('pca', PCA(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)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

运行该示例评估具有降维和逻辑回归预测模型的建模管道。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们看不到使用主成分分析变换对模型表现有任何提升。

Accuracy: 0.824 (0.034)

奇异值分解

奇异值分解(SVD)是最流行的用于稀疏数据(具有许多零值的数据)的降维技术之一。

有关 SVD 如何工作的更多信息，请参见教程:

• 如何用 Python 从头计算奇异值分解

Sklearn 库提供了奇异值分解的截断的 VD 类实现，可用作降维数据转换。可以设置“ n_components ”参数来配置变换输出中所需的维数。

下面列出了使用奇异值分解降维评估模型的完整示例。

# 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=10, n_redundant=10, 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)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

运行该示例评估具有降维和逻辑回归预测模型的建模管道。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们看不到使用奇异值分解变换对模型表现有任何提升。

Accuracy: 0.824 (0.034)

线性判别分析

线性判别分析(LDA)是一种多类分类算法，可用于降维。

投影的维数限于 1 和 C-1，其中 C 是类的数目。在这种情况下，我们的数据集是一个二分类问题(两个类)，将维数限制为 1。

有关降维 LDA 的更多信息，请参见教程:

• Python 中降维的线性判别分析

Sklearn 库提供了线性判别分析类的线性判别分析实现，可用作降维数据转换。可以设置“ n_components ”参数来配置变换输出中所需的维数。

下面列出了使用 LDA 降维评估模型的完整示例。

# evaluate lda 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.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# define the pipeline
steps = [('lda', LinearDiscriminantAnalysis(n_components=1)), ('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)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

运行该示例评估具有降维和逻辑回归预测模型的建模管道。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，与原始数据的基线拟合相比，我们可以看到表现略有提升。

Accuracy: 0.825 (0.034)

Isomap 嵌入

Isomap 嵌入(Isomap)创建数据集的嵌入，并尝试保留数据集中的关系。

Sklearn 库提供了 Isomap 嵌入的 Isomap 类实现，可用作降维数据转换。可以设置“ n_components ”参数来配置变换输出中所需的维数。

下面列出了使用奇异值分解降维评估模型的完整示例。

# evaluate isomap 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.manifold import Isomap
from sklearn.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# define the pipeline
steps = [('iso', Isomap(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)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

运行该示例评估具有降维和逻辑回归预测模型的建模管道。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，与原始数据的基线拟合相比，我们可以看到 Isomap 数据转换的表现有所提升。

Accuracy: 0.888 (0.029)

局部线性嵌入

局部线性嵌入(LLE)创建数据集的嵌入，并试图保留数据集中邻域之间的关系。

Sklearn 库提供了局部线性嵌入的局部线性嵌入类实现，可用作降维数据转换。可以设置“ n_components ”参数来配置变换输出中所需的维数

下面列出了使用 LLE 降维评估模型的完整示例。

# evaluate lle and logistic regression 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.manifold import LocallyLinearEmbedding
from sklearn.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# define the pipeline
steps = [('lle', LocallyLinearEmbedding(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)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

运行该示例评估具有降维和逻辑回归预测模型的建模管道。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，与原始数据的基线拟合相比，我们可以看到 LLE 数据转换的表现提升。

Accuracy: 0.886 (0.028)

改进的局部线性嵌入

修改的局部线性嵌入，或修改的 LLE，是局部线性嵌入的扩展，为每个邻域创建多个加权向量。

Sklearn 库提供了修改的局部线性嵌入的局部线性嵌入类实现，可用作降维数据转换。“方法”参数必须设置为“已修改”，并且“ n_components ”参数可以设置为配置转换输出中所需的维数，该维数必须小于“ n_neighbors ”参数。

下面列出了使用修正 LLE 降维评估模型的完整示例。

# evaluate modified lle and logistic regression 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.manifold import LocallyLinearEmbedding
from sklearn.linear_model import LogisticRegression
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=7)
# define the pipeline
steps = [('lle', LocallyLinearEmbedding(n_components=5, method='modified', n_neighbors=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)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

运行该示例评估具有降维和逻辑回归预测模型的建模管道。

注:考虑到算法或评估程序的随机性，或数值准确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，与原始数据的基线拟合相比，我们可以看到修改后的 LLE 数据转换的表现有所提升。

Accuracy: 0.846 (0.036)

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

教程

• 机器学习降维介绍
• Python 中降维的主成分分析
• Python 中降维的奇异值分解
• Python 中降维的线性判别分析

蜜蜂

• 分解组件中的信号，Sklearn API 。
• 歧管学习，sci kit-学习 API 。

摘要

在本教程中，您发现了如何在 Python 中拟合和评估顶级降维算法。

具体来说，您了解到:

• 降维寻求保留数据中显著关系的数字输入数据的低维表示。
• 有许多不同的降维算法，没有一种最佳方法适用于所有数据集。
• 如何使用 Sklearn 机器学习库在 Python 中实现、拟合和评估顶级降维。

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。