使用 Optuna 优化你的优化器

磐创AI

发布于 2021-10-27 08:08:59

2.7K00

代码可运行

文章被收录于专栏：磐创AI技术团队的专栏磐创AI技术团队的专栏

运行总次数：0

代码可运行

磐创AI分享

作者 | Sion

编译 | Flin

来源 | analyticsvidhya

介绍

Optuna 是一个最先进的自动超参数调整框架，完全用 Python 编写。在过去的 2 年里，Kaggle社区一直在广泛使用它，具有巨大的竞争力。在本文中，我们将有一个实际操作的方法，并了解它的工作原理。

什么是Optuna？

Optuna 是一个自动超参数调优软件框架，专为机器学习而设计，可以与 PyTorch、TensorFlow、Keras、SKlearn 等其他框架一起使用。

Optuna 使用一种称为运行定义 API 的东西，它帮助用户编写高度模块化的代码并动态构建超参数的搜索空间，我们将在本文后面学习。

使用网格搜索、随机、贝叶斯和进化算法等不同的采样器来自动找到最佳参数。让我们简要讨论一下 Optuna 中可用的不同采样器。

网格搜索：搜索目标算法整个超参数空间的预定子集。
贝叶斯：此方法使用概率分布为每个超参数选择一个值。
随机搜索：顾名思义，对搜索空间进行随机采样，直到满足停止条件。
进化算法：适应度函数用于找到超参数的值。

但是是什么让它在 Kaggler 中如此受欢迎呢？

以下是他们在网站上提到的主要功能：

1） 轻量级和多功能：需要一个简单的安装，然后你就可以开始了。可以处理广泛的任务并找到最佳的替代方案。

2) 渴望搜索空间：使用熟悉的 Pythonic 语法（如条件和循环）来自动搜索最佳超参数。

3）最先进的算法：快速搜索大空间，并更快地剪枝没有希望的试验，以获得更好、更快的结果。

4) 轻松并行化：可以轻松地并行化超参数搜索，而对原始代码几乎没有更改。

5）快速可视化：各种可视化功能也可用于可视化分析优化结果。

在开始本教程之前，我们必须了解一些 Optuna 术语和约定。

Optuna 术语

在 Optuna 中，有两个主要术语，即：

1) Study：整个优化过程基于一个目标函数，即研究需要一个可以优化的函数。

2) Trial：优化函数的单次执行称为trial。因此，这项研究(Study)是一系列试验(trial)。

将使用 Optuna 的数据集

在本文中，我们将使用来自ASHRAE – Great Energy Predictor III的数据集，这是一项 Kaggle 竞赛，用于预测建筑物消耗的能源量。数据集的大小为 2.5 Gb，因此非常大。

为了便于使用，数据被分成几个文件。为了训练我们的模型，我们提供了train.csv、weather_train.csv和building_metadata.csv。

除此之外，我们还有一些 trs.csv 文件。以下是文件的简要说明以及显示的列。

加载库

import gc
import os
from pathlib import Path
import random
import sys

from tqdm import tqdm_notebook as tqdm
import numpy as np # linear algebra
import pandas as pd # data processing

import matplotlib.pyplot as plt
import seaborn as sns

from IPython.core.display import display, HTML

# --- plotly ---
from plotly import tools, subplots
import plotly.offline as py
py.init_notebook_mode(connected=True)
import plotly.graph_objs as go
import plotly.express as px
import plotly.figure_factory as ff

# --- models ---
from sklearn import preprocessing
from sklearn.model_selection import KFold
import lightgbm as lgb
import xgboost as xgb
import catboost as cb

读取数据

%%time

# Read data...
root = '../input/ashrae-energy-prediction'

train_df = pd.read_csv(os.path.join(root, 'train.csv'))
weather_train_df = pd.read_csv(os.path.join(root, 'weather_train.csv'))
test_df = pd.read_csv(os.path.join(root, 'test.csv'))
weather_test_df = pd.read_csv(os.path.join(root, 'weather_test.csv'))
building_meta_df = pd.read_csv(os.path.join(root, 'building_metadata.csv'))
sample_submission = pd.read_csv(os.path.join(root, 'sample_submission.csv'))

数据预处理

我们本次比赛的目标是预测建筑物的能源消耗。我们必须预测的 4 种能量类型是：

