TensorFlow2.0 学习笔记 keras实战(下)_tensorflow2 多输出回归-CSDN博客

本文链接：https://blog.csdn.net/Diiiiiiiiiiiiiiii/article/details/100102971

wide&Deep 模型

16年发布,用于分类和回归
应用在Google Play中的应用推荐
原始论文 https://arxiv.org/pdf/1606.07792v1.pdf

稀疏特征

离散值特征 eg.性别工作年龄
One-hot 表示
- Eg:专业 = {计算机,人文,其他}. 人文=[0,1,0]
- Eg:词表={智能,你,他,我…}
叉乘=
- 叉乘之后
  - 稀疏特征做叉乘获取共现信息
  - 实现记忆效果
优点
- 有效,广泛应用于工业界(推荐算法)
缺点
- 需要人工设计 (选取特征)
- 可能过拟合,所有特征都叉乘,相当于记住每一个样本(泛化能力差)

密集特征

向量表达
- Eg 词表 ={智能,你,他,我}.
- 他 = [0.3,0.2,0.6(n维向量)]
word2vec
- 男-女 = 国王-王后
- 把词语转换成向量,之后通过计算向量之间的距离,来确定词语之间的语义近似程度
优点
- 带有语音信息,不同向量之间有相关性
- 兼容没有出现过的特征组合
- 更少的人参与
缺点
- 过度泛化,推荐不怎么相关的产品

编程实战

Wide & Deep 模型
子类API
功能API(函数式API)
多输入与多输出

在Wide&Deep模型中,要先划分特征是给Wide用还是Deep用.

训练数据选取房价预测的数据集,因为其中8个特征.划分起来更有意义.
并没有选取图像分类测试集,因为图像分类中每一个特征重要性都是一样的.

因为wide&deep模型不是单一层级结构,所以不能使用Sequential模型

函数式API 功能API

input = keras.layers.Input(shape = x_train.shape[1:]) #使用Keras.Input 确定输入形状
hidden1 = keras.layers.Dense(30,activation="relu")(input) # 括号后面是这层的输入
hidden2 = keras.layers.Dense(30,activation = "relu")(hidden1)#实现了两层的模拟deep模型

concat = keras.layers.concatenate([input,hidden2]) # 把Wide 和Deep 模型拼接到一起
output = keras.layers.Dense(1)(concat) #应用拼接到一起的Wide&Deep模型构建最后一层

model = keras.models.Model(inputs = [input], #使用Keras.models.Model 固话所建立的model
                          outputs = [output])

子类API

完成的功能和上面函数式 API一样个人感觉这个有点抽象

# 子类API
class WideDeepModel(keras.models.Model):
    def __init__(self):
        super(WideDeepModel, self).__init__()
        """定义模型的层次"""
        self.hidden1_layer = keras.layers.Dense(30, activation='relu')
        self.hidden2_layer = keras.layers.Dense(30, activation='relu')
        self.output_layer = keras.layers.Dense(1)
    
    def call(self, input):
        """完成模型的正向计算"""
        hidden1 = self.hidden1_layer(input)
        hidden2 = self.hidden2_layer(hidden1)
        concat = keras.layers.concatenate([input, hidden2])
        output = self.output_layer(concat)
        return output
model = WideDeepModel()
#model = keras.models.Sequential([
 #   WideDeepModel(),
#])

model.build(input_shape=(None, 8))       
model.summary()

多输入与多输出

多输入实现

在很多情况下Wide 和Deep模型的输入特征不相同,所以就要有两个不同的输入

因为输入改变,所以对应的 **model.fit()**中的参数也要改变

同时train特征进行了改变,那么vaild 特征也要做相应改变,同样 test特征也要改变

input_wide = keras.layers.Input(shape = "5")  # x_train 前5项
input_deep = keras.layers.Input(shape = "6")  # x_train 后6项

hidden1 = keras.layers.Dense(30,activation="relu")(input_deep)
hidden2 = keras.layers.Dense(30,activation = "relu")(hidden1)
concat = keras.layers.concatenate([input_wide,hidden2])
output = keras.layers.Dense(1)(concat)

model = keras.models.Model(inputs = [input_wide,input_deep],
                          outputs = [output])

对多输入数据的构造

x_train_wide = x_train_scaled[:,:5]
x_train_deep = x_train_scaled[:,-6:]

x_valid_wide = x_valid_scaled[:,:5]
x_valid_deep = x_valid_scaled[:,-6:]

x_test_wide = x_test_scaled[:,:5]
x_test_deep = x_test_scaled[:,-6:]

fit函数的改写

history = model.fit([x_train_wide,x_train_deep], y_train,
                    validation_data = ([x_valid_wide,x_valid_deep], y_valid),
                    epochs = 100,
                    callbacks = callbacks)

多输出实现

比方说预测房价,可能需要根据当前的数据,既预测当前的价值,还要预测一年以后的房价,这样就需要有两部分输出

同时多输出也可以在构建的网络的时候对多个模型,使用多输出,这样一次训练就可以得到多个想要的模型效果.在从好的效果中,选择你想要的模型.
多任务学习问题
不是模型上的改进,而是实际问题需要这种模型

