| Package | Description | 
|---|---|
| gov.sandia.cognition.learning.algorithm | 
 Provides general interfaces for learning algorithms. 
 | 
| gov.sandia.cognition.learning.algorithm.baseline | 
 Provides baseline (dummy) learning algorithms. 
 | 
| gov.sandia.cognition.learning.algorithm.bayes | 
 Provides algorithms for computing Bayesian categorizers. 
 | 
| gov.sandia.cognition.learning.algorithm.confidence | 
 Provides confidence-weighted categorization algorithms. 
 | 
| gov.sandia.cognition.learning.algorithm.delta | 
 Provides an abstract class for helping to implement variants of the Burrows'
 Delta algorithm. 
 | 
| gov.sandia.cognition.learning.algorithm.ensemble | 
 Provides ensemble methods. 
 | 
| gov.sandia.cognition.learning.algorithm.factor.machine | 
 Provides factorization machine algorithms. 
 | 
| gov.sandia.cognition.learning.algorithm.nearest | 
 Provides algorithms for Nearest-Neighbor memory-based functions. 
 | 
| gov.sandia.cognition.learning.algorithm.perceptron | 
 Provides the Perceptron algorithm and some of its variations. 
 | 
| gov.sandia.cognition.learning.algorithm.perceptron.kernel | |
| gov.sandia.cognition.learning.algorithm.regression | 
 Provides regression algorithms, such as Linear Regression. 
 | 
| gov.sandia.cognition.learning.algorithm.svm | 
 Provides implementations of Support Vector Machine (SVM) learning algorithms. 
 | 
| gov.sandia.cognition.learning.algorithm.tree | 
 Provides decision tree learning algorithms. 
 | 
| gov.sandia.cognition.learning.function.categorization | 
 Provides functions that output a discrete set of categories. 
 | 
| gov.sandia.cognition.learning.function.scalar | 
 Provides functions that output real numbers. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
SupervisedBatchAndIncrementalLearner<InputType,OutputType,ResultType extends Evaluator<? super InputType,? extends OutputType>>
Interface for a class that is a supervised learning algorithm that can be
 used both batch and incremental contexts. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AbstractAnytimeSupervisedBatchLearner<InputType,OutputType,ResultType extends Evaluator<? super InputType,? extends OutputType>>
The  
AbstractAnytimeSupervisedBatchLearner abstract class extends
 the AbstractAnytimeBatchLearner to implement the 
 SupervisedBatchLearner interface. | 
class  | 
AbstractSupervisedBatchAndIncrementalLearner<InputType,OutputType,ResultType extends Evaluator<? super InputType,? extends OutputType>>
An abstract implementation of the batch and incremental learning for
 an incremental supervised learner. 
 | 
class  | 
InputOutputTransformedBatchLearner<InputType,TransformedInputType,TransformedOutputType,OutputType>
An adapter class for performing supervised learning from data where both
 the input and output have to be transformed before they are passed to the
 learning algorithm. 
 | 
class  | 
TimeSeriesPredictionLearner<InputType,OutputType,EvaluatorType extends Evaluator<? super InputType,? extends OutputType>>
A learner used to predict the future of a sequence of data by wrapping
 another learner and created a future-aligned data set. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
SupervisedBatchLearner<InputType,OutputType,EvaluatorType> | 
TimeSeriesPredictionLearner.getSupervisedLearner()
Getter for supervisedLearner 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
TimeSeriesPredictionLearner.setSupervisedLearner(SupervisedBatchLearner<InputType,OutputType,EvaluatorType> supervisedLearner)
Setter for supervisedLearner 
 | 
| Constructor and Description | 
|---|
TimeSeriesPredictionLearner(int predictionHorizon,
                           SupervisedBatchLearner<InputType,OutputType,EvaluatorType> supervisedLearner)
Creates a new instance of TimeSeriesPredictionLearner 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
MeanLearner
The  
MeanLearner class implements a baseline learner that computes
 the mean of a given set of values. | 
