Predictive Services Development With Java and Weka

In this article, we will briefly describe how to create predictive services with Java and Weka library (Waikato Environment for Knowledge Analysis, The University of Waikato).

We will develop a Java application and consider a real-life example — the prediction of real estate prices in Seattle depending on parameters (area, distance from center, bedrooms). The application will learn real estate prices, and we will analyze its predictions.

The city of Seattle was chosen randomly for this article.

Brief Introduction to Machine Learning in Java

If you never heard about machine learning, or you're simply afraid of it, please don't  :)

Machine learning is a rapidly growing field of artificial intelligence (AI) that involves the development of algorithms and models that enable computers to learn and make predictions or decisions based on data. Machine learning could be used for image and object recognition, natural language processing (NLP), customer relationship management, recommendation systems, predictive maintenance, and much more.

Indeed, it is not that easy to develop everything from scratch, but Java provides a rich ecosystem of libraries and tools that can be leveraged for machine learning tasks, such as data preprocessing, feature engineering, model training, and evaluation. 

Just some examples of tools that help developers to implement machine learning algorithms and build predictive models — Deeplearning4j, MLlib (Apache Spark), Smile (Statistical Machine Intelligence and Learning Engine), DL4J (Deep Learning for Java), Encog (Embedded Neural Network and Genetic Programming Framework), JOONE (Java Object Oriented Neural Engine), Weka (Waikato Environment for Knowledge Analysis).

Development of Predictive Application

In this article, we will develop an application responsible for predicting real estate prices in Seattle depending on parameters (area, distance from the center, and bedrooms).

We will use a machine learning library called Weka (Waikato Environment for Knowledge Analysis, The University of Waikato), which provides a wide range of machine learning algorithms and tools for data mining, feature selection, and model evaluation. Weka is an open-source software that is widely used in both academic and industry settings for a variety of machine-learning tasks.

1. Application Dependencies

First, in order to start using Weka in the Java application, we have to add it to the classpath. You can find the required artifacts in the Maven repository. Just add it to application properties:

• using Maven

<dependencies>
    <!-- https://mvnrepository.com/artifact/nz.ac.waikato.cms.weka/weka-stable -->
    <dependency>
        <groupId>nz.ac.waikato.cms.weka</groupId>
        <artifactId>weka-stable</artifactId>
        <version>3.8.6</version>
    </dependency>
</dependencies>

• using Gradle

// https://mvnrepository.com/artifact/nz.ac.waikato.cms.weka/weka-stable
implementation group: 'nz.ac.waikato.cms.weka', name: 'weka-stable', version: '3.8.6'

2. Initial Dataset

Machine learning applications are mostly designed to autonomously learn from data and improve their performance over time.

But in this article, we will simply provide an application with the initial dataset, i.e. some real estate prices in Seattle. To do that, let's create an arff file and collect some data there.

% All comments have to start with '%' character

% Relation name
@relation prices

% Fields order
@attribute area numeric     % area, sqft
@attribute Bedrooms numeric % bedrooms, bd
@attribute distance numeric % distance to the center, mi
@attribute price numeric    % price, $

% Declaring examples
@data
% Area, sqft    Bedrooms    Distance, mi    Price, $
3150            4           1.2             1349000
2290            3           1.2             1050000
2940            6           3.0             1850000
1107            2           3.2             729950
1122            2           6.6             599950
1350            2           6.9             598000
1390            3           12.2            449950
1660            5           12.3            619950
1540            4           12.9            1024900

Such a file could be simply placed in the application resources folder or in any other place.

There are just several records. This is enough for this article, but for real-world applications, it isn't. In order to achieve high accuracy, much more data should be provided, automated learning techniques should be used, and data should be collected continuously. 

However, it's important to carefully evaluate and validate the results obtained from automated processes to ensure the reliability and accuracy of the machine learning models in real-world applications.

3. Java Code

First, we have to teach our application. In this article, we can do it by passing an arff file with the initial dataset to it. Let's retrieve this data and set a class index to a price:

// Loading Seattle real estate prices from arff file
ConverterUtils.DataSource source = new ConverterUtils.DataSource("prices.arff");
Instances data = source.getDataSet();
// Setting the last attribute (price) to the class index
data.setClassIndex(data.numAttributes() - 1);

Second, we have to create a classifier. Let's use a linear regression classifier in this article:

// Creating a linear regression based classifier
Classifier classifier = new LinearRegression();

// Let's learn classifier with data
classifier.buildClassifier(data);

// Creating an Instance for predictions
Instance instance = new DenseInstance(data.numAttributes());
instance.setDataset(data);

And now, we can write a code for a price prediction depending on the area, bedrooms, and distance to the center:

public void predictPrice(double area, int bedrooms, double milesAway) throws Exception {
    // Let's ask for a price for the property:
    instance.setValue(0, area);
    instance.setValue(1, bedrooms);
    instance.setValue(2, milesAway);

    // Price predicting action
    double predictedPrice = classifier.classifyInstance(instance);
    System.out.println("Predicted price: " + predictedPrice);

    // Calculation error rate
    Evaluation eval = new Evaluation(data);
    eval.evaluateModel(classifier, data);
    System.out.println("Calculation error rate: " + eval.errorRate());
}

The code mentioned in this article can be found on GitHub.

4. Running Application

So basically, we're ready to launch an application. 

It consumes a file with an initial dataset in order to learn prices in Seattle, linear regression is used, and it is ready to predict prices depending on parameters (area, distance from center, bedrooms).

The application is asked to predict prices for several objects, and the output is:

-- Predicting price for [area - 2000.0 sqft, bedrooms - 4, miles away - 1.0 mi]
Predicted price: 1367914.915677933
...
-- Predicting price for [area - 2000.0 sqft, bedrooms - 4, miles away - 10.0 mi]
Predicted price: 857712.4223102874
Calculation error rate: 167943.05185960032