标签	能量类型
0	电
1	冷冻水
2	蒸汽
3	热水

电和水的消耗量可能会有所不同，并且具有不同的预测因素。所以我分别训练和预测了模型。

删除奇怪的数据

train_df['date'] = train_df['timestamp'].dt.date
train_df['meter_reading_log1p'] = np.log1p(train_df['meter_reading'])

def plot_date_usage(train_df, meter=0, building_id=0):
    train_temp_df = train_df[train_df['meter'] == meter]
    train_temp_df = train_temp_df[train_temp_df['building_id'] == building_id]    
    train_temp_df_meter = train_temp_df.groupby('date')['meter_reading_log1p'].sum()
    train_temp_df_meter = train_temp_df_meter.to_frame().reset_index()
    fig = px.line(train_temp_df_meter, x='date', y='meter_reading_log1p')
    fig.show()

plot_date_usage(train_df, meter=0, building_id=0)

如你所见，2016 年 5 月中旬之前的数据看起来很奇怪，因为它位于图表的底部。这样做的原因是直到 5 月 20 日，对于site_id == 0 的所有电表读数都是0。一位与会者指出了这一点。因此，合乎逻辑的做法是删除该数据段。

building_meta_df[building_meta_df.site_id == 0]

因此我们可以看到所有带有site_id == 0的条目都有building_id <= 104。现在我们删除它们：

train_df = train_df.query('not (building_id <= 104 & meter == 0 & timestamp <= "2016-05-20")')

添加时间功能

我们可以使用时间戳特性来获得更好的特征。

def preprocess(df):
    df["hour"] = df["timestamp"].dt.hour
    df["month"] = df["timestamp"].dt.month
    df["dayofweek"] = df["timestamp"].dt.dayofweek
    df["weekend"] = df["dayofweek"] >= 5

preprocess(train_df)

df_group = train_df.groupby(['building_id', 'meter'])['meter_reading_log1p']
building_mean = df_group.mean().astype(np.float16)
building_median = df_group.median().astype(np.float16)
building_min = df_group.min().astype(np.float16)
building_max = df_group.max().astype(np.float16)
building_std = df_group.std().astype(np.float16)

building_stats_df = pd.concat([building_mean, building_median, building_min, building_max, building_std], axis=1,
                              keys=['building_mean', 'building_median', 'building_min', 'building_max', 'building_std']).reset_index()
train_df = pd.merge(train_df, building_stats_df, on=['building_id', 'meter'], how='left', copy=False)

train_df.head()

（注意：以上代码段中未包含所有列）

填充 NaN 值

天气数据有很多NaN 值，所以我们不能直接去掉条目。我们将尝试通过插入数据来填充这些值。

weather_train_df.head()

（注意：以上代码段中未包含所有列）

weather_train_df.isna().sum()

weather_test_df = pd.read_feather(root/'weather_test.feather')
weather = pd.concat([weather_train_df, weather_test_df],ignore_index=True)
del weather_test_df
weather_key = ['site_id', 'timestamp']

temp_skeleton = weather[weather_key + ['air_temperature']].drop_duplicates(subset=weather_key).sort_values(by=weather_key).copy()

temp_skeleton['temp_rank'] = temp_skeleton.groupby(['site_id', temp_skeleton.timestamp.dt.date])['air_temperature'].rank('average')

df_2d = temp_skeleton.groupby(['site_id', temp_skeleton.timestamp.dt.hour])['temp_rank'].mean().unstack(level=1)

site_ids_offsets = pd.Series(df_2d.values.argmax(axis=1) - 14)
site_ids_offsets.index.name = 'site_id'

def timestamp_align(df):
    df['offset'] = df.site_id.map(site_ids_offsets)
    df['timestamp_aligned'] = (df.timestamp - pd.to_timedelta(df.offset, unit='H'))
    df['timestamp'] = df['timestamp_aligned']
    del df['timestamp_aligned']
    return df

del weather
del temp_skeleton
gc.collect()

weather_train_df = timestamp_align(weather_train_df)
weather_train_df = weather_train_df.groupby('site_id').apply(lambda group: group.interpolate(limit_direction='both'))

现在，我们数据集中的 NaN 值数量已显着减少。

添加滞后

