机器学习python入门（二）
接下来我们将加速您的机器学习专业知识，学习如何:
- 处理经常在真实数据集中发现的数据类型(缺失值missing values，分类变量categorical variables)。
- 设计管道pipelines来提高机器学习代码的质量。
- 使用高级技术进行模型验证(交叉验证cross-validation)。
- 建立最先进的模型，广泛用于赢得Kaggle竞赛(XGBoost)。
- 避免常见和重要的数据科学错误(泄漏leakage)。
在此过程中，您将通过使用每个新主题的真实数据完成实际操作来巩固您的知识。实际操作使用来自Kaggle Learn用户的房价竞争数据，你将使用79个不同的解释变量(比如屋顶的类型，卧室的数量，浴室的数量)来预测房价。
Missing values
下面我们将学习三种处理缺失值的方法。然后我们将比较这些方法在真实数据集上的有效性。
数据缺失值的方式有很多种。例如,
- 两间卧室的房子不包括第三间卧室的大小。
- 被调查者可以选择不分享他的收入。
如果试图使用缺失值的数据构建模型，那么大多数机器学习库(包括scikit-learn)都会出错。所以你需要选择下面的策略之一。
Three Approaches
1) 一个简单的选项: 删除缺少值的列
最简单的选择是删除缺少值的列。
除非删除列中的大多数值丢失，否则使用这种方法模型将失去对大量(可能有用的!)信息。作为一个极端的例子，假设一个数据集有10,000行，其中一个重要的列缺少一个条目。这种方法将完全删除该列!
2) 一个更好的选择: 填充Imputation
填充法Imputation用某个数字填充缺失的值。例如，我们可以沿每一列填充平均值。
在大多数情况下，填充的值并不完全正确，但它通常会产生比完全删除列更准确的模型。
3) 对填充的延伸
填充法是标准的方法，而且通常效果很好。然而，填充值可能系统地高于或低于它们的实际值(数据集中没有收集到这些值)。或者缺失值的行在其他方面可能是惟一的。在这种情况下，我们的模型可以通过考虑最初丢失了哪些值来做出更好的预测。
在这种方法中，我们像前面一样填充缺失的值。此外，对于原始数据集中缺失记录的每一列，我们添加一个新列，显示填充记录的位置。
在某些情况下，这将有意义地改善结果。在其他情况下，它完全没有帮助。
Example
在本例中，我们将使用Melbourne Housing数据集。我们的模型将使用房间数量和土地面积等信息来预测房价。
我们不会关注数据加载步骤。相反，我们可以想象我们已经拥有了X_train、X_valid、y_train和y_valid中的训练和验证数据。
import pandas as pd
from sklearn.model_selection import train_test_split
# Load the data
data = pd.read_csv('../input/melbourne-housing-snapshot/melb_data.csv')
# Select target
y = data.Price
# To keep things simple, we'll use only numerical predictors
melb_predictors = data.drop(['Price'], axis=1)
X = melb_predictors.select_dtypes(exclude=['object'])
# Divide data into training and validation subsets
X_train, X_valid, y_train, y_valid = train_test_split(X, y, train_size=0.8, test_size=0.2,
random_state=0)
我们定义了一个函数score_dataset()来比较处理缺失值的不同方法。这个函数报告随机森林模型的平均绝对误差(MAE)
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error
# Function for comparing different approaches
def score_dataset(X_train, X_valid, y_train, y_valid):
model = RandomForestRegressor(n_estimators=10, random_state=0)
model.fit(X_train, y_train)
preds = model.predict(X_valid)
return mean_absolute_error(y_valid, preds)
方法1(删除缺少值的列)的得分
由于我们同时使用训练集和验证集，所以我们仔细地删除两个dataframes中的相同列。
# Get names of columns with missing values
cols_with_missing = [col for col in X_train.columns
if X_train[col].isnull().any()]
# Drop columns in training and validation data
reduced_X_train = X_train.drop(cols_with_missing, axis=1)
reduced_X_valid = X_valid.drop(cols_with_missing, axis=1)
print("MAE from Approach 1 (Drop columns with missing values):")
print(score_dataset(reduced_X_train, reduced_X_valid, y_train, y_valid))
output:
MAE from Approach 1 (Drop columns with missing values):
183550.22137772635
方法2 (填充)的得分
接下来，我们使用SimpleImputer将缺失的值替换为每一列的平均值
虽然很简单，但填充平均值通常执行得很好(但这因数据集而异)。虽然统计学家已经尝试过更复杂的方法来确定填充值(比如回归填充regression imputation)，但一旦将结果插入复杂的机器学习模型，这些复杂的策略通常不会带来额外的好处。
from sklearn.impute import SimpleImputer
# Imputation
my_imputer = SimpleImputer()
imputed_X_train = pd.DataFrame(my_imputer.fit_transform(X_train))
imputed_X_valid = pd.DataFrame(my_imputer.transform(X_valid))
# Imputation removed column names; put them back
imputed_X_train.columns = X_train.columns
imputed_X_valid.columns = X_valid.columns
print("MAE from Approach 2 (Imputation):")
print(score_dataset(imputed_X_train, imputed_X_valid, y_train, y_valid))
output:
MAE from Approach 2 (Imputation):
178166.46269899711
我们看到方法2比方法1具有更低的MAE，因此方法2在这个数据集上表现更好。
方法3(填充的延申)的得分
接下来，我们填充缺失的值，同时跟踪被填充的值
# Make copy to avoid changing original data (when imputing)
X_train_plus = X_train.copy()
X_valid_plus = X_valid.copy()
# Make new columns indicating what will be imputed
for col in cols_with_missing:
X_train_plus[col + '_was_missing'] = X_train_plus[col].isnull()
X_valid_plus[col + '_was_missing'] = X_valid_plus[col].isnull()
# Imputation
my_imputer = SimpleImputer()
imputed_X_train_plus = pd.DataFrame(my_imputer.fit_transform(X_train_plus))
imputed_X_valid_plus = pd.DataFrame(my_imputer.transform(X_valid_plus))
# Imputation removed column names; put them back
imputed_X_train_plus.columns = X_train_plus.columns
imputed_X_valid_plus.columns = X_valid_plus.columns
print("MAE from Approach 3 (An Extension to Imputation):")
print(score_dataset(imputed_X_train_plus, imputed_X_valid_plus, y_train, y_valid))
output:
MAE from Approach 3 (An Extension to Imputation):
178927.503183954
正如我们所看到的，方法3的性能略逊于方法2。
为什么填充法比直接删除这些列的效果更好呢?
训练数据有10864行和12列，其中3列包含缺失的数据。对于每一列，少于一半的记录被遗漏。因此，删除这些列删除了大量有用的信息，因此，填充法将表现得更好是有道理的。
# Shape of training data (num_rows, num_columns)
print(X_train.shape)
# Number of missing values in each column of training data
missing_val_count_by_column = (X_train.isnull().sum())
print(missing_val_count_by_column[missing_val_count_by_column > 0])
output：
(10864, 12)
Car 49
BuildingArea 5156
YearBuilt 4307
dtype: int64
总结
与简单地删除有缺失值的列(在方法1中)相比，填充缺失值(在方法2和方法3中)通常会产生更好的结果。
分类变量categorical variable
分类变量只接受有限数量的值。
- 考虑一个调查，问你多久吃一次早餐，并提供四种选择:“从不”，“很少”，“大部分时间”，或“每天”。在这种情况下，数据是分类的，因为响应于一组固定的类别。
- 如果人们回答一项关于他们拥有什么品牌的汽车的调查，他们的回答会分成像“本田”、“丰田”和“福特”这样的类别。在这种情况下，数据也是分类的。
如果您试图将这些变量插入到Python中的大多数机器学习模型中而不首先对它们进行预处理，那么将会出现错误。在本教程中，我们将比较用于准备分类数据的三种方法。
Three Approaches
1)删除分类变量
处理分类变量最简单的方法是将它们从数据集中移除。这种方法只有在列不包含有用信息时才有效。
2) 标签编码Label Encoding
标签编码将每个唯一值分配给一个不同的整数。
这种方法假定类别的顺序为:“Never”(0)<“Rarely”(1)<“Most days”(2)<“Every day”(3)。
这个假设在这个例子中是有意义的，因为类别有一个无可争辩的排名。并不是所有的分类变量的值都有一个明确的顺序，但我们把那些做顺序变量。对于基于树的模型(如决策树和随机森林)，您可以期望标签编码能够很好地处理顺序变量。
3) 独热编码One-Hot Encoding
独热编码创建新列，指示原始数据中每个可能值的存在(或不存在)。为了理解这一点，我们将通过一个示例。
在原始数据集中，“Color”是一个分类变量，有“Red”、“Yellow”、“Green”三个类别。对应的one-hot编码为每个可能的值包含一列，为原始数据集中的每一行包含一行。当原始值为“Red”时，我们在“Red”一栏中写上1;如果原始值是“Yellow”，我们在“Yellow”列中输入1，以此类推。
与标签编码相比，独热编码不假定类别的顺序。因此，如果分类数据中没有明确的排序(例如，“Red”既不多于也不少于“Yellow”)，那么你可以期望这种方法特别有效。我们把没有内在等级的分类变量称为名义变量nominal variables.。
如果分类变量具有大量的值,独热编码通常表现得不好(例如:，一般不会将其用于包含超过15个不同值的变量)。
Example
我们将使用墨尔本房屋数据集 Melbourne Housing dataset。
我们不会关注数据加载步骤。相反，您可以想象您已经拥有了X_train、X_valid、y_train和y_valid中的训练和验证数据。
import pandas as pd
from sklearn.model_selection import train_test_split
# Read the data
data = pd.read_csv('../input/melbourne-housing-snapshot/melb_data.csv')
# Separate target from predictors
y = data.Price
X = data.drop(['Price'], axis=1)
# Divide data into training and validation subsets
X_train_full, X_valid_full, y_train, y_valid = train_test_split(X, y, train_size=0.8, test_size=0.2,
random_state=0)
# Drop columns with missing values (simplest approach)
cols_with_missing = [col for col in X_train_full.columns if X_train_full[col].isnull().any()]
X_train_full.drop(cols_with_missing, axis=1, inplace=True)
X_valid_full.drop(cols_with_missing, axis=1, inplace=True)
# "Cardinality" means the number of unique values in a column
# Select categorical columns with relatively low cardinality (convenient but arbitrary)
low_cardinality_cols = [cname for cname in X_train_full.columns if X_train_full[cname].nunique() < 10 and
X_train_full[cname].dtype == "object"]
# Select numerical columns
numerical_cols = [cname for cname in X_train_full.columns if X_train_full[cname].dtype in ['int64', 'float64']]
# Keep selected columns only
my_cols = low_cardinality_cols + numerical_cols
X_train = X_train_full[my_cols].copy()
X_valid = X_valid_full[my_cols].copy()
用下面的head()方法看一下训练数据。
X_train.head()
Type Method Regionname Rooms Distance Postcode Bedroom2 Bathroom Landsize Lattitude Longtitude Propertycount
12167 u S Southern Metropolitan 1 5.0 3182.0 1.0 1.0 0.0 -37.85984 144.9867 13240.0
6524 h SA Western Metropolitan 2 8.0 3016.0 2.0 2.0 193.0 -37.85800 144.9005 6380.0
8413 h S Western Metropolitan 3 12.6 3020.0 3.0 1.0 555.0 -37.79880 144.8220 3755.0
2919 u SP Northern Metropolitan 3 13.0 3046.0 3.0 1.0 265.0 -37.70830 144.9158 8870.0
6043 h S Western Metropolitan 3 13.3 3020.0 3.0 1.0 673.0 -37.76230 144.8272 4217.0
接下来，我们获得训练数据中所有分类变量的列表。
我们通过检查每个列的数据类型(或dtype)来实现这一点。对象object dtype表示列具有文本(理论上还可以是其他内容，但这对我们的目的不重要)。对于这个数据集，带有文本的列表示分类变量。
# Get list of categorical variables
s = (X_train.dtypes == 'object')
object_cols = list(s[s].index)
print("Categorical variables:")
print(object_cols)
output：
Categorical variables:
['Type', 'Method', 'Regionname']
定义函数来度量每种方法的质量
我们定义函数score_dataset()来比较处理分类变量的三种不同方法。这个函数报告随机森林模型的平均绝对误差(MAE)。一般来说，我们希望MAE尽可能低!
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error
# Function for comparing different approaches
def score_dataset(X_train, X_valid, y_train, y_valid):
model = RandomForestRegressor(n_estimators=100, random_state=0)
model.fit(X_train, y_train)
preds = model.predict(X_valid)
return mean_absolute_error(y_valid, preds)
方法1(去掉分类变量)的得分
我们使用select_dtypes()方法删除对象列。
drop_X_train = X_train.select_dtypes(exclude=['object'])
drop_X_valid = X_valid.select_dtypes(exclude=['object'])
print("MAE from Approach 1 (Drop categorical variables):")
print(score_dataset(drop_X_train, drop_X_valid, y_train, y_valid))
output:
MAE from Approach 1 (Drop categorical variables):
175703.48185157913
方法2(标签编码)的得分
在进入标签编码之前，我们将研究数据集。
是否有一些值出现在验证数据中而训练数据中没有?
这是在实际数据中会遇到的常见问题，有很多方法可以解决这个问题。例如，您可以编写一个自定义标签编码器来处理新的类别。然而，最简单的方法是删除有问题的分类列。
运行下面的代码单元格，将有问题的列保存到Python列表bad_label_cols中。同样，可以安全地进行标签编码的列存储在good_label_cols中。
# All categorical columns
object_cols = [col for col in X_train.columns if X_train[col].dtype == "object"]
# Columns that can be safely label encoded
good_label_cols = [col for col in object_cols if
set(X_train[col]) == set(X_valid[col])]
# Problematic columns that will be dropped from the dataset
bad_label_cols = list(set(object_cols)-set(good_label_cols))
print('Categorical columns that will be label encoded:', good_label_cols)
print('\nCategorical columns that will be dropped from the dataset:', bad_label_cols)
Scikit-learn有一个LabelEncoder类，可以用来获取标签编码。我们循环遍历分类变量，并将标签编码器分别应用到每一列。
from sklearn.preprocessing import LabelEncoder
# Make copy to avoid changing original data
label_X_train = X_train.drop(bad_label_cols, axis=1)
label_X_valid = X_valid.drop(bad_label_cols, axis=1)
# Apply label encoder to each column with categorical data
label_encoder = LabelEncoder()
for col in good_label_cols:
label_X_train[col] = label_encoder.fit_transform(X_train[col])
label_X_valid[col] = label_encoder.transform(X_valid[col])
print("MAE from Approach 2 (Label Encoding):")
print(score_dataset(label_X_train, label_X_valid, y_train, y_valid))
output:
MAE from Approach 2 (Label Encoding):
165936.40548390493
在上面的代码单元格中，对于每个列，我们将每个唯一值随机分配给一个不同的整数。这是一种常见的方法，比提供自定义标签更简单;但是，如果我们为所有序号变量提供更好的标签，我们可以期待性能的额外提升。
方法3(独热编码)得分
首先我们来查看基数cardinality：
对于具有分类数据的每一列，该列中惟一值的数量。例如，训练数据中的’Street’列有两个惟一的值:‘Grvl’和’Pave’，分别对应于一条砾石路和一条铺好的路。我们将一个类别变量的唯一条目的数量称为该类别变量的基数。例如，'Street’变量的基数为2。
#练习里面的数据Housing Prices Competition for Kaggle Learn Users.
# Get number of unique entries in each column with categorical data
object_nunique = list(map(lambda col: X_train[col].nunique(), object_cols))
d = dict(zip(object_cols, object_nunique))
# Print number of unique entries by column, in ascending order
sorted(d.items(), key=lambda x: x[1])
[('Street', 2),
('Utilities', 2),
('CentralAir', 2),
('LandSlope', 3),
('PavedDrive', 3),
('LotShape', 4),
('LandContour', 4),
('ExterQual', 4),
('KitchenQual', 4),
('MSZoning', 5),
('LotConfig', 5),
('BldgType', 5),
('ExterCond', 5),
('HeatingQC', 5),
('Condition2', 6),
('RoofStyle', 6),
('Foundation', 6),
('Heating', 6),
('Functional', 6),
('SaleCondition', 6),
('RoofMatl', 7),
('HouseStyle', 8),
('Condition1', 9),
('SaleType', 9),
('Exterior1st', 15),
('Exterior2nd', 16),
('Neighborhood', 25)]
对于多行大型数据集，独热编码可以极大地扩展数据集的大小。因此，我们通常只使用基数较低的独热编码列。然后，可以从数据集中删除高基数列，或者我们可以使用标签编码。
下面，我们将只为基数小于10的列创建一个独热编码，而不是对数据集中的所有分类变量进行编码。
# Columns that will be one-hot encoded
low_cardinality_cols = [col for col in object_cols if X_train[col].nunique() < 10]
# Columns that will be dropped from the dataset
high_cardinality_cols = list(set(object_cols)-set(low_cardinality_cols))
我们使用scikitl -learn中的OneHotEncoder类来获得一次性编码。有许多参数可以用于定制其行为。
- 我们设置handle_unknown=‘ignore’，以避免在验证数据包含训练数据中没有表示的类时出现错误。
- 设置sparse=False可以确保以numpy数组(而不是稀疏矩阵)的形式返回已编码的列。
要使用编码器，我们只提供我们希望进行独热编码的分类列。例如，为了编码训练数据，我们提供X_train[object_cols]。(下面代码单元中的object_cols是带有分类数据的列名称列表，因此X_train[object_cols]包含训练集中的所有分类数据。)
from sklearn.preprocessing import OneHotEncoder
# Apply one-hot encoder to each column with categorical data
OH_encoder = OneHotEncoder(handle_unknown='ignore', sparse=False)
OH_cols_train = pd.DataFrame(OH_encoder.fit_transform(X_train[low_cardinality_cols]))
OH_cols_valid = pd.DataFrame(OH_encoder.transform(X_valid[low_cardinality_cols]))
# One-hot encoding removed index; put it back
OH_cols_train.index = X_train.index
OH_cols_valid.index = X_valid.index
# Remove categorical columns (will replace with one-hot encoding)
num_X_train = X_train.drop(object_cols, axis=1)
num_X_valid = X_valid.drop(object_cols, axis=1)
# Add one-hot encoded columns to numerical features
OH_X_train = pd.concat([num_X_train, OH_cols_train], axis=1)
OH_X_valid = pd.concat([num_X_valid, OH_cols_valid], axis=1)
print("MAE from Approach 3 (One-Hot Encoding):")
print(score_dataset(OH_X_train, OH_X_valid, y_train, y_valid))
output:
MAE from Approach 3 (One-Hot Encoding):
166089.4893009678
哪种方法是最好的?
在这种情况下，删除分类列(方法1)表现最差，因为它拥有最高的MAE得分。至于其他两种方法，由于归还的MAE得分值非常接近，两者之间似乎没有任何有意义的优势。
通常，独热编码(方法3)的性能最好，而删除分类列(方法1)的性能最差，但具体情况会有所不同。
结论
这个世界充满了分类数据。如果你知道如何使用这种通用数据类型，你将成为一名更有效的数据科学家!
Pipelines
管道Pipelines是保持数据预处理和建模代码有组织的一种简单方法。具体来说，管道捆绑了预处理和建模步骤，因此您可以像使用单个步骤一样使用整个捆绑包。
许多数据科学家在没有流水线的情况下拼凑模型，但是管道有一些重要的好处。这些包括:
- 更干净的代码Cleaner Code: 在预处理的每一步计算数据可能会变得很混乱。通过管道，你将不需要在每一步手动跟踪你的训练和验证数据。
- 错误更少Fewer Bugs: 错误应用步骤或忘记预处理步骤的机会更少。
- 易于生产化Easier to Productionize: 将模型从原型转换为可大规模部署的东西可能会异常困难。这里我们不会深入讨论许多相关问题，但是管道可能会有所帮助。
- 模型验证的更多选项More Options for Model Validation: 我们将在下一个节中看到一个示例，其中介绍了交叉验证。
Example
下面，我们将使用墨尔本房屋数据集Melbourne Housing dataset。
X_train、X_valid、y_train和y_valid中的训练和验证数据。
import pandas as pd
from sklearn.model_selection import train_test_split
# Read the data
data = pd.read_csv('../input/melbourne-housing-snapshot/melb_data.csv')
# Separate target from predictors
y = data.Price
X = data.drop(['Price'], axis=1)
# Divide data into training and validation subsets
X_train_full, X_valid_full, y_train, y_valid = train_test_split(X, y, train_size=0.8, test_size=0.2,
random_state=0)
# "Cardinality" means the number of unique values in a column
# Select categorical columns with relatively low cardinality (convenient but arbitrary)
categorical_cols = [cname for cname in X_train_full.columns if X_train_full[cname].nunique() < 10 and
X_train_full[cname].dtype == "object"]
# Select numerical columns
numerical_cols = [cname for cname in X_train_full.columns if X_train_full[cname].dtype in ['int64', 'float64']]
# Keep selected columns only
my_cols = categorical_cols + numerical_cols
X_train = X_train_full[my_cols].copy()
X_valid = X_valid_full[my_cols].copy()
我们分三步构建整个管道。
步骤1:定义预处理步骤
类似于管道如何将预处理和建模步骤捆绑在一起，我们使用ColumnTransformer类将不同的预处理步骤捆绑在一起。下面的代码:
- 填充数值数据中的缺失值；
-填充缺失值并对分类数据采用独热编码。
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder
# Preprocessing for numerical data
numerical_transformer = SimpleImputer(strategy='constant')
# Preprocessing for categorical data
categorical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='most_frequent')),
('onehot', OneHotEncoder(handle_unknown='ignore'))
])
# Bundle preprocessing for numerical and categorical data
preprocessor = ColumnTransformer(
transformers=[
('num', numerical_transformer, numerical_cols),
('cat', categorical_transformer, categorical_cols)
])
步骤2:定义模型
接下来，我们用熟悉的RandomForestRegressor类定义一个随机森林模型。
from sklearn.ensemble import RandomForestRegressor
model = RandomForestRegressor(n_estimators=100, random_state=0)
步骤3:创建和评估管道
最后，我们使用Pipeline类来定义绑定预处理和建模步骤的管道。有几件重要的事情需要注意:
- 通过管道，我们对训练数据进行预处理，并用一行代码拟合模型。(相比之下，如果没有管道，我们就必须在单独的步骤中进行注入、单热编码和模型训练。如果我们必须同时处理数字变量和分类变量，这就变得特别混乱!)
- 通过管道，我们将X_valid中未处理的特征提供给predict()命令，管道在生成预测之前自动预处理这些特性。(但是，如果没有管道，我们必须记住在进行预测之前对验证数据进行预处理。)
from sklearn.metrics import mean_absolute_error
# Bundle preprocessing and modeling code in a pipeline
my_pipeline = Pipeline(steps=[('preprocessor', preprocessor),
('model', model)
])
# Preprocessing of training data, fit model
my_pipeline.fit(X_train, y_train)
# Preprocessing of validation data, get predictions
preds = my_pipeline.predict(X_valid)
# Evaluate the model
score = mean_absolute_error(y_valid, preds)
print('MAE:', score)
output：
MAE: 160679.18917034855
结论
管道对于清理机器学习代码和避免错误很有价值，对于具有复杂数据预处理的工作流尤其有用。
Cross-Validation
机器学习是一个迭代的过程。
你将面临选择使用什么预测变量，使用什么类型的模型，为这些模型提供什么论据，等等。到目前为止，通过使用验证(或坚持)集度量模型质量，你已经以数据驱动的方式做出了这些选择。
但是这种方法也有一些缺点。要了解这一点，假设您有一个包含5000行的数据集。您通常会保留大约20%的数据作为验证数据集，即1000行。但这在决定模型得分时留下了一些随机机会。也就是说，一个模型可能在一个1000行的集合上运行得很好，即使它在不同的1000行的集合上可能不准确。
在极端情况下，你可以想象验证集中只有一行数据。如果你比较其他模型，哪一个模型在单个数据点上做出了最好的预测将主要是运气问题!
一般来说，验证集越大，我们衡量模型质量的随机性(又名“噪音”)就越少，也就越可靠。不幸的是，我们只能通过从训练数据中删除行来获得一个大的验证集，而更小的训练数据集意味着更糟糕的模型!
交叉验证是什么?
在交叉验证中，我们在数据的不同子集上运行我们的建模过程，以获得模型质量的多种度量。
例如，我们可以将数据分成5个部分，每个部分占整个数据集的20%。在这种情况下，我们说我们已经把数据分成5个“折叠”。
然后，我们对每一次折叠进行一个实验:
- 在实验1中，我们使用第一个折fold 作为验证（或holdout）集，其他的作为训练数据。这为我们提供了一个基于20%验证集的模型质量的度量。
- 在实验2中，我们拿出来自第二次折fold 的数据(并且使用除第二次折叠之外的所有数据来训练模型)。然后使用验证集得到模型质量的第二次估计。
- 我们重复这个过程,使用每一个折fold 一次来作为验证。把这个放一起,100%的数据被用作验证在某种程度上,我们最终得到的模型质量,是基于所有的行数据集(即使我们不同时使用所有行)。
什么时候应该使用交叉验证?
交叉验证为模型质量提供了更准确的度量，如果您要做大量的建模决策，这一点尤其重要。但是，它可能需要更长的时间运行，因为它估计多个模型(每个折叠一个模型)。
因此，考虑到这些权衡，什么时候应该使用每种方法?
- 对于小型数据集，额外的计算负担不是什么大问题，您应该运行交叉验证。
- 对于较大的数据集，单个验证集就足够了。你的代码将运行得更快，并且你可能有足够的数据，因此几乎不需要为验证重用其中的一些数据。
对于什么是大数据集和什么是小数据集，没有简单的阈值。但是如果你的模型需要几分钟或更短的时间运行，那么切换到交叉验证可能是值得的。
或者，你可以运行交叉验证，看看每个实验的得分是否接近。如果每个实验都产生相同的结果，那么单个验证集可能就足够了。
Example
我们将使用与上一节相同的数据。我们在X中加载输入数据，在y中加载输出数据。
# Read the data
data = pd.read_csv('../input/melbourne-housing-snapshot/melb_data.csv')
# Select subset of predictors
cols_to_use = ['Rooms', 'Distance', 'Landsize', 'BuildingArea', 'YearBuilt']
X = data[cols_to_use]
# Select target
y = data.Price
然后，我们定义了一个管道，它使用一个imputer来填充缺失值，以及一个随机森林模型来进行预测。
虽然可以在不使用管道的情况下进行交叉验证，但这是相当困难的！使用管道将使代码非常简单。
from sklearn.ensemble import RandomForestRegressor
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
my_pipeline = Pipeline(steps=[('preprocessor', SimpleImputer()),
('model', RandomForestRegressor(n_estimators=50,
random_state=0))
])
我们使用scikit-learn中的cross_val_score()函数获得交叉验证分数。我们使用cv参数设置折叠数。
from sklearn.model_selection import cross_val_score
# Multiply by -1 since sklearn calculates *negative* MAE
scores = -1 * cross_val_score(my_pipeline, X, y,
cv=5,
scoring='neg_mean_absolute_error')
print("MAE scores:\n", scores)
output:
MAE scores:
[301628.7893587 303164.4782723 287298.331666 236061.84754543
260383.45111427]
scoring参数选择一个模型质量的度量来报告：在这种情况下，我们选择了负平均绝对误差(MAE)。scikit学习的文档显示了一个选项列表。
让人有点惊讶的是，我们指定的是负的MAE。Scikit-learn有一个惯例，即所有指标都被定义为较高的数字更好。虽然在其他地方几乎没有听说过负的MAE，但在这里使用负数可以使他们与这种惯例保持一致。
我们通常需要一个模型质量的单一度量来比较其他模型。我们取实验平均值。
print("Average MAE score (across experiments):")
print(scores.mean())
output:
Average MAE score (across experiments):
277707.3795913405
结论
使用交叉验证可以更好地度量模型质量，同时还可以清理代码：注意，我们不再需要跟踪单独的训练集和验证集。所以，特别是对于小型数据集，这是一个很好的改进!
Gradient boosting
下面，你将学习如何建立和优化梯度提升Gradient boosting模型。这种方法主导了许多Kaggle竞赛，并在各种数据集上获得了达到最高水准的结果。
对于本节的大部分内容，你已经使用随机森林方法进行了预测，该方法通过平均许多决策树的预测，比单一决策树获得了更好的性能。
我们将随机森林方法称为“集成方法ensemble methods”。根据定义，集成方法结合了几个模型的预测(例如，在随机森林的情况下，是几棵树)。
接下来，我们将学习另一种称为梯度增强的集成方法。、
梯度提升是一种通过循环迭代地将模型添加到集成中的方法。
它首先用一个模型初始化集合，这个模型的预测可能非常简单。(即使它的预测是非常不准确的，后续的添加将解决这些错误。)
然后，我们开始循环:
- 首先，我们使用当前集合为数据集中的每个观察结果生成预测。为了做出预测，我们将来自所有模型的预测添加到集合中。
- 这些预测被用来计算一个损失函数(比如平均平方误差)。
- 然后，我们使用损失函数拟合一个新的模型，将被添加到整体。具体地说，我们确定了模型的参数，以便将这个新模型加入到整体中可以减少损失。(旁注:“gradient boosting”中的“gradient”是指我们将对损耗函数使用梯度下降来确定新模型中的参数。)
- 最后，我们将新模型添加到集成ensemble中，并且…
- …重复!
Example
我们首先用X_train、X_valid、y_train和y_valid加载训练和验证数据。
mport pandas as pd
from sklearn.model_selection import train_test_split
# Read the data
data = pd.read_csv('../input/melbourne-housing-snapshot/melb_data.csv')
# Select subset of predictors
cols_to_use = ['Rooms', 'Distance', 'Landsize', 'BuildingArea', 'YearBuilt']
X = data[cols_to_use]
# Select target
y = data.Price
# Separate data into training and validation sets
X_train, X_valid, y_train, y_valid = train_test_split(X, y)
在本例中，我们将使用XGBoost库。XGBoost是极端梯度提升的缩写，它是梯度提升的一个实现，带有几个侧重于性能和速度的附加特性。(Scikit-learn有另一个版本的梯度提升，但XGBoost有一些技术优势。)
在下一个代码单元中，我们为XGBoost导入scikit-learn API (XGBoost . xgbregressor)。这使我们能够像在scikiti学习中一样建立并适合一个模型。正如你将在输出中看到的，XGBRegressor类有许多可调参数——你很快就会了解到这些参数!
from xgboost import XGBRegressor
my_model = XGBRegressor()
my_model.fit(X_train, y_train)
我们还对模型进行了预测和评估。
from sklearn.metrics import mean_absolute_error
predictions = my_model.predict(X_valid)
print("Mean Absolute Error: " + str(mean_absolute_error(predictions, y_valid)))
output:
Mean Absolute Error: 280355.04334039026
参数调整
XGBoost有几个参数可以极大地影响精度和训练速度。你应该了解的第一个参数是:
n_estimators
n_estimators指定经过上面描述的建模周期的次数。它等于我们在集合中包含的模型的数量。
- 过低的值会导致拟合不足，导致对训练数据和测试数据的预测都不准确。
- 过高的值会导致过拟合，这会导致对训练数据的准确预测，但对测试数据的预测不准确(这是我们所关心的)。
典型的值范围在100-1000之间，不过这很大程度上取决于下面讨论的learning_rate参数。
下面是用于设置集合中模型数量的代码:
my_model = XGBRegressor(n_estimators=500)
my_model.fit(X_train, y_train)
output:
[13:37:05] WARNING: /workspace/src/objective/regression_obj.cu:152: reg:linear is now deprecated in favor of reg:squarederror.
/opt/conda/lib/python3.6/site-packages/xgboost/core.py:587: FutureWarning: Series.base is deprecated and will be removed in a future version
if getattr(data, 'base', None) is not None and \
XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,
colsample_bynode=1, colsample_bytree=1, gamma=0,
importance_type='gain', learning_rate=0.1, max_delta_step=0,
max_depth=3, min_child_weight=1, missing=None, n_estimators=500,
n_jobs=1, nthread=None, objective='reg:linear', random_state=0,
reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,
silent=None, subsample=1, verbosity=1)
early_stopping_rounds
early_stopping_rounds提供了一种自动查找n_estimators的理想值的方法。当验证分数停止改进时，早期停止会导致模型停止迭代，即使对于n_estimators，我们并没有处于硬停止状态。明智的做法是为n_estimators设置一个较高的值，然后使用early_stopping_rounds来查找停止迭代的最佳时间。
由于偶然的机会有时会导致一轮验证分数没有提高，因此您需要指定一个数字，说明在停止之前允许多少轮直线恶化。设置early_stopping_rounds=5是一个合理的选择。在这种情况下，我们在连续5轮验证分数恶化后停止。
在使用early_stopping_rounds时，还需要留出一些数据来计算验证分数——这可以通过设置eval_set参数来完成。
我们可以修改上面的例子来包括早期停止:
my_model = XGBRegressor(n_estimators=500)
my_model.fit(X_train, y_train,
early_stopping_rounds=5,
eval_set=[(X_valid, y_valid)],
verbose=False)
output:
[13:37:07] WARNING: /workspace/src/objective/regression_obj.cu:152: reg:linear is now deprecated in favor of reg:squarederror.
XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,
colsample_bynode=1, colsample_bytree=1, gamma=0,
importance_type='gain', learning_rate=0.1, max_delta_step=0,
max_depth=3, min_child_weight=1, missing=None, n_estimators=500,
n_jobs=1, nthread=None, objective='reg:linear', random_state=0,
reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,
silent=None, subsample=1, verbosity=1)
如果你稍后希望用您的所有数据拟合一个模型，请将n_estimators设置为您在运行早期停止时发现的最优值。
learning_rate
我们可以将每个模型的预测乘以一个小的数字(称为学习率 learning rate)，然后再将它们相加，而不是简单地将每个组件模型的预测相加。
这意味着我们添加到集合中的每棵树帮助我们的都更少。因此，我们可以在不过拟合的情况下为n_estimators设置一个更高的值。如果我们使用早期停止，适当的树的数量将被自动确定。
一般来说，较小的学习率和大量的estimators将产生更准确的XGBoost模型，尽管它也将花费模型更长的时间来训练，因为它在周期中进行了更多的迭代。默认情况下，XGBoost设置learning_rate=0.1。
修改上面的例子来改变学习速率，会产生以下代码:
my_model = XGBRegressor(n_estimators=1000, learning_rate=0.05)
my_model.fit(X_train, y_train,
early_stopping_rounds=5,
eval_set=[(X_valid, y_valid)],
verbose=False)
output：
[13:37:08] WARNING: /workspace/src/objective/regression_obj.cu:152: reg:linear is now deprecated in favor of reg:squarederror.
XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,
colsample_bynode=1, colsample_bytree=1, gamma=0,
importance_type='gain', learning_rate=0.05, max_delta_step=0,
max_depth=3, min_child_weight=1, missing=None, n_estimators=1000,
n_jobs=1, nthread=None, objective='reg:linear', random_state=0,
reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,
silent=None, subsample=1, verbosity=1)
n_jobs
在需要考虑运行时的大型数据集上，可以使用并行性更快地构建模型。通常将参数n_jobs设置为机器上的核数。在较小的数据集上，这是没有帮助的。
最终的模型不会更好，所以对拟合时间的微优化通常只是分散注意力。但是，它在大型数据集中非常有用，否则在执行fit命令期间，你将花费很长时间等待。
下面是修改后的例子:
my_model = XGBRegressor(n_estimators=1000, learning_rate=0.05, n_jobs=4)
my_model.fit(X_train, y_train,
early_stopping_rounds=5,
eval_set=[(X_valid, y_valid)],
verbose=False)
结论
XGBoost是处理标准列表数据tabular data(存储在panda DataFrames中的数据类型，而不是图像和视频等更独特的数据类型)的领先软件库。通过仔细的参数调整，你可以训练高精度的模型。
Data leakage
在本节中，我们将了解什么是数据泄漏Data leakage（也就是因果关系的纰漏）以及如何防止它。如果你不知道如何防止它，leakage将经常出现，它会以一种敏感而危险的方式毁掉你的模型。这是数据科学家最重要的概念之一。
当训练数据包含有关目标的信息时，就会发生数据泄漏Data leakage(或泄漏leakage)，但当使用模型进行预测时，将无法获得类似的数据。这导致了训练集(甚至验证数据)的高性能，但是模型在生产中表现不佳。
换句话说，泄漏leakage导致模型看起来很准确，直到你开始使用该模型做出决策，然后该模型变得非常不准确。
泄漏leakage主要有两种类型:目标泄漏target leakage 和 训练-检验污染train-test contamination.。
Target leakage
当预测器包含在进行预测时不可用的数据时，就会发生目标泄漏。从数据可用的时间或时间顺序来考虑目标泄漏是很重要的，而不仅仅是考虑某个特性是否有助于做出良好的预测。
举个例子会很有帮助。假设你想预测谁会患上肺炎。原始数据的前几行是这样的:
| got_pneumonia | age | weight | male | took_antibiotic_medicine | … |
|---|---|---|---|---|---|
| False | 65 | 100 | False | False | … |
| False | 72 | 130 | True | False | … |
| True | 58 | 100 | False | True | … |
人们在肺炎后服用抗生素药物以恢复健康。原始数据显示，这些列之间存在很强的关系，但在got_pneumonia的值确定后，took_antibiotic tic_medicine经常会被更改。这就是目标泄漏。
这个模型会发现，抗生素药物值为假的人没有患肺炎。由于验证数据与训练数据来自相同的来源，因此模式将在验证中重复，并且模型将获得很好的验证(或交叉验证)分数。
但是这个模型在随后的实际应用中会非常不准确，因为当我们需要预测他们未来的健康状况时，即使是那些会得肺炎的病人也不会接受抗生素治疗。
为了防止这种类型的数据泄漏，应该排除目标值实现后更新(或创建)的任何变量。
Train-Test Contamination
如果不小心区分培训数据和验证数据，则会发生另一种类型的泄漏。
回想一下，验证是对模型如何处理之前没有考虑到的数据的一种度量。如果验证数据影响预处理行为，就可能以微妙的方式破坏这个过程。这有时被称为Train-Test Contamination
例如，假设您在调用train_test_split()之前运行预处理(比如为缺失的值匹配imputer)。你的模型可能获得良好的验证分数，这给了你很大的信心，但是当你部署它来做决策时，它的表现很差。
毕竟，你将来自验证或测试数据的数据合并到进行预测的方式中，所以即使不能泛化到新数据，也可以很好地处理特定数据。当你进行更复杂的特性工程时，这个问题会变得更加敏感(也更加危险)。
如果你的验证是基于简单的train_test_split，请从任何类型的拟合fitting中排除验证数据，包括预处理步骤的拟合fitting。如果你使用scikit-learn pipelines，这将更容易。在使用交叉验证时，更重要的是在管道中进行预处理!
Example
在这个示例中，我们将学习一种检测和消除目标泄漏的方法。
我们将使用关于信用卡应用程序的数据集，并跳过基本的数据设置代码。最终结果是，关于每个信用卡应用程序的信息存储在一个DataFrame X 中。我们将使用它来预测哪些应用程序在系列y中被接受。
import pandas as pd
# Read the data
data = pd.read_csv('../input/aer-credit-card-data/AER_credit_card_data.csv',
true_values = ['yes'], false_values = ['no'])
# Select target
y = data.card
# Select predictors
X = data.drop(['card'], axis=1)
print("Number of rows in the dataset:", X.shape[0])
X.head()
output:
Number of rows in the dataset: 1319
reports age income share expenditure owner selfemp dependents months majorcards active
0 0 37.66667 4.5200 0.033270 124.983300 True False 3 54 1 12
1 0 33.25000 2.4200 0.005217 9.854167 False False 3 34 1 13
2 0 33.66667 4.5000 0.004156 15.000000 True False 4 58 1 5
3 0 30.50000 2.5400 0.065214 137.869200 False False 0 25 1 7
4 0 32.16667 9.7867 0.067051 546.503300 True False 2 64 1 5
由于这是一个小数据集，我们将使用交叉验证来确保模型质量的准确度量。
from sklearn.pipeline import make_pipeline
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
# Since there is no preprocessing, we don't need a pipeline (used anyway as best practice!)
my_pipeline = make_pipeline(RandomForestClassifier(n_estimators=100))
cv_scores = cross_val_score(my_pipeline, X, y,
cv=5,
scoring='accuracy')
print("Cross-validation accuracy: %f" % cv_scores.mean())
outpu:
Cross-validation accuracy: 0.979525
根据经验，你会发现很难找到准确率达到98%的模型。这种情况时有发生，但并不常见，所以我们应该更仔细地检查数据，以防目标泄漏。
这里是数据的summary，你也可以在data选项卡下找到:
- card: 1 if credit card application accepted, 0 if not如接受信用卡申请，请填写1，如不接受，请填写0
- reports: Number of major derogatory reports主要贬损报告的数目
- age: Age n years plus twelfths of a year年龄n岁加上一年的十二分之一
- income: Yearly income (divided by 10,000)年收入(除以10000)
- share: Ratio of monthly credit card expenditure to yearly income每月信用卡支出与年收入的比率
- expenditure: Average monthly credit card expenditure平均每月信用卡支出
- owner: 1 if owns home, 0 if rents拥有房屋为1，出租房屋为0
- selfempl: 1 if self-employed, 0 if not个体户1个，不个体户0个
- dependents: 1 + number of dependents 1+受抚养人数
- months: Months living at current address住在当前地址的几个月
- majorcards: Number of major credit cards held持有的主要信用卡数量
- active: Number of active credit accounts有效信用帐户数目
一些变量看起来可疑。例如，支出expenditur是指在这张卡上的支出，还是在申请前使用的卡上的支出?
在这一点上，基本的数据比较是非常有用的：
expenditures_cardholders = X.expenditure[y]
expenditures_noncardholders = X.expenditure[~y]
print('Fraction of those who did not receive a card and had no expenditures: %.2f' \
%((expenditures_noncardholders == 0).mean()))
print('Fraction of those who received a card and had no expenditures: %.2f' \
%(( expenditures_cardholders == 0).mean()))
outpu：
Fraction of those who did not receive a card and had no expenditures: 1.00
Fraction of those who received a card and had no expenditures: 0.02
如上所示，没有收到信用卡的人没有支出，而收到信用卡的人中只有2%没有支出。我们的模型似乎具有很高的准确性，这并不奇怪。但这似乎也是一个目标泄漏的案例，其中支出可能意味着支出在他们申请的卡上。
由于share部分由expenditure决定，因此也应将其排除在外。变量active和majorcard不太清楚，但从描述来看，它们听起来有关。在大多数情况下，如果你不能追踪到创建数据的人来找出更多信息，安全总比遗憾好。
我们将运行一个没有目标泄漏的模型如下：
# Drop leaky predictors from dataset
potential_leaks = ['expenditure', 'share', 'active', 'majorcards']
X2 = X.drop(potential_leaks, axis=1)
# Evaluate the model with leaky predictors removed
cv_scores = cross_val_score(my_pipeline, X2, y,
cv=5,
scoring='accuracy')
print("Cross-val accuracy: %f" % cv_scores.mean())
output：
Cross-val accuracy: 0.830924
这个准确度要低得多，可能会让人失望。然而，在新应用程序上使用时，我们可以期望它在80%的情况下是正确的，而泄露的模型可能会做得更糟(尽管它在交叉验证方面的明显得分更高)。
结论
在许多数据科学应用程序中，数据泄漏可能造成数百万美元的损失。将培训数据和验证数据仔细地分离可以防止 train-test contamination，管道可以帮助实现这种分离。同样，谨慎、常识和数据探索的结合可以帮助识别目标泄漏。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
