用PMML实现机器学习模型的跨平台上线

最新推荐文章于 2023-11-28 18:58:53 发布
最新推荐文章于 2023-11-28 18:58:53 发布
阅读量470 收藏 1
点赞数
分类专栏： 大数据 文章标签： 决策树 spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/akenseren/article/details/105620417
版权

参考：用PMML实现机器学习模型的跨平台上线

  • 目标：在Spark环境下训练机器学习模型，并在Java环境下进行推测

  • 过程1：在Spark环境下训练机器学习模型，导出训练模型为PMML文件

Code：

import java.io.File

import javax.xml.transform.stream.StreamResult
import org.apache.log4j.{Level, Logger}
import org.apache.spark.ml.classification.DecisionTreeClassifier
import org.apache.spark.ml.feature.RFormula
import org.apache.spark.ml.{Pipeline, PipelineStage}
import org.apache.spark.sql.SparkSession
import org.jpmml.model.JAXBUtil
import org.jpmml.sparkml.PMMLBuilder


object DecisionTreeClassifierDemo {
  //屏蔽不必要的日志显示在终端上
  Logger.getLogger("org.apache.spark").setLevel(Level.ERROR) //warn类信息不会显示，只显示error级别的
  Logger.getLogger("org.apache.eclipse.jetty.server").setLevel(Level.OFF)
  def main(args: Array[String]): Unit = {
    //spark2-submit --class DecisionTreeClassifierDemo ./DecisionTreeClassifierDemo.jar &> ./log/DecisionTreeClassifierDemo.log

    //离线方式
    val spark = SparkSession
      .builder
      .appName("DecisionTreeClassifier")
      .master("local[4]")
      .getOrCreate()

    // 加载训练集
    val appData = spark.read
      .format("csv")
      .options(Map(
        "header" -> "true",
        "inferSchema" -> "true"))
      .load("appused2gender.csv")

    appData.show(5)
    appData.printSchema()
    /*    
        +------------------+----------+-------------------+------------------+------------------+------------------+------------------+------+
        |          duration|use_number|     duration_trend|  duration_workday|use_number_workday|  duration_weekend|use_number_weekend|gender|
        +------------------+----------+-------------------+------------------+------------------+------------------+------------------+------+
        |465.46666666666675| 156.65625|-0.9740957966764417| 443.9840277777778|145.04166666666666| 529.9145833333333|             191.5|     1|
          | 711.4791666666666| 727.96875| 21.685239491691103| 648.4458333333334|           792.125| 900.5791666666668|             535.5|     0|
          |148.50833333333333|     212.6| 17.145959595959596|122.58809523809524|             207.0| 208.9888888888889|225.66666666666666|     0|
          | 582.4250000000001|     227.5|  41.51378260869564|357.47631578947363|127.36842105263158|           1437.23|             608.0|     0|
          |383.83833333333337|     263.5| -4.783333333333332|294.41666666666663|             202.8|473.25999999999993|             324.2|     0|
          +------------------+----------+-------------------+------------------+------------------+------------------+------------------+------+
    */

    // 特征选择
    val formula = new RFormula().setFormula("gender ~ .")

    // 设置决策树分类器
    val classifier = new DecisionTreeClassifier()
      .setLabelCol(formula.getLabelCol)
      .setFeaturesCol(formula.getFeaturesCol)

    // 组合pipeline
    val pipeline = new Pipeline().setStages(Array[PipelineStage](formula, classifier))

    // 训练
    val pipelineModel = pipeline.fit(appData)

    val schema = appData.schema
      schema.printTreeString()
    println("schema: " + schema)

    // 将pmml以流的形式输出到控制台
    val pmml = new PMMLBuilder(schema, pipelineModel).build
    JAXBUtil.marshalPMML(pmml, new StreamResult(System.out))

    // 将pmml写到文件
    new PMMLBuilder(schema, pipelineModel).buildFile(new File("Appused2genderDecisionTreeClassifier.pmml"))
  }
}

IDEA配置xml文件如下：