程序实现

因为修改了输出的格式,所以不仅要修改model ,也要修改 fit中的output

input_wide = keras.layers.Input(shape = "5")  # x_train 前5项
input_deep = keras.layers.Input(shape = "6")  # x_train 后6项

hidden1 = keras.layers.Dense(30,activation="relu")(input_deep)
hidden2 = keras.layers.Dense(30,activation = "relu")(hidden1)
output2 = keras.layers.Dense(1)(hidden2)		# 多输出修改处,创建一个输出
concat = keras.layers.concatenate([input_wide,hidden2])
output = keras.layers.Dense(1)(concat)

model = keras.models.Model(inputs = [input_wide,input_deep],
                          outputs = [output,output2])  # 多输出修改处,在model创建处

训练模型修改

history = model.fit([x_train_wide,x_train_deep], [y_train,y_train], #修改
                    validation_data = ([x_valid_wide,x_valid_deep], #修改[y_valid,y_valid]),
                    epochs = 100,
                    callbacks = callbacks)

超参数搜索

神经网络训练过程中不变的参数
- 网络结构: 几层每层宽度每层激活函数
- 训练参数: batch_size 学习率,学习率衰减算法
搜索策略
- 网格搜索
- 随机搜索
- 遗传算法搜索
- 启发式搜索 - 最高端

网格搜索:

定义n维方格
每个方格对应一组超参数
一组组参数尝试 (可以并行提高速度)
缺点,最优解可能不在网格上.

随机搜索:

参数的生成方式是随机
搜索的范围大
慢(自己理解)

遗传算法

对自然界的模拟
A.初始化候选参数->训练->得到模型指标作为生存概率
B.选择->交叉->变异->产生下一代集合
C.重新到A
找到表现最好的遗传

启发式算法

研究热点-AutoMl
使用循环神经网络来生成参数
使用强化学习来进行反馈,使用模型来训练生成参数.

编程:使用scikit实现超参数搜索

手动实现超参数搜索

用矩阵配合 for循环直线超参数搜索

learning_rate = [1e-4 ,1e-3 ,1e-2]
histories=[]
for lr in learning_rate:
    input = keras.layers.Input(shape = x_train.shape[1:])
    hidden1 = keras.layers.Dense(30,activation="relu")(input)
    hidden2 = keras.layers.Dense(30,activation = "relu")(hidden1)
    output = keras.layers.Dense(1)(hidden2)
    model = keras.models.Model(inputs = [input],
                              outputs = [output])
    optimizer = keras.optimizers.SGD(lr)   #这里learn_rate 是在这里实现的修改
    model.compile(loss="mean_squared_error", optimizer=optimizer)
    callbacks = [keras.callbacks.EarlyStopping(
                patience=5, min_delta=1e-3)]
    history = model.fit(x_train_scaled, y_train,
                    validation_data = (x_valid_scaled, y_valid),
                    epochs = 100,
                    callbacks = callbacks)
    histories.append(history)

图形化显示

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_rate,histories): 
    print("learning_rate : ",lr)
    plot_learning_curves(history)

用sklearn 实现超参数搜索

RandomizedSearchCV

转化为sklearn的model
定义参数集合
搜索参数

1.定义并转化为sklearn的model

keras 创建 model

def build_model(hidden_layers = 1,
                layer_size = 30,
                learning_rate = 3e-3):
    model = keras.models.Sequential()
    model.add(keras.layers.Dense(layer_size, activation='relu',
                                 input_shape=x_train.shape[1:]))
    for _ in range(hidden_layers - 1):
        model.add(keras.layers.Dense(layer_size,
                                     activation = 'relu'))
    model.add(keras.layers.Dense(1))
    optimizer = keras.optimizers.SGD(learning_rate)
    model.compile(loss = 'mse', optimizer = optimizer)
    return model

把keras的model转换为sklearn的model

sklearn_model = 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 = 10,
                            validation_data = (x_valid_scaled, y_valid),
                            callbacks = callbacks)

2.定义参数集合

from scipy.stats import reciprocal
# f(x) = 1/(x*log(b/a)) a <= x <= b

param_distribution = {
    "hidden_layers":[1, 2, 3, 4],				#隐藏层数
    "layer_size": np.arange(1, 100),			#每层的节点数
    "learning_rate": reciprocal(1e-4, 1e-2),	#学习率
}

3.搜索参数

from sklearn.model_selection import RandomizedSearchCV

random_search_cv = RandomizedSearchCV(sklearn_model,	#第一步设置的model
                                      param_distribution, #定义参数的集合
                                      n_iter = 10,  # 参数集合  ??有点没有理解
                                      cv = 3,		#设置把测试集 拆分为 train 和vaild 比例 train/vaild=(3-1)
                                      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训练，最后一份验证.

打印超参数搜索结果

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

用超参数搜索得到的最好的model 来在测试集上验证

model = random_search_cv.best_estimator_.model  #获取模型
model.evaluate(x_test_scaled, y_test)			#在测试集上训练