TensorLayer保存和读取模型

TensorLayer保存和读取模型

API简介

保存

TensorLayer中文版文档-API-save_npz
输入参数

tensorlayer.files.save_npz(save_list=[], name='model.npz', sess=None)

其中save_list为所要保存的参数，name为路径和保存的文件名，传入一个sess来执行此次操作。
至于其他读取方式的API于此类似，这里不再赘述。

读取

输入参数
TensorLayer中文版文档-API-load_and_assign_npz

tensorlayer.files.load_and_assign_npz(sess=None, name=None, network=None)

其中sess和name意义与保存（save_npz）相同，但是要注意的是network，到底该传入什么？
查阅文档可知

Parameters:
sess : TensorFlow Session
name : string Model path.
network : a Layer class The network to be assigned

Returns: Returns False if faild to model is not exist.

显而易见，应该传入一个Layer类，然而如果只是简单初始化一个Layer类的变量传进去，运行立刻就会报错。

mynetwork=tl.layers.Layer 
tensorlayer.files.load_and_assign_npz(sess, "model.npz",mynetwork) #报错

原因在于TensorLayer（也可以说是TensorFlow）所谓的保存，只是保存模型的参数和变量的值，而不是模型本身。这一点和sklearn中的模型保存是有区别的。
因此只有当读取时的Layer（即模型）和保存时的模型结构上一模一样，才可以将保存的模型参数一一对应，从而对模型赋值。

举例：
模型保存时有3层，分别有800，500，400个节点，意味着有800+500+400个参数（不严谨，但可以这么理解）。
然而在读取的时候，也必须构建一个3层，分别有800，500，400个节点的模型才能将这些参数一一赋值到对应的位置上去。
这两个模型的唯一区别就在于前者模型的节点参数已经被赋值，后者并没有。

代码实践

定义模型类

上述提到要构建一个和存储前一模一样模型骨架，首要的问题在于，描述一个模型骨架的完备的条件是什么？
1个网络，3个方法（训练，损失，精确函数）

class NetworkStructure:
    def __init__(self, network, trainMethod, loss, acc):
        self.network = network
        self.trainMethod = trainMethod
        self.loss = loss
        self.acc = acc
    def printLayers(self, type=""):   # 只是用于输出模型骨架信息
        print("%s Network Structure:" % (type))
        self.network.print_layers()
        print(" end")

构建模型骨架

接下来就可以根据自己的需求来设计模型的骨架了。
要注意的是设计模型骨架时不需要使用Session来执行任何语句（因为暂时不需要训练），同时模型骨架的接口，也就是数据输入的模式x_placeholder需要传入到模型骨架里。
代码如下：

def buildNetwork(x_placeholder):
    #####构建NetworkStructure.network
    network = tl.layers.InputLayer(x_placeholder, name="input_layer")
    network = tl.layers.DenseLayer(network, n_units=256, act=tf.nn.relu, name="hidden_dense_layer")
    network = tl.layers.DropoutLayer(network, keep=0.8, name="drop_layer")
    network = tl.layers.DenseLayer(network, n_units=1, act=tf.identity, name="output_layer")

    #####构建NetworkStructure.loss
    y = network.outputs  # 训练结果
    loss = tl.cost.mean_squared_error( y,y_)

    #####构建NetworkStructure.acc
    acc = tl.cost.normalized_mean_square_error( y,y_)

    #####构建NetworkStructure.trainMethod
    trainMethod = tf.train.GradientDescentOptimizer(0.005).minimize(loss)

    # 初始化MyNetwork
    MyNetwork = NetworkStructure(network, trainMethod, loss, acc)

    # 列出模型信息
    # network.print_params() #不要输出模型参数，此时只有模型骨架，参数并没有初始化！！
    MyNetwork.printLayers()  # 输出模型的结构参数
    return MyNetwork

到此一个完整的新的模型骨架就定义在了MyNetwork这个对象中了。

模型训练

定义好自己的模型骨架后就可以开始训练了。这里使用TL提供的utils.fit方法进行训练。

    sess = tf.InteractiveSession()
    # 初始化数据
    x_data, y_data, x_test, y_test, x_val, y_val = initData()  # 分别为训练集data，测试集test和验证集val
    # 初始化placeholder
    x, y_ = initPlaceHolder(x_data, y_data)
    # 构建模型骨架
    MyNetwork = buildNetwork(x)
    # 开始训练
    tl.utils.fit(
        sess, 
        MyNetwork.network, 
        MyNetwork.trainMethod,
        MyNetwork.loss, 
        x_data, y_data, x, y_,
        acc=MyNetwork.acc, 
        batch_size=50, n_epoch=1000, print_freq=100,
        X_val=x_val, y_val=y_val，tensorboard=True)

模型存储

模型存储非常简单，我们需要存储模型MyNetwork中的network，因此只需要导出network的所有参数并作为输入即可。

    ......
    tl.utils.fit(......)#训练完毕后
        # 存储模型
    tl.files.save_npz(
        save_list=MyNetwork.network.all_params,
        name="model/model5.npz", 
        sess=sess)

存储后在model文件夹中会有一个model5.npz的文件。这个就是模型的参数文件了，里面包含了模型所有参数数据。

模型读取

