Tensorflow之keras

keras

keras是基于python的高级神经网路API.keras必须有后端才可以运行，后端可以切换。它以特别方便快速试验，帮助用户以最少的时间验证自己的想法，帮助用户以最少的时间验证自己的想法。

Tf-keras和keras联系

它们都基于同一套API,keras程序可以通过改导入方式轻松转为tf.keras程序
反之不能成立，因为tf.keras有其他特性，而keras不能满足
它们有相同的JOSN和HDF5模型序列化格式和语义

tf-keras和keras区别

1.tf.keras全面支持动态图模式
2.只用keras.Sequential和keras.Model时没影响。自定义Model内部运算逻辑的时候有影响
3.TF.keras支持基于tf.data模型训练，支持TPU训练，支持tf.distribution中分布式策略。Tf.keras可以与tensorflow中estimator集成，tf.keras可以保存SavedModel

1.分类问题+回归问题

分类问题其实是预测当前所属类别，通过模型输出的是它的概率分布，而回归问题预测的是值，模型输出的是一个实际值。
回归问题，预测预测值与真实值之间差距。

目标函数

为什么需要目标函数？
	这是机器学习特性所决定的，大部分机器学习都是逐步调整参数得到最优解，从而逼近目标值。而目标函数可以帮助衡量模型好坏程度。
	比如一个分类问题：它能衡量目标类别与当前预测的差距。通过One-hot编码，把一个正整数变为向量表达（生成一个长度不小于正整数向量，只有正整数的位置处于1，其余处于0）。

分类问题常用方式：

平方差损失

平方差损失距离：
	预测值： [0.2, 0.7, 0.1]
	真实值： [0, 0, 1]
	损失函数值： [(0-0)^2 + (0.7-0)^2 + (0.1-1)^2]*0.5 = 0.65

交叉熵损失

2.Tf.kears分类模型示例

我们采用tensorflow内置图片数据集进行示例：fashion_mnist

导包：

# tf.keras 分类模型
import matplotlib as mpl
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import sklearn
import pandas as pd
import os
import sys
import time
import tensorflow as tf
from tensorflow import keras
# 打印版本
print(tf.__version__)
print(sys.version_info)
for module in mpl,np,pd,sklearn,tf,keras:
    print(module.__name__, module.__version__)
"""
2.1.0
sys.version_info(major=3, minor=7, micro=5, releaselevel='final', serial=0)
matplotlib 3.3.3
numpy 1.19.5
pandas 1.2.1
sklearn 0.24.0
tensorflow 2.1.0
tensorflow_core.keras 2.2.4-tf
"""

数据导入

# 导入内置图片数据集
fashion_mnist = keras.datasets.fashion_mnist
#           训练集            测试集
(x_train_all,y_train_all),(x_test,y_test) = fashion_mnist.load_data() 
# 拆分前5000张作为验证集，剩下作为训练集
x_valid, x_train = x_train_all[:5000], x_train_all[5000:]
y_valid, y_train = y_train_all[:5000], y_train_all[5000:]
# 打印大小
print(x_valid.shape, y_valid.shape)
print(x_train.shape, y_train.shape)
print(x_test.shape, y_test.shape)
"""
(5000, 28, 28) (5000,)
(55000, 28, 28) (55000,)
(10000, 28, 28) (10000,)
"""

展示一张图片

def show_single_image(img_arr):
    """
    展示查看一张图片
    """
    plt.imshow(img_arr,cmap="binary")
            
show_single_image(x_train[0])

展示多个图片集合

def show_imgs(n_rows, n_cols,x_data,y_data,class_names):
    """
    展示图片集
    class_names 索引
    """
    # 
    assert len(x_data) == len(y_data)
    # 验证行和列的乘积不能大于样本数
    assert n_rows * n_cols < len(x_data)
    # 定义图大小
    plt.figure(figsize=(n_cols * 1.4, n_rows * 1.6))
    # 对每行每列放图片
    for row in range(n_rows):
        for col in range(n_cols):
            index = n_cols * row + col
            # 绘制子图
            plt.subplot(n_rows, n_cols, index+1)
            # 展示数据  interpolation缩放图片
            plt.imshow(x_data[index], cmap="binary",interpolation="nearest")
            # 关闭坐标系
            plt.axis("off")
            # 配置title
            plt.title(class_names[y_data[index]])
    plt.show()
