0

我使用 sklearn 模块在 Python 中运行了 RandomForestClassifier 模型。我将模型保存在一个泡菜文件中。然后我从 Oracle 中提取数据，将其保存为 .csv 文件，将此 .csv 文件发送到可以在 Python 中打开模型的 pickle 文件的机器，并对数据进行评分。对数据进行评分后，我会将结果发送回 Oracle。

是否可以从 RandomForestClassifier(.predict_proba) 函数中提取评分系数，以便我可以将该数据加载到 Oracle 并仅在 Oracle 内部对数据进行评分？

阅读文档后，评分算法似乎过于复杂，无法执行上述建议，因为它必须将每个新记录推入每棵树，然后才能得出最终评分概率。这个对吗？

我提前感谢您的帮助。

马特

4

3 回答 3

1

AFAIK 没有现成的工具可以做到这一点，但您可以阅读基础决策树类的 Cython 源代码，特别是predict方法，以了解如何根据决策树模型的拟合参数进行预测。随机森林预测将单个树的预测视为二元概率（0 或 1），对它们进行平均并将它们归一化，如此处所述。

不过，将其转换为 PL/SQL 可能并非易事。显然，Oracle Data Mining在其他模型中对决策树模型的 PMML 导入/导出有一些支持。不幸的是，我也不知道任何用于 scikit-learn 决策树的PMML导出器的实现（尽管以graphviz 树导出器的源代码为例，它可能更容易编写）。

另请注意，另一方面，在 PostgreSQL 下，您可以在使用PL/Python编写的 DB 函数中直接使用 scikit-learn 。

于 2013-08-29T08:30:55.927 回答
1

我处于必须在 Oracle 数据库上运行随机森林模型的情况。可以生成执行与 Python Sk-learn RF 模型相同功能的 PL/SQL 包。

一旦你从这个 SO中得到了 Daniele 的回答，这很简单

首先你有这个文件：rforest_to_plsql.py

def t(n):
    return " " * 4 * n

def get_est_code(tree, feature_names):
    left      = tree.tree_.children_left
    right     = tree.tree_.children_right
    threshold = tree.tree_.threshold
    features  = [feature_names[i] for i in tree.tree_.feature]
    value = tree.tree_.value
    def recurse(left, right, threshold, features, node, depth, code):
        if (threshold[node] != -2):
            code += t(depth) + "if ( " + features[node] + " <= " + str(threshold[node]) + " ) then\n"
            depth += 1
            if left[node] != -1:
                code = recurse (left, right, threshold, features,left[node], depth, code)                 
            code += t(depth - 1) + "else\n"
            if right[node] != -1:
                code = recurse (left, right, threshold, features,right[node], depth, code)
            code += t(depth - 1) + "end if;\n"
            depth -= 1
        else:
            code +=  t(depth) + "return two_values(" + str(value[node][0][0]) + ", " + str(value[node][0][1]) + ");\n"
        return code
    return recurse(left, right, threshold, features, 0, 2, "")


def get_pkg_header_code(clf, feature_names):
    pkg_h_code = """create or replace package pkg_rforest_model as
    function predict_proba (\n"""
    for feat in feature_names:
        pkg_h_code += t(2) + feat + "   number,\n"
    pkg_h_code = pkg_h_code[:-2] + ")  return number;\n"
    pkg_h_code += "end pkg_rforest_model;"
    return pkg_h_code

def get_pkg_body_code(clf, feature_names):
    pkg_b_code = "create or replace package body pkg_rforest_model as\n"        
    #code for each estimator
    for index, estimator in enumerate(clf.estimators_):
        func_name = "f_est_" + str(index).zfill(3)
        pkg_b_code += t(1) + "function " + func_name + " (\n"
        for feat in feature_names:
            pkg_b_code += t(2) + feat + "   number,\n"
        pkg_b_code = pkg_b_code[:-2] + ") return two_values as\n    begin\n"
        pkg_b_code += get_est_code(clf.estimators_[index], ["f" + str(i) for i in range(7)])
        pkg_b_code += "    end " + func_name + ";\n"
    #this function calls all each estimator function and returns a weighted probability
    pkg_b_code += "    function predict_proba (\n"
    for feat in feature_names:
        pkg_b_code += t(2) + feat + "   number,\n"
    pkg_b_code = pkg_b_code[:-2] + ")  return number as\n    v_prob    number;\n"    
    for index, estimator in enumerate(clf.estimators_):
        func_name = "f_est_" + str(index).zfill(3)
        pkg_b_code += t(2) + "v_" + func_name + "_a number;\n"
        pkg_b_code += t(2) + "v_" + func_name + "_b number;\n"
        pkg_b_code += t(2) + "pr_est_" + str(index).zfill(3) + " number;\n"

    pkg_b_code += t(1) + "begin\n"    
    for index, estimator in enumerate(clf.estimators_):
        func_name = "f_est_" + str(index).zfill(3)
        pkg_b_code += t(2) + "v_" + func_name + "_a := " + func_name+ "(" + ", ".join(feature_names) + ").a;\n"
        pkg_b_code += t(2) + "v_" + func_name + "_b := " + func_name+ "(" + ", ".join(feature_names) + ").b;\n"
        pkg_b_code += t(2) + "pr_est_" + str(index).zfill(3) + " := v_" + func_name + "_a / ( v_" + \
                      func_name + "_a + v_" + func_name + "_b);\n"
    pkg_b_code += t(2) + "return  ("
    for index, estimator in enumerate(clf.estimators_):
        pkg_b_code += "pr_est_" + str(index).zfill(3) + " + "
    pkg_b_code = pkg_b_code[:-2] + ") / " + str(len(clf.estimators_)) + ";\n"
    pkg_b_code += t(1) + "end predict_proba;\n"   
    pkg_b_code += "end pkg_rforest_model;"
    return pkg_b_code

然后你训练你的模型，并让 PL/SQL 代码返回文件的函数：

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
import rforest_to_plsql
n_features = 4
X, y = make_classification(n_samples=1000, n_features=n_features,
                            n_informative=2, n_redundant=0,
                            random_state=0, shuffle=False)
clf = RandomForestClassifier(max_depth=2, random_state=0)
clf.fit(X, y)
features = ["f" + str(i) for i in range(n_features)]
pkg_h_code = rforest_to_plsql.get_pkg_header_code(clf, features)
pkg_b_code = rforest_to_plsql.get_pkg_body_code(clf, features)
print pkg_h_code
print pkg_b_code

在数据库上创建该包后，您可以执行以下操作：

select pkg_rforest_model.predict_proba(0.513889 , 0.511111 , 0.491667 ,  0)
from   dual;

这是纯 PL/SQL 并且应该运行得非常快。如果你有一个非常大的 RF，那么你可以在本地编译包以获得更高的性能。请注意 - 包裹可能是 1000 个 LOC 中的 10 个。

于 2018-06-27T00:15:20.577 回答
0

以下是使用SKompiler库的方法：

from skompiler import skompile
expr = skompile(gbr.predict)

skompile(rf.predict_proba).to('sqlalchemy/oracle')

当然，这可能不是评估 RF 分类器的最有效方法 - 对于大型森林，生成的查询可能很容易达到兆字节的大小。

注意：如果您的森林有超过一百个估算器，您可能还需要增加系统递归限制来编译它：

import sys
sys.setrecursionlimit(10000)
于 2018-12-12T13:07:37.847 回答