class  | 
MostFrequentLearner<OutputType>
The  
MostFrequentLearner class implements a baseline learner that
 computes the most frequent output value. | 
class  | 
WeightedMeanLearner
The  
WeightedMeanLearner class implements a baseline learner that
 computes the weighted mean output value. | 
class  | 
WeightedMostFrequentLearner<OutputType>
The  
WeightedMostFrequentLearner class implements a baseline learning
 algorithm that finds the most frequent output of a given dataset based on
 the weights of the examples. | 
| Modifier and Type | Class and Description | 
|---|---|
static class  | 
DiscreteNaiveBayesCategorizer.Learner<InputType,CategoryType>
Learner for a DiscreteNaiveBayesCategorizer. 
 | 
static class  | 
VectorNaiveBayesCategorizer.BatchGaussianLearner<CategoryType>
A supervised batch distributionLearner for a vector Naive Bayes categorizer that fits
 a Gaussian. 
 | 
static class  | 
VectorNaiveBayesCategorizer.Learner<CategoryType,DistributionType extends UnivariateProbabilityDensityFunction>
A supervised batch distributionLearner for a vector Naive Bayes categorizer. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AdaptiveRegularizationOfWeights
An implementation of the Adaptive Regularization of Weights (AROW) algorithm
 for online learning of a linear binary categorizer. 
 | 
class  | 
ConfidenceWeightedDiagonalDeviation
An implementation of the Standard Deviation (Stdev) algorithm for learning
 a confidence-weighted categorizer. 
 | 
class  | 
ConfidenceWeightedDiagonalDeviationProject
An implementation of the Standard Deviation (Stdev) algorithm for learning
 a confidence-weighted categorizer. 
 | 
class  | 
ConfidenceWeightedDiagonalVariance
An implementation of the Variance algorithm for learning a confidence-weighted
 linear categorizer. 
 | 
class  | 
ConfidenceWeightedDiagonalVarianceProject
An implementation of the Variance algorithm for learning a confidence-weighted
 linear categorizer. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
static class  | 
AbstractDeltaCategorizer.AbstractLearner<CategoryType>
Abstract learner for delta algorithms. 
 | 
static class  | 
BurrowsDeltaCategorizer.Learner<CategoryType>
Learner for a BurrowsDeltaCategorizer. 
 | 
static class  | 
CosineDeltaCategorizer.Learner<CategoryType>
Learner for a CosineDeltaCategorizer. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AbstractBaggingLearner<InputType,OutputType,MemberType,EnsembleType extends Evaluator<? super InputType,? extends OutputType>>
Learns an ensemble by randomly sampling with replacement
 (duplicates allowed) some percentage of the size of the data (defaults to
 100%) on each iteration to train a new ensemble member. 
 | 
class  | 
AdaBoost<InputType>
The  
AdaBoost class implements the Adaptive Boosting (AdaBoost)
 algorithm formulated by Yoav Freund and Robert Shapire. | 
class  | 
BaggingCategorizerLearner<InputType,CategoryType>
Learns an categorization ensemble by randomly sampling with replacement
 (duplicates allowed) some percentage of the size of the data (defaults to
 100%) on each iteration to train a new ensemble member. 
 | 
class  | 
BaggingRegressionLearner<InputType>
Learns an ensemble for regression by randomly sampling with replacement
 (duplicates allowed) some percentage of the size of the data (defaults to
 100%) on each iteration to train a new ensemble member. 
 | 
class  | 
BinaryBaggingLearner<InputType>
The  
BinaryBaggingLearner implements the Bagging learning algorithm. | 
class  | 
BinaryCategorizerSelector<InputType>
The  
BinaryCategorizerSelector class implements a "weak learner"
 meant for use in boosting algorithms that selects the best 
 BinaryCategorizer from a pre-set list by picking the one with the
 best weighted error. | 
class  | 
CategoryBalancedBaggingLearner<InputType,CategoryType>
An extension of the basic bagging learner that attempts to sample bags that
 have equal numbers of examples from every category. 
 | 
