Crate smartcore

smartcore

Welcome to smartcore, machine learning in Rust!

smartcore features various classification, regression and clustering algorithms including support vector machines, random forests, k-means and DBSCAN, as well as tools for model selection and model evaluation.

smartcore provides its own traits system that extends Rust standard library, to deal with linear algebra and common computational models. Its API is designed using well recognizable patterns. Extra features (like support for ndarray structures) is available via optional features.

Getting Started

To start using smartcore latest stable version simply add the following to your Cargo.toml file:

[dependencies]
smartcore = "*"

To start using smartcore development version with latest unstable additions:

[dependencies]
smartcore = { git = "https://github.com/smartcorelib/smartcore", branch = "development" }

There are different features that can be added to the base library, for example to add sample datasets:

[dependencies]
smartcore = { git = "https://github.com/smartcorelib/smartcore", features = ["datasets"] }

Check smartcore’s Cargo.toml for available features.

Using Jupyter

For quick introduction, Jupyter Notebooks are available here. You can set up a local environment to run Rust notebooks using EVCXR following these instructions.

First Example

For example, you can use this code to fit a K Nearest Neighbors classifier to a dataset that is defined as standard Rust vector:

// DenseMatrix definition
use smartcore::linalg::basic::matrix::DenseMatrix;
// KNNClassifier
use smartcore::neighbors::knn_classifier::*;
// Various distance metrics
use smartcore::metrics::distance::*;

// Turn Rust vector-slices with samples into a matrix
let x = DenseMatrix::from_2d_array(&[
   &[1., 2.],
   &[3., 4.],
   &[5., 6.],
   &[7., 8.],
   &[9., 10.]]).unwrap();
// Our classes are defined as a vector
let y = vec![2, 2, 2, 3, 3];

// Train classifier
let knn = KNNClassifier::fit(&x, &y, Default::default()).unwrap();

// Predict classes
let y_hat = knn.predict(&x).unwrap();

Overview

Supported algorithms

All machine learning algorithms are grouped into these broad categories:

• Clustering, unsupervised clustering of unlabeled data.
• Matrix Decomposition, various methods for matrix decomposition.
• Linear Models, regression and classification methods where output is assumed to have linear relation to explanatory variables
• Ensemble Models, variety of regression and classification ensemble models
• Tree-based Models, classification and regression trees
• Nearest Neighbors, K Nearest Neighbors for classification and regression
• Naive Bayes, statistical classification technique based on Bayes Theorem
• SVM, support vector machines

Linear Algebra traits system

For an introduction to smartcore’s traits system see this notebook

Modules

algorithm

Various algorithms and helper methods that are used elsewhere in smartcore

api

Common Interfaces and API

cluster

Algorithms for clustering of unlabeled data

decomposition

Matrix decomposition algorithms

ensemble

Ensemble methods, including Random Forest classifier and regressor

error

Custom warnings and errors

linalg

Diverse collection of linear algebra abstractions and methods that power smartcore algorithms

linear

Supervised classification and regression models that assume linear relationship between dependent and explanatory variables.

metrics

Functions for assessing prediction error.

model_selection

TODO: add docstring for model_selection

naive_bayes

Supervised learning algorithms based on applying the Bayes theorem with the independence assumptions between predictors

neighbors

Supervised neighbors-based learning methods

numbers

Foundamental numbers traits

optimization

Optimization procedures

preprocessing

Preprocessing utilities

svm

Support Vector Machines

tree

Supervised tree-based learning methods