[PMML] LightGBM模型保存为PMML文件，通过Java或者Python调用

最新推荐文章于 2025-02-14 17:11:28 发布
最新推荐文章于 2025-02-14 17:11:28 发布
阅读量4.5k 收藏 16
点赞数 3
分类专栏： PMML 文章标签： pmml java调用 python调用 lightgbm
原创文章，未经授权请勿转载。
本文链接：https://blog.csdn.net/guolindonggld/article/details/117450761
版权

1、LightGBM

多分类

import os
import lightgbm as lgb
from sklearn import datasets
from sklearn.model_selection import train_test_split

iris = datasets.load_iris()

X = iris.data
y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=56)

# create dataset for lightgbm
lgb_train = lgb.Dataset(X_train, y_train)
lgb_test = lgb.Dataset(X_test, y_test, reference=lgb_train)

# specify your configurations as a dict
params = {
    'objective': 'multiclass',
    'num_class': 3,
    'num_leaves': 5,
    'metric': {'multi_logloss', 'multi_error'},
    'verbose': 0
}

evals_result = {}  # to record eval results for plotting

print('Starting training...')
# train
gbm = lgb.train(params,
                lgb_train,
                num_boost_round=5,
                valid_sets=[lgb_train, lgb_test],
                feature_name=list(iris.feature_names),
                evals_result=evals_result,
                verbose_eval=1)

gbm.save_model('lgb_model.txt')

2、转为PMML文件

GitHub：JPMML-LightGBM

或CSDN直接下载jpmml-lightgbm-executable-1.3.7.jar