class  | 
CategoryBalancedIVotingLearner<InputType,CategoryType>
An extension of IVoting for dealing with skew problems that makes sure that
 there are an equal number of examples from each category in each sample that
 an ensemble member is trained on. 
 | 
class  | 
IVotingCategorizerLearner<InputType,CategoryType>
Learns an ensemble in a method similar to bagging except that on each
 iteration the bag is built from two parts, each sampled from elements from
 disjoint sets. 
 | 
class  | 
MultiCategoryAdaBoost<InputType,CategoryType>
An implementation of a multi-class version of the Adaptive Boosting
 (AdaBoost) algorithm, known as AdaBoost.M1. 
 | 
class  | 
OnlineBaggingCategorizerLearner<InputType,CategoryType,MemberType extends Evaluator<? super InputType,? extends CategoryType>>
An implementation of an online version of the Bagging algorithm for learning
 an ensemble of categorizers. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AbstractFactorizationMachineLearner
An abstract class for learning  
FactorizationMachines. | 
class  | 
FactorizationMachineAlternatingLeastSquares
Implements an Alternating Least Squares (ALS) algorithm for learning a 
 Factorization Machine. 
 | 
class  | 
FactorizationMachineStochasticGradient
Implements a Stochastic Gradient Descent (SGD) algorithm for learning a
 Factorization Machine. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
static class  | 
KNearestNeighborExhaustive.Learner<InputType,OutputType>
This is a BatchLearner interface for creating a new KNearestNeighborExhaustive
 from a given dataset, simply a pass-through to the constructor of
 KNearestNeighborExhaustive 
 | 
static class  | 
KNearestNeighborKDTree.Learner<InputType extends Vectorizable,OutputType>
This is a BatchLearner interface for creating a new KNearestNeighbor
 from a given dataset, simply a pass-through to the constructor of
 KNearestNeighbor 
 | 
static class  | 
NearestNeighborExhaustive.Learner<InputType,OutputType>
The  
NearestNeighborExhaustive.Learner class implements a batch learner for
 the NearestNeighborExhaustive class. | 
static class  | 
NearestNeighborKDTree.Learner<InputType extends Vectorizable,OutputType>
This is a BatchLearner interface for creating a new NearestNeighbor
 from a given dataset, simply a pass-through to the constructor of
 NearestNeighbor 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
KernelizableBinaryCategorizerOnlineLearner
Interface for an online learner of a linear binary categorizer that can also
 be used with a kernel function. 
 | 
interface  | 
LinearizableBinaryCategorizerOnlineLearner<InputType>
Interface for an online learner of a kernel binary categorizer that can also
 be used for learning a linear categorizer. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AbstractKernelizableBinaryCategorizerOnlineLearner
An abstract implementation of the  
KernelizableBinaryCategorizerOnlineLearner
 interface. | 
class  | 
AbstractLinearCombinationOnlineLearner
An abstract class for online learning of linear binary categorizers that
 take the form of a weighted sum of inputs. 
 | 
class  | 
AbstractOnlineLinearBinaryCategorizerLearner
An abstract class for online (incremental) learning algorithms that produce
 an  
LinearBinaryCategorizer. | 
class  | 
AggressiveRelaxedOnlineMaximumMarginAlgorithm
An implementation of the Aggressive Relaxed Online Maximum Margin Algorithm
 (AROMMA). 
 | 
class  | 
Ballseptron
An implementation of the Ballseptron algorithm. 
 | 
class  | 
BatchMultiPerceptron<CategoryType>
Implements a multi-class version of the standard batch Perceptron learning
 algorithm. 
 | 
class  | 
OnlineBinaryMarginInfusedRelaxedAlgorithm
An implementation of the binary MIRA algorithm. 
 | 
class  | 
OnlinePassiveAggressivePerceptron
An implementation of the Passive-Aggressive algorithm for learning a linear
 binary categorizer. 
 | 
