在模型训练完成后，我们需要对我们训练出来的模型进行持久性储存，这样既能将我们调参后得到的最佳模型进行存储，还可以方便后期同团队的人进行调用预测。
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)训练及存储模型宽度学习（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,
'sigmoid': self.sigmoid,
'tanh': self.tanh,
'relu': self.relu}[function_num] # 激活函数供不同的层选择
# 下面就是先得到一组mapping nodes，再不断叠加，得到len(Wlist)组mapping nodes
nodes = self.function_num(data.dot(self.Wlist[0]) + self.blist[0])
for i in range(1, len(self.Wlist)):
nodes = np.column_stack((nodes, self.function_num(data.dot(self.Wlist[i]) + self.blist[i])))
return nodes
def transform(self, testdata):
testnodes = self.function_num(testdata.dot(self.Wlist[0]) + self.blist[0])
for i in range(1, len(self.Wlist)):
testnodes = np.column_stack((testnodes, self.function_num(testdata.dot(self.Wlist[i]) + self.blist[i])))
return testnodes
# 归一化处理
class scaler:
def __init__(self):
self._mean = 0
self._std = 0
def fit_transform(self, traindata):
self._mean = traindata.mean(axis=0)
self._std = traindata.std(axis=0)
return (traindata - self._mean) / (self._std + 0.001)
def transform(self, testdata):
return (testdata - self._mean) / (self._std + 0.001)
# 宽度神经网络结构
class broadNet(object):
def __init__(self, map_num=10, enhance_num=10, map_function='linear', enhance_function='linear', batchsize='auto'):
self.map_num = map_num
self.enhance_num = enhance_num
self.batchsize = batchsize
self.map_function = map_function
self.enhance_function = enhance_function
self.W = 0
self.pseudoinverse = 0
self.normalscaler = scaler()
self.onehotencoder = preprocessing.OneHotEncoder(sparse=False)
self.mapping_generator = node_generator()
self.enhance_generator = node_generator(isenhance=True)
def fit(self, data, label):
if self.batchsize == 'auto':
self.batchsize = data.shape[1]
data = self.normalscaler.fit_transform(data)
label = self.onehotencoder.fit_transform(np.mat(label).T)
mappingdata = self.mapping_generator.generator_nodes(data, self.map_num, self.batchsize, self.map_function)
enhancedata = self.enhance_generator.generator_nodes(mappingdata, self.enhance_num, self.batchsize,
self.enhance_function)
print('number of mapping nodes {0}, number of enhence nodes {1}'.format(mappingdata.shape[1],
enhancedata.shape[1]))
print('mapping nodes maxvalue {0} minvalue {1} '.format(round(np.max(mappingdata), 5),
round(np.min(mappingdata), 5)))
print('enhence nodes maxvalue {0} minvalue {1} '.format(round(np.max(enhancedata), 5),
round(np.min(enhancedata), 5)))
inputdata = np.column_stack((mappingdata, enhancedata))
print('input shape ', inputdata.shape)
pseudoinverse = np.linalg.pinv(inputdata)
# 新的输入到输出的权重
print('pseudoinverse shape:', pseudoinverse.shape)
self.W = pseudoinverse.dot(label)
def decode(self, Y_onehot):
Y = []
for i in range(Y_onehot.shape[0]):
lis = np.ravel(Y_onehot[i, :]).tolist()
Y.append(lis.index(max(lis)))
return np.array(Y)
def accuracy(self, 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))
def predict(self, testdata):
testdata = self.normalscaler.transform(testdata)
test_mappingdata = self.mapping_generator.transform(testdata)
test_enhancedata = self.enhance_generator.transform(test_mappingdata)
test_inputdata = np.column_stack((test_mappingdata, test_enhancedata))
return self.decode(test_inputdata.dot(self.W))
if __name__ == '__main__':
# load the data
train_data = pd.read_csv('../train.csv')
test_data = pd.read_csv('../test.csv')
samples_data = pd.read_csv('../sample_submission2.csv')
le = preprocessing.LabelEncoder()
#for item in train_data.columns:
# train_data[item] = le.fit_transform(train_data[item])
label = train_data['label'].values
data = train_data.drop('label', axis=1)
data = data.values
print(data.shape, max(label) + 1)
traindata, testdata, trainlabel, testlabel = train_test_split(data, label, test_size=0.2, random_state=0)
print(traindata.shape, trainlabel.shape, testdata.shape, testlabel.shape)
bls = broadNet(map_num=32,
enhance_num=33,
map_function='sigmoid',
enhance_function='sigmoid',
batchsize=200)
starttime = datetime.datetime.now()
bls.fit(traindata, trainlabel)
endtime = datetime.datetime.now()
# 存储训练后模型
joblib.dump(bls,"model1.pkl")
print('the training time of BLS is {0} seconds'.format((endtime - starttime).total_seconds()))
predictlabel = bls.predict(testdata)
print(show_accuracy(predictlabel, testlabel))调用自己训练的模型代码：
import numpy as np
from sklearn import preprocessing
import pandas as pd
import joblib
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,
'sigmoid': self.sigmoid,
'tanh': self.tanh,
'relu': self.relu}[function_num] # 激活函数供不同的层选择
# 下面就是先得到一组mapping nodes，再不断叠加，得到len(Wlist)组mapping nodes
nodes = self.function_num(data.dot(self.Wlist[0]) + self.blist[0])
for i in range(1, len(self.Wlist)):
nodes = np.column_stack((nodes, self.function_num(data.dot(self.Wlist[i]) + self.blist[i])))
return nodes
def transform(self, testdata):
testnodes = self.function_num(testdata.dot(self.Wlist[0]) + self.blist[0])
for i in range(1, len(self.Wlist)):
testnodes = np.column_stack((testnodes, self.function_num(testdata.dot(self.Wlist[i]) + self.blist[i])))
return testnodes
class scaler:
def __init__(self):
self._mean = 0
self._std = 0
def fit_transform(self, traindata):
self._mean = traindata.mean(axis=0)
self._std = traindata.std(axis=0)
return (traindata - self._mean) / (self._std + 0.001)
def transform(self, testdata):
return (testdata - self._mean) / (self._std + 0.001)
class broadNet(object):
def __init__(self, map_num=10, enhance_num=10, map_function='linear', enhance_function='linear', batchsize='auto'):
self.map_num = map_num
self.enhance_num = enhance_num
self.batchsize = batchsize
self.map_function = map_function
self.enhance_function = enhance_function
self.W = 0
self.pseudoinverse = 0
self.normalscaler = scaler()
self.onehotencoder = preprocessing.OneHotEncoder(sparse=False)
self.mapping_generator = node_generator()
self.enhance_generator = node_generator(isenhance=True)
def fit(self, data, label):
if self.batchsize == 'auto':
self.batchsize = data.shape[1]
data = self.normalscaler.fit_transform(data)
label = self.onehotencoder.fit_transform(np.mat(label).T)
mappingdata = self.mapping_generator.generator_nodes(data, self.map_num, self.batchsize, self.map_function)
enhancedata = self.enhance_generator.generator_nodes(mappingdata, self.enhance_num, self.batchsize,
self.enhance_function)
print('number of mapping nodes {0}, number of enhence nodes {1}'.format(mappingdata.shape[1],
enhancedata.shape[1]))
print('mapping nodes maxvalue {0} minvalue {1} '.format(round(np.max(mappingdata), 5),
round(np.min(mappingdata), 5)))
print('enhence nodes maxvalue {0} minvalue {1} '.format(round(np.max(enhancedata), 5),
round(np.min(enhancedata), 5)))
inputdata = np.column_stack((mappingdata, enhancedata))
print('input shape ', inputdata.shape)
pseudoinverse = np.linalg.pinv(inputdata)
# 新的输入到输出的权重
print('pseudoinverse shape:', pseudoinverse.shape)
self.W = pseudoinverse.dot(label)
def decode(self, Y_onehot):
Y = []
for i in range(Y_onehot.shape[0]):
lis = np.ravel(Y_onehot[i, :]).tolist()
Y.append(lis.index(max(lis)))
return np.array(Y)
def accuracy(self, 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))
def predict(self, testdata):
testdata = self.normalscaler.transform(testdata)
test_mappingdata = self.mapping_generator.transform(testdata)
test_enhancedata = self.enhance_generator.transform(test_mappingdata)
test_inputdata = np.column_stack((test_mappingdata, test_enhancedata))
return self.decode(test_inputdata.dot(self.W))
if __name__ == '__main__':
test_data = pd.read_csv('../test.csv')
samples_data = pd.read_csv('../sample_submission2.csv')
# 加载训练好的模型
BLS = joblib.load("model1.pkl")
predicts = BLS.predict(test_data)
# save as csv file
samples = samples_data['ImageId']
result = {'ImageId':samples,
'Label': predicts }
result = pd.DataFrame(result)
result.to_csv('../output/model8.csv', index=False)
调用后的模型对测试集进行预测的结果：
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）