【ML&DL学习】6 tf keras regression hp search sklearn

超参数搜索

搜索策略：

• 网格搜索
• 随机搜索
• 遗传算法搜索
• 启发式搜索
  
  
  
  

手动搜索 learning rate

# learning_rate: [1e-4, 3e-4, 1e-3, 3e-3, 1e-2, 3e-2]
# W = W + grad * learning_rate
# 定义learning rate集合
learning_rates = [1e-4, 3e-4, 1e-3, 3e-3, 1e-2, 3e-2]
# 保存每个模型对应的history
histories = []
# 对于每一个学习率 都需要定义一个模型 去学习
for lr in learning_rates:
    model = keras.models.Sequential([
        keras.layers.Dense(30, activation='relu',
                           input_shape=x_train.shape[1:]),
        keras.layers.Dense(1),
    ])
    # 初始化 optimizer的学习率，使用我们定义的学习率
    optimizer = keras.optimizers.SGD(lr)
    # 使用定义的 optimizer
    model.compile(loss="mean_squared_error", optimizer=optimizer)
    callbacks = [keras.callbacks.EarlyStopping(
        patience=5, min_delta=1e-2)]
    # 模型训练
    history = model.fit(x_train_scaled, y_train,
                        validation_data = (x_valid_scaled, y_valid),
                        epochs = 100,
                        callbacks = callbacks)
    # 保存每个模型对应的history
    histories.append(history)

学习曲线和learning rate

def plot_learning_curves(history):
    pd.DataFrame(history.history).plot(figsize=(8, 5))
    plt.grid(True)
    plt.gca().set_ylim(0, 1)
    plt.show()
# 打印每个模型 
for lr, history in zip(learning_rates, histories):
    print("Learning rate: ", lr)
    plot_learning_curves(history)

可以发现，0.003的训练效果比较好，对于最后一个0.03，对应的值爆炸了，不适应这个模型。学习率如果比较小，训练的速度会比较慢，如果学习率比较合适的话，训练可以达到比较小的值。

我们上面定义的lr是不会变化的，而随着模型的训练，这个lr可以按照一定的策略取衰减的。

综上，自己实现超参数搜索的话，有两个缺点：

• 超参数的搜索不单单只是lr的搜索，还有很多其他超参数的搜索，随之使用的for循环会很多。
• 使用for循环进行训练，模型只能等上一个模型训练完之后才可以开始训练，没有一个并行化的处理

我们可以使用sklearn实现超参数搜索

sklearn实现超参数搜索

# RandomizedSearchCV
# 1. tf kears转化为sklearn的model
# 2. 定义参数集合
# 3. 使用RandomizedSearchCV搜索参数

# 定义build_fn
def build_model(hidden_layers = 1,
                layer_size = 30,
                learning_rate = 3e-3):
    # 定义一个model
    model = keras.models.Sequential()
    # 添加全连接层
    model.add(keras.layers.Dense(layer_size, activation='relu',
                                 input_shape=x_train.shape[1:]))
    # 上面与下面要分开 第一层隐含层涉及输入的shape
    #其他隐含层不需要，是第一层的输出
    # 添加hidden_layers - 1个全连接层
    for _ in range(hidden_layers - 1):
        model.add(keras.layers.Dense(layer_size,
                                     activation = 'relu'))
    # 添加输出层
    model.add(keras.layers.Dense(1))
    # 定义optimizer
    optimizer = keras.optimizers.SGD(learning_rate)
    model.compile(loss = 'mse', optimizer = optimizer)
    return model
# 转成sklearn模型
sklearn_model = keras.wrappers.scikit_learn.KerasRegressor(
    build_fn = build_model)
callbacks = [keras.callbacks.EarlyStopping(patience=5, min_delta=1e-2)]
history = sklearn_model.fit(x_train_scaled, y_train,
                            epochs = 100,
                            validation_data = (x_valid_scaled, y_valid),
                            callbacks = callbacks)

使用kerasRegressor 讲tf kears转化为sklearn的model


分类模型可以使用 KerasClassifier

训练到26次损失值变化比较小，就提前结束了

学习曲线

使用RandomizedSearchCV搜索参数

from scipy.stats import reciprocal
# f(x) = 1/(x*log(b/a)) a <= x <= b
# 定义超参数集合
param_distribution = {
	# hidden_layers 层数
    "hidden_layers":[1, 2, 3, 4],
    "layer_size": np.arange(1, 100),
    # 一个分布 最小值和最大值
    "learning_rate": reciprocal(1e-4, 1e-2),
}
#导入后可以不用写前面
from sklearn.model_selection import RandomizedSearchCV
									#sklearn模型
random_search_cv = RandomizedSearchCV(sklearn_model,
									  # 参数分布
                                      param_distribution,
                                      # 选出的参数集合数目
                                      n_iter = 10,
                                      # cross_validation参数默认是3
                                      cv = 3,
                                      # 并行处理数
                                      n_jobs = 1)
random_search_cv.fit(x_train_scaled, y_train, epochs = 100,
                     validation_data = (x_valid_scaled, y_valid),
                     callbacks = callbacks)

# cross_validation: 训练集分成n份，n-1训练，最后一份验证.

cross_validation: 训练集分成n份，n-1训练，最后一份验证.


训练结果

# 最好的参数
print(random_search_cv.best_params_)
# 最好的分值
print(random_search_cv.best_score_)
# 最好的模型
print(random_search_cv.best_estimator_)

获取最好的模型，进行测试

model = random_search_cv.best_estimator_.model
model.evaluate(x_test_scaled, y_test)