java -jar "path\to\jpmml-lightgbm-executable-1.3.7.jar" --lgbm-input lgb_model.txt --pmml-output lgb_model.pmml

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<PMML xmlns="http://www.dmg.org/PMML-4_4" xmlns:data="http://jpmml.org/jpmml-model/InlineTable" version="4.4">
    <Header>
        <Application name="JPMML-LightGBM" version="1.3.7" />
        <Timestamp>2021-06-01T11:54:38Z</Timestamp>
    </Header>
    <DataDictionary>
        <DataField name="_target" optype="categorical" dataType="integer">
            <Value value="0" />
            <Value value="1" />
            <Value value="2" />
        </DataField>
        <DataField name="sepal_length_(cm)" optype="continuous" dataType="double">
            <Interval closure="closedClosed" leftMargin="4.3" rightMargin="7.9" />
            <Value value="NaN" property="missing" />
        </DataField>
        <DataField name="sepal_width_(cm)" optype="continuous" dataType="double">
            <Interval closure="closedClosed" leftMargin="2.0" rightMargin="4.4" />
            <Value value="NaN" property="missing" />
        </DataField>
        <DataField name="petal_length_(cm)" optype="continuous" dataType="double">
            <Interval closure="closedClosed" leftMargin="1.0" rightMargin="6.9" />
            <Value value="NaN" property="missing" />
        </DataField>
        <DataField name="petal_width_(cm)" optype="continuous" dataType="double">
            <Interval closure="closedClosed" leftMargin="0.1" rightMargin="2.5" />
            <Value value="NaN" property="missing" />
        </DataField>
    </DataDictionary>
    <MiningModel functionName="classification" algorithmName="LightGBM">
        <MiningSchema>
            <MiningField name="_target" usageType="target" />
            <MiningField name="sepal_length_(cm)" importance="11.0" invalidValueTreatment="asIs" />
            <MiningField name="sepal_width_(cm)" importance="2.0" invalidValueTreatment="asIs" />
            <MiningField name="petal_length_(cm)" importance="24.0" invalidValueTreatment="asIs" />
            <MiningField name="petal_width_(cm)" importance="13.0" invalidValueTreatment="asIs" />
        </MiningSchema>
        <Segmentation multipleModelMethod="modelChain" missingPredictionTreatment="returnMissing">
            <Segment id="1">
                <True />
                <MiningModel functionName="regression">
                    <MiningSchema>
                        <MiningField name="sepal_length_(cm)" />
                        <MiningField name="petal_length_(cm)" />
                    </MiningSchema>
                    <Output>
                        <OutputField name="lgbmValue(0)" optype="continuous" dataType="double" isFinalResult="false" />
                    </Output>
                    <Segmentation multipleModelMethod="sum">
                        <Segment id="1">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="sepal_length_(cm)" />
                                    <MiningField name="petal_length_(cm)" />
                                </MiningSchema>
                                <Node score="-0.9593265712691172">
                                    <True />
                                    <Node score="-1.1736122903444903">
                                        <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="3.4000000000000004" />
                                    </Node>
                                    <Node score="-0.9486122853153485">
                                        <SimplePredicate field="sepal_length_(cm)" operator="greaterThan" value="5.050000000000001" />
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                        <Segment id="2">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="sepal_length_(cm)" />
                                    <MiningField name="petal_length_(cm)" />
                                </MiningSchema>
                                <Node score="0.12185392449415344">
                                    <True />
                                    <Node score="-0.07257055906750128">
                                        <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="3.4000000000000004" />
                                        <Node score="-0.07207145404943262">
                                            <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="4.750000000000001" />
                                            <Node score="-0.07219570607417626">
                                                <SimplePredicate field="sepal_length_(cm)" operator="greaterThan" value="6.450000000000001" />
                                            </Node>
                                        </Node>
                                    </Node>
                                    <Node score="0.1303003664697049">
                                        <SimplePredicate field="sepal_length_(cm)" operator="greaterThan" value="5.050000000000001" />
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                        <Segment id="3">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="sepal_length_(cm)" />
                                    <MiningField name="petal_length_(cm)" />
                                </MiningSchema>
                                <Node score="0.10845272227015224">
                                    <True />
                                    <Node score="-0.07021340444377018">
                                        <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="3.4000000000000004" />
                                        <Node score="-0.06973716059085941">
                                            <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="4.750000000000001" />
                                            <Node score="-0.0697703896715927">
                                                <SimplePredicate field="sepal_length_(cm)" operator="greaterThan" value="6.450000000000001" />
                                            </Node>
                                        </Node>
                                    </Node>
                                    <Node score="0.11590997871777123">
                                        <SimplePredicate field="sepal_length_(cm)" operator="greaterThan" value="5.050000000000001" />
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                        <Segment id="4">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="sepal_length_(cm)" />
                                    <MiningField name="petal_length_(cm)" />
                                </MiningSchema>
                                <Node score="0.09842698080005607">
                                    <True />
                                    <Node score="-0.06827343512337868">
                                        <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="3.4000000000000004" />
                                        <Node score="-0.06761783054533778">
                                            <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="4.750000000000001" />
                                            <Node score="-0.06764010026474891">
                                                <SimplePredicate field="sepal_length_(cm)" operator="greaterThan" value="6.450000000000001" />
                                            </Node>
                                        </Node>
                                    </Node>
                                    <Node score="0.10504313154015506">
                                        <SimplePredicate field="sepal_length_(cm)" operator="greaterThan" value="5.050000000000001" />
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                        <Segment id="5">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="sepal_length_(cm)" />
                                    <MiningField name="petal_length_(cm)" />
                                </MiningSchema>
                                <Node score="0.0904309166215982">
                                    <True />
                                    <Node score="-0.06652987665633432">
                                        <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="3.4000000000000004" />
                                        <Node score="-0.0658371655887295">
                                            <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="4.750000000000001" />
                                            <Node score="-0.06572093661554763">
                                                <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="5.550000000000001" />
                                            </Node>
                                        </Node>
                                    </Node>
                                    <Node score="0.09656194725537585">
                                        <SimplePredicate field="sepal_length_(cm)" operator="greaterThan" value="5.050000000000001" />
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                    </Segmentation>
                </MiningModel>
            </Segment>
            <Segment id="2">
                <True />
                <MiningModel functionName="regression">
                    <MiningSchema>
                        <MiningField name="petal_length_(cm)" />
                        <MiningField name="petal_width_(cm)" />
                    </MiningSchema>
                    <Output>
                        <OutputField name="lgbmValue(1)" optype="continuous" dataType="double" isFinalResult="false" />
                    </Output>
                    <Segmentation multipleModelMethod="sum">
                        <Segment id="1">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="petal_length_(cm)" />
                                </MiningSchema>
                                <Node score="-1.1736122903444903">
                                    <True />
                                    <Node score="-0.9659199780098979">
                                        <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="1.8" />
                                        <Node score="-1.1736122903444903">
                                            <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="4.950000000000001" />
                                        </Node>
                                        <Node score="-1.002183715084192">
                                            <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="4.450000000000001" />
                                        </Node>
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                        <Segment id="2">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="petal_width_(cm)" />
                                </MiningSchema>
                                <Node score="-0.07250517806119815">
                                    <True />
                                    <Node score="0.11645485855092522">
                                        <SimplePredicate field="petal_width_(cm)" operator="greaterThan" value="0.45000000000000007" />
                                        <Node score="-0.06700056833064691">
                                            <SimplePredicate field="petal_width_(cm)" operator="greaterThan" value="1.6500000000000001" />
                                        </Node>
                                        <Node score="0.0981912222296533">
                                            <SimplePredicate field="petal_width_(cm)" operator="greaterThan" value="1.3500000000000003" />
                                        </Node>
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                        <Segment id="3">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="petal_length_(cm)" />
                                    <MiningField name="petal_width_(cm)" />
                                </MiningSchema>
                                <Node score="-0.07006593404406375">
                                    <True />
                                    <Node score="0.1050172735135845">
                                        <SimplePredicate field="petal_width_(cm)" operator="greaterThan" value="0.45000000000000007" />
                                        <Node score="-0.07081316273464346">
                                            <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="4.950000000000001" />
                                        </Node>
                                        <Node score="0.08054282244171226">
                                            <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="4.450000000000001" />
                                        </Node>
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                        <Segment id="4">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="petal_length_(cm)" />
                                </MiningSchema>
                                <Node score="-0.06811367792034477">
                                    <True />
                                    <Node score="0.09588720003106202">
                                        <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="1.8" />
                                        <Node score="-0.06868727088904823">
                                            <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="4.950000000000001" />
                                        </Node>
                                        <Node score="0.07317294292378695">
                                            <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="4.450000000000001" />
                                        </Node>
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                        <Segment id="5">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="petal_width_(cm)" />
                                </MiningSchema>
                                <Node score="-0.06617439842593348">
                                    <True />
                                    <Node score="0.08703239160896648">
                                        <SimplePredicate field="petal_width_(cm)" operator="greaterThan" value="0.45000000000000007" />
                                        <Node score="-0.06143345433867317">
                                            <SimplePredicate field="petal_width_(cm)" operator="greaterThan" value="1.6500000000000001" />
                                        </Node>
                                        <Node score="0.07675765159801226">
                                            <SimplePredicate field="petal_width_(cm)" operator="greaterThan" value="1.3500000000000003" />
                                        </Node>
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                    </Segmentation>
                </MiningModel>
            </Segment>
            <Segment id="3">
                <True />
                <MiningModel functionName="regression">
                    <MiningSchema>
                        <MiningField name="sepal_length_(cm)" />
                        <MiningField name="sepal_width_(cm)" />
                        <MiningField name="petal_length_(cm)" />
                        <MiningField name="petal_width_(cm)" />
                    </MiningSchema>
                    <Output>
                        <OutputField name="lgbmValue(2)" optype="continuous" dataType="double" isFinalResult="false" />
                    </Output>
                    <Segmentation multipleModelMethod="sum">
                        <Segment id="1">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="sepal_length_(cm)" />
                                    <MiningField name="petal_length_(cm)" />
                                </MiningSchema>
                                <Node score="-1.1638296814301798">
                                    <True />
                                    <Node score="-0.9877427209725906">
                                        <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="4.750000000000001" />
                                        <Node score="-0.9486122853153485">
                                            <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="5.550000000000001" />
                                        </Node>
                                    </Node>
                                    <Node score="-1.1736122903444903">
                                        <SimplePredicate field="sepal_length_(cm)" operator="greaterThan" value="5.050000000000001" />
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                        <Segment id="2">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="sepal_width_(cm)" />
                                    <MiningField name="petal_width_(cm)" />
                                </MiningSchema>
                                <Node score="-0.0724357261619468">
                                    <True />
                                    <Node score="0.12736121841495812">
                                        <SimplePredicate field="petal_width_(cm)" operator="greaterThan" value="1.6500000000000001" />
                                    </Node>
                                    <Node score="-0.0319429343565856">
                                        <SimplePredicate field="petal_width_(cm)" operator="greaterThan" value="1.3500000000000003" />
                                    </Node>
                                    <Node score="-0.07213929036587866">
                                        <SimplePredicate field="sepal_width_(cm)" operator="greaterThan" value="3.35" />
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                        <Segment id="3">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="sepal_length_(cm)" />
                                    <MiningField name="petal_length_(cm)" />
                                    <MiningField name="petal_width_(cm)" />
                                </MiningSchema>
                                <Node score="-0.059662719835815003">
                                    <True />
                                    <Node score="0.08831532996239182">
                                        <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="4.750000000000001" />
                                        <Node score="0.11732538921269522">
                                            <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="5.550000000000001" />
                                        </Node>
                                    </Node>
                                    <Node score="-0.06975022798344958">
                                        <SimplePredicate field="sepal_length_(cm)" operator="greaterThan" value="5.050000000000001" />
                                        <Node score="-0.07092820238292231">
                                            <SimplePredicate field="petal_width_(cm)" operator="greaterThan" value="1.2500000000000002" />
                                        </Node>
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                        <Segment id="4">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="sepal_length_(cm)" />
                                    <MiningField name="petal_length_(cm)" />
                                    <MiningField name="petal_width_(cm)" />
                                </MiningSchema>
                                <Node score="-0.05718847818792119">
                                    <True />
                                    <Node score="0.08026262561477648">
                                        <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="4.750000000000001" />
                                        <Node score="0.10583777787647669">
                                            <SimplePredicate field="petal_length_(cm)" operator="greaterThan" value="5.550000000000001" />
                                        </Node>
                                    </Node>
                                    <Node score="-0.0676030312212233">
                                        <SimplePredicate field="sepal_length_(cm)" operator="greaterThan" value="5.050000000000001" />
                                        <Node score="-0.06893421344995508">
                                            <SimplePredicate field="petal_width_(cm)" operator="greaterThan" value="1.2500000000000002" />
                                        </Node>
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                        <Segment id="5">
                            <True />
                            <TreeModel functionName="regression" noTrueChildStrategy="returnLastPrediction">
                                <MiningSchema>
                                    <MiningField name="sepal_width_(cm)" />
                                    <MiningField name="petal_width_(cm)" />
                                </MiningSchema>
                                <Node score="-0.0662759744408909">
                                    <True />
                                    <Node score="0.09578590305317655">
                                        <SimplePredicate field="petal_width_(cm)" operator="greaterThan" value="1.6500000000000001" />
                                    </Node>
                                    <Node score="-0.029336428814000854">
                                        <SimplePredicate field="petal_width_(cm)" operator="greaterThan" value="1.3500000000000003" />
                                    </Node>
                                    <Node score="-0.06563769706964893">
                                        <SimplePredicate field="sepal_width_(cm)" operator="greaterThan" value="3.2500000000000004" />
                                    </Node>
                                </Node>
                            </TreeModel>
                        </Segment>
                    </Segmentation>
                </MiningModel>
            </Segment>
            <Segment id="4">
                <True />
                <RegressionModel functionName="classification" normalizationMethod="softmax">
                    <MiningSchema>
                        <MiningField name="_target" usageType="target" />
                        <MiningField name="lgbmValue(0)" />
                        <MiningField name="lgbmValue(1)" />
                        <MiningField name="lgbmValue(2)" />
                    </MiningSchema>
                    <Output>
                        <OutputField name="probability(0)" optype="continuous" dataType="double" feature="probability" value="0" />
                        <OutputField name="probability(1)" optype="continuous" dataType="double" feature="probability" value="1" />
                        <OutputField name="probability(2)" optype="continuous" dataType="double" feature="probability" value="2" />
                    </Output>
                    <RegressionTable intercept="0.0" targetCategory="0">
                        <NumericPredictor name="lgbmValue(0)" coefficient="1.0" />
                    </RegressionTable>
                    <RegressionTable intercept="0.0" targetCategory="1">
                        <NumericPredictor name="lgbmValue(1)" coefficient="1.0" />
                    </RegressionTable>
                    <RegressionTable intercept="0.0" targetCategory="2">
                        <NumericPredictor name="lgbmValue(2)" coefficient="1.0" />
                    </RegressionTable>
                </RegressionModel>
            </Segment>
        </Segmentation>
    </MiningModel>
