TensorFlow2.0入门到进阶系列——2_TensorFlow-Keras实战

最新推荐文章于 2021-04-24 15:44:45 发布
原创 最新推荐文章于 2021-04-24 15:44:45 发布 · 1.3k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#tensorflow #深度学习 #人工智能 #python

本文介绍了TensorFlow2.0中Keras的基本概念，包括Tensorflow-Keras与纯Keras的关系，以及它们在分类、回归问题和损失函数上的应用。实战部分涵盖Keras构建分类、回归模型，深度神经网络，wide&deep模型，以及使用Keras与scikit-learn进行超参数搜索。文章强调了Tensorflow-Keras在实验中的优势，并提供了多个模型训练和调优的例子。
部署运行你感兴趣的模型镜像

2_TensorFlow-Keras实战

1、内容结构

  • 内容如何安排
    • 实战与理论并存，实战为主，理论为辅
    • 小知识点第一次遇见会讲
    • 大知识点独立为一个小节
  • 代码的TensorFlow版本
    • 大部分都是tf2.0
    • 课程以tf.keras API为主，因而部分代码可以在tf1.3+运行
    • 另有少量tf1.*版本代码（方便大家读懂老代码）

2、理论部分

  • Tensorflow-keras简介；
  • 分类问题、回归问题、损失函数；
  • 神经网络、激活函数、批归一化、Dropout;
  • Wide & deep 模型；
  • 超参数搜索

2.1、Tensorflow-keras简介

2.1.1、keras是什么

  • 基于python的高级神经网络API；
  • Francois Chollet于2014-2015年编写keras；
  • 以Tensorflow、CNTK或者Theano为后端运行，keras必须有后端才可以运行；
    • 后端可以切换，现在多用TensorFlow
  • 极方便于快速实验，帮助用户以最少的时间验证自己的想法；

2.1.2、Tensorflow-keras是什么

  • Tensorflow对keras API规范的实现；
  • 相对于以Tensorflow为后端的keras，Tensorflow-keras与Tensorflow结合更加紧密；
  • 实现在tf.keras空间下；

2.1.3、Tensorflow-keras和keras的联系

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

2.1.4、Tensorflow-keras和keras的区别

  • Tf.keras全面支持eager mode
    • 只是用keras.Sequential和keras.Model时没影响
    • 自定义Model内部运算逻辑的时候会有影响
      • Tf低层API可以使用keras的model.fit等抽象
      • 适用于研究人员
  • Tf.keras支持基于tf.data的模型训练；
  • Tf.keras支持TPU训练；
  • Tf.keras支持tf.distribution中的分布式策略；
  • 其他特性
    • Tf.keras可以与Tensorflow中的estimator集成
    • Tf.keras可以保存为SavedModel

2.1.5、Tensorflow-keras和keras如何选择

  • 如果想用tf.keras的任何一个特性，那么选tf.keras；
  • 如果后端互换性很重要，那么选择keras；
  • 如果都不重要，那就随便。

2.2、分类问题、回归问题、损失函数

2.2.1、分类问题、回归问题

  • 分类问题预测的是类别，模型的输出是概率分布
    • 三分类问题输出例子：[0.2,0.7,0.1]
  • 回归问题预测的是值，模型的输出是一个实数值

2.2.2、目标函数

为什么需要目标函数？

  • 参数是逐步调整的
  • 目标函数可以帮助衡量模型的好坏
    • Model A:[0.1,0.4,0.5]
    • Model B:[0.1,0.2,0.7]

分类问题：

  • 需要衡量目标类别与当前预测的差距
    • 三分类问题输出例子：[0.2,0.7,0.1] (1 ->one_hot -> [0,1,0])
    • 三分类真实类别：2 -> one_hot -> [0,0,1]
  • One-hot编码，把正整数变为向量表达
    • 生成一个长度不小于正整数的向量，只有正整数的位置处为1，其余位置都为0
  • 分类问题损失函数
    • 平方差损失；
    • 交叉熵损失；
  • 平方差损失举例
    • 预测值：[0.2,0.7,0.1]
    • 真实值：[0,0,1]
    • 损失函数值：[(0.2-0)^2 + (0.7-0) ^2 + (0.1-1) ^2 ] * 0.5 = 0.67

回归问题：

  • 预测值与 真实值的差距
  • 平方差损失
  • 绝对值损失

模型的训练就是调整参数，使得目标函数逐渐变小的过程

3、实战部分

  • Keras搭建分类模型；
  • Keras回调函数；
  • Keras搭建回归模型；
  • Keras搭建深度神经网络；
  • Keras实现wide&deep模型；
  • Keras与scikit-learn实现超参数搜索。

3.1、Keras搭建分类模型

3.1.1、数据读取与展示

先导入各种需要的库

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
#import keras

查看导入的库的版本信息

print(tf.__version__)
print(sys.version_info)
for module in mpl,np,pd,sklearn,tf,keras:
    print(module.__name__,module.__version__)