<?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.xdb.spark2pmml</groupId>
    <artifactId>Spark2PmmlDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <spark.version>2.3.0</spark.version>
        <scala.version>2.11</scala.version>
    </properties>


    <dependencies>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_${scala.version}</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming_${scala.version}</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_${scala.version}</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-hive_${scala.version}</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-mllib_${scala.version}</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.jpmml/jpmml-sparkml -->
        <dependency>
            <groupId>org.jpmml</groupId>
            <artifactId>jpmml-sparkml</artifactId>
            <version>1.4.11</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>

            <plugin>
                <groupId>org.scala-tools</groupId>
                <artifactId>maven-scala-plugin</artifactId>
                <version>2.15.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.19</version>
                <configuration>
                    <skip>true</skip>
                </configuration>
            </plugin>

        </plugins>
    </build>
</project>

输出PMML文件格式如下：

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<PMML xmlns="http://www.dmg.org/PMML-4_3" xmlns:data="http://jpmml.org/jpmml-model/InlineTable" version="4.3">
	<Header>
		<Application name="JPMML-SparkML" version="1.4.11"/>
		<Timestamp>2020-04-19T11:25:07Z</Timestamp>
	</Header>
	<DataDictionary>
		<DataField name="gender" optype="categorical" dataType="integer">
			<Value value="0"/>
			<Value value="1"/>
		</DataField>
		<DataField name="duration" optype="continuous" dataType="double"/>
		<DataField name="use_number" optype="continuous" dataType="double"/>
		<DataField name="duration_trend" optype="continuous" dataType="double"/>
		<DataField name="duration_workday" optype="continuous" dataType="double"/>
		<DataField name="use_number_workday" optype="continuous" dataType="double"/>
		<DataField name="duration_weekend" optype="continuous" dataType="double"/>
		<DataField name="use_number_weekend" optype="continuous" dataType="double"/>
	</DataDictionary>
	<TreeModel functionName="classification" missingValueStrategy="nullPrediction">
		<MiningSchema>
			<MiningField name="gender" usageType="target"/>
			<MiningField name="duration"/>
			<MiningField name="use_number"/>
			<MiningField name="duration_trend"/>
			<MiningField name="duration_workday"/>
			<MiningField name="use_number_workday"/>
			<MiningField name="duration_weekend"/>
			<MiningField name="use_number_weekend"/>
		</MiningSchema>
		<Output>
			<OutputField name="pmml(prediction)" optype="categorical" dataType="integer" isFinalResult="false"/>
			<OutputField name="prediction" optype="continuous" dataType="double" feature="transformedValue">
				<MapValues outputColumn="data:output" dataType="double">
					<FieldColumnPair field="pmml(prediction)" column="data:input"/>
					<InlineTable>
						<row>
							<data:input>0</data:input>
							<data:output>0</data:output>
						</row>
						<row>
							<data:input>1</data:input>
							<data:output>1</data:output>
						</row>
					</InlineTable>
				</MapValues>
			</OutputField>
			<OutputField name="probability(0)" optype="continuous" dataType="double" feature="probability" value="0"/>
			<OutputField name="probability(1)" optype="continuous" dataType="double" feature="probability" value="1"/>
		</Output>
		<Node>
			<True/>
			<Node>
				<SimplePredicate field="duration" operator="lessOrEqual" value="770.2519269776877"/>
				<Node>
					<SimplePredicate field="duration_weekend" operator="lessOrEqual" value="133.434375"/>
					<Node>
						<SimplePredicate field="duration_workday" operator="lessOrEqual" value="571.2881944444446"/>
						<Node>
							<SimplePredicate field="use_number_weekend" operator="lessOrEqual" value="467.5"/>
							<Node score="0" recordCount="400">
								<SimplePredicate field="use_number_workday" operator="lessOrEqual" value="486.6594202898551"/>
								<ScoreDistribution value="0" recordCount="227.0"/>
								<ScoreDistribution value="1" recordCount="173.0"/>
							</Node>
							<Node score="1" recordCount="8">
								<True/>
								<ScoreDistribution value="0" recordCount="2.0"/>
								<ScoreDistribution value="1" recordCount="6.0"/>
							</Node>
						</Node>
						<Node score="1" recordCount="4">
							<True/>
							<ScoreDistribution value="0" recordCount="0.0"/>
							<ScoreDistribution value="1" recordCount="4.0"/>
						</Node>
					</Node>
					<Node>
						<SimplePredicate field="duration_trend" operator="lessOrEqual" value="-73.75824404761904"/>
						<Node score="1" recordCount="1">
							<SimplePredicate field="duration" operator="lessOrEqual" value="539.9891025641025"/>
							<ScoreDistribution value="0" recordCount="0.0"/>
							<ScoreDistribution value="1" recordCount="1.0"/>
						</Node>
						<Node score="0" recordCount="4">
							<True/>
							<ScoreDistribution value="0" recordCount="4.0"/>
							<ScoreDistribution value="1" recordCount="0.0"/>
						</Node>
					</Node>
					<Node score="0" recordCount="17">
						<True/>
						<ScoreDistribution value="0" recordCount="17.0"/>
						<ScoreDistribution value="1" recordCount="0.0"/>
					</Node>
				</Node>
				<Node>
					<SimplePredicate field="duration_trend" operator="lessOrEqual" value="20.406185850439883"/>
					<Node>
						<SimplePredicate field="duration_trend" operator="lessOrEqual" value="-16.603133718344537"/>
						<Node score="0" recordCount="162">
							<SimplePredicate field="use_number" operator="lessOrEqual" value="326.46770833333335"/>
							<ScoreDistribution value="0" recordCount="98.0"/>
							<ScoreDistribution value="1" recordCount="64.0"/>
						</Node>
						<Node score="1" recordCount="96">
							<True/>
							<ScoreDistribution value="0" recordCount="41.0"/>
							<ScoreDistribution value="1" recordCount="55.0"/>
						</Node>
					</Node>
					<Node score="0" recordCount="134">
						<SimplePredicate field="duration_workday" operator="lessOrEqual" value="149.45138888888889"/>
						<ScoreDistribution value="0" recordCount="73.0"/>
						<ScoreDistribution value="1" recordCount="61.0"/>
					</Node>
					<Node score="1" recordCount="2247">
						<True/>
						<ScoreDistribution value="0" recordCount="930.0"/>
						<ScoreDistribution value="1" recordCount="1317.0"/>
					</Node>
				</Node>
				<Node>
					<SimplePredicate field="duration_weekend" operator="lessOrEqual" value="925.04375"/>
					<Node score="0" recordCount="26">
						<SimplePredicate field="duration" operator="lessOrEqual" value="302.228125"/>
						<ScoreDistribution value="0" recordCount="19.0"/>
						<ScoreDistribution value="1" recordCount="7.0"/>
					</Node>
					<Node score="0" recordCount="155">
						<True/>
						<ScoreDistribution value="0" recordCount="82.0"/>
						<ScoreDistribution value="1" recordCount="73.0"/>
					</Node>
				</Node>
                   <node>此处省略一堆node</node>
				<True/>
				<ScoreDistribution value="0" recordCount="12.0"/>
				<ScoreDistribution value="1" recordCount="24.0"/>
			</Node>
		</Node>
	</TreeModel>