static class  | 
OnlinePassiveAggressivePerceptron.AbstractSoftMargin
An abstract class for soft-margin versions of the Passive-Aggressive
 algorithm. 
 | 
static class  | 
OnlinePassiveAggressivePerceptron.LinearSoftMargin
An implementation of the linear soft-margin variant of the Passive-
 Aggressive algorithm (PA-I). 
 | 
static class  | 
OnlinePassiveAggressivePerceptron.QuadraticSoftMargin
An implementation of the quadratic soft-margin variant of the Passive-
 Aggressive algorithm (PA-II). 
 | 
class  | 
OnlinePerceptron
An online version of the classic Perceptron algorithm. 
 | 
class  | 
OnlineRampPassiveAggressivePerceptron
An implementation of the Ramp Loss Passive Aggressive Perceptron (PA^R) from
 the referenced paper. 
 | 
class  | 
OnlineShiftingPerceptron
An implementation of the Shifting Perceptron algorithm. 
 | 
class  | 
OnlineVotedPerceptron
An online version of the Voted-Perceptron algorithm. 
 | 
class  | 
Perceptron
The  
Perceptron class implements the standard Perceptron learning 
 algorithm that learns a binary classifier based on vector input. | 
class  | 
RelaxedOnlineMaximumMarginAlgorithm
An implementation of the Relaxed Online Maximum Margin Algorithm
 (ROMMA). 
 | 
class  | 
Winnow
An implementation of the Winnow incremental learning algorithm. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AbstractOnlineBudgetedKernelBinaryCategorizerLearner<InputType>
An abstract implementation of the  
BudgetedKernelBinaryCategorizerLearner
 for online learners. | 
class  | 
AbstractOnlineKernelBinaryCategorizerLearner<InputType>
An abstract class for an online kernel binary categorizer learner. 
 | 
class  | 
Forgetron<InputType>
An implementation of the "self-tuned" Forgetron algorithm, which is an online
 budgeted kernel binary categorizer learner. 
 | 
static class  | 
Forgetron.Basic<InputType>
An implementation of the "basic" Forgetron algorithm, which is an online
 budgeted kernel binary categorizer learner. 
 | 
static class  | 
Forgetron.Greedy<InputType>
An implementation of the "greedy" Forgetron algorithm, which is an online
 budgeted kernel binary categorizer learner. 
 | 
class  | 
KernelAdatron<InputType>
The  
KernelAdatron class implements an online version of the Support
 Vector Machine learning algorithm. | 
class  | 
KernelBinaryCategorizerOnlineLearnerAdapter<InputType>
A wrapper class for a  
KernelizableBinaryCategorizerOnlineLearner
 that allows it to be used as a batch or incremental learner over the
 input type directly, rather than using utility methods. | 
class  | 
KernelPerceptron<InputType>
The  
KernelPerceptron class implements the kernel version of 
 the Perceptron algorithm. | 
class  | 
OnlineKernelPerceptron<InputType>
An implementation of the online version of the Perceptron algorithm. 
 | 
class  | 
OnlineKernelRandomizedBudgetPerceptron<InputType>
An implementation of a fixed-memory kernel Perceptron algorithm. 
 | 
class  | 
Projectron<InputType>
An implementation of the Projectron algorithm, which is an online kernel
 binary categorizer learner that has a budget parameter tuned by the eta
 parameter. 
 | 
static class  | 
Projectron.LinearSoftMargin<InputType>
An implementation of the Projectron++ algorithm, which is an online
 kernel binary categorizer learner that has a budget parameter tuned by
 the eta parameter. 
 | 
class  | 
RemoveOldestKernelPerceptron<InputType>
A budget kernel Perceptron that always removes the oldest item. 
 | 
class  | 
Stoptron<InputType>
An online, budgeted, kernel version of the Perceptron algorithm that stops
 learning once it has reached its budget. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
MultivariateRegression<InputType,EvaluatorType extends Evaluator<? super InputType,? extends Vectorizable>>
A regression algorithm that maps one or more independent (input) variables
 onto multiple output variables. 
 | 