在这里插入图片描述
查看使用的数据集的结构

fashion_mnist = keras.datasets.fashion_mnist
(x_train_all,y_train_all),(x_test,y_test) = fashion_mnist.load_data()
x_valid,x_train = x_train_all[:5000],x_train_all[5000:]     #前5000张做验证集  后55000做训练集
y_valid,y_train = y_train_all[:5000],y_train_all[5000:]     #前5000张做验证集  后55000做训练集

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

在这里插入图片描述
看一下数据集里面的图片是什么样的（了解数据集是机器学习很重要的一部分）

#定义一个函数，可以显示一张图像
def show_single_image(img_arr):
    plt.imshow(img_arr,cmap="binary")   #这里是灰度图，其他图像具体参数请百度imshow()函数
    plt.show()
    
show_single_image(x_train[0])

在这里插入图片描述
查看多张照片

#显示很多张图片
def show_image(n_rows, n_cols, x_data, y_data, class_names):
    assert len(x_data) == len(y_data)       #验证x样本数和y样本数一样
    assert n_rows * n_cols < len(x_data)    #验证行和列的乘积不能大于样本数
    plt.figure(figsize = (n_cols * 1.4, n_rows * 1.6))   #定义一张大图1.4   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)     #大图上画子图（之前index是从0开始的，这里要从1开始）
            plt.imshow(x_data[index], cmap="binary", interpolation='nearest')    #interpolation缩放图片时，插值的方法
            plt.axis('off')    #坐标系关掉
            plt.title(class_names[y_data[index]])   #给每一张小图都加上title
    plt.show()
    
class_names = ['T-shirt', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

show_image(3, 5, x_train, y_train, class_names)

在这里插入图片描述

3.1.2、模型构建

#tf.keras.models.Sequential()

'''
#构建模型
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape = [28, 28]))
model.add(keras.layers.Dense(300, activation = "relu"))
model.add(keras.layers.Dense(100, activation = "relu"))
model.add(keras.layers.Dense(10, activation = "softmax"))
'''

#模型构建的另一种等价写法
model = keras.models.Sequential([
    keras.layers.Flatten(input_shape = [28, 28]),  #将输入为28 * 28的图像展开（28*28的二维矩阵展成784的一维向量）
    keras.layers.Dense(300, activation = "relu"),
    keras.layers.Dense(100, activation = "relu"),
    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]

# reason for sparse: y->index. y->one_hot->[]
model.compile(loss = "sparse_categorical_crossentropy",     #如果y已经是向量了就用categorical_crossentropy",如果是数字就用sparse_
             optimizer = "adam",
             metrics = ["accuracy"])

查看模型层数

model.layers

在这里插入图片描述
查看模型概况

model.summary()

在这里插入图片描述
训练模型

'''
[None, 784] * w + b -> [None, 300]   其中，w.shape->[784,300], b = [300]

'''

history = model.fit(x_train, y_train, epochs=10, validation_data = (x_valid, y_valid))

在这里插入图片描述

3.1.3、模型训练参数查看

history.history       #查看history里面存储的一些值

在这里插入图片描述
绘图查看history中的变量变化过程

def plot_learning_curves(history):
    pd.DataFrame(history.history).plot(figsize = (8,5))   #将数据转换成DataFrame，然后调用plot实现
    plt.grid(True)      #绘制网格
    plt.gca().set_ylim(0, 1)       #设定y坐标的范围
    plt.show()
    
plot_learning_curves(history)

在这里插入图片描述

3.1.4、数据归一化处理

归一化分两种，数据归一化，批归一化
查看归一化之前数据的最大值最小值

print(np.max(x_train), np.min(x_train))

在这里插入图片描述
数据归一化

#数据归一化
# x = (x - u) / std

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
# x_train:[None, 28, 28] -> [None, 784]
x_train_scaler = scaler.fit_transform(
    x_train.astype(np.float32).reshape(-1,1)).reshape(-1,28,28)  #之前数据是int的，因为要做除法，所以先转换成float32的
                                                                 #scaler.fit_transform()函数要求输入参数是二维数据，
                                                                 #所以先变成二维数据，然后再变回三维数据
#scaler.fit_transform()函数有fit功能，记录训练的均值和方差（因为后面验证集和测试集数据归一化的时候，都要使用训练集的均值和方差）

#验证集和测试集归一化,用scaler.transform()即可
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_scaler), np.min(x_train_scaler))

在这里插入图片描述
重新训练模型

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

在这里插入图片描述
绘图查看history中的变量变化过程

def plot_learning_curves(history):
    pd.DataFrame(history.history).plot(figsize = (8,5))   #将数据转换成DataFrame，然后调用plot实现
    plt.grid(True)      #绘制网格
    plt.gca().set_ylim(0, 1)       #设定y坐标的范围
    plt.show()
    
plot_learning_curves(history)

