smile

Statistical Machine Intelligence & Learning Engine

6,373

1,146

6,373

View on GitHub

Top Related Projects

scikit-learn

66,751

scikit-learn: machine learning in Python

spark

43,242

Apache Spark - A unified analytics engine for large-scale data processing

H2O is an Open Source, Distributed, Fast & Scalable Machine Learning Platform: Deep Learning, Gradient Boosting (GBM) & XGBoost, Random Forest, Generalized Linear Modeling (GLM with Elastic Net), K-Means, PCA, Generalized Additive Models (GAM), RuleFit, Support Vector Machine (SVM), Stacked Ensembles, Automatic Machine Learning (AutoML), etc.

xgboost

28,479

Scalable, Portable and Distributed Gradient Boosting (GBDT, GBRT or GBM) Library, for Python, R, Java, Scala, C++ and more. Runs on single machine, Hadoop, Spark, Dask, Flink and DataFlow

LightGBM

18,470

A fast, distributed, high performance gradient boosting (GBT, GBDT, GBRT, GBM or MART) framework based on decision tree algorithms, used for ranking, classification and many other machine learning tasks.

mlpack

5,638

mlpack: a fast, header-only C++ machine learning library

Quick Overview

SMILE (Statistical Machine Intelligence and Learning Engine) is a comprehensive machine learning and data mining library written in Java and Scala. It provides a wide range of algorithms for classification, regression, clustering, association rule mining, feature selection, and more. SMILE aims to be efficient, scalable, and easy to use for both researchers and practitioners.

Pros

Comprehensive library covering a wide range of machine learning tasks
High-performance implementation with native C/C++ backends for some algorithms
Supports both Java and Scala, with a user-friendly API
Well-documented with extensive examples and tutorials

Cons

Steeper learning curve compared to some other ML libraries
Less frequent updates and smaller community compared to more popular libraries like scikit-learn
Limited support for deep learning compared to specialized frameworks
Some advanced features may require more in-depth knowledge of machine learning concepts

Code Examples

Classification using Random Forest:

DataFrame data = Read.csv("iris.csv");
Formula formula = Formula.lhs("species");
RandomForest model = RandomForest.fit(formula, data);
System.out.println("OOB error = " + model.error());

K-means clustering:

double[][] data = MathEx.readCSV("clustering_data.csv");
KMeans kmeans = KMeans.fit(data, 3);
int[] labels = kmeans.predict(data);

Principal Component Analysis (PCA):

val data = Read.csv("pca_data.csv").toArray
val pca = PCA.fit(data)
val projected = pca.project(data)

Getting Started

To use SMILE in your Java or Scala project, add the following dependency to your build file:

For Maven:

<dependency>
    <groupId>com.github.haifengl</groupId>
    <artifactId>smile-core</artifactId>
    <version>2.6.0</version>
</dependency>

For Gradle:

implementation 'com.github.haifengl:smile-core:2.6.0'

Then, import the necessary classes and start using SMILE in your code:

import smile.data.*;
import smile.classification.*;
import smile.regression.*;
import smile.clustering.*;

For more detailed instructions and examples, refer to the official documentation at https://haifengl.github.io/smile/.

Competitor Comparisons

scikit-learn

66,751

scikit-learn: machine learning in Python

Pros of scikit-learn

Larger community and more extensive documentation
Wider range of algorithms and tools for machine learning tasks
Better integration with other Python scientific computing libraries

Cons of scikit-learn

Slower performance for some algorithms compared to SMILE
Less support for big data processing and distributed computing
More complex API for certain tasks, especially when compared to SMILE's streamlined approach

Code Comparison

SMILE example (Java):

DataFrame df = Read.csv("iris.csv");
KMeans model = new KMeans(3);
int[] labels = model.fit(df).predict(df);

scikit-learn example (Python):

from sklearn.cluster import KMeans
import pandas as pd

df = pd.read_csv("iris.csv")
model = KMeans(n_clusters=3)
labels = model.fit_predict(df)

