The jPL framework was originally created by a student project group under the supervision of the Intelligent Systems Group at the University of Paderborn. The aim of this framework is to provide a generic framework to evaluate different algorithms in the context of preference learning. Preference learning is a subfield of machine learning, which deals with learning prediction models using preference information. Learning algorithms solving the following preference learning problems are implemented so far:
- Collaborative Filtering
- Instance Ranking
- Label Ranking
- Multilabel Classification
- Object Ranking
- Ordinal Classification
- Rank Aggregation
On the architecture level our framework can be divided into two different parts. The jPL API provides necessary classes to integrate the different learning algorithms into your own projects whereas the jPL CLI is a complete command line interface. The jPL framework can be used with datasets in the Generic Preference Representation Format (GPRF). This is a format which is created by us for the context of preference learning. In addition, we have created the GPRF dataset transformer to ensure that the user can easily convert other dataset formats into the GPRF.
For a comprehensive guide on how to get started, we refer to the Getting Started page in our wiki.
TL;DR: The following code gives a quick introduction on how to initialize two multilabel classification learning algorithms and run an evaluation of the two of them based on a given dataset in the GPRF format using the API.
//Create the dataset file
DatasetFile datasetFile = new DatasetFile(new File("datasets/emotions-arff.gprf"));
//Create the learning algorithms
ClassifierChainsLearningAlgorithm classifierChains = new ClassifierChainsLearningAlgorithm();
BinaryRelevanceLearningAlgorithm binaryRelevanceLearning = new BinaryRelevanceLearningAlgorithm();
//Create an in sample evaluation
MultilabelClassificationInSampleEvaluation evaluation = new MultilabelClassificationInSampleEvaluation();
//Setup the evaluation with the dataset and the algorithms
evaluation.setupEvaluation(Arrays.asList(datasetFile), Arrays.asList(classifierChains, binaryRelevanceLearning));
evaluation.evaluate();
//Print evaluation result
System.out.println(evaluation.interpretEvaluationResult());
The project itself consists of three Maven projects, where we distinguish between the jpl-api and the jpl-cli project (the latter having a dependency to the first) and finally the jpl-parent, which acts as a Maven aggregator project for the other two.
The easiest way to build the parts of the jPL framework is to use Maven.
In order to build the API on the command line, simply navigate to the according subdirectory and type mvn clean install. Once this is done, you installed the jPL API to your local Maven reository and can now use it freely inside your projects as a Maven dependency.
As the CLI depends on the API, you firstly need to install the API using mvn clean install in the according API directory. Once this is done, you can go to the CLI directory and use the mvn package command to build a jar file.
If you do not want to manually install the API on your system, you can also go to the jpl-parent directory and use the mvn package command, which will ensure that the CLI dependency to the API will be resolved automatically. In case you will only use the CLI, this is method is the suggested method.
The current version of the jPL framework is: 0.0.9
Coming soon!
For more detailed information, please visit our Confluence handbook.
Currently the project is licensed under GPL v3.0.