</PMML>

3、Java调用解析PMML文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.gld</groupId>
    <artifactId>apple</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.jpmml</groupId>
            <artifactId>pmml-evaluator</artifactId>
            <version>1.5.15</version>
        </dependency>
    </dependencies>

</project>

import org.dmg.pmml.FieldName;
import org.jpmml.evaluator.*;
import org.xml.sax.SAXException;

import javax.xml.bind.JAXBException;
import java.io.File;
import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class Server {

    public static void main(String[] args) throws JAXBException, SAXException, IOException {
        // Building a model evaluator from a PMML file
        String modelPath = "model.pmml";
        System.out.println(modelPath);
        Evaluator evaluator = new LoadingModelEvaluatorBuilder().load(new File(modelPath)).build();

        // Performing the self-check
        evaluator.verify();

        // Printing input (x1, x2, .., xn) fields
        List<? extends InputField> inputFields = evaluator.getInputFields();
        System.out.println("Input fields: ");
        for (InputField inputField : inputFields) {
            System.out.println(inputField);
        }

        // Printing primary result (y) field(s)
        List<? extends TargetField> targetFields = evaluator.getTargetFields();
        System.out.println("Target field(s): " + targetFields);

        // Printing secondary result (eg. probability(y), decision(y)) fields
        List<? extends OutputField> outputFields = evaluator.getOutputFields();
        System.out.println("Output fields: ");
        for (OutputField outputField : outputFields) {
            System.out.println(outputField);
        }

        // Predicting
        Map<String, Double> inputRecord = new LinkedHashMap<String, Double>();
        // 5.1, 3.5, 1.4, 0.2 -> 0
        // 6.4, 3.2, 4.5, 1.5 -> 1
        // 5.9, 3. , 5.1, 1.8 -> 2
        inputRecord.put("sepal_length_(cm)", 5.1);
        inputRecord.put("sepal_width_(cm)", 3.5);
        inputRecord.put("petal_length_(cm)", 1.4);
        inputRecord.put("petal_width_(cm)", 0.2);

        Map<FieldName, FieldValue> arguments = new LinkedHashMap<FieldName, FieldValue>();

        // Mapping the record field-by-field from data source schema to PMML schema
        for (InputField inputField : inputFields) {
            FieldName inputName = inputField.getName();

            Object rawValue = inputRecord.get(inputName.getValue());

            // Transforming an arbitrary user-supplied value to a known-good PMML value
            FieldValue inputValue = inputField.prepare(rawValue);

            arguments.put(inputName, inputValue);
        }

        // Evaluating the model with known-good arguments
        Map<FieldName, ?> results = evaluator.evaluate(arguments);
        System.out.println(results);

        // Decoupling results from the JPMML-Evaluator runtime environment
        Map<String, ?> resultRecord = EvaluatorUtil.decodeAll(results);
        System.out.println(resultRecord);

    }
}