interface  | 
ParameterCostMinimizer<ResultType extends VectorizableVectorFunction>
A anytime algorithm that is used to estimate the locally minimum-cost
 parameters of an object. 
 | 
interface  | 
Regression<InputType,OutputType,EvaluatorType extends Evaluator<? super InputType,? extends OutputType>>
A supervised learning algorithm that attempts to interpolate/extrapolate
 inputs given a training set of input/output pairs. 
 | 
interface  | 
UnivariateRegression<InputType,EvaluatorType extends Evaluator<? super InputType,? extends java.lang.Double>>
A type of Regression algorithm that has a single dependent (output) variable
 that we are trying to predict. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AbstractLogisticRegression<InputType,OutputType,FunctionType extends Evaluator<? super InputType,OutputType>>
Abstract partial implementation for logistic regression classes. 
 | 
class  | 
AbstractMinimizerBasedParameterCostMinimizer<ResultType extends VectorizableVectorFunction,EvaluatorType extends Evaluator<? super Vector,? extends java.lang.Double>>
Partial implementation of ParameterCostMinimizer, based on the algorithms
 from the minimization package. 
 | 
class  | 
AbstractParameterCostMinimizer<ResultType extends VectorizableVectorFunction,CostFunctionType extends SupervisedCostFunction<Vector,Vector>>
Partial implementation of ParameterCostMinimizer. 
 | 
class  | 
FletcherXuHybridEstimation
The Fletcher-Xu hybrid estimation for solving the nonlinear least-squares
 parameters. 
 | 
class  | 
GaussNewtonAlgorithm
Implementation of the Gauss-Newton parameter-estimation procedure. 
 | 
class  | 
KernelBasedIterativeRegression<InputType>
The  
KernelBasedIterativeRegression class implements an online version of
 the Support Vector Regression algorithm. | 
class  | 
KernelWeightedRobustRegression<InputType,OutputType>
KernelWeightedRobustRegression takes a supervised learning algorithm that 
 operates on a weighted collection of InputOutputPairs and modifies the 
 weight of a sample based on the dataset output and its corresponding 
 estimate from the Evaluator from the supervised learning algorithm at each 
 iteration. 
 | 
class  | 
LeastSquaresEstimator
Abstract implementation of iterative least-squares estimators. 
 | 
class  | 
LevenbergMarquardtEstimation
Implementation of the nonlinear regression algorithm, known as
 Levenberg-Marquardt Estimation (or LMA). 
 | 
class  | 
LinearBasisRegression<InputType>
Computes the least-squares regression for a LinearCombinationFunction
 given a dataset. 
 | 
class  | 
LinearRegression
Computes the least-squares regression for a LinearCombinationFunction
 given a dataset. 
 | 
static class  | 
LocallyWeightedFunction.Learner<InputType,OutputType>
Learning algorithm for creating LocallyWeightedFunctions. 
 | 
class  | 
LogisticRegression
Performs Logistic Regression by means of the iterative reweighted least
 squares (IRLS) algorithm, where the logistic function has an explicit bias
 term, and a diagonal L2 regularization term. 
 | 
class  | 
MultivariateLinearRegression
Performs multivariate regression with an explicit bias term, with optional
 L2 regularization. 
 | 
class  | 
ParameterDerivativeFreeCostMinimizer
Implementation of a class of objects that uses a derivative-free
 minimization algorithm. 
 | 
class  | 
ParameterDifferentiableCostMinimizer
This class adapts the unconstrained nonlinear minimization algorithms in
 the "minimization" package to the task of estimating locally optimal
 (minimum-cost) parameter sets. 
 | 
class  | 
UnivariateLinearRegression
An implementation of simple univariate linear regression. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
SupervisedBatchLearner<InputType,OutputType,?> | 
KernelWeightedRobustRegression.getIterationLearner()
Getter for iterationLearner 
 | 
SupervisedBatchLearner<InputType,OutputType,?> | 
LocallyWeightedFunction.getLearner()
Getter for learner 
 | 