在这里插入图片描述

由结果可以看出对数据进行归一化处理之后，模型的精度有所提升（87.1%->89.2%）

#在测试集上进行测试
model.evaluate(x_test_scaled, y_test)

在这里插入图片描述

3.2、Keras回调函数

callbacks(回调函数)是在训练过程中做一些监听，所以要添加到fit函数中
修改训练模型为

#这里演示，使用三个常用的callbaks：TensorBoard, EarlyStopping, ModelCheckpoint
#对于Tensorboard需要一个文件夹，对于ModelCheckpoint来说需要一个文件名
#定义一个文件夹，和文件名
logdir = './callbacks'
#logdir = os.path.join("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),
    keras.callbacks.ModelCheckpoint(output_model_file,save_best_only = True),
    keras.callbacks.EarlyStopping(patience = 5, min_delta = 1e-3),
]
#callbacks是在训练过程中做一些监听，所以要添加到fit函数中
history = model.fit(x_train_scaler, y_train, epochs=10, 
                    validation_data = (x_valid_scaled, y_valid), 
                    callbacks = callbacks)

在这里插入图片描述
在根目录下，生成callbacks文件夹。
在这里插入图片描述
打开Anaconda Powershell Prompt
在这里插入图片描述
在命令行中输入：tensorboard --logdir=callbacks，会得到一个网址
在这里插入图片描述
用浏览器打开网址，就打开tensorboard了
SCALARS：显示训练趋势图
在这里插入图片描述
GRAPHS：显示模型结构
在这里插入图片描述
PROFILE：记录内存和CPU的使用量

3.3、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
#import keras

print(tf.__version__)
print(sys.version_info)
for module in mpl,np,pd,sklearn,tf,keras:
    print(module.__name__,module.__version__)

加载加福利尼亚房价数据集

from sklearn.datasets import fetch_california_housing

housing = fetch_california_housing()
print(housing.DESCR)
print(housing.data.shape)
print(housing.target.shape)

输出前5个数据查看，这里使用pprint()函数输出，他是一种标准、格式化输出方式。

import pprint
pprint.pprint(housing.data[0:5])
pprint.pprint(housing.target[0:5])

在这里插入图片描述
切分数据集

#切分数据集
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.25)  
#总体数据按照3:1的比例划分,可以通过添加test_size参数调整比例  （不写，默认就是0.25） 

#切分出训练集和验证集
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)

在这里插入图片描述
数据归一化

#数据归一化
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
x_train_scaled = scaler.fit_transform(x_train)
x_valid_scaled = scaler.transform(x_valid)
x_test_scaled = scaler.transform(x_test)

构建模型

#构建模型
model = keras.models.Sequential([
    keras.layers.Dense(30,activation='relu',input_shape=x_train.shape[1:]),   #这里取8(读取第二维的长度)，因为x_train.shape -> (11610,8)
    keras.layers.Dense(1),
])
model.summary()    #打印model的信息
model.compile(loss="mean_squared_error",optimizer="sgd")   #编译
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)

在这里插入图片描述
这里训练到18轮就停止训练了，因为损失进度的变换已经小于设定的1e-3，提前停止了训练。
绘图显示

#绘图显示
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)

在这里插入图片描述
测试集验证模型

model.evaluate(x_test_scaled,y_test)

在这里插入图片描述

3.4、Keras搭建深度神经网络

  • 激活函数
    在这里插入图片描述
  • 归一化与批归一化
    批归一化就是，从对输入数据进行归一化，扩展到网络的每层的激活值上。
    在这里插入图片描述
    在这里插入图片描述
  • Dropout
    在这里插入图片描述
    在这里插入图片描述

3.4.1、实战深度神经网络

修改构造模型部分即可

#tf.keras.models.Sequential()

'''
#构建模型(浅层神经网络)
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape = [28, 28]))
model.add(keras.layers.Dense(300, activation = "relu"))
model.add(keras.layers.Dense(100, activation = "relu"))
model.add(keras.layers.Dense(10, activation = "softmax"))
'''

#深度神经网络
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape = [28,28]))
for _ in range(20):
    model.add(keras.layers.Dense(100, activation="relu"))
model.add(keras.layers.Dense(10, activation="softmax"))

model.compile(loss = "sparse_categorical_crossentropy",     #如果y已经是向量了就用categorical_crossentropy",如果是数字就用sparse_
             optimizer = "sgd",
             metrics = ["accuracy"])

model.summary()

在这里插入图片描述

3.4.2、实战批归一化、激活函数、dropout

  • 加入批归一化，只需修改模型构建部分代码
#tf.keras.models.Sequential()

'''
#构建模型(浅层神经网络)
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape = [28, 28]))
model.add(keras.layers.Dense(300, activation = "relu"))
model.add(keras.layers.Dense(100, activation = "relu"))
model.add(keras.layers.Dense(10, activation = "softmax"))
'''