Output:

Input fields: 
InputField{name=sepal_length_(cm), fieldName=sepal_length_(cm), displayName=null, dataType=double, opType=continuous}
InputField{name=sepal_width_(cm), fieldName=sepal_width_(cm), displayName=null, dataType=double, opType=continuous}
InputField{name=petal_length_(cm), fieldName=petal_length_(cm), displayName=null, dataType=double, opType=continuous}
InputField{name=petal_width_(cm), fieldName=petal_width_(cm), displayName=null, dataType=double, opType=continuous}

Target field(s): [TargetField{name=_target, fieldName=_target, displayName=null, dataType=integer, opType=categorical}]

Output fields: 
OutputField{name=probability(0), fieldName=probability(0), displayName=null, dataType=double, opType=continuous, finalResult=true, depth=1}
OutputField{name=probability(1), fieldName=probability(1), displayName=null, dataType=double, opType=continuous, finalResult=true, depth=1}
OutputField{name=probability(2), fieldName=probability(2), displayName=null, dataType=double, opType=continuous, finalResult=true, depth=1}

{_target=ProbabilityDistribution{result=0, probability_entries=[0=0.5635697635950065, 1=0.2180264776286243, 2=0.21840375877636908]}, probability(0)=0.5635697635950065, probability(1)=0.2180264776286243, probability(2)=0.21840375877636908}