def add_lag_feature(weather_df, window=3):
    group_df = weather_df.groupby('site_id')
    c = ['dew_temperature', 'cloud_coverage', 'precip_depth_1_hr', 'air_temperature', 'sea_level_pressure', 'wind_direction', 'wind_speed']
    cols = c
    rolled = group_df[cols].rolling(window=window, min_periods=0)
    lag_mean = rolled.mean().reset_index().astype(np.float16)
    lag_max = rolled.max().reset_index().astype(np.float16)
    lag_min = rolled.min().reset_index().astype(np.float16)
    lag_std = rolled.std().reset_index().astype(np.float16)
    for col in cols:
        weather_df[f'{col}_mean_lag{window}'] = lag_mean[col]
        weather_df[f'{col}_max_lag{window}'] = lag_max[col]
        weather_df[f'{col}_min_lag{window}'] = lag_min[col]
        weather_df[f'{col}_std_lag{window}'] = lag_std[col]

add_lag_feature(weather_train_df, window=3)
add_lag_feature(weather_train_df, window=72)

现在，加入滞后，我们将对primary_use列进行分类，以减少合并时的内存:

primary_use_list = building_meta_df['primary_use'].unique()
primary_use_dict = {key: value for value, key in enumerate(primary_use_list)} 
print('primary_use_dict: ', primary_use_dict)
building_meta_df['primary_use'] = building_meta_df['primary_use'].map(primary_use_dict)

gc.collect()

使用 Optuna 进行模型训练

在本节中，我们将学习如何使用 Optuna。但首先，让我们将列分为分类值和数字特征。

category_columns = ['building_id', 'site_id', 'primary_use']
weather_columns = [
    'air_temperature', 'cloud_coverage',
    'dew_temperature', 'precip_depth_1_hr', 'sea_level_pressure',
    'wind_direction', 'wind_speed', 'air_temperature_mean_lag72',
    'air_temperature_max_lag72', 'air_temperature_min_lag72',
    'air_temperature_std_lag72', 'cloud_coverage_mean_lag72',
    'dew_temperature_mean_lag72', 'precip_depth_1_hr_mean_lag72',
    'sea_level_pressure_mean_lag72', 'wind_direction_mean_lag72',
    'wind_speed_mean_lag72', 'air_temperature_mean_lag3',
    'air_temperature_max_lag3',
    'air_temperature_min_lag3', 'cloud_coverage_mean_lag3',
    'dew_temperature_mean_lag3',
    'precip_depth_1_hr_mean_lag3', 'sea_level_pressure_mean_lag3',
    'wind_direction_mean_lag3', 'wind_speed_mean_lag3']
feature_columns = ['square_feet', 'year_built'] + [
    'hour', 'weekend', 'dayofweek', # 'month'
    'building_median'] + weather_cols

def create_X_y(train_df, target_meter):
    target_train_df = train_df[train_df['meter'] == target_meter]
    target_train_df = target_train_df.merge(building_meta_df, on='building_id', how='left')
    target_train_df = target_train_df.merge(weather_train_df, on=['site_id', 'timestamp'], how='left')
    X_train = target_train_df[feature_cols + category_cols]
    y_train = target_train_df['meter_reading_log1p'].values

    del target_train_df
    return X_train, y_train

定义 “目标”函数

使用 Optuna 完成的每个超参数调整项目都从一个目标函数开始，我们必须在其中决定优化所依据的指标。

一个试验对象是一个目标函数的输入，并返回一个分数。

def objective(trial, ...):
    # calculate score...
    return score

现在我们将为电表训练 LightGBM 模型，获得最佳验证分数并将该分数作为最终分数返回。让我们开始！

import optuna
from optuna import Trial

debug = False

train_df_original = train_df
# Only using 10000 data,,, for fast computation for debugging.
train_df = train_df.sample(10000)