Both libraries offer similar functionality for common machine learning tasks, but SMILE provides a more concise API in Java, while scikit-learn offers greater flexibility and integration within the Python ecosystem. SMILE may have performance advantages in certain scenarios, particularly for large-scale data processing, while scikit-learn benefits from a larger community and more extensive documentation.

spark

43,242

Apache Spark - A unified analytics engine for large-scale data processing

Pros of Spark

Distributed computing capabilities for large-scale data processing
Extensive ecosystem with support for SQL, streaming, and machine learning
Strong community support and regular updates

Cons of Spark

Steeper learning curve and more complex setup
Higher resource requirements, especially for smaller datasets
Potential overhead for simple tasks that don't require distributed processing

Code Comparison

Spark (Scala):

val df = spark.read.csv("data.csv")
val result = df.groupBy("column").agg(sum("value"))
result.show()

Smile (Java):

DataFrame df = Read.csv("data.csv");
DataFrame result = df.groupBy("column").sum("value");
System.out.println(result);

Key Differences

Spark is designed for distributed computing, while Smile focuses on in-memory processing
Spark offers a wider range of functionalities, whereas Smile specializes in machine learning and statistical analysis
Smile provides a simpler API and is more lightweight, making it easier to integrate into existing Java projects
Spark has better support for big data processing and real-time streaming analytics

Use Cases

Choose Spark for large-scale data processing, distributed computing, and complex analytics pipelines
Opt for Smile when working with smaller datasets, requiring fast in-memory processing, or integrating machine learning into Java applications

h2o-3

7,494

Pros of H2O-3

Distributed computing support for handling large datasets
Extensive API support (R, Python, Java, Scala, REST)
Advanced AutoML capabilities

Cons of H2O-3

Steeper learning curve due to its distributed nature
Requires more system resources for setup and operation

Code Comparison

H2O-3 (Python):

import h2o
h2o.init()
data = h2o.import_file("path/to/data.csv")
model = h2o.automl.H2OAutoML(max_models=10)
model.train(x=["feature1", "feature2"], y="target", training_frame=data)

SMILE (Java):

DataFrame data = Read.csv("path/to/data.csv");
RandomForest model = RandomForest.fit(Formula.lhs("target"), data);
double[] prediction = model.predict(newData);

H2O-3 offers a more automated approach with its AutoML feature, while SMILE provides a more traditional API for machine learning tasks. H2O-3 is better suited for large-scale distributed computing, whereas SMILE is more lightweight and easier to integrate into existing Java applications. Both libraries offer a wide range of machine learning algorithms, but H2O-3 has a broader ecosystem with multiple language bindings and advanced features like AutoML.

xgboost

28,479

Scalable, Portable and Distributed Gradient Boosting (GBDT, GBRT or GBM) Library, for Python, R, Java, Scala, C++ and more. Runs on single machine, Hadoop, Spark, Dask, Flink and DataFlow

Pros of XGBoost

Highly optimized for performance and scalability
Supports distributed computing for large-scale datasets
Extensive documentation and active community support

Cons of XGBoost

Steeper learning curve for beginners
More complex hyperparameter tuning process
Limited built-in visualization tools

Code Comparison

XGBoost:

import xgboost as xgb
model = xgb.XGBClassifier()
model.fit(X_train, y_train)
predictions = model.predict(X_test)

Smile:

XGBoost model = XGBoost.fit(X_train, y_train);
int[] predictions = model.predict(X_test);

Key Differences

XGBoost is primarily focused on gradient boosting, while Smile offers a broader range of machine learning algorithms
Smile provides a more user-friendly API for Java developers, while XGBoost has stronger support for Python users
XGBoost excels in handling large-scale datasets and distributed computing, whereas Smile is more suitable for smaller to medium-sized datasets
Smile offers built-in data preprocessing and feature selection tools, which are not as extensive in XGBoost

Both libraries have their strengths and are suitable for different use cases. XGBoost is ideal for large-scale gradient boosting tasks, while Smile provides a more comprehensive machine learning toolkit for Java developers.

LightGBM

18,470

