python宽度学习训练后模型的持久化存储和快速调用

在模型训练完成后，我们需要对我们训练出来的模型进行持久性储存，这样既能将我们调参后得到的最佳模型进行存储，还可以方便后期同团队的人进行调用预测。

1.原理

此处用到的是sklearn库中的joblib包进行存储和加载

因为宽度学习的类属于自定义类，所以在调用时需要在调用的py文件中加入bls代码中的类（在bls代码中分别是node_generator, scaler, broadNet）

如果不加入这些类，由于宽度学习是未知自定义的模型的结构，joblib包将无法解析模型，出现报错：AttributeError: Can‘t get attribute ‘XXX‘ on ＜module ‘__main__‘ from XXX＞

2.核心代码

首先我们需要在训练模型后，对训练后的模型进行存储

核心代码

# bls模型训练
bls.fit(traindata, trainlabel)
# 存储训练后的模型
joblib.dump(bls,"model1.pkl")

然后再另一文件中加载模型文件——model1.pkl

核心代码

# 加载模型
BLS = joblib.load("model1.pkl")
# 用加载后的模型对测试集进行预测
predicts = BLS.predict(test_data)

3.完整代码

训练及存储模型宽度学习（bls）代码：

import numpy as np
from sklearn import preprocessing
import pandas as pd
from sklearn.model_selection import train_test_split
import datetime
import joblib

# 准确度显示
def show_accuracy(predictLabel, Label):
    Label = np.ravel(Label).tolist()
    predictLabel = predictLabel.tolist()
    count = 0
    for i in range(len(Label)):
        if Label[i] == predictLabel[i]:
            count += 1
    return (round(count / len(Label), 5))


# 线性/非线性变化
class node_generator(object):
    def __init__(self, isenhance=False):
        self.Wlist = []
        self.blist = []
        self.function_num = 0
        self.isenhance = isenhance

    def sigmoid(self, x):
        return 1.0 / (1 + np.exp(-x))

    def relu(self, x):
        return np.maximum(x, 0)

    def tanh(self, x):
        return (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))

    def linear(self, x):
        return x

    def orth(self, W):
        """
        orth是正交基的意思，求正交基可能是为了使增强节点彼此无关
        目前看来，这个函数应该配合下一个generator函数是生成权重的
        此函数传入的weights与传出的weights的shape是一样的。
        """
        for i in range(0, W.shape[1]):
            w = np.mat(W[:, i].copy()).T
            w_sum = 0
            for j in range(i):
                wj = np.mat(W[:, j].copy()).T
                w_sum += (w.T.dot(wj))[0, 0] * wj
            w -= w_sum
            w = w / np.sqrt(w.T.dot(w))
            W[:, i] = np.ravel(w)

        return W

    def generator(self, shape, times):
        for i in range(times):
            W = 2 * np.random.random(size=shape) - 1
            if self.isenhance == True:
                W = self.orth(W)  # 只在增强层使用
            b = 2 * np.random.random() - 1
            yield (W, b)

    def generator_nodes(self, data, times, batchsize, function_num):
        # 按照bls的理论，mapping layer是输入乘以不同的权重加上不同的偏差之后得到的
        # 若干组，所以，权重是一个列表，每一个元素可作为权重与输入相乘
        self.Wlist = [elem[0] for elem in self.generator((data.shape[1], batchsize), times)]
        self.blist = [elem[1] for elem in self.generator((data.shape[1], batchsize), times)]

        self.function_num = {'linear': self.linear,