def objective(trial: Trial, fast_check=True, target_meter=0, return_info=False):
    folds = 5
    seed = 666
    shuffle = False
    kf = KFold(n_splits=folds, shuffle=shuffle, random_state=seed)
    X_train, y_train = create_X_y(train_df, target_meter=target_meter)
    y_valid_pred_total = np.zeros(X_train.shape[0])
    gc.collect()
    print('target_meter', target_meter, X_train.shape)
    L = [X_train.columns.get_loc(cat_col) for cat_col in category_cols]
    categorical_features = L
    print('cat_features', categorical_features)
    models = []
    valid_score = 0
    for train_idx, valid_idx in kf.split(X_train, y_train):
        train_data = X_train.iloc[train_idx,:], y_train[train_idx]
        valid_data = X_train.iloc[valid_idx,:], y_train[valid_idx]
        print('train', len(train_idx), 'valid', len(valid_idx))
        a, b, c = fit_lgbm(trial, train_data, valid_data, cat_features=category_cols,
                                            num_rounds=1000)
        model, y_pred_valid, log = a, b, c
        y_valid_pred_total[valid_idx] = y_pred_valid
        models.append(model)
        gc.collect()
        valid_score += log["valid/l2"]
        if fast_check:
            break
    valid_score /= len(models)
    if return_info:
        return valid_score, models, y_pred_valid, y_train
    else:
        return valid_score

该fit_lgbm函数具有核心训练码，并定义了超参数。

接下来，我们将熟悉“trial” 模块的内部工作原理。

使用“trial”模块动态定义超参数

这是使用 Optuna 代码与传统定义并运行代码之间的比较：

这是Define-by-run 的优势。这使得用户更容易编写直观的代码来获取超参数，而不是预先定义整个搜索空间。

你可以使用这些方法来获取超参数：

# Categorical parameter
optimizer = trial.suggest_categorical('optimizer', ['MomentumSGD', 'Adam'])

# Int parameter
num_layers = trial.suggest_int('num_layers', 1, 3)

# Uniform parameter
dropout_rate = trial.suggest_uniform('dropout_rate', 0.0, 1.0)

# Loguniform parameter
learning_rate = trial.suggest_loguniform('learning_rate', 1e-5, 1e-2)

# Discrete-uniform parameter
drop_path_rate = trial.suggest_discrete_uniform('drop_path_rate', 0.0, 1.0, 0.1)

现在让我们创建一个简单的 Lightgbm 模型：

def fit_lgbm(trial, train, val, devices=(-1,), seed=None, cat_features=None, num_rounds=1500):
    """Train Light GBM model"""
    X_train, y_train = train
    X_valid, y_valid = val
    metric = 'l2'
    params = {
        'num_leaves': trial.suggest_int('num_leaves', 2, 256),
        'objective': 'regression',
        'max_depth': -1,
        'learning_rate': 0.1,
        "boosting": "gbdt",
        'lambda_l1': trial.suggest_loguniform('lambda_l1', 1e-8, 10.0),
        'lambda_l2': trial.suggest_loguniform('lambda_l2', 1e-8, 10.0),
        "bagging_freq": 5,
        "bagging_fraction": trial.suggest_uniform('bagging_fraction', 0.1, 1.0),
        "feature_fraction": trial.suggest_uniform('feature_fraction', 0.4, 1.0),
        "metric": metric,
        "verbosity": -1,
    }
    device = devices[0]
    if device == -1:
        # use cpu
        pass
    else:
        # use gpu
        print(f'using gpu device_id {device}...')
        params.update({'device': 'gpu', 'gpu_device_id': device})

    params['seed'] = seed

    early_stop = 20
    verbose_eval = 20

    d_train = lgb.Dataset(X_train, label=y_train, categorical_feature=cat_features)
    d_valid = lgb.Dataset(X_valid, label=y_valid, categorical_feature=cat_features)
    watchlist = [d_train, d_valid]

    print('training LGB:')
    model = lgb.train(params,
                      train_set=d_train,
                      num_boost_round=num_rounds,
                      valid_sets=watchlist,
                      verbose_eval=verbose_eval,
                      early_stopping_rounds=early_stop)

    # predictions
    y_pred_valid = model.predict(X_valid, num_iteration=model.best_iteration)

    print('best_score', model.best_score)
    log = {'train/l2': model.best_score['training']['l2'],
           'valid/l2': model.best_score['valid_1']['l2']}
    return model, y_pred_valid, log

现在是优化的时候了！

做“学习”，优化！

在使用“trial”模块定义目标函数并找到超参数后，我们都准备好进行调整了。

只需 2 行代码，所有的超参数调优就可以完成了!