Error generating comparison

mlpack

5,638

mlpack: a fast, header-only C++ machine learning library

Pros of mlpack

Written in C++, offering high performance and efficiency
Extensive collection of machine learning algorithms and tools
Supports both command-line interface and C++ API

Cons of mlpack

Steeper learning curve due to C++ complexity
Less extensive documentation compared to Smile
Smaller community and fewer contributors

Code Comparison

mlpack:

#include <mlpack/core.hpp>
#include <mlpack/methods/neighbor_search/neighbor_search.hpp>

using namespace mlpack;

arma::mat data;
data::Load("dataset.csv", data, true);
NeighborSearch<NearestNeighborSort> nn(data);

Smile:

import smile.data.*;
import smile.neighbor.*;

DataFrame data = Read.csv("dataset.csv");
KNNSearch<double[]> knn = new KDTree<>(data.toArray(), data.toArray());

Summary

mlpack offers high performance and a wide range of algorithms but has a steeper learning curve. Smile provides a more user-friendly Java-based approach with comprehensive documentation. Both libraries have their strengths, and the choice depends on specific project requirements and developer preferences.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Statistical Machine Intelligence & Learning Engine

SMILE (Statistical Machine Intelligence & Learning Engine) is a comprehensive, high-performance machine learning framework for the JVM. SMILE v5+ requires Java 25; v4.x requires Java 21; all previous versions require Java 8. SMILE also provides idiomatic APIs for Scala and Kotlin. With advanced data structures and algorithms, SMILE delivers state-of-the-art performance across every aspect of machine learning.

Features
Module Map
Installation
Quick Start
SMILE Studio & Shell
Model Serialization
Visualization
License
Issues & Discussions
Contributing
Maintainers
Gallery

Features

Area	Highlights
LLM	LLaMA-3 inference, tiktoken BPE tokenizer, OpenAI-compatible REST server, SSE chat streaming
Deep Learning	LibTorch/GPU backend, EfficientNet-V2 image classification, custom layer API
Classification	SVM, Decision Trees, Random Forest, AdaBoost, Gradient Boosting, Logistic Regression, Neural Networks, RBF Networks, MaxEnt, KNN, NaÃ¯ve Bayes, LDA/QDA/RDA
Regression	SVR, Gaussian Process, Regression Trees, GBDT, Random Forest, RBF, OLS, LASSO, ElasticNet, Ridge
Clustering	BIRCH, CLARANS, DBSCAN, DENCLUE, Deterministic Annealing, K-Means, X-Means, G-Means, Neural Gas, Growing Neural Gas, Hierarchical, SIB, SOM, Spectral, Min-Entropy
Manifold Learning	IsoMap, LLE, Laplacian Eigenmap, t-SNE, UMAP, PCA, Kernel PCA, Probabilistic PCA, GHA, Random Projection, ICA
Feature Engineering	Genetic Algorithm selection, Ensemble selection, TreeSHAP, SNR, Sum-Squares ratio, data transformations, formula API
NLP	Sentence / word tokenization, Bigram test, Phrase & Keyword extraction, Stemmer, POS tagging, Relevance ranking
Association Rules	FP-growth frequent itemset mining
Sequence Learning	Hidden Markov Model, Conditional Random Field
Nearest Neighbor	BK-Tree, Cover Tree, KD-Tree, SimHash, LSH
Numerical Methods	Linear algebra, numerical optimization (BFGS, L-BFGS), interpolation, wavelets, RBF, distributions, hypothesis tests
Visualization	Swing plots (scatter, line, bar, box, histogram, surface, heatmap, contour, â¦) and declarative Vega-Lite charts

Module Map

Each module has its own detailed user guide. Click the README link for the module overview, or drill into individual topic guides.

`base/` â Foundation

Data structures, math, linear algebra, statistical utilities, I/O