</PMML>

过程2：在Java环境下加载PMML文件模型并做推测

Code：

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

import javax.xml.bind.JAXBException;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;

public class PMML2EvaluatorDemo {
    private Evaluator loadPmml(String filePath){
        //加载pmml文件
        PMML pmml = new PMML();
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream(filePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
        if(inputStream == null){
            return null;
        }

        InputStream is = inputStream;
        try {
            pmml = org.jpmml.model.PMMLUtil.unmarshal(is);
        } catch (SAXException e1) {
            e1.printStackTrace();
        } catch (JAXBException e1) {
            e1.printStackTrace();
        }finally {
            //关闭输入流
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        ModelEvaluatorFactory modelEvaluatorFactory = ModelEvaluatorFactory.newInstance();
        Evaluator evaluator = modelEvaluatorFactory.newModelEvaluator(pmml);
        pmml = null;
        return evaluator;
    }

    private void showEvaluator(Evaluator evaluator) {
        //输出模型的输入输出节点
        List<InputField> inputFields = evaluator.getInputFields();
        for (InputField inputField : inputFields) {
            FieldName inputFieldName = inputField.getName();
            System.out.println("inputFieldName:" + inputFieldName);
        }
        List<TargetField> targetFields = evaluator.getTargetFields();
        for (TargetField targetField : targetFields) {
            FieldName targetFieldName = targetField.getName();
            System.out.println("targetFieldName:" + targetFieldName);
        }

    }

    private int predictAppused2gender(Evaluator evaluator,double a, double b, double c, double d, double e, double f, double g) {
        Map<String, Double> data = new HashMap<String, Double>();
        data.put("duration", a);
        data.put("use_number", b);
        data.put("duration_trend", c);
        data.put("duration_workday", d);
        data.put("use_number_workday", e);
        data.put("duration_weekend", f);
        data.put("use_number_weekend", g);
        List<InputField> inputFields = evaluator.getInputFields();

        //过模型的原始特征，从画像中获取数据，作为模型输入
        Map<FieldName, FieldValue> arguments = new LinkedHashMap<FieldName, FieldValue>();
        for (InputField inputField : inputFields) {
            FieldName inputFieldName = inputField.getName();
            Object rawValue = data.get(inputFieldName.getValue());
            FieldValue inputFieldValue = inputField.prepare(rawValue);
            arguments.put(inputFieldName, inputFieldValue);
        }

        Map<FieldName, ?> results = evaluator.evaluate(arguments);
        List<TargetField> targetFields = evaluator.getTargetFields();

        TargetField targetField = targetFields.get(0);
        FieldName targetFieldName = targetField.getName();

        Object targetFieldValue = results.get(targetFieldName);
        System.out.println("target: " + targetFieldName.getValue() + " value: " + targetFieldValue);

        Integer primitiveValue = -1;
        if (targetFieldValue instanceof Computable) {
            Computable computable = (Computable) targetFieldValue;
            //System.out.println(" computable.getResult(): "+  computable.getResult());
            primitiveValue = (Integer) computable.getResult();
        }
        shuchu(data);
        System.out.println("duration:" +a + " use_number:" + b + " duration_trend:" + c + " duration_workday:" + d +
                " use_number_workday:" + e +" duration_weekend:" + f + " use_number_weekend:" + g +" --> gender:" + primitiveValue);
        return primitiveValue;
    }

    public void shuchu(Map<String, Double> data) {
        Iterator iter = data.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry entry = (Map.Entry) iter.next();
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println(key + ":" + value);
        }
    }

    public static void main(String args[]){
        PMML2EvaluatorDemo demo = new PMML2EvaluatorDemo();
        // 加载保存在pmml中的模型
        String modelPath = "C:\\Users\\11103378\\IdeaProjects\\Spark\\SparkModel2PMML\\Appused2genderMultilayerPerceptronClassifier.pmml";
        Evaluator model = demo.loadPmml(modelPath);
        demo.showEvaluator(model);
        // 单条记录推测
        demo.predictAppused2gender(model,465.4,156.6,-0.9,443.9,145.0,529.9,191.5);
    }
    /*
    duration:465.4
    use_number_workday:145.0
    duration_trend:-0.9
    duration_weekend:529.9
    use_number_weekend:191.5
    use_number:156.6
    duration_workday:443.9
    duration:465.4 use_number:156.6 duration_trend:-0.9 duration_workday:443.9 use_number_workday:145.0 duration_weekend:529.9 use_number_weekend:191.5 --> gender:1
    */
}

配置pom文件如下：

<?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.xdb.spark</groupId>
    <artifactId>LoadPmmlDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <pmml-model.version>1.4.2</pmml-model.version>
    </properties>