#深度神经网络
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape = [28,28]))
for _ in range(20):
    model.add(keras.layers.Dense(100, activation="relu"))
    #加 批归一化 层
    model.add(keras.layers.BatchNormalization())
    '''
    #激活函数放在批归一化BN的后面
    model.add(keras.layers.Dense(100))
    model.add(keras.layers.BatchNormalization())
    model.add(keras.layers.Activation('relu'))
    '''
model.add(keras.layers.Dense(10, activation="softmax"))

model.compile(loss = "sparse_categorical_crossentropy",     #如果y已经是向量了就用categorical_crossentropy",如果是数字就用sparse_
             optimizer = "sgd",
             metrics = ["accuracy"])

model.summary()

在这里插入图片描述
训练模型

#这里演示，使用三个常用的callbaks：TensorBoard, EarlyStopping, ModelCheckpoint
#对于Tensorboard需要一个文件夹，对于ModelCheckpoint来说需要一个文件名
#定义一个文件夹，和文件名
#logdir = './dnn-callbacks'
logdir = os.path.join("dnn-bn-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),
    keras.callbacks.ModelCheckpoint(output_model_file,save_best_only = True),
    keras.callbacks.EarlyStopping(patience = 5, min_delta = 1e-3),
]
#callbacks是在训练过程中做一些监听，所以要添加到fit函数中
history = model.fit(x_train_scaler, y_train, epochs=10, 
                    validation_data = (x_valid_scaled, y_valid), 
                    callbacks = callbacks)

在这里插入图片描述
加入批归一化BN层，准确率有所提升。

  • 修改激活函数：relu -> selu(自带批归一化功能的激活函数)
    修改模型构建部分代码

#深度神经网络
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape = [28,28]))
for _ in range(20):
    model.add(keras.layers.Dense(100, activation="selu"))  #selu函数自带批归一化功能。所以，这里就不需要批归一化处理了。
#     #加 批归一化 层
#     model.add(keras.layers.BatchNormalization())
#     '''
#     #激活函数放在批归一化BN的后面
#     model.add(keras.layers.Dense(100))
#     model.add(keras.layers.BatchNormalization())
#     model.add(keras.layers.Activation('relu'))
#     '''
model.add(keras.layers.Dense(10, activation="softmax"))

model.compile(loss = "sparse_categorical_crossentropy",     #如果y已经是向量了就用categorical_crossentropy",如果是数字就用sparse_
             optimizer = "sgd",
             metrics = ["accuracy"])
  • 添加Dropout层
#深度神经网络
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape = [28,28]))
for _ in range(20):
    model.add(keras.layers.Dense(100, activation="selu"))  #selu函数自带批归一化功能
#     #加 批归一化 层
#     model.add(keras.layers.BatchNormalization())
#     '''
#     #激活函数放在批归一化BN的后面
#     model.add(keras.layers.Dense(100))
#     model.add(keras.layers.BatchNormalization())
#     model.add(keras.layers.Activation('relu'))
#     '''
model.add(keras.layers.AlphaDropout(rate=0.5))  #更加强大的Dropout（常用）
'''
AlphaDropout强大之处:
    1、均值和方差不变
    2、归一化性质不变
'''
#model.add(keras.layers.Dropout(rate=0.5))  #rate丢掉的比例

model.add(keras.layers.Dense(10, activation="softmax"))

model.compile(loss = "sparse_categorical_crossentropy",     #如果y已经是向量了就用categorical_crossentropy",如果是数字就用sparse_
             optimizer = "sgd",
             metrics = ["accuracy"])

model.summary()

在这里插入图片描述

3.5、Keras实现wide&deep模型

3.5.1 wide&deep模型

  • google在16年发布，用于分类和回归
  • 这个算法已经应用到了Google play中的应用推荐

稀疏特征

  • 离散值特征（eg:性别）
  • One-hot表示（离散值用One-hot表示的时候，就认为是稀疏特征）
  • eg:专业={计算机，人文，其他}。人文=[0,1,0]
  • eg:词表={人工智能，你，他，慕课网，…}。他=[0,0,1,0,…]
  • 稀疏特征可以进行叉乘={（计算机，人工智能），（计算机，你），…}
  • 叉乘之后
    • 稀疏特征做叉乘获取共现信息
    • 实现记忆的效果
  • 优点
    • 有效，广泛用于工业界（推荐算法等）
  • 缺点
    • 需要人工设计
    • 可能过拟合，所有特征都叉乘，相当于记住每一个样本

密集特征

  • 向量表达
    • eg：词表={人工智能，你，他，慕课网}
    • 他=[0.3,0.2,0.6,(n维向量)]
  • Word2vec工具（将词语转换为向量的工具，通过向量之间的距离可以得到成语之间的距离）
  • 优点
    • 带有语义信息，不同向量之间有相关性
    • 兼容没有出现过的特征组合
    • 更少人工参与
  • 缺点
    • 过度泛化，推荐不怎么相关的产品