SupervisedBatchLearner<InputType,OutputType,?> | 
LocallyWeightedFunction.Learner.getLearner()
Getter for learner 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
KernelWeightedRobustRegression.setIterationLearner(SupervisedBatchLearner<InputType,OutputType,?> iterationLearner)  | 
void | 
LocallyWeightedFunction.setLearner(SupervisedBatchLearner<InputType,OutputType,?> learner)
Setter for learner 
 | 
void | 
LocallyWeightedFunction.Learner.setLearner(SupervisedBatchLearner<InputType,OutputType,?> learner)
Setter for learner 
 | 
| Constructor and Description | 
|---|
KernelWeightedRobustRegression(SupervisedBatchLearner<InputType,OutputType,?> iterationLearner,
                              Kernel<? super OutputType> kernelWeightingFunction)
Creates a new instance of RobustRegression 
 | 
KernelWeightedRobustRegression(SupervisedBatchLearner<InputType,OutputType,?> iterationLearner,
                              Kernel<? super OutputType> kernelWeightingFunction,
                              int maxIterations,
                              double tolerance)
Creates a new instance of RobustRegression 
 | 
Learner(Kernel<? super InputType> kernel,
       SupervisedBatchLearner<InputType,OutputType,?> learner)
Creates a new instance of LocallyWeightedFunction 
 | 
LocallyWeightedFunction(Kernel<? super InputType> kernel,
                       java.util.Collection<? extends InputOutputPair<? extends InputType,OutputType>> rawData,
                       SupervisedBatchLearner<InputType,OutputType,?> learner)
Evaluator that implements the concept of LocallyWeightedLearning. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
PrimalEstimatedSubGradient
An implementation of the Primal Estimated Sub-Gradient Solver (PEGASOS)
 algorithm for learning a linear support vector machine (SVM). 
 | 
class  | 
SequentialMinimalOptimization<InputType>
An implementation of the Sequential Minimal Optimization (SMO) algorithm for
 training a Support Vector Machine (SVM), which is a kernel-based binary
 categorizer. 
 | 
class  | 
SuccessiveOverrelaxation<InputType>
The  
SuccessiveOverrelaxation class implements the Successive 
 Overrelaxation (SOR) algorithm for learning a Support Vector Machine (SVM). | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
CategorizationTreeLearner<InputType,OutputType>
The  
CategorizationTreeLearner class implements a supervised learning 
 algorithm for learning a categorization tree. | 
class  | 
RegressionTreeLearner<InputType>
The  
RegressionTreeLearner class implements a learning algorithm for
 a regression tree that makes use of a decider learner and a regression 
 learner. | 
| Modifier and Type | Class and Description | 
|---|---|
static class  | 
BinaryVersusCategorizer.Learner<InputType,CategoryType>
A learner for the  
BinaryVersusCategorizer. | 
static class  | 
EvaluatorToCategorizerAdapter.Learner<InputType,CategoryType>
The  
EvaluatorToCategorizerAdapter.Learner class implements a
 simple supervised learner for a EvaluatorToCategorizerAdapter. | 
static class  | 
FisherLinearDiscriminantBinaryCategorizer.ClosedFormSolver
This class implements a closed form solver for the Fisher linear
 discriminant binary categorizer. 
 | 
static class  | 
MaximumAPosterioriCategorizer.Learner<ObservationType,CategoryType>
Learner for the MAP categorizer 
 | 
static class  | 
WinnerTakeAllCategorizer.Learner<InputType,CategoryType>
A learner for the adapter. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
static class  | 
PolynomialFunction.Regression
Performs Linear Regression using an arbitrary set of
 PolynomialFunction basis functions 
 | 
static class  | 
VectorFunctionToScalarFunction.Learner<InputType>
The  
VectorFunctionToScalarFunction.Learner class implements a
 simple learner for a VectorFunctionToScalarFunction that allows
 a learning algorithm that outputs a vector function to be adapted to 
 learn on data whose output are doubles. |