Document	Topics
README	Module overview and dependency setup
DATA_FRAME.md	DataFrame API â creation, selection, transformation
DATA_IO.md	CSV, JSON, Parquet, Arrow, JDBC, Avro readers/writers
DATA_TRANSFORMATION.md	Scalers, encoders, imputers, feature transforms
DATASET.md	Built-in benchmark and real-world datasets
FORMULA.md	R-style formula language for model matrices
DISTRIBUTIONS.md	Probability distributions (Normal, Poisson, Beta, â¦)
HYPOTHESIS_TESTING.md	t-test, chi-squared, ANOVA, KS-test, â¦
DISTANCES.md	Euclidean, Mahalanobis, Hamming, edit distance, â¦
NEAREST_NEIGHBOR.md	KD-Tree, Cover Tree, BK-Tree, LSH
KERNELS.md	Gaussian, polynomial, Laplacian, and other kernel functions
RBF.md	Radial basis function networks
INTERPOLATION.md	Linear, cubic spline, bilinear, bicubic
GRAPH.md	Adjacency list/matrix graph, BFS/DFS, spanning trees
SORT.md	Quick sort, heap sort, counting sort, index sort
HASH.md	Locality-sensitive hashing, SimHash
RNG.md	Random number generators, sampling, permutations
BFGS.md	L-BFGS and BFGS numerical optimizers
ICA.md	Independent Component Analysis
TENSOR.md	N-dimensional array (CPU tensor without LibTorch)
WAVELET.md	DWT, CWT, and wavelet families
GAP.md	GAP statistic for optimal cluster count estimation
COMPRESSED_SENSING.md	Compressed sensing and basis pursuit

`core/` â Machine Learning Algorithms

Classification, regression, clustering, manifold learning, and more

Document	Topics
README	Module overview
CLASSIFICATION.md	SVM, Random Forest, AdaBoost, GBDT, KNN, NaÃ¯ve Bayes, LDA, â¦
REGRESSION.md	SVR, Gaussian Process, LASSO, Ridge, ElasticNet, GBDT, â¦
CLUSTERING.md	K-Means, DBSCAN, BIRCH, SOM, Spectral Clustering, â¦
FEATURE_ENGINEERING.md	Feature selection, PCA, ICA, projection, encoding
MANIFOLD.md	t-SNE, UMAP, IsoMap, LLE, Laplacian Eigenmap
ANOMALY_DETECTION.md	IsolationForest, one-class SVM, local outlier factor
ASSOCIATION_RULE_MINING.md	FP-growth, association rules, frequent itemsets
SEQUENCE.md	HMM (Baum-Welch, Viterbi), CRF
TIME_SERIES.md	ARIMA, box-plots, autocorrelation
REGRESSION.md	Full regression API reference
TRAINING.md	Cross-validation, bootstrap, hyper-parameter search
VALIDATION.md	Hold-out, k-fold, leave-one-out evaluation
VALIDATION_METRICS.md	Accuracy, AUC, F1, RMSE, MAE, confusion matrix
HYPER_PARAMETER_OPTIMIZATION.md	Grid search, random search, Bayesian optimization
VECTOR_QUANTIZATION.md	LVQ, Neural Gas, SOM as vector quantizers
ONNX.md	Exporting and importing models via ONNX

`deep/` â Deep Learning & LLMs

LibTorch-backed GPU/CPU tensor operations, neural network layers, LLaMA-3 inference, EfficientNet

Document	Topics
README	Full deep-learning & LLM user guide (tensors, layers, loss, optimizer, EfficientNet, LLaMA)

The deep/README.md covers:

smile.deep.tensor â Tensor factory, indexing, arithmetic, AutoScope memory management, dtype/device
smile.deep.layer â Linear, Conv2d, pooling, normalization (BN/GN/RMS), dropout, embedding, sequential blocks
smile.deep.activation â ReLU, GELU, SiLU, Tanh, Sigmoid, Softmax, GLU, HardShrink, â¦
smile.deep.Loss â MSE, cross-entropy, BCE, Huber, KL, hinge, and more
smile.deep.Optimizer â SGD, Adam, AdamW, RMSprop
smile.deep.Model â Abstract base class + training loop
smile.deep.metric â Accuracy, Precision, Recall, F1Score with macro/micro/weighted averaging
smile.llm â Message, Role, FinishReason, ChatCompletion records; sinusoidal & RoPE positional encodings
smile.llm.tokenizer â Tokenizer interface, Tiktoken BPE implementation (LLaMA-3 compatible)
smile.llm.llama â Full LLaMA-3 stack: Llama.build(), generate(), chat(), streaming via SubmissionPublisher
smile.vision â VisionModel, ImageDataset, EfficientNet.V2S/M/L() pretrained models, ImageNet labels
smile.vision.transform â Transform interface, ImageClassification pipeline, resize/crop/toTensor helpers