    <dependencies>
        <!--pmml模型-->
        <dependency>
            <groupId>org.jpmml</groupId>
            <artifactId>pmml-model</artifactId>
            <version>${pmml-model.version}</version>
        </dependency>
        <dependency>
            <groupId>org.jpmml</groupId>
            <artifactId>pmml-evaluator</artifactId>
            <version>1.4.2</version>
        </dependency>
        <dependency>
            <groupId>org.jpmml</groupId>
            <artifactId>pmml-evaluator-extension</artifactId>
            <version>1.4.2</version>
        </dependency>
    </dependencies>
</project>

 

akenseren
关注
专栏目录
tensorflow机器学习模型的跨平台上线
wenyusuran的专栏
08-05 1021
　　在用PMML实现机器学习模型的跨平台上线中，我们讨论了使用PMML文件来实现跨平台模型上线的方法，这个方法当然也适用于tensorflow生成的模型，但是由于tensorflow模型往往较大，使用无法优化的PMML文件大多数时候很笨拙，因此本文我们专门讨论下tensorflow机器学习模型的跨平台上线的方法。 1.tensorflow模型的跨平台上线的备选方案 　　　　tensorflo...
机器学习模型部署—PMML
阿黎逸阳的博客
08-03 2153
机器学习模型部署——PMML
pmml4s：Scala的PMML评分库
02-05
PMML4S PMML4S是Scala的PMML（预测模型标记语言）评分库。 它为PMML提供了Scala和Java Evaluator API。 目录 产品特点 PMML4S是基于2.0到最新4.4的PMML规范的轻量级，干净且高效的实现。 型号支持 它支持以下模型： 尚不支持的型号： 转型支持 它支持以下转换： 正常化 离散化 价值映射 文字索引 功能 尚不支持的转换： 聚合 落后 安装 可从Maven Central获得PMML4S 。 最新发布的： SBT用户 libraryDependencies + = " org.pmml4s " %% " pmml4s " % " 0
Python模型上线pmml以及自定义函数转换（2）
最新发布
jin_tmac's studio
11-28 958
常用特征转换有sklearn_pandas.DataFrameMapper、sklearn.compose.ColumnTransformer、sklearn.preprocessing.FunctionTransformer等，ColumnTransformer用法如下： 2、能转换成pmml文件的特征转换 但是functiontransformer在转换pmml的时候总是报Java错误，不支持自定义函数转换，因此目前函数转换主要是用到sklearn2pmml.preprocessing相关的特征预处理过
Spark-ml模型保存为PMML格式，PMML version不兼容问题。
baifanwudi的专栏
11-09 6560
最近使用spark-ml做数据模型训练，考虑到怎么把模型部署到线上环境。 本尝试spring-boot启动spark-local模式预测，发现线上预测需要200ms~300ms，耗时太多。 所以考虑把spark模型转换为pmml格式。 我的spark集群版本为2.1.3
pyspark使用ML库并用pyspark2pmml把模型保存为pmml格式
weixin_42051109的博客
11-20 5996
一、准备工作        使用Idea开发pyspark程序，在这之前我们需要做一些准备工作， 如同PyCharm开发pyspark程序一样，我们需要先对python项目进行配置： 1. 使用anaconda3里面的python     打开File -&gt; Project Structure -&gt; Project ,其中Project SDK的路径设为anaconda3的pyt...
【Spark】Spark训练Lr模型，并保存为Pmml
郝同学的博客
08-10 1188
scala版本spark构建的Lr模型： 模型接口详情可以参考spark的scala的API文档：https://spark.apache.org/docs/latest/api/scala/org/apache/spark/index.html import org.apache.spark.ml.Pipeline import org.apache.spark.ml.classification.{LogisticRegression, LogisticRegressionModel} import o
java调用pmml_用PMML实现机器学习模型的跨平台上线
weixin_39608398的博客
02-16 1035
在机器学习用于产品的时候，我们经常会遇到跨平台的问题。比如我们用Python基于一系列的机器学习库训练了一个模型，但是有时候其他的产品和项目想把这个模型集成进去，但是这些产品很多只支持某些特定的生产环境比如Java，为了上一个机器学习模型去大动干戈修改环境配置很不划算，此时我们就可以考虑用预测模型标记语言(Predictive Model Markup Language,以下简称PMML)来实现跨...
java加载pmml模型文件报错_用PMML实现机器学习模型的跨平台上线
weixin_31854867的博客
02-26 470
在机器学习用于产品的时候，我们经常会遇到跨平台的问题。比如我们用Python基于一系列的机器学习库训练了一个模型，但是有时候其他的产品和项目想把这个模型集成进去，但是这些产品很多只支持某些特定的生产环境比如Java，为了上一个机器学习模型去大动干戈修改环境配置很不划算，此时我们就可以考虑用预测模型标记语言(Predictive Model Markup Language,以下简称PMML)来实现跨...
使用PMML部署机器学习模型
关注AI/ML模型上线、模型部署
09-11 3930
介绍了PMML这种跨平台机器学习模型表示标准，PMML的优缺点，常用的PMML开源类库(Nyoka、JPMML、PMML4S、PyPMML等)，以及演示了如何生成和使用PMML
spark导出PMML模型bug排查纪实
Luckin的博客
06-18 573
当遇到大规模逻辑回归LR时，原生spark是解决不了问题的 项目场景： 本项目需要使用LR模型作为排序模型，输入矩阵为独热编码后的稀疏矩阵。不考虑PMML存储方式的实现很简单，使用的是官方API（我用的是spark2.4.0版本） 通过独热编码One-hotCode产生高维稀疏矩阵时，此时还想通过JPMML-spark工具和pipelineModel方式生成PMML文件是不可行。 问题描述： 一开始我也以为LR模型模型训练后很容易导出为PMML文件。 通过下文我开启了PMML探索之旅。 模型在
PMML模型的介绍
weixin_44152939的博客
08-17 2042
PMML(Predictive Model Markup Language，预测模型标记语⾔)⽂件，它⽤XML格式来描述⽣成的机器学习 模型，可以将在Python中训练好的模型部署到⽣产上，⽤⽬标环境解析PMML⽂件的库来加载模型，并做预测。...
机器学习平台系列（八） - 模型在线预测服务之模型转换PMML
蜗牛的专栏
12-15 2470
文章目录1.SparkML 本文介绍如何使用jpmml将各类模型转换成pmml文件，模型在线预测服务需要支持如下几类模型： 支持Spark ML的模型 支持Sklearn的模型 支持XGBoost 支持LightGBM 1.SparkML 从 Spark 中 LogisticRegressionModel 着手，分析是否有原生方法生成 PMML 文件。 在spark-mllib_2.11:2....
Spark加载PMML进行预测
fansy1990的专栏
11-25 1万+
软件版本：CDH:5.8.0 , CDH-hadoop :2.6.0 ; CDH-spark :1.6.0 目标：使用Spark 加载PMML文件到模型，并使用Spark平台进行预测（这里测试使用的是Spark on YARN的方式）。具体小目标：1. 参考https://github.com/jpmml/jpmml-spark 实现，能运行简单例子；2. 直接读取HDFS上面的输入数据文件，使用
pmml（模型标准化）
Liao Tuo
11-01 1万+
PMML简介PMML全称预言模型标记模型（Predictive Model Markup Language），以XML 为载体呈现数据挖掘模型。PMML 允许您在不同的应用程序之间轻松共享预测分析模型。因此，您可以在一个系统中定型一个模型，在 PMML 中对其进行表达，然后将其移动到另一个系统中，而不需考虑分析和预测过程中的具体实现细节。使得模型的部署摆脱了模型开发和产品整合的束缚。PMML标准PM
JPMML调用PMML机器学习模型零基础总结（内含新版本jpmml解决方法）
轻舟已过万重山的博客
08-13 3655
起因 由于公司要上线机器学习的预测模型，而我用的是python语言，要在java上部署，所以需要我提供pmml文件，再通过jpmml库调用。但我不知道这种方式可不可行，同时交给别人调试也不方便，于是乎产生了自己搭建java-jpmml环境的想法。 流程 总体的流程大致是： python侧sklearn2pmml 直接生成 .pmml 模型文件 下载JDK 16.0 下载intellij idea社区版 下载Maven（好像也可以不下载，毕竟intellij自带创建maven项目) 在intellij中创建新
PMML 预测模型教程
wxk_1127的博客
04-03 5973
什么是PMMLPMML 是一种基于XML的标准语言，用于表达数据挖掘模型，可以用来在不同的应用程序中交换模型。一种非常有用的应用场景是在生产环境中部署用各种建模工具训练出来的模型。目前最新的标准是4.3 http://dmg.org/pmml/pmml-v4-3.html。PMML 文件的结构遵从了用于构建预测解决方案的常用步骤，包括：数据词典，这是一种数据分析阶段的产品，可以识别和定义哪些输入数...
PMML模型文件在机器学习的实践经验
热门推荐
文西
10-23 2万+
算法工程师和业务开发工程师，所掌握的技能容易在长期的工作中出现比较深的鸿沟，算法工程师辛辛苦苦调参的成果，业务工程师可能不清楚如何使用，如何为线上决策给予支持。本文介绍一种基于PMML的模型上线方法。这种方案，在本次参加 QCon 大会时，Paypal的机器学习平台中也有所提及：PMML预测模型标记语言(Predictive Model Markup Language,PMML)是一种可以呈现预测
PMML跨平台使用（与Java交互）
weixin_42155726的博客
07-31 2253
什么是PMML PMML 是一种事实标准语言，用于呈现数据挖掘模型。预测分析模型和数据挖掘模型是指代数学模型的术语，这些模型采用统计技术了解大量历史数据中隐藏的模式。预测分析模型采用定型过程中获取的知识来预测新数据中是否有已知模式。PMML 允许您在不同的应用程序之间轻松共享预测分析模型。因此，您可以在一个系统中定型一个模型，在 PMML 中对其进行表达，然后将其移动到另一个系统中，并在该系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值