• C++ API Documentation

  • Quickstart
  • Matrices and data
  • Loading and saving
  • Citation
  • Core functionality

    • Core math utilities
    • Distances
    • Distributions
    • Kernels
  • Trees

    • KDTree
    • MeanSplitKDTree
    • BallTree
    • MeanSplitBallTree
    • VPTree
    • RPTree
    • MaxRPTree
    • UBTree
    • BinarySpaceTree
  • Classification

    • AdaBoost
    • DecisionTree
    • HoeffdingTree
    • LinearSVM
    • LogisticRegression
    • NaiveBayesClassifier
    • Perceptron
    • RandomForest
    • SoftmaxRegression
  • Regression

    • BayesianLinearRegression
    • DecisionTreeRegressor
    • LARS
    • LinearRegression
  • Clustering

    • MeanShift
  • Geometry
  • Preprocessing

    • Normalizing labels
    • Dataset splitting
  • Transformations

    • AMF
    • LocalCoordinateCoding
    • LMNN
    • NCA
    • NMF
    • PCA
    • RADICAL
    • SparseCoding
  • Modeling

    • Cross-validation
    • Hyperparameter tuning
  • Embedded Applications

    • cross-compile and run k-NN on a Raspberry Pi 2 (armv7)
    • Setting up an mlpack cross-compilation environment
  • Examples
  • Developers

• Binding API

  • Python quickstart
  • Python binding documentation
  • Julia quickstart
  • Julia binding documentation
  • R quickstart
  • R binding documentation
  • CLI quickstart
  • CLI binding documentation
  • Go quickstart
  • Go binding documentation

• mlpack Go binding documentation [top]
  • Overview
  • Go Quickstart
  • Data Formats
  • Classification

    • DecisionTree()
    • LinearSvm()
    • LogisticRegression()
    • Nbc()
    • Perceptron()
    • RandomForest()
    • SoftmaxRegression()
    • Adaboost()
  • Regression

    • BayesianLinearRegression()
    • Lars()
    • LinearRegression()
  • Clustering

    • Dbscan()
    • GmmTrain()
    • GmmGenerate()
    • GmmProbability()
    • HoeffdingTree()
    • Kmeans()
    • MeanShift()
  • Geometry

    • ApproxKfn()
    • Emst()
    • Fastmks()
    • Lsh()
    • Knn()
    • Kfn()
    • Krann()
  • Preprocessing

    • PreprocessSplit()
    • PreprocessBinarize()
    • PreprocessDescribe()
    • PreprocessScale()
    • PreprocessOneHotEncoding()
    • ImageConverter()
  • Misc. / Other

    • Cf()
    • Det()
    • HmmTrain()
    • HmmGenerate()
    • HmmLoglik()
    • HmmViterbi()
    • Kde()
    • Nmf()
  • Transformations

    • KernelPca()
    • Lmnn()
    • LocalCoordinateCoding()
    • Nca()
    • Pca()
    • Radical()
    • SparseCoding()

mlpack Go binding documentation

🔗 mlpack overview

mlpack is an intuitive, fast, and flexible header-only C++ machine learning library with bindings to other languages. It aims to provide fast, lightweight implementations of both common and cutting-edge machine learning algorithms.

This reference page details mlpack’s bindings to Go.

Further useful mlpack documentation links are given below.

• mlpack homepage
• mlpack on Github
• mlpack main documentation page

See also the quickstart guide for Go:

• Go Quickstart

🔗 Data Formats

🔗 ApproxKfn()

Approximate furthest neighbor search

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for ApproxKfn().
param := mlpack.ApproxKfnOptions()
param.Algorithm = "ds"
param.CalculateError = false
param.ExactDistances = mat.NewDense(1, 1, nil)
param.InputModel = nil
param.K = 0
param.NumProjections = 5
param.NumTables = 5
param.Query = mat.NewDense(1, 1, nil)
param.Reference = mat.NewDense(1, 1, nil)
param.Verbose = false

distances, neighbors, output_model := mlpack.ApproxKfn(param)

An implementation of two strategies for furthest neighbor search. This can be used to compute the furthest neighbor of query point(s) from a set of points; furthest neighbor models can be saved and reused with future query point(s). Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program implements two strategies for furthest neighbor search. These strategies are:

• The ‘qdafn’ algorithm from “Approximate Furthest Neighbor in High Dimensions” by R. Pagh, F. Silvestri, J. Sivertsen, and M. Skala, in Similarity Search and Applications 2015 (SISAP).
• The ‘DrusillaSelect’ algorithm from “Fast approximate furthest neighbors with data-dependent candidate selection”, by R.R. Curtin and A.B. Gardner, in Similarity Search and Applications 2016 (SISAP).

These two strategies give approximate results for the furthest neighbor search problem and can be used as fast replacements for other furthest neighbor techniques such as those found in the mlpack_kfn program. Note that typically, the ‘ds’ algorithm requires far fewer tables and projections than the ‘qdafn’ algorithm.

Specify a reference set (set to search in) with Reference, specify a query set with Query, and specify algorithm parameters with NumTables and NumProjections (or don’t and defaults will be used). The algorithm to be used (either ‘ds’—the default—or ‘qdafn’) may be specified with Algorithm. Also specify the number of neighbors to search for with K.

Note that for ‘qdafn’ in lower dimensions, NumProjections may need to be set to a high value in order to return results for each query point.

If no query set is specified, the reference set will be used as the query set. The OutputModel output parameter may be used to store the built model, and an input model may be loaded instead of specifying a reference set with the InputModel option.

Results for each query point can be stored with the Neighbors and Distances output parameters. Each row of these output matrices holds the k distances or neighbor indices for each query point.

🔗 Example

For example, to find the 5 approximate furthest neighbors with reference_set as the reference set and query_set as the query set using DrusillaSelect, storing the furthest neighbor indices to neighbors and the furthest neighbor distances to distances, one could call

// Initialize optional parameters for ApproxKfn().
param := mlpack.ApproxKfnOptions()
param.Query = query_set
param.Reference = reference_set
param.K = 5
param.Algorithm = "ds"

distances, neighbors, _ := mlpack.ApproxKfn(param)

and to perform approximate all-furthest-neighbors search with k=1 on the set data storing only the furthest neighbor distances to distances, one could call

// Initialize optional parameters for ApproxKfn().
param := mlpack.ApproxKfnOptions()
param.Reference = reference_set
param.K = 1

distances, _, _ := mlpack.ApproxKfn(param)

A trained model can be re-used. If a model has been previously saved to model, then we may find 3 approximate furthest neighbors on a query set new_query_set using that model and store the furthest neighbor indices into neighbors by calling

// Initialize optional parameters for ApproxKfn().
param := mlpack.ApproxKfnOptions()
param.InputModel = &model
param.Query = new_query_set
param.K = 3

_, neighbors, _ := mlpack.ApproxKfn(param)

🔗 See also

• k-furthest-neighbor search
• k-nearest-neighbor search
• Fast approximate furthest neighbors with data-dependent candidate selection (pdf)
• Approximate furthest neighbor in high dimensions (pdf)
• QDAFN class documentation
• DrusillaSelect class documentation

🔗 BayesianLinearRegression()

BayesianLinearRegression

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for BayesianLinearRegression().
param := mlpack.BayesianLinearRegressionOptions()
param.Center = false
param.Input = mat.NewDense(1, 1, nil)
param.InputModel = nil
param.Responses = mat.NewDense(1, 1, nil)
param.Scale = false
param.Test = mat.NewDense(1, 1, nil)
param.Verbose = false

output_model, predictions, stds := mlpack.BayesianLinearRegression(param)