class_names = ["T-shirt","Trouser","Pullover","Dress","Coat","Sandal","Shirt","Sneaker","Bag", "Ankle boot"]
# 显示3行5列
show_imgs(3, 5,x_train,y_train,class_names)

使用tf.keras.models.Sequential 进行分类

# 使用tf.keras.models.Sequential 进行分类
# 写法1：
# Sequential对象
model = keras.models.Sequential()
# 往对象添加层次:
# 添加输入层，并将其展开  ： 我输入的是28*28矩阵，用Flatten进行展平，成为一个一维向量
model.add(keras.layers.Flatten(input_shape=[28,28]))
# 添加全连接层 单元数：300（它是用层次发掘神经网络，上一层神经单元和下一层神经单元一一进行连接）  activation表示激活函数
model.add(keras.layers.Dense(300, activation="relu"))
# 再添加全连接层 单元数：100
model.add(keras.layers.Dense(100, activation="relu"))
model.add(keras.layers.Dense(10, activation="softmax"))
# relu: y = max(0,x)
# softmax: 将向量变成概率分布输出  
    # x=[x1,x2,x3]
    # y = [e^x1/sum , e^x2/sum, e^x3/sum], sum = e^x1 + e^x2 + e^x3

# 写法2：
# model = keras.models.Sequential([
#     keras.layers.Flatten(input_shape=[28,28]),
#     keras.layers.Dense(300, activation="relu"),
#     keras.layers.Dense(100, activation="relu"),
#     keras.layers.Dense(10, activation="softmax")
# ])
    
    
    
# 因为y是一个index值，我们需要将y 经过one_hot 变成一个向量
# 如果y是一个向量用categorical_crossentropy即可
# optimizer 为求解优化器方法： 这里使用adam
# metrics : 把损失函数，优化方法加入 keras.optimizers.SGD(lr = 0.1)
model.compile(loss="sparse_categorical_crossentropy",optimizer="adam", metrics=["accuracy"])

查看模型层数

# 查看模型层数
model.layers
"""
[<tensorflow.python.keras.layers.core.Flatten at 0x7fa359641750>,
 <tensorflow.python.keras.layers.core.Dense at 0x7fa359641950>,
 <tensorflow.python.keras.layers.core.Dense at 0x7fa359645490>,
 <tensorflow.python.keras.layers.core.Dense at 0x7fa359645050>]
"""

查看模型概况

# 查看模型概况
model.summary()
"""
Model: "sequential_7"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
flatten_7 (Flatten)          (None, 784)               0         
_________________________________________________________________
dense_21 (Dense)             (None, 300)               235500    
_________________________________________________________________
dense_22 (Dense)             (None, 100)               30100     
_________________________________________________________________
dense_23 (Dense)             (None, 10)                1010      
=================================================================
Total params: 266,610
Trainable params: 266,610
Non-trainable params: 0
_________________________________________________________________
"""

开始训练

# 整个层数解析：
    # 第一层：是样本数 乘以 784 矩阵
    # 第二层：进入全连接层  将其变成样本数 * 300 矩阵  （变换过程： 【样本数 乘以 784 】 * W(权重， W为[784,300]矩阵) + b(偏执， b为300长的向量)）
    # 第三层，第四层也是如上方式实现
