The Predictive Model Markup Language (PMML) developed by the Data Mining Group is a standardized XML-based representation of mining models to be used and shared across languages or tools. The standardized definition allows a classification model trained with R to be used with Storm for example. Many projects related to Big Data have some support for PMML, which is often implemented by JPMML.

Train and Export from R

For this example we train a random forest model based on the iris data set in R. The data set is divided into two samples for training and testing.

# load library and data
library(randomForest)
data(iris)
 
# load data and divide into training set and sampling
ind <- sample(2,nrow(iris),replace=TRUE,prob=c(0.7,0.3))
trainData <- iris[ind==1,]
testData <- iris[ind==2,]
 
# train model
iris_rf <- randomForest(Species~.,data=trainData,ntree=100,proximity=TRUE)
table(predict(iris_rf),trainData$Species)
 
# visualize the model
print(iris_rf)
attributes(iris_rf)
plot(iris_rf)

Now that we have our model we can use the PMML implementation of R to store it a file. Since PMML is XML based we also need the XML library of R to write the model into a file.

# load xml and pmml library
library(XML)
library(pmml)
 
# convert model to pmml
iris_rf.pmml <- pmml(iris_rf,name="Iris Random Forest",data=iris_rf)
 
# save to file "iris_rf.pmml" in same workspace
saveXML(iris_rf.pmml,"iris_rf.pmml")

Run Model in Java with JPMML

Now that we have our trained model we take JPMML to exercise it on the same input. Random Forest, although a kind of tree model, does not count as such in a strict manner. It is a MiningModel for classification in the PMML definition.

PMML pmml = <strong>createPMMLfromFile</strong>("iris_rf.pmml");
 
// create a ModelEvaluator, later being used for evaluation of the input data
ModelEvaluator<<strong>MiningModel</strong>> modelEvaluator = new MiningModelEvaluator(pmml);
printArgumentsOfModel(modelEvaluator);
 
// unmarshal the given file to a PMML model
public PMML <strong>createPMMLfromFile</strong>(String fileName) throws SAXException, JAXBException, FileNotFoundException {
  File pmmlFile = new File(App.class.getResource(fileName).getPath());
  String pmmlString = new Scanner(pmmlFile).useDelimiter("\Z").next();
 
  InputStream is = new ByteArrayInputStream(pmmlString.getBytes());
  InputSource source = new InputSource(is);
  SAXSource transformedSource = ImportFilter.apply(source);
  
  return JAXBUtil.unmarshalPMML(transformedSource);
}

Here we create an explicit ModelEvaluator for a MiningModel. For a more general implementation the ModelEvalutorFactory could be used. The PMML class also has a getModels() function to extract the given model from the definition found in the XML.

The model evaluator can now be used to classify the input data. We use the same iris data we used to train the model for demo purposes. Each model specifies the required input fields and their value types. Here the readArgumentsFromLine function is being used to set the parameters necessary prior to the evaluation. Not much more is required. After we have set the parameters the model can successfully be evaluated. The result again can be read from the model itself.

for(String dataLine : dataLines){
  // System.out.println(dataLine); // (sepal_length,sepal_width,petal_length,petal_width,class)
  if(dataLine.startsWith("sepal_length")) continue;
 
  // read input field for the model
  Map<FieldName, FieldValue> arguments = <strong>readArgumentsFromLine</strong>(dataLine, modelEvaluator);
  modelEvaluator.verify();
 
  // evaluate the model with the given fields
  Map<FieldName, ?> results = modelEvaluator.evaluate(arguments);
  
  // read result fields
  FieldName targetName = modelEvaluator.getTargetField();
  Object targetValue = results.get(targetName);
 
  ProbabilityClassificationMap nodeMap = (ProbabilityClassificationMap) targetValue;
 
  System.out.println("n% 'setosa': " + nodeMap.getProbability("setosa"));
  System.out.println("% 'versicolor': " + nodeMap.getProbability("versicolor"));
  System.out.println("% 'virginica': " + nodeMap.getProbability("virginica"));
 
  System.out.println("== Result: " + nodeMap.getResult() +"n");
}
 
// prepare the input fields of the model
public Map<FieldName, FieldValue> <strong>readArgumentsFromLine</strong>(String line, ModelEvaluator<MiningModel> modelEvaluator) {
  Map<FieldName, FieldValue> arguments = new LinkedHashMap<FieldName, FieldValue>();
  String[] lineArgs = line.split(",");
 
  if( lineArgs.length != 5) return arguments;
 
  FieldValue sepalLength = modelEvaluator.prepare(new FieldName("Sepal.Length"), lineArgs[0].isEmpty() ? 0 : lineArgs[0]);
  FieldValue sepalWidth = modelEvaluator.prepare(new FieldName("Sepal.Width"), lineArgs[1].isEmpty() ? 0 : lineArgs[1]);
  FieldValue petalLength = modelEvaluator.prepare(new FieldName("Petal.Length"), lineArgs[2].isEmpty() ? 0 : lineArgs[2]);
  FieldValue petalWidth = modelEvaluator.prepare(new FieldName("Petal.Width"), lineArgs[3].isEmpty() ? 0 : lineArgs[3]);
 
  arguments.put(new FieldName("Sepal.Length"), sepalLength);
  arguments.put(new FieldName("Sepal.Width"), sepalWidth);
  arguments.put(new FieldName("Petal.Length"), petalLength);
  arguments.put(new FieldName("Petal.Width"), petalWidth);
 
  return arguments;
}

The output would look like this:

...
% 'setosa': 1.0
% 'versicolor': 0.0
% 'virginica': 0.0
== Result: setosa
 
 
% 'setosa': 1.0
% 'versicolor': 0.0
% 'virginica': 0.0
== Result: setosa
....