Sigkit学习模型持久性：泡菜vs pmml vs...？

Question

我构建了一个scikit学习模型，并希望在日常python cron作业中重用它（注意：不涉及其他平台-没有R，没有Java）

我对它进行了pickle（实际上，我对自己的对象进行了pickle，其中一个字段是GradientBoostingClassifier），然后在cron作业中取消了pickle。到目前为止还不错（在scikit learn中将分类器保存到磁盘和在scikit learn中将模型持久化中进行了讨论？）。

但是，我升级了skLearning，现在我得到了这些警告：

.../.local/lib/python2.7/site-packages/sklearn/base.py:315: 
UserWarning: Trying to unpickle estimator DecisionTreeRegressor from version 0.18.1 when using version 0.18.2. This might lead to breaking code or invalid results. Use at your own risk.
UserWarning)
.../.local/lib/python2.7/site-packages/sklearn/base.py:315: 
UserWarning: Trying to unpickle estimator PriorProbabilityEstimator from version 0.18.1 when using version 0.18.2. This might lead to breaking code or invalid results. Use at your own risk.
UserWarning)
.../.local/lib/python2.7/site-packages/sklearn/base.py:315: 
UserWarning: Trying to unpickle estimator GradientBoostingClassifier from version 0.18.1 when using version 0.18.2. This might lead to breaking code or invalid results. Use at your own risk.
UserWarning)

我现在该怎么办？

>

我可以解开文件并重新腌制它。这在0.18.2时有效，但在0.19时中断。joblib看起来也好不到哪去。

我希望我可以将数据保存为独立于版本的ASCII格式（例如，JSON或XML）。显然，这是最佳的解决方案，但似乎没有办法做到这一点（另请参见Sklearn-model persistence without-pkl file）。

我可以将模型保存到PMML，但它的支持充其量也不温不火：我可以使用sklearn2pmml保存模型（尽管不容易），并使用augustus/lightpmmlpredictor应用（尽管不加载）模型。但是，pip无法直接使用这些工具，这使得部署成为一场噩梦。还有，奥古斯都的

上述方法的一种变体：使用sklearn2pmml保存PMML，并使用openscoring进行评分。需要与外部过程接口。大笑。

建议？

Answer 1

通常情况下，不可能跨不同版本的Scikit学习实现模型持久性。原因很明显：您用一个定义来泡制Class1，并希望用另一个定义将其解泡制到Class2中。

你可以：

• 仍然尝试坚持使用sklearn的一个版本
• 忽略这些警告，并希望对Class1有效的方法也适用于Class2
• 编写您自己的类，该类可以序列化您的GradientBoostingClassifier，并从该序列化表单还原它，希望它比pickle工作得更好

我举了一个例子，说明了如何将单个DecisionTreeRegressor转换为完全兼容JSON的纯列表和dict格式，并将其还原回来。

import numpy as np
from sklearn.tree import DecisionTreeRegressor
from sklearn.datasets import make_classification

### Code to serialize and deserialize trees

LEAF_ATTRIBUTES = ['children_left', 'children_right', 'threshold', 'value', 'feature', 'impurity', 'weighted_n_node_samples']
TREE_ATTRIBUTES = ['n_classes_', 'n_features_', 'n_outputs_']

def serialize_tree(tree):
    """ Convert a sklearn.tree.DecisionTreeRegressor into a json-compatible format """
    encoded = {
        'nodes': {},
        'tree': {},
        'n_leaves': len(tree.tree_.threshold),
        'params': tree.get_params()
    }
    for attr in LEAF_ATTRIBUTES:
        encoded['nodes'][attr] = getattr(tree.tree_, attr).tolist()
    for attr in TREE_ATTRIBUTES:
        encoded['tree'][attr] = getattr(tree, attr)
    return encoded

def deserialize_tree(encoded):
    """ Restore a sklearn.tree.DecisionTreeRegressor from a json-compatible format """
    x = np.arange(encoded['n_leaves'])
    tree = DecisionTreeRegressor().fit(x.reshape((-1,1)), x)
    tree.set_params(**encoded['params'])
    for attr in LEAF_ATTRIBUTES:
        for i in range(encoded['n_leaves']):
            getattr(tree.tree_, attr)[i] = encoded['nodes'][attr][i]
    for attr in TREE_ATTRIBUTES:
        setattr(tree, attr, encoded['tree'][attr])
    return tree

## test the code

X, y = make_classification(n_classes=3, n_informative=10)
tree = DecisionTreeRegressor().fit(X, y)
encoded = serialize_tree(tree)
decoded = deserialize_tree(encoded)
assert (decoded.predict(X)==tree.predict(X)).all()

这样，您就可以继续序列化和反序列化整个GradientBoostingClassifier：

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble.gradient_boosting import PriorProbabilityEstimator

def serialize_gbc(clf):
    encoded = {
        'classes_': clf.classes_.tolist(),
        'max_features_': clf.max_features_, 
        'n_classes_': clf.n_classes_,
        'n_features_': clf.n_features_,
        'train_score_': clf.train_score_.tolist(),
        'params': clf.get_params(),
        'estimators_shape': list(clf.estimators_.shape),
        'estimators': [],
        'priors':clf.init_.priors.tolist()
    }
    for tree in clf.estimators_.reshape((-1,)):
        encoded['estimators'].append(serialize_tree(tree))
    return encoded

def deserialize_gbc(encoded):
    x = np.array(encoded['classes_'])
    clf = GradientBoostingClassifier(**encoded['params']).fit(x.reshape(-1, 1), x)
    trees = [deserialize_tree(tree) for tree in encoded['estimators']]
    clf.estimators_ = np.array(trees).reshape(encoded['estimators_shape'])
    clf.init_ = PriorProbabilityEstimator()
    clf.init_.priors = np.array(encoded['priors'])
    clf.classes_ = np.array(encoded['classes_'])
    clf.train_score_ = np.array(encoded['train_score_'])
    clf.max_features_ = encoded['max_features_']
    clf.n_classes_ = encoded['n_classes_']
    clf.n_features_ = encoded['n_features_']
    return clf

# test on the same problem
clf = GradientBoostingClassifier()
clf.fit(X, y);
encoded = serialize_gbc(clf)
decoded = deserialize_gbc(encoded)
assert (decoded.predict(X) == clf.predict(X)).all()

这适用于scikit学习v0。19，但不要问我在下一个版本中会出现什么来破坏这个代码。我既不是先知，也不是sklearn的开发者。

如果希望完全独立于新版本的sklearn，最安全的方法是编写一个函数，遍历序列化树并进行预测，而不是重新创建sklearn树。