# 训练模型
# epochs：将训练集运行10次
# validation_data：对训练集进行验证
history = model.fit(x_train,y_train, epochs=10,validation_data=(x_valid,y_valid))
"""
Train on 55000 samples, validate on 5000 samples
Epoch 1/10
55000/55000 [==============================] - 5s 95us/sample - loss: 2.0006 - accuracy: 0.7321 - val_loss: 0.6174 - val_accuracy: 0.8032
Epoch 2/10
55000/55000 [==============================] - 4s 81us/sample - loss: 0.5339 - accuracy: 0.8135 - val_loss: 0.4758 - val_accuracy: 0.8424
Epoch 3/10
55000/55000 [==============================] - 5s 99us/sample - loss: 0.4774 - accuracy: 0.8339 - val_loss: 0.4359 - val_accuracy: 0.8538
Epoch 4/10
55000/55000 [==============================] - 5s 91us/sample - loss: 0.4468 - accuracy: 0.8447 - val_loss: 0.4878 - val_accuracy: 0.8392
Epoch 5/10
55000/55000 [==============================] - 5s 95us/sample - loss: 0.4269 - accuracy: 0.8511 - val_loss: 0.4067 - val_accuracy: 0.8642
Epoch 6/10
55000/55000 [==============================] - 5s 93us/sample - loss: 0.4076 - accuracy: 0.8551 - val_loss: 0.3962 - val_accuracy: 0.8728
Epoch 7/10
55000/55000 [==============================] - 5s 97us/sample - loss: 0.4024 - accuracy: 0.8594 - val_loss: 0.3951 - val_accuracy: 0.8690
Epoch 8/10
55000/55000 [==============================] - 5s 98us/sample - loss: 0.3881 - accuracy: 0.8627 - val_loss: 0.4112 - val_accuracy: 0.8626
Epoch 9/10
55000/55000 [==============================] - 5s 95us/sample - loss: 0.3734 - accuracy: 0.8691 - val_loss: 0.4331 - val_accuracy: 0.8550
Epoch 10/10
55000/55000 [==============================] - 5s 95us/sample - loss: 0.3594 - accuracy: 0.8727 - val_loss: 0.3709 - val_accuracy: 0.8800
history.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()
plot_learning_curves(history)

3.分类模型归一化

训练后数据的准确率达到81%-87%之间，而在图像分类有个很有效的方式用于提高准确率，那就是归一化
这里使用sklearn进行归一化，采用x = (x - avg) /std方式进行归一化（avg是均值，std是方差）
代码：
- 导入图片数据集

# 这里使用sklearn进行归一化
# 导入内置图片数据集
fashion_mnist = keras.datasets.fashion_mnist
#           训练集            测试集
(x_train_all,y_train_all),(x_test,y_test) = fashion_mnist.load_data() 
# 拆分前5000张作为验证集，剩下作为训练集
x_valid, x_train = x_train_all[:5000], x_train_all[5000:]
y_valid, y_train = y_train_all[:5000], y_train_all[5000:]
print(x_valid.shape, y_valid.shape)
print(x_train.shape, y_train.shape)
print(x_test.shape, y_test.shape)
"""
(5000, 28, 28) (5000,)
(55000, 28, 28) (55000,)
(10000, 28, 28) (10000,)
"""

打印训练集最大值

print(np.max(x_train), np.min(x_train))
# 255 0

归一化：训练集，验证集，测试集

# 归一化
# 
# x = (x - avg) /std
# avg是均值
# std是方差
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
# 训练集做归一化
# 归一化只能进行二维矩阵归一化，因为x_train是三维矩阵，首先将它转为二维矩阵，然后归一化，然后再转回三维矩阵
x_train_scaled = scaler.fit_transform(x_train.astype(np.float32).reshape(-1,1)).reshape(-1,28,28)
# 验证集做归一化
x_valid_scaled = scaler.transform(x_valid.astype(np.float32).reshape(-1,1)).reshape(-1,28,28)
# 测试集做归一化
x_test_scaled = scaler.transform(x_test.astype(np.float32).reshape(-1,1)).reshape(-1,28,28)

此时再打印训练集最大值

print(np.max(x_train_scaled), np.min(x_train_scaled))
# 2.0231433 -0.8105136

使用tf.keras.models.Sequential 进行分类(同上)
训练模型，这里训练集和验证集为归一化的数据集

history = model.fit(x_train_scaled,y_train, epochs=10,validation_data=(x_valid_scaled,y_valid))
"""
Train on 55000 samples, validate on 5000 samples
Epoch 1/10
55000/55000 [==============================] - 5s 95us/sample - loss: 0.4586 - accuracy: 0.8323 - val_loss: 0.3790 - val_accuracy: 0.8560
Epoch 2/10
55000/55000 [==============================] - 6s 104us/sample - loss: 0.3526 - accuracy: 0.8701 - val_loss: 0.3577 - val_accuracy: 0.8718
Epoch 3/10
55000/55000 [==============================] - 5s 95us/sample - loss: 0.3154 - accuracy: 0.8826 - val_loss: 0.3366 - val_accuracy: 0.8758
Epoch 4/10
55000/55000 [==============================] - 5s 93us/sample - loss: 0.2916 - accuracy: 0.8909 - val_loss: 0.3162 - val_accuracy: 0.8854
Epoch 5/10
55000/55000 [==============================] - 5s 91us/sample - loss: 0.2722 - accuracy: 0.8972 - val_loss: 0.3546 - val_accuracy: 0.8720
Epoch 6/10
55000/55000 [==============================] - 5s 92us/sample - loss: 0.2593 - accuracy: 0.9024 - val_loss: 0.3358 - val_accuracy: 0.8800
Epoch 7/10
55000/55000 [==============================] - 5s 90us/sample - loss: 0.2395 - accuracy: 0.9095 - val_loss: 0.3286 - val_accuracy: 0.8894
Epoch 8/10
55000/55000 [==============================] - 5s 91us/sample - loss: 0.2318 - accuracy: 0.9122 - val_loss: 0.3225 - val_accuracy: 0.8900
Epoch 9/10
55000/55000 [==============================] - 5s 88us/sample - loss: 0.2172 - accuracy: 0.9185 - val_loss: 0.3302 - val_accuracy: 0.8930
Epoch 10/10
55000/55000 [==============================] - 5s 89us/sample - loss: 0.2101 - accuracy: 0.9202 - val_loss: 0.3380 - val_accuracy: 0.8942
"""

查看训练结果图

由上面可以知道归一化的训练后结果准确率：达到最高92%

验证准确率

model.evaluate(x_test_scaled, y_test)
"""
10000/10000 [==============================] - 0s 37us/sample - loss: 0.3633 - accuracy: 0.8853
[0.3633375147640705, 0.8853]
"""
loss 0.3633375147640705
准确度：0.8853

4.回调函数

当你在训练模型时候，你中间可以做一些事情，常用回调函数：

EarlyStopping	当模型训练时候当你的loss在不断下降时候，我们可以提前停掉
ModelCheckpoint	 将在每个epoch后保存模型到filepath
TensorBoard		模型训练过程中可以显示训练结果状态

只需在model.fit调用回调函数

# Tensorboard
logdir = "./callbacks"
# 创建目录
if not os.path.exists(logdir):
    os.mkdir(logdir)
# 定义输出文件
output_model_file = os.path.join(logdir, "fashion_mnist_model.h5")
callbacks = [
    keras.callbacks.TensorBoard(logdir),
    # save_best_only保存最好模型
    keras.callbacks.ModelCheckpoint(output_model_file, save_best_only=True),
    # patience 当下一次训练比上一次训练小的时候，连续发生多少次，就要停掉
    # min_delta 阈值， 当前次训练比上一次训练要低于这个值会停掉
    keras.callbacks.EarlyStopping( patience=5,min_delta=1e-3)
]

history = model.fit(x_train_scaled,y_train, epochs=10,validation_data=(x_valid_scaled,y_valid),callbacks=callbacks)

命令行中callbacks目录下执行tensorboard --logdir=callbacks --host=0.0.0.0获取详细信息
- 可以调整Smoothing调整平滑度
- GRAPHS查看训练模型

5.回归模型

？？

6.神经网络如何进行训练

采用训练方式为梯度下降方式，首先进行求导，找到每个变量变化方向，然后更新参数。上面我们的分类模型为一个三层，伴随层次越来越深。就成深度神经网络。

7.激活函数

在我们构建模型层次时候，使用激活函数，激活函数有如下

它们将非线性特性引入到我们的网络中。其主要目的是将模型中一个节点的输入信号转换成一个输出信号。该输出信号现在被用作堆叠中下一个层的输入。

8.归一化和批归一化

其实它就是将输入输出数据进行规整，使它的均值为0，方差为1。常用归一化种类
```
Min-max归一化： x*=(x-min)/(max-min)
Z-score归一化:  x*=(x-μ)/σ
```
批归一化
```
将每层激活值都做归一化
```

为什么归一化有效，如下图：

图一没有做归一化处理导致theta1与theta2值是不一样的。这样由于theta1与theta2值是不一样，等高线看起来像是一个椭圆，（等高线解释：等高线表示在这条等高线的值都是一样的），但是目标函数值是一样的。因为它是椭圆，在计算法向量时候没有指向圆心，导致训练轨迹非常曲折。

经过归一化如图二，当然训练速度也会更快

11.Dropout

Dropout是一种在深度学习环境中应用的正规化手段。它是这样运作的：在一次循环中我们先随机选择神经层中的一些单元并将其临时隐藏，然后再进行该次循环中神经网络的训练和优化过程。在下一次循环中，我们又将隐藏另外一些神经元，如此直至训练结束。Dropout

Droupout作用

作用可以防止过拟合：
（什么是过拟合：训练集上表现很好，测试集上不好）---造成这样原因可能模型参数比较多，容量太大，使得模型记住样本（测试集的样本和训练集样本是不一样），不能泛华

12.Keras实现深度神经网络

还是以上面为例只不过我们添加学习网络时，增加20层

# 使用tf.keras.models.Sequential 进行分类
# Sequential对象
model = keras.models.Sequential()
# 往对象添加层次:
# 添加输入层，并将其展开  ： 我输入的是28*28矩阵，用Flatten进行展平，成为一个一维向量
model.add(keras.layers.Flatten(input_shape=[28,28]))
# 添加20层学习网络
for _ in range(20):
    model.add(keras.layers.Dense(100, activation="relu"))
model.add(keras.layers.Dense(10,activation="softmax"))

此时打印训练结果图

由上图我们发现，相对于之前学习曲线图在初期时候（x轴0到3之间），目标函数趋势是不怎么发生变化的。而把目标函数迭代到x轴为4时，目标函数才变化的陡峭，导致原因是：
	1. 由于是深度学习，参数比较多，训练不充分。
	2. 梯度消失：一般发生在深度学习网络里，导致发生原因为链式法则，（链式法则用于复合函数求导f(g(x))， 函数g(x)输出是f函数输入）。对于低层次神经网络，它的复合函数嵌套较多，梯度一层一层传导下去，到低层次因符合函数嵌套较多，就有可能导致梯度消失，导致训练结果比较平滑，梯度消失

批归一化实现

在keras实现批归一化较为简单，只需要在添加训练模型时候添加如下代码

model.add(keras.layers.BatchNormalization())

批归一化添加也可以放在激活函数之前

model.add(keras.layers.Dense(100))# 添加学习层次
model.add(keras.layers.BatchNormalization())# 批归一化
model.add(keras.layers.Activation('relu'))# 添加激活后面

训练结果

我们可以看到进行批归一化训练的模型，没有了上述问题。我们通过批归一化缓解梯度消失，通过归一化是数据更加规整，这样计算更加准确

激活函数更改带来效果
- selu 自带归一化的激活函数
```
model.add(keras.layers.Dense(100, activation="selu"))
```
- 训练效果训练时间优于BatchNormalization
dropout添加
- 一般我们添加dropout都是在最后几层添加
```
# rate为添加单元比例
# 添加AlphaDropout
model.add(keras.layers.AlphaDropout(rate=0.5))
# 添加普通Dropout方式
model.add(keras.layers.Dropout(rate=0.5))
```
AlphaDropout 比 Dropout更加强大，AlphaDropout优势：均值和方差不变，归一化的性质也不变。
Dropout使用，根据自己训练场景定，如果没有出现过拟合现象可以不用使用Dropout

13. wide和Deep模型

用于分类和回归的模型，并应用到了 Google Play 的应用推荐中。wide and deep 模型的核心思想是结合线性模型的记忆能力（memorization）和 DNN 模型的泛化能力（generalization），在训练过程中同时优化 2 个模型的参数，从而达到整体模型的预测能力最优。

稀疏特征：

什么是稀疏特征：

比如我们100维度的向量(x1,x2,....x100)，我们通过x1,x2,x3来表示即可，其他参数约束为0，那么他就是一种稀疏表示思想。

它是一个离散值特征，使用One-hot表示。而稀疏特征可以进行叉乘，叉乘可以有效刻画样本,通过稀疏特征做叉乘取出共现信息，实现模型记忆效果。
```
有一个词表：  [你，他， 计算机]  经过one-hot ===>  他=[0,0,1,...]   计算机=[1,0,1,...]
进行叉乘 ： (他,计算机)  
```

优缺点：

优点：
	降低表示复杂度，更直白的原因其实就是减少系数参数，通过稀疏表示，可以充分发挥数据所含有的信息，去掉冗余的数据信息，达到最大化利用数据，广泛用于工业界
缺点：
	需要人工设计
	可能过拟合，所有特征都叉乘，相当于记住每一个样本

密集特征

用向量表达特征

有一个词表：  [你，他， 计算机]  经过one-hot ===>  他=[0,0,1,...]   计算机=[1,0,1,...]
他   用一个向量来表示 [0.2,0.5,0.3,...(n维向量)]

Word2vec工具就是词语转化成向量。

优缺点

优点：
	带有语义信息，不同向量之间有相关性
	兼容没有出现过的特征组合
	更少的人工去设计
缺点：
	过度泛化，导致推荐不怎么相关的产品

wide 和deep模型结构

图像左侧为wide模型 
右侧为wide&deep模型

wide模型 
	它所有输入都连接输出上，输入就是系数特征（one-hot表达）


wide&deep
	左半部分是一个wide模型
	右半部分是deep模型，他是多层的模型。首先输入是稀疏特征，deep把说有输入数据作为一个密集的向量表达，然后进行多层的全连接网络，最后连接到输出。

14.wide 和deep模型实现

14.1函数API实现wide&deep模型

导包


import matplotlib as mpl
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import sklearn
import pandas as pd
import os
import sys
import time
import tensorflow as tf
from tensorflow import keras
# 打印版本
print(tf.__version__)
print(sys.version_info)
for module in mpl,np,pd,sklearn,tf,keras:
    print(module.__name__, module.__version__)

加载数据使用sklearn fetch_californiz_hoursing

# 导入fetch_california_housing类
from sklearn.datasets import fetch_california_housing 
# 实例化对象
housing = fetch_california_housing()
# 打印相关信息
print(housing.DESCR)
print(housing.data.shape)
# 输出：(20640, 8)
print(housing.target.shape)
# 输出：(20640,)

数据预处理（划分训练集，测试集）

from sklearn.model_selection import train_test_split

#拆分训练集，测试集
x_train_all,x_test,y_train_all,y_test = train_test_split(
             housing.data , housing.target , random_state=7,test_size = 0.2)

# 拆分训练集，验证集
x_train,x_valid,y_train,y_valid = train_test_split(
                x_train_all , y_train_all , random_state=11)

"""
train_test_split类里面传入housing.data-(20640, 8),
                  housing.targget-(20640,)
                           随机种子-random.state

