►Ctemplate AuxiliarySplitInfo | |
CDecisionTree< FitnessFunction, NumericSplitType, CategoricalSplitType, DimensionSelectionType, ElemType, NoRecursion > | This class implements a generic decision tree learner |
CBernoulliDistribution< arma::mat > | |
►Ctemplate AuxiliarySplitInfo | |
CDecisionTree< FitnessFunction, NumericSplitType, CategoricalSplitType, DimensionSelectionType, ElemType, NoRecursion > | This class implements a generic decision tree learner |
Cversion< mlpack::adaboost::AdaBoost< WeakLearnerType, MatType > > | |
Cversion< mlpack::ann::AddMerge< InputDataType, OutputDataType, CustomLayers... > > | |
Cversion< mlpack::ann::AtrousConvolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType > > | |
Cversion< mlpack::ann::BRNN< OutputLayerType, MergeLayerType, MergeOutputType, InitializationRuleType, CustomLayer... > > | |
Cversion< mlpack::ann::Convolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType > > | |
Cversion< mlpack::ann::FFN< OutputLayerType, InitializationRuleType, CustomLayer... > > | |
Cversion< mlpack::ann::RNN< OutputLayerType, InitializationRuleType, CustomLayer... > > | |
Cversion< mlpack::ann::Sequential< InputDataType, OutputDataType, Residual, CustomLayers... > > | |
Cversion< mlpack::ann::TransposedConvolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType > > | |
Cversion< mlpack::kde::KDE< KernelType, MetricType, MatType, TreeType, DualTreeTraversalType, SingleTreeTraversalType > > | |
►Cstatic_visitor | |
CLayerNameVisitor | Implementation of a class that returns the string representation of the name of the given layer |
CAddVisitor< CustomLayers > | AddVisitor exposes the Add() method of the given module |
CBackwardVisitor | BackwardVisitor executes the Backward() function given the input, error and delta parameter |
CBiasSetVisitor | BiasSetVisitor updates the module bias parameters given the parameters set |
CCopyVisitor< CustomLayers > | This visitor is to support copy constructor for neural network module |
CDeleteVisitor | DeleteVisitor executes the destructor of the instantiated object |
CDeltaVisitor | DeltaVisitor exposes the delta parameter of the given module |
CDeterministicSetVisitor | DeterministicSetVisitor set the deterministic parameter given the deterministic value |
CForwardVisitor | ForwardVisitor executes the Forward() function given the input and output parameter |
CGradientSetVisitor | GradientSetVisitor update the gradient parameter given the gradient set |
CGradientUpdateVisitor | GradientUpdateVisitor update the gradient parameter given the gradient set |
CGradientVisitor | SearchModeVisitor executes the Gradient() method of the given module using the input and delta parameter |
CGradientZeroVisitor | |
CLoadOutputParameterVisitor | LoadOutputParameterVisitor restores the output parameter using the given parameter set |
CLossVisitor | LossVisitor exposes the Loss() method of the given module |
COutputHeightVisitor | OutputHeightVisitor exposes the OutputHeight() method of the given module |
COutputParameterVisitor | OutputParameterVisitor exposes the output parameter of the given module |
COutputWidthVisitor | OutputWidthVisitor exposes the OutputWidth() method of the given module |
CParametersSetVisitor | ParametersSetVisitor update the parameters set using the given matrix |
CParametersVisitor | ParametersVisitor exposes the parameters set of the given module and stores the parameters set into the given matrix |
CResetCellVisitor | ResetCellVisitor executes the ResetCell() function |
CResetVisitor | ResetVisitor executes the Reset() function |
CRewardSetVisitor | RewardSetVisitor set the reward parameter given the reward value |
CRunSetVisitor | RunSetVisitor set the run parameter given the run value |
CSaveOutputParameterVisitor | SaveOutputParameterVisitor saves the output parameter into the given parameter set |
CSetInputHeightVisitor | SetInputHeightVisitor updates the input height parameter with the given input height |
CSetInputWidthVisitor | SetInputWidthVisitor updates the input width parameter with the given input width |
CWeightSetVisitor | WeightSetVisitor update the module parameters given the parameters set |
CWeightSizeVisitor | WeightSizeVisitor returns the number of weights of the given module |
CDeleteVisitor | DeleteVisitor deletes the CFType<> object which is pointed to by the variable cf in class CFModel |
CGetValueVisitor | GetValueVisitor returns the pointer which points to the CFType object |
CPredictVisitor< NeighborSearchPolicy, InterpolationPolicy > | PredictVisitor uses the CFType object to make predictions on the given combinations of users and items |
CRecommendationVisitor< NeighborSearchPolicy, InterpolationPolicy > | RecommendationVisitor uses the CFType object to get recommendations for the given users |
CAbsErrorVisitor | AbsErrorVisitor modifies absolute error tolerance for a KDEType |
CBandwidthVisitor | BandwidthVisitor modifies the bandwidth of a KDEType kernel |
CDeleteVisitor | |
CDualBiKDE | DualBiKDE computes a Kernel Density Estimation on the given KDEType |
CDualMonoKDE | DualMonoKDE computes a Kernel Density Estimation on the given KDEType |
CMCBreakCoefVisitor | MCBreakCoefVisitor sets the Monte Carlo break coefficient |
CMCEntryCoefVisitor | MCEntryCoefVisitor sets the Monte Carlo entry coefficient |
CMCProbabilityVisitor | MCProbabilityVisitor sets the Monte Carlo probability for a given KDEType |
CMCSampleSizeVisitor | MCSampleSizeVisitor sets the Monte Carlo intial sample size for a given KDEType |
CModeVisitor | ModeVisitor exposes the Mode() method of the KDEType |
CMonteCarloVisitor | MonteCarloVisitor activates or deactivates Monte Carlo for a given KDEType |
CRelErrorVisitor | RelErrorVisitor modifies relative error tolerance for a KDEType |
CTrainVisitor | TrainVisitor trains a given KDEType using a reference set |
CAlphaVisitor | Exposes the Alpha() method of the given RAType |
CBiSearchVisitor< SortPolicy > | BiSearchVisitor executes a bichromatic neighbor search on the given NSType |
CBiSearchVisitor< SortPolicy > | BiSearchVisitor executes a bichromatic neighbor search on the given NSType |
CDeleteVisitor | DeleteVisitor deletes the given NSType instance |
CDeleteVisitor | DeleteVisitor deletes the given NSType instance |
CEpsilonVisitor | EpsilonVisitor exposes the Epsilon method of the given NSType |
CFirstLeafExactVisitor | Exposes the FirstLeafExact() method of the given RAType |
CMonoSearchVisitor | MonoSearchVisitor executes a monochromatic neighbor search on the given NSType |
CMonoSearchVisitor | MonoSearchVisitor executes a monochromatic neighbor search on the given NSType |
CNaiveVisitor | NaiveVisitor exposes the Naive() method of the given RAType |
CReferenceSetVisitor | ReferenceSetVisitor exposes the referenceSet of the given NSType |
CReferenceSetVisitor | ReferenceSetVisitor exposes the referenceSet of the given NSType |
CSampleAtLeavesVisitor | Exposes the SampleAtLeaves() method of the given RAType |
CSearchModeVisitor | SearchModeVisitor exposes the SearchMode() method of the given NSType |
CSingleModeVisitor | Exposes the SingleMode() method of the given RAType |
CSingleSampleLimitVisitor | Exposes the SingleSampleLimit() method of the given RAType |
CTauVisitor | Exposes the Tau() method of the given RAType |
CTrainVisitor< SortPolicy > | TrainVisitor sets the reference set to a new reference set on the given NSType |
CTrainVisitor< SortPolicy > | TrainVisitor sets the reference set to a new reference set on the given NSType |
CBiSearchVisitor | BiSearchVisitor executes a bichromatic range search on the given RSType |
CDeleteVisitor | DeleteVisitor deletes the given RSType instance |
CMonoSearchVisitor | MonoSearchVisitor executes a monochromatic range search on the given RSType |
CNaiveVisitor | NaiveVisitor exposes the Naive() method of the given RSType |
CReferenceSetVisitor | ReferenceSetVisitor exposes the referenceSet of the given RSType |
CSingleModeVisitor | SingleModeVisitor exposes the SingleMode() method of the given RSType |
CTrainVisitor | TrainVisitor sets the reference set to a new reference set on the given RSType |
CCVBase< MLAlgorithm, arma::mat, typename MetaInfoExtractor< MLAlgorithm, arma::mat >::PredictionsType, typename MetaInfoExtractor< MLAlgorithm, arma::mat, typename MetaInfoExtractor< MLAlgorithm, arma::mat >::PredictionsType >::WeightsType > | |
CFFN< EmptyLoss<>, GaussianInitialization > | |
CFFN< MeanSquaredError<>, GaussianInitialization > | |
►CHMM< distribution::RegressionDistribution > | |
CHMMRegression | A class that represents a Hidden Markov Model Regression (HMMR) |
CHRectBound< metric::EuclideanDistance, ElemType > | |
CHyperplaneBase< MetricType > | |
CInitHMMModel | |
CIsVector< VecType > | If value == true, then VecType is some sort of Armadillo vector or subview |
CIsVector< arma::Col< eT > > | |
CIsVector< arma::Row< eT > > | |
CIsVector< arma::SpCol< eT > > | |
CIsVector< arma::SpRow< eT > > | |
CIsVector< arma::SpSubview< eT > > | |
CIsVector< arma::subview_col< eT > > | |
CIsVector< arma::subview_row< eT > > | |
CLMetric< 2, true > | |
CMetaInfoExtractor< MLAlgorithm, arma::mat > | |
CMetaInfoExtractor< MLAlgorithm, arma::mat, typename MetaInfoExtractor< MLAlgorithm, arma::mat >::PredictionsType > | |
CAdaBoost< WeakLearnerType, MatType > | The AdaBoost class |
CAdaBoostModel | The model to save to disk |
CAMF< TerminationPolicyType, InitializationRuleType, UpdateRuleType > | This class implements AMF (alternating matrix factorization) on the given matrix V |
CAverageInitialization | This initialization rule initializes matrix W and H to root of the average of V, perturbed with uniform noise |
CCompleteIncrementalTermination< TerminationPolicy > | This class acts as a wrapper for basic termination policies to be used by SVDCompleteIncrementalLearning |
CGivenInitialization | This initialization rule for AMF simply fills the W and H matrices with the matrices given to the constructor of this object |
CIncompleteIncrementalTermination< TerminationPolicy > | This class acts as a wrapper for basic termination policies to be used by SVDIncompleteIncrementalLearning |
CMaxIterationTermination | This termination policy only terminates when the maximum number of iterations has been reached |
CMergeInitialization< WInitializationRuleType, HInitializationRuleType > | This initialization rule for AMF simply takes in two initialization rules, and initialize W with the first rule and H with the second rule |
CNMFALSUpdate | This class implements a method titled 'Alternating Least Squares' described in the following paper: |
CNMFMultiplicativeDistanceUpdate | The multiplicative distance update rules for matrices W and H |
CNMFMultiplicativeDivergenceUpdate | This follows a method described in the paper 'Algorithms for Non-negative |
CRandomAcolInitialization< columnsToAverage > | This class initializes the W matrix of the AMF algorithm by averaging p randomly chosen columns of V |
CRandomInitialization | This initialization rule for AMF simply fills the W and H matrices with uniform random noise in [0, 1] |
CSimpleResidueTermination | This class implements a simple residue-based termination policy |
CSimpleToleranceTermination< MatType > | This class implements residue tolerance termination policy |
CSVDBatchLearning | This class implements SVD batch learning with momentum |
CSVDCompleteIncrementalLearning< MatType > | This class computes SVD using complete incremental batch learning, as described in the following paper: |
CSVDCompleteIncrementalLearning< arma::sp_mat > | TODO : Merge this template specialized function for sparse matrix using common row_col_iterator |
CSVDIncompleteIncrementalLearning | This class computes SVD using incomplete incremental batch learning, as described in the following paper: |
CValidationRMSETermination< MatType > | This class implements validation termination policy based on RMSE index |
CAdaptiveMaxPooling< InputDataType, OutputDataType > | Implementation of the AdaptiveMaxPooling layer |
CAdaptiveMeanPooling< InputDataType, OutputDataType > | Implementation of the AdaptiveMeanPooling |
CAdd< InputDataType, OutputDataType > | Implementation of the Add module class |
CAddMerge< InputDataType, OutputDataType, CustomLayers > | Implementation of the AddMerge module class |
CAlphaDropout< InputDataType, OutputDataType > | The alpha - dropout layer is a regularizer that randomly with probability 'ratio' sets input values to alphaDash |
CAtrousConvolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType > | Implementation of the Atrous Convolution class |
CAddTask | Generator of instances of the binary addition task |
CCopyTask | Generator of instances of the binary sequence copy task |
CSortTask | Generator of instances of the sequence sort task |
CBaseLayer< ActivationFunction, InputDataType, OutputDataType > | Implementation of the base layer |
CBatchNorm< InputDataType, OutputDataType > | Declaration of the Batch Normalization layer class |
CBernoulliDistribution< DataType > | Multiple independent Bernoulli distributions |
CBilinearInterpolation< InputDataType, OutputDataType > | Definition and Implementation of the Bilinear Interpolation Layer |
CBinaryRBM | For more information, see the following paper: |
CBRNN< OutputLayerType, MergeLayerType, MergeOutputType, InitializationRuleType, CustomLayers > | Implementation of a standard bidirectional recurrent neural network container |
CCELU< InputDataType, OutputDataType > | The CELU activation function, defined by |
CConcat< InputDataType, OutputDataType, CustomLayers > | Implementation of the Concat class |
CConcatenate< InputDataType, OutputDataType > | Implementation of the Concatenate module class |
CConcatPerformance< OutputLayerType, InputDataType, OutputDataType > | Implementation of the concat performance class |
CConstant< InputDataType, OutputDataType > | Implementation of the constant layer |
CConstInitialization | This class is used to initialize weight matrix with constant values |
CConvolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType > | Implementation of the Convolution class |
CCosineEmbeddingLoss< InputDataType, OutputDataType > | Cosine Embedding Loss function is used for measuring whether two inputs are similar or dissimilar, using the cosine distance, and is typically used for learning nonlinear embeddings or semi-supervised learning |
CCReLU< InputDataType, OutputDataType > | A concatenated ReLU has two outputs, one ReLU and one negative ReLU, concatenated together |
CCrossEntropyError< InputDataType, OutputDataType > | The cross-entropy performance function measures the network's performance according to the cross-entropy between the input and target distributions |
CDCGAN | For more information, see the following paper: |
CDiceLoss< InputDataType, OutputDataType > | The dice loss performance function measures the network's performance according to the dice coefficient between the input and target distributions |
CDropConnect< 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) |
CDropout< 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 |
CEarthMoverDistance< InputDataType, OutputDataType > | The earth mover distance function measures the network's performance according to the Kantorovich-Rubinstein duality approximation |
CElishFunction | The ELiSH function, defined by |
CElliotFunction | The Elliot function, defined by |
CELU< InputDataType, OutputDataType > | The ELU activation function, defined by |
CEmptyLoss< InputDataType, OutputDataType > | The empty loss does nothing, letting the user calculate the loss outside the model |
CFastLSTM< InputDataType, OutputDataType > | An implementation of a faster version of the Fast LSTM network layer |
CFFN< OutputLayerType, InitializationRuleType, CustomLayers > | Implementation of a standard feed forward network |
CFFTConvolution< BorderMode, padLastDim > | Computes the two-dimensional convolution through fft |
CFlexibleReLU< InputDataType, OutputDataType > | The FlexibleReLU activation function, defined by |
CFullConvolution | |
CGAN< Model, InitializationRuleType, Noise, PolicyType > | The implementation of the standard GAN module |
CGaussianFunction | The gaussian function, defined by |
CGaussianInitialization | This class is used to initialize weigth matrix with a gaussian |
CGELUFunction | The GELU function, defined by |
CGlimpse< 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 |
CGlorotInitializationType< Uniform > | This class is used to initialize the weight matrix with the Glorot Initialization method |
CGRU< InputDataType, OutputDataType > | An implementation of a gru network layer |
CHardShrink< InputDataType, OutputDataType > | Hard Shrink operator is defined as, |
CHardSigmoidFunction | The hard sigmoid function, defined by |
CHardTanH< InputDataType, OutputDataType > | The Hard Tanh activation function, defined by |
CHeInitialization | This class is used to initialize weight matrix with the He initialization rule given by He et |
CHighway< InputDataType, OutputDataType, CustomLayers > | Implementation of the Highway layer |
CHingeEmbeddingLoss< InputDataType, OutputDataType > | The Hinge Embedding loss function is often used to compute the loss between y_true and y_pred |
CHuberLoss< InputDataType, OutputDataType > | The Huber loss is a loss function used in robust regression, that is less sensitive to outliers in data than the squared error loss |
CIdentityFunction | The identity function, defined by |
CInitTraits< InitRuleType > | This is a template class that can provide information about various initialization methods |
CInitTraits< KathirvalavakumarSubavathiInitialization > | Initialization traits of the kathirvalavakumar subavath initialization rule |
CInitTraits< NguyenWidrowInitialization > | Initialization traits of the Nguyen-Widrow initialization rule |
CInvQuadFunction | The Inverse Quadratic function, defined by |
CJoin< InputDataType, OutputDataType > | Implementation of the Join module class |
CKathirvalavakumarSubavathiInitialization | This class is used to initialize the weight matrix with the method proposed by T |
CKLDivergence< InputDataType, OutputDataType > | The Kullback–Leibler divergence is often used for continuous distributions (direct regression) |
CL1Loss< InputDataType, OutputDataType > | The L1 loss is a loss function that measures the mean absolute error (MAE) between each element in the input x and target y |
CLayerNorm< InputDataType, OutputDataType > | Declaration of the Layer Normalization class |
CLayerTraits< LayerType > | This is a template class that can provide information about various layers |
CLeakyReLU< InputDataType, OutputDataType > | The LeakyReLU activation function, defined by |
CLecunNormalInitialization | This class is used to initialize weight matrix with the Lecun Normalization initialization rule |
CLinear< InputDataType, OutputDataType, RegularizerType > | Implementation of the Linear layer class |
CLinear3D< InputDataType, OutputDataType, RegularizerType > | Implementation of the Linear3D layer class |
CLinearNoBias< InputDataType, OutputDataType, RegularizerType > | Implementation of the LinearNoBias class |
CLiSHTFunction | The LiSHT function, defined by |
CLogCoshLoss< InputDataType, OutputDataType > | The Log-Hyperbolic-Cosine loss function is often used to improve variational auto encoder |
CLogisticFunction | The logistic function, defined by |
CLogSoftMax< InputDataType, OutputDataType > | Implementation of the log softmax layer |
CLookup< InputDataType, OutputDataType > | The Lookup class stores word embeddings and retrieves them using tokens |
CLRegularizer< TPower > | The L_p regularizer for arbitrary integer p |
CLSTM< InputDataType, OutputDataType > | Implementation of the LSTM module class |
CMarginRankingLoss< InputDataType, OutputDataType > | Margin ranking loss measures the loss given inputs and a label vector with values of 1 or -1 |
CMaxPooling< InputDataType, OutputDataType > | Implementation of the MaxPooling layer |
CMaxPoolingRule | |
CMeanAbsolutePercentageError< InputDataType, OutputDataType > | The mean absolute percentage error performance function measures the network's performance according to the mean of the absolute difference between input and target divided by target |
CMeanBiasError< InputDataType, OutputDataType > | The mean bias error performance function measures the network's performance according to the mean of errors |
CMeanPooling< InputDataType, OutputDataType > | Implementation of the MeanPooling |
CMeanPoolingRule | |
CMeanSquaredError< InputDataType, OutputDataType > | The mean squared error performance function measures the network's performance according to the mean of squared errors |
CMeanSquaredLogarithmicError< InputDataType, OutputDataType > | The mean squared logarithmic error performance function measures the network's performance according to the mean of squared logarithmic errors |
CMiniBatchDiscrimination< InputDataType, OutputDataType > | Implementation of the MiniBatchDiscrimination layer |
CMishFunction | The Mish function, defined by |
CMultiheadAttention< InputDataType, OutputDataType, RegularizerType > | Multihead Attention allows the model to jointly attend to information from different representation subspaces at different positions |
CMultiplyConstant< InputDataType, OutputDataType > | Implementation of the multiply constant layer |
CMultiplyMerge< InputDataType, OutputDataType, CustomLayers > | Implementation of the MultiplyMerge module class |
CMultiQuadFunction | The Multi Quadratic function, defined by |
CNaiveConvolution< BorderMode > | Computes the two-dimensional convolution |
CNegativeLogLikelihood< InputDataType, OutputDataType > | Implementation of the negative log likelihood layer |
CNetworkInitialization< InitializationRuleType, CustomLayers > | This class is used to initialize the network with the given initialization rule |
CNguyenWidrowInitialization | This class is used to initialize the weight matrix with the Nguyen-Widrow method |
CNoisyLinear< InputDataType, OutputDataType > | Implementation of the NoisyLinear layer class |
CNoRegularizer | Implementation of the NoRegularizer |
CNormalDistribution< DataType > | Implementation of the Normal Distribution function |
COivsInitialization< ActivationFunction > | This class is used to initialize the weight matrix with the oivs method |
COrthogonalInitialization | This class is used to initialize the weight matrix with the orthogonal matrix initialization |
COrthogonalRegularizer | Implementation of the OrthogonalRegularizer |
CPadding< InputDataType, OutputDataType > | Implementation of the Padding module class |
CPoisson1Function | The Poisson one function, defined by |
CPoissonNLLLoss< InputDataType, OutputDataType > | Implementation of the Poisson negative log likelihood loss |
CPositionalEncoding< InputDataType, OutputDataType > | Positional Encoding injects some information about the relative or absolute position of the tokens in the sequence |
CPReLU< InputDataType, OutputDataType > | The PReLU activation function, defined by (where alpha is trainable) |
CQuadraticFunction | The Quadratic function, defined by |
CRandomInitialization | This class is used to initialize randomly the weight matrix |
CRBF< InputDataType, OutputDataType, Activation > | Implementation of the Radial Basis Function layer |
CRBM< InitializationRuleType, DataType, PolicyType > | The implementation of the RBM module |
CReconstructionLoss< InputDataType, OutputDataType, DistType > | The reconstruction loss performance function measures the network's performance equal to the negative log probability of the target with the input distribution |
CRectifierFunction | The rectifier function, defined by |
CRecurrent< InputDataType, OutputDataType, CustomLayers > | Implementation of the RecurrentLayer class |
CRecurrentAttention< InputDataType, OutputDataType > | This class implements the Recurrent Model for Visual Attention, using a variety of possible layer implementations |
CReinforceNormal< InputDataType, OutputDataType > | Implementation of the reinforce normal layer |
CReparametrization< InputDataType, OutputDataType > | Implementation of the Reparametrization layer class |
CRNN< OutputLayerType, InitializationRuleType, CustomLayers > | Implementation of a standard recurrent neural network container |
CSelect< InputDataType, OutputDataType > | The select module selects the specified column from a given input matrix |
CSequential< InputDataType, OutputDataType, Residual, CustomLayers > | Implementation of the Sequential class |
CSigmoidCrossEntropyError< InputDataType, OutputDataType > | The SigmoidCrossEntropyError performance function measures the network's performance according to the cross-entropy function between the input and target distributions |
CSoftMarginLoss< InputDataType, OutputDataType > | |
CSoftmax< InputDataType, OutputDataType > | Implementation of the Softmax layer |
CSoftmin< InputDataType, OutputDataType > | Implementation of the Softmin layer |
CSoftplusFunction | The softplus function, defined by |
CSoftShrink< InputDataType, OutputDataType > | Soft Shrink operator is defined as, |
CSoftsignFunction | The softsign function, defined by |
CSpatialDropout< InputDataType, OutputDataType > | Implementation of the SpatialDropout layer |
CSpikeSlabRBM | For more information, see the following paper: |
CSplineFunction | The Spline function, defined by |
CStandardGAN | For more information, see the following paper: |
CSubview< InputDataType, OutputDataType > | Implementation of the subview layer |
CSVDConvolution< BorderMode > | Computes the two-dimensional convolution using singular value decomposition |
CSwishFunction | The swish function, defined by |
CTanhFunction | The tanh function, defined by |
CTransposedConvolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType > | Implementation of the Transposed Convolution class |
CValidConvolution | |
CVirtualBatchNorm< InputDataType, OutputDataType > | Declaration of the VirtualBatchNorm layer class |
CVRClassReward< InputDataType, OutputDataType > | Implementation of the variance reduced classification reinforcement layer |
CWeightNorm< InputDataType, OutputDataType, CustomLayers > | Declaration of the WeightNorm layer class |
CWGAN | For more information, see the following paper: |
CWGANGP | For more information, see the following paper: |
CBacktrace | Provides a backtrace |
CCLIOption< N > | A static object whose constructor registers a parameter with the IO class |
CParameterType< T > | Utility struct to return the type that CLI11 should accept for a given input type |
CParameterType< arma::Col< eT > > | For vector types, CLI11 will accept a std::string, not an arma::Col<eT> (since it is not clear how to specify a vector on the command-line) |
CParameterType< arma::Mat< eT > > | For matrix types, CLI11 will accept a std::string, not an arma::mat (since it is not clear how to specify a matrix on the command-line) |
CParameterType< arma::Row< eT > > | For row vector types, CLI11 will accept a std::string, not an arma::Row<eT> (since it is not clear how to specify a vector on the command-line) |
CParameterType< std::tuple< mlpack::data::DatasetMapper< PolicyType, std::string >, arma::Mat< eT > > > | For matrix+dataset info types, we should accept a std::string |
CParameterTypeDeducer< HasSerialize, T > | |
CParameterTypeDeducer< true, T > | |
CGoOption< T > | The Go option class |
CJuliaOption< T > | The Julia option class |
CBindingInfo | Used by the Markdown documentation generator to store multiple documentation objects, indexed by both the binding name (i.e |
CExampleWrapper | |
CLongDescriptionWrapper | |
CMDOption< T > | The Markdown option class |
CProgramNameWrapper | |
CSeeAlsoWrapper | |
CShortDescriptionWrapper | |
CPyOption< T > | The Python option class |
CROption< T > | The R option class |
CTestOption< N > | A static object whose constructor registers a parameter with the IO class |
CBallBound< MetricType, VecType > | Ball bound encloses a set of points at a specific distance (radius) from a specific point (center) |
CBoundTraits< BoundType > | A class to obtain compile-time traits about BoundType classes |
CBoundTraits< BallBound< MetricType, VecType > > | A specialization of BoundTraits for this bound type |
CBoundTraits< CellBound< MetricType, ElemType > > | |
CBoundTraits< HollowBallBound< MetricType, ElemType > > | A specialization of BoundTraits for this bound type |
CBoundTraits< HRectBound< MetricType, ElemType > > | |
CCellBound< MetricType, ElemType > | The CellBound class describes a bound that consists of a number of hyperrectangles |
CHollowBallBound< 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) |
CHRectBound< MetricType, ElemType > | Hyper-rectangle bound for an L-metric |
CIsLMetric< MetricType > | Utility struct where Value is true if and only if the argument is of type LMetric |
CIsLMetric< metric::LMetric< Power, TakeRoot > > | Specialization for IsLMetric when the argument is of type LMetric |
CAverageInterpolation | This class performs average interpolation to generate interpolation weights for neighborhood-based collaborative filtering |
CBatchSVDPolicy | Implementation of the Batch SVD policy to act as a wrapper when accessing Batch SVD from within CFType |
CBiasSVDPolicy | Implementation of the Bias SVD policy to act as a wrapper when accessing Bias SVD from within CFType |
CCFModel | The model to save to disk |
CCFType< DecompositionPolicy, NormalizationType > | This class implements Collaborative Filtering (CF) |
CCombinedNormalization< NormalizationTypes > | This normalization class performs a sequence of normalization methods on raw ratings |
CCosineSearch | Nearest neighbor search with cosine distance |
CDummyClass | This class acts as a dummy class for passing as template parameter |
CItemMeanNormalization | This normalization class performs item mean normalization on raw ratings |
CLMetricSearch< TPower > | Nearest neighbor search with L_p distance |
CNMFPolicy | Implementation of the NMF policy to act as a wrapper when accessing NMF from within CFType |
CNoNormalization | This normalization class doesn't perform any normalization |
COverallMeanNormalization | This normalization class performs overall mean normalization on raw ratings |
CPearsonSearch | Nearest neighbor search with pearson distance (or furthest neighbor search with pearson correlation) |
CRandomizedSVDPolicy | Implementation of the Randomized SVD policy to act as a wrapper when accessing Randomized SVD from within CFType |
CRegressionInterpolation | Implementation of regression-based interpolation method |
CRegSVDPolicy | Implementation of the Regularized SVD policy to act as a wrapper when accessing Regularized SVD from within CFType |
CSimilarityInterpolation | With SimilarityInterpolation, interpolation weights are based on similarities between query user and its neighbors |
CSVDCompletePolicy | Implementation of the SVD complete incremental policy to act as a wrapper when accessing SVD complete decomposition from within CFType |
CSVDIncompletePolicy | Implementation of the SVD incomplete incremental to act as a wrapper when accessing SVD incomplete incremental from within CFType |
CSVDPlusPlusPolicy | Implementation of the SVDPlusPlus policy to act as a wrapper when accessing SVDPlusPlus from within CFType |
CSVDWrapper< Factorizer > | This class acts as the wrapper for all SVD factorizers which are incompatible with CF module |
CUserMeanNormalization | This normalization class performs user mean normalization on raw ratings |
CZScoreNormalization | This normalization class performs z-score normalization on raw ratings |
CAccuracy | The 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 |
CCVBase< MLAlgorithm, MatType, PredictionsType, WeightsType > | An auxiliary class for cross-validation |
CF1< AS, PositiveClass > | F1 is a metric of performance for classification algorithms that for binary classification is equal to |
CKFoldCV< MLAlgorithm, Metric, MatType, PredictionsType, WeightsType > | The class KFoldCV implements k-fold cross-validation for regression and classification algorithms |
CMetaInfoExtractor< MLAlgorithm, MT, PT, WT > | MetaInfoExtractor is a tool for extracting meta information about a given machine learning algorithm |
CMSE | The 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 |
CNotFoundMethodForm | |
CPrecision< AS, PositiveClass > | Precision is a metric of performance for classification algorithms that for binary classification is equal to , where and are the numbers of true positives and false positives respectively |
CR2Score | The R2 Score is a metric of performance for regression algorithms that represents the proportion of variance (here y) that has been explained by the independent variables in the model |
CRecall< AS, PositiveClass > | Recall is a metric of performance for classification algorithms that for binary classification is equal to , where and are the numbers of true positives and false negatives respectively |
CSelectMethodForm< MLAlgorithm, HMFs > | A type function that selects a right method form |
CSelectMethodForm< MLAlgorithm > | |
CSelectMethodForm< MLAlgorithm >::From< Forms > | |
CSelectMethodForm< MLAlgorithm, HasMethodForm, HMFs... > | |
CSelectMethodForm< MLAlgorithm, HasMethodForm, HMFs... >::From< Forms > | |
CSilhouetteScore | The Silhouette Score is a metric of performance for clustering that represents the quality of clusters made as a result |
CSimpleCV< 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 |
CTrainForm< MatType, PredictionsType, WeightsType, DatasetInfo, NumClasses > | A wrapper struct for holding a Train form |
CTrainFormBase4< PT, WT, T1, T2 > | |
CTrainFormBase5< PT, WT, T1, T2, T3 > | |
CTrainFormBase6< PT, WT, T1, T2, T3, T4 > | |
CTrainFormBase7< PT, WT, T1, T2, T3, T4, T5 > | |
CBagOfWordsEncodingPolicy | Definition of the BagOfWordsEncodingPolicy class |
CCharExtract | The class is used to split a string into characters |
CCustomImputation< T > | A simple custom imputation class |
CDatasetMapper< PolicyType, InputType > | Auxiliary information for a dataset, including mappings to/from strings (or other types) and the datatype of each dimension |
CDictionaryEncodingPolicy | DicitonaryEnocdingPolicy is used as a helper class for StringEncoding |
CHasSerialize< T > | |
CHasSerialize< T >::check< U, V, W > | |
CHasSerializeFunction< T > | |
CImageInfo | Implements meta-data of images required by data::Load and data::Save for loading and saving images into arma::Mat |
CImputer< T, MapperType, StrategyType > | Given a dataset of a particular datatype, replace user-specified missing value with a variable dependent on the StrategyType and MapperType |
CIncrementPolicy | IncrementPolicy is used as a helper class for DatasetMapper |
CListwiseDeletion< T > | A complete-case analysis to remove the values containing mappedValue |
CLoadCSV | Load 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 |
CMaxAbsScaler | A simple MaxAbs Scaler class |
CMeanImputation< T > | A simple mean imputation class |
CMeanNormalization | A simple Mean Normalization class |
CMedianImputation< T > | This is a class implementation of simple median imputation |
CMinMaxScaler | A simple MinMax Scaler class |
CMissingPolicy | MissingPolicy is used as a helper class for DatasetMapper |
CPCAWhitening | A simple PCAWhitening class |
CScalingModel | The model to save to disk |
CSplitByAnyOf | Tokenizes a string using a set of delimiters |
CStandardScaler | A simple Standard Scaler class |
CStringEncoding< EncodingPolicyType, DictionaryType > | The class translates a set of strings into numbers using various encoding algorithms |
CStringEncodingDictionary< Token > | This class provides a dictionary interface for the purpose of string encoding |
CStringEncodingDictionary< boost::string_view > | |
CStringEncodingDictionary< int > | |
CStringEncodingPolicyTraits< PolicyType > | This is a template struct that provides some information about various encoding policies |
CStringEncodingPolicyTraits< DictionaryEncodingPolicy > | The specialization provides some information about the dictionary encoding policy |
CTfIdfEncodingPolicy | Definition of the TfIdfEncodingPolicy class |
CZCAWhitening | A simple ZCAWhitening class |
CDBSCAN< RangeSearchType, PointSelectionPolicy > | DBSCAN (Density-Based Spatial Clustering of Applications with Noise) is a clustering technique described in the following paper: |
COrderedPointSelection | This class can be used to sequentially select the next point to use for DBSCAN |
CRandomPointSelection | This class can be used to randomly select the next point to use for DBSCAN |
CDecisionStump< MatType > | This class implements a decision stump |
CDTree< MatType, TagType > | A density estimation tree is similar to both a decision tree and a space partitioning tree (like a kd-tree) |
CPathCacher | This class is responsible for caching the path to each node of the tree |
CDiagonalGaussianDistribution | A single multivariate Gaussian distribution with diagonal covariance |
CDiscreteDistribution | A discrete distribution where the only observations are discrete observations |
CGammaDistribution | This class represents the Gamma distribution |
CGaussianDistribution | A single multivariate Gaussian distribution |
CLaplaceDistribution | The multivariate Laplace distribution centered at 0 has pdf |
CRegressionDistribution | A class that represents a univariate conditionally Gaussian distribution |
CDTBRules< MetricType, TreeType > | |
CDTBStat | A statistic for use with mlpack trees, which stores the upper bound on distance to nearest neighbors and the component which this node belongs to |
CDualTreeBoruvka< MetricType, MatType, TreeType > | Performs the MST calculation using the Dual-Tree Boruvka algorithm, using any type of tree |
CEdgePair | An edge pair is simply two indices and a distance |
CUnionFind | A Union-Find data structure |
CFastMKS< KernelType, MatType, TreeType > | An implementation of fast exact max-kernel search |
CFastMKSModel | A utility struct to contain all the possible FastMKS models, for use by the mlpack_fastmks program |
CFastMKSRules< KernelType, TreeType > | The FastMKSRules class is a template helper class used by FastMKS class when performing exact max-kernel search |
CFastMKSStat | The statistic used in trees with FastMKS |
CDiagonalConstraint | Force a covariance matrix to be diagonal |
CDiagonalGMM | A Diagonal Gaussian Mixture Model |
CEigenvalueRatioConstraint | Given a vector of eigenvalue ratios, ensure that the covariance matrix always has those eigenvalue ratios |
CEMFit< InitialClusteringType, CovarianceConstraintPolicy, Distribution > | This class contains methods which can fit a GMM to observations using the EM algorithm |
CGMM | A Gaussian Mixture Model (GMM) |
CNoConstraint | This class enforces no constraint on the covariance matrix |
CPositiveDefiniteConstraint | Given a covariance matrix, force the matrix to be positive definite |
CHMM< Distribution > | A class that represents a Hidden Markov Model with an arbitrary type of emission distribution |
CHMMModel | A serializable HMM model that also stores the type |
CCVFunction< 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 |
CDeduceHyperParameterTypes< Args > | A type function for deducing types of hyper-parameters from types of arguments in the Optimize method in HyperParameterTuner |
CDeduceHyperParameterTypes< Args >::ResultHolder< HPTypes > | |
CDeduceHyperParameterTypes< 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 |
CDeduceHyperParameterTypes< PreFixedArg< T >, Args... >::ResultHolder< HPTypes > | |
CDeduceHyperParameterTypes< 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 |
CDeduceHyperParameterTypes< T, Args... >::IsCollectionType< Type > | A type function to check whether Type is a collection type (for that it should define value_type) |
CDeduceHyperParameterTypes< T, Args... >::ResultHolder< HPTypes > | |
CDeduceHyperParameterTypes< T, Args... >::ResultHPType< ArgumentType, IsArithmetic > | A type function to deduce the result hyper-parameter type for ArgumentType |
CDeduceHyperParameterTypes< T, Args... >::ResultHPType< ArithmeticType, true > | |
CDeduceHyperParameterTypes< T, Args... >::ResultHPType< CollectionType, false > | |
CFixedArg< T, I > | A struct for storing information about a fixed argument |
CHyperParameterTuner< 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 |
CIsPreFixedArg< T > | A type function for checking whether the given type is PreFixedArg |
CPreFixedArg< T > | A struct for marking arguments as ones that should be fixed (it can be useful for the Optimize method of HyperParameterTuner) |
CPreFixedArg< T & > | The specialization of the template for references |
CIO | Parses the command line for parameters and holds user-specified parameters |
CKDE< KernelType, MetricType, MatType, TreeType, DualTreeTraversalType, SingleTreeTraversalType > | The KDE class is a template class for performing Kernel Density Estimations |
CKDECleanRules< TreeType > | A dual-tree traversal Rules class for cleaning used trees before performing kernel density estimation |
CKDEDefaultParams | KDEDefaultParams contains the default input parameter values for KDE |
CKDEModel | |
CKDERules< MetricType, KernelType, TreeType > | A dual-tree traversal Rules class for kernel density estimation |
CKDEStat | Extra data for each node in the tree for the task of kernel density estimation |
CKernelNormalizer | KernelNormalizer holds a set of methods to normalize estimations applying in each case the appropiate kernel normalizer function |
CCauchyKernel | The Cauchy kernel |
CCosineDistance | The cosine distance (or cosine similarity) |
CEpanechnikovKernel | The Epanechnikov kernel, defined as |
CExampleKernel | An example kernel function |
CGaussianKernel | The standard Gaussian kernel |
CHyperbolicTangentKernel | Hyperbolic tangent kernel |
CKernelTraits< KernelType > | This is a template class that can provide information about various kernels |
CKernelTraits< CauchyKernel > | Kernel traits for the Cauchy kernel |
CKernelTraits< CosineDistance > | Kernel traits for the cosine distance |
CKernelTraits< EpanechnikovKernel > | Kernel traits for the Epanechnikov kernel |
CKernelTraits< GaussianKernel > | Kernel traits for the Gaussian kernel |
CKernelTraits< LaplacianKernel > | Kernel traits of the Laplacian kernel |
CKernelTraits< SphericalKernel > | Kernel traits for the spherical kernel |
CKernelTraits< TriangularKernel > | Kernel traits for the triangular kernel |
CKMeansSelection< ClusteringType, maxIterations > | Implementation of the kmeans sampling scheme |
CLaplacianKernel | The standard Laplacian kernel |
CLinearKernel | The simple linear kernel (dot product) |
CNystroemMethod< KernelType, PointSelectionPolicy > | |
COrderedSelection | |
CPolynomialKernel | The simple polynomial kernel |
CPSpectrumStringKernel | The p-spectrum string kernel |
CRandomSelection | |
CSphericalKernel | The spherical kernel, which is 1 when the distance between the two argument points is less than or equal to the bandwidth, or 0 otherwise |
CTriangularKernel | The trivially simple triangular kernel, defined by |
CAllowEmptyClusters | Policy which allows K-Means to create empty clusters without any error being reported |
CDualTreeKMeans< 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 |
CDualTreeKMeansRules< MetricType, TreeType > | |
CElkanKMeans< MetricType, MatType > | |
CHamerlyKMeans< MetricType, MatType > | |
CKillEmptyClusters | Policy which allows K-Means to "kill" empty clusters without any error being reported |
CKMeans< MetricType, InitialPartitionPolicy, EmptyClusterPolicy, LloydStepType, MatType > | This class implements K-Means clustering, using a variety of possible implementations of Lloyd's algorithm |
CMaxVarianceNewCluster | When an empty cluster is detected, this class takes the point furthest from the centroid of the cluster with maximum variance as a new cluster |
CNaiveKMeans< MetricType, MatType > | This is an implementation of a single iteration of Lloyd's algorithm for k-means |
CPellegMooreKMeans< MetricType, MatType > | An implementation of Pelleg-Moore's 'blacklist' algorithm for k-means clustering |
CPellegMooreKMeansRules< MetricType, TreeType > | The rules class for the single-tree Pelleg-Moore kd-tree traversal for k-means clustering |
CPellegMooreKMeansStatistic | A 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) |
CRandomPartition | A very simple partitioner which partitions the data randomly into the number of desired clusters |
CRefinedStart | A refined approach for choosing initial points for k-means clustering |
CSampleInitialization | |
CKernelPCA< KernelType, KernelRule > | This class performs kernel principal components analysis (Kernel PCA), for a given kernel |
CNaiveKernelRule< KernelType > | |
CNystroemKernelRule< KernelType, PointSelectionPolicy > | |
CLocalCoordinateCoding | An 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 |
CConstraints< MetricType > | Interface for generating distance based constraints on a given dataset, provided corresponding true labels and a quantity parameter (k) are specified |
CLMNN< MetricType, OptimizerType > | An implementation of Large Margin nearest neighbor metric learning technique |
CLMNNFunction< MetricType > | The Large Margin Nearest Neighbors function |
CLog | Provides a convenient way to give formatted output |
CColumnsToBlocks | Transform the columns of the given matrix into a block format |
CRangeType< T > | Simple real-valued range |
CMatrixCompletion | This class implements the popular nuclear norm minimization heuristic for matrix completion problems |
CMeanShift< UseKernel, KernelType, MatType > | This class implements mean shift clustering |
CBLEU< ElemType, PrecisionType > | BLEU, or the Bilingual Evaluation Understudy, is an algorithm for evaluating the quality of text which has been machine translated from one natural language to another |
CIoU< UseCoordinates > | Definition of Intersection over Union metric |
CIPMetric< 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: |
CLMetric< TPower, TTakeRoot > | The L_p metric for arbitrary integer p, with an option to take the root |
CMahalanobisDistance< TakeRoot > | The Mahalanobis distance, which is essentially a stretched Euclidean distance |
CNMS< UseCoordinates > | Definition of Non Maximal Supression |
CMVU | Meant to provide a good abstraction for users |
CNaiveBayesClassifier< ModelMatType > | The simple Naive Bayes classifier |
CNCA< MetricType, OptimizerType > | An implementation of Neighborhood Components Analysis, both a linear dimensionality reduction technique and a distance learning technique |
CSoftmaxErrorFunction< MetricType > | The "softmax" stochastic neighbor assignment probability function |
CDrusillaSelect< MatType > | |
CFurthestNS | This class implements the necessary methods for the SortPolicy template parameter of the NeighborSearch class |
CLSHSearch< SortPolicy, MatType > | 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 |
CNearestNS | This class implements the necessary methods for the SortPolicy template parameter of the NeighborSearch class |
CNeighborSearch< SortPolicy, MetricType, MatType, TreeType, DualTreeTraversalType, SingleTreeTraversalType > | The NeighborSearch class is a template class for performing distance-based neighbor searches |
CNeighborSearchRules< SortPolicy, MetricType, TreeType > | The NeighborSearchRules class is a template helper class used by NeighborSearch class when performing distance-based neighbor searches |
CNeighborSearchRules< SortPolicy, MetricType, TreeType >::CandidateCmp | Compare two candidates based on the distance |
CNeighborSearchStat< SortPolicy > | Extra data for each node in the tree |
CNSModel< 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 |
CQDAFN< MatType > | |
CRAModel< 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 |
CRAQueryStat< SortPolicy > | Extra data for each node in the tree |
CRASearch< SortPolicy, MetricType, MatType, TreeType > | The RASearch class: This class provides a generic manner to perform rank-approximate search via random-sampling |
CRASearchRules< SortPolicy, MetricType, TreeType > | The RASearchRules class is a template helper class used by RASearch class when performing rank-approximate search via random-sampling |
CRAUtil | |
CSparseAutoencoder | A 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 |
CSparseAutoencoderFunction | This is a class for the sparse autoencoder objective function |
CExactSVDPolicy | Implementation of the exact SVD policy |
CPCA< DecompositionPolicy > | This class implements principal components analysis (PCA) |
CQUICSVDPolicy | Implementation of the QUIC-SVD policy |
CRandomizedBlockKrylovSVDPolicy | Implementation of the randomized block krylov SVD policy |
CRandomizedSVDPolicy | Implementation of the randomized SVD policy |
CPerceptron< LearnPolicy, WeightInitializationPolicy, MatType > | This class implements a simple perceptron (i.e., a single layer neural network) |
CRandomInitialization | This class is used to initialize weights for the weightVectors matrix in a random manner |
CSimpleWeightUpdate | |
CZeroInitialization | This class is used to initialize the matrix weightVectors to zero |
CRadical | An implementation of RADICAL, an algorithm for independent component analysis (ICA) |
CRangeSearch< MetricType, MatType, TreeType > | The RangeSearch class is a template class for performing range searches |
CRangeSearchRules< MetricType, TreeType > | The RangeSearchRules class is a template helper class used by RangeSearch class when performing range searches |
CRangeSearchStat | Statistic class for RangeSearch, to be set to the StatisticType of the tree type that range search is being performed with |
CRSModel | |
CBayesianLinearRegression | A Bayesian approach to the maximum likelihood estimation of the parameters of the linear regression model |
CLARS | An implementation of LARS, a stage-wise homotopy-based algorithm for l1-regularized linear regression (LASSO) and l1+l2 regularized linear regression (Elastic Net) |
CLinearRegression | A simple linear regression algorithm using ordinary least squares |
CLogisticRegression< MatType > | The LogisticRegression class implements an L2-regularized logistic regression model, and supports training with multiple optimizers and classification |
CLogisticRegressionFunction< MatType > | The log-likelihood function for the logistic regression objective function |
CSoftmaxRegression | Softmax Regression is a classifier which can be used for classification when the data available can take two or more class values |
CSoftmaxRegressionFunction | |
CAcrobot | Implementation of Acrobot game |
CAcrobot::Action | |
CAcrobot::State | |
CAggregatedPolicy< PolicyType > | |
CAsyncLearning< WorkerType, EnvironmentType, NetworkType, UpdaterType, PolicyType > | Wrapper of various asynchronous learning algorithms, e.g |
CCartPole | Implementation of Cart Pole task |
CCartPole::Action | Implementation of action of Cart Pole |
CCartPole::State | Implementation of the state of Cart Pole |
CCategoricalDQN< OutputLayerType, InitType, NetworkType > | Implementation of the Categorical Deep Q-Learning network |
CContinuousActionEnv | To use the dummy environment, one may start by specifying the state and action dimensions |
CContinuousActionEnv::Action | Implementation of continuous action |
CContinuousActionEnv::State | Implementation of state of the dummy environment |
CContinuousDoublePoleCart | Implementation of Continuous Double Pole Cart Balancing task |
CContinuousDoublePoleCart::Action | Implementation of action of Continuous Double Pole Cart |
CContinuousDoublePoleCart::State | Implementation of the state of Continuous Double Pole Cart |
CContinuousMountainCar | Implementation of Continuous Mountain Car task |
CContinuousMountainCar::Action | Implementation of action of Continuous Mountain Car |
CContinuousMountainCar::State | Implementation of state of Continuous Mountain Car |
CDiscreteActionEnv | To use the dummy environment, one may start by specifying the state and action dimensions |
CDiscreteActionEnv::Action | Implementation of discrete action |
CDiscreteActionEnv::State | Implementation of state of the dummy environment |
CDoublePoleCart | Implementation of Double Pole Cart Balancing task |
CDoublePoleCart::Action | Implementation of action of Double Pole Cart |
CDoublePoleCart::State | Implementation of the state of Double Pole Cart |
CDuelingDQN< OutputLayerType, InitType, CompleteNetworkType, FeatureNetworkType, AdvantageNetworkType, ValueNetworkType > | Implementation of the Dueling Deep Q-Learning network |
CGreedyPolicy< EnvironmentType > | Implementation for epsilon greedy policy |
CMountainCar | Implementation of Mountain Car task |
CMountainCar::Action | Implementation of action of Mountain Car |
CMountainCar::State | Implementation of state of Mountain Car |
CNStepQLearningWorker< EnvironmentType, NetworkType, UpdaterType, PolicyType > | Forward declaration of NStepQLearningWorker |
COneStepQLearningWorker< EnvironmentType, NetworkType, UpdaterType, PolicyType > | Forward declaration of OneStepQLearningWorker |
COneStepSarsaWorker< EnvironmentType, NetworkType, UpdaterType, PolicyType > | Forward declaration of OneStepSarsaWorker |
CPendulum | Implementation of Pendulum task |
CPendulum::Action | Implementation of action of Pendulum |
CPendulum::State | Implementation of state of Pendulum |
CPrioritizedReplay< EnvironmentType > | Implementation of prioritized experience replay |
CPrioritizedReplay< EnvironmentType >::Transition | |
CQLearning< EnvironmentType, NetworkType, UpdaterType, PolicyType, ReplayType > | Implementation of various Q-Learning algorithms, such as DQN, double DQN |
CRandomReplay< EnvironmentType > | Implementation of random experience replay |
CRandomReplay< EnvironmentType >::Transition | |
CRewardClipping< EnvironmentType > | Interface for clipping the reward to some value between the specified maximum and minimum value (Clipping here is implemented as .) |
CSAC< EnvironmentType, QNetworkType, PolicyNetworkType, UpdaterType, ReplayType > | Implementation of Soft Actor-Critic, a model-free off-policy actor-critic based deep reinforcement learning algorithm |
CSimpleDQN< OutputLayerType, InitType, NetworkType > | |
CSumTree< T > | Implementation of SumTree |
CTrainingConfig | |
CMethodFormDetector< Class, MethodForm, AdditionalArgsCount > | |
CMethodFormDetector< Class, MethodForm, 0 > | |
CMethodFormDetector< Class, MethodForm, 1 > | |
CMethodFormDetector< Class, MethodForm, 2 > | |
CMethodFormDetector< Class, MethodForm, 3 > | |
CMethodFormDetector< Class, MethodForm, 4 > | |
CMethodFormDetector< Class, MethodForm, 5 > | |
CMethodFormDetector< Class, MethodForm, 6 > | |
CMethodFormDetector< Class, MethodForm, 7 > | |
CDataDependentRandomInitializer | A data-dependent random dictionary initializer for SparseCoding |
CNothingInitializer | A 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() |
CRandomInitializer | A DictionaryInitializer for use with the SparseCoding class |
CSparseCoding | An 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) |
CBiasSVD< OptimizerType > | Bias SVD is an improvement on Regularized SVD which is a matrix factorization techniques |
CBiasSVDFunction< MatType > | This class contains methods which are used to calculate the cost of BiasSVD's objective function, to calculate gradient of parameters with respect to the objective function, etc |
CQUIC_SVD | QUIC-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) |
CRandomizedBlockKrylovSVD | Randomized 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" |
CRandomizedSVD | Randomized 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" |
CRegularizedSVD< 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 |
CRegularizedSVDFunction< 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 |
CSVDPlusPlus< OptimizerType > | SVD++ is a matrix decomposition tenique used in collaborative filtering |
CSVDPlusPlusFunction< MatType > | This class contains methods which are used to calculate the cost of SVD++'s objective function, to calculate gradient of parameters with respect to the objective function, etc |
CLinearSVM< MatType > | The LinearSVM class implements an L2-regularized support vector machine model, and supports training with multiple optimizers and classification |
CLinearSVMFunction< MatType > | The hinge loss function for the linear SVM objective function |
CTimer | The timer class provides a way for mlpack methods to be timed |
CTimers | |
CAllCategoricalSplit< FitnessFunction > | The AllCategoricalSplit is a splitting function that will split categorical features into many children: one child for each category |
CAllCategoricalSplit< FitnessFunction >::AuxiliarySplitInfo< ElemType > | |
CAllDimensionSelect | This dimension selection policy allows any dimension to be selected for splitting |
CAxisParallelProjVector | AxisParallelProjVector defines an axis-parallel projection vector |
CBestBinaryNumericSplit< FitnessFunction > | The BestBinaryNumericSplit is a splitting function for decision trees that will exhaustively search a numeric dimension for the best binary split |
CBestBinaryNumericSplit< FitnessFunction >::AuxiliarySplitInfo< ElemType > | |
CBinaryNumericSplit< FitnessFunction, ObservationType > | The BinaryNumericSplit class implements the numeric feature splitting strategy devised by Gama, Rocha, and Medas in the following paper: |
CBinaryNumericSplitInfo< ObservationType > | |
CBinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType > | A binary space partitioning tree, such as a KD-tree or a ball tree |
CBinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType >::BreadthFirstDualTreeTraverser< RuleType > | |
CBinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType >::DualTreeTraverser< RuleType > | A dual-tree traverser for binary space trees; see dual_tree_traverser.hpp |
CBinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType >::SingleTreeTraverser< RuleType > | A single-tree traverser for binary space trees; see single_tree_traverser.hpp for implementation |
CCategoricalSplitInfo | |
CCompareCosineNode | |
CCosineTree | |
CCoverTree< MetricType, StatisticType, MatType, RootPointPolicy > | A cover tree is a tree specifically designed to speed up nearest-neighbor computation in high-dimensional spaces |
CCoverTree< MetricType, StatisticType, MatType, RootPointPolicy >::DualTreeTraverser< RuleType > | A dual-tree cover tree traverser; see dual_tree_traverser.hpp |
CCoverTree< MetricType, StatisticType, MatType, RootPointPolicy >::SingleTreeTraverser< RuleType > | A single-tree cover tree traverser; see single_tree_traverser.hpp for implementation |
CDiscreteHilbertValue< TreeElemType > | The DiscreteHilbertValue class stores Hilbert values for all of the points in a RectangleTree node, and calculates Hilbert values for new points |
CEmptyStatistic | Empty statistic if you are not interested in storing statistics in your tree |
CExampleTree< 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 |
CFirstPointIsRoot | This class is meant to be used as a choice for the policy class RootPointPolicy of the CoverTree class |
CGiniGain | The Gini gain, a measure of set purity usable as a fitness function (FitnessFunction) for decision trees |
CGiniImpurity | |
CGreedySingleTreeTraverser< TreeType, RuleType > | |
CHilbertRTreeAuxiliaryInformation< TreeType, HilbertValueType > | |
CHilbertRTreeDescentHeuristic | This class chooses the best child of a node in a Hilbert R tree when inserting a new point |
CHilbertRTreeSplit< splitOrder > | The splitting procedure for the Hilbert R tree |
CHoeffdingCategoricalSplit< FitnessFunction > | This is the standard Hoeffding-bound categorical feature proposed in the paper below: |
CHoeffdingInformationGain | |
CHoeffdingNumericSplit< FitnessFunction, ObservationType > | The HoeffdingNumericSplit class implements the numeric feature splitting strategy alluded to by Domingos and Hulten in the following paper: |
CHoeffdingTree< FitnessFunction, NumericSplitType, CategoricalSplitType > | The HoeffdingTree object represents all of the necessary information for a Hoeffding-bound-based decision tree |
CHoeffdingTreeModel | This class is a serializable Hoeffding tree model that can hold four different types of Hoeffding trees |
CHyperplaneBase< BoundT, ProjVectorT > | HyperplaneBase defines a splitting hyperplane based on a projection vector and projection value |
CInformationGain | The standard information gain criterion, used for calculating gain in decision trees |
CIsSpillTree< TreeType > | |
CIsSpillTree< tree::SpillTree< MetricType, StatisticType, MatType, HyperplaneType, SplitType > > | |
CMeanSpaceSplit< MetricType, MatType > | |
CMeanSplit< BoundType, MatType > | A binary space partitioning tree node is split into its left and right child |
CMeanSplit< BoundType, MatType >::SplitInfo | An information about the partition |
CMidpointSpaceSplit< MetricType, MatType > | |
CMidpointSplit< BoundType, MatType > | A binary space partitioning tree node is split into its left and right child |
CMidpointSplit< BoundType, MatType >::SplitInfo | A struct that contains an information about the split |
CMinimalCoverageSweep< SplitPolicy > | The MinimalCoverageSweep class finds a partition along which we can split a node according to the coverage of two resulting nodes |
CMinimalCoverageSweep< SplitPolicy >::SweepCost< TreeType > | A struct that provides the type of the sweep cost |
CMinimalSplitsNumberSweep< SplitPolicy > | The MinimalSplitsNumberSweep class finds a partition along which we can split a node according to the number of required splits of the node |
CMinimalSplitsNumberSweep< SplitPolicy >::SweepCost< typename > | A struct that provides the type of the sweep cost |
CMultipleRandomDimensionSelect | This dimension selection policy allows the selection from a few random dimensions |
CNoAuxiliaryInformation< TreeType > | |
CNumericSplitInfo< ObservationType > | |
COctree< MetricType, StatisticType, MatType > | |
COctree< MetricType, StatisticType, MatType >::DualTreeTraverser< MetricType, StatisticType, MatType > | A dual-tree traverser; see dual_tree_traverser.hpp |
COctree< MetricType, StatisticType, MatType >::SingleTreeTraverser< RuleType > | A single-tree traverser; see single_tree_traverser.hpp |
COctree< MetricType, StatisticType, MatType >::SplitType::SplitInfo | |
CProjVector | ProjVector defines a general projection vector (not necessarily axis-parallel) |
CQueueFrame< TreeType, TraversalInfoType > | |
CRandomDimensionSelect | This dimension selection policy only selects one single random dimension |
CRandomForest< FitnessFunction, DimensionSelectionType, NumericSplitType, CategoricalSplitType, ElemType > | |
CRectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType > | A rectangle type tree tree, such as an R-tree or X-tree |
CRectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >::DualTreeTraverser< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType > | A dual tree traverser for rectangle type trees |
CRectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >::SingleTreeTraverser< RuleType > | A single traverser for rectangle type trees |
CRPlusPlusTreeAuxiliaryInformation< TreeType > | |
CRPlusPlusTreeDescentHeuristic | |
CRPlusPlusTreeSplitPolicy | The RPlusPlusTreeSplitPolicy helps to determine the subtree into which we should insert a child of an intermediate node that is being split |
CRPlusTreeDescentHeuristic | |
CRPlusTreeSplit< SplitPolicyType, SweepType > | The RPlusTreeSplit class performs the split process of a node on overflow |
CRPlusTreeSplitPolicy | The RPlusPlusTreeSplitPolicy helps to determine the subtree into which we should insert a child of an intermediate node that is being split |
CRPTreeMaxSplit< BoundType, MatType > | This class splits a node by a random hyperplane |
CRPTreeMaxSplit< BoundType, MatType >::SplitInfo | An information about the partition |
CRPTreeMeanSplit< BoundType, MatType > | This class splits a binary space tree |
CRPTreeMeanSplit< BoundType, MatType >::SplitInfo | An information about the partition |
CRStarTreeDescentHeuristic | When 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 |
CRStarTreeSplit | A Rectangle Tree has new points inserted at the bottom |
CRTreeDescentHeuristic | When 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 |
CRTreeSplit | A Rectangle Tree has new points inserted at the bottom |
CSpaceSplit< MetricType, MatType > | |
CSpillTree< 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 |
CSpillTree< 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 |
CSpillTree< 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 |
CTraversalInfo< TreeType > | The TraversalInfo class holds traversal information which is used in dual-tree (and single-tree) traversals |
CTreeTraits< TreeType > | The TreeTraits class provides compile-time information on the characteristics of a given tree type |
CTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, bound::BallBound, SplitType > > | This is a specialization of the TreeType class to the BallTree tree type |
CTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, bound::CellBound, SplitType > > | This is a specialization of the TreeType class to the UBTree tree type |
CTreeTraits< 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) |
CTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, RPTreeMaxSplit > > | This is a specialization of the TreeType class to the max-split random projection tree |
CTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, RPTreeMeanSplit > > | This is a specialization of the TreeType class to the mean-split random projection tree |
CTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType > > | This is a specialization of the TreeTraits class to the BinarySpaceTree tree type |
CTreeTraits< CoverTree< MetricType, StatisticType, MatType, RootPointPolicy > > | The specialization of the TreeTraits class for the CoverTree tree type |
CTreeTraits< Octree< MetricType, StatisticType, MatType > > | This is a specialization of the TreeTraits class to the Octree tree type |
CTreeTraits< 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 |
CTreeTraits< RectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType > > | This is a specialization of the TreeType class to the RectangleTree tree type |
CTreeTraits< SpillTree< MetricType, StatisticType, MatType, HyperplaneType, SplitType > > | This is a specialization of the TreeType class to the SpillTree tree type |
CUBTreeSplit< BoundType, MatType > | Split a node into two parts according to the median address of points contained in the node |
CVantagePointSplit< BoundType, MatType, MaxNumSamples > | The class splits a binary space partitioning tree node according to the median distance to the vantage point |
CVantagePointSplit< BoundType, MatType, MaxNumSamples >::SplitInfo | A struct that contains an information about the split |
CXTreeAuxiliaryInformation< TreeType > | The XTreeAuxiliaryInformation class provides information specific to X trees for each node in a RectangleTree |
CXTreeAuxiliaryInformation< TreeType >::SplitHistoryStruct | The X tree requires that the tree records it's "split history" |
CXTreeSplit | A Rectangle Tree has new points inserted at the bottom |
CBindingDetails | This structure holds all of the information about bindings documentation |
CExample | |
CIsStdVector< T > | Metaprogramming structure for vector detection |
CIsStdVector< std::vector< T, A > > | Metaprogramming structure for vector detection |
CLongDescription | |
CNullOutStream | Used for Log::Debug when not compiled with debugging symbols |
CParamData | This structure holds all of the information about a single parameter, including its value (which is set when ParseCommandLine() is called) |
CPrefixedOutStream | Allows 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 |
CProgramName | |
CSeeAlso | |
CShortDescription | |
CNeighborSearch< neighbor::NearestNeighborSort, metric::LMetric< TPower, true > > | |
►CNeighborSearchStat< neighbor::NearestNeighborSort > | |
CDualTreeKMeansStatistic | |
CSequential<> | |
►Ctrue_type | |
CSigCheck< U, U > | Utility struct for checking signatures |
►CTrainFormBase4< PT, void, const MT &, const PT & > | |
CTrainForm< MT, PT, void, false, false > | |
►CTrainFormBase5< PT, void, const MT &, const data::DatasetInfo &, const PT & > | |
CTrainForm< MT, PT, void, true, false > | |
►CTrainFormBase5< PT, void, const MT &, const PT &, const size_t > | |
CTrainForm< MT, PT, void, false, true > | |
►CTrainFormBase5< PT, WT, const MT &, const PT &, const WT & > | |
CTrainForm< MT, PT, WT, false, false > | |
►CTrainFormBase6< PT, void, const MT &, const data::DatasetInfo &, const PT &, const size_t > | |
CTrainForm< MT, PT, void, true, true > | |
►CTrainFormBase6< PT, WT, const MT &, const data::DatasetInfo &, const PT &, const WT & > | |
CTrainForm< MT, PT, WT, true, false > | |
►CTrainFormBase6< PT, WT, const MT &, const PT &, const size_t, const WT & > | |
CTrainForm< MT, PT, WT, false, true > | |
►CTrainFormBase7< PT, WT, const MT &, const data::DatasetInfo &, const PT &, const size_t, const WT & > | |
CTrainForm< MT, PT, WT, true, true > | |
CTrainHMMModel | |