{_target=0, probability(0)=0.5635697635950065, probability(1)=0.2180264776286243, probability(2)=0.21840375877636908}

4、Python调用解析PMML文件

GitHub：JPMML-Evaluator-Python

首先安装：pip install jpmml_evaluator

from jpmml_evaluator.pyjnius import jnius_configure_classpath, PyJNIusBackend

# Configure JVM
jnius_configure_classpath()

# Construct a PyJNIus backend
backend = PyJNIusBackend()


from jpmml_evaluator import make_evaluator

evaluator = make_evaluator(backend, "lgb_model.pmml") .verify()

input_fields = evaluator.getInputFields()
print("\r\nInput fields: " + str([input_field.getName() for input_field in input_fields]))

target_fields = evaluator.getTargetFields()
print("\r\nTarget field(s): " + str([target_field.getName() for target_field in target_fields]))

output_fields = evaluator.getOutputFields()
print("\r\nOutput fields: " + str([output_field.getName() for output_field in output_fields]))

args = {
	"sepal_length_(cm)": 5.1,
	"sepal_width_(cm)": 3.5,
	"petal_length_(cm)": 1.4,
	"petal_width_(cm)": 0.2
}

result = evaluator.evaluate(args)

print('\r\n',result) # {'_target': 0, 'probability(0)': 0.5635697635950065, 'probability(1)': 0.2180264776286243, 'probability(2)': 0.21840375877636908}
LightGBM模型文件保存pmml形式
Arvin2015的博客
11-04 2448
LightGBM保存pmml形式 1.先保存成txt文件 from sklearn2pmml import PMMLPipeline gbm.save_model("c:\\data_set\\lightgbm.txt") 2.再用 jpmml-lightgbm-executable-1.3-SNAPSHOT.jar 文件编译成pmml文件。进入到jar文件所在目录后执行以下命令： cd target java -jar jpmml-lightgbm-executable-1.3-SNAPSH..
lightgbm模型保存为pmml文件 机器学习lgbm模型存为pmml文件 通过java调用jar
01-23
lightgbm模型保存为pmml文件 机器学习lgbm模型存为pmml文件， 使用方法查阅附件内容txt文件
模型文件及部署工具包org.dmg.pmml
最新发布
zhglhy的专栏
02-14 982
PMML 是一种基于 XML 的标准格式，用于表示数据挖掘和机器学习模型。通过 PMML，可以在不同的平台和工具之间共享和部署模型。
lightgbm模型保存为pmml文件，并加载
m0_63841024的博客
08-07 1593
5.在pmml-lightgbm-example目录下会生成target文件，target目录下会生成.jar文件7.在此目录下可生成.pmml文件。
如何将lightgbm模型存为pmml文件
小颜颜6035的博客
10-11 1721
1.下载jpmml-lightgbm文件 https://github.com/jpmml/jpmml-lightgbm 上传到linux上 解压:tar -zxvf 文件名 切换到解压文件夹所在目录下： mvn clean install 若显示没有mvn命令，请点击此处： https://blog.csdn.net/yinjun3215/article/details/120702748?spm=1001.2014.3001.5501 成功，会在当前目录下生成target文件 cd target
lgbm模型转为pmml格式的jar包
10-15
lgbm模型转为pmml格式的jar包，jpmml-lightgbm-executable-1.3-SNAPSHOT.jar
lightgbm模型通过pmml存储，在java中调用
热门推荐
luoyexuge的专栏
04-26 1万+
lightgbm模型是微软开源的一个模型，比xgboost快个10倍左右，原始训练使用的是c++，也提供了python接口，晚上摸索了下lightgbm在python中训练，转化为pmml语言，在java中调用，过程碰到不少坑，记录下，首先是  git clone  https://github.com/jpmml/jpmml-lightgbm/tree/master/src/main/java/...
LightGBM模型保存为PMML文件，通过Java调用
nchkchy的博客
03-08 1317
LightGBM模型保存为PMML文件，通过Java调用 1、将模型保存为txt文件 import os import lightgbm as lgb from sklearn import datasets from sklearn.model_selection import train_test_split iris = datasets.load_iris() X = iris.data y = iris.target X_train, X_test, y_train, y_test =
机器学习-lightgbm转pmml
05-15
lightgbm模型转pmml文件，可用于java程序调用，实现在线打分功能。 看网站上有人定价为付费，于是开出积分版本，赚点积分，谢谢支持 使用方法: 1. 生产模型基础文件：python环境下模型训练完后, model.booser_.save...
python模型保存与恢复 pmml_将python训练好的模型保存为pmml文件供java调用
weixin_39696518的博客
12-11 1103
1、PMLL概述用python训练好的机器学习模型如果上线部署，被java调用，可以将模型保存为pmml文件，那么什么是pmml呢？PMML是数据挖掘的一种通用的规范，它用统一的XML格式来描述我们生成的机器学习模型。这样无论你的模型是sklearn,R还是Spark MLlib生成的，都可以将其转化为标准的XML格式来存储。当我们需要将这个PMML的模型用于部署的时候，可以使用目标环境的解析PM...
java使用python模型_PMML，JAVA调用Python算法模型
weixin_39583655的博客
12-17 1888
公司大部分应用的使用的是JAVA开发，要想使用Python模型非常困难，网上搜索了下，可以先将生成的模型转换为PMML文件后即可在JAVA中直接调用。PMML简介模型预测标记语言(Predictive Model Markup Language)是由Dr. Robert Lee Grossman 提出的一种基于XML的存储模型的格式标准。这里的模型是指那些由数据挖掘和机器学习算法生成的预测模型。P...
lightgbm_pmml_demo:从python导出的受过训练的lightgbm模型，以供Java调用
04-08
lightgbm_pmml_demo 从python导出的受过训练的lightgbm模型，以供Java调用
jpmml-lightgbm:Java库和命令行应用程序，用于将LightGBM模型转换为PMML
05-02
JPMML-LightGBM Java库和命令行应用程序，用于将模型转换为PMML。 先决条件 LightGBM 2.0.0或更高版本。 Java 1.8或更高版本。 安装 输入项目根目录并使用构建： mvn clean install 构建生成可执行的uber-JAR文件target/jpmml-lightgbm-executable-1.3-SNAPSHOT.jar 。 用法 典型的工作流程可以总结如下： 使用LightGBM训练模型。 将模型保存到本地文件系统中的文本文件中。 使用JPMML-LightGBM命令行转换器应用程序将此文本文件转换为PMML文件。 LightGBM操作方面 使用软件包为示例波士顿住房数据集训练回归模型： from sklearn . datasets import load_boston boston = load_boston () fr
pmml-lightgbm-example-executable-1.4-SNAPSHOT.jar
01-22
1、lgb模型转换pmml格式
定制版LightGBM
06-24
本文件主要基于微软开源的LightGBM项目，对其中的application.h,application.hpp,predictor.hpp文件进行修改，添加用于实时预测的C++ API ，方便用户部署预测速度飞快的C/C++线上预测模型。
MATLAB算法实战应用案例精讲-【回归算法】LightGBM算法（附Java、Python和R语言代码）
qq_36130719的博客
09-26 1969
LightGBM是微软旗下的Distributed Machine Learning Toolkit （DMKT）的一个项目，由2014年首届阿里巴巴大数据竞赛获胜者之一柯国霖主持开发。虽然其开源时间才仅仅2个月，但是其快速高效的特点已经在数据科学竞赛中崭露头角。Allstate Claims Severity竞赛中的冠军解决方案里就使用了LightGBM，并对其大嘉赞赏。xgboost虽然是一种优秀的boosting框架，但是在使用过程中，其训练耗时过长，内存占用比较大。微软在2016年推出了另外一种bo
MAC系统 LightGBM模型转为pmml格式
Matrix_cc的博客
01-28 1148
MAC系统 LightGBM模型转为pmml格式 相关流程
Nyoka库实现Python机器学习模型PMML导出
资源摘要信息:"Nyoka是一个开源的Python库，主要用于将机器学习和深度学习（MLDL）模型导出为PMML（Predictive Model Markup Language）格式，该格式遵循4.4.1版本的标准。PMML是一种广泛使用的工业标准语言，用于...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

手撕机

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值