(train_test_split 默认划分比例是3：1 
也可以通过test_size,改变比例,
默认test_size = 0.25)  
"""

打印划分结果

print(x_train.shape,y_train.shape)
print(x_valid.shape,y_valid.shape)
print(x_test.shape,y_test.shape)

数据标准化

#导入StandardScaler类
from sklearn.preprocessing import StandardScaler
# 实例化
scaler = StandardScaler()
# 调用scaler。fit 或者scaler.transform方法
x_train_scaled = scaler.fit_transform(x_train)
x_valid_scaled = scaler.transform(x_valid)
x_test_scaled = scaler.transform(x_test)

创建模型使用函数式API功能实现

# 使用函数式API功能实现
# 定义输入层 将数据读取
input = keras.layers.Input(shape=x_train.shape[1:])
# 使用2层神经网络实现deep model 有点类似复合函数 fx(x) = h(g(x))
hidden1 = keras.layers.Dense(30, activation='relu')(input)# 第一层
hidden2 = keras.layers.Dense(30, activation='relu')(hidden1)# 第二层
# wide输入和神经网络层输出合并
concat = keras.layers.concatenate([input, hidden2])
# 最后输出
output = keras.layers.Dense(1)(concat)

# 定义model  函数式需要定义model
model = keras.models.Model(inputs=[input],outputs=[output])
model.compile(loss="mean_squared_error",optimizer="adam", metrics=["accuracy"])

训练模型



callbacks = [
    keras.callbacks.EarlyStopping( patience=5,min_delta=1e-3)
]

history = model.fit(x_train_scaled,y_train, epochs=100,validation_data=(x_valid_scaled,y_valid), callbacks=callbacks)

查看训练结果图

def plot_learning_curves(history):
    """
    查看训练结果图
    """
    # 设置图像大小
    pd.DataFrame(history.history).plot(figsize=(8,5))
    # 显示网格
    plt.grid(True)
    # 坐标轴范围
    plt.gca().set_ylim(0,1)
    plt.show()
plot_learning_curves(history)

14.2子类API实现wide & deep模型

# 子类API
class WideDeepModel(keras.models.Model):
    def __init__(self):
        super(WideDeepModel, self).__init__()
        # 定义模型层次
        self.hidden1_layer = keras.layers.Dense(30, activation="relu")# 全连接层1
        self.hidden2_layer = keras.layers.Dense(30, activation="relu")# 全连接层2
        self.output_layer = keras.layers.Dense(1)# 输出层 ，长度为1
    def call(self, input):
        """完成模型正向计算"""
        hideen1 = self.hidden1_layer(input)
        hideen2 = self.hidden2_layer(hideen1)
        concat = keras.layers.concatenate([input, hideen2])
        output = self.output_layer(concat)
        return output
# 构建model
# 方式1：
# model = WideDeepModel()
# 方式2：
model = keras.models.Sequential([
    WideDeepModel(),
])

model.build(input_shape=(None, 8))
    
model.compile(loss="mean_squared_error",optimizer="adam")

15.wide &deep模型多输入和多输出

上面实现wide&deep模型的wide，deep部分输入都是用一样输入，其实真实情况下，wide&deep模型的输入和输出式不一样的

15.1多输入

选择wide和deep输入：

# 多输入
# 函数式实现方法
input_wide = keras.layers.Input(shape=[5])# wide输入:选前5个当wide模型输入
input_deep = keras.layers.Input(shape=[6])# deep输入：选后6个 当deep模型输入

hidden1 = keras.layers.Dense(30, activation='relu')(input_deep)
hidden2 = keras.layers.Dense(30, activation='relu')(input_wide)
concat = keras.layers.concatenate([input_wide, hidden2])
# 输出
output = keras.layers.Dense(1)(concat)
# 实例模型
model = keras.models.Model(inputs=[input_wide,input_deep],outputs=[output])

model.compile(loss="mean_squared_error",optimizer="adam")

训练输入数据拆分

callbacks = [
    keras.callbacks.EarlyStopping( patience=5,min_delta=1e-3)
]
# 训练数据拆分
# wide训练数据取前5个
x_train_scaled_wide = x_train_scaled[:,:5]
# deep训练数据取后5个
x_train_scaled_deep = x_train_scaled[:,2:]
# 测试数据拆分
x_test_scaled_deep = x_test_scaled[:,2:]
x_test_scaled_wide = x_test_scaled[:,:5]
# 验证数据拆分
x_valid_scaled_deep = x_valid_scaled[:,2:]
x_valid_scaled_wide = x_valid_scaled[:,:5]

history = model.fit([x_train_scaled_wide, x_train_scaled_deep],y_train, epochs=100,validation_data=([x_valid_scaled_wide, x_valid_scaled_deep],y_valid), callbacks=callbacks)

15.2多输出

多输出一般用于多任务学习问题。比如我们预测当年房价和明年房价，这样就有2个任务。

# 上例中再定义个输出
# 输出hidden2
output2 = keras.layers.Dense(1)(hidden2)
# 实例模型加入输出
model = keras.models.Model(inputs=[input_wide,input_deep],outputs=[output, output2])
# 训练模型： y_train，y_valid 添加输出训练数据和验证数据
history = model.fit([x_train_scaled_wide, x_train_scaled_deep],[y_train, y_train], epochs=100,validation_data=([x_valid_scaled_wide, x_valid_scaled_deep],[y_valid,y_valid]), callbacks=callbacks)
# 验证增加 y_test验证数据集
model.evaluate([x_test_scaled_wide,x_test_scaled_deep], [y_test,y_test])

16.超参数搜索

神经网络有很多训练过程中不变参数，比如

网络结构参数：有几层,每层宽度，每层激活函数
训练参数：batch_size,学习率，学习率衰减算法等

而这些参数是不变的，如果手工去实验耗费人力。

搜索策略：

网格搜索

把各种传参数离散化成几个值，吧这几个值一一组合起来，然后一个个去试。

随机搜索

相比网格搜索，网格搜索是将传参数离散化几个固定值，比如值为[0.2,0.4,0.6,0.8] 而最优解是一个0.2-0.4之间的值，这样无法得到最优解。随机搜索是随机的生成参数组合，就能确保最优解是有可能被搜索到的，但随机的组合会比网格搜索更多

遗传算法搜索

遗传算法是对自然界的模拟
	1.首先初始化候选参数集合 -> 训练-> 得到模型指标作为生存概率
	2.然后根据生存的概率做随机选择 -> 交叉（类似于DNA组合） -> 变异（参数进行微小调整） -> 产生下一代集合
	3.重新回到1.

启发式搜索

使用循环神经网络来生成参数，使用强化学习来进行反馈，使用模型来训练生成参数。

17.超参数搜索实现

使用regression数据集

17.1手动实现超参数搜索

# 定义 learning_rate
# W = W + grad + learning_rate
learning_rates = [1e-4,3e-4,1e-3,3e-3,1e-2,3e-2]
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 = keras.optimizers.SGD(lr)
    model.compile(loss="mean_squared_error",optimizer=optimizer)# sgd  adam

    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 = 10,
        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_rates, histories):
    print("Learning rate:", lr)
    plot_learning_curves(history)

上述手动实现超参数搜索存在着以下问题

1.当前我们只有一个参数，只用一层for循环，如果我们参数有20层，那就会有20层for循环
2.使用for循环导致只能等上一个模型训练完毕才能开始下一个模型训练，没有一个并行化处理

17.2sklearn实现超参数搜索

使用RandomizedSearchCV实现超参数搜索，整体步骤是首先将tf.model转化为sklearn的model，定义参数集合，实现超参数搜索

常规导报


import matplotlib as mpl
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import sklearn
import pandas as pd
import os
import sys
import time
import tensorflow as tf
from tensorflow import keras
# 打印版本
print(tf.__version__)
print(sys.version_info)
for module in mpl,np,pd,sklearn,tf,keras:
    print(module.__name__, module.__version__)

导入数据集

# 导入fetch_california_housing类
from sklearn.datasets import fetch_california_housing 
# 实例化对象
housing = fetch_california_housing()
# 打印相关信息
print(housing.DESCR)
print(housing.data.shape)
# 输出：(20640, 8)
print(housing.target.shape)

拆分训练集，测试集

from sklearn.model_selection import train_test_split

#拆分训练集，测试集
x_train_all,x_test,y_train_all,y_test = train_test_split(
             housing.data , housing.target , random_state=7,test_size = 0.2)

# 拆分训练集，验证集
x_train,x_valid,y_train,y_valid = train_test_split(
                x_train_all , y_train_all , random_state=11)
print(x_train.shape, y_train.shape)
print(x_valid.shape, y_valid.shape)
print(x_test.shape, y_test.shape)

数据标准化

#导入StandardScaler类
from sklearn.preprocessing import StandardScaler
# 实例化
scaler = StandardScaler()
# 调用scaler。fit 或者scaler.transform方法
x_train_scaled = scaler.fit_transform(x_train)
x_valid_scaled = scaler.transform(x_valid)
x_test_scaled = scaler.transform(x_test)

将tf.model转化为sklearn的model

callbacks = [
        keras.callbacks.EarlyStopping( patience=5,min_delta=1e-3)
    ]
# 将tf.model转化为sklearn的model
def build_model(hidden_layers=1,layer_size=30,learning_rate=3e-3):
    """
    hidden_layers中间层的层数 
    layer_size 默认30
    learning_rate 学习率
    """
    # 实例化一个训练model
    model = keras.models.Sequential()
    # 添加全连接层
    model.add(keras.layers.Dense(layer_size, activation='relu', input_shape=x_train.shape[1:]))
    # 添加hidden_layers 个全连接层
    for _ in range(hidden_layers):
        model.add(keras.layers.Dense(layer_size, activation='relu'))
    # 添加输出层
    model.add(keras.layers.Dense(1))
    # 定义优化器
    optimizer = keras.optimizers.SGD(learning_rate)
    # mse为mean_squared_error简称
    model.compile(loss="mse",optimizer=optimizer)# sgd  adam
    return model

# sklearn_model = keras.wrappers.scikit_learn.KerasRegressor(build_model)
history = sklearn_model.fit(x_train_scaled, y_train, epochs=10, validation_data=(x_valid_scaled,y_valid),callbacks=callbacks)

定义搜索空间

param_distribution = {
    "hidden_layers": [1,2,3,4,5],
    "layer_size":np.arange(1,100),# 为1-100连续取值
    "learning_rate": reciprocal(1e-4,1e-2)# 为一个分布取值
}

scipy 的reciprocal

from scipy.stats import reciprocal
reciprocal.rvs(1e-4,1e-2,size=10)# 生成10的-4次方到10的-2次方 的 10个数
"""
array([0.00407106, 0.00033841, 0.00018518, 0.00246045, 0.00991374,
       0.00079176, 0.00011086, 0.00023637, 0.00359715, 0.00372375])
"""

RandomizedSearchCV超参数搜搜

from sklearn.model_selection import RandomizedSearchCV
# 初始化对象
# n_iter 从param_distribution 生成多少个集合
# n_jobs 并行处理数量
# cv  默认为3 使用了cross_validation: 训练集分成n份，n-1训练，最后一份验证
random_search_cv = RandomizedSearchCV(sklearn_model,param_distribution,cv=3, n_iter=10,n_jobs=1)

# 进行训练
random_search_cv.fit(x_train_scaled,y_train,epochs=100,validation_data=(x_valid_scaled,y_valid), callbacks=callbacks)

查看结果

# 查看最好参数
print(random_search_cv.best_params_)
# 查看最好峰值
print(random_search_cv.best_score_)
# 最好model
print(random_search_cv.best_estimator_)

拿取最好model进行验证

# 拿取最好model进行验证
model = random_search_cv.best_estimator_.model
model.evaluate(x_test_scaled, y_test)