songyp0505

songyp0505'Blog

0%

Intro and intermediate Machine Learning 课程总结

发表于 更新于 分类于

回顾一下Kaggle里两个简短的入门课程里用到的东西

Intro to Machine Learning

基础探索：

1
2
describe() #描述每一列的计数、均值、标准差等数据
head() #列出前X行的数据

建立第一个模型：

1
2
3
4
5
6
7
8
9
10
from sklearn.tree import Dmelbourne_model.predict(X.head()ecisionTreeRegressor

# Define model. Specify a number for random_state to ensure same results each run
melbourne_model = DecisionTreeRegressor(random_state=1)

# Fit model
melbourne_model.fit(X, y) 

#predict data
melbourne_model.predict(X.head()

这里用的是一个决策树模型，指定random_state的数字是为了在模型初始化时确定好模型内的参数，从而使得每次使用相同的random_state运行模型时都可以得到相同的结果。

通常model.fit()里的参数都是训练集，而model.predict()里的参数则是验证集或测试集。

模型验证：

1
2
3
4
from sklearn.metrics import mean_absolute_error

predicted_home_prices = melbourne_model.predict(X)
mean_absolute_error(y, predicted_home_prices)

mean_absolute_error则为平均绝对值误差，即对所有项进行预测值与实际值求差后的平方和的均值。

决策树VS随机森林：

决策树单一，随机森林由多个决策树组成，且随机挑选特征

Intermediate Machine Learning

缺失值处理：

  1. 舍弃存在缺失值的列

  2. 插值：如在数值列中将空缺数据的表格填上指定的数值。

  3. 高级插值：通过均值、最大值、最小值等数据进行综合决定

1
2
#确定存在缺失值的列名
cols_with_missing = [col for col in X.columns if X[col].isnull().any()]
1
2
3
4
5
6
7
#快速插值
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))

类别变量：

  1. 舍弃存在类别变量的列

  2. 序数编码

    1. 把为数不多的类别型变量按顺序排列，根据权重或顺序等方式确定每个变量的数值

  3. One_Hot编码

1
2
3
#确定哪一列是类别型变量：
s = (X.dtypes == 'object')
object_cols = list(s[s].index)

如果一个列中有文本，那么这一列的dtype就会是object

1
2
3
4
5
6
7
8
9
10
from sklearn.preprocessing import OrdinalEncoder

# Make copy to avoid changing original data 
label_X_train = X_train.copy()
label_X_valid = X_valid.copy()

# Apply ordinal encoder to each column with categorical data
ordinal_encoder = OrdinalEncoder()
label_X_train[object_cols] = ordinal_encoder.fit_transform(X_train[object_cols])
label_X_valid[object_cols] = ordinal_encoder.transform(X_valid[object_cols])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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[object_cols]))
OH_cols_valid = pd.DataFrame(OH_encoder.transform(X_valid[object_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)

管道整合

在对整体数据的特征把握清楚后，可以对数据处理的步骤进行整合

1.管道的步骤

  • 对数值型数据列进行缺失值处理

  • 对类别型数据列进行One—Hot编码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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.定义模型

1
2
3
from sklearn.ensemble import RandomForestRegressor

model = RandomForestRegressor(n_estimators=100, random_state=0)

3.整合上述工作到管道中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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)

交叉验证

由于采用交叉验证需要进行额外步骤，所以会对计算机产生额外负担，当数据量较大时尽量不采用交叉验证。并且当数据量较大时训练集和验证集的数据划分时已经有了较大的随机性

验证步骤：

  1. 将验证集平均划分为不同的子集

  2. 选其中一个子集为训练集，其余子集为验证集

  3. 除第二步中的子集以外选择一个子集为训练集，其余子集（包含第二步）为验证集

  4. 重复第三步，直至所有子集均被作为训练集录入模型。

1
2
3
4
5
6
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')

“调参侠”XGBoost

XGBoost是一个开源软件库，它为 C++、Java、Python、 R和Julia提供了一个梯度提升框架，适用于Linux、Windows和 mac os。根据项目的描述，它的目的在于提供一个”可扩展、可移植和分布式梯度提升(GBM、GBRT、GBDT)库“。

调用：

1
2
3
4
from xgboost import XGBRegressor

my_model = XGBRegressor()
my_model.fit(X_train, y_train)

调参：

n_estimators： 指定经过建模周期的次数。它等于我们在集成中包含的模型数量。太小会欠拟合，太大会过拟合，默认在100-1000

early_stopping_rounds： 指定验证分数在多少轮没有提升时停止训练

learning_rate： 我们可以将每个模型的预测乘以一个小数（称为学习率），然后再将它们相加，而不是通过简单地将每个组件模型的预测相加来获得预测。一般来说，小的学习率和大的n_estimators会产生更准确的 XGBoost 模型，尽管它也会花费更长的时间来训练模型，因为它在整个循环中进行了更多的迭代。默认情况下，XGBoost 设置 learning_rate=0.1

n_jobs: 在考虑运行时间的较大数据集上，可以使用并行更快地构建模型。通常将参数 n_jobs 设置为机器上的内核数。在较小的数据集上，这无济于事。