上文提到要想读取模型，首先要构建一个和被存储模型一模一样的骨架才能将所有参数一一赋值给读取模型的骨架。
因此，要做的第一步就是复现存储时的模型骨架。这部分代码基本与构建模型的基本一致。唯一的区别在于，此时并不需要训练。

    sess = tf.InteractiveSession()
    # 初始化数据
    x_data, y_data, x_test, y_test, x_val, y_val = initData()  # 分别为训练集data，测试集test和验证集val
    # 初始化placeholder
    x, y_ = initPlaceHolder(x_data, y_data)
    # 构建模型骨架
    MyNetwork = buildNetwork(x)
    #不要需要fit训练！！构建好骨架MyNetwork之后，直接读取。
    tl.files.load_and_assign_npz(sess, name="model/model5.npz", network=MyNetwork.network)
    #到此，MyNetwork模型读取完毕，和存储前的模型一模一样啦！

到此模型的存储和读取介绍完毕。这些只是TensorLayer下的存储和读取方式，但是对于Tensorflow其思路是一样的。
要记住的是，直接存储模型太抽象，难以移植，而模型最重要的就是模型中每一个节点的权值与参数，因此只要有了参数，就可以在任何平台上重新搭建模型骨架，通过给每一个节点赋值，复现存储前的模型。

完整代码

以下是本次教程的完整代码：

import tensorflow as tf
import tensorlayer as tl
import numpy as np



def initData():
    # 使用 NumPy 生成假数据(phony data), 总共 100 个点.
    x_data_sum = np.float32(np.random.rand(6000, 4))  # 随机输入
    y_data_sum = np.array([x * (y + z) + w + 0.01 for x, y, z, w in x_data_sum])

    x_test = x_data_sum[0:1000].reshape(-1, x_data_sum.shape[1])
    y_test = np.array([np.array([x]) for x in y_data_sum[0:1000]])

    x_data = x_data_sum[1000:5000].reshape(-1, x_data_sum.shape[1])
    y_data = np.array([np.array([x]) for x in y_data_sum[1000:5000]])

    x_val = x_data_sum[-1000:].reshape(-1, x_data_sum.shape[1])
    y_val = np.array([np.array([x]) for x in y_data_sum[-1000:]])

    return x_data, y_data, x_test, y_test, x_val, y_val


def initPlaceHolder(x_data, y_data):
    with tf.name_scope("inputs"):
        x = tf.placeholder(tf.float32, shape=[None, x_data.shape[1]], name='x_in')  # 训练特征输入
        y_ = tf.placeholder(tf.float32, shape=[None, 1], name='y_in')  # 真实结果
    return x, y_


class NetworkStructure:
    def __init__(self, network, trainMethod, loss, acc):
        self.network = network
        self.trainMethod = trainMethod
        self.loss = loss
        self.acc = acc

    def printLayers(self, type=""):
        print("%s Network Structure:" % (type))
        self.network.print_layers()
        print(" end")


def buildNetwork(x_placeholder):
    #####构建NetworkStructure.network
    network = tl.layers.InputLayer(x_placeholder, name="input_layer")
    network = tl.layers.DenseLayer(network, n_units=256, act=tf.nn.relu, name="hidden_dense_layer")
    network = tl.layers.DropoutLayer(network, keep=0.8, name="drop_layer")
    network = tl.layers.DenseLayer(network, n_units=1, act=tf.identity, name="output_layer")

    #####构建NetworkStructure.loss
    y = network.outputs  # 训练结果
    loss = tl.cost.mean_squared_error( y,y_)

    #####构建NetworkStructure.acc
    acc = tl.cost.normalized_mean_square_error( y,y_)

    #####构建NetworkStructure.trainMethod
    trainMethod = tf.train.GradientDescentOptimizer(0.005).minimize(loss)

    # 初始化MyNetwork
    MyNetwork = NetworkStructure(network, trainMethod, loss, acc)

    # 列出模型信息
    # network.print_params() #不要输出模型参数，此时只有模型骨架，参数并没有初始化！！
    MyNetwork.printLayers()  # 输出模型的结构参数
    return MyNetwork


if __name__ == '__main__':
    sess = tf.InteractiveSession()
    # 初始化数据
    x_data, y_data, x_test, y_test, x_val, y_val = initData()  # 分别为训练集data，测试集test和验证集val
    # 初始化placeholder
    x, y_ = initPlaceHolder(x_data, y_data)
    # 构建模型骨架
    MyNetwork = buildNetwork(x)
    TrainAndSave = True  #控制TrainAndSave 可以实现存储与读取的切换
    if TrainAndSave:
        # 开始训练
        tl.utils.fit(sess, MyNetwork.network, MyNetwork.trainMethod, MyNetwork.loss, x_data, y_data, x, y_,
                     acc=MyNetwork.acc, batch_size=50, n_epoch=1000, print_freq=100,
                     X_val=x_val, y_val=y_val, eval_train=False, tensorboard=True)
        # 存储模型
        tl.files.save_npz(save_list=MyNetwork.network.all_params,name="model/model5.npz", sess=sess)
    else:
        # 读取模型
        tl.files.load_and_assign_npz(sess, name="model/model5.npz", network=MyNetwork.network)

    x_Test = np.array([[0.5, 0.3, 0.8, 0.1], [0.1, 0.7, 0.7, 0.1], [0.9, 0.1, 0.3, 0.9], [0.45, 0.23, 0.45, 0.91]])
    # y_Test = [0.66, 0.25, 1.27, 1.226]
    y = MyNetwork.network.outputs
    y_op = tf.identity(y)

    print(tl.utils.predict(sess, MyNetwork.network, x_Test, x, y_op))