study = optuna.create_study()
study.optimize(objective, n_trials=10)

由于 n_trials 的值为 10，因此输出相当大。因此，在下面的屏幕截图中，我将只包括最后一次试验：

就是这样！！你的超参数已调整！！

“trial”与“Study”：总结

Trial通过指定超参数的一次试验来管理模型训练、评估和获得分数的所有单次执行。

Study管理并记录所有已执行的试验。该记录帮助我们了解最佳超参数并建议下一个要搜索的参数空间。

剪枝以加快搜索

optuna 中，有一种先进而有用的技术是对那些没有希望的试验进行剪枝。

对于那些不熟悉什么是剪枝的人来说，它是一种在 ML 搜索算法中压缩数据的技术，它通过消除冗余和不重要的数据来对实例进行分类来减小决策树的大小。

因此剪枝可以提高最终分类器的复杂性并防止过度拟合。Optuna 中提供了对多个流行 ML 框架的集成，用户可以使用它在超参数训练期间尝试剪枝。例子：

XGBoost：optuna.integration.XGBoostPruningCallback
LightGBM：optuna.integration.LightGBMPruningCallback
Chainer：optuna.integration.ChainerPruningExtension
keras：optuna.integration.KerasPruningCallback
TensorFlow optuna.integration.TensorFlowPruningHook
keras optuna.integration.TFKerasPruningCallback
MXNet optuna.integration.MXNetPruningCallback

你可以在此处详细了解这些集成：https://optuna.readthedocs.io/en/stable/reference/integration.html

这是一个使用剪枝创建目标函数的简单示例：

def objective_with_prune(trial: Trial, fast_check=True, target_meter=0):
    folds = 5
    seed = 666
    shuffle = False
    kf = KFold(n_splits=folds, shuffle=shuffle, random_state=seed)

    X_train, y_train = create_X_y(train_df, target_meter=target_meter)
    y_valid_pred_total = np.zeros(X_train.shape[0])
    gc.collect()
    print('target_meter', target_meter, X_train.shape)
    x = [X_train.columns.get_loc(cat_col) for cat_col in category_cols]
    cat_features = x
    print('cat_features', cat_features)

    models0 = []
    valid_score = 0
    for train_idx, valid_idx in kf.split(X_train, y_train):
        train_data = X_train.iloc[train_idx,:], y_train[train_idx]
        valid_data = X_train.iloc[valid_idx,:], y_train[valid_idx]

        print('train', len(train_idx), 'valid', len(valid_idx))
        model, y_pred_valid, log = fit_lgbm_with_pruning(trial, train_data, valid_data, cat_features=category_cols,
                                                         num_rounds=1000)
        y_valid_pred_total[valid_idx] = y_pred_valid
        models0.append(model)
        gc.collect()
        valid_score += log["valid/l2"]
        if fast_check:
            break
    valid_score /= len(models0)
    return valid_score

使用 Optuna 进行可视化

Optuna 为我们提供了可视化训练和研究历史的选项，以确定具有最佳性能的超参数。最棒的是，所有这些可视化只需要 1 行代码！

优化历史

optuna.visualization.plot_optimization_history(study)

剪枝历史

optuna.visualization.plot_intermediate_values(study)

所有不同的颜色都显示了每次试验的损失曲线。

切片图

optuna.visualization.plot_slice(study)

等高线图

以目标值作为轮廓绘制参数对。

optuna.visualization.plot_contour(study)

平行坐标图

optuna.visualization.plot_parallel_coordinate(study)

尾注

本文只是熟悉Optuna的开始，涵盖了有关如何调整 ML 模型的超参数的大部分基础知识。我们学习了 Optuna 库中使用的术语，如trial和Study。我们还学习了如何定义使用 Optuna 调整所必需的目标函数。

接下来，我们讨论并研究了一些高级概念，例如剪枝，这也是 Optuna 的最佳功能之一。然后我们学习了如何使用 Optuna 的可视化并使用它们来评估和选择最佳超参数。

参考

数据集 – https://www.kaggle.com/c/ashrae-energy-prediction/overview

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2021-10-24，如有侵权请联系 cloudcommunity@tencent.com 删除

keras

tensorflow

本文分享自磐创AI 微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

keras

tensorflow

登录后参与评论

暂无评论