How Do I Get Started with Aerosolve on the JVM?

Aerosolve is a machine learning package built for humans, designed to make feature engineering fast and painless. It is built on the JVM, uses Scala for feature training, and provides a lightweight Java API for run-time inference. To get started, you need a JVM project, access to the Aerosolve GitHub repository, and the official Get Started entry point on the Aerosolve site. The steps below cover what to gather, how to integrate, and what to verify.

What Aerosolve Gives You on the JVM

Aerosolve is not a standalone platform you run separately from your code. It is a library that lives inside your JVM project. That shapes the entire setup:

• Training side: Scala is used for feature training. You define and train models in Scala.
• Inference side: A lightweight Java API handles run-time inference, so Java services can call trained models without rewriting everything in Scala.
• Integration: Because it is built on the JVM, it integrates with existing JVM projects rather than requiring a separate runtime.

This split matters for planning. If your team writes Java but not Scala, you still need a Scala-capable build path for the training step.

Prerequisites Before You Start

The site lists "Get Started" and "Github" as the two starting points. Use Get Started for the guided path and GitHub for the actual source and build files.

Step-by-Step: Getting Aerosolve Running

Step 1: Open the official Get Started entry

Go to the Aerosolve site and follow the Get Started link. This is the intended first stop and should point you toward installation and build instructions. The site also links to Github, where the package source lives.

Expected result: You have the repository location and the official setup instructions in front of you.

Step 2: Pull the source from GitHub

Clone or download the Aerosolve repository from GitHub. This gives you the Scala training code, the Java inference API, and the build configuration.

Expected result: The Aerosolve source is available locally in your project workspace.

Step 3: Wire it into your JVM build

Add Aerosolve as a dependency in your JVM project's build. Because it is built on the JVM, it slots into an existing JVM build rather than requiring a separate toolchain.

Expected result: Your build resolves Aerosolve and its dependencies without errors.

Step 4: Train a model in Scala

Use Scala to define features and train the model. This is where Aerosolve's feature transform language comes in — it gives you full control over features, and general additive models provide capacity while keeping interpretation easy.

Expected result: A trained model artifact you can hand to the inference layer.

Step 5: Call the model from Java at run time

Use the lightweight Java API for run-time inference. Your Java service loads the trained model and serves predictions.

Expected result: Your Java application returns model predictions in production or test.

What Makes This Worth the Setup

Aerosolve's design choices are the reason to accept the Scala-plus-Java split:

• Geo-based features — the site's own example is neighborhood polygons based on listing density in San Francisco, generated with a multi-scale Kd-tree model.
• Controllable quantization and feature interaction — you steer how features are bucketed and combined.
• Prior beliefs — you can specify prior beliefs to give human intuition to machine models.
• Debuggable models — general additive models offer lots of capacity while enabling easy interpretation, which is the core of the "human-friendly" claim.

If your problem involves geographic signals or you need models a human can inspect, these features justify the two-language setup.

Common Sticking Points

• Assuming Java-only is enough. Training is Scala. Plan for Scala tooling even if inference is Java.
• Skipping the Get Started page. The site provides it as the entry point; use it rather than guessing at build steps.
• Treating it as a service. Aerosolve is a package you integrate, not a hosted platform.
• Ignoring the feature transform language. It is the mechanism for controlling features — skipping it wastes the main advantage.

Verify Your Setup

After integration, confirm three things:

1. Your JVM build resolves Aerosolve without errors.
2. A Scala training run produces a model artifact.
3. A Java call to the inference API returns a prediction from that artifact.

If all three pass, you have a working Aerosolve pipeline. If the training step fails, check your Scala setup first; if inference fails, check the Java API wiring.