`nlp/` â Natural Language Processing

Text normalization, tokenization, POS tagging, stemming, relevance ranking

Document	Topics
README	Module overview
TOKENIZER.md	Sentence splitter, word tokenizer, regex tokenizer
POS.md	Part-of-speech tagging (Brill tagger, HMM tagger)
STEM.md	Porter, Lancaster, Lovins stemmers; lemmatization
COLLOCATION.md	Bigram/trigram statistical tests, phrase extraction
RELEVANCE.md	TF-IDF, BM25, keyword extraction
TAXONOMY.md	WordNet integration, synsets, hypernyms

`plot/` â Data Visualization

Swing-based interactive plots and declarative Vega-Lite charts

Document	Topics
README	Swing plotting API â scatter, line, bar, box, histogram, heatmap, surface, contour, wireframe
VEGA.md	Declarative `smile.plot.vega` (Vega-Lite) â JSON spec generation, web/Jupyter rendering

`serve/` â Inference Server

Quarkus-based REST inference service with OpenAI-compatible API and SSE streaming

Document	Topics
README	Building and running the server, `/chat/completions` endpoint, SSE streaming, configuration

`studio/` â Interactive Shell & Desktop IDE

REPL / notebook environment for Java, Scala, and Kotlin

Document	Topics
README.md	Desktop Studio notebook UI, cell types, output rendering
CLI	CLI entry points (`smile`, `smile shell`, `smile scala`, `smile kotlin`, `smile server`)

`scala/` â Scala API

Idiomatic Scala shim â concise wrappers, symbolic operators, Scala collections integration

Document	Topics
README	API overview, `smile.classification`, `smile.regression`, `smile.clustering`, `smile.plot` in Scala

`kotlin/` â Kotlin API

Idiomatic Kotlin shim â extension functions, named parameters, builder DSLs

Document	Topics
README	API overview, extension functions, Kotlin-style builders
packages.md	Full package-by-package listing of all Kotlin extension functions

`json/` â JSON Library (Scala)

Lightweight zero-dependency JSON library for Scala with a clean DSL

Document	Topics
README	Parsing, building, pattern matching, path navigation, serialization

`spark/` â Apache Spark Integration

Use SMILE models inside Spark ML pipelines

Document	Topics
README	`SmileTransformer`, `SmileClassifier`, `SmileRegressor`; training and scoring in Spark DataFrames

Installation

Maven

<!-- Core ML algorithms -->
<dependency>
  <groupId>com.github.haifengl</groupId>
  <artifactId>smile-core</artifactId>
  <version>6.1.0</version>
</dependency>

<!-- Deep learning + LLMs (requires LibTorch) -->
<dependency>
  <groupId>com.github.haifengl</groupId>
  <artifactId>smile-deep</artifactId>
  <version>6.1.0</version>
</dependency>

<!-- Natural language processing -->
<dependency>
  <groupId>com.github.haifengl</groupId>
  <artifactId>smile-nlp</artifactId>
  <version>6.1.0</version>
</dependency>

<!-- Data visualization -->
<dependency>
  <groupId>com.github.haifengl</groupId>
  <artifactId>smile-plot</artifactId>
  <version>6.1.0</version>
</dependency>

SBT (Scala)

libraryDependencies += "com.github.haifengl" %% "smile-scala" % "6.1.0"

Gradle (Kotlin)

dependencies {
    implementation("com.github.haifengl:smile-kotlin:6.1.0")
}