wide&deep模型结构
在这里插入图片描述
在这里插入图片描述

3.5.2 实战

  • wide&deep模型
    • 功能API（函数式API）
    • 子类API
    • 多输入与多输出

代码实现
- 功能API（函数式API）

#构建模型
# model = keras.models.Sequential([
#     keras.layers.Dense(30,activation='relu',input_shape=x_train.shape[1:]),   #这里取8(读取第二维的长度)，因为x_train.shape -> (11610,8)
#     keras.layers.Dense(1),
# ])

#使用函数式API（功能API）
input = keras.layers.Input(shape=x_train.shape[1:]) #这里取8(读取第二维的长度)，因为x_train.shape -> (11610,8)
hidden1 = keras.layers.Dense(30,activation='relu')(input)  #函数式API       本层30个单元
hidden2 = keras.layers.Dense(30,activation='relu')(hidden1) 
#这样的结构，更像是复合函数的结构：f(x) = h(g(x))

concat = keras.layers.concatenate([input,hidden2])       #hidden2是deep模型的输出，input是wide模型的输入
output = keras.layers.Dense(1)(concat)

#将函数式API定义的模型固化下来
model = keras.models.Model(inputs = [input],
                           outputs = [output])

model.summary()    #打印model的信息
model.compile(loss="mean_squared_error",optimizer="sgd")   #编译
callbacks = [keras.callbacks.EarlyStopping(patience = 5, min_delta = 1e-2)]

在这里插入图片描述
- 子类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(hidden2)
        return output

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

model.summary()    #打印model的信息
model.compile(loss="mean_squared_error",optimizer="sgd")   #编译
callbacks = [keras.callbacks.EarlyStopping(patience = 5, min_delta = 1e-2)]

在这里插入图片描述

  • 多输入
#多输入
input_wide = keras.layers.Input(shape=[5])
input_deep = keras.layers.Input(shape=[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.model.Model(inputs = [input_wide,input_deep],outputs = [output])

model.summary()    #打印model的信息
model.compile(loss="mean_squared_error",optimizer="sgd")   #编译
callbacks = [keras.callbacks.EarlyStopping(patience = 5, min_delta = 1e-2)]

x_train_scaled_wide = x_train_scaled[:,:5]  #输入前5个特征
x_train_scaled_deep = x_train_scaled[:,2:]  #输入后6个特征（一共8个特征）
x_valid_scaled_wide = x_valid_scaled[:,:5]
x_valid_scaled_deep = x_valid_scaled[:,2:]
x_test_scaled_wide = x_test_scaled[:,:5]
x_test_scaled_deep = x_test_scaled[:,2:]

#训练模型
history = model.fit([x_train_scaled_wide,x_train_scaled_deep], y_train, 
                    validation_data = ([x_valid_scaled_wide,x_valid_scaled_deep], y_valid), 
                    epochs = 100,
                    callbacks = callbacks)
  • 多输出(针对多任务学习)
#构建模型
#多输入+多输出
input_wide = keras.layers.Input(shape=[5])
input_deep = keras.layers.Input(shape=[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)
output2 = keras.layers.Dense(1)(hidden2)
model = keras.models.Model(inputs = [input_wide,input_deep],outputs = [output,output2])

model.summary()    #打印model的信息
model.compile(loss="mean_squared_error",optimizer="sgd")   #编译
callbacks = [keras.callbacks.EarlyStopping(patience = 5, min_delta = 1e-2)]

x_train_scaled_wide = x_train_scaled[:,:5]  #输入前5个特征
x_train_scaled_deep = x_train_scaled[:,2:]  #输入后6个特征（一共8个特征）
x_valid_scaled_wide = x_valid_scaled[:,:5]
x_valid_scaled_deep = x_valid_scaled[:,2:]
x_test_scaled_wide = x_test_scaled[:,:5]
x_test_scaled_deep = x_test_scaled[:,2:]

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

model.evaluate([x_test_scaled_wide,x_test_scaled_deep],[y_test,y_test])

3.6、Keras与scikit-learn实现超参数搜索

为什么要超参数搜索

  • 神经网络有很多训练过程中不变的参数
    • 网络结构参数：几层，每层宽度，每层激活函数等；
    • 训练参数：batch_size，学习率，学习率衰减算法等。
  • 手工去试耗费人力

搜索策略

  • 网格搜索；
    在这里插入图片描述
  • 随机搜索；
    • 参数的生成方式为随机
    • 可探索的空间更大
      在这里插入图片描述
  • 遗传算法搜索；
    • 对自然界的模拟；
    • A.初始化候选参数集合 -> 训练 -> 得到模型指标作为生存概率；
    • B.选择 -> 交叉 -> 变异 -> 产生下一代集合；
    • C.重新到A。
  • 启发式搜索。
    • 研究热点-AutoML
    • 使用循环神经网络来生成参数
    • 使用强化学习来进行反馈，使用模型来训练生成参数。

实战

  • 超参数搜索
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
#import keras

print(tf.__version__)
print(sys.version_info)
for module in mpl,np,pd,sklearn,tf,keras:
    print(module.__name__,module.__version__)

from sklearn.datasets import fetch_california_housing

housing = fetch_california_housing()
print(housing.DESCR)
print(housing.data.shape)
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.25)  
#总体数据按照3:1的比例划分,可以通过添加test_size参数调整比例  （不写，默认就是0.25） 

#切分出训练集和验证集
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)

#数据归一化
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
x_train_scaled = scaler.fit_transform(x_train)    #归一化的同时，可以算出均值和方差
x_valid_scaled = scaler.transform(x_valid)        #利用在训练集得到的均值和方差来归一化
x_test_scaled = scaler.transform(x_test)

重点

#learning_rate:[1e-4,3e-4,1e-3,3e-3,1e-2,3e-2]
# 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:]),   #这里取8(读取第二维的长度)，因为x_train.shape -> (11610,8)
    keras.layers.Dense(1),
    ])
    
    optimizer = keras.optimizers.SGD(lr)

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