An implementation of the bayesian linear regression. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

An implementation of the bayesian linear regression. This model is a probabilistic view and implementation of the linear regression. The final solution is obtained by computing a posterior distribution from gaussian likelihood and a zero mean gaussian isotropic prior distribution on the solution. Optimization is AUTOMATIC and does not require cross validation. The optimization is performed by maximization of the evidence function. Parameters are tuned during the maximization of the marginal likelihood. This procedure includes the Ockham’s razor that penalizes over complex solutions.

This program is able to train a Bayesian linear regression model or load a model from file, output regression predictions for a test set, and save the trained model to a file.

To train a BayesianLinearRegression model, the Input and Responsesparameters must be given. The Centerand Scale parameters control the centering and the normalizing options. A trained model can be saved with the OutputModel. If no training is desired at all, a model can be passed via the InputModel parameter.

The program can also provide predictions for test data using either the trained model or the given input model. Test points can be specified with the Test parameter. Predicted responses to the test points can be saved with the Predictions output parameter. The corresponding standard deviation can be save by precising the Stds parameter.

🔗 Example

For example, the following command trains a model on the data data and responses responseswith center set to true and scale set to false (so, Bayesian linear regression is being solved, and then the model is saved to blr_model:

// Initialize optional parameters for BayesianLinearRegression().
param := mlpack.BayesianLinearRegressionOptions()
param.Input = data
param.Responses = responses
param.Center = 1
param.Scale = 0

blr_model, _, _ := mlpack.BayesianLinearRegression(param)

The following command uses the blr_model to provide predicted responses for the data test and save those responses to test_predictions:

// Initialize optional parameters for BayesianLinearRegression().
param := mlpack.BayesianLinearRegressionOptions()
param.InputModel = &blr_model
param.Test = test

_, test_predictions, _ := mlpack.BayesianLinearRegression(param)

Because the estimator computes a predictive distribution instead of a simple point estimate, the Stds parameter allows one to save the prediction uncertainties:

// Initialize optional parameters for BayesianLinearRegression().
param := mlpack.BayesianLinearRegressionOptions()
param.InputModel = &blr_model
param.Test = test

_, test_predictions, stds := mlpack.BayesianLinearRegression(param)

🔗 See also

• Bayesian Interpolation
• Bayesian Linear Regression, Section 3.3
• BayesianLinearRegression C++ class documentation

🔗 Cf()

Collaborative Filtering

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for Cf().
param := mlpack.CfOptions()
param.Algorithm = "NMF"
param.AllUserRecommendations = false
param.InputModel = nil
param.Interpolation = "average"
param.IterationOnlyTermination = false
param.MaxIterations = 1000
param.MinResidue = 1e-05
param.NeighborSearch = "euclidean"
param.Neighborhood = 5
param.Normalization = "none"
param.Query = mat.NewDense(1, 1, nil)
param.Rank = 0
param.Recommendations = 5
param.Seed = 0
param.Test = mat.NewDense(1, 1, nil)
param.Training = mat.NewDense(1, 1, nil)
param.Verbose = false

output, output_model := mlpack.Cf(param)

An implementation of several collaborative filtering (CF) techniques for recommender systems. This can be used to train a new CF model, or use an existing CF model to compute recommendations. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program performs collaborative filtering (CF) on the given dataset. Given a list of user, item and preferences (the Training parameter), the program will perform a matrix decomposition and then can perform a series of actions related to collaborative filtering. Alternately, the program can load an existing saved CF model with the InputModel parameter and then use that model to provide recommendations or predict values.

The input matrix should be a 3-dimensional matrix of ratings, where the first dimension is the user, the second dimension is the item, and the third dimension is that user’s rating of that item. Both the users and items should be numeric indices, not names. The indices are assumed to start from 0.

A set of query users for which recommendations can be generated may be specified with the Query parameter; alternately, recommendations may be generated for every user in the dataset by specifying the AllUserRecommendations parameter. In addition, the number of recommendations per user to generate can be specified with the Recommendations parameter, and the number of similar users (the size of the neighborhood) to be considered when generating recommendations can be specified with the Neighborhood parameter.

For performing the matrix decomposition, the following optimization algorithms can be specified via the Algorithm parameter:

• ‘RegSVD’ – Regularized SVD using a SGD optimizer
• ‘NMF’ – Non-negative matrix factorization with alternating least squares update rules
• ‘BatchSVD’ – SVD batch learning
• ‘SVDIncompleteIncremental’ – SVD incomplete incremental learning
• ‘SVDCompleteIncremental’ – SVD complete incremental learning
• ‘BiasSVD’ – Bias SVD using a SGD optimizer
• ‘SVDPP’ – SVD++ using a SGD optimizer
• ‘RandSVD’ – RandomizedSVD learning
• ‘QSVD’ – QuicSVD learning
• ‘BKSVD’ – Block Krylov SVD learning

The following neighbor search algorithms can be specified via the NeighborSearch parameter:

• ‘cosine’ – Cosine Search Algorithm
• ‘euclidean’ – Euclidean Search Algorithm
• ‘pearson’ – Pearson Search Algorithm

The following weight interpolation algorithms can be specified via the Interpolation parameter:

• ‘average’ – Average Interpolation Algorithm
• ‘regression’ – Regression Interpolation Algorithm
• ‘similarity’ – Similarity Interpolation Algorithm

The following ranking normalization algorithms can be specified via the Normalization parameter:

• ‘none’ – No Normalization
• ‘item_mean’ – Item Mean Normalization
• ‘overall_mean’ – Overall Mean Normalization
• ‘user_mean’ – User Mean Normalization
• ‘z_score’ – Z-Score Normalization

A trained model may be saved to with the OutputModel output parameter.

🔗 Example

To train a CF model on a dataset training_set using NMF for decomposition and saving the trained model to model, one could call:

// Initialize optional parameters for Cf().
param := mlpack.CfOptions()
param.Training = training_set
param.Algorithm = "NMF"

_, model := mlpack.Cf(param)

Then, to use this model to generate recommendations for the list of users in the query set users, storing 5 recommendations in recommendations, one could call

// Initialize optional parameters for Cf().
param := mlpack.CfOptions()
param.InputModel = &model
param.Query = users
param.Recommendations = 5

recommendations, _ := mlpack.Cf(param)

🔗 See also

• Collaborative Filtering on Wikipedia
• Matrix factorization on Wikipedia
• Matrix factorization techniques for recommender systems (pdf)
• CFType class documentation

🔗 Dbscan()

DBSCAN clustering

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for Dbscan().
param := mlpack.DbscanOptions()
param.Epsilon = 1
param.MinSize = 5
param.Naive = false
param.SelectionType = "ordered"
param.SingleMode = false
param.TreeType = "kd"
param.Verbose = false

assignments, centroids := mlpack.Dbscan(input, param)

An implementation of DBSCAN clustering. Given a dataset, this can compute and return a clustering of that dataset. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program implements the DBSCAN algorithm for clustering using accelerated tree-based range search. The type of tree that is used may be parameterized, or brute-force range search may also be used.

The input dataset to be clustered may be specified with the Input parameter; the radius of each range search may be specified with the Epsilon parameters, and the minimum number of points in a cluster may be specified with the MinSize parameter.

The Assignments and Centroids output parameters may be used to save the output of the clustering. Assignments contains the cluster assignments of each point, and Centroids contains the centroids of each cluster.

The range search may be controlled with the TreeType, SingleMode, and Naive parameters. TreeType can control the type of tree used for range search; this can take a variety of values: ‘kd’, ‘r’, ‘r-star’, ‘x’, ‘hilbert-r’, ‘r-plus’, ‘r-plus-plus’, ‘cover’, ‘ball’. The SingleMode parameter will force single-tree search (as opposed to the default dual-tree search), and ‘Naive will force brute-force range search.

🔗 Example

An example usage to run DBSCAN on the dataset in input with a radius of 0.5 and a minimum cluster size of 5 is given below:

// Initialize optional parameters for Dbscan().
param := mlpack.DbscanOptions()
param.Epsilon = 0.5
param.MinSize = 5

_, _ := mlpack.Dbscan(input, param)

🔗 See also

• DBSCAN on Wikipedia
• A density-based algorithm for discovering clusters in large spatial databases with noise (pdf)
• DBSCAN class documentation

🔗 DecisionTree()

Decision tree

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for DecisionTree().
param := mlpack.DecisionTreeOptions()
param.InputModel = nil
param.Labels = mat.NewDense(1, 1, nil)
param.MaximumDepth = 0
param.MinimumGainSplit = 1e-07
param.MinimumLeafSize = 20
param.PrintTrainingAccuracy = false
param.Test = mat.NewDense(1, 1, nil)
param.TestLabels = mat.NewDense(1, 1, nil)
param.Training = mat.NewDense(1, 1, nil)
param.Verbose = false
param.Weights = mat.NewDense(1, 1, nil)

output_model, predictions, probabilities := mlpack.DecisionTree(param)

An implementation of an ID3-style decision tree for classification, which supports categorical data. Given labeled data with numeric or categorical features, a decision tree can be trained and saved; or, an existing decision tree can be used for classification on new points. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

Train and evaluate using a decision tree. Given a dataset containing numeric or categorical features, and associated labels for each point in the dataset, this program can train a decision tree on that data.

The training set and associated labels are specified with the Training and Labels parameters, respectively. The labels should be in the range [0, num_classes - 1]. Optionally, if Labels is not specified, the labels are assumed to be the last dimension of the training dataset.

When a model is trained, the OutputModel output parameter may be used to save the trained model. A model may be loaded for predictions with the InputModel parameter. The InputModel parameter may not be specified when the Training parameter is specified. The MinimumLeafSize parameter specifies the minimum number of training points that must fall into each leaf for it to be split. The MinimumGainSplit parameter specifies the minimum gain that is needed for the node to split. The MaximumDepth parameter specifies the maximum depth of the tree. If PrintTrainingAccuracy is specified, the training accuracy will be printed.

Test data may be specified with the Test parameter, and if performance numbers are desired for that test set, labels may be specified with the TestLabels parameter. Predictions for each test point may be saved via the Predictions output parameter. Class probabilities for each prediction may be saved with the Probabilities output parameter.

🔗 Example

For example, to train a decision tree with a minimum leaf size of 20 on the dataset contained in data with labels labels, saving the output model to tree and printing the training error, one could call

// Initialize optional parameters for DecisionTree().
param := mlpack.DecisionTreeOptions()
param.Training = data
param.Labels = labels
param.MinimumLeafSize = 20
param.MinimumGainSplit = 0.001
param.PrintTrainingAccuracy = true

tree, _, _ := mlpack.DecisionTree(param)

Then, to use that model to classify points in test_set and print the test error given the labels test_labels using that model, while saving the predictions for each point to predictions, one could call

// Initialize optional parameters for DecisionTree().
param := mlpack.DecisionTreeOptions()
param.InputModel = &tree
param.Test = test_set
param.TestLabels = test_labels

_, predictions, _ := mlpack.DecisionTree(param)

🔗 See also

• Random forest
• Decision trees on Wikipedia
• Induction of Decision Trees (pdf)
• DecisionTree C++ class documentation

🔗 Det()

Density Estimation With Density Estimation Trees

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for Det().
param := mlpack.DetOptions()
param.Folds = 10
param.InputModel = nil
param.MaxLeafSize = 10
param.MinLeafSize = 5
param.PathFormat = "lr"
param.SkipPruning = false
param.Test = mat.NewDense(1, 1, nil)
param.Training = mat.NewDense(1, 1, nil)
param.Verbose = false

output_model, tag_counters_file, tag_file, test_set_estimates,
    training_set_estimates, vi := mlpack.Det(param)

An implementation of density estimation trees for the density estimation task. Density estimation trees can be trained or used to predict the density at locations given by query points. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program performs a number of functions related to Density Estimation Trees. The optimal Density Estimation Tree (DET) can be trained on a set of data (specified by Training) using cross-validation (with number of folds specified with the Folds parameter). This trained density estimation tree may then be saved with the OutputModel output parameter.

The variable importances (that is, the feature importance values for each dimension) may be saved with the Vi output parameter, and the density estimates for each training point may be saved with the TrainingSetEstimates output parameter.

Enabling path printing for each node outputs the path from the root node to a leaf for each entry in the test set, or training set (if a test set is not provided). Strings like ‘LRLRLR’ (indicating that traversal went to the left child, then the right child, then the left child, and so forth) will be output. If ‘lr-id’ or ‘id-lr’ are given as the PathFormat parameter, then the ID (tag) of every node along the path will be printed after or before the L or R character indicating the direction of traversal, respectively.

This program also can provide density estimates for a set of test points, specified in the Test parameter. The density estimation tree used for this task will be the tree that was trained on the given training points, or a tree given as the parameter InputModel. The density estimates for the test points may be saved using the TestSetEstimates output parameter.

🔗 See also

• Density estimation on Wikipedia
• Density estimation trees (pdf)
• DTree class documentation

🔗 Emst()

Fast Euclidean Minimum Spanning Tree

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for Emst().
param := mlpack.EmstOptions()
param.LeafSize = 1
param.Naive = false
param.Verbose = false

output := mlpack.Emst(input, param)

An implementation of the Dual-Tree Boruvka algorithm for computing the Euclidean minimum spanning tree of a set of input points. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program can compute the Euclidean minimum spanning tree of a set of input points using the dual-tree Boruvka algorithm.

The set to calculate the minimum spanning tree of is specified with the Input parameter, and the output may be saved with the Output output parameter.

The LeafSize parameter controls the leaf size of the kd-tree that is used to calculate the minimum spanning tree, and if the Naive option is given, then brute-force search is used (this is typically much slower in low dimensions). The leaf size does not affect the results, but it may have some effect on the runtime of the algorithm.

🔗 Example

For example, the minimum spanning tree of the input dataset data can be calculated with a leaf size of 20 and stored as spanning_tree using the following command:

// Initialize optional parameters for Emst().
param := mlpack.EmstOptions()
param.LeafSize = 20

spanning_tree := mlpack.Emst(data, param)

The output matrix is a three-dimensional matrix, where each row indicates an edge. The first dimension corresponds to the lesser index of the edge; the second dimension corresponds to the greater index of the edge; and the third column corresponds to the distance between the two points.

🔗 See also

• Minimum spanning tree on Wikipedia
• Fast Euclidean Minimum Spanning Tree: Algorithm, Analysis, and Applications (pdf)
• DualTreeBoruvka class documentation

🔗 Fastmks()

FastMKS (Fast Max-Kernel Search)

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for Fastmks().
param := mlpack.FastmksOptions()
param.Bandwidth = 1
param.Base = 2
param.Degree = 2
param.InputModel = nil
param.K = 0
param.Kernel = "linear"
param.Naive = false
param.Offset = 0
param.Query = mat.NewDense(1, 1, nil)
param.Reference = mat.NewDense(1, 1, nil)
param.Scale = 1
param.Single = false
param.Verbose = false

indices, kernels, output_model := mlpack.Fastmks(param)

An implementation of the single-tree and dual-tree fast max-kernel search (FastMKS) algorithm. Given a set of reference points and a set of query points, this can find the reference point with maximum kernel value for each query point; trained models can be reused for future queries. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program will find the k maximum kernels of a set of points, using a query set and a reference set (which can optionally be the same set). More specifically, for each point in the query set, the k points in the reference set with maximum kernel evaluations are found. The kernel function used is specified with the Kernel parameter.

🔗 Example

For example, the following command will calculate, for each point in the query set query, the five points in the reference set reference with maximum kernel evaluation using the linear kernel. The kernel evaluations may be saved with the kernels output parameter and the indices may be saved with the indices output parameter.

// Initialize optional parameters for Fastmks().
param := mlpack.FastmksOptions()
param.K = 5
param.Reference = reference
param.Query = query
param.Kernel = "linear"

indices, kernels, _ := mlpack.Fastmks(param)

The output matrices are organized such that row i and column j in the indices matrix corresponds to the index of the point in the reference set that has j’th largest kernel evaluation with the point in the query set with index i. Row i and column j in the kernels matrix corresponds to the kernel evaluation between those two points.

This program performs FastMKS using a cover tree. The base used to build the cover tree can be specified with the Base parameter.

🔗 See also

• k-nearest-neighbor search
• Dual-tree Fast Exact Max-Kernel Search (pdf)
• FastMKS class documentation

🔗 GmmTrain()

Gaussian Mixture Model (GMM) Training

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for GmmTrain().
param := mlpack.GmmTrainOptions()
param.DiagonalCovariance = false
param.InputModel = nil
param.KmeansMaxIterations = 1000
param.MaxIterations = 250
param.NoForcePositive = false
param.Noise = 0
param.Percentage = 0.02
param.RefinedStart = false
param.Samplings = 100
param.Seed = 0
param.Tolerance = 1e-10
param.Trials = 1
param.Verbose = false

output_model := mlpack.GmmTrain(gaussians, input, param)

An implementation of the EM algorithm for training Gaussian mixture models (GMMs). Given a dataset, this can train a GMM for future use with other tools. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program takes a parametric estimate of a Gaussian mixture model (GMM) using the EM algorithm to find the maximum likelihood estimate. The model may be saved and reused by other mlpack GMM tools.

The input data to train on must be specified with the Input parameter, and the number of Gaussians in the model must be specified with the Gaussians parameter. Optionally, many trials with different random initializations may be run, and the result with highest log-likelihood on the training data will be taken. The number of trials to run is specified with the Trials parameter. By default, only one trial is run.

The tolerance for convergence and maximum number of iterations of the EM algorithm are specified with the Tolerance and MaxIterations parameters, respectively. The GMM may be initialized for training with another model, specified with the InputModel parameter. Otherwise, the model is initialized by running k-means on the data. The k-means clustering initialization can be controlled with the KmeansMaxIterations, RefinedStart, Samplings, and Percentage parameters. If RefinedStart is specified, then the Bradley-Fayyad refined start initialization will be used. This can often lead to better clustering results.

The ‘diagonal_covariance’ flag will cause the learned covariances to be diagonal matrices. This significantly simplifies the model itself and causes training to be faster, but restricts the ability to fit more complex GMMs.

If GMM training fails with an error indicating that a covariance matrix could not be inverted, make sure that the NoForcePositive parameter is not specified. Alternately, adding a small amount of Gaussian noise (using the Noise parameter) to the entire dataset may help prevent Gaussians with zero variance in a particular dimension, which is usually the cause of non-invertible covariance matrices.

The NoForcePositive parameter, if set, will avoid the checks after each iteration of the EM algorithm which ensure that the covariance matrices are positive definite. Specifying the flag can cause faster runtime, but may also cause non-positive definite covariance matrices, which will cause the program to crash.

🔗 Example

As an example, to train a 6-Gaussian GMM on the data in data with a maximum of 100 iterations of EM and 3 trials, saving the trained GMM to gmm, the following command can be used:

// Initialize optional parameters for GmmTrain().
param := mlpack.GmmTrainOptions()
param.Trials = 3

gmm := mlpack.GmmTrain(data, 6, param)

To re-train that GMM on another set of data data2, the following command may be used:

// Initialize optional parameters for GmmTrain().
param := mlpack.GmmTrainOptions()
param.InputModel = &gmm

new_gmm := mlpack.GmmTrain(data2, 6, param)

🔗 See also

• GmmGenerate()
• GmmProbability()
• Gaussian Mixture Models on Wikipedia
• GMM class documentation

🔗 GmmGenerate()

GMM Sample Generator

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for GmmGenerate().
param := mlpack.GmmGenerateOptions()
param.Seed = 0
param.Verbose = false

output := mlpack.GmmGenerate(inputModel, samples, param)

A sample generator for pre-trained GMMs. Given a pre-trained GMM, this can sample new points randomly from that distribution. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program is able to generate samples from a pre-trained GMM (use gmm_train to train a GMM). The pre-trained GMM must be specified with the InputModel parameter. The number of samples to generate is specified by the Samples parameter. Output samples may be saved with the Output output parameter.

🔗 Example

The following command can be used to generate 100 samples from the pre-trained GMM gmm and store those generated samples in samples:

// Initialize optional parameters for GmmGenerate().
param := mlpack.GmmGenerateOptions()

samples := mlpack.GmmGenerate(&gmm, 100, param)

🔗 See also

• GmmTrain()
• GmmProbability()
• Gaussian Mixture Models on Wikipedia
• GMM class documentation

🔗 GmmProbability()

GMM Probability Calculator

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for GmmProbability().
param := mlpack.GmmProbabilityOptions()
param.Verbose = false

output := mlpack.GmmProbability(input, inputModel, param)

A probability calculator for GMMs. Given a pre-trained GMM and a set of points, this can compute the probability that each point is from the given GMM. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program calculates the probability that given points came from a given GMM (that is, P(X | gmm)). The GMM is specified with the InputModel parameter, and the points are specified with the Input parameter. The output probabilities may be saved via the Output output parameter.

🔗 Example

So, for example, to calculate the probabilities of each point in points coming from the pre-trained GMM gmm, while storing those probabilities in probs, the following command could be used:

// Initialize optional parameters for GmmProbability().
param := mlpack.GmmProbabilityOptions()

probs := mlpack.GmmProbability(&gmm, points, param)

🔗 See also

• GmmTrain()
• GmmGenerate()
• Gaussian Mixture Models on Wikipedia
• GMM class documentation

🔗 HmmTrain()

Hidden Markov Model (HMM) Training

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for HmmTrain().
param := mlpack.HmmTrainOptions()
param.Batch = false
param.Gaussians = 0
param.InputModel = nil
param.LabelsFile = ""
param.Seed = 0
param.States = 0
param.Tolerance = 1e-05
param.Type = "gaussian"
param.Verbose = false

output_model := mlpack.HmmTrain(inputFile, param)

An implementation of training algorithms for Hidden Markov Models (HMMs). Given labeled or unlabeled data, an HMM can be trained for further use with other mlpack HMM tools. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program allows a Hidden Markov Model to be trained on labeled or unlabeled data. It supports four types of HMMs: Discrete HMMs, Gaussian HMMs, GMM HMMs, or Diagonal GMM HMMs

Either one input sequence can be specified (with InputFile), or, a file containing files in which input sequences can be found (when InputFileandBatch are used together). In addition, labels can be provided in the file specified by LabelsFile, and if Batch is used, the file given to LabelsFile should contain a list of files of labels corresponding to the sequences in the file given to InputFile.

The HMM is trained with the Baum-Welch algorithm if no labels are provided. The tolerance of the Baum-Welch algorithm can be set with the Toleranceoption. By default, the transition matrix is randomly initialized and the emission distributions are initialized to fit the extent of the data.

Optionally, a pre-created HMM model can be used as a guess for the transition matrix and emission probabilities; this is specifiable with OutputModel.

🔗 See also

• HmmGenerate()
• HmmLoglik()
• HmmViterbi()
• Hidden Mixture Models on Wikipedia
• HMM class documentation

🔗 HmmGenerate()

Hidden Markov Model (HMM) Sequence Generator

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for HmmGenerate().
param := mlpack.HmmGenerateOptions()
param.Seed = 0
param.StartState = 0
param.Verbose = false

output, state := mlpack.HmmGenerate(length, model, param)

A utility to generate random sequences from a pre-trained Hidden Markov Model (HMM). The length of the desired sequence can be specified, and a random sequence of observations is returned. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This utility takes an already-trained HMM, specified as the Model parameter, and generates a random observation sequence and hidden state sequence based on its parameters. The observation sequence may be saved with the Output output parameter, and the internal state sequence may be saved with the State output parameter.

The state to start the sequence in may be specified with the StartState parameter.

🔗 Example

For example, to generate a sequence of length 150 from the HMM hmm and save the observation sequence to observations and the hidden state sequence to states, the following command may be used:

// Initialize optional parameters for HmmGenerate().
param := mlpack.HmmGenerateOptions()

observations, states := mlpack.HmmGenerate(&hmm, 150, param)

🔗 See also

• HmmTrain()
• HmmLoglik()
• HmmViterbi()
• Hidden Mixture Models on Wikipedia
• HMM class documentation

🔗 HmmLoglik()

Hidden Markov Model (HMM) Sequence Log-Likelihood

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for HmmLoglik().
param := mlpack.HmmLoglikOptions()
param.Verbose = false

log_likelihood := mlpack.HmmLoglik(input, inputModel, param)

A utility for computing the log-likelihood of a sequence for Hidden Markov Models (HMMs). Given a pre-trained HMM and an observation sequence, this computes and returns the log-likelihood of that sequence being observed from that HMM. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This utility takes an already-trained HMM, specified with the InputModel parameter, and evaluates the log-likelihood of a sequence of observations, given with the Input parameter. The computed log-likelihood is given as output.

🔗 Example

For example, to compute the log-likelihood of the sequence seq with the pre-trained HMM hmm, the following command may be used:

// Initialize optional parameters for HmmLoglik().
param := mlpack.HmmLoglikOptions()

_ := mlpack.HmmLoglik(seq, &hmm, param)

🔗 See also

• HmmTrain()
• HmmGenerate()
• HmmViterbi()
• Hidden Mixture Models on Wikipedia
• HMM class documentation

🔗 HmmViterbi()

Hidden Markov Model (HMM) Viterbi State Prediction

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for HmmViterbi().
param := mlpack.HmmViterbiOptions()
param.Verbose = false

output := mlpack.HmmViterbi(input, inputModel, param)

A utility for computing the most probable hidden state sequence for Hidden Markov Models (HMMs). Given a pre-trained HMM and an observed sequence, this uses the Viterbi algorithm to compute and return the most probable hidden state sequence. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This utility takes an already-trained HMM, specified as InputModel, and evaluates the most probable hidden state sequence of a given sequence of observations (specified as ‘Input, using the Viterbi algorithm. The computed state sequence may be saved using the Output output parameter.

🔗 Example

For example, to predict the state sequence of the observations obs using the HMM hmm, storing the predicted state sequence to states, the following command could be used:

// Initialize optional parameters for HmmViterbi().
param := mlpack.HmmViterbiOptions()

states := mlpack.HmmViterbi(obs, &hmm, param)

🔗 See also

• HmmTrain()
• HmmGenerate()
• HmmLoglik()
• Hidden Mixture Models on Wikipedia
• HMM class documentation

🔗 HoeffdingTree()

Hoeffding trees

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for HoeffdingTree().
param := mlpack.HoeffdingTreeOptions()
param.BatchMode = false
param.Bins = 10
param.Confidence = 0.95
param.InfoGain = false
param.InputModel = nil
param.Labels = mat.NewDense(1, 1, nil)
param.MaxSamples = 5000
param.MinSamples = 100
param.NumericSplitStrategy = "binary"
param.ObservationsBeforeBinning = 100
param.Passes = 1
param.Test = mat.NewDense(1, 1, nil)
param.TestLabels = mat.NewDense(1, 1, nil)
param.Training = mat.NewDense(1, 1, nil)
param.Verbose = false

output_model, predictions, probabilities := mlpack.HoeffdingTree(param)

An implementation of Hoeffding trees, a form of streaming decision tree for classification. Given labeled data, a Hoeffding tree can be trained and saved for later use, or a pre-trained Hoeffding tree can be used for predicting the classifications of new points. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program implements Hoeffding trees, a form of streaming decision tree suited best for large (or streaming) datasets. This program supports both categorical and numeric data. Given an input dataset, this program is able to train the tree with numerous training options, and save the model to a file. The program is also able to use a trained model or a model from file in order to predict classes for a given test set.

The training file and associated labels are specified with the Training and Labels parameters, respectively. Optionally, if Labels is not specified, the labels are assumed to be the last dimension of the training dataset.

The training may be performed in batch mode (like a typical decision tree algorithm) by specifying the BatchMode option, but this may not be the best option for large datasets.

When a model is trained, it may be saved via the OutputModel output parameter. A model may be loaded from file for further training or testing with the InputModel parameter.

Test data may be specified with the Test parameter, and if performance statistics are desired for that test set, labels may be specified with the TestLabels parameter. Predictions for each test point may be saved with the Predictions output parameter, and class probabilities for each prediction may be saved with the Probabilities output parameter.

🔗 Example

For example, to train a Hoeffding tree with confidence 0.99 with data dataset, saving the trained tree to tree, the following command may be used:

// Initialize optional parameters for HoeffdingTree().
param := mlpack.HoeffdingTreeOptions()
param.Training = dataset
param.Confidence = 0.99

tree, _, _ := mlpack.HoeffdingTree(param)

Then, this tree may be used to make predictions on the test set test_set, saving the predictions into predictions and the class probabilities into class_probs with the following command:

// Initialize optional parameters for HoeffdingTree().
param := mlpack.HoeffdingTreeOptions()
param.InputModel = &tree
param.Test = test_set

_, predictions, class_probs := mlpack.HoeffdingTree(param)

🔗 See also

• DecisionTree()
• RandomForest()
• Mining High-Speed Data Streams (pdf)
• HoeffdingTree class documentation

🔗 Kde()

Kernel Density Estimation

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for Kde().
param := mlpack.KdeOptions()
param.AbsError = 0
param.Algorithm = "dual-tree"
param.Bandwidth = 1
param.InitialSampleSize = 100
param.InputModel = nil
param.Kernel = "gaussian"
param.McBreakCoef = 0.4
param.McEntryCoef = 3
param.McProbability = 0.95
param.MonteCarlo = false
param.Query = mat.NewDense(1, 1, nil)
param.Reference = mat.NewDense(1, 1, nil)
param.RelError = 0.05
param.Tree = "kd-tree"
param.Verbose = false

output_model, predictions := mlpack.Kde(param)

An implementation of kernel density estimation with dual-tree algorithms. Given a set of reference points and query points and a kernel function, this can estimate the density function at the location of each query point using trees; trees that are built can be saved for later use. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program performs a Kernel Density Estimation. KDE is a non-parametric way of estimating probability density function. For each query point the program will estimate its probability density by applying a kernel function to each reference point. The computational complexity of this is O(N^2) where there are N query points and N reference points, but this implementation will typically see better performance as it uses an approximate dual or single tree algorithm for acceleration.

Dual or single tree optimization avoids many barely relevant calculations (as kernel function values decrease with distance), so it is an approximate computation. You can specify the maximum relative error tolerance for each query value with RelError as well as the maximum absolute error tolerance with the parameter AbsError. This program runs using an Euclidean metric. Kernel function can be selected using the Kernel option. You can also choose what which type of tree to use for the dual-tree algorithm with Tree. It is also possible to select whether to use dual-tree algorithm or single-tree algorithm using the Algorithm option.

Monte Carlo estimations can be used to accelerate the KDE estimate when the Gaussian Kernel is used. This provides a probabilistic guarantee on the the error of the resulting KDE instead of an absolute guarantee.To enable Monte Carlo estimations, the MonteCarlo flag can be used, and success probability can be set with the McProbability option. It is possible to set the initial sample size for the Monte Carlo estimation using InitialSampleSize. This implementation will only consider a node, as a candidate for the Monte Carlo estimation, if its number of descendant nodes is bigger than the initial sample size. This can be controlled using a coefficient that will multiply the initial sample size and can be set using McEntryCoef. To avoid using the same amount of computations an exact approach would take, this program recurses the tree whenever a fraction of the amount of the node’s descendant points have already been computed. This fraction is set using McBreakCoef.

🔗 Example

For example, the following will run KDE using the data in ref_data for training and the data in qu_data as query data. It will apply an Epanechnikov kernel with a 0.2 bandwidth to each reference point and use a KD-Tree for the dual-tree optimization. The returned predictions will be within 5% of the real KDE value for each query point.

// Initialize optional parameters for Kde().
param := mlpack.KdeOptions()
param.Reference = ref_data
param.Query = qu_data
param.Bandwidth = 0.2
param.Kernel = "epanechnikov"
param.Tree = "kd-tree"
param.RelError = 0.05

_, out_data := mlpack.Kde(param)

the predicted density estimations will be stored in out_data. If no Query is provided, then KDE will be computed on the Reference dataset. It is possible to select either a reference dataset or an input model but not both at the same time. If an input model is selected and parameter values are not set (e.g. Bandwidth) then default parameter values will be used.

In addition to the last program call, it is also possible to activate Monte Carlo estimations if a Gaussian kernel is used. This can provide faster results, but the KDE will only have a probabilistic guarantee of meeting the desired error bound (instead of an absolute guarantee). The following example will run KDE using a Monte Carlo estimation when possible. The results will be within a 5% of the real KDE value with a 95% probability. Initial sample size for the Monte Carlo estimation will be 200 points and a node will be a candidate for the estimation only when it contains 700 (i.e. 3.5200) points. If a node contains 700 points and 420 (i.e. 0.6700) have already been sampled, then the algorithm will recurse instead of keep sampling.

// Initialize optional parameters for Kde().
param := mlpack.KdeOptions()
param.Reference = ref_data
param.Query = qu_data
param.Bandwidth = 0.2
param.Kernel = "gaussian"
param.Tree = "kd-tree"
param.RelError = 0.05
param.MonteCarlo = 
param.McProbability = 0.95
param.InitialSampleSize = 200
param.McEntryCoef = 3.5
param.McBreakCoef = 0.6

_, out_data := mlpack.Kde(param)

🔗 See also

• Knn()
• Kernel density estimation on Wikipedia
• Tree-Independent Dual-Tree Algorithms
• Fast High-dimensional Kernel Summations Using the Monte Carlo Multipole Method
• KDE C++ class documentation

🔗 KernelPca()

Kernel Principal Components Analysis

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for KernelPca().
param := mlpack.KernelPcaOptions()
param.Bandwidth = 1
param.Center = false
param.Degree = 1
param.KernelScale = 1
param.NewDimensionality = 0
param.NystroemMethod = false
param.Offset = 0
param.Sampling = "kmeans"
param.Verbose = false

output := mlpack.KernelPca(input, kernel, param)

An implementation of Kernel Principal Components Analysis (KPCA). This can be used to perform nonlinear dimensionality reduction or preprocessing on a given dataset. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program performs Kernel Principal Components Analysis (KPCA) on the specified dataset with the specified kernel. This will transform the data onto the kernel principal components, and optionally reduce the dimensionality by ignoring the kernel principal components with the smallest eigenvalues.

For the case where a linear kernel is used, this reduces to regular PCA.

The kernels that are supported are listed below:

• ‘linear’: the standard linear dot product (same as normal PCA): K(x, y) = x^T y

• ‘gaussian’: a Gaussian kernel; requires bandwidth: K(x, y) = exp(-(\|\| x - y \|\| ^ 2) / (2 * (bandwidth ^ 2)))

• ‘polynomial’: polynomial kernel; requires offset and degree: K(x, y) = (x^T y + offset) ^ degree

• ‘hyptan’: hyperbolic tangent kernel; requires scale and offset: K(x, y) = tanh(scale * (x^T y) + offset)

• ‘laplacian’: Laplacian kernel; requires bandwidth: K(x, y) = exp(-(\|\| x - y \|\|) / bandwidth)

• ‘epanechnikov’: Epanechnikov kernel; requires bandwidth: K(x, y) = max(0, 1 - \|\| x - y \|\|^2 / bandwidth^2)

• ‘cosine’: cosine distance: K(x, y) = 1 - (x^T y) / (\|\| x \|\| * \|\| y \|\|)

The parameters for each of the kernels should be specified with the options Bandwidth, KernelScale, Offset, or Degree (or a combination of those parameters).

Optionally, the Nystroem method (“Using the Nystroem method to speed up kernel machines”, 2001) can be used to calculate the kernel matrix by specifying the NystroemMethod parameter. This approach works by using a subset of the data as basis to reconstruct the kernel matrix; to specify the sampling scheme, the Sampling parameter is used. The sampling scheme for the Nystroem method can be chosen from the following list: ‘kmeans’, ‘random’, ‘ordered’.

🔗 Example

For example, the following command will perform KPCA on the dataset input using the Gaussian kernel, and saving the transformed data to transformed:

// Initialize optional parameters for KernelPca().
param := mlpack.KernelPcaOptions()

transformed := mlpack.KernelPca(input, "gaussian", param)

🔗 See also

• Kernel principal component analysis on Wikipedia
• Nonlinear Component Analysis as a Kernel Eigenvalue Problem
• KernelPCA class documentation

🔗 Kmeans()

K-Means Clustering

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for Kmeans().
param := mlpack.KmeansOptions()
param.Algorithm = "naive"
param.AllowEmptyClusters = false
param.InPlace = false
param.InitialCentroids = mat.NewDense(1, 1, nil)
param.KillEmptyClusters = false
param.KmeansPlusPlus = false
param.LabelsOnly = false
param.MaxIterations = 1000
param.Percentage = 0.02
param.RefinedStart = false
param.Samplings = 100
param.Seed = 0
param.Verbose = false

centroid, output := mlpack.Kmeans(clusters, input, param)

An implementation of several strategies for efficient k-means clustering. Given a dataset and a value of k, this computes and returns a k-means clustering on that data. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program performs K-Means clustering on the given dataset. It can return the learned cluster assignments, and the centroids of the clusters. Empty clusters are not allowed by default; when a cluster becomes empty, the point furthest from the centroid of the cluster with maximum variance is taken to fill that cluster.

Optionally, the strategy to choose initial centroids can be specified. The k-means++ algorithm can be used to choose initial centroids with the KmeansPlusPlus parameter. The Bradley and Fayyad approach (“Refining initial points for k-means clustering”, 1998) can be used to select initial points by specifying the RefinedStart parameter. This approach works by taking random samplings of the dataset; to specify the number of samplings, the Samplings parameter is used, and to specify the percentage of the dataset to be used in each sample, the Percentage parameter is used (it should be a value between 0.0 and 1.0).

There are several options available for the algorithm used for each Lloyd iteration, specified with the Algorithm option. The standard O(kN) approach can be used (‘naive’). Other options include the Pelleg-Moore tree-based algorithm (‘pelleg-moore’), Elkan’s triangle-inequality based algorithm (‘elkan’), Hamerly’s modification to Elkan’s algorithm (‘hamerly’), the dual-tree k-means algorithm (‘dualtree’), and the dual-tree k-means algorithm using the cover tree (‘dualtree-covertree’).

The behavior for when an empty cluster is encountered can be modified with the AllowEmptyClusters option. When this option is specified and there is a cluster owning no points at the end of an iteration, that cluster’s centroid will simply remain in its position from the previous iteration. If the KillEmptyClusters option is specified, then when a cluster owns no points at the end of an iteration, the cluster centroid is simply filled with DBL_MAX, killing it and effectively reducing k for the rest of the computation. Note that the default option when neither empty cluster option is specified can be time-consuming to calculate; therefore, specifying either of these parameters will often accelerate runtime.

Initial clustering assignments may be specified using the InitialCentroids parameter, and the maximum number of iterations may be specified with the MaxIterations parameter.

🔗 Example

As an example, to use Hamerly’s algorithm to perform k-means clustering with k=10 on the dataset data, saving the centroids to centroids and the assignments for each point to assignments, the following command could be used:

// Initialize optional parameters for Kmeans().
param := mlpack.KmeansOptions()

centroids, assignments := mlpack.Kmeans(data, 10, param)

To run k-means on that same dataset with initial centroids specified in initial with a maximum of 500 iterations, storing the output centroids in final the following command may be used:

// Initialize optional parameters for Kmeans().
param := mlpack.KmeansOptions()
param.InitialCentroids = initial
param.MaxIterations = 500

final, _ := mlpack.Kmeans(data, 10, param)

🔗 See also

• Dbscan()
• k-means++
• Using the triangle inequality to accelerate k-means (pdf)
• Making k-means even faster (pdf)
• Accelerating exact k-means algorithms with geometric reasoning (pdf)
• A dual-tree algorithm for fast k-means clustering with large k (pdf)
• KMeans class documentation

🔗 Lars()

LARS

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for Lars().
param := mlpack.LarsOptions()
param.Input = mat.NewDense(1, 1, nil)
param.InputModel = nil
param.Lambda1 = 0
param.Lambda2 = 0
param.NoIntercept = false
param.NoNormalize = false
param.Responses = mat.NewDense(1, 1, nil)
param.Test = mat.NewDense(1, 1, nil)
param.UseCholesky = false
param.Verbose = false

output_model, output_predictions := mlpack.Lars(param)

An implementation of Least Angle Regression (Stagewise/laSso), also known as LARS. This can train a LARS/LASSO/Elastic Net model and use that model or a pre-trained model to output regression predictions for a test set. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

An implementation of LARS: Least Angle Regression (Stagewise/laSso). This is a stage-wise homotopy-based algorithm for L1-regularized linear regression (LASSO) and L1+L2-regularized linear regression (Elastic Net).

This program is able to train a LARS/LASSO/Elastic Net model or load a model from file, output regression predictions for a test set, and save the trained model to a file. The LARS algorithm is described in more detail below:

Let X be a matrix where each row is a point and each column is a dimension, and let y be a vector of targets.

The Elastic Net problem is to solve

min_beta 0.5 || X * beta - y ||_2^2 + lambda_1 ||beta||_1 + 0.5 lambda_2 ||beta||_2^2

If lambda1 > 0 and lambda2 = 0, the problem is the LASSO. If lambda1 > 0 and lambda2 > 0, the problem is the Elastic Net. If lambda1 = 0 and lambda2 > 0, the problem is ridge regression. If lambda1 = 0 and lambda2 = 0, the problem is unregularized linear regression.

For efficiency reasons, it is not recommended to use this algorithm with Lambda1 = 0. In that case, use the ‘linear_regression’ program, which implements both unregularized linear regression and ridge regression.

To train a LARS/LASSO/Elastic Net model, the Input and Responses parameters must be given. The Lambda1, Lambda2, and UseCholesky parameters control the training options. A trained model can be saved with the OutputModel. If no training is desired at all, a model can be passed via the InputModel parameter.

The program can also provide predictions for test data using either the trained model or the given input model. Test points can be specified with the Test parameter. Predicted responses to the test points can be saved with the OutputPredictions output parameter.

🔗 Example

For example, the following command trains a model on the data data and responses responses with lambda1 set to 0.4 and lambda2 set to 0 (so, LASSO is being solved), and then the model is saved to lasso_model:

// Initialize optional parameters for Lars().
param := mlpack.LarsOptions()
param.Input = data
param.Responses = responses
param.Lambda1 = 0.4
param.Lambda2 = 0

lasso_model, _ := mlpack.Lars(param)

The following command uses the lasso_model to provide predicted responses for the data test and save those responses to test_predictions:

// Initialize optional parameters for Lars().
param := mlpack.LarsOptions()
param.InputModel = &lasso_model
param.Test = test

_, test_predictions := mlpack.Lars(param)

🔗 See also

• LinearRegression()
• Least angle regression (pdf)
• LARS C++ class documentation

🔗 LinearSvm()

Linear SVM is an L2-regularized support vector machine.

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for LinearSvm().
param := mlpack.LinearSvmOptions()
param.Delta = 1
param.Epochs = 50
param.InputModel = nil
param.Labels = mat.NewDense(1, 1, nil)
param.Lambda = 0.0001
param.MaxIterations = 10000
param.NoIntercept = false
param.NumClasses = 0
param.Optimizer = "lbfgs"
param.Seed = 0
param.Shuffle = false
param.StepSize = 0.01
param.Test = mat.NewDense(1, 1, nil)
param.TestLabels = mat.NewDense(1, 1, nil)
param.Tolerance = 1e-10
param.Training = mat.NewDense(1, 1, nil)
param.Verbose = false

output_model, predictions, probabilities := mlpack.LinearSvm(param)

An implementation of linear SVM for multiclass classification. Given labeled data, a model can be trained and saved for future use; or, a pre-trained model can be used to classify new points. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

An implementation of linear SVMs that uses either L-BFGS or parallel SGD (stochastic gradient descent) to train the model.

This program allows loading a linear SVM model (via the InputModel parameter) or training a linear SVM model given training data (specified with the Training parameter), or both those things at once. In addition, this program allows classification on a test dataset (specified with the Test parameter) and the classification results may be saved with the Predictions output parameter. The trained linear SVM model may be saved using the OutputModel output parameter.

The training data, if specified, may have class labels as its last dimension. Alternately, the Labels parameter may be used to specify a separate vector of labels.

When a model is being trained, there are many options. L2 regularization (to prevent overfitting) can be specified with the Lambda option, and the number of classes can be manually specified with the NumClassesand if an intercept term is not desired in the model, the NoIntercept parameter can be specified.Margin of difference between correct class and other classes can be specified with the Delta option.The optimizer used to train the model can be specified with the Optimizer parameter. Available options are ‘psgd’ (parallel stochastic gradient descent) and ‘lbfgs’ (the L-BFGS optimizer). There are also various parameters for the optimizer; the MaxIterations parameter specifies the maximum number of allowed iterations, and the Tolerance parameter specifies the tolerance for convergence. For the parallel SGD optimizer, the StepSize parameter controls the step size taken at each iteration by the optimizer and the maximum number of epochs (specified with Epochs). If the objective function for your data is oscillating between Inf and 0, the step size is probably too large. There are more parameters for the optimizers, but the C++ interface must be used to access these.

Optionally, the model can be used to predict the labels for another matrix of data points, if Test is specified. The Test parameter can be specified without the Training parameter, so long as an existing linear SVM model is given with the InputModel parameter. The output predictions from the linear SVM model may be saved with the Predictions parameter.

🔗 Example

As an example, to train a LinaerSVM on the data ‘data’ with labels ‘labels’ with L2 regularization of 0.1, saving the model to ‘lsvm_model’, the following command may be used:

// Initialize optional parameters for LinearSvm().
param := mlpack.LinearSvmOptions()
param.Training = data
param.Labels = labels
param.Lambda = 0.1
param.Delta = 1
param.NumClasses = 0

lsvm_model, _, _ := mlpack.LinearSvm(param)

Then, to use that model to predict classes for the dataset ‘test’, storing the output predictions in ‘predictions’, the following command may be used:

// Initialize optional parameters for LinearSvm().
param := mlpack.LinearSvmOptions()
param.InputModel = &lsvm_model
param.Test = test

_, predictions, _ := mlpack.LinearSvm(param)

🔗 See also

• RandomForest()
• LogisticRegression()
• LinearSVM on Wikipedia
• LinearSVM C++ class documentation

🔗 Lmnn()

Large Margin Nearest Neighbors (LMNN)

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for Lmnn().
param := mlpack.LmnnOptions()
param.BatchSize = 50
param.Center = false
param.Distance = mat.NewDense(1, 1, nil)
param.K = 1
param.Labels = mat.NewDense(1, 1, nil)
param.LinearScan = false
param.MaxIterations = 100000
param.Normalize = false
param.Optimizer = "amsgrad"
param.Passes = 50
param.PrintAccuracy = false
param.Rank = 0
param.Regularization = 0.5
param.Seed = 0
param.StepSize = 0.01
param.Tolerance = 1e-07
param.UpdateInterval = 1
param.Verbose = false

centered_data, output, transformed_data := mlpack.Lmnn(input, param)

An implementation of Large Margin Nearest Neighbors (LMNN), a distance learning technique. Given a labeled dataset, this learns a transformation of the data that improves k-nearest-neighbor performance; this can be useful as a preprocessing step. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.

🔗 Detailed documentation

This program implements Large Margin Nearest Neighbors, a distance learning technique. The method seeks to improve k-nearest-neighbor classification on a dataset. The method employes the strategy of reducing distance between similar labeled data points (a.k.a target neighbors) and increasing distance between differently labeled points (a.k.a impostors) using standard optimization techniques over the gradient of the distance between data points.

To work, this algorithm needs labeled data. It can be given as the last row of the input dataset (specified with Input), or alternatively as a separate matrix (specified with Labels). Additionally, a starting point for optimization (specified with Distancecan be given, having (r x d) dimensionality. Here r should satisfy 1 <= r <= d, Consequently a Low-Rank matrix will be optimized. Alternatively, Low-Rank distance can be learned by specifying the Rankparameter (A Low-Rank matrix with uniformly distributed values will be used as initial learning point).

The program also requires number of targets neighbors to work with ( specified with K), A regularization parameter can also be passed, It acts as a trade of between the pulling and pushing terms (specified with Regularization), In addition, this implementation of LMNN includes a parameter to decide the interval after which impostors must be re-calculated (specified with UpdateInterval).

Output can either be the learned distance matrix (specified with Output), or the transformed dataset (specified with TransformedData), or both. Additionally mean-centered dataset (specified with CenteredData) can be accessed given mean-centering (specified with Center) is performed on the dataset. Accuracy on initial dataset and final transformed dataset can be printed by specifying the PrintAccuracyparameter.

This implementation of LMNN uses AdaGrad, BigBatch_SGD, stochastic gradient descent, mini-batch stochastic gradient descent, or the L_BFGS optimizer.

AdaGrad, specified by the value ‘adagrad’ for the parameter Optimizer, uses maximum of past squared gradients. It primarily on six parameters: the step size (specified with StepSize), the batch size (specified with BatchSize), the maximum number of passes (specified with Passes). Inaddition, a normalized starting point can be used by specifying the Normalize parameter.

BigBatch_SGD, specified by the value ‘bbsgd’ for the parameter Optimizer, depends primarily on four parameters: the step size (specified with StepSize), the batch size (specified with BatchSize), the maximum number of passes (specified with Passes). In addition, a normalized starting point can be used by specifying the Normalize parameter.

Stochastic gradient descent, specified by the value ‘sgd’ for the parameter Optimizer, depends primarily on three parameters: the step size (specified with StepSize), the batch size (specified with BatchSize), and the maximum number of passes (specified with Passes). In addition, a normalized starting point can be used by specifying the Normalize parameter. Furthermore, mean-centering can be performed on the dataset by specifying the Centerparameter.

The L-BFGS optimizer, specified by the value ‘lbfgs’ for the parameter Optimizer, uses a back-tracking line search algorithm to minimize a function. The following parameters are used by L-BFGS: MaxIterations, Tolerance(the optimization is terminated when the gradient norm is below this value). For more details on the L-BFGS optimizer, consult either the mlpack L-BFGS documentation (in lbfgs.hpp) or the vast set of published literature on L-BFGS. In addition, a normalized starting point can be used by specifying the Normalize parameter.

By default, the AMSGrad optimizer is used.

🔗 Example

Example - Let’s say we want to learn distance on iris dataset with number of targets as 3 using BigBatch_SGD optimizer. A simple call for the same will look like:

// Initialize optional parameters for Lmnn().
param := mlpack.LmnnOptions()
param.Labels = iris_labels
param.K = 3
param.Optimizer = "bbsgd"

_, output, _ := mlpack.Lmnn(iris, param)

Another program call making use of update interval & regularization parameter with dataset having labels as last column can be made as:

// Initialize optional parameters for Lmnn().
param := mlpack.LmnnOptions()
param.K = 5
param.UpdateInterval = 10
param.Regularization = 0.4

_, output, _ := mlpack.Lmnn(letter_recognition, param)

🔗 See also

• Nca()
• Large margin nearest neighbor on Wikipedia
• Distance metric learning for large margin nearest neighbor classification (pdf)
• LMNN C++ class documentation

🔗 LocalCoordinateCoding()

Local Coordinate Coding

import (
  "mlpack.org/v1/mlpack"
  "gonum.org/v1/gonum/mat"
)

// Initialize optional parameters for LocalCoordinateCoding().
param := mlpack.LocalCoordinateCodingOptions()
param.Atoms = 0
param.InitialDictionary = mat.NewDense(1, 1, nil)
param.InputModel = nil
param.Lambda = 0
param.MaxIterations = 0
param.Normalize = false
param.Seed = 0
param.Test = mat.NewDense(1, 1, nil)
param.Tolerance = 0.01
param.Training = mat.NewDense(1, 1, nil)
param.Verbose = false

codes, dictionary, output_model := mlpack.LocalCoordinateCoding(param)

An implementation of Local Coordinate Coding (LCC), a data transformation technique. Given input data, this transforms each point to be expressed as a linear combination of a few points in the dataset; once an LCC model is trained, it can be used to transform points later also. Detailed documentation.

🔗 Input options

There are two types of input options: required options, which are passed directly to the function call, and optional options, which are passed via an initialized struct, which allows keyword access to each of the options.

🔗 Output options

Output options are returned via Go’s support for multiple return values, in the order listed below.