从PMML文件导入mllib模型

从PMML文件导入mllib模型

之前找到了从mllib导出PMML模型的方法，并且知道如何从PMML中通过jpmml获取evaluator进行评价。但是要做加载模型进行下一阶段训练的方法没有找到。我找了好几个相关的库都只能找到获取evaluator做评估的方法，最后我想起爬虫中有解析xml的方法，所以通过DOM做了自定义的PMML文件解析，从而获取参数构建模型来训练。

1、 DOM自定义PMML解析

DOM可以将xml-like的文件转成树结构，具体如下：

<?xml version="1.0" encoding="GBK"?>
<address>
	<linkman>
		<name>Van_DarkHolme</name>
		<email>van_darkholme@163.com</email>
	</linkman>
	<linkman>
		<name>Bili</name>
		<email>Bili@163.com</email>
	</linkman>
</address>

转成：

所以我去学了一些DOM的操作，将KMeans的PMML文件解析出来并封装成类：

public class MyPMMLPaser {

    public List<String> parse(String path){
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        List<String> res = new ArrayList<>();
        try {
            DocumentBuilder builder = documentBuilderFactory.newDocumentBuilder();
            Document document = builder.parse(path);
            NodeList arrays = document.getElementsByTagName("Array");
            System.out.println("共有" + arrays.getLength() + "个array标签");
            for (int i = 0; i < arrays.getLength(); i++) {
                res.add(arrays.item(i).getFirstChild().getNodeValue());
                /**
                 * 共有2个array标签
                 * NodeName:Array
                 * NodeValue:null
                 * 0.1 0.1 0.1
                 * NodeName:Array
                 * NodeValue:null
                 * 9.1 9.1 9.1
                 */
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return res;
    }

}

最后可以得到模型保存的簇心，做成List< String >返回。本来我一直在找如何将PMML文件转成对象，通过对象获取簇心值的方法，但是去看了pmml4s、jpmml等库，还是没找到。最后只能想到这种方式来解析，虽然能够成功获取簇心，但是针对不同的模型需要自定义解析器，不是很方便。

2、 构建KMeans模型继续训练

在得到了簇心Array后需要对其做解析，转成Vector：

// 获取簇心List
val paser = new MyPMMLPaser()
val clusterList: util.List[String] = paser.parse("D:\\My_IDE\\IDEA2019\\WorkSpace\\Spark-Kafka\\5_Spark_model_PMML\\src\\main\\model")

val clusterCenters: Array[Vector] = Array[Vector]()
var i: Int = 0
clusterList.forEach(line => {
    // 切分字符串
    val point: Array[String] = line.split(" ")
    // 转Double
    val vector: linalg.Vector = Vectors.dense(Array(point(0).toDouble, point(1).toDouble, point(2).toDouble))

    clusterCenters(i) = vector
    i += 1
})

在完成这一步后就会得到可以用于new KMeansModel的簇心Array。需要构建KMeans做训练首先要了解模型内部的继承关系。经过查阅源码了解到，一般开发者使用的是KMeans的伴生对象，调用train方法做训练：

val model: KMeansModel = KMeans.train(dataVec, clusterNum, iterationNum)

但是如果要设置参数则不能使用伴生对象，所以需要通过模型的类来new对象，通过对象设置参数：

// KMeansModel作为核心模型需要设置簇心
val model: KMeansModel = new KMeansModel(clusterCenters)
// 通过设置模型得到KMeans对象
val means = new KMeans().setInitialModel(model)

但是得到的对象并不是伴生对象，所以无法调用train（伴生对象中的方法）。看源码发现伴生对象中trian方法最终使用的也是类中的run方法：

@Since("2.1.0")
def train(
    data: RDD[Vector],
    k: Int,
    maxIterations: Int,
    initializationMode: String,
    seed: Long): KMeansModel = {
    new KMeans().setK(k)
    .setMaxIterations(maxIterations)
    .setInitializationMode(initializationMode)
    .setSeed(seed)
    .run(data)
}

所以在得到KMeans类对象后，只需要调用run方法即可做训练：

means.run(dataset)

完整代码如下：

object Kmeans2PMML {

    def reLoadModel(pmmlPath: String): KMeans = {

        // 获取簇心List
        val paser = new MyPMMLPaser()
        val clusterList: util.List[String] = paser.parse(pmmlPath)

        val clusterCenters: Array[Vector] = Array[Vector]()
        var i: Int = 0
        clusterList.forEach(line => {
            // 切分字符串
            val point: Array[String] = line.split(" ")
            // 转Double
            val vector: linalg.Vector = Vectors.dense(Array(point(0).toDouble, point(1).toDouble, point(2).toDouble))

            clusterCenters(i) = vector
            i += 1
        })
        val model: KMeansModel = new KMeansModel(clusterCenters)

        new KMeans().setInitialModel(model)
    }

    def main(args: Array[String]): Unit = {
        val conf = new SparkConf().setMaster("local[*]").setAppName("Kmeans2PMML")
        val sc = new SparkContext(conf)
        val data: RDD[String] = sc.textFile("D:\\My_IDE\\IDEA2019\\WorkSpace\\Spark-Kafka\\5_Spark_model_PMML\\src\\main\\data\\kmeans_data.txt")

        val dataVec: RDD[linalg.Vector] = data.map(line => Vectors.dense(line.split(" ").map(_.toDouble)))

        // 设置kmeans参数
        val clusterNum = 2
        val iterationNum = 100
        val model: KMeansModel = KMeans.train(dataVec, clusterNum, iterationNum)

        // PMML模型路径
        val pmmlPath = "D:\\\\My_IDE\\\\IDEA2019\\\\WorkSpace\\\\Spark-Kafka\\\\5_Spark_model_PMML\\\\src\\\\main\\\\model"
        // 保存PMML模型
        model.toPMML(pmmlPath)

        // 加载PMML、构建kmeans类对象
        val kmeans: KMeans = reLoadModel(pmmlPath)

        // 继续训练
        val model1: KMeansModel = kmeans.run(dataVec)

        sc.stop()
    }
}

总结

通过重新构建模型确实是可以实现重新加载训练的，而且这种方式不单只适用于批式算法，在Spark Streaming中应该也是适用的，因为Streaming中的机器学习算法内核同样保存的是mllib批式算法的对象。至于解析PMML，这不是太好的方式，但是目前没找到什么特别好的方法。