上述方法实现了lr的超参数搜索，但是有两个很明显的缺点：
1、实际超参数远远不止一个，所以需要使用20层或者更多层的for循环来实现超参数搜索；
2、这里使用for循环来实现超参数搜索，这样就导致只能等上一个模型训练完成之后，后面的模型才能开始训练，没有一个并行化的处理，增加了模型实现的时间复杂度，很费时间。

所以，我们需要会用一些现有的库来实现超参数搜索。

  • 使用scikit实现超参数搜索
    将tf.keras的model转化为sklearn支持的model
  • 封装函数可以在Tensorflow官网API查到
    在这里插入图片描述
#RandomizedSearchCV
#1.将tf.keras的model转化为sklearn支持的的model （sklearn_model = keras.wrappers.scikit_learn.KerasRegressor(build_model)）
#2.定义参数集合
#3.搜索参数（hidden_layers、layer_size、learning_rate）

def build_model(hidden_layers = 1,layer_size = 30,learning_rate = 3e-3):    #中间层的层数、每一层的单元数、学习率
    model = keras.models.Sequential()     #定义model
    model.add(keras.layers.Dense(layer_size,activation='relu',input_shape = x_train.shape[1:]))   
    #上面这一层单独拿出来，不放在for里面，因为第一层需要指定输入的数据大小
    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)                    #学习率可变，所以自定义optimizer
    model.compile(loss = 'mse',optimizer = optimizer)                  #mse是mean_squared_error的缩写
    return model

#将model转换为sklearn_model
sklearn_model = keras.wrappers.scikit_learn.KerasRegressor(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)

在这里插入图片描述

#绘图显示
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)

在这里插入图片描述
model.evaluate(x_test_scaled,y_test)
sklearn中没有evaluate这个函数

from scipy.stats import reciprocal
#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),        #使用reciprocal分布生成数据 
}

#搜索参数
from sklearn.model_selection import RandomizedSearchCV

random_search_cv = RandomizedSearchCV(sklearn_model,
                                      param_distribution,      #参数空间
                                      n_iter = 10,             #从param_distribution中生成多少参数集合
                                      #n_jobs = 5，            #有多少任务在并行处理
                                      cv = 3,                  #默认就是3
                                      n_jobs = 1)              #现在还不能并行化（所以，改成1）

#运行搜索算法
random_search_cv.fit(x_train_scaled,y_train,epochs = 100,
                     validation_data = (x_valid_scaled,y_valid),
                     callbacks = callbacks)

在这里插入图片描述
注：查看reciprocal分布生成的数据
在这里插入图片描述

'''
在超参数搜索的过程中每个epoch遍历7740个样本，而不是之前的11000多个。
这是因为，在做超参数搜索的时候用了cross_validation。
cross_validation:把训练集平均分成n份，用n-1份去训练，最后一份验证。（交叉验证）
默认n=3
'''

#查看最好的参数和最好的分值都是多少
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)

在这里插入图片描述

您可能感兴趣的与本文相关的镜像

TensorFlow-v2.15

TensorFlow-v2.15

TensorFlow

TensorFlow 是由Google Brain 团队开发的开源机器学习框架,广泛应用于深度学习研究和生产环境。 它提供了一个灵活的平台,用于构建和训练各种机器学习模型