Native Libraries (BLAS / LAPACK)

Several algorithms (manifold learning, Gaussian Process, MLP, some clustering) require BLAS and LAPACK.

Linux (Ubuntu / Debian)

sudo apt update
sudo apt install libopenblas-dev libarpack2-dev

macOS (Homebrew)

brew install arpack
# If macOS SIP strips DYLD_LIBRARY_PATH, copy the dylib to your working dir:
cp /opt/homebrew/lib/libarpack.dylib .

Windows â pre-built DLLs are included in the bin/ directory of the release package. Add that directory to PATH.

GPU (CUDA) â make sure the LibTorch CUDA native libraries are on java.library.path and that your Bytedeco pytorch classifier matches your CUDA version (e.g., linux-x86_64-gpu-cuda12.4).

Quick Start

import smile.classification.RandomForest;
import smile.data.formula.Formula;
import smile.io.Read;

// Load data
var data = Read.csv("src/test/resources/iris.csv");

// Train a random forest
var forest = RandomForest.fit(Formula.lhs("species"), data);

// Predict
int label = forest.predict(data.get(0));
System.out.println("Predicted class: " + label);

For deep learning and LLM examples, see deep/README.md. For visualization examples, see plot/README.md.

SMILE Studio & Shell

SMILE ships with an interactive desktop Studio (notebook-style) and a set of CLI shells. See studio/README.md for full documentation.

Download a pre-packaged release from the releases page, then:

cd bin
path/to/smile/bin/setup      # install required native dependencies
path/to/smile/bin/smile      # launch SMILE Studio from your project directory

Other entry points:

Command	Description
`smile`	Desktop notebook IDE
`smile shell`	Java REPL with all SMILE packages pre-imported
`smile scala`	Scala REPL
`smile train`	Train a supervised learning model
`smile predict`	Predict on a file using a saved model
`smile serve`	Start the LLM inference server

To increase the JVM heap:

path/to/smile/bin/smile -J-Xmx30G

Model Serialization

Most SMILE models implement java.io.Serializable. You can serialize a trained model to disk and load it in a production environment or inside a Spark job:

// Save
try (var out = new ObjectOutputStream(new FileOutputStream("model.ser"))) {
    out.writeObject(forest);
}

// Load
try (var in = new ObjectInputStream(new FileInputStream("model.ser"))) {
    var loaded = (RandomForest) in.readObject();
}

Visualization

SMILE provides two visualization layers:

smile.plot.swing â Swing-based interactive 2D/3D plots. See plot/README.md.
smile.plot.vega â Declarative Vega-Lite charts for browsers and Jupyter. See plot/VEGA.md.

<dependency>
  <groupId>com.github.haifengl</groupId>
  <artifactId>smile-plot</artifactId>
  <version>6.1.0</version>
</dependency>

License

SMILE employs a dual license model designed to meet the development and distribution needs of both commercial distributors (OEMs, ISVs, VARs) and open source projects. For details, see LICENSE. To acquire a commercial license, contact smile.sales@outlook.com.

Issues & Discussions

Channel	Purpose
GitHub Discussions	Questions, ideas, show-and-tell
Stack Overflow `[smile]`	Technical Q&A
Issue Tracker	Bug reports and feature requests
Online Docs	Tutorials and programming guides
Java API Â· Scala API Â· Kotlin API Â· Clojure API	API Javadoc

Contributing

Please read CONTRIBUTING.md for build and test instructions.

Maintainers

Haifeng Li (@haifengl)
Karl Li (@kklioss)

Gallery

Scatterplot Matrix
Scatter Plot	Line Plot	Surface Plot
Bar Plot	Box Plot	Histogram Heatmap
Rolling Average	Geo Map	UMAP
Text Plot	Heatmap with Contour	Hexmap
IsoMap	LLE	Kernel PCA
Neural Network	SVM	Hierarchical Clustering
SOM	DBSCAN	Neural Gas
Wavelet	Exponential Family Mixture	Teapot Wireframe
Grid Interpolation