mlpack  3.0.4
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123]
oCAdaBoost< decision_stump::DecisionStump<> >
oCAdaBoost< perceptron::Perceptron<> >
oCAddDecomposableEvaluate< FunctionType >
oCAddDecomposableEvaluateConst< FunctionType >
oCAddDecomposableEvaluateStatic< FunctionType >
oCAddDecomposableEvaluateWithGradientConst< FunctionType >
oCAddDecomposableEvaluateWithGradientStatic< FunctionType >
oCAddDecomposableGradient< FunctionType >
oCAddDecomposableGradientConst< FunctionType >
oCAddDecomposableGradientStatic< FunctionType >
oCAddEvaluate< FunctionType >
oCAddEvaluateConst< FunctionType >
oCAddEvaluateStatic< FunctionType >
oCAddEvaluateWithGradient< FunctionType >
oCAddEvaluateWithGradientConst< FunctionType >
oCAddEvaluateWithGradientStatic< FunctionType >
oCAddGradient< FunctionType >
oCAddGradientConst< FunctionType >
oCAddGradientStatic< FunctionType >
oCversion< mlpack::ann::FFN< OutputLayerType, InitializationRuleType, CustomLayer...> >
oCversion< mlpack::ann::RNN< OutputLayerType, InitializationRuleType, CustomLayer...> >
oCstatic_visitor
oCtemplateAuxiliarySplitInfo< ElemType >
oCFastMKS< kernel::CosineDistance >
oCFastMKS< kernel::EpanechnikovKernel >
oCFastMKS< kernel::GaussianKernel >
oCFastMKS< kernel::HyperbolicTangentKernel >
oCFastMKS< kernel::LinearKernel >
oCFastMKS< kernel::PolynomialKernel >
oCFastMKS< kernel::TriangularKernel >
oCFunctionType
oCHMM< distribution::DiscreteDistribution >
oCHMM< distribution::GaussianDistribution >
oCHMM< distribution::RegressionDistribution >
oCHMM< gmm::GMM >
oCHRectBound< metric::EuclideanDistance, ElemType >
oCHRectBound< MetricType >
oCInitHMMModel
oCIPMetric< kernel::CosineDistance >
oCIPMetric< kernel::EpanechnikovKernel >
oCIPMetric< kernel::GaussianKernel >
oCIPMetric< kernel::HyperbolicTangentKernel >
oCIPMetric< kernel::LinearKernel >
oCIPMetric< kernel::PolynomialKernel >
oCIPMetric< kernel::TriangularKernel >
oCIsVector< VecType >If value == true, then VecType is some sort of Armadillo vector or subview
oCIsVector< arma::Col< eT > >
oCIsVector< arma::Row< eT > >
oCIsVector< arma::SpCol< eT > >
oCIsVector< arma::SpRow< eT > >
oCIsVector< arma::SpSubview< eT > >
oCIsVector< arma::subview_col< eT > >
oCIsVector< arma::subview_row< eT > >
oCLRSDP< optimization::SDP< arma::sp_mat > >
oCLRSDPFunction< optimization::SDP< arma::sp_mat > >
oCAdaBoost< WeakLearnerType, MatType >The AdaBoost class
oCAdaBoostModelThe model to save to disk
oCAMF< TerminationPolicyType, InitializationRuleType, UpdateRuleType >This class implements AMF (alternating matrix factorization) on the given matrix V
oCAverageInitializationThis initialization rule initializes matrix W and H to root of the average of V, perturbed with uniform noise
oCCompleteIncrementalTermination< TerminationPolicy >This class acts as a wrapper for basic termination policies to be used by SVDCompleteIncrementalLearning
oCGivenInitializationThis initialization rule for AMF simply fills the W and H matrices with the matrices given to the constructor of this object
oCIncompleteIncrementalTermination< TerminationPolicy >This class acts as a wrapper for basic termination policies to be used by SVDIncompleteIncrementalLearning
oCMaxIterationTerminationThis termination policy only terminates when the maximum number of iterations has been reached
oCNMFALSUpdateThis class implements a method titled 'Alternating Least Squares' described in the following paper:
oCNMFMultiplicativeDistanceUpdateThe multiplicative distance update rules for matrices W and H
oCNMFMultiplicativeDivergenceUpdateThis follows a method described in the paper 'Algorithms for Non-negative
oCRandomAcolInitialization< columnsToAverage >This class initializes the W matrix of the AMF algorithm by averaging p randomly chosen columns of V
oCRandomInitializationThis initialization rule for AMF simply fills the W and H matrices with uniform random noise in [0, 1]
oCSimpleResidueTerminationThis class implements a simple residue-based termination policy
oCSimpleToleranceTermination< MatType >This class implements residue tolerance termination policy
oCSVDBatchLearningThis class implements SVD batch learning with momentum
oCSVDCompleteIncrementalLearning< MatType >This class computes SVD using complete incremental batch learning, as described in the following paper:
oCSVDCompleteIncrementalLearning< arma::sp_mat >TODO : Merge this template specialized function for sparse matrix using common row_col_iterator
oCSVDIncompleteIncrementalLearningThis class computes SVD using incomplete incremental batch learning, as described in the following paper:
oCValidationRMSETermination< MatType >This class implements validation termination policy based on RMSE index
oCAdd< InputDataType, OutputDataType >Implementation of the Add module class
oCAddMerge< InputDataType, OutputDataType, CustomLayers >Implementation of the AddMerge module class
oCAlphaDropout< InputDataType, OutputDataType >The alpha - dropout layer is a regularizer that randomly with probability 'ratio' sets input values to alphaDash
oCAtrousConvolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType >Implementation of the Atrous Convolution class
oCAddTaskGenerator of instances of the binary addition task
oCCopyTaskGenerator of instances of the binary sequence copy task
oCSortTaskGenerator of instances of the sequence sort task
oCBaseLayer< ActivationFunction, InputDataType, OutputDataType >Implementation of the base layer
oCBatchNorm< InputDataType, OutputDataType >Declaration of the Batch Normalization layer class
oCBilinearInterpolation< InputDataType, OutputDataType >Definition and Implementation of the Bilinear Interpolation Layer
oCConcat< InputDataType, OutputDataType, CustomLayers >Implementation of the Concat class
oCConcatPerformance< OutputLayerType, InputDataType, OutputDataType >Implementation of the concat performance class
oCConstant< InputDataType, OutputDataType >Implementation of the constant layer
oCConstInitializationThis class is used to initialize weight matrix with constant values
oCConvolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType >Implementation of the Convolution class
oCCrossEntropyError< InputDataType, OutputDataType >The cross-entropy performance function measures the network's performance according to the cross-entropy between the input and target distributions
oCDropConnect< InputDataType, OutputDataType >The DropConnect layer is a regularizer that randomly with probability ratio sets the connection values to zero and scales the remaining elements by factor 1 /(1 - ratio)
oCDropout< InputDataType, OutputDataType >The dropout layer is a regularizer that randomly with probability 'ratio' sets input values to zero and scales the remaining elements by factor 1 / (1 - ratio) rather than during test time so as to keep the expected sum same
oCELU< InputDataType, OutputDataType >The ELU activation function, defined by
oCFastLSTM< InputDataType, OutputDataType >An implementation of a faster version of the Fast LSTM network layer
oCFFN< OutputLayerType, InitializationRuleType, CustomLayers >Implementation of a standard feed forward network
oCFFTConvolution< BorderMode, padLastDim >Computes the two-dimensional convolution through fft
oCFlexibleReLU< InputDataType, OutputDataType >The FlexibleReLU activation function, defined by
oCFullConvolution
oCGaussianInitializationThis class is used to initialize weigth matrix with a gaussian
oCGlimpse< InputDataType, OutputDataType >The glimpse layer returns a retina-like representation (down-scaled cropped images) of increasing scale around a given location in a given image
oCGlorotInitializationType< Uniform >This class is used to initialize the weight matrix with the Glorot Initialization method
oCGRU< InputDataType, OutputDataType >An implementation of a gru network layer
oCHardTanH< InputDataType, OutputDataType >The Hard Tanh activation function, defined by
oCHeInitializationThis class is used to initialize weight matrix with the He initialization rule given by He et
oCIdentityFunctionThe identity function, defined by
oCInitTraits< InitRuleType >This is a template class that can provide information about various initialization methods
oCInitTraits< KathirvalavakumarSubavathiInitialization >Initialization traits of the kathirvalavakumar subavath initialization rule
oCInitTraits< NguyenWidrowInitialization >Initialization traits of the Nguyen-Widrow initialization rule
oCJoin< InputDataType, OutputDataType >Implementation of the Join module class
oCKathirvalavakumarSubavathiInitializationThis class is used to initialize the weight matrix with the method proposed by T
oCKLDivergence< InputDataType, OutputDataType >The Kullback–Leibler divergence is often used for continuous distributions (direct regression)
oCLayerNorm< InputDataType, OutputDataType >Declaration of the Layer Normalization class
oCLayerTraits< LayerType >This is a template class that can provide information about various layers
oCLeakyReLU< InputDataType, OutputDataType >The LeakyReLU activation function, defined by
oCLecunNormalInitializationThis class is used to initialize weight matrix with the Lecun Normalization initialization rule
oCLinear< InputDataType, OutputDataType >Implementation of the Linear layer class
oCLinearNoBias< InputDataType, OutputDataType >Implementation of the LinearNoBias class
oCLogisticFunctionThe logistic function, defined by
oCLogSoftMax< InputDataType, OutputDataType >Implementation of the log softmax layer
oCLookup< InputDataType, OutputDataType >Implementation of the Lookup class
oCLSTM< InputDataType, OutputDataType >An implementation of a lstm network layer
oCMaxPooling< InputDataType, OutputDataType >Implementation of the MaxPooling layer
oCMaxPoolingRule
oCMeanPooling< InputDataType, OutputDataType >Implementation of the MeanPooling
oCMeanPoolingRule
oCMeanSquaredError< InputDataType, OutputDataType >The mean squared error performance function measures the network's performance according to the mean of squared errors
oCMultiplyConstant< InputDataType, OutputDataType >Implementation of the multiply constant layer
oCMultiplyMerge< InputDataType, OutputDataType, CustomLayers >Implementation of the MultiplyMerge module class
oCNaiveConvolution< BorderMode >Computes the two-dimensional convolution
oCNegativeLogLikelihood< InputDataType, OutputDataType >Implementation of the negative log likelihood layer
oCNetworkInitialization< InitializationRuleType, CustomLayers >This class is used to initialize the network with the given initialization rule
oCNguyenWidrowInitializationThis class is used to initialize the weight matrix with the Nguyen-Widrow method
oCOivsInitialization< ActivationFunction >This class is used to initialize the weight matrix with the oivs method
oCOrthogonalInitializationThis class is used to initialize the weight matrix with the orthogonal matrix initialization
oCPReLU< InputDataType, OutputDataType >The PReLU activation function, defined by (where alpha is trainable)
oCRandomInitializationThis class is used to initialize randomly the weight matrix
oCRectifierFunctionThe rectifier function, defined by
oCRecurrent< InputDataType, OutputDataType, CustomLayers >Implementation of the RecurrentLayer class
oCRecurrentAttention< InputDataType, OutputDataType >This class implements the Recurrent Model for Visual Attention, using a variety of possible layer implementations
oCReinforceNormal< InputDataType, OutputDataType >Implementation of the reinforce normal layer
oCRNN< OutputLayerType, InitializationRuleType, CustomLayers >Implementation of a standard recurrent neural network container
oCSelect< InputDataType, OutputDataType >The select module selects the specified column from a given input matrix
oCSequential< InputDataType, OutputDataType, CustomLayers >Implementation of the Sequential class
oCSigmoidCrossEntropyError< InputDataType, OutputDataType >The SigmoidCrossEntropyError performance function measures the network's performance according to the cross-entropy function between the input and target distributions
oCSoftplusFunctionThe softplus function, defined by
oCSoftsignFunctionThe softsign function, defined by
oCSVDConvolution< BorderMode >Computes the two-dimensional convolution using singular value decomposition
oCSwishFunctionThe swish function, defined by
oCTanhFunctionThe tanh function, defined by
oCTransposedConvolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType >Implementation of the Transposed Convolution class
oCValidConvolution
oCVRClassReward< InputDataType, OutputDataType >Implementation of the variance reduced classification reinforcement layer
oCBacktraceProvides a backtrace
oCCLIOption< N >A static object whose constructor registers a parameter with the CLI class
oCParameterType< T >Utility struct to return the type that boost::program_options should accept for a given input type
oCParameterType< arma::Col< eT > >For vector types, boost::program_options will accept a std::string, not an arma::Col<eT> (since it is not clear how to specify a vector on the command-line)
oCParameterType< arma::Mat< eT > >For matrix types, boost::program_options will accept a std::string, not an arma::mat (since it is not clear how to specify a matrix on the command-line)
oCParameterType< arma::Row< eT > >For row vector types, boost::program_options will accept a std::string, not an arma::Row<eT> (since it is not clear how to specify a vector on the command-line)
oCParameterType< std::tuple< mlpack::data::DatasetMapper< PolicyType, std::string >, arma::Mat< eT > > >For matrix+dataset info types, we should accept a std::string
oCParameterTypeDeducer< HasSerialize, T >
oCParameterTypeDeducer< true, T >
oCProgramDocA static object whose constructor registers program documentation with the CLI class
oCPyOption< T >The Python option class
oCProgramDocA static object whose constructor registers program documentation with the CLI class
oCTestOption< N >A static object whose constructor registers a parameter with the CLI class
oCBallBound< MetricType, VecType >Ball bound encloses a set of points at a specific distance (radius) from a specific point (center)
oCBoundTraits< BoundType >A class to obtain compile-time traits about BoundType classes
oCBoundTraits< BallBound< MetricType, VecType > >A specialization of BoundTraits for this bound type
oCBoundTraits< CellBound< MetricType, ElemType > >
oCBoundTraits< HollowBallBound< MetricType, ElemType > >A specialization of BoundTraits for this bound type
oCBoundTraits< HRectBound< MetricType, ElemType > >
oCCellBound< MetricType, ElemType >The CellBound class describes a bound that consists of a number of hyperrectangles
oCHollowBallBound< TMetricType, ElemType >Hollow ball bound encloses a set of points at a specific distance (radius) from a specific point (center) except points at a specific distance from another point (the center of the hole)
oCHRectBound< MetricType, ElemType >Hyper-rectangle bound for an L-metric
oCIsLMetric< MetricType >Utility struct where Value is true if and only if the argument is of type LMetric
oCIsLMetric< metric::LMetric< Power, TakeRoot > >Specialization for IsLMetric when the argument is of type LMetric
oCBatchSVDPolicyImplementation of the Batch SVD policy to act as a wrapper when accessing Batch SVD from within CFType
oCCFTypeThis class implements Collaborative Filtering (CF)
oCDummyClassThis class acts as a dummy class for passing as template parameter
oCNMFPolicyImplementation of the NMF policy to act as a wrapper when accessing NMF from within CFType
oCRandomizedSVDPolicyImplementation of the Randomized SVD policy to act as a wrapper when accessing Randomized SVD from within CFType
oCRegSVDPolicyImplementation of the Regularized SVD policy to act as a wrapper when accessing Regularized SVD from within CFType
oCSVDCompletePolicyImplementation of the SVD complete incremental policy to act as a wrapper when accessing SVD complete decomposition from within CFType
oCSVDIncompletePolicyImplementation of the SVD incomplete incremental to act as a wrapper when accessing SVD incomplete incremental from within CFType
oCSVDWrapper< Factorizer >This class acts as the wrapper for all SVD factorizers which are incompatible with CF module
oCCLIParses the command line for parameters and holds user-specified parameters
oCAccuracyThe Accuracy is a metric of performance for classification algorithms that is equal to a proportion of correctly labeled test items among all ones for given test items
oCCVBase< MLAlgorithm, MatType, PredictionsType, WeightsType >An auxiliary class for cross-validation
oCF1< AS, PositiveClass >F1 is a metric of performance for classification algorithms that for binary classification is equal to $ 2 * precision * recall / (precision + recall) $
oCKFoldCV< MLAlgorithm, Metric, MatType, PredictionsType, WeightsType >The class KFoldCV implements k-fold cross-validation for regression and classification algorithms
oCMetaInfoExtractor< MLAlgorithm, MT, PT, WT >MetaInfoExtractor is a tool for extracting meta information about a given machine learning algorithm
oCMSEThe MeanSquaredError is a metric of performance for regression algorithms that is equal to the mean squared error between predicted values and ground truth (correct) values for given test items
oCNotFoundMethodForm
oCPrecision< AS, PositiveClass >Precision is a metric of performance for classification algorithms that for binary classification is equal to $ tp / (tp + fp) $, where $ tp $ and $ fp $ are the numbers of true positives and false positives respectively
oCRecall< AS, PositiveClass >Recall is a metric of performance for classification algorithms that for binary classification is equal to $ tp / (tp + fn) $, where $ tp $ and $ fn $ are the numbers of true positives and false negatives respectively
oCSelectMethodForm< MLAlgorithm, HMFs >A type function that selects a right method form
oCSelectMethodForm< MLAlgorithm >
oCSelectMethodForm< MLAlgorithm >::From< Forms >
oCSelectMethodForm< MLAlgorithm, HasMethodForm, HMFs...>
oCSelectMethodForm< MLAlgorithm, HasMethodForm, HMFs...>::From< Forms >
oCSimpleCV< MLAlgorithm, Metric, MatType, PredictionsType, WeightsType >SimpleCV splits data into two sets - training and validation sets - and then runs training on the training set and evaluates performance on the validation set
oCTrainForm< MatType, PredictionsType, WeightsType, DatasetInfo, NumClasses >A wrapper struct for holding a Train form
oCTrainFormBase< PT, WT, SignatureParams >
oCCustomImputation< T >A simple custom imputation class
oCDatasetMapper< PolicyType, InputType >Auxiliary information for a dataset, including mappings to/from strings (or other types) and the datatype of each dimension
oCHasSerialize< T >
oCHasSerialize< T >::check< U, V, W >
oCHasSerializeFunction< T >
oCImputer< T, MapperType, StrategyType >Given a dataset of a particular datatype, replace user-specified missing value with a variable dependent on the StrategyType and MapperType
oCIncrementPolicyIncrementPolicy is used as a helper class for DatasetMapper
oCListwiseDeletion< T >A complete-case analysis to remove the values containing mappedValue
oCLoadCSVLoad the csv file.This class use boost::spirit to implement the parser, please refer to following link http://theboostcpplibraries.com/boost.spirit for quick review
oCMeanImputation< T >A simple mean imputation class
oCMedianImputation< T >This is a class implementation of simple median imputation
oCMissingPolicyMissingPolicy is used as a helper class for DatasetMapper
oCDBSCAN< RangeSearchType, PointSelectionPolicy >DBSCAN (Density-Based Spatial Clustering of Applications with Noise) is a clustering technique described in the following paper:
oCRandomPointSelectionThis class can be used to randomly select the next point to use for DBSCAN
oCDecisionStump< MatType >This class implements a decision stump
oCDTree< MatType, TagType >A density estimation tree is similar to both a decision tree and a space partitioning tree (like a kd-tree)
oCPathCacherThis class is responsible for caching the path to each node of the tree
oCDiscreteDistributionA discrete distribution where the only observations are discrete observations
oCGammaDistributionThis class represents the Gamma distribution
oCGaussianDistributionA single multivariate Gaussian distribution
oCLaplaceDistributionThe multivariate Laplace distribution centered at 0 has pdf
oCRegressionDistributionA class that represents a univariate conditionally Gaussian distribution
oCDTBRules< MetricType, TreeType >
oCDTBStatA statistic for use with mlpack trees, which stores the upper bound on distance to nearest neighbors and the component which this node belongs to
oCDualTreeBoruvka< MetricType, MatType, TreeType >Performs the MST calculation using the Dual-Tree Boruvka algorithm, using any type of tree
oCEdgePairAn edge pair is simply two indices and a distance
oCUnionFindA Union-Find data structure
oCFastMKS< KernelType, MatType, TreeType >An implementation of fast exact max-kernel search
oCFastMKSModelA utility struct to contain all the possible FastMKS models, for use by the mlpack_fastmks program
oCFastMKSRules< KernelType, TreeType >The FastMKSRules class is a template helper class used by FastMKS class when performing exact max-kernel search
oCFastMKSStatThe statistic used in trees with FastMKS
oCDiagonalConstraintForce a covariance matrix to be diagonal
oCEigenvalueRatioConstraintGiven a vector of eigenvalue ratios, ensure that the covariance matrix always has those eigenvalue ratios
oCEMFit< InitialClusteringType, CovarianceConstraintPolicy >This class contains methods which can fit a GMM to observations using the EM algorithm
oCGMMA Gaussian Mixture Model (GMM)
oCNoConstraintThis class enforces no constraint on the covariance matrix
oCPositiveDefiniteConstraintGiven a covariance matrix, force the matrix to be positive definite
oCHMM< Distribution >A class that represents a Hidden Markov Model with an arbitrary type of emission distribution
oCHMMModelA serializable HMM model that also stores the type
oCCVFunction< CVType, MLAlgorithm, TotalArgs, BoundArgs >This wrapper serves for adapting the interface of the cross-validation classes to the one that can be utilized by the mlpack optimizers
oCDeduceHyperParameterTypes< Args >A type function for deducing types of hyper-parameters from types of arguments in the Optimize method in HyperParameterTuner
oCDeduceHyperParameterTypes< Args >::ResultHolder< HPTypes >
oCDeduceHyperParameterTypes< PreFixedArg< T >, Args...>Defining DeduceHyperParameterTypes for the case when not all argument types have been processed, and the next one is the type of an argument that should be fixed
oCDeduceHyperParameterTypes< PreFixedArg< T >, Args...>::ResultHolder< HPTypes >
oCDeduceHyperParameterTypes< T, Args...>Defining DeduceHyperParameterTypes for the case when not all argument types have been processed, and the next one (T) is a collection type or an arithmetic type
oCDeduceHyperParameterTypes< T, Args...>::IsCollectionType< Type >A type function to check whether Type is a collection type (for that it should define value_type)
oCDeduceHyperParameterTypes< T, Args...>::ResultHolder< HPTypes >
oCDeduceHyperParameterTypes< T, Args...>::ResultHPType< ArgumentType, IsArithmetic >A type function to deduce the result hyper-parameter type for ArgumentType
oCDeduceHyperParameterTypes< T, Args...>::ResultHPType< ArithmeticType, true >
oCDeduceHyperParameterTypes< T, Args...>::ResultHPType< CollectionType, false >
oCFixedArg< T, I >A struct for storing information about a fixed argument
oCHyperParameterTuner< MLAlgorithm, Metric, CV, OptimizerType, MatType, PredictionsType, WeightsType >The class HyperParameterTuner for the given MLAlgorithm utilizes the provided Optimizer to find the values of hyper-parameters that optimize the value of the given Metric
oCIsPreFixedArg< T >A type function for checking whether the given type is PreFixedArg
oCPreFixedArg< typename >A struct for marking arguments as ones that should be fixed (it can be useful for the Optimize method of HyperParameterTuner)
oCPreFixedArg< T & >The specialization of the template for references
oCCosineDistanceThe cosine distance (or cosine similarity)
oCEpanechnikovKernelThe Epanechnikov kernel, defined as
oCExampleKernelAn example kernel function
oCGaussianKernelThe standard Gaussian kernel
oCHyperbolicTangentKernelHyperbolic tangent kernel
oCKernelTraits< KernelType >This is a template class that can provide information about various kernels
oCKernelTraits< CosineDistance >Kernel traits for the cosine distance
oCKernelTraits< EpanechnikovKernel >Kernel traits for the Epanechnikov kernel
oCKernelTraits< GaussianKernel >Kernel traits for the Gaussian kernel
oCKernelTraits< LaplacianKernel >Kernel traits of the Laplacian kernel
oCKernelTraits< SphericalKernel >Kernel traits for the spherical kernel
oCKernelTraits< TriangularKernel >Kernel traits for the triangular kernel
oCKMeansSelection< ClusteringType, maxIterations >Implementation of the kmeans sampling scheme
oCLaplacianKernelThe standard Laplacian kernel
oCLinearKernelThe simple linear kernel (dot product)
oCNystroemMethod< KernelType, PointSelectionPolicy >
oCOrderedSelection
oCPolynomialKernelThe simple polynomial kernel
oCPSpectrumStringKernelThe p-spectrum string kernel
oCRandomSelection
oCSphericalKernelThe spherical kernel, which is 1 when the distance between the two argument points is less than or equal to the bandwidth, or 0 otherwise
oCTriangularKernelThe trivially simple triangular kernel, defined by
oCAllowEmptyClustersPolicy which allows K-Means to create empty clusters without any error being reported
oCDualTreeKMeans< MetricType, MatType, TreeType >An algorithm for an exact Lloyd iteration which simply uses dual-tree nearest-neighbor search to find the nearest centroid for each point in the dataset
oCDualTreeKMeansRules< MetricType, TreeType >
oCElkanKMeans< MetricType, MatType >
oCHamerlyKMeans< MetricType, MatType >
oCKillEmptyClustersPolicy which allows K-Means to "kill" empty clusters without any error being reported
oCKMeans< MetricType, InitialPartitionPolicy, EmptyClusterPolicy, LloydStepType, MatType >This class implements K-Means clustering, using a variety of possible implementations of Lloyd's algorithm
oCMaxVarianceNewClusterWhen an empty cluster is detected, this class takes the point furthest from the centroid of the cluster with maximum variance as a new cluster
oCNaiveKMeans< MetricType, MatType >This is an implementation of a single iteration of Lloyd's algorithm for k-means
oCPellegMooreKMeans< MetricType, MatType >An implementation of Pelleg-Moore's 'blacklist' algorithm for k-means clustering
oCPellegMooreKMeansRules< MetricType, TreeType >The rules class for the single-tree Pelleg-Moore kd-tree traversal for k-means clustering
oCPellegMooreKMeansStatisticA statistic for trees which holds the blacklist for Pelleg-Moore k-means clustering (which represents the clusters that cannot possibly own any points in a node)
oCRandomPartitionA very simple partitioner which partitions the data randomly into the number of desired clusters
oCRefinedStartA refined approach for choosing initial points for k-means clustering
oCSampleInitialization
oCKernelPCA< KernelType, KernelRule >This class performs kernel principal components analysis (Kernel PCA), for a given kernel
oCNaiveKernelRule< KernelType >
oCNystroemKernelRule< KernelType, PointSelectionPolicy >
oCLocalCoordinateCodingAn implementation of Local Coordinate Coding (LCC) that codes data which approximately lives on a manifold using a variation of l1-norm regularized sparse coding; in LCC, the penalty on the absolute value of each point's coefficient for each atom is weighted by the squared distance of that point to that atom
oCLogProvides a convenient way to give formatted output
oCColumnsToBlocksTransform the columns of the given matrix into a block format
oCRangeType< T >Simple real-valued range
oCMatrixCompletionThis class implements the popular nuclear norm minimization heuristic for matrix completion problems
oCMeanShift< UseKernel, KernelType, MatType >This class implements mean shift clustering
oCIPMetric< KernelType >The inner product metric, IPMetric, takes a given Mercer kernel (KernelType), and when Evaluate() is called, returns the distance between the two points in kernel space:
oCLMetric< TPower, TTakeRoot >The L_p metric for arbitrary integer p, with an option to take the root
oCMahalanobisDistance< TakeRoot >The Mahalanobis distance, which is essentially a stretched Euclidean distance
oCMVUMeant to provide a good abstraction for users
oCNaiveBayesClassifier< ModelMatType >The simple Naive Bayes classifier
oCNCA< MetricType, OptimizerType >An implementation of Neighborhood Components Analysis, both a linear dimensionality reduction technique and a distance learning technique
oCSoftmaxErrorFunction< MetricType >The "softmax" stochastic neighbor assignment probability function
oCDrusillaSelect< MatType >
oCFurthestNeighborSortThis class implements the necessary methods for the SortPolicy template parameter of the NeighborSearch class
oCLSHSearch< SortPolicy >The LSHSearch class; this class builds a hash on the reference set and uses this hash to compute the distance-approximate nearest-neighbors of the given queries
oCNearestNeighborSortThis class implements the necessary methods for the SortPolicy template parameter of the NeighborSearch class
oCNeighborSearch< SortPolicy, MetricType, MatType, TreeType, DualTreeTraversalType, SingleTreeTraversalType >The NeighborSearch class is a template class for performing distance-based neighbor searches
oCNeighborSearchRules< SortPolicy, MetricType, TreeType >The NeighborSearchRules class is a template helper class used by NeighborSearch class when performing distance-based neighbor searches
oCNeighborSearchRules< SortPolicy, MetricType, TreeType >::CandidateCmpCompare two candidates based on the distance
oCNeighborSearchStat< SortPolicy >Extra data for each node in the tree
oCNSModel< SortPolicy >The NSModel class provides an easy way to serialize a model, abstracts away the different types of trees, and also reflects the NeighborSearch API
oCQDAFN< MatType >
oCRAModel< SortPolicy >The RAModel class provides an abstraction for the RASearch class, abstracting away the TreeType parameter and allowing it to be specified at runtime in this class
oCRAQueryStat< SortPolicy >Extra data for each node in the tree
oCRASearch< SortPolicy, MetricType, MatType, TreeType >The RASearch class: This class provides a generic manner to perform rank-approximate search via random-sampling
oCRASearchRules< SortPolicy, MetricType, TreeType >The RASearchRules class is a template helper class used by RASearch class when performing rank-approximate search via random-sampling
oCRAUtil
oCSparseAutoencoderA sparse autoencoder is a neural network whose aim to learn compressed representations of the data, typically for dimensionality reduction, with a constraint on the activity of the neurons in the network
oCSparseAutoencoderFunctionThis is a class for the sparse autoencoder objective function
oCAdaDeltaAdaDelta is an optimizer that uses two ideas to improve upon the two main drawbacks of the Adagrad method:
oCAdaDeltaUpdateImplementation of the AdaDelta update policy
oCAdaGradAdaGrad is a modified version of stochastic gradient descent which performs larger updates for more sparse parameters and smaller updates for less sparse parameters
oCAdaGradUpdateImplementation of the AdaGrad update policy
oCAdaMaxUpdateAdaMax is a variant of Adam, an optimizer that computes individual adaptive learning rates for different parameters from estimates of first and second moments of the gradients.based on the infinity norm as given in the section 7 of the following paper
oCAdamType< UpdateRule >Adam is an optimizer that computes individual adaptive learning rates for different parameters from estimates of first and second moments of the gradients
oCAdamUpdateAdam is an optimizer that computes individual adaptive learning rates for different parameters from estimates of first and second moments of the gradients as given in the section 7 of the following paper
oCAdaptiveStepsizeDefinition of the adaptive stepize technique, a non-monotonic stepsize scheme that uses curvature estimates to propose new stepsize choices
oCAddDecomposableEvaluate< FunctionType, HasDecomposableEvaluateWithGradient, HasDecomposableEvaluate >The AddDecomposableEvaluate mixin class will add a decomposable Evaluate() method if a decomposable EvaluateWithGradient() function exists, or nothing otherwise
oCAddDecomposableEvaluate< FunctionType, HasDecomposableEvaluateWithGradient, true >Reflect the existing Evaluate()
oCAddDecomposableEvaluate< FunctionType, true, false >If we have a decomposable EvaluateWithGradient() but not a decomposable Evaluate(), add a decomposable Evaluate() method
oCAddDecomposableEvaluateConst< FunctionType, HasDecomposableEvaluateWithGradient, HasDecomposableEvaluate >The AddDecomposableEvaluateConst mixin class will add a decomposable const Evaluate() method if a decomposable const EvaluateWithGradient() function exists, or nothing otherwise
oCAddDecomposableEvaluateConst< FunctionType, HasDecomposableEvaluateWithGradient, true >Reflect the existing Evaluate()
oCAddDecomposableEvaluateConst< FunctionType, true, false >If we have a decomposable const EvaluateWithGradient() but not a decomposable const Evaluate(), add a decomposable const Evaluate() method
oCAddDecomposableEvaluateStatic< FunctionType, HasDecomposableEvaluateWithGradient, HasDecomposableEvaluate >The AddDecomposableEvaluateStatic mixin class will add a decomposable static Evaluate() method if a decomposable static EvaluateWithGradient() function exists, or nothing otherwise
oCAddDecomposableEvaluateStatic< FunctionType, HasDecomposableEvaluateWithGradient, true >Reflect the existing Evaluate()
oCAddDecomposableEvaluateStatic< FunctionType, true, false >If we have a decomposable EvaluateWithGradient() but not a decomposable Evaluate(), add a decomposable Evaluate() method
oCAddDecomposableEvaluateWithGradient< FunctionType, HasDecomposableEvaluateGradient, true >Reflect the existing EvaluateWithGradient()
oCAddDecomposableEvaluateWithGradient< FunctionType, true, false >If we have a both decomposable Evaluate() and a decomposable Gradient() but not a decomposable EvaluateWithGradient(), add a decomposable EvaluateWithGradient() method
oCAddDecomposableEvaluateWithGradientConst< FunctionType, HasDecomposableEvaluateGradient, HasDecomposableEvaluateWithGradient >The AddDecomposableEvaluateWithGradientConst mixin class will add a decomposable const EvaluateWithGradient() method if both a decomposable const Evaluate() and a decomposable const Gradient() function exist, or nothing otherwise
oCAddDecomposableEvaluateWithGradientConst< FunctionType, HasDecomposableEvaluateGradient, true >Reflect the existing EvaluateWithGradient()
oCAddDecomposableEvaluateWithGradientConst< FunctionType, true, false >If we have both a decomposable const Evaluate() and a decomposable const Gradient() but not a decomposable const EvaluateWithGradient(), add a decomposable const EvaluateWithGradient() method
oCAddDecomposableEvaluateWithGradientStatic< FunctionType, HasDecomposableEvaluateGradient, HasDecomposableEvaluateWithGradient >The AddDecomposableEvaluateWithGradientStatic mixin class will add a decomposable static EvaluateWithGradient() method if both a decomposable static Evaluate() and a decomposable static gradient() function exist, or nothing otherwise
oCAddDecomposableEvaluateWithGradientStatic< FunctionType, HasDecomposableEvaluateGradient, true >Reflect the existing EvaluateWithGradient()
oCAddDecomposableEvaluateWithGradientStatic< FunctionType, true, false >If we have a decomposable static Evaluate() and a decomposable static Gradient() but not a decomposable static EvaluateWithGradient(), add a decomposable static Gradient() method
oCAddDecomposableGradient< FunctionType, HasDecomposableEvaluateWithGradient, HasDecomposableGradient >The AddDecomposableGradient mixin class will add a decomposable Gradient() method if a decomposable EvaluateWithGradient() function exists, or nothing otherwise
oCAddDecomposableGradient< FunctionType, HasDecomposableEvaluateWithGradient, true >Reflect the existing Gradient()
oCAddDecomposableGradient< FunctionType, true, false >If we have a decomposable EvaluateWithGradient() but not a decomposable Gradient(), add a decomposable Evaluate() method
oCAddDecomposableGradientConst< FunctionType, HasDecomposableEvaluateWithGradient, HasDecomposableGradient >The AddDecomposableGradientConst mixin class will add a decomposable const Gradient() method if a decomposable const EvaluateWithGradient() function exists, or nothing otherwise
oCAddDecomposableGradientConst< FunctionType, HasDecomposableEvaluateWithGradient, true >Reflect the existing Gradient()
oCAddDecomposableGradientConst< FunctionType, true, false >If we have a decomposable const EvaluateWithGradient() but not a decomposable const Gradient(), add a decomposable const Gradient() method
oCAddDecomposableGradientStatic< FunctionType, HasDecomposableEvaluateWithGradient, HasDecomposableGradient >The AddDecomposableEvaluateStatic mixin class will add a decomposable static Gradient() method if a decomposable static EvaluateWithGradient() function exists, or nothing otherwise
oCAddDecomposableGradientStatic< FunctionType, HasDecomposableEvaluateWithGradient, true >Reflect the existing Gradient()
oCAddDecomposableGradientStatic< FunctionType, true, false >If we have a decomposable EvaluateWithGradient() but not a decomposable Gradient(), add a decomposable Gradient() method
oCAddEvaluate< FunctionType, HasEvaluateWithGradient, HasEvaluate >The AddEvaluate mixin class will provide an Evaluate() method if the given FunctionType has EvaluateWithGradient(), or nothing otherwise
oCAddEvaluate< FunctionType, HasEvaluateWithGradient, true >Reflect the existing Evaluate()
oCAddEvaluate< FunctionType, true, false >If we have EvaluateWithGradient() but no existing Evaluate(), add an Evaluate() method
oCAddEvaluateConst< FunctionType, HasEvaluateWithGradient, HasEvaluate >The AddEvaluateConst mixin class will provide a const Evaluate() method if the given FunctionType has EvaluateWithGradient() const, or nothing otherwise
oCAddEvaluateConst< FunctionType, HasEvaluateWithGradient, true >Reflect the existing Evaluate()
oCAddEvaluateConst< FunctionType, true, false >If we have EvaluateWithGradient() but no existing Evaluate(), add an Evaluate() without a using directive to make the base Evaluate() accessible
oCAddEvaluateStatic< FunctionType, HasEvaluateWithGradient, HasEvaluate >The AddEvaluateStatic mixin class will provide a static Evaluate() method if the given FunctionType has EvaluateWithGradient() static, or nothing otherwise
oCAddEvaluateStatic< FunctionType, HasEvaluateWithGradient, true >Reflect the existing Evaluate()
oCAddEvaluateStatic< FunctionType, true, false >If we have EvaluateWithGradient() but no existing Evaluate(), add an Evaluate() without a using directive to make the base Evaluate() accessible
oCAddEvaluateWithGradient< FunctionType, HasEvaluateGradient, HasEvaluateWithGradient >The AddEvaluateWithGradient mixin class will provide an EvaluateWithGradient() method if the given FunctionType has both Evaluate() and Gradient(), or it will provide nothing otherwise
oCAddEvaluateWithGradient< FunctionType, HasEvaluateGradient, true >Reflect the existing EvaluateWithGradient()
oCAddEvaluateWithGradient< FunctionType, true, false >If the FunctionType has Evaluate() and Gradient(), provide EvaluateWithGradient()
oCAddEvaluateWithGradientConst< FunctionType, HasEvaluateGradient, HasEvaluateWithGradient >The AddEvaluateWithGradient mixin class will provide an EvaluateWithGradient() const method if the given FunctionType has both Evaluate() const and Gradient() const, or it will provide nothing otherwise
oCAddEvaluateWithGradientConst< FunctionType, HasEvaluateGradient, true >Reflect the existing EvaluateWithGradient()
oCAddEvaluateWithGradientConst< FunctionType, true, false >If the FunctionType has Evaluate() const and Gradient() const, provide EvaluateWithGradient() const
oCAddEvaluateWithGradientStatic< FunctionType, HasEvaluateGradient, HasEvaluateWithGradient >The AddEvaluateWithGradientStatic mixin class will provide a static EvaluateWithGradient() method if the given FunctionType has both static Evaluate() and static Gradient(), or it will provide nothing otherwise
oCAddEvaluateWithGradientStatic< FunctionType, HasEvaluateGradient, true >Reflect the existing EvaluateWithGradient()
oCAddEvaluateWithGradientStatic< FunctionType, true, false >If the FunctionType has static Evaluate() and static Gradient(), provide static EvaluateWithGradient()
oCAddGradient< FunctionType, HasEvaluateWithGradient, HasGradient >The AddGradient mixin class will provide a Gradient() method if the given FunctionType has EvaluateWithGradient(), or nothing otherwise
oCAddGradient< FunctionType, HasEvaluateWithGradient, true >Reflect the existing Gradient()
oCAddGradient< FunctionType, true, false >If we have EvaluateWithGradient() but no existing Gradient(), add an Gradient() without a using directive to make the base Gradient() accessible
oCAddGradientConst< FunctionType, HasEvaluateWithGradient, HasGradient >The AddGradient mixin class will provide a const Gradient() method if the given FunctionType has EvaluateWithGradient() const, or nothing otherwise
oCAddGradientConst< FunctionType, HasEvaluateWithGradient, true >Reflect the existing Gradient()
oCAddGradientConst< FunctionType, true, false >If we have EvaluateWithGradient() but no existing Gradient(), add a Gradient() without a using directive to make the base Gradient() accessible
oCAddGradientStatic< FunctionType, HasEvaluateWithGradient, HasGradient >The AddGradient mixin class will provide a static Gradient() method if the given FunctionType has static EvaluateWithGradient(), or nothing otherwise
oCAddGradientStatic< FunctionType, HasEvaluateWithGradient, true >Reflect the existing Gradient()
oCAddGradientStatic< FunctionType, true, false >If we have EvaluateWithGradient() but no existing Gradient(), add a Gradient() without a using directive to make the base Gradient() accessible
oCAMSGradUpdateAMSGrad is an exponential moving average variant which along with having benefits of optimizers like Adam and RMSProp, also guarantees convergence
oCAtomsClass to hold the information and operations of current atoms in the soluton space
oCAugLagrangianImplements the Augmented Lagrangian method of optimization
oCAugLagrangianFunction< LagrangianFunction >This is a utility class used by AugLagrangian, meant to wrap a LagrangianFunction into a function usable by a simple optimizer like L-BFGS
oCAugLagrangianTestFunctionThis function is taken from "Practical Mathematical Optimization" (Snyman), section 5.3.8 ("Application of the Augmented Lagrangian Method")
oCBacktrackingLineSearchDefinition of the backtracking line search algorithm based on the Armijo–Goldstein condition to determine the maximum amount to move along the given search direction
oCBarzilaiBorweinDecayBarzilai-Borwein decay policy for Stochastic variance reduced gradient (SVRG)
oCBigBatchSGD< UpdatePolicyType >Big-batch Stochastic Gradient Descent is a technique for minimizing a function which can be expressed as a sum of other functions
oCCMAES< SelectionPolicyType >CMA-ES - Covariance Matrix Adaptation Evolution Strategy is s a stochastic search algorithm
oCCNEConventional Neural Evolution (CNE) is a class of evolutionary algorithms focused on dealing with fixed topology
oCConstantStepImplementation of the ConstantStep stepsize decay policy for parallel SGD
oCConstrLpBallSolverLinearConstrSolver for FrankWolfe algorithm
oCConstrStructGroupSolver< GroupType >Linear Constrained Solver for FrankWolfe
oCCyclicalDecaySimulate a new warm-started run/restart once a number of epochs are performed
oCCyclicDescentCyclic descent policy for Stochastic Coordinate Descent(SCD)
oCExponentialBackoffExponential backoff stepsize reduction policy for parallel SGD
oCExponentialScheduleThe exponential cooling schedule cools the temperature T at every step according to the equation
oCFrankWolfe< LinearConstrSolverType, UpdateRuleType >Frank-Wolfe is a technique to minimize a continuously differentiable convex function $ f $ over a compact convex subset $ D $ of a vector space
oCFullSelection
oCFuncSqSquare loss function $ f(x) = 0.5 * ||Ax - b||_2^2 $
oCGockenbachFunctionThis function is taken from M
oCGradientClipping< UpdatePolicyType >Interface for wrapping around update policies (e.g., VanillaUpdate) and feeding a clipped gradient to them instead of the normal one
oCGradientDescentGradient Descent is a technique to minimize a function
oCGreedyDescentGreedy descent policy for Stochastic Co-ordinate Descent(SCD)
oCGridSearchAn optimizer that finds the minimum of a given function by iterating through points on a multidimensional grid
oCGroupLpBallImplementation of Structured Group
oCIQNIQN is a technique for minimizing a function which can be expressed as a sum of other functions
oCKatyushaType< Proximal >Katyusha is a direct, primal-only stochastic gradient method which uses a "negative momentum" on top of Nesterov’s momentum
oCL_BFGSThe generic L-BFGS optimizer, which uses a back-tracking line search algorithm to minimize a function
oCLineSearchFind the minimum of a function along the line between two points
oCLovaszThetaSDPThis function is the Lovasz-Theta semidefinite program, as implemented in the following paper:
oCLRSDP< SDPType >LRSDP is the implementation of Monteiro and Burer's formulation of low-rank semidefinite programs (LR-SDP)
oCLRSDPFunction< SDPType >The objective function that LRSDP is trying to optimize
oCNadaMaxUpdateNadaMax is an optimizer that combines the AdaMax and NAG
oCNadamUpdateNadam is an optimizer that combines the Adam and NAG optimization strategies
oCNesterovMomentumUpdateNesterov Momentum update policy for Stochastic Gradient Descent (SGD)
oCNoDecayDefinition of the NoDecay class
oCOptimisticAdamUpdateOptimisticAdam is an optimizer which implements the Optimistic Adam algorithm which uses Optmistic Mirror Descent with the Adam Optimizer
oCParallelSGD< DecayPolicyType >An implementation of parallel stochastic gradient descent using the lock-free HOGWILD! approach
oCPrimalDualSolver< SDPType >Interface to a primal dual interior point solver
oCProximalApproximate a vector with another vector on lp ball
oCRandomDescentRandom descent policy for Stochastic Coordinate Descent(SCD)
oCRandomSelection
oCRMSPropRMSProp is an optimizer that utilizes the magnitude of recent gradients to normalize the gradients
oCRMSPropUpdateRMSProp is an optimizer that utilizes the magnitude of recent gradients to normalize the gradients
oCSA< CoolingScheduleType >Simulated Annealing is an stochastic optimization algorithm which is able to deliver near-optimal results quickly without knowing the gradient of the function being optimized
oCSARAHPlusUpdateSARAH+ provides an automatic and adaptive choice of the inner loop size
oCSARAHType< UpdatePolicyType >StochAstic Recusive gRadient algoritHm (SARAH)
oCSARAHUpdateVanilla update policy for SARAH
oCSCD< DescentPolicyType >Stochastic Coordinate descent is a technique for minimizing a function by doing a line search along a single direction at the current point in the iteration
oCSDP< ObjectiveMatrixType >Specify an SDP in primal form
oCSGD< UpdatePolicyType, DecayPolicyType >Stochastic Gradient Descent is a technique for minimizing a function which can be expressed as a sum of other functions
oCSGDR< UpdatePolicyType >This class is based on Mini-batch Stochastic Gradient Descent class and simulates a new warm-started run/restart once a number of epochs are performed
oCSMORMS3SMORMS3 is an optimizer that estimates a safe and optimal distance based on curvature and normalizing the stepsize in the parameter space
oCSMORMS3UpdateSMORMS3 is an optimizer that estimates a safe and optimal distance based on curvature and normalizing the stepsize in the parameter space
oCSnapshotEnsemblesSimulate a new warm-started run/restart once a number of epochs are performed
oCSnapshotSGDR< UpdatePolicyType >This class is based on Mini-batch Stochastic Gradient Descent class and simulates a new warm-started run/restart once a number of epochs are performed using the Snapshot ensembles technique
oCSPALeRASGD< DecayPolicyType >SPALeRA Stochastic Gradient Descent is a technique for minimizing a function which can be expressed as a sum of other functions
oCSPALeRAStepsizeDefinition of the SPALeRA stepize technique, which implementes a change detection mechanism with an agnostic adaptation scheme
oCSVRGType< UpdatePolicyType, DecayPolicyType >Stochastic Variance Reduced Gradient is a technique for minimizing a function which can be expressed as a sum of other functions
oCSVRGUpdateVanilla update policy for Stochastic variance reduced gradient (SVRG)
oCBoothFunctionThe Booth function, defined by
oCBukinFunctionThe Bukin function, defined by
oCColvilleFunctionThe Colville function, defined by
oCDropWaveFunctionThe Drop-Wave function, defined by
oCEasomFunctionThe Easom function, defined by
oCEggholderFunctionThe Eggholder function, defined by
oCGDTestFunctionVery, very simple test function which is the composite of three other functions
oCGeneralizedRosenbrockFunctionThe Generalized Rosenbrock function in n dimensions, defined by f(x) = sum_i^{n - 1} (f(i)(x)) f_i(x) = 100 * (x_i^2 - x_{i + 1})^2 + (1 - x_i)^2 x_0 = [-1.2, 1, -1.2, 1, ...]
oCMatyasFunctionThe Matyas function, defined by
oCMcCormickFunctionThe McCormick function, defined by
oCRastriginFunctionThe Rastrigin function, defined by
oCRosenbrockFunctionThe Rosenbrock function, defined by:
oCRosenbrockWoodFunctionThe Generalized Rosenbrock function in 4 dimensions with the Wood Function in four dimensions
oCSchwefelFunctionThe Schwefel function, defined by
oCSGDTestFunctionVery, very simple test function which is the composite of three other functions
oCSparseTestFunction
oCSphereFunctionThe Sphere function, defined by
oCStyblinskiTangFunctionThe Styblinski-Tang function, defined by
oCWoodFunctionThe Wood function, defined by f(x) = f1(x) + f2(x) + f3(x) + f4(x) + f5(x) + f6(x) f1(x) = 100 (x2 - x1^2)^2 f2(x) = (1 - x1)^2 f3(x) = 90 (x4 - x3^2)^2 f4(x) = (1 - x3)^2 f5(x) = 10 (x2 + x4 - 2)^2 f6(x) = (1 / 10) (x2 - x4)^2 x_0 = [-3, -1, -3, -1]
oCTestFuncFWSimple test function for classic Frank Wolfe Algorithm:
oCCheckDecomposableEvaluate< FunctionType >Check if a suitable decomposable overload of Evaluate() is available
oCCheckDecomposableEvaluateWithGradient< FunctionType >Check if a suitable decomposable overload of EvaluateWithGradient() is available
oCCheckDecomposableGradient< FunctionType >Check if a suitable decomposable overload of Gradient() is available
oCCheckEvaluate< FunctionType >Check if a suitable overload of Evaluate() is available
oCCheckEvaluateConstraint< FunctionType >Check if a suitable overload of EvaluateConstraint() is available
oCCheckEvaluateWithGradient< FunctionType >Check if a suitable overload of EvaluateWithGradient() is available
oCCheckGradient< FunctionType >Check if a suitable overload of Gradient() is available
oCCheckGradientConstraint< FunctionType >Check if a suitable overload of GradientConstraint() is available
oCCheckNumConstraints< FunctionType >Check if a suitable overload of NumConstraints() is available
oCCheckNumFeatures< FunctionType >Check if a suitable overload of NumFeatures() is available
oCCheckNumFunctions< FunctionType >Check if a suitable overload of NumFunctions() is available
oCCheckPartialGradient< FunctionType >Check if a suitable overload of PartialGradient() is available
oCCheckShuffle< FunctionType >Check if a suitable overload of Shuffle() is available
oCCheckSparseGradient< FunctionType >Check if a suitable overload of Gradient() that supports sparse gradients is available
oCHasConstSignatures< ClassType, CheckerA, ConstSignatureA, StaticSignatureA, CheckerB, ConstSignatureB, StaticSignatureB >Utility struct: sometimes we want to know if we have two functions available, and that at least one of them is const and both of them are not non-const and non-static
oCHasNonConstSignatures< ClassType, CheckerA, SignatureA, ConstSignatureA, StaticSignatureA, CheckerB, SignatureB, ConstSignatureB, StaticSignatureB >Utility struct: sometimes we want to know if we have two functions available, and that at least one of them is non-const and non-static
oCUnconstructableTypeThis is a utility type used to provide unusable overloads from each of the mixin classes
oCUpdateClassicUse classic rule in the update step for FrankWolfe algorithm
oCUpdateFullCorrectionFull correction approach to update the solution
oCUpdateLineSearchUse line search in the update step for FrankWolfe algorithm
oCUpdateSpanRecalculate the optimal solution in the span of all previous solution space, used as update step for FrankWolfe algorithm
oCVanillaUpdateVanilla update policy for Stochastic Gradient Descent (SGD)
oCExactSVDPolicyImplementation of the exact SVD policy
oCPCA< DecompositionPolicy >This class implements principal components analysis (PCA)
oCQUICSVDPolicyImplementation of the QUIC-SVD policy
oCRandomizedBlockKrylovSVDPolicyImplementation of the randomized block krylov SVD policy
oCRandomizedSVDPolicyImplementation of the randomized SVD policy
oCPerceptron< LearnPolicy, WeightInitializationPolicy, MatType >This class implements a simple perceptron (i.e., a single layer neural network)
oCRandomInitializationThis class is used to initialize weights for the weightVectors matrix in a random manner
oCSimpleWeightUpdate
oCZeroInitializationThis class is used to initialize the matrix weightVectors to zero
oCRadicalAn implementation of RADICAL, an algorithm for independent component analysis (ICA)
oCRangeSearch< MetricType, MatType, TreeType >The RangeSearch class is a template class for performing range searches
oCRangeSearchRules< MetricType, TreeType >The RangeSearchRules class is a template helper class used by RangeSearch class when performing range searches
oCRangeSearchStatStatistic class for RangeSearch, to be set to the StatisticType of the tree type that range search is being performed with
oCRSModel
oCLARSAn implementation of LARS, a stage-wise homotopy-based algorithm for l1-regularized linear regression (LASSO) and l1+l2 regularized linear regression (Elastic Net)
oCLinearRegressionA simple linear regression algorithm using ordinary least squares
oCLogisticRegression< MatType >The LogisticRegression class implements an L2-regularized logistic regression model, and supports training with multiple optimizers and classification
oCLogisticRegressionFunction< MatType >The log-likelihood function for the logistic regression objective function
oCSoftmaxRegressionSoftmax Regression is a classifier which can be used for classification when the data available can take two or more class values
oCSoftmaxRegressionFunction
oCAcrobatImplementation of Acrobat game
oCAcrobat::State
oCAggregatedPolicy< PolicyType >
oCAsyncLearning< WorkerType, EnvironmentType, NetworkType, UpdaterType, PolicyType >Wrapper of various asynchronous learning algorithms, e.g
oCCartPoleImplementation of Cart Pole task
oCCartPole::StateImplementation of the state of Cart Pole
oCContinuousMountainCarImplementation of Continuous Mountain Car task
oCContinuousMountainCar::ActionImplementation of action of Continuous Mountain Car
oCContinuousMountainCar::StateImplementation of state of Continuous Mountain Car
oCGreedyPolicy< EnvironmentType >Implementation for epsilon greedy policy
oCMountainCarImplementation of Mountain Car task
oCMountainCar::StateImplementation of state of Mountain Car
oCNStepQLearningWorker< EnvironmentType, NetworkType, UpdaterType, PolicyType >Forward declaration of NStepQLearningWorker
oCOneStepQLearningWorker< EnvironmentType, NetworkType, UpdaterType, PolicyType >Forward declaration of OneStepQLearningWorker
oCOneStepSarsaWorker< EnvironmentType, NetworkType, UpdaterType, PolicyType >Forward declaration of OneStepSarsaWorker
oCPendulumImplementation of Pendulum task
oCPendulum::ActionImplementation of action of Pendulum
oCPendulum::StateImplementation of state of Pendulum
oCQLearning< EnvironmentType, NetworkType, UpdaterType, PolicyType, ReplayType >Implementation of various Q-Learning algorithms, such as DQN, double DQN
oCRandomReplay< EnvironmentType >Implementation of random experience replay
oCTrainingConfig
oCMethodFormDetector< Class, MethodForm, AdditionalArgsCount >
oCMethodFormDetector< Class, MethodForm, 0 >
oCMethodFormDetector< Class, MethodForm, 1 >
oCMethodFormDetector< Class, MethodForm, 2 >
oCMethodFormDetector< Class, MethodForm, 3 >
oCMethodFormDetector< Class, MethodForm, 4 >
oCMethodFormDetector< Class, MethodForm, 5 >
oCMethodFormDetector< Class, MethodForm, 6 >
oCMethodFormDetector< Class, MethodForm, 7 >
oCDataDependentRandomInitializerA data-dependent random dictionary initializer for SparseCoding
oCNothingInitializerA DictionaryInitializer for SparseCoding which does not initialize anything; it is useful for when the dictionary is already known and will be set with SparseCoding::Dictionary()
oCRandomInitializerA DictionaryInitializer for use with the SparseCoding class
oCSparseCodingAn implementation of Sparse Coding with Dictionary Learning that achieves sparsity via an l1-norm regularizer on the codes (LASSO) or an (l1+l2)-norm regularizer on the codes (the Elastic Net)
oCQUIC_SVDQUIC-SVD is a matrix factorization technique, which operates in a subspace such that A's approximation in that subspace has minimum error(A being the data matrix)
oCRandomizedBlockKrylovSVDRandomized block krylov SVD is a matrix factorization that is based on randomized matrix approximation techniques, developed in in "Randomized Block Krylov Methods for Stronger and Faster Approximate Singular Value Decomposition"
oCRandomizedSVDRandomized SVD is a matrix factorization that is based on randomized matrix approximation techniques, developed in in "Finding structure with randomness: Probabilistic algorithms for constructing approximate matrix decompositions"
oCRegularizedSVD< OptimizerType >Regularized SVD is a matrix factorization technique that seeks to reduce the error on the training set, that is on the examples for which the ratings have been provided by the users
oCRegularizedSVDFunction< MatType >The data is stored in a matrix of type MatType, so that this class can be used with both dense and sparse matrix types
oCTimerThe timer class provides a way for mlpack methods to be timed
oCTimers
oCAllCategoricalSplit< FitnessFunction >The AllCategoricalSplit is a splitting function that will split categorical features into many children: one child for each category
oCAllCategoricalSplit< FitnessFunction >::AuxiliarySplitInfo< ElemType >
oCAllDimensionSelectThis dimension selection policy allows any dimension to be selected for splitting
oCAxisParallelProjVectorAxisParallelProjVector defines an axis-parallel projection vector
oCBestBinaryNumericSplit< FitnessFunction >The BestBinaryNumericSplit is a splitting function for decision trees that will exhaustively search a numeric dimension for the best binary split
oCBestBinaryNumericSplit< FitnessFunction >::AuxiliarySplitInfo< ElemType >
oCBinaryNumericSplit< FitnessFunction, ObservationType >The BinaryNumericSplit class implements the numeric feature splitting strategy devised by Gama, Rocha, and Medas in the following paper:
oCBinaryNumericSplitInfo< ObservationType >
oCBinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType >A binary space partitioning tree, such as a KD-tree or a ball tree
oCBinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType >::BreadthFirstDualTreeTraverser< RuleType >
oCBinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType >::DualTreeTraverser< RuleType >A dual-tree traverser for binary space trees; see dual_tree_traverser.hpp
oCBinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType >::SingleTreeTraverser< RuleType >A single-tree traverser for binary space trees; see single_tree_traverser.hpp for implementation
oCCategoricalSplitInfo
oCCompareCosineNode
oCCosineTree
oCCoverTree< MetricType, StatisticType, MatType, RootPointPolicy >A cover tree is a tree specifically designed to speed up nearest-neighbor computation in high-dimensional spaces
oCCoverTree< MetricType, StatisticType, MatType, RootPointPolicy >::DualTreeTraverser< RuleType >A dual-tree cover tree traverser; see dual_tree_traverser.hpp
oCCoverTree< MetricType, StatisticType, MatType, RootPointPolicy >::SingleTreeTraverser< RuleType >A single-tree cover tree traverser; see single_tree_traverser.hpp for implementation
oCDiscreteHilbertValue< TreeElemType >The DiscreteHilbertValue class stores Hilbert values for all of the points in a RectangleTree node, and calculates Hilbert values for new points
oCEmptyStatisticEmpty statistic if you are not interested in storing statistics in your tree
oCExampleTree< MetricType, StatisticType, MatType >This is not an actual space tree but instead an example tree that exists to show and document all the functions that mlpack trees must implement
oCFirstPointIsRootThis class is meant to be used as a choice for the policy class RootPointPolicy of the CoverTree class
oCGiniGainThe Gini gain, a measure of set purity usable as a fitness function (FitnessFunction) for decision trees
oCGiniImpurity
oCGreedySingleTreeTraverser< TreeType, RuleType >
oCHilbertRTreeAuxiliaryInformation< TreeType, HilbertValueType >
oCHilbertRTreeDescentHeuristicThis class chooses the best child of a node in a Hilbert R tree when inserting a new point
oCHilbertRTreeSplit< splitOrder >The splitting procedure for the Hilbert R tree
oCHoeffdingCategoricalSplit< FitnessFunction >This is the standard Hoeffding-bound categorical feature proposed in the paper below:
oCHoeffdingNumericSplit< FitnessFunction, ObservationType >The HoeffdingNumericSplit class implements the numeric feature splitting strategy alluded to by Domingos and Hulten in the following paper:
oCHoeffdingTree< FitnessFunction, NumericSplitType, CategoricalSplitType >The HoeffdingTree object represents all of the necessary information for a Hoeffding-bound-based decision tree
oCHoeffdingTreeModelThis class is a serializable Hoeffding tree model that can hold four different types of Hoeffding trees
oCHyperplaneBase< BoundT, ProjVectorT >HyperplaneBase defines a splitting hyperplane based on a projection vector and projection value
oCInformationGainThe standard information gain criterion, used for calculating gain in decision trees
oCIsSpillTree< TreeType >
oCIsSpillTree< tree::SpillTree< MetricType, StatisticType, MatType, HyperplaneType, SplitType > >
oCMeanSpaceSplit< MetricType, MatType >
oCMeanSplit< BoundType, MatType >A binary space partitioning tree node is split into its left and right child
oCMeanSplit< BoundType, MatType >::SplitInfoAn information about the partition
oCMidpointSpaceSplit< MetricType, MatType >
oCMidpointSplit< BoundType, MatType >A binary space partitioning tree node is split into its left and right child
oCMidpointSplit< BoundType, MatType >::SplitInfoA struct that contains an information about the split
oCMinimalCoverageSweep< SplitPolicy >The MinimalCoverageSweep class finds a partition along which we can split a node according to the coverage of two resulting nodes
oCMinimalCoverageSweep< SplitPolicy >::SweepCost< TreeType >A struct that provides the type of the sweep cost
oCMinimalSplitsNumberSweep< SplitPolicy >The MinimalSplitsNumberSweep class finds a partition along which we can split a node according to the number of required splits of the node
oCMinimalSplitsNumberSweep< SplitPolicy >::SweepCost< typename >A struct that provides the type of the sweep cost
oCMultipleRandomDimensionSelect< NumDimensions >This dimension selection policy allows the selection from a few random dimensions
oCNoAuxiliaryInformation< TreeType >
oCNumericSplitInfo< ObservationType >
oCOctree< MetricType, StatisticType, MatType >
oCOctree< MetricType, StatisticType, MatType >::DualTreeTraverser< MetricType, StatisticType, MatType >A dual-tree traverser; see dual_tree_traverser.hpp
oCOctree< MetricType, StatisticType, MatType >::SingleTreeTraverser< RuleType >A single-tree traverser; see single_tree_traverser.hpp
oCOctree< MetricType, StatisticType, MatType >::SplitType::SplitInfo
oCProjVectorProjVector defines a general projection vector (not necessarily axis-parallel)
oCQueueFrame< TreeType, TraversalInfoType >
oCRandomDimensionSelectThis dimension selection policy only selects one single random dimension
oCRandomForest< FitnessFunction, DimensionSelectionType, NumericSplitType, CategoricalSplitType, ElemType >
oCRectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >A rectangle type tree tree, such as an R-tree or X-tree
oCRectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >::DualTreeTraverser< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >A dual tree traverser for rectangle type trees
oCRectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >::SingleTreeTraverser< RuleType >A single traverser for rectangle type trees
oCRPlusPlusTreeAuxiliaryInformation< TreeType >
oCRPlusPlusTreeDescentHeuristic
oCRPlusPlusTreeSplitPolicyThe RPlusPlusTreeSplitPolicy helps to determine the subtree into which we should insert a child of an intermediate node that is being split
oCRPlusTreeDescentHeuristic
oCRPlusTreeSplit< SplitPolicyType, SweepType >The RPlusTreeSplit class performs the split process of a node on overflow
oCRPlusTreeSplitPolicyThe RPlusPlusTreeSplitPolicy helps to determine the subtree into which we should insert a child of an intermediate node that is being split
oCRPTreeMaxSplit< BoundType, MatType >This class splits a node by a random hyperplane
oCRPTreeMaxSplit< BoundType, MatType >::SplitInfoAn information about the partition
oCRPTreeMeanSplit< BoundType, MatType >This class splits a binary space tree
oCRPTreeMeanSplit< BoundType, MatType >::SplitInfoAn information about the partition
oCRStarTreeDescentHeuristicWhen descending a RectangleTree to insert a point, we need to have a way to choose a child node when the point isn't enclosed by any of them
oCRStarTreeSplitA Rectangle Tree has new points inserted at the bottom
oCRTreeDescentHeuristicWhen descending a RectangleTree to insert a point, we need to have a way to choose a child node when the point isn't enclosed by any of them
oCRTreeSplitA Rectangle Tree has new points inserted at the bottom
oCSpaceSplit< MetricType, MatType >
oCSpillTree< MetricType, StatisticType, MatType, HyperplaneType, SplitType >A hybrid spill tree is a variant of binary space trees in which the children of a node can "spill over" each other, and contain shared datapoints
oCSpillTree< MetricType, StatisticType, MatType, HyperplaneType, SplitType >::SpillDualTreeTraverser< MetricType, StatisticType, MatType, HyperplaneType, SplitType >A generic dual-tree traverser for hybrid spill trees; see spill_dual_tree_traverser.hpp for implementation
oCSpillTree< MetricType, StatisticType, MatType, HyperplaneType, SplitType >::SpillSingleTreeTraverser< MetricType, StatisticType, MatType, HyperplaneType, SplitType >A generic single-tree traverser for hybrid spill trees; see spill_single_tree_traverser.hpp for implementation
oCTraversalInfo< TreeType >The TraversalInfo class holds traversal information which is used in dual-tree (and single-tree) traversals
oCTreeTraits< TreeType >The TreeTraits class provides compile-time information on the characteristics of a given tree type
oCTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, bound::BallBound, SplitType > >This is a specialization of the TreeType class to the BallTree tree type
oCTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, bound::CellBound, SplitType > >This is a specialization of the TreeType class to the UBTree tree type
oCTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, bound::HollowBallBound, SplitType > >This is a specialization of the TreeType class to an arbitrary tree with HollowBallBound (currently only the vantage point tree is supported)
oCTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, RPTreeMaxSplit > >This is a specialization of the TreeType class to the max-split random projection tree
oCTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, RPTreeMeanSplit > >This is a specialization of the TreeType class to the mean-split random projection tree
oCTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType > >This is a specialization of the TreeTraits class to the BinarySpaceTree tree type
oCTreeTraits< CoverTree< MetricType, StatisticType, MatType, RootPointPolicy > >The specialization of the TreeTraits class for the CoverTree tree type
oCTreeTraits< Octree< MetricType, StatisticType, MatType > >This is a specialization of the TreeTraits class to the Octree tree type
oCTreeTraits< RectangleTree< MetricType, StatisticType, MatType, RPlusTreeSplit< SplitPolicyType, SweepType >, DescentType, AuxiliaryInformationType > >Since the R+/R++ tree can not have overlapping children, we should define traits for the R+/R++ tree
oCTreeTraits< RectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType > >This is a specialization of the TreeType class to the RectangleTree tree type
oCTreeTraits< SpillTree< MetricType, StatisticType, MatType, HyperplaneType, SplitType > >This is a specialization of the TreeType class to the SpillTree tree type
oCUBTreeSplit< BoundType, MatType >Split a node into two parts according to the median address of points contained in the node
oCVantagePointSplit< BoundType, MatType, MaxNumSamples >The class splits a binary space partitioning tree node according to the median distance to the vantage point
oCVantagePointSplit< BoundType, MatType, MaxNumSamples >::SplitInfoA struct that contains an information about the split
oCXTreeAuxiliaryInformation< TreeType >The XTreeAuxiliaryInformation class provides information specific to X trees for each node in a RectangleTree
oCXTreeAuxiliaryInformation< TreeType >::SplitHistoryStructThe X tree requires that the tree records it's "split history"
oCXTreeSplitA Rectangle Tree has new points inserted at the bottom
oCIsStdVector< T >Metaprogramming structure for vector detection
oCIsStdVector< std::vector< T, A > >Metaprogramming structure for vector detection
oCNullOutStreamUsed for Log::Debug when not compiled with debugging symbols
oCParamDataThis structure holds all of the information about a single parameter, including its value (which is set when ParseCommandLine() is called)
oCPrefixedOutStreamAllows us to output to an ostream with a prefix at the beginning of each line, in the same way we would output to cout or cerr
oCProgramDocA static object whose constructor registers program documentation with the CLI class
oCNeighborSearchStat< neighbor::NearestNeighborSort >
oCtemplateAuxiliarySplitInfo< ElemType >
oCRangeType< double >
oCRangeType< ElemType >
oCSDP< arma::sp_mat >
oCSGD< mlpack::optimization::AdaDeltaUpdate >
oCSGD< mlpack::optimization::AdaGradUpdate >
oCSGD< mlpack::optimization::RMSPropUpdate >
oCSGD< mlpack::optimization::SMORMS3Update >
oCSGD< UpdatePolicyType, CyclicalDecay >
oCSGD< UpdatePolicyType, SnapshotEnsembles >
oCSGD< UpdateRule >
oCSparseSVMFunction
oCtrue_type
oCTrainFormBase< PT, void, const MT &, const data::DatasetInfo &, const PT & >
oCTrainFormBase< PT, void, const MT &, const data::DatasetInfo &, const PT &, const size_t >
oCTrainFormBase< PT, void, const MT &, const PT & >
oCTrainFormBase< PT, void, const MT &, const PT &, const size_t >
oCTrainFormBase< PT, WT, const MT &, const data::DatasetInfo &, const PT &, const size_t, const WT & >
oCTrainFormBase< PT, WT, const MT &, const data::DatasetInfo &, const PT &, const WT & >
oCTrainFormBase< PT, WT, const MT &, const PT &, const size_t, const WT & >
oCTrainFormBase< PT, WT, const MT &, const PT &, const WT & >
\CTrainHMMModel
Generated by   doxygen 1.8.5