谷歌tensorflow例程2
10-23
谷歌tensorflow安卓例程，是分开打包的，一共4个，要一起下载后解压缩。工程包括1000物体识别，90物体检测，图片风格融合，英文单词语音识别
TensorFlow2.0入门到进阶系列——8_模型保存与部署
Xiaobai_rabbit0的博客
05-20 876
8_模型保存与部署1、实战部分1.1、模型保存与部署1.2、模型转tflite1.3、量化处理2、实战2.1、keras-保存参数与保存模型+参数2.1.1、保存模型结构2.1.2、保存模型参数（keras_load_weights） 1、实战部分 保存模型 模型转tflite 量化处理 Tensorflow.js部署模型 Android部署模型 1.1、模型保存与部署 1.2、模型转tflite 1.3、量化处理 2、实战 keras-保存参数与保存模型+参数 keras,签名函数到Sav
TensorFlow2.0入门到进阶2.9 —— 实战深度神经网络
caoyuan666的博客
04-30 1674
文章目录1、写在前面2、深度神经网络3、举个栗子 1、写在前面 有人会问，2.88在哪呢？其实2.8是一些基础理论知识，这一部分在2.1已经介绍的很详细了，如果不了解看看2.1吧。 这里说个知识点吧： dropout 通俗来说，就是将训练好的十分复杂的神经网络，去除一部分连接，如下图所示。那么有人会问，这么费劲训练好的网络，为什么还要去掉一部分连接？这主要是为了提高训练模型的泛化能力。 一般在...
TensorFlow 2.0 快速入门进阶教程
蓝三金的博客
03-08 4852
Colab 传送门 译自：TensorFlow 官方教程 在进阶教程里，我们将使用 keras 的模型子类化（subclassing） API 建立模型。 首先导入需要的库 from __future__ import absolute_import, division, print_function import tensorflow_datasets as tfds import tenso...
TensorFlow2.0实战： 入门到进阶深度学习
中科院AI算法工程师的博客
12-28 2702
Google老师亲授 TensorFlow2.0 入门到进阶 课程以Tensorflow2.0框架为主体，以图像分类、房价预测、文本分类等项目为依托，讲解Tensorflow框架的使用方法，同时学习到相关的深度学习/机器学习知识。 课程目录 课程下载 公众号【计算机视觉联盟】回复关键词【20191228】即可获取下载链接！ ...
Google老师亲授 TensorFlow2.0 入门到进阶 学习笔记 ch2_2
xuanshuang的博客
08-24 874
11、wide_deep模型 简介 google16 年发布，用于分类和回归 应用到了Google Play中的应用推荐 原始论文：https://arxiv.org/pdf/1606.07792v1.pdf 稀疏特征 离散值特征 One-hot表示 Eg：专业={计算机，人文，其他}，人文=[0, 1, 0] Eg：词表={人工智能，你，他，慕课网，...}，他=[0, 0, 1, 0,...] 叉乘={(计算机, 人工智能), (计算机, 你),...} 叉乘之后 稀疏特征做叉乘获
TensorFlow2.0入门到进阶系列——7_tensorflow分布式
Xiaobai_rabbit0的博客
05-20 674
7_tensorflow分布式1、理论部分1.1、GPU设置1.1.1、API列表1.2、分布式策略2、实战部分2.1、GPU设置实战2.1.1、GPU使用实战2.2、分布式训练实战 1、理论部分 1.1、GPU设置 默认使用全部GPU并且内存全部占满，这样很浪费资源 如何不浪费内存和计算资源 内存自增长 虚拟设备机制 多GPU使用 虚拟GPU & 实际GPU 手工设置 & 分布式机制 1.1.1、API列表 tf.debugging.set_log_device_plac
TensorFlow2.0入门到进阶系列——5.1_TensorFlow进阶篇
Xiaobai_rabbit0的博客
05-11 1109
5_TensorFlow进阶篇1、Tf.estimator使用2.1、API列表2、Estimator实战二级目录三级目录 1、Tf.estimator使用 keras转estimator 使用预定义的estimator BaseLineClassifier LinearClassifier DNNClassifier Tf.feature_column做特征工程 2.1、API列表 Tf.keras.estimator.to_estimator Train,evaluate Tf.est
TensorFlow2.0入门到进阶2.10 —— 批归一化、dropout、激活函数
caoyuan666的博客
04-30 4375
文章目录1、批归一化2、dropout3、激活函数3.1 原理部分：3.2 各直观图像激活函数3.3 代码 1、批归一化 原理部分：一文轻松搞懂Keras神经网络（理论+实战） 批归一化其实就是在每经过一层神经网络训练后，将训练结果重新归一化，从而为经过下一层神经网络提过一个良好的数据，消除量纲的影响。 代码： model.add(keras.layers.BatchNormalization()...
TensorFlow2.0入门到进阶系列——5.3_TensorFlow—kaggle实战
Xiaobai_rabbit0的博客
05-13 880
5.2_TensorFlow—kaggle实战1、kaggle实战1.1、使用数据增强 1、kaggle实战 利用kaggle进行训练 登陆kaggle官网 找到10-monkey-species数据集 新建notebook编写代码 1.1、使用数据增强 加载库 %matplotlib inline import matplotlib as mpl import matplotlib.pyplot as plt import numpy as np import os import pandas a
TensorFlow2.0入门到进阶系列——0_内容介绍
Xiaobai_rabbit0的博客
05-01 387
内容介绍0 先贴图 后面改成导图1 TensorFlow简介2 TensorFlow keras实战3 TensorFlow基础API使用4 TensorFlow dataset使用5 TensorFlow Estimator使用与tf1.06 卷积神经网络7 循环神经网络8 TensorFlow分布式9 TensorFlow模型保存与部署10 机器翻译与tensor2tensor使用 0 先贴...
TensorFlow2.0 进阶
qq_41168327的博客
02-27 339
拼接：通过 tf.concat(tensors, axis)，其中 tensors 保存了所有需要合并的张量 List，axis 指定需要合并的维度 堆叠： tf.concat（） 直接在现有维度上面合并数据，并不会创造新的维度 若希望创建一个新的维度，则需要使用 tf.stack( ) 操作。但tf.stack( )需要所有的合并张量完全一致；使用 tf.stack(tensors, axis)...
Tensorflow2.0：进阶操作
Docpark
02-19 391
目录 一 合并与分割 1.合并 拼接 tf.concat 含义：原有维度上的合并，不会增加新的维度 要求：任意维度上拼接，非拼接的维度长度要一样 a = tf.random.normal([4, 35, 8]) b = tf.random.normal([6, 35, 8]) # 第一个维度上的拼接 c = tf.concat([a, b], axis=0) # shape为[10,35,8] ...
keras2tensorflow
fkyyly的专栏
05-07 480
keras模型文件转化为tensorflow的pb文件，然后java调用 from keras.models import load_model from keras import backend as K from keras.models import model_from_config import tensorflow as tf model = load_model('mode...
TensorFlow2.0入门到进阶 —— 1.1前言：整体内容介绍
caoyuan666的博客
03-11 916
文章目录1、前言2、主要内容3、PS 1、前言 TensorFlow是谷歌2015年开源的通用高性能计算库。最初主要是为构建神经网络(NNs)提供高性能的API。然而，随着时间的推移和机器学习(ML)社区的兴起，TensorFlow已经发展为一个完整的机器学习生态系统。 2019年6月发布了TensorFlow 2.0测试版之后，Google于周一宣布了其最终版本。该版本与Keras紧密集成，默认...
神经网络与深度学习——TensorFlow2.0实战(笔记)(五)(Matplotlib绘图基础＜1＞python)
Z_W_H_的博客
04-24 381
数据可视化 数据分析阶段：理解和洞察数据之间的关系 算法调试阶段：发现问题，优化算法 项目总结阶段：展示项目成果 Matplotlib： 第三方库，可以快速方便地生成高质量的图表 安装Matplotlib库 Figure 对象： 创建画布 #matplotlib绘图库 #pyplot子库用于绘制二维图表 import matplotlib.pyplot as plt #figure对象 plt.figure(figsize=(3,2),facecolor="green") plt
官方推荐！用TensorFlow 2.0做深度学习入门教程
ctrigger的专栏
07-06 380
最近，TensorFlow 2.0版的开发者预览版发布没多久，这不，又有一篇优质教程来了。 最近，前Youtube视频分类的产品经理、Hands-On MachineLearning with ScikitLearn and TensorFlow一书的作者Aurélien Geron 就发布了用tf.keras和TensorFlow2.0做深度学习任务的Jupyter教程。 教程一...
tensorflow和keras版本对应关系
热门推荐
成功的方式只有一个，按自己的方式，度过人生。欢迎共赴知识与乐趣的探索之旅！
10-20 1万+
tensorflow和keras版本对应关系 Keras 2.3.1: Tensorflow 2.1 Tensorflow 2.0 Tensorflow 1.15 Keras 2.2.5: Tensorflow 1.14 Tensorflow 1.13 Tensorflow 1.12 Keras 2.2.4: Tensorflow 1.11 Tensorflow 1.10 Keras 2.2.0: Tensorflow 1.9
TensorFlow2.0入门到进阶2.1 —— 一文轻松搞懂Keras神经网络（理论+实战）
caoyuan666的博客
04-08 2816
欢迎进入TensorFlow2.0入门到进阶的第二章内容，这一章将主要讲解利用tf.keras的实战部分。本节主要是对tf.keras的简要介绍。 文章目录1、理论部分1.1 TensorFlow-Keras简介1.1.1 Keras1.1.2 tf-keras和keras相同点1.1.3 tf-keras和keras不同点1.2 分类问题、回归1.2.1 分类1.2.2 回归：1.3 目标函数、...
TensorFlow从入门到进阶：构建神经网络实战教程
本文件标题为《TensorFlow教程：从基础到难》，结合其描述、标签以及压缩包内文件名称“Tensorflow-Tutorial-master”，可以明确该资源是一套系统性极强的TensorFlow学习资料，涵盖了从初学者入门到高级神经网络架构...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值